diff --git a/APP_Framework/Applications/connection_app/Kconfig b/APP_Framework/Applications/connection_app/Kconfig index 95563d5c..338c7b38 100755 --- a/APP_Framework/Applications/connection_app/Kconfig +++ b/APP_Framework/Applications/connection_app/Kconfig @@ -1,3 +1,7 @@ menu "connection app" + menuconfig APPLICATION_CONNECTION + bool "Using connection apps" + default n + endmenu diff --git a/APP_Framework/Applications/connection_app/Makefile b/APP_Framework/Applications/connection_app/Makefile index 5948fa6f..cb4403cd 100755 --- a/APP_Framework/Applications/connection_app/Makefile +++ b/APP_Framework/Applications/connection_app/Makefile @@ -1,3 +1,7 @@ SRC_DIR := +ifeq ($(CONFIG_RESOURCES_LWIP),y) + SRC_DIR += socket_demo +endif + include $(KERNEL_ROOT)/compiler.mk \ No newline at end of file diff --git a/APP_Framework/Applications/connection_app/socket_demo/Makefile b/APP_Framework/Applications/connection_app/socket_demo/Makefile new file mode 100755 index 00000000..22a13f97 --- /dev/null +++ b/APP_Framework/Applications/connection_app/socket_demo/Makefile @@ -0,0 +1,3 @@ +SRC_FILES := lwip_tcp_socket_demo.c lwip_udp_socket_demo.c + +include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c b/APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c new file mode 100755 index 00000000..08452c8e --- /dev/null +++ b/APP_Framework/Applications/connection_app/socket_demo/lwip_tcp_socket_demo.c @@ -0,0 +1,187 @@ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file tcp_echo_socket_demo.c +* @brief One UDP demo based on LwIP +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-29 +*/ +#include +#include +#include "board.h" +#include "sys_arch.h" +#include +#include "lwip/sys.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +char tcp_socket_ip[] = {192, 168, 250, 252}; + +#define TCP_BUF_SIZE 1024 + +/******************************************************************************* + * Code + ******************************************************************************/ + +static void tcp_recv_demo(void *arg) +{ + lw_print("tcp_recv_demo start.\n"); + + int fd = -1; + char *recv_buf; + struct sockaddr_in tcp_addr, server_addr; + int recv_len; + socklen_t addr_len; + + while(1) + { + recv_buf = (char *)malloc(TCP_BUF_SIZE); + if (recv_buf == NULL) + { + lw_print("No memory\n"); + goto __exit; + } + + fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) + { + lw_print("Socket error\n"); + goto __exit; + } + + tcp_addr.sin_family = AF_INET; + tcp_addr.sin_addr.s_addr = INADDR_ANY; + tcp_addr.sin_port = htons(LOCAL_PORT_SERVER); + memset(&(tcp_addr.sin_zero), 0, sizeof(tcp_addr.sin_zero)); + + if (bind(fd, (struct sockaddr *)&tcp_addr, sizeof(struct sockaddr)) == -1) + { + lw_print("Unable to bind\n"); + goto __exit; + } + + lw_print("tcp bind sucess, start to receive.\n"); + lw_print("\n\nLocal Port:%d\n\n", LOCAL_PORT_SERVER); + + while(1) + { + memset(recv_buf, 0, TCP_BUF_SIZE); + recv_len = recvfrom(fd, recv_buf, TCP_BUF_SIZE, 0, (struct sockaddr *)&server_addr, &addr_len); + lw_pr_info("Receive from : %s\n", inet_ntoa(server_addr.sin_addr)); + lw_pr_info("Receive data : %s\n\n", recv_buf); + sendto(fd, recv_buf, recv_len, 0, (struct sockaddr*)&server_addr, addr_len); + } + + __exit: + if (fd >= 0) + closesocket(fd); + + if (recv_buf) + free(recv_buf); + } +} + +void tcp_socket_recv_run(int argc, char *argv[]) +{ + int result = 0; + pthread_t th_id; + pthread_attr_t attr; + + if(argc == 2) + { + lw_print("lw: [%s] gw %s\n", __func__, argv[1]); + sscanf(argv[1], "%d.%d.%d.%d", &tcp_socket_ip[0], &tcp_socket_ip[1], &tcp_socket_ip[2], &tcp_socket_ip[3]); + } + + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + sys_thread_new("tcp_recv_demo", tcp_recv_demo, NULL, 4096, 15); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + TCPSocketRecv, tcp_socket_recv_run, TCP recv echo); + +static void tcp_send_demo(void *arg) +{ + int cnt = TEST_LWIP_TIMES; + lw_print("tcp_send_demo start.\n"); + int fd = -1; + char send_msg[128]; + + memset(send_msg, 0, sizeof(send_msg)); + fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) + { + lw_print("Socket error\n"); + goto __exit; + } + + struct sockaddr_in tcp_sock; + tcp_sock.sin_family = AF_INET; + tcp_sock.sin_port = htons(TARGET_PORT_CLIENT); + tcp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(tcp_socket_ip[0],tcp_socket_ip[1],tcp_socket_ip[2],tcp_socket_ip[3])); + memset(&(tcp_sock.sin_zero), 0, sizeof(tcp_sock.sin_zero)); + + if (connect(fd, (struct sockaddr *)&tcp_sock, sizeof(struct sockaddr))) + { + lw_print("Unable to connect\n"); + goto __exit; + } + + lw_print("tcp connect success, start to send.\n"); + lw_print("\n\nTarget Port:%d\n\n", tcp_sock.sin_port); + + while (cnt --) + { + lw_print("Lwip client is running.\n"); + snprintf(send_msg, sizeof(send_msg), "TCP test package times %d\r\n", cnt); + sendto(fd, send_msg, strlen(send_msg), 0, (struct sockaddr*)&tcp_sock, sizeof(struct sockaddr)); + lw_print("Send tcp msg: %s ", send_msg); + MdelayKTask(1000); + } + +__exit: + if (fd >= 0) + closesocket(fd); + + return; +} + + +void tcp_socket_send_run(int argc, char *argv[]) +{ + if(argc == 2) + { + lw_print("lw: [%s] gw %s\n", __func__, argv[1]); + sscanf(argv[1], "%d.%d.%d.%d", &tcp_socket_ip[0], &tcp_socket_ip[1], &tcp_socket_ip[2], &tcp_socket_ip[3]); + } + + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + sys_thread_new("tcp socket", tcp_send_demo, NULL, 4096, 25); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), + TCPSocketSend, tcp_socket_send_run, TCP send demo); + diff --git a/APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c b/APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c new file mode 100755 index 00000000..3f71783a --- /dev/null +++ b/APP_Framework/Applications/connection_app/socket_demo/lwip_udp_socket_demo.c @@ -0,0 +1,209 @@ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file lwip_udp_socket_demo.c +* @brief One UDP demo based on LwIP +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-29 +*/ +#include +#include +#include "board.h" +#include "sys_arch.h" +#include "lwip/udp.h" +#include "lwip/opt.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ +extern char udp_target[]; +static struct udp_pcb *udpecho_raw_pcb; +char udp_socket_ip[] = {192, 168, 250, 252}; + +/******************************************************************************* + * Code + ******************************************************************************/ + +#include +#include "lwip/sys.h" + +#define LWIP_UDP_TASK_STACK 4096 +#define LWIP_UDP_TASK_PRIO 25 +#define UDP_BUF_SIZE 1024 + +static void udp_recv_demo(void *arg) +{ + lw_print("udp_recv_demo start.\n"); + + int socket_fd = -1; + char *recv_buf; + struct sockaddr_in udp_addr, server_addr; + int recv_len; + socklen_t addr_len; + + while(1) + { + recv_buf = (char *)malloc(UDP_BUF_SIZE); + if (recv_buf == NULL) + { + lw_print("No memory\n"); + goto __exit; + } + + socket_fd = socket(AF_INET, SOCK_DGRAM, 0); + if (socket_fd < 0) + { + lw_print("Socket error\n"); + goto __exit; + } + + udp_addr.sin_family = AF_INET; + udp_addr.sin_addr.s_addr = INADDR_ANY; + udp_addr.sin_port = htons(LOCAL_PORT_SERVER); + memset(&(udp_addr.sin_zero), 0, sizeof(udp_addr.sin_zero)); + + if (bind(socket_fd, (struct sockaddr *)&udp_addr, sizeof(struct sockaddr)) == -1) + { + lw_print("Unable to bind\n"); + goto __exit; + } + + lw_print("UDP bind sucess, start to receive.\n"); + lw_print("\n\nLocal Port:%d\n\n", LOCAL_PORT_SERVER); + + while(1) + { + memset(recv_buf, 0, UDP_BUF_SIZE); + recv_len = recvfrom(socket_fd, recv_buf, UDP_BUF_SIZE, 0, (struct sockaddr *)&server_addr, &addr_len); + lw_print("Receive from : %s\n", inet_ntoa(server_addr.sin_addr)); + lw_print("Receive data : %s\n\n", recv_buf); + sendto(socket_fd, recv_buf, recv_len, 0, (struct sockaddr*)&server_addr, addr_len); + } + + __exit: + if (socket_fd >= 0) + closesocket(socket_fd); + + if (recv_buf) + free(recv_buf); + } +} + +static void udp_recv_demo_thread(void* param) +{ + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + sys_thread_new("udp_recv_demo", udp_recv_demo, NULL, LWIP_UDP_TASK_STACK, LWIP_UDP_TASK_PRIO); +} + +void udp_socket_recv_run(int argc, char *argv[]) +{ + int result = 0; + pthread_t th_id; + pthread_attr_t attr; + + if(argc == 2) + { + lw_print("lw: [%s] gw %s\n", __func__, argv[1]); + sscanf(argv[1], "%d.%d.%d.%d", &udp_socket_ip[0], &udp_socket_ip[1], &udp_socket_ip[2], &udp_socket_ip[3]); + } + + sys_thread_new("udp socket send", udp_recv_demo_thread, NULL, 4096, 15); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + UDPSocketRecv, udp_socket_recv_run, UDP recv echo); + +static void udp_send_demo(void *arg) +{ + int cnt = TEST_LWIP_TIMES; + char send_str[128]; + + lw_print("udp_send_demo start.\n"); + + int socket_fd = -1; + memset(send_str, 0, sizeof(send_str)); + + socket_fd = socket(AF_INET, SOCK_DGRAM, 0); + if (socket_fd < 0) + { + lw_print("Socket error\n"); + goto __exit; + } + + struct sockaddr_in udp_sock; + udp_sock.sin_family = AF_INET; + udp_sock.sin_port = htons(TARGET_PORT_CLIENT); + udp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(udp_target[0],udp_target[1],udp_target[2],udp_target[3])); + memset(&(udp_sock.sin_zero), 0, sizeof(udp_sock.sin_zero)); + + if (connect(socket_fd, (struct sockaddr *)&udp_sock, sizeof(struct sockaddr))) + { + lw_print("Unable to connect\n"); + goto __exit; + } + + lw_print("UDP connect success, start to send.\n"); + lw_print("\n\nTarget Port:%d\n\n", udp_sock.sin_port); + + while (cnt --) + { + snprintf(send_str, sizeof(send_str), "UDP test package times %d\r\n", cnt); + sendto(socket_fd, send_str, strlen(send_str), 0, (struct sockaddr*)&udp_sock, sizeof(struct sockaddr)); + lw_pr_info("Send UDP msg: %s ", send_str); + MdelayKTask(1000); + } + +__exit: + if (socket_fd >= 0) + { + closesocket(socket_fd); + } + + return; +} + +static void udp_send_demo_thread(void* param) +{ + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + sys_thread_new("udp_send_demo", udp_send_demo, NULL, LWIP_UDP_TASK_STACK, LWIP_UDP_TASK_PRIO); +} + +void udp_socket_send_run(int argc, char *argv[]) +{ + int result = 0; + pthread_t th_id; + pthread_attr_t attr; + + if(argc == 2) + { + lw_print("lw: [%s] gw %s\n", __func__, argv[1]); + sscanf(argv[1], "%d.%d.%d.%d", &udp_socket_ip[0], &udp_socket_ip[1], &udp_socket_ip[2], &udp_socket_ip[3]); + } + + sys_thread_new("udp socket send", udp_send_demo_thread, NULL, 4096, 15); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + UDPSocketSend, udp_socket_send_run, UDP send echo); + diff --git a/APP_Framework/Applications/control_app/Kconfig b/APP_Framework/Applications/control_app/Kconfig index 6128642c..02ddbf10 100755 --- a/APP_Framework/Applications/control_app/Kconfig +++ b/APP_Framework/Applications/control_app/Kconfig @@ -3,6 +3,7 @@ menu "control app" menuconfig APPLICATION_CONTROL bool "Using control apps" default n + depends on SUPPORT_CONTROL_FRAMEWORK endmenu diff --git a/APP_Framework/Applications/control_app/Makefile b/APP_Framework/Applications/control_app/Makefile index e69de29b..e321906d 100755 --- a/APP_Framework/Applications/control_app/Makefile +++ b/APP_Framework/Applications/control_app/Makefile @@ -0,0 +1,11 @@ +SRC_DIR := + +ifeq ($(CONFIG_RESOURCES_LWIP),y) + +ifeq ($(CONFIG_USING_CONTROL_PLC_OPCUA), y) + SRC_DIR += opcua_demo +endif + +endif + +include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Applications/control_app/opcua_demo/Makefile b/APP_Framework/Applications/control_app/opcua_demo/Makefile new file mode 100755 index 00000000..b595ed06 --- /dev/null +++ b/APP_Framework/Applications/control_app/opcua_demo/Makefile @@ -0,0 +1,3 @@ +SRC_FILES :=opcua_demo.c + +include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Applications/control_app/opcua_demo/opcua_demo.c b/APP_Framework/Applications/control_app/opcua_demo/opcua_demo.c new file mode 100755 index 00000000..76634b9d --- /dev/null +++ b/APP_Framework/Applications/control_app/opcua_demo/opcua_demo.c @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file ua_demo.c + * @brief Demo for OpcUa function + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#include +#include +#include "board.h" +#include +#include "open62541.h" +#include "ua_api.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ +//#define ua_print KPrintf +#define ua_trace() KPrintf("ua: [%s] %d pass!\n", __func__, __LINE__) + +#define TCP_LOCAL_PORT 4840 + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +const char *test_uri = "opc.tcp://192.168.250.5:4840"; +const char *test_cb_str = "tcp client connected\r\n"; + +char test_ua_gw[] = {192, 168, 250, 5}; + +static pthread_t eth_input_id = 0; +static pthread_t ua_demo_id; + +/******************************************************************************* + * Code + ******************************************************************************/ + +void *test_ua_get_server_info(void *param); + +static void test_ua_connect(void *arg) +{ + struct netif net; + UA_StatusCode retval; + + UA_Client *client = UA_Client_new(); + + if (client == NULL) + { + ua_print("ua: [%s] tcp client null\n", __func__); + return; + } + + UA_ClientConfig *config = UA_Client_getConfig(client); + UA_ClientConfig_setDefault(config); + + retval = UA_Client_connect(client, test_uri); + if (retval != UA_STATUSCODE_GOOD) + { + ua_print("ua: [%s] ret %x\n", __func__, retval); + } + + ua_print("ua: [%s] start Ua Test!\n", __func__); + UA_Client_disconnect(client); + UA_Client_delete(client); +} + +void test_ua_connect_thr(void *arg) +{ + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, test_ua_gw); + test_ua_connect(NULL); +} + +void test_sh_ua_connect(void) +{ + int result = 0; + pthread_t th_id; + pthread_attr_t attr; + sys_thread_new("ua test", test_ua_connect_thr, NULL, 4096, 15); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), + UaConnect, test_sh_ua_connect, Test Opc UA connection); + +void *test_ua_get_server_info(void *param) +{ + UA_Client *client = UA_Client_new(); + + ua_print("ua: [%s] start ...\n", __func__); + + if (client == NULL) + { + ua_print("ua: [%s] tcp client null\n", __func__); + return NULL; + } + + UA_ClientConfig *config = UA_Client_getConfig(client); + UA_ClientConfig_setDefault(config); + + UA_StatusCode retval = UA_Client_connect(client, OPC_SERVER); + if(retval != UA_STATUSCODE_GOOD) { + ua_print("ua: [%s] connect failed %#x\n", __func__, retval); + UA_Client_delete(client); + return NULL; + } + + ua_print("ua: [%s] connect ok!\n", __func__); + + ua_read_time(client); + ua_get_server_info(client); + + /* Clean up */ + UA_Client_disconnect(client); + UA_Client_delete(client); /* Disconnects the client internally */ +} + +void *test_ua_get_server_info_thr(void *arg) +{ + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, test_ua_gw); + test_ua_get_server_info(NULL); +} + +void *test_sh_ua_get_server_info(void *param) +{ + int result = 0; + pthread_attr_t attr; + + attr.schedparam.sched_priority = 15; + attr.stacksize = 4096; + + result = pthread_create(&ua_demo_id, &attr, test_ua_get_server_info_thr, NULL); + if (0 == result) { + lw_print("test_ua_get_server_info %d successfully!\n", __func__, ua_demo_id); + } else { + lw_print("test_ua_get_server_info failed! error code is %d\n", __func__, result); + } +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), + UaGetInfo, test_sh_ua_get_server_info, Get information from OpcUA server); + diff --git a/APP_Framework/Framework/control/Kconfig b/APP_Framework/Framework/control/Kconfig index 3ac0ef89..9a4f5e4b 100755 --- a/APP_Framework/Framework/control/Kconfig +++ b/APP_Framework/Framework/control/Kconfig @@ -1,4 +1,8 @@ menuconfig SUPPORT_CONTROL_FRAMEWORK bool "support control framework" default n - select TRANSFORM_LAYER_ATTRIUBUTE \ No newline at end of file + select TRANSFORM_LAYER_ATTRIUBUTE + +if SUPPORT_CONTROL_FRAMEWORK + source "$APP_DIR/Framework/control/plc/interoperability/Kconfig" +endif diff --git a/APP_Framework/Framework/control/Makefile b/APP_Framework/Framework/control/Makefile index f75f2e60..3b00b033 100755 --- a/APP_Framework/Framework/control/Makefile +++ b/APP_Framework/Framework/control/Makefile @@ -1,3 +1,3 @@ -SRC_DIR := +SRC_DIR := shared plc include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Framework/control/plc/Makefile b/APP_Framework/Framework/control/plc/Makefile new file mode 100755 index 00000000..6c76af19 --- /dev/null +++ b/APP_Framework/Framework/control/plc/Makefile @@ -0,0 +1,4 @@ +SRC_DIR := shared interoperability + +include $(KERNEL_ROOT)/compiler.mk + diff --git a/APP_Framework/Framework/control/plc/interoperability/Kconfig b/APP_Framework/Framework/control/plc/interoperability/Kconfig new file mode 100755 index 00000000..66ae5f18 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/Kconfig @@ -0,0 +1,6 @@ + +menuconfig USING_CONTROL_PLC_OPCUA + bool "PLC support OPCUA" + default y + depends on RESOURCES_LWIP + diff --git a/APP_Framework/Framework/control/plc/interoperability/Makefile b/APP_Framework/Framework/control/plc/interoperability/Makefile new file mode 100755 index 00000000..7f542f71 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/Makefile @@ -0,0 +1,13 @@ +SRC_DIR := + +ifeq ($(CONFIG_RESOURCES_LWIP),y) + +ifeq ($(CONFIG_USING_CONTROL_PLC_OPCUA), y) + SRC_DIR += opcua +endif + +endif + +SRC_FILES += interoperability.c + +include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Framework/control/plc/interoperability/interoperability.c b/APP_Framework/Framework/control/plc/interoperability/interoperability.c new file mode 100755 index 00000000..74c46fad --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/interoperability.c @@ -0,0 +1,30 @@ +/* +* Copyright (c) 2021 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + + +void ctrl_interop_init(void) +{ +} + +void ctrl_interop_connect(void) +{ +} + +void ctrl_interop_enable(void) +{ +} + +void ctrl_interop_disable(void) +{ +} + + diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/Kconfig b/APP_Framework/Framework/control/plc/interoperability/opcua/Kconfig new file mode 100755 index 00000000..e69de29b diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/Makefile b/APP_Framework/Framework/control/plc/interoperability/opcua/Makefile new file mode 100755 index 00000000..531b181e --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/Makefile @@ -0,0 +1,3 @@ +SRC_FILES := ua_data.c open62541.c ua_client.c ua_server.c + +include $(KERNEL_ROOT)/compiler.mk diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.c b/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.c new file mode 100755 index 00000000..961f243a --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.c @@ -0,0 +1,71784 @@ +/* THIS IS A SINGLE-FILE DISTRIBUTION CONCATENATED FROM THE OPEN62541 SOURCES + * visit http://open62541.org/ for information about this software + * Git-Revision: v1.2.2-506-g998e2523-dirty + */ + +/* + * Copyright (C) 2014-2021 the contributors as stated in the AUTHORS file + * + * This file is part of open62541. open62541 is free software: you can + * redistribute it and/or modify it under the terms of the Mozilla Public + * License v2.0 as stated in the LICENSE file provided with open62541. + * + * open62541 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. + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file open62541.c + * @brief Support OPCUA protocol + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.12.15 + */ + +#ifndef UA_DYNAMIC_LINKING_EXPORT +# define UA_DYNAMIC_LINKING_EXPORT +# define MDNSD_DYNAMIC_LINKING +#endif + +/* Disable security warnings for BSD sockets on MSVC */ +#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS) +# define _CRT_SECURE_NO_WARNINGS +#endif + +#include "open62541.h" + +#define ua_print KPrintf +#define ua_trace() KPrintf("ua: [%s] line %d checked!\n", __func__, __LINE__) + +#if LWIP_DNS + +#else + +/* input flags for struct addrinfo */ +#define AI_PASSIVE 0x01 +#define AI_CANONNAME 0x02 +#define AI_NUMERICHOST 0x04 +#define AI_NUMERICSERV 0x08 +#define AI_V4MAPPED 0x10 +#define AI_ALL 0x20 +#define AI_ADDRCONFIG 0x40 + +struct addrinfo { + int ai_flags; /* Input flags. */ + int ai_family; /* Address family of socket. */ + int ai_socktype; /* Socket type. */ + int ai_protocol; /* Protocol of socket. */ + socklen_t ai_addrlen; /* Length of socket address. */ + struct sockaddr *ai_addr; /* Socket address of socket. */ + char *ai_canonname; /* Canonical name of service location. */ + struct addrinfo *ai_next; /* Pointer to next in list. */ +}; + +#endif + +/**** amalgamated original file "/deps/open62541_queue.h" ****/ + +/* $OpenBSD: queue.h,v 1.38 2013/07/03 15:05:21 fgsch Exp $ */ +/* $NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $ */ + +/* + * Copyright (c) 1991, 1993 + * The Regents of the University of California. 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 University 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 REGENTS 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 REGENTS 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. + * + * @(#)queue.h 8.5 (Berkeley) 8/20/94 + */ + + +/* + * This file defines five types of data structures: singly-linked lists, + * lists, simple queues, tail queues, and circular queues. + * + * + * A singly-linked list is headed by a single forward pointer. The elements + * are singly linked for minimum space and pointer manipulation overhead at + * the expense of O(n) removal for arbitrary elements. New elements can be + * added to the list after an existing element or at the head of the list. + * Elements being removed from the head of the list should use the explicit + * macro for this purpose for optimum efficiency. A singly-linked list may + * only be traversed in the forward direction. Singly-linked lists are ideal + * for applications with large datasets and few or no removals or for + * implementing a LIFO queue. + * + * A list is headed by a single forward pointer (or an array of forward + * pointers for a hash table header). The elements are doubly linked + * so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before + * or after an existing element or at the head of the list. A list + * may only be traversed in the forward direction. + * + * A simple queue is headed by a pair of pointers, one the head of the + * list and the other to the tail of the list. The elements are singly + * linked to save space, so elements can only be removed from the + * head of the list. New elements can be added to the list before or after + * an existing element, at the head of the list, or at the end of the + * list. A simple queue may only be traversed in the forward direction. + * + * A tail queue is headed by a pair of pointers, one to the head of the + * list and the other to the tail of the list. The elements are doubly + * linked so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before or + * after an existing element, at the head of the list, or at the end of + * the list. A tail queue may be traversed in either direction. + * + * A circle queue is headed by a pair of pointers, one to the head of the + * list and the other to the tail of the list. The elements are doubly + * linked so that an arbitrary element can be removed without a need to + * traverse the list. New elements can be added to the list before or after + * an existing element, at the head of the list, or at the end of the list. + * A circle queue may be traversed in either direction, but has a more + * complex end of list detection. + * + * For details on the use of these macros, see the queue(3) manual page. + */ + +#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC)) +#define _Q_INVALIDATE(a) (a) = ((void *)-1) +#else +#define _Q_INVALIDATE(a) +#endif + +/* + * Singly-linked List definitions. + */ +#define SLIST_HEAD(name, type) \ +struct name { \ + struct type *slh_first; /* first element */ \ +} + +#define SLIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define SLIST_ENTRY(type) \ +struct { \ + struct type *sle_next; /* next element */ \ +} + +/* + * Singly-linked List access methods. + */ +#define SLIST_FIRST(head) ((head)->slh_first) +#define SLIST_END(head) NULL +#define SLIST_EMPTY(head) (SLIST_FIRST(head) == SLIST_END(head)) +#define SLIST_NEXT(elm, field) ((elm)->field.sle_next) + +#define SLIST_FOREACH(var, head, field) \ + for((var) = SLIST_FIRST(head); \ + (var) != SLIST_END(head); \ + (var) = SLIST_NEXT(var, field)) + +#define SLIST_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = SLIST_FIRST(head); \ + (var) && ((tvar) = SLIST_NEXT(var, field), 1); \ + (var) = (tvar)) + +/* + * Singly-linked List functions. + */ +#define SLIST_INIT(head) do { \ + SLIST_FIRST(head) = SLIST_END(head); \ +} while(0) + +#define SLIST_INSERT_AFTER(slistelm, elm, field) do { \ + (elm)->field.sle_next = (slistelm)->field.sle_next; \ + (slistelm)->field.sle_next = (elm); \ +} while (0) + +#define SLIST_INSERT_HEAD(head, elm, field) do { \ + (elm)->field.sle_next = (head)->slh_first; \ + (head)->slh_first = (elm); \ +} while (0) + +#define SLIST_REMOVE_AFTER(elm, field) do { \ + (elm)->field.sle_next = (elm)->field.sle_next->field.sle_next; \ +} while (0) + +#define SLIST_REMOVE_HEAD(head, field) do { \ + (head)->slh_first = (head)->slh_first->field.sle_next; \ +} while (0) + +#define SLIST_REMOVE(head, elm, type, field) do { \ + if ((head)->slh_first == (elm)) { \ + SLIST_REMOVE_HEAD((head), field); \ + } else { \ + struct type *curelm = (head)->slh_first; \ + \ + while (curelm->field.sle_next != (elm)) \ + curelm = curelm->field.sle_next; \ + curelm->field.sle_next = \ + curelm->field.sle_next->field.sle_next; \ + _Q_INVALIDATE((elm)->field.sle_next); \ + } \ +} while (0) + +/* + * List definitions. + */ +#define LIST_HEAD(name, type) \ +struct name { \ + struct type *lh_first; /* first element */ \ +} + +#define LIST_HEAD_INITIALIZER(head) \ + { NULL } + +#define LIST_ENTRY(type) \ +struct { \ + struct type *le_next; /* next element */ \ + struct type **le_prev; /* address of previous next element */ \ +} + +/* + * List access methods + */ +#define LIST_FIRST(head) ((head)->lh_first) +#define LIST_END(head) NULL +#define LIST_EMPTY(head) (LIST_FIRST(head) == LIST_END(head)) +#define LIST_NEXT(elm, field) ((elm)->field.le_next) + +#define LIST_FOREACH(var, head, field) \ + for((var) = LIST_FIRST(head); \ + (var)!= LIST_END(head); \ + (var) = LIST_NEXT(var, field)) + +#define LIST_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = LIST_FIRST(head); \ + (var) && ((tvar) = LIST_NEXT(var, field), 1); \ + (var) = (tvar)) + +/* + * List functions. + */ +#define LIST_INIT(head) do { \ + LIST_FIRST(head) = LIST_END(head); \ +} while (0) + +#define LIST_INSERT_AFTER(listelm, elm, field) do { \ + if (((elm)->field.le_next = (listelm)->field.le_next) != NULL) \ + (listelm)->field.le_next->field.le_prev = \ + &(elm)->field.le_next; \ + (listelm)->field.le_next = (elm); \ + (elm)->field.le_prev = &(listelm)->field.le_next; \ +} while (0) + +#define LIST_INSERT_BEFORE(listelm, elm, field) do { \ + (elm)->field.le_prev = (listelm)->field.le_prev; \ + (elm)->field.le_next = (listelm); \ + *(listelm)->field.le_prev = (elm); \ + (listelm)->field.le_prev = &(elm)->field.le_next; \ +} while (0) + +#define LIST_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.le_next = (head)->lh_first) != NULL) \ + (head)->lh_first->field.le_prev = &(elm)->field.le_next;\ + (head)->lh_first = (elm); \ + (elm)->field.le_prev = &(head)->lh_first; \ +} while (0) + +#define LIST_REMOVE(elm, field) do { \ + if ((elm)->field.le_next != NULL) \ + (elm)->field.le_next->field.le_prev = \ + (elm)->field.le_prev; \ + *(elm)->field.le_prev = (elm)->field.le_next; \ + _Q_INVALIDATE((elm)->field.le_prev); \ + _Q_INVALIDATE((elm)->field.le_next); \ +} while (0) + +#define LIST_REPLACE(elm, elm2, field) do { \ + if (((elm2)->field.le_next = (elm)->field.le_next) != NULL) \ + (elm2)->field.le_next->field.le_prev = \ + &(elm2)->field.le_next; \ + (elm2)->field.le_prev = (elm)->field.le_prev; \ + *(elm2)->field.le_prev = (elm2); \ + _Q_INVALIDATE((elm)->field.le_prev); \ + _Q_INVALIDATE((elm)->field.le_next); \ +} while (0) + +/* + * Simple queue definitions. + */ +#define SIMPLEQ_HEAD(name, type) \ +struct name { \ + struct type *sqh_first; /* first element */ \ + struct type **sqh_last; /* addr of last next element */ \ +} + +#define SIMPLEQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).sqh_first } + +#define SIMPLEQ_ENTRY(type) \ +struct { \ + struct type *sqe_next; /* next element */ \ +} + +/* + * Simple queue access methods. + */ +#define SIMPLEQ_FIRST(head) ((head)->sqh_first) +#define SIMPLEQ_END(head) NULL +#define SIMPLEQ_EMPTY(head) (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head)) +#define SIMPLEQ_NEXT(elm, field) ((elm)->field.sqe_next) + +#define SIMPLEQ_FOREACH(var, head, field) \ + for((var) = SIMPLEQ_FIRST(head); \ + (var) != SIMPLEQ_END(head); \ + (var) = SIMPLEQ_NEXT(var, field)) + +#define SIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = SIMPLEQ_FIRST(head); \ + (var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1); \ + (var) = (tvar)) + +/* + * Simple queue functions. + */ +#define SIMPLEQ_INIT(head) do { \ + (head)->sqh_first = NULL; \ + (head)->sqh_last = &(head)->sqh_first; \ +} while (0) + +#define SIMPLEQ_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.sqe_next = (head)->sqh_first) == NULL) \ + (head)->sqh_last = &(elm)->field.sqe_next; \ + (head)->sqh_first = (elm); \ +} while (0) + +#define SIMPLEQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.sqe_next = NULL; \ + *(head)->sqh_last = (elm); \ + (head)->sqh_last = &(elm)->field.sqe_next; \ +} while (0) + +#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ + if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\ + (head)->sqh_last = &(elm)->field.sqe_next; \ + (listelm)->field.sqe_next = (elm); \ +} while (0) + +#define SIMPLEQ_REMOVE_HEAD(head, field) do { \ + if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \ + (head)->sqh_last = &(head)->sqh_first; \ +} while (0) + +#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ + if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \ + == NULL) \ + (head)->sqh_last = &(elm)->field.sqe_next; \ +} while (0) + +/* + * XOR Simple queue definitions. + */ +#define XSIMPLEQ_HEAD(name, type) \ +struct name { \ + struct type *sqx_first; /* first element */ \ + struct type **sqx_last; /* addr of last next element */ \ + unsigned long sqx_cookie; \ +} + +#define XSIMPLEQ_ENTRY(type) \ +struct { \ + struct type *sqx_next; /* next element */ \ +} + +/* + * XOR Simple queue access methods. + */ +#define XSIMPLEQ_XOR(head, ptr) ((__typeof(ptr))((head)->sqx_cookie ^ \ + (unsigned long)(ptr))) +#define XSIMPLEQ_FIRST(head) XSIMPLEQ_XOR(head, ((head)->sqx_first)) +#define XSIMPLEQ_END(head) NULL +#define XSIMPLEQ_EMPTY(head) (XSIMPLEQ_FIRST(head) == XSIMPLEQ_END(head)) +#define XSIMPLEQ_NEXT(head, elm, field) XSIMPLEQ_XOR(head, ((elm)->field.sqx_next)) + + +#define XSIMPLEQ_FOREACH(var, head, field) \ + for ((var) = XSIMPLEQ_FIRST(head); \ + (var) != XSIMPLEQ_END(head); \ + (var) = XSIMPLEQ_NEXT(head, var, field)) + +#define XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = XSIMPLEQ_FIRST(head); \ + (var) && ((tvar) = XSIMPLEQ_NEXT(head, var, field), 1); \ + (var) = (tvar)) + +/* + * XOR Simple queue functions. + */ +#define XSIMPLEQ_INIT(head) do { \ + arc4random_buf(&(head)->sqx_cookie, sizeof((head)->sqx_cookie)); \ + (head)->sqx_first = XSIMPLEQ_XOR(head, NULL); \ + (head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \ +} while (0) + +#define XSIMPLEQ_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.sqx_next = (head)->sqx_first) == \ + XSIMPLEQ_XOR(head, NULL)) \ + (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ + (head)->sqx_first = XSIMPLEQ_XOR(head, (elm)); \ +} while (0) + +#define XSIMPLEQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.sqx_next = XSIMPLEQ_XOR(head, NULL); \ + *(XSIMPLEQ_XOR(head, (head)->sqx_last)) = XSIMPLEQ_XOR(head, (elm)); \ + (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ +} while (0) + +#define XSIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ + if (((elm)->field.sqx_next = (listelm)->field.sqx_next) == \ + XSIMPLEQ_XOR(head, NULL)) \ + (head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ + (listelm)->field.sqx_next = XSIMPLEQ_XOR(head, (elm)); \ +} while (0) + +#define XSIMPLEQ_REMOVE_HEAD(head, field) do { \ + if (((head)->sqx_first = XSIMPLEQ_XOR(head, \ + (head)->sqx_first)->field.sqx_next) == XSIMPLEQ_XOR(head, NULL)) \ + (head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \ +} while (0) + +#define XSIMPLEQ_REMOVE_AFTER(head, elm, field) do { \ + if (((elm)->field.sqx_next = XSIMPLEQ_XOR(head, \ + (elm)->field.sqx_next)->field.sqx_next) \ + == XSIMPLEQ_XOR(head, NULL)) \ + (head)->sqx_last = \ + XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \ +} while (0) + + +/* + * Tail queue definitions. + */ +#define TAILQ_HEAD(name, type) \ +struct name { \ + struct type *tqh_first; /* first element */ \ + struct type **tqh_last; /* addr of last next element */ \ +} + +#define TAILQ_HEAD_INITIALIZER(head) \ + { NULL, &(head).tqh_first } + +#define TAILQ_ENTRY(type) \ +struct { \ + struct type *tqe_next; /* next element */ \ + struct type **tqe_prev; /* address of previous next element */ \ +} + +/* + * tail queue access methods + */ +#define TAILQ_FIRST(head) ((head)->tqh_first) +#define TAILQ_END(head) NULL +#define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) +#define TAILQ_LAST(head, headname) \ + (*(((struct headname *)((head)->tqh_last))->tqh_last)) +/* XXX */ +#define TAILQ_PREV(elm, headname, field) \ + (*(((struct headname *)((elm)->field.tqe_prev))->tqh_last)) +#define TAILQ_EMPTY(head) \ + (TAILQ_FIRST(head) == TAILQ_END(head)) + +#define TAILQ_FOREACH(var, head, field) \ + for((var) = TAILQ_FIRST(head); \ + (var) != TAILQ_END(head); \ + (var) = TAILQ_NEXT(var, field)) + +#define TAILQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = TAILQ_FIRST(head); \ + (var) != TAILQ_END(head) && \ + ((tvar) = TAILQ_NEXT(var, field), 1); \ + (var) = (tvar)) + + +#define TAILQ_FOREACH_REVERSE(var, head, headname, field) \ + for((var) = TAILQ_LAST(head, headname); \ + (var) != TAILQ_END(head); \ + (var) = TAILQ_PREV(var, headname, field)) + +#define TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ + for ((var) = TAILQ_LAST(head, headname); \ + (var) != TAILQ_END(head) && \ + ((tvar) = TAILQ_PREV(var, headname, field), 1); \ + (var) = (tvar)) + +/* + * Tail queue functions. + */ +#define TAILQ_INIT(head) do { \ + (head)->tqh_first = NULL; \ + (head)->tqh_last = &(head)->tqh_first; \ +} while (0) + +#define TAILQ_INSERT_HEAD(head, elm, field) do { \ + if (((elm)->field.tqe_next = (head)->tqh_first) != NULL) \ + (head)->tqh_first->field.tqe_prev = \ + &(elm)->field.tqe_next; \ + else \ + (head)->tqh_last = &(elm)->field.tqe_next; \ + (head)->tqh_first = (elm); \ + (elm)->field.tqe_prev = &(head)->tqh_first; \ +} while (0) + +#define TAILQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.tqe_next = NULL; \ + (elm)->field.tqe_prev = (head)->tqh_last; \ + *(head)->tqh_last = (elm); \ + (head)->tqh_last = &(elm)->field.tqe_next; \ +} while (0) + +#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do { \ + if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\ + (elm)->field.tqe_next->field.tqe_prev = \ + &(elm)->field.tqe_next; \ + else \ + (head)->tqh_last = &(elm)->field.tqe_next; \ + (listelm)->field.tqe_next = (elm); \ + (elm)->field.tqe_prev = &(listelm)->field.tqe_next; \ +} while (0) + +#define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ + (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ + (elm)->field.tqe_next = (listelm); \ + *(listelm)->field.tqe_prev = (elm); \ + (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ +} while (0) + +#define TAILQ_REMOVE(head, elm, field) do { \ + if (((elm)->field.tqe_next) != NULL) \ + (elm)->field.tqe_next->field.tqe_prev = \ + (elm)->field.tqe_prev; \ + else \ + (head)->tqh_last = (elm)->field.tqe_prev; \ + *(elm)->field.tqe_prev = (elm)->field.tqe_next; \ + _Q_INVALIDATE((elm)->field.tqe_prev); \ + _Q_INVALIDATE((elm)->field.tqe_next); \ +} while (0) + +#define TAILQ_REPLACE(head, elm, elm2, field) do { \ + if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL) \ + (elm2)->field.tqe_next->field.tqe_prev = \ + &(elm2)->field.tqe_next; \ + else \ + (head)->tqh_last = &(elm2)->field.tqe_next; \ + (elm2)->field.tqe_prev = (elm)->field.tqe_prev; \ + *(elm2)->field.tqe_prev = (elm2); \ + _Q_INVALIDATE((elm)->field.tqe_prev); \ + _Q_INVALIDATE((elm)->field.tqe_next); \ +} while (0) + +/* + * Circular queue definitions. + */ +#define CIRCLEQ_HEAD(name, type) \ +struct name { \ + struct type *cqh_first; /* first element */ \ + struct type *cqh_last; /* last element */ \ +} + +#define CIRCLEQ_HEAD_INITIALIZER(head) \ + { CIRCLEQ_END(&head), CIRCLEQ_END(&head) } + +#define CIRCLEQ_ENTRY(type) \ +struct { \ + struct type *cqe_next; /* next element */ \ + struct type *cqe_prev; /* previous element */ \ +} + +/* + * Circular queue access methods + */ +#define CIRCLEQ_FIRST(head) ((head)->cqh_first) +#define CIRCLEQ_LAST(head) ((head)->cqh_last) +#define CIRCLEQ_END(head) ((void *)(head)) +#define CIRCLEQ_NEXT(elm, field) ((elm)->field.cqe_next) +#define CIRCLEQ_PREV(elm, field) ((elm)->field.cqe_prev) +#define CIRCLEQ_EMPTY(head) \ + (CIRCLEQ_FIRST(head) == CIRCLEQ_END(head)) + +#define CIRCLEQ_FOREACH(var, head, field) \ + for((var) = CIRCLEQ_FIRST(head); \ + (var) != CIRCLEQ_END(head); \ + (var) = CIRCLEQ_NEXT(var, field)) + +#define CIRCLEQ_FOREACH_SAFE(var, head, field, tvar) \ + for ((var) = CIRCLEQ_FIRST(head); \ + (var) != CIRCLEQ_END(head) && \ + ((tvar) = CIRCLEQ_NEXT(var, field), 1); \ + (var) = (tvar)) + +#define CIRCLEQ_FOREACH_REVERSE(var, head, field) \ + for((var) = CIRCLEQ_LAST(head); \ + (var) != CIRCLEQ_END(head); \ + (var) = CIRCLEQ_PREV(var, field)) + +#define CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar) \ + for ((var) = CIRCLEQ_LAST(head, headname); \ + (var) != CIRCLEQ_END(head) && \ + ((tvar) = CIRCLEQ_PREV(var, headname, field), 1); \ + (var) = (tvar)) + +/* + * Circular queue functions. + */ +#define CIRCLEQ_INIT(head) do { \ + (head)->cqh_first = CIRCLEQ_END(head); \ + (head)->cqh_last = CIRCLEQ_END(head); \ +} while (0) + +#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do { \ + (elm)->field.cqe_next = (listelm)->field.cqe_next; \ + (elm)->field.cqe_prev = (listelm); \ + if ((listelm)->field.cqe_next == CIRCLEQ_END(head)) \ + (head)->cqh_last = (elm); \ + else \ + (listelm)->field.cqe_next->field.cqe_prev = (elm); \ + (listelm)->field.cqe_next = (elm); \ +} while (0) + +#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do { \ + (elm)->field.cqe_next = (listelm); \ + (elm)->field.cqe_prev = (listelm)->field.cqe_prev; \ + if ((listelm)->field.cqe_prev == CIRCLEQ_END(head)) \ + (head)->cqh_first = (elm); \ + else \ + (listelm)->field.cqe_prev->field.cqe_next = (elm); \ + (listelm)->field.cqe_prev = (elm); \ +} while (0) + +#define CIRCLEQ_INSERT_HEAD(head, elm, field) do { \ + (elm)->field.cqe_next = (head)->cqh_first; \ + (elm)->field.cqe_prev = CIRCLEQ_END(head); \ + if ((head)->cqh_last == CIRCLEQ_END(head)) \ + (head)->cqh_last = (elm); \ + else \ + (head)->cqh_first->field.cqe_prev = (elm); \ + (head)->cqh_first = (elm); \ +} while (0) + +#define CIRCLEQ_INSERT_TAIL(head, elm, field) do { \ + (elm)->field.cqe_next = CIRCLEQ_END(head); \ + (elm)->field.cqe_prev = (head)->cqh_last; \ + if ((head)->cqh_first == CIRCLEQ_END(head)) \ + (head)->cqh_first = (elm); \ + else \ + (head)->cqh_last->field.cqe_next = (elm); \ + (head)->cqh_last = (elm); \ +} while (0) + +#define CIRCLEQ_REMOVE(head, elm, field) do { \ + if ((elm)->field.cqe_next == CIRCLEQ_END(head)) \ + (head)->cqh_last = (elm)->field.cqe_prev; \ + else \ + (elm)->field.cqe_next->field.cqe_prev = \ + (elm)->field.cqe_prev; \ + if ((elm)->field.cqe_prev == CIRCLEQ_END(head)) \ + (head)->cqh_first = (elm)->field.cqe_next; \ + else \ + (elm)->field.cqe_prev->field.cqe_next = \ + (elm)->field.cqe_next; \ + _Q_INVALIDATE((elm)->field.cqe_prev); \ + _Q_INVALIDATE((elm)->field.cqe_next); \ +} while (0) + +#define CIRCLEQ_REPLACE(head, elm, elm2, field) do { \ + if (((elm2)->field.cqe_next = (elm)->field.cqe_next) == \ + CIRCLEQ_END(head)) \ + (head)->cqh_last = (elm2); \ + else \ + (elm2)->field.cqe_next->field.cqe_prev = (elm2); \ + if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) == \ + CIRCLEQ_END(head)) \ + (head)->cqh_first = (elm2); \ + else \ + (elm2)->field.cqe_prev->field.cqe_next = (elm2); \ + _Q_INVALIDATE((elm)->field.cqe_prev); \ + _Q_INVALIDATE((elm)->field.cqe_next); \ +} while (0) + + +/**** amalgamated original file "/deps/pcg_basic.h" ****/ + +/* + * PCG Random Number Generation for C. + * + * Copyright 2014 Melissa O'Neill + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * For additional information about the PCG random number generation scheme, + * including its license and other licensing options, visit + * + * http://www.pcg-random.org + */ + + + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct pcg_state_setseq_64 { + uint64_t state; /* RNG state. All values are possible. */ + uint64_t inc; /* Controls which RNG sequence (stream) is selected. Must + * *always* be odd. */ +} pcg32_random_t; + +#define PCG32_INITIALIZER { 0x853c49e6748fea9bULL, 0xda3e39cb94b95bdbULL } + +void pcg32_srandom_r(pcg32_random_t* rng, uint64_t initial_state, uint64_t initseq); +uint32_t pcg32_random_r(pcg32_random_t* rng); + +#ifdef __cplusplus +} +#endif + + +/**** amalgamated original file "/deps/libc_time.h" ****/ + + +struct mytm { + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; +}; + +int __secs_to_tm(long long t, struct mytm *tm); +long long __tm_to_secs(const struct mytm *tm); + + +/**** amalgamated original file "/deps/base64.h" ****/ + +#ifndef UA_BASE64_H_ +#define UA_BASE64_H_ + + +_UA_BEGIN_DECLS + +#include + +/** + * base64_encode - Base64 encode + * @src: Data to be encoded + * @len: Length of the data to be encoded + * @out_len: Pointer to output length variable + * Returns: Allocated buffer of out_len bytes of encoded data, + * or %NULL on failure. The output is NOT Null-terminated. */ +unsigned char * +UA_base64(const unsigned char *src, size_t len, size_t *out_len); + +/** + * base64_decode - Base64 decode + * @src: Data to be decoded + * @len: Length of the data to be decoded + * @out_len: Pointer to output length variable + * Returns: Allocated buffer of out_len bytes of decoded data, + * or %NULL on failure. */ +unsigned char * +UA_unbase64(const unsigned char *src, size_t len, size_t *out_len); + +_UA_END_DECLS + +#endif /* UA_BASE64_H_ */ + +/**** amalgamated original file "/src/ua_types_encoding_binary.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015 (c) Sten Grüner + * Copyright 2014, 2017 (c) Florian Palm + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + */ + + + +_UA_BEGIN_DECLS + +typedef UA_StatusCode (*UA_exchangeEncodeBuffer)(void *handle, UA_Byte **bufPos, + const UA_Byte **bufEnd); + +/* Encodes the scalar value described by type in the binary encoding. Encoding + * is thread-safe if thread-local variables are enabled. Encoding is also + * reentrant and can be safely called from signal handlers or interrupts. + * + * @param src The value. Must not be NULL. + * @param type The value type. Must not be NULL. + * @param bufPos Points to a pointer to the current position in the encoding + * buffer. Must not be NULL. The pointer is advanced by the number of + * encoded bytes, or, if the buffer is exchanged, to the position in the + * new buffer. + * @param bufEnd Points to a pointer to the end of the encoding buffer (encoding + * always stops before *buf_end). Must not be NULL. The pointer is + * changed when the buffer is exchanged. + * @param exchangeCallback Called when the end of the buffer is reached. This is + used to send out a message chunk before continuing with the encoding. + Is ignored if NULL. + * @param exchangeHandle Custom data passed into the exchangeCallback. + * @return Returns a statuscode whether encoding succeeded. */ +UA_StatusCode +UA_encodeBinaryInternal(const void *src, const UA_DataType *type, + UA_Byte **bufPos, const UA_Byte **bufEnd, + UA_exchangeEncodeBuffer exchangeCallback, + void *exchangeHandle) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +/* Decodes a scalar value described by type from binary encoding. Decoding + * is thread-safe if thread-local variables are enabled. Decoding is also + * reentrant and can be safely called from signal handlers or interrupts. + * + * @param src The buffer with the binary encoded value. Must not be NULL. + * @param offset The current position in the buffer. Must not be NULL. The value + * is advanced as decoding progresses. + * @param dst The target value. Must not be NULL. The target is assumed to have + * size type->memSize. The value is reset to zero before decoding. If + * decoding fails, members are deleted and the value is reset (zeroed) + * again. + * @param type The value type. Must not be NULL. + * @param customTypesSize The number of non-standard datatypes contained in the + * customTypes array. + * @param customTypes An array of non-standard datatypes (not included in + * UA_TYPES). Can be NULL if customTypesSize is zero. + * @return Returns a statuscode whether decoding succeeded. */ +UA_StatusCode +UA_decodeBinaryInternal(const UA_ByteString *src, size_t *offset, + void *dst, const UA_DataType *type, + const UA_DataTypeArray *customTypes) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +const UA_DataType * +UA_findDataTypeByBinary(const UA_NodeId *typeId); + +_UA_END_DECLS + + +/**** amalgamated original file "/src/ua_util_internal.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2017 (c) Florian Palm + * Copyright 2015 (c) LEvertz + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2021 (c) Fraunhofer IOSB (Author: Jan Hermes) + */ + + +#define UA_INTERNAL + + +_UA_BEGIN_DECLS + +/* Macro-Expand for MSVC workarounds */ +#define UA_MACRO_EXPAND(x) x + +/* Print a NodeId in logs */ +#define UA_LOG_NODEID_INTERNAL(NODEID, LOG) \ + do { \ + UA_String nodeIdStr = UA_STRING_NULL; \ + UA_NodeId_print(NODEID, &nodeIdStr); \ + LOG; \ + UA_String_clear(&nodeIdStr); \ + } while(0) + +#if UA_LOGLEVEL <= 100 +# define UA_LOG_NODEID_TRACE(NODEID, LOG) \ + UA_LOG_NODEID_INTERNAL(NODEID, LOG) +#else +# define UA_LOG_NODEID_TRACE(NODEID, LOG) +#endif + +#if UA_LOGLEVEL <= 200 +# define UA_LOG_NODEID_DEBUG(NODEID, LOG) \ + UA_LOG_NODEID_INTERNAL(NODEID, LOG) +#else +# define UA_LOG_NODEID_DEBUG(NODEID, LOG) +#endif + +#if UA_LOGLEVEL <= 300 +# define UA_LOG_NODEID_INFO(NODEID, LOG) \ + UA_LOG_NODEID_INTERNAL(NODEID, LOG) +#else +# define UA_LOG_NODEID_INFO(NODEID, LOG) +#endif + +#if UA_LOGLEVEL <= 400 +# define UA_LOG_NODEID_WARNING(NODEID, LOG) \ + UA_LOG_NODEID_INTERNAL(NODEID, LOG) +#else +# define UA_LOG_NODEID_WARNING(NODEID, LOG) +#endif + +#if UA_LOGLEVEL <= 500 +# define UA_LOG_NODEID_ERROR(NODEID, LOG) \ + UA_LOG_NODEID_INTERNAL(NODEID, LOG) +#else +# define UA_LOG_NODEID_ERROR(NODEID, LOG) +#endif + +#if UA_LOGLEVEL <= 600 +# define UA_LOG_NODEID_FATAL(NODEID, LOG) \ + UA_LOG_NODEID_INTERNAL(NODEID, LOG) +#else +# define UA_LOG_NODEID_FATAL(NODEID, LOG) +#endif + +/* Short names for integer. These are not exposed on the public API, since many + * user-applications make the same definitions in their headers. */ +typedef UA_Byte u8; +typedef UA_SByte i8; +typedef UA_UInt16 u16; +typedef UA_Int16 i16; +typedef UA_UInt32 u32; +typedef UA_Int32 i32; +typedef UA_UInt64 u64; +typedef UA_Int64 i64; +typedef UA_StatusCode status; + +/** + * Error checking macros + */ + +static UA_INLINE UA_Boolean +isGood(UA_StatusCode code) { + return code == UA_STATUSCODE_GOOD; +} + +static UA_INLINE UA_Boolean +isNonNull(const void *ptr) { + return ptr != NULL; +} + +static UA_INLINE UA_Boolean +isTrue(uint8_t expr) { + return expr; +} + +#define UA_CHECK(A, EVAL_ON_ERROR) \ + do { \ + if(UA_UNLIKELY(!isTrue(A))) { \ + EVAL_ON_ERROR; \ + } \ + } while(0) + +#define UA_CHECK_STATUS(STATUSCODE, EVAL_ON_ERROR) \ + UA_CHECK(isGood(STATUSCODE), EVAL_ON_ERROR) + +#define UA_CHECK_MEM(STATUSCODE, EVAL_ON_ERROR) \ + UA_CHECK(isNonNull(STATUSCODE), EVAL_ON_ERROR) + +#ifdef UA_DEBUG_FILE_LINE_INFO +#define UA_CHECK_LOG_INTERNAL(A, STATUSCODE, EVAL, LOG, LOGGER, CAT, MSG, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK(A, LOG(LOGGER, CAT, "" MSG "%s (%s:%d: statuscode: %s)", __VA_ARGS__, \ + __FILE__, __LINE__, UA_StatusCode_name(STATUSCODE)); \ + EVAL)) +#else +#define UA_CHECK_LOG_INTERNAL(A, STATUSCODE, EVAL, LOG, LOGGER, CAT, MSG, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK(A, LOG(LOGGER, CAT, "" MSG "%s (statuscode: %s)", __VA_ARGS__, \ + UA_StatusCode_name(STATUSCODE)); \ + EVAL)) +#endif + +#define UA_CHECK_LOG(A, EVAL, LEVEL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND(UA_CHECK_LOG_INTERNAL(A, UA_STATUSCODE_BAD, EVAL, UA_LOG_##LEVEL, \ + LOGGER, CAT, __VA_ARGS__, "")) + +#define UA_CHECK_STATUS_LOG(STATUSCODE, EVAL, LEVEL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND(UA_CHECK_LOG_INTERNAL(isGood(STATUSCODE), STATUSCODE, \ + EVAL, UA_LOG_##LEVEL, LOGGER, CAT, \ + __VA_ARGS__, "")) + +#define UA_CHECK_MEM_LOG(PTR, EVAL, LEVEL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND(UA_CHECK_LOG_INTERNAL(isNonNull(PTR), UA_STATUSCODE_BADOUTOFMEMORY, \ + EVAL, UA_LOG_##LEVEL, LOGGER, CAT, \ + __VA_ARGS__, "")) + +/** + * Check Macros + * Usage examples: + * + * void *data = malloc(...); + * UA_CHECK(data, return error); + * + * UA_StatusCode rv = some_func(...); + * UA_CHECK_STATUS(rv, return rv); + * + * UA_Logger *logger = &server->config.logger; + * rv = bar_func(...); + * UA_CHECK_STATUS_WARN(rv, return rv, logger, UA_LOGCATEGORY_SERVER, "msg & args %s", "arg"); + */ +#define UA_CHECK_FATAL(A, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND(UA_CHECK_LOG(A, EVAL, FATAL, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_ERROR(A, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND(UA_CHECK_LOG(A, EVAL, ERROR, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_WARN(A, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND(UA_CHECK_LOG(A, EVAL, WARNING, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_INFO(A, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND(UA_CHECK_LOG(A, EVAL, INFO, LOGGER, CAT, __VA_ARGS__)) + +#define UA_CHECK_STATUS_FATAL(STATUSCODE, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_STATUS_LOG(STATUSCODE, EVAL, FATAL, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_STATUS_ERROR(STATUSCODE, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_STATUS_LOG(STATUSCODE, EVAL, ERROR, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_STATUS_WARN(STATUSCODE, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_STATUS_LOG(STATUSCODE, EVAL, WARNING, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_STATUS_INFO(STATUSCODE, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_STATUS_LOG(STATUSCODE, EVAL, INFO, LOGGER, CAT, __VA_ARGS__)) + +#define UA_CHECK_MEM_FATAL(PTR, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_MEM_LOG(PTR, EVAL, FATAL, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_MEM_ERROR(PTR, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_MEM_LOG(PTR, EVAL, ERROR, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_MEM_WARN(PTR, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_MEM_LOG(PTR, EVAL, WARNING, LOGGER, CAT, __VA_ARGS__)) +#define UA_CHECK_MEM_INFO(PTR, EVAL, LOGGER, CAT, ...) \ + UA_MACRO_EXPAND( \ + UA_CHECK_MEM_LOG(PTR, EVAL, INFO, LOGGER, CAT, __VA_ARGS__)) + +/** + * Utility Functions + * ----------------- */ + +const UA_DataType * +UA_findDataTypeWithCustom(const UA_NodeId *typeId, + const UA_DataTypeArray *customTypes); + +/* Get the number of optional fields contained in an structure type */ +size_t UA_EXPORT +getCountOfOptionalFields(const UA_DataType *type); + +/* Dump packet for debugging / fuzzing */ +#ifdef UA_DEBUG_DUMP_PKGS +void UA_EXPORT +UA_dump_hex_pkg(UA_Byte* buffer, size_t bufferLen); +#endif + +/* Unions that represent any of the supported request or response message */ +typedef union { + UA_RequestHeader requestHeader; + UA_FindServersRequest findServersRequest; + UA_GetEndpointsRequest getEndpointsRequest; +#ifdef UA_ENABLE_DISCOVERY +# ifdef UA_ENABLE_DISCOVERY_MULTICAST + UA_FindServersOnNetworkRequest findServersOnNetworkRequest; +# endif + UA_RegisterServerRequest registerServerRequest; + UA_RegisterServer2Request registerServer2Request; +#endif + UA_OpenSecureChannelRequest openSecureChannelRequest; + UA_CreateSessionRequest createSessionRequest; + UA_ActivateSessionRequest activateSessionRequest; + UA_CloseSessionRequest closeSessionRequest; + UA_AddNodesRequest addNodesRequest; + UA_AddReferencesRequest addReferencesRequest; + UA_DeleteNodesRequest deleteNodesRequest; + UA_DeleteReferencesRequest deleteReferencesRequest; + UA_BrowseRequest browseRequest; + UA_BrowseNextRequest browseNextRequest; + UA_TranslateBrowsePathsToNodeIdsRequest translateBrowsePathsToNodeIdsRequest; + UA_RegisterNodesRequest registerNodesRequest; + UA_UnregisterNodesRequest unregisterNodesRequest; + UA_ReadRequest readRequest; + UA_WriteRequest writeRequest; +#ifdef UA_ENABLE_HISTORIZING + UA_HistoryReadRequest historyReadRequest; + UA_HistoryUpdateRequest historyUpdateRequest; +#endif +#ifdef UA_ENABLE_METHODCALLS + UA_CallRequest callRequest; +#endif +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_CreateMonitoredItemsRequest createMonitoredItemsRequest; + UA_DeleteMonitoredItemsRequest deleteMonitoredItemsRequest; + UA_ModifyMonitoredItemsRequest modifyMonitoredItemsRequest; + UA_SetMonitoringModeRequest setMonitoringModeRequest; + UA_CreateSubscriptionRequest createSubscriptionRequest; + UA_ModifySubscriptionRequest modifySubscriptionRequest; + UA_SetPublishingModeRequest setPublishingModeRequest; + UA_PublishRequest publishRequest; + UA_RepublishRequest republishRequest; + UA_DeleteSubscriptionsRequest deleteSubscriptionsRequest; +#endif +} UA_Request; + +typedef union { + UA_ResponseHeader responseHeader; + UA_FindServersResponse findServersResponse; + UA_GetEndpointsResponse getEndpointsResponse; +#ifdef UA_ENABLE_DISCOVERY +# ifdef UA_ENABLE_DISCOVERY_MULTICAST + UA_FindServersOnNetworkResponse findServersOnNetworkResponse; +# endif + UA_RegisterServerResponse registerServerResponse; + UA_RegisterServer2Response registerServer2Response; +#endif + UA_OpenSecureChannelResponse openSecureChannelResponse; + UA_CreateSessionResponse createSessionResponse; + UA_ActivateSessionResponse activateSessionResponse; + UA_CloseSessionResponse closeSessionResponse; + UA_AddNodesResponse addNodesResponse; + UA_AddReferencesResponse addReferencesResponse; + UA_DeleteNodesResponse deleteNodesResponse; + UA_DeleteReferencesResponse deleteReferencesResponse; + UA_BrowseResponse browseResponse; + UA_BrowseNextResponse browseNextResponse; + UA_TranslateBrowsePathsToNodeIdsResponse translateBrowsePathsToNodeIdsResponse; + UA_RegisterNodesResponse registerNodesResponse; + UA_UnregisterNodesResponse unregisterNodesResponse; + UA_ReadResponse readResponse; + UA_WriteResponse writeResponse; +#ifdef UA_ENABLE_HISTORIZING + UA_HistoryReadResponse historyReadResponse; + UA_HistoryUpdateResponse historyUpdateResponse; +#endif +#ifdef UA_ENABLE_METHODCALLS + UA_CallResponse callResponse; +#endif +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_CreateMonitoredItemsResponse createMonitoredItemsResponse; + UA_DeleteMonitoredItemsResponse deleteMonitoredItemsResponse; + UA_ModifyMonitoredItemsResponse modifyMonitoredItemsResponse; + UA_SetMonitoringModeResponse setMonitoringModeResponse; + UA_CreateSubscriptionResponse createSubscriptionResponse; + UA_ModifySubscriptionResponse modifySubscriptionResponse; + UA_SetPublishingModeResponse setPublishingModeResponse; + UA_PublishResponse publishResponse; + UA_RepublishResponse republishResponse; + UA_DeleteSubscriptionsResponse deleteSubscriptionsResponse; +#endif +} UA_Response; + +/* Do not expose UA_String_equal_ignorecase to public API as it currently only handles + * ASCII strings, and not UTF8! */ +UA_Boolean UA_EXPORT +UA_String_equal_ignorecase(const UA_String *s1, const UA_String *s2); + +/********************/ +/* Encoding Helpers */ +/********************/ + +#define UA_ENCODING_HELPERS(TYPE, UPCASE_TYPE) \ + static UA_INLINE size_t \ + UA_##TYPE##_calcSizeBinary(const UA_##TYPE *src) { \ + return UA_calcSizeBinary(src, &UA_TYPES[UA_TYPES_##UPCASE_TYPE]); \ + } \ + static UA_INLINE UA_StatusCode \ + UA_##TYPE##_encodeBinary(const UA_##TYPE *src, UA_Byte **bufPos, const UA_Byte *bufEnd) { \ + return UA_encodeBinaryInternal(src, &UA_TYPES[UA_TYPES_##UPCASE_TYPE], \ + bufPos, &bufEnd, NULL, NULL); \ + } \ + static UA_INLINE UA_StatusCode \ + UA_##TYPE##_decodeBinary(const UA_ByteString *src, size_t *offset, UA_##TYPE *dst) { \ + return UA_decodeBinaryInternal(src, offset, dst, \ + &UA_TYPES[UA_TYPES_##UPCASE_TYPE], NULL); \ + } + +UA_ENCODING_HELPERS(Boolean, BOOLEAN) +UA_ENCODING_HELPERS(SByte, SBYTE) +UA_ENCODING_HELPERS(Byte, BYTE) +UA_ENCODING_HELPERS(Int16, INT16) +UA_ENCODING_HELPERS(UInt16, UINT16) +UA_ENCODING_HELPERS(Int32, INT32) +UA_ENCODING_HELPERS(UInt32, UINT32) +UA_ENCODING_HELPERS(Int64, INT64) +UA_ENCODING_HELPERS(UInt64, UINT64) +UA_ENCODING_HELPERS(Float, FLOAT) +UA_ENCODING_HELPERS(Double, DOUBLE) +UA_ENCODING_HELPERS(String, STRING) +UA_ENCODING_HELPERS(DateTime, DATETIME) +UA_ENCODING_HELPERS(Guid, GUID) +UA_ENCODING_HELPERS(ByteString, BYTESTRING) +UA_ENCODING_HELPERS(XmlElement, XMLELEMENT) +UA_ENCODING_HELPERS(NodeId, NODEID) +UA_ENCODING_HELPERS(ExpandedNodeId, EXPANDEDNODEID) +UA_ENCODING_HELPERS(StatusCode, STATUSCODE) +UA_ENCODING_HELPERS(QualifiedName, QUALIFIEDNAME) +UA_ENCODING_HELPERS(LocalizedText, LOCALIZEDTEXT) +UA_ENCODING_HELPERS(ExtensionObject, EXTENSIONOBJECT) +UA_ENCODING_HELPERS(DataValue, DATAVALUE) +UA_ENCODING_HELPERS(Variant, VARIANT) +UA_ENCODING_HELPERS(DiagnosticInfo, DIAGNOSTICINFO) + +_UA_END_DECLS + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/transport_generated.h" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + + +#ifdef UA_ENABLE_AMALGAMATION +#else + +#endif + + + +_UA_BEGIN_DECLS + + +/** + * Every type is assigned an index in an array containing the type descriptions. + * These descriptions are used during type handling (copying, deletion, + * binary encoding, ...). */ +#define UA_TRANSPORT_COUNT 8 +extern UA_EXPORT const UA_DataType UA_TRANSPORT[UA_TRANSPORT_COUNT]; + +/** + * MessageType + * ^^^^^^^^^^^ + * Message Type and whether the message contains an intermediate chunk */ +typedef enum { + UA_MESSAGETYPE_ACK = 0x4B4341, + UA_MESSAGETYPE_HEL = 0x4C4548, + UA_MESSAGETYPE_MSG = 0x47534D, + UA_MESSAGETYPE_OPN = 0x4E504F, + UA_MESSAGETYPE_CLO = 0x4F4C43, + UA_MESSAGETYPE_ERR = 0x525245, + UA_MESSAGETYPE_INVALID = 0x0, + __UA_MESSAGETYPE_FORCE32BIT = 0x7fffffff +} UA_MessageType; +UA_STATIC_ASSERT(sizeof(UA_MessageType) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TRANSPORT_MESSAGETYPE 0 + +/** + * ChunkType + * ^^^^^^^^^ + * Type of the chunk */ +typedef enum { + UA_CHUNKTYPE_FINAL = 0x46000000, + UA_CHUNKTYPE_INTERMEDIATE = 0x43000000, + UA_CHUNKTYPE_ABORT = 0x41000000, + __UA_CHUNKTYPE_FORCE32BIT = 0x7fffffff +} UA_ChunkType; +UA_STATIC_ASSERT(sizeof(UA_ChunkType) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TRANSPORT_CHUNKTYPE 1 + +/** + * TcpMessageHeader + * ^^^^^^^^^^^^^^^^ + * TCP Header */ +typedef struct { + UA_UInt32 messageTypeAndChunkType; + UA_UInt32 messageSize; +} UA_TcpMessageHeader; + +#define UA_TRANSPORT_TCPMESSAGEHEADER 2 + +/** + * TcpHelloMessage + * ^^^^^^^^^^^^^^^ + * Hello Message */ +typedef struct { + UA_UInt32 protocolVersion; + UA_UInt32 receiveBufferSize; + UA_UInt32 sendBufferSize; + UA_UInt32 maxMessageSize; + UA_UInt32 maxChunkCount; + UA_String endpointUrl; +} UA_TcpHelloMessage; + +#define UA_TRANSPORT_TCPHELLOMESSAGE 3 + +/** + * TcpAcknowledgeMessage + * ^^^^^^^^^^^^^^^^^^^^^ + * Acknowledge Message */ +typedef struct { + UA_UInt32 protocolVersion; + UA_UInt32 receiveBufferSize; + UA_UInt32 sendBufferSize; + UA_UInt32 maxMessageSize; + UA_UInt32 maxChunkCount; +} UA_TcpAcknowledgeMessage; + +#define UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE 4 + +/** + * TcpErrorMessage + * ^^^^^^^^^^^^^^^ + * Error Message */ +typedef struct { + UA_UInt32 error; + UA_String reason; +} UA_TcpErrorMessage; + +#define UA_TRANSPORT_TCPERRORMESSAGE 5 + +/** + * AsymmetricAlgorithmSecurityHeader + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Asymmetric Security Header */ +typedef struct { + UA_ByteString securityPolicyUri; + UA_ByteString senderCertificate; + UA_ByteString receiverCertificateThumbprint; +} UA_AsymmetricAlgorithmSecurityHeader; + +#define UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER 6 + +/** + * SequenceHeader + * ^^^^^^^^^^^^^^ + * Secure Layer Sequence Header */ +typedef struct { + UA_UInt32 sequenceNumber; + UA_UInt32 requestId; +} UA_SequenceHeader; + +#define UA_TRANSPORT_SEQUENCEHEADER 7 + + +_UA_END_DECLS + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/transport_generated_handling.h" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + + + +_UA_BEGIN_DECLS + +#if defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 6 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wmissing-field-initializers" +# pragma GCC diagnostic ignored "-Wmissing-braces" +#endif + + +/* MessageType */ +static UA_INLINE void +UA_MessageType_init(UA_MessageType *p) { + memset(p, 0, sizeof(UA_MessageType)); +} + +static UA_INLINE UA_MessageType * +UA_MessageType_new(void) { + return (UA_MessageType*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_MESSAGETYPE]); +} + +static UA_INLINE UA_StatusCode +UA_MessageType_copy(const UA_MessageType *src, UA_MessageType *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_MESSAGETYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MessageType_deleteMembers(UA_MessageType *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_MESSAGETYPE]); +} + +static UA_INLINE void +UA_MessageType_clear(UA_MessageType *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_MESSAGETYPE]); +} + +static UA_INLINE void +UA_MessageType_delete(UA_MessageType *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_MESSAGETYPE]); +} + +/* ChunkType */ +static UA_INLINE void +UA_ChunkType_init(UA_ChunkType *p) { + memset(p, 0, sizeof(UA_ChunkType)); +} + +static UA_INLINE UA_ChunkType * +UA_ChunkType_new(void) { + return (UA_ChunkType*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_CHUNKTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_ChunkType_copy(const UA_ChunkType *src, UA_ChunkType *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_CHUNKTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ChunkType_deleteMembers(UA_ChunkType *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_CHUNKTYPE]); +} + +static UA_INLINE void +UA_ChunkType_clear(UA_ChunkType *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_CHUNKTYPE]); +} + +static UA_INLINE void +UA_ChunkType_delete(UA_ChunkType *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_CHUNKTYPE]); +} + +/* TcpMessageHeader */ +static UA_INLINE void +UA_TcpMessageHeader_init(UA_TcpMessageHeader *p) { + memset(p, 0, sizeof(UA_TcpMessageHeader)); +} + +static UA_INLINE UA_TcpMessageHeader * +UA_TcpMessageHeader_new(void) { + return (UA_TcpMessageHeader*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER]); +} + +static UA_INLINE UA_StatusCode +UA_TcpMessageHeader_copy(const UA_TcpMessageHeader *src, UA_TcpMessageHeader *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TcpMessageHeader_deleteMembers(UA_TcpMessageHeader *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER]); +} + +static UA_INLINE void +UA_TcpMessageHeader_clear(UA_TcpMessageHeader *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER]); +} + +static UA_INLINE void +UA_TcpMessageHeader_delete(UA_TcpMessageHeader *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER]); +} + +/* TcpHelloMessage */ +static UA_INLINE void +UA_TcpHelloMessage_init(UA_TcpHelloMessage *p) { + memset(p, 0, sizeof(UA_TcpHelloMessage)); +} + +static UA_INLINE UA_TcpHelloMessage * +UA_TcpHelloMessage_new(void) { + return (UA_TcpHelloMessage*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE]); +} + +static UA_INLINE UA_StatusCode +UA_TcpHelloMessage_copy(const UA_TcpHelloMessage *src, UA_TcpHelloMessage *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TcpHelloMessage_deleteMembers(UA_TcpHelloMessage *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE]); +} + +static UA_INLINE void +UA_TcpHelloMessage_clear(UA_TcpHelloMessage *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE]); +} + +static UA_INLINE void +UA_TcpHelloMessage_delete(UA_TcpHelloMessage *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE]); +} + +/* TcpAcknowledgeMessage */ +static UA_INLINE void +UA_TcpAcknowledgeMessage_init(UA_TcpAcknowledgeMessage *p) { + memset(p, 0, sizeof(UA_TcpAcknowledgeMessage)); +} + +static UA_INLINE UA_TcpAcknowledgeMessage * +UA_TcpAcknowledgeMessage_new(void) { + return (UA_TcpAcknowledgeMessage*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE]); +} + +static UA_INLINE UA_StatusCode +UA_TcpAcknowledgeMessage_copy(const UA_TcpAcknowledgeMessage *src, UA_TcpAcknowledgeMessage *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TcpAcknowledgeMessage_deleteMembers(UA_TcpAcknowledgeMessage *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE]); +} + +static UA_INLINE void +UA_TcpAcknowledgeMessage_clear(UA_TcpAcknowledgeMessage *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE]); +} + +static UA_INLINE void +UA_TcpAcknowledgeMessage_delete(UA_TcpAcknowledgeMessage *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE]); +} + +/* TcpErrorMessage */ +static UA_INLINE void +UA_TcpErrorMessage_init(UA_TcpErrorMessage *p) { + memset(p, 0, sizeof(UA_TcpErrorMessage)); +} + +static UA_INLINE UA_TcpErrorMessage * +UA_TcpErrorMessage_new(void) { + return (UA_TcpErrorMessage*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE]); +} + +static UA_INLINE UA_StatusCode +UA_TcpErrorMessage_copy(const UA_TcpErrorMessage *src, UA_TcpErrorMessage *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TcpErrorMessage_deleteMembers(UA_TcpErrorMessage *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE]); +} + +static UA_INLINE void +UA_TcpErrorMessage_clear(UA_TcpErrorMessage *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE]); +} + +static UA_INLINE void +UA_TcpErrorMessage_delete(UA_TcpErrorMessage *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE]); +} + +/* AsymmetricAlgorithmSecurityHeader */ +static UA_INLINE void +UA_AsymmetricAlgorithmSecurityHeader_init(UA_AsymmetricAlgorithmSecurityHeader *p) { + memset(p, 0, sizeof(UA_AsymmetricAlgorithmSecurityHeader)); +} + +static UA_INLINE UA_AsymmetricAlgorithmSecurityHeader * +UA_AsymmetricAlgorithmSecurityHeader_new(void) { + return (UA_AsymmetricAlgorithmSecurityHeader*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER]); +} + +static UA_INLINE UA_StatusCode +UA_AsymmetricAlgorithmSecurityHeader_copy(const UA_AsymmetricAlgorithmSecurityHeader *src, UA_AsymmetricAlgorithmSecurityHeader *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AsymmetricAlgorithmSecurityHeader_deleteMembers(UA_AsymmetricAlgorithmSecurityHeader *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER]); +} + +static UA_INLINE void +UA_AsymmetricAlgorithmSecurityHeader_clear(UA_AsymmetricAlgorithmSecurityHeader *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER]); +} + +static UA_INLINE void +UA_AsymmetricAlgorithmSecurityHeader_delete(UA_AsymmetricAlgorithmSecurityHeader *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER]); +} + +/* SequenceHeader */ +static UA_INLINE void +UA_SequenceHeader_init(UA_SequenceHeader *p) { + memset(p, 0, sizeof(UA_SequenceHeader)); +} + +static UA_INLINE UA_SequenceHeader * +UA_SequenceHeader_new(void) { + return (UA_SequenceHeader*)UA_new(&UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER]); +} + +static UA_INLINE UA_StatusCode +UA_SequenceHeader_copy(const UA_SequenceHeader *src, UA_SequenceHeader *dst) { + return UA_copy(src, dst, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SequenceHeader_deleteMembers(UA_SequenceHeader *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER]); +} + +static UA_INLINE void +UA_SequenceHeader_clear(UA_SequenceHeader *p) { + UA_clear(p, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER]); +} + +static UA_INLINE void +UA_SequenceHeader_delete(UA_SequenceHeader *p) { + UA_delete(p, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER]); +} + +#if defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 6 +# pragma GCC diagnostic pop +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/src/ua_connection_internal.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2016-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Florian Palm + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + */ + + + +_UA_BEGIN_DECLS + +/* When a fatal error occurs the Server shall send an Error Message to the + * Client and close the socket. When a Client encounters one of these errors, it + * shall also close the socket but does not send an Error Message. After the + * socket is closed a Client shall try to reconnect automatically using the + * mechanisms described in [...]. */ +void +UA_Connection_sendError(UA_Connection *connection, + UA_TcpErrorMessage *error); + +void UA_Connection_detachSecureChannel(UA_Connection *connection); +void UA_Connection_attachSecureChannel(UA_Connection *connection, + UA_SecureChannel *channel); + +_UA_END_DECLS + + +/**** amalgamated original file "/src/ua_securechannel.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Florian Palm + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + */ + + + + +_UA_BEGIN_DECLS + +/* The message header of the OPC UA binary protocol is structured as follows: + * + * - MessageType (3 Byte) + * - IsFinal (1 Byte) + * - MessageSize (4 Byte) + * *** UA_SECURECHANNEL_MESSAGEHEADER_LENGTH *** + * - SecureChannelId (4 Byte) + * *** UA_SECURECHANNEL_CHANNELHEADER_LENGTH *** + * - SecurityHeader (4 Byte TokenId for symmetric, otherwise dynamic length) + * - SequenceHeader (8 Byte) + * - SequenceNumber + * - RequestId + */ + +#define UA_SECURECHANNEL_MESSAGEHEADER_LENGTH 8 +#define UA_SECURECHANNEL_CHANNELHEADER_LENGTH 12 +#define UA_SECURECHANNEL_SYMMETRIC_SECURITYHEADER_LENGTH 4 +#define UA_SECURECHANNEL_SEQUENCEHEADER_LENGTH 8 +#define UA_SECURECHANNEL_SYMMETRIC_HEADER_UNENCRYPTEDLENGTH \ + (UA_SECURECHANNEL_CHANNELHEADER_LENGTH + \ + UA_SECURECHANNEL_SYMMETRIC_SECURITYHEADER_LENGTH) +#define UA_SECURECHANNEL_SYMMETRIC_HEADER_TOTALLENGTH \ + (UA_SECURECHANNEL_CHANNELHEADER_LENGTH + \ + UA_SECURECHANNEL_SYMMETRIC_SECURITYHEADER_LENGTH + \ + UA_SECURECHANNEL_SEQUENCEHEADER_LENGTH) + +/* Minimum length of a valid message (ERR message with an empty reason) */ +#define UA_SECURECHANNEL_MESSAGE_MIN_LENGTH 16 + +/* Thread-local variables to force failure modes during testing */ +#ifdef UA_ENABLE_UNIT_TEST_FAILURE_HOOKS +extern UA_StatusCode decrypt_verifySignatureFailure; +extern UA_StatusCode sendAsym_sendFailure; +extern UA_StatusCode processSym_seqNumberFailure; +#endif + +/* The Session implementation differs between client and server. Still, it is + * expected that the Session structure begins with the SessionHeader. This is + * the interface that will be used by the SecureChannel. The lifecycle of + * Sessions is independent of the underlying SecureChannel. But every Session + * can be attached to only one SecureChannel. */ +typedef struct UA_SessionHeader { + SLIST_ENTRY(UA_SessionHeader) next; + UA_NodeId authenticationToken; + UA_SecureChannel *channel; /* The pointer back to the SecureChannel in the session. */ +} UA_SessionHeader; + +/* For chunked requests */ +typedef struct UA_Chunk { + SIMPLEQ_ENTRY(UA_Chunk) pointers; + UA_ByteString bytes; + UA_MessageType messageType; + UA_ChunkType chunkType; + UA_UInt32 requestId; + UA_Boolean copied; /* Do the bytes point to a buffer from the network or was + * memory allocated for the chunk separately */ +} UA_Chunk; + +typedef SIMPLEQ_HEAD(UA_ChunkQueue, UA_Chunk) UA_ChunkQueue; + +typedef enum { + UA_SECURECHANNELRENEWSTATE_NORMAL, + + /* Client has sent an OPN, but not received a response so far. */ + UA_SECURECHANNELRENEWSTATE_SENT, + + /* The server waits for the first request with the new token for the rollover. + * The new token is stored in the altSecurityToken. The configured local and + * remote symmetric encryption keys are the old ones. */ + UA_SECURECHANNELRENEWSTATE_NEWTOKEN_SERVER, + + /* The client already uses the new token. But he waits for the server to respond + * with the new token to complete the rollover. The old token is stored in + * altSecurityToken. The local symmetric encryption key is new. The remote + * encryption key is the old one. */ + UA_SECURECHANNELRENEWSTATE_NEWTOKEN_CLIENT +} UA_SecureChannelRenewState; + +struct UA_SecureChannel { + UA_SecureChannelState state; + UA_SecureChannelRenewState renewState; + UA_MessageSecurityMode securityMode; + UA_ConnectionConfig config; + + /* Rules for revolving the token with a renew OPN request: The client is + * allowed to accept messages with the old token until the OPN response has + * arrived. The server accepts the old token until one message secured with + * the new token has arrived. + * + * We recognize whether nextSecurityToken contains a valid next token if the + * ChannelId is not 0. */ + UA_ChannelSecurityToken securityToken; /* Also contains the channelId */ + UA_ChannelSecurityToken altSecurityToken; /* Alternative token for the rollover. + * See the renewState. */ + + /* The endpoint and context of the channel */ + const UA_SecurityPolicy *securityPolicy; + void *channelContext; /* For interaction with the security policy */ + UA_Connection *connection; + + /* Asymmetric encryption info */ + UA_ByteString remoteCertificate; + UA_Byte remoteCertificateThumbprint[20]; /* The thumbprint of the remote certificate */ + + /* Symmetric encryption nonces. These are used to generate the key material + * and must not be reused once the keys are in place. + * + * Nonces are also used during the CreateSession / ActivateSession + * handshake. These are not handled here, as the Session handling can + * overlap with a RenewSecureChannel. */ + UA_ByteString remoteNonce; + UA_ByteString localNonce; + + UA_UInt32 receiveSequenceNumber; + UA_UInt32 sendSequenceNumber; + + /* Sessions that are bound to the SecureChannel */ + SLIST_HEAD(, UA_SessionHeader) sessions; + + /* If a buffer is received, first all chunks are put into the completeChunks + * queue. Then they are processed in order. This ensures that processing + * buffers is reentrant with the correct processing order. (This has lead to + * problems in the client in the past.) */ + UA_ChunkQueue completeChunks; /* Received full chunks that have not been + * decrypted so far */ + UA_ChunkQueue decryptedChunks; /* Received chunks that were decrypted but + * not processed */ + size_t decryptedChunksCount; + size_t decryptedChunksLength; + UA_ByteString incompleteChunk; /* A half-received chunk (TCP is a + * streaming protocol) is stored here */ + + UA_CertificateVerification *certificateVerification; + UA_StatusCode (*processOPNHeader)(void *application, UA_SecureChannel *channel, + const UA_AsymmetricAlgorithmSecurityHeader *asymHeader); +}; + +void UA_SecureChannel_init(UA_SecureChannel *channel, + const UA_ConnectionConfig *config); + +void UA_SecureChannel_close(UA_SecureChannel *channel); + +/* Process the remote configuration in the HEL/ACK handshake. The connection + * config is initialized with the local settings. */ +UA_StatusCode +UA_SecureChannel_processHELACK(UA_SecureChannel *channel, + const UA_TcpAcknowledgeMessage *remoteConfig); + +UA_StatusCode +UA_SecureChannel_setSecurityPolicy(UA_SecureChannel *channel, + const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate); + +/* Remove (partially) received unprocessed chunks */ +void +UA_SecureChannel_deleteBuffered(UA_SecureChannel *channel); + +/* Wrapper function for generating a local nonce for the supplied channel. Uses + * the random generator of the channels security policy to allocate and generate + * a nonce with the specified length. */ +UA_StatusCode +UA_SecureChannel_generateLocalNonce(UA_SecureChannel *channel); + +UA_StatusCode +UA_SecureChannel_generateLocalKeys(const UA_SecureChannel *channel); + +UA_StatusCode +generateRemoteKeys(const UA_SecureChannel *channel); + +/** + * Sending Messages + * ---------------- */ + +UA_StatusCode +UA_SecureChannel_sendAsymmetricOPNMessage(UA_SecureChannel *channel, UA_UInt32 requestId, + const void *content, const UA_DataType *contentType); + +UA_StatusCode +UA_SecureChannel_sendSymmetricMessage(UA_SecureChannel *channel, UA_UInt32 requestId, + UA_MessageType messageType, void *payload, + const UA_DataType *payloadType); + +/* The MessageContext is forwarded into the encoding layer so that we can send + * chunks before continuing to encode. This lets us reuse a fixed chunk-sized + * messages buffer. */ +typedef struct { + UA_SecureChannel *channel; + UA_UInt32 requestId; + UA_UInt32 messageType; + + UA_UInt16 chunksSoFar; + size_t messageSizeSoFar; + + UA_ByteString messageBuffer; + UA_Byte *buf_pos; + const UA_Byte *buf_end; + + UA_Boolean final; +} UA_MessageContext; + +/* Start the context of a new symmetric message. */ +UA_StatusCode +UA_MessageContext_begin(UA_MessageContext *mc, UA_SecureChannel *channel, + UA_UInt32 requestId, UA_MessageType messageType); + +/* Encode the content and send out full chunks. If the return code is good, then + * the ChunkInfo contains encoded content that has not been sent. If the return + * code is bad, then the ChunkInfo has been cleaned up internally. */ +UA_StatusCode +UA_MessageContext_encode(UA_MessageContext *mc, const void *content, + const UA_DataType *contentType); + +/* Sends a symmetric message already encoded in the context. The context is + * cleaned up, also in case of errors. */ +UA_StatusCode +UA_MessageContext_finish(UA_MessageContext *mc); + +/* To be used when a failure occures when a MessageContext is open. Note that + * the _encode and _finish methods will clean up internally. _abort can be run + * on a MessageContext that has already been cleaned up before. */ +void +UA_MessageContext_abort(UA_MessageContext *mc); + +/** + * Receive Message + * --------------- */ + +typedef UA_StatusCode +(UA_ProcessMessageCallback)(void *application, UA_SecureChannel *channel, + UA_MessageType messageType, UA_UInt32 requestId, + UA_ByteString *message); + +/* Process a received buffer. The callback function is called with the message + * body if the message is complete. The message is removed afterwards. Returns + * if an irrecoverable error occured. + * + * Note that only MSG and CLO messages are decrypted. HEL/ACK/OPN/... are + * forwarded verbatim to the application. */ +UA_StatusCode +UA_SecureChannel_processBuffer(UA_SecureChannel *channel, void *application, + UA_ProcessMessageCallback callback, + const UA_ByteString *buffer); + +/* Try to receive at least one complete chunk on the connection. This blocks the + * current thread up to the given timeout. It will return once the first buffer + * has been received (and possibly processed when the message is complete). + * + * @param channel The SecureChannel + * @param application The client or server application + * @param callback The function pointer for processing complete messages + * @param timeout The timeout (in milliseconds) the method will block at most. + * @return Returns UA_STATUSCODE_GOOD or an error code. A timeout does not + * create an error. */ +UA_StatusCode +UA_SecureChannel_receive(UA_SecureChannel *channel, void *application, + UA_ProcessMessageCallback callback, UA_UInt32 timeout); + +/* Internal methods in ua_securechannel_crypto.h */ + +void +hideBytesAsym(const UA_SecureChannel *channel, UA_Byte **buf_start, + const UA_Byte **buf_end); + +/* Decrypt and verify via the signature. The chunk buffer is reused to hold the + * decrypted data after the MessageHeader and SecurityHeader. The chunk length + * is reduced by the signature, padding and encryption overhead. + * + * The offset argument points to the start of the encrypted content (beginning + * with the SequenceHeader).*/ +UA_StatusCode +decryptAndVerifyChunk(const UA_SecureChannel *channel, + const UA_SecurityPolicyCryptoModule *cryptoModule, + UA_MessageType messageType, UA_ByteString *chunk, + size_t offset); + +size_t +calculateAsymAlgSecurityHeaderLength(const UA_SecureChannel *channel); + +UA_StatusCode +prependHeadersAsym(UA_SecureChannel *const channel, UA_Byte *header_pos, + const UA_Byte *buf_end, size_t totalLength, + size_t securityHeaderLength, UA_UInt32 requestId, + size_t *const finalLength); + +void +setBufPos(UA_MessageContext *mc); + +UA_StatusCode +checkSymHeader(UA_SecureChannel *channel, const UA_UInt32 tokenId); + +UA_StatusCode +checkAsymHeader(UA_SecureChannel *channel, + const UA_AsymmetricAlgorithmSecurityHeader *asymHeader); + +void +padChunk(UA_SecureChannel *channel, const UA_SecurityPolicyCryptoModule *cm, + const UA_Byte *start, UA_Byte **pos); + +UA_StatusCode +signAndEncryptAsym(UA_SecureChannel *channel, size_t preSignLength, + UA_ByteString *buf, size_t securityHeaderLength, + size_t totalLength); + +UA_StatusCode +signAndEncryptSym(UA_MessageContext *messageContext, + size_t preSigLength, size_t totalLength); + +/** + * Log Helper + * ---------- + * C99 requires at least one element for the variadic argument. If the log + * statement has no variable arguments, supply an additional NULL. It will be + * ignored by printf. + * + * We have to jump through some hoops to enable the use of format strings + * without arguments since (pedantic) C99 does not allow variadic macros with + * zero arguments. So we add a dummy argument that is not printed (%.0s is + * string of length zero). */ + +#define UA_LOG_TRACE_CHANNEL_INTERNAL(LOGGER, CHANNEL, MSG, ...) \ + UA_LOG_TRACE(LOGGER, UA_LOGCATEGORY_SECURECHANNEL, \ + "Connection %i | SecureChannel %" PRIu32 " | " MSG "%.0s", \ + ((CHANNEL)->connection ? (int)((CHANNEL)->connection->sockfd) : 0), \ + (CHANNEL)->securityToken.channelId, __VA_ARGS__) + +#define UA_LOG_TRACE_CHANNEL(LOGGER, CHANNEL, ...) \ + UA_MACRO_EXPAND(UA_LOG_TRACE_CHANNEL_INTERNAL(LOGGER, CHANNEL, __VA_ARGS__, "")) + +#define UA_LOG_DEBUG_CHANNEL_INTERNAL(LOGGER, CHANNEL, MSG, ...) \ + UA_LOG_DEBUG(LOGGER, UA_LOGCATEGORY_SECURECHANNEL, \ + "Connection %i | SecureChannel %" PRIu32 " | " MSG "%.0s", \ + ((CHANNEL)->connection ? (int)((CHANNEL)->connection->sockfd) : 0), \ + (CHANNEL)->securityToken.channelId, __VA_ARGS__) + +#define UA_LOG_DEBUG_CHANNEL(LOGGER, CHANNEL, ...) \ + UA_MACRO_EXPAND(UA_LOG_DEBUG_CHANNEL_INTERNAL(LOGGER, CHANNEL, __VA_ARGS__, "")) + +#define UA_LOG_INFO_CHANNEL_INTERNAL(LOGGER, CHANNEL, MSG, ...) \ + UA_LOG_INFO(LOGGER, UA_LOGCATEGORY_SECURECHANNEL, \ + "Connection %i | SecureChannel %" PRIu32 " | " MSG "%.0s", \ + ((CHANNEL)->connection ? (int)((CHANNEL)->connection->sockfd) : 0), \ + (CHANNEL)->securityToken.channelId, __VA_ARGS__) + +#define UA_LOG_INFO_CHANNEL(LOGGER, CHANNEL, ...) \ + UA_MACRO_EXPAND(UA_LOG_INFO_CHANNEL_INTERNAL(LOGGER, CHANNEL, __VA_ARGS__, "")) + +#define UA_LOG_WARNING_CHANNEL_INTERNAL(LOGGER, CHANNEL, MSG, ...) \ + UA_LOG_WARNING(LOGGER, UA_LOGCATEGORY_SECURECHANNEL, \ + "Connection %i | SecureChannel %" PRIu32 " | " MSG "%.0s", \ + ((CHANNEL)->connection ? (int)((CHANNEL)->connection->sockfd) : 0), \ + (CHANNEL)->securityToken.channelId, __VA_ARGS__) + +#define UA_LOG_WARNING_CHANNEL(LOGGER, CHANNEL, ...) \ + UA_MACRO_EXPAND(UA_LOG_WARNING_CHANNEL_INTERNAL(LOGGER, CHANNEL, __VA_ARGS__, "")) + +#define UA_LOG_ERROR_CHANNEL_INTERNAL(LOGGER, CHANNEL, MSG, ...) \ + UA_LOG_ERROR(LOGGER, UA_LOGCATEGORY_SECURECHANNEL, \ + "Connection %i | SecureChannel %" PRIu32 " | " MSG "%.0s", \ + ((CHANNEL)->connection ? (int)((CHANNEL)->connection->sockfd) : 0), \ + (CHANNEL)->securityToken.channelId, __VA_ARGS__) + +#define UA_LOG_ERROR_CHANNEL(LOGGER, CHANNEL, ...) \ + UA_MACRO_EXPAND(UA_LOG_ERROR_CHANNEL_INTERNAL(LOGGER, CHANNEL, __VA_ARGS__, "")) + +#define UA_LOG_FATAL_CHANNEL_INTERNAL(LOGGER, CHANNEL, MSG, ...) \ + UA_LOG_FATAL(LOGGER, UA_LOGCATEGORY_SECURECHANNEL, \ + "Connection %i | SecureChannel %" PRIu32 " | " MSG "%.0s", \ + ((CHANNEL)->connection ? (CHANNEL)->connection->sockfd : 0), \ + (CHANNEL)->securityToken.channelId, __VA_ARGS__) + +#define UA_LOG_FATAL_CHANNEL(LOGGER, CHANNEL, ...) \ + UA_MACRO_EXPAND(UA_LOG_FATAL_CHANNEL_INTERNAL(LOGGER, CHANNEL, __VA_ARGS__, "")) + +_UA_END_DECLS + + +/**** amalgamated original file "/src/ua_timer.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017, 2018, 2021 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +_UA_BEGIN_DECLS + +/* The timer is protected by its own mutex. The mutex is released before calling + * into the callbacks. So the timer can be modified from the callbacks it is + * executing. Also, the timer mutex can never lead to locking. Because the timer + * mutex will be left without acquiring another mutex. + * + * Obviously, the timer must not be deleted from within one of its + * callbacks. */ + +/* Callback where the application is either a client or a server */ +typedef void (*UA_ApplicationCallback)(void *application, void *data); + +typedef struct UA_TimerEntry { + struct aa_entry treeEntry; + UA_TimerPolicy timerPolicy; /* Timer policy to handle cycle misses */ + UA_DateTime nextTime; /* The next time when the callback + * is to be executed */ + UA_UInt64 interval; /* Interval in 100ns resolution. If + the interval is zero, the + callback is not repeated and + removed after execution. */ + UA_ApplicationCallback callback; + void *application; + void *data; + + struct aa_entry idTreeEntry; + UA_UInt64 id; /* Id of the entry */ +} UA_TimerEntry; + +typedef struct { + struct aa_head root; /* The root of the time-sorted tree */ + struct aa_head idRoot; /* The root of the id-sorted tree */ + UA_UInt64 idCounter; /* Generate unique identifiers. Identifiers are + * always above zero. */ +#if UA_MULTITHREADING >= 100 + UA_Lock timerMutex; +#endif +} UA_Timer; + +void +UA_Timer_init(UA_Timer *t); + +UA_StatusCode +UA_Timer_addTimedCallback(UA_Timer *t, UA_ApplicationCallback callback, + void *application, void *data, UA_DateTime date, + UA_UInt64 *callbackId); + +/* Add a pre-allocated and pre-filled UA_TimerEntry. This cannot fail. It is + * used, for example, for delayed memory reclamation where the data structure + * begins with a UA_TimerEntry. */ +void +UA_Timer_addTimerEntry(UA_Timer *t, UA_TimerEntry *te, UA_UInt64 *callbackId); + +UA_StatusCode +UA_Timer_addRepeatedCallback(UA_Timer *t, UA_ApplicationCallback callback, + void *application, void *data, UA_Double interval_ms, + UA_DateTime *baseTime, UA_TimerPolicy timerPolicy, + UA_UInt64 *callbackId); + +UA_StatusCode +UA_Timer_changeRepeatedCallback(UA_Timer *t, UA_UInt64 callbackId, + UA_Double interval_ms, UA_DateTime *baseTime, + UA_TimerPolicy timerPolicy); + +void +UA_Timer_removeCallback(UA_Timer *t, UA_UInt64 callbackId); + +/* Process (dispatch) the repeated callbacks that have timed out. Returns the + * timestamp of the next scheduled repeated callback. Not thread-safe. + * Application is a pointer to the client / server environment for the callback. + * Dispatched is set to true when at least one callback was run / dispatched. */ +typedef void +(*UA_TimerExecutionCallback)(void *executionApplication, UA_ApplicationCallback cb, + void *callbackApplication, void *data); + +UA_DateTime +UA_Timer_process(UA_Timer *t, UA_DateTime nowMonotonic, + UA_TimerExecutionCallback executionCallback, + void *executionApplication); + +void +UA_Timer_clear(UA_Timer *t); + +_UA_END_DECLS + + +/**** amalgamated original file "/src/server/ua_session.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + + + +_UA_BEGIN_DECLS + +#define UA_MAXCONTINUATIONPOINTS 5 + +struct ContinuationPoint; +typedef struct ContinuationPoint ContinuationPoint; + +/* Returns the next entry in the linked list */ +ContinuationPoint * +ContinuationPoint_clear(ContinuationPoint *cp); + +struct UA_Subscription; +typedef struct UA_Subscription UA_Subscription; + +#ifdef UA_ENABLE_SUBSCRIPTIONS +typedef struct UA_PublishResponseEntry { + SIMPLEQ_ENTRY(UA_PublishResponseEntry) listEntry; + UA_UInt32 requestId; + UA_PublishResponse response; +} UA_PublishResponseEntry; +#endif + +typedef struct { + UA_SessionHeader header; + UA_ApplicationDescription clientDescription; + UA_String sessionName; + UA_Boolean activated; + void *sessionHandle; /* pointer assigned in userland-callback */ + UA_NodeId sessionId; + UA_UInt32 maxRequestMessageSize; + UA_UInt32 maxResponseMessageSize; + UA_Double timeout; /* in ms */ + UA_DateTime validTill; + UA_ByteString serverNonce; + + UA_UInt16 availableContinuationPoints; + ContinuationPoint *continuationPoints; + + size_t paramsSize; + UA_KeyValuePair *params; + +#ifdef UA_ENABLE_SUBSCRIPTIONS + size_t subscriptionsSize; + TAILQ_HEAD(, UA_Subscription) subscriptions; /* Late subscriptions that do eventually + * publish are moved to the tail. So that + * other late subscriptions are not + * starved. */ + SIMPLEQ_HEAD(, UA_PublishResponseEntry) responseQueue; + UA_UInt32 numPublishReq; + size_t totalRetransmissionQueueSize; /* Retransmissions of all subscriptions */ +#endif +} UA_Session; + +/** + * Session Lifecycle + * ----------------- */ + +void UA_Session_init(UA_Session *session); +void UA_Session_clear(UA_Session *session, UA_Server *server); +void UA_Session_attachToSecureChannel(UA_Session *session, UA_SecureChannel *channel); +void UA_Session_detachFromSecureChannel(UA_Session *session); +UA_StatusCode UA_Session_generateNonce(UA_Session *session); + +/* If any activity on a session happens, the timeout is extended */ +void UA_Session_updateLifetime(UA_Session *session); + +/** + * Subscription handling + * --------------------- */ + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +void +UA_Session_attachSubscription(UA_Session *session, UA_Subscription *sub); + +void +UA_Session_detachSubscription(UA_Server *server, UA_Session *session, + UA_Subscription *sub); + +UA_Subscription * +UA_Session_getSubscriptionById(UA_Session *session, + UA_UInt32 subscriptionId); + + +void +UA_Session_queuePublishReq(UA_Session *session, + UA_PublishResponseEntry* entry, + UA_Boolean head); + +UA_PublishResponseEntry * +UA_Session_dequeuePublishReq(UA_Session *session); + +#endif + +/** + * Log Helper + * ---------- + * We have to jump through some hoops to enable the use of format strings + * without arguments since (pedantic) C99 does not allow variadic macros with + * zero arguments. So we add a dummy argument that is not printed (%.0s is + * string of length zero). */ + +#define UA_LOG_SESSION_INTERNAL(LOGGER, LEVEL, SESSION, MSG, ...) \ + do { \ + UA_String idString = UA_STRING_NULL; \ + UA_UInt32 channelId = 0; \ + if(SESSION) { \ + UA_NodeId_print(&(SESSION)->sessionId, &idString); \ + channelId = (SESSION)->header.channel ? \ + (SESSION)->header.channel->securityToken.channelId : 0; \ + } \ + UA_LOG_##LEVEL(LOGGER, UA_LOGCATEGORY_SESSION, \ + "SecureChannel %" PRIu32 " | Session %.*s | " MSG "%.0s", \ + channelId, (int)idString.length, idString.data, __VA_ARGS__); \ + UA_String_clear(&idString); \ + } while(0) + +#if UA_LOGLEVEL <= 100 +# define UA_LOG_TRACE_SESSION(LOGGER, SESSION, ...) \ + UA_MACRO_EXPAND(UA_LOG_SESSION_INTERNAL(LOGGER, TRACE, SESSION, __VA_ARGS__, "")) +#else +# define UA_LOG_TRACE_SESSION(LOGGER, SESSION, ...) +#endif + +#if UA_LOGLEVEL <= 200 +# define UA_LOG_DEBUG_SESSION(LOGGER, SESSION, ...) \ + UA_MACRO_EXPAND(UA_LOG_SESSION_INTERNAL(LOGGER, DEBUG, SESSION, __VA_ARGS__, "")) +#else +# define UA_LOG_DEBUG_SESSION(LOGGER, SESSION, ...) +#endif + +#if UA_LOGLEVEL <= 300 +# define UA_LOG_INFO_SESSION(LOGGER, SESSION, ...) \ + UA_MACRO_EXPAND(UA_LOG_SESSION_INTERNAL(LOGGER, INFO, SESSION, __VA_ARGS__, "")) +#else +# define UA_LOG_INFO_SESSION(LOGGER, SESSION, ...) +#endif + +#if UA_LOGLEVEL <= 400 +# define UA_LOG_WARNING_SESSION(LOGGER, SESSION, ...) \ + UA_MACRO_EXPAND(UA_LOG_SESSION_INTERNAL(LOGGER, WARNING, SESSION, __VA_ARGS__, "")) +#else +# define UA_LOG_WARNING_SESSION(LOGGER, SESSION, ...) +#endif + +#if UA_LOGLEVEL <= 500 +# define UA_LOG_ERROR_SESSION(LOGGER, SESSION, ...) \ + UA_MACRO_EXPAND(UA_LOG_SESSION_INTERNAL(LOGGER, ERROR, SESSION, __VA_ARGS__, "")) +#else +# define UA_LOG_ERROR_SESSION(LOGGER, SESSION, ...) +#endif + +#if UA_LOGLEVEL <= 600 +# define UA_LOG_FATAL_SESSION(LOGGER, SESSION, ...) \ + UA_MACRO_EXPAND(UA_LOG_SESSION_INTERNAL(LOGGER, FATAL, SESSION, __VA_ARGS__, "")) +#else +# define UA_LOG_FATAL_SESSION(LOGGER, SESSION, ...) +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/src/server/ua_subscription.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2018, 2021 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Florian Palm + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Mattias Bornhager + * Copyright 2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + * Copyright 2020 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + * Copyright 2021 (c) Fraunhofer IOSB (Author: Andreas Ebner) + */ + + + + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +/* MonitoredItems create Notifications. Subscriptions collect Notifications from + * (several) MonitoredItems and publish them to the client. + * + * Notifications are put into two queues at the same time. One for the + * MonitoredItem that generated the notification. Here we can remove it if the + * space reserved for the MonitoredItem runs full. The second queue is the + * "global" queue for all Notifications generated in a Subscription. For + * publication, the notifications are taken out of the "global" queue in the + * order of their creation. */ + +/*****************/ +/* Notifications */ +/*****************/ + +/* Set to the TAILQ_NEXT pointer of a notification, the sentinel that the + * notification was not added to the global queue */ +#define UA_SUBSCRIPTION_QUEUE_SENTINEL ((UA_Notification*)0x01) + +typedef struct UA_Notification { + TAILQ_ENTRY(UA_Notification) localEntry; /* Notification list for the MonitoredItem */ + TAILQ_ENTRY(UA_Notification) globalEntry; /* Notification list for the Subscription */ + UA_MonitoredItem *mon; /* Always set */ + + /* The event field is used if mon->attributeId is the EventNotifier */ + union { + UA_MonitoredItemNotification dataChange; +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + UA_EventFieldList event; +#endif + } data; + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + UA_Boolean isOverflowEvent; /* Counted manually */ + UA_EventFilterResult result; +#endif +} UA_Notification; + +/* Initializes and sets the sentinel pointers */ +UA_Notification * UA_Notification_new(void); + +/* Notifications are always added to the queue of the MonitoredItem. That queue + * can overflow. If Notifications are reported, they are also added to the + * global queue of the Subscription. There they are picked up by the publishing + * callback. + * + * There are two ways Notifications can be put into the global queue of the + * Subscription: They are added because the MonitoringMode of the MonitoredItem + * is "reporting". Or the MonitoringMode is "sampling" and a link is trigered + * that puts the last Notification into the global queue. */ +void UA_Notification_enqueueAndTrigger(UA_Server *server, + UA_Notification *n); + +/* Dequeue and delete the notification */ +void UA_Notification_delete(UA_Notification *n); + +/* A NotificationMessage contains an array of notifications. + * Sent NotificationMessages are stored for the republish service. */ +typedef struct UA_NotificationMessageEntry { + TAILQ_ENTRY(UA_NotificationMessageEntry) listEntry; + UA_NotificationMessage message; +} UA_NotificationMessageEntry; + +/* Queue Definitions */ +typedef TAILQ_HEAD(NotificationQueue, UA_Notification) NotificationQueue; +typedef TAILQ_HEAD(NotificationMessageQueue, UA_NotificationMessageEntry) + NotificationMessageQueue; + +/*****************/ +/* MonitoredItem */ +/*****************/ + +struct UA_MonitoredItem { + UA_TimerEntry delayedFreePointers; + LIST_ENTRY(UA_MonitoredItem) listEntry; /* Linked list in the Subscription */ + UA_MonitoredItem *next; /* Linked list of MonitoredItems directly attached + * to a Node. Initialized to ~0 to indicate that the + * MonitoredItem is not added to a node. */ + UA_Subscription *subscription; /* If NULL, then this is a Local MonitoredItem */ + UA_UInt32 monitoredItemId; + + /* Status and Settings */ + UA_ReadValueId itemToMonitor; + UA_MonitoringMode monitoringMode; + UA_TimestampsToReturn timestampsToReturn; + UA_Boolean sampleCallbackIsRegistered; + UA_Boolean registered; /* Registered in the server / Subscription */ + UA_DateTime triggeredUntil; /* If the MonitoringMode is SAMPLING, a + * triggered MonitoredItem puts the next + * Notification into the global queue (of the + * Subscription) for publishing. But triggering + * is only active for the duration of one + * publishin cycle. */ + + /* If the filter is a UA_DataChangeFilter: The DataChangeFilter always + * contains an absolute deadband definition. Part 8, §6.2 gives the + * following formula to test for percentage deadbands: + * + * DataChange if (absolute value of (last cached value - current value) + * > (deadbandValue/100.0) * ((high–low) of EURange))) + * + * So we can convert from a percentage to an absolute deadband and keep + * the hot code path simple. + * + * TODO: Store the percentage deadband to recompute when the UARange is + * changed at runtime of the MonitoredItem */ + UA_MonitoringParameters parameters; + + /* Sampling Callback */ + UA_UInt64 sampleCallbackId; + UA_DataValue lastValue; + + /* Triggering Links */ + size_t triggeringLinksSize; + UA_UInt32 *triggeringLinks; + + /* Notification Queue */ + NotificationQueue queue; + size_t queueSize; /* This is the current size. See also the configured + * (maximum) queueSize in the parameters. */ + size_t eventOverflows; /* Separate counter for the queue. Can at most double + * the queue size */ +}; + +void UA_MonitoredItem_init(UA_MonitoredItem *mon); + +void +UA_MonitoredItem_delete(UA_Server *server, UA_MonitoredItem *monitoredItem); + +void +UA_MonitoredItem_removeOverflowInfoBits(UA_MonitoredItem *mon); + +void +UA_Server_registerMonitoredItem(UA_Server *server, UA_MonitoredItem *mon); + +/* Register sampling. Either by adding a repeated callback or by adding the + * MonitoredItem to a linked list in the node. */ +UA_StatusCode +UA_MonitoredItem_registerSampling(UA_Server *server, UA_MonitoredItem *mon); + +void +UA_MonitoredItem_unregisterSampling(UA_Server *server, + UA_MonitoredItem *mon); + +UA_StatusCode +UA_MonitoredItem_setMonitoringMode(UA_Server *server, UA_MonitoredItem *mon, + UA_MonitoringMode monitoringMode); + +void +UA_MonitoredItem_sampleCallback(UA_Server *server, + UA_MonitoredItem *monitoredItem); + +UA_StatusCode +sampleCallbackWithValue(UA_Server *server, UA_Subscription *sub, + UA_MonitoredItem *mon, UA_DataValue *value); + +UA_StatusCode +UA_MonitoredItem_removeLink(UA_Subscription *sub, UA_MonitoredItem *mon, + UA_UInt32 linkId); + +UA_StatusCode +UA_MonitoredItem_addLink(UA_Subscription *sub, UA_MonitoredItem *mon, + UA_UInt32 linkId); + +UA_StatusCode +UA_MonitoredItem_createDataChangeNotification(UA_Server *server, + UA_Subscription *sub, + UA_MonitoredItem *mon, + const UA_DataValue *value); + +UA_StatusCode +UA_Event_addEventToMonitoredItem(UA_Server *server, const UA_NodeId *event, + UA_MonitoredItem *mon); + +UA_StatusCode +UA_Event_generateEventId(UA_ByteString *generatedId); + +void +UA_Event_staticSelectClauseValidation(UA_Server *server, + const UA_EventFilter *eventFilter, + UA_StatusCode *result); + +UA_StatusCode +UA_Event_staticWhereClauseValidation(UA_Server *server, + const UA_ContentFilter *filter, + UA_ContentFilterResult *); + +/* Remove entries until mon->maxQueueSize is reached. Sets infobits for lost + * data if required. */ +void +UA_MonitoredItem_ensureQueueSpace(UA_Server *server, UA_MonitoredItem *mon); + +/****************/ +/* Subscription */ +/****************/ + +/* We use only a subset of the states defined in the standard */ +typedef enum { + /* UA_SUBSCRIPTIONSTATE_CLOSED */ + /* UA_SUBSCRIPTIONSTATE_CREATING */ + UA_SUBSCRIPTIONSTATE_NORMAL, + UA_SUBSCRIPTIONSTATE_LATE, + UA_SUBSCRIPTIONSTATE_KEEPALIVE +} UA_SubscriptionState; + +/* Subscriptions are managed in a server-wide linked list. If they are attached + * to a Session, then they are additionaly in the per-Session linked-list. A + * subscription is always generated for a Session. But the CloseSession Service + * may keep Subscriptions intact beyond the Session lifetime. They can then be + * re-bound to a new Session with the TransferSubscription Service. */ +struct UA_Subscription { + UA_TimerEntry delayedFreePointers; + LIST_ENTRY(UA_Subscription) serverListEntry; + TAILQ_ENTRY(UA_Subscription) sessionListEntry; /* Only set if session != NULL */ + UA_Session *session; /* May be NULL if no session is attached. */ + UA_UInt32 subscriptionId; + + /* Settings */ + UA_UInt32 lifeTimeCount; + UA_UInt32 maxKeepAliveCount; + UA_Double publishingInterval; /* in ms */ + UA_UInt32 notificationsPerPublish; + UA_Boolean publishingEnabled; + UA_UInt32 priority; + + /* Runtime information */ + UA_SubscriptionState state; + UA_StatusCode statusChange; /* If set, a notification is generated and the + * Subscription is deleted within + * UA_Subscription_publish. */ + UA_UInt32 nextSequenceNumber; + UA_UInt32 currentKeepAliveCount; + UA_UInt32 currentLifetimeCount; + + /* Publish Callback. Registered if id > 0. */ + UA_UInt64 publishCallbackId; + + /* MonitoredItems */ + UA_UInt32 lastMonitoredItemId; /* increase the identifiers */ + LIST_HEAD(, UA_MonitoredItem) monitoredItems; + UA_UInt32 monitoredItemsSize; + + /* Global list of notifications from the MonitoredItems */ + TAILQ_HEAD(, UA_Notification) notificationQueue; + UA_UInt32 notificationQueueSize; /* Total queue size */ + UA_UInt32 dataChangeNotifications; + UA_UInt32 eventNotifications; + + /* Notifications to be sent out now (already late). In a regular publish + * callback, all queued notifications are sent out. In a late publish + * response, only the notifications left from the last regular publish + * callback are sent. */ + UA_UInt32 readyNotifications; + + /* Retransmission Queue */ + NotificationMessageQueue retransmissionQueue; + size_t retransmissionQueueSize; +}; + +UA_Subscription * UA_Subscription_new(void); + +void +UA_Subscription_delete(UA_Server *server, UA_Subscription *sub); + +UA_StatusCode +Subscription_registerPublishCallback(UA_Server *server, + UA_Subscription *sub); + +void +Subscription_unregisterPublishCallback(UA_Server *server, + UA_Subscription *sub); + +UA_MonitoredItem * +UA_Subscription_getMonitoredItem(UA_Subscription *sub, + UA_UInt32 monitoredItemId); + +void +UA_Subscription_publish(UA_Server *server, UA_Subscription *sub); + +UA_StatusCode +UA_Subscription_removeRetransmissionMessage(UA_Subscription *sub, + UA_UInt32 sequenceNumber); + +UA_Boolean +UA_Session_reachedPublishReqLimit(UA_Server *server, UA_Session *session); + +/* Forward declaration for A&C used in ua_server_internal.h" */ +struct UA_ConditionSource; +typedef struct UA_ConditionSource UA_ConditionSource; + +/***********/ +/* Helpers */ +/***********/ + +/* Evaluate content filter, Only for unit testing */ +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS +UA_StatusCode +UA_Server_evaluateWhereClauseContentFilter(UA_Server *server, UA_Session *session, + const UA_NodeId *eventNode, + const UA_ContentFilter *contentFilter, + UA_ContentFilterResult *contentFilterResult); +#endif + +/* Setting an integer value within bounds */ +#define UA_BOUNDEDVALUE_SETWBOUNDS(BOUNDS, SRC, DST) { \ + if(SRC > BOUNDS.max) DST = BOUNDS.max; \ + else if(SRC < BOUNDS.min) DST = BOUNDS.min; \ + else DST = SRC; \ + } + +/* Logging + * See a description of the tricks used in ua_session.h */ +#define UA_LOG_SUBSCRIPTION_INTERNAL(LOGGER, LEVEL, SUB, MSG, ...) do { \ + UA_String idString = UA_STRING_NULL; \ + if((SUB) && (SUB)->session) { \ + UA_NodeId_print(&(SUB)->session->sessionId, &idString); \ + UA_LOG_##LEVEL(LOGGER, UA_LOGCATEGORY_SESSION, \ + "SecureChannel %" PRIu32 " | Session %.*s | Subscription %" PRIu32 " | " MSG "%.0s", \ + ((SUB)->session->header.channel ? \ + (SUB)->session->header.channel->securityToken.channelId : 0), \ + (int)idString.length, idString.data, (SUB)->subscriptionId, __VA_ARGS__); \ + UA_String_clear(&idString); \ + } else { \ + UA_LOG_##LEVEL(LOGGER, UA_LOGCATEGORY_SERVER, \ + "Subscription %" PRIu32 " | " MSG "%.0s", \ + (SUB) ? (SUB)->subscriptionId : 0, __VA_ARGS__); \ + } \ +} while(0) + +#if UA_LOGLEVEL <= 100 +# define UA_LOG_TRACE_SUBSCRIPTION(LOGGER, SUB, ...) \ + UA_MACRO_EXPAND(UA_LOG_SUBSCRIPTION_INTERNAL(LOGGER, TRACE, SUB, __VA_ARGS__, "")) +#else +# define UA_LOG_TRACE_SUBSCRIPTION(LOGGER, SUB, ...) do {} while(0) +#endif + +#if UA_LOGLEVEL <= 200 +# define UA_LOG_DEBUG_SUBSCRIPTION(LOGGER, SUB, ...) \ + UA_MACRO_EXPAND(UA_LOG_SUBSCRIPTION_INTERNAL(LOGGER, DEBUG, SUB, __VA_ARGS__, "")) +#else +# define UA_LOG_DEBUG_SUBSCRIPTION(LOGGER, SUB, ...) do {} while(0) +#endif + +#if UA_LOGLEVEL <= 300 +# define UA_LOG_INFO_SUBSCRIPTION(LOGGER, SUB, ...) \ + UA_MACRO_EXPAND(UA_LOG_SUBSCRIPTION_INTERNAL(LOGGER, INFO, SUB, __VA_ARGS__, "")) +#else +# define UA_LOG_INFO_SUBSCRIPTION(LOGGER, SUB, ...) do {} while(0) +#endif + +#if UA_LOGLEVEL <= 400 +# define UA_LOG_WARNING_SUBSCRIPTION(LOGGER, SUB, ...) \ + UA_MACRO_EXPAND(UA_LOG_SUBSCRIPTION_INTERNAL(LOGGER, WARNING, SUB, __VA_ARGS__, "")) +#else +# define UA_LOG_WARNING_SUBSCRIPTION(LOGGER, SUB, ...) do {} while(0) +#endif + +#if UA_LOGLEVEL <= 500 +# define UA_LOG_ERROR_SUBSCRIPTION(LOGGER, SUB, ...) \ + UA_MACRO_EXPAND(UA_LOG_SUBSCRIPTION_INTERNAL(LOGGER, ERROR, SUB, __VA_ARGS__, "")) +#else +# define UA_LOG_ERROR_SUBSCRIPTION(LOGGER, SUB, ...) do {} while(0) +#endif + +#if UA_LOGLEVEL <= 600 +# define UA_LOG_FATAL_SUBSCRIPTION(LOGGER, SUB, ...) \ + UA_MACRO_EXPAND(UA_LOG_SUBSCRIPTION_INTERNAL(LOGGER, FATAL, SUB, __VA_ARGS__, "")) +#else +# define UA_LOG_FATAL_SUBSCRIPTION(LOGGER, SUB, ...) do {} while(0) +#endif + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +_UA_END_DECLS + + +/**** amalgamated original file "/src/pubsub/ua_pubsub_networkmessage.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017 - 2018 Fraunhofer IOSB (Author: Tino Bischoff) + * Copyright (c) 2017-2019 Fraunhofer IOSB (Author: Andreas Ebner) + */ + + + +_UA_BEGIN_DECLS + +/* DataSet Payload Header */ +typedef struct { + UA_Byte count; + UA_UInt16* dataSetWriterIds; +} UA_DataSetPayloadHeader; + +/* FieldEncoding Enum */ +typedef enum { + UA_FIELDENCODING_VARIANT = 0, + UA_FIELDENCODING_RAWDATA = 1, + UA_FIELDENCODING_DATAVALUE = 2, + UA_FIELDENCODING_UNKNOWN = 3 +} UA_FieldEncoding; + +/* DataSetMessage Type */ +typedef enum { + UA_DATASETMESSAGE_DATAKEYFRAME = 0, + UA_DATASETMESSAGE_DATADELTAFRAME = 1, + UA_DATASETMESSAGE_EVENT = 2, + UA_DATASETMESSAGE_KEEPALIVE = 3 +} UA_DataSetMessageType; + +/* DataSetMessage Header */ +typedef struct { + UA_Boolean dataSetMessageValid; + UA_FieldEncoding fieldEncoding; + UA_Boolean dataSetMessageSequenceNrEnabled; + UA_Boolean timestampEnabled; + UA_Boolean statusEnabled; + UA_Boolean configVersionMajorVersionEnabled; + UA_Boolean configVersionMinorVersionEnabled; + UA_DataSetMessageType dataSetMessageType; + UA_Boolean picoSecondsIncluded; + UA_UInt16 dataSetMessageSequenceNr; + UA_UtcTime timestamp; + UA_UInt16 picoSeconds; + UA_UInt16 status; + UA_UInt32 configVersionMajorVersion; + UA_UInt32 configVersionMinorVersion; +} UA_DataSetMessageHeader; + +/** + * DataSetMessage + * ^^^^^^^^^^^^^^ */ + +typedef struct { + UA_UInt16 fieldCount; + UA_DataValue* dataSetFields; + UA_ByteString rawFields; + /* Json keys for the dataSetFields: TODO: own dataSetMessageType for json? */ + UA_String* fieldNames; +} UA_DataSetMessage_DataKeyFrameData; + +typedef struct { + UA_UInt16 fieldIndex; + UA_DataValue fieldValue; +} UA_DataSetMessage_DeltaFrameField; + +typedef struct { + UA_UInt16 fieldCount; + UA_DataSetMessage_DeltaFrameField* deltaFrameFields; +} UA_DataSetMessage_DataDeltaFrameData; + +typedef struct { + UA_DataSetMessageHeader header; + union { + UA_DataSetMessage_DataKeyFrameData keyFrameData; + UA_DataSetMessage_DataDeltaFrameData deltaFrameData; + } data; +} UA_DataSetMessage; + +typedef struct { + UA_UInt16* sizes; + UA_DataSetMessage* dataSetMessages; +} UA_DataSetPayload; + +typedef enum { + UA_PUBLISHERDATATYPE_BYTE = 0, + UA_PUBLISHERDATATYPE_UINT16 = 1, + UA_PUBLISHERDATATYPE_UINT32 = 2, + UA_PUBLISHERDATATYPE_UINT64 = 3, + UA_PUBLISHERDATATYPE_STRING = 4 +} UA_PublisherIdDatatype; + +typedef enum { + UA_NETWORKMESSAGE_DATASET = 0, + UA_NETWORKMESSAGE_DISCOVERY_REQUEST = 1, + UA_NETWORKMESSAGE_DISCOVERY_RESPONSE = 2 +} UA_NetworkMessageType; + +/** + * UA_NetworkMessageGroupHeader + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ +typedef struct { + UA_Boolean writerGroupIdEnabled; + UA_Boolean groupVersionEnabled; + UA_Boolean networkMessageNumberEnabled; + UA_Boolean sequenceNumberEnabled; + UA_UInt16 writerGroupId; + UA_UInt32 groupVersion; // spec: type "VersionTime" + UA_UInt16 networkMessageNumber; + UA_UInt16 sequenceNumber; +} UA_NetworkMessageGroupHeader; + +/** + * UA_NetworkMessageSecurityHeader + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ +typedef struct { + UA_Boolean networkMessageSigned; + UA_Boolean networkMessageEncrypted; + UA_Boolean securityFooterEnabled; + UA_Boolean forceKeyReset; + UA_UInt32 securityTokenId; // spec: IntegerId + UA_ByteString messageNonce; + UA_UInt16 securityFooterSize; +} UA_NetworkMessageSecurityHeader; + +/** + * UA_NetworkMessage + * ^^^^^^^^^^^^^^^^^ */ +typedef struct { + UA_Byte version; + UA_Boolean messageIdEnabled; + UA_String messageId; /* For Json NetworkMessage */ + UA_Boolean publisherIdEnabled; + UA_Boolean groupHeaderEnabled; + UA_Boolean payloadHeaderEnabled; + UA_PublisherIdDatatype publisherIdType; + UA_Boolean dataSetClassIdEnabled; + UA_Boolean securityEnabled; + UA_Boolean timestampEnabled; + UA_Boolean picosecondsEnabled; + UA_Boolean chunkMessage; + UA_Boolean promotedFieldsEnabled; + UA_NetworkMessageType networkMessageType; + union { + UA_Byte publisherIdByte; + UA_UInt16 publisherIdUInt16; + UA_UInt32 publisherIdUInt32; + UA_UInt64 publisherIdUInt64; + UA_Guid publisherIdGuid; + UA_String publisherIdString; + } publisherId; + UA_Guid dataSetClassId; + + UA_NetworkMessageGroupHeader groupHeader; + + union { + UA_DataSetPayloadHeader dataSetPayloadHeader; + } payloadHeader; + + UA_DateTime timestamp; + UA_UInt16 picoseconds; + UA_UInt16 promotedFieldsSize; + UA_Variant* promotedFields; /* BaseDataType */ + + UA_NetworkMessageSecurityHeader securityHeader; + + union { + UA_DataSetPayload dataSetPayload; + } payload; + + UA_ByteString securityFooter; +} UA_NetworkMessage; + +/**********************************************/ +/* Network Message Offsets */ +/**********************************************/ + +/* Offsets for buffered messages in the PubSub fast path. */ +typedef enum { + UA_PUBSUB_OFFSETTYPE_DATASETMESSAGE_SEQUENCENUMBER, + UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_SEQUENCENUMBER, + UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_FIELDENCDODING, + UA_PUBSUB_OFFSETTYPE_TIMESTAMP_PICOSECONDS, + UA_PUBSUB_OFFSETTYPE_TIMESTAMP, /* source pointer */ + UA_PUBSUB_OFFSETTYPE_TIMESTAMP_NOW, /* no source */ + UA_PUBSUB_OFFSETTYPE_PAYLOAD_DATAVALUE, + UA_PUBSUB_OFFSETTYPE_PAYLOAD_VARIANT, + UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW, + /* For subscriber RT */ + UA_PUBSUB_OFFSETTYPE_PUBLISHERID, + UA_PUBSUB_OFFSETTYPE_WRITERGROUPID, + UA_PUBSUB_OFFSETTYPE_DATASETWRITERID + /* Add more offset types as needed */ +} UA_NetworkMessageOffsetType; + +typedef struct { + UA_NetworkMessageOffsetType contentType; + union { + struct { + UA_DataValue *value; + size_t valueBinarySize; + } value; + UA_DateTime *timestamp; + } offsetData; + size_t offset; +} UA_NetworkMessageOffset; + +typedef struct { + UA_ByteString buffer; /* The precomputed message buffer */ + UA_NetworkMessageOffset *offsets; /* Offsets for changes in the message buffer */ + size_t offsetsSize; + UA_Boolean RTsubscriberEnabled; /* Addtional offsets computation like publisherId, WGId if this bool enabled */ + UA_NetworkMessage *nm; /* The precomputed NetworkMessage for subscriber */ + size_t rawMessageLength; +} UA_NetworkMessageOffsetBuffer; + +/** + * DataSetMessage + * ^^^^^^^^^^^^^^ */ + +UA_StatusCode +UA_DataSetMessageHeader_encodeBinary(const UA_DataSetMessageHeader* src, + UA_Byte **bufPos, const UA_Byte *bufEnd); + +UA_StatusCode +UA_DataSetMessageHeader_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_DataSetMessageHeader* dst); + +size_t +UA_DataSetMessageHeader_calcSizeBinary(const UA_DataSetMessageHeader* p); + +UA_StatusCode +UA_DataSetMessage_encodeBinary(const UA_DataSetMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd); + +UA_StatusCode +UA_DataSetMessage_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_DataSetMessage* dst, UA_UInt16 dsmSize); + +size_t +UA_DataSetMessage_calcSizeBinary(UA_DataSetMessage *p, UA_NetworkMessageOffsetBuffer *offsetBuffer, + size_t currentOffset); + +void UA_DataSetMessage_clear(const UA_DataSetMessage* p); + +/** + * NetworkMessage + * ^^^^^^^^^^^^^^ */ + +UA_StatusCode +UA_NetworkMessage_updateBufferedMessage(UA_NetworkMessageOffsetBuffer *buffer); + +UA_StatusCode +UA_NetworkMessage_updateBufferedNwMessage(UA_NetworkMessageOffsetBuffer *buffer, + const UA_ByteString *src, size_t *bufferPosition); + + +/** + * NetworkMessage Encoding + * ^^^^^^^^^^^^^^^^^^^^^^^ */ + +/* If dataToEncryptStart not-NULL, then it will be set to the start-position of + * the payload in the buffer. */ +UA_StatusCode +UA_NetworkMessage_encodeBinary(const UA_NetworkMessage* src, + UA_Byte **bufPos, const UA_Byte *bufEnd, + UA_Byte **dataToEncryptStart); + +UA_StatusCode +UA_NetworkMessage_encodeHeaders(const UA_NetworkMessage* src, + UA_Byte **bufPos, const UA_Byte *bufEnd); + +UA_StatusCode +UA_NetworkMessage_encodePayload(const UA_NetworkMessage* src, + UA_Byte **bufPos, const UA_Byte *bufEnd); + +UA_StatusCode +UA_NetworkMessage_encodeFooters(const UA_NetworkMessage* src, + UA_Byte **bufPos, const UA_Byte *bufEnd); + +/** + * NetworkMessage Decoding + * ^^^^^^^^^^^^^^^^^^^^^^^ */ + +UA_StatusCode +UA_NetworkMessage_decodeHeaders(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst); + +UA_StatusCode +UA_NetworkMessage_decodePayload(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst); + +UA_StatusCode +UA_NetworkMessage_decodeFooters(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst); + +UA_StatusCode +UA_NetworkMessage_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_NetworkMessage* dst); + + +UA_StatusCode +UA_NetworkMessageHeader_decodeBinary(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst); + +size_t +UA_NetworkMessage_calcSizeBinary(UA_NetworkMessage *p, + UA_NetworkMessageOffsetBuffer *offsetBuffer); + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + +UA_StatusCode +UA_NetworkMessage_signEncrypt(UA_NetworkMessage *nm, UA_MessageSecurityMode securityMode, + UA_PubSubSecurityPolicy *policy, void *policyContext, + UA_Byte *messageStart, UA_Byte *encryptStart, + UA_Byte *sigStart); +#endif + +void +UA_NetworkMessage_clear(UA_NetworkMessage* p); + +void +UA_NetworkMessage_delete(UA_NetworkMessage* p); + + +#ifdef UA_ENABLE_JSON_ENCODING +UA_StatusCode +UA_NetworkMessage_encodeJson(const UA_NetworkMessage *src, + UA_Byte **bufPos, const UA_Byte **bufEnd, UA_String *namespaces, + size_t namespaceSize, UA_String *serverUris, + size_t serverUriSize, UA_Boolean useReversible); + +size_t +UA_NetworkMessage_calcSizeJson(const UA_NetworkMessage *src, + UA_String *namespaces, size_t namespaceSize, + UA_String *serverUris, size_t serverUriSize, + UA_Boolean useReversible); + +UA_StatusCode UA_NetworkMessage_decodeJson(UA_NetworkMessage *dst, const UA_ByteString *src); +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/src/pubsub/ua_pubsub.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2018 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019 Kalycito Infotech Private Limited + * Copyright (c) 2020 Yannick Wallerer, Siemens AG + * Copyright (c) 2020 Thomas Fischer, Siemens AG + * Copyright (c) 2021 Fraunhofer IOSB (Author: Jan Hermes) + */ + + + + +/* The public configuration structs are defined in include/ua_plugin_pubsub.h */ + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_PUBSUB + +struct UA_WriterGroup; +typedef struct UA_WriterGroup UA_WriterGroup; + +struct UA_ReaderGroup; +typedef struct UA_ReaderGroup UA_ReaderGroup; + +/**********************************************/ +/* PublishedDataSet */ +/**********************************************/ + +typedef struct UA_PublishedDataSet { + UA_PublishedDataSetConfig config; + UA_DataSetMetaDataType dataSetMetaData; + TAILQ_HEAD(UA_ListOfDataSetField, UA_DataSetField) fields; + UA_NodeId identifier; + UA_UInt16 fieldSize; + UA_UInt16 promotedFieldsCount; + UA_UInt16 configurationFreezeCounter; + TAILQ_ENTRY(UA_PublishedDataSet) listEntry; + UA_Boolean configurationFrozen; +} UA_PublishedDataSet; + +UA_StatusCode +UA_PublishedDataSetConfig_copy(const UA_PublishedDataSetConfig *src, + UA_PublishedDataSetConfig *dst); + +UA_PublishedDataSet * +UA_PublishedDataSet_findPDSbyId(UA_Server *server, UA_NodeId identifier); + +void +UA_PublishedDataSet_clear(UA_Server *server, + UA_PublishedDataSet *publishedDataSet); + +/**********************************************/ +/* Connection */ +/**********************************************/ + +typedef struct UA_PubSubConnection { + UA_PubSubComponentEnumType componentType; + UA_PubSubConnectionConfig *config; + UA_PubSubChannel *channel; + UA_NodeId identifier; + LIST_HEAD(UA_ListOfWriterGroup, UA_WriterGroup) writerGroups; + size_t writerGroupsSize; + LIST_HEAD(UA_ListOfPubSubReaderGroup, UA_ReaderGroup) readerGroups; + size_t readerGroupsSize; + TAILQ_ENTRY(UA_PubSubConnection) listEntry; + UA_UInt16 configurationFreezeCounter; + UA_Boolean isRegistered; /* Subscriber requires connection channel regist */ + UA_Boolean configurationFrozen; +} UA_PubSubConnection; + +UA_StatusCode +UA_PubSubConnectionConfig_copy(const UA_PubSubConnectionConfig *src, + UA_PubSubConnectionConfig *dst); + +UA_PubSubConnection * +UA_PubSubConnection_findConnectionbyId(UA_Server *server, + UA_NodeId connectionIdentifier); + +void +UA_PubSubConnectionConfig_clear(UA_PubSubConnectionConfig *connectionConfig); + +void +UA_PubSubConnection_clear(UA_Server *server, UA_PubSubConnection *connection); + +/* Register channel for given connectionIdentifier */ +UA_StatusCode +UA_PubSubConnection_regist(UA_Server *server, UA_NodeId *connectionIdentifier); + +/* Process Network Message for a ReaderGroup. But we the ReaderGroup needs to be + * identified first. */ +UA_StatusCode +UA_Server_processNetworkMessage(UA_Server *server, + UA_PubSubConnection *connection, + UA_NetworkMessage *msg); + +/**********************************************/ +/* DataSetWriter */ +/**********************************************/ + +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES +typedef struct UA_DataSetWriterSample { + UA_Boolean valueChanged; + UA_DataValue value; +} UA_DataSetWriterSample; +#endif + +typedef struct UA_DataSetWriter { + UA_PubSubComponentEnumType componentType; + UA_DataSetWriterConfig config; + LIST_ENTRY(UA_DataSetWriter) listEntry; + UA_NodeId identifier; + UA_NodeId linkedWriterGroup; + UA_NodeId connectedDataSet; + UA_ConfigurationVersionDataType connectedDataSetVersion; + UA_PubSubState state; +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES + UA_UInt16 deltaFrameCounter; /* count of sent deltaFrames */ + size_t lastSamplesCount; + UA_DataSetWriterSample *lastSamples; +#endif + UA_UInt16 actualDataSetMessageSequenceCount; + UA_Boolean configurationFrozen; +} UA_DataSetWriter; + +UA_StatusCode +UA_DataSetWriterConfig_copy(const UA_DataSetWriterConfig *src, + UA_DataSetWriterConfig *dst); + +UA_DataSetWriter * +UA_DataSetWriter_findDSWbyId(UA_Server *server, UA_NodeId identifier); + +UA_StatusCode +UA_DataSetWriter_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_DataSetWriter *dataSetWriter); + +UA_StatusCode +UA_DataSetWriter_generateDataSetMessage(UA_Server *server, + UA_DataSetMessage *dataSetMessage, + UA_DataSetWriter *dataSetWriter); + +UA_StatusCode +UA_DataSetWriter_remove(UA_Server *server, UA_WriterGroup *linkedWriterGroup, + UA_DataSetWriter *dataSetWriter); + +/**********************************************/ +/* WriterGroup */ +/**********************************************/ + +struct UA_WriterGroup { + UA_PubSubComponentEnumType componentType; + UA_WriterGroupConfig config; + LIST_ENTRY(UA_WriterGroup) listEntry; + UA_NodeId identifier; + UA_PubSubConnection *linkedConnection; + LIST_HEAD(UA_ListOfDataSetWriter, UA_DataSetWriter) writers; + UA_UInt32 writersCount; + UA_UInt64 publishCallbackId; + UA_Boolean publishCallbackIsRegistered; + UA_PubSubState state; + UA_NetworkMessageOffsetBuffer bufferedMessage; + UA_UInt16 sequenceNumber; /* Increased after every succressuly sent message */ + UA_Boolean configurationFrozen; + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + UA_UInt32 securityTokenId; + UA_UInt32 nonceSequenceNumber; /* To be part of the MessageNonce */ + void *securityPolicyContext; +#endif +}; + +UA_StatusCode +UA_WriterGroupConfig_copy(const UA_WriterGroupConfig *src, + UA_WriterGroupConfig *dst); + +UA_WriterGroup * +UA_WriterGroup_findWGbyId(UA_Server *server, UA_NodeId identifier); + +UA_StatusCode +UA_WriterGroup_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_WriterGroup *writerGroup); + +/**********************************************/ +/* DataSetField */ +/**********************************************/ + +typedef struct UA_DataSetField { + UA_DataSetFieldConfig config; + TAILQ_ENTRY(UA_DataSetField) listEntry; + UA_NodeId identifier; + UA_NodeId publishedDataSet; /* parent pds */ + UA_FieldMetaData fieldMetaData; /* contains the dataSetFieldId */ + UA_UInt64 sampleCallbackId; + UA_Boolean sampleCallbackIsRegistered; + UA_Boolean configurationFrozen; +} UA_DataSetField; + +UA_StatusCode +UA_DataSetFieldConfig_copy(const UA_DataSetFieldConfig *src, + UA_DataSetFieldConfig *dst); + +UA_DataSetField * +UA_DataSetField_findDSFbyId(UA_Server *server, UA_NodeId identifier); + +/**********************************************/ +/* DataSetReader */ +/**********************************************/ + +/* DataSetReader Type definition */ +typedef struct UA_DataSetReader { + UA_PubSubComponentEnumType componentType; + UA_DataSetReaderConfig config; + UA_NodeId identifier; + UA_NodeId linkedReaderGroup; + LIST_ENTRY(UA_DataSetReader) listEntry; + + UA_PubSubState state; /* non std */ + UA_Boolean configurationFrozen; + UA_NetworkMessageOffsetBuffer bufferedMessage; + +#ifdef UA_ENABLE_PUBSUB_MONITORING + /* MessageReceiveTimeout handling */ + UA_ServerCallback msgRcvTimeoutTimerCallback; + UA_UInt64 msgRcvTimeoutTimerId; + UA_Boolean msgRcvTimeoutTimerRunning; +#endif +} UA_DataSetReader; + +/* Process Network Message using DataSetReader */ +void +UA_DataSetReader_process(UA_Server *server, + UA_ReaderGroup *readerGroup, + UA_DataSetReader *dataSetReader, + UA_DataSetMessage *dataSetMsg); + +/* Copy the configuration of DataSetReader */ +UA_StatusCode UA_DataSetReaderConfig_copy(const UA_DataSetReaderConfig *src, + UA_DataSetReaderConfig *dst); + +/* Clear the configuration of a DataSetReader */ +void UA_DataSetReaderConfig_clear(UA_DataSetReaderConfig *cfg); + +/* Copy the configuration of Target Variables */ +UA_StatusCode UA_TargetVariables_copy(const UA_TargetVariables *src, + UA_TargetVariables *dst); + +/* Clear the Target Variables configuration */ +void UA_TargetVariables_clear(UA_TargetVariables *subscribedDataSetTarget); + +/* Copy the configuration of Field Target Variables */ +UA_StatusCode UA_FieldTargetVariable_copy(const UA_FieldTargetVariable *src, + UA_FieldTargetVariable *dst); + +UA_StatusCode +UA_DataSetReader_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_DataSetReader *dataSetReader); + +#ifdef UA_ENABLE_PUBSUB_MONITORING +/* Check if DataSetReader has a message receive timeout */ +void +UA_DataSetReader_checkMessageReceiveTimeout(UA_Server *server, + UA_DataSetReader *dataSetReader); + +/* DataSetReader MessageReceiveTimeout callback for generic PubSub component + * timeout handling */ +void +UA_DataSetReader_handleMessageReceiveTimeout(UA_Server *server, + void *dataSetReader); +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + +UA_StatusCode +UA_DataSetReader_generateNetworkMessage(UA_PubSubConnection *pubSubConnection, + UA_DataSetReader *dataSetReader, + UA_DataSetMessage *dsm, UA_UInt16 *writerId, + UA_Byte dsmCount, UA_NetworkMessage *nm); + +UA_StatusCode +UA_DataSetReader_generateDataSetMessage(UA_Server *server, + UA_DataSetMessage *dataSetMessage, + UA_DataSetReader *dataSetReader); + +/**********************************************/ +/* ReaderGroup */ +/**********************************************/ + +struct UA_ReaderGroup { + UA_PubSubComponentEnumType componentType; + UA_ReaderGroupConfig config; + UA_NodeId identifier; + UA_NodeId linkedConnection; + LIST_ENTRY(UA_ReaderGroup) listEntry; + LIST_HEAD(UA_ListOfPubSubDataSetReader, UA_DataSetReader) readers; + /* for simplified information access */ + UA_UInt32 readersCount; + UA_UInt64 subscribeCallbackId; + UA_PubSubState state; + UA_Boolean configurationFrozen; + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + UA_UInt32 securityTokenId; + UA_UInt32 nonceSequenceNumber; /* To be part of the MessageNonce */ + void *securityPolicyContext; +#endif +}; + +UA_StatusCode +UA_ReaderGroupConfig_copy(const UA_ReaderGroupConfig *src, + UA_ReaderGroupConfig *dst); + +/* Prototypes for internal util functions - some functions maybe removed later + * (currently moved from public to internal) */ +UA_ReaderGroup * +UA_ReaderGroup_findRGbyId(UA_Server *server, UA_NodeId identifier); + +UA_DataSetReader * +UA_ReaderGroup_findDSRbyId(UA_Server *server, UA_NodeId identifier); + +UA_StatusCode +UA_ReaderGroup_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_ReaderGroup *readerGroup); + +/*********************************************************/ +/* PublishValues handling */ +/*********************************************************/ + +UA_StatusCode +UA_WriterGroup_addPublishCallback(UA_Server *server, UA_WriterGroup *writerGroup); + +void +UA_WriterGroup_publishCallback(UA_Server *server, UA_WriterGroup *writerGroup); + +/*********************************************************/ +/* SubscribeValues handling */ +/*********************************************************/ + +UA_StatusCode +UA_ReaderGroup_addSubscribeCallback(UA_Server *server, UA_ReaderGroup *readerGroup); + +void +UA_ReaderGroup_removeSubscribeCallback(UA_Server *server, UA_ReaderGroup *readerGroup); + +void +UA_ReaderGroup_subscribeCallback(UA_Server *server, UA_ReaderGroup *readerGroup); + +/*********************************************************/ +/* Reading Message handling */ +/*********************************************************/ + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION +UA_StatusCode +verifyAndDecrypt(const UA_Logger *logger, UA_ByteString *buffer, + const size_t *currentPosition, const UA_NetworkMessage *nm, + UA_Boolean doValidate, UA_Boolean doDecrypt, + void *channelContext, UA_PubSubSecurityPolicy *securityPolicy); + +UA_StatusCode +verifyAndDecryptNetworkMessage(const UA_Logger *logger, UA_ByteString *buffer, + size_t *currentPosition, UA_NetworkMessage *nm, + UA_ReaderGroup *readerGroup); +#endif + +/* Takes a value (and not a pointer) to the buffer. The original buffer is + const. Internally we may adjust the length during decryption. */ +UA_StatusCode +decodeNetworkMessage(UA_Server *server, UA_ByteString *buffer, size_t *pos, + UA_NetworkMessage *nm, UA_PubSubConnection *connection); + +UA_StatusCode +receiveBufferedNetworkMessage(UA_Server *server, UA_ReaderGroup *readerGroup, + UA_PubSubConnection *connection); + +#endif /* UA_ENABLE_PUBSUB */ + +_UA_END_DECLS + + +/**** amalgamated original file "/src/pubsub/ua_pubsub_manager.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2019 Fraunhofer IOSB (Author: Andreas Ebner) + */ + + + + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_PUBSUB /* conditional compilation */ + +typedef struct UA_PubSubManager { + /* Connections and PublishedDataSets can exist alone (own lifecycle) -> top + * level components */ + size_t connectionsSize; + TAILQ_HEAD(UA_ListOfPubSubConnection, UA_PubSubConnection) connections; + + size_t publishedDataSetsSize; + TAILQ_HEAD(UA_ListOfPublishedDataSet, UA_PublishedDataSet) publishedDataSets; + +#ifndef UA_ENABLE_PUBSUB_INFORMATIONMODEL + UA_UInt32 uniqueIdCount; +#endif +} UA_PubSubManager; + +void +UA_PubSubManager_delete(UA_Server *server, UA_PubSubManager *pubSubManager); + +#ifndef UA_ENABLE_PUBSUB_INFORMATIONMODEL +void +UA_PubSubManager_generateUniqueNodeId(UA_PubSubManager *psm, UA_NodeId *nodeId); +#endif + +UA_Guid +UA_PubSubManager_generateUniqueGuid(UA_Server *server); + +UA_UInt32 +UA_PubSubConfigurationVersionTimeDifference(void); + +/***********************************/ +/* PubSub Jobs abstraction */ +/***********************************/ +UA_StatusCode +UA_PubSubManager_addRepeatedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_Double interval_ms, UA_DateTime *baseTime, + UA_TimerPolicy timerPolicy, UA_UInt64 *callbackId); +UA_StatusCode +UA_PubSubManager_changeRepeatedCallback(UA_Server *server, UA_UInt64 callbackId, + UA_Double interval_ms, UA_DateTime *baseTime, + UA_TimerPolicy timerPolicy); +void +UA_PubSubManager_removeRepeatedPubSubCallback(UA_Server *server, UA_UInt64 callbackId); + +/*************************************************/ +/* PubSub component monitoring */ +/*************************************************/ + +#ifdef UA_ENABLE_PUBSUB_MONITORING + +UA_StatusCode +UA_PubSubManager_setDefaultMonitoringCallbacks(UA_PubSubMonitoringInterface *monitoringInterface); + +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + +#endif /* UA_ENABLE_PUBSUB */ + +_UA_END_DECLS + + +/**** amalgamated original file "/src/pubsub/ua_pubsub_ns0.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2018 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019 Kalycito Infotech Private Limited + */ + +#ifndef UA_PUBSUB_NS0_H_ +#define UA_PUBSUB_NS0_H_ + + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL /* conditional compilation */ + +UA_StatusCode +UA_Server_initPubSubNS0(UA_Server *server); + +UA_StatusCode +addPubSubConnectionRepresentation(UA_Server *server, UA_PubSubConnection *connection); + +UA_StatusCode +removePubSubConnectionRepresentation(UA_Server *server, UA_PubSubConnection *connection); + +UA_StatusCode +addWriterGroupRepresentation(UA_Server *server, UA_WriterGroup *writerGroup); + +UA_StatusCode +addReaderGroupRepresentation(UA_Server *server, UA_ReaderGroup *readerGroup); + +UA_StatusCode +removeGroupRepresentation(UA_Server *server, UA_WriterGroup *writerGroup); + +UA_StatusCode +addDataSetWriterRepresentation(UA_Server *server, UA_DataSetWriter *dataSetWriter); + +UA_StatusCode +removeDataSetWriterRepresentation(UA_Server *server, UA_DataSetWriter *dataSetWriter); + +UA_StatusCode +addPublishedDataItemsRepresentation(UA_Server *server, UA_PublishedDataSet *publishedDataSet); + +UA_StatusCode +removePublishedDataSetRepresentation(UA_Server *server, UA_PublishedDataSet *publishedDataSet); + +UA_StatusCode +addDataSetReaderRepresentation(UA_Server *server, UA_DataSetReader *dataSetReader); + +UA_StatusCode +removeDataSetReaderRepresentation(UA_Server *server, UA_DataSetReader *dataSetReader); + +UA_StatusCode +removeReaderGroupRepresentation(UA_Server *server, UA_ReaderGroup *readerGroup); + +#endif /* UA_ENABLE_PUBSUB_INFORMATIONMODEL */ + +_UA_END_DECLS + +#endif /* UA_PUBSUB_NS0_H_ */ + +/**** amalgamated original file "/src/server/ua_server_async.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2019 (c) Fraunhofer IOSB (Author: Klaus Schick) + * based on + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2017 (c) Florian Palm + * Copyright 2015 (c) Sten Grüner + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + + +_UA_BEGIN_DECLS + +#if UA_MULTITHREADING >= 100 + +struct UA_AsyncResponse; +typedef struct UA_AsyncResponse UA_AsyncResponse; + +/* A single operation (of a larger request) */ +typedef struct UA_AsyncOperation { + TAILQ_ENTRY(UA_AsyncOperation) pointers; + UA_CallMethodRequest request; + UA_CallMethodResult response; + size_t index; /* Index of the operation in the array of ops in + * request/response */ + UA_AsyncResponse *parent; /* Always non-NULL. The parent is only removed + * when its operations are removed */ +} UA_AsyncOperation; + +struct UA_AsyncResponse { + TAILQ_ENTRY(UA_AsyncResponse) pointers; /* Insert new at the end */ + UA_UInt32 requestId; + UA_NodeId sessionId; + UA_UInt32 requestHandle; + UA_DateTime timeout; + UA_AsyncOperationType operationType; + union { + UA_CallResponse callResponse; + UA_ReadResponse readResponse; + UA_WriteResponse writeResponse; + } response; + UA_UInt32 opCountdown; /* Counter for outstanding operations. The AR can + * only be deleted when all have returned. */ +}; + +typedef TAILQ_HEAD(UA_AsyncOperationQueue, UA_AsyncOperation) UA_AsyncOperationQueue; + +typedef struct { + /* Requests / Responses */ + TAILQ_HEAD(, UA_AsyncResponse) asyncResponses; + size_t asyncResponsesCount; + + /* Operations for the workers. The queues are all FIFO: Put in at the tail, + * take out at the head.*/ + UA_Lock queueLock; + UA_AsyncOperationQueue newQueue; /* New operations for the workers */ + UA_AsyncOperationQueue dispatchedQueue; /* Operations taken by a worker. When a result is + * returned, we search for the op here to see if it + * is still "alive" (not timed out). */ + UA_AsyncOperationQueue resultQueue; /* Results to be integrated */ + size_t opsCount; /* How many operations are transient (in one of the three queues)? */ + + UA_UInt64 checkTimeoutCallbackId; /* Registered repeated callbacks */ +} UA_AsyncManager; + +void UA_AsyncManager_init(UA_AsyncManager *am, UA_Server *server); +void UA_AsyncManager_clear(UA_AsyncManager *am, UA_Server *server); + +UA_StatusCode +UA_AsyncManager_createAsyncResponse(UA_AsyncManager *am, UA_Server *server, + const UA_NodeId *sessionId, + const UA_UInt32 requestId, + const UA_UInt32 requestHandle, + const UA_AsyncOperationType operationType, + UA_AsyncResponse **outAr); + +/* Only remove the AsyncResponse when the operation count is zero */ +void +UA_AsyncManager_removeAsyncResponse(UA_AsyncManager *am, UA_AsyncResponse *ar); + +UA_StatusCode +UA_AsyncManager_createAsyncOp(UA_AsyncManager *am, UA_Server *server, + UA_AsyncResponse *ar, size_t opIndex, + const UA_CallMethodRequest *opRequest); + +typedef void (*UA_AsyncServiceOperation)(UA_Server *server, UA_Session *session, + UA_UInt32 requestId, UA_UInt32 requestHandle, + size_t opIndex, const void *requestOperation, + void *responseOperation, UA_AsyncResponse **ar); + +/* Creates an AsyncResponse in-situ when an async operation is encountered. If + * that is the case, the sync responses are moved to the AsyncResponse. */ +UA_StatusCode +UA_Server_processServiceOperationsAsync(UA_Server *server, UA_Session *session, + UA_UInt32 requestId, UA_UInt32 requestHandle, + UA_AsyncServiceOperation operationCallback, + const size_t *requestOperations, + const UA_DataType *requestOperationsType, + size_t *responseOperations, + const UA_DataType *responseOperationsType, + UA_AsyncResponse **ar) +UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +#endif /* UA_MULTITHREADING >= 100 */ + +_UA_END_DECLS + + +/**** amalgamated original file "/src/server/ua_server_internal.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2019 (c) Fraunhofer IOSB (Author: Klaus Schick) + * Copyright 2014-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2017 (c) Florian Palm + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Julian Grothoff + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + + + +_UA_BEGIN_DECLS + +#if UA_MULTITHREADING >= 100 +#undef UA_THREADSAFE +#define UA_THREADSAFE UA_DEPRECATED +#endif + +#ifdef UA_ENABLE_PUBSUB +#endif + +#ifdef UA_ENABLE_DISCOVERY +#endif + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +typedef struct { + UA_MonitoredItem monitoredItem; + void *context; + union { + UA_Server_DataChangeNotificationCallback dataChangeCallback; + /* UA_Server_EventNotificationCallback eventCallback; */ + } callback; +} UA_LocalMonitoredItem; + +#endif + +typedef enum { + UA_DIAGNOSTICEVENT_CLOSE, + UA_DIAGNOSTICEVENT_REJECT, + UA_DIAGNOSTICEVENT_SECURITYREJECT, + UA_DIAGNOSTICEVENT_TIMEOUT, + UA_DIAGNOSTICEVENT_ABORT, + UA_DIAGNOSTICEVENT_PURGE +} UA_DiagnosticEvent; + +typedef struct channel_entry { + UA_TimerEntry cleanupCallback; + TAILQ_ENTRY(channel_entry) pointers; + UA_SecureChannel channel; +} channel_entry; + +typedef struct session_list_entry { + UA_TimerEntry cleanupCallback; + LIST_ENTRY(session_list_entry) pointers; + UA_Session session; +} session_list_entry; + +typedef enum { + UA_SERVERLIFECYCLE_FRESH, + UA_SERVERLIFECYLE_RUNNING +} UA_ServerLifecycle; + +struct UA_Server { + /* Config */ + UA_ServerConfig config; + UA_DateTime startTime; + UA_DateTime endTime; /* Zeroed out. If a time is set, then the server shuts + * down once the time has been reached */ + + UA_ServerLifecycle state; + + /* SecureChannels */ + TAILQ_HEAD(, channel_entry) channels; + UA_UInt32 lastChannelId; + UA_UInt32 lastTokenId; + +#if UA_MULTITHREADING >= 100 + UA_AsyncManager asyncManager; +#endif + + /* Session Management */ + LIST_HEAD(session_list, session_list_entry) sessions; + UA_UInt32 sessionCount; + UA_Session adminSession; /* Local access to the services (for startup and + * maintenance) uses this Session with all possible + * access rights (Session Id: 1) */ + + /* Namespaces */ + size_t namespacesSize; + UA_String *namespaces; + + /* Callbacks with a repetition interval */ + UA_Timer timer; + + /* For bootstrapping, omit some consistency checks, creating a reference to + * the parent and member instantiation */ + UA_Boolean bootstrapNS0; + + /* Discovery */ +#ifdef UA_ENABLE_DISCOVERY + UA_DiscoveryManager discoveryManager; +#endif + + /* Subscriptions */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + size_t subscriptionsSize; /* Number of active subscriptions */ + size_t monitoredItemsSize; /* Number of active monitored items */ + LIST_HEAD(, UA_Subscription) subscriptions; /* All subscriptions in the + * server. They may be detached + * from a session. */ + UA_UInt32 lastSubscriptionId; /* To generate unique SubscriptionIds */ + + /* To be cast to UA_LocalMonitoredItem to get the callback and context */ + LIST_HEAD(, UA_MonitoredItem) localMonitoredItems; + UA_UInt32 lastLocalMonitoredItemId; + +# ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS + LIST_HEAD(, UA_ConditionSource) conditionSources; +# endif + +#endif + + /* Publish/Subscribe */ +#ifdef UA_ENABLE_PUBSUB + UA_PubSubManager pubSubManager; +#endif + +#if UA_MULTITHREADING >= 100 + UA_Lock networkMutex; + UA_Lock serviceMutex; +#endif + + /* Statistics */ + UA_ServerStatistics serverStats; +}; + +/***********************/ +/* References Handling */ +/***********************/ + +extern const struct aa_head refNameTree; + +const UA_ReferenceTarget * +UA_NodeReferenceKind_findTarget(const UA_NodeReferenceKind *rk, + const UA_ExpandedNodeId *targetId); + +/**************************/ +/* SecureChannel Handling */ +/**************************/ + +/* Remove all securechannels */ +void +UA_Server_deleteSecureChannels(UA_Server *server); + +/* Remove timed out securechannels with a delayed callback. So all currently + * scheduled jobs with a pointer to a securechannel can finish first. */ +void +UA_Server_cleanupTimedOutSecureChannels(UA_Server *server, UA_DateTime nowMonotonic); + +UA_StatusCode +UA_Server_createSecureChannel(UA_Server *server, UA_Connection *connection); + +UA_StatusCode +UA_Server_configSecureChannel(void *application, UA_SecureChannel *channel, + const UA_AsymmetricAlgorithmSecurityHeader *asymHeader); + +UA_StatusCode +sendServiceFault(UA_SecureChannel *channel, UA_UInt32 requestId, UA_UInt32 requestHandle, + const UA_DataType *responseType, UA_StatusCode statusCode); + +void +UA_Server_closeSecureChannel(UA_Server *server, UA_SecureChannel *channel, + UA_DiagnosticEvent event); + +/* Gets the a pointer to the context of a security policy supported by the + * server matched by the security policy uri. */ +UA_SecurityPolicy * +getSecurityPolicyByUri(const UA_Server *server, + const UA_ByteString *securityPolicyUri); + + +/********************/ +/* Session Handling */ +/********************/ + +UA_StatusCode +getNamespaceByName(UA_Server *server, const UA_String namespaceUri, + size_t *foundIndex); + +UA_StatusCode +getBoundSession(UA_Server *server, const UA_SecureChannel *channel, + const UA_NodeId *token, UA_Session **session); + +UA_StatusCode +UA_Server_createSession(UA_Server *server, UA_SecureChannel *channel, + const UA_CreateSessionRequest *request, UA_Session **session); + +void +UA_Server_removeSession(UA_Server *server, session_list_entry *sentry, + UA_DiagnosticEvent event); + +UA_StatusCode +UA_Server_removeSessionByToken(UA_Server *server, const UA_NodeId *token, + UA_DiagnosticEvent event); + +void +UA_Server_cleanupSessions(UA_Server *server, UA_DateTime nowMonotonic); + +UA_Session * +getSessionByToken(UA_Server *server, const UA_NodeId *token); + +UA_Session * +UA_Server_getSessionById(UA_Server *server, const UA_NodeId *sessionId); + +/*****************/ +/* Node Handling */ +/*****************/ + +/* Calls the callback with the node retrieved from the nodestore on top of the + * stack. Either a copy or the original node for in-situ editing. Depends on + * multithreading and the nodestore.*/ +typedef UA_StatusCode (*UA_EditNodeCallback)(UA_Server*, UA_Session*, + UA_Node *node, void*); +UA_StatusCode UA_Server_editNode(UA_Server *server, UA_Session *session, + const UA_NodeId *nodeId, + UA_EditNodeCallback callback, + void *data); + +/*********************/ +/* Utility Functions */ +/*********************/ + +void setupNs1Uri(UA_Server *server); +UA_UInt16 addNamespace(UA_Server *server, const UA_String name); + +UA_Boolean +UA_Node_hasSubTypeOrInstances(const UA_NodeHead *head); + +/* Recursively searches "upwards" in the tree following specific reference types */ +UA_Boolean +isNodeInTree(UA_Server *server, const UA_NodeId *leafNode, + const UA_NodeId *nodeToFind, const UA_ReferenceTypeSet *relevantRefs); + +/* Convenience function with just a single ReferenceTypeIndex */ +UA_Boolean +isNodeInTree_singleRef(UA_Server *server, const UA_NodeId *leafNode, + const UA_NodeId *nodeToFind, const UA_Byte relevantRefTypeIndex); + +/* Returns an array with the hierarchy of nodes. The start nodes can be returned + * as well. The returned array starts at the leaf and continues "upwards" or + * "downwards". Duplicate entries are removed. */ +UA_StatusCode +browseRecursive(UA_Server *server, size_t startNodesSize, const UA_NodeId *startNodes, + UA_BrowseDirection browseDirection, const UA_ReferenceTypeSet *refTypes, + UA_UInt32 nodeClassMask, UA_Boolean includeStartNodes, + size_t *resultsSize, UA_ExpandedNodeId **results); + +/* Get the bitfield indices of a ReferenceType and possibly its subtypes. + * refType must point to a ReferenceTypeNode. */ +UA_StatusCode +referenceTypeIndices(UA_Server *server, const UA_NodeId *refType, + UA_ReferenceTypeSet *indices, UA_Boolean includeSubtypes); + +/* Returns the recursive type and interface hierarchy of the node */ +UA_StatusCode +getParentTypeAndInterfaceHierarchy(UA_Server *server, const UA_NodeId *typeNode, + UA_NodeId **typeHierarchy, size_t *typeHierarchySize); + +/* Returns the recursive interface hierarchy of the node */ +UA_StatusCode +getAllInterfaceChildNodeIds(UA_Server *server, const UA_NodeId *objectNode, const UA_NodeId *objectTypeNode, + UA_NodeId **interfaceChildNodes, size_t *interfaceChildNodesSize); + +#ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS + +UA_StatusCode +UA_getConditionId(UA_Server *server, const UA_NodeId *conditionNodeId, + UA_NodeId *outConditionId); + +void +UA_ConditionList_delete(UA_Server *server); + +UA_Boolean +isConditionOrBranch(UA_Server *server, + const UA_NodeId *condition, + const UA_NodeId *conditionSource, + UA_Boolean *isCallerAC); + +#endif /* UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS */ + +/* Returns the type node from the node on the stack top. The type node is pushed + * on the stack and returned. */ +const UA_Node * +getNodeType(UA_Server *server, const UA_NodeHead *nodeHead); + +UA_StatusCode +sendResponse(UA_Server *server, UA_Session *session, UA_SecureChannel *channel, + UA_UInt32 requestId, UA_Response *response, const UA_DataType *responseType); + +/* Many services come as an array of operations. This function generalizes the + * processing of the operations. */ +typedef void (*UA_ServiceOperation)(UA_Server *server, UA_Session *session, + const void *context, + const void *requestOperation, + void *responseOperation); + +UA_StatusCode +UA_Server_processServiceOperations(UA_Server *server, UA_Session *session, + UA_ServiceOperation operationCallback, + const void *context, + const size_t *requestOperations, + const UA_DataType *requestOperationsType, + size_t *responseOperations, + const UA_DataType *responseOperationsType) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +/******************************************/ +/* Internal function calls, without locks */ +/******************************************/ +UA_StatusCode +deleteNode(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean deleteReferences); + +UA_StatusCode +addNode(UA_Server *server, const UA_NodeClass nodeClass, const UA_NodeId *requestedNewNodeId, + const UA_NodeId *parentNodeId, const UA_NodeId *referenceTypeId, + const UA_QualifiedName browseName, const UA_NodeId *typeDefinition, + const UA_NodeAttributes *attr, const UA_DataType *attributeType, + void *nodeContext, UA_NodeId *outNewNodeId); + +UA_StatusCode +setVariableNode_dataSource(UA_Server *server, const UA_NodeId nodeId, + const UA_DataSource dataSource); + +UA_StatusCode +writeAttribute(UA_Server *server, UA_Session *session, + const UA_NodeId *nodeId, const UA_AttributeId attributeId, + const void *attr, const UA_DataType *attr_type); + +static UA_INLINE UA_StatusCode +writeValueAttribute(UA_Server *server, UA_Session *session, + const UA_NodeId *nodeId, const UA_Variant *value) { + return writeAttribute(server, session, nodeId, UA_ATTRIBUTEID_VALUE, + value, &UA_TYPES[UA_TYPES_VARIANT]); +} + +UA_DataValue +readAttribute(UA_Server *server, const UA_ReadValueId *item, + UA_TimestampsToReturn timestamps); + +UA_StatusCode +readWithReadValue(UA_Server *server, const UA_NodeId *nodeId, + const UA_AttributeId attributeId, void *v); + +UA_StatusCode +readObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + UA_Variant *value); + +UA_BrowsePathResult +translateBrowsePathToNodeIds(UA_Server *server, const UA_BrowsePath *browsePath); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +void monitoredItem_sampleCallback(UA_Server *server, UA_MonitoredItem *monitoredItem); + +UA_Subscription * +UA_Server_getSubscriptionById(UA_Server *server, UA_UInt32 subscriptionId); + +UA_StatusCode +triggerEvent(UA_Server *server, const UA_NodeId eventNodeId, + const UA_NodeId origin, UA_ByteString *outEventId, + const UA_Boolean deleteEventNode); + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +UA_BrowsePathResult +browseSimplifiedBrowsePath(UA_Server *server, const UA_NodeId origin, + size_t browsePathSize, const UA_QualifiedName *browsePath); + +UA_StatusCode +writeObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, const UA_Variant value); + +UA_StatusCode +getNodeContext(UA_Server *server, UA_NodeId nodeId, void **nodeContext); + +void +removeCallback(UA_Server *server, UA_UInt64 callbackId); + +UA_StatusCode +changeRepeatedCallbackInterval(UA_Server *server, UA_UInt64 callbackId, UA_Double interval_ms); + +UA_StatusCode +addRepeatedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_Double interval_ms, UA_UInt64 *callbackId); + +#ifdef UA_ENABLE_DISCOVERY +UA_StatusCode +register_server_with_discovery_server(UA_Server *server, + void *client, + const UA_Boolean isUnregister, + const char* semaphoreFilePath); +#endif + +/***********/ +/* RefTree */ +/***********/ + +/* A RefTree is a sorted set of NodeIds that ensures we consider each node just + * once. It holds a single array for both the ExpandedNodeIds and the entries of + * a tree-structure for fast lookup. A single realloc operation (with some + * pointer repairing) can be used to increase the capacity of the RefTree. + * + * When the RefTree is complete, the tree-part at the end of the targets array + * can be ignored / cut away to use it as a simple ExpandedNodeId array. + * + * The layout of the targets array is as follows: + * + * | Targets [ExpandedNodeId, n times] | Tree [RefEntry, n times] | */ + +#define UA_REFTREE_INITIAL_SIZE 16 + +typedef struct RefEntry { + ZIP_ENTRY(RefEntry) zipfields; + const UA_ExpandedNodeId *target; + UA_UInt32 targetHash; /* Hash of the target nodeid */ +} RefEntry; + +ZIP_HEAD(RefHead, RefEntry); +typedef struct RefHead RefHead; + +typedef struct { + UA_ExpandedNodeId *targets; + RefHead head; + size_t capacity; /* available space */ + size_t size; /* used space */ +} RefTree; + +UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT +RefTree_init(RefTree *rt); + +void RefTree_clear(RefTree *rt); + +UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT +RefTree_addNodeId(RefTree *rt, const UA_NodeId *target, UA_Boolean *duplicate); + +UA_Boolean +RefTree_contains(RefTree *rt, const UA_ExpandedNodeId *target); + +UA_Boolean +RefTree_containsNodeId(RefTree *rt, const UA_NodeId *target); + +/***************************************/ +/* Check Information Model Consistency */ +/***************************************/ + +/* Read a node attribute in the context of a "checked-out" node. So the + * attribute will not be copied when possible. The variant then points into the + * node and has UA_VARIANT_DATA_NODELETE set. */ +void +ReadWithNode(const UA_Node *node, UA_Server *server, UA_Session *session, + UA_TimestampsToReturn timestampsToReturn, + const UA_ReadValueId *id, UA_DataValue *v); + +UA_StatusCode +readValueAttribute(UA_Server *server, UA_Session *session, + const UA_VariableNode *vn, UA_DataValue *v); + +/* Test whether the value matches a variable definition given by + * - datatype + * - valueranke + * - array dimensions. + * Sometimes it can be necessary to transform the content of the value, e.g. + * byte array to bytestring or uint32 to some enum. If editableValue is non-NULL, + * we try to create a matching variant that points to the original data. */ +UA_Boolean +compatibleValue(UA_Server *server, UA_Session *session, const UA_NodeId *targetDataTypeId, + UA_Int32 targetValueRank, size_t targetArrayDimensionsSize, + const UA_UInt32 *targetArrayDimensions, const UA_Variant *value, + const UA_NumericRange *range); + +/* Is the DataType compatible */ +UA_Boolean +compatibleDataTypes(UA_Server *server, const UA_NodeId *dataType, + const UA_NodeId *constraintDataType); + +/* Set to the target type if compatible */ +void +adjustValueType(UA_Server *server, UA_Variant *value, + const UA_NodeId *targetDataTypeId); + +/* Is the Value compatible with the DataType? Can perform additional checks + * compared to compatibleDataTypes. */ +UA_Boolean +compatibleValueDataType(UA_Server *server, const UA_DataType *dataType, + const UA_NodeId *constraintDataType); + + +UA_Boolean +compatibleArrayDimensions(size_t constraintArrayDimensionsSize, + const UA_UInt32 *constraintArrayDimensions, + size_t testArrayDimensionsSize, + const UA_UInt32 *testArrayDimensions); + +UA_Boolean +compatibleValueArrayDimensions(const UA_Variant *value, size_t targetArrayDimensionsSize, + const UA_UInt32 *targetArrayDimensions); + +UA_Boolean +compatibleValueRankArrayDimensions(UA_Server *server, UA_Session *session, + UA_Int32 valueRank, size_t arrayDimensionsSize); + +UA_Boolean +compatibleValueRanks(UA_Int32 valueRank, UA_Int32 constraintValueRank); + +struct BrowseOpts { + UA_UInt32 maxReferences; + UA_Boolean recursive; +}; + +void +Operation_Browse(UA_Server *server, UA_Session *session, const UA_UInt32 *maxrefs, + const UA_BrowseDescription *descr, UA_BrowseResult *result); + +UA_DataValue +UA_Server_readWithSession(UA_Server *server, UA_Session *session, + const UA_ReadValueId *item, + UA_TimestampsToReturn timestampsToReturn); + +/*****************************/ +/* AddNodes Begin and Finish */ +/*****************************/ + +/* Creates a new node in the nodestore. */ +UA_StatusCode +AddNode_raw(UA_Server *server, UA_Session *session, void *nodeContext, + const UA_AddNodesItem *item, UA_NodeId *outNewNodeId); + +/* Check the reference to the parent node; Add references. */ +UA_StatusCode +AddNode_addRefs(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId, + const UA_NodeId *parentNodeId, const UA_NodeId *referenceTypeId, + const UA_NodeId *typeDefinitionId); + +/* Type-check type-definition; Run the constructors */ +UA_StatusCode +AddNode_finish(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId); + +/**********************/ +/* Create Namespace 0 */ +/**********************/ + +UA_StatusCode UA_Server_initNS0(UA_Server *server); + +UA_StatusCode writeNs0VariableArray(UA_Server *server, UA_UInt32 id, void *v, + size_t length, const UA_DataType *type); + +/***************************/ +/* Nodestore Access Macros */ +/***************************/ + +#define UA_NODESTORE_NEW(server, nodeClass) \ + server->config.nodestore.newNode(server->config.nodestore.context, nodeClass) + +#define UA_NODESTORE_DELETE(server, node) \ + server->config.nodestore.deleteNode(server->config.nodestore.context, node) + +#define UA_NODESTORE_GET(server, nodeid) \ + server->config.nodestore.getNode(server->config.nodestore.context, nodeid) + +/* Returns NULL if the target is an external Reference (per the ExpandedNodeId) */ +const UA_Node * +UA_NODESTORE_GETFROMREF(UA_Server *server, UA_NodePointer target); + +#define UA_NODESTORE_RELEASE(server, node) \ + server->config.nodestore.releaseNode(server->config.nodestore.context, node) + +#define UA_NODESTORE_GETCOPY(server, nodeid, outnode) \ + server->config.nodestore.getNodeCopy(server->config.nodestore.context, \ + nodeid, outnode) + +#define UA_NODESTORE_INSERT(server, node, addedNodeId) \ + server->config.nodestore.insertNode(server->config.nodestore.context, \ + node, addedNodeId) + +#define UA_NODESTORE_REPLACE(server, node) \ + server->config.nodestore.replaceNode(server->config.nodestore.context, node) + +#define UA_NODESTORE_REMOVE(server, nodeId) \ + server->config.nodestore.removeNode(server->config.nodestore.context, nodeId) + +#define UA_NODESTORE_GETREFERENCETYPEID(server, index) \ + server->config.nodestore.getReferenceTypeId(server->config.nodestore.context, \ + index) + +_UA_END_DECLS + + +/**** amalgamated original file "/src/server/ua_services.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2017 (c) Florian Palm + * Copyright 2015 (c) Sten Grüner + * Copyright 2014 (c) LEvertz + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015 (c) Christian Fimmers + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + + +_UA_BEGIN_DECLS + +/** + * .. _services: + * + * Services + * ======== + * + * In OPC UA, all communication is based on service calls, each consisting of a + * request and a response message. These messages are defined as data structures + * with a binary encoding and listed in :ref:`generated-types`. Since all + * Services are pre-defined in the standard, they cannot be modified by the + * user. But you can use the :ref:`Call ` service to invoke + * user-defined methods on the server. + * + * The following service signatures are internal and *not visible to users*. + * Still, we present them here for an overview of the capabilities of OPC UA. + * Please refer to the :ref:`client` and :ref:`server` API where the services + * are exposed to end users. Please see part 4 of the OPC UA standard for the + * authoritative definition of the service and their behaviour. + * + * Most services take as input the server, the current session and pointers to + * the request and response structures. Possible error codes are returned as + * part of the response. */ + +typedef void (*UA_Service)(UA_Server*, UA_Session*, + const void *request, void *response); + +typedef void (*UA_ChannelService)(UA_Server*, UA_SecureChannel*, + const void *request, void *response); + +/** + * Discovery Service Set + * --------------------- + * This Service Set defines Services used to discover the Endpoints implemented + * by a Server and to read the security configuration for those Endpoints. + * + * FindServers Service + * ^^^^^^^^^^^^^^^^^^^ + * Returns the Servers known to a Server or Discovery Server. The Client may + * reduce the number of results returned by specifying filter criteria */ +void Service_FindServers(UA_Server *server, UA_Session *session, + const UA_FindServersRequest *request, + UA_FindServersResponse *response); + +/** + * GetEndpoints Service + * ^^^^^^^^^^^^^^^^^^^^ + * Returns the Endpoints supported by a Server and all of the configuration + * information required to establish a SecureChannel and a Session. */ +void Service_GetEndpoints(UA_Server *server, UA_Session *session, + const UA_GetEndpointsRequest *request, + UA_GetEndpointsResponse *response); + +#ifdef UA_ENABLE_DISCOVERY + +# ifdef UA_ENABLE_DISCOVERY_MULTICAST + +/** + * FindServersOnNetwork Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Returns the Servers known to a Discovery Server. Unlike FindServer, + * this Service is only implemented by Discovery Servers. It additionally + * returns servers which may have been detected through Multicast. */ +void Service_FindServersOnNetwork(UA_Server *server, UA_Session *session, + const UA_FindServersOnNetworkRequest *request, + UA_FindServersOnNetworkResponse *response); + +# endif /* UA_ENABLE_DISCOVERY_MULTICAST */ + +/** + * RegisterServer + * ^^^^^^^^^^^^^^ + * Registers a remote server in the local discovery service. */ +void Service_RegisterServer(UA_Server *server, UA_Session *session, + const UA_RegisterServerRequest *request, + UA_RegisterServerResponse *response); + +/** + * RegisterServer2 + * ^^^^^^^^^^^^^^^ + * This Service allows a Server to register its DiscoveryUrls and capabilities + * with a Discovery Server. It extends the registration information from + * RegisterServer with information necessary for FindServersOnNetwork. */ +void Service_RegisterServer2(UA_Server *server, UA_Session *session, + const UA_RegisterServer2Request *request, + UA_RegisterServer2Response *response); + +#endif /* UA_ENABLE_DISCOVERY */ + +/** + * SecureChannel Service Set + * ------------------------- + * This Service Set defines Services used to open a communication channel that + * ensures the confidentiality and Integrity of all Messages exchanged with the + * Server. + * + * OpenSecureChannel Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + * Open or renew a SecureChannel that can be used to ensure Confidentiality and + * Integrity for Message exchange during a Session. */ +void Service_OpenSecureChannel(UA_Server *server, UA_SecureChannel* channel, + const UA_OpenSecureChannelRequest *request, + UA_OpenSecureChannelResponse *response); + +/** + * CloseSecureChannel Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to terminate a SecureChannel. */ +void Service_CloseSecureChannel(UA_Server *server, UA_SecureChannel *channel); + +/** + * Session Service Set + * ------------------- + * This Service Set defines Services for an application layer connection + * establishment in the context of a Session. + * + * CreateSession Service + * ^^^^^^^^^^^^^^^^^^^^^ + * Used by an OPC UA Client to create a Session and the Server returns two + * values which uniquely identify the Session. The first value is the sessionId + * which is used to identify the Session in the audit logs and in the Server's + * address space. The second is the authenticationToken which is used to + * associate an incoming request with a Session. */ +void Service_CreateSession(UA_Server *server, UA_SecureChannel *channel, + const UA_CreateSessionRequest *request, + UA_CreateSessionResponse *response); + +/** + * ActivateSession + * ^^^^^^^^^^^^^^^ + * Used by the Client to submit its SoftwareCertificates to the Server for + * validation and to specify the identity of the user associated with the + * Session. This Service request shall be issued by the Client before it issues + * any other Service request after CreateSession. Failure to do so shall cause + * the Server to close the Session. */ +void Service_ActivateSession(UA_Server *server, UA_SecureChannel *channel, + const UA_ActivateSessionRequest *request, + UA_ActivateSessionResponse *response); + +/** + * CloseSession + * ^^^^^^^^^^^^ + * Used to terminate a Session. */ +void Service_CloseSession(UA_Server *server, UA_SecureChannel *channel, + const UA_CloseSessionRequest *request, + UA_CloseSessionResponse *response); + +/** + * Cancel Service + * ^^^^^^^^^^^^^^ + * Used to cancel outstanding Service requests. Successfully cancelled service + * requests shall respond with Bad_RequestCancelledByClient. */ +/* Not Implemented */ + +/** + * NodeManagement Service Set + * -------------------------- + * This Service Set defines Services to add and delete AddressSpace Nodes and + * References between them. All added Nodes continue to exist in the + * AddressSpace even if the Client that created them disconnects from the + * Server. + * + * AddNodes Service + * ^^^^^^^^^^^^^^^^ + * Used to add one or more Nodes into the AddressSpace hierarchy. + * If the type or one of the supertypes has any HasInterface references + * (see OPC 10001-7 - Amendment 7, 4.9.2), the child nodes of the interfaces + * are added to the new object. +*/ +void Service_AddNodes(UA_Server *server, UA_Session *session, + const UA_AddNodesRequest *request, + UA_AddNodesResponse *response); + +/** + * AddReferences Service + * ^^^^^^^^^^^^^^^^^^^^^ + * Used to add one or more References to one or more Nodes.*/ +void Service_AddReferences(UA_Server *server, UA_Session *session, + const UA_AddReferencesRequest *request, + UA_AddReferencesResponse *response); + +/** + * DeleteNodes Service + * ^^^^^^^^^^^^^^^^^^^ + * Used to delete one or more Nodes from the AddressSpace. */ +void Service_DeleteNodes(UA_Server *server, UA_Session *session, + const UA_DeleteNodesRequest *request, + UA_DeleteNodesResponse *response); + +/** + * DeleteReferences + * ^^^^^^^^^^^^^^^^ + * Used to delete one or more References of a Node. */ +void Service_DeleteReferences(UA_Server *server, UA_Session *session, + const UA_DeleteReferencesRequest *request, + UA_DeleteReferencesResponse *response); + +/** + * .. _view-services: + * + * View Service Set + * ---------------- + * Clients use the browse Services of the View Service Set to navigate through + * the AddressSpace or through a View which is a subset of the AddressSpace. + * + * Browse Service + * ^^^^^^^^^^^^^^ + * Used to discover the References of a specified Node. The browse can be + * further limited by the use of a View. This Browse Service also supports a + * primitive filtering capability. */ +void Service_Browse(UA_Server *server, UA_Session *session, + const UA_BrowseRequest *request, + UA_BrowseResponse *response); + +/** + * BrowseNext Service + * ^^^^^^^^^^^^^^^^^^ + * Used to request the next set of Browse or BrowseNext response information + * that is too large to be sent in a single response. "Too large" in this + * context means that the Server is not able to return a larger response or that + * the number of results to return exceeds the maximum number of results to + * return that was specified by the Client in the original Browse request. */ +void Service_BrowseNext(UA_Server *server, UA_Session *session, + const UA_BrowseNextRequest *request, + UA_BrowseNextResponse *response); + +/** + * TranslateBrowsePathsToNodeIds Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to translate textual node paths to their respective ids. */ +void Service_TranslateBrowsePathsToNodeIds(UA_Server *server, UA_Session *session, + const UA_TranslateBrowsePathsToNodeIdsRequest *request, + UA_TranslateBrowsePathsToNodeIdsResponse *response); + +/** + * RegisterNodes Service + * ^^^^^^^^^^^^^^^^^^^^^ + * Used by Clients to register the Nodes that they know they will access + * repeatedly (e.g. Write, Call). It allows Servers to set up anything needed so + * that the access operations will be more efficient. */ +void Service_RegisterNodes(UA_Server *server, UA_Session *session, + const UA_RegisterNodesRequest *request, + UA_RegisterNodesResponse *response); + +/** + * UnregisterNodes Service + * ^^^^^^^^^^^^^^^^^^^^^^^ + * This Service is used to unregister NodeIds that have been obtained via the + * RegisterNodes service. */ +void Service_UnregisterNodes(UA_Server *server, UA_Session *session, + const UA_UnregisterNodesRequest *request, + UA_UnregisterNodesResponse *response); + +/** + * Query Service Set + * ----------------- + * This Service Set is used to issue a Query to a Server. OPC UA Query is + * generic in that it provides an underlying storage mechanism independent Query + * capability that can be used to access a wide variety of OPC UA data stores + * and information management systems. OPC UA Query permits a Client to access + * data maintained by a Server without any knowledge of the logical schema used + * for internal storage of the data. Knowledge of the AddressSpace is + * sufficient. + * + * QueryFirst Service + * ^^^^^^^^^^^^^^^^^^ + * This Service is used to issue a Query request to the Server. */ +/* Not Implemented */ + +/** + * QueryNext Service + * ^^^^^^^^^^^^^^^^^ + * This Service is used to request the next set of QueryFirst or QueryNext + * response information that is too large to be sent in a single response. */ +/* Not Impelemented */ + +/** + * Attribute Service Set + * --------------------- + * This Service Set provides Services to access Attributes that are part of + * Nodes. + * + * Read Service + * ^^^^^^^^^^^^ + * Used to read attributes of nodes. For constructed attribute values whose + * elements are indexed, such as an array, this Service allows Clients to read + * the entire set of indexed values as a composite, to read individual elements + * or to read ranges of elements of the composite. */ +void Service_Read(UA_Server *server, UA_Session *session, + const UA_ReadRequest *request, + UA_ReadResponse *response); + +/** + * Write Service + * ^^^^^^^^^^^^^ + * Used to write attributes of nodes. For constructed attribute values whose + * elements are indexed, such as an array, this Service allows Clients to write + * the entire set of indexed values as a composite, to write individual elements + * or to write ranges of elements of the composite. */ +void Service_Write(UA_Server *server, UA_Session *session, + const UA_WriteRequest *request, + UA_WriteResponse *response); + +/** + * HistoryRead Service + * ^^^^^^^^^^^^^^^^^^^ + * Used to read historical values or Events of one or more Nodes. Servers may + * make historical values available to Clients using this Service, although the + * historical values themselves are not visible in the AddressSpace. */ +#ifdef UA_ENABLE_HISTORIZING +void Service_HistoryRead(UA_Server *server, UA_Session *session, + const UA_HistoryReadRequest *request, + UA_HistoryReadResponse *response); + +/** + * HistoryUpdate Service + * ^^^^^^^^^^^^^^^^^^^^^ + * Used to update historical values or Events of one or more Nodes. Several + * request parameters indicate how the Server is to update the historical value + * or Event. Valid actions are Insert, Replace or Delete. */ +void +Service_HistoryUpdate(UA_Server *server, UA_Session *session, + const UA_HistoryUpdateRequest *request, + UA_HistoryUpdateResponse *response); +#endif + +/** + * .. _method-services: + * + * Method Service Set + * ------------------ + * The Method Service Set defines the means to invoke methods. A method shall be + * a component of an Object. See the section on :ref:`MethodNodes ` + * for more information. + * + * Call Service + * ^^^^^^^^^^^^ + * Used to call (invoke) a methods. Each method call is invoked within the + * context of an existing Session. If the Session is terminated, the results of + * the method's execution cannot be returned to the Client and are discarded. */ +#ifdef UA_ENABLE_METHODCALLS +void Service_Call(UA_Server *server, UA_Session *session, + const UA_CallRequest *request, + UA_CallResponse *response); + +# if UA_MULTITHREADING >= 100 +void Service_CallAsync(UA_Server *server, UA_Session *session, UA_UInt32 requestId, + const UA_CallRequest *request, UA_CallResponse *response, + UA_Boolean *finished); +#endif +#endif + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +/** + * MonitoredItem Service Set + * ------------------------- + * Clients define MonitoredItems to subscribe to data and Events. Each + * MonitoredItem identifies the item to be monitored and the Subscription to use + * to send Notifications. The item to be monitored may be any Node Attribute. + * + * CreateMonitoredItems Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to create and add one or more MonitoredItems to a Subscription. A + * MonitoredItem is deleted automatically by the Server when the Subscription is + * deleted. Deleting a MonitoredItem causes its entire set of triggered item + * links to be deleted, but has no effect on the MonitoredItems referenced by + * the triggered items. */ +void Service_CreateMonitoredItems(UA_Server *server, UA_Session *session, + const UA_CreateMonitoredItemsRequest *request, + UA_CreateMonitoredItemsResponse *response); + +/** + * DeleteMonitoredItems Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to remove one or more MonitoredItems of a Subscription. When a + * MonitoredItem is deleted, its triggered item links are also deleted. */ +void Service_DeleteMonitoredItems(UA_Server *server, UA_Session *session, + const UA_DeleteMonitoredItemsRequest *request, + UA_DeleteMonitoredItemsResponse *response); + +/** + * ModifyMonitoredItems Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to modify MonitoredItems of a Subscription. Changes to the MonitoredItem + * settings shall be applied immediately by the Server. They take effect as soon + * as practical but not later than twice the new revisedSamplingInterval. + * + * Illegal request values for parameters that can be revised do not generate + * errors. Instead the server will choose default values and indicate them in + * the corresponding revised parameter. */ +void Service_ModifyMonitoredItems(UA_Server *server, UA_Session *session, + const UA_ModifyMonitoredItemsRequest *request, + UA_ModifyMonitoredItemsResponse *response); + +/** + * SetMonitoringMode Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to set the monitoring mode for one or more MonitoredItems of a + * Subscription. */ +void Service_SetMonitoringMode(UA_Server *server, UA_Session *session, + const UA_SetMonitoringModeRequest *request, + UA_SetMonitoringModeResponse *response); + +/** + * SetTriggering Service + * ^^^^^^^^^^^^^^^^^^^^^ + * Used to create and delete triggering links for a triggering item. */ +void Service_SetTriggering(UA_Server *server, UA_Session *session, + const UA_SetTriggeringRequest *request, + UA_SetTriggeringResponse *response); + +/** + * Subscription Service Set + * ------------------------ + * Subscriptions are used to report Notifications to the Client. + * + * CreateSubscription Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to create a Subscription. Subscriptions monitor a set of MonitoredItems + * for Notifications and return them to the Client in response to Publish + * requests. */ +void Service_CreateSubscription(UA_Server *server, UA_Session *session, + const UA_CreateSubscriptionRequest *request, + UA_CreateSubscriptionResponse *response); + +/** + * ModifySubscription Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to modify a Subscription. */ +void Service_ModifySubscription(UA_Server *server, UA_Session *session, + const UA_ModifySubscriptionRequest *request, + UA_ModifySubscriptionResponse *response); + +/** + * SetPublishingMode Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to enable sending of Notifications on one or more Subscriptions. */ +void Service_SetPublishingMode(UA_Server *server, UA_Session *session, + const UA_SetPublishingModeRequest *request, + UA_SetPublishingModeResponse *response); + +/** + * Publish Service + * ^^^^^^^^^^^^^^^ + * Used for two purposes. First, it is used to acknowledge the receipt of + * NotificationMessages for one or more Subscriptions. Second, it is used to + * request the Server to return a NotificationMessage or a keep-alive + * Message. + * + * Note that the service signature is an exception and does not contain a + * pointer to a PublishResponse. That is because the service queues up publish + * requests internally and sends responses asynchronously based on timeouts. */ +void Service_Publish(UA_Server *server, UA_Session *session, + const UA_PublishRequest *request, UA_UInt32 requestId); + +/** + * Republish Service + * ^^^^^^^^^^^^^^^^^ + * Requests the Subscription to republish a NotificationMessage from its + * retransmission queue. */ +void Service_Republish(UA_Server *server, UA_Session *session, + const UA_RepublishRequest *request, + UA_RepublishResponse *response); + +/** + * DeleteSubscriptions Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Invoked to delete one or more Subscriptions that belong to the Client's + * Session. */ +void Service_DeleteSubscriptions(UA_Server *server, UA_Session *session, + const UA_DeleteSubscriptionsRequest *request, + UA_DeleteSubscriptionsResponse *response); + +/** + * TransferSubscription Service + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + * Used to transfer a Subscription and its MonitoredItems from one Session to + * another. For example, a Client may need to reopen a Session and then transfer + * its Subscriptions to that Session. It may also be used by one Client to take + * over a Subscription from another Client by transferring the Subscription to + * its Session. */ +void Service_TransferSubscriptions(UA_Server *server, UA_Session *session, + const UA_TransferSubscriptionsRequest *request, + UA_TransferSubscriptionsResponse *response); + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +_UA_END_DECLS + + +/**** amalgamated original file "/src/client/ua_client_internal.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016-2017 (c) Florian Palm + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + */ + + +#define UA_INTERNAL + + +_UA_BEGIN_DECLS + +/**************************/ +/* Subscriptions Handling */ +/**************************/ + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +typedef struct UA_Client_NotificationsAckNumber { + LIST_ENTRY(UA_Client_NotificationsAckNumber) listEntry; + UA_SubscriptionAcknowledgement subAck; +} UA_Client_NotificationsAckNumber; + +typedef struct UA_Client_MonitoredItem { + LIST_ENTRY(UA_Client_MonitoredItem) listEntry; + UA_UInt32 monitoredItemId; + UA_UInt32 clientHandle; + void *context; + UA_Client_DeleteMonitoredItemCallback deleteCallback; + union { + UA_Client_DataChangeNotificationCallback dataChangeCallback; + UA_Client_EventNotificationCallback eventCallback; + } handler; + UA_Boolean isEventMonitoredItem; /* Otherwise a DataChange MoniitoredItem */ +} UA_Client_MonitoredItem; + +typedef struct UA_Client_Subscription { + LIST_ENTRY(UA_Client_Subscription) listEntry; + UA_UInt32 subscriptionId; + void *context; + UA_Double publishingInterval; + UA_UInt32 maxKeepAliveCount; + UA_Client_StatusChangeNotificationCallback statusChangeCallback; + UA_Client_DeleteSubscriptionCallback deleteCallback; + UA_UInt32 sequenceNumber; + UA_DateTime lastActivity; + LIST_HEAD(, UA_Client_MonitoredItem) monitoredItems; +} UA_Client_Subscription; + +void +UA_Client_Subscriptions_clean(UA_Client *client); + +/* Exposed for fuzzing */ +UA_StatusCode +UA_Client_preparePublishRequest(UA_Client *client, UA_PublishRequest *request); + +void +UA_Client_Subscriptions_backgroundPublish(UA_Client *client); + +void +UA_Client_Subscriptions_backgroundPublishInactivityCheck(UA_Client *client); + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +/**********/ +/* Client */ +/**********/ + +typedef struct AsyncServiceCall { + LIST_ENTRY(AsyncServiceCall) pointers; + UA_UInt32 requestId; + UA_ClientAsyncServiceCallback callback; + const UA_DataType *responseType; + void *userdata; + UA_DateTime start; + UA_UInt32 timeout; + void *responsedata; +} AsyncServiceCall; + +void +UA_Client_AsyncService_cancel(UA_Client *client, AsyncServiceCall *ac, + UA_StatusCode statusCode); + +void +UA_Client_AsyncService_removeAll(UA_Client *client, UA_StatusCode statusCode); + +typedef struct CustomCallback { + UA_UInt32 callbackId; + + UA_ClientAsyncServiceCallback userCallback; + void *userData; + + void *clientData; +} CustomCallback; + +struct UA_Client { + UA_ClientConfig config; + UA_Timer timer; + + /* Overall connection status */ + UA_StatusCode connectStatus; + + /* Old status to notify only changes */ + UA_SecureChannelState oldChannelState; + UA_SessionState oldSessionState; + UA_StatusCode oldConnectStatus; + + UA_Boolean endpointsHandshake; /* Ongoing GetEndpoints */ + UA_Boolean noSession; /* Don't open a session */ + + /* Connection */ + UA_Connection connection; + UA_String endpointUrl; /* Only for the async connect */ + + /* SecureChannel */ + UA_SecureChannel channel; + UA_UInt32 requestId; + UA_DateTime nextChannelRenewal; + + /* Session */ + UA_SessionState sessionState; + UA_NodeId authenticationToken; + UA_UInt32 requestHandle; + UA_ByteString remoteNonce; + UA_ByteString localNonce; + + /* Connectivity check */ + UA_DateTime lastConnectivityCheck; + UA_Boolean pendingConnectivityCheck; + + /* Async Service */ + LIST_HEAD(, AsyncServiceCall) asyncServiceCalls; + + /* Subscriptions */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + LIST_HEAD(, UA_Client_NotificationsAckNumber) pendingNotificationsAcks; + LIST_HEAD(, UA_Client_Subscription) subscriptions; + UA_UInt32 monitoredItemHandles; + UA_UInt16 currentlyOutStandingPublishRequests; +#endif +}; + +void notifyClientState(UA_Client *client); +void processERRResponse(UA_Client *client, const UA_ByteString *chunk); +void processACKResponse(UA_Client *client, const UA_ByteString *chunk); +void processOPNResponse(UA_Client *client, const UA_ByteString *message); +void closeSecureChannel(UA_Client *client); + +UA_StatusCode +connectIterate(UA_Client *client, UA_UInt32 timeout); + +UA_StatusCode +receiveResponseAsync(UA_Client *client, UA_UInt32 timeout); + +_UA_END_DECLS + + +/**** amalgamated original file "/src/pubsub/ua_pubsub_config.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2020 Yannick Wallerer, Siemens AG + * Copyright (c) 2020 Thomas Fischer, Siemens AG + */ + +#ifdef UA_ENABLE_PUBSUB_FILE_CONFIG + + + +/* Decodes the information from the ByteString. If the decoded content is a + * PubSubConfiguration in a UABinaryFileDataType-object. It will overwrite the + * current PubSub configuration from the server. */ +UA_StatusCode +UA_PubSubManager_loadPubSubConfigFromByteString(UA_Server *server, + const UA_ByteString buffer); + +/* Saves the current PubSub configuration of a server in a byteString. */ +UA_StatusCode +UA_PubSubManager_getEncodedPubSubConfiguration(UA_Server *server, + UA_ByteString *buffer); + + +#endif /* UA_ENABLE_PUBSUB_FILE_CONFIG */ + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/namespace0_generated.h" ****/ + +/* WARNING: This is a generated file. + * Any manual changes will be overwritten. */ + +#ifndef NAMESPACE0_GENERATED_H_ +#define NAMESPACE0_GENERATED_H_ + + +#ifdef UA_ENABLE_AMALGAMATION + +/* The following declarations are in the open62541.c file so here's needed when compiling nodesets externally */ + +# ifndef UA_INTERNAL //this definition is needed to hide this code in the amalgamated .c file + +typedef UA_StatusCode (*UA_exchangeEncodeBuffer)(void *handle, UA_Byte **bufPos, + const UA_Byte **bufEnd); + +UA_StatusCode +UA_encodeBinary(const void *src, const UA_DataType *type, + UA_Byte **bufPos, const UA_Byte **bufEnd, + UA_exchangeEncodeBuffer exchangeCallback, + void *exchangeHandle) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +UA_StatusCode +UA_decodeBinary(const UA_ByteString *src, size_t *offset, void *dst, + const UA_DataType *type, size_t customTypesSize, + const UA_DataType *customTypes) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +size_t +UA_calcSizeBinary(void *p, const UA_DataType *type); + +const UA_DataType * +UA_findDataTypeByBinary(const UA_NodeId *typeId); + +# endif // UA_INTERNAL + +#else // UA_ENABLE_AMALGAMATION +#endif + + + + +_UA_BEGIN_DECLS + +extern UA_StatusCode namespace0_generated(UA_Server *server); + +_UA_END_DECLS + +#endif /* NAMESPACE0_GENERATED_H_ */ + +/**** amalgamated original file "/src/ua_types.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2016-2017 (c) Florian Palm + * Copyright 2014-2016 (c) Sten Grüner + * Copyright 2014 (c) Leon Urbas + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015 (c) Markus Graube + * Copyright 2015 (c) Reza Ebrahimi + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2016 (c) Lorenz Haas + */ + + + +#define UA_MAX_ARRAY_DIMS 100 /* Max dimensions of an array */ + +/* Datatype Handling + * ----------------- + * This file contains handling functions for the builtin types and functions + * handling of structured types and arrays. These need type descriptions in a + * UA_DataType structure. The UA_DataType structures as well as all non-builtin + * datatypes are autogenerated. */ + +/* Global definition of NULL type instances. These are always zeroed out, as + * mandated by the C/C++ standard for global values with no initializer. */ +const UA_String UA_STRING_NULL = {0}; +const UA_ByteString UA_BYTESTRING_NULL = {0}; +const UA_Guid UA_GUID_NULL = {0}; +const UA_NodeId UA_NODEID_NULL = {0}; +const UA_ExpandedNodeId UA_EXPANDEDNODEID_NULL = {0}; + +typedef UA_StatusCode +(*UA_copySignature)(const void *src, void *dst, const UA_DataType *type); +extern const UA_copySignature copyJumpTable[UA_DATATYPEKINDS]; + +typedef void (*UA_clearSignature)(void *p, const UA_DataType *type); +extern const UA_clearSignature clearJumpTable[UA_DATATYPEKINDS]; + +typedef UA_Order +(*UA_orderSignature)(const void *p1, const void *p2, const UA_DataType *type); +extern const UA_orderSignature orderJumpTable[UA_DATATYPEKINDS]; + +const UA_DataType * +UA_findDataTypeWithCustom(const UA_NodeId *typeId, + const UA_DataTypeArray *customTypes) { + /* Always look in built-in types first (may contain data types from all + * namespaces). + * + * TODO: The standard-defined types are ordered. See if binary search is + * more efficient. */ + for(size_t i = 0; i < UA_TYPES_COUNT; ++i) { + if(UA_NodeId_equal(&UA_TYPES[i].typeId, typeId)) + return &UA_TYPES[i]; + } + + /* Search in the customTypes */ + while(customTypes) { + for(size_t i = 0; i < customTypes->typesSize; ++i) { + if(UA_NodeId_equal(&customTypes->types[i].typeId, typeId)) + return &customTypes->types[i]; + } + customTypes = customTypes->next; + } + + return NULL; +} + +const UA_DataType * +UA_findDataType(const UA_NodeId *typeId) { + return UA_findDataTypeWithCustom(typeId, NULL); +} + +/***************************/ +/* Random Number Generator */ +/***************************/ + +//TODO is this safe for multithreading? +static pcg32_random_t UA_rng = PCG32_INITIALIZER; + +void +UA_random_seed(u64 seed) { + pcg32_srandom_r(&UA_rng, seed, (u64)UA_DateTime_now()); +} + +u32 +UA_UInt32_random(void) { + return (u32)pcg32_random_r(&UA_rng); +} + +/*****************/ +/* Builtin Types */ +/*****************/ + +UA_String +UA_String_fromChars(const char *src) { + UA_String s; s.length = 0; s.data = NULL; + if(!src) + return s; + s.length = strlen(src); + if(s.length > 0) { + s.data = (u8*)UA_malloc(s.length); + if(UA_UNLIKELY(!s.data)) { + s.length = 0; + return s; + } + memcpy(s.data, src, s.length); + } else { + s.data = (u8*)UA_EMPTY_ARRAY_SENTINEL; + } + return s; +} + +static UA_Order +stringOrder(const UA_String *p1, const UA_String *p2, const UA_DataType *type); +static UA_Order +guidOrder(const UA_Guid *p1, const UA_Guid *p2, const UA_DataType *type); +static UA_Order +qualifiedNameOrder(const UA_QualifiedName *p1, const UA_QualifiedName *p2, + const UA_DataType *type); + +UA_Boolean +UA_String_equal(const UA_String *s1, const UA_String *s2) { + return (stringOrder(s1, s2, NULL) == UA_ORDER_EQ); +} + +/* Do not expose UA_String_equal_ignorecase to public API as it currently only handles + * ASCII strings, and not UTF8! */ +UA_Boolean +UA_String_equal_ignorecase(const UA_String *s1, const UA_String *s2) { + if(s1->length != s2->length) + return false; + if(s1->length == 0) + return true; + if(s2->data == NULL) + return false; + + //FIXME this currently does not handle UTF8 + return UA_strncasecmp((const char*)s1->data, (const char*)s2->data, s1->length) == 0; +} + +static UA_StatusCode +String_copy(UA_String const *src, UA_String *dst, const UA_DataType *_) { + UA_StatusCode res = + UA_Array_copy(src->data, src->length, (void**)&dst->data, + &UA_TYPES[UA_TYPES_BYTE]); + if(res == UA_STATUSCODE_GOOD) + dst->length = src->length; + return res; +} + +static void +String_clear(UA_String *s, const UA_DataType *_) { + UA_Array_delete(s->data, s->length, &UA_TYPES[UA_TYPES_BYTE]); +} + +/* QualifiedName */ +static UA_StatusCode +QualifiedName_copy(const UA_QualifiedName *src, UA_QualifiedName *dst, + const UA_DataType *_) { + dst->namespaceIndex = src->namespaceIndex; + return String_copy(&src->name, &dst->name, NULL); +} + +static void +QualifiedName_clear(UA_QualifiedName *p, const UA_DataType *_) { + String_clear(&p->name, NULL); +} + +u32 +UA_QualifiedName_hash(const UA_QualifiedName *q) { + return UA_ByteString_hash(q->namespaceIndex, + q->name.data, q->name.length); +} + +UA_Boolean +UA_QualifiedName_equal(const UA_QualifiedName *qn1, + const UA_QualifiedName *qn2) { + return (qualifiedNameOrder(qn1, qn2, NULL) == UA_ORDER_EQ); +} + +/* DateTime */ +UA_DateTimeStruct +UA_DateTime_toStruct(UA_DateTime t) { + /* Calculating the the milli-, micro- and nanoseconds */ + UA_DateTimeStruct dateTimeStruct; + if(t >= 0) { + dateTimeStruct.nanoSec = (u16)((t % 10) * 100); + dateTimeStruct.microSec = (u16)((t % 10000) / 10); + dateTimeStruct.milliSec = (u16)((t % 10000000) / 10000); + } else { + dateTimeStruct.nanoSec = (u16)(((t % 10 + t) % 10) * 100); + dateTimeStruct.microSec = (u16)(((t % 10000 + t) % 10000) / 10); + dateTimeStruct.milliSec = (u16)(((t % 10000000 + t) % 10000000) / 10000); + } + + /* Calculating the unix time with #include */ + long long secSinceUnixEpoch = (long long)(t / UA_DATETIME_SEC) + - (long long)(UA_DATETIME_UNIX_EPOCH / UA_DATETIME_SEC); + struct mytm ts; + memset(&ts, 0, sizeof(struct mytm)); + __secs_to_tm(secSinceUnixEpoch, &ts); + dateTimeStruct.sec = (u16)ts.tm_sec; + dateTimeStruct.min = (u16)ts.tm_min; + dateTimeStruct.hour = (u16)ts.tm_hour; + dateTimeStruct.day = (u16)ts.tm_mday; + dateTimeStruct.month = (u16)(ts.tm_mon + 1); + dateTimeStruct.year = (u16)(ts.tm_year + 1900); + return dateTimeStruct; +} + +UA_DateTime +UA_DateTime_fromStruct(UA_DateTimeStruct ts) { + /* Seconds since the Unix epoch */ + struct mytm tm; + memset(&tm, 0, sizeof(struct mytm)); + tm.tm_year = ts.year - 1900; + tm.tm_mon = ts.month - 1; + tm.tm_mday = ts.day; + tm.tm_hour = ts.hour; + tm.tm_min = ts.min; + tm.tm_sec = ts.sec; + long long sec_epoch = __tm_to_secs(&tm); + + UA_DateTime t = UA_DATETIME_UNIX_EPOCH; + t += sec_epoch * UA_DATETIME_SEC; + t += ts.milliSec * UA_DATETIME_MSEC; + t += ts.microSec * UA_DATETIME_USEC; + t += ts.nanoSec / 100; + return t; +} + +/* Guid */ +UA_Boolean +UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2) { + return (guidOrder(g1, g2, NULL) == UA_ORDER_EQ); +} + +UA_Guid +UA_Guid_random(void) { + UA_Guid result; + result.data1 = (u32)pcg32_random_r(&UA_rng); + u32 r = (u32)pcg32_random_r(&UA_rng); + result.data2 = (u16) r; + result.data3 = (u16) (r >> 16); + r = (u32)pcg32_random_r(&UA_rng); + result.data4[0] = (u8)r; + result.data4[1] = (u8)(r >> 4); + result.data4[2] = (u8)(r >> 8); + result.data4[3] = (u8)(r >> 12); + r = (u32)pcg32_random_r(&UA_rng); + result.data4[4] = (u8)r; + result.data4[5] = (u8)(r >> 4); + result.data4[6] = (u8)(r >> 8); + result.data4[7] = (u8)(r >> 12); + return result; +} + +/* ByteString */ +UA_StatusCode +UA_ByteString_allocBuffer(UA_ByteString *bs, size_t length) { + UA_ByteString_init(bs); + if(length == 0) + return UA_STATUSCODE_GOOD; + + if(length <= 8192) + length = length << 1; + bs->data = (u8*)UA_malloc(length); + if(UA_UNLIKELY(!bs->data)) + { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + bs->length = length; + return UA_STATUSCODE_GOOD; +} + +/* NodeId */ +static void +NodeId_clear(UA_NodeId *p, const UA_DataType *_) { + switch(p->identifierType) { + case UA_NODEIDTYPE_STRING: + case UA_NODEIDTYPE_BYTESTRING: + String_clear(&p->identifier.string, NULL); + break; + default: break; + } +} + +static UA_StatusCode +NodeId_copy(UA_NodeId const *src, UA_NodeId *dst, const UA_DataType *_) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + switch(src->identifierType) { + case UA_NODEIDTYPE_NUMERIC: + *dst = *src; + return UA_STATUSCODE_GOOD; + case UA_NODEIDTYPE_STRING: + retval |= UA_String_copy(&src->identifier.string, + &dst->identifier.string); + break; + case UA_NODEIDTYPE_GUID: + retval |= UA_Guid_copy(&src->identifier.guid, &dst->identifier.guid); + break; + case UA_NODEIDTYPE_BYTESTRING: + retval |= UA_ByteString_copy(&src->identifier.byteString, + &dst->identifier.byteString); + break; + default: + return UA_STATUSCODE_BADINTERNALERROR; + } + dst->namespaceIndex = src->namespaceIndex; + dst->identifierType = src->identifierType; + return retval; +} + +UA_Boolean +UA_NodeId_isNull(const UA_NodeId *p) { + if(p->namespaceIndex != 0) + return false; + switch (p->identifierType) { + case UA_NODEIDTYPE_NUMERIC: + return (p->identifier.numeric == 0); + case UA_NODEIDTYPE_STRING: + return UA_String_equal(&p->identifier.string, &UA_STRING_NULL); + case UA_NODEIDTYPE_GUID: + return UA_Guid_equal(&p->identifier.guid, &UA_GUID_NULL); + case UA_NODEIDTYPE_BYTESTRING: + return UA_ByteString_equal(&p->identifier.byteString, &UA_BYTESTRING_NULL); + } + return false; +} + +/* Absolute ordering for NodeIds */ +UA_Order +UA_NodeId_order(const UA_NodeId *n1, const UA_NodeId *n2) { + /* Compare namespaceIndex */ + if(n1->namespaceIndex != n2->namespaceIndex) + return (n1->namespaceIndex < n2->namespaceIndex) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* Compare identifierType */ + if(n1->identifierType != n2->identifierType) + return (n1->identifierType < n2->identifierType) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* Compare the identifier */ + switch(n1->identifierType) { + case UA_NODEIDTYPE_NUMERIC: + default: + if(n1->identifier.numeric != n2->identifier.numeric) + return (n1->identifier.numeric < n2->identifier.numeric) ? + UA_ORDER_LESS : UA_ORDER_MORE; + return UA_ORDER_EQ; + + case UA_NODEIDTYPE_GUID: + return guidOrder(&n1->identifier.guid, &n2->identifier.guid, NULL); + + case UA_NODEIDTYPE_STRING: + case UA_NODEIDTYPE_BYTESTRING: + return stringOrder(&n1->identifier.string, &n2->identifier.string, NULL); + } +} + +/* sdbm-hash (http://www.cse.yorku.ca/~oz/hash.html) */ +u32 +UA_ByteString_hash(u32 initialHashValue, + const u8 *data, size_t size) { + u32 h = initialHashValue; + for(size_t i = 0; i < size; i++) + h = data[i] + (h << 6) + (h << 16) - h; + return h; +} + +u32 +UA_NodeId_hash(const UA_NodeId *n) { + switch(n->identifierType) { + case UA_NODEIDTYPE_NUMERIC: + default: + return UA_ByteString_hash(n->namespaceIndex, (const u8*)&n->identifier.numeric, + sizeof(UA_UInt32)); + case UA_NODEIDTYPE_STRING: + case UA_NODEIDTYPE_BYTESTRING: + return UA_ByteString_hash(n->namespaceIndex, n->identifier.string.data, + n->identifier.string.length); + case UA_NODEIDTYPE_GUID: + return UA_ByteString_hash(n->namespaceIndex, (const u8*)&n->identifier.guid, + sizeof(UA_Guid)); + } +} + +/* ExpandedNodeId */ +static void +ExpandedNodeId_clear(UA_ExpandedNodeId *p, const UA_DataType *_) { + NodeId_clear(&p->nodeId, _); + String_clear(&p->namespaceUri, NULL); +} + +static UA_StatusCode +ExpandedNodeId_copy(UA_ExpandedNodeId const *src, UA_ExpandedNodeId *dst, + const UA_DataType *_) { + UA_StatusCode retval = NodeId_copy(&src->nodeId, &dst->nodeId, NULL); + retval |= UA_String_copy(&src->namespaceUri, &dst->namespaceUri); + dst->serverIndex = src->serverIndex; + return retval; +} + +UA_Boolean +UA_ExpandedNodeId_isLocal(const UA_ExpandedNodeId *n) { + return (n->namespaceUri.length == 0 && n->serverIndex == 0); +} + +UA_Order +UA_ExpandedNodeId_order(const UA_ExpandedNodeId *n1, + const UA_ExpandedNodeId *n2) { + if(n1->serverIndex != n2->serverIndex) + return (n1->serverIndex < n2->serverIndex) ? UA_ORDER_LESS : UA_ORDER_MORE; + UA_Order o = stringOrder(&n1->namespaceUri, &n2->namespaceUri, NULL); + if(o != UA_ORDER_EQ) + return o; + return UA_NodeId_order(&n1->nodeId, &n2->nodeId); +} + +u32 +UA_ExpandedNodeId_hash(const UA_ExpandedNodeId *n) { + u32 h = UA_NodeId_hash(&n->nodeId); + if(n->serverIndex != 0) + h = UA_ByteString_hash(h, (const UA_Byte*)&n->serverIndex, 4); + if(n->namespaceUri.length != 0) + h = UA_ByteString_hash(h, n->namespaceUri.data, n->namespaceUri.length); + return h; +} + +/* ExtensionObject */ +static void +ExtensionObject_clear(UA_ExtensionObject *p, const UA_DataType *_) { + switch(p->encoding) { + case UA_EXTENSIONOBJECT_ENCODED_NOBODY: + case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING: + case UA_EXTENSIONOBJECT_ENCODED_XML: + NodeId_clear(&p->content.encoded.typeId, NULL); + String_clear(&p->content.encoded.body, NULL); + break; + case UA_EXTENSIONOBJECT_DECODED: + if(p->content.decoded.data) + UA_delete(p->content.decoded.data, p->content.decoded.type); + break; + default: + break; + } +} + +static UA_StatusCode +ExtensionObject_copy(UA_ExtensionObject const *src, UA_ExtensionObject *dst, + const UA_DataType *_) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + switch(src->encoding) { + case UA_EXTENSIONOBJECT_ENCODED_NOBODY: + case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING: + case UA_EXTENSIONOBJECT_ENCODED_XML: + dst->encoding = src->encoding; + retval = NodeId_copy(&src->content.encoded.typeId, + &dst->content.encoded.typeId, NULL); + retval |= UA_ByteString_copy(&src->content.encoded.body, + &dst->content.encoded.body); + break; + case UA_EXTENSIONOBJECT_DECODED: + case UA_EXTENSIONOBJECT_DECODED_NODELETE: + if(!src->content.decoded.type || !src->content.decoded.data) + return UA_STATUSCODE_BADINTERNALERROR; + dst->encoding = UA_EXTENSIONOBJECT_DECODED; + dst->content.decoded.type = src->content.decoded.type; + retval = UA_Array_copy(src->content.decoded.data, 1, + &dst->content.decoded.data, src->content.decoded.type); + break; + default: + break; + } + return retval; +} + +void +UA_ExtensionObject_setValue(UA_ExtensionObject *eo, + void * UA_RESTRICT p, + const UA_DataType *type) { + UA_ExtensionObject_init(eo); + eo->content.decoded.data = p; + eo->content.decoded.type = type; + eo->encoding = UA_EXTENSIONOBJECT_DECODED; +} + +void +UA_ExtensionObject_setValueNoDelete(UA_ExtensionObject *eo, + void * UA_RESTRICT p, + const UA_DataType *type) { + UA_ExtensionObject_init(eo); + eo->content.decoded.data = p; + eo->content.decoded.type = type; + eo->encoding = UA_EXTENSIONOBJECT_DECODED_NODELETE; +} + +UA_StatusCode +UA_ExtensionObject_setValueCopy(UA_ExtensionObject *eo, + void * UA_RESTRICT p, + const UA_DataType *type) { + UA_ExtensionObject_init(eo); + + /* Make a copy of the value */ + void *val = UA_malloc(type->memSize); + if(UA_UNLIKELY(!val)) + return UA_STATUSCODE_BADOUTOFMEMORY; + UA_StatusCode res = UA_copy(p, val, type); + if(UA_UNLIKELY(res != UA_STATUSCODE_GOOD)) { + UA_free(val); + return res; + } + + /* Set the ExtensionObject */ + eo->content.decoded.data = val; + eo->content.decoded.type = type; + eo->encoding = UA_EXTENSIONOBJECT_DECODED; + return UA_STATUSCODE_GOOD; +} + +/* Variant */ +static void +Variant_clear(UA_Variant *p, const UA_DataType *_) { + /* The content is "borrowed" */ + if(p->storageType == UA_VARIANT_DATA_NODELETE) + return; + + /* Delete the value */ + if(p->type && p->data > UA_EMPTY_ARRAY_SENTINEL) { + if(p->arrayLength == 0) + p->arrayLength = 1; + UA_Array_delete(p->data, p->arrayLength, p->type); + p->data = NULL; + } + + /* Delete the array dimensions */ + if((void*)p->arrayDimensions > UA_EMPTY_ARRAY_SENTINEL) + UA_free(p->arrayDimensions); +} + +static UA_StatusCode +Variant_copy(UA_Variant const *src, UA_Variant *dst, const UA_DataType *_) { + size_t length = src->arrayLength; + if(UA_Variant_isScalar(src)) + length = 1; + UA_StatusCode retval = UA_Array_copy(src->data, length, + &dst->data, src->type); + if(retval != UA_STATUSCODE_GOOD) + return retval; + dst->arrayLength = src->arrayLength; + dst->type = src->type; + if(src->arrayDimensions) { + retval = UA_Array_copy(src->arrayDimensions, src->arrayDimensionsSize, + (void**)&dst->arrayDimensions, &UA_TYPES[UA_TYPES_INT32]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + dst->arrayDimensionsSize = src->arrayDimensionsSize; + } + return UA_STATUSCODE_GOOD; +} + +void +UA_Variant_setScalar(UA_Variant *v, void * UA_RESTRICT p, + const UA_DataType *type) { + UA_Variant_init(v); + v->type = type; + v->arrayLength = 0; + v->data = p; +} + +UA_StatusCode +UA_Variant_setScalarCopy(UA_Variant *v, const void * UA_RESTRICT p, + const UA_DataType *type) { + void *n = UA_malloc(type->memSize); + if(UA_UNLIKELY(!n)) + return UA_STATUSCODE_BADOUTOFMEMORY; + UA_StatusCode retval = UA_copy(p, n, type); + if(UA_UNLIKELY(retval != UA_STATUSCODE_GOOD)) { + UA_free(n); + //cppcheck-suppress memleak + return retval; + } + UA_Variant_setScalar(v, n, type); + //cppcheck-suppress memleak + return UA_STATUSCODE_GOOD; +} + +void UA_Variant_setArray(UA_Variant *v, void * UA_RESTRICT array, + size_t arraySize, const UA_DataType *type) { + UA_Variant_init(v); + v->data = array; + v->arrayLength = arraySize; + v->type = type; +} + +UA_StatusCode +UA_Variant_setArrayCopy(UA_Variant *v, const void * UA_RESTRICT array, + size_t arraySize, const UA_DataType *type) { + UA_Variant_init(v); + UA_StatusCode retval = UA_Array_copy(array, arraySize, &v->data, type); + if(retval != UA_STATUSCODE_GOOD) + return retval; + v->arrayLength = arraySize; + v->type = type; + return UA_STATUSCODE_GOOD; +} + +/* Test if a range is compatible with a variant. If yes, the following values + * are set: + * - total: how many elements are in the range + * - block: how big is each contiguous block of elements in the variant that + * maps into the range + * - stride: how many elements are between the blocks (beginning to beginning) + * - first: where does the first block begin */ +static UA_StatusCode +computeStrides(const UA_Variant *v, const UA_NumericRange range, + size_t *total, size_t *block, size_t *stride, size_t *first) { + /* Test for max array size (64bit only) */ +#if (SIZE_MAX > 0xffffffff) + if(v->arrayLength > UA_UINT32_MAX) + return UA_STATUSCODE_BADINTERNALERROR; +#endif + + /* Test the integrity of the source variant dimensions, make dimensions + * vector of one dimension if none defined */ + u32 arrayLength = (u32)v->arrayLength; + const u32 *dims = &arrayLength; + size_t dims_count = 1; + if(v->arrayDimensionsSize > 0) { + size_t elements = 1; + dims_count = v->arrayDimensionsSize; + dims = (u32*)v->arrayDimensions; + for(size_t i = 0; i < dims_count; ++i) + elements *= dims[i]; + if(elements != v->arrayLength) + return UA_STATUSCODE_BADINTERNALERROR; + } + UA_assert(dims_count > 0); + + /* Upper bound of the dimensions for stack-allocation */ + if(dims_count > UA_MAX_ARRAY_DIMS) + return UA_STATUSCODE_BADINTERNALERROR; + UA_UInt32 realmax[UA_MAX_ARRAY_DIMS]; + + /* Test the integrity of the range and compute the max index used for every + * dimension. The standard says in Part 4, Section 7.22: + * + * When reading a value, the indexes may not specify a range that is within + * the bounds of the array. The Server shall return a partial result if some + * elements exist within the range. */ + size_t count = 1; + if(range.dimensionsSize != dims_count) + return UA_STATUSCODE_BADINDEXRANGENODATA; + for(size_t i = 0; i < dims_count; ++i) { + if(range.dimensions[i].min > range.dimensions[i].max) + return UA_STATUSCODE_BADINDEXRANGEINVALID; + if(range.dimensions[i].min >= dims[i]) + return UA_STATUSCODE_BADINDEXRANGENODATA; + + if(range.dimensions[i].max < dims[i]) + realmax[i] = range.dimensions[i].max; + else + realmax[i] = dims[i] - 1; + + count *= (realmax[i] - range.dimensions[i].min) + 1; + } + + *total = count; + + /* Compute the stride length and the position of the first element */ + *block = count; /* Assume the range describes the entire array. */ + *stride = v->arrayLength; /* So it can be copied as a contiguous block. */ + *first = 0; + size_t running_dimssize = 1; + UA_Boolean found_contiguous = false; + for(size_t k = dims_count; k > 0;) { + --k; + size_t dimrange = 1 + realmax[k] - range.dimensions[k].min; + if(!found_contiguous && dimrange != dims[k]) { + /* Found the maximum block that can be copied contiguously */ + found_contiguous = true; + *block = running_dimssize * dimrange; + *stride = running_dimssize * dims[k]; + } + *first += running_dimssize * range.dimensions[k].min; + running_dimssize *= dims[k]; + } + return UA_STATUSCODE_GOOD; +} + +/* Is the type string-like? */ +static UA_Boolean +isStringLike(const UA_DataType *type) { + if(type == &UA_TYPES[UA_TYPES_STRING] || + type == &UA_TYPES[UA_TYPES_BYTESTRING] || + type == &UA_TYPES[UA_TYPES_XMLELEMENT]) + return true; + return false; +} + +/* Returns the part of the string that lies within the rangedimension */ +static UA_StatusCode +copySubString(const UA_String *src, UA_String *dst, + const UA_NumericRangeDimension *dim) { + if(dim->min > dim->max) + return UA_STATUSCODE_BADINDEXRANGEINVALID; + if(dim->min >= src->length) + return UA_STATUSCODE_BADINDEXRANGENODATA; + + size_t length; + if(dim->max < src->length) + length = dim->max - dim->min + 1; + else + length = src->length - dim->min; + + UA_StatusCode retval = UA_ByteString_allocBuffer(dst, length); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + memcpy(dst->data, &src->data[dim->min], length); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Variant_copyRange(const UA_Variant *src, UA_Variant * UA_RESTRICT dst, + const UA_NumericRange range) { + if(!src->type) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_Boolean isScalar = UA_Variant_isScalar(src); + UA_Boolean stringLike = isStringLike(src->type); + UA_Variant arraySrc; + + /* Extract the range for copying at this level. The remaining range is dealt + * with in the "scalar" type that may define an array by itself (string, + * variant, ...). */ + UA_NumericRange thisrange, nextrange; + UA_NumericRangeDimension scalarThisDimension = {0,0}; /* a single entry */ + if(isScalar) { + /* Replace scalar src with array of length 1 */ + arraySrc = *src; + arraySrc.arrayLength = 1; + src = &arraySrc; + /* Deal with all range dimensions within the scalar */ + thisrange.dimensions = &scalarThisDimension; + thisrange.dimensionsSize = 1; + nextrange = range; + } else { + /* Deal with as many range dimensions as possible right now */ + size_t dims = src->arrayDimensionsSize; + if(dims == 0) + dims = 1; + if(dims > range.dimensionsSize) + return UA_STATUSCODE_BADINDEXRANGEINVALID; + thisrange = range; + thisrange.dimensionsSize = dims; + nextrange.dimensions = &range.dimensions[dims]; + nextrange.dimensionsSize = range.dimensionsSize - dims; + } + + /* Compute the strides */ + size_t count, block, stride, first; + UA_StatusCode retval = computeStrides(src, thisrange, &count, + &block, &stride, &first); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Allocate the array */ + UA_Variant_init(dst); + dst->data = UA_Array_new(count, src->type); + if(!dst->data) + return UA_STATUSCODE_BADOUTOFMEMORY; + + /* Copy the range */ + size_t block_count = count / block; + size_t elem_size = src->type->memSize; + uintptr_t nextdst = (uintptr_t)dst->data; + uintptr_t nextsrc = (uintptr_t)src->data + (elem_size * first); + if(nextrange.dimensionsSize == 0) { + /* no nextrange */ + if(src->type->pointerFree) { + for(size_t i = 0; i < block_count; ++i) { + memcpy((void*)nextdst, (void*)nextsrc, elem_size * block); + nextdst += block * elem_size; + nextsrc += stride * elem_size; + } + } else { + for(size_t i = 0; i < block_count; ++i) { + for(size_t j = 0; j < block; ++j) { + retval = UA_copy((const void*)nextsrc, + (void*)nextdst, src->type); + nextdst += elem_size; + nextsrc += elem_size; + } + nextsrc += (stride - block) * elem_size; + } + } + } else { + /* nextrange can only be used for variants and stringlike with remaining + * range of dimension 1 */ + if(src->type != &UA_TYPES[UA_TYPES_VARIANT]) { + if(!stringLike) + retval = UA_STATUSCODE_BADINDEXRANGENODATA; + if(nextrange.dimensionsSize != 1) + retval = UA_STATUSCODE_BADINDEXRANGENODATA; + } + + /* Copy the content */ + for(size_t i = 0; i < block_count; ++i) { + for(size_t j = 0; j < block && retval == UA_STATUSCODE_GOOD; ++j) { + if(stringLike) + retval = copySubString((const UA_String*)nextsrc, + (UA_String*)nextdst, + nextrange.dimensions); + else + retval = UA_Variant_copyRange((const UA_Variant*)nextsrc, + (UA_Variant*)nextdst, + nextrange); + nextdst += elem_size; + nextsrc += elem_size; + } + nextsrc += (stride - block) * elem_size; + } + } + + /* Clean up if copying failed */ + if(retval != UA_STATUSCODE_GOOD) { + UA_Array_delete(dst->data, count, src->type); + dst->data = NULL; + return retval; + } + + /* Done if scalar */ + dst->type = src->type; + if(isScalar) + return retval; + + /* Copy array dimensions */ + dst->arrayLength = count; + if(src->arrayDimensionsSize > 0) { + dst->arrayDimensions = + (u32*)UA_Array_new(thisrange.dimensionsSize, &UA_TYPES[UA_TYPES_UINT32]); + if(!dst->arrayDimensions) { + Variant_clear(dst, NULL); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + dst->arrayDimensionsSize = thisrange.dimensionsSize; + for(size_t k = 0; k < thisrange.dimensionsSize; ++k) + dst->arrayDimensions[k] = + thisrange.dimensions[k].max - thisrange.dimensions[k].min + 1; + } + return UA_STATUSCODE_GOOD; +} + +/* TODO: Allow ranges to reach inside a scalars that are array-like, e.g. + * variant and strings. This is already possible for reading... */ +static UA_StatusCode +Variant_setRange(UA_Variant *v, void *array, size_t arraySize, + const UA_NumericRange range, UA_Boolean copy) { + /* Compute the strides */ + size_t count, block, stride, first; + UA_StatusCode retval = computeStrides(v, range, &count, + &block, &stride, &first); + if(retval != UA_STATUSCODE_GOOD) + return retval; + if(count != arraySize) + return UA_STATUSCODE_BADINDEXRANGEINVALID; + + /* Move/copy the elements */ + size_t block_count = count / block; + size_t elem_size = v->type->memSize; + uintptr_t nextdst = (uintptr_t)v->data + (first * elem_size); + uintptr_t nextsrc = (uintptr_t)array; + if(v->type->pointerFree || !copy) { + for(size_t i = 0; i < block_count; ++i) { + memcpy((void*)nextdst, (void*)nextsrc, elem_size * block); + nextsrc += block * elem_size; + nextdst += stride * elem_size; + } + } else { + for(size_t i = 0; i < block_count; ++i) { + for(size_t j = 0; j < block; ++j) { + clearJumpTable[v->type->typeKind]((void*)nextdst, v->type); + retval |= UA_copy((void*)nextsrc, (void*)nextdst, v->type); + nextdst += elem_size; + nextsrc += elem_size; + } + nextdst += (stride - block) * elem_size; + } + } + + /* If members were moved, initialize original array to prevent reuse */ + if(!copy && !v->type->pointerFree) + memset(array, 0, sizeof(elem_size)*arraySize); + + return retval; +} + +UA_StatusCode +UA_Variant_setRange(UA_Variant *v, void * UA_RESTRICT array, + size_t arraySize, const UA_NumericRange range) { + return Variant_setRange(v, array, arraySize, range, false); +} + +UA_StatusCode +UA_Variant_setRangeCopy(UA_Variant *v, const void * UA_RESTRICT array, + size_t arraySize, const UA_NumericRange range) { + return Variant_setRange(v, (void*)(uintptr_t)array, + arraySize, range, true); +} + +/* LocalizedText */ +static void +LocalizedText_clear(UA_LocalizedText *p, const UA_DataType *_) { + String_clear(&p->locale, NULL); + String_clear(&p->text, NULL); +} + +static UA_StatusCode +LocalizedText_copy(UA_LocalizedText const *src, UA_LocalizedText *dst, + const UA_DataType *_) { + UA_StatusCode retval = UA_String_copy(&src->locale, &dst->locale); + retval |= UA_String_copy(&src->text, &dst->text); + return retval; +} + +/* DataValue */ +static void +DataValue_clear(UA_DataValue *p, const UA_DataType *_) { + Variant_clear(&p->value, NULL); +} + +static UA_StatusCode +DataValue_copy(UA_DataValue const *src, UA_DataValue *dst, + const UA_DataType *_) { + memcpy(dst, src, sizeof(UA_DataValue)); + UA_Variant_init(&dst->value); + UA_StatusCode retval = Variant_copy(&src->value, &dst->value, NULL); + if(retval != UA_STATUSCODE_GOOD) + DataValue_clear(dst, NULL); + return retval; +} + +/* DiagnosticInfo */ +static void +DiagnosticInfo_clear(UA_DiagnosticInfo *p, const UA_DataType *_) { + String_clear(&p->additionalInfo, NULL); + if(p->hasInnerDiagnosticInfo && p->innerDiagnosticInfo) { + DiagnosticInfo_clear(p->innerDiagnosticInfo, NULL); + UA_free(p->innerDiagnosticInfo); + } +} + +static UA_StatusCode +DiagnosticInfo_copy(UA_DiagnosticInfo const *src, UA_DiagnosticInfo *dst, + const UA_DataType *_) { + memcpy(dst, src, sizeof(UA_DiagnosticInfo)); + UA_String_init(&dst->additionalInfo); + dst->innerDiagnosticInfo = NULL; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(src->hasAdditionalInfo) + retval = UA_String_copy(&src->additionalInfo, &dst->additionalInfo); + if(src->hasInnerDiagnosticInfo && src->innerDiagnosticInfo) { + dst->innerDiagnosticInfo = (UA_DiagnosticInfo*) + UA_malloc(sizeof(UA_DiagnosticInfo)); + if(UA_LIKELY(dst->innerDiagnosticInfo != NULL)) { + retval |= DiagnosticInfo_copy(src->innerDiagnosticInfo, + dst->innerDiagnosticInfo, NULL); + dst->hasInnerDiagnosticInfo = true; + } else { + dst->hasInnerDiagnosticInfo = false; + retval |= UA_STATUSCODE_BADOUTOFMEMORY; + } + } + return retval; +} + +/* StatusCode */ +UA_Boolean +UA_StatusCode_isBad(const UA_StatusCode code) { + if ((code & 0x80000000) != 0) { + return UA_TRUE; + } + return UA_FALSE; +} + +/********************/ +/* Structured Types */ +/********************/ + +void * +UA_new(const UA_DataType *type) { + void *p = UA_calloc(1, type->memSize); + return p; +} + +static UA_StatusCode +copyByte(const u8 *src, u8 *dst, const UA_DataType *_) { + *dst = *src; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copy2Byte(const u16 *src, u16 *dst, const UA_DataType *_) { + *dst = *src; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copy4Byte(const u32 *src, u32 *dst, const UA_DataType *_) { + *dst = *src; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copy8Byte(const u64 *src, u64 *dst, const UA_DataType *_) { + *dst = *src; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copyGuid(const UA_Guid *src, UA_Guid *dst, const UA_DataType *_) { + *dst = *src; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copyStructure(const void *src, void *dst, const UA_DataType *type) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + uintptr_t ptrs = (uintptr_t)src; + uintptr_t ptrd = (uintptr_t)dst; + for(size_t i = 0; i < type->membersSize; ++i) { + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + ptrs += m->padding; + ptrd += m->padding; + if(!m->isOptional) { + if(!m->isArray) { + retval |= copyJumpTable[mt->typeKind]((const void *)ptrs, (void *)ptrd, mt); + ptrs += mt->memSize; + ptrd += mt->memSize; + } else { + size_t *dst_size = (size_t*)ptrd; + const size_t size = *((const size_t*)ptrs); + ptrs += sizeof(size_t); + ptrd += sizeof(size_t); + retval |= UA_Array_copy(*(void* const*)ptrs, size, (void**)ptrd, mt); + if(retval == UA_STATUSCODE_GOOD) + *dst_size = size; + else + *dst_size = 0; + ptrs += sizeof(void*); + ptrd += sizeof(void*); + } + } else { + if(!m->isArray) { + if(*(void* const*)ptrs != NULL) + retval |= UA_Array_copy(*(void* const*)ptrs, 1, (void**)ptrd, mt); + } else { + if(*(void* const*)(ptrs+sizeof(size_t)) != NULL) { + size_t *dst_size = (size_t*)ptrd; + const size_t size = *((const size_t*)ptrs); + ptrs += sizeof(size_t); + ptrd += sizeof(size_t); + retval |= UA_Array_copy(*(void* const*)ptrs, size, (void**)ptrd, mt); + if(retval == UA_STATUSCODE_GOOD) + *dst_size = size; + else + *dst_size = 0; + } else { + ptrs += sizeof(size_t); + ptrd += sizeof(size_t); + } + } + ptrs += sizeof(void*); + ptrd += sizeof(void*); + } + } + return retval; +} + +static UA_StatusCode +copyUnion(const void *src, void *dst, const UA_DataType *type) { + uintptr_t ptrs = (uintptr_t) src; + uintptr_t ptrd = (uintptr_t) dst; + UA_UInt32 selection = *(UA_UInt32 *)ptrs; + UA_copy((const UA_UInt32 *) ptrs, (UA_UInt32 *) ptrd, &UA_TYPES[UA_TYPES_UINT32]); + if(selection == 0) + return UA_STATUSCODE_GOOD; + const UA_DataTypeMember *m = &type->members[selection-1]; + const UA_DataType *mt = m->memberType; + ptrs += m->padding; + ptrd += m->padding; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + + if (m->isArray) { + size_t *dst_size = (size_t*)ptrd; + const size_t size = *((const size_t*)ptrs); + ptrs += sizeof(size_t); + ptrd += sizeof(size_t); + retval = UA_Array_copy(*(void* const*)ptrs, size, (void**)ptrd, mt); + if(retval == UA_STATUSCODE_GOOD) + *dst_size = size; + else + *dst_size = 0; + } else { + retval = copyJumpTable[mt->typeKind]((const void *)ptrs, (void *)ptrd, mt); + } + + return retval; +} + +static UA_StatusCode +copyNotImplemented(const void *src, void *dst, const UA_DataType *type) { + return UA_STATUSCODE_BADNOTIMPLEMENTED; +} + +const UA_copySignature copyJumpTable[UA_DATATYPEKINDS] = { + (UA_copySignature)copyByte, /* Boolean */ + (UA_copySignature)copyByte, /* SByte */ + (UA_copySignature)copyByte, /* Byte */ + (UA_copySignature)copy2Byte, /* Int16 */ + (UA_copySignature)copy2Byte, /* UInt16 */ + (UA_copySignature)copy4Byte, /* Int32 */ + (UA_copySignature)copy4Byte, /* UInt32 */ + (UA_copySignature)copy8Byte, /* Int64 */ + (UA_copySignature)copy8Byte, /* UInt64 */ + (UA_copySignature)copy4Byte, /* Float */ + (UA_copySignature)copy8Byte, /* Double */ + (UA_copySignature)String_copy, + (UA_copySignature)copy8Byte, /* DateTime */ + (UA_copySignature)copyGuid, /* Guid */ + (UA_copySignature)String_copy, /* ByteString */ + (UA_copySignature)String_copy, /* XmlElement */ + (UA_copySignature)NodeId_copy, + (UA_copySignature)ExpandedNodeId_copy, + (UA_copySignature)copy4Byte, /* StatusCode */ + (UA_copySignature)QualifiedName_copy, + (UA_copySignature)LocalizedText_copy, + (UA_copySignature)ExtensionObject_copy, + (UA_copySignature)DataValue_copy, + (UA_copySignature)Variant_copy, + (UA_copySignature)DiagnosticInfo_copy, + (UA_copySignature)copyNotImplemented, /* Decimal */ + (UA_copySignature)copy4Byte, /* Enumeration */ + (UA_copySignature)copyStructure, + (UA_copySignature)copyStructure, /* Structure with Optional Fields */ + (UA_copySignature)copyUnion, /* Union */ + (UA_copySignature)copyNotImplemented /* BitfieldCluster*/ +}; + +UA_StatusCode +UA_copy(const void *src, void *dst, const UA_DataType *type) { + memset(dst, 0, type->memSize); /* init */ + UA_StatusCode retval = copyJumpTable[type->typeKind](src, dst, type); + if(retval != UA_STATUSCODE_GOOD) + UA_clear(dst, type); + return retval; +} + +static void +clearStructure(void *p, const UA_DataType *type) { + uintptr_t ptr = (uintptr_t)p; + for(size_t i = 0; i < type->membersSize; ++i) { + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + ptr += m->padding; + if(!m->isOptional) { + if(!m->isArray) { + clearJumpTable[mt->typeKind]((void*)ptr, mt); + ptr += mt->memSize; + } else { + size_t length = *(size_t*)ptr; + ptr += sizeof(size_t); + UA_Array_delete(*(void**)ptr, length, mt); + ptr += sizeof(void*); + } + } else { /* field is optional */ + if(!m->isArray) { + /* optional scalar field is contained */ + if((*(void *const *)ptr != NULL)) + UA_Array_delete(*(void **)ptr, 1, mt); + ptr += sizeof(void *); + } else { + /* optional array field is contained */ + if((*(void *const *)(ptr + sizeof(size_t)) != NULL)) { + size_t length = *(size_t *)ptr; + ptr += sizeof(size_t); + UA_Array_delete(*(void **)ptr, length, mt); + ptr += sizeof(void *); + } else { /* optional array field not contained */ + ptr += sizeof(size_t); + ptr += sizeof(void *); + } + } + } + } +} + +static void +clearUnion(void *p, const UA_DataType *type) { + uintptr_t ptr = (uintptr_t) p; + UA_UInt32 selection = *(UA_UInt32 *)ptr; + if(selection == 0) + return; + const UA_DataTypeMember *m = &type->members[selection-1]; + const UA_DataType *mt = m->memberType; + ptr += m->padding; + if (m->isArray) { + size_t length = *(size_t *)ptr; + ptr += sizeof(size_t); + UA_Array_delete(*(void **)ptr, length, mt); + } else { + UA_clear((void *) ptr, mt); + } +} + +static void nopClear(void *p, const UA_DataType *type) { } + +const +UA_clearSignature clearJumpTable[UA_DATATYPEKINDS] = { + (UA_clearSignature)nopClear, /* Boolean */ + (UA_clearSignature)nopClear, /* SByte */ + (UA_clearSignature)nopClear, /* Byte */ + (UA_clearSignature)nopClear, /* Int16 */ + (UA_clearSignature)nopClear, /* UInt16 */ + (UA_clearSignature)nopClear, /* Int32 */ + (UA_clearSignature)nopClear, /* UInt32 */ + (UA_clearSignature)nopClear, /* Int64 */ + (UA_clearSignature)nopClear, /* UInt64 */ + (UA_clearSignature)nopClear, /* Float */ + (UA_clearSignature)nopClear, /* Double */ + (UA_clearSignature)String_clear, /* String */ + (UA_clearSignature)nopClear, /* DateTime */ + (UA_clearSignature)nopClear, /* Guid */ + (UA_clearSignature)String_clear, /* ByteString */ + (UA_clearSignature)String_clear, /* XmlElement */ + (UA_clearSignature)NodeId_clear, + (UA_clearSignature)ExpandedNodeId_clear, + (UA_clearSignature)nopClear, /* StatusCode */ + (UA_clearSignature)QualifiedName_clear, + (UA_clearSignature)LocalizedText_clear, + (UA_clearSignature)ExtensionObject_clear, + (UA_clearSignature)DataValue_clear, + (UA_clearSignature)Variant_clear, + (UA_clearSignature)DiagnosticInfo_clear, + (UA_clearSignature)nopClear, /* Decimal, not implemented */ + (UA_clearSignature)nopClear, /* Enumeration */ + (UA_clearSignature)clearStructure, + (UA_clearSignature)clearStructure, /* Struct with Optional Fields*/ + (UA_clearSignature)clearUnion, /* Union*/ + (UA_clearSignature)nopClear /* BitfieldCluster, not implemented*/ +}; + +void +UA_clear(void *p, const UA_DataType *type) { + clearJumpTable[type->typeKind](p, type); + memset(p, 0, type->memSize); /* init */ +} + +void +UA_delete(void *p, const UA_DataType *type) { + clearJumpTable[type->typeKind](p, type); + UA_free(p); +} + +/******************/ +/* Value Ordering */ +/******************/ + +#define UA_NUMERICORDER(NAME, TYPE) \ + static UA_Order \ + NAME(const TYPE *p1, const TYPE *p2, const UA_DataType *type) { \ + if(*p1 != *p2) \ + return (*p1 < *p2) ? UA_ORDER_LESS : UA_ORDER_MORE; \ + return UA_ORDER_EQ; \ + } + +UA_NUMERICORDER(booleanOrder, UA_Boolean) +UA_NUMERICORDER(sByteOrder, UA_SByte) +UA_NUMERICORDER(byteOrder, UA_Byte) +UA_NUMERICORDER(int16Order, UA_Int16) +UA_NUMERICORDER(uInt16Order, UA_UInt16) +UA_NUMERICORDER(int32Order, UA_Int32) +UA_NUMERICORDER(uInt32Order, UA_UInt32) +UA_NUMERICORDER(int64Order, UA_Int64) +UA_NUMERICORDER(uInt64Order, UA_UInt64) + +#define UA_FLOATORDER(NAME, TYPE) \ + static UA_Order \ + NAME(const TYPE *p1, const TYPE *p2, const UA_DataType *type) { \ + if(*p1 != *p2) { \ + /* p1 is NaN */ \ + if(*p1 != *p1) { \ + if(*p2 != *p2) \ + return UA_ORDER_EQ; \ + return UA_ORDER_LESS; \ + } \ + /* p2 is NaN */ \ + if(*p2 != *p2) \ + return UA_ORDER_MORE; \ + return (*p1 < *p2) ? UA_ORDER_LESS : UA_ORDER_MORE; \ + } \ + return UA_ORDER_EQ; \ + } + +UA_FLOATORDER(floatOrder, UA_Float) +UA_FLOATORDER(doubleOrder, UA_Double) + +static UA_Order +guidOrder(const UA_Guid *p1, const UA_Guid *p2, const UA_DataType *type) { + if(p1->data1 != p2->data1) + return (p1->data1 < p2->data1) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->data2 != p2->data2) + return (p1->data2 < p2->data2) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->data3 != p2->data3) + return (p1->data3 < p2->data3) ? UA_ORDER_LESS : UA_ORDER_MORE; + int cmp = memcmp(p1->data4, p2->data4, 8); + if(cmp != 0) + return (cmp < 0) ? UA_ORDER_LESS : UA_ORDER_MORE; + return UA_ORDER_EQ; +} + +static UA_Order +stringOrder(const UA_String *p1, const UA_String *p2, const UA_DataType *type) { + if(p1->length != p2->length) + return (p1->length < p2->length) ? UA_ORDER_LESS : UA_ORDER_MORE; + /* For zero-length arrays, every pointer not NULL is considered a + * UA_EMPTY_ARRAY_SENTINEL. */ + if(p1->data == p2->data) return UA_ORDER_EQ; + if(p1->data == NULL) return UA_ORDER_LESS; + if(p2->data == NULL) return UA_ORDER_MORE; + int cmp = memcmp((const char*)p1->data, (const char*)p2->data, p1->length); + if(cmp != 0) + return (cmp < 0) ? UA_ORDER_LESS : UA_ORDER_MORE; + return UA_ORDER_EQ; +} + +static UA_Order +nodeIdOrder(const UA_NodeId *p1, const UA_NodeId *p2, const UA_DataType *type) { + return UA_NodeId_order(p1, p2); +} + +static UA_Order +expandedNodeIdOrder(const UA_ExpandedNodeId *p1, const UA_ExpandedNodeId *p2, + const UA_DataType *type) { + return UA_ExpandedNodeId_order(p1, p2); +} + +static UA_Order +qualifiedNameOrder(const UA_QualifiedName *p1, const UA_QualifiedName *p2, + const UA_DataType *type) { + if(p1->namespaceIndex != p2->namespaceIndex) + return (p1->namespaceIndex < p2->namespaceIndex) ? UA_ORDER_LESS : UA_ORDER_MORE; + return stringOrder(&p1->name, &p2->name, NULL); +} + +static UA_Order +localizedTextOrder(const UA_LocalizedText *p1, const UA_LocalizedText *p2, + const UA_DataType *type) { + UA_Order o = stringOrder(&p1->locale, &p2->locale, NULL); + if(o != UA_ORDER_EQ) + return o; + return stringOrder(&p1->text, &p2->text, NULL); +} + +static UA_Order +extensionObjectOrder(const UA_ExtensionObject *p1, const UA_ExtensionObject *p2, + const UA_DataType *type) { + UA_ExtensionObjectEncoding enc1 = p1->encoding; + UA_ExtensionObjectEncoding enc2 = p2->encoding; + if(enc1 > UA_EXTENSIONOBJECT_DECODED) + enc1 = UA_EXTENSIONOBJECT_DECODED; + if(enc2 > UA_EXTENSIONOBJECT_DECODED) + enc2 = UA_EXTENSIONOBJECT_DECODED; + if(enc1 != enc2) + return (enc1 < enc2) ? UA_ORDER_LESS : UA_ORDER_MORE; + + switch(enc1) { + case UA_EXTENSIONOBJECT_ENCODED_NOBODY: + return UA_ORDER_EQ; + + case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING: + case UA_EXTENSIONOBJECT_ENCODED_XML: { + UA_Order o = UA_NodeId_order(&p1->content.encoded.typeId, + &p2->content.encoded.typeId); + if(o == UA_ORDER_EQ) + o = stringOrder((const UA_String*)&p1->content.encoded.body, + (const UA_String*)&p2->content.encoded.body, NULL); + return o; + } + + case UA_EXTENSIONOBJECT_DECODED: + default: { + const UA_DataType *type1 = p1->content.decoded.type; + const UA_DataType *type2 = p1->content.decoded.type; + if(type1 != type2) + return ((uintptr_t)type1 < (uintptr_t)type2) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(!type1) + return UA_ORDER_EQ; + return orderJumpTable[type1->typeKind] + (p1->content.decoded.data, p2->content.decoded.data, type1); + } + } +} + +static UA_Order +arrayOrder(const void *p1, size_t p1Length, const void *p2, size_t p2Length, + const UA_DataType *type) { + if(p1Length != p2Length) + return (p1Length < p2Length) ? UA_ORDER_LESS : UA_ORDER_MORE; + /* For zero-length arrays, every pointer not NULL is considered a + * UA_EMPTY_ARRAY_SENTINEL. */ + if(p1 == p2) return UA_ORDER_EQ; + if(p1 == NULL) return UA_ORDER_LESS; + if(p2 == NULL) return UA_ORDER_MORE; + uintptr_t u1 = (uintptr_t)p1; + uintptr_t u2 = (uintptr_t)p2; + for(size_t i = 0; i < p1Length; i++) { + UA_Order o = orderJumpTable[type->typeKind]((const void*)u1, (const void*)u2, type); + if(o != UA_ORDER_EQ) + return o; + u1 += type->memSize; + u2 += type->memSize; + } + return UA_ORDER_EQ; +} + +static UA_Order +variantOrder(const UA_Variant *p1, const UA_Variant *p2, + const UA_DataType *type) { + if(p1->type != p2->type) + return ((uintptr_t)p1->type < (uintptr_t)p2->type) ? UA_ORDER_LESS : UA_ORDER_MORE; + + if(p1->arrayLength != p2->arrayLength) + return (p1->arrayLength < p2->arrayLength) ? UA_ORDER_LESS : UA_ORDER_MORE; + + UA_Order o; + if(p1->type != NULL) { + if(p1->arrayLength == 0) + o = orderJumpTable[p1->type->typeKind](p1->data, p2->data, p1->type); + else + o = arrayOrder(p1->data, p1->arrayLength, p2->data, p2->arrayLength, p1->type); + if(o != UA_ORDER_EQ) + return o; + } + + if(p1->arrayDimensionsSize != p2->arrayDimensionsSize) + return (p1->arrayDimensionsSize < p2->arrayDimensionsSize) ? + UA_ORDER_LESS : UA_ORDER_MORE; + o = UA_ORDER_EQ; + if(p1->arrayDimensionsSize > 0) + o = arrayOrder(p1->arrayDimensions, p1->arrayDimensionsSize, + p2->arrayDimensions, p2->arrayDimensionsSize, + &UA_TYPES[UA_TYPES_UINT32]); + return o; +} + +static UA_Order +dataValueOrder(const UA_DataValue *p1, const UA_DataValue *p2, + const UA_DataType *type) { + /* Value */ + if(p1->hasValue != p2->hasValue) + return (!p1->hasValue) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasValue) { + UA_Order o = variantOrder(&p1->value, &p2->value, NULL); + if(o != UA_ORDER_EQ) + return o; + } + + /* Status */ + if(p1->hasStatus != p2->hasStatus) + return (!p1->hasStatus) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasStatus && p1->status != p2->status) + return (p1->status < p2->status) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* SourceTimestamp */ + if(p1->hasSourceTimestamp != p2->hasSourceTimestamp) + return (!p1->hasSourceTimestamp) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasSourceTimestamp && p1->sourceTimestamp != p2->sourceTimestamp) + return (p1->sourceTimestamp < p2->sourceTimestamp) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* ServerTimestamp */ + if(p1->hasServerTimestamp != p2->hasServerTimestamp) + return (!p1->hasServerTimestamp) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasServerTimestamp && p1->serverTimestamp != p2->serverTimestamp) + return (p1->serverTimestamp < p2->serverTimestamp) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* SourcePicoseconds */ + if(p1->hasSourcePicoseconds != p2->hasSourcePicoseconds) + return (!p1->hasSourcePicoseconds) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasSourcePicoseconds && p1->sourcePicoseconds != p2->sourcePicoseconds) + return (p1->sourcePicoseconds < p2->sourcePicoseconds) ? + UA_ORDER_LESS : UA_ORDER_MORE; + + /* ServerPicoseconds */ + if(p1->hasServerPicoseconds != p2->hasServerPicoseconds) + return (!p1->hasServerPicoseconds) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasServerPicoseconds && p1->serverPicoseconds != p2->serverPicoseconds) + return (p1->serverPicoseconds < p2->serverPicoseconds) ? + UA_ORDER_LESS : UA_ORDER_MORE; + + return UA_ORDER_EQ; +} + +static UA_Order +diagnosticInfoOrder(const UA_DiagnosticInfo *p1, const UA_DiagnosticInfo *p2, + const UA_DataType *type) { + /* SymbolicId */ + if(p1->hasSymbolicId != p2->hasSymbolicId) + return (!p1->hasSymbolicId) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasSymbolicId && p1->symbolicId != p2->symbolicId) + return (p1->symbolicId < p2->symbolicId) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* NamespaceUri */ + if(p1->hasNamespaceUri != p2->hasNamespaceUri) + return (!p1->hasNamespaceUri) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasNamespaceUri && p1->namespaceUri != p2->namespaceUri) + return (p1->namespaceUri < p2->namespaceUri) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* LocalizedText */ + if(p1->hasLocalizedText != p2->hasLocalizedText) + return (!p1->hasLocalizedText) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasLocalizedText && p1->localizedText != p2->localizedText) + return (p1->localizedText < p2->localizedText) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* Locale */ + if(p1->hasLocale != p2->hasLocale) + return (!p1->hasLocale) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasLocale && p1->locale != p2->locale) + return (p1->locale < p2->locale) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* AdditionalInfo */ + if(p1->hasAdditionalInfo != p2->hasAdditionalInfo) + return (!p1->hasAdditionalInfo) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasAdditionalInfo) { + UA_Order o = stringOrder(&p1->additionalInfo, &p2->additionalInfo, NULL); + if(o != UA_ORDER_EQ) + return o; + } + + /* InnerStatusCode */ + if(p1->hasInnerStatusCode != p2->hasInnerStatusCode) + return (!p1->hasInnerStatusCode) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->hasInnerStatusCode && p1->innerStatusCode != p2->innerStatusCode) + return (p1->innerStatusCode < p2->innerStatusCode) ? UA_ORDER_LESS : UA_ORDER_MORE; + + /* InnerDiagnosticInfo */ + if(p1->hasInnerDiagnosticInfo != p2->hasInnerDiagnosticInfo) + return (!p1->hasInnerDiagnosticInfo) ? UA_ORDER_LESS : UA_ORDER_MORE; + if(p1->innerDiagnosticInfo == p2->innerDiagnosticInfo) + return UA_ORDER_EQ; + if(!p1->innerDiagnosticInfo || !p2->innerDiagnosticInfo) + return (!p1->innerDiagnosticInfo) ? UA_ORDER_LESS : UA_ORDER_MORE; + return diagnosticInfoOrder(p1->innerDiagnosticInfo, p2->innerDiagnosticInfo, NULL); +} + +static UA_Order +structureOrder(const void *p1, const void *p2, const UA_DataType *type) { + uintptr_t u1 = (uintptr_t)p1; + uintptr_t u2 = (uintptr_t)p2; + UA_Order o = UA_ORDER_EQ; + for(size_t i = 0; i < type->membersSize; ++i) { + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + u1 += m->padding; + u2 += m->padding; + if(!m->isOptional) { + if(!m->isArray) { + o = orderJumpTable[mt->typeKind]((const void *)u1, (const void *)u2, mt); + u1 += mt->memSize; + u2 += mt->memSize; + } else { + size_t size1 = *(size_t*)u1; + size_t size2 = *(size_t*)u2; + u1 += sizeof(size_t); + u2 += sizeof(size_t); + o = arrayOrder((const void*)u1, size1, (const void*)u2, size2, mt); + u1 += sizeof(void*); + u2 += sizeof(void*); + } + } else { + if(!m->isArray) { + const void *pp1 = *(void* const*)u1; + const void *pp2 = *(void* const*)u2; + if(pp1 == pp2) { + o = UA_ORDER_EQ; + } else if(pp1 == NULL) { + o = UA_ORDER_LESS; + } else if(pp2 == NULL) { + o = UA_ORDER_MORE; + } else { + o = orderJumpTable[mt->typeKind](pp1, pp2, mt); + } + } else { + size_t sa1 = *(size_t*)u1; + size_t sa2 = *(size_t*)u2; + u1 += sizeof(size_t); + u2 += sizeof(size_t); + const void *pa1 = *(void* const*)u1; + const void *pa2 = *(void* const*)u2; + o = arrayOrder(pa1, sa1, pa2, sa2, mt); + } + u1 += sizeof(void*); + u2 += sizeof(void*); + } + + if(o != UA_ORDER_EQ) + break; + } + return o; +} + +static UA_Order +unionOrder(const void *p1, const void *p2, const UA_DataType *type) { + UA_UInt32 sel1 = *(const UA_UInt32 *)p1; + UA_UInt32 sel2 = *(const UA_UInt32 *)p2; + if(sel1 != sel2) + return (sel1 < sel2) ? UA_ORDER_LESS : UA_ORDER_MORE; + + const UA_DataTypeMember *m = &type->members[sel1-1]; + const UA_DataType *mt = m->memberType; + + uintptr_t u1 = ((uintptr_t)p1) + m->padding; /* includes switchfield length */ + uintptr_t u2 = ((uintptr_t)p2) + m->padding; + if(m->isArray) { + size_t sa1 = *(size_t*)u1; + size_t sa2 = *(size_t*)u2; + u1 += sizeof(size_t); + u2 += sizeof(size_t); + return arrayOrder(*(void* const*)u1, sa1, *(void* const*)u2, sa2, mt); + } + return orderJumpTable[mt->typeKind]((const void*)u1, (const void*)u2, mt); +} + +static UA_Order +notImplementedOrder(const void *p1, const void *p2, const UA_DataType *type) { + return UA_ORDER_EQ; +} + +const +UA_orderSignature orderJumpTable[UA_DATATYPEKINDS] = { + (UA_orderSignature)booleanOrder, + (UA_orderSignature)sByteOrder, + (UA_orderSignature)byteOrder, + (UA_orderSignature)int16Order, + (UA_orderSignature)uInt16Order, + (UA_orderSignature)int32Order, + (UA_orderSignature)uInt32Order, + (UA_orderSignature)int64Order, + (UA_orderSignature)uInt64Order, + (UA_orderSignature)floatOrder, + (UA_orderSignature)doubleOrder, + (UA_orderSignature)stringOrder, + (UA_orderSignature)int64Order, /* DateTime */ + (UA_orderSignature)guidOrder, + (UA_orderSignature)stringOrder, /* ByteString */ + (UA_orderSignature)stringOrder, /* XmlElement */ + (UA_orderSignature)nodeIdOrder, + (UA_orderSignature)expandedNodeIdOrder, + (UA_orderSignature)uInt32Order, /* StatusCode */ + (UA_orderSignature)qualifiedNameOrder, + (UA_orderSignature)localizedTextOrder, + (UA_orderSignature)extensionObjectOrder, + (UA_orderSignature)dataValueOrder, + (UA_orderSignature)variantOrder, + (UA_orderSignature)diagnosticInfoOrder, + notImplementedOrder, /* Decimal, not implemented */ + (UA_orderSignature)uInt32Order, /* Enumeration */ + (UA_orderSignature)structureOrder, + (UA_orderSignature)structureOrder, /* Struct with Optional Fields*/ + (UA_orderSignature)unionOrder, /* Union*/ + notImplementedOrder /* BitfieldCluster, not implemented */ +}; + +UA_Order UA_order(const void *p1, const void *p2, const UA_DataType *type) { + return orderJumpTable[type->typeKind](p1, p2, type); +} + +/******************/ +/* Array Handling */ +/******************/ + +void * +UA_Array_new(size_t size, const UA_DataType *type) { + if(size > UA_INT32_MAX) + return NULL; + if(size == 0) + return UA_EMPTY_ARRAY_SENTINEL; + return UA_calloc(size, type->memSize); +} + +UA_StatusCode +UA_Array_copy(const void *src, size_t size, + void **dst, const UA_DataType *type) { + if(size == 0) { + if(src == NULL) + *dst = NULL; + else + *dst= UA_EMPTY_ARRAY_SENTINEL; + return UA_STATUSCODE_GOOD; + } + + if(!type) + return UA_STATUSCODE_BADINTERNALERROR; + + /* calloc, so we don't have to check retval in every iteration of copying */ + *dst = UA_calloc(size, type->memSize); + if(!*dst) + return UA_STATUSCODE_BADOUTOFMEMORY; + + if(type->pointerFree) { + memcpy(*dst, src, type->memSize * size); + return UA_STATUSCODE_GOOD; + } + + uintptr_t ptrs = (uintptr_t)src; + uintptr_t ptrd = (uintptr_t)*dst; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < size; ++i) { + retval |= UA_copy((void*)ptrs, (void*)ptrd, type); + ptrs += type->memSize; + ptrd += type->memSize; + } + if(retval != UA_STATUSCODE_GOOD) { + UA_Array_delete(*dst, size, type); + *dst = NULL; + } + return retval; +} + +UA_StatusCode +UA_Array_resize(void **p, size_t *size, size_t newSize, + const UA_DataType *type) { + if(*size == newSize) + return UA_STATUSCODE_GOOD; + + /* Empty array? */ + if(newSize == 0) { + UA_Array_delete(*p, *size, type); + *p = UA_EMPTY_ARRAY_SENTINEL; + *size = 0; + return UA_STATUSCODE_GOOD; + } + + /* Make a copy of the members that shall be removed. Realloc can fail during + * trimming. So we cannot clear the members already here. */ + void *deleteMembers = NULL; + if(newSize < *size && !type->pointerFree) { + size_t deleteSize = *size - newSize; + deleteMembers = UA_malloc(deleteSize * type->memSize); + if(!deleteMembers) + return UA_STATUSCODE_BADOUTOFMEMORY; + memcpy(deleteMembers, (void*)((uintptr_t)*p + (newSize * type->memSize)), + deleteSize * type->memSize); /* shallow copy */ + } + + void *oldP = *p; + if(oldP == UA_EMPTY_ARRAY_SENTINEL) + oldP = NULL; + + /* Realloc */ + void *newP = UA_realloc(oldP, newSize * type->memSize); + if(!newP) { + if(deleteMembers) + UA_free(deleteMembers); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + /* Clear removed members or initialize the new ones. Note that deleteMembers + * depends on type->pointerFree. */ + if(newSize > *size) + memset((void*)((uintptr_t)newP + (*size * type->memSize)), 0, + (newSize - *size) * type->memSize); + else if(deleteMembers) + UA_Array_delete(deleteMembers, *size - newSize, type); + + /* Set the new array */ + *p = newP; + *size = newSize; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Array_append(void **p, size_t *size, void *newElem, + const UA_DataType *type) { + /* Resize the array */ + size_t oldSize = *size; + UA_StatusCode res = UA_Array_resize(p, size, oldSize+1, type); + if(res != UA_STATUSCODE_GOOD) + return res; + + /* Move the value */ + memcpy((void*)((uintptr_t)*p + (oldSize * type->memSize)), + newElem, type->memSize); + UA_init(newElem, type); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode UA_EXPORT +UA_Array_appendCopy(void **p, size_t *size, const void *newElem, + const UA_DataType *type) { + char scratch[512]; + if(type->memSize > 512) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Copy the value */ + UA_StatusCode res = UA_copy(newElem, (void*)scratch, type); + if(res != UA_STATUSCODE_GOOD) + return res; + + /* Append */ + res = UA_Array_append(p, size, (void*)scratch, type); + if(res != UA_STATUSCODE_GOOD) + UA_clear((void*)scratch, type); + return res; +} + +void +UA_Array_delete(void *p, size_t size, const UA_DataType *type) { + if(!type->pointerFree) { + uintptr_t ptr = (uintptr_t)p; + for(size_t i = 0; i < size; ++i) { + UA_clear((void*)ptr, type); + ptr += type->memSize; + } + } + UA_free((void*)((uintptr_t)p & ~(uintptr_t)UA_EMPTY_ARRAY_SENTINEL)); +} + +UA_Boolean +UA_DataType_isNumeric(const UA_DataType *type) { + switch(type->typeKind) { + case UA_DATATYPEKIND_SBYTE: + case UA_DATATYPEKIND_BYTE: + case UA_DATATYPEKIND_INT16: + case UA_DATATYPEKIND_UINT16: + case UA_DATATYPEKIND_INT32: + case UA_DATATYPEKIND_UINT32: + case UA_DATATYPEKIND_INT64: + case UA_DATATYPEKIND_UINT64: + case UA_DATATYPEKIND_FLOAT: + case UA_DATATYPEKIND_DOUBLE: + /* not implemented: UA_DATATYPEKIND_DECIMAL */ + return true; + default: + return false; + } +} + +/**********************/ +/* Parse NumericRange */ +/**********************/ + +static size_t +readDimension(UA_Byte *buf, size_t buflen, UA_NumericRangeDimension *dim) { + size_t progress = UA_readNumber(buf, buflen, &dim->min); + if(progress == 0) + return 0; + if(buflen <= progress + 1 || buf[progress] != ':') { + dim->max = dim->min; + return progress; + } + + ++progress; + size_t progress2 = UA_readNumber(&buf[progress], buflen - progress, &dim->max); + if(progress2 == 0) + return 0; + + /* invalid range */ + if(dim->min >= dim->max) + return 0; + + return progress + progress2; +} + +UA_StatusCode +UA_NumericRange_parse(UA_NumericRange *range, const UA_String str) { + size_t idx = 0; + size_t dimensionsMax = 0; + UA_NumericRangeDimension *dimensions = NULL; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + size_t offset = 0; + while(true) { + /* alloc dimensions */ + if(idx >= dimensionsMax) { + UA_NumericRangeDimension *newds; + size_t newdssize = sizeof(UA_NumericRangeDimension) * (dimensionsMax + 2); + newds = (UA_NumericRangeDimension*)UA_realloc(dimensions, newdssize); + if(!newds) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + break; + } + dimensions = newds; + dimensionsMax = dimensionsMax + 2; + } + + /* read the dimension */ + size_t progress = readDimension(&str.data[offset], str.length - offset, + &dimensions[idx]); + if(progress == 0) { + retval = UA_STATUSCODE_BADINDEXRANGEINVALID; + break; + } + offset += progress; + ++idx; + + /* loop into the next dimension */ + if(offset >= str.length) + break; + + if(str.data[offset] != ',') { + retval = UA_STATUSCODE_BADINDEXRANGEINVALID; + break; + } + ++offset; + } + + if(retval == UA_STATUSCODE_GOOD && idx > 0) { + range->dimensions = dimensions; + range->dimensionsSize = idx; + } else { + UA_free(dimensions); + } + + return retval; +} + +/**** amalgamated original file "/src/ua_types_encoding_binary.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright 2020 (c) Grigory Friedman + * Copyright 2014-2021 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2017 (c) Florian Palm + * Copyright 2014-2016 (c) Sten Grüner + * Copyright 2014 (c) Leon Urbas + * Copyright 2015 (c) LEvertz + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2016 (c) Lorenz Haas + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2017 (c) Henrik Norrman + */ + + + +/** + * Type Encoding and Decoding + * -------------------------- + * The following methods contain encoding and decoding functions for the builtin + * data types and generic functions that operate on all types and arrays. This + * requires the type description from a UA_DataType structure. + * + * Breaking a message up into chunks is integrated with the encoding. When the + * end of a buffer is reached, a callback is executed that sends the current + * buffer as a chunk and exchanges the encoding buffer "underneath" the ongoing + * encoding. This reduces the RAM requirements and unnecessary copying. */ + +/* Part 6 §5.1.5: Decoders shall support at least 100 nesting levels */ +#define UA_ENCODING_MAX_RECURSION 100 + +typedef struct { + /* Pointers to the current and last buffer position */ + u8 *pos; + const u8 *end; + + /* How often did we en-/decoding recurse? */ + u16 depth; + + const UA_DataTypeArray *customTypes; + UA_exchangeEncodeBuffer exchangeBufferCallback; + void *exchangeBufferCallbackHandle; +} Ctx; + +typedef status +(*encodeBinarySignature)(const void *UA_RESTRICT src, const UA_DataType *type, + Ctx *UA_RESTRICT ctx); +typedef status +(*decodeBinarySignature)(void *UA_RESTRICT dst, const UA_DataType *type, + Ctx *UA_RESTRICT ctx); +typedef size_t +(*calcSizeBinarySignature)(const void *UA_RESTRICT p, const UA_DataType *type); + +#define ENCODE_BINARY(TYPE) static status \ + TYPE##_encodeBinary(const UA_##TYPE *UA_RESTRICT src, \ + const UA_DataType *type, Ctx *UA_RESTRICT ctx) +#define DECODE_BINARY(TYPE) static status \ + TYPE##_decodeBinary(UA_##TYPE *UA_RESTRICT dst, \ + const UA_DataType *type, Ctx *UA_RESTRICT ctx) +#define CALCSIZE_BINARY(TYPE) static size_t \ + TYPE##_calcSizeBinary(const UA_##TYPE *UA_RESTRICT src, const UA_DataType *_) +#define ENCODE_DIRECT(SRC, TYPE) TYPE##_encodeBinary((const UA_##TYPE*)SRC, NULL, ctx) +#define DECODE_DIRECT(DST, TYPE) TYPE##_decodeBinary((UA_##TYPE*)DST, NULL, ctx) + +/* Jumptables for de-/encoding and computing the buffer length. The methods in + * the decoding jumptable do not all clean up their allocated memory when an + * error occurs. So a final _clear needs to be called before returning to the + * user. */ +extern const encodeBinarySignature encodeBinaryJumpTable[UA_DATATYPEKINDS]; +extern const decodeBinarySignature decodeBinaryJumpTable[UA_DATATYPEKINDS]; +extern const calcSizeBinarySignature calcSizeBinaryJumpTable[UA_DATATYPEKINDS]; + +/* Send the current chunk and replace the buffer */ +static status exchangeBuffer(Ctx *ctx) { + if(!ctx->exchangeBufferCallback) + return UA_STATUSCODE_BADENCODINGERROR; + return ctx->exchangeBufferCallback(ctx->exchangeBufferCallbackHandle, + &ctx->pos, &ctx->end); +} + +/* If encoding fails, exchange the buffer and try again. */ +static status +encodeWithExchangeBuffer(const void *ptr, const UA_DataType *type, Ctx *ctx) { + u8 *oldpos = ctx->pos; /* Last known good position */ +#ifndef NDEBUG + /* We have to ensure that the buffer was not exchanged AND + * BADENCODINGLIMITSEXCEEDED was returned. If that were the case, oldpos + * would be invalid. That means, a type encoding must never return + * BADENCODINGLIMITSEXCEEDED once the buffer could have been exchanged. This + * is achieved by the use of encodeWithExchangeBuffer. */ + const u8 *oldend = ctx->end; + (void)oldend; /* For compilers who don't understand NDEBUG... */ +#endif + status ret = encodeBinaryJumpTable[type->typeKind](ptr, type, ctx); + if(ret == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED) { + UA_assert(ctx->end == oldend); + ctx->pos = oldpos; /* Set to the last known good position and exchange */ + ret = exchangeBuffer(ctx); + UA_CHECK_STATUS(ret, return ret); + ret = encodeBinaryJumpTable[type->typeKind](ptr, type, ctx); + } + return ret; +} + +/*****************/ +/* Integer Types */ +/*****************/ + +#if !UA_BINARY_OVERLAYABLE_INTEGER + +#pragma message "Integer endianness could not be detected to be little endian. Use slow generic encoding." + +/* These en/decoding functions are only used when the architecture isn't little-endian. */ +static void +UA_encode16(const u16 v, u8 buf[2]) { + buf[0] = (u8)v; + buf[1] = (u8)(v >> 8); +} + +static void +UA_decode16(const u8 buf[2], u16 *v) { + *v = (u16)((u16)buf[0] + (((u16)buf[1]) << 8)); +} + +static void +UA_encode32(const u32 v, u8 buf[4]) { + buf[0] = (u8)v; + buf[1] = (u8)(v >> 8); + buf[2] = (u8)(v >> 16); + buf[3] = (u8)(v >> 24); +} + +static void +UA_decode32(const u8 buf[4], u32 *v) { + *v = (u32)((u32)buf[0] + (((u32)buf[1]) << 8) + + (((u32)buf[2]) << 16) + (((u32)buf[3]) << 24)); +} + +static void +UA_encode64(const u64 v, u8 buf[8]) { + buf[0] = (u8)v; + buf[1] = (u8)(v >> 8); + buf[2] = (u8)(v >> 16); + buf[3] = (u8)(v >> 24); + buf[4] = (u8)(v >> 32); + buf[5] = (u8)(v >> 40); + buf[6] = (u8)(v >> 48); + buf[7] = (u8)(v >> 56); +} + +static void +UA_decode64(const u8 buf[8], u64 *v) { + *v = (u64)((u64)buf[0] + (((u64)buf[1]) << 8) + + (((u64)buf[2]) << 16) + (((u64)buf[3]) << 24) + + (((u64)buf[4]) << 32) + (((u64)buf[5]) << 40) + + (((u64)buf[6]) << 48) + (((u64)buf[7]) << 56)); +} + +#endif /* !UA_BINARY_OVERLAYABLE_INTEGER */ + +/* Boolean */ +/* Note that sizeof(bool) != 1 on some platforms. Overlayable integer encoding + * is disabled in those cases. */ +ENCODE_BINARY(Boolean) { + UA_CHECK(ctx->pos + 1 <= ctx->end, return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + *ctx->pos = *(const u8*)src; + ++ctx->pos; + return UA_STATUSCODE_GOOD; +} + +DECODE_BINARY(Boolean) { + UA_CHECK(ctx->pos + 1 <= ctx->end, return UA_STATUSCODE_BADDECODINGERROR); + *dst = (*ctx->pos > 0) ? true : false; + ++ctx->pos; + return UA_STATUSCODE_GOOD; +} + +/* Byte */ +ENCODE_BINARY(Byte) { + UA_CHECK(ctx->pos + sizeof(u8) <= ctx->end, + return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + *ctx->pos = *(const u8*)src; + ++ctx->pos; + return UA_STATUSCODE_GOOD; +} + +DECODE_BINARY(Byte) { + UA_CHECK(ctx->pos + sizeof(u8) <= ctx->end, + return UA_STATUSCODE_BADDECODINGERROR); + *dst = *ctx->pos; + ++ctx->pos; + return UA_STATUSCODE_GOOD; +} + +/* UInt16 */ +ENCODE_BINARY(UInt16) { + UA_CHECK(ctx->pos + sizeof(u16) <= ctx->end, + return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); +#if UA_BINARY_OVERLAYABLE_INTEGER + memcpy(ctx->pos, src, sizeof(u16)); +#else + UA_encode16(*src, ctx->pos); +#endif + ctx->pos += 2; + return UA_STATUSCODE_GOOD; +} + +DECODE_BINARY(UInt16) { + UA_CHECK(ctx->pos + sizeof(u16) <= ctx->end, + return UA_STATUSCODE_BADDECODINGERROR); +#if UA_BINARY_OVERLAYABLE_INTEGER + memcpy(dst, ctx->pos, sizeof(u16)); +#else + UA_decode16(ctx->pos, dst); +#endif + ctx->pos += 2; + return UA_STATUSCODE_GOOD; +} + +/* UInt32 */ +ENCODE_BINARY(UInt32) { + UA_CHECK(ctx->pos + sizeof(u32) <= ctx->end, + return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); +#if UA_BINARY_OVERLAYABLE_INTEGER + memcpy(ctx->pos, src, sizeof(u32)); +#else + UA_encode32(*src, ctx->pos); +#endif + ctx->pos += 4; + return UA_STATUSCODE_GOOD; +} + +DECODE_BINARY(UInt32) { + UA_CHECK(ctx->pos + sizeof(u32) <= ctx->end, + return UA_STATUSCODE_BADDECODINGERROR); +#if UA_BINARY_OVERLAYABLE_INTEGER + memcpy(dst, ctx->pos, sizeof(u32)); +#else + UA_decode32(ctx->pos, dst); +#endif + ctx->pos += 4; + return UA_STATUSCODE_GOOD; +} + +/* UInt64 */ +ENCODE_BINARY(UInt64) { + UA_CHECK(ctx->pos + sizeof(u64) <= ctx->end, + return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); +#if UA_BINARY_OVERLAYABLE_INTEGER + memcpy(ctx->pos, src, sizeof(u64)); +#else + UA_encode64(*src, ctx->pos); +#endif + ctx->pos += 8; + return UA_STATUSCODE_GOOD; +} + +DECODE_BINARY(UInt64) { + UA_CHECK(ctx->pos + sizeof(u64) <= ctx->end, + return UA_STATUSCODE_BADDECODINGERROR); +#if UA_BINARY_OVERLAYABLE_INTEGER + memcpy(dst, ctx->pos, sizeof(u64)); +#else + UA_decode64(ctx->pos, dst); +#endif + ctx->pos += 8; + return UA_STATUSCODE_GOOD; +} + +/************************/ +/* Floating Point Types */ +/************************/ + +/* Can we reuse the integer encoding mechanism by casting floating point + * values? */ +#if (UA_FLOAT_IEEE754 == 1) && (UA_LITTLE_ENDIAN == UA_FLOAT_LITTLE_ENDIAN) +# define Float_encodeBinary UInt32_encodeBinary +# define Float_decodeBinary UInt32_decodeBinary +# define Double_encodeBinary UInt64_encodeBinary +# define Double_decodeBinary UInt64_decodeBinary +#else + +#include + +#pragma message "No native IEEE 754 format detected. Use slow generic encoding." + +/* Handling of IEEE754 floating point values was taken from Beej's Guide to + * Network Programming (http://beej.us/guide/bgnet/) and enhanced to cover the + * edge cases +/-0, +/-inf and nan. */ +static uint64_t +pack754(long double f, unsigned bits, unsigned expbits) { + unsigned significandbits = bits - expbits - 1; + long double fnorm; + long long sign; + if(f < 0) { sign = 1; fnorm = -f; } + else { sign = 0; fnorm = f; } + int shift = 0; + while(fnorm >= 2.0) { fnorm /= 2.0; ++shift; } + while(fnorm < 1.0) { fnorm *= 2.0; --shift; } + fnorm = fnorm - 1.0; + long long significand = (long long)(fnorm * ((float)(1LL<>significandbits) & (uint64_t)((1LL< 0) { result *= 2.0; --shift; } + while(shift < 0) { result /= 2.0; ++shift; } + result *= ((i>>(bits-1))&1)? -1.0: 1.0; + return result; +} + +/* Float */ +#define FLOAT_NAN 0xffc00000 +#define FLOAT_INF 0x7f800000 +#define FLOAT_NEG_INF 0xff800000 +#define FLOAT_NEG_ZERO 0x80000000 + +ENCODE_BINARY(Float) { + UA_Float f = *src; + u32 encoded; + /* cppcheck-suppress duplicateExpression */ + if(f != f) encoded = FLOAT_NAN; + else if(f == 0.0f) encoded = signbit(f) ? FLOAT_NEG_ZERO : 0; + else if(f/f != f/f) encoded = f > 0 ? FLOAT_INF : FLOAT_NEG_INF; + else encoded = (u32)pack754(f, 32, 8); + return ENCODE_DIRECT(&encoded, UInt32); +} + +DECODE_BINARY(Float) { + u32 decoded; + status ret = DECODE_DIRECT(&decoded, UInt32); + if(ret != UA_STATUSCODE_GOOD) + return ret; + if(decoded == 0) *dst = 0.0f; + else if(decoded == FLOAT_NEG_ZERO) *dst = -0.0f; + else if(decoded == FLOAT_INF) *dst = INFINITY; + else if(decoded == FLOAT_NEG_INF) *dst = -INFINITY; + else if((decoded >= 0x7f800001 && decoded <= 0x7fffffff) || + (decoded >= 0xff800001)) *dst = NAN; + else *dst = (UA_Float)unpack754(decoded, 32, 8); + return UA_STATUSCODE_GOOD; +} + +/* Double */ +#define DOUBLE_NAN 0xfff8000000000000L +#define DOUBLE_INF 0x7ff0000000000000L +#define DOUBLE_NEG_INF 0xfff0000000000000L +#define DOUBLE_NEG_ZERO 0x8000000000000000L + +ENCODE_BINARY(Double) { + UA_Double d = *src; + u64 encoded; + /* cppcheck-suppress duplicateExpression */ + if(d != d) encoded = DOUBLE_NAN; + else if(d == 0.0) encoded = signbit(d) ? DOUBLE_NEG_ZERO : 0; + else if(d/d != d/d) encoded = d > 0 ? DOUBLE_INF : DOUBLE_NEG_INF; + else encoded = pack754(d, 64, 11); + return ENCODE_DIRECT(&encoded, UInt64); +} + +DECODE_BINARY(Double) { + u64 decoded; + status ret = DECODE_DIRECT(&decoded, UInt64); + UA_CHECK_STATUS(ret, return ret); + if(decoded == 0) *dst = 0.0; + else if(decoded == DOUBLE_NEG_ZERO) *dst = -0.0; + else if(decoded == DOUBLE_INF) *dst = INFINITY; + else if(decoded == DOUBLE_NEG_INF) *dst = -INFINITY; + else if((decoded >= 0x7ff0000000000001L && decoded <= 0x7fffffffffffffffL) || + (decoded >= 0xfff0000000000001L)) *dst = NAN; + else *dst = (UA_Double)unpack754(decoded, 64, 11); + return UA_STATUSCODE_GOOD; +} + +#endif + +/******************/ +/* Array Handling */ +/******************/ + +static status +Array_encodeBinaryOverlayable(uintptr_t ptr, size_t memSize, Ctx *ctx) { + /* Loop as long as more elements remain than fit into the chunk */ + while(ctx->end < ctx->pos + memSize) { + size_t possible = ((uintptr_t)ctx->end - (uintptr_t)ctx->pos); + memcpy(ctx->pos, (void*)ptr, possible); + ctx->pos += possible; + ptr += possible; + status ret = exchangeBuffer(ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + memSize -= possible; + } + + /* Encode the remaining elements */ + memcpy(ctx->pos, (void*)ptr, memSize); + ctx->pos += memSize; + return UA_STATUSCODE_GOOD; +} + +static status +Array_encodeBinaryComplex(uintptr_t ptr, size_t length, + const UA_DataType *type, Ctx *ctx) { + /* Encode every element */ + for(size_t i = 0; i < length; ++i) { + status ret = encodeWithExchangeBuffer((const void*)ptr, type, ctx); + ptr += type->memSize; + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); /* Unrecoverable fail */ + } + return UA_STATUSCODE_GOOD; +} + +static status +Array_encodeBinary(const void *src, size_t length, const UA_DataType *type, Ctx *ctx) { + /* Check and convert the array length to int32 */ + i32 signed_length = -1; + if(length > UA_INT32_MAX) + return UA_STATUSCODE_BADINTERNALERROR; + if(length > 0) + signed_length = (i32)length; + else if(src == UA_EMPTY_ARRAY_SENTINEL) + signed_length = 0; + + /* Encode the array length */ + status ret = encodeWithExchangeBuffer(&signed_length, &UA_TYPES[UA_TYPES_INT32], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + + /* Encode the content */ + if(length > 0) { + if(type->overlayable) + ret = Array_encodeBinaryOverlayable((uintptr_t)src, length * type->memSize, ctx); + else + ret = Array_encodeBinaryComplex((uintptr_t)src, length, type, ctx); + } + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + return ret; +} + +static status +Array_decodeBinary(void *UA_RESTRICT *UA_RESTRICT dst, size_t *out_length, + const UA_DataType *type, Ctx *ctx) { + /* Decode the length */ + i32 signed_length; + status ret = DECODE_DIRECT(&signed_length, UInt32); /* Int32 */ + UA_CHECK_STATUS(ret, return ret); + + /* Return early for empty arrays */ + if(signed_length <= 0) { + *out_length = 0; + if(signed_length < 0) + *dst = NULL; + else + *dst = UA_EMPTY_ARRAY_SENTINEL; + return UA_STATUSCODE_GOOD; + } + + /* Filter out arrays that can obviously not be decoded, because the message + * is too small for the array length. This prevents the allocation of very + * long arrays for bogus messages.*/ + size_t length = (size_t)signed_length; + UA_CHECK(ctx->pos + ((type->memSize * length) / 32) <= ctx->end, + return UA_STATUSCODE_BADDECODINGERROR); + + /* Allocate memory */ + *dst = UA_calloc(length, type->memSize); + UA_CHECK_MEM(*dst, return UA_STATUSCODE_BADOUTOFMEMORY); + + if(type->overlayable) { + /* memcpy overlayable array */ + UA_CHECK(ctx->pos + (type->memSize * length) <= ctx->end, + UA_free(*dst); *dst = NULL; return UA_STATUSCODE_BADDECODINGERROR); + memcpy(*dst, ctx->pos, type->memSize * length); + ctx->pos += type->memSize * length; + } else { + /* Decode array members */ + uintptr_t ptr = (uintptr_t)*dst; + for(size_t i = 0; i < length; ++i) { + ret = decodeBinaryJumpTable[type->typeKind]((void*)ptr, type, ctx); + UA_CHECK_STATUS(ret, /* +1 because last element is also already initialized */ + UA_Array_delete(*dst, i+1, type); *dst = NULL; return ret); + ptr += type->memSize; + } + } + *out_length = length; + return UA_STATUSCODE_GOOD; +} + +/*****************/ +/* Builtin Types */ +/*****************/ + +ENCODE_BINARY(String) { + return Array_encodeBinary(src->data, src->length, &UA_TYPES[UA_TYPES_BYTE], ctx); +} + +DECODE_BINARY(String) { + return Array_decodeBinary((void**)&dst->data, &dst->length, &UA_TYPES[UA_TYPES_BYTE], ctx); +} + +/* Guid */ +ENCODE_BINARY(Guid) { + status ret = UA_STATUSCODE_GOOD; + ret |= ENCODE_DIRECT(&src->data1, UInt32); + ret |= ENCODE_DIRECT(&src->data2, UInt16); + ret |= ENCODE_DIRECT(&src->data3, UInt16); + UA_CHECK(ctx->pos + (8*sizeof(u8)) <= ctx->end, + return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + memcpy(ctx->pos, src->data4, 8*sizeof(u8)); + ctx->pos += 8; + return ret; +} + +DECODE_BINARY(Guid) { + status ret = UA_STATUSCODE_GOOD; + ret |= DECODE_DIRECT(&dst->data1, UInt32); + ret |= DECODE_DIRECT(&dst->data2, UInt16); + ret |= DECODE_DIRECT(&dst->data3, UInt16); + UA_CHECK(ctx->pos + (8*sizeof(u8)) <= ctx->end, + return UA_STATUSCODE_BADDECODINGERROR); + memcpy(dst->data4, ctx->pos, 8*sizeof(u8)); + ctx->pos += 8; + return ret; +} + +/* NodeId */ +#define UA_NODEIDTYPE_NUMERIC_TWOBYTE 0u +#define UA_NODEIDTYPE_NUMERIC_FOURBYTE 1u +#define UA_NODEIDTYPE_NUMERIC_COMPLETE 2u + +#define UA_EXPANDEDNODEID_SERVERINDEX_FLAG 0x40u +#define UA_EXPANDEDNODEID_NAMESPACEURI_FLAG 0x80u + +/* For ExpandedNodeId, we prefill the encoding mask. */ +static status +NodeId_encodeBinaryWithEncodingMask(UA_NodeId const *src, u8 encoding, Ctx *ctx) { + status ret = UA_STATUSCODE_GOOD; + switch(src->identifierType) { + case UA_NODEIDTYPE_NUMERIC: + if(src->identifier.numeric > UA_UINT16_MAX || src->namespaceIndex > UA_BYTE_MAX) { + encoding |= UA_NODEIDTYPE_NUMERIC_COMPLETE; + ret |= ENCODE_DIRECT(&encoding, Byte); + ret |= ENCODE_DIRECT(&src->namespaceIndex, UInt16); + ret |= ENCODE_DIRECT(&src->identifier.numeric, UInt32); + } else if(src->identifier.numeric > UA_BYTE_MAX || src->namespaceIndex > 0) { + encoding |= UA_NODEIDTYPE_NUMERIC_FOURBYTE; + ret |= ENCODE_DIRECT(&encoding, Byte); + u8 nsindex = (u8)src->namespaceIndex; + ret |= ENCODE_DIRECT(&nsindex, Byte); + u16 identifier16 = (u16)src->identifier.numeric; + ret |= ENCODE_DIRECT(&identifier16, UInt16); + } else { + encoding |= UA_NODEIDTYPE_NUMERIC_TWOBYTE; + ret |= ENCODE_DIRECT(&encoding, Byte); + u8 identifier8 = (u8)src->identifier.numeric; + ret |= ENCODE_DIRECT(&identifier8, Byte); + } + break; + case UA_NODEIDTYPE_STRING: + encoding |= (u8)UA_NODEIDTYPE_STRING; + ret |= ENCODE_DIRECT(&encoding, Byte); + ret |= ENCODE_DIRECT(&src->namespaceIndex, UInt16); + UA_CHECK_STATUS(ret, return ret); + /* Can exchange the buffer */ + ret = ENCODE_DIRECT(&src->identifier.string, String); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + break; + case UA_NODEIDTYPE_GUID: + encoding |= (u8)UA_NODEIDTYPE_GUID; + ret |= ENCODE_DIRECT(&encoding, Byte); + ret |= ENCODE_DIRECT(&src->namespaceIndex, UInt16); + ret |= ENCODE_DIRECT(&src->identifier.guid, Guid); + break; + case UA_NODEIDTYPE_BYTESTRING: + encoding |= (u8)UA_NODEIDTYPE_BYTESTRING; + ret |= ENCODE_DIRECT(&encoding, Byte); + ret |= ENCODE_DIRECT(&src->namespaceIndex, UInt16); + UA_CHECK_STATUS(ret, return ret); + /* Can exchange the buffer */ + ret = ENCODE_DIRECT(&src->identifier.byteString, String); /* ByteString */ + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + break; + default: + return UA_STATUSCODE_BADINTERNALERROR; + } + return ret; +} + +ENCODE_BINARY(NodeId) { + return NodeId_encodeBinaryWithEncodingMask(src, 0, ctx); +} + +DECODE_BINARY(NodeId) { + u8 dstByte = 0, encodingByte = 0; + u16 dstUInt16 = 0; + + /* Decode the encoding bitfield */ + status ret = DECODE_DIRECT(&encodingByte, Byte); + UA_CHECK_STATUS(ret, return ret); + + /* Filter out the bits used only for ExpandedNodeIds */ + encodingByte &= (u8)~(u8)(UA_EXPANDEDNODEID_SERVERINDEX_FLAG | + UA_EXPANDEDNODEID_NAMESPACEURI_FLAG); + + /* Decode the namespace and identifier */ + switch(encodingByte) { + case UA_NODEIDTYPE_NUMERIC_TWOBYTE: + dst->identifierType = UA_NODEIDTYPE_NUMERIC; + ret = DECODE_DIRECT(&dstByte, Byte); + dst->identifier.numeric = dstByte; + dst->namespaceIndex = 0; + break; + case UA_NODEIDTYPE_NUMERIC_FOURBYTE: + dst->identifierType = UA_NODEIDTYPE_NUMERIC; + ret |= DECODE_DIRECT(&dstByte, Byte); + dst->namespaceIndex = dstByte; + ret |= DECODE_DIRECT(&dstUInt16, UInt16); + dst->identifier.numeric = dstUInt16; + break; + case UA_NODEIDTYPE_NUMERIC_COMPLETE: + dst->identifierType = UA_NODEIDTYPE_NUMERIC; + ret |= DECODE_DIRECT(&dst->namespaceIndex, UInt16); + ret |= DECODE_DIRECT(&dst->identifier.numeric, UInt32); + break; + case UA_NODEIDTYPE_STRING: + dst->identifierType = UA_NODEIDTYPE_STRING; + ret |= DECODE_DIRECT(&dst->namespaceIndex, UInt16); + ret |= DECODE_DIRECT(&dst->identifier.string, String); + break; + case UA_NODEIDTYPE_GUID: + dst->identifierType = UA_NODEIDTYPE_GUID; + ret |= DECODE_DIRECT(&dst->namespaceIndex, UInt16); + ret |= DECODE_DIRECT(&dst->identifier.guid, Guid); + break; + case UA_NODEIDTYPE_BYTESTRING: + dst->identifierType = UA_NODEIDTYPE_BYTESTRING; + ret |= DECODE_DIRECT(&dst->namespaceIndex, UInt16); + ret |= DECODE_DIRECT(&dst->identifier.byteString, String); /* ByteString */ + break; + default: + ret |= UA_STATUSCODE_BADINTERNALERROR; + break; + } + return ret; +} + +/* ExpandedNodeId */ +ENCODE_BINARY(ExpandedNodeId) { + /* Set up the encoding mask */ + u8 encoding = 0; + if((void*)src->namespaceUri.data > UA_EMPTY_ARRAY_SENTINEL) + encoding |= UA_EXPANDEDNODEID_NAMESPACEURI_FLAG; + if(src->serverIndex > 0) + encoding |= UA_EXPANDEDNODEID_SERVERINDEX_FLAG; + + /* Encode the NodeId. Can exchange the buffer. */ + status ret = NodeId_encodeBinaryWithEncodingMask(&src->nodeId, encoding, ctx); + UA_CHECK_STATUS(ret, return ret); + + /* Encode the namespace. Internally uses encodeWithExchangeBuffer + * everywhere. So it will never return + * UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED. */ + if((void*)src->namespaceUri.data > UA_EMPTY_ARRAY_SENTINEL) { + ret = ENCODE_DIRECT(&src->namespaceUri, String); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + } + + /* Encode the serverIndex */ + if(src->serverIndex > 0) + ret = encodeWithExchangeBuffer(&src->serverIndex, &UA_TYPES[UA_TYPES_UINT32], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + return ret; +} + +DECODE_BINARY(ExpandedNodeId) { + /* Decode the encoding mask */ + UA_CHECK(ctx->pos + 1 <= ctx->end, return UA_STATUSCODE_BADDECODINGERROR); + u8 encoding = *ctx->pos; + + /* Decode the NodeId */ + status ret = DECODE_DIRECT(&dst->nodeId, NodeId); + + /* Decode the NamespaceUri */ + if(encoding & UA_EXPANDEDNODEID_NAMESPACEURI_FLAG) { + dst->nodeId.namespaceIndex = 0; + ret |= DECODE_DIRECT(&dst->namespaceUri, String); + } + + /* Decode the ServerIndex */ + if(encoding & UA_EXPANDEDNODEID_SERVERINDEX_FLAG) + ret |= DECODE_DIRECT(&dst->serverIndex, UInt32); + return ret; +} + +/* QualifiedName */ +ENCODE_BINARY(QualifiedName) { + status ret = ENCODE_DIRECT(&src->namespaceIndex, UInt16); + /* Must check here so we can exchange the buffer in the string encoding */ + UA_CHECK_STATUS(ret, return ret); + ret |= ENCODE_DIRECT(&src->name, String); + return ret; +} + +DECODE_BINARY(QualifiedName) { + status ret = DECODE_DIRECT(&dst->namespaceIndex, UInt16); + ret |= DECODE_DIRECT(&dst->name, String); + return ret; +} + +/* LocalizedText */ +#define UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE 0x01u +#define UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT 0x02u + +ENCODE_BINARY(LocalizedText) { + /* Set up the encoding mask */ + u8 encoding = 0; + if(src->locale.data) + encoding |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE; + if(src->text.data) + encoding |= UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT; + + /* Encode the encoding byte */ + status ret = ENCODE_DIRECT(&encoding, Byte); + /* Must check here so we can exchange the buffer in the string encoding */ + UA_CHECK_STATUS(ret, return ret); + + /* Encode the strings */ + if(encoding & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE) + ret |= ENCODE_DIRECT(&src->locale, String); + if(encoding & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT) + ret |= ENCODE_DIRECT(&src->text, String); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + return ret; +} + +DECODE_BINARY(LocalizedText) { + /* Decode the encoding mask */ + u8 encoding = 0; + status ret = DECODE_DIRECT(&encoding, Byte); + + /* Decode the content */ + if(encoding & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_LOCALE) + ret |= DECODE_DIRECT(&dst->locale, String); + if(encoding & UA_LOCALIZEDTEXT_ENCODINGMASKTYPE_TEXT) + ret |= DECODE_DIRECT(&dst->text, String); + return ret; +} + +/* The binary encoding has a different nodeid from the data type. So it is not + * possible to reuse UA_findDataType */ +static const UA_DataType * +UA_findDataTypeByBinaryInternal(const UA_NodeId *typeId, Ctx *ctx) { + /* Always look in the built-in types first. Assume that only numeric + * identifiers are used for the builtin types. (They may contain data types + * from all namespaces though.) */ + if(typeId->identifierType == UA_NODEIDTYPE_NUMERIC) { + for(size_t i = 0; i < UA_TYPES_COUNT; ++i) { + if(UA_TYPES[i].binaryEncodingId.identifier.numeric == typeId->identifier.numeric && + UA_TYPES[i].binaryEncodingId.namespaceIndex == typeId->namespaceIndex) + return &UA_TYPES[i]; + } + } + + const UA_DataTypeArray *customTypes = ctx->customTypes; + while(customTypes) { + for(size_t i = 0; i < customTypes->typesSize; ++i) { + if(UA_NodeId_equal(typeId, &customTypes->types[i].binaryEncodingId)) + return &customTypes->types[i]; + } + customTypes = customTypes->next; + } + + return NULL; +} + +const UA_DataType * +UA_findDataTypeByBinary(const UA_NodeId *typeId) { + Ctx ctx; + ctx.customTypes = NULL; + return UA_findDataTypeByBinaryInternal(typeId, &ctx); +} + +/* ExtensionObject */ +ENCODE_BINARY(ExtensionObject) { + u8 encoding = (u8)src->encoding; + + /* No content or already encoded content. */ + if(encoding <= UA_EXTENSIONOBJECT_ENCODED_XML) { + /* Can exchange the buffer */ + status ret = ENCODE_DIRECT(&src->content.encoded.typeId, NodeId); + UA_CHECK_STATUS(ret, return ret); + ret = encodeWithExchangeBuffer(&encoding, &UA_TYPES[UA_TYPES_BYTE], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + switch(src->encoding) { + case UA_EXTENSIONOBJECT_ENCODED_NOBODY: + break; + case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING: + case UA_EXTENSIONOBJECT_ENCODED_XML: + /* ByteString in disguise. Array encoding can exchange the buffer */ + ret = ENCODE_DIRECT(&src->content.encoded.body, String); + break; + default: + ret = UA_STATUSCODE_BADINTERNALERROR; + } + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + return ret; + } + + /* Cannot encode with no data or no type description */ + if(!src->content.decoded.type || !src->content.decoded.data) + return UA_STATUSCODE_BADENCODINGERROR; + + /* Write the NodeId for the binary encoded type. This could perform a buffer + * exchange, but can also return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED. */ + status ret = ENCODE_DIRECT(&src->content.decoded.type->binaryEncodingId, NodeId); + UA_CHECK_STATUS(ret, return ret); + + /* Encode the encoding byte */ + encoding = UA_EXTENSIONOBJECT_ENCODED_BYTESTRING; + ret = encodeWithExchangeBuffer(&encoding, &UA_TYPES[UA_TYPES_BYTE], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + + /* Encode the content length */ + const UA_DataType *contentType = src->content.decoded.type; + size_t len = UA_calcSizeBinary(src->content.decoded.data, contentType); + UA_CHECK(len <= UA_INT32_MAX, return UA_STATUSCODE_BADENCODINGERROR); + i32 signed_len = (i32)len; + ret = encodeWithExchangeBuffer(&signed_len, &UA_TYPES[UA_TYPES_INT32], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + + /* Encode the content */ + ret = encodeWithExchangeBuffer(src->content.decoded.data, contentType, ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + return ret; +} + +static status +ExtensionObject_decodeBinaryContent(UA_ExtensionObject *dst, const UA_NodeId *typeId, + Ctx *ctx) { + /* Lookup the datatype */ + const UA_DataType *type = UA_findDataTypeByBinaryInternal(typeId, ctx); + + /* Unknown type, just take the binary content */ + if(!type) { + dst->encoding = UA_EXTENSIONOBJECT_ENCODED_BYTESTRING; + UA_NodeId_copy(typeId, &dst->content.encoded.typeId); + return DECODE_DIRECT(&dst->content.encoded.body, String); /* ByteString */ + } + + /* Allocate memory */ + dst->content.decoded.data = UA_new(type); + UA_CHECK_MEM(dst->content.decoded.data, return UA_STATUSCODE_BADOUTOFMEMORY); + + /* Jump over the length field (TODO: check if the decoded length matches) */ + ctx->pos += 4; + + /* Decode */ + dst->encoding = UA_EXTENSIONOBJECT_DECODED; + dst->content.decoded.type = type; + return decodeBinaryJumpTable[type->typeKind](dst->content.decoded.data, type, ctx); +} + +DECODE_BINARY(ExtensionObject) { + u8 encoding = 0; + UA_NodeId binTypeId; + UA_NodeId_init(&binTypeId); + + status ret = UA_STATUSCODE_GOOD; + ret |= DECODE_DIRECT(&binTypeId, NodeId); + ret |= DECODE_DIRECT(&encoding, Byte); + UA_CHECK_STATUS(ret, UA_NodeId_clear(&binTypeId); return ret); + + switch(encoding) { + case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING: + ret = ExtensionObject_decodeBinaryContent(dst, &binTypeId, ctx); + UA_NodeId_clear(&binTypeId); + break; + case UA_EXTENSIONOBJECT_ENCODED_NOBODY: + dst->encoding = (UA_ExtensionObjectEncoding)encoding; + dst->content.encoded.typeId = binTypeId; /* move to dst */ + dst->content.encoded.body = UA_BYTESTRING_NULL; + break; + case UA_EXTENSIONOBJECT_ENCODED_XML: + dst->encoding = (UA_ExtensionObjectEncoding)encoding; + dst->content.encoded.typeId = binTypeId; /* move to dst */ + ret = DECODE_DIRECT(&dst->content.encoded.body, String); /* ByteString */ + UA_CHECK_STATUS(ret, UA_NodeId_clear(&dst->content.encoded.typeId)); + break; + default: + UA_NodeId_clear(&binTypeId); + ret = UA_STATUSCODE_BADDECODINGERROR; + break; + } + + return ret; +} + +/* Variant */ + +static status +Variant_encodeBinaryWrapExtensionObject(const UA_Variant *src, + const UA_Boolean isArray, Ctx *ctx) { + size_t length = 1; /* Default to 1 for a scalar. */ + + /* Encode the array length if required */ + status ret = UA_STATUSCODE_GOOD; + if(isArray) { + UA_CHECK(src->arrayLength <= UA_INT32_MAX, return UA_STATUSCODE_BADENCODINGERROR); + length = src->arrayLength; + i32 encodedLength = (i32)src->arrayLength; + ret = ENCODE_DIRECT(&encodedLength, UInt32); /* Int32 */ + UA_CHECK_STATUS(ret, return ret); + } + + /* Set up the ExtensionObject */ + UA_ExtensionObject eo; + UA_ExtensionObject_init(&eo); + eo.encoding = UA_EXTENSIONOBJECT_DECODED; + eo.content.decoded.type = src->type; + const u16 memSize = src->type->memSize; + uintptr_t ptr = (uintptr_t)src->data; + + /* Iterate over the array */ + for(size_t i = 0; i < length && ret == UA_STATUSCODE_GOOD; ++i) { + eo.content.decoded.data = (void*)ptr; + ret = encodeWithExchangeBuffer(&eo, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + ptr += memSize; + } + return ret; +} + +enum UA_VARIANT_ENCODINGMASKTYPE { + UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK = 0x3Fu, /* bits 0:5 */ + UA_VARIANT_ENCODINGMASKTYPE_DIMENSIONS = (u8)(0x01u << 6u), /* bit 6 */ + UA_VARIANT_ENCODINGMASKTYPE_ARRAY = (u8)(0x01u << 7u) /* bit 7 */ +}; + +ENCODE_BINARY(Variant) { + /* Quit early for the empty variant */ + u8 encoding = 0; + if(!src->type) + return ENCODE_DIRECT(&encoding, Byte); + + /* Set the content type in the encoding mask */ + const UA_Boolean isBuiltin = (src->type->typeKind <= UA_DATATYPEKIND_DIAGNOSTICINFO); + const UA_Boolean isEnum = (src->type->typeKind == UA_DATATYPEKIND_ENUM); + if(isBuiltin) + encoding = (u8)(encoding | (u8)((u8)UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK & (u8)(src->type->typeKind + 1u))); + else if(isEnum) + encoding = (u8)(encoding | (u8)((u8)UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK & (u8)(UA_TYPES_INT32 + 1u))); + else + encoding = (u8)(encoding | (u8)((u8)UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK & (u8)(UA_TYPES_EXTENSIONOBJECT + 1u))); + + /* Set the array type in the encoding mask */ + const UA_Boolean isArray = src->arrayLength > 0 || src->data <= UA_EMPTY_ARRAY_SENTINEL; + const UA_Boolean hasDimensions = isArray && src->arrayDimensionsSize > 0; + if(isArray) { + encoding |= (u8)UA_VARIANT_ENCODINGMASKTYPE_ARRAY; + if(hasDimensions) + encoding |= (u8)UA_VARIANT_ENCODINGMASKTYPE_DIMENSIONS; + } + + /* Encode the encoding byte */ + status ret = ENCODE_DIRECT(&encoding, Byte); + UA_CHECK_STATUS(ret, return ret); + + /* Encode the content. This can exchange the buffer. */ + if(!isBuiltin && !isEnum) { + /* This could return UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED. But we + * have not exchanged the buffer so far. */ + ret = Variant_encodeBinaryWrapExtensionObject(src, isArray, ctx); + } else if(!isArray) { + ret = encodeWithExchangeBuffer(src->data, src->type, ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + } else { + ret = Array_encodeBinary(src->data, src->arrayLength, src->type, ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + } + UA_CHECK_STATUS(ret, return ret); + + /* Encode the array dimensions */ + if(hasDimensions && ret == UA_STATUSCODE_GOOD) + ret = Array_encodeBinary(src->arrayDimensions, src->arrayDimensionsSize, + &UA_TYPES[UA_TYPES_INT32], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + return ret; +} + +static status +Variant_decodeBinaryUnwrapExtensionObject(UA_Variant *dst, Ctx *ctx) { + /* Save the position in the ByteString. If unwrapping is not possible, start + * from here to decode a normal ExtensionObject. */ + u8 *old_pos = ctx->pos; + + /* Decode the DataType */ + UA_NodeId typeId; + UA_NodeId_init(&typeId); + status ret = DECODE_DIRECT(&typeId, NodeId); + UA_CHECK_STATUS(ret, return ret); + + /* Decode the EncodingByte */ + u8 encoding; + ret = DECODE_DIRECT(&encoding, Byte); + UA_CHECK_STATUS(ret, UA_NodeId_clear(&typeId); return ret); + + /* Search for the datatype. Default to ExtensionObject. */ + if(encoding == UA_EXTENSIONOBJECT_ENCODED_BYTESTRING && + (dst->type = UA_findDataTypeByBinaryInternal(&typeId, ctx)) != NULL) { + /* Jump over the length field (TODO: check if length matches) */ + ctx->pos += 4; + } else { + /* Reset and decode as ExtensionObject */ + dst->type = &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]; + ctx->pos = old_pos; + } + UA_NodeId_clear(&typeId); + + /* Allocate memory */ + dst->data = UA_new(dst->type); + UA_CHECK_MEM(dst->data, return UA_STATUSCODE_BADOUTOFMEMORY); + + /* Decode the content */ + return decodeBinaryJumpTable[dst->type->typeKind](dst->data, dst->type, ctx); +} + +/* The resulting variant always has the storagetype UA_VARIANT_DATA. */ +DECODE_BINARY(Variant) { + /* Decode the encoding byte */ + u8 encodingByte; + status ret = DECODE_DIRECT(&encodingByte, Byte); + UA_CHECK_STATUS(ret, return ret); + + /* Return early for an empty variant (was already _inited) */ + if(encodingByte == 0) + return UA_STATUSCODE_GOOD; + + /* Does the variant contain an array? */ + const UA_Boolean isArray = (encodingByte & (u8)UA_VARIANT_ENCODINGMASKTYPE_ARRAY) > 0; + + /* Get the datatype of the content. The type must be a builtin data type. + * All not-builtin types are wrapped in an ExtensionObject. The "type kind" + * for types up to DiagnsticInfo equals to the index in the encoding + * byte. */ + size_t typeKind = (size_t)((encodingByte & (u8)UA_VARIANT_ENCODINGMASKTYPE_TYPEID_MASK) - 1); + UA_CHECK(typeKind <= UA_DATATYPEKIND_DIAGNOSTICINFO, return UA_STATUSCODE_BADDECODINGERROR); + + /* A variant cannot contain a variant. But it can contain an array of + * variants */ + UA_CHECK(typeKind != UA_DATATYPEKIND_VARIANT || isArray, + return UA_STATUSCODE_BADDECODINGERROR); + + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, return UA_STATUSCODE_BADENCODINGERROR); + ctx->depth++; + + /* Decode the content */ + dst->type = &UA_TYPES[typeKind]; + if(isArray) { + ret = Array_decodeBinary(&dst->data, &dst->arrayLength, dst->type, ctx); + } else if(typeKind != UA_DATATYPEKIND_EXTENSIONOBJECT) { + dst->data = UA_new(dst->type); + UA_CHECK_MEM(dst->data, ctx->depth--; return UA_STATUSCODE_BADOUTOFMEMORY); + ret = decodeBinaryJumpTable[typeKind](dst->data, dst->type, ctx); + } else { + ret = Variant_decodeBinaryUnwrapExtensionObject(dst, ctx); + } + + /* Decode array dimensions */ + if(isArray && (encodingByte & (u8)UA_VARIANT_ENCODINGMASKTYPE_DIMENSIONS) > 0) + ret |= Array_decodeBinary((void**)&dst->arrayDimensions, &dst->arrayDimensionsSize, + &UA_TYPES[UA_TYPES_INT32], ctx); + + ctx->depth--; + return ret; +} + +/* DataValue */ +ENCODE_BINARY(DataValue) { + /* Set up the encoding mask */ + u8 encodingMask = src->hasValue; + encodingMask |= (u8)(src->hasStatus << 1u); + encodingMask |= (u8)(src->hasSourceTimestamp << 2u); + encodingMask |= (u8)(src->hasServerTimestamp << 3u); + encodingMask |= (u8)(src->hasSourcePicoseconds << 4u); + encodingMask |= (u8)(src->hasServerPicoseconds << 5u); + + /* Encode the encoding byte */ + status ret = ENCODE_DIRECT(&encodingMask, Byte); + UA_CHECK_STATUS(ret, return ret); + + /* Encode the variant. */ + if(src->hasValue) { + ret = ENCODE_DIRECT(&src->value, Variant); + if(ret != UA_STATUSCODE_GOOD) + return ret; + } + + if(src->hasStatus) + ret |= encodeWithExchangeBuffer(&src->status, &UA_TYPES[UA_TYPES_STATUSCODE], ctx); + if(src->hasSourceTimestamp) + ret |= encodeWithExchangeBuffer(&src->sourceTimestamp, &UA_TYPES[UA_TYPES_DATETIME], ctx); + if(src->hasSourcePicoseconds) + ret |= encodeWithExchangeBuffer(&src->sourcePicoseconds, &UA_TYPES[UA_TYPES_UINT16], ctx); + if(src->hasServerTimestamp) + ret |= encodeWithExchangeBuffer(&src->serverTimestamp, &UA_TYPES[UA_TYPES_DATETIME], ctx); + if(src->hasServerPicoseconds) + ret |= encodeWithExchangeBuffer(&src->serverPicoseconds, &UA_TYPES[UA_TYPES_UINT16], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + return ret; +} + +#define MAX_PICO_SECONDS 9999 + +DECODE_BINARY(DataValue) { + /* Decode the encoding mask */ + u8 encodingMask; + status ret = DECODE_DIRECT(&encodingMask, Byte); + UA_CHECK_STATUS(ret, return ret); + + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, return UA_STATUSCODE_BADENCODINGERROR); + ctx->depth++; + + /* Decode the content */ + if(encodingMask & 0x01u) { + dst->hasValue = true; + ret |= DECODE_DIRECT(&dst->value, Variant); + } + if(encodingMask & 0x02u) { + dst->hasStatus = true; + ret |= DECODE_DIRECT(&dst->status, UInt32); /* StatusCode */ + } + if(encodingMask & 0x04u) { + dst->hasSourceTimestamp = true; + ret |= DECODE_DIRECT(&dst->sourceTimestamp, UInt64); /* DateTime */ + } + if(encodingMask & 0x10u) { + dst->hasSourcePicoseconds = true; + ret |= DECODE_DIRECT(&dst->sourcePicoseconds, UInt16); + if(dst->sourcePicoseconds > MAX_PICO_SECONDS) + dst->sourcePicoseconds = MAX_PICO_SECONDS; + } + if(encodingMask & 0x08u) { + dst->hasServerTimestamp = true; + ret |= DECODE_DIRECT(&dst->serverTimestamp, UInt64); /* DateTime */ + } + if(encodingMask & 0x20u) { + dst->hasServerPicoseconds = true; + ret |= DECODE_DIRECT(&dst->serverPicoseconds, UInt16); + if(dst->serverPicoseconds > MAX_PICO_SECONDS) + dst->serverPicoseconds = MAX_PICO_SECONDS; + } + + ctx->depth--; + return ret; +} + +/* DiagnosticInfo */ +ENCODE_BINARY(DiagnosticInfo) { + /* Set up the encoding mask */ + u8 encodingMask = src->hasSymbolicId; + encodingMask |= (u8)(src->hasNamespaceUri << 1u); + encodingMask |= (u8)(src->hasLocalizedText << 2u); + encodingMask |= (u8)(src->hasLocale << 3u); + encodingMask |= (u8)(src->hasAdditionalInfo << 4u); + encodingMask |= (u8)(src->hasInnerStatusCode << 5u); + encodingMask |= (u8)(src->hasInnerDiagnosticInfo << 6u); + + /* Encode the numeric content */ + status ret = ENCODE_DIRECT(&encodingMask, Byte); + if(src->hasSymbolicId) + ret |= ENCODE_DIRECT(&src->symbolicId, UInt32); /* Int32 */ + if(src->hasNamespaceUri) + ret |= ENCODE_DIRECT(&src->namespaceUri, UInt32); /* Int32 */ + if(src->hasLocalizedText) + ret |= ENCODE_DIRECT(&src->localizedText, UInt32); /* Int32 */ + if(src->hasLocale) + ret |= ENCODE_DIRECT(&src->locale, UInt32); /* Int32 */ + if(ret != UA_STATUSCODE_GOOD) + return ret; + + /* Encode the additional info. Can exchange the buffer. */ + if(src->hasAdditionalInfo) { + ret = ENCODE_DIRECT(&src->additionalInfo, String); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + } + + /* Encode the inner status code */ + if(src->hasInnerStatusCode) { + ret = encodeWithExchangeBuffer(&src->innerStatusCode, &UA_TYPES[UA_TYPES_UINT32], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + UA_CHECK_STATUS(ret, return ret); + } + + /* Encode the inner diagnostic info */ + if(src->hasInnerDiagnosticInfo) { + ret = encodeWithExchangeBuffer(src->innerDiagnosticInfo, + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + } + + return ret; +} + +DECODE_BINARY(DiagnosticInfo) { + /* Decode the encoding mask */ + u8 encodingMask; + status ret = DECODE_DIRECT(&encodingMask, Byte); + UA_CHECK_STATUS(ret, return ret); + + /* Decode the content */ + if(encodingMask & 0x01u) { + dst->hasSymbolicId = true; + ret |= DECODE_DIRECT(&dst->symbolicId, UInt32); /* Int32 */ + } + if(encodingMask & 0x02u) { + dst->hasNamespaceUri = true; + ret |= DECODE_DIRECT(&dst->namespaceUri, UInt32); /* Int32 */ + } + if(encodingMask & 0x04u) { + dst->hasLocalizedText = true; + ret |= DECODE_DIRECT(&dst->localizedText, UInt32); /* Int32 */ + } + if(encodingMask & 0x08u) { + dst->hasLocale = true; + ret |= DECODE_DIRECT(&dst->locale, UInt32); /* Int32 */ + } + if(encodingMask & 0x10u) { + dst->hasAdditionalInfo = true; + ret |= DECODE_DIRECT(&dst->additionalInfo, String); + } + if(encodingMask & 0x20u) { + dst->hasInnerStatusCode = true; + ret |= DECODE_DIRECT(&dst->innerStatusCode, UInt32); /* StatusCode */ + } + if(encodingMask & 0x40u) { + /* innerDiagnosticInfo is allocated on the heap */ + dst->innerDiagnosticInfo = (UA_DiagnosticInfo*) + UA_calloc(1, sizeof(UA_DiagnosticInfo)); + UA_CHECK_MEM(dst->innerDiagnosticInfo, return UA_STATUSCODE_BADOUTOFMEMORY); + dst->hasInnerDiagnosticInfo = true; + + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, + return UA_STATUSCODE_BADENCODINGERROR); + + ctx->depth++; + ret |= DECODE_DIRECT(dst->innerDiagnosticInfo, DiagnosticInfo); + ctx->depth--; + } + return ret; +} + +/********************/ +/* Structured Types */ +/********************/ + +static status +encodeBinaryStruct(const void *src, const UA_DataType *type, Ctx *ctx) { + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, + return UA_STATUSCODE_BADENCODINGERROR); + ctx->depth++; + + /* Loop over members */ + uintptr_t ptr = (uintptr_t)src; + status ret = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < type->membersSize && ret == UA_STATUSCODE_GOOD; ++i) { + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + ptr += m->padding; + + /* Array. Buffer-exchange is done inside Array_encodeBinary if required. */ + if(m->isArray) { + const size_t length = *((const size_t*)ptr); + ptr += sizeof(size_t); + ret = Array_encodeBinary(*(void *UA_RESTRICT const *)ptr, length, mt, ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + ptr += sizeof(void*); + continue; + } + + /* Scalar */ + ret = encodeWithExchangeBuffer((const void*)ptr, mt, ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + ptr += mt->memSize; + } + + ctx->depth--; + return ret; +} + +static status +encodeBinaryStructWithOptFields(const void *src, const UA_DataType *type, Ctx *ctx) { + /* Check the recursion limit */ + if(ctx->depth > UA_ENCODING_MAX_RECURSION) + return UA_STATUSCODE_BADENCODINGERROR; + ctx->depth++; + + /* Creating the encoding mask, marking the available optional fields */ + uintptr_t ptr = (uintptr_t)src; + size_t optFieldCounter = 0; + UA_UInt32 encodingMask = 0; + for(size_t j = 0; j < type->membersSize; ++j) { + const UA_DataTypeMember *m = &type->members[j]; + const UA_DataType *mt = m->memberType; + ptr += m->padding; + if(m->isOptional) { + if(m->isArray) + ptr += sizeof(size_t); + if(*(void* const*)ptr != NULL) + encodingMask |= (UA_UInt32) 1 << optFieldCounter; + ptr += sizeof(void *); + optFieldCounter++; + } else { + if(m->isArray) + ptr += sizeof(size_t); + ptr += mt->memSize; + } + } + + /* Encode the mask */ + status ret = ENCODE_DIRECT(&encodingMask, UInt32); + UA_CHECK_STATUS(ret, ctx->depth--; return ret); + + /* Loop over members */ + ptr = (uintptr_t)src; + for(size_t i = 0, o = 0; i < type->membersSize && UA_LIKELY(ret == UA_STATUSCODE_GOOD); ++i) { + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + ptr += m->padding; + + if(m->isOptional) { + if(!(encodingMask & (UA_UInt32) ( (UA_UInt32) 1<<(o++)))) { + /* Optional and not contained */ + if(m->isArray) + ptr += sizeof(size_t); + } else if(m->isArray) { + /* Optional Array */ + const size_t length = *((const size_t *) ptr); + ptr += sizeof(size_t); + ret = Array_encodeBinary(*(void *UA_RESTRICT const *) ptr, length, mt, ctx); + } else { + /* Optional Scalar */ + ret = encodeWithExchangeBuffer(*(void* const*) ptr, mt, ctx); + } + ptr += sizeof(void *); + continue; + } + + /* Mandatory Array */ + if(m->isArray) { + const size_t length = *((const size_t *) ptr); + ptr += sizeof(size_t); + ret = Array_encodeBinary(*(void *UA_RESTRICT const *) ptr, length, mt, ctx); + ptr += sizeof(void *); + continue; + } + + /* Mandatory Scalar */ + ret = encodeWithExchangeBuffer((const void*)ptr, mt, ctx); + ptr += mt->memSize; + } + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + + ctx->depth--; + return ret; +} + +static status +encodeBinaryUnion(const void *src, const UA_DataType *type, Ctx *ctx) { + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, + return UA_STATUSCODE_BADENCODINGERROR); + ctx->depth++; + + /* Encode the selection */ + const UA_UInt32 selection = *(const UA_UInt32*)src; + status ret = ENCODE_DIRECT(&selection, UInt32); + if(UA_UNLIKELY(ret != UA_STATUSCODE_GOOD) || selection == 0) { + ctx->depth--; + return ret; + } + + /* Select the member */ + const UA_DataTypeMember *m = &type->members[selection-1]; + const UA_DataType *mt = m->memberType; + + /* Encode the member */ + uintptr_t ptr = ((uintptr_t)src) + m->padding; /* includes the switchfield length */ + if(!m->isArray) { + ret = encodeWithExchangeBuffer((const void*)ptr, mt, ctx); + } else { + const size_t length = *((const size_t*)ptr); + ptr += sizeof(size_t); + ret = Array_encodeBinary(*(void *UA_RESTRICT const *)ptr, length, mt, ctx); + } + + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + + ctx->depth--; + return ret; +} + +static status +encodeBinaryNotImplemented(const void *src, const UA_DataType *type, Ctx *ctx) { + (void)src, (void)type, (void)ctx; + return UA_STATUSCODE_BADNOTIMPLEMENTED; +} + +const encodeBinarySignature encodeBinaryJumpTable[UA_DATATYPEKINDS] = { + (encodeBinarySignature)Boolean_encodeBinary, + (encodeBinarySignature)Byte_encodeBinary, /* SByte */ + (encodeBinarySignature)Byte_encodeBinary, + (encodeBinarySignature)UInt16_encodeBinary, /* Int16 */ + (encodeBinarySignature)UInt16_encodeBinary, + (encodeBinarySignature)UInt32_encodeBinary, /* Int32 */ + (encodeBinarySignature)UInt32_encodeBinary, + (encodeBinarySignature)UInt64_encodeBinary, /* Int64 */ + (encodeBinarySignature)UInt64_encodeBinary, + (encodeBinarySignature)Float_encodeBinary, + (encodeBinarySignature)Double_encodeBinary, + (encodeBinarySignature)String_encodeBinary, + (encodeBinarySignature)UInt64_encodeBinary, /* DateTime */ + (encodeBinarySignature)Guid_encodeBinary, + (encodeBinarySignature)String_encodeBinary, /* ByteString */ + (encodeBinarySignature)String_encodeBinary, /* XmlElement */ + (encodeBinarySignature)NodeId_encodeBinary, + (encodeBinarySignature)ExpandedNodeId_encodeBinary, + (encodeBinarySignature)UInt32_encodeBinary, /* StatusCode */ + (encodeBinarySignature)QualifiedName_encodeBinary, + (encodeBinarySignature)LocalizedText_encodeBinary, + (encodeBinarySignature)ExtensionObject_encodeBinary, + (encodeBinarySignature)DataValue_encodeBinary, + (encodeBinarySignature)Variant_encodeBinary, + (encodeBinarySignature)DiagnosticInfo_encodeBinary, + (encodeBinarySignature)encodeBinaryNotImplemented, /* Decimal */ + (encodeBinarySignature)UInt32_encodeBinary, /* Enumeration */ + (encodeBinarySignature)encodeBinaryStruct, + (encodeBinarySignature)encodeBinaryStructWithOptFields, /* Structure with Optional Fields */ + (encodeBinarySignature)encodeBinaryUnion, /* Union */ + (encodeBinarySignature)encodeBinaryStruct /* BitfieldCluster */ +}; + +status +UA_encodeBinaryInternal(const void *src, const UA_DataType *type, + u8 **bufPos, const u8 **bufEnd, + UA_exchangeEncodeBuffer exchangeCallback, + void *exchangeHandle) { + /* Set up the context */ + Ctx ctx; + ctx.pos = *bufPos; + ctx.end = *bufEnd; + ctx.depth = 0; + ctx.exchangeBufferCallback = exchangeCallback; + ctx.exchangeBufferCallbackHandle = exchangeHandle; + + UA_CHECK_MEM(ctx.pos, return UA_STATUSCODE_BADINVALIDARGUMENT); + + /* Encode */ + status ret = encodeWithExchangeBuffer(src, type, &ctx); + UA_assert(ret != UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED); + + /* Set the new buffer position for the output. Beware that the buffer might + * have been exchanged internally. */ + *bufPos = ctx.pos; + *bufEnd = ctx.end; + return ret; +} + +UA_StatusCode +UA_encodeBinary(const void *p, const UA_DataType *type, + UA_ByteString *outBuf) { + /* Allocate buffer */ + UA_Boolean allocated = false; + status res = UA_STATUSCODE_GOOD; + if(outBuf->length == 0) { + size_t len = UA_calcSizeBinary(p, type); + res = UA_ByteString_allocBuffer(outBuf, len); + if(res != UA_STATUSCODE_GOOD) + return res; + allocated = true; + } + + /* Encode */ + u8 *pos = outBuf->data; + const u8 *posEnd = &outBuf->data[outBuf->length]; + res = UA_encodeBinaryInternal(p, type, &pos, &posEnd, NULL, NULL); + + /* Clean up */ + if(res == UA_STATUSCODE_GOOD) { + outBuf->length = (size_t)((uintptr_t)pos - (uintptr_t)outBuf->data); + } else if(allocated) { + UA_ByteString_clear(outBuf); + } + return res; +} + +static status +decodeBinaryNotImplemented(void *dst, const UA_DataType *type, Ctx *ctx) { + (void)dst, (void)type, (void)ctx; + return UA_STATUSCODE_BADNOTIMPLEMENTED; +} + +static status +decodeBinaryStructure(void *dst, const UA_DataType *type, Ctx *ctx) { + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, + return UA_STATUSCODE_BADENCODINGERROR); + ctx->depth++; + + uintptr_t ptr = (uintptr_t)dst; + status ret = UA_STATUSCODE_GOOD; + u8 membersSize = type->membersSize; + + /* Loop over members */ + for(size_t i = 0; i < membersSize && ret == UA_STATUSCODE_GOOD; ++i) { + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + ptr += m->padding; + + /* Array */ + if(m->isArray) { + size_t *length = (size_t*)ptr; + ptr += sizeof(size_t); + ret = Array_decodeBinary((void *UA_RESTRICT *UA_RESTRICT)ptr, length, mt , ctx); + ptr += sizeof(void*); + continue; + } + + /* Scalar */ + ret = decodeBinaryJumpTable[mt->typeKind]((void *UA_RESTRICT)ptr, mt, ctx); + ptr += mt->memSize; + } + + ctx->depth--; + return ret; +} + +static status +decodeBinaryStructureWithOptFields(void *dst, const UA_DataType *type, Ctx *ctx) { + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, return UA_STATUSCODE_BADENCODINGERROR); + ctx->depth++; + + uintptr_t ptr = (uintptr_t)dst; + UA_UInt32 encodingMask = 0; + status ret = UInt32_decodeBinary(&encodingMask, &UA_TYPES[UA_TYPES_UINT32], ctx); + UA_CHECK_STATUS(ret, ctx->depth--; return ret); + + /* Loop over members */ + for(size_t i = 0, o = 0; i < type->membersSize && ret == UA_STATUSCODE_GOOD; ++i) { + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + ptr += m->padding; + if(m->isOptional) { + if(!(encodingMask & (UA_UInt32) ( (UA_UInt32) 1<<(o++)))) { + /* Optional field is not contained */ + if(m->isArray) + ptr += sizeof(size_t); + } else if(m->isArray) { + /* Optional Array */ + size_t *length = (size_t*)ptr; + ptr += sizeof(size_t); + ret = Array_decodeBinary((void *UA_RESTRICT *UA_RESTRICT)ptr, length, mt , ctx); + } else { + /* Optional Scalar */ + *(void *UA_RESTRICT *UA_RESTRICT) ptr = UA_calloc(1, mt->memSize); + UA_CHECK_MEM(*(void *UA_RESTRICT *UA_RESTRICT) ptr, return UA_STATUSCODE_BADOUTOFMEMORY); + ret = decodeBinaryJumpTable[mt->typeKind](*(void *UA_RESTRICT *UA_RESTRICT) ptr, mt, ctx); + } + ptr += sizeof(void *); + continue; + } + + /* Array */ + if(m->isArray) { + size_t *length = (size_t *)ptr; + ptr += sizeof(size_t); + ret = Array_decodeBinary((void *UA_RESTRICT *UA_RESTRICT)ptr, length, mt, ctx); + ptr += sizeof(void *); + continue; + } + + /* Scalar */ + ret = decodeBinaryJumpTable[mt->typeKind]((void *UA_RESTRICT)ptr, mt, ctx); + ptr += mt->memSize; + } + ctx->depth--; + return ret; +} + +static status +decodeBinaryUnion(void *UA_RESTRICT dst, const UA_DataType *type, Ctx *ctx) { + /* Check the recursion limit */ + UA_CHECK(ctx->depth <= UA_ENCODING_MAX_RECURSION, + return UA_STATUSCODE_BADENCODINGERROR); + + /* Decode the selection directly into the switchfield */ + status ret = DECODE_DIRECT(dst, UInt32); + UA_CHECK_STATUS(ret, return ret); + + /* No content? */ + UA_UInt32 selection = *(UA_UInt32*)dst; + if(selection == 0) + return UA_STATUSCODE_GOOD; + + /* Sanity check the selection */ + UA_CHECK(selection-1 < type->membersSize, + return UA_STATUSCODE_BADDECODINGERROR); + + /* Select the member */ + const UA_DataTypeMember *m = &type->members[selection-1]; + const UA_DataType *mt = m->memberType; + + /* Decode */ + ctx->depth++; + uintptr_t ptr = ((uintptr_t)dst) + m->padding; /* includes the switchfield */ + if(!m->isArray) { + ret = decodeBinaryJumpTable[mt->typeKind]((void *UA_RESTRICT)ptr, mt, ctx); + } else { + size_t *length = (size_t *)ptr; + ptr += sizeof(size_t); + ret = Array_decodeBinary((void *UA_RESTRICT *UA_RESTRICT)ptr, length, mt, ctx); + } + ctx->depth--; + return ret; +} + +const decodeBinarySignature decodeBinaryJumpTable[UA_DATATYPEKINDS] = { + (decodeBinarySignature)Boolean_decodeBinary, + (decodeBinarySignature)Byte_decodeBinary, /* SByte */ + (decodeBinarySignature)Byte_decodeBinary, + (decodeBinarySignature)UInt16_decodeBinary, /* Int16 */ + (decodeBinarySignature)UInt16_decodeBinary, + (decodeBinarySignature)UInt32_decodeBinary, /* Int32 */ + (decodeBinarySignature)UInt32_decodeBinary, + (decodeBinarySignature)UInt64_decodeBinary, /* Int64 */ + (decodeBinarySignature)UInt64_decodeBinary, + (decodeBinarySignature)Float_decodeBinary, + (decodeBinarySignature)Double_decodeBinary, + (decodeBinarySignature)String_decodeBinary, + (decodeBinarySignature)UInt64_decodeBinary, /* DateTime */ + (decodeBinarySignature)Guid_decodeBinary, + (decodeBinarySignature)String_decodeBinary, /* ByteString */ + (decodeBinarySignature)String_decodeBinary, /* XmlElement */ + (decodeBinarySignature)NodeId_decodeBinary, + (decodeBinarySignature)ExpandedNodeId_decodeBinary, + (decodeBinarySignature)UInt32_decodeBinary, /* StatusCode */ + (decodeBinarySignature)QualifiedName_decodeBinary, + (decodeBinarySignature)LocalizedText_decodeBinary, + (decodeBinarySignature)ExtensionObject_decodeBinary, + (decodeBinarySignature)DataValue_decodeBinary, + (decodeBinarySignature)Variant_decodeBinary, + (decodeBinarySignature)DiagnosticInfo_decodeBinary, + (decodeBinarySignature)decodeBinaryNotImplemented, /* Decimal */ + (decodeBinarySignature)UInt32_decodeBinary, /* Enumeration */ + (decodeBinarySignature)decodeBinaryStructure, + (decodeBinarySignature)decodeBinaryStructureWithOptFields, /* Structure with optional fields */ + (decodeBinarySignature)decodeBinaryUnion, /* Union */ + (decodeBinarySignature)decodeBinaryNotImplemented /* BitfieldCluster */ +}; + +status +UA_decodeBinaryInternal(const UA_ByteString *src, size_t *offset, + void *dst, const UA_DataType *type, + const UA_DataTypeArray *customTypes) { + /* Set up the context */ + Ctx ctx; + ctx.pos = &src->data[*offset]; + ctx.end = &src->data[src->length]; + ctx.depth = 0; + ctx.customTypes = customTypes; + + /* Decode */ + memset(dst, 0, type->memSize); /* Initialize the value */ + status ret = decodeBinaryJumpTable[type->typeKind](dst, type, &ctx); + + if(UA_LIKELY(ret == UA_STATUSCODE_GOOD)) { + /* Set the new offset */ + *offset = (size_t)(ctx.pos - src->data) / sizeof(u8); + } else { + /* Clean up */ + UA_clear(dst, type); + memset(dst, 0, type->memSize); + } + return ret; +} + +UA_StatusCode +UA_decodeBinary(const UA_ByteString *inBuf, + void *p, const UA_DataType *type, + const UA_DecodeBinaryOptions *options) { + size_t offset = 0; + const UA_DataTypeArray *customTypes = options ? options->customTypes : NULL; + return UA_decodeBinaryInternal(inBuf, &offset, p, type, customTypes); +} + +/** + * Compute the Message Size + * ------------------------ + * The following methods are used to compute the length of a datum in binary + * encoding. */ + +static size_t +Array_calcSizeBinary(const void *src, size_t length, const UA_DataType *type) { + size_t s = 4; /* length */ + if(type->overlayable) { + s += type->memSize * length; + return s; + } + uintptr_t ptr = (uintptr_t)src; + for(size_t i = 0; i < length; ++i) { + s += calcSizeBinaryJumpTable[type->typeKind]((const void*)ptr, type); + ptr += type->memSize; + } + return s; +} + +static size_t calcSizeBinary1(const void *_, const UA_DataType *__) { (void)_, (void)__; return 1; } +static size_t calcSizeBinary2(const void *_, const UA_DataType *__) { (void)_, (void)__; return 2; } +static size_t calcSizeBinary4(const void *_, const UA_DataType *__) { (void)_, (void)__; return 4; } +static size_t calcSizeBinary8(const void *_, const UA_DataType *__) { (void)_, (void)__; return 8; } + +CALCSIZE_BINARY(String) { return 4 + src->length; } + +CALCSIZE_BINARY(Guid) { return 16; } + +CALCSIZE_BINARY(NodeId) { + size_t s = 1; /* Encoding byte */ + switch(src->identifierType) { + case UA_NODEIDTYPE_NUMERIC: + if(src->identifier.numeric > UA_UINT16_MAX || src->namespaceIndex > UA_BYTE_MAX) { + s += 6; + } else if(src->identifier.numeric > UA_BYTE_MAX || src->namespaceIndex > 0) { + s += 3; + } else { + s += 1; + } + break; + case UA_NODEIDTYPE_BYTESTRING: + case UA_NODEIDTYPE_STRING: + s += 2; + s += String_calcSizeBinary(&src->identifier.string, NULL); + break; + case UA_NODEIDTYPE_GUID: + s += 18; + break; + default: + return 0; + } + return s; +} + +CALCSIZE_BINARY(ExpandedNodeId) { + size_t s = NodeId_calcSizeBinary(&src->nodeId, NULL); + if(src->namespaceUri.length > 0) + s += String_calcSizeBinary(&src->namespaceUri, NULL); + if(src->serverIndex > 0) + s += 4; + return s; +} + +CALCSIZE_BINARY(QualifiedName) { + return 2 + String_calcSizeBinary(&src->name, NULL); +} + +CALCSIZE_BINARY(LocalizedText) { + size_t s = 1; /* Encoding byte */ + if(src->locale.data) + s += String_calcSizeBinary(&src->locale, NULL); + if(src->text.data) + s += String_calcSizeBinary(&src->text, NULL); + return s; +} + +CALCSIZE_BINARY(ExtensionObject) { + size_t s = 1; /* Encoding byte */ + + /* Encoded content */ + if(src->encoding <= UA_EXTENSIONOBJECT_ENCODED_XML) { + s += NodeId_calcSizeBinary(&src->content.encoded.typeId, NULL); + switch(src->encoding) { + case UA_EXTENSIONOBJECT_ENCODED_NOBODY: + break; + case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING: + case UA_EXTENSIONOBJECT_ENCODED_XML: + s += String_calcSizeBinary(&src->content.encoded.body, NULL); + break; + default: + return 0; + } + return s; + } + + /* Decoded content */ + if(!src->content.decoded.type || !src->content.decoded.data) + return 0; + if(src->content.decoded.type->typeId.identifierType != UA_NODEIDTYPE_NUMERIC) + return 0; + + s += NodeId_calcSizeBinary(&src->content.decoded.type->binaryEncodingId, NULL); /* Type encoding length */ + s += 4; /* Encoding length field */ + const UA_DataType *type = src->content.decoded.type; + s += calcSizeBinaryJumpTable[type->typeKind](src->content.decoded.data, type); /* Encoding length */ + return s; +} + +CALCSIZE_BINARY(Variant) { + size_t s = 1; /* Encoding byte */ + if(!src->type) + return s; + + const UA_Boolean isArray = src->arrayLength > 0 || src->data <= UA_EMPTY_ARRAY_SENTINEL; + if(isArray) + s += Array_calcSizeBinary(src->data, src->arrayLength, src->type); + else + s += calcSizeBinaryJumpTable[src->type->typeKind](src->data, src->type); + + const UA_Boolean isBuiltin = (src->type->typeKind <= UA_DATATYPEKIND_DIAGNOSTICINFO); + const UA_Boolean isEnum = (src->type->typeKind == UA_DATATYPEKIND_ENUM); + if(!isBuiltin && !isEnum) { + /* The type is wrapped inside an extensionobject */ + /* (NodeId + encoding byte + extension object length) * array length */ + size_t length = isArray ? src->arrayLength : 1; + s += (NodeId_calcSizeBinary(&src->type->binaryEncodingId, NULL) + 1 + 4) * length; + } + + const UA_Boolean hasDimensions = isArray && src->arrayDimensionsSize > 0; + if(hasDimensions) + s += Array_calcSizeBinary(src->arrayDimensions, src->arrayDimensionsSize, + &UA_TYPES[UA_TYPES_INT32]); + return s; +} + +CALCSIZE_BINARY(DataValue) { + size_t s = 1; /* Encoding byte */ + if(src->hasValue) + s += Variant_calcSizeBinary(&src->value, NULL); + if(src->hasStatus) + s += 4; + if(src->hasSourceTimestamp) + s += 8; + if(src->hasSourcePicoseconds) + s += 2; + if(src->hasServerTimestamp) + s += 8; + if(src->hasServerPicoseconds) + s += 2; + return s; +} + +CALCSIZE_BINARY(DiagnosticInfo) { + size_t s = 1; /* Encoding byte */ + if(src->hasSymbolicId) + s += 4; + if(src->hasNamespaceUri) + s += 4; + if(src->hasLocalizedText) + s += 4; + if(src->hasLocale) + s += 4; + if(src->hasAdditionalInfo) + s += String_calcSizeBinary(&src->additionalInfo, NULL); + if(src->hasInnerStatusCode) + s += 4; + if(src->hasInnerDiagnosticInfo) + s += DiagnosticInfo_calcSizeBinary(src->innerDiagnosticInfo, NULL); + return s; +} + +static size_t +calcSizeBinaryStructure(const void *p, const UA_DataType *type) { + size_t s = 0; + uintptr_t ptr = (uintptr_t)p; + u8 membersSize = type->membersSize; + + /* Loop over members */ + for(size_t i = 0; i < membersSize; ++i) { + const UA_DataTypeMember *member = &type->members[i]; + const UA_DataType *membertype = member->memberType; + ptr += member->padding; + + /* Array */ + if(member->isArray) { + const size_t length = *((const size_t*)ptr); + ptr += sizeof(size_t); + s += Array_calcSizeBinary(*(void *UA_RESTRICT const *)ptr, length, membertype); + ptr += sizeof(void*); + continue; + } + + /* Scalar */ + s += calcSizeBinaryJumpTable[membertype->typeKind]((const void*)ptr, membertype); + ptr += membertype->memSize; + } + + return s; +} + +static size_t +calcSizeBinaryStructureWithOptFields(const void *p, const UA_DataType *type) { + /* Start with the size of the encoding mask */ + size_t s = sizeof(UA_UInt32); + + /* Loop over members */ + uintptr_t ptr = (uintptr_t)p; + for(size_t i = 0; i < type->membersSize; ++i) { + const UA_DataTypeMember *member = &type->members[i]; + const UA_DataType *membertype = member->memberType; + ptr += member->padding; + if(member->isOptional) { + if((member->isArray && ((*(void* const*)(ptr+sizeof(size_t))) == NULL)) || + (!member->isArray && (*(void* const*)ptr == NULL))) { + /* Optional member not contained */ + if(member->isArray) + ptr += sizeof(size_t); + ptr += sizeof(void *); + continue; + } + /* Fallthrough to take the size into account */ + } + /* Array */ + if(member->isArray) { + const size_t length = *((const size_t*)ptr); + ptr += sizeof(size_t); + s += Array_calcSizeBinary(*(void *UA_RESTRICT const *)ptr, length, membertype); + ptr += sizeof(void*); + continue; + } + /* Scalar */ + s += calcSizeBinaryJumpTable[membertype->typeKind]((const void*)ptr, membertype); + member->isOptional ? (ptr += sizeof(void *)) : (ptr += membertype->memSize); + } + return s; +} + +static size_t +calcSizeBinaryUnion(const void *p, const UA_DataType *type) { + size_t s = 4; /* UA_TYPES[UA_TYPES_UINT32].memSize; */ + const UA_UInt32 selection = *(const UA_UInt32 *)p; + if(selection == 0) + return s; + + const UA_DataTypeMember *m = &type->members[selection-1]; + const UA_DataType *mt = m->memberType; + + uintptr_t ptr = ((uintptr_t)p) + m->padding; /* includes switchfield length */ + if(!m->isArray) { + s += UA_calcSizeBinary((const void*)ptr, mt); + } else { + const size_t length = *((const size_t*)ptr); + ptr += sizeof(size_t); + s += Array_calcSizeBinary(*(void *UA_RESTRICT const *)ptr, length, mt); + } + return s; +} + +static size_t +calcSizeBinaryNotImplemented(const void *p, const UA_DataType *type) { + (void)p, (void)type; + return 0; +} + +const calcSizeBinarySignature calcSizeBinaryJumpTable[UA_DATATYPEKINDS] = { + (calcSizeBinarySignature)calcSizeBinary1, /* Boolean */ + (calcSizeBinarySignature)calcSizeBinary1, /* SByte */ + (calcSizeBinarySignature)calcSizeBinary1, /* Byte */ + (calcSizeBinarySignature)calcSizeBinary2, /* Int16 */ + (calcSizeBinarySignature)calcSizeBinary2, /* UInt16 */ + (calcSizeBinarySignature)calcSizeBinary4, /* Int32 */ + (calcSizeBinarySignature)calcSizeBinary4, /* UInt32 */ + (calcSizeBinarySignature)calcSizeBinary8, /* Int64 */ + (calcSizeBinarySignature)calcSizeBinary8, /* UInt64 */ + (calcSizeBinarySignature)calcSizeBinary4, /* Float */ + (calcSizeBinarySignature)calcSizeBinary8, /* Double */ + (calcSizeBinarySignature)String_calcSizeBinary, + (calcSizeBinarySignature)calcSizeBinary8, /* DateTime */ + (calcSizeBinarySignature)Guid_calcSizeBinary, + (calcSizeBinarySignature)String_calcSizeBinary, /* ByteString */ + (calcSizeBinarySignature)String_calcSizeBinary, /* XmlElement */ + (calcSizeBinarySignature)NodeId_calcSizeBinary, + (calcSizeBinarySignature)ExpandedNodeId_calcSizeBinary, + (calcSizeBinarySignature)calcSizeBinary4, /* StatusCode */ + (calcSizeBinarySignature)QualifiedName_calcSizeBinary, + (calcSizeBinarySignature)LocalizedText_calcSizeBinary, + (calcSizeBinarySignature)ExtensionObject_calcSizeBinary, + (calcSizeBinarySignature)DataValue_calcSizeBinary, + (calcSizeBinarySignature)Variant_calcSizeBinary, + (calcSizeBinarySignature)DiagnosticInfo_calcSizeBinary, + (calcSizeBinarySignature)calcSizeBinaryNotImplemented, /* Decimal */ + (calcSizeBinarySignature)calcSizeBinary4, /* Enumeration */ + (calcSizeBinarySignature)calcSizeBinaryStructure, + (calcSizeBinarySignature)calcSizeBinaryStructureWithOptFields, /* Structure with Optional Fields */ + (calcSizeBinarySignature)calcSizeBinaryUnion, /* Union */ + (calcSizeBinarySignature)calcSizeBinaryNotImplemented /* BitfieldCluster */ +}; + +size_t +UA_calcSizeBinary(const void *p, const UA_DataType *type) { + return calcSizeBinaryJumpTable[type->typeKind](p, type); +} + +/**** amalgamated original file "/src/ua_types_print.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + + +/* Printing of NodeIds is always enabled. We need it for logging. */ + +UA_StatusCode +UA_NodeId_print(const UA_NodeId *id, UA_String *output) { + UA_String_clear(output); + if(!id) + return UA_STATUSCODE_GOOD; + + char *nsStr = NULL; + long snprintfLen = 0; + size_t nsLen = 0; + if(id->namespaceIndex != 0) { + nsStr = (char*)UA_malloc(9+1); // strlen("ns=XXXXX;") = 9 + Nullbyte + if(!nsStr) + return UA_STATUSCODE_BADOUTOFMEMORY; + snprintfLen = UA_snprintf(nsStr, 10, "ns=%d;", id->namespaceIndex); + if(snprintfLen < 0 || snprintfLen >= 10) { + UA_free(nsStr); + return UA_STATUSCODE_BADINTERNALERROR; + } + nsLen = (size_t)(snprintfLen); + } + + UA_ByteString byteStr = UA_BYTESTRING_NULL; + switch (id->identifierType) { + case UA_NODEIDTYPE_NUMERIC: + /* ns (2 byte, 65535) = 5 chars, numeric (4 byte, 4294967295) = 10 + * chars, delim = 1 , nullbyte = 1-> 17 chars */ + output->length = nsLen + 2 + 10 + 1; + output->data = (UA_Byte*)UA_malloc(output->length); + if(output->data == NULL) { + output->length = 0; + UA_free(nsStr); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + snprintfLen = UA_snprintf((char*)output->data, output->length, "%si=%lu", + nsLen > 0 ? nsStr : "", + (unsigned long )id->identifier.numeric); + break; + case UA_NODEIDTYPE_STRING: + /* ns (16bit) = 5 chars, strlen + nullbyte */ + output->length = nsLen + 2 + id->identifier.string.length + 1; + output->data = (UA_Byte*)UA_malloc(output->length); + if(output->data == NULL) { + output->length = 0; + UA_free(nsStr); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + snprintfLen = UA_snprintf((char*)output->data, output->length, "%ss=%.*s", + nsLen > 0 ? nsStr : "", (int)id->identifier.string.length, + id->identifier.string.data); + break; + case UA_NODEIDTYPE_GUID: + /* ns (16bit) = 5 chars + strlen(A123456C-0ABC-1A2B-815F-687212AAEE1B)=36 + nullbyte */ + output->length = nsLen + 2 + 36 + 1; + output->data = (UA_Byte*)UA_malloc(output->length); + if(output->data == NULL) { + output->length = 0; + UA_free(nsStr); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + snprintfLen = UA_snprintf((char*)output->data, output->length, + "%sg=" UA_PRINTF_GUID_FORMAT, nsLen > 0 ? nsStr : "", + UA_PRINTF_GUID_DATA(id->identifier.guid)); + break; + case UA_NODEIDTYPE_BYTESTRING: + UA_ByteString_toBase64(&id->identifier.byteString, &byteStr); + /* ns (16bit) = 5 chars + LEN + nullbyte */ + output->length = nsLen + 2 + byteStr.length + 1; + output->data = (UA_Byte*)UA_malloc(output->length); + if(output->data == NULL) { + output->length = 0; + UA_String_clear(&byteStr); + UA_free(nsStr); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + snprintfLen = UA_snprintf((char*)output->data, output->length, "%sb=%.*s", + nsLen > 0 ? nsStr : "", + (int)byteStr.length, byteStr.data); + UA_String_clear(&byteStr); + break; + } + UA_free(nsStr); + + if(snprintfLen < 0 || snprintfLen >= (long) output->length) { + UA_free(output->data); + output->data = NULL; + output->length = 0; + return UA_STATUSCODE_BADINTERNALERROR; + } + output->length = (size_t)snprintfLen; + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_ExpandedNodeId_print(const UA_ExpandedNodeId *id, UA_String *output) { + /* Don't print the namespace-index if a NamespaceUri is set */ + UA_NodeId nid = id->nodeId; + if(id->namespaceUri.data != NULL) + nid.namespaceIndex = 0; + + /* Encode the NodeId */ + UA_String outNid = UA_STRING_NULL; + UA_StatusCode res = UA_NodeId_print(&nid, &outNid); + if(res != UA_STATUSCODE_GOOD) + return res; + + /* Encode the ServerIndex */ + char svr[100]; + if(id->serverIndex == 0) + svr[0] = 0; + else + UA_snprintf(svr, 100, "svr=%"PRIu32";", id->serverIndex); + size_t svrlen = strlen(svr); + + /* Encode the NamespaceUri */ + char nsu[100]; + if(id->namespaceUri.data == NULL) + nsu[0] = 0; + else + UA_snprintf(nsu, 100, "nsu=%.*s;", (int)id->namespaceUri.length, id->namespaceUri.data); + size_t nsulen = strlen(nsu); + + /* Combine everything */ + res = UA_ByteString_allocBuffer((UA_String*)output, outNid.length + svrlen + nsulen); + if(res == UA_STATUSCODE_GOOD) { + memcpy(output->data, svr, svrlen); + memcpy(&output->data[svrlen], nsu, nsulen); + memcpy(&output->data[svrlen+nsulen], outNid.data, outNid.length); + } + + UA_String_clear(&outNid); + return res; +} + +#ifdef UA_ENABLE_TYPEDESCRIPTION + +/***********************/ +/* Jumptable Signature */ +/***********************/ + +typedef struct UA_PrintElement { + TAILQ_ENTRY(UA_PrintElement) next; + size_t length; + UA_Byte data[]; +} UA_PrintOutput; + +typedef struct { + size_t depth; + TAILQ_HEAD(, UA_PrintElement) outputs; +} UA_PrintContext; + +typedef UA_StatusCode +(*UA_printSignature)(UA_PrintContext *ctx, const void *p, + const UA_DataType *type); + +extern const UA_printSignature printJumpTable[UA_DATATYPEKINDS]; + +/********************/ +/* Helper Functions */ +/********************/ + +static UA_PrintOutput * +UA_PrintContext_addOutput(UA_PrintContext *ctx, size_t length) { + /* Protect against overlong output in pretty-printing */ + if(length > 2<<16) + return NULL; + UA_PrintOutput *output = (UA_PrintOutput*)UA_malloc(sizeof(UA_PrintOutput) + length + 1); + if(!output) + return NULL; + output->length = length; + TAILQ_INSERT_TAIL(&ctx->outputs, output, next); + return output; +} + +static UA_StatusCode +UA_PrintContext_addNewlineTabs(UA_PrintContext *ctx, size_t tabs) { + UA_PrintOutput *out = UA_PrintContext_addOutput(ctx, tabs+1); + if(!out) + return UA_STATUSCODE_BADOUTOFMEMORY; + out->data[0] = '\n'; + for(size_t i = 1; i <= tabs; i++) + out->data[i] = '\t'; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_PrintContext_addName(UA_PrintContext *ctx, const char *name) { + size_t nameLen = strlen(name); + UA_PrintOutput *out = UA_PrintContext_addOutput(ctx, nameLen+2); + if(!out) + return UA_STATUSCODE_BADOUTOFMEMORY; + memcpy(&out->data, name, nameLen); + out->data[nameLen] = ':'; + out->data[nameLen+1] = ' '; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_PrintContext_addString(UA_PrintContext *ctx, const char *str) { + size_t len = strlen(str); + UA_PrintOutput *out = UA_PrintContext_addOutput(ctx, len); + if(!out) + return UA_STATUSCODE_BADOUTOFMEMORY; + memcpy(&out->data, str, len); + return UA_STATUSCODE_GOOD; +} + +/*********************/ +/* Printing Routines */ +/*********************/ + +static UA_StatusCode +printArray(UA_PrintContext *ctx, const void *p, const size_t length, + const UA_DataType *type); + +static UA_StatusCode +printBoolean(UA_PrintContext *ctx, const UA_Boolean *p, const UA_DataType *_) { + if(*p) + return UA_PrintContext_addString(ctx, "true"); + return UA_PrintContext_addString(ctx, "false"); +} + +static UA_StatusCode +printSByte(UA_PrintContext *ctx, const UA_SByte *p, const UA_DataType *_) { + char out[32]; + UA_snprintf(out, 32, "%"PRIi8, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printByte(UA_PrintContext *ctx, const UA_Byte *p, const UA_DataType *_) { + char out[32]; + UA_snprintf(out, 32, "%"PRIu8, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printInt16(UA_PrintContext *ctx, const UA_Int16 *p, const UA_DataType *_) { + char out[32]; + UA_snprintf(out, 32, "%"PRIi16, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printUInt16(UA_PrintContext *ctx, const UA_UInt16 *p, const UA_DataType *_) { + char out[32]; + UA_snprintf(out, 32, "%"PRIu16, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printInt32(UA_PrintContext *ctx, const UA_Int32 *p, const UA_DataType *_) { + char out[32]; + UA_snprintf(out, 32, "%"PRIi32, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printUInt32(UA_PrintContext *ctx, const UA_UInt32 *p, const UA_DataType *_) { + char out[32]; + UA_snprintf(out, 32, "%"PRIu32, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printInt64(UA_PrintContext *ctx, const UA_Int64 *p, const UA_DataType *_) { + char out[64]; + UA_snprintf(out, 64, "%"PRIi64, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printUInt64(UA_PrintContext *ctx, const UA_UInt64 *p, const UA_DataType *_) { + char out[64]; + UA_snprintf(out, 64, "%"PRIu64, *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printFloat(UA_PrintContext *ctx, const UA_Float *p, const UA_DataType *_) { + char out[64]; + UA_snprintf(out, 32, "%f", *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printDouble(UA_PrintContext *ctx, const UA_Double *p, const UA_DataType *_) { + char out[64]; + UA_snprintf(out, 64, "%lf", *p); + return UA_PrintContext_addString(ctx, out); +} + +static UA_StatusCode +printStatusCode(UA_PrintContext *ctx, const UA_StatusCode *p, const UA_DataType *_) { + return UA_PrintContext_addString(ctx, UA_StatusCode_name(*p)); +} + +static UA_StatusCode +printNodeId(UA_PrintContext *ctx, const UA_NodeId *p, const UA_DataType *_) { + UA_String out; + UA_String_init(&out); + UA_StatusCode res = UA_NodeId_print(p, &out); + if(res != UA_STATUSCODE_GOOD) + return res; + UA_PrintOutput *po = UA_PrintContext_addOutput(ctx, out.length); + if(po) + memcpy(po->data, out.data, out.length); + else + res = UA_STATUSCODE_BADOUTOFMEMORY; + UA_String_clear(&out); + return res; +} + +static UA_StatusCode +printExpandedNodeId(UA_PrintContext *ctx, const UA_ExpandedNodeId *p, const UA_DataType *_) { + UA_String out; + UA_String_init(&out); + UA_StatusCode res = UA_ExpandedNodeId_print(p, &out); + if(res != UA_STATUSCODE_GOOD) + return res; + UA_PrintOutput *po = UA_PrintContext_addOutput(ctx, out.length); + if(!po) + return UA_STATUSCODE_BADOUTOFMEMORY; + memcpy(po->data, out.data, out.length); + UA_String_clear(&out); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +printDateTime(UA_PrintContext *ctx, const UA_DateTime *p, const UA_DataType *_) { + UA_Int64 tOffset = UA_DateTime_localTimeUtcOffset(); + UA_DateTimeStruct dts = UA_DateTime_toStruct(*p); + char dateString[100]; + UA_snprintf((char*)dateString, 100, + "%04u-%02u-%02u %02u:%02u:%02u.%03u (UTC%+05d)", + dts.year, dts.month, dts.day, dts.hour, dts.min, + dts.sec, dts.milliSec, + (int)(tOffset / UA_DATETIME_SEC / 36)); + return UA_PrintContext_addString(ctx, dateString); +} + +static UA_StatusCode +printGuid(UA_PrintContext *ctx, const UA_Guid *p, const UA_DataType *_) { + char tmp[100]; + UA_snprintf(tmp, 100, UA_PRINTF_GUID_FORMAT, UA_PRINTF_GUID_DATA(*p)); + return UA_PrintContext_addString(ctx, tmp); +} + +static UA_StatusCode +printString(UA_PrintContext *ctx, const UA_String *p, const UA_DataType *_) { + if(!p->data) + return UA_PrintContext_addString(ctx, "NullString"); + UA_PrintOutput *out = UA_PrintContext_addOutput(ctx, p->length+2); + if(!out) + return UA_STATUSCODE_BADOUTOFMEMORY; + UA_snprintf((char*)out->data, p->length+3, "\"%.*s\"", (int)p->length, p->data); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +printByteString(UA_PrintContext *ctx, const UA_ByteString *p, const UA_DataType *_) { + if(!p->data) + return UA_PrintContext_addString(ctx, "NullByteString"); + UA_String str = UA_BYTESTRING_NULL; + UA_StatusCode res = UA_ByteString_toBase64(p, &str); + if(res != UA_STATUSCODE_GOOD) + return res; + res = printString(ctx, &str, NULL); + UA_String_clear(&str); + return res; +} + +static UA_StatusCode +printQualifiedName(UA_PrintContext *ctx, const UA_QualifiedName *p, const UA_DataType *_) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + retval |= UA_PrintContext_addString(ctx, "{"); + ctx->depth++; + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "NamespaceIndex"); + retval |= printUInt16(ctx, &p->namespaceIndex, NULL); + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "Name"); + retval |= printString(ctx, &p->name, NULL); + ctx->depth--; + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addString(ctx, "}"); + return retval; +} + +static UA_StatusCode +printLocalizedText(UA_PrintContext *ctx, const UA_LocalizedText *p, const UA_DataType *_) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + retval |= UA_PrintContext_addString(ctx, "{"); + ctx->depth++; + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "Locale"); + retval |= printString(ctx, &p->locale, NULL); + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "Text"); + retval |= printString(ctx, &p->text, NULL); + ctx->depth--; + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addString(ctx, "}"); + return retval; +} + +static UA_StatusCode +printVariant(UA_PrintContext *ctx, const UA_Variant *p, const UA_DataType *_) { + if(!p->type) + return UA_PrintContext_addString(ctx, "NullVariant"); + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + retval |= UA_PrintContext_addString(ctx, "{"); + ctx->depth++; + + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "DataType"); + retval |= UA_PrintContext_addString(ctx, p->type->typeName); + retval |= UA_PrintContext_addString(ctx, ","); + + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "Value"); + if(UA_Variant_isScalar(p)) + retval |= printJumpTable[p->type->typeKind](ctx, p->data, p->type); + else + retval |= printArray(ctx, p->data, p->arrayLength, p->type); + + if(p->arrayDimensionsSize > 0) { + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "ArrayDimensions"); + retval |= printArray(ctx, p->arrayDimensions, p->arrayDimensionsSize, + &UA_TYPES[UA_TYPES_UINT32]); + } + + ctx->depth--; + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addString(ctx, "}"); + return retval; +} + +static UA_StatusCode +printExtensionObject(UA_PrintContext *ctx, const UA_ExtensionObject*p, + const UA_DataType *_) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + switch(p->encoding) { + case UA_EXTENSIONOBJECT_ENCODED_NOBODY: + return UA_PrintContext_addString(ctx, "ExtensionObject(No Body)"); + case UA_EXTENSIONOBJECT_ENCODED_BYTESTRING: + res |= UA_PrintContext_addString(ctx, "ExtensionObject(Binary Encoded) {"); + ctx->depth++; + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "DataType"); + res |= printNodeId(ctx, &p->content.encoded.typeId, NULL); + res |= UA_PrintContext_addString(ctx, ","); + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "Body"); + res |= printByteString(ctx, &p->content.encoded.body, NULL); + ctx->depth--; + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "}"); + break; + case UA_EXTENSIONOBJECT_ENCODED_XML: + res |= UA_PrintContext_addString(ctx, "ExtensionObject(XML Encoded) {"); + ctx->depth++; + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "DataType"); + res |= printNodeId(ctx, &p->content.encoded.typeId, NULL); + res |= UA_PrintContext_addString(ctx, ","); + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "Body"); + res |= printString(ctx, (const UA_String*)&p->content.encoded.body, NULL); + ctx->depth--; + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "}"); + break; + case UA_EXTENSIONOBJECT_DECODED: + case UA_EXTENSIONOBJECT_DECODED_NODELETE: + res |= UA_PrintContext_addString(ctx, "ExtensionObject {"); + ctx->depth++; + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "DataType"); + res |= UA_PrintContext_addString(ctx, p->content.decoded.type->typeName); + res |= UA_PrintContext_addString(ctx, ","); + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "Body"); + res |= printJumpTable[p->content.decoded.type->typeKind](ctx, + p->content.decoded.data, + p->content.decoded.type); + ctx->depth--; + res |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + res |= UA_PrintContext_addName(ctx, "}"); + break; + default: + res = UA_STATUSCODE_BADINTERNALERROR; + break; + } + return res; +} + +static UA_StatusCode +printDataValue(UA_PrintContext *ctx, const UA_DataValue *p, const UA_DataType *_) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + retval |= UA_PrintContext_addString(ctx, "{"); + ctx->depth++; + UA_Boolean comma = false; + + if(p->hasValue) { + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "Value"); + retval |= printVariant(ctx, &p->value, NULL); + comma = true; + } + + if(p->hasStatus) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "Status"); + retval |= printStatusCode(ctx, &p->status, NULL); + comma = true; + } + + if(p->hasSourceTimestamp) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "SourceTimestamp"); + retval |= printDateTime(ctx, &p->sourceTimestamp, NULL); + comma = true; + } + + if(p->hasSourcePicoseconds) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "SourcePicoseconds"); + retval |= printUInt16(ctx, &p->sourcePicoseconds, NULL); + comma = true; + } + + if(p->hasServerTimestamp) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "ServerTimestamp"); + retval |= printDateTime(ctx, &p->serverTimestamp, NULL); + comma = true; + } + + if(p->hasServerPicoseconds) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "ServerPicoseconds"); + retval |= printUInt16(ctx, &p->serverPicoseconds, NULL); + comma = true; + } + + ctx->depth--; + if(comma) { + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addString(ctx, "}"); + } else { + retval |= UA_PrintContext_addString(ctx, " }"); + } + return retval; +} + +static UA_StatusCode +printDiagnosticInfo(UA_PrintContext *ctx, const UA_DiagnosticInfo *p, const UA_DataType *_) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + retval |= UA_PrintContext_addString(ctx, "{"); + ctx->depth++; + UA_Boolean comma = false; + + if(p->hasSymbolicId) { + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "SymbolicId"); + retval |= printInt32(ctx, &p->symbolicId, NULL); + comma = true; + } + + if(p->hasNamespaceUri) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "NamespaceUri"); + retval |= printInt32(ctx, &p->namespaceUri, NULL); + comma = true; + } + + if(p->hasLocalizedText) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "LocalizedText"); + retval |= printInt32(ctx, &p->localizedText, NULL); + comma = true; + } + + if(p->hasLocale) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "Locale"); + retval |= printInt32(ctx, &p->locale, NULL); + comma = true; + } + + if(p->hasAdditionalInfo) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "AdditionalInfo"); + retval |= printString(ctx, &p->additionalInfo, NULL); + comma = true; + } + + if(p->hasInnerStatusCode) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "InnerStatusCode"); + retval |= printStatusCode(ctx, &p->innerStatusCode, NULL); + comma = true; + } + + if(p->hasInnerDiagnosticInfo) { + if(comma) + retval |= UA_PrintContext_addString(ctx, ","); + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addName(ctx, "InnerDiagnosticInfo"); + retval |= printDiagnosticInfo(ctx, p->innerDiagnosticInfo, NULL); + comma = true; + } + + ctx->depth--; + if(comma) { + retval |= UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addString(ctx, "}"); + } else { + retval |= UA_PrintContext_addString(ctx, " }"); + } + return retval; +} + +static UA_StatusCode +printArray(UA_PrintContext *ctx, const void *p, const size_t length, + const UA_DataType *type) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(!p) { + retval |= UA_PrintContext_addString(ctx, "Array(-1, "); + retval |= UA_PrintContext_addString(ctx, type->typeName); + retval |= UA_PrintContext_addString(ctx, ")"); + return retval; + } + + UA_UInt32 length32 = (UA_UInt32)length; + retval |= UA_PrintContext_addString(ctx, "Array("); + retval |= printUInt32(ctx, &length32, NULL); + retval |= UA_PrintContext_addString(ctx, ", "); + retval |= UA_PrintContext_addString(ctx, type->typeName); + retval |= UA_PrintContext_addString(ctx, ") {"); + ctx->depth++; + uintptr_t target = (uintptr_t)p; + for(UA_UInt32 i = 0; i < length; i++) { + UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + printUInt32(ctx, &i, NULL); + retval |= UA_PrintContext_addString(ctx, ": "); + printJumpTable[type->typeKind](ctx, (const void*)target, type); + if(i < length - 1) + retval |= UA_PrintContext_addString(ctx, ","); + target += type->memSize; + } + ctx->depth--; + UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addString(ctx, "}"); + return retval; +} + +static UA_StatusCode +printStructure(UA_PrintContext *ctx, const void *p, const UA_DataType *type) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + uintptr_t ptrs = (uintptr_t)p; + retval |= UA_PrintContext_addString(ctx, "{"); + ctx->depth++; + for(size_t i = 0; i < type->membersSize; ++i) { + UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + const UA_DataTypeMember *m = &type->members[i]; + const UA_DataType *mt = m->memberType; + ptrs += m->padding; + retval |= UA_PrintContext_addName(ctx, m->memberName); + if(!m->isArray) { + retval |= printJumpTable[mt->typeKind](ctx, (const void *)ptrs, mt); + ptrs += mt->memSize; + } else { + const size_t size = *((const size_t*)ptrs); + ptrs += sizeof(size_t); + retval |= printArray(ctx, *(void* const*)ptrs, size, mt); + ptrs += sizeof(void*); + } + if(i < (size_t)(type->membersSize - 1)) + retval |= UA_PrintContext_addString(ctx, ","); + } + ctx->depth--; + UA_PrintContext_addNewlineTabs(ctx, ctx->depth); + retval |= UA_PrintContext_addString(ctx, "}"); + return retval; +} + +static UA_StatusCode +printNotImplemented(UA_PrintContext *ctx, const void *p, const UA_DataType *type) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + res |= UA_PrintContext_addString(ctx, type->typeName); + res |= UA_PrintContext_addString(ctx, " (Printing Not Implemented)"); + return res; +} + +const UA_printSignature printJumpTable[UA_DATATYPEKINDS] = { + (UA_printSignature)printBoolean, + (UA_printSignature)printSByte, + (UA_printSignature)printByte, + (UA_printSignature)printInt16, + (UA_printSignature)printUInt16, + (UA_printSignature)printInt32, + (UA_printSignature)printUInt32, + (UA_printSignature)printInt64, + (UA_printSignature)printUInt64, + (UA_printSignature)printFloat, + (UA_printSignature)printDouble, + (UA_printSignature)printString, + (UA_printSignature)printDateTime, + (UA_printSignature)printGuid, + (UA_printSignature)printByteString, + (UA_printSignature)printString, /* XmlElement */ + (UA_printSignature)printNodeId, + (UA_printSignature)printExpandedNodeId, + (UA_printSignature)printStatusCode, + (UA_printSignature)printQualifiedName, + (UA_printSignature)printLocalizedText, + (UA_printSignature)printExtensionObject, + (UA_printSignature)printDataValue, + (UA_printSignature)printVariant, + (UA_printSignature)printDiagnosticInfo, + (UA_printSignature)printNotImplemented, /* Decimal */ + (UA_printSignature)printUInt32, /* Enumeration */ + (UA_printSignature)printStructure, + (UA_printSignature)printNotImplemented, /* Structure with Optional Fields */ + (UA_printSignature)printNotImplemented, /* Union */ + (UA_printSignature)printNotImplemented /* BitfieldCluster*/ +}; + +UA_StatusCode +UA_print(const void *p, const UA_DataType *type, UA_String *output) { + UA_PrintContext ctx; + ctx.depth = 0; + TAILQ_INIT(&ctx.outputs); + + /* Encode */ + UA_StatusCode retval = printJumpTable[type->typeKind](&ctx, p, type); + + /* Allocate memory for the output */ + if(retval == UA_STATUSCODE_GOOD) { + size_t total = 0; + UA_PrintOutput *out; + TAILQ_FOREACH(out, &ctx.outputs, next) + total += out->length; + retval = UA_ByteString_allocBuffer((UA_String*)output, total); + } + + /* Write the output */ + if(retval == UA_STATUSCODE_GOOD) { + size_t pos = 0; + UA_PrintOutput *out; + TAILQ_FOREACH(out, &ctx.outputs, next) { + memcpy(&output->data[pos], out->data, out->length); + pos += out->length; + } + } + + /* Free the context */ + UA_PrintOutput *o, *o2; + TAILQ_FOREACH_SAFE(o, &ctx.outputs, next, o2) { + TAILQ_REMOVE(&ctx.outputs, o, next); + UA_free(o); + } + return retval; +} + +#endif /* UA_ENABLE_TYPEDESCRIPTION */ + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/types_generated.c" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + + +/* Boolean */ +#define Boolean_members NULL + +/* SByte */ +#define SByte_members NULL + +/* Byte */ +#define Byte_members NULL + +/* Int16 */ +#define Int16_members NULL + +/* UInt16 */ +#define UInt16_members NULL + +/* Int32 */ +#define Int32_members NULL + +/* UInt32 */ +#define UInt32_members NULL + +/* Int64 */ +#define Int64_members NULL + +/* UInt64 */ +#define UInt64_members NULL + +/* Float */ +#define Float_members NULL + +/* Double */ +#define Double_members NULL + +/* String */ +#define String_members NULL + +/* DateTime */ +#define DateTime_members NULL + +/* Guid */ +#define Guid_members NULL + +/* ByteString */ +#define ByteString_members NULL + +/* XmlElement */ +#define XmlElement_members NULL + +/* NodeId */ +#define NodeId_members NULL + +/* ExpandedNodeId */ +#define ExpandedNodeId_members NULL + +/* StatusCode */ +#define StatusCode_members NULL + +/* QualifiedName */ +#define QualifiedName_members NULL + +/* LocalizedText */ +#define LocalizedText_members NULL + +/* ExtensionObject */ +#define ExtensionObject_members NULL + +/* DataValue */ +#define DataValue_members NULL + +/* Variant */ +#define Variant_members NULL + +/* DiagnosticInfo */ +#define DiagnosticInfo_members NULL + +/* KeyValuePair */ +static UA_DataTypeMember KeyValuePair_members[2] = { +{ + UA_TYPENAME("Key") /* .memberName */ + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_VARIANT], /* .memberType */ + offsetof(UA_KeyValuePair, value) - offsetof(UA_KeyValuePair, key) - sizeof(UA_QualifiedName), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* NodeClass */ +#define NodeClass_members NULL + +/* StructureType */ +#define StructureType_members NULL + +/* StructureField */ +static UA_DataTypeMember StructureField_members[7] = { +{ + UA_TYPENAME("Name") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_StructureField, description) - offsetof(UA_StructureField, name) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DataType") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_StructureField, dataType) - offsetof(UA_StructureField, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ValueRank") /* .memberName */ + &UA_TYPES[UA_TYPES_INT32], /* .memberType */ + offsetof(UA_StructureField, valueRank) - offsetof(UA_StructureField, dataType) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ArrayDimensions") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_StructureField, arrayDimensionsSize) - offsetof(UA_StructureField, valueRank) - sizeof(UA_Int32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxStringLength") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_StructureField, maxStringLength) - offsetof(UA_StructureField, arrayDimensions) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsOptional") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_StructureField, isOptional) - offsetof(UA_StructureField, maxStringLength) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* StructureDefinition */ +static UA_DataTypeMember StructureDefinition_members[4] = { +{ + UA_TYPENAME("DefaultEncodingId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BaseDataType") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_StructureDefinition, baseDataType) - offsetof(UA_StructureDefinition, defaultEncodingId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("StructureType") /* .memberName */ + &UA_TYPES[UA_TYPES_STRUCTURETYPE], /* .memberType */ + offsetof(UA_StructureDefinition, structureType) - offsetof(UA_StructureDefinition, baseDataType) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Fields") /* .memberName */ + &UA_TYPES[UA_TYPES_STRUCTUREFIELD], /* .memberType */ + offsetof(UA_StructureDefinition, fieldsSize) - offsetof(UA_StructureDefinition, structureType) - sizeof(UA_StructureType), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* Argument */ +static UA_DataTypeMember Argument_members[5] = { +{ + UA_TYPENAME("Name") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DataType") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_Argument, dataType) - offsetof(UA_Argument, name) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ValueRank") /* .memberName */ + &UA_TYPES[UA_TYPES_INT32], /* .memberType */ + offsetof(UA_Argument, valueRank) - offsetof(UA_Argument, dataType) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ArrayDimensions") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_Argument, arrayDimensionsSize) - offsetof(UA_Argument, valueRank) - sizeof(UA_Int32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_Argument, description) - offsetof(UA_Argument, arrayDimensions) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EnumValueType */ +static UA_DataTypeMember EnumValueType_members[3] = { +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_INT64], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_EnumValueType, displayName) - offsetof(UA_EnumValueType, value) - sizeof(UA_Int64), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_EnumValueType, description) - offsetof(UA_EnumValueType, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EnumField */ +static UA_DataTypeMember EnumField_members[4] = { +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_INT64], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_EnumField, displayName) - offsetof(UA_EnumField, value) - sizeof(UA_Int64), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_EnumField, description) - offsetof(UA_EnumField, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Name") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_EnumField, name) - offsetof(UA_EnumField, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* Duration */ +#define Duration_members NULL + +/* UtcTime */ +#define UtcTime_members NULL + +/* LocaleId */ +#define LocaleId_members NULL + +/* TimeZoneDataType */ +static UA_DataTypeMember TimeZoneDataType_members[2] = { +{ + UA_TYPENAME("Offset") /* .memberName */ + &UA_TYPES[UA_TYPES_INT16], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DaylightSavingInOffset") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_TimeZoneDataType, daylightSavingInOffset) - offsetof(UA_TimeZoneDataType, offset) - sizeof(UA_Int16), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ApplicationType */ +#define ApplicationType_members NULL + +/* ApplicationDescription */ +static UA_DataTypeMember ApplicationDescription_members[7] = { +{ + UA_TYPENAME("ApplicationUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ProductUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_ApplicationDescription, productUri) - offsetof(UA_ApplicationDescription, applicationUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ApplicationName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ApplicationDescription, applicationName) - offsetof(UA_ApplicationDescription, productUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ApplicationType") /* .memberName */ + &UA_TYPES[UA_TYPES_APPLICATIONTYPE], /* .memberType */ + offsetof(UA_ApplicationDescription, applicationType) - offsetof(UA_ApplicationDescription, applicationName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("GatewayServerUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_ApplicationDescription, gatewayServerUri) - offsetof(UA_ApplicationDescription, applicationType) - sizeof(UA_ApplicationType), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiscoveryProfileUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_ApplicationDescription, discoveryProfileUri) - offsetof(UA_ApplicationDescription, gatewayServerUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiscoveryUrls") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_ApplicationDescription, discoveryUrlsSize) - offsetof(UA_ApplicationDescription, discoveryProfileUri) - sizeof(UA_String), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* RequestHeader */ +static UA_DataTypeMember RequestHeader_members[7] = { +{ + UA_TYPENAME("AuthenticationToken") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Timestamp") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + offsetof(UA_RequestHeader, timestamp) - offsetof(UA_RequestHeader, authenticationToken) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestHandle") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_RequestHeader, requestHandle) - offsetof(UA_RequestHeader, timestamp) - sizeof(UA_DateTime), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReturnDiagnostics") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_RequestHeader, returnDiagnostics) - offsetof(UA_RequestHeader, requestHandle) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AuditEntryId") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_RequestHeader, auditEntryId) - offsetof(UA_RequestHeader, returnDiagnostics) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TimeoutHint") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_RequestHeader, timeoutHint) - offsetof(UA_RequestHeader, auditEntryId) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AdditionalHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_RequestHeader, additionalHeader) - offsetof(UA_RequestHeader, timeoutHint) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ResponseHeader */ +static UA_DataTypeMember ResponseHeader_members[6] = { +{ + UA_TYPENAME("Timestamp") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestHandle") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ResponseHeader, requestHandle) - offsetof(UA_ResponseHeader, timestamp) - sizeof(UA_DateTime), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServiceResult") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_ResponseHeader, serviceResult) - offsetof(UA_ResponseHeader, requestHandle) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServiceDiagnostics") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_ResponseHeader, serviceDiagnostics) - offsetof(UA_ResponseHeader, serviceResult) - sizeof(UA_StatusCode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("StringTable") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_ResponseHeader, stringTableSize) - offsetof(UA_ResponseHeader, serviceDiagnostics) - sizeof(UA_DiagnosticInfo), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AdditionalHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_ResponseHeader, additionalHeader) - offsetof(UA_ResponseHeader, stringTable) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ServiceFault */ +static UA_DataTypeMember ServiceFault_members[1] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* FindServersRequest */ +static UA_DataTypeMember FindServersRequest_members[4] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EndpointUrl") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_FindServersRequest, endpointUrl) - offsetof(UA_FindServersRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("LocaleIds") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_FindServersRequest, localeIdsSize) - offsetof(UA_FindServersRequest, endpointUrl) - sizeof(UA_String), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerUris") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_FindServersRequest, serverUrisSize) - offsetof(UA_FindServersRequest, localeIds) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* FindServersResponse */ +static UA_DataTypeMember FindServersResponse_members[2] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Servers") /* .memberName */ + &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION], /* .memberType */ + offsetof(UA_FindServersResponse, serversSize) - offsetof(UA_FindServersResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* MessageSecurityMode */ +#define MessageSecurityMode_members NULL + +/* UserTokenType */ +#define UserTokenType_members NULL + +/* UserTokenPolicy */ +static UA_DataTypeMember UserTokenPolicy_members[5] = { +{ + UA_TYPENAME("PolicyId") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TokenType") /* .memberName */ + &UA_TYPES[UA_TYPES_USERTOKENTYPE], /* .memberType */ + offsetof(UA_UserTokenPolicy, tokenType) - offsetof(UA_UserTokenPolicy, policyId) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IssuedTokenType") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_UserTokenPolicy, issuedTokenType) - offsetof(UA_UserTokenPolicy, tokenType) - sizeof(UA_UserTokenType), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IssuerEndpointUrl") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_UserTokenPolicy, issuerEndpointUrl) - offsetof(UA_UserTokenPolicy, issuedTokenType) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityPolicyUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_UserTokenPolicy, securityPolicyUri) - offsetof(UA_UserTokenPolicy, issuerEndpointUrl) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EndpointDescription */ +static UA_DataTypeMember EndpointDescription_members[8] = { +{ + UA_TYPENAME("EndpointUrl") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Server") /* .memberName */ + &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION], /* .memberType */ + offsetof(UA_EndpointDescription, server) - offsetof(UA_EndpointDescription, endpointUrl) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerCertificate") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_EndpointDescription, serverCertificate) - offsetof(UA_EndpointDescription, server) - sizeof(UA_ApplicationDescription), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityMode") /* .memberName */ + &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE], /* .memberType */ + offsetof(UA_EndpointDescription, securityMode) - offsetof(UA_EndpointDescription, serverCertificate) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityPolicyUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_EndpointDescription, securityPolicyUri) - offsetof(UA_EndpointDescription, securityMode) - sizeof(UA_MessageSecurityMode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserIdentityTokens") /* .memberName */ + &UA_TYPES[UA_TYPES_USERTOKENPOLICY], /* .memberType */ + offsetof(UA_EndpointDescription, userIdentityTokensSize) - offsetof(UA_EndpointDescription, securityPolicyUri) - sizeof(UA_String), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TransportProfileUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_EndpointDescription, transportProfileUri) - offsetof(UA_EndpointDescription, userIdentityTokens) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityLevel") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_EndpointDescription, securityLevel) - offsetof(UA_EndpointDescription, transportProfileUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* GetEndpointsRequest */ +static UA_DataTypeMember GetEndpointsRequest_members[4] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EndpointUrl") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_GetEndpointsRequest, endpointUrl) - offsetof(UA_GetEndpointsRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("LocaleIds") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_GetEndpointsRequest, localeIdsSize) - offsetof(UA_GetEndpointsRequest, endpointUrl) - sizeof(UA_String), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ProfileUris") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_GetEndpointsRequest, profileUrisSize) - offsetof(UA_GetEndpointsRequest, localeIds) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* GetEndpointsResponse */ +static UA_DataTypeMember GetEndpointsResponse_members[2] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Endpoints") /* .memberName */ + &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION], /* .memberType */ + offsetof(UA_GetEndpointsResponse, endpointsSize) - offsetof(UA_GetEndpointsResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* SecurityTokenRequestType */ +#define SecurityTokenRequestType_members NULL + +/* ChannelSecurityToken */ +static UA_DataTypeMember ChannelSecurityToken_members[4] = { +{ + UA_TYPENAME("ChannelId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TokenId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ChannelSecurityToken, tokenId) - offsetof(UA_ChannelSecurityToken, channelId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("CreatedAt") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + offsetof(UA_ChannelSecurityToken, createdAt) - offsetof(UA_ChannelSecurityToken, tokenId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedLifetime") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ChannelSecurityToken, revisedLifetime) - offsetof(UA_ChannelSecurityToken, createdAt) - sizeof(UA_DateTime), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* OpenSecureChannelRequest */ +static UA_DataTypeMember OpenSecureChannelRequest_members[6] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ClientProtocolVersion") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_OpenSecureChannelRequest, clientProtocolVersion) - offsetof(UA_OpenSecureChannelRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestType") /* .memberName */ + &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE], /* .memberType */ + offsetof(UA_OpenSecureChannelRequest, requestType) - offsetof(UA_OpenSecureChannelRequest, clientProtocolVersion) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityMode") /* .memberName */ + &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE], /* .memberType */ + offsetof(UA_OpenSecureChannelRequest, securityMode) - offsetof(UA_OpenSecureChannelRequest, requestType) - sizeof(UA_SecurityTokenRequestType), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ClientNonce") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_OpenSecureChannelRequest, clientNonce) - offsetof(UA_OpenSecureChannelRequest, securityMode) - sizeof(UA_MessageSecurityMode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedLifetime") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_OpenSecureChannelRequest, requestedLifetime) - offsetof(UA_OpenSecureChannelRequest, clientNonce) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* OpenSecureChannelResponse */ +static UA_DataTypeMember OpenSecureChannelResponse_members[4] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerProtocolVersion") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_OpenSecureChannelResponse, serverProtocolVersion) - offsetof(UA_OpenSecureChannelResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityToken") /* .memberName */ + &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN], /* .memberType */ + offsetof(UA_OpenSecureChannelResponse, securityToken) - offsetof(UA_OpenSecureChannelResponse, serverProtocolVersion) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerNonce") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_OpenSecureChannelResponse, serverNonce) - offsetof(UA_OpenSecureChannelResponse, securityToken) - sizeof(UA_ChannelSecurityToken), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* CloseSecureChannelRequest */ +static UA_DataTypeMember CloseSecureChannelRequest_members[1] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* CloseSecureChannelResponse */ +static UA_DataTypeMember CloseSecureChannelResponse_members[1] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* SignedSoftwareCertificate */ +static UA_DataTypeMember SignedSoftwareCertificate_members[2] = { +{ + UA_TYPENAME("CertificateData") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Signature") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_SignedSoftwareCertificate, signature) - offsetof(UA_SignedSoftwareCertificate, certificateData) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* SignatureData */ +static UA_DataTypeMember SignatureData_members[2] = { +{ + UA_TYPENAME("Algorithm") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Signature") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_SignatureData, signature) - offsetof(UA_SignatureData, algorithm) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* CreateSessionRequest */ +static UA_DataTypeMember CreateSessionRequest_members[9] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ClientDescription") /* .memberName */ + &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION], /* .memberType */ + offsetof(UA_CreateSessionRequest, clientDescription) - offsetof(UA_CreateSessionRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_CreateSessionRequest, serverUri) - offsetof(UA_CreateSessionRequest, clientDescription) - sizeof(UA_ApplicationDescription), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EndpointUrl") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_CreateSessionRequest, endpointUrl) - offsetof(UA_CreateSessionRequest, serverUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SessionName") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_CreateSessionRequest, sessionName) - offsetof(UA_CreateSessionRequest, endpointUrl) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ClientNonce") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_CreateSessionRequest, clientNonce) - offsetof(UA_CreateSessionRequest, sessionName) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ClientCertificate") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_CreateSessionRequest, clientCertificate) - offsetof(UA_CreateSessionRequest, clientNonce) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedSessionTimeout") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_CreateSessionRequest, requestedSessionTimeout) - offsetof(UA_CreateSessionRequest, clientCertificate) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxResponseMessageSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSessionRequest, maxResponseMessageSize) - offsetof(UA_CreateSessionRequest, requestedSessionTimeout) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* CreateSessionResponse */ +static UA_DataTypeMember CreateSessionResponse_members[10] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SessionId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_CreateSessionResponse, sessionId) - offsetof(UA_CreateSessionResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AuthenticationToken") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_CreateSessionResponse, authenticationToken) - offsetof(UA_CreateSessionResponse, sessionId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedSessionTimeout") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_CreateSessionResponse, revisedSessionTimeout) - offsetof(UA_CreateSessionResponse, authenticationToken) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerNonce") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_CreateSessionResponse, serverNonce) - offsetof(UA_CreateSessionResponse, revisedSessionTimeout) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerCertificate") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_CreateSessionResponse, serverCertificate) - offsetof(UA_CreateSessionResponse, serverNonce) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerEndpoints") /* .memberName */ + &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION], /* .memberType */ + offsetof(UA_CreateSessionResponse, serverEndpointsSize) - offsetof(UA_CreateSessionResponse, serverCertificate) - sizeof(UA_ByteString), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerSoftwareCertificates") /* .memberName */ + &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE], /* .memberType */ + offsetof(UA_CreateSessionResponse, serverSoftwareCertificatesSize) - offsetof(UA_CreateSessionResponse, serverEndpoints) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerSignature") /* .memberName */ + &UA_TYPES[UA_TYPES_SIGNATUREDATA], /* .memberType */ + offsetof(UA_CreateSessionResponse, serverSignature) - offsetof(UA_CreateSessionResponse, serverSoftwareCertificates) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxRequestMessageSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSessionResponse, maxRequestMessageSize) - offsetof(UA_CreateSessionResponse, serverSignature) - sizeof(UA_SignatureData), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* UserIdentityToken */ +static UA_DataTypeMember UserIdentityToken_members[1] = { +{ + UA_TYPENAME("PolicyId") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AnonymousIdentityToken */ +static UA_DataTypeMember AnonymousIdentityToken_members[1] = { +{ + UA_TYPENAME("PolicyId") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* UserNameIdentityToken */ +static UA_DataTypeMember UserNameIdentityToken_members[4] = { +{ + UA_TYPENAME("PolicyId") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserName") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_UserNameIdentityToken, userName) - offsetof(UA_UserNameIdentityToken, policyId) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Password") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_UserNameIdentityToken, password) - offsetof(UA_UserNameIdentityToken, userName) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EncryptionAlgorithm") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_UserNameIdentityToken, encryptionAlgorithm) - offsetof(UA_UserNameIdentityToken, password) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* X509IdentityToken */ +static UA_DataTypeMember X509IdentityToken_members[2] = { +{ + UA_TYPENAME("PolicyId") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("CertificateData") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_X509IdentityToken, certificateData) - offsetof(UA_X509IdentityToken, policyId) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* IssuedIdentityToken */ +static UA_DataTypeMember IssuedIdentityToken_members[3] = { +{ + UA_TYPENAME("PolicyId") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TokenData") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_IssuedIdentityToken, tokenData) - offsetof(UA_IssuedIdentityToken, policyId) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EncryptionAlgorithm") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_IssuedIdentityToken, encryptionAlgorithm) - offsetof(UA_IssuedIdentityToken, tokenData) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ActivateSessionRequest */ +static UA_DataTypeMember ActivateSessionRequest_members[6] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ClientSignature") /* .memberName */ + &UA_TYPES[UA_TYPES_SIGNATUREDATA], /* .memberType */ + offsetof(UA_ActivateSessionRequest, clientSignature) - offsetof(UA_ActivateSessionRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ClientSoftwareCertificates") /* .memberName */ + &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE], /* .memberType */ + offsetof(UA_ActivateSessionRequest, clientSoftwareCertificatesSize) - offsetof(UA_ActivateSessionRequest, clientSignature) - sizeof(UA_SignatureData), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("LocaleIds") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_ActivateSessionRequest, localeIdsSize) - offsetof(UA_ActivateSessionRequest, clientSoftwareCertificates) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserIdentityToken") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_ActivateSessionRequest, userIdentityToken) - offsetof(UA_ActivateSessionRequest, localeIds) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserTokenSignature") /* .memberName */ + &UA_TYPES[UA_TYPES_SIGNATUREDATA], /* .memberType */ + offsetof(UA_ActivateSessionRequest, userTokenSignature) - offsetof(UA_ActivateSessionRequest, userIdentityToken) - sizeof(UA_ExtensionObject), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ActivateSessionResponse */ +static UA_DataTypeMember ActivateSessionResponse_members[4] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ServerNonce") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_ActivateSessionResponse, serverNonce) - offsetof(UA_ActivateSessionResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_ActivateSessionResponse, resultsSize) - offsetof(UA_ActivateSessionResponse, serverNonce) - sizeof(UA_ByteString), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_ActivateSessionResponse, diagnosticInfosSize) - offsetof(UA_ActivateSessionResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* CloseSessionRequest */ +static UA_DataTypeMember CloseSessionRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DeleteSubscriptions") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_CloseSessionRequest, deleteSubscriptions) - offsetof(UA_CloseSessionRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* CloseSessionResponse */ +static UA_DataTypeMember CloseSessionResponse_members[1] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* NodeAttributesMask */ +#define NodeAttributesMask_members NULL + +/* NodeAttributes */ +static UA_DataTypeMember NodeAttributes_members[5] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_NodeAttributes, displayName) - offsetof(UA_NodeAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_NodeAttributes, description) - offsetof(UA_NodeAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_NodeAttributes, writeMask) - offsetof(UA_NodeAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_NodeAttributes, userWriteMask) - offsetof(UA_NodeAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ObjectAttributes */ +static UA_DataTypeMember ObjectAttributes_members[6] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ObjectAttributes, displayName) - offsetof(UA_ObjectAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ObjectAttributes, description) - offsetof(UA_ObjectAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ObjectAttributes, writeMask) - offsetof(UA_ObjectAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ObjectAttributes, userWriteMask) - offsetof(UA_ObjectAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EventNotifier") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_ObjectAttributes, eventNotifier) - offsetof(UA_ObjectAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* VariableAttributes */ +static UA_DataTypeMember VariableAttributes_members[13] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_VariableAttributes, displayName) - offsetof(UA_VariableAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_VariableAttributes, description) - offsetof(UA_VariableAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_VariableAttributes, writeMask) - offsetof(UA_VariableAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_VariableAttributes, userWriteMask) - offsetof(UA_VariableAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_VARIANT], /* .memberType */ + offsetof(UA_VariableAttributes, value) - offsetof(UA_VariableAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DataType") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_VariableAttributes, dataType) - offsetof(UA_VariableAttributes, value) - sizeof(UA_Variant), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ValueRank") /* .memberName */ + &UA_TYPES[UA_TYPES_INT32], /* .memberType */ + offsetof(UA_VariableAttributes, valueRank) - offsetof(UA_VariableAttributes, dataType) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ArrayDimensions") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_VariableAttributes, arrayDimensionsSize) - offsetof(UA_VariableAttributes, valueRank) - sizeof(UA_Int32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AccessLevel") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_VariableAttributes, accessLevel) - offsetof(UA_VariableAttributes, arrayDimensions) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserAccessLevel") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_VariableAttributes, userAccessLevel) - offsetof(UA_VariableAttributes, accessLevel) - sizeof(UA_Byte), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MinimumSamplingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_VariableAttributes, minimumSamplingInterval) - offsetof(UA_VariableAttributes, userAccessLevel) - sizeof(UA_Byte), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Historizing") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_VariableAttributes, historizing) - offsetof(UA_VariableAttributes, minimumSamplingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* MethodAttributes */ +static UA_DataTypeMember MethodAttributes_members[7] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_MethodAttributes, displayName) - offsetof(UA_MethodAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_MethodAttributes, description) - offsetof(UA_MethodAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_MethodAttributes, writeMask) - offsetof(UA_MethodAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_MethodAttributes, userWriteMask) - offsetof(UA_MethodAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Executable") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_MethodAttributes, executable) - offsetof(UA_MethodAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserExecutable") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_MethodAttributes, userExecutable) - offsetof(UA_MethodAttributes, executable) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ObjectTypeAttributes */ +static UA_DataTypeMember ObjectTypeAttributes_members[6] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ObjectTypeAttributes, displayName) - offsetof(UA_ObjectTypeAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ObjectTypeAttributes, description) - offsetof(UA_ObjectTypeAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ObjectTypeAttributes, writeMask) - offsetof(UA_ObjectTypeAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ObjectTypeAttributes, userWriteMask) - offsetof(UA_ObjectTypeAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsAbstract") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_ObjectTypeAttributes, isAbstract) - offsetof(UA_ObjectTypeAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* VariableTypeAttributes */ +static UA_DataTypeMember VariableTypeAttributes_members[10] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_VariableTypeAttributes, displayName) - offsetof(UA_VariableTypeAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_VariableTypeAttributes, description) - offsetof(UA_VariableTypeAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_VariableTypeAttributes, writeMask) - offsetof(UA_VariableTypeAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_VariableTypeAttributes, userWriteMask) - offsetof(UA_VariableTypeAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_VARIANT], /* .memberType */ + offsetof(UA_VariableTypeAttributes, value) - offsetof(UA_VariableTypeAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DataType") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_VariableTypeAttributes, dataType) - offsetof(UA_VariableTypeAttributes, value) - sizeof(UA_Variant), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ValueRank") /* .memberName */ + &UA_TYPES[UA_TYPES_INT32], /* .memberType */ + offsetof(UA_VariableTypeAttributes, valueRank) - offsetof(UA_VariableTypeAttributes, dataType) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ArrayDimensions") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_VariableTypeAttributes, arrayDimensionsSize) - offsetof(UA_VariableTypeAttributes, valueRank) - sizeof(UA_Int32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsAbstract") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_VariableTypeAttributes, isAbstract) - offsetof(UA_VariableTypeAttributes, arrayDimensions) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ReferenceTypeAttributes */ +static UA_DataTypeMember ReferenceTypeAttributes_members[8] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ReferenceTypeAttributes, displayName) - offsetof(UA_ReferenceTypeAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ReferenceTypeAttributes, description) - offsetof(UA_ReferenceTypeAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ReferenceTypeAttributes, writeMask) - offsetof(UA_ReferenceTypeAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ReferenceTypeAttributes, userWriteMask) - offsetof(UA_ReferenceTypeAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsAbstract") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_ReferenceTypeAttributes, isAbstract) - offsetof(UA_ReferenceTypeAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Symmetric") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_ReferenceTypeAttributes, symmetric) - offsetof(UA_ReferenceTypeAttributes, isAbstract) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("InverseName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ReferenceTypeAttributes, inverseName) - offsetof(UA_ReferenceTypeAttributes, symmetric) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* DataTypeAttributes */ +static UA_DataTypeMember DataTypeAttributes_members[6] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_DataTypeAttributes, displayName) - offsetof(UA_DataTypeAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_DataTypeAttributes, description) - offsetof(UA_DataTypeAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_DataTypeAttributes, writeMask) - offsetof(UA_DataTypeAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_DataTypeAttributes, userWriteMask) - offsetof(UA_DataTypeAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsAbstract") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_DataTypeAttributes, isAbstract) - offsetof(UA_DataTypeAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ViewAttributes */ +static UA_DataTypeMember ViewAttributes_members[7] = { +{ + UA_TYPENAME("SpecifiedAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ViewAttributes, displayName) - offsetof(UA_ViewAttributes, specifiedAttributes) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ViewAttributes, description) - offsetof(UA_ViewAttributes, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ViewAttributes, writeMask) - offsetof(UA_ViewAttributes, description) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UserWriteMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ViewAttributes, userWriteMask) - offsetof(UA_ViewAttributes, writeMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ContainsNoLoops") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_ViewAttributes, containsNoLoops) - offsetof(UA_ViewAttributes, userWriteMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EventNotifier") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_ViewAttributes, eventNotifier) - offsetof(UA_ViewAttributes, containsNoLoops) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AddNodesItem */ +static UA_DataTypeMember AddNodesItem_members[7] = { +{ + UA_TYPENAME("ParentNodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReferenceTypeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_AddNodesItem, referenceTypeId) - offsetof(UA_AddNodesItem, parentNodeId) - sizeof(UA_ExpandedNodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedNewNodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + offsetof(UA_AddNodesItem, requestedNewNodeId) - offsetof(UA_AddNodesItem, referenceTypeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BrowseName") /* .memberName */ + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], /* .memberType */ + offsetof(UA_AddNodesItem, browseName) - offsetof(UA_AddNodesItem, requestedNewNodeId) - sizeof(UA_ExpandedNodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodeClass") /* .memberName */ + &UA_TYPES[UA_TYPES_NODECLASS], /* .memberType */ + offsetof(UA_AddNodesItem, nodeClass) - offsetof(UA_AddNodesItem, browseName) - sizeof(UA_QualifiedName), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodeAttributes") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_AddNodesItem, nodeAttributes) - offsetof(UA_AddNodesItem, nodeClass) - sizeof(UA_NodeClass), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TypeDefinition") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + offsetof(UA_AddNodesItem, typeDefinition) - offsetof(UA_AddNodesItem, nodeAttributes) - sizeof(UA_ExtensionObject), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AddNodesResult */ +static UA_DataTypeMember AddNodesResult_members[2] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AddedNodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_AddNodesResult, addedNodeId) - offsetof(UA_AddNodesResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AddNodesRequest */ +static UA_DataTypeMember AddNodesRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodesToAdd") /* .memberName */ + &UA_TYPES[UA_TYPES_ADDNODESITEM], /* .memberType */ + offsetof(UA_AddNodesRequest, nodesToAddSize) - offsetof(UA_AddNodesRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* AddNodesResponse */ +static UA_DataTypeMember AddNodesResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_ADDNODESRESULT], /* .memberType */ + offsetof(UA_AddNodesResponse, resultsSize) - offsetof(UA_AddNodesResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_AddNodesResponse, diagnosticInfosSize) - offsetof(UA_AddNodesResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* AddReferencesItem */ +static UA_DataTypeMember AddReferencesItem_members[6] = { +{ + UA_TYPENAME("SourceNodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReferenceTypeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_AddReferencesItem, referenceTypeId) - offsetof(UA_AddReferencesItem, sourceNodeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsForward") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_AddReferencesItem, isForward) - offsetof(UA_AddReferencesItem, referenceTypeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TargetServerUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_AddReferencesItem, targetServerUri) - offsetof(UA_AddReferencesItem, isForward) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TargetNodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + offsetof(UA_AddReferencesItem, targetNodeId) - offsetof(UA_AddReferencesItem, targetServerUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TargetNodeClass") /* .memberName */ + &UA_TYPES[UA_TYPES_NODECLASS], /* .memberType */ + offsetof(UA_AddReferencesItem, targetNodeClass) - offsetof(UA_AddReferencesItem, targetNodeId) - sizeof(UA_ExpandedNodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AddReferencesRequest */ +static UA_DataTypeMember AddReferencesRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReferencesToAdd") /* .memberName */ + &UA_TYPES[UA_TYPES_ADDREFERENCESITEM], /* .memberType */ + offsetof(UA_AddReferencesRequest, referencesToAddSize) - offsetof(UA_AddReferencesRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* AddReferencesResponse */ +static UA_DataTypeMember AddReferencesResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_AddReferencesResponse, resultsSize) - offsetof(UA_AddReferencesResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_AddReferencesResponse, diagnosticInfosSize) - offsetof(UA_AddReferencesResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteNodesItem */ +static UA_DataTypeMember DeleteNodesItem_members[2] = { +{ + UA_TYPENAME("NodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DeleteTargetReferences") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_DeleteNodesItem, deleteTargetReferences) - offsetof(UA_DeleteNodesItem, nodeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteNodesRequest */ +static UA_DataTypeMember DeleteNodesRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodesToDelete") /* .memberName */ + &UA_TYPES[UA_TYPES_DELETENODESITEM], /* .memberType */ + offsetof(UA_DeleteNodesRequest, nodesToDeleteSize) - offsetof(UA_DeleteNodesRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteNodesResponse */ +static UA_DataTypeMember DeleteNodesResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_DeleteNodesResponse, resultsSize) - offsetof(UA_DeleteNodesResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_DeleteNodesResponse, diagnosticInfosSize) - offsetof(UA_DeleteNodesResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteReferencesItem */ +static UA_DataTypeMember DeleteReferencesItem_members[5] = { +{ + UA_TYPENAME("SourceNodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReferenceTypeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_DeleteReferencesItem, referenceTypeId) - offsetof(UA_DeleteReferencesItem, sourceNodeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsForward") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_DeleteReferencesItem, isForward) - offsetof(UA_DeleteReferencesItem, referenceTypeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TargetNodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + offsetof(UA_DeleteReferencesItem, targetNodeId) - offsetof(UA_DeleteReferencesItem, isForward) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DeleteBidirectional") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_DeleteReferencesItem, deleteBidirectional) - offsetof(UA_DeleteReferencesItem, targetNodeId) - sizeof(UA_ExpandedNodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteReferencesRequest */ +static UA_DataTypeMember DeleteReferencesRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReferencesToDelete") /* .memberName */ + &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM], /* .memberType */ + offsetof(UA_DeleteReferencesRequest, referencesToDeleteSize) - offsetof(UA_DeleteReferencesRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteReferencesResponse */ +static UA_DataTypeMember DeleteReferencesResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_DeleteReferencesResponse, resultsSize) - offsetof(UA_DeleteReferencesResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_DeleteReferencesResponse, diagnosticInfosSize) - offsetof(UA_DeleteReferencesResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseDirection */ +#define BrowseDirection_members NULL + +/* ViewDescription */ +static UA_DataTypeMember ViewDescription_members[3] = { +{ + UA_TYPENAME("ViewId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Timestamp") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + offsetof(UA_ViewDescription, timestamp) - offsetof(UA_ViewDescription, viewId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ViewVersion") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ViewDescription, viewVersion) - offsetof(UA_ViewDescription, timestamp) - sizeof(UA_DateTime), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseDescription */ +static UA_DataTypeMember BrowseDescription_members[6] = { +{ + UA_TYPENAME("NodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BrowseDirection") /* .memberName */ + &UA_TYPES[UA_TYPES_BROWSEDIRECTION], /* .memberType */ + offsetof(UA_BrowseDescription, browseDirection) - offsetof(UA_BrowseDescription, nodeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReferenceTypeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_BrowseDescription, referenceTypeId) - offsetof(UA_BrowseDescription, browseDirection) - sizeof(UA_BrowseDirection), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IncludeSubtypes") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_BrowseDescription, includeSubtypes) - offsetof(UA_BrowseDescription, referenceTypeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodeClassMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_BrowseDescription, nodeClassMask) - offsetof(UA_BrowseDescription, includeSubtypes) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ResultMask") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_BrowseDescription, resultMask) - offsetof(UA_BrowseDescription, nodeClassMask) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseResultMask */ +#define BrowseResultMask_members NULL + +/* ReferenceDescription */ +static UA_DataTypeMember ReferenceDescription_members[7] = { +{ + UA_TYPENAME("ReferenceTypeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsForward") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_ReferenceDescription, isForward) - offsetof(UA_ReferenceDescription, referenceTypeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + offsetof(UA_ReferenceDescription, nodeId) - offsetof(UA_ReferenceDescription, isForward) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BrowseName") /* .memberName */ + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], /* .memberType */ + offsetof(UA_ReferenceDescription, browseName) - offsetof(UA_ReferenceDescription, nodeId) - sizeof(UA_ExpandedNodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ReferenceDescription, displayName) - offsetof(UA_ReferenceDescription, browseName) - sizeof(UA_QualifiedName), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodeClass") /* .memberName */ + &UA_TYPES[UA_TYPES_NODECLASS], /* .memberType */ + offsetof(UA_ReferenceDescription, nodeClass) - offsetof(UA_ReferenceDescription, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TypeDefinition") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + offsetof(UA_ReferenceDescription, typeDefinition) - offsetof(UA_ReferenceDescription, nodeClass) - sizeof(UA_NodeClass), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseResult */ +static UA_DataTypeMember BrowseResult_members[3] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ContinuationPoint") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_BrowseResult, continuationPoint) - offsetof(UA_BrowseResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("References") /* .memberName */ + &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION], /* .memberType */ + offsetof(UA_BrowseResult, referencesSize) - offsetof(UA_BrowseResult, continuationPoint) - sizeof(UA_ByteString), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseRequest */ +static UA_DataTypeMember BrowseRequest_members[4] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("View") /* .memberName */ + &UA_TYPES[UA_TYPES_VIEWDESCRIPTION], /* .memberType */ + offsetof(UA_BrowseRequest, view) - offsetof(UA_BrowseRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedMaxReferencesPerNode") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_BrowseRequest, requestedMaxReferencesPerNode) - offsetof(UA_BrowseRequest, view) - sizeof(UA_ViewDescription), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodesToBrowse") /* .memberName */ + &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION], /* .memberType */ + offsetof(UA_BrowseRequest, nodesToBrowseSize) - offsetof(UA_BrowseRequest, requestedMaxReferencesPerNode) - sizeof(UA_UInt32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseResponse */ +static UA_DataTypeMember BrowseResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_BROWSERESULT], /* .memberType */ + offsetof(UA_BrowseResponse, resultsSize) - offsetof(UA_BrowseResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_BrowseResponse, diagnosticInfosSize) - offsetof(UA_BrowseResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseNextRequest */ +static UA_DataTypeMember BrowseNextRequest_members[3] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReleaseContinuationPoints") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_BrowseNextRequest, releaseContinuationPoints) - offsetof(UA_BrowseNextRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ContinuationPoints") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_BrowseNextRequest, continuationPointsSize) - offsetof(UA_BrowseNextRequest, releaseContinuationPoints) - sizeof(UA_Boolean), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowseNextResponse */ +static UA_DataTypeMember BrowseNextResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_BROWSERESULT], /* .memberType */ + offsetof(UA_BrowseNextResponse, resultsSize) - offsetof(UA_BrowseNextResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_BrowseNextResponse, diagnosticInfosSize) - offsetof(UA_BrowseNextResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* RelativePathElement */ +static UA_DataTypeMember RelativePathElement_members[4] = { +{ + UA_TYPENAME("ReferenceTypeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IsInverse") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_RelativePathElement, isInverse) - offsetof(UA_RelativePathElement, referenceTypeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IncludeSubtypes") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_RelativePathElement, includeSubtypes) - offsetof(UA_RelativePathElement, isInverse) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TargetName") /* .memberName */ + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], /* .memberType */ + offsetof(UA_RelativePathElement, targetName) - offsetof(UA_RelativePathElement, includeSubtypes) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* RelativePath */ +static UA_DataTypeMember RelativePath_members[1] = { +{ + UA_TYPENAME("Elements") /* .memberName */ + &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowsePath */ +static UA_DataTypeMember BrowsePath_members[2] = { +{ + UA_TYPENAME("StartingNode") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RelativePath") /* .memberName */ + &UA_TYPES[UA_TYPES_RELATIVEPATH], /* .memberType */ + offsetof(UA_BrowsePath, relativePath) - offsetof(UA_BrowsePath, startingNode) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowsePathTarget */ +static UA_DataTypeMember BrowsePathTarget_members[2] = { +{ + UA_TYPENAME("TargetId") /* .memberName */ + &UA_TYPES[UA_TYPES_EXPANDEDNODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RemainingPathIndex") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_BrowsePathTarget, remainingPathIndex) - offsetof(UA_BrowsePathTarget, targetId) - sizeof(UA_ExpandedNodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* BrowsePathResult */ +static UA_DataTypeMember BrowsePathResult_members[2] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Targets") /* .memberName */ + &UA_TYPES[UA_TYPES_BROWSEPATHTARGET], /* .memberType */ + offsetof(UA_BrowsePathResult, targetsSize) - offsetof(UA_BrowsePathResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* TranslateBrowsePathsToNodeIdsRequest */ +static UA_DataTypeMember TranslateBrowsePathsToNodeIdsRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BrowsePaths") /* .memberName */ + &UA_TYPES[UA_TYPES_BROWSEPATH], /* .memberType */ + offsetof(UA_TranslateBrowsePathsToNodeIdsRequest, browsePathsSize) - offsetof(UA_TranslateBrowsePathsToNodeIdsRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* TranslateBrowsePathsToNodeIdsResponse */ +static UA_DataTypeMember TranslateBrowsePathsToNodeIdsResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_BROWSEPATHRESULT], /* .memberType */ + offsetof(UA_TranslateBrowsePathsToNodeIdsResponse, resultsSize) - offsetof(UA_TranslateBrowsePathsToNodeIdsResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_TranslateBrowsePathsToNodeIdsResponse, diagnosticInfosSize) - offsetof(UA_TranslateBrowsePathsToNodeIdsResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* RegisterNodesRequest */ +static UA_DataTypeMember RegisterNodesRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodesToRegister") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_RegisterNodesRequest, nodesToRegisterSize) - offsetof(UA_RegisterNodesRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* RegisterNodesResponse */ +static UA_DataTypeMember RegisterNodesResponse_members[2] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RegisteredNodeIds") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_RegisterNodesResponse, registeredNodeIdsSize) - offsetof(UA_RegisterNodesResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* UnregisterNodesRequest */ +static UA_DataTypeMember UnregisterNodesRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodesToUnregister") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_UnregisterNodesRequest, nodesToUnregisterSize) - offsetof(UA_UnregisterNodesRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* UnregisterNodesResponse */ +static UA_DataTypeMember UnregisterNodesResponse_members[1] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* FilterOperator */ +#define FilterOperator_members NULL + +/* ContentFilterElement */ +static UA_DataTypeMember ContentFilterElement_members[2] = { +{ + UA_TYPENAME("FilterOperator") /* .memberName */ + &UA_TYPES[UA_TYPES_FILTEROPERATOR], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("FilterOperands") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_ContentFilterElement, filterOperandsSize) - offsetof(UA_ContentFilterElement, filterOperator) - sizeof(UA_FilterOperator), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* ContentFilter */ +static UA_DataTypeMember ContentFilter_members[1] = { +{ + UA_TYPENAME("Elements") /* .memberName */ + &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* ElementOperand */ +static UA_DataTypeMember ElementOperand_members[1] = { +{ + UA_TYPENAME("Index") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* LiteralOperand */ +static UA_DataTypeMember LiteralOperand_members[1] = { +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_VARIANT], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AttributeOperand */ +static UA_DataTypeMember AttributeOperand_members[5] = { +{ + UA_TYPENAME("NodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Alias") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_AttributeOperand, alias) - offsetof(UA_AttributeOperand, nodeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BrowsePath") /* .memberName */ + &UA_TYPES[UA_TYPES_RELATIVEPATH], /* .memberType */ + offsetof(UA_AttributeOperand, browsePath) - offsetof(UA_AttributeOperand, alias) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AttributeId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_AttributeOperand, attributeId) - offsetof(UA_AttributeOperand, browsePath) - sizeof(UA_RelativePath), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IndexRange") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_AttributeOperand, indexRange) - offsetof(UA_AttributeOperand, attributeId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* SimpleAttributeOperand */ +static UA_DataTypeMember SimpleAttributeOperand_members[4] = { +{ + UA_TYPENAME("TypeDefinitionId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BrowsePath") /* .memberName */ + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], /* .memberType */ + offsetof(UA_SimpleAttributeOperand, browsePathSize) - offsetof(UA_SimpleAttributeOperand, typeDefinitionId) - sizeof(UA_NodeId), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AttributeId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SimpleAttributeOperand, attributeId) - offsetof(UA_SimpleAttributeOperand, browsePath) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IndexRange") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_SimpleAttributeOperand, indexRange) - offsetof(UA_SimpleAttributeOperand, attributeId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ContentFilterElementResult */ +static UA_DataTypeMember ContentFilterElementResult_members[3] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("OperandStatusCodes") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_ContentFilterElementResult, operandStatusCodesSize) - offsetof(UA_ContentFilterElementResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("OperandDiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_ContentFilterElementResult, operandDiagnosticInfosSize) - offsetof(UA_ContentFilterElementResult, operandStatusCodes) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* ContentFilterResult */ +static UA_DataTypeMember ContentFilterResult_members[2] = { +{ + UA_TYPENAME("ElementResults") /* .memberName */ + &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ElementDiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_ContentFilterResult, elementDiagnosticInfosSize) - offsetof(UA_ContentFilterResult, elementResults) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* TimestampsToReturn */ +#define TimestampsToReturn_members NULL + +/* ReadValueId */ +static UA_DataTypeMember ReadValueId_members[4] = { +{ + UA_TYPENAME("NodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AttributeId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ReadValueId, attributeId) - offsetof(UA_ReadValueId, nodeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IndexRange") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_ReadValueId, indexRange) - offsetof(UA_ReadValueId, attributeId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DataEncoding") /* .memberName */ + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], /* .memberType */ + offsetof(UA_ReadValueId, dataEncoding) - offsetof(UA_ReadValueId, indexRange) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ReadRequest */ +static UA_DataTypeMember ReadRequest_members[4] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxAge") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_ReadRequest, maxAge) - offsetof(UA_ReadRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TimestampsToReturn") /* .memberName */ + &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN], /* .memberType */ + offsetof(UA_ReadRequest, timestampsToReturn) - offsetof(UA_ReadRequest, maxAge) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodesToRead") /* .memberName */ + &UA_TYPES[UA_TYPES_READVALUEID], /* .memberType */ + offsetof(UA_ReadRequest, nodesToReadSize) - offsetof(UA_ReadRequest, timestampsToReturn) - sizeof(UA_TimestampsToReturn), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* ReadResponse */ +static UA_DataTypeMember ReadResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_DATAVALUE], /* .memberType */ + offsetof(UA_ReadResponse, resultsSize) - offsetof(UA_ReadResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_ReadResponse, diagnosticInfosSize) - offsetof(UA_ReadResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* WriteValue */ +static UA_DataTypeMember WriteValue_members[4] = { +{ + UA_TYPENAME("NodeId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AttributeId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_WriteValue, attributeId) - offsetof(UA_WriteValue, nodeId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("IndexRange") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_WriteValue, indexRange) - offsetof(UA_WriteValue, attributeId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_DATAVALUE], /* .memberType */ + offsetof(UA_WriteValue, value) - offsetof(UA_WriteValue, indexRange) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* WriteRequest */ +static UA_DataTypeMember WriteRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NodesToWrite") /* .memberName */ + &UA_TYPES[UA_TYPES_WRITEVALUE], /* .memberType */ + offsetof(UA_WriteRequest, nodesToWriteSize) - offsetof(UA_WriteRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* WriteResponse */ +static UA_DataTypeMember WriteResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_WriteResponse, resultsSize) - offsetof(UA_WriteResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_WriteResponse, diagnosticInfosSize) - offsetof(UA_WriteResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* CallMethodRequest */ +static UA_DataTypeMember CallMethodRequest_members[3] = { +{ + UA_TYPENAME("ObjectId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MethodId") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_CallMethodRequest, methodId) - offsetof(UA_CallMethodRequest, objectId) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("InputArguments") /* .memberName */ + &UA_TYPES[UA_TYPES_VARIANT], /* .memberType */ + offsetof(UA_CallMethodRequest, inputArgumentsSize) - offsetof(UA_CallMethodRequest, methodId) - sizeof(UA_NodeId), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* CallMethodResult */ +static UA_DataTypeMember CallMethodResult_members[4] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("InputArgumentResults") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_CallMethodResult, inputArgumentResultsSize) - offsetof(UA_CallMethodResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("InputArgumentDiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_CallMethodResult, inputArgumentDiagnosticInfosSize) - offsetof(UA_CallMethodResult, inputArgumentResults) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("OutputArguments") /* .memberName */ + &UA_TYPES[UA_TYPES_VARIANT], /* .memberType */ + offsetof(UA_CallMethodResult, outputArgumentsSize) - offsetof(UA_CallMethodResult, inputArgumentDiagnosticInfos) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* CallRequest */ +static UA_DataTypeMember CallRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MethodsToCall") /* .memberName */ + &UA_TYPES[UA_TYPES_CALLMETHODREQUEST], /* .memberType */ + offsetof(UA_CallRequest, methodsToCallSize) - offsetof(UA_CallRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* CallResponse */ +static UA_DataTypeMember CallResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_CALLMETHODRESULT], /* .memberType */ + offsetof(UA_CallResponse, resultsSize) - offsetof(UA_CallResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_CallResponse, diagnosticInfosSize) - offsetof(UA_CallResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* MonitoringMode */ +#define MonitoringMode_members NULL + +/* DataChangeTrigger */ +#define DataChangeTrigger_members NULL + +/* DeadbandType */ +#define DeadbandType_members NULL + +/* DataChangeFilter */ +static UA_DataTypeMember DataChangeFilter_members[3] = { +{ + UA_TYPENAME("Trigger") /* .memberName */ + &UA_TYPES[UA_TYPES_DATACHANGETRIGGER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DeadbandType") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_DataChangeFilter, deadbandType) - offsetof(UA_DataChangeFilter, trigger) - sizeof(UA_DataChangeTrigger), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DeadbandValue") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_DataChangeFilter, deadbandValue) - offsetof(UA_DataChangeFilter, deadbandType) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EventFilter */ +static UA_DataTypeMember EventFilter_members[2] = { +{ + UA_TYPENAME("SelectClauses") /* .memberName */ + &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WhereClause") /* .memberName */ + &UA_TYPES[UA_TYPES_CONTENTFILTER], /* .memberType */ + offsetof(UA_EventFilter, whereClause) - offsetof(UA_EventFilter, selectClauses) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AggregateConfiguration */ +static UA_DataTypeMember AggregateConfiguration_members[5] = { +{ + UA_TYPENAME("UseServerCapabilitiesDefaults") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TreatUncertainAsBad") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_AggregateConfiguration, treatUncertainAsBad) - offsetof(UA_AggregateConfiguration, useServerCapabilitiesDefaults) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("PercentDataBad") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_AggregateConfiguration, percentDataBad) - offsetof(UA_AggregateConfiguration, treatUncertainAsBad) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("PercentDataGood") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_AggregateConfiguration, percentDataGood) - offsetof(UA_AggregateConfiguration, percentDataBad) - sizeof(UA_Byte), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UseSlopedExtrapolation") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_AggregateConfiguration, useSlopedExtrapolation) - offsetof(UA_AggregateConfiguration, percentDataGood) - sizeof(UA_Byte), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AggregateFilter */ +static UA_DataTypeMember AggregateFilter_members[4] = { +{ + UA_TYPENAME("StartTime") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AggregateType") /* .memberName */ + &UA_TYPES[UA_TYPES_NODEID], /* .memberType */ + offsetof(UA_AggregateFilter, aggregateType) - offsetof(UA_AggregateFilter, startTime) - sizeof(UA_DateTime), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ProcessingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_AggregateFilter, processingInterval) - offsetof(UA_AggregateFilter, aggregateType) - sizeof(UA_NodeId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AggregateConfiguration") /* .memberName */ + &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION], /* .memberType */ + offsetof(UA_AggregateFilter, aggregateConfiguration) - offsetof(UA_AggregateFilter, processingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EventFilterResult */ +static UA_DataTypeMember EventFilterResult_members[3] = { +{ + UA_TYPENAME("SelectClauseResults") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SelectClauseDiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_EventFilterResult, selectClauseDiagnosticInfosSize) - offsetof(UA_EventFilterResult, selectClauseResults) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("WhereClauseResult") /* .memberName */ + &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT], /* .memberType */ + offsetof(UA_EventFilterResult, whereClauseResult) - offsetof(UA_EventFilterResult, selectClauseDiagnosticInfos) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* MonitoringParameters */ +static UA_DataTypeMember MonitoringParameters_members[5] = { +{ + UA_TYPENAME("ClientHandle") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SamplingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_MonitoringParameters, samplingInterval) - offsetof(UA_MonitoringParameters, clientHandle) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Filter") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_MonitoringParameters, filter) - offsetof(UA_MonitoringParameters, samplingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("QueueSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_MonitoringParameters, queueSize) - offsetof(UA_MonitoringParameters, filter) - sizeof(UA_ExtensionObject), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiscardOldest") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_MonitoringParameters, discardOldest) - offsetof(UA_MonitoringParameters, queueSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* MonitoredItemCreateRequest */ +static UA_DataTypeMember MonitoredItemCreateRequest_members[3] = { +{ + UA_TYPENAME("ItemToMonitor") /* .memberName */ + &UA_TYPES[UA_TYPES_READVALUEID], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MonitoringMode") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITORINGMODE], /* .memberType */ + offsetof(UA_MonitoredItemCreateRequest, monitoringMode) - offsetof(UA_MonitoredItemCreateRequest, itemToMonitor) - sizeof(UA_ReadValueId), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedParameters") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS], /* .memberType */ + offsetof(UA_MonitoredItemCreateRequest, requestedParameters) - offsetof(UA_MonitoredItemCreateRequest, monitoringMode) - sizeof(UA_MonitoringMode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* MonitoredItemCreateResult */ +static UA_DataTypeMember MonitoredItemCreateResult_members[5] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MonitoredItemId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_MonitoredItemCreateResult, monitoredItemId) - offsetof(UA_MonitoredItemCreateResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedSamplingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_MonitoredItemCreateResult, revisedSamplingInterval) - offsetof(UA_MonitoredItemCreateResult, monitoredItemId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedQueueSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_MonitoredItemCreateResult, revisedQueueSize) - offsetof(UA_MonitoredItemCreateResult, revisedSamplingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("FilterResult") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_MonitoredItemCreateResult, filterResult) - offsetof(UA_MonitoredItemCreateResult, revisedQueueSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* CreateMonitoredItemsRequest */ +static UA_DataTypeMember CreateMonitoredItemsRequest_members[4] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateMonitoredItemsRequest, subscriptionId) - offsetof(UA_CreateMonitoredItemsRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TimestampsToReturn") /* .memberName */ + &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN], /* .memberType */ + offsetof(UA_CreateMonitoredItemsRequest, timestampsToReturn) - offsetof(UA_CreateMonitoredItemsRequest, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ItemsToCreate") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST], /* .memberType */ + offsetof(UA_CreateMonitoredItemsRequest, itemsToCreateSize) - offsetof(UA_CreateMonitoredItemsRequest, timestampsToReturn) - sizeof(UA_TimestampsToReturn), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* CreateMonitoredItemsResponse */ +static UA_DataTypeMember CreateMonitoredItemsResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT], /* .memberType */ + offsetof(UA_CreateMonitoredItemsResponse, resultsSize) - offsetof(UA_CreateMonitoredItemsResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_CreateMonitoredItemsResponse, diagnosticInfosSize) - offsetof(UA_CreateMonitoredItemsResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* MonitoredItemModifyRequest */ +static UA_DataTypeMember MonitoredItemModifyRequest_members[2] = { +{ + UA_TYPENAME("MonitoredItemId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedParameters") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS], /* .memberType */ + offsetof(UA_MonitoredItemModifyRequest, requestedParameters) - offsetof(UA_MonitoredItemModifyRequest, monitoredItemId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* MonitoredItemModifyResult */ +static UA_DataTypeMember MonitoredItemModifyResult_members[4] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedSamplingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_MonitoredItemModifyResult, revisedSamplingInterval) - offsetof(UA_MonitoredItemModifyResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedQueueSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_MonitoredItemModifyResult, revisedQueueSize) - offsetof(UA_MonitoredItemModifyResult, revisedSamplingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("FilterResult") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_MonitoredItemModifyResult, filterResult) - offsetof(UA_MonitoredItemModifyResult, revisedQueueSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ModifyMonitoredItemsRequest */ +static UA_DataTypeMember ModifyMonitoredItemsRequest_members[4] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ModifyMonitoredItemsRequest, subscriptionId) - offsetof(UA_ModifyMonitoredItemsRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TimestampsToReturn") /* .memberName */ + &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN], /* .memberType */ + offsetof(UA_ModifyMonitoredItemsRequest, timestampsToReturn) - offsetof(UA_ModifyMonitoredItemsRequest, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ItemsToModify") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST], /* .memberType */ + offsetof(UA_ModifyMonitoredItemsRequest, itemsToModifySize) - offsetof(UA_ModifyMonitoredItemsRequest, timestampsToReturn) - sizeof(UA_TimestampsToReturn), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* ModifyMonitoredItemsResponse */ +static UA_DataTypeMember ModifyMonitoredItemsResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT], /* .memberType */ + offsetof(UA_ModifyMonitoredItemsResponse, resultsSize) - offsetof(UA_ModifyMonitoredItemsResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_ModifyMonitoredItemsResponse, diagnosticInfosSize) - offsetof(UA_ModifyMonitoredItemsResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* SetMonitoringModeRequest */ +static UA_DataTypeMember SetMonitoringModeRequest_members[4] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SetMonitoringModeRequest, subscriptionId) - offsetof(UA_SetMonitoringModeRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MonitoringMode") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITORINGMODE], /* .memberType */ + offsetof(UA_SetMonitoringModeRequest, monitoringMode) - offsetof(UA_SetMonitoringModeRequest, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MonitoredItemIds") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SetMonitoringModeRequest, monitoredItemIdsSize) - offsetof(UA_SetMonitoringModeRequest, monitoringMode) - sizeof(UA_MonitoringMode), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* SetMonitoringModeResponse */ +static UA_DataTypeMember SetMonitoringModeResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_SetMonitoringModeResponse, resultsSize) - offsetof(UA_SetMonitoringModeResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_SetMonitoringModeResponse, diagnosticInfosSize) - offsetof(UA_SetMonitoringModeResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* SetTriggeringRequest */ +static UA_DataTypeMember SetTriggeringRequest_members[5] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SetTriggeringRequest, subscriptionId) - offsetof(UA_SetTriggeringRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("TriggeringItemId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SetTriggeringRequest, triggeringItemId) - offsetof(UA_SetTriggeringRequest, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("LinksToAdd") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SetTriggeringRequest, linksToAddSize) - offsetof(UA_SetTriggeringRequest, triggeringItemId) - sizeof(UA_UInt32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("LinksToRemove") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SetTriggeringRequest, linksToRemoveSize) - offsetof(UA_SetTriggeringRequest, linksToAdd) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* SetTriggeringResponse */ +static UA_DataTypeMember SetTriggeringResponse_members[5] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AddResults") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_SetTriggeringResponse, addResultsSize) - offsetof(UA_SetTriggeringResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AddDiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_SetTriggeringResponse, addDiagnosticInfosSize) - offsetof(UA_SetTriggeringResponse, addResults) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RemoveResults") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_SetTriggeringResponse, removeResultsSize) - offsetof(UA_SetTriggeringResponse, addDiagnosticInfos) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RemoveDiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_SetTriggeringResponse, removeDiagnosticInfosSize) - offsetof(UA_SetTriggeringResponse, removeResults) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteMonitoredItemsRequest */ +static UA_DataTypeMember DeleteMonitoredItemsRequest_members[3] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_DeleteMonitoredItemsRequest, subscriptionId) - offsetof(UA_DeleteMonitoredItemsRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MonitoredItemIds") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_DeleteMonitoredItemsRequest, monitoredItemIdsSize) - offsetof(UA_DeleteMonitoredItemsRequest, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteMonitoredItemsResponse */ +static UA_DataTypeMember DeleteMonitoredItemsResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_DeleteMonitoredItemsResponse, resultsSize) - offsetof(UA_DeleteMonitoredItemsResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_DeleteMonitoredItemsResponse, diagnosticInfosSize) - offsetof(UA_DeleteMonitoredItemsResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* CreateSubscriptionRequest */ +static UA_DataTypeMember CreateSubscriptionRequest_members[7] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedPublishingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_CreateSubscriptionRequest, requestedPublishingInterval) - offsetof(UA_CreateSubscriptionRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedLifetimeCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSubscriptionRequest, requestedLifetimeCount) - offsetof(UA_CreateSubscriptionRequest, requestedPublishingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedMaxKeepAliveCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSubscriptionRequest, requestedMaxKeepAliveCount) - offsetof(UA_CreateSubscriptionRequest, requestedLifetimeCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxNotificationsPerPublish") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSubscriptionRequest, maxNotificationsPerPublish) - offsetof(UA_CreateSubscriptionRequest, requestedMaxKeepAliveCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("PublishingEnabled") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_CreateSubscriptionRequest, publishingEnabled) - offsetof(UA_CreateSubscriptionRequest, maxNotificationsPerPublish) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Priority") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_CreateSubscriptionRequest, priority) - offsetof(UA_CreateSubscriptionRequest, publishingEnabled) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* CreateSubscriptionResponse */ +static UA_DataTypeMember CreateSubscriptionResponse_members[5] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSubscriptionResponse, subscriptionId) - offsetof(UA_CreateSubscriptionResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedPublishingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_CreateSubscriptionResponse, revisedPublishingInterval) - offsetof(UA_CreateSubscriptionResponse, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedLifetimeCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSubscriptionResponse, revisedLifetimeCount) - offsetof(UA_CreateSubscriptionResponse, revisedPublishingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedMaxKeepAliveCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_CreateSubscriptionResponse, revisedMaxKeepAliveCount) - offsetof(UA_CreateSubscriptionResponse, revisedLifetimeCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ModifySubscriptionRequest */ +static UA_DataTypeMember ModifySubscriptionRequest_members[7] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ModifySubscriptionRequest, subscriptionId) - offsetof(UA_ModifySubscriptionRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedPublishingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_ModifySubscriptionRequest, requestedPublishingInterval) - offsetof(UA_ModifySubscriptionRequest, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedLifetimeCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ModifySubscriptionRequest, requestedLifetimeCount) - offsetof(UA_ModifySubscriptionRequest, requestedPublishingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestedMaxKeepAliveCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ModifySubscriptionRequest, requestedMaxKeepAliveCount) - offsetof(UA_ModifySubscriptionRequest, requestedLifetimeCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxNotificationsPerPublish") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ModifySubscriptionRequest, maxNotificationsPerPublish) - offsetof(UA_ModifySubscriptionRequest, requestedMaxKeepAliveCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Priority") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTE], /* .memberType */ + offsetof(UA_ModifySubscriptionRequest, priority) - offsetof(UA_ModifySubscriptionRequest, maxNotificationsPerPublish) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ModifySubscriptionResponse */ +static UA_DataTypeMember ModifySubscriptionResponse_members[4] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedPublishingInterval") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_ModifySubscriptionResponse, revisedPublishingInterval) - offsetof(UA_ModifySubscriptionResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedLifetimeCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ModifySubscriptionResponse, revisedLifetimeCount) - offsetof(UA_ModifySubscriptionResponse, revisedPublishingInterval) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RevisedMaxKeepAliveCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ModifySubscriptionResponse, revisedMaxKeepAliveCount) - offsetof(UA_ModifySubscriptionResponse, revisedLifetimeCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* SetPublishingModeRequest */ +static UA_DataTypeMember SetPublishingModeRequest_members[3] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("PublishingEnabled") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_SetPublishingModeRequest, publishingEnabled) - offsetof(UA_SetPublishingModeRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionIds") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SetPublishingModeRequest, subscriptionIdsSize) - offsetof(UA_SetPublishingModeRequest, publishingEnabled) - sizeof(UA_Boolean), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* SetPublishingModeResponse */ +static UA_DataTypeMember SetPublishingModeResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_SetPublishingModeResponse, resultsSize) - offsetof(UA_SetPublishingModeResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_SetPublishingModeResponse, diagnosticInfosSize) - offsetof(UA_SetPublishingModeResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* NotificationMessage */ +static UA_DataTypeMember NotificationMessage_members[3] = { +{ + UA_TYPENAME("SequenceNumber") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("PublishTime") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + offsetof(UA_NotificationMessage, publishTime) - offsetof(UA_NotificationMessage, sequenceNumber) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NotificationData") /* .memberName */ + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT], /* .memberType */ + offsetof(UA_NotificationMessage, notificationDataSize) - offsetof(UA_NotificationMessage, publishTime) - sizeof(UA_DateTime), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* MonitoredItemNotification */ +static UA_DataTypeMember MonitoredItemNotification_members[2] = { +{ + UA_TYPENAME("ClientHandle") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_DATAVALUE], /* .memberType */ + offsetof(UA_MonitoredItemNotification, value) - offsetof(UA_MonitoredItemNotification, clientHandle) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EventFieldList */ +static UA_DataTypeMember EventFieldList_members[2] = { +{ + UA_TYPENAME("ClientHandle") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EventFields") /* .memberName */ + &UA_TYPES[UA_TYPES_VARIANT], /* .memberType */ + offsetof(UA_EventFieldList, eventFieldsSize) - offsetof(UA_EventFieldList, clientHandle) - sizeof(UA_UInt32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* StatusChangeNotification */ +static UA_DataTypeMember StatusChangeNotification_members[2] = { +{ + UA_TYPENAME("Status") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfo") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_StatusChangeNotification, diagnosticInfo) - offsetof(UA_StatusChangeNotification, status) - sizeof(UA_StatusCode), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* SubscriptionAcknowledgement */ +static UA_DataTypeMember SubscriptionAcknowledgement_members[2] = { +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SequenceNumber") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SubscriptionAcknowledgement, sequenceNumber) - offsetof(UA_SubscriptionAcknowledgement, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* PublishRequest */ +static UA_DataTypeMember PublishRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionAcknowledgements") /* .memberName */ + &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT], /* .memberType */ + offsetof(UA_PublishRequest, subscriptionAcknowledgementsSize) - offsetof(UA_PublishRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* PublishResponse */ +static UA_DataTypeMember PublishResponse_members[7] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_PublishResponse, subscriptionId) - offsetof(UA_PublishResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AvailableSequenceNumbers") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_PublishResponse, availableSequenceNumbersSize) - offsetof(UA_PublishResponse, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MoreNotifications") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_PublishResponse, moreNotifications) - offsetof(UA_PublishResponse, availableSequenceNumbers) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NotificationMessage") /* .memberName */ + &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE], /* .memberType */ + offsetof(UA_PublishResponse, notificationMessage) - offsetof(UA_PublishResponse, moreNotifications) - sizeof(UA_Boolean), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_PublishResponse, resultsSize) - offsetof(UA_PublishResponse, notificationMessage) - sizeof(UA_NotificationMessage), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_PublishResponse, diagnosticInfosSize) - offsetof(UA_PublishResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* RepublishRequest */ +static UA_DataTypeMember RepublishRequest_members[3] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_RepublishRequest, subscriptionId) - offsetof(UA_RepublishRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RetransmitSequenceNumber") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_RepublishRequest, retransmitSequenceNumber) - offsetof(UA_RepublishRequest, subscriptionId) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* RepublishResponse */ +static UA_DataTypeMember RepublishResponse_members[2] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("NotificationMessage") /* .memberName */ + &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE], /* .memberType */ + offsetof(UA_RepublishResponse, notificationMessage) - offsetof(UA_RepublishResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* TransferResult */ +static UA_DataTypeMember TransferResult_members[2] = { +{ + UA_TYPENAME("StatusCode") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AvailableSequenceNumbers") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TransferResult, availableSequenceNumbersSize) - offsetof(UA_TransferResult, statusCode) - sizeof(UA_StatusCode), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* TransferSubscriptionsRequest */ +static UA_DataTypeMember TransferSubscriptionsRequest_members[3] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionIds") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TransferSubscriptionsRequest, subscriptionIdsSize) - offsetof(UA_TransferSubscriptionsRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SendInitialValues") /* .memberName */ + &UA_TYPES[UA_TYPES_BOOLEAN], /* .memberType */ + offsetof(UA_TransferSubscriptionsRequest, sendInitialValues) - offsetof(UA_TransferSubscriptionsRequest, subscriptionIds) - sizeof(void *), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* TransferSubscriptionsResponse */ +static UA_DataTypeMember TransferSubscriptionsResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_TRANSFERRESULT], /* .memberType */ + offsetof(UA_TransferSubscriptionsResponse, resultsSize) - offsetof(UA_TransferSubscriptionsResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_TransferSubscriptionsResponse, diagnosticInfosSize) - offsetof(UA_TransferSubscriptionsResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteSubscriptionsRequest */ +static UA_DataTypeMember DeleteSubscriptionsRequest_members[2] = { +{ + UA_TYPENAME("RequestHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_REQUESTHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SubscriptionIds") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_DeleteSubscriptionsRequest, subscriptionIdsSize) - offsetof(UA_DeleteSubscriptionsRequest, requestHeader) - sizeof(UA_RequestHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DeleteSubscriptionsResponse */ +static UA_DataTypeMember DeleteSubscriptionsResponse_members[3] = { +{ + UA_TYPENAME("ResponseHeader") /* .memberName */ + &UA_TYPES[UA_TYPES_RESPONSEHEADER], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Results") /* .memberName */ + &UA_TYPES[UA_TYPES_STATUSCODE], /* .memberType */ + offsetof(UA_DeleteSubscriptionsResponse, resultsSize) - offsetof(UA_DeleteSubscriptionsResponse, responseHeader) - sizeof(UA_ResponseHeader), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_DeleteSubscriptionsResponse, diagnosticInfosSize) - offsetof(UA_DeleteSubscriptionsResponse, results) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* BuildInfo */ +static UA_DataTypeMember BuildInfo_members[6] = { +{ + UA_TYPENAME("ProductUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ManufacturerName") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_BuildInfo, manufacturerName) - offsetof(UA_BuildInfo, productUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ProductName") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_BuildInfo, productName) - offsetof(UA_BuildInfo, manufacturerName) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SoftwareVersion") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_BuildInfo, softwareVersion) - offsetof(UA_BuildInfo, productName) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BuildNumber") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_BuildInfo, buildNumber) - offsetof(UA_BuildInfo, softwareVersion) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BuildDate") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + offsetof(UA_BuildInfo, buildDate) - offsetof(UA_BuildInfo, buildNumber) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* RedundancySupport */ +#define RedundancySupport_members NULL + +/* ServerState */ +#define ServerState_members NULL + +/* ServerDiagnosticsSummaryDataType */ +static UA_DataTypeMember ServerDiagnosticsSummaryDataType_members[12] = { +{ + UA_TYPENAME("ServerViewCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("CurrentSessionCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, currentSessionCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, serverViewCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("CumulatedSessionCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, cumulatedSessionCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, currentSessionCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityRejectedSessionCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, securityRejectedSessionCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, cumulatedSessionCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RejectedSessionCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, rejectedSessionCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, securityRejectedSessionCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SessionTimeoutCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, sessionTimeoutCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, rejectedSessionCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SessionAbortCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, sessionAbortCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, sessionTimeoutCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("CurrentSubscriptionCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, currentSubscriptionCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, sessionAbortCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("CumulatedSubscriptionCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, cumulatedSubscriptionCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, currentSubscriptionCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("PublishingIntervalCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, publishingIntervalCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, cumulatedSubscriptionCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecurityRejectedRequestsCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, securityRejectedRequestsCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, publishingIntervalCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RejectedRequestsCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerDiagnosticsSummaryDataType, rejectedRequestsCount) - offsetof(UA_ServerDiagnosticsSummaryDataType, securityRejectedRequestsCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* ServerStatusDataType */ +static UA_DataTypeMember ServerStatusDataType_members[6] = { +{ + UA_TYPENAME("StartTime") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("CurrentTime") /* .memberName */ + &UA_TYPES[UA_TYPES_DATETIME], /* .memberType */ + offsetof(UA_ServerStatusDataType, currentTime) - offsetof(UA_ServerStatusDataType, startTime) - sizeof(UA_DateTime), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("State") /* .memberName */ + &UA_TYPES[UA_TYPES_SERVERSTATE], /* .memberType */ + offsetof(UA_ServerStatusDataType, state) - offsetof(UA_ServerStatusDataType, currentTime) - sizeof(UA_DateTime), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("BuildInfo") /* .memberName */ + &UA_TYPES[UA_TYPES_BUILDINFO], /* .memberType */ + offsetof(UA_ServerStatusDataType, buildInfo) - offsetof(UA_ServerStatusDataType, state) - sizeof(UA_ServerState), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SecondsTillShutdown") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_ServerStatusDataType, secondsTillShutdown) - offsetof(UA_ServerStatusDataType, buildInfo) - sizeof(UA_BuildInfo), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ShutdownReason") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_ServerStatusDataType, shutdownReason) - offsetof(UA_ServerStatusDataType, secondsTillShutdown) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* Range */ +static UA_DataTypeMember Range_members[2] = { +{ + UA_TYPENAME("Low") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("High") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_Range, high) - offsetof(UA_Range, low) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EUInformation */ +static UA_DataTypeMember EUInformation_members[4] = { +{ + UA_TYPENAME("NamespaceUri") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("UnitId") /* .memberName */ + &UA_TYPES[UA_TYPES_INT32], /* .memberType */ + offsetof(UA_EUInformation, unitId) - offsetof(UA_EUInformation, namespaceUri) - sizeof(UA_String), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DisplayName") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_EUInformation, displayName) - offsetof(UA_EUInformation, unitId) - sizeof(UA_Int32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Description") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_EUInformation, description) - offsetof(UA_EUInformation, displayName) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AxisScaleEnumeration */ +#define AxisScaleEnumeration_members NULL + +/* ComplexNumberType */ +static UA_DataTypeMember ComplexNumberType_members[2] = { +{ + UA_TYPENAME("Real") /* .memberName */ + &UA_TYPES[UA_TYPES_FLOAT], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Imaginary") /* .memberName */ + &UA_TYPES[UA_TYPES_FLOAT], /* .memberType */ + offsetof(UA_ComplexNumberType, imaginary) - offsetof(UA_ComplexNumberType, real) - sizeof(UA_Float), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* DoubleComplexNumberType */ +static UA_DataTypeMember DoubleComplexNumberType_members[2] = { +{ + UA_TYPENAME("Real") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Imaginary") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_DoubleComplexNumberType, imaginary) - offsetof(UA_DoubleComplexNumberType, real) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AxisInformation */ +static UA_DataTypeMember AxisInformation_members[5] = { +{ + UA_TYPENAME("EngineeringUnits") /* .memberName */ + &UA_TYPES[UA_TYPES_EUINFORMATION], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EURange") /* .memberName */ + &UA_TYPES[UA_TYPES_RANGE], /* .memberType */ + offsetof(UA_AxisInformation, eURange) - offsetof(UA_AxisInformation, engineeringUnits) - sizeof(UA_EUInformation), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Title") /* .memberName */ + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], /* .memberType */ + offsetof(UA_AxisInformation, title) - offsetof(UA_AxisInformation, eURange) - sizeof(UA_Range), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AxisScaleType") /* .memberName */ + &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION], /* .memberType */ + offsetof(UA_AxisInformation, axisScaleType) - offsetof(UA_AxisInformation, title) - sizeof(UA_LocalizedText), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("AxisSteps") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + offsetof(UA_AxisInformation, axisStepsSize) - offsetof(UA_AxisInformation, axisScaleType) - sizeof(UA_AxisScaleEnumeration), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* XVType */ +static UA_DataTypeMember XVType_members[2] = { +{ + UA_TYPENAME("X") /* .memberName */ + &UA_TYPES[UA_TYPES_DOUBLE], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Value") /* .memberName */ + &UA_TYPES[UA_TYPES_FLOAT], /* .memberType */ + offsetof(UA_XVType, value) - offsetof(UA_XVType, x) - sizeof(UA_Double), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* EnumDefinition */ +static UA_DataTypeMember EnumDefinition_members[1] = { +{ + UA_TYPENAME("Fields") /* .memberName */ + &UA_TYPES[UA_TYPES_ENUMFIELD], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* DataChangeNotification */ +static UA_DataTypeMember DataChangeNotification_members[2] = { +{ + UA_TYPENAME("MonitoredItems") /* .memberName */ + &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("DiagnosticInfos") /* .memberName */ + &UA_TYPES[UA_TYPES_DIAGNOSTICINFO], /* .memberType */ + offsetof(UA_DataChangeNotification, diagnosticInfosSize) - offsetof(UA_DataChangeNotification, monitoredItems) - sizeof(void *), /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; + +/* EventNotificationList */ +static UA_DataTypeMember EventNotificationList_members[1] = { +{ + UA_TYPENAME("Events") /* .memberName */ + &UA_TYPES[UA_TYPES_EVENTFIELDLIST], /* .memberType */ + 0, /* .padding */ + true, /* .isArray */ + false /* .isOptional */ +},}; +const UA_DataType UA_TYPES[UA_TYPES_COUNT] = { +/* Boolean */ +{ + UA_TYPENAME("Boolean") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {1LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Boolean), /* .memSize */ + UA_DATATYPEKIND_BOOLEAN, /* .typeKind */ + true, /* .pointerFree */ + true, /* .overlayable */ + 0, /* .membersSize */ + Boolean_members /* .members */ +}, +/* SByte */ +{ + UA_TYPENAME("SByte") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {2LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_SByte), /* .memSize */ + UA_DATATYPEKIND_SBYTE, /* .typeKind */ + true, /* .pointerFree */ + true, /* .overlayable */ + 0, /* .membersSize */ + SByte_members /* .members */ +}, +/* Byte */ +{ + UA_TYPENAME("Byte") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {3LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Byte), /* .memSize */ + UA_DATATYPEKIND_BYTE, /* .typeKind */ + true, /* .pointerFree */ + true, /* .overlayable */ + 0, /* .membersSize */ + Byte_members /* .members */ +}, +/* Int16 */ +{ + UA_TYPENAME("Int16") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {4LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Int16), /* .memSize */ + UA_DATATYPEKIND_INT16, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + Int16_members /* .members */ +}, +/* UInt16 */ +{ + UA_TYPENAME("UInt16") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {5LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_UInt16), /* .memSize */ + UA_DATATYPEKIND_UINT16, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + UInt16_members /* .members */ +}, +/* Int32 */ +{ + UA_TYPENAME("Int32") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {6LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Int32), /* .memSize */ + UA_DATATYPEKIND_INT32, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + Int32_members /* .members */ +}, +/* UInt32 */ +{ + UA_TYPENAME("UInt32") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {7LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_UInt32), /* .memSize */ + UA_DATATYPEKIND_UINT32, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + UInt32_members /* .members */ +}, +/* Int64 */ +{ + UA_TYPENAME("Int64") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {8LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Int64), /* .memSize */ + UA_DATATYPEKIND_INT64, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + Int64_members /* .members */ +}, +/* UInt64 */ +{ + UA_TYPENAME("UInt64") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {9LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_UInt64), /* .memSize */ + UA_DATATYPEKIND_UINT64, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + UInt64_members /* .members */ +}, +/* Float */ +{ + UA_TYPENAME("Float") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {10LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Float), /* .memSize */ + UA_DATATYPEKIND_FLOAT, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_FLOAT, /* .overlayable */ + 0, /* .membersSize */ + Float_members /* .members */ +}, +/* Double */ +{ + UA_TYPENAME("Double") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {11LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Double), /* .memSize */ + UA_DATATYPEKIND_DOUBLE, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_FLOAT, /* .overlayable */ + 0, /* .membersSize */ + Double_members /* .members */ +}, +/* String */ +{ + UA_TYPENAME("String") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {12LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_String), /* .memSize */ + UA_DATATYPEKIND_STRING, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + String_members /* .members */ +}, +/* DateTime */ +{ + UA_TYPENAME("DateTime") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {13LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_DateTime), /* .memSize */ + UA_DATATYPEKIND_DATETIME, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + DateTime_members /* .members */ +}, +/* Guid */ +{ + UA_TYPENAME("Guid") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {14LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Guid), /* .memSize */ + UA_DATATYPEKIND_GUID, /* .typeKind */ + true, /* .pointerFree */ + (UA_BINARY_OVERLAYABLE_INTEGER && offsetof(UA_Guid, data2) == sizeof(UA_UInt32) && offsetof(UA_Guid, data3) == (sizeof(UA_UInt16) + sizeof(UA_UInt32)) && offsetof(UA_Guid, data4) == (2*sizeof(UA_UInt32))), /* .overlayable */ + 0, /* .membersSize */ + Guid_members /* .members */ +}, +/* ByteString */ +{ + UA_TYPENAME("ByteString") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {15LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_ByteString), /* .memSize */ + UA_DATATYPEKIND_BYTESTRING, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + ByteString_members /* .members */ +}, +/* XmlElement */ +{ + UA_TYPENAME("XmlElement") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {16LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_XmlElement), /* .memSize */ + UA_DATATYPEKIND_XMLELEMENT, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + XmlElement_members /* .members */ +}, +/* NodeId */ +{ + UA_TYPENAME("NodeId") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {17LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_NodeId), /* .memSize */ + UA_DATATYPEKIND_NODEID, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + NodeId_members /* .members */ +}, +/* ExpandedNodeId */ +{ + UA_TYPENAME("ExpandedNodeId") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {18LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_ExpandedNodeId), /* .memSize */ + UA_DATATYPEKIND_EXPANDEDNODEID, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + ExpandedNodeId_members /* .members */ +}, +/* StatusCode */ +{ + UA_TYPENAME("StatusCode") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {19LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_StatusCode), /* .memSize */ + UA_DATATYPEKIND_STATUSCODE, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + StatusCode_members /* .members */ +}, +/* QualifiedName */ +{ + UA_TYPENAME("QualifiedName") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {20LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_QualifiedName), /* .memSize */ + UA_DATATYPEKIND_QUALIFIEDNAME, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + QualifiedName_members /* .members */ +}, +/* LocalizedText */ +{ + UA_TYPENAME("LocalizedText") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {21LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_LocalizedText), /* .memSize */ + UA_DATATYPEKIND_LOCALIZEDTEXT, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + LocalizedText_members /* .members */ +}, +/* ExtensionObject */ +{ + UA_TYPENAME("ExtensionObject") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {22LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_ExtensionObject), /* .memSize */ + UA_DATATYPEKIND_EXTENSIONOBJECT, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + ExtensionObject_members /* .members */ +}, +/* DataValue */ +{ + UA_TYPENAME("DataValue") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {23LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_DataValue), /* .memSize */ + UA_DATATYPEKIND_DATAVALUE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + DataValue_members /* .members */ +}, +/* Variant */ +{ + UA_TYPENAME("Variant") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {24LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Variant), /* .memSize */ + UA_DATATYPEKIND_VARIANT, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + Variant_members /* .members */ +}, +/* DiagnosticInfo */ +{ + UA_TYPENAME("DiagnosticInfo") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {25LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_DiagnosticInfo), /* .memSize */ + UA_DATATYPEKIND_DIAGNOSTICINFO, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + DiagnosticInfo_members /* .members */ +}, +/* KeyValuePair */ +{ + UA_TYPENAME("KeyValuePair") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {14533LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {14846LU}}, /* .binaryEncodingId */ + sizeof(UA_KeyValuePair), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + KeyValuePair_members /* .members */ +}, +/* NodeClass */ +{ + UA_TYPENAME("NodeClass") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {257LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_NodeClass), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + NodeClass_members /* .members */ +}, +/* StructureType */ +{ + UA_TYPENAME("StructureType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {98LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_StructureType), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + StructureType_members /* .members */ +}, +/* StructureField */ +{ + UA_TYPENAME("StructureField") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {101LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {14844LU}}, /* .binaryEncodingId */ + sizeof(UA_StructureField), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + StructureField_members /* .members */ +}, +/* StructureDefinition */ +{ + UA_TYPENAME("StructureDefinition") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {99LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {122LU}}, /* .binaryEncodingId */ + sizeof(UA_StructureDefinition), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + StructureDefinition_members /* .members */ +}, +/* Argument */ +{ + UA_TYPENAME("Argument") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {296LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {298LU}}, /* .binaryEncodingId */ + sizeof(UA_Argument), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + Argument_members /* .members */ +}, +/* EnumValueType */ +{ + UA_TYPENAME("EnumValueType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {7594LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {8251LU}}, /* .binaryEncodingId */ + sizeof(UA_EnumValueType), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + EnumValueType_members /* .members */ +}, +/* EnumField */ +{ + UA_TYPENAME("EnumField") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {102LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {14845LU}}, /* .binaryEncodingId */ + sizeof(UA_EnumField), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + EnumField_members /* .members */ +}, +/* Duration */ +{ + UA_TYPENAME("Duration") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {290LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_Duration), /* .memSize */ + UA_DATATYPEKIND_DOUBLE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + Duration_members /* .members */ +}, +/* UtcTime */ +{ + UA_TYPENAME("UtcTime") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {294LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_UtcTime), /* .memSize */ + UA_DATATYPEKIND_DATETIME, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + UtcTime_members /* .members */ +}, +/* LocaleId */ +{ + UA_TYPENAME("LocaleId") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {295LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_LocaleId), /* .memSize */ + UA_DATATYPEKIND_STRING, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 0, /* .membersSize */ + LocaleId_members /* .members */ +}, +/* TimeZoneDataType */ +{ + UA_TYPENAME("TimeZoneDataType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {8912LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {8917LU}}, /* .binaryEncodingId */ + sizeof(UA_TimeZoneDataType), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + TimeZoneDataType_members /* .members */ +}, +/* ApplicationType */ +{ + UA_TYPENAME("ApplicationType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {307LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_ApplicationType), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + ApplicationType_members /* .members */ +}, +/* ApplicationDescription */ +{ + UA_TYPENAME("ApplicationDescription") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {308LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {310LU}}, /* .binaryEncodingId */ + sizeof(UA_ApplicationDescription), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + ApplicationDescription_members /* .members */ +}, +/* RequestHeader */ +{ + UA_TYPENAME("RequestHeader") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {389LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {391LU}}, /* .binaryEncodingId */ + sizeof(UA_RequestHeader), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + RequestHeader_members /* .members */ +}, +/* ResponseHeader */ +{ + UA_TYPENAME("ResponseHeader") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {392LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {394LU}}, /* .binaryEncodingId */ + sizeof(UA_ResponseHeader), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + ResponseHeader_members /* .members */ +}, +/* ServiceFault */ +{ + UA_TYPENAME("ServiceFault") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {395LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {397LU}}, /* .binaryEncodingId */ + sizeof(UA_ServiceFault), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + ServiceFault_members /* .members */ +}, +/* FindServersRequest */ +{ + UA_TYPENAME("FindServersRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {420LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {422LU}}, /* .binaryEncodingId */ + sizeof(UA_FindServersRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + FindServersRequest_members /* .members */ +}, +/* FindServersResponse */ +{ + UA_TYPENAME("FindServersResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {423LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {425LU}}, /* .binaryEncodingId */ + sizeof(UA_FindServersResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + FindServersResponse_members /* .members */ +}, +/* MessageSecurityMode */ +{ + UA_TYPENAME("MessageSecurityMode") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {302LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_MessageSecurityMode), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + MessageSecurityMode_members /* .members */ +}, +/* UserTokenType */ +{ + UA_TYPENAME("UserTokenType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {303LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_UserTokenType), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + UserTokenType_members /* .members */ +}, +/* UserTokenPolicy */ +{ + UA_TYPENAME("UserTokenPolicy") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {304LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {306LU}}, /* .binaryEncodingId */ + sizeof(UA_UserTokenPolicy), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + UserTokenPolicy_members /* .members */ +}, +/* EndpointDescription */ +{ + UA_TYPENAME("EndpointDescription") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {312LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {314LU}}, /* .binaryEncodingId */ + sizeof(UA_EndpointDescription), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 8, /* .membersSize */ + EndpointDescription_members /* .members */ +}, +/* GetEndpointsRequest */ +{ + UA_TYPENAME("GetEndpointsRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {426LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {428LU}}, /* .binaryEncodingId */ + sizeof(UA_GetEndpointsRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + GetEndpointsRequest_members /* .members */ +}, +/* GetEndpointsResponse */ +{ + UA_TYPENAME("GetEndpointsResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {429LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {431LU}}, /* .binaryEncodingId */ + sizeof(UA_GetEndpointsResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + GetEndpointsResponse_members /* .members */ +}, +/* SecurityTokenRequestType */ +{ + UA_TYPENAME("SecurityTokenRequestType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {315LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_SecurityTokenRequestType), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + SecurityTokenRequestType_members /* .members */ +}, +/* ChannelSecurityToken */ +{ + UA_TYPENAME("ChannelSecurityToken") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {441LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {443LU}}, /* .binaryEncodingId */ + sizeof(UA_ChannelSecurityToken), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + ChannelSecurityToken_members /* .members */ +}, +/* OpenSecureChannelRequest */ +{ + UA_TYPENAME("OpenSecureChannelRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {444LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {446LU}}, /* .binaryEncodingId */ + sizeof(UA_OpenSecureChannelRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + OpenSecureChannelRequest_members /* .members */ +}, +/* OpenSecureChannelResponse */ +{ + UA_TYPENAME("OpenSecureChannelResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {447LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {449LU}}, /* .binaryEncodingId */ + sizeof(UA_OpenSecureChannelResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + OpenSecureChannelResponse_members /* .members */ +}, +/* CloseSecureChannelRequest */ +{ + UA_TYPENAME("CloseSecureChannelRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {450LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {452LU}}, /* .binaryEncodingId */ + sizeof(UA_CloseSecureChannelRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + CloseSecureChannelRequest_members /* .members */ +}, +/* CloseSecureChannelResponse */ +{ + UA_TYPENAME("CloseSecureChannelResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {453LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {455LU}}, /* .binaryEncodingId */ + sizeof(UA_CloseSecureChannelResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + CloseSecureChannelResponse_members /* .members */ +}, +/* SignedSoftwareCertificate */ +{ + UA_TYPENAME("SignedSoftwareCertificate") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {344LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {346LU}}, /* .binaryEncodingId */ + sizeof(UA_SignedSoftwareCertificate), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + SignedSoftwareCertificate_members /* .members */ +}, +/* SignatureData */ +{ + UA_TYPENAME("SignatureData") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {456LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {458LU}}, /* .binaryEncodingId */ + sizeof(UA_SignatureData), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + SignatureData_members /* .members */ +}, +/* CreateSessionRequest */ +{ + UA_TYPENAME("CreateSessionRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {459LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {461LU}}, /* .binaryEncodingId */ + sizeof(UA_CreateSessionRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 9, /* .membersSize */ + CreateSessionRequest_members /* .members */ +}, +/* CreateSessionResponse */ +{ + UA_TYPENAME("CreateSessionResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {462LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {464LU}}, /* .binaryEncodingId */ + sizeof(UA_CreateSessionResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 10, /* .membersSize */ + CreateSessionResponse_members /* .members */ +}, +/* UserIdentityToken */ +{ + UA_TYPENAME("UserIdentityToken") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {316LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {318LU}}, /* .binaryEncodingId */ + sizeof(UA_UserIdentityToken), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + UserIdentityToken_members /* .members */ +}, +/* AnonymousIdentityToken */ +{ + UA_TYPENAME("AnonymousIdentityToken") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {319LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {321LU}}, /* .binaryEncodingId */ + sizeof(UA_AnonymousIdentityToken), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + AnonymousIdentityToken_members /* .members */ +}, +/* UserNameIdentityToken */ +{ + UA_TYPENAME("UserNameIdentityToken") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {322LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {324LU}}, /* .binaryEncodingId */ + sizeof(UA_UserNameIdentityToken), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + UserNameIdentityToken_members /* .members */ +}, +/* X509IdentityToken */ +{ + UA_TYPENAME("X509IdentityToken") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {325LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {327LU}}, /* .binaryEncodingId */ + sizeof(UA_X509IdentityToken), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + X509IdentityToken_members /* .members */ +}, +/* IssuedIdentityToken */ +{ + UA_TYPENAME("IssuedIdentityToken") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {938LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {940LU}}, /* .binaryEncodingId */ + sizeof(UA_IssuedIdentityToken), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + IssuedIdentityToken_members /* .members */ +}, +/* ActivateSessionRequest */ +{ + UA_TYPENAME("ActivateSessionRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {465LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {467LU}}, /* .binaryEncodingId */ + sizeof(UA_ActivateSessionRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + ActivateSessionRequest_members /* .members */ +}, +/* ActivateSessionResponse */ +{ + UA_TYPENAME("ActivateSessionResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {468LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {470LU}}, /* .binaryEncodingId */ + sizeof(UA_ActivateSessionResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + ActivateSessionResponse_members /* .members */ +}, +/* CloseSessionRequest */ +{ + UA_TYPENAME("CloseSessionRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {471LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {473LU}}, /* .binaryEncodingId */ + sizeof(UA_CloseSessionRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + CloseSessionRequest_members /* .members */ +}, +/* CloseSessionResponse */ +{ + UA_TYPENAME("CloseSessionResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {474LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {476LU}}, /* .binaryEncodingId */ + sizeof(UA_CloseSessionResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + CloseSessionResponse_members /* .members */ +}, +/* NodeAttributesMask */ +{ + UA_TYPENAME("NodeAttributesMask") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {348LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_NodeAttributesMask), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + NodeAttributesMask_members /* .members */ +}, +/* NodeAttributes */ +{ + UA_TYPENAME("NodeAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {349LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {351LU}}, /* .binaryEncodingId */ + sizeof(UA_NodeAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + NodeAttributes_members /* .members */ +}, +/* ObjectAttributes */ +{ + UA_TYPENAME("ObjectAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {352LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {354LU}}, /* .binaryEncodingId */ + sizeof(UA_ObjectAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + ObjectAttributes_members /* .members */ +}, +/* VariableAttributes */ +{ + UA_TYPENAME("VariableAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {355LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {357LU}}, /* .binaryEncodingId */ + sizeof(UA_VariableAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 13, /* .membersSize */ + VariableAttributes_members /* .members */ +}, +/* MethodAttributes */ +{ + UA_TYPENAME("MethodAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {358LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {360LU}}, /* .binaryEncodingId */ + sizeof(UA_MethodAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + MethodAttributes_members /* .members */ +}, +/* ObjectTypeAttributes */ +{ + UA_TYPENAME("ObjectTypeAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {361LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {363LU}}, /* .binaryEncodingId */ + sizeof(UA_ObjectTypeAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + ObjectTypeAttributes_members /* .members */ +}, +/* VariableTypeAttributes */ +{ + UA_TYPENAME("VariableTypeAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {364LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {366LU}}, /* .binaryEncodingId */ + sizeof(UA_VariableTypeAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 10, /* .membersSize */ + VariableTypeAttributes_members /* .members */ +}, +/* ReferenceTypeAttributes */ +{ + UA_TYPENAME("ReferenceTypeAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {367LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {369LU}}, /* .binaryEncodingId */ + sizeof(UA_ReferenceTypeAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 8, /* .membersSize */ + ReferenceTypeAttributes_members /* .members */ +}, +/* DataTypeAttributes */ +{ + UA_TYPENAME("DataTypeAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {370LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {372LU}}, /* .binaryEncodingId */ + sizeof(UA_DataTypeAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + DataTypeAttributes_members /* .members */ +}, +/* ViewAttributes */ +{ + UA_TYPENAME("ViewAttributes") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {373LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {375LU}}, /* .binaryEncodingId */ + sizeof(UA_ViewAttributes), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + ViewAttributes_members /* .members */ +}, +/* AddNodesItem */ +{ + UA_TYPENAME("AddNodesItem") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {376LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {378LU}}, /* .binaryEncodingId */ + sizeof(UA_AddNodesItem), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + AddNodesItem_members /* .members */ +}, +/* AddNodesResult */ +{ + UA_TYPENAME("AddNodesResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {483LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {485LU}}, /* .binaryEncodingId */ + sizeof(UA_AddNodesResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + AddNodesResult_members /* .members */ +}, +/* AddNodesRequest */ +{ + UA_TYPENAME("AddNodesRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {486LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {488LU}}, /* .binaryEncodingId */ + sizeof(UA_AddNodesRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + AddNodesRequest_members /* .members */ +}, +/* AddNodesResponse */ +{ + UA_TYPENAME("AddNodesResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {489LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {491LU}}, /* .binaryEncodingId */ + sizeof(UA_AddNodesResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + AddNodesResponse_members /* .members */ +}, +/* AddReferencesItem */ +{ + UA_TYPENAME("AddReferencesItem") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {379LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {381LU}}, /* .binaryEncodingId */ + sizeof(UA_AddReferencesItem), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + AddReferencesItem_members /* .members */ +}, +/* AddReferencesRequest */ +{ + UA_TYPENAME("AddReferencesRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {492LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {494LU}}, /* .binaryEncodingId */ + sizeof(UA_AddReferencesRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + AddReferencesRequest_members /* .members */ +}, +/* AddReferencesResponse */ +{ + UA_TYPENAME("AddReferencesResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {495LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {497LU}}, /* .binaryEncodingId */ + sizeof(UA_AddReferencesResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + AddReferencesResponse_members /* .members */ +}, +/* DeleteNodesItem */ +{ + UA_TYPENAME("DeleteNodesItem") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {382LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {384LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteNodesItem), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + DeleteNodesItem_members /* .members */ +}, +/* DeleteNodesRequest */ +{ + UA_TYPENAME("DeleteNodesRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {498LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {500LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteNodesRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + DeleteNodesRequest_members /* .members */ +}, +/* DeleteNodesResponse */ +{ + UA_TYPENAME("DeleteNodesResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {501LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {503LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteNodesResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + DeleteNodesResponse_members /* .members */ +}, +/* DeleteReferencesItem */ +{ + UA_TYPENAME("DeleteReferencesItem") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {385LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {387LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteReferencesItem), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + DeleteReferencesItem_members /* .members */ +}, +/* DeleteReferencesRequest */ +{ + UA_TYPENAME("DeleteReferencesRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {504LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {506LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteReferencesRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + DeleteReferencesRequest_members /* .members */ +}, +/* DeleteReferencesResponse */ +{ + UA_TYPENAME("DeleteReferencesResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {507LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {509LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteReferencesResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + DeleteReferencesResponse_members /* .members */ +}, +/* BrowseDirection */ +{ + UA_TYPENAME("BrowseDirection") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {510LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_BrowseDirection), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + BrowseDirection_members /* .members */ +}, +/* ViewDescription */ +{ + UA_TYPENAME("ViewDescription") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {511LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {513LU}}, /* .binaryEncodingId */ + sizeof(UA_ViewDescription), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + ViewDescription_members /* .members */ +}, +/* BrowseDescription */ +{ + UA_TYPENAME("BrowseDescription") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {514LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {516LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowseDescription), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + BrowseDescription_members /* .members */ +}, +/* BrowseResultMask */ +{ + UA_TYPENAME("BrowseResultMask") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {517LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_BrowseResultMask), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + BrowseResultMask_members /* .members */ +}, +/* ReferenceDescription */ +{ + UA_TYPENAME("ReferenceDescription") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {518LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {520LU}}, /* .binaryEncodingId */ + sizeof(UA_ReferenceDescription), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + ReferenceDescription_members /* .members */ +}, +/* BrowseResult */ +{ + UA_TYPENAME("BrowseResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {522LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {524LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowseResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + BrowseResult_members /* .members */ +}, +/* BrowseRequest */ +{ + UA_TYPENAME("BrowseRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {525LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {527LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowseRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + BrowseRequest_members /* .members */ +}, +/* BrowseResponse */ +{ + UA_TYPENAME("BrowseResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {528LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {530LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowseResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + BrowseResponse_members /* .members */ +}, +/* BrowseNextRequest */ +{ + UA_TYPENAME("BrowseNextRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {531LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {533LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowseNextRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + BrowseNextRequest_members /* .members */ +}, +/* BrowseNextResponse */ +{ + UA_TYPENAME("BrowseNextResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {534LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {536LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowseNextResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + BrowseNextResponse_members /* .members */ +}, +/* RelativePathElement */ +{ + UA_TYPENAME("RelativePathElement") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {537LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {539LU}}, /* .binaryEncodingId */ + sizeof(UA_RelativePathElement), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + RelativePathElement_members /* .members */ +}, +/* RelativePath */ +{ + UA_TYPENAME("RelativePath") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {540LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {542LU}}, /* .binaryEncodingId */ + sizeof(UA_RelativePath), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + RelativePath_members /* .members */ +}, +/* BrowsePath */ +{ + UA_TYPENAME("BrowsePath") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {543LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {545LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowsePath), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + BrowsePath_members /* .members */ +}, +/* BrowsePathTarget */ +{ + UA_TYPENAME("BrowsePathTarget") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {546LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {548LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowsePathTarget), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + BrowsePathTarget_members /* .members */ +}, +/* BrowsePathResult */ +{ + UA_TYPENAME("BrowsePathResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {549LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {551LU}}, /* .binaryEncodingId */ + sizeof(UA_BrowsePathResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + BrowsePathResult_members /* .members */ +}, +/* TranslateBrowsePathsToNodeIdsRequest */ +{ + UA_TYPENAME("TranslateBrowsePathsToNodeIdsRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {552LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {554LU}}, /* .binaryEncodingId */ + sizeof(UA_TranslateBrowsePathsToNodeIdsRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + TranslateBrowsePathsToNodeIdsRequest_members /* .members */ +}, +/* TranslateBrowsePathsToNodeIdsResponse */ +{ + UA_TYPENAME("TranslateBrowsePathsToNodeIdsResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {555LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {557LU}}, /* .binaryEncodingId */ + sizeof(UA_TranslateBrowsePathsToNodeIdsResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + TranslateBrowsePathsToNodeIdsResponse_members /* .members */ +}, +/* RegisterNodesRequest */ +{ + UA_TYPENAME("RegisterNodesRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {558LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {560LU}}, /* .binaryEncodingId */ + sizeof(UA_RegisterNodesRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + RegisterNodesRequest_members /* .members */ +}, +/* RegisterNodesResponse */ +{ + UA_TYPENAME("RegisterNodesResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {561LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {563LU}}, /* .binaryEncodingId */ + sizeof(UA_RegisterNodesResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + RegisterNodesResponse_members /* .members */ +}, +/* UnregisterNodesRequest */ +{ + UA_TYPENAME("UnregisterNodesRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {564LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {566LU}}, /* .binaryEncodingId */ + sizeof(UA_UnregisterNodesRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + UnregisterNodesRequest_members /* .members */ +}, +/* UnregisterNodesResponse */ +{ + UA_TYPENAME("UnregisterNodesResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {567LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {569LU}}, /* .binaryEncodingId */ + sizeof(UA_UnregisterNodesResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + UnregisterNodesResponse_members /* .members */ +}, +/* FilterOperator */ +{ + UA_TYPENAME("FilterOperator") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {576LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_FilterOperator), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + FilterOperator_members /* .members */ +}, +/* ContentFilterElement */ +{ + UA_TYPENAME("ContentFilterElement") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {583LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {585LU}}, /* .binaryEncodingId */ + sizeof(UA_ContentFilterElement), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + ContentFilterElement_members /* .members */ +}, +/* ContentFilter */ +{ + UA_TYPENAME("ContentFilter") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {586LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {588LU}}, /* .binaryEncodingId */ + sizeof(UA_ContentFilter), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + ContentFilter_members /* .members */ +}, +/* ElementOperand */ +{ + UA_TYPENAME("ElementOperand") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {592LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {594LU}}, /* .binaryEncodingId */ + sizeof(UA_ElementOperand), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + ElementOperand_members /* .members */ +}, +/* LiteralOperand */ +{ + UA_TYPENAME("LiteralOperand") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {595LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {597LU}}, /* .binaryEncodingId */ + sizeof(UA_LiteralOperand), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + LiteralOperand_members /* .members */ +}, +/* AttributeOperand */ +{ + UA_TYPENAME("AttributeOperand") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {598LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {600LU}}, /* .binaryEncodingId */ + sizeof(UA_AttributeOperand), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + AttributeOperand_members /* .members */ +}, +/* SimpleAttributeOperand */ +{ + UA_TYPENAME("SimpleAttributeOperand") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {601LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {603LU}}, /* .binaryEncodingId */ + sizeof(UA_SimpleAttributeOperand), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + SimpleAttributeOperand_members /* .members */ +}, +/* ContentFilterElementResult */ +{ + UA_TYPENAME("ContentFilterElementResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {604LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {606LU}}, /* .binaryEncodingId */ + sizeof(UA_ContentFilterElementResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + ContentFilterElementResult_members /* .members */ +}, +/* ContentFilterResult */ +{ + UA_TYPENAME("ContentFilterResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {607LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {609LU}}, /* .binaryEncodingId */ + sizeof(UA_ContentFilterResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + ContentFilterResult_members /* .members */ +}, +/* TimestampsToReturn */ +{ + UA_TYPENAME("TimestampsToReturn") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {625LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_TimestampsToReturn), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + TimestampsToReturn_members /* .members */ +}, +/* ReadValueId */ +{ + UA_TYPENAME("ReadValueId") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {626LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {628LU}}, /* .binaryEncodingId */ + sizeof(UA_ReadValueId), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + ReadValueId_members /* .members */ +}, +/* ReadRequest */ +{ + UA_TYPENAME("ReadRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {629LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {631LU}}, /* .binaryEncodingId */ + sizeof(UA_ReadRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + ReadRequest_members /* .members */ +}, +/* ReadResponse */ +{ + UA_TYPENAME("ReadResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {632LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {634LU}}, /* .binaryEncodingId */ + sizeof(UA_ReadResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + ReadResponse_members /* .members */ +}, +/* WriteValue */ +{ + UA_TYPENAME("WriteValue") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {668LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {670LU}}, /* .binaryEncodingId */ + sizeof(UA_WriteValue), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + WriteValue_members /* .members */ +}, +/* WriteRequest */ +{ + UA_TYPENAME("WriteRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {671LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {673LU}}, /* .binaryEncodingId */ + sizeof(UA_WriteRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + WriteRequest_members /* .members */ +}, +/* WriteResponse */ +{ + UA_TYPENAME("WriteResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {674LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {676LU}}, /* .binaryEncodingId */ + sizeof(UA_WriteResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + WriteResponse_members /* .members */ +}, +/* CallMethodRequest */ +{ + UA_TYPENAME("CallMethodRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {704LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {706LU}}, /* .binaryEncodingId */ + sizeof(UA_CallMethodRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + CallMethodRequest_members /* .members */ +}, +/* CallMethodResult */ +{ + UA_TYPENAME("CallMethodResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {707LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {709LU}}, /* .binaryEncodingId */ + sizeof(UA_CallMethodResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + CallMethodResult_members /* .members */ +}, +/* CallRequest */ +{ + UA_TYPENAME("CallRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {710LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {712LU}}, /* .binaryEncodingId */ + sizeof(UA_CallRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + CallRequest_members /* .members */ +}, +/* CallResponse */ +{ + UA_TYPENAME("CallResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {713LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {715LU}}, /* .binaryEncodingId */ + sizeof(UA_CallResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + CallResponse_members /* .members */ +}, +/* MonitoringMode */ +{ + UA_TYPENAME("MonitoringMode") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {716LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_MonitoringMode), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + MonitoringMode_members /* .members */ +}, +/* DataChangeTrigger */ +{ + UA_TYPENAME("DataChangeTrigger") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {717LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_DataChangeTrigger), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + DataChangeTrigger_members /* .members */ +}, +/* DeadbandType */ +{ + UA_TYPENAME("DeadbandType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {718LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_DeadbandType), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + DeadbandType_members /* .members */ +}, +/* DataChangeFilter */ +{ + UA_TYPENAME("DataChangeFilter") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {722LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {724LU}}, /* .binaryEncodingId */ + sizeof(UA_DataChangeFilter), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + DataChangeFilter_members /* .members */ +}, +/* EventFilter */ +{ + UA_TYPENAME("EventFilter") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {725LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {727LU}}, /* .binaryEncodingId */ + sizeof(UA_EventFilter), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + EventFilter_members /* .members */ +}, +/* AggregateConfiguration */ +{ + UA_TYPENAME("AggregateConfiguration") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {948LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {950LU}}, /* .binaryEncodingId */ + sizeof(UA_AggregateConfiguration), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + AggregateConfiguration_members /* .members */ +}, +/* AggregateFilter */ +{ + UA_TYPENAME("AggregateFilter") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {728LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {730LU}}, /* .binaryEncodingId */ + sizeof(UA_AggregateFilter), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + AggregateFilter_members /* .members */ +}, +/* EventFilterResult */ +{ + UA_TYPENAME("EventFilterResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {734LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {736LU}}, /* .binaryEncodingId */ + sizeof(UA_EventFilterResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + EventFilterResult_members /* .members */ +}, +/* MonitoringParameters */ +{ + UA_TYPENAME("MonitoringParameters") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {740LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {742LU}}, /* .binaryEncodingId */ + sizeof(UA_MonitoringParameters), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + MonitoringParameters_members /* .members */ +}, +/* MonitoredItemCreateRequest */ +{ + UA_TYPENAME("MonitoredItemCreateRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {743LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {745LU}}, /* .binaryEncodingId */ + sizeof(UA_MonitoredItemCreateRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + MonitoredItemCreateRequest_members /* .members */ +}, +/* MonitoredItemCreateResult */ +{ + UA_TYPENAME("MonitoredItemCreateResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {746LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {748LU}}, /* .binaryEncodingId */ + sizeof(UA_MonitoredItemCreateResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + MonitoredItemCreateResult_members /* .members */ +}, +/* CreateMonitoredItemsRequest */ +{ + UA_TYPENAME("CreateMonitoredItemsRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {749LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {751LU}}, /* .binaryEncodingId */ + sizeof(UA_CreateMonitoredItemsRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + CreateMonitoredItemsRequest_members /* .members */ +}, +/* CreateMonitoredItemsResponse */ +{ + UA_TYPENAME("CreateMonitoredItemsResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {752LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {754LU}}, /* .binaryEncodingId */ + sizeof(UA_CreateMonitoredItemsResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + CreateMonitoredItemsResponse_members /* .members */ +}, +/* MonitoredItemModifyRequest */ +{ + UA_TYPENAME("MonitoredItemModifyRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {755LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {757LU}}, /* .binaryEncodingId */ + sizeof(UA_MonitoredItemModifyRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + MonitoredItemModifyRequest_members /* .members */ +}, +/* MonitoredItemModifyResult */ +{ + UA_TYPENAME("MonitoredItemModifyResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {758LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {760LU}}, /* .binaryEncodingId */ + sizeof(UA_MonitoredItemModifyResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + MonitoredItemModifyResult_members /* .members */ +}, +/* ModifyMonitoredItemsRequest */ +{ + UA_TYPENAME("ModifyMonitoredItemsRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {761LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {763LU}}, /* .binaryEncodingId */ + sizeof(UA_ModifyMonitoredItemsRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + ModifyMonitoredItemsRequest_members /* .members */ +}, +/* ModifyMonitoredItemsResponse */ +{ + UA_TYPENAME("ModifyMonitoredItemsResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {764LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {766LU}}, /* .binaryEncodingId */ + sizeof(UA_ModifyMonitoredItemsResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + ModifyMonitoredItemsResponse_members /* .members */ +}, +/* SetMonitoringModeRequest */ +{ + UA_TYPENAME("SetMonitoringModeRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {767LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {769LU}}, /* .binaryEncodingId */ + sizeof(UA_SetMonitoringModeRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + SetMonitoringModeRequest_members /* .members */ +}, +/* SetMonitoringModeResponse */ +{ + UA_TYPENAME("SetMonitoringModeResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {770LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {772LU}}, /* .binaryEncodingId */ + sizeof(UA_SetMonitoringModeResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + SetMonitoringModeResponse_members /* .members */ +}, +/* SetTriggeringRequest */ +{ + UA_TYPENAME("SetTriggeringRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {773LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {775LU}}, /* .binaryEncodingId */ + sizeof(UA_SetTriggeringRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + SetTriggeringRequest_members /* .members */ +}, +/* SetTriggeringResponse */ +{ + UA_TYPENAME("SetTriggeringResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {776LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {778LU}}, /* .binaryEncodingId */ + sizeof(UA_SetTriggeringResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + SetTriggeringResponse_members /* .members */ +}, +/* DeleteMonitoredItemsRequest */ +{ + UA_TYPENAME("DeleteMonitoredItemsRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {779LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {781LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteMonitoredItemsRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + DeleteMonitoredItemsRequest_members /* .members */ +}, +/* DeleteMonitoredItemsResponse */ +{ + UA_TYPENAME("DeleteMonitoredItemsResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {782LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {784LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteMonitoredItemsResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + DeleteMonitoredItemsResponse_members /* .members */ +}, +/* CreateSubscriptionRequest */ +{ + UA_TYPENAME("CreateSubscriptionRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {785LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {787LU}}, /* .binaryEncodingId */ + sizeof(UA_CreateSubscriptionRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + CreateSubscriptionRequest_members /* .members */ +}, +/* CreateSubscriptionResponse */ +{ + UA_TYPENAME("CreateSubscriptionResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {788LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {790LU}}, /* .binaryEncodingId */ + sizeof(UA_CreateSubscriptionResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + CreateSubscriptionResponse_members /* .members */ +}, +/* ModifySubscriptionRequest */ +{ + UA_TYPENAME("ModifySubscriptionRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {791LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {793LU}}, /* .binaryEncodingId */ + sizeof(UA_ModifySubscriptionRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + ModifySubscriptionRequest_members /* .members */ +}, +/* ModifySubscriptionResponse */ +{ + UA_TYPENAME("ModifySubscriptionResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {794LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {796LU}}, /* .binaryEncodingId */ + sizeof(UA_ModifySubscriptionResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + ModifySubscriptionResponse_members /* .members */ +}, +/* SetPublishingModeRequest */ +{ + UA_TYPENAME("SetPublishingModeRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {797LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {799LU}}, /* .binaryEncodingId */ + sizeof(UA_SetPublishingModeRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + SetPublishingModeRequest_members /* .members */ +}, +/* SetPublishingModeResponse */ +{ + UA_TYPENAME("SetPublishingModeResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {800LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {802LU}}, /* .binaryEncodingId */ + sizeof(UA_SetPublishingModeResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + SetPublishingModeResponse_members /* .members */ +}, +/* NotificationMessage */ +{ + UA_TYPENAME("NotificationMessage") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {803LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {805LU}}, /* .binaryEncodingId */ + sizeof(UA_NotificationMessage), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + NotificationMessage_members /* .members */ +}, +/* MonitoredItemNotification */ +{ + UA_TYPENAME("MonitoredItemNotification") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {806LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {808LU}}, /* .binaryEncodingId */ + sizeof(UA_MonitoredItemNotification), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + MonitoredItemNotification_members /* .members */ +}, +/* EventFieldList */ +{ + UA_TYPENAME("EventFieldList") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {917LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {919LU}}, /* .binaryEncodingId */ + sizeof(UA_EventFieldList), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + EventFieldList_members /* .members */ +}, +/* StatusChangeNotification */ +{ + UA_TYPENAME("StatusChangeNotification") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {818LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {820LU}}, /* .binaryEncodingId */ + sizeof(UA_StatusChangeNotification), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + StatusChangeNotification_members /* .members */ +}, +/* SubscriptionAcknowledgement */ +{ + UA_TYPENAME("SubscriptionAcknowledgement") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {821LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {823LU}}, /* .binaryEncodingId */ + sizeof(UA_SubscriptionAcknowledgement), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + SubscriptionAcknowledgement_members /* .members */ +}, +/* PublishRequest */ +{ + UA_TYPENAME("PublishRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {824LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {826LU}}, /* .binaryEncodingId */ + sizeof(UA_PublishRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + PublishRequest_members /* .members */ +}, +/* PublishResponse */ +{ + UA_TYPENAME("PublishResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {827LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {829LU}}, /* .binaryEncodingId */ + sizeof(UA_PublishResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 7, /* .membersSize */ + PublishResponse_members /* .members */ +}, +/* RepublishRequest */ +{ + UA_TYPENAME("RepublishRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {830LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {832LU}}, /* .binaryEncodingId */ + sizeof(UA_RepublishRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + RepublishRequest_members /* .members */ +}, +/* RepublishResponse */ +{ + UA_TYPENAME("RepublishResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {833LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {835LU}}, /* .binaryEncodingId */ + sizeof(UA_RepublishResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + RepublishResponse_members /* .members */ +}, +/* TransferResult */ +{ + UA_TYPENAME("TransferResult") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {836LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {838LU}}, /* .binaryEncodingId */ + sizeof(UA_TransferResult), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + TransferResult_members /* .members */ +}, +/* TransferSubscriptionsRequest */ +{ + UA_TYPENAME("TransferSubscriptionsRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {839LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {841LU}}, /* .binaryEncodingId */ + sizeof(UA_TransferSubscriptionsRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + TransferSubscriptionsRequest_members /* .members */ +}, +/* TransferSubscriptionsResponse */ +{ + UA_TYPENAME("TransferSubscriptionsResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {842LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {844LU}}, /* .binaryEncodingId */ + sizeof(UA_TransferSubscriptionsResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + TransferSubscriptionsResponse_members /* .members */ +}, +/* DeleteSubscriptionsRequest */ +{ + UA_TYPENAME("DeleteSubscriptionsRequest") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {845LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {847LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteSubscriptionsRequest), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + DeleteSubscriptionsRequest_members /* .members */ +}, +/* DeleteSubscriptionsResponse */ +{ + UA_TYPENAME("DeleteSubscriptionsResponse") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {848LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {850LU}}, /* .binaryEncodingId */ + sizeof(UA_DeleteSubscriptionsResponse), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + DeleteSubscriptionsResponse_members /* .members */ +}, +/* BuildInfo */ +{ + UA_TYPENAME("BuildInfo") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {338LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {340LU}}, /* .binaryEncodingId */ + sizeof(UA_BuildInfo), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + BuildInfo_members /* .members */ +}, +/* RedundancySupport */ +{ + UA_TYPENAME("RedundancySupport") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {851LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_RedundancySupport), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + RedundancySupport_members /* .members */ +}, +/* ServerState */ +{ + UA_TYPENAME("ServerState") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {852LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_ServerState), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + ServerState_members /* .members */ +}, +/* ServerDiagnosticsSummaryDataType */ +{ + UA_TYPENAME("ServerDiagnosticsSummaryDataType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {859LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {861LU}}, /* .binaryEncodingId */ + sizeof(UA_ServerDiagnosticsSummaryDataType), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 12, /* .membersSize */ + ServerDiagnosticsSummaryDataType_members /* .members */ +}, +/* ServerStatusDataType */ +{ + UA_TYPENAME("ServerStatusDataType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {862LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {864LU}}, /* .binaryEncodingId */ + sizeof(UA_ServerStatusDataType), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + ServerStatusDataType_members /* .members */ +}, +/* Range */ +{ + UA_TYPENAME("Range") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {884LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {886LU}}, /* .binaryEncodingId */ + sizeof(UA_Range), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + Range_members /* .members */ +}, +/* EUInformation */ +{ + UA_TYPENAME("EUInformation") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {887LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {889LU}}, /* .binaryEncodingId */ + sizeof(UA_EUInformation), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 4, /* .membersSize */ + EUInformation_members /* .members */ +}, +/* AxisScaleEnumeration */ +{ + UA_TYPENAME("AxisScaleEnumeration") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {12077LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_AxisScaleEnumeration), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + AxisScaleEnumeration_members /* .members */ +}, +/* ComplexNumberType */ +{ + UA_TYPENAME("ComplexNumberType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {12171LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {12181LU}}, /* .binaryEncodingId */ + sizeof(UA_ComplexNumberType), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + ComplexNumberType_members /* .members */ +}, +/* DoubleComplexNumberType */ +{ + UA_TYPENAME("DoubleComplexNumberType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {12172LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {12182LU}}, /* .binaryEncodingId */ + sizeof(UA_DoubleComplexNumberType), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + DoubleComplexNumberType_members /* .members */ +}, +/* AxisInformation */ +{ + UA_TYPENAME("AxisInformation") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {12079LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {12089LU}}, /* .binaryEncodingId */ + sizeof(UA_AxisInformation), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + AxisInformation_members /* .members */ +}, +/* XVType */ +{ + UA_TYPENAME("XVType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {12080LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {12090LU}}, /* .binaryEncodingId */ + sizeof(UA_XVType), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + XVType_members /* .members */ +}, +/* EnumDefinition */ +{ + UA_TYPENAME("EnumDefinition") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {100LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {123LU}}, /* .binaryEncodingId */ + sizeof(UA_EnumDefinition), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + EnumDefinition_members /* .members */ +}, +/* DataChangeNotification */ +{ + UA_TYPENAME("DataChangeNotification") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {809LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {811LU}}, /* .binaryEncodingId */ + sizeof(UA_DataChangeNotification), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + DataChangeNotification_members /* .members */ +}, +/* EventNotificationList */ +{ + UA_TYPENAME("EventNotificationList") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {914LU}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {916LU}}, /* .binaryEncodingId */ + sizeof(UA_EventNotificationList), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 1, /* .membersSize */ + EventNotificationList_members /* .members */ +}, +}; + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/transport_generated.c" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + + +/* MessageType */ +#define MessageType_members NULL + +/* ChunkType */ +#define ChunkType_members NULL + +/* TcpMessageHeader */ +static UA_DataTypeMember TcpMessageHeader_members[2] = { +{ + UA_TYPENAME("MessageTypeAndChunkType") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MessageSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpMessageHeader, messageSize) - offsetof(UA_TcpMessageHeader, messageTypeAndChunkType) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* TcpHelloMessage */ +static UA_DataTypeMember TcpHelloMessage_members[6] = { +{ + UA_TYPENAME("ProtocolVersion") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReceiveBufferSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpHelloMessage, receiveBufferSize) - offsetof(UA_TcpHelloMessage, protocolVersion) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SendBufferSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpHelloMessage, sendBufferSize) - offsetof(UA_TcpHelloMessage, receiveBufferSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxMessageSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpHelloMessage, maxMessageSize) - offsetof(UA_TcpHelloMessage, sendBufferSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxChunkCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpHelloMessage, maxChunkCount) - offsetof(UA_TcpHelloMessage, maxMessageSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("EndpointUrl") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_TcpHelloMessage, endpointUrl) - offsetof(UA_TcpHelloMessage, maxChunkCount) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* TcpAcknowledgeMessage */ +static UA_DataTypeMember TcpAcknowledgeMessage_members[5] = { +{ + UA_TYPENAME("ProtocolVersion") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReceiveBufferSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpAcknowledgeMessage, receiveBufferSize) - offsetof(UA_TcpAcknowledgeMessage, protocolVersion) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SendBufferSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpAcknowledgeMessage, sendBufferSize) - offsetof(UA_TcpAcknowledgeMessage, receiveBufferSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxMessageSize") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpAcknowledgeMessage, maxMessageSize) - offsetof(UA_TcpAcknowledgeMessage, sendBufferSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("MaxChunkCount") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_TcpAcknowledgeMessage, maxChunkCount) - offsetof(UA_TcpAcknowledgeMessage, maxMessageSize) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* TcpErrorMessage */ +static UA_DataTypeMember TcpErrorMessage_members[2] = { +{ + UA_TYPENAME("Error") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("Reason") /* .memberName */ + &UA_TYPES[UA_TYPES_STRING], /* .memberType */ + offsetof(UA_TcpErrorMessage, reason) - offsetof(UA_TcpErrorMessage, error) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* AsymmetricAlgorithmSecurityHeader */ +static UA_DataTypeMember AsymmetricAlgorithmSecurityHeader_members[3] = { +{ + UA_TYPENAME("SecurityPolicyUri") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("SenderCertificate") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_AsymmetricAlgorithmSecurityHeader, senderCertificate) - offsetof(UA_AsymmetricAlgorithmSecurityHeader, securityPolicyUri) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("ReceiverCertificateThumbprint") /* .memberName */ + &UA_TYPES[UA_TYPES_BYTESTRING], /* .memberType */ + offsetof(UA_AsymmetricAlgorithmSecurityHeader, receiverCertificateThumbprint) - offsetof(UA_AsymmetricAlgorithmSecurityHeader, senderCertificate) - sizeof(UA_ByteString), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; + +/* SequenceHeader */ +static UA_DataTypeMember SequenceHeader_members[2] = { +{ + UA_TYPENAME("SequenceNumber") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + 0, /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +}, +{ + UA_TYPENAME("RequestId") /* .memberName */ + &UA_TYPES[UA_TYPES_UINT32], /* .memberType */ + offsetof(UA_SequenceHeader, requestId) - offsetof(UA_SequenceHeader, sequenceNumber) - sizeof(UA_UInt32), /* .padding */ + false, /* .isArray */ + false /* .isOptional */ +},}; +const UA_DataType UA_TRANSPORT[UA_TRANSPORT_COUNT] = { +/* MessageType */ +{ + UA_TYPENAME("MessageType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_MessageType), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + MessageType_members /* .members */ +}, +/* ChunkType */ +{ + UA_TYPENAME("ChunkType") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_ChunkType), /* .memSize */ + UA_DATATYPEKIND_ENUM, /* .typeKind */ + true, /* .pointerFree */ + UA_BINARY_OVERLAYABLE_INTEGER, /* .overlayable */ + 0, /* .membersSize */ + ChunkType_members /* .members */ +}, +/* TcpMessageHeader */ +{ + UA_TYPENAME("TcpMessageHeader") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_TcpMessageHeader), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + TcpMessageHeader_members /* .members */ +}, +/* TcpHelloMessage */ +{ + UA_TYPENAME("TcpHelloMessage") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_TcpHelloMessage), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 6, /* .membersSize */ + TcpHelloMessage_members /* .members */ +}, +/* TcpAcknowledgeMessage */ +{ + UA_TYPENAME("TcpAcknowledgeMessage") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_TcpAcknowledgeMessage), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 5, /* .membersSize */ + TcpAcknowledgeMessage_members /* .members */ +}, +/* TcpErrorMessage */ +{ + UA_TYPENAME("TcpErrorMessage") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_TcpErrorMessage), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + TcpErrorMessage_members /* .members */ +}, +/* AsymmetricAlgorithmSecurityHeader */ +{ + UA_TYPENAME("AsymmetricAlgorithmSecurityHeader") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_AsymmetricAlgorithmSecurityHeader), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + false, /* .pointerFree */ + false, /* .overlayable */ + 3, /* .membersSize */ + AsymmetricAlgorithmSecurityHeader_members /* .members */ +}, +/* SequenceHeader */ +{ + UA_TYPENAME("SequenceHeader") /* .typeName */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .typeId */ + {0, UA_NODEIDTYPE_NUMERIC, {0}}, /* .binaryEncodingId */ + sizeof(UA_SequenceHeader), /* .memSize */ + UA_DATATYPEKIND_STRUCTURE, /* .typeKind */ + true, /* .pointerFree */ + false, /* .overlayable */ + 2, /* .membersSize */ + SequenceHeader_members /* .members */ +}, +}; + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/statuscodes.c" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + + +typedef struct { + UA_StatusCode code; + const char *name; +} UA_StatusCodeName; + +#ifndef UA_ENABLE_STATUSCODE_DESCRIPTIONS +static const char * emptyStatusCodeName = ""; +const char * UA_StatusCode_name(UA_StatusCode code) { + return emptyStatusCodeName; +} +#else +static const size_t statusCodeDescriptionsSize = 252; +static const UA_StatusCodeName statusCodeDescriptions[252] = { + {UA_STATUSCODE_GOOD, "Good"}, + {UA_STATUSCODE_GOOD, "Good"}, + {UA_STATUSCODE_UNCERTAIN, "Uncertain"}, + {UA_STATUSCODE_BAD, "Bad"}, + {UA_STATUSCODE_BADUNEXPECTEDERROR, "BadUnexpectedError"}, + {UA_STATUSCODE_BADINTERNALERROR, "BadInternalError"}, + {UA_STATUSCODE_BADOUTOFMEMORY, "BadOutOfMemory"}, + {UA_STATUSCODE_BADRESOURCEUNAVAILABLE, "BadResourceUnavailable"}, + {UA_STATUSCODE_BADCOMMUNICATIONERROR, "BadCommunicationError"}, + {UA_STATUSCODE_BADENCODINGERROR, "BadEncodingError"}, + {UA_STATUSCODE_BADDECODINGERROR, "BadDecodingError"}, + {UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED, "BadEncodingLimitsExceeded"}, + {UA_STATUSCODE_BADREQUESTTOOLARGE, "BadRequestTooLarge"}, + {UA_STATUSCODE_BADRESPONSETOOLARGE, "BadResponseTooLarge"}, + {UA_STATUSCODE_BADUNKNOWNRESPONSE, "BadUnknownResponse"}, + {UA_STATUSCODE_BADTIMEOUT, "BadTimeout"}, + {UA_STATUSCODE_BADSERVICEUNSUPPORTED, "BadServiceUnsupported"}, + {UA_STATUSCODE_BADSHUTDOWN, "BadShutdown"}, + {UA_STATUSCODE_BADSERVERNOTCONNECTED, "BadServerNotConnected"}, + {UA_STATUSCODE_BADSERVERHALTED, "BadServerHalted"}, + {UA_STATUSCODE_BADNOTHINGTODO, "BadNothingToDo"}, + {UA_STATUSCODE_BADTOOMANYOPERATIONS, "BadTooManyOperations"}, + {UA_STATUSCODE_BADTOOMANYMONITOREDITEMS, "BadTooManyMonitoredItems"}, + {UA_STATUSCODE_BADDATATYPEIDUNKNOWN, "BadDataTypeIdUnknown"}, + {UA_STATUSCODE_BADCERTIFICATEINVALID, "BadCertificateInvalid"}, + {UA_STATUSCODE_BADSECURITYCHECKSFAILED, "BadSecurityChecksFailed"}, + {UA_STATUSCODE_BADCERTIFICATEPOLICYCHECKFAILED, "BadCertificatePolicyCheckFailed"}, + {UA_STATUSCODE_BADCERTIFICATETIMEINVALID, "BadCertificateTimeInvalid"}, + {UA_STATUSCODE_BADCERTIFICATEISSUERTIMEINVALID, "BadCertificateIssuerTimeInvalid"}, + {UA_STATUSCODE_BADCERTIFICATEHOSTNAMEINVALID, "BadCertificateHostNameInvalid"}, + {UA_STATUSCODE_BADCERTIFICATEURIINVALID, "BadCertificateUriInvalid"}, + {UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED, "BadCertificateUseNotAllowed"}, + {UA_STATUSCODE_BADCERTIFICATEISSUERUSENOTALLOWED, "BadCertificateIssuerUseNotAllowed"}, + {UA_STATUSCODE_BADCERTIFICATEUNTRUSTED, "BadCertificateUntrusted"}, + {UA_STATUSCODE_BADCERTIFICATEREVOCATIONUNKNOWN, "BadCertificateRevocationUnknown"}, + {UA_STATUSCODE_BADCERTIFICATEISSUERREVOCATIONUNKNOWN, "BadCertificateIssuerRevocationUnknown"}, + {UA_STATUSCODE_BADCERTIFICATEREVOKED, "BadCertificateRevoked"}, + {UA_STATUSCODE_BADCERTIFICATEISSUERREVOKED, "BadCertificateIssuerRevoked"}, + {UA_STATUSCODE_BADCERTIFICATECHAININCOMPLETE, "BadCertificateChainIncomplete"}, + {UA_STATUSCODE_BADUSERACCESSDENIED, "BadUserAccessDenied"}, + {UA_STATUSCODE_BADIDENTITYTOKENINVALID, "BadIdentityTokenInvalid"}, + {UA_STATUSCODE_BADIDENTITYTOKENREJECTED, "BadIdentityTokenRejected"}, + {UA_STATUSCODE_BADSECURECHANNELIDINVALID, "BadSecureChannelIdInvalid"}, + {UA_STATUSCODE_BADINVALIDTIMESTAMP, "BadInvalidTimestamp"}, + {UA_STATUSCODE_BADNONCEINVALID, "BadNonceInvalid"}, + {UA_STATUSCODE_BADSESSIONIDINVALID, "BadSessionIdInvalid"}, + {UA_STATUSCODE_BADSESSIONCLOSED, "BadSessionClosed"}, + {UA_STATUSCODE_BADSESSIONNOTACTIVATED, "BadSessionNotActivated"}, + {UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID, "BadSubscriptionIdInvalid"}, + {UA_STATUSCODE_BADREQUESTHEADERINVALID, "BadRequestHeaderInvalid"}, + {UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID, "BadTimestampsToReturnInvalid"}, + {UA_STATUSCODE_BADREQUESTCANCELLEDBYCLIENT, "BadRequestCancelledByClient"}, + {UA_STATUSCODE_BADTOOMANYARGUMENTS, "BadTooManyArguments"}, + {UA_STATUSCODE_BADLICENSEEXPIRED, "BadLicenseExpired"}, + {UA_STATUSCODE_BADLICENSELIMITSEXCEEDED, "BadLicenseLimitsExceeded"}, + {UA_STATUSCODE_BADLICENSENOTAVAILABLE, "BadLicenseNotAvailable"}, + {UA_STATUSCODE_GOODSUBSCRIPTIONTRANSFERRED, "GoodSubscriptionTransferred"}, + {UA_STATUSCODE_GOODCOMPLETESASYNCHRONOUSLY, "GoodCompletesAsynchronously"}, + {UA_STATUSCODE_GOODOVERLOAD, "GoodOverload"}, + {UA_STATUSCODE_GOODCLAMPED, "GoodClamped"}, + {UA_STATUSCODE_BADNOCOMMUNICATION, "BadNoCommunication"}, + {UA_STATUSCODE_BADWAITINGFORINITIALDATA, "BadWaitingForInitialData"}, + {UA_STATUSCODE_BADNODEIDINVALID, "BadNodeIdInvalid"}, + {UA_STATUSCODE_BADNODEIDUNKNOWN, "BadNodeIdUnknown"}, + {UA_STATUSCODE_BADATTRIBUTEIDINVALID, "BadAttributeIdInvalid"}, + {UA_STATUSCODE_BADINDEXRANGEINVALID, "BadIndexRangeInvalid"}, + {UA_STATUSCODE_BADINDEXRANGENODATA, "BadIndexRangeNoData"}, + {UA_STATUSCODE_BADDATAENCODINGINVALID, "BadDataEncodingInvalid"}, + {UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED, "BadDataEncodingUnsupported"}, + {UA_STATUSCODE_BADNOTREADABLE, "BadNotReadable"}, + {UA_STATUSCODE_BADNOTWRITABLE, "BadNotWritable"}, + {UA_STATUSCODE_BADOUTOFRANGE, "BadOutOfRange"}, + {UA_STATUSCODE_BADNOTSUPPORTED, "BadNotSupported"}, + {UA_STATUSCODE_BADNOTFOUND, "BadNotFound"}, + {UA_STATUSCODE_BADOBJECTDELETED, "BadObjectDeleted"}, + {UA_STATUSCODE_BADNOTIMPLEMENTED, "BadNotImplemented"}, + {UA_STATUSCODE_BADMONITORINGMODEINVALID, "BadMonitoringModeInvalid"}, + {UA_STATUSCODE_BADMONITOREDITEMIDINVALID, "BadMonitoredItemIdInvalid"}, + {UA_STATUSCODE_BADMONITOREDITEMFILTERINVALID, "BadMonitoredItemFilterInvalid"}, + {UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED, "BadMonitoredItemFilterUnsupported"}, + {UA_STATUSCODE_BADFILTERNOTALLOWED, "BadFilterNotAllowed"}, + {UA_STATUSCODE_BADSTRUCTUREMISSING, "BadStructureMissing"}, + {UA_STATUSCODE_BADEVENTFILTERINVALID, "BadEventFilterInvalid"}, + {UA_STATUSCODE_BADCONTENTFILTERINVALID, "BadContentFilterInvalid"}, + {UA_STATUSCODE_BADFILTEROPERATORINVALID, "BadFilterOperatorInvalid"}, + {UA_STATUSCODE_BADFILTEROPERATORUNSUPPORTED, "BadFilterOperatorUnsupported"}, + {UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH, "BadFilterOperandCountMismatch"}, + {UA_STATUSCODE_BADFILTEROPERANDINVALID, "BadFilterOperandInvalid"}, + {UA_STATUSCODE_BADFILTERELEMENTINVALID, "BadFilterElementInvalid"}, + {UA_STATUSCODE_BADFILTERLITERALINVALID, "BadFilterLiteralInvalid"}, + {UA_STATUSCODE_BADCONTINUATIONPOINTINVALID, "BadContinuationPointInvalid"}, + {UA_STATUSCODE_BADNOCONTINUATIONPOINTS, "BadNoContinuationPoints"}, + {UA_STATUSCODE_BADREFERENCETYPEIDINVALID, "BadReferenceTypeIdInvalid"}, + {UA_STATUSCODE_BADBROWSEDIRECTIONINVALID, "BadBrowseDirectionInvalid"}, + {UA_STATUSCODE_BADNODENOTINVIEW, "BadNodeNotInView"}, + {UA_STATUSCODE_BADNUMERICOVERFLOW, "BadNumericOverflow"}, + {UA_STATUSCODE_BADSERVERURIINVALID, "BadServerUriInvalid"}, + {UA_STATUSCODE_BADSERVERNAMEMISSING, "BadServerNameMissing"}, + {UA_STATUSCODE_BADDISCOVERYURLMISSING, "BadDiscoveryUrlMissing"}, + {UA_STATUSCODE_BADSEMPAHOREFILEMISSING, "BadSempahoreFileMissing"}, + {UA_STATUSCODE_BADREQUESTTYPEINVALID, "BadRequestTypeInvalid"}, + {UA_STATUSCODE_BADSECURITYMODEREJECTED, "BadSecurityModeRejected"}, + {UA_STATUSCODE_BADSECURITYPOLICYREJECTED, "BadSecurityPolicyRejected"}, + {UA_STATUSCODE_BADTOOMANYSESSIONS, "BadTooManySessions"}, + {UA_STATUSCODE_BADUSERSIGNATUREINVALID, "BadUserSignatureInvalid"}, + {UA_STATUSCODE_BADAPPLICATIONSIGNATUREINVALID, "BadApplicationSignatureInvalid"}, + {UA_STATUSCODE_BADNOVALIDCERTIFICATES, "BadNoValidCertificates"}, + {UA_STATUSCODE_BADIDENTITYCHANGENOTSUPPORTED, "BadIdentityChangeNotSupported"}, + {UA_STATUSCODE_BADREQUESTCANCELLEDBYREQUEST, "BadRequestCancelledByRequest"}, + {UA_STATUSCODE_BADPARENTNODEIDINVALID, "BadParentNodeIdInvalid"}, + {UA_STATUSCODE_BADREFERENCENOTALLOWED, "BadReferenceNotAllowed"}, + {UA_STATUSCODE_BADNODEIDREJECTED, "BadNodeIdRejected"}, + {UA_STATUSCODE_BADNODEIDEXISTS, "BadNodeIdExists"}, + {UA_STATUSCODE_BADNODECLASSINVALID, "BadNodeClassInvalid"}, + {UA_STATUSCODE_BADBROWSENAMEINVALID, "BadBrowseNameInvalid"}, + {UA_STATUSCODE_BADBROWSENAMEDUPLICATED, "BadBrowseNameDuplicated"}, + {UA_STATUSCODE_BADNODEATTRIBUTESINVALID, "BadNodeAttributesInvalid"}, + {UA_STATUSCODE_BADTYPEDEFINITIONINVALID, "BadTypeDefinitionInvalid"}, + {UA_STATUSCODE_BADSOURCENODEIDINVALID, "BadSourceNodeIdInvalid"}, + {UA_STATUSCODE_BADTARGETNODEIDINVALID, "BadTargetNodeIdInvalid"}, + {UA_STATUSCODE_BADDUPLICATEREFERENCENOTALLOWED, "BadDuplicateReferenceNotAllowed"}, + {UA_STATUSCODE_BADINVALIDSELFREFERENCE, "BadInvalidSelfReference"}, + {UA_STATUSCODE_BADREFERENCELOCALONLY, "BadReferenceLocalOnly"}, + {UA_STATUSCODE_BADNODELETERIGHTS, "BadNoDeleteRights"}, + {UA_STATUSCODE_UNCERTAINREFERENCENOTDELETED, "UncertainReferenceNotDeleted"}, + {UA_STATUSCODE_BADSERVERINDEXINVALID, "BadServerIndexInvalid"}, + {UA_STATUSCODE_BADVIEWIDUNKNOWN, "BadViewIdUnknown"}, + {UA_STATUSCODE_BADVIEWTIMESTAMPINVALID, "BadViewTimestampInvalid"}, + {UA_STATUSCODE_BADVIEWPARAMETERMISMATCH, "BadViewParameterMismatch"}, + {UA_STATUSCODE_BADVIEWVERSIONINVALID, "BadViewVersionInvalid"}, + {UA_STATUSCODE_UNCERTAINNOTALLNODESAVAILABLE, "UncertainNotAllNodesAvailable"}, + {UA_STATUSCODE_GOODRESULTSMAYBEINCOMPLETE, "GoodResultsMayBeIncomplete"}, + {UA_STATUSCODE_BADNOTTYPEDEFINITION, "BadNotTypeDefinition"}, + {UA_STATUSCODE_UNCERTAINREFERENCEOUTOFSERVER, "UncertainReferenceOutOfServer"}, + {UA_STATUSCODE_BADTOOMANYMATCHES, "BadTooManyMatches"}, + {UA_STATUSCODE_BADQUERYTOOCOMPLEX, "BadQueryTooComplex"}, + {UA_STATUSCODE_BADNOMATCH, "BadNoMatch"}, + {UA_STATUSCODE_BADMAXAGEINVALID, "BadMaxAgeInvalid"}, + {UA_STATUSCODE_BADSECURITYMODEINSUFFICIENT, "BadSecurityModeInsufficient"}, + {UA_STATUSCODE_BADHISTORYOPERATIONINVALID, "BadHistoryOperationInvalid"}, + {UA_STATUSCODE_BADHISTORYOPERATIONUNSUPPORTED, "BadHistoryOperationUnsupported"}, + {UA_STATUSCODE_BADINVALIDTIMESTAMPARGUMENT, "BadInvalidTimestampArgument"}, + {UA_STATUSCODE_BADWRITENOTSUPPORTED, "BadWriteNotSupported"}, + {UA_STATUSCODE_BADTYPEMISMATCH, "BadTypeMismatch"}, + {UA_STATUSCODE_BADMETHODINVALID, "BadMethodInvalid"}, + {UA_STATUSCODE_BADARGUMENTSMISSING, "BadArgumentsMissing"}, + {UA_STATUSCODE_BADNOTEXECUTABLE, "BadNotExecutable"}, + {UA_STATUSCODE_BADTOOMANYSUBSCRIPTIONS, "BadTooManySubscriptions"}, + {UA_STATUSCODE_BADTOOMANYPUBLISHREQUESTS, "BadTooManyPublishRequests"}, + {UA_STATUSCODE_BADNOSUBSCRIPTION, "BadNoSubscription"}, + {UA_STATUSCODE_BADSEQUENCENUMBERUNKNOWN, "BadSequenceNumberUnknown"}, + {UA_STATUSCODE_GOODRETRANSMISSIONQUEUENOTSUPPORTED, "GoodRetransmissionQueueNotSupported"}, + {UA_STATUSCODE_BADMESSAGENOTAVAILABLE, "BadMessageNotAvailable"}, + {UA_STATUSCODE_BADINSUFFICIENTCLIENTPROFILE, "BadInsufficientClientProfile"}, + {UA_STATUSCODE_BADSTATENOTACTIVE, "BadStateNotActive"}, + {UA_STATUSCODE_BADALREADYEXISTS, "BadAlreadyExists"}, + {UA_STATUSCODE_BADTCPSERVERTOOBUSY, "BadTcpServerTooBusy"}, + {UA_STATUSCODE_BADTCPMESSAGETYPEINVALID, "BadTcpMessageTypeInvalid"}, + {UA_STATUSCODE_BADTCPSECURECHANNELUNKNOWN, "BadTcpSecureChannelUnknown"}, + {UA_STATUSCODE_BADTCPMESSAGETOOLARGE, "BadTcpMessageTooLarge"}, + {UA_STATUSCODE_BADTCPNOTENOUGHRESOURCES, "BadTcpNotEnoughResources"}, + {UA_STATUSCODE_BADTCPINTERNALERROR, "BadTcpInternalError"}, + {UA_STATUSCODE_BADTCPENDPOINTURLINVALID, "BadTcpEndpointUrlInvalid"}, + {UA_STATUSCODE_BADREQUESTINTERRUPTED, "BadRequestInterrupted"}, + {UA_STATUSCODE_BADREQUESTTIMEOUT, "BadRequestTimeout"}, + {UA_STATUSCODE_BADSECURECHANNELCLOSED, "BadSecureChannelClosed"}, + {UA_STATUSCODE_BADSECURECHANNELTOKENUNKNOWN, "BadSecureChannelTokenUnknown"}, + {UA_STATUSCODE_BADSEQUENCENUMBERINVALID, "BadSequenceNumberInvalid"}, + {UA_STATUSCODE_BADPROTOCOLVERSIONUNSUPPORTED, "BadProtocolVersionUnsupported"}, + {UA_STATUSCODE_BADCONFIGURATIONERROR, "BadConfigurationError"}, + {UA_STATUSCODE_BADNOTCONNECTED, "BadNotConnected"}, + {UA_STATUSCODE_BADDEVICEFAILURE, "BadDeviceFailure"}, + {UA_STATUSCODE_BADSENSORFAILURE, "BadSensorFailure"}, + {UA_STATUSCODE_BADOUTOFSERVICE, "BadOutOfService"}, + {UA_STATUSCODE_BADDEADBANDFILTERINVALID, "BadDeadbandFilterInvalid"}, + {UA_STATUSCODE_UNCERTAINNOCOMMUNICATIONLASTUSABLEVALUE, "UncertainNoCommunicationLastUsableValue"}, + {UA_STATUSCODE_UNCERTAINLASTUSABLEVALUE, "UncertainLastUsableValue"}, + {UA_STATUSCODE_UNCERTAINSUBSTITUTEVALUE, "UncertainSubstituteValue"}, + {UA_STATUSCODE_UNCERTAININITIALVALUE, "UncertainInitialValue"}, + {UA_STATUSCODE_UNCERTAINSENSORNOTACCURATE, "UncertainSensorNotAccurate"}, + {UA_STATUSCODE_UNCERTAINENGINEERINGUNITSEXCEEDED, "UncertainEngineeringUnitsExceeded"}, + {UA_STATUSCODE_UNCERTAINSUBNORMAL, "UncertainSubNormal"}, + {UA_STATUSCODE_GOODLOCALOVERRIDE, "GoodLocalOverride"}, + {UA_STATUSCODE_BADREFRESHINPROGRESS, "BadRefreshInProgress"}, + {UA_STATUSCODE_BADCONDITIONALREADYDISABLED, "BadConditionAlreadyDisabled"}, + {UA_STATUSCODE_BADCONDITIONALREADYENABLED, "BadConditionAlreadyEnabled"}, + {UA_STATUSCODE_BADCONDITIONDISABLED, "BadConditionDisabled"}, + {UA_STATUSCODE_BADEVENTIDUNKNOWN, "BadEventIdUnknown"}, + {UA_STATUSCODE_BADEVENTNOTACKNOWLEDGEABLE, "BadEventNotAcknowledgeable"}, + {UA_STATUSCODE_BADDIALOGNOTACTIVE, "BadDialogNotActive"}, + {UA_STATUSCODE_BADDIALOGRESPONSEINVALID, "BadDialogResponseInvalid"}, + {UA_STATUSCODE_BADCONDITIONBRANCHALREADYACKED, "BadConditionBranchAlreadyAcked"}, + {UA_STATUSCODE_BADCONDITIONBRANCHALREADYCONFIRMED, "BadConditionBranchAlreadyConfirmed"}, + {UA_STATUSCODE_BADCONDITIONALREADYSHELVED, "BadConditionAlreadyShelved"}, + {UA_STATUSCODE_BADCONDITIONNOTSHELVED, "BadConditionNotShelved"}, + {UA_STATUSCODE_BADSHELVINGTIMEOUTOFRANGE, "BadShelvingTimeOutOfRange"}, + {UA_STATUSCODE_BADNODATA, "BadNoData"}, + {UA_STATUSCODE_BADBOUNDNOTFOUND, "BadBoundNotFound"}, + {UA_STATUSCODE_BADBOUNDNOTSUPPORTED, "BadBoundNotSupported"}, + {UA_STATUSCODE_BADDATALOST, "BadDataLost"}, + {UA_STATUSCODE_BADDATAUNAVAILABLE, "BadDataUnavailable"}, + {UA_STATUSCODE_BADENTRYEXISTS, "BadEntryExists"}, + {UA_STATUSCODE_BADNOENTRYEXISTS, "BadNoEntryExists"}, + {UA_STATUSCODE_BADTIMESTAMPNOTSUPPORTED, "BadTimestampNotSupported"}, + {UA_STATUSCODE_GOODENTRYINSERTED, "GoodEntryInserted"}, + {UA_STATUSCODE_GOODENTRYREPLACED, "GoodEntryReplaced"}, + {UA_STATUSCODE_UNCERTAINDATASUBNORMAL, "UncertainDataSubNormal"}, + {UA_STATUSCODE_GOODNODATA, "GoodNoData"}, + {UA_STATUSCODE_GOODMOREDATA, "GoodMoreData"}, + {UA_STATUSCODE_BADAGGREGATELISTMISMATCH, "BadAggregateListMismatch"}, + {UA_STATUSCODE_BADAGGREGATENOTSUPPORTED, "BadAggregateNotSupported"}, + {UA_STATUSCODE_BADAGGREGATEINVALIDINPUTS, "BadAggregateInvalidInputs"}, + {UA_STATUSCODE_BADAGGREGATECONFIGURATIONREJECTED, "BadAggregateConfigurationRejected"}, + {UA_STATUSCODE_GOODDATAIGNORED, "GoodDataIgnored"}, + {UA_STATUSCODE_BADREQUESTNOTALLOWED, "BadRequestNotAllowed"}, + {UA_STATUSCODE_BADREQUESTNOTCOMPLETE, "BadRequestNotComplete"}, + {UA_STATUSCODE_BADTICKETREQUIRED, "BadTicketRequired"}, + {UA_STATUSCODE_BADTICKETINVALID, "BadTicketInvalid"}, + {UA_STATUSCODE_GOODEDITED, "GoodEdited"}, + {UA_STATUSCODE_GOODPOSTACTIONFAILED, "GoodPostActionFailed"}, + {UA_STATUSCODE_UNCERTAINDOMINANTVALUECHANGED, "UncertainDominantValueChanged"}, + {UA_STATUSCODE_GOODDEPENDENTVALUECHANGED, "GoodDependentValueChanged"}, + {UA_STATUSCODE_BADDOMINANTVALUECHANGED, "BadDominantValueChanged"}, + {UA_STATUSCODE_UNCERTAINDEPENDENTVALUECHANGED, "UncertainDependentValueChanged"}, + {UA_STATUSCODE_BADDEPENDENTVALUECHANGED, "BadDependentValueChanged"}, + {UA_STATUSCODE_GOODEDITED_DEPENDENTVALUECHANGED, "GoodEdited_DependentValueChanged"}, + {UA_STATUSCODE_GOODEDITED_DOMINANTVALUECHANGED, "GoodEdited_DominantValueChanged"}, + {UA_STATUSCODE_GOODEDITED_DOMINANTVALUECHANGED_DEPENDENTVALUECHANGED, "GoodEdited_DominantValueChanged_DependentValueChanged"}, + {UA_STATUSCODE_BADEDITED_OUTOFRANGE, "BadEdited_OutOfRange"}, + {UA_STATUSCODE_BADINITIALVALUE_OUTOFRANGE, "BadInitialValue_OutOfRange"}, + {UA_STATUSCODE_BADOUTOFRANGE_DOMINANTVALUECHANGED, "BadOutOfRange_DominantValueChanged"}, + {UA_STATUSCODE_BADEDITED_OUTOFRANGE_DOMINANTVALUECHANGED, "BadEdited_OutOfRange_DominantValueChanged"}, + {UA_STATUSCODE_BADOUTOFRANGE_DOMINANTVALUECHANGED_DEPENDENTVALUECHANGED, "BadOutOfRange_DominantValueChanged_DependentValueChanged"}, + {UA_STATUSCODE_BADEDITED_OUTOFRANGE_DOMINANTVALUECHANGED_DEPENDENTVALUECHANGED, "BadEdited_OutOfRange_DominantValueChanged_DependentValueChanged"}, + {UA_STATUSCODE_GOODCOMMUNICATIONEVENT, "GoodCommunicationEvent"}, + {UA_STATUSCODE_GOODSHUTDOWNEVENT, "GoodShutdownEvent"}, + {UA_STATUSCODE_GOODCALLAGAIN, "GoodCallAgain"}, + {UA_STATUSCODE_GOODNONCRITICALTIMEOUT, "GoodNonCriticalTimeout"}, + {UA_STATUSCODE_BADINVALIDARGUMENT, "BadInvalidArgument"}, + {UA_STATUSCODE_BADCONNECTIONREJECTED, "BadConnectionRejected"}, + {UA_STATUSCODE_BADDISCONNECT, "BadDisconnect"}, + {UA_STATUSCODE_BADCONNECTIONCLOSED, "BadConnectionClosed"}, + {UA_STATUSCODE_BADINVALIDSTATE, "BadInvalidState"}, + {UA_STATUSCODE_BADENDOFSTREAM, "BadEndOfStream"}, + {UA_STATUSCODE_BADNODATAAVAILABLE, "BadNoDataAvailable"}, + {UA_STATUSCODE_BADWAITINGFORRESPONSE, "BadWaitingForResponse"}, + {UA_STATUSCODE_BADOPERATIONABANDONED, "BadOperationAbandoned"}, + {UA_STATUSCODE_BADEXPECTEDSTREAMTOBLOCK, "BadExpectedStreamToBlock"}, + {UA_STATUSCODE_BADWOULDBLOCK, "BadWouldBlock"}, + {UA_STATUSCODE_BADSYNTAXERROR, "BadSyntaxError"}, + {UA_STATUSCODE_BADMAXCONNECTIONSREACHED, "BadMaxConnectionsReached"}, + {0xffffffff, "Unknown StatusCode"} +}; + +const char * UA_StatusCode_name(UA_StatusCode code) { + for (size_t i = 0; i < statusCodeDescriptionsSize; ++i) { + if (statusCodeDescriptions[i].code == code) + return statusCodeDescriptions[i].name; + } + return statusCodeDescriptions[statusCodeDescriptionsSize-1].name; +} + +#endif + +/**** amalgamated original file "/src/ua_util.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014, 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014 (c) Florian Palm + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +size_t +UA_readNumberWithBase(const UA_Byte *buf, size_t buflen, UA_UInt32 *number, UA_Byte base) { + UA_assert(buf); + UA_assert(number); + u32 n = 0; + size_t progress = 0; + /* read numbers until the end or a non-number character appears */ + while(progress < buflen) { + u8 c = buf[progress]; + if(c >= '0' && c <= '9' && c <= '0' + (base-1)) + n = (n * base) + c - '0'; + else if(base > 9 && c >= 'a' && c <= 'z' && c <= 'a' + (base-11)) + n = (n * base) + c-'a' + 10; + else if(base > 9 && c >= 'A' && c <= 'Z' && c <= 'A' + (base-11)) + n = (n * base) + c-'A' + 10; + else + break; + ++progress; + } + *number = n; + return progress; +} + +size_t +UA_readNumber(const UA_Byte *buf, size_t buflen, UA_UInt32 *number) { + return UA_readNumberWithBase(buf, buflen, number, 10); +} + +UA_StatusCode +UA_parseEndpointUrl(const UA_String *endpointUrl, UA_String *outHostname, + u16 *outPort, UA_String *outPath) { + UA_Boolean ipv6 = false; + + /* Url must begin with "opc.tcp://" or opc.udp:// (if pubsub enabled) */ + if(endpointUrl->length < 11) { + return UA_STATUSCODE_BADTCPENDPOINTURLINVALID; + } + if (strncmp((char*)endpointUrl->data, "opc.tcp://", 10) != 0) { +#ifdef UA_ENABLE_PUBSUB + if (strncmp((char*)endpointUrl->data, "opc.udp://", 10) != 0 && + strncmp((char*)endpointUrl->data, "opc.mqtt://", 11) != 0) { + return UA_STATUSCODE_BADTCPENDPOINTURLINVALID; + } +#else + return UA_STATUSCODE_BADTCPENDPOINTURLINVALID; +#endif + } + + /* Where does the hostname end? */ + size_t curr = 10; + if(endpointUrl->data[curr] == '[') { + /* IPv6: opc.tcp://[2001:0db8:85a3::8a2e:0370:7334]:1234/path */ + for(; curr < endpointUrl->length; ++curr) { + if(endpointUrl->data[curr] == ']') + break; + } + if(curr == endpointUrl->length) + return UA_STATUSCODE_BADTCPENDPOINTURLINVALID; + curr++; + ipv6 = true; + } else { + /* IPv4 or hostname: opc.tcp://something.something:1234/path */ + for(; curr < endpointUrl->length; ++curr) { + if(endpointUrl->data[curr] == ':' || endpointUrl->data[curr] == '/') + break; + } + } + + /* Set the hostname */ + if(ipv6) { + /* Skip the ipv6 '[]' container for getaddrinfo() later */ + outHostname->data = &endpointUrl->data[11]; + outHostname->length = curr - 12; + } else { + outHostname->data = &endpointUrl->data[10]; + outHostname->length = curr - 10; + } + + /* Empty string? */ + if(outHostname->length == 0) + outHostname->data = NULL; + + if(curr == endpointUrl->length) + return UA_STATUSCODE_GOOD; + + /* Set the port */ + if(endpointUrl->data[curr] == ':') { + if(++curr == endpointUrl->length) + return UA_STATUSCODE_BADTCPENDPOINTURLINVALID; + u32 largeNum; + size_t progress = UA_readNumber(&endpointUrl->data[curr], + endpointUrl->length - curr, &largeNum); + if(progress == 0 || largeNum > 65535) + return UA_STATUSCODE_BADTCPENDPOINTURLINVALID; + /* Test if the end of a valid port was reached */ + curr += progress; + if(curr == endpointUrl->length || endpointUrl->data[curr] == '/') + *outPort = (u16)largeNum; + if(curr == endpointUrl->length) + return UA_STATUSCODE_GOOD; + } + + /* Set the path */ + UA_assert(curr < endpointUrl->length); + if(endpointUrl->data[curr] != '/') + return UA_STATUSCODE_BADTCPENDPOINTURLINVALID; + if(++curr == endpointUrl->length) + return UA_STATUSCODE_GOOD; + outPath->data = &endpointUrl->data[curr]; + outPath->length = endpointUrl->length - curr; + + /* Remove trailing slash from the path */ + if(endpointUrl->data[endpointUrl->length - 1] == '/') + outPath->length--; + + /* Empty string? */ + if(outPath->length == 0) + outPath->data = NULL; + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_parseEndpointUrlEthernet(const UA_String *endpointUrl, UA_String *target, + UA_UInt16 *vid, UA_Byte *pcp) { + /* Url must begin with "opc.eth://" */ + if(endpointUrl->length < 11) { + return UA_STATUSCODE_BADINTERNALERROR; + } + if(strncmp((char*) endpointUrl->data, "opc.eth://", 10) != 0) { + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Where does the host address end? */ + size_t curr = 10; + for(; curr < endpointUrl->length; ++curr) { + if(endpointUrl->data[curr] == ':') { + break; + } + } + + /* set host address */ + target->data = &endpointUrl->data[10]; + target->length = curr - 10; + if(curr == endpointUrl->length) { + return UA_STATUSCODE_GOOD; + } + + /* Set VLAN */ + u32 value = 0; + curr++; /* skip ':' */ + size_t progress = UA_readNumber(&endpointUrl->data[curr], + endpointUrl->length - curr, &value); + if(progress == 0 || value > 4096) { + return UA_STATUSCODE_BADINTERNALERROR; + } + curr += progress; + if(curr == endpointUrl->length || endpointUrl->data[curr] == '.') { + *vid = (UA_UInt16) value; + } + if(curr == endpointUrl->length) { + return UA_STATUSCODE_GOOD; + } + + /* Set priority */ + if(endpointUrl->data[curr] != '.') { + return UA_STATUSCODE_BADINTERNALERROR; + } + curr++; /* skip '.' */ + progress = UA_readNumber(&endpointUrl->data[curr], + endpointUrl->length - curr, &value); + if(progress == 0 || value > 7) { + return UA_STATUSCODE_BADINTERNALERROR; + } + curr += progress; + if(curr != endpointUrl->length) { + return UA_STATUSCODE_BADINTERNALERROR; + } + *pcp = (UA_Byte) value; + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_ByteString_toBase64(const UA_ByteString *byteString, + UA_String *str) { + UA_String_init(str); + if(!byteString || !byteString->data) + return UA_STATUSCODE_GOOD; + + str->data = (UA_Byte*) + UA_base64(byteString->data, byteString->length, &str->length); + if(!str->data) + return UA_STATUSCODE_BADOUTOFMEMORY; + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode UA_EXPORT +UA_ByteString_fromBase64(UA_ByteString *bs, + const UA_String *input) { + UA_ByteString_init(bs); + if(input->length == 0) + return UA_STATUSCODE_GOOD; + bs->data = UA_unbase64((const unsigned char*)input->data, + input->length, &bs->length); + /* TODO: Differentiate between encoding and memory errors */ + if(!bs->data) + return UA_STATUSCODE_BADINTERNALERROR; + return UA_STATUSCODE_GOOD; +} + +/* Key Value Map */ + +UA_StatusCode +UA_KeyValueMap_setQualified(UA_KeyValuePair **map, size_t *mapSize, + const UA_QualifiedName *key, + const UA_Variant *value) { + /* Parameter exists already */ + const UA_Variant *v = UA_KeyValueMap_getQualified(*map, *mapSize, key); + if(v) { + UA_Variant copyV; + UA_StatusCode res = UA_Variant_copy(v, ©V); + if(res != UA_STATUSCODE_GOOD) + return res; + UA_Variant *target = (UA_Variant*)(uintptr_t)v; + UA_Variant_clear(target); + *target = copyV; + return UA_STATUSCODE_GOOD; + } + + /* Append to the array */ + UA_KeyValuePair pair; + pair.key = *key; + pair.value = *value; + return UA_Array_appendCopy((void**)map, mapSize, &pair, + &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); +} + +UA_StatusCode +UA_KeyValueMap_set(UA_KeyValuePair **map, size_t *mapSize, + const char *key, const UA_Variant *value) { + UA_QualifiedName qnKey; + qnKey.namespaceIndex = 0; + qnKey.name = UA_STRING((char*)(uintptr_t)key); + return UA_KeyValueMap_setQualified(map, mapSize, &qnKey, value); +} + +const UA_Variant * +UA_KeyValueMap_getQualified(UA_KeyValuePair *map, size_t mapSize, + const UA_QualifiedName *key) { + for(size_t i = 0; i < mapSize; i++) { + if(map[i].key.namespaceIndex == key->namespaceIndex && + UA_String_equal(&map[i].key.name, &key->name)) + return &map[i].value; + + } + return NULL; +} + +const UA_Variant * +UA_KeyValueMap_get(UA_KeyValuePair *map, size_t mapSize, + const char *key) { + UA_QualifiedName qnKey; + qnKey.namespaceIndex = 0; + qnKey.name = UA_STRING((char*)(uintptr_t)key); + return UA_KeyValueMap_getQualified(map, mapSize, &qnKey); +} + +/* Returns NULL if the parameter is not defined or not of the right datatype */ +const UA_Variant * +UA_KeyValueMap_getScalar(UA_KeyValuePair *map, size_t mapSize, + const char *key, const UA_DataType *type) { + const UA_Variant *v = UA_KeyValueMap_get(map, mapSize, key); + if(!v || !UA_Variant_hasScalarType(v, type)) + return NULL; + return v; +} + +const UA_Variant * +UA_KeyValueMap_getArray(UA_KeyValuePair *map, size_t mapSize, + const char *key, const UA_DataType *type) { + const UA_Variant *v = UA_KeyValueMap_get(map, mapSize, key); + if(!v || !UA_Variant_hasArrayType(v, type)) + return NULL; + return v; +} + +void +UA_KeyValueMap_deleteQualified(UA_KeyValuePair **map, size_t *mapSize, + const UA_QualifiedName *key) { + UA_KeyValuePair *m = *map; + size_t s = *mapSize; + for(size_t i = 0; i < s; i++) { + if(m[i].key.namespaceIndex != key->namespaceIndex || + !UA_String_equal(&m[i].key.name, &key->name)) + continue; + + /* Clean the pair */ + UA_KeyValuePair_clear(&m[i]); + + /* Move the last pair to fill the empty slot */ + if(s > 1 && i < s - 1) { + m[i] = m[s-1]; + UA_KeyValuePair_init(&m[s-1]); + } + + UA_StatusCode res = UA_Array_resize((void**)map, mapSize, *mapSize-1, + &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); + (void)res; + *mapSize = s - 1; /* In case resize fails, keep the longer original + * array around. Resize never fails when reducing + * the size to zero. Reduce the size integer in + * any case. */ + return; + } +} + +void +UA_KeyValueMap_delete(UA_KeyValuePair **map, size_t *mapSize, + const char *key) { + UA_QualifiedName qnKey; + qnKey.namespaceIndex = 0; + qnKey.name = UA_STRING((char*)(uintptr_t)key); + UA_KeyValueMap_deleteQualified(map, mapSize, &qnKey); +} + +/**** amalgamated original file "/src/ua_timer.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017, 2018, 2021 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + +/* There may be several entries with the same nextTime in the tree. We give them + * an absolute order by considering the memory address to break ties. Because of + * this, the nextTime property cannot be used to lookup specific entries. */ +static enum aa_cmp +cmpDateTime(const UA_DateTime *a, const UA_DateTime *b) { + if(*a < *b) + return AA_CMP_LESS; + if(*a > *b) + return AA_CMP_MORE; + if(a == b) + return AA_CMP_EQ; + if(a < b) + return AA_CMP_LESS; + return AA_CMP_MORE; +} + +/* The identifiers of entries are unique */ +static enum aa_cmp +cmpId(const UA_UInt64 *a, const UA_UInt64 *b) { + if(*a < *b) + return AA_CMP_LESS; + if(*a == *b) + return AA_CMP_EQ; + return AA_CMP_MORE; +} + +static UA_DateTime +calculateNextTime(UA_DateTime currentTime, UA_DateTime baseTime, + UA_DateTime interval) { + /* Take the difference between current and base time */ + UA_DateTime diffCurrentTimeBaseTime = currentTime - baseTime; + + /* Take modulo of the diff time with the interval. This is the duration we + * are already "into" the current interval. Subtract it from (current + + * interval) to get the next execution time. */ + UA_DateTime cycleDelay = diffCurrentTimeBaseTime % interval; + + /* Handle the special case where the baseTime is in the future */ + if(UA_UNLIKELY(cycleDelay < 0)) + cycleDelay += interval; + + return currentTime + interval - cycleDelay; +} + +void +UA_Timer_init(UA_Timer *t) { + memset(t, 0, sizeof(UA_Timer)); + aa_init(&t->root, + (enum aa_cmp (*)(const void*, const void*))cmpDateTime, + offsetof(UA_TimerEntry, treeEntry), + offsetof(UA_TimerEntry, nextTime)); + aa_init(&t->idRoot, + (enum aa_cmp (*)(const void*, const void*))cmpId, + offsetof(UA_TimerEntry, idTreeEntry), + offsetof(UA_TimerEntry, id)); + UA_LOCK_INIT(&t->timerMutex); +} + +void +UA_Timer_addTimerEntry(UA_Timer *t, UA_TimerEntry *te, UA_UInt64 *callbackId) { + UA_LOCK(&t->timerMutex); + te->id = ++t->idCounter; + if(callbackId) + *callbackId = te->id; + aa_insert(&t->root, te); + aa_insert(&t->idRoot, te); + UA_UNLOCK(&t->timerMutex); +} + +static UA_StatusCode +addCallback(UA_Timer *t, UA_ApplicationCallback callback, void *application, + void *data, UA_DateTime nextTime, UA_UInt64 interval, + UA_TimerPolicy timerPolicy, UA_UInt64 *callbackId) { + /* A callback method needs to be present */ + if(!callback) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Allocate the repeated callback structure */ + UA_TimerEntry *te = (UA_TimerEntry*)UA_malloc(sizeof(UA_TimerEntry)); + if(!te) + return UA_STATUSCODE_BADOUTOFMEMORY; + + /* Set the repeated callback */ + te->interval = (UA_UInt64)interval; + te->id = ++t->idCounter; + te->callback = callback; + te->application = application; + te->data = data; + te->nextTime = nextTime; + te->timerPolicy = timerPolicy; + + /* Set the output identifier */ + if(callbackId) + *callbackId = te->id; + + aa_insert(&t->root, te); + aa_insert(&t->idRoot, te); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Timer_addTimedCallback(UA_Timer *t, UA_ApplicationCallback callback, + void *application, void *data, UA_DateTime date, + UA_UInt64 *callbackId) { + UA_LOCK(&t->timerMutex); + UA_StatusCode res = addCallback(t, callback, application, data, date, + 0, UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, + callbackId); + UA_UNLOCK(&t->timerMutex); + return res; +} + +/* Adding repeated callbacks: Add an entry with the "nextTime" timestamp in the + * future. This will be picked up in the next iteration and inserted at the + * correct place. So that the next execution takes place ät "nextTime". */ +UA_StatusCode +UA_Timer_addRepeatedCallback(UA_Timer *t, UA_ApplicationCallback callback, + void *application, void *data, UA_Double interval_ms, + UA_DateTime *baseTime, UA_TimerPolicy timerPolicy, + UA_UInt64 *callbackId) { + /* The interval needs to be positive */ + if(interval_ms <= 0.0) + return UA_STATUSCODE_BADINTERNALERROR; + UA_UInt64 interval = (UA_UInt64)(interval_ms * UA_DATETIME_MSEC); + if(interval == 0) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Compute the first time for execution */ + UA_DateTime currentTime = UA_DateTime_nowMonotonic(); + UA_DateTime nextTime; + if(baseTime == NULL) { + /* Use "now" as the basetime */ + nextTime = currentTime + (UA_DateTime)interval; + } else { + nextTime = calculateNextTime(currentTime, *baseTime, (UA_DateTime)interval); + } + + UA_LOCK(&t->timerMutex); + UA_StatusCode res = addCallback(t, callback, application, data, nextTime, + interval, timerPolicy, callbackId); + UA_UNLOCK(&t->timerMutex); + return res; +} + +UA_StatusCode +UA_Timer_changeRepeatedCallback(UA_Timer *t, UA_UInt64 callbackId, + UA_Double interval_ms, UA_DateTime *baseTime, + UA_TimerPolicy timerPolicy) { + /* The interval needs to be positive */ + if(interval_ms <= 0.0) + return UA_STATUSCODE_BADINTERNALERROR; + UA_UInt64 interval = (UA_UInt64)(interval_ms * UA_DATETIME_MSEC); + if(interval == 0) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_LOCK(&t->timerMutex); + + /* Remove from the sorted tree */ + UA_TimerEntry *te = (UA_TimerEntry*)aa_find(&t->idRoot, &callbackId); + if(!te) { + UA_UNLOCK(&t->timerMutex); + return UA_STATUSCODE_BADNOTFOUND; + } + aa_remove(&t->root, te); + + /* Compute the next time for execution. The logic is identical to the + * creation of a new repeated callback. */ + UA_DateTime currentTime = UA_DateTime_nowMonotonic(); + if(baseTime == NULL) { + /* Use "now" as the basetime */ + te->nextTime = currentTime + (UA_DateTime)interval; + } else { + te->nextTime = calculateNextTime(currentTime, *baseTime, (UA_DateTime)interval); + } + + /* Update the remaining parameters and re-insert */ + te->interval = interval; + te->timerPolicy = timerPolicy; + aa_insert(&t->root, te); + + UA_UNLOCK(&t->timerMutex); + return UA_STATUSCODE_GOOD; +} + +void +UA_Timer_removeCallback(UA_Timer *t, UA_UInt64 callbackId) { + UA_LOCK(&t->timerMutex); + UA_TimerEntry *te = (UA_TimerEntry*)aa_find(&t->idRoot, &callbackId); + if(UA_LIKELY(te != NULL)) { + aa_remove(&t->root, te); + aa_remove(&t->idRoot, te); + UA_free(te); + } + UA_UNLOCK(&t->timerMutex); +} + +UA_DateTime +UA_Timer_process(UA_Timer *t, UA_DateTime nowMonotonic, + UA_TimerExecutionCallback executionCallback, + void *executionApplication) { + UA_LOCK(&t->timerMutex); + UA_TimerEntry *first; + while((first = (UA_TimerEntry*)aa_min(&t->root)) && + first->nextTime <= nowMonotonic) { + aa_remove(&t->root, first); + + /* Reinsert / remove to their new position first. Because the callback + * can interact with the zip tree and expects the same entries in the + * root and idRoot trees. */ + + if(first->interval == 0) { + aa_remove(&t->idRoot, first); + if(first->callback) { + UA_UNLOCK(&t->timerMutex); + executionCallback(executionApplication, first->callback, + first->application, first->data); + UA_LOCK(&t->timerMutex); + } + UA_free(first); + continue; + } + + /* Set the time for the next execution. Prevent an infinite loop by + * forcing the execution time in the next iteration. + * + * If the timer policy is "CurrentTime", then there is at least the + * interval between executions. This is used for Monitoreditems, for + * which the spec says: The sampling interval indicates the fastest rate + * at which the Server should sample its underlying source for data + * changes. (Part 4, 5.12.1.2) */ + first->nextTime += (UA_DateTime)first->interval; + if(first->nextTime < nowMonotonic) { + if(first->timerPolicy == UA_TIMER_HANDLE_CYCLEMISS_WITH_BASETIME) + first->nextTime = calculateNextTime(nowMonotonic, first->nextTime, + (UA_DateTime)first->interval); + else + first->nextTime = nowMonotonic + (UA_DateTime)first->interval; + } + + aa_insert(&t->root, first); + + if(!first->callback) + continue; + + /* Unlock the mutes before dropping into the callback. So that the timer + * itself can be edited within the callback. When we return, only the + * pointer to t must still exist. */ + UA_ApplicationCallback cb = first->callback; + void *app = first->application; + void *data = first->data; + UA_UNLOCK(&t->timerMutex); + executionCallback(executionApplication, cb, app, data); + UA_LOCK(&t->timerMutex); + } + + /* Return the timestamp of the earliest next callback */ + first = (UA_TimerEntry*)aa_min(&t->root); + UA_DateTime next = (first) ? first->nextTime : UA_INT64_MAX; + if(next < nowMonotonic) + next = nowMonotonic; + UA_UNLOCK(&t->timerMutex); + return next; +} + +void +UA_Timer_clear(UA_Timer *t) { + UA_LOCK(&t->timerMutex); + + /* Free all entries */ + UA_TimerEntry *top; + while((top = (UA_TimerEntry*)aa_min(&t->idRoot))) { + aa_remove(&t->idRoot, top); + UA_free(top); + } + + /* Reset the trees to avoid future access */ + t->root.root = NULL; + t->idRoot.root = NULL; + + UA_UNLOCK(&t->timerMutex); +#if UA_MULTITHREADING >= 100 + UA_LOCK_DESTROY(&t->timerMutex); +#endif +} + +/**** amalgamated original file "/src/ua_connection.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2016-2017 (c) Florian Palm + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2019 (c) Kalycito Infotech Private Limited + */ + + + +/* Hides some errors before sending them to a client according to the + * standard. */ +static void +hideErrors(UA_TcpErrorMessage *const error) { + switch(error->error) { + case UA_STATUSCODE_BADCERTIFICATEUNTRUSTED: + case UA_STATUSCODE_BADCERTIFICATEREVOKED: + error->error = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + error->reason = UA_STRING_NULL; + break; + // TODO: Check if these are all cases that need to be covered. + default: + break; + } +} + +void +UA_Connection_sendError(UA_Connection *connection, UA_TcpErrorMessage *error) { + hideErrors(error); + + UA_TcpMessageHeader header; + header.messageTypeAndChunkType = UA_MESSAGETYPE_ERR + UA_CHUNKTYPE_FINAL; + // Header + ErrorMessage (error + reasonLength_field + length) + header.messageSize = 8 + (4 + 4 + (UA_UInt32)error->reason.length); + + /* Get the send buffer from the network layer */ + UA_ByteString msg = UA_BYTESTRING_NULL; + UA_StatusCode retval = connection->getSendBuffer(connection, header.messageSize, &msg); + if(retval != UA_STATUSCODE_GOOD) + return; + + /* Encode and send the response */ + UA_Byte *bufPos = msg.data; + const UA_Byte *bufEnd = &msg.data[msg.length]; + retval |= UA_encodeBinaryInternal(&header, + &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER], + &bufPos, &bufEnd, NULL, NULL); + retval |= UA_encodeBinaryInternal(error, + &UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE], + &bufPos, &bufEnd, NULL, NULL); + (void)retval; /* Encoding of these cannot fail */ + msg.length = header.messageSize; + connection->ua_send(connection, &msg); +} + +void UA_Connection_detachSecureChannel(UA_Connection *connection) { + UA_SecureChannel *channel = connection->channel; + if(channel) + /* only replace when the channel points to this connection */ + UA_atomic_cmpxchg((void**)&channel->connection, connection, NULL); + UA_atomic_xchg((void**)&connection->channel, NULL); +} + +// TODO: Return an error code +void +UA_Connection_attachSecureChannel(UA_Connection *connection, UA_SecureChannel *channel) { + if(UA_atomic_cmpxchg((void**)&channel->connection, NULL, connection) == NULL) + UA_atomic_xchg((void**)&connection->channel, (void*)channel); +} + +/**** amalgamated original file "/src/ua_securechannel.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2016-2017 (c) Florian Palm + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016 (c) TorbenD + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017-2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2018-2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + + +#define UA_BITMASK_MESSAGETYPE 0x00ffffffu +#define UA_BITMASK_CHUNKTYPE 0xff000000u + +const UA_ByteString UA_SECURITY_POLICY_NONE_URI = + {47, (UA_Byte *)"http://opcfoundation.org/UA/SecurityPolicy#None"}; + +#ifdef UA_ENABLE_UNIT_TEST_FAILURE_HOOKS +UA_StatusCode decrypt_verifySignatureFailure; +UA_StatusCode sendAsym_sendFailure; +UA_StatusCode processSym_seqNumberFailure; +#endif + +void UA_SecureChannel_init(UA_SecureChannel *channel, + const UA_ConnectionConfig *config) { + /* Linked lists are also initialized by zeroing out */ + memset(channel, 0, sizeof(UA_SecureChannel)); + channel->state = UA_SECURECHANNELSTATE_FRESH; + SIMPLEQ_INIT(&channel->completeChunks); + SIMPLEQ_INIT(&channel->decryptedChunks); + SLIST_INIT(&channel->sessions); + channel->config = *config; +} + +UA_StatusCode +UA_SecureChannel_setSecurityPolicy(UA_SecureChannel *channel, + const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate) { + /* Is a policy already configured? */ + UA_CHECK_ERROR(!channel->securityPolicy, return UA_STATUSCODE_BADINTERNALERROR, + securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Security policy already configured"); + + /* Create the context */ + UA_StatusCode retval = securityPolicy->channelModule. + newContext(securityPolicy, remoteCertificate, &channel->channelContext); + retval |= UA_ByteString_copy(remoteCertificate, &channel->remoteCertificate); + UA_CHECK_STATUS_WARN(retval, return retval, securityPolicy->logger, + UA_LOGCATEGORY_SECURITYPOLICY, "Could not set up the SecureChannel context"); + + /* Compute the certificate thumbprint */ + UA_ByteString remoteCertificateThumbprint = {20, channel->remoteCertificateThumbprint}; + retval = securityPolicy->asymmetricModule. + makeCertificateThumbprint(securityPolicy, &channel->remoteCertificate, + &remoteCertificateThumbprint); + UA_CHECK_STATUS_WARN(retval, return retval, securityPolicy->logger, + UA_LOGCATEGORY_SECURITYPOLICY, "Could not create the certificate thumbprint"); + + /* Set the policy */ + channel->securityPolicy = securityPolicy; + return UA_STATUSCODE_GOOD; +} + +static void +UA_Chunk_delete(UA_Chunk *chunk) { + if(chunk->copied) + UA_ByteString_clear(&chunk->bytes); + UA_free(chunk); +} + +static void +deleteChunks(UA_ChunkQueue *queue) { + UA_Chunk *chunk; + while((chunk = SIMPLEQ_FIRST(queue))) { + SIMPLEQ_REMOVE_HEAD(queue, pointers); + UA_Chunk_delete(chunk); + } +} + +void +UA_SecureChannel_deleteBuffered(UA_SecureChannel *channel) { + deleteChunks(&channel->completeChunks); + deleteChunks(&channel->decryptedChunks); + UA_ByteString_clear(&channel->incompleteChunk); +} + +void +UA_SecureChannel_close(UA_SecureChannel *channel) { + /* Set the status to closed */ + channel->state = UA_SECURECHANNELSTATE_CLOSED; + + /* Detach from the connection and close the connection */ + if(channel->connection) { + if(channel->connection->state != UA_CONNECTIONSTATE_CLOSED) + channel->connection->ua_close(channel->connection); + UA_Connection_detachSecureChannel(channel->connection); + } + + /* Remove session pointers (not the sessions) and NULL the pointers back to + * the SecureChannel in the Session */ + UA_SessionHeader *sh; + while((sh = SLIST_FIRST(&channel->sessions))) { + sh->channel = NULL; + SLIST_REMOVE_HEAD(&channel->sessions, next); + } + + /* Delete the channel context for the security policy */ + if(channel->securityPolicy) { + channel->securityPolicy->channelModule.deleteContext(channel->channelContext); + channel->securityPolicy = NULL; + channel->channelContext = NULL; + } + + /* Delete members */ + UA_ByteString_clear(&channel->remoteCertificate); + UA_ByteString_clear(&channel->localNonce); + UA_ByteString_clear(&channel->remoteNonce); + UA_ChannelSecurityToken_clear(&channel->securityToken); + UA_ChannelSecurityToken_clear(&channel->altSecurityToken); + UA_SecureChannel_deleteBuffered(channel); +} + +UA_StatusCode +UA_SecureChannel_processHELACK(UA_SecureChannel *channel, + const UA_TcpAcknowledgeMessage *remoteConfig) { + /* The lowest common version is used by both sides */ + if(channel->config.protocolVersion > remoteConfig->protocolVersion) + channel->config.protocolVersion = remoteConfig->protocolVersion; + + /* Can we receive the max send size? */ + if(channel->config.sendBufferSize > remoteConfig->receiveBufferSize) + channel->config.sendBufferSize = remoteConfig->receiveBufferSize; + + /* Can we send the max receive size? */ + if(channel->config.recvBufferSize > remoteConfig->sendBufferSize) + channel->config.recvBufferSize = remoteConfig->sendBufferSize; + + channel->config.remoteMaxMessageSize = remoteConfig->maxMessageSize; + channel->config.remoteMaxChunkCount = remoteConfig->maxChunkCount; + + /* Chunks of at least 8192 bytes must be permissible. + * See Part 6, Clause 6.7.1 */ + if(channel->config.recvBufferSize < 8192 || + channel->config.sendBufferSize < 8192 || + (channel->config.remoteMaxMessageSize != 0 && + channel->config.remoteMaxMessageSize < 8192)) + return UA_STATUSCODE_BADINTERNALERROR; + + channel->connection->state = UA_CONNECTIONSTATE_ESTABLISHED; + return UA_STATUSCODE_GOOD; +} + +/* Sends an OPN message using asymmetric encryption if defined */ +UA_StatusCode +UA_SecureChannel_sendAsymmetricOPNMessage(UA_SecureChannel *channel, + UA_UInt32 requestId, const void *content, + const UA_DataType *contentType) { + UA_CHECK(channel->securityMode != UA_MESSAGESECURITYMODE_INVALID, + return UA_STATUSCODE_BADSECURITYMODEREJECTED); + + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_Connection *conn = channel->connection; + UA_CHECK_MEM(sp, return UA_STATUSCODE_BADINTERNALERROR); + UA_CHECK_MEM(conn, return UA_STATUSCODE_BADINTERNALERROR); + + /* Allocate the message buffer */ + UA_ByteString buf = UA_BYTESTRING_NULL; + UA_StatusCode res = conn->getSendBuffer(conn, channel->config.sendBufferSize, &buf); + UA_CHECK_STATUS(res, return res); + + /* Restrict buffer to the available space for the payload */ + UA_Byte *buf_pos = buf.data; + const UA_Byte *buf_end = &buf.data[buf.length]; + hideBytesAsym(channel, &buf_pos, &buf_end); + + /* Encode the message type and content */ + res |= UA_NodeId_encodeBinary(&contentType->binaryEncodingId, &buf_pos, buf_end); + res |= UA_encodeBinaryInternal(content, contentType, + &buf_pos, &buf_end, NULL, NULL); + UA_CHECK_STATUS(res, conn->releaseSendBuffer(conn, &buf); return res); + + const size_t securityHeaderLength = calculateAsymAlgSecurityHeaderLength(channel); + +#ifdef UA_ENABLE_ENCRYPTION + /* Add padding to the chunk. Also pad if the securityMode is SIGN_ONLY, + * since we are using asymmetric communication to exchange keys and thus + * need to encrypt. */ + if(channel->securityMode != UA_MESSAGESECURITYMODE_NONE) + padChunk(channel, &channel->securityPolicy->asymmetricModule.cryptoModule, + &buf.data[UA_SECURECHANNEL_CHANNELHEADER_LENGTH + securityHeaderLength], + &buf_pos); +#endif + + /* The total message length */ + size_t pre_sig_length = (uintptr_t)buf_pos - (uintptr_t)buf.data; + size_t total_length = pre_sig_length; + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGN || + channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + total_length += sp->asymmetricModule.cryptoModule.signatureAlgorithm. + getLocalSignatureSize(channel->channelContext); + + /* The total message length is known here which is why we encode the headers + * at this step and not earlier. */ + size_t encryptedLength = 0; + res = prependHeadersAsym(channel, buf.data, buf_end, total_length, + securityHeaderLength, requestId, &encryptedLength); + UA_CHECK_STATUS(res, conn->releaseSendBuffer(conn, &buf); return res); + +#ifdef UA_ENABLE_ENCRYPTION + res = signAndEncryptAsym(channel, pre_sig_length, &buf, + securityHeaderLength, total_length); + UA_CHECK_STATUS(res, conn->releaseSendBuffer(conn, &buf); return res); +#endif + + /* Send the message, the buffer is freed in the network layer */ + buf.length = encryptedLength; + res = conn->ua_send(conn, &buf); +#ifdef UA_ENABLE_UNIT_TEST_FAILURE_HOOKS + res |= sendAsym_sendFailure; +#endif + return res; +} + +/* Will this chunk surpass the capacity of the SecureChannel for the message? */ +static UA_StatusCode +adjustCheckMessageLimitsSym(UA_MessageContext *mc, size_t bodyLength) { + mc->messageSizeSoFar += bodyLength; + mc->chunksSoFar++; + + UA_SecureChannel *channel = mc->channel; + if(mc->messageSizeSoFar > channel->config.localMaxMessageSize && + channel->config.localMaxMessageSize != 0) + return UA_STATUSCODE_BADRESPONSETOOLARGE; + + if(mc->chunksSoFar > channel->config.localMaxChunkCount && + channel->config.localMaxChunkCount != 0) + return UA_STATUSCODE_BADRESPONSETOOLARGE; + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +encodeHeadersSym(UA_MessageContext *mc, size_t totalLength) { + UA_SecureChannel *channel = mc->channel; + UA_Byte *header_pos = mc->messageBuffer.data; + + UA_TcpMessageHeader header; + header.messageTypeAndChunkType = mc->messageType; + header.messageSize = (UA_UInt32)totalLength; + if(mc->final) + header.messageTypeAndChunkType += UA_CHUNKTYPE_FINAL; + else + header.messageTypeAndChunkType += UA_CHUNKTYPE_INTERMEDIATE; + + UA_SequenceHeader seqHeader; + seqHeader.requestId = mc->requestId; + seqHeader.sequenceNumber = UA_atomic_addUInt32(&channel->sendSequenceNumber, 1); + + UA_StatusCode res = UA_STATUSCODE_GOOD; + res |= UA_encodeBinaryInternal(&header, &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER], + &header_pos, &mc->buf_end, NULL, NULL); + res |= UA_UInt32_encodeBinary(&channel->securityToken.channelId, + &header_pos, mc->buf_end); + res |= UA_UInt32_encodeBinary(&channel->securityToken.tokenId, + &header_pos, mc->buf_end); + res |= UA_encodeBinaryInternal(&seqHeader, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER], + &header_pos, &mc->buf_end, NULL, NULL); + return res; +} + +static UA_StatusCode +sendSymmetricChunk(UA_MessageContext *mc) { + UA_SecureChannel *channel = mc->channel; + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_Connection *connection = channel->connection; + UA_CHECK_MEM(connection, return UA_STATUSCODE_BADINTERNALERROR); + + /* The size of the message payload */ + size_t bodyLength = (uintptr_t)mc->buf_pos - + (uintptr_t)&mc->messageBuffer.data[UA_SECURECHANNEL_SYMMETRIC_HEADER_TOTALLENGTH]; + + /* Early-declare variables so we can use a goto in the error case */ + size_t total_length = 0; + size_t pre_sig_length = 0; + + /* Check if chunk exceeds the limits for the overall message */ + UA_StatusCode res = adjustCheckMessageLimitsSym(mc, bodyLength); + UA_CHECK_STATUS(res, goto error); + + UA_LOG_TRACE_CHANNEL(sp->logger, channel, + "Send from a symmetric message buffer of length %lu " + "a message of header+payload length of %lu", + (long unsigned int)mc->messageBuffer.length, + (long unsigned int) + ((uintptr_t)mc->buf_pos - (uintptr_t)mc->messageBuffer.data)); + +#ifdef UA_ENABLE_ENCRYPTION + /* Add padding if the message is encrypted */ + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + padChunk(channel, &sp->symmetricModule.cryptoModule, + &mc->messageBuffer.data[UA_SECURECHANNEL_SYMMETRIC_HEADER_UNENCRYPTEDLENGTH], + &mc->buf_pos); +#endif + + /* Compute the total message length */ + pre_sig_length = (uintptr_t)mc->buf_pos - (uintptr_t)mc->messageBuffer.data; + total_length = pre_sig_length; + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGN || + channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + total_length += sp->symmetricModule.cryptoModule.signatureAlgorithm. + getLocalSignatureSize(channel->channelContext); + + UA_LOG_TRACE_CHANNEL(sp->logger, channel, + "Send from a symmetric message buffer of length %lu " + "a message of length %lu", + (long unsigned int)mc->messageBuffer.length, + (long unsigned int)total_length); + + /* Space for the padding and the signature have been reserved in setBufPos() */ + UA_assert(total_length <= channel->config.sendBufferSize); + + /* Adjust the buffer size of the network layer */ + mc->messageBuffer.length = total_length; + + /* Generate and encode the header for symmetric messages */ + res = encodeHeadersSym(mc, total_length); + UA_CHECK_STATUS(res, goto error); + +#ifdef UA_ENABLE_ENCRYPTION + /* Sign and encrypt the messge */ + res = signAndEncryptSym(mc, pre_sig_length, total_length); + UA_CHECK_STATUS(res, goto error); +#endif + + /* Send the chunk, the buffer is freed in the network layer */ + return connection->ua_send(channel->connection, &mc->messageBuffer); + + error: + /* Free the unused message buffer */ + connection->releaseSendBuffer(channel->connection, &mc->messageBuffer); + return res; +} + +/* Callback from the encoding layer. Send the chunk and replace the buffer. */ +static UA_StatusCode +sendSymmetricEncodingCallback(void *data, UA_Byte **buf_pos, const UA_Byte **buf_end) { + /* Set buf values from encoding in the messagecontext */ + UA_MessageContext *mc = (UA_MessageContext *)data; + mc->buf_pos = *buf_pos; + mc->buf_end = *buf_end; + + /* Send out */ + UA_StatusCode retval = sendSymmetricChunk(mc); + UA_CHECK_STATUS(retval, return retval); + + /* Set a new buffer for the next chunk */ + UA_Connection *connection = mc->channel->connection; + UA_CHECK_MEM(connection, return UA_STATUSCODE_BADINTERNALERROR); + + retval = connection->getSendBuffer(connection, mc->channel->config.sendBufferSize, + &mc->messageBuffer); + UA_CHECK_STATUS(retval, return retval); + + /* Hide bytes for header, padding and signature */ + setBufPos(mc); + *buf_pos = mc->buf_pos; + *buf_end = mc->buf_end; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_MessageContext_begin(UA_MessageContext *mc, UA_SecureChannel *channel, + UA_UInt32 requestId, UA_MessageType messageType) { + UA_CHECK(messageType == UA_MESSAGETYPE_MSG || messageType == UA_MESSAGETYPE_CLO, + return UA_STATUSCODE_BADINTERNALERROR); + + UA_Connection *connection = channel->connection; + UA_CHECK_MEM(connection, return UA_STATUSCODE_BADINTERNALERROR); + + /* Create the chunking info structure */ + mc->channel = channel; + mc->requestId = requestId; + mc->chunksSoFar = 0; + mc->messageSizeSoFar = 0; + mc->final = false; + mc->messageBuffer = UA_BYTESTRING_NULL; + mc->messageType = messageType; + + /* Allocate the message buffer */ + UA_StatusCode retval = + connection->getSendBuffer(connection, channel->config.sendBufferSize, + &mc->messageBuffer); + UA_CHECK_STATUS(retval, return retval); + + /* Hide bytes for header, padding and signature */ + setBufPos(mc); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_MessageContext_encode(UA_MessageContext *mc, const void *content, + const UA_DataType *contentType) { + UA_StatusCode res = + UA_encodeBinaryInternal(content, contentType, &mc->buf_pos, &mc->buf_end, + sendSymmetricEncodingCallback, mc); + if(res != UA_STATUSCODE_GOOD && mc->messageBuffer.length > 0) + UA_MessageContext_abort(mc); + return res; +} + +UA_StatusCode +UA_MessageContext_finish(UA_MessageContext *mc) { + mc->final = true; + return sendSymmetricChunk(mc); +} + +void +UA_MessageContext_abort(UA_MessageContext *mc) { + UA_Connection *connection = mc->channel->connection; + connection->releaseSendBuffer(connection, &mc->messageBuffer); +} + +UA_StatusCode +UA_SecureChannel_sendSymmetricMessage(UA_SecureChannel *channel, UA_UInt32 requestId, + UA_MessageType messageType, void *payload, + const UA_DataType *payloadType) { + if(!channel || !channel->connection || !payload || !payloadType) + return UA_STATUSCODE_BADINTERNALERROR; + + if(channel->state != UA_SECURECHANNELSTATE_OPEN) + return UA_STATUSCODE_BADCONNECTIONCLOSED; + + if(channel->connection->state != UA_CONNECTIONSTATE_ESTABLISHED) + return UA_STATUSCODE_BADCONNECTIONCLOSED; + + UA_MessageContext mc; + UA_StatusCode retval = UA_MessageContext_begin(&mc, channel, requestId, messageType); + UA_CHECK_STATUS(retval, return retval); + + /* Assert's required for clang-analyzer */ + UA_assert(mc.buf_pos == &mc.messageBuffer.data[UA_SECURECHANNEL_SYMMETRIC_HEADER_TOTALLENGTH]); + UA_assert(mc.buf_end <= &mc.messageBuffer.data[mc.messageBuffer.length]); + + retval = UA_MessageContext_encode(&mc, &payloadType->binaryEncodingId, + &UA_TYPES[UA_TYPES_NODEID]); + UA_CHECK_STATUS(retval, return retval); + + retval = UA_MessageContext_encode(&mc, payload, payloadType); + UA_CHECK_STATUS(retval, return retval); + + return UA_MessageContext_finish(&mc); +} + +/********************************/ +/* Receive and Process Messages */ +/********************************/ + +#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION +static UA_StatusCode +processSequenceNumberSym(UA_SecureChannel *channel, UA_UInt32 sequenceNumber) { + /* Failure mode hook for unit tests */ +#ifdef UA_ENABLE_UNIT_TEST_FAILURE_HOOKS + if(processSym_seqNumberFailure != UA_STATUSCODE_GOOD) + return processSym_seqNumberFailure; +#endif + + /* Does the sequence number match? */ + if(sequenceNumber != channel->receiveSequenceNumber + 1) { + /* FIXME: Remove magic numbers :( */ + if(channel->receiveSequenceNumber + 1 > 4294966271 && sequenceNumber < 1024) + channel->receiveSequenceNumber = sequenceNumber - 1; /* Roll over */ + else + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + ++channel->receiveSequenceNumber; + return UA_STATUSCODE_GOOD; +} + +#endif + +static UA_StatusCode +unpackPayloadOPN(UA_SecureChannel *channel, UA_Chunk *chunk, void *application) { + UA_assert(chunk->bytes.length >= UA_SECURECHANNEL_MESSAGE_MIN_LENGTH); + size_t offset = UA_SECURECHANNEL_MESSAGEHEADER_LENGTH; /* Skip the message header */ + UA_UInt32 secureChannelId; + UA_StatusCode res = UA_UInt32_decodeBinary(&chunk->bytes, &offset, &secureChannelId); + UA_assert(res == UA_STATUSCODE_GOOD); + + UA_AsymmetricAlgorithmSecurityHeader asymHeader; + res = UA_decodeBinaryInternal(&chunk->bytes, &offset, &asymHeader, + &UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER], NULL); + UA_CHECK_STATUS(res, return res); + + if(asymHeader.senderCertificate.length > 0) { + if(channel->certificateVerification) + res = channel->certificateVerification-> + verifyCertificate(channel->certificateVerification->context, + &asymHeader.senderCertificate); + else + res = UA_STATUSCODE_BADINTERNALERROR; + UA_CHECK_STATUS(res, goto error); + } + + /* New channel, create a security policy context and attach */ + if(!channel->securityPolicy) { + if(channel->processOPNHeader) + res = channel->processOPNHeader(application, channel, &asymHeader); + if(!channel->securityPolicy) + res = UA_STATUSCODE_BADINTERNALERROR; + UA_CHECK_STATUS(res, goto error); + } + + /* On the client side, take the SecureChannelId from the first response */ + if(secureChannelId != 0 && channel->securityToken.channelId == 0) + channel->securityToken.channelId = secureChannelId; + +#if !defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) + /* Check the ChannelId. Non-opened channels have the id zero. */ + if(secureChannelId != channel->securityToken.channelId) { + res = UA_STATUSCODE_BADSECURECHANNELIDINVALID; + goto error; + } +#endif + + /* Check the header */ + res = checkAsymHeader(channel, &asymHeader); + UA_AsymmetricAlgorithmSecurityHeader_clear(&asymHeader); + UA_CHECK_STATUS(res, return res); + + /* Decrypt the chunk payload */ + res = decryptAndVerifyChunk(channel, &channel->securityPolicy->asymmetricModule.cryptoModule, + chunk->messageType, &chunk->bytes, offset); + UA_CHECK_STATUS(res, return res); + + /* Decode the SequenceHeader */ + UA_SequenceHeader sequenceHeader; + res = UA_decodeBinaryInternal(&chunk->bytes, &offset, &sequenceHeader, + &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER], NULL); + UA_CHECK_STATUS(res, return res); + + /* Set the sequence number for the channel from which to count up */ + channel->receiveSequenceNumber = sequenceHeader.sequenceNumber; + chunk->requestId = sequenceHeader.requestId; /* Set the RequestId of the chunk */ + + /* Use only the payload */ + chunk->bytes.data += offset; + chunk->bytes.length -= offset; + return UA_STATUSCODE_GOOD; + +error: + UA_AsymmetricAlgorithmSecurityHeader_clear(&asymHeader); + return res; +} + +static UA_StatusCode +unpackPayloadMSG(UA_SecureChannel *channel, UA_Chunk *chunk) { + UA_CHECK_MEM(channel->securityPolicy, return UA_STATUSCODE_BADINTERNALERROR); + + UA_assert(chunk->bytes.length >= UA_SECURECHANNEL_MESSAGE_MIN_LENGTH); + size_t offset = UA_SECURECHANNEL_MESSAGEHEADER_LENGTH; /* Skip the message header */ + UA_UInt32 secureChannelId; + UA_UInt32 tokenId; /* SymmetricAlgorithmSecurityHeader */ + UA_StatusCode res = UA_STATUSCODE_GOOD; + res |= UA_UInt32_decodeBinary(&chunk->bytes, &offset, &secureChannelId); + res |= UA_UInt32_decodeBinary(&chunk->bytes, &offset, &tokenId); + UA_assert(offset == UA_SECURECHANNEL_MESSAGE_MIN_LENGTH); + UA_assert(res == UA_STATUSCODE_GOOD); + +#if !defined(FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION) + /* Check the ChannelId. Non-opened channels have the id zero. */ + UA_CHECK(secureChannelId == channel->securityToken.channelId, + return UA_STATUSCODE_BADSECURECHANNELIDINVALID); +#endif + + /* Check (and revolve) the SecurityToken */ + res = checkSymHeader(channel, tokenId); + UA_CHECK_STATUS(res, return res); + + /* Decrypt the chunk payload */ + res = decryptAndVerifyChunk(channel, &channel->securityPolicy->symmetricModule.cryptoModule, + chunk->messageType, &chunk->bytes, offset); + UA_CHECK_STATUS(res, return res); + + /* Check the sequence number. Skip sequence number checking for fuzzer to + * improve coverage */ + UA_SequenceHeader sequenceHeader; + res = UA_decodeBinaryInternal(&chunk->bytes, &offset, &sequenceHeader, + &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER], NULL); +#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + res |= processSequenceNumberSym(channel, sequenceHeader.sequenceNumber); +#endif + UA_CHECK_STATUS(res, return res); + + chunk->requestId = sequenceHeader.requestId; /* Set the RequestId of the chunk */ + + /* Use only the payload */ + chunk->bytes.data += offset; + chunk->bytes.length -= offset; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +assembleProcessMessage(UA_SecureChannel *channel, void *application, + UA_ProcessMessageCallback callback) { + UA_Chunk *chunk = SIMPLEQ_FIRST(&channel->decryptedChunks); + UA_assert(chunk != NULL); + + if(chunk->chunkType == UA_CHUNKTYPE_FINAL) { + SIMPLEQ_REMOVE_HEAD(&channel->decryptedChunks, pointers); + UA_assert(chunk->chunkType == UA_CHUNKTYPE_FINAL); + UA_StatusCode retval = callback(application, channel, chunk->messageType, chunk->requestId, &chunk->bytes); + UA_Chunk_delete(chunk); + return retval; + } + + UA_UInt32 requestId = chunk->requestId; + UA_MessageType messageType = chunk->messageType; + UA_ChunkType chunkType = chunk->chunkType; + UA_assert(chunkType == UA_CHUNKTYPE_INTERMEDIATE); + + size_t messageSize = 0; + SIMPLEQ_FOREACH(chunk, &channel->decryptedChunks, pointers) { + /* Consistency check */ + if(requestId != chunk->requestId) + return UA_STATUSCODE_BADINTERNALERROR; + if(chunkType != chunk->chunkType && chunk->chunkType != UA_CHUNKTYPE_FINAL) + return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + if(chunk->messageType != messageType) + return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + + /* Sum up the lengths */ + messageSize += chunk->bytes.length; + if(chunk->chunkType == UA_CHUNKTYPE_FINAL) + break; + } + + /* Allocate memory for the full message */ + UA_ByteString payload; + UA_StatusCode res = UA_ByteString_allocBuffer(&payload, messageSize); + UA_CHECK_STATUS(res, return res); + + /* Assemble the full message */ + size_t offset = 0; + while(true) { + chunk = SIMPLEQ_FIRST(&channel->decryptedChunks); + memcpy(&payload.data[offset], chunk->bytes.data, chunk->bytes.length); + offset += chunk->bytes.length; + SIMPLEQ_REMOVE_HEAD(&channel->decryptedChunks, pointers); + UA_ChunkType ct = chunk->chunkType; + UA_Chunk_delete(chunk); + if(ct == UA_CHUNKTYPE_FINAL) + break; + } + + /* Process the assembled message */ + UA_StatusCode retval = callback(application, channel, messageType, requestId, &payload); + UA_ByteString_clear(&payload); + return retval; +} + +static UA_StatusCode +persistCompleteChunks(UA_ChunkQueue *queue) { + UA_Chunk *chunk; + SIMPLEQ_FOREACH(chunk, queue, pointers) { + if(chunk->copied) + continue; + UA_ByteString copy; + UA_StatusCode retval = UA_ByteString_copy(&chunk->bytes, ©); + if(retval != UA_STATUSCODE_GOOD) + return retval; + chunk->bytes = copy; + chunk->copied = true; + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +persistIncompleteChunk(UA_SecureChannel *channel, const UA_ByteString *buffer, + size_t offset) { + UA_assert(channel->incompleteChunk.length == 0); + UA_assert(offset < buffer->length); + size_t length = buffer->length - offset; + UA_StatusCode retval = UA_ByteString_allocBuffer(&channel->incompleteChunk, length); + if(retval != UA_STATUSCODE_GOOD) + return retval; + memcpy(channel->incompleteChunk.data, &buffer->data[offset], length); + return UA_STATUSCODE_GOOD; +} + +/* Processes chunks and puts them into the payloads queue. Once a final chunk is + * put into the queue, the message is assembled and the callback is called. The + * queue will be cleared for the next message. */ +static UA_StatusCode +processChunks(UA_SecureChannel *channel, void *application, + UA_ProcessMessageCallback callback) { + UA_Chunk *chunk; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + while((chunk = SIMPLEQ_FIRST(&channel->completeChunks))) { + /* Remove from the complete-chunk queue */ + SIMPLEQ_REMOVE_HEAD(&channel->completeChunks, pointers); + + /* Check, decrypt and unpack the payload */ + if(chunk->messageType == UA_MESSAGETYPE_OPN) { + if(channel->state != UA_SECURECHANNELSTATE_OPEN && + channel->state != UA_SECURECHANNELSTATE_OPN_SENT && + channel->state != UA_SECURECHANNELSTATE_ACK_SENT) + retval = UA_STATUSCODE_BADINVALIDSTATE; + else + retval = unpackPayloadOPN(channel, chunk, application); + } else if(chunk->messageType == UA_MESSAGETYPE_MSG || + chunk->messageType == UA_MESSAGETYPE_CLO) { + if(channel->state == UA_SECURECHANNELSTATE_CLOSED) + retval = UA_STATUSCODE_BADSECURECHANNELCLOSED; + else + retval = unpackPayloadMSG(channel, chunk); + } else { + chunk->bytes.data += UA_SECURECHANNEL_MESSAGEHEADER_LENGTH; + chunk->bytes.length -= UA_SECURECHANNEL_MESSAGEHEADER_LENGTH; + } + + if(retval != UA_STATUSCODE_GOOD) { + UA_Chunk_delete(chunk); + return retval; + } + + /* Add to the decrypted queue */ + SIMPLEQ_INSERT_TAIL(&channel->decryptedChunks, chunk, pointers); + + /* Check the resource limits */ + channel->decryptedChunksCount++; + channel->decryptedChunksLength += chunk->bytes.length; + if((channel->config.localMaxChunkCount != 0 && + channel->decryptedChunksCount > channel->config.localMaxChunkCount) || + (channel->config.localMaxMessageSize != 0 && + channel->decryptedChunksLength > channel->config.localMaxMessageSize)) { + return UA_STATUSCODE_BADTCPMESSAGETOOLARGE; + } + + /* Continue */ + if(chunk->chunkType != UA_CHUNKTYPE_FINAL) + continue; + + /* The decrypted queue contains a full message. Process it. */ + retval = assembleProcessMessage(channel, application, callback); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Reset the counters */ + channel->decryptedChunksCount = 0; + channel->decryptedChunksLength = 0; + } + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +extractCompleteChunk(UA_SecureChannel *channel, const UA_ByteString *buffer, + size_t *offset, UA_Boolean *done) { + /* At least 8 byte needed for the header. Wait for the next chunk. */ + size_t initial_offset = *offset; + size_t remaining = buffer->length - initial_offset; + if(remaining < UA_SECURECHANNEL_MESSAGEHEADER_LENGTH) { + *done = true; + return UA_STATUSCODE_GOOD; + } + + /* Decoding cannot fail */ + UA_TcpMessageHeader hdr; + UA_StatusCode res = + UA_decodeBinaryInternal(buffer, &initial_offset, &hdr, + &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER], NULL); + UA_assert(res == UA_STATUSCODE_GOOD); + (void)res; /* pacify compilers if assert is ignored */ + UA_MessageType msgType = (UA_MessageType) + (hdr.messageTypeAndChunkType & UA_BITMASK_MESSAGETYPE); + UA_ChunkType chunkType = (UA_ChunkType) + (hdr.messageTypeAndChunkType & UA_BITMASK_CHUNKTYPE); + + /* The message size is not allowed */ + if(hdr.messageSize < UA_SECURECHANNEL_MESSAGE_MIN_LENGTH) + return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + if(hdr.messageSize > channel->config.recvBufferSize) + return UA_STATUSCODE_BADTCPMESSAGETOOLARGE; + + /* Incomplete chunk */ + if(hdr.messageSize > remaining) { + *done = true; + return UA_STATUSCODE_GOOD; + } + + /* ByteString with only this chunk. */ + UA_ByteString chunkPayload; + chunkPayload.data = &buffer->data[*offset]; + chunkPayload.length = hdr.messageSize; + + if(msgType == UA_MESSAGETYPE_HEL || msgType == UA_MESSAGETYPE_ACK || + msgType == UA_MESSAGETYPE_ERR || msgType == UA_MESSAGETYPE_OPN) { + if(chunkType != UA_CHUNKTYPE_FINAL) + return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + } else { + /* Only messages on SecureChannel-level with symmetric encryption afterwards */ + if(msgType != UA_MESSAGETYPE_MSG && + msgType != UA_MESSAGETYPE_CLO) + return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + + /* Check the chunk type before decrypting */ + if(chunkType != UA_CHUNKTYPE_FINAL && + chunkType != UA_CHUNKTYPE_INTERMEDIATE && + chunkType != UA_CHUNKTYPE_ABORT) + return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + } + + /* Add the chunk; forward the offset */ + *offset += hdr.messageSize; + UA_Chunk *chunk = (UA_Chunk*)UA_malloc(sizeof(UA_Chunk)); + UA_CHECK_MEM(chunk, return UA_STATUSCODE_BADOUTOFMEMORY); + + chunk->bytes = chunkPayload; + chunk->messageType = msgType; + chunk->chunkType = chunkType; + chunk->requestId = 0; + chunk->copied = false; + + SIMPLEQ_INSERT_TAIL(&channel->completeChunks, chunk, pointers); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_SecureChannel_processBuffer(UA_SecureChannel *channel, void *application, + UA_ProcessMessageCallback callback, + const UA_ByteString *buffer) { + /* Prepend the incomplete last chunk. This is usually done in the + * networklayer. But we test for a buffered incomplete chunk here again to + * work around "lazy" network layers. */ + UA_ByteString appended = channel->incompleteChunk; + if(appended.length > 0) { + channel->incompleteChunk = UA_BYTESTRING_NULL; + UA_Byte *t = (UA_Byte*)UA_realloc(appended.data, appended.length + buffer->length); + UA_CHECK_MEM(t, UA_ByteString_clear(&appended); + return UA_STATUSCODE_BADOUTOFMEMORY); + memcpy(&t[appended.length], buffer->data, buffer->length); + appended.data = t; + appended.length += buffer->length; + buffer = &appended; + } + + /* Loop over the received chunks */ + size_t offset = 0; + UA_Boolean done = false; + UA_StatusCode res; + while(!done) { + res = extractCompleteChunk(channel, buffer, &offset, &done); + UA_CHECK_STATUS(res, goto cleanup); + } + + /* Buffer half-received chunk. Before processing the messages so that + * processing is reentrant. */ + if(offset < buffer->length) { + res = persistIncompleteChunk(channel, buffer, offset); + UA_CHECK_STATUS(res, goto cleanup); + } + + /* Process whatever we can. Chunks of completed and processed messages are + * removed. */ + res = processChunks(channel, application, callback); + UA_CHECK_STATUS(res, goto cleanup); + + /* Persist full chunks that still point to the buffer. Can only return + * UA_STATUSCODE_BADOUTOFMEMORY as an error code. So merging res works. */ + res |= persistCompleteChunks(&channel->completeChunks); + res |= persistCompleteChunks(&channel->decryptedChunks); + + cleanup: + UA_ByteString_clear(&appended); + return res; +} + +UA_StatusCode +UA_SecureChannel_receive(UA_SecureChannel *channel, void *application, + UA_ProcessMessageCallback callback, UA_UInt32 timeout) { + UA_Connection *connection = channel->connection; + UA_CHECK_MEM(connection, return UA_STATUSCODE_BADINTERNALERROR); + + /* Listen for messages to arrive */ + UA_ByteString buffer = UA_BYTESTRING_NULL; + UA_StatusCode retval = connection->ua_recv(connection, &buffer, timeout); + UA_CHECK_STATUS(retval, return retval); + + /* Try to process one complete chunk */ + retval = UA_SecureChannel_processBuffer(channel, application, callback, &buffer); + connection->releaseRecvBuffer(connection, &buffer); + return retval; +} + +/**** amalgamated original file "/src/ua_securechannel_crypto.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2016-2017 (c) Florian Palm + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016 (c) TorbenD + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017-2018 (c) Mark Giraud, Fraunhofer IOSB + */ + + + +UA_StatusCode +UA_SecureChannel_generateLocalNonce(UA_SecureChannel *channel) { + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_CHECK_MEM(sp, return UA_STATUSCODE_BADINTERNALERROR); + UA_LOG_DEBUG_CHANNEL(sp->logger, channel, "Generating new local nonce"); + + /* Is the length of the previous nonce correct? */ + size_t nonceLength = sp->symmetricModule.secureChannelNonceLength; + if(channel->localNonce.length != nonceLength) { + UA_ByteString_clear(&channel->localNonce); + UA_StatusCode res = UA_ByteString_allocBuffer(&channel->localNonce, nonceLength); + UA_CHECK_STATUS(res, return res); + } + + /* Generate the nonce */ + return sp->symmetricModule.generateNonce(sp->policyContext, &channel->localNonce); +} + +UA_StatusCode +UA_SecureChannel_generateLocalKeys(const UA_SecureChannel *channel) { + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_CHECK_MEM(sp, return UA_STATUSCODE_BADINTERNALERROR); + UA_LOG_TRACE_CHANNEL(sp->logger, channel, "Generating new local keys"); + + void *cc = channel->channelContext; + const UA_SecurityPolicyChannelModule *cm = &sp->channelModule; + const UA_SecurityPolicySymmetricModule *sm = &sp->symmetricModule; + const UA_SecurityPolicyCryptoModule *crm = &sm->cryptoModule; + + /* Generate symmetric key buffer of the required length. The block size is + * identical for local/remote. */ + UA_ByteString buf; + size_t encrKL = crm->encryptionAlgorithm.getLocalKeyLength(cc); + size_t encrBS = crm->encryptionAlgorithm.getRemoteBlockSize(cc); + size_t signKL = crm->signatureAlgorithm.getLocalKeyLength(cc); + if(encrBS + signKL + encrKL == 0) + return UA_STATUSCODE_GOOD; /* No keys to generate */ + + UA_StatusCode retval = UA_ByteString_allocBuffer(&buf, encrBS + signKL + encrKL); + UA_CHECK_STATUS(retval, return retval); + UA_ByteString localSigningKey = {signKL, buf.data}; + UA_ByteString localEncryptingKey = {encrKL, &buf.data[signKL]}; + UA_ByteString localIv = {encrBS, &buf.data[signKL + encrKL]}; + + /* Generate key */ + retval = sm->generateKey(sp->policyContext, &channel->remoteNonce, + &channel->localNonce, &buf); + UA_CHECK_STATUS(retval, goto error); + + /* Set the channel context */ + retval |= cm->setLocalSymSigningKey(cc, &localSigningKey); + retval |= cm->setLocalSymEncryptingKey(cc, &localEncryptingKey); + retval |= cm->setLocalSymIv(cc, &localIv); + + error: + UA_CHECK_STATUS(retval, UA_LOG_WARNING_CHANNEL(sp->logger, channel, + "Could not generate local keys (statuscode: %s)", + UA_StatusCode_name(retval))); + UA_ByteString_clear(&buf); + return retval; +} + +UA_StatusCode +generateRemoteKeys(const UA_SecureChannel *channel) { + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_CHECK_MEM(sp, return UA_STATUSCODE_BADINTERNALERROR); + UA_LOG_TRACE_CHANNEL(sp->logger, channel, "Generating new remote keys"); + + void *cc = channel->channelContext; + const UA_SecurityPolicyChannelModule *cm = &sp->channelModule; + const UA_SecurityPolicySymmetricModule *sm = &sp->symmetricModule; + const UA_SecurityPolicyCryptoModule *crm = &sm->cryptoModule; + + /* Generate symmetric key buffer of the required length */ + UA_ByteString buf; + size_t encrKL = crm->encryptionAlgorithm.getRemoteKeyLength(cc); + size_t encrBS = crm->encryptionAlgorithm.getRemoteBlockSize(cc); + size_t signKL = crm->signatureAlgorithm.getRemoteKeyLength(cc); + if(encrBS + signKL + encrKL == 0) + return UA_STATUSCODE_GOOD; /* No keys to generate */ + + UA_StatusCode retval = UA_ByteString_allocBuffer(&buf, encrBS + signKL + encrKL); + UA_CHECK_STATUS(retval, return retval); + UA_ByteString remoteSigningKey = {signKL, buf.data}; + UA_ByteString remoteEncryptingKey = {encrKL, &buf.data[signKL]}; + UA_ByteString remoteIv = {encrBS, &buf.data[signKL + encrKL]}; + + /* Generate key */ + retval = sm->generateKey(sp->policyContext, &channel->localNonce, + &channel->remoteNonce, &buf); + UA_CHECK_STATUS(retval, goto error); + + /* Set the channel context */ + retval |= cm->setRemoteSymSigningKey(cc, &remoteSigningKey); + retval |= cm->setRemoteSymEncryptingKey(cc, &remoteEncryptingKey); + retval |= cm->setRemoteSymIv(cc, &remoteIv); + + error: + UA_CHECK_STATUS(retval, UA_LOG_WARNING_CHANNEL(sp->logger, channel, + "Could not generate remote keys (statuscode: %s)", + UA_StatusCode_name(retval))); + UA_ByteString_clear(&buf); + return retval; +} + +/***************************/ +/* Send Asymmetric Message */ +/***************************/ + +/* The length of the static header content */ +#define UA_SECURECHANNEL_ASYMMETRIC_SECURITYHEADER_FIXED_LENGTH 12 + +size_t +calculateAsymAlgSecurityHeaderLength(const UA_SecureChannel *channel) { + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_CHECK_MEM(sp, return UA_STATUSCODE_BADINTERNALERROR); + + size_t asymHeaderLength = UA_SECURECHANNEL_ASYMMETRIC_SECURITYHEADER_FIXED_LENGTH + + sp->policyUri.length; + if(channel->securityMode == UA_MESSAGESECURITYMODE_NONE) + return asymHeaderLength; + + /* OPN is always encrypted even if the mode is sign only */ + asymHeaderLength += 20; /* Thumbprints are always 20 byte long */ + asymHeaderLength += sp->localCertificate.length; + return asymHeaderLength; +} + +UA_StatusCode +prependHeadersAsym(UA_SecureChannel *const channel, UA_Byte *header_pos, + const UA_Byte *buf_end, size_t totalLength, + size_t securityHeaderLength, UA_UInt32 requestId, + size_t *const encryptedLength) { + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_CHECK_MEM(sp, return UA_STATUSCODE_BADINTERNALERROR); + + if(channel->securityMode == UA_MESSAGESECURITYMODE_NONE) { + *encryptedLength = totalLength; + } else { + size_t dataToEncryptLength = totalLength - + (UA_SECURECHANNEL_CHANNELHEADER_LENGTH + securityHeaderLength); + size_t plainTextBlockSize = sp->asymmetricModule.cryptoModule. + encryptionAlgorithm.getRemotePlainTextBlockSize(channel->channelContext); + size_t encryptedBlockSize = sp->asymmetricModule.cryptoModule. + encryptionAlgorithm.getRemoteBlockSize(channel->channelContext); + + /* Padding always fills up the last block */ + UA_assert(dataToEncryptLength % plainTextBlockSize == 0); + size_t blocks = dataToEncryptLength / plainTextBlockSize; + *encryptedLength = totalLength + blocks * (encryptedBlockSize - plainTextBlockSize); + } + + UA_TcpMessageHeader messageHeader; + messageHeader.messageTypeAndChunkType = UA_MESSAGETYPE_OPN + UA_CHUNKTYPE_FINAL; + messageHeader.messageSize = (UA_UInt32)*encryptedLength; + UA_UInt32 secureChannelId = channel->securityToken.channelId; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + retval |= UA_encodeBinaryInternal(&messageHeader, + &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER], + &header_pos, &buf_end, NULL, NULL); + retval |= UA_UInt32_encodeBinary(&secureChannelId, &header_pos, buf_end); + UA_CHECK_STATUS(retval, return retval); + + UA_AsymmetricAlgorithmSecurityHeader asymHeader; + UA_AsymmetricAlgorithmSecurityHeader_init(&asymHeader); + asymHeader.securityPolicyUri = sp->policyUri; + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGN || + channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + asymHeader.senderCertificate = sp->localCertificate; + asymHeader.receiverCertificateThumbprint.length = 20; + asymHeader.receiverCertificateThumbprint.data = channel->remoteCertificateThumbprint; + } + retval = UA_encodeBinaryInternal(&asymHeader, + &UA_TRANSPORT[UA_TRANSPORT_ASYMMETRICALGORITHMSECURITYHEADER], + &header_pos, &buf_end, NULL, NULL); + UA_CHECK_STATUS(retval, return retval); + + UA_SequenceHeader seqHeader; + seqHeader.requestId = requestId; + seqHeader.sequenceNumber = UA_atomic_addUInt32(&channel->sendSequenceNumber, 1); + retval = UA_encodeBinaryInternal(&seqHeader, &UA_TRANSPORT[UA_TRANSPORT_SEQUENCEHEADER], + &header_pos, &buf_end, NULL, NULL); + return retval; +} + +void +hideBytesAsym(const UA_SecureChannel *channel, UA_Byte **buf_start, + const UA_Byte **buf_end) { + /* Set buf_start to the beginning of the payload body */ + *buf_start += UA_SECURECHANNEL_CHANNELHEADER_LENGTH; + *buf_start += calculateAsymAlgSecurityHeaderLength(channel); + *buf_start += UA_SECURECHANNEL_SEQUENCEHEADER_LENGTH; + +#ifdef UA_ENABLE_ENCRYPTION + if(channel->securityMode == UA_MESSAGESECURITYMODE_NONE) + return; + + /* Make space for the certificate */ + const UA_SecurityPolicy *sp = channel->securityPolicy; + *buf_end -= sp->asymmetricModule.cryptoModule.signatureAlgorithm. + getLocalSignatureSize(channel->channelContext); + + /* Block sizes depend on the remote key (certificate) */ + size_t plainTextBlockSize = sp->asymmetricModule.cryptoModule. + encryptionAlgorithm.getRemotePlainTextBlockSize(channel->channelContext); + size_t encryptedBlockSize = sp->asymmetricModule.cryptoModule. + encryptionAlgorithm.getRemoteBlockSize(channel->channelContext); + UA_Boolean extraPadding = (sp->asymmetricModule.cryptoModule.encryptionAlgorithm. + getRemoteKeyLength(channel->channelContext) > 2048); + + /* Compute the maximum number of encrypted blocks that can fit entirely + * before the signature. From that compute the maximum usable plaintext + * size. */ + size_t maxEncrypted = (size_t)(*buf_end - *buf_start) + + UA_SECURECHANNEL_SEQUENCEHEADER_LENGTH; + size_t max_blocks = maxEncrypted / encryptedBlockSize; + size_t paddingBytes = (UA_LIKELY(!extraPadding)) ? 1u : 2u; + *buf_end = *buf_start + (max_blocks * plainTextBlockSize) - + UA_SECURECHANNEL_SEQUENCEHEADER_LENGTH - paddingBytes; +#endif +} + +#ifdef UA_ENABLE_ENCRYPTION + +/* Assumes that pos can be advanced to the end of the current block */ +void +padChunk(UA_SecureChannel *channel, const UA_SecurityPolicyCryptoModule *cm, + const UA_Byte *start, UA_Byte **pos) { + const size_t bytesToWrite = (uintptr_t)*pos - (uintptr_t)start; + size_t signatureSize = cm->signatureAlgorithm. + getLocalSignatureSize(channel->channelContext); + size_t plainTextBlockSize = cm->encryptionAlgorithm. + getRemotePlainTextBlockSize(channel->channelContext); + UA_Boolean extraPadding = (cm->encryptionAlgorithm. + getRemoteKeyLength(channel->channelContext) > 2048); + size_t paddingBytes = (UA_LIKELY(!extraPadding)) ? 1u : 2u; + + size_t lastBlock = ((bytesToWrite + signatureSize + paddingBytes) % plainTextBlockSize); + size_t paddingLength = (lastBlock != 0) ? plainTextBlockSize - lastBlock : 0; + + UA_LOG_TRACE_CHANNEL(channel->securityPolicy->logger, channel, + "Add %lu bytes of padding plus %lu padding size bytes", + (long unsigned int)paddingLength, + (long unsigned int)paddingBytes); + + /* Write the padding. This is <= because the paddingSize byte also has to be + * written */ + UA_Byte paddingByte = (UA_Byte)paddingLength; + for(UA_UInt16 i = 0; i <= paddingLength; ++i) { + **pos = paddingByte; + ++*pos; + } + + /* Write the extra padding byte if required */ + if(extraPadding) { + **pos = (UA_Byte)(paddingLength >> 8u); + ++*pos; + } +} + +UA_StatusCode +signAndEncryptAsym(UA_SecureChannel *channel, size_t preSignLength, + UA_ByteString *buf, size_t securityHeaderLength, + size_t totalLength) { + if(channel->securityMode != UA_MESSAGESECURITYMODE_SIGN && + channel->securityMode != UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + return UA_STATUSCODE_GOOD; + + /* Sign message */ + const UA_SecurityPolicy *sp = channel->securityPolicy; + const UA_ByteString dataToSign = {preSignLength, buf->data}; + size_t sigsize = sp->asymmetricModule.cryptoModule.signatureAlgorithm. + getLocalSignatureSize(channel->channelContext); + UA_ByteString signature = {sigsize, buf->data + preSignLength}; + UA_StatusCode retval = sp->asymmetricModule.cryptoModule.signatureAlgorithm. + sign(channel->channelContext, &dataToSign, &signature); + UA_CHECK_STATUS(retval, return retval); + + /* Specification part 6, 6.7.4: The OpenSecureChannel Messages are + * signed and encrypted if the SecurityMode is not None (even if the + * SecurityMode is SignOnly). */ + size_t unencrypted_length = + UA_SECURECHANNEL_CHANNELHEADER_LENGTH + securityHeaderLength; + UA_ByteString dataToEncrypt = {totalLength - unencrypted_length, + &buf->data[unencrypted_length]}; + return sp->asymmetricModule.cryptoModule.encryptionAlgorithm. + encrypt(channel->channelContext, &dataToEncrypt); +} + +/**************************/ +/* Send Symmetric Message */ +/**************************/ + +UA_StatusCode +signAndEncryptSym(UA_MessageContext *messageContext, + size_t preSigLength, size_t totalLength) { + const UA_SecureChannel *channel = messageContext->channel; + if(channel->securityMode == UA_MESSAGESECURITYMODE_NONE) + return UA_STATUSCODE_GOOD; + + /* Sign */ + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_ByteString dataToSign = messageContext->messageBuffer; + dataToSign.length = preSigLength; + UA_ByteString signature; + signature.length = sp->symmetricModule.cryptoModule.signatureAlgorithm. + getLocalSignatureSize(channel->channelContext); + signature.data = messageContext->buf_pos; + UA_StatusCode res = sp->symmetricModule.cryptoModule.signatureAlgorithm. + sign(channel->channelContext, &dataToSign, &signature); + UA_CHECK_STATUS(res, return res); + + if(channel->securityMode != UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + return UA_STATUSCODE_GOOD; + + /* Encrypt */ + UA_ByteString dataToEncrypt; + dataToEncrypt.data = messageContext->messageBuffer.data + + UA_SECURECHANNEL_CHANNELHEADER_LENGTH + + UA_SECURECHANNEL_SYMMETRIC_SECURITYHEADER_LENGTH; + dataToEncrypt.length = totalLength - + (UA_SECURECHANNEL_CHANNELHEADER_LENGTH + + UA_SECURECHANNEL_SYMMETRIC_SECURITYHEADER_LENGTH); + return sp->symmetricModule.cryptoModule.encryptionAlgorithm. + encrypt(channel->channelContext, &dataToEncrypt); +} + +#endif /* UA_ENABLE_ENCRYPTION */ + +void +setBufPos(UA_MessageContext *mc) { + /* Forward the data pointer so that the payload is encoded after the message + * header. This has to be a symmetric message because OPN (with asymmetric + * encryption) does not support chunking. */ + mc->buf_pos = &mc->messageBuffer.data[UA_SECURECHANNEL_SYMMETRIC_HEADER_TOTALLENGTH]; + mc->buf_end = &mc->messageBuffer.data[mc->messageBuffer.length]; + +#ifdef UA_ENABLE_ENCRYPTION + if(mc->channel->securityMode == UA_MESSAGESECURITYMODE_NONE) + return; + + const UA_SecureChannel *channel = mc->channel; + const UA_SecurityPolicy *sp = channel->securityPolicy; + size_t sigsize = sp->symmetricModule.cryptoModule.signatureAlgorithm. + getLocalSignatureSize(channel->channelContext); + size_t plainBlockSize = sp->symmetricModule.cryptoModule. + encryptionAlgorithm.getRemotePlainTextBlockSize(channel->channelContext); + + /* Assuming that for symmetric encryption the plainTextBlockSize == + * cypherTextBlockSize. For symmetric encryption the remote/local block + * sizes are identical. */ + UA_assert(sp->symmetricModule.cryptoModule.encryptionAlgorithm. + getRemoteBlockSize(channel->channelContext) == plainBlockSize); + + /* Leave enough space for the signature and padding */ + mc->buf_end -= sigsize; + mc->buf_end -= mc->messageBuffer.length % plainBlockSize; + + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + /* Reserve space for the padding bytes */ + UA_Boolean extraPadding = + (sp->symmetricModule.cryptoModule.encryptionAlgorithm. + getRemoteKeyLength(channel->channelContext) > 2048); + mc->buf_end -= (UA_LIKELY(!extraPadding)) ? 1 : 2; + } + + UA_LOG_TRACE_CHANNEL(sp->logger, channel, + "Prepare a symmetric message buffer of length %lu " + "with a usable maximum payload length of %lu", + (long unsigned)mc->messageBuffer.length, + (long unsigned)((uintptr_t)mc->buf_end - + (uintptr_t)mc->messageBuffer.data)); +#endif +} + +/****************************/ +/* Process a received Chunk */ +/****************************/ + +static size_t +decodePadding(const UA_SecureChannel *channel, + const UA_SecurityPolicyCryptoModule *cryptoModule, + const UA_ByteString *chunk, size_t sigsize) { + /* Read the byte with the padding size */ + size_t paddingSize = chunk->data[chunk->length - sigsize - 1]; + + /* Extra padding size */ + if(cryptoModule->encryptionAlgorithm. + getLocalKeyLength(channel->channelContext) > 2048) { + paddingSize <<= 8u; + paddingSize += chunk->data[chunk->length - sigsize - 2]; + paddingSize += 1; /* Extra padding byte itself */ + } + + /* Add one since the paddingSize byte itself needs to be removed as well */ + return paddingSize + 1; +} + +static UA_StatusCode +verifySignature(const UA_SecureChannel *channel, + const UA_SecurityPolicyCryptoModule *cryptoModule, + const UA_ByteString *chunk, size_t sigsize) { + UA_LOG_TRACE_CHANNEL(channel->securityPolicy->logger, channel, + "Verifying chunk signature"); + UA_CHECK(sigsize < chunk->length, return UA_STATUSCODE_BADSECURITYCHECKSFAILED); + const UA_ByteString content = {chunk->length - sigsize, chunk->data}; + const UA_ByteString sig = {sigsize, chunk->data + chunk->length - sigsize}; + UA_StatusCode retval = cryptoModule->signatureAlgorithm. + verify(channel->channelContext, &content, &sig); +#ifdef UA_ENABLE_UNIT_TEST_FAILURE_HOOKS + retval |= decrypt_verifySignatureFailure; +#endif + return retval; +} + +/* Sets the payload to a pointer inside the chunk buffer. Returns the requestId + * and the sequenceNumber */ +UA_StatusCode +decryptAndVerifyChunk(const UA_SecureChannel *channel, + const UA_SecurityPolicyCryptoModule *cryptoModule, + UA_MessageType messageType, UA_ByteString *chunk, + size_t offset) { + /* Decrypt the chunk */ + UA_StatusCode res = UA_STATUSCODE_GOOD; + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT || + messageType == UA_MESSAGETYPE_OPN) { + UA_ByteString cipher = {chunk->length - offset, chunk->data + offset}; + res = cryptoModule->encryptionAlgorithm.decrypt(channel->channelContext, &cipher); + UA_CHECK_STATUS(res, return res); + chunk->length = cipher.length + offset; + } + + /* Does the message have a signature? */ + if(channel->securityMode != UA_MESSAGESECURITYMODE_SIGN && + channel->securityMode != UA_MESSAGESECURITYMODE_SIGNANDENCRYPT && + messageType != UA_MESSAGETYPE_OPN) + return UA_STATUSCODE_GOOD; + + /* Verify the chunk signature */ + size_t sigsize = cryptoModule->signatureAlgorithm. + getRemoteSignatureSize(channel->channelContext); + res = verifySignature(channel, cryptoModule, chunk, sigsize); + UA_CHECK_STATUS(res, + UA_LOG_WARNING_CHANNEL(channel->securityPolicy->logger, channel, + "Could not verify the signature"); return res); + + /* Compute the padding if the payload as encrypted */ + size_t padSize = 0; + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT || + (messageType == UA_MESSAGETYPE_OPN && + cryptoModule->encryptionAlgorithm.uri.length > 0)) { + padSize = decodePadding(channel, cryptoModule, chunk, sigsize); + UA_LOG_TRACE_CHANNEL(channel->securityPolicy->logger, channel, + "Calculated padding size to be %lu", + (long unsigned)padSize); + } + + /* Verify the content length. The encrypted payload has to be at least 9 + * bytes long: 8 byte for the SequenceHeader and one byte for the actual + * message */ + UA_CHECK(offset + padSize + sigsize + 9 < chunk->length, + UA_LOG_WARNING_CHANNEL(channel->securityPolicy->logger, channel, + "Impossible padding value"); + return UA_STATUSCODE_BADSECURITYCHECKSFAILED); + + /* Hide the signature and padding */ + chunk->length -= (sigsize + padSize); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +checkAsymHeader(UA_SecureChannel *channel, + const UA_AsymmetricAlgorithmSecurityHeader *asymHeader) { + const UA_SecurityPolicy *sp = channel->securityPolicy; + if(!UA_ByteString_equal(&sp->policyUri, &asymHeader->securityPolicyUri)) + return UA_STATUSCODE_BADSECURITYPOLICYREJECTED; + + return sp->asymmetricModule. + compareCertificateThumbprint(sp, &asymHeader->receiverCertificateThumbprint); + + /* The certificate in the header is verified via the configured PKI plugin + * as certificateVerification.verifyCertificate(...). We cannot do it here + * because the client/server context is needed. */ +} + +UA_StatusCode +checkSymHeader(UA_SecureChannel *channel, const UA_UInt32 tokenId) { + /* If no match, try to revolve to the next token after a + * RenewSecureChannel */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_ChannelSecurityToken *token = &channel->securityToken; + switch(channel->renewState) { + case UA_SECURECHANNELRENEWSTATE_NORMAL: + case UA_SECURECHANNELRENEWSTATE_SENT: + default: + break; + + case UA_SECURECHANNELRENEWSTATE_NEWTOKEN_SERVER: + /* Old token still in use */ + if(tokenId == channel->securityToken.tokenId) + break; + + /* Not the new token */ + UA_CHECK(tokenId == channel->altSecurityToken.tokenId, + UA_LOG_WARNING_CHANNEL(channel->securityPolicy->logger, channel, + "Unknown SecurityToken"); + return UA_STATUSCODE_BADSECURECHANNELTOKENUNKNOWN); + + /* Roll over to the new token, generate new local and remote keys */ + channel->renewState = UA_SECURECHANNELRENEWSTATE_NORMAL; + channel->securityToken = channel->altSecurityToken; + UA_ChannelSecurityToken_init(&channel->altSecurityToken); + retval |= UA_SecureChannel_generateLocalKeys(channel); + retval |= generateRemoteKeys(channel); + UA_CHECK_STATUS(retval, return retval); + break; + + case UA_SECURECHANNELRENEWSTATE_NEWTOKEN_CLIENT: + /* The server is still using the old token. That's okay. */ + if(tokenId == channel->altSecurityToken.tokenId) { + token = &channel->altSecurityToken; + break; + } + + /* Not the new token */ + UA_CHECK(tokenId == channel->securityToken.tokenId, + UA_LOG_WARNING_CHANNEL(channel->securityPolicy->logger, channel, + "Unknown SecurityToken"); + return UA_STATUSCODE_BADSECURECHANNELTOKENUNKNOWN); + + /* The remote server uses the new token for the first time. Delete the + * old token and roll the remote key over. The local key already uses + * the nonce pair from the last OPN exchange. */ + channel->renewState = UA_SECURECHANNELRENEWSTATE_NORMAL; + UA_ChannelSecurityToken_init(&channel->altSecurityToken); + retval = generateRemoteKeys(channel); + UA_CHECK_STATUS(retval, return retval); + } + + UA_DateTime timeout = token->createdAt + (token->revisedLifetime * UA_DATETIME_MSEC); + if(channel->state == UA_SECURECHANNELSTATE_OPEN && + timeout < UA_DateTime_nowMonotonic()) { + UA_LOG_WARNING_CHANNEL(channel->securityPolicy->logger, channel, + "SecurityToken timed out"); + UA_SecureChannel_close(channel); + return UA_STATUSCODE_BADSECURECHANNELCLOSED; + } + + return UA_STATUSCODE_GOOD; +} + +/**** amalgamated original file "/src/server/ua_session.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + +#ifdef UA_ENABLE_SUBSCRIPTIONS +#endif + +#define UA_SESSION_NONCELENTH 32 + +void UA_Session_init(UA_Session *session) { + memset(session, 0, sizeof(UA_Session)); + session->availableContinuationPoints = UA_MAXCONTINUATIONPOINTS; +#ifdef UA_ENABLE_SUBSCRIPTIONS + SIMPLEQ_INIT(&session->responseQueue); + TAILQ_INIT(&session->subscriptions); +#endif +} + +void UA_Session_clear(UA_Session *session, UA_Server* server) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Remove all Subscriptions. This may send out remaining publish + * responses. */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_Subscription *sub, *tempsub; + TAILQ_FOREACH_SAFE(sub, &session->subscriptions, sessionListEntry, tempsub) { + UA_Subscription_delete(server, sub); + } +#endif + + UA_Session_detachFromSecureChannel(session); + UA_ApplicationDescription_clear(&session->clientDescription); + UA_NodeId_clear(&session->header.authenticationToken); + UA_NodeId_clear(&session->sessionId); + UA_String_clear(&session->sessionName); + UA_ByteString_clear(&session->serverNonce); + struct ContinuationPoint *cp, *next = session->continuationPoints; + while((cp = next)) { + next = ContinuationPoint_clear(cp); + UA_free(cp); + } + session->continuationPoints = NULL; + session->availableContinuationPoints = UA_MAXCONTINUATIONPOINTS; + + UA_Array_delete(session->params, session->paramsSize, + &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); + session->params = NULL; + session->paramsSize = 0; +} + +void +UA_Session_attachToSecureChannel(UA_Session *session, UA_SecureChannel *channel) { + UA_Session_detachFromSecureChannel(session); + session->header.channel = channel; + SLIST_INSERT_HEAD(&channel->sessions, &session->header, next); +} + +void +UA_Session_detachFromSecureChannel(UA_Session *session) { + UA_SecureChannel *channel = session->header.channel; + if(!channel) + return; + session->header.channel = NULL; + UA_SessionHeader *sh; + SLIST_FOREACH(sh, &channel->sessions, next) { + if((UA_Session*)sh != session) + continue; + SLIST_REMOVE(&channel->sessions, sh, UA_SessionHeader, next); + break; + } +} + +UA_StatusCode +UA_Session_generateNonce(UA_Session *session) { + UA_SecureChannel *channel = session->header.channel; + if(!channel || !channel->securityPolicy) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Is the length of the previous nonce correct? */ + if(session->serverNonce.length != UA_SESSION_NONCELENTH) { + UA_ByteString_clear(&session->serverNonce); + UA_StatusCode retval = + UA_ByteString_allocBuffer(&session->serverNonce, UA_SESSION_NONCELENTH); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + return channel->securityPolicy->symmetricModule. + generateNonce(channel->securityPolicy->policyContext, &session->serverNonce); +} + +void UA_Session_updateLifetime(UA_Session *session) { + session->validTill = UA_DateTime_nowMonotonic() + + (UA_DateTime)(session->timeout * UA_DATETIME_MSEC); +} + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +void +UA_Session_attachSubscription(UA_Session *session, UA_Subscription *sub) { + /* Attach to the session */ + sub->session = session; + TAILQ_INSERT_TAIL(&session->subscriptions, sub, sessionListEntry); + + /* Increase the count */ + session->subscriptionsSize++; + + /* Increase the number of outstanding retransmissions */ + session->totalRetransmissionQueueSize += sub->retransmissionQueueSize; +} + +void +UA_Session_detachSubscription(UA_Server *server, UA_Session *session, + UA_Subscription *sub) { + /* Detach from the session */ + sub->session = NULL; + TAILQ_REMOVE(&session->subscriptions, sub, sessionListEntry); + + /* Reduce the count */ + UA_assert(session->subscriptionsSize > 0); + session->subscriptionsSize--; + + /* Reduce the number of outstanding retransmissions */ + session->totalRetransmissionQueueSize -= sub->retransmissionQueueSize; + + /* Send remaining publish responses if the last subscription was removed */ + if(!TAILQ_EMPTY(&session->subscriptions)) + return; + UA_PublishResponseEntry *pre; + while((pre = UA_Session_dequeuePublishReq(session))) { + UA_PublishResponse *response = &pre->response; + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOSUBSCRIPTION; + response->responseHeader.timestamp = UA_DateTime_now(); + sendResponse(server, session, session->header.channel, pre->requestId, + (UA_Response*)response, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); + UA_PublishResponse_clear(response); + UA_free(pre); + } +} + +UA_Subscription * +UA_Session_getSubscriptionById(UA_Session *session, UA_UInt32 subscriptionId) { + UA_Subscription *sub; + TAILQ_FOREACH(sub, &session->subscriptions, sessionListEntry) { + /* Prevent lookup of subscriptions that are to be deleted with a statuschange */ + if(sub->statusChange != UA_STATUSCODE_GOOD) + continue; + if(sub->subscriptionId == subscriptionId) + break; + } + return sub; +} + +UA_Subscription * +UA_Server_getSubscriptionById(UA_Server *server, UA_UInt32 subscriptionId) { + UA_Subscription *sub; + LIST_FOREACH(sub, &server->subscriptions, serverListEntry) { + /* Prevent lookup of subscriptions that are to be deleted with a statuschange */ + if(sub->statusChange != UA_STATUSCODE_GOOD) + continue; + if(sub->subscriptionId == subscriptionId) + break; + } + return sub; +} + +UA_PublishResponseEntry* +UA_Session_dequeuePublishReq(UA_Session *session) { + UA_PublishResponseEntry* entry = SIMPLEQ_FIRST(&session->responseQueue); + if(entry) { + SIMPLEQ_REMOVE_HEAD(&session->responseQueue, listEntry); + session->numPublishReq--; + } + return entry; +} + +void +UA_Session_queuePublishReq(UA_Session *session, UA_PublishResponseEntry* entry, UA_Boolean head) { + if(!head) + SIMPLEQ_INSERT_TAIL(&session->responseQueue, entry, listEntry); + else + SIMPLEQ_INSERT_HEAD(&session->responseQueue, entry, listEntry); + session->numPublishReq++; +} + +#endif + +/* Session Handling */ + +UA_StatusCode +UA_Server_closeSession(UA_Server *server, const UA_NodeId *sessionId) { + UA_LOCK(&server->serviceMutex); + session_list_entry *entry; + UA_StatusCode res = UA_STATUSCODE_BADSESSIONIDINVALID; + LIST_FOREACH(entry, &server->sessions, pointers) { + if(UA_NodeId_equal(&entry->session.sessionId, sessionId)) { + UA_Server_removeSession(server, entry, UA_DIAGNOSTICEVENT_CLOSE); + res = UA_STATUSCODE_GOOD; + break; + } + } + UA_UNLOCK(&server->serviceMutex); + return res; +} + +UA_StatusCode +UA_Server_setSessionParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, const UA_Variant *parameter) { + UA_LOCK(&server->serviceMutex); + UA_Session *session = UA_Server_getSessionById(server, sessionId); + UA_StatusCode res = UA_STATUSCODE_BADSESSIONIDINVALID; + if(session) + res = UA_KeyValueMap_set(&session->params, &session->paramsSize, + name, parameter); + UA_UNLOCK(&server->serviceMutex); + return res; +} + +void +UA_Server_deleteSessionParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name) { + UA_LOCK(&server->serviceMutex); + UA_Session *session = UA_Server_getSessionById(server, sessionId); + if(session) + UA_KeyValueMap_delete(&session->params, &session->paramsSize, name); + UA_UNLOCK(&server->serviceMutex); +} + +UA_StatusCode +UA_Server_getSessionParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, UA_Variant *outParameter) { + UA_LOCK(&server->serviceMutex); + if(!outParameter) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINTERNALERROR; + } + + UA_Session *session = UA_Server_getSessionById(server, sessionId); + if(!session) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADSESSIONIDINVALID; + } + + const UA_Variant *param = + UA_KeyValueMap_get(session->params, session->paramsSize, name); + if(!param) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADNOTFOUND; + } + + UA_StatusCode res = UA_Variant_copy(param, outParameter); + UA_UNLOCK(&server->serviceMutex); + return res; +} + +UA_StatusCode +UA_Server_getSessionScalarParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, const UA_DataType *type, + UA_Variant *outParameter) { + UA_LOCK(&server->serviceMutex); + if(!outParameter) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINTERNALERROR; + } + + UA_Session *session = UA_Server_getSessionById(server, sessionId); + if(!session) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADSESSIONIDINVALID; + } + + const UA_Variant *param = + UA_KeyValueMap_get(session->params, session->paramsSize, name); + if(!param || !UA_Variant_hasScalarType(param, type)) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADNOTFOUND; + } + + UA_StatusCode res = UA_Variant_copy(param, outParameter); + UA_UNLOCK(&server->serviceMutex); + return res; +} + +UA_StatusCode +UA_Server_getSessionArrayParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, const UA_DataType *type, + UA_Variant *outParameter) { + UA_LOCK(&server->serviceMutex); + if(!outParameter) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINTERNALERROR; + } + + UA_Session *session = UA_Server_getSessionById(server, sessionId); + if(!session) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADSESSIONIDINVALID; + } + + const UA_Variant *param = + UA_KeyValueMap_get(session->params, session->paramsSize, name); + if(!param || !UA_Variant_hasArrayType(param, type)) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADNOTFOUND; + } + + UA_StatusCode res = UA_Variant_copy(param, outParameter); + UA_UNLOCK(&server->serviceMutex); + return res; +} + +/**** amalgamated original file "/src/server/ua_nodes.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2018, 2021 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015, 2017 (c) Florian Palm + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Julian Grothoff + */ + + +/*****************/ +/* Node Pointers */ +/*****************/ + +#define UA_NODEPOINTER_MASK 0x03 +#define UA_NODEPOINTER_TAG_IMMEDIATE 0x00 +#define UA_NODEPOINTER_TAG_NODEID 0x01 +#define UA_NODEPOINTER_TAG_EXPANDEDNODEID 0x02 +#define UA_NODEPOINTER_TAG_NODE 0x03 + +void +UA_NodePointer_clear(UA_NodePointer *np) { + switch(np->immediate & UA_NODEPOINTER_MASK) { + case UA_NODEPOINTER_TAG_NODEID: + np->immediate &= ~(uintptr_t)UA_NODEPOINTER_MASK; + UA_NodeId_delete((UA_NodeId*)(uintptr_t)np->id); + break; + case UA_NODEPOINTER_TAG_EXPANDEDNODEID: + np->immediate &= ~(uintptr_t)UA_NODEPOINTER_MASK; + UA_ExpandedNodeId_delete((UA_ExpandedNodeId*)(uintptr_t) + np->expandedId); + break; + default: + break; + } + UA_NodePointer_init(np); +} + +UA_StatusCode +UA_NodePointer_copy(UA_NodePointer in, UA_NodePointer *out) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_Byte tag = in.immediate & UA_NODEPOINTER_MASK; + in.immediate &= ~(uintptr_t)UA_NODEPOINTER_MASK; + switch(tag) { + case UA_NODEPOINTER_TAG_NODE: + in.id = &in.node->nodeId; + goto nodeid; /* fallthrough */ + case UA_NODEPOINTER_TAG_NODEID: + nodeid: + out->id = UA_NodeId_new(); + if(!out->id) + return UA_STATUSCODE_BADOUTOFMEMORY; + res = UA_NodeId_copy(in.id, (UA_NodeId*)(uintptr_t)out->id); + if(res != UA_STATUSCODE_GOOD) { + UA_free((void*)out->immediate); + out->immediate = 0; + break; + } + out->immediate |= UA_NODEPOINTER_TAG_NODEID; + break; + case UA_NODEPOINTER_TAG_EXPANDEDNODEID: + out->expandedId = UA_ExpandedNodeId_new(); + if(!out->expandedId) + return UA_STATUSCODE_BADOUTOFMEMORY; + res = UA_ExpandedNodeId_copy(in.expandedId, + (UA_ExpandedNodeId*)(uintptr_t) + out->expandedId); + if(res != UA_STATUSCODE_GOOD) { + UA_free((void*)out->immediate); + out->immediate = 0; + break; + } + out->immediate |= UA_NODEPOINTER_TAG_EXPANDEDNODEID; + break; + default: + case UA_NODEPOINTER_TAG_IMMEDIATE: + *out = in; + break; + } + return res; +} + +UA_Boolean +UA_NodePointer_isLocal(UA_NodePointer np) { + UA_Byte tag = np.immediate & UA_NODEPOINTER_MASK; + return (tag != UA_NODEPOINTER_TAG_EXPANDEDNODEID); +} + +UA_Order +UA_NodePointer_order(UA_NodePointer p1, UA_NodePointer p2) { + if(p1.immediate == p2.immediate) + return UA_ORDER_EQ; + + /* Extract the tag and resolve pointers to nodes */ + UA_Byte tag1 = p1.immediate & UA_NODEPOINTER_MASK; + if(tag1 == UA_NODEPOINTER_TAG_NODE) { + p1 = UA_NodePointer_fromNodeId(&p1.node->nodeId); + tag1 = p1.immediate & UA_NODEPOINTER_MASK; + } + UA_Byte tag2 = p2.immediate & UA_NODEPOINTER_MASK; + if(tag2 == UA_NODEPOINTER_TAG_NODE) { + p2 = UA_NodePointer_fromNodeId(&p2.node->nodeId); + tag2 = p2.immediate & UA_NODEPOINTER_MASK; + } + + /* Different tags, cannot be identical */ + if(tag1 != tag2) + return (tag1 > tag2) ? UA_ORDER_MORE : UA_ORDER_LESS; + + /* Immediate */ + if(UA_LIKELY(tag1 == UA_NODEPOINTER_TAG_IMMEDIATE)) + return (p1.immediate > p2.immediate) ? + UA_ORDER_MORE : UA_ORDER_LESS; + + /* Compare from pointers */ + p1.immediate &= ~(uintptr_t)UA_NODEPOINTER_MASK; + p2.immediate &= ~(uintptr_t)UA_NODEPOINTER_MASK; + if(tag1 == UA_NODEPOINTER_TAG_EXPANDEDNODEID) + return UA_ExpandedNodeId_order(p1.expandedId, p2.expandedId); + return UA_NodeId_order(p1.id, p2.id); +} + +UA_NodePointer +UA_NodePointer_fromNodeId(const UA_NodeId *id) { + UA_NodePointer np; + if(id->identifierType != UA_NODEIDTYPE_NUMERIC) { + np.id = id; + np.immediate |= UA_NODEPOINTER_TAG_NODEID; + return np; + } + +#if SIZE_MAX > UA_UINT32_MAX + /* 64bit: 4 Byte for the numeric identifier + 2 Byte for the namespaceIndex + * + 1 Byte for the tagging bit (zero) */ + np.immediate = ((uintptr_t)id->identifier.numeric) << 32; + np.immediate |= ((uintptr_t)id->namespaceIndex) << 8; +#else + /* 32bit: 3 Byte for the numeric identifier + 6 Bit for the namespaceIndex + * + 2 Bit for the tagging bit (zero) */ + if(id->namespaceIndex < (0x01 << 6) && + id->identifier.numeric < (0x01 << 24)) { + np.immediate = ((uintptr_t)id->identifier.numeric) << 8; + np.immediate |= ((uintptr_t)id->namespaceIndex) << 2; + } else { + np.id = id; + np.immediate |= UA_NODEPOINTER_TAG_NODEID; + } +#endif + return np; +} + +UA_NodeId +UA_NodePointer_toNodeId(UA_NodePointer np) { + UA_Byte tag = np.immediate & UA_NODEPOINTER_MASK; + np.immediate &= ~(uintptr_t)UA_NODEPOINTER_MASK; + switch(tag) { + case UA_NODEPOINTER_TAG_NODE: + return np.node->nodeId; + case UA_NODEPOINTER_TAG_NODEID: + return *np.id; + case UA_NODEPOINTER_TAG_EXPANDEDNODEID: + return np.expandedId->nodeId; + default: + case UA_NODEPOINTER_TAG_IMMEDIATE: + break; + } + + UA_NodeId id; + id.identifierType = UA_NODEIDTYPE_NUMERIC; +#if SIZE_MAX > UA_UINT32_MAX /* 64bit */ + id.namespaceIndex = (UA_UInt16)(np.immediate >> 8); + id.identifier.numeric = (UA_UInt32)(np.immediate >> 32); +#else /* 32bit */ + id.namespaceIndex = ((UA_Byte)np.immediate) >> 2; + id.identifier.numeric = np.immediate >> 8; +#endif + return id; +} + +UA_NodePointer +UA_NodePointer_fromExpandedNodeId(const UA_ExpandedNodeId *id) { + if(!UA_ExpandedNodeId_isLocal(id)) { + UA_NodePointer np; + np.expandedId = id; + np.immediate |= UA_NODEPOINTER_TAG_EXPANDEDNODEID; + return np; + } + return UA_NodePointer_fromNodeId(&id->nodeId); +} + +UA_ExpandedNodeId +UA_NodePointer_toExpandedNodeId(UA_NodePointer np) { + /* Resolve node pointer to get the NodeId */ + UA_Byte tag = np.immediate & UA_NODEPOINTER_MASK; + if(tag == UA_NODEPOINTER_TAG_NODE) { + np = UA_NodePointer_fromNodeId(&np.node->nodeId); + tag = np.immediate & UA_NODEPOINTER_MASK; + } + + /* ExpandedNodeId, make a shallow copy */ + if(tag == UA_NODEPOINTER_TAG_EXPANDEDNODEID) { + np.immediate &= ~(uintptr_t)UA_NODEPOINTER_MASK; + return *np.expandedId; + } + + /* NodeId, either immediate or via a pointer */ + UA_ExpandedNodeId en; + UA_ExpandedNodeId_init(&en); + en.nodeId = UA_NodePointer_toNodeId(np); + return en; +} + +/**************/ +/* References */ +/**************/ + +static UA_StatusCode +addReferenceTarget(UA_NodeReferenceKind *refs, UA_NodePointer target, + UA_UInt32 targetNameHash); + +static enum aa_cmp +cmpRefTargetId(const void *a, const void *b) { + const UA_ReferenceTargetTreeElem *aa = (const UA_ReferenceTargetTreeElem*)a; + const UA_ReferenceTargetTreeElem *bb = (const UA_ReferenceTargetTreeElem*)b; + if(aa->targetIdHash < bb->targetIdHash) + return AA_CMP_LESS; + if(aa->targetIdHash > bb->targetIdHash) + return AA_CMP_MORE; + return (enum aa_cmp)UA_NodePointer_order(aa->target.targetId, + bb->target.targetId); +} + +static enum aa_cmp +cmpRefTargetName(const void *a, const void *b) { + const UA_UInt32 *nameHashA = (const UA_UInt32*)a; + const UA_UInt32 *nameHashB = (const UA_UInt32*)b; + if(*nameHashA < *nameHashB) + return AA_CMP_LESS; + if(*nameHashA > *nameHashB) + return AA_CMP_MORE; + return AA_CMP_EQ; +} + +/* Reusable binary search tree "heads". Just switch out the root pointer. */ +static const struct aa_head refIdTree = + { NULL, cmpRefTargetId, offsetof(UA_ReferenceTargetTreeElem, idTreeEntry), 0 }; +const struct aa_head refNameTree = + { NULL, cmpRefTargetName, offsetof(UA_ReferenceTargetTreeElem, nameTreeEntry), + offsetof(UA_ReferenceTarget, targetNameHash) }; + +const UA_ReferenceTarget * +UA_NodeReferenceKind_iterate(const UA_NodeReferenceKind *rk, + const UA_ReferenceTarget *prev) { + /* Return from the tree */ + if(rk->hasRefTree) { + const struct aa_head _refIdTree = + { rk->targets.tree.idTreeRoot, cmpRefTargetId, + offsetof(UA_ReferenceTargetTreeElem, idTreeEntry), 0 }; + if(prev == NULL) + return (const UA_ReferenceTarget*)aa_min(&_refIdTree); + return (const UA_ReferenceTarget*)aa_next(&_refIdTree, prev); + } + if(prev == NULL) /* Return start of the array */ + return rk->targets.array; + if(prev + 1 >= &rk->targets.array[rk->targetsSize]) + return NULL; /* End of the array */ + return prev + 1; /* Next element in the array */ +} + +/* Also deletes the elements of the tree */ +static void +moveTreeToArray(UA_ReferenceTarget *array, size_t *pos, + struct aa_entry *entry) { + if(!entry) + return; + UA_ReferenceTargetTreeElem *elem = (UA_ReferenceTargetTreeElem*) + ((uintptr_t)entry - offsetof(UA_ReferenceTargetTreeElem, idTreeEntry)); + moveTreeToArray(array, pos, elem->idTreeEntry.left); + moveTreeToArray(array, pos, elem->idTreeEntry.right); + array[*pos] = elem->target; + (*pos)++; + UA_free(elem); +} + +UA_StatusCode +UA_NodeReferenceKind_switch(UA_NodeReferenceKind *rk) { + if(rk->hasRefTree) { + /* From tree to array */ + UA_ReferenceTarget *array = (UA_ReferenceTarget*) + UA_malloc(sizeof(UA_ReferenceTarget) * rk->targetsSize); + if(!array) + return UA_STATUSCODE_BADOUTOFMEMORY; + size_t pos = 0; + moveTreeToArray(array, &pos, rk->targets.tree.idTreeRoot); + rk->targets.array = array; + rk->hasRefTree = false; + return UA_STATUSCODE_GOOD; + } + + /* From array to tree */ + UA_NodeReferenceKind newRk = *rk; + newRk.hasRefTree = true; + newRk.targets.tree.idTreeRoot = NULL; + newRk.targets.tree.nameTreeRoot = NULL; + for(size_t i = 0; i < rk->targetsSize; i++) { + UA_StatusCode res = + addReferenceTarget(&newRk, rk->targets.array[i].targetId, + rk->targets.array[i].targetNameHash); + if(res != UA_STATUSCODE_GOOD) { + struct aa_head _refIdTree = refIdTree; + _refIdTree.root = newRk.targets.tree.idTreeRoot; + while(_refIdTree.root) { + UA_ReferenceTargetTreeElem *elem = (UA_ReferenceTargetTreeElem*) + ((uintptr_t)_refIdTree.root - + offsetof(UA_ReferenceTargetTreeElem, idTreeEntry)); + aa_remove(&_refIdTree, elem); + UA_NodePointer_clear(&elem->target.targetId); + UA_free(elem); + } + return res; + } + } + for(size_t i = 0; i < rk->targetsSize; i++) + UA_NodePointer_clear(&rk->targets.array[i].targetId); + UA_free(rk->targets.array); + *rk = newRk; + return UA_STATUSCODE_GOOD; +} + +const UA_ReferenceTarget * +UA_NodeReferenceKind_findTarget(const UA_NodeReferenceKind *rk, + const UA_ExpandedNodeId *targetId) { + UA_NodePointer targetP = UA_NodePointer_fromExpandedNodeId(targetId); + + /* Return from the tree */ + if(rk->hasRefTree) { + UA_ReferenceTargetTreeElem tmpTarget; + tmpTarget.target.targetId = targetP; + tmpTarget.targetIdHash = UA_ExpandedNodeId_hash(targetId); + const struct aa_head _refIdTree = + { rk->targets.tree.idTreeRoot, cmpRefTargetId, + offsetof(UA_ReferenceTargetTreeElem, idTreeEntry), 0 }; + return (const UA_ReferenceTarget*)aa_find(&_refIdTree, &tmpTarget); + } + + /* Return from the array */ + for(size_t i = 0; i < rk->targetsSize; i++) { + if(UA_NodePointer_equal(targetP, rk->targets.array[i].targetId)) + return &rk->targets.array[i]; + } + return NULL; +} + +const UA_Node * +UA_NODESTORE_GETFROMREF(UA_Server *server, UA_NodePointer target) { + if(!UA_NodePointer_isLocal(target)) + return NULL; + UA_NodeId id = UA_NodePointer_toNodeId(target); + return UA_NODESTORE_GET(server, &id); +} + +/* General node handling methods. There is no UA_Node_new() method here. + * Creating nodes is part of the Nodestore layer */ + +void UA_Node_clear(UA_Node *node) { + /* Delete references */ + UA_Node_deleteReferences(node); + + /* Delete other head content */ + UA_NodeHead *head = &node->head; + UA_NodeId_clear(&head->nodeId); + UA_QualifiedName_clear(&head->browseName); + UA_LocalizedText_clear(&head->displayName); + UA_LocalizedText_clear(&head->description); + + /* Delete unique content of the nodeclass */ + switch(head->nodeClass) { + case UA_NODECLASS_OBJECT: + break; + case UA_NODECLASS_METHOD: + break; + case UA_NODECLASS_OBJECTTYPE: + break; + case UA_NODECLASS_VARIABLE: + case UA_NODECLASS_VARIABLETYPE: { + UA_VariableNode *p = &node->variableNode; + UA_NodeId_clear(&p->dataType); + UA_Array_delete(p->arrayDimensions, p->arrayDimensionsSize, + &UA_TYPES[UA_TYPES_INT32]); + p->arrayDimensions = NULL; + p->arrayDimensionsSize = 0; + if(p->valueSource == UA_VALUESOURCE_DATA) + UA_DataValue_clear(&p->value.data.value); + break; + } + case UA_NODECLASS_REFERENCETYPE: { + UA_ReferenceTypeNode *p = &node->referenceTypeNode; + UA_LocalizedText_clear(&p->inverseName); + break; + } + case UA_NODECLASS_DATATYPE: + break; + case UA_NODECLASS_VIEW: + break; + default: + break; + } +} + +static UA_StatusCode +UA_ObjectNode_copy(const UA_ObjectNode *src, UA_ObjectNode *dst) { + dst->eventNotifier = src->eventNotifier; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_CommonVariableNode_copy(const UA_VariableNode *src, UA_VariableNode *dst) { + UA_StatusCode retval = + UA_Array_copy(src->arrayDimensions, src->arrayDimensionsSize, + (void**)&dst->arrayDimensions, &UA_TYPES[UA_TYPES_INT32]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + dst->arrayDimensionsSize = src->arrayDimensionsSize; + retval = UA_NodeId_copy(&src->dataType, &dst->dataType); + dst->valueRank = src->valueRank; + dst->valueSource = src->valueSource; + if(src->valueSource == UA_VALUESOURCE_DATA) { + retval |= UA_DataValue_copy(&src->value.data.value, + &dst->value.data.value); + dst->value.data.callback = src->value.data.callback; + } else + dst->value.dataSource = src->value.dataSource; + return retval; +} + +static UA_StatusCode +UA_VariableNode_copy(const UA_VariableNode *src, UA_VariableNode *dst) { + dst->accessLevel = src->accessLevel; + dst->minimumSamplingInterval = src->minimumSamplingInterval; + dst->historizing = src->historizing; + dst->isDynamic = src->isDynamic; + return UA_CommonVariableNode_copy(src, dst); +} + +static UA_StatusCode +UA_VariableTypeNode_copy(const UA_VariableTypeNode *src, + UA_VariableTypeNode *dst) { + dst->isAbstract = src->isAbstract; + return UA_CommonVariableNode_copy((const UA_VariableNode*)src, (UA_VariableNode*)dst); +} + +static UA_StatusCode +UA_MethodNode_copy(const UA_MethodNode *src, UA_MethodNode *dst) { + dst->executable = src->executable; + dst->method = src->method; +#if UA_MULTITHREADING >= 100 + dst->async = src->async; +#endif + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_ObjectTypeNode_copy(const UA_ObjectTypeNode *src, UA_ObjectTypeNode *dst) { + dst->isAbstract = src->isAbstract; + dst->lifecycle = src->lifecycle; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_ReferenceTypeNode_copy(const UA_ReferenceTypeNode *src, + UA_ReferenceTypeNode *dst) { + dst->isAbstract = src->isAbstract; + dst->symmetric = src->symmetric; + dst->referenceTypeIndex = src->referenceTypeIndex; + dst->subTypes = src->subTypes; + return UA_LocalizedText_copy(&src->inverseName, &dst->inverseName); +} + +static UA_StatusCode +UA_DataTypeNode_copy(const UA_DataTypeNode *src, UA_DataTypeNode *dst) { + dst->isAbstract = src->isAbstract; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_ViewNode_copy(const UA_ViewNode *src, UA_ViewNode *dst) { + dst->containsNoLoops = src->containsNoLoops; + dst->eventNotifier = src->eventNotifier; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Node_copy(const UA_Node *src, UA_Node *dst) { + const UA_NodeHead *srchead = &src->head; + UA_NodeHead *dsthead = &dst->head; + if(srchead->nodeClass != dsthead->nodeClass) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Copy standard content */ + UA_StatusCode retval = UA_NodeId_copy(&srchead->nodeId, &dsthead->nodeId); + retval |= UA_QualifiedName_copy(&srchead->browseName, &dsthead->browseName); + retval |= UA_LocalizedText_copy(&srchead->displayName, &dsthead->displayName); + retval |= UA_LocalizedText_copy(&srchead->description, &dsthead->description); + dsthead->writeMask = srchead->writeMask; + dsthead->context = srchead->context; + dsthead->constructed = srchead->constructed; +#ifdef UA_ENABLE_SUBSCRIPTIONS + dsthead->monitoredItems = srchead->monitoredItems; +#endif + if(retval != UA_STATUSCODE_GOOD) { + UA_Node_clear(dst); + return retval; + } + + /* Copy the references */ + dsthead->references = NULL; + if(srchead->referencesSize > 0) { + dsthead->references = (UA_NodeReferenceKind*) + UA_calloc(srchead->referencesSize, sizeof(UA_NodeReferenceKind)); + if(!dsthead->references) { + UA_Node_clear(dst); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + dsthead->referencesSize = srchead->referencesSize; + + for(size_t i = 0; i < srchead->referencesSize; ++i) { + UA_NodeReferenceKind *srefs = &srchead->references[i]; + UA_NodeReferenceKind *drefs = &dsthead->references[i]; + drefs->referenceTypeIndex = srefs->referenceTypeIndex; + drefs->isInverse = srefs->isInverse; + drefs->hasRefTree = srefs->hasRefTree; /* initially empty */ + + /* Copy all the targets */ + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(srefs, t))) { + retval = addReferenceTarget(drefs, t->targetId, t->targetNameHash); + if(retval != UA_STATUSCODE_GOOD) { + UA_Node_clear(dst); + return retval; + } + } + } + } + + /* Copy unique content of the nodeclass */ + switch(src->head.nodeClass) { + case UA_NODECLASS_OBJECT: + retval = UA_ObjectNode_copy(&src->objectNode, &dst->objectNode); + break; + case UA_NODECLASS_VARIABLE: + retval = UA_VariableNode_copy(&src->variableNode, &dst->variableNode); + break; + case UA_NODECLASS_METHOD: + retval = UA_MethodNode_copy(&src->methodNode, &dst->methodNode); + break; + case UA_NODECLASS_OBJECTTYPE: + retval = UA_ObjectTypeNode_copy(&src->objectTypeNode, &dst->objectTypeNode); + break; + case UA_NODECLASS_VARIABLETYPE: + retval = UA_VariableTypeNode_copy(&src->variableTypeNode, &dst->variableTypeNode); + break; + case UA_NODECLASS_REFERENCETYPE: + retval = UA_ReferenceTypeNode_copy(&src->referenceTypeNode, &dst->referenceTypeNode); + break; + case UA_NODECLASS_DATATYPE: + retval = UA_DataTypeNode_copy(&src->dataTypeNode, &dst->dataTypeNode); + break; + case UA_NODECLASS_VIEW: + retval = UA_ViewNode_copy(&src->viewNode, &dst->viewNode); + break; + default: + break; + } + + if(retval != UA_STATUSCODE_GOOD) + UA_Node_clear(dst); + + return retval; +} + +UA_Node * +UA_Node_copy_alloc(const UA_Node *src) { + size_t nodesize = 0; + switch(src->head.nodeClass) { + case UA_NODECLASS_OBJECT: + nodesize = sizeof(UA_ObjectNode); + break; + case UA_NODECLASS_VARIABLE: + nodesize = sizeof(UA_VariableNode); + break; + case UA_NODECLASS_METHOD: + nodesize = sizeof(UA_MethodNode); + break; + case UA_NODECLASS_OBJECTTYPE: + nodesize = sizeof(UA_ObjectTypeNode); + break; + case UA_NODECLASS_VARIABLETYPE: + nodesize = sizeof(UA_VariableTypeNode); + break; + case UA_NODECLASS_REFERENCETYPE: + nodesize = sizeof(UA_ReferenceTypeNode); + break; + case UA_NODECLASS_DATATYPE: + nodesize = sizeof(UA_DataTypeNode); + break; + case UA_NODECLASS_VIEW: + nodesize = sizeof(UA_ViewNode); + break; + default: + return NULL; + } + + UA_Node *dst = (UA_Node*)UA_calloc(1, nodesize); + if(!dst) + return NULL; + + dst->head.nodeClass = src->head.nodeClass; + + UA_StatusCode retval = UA_Node_copy(src, dst); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(dst); + return NULL; + } + return dst; +} +/******************************/ +/* Copy Attributes into Nodes */ +/******************************/ + +static UA_StatusCode +copyStandardAttributes(UA_NodeHead *head, const UA_NodeAttributes *attr) { + /* UA_NodeId_copy(&item->requestedNewNodeId.nodeId, &node->nodeId); */ + /* UA_QualifiedName_copy(&item->browseName, &node->browseName); */ + + head->writeMask = attr->writeMask; + UA_StatusCode retval = UA_LocalizedText_copy(&attr->description, &head->description); + /* The new nodeset format has optional display names: + * https://github.com/open62541/open62541/issues/2627. If the display name + * is NULL, take the name part of the browse name */ + if(attr->displayName.text.length == 0) + retval |= UA_String_copy(&head->browseName.name, &head->displayName.text); + else + retval |= UA_LocalizedText_copy(&attr->displayName, &head->displayName); + return retval; +} + +static UA_StatusCode +copyCommonVariableAttributes(UA_VariableNode *node, + const UA_VariableAttributes *attr) { + /* Copy the array dimensions */ + UA_StatusCode retval = + UA_Array_copy(attr->arrayDimensions, attr->arrayDimensionsSize, + (void**)&node->arrayDimensions, &UA_TYPES[UA_TYPES_UINT32]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + node->arrayDimensionsSize = attr->arrayDimensionsSize; + + /* Data type and value rank */ + retval = UA_NodeId_copy(&attr->dataType, &node->dataType); + if(retval != UA_STATUSCODE_GOOD) + return retval; + node->valueRank = attr->valueRank; + + /* Copy the value */ + retval = UA_Variant_copy(&attr->value, &node->value.data.value.value); + node->valueSource = UA_VALUESOURCE_DATA; + node->value.data.value.hasValue = (node->value.data.value.value.type != NULL); + + return retval; +} + +static UA_StatusCode +copyVariableNodeAttributes(UA_VariableNode *vnode, + const UA_VariableAttributes *attr) { + vnode->accessLevel = attr->accessLevel; + vnode->historizing = attr->historizing; + vnode->minimumSamplingInterval = attr->minimumSamplingInterval; + return copyCommonVariableAttributes(vnode, attr); +} + +static UA_StatusCode +copyVariableTypeNodeAttributes(UA_VariableTypeNode *vtnode, + const UA_VariableTypeAttributes *attr) { + vtnode->isAbstract = attr->isAbstract; + return copyCommonVariableAttributes((UA_VariableNode*)vtnode, + (const UA_VariableAttributes*)attr); +} + +static UA_StatusCode +copyObjectNodeAttributes(UA_ObjectNode *onode, const UA_ObjectAttributes *attr) { + onode->eventNotifier = attr->eventNotifier; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copyReferenceTypeNodeAttributes(UA_ReferenceTypeNode *rtnode, + const UA_ReferenceTypeAttributes *attr) { + rtnode->isAbstract = attr->isAbstract; + rtnode->symmetric = attr->symmetric; + return UA_LocalizedText_copy(&attr->inverseName, &rtnode->inverseName); +} + +static UA_StatusCode +copyObjectTypeNodeAttributes(UA_ObjectTypeNode *otnode, + const UA_ObjectTypeAttributes *attr) { + otnode->isAbstract = attr->isAbstract; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copyViewNodeAttributes(UA_ViewNode *vnode, const UA_ViewAttributes *attr) { + vnode->containsNoLoops = attr->containsNoLoops; + vnode->eventNotifier = attr->eventNotifier; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copyDataTypeNodeAttributes(UA_DataTypeNode *dtnode, + const UA_DataTypeAttributes *attr) { + dtnode->isAbstract = attr->isAbstract; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +copyMethodNodeAttributes(UA_MethodNode *mnode, + const UA_MethodAttributes *attr) { + mnode->executable = attr->executable; + return UA_STATUSCODE_GOOD; +} + +#define CHECK_ATTRIBUTES(TYPE) \ + if(attributeType != &UA_TYPES[UA_TYPES_##TYPE]) { \ + retval = UA_STATUSCODE_BADNODEATTRIBUTESINVALID; \ + break; \ + } + +UA_StatusCode +UA_Node_setAttributes(UA_Node *node, const void *attributes, const UA_DataType *attributeType) { + /* Copy the attributes into the node */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + switch(node->head.nodeClass) { + case UA_NODECLASS_OBJECT: + CHECK_ATTRIBUTES(OBJECTATTRIBUTES); + retval = copyObjectNodeAttributes(&node->objectNode, + (const UA_ObjectAttributes*)attributes); + break; + case UA_NODECLASS_VARIABLE: + CHECK_ATTRIBUTES(VARIABLEATTRIBUTES); + retval = copyVariableNodeAttributes(&node->variableNode, + (const UA_VariableAttributes*)attributes); + break; + case UA_NODECLASS_OBJECTTYPE: + CHECK_ATTRIBUTES(OBJECTTYPEATTRIBUTES); + retval = copyObjectTypeNodeAttributes(&node->objectTypeNode, + (const UA_ObjectTypeAttributes*)attributes); + break; + case UA_NODECLASS_VARIABLETYPE: + CHECK_ATTRIBUTES(VARIABLETYPEATTRIBUTES); + retval = copyVariableTypeNodeAttributes(&node->variableTypeNode, + (const UA_VariableTypeAttributes*)attributes); + break; + case UA_NODECLASS_REFERENCETYPE: + CHECK_ATTRIBUTES(REFERENCETYPEATTRIBUTES); + retval = copyReferenceTypeNodeAttributes(&node->referenceTypeNode, + (const UA_ReferenceTypeAttributes*)attributes); + break; + case UA_NODECLASS_DATATYPE: + CHECK_ATTRIBUTES(DATATYPEATTRIBUTES); + retval = copyDataTypeNodeAttributes(&node->dataTypeNode, + (const UA_DataTypeAttributes*)attributes); + break; + case UA_NODECLASS_VIEW: + CHECK_ATTRIBUTES(VIEWATTRIBUTES); + retval = copyViewNodeAttributes(&node->viewNode, (const UA_ViewAttributes*)attributes); + break; + case UA_NODECLASS_METHOD: + CHECK_ATTRIBUTES(METHODATTRIBUTES); + retval = copyMethodNodeAttributes(&node->methodNode, (const UA_MethodAttributes*)attributes); + break; + case UA_NODECLASS_UNSPECIFIED: + default: + retval = UA_STATUSCODE_BADNODECLASSINVALID; + } + + if(retval == UA_STATUSCODE_GOOD) + retval = copyStandardAttributes(&node->head, (const UA_NodeAttributes*)attributes); + if(retval != UA_STATUSCODE_GOOD) + UA_Node_clear(node); + return retval; +} + +/*********************/ +/* Manage References */ +/*********************/ + +static UA_StatusCode +addReferenceTarget(UA_NodeReferenceKind *rk, UA_NodePointer targetId, + UA_UInt32 targetNameHash) { + /* Insert into array */ + if(!rk->hasRefTree) { + UA_ReferenceTarget *newRefs = (UA_ReferenceTarget*) + UA_realloc(rk->targets.array, + sizeof(UA_ReferenceTarget) * (rk->targetsSize + 1)); + if(!newRefs) + return UA_STATUSCODE_BADOUTOFMEMORY; + rk->targets.array = newRefs; + + UA_StatusCode retval = + UA_NodePointer_copy(targetId, + &rk->targets.array[rk->targetsSize].targetId); + rk->targets.array[rk->targetsSize].targetNameHash = targetNameHash; + if(retval != UA_STATUSCODE_GOOD) { + if(rk->targetsSize == 0) { + UA_free(rk->targets.array); + rk->targets.array = NULL; + } + return retval; + } + rk->targetsSize++; + return UA_STATUSCODE_GOOD; + } + + /* Insert into tree */ + UA_ReferenceTargetTreeElem *entry = (UA_ReferenceTargetTreeElem*) + UA_malloc(sizeof(UA_ReferenceTargetTreeElem)); + if(!entry) + return UA_STATUSCODE_BADOUTOFMEMORY; + + UA_StatusCode retval = + UA_NodePointer_copy(targetId, &entry->target.targetId); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(entry); + return retval; + } + + /* <-- The point of no return --> */ + + UA_ExpandedNodeId en = UA_NodePointer_toExpandedNodeId(targetId); + entry->targetIdHash = UA_ExpandedNodeId_hash(&en); + entry->target.targetNameHash = targetNameHash; + + /* Insert to the id lookup binary search tree. Only the root is kept in refs + * to save space. */ + struct aa_head _refIdTree = refIdTree; + _refIdTree.root = rk->targets.tree.idTreeRoot; + aa_insert(&_refIdTree, entry); + rk->targets.tree.idTreeRoot = _refIdTree.root; + + /* Insert to the name lookup binary search tree */ + struct aa_head _refNameTree = refNameTree; + _refNameTree.root = rk->targets.tree.nameTreeRoot; + aa_insert(&_refNameTree, entry); + rk->targets.tree.nameTreeRoot = _refNameTree.root; + + rk->targetsSize++; + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +addReferenceKind(UA_NodeHead *head, UA_Byte refTypeIndex, UA_Boolean isForward, + const UA_NodePointer target, UA_UInt32 targetBrowseNameHash) { + UA_NodeReferenceKind *refs = (UA_NodeReferenceKind*) + UA_realloc(head->references, + sizeof(UA_NodeReferenceKind) * (head->referencesSize+1)); + if(!refs) + return UA_STATUSCODE_BADOUTOFMEMORY; + head->references = refs; + + UA_NodeReferenceKind *newRef = &refs[head->referencesSize]; + memset(newRef, 0, sizeof(UA_NodeReferenceKind)); + newRef->referenceTypeIndex = refTypeIndex; + newRef->isInverse = !isForward; + UA_StatusCode retval = + addReferenceTarget(newRef, target, targetBrowseNameHash); + if(retval != UA_STATUSCODE_GOOD) { + if(head->referencesSize == 0) { + UA_free(head->references); + head->references = NULL; + } + return retval; + } + + head->referencesSize++; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Node_addReference(UA_Node *node, UA_Byte refTypeIndex, UA_Boolean isForward, + const UA_ExpandedNodeId *targetNodeId, + UA_UInt32 targetBrowseNameHash) { + /* Find the matching reference kind */ + for(size_t i = 0; i < node->head.referencesSize; ++i) { + UA_NodeReferenceKind *refs = &node->head.references[i]; + + /* Reference direction does not match */ + if(refs->isInverse == isForward) + continue; + + /* Reference type does not match */ + if(refs->referenceTypeIndex != refTypeIndex) + continue; + + /* Does an identical reference already exist? */ + const UA_ReferenceTarget *found = + UA_NodeReferenceKind_findTarget(refs, targetNodeId); + if(found) + return UA_STATUSCODE_BADDUPLICATEREFERENCENOTALLOWED; + + /* Add to existing ReferenceKind */ + return addReferenceTarget(refs, UA_NodePointer_fromExpandedNodeId(targetNodeId), + targetBrowseNameHash); + } + + /* Add new ReferenceKind for the target */ + return addReferenceKind(&node->head, refTypeIndex, isForward, + UA_NodePointer_fromExpandedNodeId(targetNodeId), + targetBrowseNameHash); + +} + +UA_StatusCode +UA_Node_deleteReference(UA_Node *node, UA_Byte refTypeIndex, UA_Boolean isForward, + const UA_ExpandedNodeId *targetNodeId) { + struct aa_head _refIdTree = refIdTree; + struct aa_head _refNameTree = refNameTree; + + UA_NodeHead *head = &node->head; + for(size_t i = 0; i < head->referencesSize; i++) { + UA_NodeReferenceKind *refs = &head->references[i]; + if(isForward == refs->isInverse) + continue; + if(refTypeIndex != refs->referenceTypeIndex) + continue; + + /* Cast out the const qualifier (hack!) */ + UA_ReferenceTarget *target = (UA_ReferenceTarget*)(uintptr_t) + UA_NodeReferenceKind_findTarget(refs, targetNodeId); + if(!target) + continue; + + /* Ok, delete the reference. Cannot fail */ + refs->targetsSize--; + + if(!refs->hasRefTree) { + /* Remove from array */ + UA_NodePointer_clear(&target->targetId); + + /* Elements remaining. Realloc. */ + if(refs->targetsSize > 0) { + if(target != &refs->targets.array[refs->targetsSize]) + *target = refs->targets.array[refs->targetsSize]; + UA_ReferenceTarget *newRefs = (UA_ReferenceTarget*) + UA_realloc(refs->targets.array, + sizeof(UA_ReferenceTarget) * refs->targetsSize); + if(newRefs) + refs->targets.array = newRefs; + return UA_STATUSCODE_GOOD; /* Realloc allowed to fail */ + } + + /* Remove the last target. Remove the ReferenceKind below */ + UA_free(refs->targets.array); + } else { + /* Remove from the tree */ + _refIdTree.root = refs->targets.tree.idTreeRoot; + aa_remove(&_refIdTree, target); + refs->targets.tree.idTreeRoot = _refIdTree.root; + + _refNameTree.root = refs->targets.tree.nameTreeRoot; + aa_remove(&_refNameTree, target); + refs->targets.tree.nameTreeRoot = _refNameTree.root; + + UA_NodePointer_clear(&target->targetId); + UA_free(target); + if(refs->targets.tree.idTreeRoot) + return UA_STATUSCODE_GOOD; /* At least one target remains */ + } + + /* No targets remaining. Remove the ReferenceKind. */ + head->referencesSize--; + if(head->referencesSize > 0) { + /* No target for the ReferenceType remaining. Remove and shrink down + * allocated buffer. Ignore errors in case memory buffer could not + * be shrinked down. */ + if(i != head->referencesSize) + head->references[i] = head->references[node->head.referencesSize]; + UA_NodeReferenceKind *newRefs = (UA_NodeReferenceKind*) + UA_realloc(head->references, + sizeof(UA_NodeReferenceKind) * head->referencesSize); + if(newRefs) + head->references = newRefs; + } else { + /* No remaining references of any ReferenceType */ + UA_free(head->references); + head->references = NULL; + } + return UA_STATUSCODE_GOOD; + } + return UA_STATUSCODE_UNCERTAINREFERENCENOTDELETED; +} + +void +UA_Node_deleteReferencesSubset(UA_Node *node, const UA_ReferenceTypeSet *keepSet) { + UA_NodeHead *head = &node->head; + struct aa_head _refIdTree = refIdTree; + for(size_t i = 0; i < head->referencesSize; i++) { + /* Keep the references of this type? */ + UA_NodeReferenceKind *refs = &head->references[i]; + if(UA_ReferenceTypeSet_contains(keepSet, refs->referenceTypeIndex)) + continue; + + /* Remove all target entries. Don't remove entries from browseName tree. + * The entire ReferenceKind will be removed anyway. */ + if(!refs->hasRefTree) { + for(size_t j = 0; j < refs->targetsSize; j++) + UA_NodePointer_clear(&refs->targets.array[j].targetId); + UA_free(refs->targets.array); + } else { + _refIdTree.root = refs->targets.tree.idTreeRoot; + while(_refIdTree.root) { + UA_ReferenceTargetTreeElem *elem = (UA_ReferenceTargetTreeElem*) + ((uintptr_t)_refIdTree.root - + offsetof(UA_ReferenceTargetTreeElem, idTreeEntry)); + aa_remove(&_refIdTree, elem); + UA_NodePointer_clear(&elem->target.targetId); + UA_free(elem); + } + } + + /* Move last references-kind entry to this position. Don't memcpy over + * the same position. Decrease i to repeat at this location. */ + head->referencesSize--; + if(i != head->referencesSize) { + head->references[i] = head->references[head->referencesSize]; + i--; + } + } + + if(head->referencesSize > 0) { + /* Realloc to save memory. Ignore if realloc fails. */ + UA_NodeReferenceKind *refs = (UA_NodeReferenceKind*) + UA_realloc(head->references, + sizeof(UA_NodeReferenceKind) * head->referencesSize); + if(refs) + head->references = refs; + } else { + /* The array is empty. Remove. */ + UA_free(head->references); + head->references = NULL; + } +} + +void UA_Node_deleteReferences(UA_Node *node) { + UA_ReferenceTypeSet noRefs; + UA_ReferenceTypeSet_init(&noRefs); + UA_Node_deleteReferencesSubset(node, &noRefs); +} + +/**** amalgamated original file "/src/server/ua_server.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2017 (c) Florian Palm + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015 (c) LEvertz + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2016 (c) Julian Grothoff + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2016 (c) Lorenz Haas + * Copyright 2017 (c) frax2222 + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2018 (c) Hilscher Gesellschaft für Systemautomation mbH (Author: Martin Lang) + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2021 (c) Fraunhofer IOSB (Author: Jan Hermes) + */ + + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL +#endif + + +#ifdef UA_ENABLE_SUBSCRIPTIONS +#endif + +#ifdef UA_ENABLE_VALGRIND_INTERACTIVE +#include +#endif + +#define STARTCHANNELID 1 +#define STARTTOKENID 1 + +/**********************/ +/* Namespace Handling */ +/**********************/ + +/* The NS1 Uri can be changed by the user to some custom string. This method is + * called to initialize the NS1 Uri if it is not set before to the default + * Application URI. + * + * This is done as soon as the Namespace Array is read or written via node value + * read / write services, or UA_Server_addNamespace, + * UA_Server_getNamespaceByName or UA_Server_run_startup is called. + * + * Therefore one has to set the custom NS1 URI before one of the previously + * mentioned steps. */ +void +setupNs1Uri(UA_Server *server) { + if(!server->namespaces[1].data) { + UA_String_copy(&server->config.applicationDescription.applicationUri, + &server->namespaces[1]); + } +} + +UA_UInt16 addNamespace(UA_Server *server, const UA_String name) { + /* ensure that the uri for ns1 is set up from the app description */ + setupNs1Uri(server); + + /* Check if the namespace already exists in the server's namespace array */ + for(UA_UInt16 i = 0; i < server->namespacesSize; ++i) { + if(UA_String_equal(&name, &server->namespaces[i])) + return i; + } + + /* Make the array bigger */ + UA_String *newNS = (UA_String*)UA_realloc(server->namespaces, + sizeof(UA_String) * (server->namespacesSize + 1)); + UA_CHECK_MEM(newNS, return 0); + + server->namespaces = newNS; + + /* Copy the namespace string */ + UA_StatusCode retval = UA_String_copy(&name, &server->namespaces[server->namespacesSize]); + UA_CHECK_STATUS(retval, return 0); + + /* Announce the change (otherwise, the array appears unchanged) */ + ++server->namespacesSize; + return (UA_UInt16)(server->namespacesSize - 1); +} + +UA_UInt16 UA_Server_addNamespace(UA_Server *server, const char* name) { + /* Override const attribute to get string (dirty hack) */ + UA_String nameString; + nameString.length = strlen(name); + nameString.data = (UA_Byte*)(uintptr_t)name; + UA_LOCK(&server->serviceMutex); + UA_UInt16 retVal = addNamespace(server, nameString); + UA_UNLOCK(&server->serviceMutex); + return retVal; +} + +UA_ServerConfig* +UA_Server_getConfig(UA_Server *server) { + UA_CHECK_MEM(server, return NULL); + return &server->config; +} + +UA_StatusCode +getNamespaceByName(UA_Server *server, const UA_String namespaceUri, + size_t *foundIndex) { + /* ensure that the uri for ns1 is set up from the app description */ + setupNs1Uri(server); + UA_StatusCode res = UA_STATUSCODE_BADNOTFOUND; + for(size_t idx = 0; idx < server->namespacesSize; idx++) { + if(UA_String_equal(&server->namespaces[idx], &namespaceUri)) { + (*foundIndex) = idx; + res = UA_STATUSCODE_GOOD; + break; + } + } + return res; +} + +UA_StatusCode +UA_Server_getNamespaceByName(UA_Server *server, const UA_String namespaceUri, + size_t *foundIndex) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode res = getNamespaceByName(server, namespaceUri, foundIndex); + UA_UNLOCK(&server->serviceMutex); + return res; +} + +UA_StatusCode +UA_Server_forEachChildNodeCall(UA_Server *server, UA_NodeId parentNodeId, + UA_NodeIteratorCallback callback, void *handle) { + UA_BrowseDescription bd; + UA_BrowseDescription_init(&bd); + bd.nodeId = parentNodeId; + bd.browseDirection = UA_BROWSEDIRECTION_BOTH; + bd.resultMask = UA_BROWSERESULTMASK_REFERENCETYPEID | UA_BROWSERESULTMASK_ISFORWARD; + + UA_BrowseResult br = UA_Server_browse(server, 0, &bd); + UA_StatusCode res = br.statusCode; + UA_CHECK_STATUS(res, goto cleanup); + + for(size_t i = 0; i < br.referencesSize; i++) { + if(!UA_ExpandedNodeId_isLocal(&br.references[i].nodeId)) + continue; + res = callback(br.references[i].nodeId.nodeId, !br.references[i].isForward, + br.references[i].referenceTypeId, handle); + UA_CHECK_STATUS(res, goto cleanup); + } +cleanup: + UA_BrowseResult_clear(&br); + return res; +} + +/********************/ +/* Server Lifecycle */ +/********************/ + +static void +serverExecuteRepeatedCallback(UA_Server *server, UA_ApplicationCallback cb, + void *callbackApplication, void *data); + +/* The server needs to be stopped before it can be deleted */ +void UA_Server_delete(UA_Server *server) { + UA_LOCK(&server->serviceMutex); + + UA_Server_deleteSecureChannels(server); + session_list_entry *current, *temp; + LIST_FOREACH_SAFE(current, &server->sessions, pointers, temp) { + UA_Server_removeSession(server, current, UA_DIAGNOSTICEVENT_CLOSE); + } + UA_Array_delete(server->namespaces, server->namespacesSize, &UA_TYPES[UA_TYPES_STRING]); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_MonitoredItem *mon, *mon_tmp; + LIST_FOREACH_SAFE(mon, &server->localMonitoredItems, listEntry, mon_tmp) { + LIST_REMOVE(mon, listEntry); + UA_MonitoredItem_delete(server, mon); + } + + /* Remove subscriptions without a session */ + UA_Subscription *sub, *sub_tmp; + LIST_FOREACH_SAFE(sub, &server->subscriptions, serverListEntry, sub_tmp) { + UA_Subscription_delete(server, sub); + } + UA_assert(server->monitoredItemsSize == 0); + UA_assert(server->subscriptionsSize == 0); + +#ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS + UA_ConditionList_delete(server); +#endif + +#endif + +#ifdef UA_ENABLE_PUBSUB + UA_PubSubManager_delete(server, &server->pubSubManager); +#endif + +#ifdef UA_ENABLE_DISCOVERY + UA_DiscoveryManager_clear(&server->discoveryManager, server); +#endif + +#if UA_MULTITHREADING >= 100 + UA_AsyncManager_clear(&server->asyncManager, server); +#endif + + /* Clean up the Admin Session */ + UA_Session_clear(&server->adminSession, server); + + UA_UNLOCK(&server->serviceMutex); /* The timer has its own mutex */ + + /* Execute all remaining delayed events and clean up the timer */ + UA_Timer_process(&server->timer, UA_DateTime_nowMonotonic() + 1, + (UA_TimerExecutionCallback)serverExecuteRepeatedCallback, server); + UA_Timer_clear(&server->timer); + + /* Clean up the config */ + UA_ServerConfig_clean(&server->config); + +#if UA_MULTITHREADING >= 100 + UA_LOCK_DESTROY(&server->networkMutex); + UA_LOCK_DESTROY(&server->serviceMutex); +#endif + + /* Delete the server itself */ + UA_free(server); +} + +/* Recurring cleanup. Removing unused and timed-out channels and sessions */ +static void +UA_Server_cleanup(UA_Server *server, void *_) { + UA_LOCK(&server->serviceMutex); + UA_DateTime nowMonotonic = UA_DateTime_nowMonotonic(); + UA_Server_cleanupSessions(server, nowMonotonic); + UA_Server_cleanupTimedOutSecureChannels(server, nowMonotonic); +#ifdef UA_ENABLE_DISCOVERY + UA_Discovery_cleanupTimedOut(server, nowMonotonic); +#endif + UA_UNLOCK(&server->serviceMutex); +} + +/********************/ +/* Server Lifecycle */ +/********************/ + +static +UA_INLINE +UA_Boolean UA_Server_NodestoreIsConfigured(UA_Server *server) { + return server->config.nodestore.getNode != NULL; +} + +static UA_Server * +UA_Server_init(UA_Server *server) { + + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_CHECK_FATAL(UA_Server_NodestoreIsConfigured(server), goto cleanup, + &server->config.logger, UA_LOGCATEGORY_SERVER, + "No Nodestore configured in the server" + ); + + /* Init start time to zero, the actual start time will be sampled in + * UA_Server_run_startup() */ + server->startTime = 0; + + /* Set a seed for non-cyptographic randomness */ +#ifndef UA_ENABLE_DETERMINISTIC_RNG + UA_random_seed((UA_UInt64)UA_DateTime_now()); +#endif + +#if UA_MULTITHREADING >= 100 + UA_LOCK_INIT(&server->networkMutex); + UA_LOCK_INIT(&server->serviceMutex); +#endif + + /* Initialize the handling of repeated callbacks */ + UA_Timer_init(&server->timer); + + /* Initialize the adminSession */ + UA_Session_init(&server->adminSession); + server->adminSession.sessionId.identifierType = UA_NODEIDTYPE_GUID; + server->adminSession.sessionId.identifier.guid.data1 = 1; + server->adminSession.validTill = UA_INT64_MAX; + + /* Create Namespaces 0 and 1 + * Ns1 will be filled later with the uri from the app description */ + server->namespaces = (UA_String *)UA_Array_new(2, &UA_TYPES[UA_TYPES_STRING]); + UA_CHECK_MEM(server->namespaces, goto cleanup); + + server->namespaces[0] = UA_STRING_ALLOC("http://opcfoundation.org/UA/"); + server->namespaces[1] = UA_STRING_NULL; + server->namespacesSize = 2; + + /* Initialize SecureChannel */ + TAILQ_INIT(&server->channels); + /* TODO: use an ID that is likely to be unique after a restart */ + server->lastChannelId = STARTCHANNELID; + server->lastTokenId = STARTTOKENID; + + /* Initialize Session Management */ + LIST_INIT(&server->sessions); + server->sessionCount = 0; + +#if UA_MULTITHREADING >= 100 + UA_AsyncManager_init(&server->asyncManager, server); +#endif + + /* Add a regular callback for cleanup and maintenance. With a 10s interval. */ + UA_Server_addRepeatedCallback(server, (UA_ServerCallback)UA_Server_cleanup, NULL, + 10000.0, NULL); + + /* Initialize namespace 0*/ + res = UA_Server_initNS0(server); + UA_CHECK_STATUS(res, goto cleanup); + +#ifdef UA_ENABLE_PUBSUB + /* Build PubSub information model */ +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + UA_Server_initPubSubNS0(server); +#endif + +#ifdef UA_ENABLE_PUBSUB_MONITORING + /* setup default PubSub monitoring callbacks */ + res = UA_PubSubManager_setDefaultMonitoringCallbacks(&server->config.pubSubConfig.monitoringInterface); + UA_CHECK_STATUS(res, goto cleanup); +#endif /* UA_ENABLE_PUBSUB_MONITORING */ +#endif /* UA_ENABLE_PUBSUB */ + return server; + + cleanup: + UA_Server_delete(server); + return NULL; +} + +UA_Server * +UA_Server_newWithConfig(UA_ServerConfig *config) { + UA_CHECK_MEM(config, return NULL); + + UA_Server *server = (UA_Server *)UA_calloc(1, sizeof(UA_Server)); + UA_CHECK_MEM(server, UA_ServerConfig_clean(config); return NULL); + + server->config = *config; + /* The config might have been "moved" into the server struct. Ensure that + * the logger pointer is correct. */ + for(size_t i = 0; i < server->config.securityPoliciesSize; i++) + server->config.securityPolicies[i].logger = &server->config.logger; + + /* Reset the old config */ + memset(config, 0, sizeof(UA_ServerConfig)); + return UA_Server_init(server); +} + +/* Returns if the server should be shut down immediately */ +static UA_Boolean +setServerShutdown(UA_Server *server) { + if(server->endTime != 0) + return false; + if(server->config.shutdownDelay == 0) + return true; + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Shutting down the server with a delay of %i ms", (int)server->config.shutdownDelay); + server->endTime = UA_DateTime_now() + (UA_DateTime)(server->config.shutdownDelay * UA_DATETIME_MSEC); + return false; +} + +/*******************/ +/* Timed Callbacks */ +/*******************/ + +UA_StatusCode +UA_Server_addTimedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_DateTime date, UA_UInt64 *callbackId) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = + UA_Timer_addTimedCallback(&server->timer, + (UA_ApplicationCallback)callback, + server, data, date, callbackId); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +addRepeatedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_Double interval_ms, + UA_UInt64 *callbackId) { + return UA_Timer_addRepeatedCallback(&server->timer, + (UA_ApplicationCallback)callback, + server, data, interval_ms, NULL, + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, callbackId); +} + +UA_StatusCode +UA_Server_addRepeatedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_Double interval_ms, + UA_UInt64 *callbackId) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = + addRepeatedCallback(server, callback, data, interval_ms, callbackId); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +changeRepeatedCallbackInterval(UA_Server *server, UA_UInt64 callbackId, + UA_Double interval_ms) { + return UA_Timer_changeRepeatedCallback(&server->timer, callbackId, + interval_ms, NULL, UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME); +} + +UA_StatusCode +UA_Server_changeRepeatedCallbackInterval(UA_Server *server, UA_UInt64 callbackId, + UA_Double interval_ms) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = + changeRepeatedCallbackInterval(server, callbackId, interval_ms); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +void +removeCallback(UA_Server *server, UA_UInt64 callbackId) { + UA_Timer_removeCallback(&server->timer, callbackId); +} + +void +UA_Server_removeCallback(UA_Server *server, UA_UInt64 callbackId) { + UA_LOCK(&server->serviceMutex); + removeCallback(server, callbackId); + UA_UNLOCK(&server->serviceMutex); +} + +UA_StatusCode +UA_Server_updateCertificate(UA_Server *server, + const UA_ByteString *oldCertificate, + const UA_ByteString *newCertificate, + const UA_ByteString *newPrivateKey, + UA_Boolean closeSessions, + UA_Boolean closeSecureChannels) { + + UA_CHECK(server && oldCertificate && newCertificate && newPrivateKey, + return UA_STATUSCODE_BADINTERNALERROR); + + if(closeSessions) { + session_list_entry *current; + LIST_FOREACH(current, &server->sessions, pointers) { + if(UA_ByteString_equal(oldCertificate, + ¤t->session.header.channel->securityPolicy->localCertificate)) { + UA_LOCK(&server->serviceMutex); + UA_Server_removeSessionByToken(server, ¤t->session.header.authenticationToken, + UA_DIAGNOSTICEVENT_CLOSE); + UA_UNLOCK(&server->serviceMutex); + } + } + + } + + if(closeSecureChannels) { + channel_entry *entry; + TAILQ_FOREACH(entry, &server->channels, pointers) { + if(UA_ByteString_equal(&entry->channel.securityPolicy->localCertificate, oldCertificate)) + UA_Server_closeSecureChannel(server, &entry->channel, UA_DIAGNOSTICEVENT_CLOSE); + } + } + + size_t i = 0; + while(i < server->config.endpointsSize) { + UA_EndpointDescription *ed = &server->config.endpoints[i]; + if(UA_ByteString_equal(&ed->serverCertificate, oldCertificate)) { + UA_String_clear(&ed->serverCertificate); + UA_String_copy(newCertificate, &ed->serverCertificate); + UA_SecurityPolicy *sp = getSecurityPolicyByUri(server, + &server->config.endpoints[i].securityPolicyUri); + UA_CHECK_MEM(sp, return UA_STATUSCODE_BADINTERNALERROR); + sp->updateCertificateAndPrivateKey(sp, *newCertificate, *newPrivateKey); + } + i++; + } + + return UA_STATUSCODE_GOOD; +} + +/***************************/ +/* Server lookup functions */ +/***************************/ + +UA_SecurityPolicy * +getSecurityPolicyByUri(const UA_Server *server, const UA_ByteString *securityPolicyUri) { + for(size_t i = 0; i < server->config.securityPoliciesSize; i++) { + UA_SecurityPolicy *securityPolicyCandidate = &server->config.securityPolicies[i]; + if(UA_ByteString_equal(securityPolicyUri, &securityPolicyCandidate->policyUri)) + return securityPolicyCandidate; + } + return NULL; +} + +#ifdef UA_ENABLE_ENCRYPTION +/* The local ApplicationURI has to match the certificates of the + * SecurityPolicies */ +static UA_StatusCode +verifyServerApplicationURI(const UA_Server *server) { + const UA_String securityPolicyNoneUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None"); + for(size_t i = 0; i < server->config.securityPoliciesSize; i++) { + UA_SecurityPolicy *sp = &server->config.securityPolicies[i]; + if(UA_String_equal(&sp->policyUri, &securityPolicyNoneUri) && (sp->localCertificate.length == 0)) + continue; + UA_StatusCode retval = server->config.certificateVerification. + verifyApplicationURI(server->config.certificateVerification.context, + &sp->localCertificate, + &server->config.applicationDescription.applicationUri); + + UA_CHECK_STATUS_ERROR(retval, return retval, &server->config.logger, UA_LOGCATEGORY_SERVER, + "The configured ApplicationURI \"%.*s\"does not match the " + "ApplicationURI specified in the certificate for the " + "SecurityPolicy %.*s", + (int)server->config.applicationDescription.applicationUri.length, + server->config.applicationDescription.applicationUri.data, + (int)sp->policyUri.length, sp->policyUri.data); + } + return UA_STATUSCODE_GOOD; +} +#endif + +UA_ServerStatistics UA_Server_getStatistics(UA_Server *server) +{ + return server->serverStats; +} + +/********************/ +/* Main Server Loop */ +/********************/ + +#define UA_MAXTIMEOUT 50 /* Max timeout in ms between main-loop iterations */ + +/* Start: Spin up the workers and the network layer and sample the server's + * start time. + * Iterate: Process repeated callbacks and events in the network layer. This + * part can be driven from an external main-loop in an event-driven + * single-threaded architecture. + * Stop: Stop workers, finish all callbacks, stop the network layer, clean up */ + +UA_StatusCode +UA_Server_run_startup(UA_Server *server) { + +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + /* Prominently warn user that fuzzing build is enabled. This will tamper with authentication tokens and other important variables + * E.g. if fuzzing is enabled, and two clients are connected, subscriptions do not work properly, + * since the tokens will be overridden to allow easier fuzzing. */ + UA_LOG_FATAL(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Server was built with unsafe fuzzing mode. " + "This should only be used for specific fuzzing builds."); +#endif + + /* ensure that the uri for ns1 is set up from the app description */ + setupNs1Uri(server); + + /* write ServerArray with same ApplicationURI value as NamespaceArray */ + UA_StatusCode retVal = + writeNs0VariableArray(server, UA_NS0ID_SERVER_SERVERARRAY, + &server->config.applicationDescription.applicationUri, + 1, &UA_TYPES[UA_TYPES_STRING]); + UA_CHECK_STATUS(retVal, return retVal); + + if(server->state > UA_SERVERLIFECYCLE_FRESH) + return UA_STATUSCODE_GOOD; + + /* At least one endpoint has to be configured */ + if(server->config.endpointsSize == 0) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "There has to be at least one endpoint."); + } + + /* Initialized discovery */ +#ifdef UA_ENABLE_DISCOVERY + UA_DiscoveryManager_init(&server->discoveryManager, server); +#endif + + /* Does the ApplicationURI match the local certificates? */ +#ifdef UA_ENABLE_ENCRYPTION + retVal = verifyServerApplicationURI(server); + UA_CHECK_STATUS(retVal, return retVal); +#endif + + /* Sample the start time and set it to the Server object */ + server->startTime = UA_DateTime_now(); + UA_Variant var; + UA_Variant_init(&var); + UA_Variant_setScalar(&var, &server->startTime, &UA_TYPES[UA_TYPES_DATETIME]); + UA_Server_writeValue(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STARTTIME), + var); + + /* Start the networklayers */ + UA_StatusCode result = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < server->config.networkLayersSize; ++i) { + UA_ServerNetworkLayer *nl = &server->config.networkLayers[i]; + nl->statistics = &server->serverStats.ns; + result |= nl->start(nl, &server->config.logger, &server->config.customHostname); + } + UA_CHECK_STATUS(result, return result); + + /* Update the application description to match the previously added + * discovery urls. We can only do this after the network layer is started + * since it inits the discovery url */ + if(server->config.applicationDescription.discoveryUrlsSize != 0) { + UA_Array_delete(server->config.applicationDescription.discoveryUrls, + server->config.applicationDescription.discoveryUrlsSize, + &UA_TYPES[UA_TYPES_STRING]); + server->config.applicationDescription.discoveryUrlsSize = 0; + } + server->config.applicationDescription.discoveryUrls = (UA_String *) + UA_Array_new(server->config.networkLayersSize, &UA_TYPES[UA_TYPES_STRING]); + UA_CHECK_MEM(server->config.applicationDescription.discoveryUrls, + return UA_STATUSCODE_BADOUTOFMEMORY); + + server->config.applicationDescription.discoveryUrlsSize = + server->config.networkLayersSize; + for(size_t i = 0; i < server->config.applicationDescription.discoveryUrlsSize; i++) { + UA_ServerNetworkLayer *nl = &server->config.networkLayers[i]; + UA_String_copy(&nl->discoveryUrl, + &server->config.applicationDescription.discoveryUrls[i]); + } + + /* Start the multicast discovery server */ +#ifdef UA_ENABLE_DISCOVERY_MULTICAST + if(server->config.mdnsEnabled) + startMulticastDiscoveryServer(server); +#endif + + server->state = UA_SERVERLIFECYCLE_FRESH; + + return result; +} + +static void +serverExecuteRepeatedCallback(UA_Server *server, UA_ApplicationCallback cb, + void *callbackApplication, void *data) { + /* Service mutex is not set inside the timer that triggers the callback */ + /* The following check cannot be used since another thread can take the + * serviceMutex during a server_iterate_call. */ + //UA_LOCK_ASSERT(&server->serviceMutex, 0); + cb(callbackApplication, data); +} + +UA_UInt16 +UA_Server_run_iterate(UA_Server *server, UA_Boolean waitInternal) { + /* Process repeated work */ + UA_DateTime now = UA_DateTime_nowMonotonic(); + UA_DateTime nextRepeated = UA_Timer_process(&server->timer, now, + (UA_TimerExecutionCallback)serverExecuteRepeatedCallback, server); + UA_DateTime latest = now + (UA_MAXTIMEOUT * UA_DATETIME_MSEC); + if(nextRepeated > latest) + nextRepeated = latest; + + UA_UInt16 timeout = 0; + + /* round always to upper value to avoid timeout to be set to 0 + * if(nextRepeated - now) < (UA_DATETIME_MSEC/2) */ + if(waitInternal) + timeout = (UA_UInt16)(((nextRepeated - now) + (UA_DATETIME_MSEC - 1)) / UA_DATETIME_MSEC); + + /* Listen on the networklayer */ + for(size_t i = 0; i < server->config.networkLayersSize; ++i) { + UA_ServerNetworkLayer *nl = &server->config.networkLayers[i]; + nl->ua_listen(nl, server, timeout); + } + +#if defined(UA_ENABLE_PUBSUB_MQTT) + /* Listen on the pubsublayer, but only if the yield function is set */ + UA_PubSubConnection *connection; + TAILQ_FOREACH(connection, &server->pubSubManager.connections, listEntry){ + UA_PubSubConnection *ps = connection; + if(ps && ps->channel->yield){ + ps->channel->yield(ps->channel, timeout); + } + } +#endif + + UA_LOCK(&server->serviceMutex); + +#if defined(UA_ENABLE_DISCOVERY_MULTICAST) && (UA_MULTITHREADING < 200) + if(server->config.mdnsEnabled) { + /* TODO multicastNextRepeat does not consider new input data (requests) + * on the socket. It will be handled on the next call. if needed, we + * need to use select with timeout on the multicast socket + * server->mdnsSocket (see example in mdnsd library) on higher level. */ + UA_DateTime multicastNextRepeat = 0; + UA_StatusCode hasNext = + iterateMulticastDiscoveryServer(server, &multicastNextRepeat, true); + if(hasNext == UA_STATUSCODE_GOOD && multicastNextRepeat < nextRepeated) + nextRepeated = multicastNextRepeat; + } +#endif + + UA_UNLOCK(&server->serviceMutex); + + now = UA_DateTime_nowMonotonic(); + timeout = 0; + if(nextRepeated > now) + timeout = (UA_UInt16)((nextRepeated - now) / UA_DATETIME_MSEC); + return timeout; +} + +UA_StatusCode +UA_Server_run_shutdown(UA_Server *server) { + /* Stop the netowrk layer */ + for(size_t i = 0; i < server->config.networkLayersSize; ++i) { + UA_ServerNetworkLayer *nl = &server->config.networkLayers[i]; + nl->stop(nl, server); + } + +#ifdef UA_ENABLE_DISCOVERY_MULTICAST + /* Stop multicast discovery */ + if(server->config.mdnsEnabled) + stopMulticastDiscoveryServer(server); +#endif + + return UA_STATUSCODE_GOOD; +} + +static UA_Boolean +testShutdownCondition(UA_Server *server) { + if(server->endTime == 0) + return false; + return (UA_DateTime_now() > server->endTime); +} + +UA_StatusCode +UA_Server_run(UA_Server *server, const volatile UA_Boolean *running) { + UA_StatusCode retval = UA_Server_run_startup(server); + UA_CHECK_STATUS(retval, return retval); + +#ifdef UA_ENABLE_VALGRIND_INTERACTIVE + size_t loopCount = 0; +#endif + while(!testShutdownCondition(server)) { +#ifdef UA_ENABLE_VALGRIND_INTERACTIVE + if(loopCount == 0) { + VALGRIND_DO_LEAK_CHECK; + } + ++loopCount; + loopCount %= UA_VALGRIND_INTERACTIVE_INTERVAL; +#endif + UA_Server_run_iterate(server, true); + if(!*running) { + if(setServerShutdown(server)) + break; + } + } + return UA_Server_run_shutdown(server); +} + +/**** amalgamated original file "/src/server/ua_server_ns0.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Thomas Bender + * Copyright 2017 (c) Julian Grothoff + * Copyright 2017 (c) Henrik Norrman + * Copyright 2018 (c) Fabian Arndt, Root-Core + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2021 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + */ + + + +static UA_StatusCode +addNode_raw(UA_Server *server, UA_NodeClass nodeClass, + UA_UInt32 nodeId, char *name, void *attributes, + const UA_DataType *attributesType) { + UA_AddNodesItem item; + UA_AddNodesItem_init(&item); + item.nodeClass = nodeClass; + item.requestedNewNodeId.nodeId = UA_NODEID_NUMERIC(0, nodeId); + item.browseName = UA_QUALIFIEDNAME(0, name); + UA_ExtensionObject_setValueNoDelete(&item.nodeAttributes, + attributes, attributesType); + return AddNode_raw(server, &server->adminSession, NULL, &item, NULL); +} + +static UA_StatusCode +addNode_finish(UA_Server *server, UA_UInt32 nodeId, + UA_UInt32 parentNodeId, UA_UInt32 referenceTypeId) { + const UA_NodeId sourceId = UA_NODEID_NUMERIC(0, nodeId); + const UA_NodeId refTypeId = UA_NODEID_NUMERIC(0, referenceTypeId); + const UA_ExpandedNodeId targetId = UA_EXPANDEDNODEID_NUMERIC(0, parentNodeId); + UA_StatusCode retval = UA_Server_addReference(server, sourceId, refTypeId, targetId, false); + if(retval != UA_STATUSCODE_GOOD) + return retval; + return AddNode_finish(server, &server->adminSession, &sourceId); +} + +static UA_StatusCode +addObjectNode(UA_Server *server, char* name, UA_UInt32 objectid, + UA_UInt32 parentid, UA_UInt32 referenceid, UA_UInt32 type_id) { + UA_ObjectAttributes object_attr = UA_ObjectAttributes_default; + object_attr.displayName = UA_LOCALIZEDTEXT("", name); + return UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(0, objectid), + UA_NODEID_NUMERIC(0, parentid), + UA_NODEID_NUMERIC(0, referenceid), + UA_QUALIFIEDNAME(0, name), + UA_NODEID_NUMERIC(0, type_id), + object_attr, NULL, NULL); +} + +static UA_StatusCode +addReferenceTypeNode(UA_Server *server, char* name, char *inverseName, UA_UInt32 referencetypeid, + UA_Boolean isabstract, UA_Boolean symmetric, UA_UInt32 parentid) { + UA_ReferenceTypeAttributes reference_attr = UA_ReferenceTypeAttributes_default; + reference_attr.displayName = UA_LOCALIZEDTEXT("", name); + reference_attr.isAbstract = isabstract; + reference_attr.symmetric = symmetric; + if(inverseName) + reference_attr.inverseName = UA_LOCALIZEDTEXT("", inverseName); + return UA_Server_addReferenceTypeNode(server, UA_NODEID_NUMERIC(0, referencetypeid), + UA_NODEID_NUMERIC(0, parentid), UA_NODEID_NULL, + UA_QUALIFIEDNAME(0, name), reference_attr, NULL, NULL); +} + +/***************************/ +/* Bootstrap NS0 hierarchy */ +/***************************/ + +/* Creates the basic nodes which are expected by the nodeset compiler to be + * already created. This is necessary to reduce the dependencies for the nodeset + * compiler. */ +static UA_StatusCode +UA_Server_createNS0_base(UA_Server *server) { + /* Bootstrap ReferenceTypes. The order of these is important for the + * ReferenceTypeIndex. The ReferenceTypeIndex is created with the raw node. + * The ReferenceTypeSet of subtypes for every ReferenceType is created + * during the call to AddNode_finish. */ + UA_StatusCode ret = UA_STATUSCODE_GOOD; + UA_ReferenceTypeAttributes references_attr = UA_ReferenceTypeAttributes_default; + references_attr.displayName = UA_LOCALIZEDTEXT("", "References"); + references_attr.isAbstract = true; + references_attr.symmetric = true; + references_attr.inverseName = UA_LOCALIZEDTEXT("", "References"); + ret |= addNode_raw(server, UA_NODECLASS_REFERENCETYPE, UA_NS0ID_REFERENCES, "References", + &references_attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); + + UA_ReferenceTypeAttributes hassubtype_attr = UA_ReferenceTypeAttributes_default; + hassubtype_attr.displayName = UA_LOCALIZEDTEXT("", "HasSubtype"); + hassubtype_attr.isAbstract = false; + hassubtype_attr.symmetric = false; + hassubtype_attr.inverseName = UA_LOCALIZEDTEXT("", "HasSupertype"); + ret |= addNode_raw(server, UA_NODECLASS_REFERENCETYPE, UA_NS0ID_HASSUBTYPE, "HasSubtype", + &hassubtype_attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); + + UA_ReferenceTypeAttributes aggregates_attr = UA_ReferenceTypeAttributes_default; + aggregates_attr.displayName = UA_LOCALIZEDTEXT("", "Aggregates"); + aggregates_attr.isAbstract = true; + aggregates_attr.symmetric = false; + aggregates_attr.inverseName = UA_LOCALIZEDTEXT("", "AggregatedBy"); + ret |= addNode_raw(server, UA_NODECLASS_REFERENCETYPE, UA_NS0ID_AGGREGATES, "Aggregates", + &aggregates_attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); + + ret |= addReferenceTypeNode(server, "HierarchicalReferences", NULL, + UA_NS0ID_HIERARCHICALREFERENCES, true, false, UA_NS0ID_REFERENCES); + + ret |= addReferenceTypeNode(server, "NonHierarchicalReferences", NULL, + UA_NS0ID_NONHIERARCHICALREFERENCES, true, true, UA_NS0ID_REFERENCES); + + ret |= addReferenceTypeNode(server, "HasChild", NULL, UA_NS0ID_HASCHILD, + true, false, UA_NS0ID_HIERARCHICALREFERENCES); + + ret |= addReferenceTypeNode(server, "Organizes", "OrganizedBy", UA_NS0ID_ORGANIZES, + false, false, UA_NS0ID_HIERARCHICALREFERENCES); + + ret |= addReferenceTypeNode(server, "HasEventSource", "EventSourceOf", UA_NS0ID_HASEVENTSOURCE, + false, false, UA_NS0ID_HIERARCHICALREFERENCES); + + ret |= addReferenceTypeNode(server, "HasModellingRule", "ModellingRuleOf", UA_NS0ID_HASMODELLINGRULE, + false, false, UA_NS0ID_NONHIERARCHICALREFERENCES); + + ret |= addReferenceTypeNode(server, "HasEncoding", "EncodingOf", UA_NS0ID_HASENCODING, + false, false, UA_NS0ID_NONHIERARCHICALREFERENCES); + + ret |= addReferenceTypeNode(server, "HasDescription", "DescriptionOf", UA_NS0ID_HASDESCRIPTION, + false, false, UA_NS0ID_NONHIERARCHICALREFERENCES); + + ret |= addReferenceTypeNode(server, "HasTypeDefinition", "TypeDefinitionOf", UA_NS0ID_HASTYPEDEFINITION, + false, false, UA_NS0ID_NONHIERARCHICALREFERENCES); + + ret |= addReferenceTypeNode(server, "GeneratesEvent", "GeneratedBy", UA_NS0ID_GENERATESEVENT, + false, false, UA_NS0ID_NONHIERARCHICALREFERENCES); + + /* Complete bootstrap of Aggregates */ + ret |= addNode_finish(server, UA_NS0ID_AGGREGATES, UA_NS0ID_HASCHILD, UA_NS0ID_HASSUBTYPE); + + /* Complete bootstrap of HasSubtype */ + ret |= addNode_finish(server, UA_NS0ID_HASSUBTYPE, UA_NS0ID_HASCHILD, UA_NS0ID_HASSUBTYPE); + + ret |= addReferenceTypeNode(server, "HasProperty", "PropertyOf", UA_NS0ID_HASPROPERTY, + false, false, UA_NS0ID_AGGREGATES); + + ret |= addReferenceTypeNode(server, "HasComponent", "ComponentOf", UA_NS0ID_HASCOMPONENT, + false, false, UA_NS0ID_AGGREGATES); + + ret |= addReferenceTypeNode(server, "HasNotifier", "NotifierOf", UA_NS0ID_HASNOTIFIER, + false, false, UA_NS0ID_HASEVENTSOURCE); + + ret |= addReferenceTypeNode(server, "HasOrderedComponent", "OrderedComponentOf", + UA_NS0ID_HASORDEREDCOMPONENT, false, false, UA_NS0ID_HASCOMPONENT); + + ret |= addReferenceTypeNode(server, "HasInterface", "InterfaceOf", + UA_NS0ID_HASINTERFACE, false, false, UA_NS0ID_NONHIERARCHICALREFERENCES); + + /**************/ + /* Data Types */ + /**************/ + + /* Bootstrap BaseDataType */ + UA_DataTypeAttributes basedatatype_attr = UA_DataTypeAttributes_default; + basedatatype_attr.displayName = UA_LOCALIZEDTEXT("", "BaseDataType"); + basedatatype_attr.isAbstract = true; + ret |= addNode_raw(server, UA_NODECLASS_DATATYPE, UA_NS0ID_BASEDATATYPE, "BaseDataType", + &basedatatype_attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]); + + /*****************/ + /* VariableTypes */ + /*****************/ + + UA_VariableTypeAttributes basevar_attr = UA_VariableTypeAttributes_default; + basevar_attr.displayName = UA_LOCALIZEDTEXT("", "BaseVariableType"); + basevar_attr.isAbstract = true; + basevar_attr.valueRank = UA_VALUERANK_ANY; + basevar_attr.dataType = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATATYPE); + ret |= addNode_raw(server, UA_NODECLASS_VARIABLETYPE, UA_NS0ID_BASEVARIABLETYPE, "BaseVariableType", + &basevar_attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]); + + UA_VariableTypeAttributes bdv_attr = UA_VariableTypeAttributes_default; + bdv_attr.displayName = UA_LOCALIZEDTEXT("", "BaseDataVariableType"); + bdv_attr.dataType = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATATYPE); + bdv_attr.valueRank = UA_VALUERANK_ANY; + ret |= UA_Server_addVariableTypeNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEVARIABLETYPE), + UA_NODEID_NULL, UA_QUALIFIEDNAME(0, "BaseDataVariableType"), + UA_NODEID_NULL, bdv_attr, NULL, NULL); + + UA_VariableTypeAttributes prop_attr = UA_VariableTypeAttributes_default; + prop_attr.displayName = UA_LOCALIZEDTEXT("", "PropertyType"); + prop_attr.dataType = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATATYPE); + prop_attr.valueRank = UA_VALUERANK_ANY; + ret |= UA_Server_addVariableTypeNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PROPERTYTYPE), + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEVARIABLETYPE), + UA_NODEID_NULL, UA_QUALIFIEDNAME(0, "PropertyType"), + UA_NODEID_NULL, prop_attr, NULL, NULL); + + /***************/ + /* ObjectTypes */ + /***************/ + + UA_ObjectTypeAttributes baseobj_attr = UA_ObjectTypeAttributes_default; + baseobj_attr.displayName = UA_LOCALIZEDTEXT("", "BaseObjectType"); + ret |= addNode_raw(server, UA_NODECLASS_OBJECTTYPE, UA_NS0ID_BASEOBJECTTYPE, "BaseObjectType", + &baseobj_attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]); + + UA_ObjectTypeAttributes folder_attr = UA_ObjectTypeAttributes_default; + folder_attr.displayName = UA_LOCALIZEDTEXT("", "FolderType"); + ret |= UA_Server_addObjectTypeNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_FOLDERTYPE), + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE), + UA_NODEID_NULL, UA_QUALIFIEDNAME(0, "FolderType"), + folder_attr, NULL, NULL); + + /******************/ + /* Root and below */ + /******************/ + + ret |= addObjectNode(server, "Root", UA_NS0ID_ROOTFOLDER, 0, 0, UA_NS0ID_FOLDERTYPE); + + ret |= addObjectNode(server, "Objects", UA_NS0ID_OBJECTSFOLDER, UA_NS0ID_ROOTFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + + ret |= addObjectNode(server, "Types", UA_NS0ID_TYPESFOLDER, UA_NS0ID_ROOTFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + + ret |= addObjectNode(server, "ReferenceTypes", UA_NS0ID_REFERENCETYPESFOLDER, UA_NS0ID_TYPESFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + ret |= addNode_finish(server, UA_NS0ID_REFERENCES, UA_NS0ID_REFERENCETYPESFOLDER, + UA_NS0ID_ORGANIZES); + + ret |= addObjectNode(server, "DataTypes", UA_NS0ID_DATATYPESFOLDER, UA_NS0ID_TYPESFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + ret |= addNode_finish(server, UA_NS0ID_BASEDATATYPE, UA_NS0ID_DATATYPESFOLDER, + UA_NS0ID_ORGANIZES); + + ret |= addObjectNode(server, "VariableTypes", UA_NS0ID_VARIABLETYPESFOLDER, UA_NS0ID_TYPESFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + ret |= addNode_finish(server, UA_NS0ID_BASEVARIABLETYPE, UA_NS0ID_VARIABLETYPESFOLDER, + UA_NS0ID_ORGANIZES); + + ret |= addObjectNode(server, "ObjectTypes", UA_NS0ID_OBJECTTYPESFOLDER, UA_NS0ID_TYPESFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + ret |= addNode_finish(server, UA_NS0ID_BASEOBJECTTYPE, UA_NS0ID_OBJECTTYPESFOLDER, + UA_NS0ID_ORGANIZES); + + ret |= addObjectNode(server, "EventTypes", UA_NS0ID_EVENTTYPESFOLDER, UA_NS0ID_TYPESFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + + ret |= addObjectNode(server, "Views", UA_NS0ID_VIEWSFOLDER, UA_NS0ID_ROOTFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_FOLDERTYPE); + + /* Add BaseEventType */ + UA_ObjectTypeAttributes eventtype_attr = UA_ObjectTypeAttributes_default; + eventtype_attr.displayName = UA_LOCALIZEDTEXT("", "BaseEventType"); + ret |= addNode_raw(server, UA_NODECLASS_OBJECTTYPE, UA_NS0ID_BASEEVENTTYPE, "BaseEventType", + &eventtype_attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]); + ret |= addNode_finish(server, UA_NS0ID_BASEEVENTTYPE, UA_NS0ID_EVENTTYPESFOLDER, + UA_NS0ID_ORGANIZES); + + if(ret != UA_STATUSCODE_GOOD) + ret = UA_STATUSCODE_BADINTERNALERROR; + + return ret; +} + +/****************/ +/* Data Sources */ +/****************/ + +static UA_StatusCode +readStatus(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext, UA_Boolean sourceTimestamp, + const UA_NumericRange *range, UA_DataValue *value) { + if(range) { + value->hasStatus = true; + value->status = UA_STATUSCODE_BADINDEXRANGEINVALID; + return UA_STATUSCODE_GOOD; + } + + if(sourceTimestamp) { + value->hasSourceTimestamp = true; + value->sourceTimestamp = UA_DateTime_now(); + } + + void *data = NULL; + + UA_assert(nodeId->identifierType == UA_NODEIDTYPE_NUMERIC); + + switch(nodeId->identifier.numeric) { + case UA_NS0ID_SERVER_SERVERSTATUS_SECONDSTILLSHUTDOWN: { + UA_UInt32 *shutdown = UA_UInt32_new(); + if(!shutdown) + return UA_STATUSCODE_BADOUTOFMEMORY; + if(server->endTime != 0) + *shutdown = (UA_UInt32)((server->endTime - UA_DateTime_now()) / UA_DATETIME_SEC); + value->value.data = shutdown; + value->value.type = &UA_TYPES[UA_TYPES_UINT32]; + value->hasValue = true; + return UA_STATUSCODE_GOOD; + } + + case UA_NS0ID_SERVER_SERVERSTATUS_STATE: { + UA_ServerState *state = UA_ServerState_new(); + if(!state) + return UA_STATUSCODE_BADOUTOFMEMORY; + if(server->endTime != 0) + *state = UA_SERVERSTATE_SHUTDOWN; + value->value.data = state; + value->value.type = &UA_TYPES[UA_TYPES_SERVERSTATE]; + value->hasValue = true; + return UA_STATUSCODE_GOOD; + } + + case UA_NS0ID_SERVER_SERVERSTATUS: { + UA_ServerStatusDataType *statustype = UA_ServerStatusDataType_new(); + if(!statustype) + return UA_STATUSCODE_BADOUTOFMEMORY; + statustype->startTime = server->startTime; + statustype->currentTime = UA_DateTime_now(); + + statustype->state = UA_SERVERSTATE_RUNNING; + statustype->secondsTillShutdown = 0; + if(server->endTime != 0) { + statustype->state = UA_SERVERSTATE_SHUTDOWN; + statustype->secondsTillShutdown = (UA_UInt32) + ((server->endTime - UA_DateTime_now()) / UA_DATETIME_SEC); + } + + value->value.data = statustype; + value->value.type = &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]; + value->hasValue = true; + return UA_BuildInfo_copy(&server->config.buildInfo, &statustype->buildInfo); + } + + case UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO: + value->value.type = &UA_TYPES[UA_TYPES_BUILDINFO]; + data = &server->config.buildInfo; + break; + + case UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTURI: + value->value.type = &UA_TYPES[UA_TYPES_STRING]; + data = &server->config.buildInfo.productUri; + break; + + case UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_MANUFACTURERNAME: + value->value.type = &UA_TYPES[UA_TYPES_STRING]; + data = &server->config.buildInfo.manufacturerName; + break; + + case UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTNAME: + value->value.type = &UA_TYPES[UA_TYPES_STRING]; + data = &server->config.buildInfo.productName; + break; + + case UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_SOFTWAREVERSION: + value->value.type = &UA_TYPES[UA_TYPES_STRING]; + data = &server->config.buildInfo.softwareVersion; + break; + + case UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDNUMBER: + value->value.type = &UA_TYPES[UA_TYPES_STRING]; + data = &server->config.buildInfo.buildNumber; + break; + + case UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDDATE: + value->value.type = &UA_TYPES[UA_TYPES_DATETIME]; + data = &server->config.buildInfo.buildDate; + break; + + default: + value->hasStatus = true; + value->status = UA_STATUSCODE_BADINTERNALERROR; + return UA_STATUSCODE_GOOD; + } + + value->value.data = UA_new(value->value.type); + if(!value->value.data) { + value->value.type = NULL; + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + value->hasValue = true; + return UA_copy(data, value->value.data, value->value.type); +} + +#ifdef UA_GENERATED_NAMESPACE_ZERO +static UA_StatusCode +readServiceLevel(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext, UA_Boolean includeSourceTimeStamp, + const UA_NumericRange *range, UA_DataValue *value) { + if(range) { + value->hasStatus = true; + value->status = UA_STATUSCODE_BADINDEXRANGEINVALID; + return UA_STATUSCODE_GOOD; + } + + value->value.type = &UA_TYPES[UA_TYPES_BYTE]; + value->value.arrayLength = 0; + UA_Byte *byte = UA_Byte_new(); + *byte = 255; + value->value.data = byte; + value->value.arrayDimensionsSize = 0; + value->value.arrayDimensions = NULL; + value->hasValue = true; + if(includeSourceTimeStamp) { + value->hasSourceTimestamp = true; + value->sourceTimestamp = UA_DateTime_now(); + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +readAuditing(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext, UA_Boolean includeSourceTimeStamp, + const UA_NumericRange *range, UA_DataValue *value) { + if(range) { + value->hasStatus = true; + value->status = UA_STATUSCODE_BADINDEXRANGEINVALID; + return UA_STATUSCODE_GOOD; + } + + value->value.type = &UA_TYPES[UA_TYPES_BOOLEAN]; + value->value.arrayLength = 0; + UA_Boolean *boolean = UA_Boolean_new(); + *boolean = false; + value->value.data = boolean; + value->value.arrayDimensionsSize = 0; + value->value.arrayDimensions = NULL; + value->hasValue = true; + if(includeSourceTimeStamp) { + value->hasSourceTimestamp = true; + value->sourceTimestamp = UA_DateTime_now(); + } + return UA_STATUSCODE_GOOD; +} +#endif + +static UA_StatusCode +readNamespaces(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeid, void *nodeContext, UA_Boolean includeSourceTimeStamp, + const UA_NumericRange *range, + UA_DataValue *value) { + /* ensure that the uri for ns1 is set up from the app description */ + setupNs1Uri(server); + + if(range) { + value->hasStatus = true; + value->status = UA_STATUSCODE_BADINDEXRANGEINVALID; + return UA_STATUSCODE_GOOD; + } + UA_StatusCode retval; + retval = UA_Variant_setArrayCopy(&value->value, server->namespaces, + server->namespacesSize, &UA_TYPES[UA_TYPES_STRING]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + value->hasValue = true; + if(includeSourceTimeStamp) { + value->hasSourceTimestamp = true; + value->sourceTimestamp = UA_DateTime_now(); + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +writeNamespaces(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeid, void *nodeContext, const UA_NumericRange *range, + const UA_DataValue *value) { + /* Check the data type */ + if(!value->hasValue || + value->value.type != &UA_TYPES[UA_TYPES_STRING]) + return UA_STATUSCODE_BADTYPEMISMATCH; + + /* Check that the variant is not empty */ + if(!value->value.data) + return UA_STATUSCODE_BADTYPEMISMATCH; + + /* TODO: Writing with a range is not implemented */ + if(range) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_String *newNamespaces = (UA_String*)value->value.data; + size_t newNamespacesSize = value->value.arrayLength; + + /* Test if we append to the existing namespaces */ + if(newNamespacesSize <= server->namespacesSize) + return UA_STATUSCODE_BADTYPEMISMATCH; + + /* ensure that the uri for ns1 is set up from the app description */ + setupNs1Uri(server); + + /* Test if the existing namespaces are unchanged */ + for(size_t i = 0; i < server->namespacesSize; ++i) { + if(!UA_String_equal(&server->namespaces[i], &newNamespaces[i])) + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Add namespaces */ + for(size_t i = server->namespacesSize; i < newNamespacesSize; ++i) + addNamespace(server, newNamespaces[i]); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +readCurrentTime(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeid, void *nodeContext, UA_Boolean sourceTimeStamp, + const UA_NumericRange *range, UA_DataValue *value) { + if(range) { + value->hasStatus = true; + value->status = UA_STATUSCODE_BADINDEXRANGEINVALID; + return UA_STATUSCODE_GOOD; + } + UA_DateTime currentTime = UA_DateTime_now(); + UA_StatusCode retval = UA_Variant_setScalarCopy(&value->value, ¤tTime, + &UA_TYPES[UA_TYPES_DATETIME]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + value->hasValue = true; + if(sourceTimeStamp) { + value->hasSourceTimestamp = true; + value->sourceTimestamp = currentTime; + } + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_GENERATED_NAMESPACE_ZERO +static UA_StatusCode +readMinSamplingInterval(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeid, void *nodeContext, UA_Boolean includeSourceTimeStamp, + const UA_NumericRange *range, + UA_DataValue *value) { + if(range) { + value->hasStatus = true; + value->status = UA_STATUSCODE_BADINDEXRANGEINVALID; + return UA_STATUSCODE_GOOD; + } + + UA_StatusCode retval; + UA_Duration minInterval; +#ifdef UA_ENABLE_SUBSCRIPTIONS + minInterval = server->config.samplingIntervalLimits.min; +#else + minInterval = 0.0; +#endif + retval = UA_Variant_setScalarCopy(&value->value, &minInterval, &UA_TYPES[UA_TYPES_DURATION]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + value->hasValue = true; + if(includeSourceTimeStamp) { + value->hasSourceTimestamp = true; + value->sourceTimestamp = UA_DateTime_now(); + } + return UA_STATUSCODE_GOOD; +} +#endif + +#if defined(UA_GENERATED_NAMESPACE_ZERO) && defined(UA_ENABLE_METHODCALLS) && defined(UA_ENABLE_SUBSCRIPTIONS) +static UA_StatusCode +readMonitoredItems(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *methodId, void *methodContext, const UA_NodeId *objectId, + void *objectContext, size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output) { + /* Return two empty arrays by default */ + UA_Variant_setArray(&output[0], UA_Array_new(0, &UA_TYPES[UA_TYPES_UINT32]), + 0, &UA_TYPES[UA_TYPES_UINT32]); + UA_Variant_setArray(&output[1], UA_Array_new(0, &UA_TYPES[UA_TYPES_UINT32]), + 0, &UA_TYPES[UA_TYPES_UINT32]); + + /* Get the Session */ + UA_LOCK(&server->serviceMutex); + UA_Session *session = UA_Server_getSessionById(server, sessionId); + if(!session) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINTERNALERROR; + } + if(inputSize == 0 || !input[0].data) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + } + + /* Get the Subscription */ + UA_UInt32 subscriptionId = *((UA_UInt32*)(input[0].data)); + UA_Subscription *subscription = UA_Session_getSubscriptionById(session, subscriptionId); + if(!subscription) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + } + + /* Count the MonitoredItems */ + UA_UInt32 sizeOfOutput = 0; + UA_MonitoredItem* monitoredItem; + LIST_FOREACH(monitoredItem, &subscription->monitoredItems, listEntry) { + ++sizeOfOutput; + } + if(sizeOfOutput == 0) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_GOOD; + } + + /* Allocate the output arrays */ + UA_UInt32 *clientHandles = (UA_UInt32*) + UA_Array_new(sizeOfOutput, &UA_TYPES[UA_TYPES_UINT32]); + if(!clientHandles) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + UA_UInt32 *serverHandles = (UA_UInt32*) + UA_Array_new(sizeOfOutput, &UA_TYPES[UA_TYPES_UINT32]); + if(!serverHandles) { + UA_UNLOCK(&server->serviceMutex); + UA_free(clientHandles); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + /* Fill the array */ + UA_UInt32 i = 0; + LIST_FOREACH(monitoredItem, &subscription->monitoredItems, listEntry) { + clientHandles[i] = monitoredItem->parameters.clientHandle; + serverHandles[i] = monitoredItem->monitoredItemId; + ++i; + } + UA_Variant_setArray(&output[0], serverHandles, sizeOfOutput, &UA_TYPES[UA_TYPES_UINT32]); + UA_Variant_setArray(&output[1], clientHandles, sizeOfOutput, &UA_TYPES[UA_TYPES_UINT32]); + + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_GOOD; +} +#endif /* defined(UA_ENABLE_METHODCALLS) && defined(UA_ENABLE_SUBSCRIPTIONS) */ + +UA_StatusCode +writeNs0VariableArray(UA_Server *server, UA_UInt32 id, void *v, + size_t length, const UA_DataType *type) { + UA_Variant var; + UA_Variant_init(&var); + UA_Variant_setArray(&var, v, length, type); + return UA_Server_writeValue(server, UA_NODEID_NUMERIC(0, id), var); +} + +#ifndef UA_GENERATED_NAMESPACE_ZERO +static UA_StatusCode +addVariableNode(UA_Server *server, char* name, UA_UInt32 variableid, + UA_UInt32 parentid, UA_UInt32 referenceid, + UA_Int32 valueRank, UA_UInt32 dataType) { + UA_VariableAttributes attr = UA_VariableAttributes_default; + attr.displayName = UA_LOCALIZEDTEXT("", name); + attr.dataType = UA_NODEID_NUMERIC(0, dataType); + attr.valueRank = valueRank; + attr.accessLevel = UA_ACCESSLEVELMASK_READ; + return UA_Server_addVariableNode(server, UA_NODEID_NUMERIC(0, variableid), + UA_NODEID_NUMERIC(0, parentid), UA_NODEID_NUMERIC(0, referenceid), + UA_QUALIFIEDNAME(0, name), + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), + attr, NULL, NULL); +} + +/* A minimal server object that is not complete and does not use the mandated + * references to a server type. To be used on very constrained devices. */ +static UA_StatusCode +UA_Server_minimalServerObject(UA_Server *server) { + /* Server */ + UA_StatusCode retval = addObjectNode(server, "Server", UA_NS0ID_SERVER, UA_NS0ID_OBJECTSFOLDER, + UA_NS0ID_ORGANIZES, UA_NS0ID_BASEOBJECTTYPE); + + /* Use a valuerank of -2 for now. The array is added later on and the valuerank set to 1. */ + retval |= addVariableNode(server, "ServerArray", UA_NS0ID_SERVER_SERVERARRAY, + UA_NS0ID_SERVER, UA_NS0ID_HASPROPERTY, + UA_VALUERANK_ANY, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "NamespaceArray", UA_NS0ID_SERVER_NAMESPACEARRAY, + UA_NS0ID_SERVER, UA_NS0ID_HASPROPERTY, + UA_VALUERANK_ANY, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "ServerStatus", UA_NS0ID_SERVER_SERVERSTATUS, + UA_NS0ID_SERVER, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "CurrentTime", UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME, + UA_NS0ID_SERVER_SERVERSTATUS, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "State", UA_NS0ID_SERVER_SERVERSTATUS_STATE, + UA_NS0ID_SERVER_SERVERSTATUS, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "BuildInfo", UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO, + UA_NS0ID_SERVER_SERVERSTATUS, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "ProductUri", UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTURI, + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "ManufacturerName", + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_MANUFACTURERNAME, + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "ProductName", + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTNAME, + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "SoftwareVersion", + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_SOFTWAREVERSION, + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "BuildNumber", + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDNUMBER, + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + retval |= addVariableNode(server, "BuildDate", + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDDATE, + UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO, UA_NS0ID_HASCOMPONENT, + UA_VALUERANK_SCALAR, UA_NS0ID_BASEDATATYPE); + + return retval; +} + +#else + +static UA_StatusCode +writeNs0Variable(UA_Server *server, UA_UInt32 id, void *v, const UA_DataType *type) { + UA_Variant var; + UA_Variant_init(&var); + UA_Variant_setScalar(&var, v, type); + return UA_Server_writeValue(server, UA_NODEID_NUMERIC(0, id), var); +} + +static void +addModellingRules(UA_Server *server) { + /* Test if the ModellingRules folder was added. (Only for the full ns0.) */ + UA_NodeClass mrnc = UA_NODECLASS_UNSPECIFIED; + UA_StatusCode retval = UA_Server_readNodeClass(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MODELLINGRULES), + &mrnc); + if(retval != UA_STATUSCODE_GOOD) + return; + + /* Add ExposesItsArray */ + UA_Server_addReference(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MODELLINGRULES), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_MODELLINGRULE_EXPOSESITSARRAY), + true); + + /* Add Mandatory */ + UA_Server_addReference(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MODELLINGRULES), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_MODELLINGRULE_MANDATORY), + true); + + + /* Add MandatoryPlaceholder */ + UA_Server_addReference(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MODELLINGRULES), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_MODELLINGRULE_MANDATORYPLACEHOLDER), + true); + + /* Add Optional */ + UA_Server_addReference(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MODELLINGRULES), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_MODELLINGRULE_OPTIONAL), + true); + + /* Add OptionalPlaceholder */ + UA_Server_addReference(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MODELLINGRULES), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_MODELLINGRULE_OPTIONALPLACEHOLDER), + true); +} + +#endif + +/* Initialize the nodeset 0 by using the generated code of the nodeset compiler. + * This also initialized the data sources for various variables, such as for + * example server time. */ +UA_StatusCode +UA_Server_initNS0(UA_Server *server) { + /* Initialize base nodes which are always required an cannot be created + * through the NS compiler */ + server->bootstrapNS0 = true; + UA_StatusCode retVal = UA_Server_createNS0_base(server); + +#ifdef UA_GENERATED_NAMESPACE_ZERO + /* Load nodes and references generated from the XML ns0 definition */ + retVal |= namespace0_generated(server); +#else + /* Create a minimal server object */ + retVal |= UA_Server_minimalServerObject(server); +#endif + + server->bootstrapNS0 = false; + + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Initialization of Namespace 0 failed with %s. " + "See previous outputs for any error messages.", + UA_StatusCode_name(retVal)); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* NamespaceArray */ + UA_DataSource namespaceDataSource = {readNamespaces, writeNamespaces}; + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_NAMESPACEARRAY), + namespaceDataSource); + retVal |= UA_Server_writeValueRank(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_NAMESPACEARRAY), 1); + + /* ServerArray */ + retVal |= writeNs0VariableArray(server, UA_NS0ID_SERVER_SERVERARRAY, + &server->config.applicationDescription.applicationUri, + 1, &UA_TYPES[UA_TYPES_STRING]); + retVal |= UA_Server_writeValueRank(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERARRAY), 1); + + /* ServerStatus */ + UA_DataSource serverStatus = {readStatus, NULL}; + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS), serverStatus); + + /* StartTime will be sampled in UA_Server_run_startup()*/ + + /* CurrentTime */ + UA_DataSource currentTime = {readCurrentTime, NULL}; + UA_NodeId currTime = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME); + retVal |= UA_Server_setVariableNode_dataSource(server, currTime, currentTime); + retVal |= UA_Server_writeMinimumSamplingInterval(server, currTime, 100.0); + + /* State */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE), + serverStatus); + + /* BuildInfo */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO), serverStatus); + + /* BuildInfo - ProductUri */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTURI), + serverStatus); + + /* BuildInfo - ManufacturerName */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_MANUFACTURERNAME), + serverStatus); + + /* BuildInfo - ProductName */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTNAME), + serverStatus); + + /* BuildInfo - SoftwareVersion */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_SOFTWAREVERSION), + serverStatus); + + /* BuildInfo - BuildNumber */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDNUMBER), + serverStatus); + + /* BuildInfo - BuildDate */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDDATE), + serverStatus); + +#ifdef UA_GENERATED_NAMESPACE_ZERO + + /* SecondsTillShutdown */ + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_SECONDSTILLSHUTDOWN), + serverStatus); + + /* ShutDownReason */ + UA_LocalizedText shutdownReason; + UA_LocalizedText_init(&shutdownReason); + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERSTATUS_SHUTDOWNREASON, + &shutdownReason, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); + + /* ServiceLevel */ + UA_DataSource serviceLevel = {readServiceLevel, NULL}; + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVICELEVEL), serviceLevel); + + /* ServerDiagnostics - ServerDiagnosticsSummary */ + UA_ServerDiagnosticsSummaryDataType serverDiagnosticsSummary; + UA_ServerDiagnosticsSummaryDataType_init(&serverDiagnosticsSummary); + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY, + &serverDiagnosticsSummary, + &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]); + + /* ServerDiagnostics - EnabledFlag */ + UA_Boolean enabledFlag = false; + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERDIAGNOSTICS_ENABLEDFLAG, + &enabledFlag, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* According to Specification part-5 - pg.no-11(PDF pg.no-29), when the ServerDiagnostics is disabled the client + * may modify the value of enabledFlag=true in the server. By default, this node have CurrentRead/Write access. + * In CTT, Subscription_Minimum_1/002.js test will modify the above flag. This will not be a problem when build + * configuration is set at UA_NAMESPACE_ZERO="REDUCED" as NodeIds will not be present. When UA_NAMESPACE_ZERO="FULL", + * the test will fail. Hence made the NodeId as read only */ + retVal |= UA_Server_writeAccessLevel(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERDIAGNOSTICS_ENABLEDFLAG), + UA_ACCESSLEVELMASK_READ); + + /* Auditing */ + UA_DataSource auditing = {readAuditing, NULL}; + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_AUDITING), auditing); + + /* Redundancy Support */ + UA_RedundancySupport redundancySupport = UA_REDUNDANCYSUPPORT_NONE; + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERREDUNDANCY_REDUNDANCYSUPPORT, + &redundancySupport, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]); + + /* Remove unused subtypes of ServerRedundancy */ + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERREDUNDANCY_CURRENTSERVERID), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERREDUNDANCY_REDUNDANTSERVERARRAY), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERREDUNDANCY_SERVERURIARRAY), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERREDUNDANCY_SERVERNETWORKGROUPS), true); + + /* ServerCapabilities - LocaleIdArray */ + UA_LocaleId locale_en = UA_STRING("en"); + retVal |= writeNs0VariableArray(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_LOCALEIDARRAY, + &locale_en, 1, &UA_TYPES[UA_TYPES_LOCALEID]); + + /* ServerCapabilities - MaxBrowseContinuationPoints */ + UA_UInt16 maxBrowseContinuationPoints = UA_MAXCONTINUATIONPOINTS; + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXBROWSECONTINUATIONPOINTS, + &maxBrowseContinuationPoints, &UA_TYPES[UA_TYPES_UINT16]); + + /* ServerProfileArray */ + UA_String profileArray[3]; + UA_UInt16 profileArraySize = 0; +#define ADDPROFILEARRAY(x) profileArray[profileArraySize++] = UA_STRING(x) + ADDPROFILEARRAY("http://opcfoundation.org/UA-Profile/Server/MicroEmbeddedDevice"); +#ifdef UA_ENABLE_NODEMANAGEMENT + ADDPROFILEARRAY("http://opcfoundation.org/UA-Profile/Server/NodeManagement"); +#endif +#ifdef UA_ENABLE_METHODCALLS + ADDPROFILEARRAY("http://opcfoundation.org/UA-Profile/Server/Methods"); +#endif + retVal |= writeNs0VariableArray(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_SERVERPROFILEARRAY, + profileArray, profileArraySize, &UA_TYPES[UA_TYPES_STRING]); + + /* ServerCapabilities - MaxQueryContinuationPoints */ + UA_UInt16 maxQueryContinuationPoints = 0; + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXQUERYCONTINUATIONPOINTS, + &maxQueryContinuationPoints, &UA_TYPES[UA_TYPES_UINT16]); + + /* ServerCapabilities - MaxHistoryContinuationPoints */ + UA_UInt16 maxHistoryContinuationPoints = 0; + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXHISTORYCONTINUATIONPOINTS, + &maxHistoryContinuationPoints, &UA_TYPES[UA_TYPES_UINT16]); + + /* ServerCapabilities - MinSupportedSampleRate */ + UA_DataSource samplingInterval = {readMinSamplingInterval, NULL}; + retVal |= UA_Server_setVariableNode_dataSource(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MINSUPPORTEDSAMPLERATE), + samplingInterval); + + /* ServerCapabilities - OperationLimits - MaxNodesPerRead */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERREAD, + &server->config.maxNodesPerRead, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - OperationLimits - maxNodesPerWrite */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERWRITE, + &server->config.maxNodesPerWrite, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - OperationLimits - MaxNodesPerMethodCall */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERMETHODCALL, + &server->config.maxNodesPerMethodCall, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - OperationLimits - MaxNodesPerBrowse */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERBROWSE, + &server->config.maxNodesPerBrowse, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - OperationLimits - MaxNodesPerRegisterNodes */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERREGISTERNODES, + &server->config.maxNodesPerRegisterNodes, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - OperationLimits - MaxNodesPerTranslateBrowsePathsToNodeIds */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERTRANSLATEBROWSEPATHSTONODEIDS, + &server->config.maxNodesPerTranslateBrowsePathsToNodeIds, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - OperationLimits - MaxNodesPerNodeManagement */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERNODEMANAGEMENT, + &server->config.maxNodesPerNodeManagement, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - OperationLimits - MaxMonitoredItemsPerCall */ + retVal |= writeNs0Variable(server, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXMONITOREDITEMSPERCALL, + &server->config.maxMonitoredItemsPerCall, &UA_TYPES[UA_TYPES_UINT32]); + + /* Remove unused operation limit components */ + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYREADDATA), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYREADEVENTS), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEDATA), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEEVENTS), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_ROLESET), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXSTRINGLENGTH), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXARRAYLENGTH), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXBYTESTRINGLENGTH), true); + + /* Remove not supported server configurations */ + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_ESTIMATEDRETURNTIME), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_LOCALTIME), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_REQUESTSERVERSTATECHANGE), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_RESENDDATA), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVERCONFIGURATION), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SETSUBSCRIPTIONDURABLE), true); + + /* Remove unused diagnostics */ + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SAMPLINGINTERVALDIAGNOSTICSARRAY), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SESSIONSDIAGNOSTICSSUMMARY), true); + + /* Removing these NodeIds make Server Object to be non-complaint with UA 1.03 in CTT (Base Inforamtion/Base Info Core Structure/ 001.js) + * In the 1.04 specification this has been resolved by allowing to remove these static nodes as well */ + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY), true); + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SUBSCRIPTIONDIAGNOSTICSARRAY), true); + +#ifndef UA_ENABLE_PUBSUB + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE), true); +#endif + +#ifndef UA_ENABLE_HISTORIZING + UA_Server_deleteNode(server, UA_NODEID_NUMERIC(0, UA_NS0ID_HISTORYSERVERCAPABILITIES), true); +#else + /* ServerCapabilities - HistoryServerCapabilities - AccessHistoryDataCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_ACCESSHISTORYDATACAPABILITY, + &server->config.accessHistoryDataCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - MaxReturnDataValues */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_MAXRETURNDATAVALUES, + &server->config.maxReturnDataValues, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - HistoryServerCapabilities - AccessHistoryEventsCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_ACCESSHISTORYEVENTSCAPABILITY, + &server->config.accessHistoryEventsCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - MaxReturnEventValues */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_MAXRETURNEVENTVALUES, + &server->config.maxReturnEventValues, &UA_TYPES[UA_TYPES_UINT32]); + + /* ServerCapabilities - HistoryServerCapabilities - InsertDataCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_INSERTDATACAPABILITY, + &server->config.insertDataCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - InsertEventCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_INSERTEVENTCAPABILITY, + &server->config.insertEventCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - InsertAnnotationsCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_INSERTANNOTATIONCAPABILITY, + &server->config.insertAnnotationsCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - ReplaceDataCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_REPLACEDATACAPABILITY, + &server->config.replaceDataCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - ReplaceEventCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_REPLACEEVENTCAPABILITY, + &server->config.replaceEventCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - UpdateDataCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_UPDATEDATACAPABILITY, + &server->config.updateDataCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - UpdateEventCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_UPDATEEVENTCAPABILITY, + &server->config.updateEventCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - DeleteRawCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_DELETERAWCAPABILITY, + &server->config.deleteRawCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - DeleteEventCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_DELETEEVENTCAPABILITY, + &server->config.deleteEventCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); + + /* ServerCapabilities - HistoryServerCapabilities - DeleteAtTimeDataCapability */ + retVal |= writeNs0Variable(server, UA_NS0ID_HISTORYSERVERCAPABILITIES_DELETEATTIMECAPABILITY, + &server->config.deleteAtTimeDataCapability, &UA_TYPES[UA_TYPES_BOOLEAN]); +#endif + +#if defined(UA_ENABLE_METHODCALLS) && defined(UA_ENABLE_SUBSCRIPTIONS) + retVal |= UA_Server_setMethodNodeCallback(server, + UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_GETMONITOREDITEMS), readMonitoredItems); +#endif + + /* The HasComponent references to the ModellingRules are not part of the + * Nodeset2.xml. So we add the references manually. */ + addModellingRules(server); + +#endif /* UA_GENERATED_NAMESPACE_ZERO */ + + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Initialization of Namespace 0 (after bootstrapping) " + "failed with %s. See previous outputs for any error messages.", + UA_StatusCode_name(retVal)); + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_GOOD; +} + +/**** amalgamated original file "/src/server/ua_server_config.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2019 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + +void +UA_ServerConfig_clean(UA_ServerConfig *config) { + if(!config) + return; + + /* Server Description */ + UA_BuildInfo_clear(&config->buildInfo); + UA_ApplicationDescription_clear(&config->applicationDescription); +#ifdef UA_ENABLE_DISCOVERY_MULTICAST + UA_MdnsDiscoveryConfiguration_clear(&config->mdnsConfig); + UA_String_clear(&config->mdnsInterfaceIP); +# if !defined(UA_HAS_GETIFADDR) + if (config->mdnsIpAddressListSize) { + UA_free(config->mdnsIpAddressList); + } +# endif +#endif + + /* Custom DataTypes */ + /* nothing to do */ + + /* Networking */ + for(size_t i = 0; i < config->networkLayersSize; ++i) + config->networkLayers[i].clear(&config->networkLayers[i]); + UA_free(config->networkLayers); + config->networkLayers = NULL; + config->networkLayersSize = 0; + UA_String_clear(&config->customHostname); + config->customHostname = UA_STRING_NULL; + + for(size_t i = 0; i < config->securityPoliciesSize; ++i) { + UA_SecurityPolicy *policy = &config->securityPolicies[i]; + policy->clear(policy); + } + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + config->securityPoliciesSize = 0; + + for(size_t i = 0; i < config->endpointsSize; ++i) + UA_EndpointDescription_clear(&config->endpoints[i]); + + UA_free(config->endpoints); + config->endpoints = NULL; + config->endpointsSize = 0; + + /* Nodestore */ + if(config->nodestore.context && config->nodestore.clear) { + config->nodestore.clear(config->nodestore.context); + config->nodestore.context = NULL; + } + + /* Certificate Validation */ + if(config->certificateVerification.clear) + config->certificateVerification.clear(&config->certificateVerification); + + /* Access Control */ + if(config->accessControl.clear) + config->accessControl.clear(&config->accessControl); + + /* Historical data */ +#ifdef UA_ENABLE_HISTORIZING + if(config->historyDatabase.clear) + config->historyDatabase.clear(&config->historyDatabase); +#endif + + /* Logger */ + if(config->logger.clear) + config->logger.clear(config->logger.context); + config->logger.log = NULL; + config->logger.clear = NULL; + +#ifdef UA_ENABLE_PUBSUB +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + if(config->pubSubConfig.securityPolicies != NULL) { + for(size_t i = 0; i < config->pubSubConfig.securityPoliciesSize; i++) { + config->pubSubConfig.securityPolicies[i].clear(&config->pubSubConfig.securityPolicies[i]); + } + UA_free(config->pubSubConfig.securityPolicies); + config->pubSubConfig.securityPolicies = NULL; + config->pubSubConfig.securityPoliciesSize = 0; + } +#endif +#endif /* UA_ENABLE_PUBSUB */ +} + +#ifdef UA_ENABLE_PUBSUB +/* Add a pubsubTransportLayer to the configuration. Memory is reallocated on + * demand. */ +UA_StatusCode +UA_ServerConfig_addPubSubTransportLayer(UA_ServerConfig *config, + UA_PubSubTransportLayer pubsubTransportLayer) { + UA_PubSubTransportLayer *tmpLayers = (UA_PubSubTransportLayer*) + UA_realloc(config->pubSubConfig.transportLayers, + sizeof(UA_PubSubTransportLayer) * + (config->pubSubConfig.transportLayersSize + 1)); + if(tmpLayers == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + + config->pubSubConfig.transportLayers = tmpLayers; + config->pubSubConfig.transportLayers[config->pubSubConfig.transportLayersSize] = pubsubTransportLayer; + config->pubSubConfig.transportLayersSize++; + return UA_STATUSCODE_GOOD; +} +#endif /* UA_ENABLE_PUBSUB */ + +/**** amalgamated original file "/src/server/ua_server_binary.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2016 (c) Sten Grüner + * Copyright 2014-2015, 2017 (c) Florian Palm + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2016 (c) Joakim L. Gilje + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2016 (c) TorbenD + * Copyright 2017 (c) frax2222 + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2019 (c) Kalycito Infotech Private Limited + */ + + + +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION +// store the authentication token and session ID so we can help fuzzing by setting +// these values in the next request automatically +UA_NodeId unsafe_fuzz_authenticationToken = {0, UA_NODEIDTYPE_NUMERIC, {0}}; +#endif + +#ifdef UA_DEBUG_DUMP_PKGS_FILE +void UA_debug_dumpCompleteChunk(UA_Server *const server, UA_Connection *const connection, + UA_ByteString *messageBuffer); +#endif + +/********************/ +/* Helper Functions */ +/********************/ + +UA_StatusCode +sendServiceFault(UA_SecureChannel *channel, UA_UInt32 requestId, UA_UInt32 requestHandle, + const UA_DataType *responseType, UA_StatusCode statusCode) { + UA_Response response; + UA_init(&response, responseType); + UA_ResponseHeader *responseHeader = &response.responseHeader; + responseHeader->requestHandle = requestHandle; + responseHeader->timestamp = UA_DateTime_now(); + responseHeader->serviceResult = statusCode; + + UA_LOG_DEBUG(channel->securityPolicy->logger, UA_LOGCATEGORY_SERVER, + "Sending response for RequestId %u with ServiceResult %s", + (unsigned)requestId, UA_StatusCode_name(statusCode)); + + /* Send error message. Message type is MSG and not ERR, since we are on a + * SecureChannel! */ + return UA_SecureChannel_sendSymmetricMessage(channel, requestId, UA_MESSAGETYPE_MSG, + &response, responseType); +} + + /* This is not an ERR message, the connection is not closed afterwards */ +static UA_StatusCode +decodeHeaderSendServiceFault(UA_SecureChannel *channel, const UA_ByteString *msg, + size_t offset, const UA_DataType *responseType, + UA_UInt32 requestId, UA_StatusCode error) { + UA_RequestHeader requestHeader; + UA_StatusCode retval = + UA_decodeBinaryInternal(msg, &offset, &requestHeader, + &UA_TYPES[UA_TYPES_REQUESTHEADER], NULL); + if(retval != UA_STATUSCODE_GOOD) + return retval; + retval = sendServiceFault(channel, requestId, requestHeader.requestHandle, + responseType, error); + UA_RequestHeader_clear(&requestHeader); + return retval; +} + +static void +getServicePointers(UA_UInt32 requestTypeId, const UA_DataType **requestType, + const UA_DataType **responseType, UA_Service *service, + UA_Boolean *requiresSession) { + switch(requestTypeId) { + case UA_NS0ID_GETENDPOINTSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_GetEndpoints; + *requestType = &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]; + *requiresSession = false; + break; + case UA_NS0ID_FINDSERVERSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_FindServers; + *requestType = &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]; + *requiresSession = false; + break; +#ifdef UA_ENABLE_DISCOVERY +# ifdef UA_ENABLE_DISCOVERY_MULTICAST + case UA_NS0ID_FINDSERVERSONNETWORKREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_FindServersOnNetwork; + *requestType = &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKRESPONSE]; + *requiresSession = false; + break; +# endif + case UA_NS0ID_REGISTERSERVERREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_RegisterServer; + *requestType = &UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]; + *requiresSession = false; + break; + case UA_NS0ID_REGISTERSERVER2REQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_RegisterServer2; + *requestType = &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST]; + *responseType = &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]; + *requiresSession = false; + break; +#endif + case UA_NS0ID_CREATESESSIONREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_CreateSession; + *requestType = &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]; + *requiresSession = false; + break; + case UA_NS0ID_ACTIVATESESSIONREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_ActivateSession; + *requestType = &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]; + break; + case UA_NS0ID_CLOSESESSIONREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_CloseSession; + *requestType = &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]; + break; + case UA_NS0ID_READREQUEST_ENCODING_DEFAULTBINARY: + *service = NULL; + *service = (UA_Service)Service_Read; + *requestType = &UA_TYPES[UA_TYPES_READREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_READRESPONSE]; + break; + case UA_NS0ID_WRITEREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_Write; + *requestType = &UA_TYPES[UA_TYPES_WRITEREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_WRITERESPONSE]; + break; + case UA_NS0ID_BROWSEREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_Browse; + *requestType = &UA_TYPES[UA_TYPES_BROWSEREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_BROWSERESPONSE]; + break; + case UA_NS0ID_BROWSENEXTREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_BrowseNext; + *requestType = &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]; + break; + case UA_NS0ID_REGISTERNODESREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_RegisterNodes; + *requestType = &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]; + break; + case UA_NS0ID_UNREGISTERNODESREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_UnregisterNodes; + *requestType = &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]; + break; + case UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_TranslateBrowsePathsToNodeIds; + *requestType = &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]; + break; + +#ifdef UA_ENABLE_SUBSCRIPTIONS + case UA_NS0ID_CREATESUBSCRIPTIONREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_CreateSubscription; + *requestType = &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]; + break; + case UA_NS0ID_PUBLISHREQUEST_ENCODING_DEFAULTBINARY: + *requestType = &UA_TYPES[UA_TYPES_PUBLISHREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]; + break; + case UA_NS0ID_REPUBLISHREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_Republish; + *requestType = &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]; + break; + case UA_NS0ID_MODIFYSUBSCRIPTIONREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_ModifySubscription; + *requestType = &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]; + break; + case UA_NS0ID_SETPUBLISHINGMODEREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_SetPublishingMode; + *requestType = &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]; + break; + case UA_NS0ID_DELETESUBSCRIPTIONSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_DeleteSubscriptions; + *requestType = &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]; + break; + case UA_NS0ID_TRANSFERSUBSCRIPTIONSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_TransferSubscriptions; + *requestType = &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]; + break; + case UA_NS0ID_CREATEMONITOREDITEMSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_CreateMonitoredItems; + *requestType = &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]; + break; + case UA_NS0ID_DELETEMONITOREDITEMSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_DeleteMonitoredItems; + *requestType = &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]; + break; + case UA_NS0ID_MODIFYMONITOREDITEMSREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_ModifyMonitoredItems; + *requestType = &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]; + break; + case UA_NS0ID_SETMONITORINGMODEREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_SetMonitoringMode; + *requestType = &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]; + break; + case UA_NS0ID_SETTRIGGERINGREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_SetTriggering; + *requestType = &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]; + break; +#endif +#ifdef UA_ENABLE_HISTORIZING + /* For History read */ + case UA_NS0ID_HISTORYREADREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_HistoryRead; + *requestType = &UA_TYPES[UA_TYPES_HISTORYREADREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_HISTORYREADRESPONSE]; + break; + /* For History update */ + case UA_NS0ID_HISTORYUPDATEREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_HistoryUpdate; + *requestType = &UA_TYPES[UA_TYPES_HISTORYUPDATEREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_HISTORYUPDATERESPONSE]; + break; +#endif + +#ifdef UA_ENABLE_METHODCALLS + case UA_NS0ID_CALLREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_Call; + *requestType = &UA_TYPES[UA_TYPES_CALLREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_CALLRESPONSE]; + break; +#endif + +#ifdef UA_ENABLE_NODEMANAGEMENT + case UA_NS0ID_ADDNODESREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_AddNodes; + *requestType = &UA_TYPES[UA_TYPES_ADDNODESREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]; + break; + case UA_NS0ID_ADDREFERENCESREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_AddReferences; + *requestType = &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]; + break; + case UA_NS0ID_DELETENODESREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_DeleteNodes; + *requestType = &UA_TYPES[UA_TYPES_DELETENODESREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]; + break; + case UA_NS0ID_DELETEREFERENCESREQUEST_ENCODING_DEFAULTBINARY: + *service = (UA_Service)Service_DeleteReferences; + *requestType = &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]; + *responseType = &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]; + break; +#endif + + default: + break; + } +} + +/*************************/ +/* Process Message Types */ +/*************************/ + +/* HEL -> Open up the connection */ +static UA_StatusCode +processHEL(UA_Server *server, UA_SecureChannel *channel, const UA_ByteString *msg) { + if(channel->state != UA_SECURECHANNELSTATE_FRESH) + return UA_STATUSCODE_BADINTERNALERROR; + size_t offset = 0; /* Go to the beginning of the TcpHelloMessage */ + UA_TcpHelloMessage helloMessage; + UA_StatusCode retval = + UA_decodeBinaryInternal(msg, &offset, &helloMessage, + &UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE], NULL); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Currently not checked */ + UA_String_clear(&helloMessage.endpointUrl); + + /* Parameterize the connection. The TcpHelloMessage casts to a + * TcpAcknowledgeMessage. */ + retval = UA_SecureChannel_processHELACK(channel, + (UA_TcpAcknowledgeMessage*)&helloMessage); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | Error during the HEL/ACK handshake", + (int)(channel->connection->sockfd)); + return retval; + } + + /* Get the send buffer from the network layer */ + UA_Connection *connection = channel->connection; + UA_ByteString ack_msg; + UA_ByteString_init(&ack_msg); + retval = connection->getSendBuffer(connection, channel->config.sendBufferSize, &ack_msg); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Build acknowledge response */ + UA_TcpAcknowledgeMessage ackMessage; + ackMessage.protocolVersion = 0; + ackMessage.receiveBufferSize = channel->config.recvBufferSize; + ackMessage.sendBufferSize = channel->config.sendBufferSize; + ackMessage.maxMessageSize = channel->config.localMaxMessageSize; + ackMessage.maxChunkCount = channel->config.localMaxChunkCount; + + UA_TcpMessageHeader ackHeader; + ackHeader.messageTypeAndChunkType = UA_MESSAGETYPE_ACK + UA_CHUNKTYPE_FINAL; + ackHeader.messageSize = 8 + 20; /* ackHeader + ackMessage */ + + /* Encode and send the response */ + UA_Byte *bufPos = ack_msg.data; + const UA_Byte *bufEnd = &ack_msg.data[ack_msg.length]; + retval |= UA_encodeBinaryInternal(&ackHeader, + &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER], + &bufPos, &bufEnd, NULL, NULL); + retval |= UA_encodeBinaryInternal(&ackMessage, + &UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE], + &bufPos, &bufEnd, NULL, NULL); + if(retval != UA_STATUSCODE_GOOD) { + connection->releaseSendBuffer(connection, &ack_msg); + return retval; + } + + ack_msg.length = ackHeader.messageSize; + retval = connection->ua_send(connection, &ack_msg); + if(retval == UA_STATUSCODE_GOOD) + channel->state = UA_SECURECHANNELSTATE_ACK_SENT; + return retval; +} + +/* OPN -> Open up/renew the securechannel */ +static UA_StatusCode +processOPN(UA_Server *server, UA_SecureChannel *channel, + const UA_UInt32 requestId, const UA_ByteString *msg) { + if(channel->state != UA_SECURECHANNELSTATE_ACK_SENT && + channel->state != UA_SECURECHANNELSTATE_OPEN) + return UA_STATUSCODE_BADINTERNALERROR; + /* Decode the request */ + UA_NodeId requestType; + UA_OpenSecureChannelRequest openSecureChannelRequest; + size_t offset = 0; + UA_StatusCode retval = UA_NodeId_decodeBinary(msg, &offset, &requestType); + if(retval != UA_STATUSCODE_GOOD) { + UA_NodeId_clear(&requestType); + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "Could not decode the NodeId. Closing the connection"); + UA_Server_closeSecureChannel(server, channel, UA_DIAGNOSTICEVENT_REJECT); + return retval; + } + retval = UA_decodeBinaryInternal(msg, &offset, &openSecureChannelRequest, + &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST], NULL); + + /* Error occurred */ + if(retval != UA_STATUSCODE_GOOD || + !UA_NodeId_equal(&requestType, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST].binaryEncodingId)) { + UA_NodeId_clear(&requestType); + UA_OpenSecureChannelRequest_clear(&openSecureChannelRequest); + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "Could not decode the OPN message. Closing the connection."); + UA_Server_closeSecureChannel(server, channel, UA_DIAGNOSTICEVENT_REJECT); + return retval; + } + UA_NodeId_clear(&requestType); + + /* Call the service */ + UA_OpenSecureChannelResponse openScResponse; + UA_OpenSecureChannelResponse_init(&openScResponse); + Service_OpenSecureChannel(server, channel, &openSecureChannelRequest, &openScResponse); + UA_OpenSecureChannelRequest_clear(&openSecureChannelRequest); + if(openScResponse.responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, "Could not open a SecureChannel. " + "Closing the connection."); + UA_Server_closeSecureChannel(server, channel, UA_DIAGNOSTICEVENT_REJECT); + return openScResponse.responseHeader.serviceResult; + } + + /* Send the response */ + retval = UA_SecureChannel_sendAsymmetricOPNMessage(channel, requestId, &openScResponse, + &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]); + UA_OpenSecureChannelResponse_clear(&openScResponse); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "Could not send the OPN answer with error code %s", + UA_StatusCode_name(retval)); + UA_Server_closeSecureChannel(server, channel, UA_DIAGNOSTICEVENT_REJECT); + } + + return retval; +} + +/* The responseHeader must have the requestHandle already set */ +UA_StatusCode +sendResponse(UA_Server *server, UA_Session *session, UA_SecureChannel *channel, + UA_UInt32 requestId, UA_Response *response, const UA_DataType *responseType) { + if(!channel) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Prepare the ResponseHeader */ + response->responseHeader.timestamp = UA_DateTime_now(); + + if(session) { +#ifdef UA_ENABLE_TYPEDESCRIPTION + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Sending response for RequestId %u of type %s", + (unsigned)requestId, responseType->typeName); +#else + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Sending reponse for RequestId %u of type %" PRIu32, + (unsigned)requestId, responseType->binaryEncodingId.identifier.numeric); +#endif + } else { +#ifdef UA_ENABLE_TYPEDESCRIPTION + UA_LOG_DEBUG_CHANNEL(&server->config.logger, channel, + "Sending response for RequestId %u of type %s", + (unsigned)requestId, responseType->typeName); +#else + UA_LOG_DEBUG_CHANNEL(&server->config.logger, channel, + "Sending reponse for RequestId %u of type %" PRIu32, + (unsigned)requestId, responseType->binaryEncodingId.identifier.numeric); +#endif + } + + /* Start the message context */ + UA_MessageContext mc; + UA_StatusCode retval = UA_MessageContext_begin(&mc, channel, requestId, UA_MESSAGETYPE_MSG); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Assert's required for clang-analyzer */ + UA_assert(mc.buf_pos == &mc.messageBuffer.data[UA_SECURECHANNEL_SYMMETRIC_HEADER_TOTALLENGTH]); + UA_assert(mc.buf_end <= &mc.messageBuffer.data[mc.messageBuffer.length]); + + /* Encode the response type */ + retval = UA_MessageContext_encode(&mc, &responseType->binaryEncodingId, + &UA_TYPES[UA_TYPES_NODEID]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Encode the response */ + retval = UA_MessageContext_encode(&mc, response, responseType); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Finish / send out */ + return UA_MessageContext_finish(&mc); +} + +/* A Session is "bound" to a SecureChannel if it was created by the + * SecureChannel or if it was activated on it. A Session can only be bound to + * one SecureChannel. A Session can only be closed from the SecureChannel to + * which it is bound. + * + * Returns Good if the AuthenticationToken exists nowhere (for CTT). */ +UA_StatusCode +getBoundSession(UA_Server *server, const UA_SecureChannel *channel, + const UA_NodeId *token, UA_Session **session) { + UA_DateTime now = UA_DateTime_nowMonotonic(); + UA_SessionHeader *sh; + SLIST_FOREACH(sh, &channel->sessions, next) { + if(!UA_NodeId_equal(token, &sh->authenticationToken)) + continue; + UA_Session *current = (UA_Session*)sh; + /* Has the session timed out? */ + if(current->validTill < now) + return UA_STATUSCODE_BADSESSIONCLOSED; + *session = current; + return UA_STATUSCODE_GOOD; + } + + /* Session exists on another SecureChannel. The CTT expect this error. */ + if(getSessionByToken(server, token)) + return UA_STATUSCODE_BADSECURECHANNELIDINVALID; + + return UA_STATUSCODE_GOOD; +} + +static const UA_String securityPolicyNone = + UA_STRING_STATIC("http://opcfoundation.org/UA/SecurityPolicy#None"); + +static UA_StatusCode +processMSGDecoded(UA_Server *server, UA_SecureChannel *channel, UA_UInt32 requestId, + UA_Service service, const UA_Request *request, + const UA_DataType *requestType, UA_Response *response, + const UA_DataType *responseType, UA_Boolean sessionRequired) { + const UA_RequestHeader *requestHeader = &request->requestHeader; + + /* If it is an unencrypted (#None) channel, only allow the discovery services */ + if(server->config.securityPolicyNoneDiscoveryOnly && + UA_String_equal(&channel->securityPolicy->policyUri, &securityPolicyNone ) && + requestType != &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST] && + requestType != &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST] +#if defined(UA_ENABLE_DISCOVERY) && defined(UA_ENABLE_DISCOVERY_MULTICAST) + && requestType != &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST] +#endif + ) { + return sendServiceFault(channel, requestId, requestHeader->requestHandle, + responseType, UA_STATUSCODE_BADSECURITYPOLICYREJECTED); + } + + /* Session lifecycle services. */ + if(requestType == &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST] || + requestType == &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST] || + requestType == &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]) { + UA_LOCK(&server->serviceMutex); + ((UA_ChannelService)service)(server, channel, request, response); + UA_UNLOCK(&server->serviceMutex); +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + /* Store the authentication token so we can help fuzzing by setting + * these values in the next request automatically */ + if(requestType == &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]) { + UA_CreateSessionResponse *res = &response->createSessionResponse; + UA_NodeId_copy(&res->authenticationToken, &unsafe_fuzz_authenticationToken); + } +#endif + return sendResponse(server, NULL, channel, requestId, response, responseType); + } + + /* Get the Session bound to the SecureChannel (not necessarily activated) */ + UA_Session *session = NULL; + if(!UA_NodeId_isNull(&requestHeader->authenticationToken)) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = getBoundSession( + server, channel, &requestHeader->authenticationToken, &session); + UA_UNLOCK(&server->serviceMutex); + if(retval != UA_STATUSCODE_GOOD) + return sendServiceFault(channel, requestId, requestHeader->requestHandle, + responseType, retval); + } + + /* Set an anonymous, inactive session for services that need no session */ + UA_Session anonymousSession; + if(!session) { + if(sessionRequired) { +#ifdef UA_ENABLE_TYPEDESCRIPTION + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "%s refused without a valid session", + requestType->typeName); +#else + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "Service %" PRIu32 " refused without a valid session", + requestType->binaryEncodingId.identifier.numeric); +#endif + return sendServiceFault(channel, requestId, requestHeader->requestHandle, + responseType, UA_STATUSCODE_BADSESSIONIDINVALID); + } + + UA_Session_init(&anonymousSession); + anonymousSession.sessionId = UA_NODEID_GUID(0, UA_GUID_NULL); + anonymousSession.header.channel = channel; + session = &anonymousSession; + } + + UA_assert(session != NULL); + + /* Trying to use a non-activated session? */ + if(sessionRequired && !session->activated) { +#ifdef UA_ENABLE_TYPEDESCRIPTION + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "%s refused on a non-activated session", + requestType->typeName); +#else + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "Service %" PRIu32 " refused on a non-activated session", + requestType->binaryEncodingId.identifier.numeric); +#endif + if(session != &anonymousSession) { + UA_LOCK(&server->serviceMutex); + UA_Server_removeSessionByToken(server, &session->header.authenticationToken, + UA_DIAGNOSTICEVENT_ABORT); + UA_UNLOCK(&server->serviceMutex); + } + return sendServiceFault(channel, requestId, requestHeader->requestHandle, + responseType, UA_STATUSCODE_BADSESSIONNOTACTIVATED); + } + + /* Update the session lifetime */ + UA_Session_updateLifetime(session); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* The publish request is not answered immediately */ + if(requestType == &UA_TYPES[UA_TYPES_PUBLISHREQUEST]) { + UA_LOCK(&server->serviceMutex); + Service_Publish(server, session, &request->publishRequest, requestId); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_GOOD; + } +#endif + +#if UA_MULTITHREADING >= 100 + /* The call request might not be answered immediately */ + if(requestType == &UA_TYPES[UA_TYPES_CALLREQUEST]) { + UA_Boolean finished = true; + UA_LOCK(&server->serviceMutex); + Service_CallAsync(server, session, requestId, &request->callRequest, + &response->callResponse, &finished); + UA_UNLOCK(&server->serviceMutex); + + /* Async method calls remain. Don't send a response now */ + if(!finished) + return UA_STATUSCODE_GOOD; + + /* We are done here */ + return sendResponse(server, session, channel, requestId, response, responseType); + } +#endif + + /* Dispatch the synchronous service call and send the response */ + UA_LOCK(&server->serviceMutex); + service(server, session, request, response); + UA_UNLOCK(&server->serviceMutex); + return sendResponse(server, session, channel, requestId, response, responseType); +} + +static UA_StatusCode +processMSG(UA_Server *server, UA_SecureChannel *channel, + UA_UInt32 requestId, const UA_ByteString *msg) { + if(channel->state != UA_SECURECHANNELSTATE_OPEN) + return UA_STATUSCODE_BADINTERNALERROR; + /* Decode the nodeid */ + size_t offset = 0; + UA_NodeId requestTypeId; + UA_StatusCode retval = UA_NodeId_decodeBinary(msg, &offset, &requestTypeId); + if(retval != UA_STATUSCODE_GOOD) + return retval; + if(requestTypeId.namespaceIndex != 0 || + requestTypeId.identifierType != UA_NODEIDTYPE_NUMERIC) + UA_NodeId_clear(&requestTypeId); /* leads to badserviceunsupported */ + + size_t requestPos = offset; /* Store the offset (for sendServiceFault) */ + + /* Get the service pointers */ + UA_Service service = NULL; + UA_Boolean sessionRequired = true; + const UA_DataType *requestType = NULL; + const UA_DataType *responseType = NULL; + getServicePointers(requestTypeId.identifier.numeric, &requestType, + &responseType, &service, &sessionRequired); + if(!requestType) { + if(requestTypeId.identifier.numeric == + UA_NS0ID_CREATESUBSCRIPTIONREQUEST_ENCODING_DEFAULTBINARY) { + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, + "Client requested a subscription, " + "but those are not enabled in the build"); + } else { + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, + "Unknown request with type identifier %" PRIi32, + requestTypeId.identifier.numeric); + } + return decodeHeaderSendServiceFault(channel, msg, requestPos, + &UA_TYPES[UA_TYPES_SERVICEFAULT], + requestId, UA_STATUSCODE_BADSERVICEUNSUPPORTED); + } + UA_assert(responseType); + + /* Decode the request */ + UA_Request request; + retval = UA_decodeBinaryInternal(msg, &offset, &request, + requestType, server->config.customDataTypes); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_DEBUG_CHANNEL(&server->config.logger, channel, + "Could not decode the request with StatusCode %s", + UA_StatusCode_name(retval)); + return decodeHeaderSendServiceFault(channel, msg, requestPos, + responseType, requestId, retval); + } + + /* Check timestamp in the request header */ + UA_RequestHeader *requestHeader = &request.requestHeader; + if(requestHeader->timestamp == 0) { + if(server->config.verifyRequestTimestamp <= UA_RULEHANDLING_WARN) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "The server sends no timestamp in the request header. " + "See the 'verifyRequestTimestamp' setting."); + if(server->config.verifyRequestTimestamp <= UA_RULEHANDLING_ABORT) { + retval = sendServiceFault(channel, requestId, requestHeader->requestHandle, + responseType, UA_STATUSCODE_BADINVALIDTIMESTAMP); + UA_clear(&request, requestType); + return retval; + } + } + } + +#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION + /* Set the authenticationToken from the create session request to help + * fuzzing cover more lines */ + if(!UA_NodeId_isNull(&unsafe_fuzz_authenticationToken) && + !UA_NodeId_isNull(&requestHeader->authenticationToken)) { + UA_NodeId_clear(&requestHeader->authenticationToken); + UA_NodeId_copy(&unsafe_fuzz_authenticationToken, &requestHeader->authenticationToken); + } +#endif + + /* Prepare the respone and process the request */ + UA_Response response; + UA_init(&response, responseType); + response.responseHeader.requestHandle = requestHeader->requestHandle; + retval = processMSGDecoded(server, channel, requestId, service, &request, requestType, + &response, responseType, sessionRequired); + + /* Clean up */ + UA_clear(&request, requestType); + UA_clear(&response, responseType); + return retval; +} + +/* Takes decoded messages starting at the nodeid of the content type. */ +static UA_StatusCode +processSecureChannelMessage(void *application, UA_SecureChannel *channel, + UA_MessageType messagetype, UA_UInt32 requestId, + UA_ByteString *message) { + UA_Server *server = (UA_Server*)application; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + switch(messagetype) { + case UA_MESSAGETYPE_HEL: + UA_LOG_TRACE_CHANNEL(&server->config.logger, channel, "Process a HEL message"); + retval = processHEL(server, channel, message); + break; + case UA_MESSAGETYPE_OPN: + UA_LOG_TRACE_CHANNEL(&server->config.logger, channel, "Process an OPN message"); + retval = processOPN(server, channel, requestId, message); + break; + case UA_MESSAGETYPE_MSG: + UA_LOG_TRACE_CHANNEL(&server->config.logger, channel, "Process a MSG"); + retval = processMSG(server, channel, requestId, message); + break; + case UA_MESSAGETYPE_CLO: + UA_LOG_TRACE_CHANNEL(&server->config.logger, channel, "Process a CLO"); + Service_CloseSecureChannel(server, channel); /* Regular close */ + break; + default: + UA_LOG_TRACE_CHANNEL(&server->config.logger, channel, "Invalid message type"); + retval = UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + break; + } + if(retval != UA_STATUSCODE_GOOD) { + if(!channel->connection) { + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, + "Processing the message failed. Channel already closed " + "with StatusCode %s. ", UA_StatusCode_name(retval)); + return retval; + } + + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, + "Processing the message failed with StatusCode %s. " + "Closing the channel.", UA_StatusCode_name(retval)); + UA_TcpErrorMessage errMsg; + UA_TcpErrorMessage_init(&errMsg); + errMsg.error = retval; + UA_Connection_sendError(channel->connection, &errMsg); + switch(retval) { + case UA_STATUSCODE_BADSECURITYMODEREJECTED: + case UA_STATUSCODE_BADSECURITYCHECKSFAILED: + case UA_STATUSCODE_BADSECURECHANNELIDINVALID: + case UA_STATUSCODE_BADSECURECHANNELTOKENUNKNOWN: + case UA_STATUSCODE_BADSECURITYPOLICYREJECTED: + case UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED: + UA_Server_closeSecureChannel(server, channel, UA_DIAGNOSTICEVENT_SECURITYREJECT); + break; + default: + UA_Server_closeSecureChannel(server, channel, UA_DIAGNOSTICEVENT_CLOSE); + break; + } + } + + return retval; +} + +void +UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, + UA_ByteString *message) { + UA_LOG_TRACE(&server->config.logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | Received a packet.", (int)(connection->sockfd)); + + UA_TcpErrorMessage error; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_SecureChannel *channel = connection->channel; + + /* Add a SecureChannel to a new connection */ + if(!channel) { + retval = UA_Server_createSecureChannel(server, connection); + if(retval != UA_STATUSCODE_GOOD) + goto error; + channel = connection->channel; + UA_assert(channel); + } + +#ifdef UA_DEBUG_DUMP_PKGS + UA_dump_hex_pkg(message->data, message->length); +#endif +#ifdef UA_DEBUG_DUMP_PKGS_FILE + UA_debug_dumpCompleteChunk(server, channel->connection, message); +#endif + + retval = UA_SecureChannel_processBuffer(channel, server, processSecureChannelMessage, message); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | Processing the message failed with error %s", + (int)(connection->sockfd), UA_StatusCode_name(retval)); + goto error; + } + + return; + + error: + /* Send an ERR message and close the connection */ + error.error = retval; + error.reason = UA_STRING_NULL; + UA_Connection_sendError(connection, &error); + connection->ua_close(connection); +} + +void +UA_Server_removeConnection(UA_Server *server, UA_Connection *connection) { + UA_Connection_detachSecureChannel(connection); + connection->free(connection); +} + +/**** amalgamated original file "/src/server/ua_server_utils.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2016-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2016 (c) Lorenz Haas + * Copyright 2017 (c) frax2222 + * Copyright 2017 (c) Florian Palm + * Copyright 2017-2018 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Julian Grothoff + */ + + +const UA_DataType * +UA_Server_findDataType(UA_Server *server, const UA_NodeId *typeId) { + return UA_findDataTypeWithCustom(typeId, server->config.customDataTypes); +} + +/********************************/ +/* Information Model Operations */ +/********************************/ + +const UA_Node * +getNodeType(UA_Server *server, const UA_NodeHead *head) { + /* The reference to the parent is different for variable and variabletype */ + UA_Byte parentRefIndex; + UA_Boolean inverse; + UA_NodeClass typeNodeClass; + switch(head->nodeClass) { + case UA_NODECLASS_OBJECT: + parentRefIndex = UA_REFERENCETYPEINDEX_HASTYPEDEFINITION; + inverse = false; + typeNodeClass = UA_NODECLASS_OBJECTTYPE; + break; + case UA_NODECLASS_VARIABLE: + parentRefIndex = UA_REFERENCETYPEINDEX_HASTYPEDEFINITION; + inverse = false; + typeNodeClass = UA_NODECLASS_VARIABLETYPE; + break; + case UA_NODECLASS_OBJECTTYPE: + case UA_NODECLASS_VARIABLETYPE: + case UA_NODECLASS_REFERENCETYPE: + case UA_NODECLASS_DATATYPE: + parentRefIndex = UA_REFERENCETYPEINDEX_HASSUBTYPE; + inverse = true; + typeNodeClass = head->nodeClass; + break; + default: + return NULL; + } + + /* Return the first matching candidate */ + for(size_t i = 0; i < head->referencesSize; ++i) { + UA_NodeReferenceKind *rk = &head->references[i]; + if(rk->isInverse != inverse) + continue; + if(rk->referenceTypeIndex != parentRefIndex) + continue; + + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + const UA_Node *type = UA_NODESTORE_GETFROMREF(server, t->targetId); + if(!type) + continue; + if(type->head.nodeClass == typeNodeClass) + return type; /* Don't release the node that is returned */ + UA_NODESTORE_RELEASE(server, type); + } + } + + return NULL; +} + +UA_Boolean +UA_Node_hasSubTypeOrInstances(const UA_NodeHead *head) { + for(size_t i = 0; i < head->referencesSize; ++i) { + if(head->references[i].isInverse == false && + head->references[i].referenceTypeIndex == UA_REFERENCETYPEINDEX_HASSUBTYPE) + return true; + if(head->references[i].isInverse == true && + head->references[i].referenceTypeIndex == UA_REFERENCETYPEINDEX_HASTYPEDEFINITION) + return true; + } + return false; +} + +UA_StatusCode +getParentTypeAndInterfaceHierarchy(UA_Server *server, const UA_NodeId *typeNode, + UA_NodeId **typeHierarchy, size_t *typeHierarchySize) { + UA_ReferenceTypeSet reftypes_subtype = + UA_REFTYPESET(UA_REFERENCETYPEINDEX_HASSUBTYPE); + UA_ExpandedNodeId *subTypes = NULL; + size_t subTypesSize = 0; + UA_StatusCode retval = browseRecursive(server, 1, typeNode, + UA_BROWSEDIRECTION_INVERSE, + &reftypes_subtype, UA_NODECLASS_UNSPECIFIED, + false, &subTypesSize, &subTypes); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + UA_assert(subTypesSize < 1000); + + UA_ReferenceTypeSet reftypes_interface = + UA_REFTYPESET(UA_REFERENCETYPEINDEX_HASINTERFACE); + UA_ExpandedNodeId *interfaces = NULL; + size_t interfacesSize = 0; + retval = browseRecursive(server, 1, typeNode, UA_BROWSEDIRECTION_FORWARD, + &reftypes_interface, UA_NODECLASS_UNSPECIFIED, + false, &interfacesSize, &interfaces); + if(retval != UA_STATUSCODE_GOOD) { + UA_Array_delete(subTypes, subTypesSize, &UA_TYPES[UA_TYPES_NODEID]); + return retval; + } + + UA_assert(interfacesSize < 1000); + + UA_NodeId *hierarchy = (UA_NodeId*) + UA_malloc(sizeof(UA_NodeId) * (1 + subTypesSize + interfacesSize)); + if(!hierarchy) { + UA_Array_delete(subTypes, subTypesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + UA_Array_delete(interfaces, interfacesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + retval = UA_NodeId_copy(typeNode, hierarchy); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(hierarchy); + UA_Array_delete(subTypes, subTypesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + UA_Array_delete(interfaces, interfacesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + for(size_t i = 0; i < subTypesSize; i++) { + hierarchy[i+1] = subTypes[i].nodeId; + UA_NodeId_init(&subTypes[i].nodeId); + } + for(size_t i = 0; i < interfacesSize; i++) { + hierarchy[i+1+subTypesSize] = interfaces[i].nodeId; + UA_NodeId_init(&interfaces[i].nodeId); + } + + *typeHierarchy = hierarchy; + *typeHierarchySize = subTypesSize + interfacesSize + 1; + + UA_assert(*typeHierarchySize < 1000); + + UA_Array_delete(subTypes, subTypesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + UA_Array_delete(interfaces, interfacesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +getAllInterfaceChildNodeIds(UA_Server *server, const UA_NodeId *objectNode, + const UA_NodeId *objectTypeNode, + UA_NodeId **interfaceChildNodes, size_t *interfaceChildNodesSize) { + if(interfaceChildNodesSize == NULL || interfaceChildNodes == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + *interfaceChildNodesSize = 0; + *interfaceChildNodes = NULL; + + UA_ExpandedNodeId *hasInterfaceCandidates = NULL; + size_t hasInterfaceCandidatesSize = 0; + UA_ReferenceTypeSet reftypes_subtype = + UA_REFTYPESET(UA_REFERENCETYPEINDEX_HASSUBTYPE); + + UA_StatusCode retval = browseRecursive(server, 1, objectTypeNode, UA_BROWSEDIRECTION_INVERSE, + &reftypes_subtype, UA_NODECLASS_OBJECTTYPE, + true, &hasInterfaceCandidatesSize, + &hasInterfaceCandidates); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* The interface could also have been added manually before calling UA_Server_addNode_finish + * This can be handled by adding the object node as a start node for the HasInterface lookup */ + UA_ExpandedNodeId *resizedHasInterfaceCandidates = + (UA_ExpandedNodeId*)UA_realloc(hasInterfaceCandidates, + (hasInterfaceCandidatesSize + 1) * sizeof(UA_ExpandedNodeId)); + + if (!resizedHasInterfaceCandidates) { + if (hasInterfaceCandidates) + UA_Array_delete(hasInterfaceCandidates, hasInterfaceCandidatesSize, + &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + hasInterfaceCandidates = resizedHasInterfaceCandidates; + hasInterfaceCandidatesSize += 1; + UA_ExpandedNodeId_init(&hasInterfaceCandidates[hasInterfaceCandidatesSize - 1]); + + UA_ExpandedNodeId_init(&hasInterfaceCandidates[hasInterfaceCandidatesSize - 1]); + UA_NodeId_copy(objectNode, &hasInterfaceCandidates[hasInterfaceCandidatesSize - 1].nodeId); + + size_t outputIndex = 0; + + for (size_t i = 0; i < hasInterfaceCandidatesSize; ++i) { + UA_ReferenceTypeSet reftypes_interface = + UA_REFTYPESET(UA_REFERENCETYPEINDEX_HASINTERFACE); + UA_ExpandedNodeId *interfaceChildren = NULL; + size_t interfacesChildrenSize = 0; + retval = browseRecursive(server, 1, &hasInterfaceCandidates[i].nodeId, + UA_BROWSEDIRECTION_FORWARD, + &reftypes_interface, UA_NODECLASS_OBJECTTYPE, + false, &interfacesChildrenSize, &interfaceChildren); + if(retval != UA_STATUSCODE_GOOD) { + UA_Array_delete(hasInterfaceCandidates, hasInterfaceCandidatesSize, + &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + if (*interfaceChildNodesSize) { + UA_Array_delete(*interfaceChildNodes, *interfaceChildNodesSize, + &UA_TYPES[UA_TYPES_NODEID]); + *interfaceChildNodesSize = 0; + } + return retval; + } + + UA_assert(interfacesChildrenSize < 1000); + + if (interfacesChildrenSize == 0) { + continue; + } + + if (!*interfaceChildNodes) { + *interfaceChildNodes = (UA_NodeId*) + UA_calloc(interfacesChildrenSize, sizeof(UA_NodeId)); + *interfaceChildNodesSize = interfacesChildrenSize; + + if(!*interfaceChildNodes) { + UA_Array_delete(interfaceChildren, interfacesChildrenSize, + &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + UA_Array_delete(hasInterfaceCandidates, hasInterfaceCandidatesSize, + &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + } else { + UA_NodeId *resizedInterfaceChildNodes = + (UA_NodeId*)UA_realloc(*interfaceChildNodes, + ((*interfaceChildNodesSize + interfacesChildrenSize) * sizeof(UA_NodeId))); + + if (!resizedInterfaceChildNodes) { + UA_Array_delete(hasInterfaceCandidates, hasInterfaceCandidatesSize, + &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + UA_Array_delete(interfaceChildren, interfacesChildrenSize, + &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + const size_t oldSize = *interfaceChildNodesSize; + *interfaceChildNodesSize += interfacesChildrenSize; + *interfaceChildNodes = resizedInterfaceChildNodes; + + for (size_t j = oldSize; j < *interfaceChildNodesSize; ++j) + UA_NodeId_init(&(*interfaceChildNodes)[j]); + } + + for(size_t j = 0; j < interfacesChildrenSize; j++) { + (*interfaceChildNodes)[outputIndex++] = interfaceChildren[j].nodeId; + } + + UA_assert(*interfaceChildNodesSize < 1000); + UA_Array_delete(interfaceChildren, interfacesChildrenSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + } + + UA_Array_delete(hasInterfaceCandidates, hasInterfaceCandidatesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + + return UA_STATUSCODE_GOOD; +} + +/* For mulithreading: make a copy of the node, edit and replace. + * For singlethreading: edit the original */ +UA_StatusCode +UA_Server_editNode(UA_Server *server, UA_Session *session, + const UA_NodeId *nodeId, UA_EditNodeCallback callback, + void *data) { +#ifndef UA_ENABLE_IMMUTABLE_NODES + /* Get the node and process it in-situ */ + const UA_Node *node = UA_NODESTORE_GET(server, nodeId); + if(!node) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + UA_StatusCode retval = callback(server, session, (UA_Node*)(uintptr_t)node, data); + UA_NODESTORE_RELEASE(server, node); + return retval; +#else + UA_StatusCode retval; + do { + /* Get an editable copy of the node */ + UA_Node *node; + retval = UA_NODESTORE_GETCOPY(server, nodeId, &node); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Run the operation on the copy */ + retval = callback(server, session, node, data); + if(retval != UA_STATUSCODE_GOOD) { + UA_NODESTORE_DELETE(server, node); + return retval; + } + + /* Replace the node */ + retval = UA_NODESTORE_REPLACE(server, node); + } while(retval != UA_STATUSCODE_GOOD); + return retval; +#endif +} + +UA_StatusCode +UA_Server_processServiceOperations(UA_Server *server, UA_Session *session, + UA_ServiceOperation operationCallback, + const void *context, const size_t *requestOperations, + const UA_DataType *requestOperationsType, + size_t *responseOperations, + const UA_DataType *responseOperationsType) { + size_t ops = *requestOperations; + if(ops == 0) + return UA_STATUSCODE_BADNOTHINGTODO; + + /* No padding after size_t */ + void **respPos = (void**)((uintptr_t)responseOperations + sizeof(size_t)); + *respPos = UA_Array_new(ops, responseOperationsType); + if(!(*respPos)) + return UA_STATUSCODE_BADOUTOFMEMORY; + + *responseOperations = ops; + uintptr_t respOp = (uintptr_t)*respPos; + /* No padding after size_t */ + uintptr_t reqOp = *(uintptr_t*)((uintptr_t)requestOperations + sizeof(size_t)); + for(size_t i = 0; i < ops; i++) { + operationCallback(server, session, context, (void*)reqOp, (void*)respOp); + reqOp += requestOperationsType->memSize; + respOp += responseOperationsType->memSize; + } + return UA_STATUSCODE_GOOD; +} + +/* A few global NodeId definitions */ +const UA_NodeId subtypeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASSUBTYPE}}; +const UA_NodeId hierarchicalReferences = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HIERARCHICALREFERENCES}}; + +/*********************************/ +/* Default attribute definitions */ +/*********************************/ + +const UA_ObjectAttributes UA_ObjectAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + 0 /* eventNotifier */ +}; + +const UA_VariableAttributes UA_VariableAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + {NULL, UA_VARIANT_DATA, + 0, NULL, 0, NULL}, /* value */ + {0, UA_NODEIDTYPE_NUMERIC, + {UA_NS0ID_BASEDATATYPE}}, /* dataType */ + UA_VALUERANK_ANY, /* valueRank */ + 0, NULL, /* arrayDimensions */ + UA_ACCESSLEVELMASK_READ, 0, /* accessLevel (userAccessLevel) */ + 0.0, /* minimumSamplingInterval */ + false /* historizing */ +}; + +const UA_MethodAttributes UA_MethodAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + true, true /* executable (userExecutable) */ +}; + +const UA_ObjectTypeAttributes UA_ObjectTypeAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + false /* isAbstract */ +}; + +const UA_VariableTypeAttributes UA_VariableTypeAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + {NULL, UA_VARIANT_DATA, + 0, NULL, 0, NULL}, /* value */ + {0, UA_NODEIDTYPE_NUMERIC, + {UA_NS0ID_BASEDATATYPE}}, /* dataType */ + UA_VALUERANK_ANY, /* valueRank */ + 0, NULL, /* arrayDimensions */ + false /* isAbstract */ +}; + +const UA_ReferenceTypeAttributes UA_ReferenceTypeAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + false, /* isAbstract */ + false, /* symmetric */ + {{0, NULL}, {0, NULL}} /* inverseName */ +}; + +const UA_DataTypeAttributes UA_DataTypeAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + false /* isAbstract */ +}; + +const UA_ViewAttributes UA_ViewAttributes_default = { + 0, /* specifiedAttributes */ + {{0, NULL}, {0, NULL}}, /* displayName */ + {{0, NULL}, {0, NULL}}, /* description */ + 0, 0, /* writeMask (userWriteMask) */ + false, /* containsNoLoops */ + 0 /* eventNotifier */ +}; + + +/**** amalgamated original file "/src/server/ua_server_discovery.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + + +#ifdef UA_ENABLE_DISCOVERY + +UA_StatusCode +register_server_with_discovery_server(UA_Server *server, + void *pClient, + const UA_Boolean isUnregister, + const char* semaphoreFilePath) { + UA_Client *client = (UA_Client *) pClient; + + /* Prepare the request. Do not cleanup the request after the service call, + * as the members are stack-allocated or point into the server config. */ + UA_RegisterServer2Request request; + UA_RegisterServer2Request_init(&request); + request.requestHeader.timestamp = UA_DateTime_now(); + request.requestHeader.timeoutHint = 10000; + + request.server.isOnline = !isUnregister; + request.server.serverUri = server->config.applicationDescription.applicationUri; + request.server.productUri = server->config.applicationDescription.productUri; + request.server.serverType = server->config.applicationDescription.applicationType; + request.server.gatewayServerUri = server->config.applicationDescription.gatewayServerUri; + + if(semaphoreFilePath) { +#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE + request.server.semaphoreFilePath = + UA_STRING((char*)(uintptr_t)semaphoreFilePath); /* dirty cast */ +#else + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_CLIENT, + "Ignoring semaphore file path. open62541 not compiled " + "with UA_ENABLE_DISCOVERY_SEMAPHORE=ON"); +#endif + } + + request.server.serverNames = &server->config.applicationDescription.applicationName; + request.server.serverNamesSize = 1; + + /* Mirror the discovery urls from the server config and the network layers */ + size_t config_discurls = server->config.applicationDescription.discoveryUrlsSize; + size_t nl_discurls = server->config.networkLayersSize; + size_t total_discurls = config_discurls + nl_discurls; + request.server.discoveryUrls = (UA_String*) + UA_Array_new(total_discurls, &UA_TYPES[UA_TYPES_STRING]); + if(!request.server.discoveryUrls) + return UA_STATUSCODE_BADOUTOFMEMORY; + + for(size_t i = 0; i < config_discurls; ++i) + request.server.discoveryUrls[i] = server->config.applicationDescription.discoveryUrls[i]; + /* TODO: Add nl only if discoveryUrl not already present */ + for(size_t i = 0; i < nl_discurls; ++i) { + UA_ServerNetworkLayer *nl = &server->config.networkLayers[i]; + request.server.discoveryUrls[config_discurls + i] = nl->discoveryUrl; + } + request.server.discoveryUrlsSize = total_discurls; + +#ifdef UA_ENABLE_DISCOVERY_MULTICAST + request.discoveryConfigurationSize = 1; + request.discoveryConfiguration = UA_ExtensionObject_new(); + // Set to NODELETE so that we can just use a pointer to the mdns config + UA_ExtensionObject_setValueNoDelete(request.discoveryConfiguration, + &server->config.mdnsConfig, + &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION]); +#endif + + // First try with RegisterServer2, if that isn't implemented, use RegisterServer + UA_RegisterServer2Response response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_REGISTERSERVER2REQUEST], + &response, &UA_TYPES[UA_TYPES_REGISTERSERVER2RESPONSE]); + + UA_StatusCode serviceResult = response.responseHeader.serviceResult; + UA_RegisterServer2Response_clear(&response); + UA_Array_delete(request.discoveryConfiguration, + request.discoveryConfigurationSize, + &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); + if(total_discurls > 0) + UA_free(request.server.discoveryUrls); + + if(serviceResult == UA_STATUSCODE_BADNOTIMPLEMENTED || + serviceResult == UA_STATUSCODE_BADSERVICEUNSUPPORTED) { + /* Try RegisterServer */ + UA_RegisterServerRequest request_fallback; + UA_RegisterServerRequest_init(&request_fallback); + /* Copy from RegisterServer2 request */ + request_fallback.requestHeader = request.requestHeader; + request_fallback.server = request.server; + + UA_RegisterServerResponse response_fallback; + + __UA_Client_Service(client, &request_fallback, + &UA_TYPES[UA_TYPES_REGISTERSERVERREQUEST], + &response_fallback, + &UA_TYPES[UA_TYPES_REGISTERSERVERRESPONSE]); + + serviceResult = response_fallback.responseHeader.serviceResult; + UA_RegisterServerResponse_clear(&response_fallback); + } + + if(serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_CLIENT, + "RegisterServer/RegisterServer2 failed with statuscode %s", + UA_StatusCode_name(serviceResult)); + } + + return serviceResult; +} + +UA_StatusCode +UA_Server_register_discovery(UA_Server *server, UA_Client *client, + const char* semaphoreFilePath) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = register_server_with_discovery_server(server, client, + false, semaphoreFilePath); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +UA_Server_unregister_discovery(UA_Server *server, UA_Client *client) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = register_server_with_discovery_server(server, client, + true, NULL); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +#endif /* UA_ENABLE_DISCOVERY */ + +/**** amalgamated original file "/src/server/ua_server_async.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2019 (c) Fraunhofer IOSB (Author: Klaus Schick) + * Copyright 2019 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + +#if UA_MULTITHREADING >= 100 + +static void +UA_AsyncOperation_delete(UA_AsyncOperation *ar) { + UA_CallMethodRequest_clear(&ar->request); + UA_CallMethodResult_clear(&ar->response); + UA_free(ar); +} + +static UA_StatusCode +UA_AsyncManager_sendAsyncResponse(UA_AsyncManager *am, UA_Server *server, + UA_AsyncResponse *ar) { + /* Get the session */ + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_LOCK(&server->serviceMutex); + UA_Session* session = UA_Server_getSessionById(server, &ar->sessionId); + UA_UNLOCK(&server->serviceMutex); + UA_SecureChannel* channel = NULL; + UA_ResponseHeader *responseHeader = NULL; + if(!session) { + res = UA_STATUSCODE_BADSESSIONIDINVALID; + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_InsertMethodResponse: Session is gone"); + goto clean_up; + } + + /* Check the channel */ + channel = session->header.channel; + if(!channel) { + res = UA_STATUSCODE_BADSECURECHANNELCLOSED; + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_InsertMethodResponse: Channel is gone"); + goto clean_up; + } + + /* Okay, here we go, send the UA_CallResponse */ + responseHeader = (UA_ResponseHeader*) + &ar->response.callResponse.responseHeader; + responseHeader->requestHandle = ar->requestHandle; + res = sendResponse(server, session, channel, ar->requestId, + (UA_Response*)&ar->response, &UA_TYPES[UA_TYPES_CALLRESPONSE]); + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_SendResponse: Response for Req# %" PRIu32 " sent", ar->requestId); + + clean_up: + /* Remove from the AsyncManager */ + UA_AsyncManager_removeAsyncResponse(&server->asyncManager, ar); + return res; +} + +/* Integrate operation result in the AsyncResponse and send out the response if + * it is ready. */ +static void +integrateOperationResult(UA_AsyncManager *am, UA_Server *server, + UA_AsyncOperation *ao) { + /* Grab the open request, so we can continue to construct the response */ + UA_AsyncResponse *ar = ao->parent; + + /* Reduce the number of open results */ + ar->opCountdown -= 1; + + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Return result in the server thread with %" PRIu32 " remaining", + ar->opCountdown); + + /* Move the UA_CallMethodResult to UA_CallResponse */ + ar->response.callResponse.results[ao->index] = ao->response; + UA_CallMethodResult_init(&ao->response); + + /* Are we done with all operations? */ + if(ar->opCountdown == 0) + UA_AsyncManager_sendAsyncResponse(am, server, ar); +} + +/* Process all operations in the result queue -> move content over to the + * AsyncResponse. This is only done by the server thread. */ +static void +processAsyncResults(UA_Server *server, void *data) { + UA_AsyncManager *am = &server->asyncManager; + while(true) { + UA_LOCK(&am->queueLock); + UA_AsyncOperation *ao = TAILQ_FIRST(&am->resultQueue); + if(ao) + TAILQ_REMOVE(&am->resultQueue, ao, pointers); + UA_UNLOCK(&am->queueLock); + if(!ao) + break; + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_CallMethodResponse: Got Response: OKAY"); + integrateOperationResult(am, server, ao); + UA_AsyncOperation_delete(ao); + am->opsCount--; + } +} + +/* Check if any operations have timed out */ +static void +checkTimeouts(UA_Server *server, void *_) { + /* Timeouts are not configured */ + if(server->config.asyncOperationTimeout <= 0.0) + return; + + UA_AsyncManager *am = &server->asyncManager; + const UA_DateTime tNow = UA_DateTime_now(); + + UA_LOCK(&am->queueLock); + + /* Loop over the queue of dispatched ops */ + UA_AsyncOperation *op = NULL, *op_tmp = NULL; + TAILQ_FOREACH_SAFE(op, &am->dispatchedQueue, pointers, op_tmp) { + /* The timeout has not passed. Also for all elements following in the queue. */ + if(tNow <= op->parent->timeout) + break; + + /* Mark as timed out and put it into the result queue */ + op->response.statusCode = UA_STATUSCODE_BADTIMEOUT; + TAILQ_REMOVE(&am->dispatchedQueue, op, pointers); + TAILQ_INSERT_TAIL(&am->resultQueue, op, pointers); + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Operation was removed due to a timeout"); + } + + /* Loop over the queue of new ops */ + TAILQ_FOREACH_SAFE(op, &am->newQueue, pointers, op_tmp) { + /* The timeout has not passed. Also for all elements following in the queue. */ + if(tNow <= op->parent->timeout) + break; + + /* Mark as timed out and put it into the result queue */ + op->response.statusCode = UA_STATUSCODE_BADTIMEOUT; + TAILQ_REMOVE(&am->newQueue, op, pointers); + TAILQ_INSERT_TAIL(&am->resultQueue, op, pointers); + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Operation was removed due to a timeout"); + } + + UA_UNLOCK(&am->queueLock); + + /* Integrate async results and send out complete responses */ + processAsyncResults(server, NULL); +} + +void +UA_AsyncManager_init(UA_AsyncManager *am, UA_Server *server) { + memset(am, 0, sizeof(UA_AsyncManager)); + TAILQ_INIT(&am->asyncResponses); + TAILQ_INIT(&am->newQueue); + TAILQ_INIT(&am->dispatchedQueue); + TAILQ_INIT(&am->resultQueue); + UA_LOCK_INIT(&am->queueLock); + + /* Add a regular callback for cleanup and sending finished responses at a + * 100s interval. */ + UA_Server_addRepeatedCallback(server, (UA_ServerCallback)checkTimeouts, + NULL, 100.0, &am->checkTimeoutCallbackId); +} + +void +UA_AsyncManager_clear(UA_AsyncManager *am, UA_Server *server) { + removeCallback(server, am->checkTimeoutCallbackId); + + UA_AsyncOperation *ar; + + /* Clean up queues */ + UA_LOCK(&am->queueLock); + while((ar = TAILQ_FIRST(&am->newQueue))) { + TAILQ_REMOVE(&am->resultQueue, ar, pointers); + UA_AsyncOperation_delete(ar); + } + while((ar = TAILQ_FIRST(&am->dispatchedQueue))) { + TAILQ_REMOVE(&am->resultQueue, ar, pointers); + UA_AsyncOperation_delete(ar); + } + while((ar = TAILQ_FIRST(&am->resultQueue))) { + TAILQ_REMOVE(&am->resultQueue, ar, pointers); + UA_AsyncOperation_delete(ar); + } + UA_UNLOCK(&am->queueLock); + + /* Remove responses */ + UA_AsyncResponse *current, *temp; + TAILQ_FOREACH_SAFE(current, &am->asyncResponses, pointers, temp) { + UA_AsyncManager_removeAsyncResponse(am, current); + } + + /* Delete all locks */ + UA_LOCK_DESTROY(&am->queueLock); +} + +UA_StatusCode +UA_AsyncManager_createAsyncResponse(UA_AsyncManager *am, UA_Server *server, + const UA_NodeId *sessionId, + const UA_UInt32 requestId, const UA_UInt32 requestHandle, + const UA_AsyncOperationType operationType, + UA_AsyncResponse **outAr) { + UA_AsyncResponse *newentry = (UA_AsyncResponse*)UA_calloc(1, sizeof(UA_AsyncResponse)); + if(!newentry) + return UA_STATUSCODE_BADOUTOFMEMORY; + + UA_StatusCode res = UA_NodeId_copy(sessionId, &newentry->sessionId); + if(res != UA_STATUSCODE_GOOD) { + UA_free(newentry); + return res; + } + + am->asyncResponsesCount += 1; + newentry->requestId = requestId; + newentry->requestHandle = requestHandle; + newentry->timeout = UA_DateTime_now(); + if(server->config.asyncOperationTimeout > 0.0) + newentry->timeout += (UA_DateTime) + (server->config.asyncOperationTimeout * (UA_DateTime)UA_DATETIME_MSEC); + TAILQ_INSERT_TAIL(&am->asyncResponses, newentry, pointers); + + *outAr = newentry; + return UA_STATUSCODE_GOOD; +} + +/* Remove entry and free all allocated data */ +void +UA_AsyncManager_removeAsyncResponse(UA_AsyncManager *am, UA_AsyncResponse *ar) { + TAILQ_REMOVE(&am->asyncResponses, ar, pointers); + am->asyncResponsesCount -= 1; + UA_CallResponse_clear(&ar->response.callResponse); + UA_NodeId_clear(&ar->sessionId); + UA_free(ar); +} + +/* Enqueue next MethodRequest */ +UA_StatusCode +UA_AsyncManager_createAsyncOp(UA_AsyncManager *am, UA_Server *server, + UA_AsyncResponse *ar, size_t opIndex, + const UA_CallMethodRequest *opRequest) { + if(server->config.maxAsyncOperationQueueSize != 0 && + am->opsCount >= server->config.maxAsyncOperationQueueSize) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_SetNextAsyncMethod: Queue exceeds limit (%d).", + (int unsigned)server->config.maxAsyncOperationQueueSize); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + + UA_AsyncOperation *ao = (UA_AsyncOperation*)UA_calloc(1, sizeof(UA_AsyncOperation)); + if(!ao) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_SetNextAsyncMethod: Mem alloc failed."); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_StatusCode result = UA_CallMethodRequest_copy(opRequest, &ao->request); + if(result != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_SetAsyncMethodResult: UA_CallMethodRequest_copy failed."); + UA_free(ao); + return result; + } + + UA_CallMethodResult_init(&ao->response); + ao->index = opIndex; + ao->parent = ar; + + UA_LOCK(&am->queueLock); + TAILQ_INSERT_TAIL(&am->newQueue, ao, pointers); + am->opsCount++; + ar->opCountdown++; + UA_UNLOCK(&am->queueLock); + + if(server->config.asyncOperationNotifyCallback) + server->config.asyncOperationNotifyCallback(server); + + return UA_STATUSCODE_GOOD; +} + +/* Get and remove next Method Call Request */ +UA_Boolean +UA_Server_getAsyncOperationNonBlocking(UA_Server *server, UA_AsyncOperationType *type, + const UA_AsyncOperationRequest **request, + void **context, UA_DateTime *timeout) { + UA_AsyncManager *am = &server->asyncManager; + + UA_Boolean bRV = false; + *type = UA_ASYNCOPERATIONTYPE_INVALID; + UA_LOCK(&am->queueLock); + UA_AsyncOperation *ao = TAILQ_FIRST(&am->newQueue); + if(ao) { + TAILQ_REMOVE(&am->newQueue, ao, pointers); + TAILQ_INSERT_TAIL(&am->dispatchedQueue, ao, pointers); + *type = UA_ASYNCOPERATIONTYPE_CALL; + *request = (UA_AsyncOperationRequest*)&ao->request; + *context = (void*)ao; + if(timeout) + *timeout = ao->parent->timeout; + bRV = true; + } + UA_UNLOCK(&am->queueLock); + + return bRV; +} + +UA_Boolean +UA_Server_getAsyncOperation(UA_Server *server, UA_AsyncOperationType *type, + const UA_AsyncOperationRequest **request, + void **context) { + return UA_Server_getAsyncOperationNonBlocking(server, type, request, context, NULL); +} + +/* Worker submits Method Call Response */ +void +UA_Server_setAsyncOperationResult(UA_Server *server, + const UA_AsyncOperationResponse *response, + void *context) { + UA_AsyncManager *am = &server->asyncManager; + + UA_AsyncOperation *ao = (UA_AsyncOperation*)context; + if(!ao) { + /* Something went wrong. Not a good AsyncOp. */ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_SetAsyncMethodResult: Invalid context"); + return; + } + + UA_LOCK(&am->queueLock); + + /* See if the operation is still in the dispatched queue. Otherwise it has + * been removed due to a timeout. + * + * TODO: Add a tree-structure for the dispatch queue. The linear lookup does + * not scale. */ + UA_Boolean found = false; + UA_AsyncOperation *op = NULL; + TAILQ_FOREACH(op, &am->dispatchedQueue, pointers) { + if(op == ao) { + found = true; + break; + } + } + + if(!found) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_SetAsyncMethodResult: The operation has timed out"); + UA_UNLOCK(&am->queueLock); + return; + } + + /* Copy the result into the internal AsyncOperation */ + UA_StatusCode result = + UA_CallMethodResult_copy(&response->callMethodResult, &ao->response); + if(result != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_Server_SetAsyncMethodResult: UA_CallMethodResult_copy failed."); + ao->response.statusCode = UA_STATUSCODE_BADOUTOFMEMORY; + } + + /* Move to the result queue */ + TAILQ_REMOVE(&am->dispatchedQueue, ao, pointers); + TAILQ_INSERT_TAIL(&am->resultQueue, ao, pointers); + + UA_UNLOCK(&am->queueLock); + + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Set the result from the worker thread"); +} + +/******************/ +/* Server Methods */ +/******************/ + +static UA_StatusCode +setMethodNodeAsync(UA_Server *server, UA_Session *session, + UA_Node *node, UA_Boolean *isAsync) { + if(node->head.nodeClass != UA_NODECLASS_METHOD) + return UA_STATUSCODE_BADNODECLASSINVALID; + node->methodNode.async = *isAsync; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_setMethodNodeAsync(UA_Server *server, const UA_NodeId id, + UA_Boolean isAsync) { + return UA_Server_editNode(server, &server->adminSession, &id, + (UA_EditNodeCallback)setMethodNodeAsync, &isAsync); +} + +UA_StatusCode +UA_Server_processServiceOperationsAsync(UA_Server *server, UA_Session *session, + UA_UInt32 requestId, UA_UInt32 requestHandle, + UA_AsyncServiceOperation operationCallback, + const size_t *requestOperations, + const UA_DataType *requestOperationsType, + size_t *responseOperations, + const UA_DataType *responseOperationsType, + UA_AsyncResponse **ar) { + size_t ops = *requestOperations; + if(ops == 0) + return UA_STATUSCODE_BADNOTHINGTODO; + + /* Allocate the response array. No padding after size_t */ + void **respPos = (void**)((uintptr_t)responseOperations + sizeof(size_t)); + *respPos = UA_Array_new(ops, responseOperationsType); + if(!*respPos) + return UA_STATUSCODE_BADOUTOFMEMORY; + *responseOperations = ops; + + /* Finish / dispatch the operations. This may allocate a new AsyncResponse internally */ + uintptr_t respOp = (uintptr_t)*respPos; + uintptr_t reqOp = *(uintptr_t*)((uintptr_t)requestOperations + sizeof(size_t)); + for(size_t i = 0; i < ops; i++) { + operationCallback(server, session, requestId, requestHandle, + i, (void*)reqOp, (void*)respOp, ar); + reqOp += requestOperationsType->memSize; + respOp += responseOperationsType->memSize; + } + + return UA_STATUSCODE_GOOD; +} + +#endif + +/**** amalgamated original file "/src/pubsub/ua_pubsub_networkmessage.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017 - 2018 Fraunhofer IOSB (Author: Tino Bischoff) + * Copyright (c) 2019 Fraunhofer IOSB (Author: Andreas Ebner) + */ + + + +#ifdef UA_ENABLE_PUBSUB /* conditional compilation */ + +const UA_Byte NM_VERSION_MASK = 15; +const UA_Byte NM_PUBLISHER_ID_ENABLED_MASK = 16; +const UA_Byte NM_GROUP_HEADER_ENABLED_MASK = 32; +const UA_Byte NM_PAYLOAD_HEADER_ENABLED_MASK = 64; +const UA_Byte NM_EXTENDEDFLAGS1_ENABLED_MASK = 128; +const UA_Byte NM_PUBLISHER_ID_MASK = 7; +const UA_Byte NM_DATASET_CLASSID_ENABLED_MASK = 8; +const UA_Byte NM_SECURITY_ENABLED_MASK = 16; +const UA_Byte NM_TIMESTAMP_ENABLED_MASK = 32; +const UA_Byte NM_PICOSECONDS_ENABLED_MASK = 64; +const UA_Byte NM_EXTENDEDFLAGS2_ENABLED_MASK = 128; +const UA_Byte NM_NETWORK_MSG_TYPE_MASK = 28; +const UA_Byte NM_CHUNK_MESSAGE_MASK = 1; +const UA_Byte NM_PROMOTEDFIELDS_ENABLED_MASK = 2; +const UA_Byte GROUP_HEADER_WRITER_GROUPID_ENABLED = 1; +const UA_Byte GROUP_HEADER_GROUP_VERSION_ENABLED = 2; +const UA_Byte GROUP_HEADER_NM_NUMBER_ENABLED = 4; +const UA_Byte GROUP_HEADER_SEQUENCE_NUMBER_ENABLED = 8; +const UA_Byte SECURITY_HEADER_NM_SIGNED = 1; +const UA_Byte SECURITY_HEADER_NM_ENCRYPTED = 2; +const UA_Byte SECURITY_HEADER_SEC_FOOTER_ENABLED = 4; +const UA_Byte SECURITY_HEADER_FORCE_KEY_RESET = 8; +const UA_Byte DS_MESSAGEHEADER_DS_MSG_VALID = 1; +const UA_Byte DS_MESSAGEHEADER_FIELD_ENCODING_MASK = 6; +const UA_Byte DS_MESSAGEHEADER_SEQ_NR_ENABLED_MASK = 8; +const UA_Byte DS_MESSAGEHEADER_STATUS_ENABLED_MASK = 16; +const UA_Byte DS_MESSAGEHEADER_CONFIGMAJORVERSION_ENABLED_MASK = 32; +const UA_Byte DS_MESSAGEHEADER_CONFIGMINORVERSION_ENABLED_MASK = 64; +const UA_Byte DS_MESSAGEHEADER_FLAGS2_ENABLED_MASK = 128; +const UA_Byte DS_MESSAGEHEADER_DS_MESSAGE_TYPE_MASK = 15; +const UA_Byte DS_MESSAGEHEADER_TIMESTAMP_ENABLED_MASK = 16; +const UA_Byte DS_MESSAGEHEADER_PICOSECONDS_INCLUDED_MASK = 32; +const UA_Byte NM_SHIFT_LEN = 2; +const UA_Byte DS_MH_SHIFT_LEN = 1; + +static UA_Boolean UA_NetworkMessage_ExtendedFlags1Enabled(const UA_NetworkMessage* src); +static UA_Boolean UA_NetworkMessage_ExtendedFlags2Enabled(const UA_NetworkMessage* src); +static UA_Boolean UA_DataSetMessageHeader_DataSetFlags2Enabled(const UA_DataSetMessageHeader* src); + +UA_StatusCode +UA_NetworkMessage_updateBufferedMessage(UA_NetworkMessageOffsetBuffer *buffer){ + UA_StatusCode rv = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < buffer->offsetsSize; ++i) { + UA_NetworkMessageOffset *nmo = &buffer->offsets[i]; + const UA_Byte *bufEnd = &buffer->buffer.data[buffer->buffer.length]; + UA_Byte *bufPos = &buffer->buffer.data[nmo->offset]; + switch(nmo->contentType) { + case UA_PUBSUB_OFFSETTYPE_DATASETMESSAGE_SEQUENCENUMBER: + case UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_SEQUENCENUMBER: + rv = UA_UInt16_encodeBinary((UA_UInt16 *)nmo->offsetData.value.value->value.data, &bufPos, bufEnd); + break; + case UA_PUBSUB_OFFSETTYPE_PAYLOAD_DATAVALUE: + rv = UA_DataValue_encodeBinary(nmo->offsetData.value.value, + &bufPos, bufEnd); + break; + case UA_PUBSUB_OFFSETTYPE_PAYLOAD_VARIANT: + rv = UA_Variant_encodeBinary(&nmo->offsetData.value.value->value, + &bufPos, bufEnd); + break; + case UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW: + rv = UA_encodeBinaryInternal(nmo->offsetData.value.value->value.data, + nmo->offsetData.value.value->value.type, + &bufPos, &bufEnd, NULL, NULL); + break; + case UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_FIELDENCDODING: + break; + default: + return UA_STATUSCODE_BADNOTSUPPORTED; + } + } + return rv; +} + +UA_StatusCode +UA_NetworkMessage_updateBufferedNwMessage(UA_NetworkMessageOffsetBuffer *buffer, + const UA_ByteString *src, size_t *bufferPosition){ + UA_StatusCode rv = UA_STATUSCODE_GOOD; + size_t payloadCounter = 0; + size_t offset = 0; + UA_DataSetMessage* dsm = buffer->nm->payload.dataSetPayload.dataSetMessages; //Considering one DSM in RT TODO: Clarify multiple DSM + UA_DataSetMessageHeader header; + size_t smallestRawOffset = UA_UINT32_MAX; + + for (size_t i = 0; i < buffer->offsetsSize; ++i) { + offset = buffer->offsets[i].offset + *bufferPosition; + switch (buffer->offsets[i].contentType) { + case UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_FIELDENCDODING: + rv = UA_DataSetMessageHeader_decodeBinary(src, &offset, &header); + if(rv != UA_STATUSCODE_GOOD) + return rv; + break; + case UA_PUBSUB_OFFSETTYPE_PUBLISHERID: + switch (buffer->nm->publisherIdType) { + case UA_PUBLISHERDATATYPE_BYTE: + rv = UA_Byte_decodeBinary(src, &offset, &(buffer->nm->publisherId.publisherIdByte)); + break; + case UA_PUBLISHERDATATYPE_UINT16: + rv = UA_UInt16_decodeBinary(src, &offset, &(buffer->nm->publisherId.publisherIdUInt16)); + break; + case UA_PUBLISHERDATATYPE_UINT32: + rv = UA_UInt32_decodeBinary(src, &offset, &(buffer->nm->publisherId.publisherIdUInt32)); + break; + case UA_PUBLISHERDATATYPE_UINT64: + rv = UA_UInt64_decodeBinary(src, &offset, &(buffer->nm->publisherId.publisherIdUInt64)); + break; + default: + return UA_STATUSCODE_BADNOTSUPPORTED; + } + break; + case UA_PUBSUB_OFFSETTYPE_WRITERGROUPID: + rv = UA_UInt16_decodeBinary(src, &offset, &buffer->nm->groupHeader.writerGroupId); + UA_CHECK_STATUS(rv, return rv); + break; + case UA_PUBSUB_OFFSETTYPE_DATASETWRITERID: + rv = UA_UInt16_decodeBinary(src, &offset, + &buffer->nm->payloadHeader.dataSetPayloadHeader.dataSetWriterIds[0]); /* TODO */ + UA_CHECK_STATUS(rv, return rv); + break; + case UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_SEQUENCENUMBER: + rv = UA_UInt16_decodeBinary(src, &offset, &buffer->nm->groupHeader.sequenceNumber); + UA_CHECK_STATUS(rv, return rv); + break; + case UA_PUBSUB_OFFSETTYPE_PAYLOAD_DATAVALUE: + rv = UA_DataValue_decodeBinary(src, &offset, + &(dsm->data.keyFrameData.dataSetFields[payloadCounter])); + UA_CHECK_STATUS(rv, return rv); + payloadCounter++; + break; + case UA_PUBSUB_OFFSETTYPE_PAYLOAD_VARIANT: + rv = UA_Variant_decodeBinary(src, &offset, + &dsm->data.keyFrameData.dataSetFields[payloadCounter].value); + UA_CHECK_STATUS(rv, return rv); + dsm->data.keyFrameData.dataSetFields[payloadCounter].hasValue = true; + payloadCounter++; + break; + case UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW: + /* We need only the start address of the raw fields */ + if (smallestRawOffset > offset){ + smallestRawOffset = offset; + dsm->data.keyFrameData.rawFields.data = &src->data[offset]; + dsm->data.keyFrameData.rawFields.length = buffer->rawMessageLength; + } + payloadCounter++; + break; + default: + return UA_STATUSCODE_BADNOTSUPPORTED; + } + } + //check if the frame is of type "raw" payload + if(smallestRawOffset != UA_UINT32_MAX){ + *bufferPosition = smallestRawOffset + buffer->rawMessageLength; + } else { + *bufferPosition = offset; + } + + return rv; +} + +static +UA_StatusCode +UA_NetworkMessageHeader_encodeBinary(const UA_NetworkMessage *src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + + /* UADPVersion + UADP Flags */ + UA_Byte v = src->version; + if(src->publisherIdEnabled) + v |= NM_PUBLISHER_ID_ENABLED_MASK; + + if(src->groupHeaderEnabled) + v |= NM_GROUP_HEADER_ENABLED_MASK; + + if(src->payloadHeaderEnabled) + v |= NM_PAYLOAD_HEADER_ENABLED_MASK; + + if(UA_NetworkMessage_ExtendedFlags1Enabled(src)) + v |= NM_EXTENDEDFLAGS1_ENABLED_MASK; + + UA_StatusCode rv = UA_Byte_encodeBinary(&v, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + // ExtendedFlags1 + if(UA_NetworkMessage_ExtendedFlags1Enabled(src)) { + v = (UA_Byte)src->publisherIdType; + + if(src->dataSetClassIdEnabled) + v |= NM_DATASET_CLASSID_ENABLED_MASK; + + if(src->securityEnabled) + v |= NM_SECURITY_ENABLED_MASK; + + if(src->timestampEnabled) + v |= NM_TIMESTAMP_ENABLED_MASK; + + if(src->picosecondsEnabled) + v |= NM_PICOSECONDS_ENABLED_MASK; + + if(UA_NetworkMessage_ExtendedFlags2Enabled(src)) + v |= NM_EXTENDEDFLAGS2_ENABLED_MASK; + + rv = UA_Byte_encodeBinary(&v, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + // ExtendedFlags2 + if(UA_NetworkMessage_ExtendedFlags2Enabled(src)) { + v = (UA_Byte)src->networkMessageType; + // shift left 2 bit + v = (UA_Byte) (v << NM_SHIFT_LEN); + + if(src->chunkMessage) + v |= NM_CHUNK_MESSAGE_MASK; + + if(src->promotedFieldsEnabled) + v |= NM_PROMOTEDFIELDS_ENABLED_MASK; + + rv = UA_Byte_encodeBinary(&v, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + } + + // PublisherId + if(src->publisherIdEnabled) { + switch (src->publisherIdType) { + case UA_PUBLISHERDATATYPE_BYTE: + rv = UA_Byte_encodeBinary(&(src->publisherId.publisherIdByte), bufPos, bufEnd); + break; + + case UA_PUBLISHERDATATYPE_UINT16: + rv = UA_UInt16_encodeBinary(&(src->publisherId.publisherIdUInt16), bufPos, bufEnd); + break; + + case UA_PUBLISHERDATATYPE_UINT32: + rv = UA_UInt32_encodeBinary(&(src->publisherId.publisherIdUInt32), bufPos, bufEnd); + break; + + case UA_PUBLISHERDATATYPE_UINT64: + rv = UA_UInt64_encodeBinary(&(src->publisherId.publisherIdUInt64), bufPos, bufEnd); + break; + + case UA_PUBLISHERDATATYPE_STRING: + rv = UA_String_encodeBinary(&(src->publisherId.publisherIdString), bufPos, bufEnd); + break; + + default: + rv = UA_STATUSCODE_BADINTERNALERROR; + break; + } + UA_CHECK_STATUS(rv, return rv); + } + + // DataSetClassId + if(src->dataSetClassIdEnabled) { + rv = UA_Guid_encodeBinary(&(src->dataSetClassId), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +static +UA_StatusCode +UA_GroupHeader_encodeBinary(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + + UA_Byte v = 0; + + if(src->groupHeader.writerGroupIdEnabled) + v |= GROUP_HEADER_WRITER_GROUPID_ENABLED; + + if(src->groupHeader.groupVersionEnabled) + v |= GROUP_HEADER_GROUP_VERSION_ENABLED; + + if(src->groupHeader.networkMessageNumberEnabled) + v |= GROUP_HEADER_NM_NUMBER_ENABLED; + + if(src->groupHeader.sequenceNumberEnabled) + v |= GROUP_HEADER_SEQUENCE_NUMBER_ENABLED; + + UA_StatusCode rv = UA_Byte_encodeBinary(&v, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + if(src->groupHeader.writerGroupIdEnabled) { + rv = UA_UInt16_encodeBinary(&(src->groupHeader.writerGroupId), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + if(src->groupHeader.groupVersionEnabled) { + rv = UA_UInt32_encodeBinary(&(src->groupHeader.groupVersion), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + if(src->groupHeader.networkMessageNumberEnabled) { + rv = UA_UInt16_encodeBinary(&(src->groupHeader.networkMessageNumber), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + if(src->groupHeader.sequenceNumberEnabled) { + rv = UA_UInt16_encodeBinary(&(src->groupHeader.sequenceNumber), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +static +UA_StatusCode +UA_PayloadHeader_encodeBinary(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + + if(src->networkMessageType != UA_NETWORKMESSAGE_DATASET) + return UA_STATUSCODE_BADNOTIMPLEMENTED; + + UA_StatusCode rv = UA_Byte_encodeBinary(&(src->payloadHeader.dataSetPayloadHeader.count), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + if(src->payloadHeader.dataSetPayloadHeader.dataSetWriterIds == NULL) + return UA_STATUSCODE_BADENCODINGERROR; + + for(UA_Byte i = 0; i < src->payloadHeader.dataSetPayloadHeader.count; i++) { + rv = UA_UInt16_encodeBinary(&(src->payloadHeader.dataSetPayloadHeader.dataSetWriterIds[i]), + bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +static +UA_StatusCode +UA_ExtendedNetworkMessageHeader_encodeBinary(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + + UA_StatusCode rv = UA_STATUSCODE_GOOD; + // Timestamp + if(src->timestampEnabled) + rv = UA_DateTime_encodeBinary(&(src->timestamp), bufPos, bufEnd); + + UA_CHECK_STATUS(rv, return rv); + // Picoseconds + if(src->picosecondsEnabled) + rv = UA_UInt16_encodeBinary(&(src->picoseconds), bufPos, bufEnd); + + UA_CHECK_STATUS(rv, return rv); + // PromotedFields + if(src->promotedFieldsEnabled) { + /* Size (calculate & encode) */ + UA_UInt16 pfSize = 0; + for(UA_UInt16 i = 0; i < src->promotedFieldsSize; i++) + pfSize = (UA_UInt16) (pfSize + UA_Variant_calcSizeBinary(&src->promotedFields[i])); + rv |= UA_UInt16_encodeBinary(&pfSize, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + for (UA_UInt16 i = 0; i < src->promotedFieldsSize; i++) + rv |= UA_Variant_encodeBinary(&(src->promotedFields[i]), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +static +UA_StatusCode +UA_SecurityHeader_encodeBinary(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + // SecurityFlags + UA_Byte v = 0; + if(src->securityHeader.networkMessageSigned) + v |= SECURITY_HEADER_NM_SIGNED; + + if(src->securityHeader.networkMessageEncrypted) + v |= SECURITY_HEADER_NM_ENCRYPTED; + + if(src->securityHeader.securityFooterEnabled) + v |= SECURITY_HEADER_SEC_FOOTER_ENABLED; + + if(src->securityHeader.forceKeyReset) + v |= SECURITY_HEADER_FORCE_KEY_RESET; + + UA_StatusCode rv = UA_Byte_encodeBinary(&v, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + // SecurityTokenId + rv = UA_UInt32_encodeBinary(&src->securityHeader.securityTokenId, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + // NonceLength + UA_Byte nonceLength = (UA_Byte)src->securityHeader.messageNonce.length; + rv = UA_Byte_encodeBinary(&nonceLength, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + // MessageNonce + for (size_t i = 0; i < src->securityHeader.messageNonce.length; i++) { + rv = UA_Byte_encodeBinary(&src->securityHeader.messageNonce.data[i], + bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // SecurityFooterSize + if(src->securityHeader.securityFooterEnabled) { + rv = UA_UInt16_encodeBinary(&src->securityHeader.securityFooterSize, + bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_NetworkMessage_encodeHeaders(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + + UA_StatusCode rv = UA_NetworkMessageHeader_encodeBinary(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + // Group Header + if(src->groupHeaderEnabled) { + rv = UA_GroupHeader_encodeBinary(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // Payload Header + if(src->payloadHeaderEnabled) { + rv = UA_PayloadHeader_encodeBinary(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // Extended Network Message Header + rv = UA_ExtendedNetworkMessageHeader_encodeBinary(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + // SecurityHeader + if(src->securityEnabled) { + rv = UA_SecurityHeader_encodeBinary(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + + +UA_StatusCode +UA_NetworkMessage_encodePayload(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + + UA_StatusCode rv; + + // Payload + if(src->networkMessageType != UA_NETWORKMESSAGE_DATASET) + return UA_STATUSCODE_BADNOTIMPLEMENTED; + + UA_Byte count = 1; + + if(src->payloadHeaderEnabled) { + count = src->payloadHeader.dataSetPayloadHeader.count; + if(count > 1) { + for (UA_Byte i = 0; i < count; i++) { + // initially calculate the size, if not specified + UA_UInt16 sz = 0; + if((src->payload.dataSetPayload.sizes != NULL) && + (src->payload.dataSetPayload.sizes[i] != 0)) { + sz = src->payload.dataSetPayload.sizes[i]; + } else { + sz = (UA_UInt16) UA_DataSetMessage_calcSizeBinary(&src->payload.dataSetPayload.dataSetMessages[i], + NULL, 0); + } + + rv = UA_UInt16_encodeBinary(&sz, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + } + } + + for(UA_Byte i = 0; i < count; i++) { + rv = UA_DataSetMessage_encodeBinary(&(src->payload.dataSetPayload.dataSetMessages[i]), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_NetworkMessage_encodeFooters(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + + if(src->securityEnabled) { + // SecurityFooter + if(src->securityHeader.securityFooterEnabled) { + for(size_t i = 0; i < src->securityHeader.securityFooterSize; i++) { + UA_StatusCode rv = UA_Byte_encodeBinary(&(src->securityFooter.data[i]), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + } + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_NetworkMessage_encodeBinary(const UA_NetworkMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd, UA_Byte **dataToEncryptStart) { + + UA_StatusCode rv = UA_NetworkMessage_encodeHeaders(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + if(dataToEncryptStart) { + *dataToEncryptStart = *bufPos; + } + + rv = UA_NetworkMessage_encodePayload(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_NetworkMessage_encodeFooters(src, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_NetworkMessageHeader_decodeBinary(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst) { + UA_Byte decoded = 0; + UA_StatusCode rv = UA_Byte_decodeBinary(src, offset, &decoded); + UA_CHECK_STATUS(rv, return rv); + + dst->version = decoded & NM_VERSION_MASK; + + if((decoded & NM_PUBLISHER_ID_ENABLED_MASK) != 0) + dst->publisherIdEnabled = true; + + if((decoded & NM_GROUP_HEADER_ENABLED_MASK) != 0) + dst->groupHeaderEnabled = true; + + if((decoded & NM_PAYLOAD_HEADER_ENABLED_MASK) != 0) + dst->payloadHeaderEnabled = true; + + if((decoded & NM_EXTENDEDFLAGS1_ENABLED_MASK) != 0) { + decoded = 0; + rv = UA_Byte_decodeBinary(src, offset, &decoded); + UA_CHECK_STATUS(rv, return rv); + + dst->publisherIdType = (UA_PublisherIdDatatype)(decoded & NM_PUBLISHER_ID_MASK); + if((decoded & NM_DATASET_CLASSID_ENABLED_MASK) != 0) + dst->dataSetClassIdEnabled = true; + + if((decoded & NM_SECURITY_ENABLED_MASK) != 0) + dst->securityEnabled = true; + + if((decoded & NM_TIMESTAMP_ENABLED_MASK) != 0) + dst->timestampEnabled = true; + + if((decoded & NM_PICOSECONDS_ENABLED_MASK) != 0) + dst->picosecondsEnabled = true; + + if((decoded & NM_EXTENDEDFLAGS2_ENABLED_MASK) != 0) { + decoded = 0; + rv = UA_Byte_decodeBinary(src, offset, &decoded); + UA_CHECK_STATUS(rv, return rv); + + if((decoded & NM_CHUNK_MESSAGE_MASK) != 0) + dst->chunkMessage = true; + + if((decoded & NM_PROMOTEDFIELDS_ENABLED_MASK) != 0) + dst->promotedFieldsEnabled = true; + + decoded = decoded & NM_NETWORK_MSG_TYPE_MASK; + decoded = (UA_Byte) (decoded >> NM_SHIFT_LEN); + dst->networkMessageType = (UA_NetworkMessageType)decoded; + } + } + + if(dst->publisherIdEnabled) { + switch (dst->publisherIdType) { + case UA_PUBLISHERDATATYPE_BYTE: + rv = UA_Byte_decodeBinary(src, offset, &(dst->publisherId.publisherIdByte)); + break; + + case UA_PUBLISHERDATATYPE_UINT16: + rv = UA_UInt16_decodeBinary(src, offset, &(dst->publisherId.publisherIdUInt16)); + break; + + case UA_PUBLISHERDATATYPE_UINT32: + rv = UA_UInt32_decodeBinary(src, offset, &(dst->publisherId.publisherIdUInt32)); + break; + + case UA_PUBLISHERDATATYPE_UINT64: + rv = UA_UInt64_decodeBinary(src, offset, &(dst->publisherId.publisherIdUInt64)); + break; + + case UA_PUBLISHERDATATYPE_STRING: + rv = UA_String_decodeBinary(src, offset, &(dst->publisherId.publisherIdString)); + break; + + default: + rv = UA_STATUSCODE_BADINTERNALERROR; + break; + } + UA_CHECK_STATUS(rv, return rv); + } + + if(dst->dataSetClassIdEnabled) { + rv = UA_Guid_decodeBinary(src, offset, &(dst->dataSetClassId)); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_GroupHeader_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_NetworkMessage* dst) { + UA_Byte decoded = 0; + UA_StatusCode rv = UA_Byte_decodeBinary(src, offset, &decoded); + UA_CHECK_STATUS(rv, return rv); + + if((decoded & GROUP_HEADER_WRITER_GROUPID_ENABLED) != 0) + dst->groupHeader.writerGroupIdEnabled = true; + + if((decoded & GROUP_HEADER_GROUP_VERSION_ENABLED) != 0) + dst->groupHeader.groupVersionEnabled = true; + + if((decoded & GROUP_HEADER_NM_NUMBER_ENABLED) != 0) + dst->groupHeader.networkMessageNumberEnabled = true; + + if((decoded & GROUP_HEADER_SEQUENCE_NUMBER_ENABLED) != 0) + dst->groupHeader.sequenceNumberEnabled = true; + + if(dst->groupHeader.writerGroupIdEnabled) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->groupHeader.writerGroupId); + UA_CHECK_STATUS(rv, return rv); + } + if(dst->groupHeader.groupVersionEnabled) { + rv = UA_UInt32_decodeBinary(src, offset, &dst->groupHeader.groupVersion); + UA_CHECK_STATUS(rv, return rv); + } + if(dst->groupHeader.networkMessageNumberEnabled) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->groupHeader.networkMessageNumber); + UA_CHECK_STATUS(rv, return rv); + } + if(dst->groupHeader.sequenceNumberEnabled) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->groupHeader.sequenceNumber); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_PayloadHeader_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_NetworkMessage* dst) { + + if(dst->networkMessageType != UA_NETWORKMESSAGE_DATASET) + return UA_STATUSCODE_BADNOTIMPLEMENTED; + + UA_StatusCode rv = UA_Byte_decodeBinary(src, offset, &dst->payloadHeader.dataSetPayloadHeader.count); + UA_CHECK_STATUS(rv, return rv); + + dst->payloadHeader.dataSetPayloadHeader.dataSetWriterIds = + (UA_UInt16 *)UA_Array_new(dst->payloadHeader.dataSetPayloadHeader.count, + &UA_TYPES[UA_TYPES_UINT16]); + for (UA_Byte i = 0; i < dst->payloadHeader.dataSetPayloadHeader.count; i++) { + rv = UA_UInt16_decodeBinary(src, offset, + &dst->payloadHeader.dataSetPayloadHeader.dataSetWriterIds[i]); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_ExtendedNetworkMessageHeader_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_NetworkMessage* dst) { + UA_StatusCode rv; + + // Timestamp + if(dst->timestampEnabled) { + rv = UA_DateTime_decodeBinary(src, offset, &(dst->timestamp)); + UA_CHECK_STATUS(rv, goto error); + } + + // Picoseconds + if(dst->picosecondsEnabled) { + rv = UA_UInt16_decodeBinary(src, offset, &(dst->picoseconds)); + UA_CHECK_STATUS(rv, goto error); + } + + // PromotedFields + if(dst->promotedFieldsEnabled) { + // Size + UA_UInt16 promotedFieldsSize = 0; + rv = UA_UInt16_decodeBinary(src, offset, &promotedFieldsSize); + UA_CHECK_STATUS(rv, goto error); + + // promotedFieldsSize: here size in Byte, not the number of objects! + if(promotedFieldsSize > 0) { + // store offset, later compared with promotedFieldsSize + size_t offsetEnd = (*offset) + promotedFieldsSize; + + unsigned int counter = 0; + do { + if(counter == 0) { + dst->promotedFields = (UA_Variant*)UA_malloc(UA_TYPES[UA_TYPES_VARIANT].memSize); + UA_CHECK_MEM(dst->promotedFields, + return UA_STATUSCODE_BADOUTOFMEMORY); + // set promotedFieldsSize to the number of objects + dst->promotedFieldsSize = (UA_UInt16) (counter + 1); + } else { + dst->promotedFields = (UA_Variant*) + UA_realloc(dst->promotedFields, + (size_t) UA_TYPES[UA_TYPES_VARIANT].memSize * (counter + 1)); + UA_CHECK_MEM(dst->promotedFields, + return UA_STATUSCODE_BADOUTOFMEMORY); + // set promotedFieldsSize to the number of objects + dst->promotedFieldsSize = (UA_UInt16) (counter + 1); + } + + UA_Variant_init(&dst->promotedFields[counter]); + rv = UA_Variant_decodeBinary(src, offset, &dst->promotedFields[counter]); + UA_CHECK_STATUS(rv, goto error); + + counter++; + } while ((*offset) < offsetEnd); + } + } + return UA_STATUSCODE_GOOD; + +error: + if (dst->promotedFields) { + UA_free(dst->promotedFields); + } + return rv; +} + +static UA_StatusCode +UA_SecurityHeader_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_NetworkMessage* dst) { + UA_Byte decoded = 0; + // SecurityFlags + decoded = 0; + UA_StatusCode rv = UA_Byte_decodeBinary(src, offset, &decoded); + UA_CHECK_STATUS(rv, return rv); + + if((decoded & SECURITY_HEADER_NM_SIGNED) != 0) + dst->securityHeader.networkMessageSigned = true; + + if((decoded & SECURITY_HEADER_NM_ENCRYPTED) != 0) + dst->securityHeader.networkMessageEncrypted = true; + + if((decoded & SECURITY_HEADER_SEC_FOOTER_ENABLED) != 0) + dst->securityHeader.securityFooterEnabled = true; + + if((decoded & SECURITY_HEADER_FORCE_KEY_RESET) != 0) + dst->securityHeader.forceKeyReset = true; + + // SecurityTokenId + rv = UA_UInt32_decodeBinary(src, offset, &dst->securityHeader.securityTokenId); + UA_CHECK_STATUS(rv, return rv); + + // NonceLength + UA_Byte nonceLength; + rv = UA_Byte_decodeBinary(src, offset, &nonceLength); + UA_CHECK_STATUS(rv, return rv); + + // MessageNonce + if(nonceLength > 0) { + //TODO: check for memory leaks + rv = UA_ByteString_allocBuffer(&dst->securityHeader.messageNonce, nonceLength); + UA_CHECK_STATUS(rv, return rv); + for (UA_Byte i = 0; i < nonceLength; i++) { + rv = UA_Byte_decodeBinary(src, offset, + &dst->securityHeader.messageNonce.data[i]); + UA_CHECK_STATUS(rv, return rv); + } + } + // SecurityFooterSize + if(dst->securityHeader.securityFooterEnabled) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->securityHeader.securityFooterSize); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_NetworkMessage_decodeHeaders(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst) { + + UA_StatusCode rv = UA_NetworkMessageHeader_decodeBinary(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + + if (dst->groupHeaderEnabled) { + rv = UA_GroupHeader_decodeBinary(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + } + + if (dst->payloadHeaderEnabled) { + rv = UA_PayloadHeader_decodeBinary(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + } + + if (dst->securityEnabled) { + rv = UA_SecurityHeader_decodeBinary(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + } + + rv = UA_ExtendedNetworkMessageHeader_decodeBinary(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_NetworkMessage_decodePayload(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst) { + + // Payload + if(dst->networkMessageType != UA_NETWORKMESSAGE_DATASET) + return UA_STATUSCODE_BADNOTIMPLEMENTED; + + UA_StatusCode rv; + + UA_Byte count = 1; + if(dst->payloadHeaderEnabled) { + count = dst->payloadHeader.dataSetPayloadHeader.count; + if(count > 1) { + dst->payload.dataSetPayload.sizes = (UA_UInt16 *)UA_Array_new(count, &UA_TYPES[UA_TYPES_UINT16]); + for (UA_Byte i = 0; i < count; i++) { + rv = UA_UInt16_decodeBinary(src, offset, &(dst->payload.dataSetPayload.sizes[i])); + UA_CHECK_STATUS(rv, return rv); + } + } + } + + dst->payload.dataSetPayload.dataSetMessages = (UA_DataSetMessage*) + UA_calloc(count, sizeof(UA_DataSetMessage)); + UA_CHECK_MEM(dst->payload.dataSetPayload.dataSetMessages, + return UA_STATUSCODE_BADOUTOFMEMORY); + + for(UA_Byte i = 0; i < count; i++) { + if(&dst->payload.dataSetPayload.sizes[i] == NULL){ + rv = UA_DataSetMessage_decodeBinary(src, offset, + &(dst->payload.dataSetPayload.dataSetMessages[i]), + 0); + } else { + rv = UA_DataSetMessage_decodeBinary(src, offset, + &(dst->payload.dataSetPayload.dataSetMessages[i]), + dst->payload.dataSetPayload.sizes[i]); + } + UA_CHECK_STATUS(rv, return rv); + } + + return UA_STATUSCODE_GOOD; + + /** + * TODO: check if making the cleanup to free its own allocated memory is better, + * currently the free happens in a parent context + */ + // error: + // if (dst->payload.dataSetPayload.dataSetMessages) { + // UA_free(dst->payload.dataSetPayload.dataSetMessages); + // } + // return rv; +} + +UA_StatusCode +UA_NetworkMessage_decodeFooters(const UA_ByteString *src, size_t *offset, UA_NetworkMessage *dst) { + + if (dst->securityEnabled) { + // SecurityFooter + if(dst->securityHeader.securityFooterEnabled && + (dst->securityHeader.securityFooterSize > 0)) { + UA_StatusCode rv = UA_ByteString_allocBuffer(&dst->securityFooter, + dst->securityHeader.securityFooterSize); + UA_CHECK_STATUS(rv, return rv); + + for(UA_UInt16 i = 0; i < dst->securityHeader.securityFooterSize; i++) { + rv = UA_Byte_decodeBinary(src, offset, &(dst->securityFooter.data[i])); + UA_CHECK_STATUS(rv, return rv); + } + } + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_NetworkMessage_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_NetworkMessage* dst) { + + UA_StatusCode rv = UA_STATUSCODE_GOOD; + + /* headers only need to be decoded when not in encryption mode + * because headers are already decoded when encryption mode is enabled + * to check for security parameters and decrypt/verify + * + * TODO: check if there is a workaround to use this function + * also when encryption is enabled + */ + // #ifndef UA_ENABLE_PUBSUB_ENCRYPTION + // if (*offset == 0) { + // rv = UA_NetworkMessage_decodeHeaders(src, offset, dst); + // UA_CHECK_STATUS(rv, return rv); + // } + // #endif + + rv = UA_NetworkMessage_decodeHeaders(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_NetworkMessage_decodePayload(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_NetworkMessage_decodeFooters(src, offset, dst); + UA_CHECK_STATUS(rv, return rv); + + return UA_STATUSCODE_GOOD; +} + +static UA_Boolean +increaseOffsetArray(UA_NetworkMessageOffsetBuffer *offsetBuffer) { + UA_NetworkMessageOffset *tmpOffsets = (UA_NetworkMessageOffset *) + UA_realloc(offsetBuffer->offsets, sizeof(UA_NetworkMessageOffset) * (offsetBuffer->offsetsSize + (size_t)1)); + UA_CHECK_MEM(tmpOffsets, return false); + + offsetBuffer->offsets = tmpOffsets; + offsetBuffer->offsetsSize++; + return true; +} + +size_t +UA_NetworkMessage_calcSizeBinary(UA_NetworkMessage *p, UA_NetworkMessageOffsetBuffer *offsetBuffer) { + size_t retval = 0; + UA_Byte byte = 0; + size_t size = UA_Byte_calcSizeBinary(&byte); // UADPVersion + UADPFlags + if(UA_NetworkMessage_ExtendedFlags1Enabled(p)) { + size += UA_Byte_calcSizeBinary(&byte); + if(UA_NetworkMessage_ExtendedFlags2Enabled(p)) + size += UA_Byte_calcSizeBinary(&byte); + } + + if(p->publisherIdEnabled) { + if(offsetBuffer && offsetBuffer->RTsubscriberEnabled){ + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_PUBLISHERID; + } + switch (p->publisherIdType) { + case UA_PUBLISHERDATATYPE_BYTE: + size += UA_Byte_calcSizeBinary(&p->publisherId.publisherIdByte); + break; + + case UA_PUBLISHERDATATYPE_UINT16: + size += UA_UInt16_calcSizeBinary(&p->publisherId.publisherIdUInt16); + break; + + case UA_PUBLISHERDATATYPE_UINT32: + size += UA_UInt32_calcSizeBinary(&p->publisherId.publisherIdUInt32); + break; + + case UA_PUBLISHERDATATYPE_UINT64: + size += UA_UInt64_calcSizeBinary(&p->publisherId.publisherIdUInt64); + break; + + case UA_PUBLISHERDATATYPE_STRING: + size += UA_String_calcSizeBinary(&p->publisherId.publisherIdString); + break; + } + } + + if(p->dataSetClassIdEnabled) + size += UA_Guid_calcSizeBinary(&p->dataSetClassId); + + // Group Header + if(p->groupHeaderEnabled) { + size += UA_Byte_calcSizeBinary(&byte); + + if(p->groupHeader.writerGroupIdEnabled) { + if(offsetBuffer && offsetBuffer->RTsubscriberEnabled){ + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_WRITERGROUPID; + } + size += UA_UInt16_calcSizeBinary(&p->groupHeader.writerGroupId); + } + + if(p->groupHeader.groupVersionEnabled) + size += UA_UInt32_calcSizeBinary(&p->groupHeader.groupVersion); + + if(p->groupHeader.networkMessageNumberEnabled) { + size += UA_UInt16_calcSizeBinary(&p->groupHeader.networkMessageNumber); + } + + if(p->groupHeader.sequenceNumberEnabled){ + if(offsetBuffer){ + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].offsetData.value.value = UA_DataValue_new(); + UA_DataValue_init(offsetBuffer->offsets[pos].offsetData.value.value); + UA_Variant_setScalar(&offsetBuffer->offsets[pos].offsetData.value.value->value, + &p->groupHeader.sequenceNumber, &UA_TYPES[UA_TYPES_UINT16]); + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_SEQUENCENUMBER; + } + size += UA_UInt16_calcSizeBinary(&p->groupHeader.sequenceNumber); + } + } + + // Payload Header + if(p->payloadHeaderEnabled) { + if(p->networkMessageType == UA_NETWORKMESSAGE_DATASET) { + size += UA_Byte_calcSizeBinary(&p->payloadHeader.dataSetPayloadHeader.count); + if(p->payloadHeader.dataSetPayloadHeader.dataSetWriterIds != NULL) { + if(offsetBuffer && offsetBuffer->RTsubscriberEnabled){ + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_DATASETWRITERID; + } + size += UA_UInt16_calcSizeBinary(&p->payloadHeader.dataSetPayloadHeader.dataSetWriterIds[0]) * + p->payloadHeader.dataSetPayloadHeader.count; + } else { + return 0; /* no dataSetWriterIds given! */ + } + } else { + // not implemented + } + } + + if(p->timestampEnabled) { + if(offsetBuffer){ + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_TIMESTAMP; + } + size += UA_DateTime_calcSizeBinary(&p->timestamp); + } + + if(p->picosecondsEnabled){ + if (offsetBuffer) { + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_TIMESTAMP_PICOSECONDS; + } + size += UA_UInt16_calcSizeBinary(&p->picoseconds); + } + + if(p->promotedFieldsEnabled) { + size += UA_UInt16_calcSizeBinary(&p->promotedFieldsSize); + for (UA_UInt16 i = 0; i < p->promotedFieldsSize; i++) + size += UA_Variant_calcSizeBinary(&p->promotedFields[i]); + } + + if(p->securityEnabled) { + size += UA_Byte_calcSizeBinary(&byte); + size += UA_UInt32_calcSizeBinary(&p->securityHeader.securityTokenId); + size += 1; /* UA_Byte_calcSizeBinary(&p->securityHeader.nonceLength); */ + size += p->securityHeader.messageNonce.length; + if(p->securityHeader.securityFooterEnabled) + size += UA_UInt16_calcSizeBinary(&p->securityHeader.securityFooterSize); + } + + if(p->networkMessageType == UA_NETWORKMESSAGE_DATASET) { + UA_Byte count = 1; + if(p->payloadHeaderEnabled) { + count = p->payloadHeader.dataSetPayloadHeader.count; + if(count > 1) + size += UA_UInt16_calcSizeBinary(&(p->payload.dataSetPayload.sizes[0])) * count; + } + + for (size_t i = 0; i < count; i++) { + if (offsetBuffer) + UA_DataSetMessage_calcSizeBinary(&(p->payload.dataSetPayload.dataSetMessages[i]), offsetBuffer, + size); + size += UA_DataSetMessage_calcSizeBinary(&(p->payload.dataSetPayload.dataSetMessages[i]), NULL, 0); + } + } + + if(p->securityEnabled) { + if(p->securityHeader.securityFooterEnabled) + size += p->securityHeader.securityFooterSize; + } + + retval = size; + return retval; +} + +void +UA_NetworkMessage_clear(UA_NetworkMessage* p) { + if(p->promotedFieldsEnabled) + UA_Array_delete(p->promotedFields, p->promotedFieldsSize, &UA_TYPES[UA_TYPES_VARIANT]); + + UA_ByteString_clear(&p->securityHeader.messageNonce); + + if(p->networkMessageType == UA_NETWORKMESSAGE_DATASET) { + if(p->payloadHeaderEnabled) { + if(p->payloadHeader.dataSetPayloadHeader.dataSetWriterIds != NULL) { + UA_Array_delete(p->payloadHeader.dataSetPayloadHeader.dataSetWriterIds, + p->payloadHeader.dataSetPayloadHeader.count, &UA_TYPES[UA_TYPES_UINT16]); + } + if(p->payload.dataSetPayload.sizes != NULL) { + UA_Array_delete(p->payload.dataSetPayload.sizes, + p->payloadHeader.dataSetPayloadHeader.count, &UA_TYPES[UA_TYPES_UINT16]); + } + } + + if(p->payload.dataSetPayload.dataSetMessages) { + UA_Byte count = 1; + if(p->payloadHeaderEnabled) + count = p->payloadHeader.dataSetPayloadHeader.count; + + for(size_t i = 0; i < count; i++) + UA_DataSetMessage_clear(&(p->payload.dataSetPayload.dataSetMessages[i])); + + UA_free(p->payload.dataSetPayload.dataSetMessages); + } + } + + if(p->securityHeader.securityFooterEnabled && (p->securityHeader.securityFooterSize > 0)) + UA_ByteString_clear(&p->securityFooter); + + if(p->messageIdEnabled){ + UA_String_clear(&p->messageId); + } + + if(p->publisherIdEnabled && p->publisherIdType == UA_PUBLISHERDATATYPE_STRING){ + UA_String_clear(&p->publisherId.publisherIdString); + } + + memset(p, 0, sizeof(UA_NetworkMessage)); +} + +void UA_NetworkMessage_delete(UA_NetworkMessage* p) { + UA_NetworkMessage_clear(p); +} + +UA_Boolean +UA_NetworkMessage_ExtendedFlags1Enabled(const UA_NetworkMessage* src) { + UA_Boolean retval = false; + + if((src->publisherIdType != UA_PUBLISHERDATATYPE_BYTE) + || src->dataSetClassIdEnabled + || src->securityEnabled + || src->timestampEnabled + || src->picosecondsEnabled + || UA_NetworkMessage_ExtendedFlags2Enabled(src)) + { + retval = true; + } + + return retval; +} + +UA_Boolean +UA_NetworkMessage_ExtendedFlags2Enabled(const UA_NetworkMessage* src) { + if(src->chunkMessage || src->promotedFieldsEnabled || + src->networkMessageType != UA_NETWORKMESSAGE_DATASET) + return true; + return false; +} + +UA_Boolean +UA_DataSetMessageHeader_DataSetFlags2Enabled(const UA_DataSetMessageHeader* src) { + if(src->dataSetMessageType != UA_DATASETMESSAGE_DATAKEYFRAME || + src->timestampEnabled || src->picoSecondsIncluded) + return true; + return false; +} + +UA_StatusCode +UA_DataSetMessageHeader_encodeBinary(const UA_DataSetMessageHeader* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + UA_Byte v; + // DataSetFlags1 + v = (UA_Byte)src->fieldEncoding; + // shift left 1 bit + v = (UA_Byte)(v << DS_MH_SHIFT_LEN); + + if(src->dataSetMessageValid) + v |= DS_MESSAGEHEADER_DS_MSG_VALID; + + if(src->dataSetMessageSequenceNrEnabled) + v |= DS_MESSAGEHEADER_SEQ_NR_ENABLED_MASK; + + if(src->statusEnabled) + v |= DS_MESSAGEHEADER_STATUS_ENABLED_MASK; + + if(src->configVersionMajorVersionEnabled) + v |= DS_MESSAGEHEADER_CONFIGMAJORVERSION_ENABLED_MASK; + + if(src->configVersionMinorVersionEnabled) + v |= DS_MESSAGEHEADER_CONFIGMINORVERSION_ENABLED_MASK; + + if(UA_DataSetMessageHeader_DataSetFlags2Enabled(src)) + v |= DS_MESSAGEHEADER_FLAGS2_ENABLED_MASK; + + UA_StatusCode rv = UA_Byte_encodeBinary(&v, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + // DataSetFlags2 + if(UA_DataSetMessageHeader_DataSetFlags2Enabled(src)) { + v = (UA_Byte)src->dataSetMessageType; + + if(src->timestampEnabled) + v |= DS_MESSAGEHEADER_TIMESTAMP_ENABLED_MASK; + + if(src->picoSecondsIncluded) + v |= DS_MESSAGEHEADER_PICOSECONDS_INCLUDED_MASK; + + rv = UA_Byte_encodeBinary(&v, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // DataSetMessageSequenceNr + if(src->dataSetMessageSequenceNrEnabled) { + rv = UA_UInt16_encodeBinary(&src->dataSetMessageSequenceNr, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // Timestamp + if(src->timestampEnabled) { + rv = UA_DateTime_encodeBinary(&(src->timestamp), bufPos, bufEnd); /* UtcTime */ + UA_CHECK_STATUS(rv, return rv); + } + + // PicoSeconds + if(src->picoSecondsIncluded) { + rv = UA_UInt16_encodeBinary(&(src->picoSeconds), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // Status + if(src->statusEnabled) { + rv = UA_UInt16_encodeBinary(&(src->status), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // ConfigVersionMajorVersion + if(src->configVersionMajorVersionEnabled) { + rv = UA_UInt32_encodeBinary(&(src->configVersionMajorVersion), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + // ConfigVersionMinorVersion + if(src->configVersionMinorVersionEnabled) { + rv = UA_UInt32_encodeBinary(&(src->configVersionMinorVersion), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + +UA_StatusCode +UA_NetworkMessage_signEncrypt(UA_NetworkMessage *nm, UA_MessageSecurityMode securityMode, + UA_PubSubSecurityPolicy *policy, void *policyContext, + UA_Byte *messageStart, UA_Byte *encryptStart, + UA_Byte *sigStart) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + + /* Encrypt the payload */ + if(securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + /* Set the temporary MessageNonce in the SecurityPolicy */ + res = policy->setMessageNonce(policyContext, &nm->securityHeader.messageNonce); + UA_CHECK_STATUS(res, return res); + + /* The encryption is done in-place, no need to encode again */ + UA_ByteString encryptBuf; + encryptBuf.data = encryptStart; + encryptBuf.length = (uintptr_t)sigStart - (uintptr_t)encryptStart; + res = policy->symmetricModule.cryptoModule.encryptionAlgorithm. + encrypt(policyContext, &encryptBuf); + UA_CHECK_STATUS(res, return res); + } + + /* Sign the entire message */ + if(securityMode == UA_MESSAGESECURITYMODE_SIGN || + securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + UA_ByteString sigBuf; + sigBuf.length = (uintptr_t)sigStart - (uintptr_t)messageStart; + sigBuf.data = messageStart; + size_t sigSize = policy->symmetricModule.cryptoModule. + signatureAlgorithm.getLocalSignatureSize(policyContext); + UA_ByteString sig = {sigSize, sigStart}; + res = policy->symmetricModule.cryptoModule. + signatureAlgorithm.sign(policyContext, &sigBuf, &sig); + } + + return res; +} +#endif + +UA_StatusCode +UA_DataSetMessageHeader_decodeBinary(const UA_ByteString *src, size_t *offset, + UA_DataSetMessageHeader* dst) { + memset(dst, 0, sizeof(UA_DataSetMessageHeader)); + UA_Byte v = 0; + UA_StatusCode rv = UA_Byte_decodeBinary(src, offset, &v); + UA_CHECK_STATUS(rv, return rv); + + UA_Byte v2 = v & DS_MESSAGEHEADER_FIELD_ENCODING_MASK; + v2 = (UA_Byte)(v2 >> DS_MH_SHIFT_LEN); + dst->fieldEncoding = (UA_FieldEncoding)v2; + + if((v & DS_MESSAGEHEADER_DS_MSG_VALID) != 0) + dst->dataSetMessageValid = true; + + if((v & DS_MESSAGEHEADER_SEQ_NR_ENABLED_MASK) != 0) + dst->dataSetMessageSequenceNrEnabled = true; + + if((v & DS_MESSAGEHEADER_STATUS_ENABLED_MASK) != 0) + dst->statusEnabled = true; + + if((v & DS_MESSAGEHEADER_CONFIGMAJORVERSION_ENABLED_MASK) != 0) + dst->configVersionMajorVersionEnabled = true; + + if((v & DS_MESSAGEHEADER_CONFIGMINORVERSION_ENABLED_MASK) != 0) + dst->configVersionMinorVersionEnabled = true; + + if((v & DS_MESSAGEHEADER_FLAGS2_ENABLED_MASK) != 0) { + v = 0; + rv = UA_Byte_decodeBinary(src, offset, &v); + UA_CHECK_STATUS(rv, return rv); + + dst->dataSetMessageType = (UA_DataSetMessageType)(v & DS_MESSAGEHEADER_DS_MESSAGE_TYPE_MASK); + + if((v & DS_MESSAGEHEADER_TIMESTAMP_ENABLED_MASK) != 0) + dst->timestampEnabled = true; + + if((v & DS_MESSAGEHEADER_PICOSECONDS_INCLUDED_MASK) != 0) + dst->picoSecondsIncluded = true; + } else { + dst->dataSetMessageType = UA_DATASETMESSAGE_DATAKEYFRAME; + dst->picoSecondsIncluded = false; + } + + if(dst->dataSetMessageSequenceNrEnabled) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->dataSetMessageSequenceNr); + UA_CHECK_STATUS(rv, return rv); + } else { + dst->dataSetMessageSequenceNr = 0; + } + + if(dst->timestampEnabled) { + rv = UA_DateTime_decodeBinary(src, offset, &dst->timestamp); /* UtcTime */ + UA_CHECK_STATUS(rv, return rv); + } else { + dst->timestamp = 0; + } + + if(dst->picoSecondsIncluded) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->picoSeconds); + UA_CHECK_STATUS(rv, return rv); + } else { + dst->picoSeconds = 0; + } + + if(dst->statusEnabled) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->status); + UA_CHECK_STATUS(rv, return rv); + } else { + dst->status = 0; + } + + if(dst->configVersionMajorVersionEnabled) { + rv = UA_UInt32_decodeBinary(src, offset, &dst->configVersionMajorVersion); + UA_CHECK_STATUS(rv, return rv); + } else { + dst->configVersionMajorVersion = 0; + } + + if(dst->configVersionMinorVersionEnabled) { + rv = UA_UInt32_decodeBinary(src, offset, &dst->configVersionMinorVersion); + UA_CHECK_STATUS(rv, return rv); + } else { + dst->configVersionMinorVersion = 0; + } + + return UA_STATUSCODE_GOOD; +} + +size_t +UA_DataSetMessageHeader_calcSizeBinary(const UA_DataSetMessageHeader* p) { + UA_Byte byte = 0; + size_t size = UA_Byte_calcSizeBinary(&byte); // DataSetMessage Type + Flags + if(UA_DataSetMessageHeader_DataSetFlags2Enabled(p)) + size += UA_Byte_calcSizeBinary(&byte); + + if(p->dataSetMessageSequenceNrEnabled) + size += UA_UInt16_calcSizeBinary(&p->dataSetMessageSequenceNr); + + if(p->timestampEnabled) + size += UA_DateTime_calcSizeBinary(&p->timestamp); /* UtcTime */ + + if(p->picoSecondsIncluded) + size += UA_UInt16_calcSizeBinary(&p->picoSeconds); + + if(p->statusEnabled) + size += UA_UInt16_calcSizeBinary(&p->status); + + if(p->configVersionMajorVersionEnabled) + size += UA_UInt32_calcSizeBinary(&p->configVersionMajorVersion); + + if(p->configVersionMinorVersionEnabled) + size += UA_UInt32_calcSizeBinary(&p->configVersionMinorVersion); + + return size; +} + +UA_StatusCode +UA_DataSetMessage_encodeBinary(const UA_DataSetMessage* src, UA_Byte **bufPos, + const UA_Byte *bufEnd) { + UA_StatusCode rv = UA_DataSetMessageHeader_encodeBinary(&src->header, bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + if(src->header.dataSetMessageType == UA_DATASETMESSAGE_DATAKEYFRAME) { + if(src->header.fieldEncoding != UA_FIELDENCODING_RAWDATA) { + rv = UA_UInt16_encodeBinary(&(src->data.keyFrameData.fieldCount), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + if(src->header.fieldEncoding == UA_FIELDENCODING_VARIANT) { + for (UA_UInt16 i = 0; i < src->data.keyFrameData.fieldCount; i++) { + rv = UA_Variant_encodeBinary(&(src->data.keyFrameData.dataSetFields[i].value), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + } else if(src->header.fieldEncoding == UA_FIELDENCODING_RAWDATA) { + for (UA_UInt16 i = 0; i < src->data.keyFrameData.fieldCount; i++) { + rv = UA_encodeBinaryInternal(src->data.keyFrameData.dataSetFields[i].value.data, + src->data.keyFrameData.dataSetFields[i].value.type, + bufPos, &bufEnd, NULL, NULL); + UA_CHECK_STATUS(rv, return rv); + } + } else if(src->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE) { + for (UA_UInt16 i = 0; i < src->data.keyFrameData.fieldCount; i++) { + rv = UA_DataValue_encodeBinary(&(src->data.keyFrameData.dataSetFields[i]), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + } + } else if(src->header.dataSetMessageType == UA_DATASETMESSAGE_DATADELTAFRAME) { + // Encode Delta Frame + // Here the FieldCount is always present + rv = UA_UInt16_encodeBinary(&(src->data.keyFrameData.fieldCount), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + if(src->header.fieldEncoding == UA_FIELDENCODING_VARIANT) { + for (UA_UInt16 i = 0; i < src->data.deltaFrameData.fieldCount; i++) { + rv = UA_UInt16_encodeBinary(&(src->data.deltaFrameData.deltaFrameFields[i].fieldIndex), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_Variant_encodeBinary(&(src->data.deltaFrameData.deltaFrameFields[i].fieldValue.value), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + } else if(src->header.fieldEncoding == UA_FIELDENCODING_RAWDATA) { + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } else if(src->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE) { + for (UA_UInt16 i = 0; i < src->data.deltaFrameData.fieldCount; i++) { + rv = UA_UInt16_encodeBinary(&(src->data.deltaFrameData.deltaFrameFields[i].fieldIndex), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_DataValue_encodeBinary(&(src->data.deltaFrameData.deltaFrameFields[i].fieldValue), bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + } + } + } else if(src->header.dataSetMessageType != UA_DATASETMESSAGE_KEEPALIVE) { + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + + /* Keep-Alive Message contains no Payload Data */ + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_DataSetMessage_decodeBinary(const UA_ByteString *src, size_t *offset, UA_DataSetMessage* dst, UA_UInt16 dsmSize) { + size_t initialOffset = *offset; + memset(dst, 0, sizeof(UA_DataSetMessage)); + UA_StatusCode rv = UA_DataSetMessageHeader_decodeBinary(src, offset, &dst->header); + UA_CHECK_STATUS(rv, return rv); + + if(dst->header.dataSetMessageType == UA_DATASETMESSAGE_DATAKEYFRAME) { + switch(dst->header.fieldEncoding) { + case UA_FIELDENCODING_VARIANT: + { + rv = UA_UInt16_decodeBinary(src, offset, &dst->data.keyFrameData.fieldCount); + UA_CHECK_STATUS(rv, return rv); + dst->data.keyFrameData.dataSetFields = + (UA_DataValue *)UA_Array_new(dst->data.keyFrameData.fieldCount, &UA_TYPES[UA_TYPES_DATAVALUE]); + for (UA_UInt16 i = 0; i < dst->data.keyFrameData.fieldCount; i++) { + UA_DataValue_init(&dst->data.keyFrameData.dataSetFields[i]); + rv = UA_Variant_decodeBinary(src, offset, &dst->data.keyFrameData.dataSetFields[i].value); + UA_CHECK_STATUS(rv, return rv); + + dst->data.keyFrameData.dataSetFields[i].hasValue = true; + } + break; + } + case UA_FIELDENCODING_DATAVALUE: + { + rv = UA_UInt16_decodeBinary(src, offset, &dst->data.keyFrameData.fieldCount); + UA_CHECK_STATUS(rv, return rv); + dst->data.keyFrameData.dataSetFields = + (UA_DataValue *)UA_Array_new(dst->data.keyFrameData.fieldCount, &UA_TYPES[UA_TYPES_DATAVALUE]); + for (UA_UInt16 i = 0; i < dst->data.keyFrameData.fieldCount; i++) { + rv = UA_DataValue_decodeBinary(src, offset, &(dst->data.keyFrameData.dataSetFields[i])); + UA_CHECK_STATUS(rv, return rv); + } + break; + } + case UA_FIELDENCODING_RAWDATA: + { + dst->data.keyFrameData.rawFields.data = &src->data[*offset]; + dst->data.keyFrameData.rawFields.length = dsmSize; + if(dsmSize == 0){ + //TODO calculate the length of the DSM-Payload for a single DSM + //Problem: Size is not set and MetaData information are needed. + //Increase offset to avoid endless chunk loop. Needs to be fixed when + //pubsub security footer and signatur is enabled. + *offset += 1500; + } else { + *offset += (dsmSize - (*offset - initialOffset)); + } + break; + } + default: + return UA_STATUSCODE_BADINTERNALERROR; + } + } else if(dst->header.dataSetMessageType == UA_DATASETMESSAGE_DATADELTAFRAME) { + switch(dst->header.fieldEncoding) { + case UA_FIELDENCODING_VARIANT: { + rv = UA_UInt16_decodeBinary(src, offset, &dst->data.deltaFrameData.fieldCount); + UA_CHECK_STATUS(rv, return rv); + size_t memsize = sizeof(UA_DataSetMessage_DeltaFrameField) * dst->data.deltaFrameData.fieldCount; + dst->data.deltaFrameData.deltaFrameFields = (UA_DataSetMessage_DeltaFrameField*)UA_malloc(memsize); + for (UA_UInt16 i = 0; i < dst->data.deltaFrameData.fieldCount; i++) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->data.deltaFrameData.deltaFrameFields[i].fieldIndex); + UA_CHECK_STATUS(rv, return rv); + + UA_DataValue_init(&dst->data.deltaFrameData.deltaFrameFields[i].fieldValue); + rv = UA_Variant_decodeBinary(src, offset, &dst->data.deltaFrameData.deltaFrameFields[i].fieldValue.value); + UA_CHECK_STATUS(rv, return rv); + + dst->data.deltaFrameData.deltaFrameFields[i].fieldValue.hasValue = true; + } + break; + } + case UA_FIELDENCODING_DATAVALUE: { + rv = UA_UInt16_decodeBinary(src, offset, &dst->data.deltaFrameData.fieldCount); + UA_CHECK_STATUS(rv, return rv); + size_t memsize = sizeof(UA_DataSetMessage_DeltaFrameField) * dst->data.deltaFrameData.fieldCount; + dst->data.deltaFrameData.deltaFrameFields = (UA_DataSetMessage_DeltaFrameField*)UA_malloc(memsize); + for (UA_UInt16 i = 0; i < dst->data.deltaFrameData.fieldCount; i++) { + rv = UA_UInt16_decodeBinary(src, offset, &dst->data.deltaFrameData.deltaFrameFields[i].fieldIndex); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_DataValue_decodeBinary(src, offset, &(dst->data.deltaFrameData.deltaFrameFields[i].fieldValue)); + UA_CHECK_STATUS(rv, return rv); + } + break; + } + case UA_FIELDENCODING_RAWDATA: { + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + default: + return UA_STATUSCODE_BADINTERNALERROR; + } + } else if(dst->header.dataSetMessageType != UA_DATASETMESSAGE_KEEPALIVE) { + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + + /* Keep-Alive Message contains no Payload Data */ + return UA_STATUSCODE_GOOD; +} + +size_t +UA_DataSetMessage_calcSizeBinary(UA_DataSetMessage* p, UA_NetworkMessageOffsetBuffer *offsetBuffer, size_t currentOffset) { + size_t size = currentOffset; + if (offsetBuffer) { + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].offsetData.value.value = UA_DataValue_new(); + UA_DataValue_init(offsetBuffer->offsets[pos].offsetData.value.value); + UA_Variant_setScalar(&offsetBuffer->offsets[pos].offsetData.value.value->value, + &p->header.fieldEncoding, &UA_TYPES[UA_TYPES_UINT32]); + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_FIELDENCDODING; + } + UA_Byte byte = 0; + size += UA_Byte_calcSizeBinary(&byte); // DataSetMessage Type + Flags + if(UA_DataSetMessageHeader_DataSetFlags2Enabled(&p->header)) + size += UA_Byte_calcSizeBinary(&byte); + + if(p->header.dataSetMessageSequenceNrEnabled) { + if (offsetBuffer) { + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].offsetData.value.value = UA_DataValue_new(); + UA_DataValue_init(offsetBuffer->offsets[pos].offsetData.value.value); + UA_Variant_setScalar(&offsetBuffer->offsets[pos].offsetData.value.value->value, + &p->header.dataSetMessageSequenceNr, &UA_TYPES[UA_TYPES_UINT16]); + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_DATASETMESSAGE_SEQUENCENUMBER; + } + size += UA_UInt16_calcSizeBinary(&p->header.dataSetMessageSequenceNr); + } + + if(p->header.timestampEnabled) + size += UA_DateTime_calcSizeBinary(&p->header.timestamp); /* UtcTime */ + + if(p->header.picoSecondsIncluded) + size += UA_UInt16_calcSizeBinary(&p->header.picoSeconds); + + if(p->header.statusEnabled) + size += UA_UInt16_calcSizeBinary(&p->header.status); + + if(p->header.configVersionMajorVersionEnabled) + size += UA_UInt32_calcSizeBinary(&p->header.configVersionMajorVersion); + + if(p->header.configVersionMinorVersionEnabled) + size += UA_UInt32_calcSizeBinary(&p->header.configVersionMinorVersion); + + if(p->header.dataSetMessageType == UA_DATASETMESSAGE_DATAKEYFRAME) { + if(p->header.fieldEncoding != UA_FIELDENCODING_RAWDATA){ + size += UA_calcSizeBinary(&p->data.keyFrameData.fieldCount, &UA_TYPES[UA_TYPES_UINT16]); + } + if(p->header.fieldEncoding == UA_FIELDENCODING_VARIANT) { + for (UA_UInt16 i = 0; i < p->data.keyFrameData.fieldCount; i++){ + if (offsetBuffer) { + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_PAYLOAD_VARIANT; + //TODO check value source and alloc! + //offsetBuffer->offsets[pos].offsetData.value.value = p->data.keyFrameData.dataSetFields; + offsetBuffer->offsets[pos].offsetData.value.value = UA_DataValue_new(); + UA_Variant_setScalar(&offsetBuffer->offsets[pos].offsetData.value.value->value, + p->data.keyFrameData.dataSetFields[i].value.data, + p->data.keyFrameData.dataSetFields[i].value.type); + offsetBuffer->offsets[pos].offsetData.value.value->value.storageType = UA_VARIANT_DATA_NODELETE; + } + size += UA_calcSizeBinary(&p->data.keyFrameData.dataSetFields[i].value, &UA_TYPES[UA_TYPES_VARIANT]); + } + } else if(p->header.fieldEncoding == UA_FIELDENCODING_RAWDATA) { + for (UA_UInt16 i = 0; i < p->data.keyFrameData.fieldCount; i++){ + if (offsetBuffer) { + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW; + offsetBuffer->offsets[pos].offsetData.value.value = UA_DataValue_new(); + //init offset buffer with the latest value + UA_Variant_setScalar(&offsetBuffer->offsets[pos].offsetData.value.value->value, + p->data.keyFrameData.dataSetFields[i].value.data, + p->data.keyFrameData.dataSetFields[i].value.type); + offsetBuffer->offsets[pos].offsetData.value.value->value.storageType = UA_VARIANT_DATA_NODELETE; + //count the memory size of the specific field + offsetBuffer->rawMessageLength += p->data.keyFrameData.dataSetFields[i].value.type->memSize; + } + size += UA_calcSizeBinary(p->data.keyFrameData.dataSetFields[i].value.data, + p->data.keyFrameData.dataSetFields[i].value.type); + } + } else if(p->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE) { + for (UA_UInt16 i = 0; i < p->data.keyFrameData.fieldCount; i++) { + if (offsetBuffer) { + size_t pos = offsetBuffer->offsetsSize; + if(!increaseOffsetArray(offsetBuffer)) + return 0; + offsetBuffer->offsets[pos].offset = size; + offsetBuffer->offsets[pos].contentType = UA_PUBSUB_OFFSETTYPE_PAYLOAD_DATAVALUE; + //TODO check value source, change implementation to 'variant' + offsetBuffer->offsets[pos].offsetData.value.value = p->data.keyFrameData.dataSetFields; + } + size += UA_calcSizeBinary(&p->data.keyFrameData.dataSetFields[i], &UA_TYPES[UA_TYPES_DATAVALUE]); + } + } + } else if(p->header.dataSetMessageType == UA_DATASETMESSAGE_DATADELTAFRAME) { + //TODO clarify how to handle DATADELTAFRAME messages with RT + if(p->header.fieldEncoding != UA_FIELDENCODING_RAWDATA) + size += UA_calcSizeBinary(&p->data.deltaFrameData.fieldCount, &UA_TYPES[UA_TYPES_UINT16]); + + if(p->header.fieldEncoding == UA_FIELDENCODING_VARIANT) { + for (UA_UInt16 i = 0; i < p->data.deltaFrameData.fieldCount; i++) { + size += UA_calcSizeBinary(&p->data.deltaFrameData.deltaFrameFields[i].fieldIndex, &UA_TYPES[UA_TYPES_UINT16]); + size += UA_calcSizeBinary(&p->data.deltaFrameData.deltaFrameFields[i].fieldValue.value, &UA_TYPES[UA_TYPES_VARIANT]); + } + } else if(p->header.fieldEncoding == UA_FIELDENCODING_RAWDATA) { + // not implemented + } else if(p->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE) { + for (UA_UInt16 i = 0; i < p->data.deltaFrameData.fieldCount; i++) { + size += UA_calcSizeBinary(&p->data.deltaFrameData.deltaFrameFields[i].fieldIndex, &UA_TYPES[UA_TYPES_UINT16]); + size += UA_calcSizeBinary(&p->data.deltaFrameData.deltaFrameFields[i].fieldValue, &UA_TYPES[UA_TYPES_DATAVALUE]); + } + } + } + /* KeepAlive-Message contains no Payload Data */ + return size; +} + +void +UA_DataSetMessage_clear(const UA_DataSetMessage* p) { + if(p->header.dataSetMessageType == UA_DATASETMESSAGE_DATAKEYFRAME) { + if(p->data.keyFrameData.dataSetFields != NULL) { + UA_Array_delete(p->data.keyFrameData.dataSetFields, + p->data.keyFrameData.fieldCount, + &UA_TYPES[UA_TYPES_DATAVALUE]); + } + + /* Json keys */ + if(p->data.keyFrameData.fieldNames != NULL){ + UA_Array_delete(p->data.keyFrameData.fieldNames, + p->data.keyFrameData.fieldCount, + &UA_TYPES[UA_TYPES_STRING]); + } + } else if(p->header.dataSetMessageType == UA_DATASETMESSAGE_DATADELTAFRAME) { + if(p->data.deltaFrameData.deltaFrameFields != NULL) { + for(UA_UInt16 i = 0; i < p->data.deltaFrameData.fieldCount; i++) { + if(p->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE) { + UA_DataValue_clear(&p->data.deltaFrameData.deltaFrameFields[i].fieldValue); + } else if(p->header.fieldEncoding == UA_FIELDENCODING_VARIANT) { + UA_Variant_clear(&p->data.deltaFrameData.deltaFrameFields[i].fieldValue.value); + } + } + UA_free(p->data.deltaFrameData.deltaFrameFields); + } + } +} +#endif /* UA_ENABLE_PUBSUB */ + +/**** amalgamated original file "/src/pubsub/ua_pubsub_writer.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2019 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019 Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright (c) 2019-2021 Kalycito Infotech Private Limited + * Copyright (c) 2020 Yannick Wallerer, Siemens AG + * Copyright (c) 2020 Thomas Fischer, Siemens AG + * Copyright (c) 2021 Fraunhofer IOSB (Author: Jan Hermes) + */ + + +#ifdef UA_ENABLE_PUBSUB /* conditional compilation */ + + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL +#endif + +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES +#endif + +/* Forward declaration */ +static void +UA_DataSetField_clear(UA_DataSetField *field); + +/**********************************************/ +/* Connection */ +/**********************************************/ + +UA_StatusCode +UA_PubSubConnectionConfig_copy(const UA_PubSubConnectionConfig *src, + UA_PubSubConnectionConfig *dst) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + memcpy(dst, src, sizeof(UA_PubSubConnectionConfig)); + res |= UA_String_copy(&src->name, &dst->name); + res |= UA_Variant_copy(&src->address, &dst->address); + res |= UA_String_copy(&src->transportProfileUri, &dst->transportProfileUri); + res |= UA_Variant_copy(&src->connectionTransportSettings, + &dst->connectionTransportSettings); + if(src->connectionPropertiesSize > 0) { + dst->connectionProperties = (UA_KeyValuePair *) + UA_calloc(src->connectionPropertiesSize, sizeof(UA_KeyValuePair)); + if(!dst->connectionProperties) { + UA_PubSubConnectionConfig_clear(dst); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + for(size_t i = 0; i < src->connectionPropertiesSize; i++){ + res |= UA_QualifiedName_copy(&src->connectionProperties[i].key, + &dst->connectionProperties[i].key); + res |= UA_Variant_copy(&src->connectionProperties[i].value, + &dst->connectionProperties[i].value); + } + } + if(res != UA_STATUSCODE_GOOD) + UA_PubSubConnectionConfig_clear(dst); + return res; +} + +UA_StatusCode +UA_Server_getPubSubConnectionConfig(UA_Server *server, const UA_NodeId connection, + UA_PubSubConnectionConfig *config) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_PubSubConnection *currentPubSubConnection = + UA_PubSubConnection_findConnectionbyId(server, connection); + if(!currentPubSubConnection) + return UA_STATUSCODE_BADNOTFOUND; + return UA_PubSubConnectionConfig_copy(currentPubSubConnection->config, config); +} + +UA_PubSubConnection * +UA_PubSubConnection_findConnectionbyId(UA_Server *server, UA_NodeId connectionIdentifier) { + UA_PubSubConnection *pubSubConnection; + TAILQ_FOREACH(pubSubConnection, &server->pubSubManager.connections, listEntry){ + if(UA_NodeId_equal(&connectionIdentifier, &pubSubConnection->identifier)) + break; + } + return pubSubConnection; +} + +void +UA_PubSubConnectionConfig_clear(UA_PubSubConnectionConfig *connectionConfig) { + UA_String_clear(&connectionConfig->name); + UA_String_clear(&connectionConfig->transportProfileUri); + UA_Variant_clear(&connectionConfig->connectionTransportSettings); + UA_Variant_clear(&connectionConfig->address); + for(size_t i = 0; i < connectionConfig->connectionPropertiesSize; i++){ + UA_QualifiedName_clear(&connectionConfig->connectionProperties[i].key); + UA_Variant_clear(&connectionConfig->connectionProperties[i].value); + } + UA_free(connectionConfig->connectionProperties); +} + +void +UA_PubSubConnection_clear(UA_Server *server, UA_PubSubConnection *connection) { + /* Remove WriterGroups */ + UA_WriterGroup *writerGroup, *tmpWriterGroup; + LIST_FOREACH_SAFE(writerGroup, &connection->writerGroups, listEntry, tmpWriterGroup) + UA_Server_removeWriterGroup(server, writerGroup->identifier); + + /* Remove ReaderGroups */ + UA_ReaderGroup *readerGroups, *tmpReaderGroup; + LIST_FOREACH_SAFE(readerGroups, &connection->readerGroups, listEntry, tmpReaderGroup) + UA_Server_removeReaderGroup(server, readerGroups->identifier); + + UA_NodeId_clear(&connection->identifier); + if(connection->channel) + connection->channel->ua_close(connection->channel); + + UA_PubSubConnectionConfig_clear(connection->config); + UA_free(connection->config); +} + +/**********************************************/ +/* PublishedDataSet */ +/**********************************************/ + +UA_StatusCode +UA_PublishedDataSetConfig_copy(const UA_PublishedDataSetConfig *src, + UA_PublishedDataSetConfig *dst) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + memcpy(dst, src, sizeof(UA_PublishedDataSetConfig)); + res |= UA_String_copy(&src->name, &dst->name); + switch(src->publishedDataSetType) { + case UA_PUBSUB_DATASET_PUBLISHEDITEMS: + //no additional items + break; + + case UA_PUBSUB_DATASET_PUBLISHEDITEMS_TEMPLATE: + if(src->config.itemsTemplate.variablesToAddSize > 0) { + dst->config.itemsTemplate.variablesToAdd = (UA_PublishedVariableDataType *) + UA_calloc(src->config.itemsTemplate.variablesToAddSize, + sizeof(UA_PublishedVariableDataType)); + if(!dst->config.itemsTemplate.variablesToAdd) { + res = UA_STATUSCODE_BADOUTOFMEMORY; + break; + } + dst->config.itemsTemplate.variablesToAddSize = + src->config.itemsTemplate.variablesToAddSize; + } + + for(size_t i = 0; i < src->config.itemsTemplate.variablesToAddSize; i++) { + res |= UA_PublishedVariableDataType_copy(&src->config.itemsTemplate.variablesToAdd[i], + &dst->config.itemsTemplate.variablesToAdd[i]); + } + res |= UA_DataSetMetaDataType_copy(&src->config.itemsTemplate.metaData, + &dst->config.itemsTemplate.metaData); + break; + + default: + res = UA_STATUSCODE_BADINVALIDARGUMENT; + break; + } + + if(res != UA_STATUSCODE_GOOD) + UA_PublishedDataSetConfig_clear(dst); + return res; +} + +UA_StatusCode +UA_Server_getPublishedDataSetConfig(UA_Server *server, const UA_NodeId pds, + UA_PublishedDataSetConfig *config) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_PublishedDataSet *currentPDS = UA_PublishedDataSet_findPDSbyId(server, pds); + if(!currentPDS) + return UA_STATUSCODE_BADNOTFOUND; + return UA_PublishedDataSetConfig_copy(¤tPDS->config, config); +} + +UA_StatusCode +UA_Server_getPublishedDataSetMetaData(UA_Server *server, const UA_NodeId pds, + UA_DataSetMetaDataType *metaData) { + if(!metaData) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_PublishedDataSet *currentPDS = UA_PublishedDataSet_findPDSbyId(server, pds); + if(!currentPDS) + return UA_STATUSCODE_BADNOTFOUND; + return UA_DataSetMetaDataType_copy(¤tPDS->dataSetMetaData, metaData); +} + +UA_PublishedDataSet * +UA_PublishedDataSet_findPDSbyId(UA_Server *server, UA_NodeId identifier) { + UA_PublishedDataSet *tmpPDS = NULL; + TAILQ_FOREACH(tmpPDS, &server->pubSubManager.publishedDataSets, listEntry) { + if(UA_NodeId_equal(&tmpPDS->identifier, &identifier)) + break; + } + return tmpPDS; +} + +void +UA_PublishedDataSetConfig_clear(UA_PublishedDataSetConfig *pdsConfig) { + //delete pds config + UA_String_clear(&pdsConfig->name); + switch (pdsConfig->publishedDataSetType){ + case UA_PUBSUB_DATASET_PUBLISHEDITEMS: + //no additional items + break; + case UA_PUBSUB_DATASET_PUBLISHEDITEMS_TEMPLATE: + if(pdsConfig->config.itemsTemplate.variablesToAddSize > 0){ + for(size_t i = 0; i < pdsConfig->config.itemsTemplate.variablesToAddSize; i++){ + UA_PublishedVariableDataType_clear(&pdsConfig->config.itemsTemplate.variablesToAdd[i]); + } + UA_free(pdsConfig->config.itemsTemplate.variablesToAdd); + } + UA_DataSetMetaDataType_clear(&pdsConfig->config.itemsTemplate.metaData); + break; + default: + break; + } +} + +void +UA_PublishedDataSet_clear(UA_Server *server, UA_PublishedDataSet *publishedDataSet) { + UA_DataSetField *field, *tmpField; + TAILQ_FOREACH_SAFE(field, &publishedDataSet->fields, listEntry, tmpField) { + UA_Server_removeDataSetField(server, field->identifier); + } + UA_PublishedDataSetConfig_clear(&publishedDataSet->config); + UA_DataSetMetaDataType_clear(&publishedDataSet->dataSetMetaData); + UA_NodeId_clear(&publishedDataSet->identifier); +} + +/* The fieldMetaData variable has to be cleaned up external in case of an error */ +static UA_StatusCode +generateFieldMetaData(UA_Server *server, UA_DataSetField *field, + UA_FieldMetaData *fieldMetaData) { + if(field->config.dataSetFieldType != UA_PUBSUB_DATASETFIELD_VARIABLE) + return UA_STATUSCODE_BADNOTSUPPORTED; + + /* Set the field identifier */ + fieldMetaData->dataSetFieldId = UA_PubSubManager_generateUniqueGuid(server); + + /* Set the description */ + fieldMetaData->description = UA_LOCALIZEDTEXT_ALLOC("", ""); + + /* Set the name */ + const UA_DataSetVariableConfig *var = &field->config.field.variable; + UA_StatusCode res = UA_String_copy(&var->fieldNameAlias, &fieldMetaData->name); + UA_CHECK_STATUS(res, return res); + + /* Static value source. ToDo after freeze PR, the value source must be + * checked (other behavior for static value source) */ + if(var->rtValueSource.rtFieldSourceEnabled && + !var->rtValueSource.rtInformationModelNode) { + const UA_DataValue *svs = *var->rtValueSource.staticValueSource; + if(svs->value.arrayDimensionsSize > 0) { + fieldMetaData->arrayDimensions = (UA_UInt32 *) + UA_calloc(svs->value.arrayDimensionsSize, sizeof(UA_UInt32)); + if(fieldMetaData->arrayDimensions == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + memcpy(fieldMetaData->arrayDimensions, svs->value.arrayDimensions, + sizeof(UA_UInt32) * svs->value.arrayDimensionsSize); + } + fieldMetaData->arrayDimensionsSize = svs->value.arrayDimensionsSize; + + res = UA_NodeId_copy(&svs->value.type->typeId, &fieldMetaData->dataType); + UA_CHECK_STATUS(res, return res); + + //TODO collect value rank for the static field source + fieldMetaData->properties = NULL; + fieldMetaData->propertiesSize = 0; + fieldMetaData->fieldFlags = UA_DATASETFIELDFLAGS_NONE; + return UA_STATUSCODE_GOOD; + } + + /* Set the Array Dimensions */ + const UA_PublishedVariableDataType *pp = &var->publishParameters; + UA_Variant value; + UA_Variant_init(&value); + res = UA_Server_readArrayDimensions(server, pp->publishedVariable, &value); + UA_CHECK_STATUS_LOG(res, return res, + WARNING, &server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub meta data generation. Reading the array dimensions failed."); + + if(value.arrayDimensionsSize > 0) { + fieldMetaData->arrayDimensions = (UA_UInt32 *) + UA_calloc(value.arrayDimensionsSize, sizeof(UA_UInt32)); + if(!fieldMetaData->arrayDimensions) + return UA_STATUSCODE_BADOUTOFMEMORY; + memcpy(fieldMetaData->arrayDimensions, value.arrayDimensions, + sizeof(UA_UInt32)*value.arrayDimensionsSize); + } + fieldMetaData->arrayDimensionsSize = value.arrayDimensionsSize; + + /* Set the DataType */ + res = UA_Server_readDataType(server, pp->publishedVariable, + &fieldMetaData->dataType); + UA_CHECK_STATUS_LOG(res, return res, + WARNING, &server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub meta data generation. Reading the datatype failed."); + + if(!UA_NodeId_isNull(&fieldMetaData->dataType)) { + const UA_DataType *currentDataType = + UA_findDataTypeWithCustom(&fieldMetaData->dataType, + server->config.customDataTypes); +#ifdef UA_ENABLE_TYPEDESCRIPTION + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "MetaData creation. Found DataType %s.", currentDataType->typeName); +#endif + /* Check if the datatype is a builtInType, if yes set the builtinType. + * TODO: Remove the magic number */ + if(currentDataType->typeKind <= UA_DATATYPEKIND_ENUM) + fieldMetaData->builtInType = (UA_Byte)currentDataType->typeKind; + } else { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub meta data generation. DataType is UA_NODEID_NULL."); + } + + /* Set the ValueRank */ + UA_Int32 valueRank; + res = UA_Server_readValueRank(server, pp->publishedVariable, &valueRank); + UA_CHECK_STATUS_LOG(res, return res, + WARNING, &server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub meta data generation. Reading the value rank failed."); + fieldMetaData->valueRank = valueRank; + + /* PromotedField? */ + if(var->promotedField) + fieldMetaData->fieldFlags = UA_DATASETFIELDFLAGS_PROMOTEDFIELD; + else + fieldMetaData->fieldFlags = UA_DATASETFIELDFLAGS_NONE; + + /* Properties */ + fieldMetaData->properties = NULL; + fieldMetaData->propertiesSize = 0; + + //TODO collect the following fields*/ + //fieldMetaData.builtInType + //fieldMetaData.maxStringLength + + return UA_STATUSCODE_GOOD; +} + +UA_DataSetFieldResult +UA_Server_addDataSetField(UA_Server *server, const UA_NodeId publishedDataSet, + const UA_DataSetFieldConfig *fieldConfig, + UA_NodeId *fieldIdentifier) { + UA_DataSetFieldResult result = {0}; + if(!fieldConfig) { + result.result = UA_STATUSCODE_BADINVALIDARGUMENT; + return result; + } + + UA_PublishedDataSet *currDS = + UA_PublishedDataSet_findPDSbyId(server, publishedDataSet); + if(!currDS) { + result.result = UA_STATUSCODE_BADNOTFOUND; + return result; + } + + if(currDS->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Adding DataSetField failed. PublishedDataSet is frozen."); + result.result = UA_STATUSCODE_BADCONFIGURATIONERROR; + return result; + } + + if(currDS->config.publishedDataSetType != UA_PUBSUB_DATASET_PUBLISHEDITEMS) { + result.result = UA_STATUSCODE_BADNOTIMPLEMENTED; + return result; + } + + UA_DataSetField *newField = (UA_DataSetField*)UA_calloc(1, sizeof(UA_DataSetField)); + if(!newField) { + result.result = UA_STATUSCODE_BADINTERNALERROR; + return result; + } + + UA_StatusCode retVal = UA_DataSetFieldConfig_copy(fieldConfig, &newField->config); + if(retVal != UA_STATUSCODE_GOOD) { + UA_free(newField); + result.result = retVal; + return result; + } + + newField->publishedDataSet = currDS->identifier; + + /* Initialize the field metadata. Also generates a FieldId */ + UA_FieldMetaData fmd; + UA_FieldMetaData_init(&fmd); + result.result = generateFieldMetaData(server, newField, &fmd); + if(result.result != UA_STATUSCODE_GOOD) { + UA_FieldMetaData_clear(&fmd); + UA_DataSetFieldConfig_clear(&newField->config); + UA_free(newField); + return result; + } + + /* Append to the metadata fields array. Point of last return. */ + result.result = UA_Array_append((void**)&currDS->dataSetMetaData.fields, + &currDS->dataSetMetaData.fieldsSize, + &fmd, &UA_TYPES[UA_TYPES_FIELDMETADATA]); + if(result.result != UA_STATUSCODE_GOOD) { + UA_FieldMetaData_clear(&fmd); + UA_DataSetFieldConfig_clear(&newField->config); + UA_free(newField); + return result; + } + + /* Copy the identifier from the metadata. Cannot fail with a guid NodeId. */ + newField->identifier = UA_NODEID_GUID(1, fmd.dataSetFieldId); + if(fieldIdentifier) + UA_NodeId_copy(&newField->identifier, fieldIdentifier); + + /* Register the field. The order of DataSetFields should be the same in both + * creating and publishing. So adding DataSetFields at the the end of the + * DataSets using the TAILQ structure. */ + TAILQ_INSERT_TAIL(&currDS->fields, newField, listEntry); + currDS->fieldSize++; + + if(newField->config.field.variable.promotedField) + currDS->promotedFieldsCount++; + + /* The values of the metadata are "borrowed" in a mirrored structure in the + * pds. Reset them after resizing the array. */ + size_t counter = 0; + UA_DataSetField *dsf; + TAILQ_FOREACH(dsf, &currDS->fields, listEntry) { + dsf->fieldMetaData = currDS->dataSetMetaData.fields[counter++]; + } + + /* Update major version of parent published data set */ + currDS->dataSetMetaData.configurationVersion.majorVersion = + UA_PubSubConfigurationVersionTimeDifference(); + + result.configurationVersion.majorVersion = + currDS->dataSetMetaData.configurationVersion.majorVersion; + result.configurationVersion.minorVersion = + currDS->dataSetMetaData.configurationVersion.minorVersion; + return result; +} + +UA_DataSetFieldResult +UA_Server_removeDataSetField(UA_Server *server, const UA_NodeId dsf) { + UA_DataSetFieldResult result = {0}; + + UA_DataSetField *currentField = UA_DataSetField_findDSFbyId(server, dsf); + if(!currentField) { + result.result = UA_STATUSCODE_BADNOTFOUND; + return result; + } + + if(currentField->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove DataSetField failed. DataSetField is frozen."); + result.result = UA_STATUSCODE_BADCONFIGURATIONERROR; + return result; + } + + UA_PublishedDataSet *pds = + UA_PublishedDataSet_findPDSbyId(server, currentField->publishedDataSet); + if(!pds) { + result.result = UA_STATUSCODE_BADNOTFOUND; + return result; + } + + if(pds->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove DataSetField failed. PublishedDataSet is frozen."); + result.result = UA_STATUSCODE_BADCONFIGURATIONERROR; + return result; + } + + /* Reduce the counters before the config is cleaned up */ + if(currentField->config.field.variable.promotedField) + pds->promotedFieldsCount--; + pds->fieldSize--; + + /* Update major version of PublishedDataSet */ + pds->dataSetMetaData.configurationVersion.majorVersion = + UA_PubSubConfigurationVersionTimeDifference(); + + /* Clean up */ + currentField->fieldMetaData.arrayDimensions = NULL; + currentField->fieldMetaData.properties = NULL; + currentField->fieldMetaData.name = UA_STRING_NULL; + currentField->fieldMetaData.description.locale = UA_STRING_NULL; + currentField->fieldMetaData.description.text = UA_STRING_NULL; + UA_DataSetField_clear(currentField); + + /* Remove */ + TAILQ_REMOVE(&pds->fields, currentField, listEntry); + UA_free(currentField); + + /* Regenerate DataSetMetaData */ + pds->dataSetMetaData.fieldsSize--; + if(pds->dataSetMetaData.fieldsSize > 0) { + for(size_t i = 0; i < pds->dataSetMetaData.fieldsSize+1; i++) { + UA_FieldMetaData_clear(&pds->dataSetMetaData.fields[i]); + } + UA_free(pds->dataSetMetaData.fields); + UA_FieldMetaData *fieldMetaData = (UA_FieldMetaData *) + UA_calloc(pds->dataSetMetaData.fieldsSize, sizeof(UA_FieldMetaData)); + if(!fieldMetaData) { + result.result = UA_STATUSCODE_BADOUTOFMEMORY; + return result; + } + UA_DataSetField *tmpDSF; + size_t counter = 0; + TAILQ_FOREACH(tmpDSF, &pds->fields, listEntry){ + result.result = generateFieldMetaData(server, tmpDSF, &fieldMetaData[counter]); + if(result.result != UA_STATUSCODE_GOOD) { + UA_FieldMetaData_clear(&fieldMetaData[counter]); + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub MetaData generation failed!"); + break; + } + counter++; + } + pds->dataSetMetaData.fields = fieldMetaData; + } else { + UA_FieldMetaData_delete(pds->dataSetMetaData.fields); + pds->dataSetMetaData.fields = NULL; + } + + result.configurationVersion.majorVersion = + pds->dataSetMetaData.configurationVersion.majorVersion; + result.configurationVersion.minorVersion = + pds->dataSetMetaData.configurationVersion.minorVersion; + return result; +} + +/**********************************************/ +/* DataSetWriter */ +/**********************************************/ + +UA_StatusCode +UA_DataSetWriterConfig_copy(const UA_DataSetWriterConfig *src, + UA_DataSetWriterConfig *dst){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + memcpy(dst, src, sizeof(UA_DataSetWriterConfig)); + retVal |= UA_String_copy(&src->name, &dst->name); + retVal |= UA_String_copy(&src->dataSetName, &dst->dataSetName); + retVal |= UA_ExtensionObject_copy(&src->messageSettings, &dst->messageSettings); + if(src->dataSetWriterPropertiesSize > 0) { + dst->dataSetWriterProperties = (UA_KeyValuePair *) + UA_calloc(src->dataSetWriterPropertiesSize, sizeof(UA_KeyValuePair)); + if(!dst->dataSetWriterProperties) + return UA_STATUSCODE_BADOUTOFMEMORY; + for(size_t i = 0; i < src->dataSetWriterPropertiesSize; i++){ + retVal |= UA_KeyValuePair_copy(&src->dataSetWriterProperties[i], + &dst->dataSetWriterProperties[i]); + } + } + return retVal; +} + +UA_StatusCode +UA_Server_getDataSetWriterConfig(UA_Server *server, const UA_NodeId dsw, + UA_DataSetWriterConfig *config) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_DataSetWriter *currentDataSetWriter = UA_DataSetWriter_findDSWbyId(server, dsw); + if(!currentDataSetWriter) + return UA_STATUSCODE_BADNOTFOUND; + return UA_DataSetWriterConfig_copy(¤tDataSetWriter->config, config); +} + +UA_StatusCode +UA_Server_DataSetWriter_getState(UA_Server *server, UA_NodeId dataSetWriterIdentifier, + UA_PubSubState *state) { + if((server == NULL) || (state == NULL)) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_DataSetWriter *currentDataSetWriter = + UA_DataSetWriter_findDSWbyId(server, dataSetWriterIdentifier); + if(currentDataSetWriter == NULL) + return UA_STATUSCODE_BADNOTFOUND; + *state = currentDataSetWriter->state; + return UA_STATUSCODE_GOOD; +} + +UA_DataSetWriter * +UA_DataSetWriter_findDSWbyId(UA_Server *server, UA_NodeId identifier) { + UA_PubSubConnection *pubSubConnection; + TAILQ_FOREACH(pubSubConnection, &server->pubSubManager.connections, listEntry){ + UA_WriterGroup *tmpWriterGroup; + LIST_FOREACH(tmpWriterGroup, &pubSubConnection->writerGroups, listEntry){ + UA_DataSetWriter *tmpWriter; + LIST_FOREACH(tmpWriter, &tmpWriterGroup->writers, listEntry){ + if(UA_NodeId_equal(&tmpWriter->identifier, &identifier)){ + return tmpWriter; + } + } + } + } + return NULL; +} + +void +UA_DataSetWriterConfig_clear(UA_DataSetWriterConfig *pdsConfig) { + UA_String_clear(&pdsConfig->name); + UA_String_clear(&pdsConfig->dataSetName); + for(size_t i = 0; i < pdsConfig->dataSetWriterPropertiesSize; i++) { + UA_KeyValuePair_clear(&pdsConfig->dataSetWriterProperties[i]); + } + UA_free(pdsConfig->dataSetWriterProperties); + UA_ExtensionObject_clear(&pdsConfig->messageSettings); +} + +static void +UA_DataSetWriter_clear(UA_Server *server, UA_DataSetWriter *dataSetWriter) { + UA_DataSetWriterConfig_clear(&dataSetWriter->config); + UA_NodeId_clear(&dataSetWriter->identifier); + UA_NodeId_clear(&dataSetWriter->linkedWriterGroup); + UA_NodeId_clear(&dataSetWriter->connectedDataSet); + + /* Delete lastSamples store */ +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES + for(size_t i = 0; i < dataSetWriter->lastSamplesCount; i++) { + UA_DataValue_clear(&dataSetWriter->lastSamples[i].value); + } + UA_free(dataSetWriter->lastSamples); + dataSetWriter->lastSamples = NULL; + dataSetWriter->lastSamplesCount = 0; +#endif +} + +//state machine methods not part of the open62541 state machine API +UA_StatusCode +UA_DataSetWriter_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_DataSetWriter *dataSetWriter) { + switch(state){ + case UA_PUBSUBSTATE_DISABLED: + switch (dataSetWriter->state){ + case UA_PUBSUBSTATE_DISABLED: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_PAUSED: + dataSetWriter->state = UA_PUBSUBSTATE_DISABLED; + //no further action is required + break; + case UA_PUBSUBSTATE_OPERATIONAL: + dataSetWriter->state = UA_PUBSUBSTATE_DISABLED; + break; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + break; + case UA_PUBSUBSTATE_PAUSED: + switch (dataSetWriter->state){ + case UA_PUBSUBSTATE_DISABLED: + break; + case UA_PUBSUBSTATE_PAUSED: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_OPERATIONAL: + break; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + break; + case UA_PUBSUBSTATE_OPERATIONAL: + switch (dataSetWriter->state){ + case UA_PUBSUBSTATE_DISABLED: + dataSetWriter->state = UA_PUBSUBSTATE_OPERATIONAL; + break; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + break; + case UA_PUBSUBSTATE_ERROR: + switch (dataSetWriter->state){ + case UA_PUBSUBSTATE_DISABLED: + break; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + break; + case UA_PUBSUBSTATE_ERROR: + return UA_STATUSCODE_GOOD; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_addDataSetWriter(UA_Server *server, + const UA_NodeId writerGroup, const UA_NodeId dataSet, + const UA_DataSetWriterConfig *dataSetWriterConfig, + UA_NodeId *writerIdentifier) { + if(!dataSetWriterConfig) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + UA_PublishedDataSet *currentDataSetContext = + UA_PublishedDataSet_findPDSbyId(server, dataSet); + if(!currentDataSetContext) + return UA_STATUSCODE_BADNOTFOUND; + + if(currentDataSetContext->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Adding DataSetWriter failed. PublishedDataSet is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!wg) + return UA_STATUSCODE_BADNOTFOUND; + + if(wg->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Adding DataSetWriter failed. WriterGroup is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + if(wg->config.rtLevel != UA_PUBSUB_RT_NONE) { + UA_DataSetField *tmpDSF; + TAILQ_FOREACH(tmpDSF, ¤tDataSetContext->fields, listEntry) { + if(!tmpDSF->config.field.variable.rtValueSource.rtFieldSourceEnabled && + !tmpDSF->config.field.variable.rtValueSource.rtInformationModelNode) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Adding DataSetWriter failed. Fields in PDS are not RT capable."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + } + } + + UA_DataSetWriter *newDataSetWriter = (UA_DataSetWriter *) + UA_calloc(1, sizeof(UA_DataSetWriter)); + if(!newDataSetWriter) + return UA_STATUSCODE_BADOUTOFMEMORY; + + newDataSetWriter->componentType = UA_PUBSUB_COMPONENT_DATASETWRITER; + + UA_StatusCode res = UA_STATUSCODE_GOOD; + if(wg->state == UA_PUBSUBSTATE_OPERATIONAL) { + res = UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_OPERATIONAL, + newDataSetWriter); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Add DataSetWriter failed. setPubSubState failed."); + UA_free(newDataSetWriter); + return res; + } + } + + /* Copy the config into the new dataSetWriter */ + res = UA_DataSetWriterConfig_copy(dataSetWriterConfig, &newDataSetWriter->config); + UA_CHECK_STATUS(res, UA_free(newDataSetWriter); return res); + + /* Save the current version of the connected PublishedDataSet */ + newDataSetWriter->connectedDataSetVersion = + currentDataSetContext->dataSetMetaData.configurationVersion; + +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES + /* Initialize the queue for the last values */ + if(currentDataSetContext->fieldSize > 0) { + newDataSetWriter->lastSamples = (UA_DataSetWriterSample*) + UA_calloc(currentDataSetContext->fieldSize, sizeof(UA_DataSetWriterSample)); + if(!newDataSetWriter->lastSamples) { + UA_DataSetWriterConfig_clear(&newDataSetWriter->config); + UA_free(newDataSetWriter); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + newDataSetWriter->lastSamplesCount = currentDataSetContext->fieldSize; + for(size_t i = 0; i < newDataSetWriter->lastSamplesCount; i++) { + UA_DataValue_init(&newDataSetWriter->lastSamples[i].value); + newDataSetWriter->lastSamples[i].valueChanged = false; + } + } +#endif + + /* Connect PublishedDataSet with DataSetWriter */ + newDataSetWriter->connectedDataSet = currentDataSetContext->identifier; + newDataSetWriter->linkedWriterGroup = wg->identifier; + + /* Add the new writer to the group */ + LIST_INSERT_HEAD(&wg->writers, newDataSetWriter, listEntry); + wg->writersCount++; + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + res |= addDataSetWriterRepresentation(server, newDataSetWriter); +#else + UA_PubSubManager_generateUniqueNodeId(&server->pubSubManager, + &newDataSetWriter->identifier); +#endif + if(writerIdentifier) + UA_NodeId_copy(&newDataSetWriter->identifier, writerIdentifier); + return res; +} + +UA_StatusCode +UA_DataSetWriter_remove(UA_Server *server, UA_WriterGroup *linkedWriterGroup, + UA_DataSetWriter *dataSetWriter) { + /* Frozen? */ + if(linkedWriterGroup->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove DataSetWriter failed. WriterGroup is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + /* Remove from information model */ +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + removeDataSetWriterRepresentation(server, dataSetWriter); +#endif + + /* Remove DataSetWriter from group */ + UA_DataSetWriter_clear(server, dataSetWriter); + LIST_REMOVE(dataSetWriter, listEntry); + linkedWriterGroup->writersCount--; + UA_free(dataSetWriter); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_removeDataSetWriter(UA_Server *server, const UA_NodeId dsw) { + UA_DataSetWriter *dataSetWriter = UA_DataSetWriter_findDSWbyId(server, dsw); + if(!dataSetWriter) + return UA_STATUSCODE_BADNOTFOUND; + + if(dataSetWriter->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove DataSetWriter failed. DataSetWriter is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + UA_WriterGroup *linkedWriterGroup = + UA_WriterGroup_findWGbyId(server, dataSetWriter->linkedWriterGroup); + if(!linkedWriterGroup) + return UA_STATUSCODE_BADNOTFOUND; + + return UA_DataSetWriter_remove(server, linkedWriterGroup, dataSetWriter); +} + +/**********************************************/ +/* DataSetField */ +/**********************************************/ + +static void +UA_DataSetField_clear(UA_DataSetField *field) { + UA_DataSetFieldConfig_clear(&field->config); + UA_NodeId_clear(&field->identifier); + UA_NodeId_clear(&field->publishedDataSet); + UA_FieldMetaData_clear(&field->fieldMetaData); +} + +UA_StatusCode +UA_DataSetFieldConfig_copy(const UA_DataSetFieldConfig *src, + UA_DataSetFieldConfig *dst) { + if(src->dataSetFieldType != UA_PUBSUB_DATASETFIELD_VARIABLE) + return UA_STATUSCODE_BADNOTSUPPORTED; + memcpy(dst, src, sizeof(UA_DataSetFieldConfig)); + UA_StatusCode res = UA_STATUSCODE_GOOD; + res |= UA_String_copy(&src->field.variable.fieldNameAlias, + &dst->field.variable.fieldNameAlias); + res |= UA_PublishedVariableDataType_copy(&src->field.variable.publishParameters, + &dst->field.variable.publishParameters); + if(res != UA_STATUSCODE_GOOD) + UA_DataSetFieldConfig_clear(dst); + return res; +} + +UA_StatusCode +UA_Server_getDataSetFieldConfig(UA_Server *server, const UA_NodeId dsf, + UA_DataSetFieldConfig *config) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_DataSetField *currentDataSetField = UA_DataSetField_findDSFbyId(server, dsf); + if(!currentDataSetField) + return UA_STATUSCODE_BADNOTFOUND; + return UA_DataSetFieldConfig_copy(¤tDataSetField->config, config); +} + +UA_DataSetField * +UA_DataSetField_findDSFbyId(UA_Server *server, UA_NodeId identifier) { + UA_PublishedDataSet *tmpPDS; + TAILQ_FOREACH(tmpPDS, &server->pubSubManager.publishedDataSets, listEntry) { + UA_DataSetField *tmpField; + TAILQ_FOREACH(tmpField, &tmpPDS->fields, listEntry) { + if(UA_NodeId_equal(&tmpField->identifier, &identifier)) + return tmpField; + } + } + return NULL; +} + +void +UA_DataSetFieldConfig_clear(UA_DataSetFieldConfig *dataSetFieldConfig) { + if(dataSetFieldConfig->dataSetFieldType == UA_PUBSUB_DATASETFIELD_VARIABLE) { + UA_String_clear(&dataSetFieldConfig->field.variable.fieldNameAlias); + UA_PublishedVariableDataType_clear(&dataSetFieldConfig->field.variable.publishParameters); + } +} + +/*********************************************************/ +/* PublishValues handling */ +/*********************************************************/ + +/* Compare two variants. Internally used for value change detection. */ +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES +static UA_Boolean +valueChangedVariant(UA_Variant *oldValue, UA_Variant *newValue) { + if(!oldValue || !newValue) + return false; + + size_t oldValueEncodingSize = UA_calcSizeBinary(oldValue, &UA_TYPES[UA_TYPES_VARIANT]); + size_t newValueEncodingSize = UA_calcSizeBinary(newValue, &UA_TYPES[UA_TYPES_VARIANT]); + if(oldValueEncodingSize == 0 || newValueEncodingSize == 0) + return false; + + if(oldValueEncodingSize != newValueEncodingSize) + return true; + + UA_ByteString oldValueEncoding = {0}; + UA_StatusCode res = UA_ByteString_allocBuffer(&oldValueEncoding, oldValueEncodingSize); + if(res != UA_STATUSCODE_GOOD) + return false; + + UA_ByteString newValueEncoding = {0}; + res = UA_ByteString_allocBuffer(&newValueEncoding, newValueEncodingSize); + if(res != UA_STATUSCODE_GOOD) { + UA_ByteString_clear(&oldValueEncoding); + return false; + } + + UA_Byte *bufPosOldValue = oldValueEncoding.data; + const UA_Byte *bufEndOldValue = &oldValueEncoding.data[oldValueEncoding.length]; + UA_Byte *bufPosNewValue = newValueEncoding.data; + const UA_Byte *bufEndNewValue = &newValueEncoding.data[newValueEncoding.length]; + + UA_Boolean compareResult = false; /* default */ + + res = UA_encodeBinaryInternal(oldValue, &UA_TYPES[UA_TYPES_VARIANT], + &bufPosOldValue, &bufEndOldValue, NULL, NULL); + if(res != UA_STATUSCODE_GOOD) + goto cleanup; + + res = UA_encodeBinaryInternal(newValue, &UA_TYPES[UA_TYPES_VARIANT], + &bufPosNewValue, &bufEndNewValue, NULL, NULL); + if(res != UA_STATUSCODE_GOOD) + goto cleanup; + + oldValueEncoding.length = (uintptr_t)bufPosOldValue - (uintptr_t)oldValueEncoding.data; + newValueEncoding.length = (uintptr_t)bufPosNewValue - (uintptr_t)newValueEncoding.data; + compareResult = !UA_ByteString_equal(&oldValueEncoding, &newValueEncoding); + + cleanup: + UA_ByteString_clear(&oldValueEncoding); + UA_ByteString_clear(&newValueEncoding); + return compareResult; +} +#endif + +/* Obtain the latest value for a specific DataSetField. This method is currently + * called inside the DataSetMessage generation process. */ +static void +UA_PubSubDataSetField_sampleValue(UA_Server *server, UA_DataSetField *field, + UA_DataValue *value) { + UA_PublishedVariableDataType *params = &field->config.field.variable.publishParameters; + + /* Read the value */ + if(field->config.field.variable.rtValueSource.rtInformationModelNode) { + const UA_VariableNode *rtNode = (const UA_VariableNode *) + UA_NODESTORE_GET(server, ¶ms->publishedVariable); + *value = **rtNode->valueBackend.backend.external.value; + value->value.storageType = UA_VARIANT_DATA_NODELETE; + UA_NODESTORE_RELEASE(server, (const UA_Node *) rtNode); + } else if(field->config.field.variable.rtValueSource.rtFieldSourceEnabled == UA_FALSE){ + UA_ReadValueId rvid; + UA_ReadValueId_init(&rvid); + rvid.nodeId = params->publishedVariable; + rvid.attributeId = params->attributeId; + rvid.indexRange = params->indexRange; + *value = UA_Server_read(server, &rvid, UA_TIMESTAMPSTORETURN_BOTH); + } else { + *value = **field->config.field.variable.rtValueSource.staticValueSource; + value->value.storageType = UA_VARIANT_DATA_NODELETE; + } +} + +static UA_StatusCode +UA_PubSubDataSetWriter_generateKeyFrameMessage(UA_Server *server, + UA_DataSetMessage *dataSetMessage, + UA_DataSetWriter *dataSetWriter) { + UA_PublishedDataSet *currentDataSet = + UA_PublishedDataSet_findPDSbyId(server, dataSetWriter->connectedDataSet); + if(!currentDataSet) + return UA_STATUSCODE_BADNOTFOUND; + + /* Prepare DataSetMessageContent */ + dataSetMessage->header.dataSetMessageValid = true; + dataSetMessage->header.dataSetMessageType = UA_DATASETMESSAGE_DATAKEYFRAME; + dataSetMessage->data.keyFrameData.fieldCount = currentDataSet->fieldSize; + dataSetMessage->data.keyFrameData.dataSetFields = (UA_DataValue *) + UA_Array_new(currentDataSet->fieldSize, &UA_TYPES[UA_TYPES_DATAVALUE]); + if(!dataSetMessage->data.keyFrameData.dataSetFields) + return UA_STATUSCODE_BADOUTOFMEMORY; + +#ifdef UA_ENABLE_JSON_ENCODING + dataSetMessage->data.keyFrameData.fieldNames = (UA_String *) + UA_Array_new(currentDataSet->fieldSize, &UA_TYPES[UA_TYPES_STRING]); + if(!dataSetMessage->data.keyFrameData.fieldNames) { + UA_DataSetMessage_clear(dataSetMessage); + return UA_STATUSCODE_BADOUTOFMEMORY; + } +#endif + + /* Loop over the fields */ + size_t counter = 0; + UA_DataSetField *dsf; + TAILQ_FOREACH(dsf, ¤tDataSet->fields, listEntry) { +#ifdef UA_ENABLE_JSON_ENCODING + /* Set the field name alias */ + UA_String_copy(&dsf->config.field.variable.fieldNameAlias, + &dataSetMessage->data.keyFrameData.fieldNames[counter]); +#endif + + /* Sample the value */ + UA_DataValue *dfv = &dataSetMessage->data.keyFrameData.dataSetFields[counter]; + UA_PubSubDataSetField_sampleValue(server, dsf, dfv); + + /* Deactivate statuscode? */ + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_STATUSCODE) == 0) + dfv->hasStatus = false; + + /* Deactivate timestamps */ + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SOURCETIMESTAMP) == 0) + dfv->hasSourceTimestamp = false; + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SOURCEPICOSECONDS) == 0) + dfv->hasSourcePicoseconds = false; + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SERVERTIMESTAMP) == 0) + dfv->hasServerTimestamp = false; + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SERVERPICOSECONDS) == 0) + dfv->hasServerPicoseconds = false; + +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES + /* Update lastValue store */ + UA_DataValue_clear(&dataSetWriter->lastSamples[counter].value); + UA_DataValue_copy(dfv, &dataSetWriter->lastSamples[counter].value); +#endif + + counter++; + } + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES +static UA_StatusCode +UA_PubSubDataSetWriter_generateDeltaFrameMessage(UA_Server *server, + UA_DataSetMessage *dataSetMessage, + UA_DataSetWriter *dataSetWriter) { + UA_PublishedDataSet *currentDataSet = + UA_PublishedDataSet_findPDSbyId(server, dataSetWriter->connectedDataSet); + if(!currentDataSet) + return UA_STATUSCODE_BADNOTFOUND; + + /* Prepare DataSetMessageContent */ + memset(dataSetMessage, 0, sizeof(UA_DataSetMessage)); + dataSetMessage->header.dataSetMessageValid = true; + dataSetMessage->header.dataSetMessageType = UA_DATASETMESSAGE_DATADELTAFRAME; + if(currentDataSet->fieldSize == 0) + return UA_STATUSCODE_GOOD; + + UA_DataSetField *dsf; + size_t counter = 0; + TAILQ_FOREACH(dsf, ¤tDataSet->fields, listEntry) { + /* Sample the value */ + UA_DataValue value; + UA_DataValue_init(&value); + UA_PubSubDataSetField_sampleValue(server, dsf, &value); + + /* Check if the value has changed */ + UA_DataSetWriterSample *ls = &dataSetWriter->lastSamples[counter]; + if(valueChangedVariant(&ls->value.value, &value.value)) { + /* increase fieldCount for current delta message */ + dataSetMessage->data.deltaFrameData.fieldCount++; + ls->valueChanged = true; + + /* Update last stored sample */ + UA_DataValue_clear(&ls->value); + ls->value = value; + } else { + UA_DataValue_clear(&value); + ls->valueChanged = false; + } + + counter++; + } + + /* Allocate DeltaFrameFields */ + UA_DataSetMessage_DeltaFrameField *deltaFields = (UA_DataSetMessage_DeltaFrameField *) + UA_calloc(dataSetMessage->data.deltaFrameData.fieldCount, + sizeof(UA_DataSetMessage_DeltaFrameField)); + if(!deltaFields) + return UA_STATUSCODE_BADOUTOFMEMORY; + + dataSetMessage->data.deltaFrameData.deltaFrameFields = deltaFields; + size_t currentDeltaField = 0; + for(size_t i = 0; i < currentDataSet->fieldSize; i++) { + if(!dataSetWriter->lastSamples[i].valueChanged) + continue; + + UA_DataSetMessage_DeltaFrameField *dff = &deltaFields[currentDeltaField]; + + dff->fieldIndex = (UA_UInt16) i; + UA_DataValue_copy(&dataSetWriter->lastSamples[i].value, &dff->fieldValue); + dataSetWriter->lastSamples[i].valueChanged = false; + + /* Deactivate statuscode? */ + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_STATUSCODE) == 0) + dff->fieldValue.hasStatus = false; + + /* Deactivate timestamps? */ + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SOURCETIMESTAMP) == 0) + dff->fieldValue.hasSourceTimestamp = false; + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SOURCEPICOSECONDS) == 0) + dff->fieldValue.hasServerPicoseconds = false; + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SERVERTIMESTAMP) == 0) + dff->fieldValue.hasServerTimestamp = false; + if(((u64)dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SERVERPICOSECONDS) == 0) + dff->fieldValue.hasServerPicoseconds = false; + + currentDeltaField++; + } + return UA_STATUSCODE_GOOD; +} +#endif + +/* Generate a DataSetMessage for the given writer. */ +UA_StatusCode +UA_DataSetWriter_generateDataSetMessage(UA_Server *server, + UA_DataSetMessage *dataSetMessage, + UA_DataSetWriter *dataSetWriter) { + UA_PublishedDataSet *currentDataSet = + UA_PublishedDataSet_findPDSbyId(server, dataSetWriter->connectedDataSet); + if(!currentDataSet) + return UA_STATUSCODE_BADNOTFOUND; + + /* Reset the message */ + memset(dataSetMessage, 0, sizeof(UA_DataSetMessage)); + + /* The configuration Flags are included + * inside the std. defined UA_UadpDataSetWriterMessageDataType */ + UA_UadpDataSetWriterMessageDataType defaultUadpConfiguration; + UA_UadpDataSetWriterMessageDataType *dsm = NULL; + UA_JsonDataSetWriterMessageDataType *jsonDsm = NULL; + const UA_ExtensionObject *ms = &dataSetWriter->config.messageSettings; + if((ms->encoding == UA_EXTENSIONOBJECT_DECODED || + ms->encoding == UA_EXTENSIONOBJECT_DECODED_NODELETE) && + ms->content.decoded.type == &UA_TYPES[UA_TYPES_UADPDATASETWRITERMESSAGEDATATYPE]) { + dsm = (UA_UadpDataSetWriterMessageDataType*)ms->content.decoded.data; /* type is UADP */ + } else if((ms->encoding == UA_EXTENSIONOBJECT_DECODED || + ms->encoding == UA_EXTENSIONOBJECT_DECODED_NODELETE) && + ms->content.decoded.type == &UA_TYPES[UA_TYPES_JSONDATASETWRITERMESSAGEDATATYPE]) { + jsonDsm = (UA_JsonDataSetWriterMessageDataType*)ms->content.decoded.data; /* type is JSON */ + } else { + /* Create default flag configuration if no + * UadpDataSetWriterMessageDataType was passed in */ + memset(&defaultUadpConfiguration, 0, sizeof(UA_UadpDataSetWriterMessageDataType)); + defaultUadpConfiguration.dataSetMessageContentMask = (UA_UadpDataSetMessageContentMask) + ((u64)UA_UADPDATASETMESSAGECONTENTMASK_TIMESTAMP | + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MAJORVERSION | + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MINORVERSION); + dsm = &defaultUadpConfiguration; /* type is UADP */ + } + + /* The field encoding depends on the flags inside the writer config. */ + if(dataSetWriter->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_RAWDATA) { + dataSetMessage->header.fieldEncoding = UA_FIELDENCODING_RAWDATA; + } else if((u64)dataSetWriter->config.dataSetFieldContentMask & + ((u64)UA_DATASETFIELDCONTENTMASK_SOURCETIMESTAMP | + (u64)UA_DATASETFIELDCONTENTMASK_SERVERPICOSECONDS | + (u64)UA_DATASETFIELDCONTENTMASK_SOURCEPICOSECONDS | + (u64)UA_DATASETFIELDCONTENTMASK_STATUSCODE)) { + dataSetMessage->header.fieldEncoding = UA_FIELDENCODING_DATAVALUE; + } else { + dataSetMessage->header.fieldEncoding = UA_FIELDENCODING_VARIANT; + } + + if(dsm) { + /* Sanity-test the configuration */ + if(dsm->networkMessageNumber != 0 || + dsm->dataSetOffset != 0 || + dsm->configuredSize != 0) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Static DSM configuration not supported. Using defaults"); + dsm->networkMessageNumber = 0; + dsm->dataSetOffset = 0; + dsm->configuredSize = 0; + } + + /* Std: 'The DataSetMessageContentMask defines the flags for the content + * of the DataSetMessage header.' */ + if((u64)dsm->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MAJORVERSION) { + dataSetMessage->header.configVersionMajorVersionEnabled = true; + dataSetMessage->header.configVersionMajorVersion = + currentDataSet->dataSetMetaData.configurationVersion.majorVersion; + } + if((u64)dsm->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MINORVERSION) { + dataSetMessage->header.configVersionMinorVersionEnabled = true; + dataSetMessage->header.configVersionMinorVersion = + currentDataSet->dataSetMetaData.configurationVersion.minorVersion; + } + + if((u64)dsm->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_SEQUENCENUMBER) { + dataSetMessage->header.dataSetMessageSequenceNrEnabled = true; + dataSetMessage->header.dataSetMessageSequenceNr = + dataSetWriter->actualDataSetMessageSequenceCount; + } + + if((u64)dsm->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_TIMESTAMP) { + dataSetMessage->header.timestampEnabled = true; + dataSetMessage->header.timestamp = UA_DateTime_now(); + } + + /* TODO: Picoseconds resolution not supported atm */ + if((u64)dsm->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_PICOSECONDS) { + dataSetMessage->header.picoSecondsIncluded = false; + } + + /* TODO: Statuscode not supported yet */ + if((u64)dsm->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_STATUS) { + dataSetMessage->header.statusEnabled = false; + } + } else if(jsonDsm) { + if((u64)jsonDsm->dataSetMessageContentMask & + (u64)UA_JSONDATASETMESSAGECONTENTMASK_METADATAVERSION) { + dataSetMessage->header.configVersionMajorVersionEnabled = true; + dataSetMessage->header.configVersionMajorVersion = + currentDataSet->dataSetMetaData.configurationVersion.majorVersion; + } + if((u64)jsonDsm->dataSetMessageContentMask & + (u64)UA_JSONDATASETMESSAGECONTENTMASK_METADATAVERSION) { + dataSetMessage->header.configVersionMinorVersionEnabled = true; + dataSetMessage->header.configVersionMinorVersion = + currentDataSet->dataSetMetaData.configurationVersion.minorVersion; + } + + if((u64)jsonDsm->dataSetMessageContentMask & + (u64)UA_JSONDATASETMESSAGECONTENTMASK_SEQUENCENUMBER) { + dataSetMessage->header.dataSetMessageSequenceNrEnabled = true; + dataSetMessage->header.dataSetMessageSequenceNr = + dataSetWriter->actualDataSetMessageSequenceCount; + } + + if((u64)jsonDsm->dataSetMessageContentMask & + (u64)UA_JSONDATASETMESSAGECONTENTMASK_TIMESTAMP) { + dataSetMessage->header.timestampEnabled = true; + dataSetMessage->header.timestamp = UA_DateTime_now(); + } + + /* TODO: Statuscode not supported yet */ + if((u64)jsonDsm->dataSetMessageContentMask & + (u64)UA_JSONDATASETMESSAGECONTENTMASK_STATUS) { + dataSetMessage->header.statusEnabled = false; + } + } + + /* Set the sequence count. Automatically rolls over to zero */ + dataSetWriter->actualDataSetMessageSequenceCount++; + + /* JSON does not differ between deltaframes and keyframes, only keyframes + * are currently used. */ + if(dsm) { +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES + /* Check if the PublishedDataSet version has changed -> if yes flush the + * lastValue store and send a KeyFrame */ + if(dataSetWriter->connectedDataSetVersion.majorVersion != + currentDataSet->dataSetMetaData.configurationVersion.majorVersion || + dataSetWriter->connectedDataSetVersion.minorVersion != + currentDataSet->dataSetMetaData.configurationVersion.minorVersion) { + /* Remove old samples */ + for(size_t i = 0; i < dataSetWriter->lastSamplesCount; i++) + UA_DataValue_clear(&dataSetWriter->lastSamples[i].value); + + /* Realloc PDS dependent memory */ + dataSetWriter->lastSamplesCount = currentDataSet->fieldSize; + UA_DataSetWriterSample *newSamplesArray = (UA_DataSetWriterSample * ) + UA_realloc(dataSetWriter->lastSamples, + sizeof(UA_DataSetWriterSample) * dataSetWriter->lastSamplesCount); + if(!newSamplesArray) + return UA_STATUSCODE_BADOUTOFMEMORY; + dataSetWriter->lastSamples = newSamplesArray; + memset(dataSetWriter->lastSamples, 0, + sizeof(UA_DataSetWriterSample) * dataSetWriter->lastSamplesCount); + + dataSetWriter->connectedDataSetVersion = + currentDataSet->dataSetMetaData.configurationVersion; + UA_PubSubDataSetWriter_generateKeyFrameMessage(server, dataSetMessage, + dataSetWriter); + dataSetWriter->deltaFrameCounter = 0; + return UA_STATUSCODE_GOOD; + } + + /* The standard defines: if a PDS contains only one fields no delta messages + * should be generated because they need more memory than a keyframe with 1 + * field. */ + if(currentDataSet->fieldSize > 1 && dataSetWriter->deltaFrameCounter > 0 && + dataSetWriter->deltaFrameCounter <= dataSetWriter->config.keyFrameCount) { + UA_PubSubDataSetWriter_generateDeltaFrameMessage(server, dataSetMessage, + dataSetWriter); + dataSetWriter->deltaFrameCounter++; + return UA_STATUSCODE_GOOD; + } + + dataSetWriter->deltaFrameCounter = 1; +#endif + } + + return UA_PubSubDataSetWriter_generateKeyFrameMessage(server, dataSetMessage, + dataSetWriter); +} + +#endif /* UA_ENABLE_PUBSUB */ + +/**** amalgamated original file "/src/pubsub/ua_pubsub_writergroup.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2019 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019 Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright (c) 2019 Kalycito Infotech Private Limited + * Copyright (c) 2020 Yannick Wallerer, Siemens AG + * Copyright (c) 2020 Thomas Fischer, Siemens AG + * Copyright (c) 2021 Fraunhofer IOSB (Author: Jan Hermes) + */ + + +#ifdef UA_ENABLE_PUBSUB /* conditional compilation */ + + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL +#endif + +#define UA_MAX_STACKBUF 128 /* Max size of network messages on the stack */ + +static void +UA_WriterGroup_clear(UA_Server *server, UA_WriterGroup *writerGroup); + +static UA_StatusCode +generateNetworkMessage(UA_PubSubConnection *connection, UA_WriterGroup *wg, + UA_DataSetMessage *dsm, UA_UInt16 *writerIds, UA_Byte dsmCount, + UA_ExtensionObject *messageSettings, + UA_ExtensionObject *transportSettings, + UA_NetworkMessage *networkMessage); + +UA_StatusCode +UA_Server_addWriterGroup(UA_Server *server, const UA_NodeId connection, + const UA_WriterGroupConfig *writerGroupConfig, + UA_NodeId *writerGroupIdentifier) { + if(!writerGroupConfig) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + /* Search the connection by the given connectionIdentifier */ + UA_PubSubConnection *currentConnectionContext = + UA_PubSubConnection_findConnectionbyId(server, connection); + if(!currentConnectionContext) + return UA_STATUSCODE_BADNOTFOUND; + + if(currentConnectionContext->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Adding WriterGroup failed. PubSubConnection is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + /* Validate messageSettings type */ + const UA_ExtensionObject *ms = &writerGroupConfig->messageSettings; + if(ms->content.decoded.type) { + if(writerGroupConfig->encodingMimeType == UA_PUBSUB_ENCODING_JSON && + (ms->encoding != UA_EXTENSIONOBJECT_DECODED || + ms->content.decoded.type != &UA_TYPES[UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE])) { + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + if(writerGroupConfig->encodingMimeType == UA_PUBSUB_ENCODING_UADP && + (ms->encoding != UA_EXTENSIONOBJECT_DECODED || + ms->content.decoded.type != &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE])) { + return UA_STATUSCODE_BADTYPEMISMATCH; + } + } + + /* Allocate new WriterGroup */ + UA_WriterGroup *newWriterGroup = (UA_WriterGroup*)UA_calloc(1, sizeof(UA_WriterGroup)); + if(!newWriterGroup) + return UA_STATUSCODE_BADOUTOFMEMORY; + + newWriterGroup->componentType = UA_PUBSUB_COMPONENT_WRITERGROUP; + newWriterGroup->linkedConnection = currentConnectionContext; + + /* Deep copy of the config */ + UA_WriterGroupConfig *newConfig = &newWriterGroup->config; + UA_StatusCode res = UA_WriterGroupConfig_copy(writerGroupConfig, newConfig); + if(res != UA_STATUSCODE_GOOD) { + UA_free(newWriterGroup); + return res; + } + + /* Create the datatype value if not present */ + if(!newConfig->messageSettings.content.decoded.type) { + UA_UadpWriterGroupMessageDataType *wgm = UA_UadpWriterGroupMessageDataType_new(); + newConfig->messageSettings.content.decoded.data = wgm; + newConfig->messageSettings.content.decoded.type = + &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]; + newConfig->messageSettings.encoding = UA_EXTENSIONOBJECT_DECODED; + } + + /* Attach to the connection */ + LIST_INSERT_HEAD(¤tConnectionContext->writerGroups, newWriterGroup, listEntry); + currentConnectionContext->writerGroupsSize++; + + /* Add representation / create unique identifier */ +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + res = addWriterGroupRepresentation(server, newWriterGroup); +#else + UA_PubSubManager_generateUniqueNodeId(&server->pubSubManager, + &newWriterGroup->identifier); +#endif + if(writerGroupIdentifier) + UA_NodeId_copy(&newWriterGroup->identifier, writerGroupIdentifier); + return res; +} + +UA_StatusCode +UA_Server_removeWriterGroup(UA_Server *server, const UA_NodeId writerGroup) { + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!wg) + return UA_STATUSCODE_BADNOTFOUND; + + if(wg->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Delete WriterGroup failed. WriterGroup is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + UA_PubSubConnection *connection = wg->linkedConnection; + if(!connection) + return UA_STATUSCODE_BADNOTFOUND; + + if(connection->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Delete WriterGroup failed. PubSubConnection is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + if(wg->state == UA_PUBSUBSTATE_OPERATIONAL) { + /* Unregister the publish callback */ + if(wg->config.pubsubManagerCallback.removeCustomCallback) + wg->config.pubsubManagerCallback. + removeCustomCallback(server, wg->identifier, wg->publishCallbackId); + else + UA_PubSubManager_removeRepeatedPubSubCallback(server, wg->publishCallbackId); + + } + + UA_DataSetWriter *dsw, *dsw_tmp; + LIST_FOREACH_SAFE(dsw, &wg->writers, listEntry, dsw_tmp) { + UA_DataSetWriter_remove(server, wg, dsw); + } + + connection->writerGroupsSize--; +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + removeGroupRepresentation(server, wg); +#endif + + UA_WriterGroup_clear(server, wg); + LIST_REMOVE(wg, listEntry); + UA_free(wg); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_freezeWriterGroupConfiguration(UA_Server *server, + const UA_NodeId writerGroup) { + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!wg) + return UA_STATUSCODE_BADNOTFOUND; + + /* PubSubConnection freezeCounter++ */ + UA_PubSubConnection *pubSubConnection = wg->linkedConnection; + pubSubConnection->configurationFreezeCounter++; + pubSubConnection->configurationFrozen = true; + + /* WriterGroup freeze */ + wg->configurationFrozen = true; + + /* DataSetWriter freeze */ + UA_DataSetWriter *dataSetWriter; + LIST_FOREACH(dataSetWriter, &wg->writers, listEntry) { + dataSetWriter->configurationFrozen = true; + /* PublishedDataSet freezeCounter++ */ + UA_PublishedDataSet *publishedDataSet = + UA_PublishedDataSet_findPDSbyId(server, dataSetWriter->connectedDataSet); + publishedDataSet->configurationFreezeCounter++; + publishedDataSet->configurationFrozen = true; + /* DataSetFields freeze */ + UA_DataSetField *dataSetField; + TAILQ_FOREACH(dataSetField, &publishedDataSet->fields, listEntry) { + dataSetField->configurationFrozen = true; + } + } + + if(wg->config.rtLevel != UA_PUBSUB_RT_FIXED_SIZE) + return UA_STATUSCODE_GOOD; + + /* Freeze the RT writer configuration */ + size_t dsmCount = 0; + if(wg->config.encodingMimeType != UA_PUBSUB_ENCODING_UADP) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: Non-RT capable encoding."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + //TODO Clarify: should we only allow = maxEncapsulatedDataSetMessageCount == 1 with RT? + //TODO Clarify: Behaviour if the finale size is more than MTU + + /* Generate data set messages */ + UA_STACKARRAY(UA_UInt16, dsWriterIds, wg->writersCount); + UA_STACKARRAY(UA_DataSetMessage, dsmStore, wg->writersCount); + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_DataSetWriter *dsw; + LIST_FOREACH(dsw, &wg->writers, listEntry) { + /* Find the dataset */ + UA_PublishedDataSet *pds = + UA_PublishedDataSet_findPDSbyId(server, dsw->connectedDataSet); + if(!pds) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Publish: PublishedDataSet not found"); + continue; + } + if(pds->promotedFieldsCount > 0) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: PDS contains promoted fields."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + /* Test the DataSetFields */ + UA_DataSetField *dsf; + TAILQ_FOREACH(dsf, &pds->fields, listEntry) { + const UA_VariableNode *rtNode = (const UA_VariableNode *) + UA_NODESTORE_GET(server, &dsf->config.field.variable.publishParameters.publishedVariable); + if(rtNode != NULL && rtNode->valueBackend.backendType != UA_VALUEBACKENDTYPE_EXTERNAL) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: PDS contains field without external data source."); + UA_NODESTORE_RELEASE(server, (const UA_Node *) rtNode); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + UA_NODESTORE_RELEASE(server, (const UA_Node *) rtNode); + if((UA_NodeId_equal(&dsf->fieldMetaData.dataType, &UA_TYPES[UA_TYPES_STRING].typeId) || + UA_NodeId_equal(&dsf->fieldMetaData.dataType, + &UA_TYPES[UA_TYPES_BYTESTRING].typeId)) && + dsf->fieldMetaData.maxStringLength == 0) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: " + "PDS contains String/ByteString with dynamic length."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } else if(!UA_DataType_isNumeric(UA_findDataType(&dsf->fieldMetaData.dataType))){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: " + "PDS contains variable with dynamic size."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + } + + /* Generate the DSM */ + res = UA_DataSetWriter_generateDataSetMessage(server, &dsmStore[dsmCount], dsw); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub RT Offset calculation: DataSetMessage buffering failed"); + continue; + } + + dsWriterIds[dsmCount] = dsw->config.dataSetWriterId; + dsmCount++; + } + + /* Define variables here for goto */ + size_t msgSize; + UA_ByteString buf; + UA_NetworkMessage networkMessage; + const UA_Byte *bufEnd; + UA_Byte *bufPos; + + if(res != UA_STATUSCODE_GOOD) + goto cleanup_dsm; + + memset(&networkMessage, 0, sizeof(networkMessage)); + res = generateNetworkMessage(pubSubConnection, wg, dsmStore, dsWriterIds, + (UA_Byte) dsmCount, &wg->config.messageSettings, + &wg->config.transportSettings, &networkMessage); + if(res != UA_STATUSCODE_GOOD) + goto cleanup_dsm; + + memset(&wg->bufferedMessage, 0, sizeof(UA_NetworkMessageOffsetBuffer)); + UA_NetworkMessage_calcSizeBinary(&networkMessage, &wg->bufferedMessage); + + /* Allocate the buffer. Allocate on the stack if the buffer is small. */ + msgSize = UA_NetworkMessage_calcSizeBinary(&networkMessage, NULL); + res = UA_ByteString_allocBuffer(&buf, msgSize); + if(res != UA_STATUSCODE_GOOD) + goto cleanup; + wg->bufferedMessage.buffer = buf; + + /* Encode the NetworkMessage */ + bufEnd = &wg->bufferedMessage.buffer.data[wg->bufferedMessage.buffer.length]; + bufPos = wg->bufferedMessage.buffer.data; + UA_NetworkMessage_encodeBinary(&networkMessage, &bufPos, bufEnd, NULL); + + cleanup: + UA_free(networkMessage.payload.dataSetPayload.sizes); + + /* Clean up DSM */ + cleanup_dsm: + for(size_t i = 0; i < dsmCount; i++){ + UA_free(dsmStore[i].data.keyFrameData.dataSetFields); +#ifdef UA_ENABLE_JSON_ENCODING + UA_Array_delete(dsmStore[i].data.keyFrameData.fieldNames, + dsmStore[i].data.keyFrameData.fieldCount, + &UA_TYPES[UA_TYPES_STRING]); +#endif + } + + return res; +} + +UA_StatusCode +UA_Server_unfreezeWriterGroupConfiguration(UA_Server *server, + const UA_NodeId writerGroup) { + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!wg) + return UA_STATUSCODE_BADNOTFOUND; + //if(wg->config.rtLevel == UA_PUBSUB_RT_NONE){ + // UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + // "PubSub configuration freeze without RT configuration has no effect."); + // return UA_STATUSCODE_BADCONFIGURATIONERROR; + //} + //PubSubConnection freezeCounter-- + UA_PubSubConnection *pubSubConnection = wg->linkedConnection; + pubSubConnection->configurationFreezeCounter--; + if(pubSubConnection->configurationFreezeCounter == 0){ + pubSubConnection->configurationFrozen = UA_FALSE; + } + //WriterGroup unfreeze + wg->configurationFrozen = UA_FALSE; + //DataSetWriter unfreeze + UA_DataSetWriter *dataSetWriter; + LIST_FOREACH(dataSetWriter, &wg->writers, listEntry) { + UA_PublishedDataSet *publishedDataSet = + UA_PublishedDataSet_findPDSbyId(server, dataSetWriter->connectedDataSet); + //PublishedDataSet freezeCounter-- + publishedDataSet->configurationFreezeCounter--; + if(publishedDataSet->configurationFreezeCounter == 0){ + publishedDataSet->configurationFrozen = UA_FALSE; + UA_DataSetField *dataSetField; + TAILQ_FOREACH(dataSetField, &publishedDataSet->fields, listEntry){ + dataSetField->configurationFrozen = UA_FALSE; + } + } + dataSetWriter->configurationFrozen = UA_FALSE; + } + if(wg->config.rtLevel == UA_PUBSUB_RT_FIXED_SIZE) + UA_ByteString_clear(&wg->bufferedMessage.buffer); + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_setWriterGroupOperational(UA_Server *server, + const UA_NodeId writerGroup) { + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!wg) + return UA_STATUSCODE_BADNOTFOUND; + return UA_WriterGroup_setPubSubState(server, UA_PUBSUBSTATE_OPERATIONAL, wg); +} + +UA_StatusCode +UA_Server_setWriterGroupDisabled(UA_Server *server, + const UA_NodeId writerGroup) { + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!wg) + return UA_STATUSCODE_BADNOTFOUND; + return UA_WriterGroup_setPubSubState(server, UA_PUBSUBSTATE_DISABLED, wg); +} + +UA_StatusCode +UA_WriterGroupConfig_copy(const UA_WriterGroupConfig *src, + UA_WriterGroupConfig *dst){ + UA_StatusCode res = UA_STATUSCODE_GOOD; + memcpy(dst, src, sizeof(UA_WriterGroupConfig)); + res |= UA_String_copy(&src->name, &dst->name); + res |= UA_ExtensionObject_copy(&src->transportSettings, &dst->transportSettings); + res |= UA_ExtensionObject_copy(&src->messageSettings, &dst->messageSettings); + if(src->groupPropertiesSize > 0) { + dst->groupProperties = (UA_KeyValuePair*) + UA_calloc(src->groupPropertiesSize, sizeof(UA_KeyValuePair)); + if(!dst->groupProperties) + return UA_STATUSCODE_BADOUTOFMEMORY; + for(size_t i = 0; i < src->groupPropertiesSize; i++) { + res |= UA_KeyValuePair_copy(&src->groupProperties[i], &dst->groupProperties[i]); + } + } + if(res != UA_STATUSCODE_GOOD) + UA_WriterGroupConfig_clear(dst); + return res; +} + +UA_StatusCode +UA_Server_getWriterGroupConfig(UA_Server *server, const UA_NodeId writerGroup, + UA_WriterGroupConfig *config) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_WriterGroup *currentWG = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!currentWG) + return UA_STATUSCODE_BADNOTFOUND; + return UA_WriterGroupConfig_copy(¤tWG->config, config); +} + +UA_StatusCode +UA_Server_updateWriterGroupConfig(UA_Server *server, UA_NodeId writerGroupIdentifier, + const UA_WriterGroupConfig *config){ + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + UA_WriterGroup *currentWriterGroup = + UA_WriterGroup_findWGbyId(server, writerGroupIdentifier); + if(!currentWriterGroup) + return UA_STATUSCODE_BADNOTFOUND; + + if(currentWriterGroup->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Modify WriterGroup failed. WriterGroup is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + //The update functionality will be extended during the next PubSub batches. + //Currently is only a change of the publishing interval possible. + if(currentWriterGroup->config.maxEncapsulatedDataSetMessageCount != config->maxEncapsulatedDataSetMessageCount) { + currentWriterGroup->config.maxEncapsulatedDataSetMessageCount = config->maxEncapsulatedDataSetMessageCount; + if(currentWriterGroup->config.messageSettings.encoding == UA_EXTENSIONOBJECT_ENCODED_NOBODY) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "MaxEncapsulatedDataSetMessag need enabled 'PayloadHeader' within the message settings."); + } + } + + if(currentWriterGroup->config.publishingInterval != config->publishingInterval) { + if(currentWriterGroup->config.rtLevel == UA_PUBSUB_RT_NONE && + currentWriterGroup->state == UA_PUBSUBSTATE_OPERATIONAL) { + if(currentWriterGroup->config.pubsubManagerCallback.removeCustomCallback) + currentWriterGroup->config.pubsubManagerCallback. + removeCustomCallback(server, currentWriterGroup->identifier, + currentWriterGroup->publishCallbackId); + else + UA_PubSubManager_removeRepeatedPubSubCallback(server, currentWriterGroup->publishCallbackId); + + currentWriterGroup->config.publishingInterval = config->publishingInterval; + UA_WriterGroup_addPublishCallback(server, currentWriterGroup); + } else { + currentWriterGroup->config.publishingInterval = config->publishingInterval; + } + } + + if(currentWriterGroup->config.priority != config->priority) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "No or unsupported WriterGroup update."); + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_WriterGroup_getState(UA_Server *server, UA_NodeId writerGroupIdentifier, + UA_PubSubState *state) { + if((server == NULL) || (state == NULL)) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_WriterGroup *currentWriterGroup = + UA_WriterGroup_findWGbyId(server, writerGroupIdentifier); + if(currentWriterGroup == NULL) + return UA_STATUSCODE_BADNOTFOUND; + *state = currentWriterGroup->state; + return UA_STATUSCODE_GOOD; +} + +UA_WriterGroup * +UA_WriterGroup_findWGbyId(UA_Server *server, UA_NodeId identifier) { + UA_PubSubConnection *tmpConnection; + TAILQ_FOREACH(tmpConnection, &server->pubSubManager.connections, listEntry) { + UA_WriterGroup *tmpWriterGroup; + LIST_FOREACH(tmpWriterGroup, &tmpConnection->writerGroups, listEntry) { + if(UA_NodeId_equal(&identifier, &tmpWriterGroup->identifier)) + return tmpWriterGroup; + } + } + return NULL; +} + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION +UA_StatusCode +UA_Server_setWriterGroupEncryptionKeys(UA_Server *server, const UA_NodeId writerGroup, + UA_UInt32 securityTokenId, + const UA_ByteString signingKey, + const UA_ByteString encryptingKey, + const UA_ByteString keyNonce) { + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, writerGroup); + if(!wg) + return UA_STATUSCODE_BADNOTFOUND; + + if(!wg->config.securityPolicy) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "No SecurityPolicy configured for the WriterGroup"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + if(securityTokenId != wg->securityTokenId) { + wg->securityTokenId = securityTokenId; + wg->nonceSequenceNumber = 1; + } + + /* Create a new context */ + if(!wg->securityPolicyContext) { + return wg->config.securityPolicy-> + newContext(wg->config.securityPolicy->policyContext, + &signingKey, &encryptingKey, &keyNonce, + &wg->securityPolicyContext); + } + + /* Update the context */ + return wg->config.securityPolicy-> + setSecurityKeys(wg->securityPolicyContext, &signingKey, &encryptingKey, &keyNonce); +} +#endif + +void +UA_WriterGroupConfig_clear(UA_WriterGroupConfig *writerGroupConfig){ + UA_String_clear(&writerGroupConfig->name); + UA_ExtensionObject_clear(&writerGroupConfig->transportSettings); + UA_ExtensionObject_clear(&writerGroupConfig->messageSettings); + UA_Array_delete(writerGroupConfig->groupProperties, + writerGroupConfig->groupPropertiesSize, + &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); + writerGroupConfig->groupProperties = NULL; +} + +static void +UA_WriterGroup_clear(UA_Server *server, UA_WriterGroup *writerGroup) { + UA_WriterGroupConfig_clear(&writerGroup->config); + UA_NodeId_clear(&writerGroup->identifier); + + /* Delete all writers */ + UA_DataSetWriter *dataSetWriter, *tmpDataSetWriter; + LIST_FOREACH_SAFE(dataSetWriter, &writerGroup->writers, listEntry, tmpDataSetWriter){ + UA_Server_removeDataSetWriter(server, dataSetWriter->identifier); + } + + if(writerGroup->bufferedMessage.offsetsSize > 0){ + for(size_t i = 0; i < writerGroup->bufferedMessage.offsetsSize; i++) { + if((writerGroup->bufferedMessage.offsets[i].contentType == UA_PUBSUB_OFFSETTYPE_PAYLOAD_VARIANT) || + (writerGroup->bufferedMessage.offsets[i].contentType == UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW)) { + UA_DataValue_delete(writerGroup->bufferedMessage.offsets[i].offsetData.value.value); + } else if(writerGroup->bufferedMessage.offsets[i].contentType == UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_FIELDENCDODING) { + writerGroup->bufferedMessage.offsets[i].offsetData.value.value->value.data = NULL; + UA_DataValue_delete(writerGroup->bufferedMessage.offsets[i].offsetData.value.value); + } + } + UA_ByteString_clear(&writerGroup->bufferedMessage.buffer); + UA_free(writerGroup->bufferedMessage.offsets); + } + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + if(writerGroup->config.securityPolicy && writerGroup->securityPolicyContext) { + writerGroup->config.securityPolicy->deleteContext(writerGroup->securityPolicyContext); + writerGroup->securityPolicyContext = NULL; + } +#endif +} + +UA_StatusCode +UA_WriterGroup_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_WriterGroup *writerGroup) { + UA_DataSetWriter *dataSetWriter; + switch(state) { + case UA_PUBSUBSTATE_DISABLED: + switch (writerGroup->state){ + case UA_PUBSUBSTATE_DISABLED: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + if(writerGroup->config.pubsubManagerCallback.removeCustomCallback) + writerGroup->config.pubsubManagerCallback. + removeCustomCallback(server, writerGroup->identifier, writerGroup->publishCallbackId); + else + UA_PubSubManager_removeRepeatedPubSubCallback(server, writerGroup->publishCallbackId); + + LIST_FOREACH(dataSetWriter, &writerGroup->writers, listEntry){ + UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_DISABLED, dataSetWriter); + } + writerGroup->state = UA_PUBSUBSTATE_DISABLED; + break; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + break; + case UA_PUBSUBSTATE_PAUSED: + switch (writerGroup->state) { + case UA_PUBSUBSTATE_DISABLED: + break; + case UA_PUBSUBSTATE_PAUSED: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_OPERATIONAL: + break; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + break; + case UA_PUBSUBSTATE_OPERATIONAL: + switch (writerGroup->state) { + case UA_PUBSUBSTATE_DISABLED: + writerGroup->state = UA_PUBSUBSTATE_OPERATIONAL; + if(writerGroup->config.pubsubManagerCallback.removeCustomCallback) + writerGroup->config.pubsubManagerCallback. + removeCustomCallback(server, writerGroup->identifier, + writerGroup->publishCallbackId); + else + UA_PubSubManager_removeRepeatedPubSubCallback(server, writerGroup->publishCallbackId); + + LIST_FOREACH(dataSetWriter, &writerGroup->writers, listEntry){ + UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_OPERATIONAL, + dataSetWriter); + } + UA_WriterGroup_addPublishCallback(server, writerGroup); + break; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + break; + case UA_PUBSUBSTATE_ERROR: { + switch (writerGroup->state){ + case UA_PUBSUBSTATE_DISABLED: + break; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + UA_PubSubManager_removeRepeatedPubSubCallback(server, writerGroup->publishCallbackId); + LIST_FOREACH(dataSetWriter, &writerGroup->writers, listEntry){ + UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dataSetWriter); + } + break; + case UA_PUBSUBSTATE_ERROR: + return UA_STATUSCODE_GOOD; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + writerGroup->state = UA_PUBSUBSTATE_ERROR; + /* TODO: WIP - example usage of pubsubStateChangeCallback -> inform + * application about error state, reason param necessary */ + UA_ServerConfig *pConfig = UA_Server_getConfig(server); + if(pConfig->pubSubConfig.stateChangeCallback != 0) { + pConfig->pubSubConfig. + stateChangeCallback(&writerGroup->identifier, UA_PUBSUBSTATE_ERROR, + UA_STATUSCODE_BADINTERNALERROR); + } + break; + } + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION +static UA_StatusCode +encryptAndSign(UA_WriterGroup *wg, const UA_NetworkMessage *nm, + UA_Byte *signStart, UA_Byte *encryptStart, + UA_Byte *msgEnd) { + UA_StatusCode rv; + void *channelContext = wg->securityPolicyContext; + + if(nm->securityHeader.networkMessageEncrypted) { + /* Set the temporary MessageNonce in the SecurityPolicy */ + rv = wg->config.securityPolicy->setMessageNonce(channelContext, + &nm->securityHeader.messageNonce); + UA_CHECK_STATUS(rv, return rv); + + /* The encryption is done in-place, no need to encode again */ + UA_ByteString toBeEncrypted = + {(uintptr_t)msgEnd - (uintptr_t)encryptStart, encryptStart}; + rv = wg->config.securityPolicy->symmetricModule.cryptoModule.encryptionAlgorithm. + encrypt(channelContext, &toBeEncrypted); + UA_CHECK_STATUS(rv, return rv); + } + + if(nm->securityHeader.networkMessageSigned) { + UA_ByteString toBeSigned = {(uintptr_t)msgEnd - (uintptr_t)signStart, + signStart}; + + size_t sigSize = wg->config.securityPolicy->symmetricModule.cryptoModule. + signatureAlgorithm.getLocalSignatureSize(channelContext); + UA_ByteString signature = {sigSize, msgEnd}; + + rv = wg->config.securityPolicy->symmetricModule.cryptoModule. + signatureAlgorithm.sign(channelContext, &toBeSigned, &signature); + UA_CHECK_STATUS(rv, return rv); + } + return UA_STATUSCODE_GOOD; +} +#endif + +static UA_StatusCode +encodeNetworkMessage(UA_WriterGroup *wg, UA_NetworkMessage *nm, + UA_ByteString *buf) { + UA_Byte *bufPos = buf->data; + UA_Byte *bufEnd = &buf->data[buf->length]; + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + UA_Byte *networkMessageStart = bufPos; +#endif + UA_StatusCode rv = UA_NetworkMessage_encodeHeaders(nm, &bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + UA_Byte *payloadStart = bufPos; +#endif + rv = UA_NetworkMessage_encodePayload(nm, &bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_NetworkMessage_encodeFooters(nm, &bufPos, bufEnd); + UA_CHECK_STATUS(rv, return rv); + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + /* Encrypt and Sign the message */ + UA_Byte *footerEnd = bufPos; + rv = encryptAndSign(wg, nm, networkMessageStart, payloadStart, footerEnd); + UA_CHECK_STATUS(rv, return rv); +#endif + + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_JSON_ENCODING +static UA_StatusCode +sendNetworkMessageJson(UA_PubSubConnection *connection, UA_DataSetMessage *dsm, + UA_UInt16 *writerIds, UA_Byte dsmCount, + UA_ExtensionObject *transportSettings) { + /* Prepare the NetworkMessage */ + UA_NetworkMessage nm; + memset(&nm, 0, sizeof(UA_NetworkMessage)); + nm.version = 1; + nm.networkMessageType = UA_NETWORKMESSAGE_DATASET; + nm.payloadHeaderEnabled = true; + nm.payloadHeader.dataSetPayloadHeader.count = dsmCount; + nm.payloadHeader.dataSetPayloadHeader.dataSetWriterIds = writerIds; + nm.payload.dataSetPayload.dataSetMessages = dsm; + + /* Compute the message length */ + size_t msgSize = UA_NetworkMessage_calcSizeJson(&nm, NULL, 0, NULL, 0, true); + + /* Allocate the buffer. Allocate on the stack if the buffer is small. */ + UA_ByteString buf; + UA_Byte stackBuf[UA_MAX_STACKBUF]; + buf.data = stackBuf; + buf.length = msgSize; + UA_StatusCode res = UA_STATUSCODE_GOOD; + if(msgSize > UA_MAX_STACKBUF) { + res = UA_ByteString_allocBuffer(&buf, msgSize); + if(res != UA_STATUSCODE_GOOD) + return res; + } + + /* Encode the message */ + UA_Byte *bufPos = buf.data; + const UA_Byte *bufEnd = &buf.data[msgSize]; + res = UA_NetworkMessage_encodeJson(&nm, &bufPos, &bufEnd, NULL, 0, NULL, 0, true); + if(res != UA_STATUSCODE_GOOD) + goto cleanup; + UA_assert(bufPos == bufEnd); + + /* Send the prepared messages */ + res = connection->channel->send(connection->channel, transportSettings, &buf); + + cleanup: + if(msgSize > UA_MAX_STACKBUF) + UA_ByteString_clear(&buf); + return res; +} +#endif + +static UA_StatusCode +generateNetworkMessage(UA_PubSubConnection *connection, UA_WriterGroup *wg, + UA_DataSetMessage *dsm, UA_UInt16 *writerIds, UA_Byte dsmCount, + UA_ExtensionObject *messageSettings, + UA_ExtensionObject *transportSettings, + UA_NetworkMessage *networkMessage) { + if(messageSettings->content.decoded.type != + &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]) + return UA_STATUSCODE_BADINTERNALERROR; + UA_UadpWriterGroupMessageDataType *wgm = (UA_UadpWriterGroupMessageDataType*) + messageSettings->content.decoded.data; + + networkMessage->publisherIdEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PUBLISHERID) != 0; + networkMessage->groupHeaderEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_GROUPHEADER) != 0; + networkMessage->groupHeader.writerGroupIdEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_WRITERGROUPID) != 0; + networkMessage->groupHeader.groupVersionEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_GROUPVERSION) != 0; + networkMessage->groupHeader.networkMessageNumberEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_NETWORKMESSAGENUMBER) != 0; + networkMessage->groupHeader.sequenceNumberEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_SEQUENCENUMBER) != 0; + networkMessage->payloadHeaderEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PAYLOADHEADER) != 0; + networkMessage->timestampEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_TIMESTAMP) != 0; + networkMessage->picosecondsEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PICOSECONDS) != 0; + networkMessage->dataSetClassIdEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_DATASETCLASSID) != 0; + networkMessage->promotedFieldsEnabled = + ((u64)wgm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PROMOTEDFIELDS) != 0; + + /* Set the SecurityHeader */ +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + if(wg->config.securityMode > UA_MESSAGESECURITYMODE_NONE) { + networkMessage->securityEnabled = true; + networkMessage->securityHeader.networkMessageSigned = true; + if(wg->config.securityMode >= UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + networkMessage->securityHeader.networkMessageEncrypted = true; + networkMessage->securityHeader.securityTokenId = wg->securityTokenId; + + /* Generate the MessageNonce */ + UA_ByteString_allocBuffer(&networkMessage->securityHeader.messageNonce, 8); + if(networkMessage->securityHeader.messageNonce.length == 0) + return UA_STATUSCODE_BADOUTOFMEMORY; + + networkMessage->securityHeader.messageNonce.length = 4; /* Generate 4 random bytes */ + UA_StatusCode rv = wg->config.securityPolicy->symmetricModule. + generateNonce(wg->config.securityPolicy->policyContext, + &networkMessage->securityHeader.messageNonce); + if(rv != UA_STATUSCODE_GOOD) + return rv; + networkMessage->securityHeader.messageNonce.length = 8; + UA_Byte *pos = &networkMessage->securityHeader.messageNonce.data[4]; + const UA_Byte *end = &networkMessage->securityHeader.messageNonce.data[8]; + UA_UInt32_encodeBinary(&wg->nonceSequenceNumber, &pos, end); + } +#endif + + networkMessage->version = 1; + networkMessage->networkMessageType = UA_NETWORKMESSAGE_DATASET; + if(connection->config->publisherIdType == UA_PUBSUB_PUBLISHERID_NUMERIC) { + networkMessage->publisherIdType = UA_PUBLISHERDATATYPE_UINT16; + networkMessage->publisherId.publisherIdUInt32 = + connection->config->publisherId.numeric; + } else if(connection->config->publisherIdType == UA_PUBSUB_PUBLISHERID_STRING) { + networkMessage->publisherIdType = UA_PUBLISHERDATATYPE_STRING; + networkMessage->publisherId.publisherIdString = + connection->config->publisherId.string; + } + + if(networkMessage->groupHeader.sequenceNumberEnabled) + networkMessage->groupHeader.sequenceNumber = wg->sequenceNumber; + + /* Compute the length of the dsm separately for the header */ + UA_UInt16 *dsmLengths = (UA_UInt16 *) UA_calloc(dsmCount, sizeof(UA_UInt16)); + if(!dsmLengths) + return UA_STATUSCODE_BADOUTOFMEMORY; + for(UA_Byte i = 0; i < dsmCount; i++) + dsmLengths[i] = (UA_UInt16) UA_DataSetMessage_calcSizeBinary(&dsm[i], NULL, 0); + + networkMessage->payloadHeader.dataSetPayloadHeader.count = dsmCount; + networkMessage->payloadHeader.dataSetPayloadHeader.dataSetWriterIds = writerIds; + networkMessage->groupHeader.writerGroupId = wg->config.writerGroupId; + /* number of the NetworkMessage inside a PublishingInterval */ + networkMessage->groupHeader.networkMessageNumber = 1; + networkMessage->payload.dataSetPayload.sizes = dsmLengths; + networkMessage->payload.dataSetPayload.dataSetMessages = dsm; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +sendNetworkMessage(UA_PubSubConnection *connection, UA_WriterGroup *wg, + UA_DataSetMessage *dsm, UA_UInt16 *writerIds, UA_Byte dsmCount, + UA_ExtensionObject *messageSettings, + UA_ExtensionObject *transportSettings) { + UA_NetworkMessage nm; + memset(&nm, 0, sizeof(UA_NetworkMessage)); + + /* Fill the message structure */ + UA_StatusCode rv = + generateNetworkMessage(connection, wg, dsm, writerIds, dsmCount, + messageSettings, transportSettings, &nm); + UA_CHECK_STATUS(rv, return rv); + + /* Compute the message size. Add the overhead for the security signature. + * There is no padding and the encryption incurs no size overhead. */ + size_t msgSize = UA_NetworkMessage_calcSizeBinary(&nm, NULL); +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + if(wg->config.securityMode > UA_MESSAGESECURITYMODE_NONE) { + UA_PubSubSecurityPolicy *sp = wg->config.securityPolicy; + msgSize += sp->symmetricModule.cryptoModule. + signatureAlgorithm.getLocalSignatureSize(sp->policyContext); + } +#endif + + /* Allocate the buffer. Allocate on the stack if the buffer is small. */ + UA_ByteString buf; + UA_Byte stackBuf[UA_MAX_STACKBUF]; + buf.data = stackBuf; + buf.length = msgSize; + if(msgSize > UA_MAX_STACKBUF) { + rv = UA_ByteString_allocBuffer(&buf, msgSize); + UA_CHECK_STATUS(rv, goto cleanup); + } + + /* Encode and encrypt the message */ + rv = encodeNetworkMessage(wg, &nm, &buf); + UA_CHECK_STATUS(rv, goto cleanup_with_msg_size); + + /* Send out the message */ + rv = connection->channel->send(connection->channel, transportSettings, &buf); + UA_CHECK_STATUS(rv, goto cleanup_with_msg_size); + +cleanup_with_msg_size: + if(msgSize > UA_MAX_STACKBUF) { + UA_ByteString_clear(&buf); + } +cleanup: + UA_ByteString_clear(&nm.securityHeader.messageNonce); + UA_free(nm.payload.dataSetPayload.sizes); + return rv; +} + +static UA_StatusCode +sendBufferedNetworkMessage(UA_Server *server, UA_PubSubConnection *connection, + UA_NetworkMessageOffsetBuffer *buffer, + UA_ExtensionObject *transportSettings) { + if(UA_NetworkMessage_updateBufferedMessage(buffer) != UA_STATUSCODE_GOOD) + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub sending. Unknown field type."); + return connection->channel->send(connection->channel, + transportSettings, &buffer->buffer); +} + +/* This callback triggers the collection and publish of NetworkMessages and the + * contained DataSetMessages. */ +void +UA_WriterGroup_publishCallback(UA_Server *server, UA_WriterGroup *writerGroup) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, "Publish Callback"); + + // TODO: review if its okay to force correct value from caller side instead + // UA_assert(writerGroup != NULL); + // UA_assert(server != NULL); + + if(!writerGroup) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Publish failed. WriterGroup not found"); + return; + } + + /* Nothing to do? */ + if(writerGroup->writersCount == 0) + return; + + /* Binary or Json encoding? */ + if(writerGroup->config.encodingMimeType != UA_PUBSUB_ENCODING_UADP && + writerGroup->config.encodingMimeType != UA_PUBSUB_ENCODING_JSON) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Publish failed: Unknown encoding type."); + UA_WriterGroup_setPubSubState(server, UA_PUBSUBSTATE_ERROR, writerGroup); + return; + } + + /* Find the connection associated with the writer */ + UA_PubSubConnection *connection = writerGroup->linkedConnection; + if(!connection) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Publish failed. PubSubConnection invalid."); + UA_WriterGroup_setPubSubState(server, UA_PUBSUBSTATE_ERROR, writerGroup); + return; + } + + if(writerGroup->config.rtLevel == UA_PUBSUB_RT_FIXED_SIZE) { + UA_StatusCode res = + sendBufferedNetworkMessage(server, connection, &writerGroup->bufferedMessage, + &writerGroup->config.transportSettings); + if(res == UA_STATUSCODE_GOOD) { + writerGroup->sequenceNumber++; + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Publish failed. RT fixed size. sendBufferedNetworkMessage failed"); + UA_WriterGroup_setPubSubState(server, UA_PUBSUBSTATE_ERROR, writerGroup); + } + return; + } + + /* How many DSM can be sent in one NM? */ + UA_Byte maxDSM = (UA_Byte)writerGroup->config.maxEncapsulatedDataSetMessageCount; + if(writerGroup->config.maxEncapsulatedDataSetMessageCount > UA_BYTE_MAX) + maxDSM = UA_BYTE_MAX; + /* If the maxEncapsulatedDataSetMessageCount is set to 0->1 */ + if(maxDSM == 0) + maxDSM = 1; + + /* It is possible to put several DataSetMessages into one NetworkMessage. + * But only if they do not contain promoted fields. NM with only DSM are + * sent out right away. The others are kept in a buffer for "batching". */ + size_t dsmCount = 0; + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_STACKARRAY(UA_UInt16, dsWriterIds, writerGroup->writersCount); + UA_STACKARRAY(UA_DataSetMessage, dsmStore, writerGroup->writersCount); + UA_DataSetWriter *dsw; + LIST_FOREACH(dsw, &writerGroup->writers, listEntry) { + if(dsw->state != UA_PUBSUBSTATE_OPERATIONAL) + continue; + + /* Find the dataset */ + UA_PublishedDataSet *pds = + UA_PublishedDataSet_findPDSbyId(server, dsw->connectedDataSet); + if(!pds) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Publish: PublishedDataSet not found"); + UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dsw); + continue; + } + + /* Generate the DSM */ + res = UA_DataSetWriter_generateDataSetMessage(server, &dsmStore[dsmCount], dsw); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Publish: DataSetMessage creation failed"); + UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dsw); + continue; + } + + /* There is no promoted field and we can batch dsm. So do the batching. */ + if(pds->promotedFieldsCount == 0 && maxDSM > 1) { + dsWriterIds[dsmCount] = dsw->config.dataSetWriterId; + dsmCount++; + continue; + } + + /* Send right away */ + if(writerGroup->config.encodingMimeType == UA_PUBSUB_ENCODING_UADP){ + res = sendNetworkMessage(connection, writerGroup, &dsmStore[dsmCount], + &dsw->config.dataSetWriterId, 1, + &writerGroup->config.messageSettings, + &writerGroup->config.transportSettings); + } else { /* if(writerGroup->config.encodingMimeType == UA_PUBSUB_ENCODING_JSON) */ +#ifdef UA_ENABLE_JSON_ENCODING + res = sendNetworkMessageJson(connection, &dsmStore[dsmCount], + &dsw->config.dataSetWriterId, 1, + &writerGroup->config.transportSettings); +#else + res = UA_STATUSCODE_BADNOTSUPPORTED; +#endif + } + + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Publish: Could not send a NetworkMessage"); + UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dsw); + } + + /* Clean up */ + if(writerGroup->config.rtLevel == UA_PUBSUB_RT_DIRECT_VALUE_ACCESS) { + for(size_t i = 0; i < dsmStore[dsmCount].data.keyFrameData.fieldCount; ++i) { + dsmStore[dsmCount].data.keyFrameData.dataSetFields[i].value.data = NULL; + } + } + UA_DataSetMessage_clear(&dsmStore[dsmCount]); + } + + /* Send the NetworkMessages with batched DataSetMessages */ + size_t i = 0; + while(i < dsmCount) { + /* How many dsm in this iteration? */ + UA_Byte nmDsmCount = maxDSM; + if(i + nmDsmCount > dsmCount) { + nmDsmCount = (UA_Byte)(dsmCount - i); + } + + if(writerGroup->config.encodingMimeType == UA_PUBSUB_ENCODING_UADP){ + res = sendNetworkMessage(connection, writerGroup, &dsmStore[i], + &dsWriterIds[i], nmDsmCount, + &writerGroup->config.messageSettings, + &writerGroup->config.transportSettings); + } else { /* if(writerGroup->config.encodingMimeType == UA_PUBSUB_ENCODING_JSON) */ +#ifdef UA_ENABLE_JSON_ENCODING + res = sendNetworkMessageJson(connection, &dsmStore[i], + &dsWriterIds[i], nmDsmCount, + &writerGroup->config.transportSettings); +#else + res = UA_STATUSCODE_BADNOTSUPPORTED; +#endif + } + + if(res == UA_STATUSCODE_GOOD) { + writerGroup->sequenceNumber++; /* TODO: Why not in the direct-send case? */ + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Publish: Sending a NetworkMessage failed"); + LIST_FOREACH(dsw, &writerGroup->writers, listEntry) { + if(dsWriterIds[i * maxDSM] != dsw->config.dataSetWriterId) + continue; + UA_DataSetWriter_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dsw); + } + } + + /* Forward the position for the next iteration */ + i += nmDsmCount; + } + + /* Clean up DSM */ + for(i = 0; i < dsmCount; i++) + UA_DataSetMessage_clear(&dsmStore[i]); +} + +/* Add new publishCallback. The first execution is triggered directly after + * creation. */ +UA_StatusCode +UA_WriterGroup_addPublishCallback(UA_Server *server, UA_WriterGroup *writerGroup) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(writerGroup->config.pubsubManagerCallback.addCustomCallback) + retval |= writerGroup->config.pubsubManagerCallback. + addCustomCallback(server, writerGroup->identifier, + (UA_ServerCallback) UA_WriterGroup_publishCallback, + writerGroup, writerGroup->config.publishingInterval, + NULL, // TODO: Send base time from writer group config + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, // TODO: Send timer policy from writer group config + &writerGroup->publishCallbackId); + else + retval |= UA_PubSubManager_addRepeatedCallback(server, + (UA_ServerCallback) UA_WriterGroup_publishCallback, + writerGroup, writerGroup->config.publishingInterval, + NULL, // TODO: Send base time from writer group config + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, // TODO: Send timer policy from writer group config + &writerGroup->publishCallbackId); + + if(retval == UA_STATUSCODE_GOOD) + writerGroup->publishCallbackIsRegistered = true; + + /* Run once after creation */ + UA_WriterGroup_publishCallback(server, writerGroup); + return retval; +} + +#endif /* UA_ENABLE_PUBSUB */ + +/**** amalgamated original file "/src/pubsub/ua_pubsub_reader.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2018 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019 Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright (c) 2019 Kalycito Infotech Private Limited + * Copyright (c) 2021 Fraunhofer IOSB (Author: Jan Hermes) + */ + + + +#ifdef UA_ENABLE_PUBSUB /* conditional compilation */ + + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL +#endif + +#ifdef UA_ENABLE_PUBSUB_DELTAFRAMES +#endif + +#ifdef UA_ENABLE_PUBSUB_BUFMALLOC +#endif + +/* This functionality of this API will be used in future to create mirror Variables - TODO */ +/* #define UA_MAX_SIZENAME 64 */ /* Max size of Qualified Name of Subscribed Variable */ + +/* Clear DataSetReader */ +static void +UA_DataSetReader_clear(UA_Server *server, UA_DataSetReader *dataSetReader); + +static void +UA_PubSubDSRDataSetField_sampleValue(UA_Server *server, UA_DataSetReader *dataSetReader, + UA_DataValue *value, UA_FieldTargetVariable *ftv) { + /* TODO: Static value source without RT information model + * This API supports only to external datasource in RT configutation + * TODO: Extend to support other configuration if required */ + + /* Get the Node */ + const UA_VariableNode *rtNode = (const UA_VariableNode *) + UA_NODESTORE_GET(server, &ftv->targetVariable.targetNodeId); + if(!rtNode) + return; + + if(rtNode->valueBackend.backendType == UA_VALUEBACKENDTYPE_EXTERNAL) { + /* Set the external source in the dataset reader config */ + ftv->externalDataValue = rtNode->valueBackend.backend.external.value; + + /* Get the value to compute the offsets */ + *value = **rtNode->valueBackend.backend.external.value; + value->value.storageType = UA_VARIANT_DATA_NODELETE; + } + + UA_NODESTORE_RELEASE(server, (const UA_Node *) rtNode); +} + +static UA_StatusCode +UA_PubSubDataSetReader_generateKeyFrameMessage(UA_Server *server, + UA_DataSetMessage *dataSetMessage, + UA_DataSetReader *dataSetReader) { + /* Prepare DataSetMessageContent */ + UA_TargetVariables *tv = &dataSetReader->config.subscribedDataSet.subscribedDataSetTarget; + dataSetMessage->header.dataSetMessageValid = true; + dataSetMessage->header.dataSetMessageType = UA_DATASETMESSAGE_DATAKEYFRAME; + dataSetMessage->data.keyFrameData.fieldCount = (UA_UInt16) tv->targetVariablesSize; + dataSetMessage->data.keyFrameData.dataSetFields = (UA_DataValue *) + UA_Array_new(tv->targetVariablesSize, &UA_TYPES[UA_TYPES_DATAVALUE]); + if(!dataSetMessage->data.keyFrameData.dataSetFields) + return UA_STATUSCODE_BADOUTOFMEMORY; + + for(size_t counter = 0; counter < tv->targetVariablesSize; counter++) { + /* Sample the value and set the source in the reader config */ + UA_DataValue *dfv = &dataSetMessage->data.keyFrameData.dataSetFields[counter]; + UA_FieldTargetVariable *ftv = &tv->targetVariables[counter]; + UA_PubSubDSRDataSetField_sampleValue(server, dataSetReader, dfv, ftv); + + /* Deactivate statuscode? */ + if(((u64)dataSetReader->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_STATUSCODE) == 0) + dfv->hasStatus = false; + + /* Deactivate timestamps */ + if(((u64)dataSetReader->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SOURCETIMESTAMP) == 0) + dfv->hasSourceTimestamp = false; + if(((u64)dataSetReader->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SOURCEPICOSECONDS) == 0) + dfv->hasSourcePicoseconds = false; + if(((u64)dataSetReader->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SERVERTIMESTAMP) == 0) + dfv->hasServerTimestamp = false; + if(((u64)dataSetReader->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_SERVERPICOSECONDS) == 0) + dfv->hasServerPicoseconds = false; + } + + return UA_STATUSCODE_GOOD; +} + +/* Generate a DataSetMessage for the given reader. */ +UA_StatusCode +UA_DataSetReader_generateDataSetMessage(UA_Server *server, + UA_DataSetMessage *dataSetMessage, + UA_DataSetReader *dataSetReader) { + /* Reset the message */ + memset(dataSetMessage, 0, sizeof(UA_DataSetMessage)); + + /* Support only for UADP configuration + * TODO: JSON encoding if UA_DataSetReader_generateDataSetMessage used other + * that RT configuration */ + + UA_ExtensionObject *settings = &dataSetReader->config.messageSettings; + if(settings->content.decoded.type != &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Only UADP encoding is supported."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + /* The configuration Flags are included inside the std. defined UA_UadpDataSetReaderMessageDataType */ + UA_UadpDataSetReaderMessageDataType defaultUadpConfiguration; + UA_UadpDataSetReaderMessageDataType *dataSetReaderMessageDataType = + (UA_UadpDataSetReaderMessageDataType*) settings->content.decoded.data; + + if(!(settings->encoding == UA_EXTENSIONOBJECT_DECODED || + settings->encoding == UA_EXTENSIONOBJECT_DECODED_NODELETE) || + !dataSetReaderMessageDataType->dataSetMessageContentMask) { + /* create default flag configuration if no dataSetMessageContentMask or even messageSettings in + * UadpDataSetWriterMessageDataType was passed in */ + memset(&defaultUadpConfiguration, 0, sizeof(UA_UadpDataSetReaderMessageDataType)); + defaultUadpConfiguration.dataSetMessageContentMask = (UA_UadpDataSetMessageContentMask) + ((u64)UA_UADPDATASETMESSAGECONTENTMASK_TIMESTAMP | + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MAJORVERSION | + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MINORVERSION); + dataSetReaderMessageDataType = &defaultUadpConfiguration; + } + + /* Sanity-test the configuration */ + if(dataSetReaderMessageDataType && + (dataSetReaderMessageDataType->networkMessageNumber != 0 || + dataSetReaderMessageDataType->dataSetOffset != 0)) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Static DSM configuration not supported. Using defaults"); + dataSetReaderMessageDataType->networkMessageNumber = 0; + dataSetReaderMessageDataType->dataSetOffset = 0; + } + + /* The field encoding depends on the flags inside the reader config. */ + if(dataSetReader->config.dataSetFieldContentMask & + (u64)UA_DATASETFIELDCONTENTMASK_RAWDATA) { + dataSetMessage->header.fieldEncoding = UA_FIELDENCODING_RAWDATA; + } else if((u64)dataSetReader->config.dataSetFieldContentMask & + ((u64)UA_DATASETFIELDCONTENTMASK_SOURCETIMESTAMP | + (u64)UA_DATASETFIELDCONTENTMASK_SERVERPICOSECONDS | + (u64)UA_DATASETFIELDCONTENTMASK_SOURCEPICOSECONDS | + (u64)UA_DATASETFIELDCONTENTMASK_STATUSCODE)) { + dataSetMessage->header.fieldEncoding = UA_FIELDENCODING_DATAVALUE; + } else { + dataSetMessage->header.fieldEncoding = UA_FIELDENCODING_VARIANT; + } + + /* Std: 'The DataSetMessageContentMask defines the flags for the content + * of the DataSetMessage header.' */ + if((u64)dataSetReaderMessageDataType->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MAJORVERSION) { + dataSetMessage->header.configVersionMajorVersionEnabled = true; + dataSetMessage->header.configVersionMajorVersion = + dataSetReader->config.dataSetMetaData.configurationVersion.majorVersion; + } + + if((u64)dataSetReaderMessageDataType->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_MINORVERSION) { + dataSetMessage->header.configVersionMinorVersionEnabled = true; + dataSetMessage->header.configVersionMinorVersion = + dataSetReader->config.dataSetMetaData.configurationVersion.minorVersion; + } + + if((u64)dataSetReaderMessageDataType->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_SEQUENCENUMBER) { + /* Will be modified when subscriber receives new nw msg */ + dataSetMessage->header.dataSetMessageSequenceNrEnabled = true; + dataSetMessage->header.dataSetMessageSequenceNr = 1; + } + + if((u64)dataSetReaderMessageDataType->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_TIMESTAMP) { + dataSetMessage->header.timestampEnabled = true; + dataSetMessage->header.timestamp = UA_DateTime_now(); + } + + /* TODO: Picoseconds resolution not supported atm */ + if((u64)dataSetReaderMessageDataType->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_PICOSECONDS) { + dataSetMessage->header.picoSecondsIncluded = false; + } + /* TODO: Statuscode not supported yet */ + if((u64)dataSetReaderMessageDataType->dataSetMessageContentMask & + (u64)UA_UADPDATASETMESSAGECONTENTMASK_STATUS) { + dataSetMessage->header.statusEnabled = false; + } + + /* Not supported for Delta frames atm */ + return UA_PubSubDataSetReader_generateKeyFrameMessage(server, dataSetMessage, dataSetReader); +} + +UA_StatusCode +UA_DataSetReader_generateNetworkMessage(UA_PubSubConnection *pubSubConnection, + UA_DataSetReader *dataSetReader, + UA_DataSetMessage *dsm, UA_UInt16 *writerId, + UA_Byte dsmCount, UA_NetworkMessage *nm) { + UA_ExtensionObject *settings = &dataSetReader->config.messageSettings; + if(settings->content.decoded.type != &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]) + return UA_STATUSCODE_BADNOTSUPPORTED; + + UA_UadpDataSetReaderMessageDataType *dsrm = + (UA_UadpDataSetReaderMessageDataType*)settings->content.decoded.data; + nm->publisherIdEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PUBLISHERID) != 0; + nm->groupHeaderEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_GROUPHEADER) != 0; + nm->groupHeader.writerGroupIdEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_WRITERGROUPID) != 0; + nm->groupHeader.groupVersionEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_GROUPVERSION) != 0; + nm->groupHeader.networkMessageNumberEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_NETWORKMESSAGENUMBER) != 0; + nm->groupHeader.sequenceNumberEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_SEQUENCENUMBER) != 0; + nm->payloadHeaderEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PAYLOADHEADER) != 0; + nm->timestampEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_TIMESTAMP) != 0; + nm->picosecondsEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PICOSECONDS) != 0; + nm->dataSetClassIdEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_DATASETCLASSID) != 0; + nm->promotedFieldsEnabled = ((u64)dsrm->networkMessageContentMask & + (u64)UA_UADPNETWORKMESSAGECONTENTMASK_PROMOTEDFIELDS) != 0; + nm->version = 1; + nm->networkMessageType = UA_NETWORKMESSAGE_DATASET; + + if(!UA_DataType_isNumeric(dataSetReader->config.publisherId.type)) + return UA_STATUSCODE_BADNOTSUPPORTED; + + switch(dataSetReader->config.publisherId.type->typeKind) { + case UA_DATATYPEKIND_BYTE: + nm->publisherIdType = UA_PUBLISHERDATATYPE_BYTE; + nm->publisherId.publisherIdByte = *(UA_Byte *) dataSetReader->config.publisherId.data; + break; + case UA_DATATYPEKIND_UINT16: + nm->publisherIdType = UA_PUBLISHERDATATYPE_UINT16; + nm->publisherId.publisherIdUInt16 = *(UA_UInt16 *) dataSetReader->config.publisherId.data; + break; + case UA_DATATYPEKIND_UINT32: + nm->publisherIdType = UA_PUBLISHERDATATYPE_UINT32; + nm->publisherId.publisherIdUInt32 = *(UA_UInt32 *) dataSetReader->config.publisherId.data; + break; + case UA_DATATYPEKIND_UINT64: + nm->publisherIdType = UA_PUBLISHERDATATYPE_UINT64; + nm->publisherId.publisherIdUInt64 = *(UA_UInt64 *) dataSetReader->config.publisherId.data; + break; + default: + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + if(nm->groupHeader.sequenceNumberEnabled) + nm->groupHeader.sequenceNumber = 1; /* Will be modified when subscriber receives new nw msg. */ + + /* Compute the length of the dsm separately for the header */ + UA_UInt16 *dsmLengths = (UA_UInt16 *) UA_calloc(dsmCount, sizeof(UA_UInt16)); + if(!dsmLengths) + return UA_STATUSCODE_BADOUTOFMEMORY; + for(UA_Byte i = 0; i < dsmCount; i++){ + dsmLengths[i] = (UA_UInt16) UA_DataSetMessage_calcSizeBinary(&dsm[i], NULL, 0); + switch(dataSetReader->config.expectedEncoding) { + case UA_PUBSUB_RT_UNKNOWN: + break; + case UA_PUBSUB_RT_VARIANT: + dsm[i].header.fieldEncoding = UA_FIELDENCODING_VARIANT; + break; + case UA_PUBSUB_RT_DATA_VALUE: + dsm[i].header.fieldEncoding = UA_FIELDENCODING_DATAVALUE; + break; + case UA_PUBSUB_RT_RAW: + dsm[i].header.fieldEncoding = UA_FIELDENCODING_RAWDATA; + break; + } + } + nm->payloadHeader.dataSetPayloadHeader.count = dsmCount; + nm->payloadHeader.dataSetPayloadHeader.dataSetWriterIds = writerId; + nm->groupHeader.writerGroupId = dataSetReader->config.writerGroupId; + nm->groupHeader.networkMessageNumber = 1; /* number of the NetworkMessage inside a PublishingInterval */ + nm->payload.dataSetPayload.sizes = dsmLengths; + nm->payload.dataSetPayload.dataSetMessages = dsm; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +checkReaderIdentifier(UA_Server *server, UA_NetworkMessage *msg, + UA_DataSetReader *reader) { + if(!msg->groupHeaderEnabled || !msg->groupHeader.writerGroupIdEnabled || + !msg->payloadHeaderEnabled) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Cannot process DataSetReader without WriterGroup" + "and DataSetWriter identifiers"); + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + + switch(msg->publisherIdType) { + case UA_PUBLISHERDATATYPE_BYTE: + if(reader->config.publisherId.type == &UA_TYPES[UA_TYPES_BYTE] && + msg->publisherIdType == UA_PUBLISHERDATATYPE_BYTE && + msg->publisherId.publisherIdByte == *(UA_Byte*)reader->config.publisherId.data) + break; + return UA_STATUSCODE_BADNOTFOUND; + case UA_PUBLISHERDATATYPE_UINT16: + if(reader->config.publisherId.type == &UA_TYPES[UA_TYPES_UINT16] && + msg->publisherIdType == UA_PUBLISHERDATATYPE_UINT16 && + msg->publisherId.publisherIdUInt16 == *(UA_UInt16*)reader->config.publisherId.data) + break; + return UA_STATUSCODE_BADNOTFOUND; + case UA_PUBLISHERDATATYPE_UINT32: + if(reader->config.publisherId.type == &UA_TYPES[UA_TYPES_UINT32] && + msg->publisherIdType == UA_PUBLISHERDATATYPE_UINT32 && + msg->publisherId.publisherIdUInt32 == *(UA_UInt32*)reader->config.publisherId.data) + break; + return UA_STATUSCODE_BADNOTFOUND; + case UA_PUBLISHERDATATYPE_UINT64: + if(reader->config.publisherId.type == &UA_TYPES[UA_TYPES_UINT64] && + msg->publisherIdType == UA_PUBLISHERDATATYPE_UINT64 && + msg->publisherId.publisherIdUInt64 == *(UA_UInt64*)reader->config.publisherId.data) + break; + return UA_STATUSCODE_BADNOTFOUND; + case UA_PUBLISHERDATATYPE_STRING: + if(reader->config.publisherId.type == &UA_TYPES[UA_TYPES_STRING] && + msg->publisherIdType == UA_PUBLISHERDATATYPE_STRING && + UA_String_equal(&msg->publisherId.publisherIdString, + (UA_String*)reader->config.publisherId.data)) + break; + return UA_STATUSCODE_BADNOTFOUND; + default: + return UA_STATUSCODE_BADNOTFOUND; + } + + if(reader->config.writerGroupId == msg->groupHeader.writerGroupId && + reader->config.dataSetWriterId == *msg->payloadHeader.dataSetPayloadHeader.dataSetWriterIds) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "DataSetReader found. Process NetworkMessage"); + return UA_STATUSCODE_GOOD; + } + + return UA_STATUSCODE_BADNOTFOUND; +} + +UA_StatusCode +UA_Server_addDataSetReader(UA_Server *server, UA_NodeId readerGroupIdentifier, + const UA_DataSetReaderConfig *dataSetReaderConfig, + UA_NodeId *readerIdentifier) { + /* Search the reader group by the given readerGroupIdentifier */ + UA_ReaderGroup *readerGroup = UA_ReaderGroup_findRGbyId(server, readerGroupIdentifier); + if(readerGroup == NULL) + return UA_STATUSCODE_BADNOTFOUND; + + if(!dataSetReaderConfig) + return UA_STATUSCODE_BADNOTFOUND; + + if(readerGroup->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Add DataSetReader failed. Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + /* Allocate memory for new DataSetReader */ + UA_DataSetReader *newDataSetReader = (UA_DataSetReader *) + UA_calloc(1, sizeof(UA_DataSetReader)); + if(!newDataSetReader) + return UA_STATUSCODE_BADOUTOFMEMORY; + + newDataSetReader->componentType = UA_PUBSUB_COMPONENT_DATASETREADER; + if(readerGroup->state == UA_PUBSUBSTATE_OPERATIONAL) { + UA_StatusCode retVal = + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_OPERATIONAL, + newDataSetReader); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Add DataSetReader failed. setPubSubState failed."); + return retVal; + } + } + + /* Copy the config into the new dataSetReader */ + UA_DataSetReaderConfig_copy(dataSetReaderConfig, &newDataSetReader->config); + newDataSetReader->linkedReaderGroup = readerGroup->identifier; + + UA_StatusCode retVal = UA_STATUSCODE_GOOD; +#ifdef UA_ENABLE_PUBSUB_MONITORING + /* create message receive timeout timer */ + retVal = server->config.pubSubConfig.monitoringInterface. + createMonitoring(server, newDataSetReader->identifier, + UA_PUBSUB_COMPONENT_DATASETREADER, + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT, + newDataSetReader, UA_DataSetReader_handleMessageReceiveTimeout); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Add DataSetReader failed. Create message receive timeout timer failed."); + UA_DataSetReaderConfig_clear(&newDataSetReader->config); + UA_free(newDataSetReader); + newDataSetReader = 0; + return retVal; + } +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + + /* Add the new reader to the group */ + LIST_INSERT_HEAD(&readerGroup->readers, newDataSetReader, listEntry); + readerGroup->readersCount++; + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + retVal = addDataSetReaderRepresentation(server, newDataSetReader); +#else + UA_PubSubManager_generateUniqueNodeId(&server->pubSubManager, + &newDataSetReader->identifier); +#endif + if(readerIdentifier) + UA_NodeId_copy(&newDataSetReader->identifier, readerIdentifier); + + return retVal; +} + +UA_StatusCode +UA_Server_removeDataSetReader(UA_Server *server, UA_NodeId readerIdentifier) { + /* Remove datasetreader given by the identifier */ + UA_DataSetReader *dsr = UA_ReaderGroup_findDSRbyId(server, readerIdentifier); + if(!dsr) + return UA_STATUSCODE_BADNOTFOUND; + + if(dsr->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove DataSetReader failed. " + "Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + removeDataSetReaderRepresentation(server, dsr); +#endif + + UA_StatusCode res = UA_STATUSCODE_GOOD; +#ifdef UA_ENABLE_PUBSUB_MONITORING + /* Stop and remove message receive timeout timer */ + if(dsr->msgRcvTimeoutTimerRunning) { + res = server->config.pubSubConfig.monitoringInterface. + stopMonitoring(server, dsr->identifier, UA_PUBSUB_COMPONENT_DATASETREADER, + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT, dsr); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove DataSetReader failed. Stop message " + "receive timeout timer of DataSetReader '%.*s' failed.", + (int) dsr->config.name.length, dsr->config.name.data); + } + } + + res |= server->config.pubSubConfig.monitoringInterface. + deleteMonitoring(server, dsr->identifier, UA_PUBSUB_COMPONENT_DATASETREADER, + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT, dsr); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove DataSetReader failed. Delete message receive " + "timeout timer of DataSetReader '%.*s' failed.", + (int) dsr->config.name.length, dsr->config.name.data); + } +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + + UA_DataSetReader_clear(server, dsr); + return res; +} + +UA_StatusCode +UA_Server_DataSetReader_updateConfig(UA_Server *server, UA_NodeId dataSetReaderIdentifier, + UA_NodeId readerGroupIdentifier, + const UA_DataSetReaderConfig *config) { + if(config == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + UA_DataSetReader *currentDataSetReader = + UA_ReaderGroup_findDSRbyId(server, dataSetReaderIdentifier); + if(!currentDataSetReader) + return UA_STATUSCODE_BADNOTFOUND; + + if(currentDataSetReader->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Update DataSetReader config failed. " + "Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + UA_ReaderGroup *currentReaderGroup = + UA_ReaderGroup_findRGbyId(server, readerGroupIdentifier); + if(currentReaderGroup->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Update DataSetReader config failed. " + "Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + /* The update functionality will be extended during the next PubSub batches. + * Currently changes for writerGroupId, dataSetWriterId and TargetVariables are possible. */ + if(currentDataSetReader->config.writerGroupId != config->writerGroupId) + currentDataSetReader->config.writerGroupId = config->writerGroupId; + + if(currentDataSetReader->config.dataSetWriterId != config->dataSetWriterId) + currentDataSetReader->config.dataSetWriterId = config->dataSetWriterId; + + if(currentDataSetReader->config.subscribedDataSetType != UA_PUBSUB_SDS_TARGET) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Unsupported SubscribedDataSetType."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + UA_TargetVariables *oldTV = + ¤tDataSetReader->config.subscribedDataSet.subscribedDataSetTarget; + const UA_TargetVariables *newTV = + &config->subscribedDataSet.subscribedDataSetTarget; + if(oldTV->targetVariablesSize == newTV->targetVariablesSize) { + for(size_t i = 0; i < config->subscribedDataSet.subscribedDataSetTarget.targetVariablesSize; i++) { + if(!UA_NodeId_equal(&oldTV->targetVariables[i].targetVariable.targetNodeId, + &newTV->targetVariables[i].targetVariable.targetNodeId)) { + UA_Server_DataSetReader_createTargetVariables(server, currentDataSetReader->identifier, + newTV->targetVariablesSize, newTV->targetVariables); + } + } + } else { + UA_Server_DataSetReader_createTargetVariables(server, currentDataSetReader->identifier, + newTV->targetVariablesSize, newTV->targetVariables); + } + + UA_StatusCode res = UA_STATUSCODE_GOOD; +#ifdef UA_ENABLE_PUBSUB_MONITORING + if(currentDataSetReader->config.messageReceiveTimeout != config->messageReceiveTimeout) { + /* Update message receive timeout timer interval */ + currentDataSetReader->config.messageReceiveTimeout = config->messageReceiveTimeout; + res = server->config.pubSubConfig.monitoringInterface. + updateMonitoringInterval(server, currentDataSetReader->identifier, + UA_PUBSUB_COMPONENT_DATASETREADER, + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT, + currentDataSetReader); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Update DataSetReader message receive timeout timer failed."); + } + } +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + return res; +} + +UA_StatusCode +UA_Server_DataSetReader_getConfig(UA_Server *server, UA_NodeId dataSetReaderIdentifier, + UA_DataSetReaderConfig *config) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + UA_DataSetReader *currentDataSetReader = + UA_ReaderGroup_findDSRbyId(server, dataSetReaderIdentifier); + if(!currentDataSetReader) + return UA_STATUSCODE_BADNOTFOUND; + + UA_DataSetReaderConfig tmpReaderConfig; + /* Deep copy of the actual config */ + UA_DataSetReaderConfig_copy(¤tDataSetReader->config, &tmpReaderConfig); + *config = tmpReaderConfig; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_DataSetReaderConfig_copy(const UA_DataSetReaderConfig *src, + UA_DataSetReaderConfig *dst) { + memset(dst, 0, sizeof(UA_DataSetReaderConfig)); + UA_StatusCode retVal = UA_String_copy(&src->name, &dst->name); + if(retVal != UA_STATUSCODE_GOOD) + return retVal; + + retVal = UA_Variant_copy(&src->publisherId, &dst->publisherId); + if(retVal != UA_STATUSCODE_GOOD) + return retVal; + + dst->writerGroupId = src->writerGroupId; + dst->dataSetWriterId = src->dataSetWriterId; + dst->expectedEncoding = src->expectedEncoding; + retVal = UA_DataSetMetaDataType_copy(&src->dataSetMetaData, &dst->dataSetMetaData); + if(retVal != UA_STATUSCODE_GOOD) + return retVal; + + dst->dataSetFieldContentMask = src->dataSetFieldContentMask; + dst->messageReceiveTimeout = src->messageReceiveTimeout; + + /* Currently memcpy is used to copy the securityParameters */ + memcpy(&dst->securityParameters, &src->securityParameters, sizeof(UA_PubSubSecurityParameters)); + retVal = UA_ExtensionObject_copy(&src->messageSettings, &dst->messageSettings); + if(retVal != UA_STATUSCODE_GOOD) + return retVal; + + retVal = UA_ExtensionObject_copy(&src->transportSettings, &dst->transportSettings); + if(retVal != UA_STATUSCODE_GOOD) + return retVal; + + if(src->subscribedDataSetType == UA_PUBSUB_SDS_TARGET) { + retVal = UA_TargetVariables_copy(&src->subscribedDataSet.subscribedDataSetTarget, + &dst->subscribedDataSet.subscribedDataSetTarget); + } + return retVal; +} + +void +UA_DataSetReaderConfig_clear(UA_DataSetReaderConfig *cfg) { + UA_String_clear(&cfg->name); + UA_Variant_clear(&cfg->publisherId); + UA_DataSetMetaDataType_clear(&cfg->dataSetMetaData); + UA_ExtensionObject_clear(&cfg->messageSettings); + UA_ExtensionObject_clear(&cfg->transportSettings); + if(cfg->subscribedDataSetType == UA_PUBSUB_SDS_TARGET) { + UA_TargetVariables_clear(&cfg->subscribedDataSet.subscribedDataSetTarget); + } +} + +UA_StatusCode +UA_Server_DataSetReader_getState(UA_Server *server, UA_NodeId dataSetReaderIdentifier, + UA_PubSubState *state) { + + if((server == NULL) || (state == NULL)) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_DataSetReader *currentDataSetReader = + UA_ReaderGroup_findDSRbyId(server, dataSetReaderIdentifier); + if(currentDataSetReader == NULL) + return UA_STATUSCODE_BADNOTFOUND; + *state = currentDataSetReader->state; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_DataSetReader_setState_disabled(UA_Server *server, UA_DataSetReader *dsr) { + UA_StatusCode ret = UA_STATUSCODE_GOOD; + switch(dsr->state) { + case UA_PUBSUBSTATE_DISABLED: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_PAUSED: + dsr->state = UA_PUBSUBSTATE_DISABLED; + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_OPERATIONAL: +#ifdef UA_ENABLE_PUBSUB_MONITORING + /* Stop MessageReceiveTimeout timer */ + if(dsr->msgRcvTimeoutTimerRunning == UA_TRUE) { + ret = server->config.pubSubConfig.monitoringInterface. + stopMonitoring(server, dsr->identifier, + UA_PUBSUB_COMPONENT_DATASETREADER, + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT, dsr); + if(ret == UA_STATUSCODE_GOOD) { + dsr->msgRcvTimeoutTimerRunning = UA_FALSE; + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Disable ReaderGroup failed. Stop message receive " + "timeout timer of DataSetReader '%.*s' failed.", + (int) dsr->config.name.length, dsr->config.name.data); + } + } +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + if(ret == UA_STATUSCODE_GOOD) + dsr->state = UA_PUBSUBSTATE_DISABLED; + return ret; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + } + return UA_STATUSCODE_BADINVALIDARGUMENT; +} + +/* State machine methods not part of the open62541 state machine API */ +UA_StatusCode +UA_DataSetReader_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_DataSetReader *dataSetReader) { + switch(state) { + case UA_PUBSUBSTATE_DISABLED: + return UA_DataSetReader_setState_disabled(server, dataSetReader); + case UA_PUBSUBSTATE_PAUSED: + return UA_STATUSCODE_BADNOTSUPPORTED; + case UA_PUBSUBSTATE_OPERATIONAL: + dataSetReader->state = UA_PUBSUBSTATE_OPERATIONAL; + break; + case UA_PUBSUBSTATE_ERROR: + dataSetReader->state = UA_PUBSUBSTATE_ERROR; + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_FieldTargetVariable_copy(const UA_FieldTargetVariable *src, UA_FieldTargetVariable *dst) { + /* Do a simple memcpy */ + memcpy(dst, src, sizeof(UA_FieldTargetVariable)); + return UA_FieldTargetDataType_copy(&src->targetVariable, &dst->targetVariable); +} + +UA_StatusCode +UA_TargetVariables_copy(const UA_TargetVariables *src, UA_TargetVariables *dst) { + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + memcpy(dst, src, sizeof(UA_TargetVariables)); + if(src->targetVariablesSize > 0) { + dst->targetVariables = (UA_FieldTargetVariable*) + UA_calloc(src->targetVariablesSize, sizeof(UA_FieldTargetVariable)); + if(!dst->targetVariables) + return UA_STATUSCODE_BADOUTOFMEMORY; + for(size_t i = 0; i < src->targetVariablesSize; i++) + retVal |= UA_FieldTargetVariable_copy(&src->targetVariables[i], &dst->targetVariables[i]); + } + return retVal; +} + +void +UA_TargetVariables_clear(UA_TargetVariables *subscribedDataSetTarget) { + for(size_t i = 0; i < subscribedDataSetTarget->targetVariablesSize; i++) { + UA_FieldTargetDataType_clear(&subscribedDataSetTarget->targetVariables[i].targetVariable); + } + if(subscribedDataSetTarget->targetVariablesSize > 0) + UA_free(subscribedDataSetTarget->targetVariables); + memset(subscribedDataSetTarget, 0, sizeof(UA_TargetVariables)); +} + +/* This Method is used to initially set the SubscribedDataSet to + * TargetVariablesType and to create the list of target Variables of a + * SubscribedDataSetType. */ +UA_StatusCode +UA_Server_DataSetReader_createTargetVariables(UA_Server *server, + UA_NodeId dataSetReaderIdentifier, + size_t targetVariablesSize, + const UA_FieldTargetVariable *targetVariables) { + UA_DataSetReader *dataSetReader = UA_ReaderGroup_findDSRbyId(server, dataSetReaderIdentifier); + if(!dataSetReader) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + if(dataSetReader->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Create Target Variables failed. Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + if(dataSetReader->config.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize > 0) + UA_TargetVariables_clear(&dataSetReader->config.subscribedDataSet.subscribedDataSetTarget); + + /* Set subscribed dataset to TargetVariableType */ + dataSetReader->config.subscribedDataSetType = UA_PUBSUB_SDS_TARGET; + UA_TargetVariables tmp; + tmp.targetVariablesSize = targetVariablesSize; + tmp.targetVariables = (UA_FieldTargetVariable*)(uintptr_t)targetVariables; + return UA_TargetVariables_copy(&tmp, &dataSetReader->config.subscribedDataSet.subscribedDataSetTarget); +} + +/* This functionality of this API will be used in future to create mirror Variables - TODO */ +/* UA_StatusCode +UA_Server_DataSetReader_createDataSetMirror(UA_Server *server, UA_String *parentObjectNodeName, + UA_NodeId dataSetReaderIdentifier) { + if((server == NULL) || (parentNode == NULL)) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_DataSetReader* pDataSetReader = UA_ReaderGroup_findDSRbyId(server, dataSetReaderIdentifier); + if(pDataSetReader == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + if(pDataSetReader->configurationFrozen) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Add Target Variables failed. Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } // TODO: Frozen configuration variable in TargetVariable structure + + UA_TargetVariables targetVars; + targetVars.targetVariablesSize = pDataSetReader->config.dataSetMetaData.fieldsSize; + targetVars.targetVariables = (UA_FieldTargetVariable *) + UA_calloc(targetVars.targetVariablesSize, sizeof(UA_FieldTargetVariable)); + + for(size_t i = 0; i < pDataSetReader->config.dataSetMetaData.fieldsSize; i++) { + UA_VariableAttributes vAttr = UA_VariableAttributes_default; + vAttr.valueRank = pDataSetReader->config.dataSetMetaData.fields[i].valueRank; + if(pDataSetReader->config.dataSetMetaData.fields[i].arrayDimensionsSize > 0) { + retval = UA_Array_copy(pDataSetReader->config.dataSetMetaData.fields[i].arrayDimensions, + pDataSetReader->config.dataSetMetaData.fields[i].arrayDimensionsSize, + (void**)&vAttr.arrayDimensions, &UA_TYPES[UA_TYPES_UINT32]); + if(retval == UA_STATUSCODE_GOOD) { + vAttr.arrayDimensionsSize = + pDataSetReader->config.dataSetMetaData.fields[i].arrayDimensionsSize; + } + + } + + vAttr.dataType = pDataSetReader->config.dataSetMetaData.fields[i].dataType; + + vAttr.accessLevel = UA_ACCESSLEVELMASK_READ; + UA_LocalizedText_copy(&pDataSetReader->config.dataSetMetaData.fields[i].description, + &vAttr.description); + UA_QualifiedName qn; + UA_QualifiedName_init(&qn); + char szTmpName[UA_MAX_SIZENAME]; + if(pDataSetReader->config.dataSetMetaData.fields[i].name.length > 0) { + UA_UInt16 slen = UA_MAX_SIZENAME -1; + vAttr.displayName.locale = UA_STRING("en-US"); + vAttr.displayName.text = pDataSetReader->config.dataSetMetaData.fields[i].name; + if(pDataSetReader->config.dataSetMetaData.fields[i].name.length < slen) { + slen = (UA_UInt16)pDataSetReader->config.dataSetMetaData.fields[i].name.length; + UA_snprintf(szTmpName, sizeof(szTmpName), "%.*s", (int)slen, + (const char*)pDataSetReader->config.dataSetMetaData.fields[i].name.data); + } + + szTmpName[slen] = '\0'; + qn = UA_QUALIFIEDNAME(1, szTmpName); + } + else { + strcpy(szTmpName, "SubscribedVariable"); + vAttr.displayName = UA_LOCALIZEDTEXT("en-US", szTmpName); + qn = UA_QUALIFIEDNAME(1, "SubscribedVariable"); + } + + // Add variable to the given parent node + UA_NodeId newNode; + retval = UA_Server_addVariableNode(server, UA_NODEID_NULL, *parentNode, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), qn, + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), + vAttr, NULL, &newNode); + if(retval == UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "addVariableNode %s succeeded", szTmpName); + } + else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "addVariableNode: error 0x%" PRIx32, retval); + } + + targetVars.targetVariables[i].targetVariable.attributeId = UA_ATTRIBUTEID_VALUE; + UA_NodeId_copy(&newNode, &targetVars.targetVariables[i].targetVariable.targetNodeId); + UA_NodeId_clear(&newNode); + if(vAttr.arrayDimensionsSize > 0) { + UA_Array_delete(vAttr.arrayDimensions, vAttr.arrayDimensionsSize, + &UA_TYPES[UA_TYPES_UINT32]); + } + } + + UA_TargetVariables_clear(&targetVars); + return retval; +}*/ + +static void +DataSetReader_processRaw(UA_Server *server, UA_ReaderGroup *rg, + UA_DataSetReader *dsr, UA_DataSetMessage* msg) { + UA_LOG_TRACE(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received RAW Frame"); + msg->data.keyFrameData.fieldCount = (UA_UInt16) + dsr->config.dataSetMetaData.fieldsSize; + + size_t offset = 0; + for(size_t i = 0; i < dsr->config.dataSetMetaData.fieldsSize; i++) { + /* TODO The datatype reference should be part of the internal + * pubsub configuration to avoid the time-expensive lookup */ + const UA_DataType *type = + UA_findDataTypeWithCustom(&dsr->config.dataSetMetaData.fields[i].dataType, + server->config.customDataTypes); + msg->data.keyFrameData.rawFields.length += type->memSize; + UA_STACKARRAY(UA_Byte, value, type->memSize); + UA_StatusCode res = + UA_decodeBinaryInternal(&msg->data.keyFrameData.rawFields, + &offset, value, type, NULL); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error during Raw-decode KeyFrame field %u: %s", + (unsigned)i, UA_StatusCode_name(res)); + return; + } + + UA_FieldTargetVariable *tv = + &dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; + + if(rg->config.rtLevel == UA_PUBSUB_RT_FIXED_SIZE) { + if (tv->beforeWrite) { + void *pData = (**tv->externalDataValue).value.data; + (**tv->externalDataValue).value.data = value; // set raw data as "preview" + tv->beforeWrite(server, + &dsr->identifier, + &dsr->linkedReaderGroup, + &dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i].targetVariable.targetNodeId, + dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i].targetVariableContext, + tv->externalDataValue); + (**tv->externalDataValue).value.data = pData; // restore previous data pointer + } + memcpy((**tv->externalDataValue).value.data, value, type->memSize); + if(tv->afterWrite) + tv->afterWrite(server, &dsr->identifier, + &dsr->linkedReaderGroup, + &tv->targetVariable.targetNodeId, + tv->targetVariableContext, + tv->externalDataValue); + continue; /* No dynamic allocation for fixed-size msg, no need to _clear */ + } + + UA_WriteValue writeVal; + UA_WriteValue_init(&writeVal); + writeVal.attributeId = tv->targetVariable.attributeId; + writeVal.indexRange = tv->targetVariable.receiverIndexRange; + writeVal.nodeId = tv->targetVariable.targetNodeId; + UA_Variant_setScalar(&writeVal.value.value, value, type); + writeVal.value.hasValue = true; + res = UA_Server_write(server, &writeVal); + UA_clear(value, type); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error writing KeyFrame field %u: %s", + (unsigned)i, UA_StatusCode_name(res)); + } + } +} + +static void +DataSetReader_processFixedSize(UA_Server *server, UA_ReaderGroup *rg, + UA_DataSetReader *dsr, UA_DataSetMessage *msg, + size_t fieldCount) { + for(size_t i = 0; i < fieldCount; i++) { + if(!msg->data.keyFrameData.dataSetFields[i].hasValue) + continue; + + UA_FieldTargetVariable *tv = + &dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; + if(tv->targetVariable.attributeId != UA_ATTRIBUTEID_VALUE) + continue; + if (tv->beforeWrite) { + UA_DataValue *tmp = &msg->data.keyFrameData.dataSetFields[i]; + tv->beforeWrite(server, + &dsr->identifier, + &dsr->linkedReaderGroup, + &dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i].targetVariable.targetNodeId, + dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i].targetVariableContext, + &tmp); + } + memcpy((**tv->externalDataValue).value.data, + msg->data.keyFrameData.dataSetFields[i].value.data, + msg->data.keyFrameData.dataSetFields[i].value.type->memSize); + if(tv->afterWrite) + tv->afterWrite(server, &dsr->identifier, &dsr->linkedReaderGroup, + &tv->targetVariable.targetNodeId, + tv->targetVariableContext, tv->externalDataValue); + } +} + +void +UA_DataSetReader_process(UA_Server *server, UA_ReaderGroup *rg, + UA_DataSetReader *dsr, UA_DataSetMessage *msg) { + if(!dsr || !rg || !msg || !server) + return; + + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "DataSetReader '%.*s': received a network message", + (int) dsr->config.name.length, dsr->config.name.data); + + if(!msg->header.dataSetMessageValid) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "DataSetMessage is discarded: message is not valid"); + /* To Do check ConfigurationVersion */ + /* if(msg->header.configVersionMajorVersionEnabled) { + * if(msg->header.configVersionMajorVersion != + * dsr->config.dataSetMetaData.configurationVersion.majorVersion) { + * UA_LOG_WARNING(server->config.logger, UA_LOGCATEGORY_SERVER, + * "DataSetMessage is discarded: ConfigurationVersion " + * "MajorVersion does not match"); + * return; + * } + * } */ + return; + } + + if(msg->header.dataSetMessageType != UA_DATASETMESSAGE_DATAKEYFRAME) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "DataSetMessage is discarded: Only keyframes are supported"); + return; + } + + /* Process message with raw encoding (realtime and non-realtime) */ + if(msg->header.fieldEncoding == UA_FIELDENCODING_RAWDATA) { + DataSetReader_processRaw(server, rg, dsr, msg); +#ifdef UA_ENABLE_PUBSUB_MONITORING + UA_DataSetReader_checkMessageReceiveTimeout(server, dsr); +#endif + return; + } + + /* Check and adjust the field count + * TODO Throw an error if non-matching? */ + size_t fieldCount = msg->data.keyFrameData.fieldCount; + if(dsr->config.dataSetMetaData.fieldsSize < fieldCount) + fieldCount = dsr->config.dataSetMetaData.fieldsSize; + + if(dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize < fieldCount) + fieldCount = dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariablesSize; + + /* Process message with fixed size fields (realtime capable) */ + if(rg->config.rtLevel == UA_PUBSUB_RT_FIXED_SIZE) { + DataSetReader_processFixedSize(server, rg, dsr, msg, fieldCount); +#ifdef UA_ENABLE_PUBSUB_MONITORING + UA_DataSetReader_checkMessageReceiveTimeout(server, dsr); +#endif + return; + } + + /* Write the message fields via the write service (non realtime) */ + UA_StatusCode res = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < fieldCount; i++) { + if(!msg->data.keyFrameData.dataSetFields[i].hasValue) + continue; + + UA_FieldTargetVariable *tv = + &dsr->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; + + UA_WriteValue writeVal; + UA_WriteValue_init(&writeVal); + writeVal.attributeId = tv->targetVariable.attributeId; + writeVal.indexRange = tv->targetVariable.receiverIndexRange; + writeVal.nodeId = tv->targetVariable.targetNodeId; + writeVal.value = msg->data.keyFrameData.dataSetFields[i]; + res = UA_Server_write(server, &writeVal); + if(res != UA_STATUSCODE_GOOD) + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error writing KeyFrame field %u: %s", + (unsigned)i, UA_StatusCode_name(res)); + } + +#ifdef UA_ENABLE_PUBSUB_MONITORING + UA_DataSetReader_checkMessageReceiveTimeout(server, dsr); +#endif +} + +#ifdef UA_ENABLE_PUBSUB_MONITORING + +void +UA_DataSetReader_checkMessageReceiveTimeout(UA_Server *server, + UA_DataSetReader *dsr) { + UA_assert(server != 0); + UA_assert(dsr != 0); + + /* If previous reader state was error (because we haven't received messages + * and ran into timeout) we should set the state back to operational */ + if(dsr->state == UA_PUBSUBSTATE_ERROR) { + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_OPERATIONAL, dsr); + if(server->config.pubSubConfig.stateChangeCallback != 0) { + server->config.pubSubConfig.stateChangeCallback(&dsr->identifier, + UA_PUBSUBSTATE_OPERATIONAL, + UA_STATUSCODE_GOOD); + } + } + + /* Stop message receive timeout timer */ + UA_StatusCode res; + if(dsr->msgRcvTimeoutTimerRunning) { + res = server->config.pubSubConfig.monitoringInterface. + stopMonitoring(server, dsr->identifier, UA_PUBSUB_COMPONENT_DATASETREADER, + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT, dsr); + if(res == UA_STATUSCODE_GOOD) { + dsr->msgRcvTimeoutTimerRunning = false; + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "DataSetReader '%.*s': stop receive timeout timer failed", + (int)dsr->config.name.length, dsr->config.name.data); + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dsr); + } + } + + /* Start message receive timeout timer */ + res = server->config.pubSubConfig.monitoringInterface. + startMonitoring(server, dsr->identifier, UA_PUBSUB_COMPONENT_DATASETREADER, + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT, dsr); + if(res == UA_STATUSCODE_GOOD) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Info: DataSetReader '%.*s': start receive timeout timer", + (int)dsr->config.name.length, dsr->config.name.data); + dsr->msgRcvTimeoutTimerRunning = true; + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Starting Message Receive Timeout timer failed."); + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dsr); + } +} + +/* Timeout callback for DataSetReader MessageReceiveTimeout handling */ +void +UA_DataSetReader_handleMessageReceiveTimeout(UA_Server *server, + void *dataSetReader) { + if(!server || !dataSetReader) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_DataSetReader_handleMessageReceiveTimeout(): " + "null pointer param"); + return; + } + + UA_DataSetReader *dsr = (UA_DataSetReader*) dataSetReader; + if(dsr->componentType != UA_PUBSUB_COMPONENT_DATASETREADER) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_DataSetReader_handleMessageReceiveTimeout(): " + "input param is not of type DataSetReader"); + return; + } + + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_DataSetReader_handleMessageReceiveTimeout(): " + "MessageReceiveTimeout occurred at DataSetReader " + "'%.*s': MessageReceiveTimeout = %f Timer Id = %u ", + (int)dsr->config.name.length, dsr->config.name.data, + dsr->config.messageReceiveTimeout, + (UA_UInt32) dsr->msgRcvTimeoutTimerId); + + UA_ServerConfig *pConfig = UA_Server_getConfig(server); + if(pConfig->pubSubConfig.stateChangeCallback != 0) { + pConfig->pubSubConfig.stateChangeCallback(&dsr->identifier, + UA_PUBSUBSTATE_ERROR, + UA_STATUSCODE_BADTIMEOUT); + } + + UA_StatusCode res = + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dsr); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_DataSetReader_handleMessageReceiveTimeout(): " + "setting pubsub state failed"); + } +} +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + +static void +UA_DataSetReader_clear(UA_Server *server, UA_DataSetReader *dsr) { + /* Delete DataSetReader config */ + UA_DataSetReaderConfig_clear(&dsr->config); + + /* Delete DataSetReader */ + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, dsr->linkedReaderGroup); + if(rg) + rg->readersCount--; + + UA_NodeId_clear(&dsr->identifier); + UA_NodeId_clear(&dsr->linkedReaderGroup); + if(dsr->config.subscribedDataSetType == UA_PUBSUB_SDS_TARGET) { + UA_TargetVariables_clear(&dsr->config.subscribedDataSet.subscribedDataSetTarget); + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_DataSetReader_clear(): unsupported subscribed dataset enum type"); + } + + /* Remove DataSetReader from group */ + LIST_REMOVE(dsr, listEntry); + + /* Free memory allocated for DataSetReader */ + UA_free(dsr); +} + +static void +processMessageWithReader(UA_Server *server, UA_ReaderGroup *readerGroup, + UA_DataSetReader *reader, UA_NetworkMessage *msg) { + UA_Byte totalDataSets = 1; + if(msg->payloadHeaderEnabled) + totalDataSets = msg->payloadHeader.dataSetPayloadHeader.count; + for(UA_Byte i = 0; i < totalDataSets; i++) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Process Msg with DataSetReader!"); + UA_DataSetReader_process(server, readerGroup, reader, + &msg->payload.dataSetPayload.dataSetMessages[i]); + } +} + +UA_StatusCode +UA_Server_processNetworkMessage(UA_Server *server, UA_PubSubConnection *connection, + UA_NetworkMessage* msg) { + if(!msg || !connection) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + /* To Do The condition pMsg->dataSetClassIdEnabled + * Here some filtering is possible */ + + if(!msg->publisherIdEnabled) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Cannot process DataSetReader without PublisherId"); + return UA_STATUSCODE_BADNOTIMPLEMENTED; /* TODO: Handle DSR without PublisherId */ + } + + /* There can be several readers listening for the same network message */ + UA_Boolean processed = false; + UA_ReaderGroup *readerGroup; + UA_DataSetReader *reader; + LIST_FOREACH(readerGroup, &connection->readerGroups, listEntry) { + LIST_FOREACH(reader, &readerGroup->readers, listEntry) { + UA_StatusCode retval = checkReaderIdentifier(server, msg, reader); + if(retval == UA_STATUSCODE_GOOD) { + processed = true; + processMessageWithReader(server, readerGroup, reader, msg); + } + } + } + + if(!processed) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Dataset reader not found. Check PublisherID, WriterGroupID " + "and DatasetWriterID"); + } + + return UA_STATUSCODE_GOOD; +} + +/******************************************************************************** + * Functionality related to decoding, decrypting and processing network messages + * as a subscriber + ********************************************************************************/ + +#define MIN_PAYLOAD_SIZE_ETHERNET 46 + +/* Delete the payload value of every decoded DataSet field */ +static void UA_DataSetMessage_freeDecodedPayload(UA_DataSetMessage *dsm) { + if(dsm->header.fieldEncoding == UA_FIELDENCODING_VARIANT) { + for(size_t i = 0; i < dsm->data.keyFrameData.fieldCount; i++) { +#ifdef UA_ENABLE_PUBSUB_BUFMALLOC + UA_Variant_init(&dsm->data.keyFrameData.dataSetFields[i].value); +#else + UA_Variant_clear(&dsm->data.keyFrameData.dataSetFields[i].value); +#endif + } + } + else if(dsm->header.fieldEncoding == UA_FIELDENCODING_DATAVALUE) { + for(size_t i = 0; i < dsm->data.keyFrameData.fieldCount; i++) { +#ifdef UA_ENABLE_PUBSUB_BUFMALLOC + UA_DataValue_init(&dsm->data.keyFrameData.dataSetFields[i]); +#else + UA_DataValue_clear(&dsm->data.keyFrameData.dataSetFields[i]); +#endif + } + } +} + +UA_StatusCode +decodeNetworkMessage(UA_Server *server, UA_ByteString *buffer, size_t *pos, + UA_NetworkMessage *nm, UA_PubSubConnection *connection) { +#ifdef UA_DEBUG_DUMP_PKGS + UA_dump_hex_pkg(buffer->data, buffer->length); +#endif + + UA_StatusCode rv = UA_NetworkMessage_decodeHeaders(buffer, pos, nm); + UA_CHECK_STATUS_ERROR(rv, return rv, + &server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub receive. decoding headers failed"); + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + UA_Boolean processed = false; + UA_ReaderGroup *readerGroup; + UA_DataSetReader *reader; + + /* Choose a correct readergroup for decrypt/verify this message + * (there could be multiple) */ + LIST_FOREACH(readerGroup, &connection->readerGroups, listEntry) { + LIST_FOREACH(reader, &readerGroup->readers, listEntry) { + UA_StatusCode retval = checkReaderIdentifier(server, nm, reader); + if(retval == UA_STATUSCODE_GOOD) { + processed = true; + rv = verifyAndDecryptNetworkMessage(&server->config.logger, buffer, pos, + nm, readerGroup); + UA_CHECK_STATUS_WARN(rv, return rv, + &server->config.logger, UA_LOGCATEGORY_SERVER, + "Subscribe failed. verify and decrypt network message failed."); + +#ifdef UA_DEBUG_DUMP_PKGS + UA_dump_hex_pkg(buffer->data, buffer->length); +#endif + /* break out of all loops when first verify & decrypt was successful */ + goto loops_exit; + } + } + } + +loops_exit: + if(!processed) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Dataset reader not found. Check PublisherId, " + "WriterGroupId and DatasetWriterId"); + /* Possible multicast scenario: there are multiple connections (with one + * or more ReaderGroups) within a multicast group every connection + * receives all network messages, even if some of them are not meant for + * the connection currently processed -> therefore it is ok if the + * connection does not have a DataSetReader for every received network + * message. We must not return an error here, but continue with the + * buffer decoding and see if we have a matching DataSetReader for the + * next network message. */ + } +#endif + + rv = UA_NetworkMessage_decodePayload(buffer, pos, nm); + UA_CHECK_STATUS(rv, return rv); + + rv = UA_NetworkMessage_decodeFooters(buffer, pos, nm); + UA_CHECK_STATUS(rv, return rv); + + return UA_STATUSCODE_GOOD; +} + +static +UA_StatusCode +decodeAndProcessNetworkMessage(UA_Server *server, UA_ReaderGroup *readerGroup, + UA_PubSubConnection *connection, + UA_ByteString *buffer) { + UA_NetworkMessage nm; + memset(&nm, 0, sizeof(UA_NetworkMessage)); + size_t currentPosition = 0; + + UA_StatusCode rv = UA_STATUSCODE_GOOD; + rv = decodeNetworkMessage(server, buffer, ¤tPosition, &nm, connection); + UA_CHECK_STATUS_WARN(rv, goto cleanup, &server->config.logger, UA_LOGCATEGORY_SERVER, + "Subscribe failed. verify, decrypt and decode network message failed."); + + rv = UA_Server_processNetworkMessage(server, connection, &nm); + // TODO: check what action to perform on error (nothing?) + UA_CHECK_STATUS_WARN(rv, (void)0, &server->config.logger, UA_LOGCATEGORY_SERVER, + "Subscribe failed. process network message failed."); + +cleanup: + UA_NetworkMessage_clear(&nm); + return rv; +} + +static +UA_StatusCode +decodeAndProcessNetworkMessageRT(UA_Server *server, UA_ReaderGroup *readerGroup, + UA_PubSubConnection *connection, + UA_ByteString *buffer) { +#ifdef UA_ENABLE_PUBSUB_BUFMALLOC + useMembufAlloc(); +#endif + + /* Considering max DSM as 1 + * TODO: Process with the static value source */ + size_t currentPosition = 0; + UA_DataSetReader *dataSetReader = LIST_FIRST(&readerGroup->readers); + UA_NetworkMessage *nm = dataSetReader->bufferedMessage.nm; + + /* Decode only the necessary offset and update the networkMessage */ + UA_StatusCode res = + UA_NetworkMessage_updateBufferedNwMessage(&dataSetReader->bufferedMessage, + buffer, ¤tPosition); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub receive. Unknown field type."); + res = UA_STATUSCODE_UNCERTAIN; + goto cleanup; + } + + /* Check the decoded message is the expected one + * TODO: PublisherID check after modification in NM to support all datatypes */ + if(nm->groupHeader.writerGroupId != dataSetReader->config.writerGroupId || + *nm->payloadHeader.dataSetPayloadHeader.dataSetWriterIds != dataSetReader->config.dataSetWriterId) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub receive. Unknown message received. Will not be processed."); + res = UA_STATUSCODE_UNCERTAIN; + goto cleanup; + } + + UA_DataSetReader_process(server, readerGroup, dataSetReader, + nm->payload.dataSetPayload.dataSetMessages); + + cleanup: + UA_DataSetMessage_freeDecodedPayload(nm->payload.dataSetPayload.dataSetMessages); +#ifdef UA_ENABLE_PUBSUB_BUFMALLOC + useNormalAlloc(); +#endif + return res; +} + +typedef struct { + UA_Server *server; + UA_PubSubConnection *connection; + UA_ReaderGroup *readerGroup; +} UA_RGContext; + +static UA_StatusCode +decodeAndProcessFun(UA_PubSubChannel *channel, void *cbContext, + const UA_ByteString *buffer) { + UA_ByteString mutableBuffer = {buffer->length, buffer->data}; + UA_RGContext *ctx = (UA_RGContext*) cbContext; + return decodeAndProcessNetworkMessage(ctx->server, ctx->readerGroup, + ctx->connection, &mutableBuffer); +} + +static UA_StatusCode +decodeAndProcessFunRT(UA_PubSubChannel *channel, void *cbContext, + const UA_ByteString *buffer) { + UA_ByteString mutableBuffer = {buffer->length, buffer->data}; + UA_RGContext *ctx = (UA_RGContext*) cbContext; + return decodeAndProcessNetworkMessageRT(ctx->server, ctx->readerGroup, + ctx->connection, &mutableBuffer); +} + +UA_StatusCode +receiveBufferedNetworkMessage(UA_Server *server, UA_ReaderGroup *readerGroup, + UA_PubSubConnection *connection) { + UA_RGContext ctx = {server, connection, readerGroup}; + UA_PubSubReceiveCallback receiveCB; + if(readerGroup->config.rtLevel == UA_PUBSUB_RT_FIXED_SIZE) + receiveCB = decodeAndProcessFunRT; + else + receiveCB = decodeAndProcessFun; + + /* TODO: Move the TransportSettings to to the readerGroupConfig. So we can + * use it here instead of a NULL pointer. */ + UA_StatusCode rv = + connection->channel->receive(connection->channel, NULL, + receiveCB, &ctx, + readerGroup->config.timeout); + + // TODO attention: here rv is ok if UA_STATUSCODE_GOOD != rv + UA_CHECK_WARN(!UA_StatusCode_isBad(rv), return rv, + &server->config.logger, UA_LOGCATEGORY_SERVER, + "SubscribeCallback(): Connection receive failed!"); + + return UA_STATUSCODE_GOOD; +} + +#endif /* UA_ENABLE_PUBSUB */ + +/**** amalgamated original file "/src/pubsub/ua_pubsub_readergroup.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2018 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019 Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright (c) 2019 Kalycito Infotech Private Limited + * Copyright (c) 2021 Fraunhofer IOSB (Author: Jan Hermes) + */ + + + +#ifdef UA_ENABLE_PUBSUB /* conditional compilation */ + + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL +#endif + +UA_ReaderGroup * +UA_ReaderGroup_findRGbyId(UA_Server *server, UA_NodeId identifier) { + UA_PubSubConnection *pubSubConnection; + TAILQ_FOREACH(pubSubConnection, &server->pubSubManager.connections, listEntry){ + UA_ReaderGroup* readerGroup = NULL; + LIST_FOREACH(readerGroup, &pubSubConnection->readerGroups, listEntry) { + if(UA_NodeId_equal(&identifier, &readerGroup->identifier)) + return readerGroup; + } + } + return NULL; +} + +UA_DataSetReader *UA_ReaderGroup_findDSRbyId(UA_Server *server, UA_NodeId identifier) { + UA_PubSubConnection *pubSubConnection; + TAILQ_FOREACH(pubSubConnection, &server->pubSubManager.connections, listEntry){ + UA_ReaderGroup* readerGroup = NULL; + LIST_FOREACH(readerGroup, &pubSubConnection->readerGroups, listEntry) { + UA_DataSetReader *tmpReader; + LIST_FOREACH(tmpReader, &readerGroup->readers, listEntry) { + if(UA_NodeId_equal(&tmpReader->identifier, &identifier)) + return tmpReader; + } + } + } + return NULL; +} + +/* Clear ReaderGroup */ +static void +UA_Server_ReaderGroup_clear(UA_Server* server, UA_ReaderGroup *readerGroup); + +/* ReaderGroup Config Handling */ + +UA_StatusCode +UA_ReaderGroupConfig_copy(const UA_ReaderGroupConfig *src, + UA_ReaderGroupConfig *dst) { + memcpy(dst, src, sizeof(UA_ReaderGroupConfig)); + + UA_StatusCode res = UA_String_copy(&src->name, &dst->name); + if(res != UA_STATUSCODE_GOOD) + return res; + + res = UA_Array_copy(src->groupProperties, src->groupPropertiesSize, + (void**)&dst->groupProperties, + &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); + if(res != UA_STATUSCODE_GOOD) { + UA_String_clear(&dst->name); + return res; + } + dst->groupPropertiesSize = src->groupPropertiesSize; + return UA_STATUSCODE_GOOD; +} + +void +UA_ReaderGroupConfig_clear(UA_ReaderGroupConfig *readerGroupConfig) { + UA_String_clear(&readerGroupConfig->name); + UA_Array_delete(readerGroupConfig->groupProperties, + readerGroupConfig->groupPropertiesSize, + &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); + readerGroupConfig->groupProperties = NULL; + readerGroupConfig->groupPropertiesSize = 0; +} + +/* ReaderGroup Lifecycle */ + +UA_StatusCode +UA_Server_addReaderGroup(UA_Server *server, UA_NodeId connectionIdentifier, + const UA_ReaderGroupConfig *readerGroupConfig, + UA_NodeId *readerGroupIdentifier) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + + /* Check for valid readergroup configuration */ + if(!readerGroupConfig) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + if(!readerGroupConfig->pubsubManagerCallback.addCustomCallback && + readerGroupConfig->enableBlockingSocket) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Adding ReaderGroup failed, blocking socket functionality " + "only supported in customcallback"); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + /* Search the connection by the given connectionIdentifier */ + UA_PubSubConnection *currentConnectionContext = + UA_PubSubConnection_findConnectionbyId(server, connectionIdentifier); + if(!currentConnectionContext) + return UA_STATUSCODE_BADNOTFOUND; + + if(currentConnectionContext->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Adding ReaderGroup failed. Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + /* Regist (bind) the connection channel if it is not already registered */ + if(!currentConnectionContext->isRegistered) { + retval |= UA_PubSubConnection_regist(server, &connectionIdentifier); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + /* Allocate memory for new reader group */ + UA_ReaderGroup *newGroup = (UA_ReaderGroup *)UA_calloc(1, sizeof(UA_ReaderGroup)); + if(!newGroup) + return UA_STATUSCODE_BADOUTOFMEMORY; + + newGroup->componentType = UA_PUBSUB_COMPONENT_READERGROUP; + /* Generate nodeid for the readergroup identifier */ + newGroup->linkedConnection = currentConnectionContext->identifier; + + /* Deep copy of the config */ + retval |= UA_ReaderGroupConfig_copy(readerGroupConfig, &newGroup->config); + /* Check user configured params and define it accordingly */ + if(newGroup->config.subscribingInterval <= 0.0) + newGroup->config.subscribingInterval = 5; // Set default to 5 ms + + if(newGroup->config.enableBlockingSocket) + newGroup->config.timeout = 0; // Set timeout to 0 for blocking socket + + if((!newGroup->config.enableBlockingSocket) && (!newGroup->config.timeout)) + newGroup->config.timeout = 1000; /* Set default to 1ms socket timeout + when non-blocking socket allows with + zero timeout */ + + LIST_INSERT_HEAD(¤tConnectionContext->readerGroups, newGroup, listEntry); + currentConnectionContext->readerGroupsSize++; + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + retval |= addReaderGroupRepresentation(server, newGroup); +#else + UA_PubSubManager_generateUniqueNodeId(&server->pubSubManager, + &newGroup->identifier); +#endif + if(readerGroupIdentifier) + UA_NodeId_copy(&newGroup->identifier, readerGroupIdentifier); + + return retval; +} + +UA_StatusCode +UA_Server_removeReaderGroup(UA_Server *server, UA_NodeId groupIdentifier) { + UA_ReaderGroup* readerGroup = + UA_ReaderGroup_findRGbyId(server, groupIdentifier); + if(readerGroup == NULL) + return UA_STATUSCODE_BADNOTFOUND; + + if(readerGroup->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove ReaderGroup failed. Subscriber configuration is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + /* Search the connection to which the given readergroup is connected to */ + UA_PubSubConnection *connection = + UA_PubSubConnection_findConnectionbyId(server, readerGroup->linkedConnection); + if(connection == NULL) + return UA_STATUSCODE_BADNOTFOUND; + + /* Unregister subscribe callback */ + if(readerGroup->state == UA_PUBSUBSTATE_OPERATIONAL) + UA_ReaderGroup_removeSubscribeCallback(server, readerGroup); + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + removeReaderGroupRepresentation(server, readerGroup); +#endif + + /* UA_Server_ReaderGroup_clear also removes itself from the list */ + UA_Server_ReaderGroup_clear(server, readerGroup); + + /* Remove readerGroup from Connection */ + LIST_REMOVE(readerGroup, listEntry); + UA_free(readerGroup); + return UA_STATUSCODE_GOOD; +} + +/* TODO: Implement +UA_StatusCode +UA_Server_ReaderGroup_updateConfig(UA_Server *server, UA_NodeId readerGroupIdentifier, + const UA_ReaderGroupConfig *config) { + return UA_STATUSCODE_BADNOTIMPLEMENTED; +} +*/ + +UA_StatusCode +UA_Server_ReaderGroup_getConfig(UA_Server *server, UA_NodeId readerGroupIdentifier, + UA_ReaderGroupConfig *config) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + /* Identify the readergroup through the readerGroupIdentifier */ + UA_ReaderGroup *currentReaderGroup = + UA_ReaderGroup_findRGbyId(server, readerGroupIdentifier); + if(!currentReaderGroup) + return UA_STATUSCODE_BADNOTFOUND; + + UA_ReaderGroupConfig tmpReaderGroupConfig; + /* deep copy of the actual config */ + UA_ReaderGroupConfig_copy(¤tReaderGroup->config, &tmpReaderGroupConfig); + *config = tmpReaderGroupConfig; + return UA_STATUSCODE_GOOD; +} + +static void +UA_Server_ReaderGroup_clear(UA_Server* server, UA_ReaderGroup *readerGroup) { + UA_ReaderGroupConfig_clear(&readerGroup->config); + UA_DataSetReader *dataSetReader; + UA_DataSetReader *tmpDataSetReader; + LIST_FOREACH_SAFE(dataSetReader, &readerGroup->readers, listEntry, tmpDataSetReader) { + UA_Server_removeDataSetReader(server, dataSetReader->identifier); + } + UA_PubSubConnection* pConn = + UA_PubSubConnection_findConnectionbyId(server, readerGroup->linkedConnection); + if(pConn != NULL) + pConn->readerGroupsSize--; + + /* Delete ReaderGroup and its members */ + UA_NodeId_clear(&readerGroup->linkedConnection); + UA_NodeId_clear(&readerGroup->identifier); + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + if(readerGroup->config.securityPolicy && readerGroup->securityPolicyContext) { + readerGroup->config.securityPolicy->deleteContext(readerGroup->securityPolicyContext); + readerGroup->securityPolicyContext = NULL; + } +#endif + + UA_ReaderGroupConfig_clear(&readerGroup->config); +} + +UA_StatusCode +UA_Server_ReaderGroup_getState(UA_Server *server, UA_NodeId readerGroupIdentifier, + UA_PubSubState *state) { + if((server == NULL) || (state == NULL)) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_ReaderGroup *currentReaderGroup = + UA_ReaderGroup_findRGbyId(server, readerGroupIdentifier); + if(!currentReaderGroup) + return UA_STATUSCODE_BADNOTFOUND; + *state = currentReaderGroup->state; + return UA_STATUSCODE_GOOD; +} + +/* ReaderGroup State */ + +static UA_StatusCode +UA_ReaderGroup_setPubSubState_disable(UA_Server *server, + UA_ReaderGroup *rg) { + UA_DataSetReader *dataSetReader; + switch(rg->state) { + case UA_PUBSUBSTATE_DISABLED: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + UA_ReaderGroup_removeSubscribeCallback(server, rg); + LIST_FOREACH(dataSetReader, &rg->readers, listEntry) { + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_DISABLED, + dataSetReader); + } + rg->state = UA_PUBSUBSTATE_DISABLED; + break; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Unknown PubSub state!"); + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_ReaderGroup_setPubSubState_paused(UA_Server *server, + UA_ReaderGroup *rg) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub state paused is unsupported at the moment!"); + switch(rg->state) { + case UA_PUBSUBSTATE_DISABLED: + break; + case UA_PUBSUBSTATE_PAUSED: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_OPERATIONAL: + break; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Unknown PubSub state!"); + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_BADNOTSUPPORTED; +} + +static UA_StatusCode +UA_ReaderGroup_setPubSubState_operational(UA_Server *server, + UA_ReaderGroup *rg) { + UA_DataSetReader *dataSetReader; + switch(rg->state) { + case UA_PUBSUBSTATE_DISABLED: + LIST_FOREACH(dataSetReader, &rg->readers, listEntry) { + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_OPERATIONAL, dataSetReader); + } + UA_ReaderGroup_addSubscribeCallback(server, rg); + rg->state = UA_PUBSUBSTATE_OPERATIONAL; + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + return UA_STATUSCODE_GOOD; + case UA_PUBSUBSTATE_ERROR: + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Unknown PubSub state!"); + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_BADNOTSUPPORTED; +} + +static UA_StatusCode +UA_ReaderGroup_setPubSubState_error(UA_Server *server, + UA_ReaderGroup *rg) { + UA_DataSetReader *dataSetReader; + switch(rg->state) { + case UA_PUBSUBSTATE_DISABLED: + break; + case UA_PUBSUBSTATE_PAUSED: + break; + case UA_PUBSUBSTATE_OPERATIONAL: + UA_ReaderGroup_removeSubscribeCallback(server, rg); + LIST_FOREACH(dataSetReader, &rg->readers, listEntry){ + UA_DataSetReader_setPubSubState(server, UA_PUBSUBSTATE_ERROR, dataSetReader); + } + break; + case UA_PUBSUBSTATE_ERROR: + return UA_STATUSCODE_GOOD; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Unknown PubSub state!"); + return UA_STATUSCODE_BADINTERNALERROR; + } + rg->state = UA_PUBSUBSTATE_ERROR; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_ReaderGroup_setPubSubState(UA_Server *server, UA_PubSubState state, + UA_ReaderGroup *readerGroup) { + switch(state) { + case UA_PUBSUBSTATE_DISABLED: + return UA_ReaderGroup_setPubSubState_disable(server, readerGroup); + case UA_PUBSUBSTATE_PAUSED: + return UA_ReaderGroup_setPubSubState_paused(server, readerGroup); + case UA_PUBSUBSTATE_OPERATIONAL: + return UA_ReaderGroup_setPubSubState_operational(server, readerGroup); + case UA_PUBSUBSTATE_ERROR: + return UA_ReaderGroup_setPubSubState_error(server, readerGroup); + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Received unknown PubSub state!"); + break; + } + return UA_STATUSCODE_BADINVALIDARGUMENT; +} + +UA_StatusCode +UA_Server_setReaderGroupOperational(UA_Server *server, const UA_NodeId readerGroupId){ + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, readerGroupId); + if(!rg) + return UA_STATUSCODE_BADNOTFOUND; + return UA_ReaderGroup_setPubSubState(server, UA_PUBSUBSTATE_OPERATIONAL, rg); +} + +UA_StatusCode +UA_Server_setReaderGroupDisabled(UA_Server *server, const UA_NodeId readerGroupId){ + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, readerGroupId); + if(!rg) + return UA_STATUSCODE_BADNOTFOUND; + return UA_ReaderGroup_setPubSubState(server, UA_PUBSUBSTATE_DISABLED, rg); +} + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION +UA_StatusCode +UA_Server_setReaderGroupEncryptionKeys(UA_Server *server, const UA_NodeId readerGroup, + UA_UInt32 securityTokenId, + const UA_ByteString signingKey, + const UA_ByteString encryptingKey, + const UA_ByteString keyNonce) { + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, readerGroup); + UA_CHECK_MEM(rg, return UA_STATUSCODE_BADNOTFOUND); + + UA_CHECK_MEM_WARN(rg->config.securityPolicy, return UA_STATUSCODE_BADINTERNALERROR, + &server->config.logger, UA_LOGCATEGORY_SERVER, + "No SecurityPolicy configured for the ReaderGroup"); + + if(securityTokenId != rg->securityTokenId) { + rg->securityTokenId = securityTokenId; + rg->nonceSequenceNumber = 1; + } + + /* Create a new context */ + if(!rg->securityPolicyContext) { + return rg->config.securityPolicy-> + newContext(rg->config.securityPolicy->policyContext, + &signingKey, &encryptingKey, &keyNonce, + &rg->securityPolicyContext); + } + + /* Update the context */ + return rg->config.securityPolicy-> + setSecurityKeys(rg->securityPolicyContext, &signingKey, + &encryptingKey, &keyNonce); +} +#endif + +/* Freezing of the configuration */ + +UA_StatusCode +UA_Server_freezeReaderGroupConfiguration(UA_Server *server, + const UA_NodeId readerGroupId) { + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, readerGroupId); + if(!rg) + return UA_STATUSCODE_BADNOTFOUND; + + /* PubSubConnection freezeCounter++ */ + UA_NodeId pubSubConnectionId = rg->linkedConnection; + UA_PubSubConnection *pubSubConnection = + UA_PubSubConnection_findConnectionbyId(server, pubSubConnectionId); + pubSubConnection->configurationFreezeCounter++; + pubSubConnection->configurationFrozen = UA_TRUE; + + /* ReaderGroup freeze */ + /* TODO: Clarify on the freeze functionality in multiple DSR, multiple + * networkMessage conf in a RG */ + rg->configurationFrozen = UA_TRUE; + + /* DataSetReader freeze */ + UA_DataSetReader *dataSetReader; + UA_UInt16 dsrCount = 0; + LIST_FOREACH(dataSetReader, &rg->readers, listEntry){ + dataSetReader->configurationFrozen = UA_TRUE; + dsrCount++; + /* TODO: Configuration frozen for subscribedDataSet once + * UA_Server_DataSetReader_addTargetVariables API modified to support + * adding target variable one by one or in a group stored in a list. */ + } + + /* Not rt, we don't have to adjust anything */ + if(rg->config.rtLevel != UA_PUBSUB_RT_FIXED_SIZE) + return UA_STATUSCODE_GOOD; + + if(dsrCount > 1) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Mutiple DSR in a readerGroup not supported in RT " + "fixed size configuration"); + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + + dataSetReader = LIST_FIRST(&rg->readers); + + /* Support only to UADP encoding */ + if(dataSetReader->config.messageSettings.content.decoded.type != + &UA_TYPES[UA_TYPES_UADPDATASETREADERMESSAGEDATATYPE]) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: Non-RT capable encoding."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + size_t fieldsSize = dataSetReader->config.dataSetMetaData.fieldsSize; + for(size_t i = 0; i < fieldsSize; i++) { + UA_FieldTargetVariable *tv = + &dataSetReader->config.subscribedDataSet.subscribedDataSetTarget.targetVariables[i]; + const UA_VariableNode *rtNode = (const UA_VariableNode *) + UA_NODESTORE_GET(server, &tv->targetVariable.targetNodeId); + if(rtNode != NULL && + rtNode->valueBackend.backendType != UA_VALUEBACKENDTYPE_EXTERNAL) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: PDS contains field " + "without external data source."); + UA_NODESTORE_RELEASE(server, (const UA_Node *) rtNode); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + UA_NODESTORE_RELEASE(server, (const UA_Node *) rtNode); + + UA_FieldMetaData *field = &dataSetReader->config.dataSetMetaData.fields[i]; + if((UA_NodeId_equal(&field->dataType, &UA_TYPES[UA_TYPES_STRING].typeId) || + UA_NodeId_equal(&field->dataType, &UA_TYPES[UA_TYPES_BYTESTRING].typeId)) && + field->maxStringLength == 0) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: " + "PDS contains String/ByteString with dynamic length."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } else if(!UA_DataType_isNumeric(UA_findDataType(&field->dataType))) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub-RT configuration fail: " + "PDS contains variable with dynamic size."); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + } + + UA_DataSetMessage *dsm = (UA_DataSetMessage *) UA_calloc(1, sizeof(UA_DataSetMessage)); + if(!dsm) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub RT Offset calculation: DSM creation failed"); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + /* Generate the DSM */ + UA_StatusCode res = UA_DataSetReader_generateDataSetMessage(server, dsm, dataSetReader); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub RT Offset calculation: DataSetMessage generation failed"); + UA_DataSetMessage_clear(dsm); + UA_free(dsm); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Generate data set messages - Considering 1 DSM as max */ + UA_UInt16 *dsWriterIds = (UA_UInt16 *)UA_calloc(1, sizeof(UA_UInt16)); + if(!dsWriterIds) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub RT Offset calculation: DataSetWriterId creation failed"); + UA_DataSetMessage_clear(dsm); + UA_free(dsm); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + *dsWriterIds = dataSetReader->config.dataSetWriterId; + + UA_NetworkMessage *networkMessage = (UA_NetworkMessage *)UA_calloc(1, sizeof(UA_NetworkMessage)); + if(!networkMessage) { + UA_free(dsWriterIds); + UA_DataSetMessage_clear(dsm); + UA_free(dsm); + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub RT Offset calculation: Network message creation failed"); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + res = UA_DataSetReader_generateNetworkMessage(pubSubConnection, dataSetReader, dsm, + dsWriterIds, 1, networkMessage); + if(res != UA_STATUSCODE_GOOD) { + UA_free(networkMessage->payload.dataSetPayload.sizes); + UA_free(networkMessage); + UA_free(dsWriterIds); + UA_DataSetMessage_clear(dsm); + UA_free(dsm); + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub RT Offset calculation: NetworkMessage generation failed"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + memset(&dataSetReader->bufferedMessage, 0, sizeof(UA_NetworkMessageOffsetBuffer)); + dataSetReader->bufferedMessage.RTsubscriberEnabled = true; + + /* Fix the offsets necessary to decode */ + UA_NetworkMessage_calcSizeBinary(networkMessage, &dataSetReader->bufferedMessage); + dataSetReader->bufferedMessage.nm = networkMessage; + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_unfreezeReaderGroupConfiguration(UA_Server *server, + const UA_NodeId readerGroupId) { + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, readerGroupId); + if(!rg) + return UA_STATUSCODE_BADNOTFOUND; + + /* PubSubConnection freezeCounter-- */ + UA_NodeId pubSubConnectionId = rg->linkedConnection; + UA_PubSubConnection *pubSubConnection = + UA_PubSubConnection_findConnectionbyId(server, pubSubConnectionId); + pubSubConnection->configurationFreezeCounter--; + if(pubSubConnection->configurationFreezeCounter == 0){ + pubSubConnection->configurationFrozen = UA_FALSE; + } + + /* ReaderGroup unfreeze */ + rg->configurationFrozen = UA_FALSE; + + /* DataSetReader unfreeze */ + UA_DataSetReader *dataSetReader; + LIST_FOREACH(dataSetReader, &rg->readers, listEntry) { + dataSetReader->configurationFrozen = UA_FALSE; + } + + if(rg->config.rtLevel != UA_PUBSUB_RT_FIXED_SIZE) + return UA_STATUSCODE_GOOD; + + dataSetReader = LIST_FIRST(&rg->readers); + if(dataSetReader->bufferedMessage.offsetsSize > 0) { + for(size_t i = 0; i < dataSetReader->bufferedMessage.offsetsSize; i++) { + UA_NetworkMessageOffset *offset = &dataSetReader->bufferedMessage.offsets[i]; + if((offset->contentType == UA_PUBSUB_OFFSETTYPE_PAYLOAD_VARIANT) || + (offset->contentType == UA_PUBSUB_OFFSETTYPE_PAYLOAD_RAW)) { + UA_DataValue_delete(offset->offsetData.value.value); + } else if(offset->contentType == UA_PUBSUB_OFFSETTYPE_NETWORKMESSAGE_FIELDENCDODING) { + offset->offsetData.value.value->value.data = NULL; + UA_DataValue_delete(offset->offsetData.value.value); + } + } + UA_free(dataSetReader->bufferedMessage.offsets); + } + + if(dataSetReader->bufferedMessage.RTsubscriberEnabled && + dataSetReader->bufferedMessage.nm) { + UA_NetworkMessage_delete(dataSetReader->bufferedMessage.nm); + UA_free(dataSetReader->bufferedMessage.nm); + } + + return UA_STATUSCODE_GOOD; +} + +/* This triggers the collection and reception of NetworkMessages and the + * contained DataSetMessages. */ +void +UA_ReaderGroup_subscribeCallback(UA_Server *server, + UA_ReaderGroup *readerGroup) { + // TODO: feedback for debug-assert vs runtime-check + UA_assert(server); + UA_assert(readerGroup); + + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub subscribe callback"); + + UA_PubSubConnection *connection = + UA_PubSubConnection_findConnectionbyId(server, readerGroup->linkedConnection); + if(!connection) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "SubscribeCallback(): Find linked connection failed"); + UA_ReaderGroup_setPubSubState(server, UA_PUBSUBSTATE_ERROR, readerGroup); + return; + } + + receiveBufferedNetworkMessage(server, readerGroup, connection); +} + +/* Add new subscribeCallback. The first execution is triggered directly after + * creation. */ +UA_StatusCode +UA_ReaderGroup_addSubscribeCallback(UA_Server *server, UA_ReaderGroup *readerGroup) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(readerGroup->config.pubsubManagerCallback.addCustomCallback) + retval = readerGroup->config.pubsubManagerCallback. + addCustomCallback(server, readerGroup->identifier, + (UA_ServerCallback)UA_ReaderGroup_subscribeCallback, + readerGroup, readerGroup->config.subscribingInterval, + NULL, // TODO: Send base time from reader group config + // TODO: Send timer policy from reader group config + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, + &readerGroup->subscribeCallbackId); + else { + if(readerGroup->config.enableBlockingSocket == UA_TRUE) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "addSubscribeCallback() failed, blocking socket " + "functionality only supported in customcallback"); + return UA_STATUSCODE_BADNOTSUPPORTED; + } + + retval = UA_PubSubManager_addRepeatedCallback(server, + (UA_ServerCallback)UA_ReaderGroup_subscribeCallback, + readerGroup, readerGroup->config.subscribingInterval, + NULL, // TODO: Send base time from reader group config + // TODO: Send timer policy from reader group config + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, + &readerGroup->subscribeCallbackId); + } + + /* Run once after creation */ + /* When using blocking socket functionality, the server mechanism might get + * blocked. It is highly recommended to use custom callback when using + * blockingsocket. */ + if(readerGroup->config.enableBlockingSocket != UA_TRUE) + UA_ReaderGroup_subscribeCallback(server, readerGroup); + + return retval; +} + +void +UA_ReaderGroup_removeSubscribeCallback(UA_Server *server, UA_ReaderGroup *readerGroup) { + if(readerGroup->config.pubsubManagerCallback.removeCustomCallback) + readerGroup->config.pubsubManagerCallback. + removeCustomCallback(server, readerGroup->identifier, + readerGroup->subscribeCallbackId); + else + UA_PubSubManager_removeRepeatedPubSubCallback(server, + readerGroup->subscribeCallbackId); +} + +#endif /* UA_ENABLE_PUBSUB */ + +/**** amalgamated original file "/src/pubsub/ua_pubsub_manager.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2019 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2018 Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + +#ifdef UA_ENABLE_PUBSUB /* conditional compilation */ + + +#define UA_DATETIMESTAMP_2000 125911584000000000 + +UA_StatusCode +UA_Server_addPubSubConnection(UA_Server *server, + const UA_PubSubConnectionConfig *connectionConfig, + UA_NodeId *connectionIdentifier) { + /* Find the matching UA_PubSubTransportLayers */ + UA_PubSubTransportLayer *tl = NULL; + for(size_t i = 0; i < server->config.pubSubConfig.transportLayersSize; i++) { + if(connectionConfig && + UA_String_equal(&server->config.pubSubConfig.transportLayers[i].transportProfileUri, + &connectionConfig->transportProfileUri)) { + tl = &server->config.pubSubConfig.transportLayers[i]; + } + } + if(!tl) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Connection creation failed. Requested transport layer not found."); + return UA_STATUSCODE_BADNOTFOUND; + } + + /* Create a copy of the connection config */ + UA_PubSubConnectionConfig *tmpConnectionConfig = (UA_PubSubConnectionConfig *) + UA_calloc(1, sizeof(UA_PubSubConnectionConfig)); + if(!tmpConnectionConfig){ + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Connection creation failed. Out of Memory."); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_StatusCode retval = UA_PubSubConnectionConfig_copy(connectionConfig, tmpConnectionConfig); + if(retval != UA_STATUSCODE_GOOD){ + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Connection creation failed. Could not copy the config."); + return retval; + } + + /* Create new connection and add to UA_PubSubManager */ + UA_PubSubConnection *newConnectionsField = (UA_PubSubConnection *) + UA_calloc(1, sizeof(UA_PubSubConnection)); + if(!newConnectionsField) { + UA_PubSubConnectionConfig_clear(tmpConnectionConfig); + UA_free(tmpConnectionConfig); + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Connection creation failed. Out of Memory."); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + newConnectionsField->componentType = UA_PUBSUB_COMPONENT_CONNECTION; + if (server->pubSubManager.connectionsSize != 0) + TAILQ_INSERT_TAIL(&server->pubSubManager.connections, newConnectionsField, listEntry); + else { + TAILQ_INIT(&server->pubSubManager.connections); + TAILQ_INSERT_HEAD(&server->pubSubManager.connections, newConnectionsField, listEntry); + } + + server->pubSubManager.connectionsSize++; + + LIST_INIT(&newConnectionsField->writerGroups); + newConnectionsField->config = tmpConnectionConfig; + + /* Open the channel */ + newConnectionsField->channel = tl->createPubSubChannel(newConnectionsField->config); + if(!newConnectionsField->channel) { + UA_PubSubConnection_clear(server, newConnectionsField); + TAILQ_REMOVE(&server->pubSubManager.connections, newConnectionsField, listEntry); + server->pubSubManager.connectionsSize--; + UA_free(newConnectionsField); + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PubSub Connection creation failed. Transport layer creation problem."); + return UA_STATUSCODE_BADINTERNALERROR; + } + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + /* Internally createa a unique id */ + addPubSubConnectionRepresentation(server, newConnectionsField); +#else + /* Create a unique NodeId that does not correspond to a Node */ + UA_PubSubManager_generateUniqueNodeId(&server->pubSubManager, + &newConnectionsField->identifier); +#endif + + if(connectionIdentifier) + UA_NodeId_copy(&newConnectionsField->identifier, connectionIdentifier); + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_removePubSubConnection(UA_Server *server, const UA_NodeId connection) { + //search the identified Connection and store the Connection index + UA_PubSubConnection *currentConnection = UA_PubSubConnection_findConnectionbyId(server, connection); + if(!currentConnection) + return UA_STATUSCODE_BADNOTFOUND; + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + removePubSubConnectionRepresentation(server, currentConnection); +#endif + server->pubSubManager.connectionsSize--; + + UA_PubSubConnection_clear(server, currentConnection); + TAILQ_REMOVE(&server->pubSubManager.connections, currentConnection, listEntry); + UA_free(currentConnection); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_PubSubConnection_regist(UA_Server *server, UA_NodeId *connectionIdentifier) { + UA_PubSubConnection *connection = + UA_PubSubConnection_findConnectionbyId(server, *connectionIdentifier); + if(!connection) + return UA_STATUSCODE_BADNOTFOUND; + + if(connection->isRegistered) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, "Connection already registered"); + return UA_STATUSCODE_GOOD; + } + + UA_StatusCode retval = connection->channel->regist(connection->channel, NULL, NULL); + if(retval != UA_STATUSCODE_GOOD) + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "register channel failed: 0x%" PRIx32 "!", retval); + + connection->isRegistered = UA_TRUE; + return retval; +} + +UA_AddPublishedDataSetResult +UA_Server_addPublishedDataSet(UA_Server *server, + const UA_PublishedDataSetConfig *publishedDataSetConfig, + UA_NodeId *pdsIdentifier) { + UA_AddPublishedDataSetResult result = {UA_STATUSCODE_BADINVALIDARGUMENT, 0, NULL, {0, 0}}; + if(!publishedDataSetConfig){ + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PublishedDataSet creation failed. No config passed in."); + return result; + } + + if(publishedDataSetConfig->publishedDataSetType != UA_PUBSUB_DATASET_PUBLISHEDITEMS){ + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PublishedDataSet creation failed. Unsupported PublishedDataSet type."); + return result; + } + + /* Create new PDS and add to UA_PubSubManager */ + UA_PublishedDataSet *newPDS = (UA_PublishedDataSet *) + UA_calloc(1, sizeof(UA_PublishedDataSet)); + if(!newPDS) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PublishedDataSet creation failed. Out of Memory."); + result.addResult = UA_STATUSCODE_BADOUTOFMEMORY; + return result; + } + TAILQ_INIT(&newPDS->fields); + + UA_PublishedDataSetConfig *newConfig = &newPDS->config; + + /* Deep copy the given connection config */ + UA_StatusCode res = UA_PublishedDataSetConfig_copy(publishedDataSetConfig, newConfig); + if(res != UA_STATUSCODE_GOOD){ + UA_free(newPDS); + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "PublishedDataSet creation failed. Configuration copy failed."); + result.addResult = UA_STATUSCODE_BADINTERNALERROR; + return result; + } + + /* TODO: Parse template config and add fields (later PubSub batch) */ + if(newConfig->publishedDataSetType == UA_PUBSUB_DATASET_PUBLISHEDITEMS_TEMPLATE) { + } + + /* Fill the DataSetMetaData */ + result.configurationVersion.majorVersion = UA_PubSubConfigurationVersionTimeDifference(); + result.configurationVersion.minorVersion = UA_PubSubConfigurationVersionTimeDifference(); + switch(newConfig->publishedDataSetType) { + case UA_PUBSUB_DATASET_PUBLISHEDEVENTS_TEMPLATE: + res = UA_STATUSCODE_BADNOTSUPPORTED; + break; + case UA_PUBSUB_DATASET_PUBLISHEDEVENTS: + res = UA_STATUSCODE_BADNOTSUPPORTED; + break; + case UA_PUBSUB_DATASET_PUBLISHEDITEMS: + newPDS->dataSetMetaData.configurationVersion.majorVersion = + UA_PubSubConfigurationVersionTimeDifference(); + newPDS->dataSetMetaData.configurationVersion.minorVersion = + UA_PubSubConfigurationVersionTimeDifference(); + newPDS->dataSetMetaData.description = UA_LOCALIZEDTEXT_ALLOC("", ""); + newPDS->dataSetMetaData.dataSetClassId = UA_GUID_NULL; + res = UA_String_copy(&newConfig->name, &newPDS->dataSetMetaData.name); + break; + case UA_PUBSUB_DATASET_PUBLISHEDITEMS_TEMPLATE: + res = UA_DataSetMetaDataType_copy(&newConfig->config.itemsTemplate.metaData, + &newPDS->dataSetMetaData); + break; + default: + res = UA_STATUSCODE_BADINTERNALERROR; + } + + /* Abort? */ + result.addResult = res; + if(result.addResult != UA_STATUSCODE_GOOD) { + UA_PublishedDataSetConfig_clear(newConfig); + UA_free(newPDS); + return result; + } + + /* Insert into the queue of the manager */ + if(server->pubSubManager.publishedDataSetsSize != 0) { + TAILQ_INSERT_TAIL(&server->pubSubManager.publishedDataSets, + newPDS, listEntry); + } else { + TAILQ_INIT(&server->pubSubManager.publishedDataSets); + TAILQ_INSERT_HEAD(&server->pubSubManager.publishedDataSets, + newPDS, listEntry); + } + server->pubSubManager.publishedDataSetsSize++; + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + /* Create representation and unique id */ + addPublishedDataItemsRepresentation(server, newPDS); +#else + /* Generate unique nodeId */ + UA_PubSubManager_generateUniqueNodeId(&server->pubSubManager, &newPDS->identifier); +#endif + if(pdsIdentifier) + UA_NodeId_copy(&newPDS->identifier, pdsIdentifier); + + return result; +} + +UA_StatusCode +UA_Server_removePublishedDataSet(UA_Server *server, const UA_NodeId pds) { + //search the identified PublishedDataSet and store the PDS index + UA_PublishedDataSet *publishedDataSet = UA_PublishedDataSet_findPDSbyId(server, pds); + if(!publishedDataSet){ + return UA_STATUSCODE_BADNOTFOUND; + } + if(publishedDataSet->configurationFrozen){ + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Remove PublishedDataSet failed. PublishedDataSet is frozen."); + return UA_STATUSCODE_BADCONFIGURATIONERROR; + } + + //search for referenced writers -> delete this writers. (Standard: writer must be connected with PDS) + UA_PubSubConnection *tmpConnectoin; + TAILQ_FOREACH(tmpConnectoin, &server->pubSubManager.connections, listEntry){ + UA_WriterGroup *writerGroup; + LIST_FOREACH(writerGroup, &tmpConnectoin->writerGroups, listEntry){ + UA_DataSetWriter *currentWriter, *tmpWriterGroup; + LIST_FOREACH_SAFE(currentWriter, &writerGroup->writers, listEntry, tmpWriterGroup){ + if(UA_NodeId_equal(¤tWriter->connectedDataSet, &publishedDataSet->identifier)){ + UA_Server_removeDataSetWriter(server, currentWriter->identifier); + } + } + } + } +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL + removePublishedDataSetRepresentation(server, publishedDataSet); +#endif + UA_PublishedDataSet_clear(server, publishedDataSet); + server->pubSubManager.publishedDataSetsSize--; + + TAILQ_REMOVE(&server->pubSubManager.publishedDataSets, publishedDataSet, listEntry); + UA_free(publishedDataSet); + return UA_STATUSCODE_GOOD; +} + +/* Calculate the time difference between current time and UTC (00:00) on January + * 1, 2000. */ +UA_UInt32 +UA_PubSubConfigurationVersionTimeDifference() { + UA_UInt32 timeDiffSince2000 = (UA_UInt32) (UA_DateTime_now() - UA_DATETIMESTAMP_2000); + return timeDiffSince2000; +} + +/* Generate a new unique NodeId. This NodeId will be used for the information + * model representation of PubSub entities. */ +#ifndef UA_ENABLE_PUBSUB_INFORMATIONMODEL +void +UA_PubSubManager_generateUniqueNodeId(UA_PubSubManager *psm, UA_NodeId *nodeId) { + *nodeId = UA_NODEID_NUMERIC(1, ++psm->uniqueIdCount); +} +#endif + +UA_Guid +UA_PubSubManager_generateUniqueGuid(UA_Server *server) { + while(true) { + UA_NodeId testId = UA_NODEID_GUID(1, UA_Guid_random()); + const UA_Node *testNode = UA_NODESTORE_GET(server, &testId); + if(!testNode) + return testId.identifier.guid; + UA_NODESTORE_RELEASE(server, testNode); + } +} + +/* Delete the current PubSub configuration including all nested members. This + * action also delete the configured PubSub transport Layers. */ +void +UA_PubSubManager_delete(UA_Server *server, UA_PubSubManager *pubSubManager) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, "PubSub cleanup was called."); + + /* Stop and unfreeze all WriterGroups */ + UA_PubSubConnection *tmpConnection; + TAILQ_FOREACH(tmpConnection, &server->pubSubManager.connections, listEntry){ + for(size_t i = 0; i < pubSubManager->connectionsSize; i++) { + UA_WriterGroup *writerGroup; + LIST_FOREACH(writerGroup, &tmpConnection->writerGroups, listEntry) { + UA_WriterGroup_setPubSubState(server, UA_PUBSUBSTATE_DISABLED, writerGroup); + UA_Server_unfreezeWriterGroupConfiguration(server, writerGroup->identifier); + } + } + } + + //free the currently configured transport layers + if(server->config.pubSubConfig.transportLayersSize > 0) { + UA_free(server->config.pubSubConfig.transportLayers); + server->config.pubSubConfig.transportLayersSize = 0; + } + + //remove Connections and WriterGroups + UA_PubSubConnection *tmpConnection1, *tmpConnection2; + TAILQ_FOREACH_SAFE(tmpConnection1, &server->pubSubManager.connections, listEntry, tmpConnection2){ + UA_Server_removePubSubConnection(server, tmpConnection1->identifier); + } + UA_PublishedDataSet *tmpPDS1, *tmpPDS2; + TAILQ_FOREACH_SAFE(tmpPDS1, &server->pubSubManager.publishedDataSets, listEntry, tmpPDS2){ + UA_Server_removePublishedDataSet(server, tmpPDS1->identifier); + } +} + +/***********************************/ +/* PubSub Jobs abstraction */ +/***********************************/ + +/* Default Timer based PubSub Callbacks */ + +UA_StatusCode +UA_PubSubManager_addRepeatedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_Double interval_ms, UA_DateTime *baseTime, + UA_TimerPolicy timerPolicy, UA_UInt64 *callbackId) { + return UA_Timer_addRepeatedCallback(&server->timer, (UA_ApplicationCallback)callback, + server, data, interval_ms, baseTime, timerPolicy, callbackId); +} + +UA_StatusCode +UA_PubSubManager_changeRepeatedCallback(UA_Server *server, UA_UInt64 callbackId, + UA_Double interval_ms, UA_DateTime *baseTime, + UA_TimerPolicy timerPolicy) { + return UA_Timer_changeRepeatedCallback(&server->timer, callbackId, interval_ms, baseTime, timerPolicy); +} + +void +UA_PubSubManager_removeRepeatedPubSubCallback(UA_Server *server, UA_UInt64 callbackId) { + UA_Timer_removeCallback(&server->timer, callbackId); +} + + +#ifdef UA_ENABLE_PUBSUB_MONITORING + +static UA_StatusCode +UA_PubSubComponent_createMonitoring(UA_Server *server, UA_NodeId Id, UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data, UA_ServerCallback callback) { + + if ((!server) || (!data)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "Error UA_PubSubComponent_createMonitoring(): " + "null pointer param"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + UA_StatusCode ret = UA_STATUSCODE_GOOD; + switch (eComponentType) { + case UA_PUBSUB_COMPONENT_DATASETREADER: { + UA_DataSetReader *reader = (UA_DataSetReader*) data; + switch (eMonitoringType) { + case UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT: + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, "UA_PubSubComponent_createMonitoring(): DataSetReader '%.*s' " + "- MessageReceiveTimeout", (UA_Int32) reader->config.name.length, reader->config.name.data); + reader->msgRcvTimeoutTimerCallback = callback; + break; + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "UA_PubSubComponent_createMonitoring(): DataSetReader '%.*s' " + "DataSetReader does not support timeout type '%i'", (UA_Int32) reader->config.name.length, reader->config.name.data, + eMonitoringType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error UA_PubSubComponent_createMonitoring(): PubSub component type '%i' is not supported", eComponentType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + return ret; +} + +static UA_StatusCode +UA_PubSubComponent_startMonitoring(UA_Server *server, UA_NodeId Id, UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data) { + + if ((!server) || (!data)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "Error UA_PubSubComponent_startMonitoring(): " + "null pointer param"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode ret = UA_STATUSCODE_GOOD; + switch (eComponentType) { + case UA_PUBSUB_COMPONENT_DATASETREADER: { + UA_DataSetReader *reader = (UA_DataSetReader*) data; + switch (eMonitoringType) { + case UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT: { + /* use a timed callback, because one notification is enough, + we assume that MessageReceiveTimeout configuration is in [ms], we do not handle or check fractions */ + UA_UInt64 interval = (UA_UInt64)(reader->config.messageReceiveTimeout * UA_DATETIME_MSEC); + ret = UA_Timer_addTimedCallback(&server->timer, (UA_ApplicationCallback) reader->msgRcvTimeoutTimerCallback, + server, reader, UA_DateTime_nowMonotonic() + (UA_DateTime) interval, &(reader->msgRcvTimeoutTimerId)); + if (ret == UA_STATUSCODE_GOOD) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_PubSubComponent_startMonitoring(): DataSetReader '%.*s'- MessageReceiveTimeout: MessageReceiveTimeout = '%f' " + "Timer Id = '%u'", (UA_Int32) reader->config.name.length, reader->config.name.data, + reader->config.messageReceiveTimeout, (UA_UInt32) reader->msgRcvTimeoutTimerId); + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error UA_PubSubComponent_startMonitoring(): DataSetReader '%.*s' - MessageReceiveTimeout: start timer failed", + (UA_Int32) reader->config.name.length, reader->config.name.data); + } + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "UA_PubSubComponent_startMonitoring(): DataSetReader '%.*s' " + "DataSetReader does not support timeout type '%i'", (UA_Int32) reader->config.name.length, reader->config.name.data, + eMonitoringType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error UA_PubSubComponent_startMonitoring(): PubSub component type '%i' is not supported", eComponentType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + return ret; +} + +static UA_StatusCode +UA_PubSubComponent_stopMonitoring(UA_Server *server, UA_NodeId Id, UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data) { + + if ((!server) || (!data)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "Error UA_PubSubComponent_stopMonitoring(): " + "null pointer param"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode ret = UA_STATUSCODE_GOOD; + switch (eComponentType) { + case UA_PUBSUB_COMPONENT_DATASETREADER: { + UA_DataSetReader *reader = (UA_DataSetReader*) data; + switch (eMonitoringType) { + case UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT: { + UA_Timer_removeCallback(&server->timer, reader->msgRcvTimeoutTimerId); + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_PubSubComponent_stopMonitoring(): DataSetReader '%.*s' - MessageReceiveTimeout: MessageReceiveTimeout = '%f' " + "Timer Id = '%u'", (UA_Int32) reader->config.name.length, reader->config.name.data, + reader->config.messageReceiveTimeout, (UA_UInt32) reader->msgRcvTimeoutTimerId); + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "UA_PubSubComponent_stopMonitoring(): DataSetReader '%.*s' " + "DataSetReader does not support timeout type '%i'", (UA_Int32) reader->config.name.length, reader->config.name.data, + eMonitoringType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error UA_PubSubComponent_stopMonitoring(): PubSub component type '%i' is not supported", eComponentType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + return ret; +} + +static UA_StatusCode +UA_PubSubComponent_updateMonitoringInterval(UA_Server *server, UA_NodeId Id, UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data) +{ + if ((!server) || (!data)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "Error UA_PubSubComponent_updateMonitoringInterval(): " + "null pointer param"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + UA_StatusCode ret = UA_STATUSCODE_GOOD; + switch (eComponentType) { + case UA_PUBSUB_COMPONENT_DATASETREADER: { + UA_DataSetReader *reader = (UA_DataSetReader*) data; + switch (eMonitoringType) { + case UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT: { + ret = UA_Timer_changeRepeatedCallback(&server->timer, reader->msgRcvTimeoutTimerId, + reader->config.messageReceiveTimeout, NULL, + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME); + if (ret == UA_STATUSCODE_GOOD) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_PubSubComponent_updateMonitoringInterval(): DataSetReader '%.*s' - MessageReceiveTimeout: new MessageReceiveTimeout = '%f' " + "Timer Id = '%u'", (UA_Int32) reader->config.name.length, reader->config.name.data, + reader->config.messageReceiveTimeout, (UA_UInt32) reader->msgRcvTimeoutTimerId); + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error UA_PubSubComponent_updateMonitoringInterval(): DataSetReader '%.*s': update timer interval failed", + (UA_Int32) reader->config.name.length, reader->config.name.data); + } + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "UA_PubSubComponent_createMonitoring(): DataSetReader '%.*s' " + "DataSetReader does not support timeout type '%i'", (UA_Int32) reader->config.name.length, reader->config.name.data, + eMonitoringType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error UA_PubSubComponent_updateMonitoringInterval(): PubSub component type '%i' is not supported", eComponentType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + return ret; +} + +static UA_StatusCode +UA_PubSubComponent_deleteMonitoring(UA_Server *server, UA_NodeId Id, UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data) { + + if ((!server) || (!data)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "Error UA_PubSubComponent_deleteMonitoring(): " + "null pointer param"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + UA_StatusCode ret = UA_STATUSCODE_GOOD; + switch (eComponentType) { + case UA_PUBSUB_COMPONENT_DATASETREADER: { + UA_DataSetReader *reader = (UA_DataSetReader*) data; + switch (eMonitoringType) { + case UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT: + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "UA_PubSubComponent_deleteMonitoring(): DataSetReader '%.*s' - MessageReceiveTimeout: Timer Id = '%u'", + (UA_Int32) reader->config.name.length, reader->config.name.data, (UA_UInt32) reader->msgRcvTimeoutTimerId); + break; + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "UA_PubSubComponent_deleteMonitoring(): DataSetReader '%.*s' " + "DataSetReader does not support timeout type '%i'", (UA_Int32) reader->config.name.length, reader->config.name.data, + eMonitoringType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + break; + } + default: + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Error UA_PubSubComponent_deleteMonitoring(): PubSub component type '%i' is not supported", eComponentType); + ret = UA_STATUSCODE_BADNOTSUPPORTED; + break; + } + return ret; +} + +UA_StatusCode +UA_PubSubManager_setDefaultMonitoringCallbacks(UA_PubSubMonitoringInterface *monitoringInterface) { + if (monitoringInterface == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + monitoringInterface->createMonitoring = UA_PubSubComponent_createMonitoring; + monitoringInterface->startMonitoring = UA_PubSubComponent_startMonitoring; + monitoringInterface->stopMonitoring = UA_PubSubComponent_stopMonitoring; + monitoringInterface->updateMonitoringInterval = UA_PubSubComponent_updateMonitoringInterval; + monitoringInterface->deleteMonitoring = UA_PubSubComponent_deleteMonitoring; + return UA_STATUSCODE_GOOD; +} + +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + +#endif /* UA_ENABLE_PUBSUB */ + +/**** amalgamated original file "/src/pubsub/ua_pubsub_ns0.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2018 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019-2021 Kalycito Infotech Private Limited + * Copyright (c) 2020 Yannick Wallerer, Siemens AG + * Copyright (c) 2020 Thomas Fischer, Siemens AG + */ + + +#ifdef UA_ENABLE_PUBSUB_FILE_CONFIG +#endif + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL /* conditional compilation */ + +typedef struct { + UA_NodeId parentNodeId; + UA_UInt32 parentClassifier; + UA_UInt32 elementClassiefier; +} UA_NodePropertyContext; + +static UA_StatusCode +writePubSubNs0VariableArray(UA_Server *server, UA_UInt32 id, void *v, + size_t length, const UA_DataType *type) { + UA_Variant var; + UA_Variant_init(&var); + UA_Variant_setArray(&var, v, length, type); + return UA_Server_writeValue(server, UA_NODEID_NUMERIC(0, id), var); +} + +static UA_NodeId +findSingleChildNode(UA_Server *server, UA_QualifiedName targetName, + UA_NodeId referenceTypeId, UA_NodeId startingNode){ + UA_NodeId resultNodeId; + UA_RelativePathElement rpe; + UA_RelativePathElement_init(&rpe); + rpe.referenceTypeId = referenceTypeId; + rpe.isInverse = false; + rpe.includeSubtypes = false; + rpe.targetName = targetName; + UA_BrowsePath bp; + UA_BrowsePath_init(&bp); + bp.startingNode = startingNode; + bp.relativePath.elementsSize = 1; + bp.relativePath.elements = &rpe; + UA_BrowsePathResult bpr = UA_Server_translateBrowsePathToNodeIds(server, &bp); + if(bpr.statusCode != UA_STATUSCODE_GOOD || + bpr.targetsSize < 1) + return UA_NODEID_NULL; + UA_StatusCode res = UA_NodeId_copy(&bpr.targets[0].targetId.nodeId, &resultNodeId); + if(res != UA_STATUSCODE_GOOD){ + UA_BrowsePathResult_clear(&bpr); + return UA_NODEID_NULL; + } + UA_BrowsePathResult_clear(&bpr); + return resultNodeId; +} + +static void +onRead(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeid, void *context, + const UA_NumericRange *range, const UA_DataValue *data) { + UA_Variant value; + UA_Variant_init(&value); + const UA_NodePropertyContext *nodeContext = (const UA_NodePropertyContext*)context; + const UA_NodeId *myNodeId = &nodeContext->parentNodeId; + + switch(nodeContext->parentClassifier){ + case UA_NS0ID_PUBSUBCONNECTIONTYPE: { + UA_PubSubConnection *pubSubConnection = + UA_PubSubConnection_findConnectionbyId(server, *myNodeId); + switch(nodeContext->elementClassiefier) { + case UA_NS0ID_PUBSUBCONNECTIONTYPE_PUBLISHERID: + if(pubSubConnection->config->publisherIdType == UA_PUBSUB_PUBLISHERID_STRING) { + UA_Variant_setScalar(&value, &pubSubConnection->config->publisherId.numeric, + &UA_TYPES[UA_TYPES_STRING]); + } else { + UA_Variant_setScalar(&value, &pubSubConnection->config->publisherId.numeric, + &UA_TYPES[UA_TYPES_UINT32]); + } + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Read error! Unknown property."); + } + break; + } + case UA_NS0ID_DATASETREADERTYPE: { + UA_DataSetReader *dataSetReader = UA_ReaderGroup_findDSRbyId(server, *myNodeId); + if(!dataSetReader) + return; + + switch(nodeContext->elementClassiefier) { + case UA_NS0ID_DATASETREADERTYPE_PUBLISHERID: + UA_Variant_setScalar(&value, dataSetReader->config.publisherId.data, + dataSetReader->config.publisherId.type); + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Read error! Unknown property."); + } + break; + } + case UA_NS0ID_WRITERGROUPTYPE: { + UA_WriterGroup *writerGroup = UA_WriterGroup_findWGbyId(server, *myNodeId); + if(!writerGroup) + return; + switch(nodeContext->elementClassiefier){ + case UA_NS0ID_WRITERGROUPTYPE_PUBLISHINGINTERVAL: + UA_Variant_setScalar(&value, &writerGroup->config.publishingInterval, + &UA_TYPES[UA_TYPES_DURATION]); + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Read error! Unknown property."); + } + break; + } + case UA_NS0ID_DATASETWRITERTYPE: { + UA_DataSetWriter *dataSetWriter = UA_DataSetWriter_findDSWbyId(server, *myNodeId); + if(!dataSetWriter) + return; + + switch(nodeContext->elementClassiefier) { + case UA_NS0ID_DATASETWRITERTYPE_DATASETWRITERID: + UA_Variant_setScalar(&value, &dataSetWriter->config.dataSetWriterId, + &UA_TYPES[UA_TYPES_UINT16]); + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Read error! Unknown property."); + } + break; + } + case UA_NS0ID_PUBLISHEDDATAITEMSTYPE: { + UA_PublishedDataSet *publishedDataSet = UA_PublishedDataSet_findPDSbyId(server, *myNodeId); + if(!publishedDataSet) + return; + switch(nodeContext->elementClassiefier) { + case UA_NS0ID_PUBLISHEDDATAITEMSTYPE_PUBLISHEDDATA: { + UA_PublishedVariableDataType *pvd = (UA_PublishedVariableDataType *) + UA_calloc(publishedDataSet->fieldSize, sizeof(UA_PublishedVariableDataType)); + size_t counter = 0; + UA_DataSetField *field; + TAILQ_FOREACH(field, &publishedDataSet->fields, listEntry) { + pvd[counter].attributeId = UA_ATTRIBUTEID_VALUE; + pvd[counter].publishedVariable = field->config.field.variable.publishParameters.publishedVariable; + //UA_NodeId_copy(&field->config.field.variable.publishParameters.publishedVariable, &pvd[counter].publishedVariable); + counter++; + } + UA_Variant_setArray(&value, pvd, publishedDataSet->fieldSize, + &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]); + break; + } + case UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETMETADATA: { + UA_Variant_setScalarCopy(&value, &publishedDataSet->dataSetMetaData, &UA_TYPES[UA_TYPES_DATASETMETADATATYPE]); + break; + } + case UA_NS0ID_PUBLISHEDDATAITEMSTYPE_CONFIGURATIONVERSION: { + UA_Variant_setScalarCopy(&value, &publishedDataSet->dataSetMetaData.configurationVersion, + &UA_TYPES[UA_TYPES_CONFIGURATIONVERSIONDATATYPE]); + break; + } + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Read error! Unknown property."); + } + break; + } + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Read error! Unknown parent element."); + } + UA_Server_writeValue(server, *nodeid, value); +} + +static void +onWrite(UA_Server *server, const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext, + const UA_NumericRange *range, const UA_DataValue *data){ + UA_Variant value; + UA_NodeId myNodeId; + UA_WriterGroup *writerGroup = NULL; + switch(((UA_NodePropertyContext *) nodeContext)->parentClassifier){ + case UA_NS0ID_PUBSUBCONNECTIONTYPE: + //no runtime writable attributes + break; + case UA_NS0ID_WRITERGROUPTYPE: + myNodeId = ((UA_NodePropertyContext *) nodeContext)->parentNodeId; + writerGroup = UA_WriterGroup_findWGbyId(server, myNodeId); + UA_WriterGroupConfig writerGroupConfig; + memset(&writerGroupConfig, 0, sizeof(writerGroupConfig)); + if(!writerGroup) + return; + switch(((UA_NodePropertyContext *) nodeContext)->elementClassiefier){ + case UA_NS0ID_WRITERGROUPTYPE_PUBLISHINGINTERVAL: + UA_Server_getWriterGroupConfig(server, writerGroup->identifier, &writerGroupConfig); + writerGroupConfig.publishingInterval = *((UA_Duration *) data->value.data); + UA_Server_updateWriterGroupConfig(server, writerGroup->identifier, &writerGroupConfig); + UA_Variant_setScalar(&value, data->value.data, &UA_TYPES[UA_TYPES_DURATION]); + UA_WriterGroupConfig_clear(&writerGroupConfig); + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Write error! Unknown property element."); + } + break; + default: + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Read error! Unknown parent element."); + } +} + +static UA_StatusCode +addVariableValueSource(UA_Server *server, UA_ValueCallback valueCallback, + UA_NodeId node, UA_NodePropertyContext *context){ + UA_Server_setNodeContext(server, node, context); + return UA_Server_setVariableNode_valueCallback(server, node, valueCallback); +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addPubSubConnectionConfig(UA_Server *server, UA_PubSubConnectionDataType *pubsubConnectionDataType, + UA_NodeId *connectionId){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_NetworkAddressUrlDataType networkAddressUrlDataType; + memset(&networkAddressUrlDataType, 0, sizeof(networkAddressUrlDataType)); + UA_ExtensionObject eo = pubsubConnectionDataType->address; + if(eo.encoding == UA_EXTENSIONOBJECT_DECODED){ + if(eo.content.decoded.type == &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]){ + if(UA_NetworkAddressUrlDataType_copy((UA_NetworkAddressUrlDataType *) eo.content.decoded.data, + &networkAddressUrlDataType) != UA_STATUSCODE_GOOD){ + return UA_STATUSCODE_BADOUTOFMEMORY; + } + } + } + + UA_PubSubConnectionConfig connectionConfig; + memset(&connectionConfig, 0, sizeof(UA_PubSubConnectionConfig)); + connectionConfig.transportProfileUri = pubsubConnectionDataType->transportProfileUri; + connectionConfig.name = pubsubConnectionDataType->name; + //TODO set real connection state + connectionConfig.enabled = pubsubConnectionDataType->enabled; + //connectionConfig.enabled = pubSubConnectionDataType.enabled; + UA_Variant_setScalar(&connectionConfig.address, &networkAddressUrlDataType, + &UA_TYPES[UA_TYPES_NETWORKADDRESSURLDATATYPE]); + if(pubsubConnectionDataType->publisherId.type == &UA_TYPES[UA_TYPES_UINT32]){ + connectionConfig.publisherId.numeric = * ((UA_UInt32 *) pubsubConnectionDataType->publisherId.data); + } else if(pubsubConnectionDataType->publisherId.type == &UA_TYPES[UA_TYPES_STRING]){ + connectionConfig.publisherIdType = UA_PUBSUB_PUBLISHERID_STRING; + UA_String_copy((UA_String *) pubsubConnectionDataType->publisherId.data, &connectionConfig.publisherId.string); + } else { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, "Unsupported PublisherId Type used."); + //TODO what's the best default behaviour here? + connectionConfig.publisherId.numeric = 0; + } + + retVal |= UA_Server_addPubSubConnection(server, &connectionConfig, connectionId); + UA_NetworkAddressUrlDataType_clear(&networkAddressUrlDataType); + return retVal; +} + +/** + * **WriterGroup handling** + * + * The WriterGroup (WG) is part of the connection and contains the primary + * configuration parameters for the message creation. */ +static UA_StatusCode +addWriterGroupConfig(UA_Server *server, UA_NodeId connectionId, + UA_WriterGroupDataType *writerGroupDataType, UA_NodeId *writerGroupId){ + /* Now we create a new WriterGroupConfig and add the group to the existing + * PubSubConnection. */ + UA_WriterGroupConfig writerGroupConfig; + memset(&writerGroupConfig, 0, sizeof(UA_WriterGroupConfig)); + writerGroupConfig.name = writerGroupDataType->name; + writerGroupConfig.publishingInterval = writerGroupDataType->publishingInterval; + writerGroupConfig.enabled = writerGroupDataType->enabled; + writerGroupConfig.writerGroupId = writerGroupDataType->writerGroupId; + //TODO remove hard coded UADP + writerGroupConfig.encodingMimeType = UA_PUBSUB_ENCODING_UADP; + writerGroupConfig.priority = writerGroupDataType->priority; + + UA_UadpWriterGroupMessageDataType writerGroupMessage; + UA_ExtensionObject *eoWG = &writerGroupDataType->messageSettings; + if(eoWG->encoding == UA_EXTENSIONOBJECT_DECODED){ + writerGroupConfig.messageSettings.encoding = UA_EXTENSIONOBJECT_DECODED; + if(eoWG->content.decoded.type == &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]){ + if(UA_UadpWriterGroupMessageDataType_copy((UA_UadpWriterGroupMessageDataType *) eoWG->content.decoded.data, + &writerGroupMessage) != UA_STATUSCODE_GOOD){ + return UA_STATUSCODE_BADOUTOFMEMORY; + } + writerGroupConfig.messageSettings.content.decoded.type = &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]; + writerGroupConfig.messageSettings.content.decoded.data = &writerGroupMessage; + } + } + + return UA_Server_addWriterGroup(server, connectionId, &writerGroupConfig, writerGroupId); +} + +/** + * **DataSetWriter handling** + * + * A DataSetWriter (DSW) is the glue between the WG and the PDS. The DSW is + * linked to exactly one PDS and contains additional informations for the + * message generation. */ +static UA_StatusCode +addDataSetWriterConfig(UA_Server *server, const UA_NodeId *writerGroupId, + UA_DataSetWriterDataType *dataSetWriterDataType, + UA_NodeId *dataSetWriterId) { + UA_NodeId publishedDataSetId = UA_NODEID_NULL; + UA_PublishedDataSet *tmpPDS; + TAILQ_FOREACH(tmpPDS, &server->pubSubManager.publishedDataSets, listEntry){ + if(UA_String_equal(&dataSetWriterDataType->dataSetName, &tmpPDS->config.name)) { + publishedDataSetId = tmpPDS->identifier; + break; + } + } + + if(UA_NodeId_isNull(&publishedDataSetId)) + return UA_STATUSCODE_BADPARENTNODEIDINVALID; + + /* We need now a DataSetWriter within the WriterGroup. This means we must + * create a new DataSetWriterConfig and add call the addWriterGroup function. */ + UA_DataSetWriterConfig dataSetWriterConfig; + memset(&dataSetWriterConfig, 0, sizeof(UA_DataSetWriterConfig)); + dataSetWriterConfig.name = dataSetWriterDataType->name; + dataSetWriterConfig.dataSetWriterId = dataSetWriterDataType->dataSetWriterId; + dataSetWriterConfig.keyFrameCount = dataSetWriterDataType->keyFrameCount; + dataSetWriterConfig.dataSetFieldContentMask = dataSetWriterDataType->dataSetFieldContentMask; + return UA_Server_addDataSetWriter(server, *writerGroupId, publishedDataSetId, + &dataSetWriterConfig, dataSetWriterId); +} + +/** + * **ReaderGroup** + * + * ReaderGroup is used to group a list of DataSetReaders. All ReaderGroups are + * created within a PubSubConnection and automatically deleted if the connection + * is removed. All network message related filters are only available in the DataSetReader. */ +/* Add ReaderGroup to the created connection */ +static UA_StatusCode +addReaderGroupConfig(UA_Server *server, UA_NodeId connectionId, + UA_ReaderGroupDataType *readerGroupDataType, + UA_NodeId *readerGroupId) { + UA_ReaderGroupConfig readerGroupConfig; + memset(&readerGroupConfig, 0, sizeof(UA_ReaderGroupConfig)); + readerGroupConfig.name = readerGroupDataType->name; + return UA_Server_addReaderGroup(server, connectionId, + &readerGroupConfig, readerGroupId); +} + +/** + * **SubscribedDataSet** + * + * Set SubscribedDataSet type to TargetVariables data type. + * Add subscribedvariables to the DataSetReader */ +static UA_StatusCode +addSubscribedVariables(UA_Server *server, UA_NodeId dataSetReaderId, + UA_DataSetReaderDataType *dataSetReaderDataType, + UA_DataSetMetaDataType *pMetaData) { + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_TargetVariablesDataType targetVars; + UA_ExtensionObject *eoTargetVar = &dataSetReaderDataType->subscribedDataSet; + if(eoTargetVar->encoding == UA_EXTENSIONOBJECT_DECODED){ + if(eoTargetVar->content.decoded.type == &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]){ + if(UA_TargetVariablesDataType_copy((UA_TargetVariablesDataType *) eoTargetVar->content.decoded.data, + &targetVars) != UA_STATUSCODE_GOOD){ + return UA_STATUSCODE_BADOUTOFMEMORY; + } + } + UA_NodeId folderId; + UA_String folderName = pMetaData->name; + UA_ObjectAttributes oAttr = UA_ObjectAttributes_default; + UA_QualifiedName folderBrowseName; + if(folderName.length > 0) { + oAttr.displayName.locale = UA_STRING(""); + oAttr.displayName.text = folderName; + folderBrowseName.namespaceIndex = 1; + folderBrowseName.name = folderName; + } else { + oAttr.displayName = UA_LOCALIZEDTEXT("", "Subscribed Variables"); + folderBrowseName = UA_QUALIFIEDNAME(1, "Subscribed Variables"); + } + + UA_Server_addObjectNode(server, UA_NODEID_NULL, + UA_NODEID_NUMERIC (0, UA_NS0ID_OBJECTSFOLDER), + UA_NODEID_NUMERIC (0, UA_NS0ID_ORGANIZES), + folderBrowseName, UA_NODEID_NUMERIC (0, + UA_NS0ID_BASEOBJECTTYPE), oAttr, NULL, &folderId); + /** + * **TargetVariables** + * + * The SubscribedDataSet option TargetVariables defines a list of Variable mappings between + * received DataSet fields and target Variables in the Subscriber AddressSpace. + * The values subscribed from the Publisher are updated in the value field of these variables */ + /* Create the TargetVariables with respect to DataSetMetaData fields */ + UA_FieldTargetVariable *targetVarsData = (UA_FieldTargetVariable *) + UA_calloc(targetVars.targetVariablesSize, sizeof(UA_FieldTargetVariable)); + for(size_t i = 0; i < targetVars.targetVariablesSize; i++) { + /* Variable to subscribe data */ + UA_VariableAttributes vAttr = UA_VariableAttributes_default; + UA_LocalizedText_copy(&pMetaData->fields[i].description, + &vAttr.description); + vAttr.displayName.locale = UA_STRING(""); + vAttr.displayName.text = pMetaData->fields[i].name; + vAttr.dataType = pMetaData->fields[i].dataType; + + UA_NodeId newNode; + retVal |= UA_Server_addVariableNode(server, targetVars.targetVariables[i].targetNodeId, + folderId, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(1, (char *)pMetaData->fields[i].name.data), + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE), + vAttr, NULL, &newNode); + + /* For creating Targetvariables */ + UA_FieldTargetDataType_init(&targetVarsData[i].targetVariable); + targetVarsData[i].targetVariable.attributeId = targetVars.targetVariables[i].attributeId; + targetVarsData[i].targetVariable.targetNodeId = newNode; + } + retVal = UA_Server_DataSetReader_createTargetVariables(server, dataSetReaderId, + targetVars.targetVariablesSize, targetVarsData); + for(size_t j = 0; j < targetVars.targetVariablesSize; j++) + UA_FieldTargetDataType_clear(&targetVarsData[j].targetVariable); + UA_free(targetVarsData); + } + + return retVal; +} + +/** + * **DataSetReader** + * + * DataSetReader can receive NetworkMessages with the DataSetMessage + * of interest sent by the Publisher. DataSetReader provides + * the configuration necessary to receive and process DataSetMessages + * on the Subscriber side. DataSetReader must be linked with a + * SubscribedDataSet and be contained within a ReaderGroup. */ +/* Add DataSetReader to the ReaderGroup */ +static UA_StatusCode +addDataSetReaderConfig(UA_Server *server, UA_NodeId readerGroupId, + UA_DataSetReaderDataType *dataSetReaderDataType, + UA_NodeId *dataSetReaderId) { + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_DataSetReaderConfig readerConfig; + memset (&readerConfig, 0, sizeof(UA_DataSetReaderConfig)); + readerConfig.name = dataSetReaderDataType->name; + /* Parameters to filter which DataSetMessage has to be processed + * by the DataSetReader */ + if(dataSetReaderDataType->publisherId.type == &UA_TYPES[UA_TYPES_STRING]){ + UA_String publisherIdentifier; + readerConfig.publisherId.type = &UA_TYPES[UA_TYPES_STRING]; + UA_String_copy((UA_String *) dataSetReaderDataType->publisherId.data, &publisherIdentifier); + readerConfig.publisherId.data = &publisherIdentifier; + } else { + UA_UInt16 publisherIdentifier = *(UA_UInt16*)dataSetReaderDataType->publisherId.data; + readerConfig.publisherId.type = &UA_TYPES[UA_TYPES_UINT16]; + readerConfig.publisherId.data = &publisherIdentifier; + } + + readerConfig.writerGroupId = dataSetReaderDataType->writerGroupId; + readerConfig.dataSetWriterId = dataSetReaderDataType->dataSetWriterId; + + /* Setting up Meta data configuration in DataSetReader */ + UA_DataSetMetaDataType *pMetaData; + pMetaData = &readerConfig.dataSetMetaData; + UA_DataSetMetaDataType_init (pMetaData); + pMetaData->name = dataSetReaderDataType->dataSetMetaData.name; + pMetaData->fieldsSize = dataSetReaderDataType->dataSetMetaData.fieldsSize; + pMetaData->fields = (UA_FieldMetaData*)UA_Array_new (pMetaData->fieldsSize, + &UA_TYPES[UA_TYPES_FIELDMETADATA]); + for(size_t i = 0; i < pMetaData->fieldsSize; i++){ + UA_FieldMetaData_init (&pMetaData->fields[i]); + UA_NodeId_copy (&dataSetReaderDataType->dataSetMetaData.fields[i].dataType, + &pMetaData->fields[i].dataType); + pMetaData->fields[i].builtInType = dataSetReaderDataType->dataSetMetaData.fields[i].builtInType; + pMetaData->fields[i].name = dataSetReaderDataType->dataSetMetaData.fields[i].name; + pMetaData->fields[i].valueRank = dataSetReaderDataType->dataSetMetaData.fields[i].valueRank; + } + + retVal |= UA_Server_addDataSetReader(server, readerGroupId, &readerConfig, + dataSetReaderId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_free(pMetaData->fields); + return retVal; + } + + retVal |= addSubscribedVariables(server, *dataSetReaderId, dataSetReaderDataType, pMetaData); + UA_free(pMetaData->fields); + return retVal; +} +#endif + +/*************************************************/ +/* PubSubConnection */ +/*************************************************/ +UA_StatusCode +addPubSubConnectionRepresentation(UA_Server *server, UA_PubSubConnection *connection) { + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + if(connection->config->name.length > 512) + return UA_STATUSCODE_BADOUTOFMEMORY; + char connectionName[513]; + memcpy(connectionName, connection->config->name.data, connection->config->name.length); + connectionName[connection->config->name.length] = '\0'; + + UA_ObjectAttributes attr = UA_ObjectAttributes_default; + attr.displayName = UA_LOCALIZEDTEXT("", connectionName); + retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, + UA_NODEID_NUMERIC(1, 0), /* Generate a new id */ + UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPUBSUBCONNECTION), + UA_QUALIFIEDNAME(0, connectionName), + UA_NODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE), + (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES], + NULL, &connection->identifier); + + attr.displayName = UA_LOCALIZEDTEXT("", "Address"); + retVal |= UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), + connection->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(0, "Address"), + UA_NODEID_NUMERIC(0, UA_NS0ID_NETWORKADDRESSURLTYPE), + attr, NULL, NULL); + + UA_Server_addNode_finish(server, connection->identifier); + + UA_NodeId addressNode, urlNode, interfaceNode, publisherIdNode, + connectionPropertieNode, transportProfileUri; + addressNode = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "Address"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + connection->identifier); + urlNode = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "Url"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + addressNode); + interfaceNode = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "NetworkInterface"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + addressNode); + publisherIdNode = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublisherId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + connection->identifier); + connectionPropertieNode = findSingleChildNode(server, + UA_QUALIFIEDNAME(0, "ConnectionProperties"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + connection->identifier); + transportProfileUri = findSingleChildNode(server, + UA_QUALIFIEDNAME(0, "TransportProfileUri"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + connection->identifier); + + if(UA_NodeId_isNull(&addressNode) || UA_NodeId_isNull(&urlNode) || + UA_NodeId_isNull(&interfaceNode) || UA_NodeId_isNull(&publisherIdNode) || + UA_NodeId_isNull(&connectionPropertieNode) || + UA_NodeId_isNull(&transportProfileUri)) { + return UA_STATUSCODE_BADNOTFOUND; + } + + retVal |= writePubSubNs0VariableArray(server, connectionPropertieNode.identifier.numeric, + connection->config->connectionProperties, + connection->config->connectionPropertiesSize, + &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); + + UA_NetworkAddressUrlDataType *networkAddressUrlDataType = + ((UA_NetworkAddressUrlDataType*)connection->config->address.data); + UA_Variant value; + UA_Variant_init(&value); + UA_Variant_setScalar(&value, &networkAddressUrlDataType->url, + &UA_TYPES[UA_TYPES_STRING]); + UA_Server_writeValue(server, urlNode, value); + UA_Variant_setScalar(&value, &networkAddressUrlDataType->networkInterface, + &UA_TYPES[UA_TYPES_STRING]); + UA_Server_writeValue(server, interfaceNode, value); + UA_Variant_setScalar(&value, &connection->config->transportProfileUri, + &UA_TYPES[UA_TYPES_STRING]); + UA_Server_writeValue(server, transportProfileUri, value); + + UA_NodePropertyContext *connectionPublisherIdContext = (UA_NodePropertyContext *) + UA_malloc(sizeof(UA_NodePropertyContext)); + connectionPublisherIdContext->parentNodeId = connection->identifier; + connectionPublisherIdContext->parentClassifier = UA_NS0ID_PUBSUBCONNECTIONTYPE; + connectionPublisherIdContext->elementClassiefier = + UA_NS0ID_PUBSUBCONNECTIONTYPE_PUBLISHERID; + UA_ValueCallback valueCallback; + valueCallback.onRead = onRead; + valueCallback.onWrite = NULL; + retVal |= addVariableValueSource(server, valueCallback, publisherIdNode, + connectionPublisherIdContext); + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS + retVal |= UA_Server_addReference(server, connection->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDWRITERGROUP), + true); + retVal |= UA_Server_addReference(server, connection->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDREADERGROUP), + true); + retVal |= UA_Server_addReference(server, connection->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE_REMOVEGROUP), + true); +#endif + return retVal; +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addPubSubConnectionAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_PubSubConnectionDataType pubSubConnectionDataType = *((UA_PubSubConnectionDataType *) input[0].data); + + //call API function and create the connection + UA_NodeId connectionId; + retVal |= addPubSubConnectionConfig(server, &pubSubConnectionDataType, &connectionId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addPubSubConnection failed"); + return retVal; + } + + for(size_t i = 0; i < pubSubConnectionDataType.writerGroupsSize; i++){ + UA_NodeId writerGroupId; + UA_WriterGroupDataType *writerGroupDataType = &pubSubConnectionDataType.writerGroups[i]; + retVal |= addWriterGroupConfig(server, connectionId, writerGroupDataType, &writerGroupId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addWriterGroup failed"); + return retVal; + } + + for (size_t j = 0; j < pubSubConnectionDataType.writerGroups[i].dataSetWritersSize; j++){ + UA_DataSetWriterDataType *dataSetWriterDataType = &writerGroupDataType->dataSetWriters[j]; + retVal |= addDataSetWriterConfig(server, &writerGroupId, dataSetWriterDataType, NULL); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addDataSetWriter failed"); + return retVal; + } + } + + //TODO: Need to handle the UA_Server_setWriterGroupOperational based on the status variable in information model + if(pubSubConnectionDataType.enabled) { + UA_Server_freezeWriterGroupConfiguration(server, writerGroupId); + UA_Server_setWriterGroupOperational(server, writerGroupId); + } else + UA_Server_setWriterGroupDisabled(server, writerGroupId); + } + + for(size_t i = 0; i < pubSubConnectionDataType.readerGroupsSize; i++){ + UA_NodeId readerGroupId; + UA_ReaderGroupDataType *readerGroupDataType = &pubSubConnectionDataType.readerGroups[i]; + retVal |= addReaderGroupConfig(server, connectionId, readerGroupDataType, &readerGroupId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addReaderGroup failed"); + return retVal; + } + + for(size_t j = 0; j < pubSubConnectionDataType.readerGroups[i].dataSetReadersSize; j++){ + UA_NodeId dataSetReaderId; + UA_DataSetReaderDataType *dataSetReaderDataType = &readerGroupDataType->dataSetReaders[j]; + retVal |= addDataSetReaderConfig(server, readerGroupId, dataSetReaderDataType, &dataSetReaderId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addDataSetReader failed"); + return retVal; + } + } + //TODO: Need to handle the UA_Server_setReaderGroupOperational based on the status variable in information model + if(pubSubConnectionDataType.enabled) { + UA_Server_freezeReaderGroupConfiguration(server, readerGroupId); + UA_Server_setReaderGroupOperational(server, readerGroupId); + } + else + UA_Server_setReaderGroupDisabled(server, readerGroupId); + } + //set ouput value + UA_Variant_setScalarCopy(output, &connectionId, &UA_TYPES[UA_TYPES_NODEID]); + return UA_STATUSCODE_GOOD; +} +#endif + +UA_StatusCode +removePubSubConnectionRepresentation(UA_Server *server, + UA_PubSubConnection *connection) { + return UA_Server_deleteNode(server, connection->identifier, true); +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +removeConnectionAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_NodeId nodeToRemove = *((UA_NodeId *) input[0].data); + retVal |= UA_Server_removePubSubConnection(server, nodeToRemove); + if(retVal == UA_STATUSCODE_BADNOTFOUND) + retVal = UA_STATUSCODE_BADNODEIDUNKNOWN; + return retVal; +} +#endif + +/**********************************************/ +/* DataSetReader */ +/**********************************************/ +UA_StatusCode +addDataSetReaderRepresentation(UA_Server *server, UA_DataSetReader *dataSetReader){ + if(dataSetReader->config.name.length > 512) + return UA_STATUSCODE_BADCONFIGURATIONERROR; + + char dsrName[513]; + memcpy(dsrName, dataSetReader->config.name.data, dataSetReader->config.name.length); + dsrName[dataSetReader->config.name.length] = '\0'; + + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_NodeId publisherIdNode, writerGroupIdNode, dataSetwriterIdNode; + + UA_ObjectAttributes object_attr = UA_ObjectAttributes_default; + object_attr.displayName = UA_LOCALIZEDTEXT("", dsrName); + retVal = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), /* create an id */ + dataSetReader->linkedReaderGroup, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASDATASETREADER), + UA_QUALIFIEDNAME(0, dsrName), + UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETREADERTYPE), + object_attr, NULL, &dataSetReader->identifier); + + /* Add childNodes such as PublisherId, WriterGroupId and DataSetWriterId in + * DataSetReader object */ + publisherIdNode = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublisherId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + dataSetReader->identifier); + writerGroupIdNode = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "WriterGroupId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + dataSetReader->identifier); + dataSetwriterIdNode = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "DataSetWriterId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + dataSetReader->identifier); + + if(UA_NodeId_isNull(&publisherIdNode) || + UA_NodeId_isNull(&writerGroupIdNode) || + UA_NodeId_isNull(&dataSetwriterIdNode)) { + return UA_STATUSCODE_BADNOTFOUND; + } + + UA_NodePropertyContext *dataSetReaderPublisherIdContext = + (UA_NodePropertyContext *) UA_malloc(sizeof(UA_NodePropertyContext)); + dataSetReaderPublisherIdContext->parentNodeId = dataSetReader->identifier; + dataSetReaderPublisherIdContext->parentClassifier = UA_NS0ID_DATASETREADERTYPE; + dataSetReaderPublisherIdContext->elementClassiefier = UA_NS0ID_DATASETREADERTYPE_PUBLISHERID; + UA_ValueCallback valueCallback; + valueCallback.onRead = onRead; + valueCallback.onWrite = NULL; + retVal |= addVariableValueSource(server, valueCallback, publisherIdNode, + dataSetReaderPublisherIdContext); + + /* Update childNode with values from Publisher */ + UA_Variant value; + UA_Variant_init(&value); + UA_Variant_setScalar(&value, &dataSetReader->config.writerGroupId, + &UA_TYPES[UA_TYPES_UINT16]); + UA_Server_writeValue(server, writerGroupIdNode, value); + UA_Variant_setScalar(&value, &dataSetReader->config.dataSetWriterId, + &UA_TYPES[UA_TYPES_UINT16]); + UA_Server_writeValue(server, dataSetwriterIdNode, value); + return retVal; +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addDataSetReaderAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, *objectId); + if(rg->configurationFrozen) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "addDataSetReader cannot be done because ReaderGroup config frozen"); + return UA_STATUSCODE_BAD; + } + + UA_NodeId dataSetReaderId; + UA_DataSetReaderDataType *dataSetReaderDataType = (UA_DataSetReaderDataType *) input[0].data; + retVal |= addDataSetReaderConfig(server, *objectId, dataSetReaderDataType, &dataSetReaderId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addDataSetReader failed"); + return retVal; + } + + UA_Variant_setScalarCopy(output, &dataSetReaderId, &UA_TYPES[UA_TYPES_NODEID]); + return retVal; +} +#endif + +UA_StatusCode +removeDataSetReaderRepresentation(UA_Server *server, + UA_DataSetReader* dataSetReader) { + return UA_Server_deleteNode(server, dataSetReader->identifier, true); +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +removeDataSetReaderAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_NodeId nodeToRemove = *((UA_NodeId *)input[0].data); + return UA_Server_removeDataSetReader(server, nodeToRemove); +} +#endif + +/*************************************************/ +/* PublishedDataSet */ +/*************************************************/ +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addDataSetFolderAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + /* defined in R 1.04 9.1.4.5.7 */ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_String newFolderName = *((UA_String *) input[0].data); + UA_NodeId generatedId; + UA_ObjectAttributes objectAttributes = UA_ObjectAttributes_default; + UA_LocalizedText name = {UA_STRING(""), newFolderName}; + objectAttributes.displayName = name; + retVal |= UA_Server_addObjectNode(server, UA_NODEID_NULL, *objectId, + UA_NODEID_NUMERIC(0,UA_NS0ID_ORGANIZES), + UA_QUALIFIEDNAME(0, "DataSetFolder"), + UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE), + objectAttributes, NULL, &generatedId); + UA_Variant_setScalarCopy(output, &generatedId, &UA_TYPES[UA_TYPES_NODEID]); +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS + retVal |= UA_Server_addReference(server, generatedId, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMS), true); + retVal |= UA_Server_addReference(server, generatedId, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_REMOVEPUBLISHEDDATASET), true); + retVal |= UA_Server_addReference(server, generatedId, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_ADDDATASETFOLDER), true); + retVal |= UA_Server_addReference(server, generatedId, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_REMOVEDATASETFOLDER), true); +#endif + return retVal; +} +#endif + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +removeDataSetFolderAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output) { + UA_NodeId nodeToRemove = *((UA_NodeId *) input[0].data); + return UA_Server_deleteNode(server, nodeToRemove, true); +} +#endif + +UA_StatusCode +addPublishedDataItemsRepresentation(UA_Server *server, + UA_PublishedDataSet *publishedDataSet) { + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + if(publishedDataSet->config.name.length > 512) + return UA_STATUSCODE_BADOUTOFMEMORY; + char pdsName[513]; + memcpy(pdsName, publishedDataSet->config.name.data, publishedDataSet->config.name.length); + pdsName[publishedDataSet->config.name.length] = '\0'; + + UA_ObjectAttributes object_attr = UA_ObjectAttributes_default; + object_attr.displayName = UA_LOCALIZEDTEXT("", pdsName); + retVal = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), /* Create a new id */ + UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(0, pdsName), + UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHEDDATAITEMSTYPE), + object_attr, NULL, &publishedDataSet->identifier); + UA_CHECK_STATUS(retVal, return retVal); + + UA_ValueCallback valueCallback; + valueCallback.onRead = onRead; + valueCallback.onWrite = NULL; + //ToDo: Need to move the browse name from namespaceindex 0 to 1 + UA_NodeId configurationVersionNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "ConfigurationVersion"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + publishedDataSet->identifier); + if(UA_NodeId_isNull(&configurationVersionNode)) + return UA_STATUSCODE_BADNOTFOUND; + + UA_NodePropertyContext *configurationVersionContext = (UA_NodePropertyContext *) + UA_malloc(sizeof(UA_NodePropertyContext)); + configurationVersionContext->parentNodeId = publishedDataSet->identifier; + configurationVersionContext->parentClassifier = UA_NS0ID_PUBLISHEDDATAITEMSTYPE; + configurationVersionContext->elementClassiefier = + UA_NS0ID_PUBLISHEDDATAITEMSTYPE_CONFIGURATIONVERSION; + retVal |= addVariableValueSource(server, valueCallback, configurationVersionNode, + configurationVersionContext); + + UA_NodeId publishedDataNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublishedData"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + publishedDataSet->identifier); + if(UA_NodeId_isNull(&publishedDataNode)) + return UA_STATUSCODE_BADNOTFOUND; + + UA_NodePropertyContext * publishingIntervalContext = (UA_NodePropertyContext *) + UA_malloc(sizeof(UA_NodePropertyContext)); + publishingIntervalContext->parentNodeId = publishedDataSet->identifier; + publishingIntervalContext->parentClassifier = UA_NS0ID_PUBLISHEDDATAITEMSTYPE; + publishingIntervalContext->elementClassiefier = UA_NS0ID_PUBLISHEDDATAITEMSTYPE_PUBLISHEDDATA; + retVal |= addVariableValueSource(server, valueCallback, publishedDataNode, + publishingIntervalContext); + + UA_NodeId dataSetMetaDataNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "DataSetMetaData"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + publishedDataSet->identifier); + if(UA_NodeId_isNull(&dataSetMetaDataNode)) + return UA_STATUSCODE_BADNOTFOUND; + + UA_NodePropertyContext *metaDataContext = (UA_NodePropertyContext *) + UA_malloc(sizeof(UA_NodePropertyContext)); + metaDataContext->parentNodeId = publishedDataSet->identifier; + metaDataContext->parentClassifier = UA_NS0ID_PUBLISHEDDATAITEMSTYPE; + metaDataContext->elementClassiefier = UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETMETADATA; + retVal |= addVariableValueSource(server, valueCallback, + dataSetMetaDataNode, metaDataContext); + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS + retVal |= UA_Server_addReference(server, publishedDataSet->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PUBLISHEDDATAITEMSTYPE_ADDVARIABLES), true); + retVal |= UA_Server_addReference(server, publishedDataSet->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PUBLISHEDDATAITEMSTYPE_REMOVEVARIABLES), true); +#endif + return retVal; +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addPublishedDataItemsAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + size_t fieldNameAliasesSize = input[1].arrayLength; + UA_String * fieldNameAliases = (UA_String *) input[1].data; + size_t fieldFlagsSize = input[2].arrayLength; + UA_DataSetFieldFlags * fieldFlags = (UA_DataSetFieldFlags *) input[2].data; + size_t variablesToAddSize = input[3].arrayLength; + UA_ExtensionObject *eoAddVar = (UA_ExtensionObject *)input[3].data; + + if(!(fieldNameAliasesSize == fieldFlagsSize || fieldFlagsSize == variablesToAddSize)) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + UA_PublishedDataSetConfig publishedDataSetConfig; + memset(&publishedDataSetConfig, 0, sizeof(publishedDataSetConfig)); + publishedDataSetConfig.name = *((UA_String *) input[0].data); + publishedDataSetConfig.publishedDataSetType = UA_PUBSUB_DATASET_PUBLISHEDITEMS; + + UA_NodeId dataSetItemsNodeId; + retVal |= UA_Server_addPublishedDataSet(server, &publishedDataSetConfig, + &dataSetItemsNodeId).addResult; + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "addPublishedDataset failed"); + return retVal; + } + + UA_DataSetFieldConfig dataSetFieldConfig; + for(size_t j = 0; j < variablesToAddSize; ++j) { + memset(&dataSetFieldConfig, 0, sizeof(UA_DataSetFieldConfig)); + dataSetFieldConfig.dataSetFieldType = UA_PUBSUB_DATASETFIELD_VARIABLE; + dataSetFieldConfig.field.variable.fieldNameAlias = fieldNameAliases[j]; + if(fieldFlags[j] == UA_DATASETFIELDFLAGS_PROMOTEDFIELD) + dataSetFieldConfig.field.variable.promotedField = true; + + UA_PublishedVariableDataType variablesToAddField; + UA_PublishedVariableDataType_init(&variablesToAddField); + if(eoAddVar[j].encoding == UA_EXTENSIONOBJECT_DECODED){ + if(eoAddVar[j].content.decoded.type == &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]){ + if(UA_PublishedVariableDataType_copy((UA_PublishedVariableDataType *) eoAddVar[j].content.decoded.data, + &variablesToAddField) != UA_STATUSCODE_GOOD){ + return UA_STATUSCODE_BADOUTOFMEMORY; + } + } + } + dataSetFieldConfig.field.variable.publishParameters = variablesToAddField; + retVal |= UA_Server_addDataSetField(server, dataSetItemsNodeId, &dataSetFieldConfig, NULL).result; + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addDataSetField failed"); + return retVal; + } + + UA_PublishedVariableDataType_clear(&variablesToAddField); + } + + UA_Variant_setScalarCopy(output, &dataSetItemsNodeId, &UA_TYPES[UA_TYPES_NODEID]); + return retVal; +} +#endif + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addVariablesAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +removeVariablesAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + return UA_STATUSCODE_GOOD; +} +#endif + + +UA_StatusCode +removePublishedDataSetRepresentation(UA_Server *server, + UA_PublishedDataSet *publishedDataSet) { + return UA_Server_deleteNode(server, publishedDataSet->identifier, true); +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +removePublishedDataSetAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_NodeId nodeToRemove = *((UA_NodeId *) input[0].data); + return UA_Server_removePublishedDataSet(server, nodeToRemove); +} +#endif + +/**********************************************/ +/* WriterGroup */ +/**********************************************/ + +static UA_StatusCode +readContentMask(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeId, + void *nodeContext, UA_Boolean includeSourceTimeStamp, + const UA_NumericRange *range, UA_DataValue *value) { + UA_WriterGroup *writerGroup = (UA_WriterGroup*)nodeContext; + if((writerGroup->config.messageSettings.encoding != UA_EXTENSIONOBJECT_DECODED && + writerGroup->config.messageSettings.encoding != UA_EXTENSIONOBJECT_DECODED_NODELETE) || + writerGroup->config.messageSettings.content.decoded.type != + &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]) + return UA_STATUSCODE_BADINTERNALERROR; + UA_UadpWriterGroupMessageDataType *wgm = (UA_UadpWriterGroupMessageDataType*) + writerGroup->config.messageSettings.content.decoded.data; + + UA_Variant_setScalarCopy(&value->value, &wgm->networkMessageContentMask, + &UA_TYPES[UA_TYPES_UADPNETWORKMESSAGECONTENTMASK]); + value->hasValue = true; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +writeContentMask(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeId, + void *nodeContext, const UA_NumericRange *range, + const UA_DataValue *value) { + UA_WriterGroup *writerGroup = (UA_WriterGroup*)nodeContext; + if((writerGroup->config.messageSettings.encoding != UA_EXTENSIONOBJECT_DECODED && + writerGroup->config.messageSettings.encoding != UA_EXTENSIONOBJECT_DECODED_NODELETE) || + writerGroup->config.messageSettings.content.decoded.type != + &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]) + return UA_STATUSCODE_BADINTERNALERROR; + UA_UadpWriterGroupMessageDataType *wgm = (UA_UadpWriterGroupMessageDataType*) + writerGroup->config.messageSettings.content.decoded.data; + + if(!value->value.type) + return UA_STATUSCODE_BADTYPEMISMATCH; + if(value->value.type->typeKind != UA_DATATYPEKIND_ENUM && + value->value.type->typeKind != UA_DATATYPEKIND_INT32) + return UA_STATUSCODE_BADTYPEMISMATCH; + + wgm->networkMessageContentMask = *(UA_UadpNetworkMessageContentMask*)value->value.data; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +addWriterGroupRepresentation(UA_Server *server, UA_WriterGroup *writerGroup){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + if(writerGroup->config.name.length > 512) + return UA_STATUSCODE_BADOUTOFMEMORY; + char wgName[513]; + memcpy(wgName, writerGroup->config.name.data, writerGroup->config.name.length); + wgName[writerGroup->config.name.length] = '\0'; + + UA_ObjectAttributes object_attr = UA_ObjectAttributes_default; + object_attr.displayName = UA_LOCALIZEDTEXT("", wgName); + retVal = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), /* create a new id */ + writerGroup->linkedConnection->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(0, wgName), + UA_NODEID_NUMERIC(0, UA_NS0ID_WRITERGROUPTYPE), + object_attr, NULL, &writerGroup->identifier); + + UA_NodeId keepAliveNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "KeepAliveTime"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + writerGroup->identifier); + UA_NodeId publishingIntervalNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublishingInterval"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + writerGroup->identifier); + if(UA_NodeId_isNull(&keepAliveNode) || + UA_NodeId_isNull(&publishingIntervalNode)) + return UA_STATUSCODE_BADNOTFOUND; + + UA_NodePropertyContext * publishingIntervalContext = (UA_NodePropertyContext *) + UA_malloc(sizeof(UA_NodePropertyContext)); + publishingIntervalContext->parentNodeId = writerGroup->identifier; + publishingIntervalContext->parentClassifier = UA_NS0ID_WRITERGROUPTYPE; + publishingIntervalContext->elementClassiefier = UA_NS0ID_WRITERGROUPTYPE_PUBLISHINGINTERVAL; + UA_ValueCallback valueCallback; + valueCallback.onRead = onRead; + valueCallback.onWrite = onWrite; + retVal |= addVariableValueSource(server, valueCallback, + publishingIntervalNode, publishingIntervalContext); + UA_Server_writeAccessLevel(server, publishingIntervalNode, + UA_ACCESSLEVELMASK_READ ^ UA_ACCESSLEVELMASK_WRITE); + + UA_NodeId priorityNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "Priority"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + writerGroup->identifier); + UA_NodeId writerGroupIdNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "WriterGroupId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + writerGroup->identifier); + + UA_Variant value; + UA_Variant_init(&value); + UA_Variant_setScalar(&value, &writerGroup->config.publishingInterval, &UA_TYPES[UA_TYPES_DURATION]); + UA_Server_writeValue(server, publishingIntervalNode, value); + UA_Variant_setScalar(&value, &writerGroup->config.keepAliveTime, &UA_TYPES[UA_TYPES_DURATION]); + UA_Server_writeValue(server, keepAliveNode, value); + UA_Variant_setScalar(&value, &writerGroup->config.priority, &UA_TYPES[UA_TYPES_BYTE]); + UA_Server_writeValue(server, priorityNode, value); + UA_Variant_setScalar(&value, &writerGroup->config.writerGroupId, &UA_TYPES[UA_TYPES_UINT16]); + UA_Server_writeValue(server, writerGroupIdNode, value); + + object_attr.displayName = UA_LOCALIZEDTEXT("", "MessageSettings"); + retVal |= UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), + writerGroup->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(0, "MessageSettings"), + UA_NODEID_NUMERIC(0, UA_NS0ID_UADPWRITERGROUPMESSAGETYPE), + object_attr, NULL, NULL); + + /* Find the variable with the content mask */ + + UA_NodeId messageSettingsId = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "MessageSettings"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + writerGroup->identifier); + UA_NodeId contentMaskId = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "NetworkMessageContentMask"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), messageSettingsId); + if(!UA_NodeId_isNull(&contentMaskId)) { + /* Set the callback */ + UA_DataSource ds; + ds.read = readContentMask; + ds.write = writeContentMask; + UA_Server_setVariableNode_dataSource(server, contentMaskId, ds); + UA_Server_setNodeContext(server, contentMaskId, writerGroup); + + /* Make writable */ + UA_Server_writeAccessLevel(server, contentMaskId, + UA_ACCESSLEVELMASK_WRITE | UA_ACCESSLEVELMASK_READ); + + } + + /* Add reference to methods */ +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS + retVal |= UA_Server_addReference(server, writerGroup->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_WRITERGROUPTYPE_ADDDATASETWRITER), true); + retVal |= UA_Server_addReference(server, writerGroup->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_WRITERGROUPTYPE_REMOVEDATASETWRITER), true); +#endif + + return retVal; +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addWriterGroupAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_WriterGroupDataType *writerGroupDataType = ((UA_WriterGroupDataType *) input[0].data); + UA_NodeId writerGroupId; + retVal |= addWriterGroupConfig(server, *objectId, writerGroupDataType, &writerGroupId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addWriterGroup failed"); + return retVal; + } + //TODO: Need to handle the UA_Server_setWriterGroupOperational based on the status variable in information model + + UA_Variant_setScalarCopy(output, &writerGroupId, &UA_TYPES[UA_TYPES_NODEID]); + return retVal; +} +#endif + +UA_StatusCode +removeGroupRepresentation(UA_Server *server, UA_WriterGroup *writerGroup) { + return UA_Server_deleteNode(server, writerGroup->identifier, true); +} + +UA_StatusCode +removeReaderGroupRepresentation(UA_Server *server, UA_ReaderGroup *readerGroup) { + return UA_Server_deleteNode(server, readerGroup->identifier, true); +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +removeGroupAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_NodeId nodeToRemove = *((UA_NodeId *)input->data); + if(UA_WriterGroup_findWGbyId(server, nodeToRemove)) { + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, nodeToRemove); + if(wg->configurationFrozen) + UA_Server_unfreezeWriterGroupConfiguration(server, nodeToRemove); + return UA_Server_removeWriterGroup(server, nodeToRemove); + } else { + UA_ReaderGroup *rg = UA_ReaderGroup_findRGbyId(server, nodeToRemove); + if(rg->configurationFrozen) + UA_Server_unfreezeReaderGroupConfiguration(server, nodeToRemove); + return UA_Server_removeReaderGroup(server, nodeToRemove); + } +} +#endif + +/**********************************************/ +/* ReaderGroup */ +/**********************************************/ + +UA_StatusCode +addReaderGroupRepresentation(UA_Server *server, UA_ReaderGroup *readerGroup) { + if(readerGroup->config.name.length > 512) + return UA_STATUSCODE_BADCONFIGURATIONERROR; + char rgName[513]; + memcpy(rgName, readerGroup->config.name.data, readerGroup->config.name.length); + rgName[readerGroup->config.name.length] = '\0'; + + UA_ObjectAttributes object_attr = UA_ObjectAttributes_default; + object_attr.displayName = UA_LOCALIZEDTEXT("", rgName); + UA_StatusCode retVal = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), /* create an id */ + readerGroup->linkedConnection, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(0, rgName), + UA_NODEID_NUMERIC(0, UA_NS0ID_READERGROUPTYPE), + object_attr, NULL, &readerGroup->identifier); +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS + retVal |= UA_Server_addReference(server, readerGroup->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_READERGROUPTYPE_ADDDATASETREADER), true); + retVal |= UA_Server_addReference(server, readerGroup->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_READERGROUPTYPE_REMOVEDATASETREADER), true); +#endif + return retVal; +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addReaderGroupAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_ReaderGroupDataType *readerGroupDataType = ((UA_ReaderGroupDataType *) input->data); + UA_NodeId readerGroupId; + retVal |= addReaderGroupConfig(server, *objectId, readerGroupDataType, &readerGroupId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "addReaderGroup failed"); + return retVal; + } + //TODO: Need to handle the UA_Server_setReaderGroupOperational based on the status variable in information model + + UA_Variant_setScalarCopy(output, &readerGroupId, &UA_TYPES[UA_TYPES_NODEID]); + return retVal; +} +#endif + +/**********************************************/ +/* DataSetWriter */ +/**********************************************/ + +UA_StatusCode +addDataSetWriterRepresentation(UA_Server *server, UA_DataSetWriter *dataSetWriter){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + if(dataSetWriter->config.name.length > 512) + return UA_STATUSCODE_BADOUTOFMEMORY; + char dswName[513]; + memcpy(dswName, dataSetWriter->config.name.data, dataSetWriter->config.name.length); + dswName[dataSetWriter->config.name.length] = '\0'; + + UA_ObjectAttributes object_attr = UA_ObjectAttributes_default; + object_attr.displayName = UA_LOCALIZEDTEXT("", dswName); + retVal = UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), /* create an id */ + dataSetWriter->linkedWriterGroup, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASDATASETWRITER), + UA_QUALIFIEDNAME(0, dswName), + UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETWRITERTYPE), + object_attr, NULL, &dataSetWriter->identifier); + + retVal |= UA_Server_addReference(server, dataSetWriter->connectedDataSet, + UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETTOWRITER), + UA_EXPANDEDNODEID_NODEID(dataSetWriter->identifier), + true); + + UA_NodeId dataSetWriterIdNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "DataSetWriterId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + dataSetWriter->identifier); + UA_NodeId keyFrameNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "KeyFrameCount"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + dataSetWriter->identifier); + UA_NodeId dataSetFieldContentMaskNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "DataSetFieldContentMask"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + dataSetWriter->identifier); + + UA_NodePropertyContext *dataSetWriterIdContext = (UA_NodePropertyContext *) + UA_malloc(sizeof(UA_NodePropertyContext)); + dataSetWriterIdContext->parentNodeId = dataSetWriter->identifier; + dataSetWriterIdContext->parentClassifier = UA_NS0ID_DATASETWRITERTYPE; + dataSetWriterIdContext->elementClassiefier = UA_NS0ID_DATASETWRITERTYPE_DATASETWRITERID; + UA_ValueCallback valueCallback; + valueCallback.onRead = onRead; + valueCallback.onWrite = NULL; + retVal |= addVariableValueSource(server, valueCallback, + dataSetWriterIdNode, dataSetWriterIdContext); + + UA_Variant value; + UA_Variant_init(&value); + UA_Variant_setScalar(&value, &dataSetWriter->config.dataSetWriterId, + &UA_TYPES[UA_TYPES_UINT16]); + UA_Server_writeValue(server, dataSetWriterIdNode, value); + UA_Variant_setScalar(&value, &dataSetWriter->config.keyFrameCount, + &UA_TYPES[UA_TYPES_UINT32]); + UA_Server_writeValue(server, keyFrameNode, value); + UA_Variant_setScalar(&value, &dataSetWriter->config.dataSetFieldContentMask, + &UA_TYPES[UA_TYPES_DATASETFIELDCONTENTMASK]); + UA_Server_writeValue(server, dataSetFieldContentMaskNode, value); + + object_attr.displayName = UA_LOCALIZEDTEXT("", "MessageSettings"); + retVal |= UA_Server_addObjectNode(server, UA_NODEID_NUMERIC(1, 0), + dataSetWriter->identifier, + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_QUALIFIEDNAME(0, "MessageSettings"), + UA_NODEID_NUMERIC(0, UA_NS0ID_UADPDATASETWRITERMESSAGETYPE), + object_attr, NULL, NULL); + return retVal; +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +addDataSetWriterAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_WriterGroup *wg = UA_WriterGroup_findWGbyId(server, *objectId); + if(!wg) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Not a WriterGroup"); + return UA_STATUSCODE_BAD; + } + if(wg->configurationFrozen) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "addDataSetWriter cannot be done because writergroup config frozen"); + return UA_STATUSCODE_BAD; + } + + UA_NodeId dataSetWriterId; + UA_DataSetWriterDataType *dataSetWriterData = (UA_DataSetWriterDataType *)input->data; + retVal |= addDataSetWriterConfig(server, objectId, dataSetWriterData, &dataSetWriterId); + if(retVal != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "addDataSetWriter failed"); + return retVal; + } + + UA_Variant_setScalarCopy(output, &dataSetWriterId, &UA_TYPES[UA_TYPES_NODEID]); + return UA_STATUSCODE_GOOD; +} +#endif + + +UA_StatusCode +removeDataSetWriterRepresentation(UA_Server *server, + UA_DataSetWriter *dataSetWriter) { + return UA_Server_deleteNode(server, dataSetWriter->identifier, true); +} + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS +static UA_StatusCode +removeDataSetWriterAction(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output){ + UA_NodeId nodeToRemove = *((UA_NodeId *) input[0].data); + return UA_Server_removeDataSetWriter(server, nodeToRemove); +} +#endif + +/**********************************************/ +/* Destructors */ +/**********************************************/ + +static void +connectionTypeDestructor(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeId, void *typeContext, + const UA_NodeId *nodeId, void **nodeContext) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "Connection destructor called!"); + UA_NodeId publisherIdNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublisherId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), *nodeId); + UA_NodePropertyContext *ctx; + UA_Server_getNodeContext(server, publisherIdNode, (void **)&ctx); + if(!UA_NodeId_isNull(&publisherIdNode)) + UA_free(ctx); +} + +static void +writerGroupTypeDestructor(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeId, void *typeContext, + const UA_NodeId *nodeId, void **nodeContext) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "WriterGroup destructor called!"); + UA_NodeId intervalNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublishingInterval"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), *nodeId); + UA_NodePropertyContext *ctx; + UA_Server_getNodeContext(server, intervalNode, (void **)&ctx); + if(!UA_NodeId_isNull(&intervalNode)) + UA_free(ctx); +} + +static void +readerGroupTypeDestructor(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeId, void *typeContext, + const UA_NodeId *nodeId, void **nodeContext) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "ReaderGroup destructor called!"); +} + +static void +dataSetWriterTypeDestructor(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeId, void *typeContext, + const UA_NodeId *nodeId, void **nodeContext) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "DataSetWriter destructor called!"); + UA_NodeId dataSetWriterIdNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "DataSetWriterId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), *nodeId); + UA_NodePropertyContext *ctx; + UA_Server_getNodeContext(server, dataSetWriterIdNode, (void **)&ctx); + if(!UA_NodeId_isNull(&dataSetWriterIdNode)) + UA_free(ctx); +} + +static void +dataSetReaderTypeDestructor(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeId, void *typeContext, + const UA_NodeId *nodeId, void **nodeContext) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "DataSetReader destructor called!"); + + /* Deallocate the memory allocated for publisherId */ + UA_NodeId publisherIdNode = + findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublisherId"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), *nodeId); + UA_NodePropertyContext *ctx; + UA_Server_getNodeContext(server, publisherIdNode, (void **)&ctx); + if(!UA_NodeId_isNull(&publisherIdNode)) + UA_free(ctx); +} + +static void +publishedDataItemsTypeDestructor(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeId, void *typeContext, + const UA_NodeId *nodeId, void **nodeContext) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "PublishedDataItems destructor called!"); + void *childContext; + UA_NodeId node = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "PublishedData"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), *nodeId); + UA_Server_getNodeContext(server, node, (void**)&childContext); + if(!UA_NodeId_isNull(&node)) + UA_free(childContext); + + node = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "ConfigurationVersion"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), + *nodeId); + UA_Server_getNodeContext(server, node, (void**)&childContext); + if(!UA_NodeId_isNull(&node)) + UA_free(childContext); + + node = findSingleChildNode(server, UA_QUALIFIEDNAME(0, "DataSetMetaData"), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY), *nodeId); + UA_Server_getNodeContext(server, node, (void**)&childContext); + if(!UA_NodeId_isNull(&node)) + UA_free(childContext); +} + +/*************************************/ +/* PubSub configurator */ +/*************************************/ + +#if defined(UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS) && defined(UA_ENABLE_PUBSUB_FILE_CONFIG) + +/* Callback function that will be executed when the method "PubSub configurator + * (replace config)" is called. */ +static UA_StatusCode +UA_loadPubSubConfigMethodCallback(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output) { + if(inputSize == 1) { + UA_ByteString *inputStr = (UA_ByteString*)input->data; + return UA_PubSubManager_loadPubSubConfigFromByteString(server, *inputStr); + } else if(inputSize > 1) { + return UA_STATUSCODE_BADTOOMANYARGUMENTS; + } else { + return UA_STATUSCODE_BADARGUMENTSMISSING; + } +} + +/* Adds method node to server. This method is used to load binary files for + * PubSub configuration and delete / replace old PubSub configurations. */ +static UA_StatusCode +UA_addLoadPubSubConfigMethod(UA_Server *server) { + UA_Argument inputArgument; + UA_Argument_init(&inputArgument); + inputArgument.description = UA_LOCALIZEDTEXT("", "PubSub config binfile"); + inputArgument.name = UA_STRING("BinFile"); + inputArgument.dataType = UA_TYPES[UA_TYPES_BYTESTRING].typeId; + inputArgument.valueRank = UA_VALUERANK_SCALAR; + + UA_MethodAttributes configAttr = UA_MethodAttributes_default; + configAttr.description = UA_LOCALIZEDTEXT("","Load binary configuration file"); + configAttr.displayName = UA_LOCALIZEDTEXT("","LoadPubSubConfigurationFile"); + configAttr.executable = true; + configAttr.userExecutable = true; + return UA_Server_addMethodNode(server, UA_NODEID_NULL, + UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASORDEREDCOMPONENT), + UA_QUALIFIEDNAME(1, "PubSub configuration"), + configAttr, &UA_loadPubSubConfigMethodCallback, + 1, &inputArgument, 0, NULL, NULL, NULL); +} + +/* Callback function that will be executed when the method "PubSub configurator + * (delete config)" is called. */ +static UA_StatusCode +UA_deletePubSubConfigMethodCallback(UA_Server *server, + const UA_NodeId *sessionId, void *sessionHandle, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext, + size_t inputSize, const UA_Variant *input, + size_t outputSize, UA_Variant *output) { + UA_PubSubManager_delete(server, &(server->pubSubManager)); + return UA_STATUSCODE_GOOD; +} + +/* Adds method node to server. This method is used to delete the current PubSub + * configuration. */ +static UA_StatusCode +UA_addDeletePubSubConfigMethod(UA_Server *server) { + UA_MethodAttributes configAttr = UA_MethodAttributes_default; + configAttr.description = UA_LOCALIZEDTEXT("","Delete current PubSub configuration"); + configAttr.displayName = UA_LOCALIZEDTEXT("","DeletePubSubConfiguration"); + configAttr.executable = true; + configAttr.userExecutable = true; + return UA_Server_addMethodNode(server, UA_NODEID_NULL, + UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASORDEREDCOMPONENT), + UA_QUALIFIEDNAME(1, "Delete PubSub config"), + configAttr, &UA_deletePubSubConfigMethodCallback, + 0, NULL, 0, NULL, NULL, NULL); +} + +#endif /* defined(UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS) && defined(UA_ENABLE_PUBSUB_FILE_CONFIG) */ + +UA_StatusCode +UA_Server_initPubSubNS0(UA_Server *server) { + UA_StatusCode retVal = UA_STATUSCODE_GOOD; + UA_String profileArray[1]; + profileArray[0] = UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-udp-uadp"); + + retVal |= writePubSubNs0VariableArray(server, UA_NS0ID_PUBLISHSUBSCRIBE_SUPPORTEDTRANSPORTPROFILES, + profileArray, 1, &UA_TYPES[UA_TYPES_STRING]); + +#ifdef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS + /* Add missing references */ + retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_ADDDATASETFOLDER), true); + retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMS), true); + retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_REMOVEPUBLISHEDDATASET), true); + retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_REMOVEDATASETFOLDER), true); + + /* Set method callbacks */ + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_ADDCONNECTION), addPubSubConnectionAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_REMOVECONNECTION), removeConnectionAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_ADDDATASETFOLDER), addDataSetFolderAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_REMOVEDATASETFOLDER), removeDataSetFolderAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMS), addPublishedDataItemsAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETFOLDERTYPE_REMOVEPUBLISHEDDATASET), removePublishedDataSetAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHEDDATAITEMSTYPE_ADDVARIABLES), addVariablesAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHEDDATAITEMSTYPE_REMOVEVARIABLES), removeVariablesAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDWRITERGROUP), addWriterGroupAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDREADERGROUP), addReaderGroupAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE_REMOVEGROUP), removeGroupAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_WRITERGROUPTYPE_ADDDATASETWRITER), addDataSetWriterAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_WRITERGROUPTYPE_REMOVEDATASETWRITER), removeDataSetWriterAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_READERGROUPTYPE_ADDDATASETREADER), addDataSetReaderAction); + retVal |= UA_Server_setMethodNodeCallback(server, UA_NODEID_NUMERIC(0, UA_NS0ID_READERGROUPTYPE_REMOVEDATASETREADER), removeDataSetReaderAction); + +#ifdef UA_ENABLE_PUBSUB_FILE_CONFIG + retVal |= UA_addLoadPubSubConfigMethod(server); + retVal |= UA_addDeletePubSubConfigMethod(server); +#endif + +#else + /* Remove methods */ + retVal |= UA_Server_deleteReference(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), true, + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_ADDCONNECTION), + false); + retVal |= UA_Server_deleteReference(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASCOMPONENT), true, + UA_EXPANDEDNODEID_NUMERIC(0, UA_NS0ID_PUBLISHSUBSCRIBE_REMOVECONNECTION), + false); +#endif + + /* Set the object-type destructors */ + UA_NodeTypeLifecycle lifeCycle; + lifeCycle.constructor = NULL; + + lifeCycle.destructor = connectionTypeDestructor; + retVal |= UA_Server_setNodeTypeLifecycle(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBSUBCONNECTIONTYPE), lifeCycle); + + lifeCycle.destructor = writerGroupTypeDestructor; + retVal |= UA_Server_setNodeTypeLifecycle(server, UA_NODEID_NUMERIC(0, UA_NS0ID_WRITERGROUPTYPE), lifeCycle); + + lifeCycle.destructor = readerGroupTypeDestructor; + retVal |= UA_Server_setNodeTypeLifecycle(server, UA_NODEID_NUMERIC(0, UA_NS0ID_READERGROUPTYPE), lifeCycle); + + lifeCycle.destructor = dataSetWriterTypeDestructor; + retVal |= UA_Server_setNodeTypeLifecycle(server, UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETWRITERTYPE), lifeCycle); + + lifeCycle.destructor = publishedDataItemsTypeDestructor; + retVal |= UA_Server_setNodeTypeLifecycle(server, UA_NODEID_NUMERIC(0, UA_NS0ID_PUBLISHEDDATAITEMSTYPE), lifeCycle); + + lifeCycle.destructor = dataSetReaderTypeDestructor; + retVal |= UA_Server_setNodeTypeLifecycle(server, UA_NODEID_NUMERIC(0, UA_NS0ID_DATASETREADERTYPE), lifeCycle); + + return retVal; +} + +#endif /* UA_ENABLE_PUBSUB_INFORMATIONMODEL */ + +/**** amalgamated original file "/src/server/ua_services_view.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2019 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2017 (c) Florian Palm + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) LEvertz + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015 (c) Ecosmos + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2016 (c) Lorenz Haas + * Copyright 2017 (c) pschoppe + * Copyright 2017 (c) Julian Grothoff + * Copyright 2017 (c) Henrik Norrman + */ + + +#define UA_MAX_TREE_RECURSE 50 /* How deep up/down the tree do we recurse at most? */ + +UA_StatusCode +referenceTypeIndices(UA_Server *server, const UA_NodeId *refType, + UA_ReferenceTypeSet *indices, UA_Boolean includeSubtypes) { + UA_ReferenceTypeSet_init(indices); + + const UA_Node *refNode = UA_NODESTORE_GET(server, refType); + if(!refNode) + return UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + + if(refNode->head.nodeClass != UA_NODECLASS_REFERENCETYPE) { + UA_NODESTORE_RELEASE(server, refNode); + return UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + } + + if(!includeSubtypes) + *indices = UA_REFTYPESET(refNode->referenceTypeNode.referenceTypeIndex); + else + *indices = refNode->referenceTypeNode.subTypes; + + UA_NODESTORE_RELEASE(server, refNode); + return UA_STATUSCODE_GOOD; +} + +static UA_Boolean +matchClassMask(const UA_Node *node, UA_UInt32 nodeClassMask) { + if(nodeClassMask != UA_NODECLASS_UNSPECIFIED && + (node->head.nodeClass & nodeClassMask) == 0) + return false; + return true; +} + +/****************/ +/* IsNodeInTree */ +/****************/ + +/* Internal method to check if a node is already upwards from a leaf node */ + +/* Keeps track of visited nodes to detect circular references */ +struct ref_history { + struct ref_history *parent; /* the previous element */ + const UA_NodePointer id; /* the id of the node at this depth */ + UA_UInt16 depth; +}; + +static UA_Boolean +isNodeInTreeNoCircular(UA_Server *server, + UA_NodePointer leafNode, + UA_NodePointer nodeToFind, + struct ref_history *visitedRefs, + const UA_ReferenceTypeSet *relevantRefs) { + if(UA_NodePointer_equal(nodeToFind, leafNode)) + return true; + + if(visitedRefs->depth >= UA_MAX_TREE_RECURSE) + return false; + + const UA_Node *node = UA_NODESTORE_GETFROMREF(server, leafNode); + if(!node) + return false; + + for(size_t i = 0; i < node->head.referencesSize; ++i) { + UA_NodeReferenceKind *rk = &node->head.references[i]; + /* Search upwards in the tree */ + if(!rk->isInverse) + continue; + + /* Consider only the indicated reference types */ + if(!UA_ReferenceTypeSet_contains(relevantRefs, rk->referenceTypeIndex)) + continue; + + /* Match the targets or recurse */ + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + /* Don't follow remote targets */ + if(!UA_NodePointer_isLocal(t->targetId)) + continue; + + /* Check if we already have seen the referenced node and skip to + * avoid endless recursion. Do this only at every 5th depth to save + * effort. Circular dependencies are rare and forbidden for most + * reference types. */ + if(visitedRefs->depth % 5 == 4) { + struct ref_history *last = visitedRefs; + UA_Boolean skip = false; + while(last) { + if(UA_NodePointer_equal(last->id, t->targetId)) { + skip = true; + break; + } + last = last->parent; + } + if(skip) + continue; + } + + /* Stack-allocate the visitedRefs structure for the next depth */ + struct ref_history nextVisitedRefs = {visitedRefs, t->targetId, + (UA_UInt16)(visitedRefs->depth+1)}; + + /* Recurse */ + UA_Boolean foundRecursive = + isNodeInTreeNoCircular(server, t->targetId, nodeToFind, + &nextVisitedRefs, relevantRefs); + if(foundRecursive) { + UA_NODESTORE_RELEASE(server, node); + return true; + } + } + } + + UA_NODESTORE_RELEASE(server, node); + return false; +} + +UA_Boolean +isNodeInTree(UA_Server *server, const UA_NodeId *leafNode, + const UA_NodeId *nodeToFind, + const UA_ReferenceTypeSet *relevantRefs) { + UA_NodePointer leafP = UA_NodePointer_fromNodeId(leafNode); + UA_NodePointer targetP = UA_NodePointer_fromNodeId(nodeToFind); + struct ref_history visitedRefs = {NULL, leafP, 0}; + return isNodeInTreeNoCircular(server, leafP, targetP, + &visitedRefs, relevantRefs); +} + +UA_Boolean +isNodeInTree_singleRef(UA_Server *server, const UA_NodeId *leafNode, + const UA_NodeId *nodeToFind, const UA_Byte relevantRefTypeIndex) { + UA_ReferenceTypeSet reftypes = UA_REFTYPESET(relevantRefTypeIndex); + return isNodeInTree(server, leafNode, nodeToFind, &reftypes); +} + +static enum ZIP_CMP +cmpTarget(const void *a, const void *b) { + const RefEntry *aa = (const RefEntry*)a; + const RefEntry *bb = (const RefEntry*)b; + if(aa->targetHash < bb->targetHash) + return ZIP_CMP_LESS; + if(aa->targetHash > bb->targetHash) + return ZIP_CMP_MORE; + return (enum ZIP_CMP)UA_ExpandedNodeId_order(aa->target, bb->target); +} + +ZIP_PROTOTYPE(RefHead, RefEntry, RefEntry) +ZIP_IMPL(RefHead, RefEntry, zipfields, RefEntry, zipfields, cmpTarget) + +UA_StatusCode +RefTree_init(RefTree *rt) { + rt->size = 0; + rt->capacity = 0; + ZIP_INIT(&rt->head); + size_t space = (sizeof(UA_ExpandedNodeId) + sizeof(RefEntry)) * UA_REFTREE_INITIAL_SIZE; + rt->targets = (UA_ExpandedNodeId*)UA_malloc(space); + if(!rt->targets) + return UA_STATUSCODE_BADOUTOFMEMORY; + rt->capacity = UA_REFTREE_INITIAL_SIZE; + return UA_STATUSCODE_GOOD; +} + +void +RefTree_clear(RefTree *rt) { + for(size_t i = 0; i < rt->size; i++) + UA_ExpandedNodeId_clear(&rt->targets[i]); + if(rt->targets) + UA_free(rt->targets); +} + +/* Double the capacity of the reftree */ +static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT +RefTree_double(RefTree *rt) { + size_t capacity = rt->capacity * 2; + UA_assert(capacity > 0); + size_t space = (sizeof(UA_ExpandedNodeId) + sizeof(RefEntry)) * capacity; + UA_ExpandedNodeId *newTargets = (UA_ExpandedNodeId*)UA_realloc(rt->targets, space); + if(!newTargets) + return UA_STATUSCODE_BADOUTOFMEMORY; + + /* Repair the pointers for the realloced array+tree */ + // What is this sorcery? + // FIXME: This needs some cleaning up or explanation. + // IMO uintptr could be completely avoided here. + uintptr_t arraydiff = (uintptr_t)newTargets - (uintptr_t)rt->targets; + RefEntry *reArray = (RefEntry*) + ((uintptr_t)newTargets + (capacity * sizeof(UA_ExpandedNodeId))); + uintptr_t entrydiff = (uintptr_t)reArray - + ((uintptr_t)rt->targets + (rt->capacity * sizeof(UA_ExpandedNodeId))); + RefEntry *oldReArray = (RefEntry*) + ((uintptr_t)newTargets + (rt->capacity * sizeof(UA_ExpandedNodeId))); + memmove(reArray, oldReArray, rt->size * sizeof(RefEntry)); + for(size_t i = 0; i < rt->size; i++) { + uintptr_t *left = (uintptr_t*)&ZIP_LEFT(&reArray[i], zipfields); + uintptr_t *right = (uintptr_t*)&ZIP_RIGHT(&reArray[i], zipfields); + if(*left != 0) + *left += entrydiff; + if(*right != 0) + *right += entrydiff; + reArray[i].target = (UA_ExpandedNodeId*)((uintptr_t)reArray[i].target + arraydiff); + } + + rt->head.zip_root = (RefEntry*)((uintptr_t)rt->head.zip_root + entrydiff); + rt->capacity = capacity; + rt->targets = newTargets; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +RefTree_add(RefTree *rt, UA_NodePointer target, UA_Boolean *duplicate) { + UA_ExpandedNodeId en = UA_NodePointer_toExpandedNodeId(target); + + /* Is the target already in the tree? */ + RefEntry dummy; + memset(&dummy, 0, sizeof(RefEntry)); + dummy.target = &en; + dummy.targetHash = UA_ExpandedNodeId_hash(&en); + if(ZIP_FIND(RefHead, &rt->head, &dummy)) { + if(duplicate) + *duplicate = true; + return UA_STATUSCODE_GOOD; + } + + UA_StatusCode s = UA_STATUSCODE_GOOD; + if(rt->capacity <= rt->size) { + s = RefTree_double(rt); + if(s != UA_STATUSCODE_GOOD) + return s; + } + s = UA_ExpandedNodeId_copy(&en, &rt->targets[rt->size]); + if(s != UA_STATUSCODE_GOOD) + return s; + RefEntry *re = (RefEntry*)((uintptr_t)rt->targets + + (sizeof(UA_ExpandedNodeId) * rt->capacity) + + (sizeof(RefEntry) * rt->size)); + re->target = &rt->targets[rt->size]; + re->targetHash = dummy.targetHash; + ZIP_INSERT(RefHead, &rt->head, re, ZIP_FFS32(UA_UInt32_random())); + rt->size++; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +RefTree_addNodeId(RefTree *rt, const UA_NodeId *target, + UA_Boolean *duplicate) { + return RefTree_add(rt, UA_NodePointer_fromNodeId(target), duplicate); +} + +UA_Boolean +RefTree_contains(RefTree *rt, const UA_ExpandedNodeId *target) { + RefEntry dummy; + dummy.target = target; + dummy.targetHash = UA_ExpandedNodeId_hash(target); + return !!ZIP_FIND(RefHead, &rt->head, &dummy); +} + +UA_Boolean +RefTree_containsNodeId(RefTree *rt, const UA_NodeId *target) { + UA_ExpandedNodeId en; + en.nodeId = *target; + en.namespaceUri = UA_STRING_NULL; + en.serverIndex = 0; + return RefTree_contains(rt, &en); +} + +/********************/ +/* Browse Recursive */ +/********************/ + +static UA_StatusCode +browseRecursiveInner(UA_Server *server, RefTree *rt, UA_UInt16 depth, UA_Boolean skip, + UA_NodePointer nodeP, UA_BrowseDirection browseDirection, + const UA_ReferenceTypeSet *refTypes, UA_UInt32 nodeClassMask) { + /* Have we reached the max recursion depth? */ + if(depth >= UA_MAX_TREE_RECURSE) + return UA_STATUSCODE_GOOD; + + const UA_Node *node = UA_NODESTORE_GETFROMREF(server, nodeP); + if(!node) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + const UA_NodeHead *head = &node->head; + + /* Add the current node to the results if we don't want to skip it (i.e. for + * includeStartNodes) and it matches the nodeClassMask filter. Process the + * children also if the nodeClassMask does not match. */ + if(!skip && matchClassMask(node, nodeClassMask)) { + UA_Boolean duplicate = false; + retval = RefTree_addNodeId(rt, &head->nodeId, &duplicate); + if(duplicate || retval != UA_STATUSCODE_GOOD) + goto cleanup; + } + + for(size_t i = 0; i < head->referencesSize; i++) { + UA_NodeReferenceKind *rk = &head->references[i]; + + /* Reference in the right direction? */ + if(rk->isInverse && browseDirection == UA_BROWSEDIRECTION_FORWARD) + continue; + if(!rk->isInverse && browseDirection == UA_BROWSEDIRECTION_INVERSE) + continue; + + /* Is the reference part of the hierarchy of references we look for? */ + if(!UA_ReferenceTypeSet_contains(refTypes, rk->referenceTypeIndex)) + continue; + + const UA_ReferenceTarget *target = NULL; + while((target = UA_NodeReferenceKind_iterate(rk, target))) { + if(UA_NodePointer_isLocal(target->targetId)) { + retval = browseRecursiveInner(server, rt, (UA_UInt16)(depth+1), false, + target->targetId, browseDirection, + refTypes, nodeClassMask); + } else { + retval = RefTree_add(rt, target->targetId, NULL); + } + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + } + } + + cleanup: + UA_NODESTORE_RELEASE(server, node); + return retval; +} + +UA_StatusCode +browseRecursive(UA_Server *server, size_t startNodesSize, const UA_NodeId *startNodes, + UA_BrowseDirection browseDirection, const UA_ReferenceTypeSet *refTypes, + UA_UInt32 nodeClassMask, UA_Boolean includeStartNodes, + size_t *resultsSize, UA_ExpandedNodeId **results) { + RefTree rt; + UA_StatusCode retval = RefTree_init(&rt); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + for(size_t i = 0; i < startNodesSize; i++) { + /* Call the inner recursive browse separately for the search direction. + * Otherwise we might take one step up and another step down in the + * search tree. */ + if(browseDirection == UA_BROWSEDIRECTION_FORWARD || + browseDirection == UA_BROWSEDIRECTION_BOTH) + retval |= browseRecursiveInner(server, &rt, 0, !includeStartNodes, + UA_NodePointer_fromNodeId(&startNodes[i]), + UA_BROWSEDIRECTION_FORWARD, + refTypes, nodeClassMask); + if(browseDirection == UA_BROWSEDIRECTION_INVERSE || + browseDirection == UA_BROWSEDIRECTION_BOTH) + retval |= browseRecursiveInner(server, &rt, 0, !includeStartNodes, + UA_NodePointer_fromNodeId(&startNodes[i]), + UA_BROWSEDIRECTION_INVERSE, + refTypes, nodeClassMask); + if(retval != UA_STATUSCODE_GOOD) + break; + } + + if(rt.size > 0 && retval == UA_STATUSCODE_GOOD) { + *results = rt.targets; + *resultsSize = rt.size; + } else { + RefTree_clear(&rt); + } + return retval; +} + +UA_StatusCode +UA_Server_browseRecursive(UA_Server *server, const UA_BrowseDescription *bd, + size_t *resultsSize, UA_ExpandedNodeId **results) { + UA_LOCK(&server->serviceMutex); + + /* Set the list of relevant reference types */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_ReferenceTypeSet refTypes; + UA_ReferenceTypeSet_any(&refTypes); + if(!UA_NodeId_isNull(&bd->referenceTypeId)) { + retval = referenceTypeIndices(server, &bd->referenceTypeId, + &refTypes, bd->includeSubtypes); + if(retval != UA_STATUSCODE_GOOD) { + UA_UNLOCK(&server->serviceMutex); + return retval; + } + } + + /* Browse */ + retval = browseRecursive(server, 1, &bd->nodeId, bd->browseDirection, + &refTypes, bd->nodeClassMask, false, resultsSize, results); + + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/**********/ +/* Browse */ +/**********/ + +typedef struct { + size_t size; + size_t capacity; + UA_ReferenceDescription *descr; +} RefResult; + +static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT +RefResult_init(RefResult *rr) { + memset(rr, 0, sizeof(RefResult)); + rr->descr = (UA_ReferenceDescription*) + UA_Array_new(UA_REFTREE_INITIAL_SIZE, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]); + if(!rr->descr) + return UA_STATUSCODE_BADOUTOFMEMORY; + rr->capacity = UA_REFTREE_INITIAL_SIZE; + rr->size = 0; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT +RefResult_double(RefResult *rr) { + size_t newSize = rr->capacity * 2; + UA_ReferenceDescription *rd = (UA_ReferenceDescription*) + UA_realloc(rr->descr, newSize * sizeof(UA_ReferenceDescription)); + if(!rd) + return UA_STATUSCODE_BADOUTOFMEMORY; + memset(&rd[rr->size], 0, sizeof(UA_ReferenceDescription) * (newSize - rr->size)); + rr->descr = rd; + rr->capacity = newSize; + return UA_STATUSCODE_GOOD; +} + +static void +RefResult_clear(RefResult *rr) { + UA_assert(rr->descr != NULL); + for(size_t i = 0; i < rr->size; i++) + UA_ReferenceDescription_clear(&rr->descr[i]); + UA_free(rr->descr); +} + +struct ContinuationPoint { + ContinuationPoint *next; + UA_ByteString identifier; + + /* Parameters of the Browse Request */ + UA_BrowseDescription browseDescription; + UA_UInt32 maxReferences; + UA_ReferenceTypeSet relevantReferences; + + /* The next target to be transmitted to the client */ + UA_ExpandedNodeId nextTarget; + UA_Byte nextRefKindIndex; +}; + +ContinuationPoint * +ContinuationPoint_clear(ContinuationPoint *cp) { + UA_ByteString_clear(&cp->identifier); + UA_BrowseDescription_clear(&cp->browseDescription); + UA_ExpandedNodeId_clear(&cp->nextTarget); + return cp->next; +} + +/* Target node on top of the stack */ +static UA_StatusCode UA_FUNC_ATTR_WARN_UNUSED_RESULT +addReferenceDescription(UA_Server *server, RefResult *rr, + const UA_NodeReferenceKind *ref, UA_UInt32 mask, + UA_NodePointer nodeP, const UA_Node *curr) { + /* Ensure capacity is left */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(rr->size >= rr->capacity) { + retval = RefResult_double(rr); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + UA_ReferenceDescription *descr = &rr->descr[rr->size]; + + /* Fields without access to the actual node */ + UA_ExpandedNodeId en = UA_NodePointer_toExpandedNodeId(nodeP); + retval = UA_ExpandedNodeId_copy(&en, &descr->nodeId); + if(mask & UA_BROWSERESULTMASK_REFERENCETYPEID) { + const UA_NodeId *refTypeId = + UA_NODESTORE_GETREFERENCETYPEID(server, ref->referenceTypeIndex); + retval |= UA_NodeId_copy(refTypeId, &descr->referenceTypeId); + } + if(mask & UA_BROWSERESULTMASK_ISFORWARD) + descr->isForward = !ref->isInverse; + + /* Remote references (ExpandedNodeId) are not further looked up here */ + if(!curr) { + UA_ReferenceDescription_clear(descr); + return retval; + } + + /* Fields that require the actual node */ + if(mask & UA_BROWSERESULTMASK_NODECLASS) + descr->nodeClass = curr->head.nodeClass; + if(mask & UA_BROWSERESULTMASK_BROWSENAME) + retval |= UA_QualifiedName_copy(&curr->head.browseName, &descr->browseName); + if(mask & UA_BROWSERESULTMASK_DISPLAYNAME) + retval |= UA_LocalizedText_copy(&curr->head.displayName, &descr->displayName); + if(mask & UA_BROWSERESULTMASK_TYPEDEFINITION) { + if(curr->head.nodeClass == UA_NODECLASS_OBJECT || + curr->head.nodeClass == UA_NODECLASS_VARIABLE) { + const UA_Node *type = getNodeType(server, &curr->head); + if(type) { + retval |= UA_NodeId_copy(&type->head.nodeId, &descr->typeDefinition.nodeId); + UA_NODESTORE_RELEASE(server, type); + } + } + } + + if(retval == UA_STATUSCODE_GOOD) + rr->size++; /* Increase the counter */ + else + UA_ReferenceDescription_clear(descr); + return retval; +} + +/* Returns whether the node / continuationpoint is done */ +static UA_StatusCode +browseReferences(UA_Server *server, const UA_NodeHead *head, + ContinuationPoint *cp, RefResult *rr, UA_Boolean *done) { + UA_assert(cp); + const UA_BrowseDescription *bd = &cp->browseDescription; + + size_t i = 0; + const UA_ReferenceTarget *ref = NULL; + + /* If the cp was previously used, skip forward to the next ReferenceType to + * be transmitted. */ + if(cp->identifier.length > 0) { + for(; i < head->referencesSize; ++i) { + UA_NodeReferenceKind *rk = &head->references[i]; + + /* Reference in the right direction? */ + if(rk->isInverse && bd->browseDirection == UA_BROWSEDIRECTION_FORWARD) + continue; + if(!rk->isInverse && bd->browseDirection == UA_BROWSEDIRECTION_INVERSE) + continue; + + /* Was this the last transmitted ReferenceType? If yes, get the next + * target to send out. */ + if(head->references[i].referenceTypeIndex == cp->nextRefKindIndex) { + ref = UA_NodeReferenceKind_findTarget(rk, &cp->nextTarget); + break; + } + } + + /* Fail with an error if the reference no longer exists. */ + if(!ref) + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Loop over the ReferenceTypes */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + for(; i < head->referencesSize; ++i) { + UA_NodeReferenceKind *rk = &head->references[i]; + + /* Reference in the right direction? */ + if(rk->isInverse && bd->browseDirection == UA_BROWSEDIRECTION_FORWARD) + continue; + if(!rk->isInverse && bd->browseDirection == UA_BROWSEDIRECTION_INVERSE) + continue; + + /* Is the reference part of the hierarchy of references we look for? */ + if(!UA_ReferenceTypeSet_contains(&cp->relevantReferences, + rk->referenceTypeIndex)) + continue; + + /* We have a matching ReferenceType! */ + + /* Loop over the targets for the ReferenceType. Start with the first + * entry if we don't have a known entry-point from the cp. */ + if(!ref) + ref = UA_NodeReferenceKind_iterate(rk, ref); + for(;ref; ref = UA_NodeReferenceKind_iterate(rk, ref)) { + /* Get the node if it is not a remote reference */ + const UA_Node *target = + UA_NODESTORE_GETFROMREF(server, ref->targetId); + + /* Test if the node class matches */ + if(target && !matchClassMask(target, bd->nodeClassMask)) { + UA_NODESTORE_RELEASE(server, target); + continue; + } + + /* We have a matching target! */ + + /* Reached maxrefs. Update the cp and bail. */ + if(rr->size >= cp->maxReferences) { + if(target) + UA_NODESTORE_RELEASE(server, target); + cp->nextRefKindIndex = rk->referenceTypeIndex; + /* Make a deep copy */ + UA_ExpandedNodeId tmpEn = + UA_NodePointer_toExpandedNodeId(ref->targetId); + return UA_ExpandedNodeId_copy(&tmpEn, &cp->nextTarget); + } + + /* Copy the node description. Target is on top of the stack */ + retval = addReferenceDescription(server, rr, rk, bd->resultMask, + ref->targetId, target); + if(target) + UA_NODESTORE_RELEASE(server, target); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + } + + /* The node is done */ + *done = true; + return UA_STATUSCODE_GOOD; +} + +/* Results for a single browsedescription. This is the inner loop for both + * Browse and BrowseNext. The ContinuationPoint contains all the data used. + * Including the BrowseDescription. Returns whether there are remaining + * references. */ +static UA_Boolean +browseWithContinuation(UA_Server *server, UA_Session *session, + ContinuationPoint *cp, UA_BrowseResult *result) { + UA_assert(cp); + const UA_BrowseDescription *descr = &cp->browseDescription; + + /* Is the browsedirection valid? */ + if(descr->browseDirection != UA_BROWSEDIRECTION_BOTH && + descr->browseDirection != UA_BROWSEDIRECTION_FORWARD && + descr->browseDirection != UA_BROWSEDIRECTION_INVERSE) { + result->statusCode = UA_STATUSCODE_BADBROWSEDIRECTIONINVALID; + return true; + } + + /* Is the reference type valid? */ + if(!UA_NodeId_isNull(&descr->referenceTypeId)) { + const UA_Node *reftype = UA_NODESTORE_GET(server, &descr->referenceTypeId); + if(!reftype) { + result->statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + return true; + } + + UA_Boolean isRef = (reftype->head.nodeClass == UA_NODECLASS_REFERENCETYPE); + UA_NODESTORE_RELEASE(server, reftype); + + if(!isRef) { + result->statusCode = UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + return true; + } + } + + const UA_Node *node = UA_NODESTORE_GET(server, &descr->nodeId); + if(!node) { + result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN; + return true; + } + + if(session != &server->adminSession && + !server->config.accessControl. + allowBrowseNode(server, &server->config.accessControl, + &session->sessionId, session->sessionHandle, + &descr->nodeId, node->head.context)) { + result->statusCode = UA_STATUSCODE_BADUSERACCESSDENIED; + UA_NODESTORE_RELEASE(server, node); + return true; + } + + RefResult rr; + result->statusCode = RefResult_init(&rr); + if(result->statusCode != UA_STATUSCODE_GOOD) { + UA_NODESTORE_RELEASE(server, node); + return true; + } + + /* Browse the references */ + UA_Boolean done = false; + result->statusCode = browseReferences(server, &node->head, cp, &rr, &done); + UA_NODESTORE_RELEASE(server, node); + if(result->statusCode != UA_STATUSCODE_GOOD) { + RefResult_clear(&rr); + return true; + } + + /* Move results */ + if(rr.size > 0) { + result->references = rr.descr; + result->referencesSize = rr.size; + } else { + /* No relevant references, return array of length zero */ + RefResult_clear(&rr); + result->references = (UA_ReferenceDescription*)UA_EMPTY_ARRAY_SENTINEL; + } + + return done; +} + +/* Start to browse with no previous cp */ +void +Operation_Browse(UA_Server *server, UA_Session *session, const UA_UInt32 *maxrefs, + const UA_BrowseDescription *descr, UA_BrowseResult *result) { + /* Stack-allocate a temporary cp */ + ContinuationPoint cp; + memset(&cp, 0, sizeof(ContinuationPoint)); + cp.maxReferences = *maxrefs; + cp.browseDescription = *descr; /* Shallow copy. Deep-copy later if we persist the cp. */ + + /* How many references can we return at most? */ + if(cp.maxReferences == 0) { + if(server->config.maxReferencesPerNode != 0) { + cp.maxReferences = server->config.maxReferencesPerNode; + } else { + cp.maxReferences = UA_INT32_MAX; + } + } else { + if(server->config.maxReferencesPerNode != 0 && + cp.maxReferences > server->config.maxReferencesPerNode) { + cp.maxReferences= server->config.maxReferencesPerNode; + } + } + + /* Get the list of relevant reference types */ + if(UA_NodeId_isNull(&descr->referenceTypeId)) { + UA_ReferenceTypeSet_any(&cp.relevantReferences); + } else { + result->statusCode = + referenceTypeIndices(server, &descr->referenceTypeId, + &cp.relevantReferences, descr->includeSubtypes); + if(result->statusCode != UA_STATUSCODE_GOOD) + return; + } + + UA_Boolean done = browseWithContinuation(server, session, &cp, result); + + /* Exit early if done or an error occurred */ + if(done || result->statusCode != UA_STATUSCODE_GOOD) + return; + + /* Persist the new continuation point */ + + ContinuationPoint *cp2 = NULL; + UA_Guid *ident = NULL; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + + /* Enough space for the continuation point? */ + if(session->availableContinuationPoints == 0) { + retval = UA_STATUSCODE_BADNOCONTINUATIONPOINTS; + goto cleanup; + } + + /* Allocate and fill the data structure */ + cp2 = (ContinuationPoint*)UA_malloc(sizeof(ContinuationPoint)); + if(!cp2) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } + + memset(cp2, 0, sizeof(ContinuationPoint)); + /* The BrowseDescription is only a shallow copy in cp */ + retval = UA_BrowseDescription_copy(descr, &cp2->browseDescription); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + cp2->maxReferences = cp.maxReferences; + cp2->relevantReferences = cp.relevantReferences; + cp2->nextTarget = cp.nextTarget; + cp2->nextRefKindIndex = cp.nextRefKindIndex; + + /* Create a random bytestring via a Guid */ + ident = UA_Guid_new(); + if(!ident) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } + *ident = UA_Guid_random(); + cp2->identifier.data = (UA_Byte*)ident; + cp2->identifier.length = sizeof(UA_Guid); + + /* Return the cp identifier */ + retval = UA_ByteString_copy(&cp2->identifier, &result->continuationPoint); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Attach the cp to the session */ + cp2->next = session->continuationPoints; + session->continuationPoints = cp2; + --session->availableContinuationPoints; + return; + + cleanup: + if(cp2) { + ContinuationPoint_clear(cp2); + UA_free(cp2); + } + UA_BrowseResult_clear(result); + result->statusCode = retval; +} + +void Service_Browse(UA_Server *server, UA_Session *session, + const UA_BrowseRequest *request, UA_BrowseResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing BrowseRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Test the number of operations in the request */ + if(server->config.maxNodesPerBrowse != 0 && + request->nodesToBrowseSize > server->config.maxNodesPerBrowse) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + /* No views supported at the moment */ + if(!UA_NodeId_isNull(&request->view.viewId)) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADVIEWIDUNKNOWN; + return; + } + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_Browse, + &request->requestedMaxReferencesPerNode, + &request->nodesToBrowseSize, + &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION], + &response->resultsSize, + &UA_TYPES[UA_TYPES_BROWSERESULT]); +} + +UA_BrowseResult +UA_Server_browse(UA_Server *server, UA_UInt32 maxReferences, + const UA_BrowseDescription *bd) { + UA_BrowseResult result; + UA_BrowseResult_init(&result); + UA_LOCK(&server->serviceMutex); + Operation_Browse(server, &server->adminSession, &maxReferences, bd, &result); + UA_UNLOCK(&server->serviceMutex); + return result; +} + +static void +Operation_BrowseNext(UA_Server *server, UA_Session *session, + const UA_Boolean *releaseContinuationPoints, + const UA_ByteString *continuationPoint, UA_BrowseResult *result) { + /* Find the continuation point */ + ContinuationPoint **prev = &session->continuationPoints; + ContinuationPoint *cp; + while((cp = *prev)) { + if(UA_ByteString_equal(&cp->identifier, continuationPoint)) + break; + prev = &cp->next; + } + if(!cp) { + result->statusCode = UA_STATUSCODE_BADCONTINUATIONPOINTINVALID; + return; + } + + /* Remove the cp */ + if(*releaseContinuationPoints) { + *prev = ContinuationPoint_clear(cp); + UA_free(cp); + ++session->availableContinuationPoints; + return; + } + + /* Continue browsing */ + UA_Boolean done = browseWithContinuation(server, session, cp, result); + + if(done) { + /* Remove the cp if there are no references left */ + *prev = ContinuationPoint_clear(cp); + UA_free(cp); + ++session->availableContinuationPoints; + } else { + /* Return the cp identifier */ + UA_StatusCode retval = + UA_ByteString_copy(&cp->identifier, &result->continuationPoint); + if(retval != UA_STATUSCODE_GOOD) { + UA_BrowseResult_clear(result); + result->statusCode = retval; + } + } +} + +void +Service_BrowseNext(UA_Server *server, UA_Session *session, + const UA_BrowseNextRequest *request, + UA_BrowseNextResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing BrowseNextRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_Boolean releaseContinuationPoints = + request->releaseContinuationPoints; /* request is const */ + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_BrowseNext, + &releaseContinuationPoints, + &request->continuationPointsSize, + &UA_TYPES[UA_TYPES_BYTESTRING], + &response->resultsSize, + &UA_TYPES[UA_TYPES_BROWSERESULT]); +} + +UA_BrowseResult +UA_Server_browseNext(UA_Server *server, UA_Boolean releaseContinuationPoint, + const UA_ByteString *continuationPoint) { + UA_BrowseResult result; + UA_BrowseResult_init(&result); + UA_LOCK(&server->serviceMutex); + Operation_BrowseNext(server, &server->adminSession, &releaseContinuationPoint, + continuationPoint, &result); + UA_UNLOCK(&server->serviceMutex); + return result; +} + +/***********************/ +/* TranslateBrowsePath */ +/***********************/ + +/* Find all entries for that hash. There are duplicate for the possible hash + * collisions. The exact browsename is checked afterwards. */ +static UA_StatusCode +recursiveAddBrowseHashTarget(RefTree *results, struct aa_head *head, + const UA_ReferenceTarget *rt) { + UA_assert(rt); + UA_StatusCode res = RefTree_add(results, rt->targetId, NULL); + UA_ReferenceTarget *prev = (UA_ReferenceTarget*)aa_prev(head, rt); + while(prev && prev->targetNameHash == rt->targetNameHash) { + res |= RefTree_add(results, prev->targetId, NULL); + prev = (UA_ReferenceTarget*)aa_prev(head, prev); + } + UA_ReferenceTarget *next= (UA_ReferenceTarget*)aa_next(head, rt); + while(next && next->targetNameHash == rt->targetNameHash) { + res |= RefTree_add(results, next->targetId, NULL); + next = (UA_ReferenceTarget*)aa_next(head, next); + } + return res; +} + +static UA_StatusCode +walkBrowsePathElement(UA_Server *server, UA_Session *session, + const UA_RelativePath *path, const size_t pathIndex, + UA_UInt32 nodeClassMask, const UA_QualifiedName *lastBrowseName, + UA_BrowsePathResult *result, RefTree *current, RefTree *next) { + /* For the next level. Note the difference from lastBrowseName */ + const UA_RelativePathElement *elem = &path->elements[pathIndex]; + UA_UInt32 browseNameHash = UA_QualifiedName_hash(&elem->targetName); + + /* Get the relevant ReferenceTypes */ + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_ReferenceTypeSet refTypes; + if(UA_NodeId_isNull(&elem->referenceTypeId)) { + UA_ReferenceTypeSet_any(&refTypes); + } else { + res = referenceTypeIndices(server, &elem->referenceTypeId, + &refTypes, elem->includeSubtypes); + if(res != UA_STATUSCODE_GOOD) + return UA_STATUSCODE_BADNOMATCH; + } + + struct aa_head _refNameTree = refNameTree; + + /* Loop over all Nodes in the current depth level */ + for(size_t i = 0; i < current->size; i++) { + /* Remote Node. Immediately add to the results with the + * RemainingPathIndex set. */ + if(!UA_ExpandedNodeId_isLocal(¤t->targets[i])) { + /* Increase the size of the results array */ + UA_BrowsePathTarget *tmpResults = (UA_BrowsePathTarget*) + UA_realloc(result->targets, sizeof(UA_BrowsePathTarget) * + (result->targetsSize + 1)); + if(!tmpResults) + return UA_STATUSCODE_BADOUTOFMEMORY; + result->targets = tmpResults; + + /* Copy over the result */ + res = UA_ExpandedNodeId_copy(¤t->targets[i], + &result->targets[result->targetsSize].targetId); + result->targets[result->targetsSize].remainingPathIndex = (UA_UInt32)pathIndex; + result->targetsSize++; + if(res != UA_STATUSCODE_GOOD) + break; + continue; + } + + /* Local Node. Add to the tree of results at the next depth. */ + const UA_Node *node = UA_NODESTORE_GET(server, ¤t->targets[i].nodeId); + if(!node) + continue; + + /* Test whether the node fits the class mask */ + UA_Boolean skip = !matchClassMask(node, nodeClassMask); + + /* Does the BrowseName match for the current node (not the references + * going out here) */ + skip |= (lastBrowseName && + !UA_QualifiedName_equal(lastBrowseName, &node->head.browseName)); + + if(skip) { + UA_NODESTORE_RELEASE(server, node); + continue; + } + + /* Loop over the ReferenceKinds */ + for(size_t j = 0; j < node->head.referencesSize; j++) { + UA_NodeReferenceKind *rk = &node->head.references[j]; + + /* Does the direction of the reference match? */ + if(rk->isInverse != elem->isInverse) + continue; + + /* Does the reference type match? */ + if(!UA_ReferenceTypeSet_contains(&refTypes, rk->referenceTypeIndex)) + continue; + + if(rk->hasRefTree) { + /* Retrieve by BrowseName hash. We might have several nodes where + * the hash matches. The exact BrowseName will be verified in the + * next iteration of the outer loop. So we only have to retrieve + * every node just once. */ + _refNameTree.root = rk->targets.tree.nameTreeRoot; + UA_ReferenceTarget *rt = (UA_ReferenceTarget*) + aa_find(&_refNameTree, &browseNameHash); + if(!rt) + continue; + + res = recursiveAddBrowseHashTarget(next, &_refNameTree, rt); + if(res != UA_STATUSCODE_GOOD) + break; + } else { + /* The array entries don't have a BrowseName hash. Add all of + * them at this level to be checked with a full string + * comparison. */ + for(size_t k = 0; k < rk->targetsSize; k++) { + if(rk->targets.array[k].targetNameHash != browseNameHash) + continue; + res = RefTree_add(next, rk->targets.array[k].targetId, NULL); + if(res != UA_STATUSCODE_GOOD) + break; + } + if(res != UA_STATUSCODE_GOOD) + break; + } + } + + UA_NODESTORE_RELEASE(server, node); + } + return res; +} + +static void +Operation_TranslateBrowsePathToNodeIds(UA_Server *server, UA_Session *session, + const UA_UInt32 *nodeClassMask, + const UA_BrowsePath *path, + UA_BrowsePathResult *result) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(path->relativePath.elementsSize == 0) { + result->statusCode = UA_STATUSCODE_BADNOTHINGTODO; + return; + } + + /* RelativePath elements must not have an empty targetName */ + for(size_t i = 0; i < path->relativePath.elementsSize; ++i) { + if(UA_QualifiedName_isNull(&path->relativePath.elements[i].targetName)) { + result->statusCode = UA_STATUSCODE_BADBROWSENAMEINVALID; + return; + } + } + + /* Check if the starting node exists */ + const UA_Node *startingNode = UA_NODESTORE_GET(server, &path->startingNode); + if(!startingNode) { + result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN; + return; + } + UA_NODESTORE_RELEASE(server, startingNode); + + /* Create two RefTrees that are alternated between path elements */ + RefTree rt1; + RefTree rt2; + RefTree *current = &rt1; + RefTree *next = &rt2; + RefTree *tmp; + result->statusCode |= RefTree_init(&rt1); + result->statusCode |= RefTree_init(&rt2); + UA_BrowsePathTarget *tmpResults = NULL; + UA_QualifiedName *browseNameFilter = NULL; + if(result->statusCode != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Copy the starting node into next */ + result->statusCode = RefTree_addNodeId(next, &path->startingNode, NULL); + if(result->statusCode != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Walk the path elements. Retrieve the nodes only once from the NodeStore. + * Hence the BrowseName is checked with one element "delay". */ + for(size_t i = 0; i < path->relativePath.elementsSize; i++) { + /* Switch the trees */ + tmp = current; + current = next; + next = tmp; + + /* Clear up current, keep the capacity */ + for(size_t j = 0; j < next->size; j++) + UA_ExpandedNodeId_clear(&next->targets[j]); + next->size = 0; + ZIP_INIT(&next->head); + + /* Do this check after next->size has been set to zero */ + if(current->size == 0) + break; + + /* Walk element for all NodeIds in the "current" tree. + * Puts new results in the "next" tree. */ + result->statusCode = + walkBrowsePathElement(server, session, &path->relativePath, i, + *nodeClassMask, browseNameFilter, result, current, next); + if(result->statusCode != UA_STATUSCODE_GOOD) + goto cleanup; + + browseNameFilter = &path->relativePath.elements[i].targetName; + } + + /* Allocate space for the results array */ + tmpResults = (UA_BrowsePathTarget*) + UA_realloc(result->targets, sizeof(UA_BrowsePathTarget) * + (result->targetsSize + next->size)); + if(!tmpResults) { + result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } + result->targets = tmpResults; + + for(size_t k = 0; k < next->size; k++) { + /* Check the BrowseName. It has been filtered only via its hash so far. */ + const UA_Node *node = UA_NODESTORE_GET(server, &next->targets[k].nodeId); + if(!node) + continue; + UA_Boolean match = UA_QualifiedName_equal(browseNameFilter, &node->head.browseName); + UA_NODESTORE_RELEASE(server, node); + if(!match) + continue; + + /* Move to the target to the results array */ + result->targets[result->targetsSize].targetId = next->targets[k]; + result->targets[result->targetsSize].remainingPathIndex = UA_UINT32_MAX; + UA_ExpandedNodeId_init(&next->targets[k]); + result->targetsSize++; + } + + /* No results => BadNoMatch status code */ + if(result->targetsSize == 0 && result->statusCode == UA_STATUSCODE_GOOD) + result->statusCode = UA_STATUSCODE_BADNOMATCH; + + /* Clean up the temporary arrays and the targets */ + cleanup: + RefTree_clear(&rt1); + RefTree_clear(&rt2); + if(result->statusCode != UA_STATUSCODE_GOOD) { + for(size_t i = 0; i < result->targetsSize; ++i) + UA_BrowsePathTarget_clear(&result->targets[i]); + if(result->targets) + UA_free(result->targets); + result->targets = NULL; + result->targetsSize = 0; + } +} + +UA_BrowsePathResult +translateBrowsePathToNodeIds(UA_Server *server, + const UA_BrowsePath *browsePath) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_BrowsePathResult result; + UA_BrowsePathResult_init(&result); + UA_UInt32 nodeClassMask = 0; /* All node classes */ + Operation_TranslateBrowsePathToNodeIds(server, &server->adminSession, &nodeClassMask, + browsePath, &result); + return result; +} + +UA_BrowsePathResult +UA_Server_translateBrowsePathToNodeIds(UA_Server *server, + const UA_BrowsePath *browsePath) { + UA_LOCK(&server->serviceMutex); + UA_BrowsePathResult result = translateBrowsePathToNodeIds(server, browsePath); + UA_UNLOCK(&server->serviceMutex); + return result; +} + +void +Service_TranslateBrowsePathsToNodeIds(UA_Server *server, UA_Session *session, + const UA_TranslateBrowsePathsToNodeIdsRequest *request, + UA_TranslateBrowsePathsToNodeIdsResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing TranslateBrowsePathsToNodeIdsRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Test the number of operations in the request */ + if(server->config.maxNodesPerTranslateBrowsePathsToNodeIds != 0 && + request->browsePathsSize > server->config.maxNodesPerTranslateBrowsePathsToNodeIds) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + UA_UInt32 nodeClassMask = 0; /* All node classes */ + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_TranslateBrowsePathToNodeIds, + &nodeClassMask, + &request->browsePathsSize, &UA_TYPES[UA_TYPES_BROWSEPATH], + &response->resultsSize, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]); +} + +UA_BrowsePathResult +browseSimplifiedBrowsePath(UA_Server *server, const UA_NodeId origin, + size_t browsePathSize, const UA_QualifiedName *browsePath) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_BrowsePathResult bpr; + UA_BrowsePathResult_init(&bpr); + if(browsePathSize > UA_MAX_TREE_RECURSE) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Simplified Browse Path too long"); + bpr.statusCode = UA_STATUSCODE_BADINTERNALERROR; + return bpr; + } + + /* Construct the BrowsePath */ + UA_BrowsePath bp; + UA_BrowsePath_init(&bp); + bp.startingNode = origin; + + UA_RelativePathElement rpe[UA_MAX_TREE_RECURSE]; + memset(rpe, 0, sizeof(UA_RelativePathElement) * browsePathSize); + for(size_t j = 0; j < browsePathSize; j++) { + rpe[j].referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES); + rpe[j].includeSubtypes = true; + rpe[j].targetName = browsePath[j]; + } + bp.relativePath.elements = rpe; + bp.relativePath.elementsSize = browsePathSize; + + /* Browse */ + UA_UInt32 nodeClassMask = UA_NODECLASS_OBJECT | UA_NODECLASS_VARIABLE; +#ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS + nodeClassMask |= UA_NODECLASS_OBJECTTYPE; +#endif /* UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS */ + + Operation_TranslateBrowsePathToNodeIds(server, &server->adminSession, &nodeClassMask, &bp, &bpr); + return bpr; +} + +UA_BrowsePathResult +UA_Server_browseSimplifiedBrowsePath(UA_Server *server, const UA_NodeId origin, + size_t browsePathSize, const UA_QualifiedName *browsePath) { + UA_LOCK(&server->serviceMutex); + UA_BrowsePathResult bpr = browseSimplifiedBrowsePath(server, origin, browsePathSize, browsePath); + UA_UNLOCK(&server->serviceMutex); + return bpr; +} + +/************/ +/* Register */ +/************/ + +void Service_RegisterNodes(UA_Server *server, UA_Session *session, + const UA_RegisterNodesRequest *request, + UA_RegisterNodesResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing RegisterNodesRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + //TODO: hang the nodeids to the session if really needed + if(request->nodesToRegisterSize == 0) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO; + return; + } + + /* Test the number of operations in the request */ + if(server->config.maxNodesPerRegisterNodes != 0 && + request->nodesToRegisterSize > server->config.maxNodesPerRegisterNodes) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + response->responseHeader.serviceResult = + UA_Array_copy(request->nodesToRegister, request->nodesToRegisterSize, + (void**)&response->registeredNodeIds, &UA_TYPES[UA_TYPES_NODEID]); + if(response->responseHeader.serviceResult == UA_STATUSCODE_GOOD) + response->registeredNodeIdsSize = request->nodesToRegisterSize; +} + +void Service_UnregisterNodes(UA_Server *server, UA_Session *session, + const UA_UnregisterNodesRequest *request, + UA_UnregisterNodesResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing UnRegisterNodesRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + //TODO: remove the nodeids from the session if really needed + if(request->nodesToUnregisterSize == 0) + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO; + + /* Test the number of operations in the request */ + if(server->config.maxNodesPerRegisterNodes != 0 && + request->nodesToUnregisterSize > server->config.maxNodesPerRegisterNodes) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } +} + +/**** amalgamated original file "/src/server/ua_services_method.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2017 (c) Florian Palm + * Copyright 2015-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016 (c) LEvertz + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Julian Grothoff + * Copyright 2020 (c) Hilscher Gesellschaft für Systemautomation mbH (Author: Martin Lang) + */ + + +#ifdef UA_ENABLE_METHODCALLS /* conditional compilation */ + +static const UA_VariableNode * +getArgumentsVariableNode(UA_Server *server, const UA_NodeHead *head, + UA_String withBrowseName) { + for(size_t i = 0; i < head->referencesSize; ++i) { + const UA_NodeReferenceKind *rk = &head->references[i]; + if(rk->isInverse != false) + continue; + if(rk->referenceTypeIndex != UA_REFERENCETYPEINDEX_HASPROPERTY) + continue; + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + const UA_Node *refTarget = + UA_NODESTORE_GETFROMREF(server, t->targetId); + if(!refTarget) + continue; + if(refTarget->head.nodeClass == UA_NODECLASS_VARIABLE && + refTarget->head.browseName.namespaceIndex == 0 && + UA_String_equal(&withBrowseName, &refTarget->head.browseName.name)) { + return &refTarget->variableNode; + } + UA_NODESTORE_RELEASE(server, refTarget); + } + } + return NULL; +} + +/* inputArgumentResults has the length request->inputArgumentsSize */ +static UA_StatusCode +typeCheckArguments(UA_Server *server, UA_Session *session, + const UA_VariableNode *argRequirements, size_t argsSize, + UA_Variant *args, UA_StatusCode *inputArgumentResults) { + /* Verify that we have a Variant containing UA_Argument (scalar or array) in + * the "InputArguments" node */ + if(argRequirements->valueSource != UA_VALUESOURCE_DATA) + return UA_STATUSCODE_BADINTERNALERROR; + if(!argRequirements->value.data.value.hasValue) + return UA_STATUSCODE_BADINTERNALERROR; + if(argRequirements->value.data.value.value.type != &UA_TYPES[UA_TYPES_ARGUMENT]) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Verify the number of arguments. A scalar argument value is interpreted as + * an array of length 1. */ + size_t argReqsSize = argRequirements->value.data.value.value.arrayLength; + if(UA_Variant_isScalar(&argRequirements->value.data.value.value)) + argReqsSize = 1; + if(argReqsSize > argsSize) + return UA_STATUSCODE_BADARGUMENTSMISSING; + if(argReqsSize < argsSize) + return UA_STATUSCODE_BADTOOMANYARGUMENTS; + + /* Type-check every argument against the definition */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_Argument *argReqs = (UA_Argument*)argRequirements->value.data.value.value.data; + for(size_t i = 0; i < argReqsSize; ++i) { + if(compatibleValue(server, session, &argReqs[i].dataType, argReqs[i].valueRank, + argReqs[i].arrayDimensionsSize, argReqs[i].arrayDimensions, + &args[i], NULL)) + continue; + + /* Incompatible try to correct the type if possible */ + adjustValueType(server, &args[i], &argReqs[i].dataType); + + /* Recheck */ + if(!compatibleValue(server, session, &argReqs[i].dataType, argReqs[i].valueRank, + argReqs[i].arrayDimensionsSize, argReqs[i].arrayDimensions, + &args[i], NULL)) { + inputArgumentResults[i] = UA_STATUSCODE_BADTYPEMISMATCH; + retval = UA_STATUSCODE_BADINVALIDARGUMENT; + } + } + return retval; +} + +/* inputArgumentResults has the length request->inputArgumentsSize */ +static UA_StatusCode +validMethodArguments(UA_Server *server, UA_Session *session, const UA_MethodNode *method, + const UA_CallMethodRequest *request, + UA_StatusCode *inputArgumentResults) { + /* Get the input arguments node */ + const UA_VariableNode *inputArguments = + getArgumentsVariableNode(server, &method->head, UA_STRING("InputArguments")); + if(!inputArguments) { + if(request->inputArgumentsSize > 0) + return UA_STATUSCODE_BADTOOMANYARGUMENTS; + return UA_STATUSCODE_GOOD; + } + + /* Verify the request */ + UA_StatusCode retval = + typeCheckArguments(server, session, inputArguments, request->inputArgumentsSize, + request->inputArguments, inputArgumentResults); + + /* Release the input arguments node */ + UA_NODESTORE_RELEASE(server, (const UA_Node*)inputArguments); + return retval; +} + +static const UA_NodeId hasComponentNodeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASCOMPONENT}}; +static const UA_NodeId organizedByNodeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_ORGANIZES}}; +static const UA_String namespaceDiModel = UA_STRING_STATIC("http://opcfoundation.org/UA/DI/"); +static const UA_NodeId hasTypeDefinitionNodeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASTYPEDEFINITION}}; +// ns=0 will be replace dynamically. DI-Spec. 1.01: +static UA_NodeId functionGroupNodeId = {0, UA_NODEIDTYPE_NUMERIC, {1005}}; + +static void +callWithMethodAndObject(UA_Server *server, UA_Session *session, + const UA_CallMethodRequest *request, UA_CallMethodResult *result, + const UA_MethodNode *method, const UA_ObjectNode *object) { + /* Verify the object's NodeClass */ + if(object->head.nodeClass != UA_NODECLASS_OBJECT && + object->head.nodeClass != UA_NODECLASS_OBJECTTYPE) { + result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID; + return; + } + + /* Verify the method's NodeClass */ + if(method->head.nodeClass != UA_NODECLASS_METHOD) { + result->statusCode = UA_STATUSCODE_BADNODECLASSINVALID; + return; + } + + /* Is there a method to execute? */ + if(!method->method) { + result->statusCode = UA_STATUSCODE_BADINTERNALERROR; + return; + } + + UA_NodePointer methodP = UA_NodePointer_fromNodeId(&request->methodId); + + /* Verify method/object relations. Object must have a hasComponent or a + * subtype of hasComponent reference to the method node. Therefore, check + * every reference between the parent object and the method node if there is + * a hasComponent (or subtype) reference */ + UA_ReferenceTypeSet hasComponentRefs; + result->statusCode = + referenceTypeIndices(server, &hasComponentNodeId, &hasComponentRefs, true); + if(result->statusCode != UA_STATUSCODE_GOOD) + return; + + UA_Boolean found = false; + for(size_t i = 0; i < object->head.referencesSize && !found; ++i) { + const UA_NodeReferenceKind *rk = &object->head.references[i]; + if(rk->isInverse) + continue; + if(!UA_ReferenceTypeSet_contains(&hasComponentRefs, rk->referenceTypeIndex)) + continue; + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + if(UA_NodePointer_equal(t->targetId, methodP)) { + found = true; + break; + } + } + } + + if(!found) { + /* The following ParentObject evaluation is a workaround only to fulfill + * the OPC UA Spec. Part 100 - Devices requirements regarding functional + * groups. Compare OPC UA Spec. Part 100 - Devices, Release 1.02 + * - 5.4 FunctionalGroupType + * - B.1 Functional Group Usages + * A functional group is a sub-type of the FolderType and is used to + * organize the Parameters and Methods from the complete set (named + * ParameterSet and MethodSet) in (Functional) groups for instance + * Configuration or Identification. The same Property, Parameter or + * Method can be referenced from more than one FunctionalGroup. */ + + /* Check whether the DI namespace is available */ + size_t foundNamespace = 0; + UA_StatusCode res = getNamespaceByName(server, namespaceDiModel, &foundNamespace); + if(res != UA_STATUSCODE_GOOD) { + result->statusCode = UA_STATUSCODE_BADMETHODINVALID; + return; + } + functionGroupNodeId.namespaceIndex = (UA_UInt16)foundNamespace; + + UA_ReferenceTypeSet hasTypeDefinitionRefs; + result->statusCode = + referenceTypeIndices(server, &hasTypeDefinitionNodeId, + &hasTypeDefinitionRefs, true); + if(result->statusCode != UA_STATUSCODE_GOOD) + return; + + /* Search for a HasTypeDefinition (or sub-) reference in the parent object */ + for(size_t i = 0; i < object->head.referencesSize && !found; ++i) { + const UA_NodeReferenceKind *rk = &object->head.references[i]; + if(rk->isInverse) + continue; + if(!UA_ReferenceTypeSet_contains(&hasTypeDefinitionRefs, rk->referenceTypeIndex)) + continue; + + /* Verify that the HasTypeDefinition is equal to FunctionGroupType + * (or sub-type) from the DI model */ + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + if(!UA_NodePointer_isLocal(t->targetId)) + continue; + + UA_NodeId tmpId = UA_NodePointer_toNodeId(t->targetId); + if(!isNodeInTree_singleRef(server, &tmpId, &functionGroupNodeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) + continue; + + /* Search for the called method with reference Organize (or + * sub-type) from the parent object */ + for(size_t k = 0; k < object->head.referencesSize && !found; ++k) { + const UA_NodeReferenceKind *rkInner = &object->head.references[k]; + if(rkInner->isInverse) + continue; + const UA_NodeId * refId = + UA_NODESTORE_GETREFERENCETYPEID(server, rkInner->referenceTypeIndex); + if(!isNodeInTree_singleRef(server, refId, &organizedByNodeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) + continue; + + const UA_ReferenceTarget *t2 = NULL; + while((t2 = UA_NodeReferenceKind_iterate(rkInner, t2))) { + if(UA_NodePointer_equal(t2->targetId, methodP)) { + found = true; + break; + } + } + } + } + } + if(!found) { + result->statusCode = UA_STATUSCODE_BADMETHODINVALID; + return; + } + } + + /* Verify access rights */ + UA_Boolean executable = method->executable; + if(session != &server->adminSession) { + UA_UNLOCK(&server->serviceMutex); + executable = executable && server->config.accessControl. + getUserExecutableOnObject(server, &server->config.accessControl, &session->sessionId, + session->sessionHandle, &request->methodId, method->head.context, + &request->objectId, object->head.context); + UA_LOCK(&server->serviceMutex); + } + + if(!executable) { + result->statusCode = UA_STATUSCODE_BADNOTEXECUTABLE; + return; + } + + /* Allocate the inputArgumentResults array */ + result->inputArgumentResults = (UA_StatusCode*) + UA_Array_new(request->inputArgumentsSize, &UA_TYPES[UA_TYPES_STATUSCODE]); + if(!result->inputArgumentResults) { + result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + result->inputArgumentResultsSize = request->inputArgumentsSize; + + /* Verify Input Arguments */ + result->statusCode = validMethodArguments(server, session, method, request, + result->inputArgumentResults); + + /* Return inputArgumentResults only for BADINVALIDARGUMENT */ + if(result->statusCode != UA_STATUSCODE_BADINVALIDARGUMENT) { + UA_Array_delete(result->inputArgumentResults, result->inputArgumentResultsSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); + result->inputArgumentResults = NULL; + result->inputArgumentResultsSize = 0; + } + + /* Error during type-checking? */ + if(result->statusCode != UA_STATUSCODE_GOOD) + return; + + /* Get the output arguments node */ + const UA_VariableNode *outputArguments = + getArgumentsVariableNode(server, &method->head, UA_STRING("OutputArguments")); + + /* Allocate the output arguments array */ + size_t outputArgsSize = 0; + if(outputArguments) + outputArgsSize = outputArguments->value.data.value.value.arrayLength; + result->outputArguments = (UA_Variant*) + UA_Array_new(outputArgsSize, &UA_TYPES[UA_TYPES_VARIANT]); + if(!result->outputArguments) { + result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + result->outputArgumentsSize = outputArgsSize; + + /* Release the output arguments node */ + UA_NODESTORE_RELEASE(server, (const UA_Node*)outputArguments); + + /* Call the method */ + UA_UNLOCK(&server->serviceMutex); + result->statusCode = method->method(server, &session->sessionId, session->sessionHandle, + &method->head.nodeId, method->head.context, + &object->head.nodeId, object->head.context, + request->inputArgumentsSize, request->inputArguments, + result->outputArgumentsSize, result->outputArguments); + UA_LOCK(&server->serviceMutex); + /* TODO: Verify Output matches the argument definition */ +} + +#if UA_MULTITHREADING >= 100 + +static void +Operation_CallMethodAsync(UA_Server *server, UA_Session *session, UA_UInt32 requestId, + UA_UInt32 requestHandle, size_t opIndex, + UA_CallMethodRequest *opRequest, UA_CallMethodResult *opResult, + UA_AsyncResponse **ar) { + /* Get the method node */ + const UA_Node *method = UA_NODESTORE_GET(server, &opRequest->methodId); + if(!method) { + opResult->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN; + return; + } + + /* Get the object node */ + const UA_Node *object = UA_NODESTORE_GET(server, &opRequest->objectId); + if(!object) { + opResult->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN; + UA_NODESTORE_RELEASE(server, method); + return; + } + + /* Synchronous execution */ + if(!method->methodNode.async) { + callWithMethodAndObject(server, session, opRequest, opResult, + &method->methodNode, &object->objectNode); + goto cleanup; + } + + /* <-- Async method call --> */ + + /* No AsyncResponse allocated so far */ + if(!*ar) { + opResult->statusCode = + UA_AsyncManager_createAsyncResponse(&server->asyncManager, server, + &session->sessionId, requestId, requestHandle, + UA_ASYNCOPERATIONTYPE_CALL, ar); + if(opResult->statusCode != UA_STATUSCODE_GOOD) + goto cleanup; + } + + /* Create the Async Request to be taken by workers */ + opResult->statusCode = + UA_AsyncManager_createAsyncOp(&server->asyncManager, + server, *ar, opIndex, opRequest); + + cleanup: + /* Release the method and object node */ + UA_NODESTORE_RELEASE(server, method); + UA_NODESTORE_RELEASE(server, object); +} + +void +Service_CallAsync(UA_Server *server, UA_Session *session, UA_UInt32 requestId, + const UA_CallRequest *request, UA_CallResponse *response, + UA_Boolean *finished) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing CallRequestAsync"); + if(server->config.maxNodesPerMethodCall != 0 && + request->methodsToCallSize > server->config.maxNodesPerMethodCall) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + UA_AsyncResponse *ar = NULL; + response->responseHeader.serviceResult = + UA_Server_processServiceOperationsAsync(server, session, requestId, + request->requestHeader.requestHandle, + (UA_AsyncServiceOperation)Operation_CallMethodAsync, + &request->methodsToCallSize, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST], + &response->resultsSize, &UA_TYPES[UA_TYPES_CALLMETHODRESULT], &ar); + + if(ar) { + if(ar->opCountdown > 0) { + /* Move all results to the AsyncResponse. The async operation + * results will be overwritten when the workers return results. */ + ar->response.callResponse = *response; + UA_CallResponse_init(response); + *finished = false; + } else { + /* If there is a new AsyncResponse, ensure it has at least one + * pending operation */ + UA_AsyncManager_removeAsyncResponse(&server->asyncManager, ar); + } + } +} +#endif + +static void +Operation_CallMethod(UA_Server *server, UA_Session *session, void *context, + const UA_CallMethodRequest *request, UA_CallMethodResult *result) { + /* Get the method node */ + const UA_Node *method = UA_NODESTORE_GET(server, &request->methodId); + if(!method) { + result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN; + return; + } + + /* Get the object node */ + const UA_Node *object = UA_NODESTORE_GET(server, &request->objectId); + if(!object) { + result->statusCode = UA_STATUSCODE_BADNODEIDUNKNOWN; + UA_NODESTORE_RELEASE(server, method); + return; + } + + /* Continue with method and object as context */ + callWithMethodAndObject(server, session, request, result, + &method->methodNode, &object->objectNode); + + /* Release the method and object node */ + UA_NODESTORE_RELEASE(server, method); + UA_NODESTORE_RELEASE(server, object); +} + +void Service_Call(UA_Server *server, UA_Session *session, + const UA_CallRequest *request, UA_CallResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing CallRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxNodesPerMethodCall != 0 && + request->methodsToCallSize > server->config.maxNodesPerMethodCall) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_CallMethod, NULL, + &request->methodsToCallSize, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST], + &response->resultsSize, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]); +} + +UA_CallMethodResult +UA_Server_call(UA_Server *server, const UA_CallMethodRequest *request) { + UA_CallMethodResult result; + UA_CallMethodResult_init(&result); + UA_LOCK(&server->serviceMutex); + Operation_CallMethod(server, &server->adminSession, NULL, request, &result); + UA_UNLOCK(&server->serviceMutex); + return result; +} + +#endif /* UA_ENABLE_METHODCALLS */ + +/**** amalgamated original file "/src/server/ua_services_session.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2017 (c) Florian Palm + * Copyright 2014-2016 (c) Sten Grüner + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017-2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2018-2020 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + +/* Delayed callback to free the session memory */ +static void +removeSessionCallback(UA_Server *server, session_list_entry *entry) { + UA_LOCK(&server->serviceMutex); + UA_Session_clear(&entry->session, server); + UA_UNLOCK(&server->serviceMutex); +} + +void +UA_Server_removeSession(UA_Server *server, session_list_entry *sentry, + UA_DiagnosticEvent event) { + UA_Session *session = &sentry->session; + + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Remove the Subscriptions */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_Subscription *sub, *tempsub; + TAILQ_FOREACH_SAFE(sub, &session->subscriptions, sessionListEntry, tempsub) { + UA_Subscription_delete(server, sub); + } + + UA_PublishResponseEntry *entry; + while((entry = UA_Session_dequeuePublishReq(session))) { + UA_PublishResponse_clear(&entry->response); + UA_free(entry); + } +#endif + + /* Callback into userland access control */ + if(server->config.accessControl.closeSession) { + UA_UNLOCK(&server->serviceMutex); + server->config.accessControl.closeSession(server, &server->config.accessControl, + &session->sessionId, session->sessionHandle); + UA_LOCK(&server->serviceMutex); + } + + /* Detach the Session from the SecureChannel */ + UA_Session_detachFromSecureChannel(session); + + /* Deactivate the session */ + sentry->session.activated = false; + + /* Detach the session from the session manager and make the capacity + * available */ + LIST_REMOVE(sentry, pointers); + UA_atomic_subUInt32(&server->sessionCount, 1); + UA_atomic_subSize(&server->serverStats.ss.currentSessionCount, 1); + + switch(event) { + case UA_DIAGNOSTICEVENT_CLOSE: + case UA_DIAGNOSTICEVENT_PURGE: + break; + case UA_DIAGNOSTICEVENT_TIMEOUT: + UA_atomic_addSize(&server->serverStats.ss.sessionTimeoutCount, 1); + break; + case UA_DIAGNOSTICEVENT_REJECT: + UA_atomic_addSize(&server->serverStats.ss.rejectedSessionCount, 1); + break; + case UA_DIAGNOSTICEVENT_SECURITYREJECT: + UA_atomic_addSize(&server->serverStats.ss.securityRejectedSessionCount, 1); + break; + case UA_DIAGNOSTICEVENT_ABORT: + UA_atomic_addSize(&server->serverStats.ss.sessionAbortCount, 1); + break; + default: + UA_assert(false); + break; + } + + /* Add a delayed callback to remove the session when the currently + * scheduled jobs have completed */ + sentry->cleanupCallback.callback = (UA_ApplicationCallback)removeSessionCallback; + sentry->cleanupCallback.application = server; + sentry->cleanupCallback.data = sentry; + sentry->cleanupCallback.nextTime = UA_DateTime_nowMonotonic() + 1; + sentry->cleanupCallback.interval = 0; /* Remove the structure */ + UA_Timer_addTimerEntry(&server->timer, &sentry->cleanupCallback, NULL); +} + +UA_StatusCode +UA_Server_removeSessionByToken(UA_Server *server, const UA_NodeId *token, + UA_DiagnosticEvent event) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + session_list_entry *entry; + LIST_FOREACH(entry, &server->sessions, pointers) { + if(UA_NodeId_equal(&entry->session.header.authenticationToken, token)) { + UA_Server_removeSession(server, entry, event); + return UA_STATUSCODE_GOOD; + } + } + return UA_STATUSCODE_BADSESSIONIDINVALID; +} + +void +UA_Server_cleanupSessions(UA_Server *server, UA_DateTime nowMonotonic) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + session_list_entry *sentry, *temp; + LIST_FOREACH_SAFE(sentry, &server->sessions, pointers, temp) { + /* Session has timed out? */ + if(sentry->session.validTill >= nowMonotonic) + continue; + UA_LOG_INFO_SESSION(&server->config.logger, &sentry->session, "Session has timed out"); + UA_Server_removeSession(server, sentry, UA_DIAGNOSTICEVENT_TIMEOUT); + } +} + +/************/ +/* Services */ +/************/ + +UA_Session * +getSessionByToken(UA_Server *server, const UA_NodeId *token) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + session_list_entry *current = NULL; + LIST_FOREACH(current, &server->sessions, pointers) { + /* Token does not match */ + if(!UA_NodeId_equal(¤t->session.header.authenticationToken, token)) + continue; + + /* Session has timed out */ + if(UA_DateTime_nowMonotonic() > current->session.validTill) { + UA_LOG_INFO_SESSION(&server->config.logger, ¤t->session, + "Client tries to use a session that has timed out"); + return NULL; + } + + return ¤t->session; + } + + return NULL; +} + +UA_Session * +UA_Server_getSessionById(UA_Server *server, const UA_NodeId *sessionId) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + session_list_entry *current = NULL; + LIST_FOREACH(current, &server->sessions, pointers) { + /* Token does not match */ + if(!UA_NodeId_equal(¤t->session.sessionId, sessionId)) + continue; + + /* Session has timed out */ + if(UA_DateTime_nowMonotonic() > current->session.validTill) { + UA_LOG_INFO_SESSION(&server->config.logger, ¤t->session, + "Client tries to use a session that has timed out"); + return NULL; + } + + return ¤t->session; + } + + return NULL; +} + +static UA_StatusCode +signCreateSessionResponse(UA_Server *server, UA_SecureChannel *channel, + const UA_CreateSessionRequest *request, + UA_CreateSessionResponse *response) { + if(channel->securityMode != UA_MESSAGESECURITYMODE_SIGN && + channel->securityMode != UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + return UA_STATUSCODE_GOOD; + + const UA_SecurityPolicy *securityPolicy = channel->securityPolicy; + UA_SignatureData *signatureData = &response->serverSignature; + + /* Prepare the signature */ + size_t signatureSize = securityPolicy->certificateSigningAlgorithm. + getLocalSignatureSize(channel->channelContext); + UA_StatusCode retval = UA_String_copy(&securityPolicy->certificateSigningAlgorithm.uri, + &signatureData->algorithm); + retval |= UA_ByteString_allocBuffer(&signatureData->signature, signatureSize); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Allocate a temp buffer */ + size_t dataToSignSize = request->clientCertificate.length + request->clientNonce.length; + UA_ByteString dataToSign; + retval = UA_ByteString_allocBuffer(&dataToSign, dataToSignSize); + if(retval != UA_STATUSCODE_GOOD) + return retval; /* signatureData->signature is cleaned up with the response */ + + /* Sign the signature */ + memcpy(dataToSign.data, request->clientCertificate.data, request->clientCertificate.length); + memcpy(dataToSign.data + request->clientCertificate.length, + request->clientNonce.data, request->clientNonce.length); + retval = securityPolicy->certificateSigningAlgorithm. + sign(channel->channelContext, &dataToSign, &signatureData->signature); + + /* Clean up */ + UA_ByteString_clear(&dataToSign); + return retval; +} + +/* Creates and adds a session. But it is not yet attached to a secure channel. */ +UA_StatusCode +UA_Server_createSession(UA_Server *server, UA_SecureChannel *channel, + const UA_CreateSessionRequest *request, UA_Session **session) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->sessionCount >= server->config.maxSessions) + return UA_STATUSCODE_BADTOOMANYSESSIONS; + + session_list_entry *newentry = (session_list_entry *)UA_malloc(sizeof(session_list_entry)); + if(!newentry) + return UA_STATUSCODE_BADOUTOFMEMORY; + + UA_atomic_addUInt32(&server->sessionCount, 1); + UA_Session_init(&newentry->session); + newentry->session.sessionId = UA_NODEID_GUID(1, UA_Guid_random()); + newentry->session.header.authenticationToken = UA_NODEID_GUID(1, UA_Guid_random()); + + if(request->requestedSessionTimeout <= server->config.maxSessionTimeout && + request->requestedSessionTimeout > 0) + newentry->session.timeout = request->requestedSessionTimeout; + else + newentry->session.timeout = server->config.maxSessionTimeout; + + /* Attach the session to the channel. But don't activate for now. */ + if(channel) + UA_Session_attachToSecureChannel(&newentry->session, channel); + UA_Session_updateLifetime(&newentry->session); + + LIST_INSERT_HEAD(&server->sessions, newentry, pointers); + *session = &newentry->session; + return UA_STATUSCODE_GOOD; +} + +void +Service_CreateSession(UA_Server *server, UA_SecureChannel *channel, + const UA_CreateSessionRequest *request, + UA_CreateSessionResponse *response) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_LOG_DEBUG_CHANNEL(&server->config.logger, channel, "Trying to create session"); + + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGN || + channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + /* Compare the clientCertificate with the remoteCertificate of the channel. + * Both the clientCertificate of this request and the remoteCertificate + * of the channel may contain a partial or a complete certificate chain. + * The compareCertificate function of the channelModule will compare the + * first certificate of each chain. The end certificate shall be located + * first in the chain according to the OPC UA specification Part 6 (1.04), + * chapter 6.2.3.*/ + UA_StatusCode retval = channel->securityPolicy->channelModule. + compareCertificate(channel->channelContext, &request->clientCertificate); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "The client certificate did not validate"); + response->responseHeader.serviceResult = UA_STATUSCODE_BADCERTIFICATEINVALID; + return; + } + } + + UA_assert(channel->securityToken.channelId != 0); + + if(!UA_ByteString_equal(&channel->securityPolicy->policyUri, + &UA_SECURITY_POLICY_NONE_URI) && + request->clientNonce.length < 32) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADNONCEINVALID; + return; + } + + if(request->clientCertificate.length > 0) { + UA_CertificateVerification *cv = &server->config.certificateVerification; + response->responseHeader.serviceResult = + cv->verifyApplicationURI(cv->context, &request->clientCertificate, + &request->clientDescription.applicationUri); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "The client's ApplicationURI did not match the certificate"); + UA_atomic_addSize(&server->serverStats.ss.securityRejectedSessionCount, 1); + UA_atomic_addSize(&server->serverStats.ss.rejectedSessionCount, 1); + return; + } + } + + UA_Session *newSession = NULL; + response->responseHeader.serviceResult = + UA_Server_createSession(server, channel, request, &newSession); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "Processing CreateSessionRequest failed"); + UA_atomic_addSize(&server->serverStats.ss.rejectedSessionCount, 1); + return; + } + + UA_assert(newSession != NULL); + + /* Allocate the response */ + response->serverEndpoints = (UA_EndpointDescription *) + UA_Array_new(server->config.endpointsSize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); + if(!response->serverEndpoints) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + UA_Server_removeSessionByToken(server, &newSession->header.authenticationToken, + UA_DIAGNOSTICEVENT_REJECT); + return; + } + response->serverEndpointsSize = server->config.endpointsSize; + + /* Copy the server's endpointdescriptions into the response */ + for(size_t i = 0; i < server->config.endpointsSize; ++i) + response->responseHeader.serviceResult |= + UA_EndpointDescription_copy(&server->config.endpoints[i], + &response->serverEndpoints[i]); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_Server_removeSessionByToken(server, &newSession->header.authenticationToken, + UA_DIAGNOSTICEVENT_REJECT); + return; + } + + /* Mirror back the endpointUrl */ + for(size_t i = 0; i < response->serverEndpointsSize; ++i) { + UA_String_clear(&response->serverEndpoints[i].endpointUrl); + response->responseHeader.serviceResult |= + UA_String_copy(&request->endpointUrl, + &response->serverEndpoints[i].endpointUrl); + } + + /* Fill the session information */ + newSession->maxResponseMessageSize = request->maxResponseMessageSize; + newSession->maxRequestMessageSize = channel->config.localMaxMessageSize; + response->responseHeader.serviceResult |= + UA_ApplicationDescription_copy(&request->clientDescription, + &newSession->clientDescription); + + /* Prepare the response */ + response->sessionId = newSession->sessionId; + response->revisedSessionTimeout = (UA_Double)newSession->timeout; + response->authenticationToken = newSession->header.authenticationToken; + response->responseHeader.serviceResult |= + UA_String_copy(&request->sessionName, &newSession->sessionName); + + UA_ByteString_init(&response->serverCertificate); + + if(server->config.endpointsSize > 0) + for(size_t i = 0; i < response->serverEndpointsSize; ++i) { + if(response->serverEndpoints[i].securityMode==channel->securityMode && + UA_ByteString_equal(&response->serverEndpoints[i].securityPolicyUri, + &channel->securityPolicy->policyUri) && + UA_String_equal(&response->serverEndpoints[i].endpointUrl, + &request->endpointUrl)) + { + response->responseHeader.serviceResult |= + UA_ByteString_copy(&response->serverEndpoints[i].serverCertificate, + &response->serverCertificate); + } + } + + /* Create a session nonce */ + response->responseHeader.serviceResult |= UA_Session_generateNonce(newSession); + response->responseHeader.serviceResult |= + UA_ByteString_copy(&newSession->serverNonce, &response->serverNonce); + + /* Sign the signature */ + response->responseHeader.serviceResult |= + signCreateSessionResponse(server, channel, request, response); + + /* Failure -> remove the session */ + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_Server_removeSessionByToken(server, &newSession->header.authenticationToken, + UA_DIAGNOSTICEVENT_REJECT); + return; + } + + UA_LOG_INFO_SESSION(&server->config.logger, newSession, "Session created"); +} + +static UA_StatusCode +checkSignature(const UA_Server *server, const UA_SecurityPolicy *securityPolicy, + void *channelContext, const UA_ByteString *serverNonce, + const UA_SignatureData *signature) { + /* Check for zero signature length */ + if(signature->signature.length == 0) + return UA_STATUSCODE_BADAPPLICATIONSIGNATUREINVALID; + + if(!securityPolicy) + return UA_STATUSCODE_BADINTERNALERROR; + + const UA_ByteString *localCertificate = &securityPolicy->localCertificate; + /* Data to verify is calculated by appending the serverNonce to the local certificate */ + UA_ByteString dataToVerify; + size_t dataToVerifySize = localCertificate->length + serverNonce->length; + UA_StatusCode retval = UA_ByteString_allocBuffer(&dataToVerify, dataToVerifySize); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + memcpy(dataToVerify.data, localCertificate->data, localCertificate->length); + memcpy(dataToVerify.data + localCertificate->length, + serverNonce->data, serverNonce->length); + retval = securityPolicy->certificateSigningAlgorithm. + verify(channelContext, &dataToVerify, &signature->signature); + UA_ByteString_clear(&dataToVerify); + return retval; +} + +#ifdef UA_ENABLE_ENCRYPTION + +static UA_StatusCode +decryptPassword(UA_SecurityPolicy *securityPolicy, void *tempChannelContext, + const UA_ByteString *serverNonce, UA_UserNameIdentityToken *userToken) { + UA_SecurityPolicyEncryptionAlgorithm *asymEnc = + &securityPolicy->asymmetricModule.cryptoModule.encryptionAlgorithm; + if(!UA_String_equal(&userToken->encryptionAlgorithm, &asymEnc->uri)) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + UA_UInt32 tokenSecretLength; + UA_ByteString decryptedTokenSecret, tokenServerNonce; + size_t tokenpos = 0; + size_t offset = 0; + if(UA_ByteString_copy(&userToken->password, &decryptedTokenSecret) != UA_STATUSCODE_GOOD) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + UA_StatusCode retval = UA_STATUSCODE_BADIDENTITYTOKENINVALID; + if(asymEnc->decrypt(tempChannelContext, &decryptedTokenSecret) != UA_STATUSCODE_GOOD) + goto cleanup; + + UA_UInt32_decodeBinary(&decryptedTokenSecret, &offset, &tokenSecretLength); + + /* The decrypted data must be large enough to include the Encrypted Token + * Secret Format and the length field must indicate enough data to include + * the server nonce. */ + if(decryptedTokenSecret.length < sizeof(UA_UInt32) + serverNonce->length || + decryptedTokenSecret.length < sizeof(UA_UInt32) + tokenSecretLength || + tokenSecretLength < serverNonce->length) + goto cleanup; + + /* If the Encrypted Token Secret contains padding, the padding must be + * zeroes according to the 1.04.1 specification errata, chapter 3. */ + for(size_t i = sizeof(UA_UInt32) + tokenSecretLength; i < decryptedTokenSecret.length; i++) { + if(decryptedTokenSecret.data[i] != 0) + goto cleanup; + } + + /* The server nonce must match according to the 1.04.1 specification errata, + * chapter 3. */ + tokenpos = sizeof(UA_UInt32) + tokenSecretLength - serverNonce->length; + tokenServerNonce.length = serverNonce->length; + tokenServerNonce.data = &decryptedTokenSecret.data[tokenpos]; + if(!UA_ByteString_equal(serverNonce, &tokenServerNonce)) + goto cleanup; + + /* The password was decrypted successfully. Replace usertoken with the + * decrypted password. The encryptionAlgorithm and policyId fields are left + * in the UserToken as an indication for the AccessControl plugin that + * evaluates the decrypted content. */ + memcpy(userToken->password.data, &decryptedTokenSecret.data[sizeof(UA_UInt32)], + tokenSecretLength - serverNonce->length); + userToken->password.length = tokenSecretLength - serverNonce->length; + retval = UA_STATUSCODE_GOOD; + + cleanup: + UA_ByteString_clear(&decryptedTokenSecret); + return retval; +} +#endif + +static void +selectEndpointAndTokenPolicy(UA_Server *server, UA_SecureChannel *channel, + const UA_ExtensionObject *identityToken, + const UA_EndpointDescription **ed, + const UA_UserTokenPolicy **utp) { + for(size_t i = 0; i < server->config.endpointsSize; ++i) { + const UA_EndpointDescription *desc = &server->config.endpoints[i]; + + /* Match the Security Mode */ + if(desc->securityMode != channel->securityMode) + continue; + + /* Match the SecurityPolicy of the endpoint with the current channel */ + if(!UA_String_equal(&desc->securityPolicyUri, &channel->securityPolicy->policyUri)) + continue; + + /* Match the UserTokenType */ + const UA_DataType *tokenDataType = identityToken->content.decoded.type; + for(size_t j = 0; j < desc->userIdentityTokensSize; j++) { + const UA_UserTokenPolicy *pol = &desc->userIdentityTokens[j]; + + /* Part 4, Section 5.6.3.2, Table 17: A NULL or empty + * UserIdentityToken should be treated as Anonymous */ + if(identityToken->encoding == UA_EXTENSIONOBJECT_ENCODED_NOBODY && + pol->tokenType == UA_USERTOKENTYPE_ANONYMOUS) { + *ed = desc; + *utp = pol; + return; + } + + /* Expect decoded content */ + if(!tokenDataType) + continue; + + if(pol->tokenType == UA_USERTOKENTYPE_ANONYMOUS) { + if(tokenDataType != &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]) + continue; + } else if(pol->tokenType == UA_USERTOKENTYPE_USERNAME) { + if(tokenDataType != &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]) + continue; + } else if(pol->tokenType == UA_USERTOKENTYPE_CERTIFICATE) { + if(tokenDataType != &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]) + continue; + } else if(pol->tokenType == UA_USERTOKENTYPE_ISSUEDTOKEN) { + if(tokenDataType != &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]) + continue; + } else { + continue; + } + + /* All valid token data types start with a string policyId */ + UA_AnonymousIdentityToken *token = (UA_AnonymousIdentityToken*) + identityToken->content.decoded.data; + + if(!UA_String_equal(&pol->policyId, &token->policyId)) + continue; + + /* Match found */ + *ed = desc; + *utp = pol; + return; + } + } +} + +/* TODO: Check all of the following: The Server shall verify that the + * Certificate the Client used to create the new SecureChannel is the same as + * the Certificate used to create the original SecureChannel. In addition, the + * Server shall verify that the Client supplied a UserIdentityToken that is + * identical to the token currently associated with the Session. Once the Server + * accepts the new SecureChannel it shall reject requests sent via the old + * SecureChannel. */ + +void +Service_ActivateSession(UA_Server *server, UA_SecureChannel *channel, + const UA_ActivateSessionRequest *request, + UA_ActivateSessionResponse *response) { + const UA_EndpointDescription *ed = NULL; + const UA_UserTokenPolicy *utp = NULL; + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_Session *session = getSessionByToken(server, &request->requestHeader.authenticationToken); + if(!session) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "ActivateSession: Session not found"); + response->responseHeader.serviceResult = UA_STATUSCODE_BADSESSIONIDINVALID; + goto rejected; + } + + /* Part 4, §5.6.3: When the ActivateSession Service is called for the + * first time then the Server shall reject the request if the + * SecureChannel is not same as the one associated with the + * CreateSession request. Subsequent calls to ActivateSession may be + * associated with different SecureChannels. */ + if(!session->activated && session->header.channel != channel) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "ActivateSession: The Session has to be initially activated " + "on the SecureChannel that created it"); + response->responseHeader.serviceResult = UA_STATUSCODE_BADSESSIONIDINVALID; + goto rejected; + } + + /* Has the session timed out? */ + if(session->validTill < UA_DateTime_nowMonotonic()) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "ActivateSession: The Session has timed out"); + response->responseHeader.serviceResult = UA_STATUSCODE_BADSESSIONIDINVALID; + goto rejected; + } + + /* Check the client signature */ + if(channel->securityMode == UA_MESSAGESECURITYMODE_SIGN || + channel->securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + response->responseHeader.serviceResult = + checkSignature(server, channel->securityPolicy, channel->channelContext, + &session->serverNonce, &request->clientSignature); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "ActivateSession: Client signature check failed with StatusCode %s", + UA_StatusCode_name(response->responseHeader.serviceResult)); + goto securityRejected; + } + } + + /* Find the matching Endpoint with UserTokenPolicy */ + selectEndpointAndTokenPolicy(server, channel, &request->userIdentityToken, &ed, &utp); + if(!ed) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADIDENTITYTOKENINVALID; + goto rejected; + } + + /* If it is a UserNameIdentityToken, the password may be encrypted */ + if(utp->tokenType == UA_USERTOKENTYPE_USERNAME) { + UA_UserNameIdentityToken *userToken = (UA_UserNameIdentityToken *) + request->userIdentityToken.content.decoded.data; + + /* If the userTokenPolicy doesn't specify a security policy the security + * policy of the secure channel is used. */ + UA_SecurityPolicy* securityPolicy; + if(!utp->securityPolicyUri.data) + securityPolicy = getSecurityPolicyByUri(server, &ed->securityPolicyUri); + else + securityPolicy = getSecurityPolicyByUri(server, &utp->securityPolicyUri); + if(!securityPolicy) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR; + goto rejected; + } + + /* Test if the encryption algorithm is correctly specified */ + if(!UA_String_equal(&userToken->encryptionAlgorithm, + &securityPolicy->asymmetricModule.cryptoModule.encryptionAlgorithm.uri)) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADIDENTITYTOKENINVALID; + goto securityRejected; + } + +#ifdef UA_ENABLE_ENCRYPTION + /* Encrypted password? */ + if(!UA_String_equal(&securityPolicy->policyUri, &UA_SECURITY_POLICY_NONE_URI)) { + /* Create a temporary channel context if a different SecurityPolicy is + * used for the password from the SecureChannel */ + void *tempChannelContext = channel->channelContext; + if(securityPolicy != channel->securityPolicy) { + /* We use our own certificate to create a temporary channel + * context. Because the client does not provide one in a #None + * SecureChannel. We should not need a ChannelContext at all for + * asymmetric decryption where the remote certificate is not + * used. */ + UA_UNLOCK(&server->serviceMutex); + response->responseHeader.serviceResult = securityPolicy->channelModule. + newContext(securityPolicy, &securityPolicy->localCertificate, + &tempChannelContext); + UA_LOCK(&server->serviceMutex); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, "ActivateSession: " + "Failed to create a context for the SecurityPolicy %.*s", + (int)securityPolicy->policyUri.length, + securityPolicy->policyUri.data); + goto rejected; + } + } + + /* Decrypt */ + response->responseHeader.serviceResult = + decryptPassword(securityPolicy, tempChannelContext, &session->serverNonce, userToken); + + /* Remove the temporary channel context */ + if(securityPolicy != channel->securityPolicy) { + UA_UNLOCK(&server->serviceMutex); + securityPolicy->channelModule.deleteContext(tempChannelContext); + UA_LOCK(&server->serviceMutex); + } + } else if(userToken->encryptionAlgorithm.length != 0) { + /* If SecurityPolicy is None there shall be no EncryptionAlgorithm */ + response->responseHeader.serviceResult = UA_STATUSCODE_BADIDENTITYTOKENINVALID; + return; + } + + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, "ActivateSession: " + "Failed to decrypt the password with the StatusCode %s", + UA_StatusCode_name(response->responseHeader.serviceResult)); + goto securityRejected; + } +#endif + } + +#ifdef UA_ENABLE_ENCRYPTION + /* If it is a X509IdentityToken, check the userTokenSignature. Note this + * only validates that the user has the corresponding private key for the + * given user cetificate. Checking whether the user certificate is trusted + * has to be implemented in the access control plugin. The entire token is + * forwarded in the call to ActivateSession. */ + if(utp->tokenType == UA_USERTOKENTYPE_CERTIFICATE) { + UA_X509IdentityToken* userCertToken = (UA_X509IdentityToken*) + request->userIdentityToken.content.decoded.data; + + /* If the userTokenPolicy doesn't specify a security policy the security + * policy of the secure channel is used. */ + UA_SecurityPolicy* securityPolicy; + if(!utp->securityPolicyUri.data) + securityPolicy = getSecurityPolicyByUri(server, &ed->securityPolicyUri); + else + securityPolicy = getSecurityPolicyByUri(server, &utp->securityPolicyUri); + if(!securityPolicy) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR; + goto rejected; + } + + /* We need a channel context with the user certificate in order to reuse + * the signature checking code. */ + void *tempChannelContext; + UA_UNLOCK(&server->serviceMutex); + response->responseHeader.serviceResult = securityPolicy->channelModule. + newContext(securityPolicy, &userCertToken->certificateData, &tempChannelContext); + UA_LOCK(&server->serviceMutex); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, "ActivateSession: " + "Failed to create a context for the SecurityPolicy %.*s", + (int)securityPolicy->policyUri.length, + securityPolicy->policyUri.data); + goto rejected; + } + + /* Check the user token signature */ + response->responseHeader.serviceResult = + checkSignature(server, channel->securityPolicy, tempChannelContext, + &session->serverNonce, &request->userTokenSignature); + + /* Delete the temporary channel context */ + UA_UNLOCK(&server->serviceMutex); + securityPolicy->channelModule.deleteContext(tempChannelContext); + UA_LOCK(&server->serviceMutex); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "ActivateSession: User token signature check failed with StatusCode %s", + UA_StatusCode_name(response->responseHeader.serviceResult)); + goto securityRejected; + } + } +#endif + + /* Callback into userland access control */ + UA_UNLOCK(&server->serviceMutex); + response->responseHeader.serviceResult = server->config.accessControl. + activateSession(server, &server->config.accessControl, ed, &channel->remoteCertificate, + &session->sessionId, &request->userIdentityToken, &session->sessionHandle); + UA_LOCK(&server->serviceMutex); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, "ActivateSession: The AccessControl " + "plugin denied the activation with the StatusCode %s", + UA_StatusCode_name(response->responseHeader.serviceResult)); + goto rejected; + } + + /* Attach the session to the currently used channel if the session isn't + * attached to a channel or if the session is activated on a different + * channel than it is attached to. */ + if(!session->header.channel || session->header.channel != channel) { + /* Attach the new SecureChannel, the old channel will be detached if present */ + UA_Session_attachToSecureChannel(session, channel); + UA_LOG_INFO_SESSION(&server->config.logger, session, + "ActivateSession: Session attached to new channel"); + } + + /* Generate a new session nonce for the next time ActivateSession is called */ + response->responseHeader.serviceResult = UA_Session_generateNonce(session); + response->responseHeader.serviceResult |= + UA_ByteString_copy(&session->serverNonce, &response->serverNonce); + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_Session_detachFromSecureChannel(session); + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "ActivateSession: Could not generate the server nonce"); + goto rejected; + } + + UA_Session_updateLifetime(session); + + /* Activate the session */ + if(!session->activated) { + session->activated = true; + UA_atomic_addSize(&server->serverStats.ss.currentSessionCount, 1); + UA_atomic_addSize(&server->serverStats.ss.cumulatedSessionCount, 1); + } + + UA_LOG_INFO_SESSION(&server->config.logger, session, "ActivateSession: Session activated"); + return; + +securityRejected: + UA_atomic_addSize(&server->serverStats.ss.securityRejectedSessionCount, 1); +rejected: + UA_atomic_addSize(&server->serverStats.ss.rejectedSessionCount, 1); +} + +void +Service_CloseSession(UA_Server *server, UA_SecureChannel *channel, + const UA_CloseSessionRequest *request, + UA_CloseSessionResponse *response) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Part 4, 5.6.4: When the CloseSession Service is called before the Session + * is successfully activated, the Server shall reject the request if the + * SecureChannel is not the same as the one associated with the + * CreateSession request. + * + * A non-activated Session is already bound to the SecureChannel that + * created the Session. */ + UA_Session *session = NULL; + response->responseHeader.serviceResult = + getBoundSession(server, channel, &request->requestHeader.authenticationToken, &session); + if(!session && response->responseHeader.serviceResult == UA_STATUSCODE_GOOD) + response->responseHeader.serviceResult = UA_STATUSCODE_BADSESSIONIDINVALID; + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_CHANNEL(&server->config.logger, channel, + "CloseSession: No Session activated to the SecureChannel"); + return; + } + + UA_assert(session); /* Assured by the previous section */ + UA_LOG_INFO_SESSION(&server->config.logger, session, "Closing the Session"); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* If Subscriptions are not deleted, detach them from the Session */ + if(!request->deleteSubscriptions) { + UA_Subscription *sub, *sub_tmp; + TAILQ_FOREACH_SAFE(sub, &session->subscriptions, sessionListEntry, sub_tmp) { + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, sub, + "Detaching the Subscription from the Session"); + UA_Session_detachSubscription(server, session, sub); + } + } +#endif + + /* Remove the sesison */ + response->responseHeader.serviceResult = + UA_Server_removeSessionByToken(server, &session->header.authenticationToken, + UA_DIAGNOSTICEVENT_CLOSE); +} + +/**** amalgamated original file "/src/server/ua_services_attribute.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2014-2017 (c) Florian Palm + * Copyright 2015 (c) Christian Fimmers + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2015 (c) wuyangtang + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2016 (c) Lorenz Haas + * Copyright 2017 (c) frax2222 + * Copyright 2017 (c) Thomas Bender + * Copyright 2017 (c) Julian Grothoff + * Copyright 2017-2020 (c) HMS Industrial Networks AB (Author: Jonas Green) + * Copyright 2017 (c) Henrik Norrman + * Copyright 2020 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + */ + + +#ifdef UA_ENABLE_HISTORIZING +#endif + +/******************/ +/* Access Control */ +/******************/ + +/* Session for read operations can be NULL. For example for a MonitoredItem + * where the underlying Subscription was detached during CloseSession. */ + +static UA_UInt32 +getUserWriteMask(UA_Server *server, const UA_Session *session, + const UA_NodeHead *head) { + if(session == &server->adminSession) + return 0xFFFFFFFF; /* the local admin user has all rights */ + UA_UInt32 mask = head->writeMask; + UA_UNLOCK(&server->serviceMutex); + mask &= server->config.accessControl. + getUserRightsMask(server, &server->config.accessControl, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &head->nodeId, head->context); + UA_LOCK(&server->serviceMutex); + return mask; +} + +static UA_Byte +getAccessLevel(UA_Server *server, const UA_Session *session, + const UA_VariableNode *node) { + if(session == &server->adminSession) + return 0xFF; /* the local admin user has all rights */ + return node->accessLevel; +} + +static UA_Byte +getUserAccessLevel(UA_Server *server, const UA_Session *session, + const UA_VariableNode *node) { + if(session == &server->adminSession) + return 0xFF; /* the local admin user has all rights */ + UA_Byte retval = node->accessLevel; + UA_UNLOCK(&server->serviceMutex); + retval &= server->config.accessControl. + getUserAccessLevel(server, &server->config.accessControl, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &node->head.nodeId, node->head.context); + UA_LOCK(&server->serviceMutex); + return retval; +} + +static UA_Boolean +getUserExecutable(UA_Server *server, const UA_Session *session, + const UA_MethodNode *node) { + if(session == &server->adminSession) + return true; /* the local admin user has all rights */ + UA_UNLOCK(&server->serviceMutex); + UA_Boolean userExecutable = node->executable; + userExecutable &= + server->config.accessControl. + getUserExecutable(server, &server->config.accessControl, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &node->head.nodeId, node->head.context); + UA_LOCK(&server->serviceMutex); + return userExecutable; +} + +/****************/ +/* Read Service */ +/****************/ + +static UA_StatusCode +readIsAbstractAttribute(const UA_Node *node, UA_Variant *v) { + const UA_Boolean *isAbstract; + switch(node->head.nodeClass) { + case UA_NODECLASS_REFERENCETYPE: + isAbstract = &node->referenceTypeNode.isAbstract; + break; + case UA_NODECLASS_OBJECTTYPE: + isAbstract = &node->objectTypeNode.isAbstract; + break; + case UA_NODECLASS_VARIABLETYPE: + isAbstract = &node->variableTypeNode.isAbstract; + break; + case UA_NODECLASS_DATATYPE: + isAbstract = &node->dataTypeNode.isAbstract; + break; + default: + return UA_STATUSCODE_BADATTRIBUTEIDINVALID; + } + + return UA_Variant_setScalarCopy(v, isAbstract, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_StatusCode +readValueAttributeFromNode(UA_Server *server, UA_Session *session, + const UA_VariableNode *vn, UA_DataValue *v, + UA_NumericRange *rangeptr) { + /* Update the value by the user callback */ + if(vn->value.data.callback.onRead) { + UA_UNLOCK(&server->serviceMutex); + vn->value.data.callback.onRead(server, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &vn->head.nodeId, vn->head.context, rangeptr, + &vn->value.data.value); + UA_LOCK(&server->serviceMutex); + vn = (const UA_VariableNode*)UA_NODESTORE_GET(server, &vn->head.nodeId); + if(!vn) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + } + + /* Set the result */ + if(rangeptr) + return UA_Variant_copyRange(&vn->value.data.value.value, &v->value, *rangeptr); + UA_StatusCode retval = UA_DataValue_copy(&vn->value.data.value, v); + + /* Clean up */ + if(vn->value.data.callback.onRead) + UA_NODESTORE_RELEASE(server, (const UA_Node *)vn); + return retval; +} + +static UA_StatusCode +readValueAttributeFromDataSource(UA_Server *server, UA_Session *session, + const UA_VariableNode *vn, UA_DataValue *v, + UA_TimestampsToReturn timestamps, + UA_NumericRange *rangeptr) { + if(!vn->value.dataSource.ua_read) + return UA_STATUSCODE_BADINTERNALERROR; + UA_Boolean sourceTimeStamp = (timestamps == UA_TIMESTAMPSTORETURN_SOURCE || + timestamps == UA_TIMESTAMPSTORETURN_BOTH); + UA_DataValue v2; + UA_DataValue_init(&v2); + UA_UNLOCK(&server->serviceMutex); + UA_StatusCode retval = vn->value.dataSource. + ua_read(server, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &vn->head.nodeId, vn->head.context, + sourceTimeStamp, rangeptr, &v2); + UA_LOCK(&server->serviceMutex); + if(v2.hasValue && v2.value.storageType == UA_VARIANT_DATA_NODELETE) { + retval = UA_DataValue_copy(&v2, v); + UA_DataValue_clear(&v2); + } else { + *v = v2; + } + return retval; +} + +static UA_StatusCode +readValueAttributeComplete(UA_Server *server, UA_Session *session, + const UA_VariableNode *vn, UA_TimestampsToReturn timestamps, + const UA_String *indexRange, UA_DataValue *v) { + /* Compute the index range */ + UA_NumericRange range; + UA_NumericRange *rangeptr = NULL; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(indexRange && indexRange->length > 0) { + retval = UA_NumericRange_parse(&range, *indexRange); + if(retval != UA_STATUSCODE_GOOD) + return retval; + rangeptr = ⦥ + } + + switch(vn->valueBackend.backendType) { + case UA_VALUEBACKENDTYPE_INTERNAL: + retval = readValueAttributeFromNode(server, session, vn, v, rangeptr); + //TODO change old structure to value backend + break; + case UA_VALUEBACKENDTYPE_DATA_SOURCE_CALLBACK: + retval = readValueAttributeFromDataSource(server, session, vn, v, + timestamps, rangeptr); + //TODO change old structure to value backend + break; + case UA_VALUEBACKENDTYPE_EXTERNAL: + if(vn->valueBackend.backend.external.callback.notificationRead){ + retval = vn->valueBackend.backend.external.callback. + notificationRead(server, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &vn->head.nodeId, vn->head.context, rangeptr); + } else { + retval = UA_STATUSCODE_BADNOTREADABLE; + } + if(retval != UA_STATUSCODE_GOOD){ + retval = UA_STATUSCODE_BADNOTREADABLE; + break; + } + /* Set the result */ + if(rangeptr) + return UA_Variant_copyRange( + (const UA_Variant *)&vn->valueBackend.backend.external.value, + &v->value, *rangeptr); + UA_DataValue_copy(*vn->valueBackend.backend.external.value, v); + break; + case UA_VALUEBACKENDTYPE_NONE: + /* Read the value */ + if(vn->valueSource == UA_VALUESOURCE_DATA) + retval = readValueAttributeFromNode(server, session, vn, v, rangeptr); + else + retval = readValueAttributeFromDataSource(server, session, vn, v, + timestamps, rangeptr); + /* end lagacy */ + break; + } + + /* Static Variables and VariableTypes have timestamps of "now". Will be set + * below in the absence of predefined timestamps. */ + if(vn->head.nodeClass == UA_NODECLASS_VARIABLE) { + if(!vn->isDynamic) { + v->hasServerTimestamp = false; + v->hasSourceTimestamp = false; + } + } else { + v->hasServerTimestamp = false; + v->hasSourceTimestamp = false; + } + + /* Clean up */ + if(rangeptr) + UA_free(range.dimensions); + return retval; +} + +UA_StatusCode +readValueAttribute(UA_Server *server, UA_Session *session, + const UA_VariableNode *vn, UA_DataValue *v) { + return readValueAttributeComplete(server, session, vn, + UA_TIMESTAMPSTORETURN_NEITHER, NULL, v); +} + +static const UA_String binEncoding = {sizeof("Default Binary")-1, (UA_Byte*)"Default Binary"}; +static const UA_String xmlEncoding = {sizeof("Default XML")-1, (UA_Byte*)"Default XML"}; +static const UA_String jsonEncoding = {sizeof("Default JSON")-1, (UA_Byte*)"Default JSON"}; + +#define CHECK_NODECLASS(CLASS) \ + if(!(node->head.nodeClass & (CLASS))) { \ + retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; \ + break; \ + } + +#ifdef UA_ENABLE_TYPEDESCRIPTION +static const UA_DataType * +findDataType(const UA_Node *node, const UA_DataTypeArray *customTypes) { + for(size_t i = 0; i < UA_TYPES_COUNT; ++i) { + if(UA_NodeId_equal(&UA_TYPES[i].typeId, &node->head.nodeId)) { + return &UA_TYPES[i]; + } + } + + // lookup custom type + while(customTypes) { + for(size_t i = 0; i < customTypes->typesSize; ++i) { + if(UA_NodeId_equal(&customTypes->types[i].typeId, &node->head.nodeId)) + return &customTypes->types[i]; + } + customTypes = customTypes->next; + } + return NULL; +} + +static UA_StatusCode +getStructureDefinition(const UA_DataType *type, UA_StructureDefinition *def) { + UA_StatusCode retval = + UA_NodeId_copy(&type->binaryEncodingId, &def->defaultEncodingId); + if(retval != UA_STATUSCODE_GOOD) + return retval; + switch(type->typeKind) { + case UA_DATATYPEKIND_STRUCTURE: + def->structureType = UA_STRUCTURETYPE_STRUCTURE; + def->baseDataType = UA_NODEID_NUMERIC(0, UA_NS0ID_STRUCTURE); + break; + case UA_DATATYPEKIND_OPTSTRUCT: + def->structureType = UA_STRUCTURETYPE_STRUCTUREWITHOPTIONALFIELDS; + def->baseDataType = UA_NODEID_NUMERIC(0, UA_NS0ID_STRUCTURE); + break; + case UA_DATATYPEKIND_UNION: + def->structureType = UA_STRUCTURETYPE_UNION; + def->baseDataType = UA_NODEID_NUMERIC(0, UA_NS0ID_UNION); + break; + default: + return UA_STATUSCODE_BADENCODINGERROR; + } + def->fieldsSize = type->membersSize; + def->fields = (UA_StructureField *) + UA_calloc(def->fieldsSize, sizeof(UA_StructureField)); + if(!def->fields) { + UA_NodeId_clear(&def->defaultEncodingId); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + for(size_t cnt = 0; cnt < def->fieldsSize; cnt++) { + const UA_DataTypeMember *m = &type->members[cnt]; + def->fields[cnt].valueRank = UA_TRUE == m->isArray ? 1 : -1; + def->fields[cnt].arrayDimensions = NULL; + def->fields[cnt].arrayDimensionsSize = 0; + def->fields[cnt].name = UA_STRING((char *)(uintptr_t)m->memberName); + def->fields[cnt].description.locale = UA_STRING_NULL; + def->fields[cnt].description.text = UA_STRING_NULL; + def->fields[cnt].dataType = m->memberType->typeId; + def->fields[cnt].maxStringLength = 0; + def->fields[cnt].isOptional = m->isOptional; + } + return UA_STATUSCODE_GOOD; +} +#endif + +/* Returns a datavalue that may point into the node via the + * UA_VARIANT_DATA_NODELETE tag. Don't access the returned DataValue once the + * node has been released! */ +void +ReadWithNode(const UA_Node *node, UA_Server *server, UA_Session *session, + UA_TimestampsToReturn timestampsToReturn, + const UA_ReadValueId *id, UA_DataValue *v) { + UA_LOG_NODEID_DEBUG(&node->head.nodeId, + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Read attribute %"PRIi32 " of Node %.*s", + id->attributeId, (int)nodeIdStr.length, + nodeIdStr.data)); + + /* Only Binary Encoding is supported */ + if(id->dataEncoding.name.length > 0 && + !UA_String_equal(&binEncoding, &id->dataEncoding.name)) { + if(UA_String_equal(&xmlEncoding, &id->dataEncoding.name) || + UA_String_equal(&jsonEncoding, &id->dataEncoding.name)) + v->status = UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED; + else + v->status = UA_STATUSCODE_BADDATAENCODINGINVALID; + v->hasStatus = true; + return; + } + + /* Index range for an attribute other than value */ + if(id->indexRange.length > 0 && id->attributeId != UA_ATTRIBUTEID_VALUE) { + v->hasStatus = true; + v->status = UA_STATUSCODE_BADINDEXRANGENODATA; + return; + } + + /* Read the attribute */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + switch(id->attributeId) { + case UA_ATTRIBUTEID_NODEID: + retval = UA_Variant_setScalarCopy(&v->value, &node->head.nodeId, + &UA_TYPES[UA_TYPES_NODEID]); + break; + case UA_ATTRIBUTEID_NODECLASS: + retval = UA_Variant_setScalarCopy(&v->value, &node->head.nodeClass, + &UA_TYPES[UA_TYPES_NODECLASS]); + break; + case UA_ATTRIBUTEID_BROWSENAME: + retval = UA_Variant_setScalarCopy(&v->value, &node->head.browseName, + &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); + break; + case UA_ATTRIBUTEID_DISPLAYNAME: + retval = UA_Variant_setScalarCopy(&v->value, &node->head.displayName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); + break; + case UA_ATTRIBUTEID_DESCRIPTION: + retval = UA_Variant_setScalarCopy(&v->value, &node->head.description, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); + break; + case UA_ATTRIBUTEID_WRITEMASK: + retval = UA_Variant_setScalarCopy(&v->value, &node->head.writeMask, + &UA_TYPES[UA_TYPES_UINT32]); + break; + case UA_ATTRIBUTEID_USERWRITEMASK: { + UA_UInt32 userWriteMask = getUserWriteMask(server, session, &node->head); + retval = UA_Variant_setScalarCopy(&v->value, &userWriteMask, + &UA_TYPES[UA_TYPES_UINT32]); + break; } + case UA_ATTRIBUTEID_ISABSTRACT: + retval = readIsAbstractAttribute(node, &v->value); + break; + case UA_ATTRIBUTEID_SYMMETRIC: + CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE); + retval = UA_Variant_setScalarCopy(&v->value, &node->referenceTypeNode.symmetric, + &UA_TYPES[UA_TYPES_BOOLEAN]); + break; + case UA_ATTRIBUTEID_INVERSENAME: + CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE); + retval = UA_Variant_setScalarCopy(&v->value, &node->referenceTypeNode.inverseName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); + break; + case UA_ATTRIBUTEID_CONTAINSNOLOOPS: + CHECK_NODECLASS(UA_NODECLASS_VIEW); + retval = UA_Variant_setScalarCopy(&v->value, &node->viewNode.containsNoLoops, + &UA_TYPES[UA_TYPES_BOOLEAN]); + break; + case UA_ATTRIBUTEID_EVENTNOTIFIER: + CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT); + if(node->head.nodeClass == UA_NODECLASS_VIEW) { + retval = UA_Variant_setScalarCopy(&v->value, &node->viewNode.eventNotifier, + &UA_TYPES[UA_TYPES_BYTE]); + } else { + retval = UA_Variant_setScalarCopy(&v->value, &node->objectNode.eventNotifier, + &UA_TYPES[UA_TYPES_BYTE]); + } + break; + case UA_ATTRIBUTEID_VALUE: { + CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + /* VariableTypes don't have the AccessLevel concept. Always allow + * reading the value. */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLE) { + /* The access to a value variable is granted via the AccessLevel + * and UserAccessLevel attributes */ + UA_Byte accessLevel = getAccessLevel(server, session, &node->variableNode); + if(!(accessLevel & (UA_ACCESSLEVELMASK_READ))) { + retval = UA_STATUSCODE_BADNOTREADABLE; + break; + } + accessLevel = getUserAccessLevel(server, session, &node->variableNode); + if(!(accessLevel & (UA_ACCESSLEVELMASK_READ))) { + retval = UA_STATUSCODE_BADUSERACCESSDENIED; + break; + } + } + retval = readValueAttributeComplete(server, session, &node->variableNode, + timestampsToReturn, &id->indexRange, v); + break; + } + case UA_ATTRIBUTEID_DATATYPE: + CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + retval = UA_Variant_setScalarCopy(&v->value, &node->variableTypeNode.dataType, + &UA_TYPES[UA_TYPES_NODEID]); + break; + case UA_ATTRIBUTEID_VALUERANK: + CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + retval = UA_Variant_setScalarCopy(&v->value, &node->variableTypeNode.valueRank, + &UA_TYPES[UA_TYPES_INT32]); + break; + case UA_ATTRIBUTEID_ARRAYDIMENSIONS: + CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + retval = UA_Variant_setArrayCopy(&v->value, node->variableTypeNode.arrayDimensions, + node->variableTypeNode.arrayDimensionsSize, + &UA_TYPES[UA_TYPES_UINT32]); + break; + case UA_ATTRIBUTEID_ACCESSLEVEL: + CHECK_NODECLASS(UA_NODECLASS_VARIABLE); + retval = UA_Variant_setScalarCopy(&v->value, &node->variableNode.accessLevel, + &UA_TYPES[UA_TYPES_BYTE]); + break; + case UA_ATTRIBUTEID_USERACCESSLEVEL: { + CHECK_NODECLASS(UA_NODECLASS_VARIABLE); + UA_Byte userAccessLevel = getUserAccessLevel(server, session, &node->variableNode); + retval = UA_Variant_setScalarCopy(&v->value, &userAccessLevel, + &UA_TYPES[UA_TYPES_BYTE]); + break; } + case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL: + CHECK_NODECLASS(UA_NODECLASS_VARIABLE); + retval = UA_Variant_setScalarCopy(&v->value, + &node->variableNode.minimumSamplingInterval, + &UA_TYPES[UA_TYPES_DOUBLE]); + break; + case UA_ATTRIBUTEID_HISTORIZING: + CHECK_NODECLASS(UA_NODECLASS_VARIABLE); + retval = UA_Variant_setScalarCopy(&v->value, &node->variableNode.historizing, + &UA_TYPES[UA_TYPES_BOOLEAN]); + break; + case UA_ATTRIBUTEID_EXECUTABLE: + CHECK_NODECLASS(UA_NODECLASS_METHOD); + retval = UA_Variant_setScalarCopy(&v->value, &node->methodNode.executable, + &UA_TYPES[UA_TYPES_BOOLEAN]); + break; + case UA_ATTRIBUTEID_USEREXECUTABLE: { + CHECK_NODECLASS(UA_NODECLASS_METHOD); + UA_Boolean userExecutable = + getUserExecutable(server, session, &node->methodNode); + retval = UA_Variant_setScalarCopy(&v->value, &userExecutable, + &UA_TYPES[UA_TYPES_BOOLEAN]); + break; } + case UA_ATTRIBUTEID_DATATYPEDEFINITION: { + CHECK_NODECLASS(UA_NODECLASS_DATATYPE); + +#ifdef UA_ENABLE_TYPEDESCRIPTION + const UA_DataType *type = + findDataType(node, server->config.customDataTypes); + if(!type) { + retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; + break; + } + + if(UA_DATATYPEKIND_STRUCTURE == type->typeKind || + UA_DATATYPEKIND_OPTSTRUCT == type->typeKind || + UA_DATATYPEKIND_UNION == type->typeKind) { + UA_StructureDefinition def; + retval = getStructureDefinition(type, &def); + if(UA_STATUSCODE_GOOD!=retval) + break; + retval = UA_Variant_setScalarCopy(&v->value, &def, + &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]); + UA_free(def.fields); + break; + } +#endif + retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; + break; } + default: + retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; + } + + if(retval != UA_STATUSCODE_GOOD) { + /* Reading has failed but can not return because we may need to add timestamp */ + v->hasStatus = true; + v->status = retval; + } else { + v->hasValue = true; + } + + /* Create server timestamp */ + if(timestampsToReturn == UA_TIMESTAMPSTORETURN_SERVER || + timestampsToReturn == UA_TIMESTAMPSTORETURN_BOTH) { + if(!v->hasServerTimestamp) { + v->serverTimestamp = UA_DateTime_now(); + v->hasServerTimestamp = true; + } + } else { + /* In case the ServerTimestamp has been set manually */ + v->hasServerTimestamp = false; + } + + /* Handle source time stamp */ + if(id->attributeId == UA_ATTRIBUTEID_VALUE) { + if(timestampsToReturn == UA_TIMESTAMPSTORETURN_SERVER || + timestampsToReturn == UA_TIMESTAMPSTORETURN_NEITHER) { + v->hasSourceTimestamp = false; + v->hasSourcePicoseconds = false; + } else if(!v->hasSourceTimestamp) { + v->sourceTimestamp = UA_DateTime_now(); + v->hasSourceTimestamp = true; + } + } +} + +static void +Operation_Read(UA_Server *server, UA_Session *session, UA_ReadRequest *request, + UA_ReadValueId *rvi, UA_DataValue *result) { + /* Get the node */ + const UA_Node *node = UA_NODESTORE_GET(server, &rvi->nodeId); + + /* Perform the read operation */ + if(node) { + ReadWithNode(node, server, session, request->timestampsToReturn, rvi, result); + UA_NODESTORE_RELEASE(server, node); + } else { + result->hasStatus = true; + result->status = UA_STATUSCODE_BADNODEIDUNKNOWN; + } +} + +void +Service_Read(UA_Server *server, UA_Session *session, + const UA_ReadRequest *request, UA_ReadResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing ReadRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Check if the timestampstoreturn is valid */ + if(request->timestampsToReturn > UA_TIMESTAMPSTORETURN_NEITHER) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID; + return; + } + + /* Check if maxAge is valid */ + if(request->maxAge < 0) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADMAXAGEINVALID; + return; + } + + /* Check if there are too many operations */ + if(server->config.maxNodesPerRead != 0 && + request->nodesToReadSize > server->config.maxNodesPerRead) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_Read, + request, &request->nodesToReadSize, + &UA_TYPES[UA_TYPES_READVALUEID], + &response->resultsSize, + &UA_TYPES[UA_TYPES_DATAVALUE]); +} + +UA_DataValue +UA_Server_readWithSession(UA_Server *server, UA_Session *session, + const UA_ReadValueId *item, + UA_TimestampsToReturn timestampsToReturn) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_DataValue dv; + UA_DataValue_init(&dv); + + /* Get the node */ + const UA_Node *node = UA_NODESTORE_GET(server, &item->nodeId); + if(!node) { + dv.hasStatus = true; + dv.status = UA_STATUSCODE_BADNODEIDUNKNOWN; + return dv; + } + + /* Perform the read operation */ + ReadWithNode(node, server, session, timestampsToReturn, item, &dv); + + /* Release the node and return */ + UA_NODESTORE_RELEASE(server, node); + return dv; +} + +UA_DataValue +readAttribute(UA_Server *server, const UA_ReadValueId *item, + UA_TimestampsToReturn timestamps) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + return UA_Server_readWithSession(server, &server->adminSession, item, timestamps); +} + +UA_StatusCode +readWithReadValue(UA_Server *server, const UA_NodeId *nodeId, + const UA_AttributeId attributeId, void *v) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Call the read service */ + UA_ReadValueId item; + UA_ReadValueId_init(&item); + item.nodeId = *nodeId; + item.attributeId = attributeId; + UA_DataValue dv = readAttribute(server, &item, UA_TIMESTAMPSTORETURN_NEITHER); + + /* Check the return value */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(dv.hasStatus) + retval = dv.status; + else if(!dv.hasValue) + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + if(retval != UA_STATUSCODE_GOOD) { + UA_DataValue_clear(&dv); + return retval; + } + + if(attributeId == UA_ATTRIBUTEID_VALUE || + attributeId == UA_ATTRIBUTEID_ARRAYDIMENSIONS) { + /* Return the entire variant */ + memcpy(v, &dv.value, sizeof(UA_Variant)); + } else { + /* Return the variant content only */ + memcpy(v, dv.value.data, dv.value.type->memSize); + UA_free(dv.value.data); + } + return retval; +} + +/* Exposes the Read service to local users */ +UA_DataValue +UA_Server_read(UA_Server *server, const UA_ReadValueId *item, + UA_TimestampsToReturn timestamps) { + UA_LOCK(&server->serviceMutex); + UA_DataValue dv = readAttribute(server, item, timestamps); + UA_UNLOCK(&server->serviceMutex); + return dv; +} + +/* Used in inline functions exposing the Read service with more syntactic sugar + * for individual attributes */ +UA_StatusCode +__UA_Server_read(UA_Server *server, const UA_NodeId *nodeId, + const UA_AttributeId attributeId, void *v) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = readWithReadValue(server, nodeId, attributeId, v); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +readObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + UA_Variant *value) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Create a BrowsePath to get the target NodeId */ + UA_RelativePathElement rpe; + UA_RelativePathElement_init(&rpe); + rpe.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY); + rpe.isInverse = false; + rpe.includeSubtypes = false; + rpe.targetName = propertyName; + + UA_BrowsePath bp; + UA_BrowsePath_init(&bp); + bp.startingNode = objectId; + bp.relativePath.elementsSize = 1; + bp.relativePath.elements = &rpe; + + UA_StatusCode retval; + UA_BrowsePathResult bpr = translateBrowsePathToNodeIds(server, &bp); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + retval = bpr.statusCode; + UA_BrowsePathResult_clear(&bpr); + return retval; + } + + /* Use the first result from the BrowsePath */ + retval = readWithReadValue(server, &bpr.targets[0].targetId.nodeId, + UA_ATTRIBUTEID_VALUE, value); + + UA_BrowsePathResult_clear(&bpr); + return retval; +} + + +UA_StatusCode +UA_Server_readObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + UA_Variant *value) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = readObjectProperty(server, objectId, propertyName, value); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/*****************/ +/* Type Checking */ +/*****************/ + +static UA_DataTypeKind +typeEquivalence(const UA_DataType *t) { + UA_DataTypeKind k = (UA_DataTypeKind)t->typeKind; + if(k == UA_DATATYPEKIND_ENUM) + return UA_DATATYPEKIND_INT32; + return k; +} + +static const UA_NodeId enumNodeId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_ENUMERATION}}; + +UA_Boolean +compatibleValueDataType(UA_Server *server, const UA_DataType *dataType, + const UA_NodeId *constraintDataType) { + if(compatibleDataTypes(server, &dataType->typeId, constraintDataType)) + return true; + + /* For actual values, the constraint DataType may be a subtype of the + * DataType of the value. E.g. UtcTime is subtype of DateTime. But it still + * is a DateTime value when transferred over the wire. */ + if(isNodeInTree_singleRef(server, constraintDataType, &dataType->typeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) + return true; + + return false; +} + +UA_Boolean +compatibleDataTypes(UA_Server *server, const UA_NodeId *dataType, + const UA_NodeId *constraintDataType) { + /* Do not allow empty datatypes */ + if(UA_NodeId_isNull(dataType)) + return false; + + /* No constraint or Variant / BaseDataType which allows any content */ + if(UA_NodeId_isNull(constraintDataType) || + UA_NodeId_equal(constraintDataType, &UA_TYPES[UA_TYPES_VARIANT].typeId)) + return true; + + /* Same datatypes */ + if(UA_NodeId_equal(dataType, constraintDataType)) + return true; + + /* Is the DataType a subtype of the constraint type? */ + if(isNodeInTree_singleRef(server, dataType, constraintDataType, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) + return true; + + /* The constraint is an enum -> allow writing Int32 */ + if(UA_NodeId_equal(dataType, &UA_TYPES[UA_TYPES_INT32].typeId) && + isNodeInTree_singleRef(server, constraintDataType, &enumNodeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) + return true; + + return false; +} + +/* Test whether a ValueRank and the given arraydimensions are compatible. + * + * 5.6.2 Variable NodeClass: If the maximum is unknown the value shall be 0. The + * number of elements shall be equal to the value of the ValueRank Attribute. + * This Attribute shall be null if ValueRank <= 0. */ +UA_Boolean +compatibleValueRankArrayDimensions(UA_Server *server, UA_Session *session, + UA_Int32 valueRank, size_t arrayDimensionsSize) { + /* ValueRank invalid */ + if(valueRank < UA_VALUERANK_SCALAR_OR_ONE_DIMENSION) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "The ValueRank is invalid (< -3)"); + return false; + } + + /* case -3, UA_VALUERANK_SCALAR_OR_ONE_DIMENSION: the value can be a scalar + * or a one dimensional array + * case -2, UA_VALUERANK_ANY: the value can be a scalar or an array with any + * number of dimensions + * case -1, UA_VALUERANK_SCALAR: the value is a scalar + * case 0, UA_VALUERANK_ONE_OR_MORE_DIMENSIONS: the value is an array with + * one or more dimensions */ + if(valueRank <= UA_VALUERANK_ONE_OR_MORE_DIMENSIONS) { + if(arrayDimensionsSize > 0) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "No ArrayDimensions can be defined for a ValueRank <= 0"); + return false; + } + return true; + } + + /* case >= 1, UA_VALUERANK_ONE_DIMENSION: the value is an array with the + specified number of dimensions */ + if(arrayDimensionsSize != (size_t)valueRank) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "The number of ArrayDimensions is not equal to " + "the (positive) ValueRank"); + return false; + } + return true; +} + +UA_Boolean +compatibleValueRanks(UA_Int32 valueRank, UA_Int32 constraintValueRank) { + /* Check if the valuerank of the variabletype allows the change. */ + switch(constraintValueRank) { + case UA_VALUERANK_SCALAR_OR_ONE_DIMENSION: /* the value can be a scalar or a + one dimensional array */ + if(valueRank != UA_VALUERANK_SCALAR && valueRank != UA_VALUERANK_ONE_DIMENSION) + return false; + break; + case UA_VALUERANK_ANY: /* the value can be a scalar or an array with any + number of dimensions */ + break; + case UA_VALUERANK_SCALAR: /* the value is a scalar */ + if(valueRank != UA_VALUERANK_SCALAR) + return false; + break; + case UA_VALUERANK_ONE_OR_MORE_DIMENSIONS: /* the value is an array with one + or more dimensions */ + if(valueRank < (UA_Int32) UA_VALUERANK_ONE_OR_MORE_DIMENSIONS) + return false; + break; + default: /* >= 1: the value is an array with the specified number of + dimensions */ + if(valueRank != constraintValueRank) + return false; + break; + } + return true; +} + +/* Check if the ValueRank allows for the value dimension. This is more + * permissive than checking for the ArrayDimensions attribute. Because the value + * can have dimensions if the ValueRank < 0 */ +static UA_Boolean +compatibleValueRankValue(UA_Int32 valueRank, const UA_Variant *value) { + /* Invalid ValueRank */ + if(valueRank < UA_VALUERANK_SCALAR_OR_ONE_DIMENSION) + return false; + + /* Empty arrays (-1) always match */ + if(!value->data) + return true; + + size_t arrayDims = value->arrayDimensionsSize; + if(arrayDims == 0 && !UA_Variant_isScalar(value)) + arrayDims = 1; /* array but no arraydimensions -> implicit array dimension 1 */ + + /* We cannot simply use compatibleValueRankArrayDimensions since we can have + * defined ArrayDimensions for the value if the ValueRank is -2 */ + switch(valueRank) { + case UA_VALUERANK_SCALAR_OR_ONE_DIMENSION: /* The value can be a scalar or a + one dimensional array */ + return (arrayDims <= 1); + case UA_VALUERANK_ANY: /* The value can be a scalar or an array with any + number of dimensions */ + return true; + case UA_VALUERANK_SCALAR: /* The value is a scalar */ + return (arrayDims == 0); + case UA_VALUERANK_ONE_OR_MORE_DIMENSIONS: + return (arrayDims >= 1); + default: + break; + } + + UA_assert(valueRank >= UA_VALUERANK_ONE_OR_MORE_DIMENSIONS); + + /* case 0: the value is an array with one or more dimensions */ + return (arrayDims == (UA_UInt32)valueRank); +} + +UA_Boolean +compatibleArrayDimensions(size_t constraintArrayDimensionsSize, + const UA_UInt32 *constraintArrayDimensions, + size_t testArrayDimensionsSize, + const UA_UInt32 *testArrayDimensions) { + /* No array dimensions defined -> everything is permitted if the value rank fits */ + if(constraintArrayDimensionsSize == 0) + return true; + + /* Dimension count must match */ + if(testArrayDimensionsSize != constraintArrayDimensionsSize) + return false; + + /* Dimension lengths must not be larger than the constraint. Zero in the + * constraint indicates a wildcard. */ + for(size_t i = 0; i < constraintArrayDimensionsSize; ++i) { + if(constraintArrayDimensions[i] < testArrayDimensions[i] && + constraintArrayDimensions[i] != 0) + return false; + } + return true; +} + +UA_Boolean +compatibleValueArrayDimensions(const UA_Variant *value, size_t targetArrayDimensionsSize, + const UA_UInt32 *targetArrayDimensions) { + size_t valueArrayDimensionsSize = value->arrayDimensionsSize; + UA_UInt32 *valueArrayDimensions = value->arrayDimensions; + UA_UInt32 tempArrayDimensions; + if(!valueArrayDimensions && !UA_Variant_isScalar(value)) { + valueArrayDimensionsSize = 1; + tempArrayDimensions = (UA_UInt32)value->arrayLength; + valueArrayDimensions = &tempArrayDimensions; + } + UA_assert(valueArrayDimensionsSize == 0 || valueArrayDimensions != NULL); + return compatibleArrayDimensions(targetArrayDimensionsSize, targetArrayDimensions, + valueArrayDimensionsSize, valueArrayDimensions); +} + +UA_Boolean +compatibleValue(UA_Server *server, UA_Session *session, const UA_NodeId *targetDataTypeId, + UA_Int32 targetValueRank, size_t targetArrayDimensionsSize, + const UA_UInt32 *targetArrayDimensions, const UA_Variant *value, + const UA_NumericRange *range) { + /* Empty value */ + if(!value->type) { + /* Empty value is allowed for BaseDataType */ + if(UA_NodeId_equal(targetDataTypeId, &UA_TYPES[UA_TYPES_VARIANT].typeId) || + UA_NodeId_equal(targetDataTypeId, &UA_NODEID_NULL)) + return true; + + /* Ignore if that is configured */ + if(server->bootstrapNS0 || + server->config.allowEmptyVariables == UA_RULEHANDLING_ACCEPT) + return true; + + UA_LOG_INFO_SESSION(&server->config.logger, session, + "Only Variables with data type BaseDataType " + "can contain an empty value"); + + /* Ignore if that is configured */ + if(server->config.allowEmptyVariables == UA_RULEHANDLING_WARN) + return true; + + /* Default handling is to abort */ + return false; + } + + /* Is the datatype compatible? */ + if(!compatibleValueDataType(server, value->type, targetDataTypeId)) + return false; + + /* Array dimensions are checked later when writing the range */ + if(range) + return true; + + /* See if the array dimensions match. */ + if(!compatibleValueArrayDimensions(value, targetArrayDimensionsSize, + targetArrayDimensions)) + return false; + + /* Check if the valuerank allows for the value dimension */ + return compatibleValueRankValue(targetValueRank, value); +} + +/*****************/ +/* Write Service */ +/*****************/ + +void +adjustValueType(UA_Server *server, UA_Variant *value, + const UA_NodeId *targetDataTypeId) { + const UA_DataType *targetDataType = UA_findDataType(targetDataTypeId); + if(!targetDataType) + return; + + /* A string is written to a byte array. the valuerank and array dimensions + * are checked later */ + if(targetDataType == &UA_TYPES[UA_TYPES_BYTE] && + value->type == &UA_TYPES[UA_TYPES_BYTESTRING] && + UA_Variant_isScalar(value)) { + UA_ByteString *str = (UA_ByteString*)value->data; + value->type = &UA_TYPES[UA_TYPES_BYTE]; + value->arrayLength = str->length; + value->data = str->data; + return; + } + + /* An enum was sent as an int32, or an opaque type as a bytestring. This + * is detected with the typeKind indicating the "true" datatype. */ + UA_DataTypeKind te1 = typeEquivalence(targetDataType); + UA_DataTypeKind te2 = typeEquivalence(value->type); + if(te1 == te2 && te1 <= UA_DATATYPEKIND_ENUM) { + value->type = targetDataType; + return; + } + + /* No more possible equivalencies */ +} + +static UA_StatusCode +writeArrayDimensionsAttribute(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_VariableTypeNode *type, + size_t arrayDimensionsSize, UA_UInt32 *arrayDimensions) { + UA_assert(node != NULL); + UA_assert(type != NULL); + + /* If this is a variabletype, there must be no instances or subtypes of it + * when we do the change */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLETYPE && + UA_Node_hasSubTypeOrInstances(&node->head)) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Cannot change a variable type with existing instances"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Check that the array dimensions match with the valuerank */ + if(!compatibleValueRankArrayDimensions(server, session, node->valueRank, + arrayDimensionsSize)) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Cannot write the ArrayDimensions. The ValueRank does not match."); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + /* Check if the array dimensions match with the wildcards in the + * variabletype (dimension length 0) */ + if(type->arrayDimensions && + !compatibleArrayDimensions(type->arrayDimensionsSize, type->arrayDimensions, + arrayDimensionsSize, arrayDimensions)) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Array dimensions in the variable type do not match"); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + /* Check if the current value is compatible with the array dimensions */ + UA_DataValue value; + UA_DataValue_init(&value); + UA_StatusCode retval = readValueAttribute(server, session, node, &value); + if(retval != UA_STATUSCODE_GOOD) + return retval; + if(value.hasValue) { + if(!compatibleValueArrayDimensions(&value.value, arrayDimensionsSize, + arrayDimensions)) + retval = UA_STATUSCODE_BADTYPEMISMATCH; + UA_DataValue_clear(&value); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Array dimensions in the current value do not match"); + return retval; + } + } + + /* Ok, apply */ + UA_UInt32 *oldArrayDimensions = node->arrayDimensions; + size_t oldArrayDimensionsSize = node->arrayDimensionsSize; + retval = UA_Array_copy(arrayDimensions, arrayDimensionsSize, + (void**)&node->arrayDimensions, + &UA_TYPES[UA_TYPES_UINT32]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + UA_Array_delete(oldArrayDimensions, oldArrayDimensionsSize, &UA_TYPES[UA_TYPES_UINT32]); + node->arrayDimensionsSize = arrayDimensionsSize; + return UA_STATUSCODE_GOOD; +} + +/* Stack layout: ... | node | type */ +static UA_StatusCode +writeValueRankAttribute(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_VariableTypeNode *type, + UA_Int32 valueRank) { + UA_assert(node != NULL); + UA_assert(type != NULL); + + UA_Int32 constraintValueRank = type->valueRank; + + /* If this is a variabletype, there must be no instances or subtypes of it + * when we do the change */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLETYPE && + UA_Node_hasSubTypeOrInstances(&node->head)) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Check if the valuerank of the variabletype allows the change. */ + if(!compatibleValueRanks(valueRank, constraintValueRank)) + return UA_STATUSCODE_BADTYPEMISMATCH; + + /* Check if the new valuerank is compatible with the array dimensions. Use + * the read service to handle data sources. */ + size_t arrayDims = node->arrayDimensionsSize; + if(arrayDims == 0) { + /* the value could be an array with no arrayDimensions defined. + dimensions zero indicate a scalar for compatibleValueRankArrayDimensions. */ + UA_DataValue value; + UA_DataValue_init(&value); + UA_StatusCode retval = readValueAttribute(server, session, node, &value); + if(retval != UA_STATUSCODE_GOOD) + return retval; + if(!value.hasValue || !value.value.type) { + /* no value -> apply */ + node->valueRank = valueRank; + return UA_STATUSCODE_GOOD; + } + if(!UA_Variant_isScalar(&value.value)) + arrayDims = 1; + UA_DataValue_clear(&value); + } + if(!compatibleValueRankArrayDimensions(server, session, valueRank, arrayDims)) + return UA_STATUSCODE_BADTYPEMISMATCH; + + /* All good, apply the change */ + node->valueRank = valueRank; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +writeDataTypeAttribute(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_VariableTypeNode *type, + const UA_NodeId *dataType) { + UA_assert(node != NULL); + UA_assert(type != NULL); + + /* If this is a variabletype, there must be no instances or subtypes of it + when we do the change */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLETYPE && + UA_Node_hasSubTypeOrInstances(&node->head)) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Does the new type match the constraints of the variabletype? */ + if(!compatibleDataTypes(server, dataType, &type->dataType)) + return UA_STATUSCODE_BADTYPEMISMATCH; + + /* Check if the current value would match the new type */ + UA_DataValue value; + UA_DataValue_init(&value); + UA_StatusCode retval = readValueAttribute(server, session, node, &value); + if(retval != UA_STATUSCODE_GOOD) + return retval; + if(value.hasValue) { + if(!compatibleValue(server, session, dataType, node->valueRank, + node->arrayDimensionsSize, node->arrayDimensions, + &value.value, NULL)) + retval = UA_STATUSCODE_BADTYPEMISMATCH; + UA_DataValue_clear(&value); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "The current value does not match the new data type"); + return retval; + } + } + + /* Replace the datatype nodeid */ + UA_NodeId dtCopy = node->dataType; + retval = UA_NodeId_copy(dataType, &node->dataType); + if(retval != UA_STATUSCODE_GOOD) { + node->dataType = dtCopy; + return retval; + } + UA_NodeId_clear(&dtCopy); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +writeValueAttributeWithoutRange(UA_VariableNode *node, const UA_DataValue *value) { + UA_DataValue new_value; + UA_StatusCode retval = UA_DataValue_copy(value, &new_value); + if(retval != UA_STATUSCODE_GOOD) + return retval; + UA_DataValue_clear(&node->value.data.value); + node->value.data.value = new_value; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +writeValueAttributeWithRange(UA_VariableNode *node, const UA_DataValue *value, + const UA_NumericRange *rangeptr) { + /* Value on both sides? */ + if(value->status != node->value.data.value.status || + !value->hasValue || !node->value.data.value.hasValue) + return UA_STATUSCODE_BADINDEXRANGEINVALID; + + /* Make scalar a one-entry array for range matching */ + UA_Variant editableValue; + const UA_Variant *v = &value->value; + if(UA_Variant_isScalar(&value->value)) { + editableValue = value->value; + editableValue.arrayLength = 1; + v = &editableValue; + } + + /* Check that the type is an exact match and not only "compatible" */ + if(!node->value.data.value.value.type || !v->type || + !UA_NodeId_equal(&node->value.data.value.value.type->typeId, + &v->type->typeId)) + return UA_STATUSCODE_BADTYPEMISMATCH; + + /* Write the value */ + UA_StatusCode retval = + UA_Variant_setRangeCopy(&node->value.data.value.value, + v->data, v->arrayLength, *rangeptr); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Write the status and timestamps */ + node->value.data.value.hasStatus = value->hasStatus; + node->value.data.value.status = value->status; + node->value.data.value.hasSourceTimestamp = value->hasSourceTimestamp; + node->value.data.value.sourceTimestamp = value->sourceTimestamp; + node->value.data.value.hasSourcePicoseconds = value->hasSourcePicoseconds; + node->value.data.value.sourcePicoseconds = value->sourcePicoseconds; + return UA_STATUSCODE_GOOD; +} + +/* Stack layout: ... | node */ +static UA_StatusCode +writeNodeValueAttribute(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_DataValue *value, + const UA_String *indexRange) { + UA_assert(node != NULL); + UA_assert(session != NULL); + + /* Parse the range */ + UA_NumericRange range; + range.dimensions = NULL; + UA_NumericRange *rangeptr = NULL; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(indexRange && indexRange->length > 0) { + retval = UA_NumericRange_parse(&range, *indexRange); + if(retval != UA_STATUSCODE_GOOD) + return retval; + rangeptr = ⦥ + } + + /* Created an editable version. The data is not touched. Only the variant + * "container". */ + UA_DataValue adjustedValue = *value; + + /* Type checking. May change the type of editableValue */ + if(value->hasValue && value->value.type) { + adjustValueType(server, &adjustedValue.value, &node->dataType); + + /* The value may be an extension object, especially the nodeset compiler + * uses extension objects to write variable values. If value is an + * extension object we check if the current node value is also an + * extension object. */ + const UA_NodeId nodeDataType = UA_NODEID_NUMERIC(0, UA_NS0ID_STRUCTURE); + const UA_NodeId *nodeDataTypePtr = &node->dataType; + if(value->value.type->typeId.identifierType == UA_NODEIDTYPE_NUMERIC && + value->value.type->typeId.identifier.numeric == UA_NS0ID_STRUCTURE) + nodeDataTypePtr = &nodeDataType; + + if(!compatibleValue(server, session, nodeDataTypePtr, node->valueRank, + node->arrayDimensionsSize, node->arrayDimensions, + &adjustedValue.value, rangeptr)) { + if(rangeptr && rangeptr->dimensions != NULL) + UA_free(rangeptr->dimensions); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + } + + /* Set the source timestamp if there is none */ + UA_DateTime now = UA_DateTime_now(); + if(!adjustedValue.hasSourceTimestamp) { + adjustedValue.sourceTimestamp = now; + adjustedValue.hasSourceTimestamp = true; + } + + /* Update the timestamp when the value was last updated in the server */ + adjustedValue.serverTimestamp = now; + adjustedValue.hasServerTimestamp = true; + + switch(node->valueBackend.backendType) { + case UA_VALUEBACKENDTYPE_NONE: + /* Ok, do it */ + if(node->valueSource == UA_VALUESOURCE_DATA) { + if(!rangeptr) + retval = writeValueAttributeWithoutRange(node, &adjustedValue); + else + retval = writeValueAttributeWithRange(node, &adjustedValue, rangeptr); + +#ifdef UA_ENABLE_HISTORIZING + /* node is a UA_VariableNode*, but it may also point to a + UA_VariableTypeNode */ + /* UA_VariableTypeNode doesn't have the historizing attribute */ + if(retval == UA_STATUSCODE_GOOD && + node->head.nodeClass == UA_NODECLASS_VARIABLE && + server->config.historyDatabase.setValue) { + UA_UNLOCK(&server->serviceMutex); + server->config.historyDatabase. + setValue(server, server->config.historyDatabase.context, + &session->sessionId, session->sessionHandle, + &node->head.nodeId, node->historizing, &adjustedValue); + UA_LOCK(&server->serviceMutex); + } +#endif + /* Callback after writing */ + if(retval == UA_STATUSCODE_GOOD && node->value.data.callback.onWrite) { + UA_UNLOCK(&server->serviceMutex); + node->value.data.callback. + onWrite(server, &session->sessionId, session->sessionHandle, + &node->head.nodeId, node->head.context, + rangeptr, &adjustedValue); + UA_LOCK(&server->serviceMutex); + + } + } else { + if(node->value.dataSource.ua_write) { + UA_UNLOCK(&server->serviceMutex); + retval = node->value.dataSource. + ua_write(server, &session->sessionId, session->sessionHandle, + &node->head.nodeId, node->head.context, + rangeptr, &adjustedValue); + UA_LOCK(&server->serviceMutex); + } else { + retval = UA_STATUSCODE_BADWRITENOTSUPPORTED; + } + } + break; + case UA_VALUEBACKENDTYPE_INTERNAL: + break; + case UA_VALUEBACKENDTYPE_DATA_SOURCE_CALLBACK: + break; + case UA_VALUEBACKENDTYPE_EXTERNAL: + if(node->valueBackend.backend.external.callback.userWrite == NULL){ + if(rangeptr && rangeptr->dimensions != NULL) + UA_free(rangeptr->dimensions); + return UA_STATUSCODE_BADWRITENOTSUPPORTED; + } + node->valueBackend.backend.external.callback. + userWrite(server, &session->sessionId, session->sessionHandle, + &node->head.nodeId, node->head.context, + rangeptr, &adjustedValue); + break; + } + + /* Clean up */ + if(rangeptr && rangeptr->dimensions != NULL) + UA_free(rangeptr->dimensions); + return retval; +} + +static UA_StatusCode +writeIsAbstractAttribute(UA_Node *node, UA_Boolean value) { + switch(node->head.nodeClass) { + case UA_NODECLASS_OBJECTTYPE: + node->objectTypeNode.isAbstract = value; + break; + case UA_NODECLASS_REFERENCETYPE: + node->referenceTypeNode.isAbstract = value; + break; + case UA_NODECLASS_VARIABLETYPE: + node->variableTypeNode.isAbstract = value; + break; + case UA_NODECLASS_DATATYPE: + node->dataTypeNode.isAbstract = value; + break; + default: + return UA_STATUSCODE_BADNODECLASSINVALID; + } + return UA_STATUSCODE_GOOD; +} + +/*****************/ +/* Write Service */ +/*****************/ + +#define CHECK_DATATYPE_SCALAR(EXP_DT) \ + if(!wvalue->value.hasValue || \ + &UA_TYPES[UA_TYPES_##EXP_DT] != wvalue->value.value.type || \ + !UA_Variant_isScalar(&wvalue->value.value)) { \ + retval = UA_STATUSCODE_BADTYPEMISMATCH; \ + break; \ + } + +#define CHECK_DATATYPE_ARRAY(EXP_DT) \ + if(!wvalue->value.hasValue || \ + &UA_TYPES[UA_TYPES_##EXP_DT] != wvalue->value.value.type || \ + UA_Variant_isScalar(&wvalue->value.value)) { \ + retval = UA_STATUSCODE_BADTYPEMISMATCH; \ + break; \ + } + +#define CHECK_NODECLASS_WRITE(CLASS) \ + if((node->head.nodeClass & (CLASS)) == 0) { \ + retval = UA_STATUSCODE_BADNODECLASSINVALID; \ + break; \ + } + +#define CHECK_USERWRITEMASK(mask) \ + if(!(userWriteMask & (mask))) { \ + retval = UA_STATUSCODE_BADUSERACCESSDENIED; \ + break; \ + } + +#define GET_NODETYPE \ + type = (const UA_VariableTypeNode*) \ + getNodeType(server, &node->head); \ + if(!type) { \ + retval = UA_STATUSCODE_BADTYPEMISMATCH; \ + break; \ + } + +/* Update a localized text. Don't touch the target if copying fails + * (maybe due to BadOutOfMemory). */ +static UA_StatusCode +updateLocalizedText(const UA_LocalizedText *source, UA_LocalizedText *target) { + UA_LocalizedText tmp; + UA_StatusCode retval = UA_LocalizedText_copy(source, &tmp); + if(retval != UA_STATUSCODE_GOOD) + return retval; + UA_LocalizedText_clear(target); + *target = tmp; + return UA_STATUSCODE_GOOD; +} + +/* Trigger sampling if a MonitoredItem surveils the attribute with no sampling + * interval */ +static void +triggerImmediateDataChange(UA_Server *server, UA_Session *session, + UA_Node *node, const UA_WriteValue *wvalue) { + for(UA_MonitoredItem *mon = node->head.monitoredItems; mon != NULL; mon = mon->next) { + if(mon->itemToMonitor.attributeId != wvalue->attributeId) + continue; + UA_DataValue value; + UA_DataValue_init(&value); + ReadWithNode(node, server, session, mon->timestampsToReturn, + &mon->itemToMonitor, &value); + UA_Subscription *sub = mon->subscription; + UA_StatusCode res = sampleCallbackWithValue(server, sub, mon, &value); + if(res != UA_STATUSCODE_GOOD) { + UA_DataValue_clear(&value); + UA_LOG_WARNING_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %" PRIi32 " | " + "Sampling returned the statuscode %s", + mon->monitoredItemId, + UA_StatusCode_name(res)); + } + } +} + +/* This function implements the main part of the write service and operates on a + copy of the node (not in single-threaded mode). */ +static UA_StatusCode +copyAttributeIntoNode(UA_Server *server, UA_Session *session, + UA_Node *node, const UA_WriteValue *wvalue) { + UA_assert(session != NULL); + const void *value = wvalue->value.value.data; + UA_UInt32 userWriteMask = getUserWriteMask(server, session, &node->head); + UA_StatusCode retval = UA_STATUSCODE_GOOD; + + UA_LOG_NODEID_DEBUG(&node->head.nodeId, + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Write attribute %"PRIi32 " of Node %.*s", + wvalue->attributeId, (int)nodeIdStr.length, + nodeIdStr.data)); + + const UA_VariableTypeNode *type; + + switch(wvalue->attributeId) { + case UA_ATTRIBUTEID_NODEID: + case UA_ATTRIBUTEID_NODECLASS: + case UA_ATTRIBUTEID_USERWRITEMASK: + case UA_ATTRIBUTEID_USERACCESSLEVEL: + case UA_ATTRIBUTEID_USEREXECUTABLE: + case UA_ATTRIBUTEID_BROWSENAME: /* BrowseName is tracked in a binary tree + for fast lookup */ + retval = UA_STATUSCODE_BADWRITENOTSUPPORTED; + break; + case UA_ATTRIBUTEID_DISPLAYNAME: + CHECK_USERWRITEMASK(UA_WRITEMASK_DISPLAYNAME); + CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT); + retval = updateLocalizedText((const UA_LocalizedText *)value, + &node->head.displayName); + break; + case UA_ATTRIBUTEID_DESCRIPTION: + CHECK_USERWRITEMASK(UA_WRITEMASK_DESCRIPTION); + CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT); + retval = updateLocalizedText((const UA_LocalizedText *)value, + &node->head.description); + break; + case UA_ATTRIBUTEID_WRITEMASK: + CHECK_USERWRITEMASK(UA_WRITEMASK_WRITEMASK); + CHECK_DATATYPE_SCALAR(UINT32); + node->head.writeMask = *(const UA_UInt32*)value; + break; + case UA_ATTRIBUTEID_ISABSTRACT: + CHECK_USERWRITEMASK(UA_WRITEMASK_ISABSTRACT); + CHECK_DATATYPE_SCALAR(BOOLEAN); + retval = writeIsAbstractAttribute(node, *(const UA_Boolean*)value); + break; + case UA_ATTRIBUTEID_SYMMETRIC: + CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE); + CHECK_USERWRITEMASK(UA_WRITEMASK_SYMMETRIC); + CHECK_DATATYPE_SCALAR(BOOLEAN); + node->referenceTypeNode.symmetric = *(const UA_Boolean*)value; + break; + case UA_ATTRIBUTEID_INVERSENAME: + CHECK_NODECLASS_WRITE(UA_NODECLASS_REFERENCETYPE); + CHECK_USERWRITEMASK(UA_WRITEMASK_INVERSENAME); + CHECK_DATATYPE_SCALAR(LOCALIZEDTEXT); + retval = updateLocalizedText((const UA_LocalizedText *)value, + &node->referenceTypeNode.inverseName); + break; + case UA_ATTRIBUTEID_CONTAINSNOLOOPS: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW); + CHECK_USERWRITEMASK(UA_WRITEMASK_CONTAINSNOLOOPS); + CHECK_DATATYPE_SCALAR(BOOLEAN); + node->viewNode.containsNoLoops = *(const UA_Boolean*)value; + break; + case UA_ATTRIBUTEID_EVENTNOTIFIER: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT); + CHECK_USERWRITEMASK(UA_WRITEMASK_EVENTNOTIFIER); + CHECK_DATATYPE_SCALAR(BYTE); + if(node->head.nodeClass == UA_NODECLASS_VIEW) { + node->viewNode.eventNotifier = *(const UA_Byte*)value; + } else { + node->objectNode.eventNotifier = *(const UA_Byte*)value; + } + break; + case UA_ATTRIBUTEID_VALUE: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + if(node->head.nodeClass == UA_NODECLASS_VARIABLE) { + /* The access to a value variable is granted via the AccessLevel + * and UserAccessLevel attributes */ + UA_Byte accessLevel = getAccessLevel(server, session, &node->variableNode); + if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) { + retval = UA_STATUSCODE_BADNOTWRITABLE; + break; + } + accessLevel = getUserAccessLevel(server, session, &node->variableNode); + if(!(accessLevel & (UA_ACCESSLEVELMASK_WRITE))) { + retval = UA_STATUSCODE_BADUSERACCESSDENIED; + break; + } + } else { /* UA_NODECLASS_VARIABLETYPE */ + CHECK_USERWRITEMASK(UA_WRITEMASK_VALUEFORVARIABLETYPE); + } + retval = writeNodeValueAttribute(server, session, &node->variableNode, + &wvalue->value, &wvalue->indexRange); + break; + case UA_ATTRIBUTEID_DATATYPE: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + CHECK_USERWRITEMASK(UA_WRITEMASK_DATATYPE); + CHECK_DATATYPE_SCALAR(NODEID); + GET_NODETYPE; + retval = writeDataTypeAttribute(server, session, &node->variableNode, + type, (const UA_NodeId*)value); + UA_NODESTORE_RELEASE(server, (const UA_Node*)type); + break; + case UA_ATTRIBUTEID_VALUERANK: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + CHECK_USERWRITEMASK(UA_WRITEMASK_VALUERANK); + CHECK_DATATYPE_SCALAR(INT32); + GET_NODETYPE; + retval = writeValueRankAttribute(server, session, &node->variableNode, + type, *(const UA_Int32*)value); + UA_NODESTORE_RELEASE(server, (const UA_Node*)type); + break; + case UA_ATTRIBUTEID_ARRAYDIMENSIONS: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE); + CHECK_USERWRITEMASK(UA_WRITEMASK_ARRRAYDIMENSIONS); + CHECK_DATATYPE_ARRAY(UINT32); + GET_NODETYPE; + retval = writeArrayDimensionsAttribute(server, session, &node->variableNode, + type, wvalue->value.value.arrayLength, + (UA_UInt32 *)wvalue->value.value.data); + UA_NODESTORE_RELEASE(server, (const UA_Node*)type); + break; + case UA_ATTRIBUTEID_ACCESSLEVEL: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE); + CHECK_USERWRITEMASK(UA_WRITEMASK_ACCESSLEVEL); + CHECK_DATATYPE_SCALAR(BYTE); + node->variableNode.accessLevel = *(const UA_Byte*)value; + break; + case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE); + CHECK_USERWRITEMASK(UA_WRITEMASK_MINIMUMSAMPLINGINTERVAL); + CHECK_DATATYPE_SCALAR(DOUBLE); + node->variableNode.minimumSamplingInterval = *(const UA_Double*)value; + break; + case UA_ATTRIBUTEID_HISTORIZING: + CHECK_NODECLASS_WRITE(UA_NODECLASS_VARIABLE); + CHECK_USERWRITEMASK(UA_WRITEMASK_HISTORIZING); + CHECK_DATATYPE_SCALAR(BOOLEAN); + node->variableNode.historizing = *(const UA_Boolean*)value; + break; + case UA_ATTRIBUTEID_EXECUTABLE: + CHECK_NODECLASS_WRITE(UA_NODECLASS_METHOD); + CHECK_USERWRITEMASK(UA_WRITEMASK_EXECUTABLE); + CHECK_DATATYPE_SCALAR(BOOLEAN); + node->methodNode.executable = *(const UA_Boolean*)value; + break; + default: + retval = UA_STATUSCODE_BADATTRIBUTEIDINVALID; + break; + } + + /* Check if writing succeeded */ + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "WriteRequest returned status code %s", + UA_StatusCode_name(retval)); + return retval; + } + + /* Trigger MonitoredItems with no SamplingInterval */ + triggerImmediateDataChange(server, session, node, wvalue); + + return UA_STATUSCODE_GOOD; +} + +static void +Operation_Write(UA_Server *server, UA_Session *session, void *context, + const UA_WriteValue *wv, UA_StatusCode *result) { + UA_assert(session != NULL); + *result = UA_Server_editNode(server, session, &wv->nodeId, + (UA_EditNodeCallback)copyAttributeIntoNode, + (void*)(uintptr_t)wv); +} + +void +Service_Write(UA_Server *server, UA_Session *session, + const UA_WriteRequest *request, + UA_WriteResponse *response) { + UA_assert(session != NULL); + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing WriteRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxNodesPerWrite != 0 && + request->nodesToWriteSize > server->config.maxNodesPerWrite) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_Write, NULL, + &request->nodesToWriteSize, + &UA_TYPES[UA_TYPES_WRITEVALUE], + &response->resultsSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +UA_StatusCode +UA_Server_write(UA_Server *server, const UA_WriteValue *value) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_LOCK(&server->serviceMutex); + Operation_Write(server, &server->adminSession, NULL, value, &res); + UA_UNLOCK(&server->serviceMutex); + return res; +} + +/* Convenience function to be wrapped into inline functions */ +UA_StatusCode +__UA_Server_write(UA_Server *server, const UA_NodeId *nodeId, + const UA_AttributeId attributeId, + const UA_DataType *attr_type, const void *attr) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode res = writeAttribute(server, &server->adminSession, + nodeId, attributeId, attr, attr_type); + UA_UNLOCK(&server->serviceMutex); + return res; +} + +/* Internal convenience function */ +UA_StatusCode +writeAttribute(UA_Server *server, UA_Session *session, + const UA_NodeId *nodeId, const UA_AttributeId attributeId, + const void *attr, const UA_DataType *attr_type) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_WriteValue wvalue; + UA_WriteValue_init(&wvalue); + wvalue.nodeId = *nodeId; + wvalue.attributeId = attributeId; + wvalue.value.hasValue = true; + if(attr_type == &UA_TYPES[UA_TYPES_VARIANT]) { + wvalue.value.value = *(const UA_Variant*)attr; + } else if(attr_type == &UA_TYPES[UA_TYPES_DATAVALUE]) { + wvalue.value = *(const UA_DataValue*)attr; + } else { + /* hacked cast. the target WriteValue is used as const anyway */ + UA_Variant_setScalar(&wvalue.value.value, + (void*)(uintptr_t)attr, attr_type); + } + + UA_StatusCode res = UA_STATUSCODE_GOOD; + Operation_Write(server, session, NULL, &wvalue, &res); + return res; +} + +#ifdef UA_ENABLE_HISTORIZING +typedef void + (*UA_HistoryDatabase_readFunc)(UA_Server *server, void *hdbContext, + const UA_NodeId *sessionId, void *sessionContext, + const UA_RequestHeader *requestHeader, + const void *historyReadDetails, + UA_TimestampsToReturn timestampsToReturn, + UA_Boolean releaseContinuationPoints, + size_t nodesToReadSize, + const UA_HistoryReadValueId *nodesToRead, + UA_HistoryReadResponse *response, + void * const * const historyData); + +void +Service_HistoryRead(UA_Server *server, UA_Session *session, + const UA_HistoryReadRequest *request, + UA_HistoryReadResponse *response) { + UA_assert(session != NULL); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(request->historyReadDetails.encoding != UA_EXTENSIONOBJECT_DECODED) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTSUPPORTED; + return; + } + + const UA_DataType *historyDataType = &UA_TYPES[UA_TYPES_HISTORYDATA]; + UA_HistoryDatabase_readFunc readHistory = NULL; + if(request->historyReadDetails.content.decoded.type == + &UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS]) { + UA_ReadRawModifiedDetails *details = (UA_ReadRawModifiedDetails*) + request->historyReadDetails.content.decoded.data; + if(!details->isReadModified) { + readHistory = (UA_HistoryDatabase_readFunc) + server->config.historyDatabase.readRaw; + } else { + historyDataType = &UA_TYPES[UA_TYPES_HISTORYMODIFIEDDATA]; + readHistory = (UA_HistoryDatabase_readFunc) + server->config.historyDatabase.readModified; + } + } else if(request->historyReadDetails.content.decoded.type == + &UA_TYPES[UA_TYPES_READEVENTDETAILS]) { + historyDataType = &UA_TYPES[UA_TYPES_HISTORYEVENT]; + readHistory = (UA_HistoryDatabase_readFunc) + server->config.historyDatabase.readEvent; + } else if(request->historyReadDetails.content.decoded.type == + &UA_TYPES[UA_TYPES_READPROCESSEDDETAILS]) { + readHistory = (UA_HistoryDatabase_readFunc) + server->config.historyDatabase.readProcessed; + } else if(request->historyReadDetails.content.decoded.type == + &UA_TYPES[UA_TYPES_READATTIMEDETAILS]) { + readHistory = (UA_HistoryDatabase_readFunc) + server->config.historyDatabase.readAtTime; + } else { + /* TODO handle more request->historyReadDetails.content.decoded.type types */ + response->responseHeader.serviceResult = UA_STATUSCODE_BADHISTORYOPERATIONUNSUPPORTED; + return; + } + + /* Something to do? */ + if(request->nodesToReadSize == 0) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO; + return; + } + + /* Check if there are too many operations */ + if(server->config.maxNodesPerRead != 0 && + request->nodesToReadSize > server->config.maxNodesPerRead) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + /* Allocate a temporary array to forward the result pointers to the + * backend */ + void **historyData = (void **) + UA_calloc(request->nodesToReadSize, sizeof(void*)); + if(!historyData) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + /* Allocate the results array */ + response->results = (UA_HistoryReadResult*) + UA_Array_new(request->nodesToReadSize, &UA_TYPES[UA_TYPES_HISTORYREADRESULT]); + if(!response->results) { + UA_free(historyData); + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + response->resultsSize = request->nodesToReadSize; + + for(size_t i = 0; i < response->resultsSize; ++i) { + void * data = UA_new(historyDataType); + UA_ExtensionObject_setValue(&response->results[i].historyData, + data, historyDataType); + historyData[i] = data; + } + UA_UNLOCK(&server->serviceMutex); + readHistory(server, server->config.historyDatabase.context, + &session->sessionId, session->sessionHandle, + &request->requestHeader, + request->historyReadDetails.content.decoded.data, + request->timestampsToReturn, + request->releaseContinuationPoints, + request->nodesToReadSize, request->nodesToRead, + response, historyData); + UA_LOCK(&server->serviceMutex); + UA_free(historyData); +} + +void +Service_HistoryUpdate(UA_Server *server, UA_Session *session, + const UA_HistoryUpdateRequest *request, + UA_HistoryUpdateResponse *response) { + UA_assert(session != NULL); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + response->resultsSize = request->historyUpdateDetailsSize; + response->results = (UA_HistoryUpdateResult*) + UA_Array_new(response->resultsSize, &UA_TYPES[UA_TYPES_HISTORYUPDATERESULT]); + if(!response->results) { + response->resultsSize = 0; + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + for(size_t i = 0; i < request->historyUpdateDetailsSize; ++i) { + UA_HistoryUpdateResult_init(&response->results[i]); + if(request->historyUpdateDetails[i].encoding != UA_EXTENSIONOBJECT_DECODED) { + response->results[i].statusCode = UA_STATUSCODE_BADNOTSUPPORTED; + continue; + } + + const UA_DataType *updateDetailsType = + request->historyUpdateDetails[i].content.decoded.type; + void *updateDetailsData = request->historyUpdateDetails[i].content.decoded.data; + + if(updateDetailsType == &UA_TYPES[UA_TYPES_UPDATEDATADETAILS]) { + if(!server->config.historyDatabase.updateData) { + response->results[i].statusCode = UA_STATUSCODE_BADNOTSUPPORTED; + continue; + } + UA_UNLOCK(&server->serviceMutex); + server->config.historyDatabase. + updateData(server, server->config.historyDatabase.context, + &session->sessionId, session->sessionHandle, + &request->requestHeader, + (UA_UpdateDataDetails*)updateDetailsData, + &response->results[i]); + UA_LOCK(&server->serviceMutex); + continue; + } + + if(updateDetailsType == &UA_TYPES[UA_TYPES_DELETERAWMODIFIEDDETAILS]) { + if(!server->config.historyDatabase.deleteRawModified) { + response->results[i].statusCode = UA_STATUSCODE_BADNOTSUPPORTED; + continue; + } + UA_UNLOCK(&server->serviceMutex); + server->config.historyDatabase. + deleteRawModified(server, server->config.historyDatabase.context, + &session->sessionId, session->sessionHandle, + &request->requestHeader, + (UA_DeleteRawModifiedDetails*)updateDetailsData, + &response->results[i]); + UA_LOCK(&server->serviceMutex); + continue; + } + + response->results[i].statusCode = UA_STATUSCODE_BADNOTSUPPORTED; + } +} + +#endif + +UA_StatusCode +UA_Server_writeObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + const UA_Variant value) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retVal = writeObjectProperty(server, objectId, propertyName, value); + UA_UNLOCK(&server->serviceMutex); + return retVal; +} + +UA_StatusCode +writeObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + const UA_Variant value) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_RelativePathElement rpe; + UA_RelativePathElement_init(&rpe); + rpe.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY); + rpe.isInverse = false; + rpe.includeSubtypes = false; + rpe.targetName = propertyName; + + UA_BrowsePath bp; + UA_BrowsePath_init(&bp); + bp.startingNode = objectId; + bp.relativePath.elementsSize = 1; + bp.relativePath.elements = &rpe; + + UA_StatusCode retval; + UA_BrowsePathResult bpr = translateBrowsePathToNodeIds(server, &bp); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + retval = bpr.statusCode; + UA_BrowsePathResult_clear(&bpr); + return retval; + } + + retval = writeValueAttribute(server, &server->adminSession, + &bpr.targets[0].targetId.nodeId, &value); + + UA_BrowsePathResult_clear(&bpr); + return retval; +} + +UA_StatusCode UA_EXPORT +UA_Server_writeObjectProperty_scalar(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + const void *value, const UA_DataType *type) { + UA_Variant var; + UA_Variant_init(&var); + UA_Variant_setScalar(&var, (void*)(uintptr_t)value, type); + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = writeObjectProperty(server, objectId, propertyName, var); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/**** amalgamated original file "/src/server/ua_services_discovery.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2016 (c) Sten Grüner + * Copyright 2014, 2017 (c) Florian Palm + * Copyright 2016 (c) Oleksiy Vasylyev + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) frax2222 + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + */ + + +#ifdef UA_ENABLE_DISCOVERY + + +static UA_StatusCode +setApplicationDescriptionFromRegisteredServer(const UA_FindServersRequest *request, + UA_ApplicationDescription *target, + const UA_RegisteredServer *registeredServer) { + UA_ApplicationDescription_init(target); + UA_StatusCode retval = UA_String_copy(®isteredServer->serverUri, &target->applicationUri); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + retval = UA_String_copy(®isteredServer->productUri, &target->productUri); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + // if the client requests a specific locale, select the corresponding server name + if(request->localeIdsSize) { + UA_Boolean appNameFound = false; + for(size_t i =0; ilocaleIdsSize && !appNameFound; i++) { + for(size_t j =0; jserverNamesSize; j++) { + if(UA_String_equal(&request->localeIds[i], ®isteredServer->serverNames[j].locale)) { + retval = UA_LocalizedText_copy(®isteredServer->serverNames[j], + &target->applicationName); + if(retval != UA_STATUSCODE_GOOD) + return retval; + appNameFound = true; + break; + } + } + } + + // server does not have the requested local, therefore we can select the + // most suitable one + if(!appNameFound && registeredServer->serverNamesSize) { + retval = UA_LocalizedText_copy(®isteredServer->serverNames[0], + &target->applicationName); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + } else if(registeredServer->serverNamesSize) { + // just take the first name + retval = UA_LocalizedText_copy(®isteredServer->serverNames[0], &target->applicationName); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + target->applicationType = registeredServer->serverType; + retval = UA_String_copy(®isteredServer->gatewayServerUri, &target->gatewayServerUri); + if(retval != UA_STATUSCODE_GOOD) + return retval; + // TODO where do we get the discoveryProfileUri for application data? + + target->discoveryUrlsSize = registeredServer->discoveryUrlsSize; + if(registeredServer->discoveryUrlsSize) { + size_t duSize = sizeof(UA_String) * registeredServer->discoveryUrlsSize; + target->discoveryUrls = (UA_String *)UA_malloc(duSize); + if(!target->discoveryUrls) + return UA_STATUSCODE_BADOUTOFMEMORY; + for(size_t i = 0; i < registeredServer->discoveryUrlsSize; i++) { + retval = UA_String_copy(®isteredServer->discoveryUrls[i], &target->discoveryUrls[i]); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + } + + return retval; +} +#endif + +static UA_StatusCode +setApplicationDescriptionFromServer(UA_ApplicationDescription *target, const UA_Server *server) { + /* Copy ApplicationDescription from the config */ + UA_StatusCode result = UA_ApplicationDescription_copy(&server->config.applicationDescription, target); + if(result != UA_STATUSCODE_GOOD) + return result; + + /* Add the discoveryUrls from the networklayers only if discoveryUrl + * not already present and to avoid redundancy */ + if(!target->discoveryUrlsSize) { + size_t discSize = sizeof(UA_String) * (target->discoveryUrlsSize + server->config.networkLayersSize); + UA_String* disc = (UA_String *)UA_realloc(target->discoveryUrls, discSize); + if(!disc) + return UA_STATUSCODE_BADOUTOFMEMORY; + size_t existing = target->discoveryUrlsSize; + target->discoveryUrls = disc; + target->discoveryUrlsSize += server->config.networkLayersSize; + + for(size_t i = 0; i < server->config.networkLayersSize; i++) { + UA_ServerNetworkLayer* nl = &server->config.networkLayers[i]; + UA_String_copy(&nl->discoveryUrl, &target->discoveryUrls[existing + i]); + } + } + + return UA_STATUSCODE_GOOD; +} + +void Service_FindServers(UA_Server *server, UA_Session *session, + const UA_FindServersRequest *request, + UA_FindServersResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing FindServersRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Return the server itself? */ + UA_Boolean foundSelf = false; + if(request->serverUrisSize) { + for(size_t i = 0; i < request->serverUrisSize; i++) { + if(UA_String_equal(&request->serverUris[i], + &server->config.applicationDescription.applicationUri)) { + foundSelf = true; + break; + } + } + } else { + foundSelf = true; + } + +#ifndef UA_ENABLE_DISCOVERY + if(!foundSelf) + return; + + UA_ApplicationDescription *ad = UA_ApplicationDescription_new(); + if(!ad) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + UA_StatusCode retval = setApplicationDescriptionFromServer(ad, server); + if(retval != UA_STATUSCODE_GOOD) { + UA_ApplicationDescription_delete(ad); + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + response->servers = ad; + response->serversSize = 1; + return; + +#else + + /* Allocate enough memory, including memory for the "self" response */ + size_t maxResults = server->discoveryManager.registeredServersSize + 1; + response->servers = (UA_ApplicationDescription*)UA_Array_new(maxResults, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]); + if(!response->servers) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + /* Copy into the response. TODO: Evaluate return codes */ + size_t pos = 0; + if(foundSelf) + setApplicationDescriptionFromServer(&response->servers[pos++], server); + + registeredServer_list_entry* current; + LIST_FOREACH(current, &server->discoveryManager.registeredServers, pointers) { + UA_Boolean usable = (request->serverUrisSize == 0); + if(!usable) { + /* If client only requested a specific set of servers */ + for(size_t i = 0; i < request->serverUrisSize; i++) { + if(UA_String_equal(¤t->registeredServer.serverUri, &request->serverUris[i])) { + usable = true; + break; + } + } + } + + if(usable) + setApplicationDescriptionFromRegisteredServer(request, &response->servers[pos++], + ¤t->registeredServer); + } + + /* Set the final size */ + if(pos > 0) { + response->serversSize = pos; + } else { + UA_free(response->servers); + response->servers = NULL; + } +#endif +} + +void +Service_GetEndpoints(UA_Server *server, UA_Session *session, + const UA_GetEndpointsRequest *request, + UA_GetEndpointsResponse *response) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* If the client expects to see a specific endpointurl, mirror it back. If + * not, clone the endpoints with the discovery url of all networklayers. */ + const UA_String *endpointUrl = &request->endpointUrl; + if(endpointUrl->length > 0) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing GetEndpointsRequest with endpointUrl " + UA_PRINTF_STRING_FORMAT, UA_PRINTF_STRING_DATA(*endpointUrl)); + } else { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing GetEndpointsRequest with an empty endpointUrl"); + } + + /* Clone the endpoint for each networklayer? */ + size_t clone_times = 1; + UA_Boolean nl_endpointurl = false; + if(endpointUrl->length == 0) { + clone_times = server->config.networkLayersSize; + nl_endpointurl = true; + } + + /* Allocate enough memory */ + response->endpoints = (UA_EndpointDescription*) + UA_Array_new(server->config.endpointsSize * clone_times, + &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); + if(!response->endpoints) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + size_t pos = 0; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + for(size_t j = 0; j < server->config.endpointsSize; ++j) { + /* Test if the supported binary profile shall be returned */ + UA_Boolean usable = (request->profileUrisSize == 0); + if(!usable) { + for(size_t i = 0; i < request->profileUrisSize; ++i) { + if(!UA_String_equal(&request->profileUris[i], + &server->config.endpoints[j].transportProfileUri)) + continue; + usable = true; + break; + } + } + if(!usable) + continue; + + /* Copy into the results */ + for(size_t i = 0; i < clone_times; ++i) { + retval |= UA_EndpointDescription_copy(&server->config.endpoints[j], + &response->endpoints[pos]); + if(nl_endpointurl) + endpointUrl = &server->config.networkLayers[i].discoveryUrl; + retval |= UA_String_copy(endpointUrl, &response->endpoints[pos].endpointUrl); + retval |= UA_Array_copy(endpointUrl, 1, + (void**)&response->endpoints[pos].server.discoveryUrls, + &UA_TYPES[UA_TYPES_STRING]); + if(retval != UA_STATUSCODE_GOOD) + goto error; + response->endpoints[pos].server.discoveryUrlsSize = 1; + pos++; + } + } + + UA_assert(pos <= server->config.endpointsSize * clone_times); + response->endpointsSize = pos; + + /* Clean up the memory of there are no usable results */ + if(pos > 0) + return; + +error: + response->responseHeader.serviceResult = retval; + UA_Array_delete(response->endpoints, response->endpointsSize, + &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); + response->endpoints = NULL; + response->endpointsSize = 0; +} + +#ifdef UA_ENABLE_DISCOVERY + +static void +process_RegisterServer(UA_Server *server, UA_Session *session, + const UA_RequestHeader* requestHeader, + const UA_RegisteredServer *requestServer, + const size_t requestDiscoveryConfigurationSize, + const UA_ExtensionObject *requestDiscoveryConfiguration, + UA_ResponseHeader* responseHeader, + size_t *responseConfigurationResultsSize, + UA_StatusCode **responseConfigurationResults, + size_t *responseDiagnosticInfosSize, + UA_DiagnosticInfo *responseDiagnosticInfos) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Find the server from the request in the registered list */ + registeredServer_list_entry* current; + registeredServer_list_entry *registeredServer_entry = NULL; + LIST_FOREACH(current, &server->discoveryManager.registeredServers, pointers) { + if(UA_String_equal(¤t->registeredServer.serverUri, &requestServer->serverUri)) { + registeredServer_entry = current; + break; + } + } + + UA_MdnsDiscoveryConfiguration *mdnsConfig = NULL; + + const UA_String* mdnsServerName = NULL; + if(requestDiscoveryConfigurationSize) { + *responseConfigurationResults = + (UA_StatusCode *)UA_Array_new(requestDiscoveryConfigurationSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); + if(!(*responseConfigurationResults)) { + responseHeader->serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + *responseConfigurationResultsSize = requestDiscoveryConfigurationSize; + + for(size_t i = 0; i < requestDiscoveryConfigurationSize; i++) { + const UA_ExtensionObject *object = &requestDiscoveryConfiguration[i]; + if(!mdnsConfig && (object->encoding == UA_EXTENSIONOBJECT_DECODED || + object->encoding == UA_EXTENSIONOBJECT_DECODED_NODELETE) && + (object->content.decoded.type == &UA_TYPES[UA_TYPES_MDNSDISCOVERYCONFIGURATION])) { + mdnsConfig = (UA_MdnsDiscoveryConfiguration *)object->content.decoded.data; + mdnsServerName = &mdnsConfig->mdnsServerName; + (*responseConfigurationResults)[i] = UA_STATUSCODE_GOOD; + } else { + (*responseConfigurationResults)[i] = UA_STATUSCODE_BADNOTSUPPORTED; + } + } + } + + if(!mdnsServerName && requestServer->serverNamesSize) + mdnsServerName = &requestServer->serverNames[0].text; + + if(!mdnsServerName) { + responseHeader->serviceResult = UA_STATUSCODE_BADSERVERNAMEMISSING; + return; + } + + if(requestServer->discoveryUrlsSize == 0) { + responseHeader->serviceResult = UA_STATUSCODE_BADDISCOVERYURLMISSING; + return; + } + + if(requestServer->semaphoreFilePath.length) { +#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE + char* filePath = (char*) + UA_malloc(sizeof(char)*requestServer->semaphoreFilePath.length+1); + if(!filePath) { + UA_LOG_ERROR_SESSION(&server->config.logger, session, + "Cannot allocate memory for semaphore path. Out of memory."); + responseHeader->serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + memcpy(filePath, requestServer->semaphoreFilePath.data, requestServer->semaphoreFilePath.length ); + filePath[requestServer->semaphoreFilePath.length] = '\0'; + if(!UA_fileExists( filePath )) { + responseHeader->serviceResult = UA_STATUSCODE_BADSEMPAHOREFILEMISSING; + UA_free(filePath); + return; + } + UA_free(filePath); +#else + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_CLIENT, + "Ignoring semaphore file path. open62541 not compiled " + "with UA_ENABLE_DISCOVERY_SEMAPHORE=ON"); +#endif + } + +#ifdef UA_ENABLE_DISCOVERY_MULTICAST + if(server->config.mdnsEnabled) { + for(size_t i = 0; i < requestServer->discoveryUrlsSize; i++) { + /* create TXT if is online and first index, delete TXT if is offline and last index */ + UA_Boolean updateTxt = (requestServer->isOnline && i==0) || + (!requestServer->isOnline && i==requestServer->discoveryUrlsSize); + UA_Server_updateMdnsForDiscoveryUrl(server, mdnsServerName, mdnsConfig, + &requestServer->discoveryUrls[i], + requestServer->isOnline, updateTxt); + } + } +#endif + + if(!requestServer->isOnline) { + // server is shutting down. Remove it from the registered servers list + if(!registeredServer_entry) { + // server not found, show warning + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "Could not unregister server %.*s. Not registered.", + (int)requestServer->serverUri.length, requestServer->serverUri.data); + responseHeader->serviceResult = UA_STATUSCODE_BADNOTHINGTODO; + return; + } + + if(server->discoveryManager.registerServerCallback) { + UA_UNLOCK(&server->serviceMutex); + server->discoveryManager. + registerServerCallback(requestServer, + server->discoveryManager.registerServerCallbackData); + UA_LOCK(&server->serviceMutex); + } + + // server found, remove from list + LIST_REMOVE(registeredServer_entry, pointers); + UA_RegisteredServer_clear(®isteredServer_entry->registeredServer); + UA_free(registeredServer_entry); + server->discoveryManager.registeredServersSize--; + responseHeader->serviceResult = UA_STATUSCODE_GOOD; + return; + } + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(!registeredServer_entry) { + // server not yet registered, register it by adding it to the list + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Registering new server: %.*s", + (int)requestServer->serverUri.length, requestServer->serverUri.data); + + registeredServer_entry = + (registeredServer_list_entry *)UA_malloc(sizeof(registeredServer_list_entry)); + if(!registeredServer_entry) { + responseHeader->serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + LIST_INSERT_HEAD(&server->discoveryManager.registeredServers, registeredServer_entry, pointers); + UA_atomic_addSize(&server->discoveryManager.registeredServersSize, 1); + } else { + UA_RegisteredServer_clear(®isteredServer_entry->registeredServer); + } + + // Always call the callback, if it is set. + // Previously we only called it if it was a new register call. It may be the case that this endpoint + // registered before, then crashed, restarts and registeres again. In that case the entry is not deleted + // and the callback would not be called. + if(server->discoveryManager.registerServerCallback) { + UA_UNLOCK(&server->serviceMutex); + server->discoveryManager. + registerServerCallback(requestServer, + server->discoveryManager.registerServerCallbackData); + UA_LOCK(&server->serviceMutex); + } + + // copy the data from the request into the list + UA_RegisteredServer_copy(requestServer, ®isteredServer_entry->registeredServer); + registeredServer_entry->lastSeen = UA_DateTime_nowMonotonic(); + responseHeader->serviceResult = retval; +} + +void Service_RegisterServer(UA_Server *server, UA_Session *session, + const UA_RegisterServerRequest *request, + UA_RegisterServerResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing RegisterServerRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + process_RegisterServer(server, session, &request->requestHeader, &request->server, 0, + NULL, &response->responseHeader, 0, NULL, 0, NULL); +} + +void Service_RegisterServer2(UA_Server *server, UA_Session *session, + const UA_RegisterServer2Request *request, + UA_RegisterServer2Response *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing RegisterServer2Request"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + process_RegisterServer(server, session, &request->requestHeader, &request->server, + request->discoveryConfigurationSize, request->discoveryConfiguration, + &response->responseHeader, &response->configurationResultsSize, + &response->configurationResults, &response->diagnosticInfosSize, + response->diagnosticInfos); +} + +/* Cleanup server registration: If the semaphore file path is set, then it just + * checks the existence of the file. When it is deleted, the registration is + * removed. If there is no semaphore file, then the registration will be removed + * if it is older than 60 minutes. */ +void UA_Discovery_cleanupTimedOut(UA_Server *server, UA_DateTime nowMonotonic) { + UA_DateTime timedOut = nowMonotonic; + // registration is timed out if lastSeen is older than 60 minutes (default + // value, can be modified by user). + if(server->config.discoveryCleanupTimeout) + timedOut -= server->config.discoveryCleanupTimeout * UA_DATETIME_SEC; + + registeredServer_list_entry* current, *temp; + LIST_FOREACH_SAFE(current, &server->discoveryManager.registeredServers, pointers, temp) { + UA_Boolean semaphoreDeleted = false; + +#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE + if(current->registeredServer.semaphoreFilePath.length) { + size_t fpSize = sizeof(char)*current->registeredServer.semaphoreFilePath.length+1; + // todo: malloc may fail: return a statuscode + char* filePath = (char *)UA_malloc(fpSize); + if(filePath) { + memcpy(filePath, current->registeredServer.semaphoreFilePath.data, + current->registeredServer.semaphoreFilePath.length ); + filePath[current->registeredServer.semaphoreFilePath.length] = '\0'; + semaphoreDeleted = UA_fileExists(filePath) == false; + UA_free(filePath); + } else { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Cannot check registration semaphore. Out of memory"); + } + } +#endif + + if(semaphoreDeleted || (server->config.discoveryCleanupTimeout && + current->lastSeen < timedOut)) { + if(semaphoreDeleted) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Registration of server with URI %.*s is removed because " + "the semaphore file '%.*s' was deleted.", + (int)current->registeredServer.serverUri.length, + current->registeredServer.serverUri.data, + (int)current->registeredServer.semaphoreFilePath.length, + current->registeredServer.semaphoreFilePath.data); + } else { + // cppcheck-suppress unreadVariable + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Registration of server with URI %.*s has timed out and is removed.", + (int)current->registeredServer.serverUri.length, + current->registeredServer.serverUri.data); + } + LIST_REMOVE(current, pointers); + UA_RegisteredServer_clear(¤t->registeredServer); + UA_free(current); + server->discoveryManager.registeredServersSize--; + } + } +} + +/* Called by the UA_Server callback. The OPC UA specification says: + * + * > If an error occurs during registration (e.g. the Discovery Server is not running) then the Server + * > must periodically re-attempt registration. The frequency of these attempts should start at 1 second + * > but gradually increase until the registration frequency is the same as what it would be if not + * > errors occurred. The recommended approach would double the period each attempt until reaching the maximum. + * + * We will do so by using the additional data parameter which holds information + * if the next interval is default or if it is a repeated call. */ +static void +periodicServerRegister(UA_Server *server, void *data) { + UA_assert(data != NULL); + UA_LOCK(&server->serviceMutex); + + struct PeriodicServerRegisterCallback *cb = (struct PeriodicServerRegisterCallback *)data; + + UA_StatusCode retval = UA_Client_connectSecureChannel(cb->client, cb->discovery_server_url); + if (retval == UA_STATUSCODE_GOOD) { + /* Register + You can also use a semaphore file. That file must exist. When the file is + deleted, the server is automatically unregistered. The semaphore file has + to be accessible by the discovery server + + UA_StatusCode retval = UA_Server_register_discovery(server, + "opc.tcp://localhost:4840", "/path/to/some/file"); + */ + retval = register_server_with_discovery_server(server, cb->client, false, NULL); + if (retval == UA_STATUSCODE_BADCONNECTIONCLOSED) { + /* If the periodic interval is higher than the maximum lifetime of + * the session, the server will close the connection. In this case + * we should try to reconnect */ + UA_Client_disconnect(cb->client); + retval = UA_Client_connectSecureChannel(cb->client, cb->discovery_server_url); + if (retval == UA_STATUSCODE_GOOD) { + retval = register_server_with_discovery_server(server, cb->client, false, NULL); + } + } + } + /* Registering failed */ + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Could not register server with discovery server. " + "Is the discovery server started? StatusCode %s", + UA_StatusCode_name(retval)); + + /* If the server was previously registered, retry in one second, + * else, double the previous interval */ + UA_Double nextInterval = 1000.0; + if(!cb->registered) + nextInterval = cb->this_interval * 2; + + /* The interval should be smaller than the default interval */ + if(nextInterval > cb->default_interval) + nextInterval = cb->default_interval; + + cb->this_interval = nextInterval; + changeRepeatedCallbackInterval(server, cb->id, nextInterval); + UA_UNLOCK(&server->serviceMutex); + return; + } + + /* Registering succeeded */ + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Server successfully registered. Next periodical register will be in %d seconds", + (int)(cb->default_interval/1000)); + + if(!cb->registered) { + retval = changeRepeatedCallbackInterval(server, cb->id, cb->default_interval); + /* If changing the interval fails, try again after the next registering */ + if(retval == UA_STATUSCODE_GOOD) + cb->registered = true; + } + UA_UNLOCK(&server->serviceMutex); +} + +UA_StatusCode +UA_Server_addPeriodicServerRegisterCallback(UA_Server *server, + struct UA_Client *client, + const char* discoveryServerUrl, + UA_Double intervalMs, + UA_Double delayFirstRegisterMs, + UA_UInt64 *periodicCallbackId) { + UA_LOCK(&server->serviceMutex); + /* No valid server URL */ + if(!discoveryServerUrl) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "No discovery server URL provided"); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINTERNALERROR; + } + + + if (client->connection.state != UA_CONNECTIONSTATE_CLOSED) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINVALIDSTATE; + } + + /* Check if we are already registering with the given discovery url and + * remove the old periodic call */ + periodicServerRegisterCallback_entry *rs, *rs_tmp; + LIST_FOREACH_SAFE(rs, &server->discoveryManager. + periodicServerRegisterCallbacks, pointers, rs_tmp) { + if(strcmp(rs->callback->discovery_server_url, discoveryServerUrl) == 0) { + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "There is already a register callback for '%s' in place. " + "Removing the older one.", discoveryServerUrl); + removeCallback(server, rs->callback->id); + LIST_REMOVE(rs, pointers); + UA_free(rs->callback->discovery_server_url); + UA_free(rs->callback); + UA_free(rs); + break; + } + } + + /* Allocate and initialize */ + struct PeriodicServerRegisterCallback* cb = (struct PeriodicServerRegisterCallback*) + UA_malloc(sizeof(struct PeriodicServerRegisterCallback)); + if(!cb) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + /* Start repeating a failed register after 1s, then increase the delay. Set + * to 500ms, as the delay is doubled before changing the callback + * interval.*/ + cb->this_interval = 500.0; + cb->default_interval = intervalMs; + cb->registered = false; + cb->client = client; + size_t len = strlen(discoveryServerUrl); + cb->discovery_server_url = (char*)UA_malloc(len+1); + if (!cb->discovery_server_url) { + UA_free(cb); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + memcpy(cb->discovery_server_url, discoveryServerUrl, len+1); + + /* Add the callback */ + UA_StatusCode retval = + addRepeatedCallback(server, periodicServerRegister, + cb, delayFirstRegisterMs, &cb->id); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Could not create periodic job for server register. " + "StatusCode %s", UA_StatusCode_name(retval)); + UA_free(cb); + UA_UNLOCK(&server->serviceMutex); + return retval; + } + +#ifndef __clang_analyzer__ + // the analyzer reports on LIST_INSERT_HEAD a use after free false positive + periodicServerRegisterCallback_entry *newEntry = (periodicServerRegisterCallback_entry*) + UA_malloc(sizeof(periodicServerRegisterCallback_entry)); + if(!newEntry) { + removeCallback(server, cb->id); + UA_free(cb); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + newEntry->callback = cb; + LIST_INSERT_HEAD(&server->discoveryManager.periodicServerRegisterCallbacks, newEntry, pointers); +#endif + + if(periodicCallbackId) + *periodicCallbackId = cb->id; + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_GOOD; +} + +void +UA_Server_setRegisterServerCallback(UA_Server *server, + UA_Server_registerServerCallback cb, + void* data) { + UA_LOCK(&server->serviceMutex); + server->discoveryManager.registerServerCallback = cb; + server->discoveryManager.registerServerCallbackData = data; + UA_UNLOCK(&server->serviceMutex); +} + +#endif /* UA_ENABLE_DISCOVERY */ + +/**** amalgamated original file "/src/server/ua_services_subscription.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2016-2017 (c) Florian Palm + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Ari Breitkreuz, fortiss GmbH + * Copyright 2017 (c) Mattias Bornhager + * Copyright 2017 (c) Henrik Norrman + * Copyright 2017-2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2018 (c) Fabian Arndt, Root-Core + * Copyright 2017-2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + +#ifdef UA_ENABLE_SUBSCRIPTIONS /* conditional compilation */ + +static void +setSubscriptionSettings(UA_Server *server, UA_Subscription *subscription, + UA_Double requestedPublishingInterval, + UA_UInt32 requestedLifetimeCount, + UA_UInt32 requestedMaxKeepAliveCount, + UA_UInt32 maxNotificationsPerPublish, + UA_Byte priority) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* re-parameterize the subscription */ + UA_BOUNDEDVALUE_SETWBOUNDS(server->config.publishingIntervalLimits, + requestedPublishingInterval, subscription->publishingInterval); + /* check for nan*/ + if(requestedPublishingInterval != requestedPublishingInterval) + subscription->publishingInterval = server->config.publishingIntervalLimits.min; + UA_BOUNDEDVALUE_SETWBOUNDS(server->config.keepAliveCountLimits, + requestedMaxKeepAliveCount, subscription->maxKeepAliveCount); + UA_BOUNDEDVALUE_SETWBOUNDS(server->config.lifeTimeCountLimits, + requestedLifetimeCount, subscription->lifeTimeCount); + if(subscription->lifeTimeCount < 3 * subscription->maxKeepAliveCount) + subscription->lifeTimeCount = 3 * subscription->maxKeepAliveCount; + subscription->notificationsPerPublish = maxNotificationsPerPublish; + if(maxNotificationsPerPublish == 0 || + maxNotificationsPerPublish > server->config.maxNotificationsPerPublish) + subscription->notificationsPerPublish = server->config.maxNotificationsPerPublish; + subscription->priority = priority; +} + +void +Service_CreateSubscription(UA_Server *server, UA_Session *session, + const UA_CreateSubscriptionRequest *request, + UA_CreateSubscriptionResponse *response) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Check limits for the number of subscriptions */ + if(((server->config.maxSubscriptions != 0) && + (server->subscriptionsSize >= server->config.maxSubscriptions)) || + ((server->config.maxSubscriptionsPerSession != 0) && + (session->subscriptionsSize >= server->config.maxSubscriptionsPerSession))) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYSUBSCRIPTIONS; + return; + } + + /* Create the subscription */ + UA_Subscription *sub= UA_Subscription_new(); + if(!sub) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing CreateSubscriptionRequest failed"); + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + /* Set the subscription parameters */ + setSubscriptionSettings(server, sub, request->requestedPublishingInterval, + request->requestedLifetimeCount, request->requestedMaxKeepAliveCount, + request->maxNotificationsPerPublish, request->priority); + sub->publishingEnabled = request->publishingEnabled; + sub->currentKeepAliveCount = sub->maxKeepAliveCount; /* set settings first */ + + /* Assign the SubscriptionId */ + sub->subscriptionId = ++server->lastSubscriptionId; + + /* Register the cyclic callback */ + UA_StatusCode retval = Subscription_registerPublishCallback(server, sub); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_DEBUG_SESSION(&server->config.logger, sub->session, + "Subscription %" PRIu32 " | " + "Could not register publish callback with error code %s", + sub->subscriptionId, UA_StatusCode_name(retval)); + response->responseHeader.serviceResult = retval; + UA_Subscription_delete(server, sub); + return; + } + + /* Register the subscription in the server */ + LIST_INSERT_HEAD(&server->subscriptions, sub, serverListEntry); + server->subscriptionsSize++; + + /* Attach the Subscription to the session */ + UA_Session_attachSubscription(session, sub); + + /* Prepare the response */ + response->subscriptionId = sub->subscriptionId; + response->revisedPublishingInterval = sub->publishingInterval; + response->revisedLifetimeCount = sub->lifeTimeCount; + response->revisedMaxKeepAliveCount = sub->maxKeepAliveCount; + + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, sub, + "Created the Subscription with a publishing interval of %.2f ms", + sub->publishingInterval); +} + +void +Service_ModifySubscription(UA_Server *server, UA_Session *session, + const UA_ModifySubscriptionRequest *request, + UA_ModifySubscriptionResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing ModifySubscriptionRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_Subscription *sub = UA_Session_getSubscriptionById(session, request->subscriptionId); + if(!sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + /* Store the old publishing interval */ + UA_Double oldPublishingInterval = sub->publishingInterval; + + /* Change the Subscription settings */ + setSubscriptionSettings(server, sub, request->requestedPublishingInterval, + request->requestedLifetimeCount, request->requestedMaxKeepAliveCount, + request->maxNotificationsPerPublish, request->priority); + + /* Reset the subscription lifetime */ + sub->currentLifetimeCount = 0; + + /* Change the repeated callback to the new interval. This cannot fail as the + * CallbackId must exist. */ + if(sub->publishCallbackId > 0 && + sub->publishingInterval != oldPublishingInterval) + changeRepeatedCallbackInterval(server, sub->publishCallbackId, sub->publishingInterval); + + /* Set the response */ + response->revisedPublishingInterval = sub->publishingInterval; + response->revisedLifetimeCount = sub->lifeTimeCount; + response->revisedMaxKeepAliveCount = sub->maxKeepAliveCount; +} + +static void +Operation_SetPublishingMode(UA_Server *server, UA_Session *session, + const UA_Boolean *publishingEnabled, const UA_UInt32 *subscriptionId, + UA_StatusCode *result) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_Subscription *sub = UA_Session_getSubscriptionById(session, *subscriptionId); + if(!sub) { + *result = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + sub->currentLifetimeCount = 0; /* Reset the subscription lifetime */ + sub->publishingEnabled = *publishingEnabled; /* Set the publishing mode */ +} + +void +Service_SetPublishingMode(UA_Server *server, UA_Session *session, + const UA_SetPublishingModeRequest *request, + UA_SetPublishingModeResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing SetPublishingModeRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_Boolean publishingEnabled = request->publishingEnabled; /* request is const */ + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, (UA_ServiceOperation)Operation_SetPublishingMode, + &publishingEnabled, + &request->subscriptionIdsSize, &UA_TYPES[UA_TYPES_UINT32], + &response->resultsSize, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +void +Service_Publish(UA_Server *server, UA_Session *session, + const UA_PublishRequest *request, UA_UInt32 requestId) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing PublishRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Return an error if the session has no subscription */ + if(TAILQ_EMPTY(&session->subscriptions)) { + sendServiceFault(session->header.channel, requestId, request->requestHeader.requestHandle, + &UA_TYPES[UA_TYPES_PUBLISHRESPONSE], UA_STATUSCODE_BADNOSUBSCRIPTION); + return; + } + + /* Handle too many subscriptions to free resources before trying to allocate + * resources for the new publish request. If the limit has been reached the + * oldest publish request shall be responded */ + if((server->config.maxPublishReqPerSession != 0) && + (session->numPublishReq >= server->config.maxPublishReqPerSession)) { + if(!UA_Session_reachedPublishReqLimit(server, session)) { + sendServiceFault(session->header.channel, requestId, request->requestHeader.requestHandle, + &UA_TYPES[UA_TYPES_PUBLISHRESPONSE], UA_STATUSCODE_BADINTERNALERROR); + return; + } + } + + /* Allocate the response to store it in the retransmission queue */ + UA_PublishResponseEntry *entry = (UA_PublishResponseEntry *) + UA_malloc(sizeof(UA_PublishResponseEntry)); + if(!entry) { + sendServiceFault(session->header.channel, requestId, request->requestHeader.requestHandle, + &UA_TYPES[UA_TYPES_PUBLISHRESPONSE], UA_STATUSCODE_BADOUTOFMEMORY); + return; + } + + /* Prepare the response */ + entry->requestId = requestId; + UA_PublishResponse *response = &entry->response; + UA_PublishResponse_init(response); + response->responseHeader.requestHandle = request->requestHeader.requestHandle; + + /* Allocate the results array to acknowledge the acknowledge */ + if(request->subscriptionAcknowledgementsSize > 0) { + response->results = (UA_StatusCode *) + UA_Array_new(request->subscriptionAcknowledgementsSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); + if(!response->results) { + UA_free(entry); + sendServiceFault(session->header.channel, requestId, request->requestHeader.requestHandle, + &UA_TYPES[UA_TYPES_PUBLISHRESPONSE], UA_STATUSCODE_BADOUTOFMEMORY); + return; + } + response->resultsSize = request->subscriptionAcknowledgementsSize; + } + + /* Delete Acknowledged Subscription Messages */ + for(size_t i = 0; i < request->subscriptionAcknowledgementsSize; ++i) { + UA_SubscriptionAcknowledgement *ack = &request->subscriptionAcknowledgements[i]; + UA_Subscription *sub = UA_Session_getSubscriptionById(session, ack->subscriptionId); + if(!sub) { + response->results[i] = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Cannot process acknowledgements subscription %u" PRIu32, + ack->subscriptionId); + continue; + } + /* Remove the acked transmission from the retransmission queue */ + response->results[i] = UA_Subscription_removeRetransmissionMessage(sub, ack->sequenceNumber); + } + + /* Queue the publish response. It will be dequeued in a repeated publish + * callback. This can also be triggered right now for a late + * subscription. */ + UA_Session_queuePublishReq(session, entry, false); + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Queued a publication message"); + + /* If there are late subscriptions, the new publish request is used to + * answer them immediately. However, a single subscription that generates + * many notifications must not "starve" other late subscriptions. Hence we + * move it to the end of the queue when a response was sent. */ + UA_Subscription *late = NULL; + TAILQ_FOREACH(late, &session->subscriptions, sessionListEntry) { + if(late->state != UA_SUBSCRIPTIONSTATE_LATE) + continue; + + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, late, + "Send PublishResponse on a late subscription"); + UA_Subscription_publish(server, late); + /* If the subscription was not detached from the session during publish, + * enqueue at the end */ + if(late->session) { + TAILQ_REMOVE(&session->subscriptions, late, sessionListEntry); + TAILQ_INSERT_TAIL(&session->subscriptions, late, sessionListEntry); + } + break; + } +} + +static void +Operation_DeleteSubscription(UA_Server *server, UA_Session *session, void *_, + const UA_UInt32 *subscriptionId, UA_StatusCode *result) { + UA_Subscription *sub = UA_Session_getSubscriptionById(session, *subscriptionId); + if(!sub) { + *result = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Deleting Subscription with Id %" PRIu32 " failed with error code %s", + *subscriptionId, UA_StatusCode_name(*result)); + return; + } + + UA_Subscription_delete(server, sub); + *result = UA_STATUSCODE_GOOD; + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Subscription %" PRIu32 " | Subscription deleted", + *subscriptionId); +} + +void +Service_DeleteSubscriptions(UA_Server *server, UA_Session *session, + const UA_DeleteSubscriptionsRequest *request, + UA_DeleteSubscriptionsResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing DeleteSubscriptionsRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_DeleteSubscription, NULL, + &request->subscriptionIdsSize, &UA_TYPES[UA_TYPES_UINT32], + &response->resultsSize, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +void +Service_Republish(UA_Server *server, UA_Session *session, + const UA_RepublishRequest *request, + UA_RepublishResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing RepublishRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Get the subscription */ + UA_Subscription *sub = UA_Session_getSubscriptionById(session, request->subscriptionId); + if(!sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + /* Reset the subscription lifetime */ + sub->currentLifetimeCount = 0; + + /* Find the notification in the retransmission queue */ + UA_NotificationMessageEntry *entry; + TAILQ_FOREACH(entry, &sub->retransmissionQueue, listEntry) { + if(entry->message.sequenceNumber == request->retransmitSequenceNumber) + break; + } + if(!entry) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADMESSAGENOTAVAILABLE; + return; + } + + response->responseHeader.serviceResult = + UA_NotificationMessage_copy(&entry->message, &response->notificationMessage); +} + +static UA_StatusCode +setTransferredSequenceNumbers(const UA_Subscription *sub, UA_TransferResult *result) { + /* Allocate memory */ + result->availableSequenceNumbers = (UA_UInt32*) + UA_Array_new(sub->retransmissionQueueSize, &UA_TYPES[UA_TYPES_UINT32]); + if(!result->availableSequenceNumbers) + return UA_STATUSCODE_BADOUTOFMEMORY; + result->availableSequenceNumbersSize = sub->retransmissionQueueSize; + + /* Copy over the sequence numbers */ + UA_NotificationMessageEntry *entry; + size_t i = 0; + TAILQ_FOREACH(entry, &sub->retransmissionQueue, listEntry) { + result->availableSequenceNumbers[i] = entry->message.sequenceNumber; + i++; + } + + UA_assert(i == result->availableSequenceNumbersSize); + + return UA_STATUSCODE_GOOD; +} + +static void +Operation_TransferSubscription(UA_Server *server, UA_Session *session, + const UA_Boolean *sendInitialValues, + const UA_UInt32 *subscriptionId, + UA_TransferResult *result) { + /* Get the subscription. This requires a server-wide lookup instead of the + * usual session-wide lookup. */ + UA_Subscription *sub = UA_Server_getSubscriptionById(server, *subscriptionId); + if(!sub) { + result->statusCode = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + /* Is this the same session? Return the sequence numbers and do nothing else. */ + UA_Session *oldSession = sub->session; + if(oldSession == session) { + result->statusCode = setTransferredSequenceNumbers(sub, result); + return; + } + + /* Check with AccessControl if the transfer is allowed */ + if(!server->config.accessControl.allowTransferSubscription || + !server->config.accessControl. + allowTransferSubscription(server, &server->config.accessControl, + oldSession ? &oldSession->sessionId : NULL, + oldSession ? oldSession->sessionHandle : NULL, + &session->sessionId, session->sessionHandle)) { + result->statusCode = UA_STATUSCODE_BADUSERACCESSDENIED; + return; + } + + /* Check limits for the number of subscriptions for this Session */ + if((server->config.maxSubscriptionsPerSession != 0) && + (session->subscriptionsSize >= server->config.maxSubscriptionsPerSession)) { + result->statusCode = UA_STATUSCODE_BADTOOMANYSUBSCRIPTIONS; + return; + } + + /* Allocate memory for the new subscription */ + UA_Subscription *newSub = (UA_Subscription*)UA_malloc(sizeof(UA_Subscription)); + if(!newSub) { + result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + /* Set the available sequence numbers */ + result->statusCode = setTransferredSequenceNumbers(sub, result); + if(result->statusCode != UA_STATUSCODE_GOOD) { + UA_free(newSub); + return; + } + + /* Create an identical copy of the Subscription struct. The original + * subscription remains in place until a StatusChange notification has been + * sent. The elements for lists and queues are moved over manually to ensure + * that all backpointers are set correctly. */ + memcpy(newSub, sub, sizeof(UA_Subscription)); + + /* Register cyclic publish callback */ + result->statusCode = Subscription_registerPublishCallback(server, newSub); + if(result->statusCode != UA_STATUSCODE_GOOD) { + UA_Array_delete(result->availableSequenceNumbers, + sub->retransmissionQueueSize, &UA_TYPES[UA_TYPES_UINT32]); + result->availableSequenceNumbers = NULL; + result->availableSequenceNumbersSize = 0; + UA_free(newSub); + return; + } + + /* <-- The point of no return --> */ + + /* Move over the MonitoredItems and adjust the backpointers */ + LIST_INIT(&newSub->monitoredItems); + UA_MonitoredItem *mon, *mon_tmp; + LIST_FOREACH_SAFE(mon, &sub->monitoredItems, listEntry, mon_tmp) { + LIST_REMOVE(mon, listEntry); + mon->subscription = newSub; + LIST_INSERT_HEAD(&newSub->monitoredItems, mon, listEntry); + } + sub->monitoredItemsSize = 0; + + /* Move over the notification queue */ + TAILQ_INIT(&newSub->notificationQueue); + UA_Notification *nn; + TAILQ_FOREACH(nn, &sub->notificationQueue, globalEntry) { + TAILQ_REMOVE(&sub->notificationQueue, nn, globalEntry); + TAILQ_INSERT_TAIL(&newSub->notificationQueue, nn, globalEntry); + } + sub->notificationQueueSize = 0; + sub->dataChangeNotifications = 0; + sub->eventNotifications = 0; + sub->readyNotifications = 0; + + TAILQ_INIT(&newSub->retransmissionQueue); + UA_NotificationMessageEntry *nme, *nme_tmp; + TAILQ_FOREACH_SAFE(nme, &sub->retransmissionQueue, listEntry, nme_tmp) { + TAILQ_REMOVE(&sub->retransmissionQueue, nme, listEntry); + TAILQ_INSERT_TAIL(&newSub->retransmissionQueue, nme, listEntry); + if(oldSession) + oldSession->totalRetransmissionQueueSize -= 1; + sub->retransmissionQueueSize -= 1; + } + UA_assert(sub->retransmissionQueueSize == 0); + sub->retransmissionQueueSize = 0; + + /* Add to the server */ + UA_assert(newSub->subscriptionId == sub->subscriptionId); + LIST_INSERT_HEAD(&server->subscriptions, newSub, serverListEntry); + server->subscriptionsSize++; + + /* Attach to the session */ + UA_Session_attachSubscription(session, newSub); + + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, newSub, "Transferred to this Session"); + + /* Set StatusChange in the original subscription and force publish. This + * also removes the Subscription, even if there was no PublishResponse + * queued to send a StatusChangeNotification. */ + sub->statusChange = UA_STATUSCODE_GOODSUBSCRIPTIONTRANSFERRED; + UA_Subscription_publish(server, sub); + UA_assert(sub->publishCallbackId == 0); + + /* Create notifications with the current values */ + if(*sendInitialValues) { + LIST_FOREACH(mon, &newSub->monitoredItems, listEntry) { + + /* Create only DataChange notifications */ + if(mon->itemToMonitor.attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER) + continue; + + /* Only if the mode is monitoring */ + if(mon->monitoringMode != UA_MONITORINGMODE_REPORTING) + continue; + + /* If a value is queued for a data MonitoredItem, the next value in + * the queue is sent in the Publish response. */ + if(mon->queueSize > 0) + continue; + + /* Create a notification with the last sampled value */ + UA_MonitoredItem_createDataChangeNotification(server, newSub, mon, + &mon->lastValue); + } + } + + /* Immediately try to publish. If the notification was late, include the new + * sample in the "ready-list" and don't wait until the next cyclic + * timeout. */ + newSub->readyNotifications = newSub->notificationQueueSize; + UA_Subscription_publish(server, newSub); +} + +void Service_TransferSubscriptions(UA_Server *server, UA_Session *session, + const UA_TransferSubscriptionsRequest *request, + UA_TransferSubscriptionsResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing TransferSubscriptionsRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_TransferSubscription, + &request->sendInitialValues, + &request->subscriptionIdsSize, &UA_TYPES[UA_TYPES_UINT32], + &response->resultsSize, &UA_TYPES[UA_TYPES_TRANSFERRESULT]); +} + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +/**** amalgamated original file "/src/server/ua_services_monitoreditem.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2016-2017 (c) Florian Palm + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Ari Breitkreuz, fortiss GmbH + * Copyright 2017 (c) Mattias Bornhager + * Copyright 2017 (c) Henrik Norrman + * Copyright 2017-2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2018 (c) Fabian Arndt, Root-Core + * Copyright 2020 (c) Kalycito Infotech Private Limited + * Copyright 2021 (c) Uranik, Berisha + * Copyright 2021 (c) Ammar, Morshed + * Copyright 2021 (c) Fraunhofer IOSB (Author: Andreas Ebner) + */ + + +#ifdef UA_ENABLE_SUBSCRIPTIONS /* conditional compilation */ + +#ifdef UA_ENABLE_DA + +/* Translate a percentage deadband into an absolute deadband based on the + * UARange property of the variable */ +static UA_StatusCode +setAbsoluteFromPercentageDeadband(UA_Server *server, UA_Session *session, + const UA_MonitoredItem *mon, UA_DataChangeFilter *filter) { + /* A valid deadband? */ + if(filter->deadbandValue < 0.0 || filter->deadbandValue > 100.0) + return UA_STATUSCODE_BADDEADBANDFILTERINVALID; + + /* Browse for the percent range */ + UA_QualifiedName qn = UA_QUALIFIEDNAME(0, "EURange"); + UA_BrowsePathResult bpr = + browseSimplifiedBrowsePath(server, mon->itemToMonitor.nodeId, 1, &qn); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + UA_BrowsePathResult_clear(&bpr); + return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED; + } + + /* Read the range */ + UA_ReadValueId rvi; + UA_ReadValueId_init(&rvi); + rvi.nodeId = bpr.targets->targetId.nodeId; + rvi.attributeId = UA_ATTRIBUTEID_VALUE; + UA_DataValue rangeVal = UA_Server_readWithSession(server, session, &rvi, + UA_TIMESTAMPSTORETURN_NEITHER); + UA_BrowsePathResult_clear(&bpr); + if(!UA_Variant_isScalar(&rangeVal.value) || + rangeVal.value.type != &UA_TYPES[UA_TYPES_RANGE]) { + UA_DataValue_clear(&rangeVal); + return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED; + } + + /* Compute the abs deadband */ + UA_Range *euRange = (UA_Range*)rangeVal.value.data; + UA_Double absDeadband = (filter->deadbandValue/100.0) * (euRange->high - euRange->low); + + /* EURange invalid or NaN? */ + if(absDeadband < 0.0 || absDeadband != absDeadband) { + UA_DataValue_clear(&rangeVal); + return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED; + } + + /* Adjust the original filter */ + filter->deadbandType = UA_DEADBANDTYPE_ABSOLUTE; + filter->deadbandValue = absDeadband; + return UA_STATUSCODE_GOOD; +} + +#endif /* UA_ENABLE_DA */ + +void +Service_SetTriggering(UA_Server *server, UA_Session *session, + const UA_SetTriggeringRequest *request, + UA_SetTriggeringResponse *response) { + /* Nothing to do? */ + if(request->linksToRemoveSize == 0 && + request->linksToAddSize == 0) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTHINGTODO; + return; + } + + /* Get the Subscription */ + UA_Subscription *sub = UA_Session_getSubscriptionById(session, request->subscriptionId); + if(!sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + /* Get the MonitoredItem */ + UA_MonitoredItem *mon = UA_Subscription_getMonitoredItem(sub, request->triggeringItemId); + if(!mon) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADMONITOREDITEMIDINVALID; + return; + } + + /* Allocate the results arrays */ + if(request->linksToRemoveSize > 0) { + response->removeResults = (UA_StatusCode*) + UA_Array_new(request->linksToRemoveSize, &UA_TYPES[UA_TYPES_STATUSCODE]); + if(!response->removeResults) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + response->removeResultsSize = request->linksToRemoveSize; + } + + if(request->linksToAddSize> 0) { + response->addResults = (UA_StatusCode*) + UA_Array_new(request->linksToAddSize, &UA_TYPES[UA_TYPES_STATUSCODE]); + if(!response->addResults) { + UA_Array_delete(response->removeResults, + request->linksToAddSize, &UA_TYPES[UA_TYPES_STATUSCODE]); + response->removeResults = NULL; + response->removeResultsSize = 0; + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + response->addResultsSize = request->linksToAddSize; + } + + /* Apply the changes */ + for(size_t i = 0; i < request->linksToRemoveSize; i++) + response->removeResults[i] = + UA_MonitoredItem_removeLink(sub, mon, request->linksToRemove[i]); + + for(size_t i = 0; i < request->linksToAddSize; i++) + response->addResults[i] = + UA_MonitoredItem_addLink(sub, mon, request->linksToAdd[i]); +} + +/* Verify and adjust the parameters of a MonitoredItem */ +static UA_StatusCode +checkAdjustMonitoredItemParams(UA_Server *server, UA_Session *session, + const UA_MonitoredItem *mon, + const UA_DataType* valueType, + UA_MonitoringParameters *params) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Check the filter */ + if(mon->itemToMonitor.attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER) { + /* Event MonitoredItems need a filter */ +#ifndef UA_ENABLE_SUBSCRIPTIONS_EVENTS + return UA_STATUSCODE_BADNOTSUPPORTED; +#else + if(params->filter.encoding != UA_EXTENSIONOBJECT_DECODED && + params->filter.encoding != UA_EXTENSIONOBJECT_DECODED_NODELETE) + return UA_STATUSCODE_BADEVENTFILTERINVALID; + if(params->filter.content.decoded.type != &UA_TYPES[UA_TYPES_EVENTFILTER]) + return UA_STATUSCODE_BADEVENTFILTERINVALID; +#endif + } else { + /* DataChange MonitoredItem. Can be "no filter" which defaults to + * triggering on Status and Value. */ + if(params->filter.encoding != UA_EXTENSIONOBJECT_DECODED && + params->filter.encoding != UA_EXTENSIONOBJECT_DECODED_NODELETE && + params->filter.encoding != UA_EXTENSIONOBJECT_ENCODED_NOBODY) + return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED; + + /* If the filter ExtensionObject has a body, then it must be a + * DataChangeFilter */ + if(params->filter.encoding != UA_EXTENSIONOBJECT_ENCODED_NOBODY && + params->filter.content.decoded.type != &UA_TYPES[UA_TYPES_DATACHANGEFILTER]) + return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED; + + /* Check the deadband and adjust if necessary. */ + if(params->filter.content.decoded.type == &UA_TYPES[UA_TYPES_DATACHANGEFILTER]) { + UA_DataChangeFilter *filter = (UA_DataChangeFilter *) + params->filter.content.decoded.data; + switch(filter->deadbandType) { + case UA_DEADBANDTYPE_NONE: + break; + case UA_DEADBANDTYPE_ABSOLUTE: + if(mon->itemToMonitor.attributeId != UA_ATTRIBUTEID_VALUE || + !valueType || !UA_DataType_isNumeric(valueType)) + return UA_STATUSCODE_BADFILTERNOTALLOWED; + break; +#ifdef UA_ENABLE_DA + case UA_DEADBANDTYPE_PERCENT: { + if(mon->itemToMonitor.attributeId != UA_ATTRIBUTEID_VALUE || + !valueType || !UA_DataType_isNumeric(valueType)) + return UA_STATUSCODE_BADFILTERNOTALLOWED; + /* If percentage deadband is supported, look up the range values + * and precompute as if it was an absolute deadband. */ + UA_StatusCode res = + setAbsoluteFromPercentageDeadband(server, session, mon, filter); + if(res != UA_STATUSCODE_GOOD) + return res; + break; + } +#endif + default: + return UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED; + } + } + } + + /* Read the minimum sampling interval for the variable. The sampling + * interval of the MonitoredItem must not be less than that. */ + if(mon->itemToMonitor.attributeId == UA_ATTRIBUTEID_VALUE) { + const UA_Node *node = UA_NODESTORE_GET(server, &mon->itemToMonitor.nodeId); + if(node) { + const UA_VariableNode *vn = &node->variableNode; + if(node->head.nodeClass == UA_NODECLASS_VARIABLE && + params->samplingInterval < vn->minimumSamplingInterval) + params->samplingInterval = vn->minimumSamplingInterval; + UA_NODESTORE_RELEASE(server, node); + } + } + + /* Adjust to sampling interval to lie within the limits */ + if(params->samplingInterval <= 0.0) { + /* A sampling interval of zero is possible and indicates that the + * MonitoredItem is checked for every write operation */ + params->samplingInterval = 0.0; + } else { + UA_BOUNDEDVALUE_SETWBOUNDS(server->config.samplingIntervalLimits, + params->samplingInterval, params->samplingInterval); + /* Check for NaN */ + if(mon->parameters.samplingInterval != mon->parameters.samplingInterval) + params->samplingInterval = server->config.samplingIntervalLimits.min; + } + + /* Adjust the maximum queue size */ +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + if(mon->itemToMonitor.attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER) { + /* 0 => Set to the configured maximum. Otherwise adjust with configured limits */ + if(params->queueSize == 0) { + params->queueSize = server->config.queueSizeLimits.max; + } else { + UA_BOUNDEDVALUE_SETWBOUNDS(server->config.queueSizeLimits, + params->queueSize, params->queueSize); + } + } else +#endif + { + /* 0 or 1 => queue-size 1. Otherwise adjust with configured limits */ + if(params->queueSize == 0) + params->queueSize = 1; + if(params->queueSize != 1) + UA_BOUNDEDVALUE_SETWBOUNDS(server->config.queueSizeLimits, + params->queueSize, params->queueSize); + } + + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS +static UA_StatusCode +checkEventFilterParam(UA_Server *server, UA_Session *session, + const UA_MonitoredItem *mon, + UA_MonitoringParameters *params){ + if(mon->itemToMonitor.attributeId != UA_ATTRIBUTEID_EVENTNOTIFIER) + return UA_STATUSCODE_GOOD; + + UA_EventFilter *eventFilter = + (UA_EventFilter *) params->filter.content.decoded.data; + + if(eventFilter == NULL) + return UA_STATUSCODE_BADEVENTFILTERINVALID; + + //TODO make the maximum select clause size param an server-config parameter + if(eventFilter->selectClausesSize > 128) + return UA_STATUSCODE_BADCONFIGURATIONERROR; + + //check the where clause for logical consistency + if(eventFilter->whereClause.elementsSize != 0) { + UA_ContentFilterResult contentFilterResult; + UA_Event_staticWhereClauseValidation(server, &eventFilter->whereClause, + &contentFilterResult); + for(size_t i = 0; i < contentFilterResult.elementResultsSize; ++i) { + if(contentFilterResult.elementResults[i].statusCode != UA_STATUSCODE_GOOD){ + //ToDo currently we return the first non good status code, check if + //we can use the detailed contentFilterResult later + UA_StatusCode whereResult = + contentFilterResult.elementResults[i].statusCode; + UA_ContentFilterResult_clear(&contentFilterResult); + return whereResult; + } + } + } + //check the select clause for logical consistency + UA_StatusCode selectClauseValidationResult[128]; + UA_Event_staticSelectClauseValidation(server,eventFilter, + selectClauseValidationResult); + for(size_t i = 0; i < eventFilter->selectClausesSize; ++i){ + //ToDo currently we return the first non good status code, check if + //we can use the detailed status code list later + if(selectClauseValidationResult[i] != UA_STATUSCODE_GOOD){ + return selectClauseValidationResult[i]; + } + } + + return UA_STATUSCODE_GOOD; +} +#endif + +static const UA_String +binaryEncoding = {sizeof("Default Binary") - 1, (UA_Byte *)"Default Binary"}; + +/* Structure to pass additional arguments into the operation */ +struct createMonContext { + UA_Subscription *sub; + UA_TimestampsToReturn timestampsToReturn; + + /* If sub is NULL, use local callbacks */ + UA_Server_DataChangeNotificationCallback dataChangeCallback; + void *context; +}; + +static void +Operation_CreateMonitoredItem(UA_Server *server, UA_Session *session, + struct createMonContext *cmc, + const UA_MonitoredItemCreateRequest *request, + UA_MonitoredItemCreateResult *result) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Check available capacity */ + if(cmc->sub && + (((server->config.maxMonitoredItems != 0) && + (server->monitoredItemsSize >= server->config.maxMonitoredItems)) || + ((server->config.maxMonitoredItemsPerSubscription != 0) && + (cmc->sub->monitoredItemsSize >= server->config.maxMonitoredItemsPerSubscription)))) { + result->statusCode = UA_STATUSCODE_BADTOOMANYMONITOREDITEMS; + return; + } + + /* Check if the encoding is supported */ + if(request->itemToMonitor.dataEncoding.name.length > 0 && + (!UA_String_equal(&binaryEncoding, &request->itemToMonitor.dataEncoding.name) || + request->itemToMonitor.dataEncoding.namespaceIndex != 0)) { + result->statusCode = UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED; + return; + } + + /* Check if the encoding is set for a value */ + if(request->itemToMonitor.attributeId != UA_ATTRIBUTEID_VALUE && + request->itemToMonitor.dataEncoding.name.length > 0) { + result->statusCode = UA_STATUSCODE_BADDATAENCODINGINVALID; + return; + } + + /* Make an example read to check the itemToMonitor. The DataSource itself + * could return a (temporary) error. This should still result in a valid + * MonitoredItem. Only a few StatusCodes are considered unrecoverable and + * lead to an abort: + * - The Node does not exist + * - The AttributeId does not match the NodeClass + * - The Session does not have sufficient access rights + * - The indicated encoding is not supported or not valid */ + UA_DataValue v = UA_Server_readWithSession(server, session, &request->itemToMonitor, + cmc->timestampsToReturn); + if(v.hasStatus && + (v.status == UA_STATUSCODE_BADNODEIDUNKNOWN || + v.status == UA_STATUSCODE_BADATTRIBUTEIDINVALID || + v.status == UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED || + v.status == UA_STATUSCODE_BADDATAENCODINGINVALID || + v.status == UA_STATUSCODE_BADINDEXRANGEINVALID + /* Part 4, 5.12.2 CreateMonitoredItems: When a user adds a monitored + * item that the user is denied read access to, the add operation for + * the item shall succeed and the bad status Bad_NotReadable or + * Bad_UserAccessDenied shall be returned in the Publish response. + * v.status == UA_STATUSCODE_BADNOTREADABLE + * v.status == UA_STATUSCODE_BADUSERACCESSDENIED + * + * The IndexRange error can change depending on the value. + * v.status == UA_STATUSCODE_BADINDEXRANGENODATA */ + )) { + result->statusCode = v.status; + UA_DataValue_clear(&v); + return; + } + + /* Adding an Event MonitoredItem */ +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + if(request->itemToMonitor.attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER) { + /* TODO: Only remote clients can add Event-MonitoredItems at the moment */ + if(!cmc->sub) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Only remote clients can add Event-MonitoredItems"); + result->statusCode = UA_STATUSCODE_BADNOTSUPPORTED; + UA_DataValue_clear(&v); + return; + } + + /* If the 'SubscribeToEvents' bit of EventNotifier attribute is + * zero, then the object cannot be subscribed to monitor events */ + if(!v.hasValue || !v.value.data) { + result->statusCode = UA_STATUSCODE_BADINTERNALERROR; + UA_DataValue_clear(&v); + return; + } + UA_Byte eventNotifierValue = *((UA_Byte *)v.value.data); + if((eventNotifierValue & 0x01) != 1) { + result->statusCode = UA_STATUSCODE_BADNOTSUPPORTED; + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, cmc->sub, + "Could not create a MonitoredItem as the " + "'SubscribeToEvents' bit of the EventNotifier " + "attribute is not set"); + UA_DataValue_clear(&v); + return; + } + } +#endif + + const UA_DataType *valueType = v.value.type; + UA_DataValue_clear(&v); + + /* Allocate the MonitoredItem */ + UA_MonitoredItem *newMon = NULL; + if(cmc->sub) { + newMon = (UA_MonitoredItem*)UA_malloc(sizeof(UA_MonitoredItem)); + } else { + UA_LocalMonitoredItem *localMon = (UA_LocalMonitoredItem*) + UA_malloc(sizeof(UA_LocalMonitoredItem)); + if(localMon) { + /* Set special values only for the LocalMonitoredItem */ + localMon->context = cmc->context; + localMon->callback.dataChangeCallback = cmc->dataChangeCallback; + } + newMon = &localMon->monitoredItem; + } + if(!newMon) { + result->statusCode = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + + /* Initialize the MonitoredItem */ + UA_MonitoredItem_init(newMon); + newMon->subscription = cmc->sub; /* Can be NULL for local MonitoredItems */ + newMon->timestampsToReturn = cmc->timestampsToReturn; + result->statusCode |= UA_ReadValueId_copy(&request->itemToMonitor, + &newMon->itemToMonitor); + result->statusCode |= UA_MonitoringParameters_copy(&request->requestedParameters, + &newMon->parameters); + result->statusCode |= checkAdjustMonitoredItemParams(server, session, newMon, + valueType, &newMon->parameters); +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + result->statusCode |= checkEventFilterParam(server, session, newMon, + &newMon->parameters); +#endif + if(result->statusCode != UA_STATUSCODE_GOOD) { + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, cmc->sub, + "Could not create a MonitoredItem " + "with StatusCode %s", + UA_StatusCode_name(result->statusCode)); + UA_MonitoredItem_delete(server, newMon); + return; + } + + /* Register the Monitoreditem in the server and subscription */ + UA_Server_registerMonitoredItem(server, newMon); + + /* Activate the MonitoredItem */ + result->statusCode |= + UA_MonitoredItem_setMonitoringMode(server, newMon, request->monitoringMode); + if(result->statusCode != UA_STATUSCODE_GOOD) { + UA_MonitoredItem_delete(server, newMon); + return; + } + + /* Prepare the response */ + result->revisedSamplingInterval = newMon->parameters.samplingInterval; + result->revisedQueueSize = newMon->parameters.queueSize; + result->monitoredItemId = newMon->monitoredItemId; + + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, cmc->sub, + "MonitoredItem %" PRIi32 " | " + "Created the MonitoredItem " + "(Sampling Interval: %fms, Queue Size: %lu)", + newMon->monitoredItemId, + newMon->parameters.samplingInterval, + (unsigned long)newMon->queueSize); +} + +void +Service_CreateMonitoredItems(UA_Server *server, UA_Session *session, + const UA_CreateMonitoredItemsRequest *request, + UA_CreateMonitoredItemsResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing CreateMonitoredItemsRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxMonitoredItemsPerCall != 0 && + request->itemsToCreateSize > server->config.maxMonitoredItemsPerCall) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + /* Check if the timestampstoreturn is valid */ + struct createMonContext cmc; + cmc.timestampsToReturn = request->timestampsToReturn; + if(cmc.timestampsToReturn > UA_TIMESTAMPSTORETURN_NEITHER) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID; + return; + } + + /* Find the subscription */ + cmc.sub = UA_Session_getSubscriptionById(session, request->subscriptionId); + if(!cmc.sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + /* Reset the subscription lifetime */ + cmc.sub->currentLifetimeCount = 0; + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_CreateMonitoredItem, + &cmc, &request->itemsToCreateSize, + &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST], + &response->resultsSize, + &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]); +} + +UA_MonitoredItemCreateResult +UA_Server_createDataChangeMonitoredItem(UA_Server *server, + UA_TimestampsToReturn timestampsToReturn, + const UA_MonitoredItemCreateRequest item, + void *monitoredItemContext, + UA_Server_DataChangeNotificationCallback callback) { + struct createMonContext cmc; + cmc.sub = NULL; + cmc.context = monitoredItemContext; + cmc.dataChangeCallback = callback; + cmc.timestampsToReturn = timestampsToReturn; + + UA_MonitoredItemCreateResult result; + UA_MonitoredItemCreateResult_init(&result); + UA_LOCK(&server->serviceMutex); + Operation_CreateMonitoredItem(server, &server->adminSession, &cmc, &item, &result); + UA_UNLOCK(&server->serviceMutex); + return result; +} + +static void +Operation_ModifyMonitoredItem(UA_Server *server, UA_Session *session, UA_Subscription *sub, + const UA_MonitoredItemModifyRequest *request, + UA_MonitoredItemModifyResult *result) { + /* Get the MonitoredItem */ + UA_MonitoredItem *mon = UA_Subscription_getMonitoredItem(sub, request->monitoredItemId); + if(!mon) { + result->statusCode = UA_STATUSCODE_BADMONITOREDITEMIDINVALID; + return; + } + + /* Make local copy of the settings */ + UA_MonitoringParameters params; + result->statusCode = + UA_MonitoringParameters_copy(&request->requestedParameters, ¶ms); + if(result->statusCode != UA_STATUSCODE_GOOD) + return; + + /* Read the current value to test if filters are possible. + * Can return an empty value (v.value.type == NULL). */ + UA_DataValue v = + UA_Server_readWithSession(server, session, &mon->itemToMonitor, + mon->timestampsToReturn); + + /* Verify and adjust the new parameters. This still leaves the original + * MonitoredItem untouched. */ + result->statusCode = + checkAdjustMonitoredItemParams(server, session, mon, + v.value.type, ¶ms); + UA_DataValue_clear(&v); + if(result->statusCode != UA_STATUSCODE_GOOD) { + UA_MonitoringParameters_clear(¶ms); + return; + } + + /* Store the old sampling interval */ + UA_Double oldSamplingInterval = mon->parameters.samplingInterval; + + /* Move over the new settings */ + UA_MonitoringParameters_clear(&mon->parameters); + mon->parameters = params; + + /* Re-register the callback if necessary */ + if(oldSamplingInterval != mon->parameters.samplingInterval) { + UA_MonitoredItem_unregisterSampling(server, mon); + result->statusCode = + UA_MonitoredItem_setMonitoringMode(server, mon, mon->monitoringMode); + } + + result->revisedSamplingInterval = mon->parameters.samplingInterval; + result->revisedQueueSize = mon->parameters.queueSize; + + /* Remove some notifications if the queue is now too small */ + UA_MonitoredItem_ensureQueueSpace(server, mon); + + /* Remove the overflow bits if the queue has now a size of 1 */ + UA_MonitoredItem_removeOverflowInfoBits(mon); + + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %" PRIi32 " | " + "Modified the MonitoredItem " + "(Sampling Interval: %fms, Queue Size: %lu)", + mon->monitoredItemId, + mon->parameters.samplingInterval, + (unsigned long)mon->queueSize); +} + +void +Service_ModifyMonitoredItems(UA_Server *server, UA_Session *session, + const UA_ModifyMonitoredItemsRequest *request, + UA_ModifyMonitoredItemsResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing ModifyMonitoredItemsRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxMonitoredItemsPerCall != 0 && + request->itemsToModifySize > server->config.maxMonitoredItemsPerCall) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + /* Check if the timestampstoreturn is valid */ + if(request->timestampsToReturn > UA_TIMESTAMPSTORETURN_NEITHER) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID; + return; + } + + /* Get the subscription */ + UA_Subscription *sub = UA_Session_getSubscriptionById(session, request->subscriptionId); + if(!sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + sub->currentLifetimeCount = 0; /* Reset the subscription lifetime */ + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_ModifyMonitoredItem, + sub, &request->itemsToModifySize, + &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST], + &response->resultsSize, + &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]); +} + +struct setMonitoringContext { + UA_Subscription *sub; + UA_MonitoringMode monitoringMode; +}; + +static void +Operation_SetMonitoringMode(UA_Server *server, UA_Session *session, + struct setMonitoringContext *smc, + const UA_UInt32 *monitoredItemId, UA_StatusCode *result) { + UA_MonitoredItem *mon = UA_Subscription_getMonitoredItem(smc->sub, *monitoredItemId); + if(!mon) { + *result = UA_STATUSCODE_BADMONITOREDITEMIDINVALID; + return; + } + *result = UA_MonitoredItem_setMonitoringMode(server, mon, smc->monitoringMode); +} + +void +Service_SetMonitoringMode(UA_Server *server, UA_Session *session, + const UA_SetMonitoringModeRequest *request, + UA_SetMonitoringModeResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing SetMonitoringMode"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxMonitoredItemsPerCall != 0 && + request->monitoredItemIdsSize > server->config.maxMonitoredItemsPerCall) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + /* Get the subscription */ + struct setMonitoringContext smc; + smc.sub = UA_Session_getSubscriptionById(session, request->subscriptionId); + if(!smc.sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + smc.sub->currentLifetimeCount = 0; /* Reset the subscription lifetime */ + + smc.monitoringMode = request->monitoringMode; + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_SetMonitoringMode, + &smc, &request->monitoredItemIdsSize, + &UA_TYPES[UA_TYPES_UINT32], + &response->resultsSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +static void +Operation_DeleteMonitoredItem(UA_Server *server, UA_Session *session, UA_Subscription *sub, + const UA_UInt32 *monitoredItemId, UA_StatusCode *result) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_MonitoredItem *mon = UA_Subscription_getMonitoredItem(sub, *monitoredItemId); + if(!mon) { + *result = UA_STATUSCODE_BADMONITOREDITEMIDINVALID; + return; + } + UA_MonitoredItem_delete(server, mon); +} + +void +Service_DeleteMonitoredItems(UA_Server *server, UA_Session *session, + const UA_DeleteMonitoredItemsRequest *request, + UA_DeleteMonitoredItemsResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing DeleteMonitoredItemsRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxMonitoredItemsPerCall != 0 && + request->monitoredItemIdsSize > server->config.maxMonitoredItemsPerCall) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + /* Get the subscription */ + UA_Subscription *sub = UA_Session_getSubscriptionById(session, request->subscriptionId); + if(!sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + /* Reset the subscription lifetime */ + sub->currentLifetimeCount = 0; + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_DeleteMonitoredItem, + sub, &request->monitoredItemIdsSize, + &UA_TYPES[UA_TYPES_UINT32], + &response->resultsSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +UA_StatusCode +UA_Server_deleteMonitoredItem(UA_Server *server, UA_UInt32 monitoredItemId) { + UA_LOCK(&server->serviceMutex); + UA_MonitoredItem *mon, *mon_tmp; + LIST_FOREACH_SAFE(mon, &server->localMonitoredItems, listEntry, mon_tmp) { + if(mon->monitoredItemId != monitoredItemId) + continue; + UA_MonitoredItem_delete(server, mon); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_GOOD; + } + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADMONITOREDITEMIDINVALID; +} + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +/**** amalgamated original file "/src/server/ua_services_securechannel.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014, 2017 (c) Florian Palm + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + */ + + +#ifndef container_of +#define container_of(ptr, type, member) \ + (type *)((uintptr_t)ptr - offsetof(type,member)) +#endif + +static void +removeSecureChannelCallback(void *_, channel_entry *entry) { + UA_SecureChannel_close(&entry->channel); +} + +/* Half-closes the channel. Will be completely closed / deleted in a deferred + * callback. Deferring is necessary so we don't remove lists that are still + * processed upwards the call stack. */ +static void +removeSecureChannel(UA_Server *server, channel_entry *entry, + UA_DiagnosticEvent event) { + if(entry->channel.state == UA_SECURECHANNELSTATE_CLOSING) + return; + entry->channel.state = UA_SECURECHANNELSTATE_CLOSING; + + /* Detach from the connection and close the connection */ + if(entry->channel.connection) { + if(entry->channel.connection->state != UA_CONNECTIONSTATE_CLOSED) + entry->channel.connection->ua_close(entry->channel.connection); + UA_Connection_detachSecureChannel(entry->channel.connection); + } + + /* Detach the channel */ + TAILQ_REMOVE(&server->channels, entry, pointers); + + /* Update the statistics */ + UA_SecureChannelStatistics *scs = &server->serverStats.scs; + UA_atomic_subSize(&scs->currentChannelCount, 1); + switch(event) { + case UA_DIAGNOSTICEVENT_CLOSE: + break; + case UA_DIAGNOSTICEVENT_TIMEOUT: + UA_atomic_addSize(&scs->channelTimeoutCount, 1); + break; + case UA_DIAGNOSTICEVENT_PURGE: + UA_atomic_addSize(&scs->channelPurgeCount, 1); + break; + case UA_DIAGNOSTICEVENT_REJECT: + case UA_DIAGNOSTICEVENT_SECURITYREJECT: + UA_atomic_addSize(&scs->rejectedChannelCount, 1); + break; + case UA_DIAGNOSTICEVENT_ABORT: + UA_atomic_addSize(&scs->channelAbortCount, 1); + break; + default: + UA_assert(false); + break; + } + + /* Add a delayed callback to remove the channel when the currently + * scheduled jobs have completed */ + entry->cleanupCallback.callback = (UA_ApplicationCallback)removeSecureChannelCallback; + entry->cleanupCallback.application = NULL; + entry->cleanupCallback.data = entry; + entry->cleanupCallback.nextTime = UA_DateTime_nowMonotonic() + 1; + entry->cleanupCallback.interval = 0; /* Remove the structure */ + UA_Timer_addTimerEntry(&server->timer, &entry->cleanupCallback, NULL); +} + +void +UA_Server_deleteSecureChannels(UA_Server *server) { + channel_entry *entry, *temp; + TAILQ_FOREACH_SAFE(entry, &server->channels, pointers, temp) + removeSecureChannel(server, entry, UA_DIAGNOSTICEVENT_CLOSE); +} + +/* remove channels that were not renewed or who have no connection attached */ +void +UA_Server_cleanupTimedOutSecureChannels(UA_Server *server, + UA_DateTime nowMonotonic) { + channel_entry *entry, *temp; + TAILQ_FOREACH_SAFE(entry, &server->channels, pointers, temp) { + /* The channel was closed internally */ + if(entry->channel.state == UA_SECURECHANNELSTATE_CLOSED || + !entry->channel.connection) { + removeSecureChannel(server, entry, UA_DIAGNOSTICEVENT_CLOSE); + continue; + } + + /* Is the SecurityToken already created? */ + if(entry->channel.securityToken.createdAt == 0) { + /* No -> channel is still in progress of being opened, do not remove */ + continue; + } + + /* Has the SecurityToken timed out? */ + UA_DateTime timeout = + entry->channel.securityToken.createdAt + + (UA_DateTime)(entry->channel.securityToken.revisedLifetime * UA_DATETIME_MSEC); + + /* There is a new token. But it has not been used by the client so far. + * Do the rollover now instead of shutting the channel down. + * + * Part 4, 5.5.2 says: Servers shall use the existing SecurityToken to + * secure outgoing Messages until the SecurityToken expires or the + * Server receives a Message secured with a new SecurityToken.*/ + if(timeout < nowMonotonic && + entry->channel.renewState == UA_SECURECHANNELRENEWSTATE_NEWTOKEN_SERVER) { + /* Compare with the rollover in checkSymHeader */ + entry->channel.renewState = UA_SECURECHANNELRENEWSTATE_NORMAL; + entry->channel.securityToken = entry->channel.altSecurityToken; + UA_ChannelSecurityToken_init(&entry->channel.altSecurityToken); + UA_SecureChannel_generateLocalKeys(&entry->channel); + generateRemoteKeys(&entry->channel); + + /* Use the timeout of the new SecurityToken */ + timeout = entry->channel.securityToken.createdAt + + (UA_DateTime)(entry->channel.securityToken.revisedLifetime * UA_DATETIME_MSEC); + } + + if(timeout < nowMonotonic) { + UA_LOG_INFO_CHANNEL(&server->config.logger, &entry->channel, + "SecureChannel has timed out"); + removeSecureChannel(server, entry, UA_DIAGNOSTICEVENT_TIMEOUT); + } + } +} + +/* remove the first channel that has no session attached */ +static UA_Boolean +purgeFirstChannelWithoutSession(UA_Server *server) { + channel_entry *entry; + TAILQ_FOREACH(entry, &server->channels, pointers) { + if(SLIST_FIRST(&entry->channel.sessions)) + continue; + UA_LOG_INFO_CHANNEL(&server->config.logger, &entry->channel, + "Channel was purged since maxSecureChannels was " + "reached and channel had no session attached"); + removeSecureChannel(server, entry, UA_DIAGNOSTICEVENT_PURGE); + return true; + } + return false; +} + +UA_StatusCode +UA_Server_createSecureChannel(UA_Server *server, UA_Connection *connection) { + /* connection already has a channel attached. */ + if(connection->channel != NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Check if there exists a free SC, otherwise try to purge one SC without a + * session the purge has been introduced to pass CTT, it is not clear what + * strategy is expected here */ + if(server->serverStats.scs.currentChannelCount >= server->config.maxSecureChannels && + !purgeFirstChannelWithoutSession(server)) + return UA_STATUSCODE_BADOUTOFMEMORY; + + channel_entry *entry = (channel_entry *)UA_malloc(sizeof(channel_entry)); + if(!entry) + return UA_STATUSCODE_BADOUTOFMEMORY; + + /* Channel state is closed (0) */ + /* TODO: Use the connection config from the correct network layer */ + UA_SecureChannel_init(&entry->channel, &server->config.networkLayers[0].localConnectionConfig); + entry->channel.certificateVerification = &server->config.certificateVerification; + entry->channel.processOPNHeader = UA_Server_configSecureChannel; + + TAILQ_INSERT_TAIL(&server->channels, entry, pointers); + UA_Connection_attachSecureChannel(connection, &entry->channel); + UA_atomic_addSize(&server->serverStats.scs.currentChannelCount, 1); + UA_atomic_addSize(&server->serverStats.scs.cumulatedChannelCount, 1); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_configSecureChannel(void *application, UA_SecureChannel *channel, + const UA_AsymmetricAlgorithmSecurityHeader *asymHeader) { + /* Iterate over available endpoints and choose the correct one */ + UA_SecurityPolicy *securityPolicy = NULL; + UA_Server *const server = (UA_Server *const) application; + for(size_t i = 0; i < server->config.securityPoliciesSize; ++i) { + UA_SecurityPolicy *policy = &server->config.securityPolicies[i]; + if(!UA_ByteString_equal(&asymHeader->securityPolicyUri, &policy->policyUri)) + continue; + + UA_StatusCode retval = policy->asymmetricModule. + compareCertificateThumbprint(policy, &asymHeader->receiverCertificateThumbprint); + if(retval != UA_STATUSCODE_GOOD) + continue; + + /* We found the correct policy (except for security mode). The endpoint + * needs to be selected by the client / server to match the security + * mode in the endpoint for the session. */ + securityPolicy = policy; + break; + } + + if(!securityPolicy) + return UA_STATUSCODE_BADSECURITYPOLICYREJECTED; + + /* Create the channel context and parse the sender (remote) certificate used for the + * secureChannel. */ + UA_StatusCode retval = + UA_SecureChannel_setSecurityPolicy(channel, securityPolicy, + &asymHeader->senderCertificate); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + channel->securityToken.tokenId = server->lastTokenId++; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_SecureChannelManager_open(UA_Server *server, UA_SecureChannel *channel, + const UA_OpenSecureChannelRequest *request, + UA_OpenSecureChannelResponse *response) { + if(channel->state != UA_SECURECHANNELSTATE_ACK_SENT) { + UA_LOG_ERROR_CHANNEL(&server->config.logger, channel, + "Called open on already open or closed channel"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + if(request->securityMode != UA_MESSAGESECURITYMODE_NONE && + UA_ByteString_equal(&channel->securityPolicy->policyUri, &UA_SECURITY_POLICY_NONE_URI)) { + return UA_STATUSCODE_BADSECURITYMODEREJECTED; + } + + channel->securityMode = request->securityMode; + channel->securityToken.channelId = server->lastChannelId++; + channel->securityToken.createdAt = UA_DateTime_nowMonotonic(); + + /* Set the lifetime. Lifetime 0 -> set the maximum possible */ + channel->securityToken.revisedLifetime = + (request->requestedLifetime > server->config.maxSecurityTokenLifetime) ? + server->config.maxSecurityTokenLifetime : request->requestedLifetime; + if(channel->securityToken.revisedLifetime == 0) + channel->securityToken.revisedLifetime = server->config.maxSecurityTokenLifetime; + + UA_StatusCode retval = UA_ByteString_copy(&request->clientNonce, &channel->remoteNonce); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Generate the nonce. The syymmetric encryption keys are generated when the + * first symmetric message is received */ + retval = UA_SecureChannel_generateLocalNonce(channel); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Set the response. The token will be revolved to the new token when the + * first symmetric messages is received. */ + response->securityToken = channel->securityToken; + response->securityToken.createdAt = UA_DateTime_now(); /* Only for sending */ + response->responseHeader.timestamp = response->securityToken.createdAt; + response->responseHeader.requestHandle = request->requestHeader.requestHandle; + retval = UA_ByteString_copy(&channel->localNonce, &response->serverNonce); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* The channel is open */ + channel->state = UA_SECURECHANNELSTATE_OPEN; + + /* For the first revolve */ + channel->renewState = UA_SECURECHANNELRENEWSTATE_NEWTOKEN_SERVER; + channel->altSecurityToken = channel->securityToken; + channel->securityToken.tokenId = 0; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_SecureChannelManager_renew(UA_Server *server, UA_SecureChannel *channel, + const UA_OpenSecureChannelRequest *request, + UA_OpenSecureChannelResponse *response) { + if(channel->state != UA_SECURECHANNELSTATE_OPEN) { + UA_LOG_ERROR_CHANNEL(&server->config.logger, channel, + "Called renew on channel which is not open"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Check whether the nonce was reused */ + if(channel->securityMode != UA_MESSAGESECURITYMODE_NONE && + UA_ByteString_equal(&channel->remoteNonce, &request->clientNonce)) { + UA_LOG_ERROR_CHANNEL(&server->config.logger, channel, + "The client reused the last nonce"); + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + + /* Create a new SecurityToken. Will be switched over when the first message + * is received. */ + channel->altSecurityToken = channel->securityToken; + channel->altSecurityToken.tokenId = server->lastTokenId++; + channel->altSecurityToken.createdAt = UA_DateTime_nowMonotonic(); + channel->altSecurityToken.revisedLifetime = + (request->requestedLifetime > server->config.maxSecurityTokenLifetime) ? + server->config.maxSecurityTokenLifetime : request->requestedLifetime; + if(channel->altSecurityToken.revisedLifetime == 0) /* lifetime 0 -> return the max lifetime */ + channel->altSecurityToken.revisedLifetime = server->config.maxSecurityTokenLifetime; + + /* Replace the nonces */ + UA_ByteString_clear(&channel->remoteNonce); + UA_StatusCode retval = UA_ByteString_copy(&request->clientNonce, &channel->remoteNonce); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + retval = UA_SecureChannel_generateLocalNonce(channel); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Set the response */ + response->securityToken = channel->altSecurityToken; + response->securityToken.createdAt = UA_DateTime_now(); /* Only for sending */ + response->responseHeader.requestHandle = request->requestHeader.requestHandle; + retval = UA_ByteString_copy(&channel->localNonce, &response->serverNonce); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + channel->renewState = UA_SECURECHANNELRENEWSTATE_NEWTOKEN_SERVER; + return UA_STATUSCODE_GOOD; +} + +void +UA_Server_closeSecureChannel(UA_Server *server, UA_SecureChannel *channel, + UA_DiagnosticEvent event) { + removeSecureChannel(server, container_of(channel, channel_entry, channel), event); +} + +void +Service_OpenSecureChannel(UA_Server *server, UA_SecureChannel *channel, + const UA_OpenSecureChannelRequest *request, + UA_OpenSecureChannelResponse *response) { + if(request->requestType == UA_SECURITYTOKENREQUESTTYPE_RENEW) { + /* Renew the channel */ + response->responseHeader.serviceResult = + UA_SecureChannelManager_renew(server, channel, request, response); + + /* Logging */ + if(response->responseHeader.serviceResult == UA_STATUSCODE_GOOD) { + UA_Float lifetime = (UA_Float)response->securityToken.revisedLifetime / 1000; + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, "SecureChannel renewed " + "with a revised lifetime of %.2fs", lifetime); + } else { + UA_LOG_DEBUG_CHANNEL(&server->config.logger, channel, + "Renewing SecureChannel failed"); + } + return; + } + + /* Must be ISSUE or RENEW */ + if(request->requestType != UA_SECURITYTOKENREQUESTTYPE_ISSUE) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR; + return; + } + + /* Open the channel */ + response->responseHeader.serviceResult = + UA_SecureChannelManager_open(server, channel, request, response); + + /* Logging */ + if(response->responseHeader.serviceResult == UA_STATUSCODE_GOOD) { + UA_Float lifetime = (UA_Float)response->securityToken.revisedLifetime / 1000; + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, + "SecureChannel opened with SecurityPolicy %.*s " + "and a revised lifetime of %.2fs", + (int)channel->securityPolicy->policyUri.length, + channel->securityPolicy->policyUri.data, lifetime); + } else { + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, + "Opening a SecureChannel failed"); + } +} + +/* The server does not send a CloseSecureChannel response */ +void +Service_CloseSecureChannel(UA_Server *server, UA_SecureChannel *channel) { + UA_LOG_INFO_CHANNEL(&server->config.logger, channel, "CloseSecureChannel"); + removeSecureChannel(server, container_of(channel, channel_entry, channel), + UA_DIAGNOSTICEVENT_CLOSE); +} + +/**** amalgamated original file "/src/server/ua_services_nodemanagement.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2014-2017 (c) Florian Palm + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Julian Grothoff + * Copyright 2016 (c) LEvertz + * Copyright 2016 (c) Lorenz Haas + * Copyright 2017 (c) frax2222 + * Copyright 2017-2018 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Christian von Arnim + * Copyright 2021 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + * Copyright 2017 (c) Henrik Norrman + * Copyright 2021 (c) Fraunhofer IOSB (Author: Andreas Ebner) + */ + + +static UA_StatusCode +setMethodNode_callback(UA_Server *server, + const UA_NodeId methodNodeId, + UA_MethodCallback methodCallback); + +/*********************/ +/* Edit Node Context */ +/*********************/ + +UA_StatusCode +UA_Server_getNodeContext(UA_Server *server, UA_NodeId nodeId, + void **nodeContext) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = getNodeContext(server, nodeId, nodeContext); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +getNodeContext(UA_Server *server, UA_NodeId nodeId, + void **nodeContext) { + const UA_Node *node = UA_NODESTORE_GET(server, &nodeId); + if(!node) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + *nodeContext = node->head.context; + UA_NODESTORE_RELEASE(server, node); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +setDeconstructedNode(UA_Server *server, UA_Session *session, + UA_NodeHead *head, void *context) { + head->constructed = false; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +setConstructedNodeContext(UA_Server *server, UA_Session *session, + UA_NodeHead *head, void *context) { + head->context = context; + head->constructed = true; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +editNodeContext(UA_Server *server, UA_Session* session, + UA_NodeHead *head, void *context) { + head->context = context; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_setNodeContext(UA_Server *server, UA_NodeId nodeId, + void *nodeContext) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = UA_Server_editNode(server, &server->adminSession, &nodeId, + (UA_EditNodeCallback)editNodeContext, nodeContext); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/**********************/ +/* Consistency Checks */ +/**********************/ + +#define UA_PARENT_REFERENCES_COUNT 2 + +const UA_NodeId parentReferences[UA_PARENT_REFERENCES_COUNT] = { + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASSUBTYPE}}, + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASCOMPONENT}} +}; + +static void +logAddNode(const UA_Logger *logger, UA_Session *session, + const UA_NodeId *nodeId, const char *msg) { + UA_LOG_NODEID_INFO(nodeId, + UA_LOG_INFO_SESSION(logger, session, "AddNode (%.*s): %s", + (int)nodeIdStr.length, nodeIdStr.data, msg)); +} + +/* Check if the requested parent node exists, has the right node class and is + * referenced with an allowed (hierarchical) reference type. For "type" nodes, + * only hasSubType references are allowed. */ +static UA_StatusCode +checkParentReference(UA_Server *server, UA_Session *session, const UA_NodeHead *head, + const UA_NodeId *parentNodeId, const UA_NodeId *referenceTypeId) { + /* Objects do not need a parent (e.g. mandatory/optional modellingrules) */ + /* Also, there are some variables which do not have parents, e.g. EnumStrings, EnumValues */ + if((head->nodeClass == UA_NODECLASS_OBJECT || head->nodeClass == UA_NODECLASS_VARIABLE) && + UA_NodeId_isNull(parentNodeId) && UA_NodeId_isNull(referenceTypeId)) + return UA_STATUSCODE_GOOD; + + /* See if the parent exists */ + const UA_Node *parent = UA_NODESTORE_GET(server, parentNodeId); + if(!parent) { + logAddNode(&server->config.logger, session, &head->nodeId, + "Parent node not found"); + return UA_STATUSCODE_BADPARENTNODEIDINVALID; + } + + UA_NodeClass parentNodeClass = parent->head.nodeClass; + UA_NODESTORE_RELEASE(server, parent); + + /* Check the referencetype exists */ + const UA_Node *referenceType = UA_NODESTORE_GET(server, referenceTypeId); + if(!referenceType) { + logAddNode(&server->config.logger, session, &head->nodeId, + "Reference type to the parent not found"); + return UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + } + + /* Check if the referencetype is a reference type node */ + if(referenceType->head.nodeClass != UA_NODECLASS_REFERENCETYPE) { + logAddNode(&server->config.logger, session, &head->nodeId, + "Reference type to the parent is not a ReferenceTypeNode"); + UA_NODESTORE_RELEASE(server, referenceType); + return UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + } + + /* Check that the reference type is not abstract */ + UA_Boolean referenceTypeIsAbstract = referenceType->referenceTypeNode.isAbstract; + UA_NODESTORE_RELEASE(server, referenceType); + if(referenceTypeIsAbstract == true) { + logAddNode(&server->config.logger, session, &head->nodeId, + "Abstract reference type to the parent not allowed"); + return UA_STATUSCODE_BADREFERENCENOTALLOWED; + } + + /* Check hassubtype relation for type nodes */ + if(head->nodeClass == UA_NODECLASS_DATATYPE || + head->nodeClass == UA_NODECLASS_VARIABLETYPE || + head->nodeClass == UA_NODECLASS_OBJECTTYPE || + head->nodeClass == UA_NODECLASS_REFERENCETYPE) { + /* Type needs hassubtype reference to the supertype */ + if(referenceType->referenceTypeNode.referenceTypeIndex != + UA_REFERENCETYPEINDEX_HASSUBTYPE) { + logAddNode(&server->config.logger, session, &head->nodeId, + "Type nodes need to have a HasSubType reference to the parent"); + return UA_STATUSCODE_BADREFERENCENOTALLOWED; + } + /* Supertype needs to be of the same node type */ + if(parentNodeClass != head->nodeClass) { + logAddNode(&server->config.logger, session, &head->nodeId, + "Type nodes needs to be of the same node " + "type as their parent"); + return UA_STATUSCODE_BADPARENTNODEIDINVALID; + } + return UA_STATUSCODE_GOOD; + } + + /* Test if the referencetype is hierarchical */ + const UA_NodeId hierarchRefs = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES); + if(!isNodeInTree_singleRef(server, referenceTypeId, &hierarchRefs, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) { + logAddNode(&server->config.logger, session, &head->nodeId, + "Reference type to the parent is not hierarchical"); + return UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + } + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +setDefaultValue(UA_Server *server, const UA_VariableNode *node) { + /* Get the DataType */ + UA_StatusCode res = UA_STATUSCODE_GOOD; + const UA_DataType *type = UA_Server_findDataType(server, &node->dataType); + if(!type) { + /* No description for the DataType found. It is possible that an + * abstract DataType is used, e.g. UInteger. Browse to see if there is a + * non-abstract subtype that can be used for the default value. + * + * Look up and downwards in the hierarchy. Some data types (e.g. + * UtcTime) are derived from a non-abstract data type. This is then used + * for the actual value, Use the first match. */ + UA_ReferenceTypeSet refs = UA_REFTYPESET(UA_REFERENCETYPEINDEX_HASSUBTYPE); + UA_ExpandedNodeId *typeCandidates = NULL; + size_t typeCandidatesSize = 0; + res = browseRecursive(server, 1, &node->dataType, + UA_BROWSEDIRECTION_BOTH, &refs, + UA_NODECLASS_DATATYPE, false, + &typeCandidatesSize, &typeCandidates); + if(res != UA_STATUSCODE_GOOD) + return res; + + for(size_t i = 0; i < typeCandidatesSize; i++) { + /* Skip BaseDataType (Variant). This is the root of the DataType + * hierarchy. Variables of BaseDataType can be empty. */ + if(UA_NodeId_equal(&UA_TYPES[UA_TYPES_VARIANT].typeId, + &typeCandidates[i].nodeId)) + continue; + type = UA_Server_findDataType(server, &typeCandidates[i].nodeId); + if(type) + break; + } + + UA_Array_delete(typeCandidates, typeCandidatesSize, + &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + if(!type) + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + /* Set up the value with the default content */ + UA_Variant val; + UA_Variant_init(&val); + if(node->valueRank < 0) { + /* Set a scalar */ + void *data = UA_new(type); + if(!data) + return UA_STATUSCODE_BADOUTOFMEMORY; + UA_Variant_setScalar(&val, data, type); + } else if(node->valueRank == 0) { + /* Use an empty array of one dimension */ + UA_Variant_setArray(&val, NULL, 0, type); + } else { + /* Write an array that matches the ArrayDimensions */ + res = UA_Array_copy(node->arrayDimensions, node->arrayDimensionsSize, + (void**)&val.arrayDimensions, &UA_TYPES[UA_TYPES_UINT32]); + if(res != UA_STATUSCODE_GOOD) + return res; + val.arrayDimensionsSize = node->arrayDimensionsSize; + + /* No length restriction in the ArrayDimension -> use length 1 */ + size_t size = 1; + for(size_t i = 0; i < val.arrayDimensionsSize; i++) { + if(val.arrayDimensions[i] == 0) + val.arrayDimensions[i] = 1; + size *= val.arrayDimensions[i]; + } + + /* Create the content array */ + void *data = UA_Array_new(size, type); + if(!data) { + UA_Variant_clear(&val); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + val.data = data; + val.arrayLength = size; + val.type = type; + } + + /* Write the value */ + res = writeAttribute(server, &server->adminSession, &node->head.nodeId, + UA_ATTRIBUTEID_VALUE, &val, &UA_TYPES[UA_TYPES_VARIANT]); + + /* Clean up */ + UA_Variant_clear(&val); + return res; +} + +static UA_StatusCode +typeCheckVariableNode(UA_Server *server, UA_Session *session, + const UA_VariableNode *node, + const UA_VariableTypeNode *vt) { + /* Check the datatype against the vt */ + if(!compatibleDataTypes(server, &node->dataType, &vt->dataType)) { + logAddNode(&server->config.logger, session, &node->head.nodeId, + "The value of is incompatible with " + "the datatype of the VariableType"); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + /* Check valueRank against array dimensions */ + if(!compatibleValueRankArrayDimensions(server, session, node->valueRank, + node->arrayDimensionsSize)) { + logAddNode(&server->config.logger, session, &node->head.nodeId, + "The value rank of is incompatible with its array dimensions"); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + /* Check valueRank against the vt */ + if(!compatibleValueRanks(node->valueRank, vt->valueRank)) { + logAddNode(&server->config.logger, session, &node->head.nodeId, + "The value rank is incompatible " + "with the value rank of the VariableType"); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + /* Check array dimensions against the vt */ + if(!compatibleArrayDimensions(vt->arrayDimensionsSize, vt->arrayDimensions, + node->arrayDimensionsSize, node->arrayDimensions)) { + logAddNode(&server->config.logger, session, &node->head.nodeId, + "The array dimensions are incompatible with the " + "array dimensions of the VariableType"); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + /* Typecheck the value */ + + /* The value might come from a datasource, so we perform a + * regular read. */ + UA_DataValue value; + UA_DataValue_init(&value); + UA_StatusCode retval = readValueAttribute(server, session, node, &value); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Only BaseDataType (Variant) can have empty values. Create default content + * otherwise that matches the constraints. */ + if(!value.hasValue || !value.value.type) { + if(!UA_NodeId_equal(&node->dataType, &UA_TYPES[UA_TYPES_VARIANT].typeId)) { + /* Warn if that is configured */ + if(!server->bootstrapNS0 && + server->config.allowEmptyVariables != UA_RULEHANDLING_ACCEPT) + logAddNode(&server->config.logger, session, &node->head.nodeId, + "The value is empty. But this is only allowed for BaseDataType. " + "Create a matching default value."); + + /* Abort if that is configured */ + if(server->config.allowEmptyVariables == UA_RULEHANDLING_ABORT) + retval = UA_STATUSCODE_BADTYPEMISMATCH; + + /* Try to generate a default value if that is configured */ + if(server->config.allowEmptyVariables == UA_RULEHANDLING_DEFAULT) { + retval = setDefaultValue(server, node); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode (%.*s): Could not create a default value " + "with StatusCode %s", (int)nodeIdStr.length, + nodeIdStr.data, UA_StatusCode_name(retval))); + } + + /* Reread the current value for compat tests below */ + UA_DataValue_clear(&value); + retval = readValueAttribute(server, session, node, &value); + } + } + + if(retval != UA_STATUSCODE_GOOD) { + UA_DataValue_clear(&value); + return retval; + } + } + + /* Perform the value typecheck. If this fails, write the current value + * again. The write-service tries to convert to the correct type... */ + if(!compatibleValue(server, session, &node->dataType, node->valueRank, + node->arrayDimensionsSize, node->arrayDimensions, + &value.value, NULL)) { + retval = writeValueAttribute(server, session, &node->head.nodeId, &value.value); + if(retval != UA_STATUSCODE_GOOD) { + logAddNode(&server->config.logger, session, &node->head.nodeId, + "The value is incompatible with the variable definition"); + } + } + + UA_DataValue_clear(&value); + return retval; +} + +/********************/ +/* Instantiate Node */ +/********************/ + +static const UA_NodeId baseDataVariableType = + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_BASEDATAVARIABLETYPE}}; +static const UA_NodeId baseObjectType = + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_BASEOBJECTTYPE}}; +static const UA_NodeId hasTypeDefinition = + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASTYPEDEFINITION}}; + +/* Use attributes from the variable type wherever required. Reload the node if + * changes were made. */ +static UA_StatusCode +useVariableTypeAttributes(UA_Server *server, UA_Session *session, + const UA_VariableNode **node_ptr, + const UA_VariableTypeNode *vt) { + const UA_VariableNode *node = *node_ptr; + UA_Boolean modified = false; + + /* If no value is set, see if the vt provides one and copy it. This needs to + * be done before copying the datatype from the vt, as setting the datatype + * triggers a typecheck. */ + UA_DataValue orig; + UA_DataValue_init(&orig); + UA_StatusCode retval = readValueAttribute(server, session, node, &orig); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + if(orig.value.type) { + /* A value is present */ + UA_DataValue_clear(&orig); + } else { + UA_DataValue v; + UA_DataValue_init(&v); + retval = readValueAttribute(server, session, (const UA_VariableNode*)vt, &v); + if(retval == UA_STATUSCODE_GOOD && v.hasValue) { + retval = writeValueAttribute(server, session, &node->head.nodeId, + &v.value); + modified = true; + } + UA_DataValue_clear(&v); + + if(retval != UA_STATUSCODE_GOOD) { + logAddNode(&server->config.logger, session, &node->head.nodeId, + "The default content of the VariableType could " + "not be used. This may happen if the VariableNode " + "makes additional restrictions."); + retval = UA_STATUSCODE_GOOD; + } + } + + /* If no datatype is given, use the datatype of the vt */ + if(UA_NodeId_isNull(&node->dataType)) { + logAddNode(&server->config.logger, session, &node->head.nodeId, + "No datatype given; Copy the datatype attribute " + "from the TypeDefinition"); + retval = writeAttribute(server, session, &node->head.nodeId, + UA_ATTRIBUTEID_DATATYPE, &vt->dataType, + &UA_TYPES[UA_TYPES_NODEID]); + modified = true; + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + /* Use the ArrayDimensions of the vt */ + if(node->arrayDimensionsSize == 0 && vt->arrayDimensionsSize > 0) { + UA_Variant v; + UA_Variant_init(&v); + UA_Variant_setArray(&v, vt->arrayDimensions, vt->arrayDimensionsSize, + &UA_TYPES[UA_TYPES_UINT32]); + retval = writeAttribute(server, session, &node->head.nodeId, + UA_ATTRIBUTEID_ARRAYDIMENSIONS, &v, + &UA_TYPES[UA_TYPES_VARIANT]); + modified = true; + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + /* If the node was modified, update the pointer to the new version */ + if(modified) { + const UA_Node *updated = UA_NODESTORE_GET(server, &node->head.nodeId); + if(!updated) + return UA_STATUSCODE_BADINTERNALERROR; + UA_NODESTORE_RELEASE(server, (const UA_Node*)node); + *node_ptr = (const UA_VariableNode*)updated; + } + + return retval; +} + +/* Search for an instance of "browseName" in node searchInstance. Used during + * copyChildNodes to find overwritable/mergable nodes. Does not touch + * outInstanceNodeId if no child is found. */ +static UA_StatusCode +findChildByBrowsename(UA_Server *server, UA_Session *session, + const UA_NodeId *searchInstance, + const UA_QualifiedName *browseName, + UA_NodeId *outInstanceNodeId) { + UA_BrowseDescription bd; + UA_BrowseDescription_init(&bd); + bd.nodeId = *searchInstance; + bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_AGGREGATES); + bd.includeSubtypes = true; + bd.browseDirection = UA_BROWSEDIRECTION_FORWARD; + bd.nodeClassMask = UA_NODECLASS_OBJECT | UA_NODECLASS_VARIABLE | UA_NODECLASS_METHOD; + bd.resultMask = UA_BROWSERESULTMASK_BROWSENAME; + + UA_BrowseResult br; + UA_BrowseResult_init(&br); + UA_UInt32 maxrefs = 0; + Operation_Browse(server, session, &maxrefs, &bd, &br); + if(br.statusCode != UA_STATUSCODE_GOOD) + return br.statusCode; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < br.referencesSize; ++i) { + UA_ReferenceDescription *rd = &br.references[i]; + if(rd->browseName.namespaceIndex == browseName->namespaceIndex && + UA_String_equal(&rd->browseName.name, &browseName->name)) { + retval = UA_NodeId_copy(&rd->nodeId.nodeId, outInstanceNodeId); + break; + } + } + + UA_BrowseResult_clear(&br); + return retval; +} + +static const UA_NodeId mandatoryId = + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_MODELLINGRULE_MANDATORY}}; + +static UA_Boolean +isMandatoryChild(UA_Server *server, UA_Session *session, + const UA_NodeId *childNodeId) { + /* Get the child */ + const UA_Node *child = UA_NODESTORE_GET(server, childNodeId); + if(!child) + return false; + + /* Look for the reference making the child mandatory */ + UA_NodePointer mandatoryP = UA_NodePointer_fromNodeId(&mandatoryId); + for(size_t i = 0; i < child->head.referencesSize; ++i) { + UA_NodeReferenceKind *rk = &child->head.references[i]; + if(rk->referenceTypeIndex != UA_REFERENCETYPEINDEX_HASMODELLINGRULE) + continue; + if(rk->isInverse) + continue; + + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + if(UA_NodePointer_equal(mandatoryP, t->targetId)) { + UA_NODESTORE_RELEASE(server, child); + return true; + } + } + } + + UA_NODESTORE_RELEASE(server, child); + return false; +} + +static UA_StatusCode +copyAllChildren(UA_Server *server, UA_Session *session, + const UA_NodeId *source, const UA_NodeId *destination); + +static UA_StatusCode +recursiveTypeCheckAddChildren(UA_Server *server, UA_Session *session, + const UA_Node **node, const UA_Node *type); + +static void +Operation_addReference(UA_Server *server, UA_Session *session, void *context, + const UA_AddReferencesItem *item, UA_StatusCode *retval); + +static UA_StatusCode +addRef(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId, + const UA_NodeId *referenceTypeId, const UA_NodeId *parentNodeId, + UA_Boolean forward) { + UA_AddReferencesItem ref_item; + UA_AddReferencesItem_init(&ref_item); + ref_item.sourceNodeId = *nodeId; + ref_item.referenceTypeId = *referenceTypeId; + ref_item.isForward = forward; + ref_item.targetNodeId.nodeId = *parentNodeId; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + Operation_addReference(server, session, NULL, &ref_item, &retval); + return retval; +} + +static UA_StatusCode +addInterfaceChildren(UA_Server *server, UA_Session *session, + const UA_NodeHead *head, const UA_Node *type) { + /* Get the hierarchy of the type and all its supertypes */ + UA_NodeId *hierarchy = NULL; + size_t hierarchySize = 0; + UA_StatusCode retval = getAllInterfaceChildNodeIds(server, &head->nodeId, &type->head.nodeId, + &hierarchy, &hierarchySize); + if(retval != UA_STATUSCODE_GOOD) + return retval; + UA_assert(hierarchySize < 1000); + + /* Copy members of the type and supertypes (and instantiate them) */ + for(size_t i = 0; i < hierarchySize; ++i) { + retval = copyAllChildren(server, session, &hierarchy[i], &head->nodeId); + if(retval != UA_STATUSCODE_GOOD) { + UA_Array_delete(hierarchy, hierarchySize, &UA_TYPES[UA_TYPES_NODEID]); + return retval; + } + } + + for (size_t i = 0; i < hierarchySize; ++i) { + UA_NodeId refId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASINTERFACE); + retval = addRef(server, &server->adminSession, &head->nodeId, &refId, &hierarchy[i], true); + + /* Don't add the original HasInterface reference to ObjectType sub nodes */ + if (retval == UA_STATUSCODE_BADDUPLICATEREFERENCENOTALLOWED) { + retval = UA_STATUSCODE_GOOD; + continue; + } + + if (retval != UA_STATUSCODE_GOOD) + break; + } + + UA_Array_delete(hierarchy, hierarchySize, &UA_TYPES[UA_TYPES_NODEID]); + return retval; +} + +static UA_StatusCode +copyChild(UA_Server *server, UA_Session *session, + const UA_NodeId *destinationNodeId, + const UA_ReferenceDescription *rd) { + UA_assert(session); + + /* Is there an existing child with the browsename? */ + UA_NodeId existingChild = UA_NODEID_NULL; + UA_StatusCode retval = findChildByBrowsename(server, session, destinationNodeId, + &rd->browseName, &existingChild); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Have a child with that browseName. Deep-copy missing members. */ + if(!UA_NodeId_isNull(&existingChild)) { + if(rd->nodeClass == UA_NODECLASS_VARIABLE || + rd->nodeClass == UA_NODECLASS_OBJECT) + retval = copyAllChildren(server, session, &rd->nodeId.nodeId, &existingChild); + UA_NodeId_clear(&existingChild); + return retval; + } + + /* Is the child mandatory? If not, ask callback whether child should be instantiated. + * If not, skip. */ + if(!isMandatoryChild(server, session, &rd->nodeId.nodeId)) { + if(!server->config.nodeLifecycle.createOptionalChild) + return UA_STATUSCODE_GOOD; + + UA_UNLOCK(&server->serviceMutex); + UA_Boolean createChild = + server->config.nodeLifecycle.createOptionalChild(server, + &session->sessionId, + session->sessionHandle, + &rd->nodeId.nodeId, + destinationNodeId, + &rd->referenceTypeId); + UA_LOCK(&server->serviceMutex); + if(!createChild) + return UA_STATUSCODE_GOOD; + } + + /* Child is a method -> create a reference */ + if(rd->nodeClass == UA_NODECLASS_METHOD) { + UA_AddReferencesItem newItem; + UA_AddReferencesItem_init(&newItem); + newItem.sourceNodeId = *destinationNodeId; + newItem.referenceTypeId = rd->referenceTypeId; + newItem.isForward = true; + newItem.targetNodeId = rd->nodeId; + newItem.targetNodeClass = UA_NODECLASS_METHOD; + Operation_addReference(server, session, NULL, &newItem, &retval); + return retval; + } + + /* Child is a variable or object */ + if(rd->nodeClass == UA_NODECLASS_VARIABLE || + rd->nodeClass == UA_NODECLASS_OBJECT) { + /* Make a copy of the node */ + UA_Node *node; + retval = UA_NODESTORE_GETCOPY(server, &rd->nodeId.nodeId, &node); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Remove the context of the copied node */ + node->head.context = NULL; + node->head.constructed = false; +#ifdef UA_ENABLE_SUBSCRIPTIONS + node->head.monitoredItems = NULL; +#endif + + /* Reset the NodeId (random numeric id will be assigned in the nodestore) */ + UA_NodeId_clear(&node->head.nodeId); + node->head.nodeId.namespaceIndex = destinationNodeId->namespaceIndex; + + if (server->config.nodeLifecycle.generateChildNodeId) { + UA_UNLOCK(&server->serviceMutex); + retval = server->config.nodeLifecycle. + generateChildNodeId(server, &session->sessionId, session->sessionHandle, + &rd->nodeId.nodeId, destinationNodeId, + &rd->referenceTypeId, &node->head.nodeId); + UA_LOCK(&server->serviceMutex); + if(retval != UA_STATUSCODE_GOOD) { + UA_NODESTORE_DELETE(server, node); + return retval; + } + } + + /* Remove references, they are re-created from scratch in addnode_finish */ + /* TODO: Be more clever in removing references that are re-added during + * addnode_finish. That way, we can call addnode_finish also on children that were + * manually added by the user during addnode_begin and addnode_finish. */ + /* For now we keep all the modelling rule references and delete all others */ + const UA_NodeId nodeId_typesFolder= UA_NODEID_NUMERIC(0, UA_NS0ID_TYPESFOLDER); + const UA_ReferenceTypeSet reftypes_aggregates = + UA_REFTYPESET(UA_REFERENCETYPEINDEX_AGGREGATES); + UA_ReferenceTypeSet reftypes_skipped; + /* Check if the hasModellingRule-reference is required (configured or node in an + instance declaration) */ + if(server->config.modellingRulesOnInstances || + isNodeInTree(server, destinationNodeId, &nodeId_typesFolder, &reftypes_aggregates)) { + reftypes_skipped = + UA_REFTYPESET(UA_REFERENCETYPEINDEX_HASMODELLINGRULE); + } else { + UA_ReferenceTypeSet_init(&reftypes_skipped); + } + UA_Node_deleteReferencesSubset(node, &reftypes_skipped); + + /* Add the node to the nodestore */ + UA_NodeId newNodeId; + retval = UA_NODESTORE_INSERT(server, node, &newNodeId); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Add the node references */ + retval = AddNode_addRefs(server, session, &newNodeId, destinationNodeId, + &rd->referenceTypeId, &rd->typeDefinition.nodeId); + if(retval != UA_STATUSCODE_GOOD) { + UA_NODESTORE_REMOVE(server, &newNodeId); + return retval; + } + + /* Add HasInterface references to the child */ + if(rd->nodeClass == UA_NODECLASS_OBJECT && !UA_NodeId_isNull(&rd->typeDefinition.nodeId)) { + const UA_Node *typeNode = UA_NODESTORE_GET(server, &rd->typeDefinition.nodeId); + + if (!typeNode) { + UA_NODESTORE_REMOVE(server, &newNodeId); + return retval; + } + + retval = addInterfaceChildren(server, session, &node->head, typeNode); + UA_NODESTORE_RELEASE(server, typeNode); + + if (retval != UA_STATUSCODE_GOOD) { + UA_NODESTORE_REMOVE(server, &newNodeId); + return retval; + } + } + + /* For the new child, recursively copy the members of the original. No + * typechecking is performed here. Assuming that the original is + * consistent. */ + retval = copyAllChildren(server, session, &rd->nodeId.nodeId, &newNodeId); + + /* Clean up. Because it can happen that a string is assigned as ID at + * generateChildNodeId. */ + UA_NodeId_clear(&newNodeId); + } + + return retval; +} + +/* Copy any children of Node sourceNodeId to another node destinationNodeId. */ +static UA_StatusCode +copyAllChildren(UA_Server *server, UA_Session *session, + const UA_NodeId *source, const UA_NodeId *destination) { + /* Browse to get all children of the source */ + UA_BrowseDescription bd; + UA_BrowseDescription_init(&bd); + bd.nodeId = *source; + bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_AGGREGATES); + bd.includeSubtypes = true; + bd.browseDirection = UA_BROWSEDIRECTION_FORWARD; + bd.nodeClassMask = UA_NODECLASS_OBJECT | UA_NODECLASS_VARIABLE | UA_NODECLASS_METHOD; + bd.resultMask = UA_BROWSERESULTMASK_REFERENCETYPEID | UA_BROWSERESULTMASK_NODECLASS | + UA_BROWSERESULTMASK_BROWSENAME | UA_BROWSERESULTMASK_TYPEDEFINITION; + + UA_BrowseResult br; + UA_BrowseResult_init(&br); + UA_UInt32 maxrefs = 0; + Operation_Browse(server, session, &maxrefs, &bd, &br); + if(br.statusCode != UA_STATUSCODE_GOOD) + return br.statusCode; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < br.referencesSize; ++i) { + UA_ReferenceDescription *rd = &br.references[i]; + retval = copyChild(server, session, destination, rd); + if(retval != UA_STATUSCODE_GOOD) + break; + } + + UA_BrowseResult_clear(&br); + return retval; +} + +static UA_StatusCode +addTypeChildren(UA_Server *server, UA_Session *session, + const UA_NodeHead *head, const UA_NodeHead *typeHead) { + /* Get the hierarchy of the type and all its supertypes */ + UA_NodeId *hierarchy = NULL; + size_t hierarchySize = 0; + UA_StatusCode retval = getParentTypeAndInterfaceHierarchy(server, &typeHead->nodeId, + &hierarchy, &hierarchySize); + if(retval != UA_STATUSCODE_GOOD) + return retval; + UA_assert(hierarchySize < 1000); + + /* Copy members of the type and supertypes (and instantiate them) */ + for(size_t i = 0; i < hierarchySize; ++i) { + retval = copyAllChildren(server, session, &hierarchy[i], &head->nodeId); + if(retval != UA_STATUSCODE_GOOD) + break; + } + + UA_Array_delete(hierarchy, hierarchySize, &UA_TYPES[UA_TYPES_NODEID]); + return retval; +} + +/************/ +/* Add Node */ +/************/ + +static const UA_NodeId hasSubtype = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASSUBTYPE}}; + +UA_StatusCode +AddNode_addRefs(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId, + const UA_NodeId *parentNodeId, const UA_NodeId *referenceTypeId, + const UA_NodeId *typeDefinitionId) { + /* Get the node */ + const UA_Node *type = NULL; + const UA_Node *node = UA_NODESTORE_GET(server, nodeId); + if(!node) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + + /* Use the typeDefinition as parent for type-nodes */ + const UA_NodeHead *head = &node->head; + if(head->nodeClass == UA_NODECLASS_VARIABLETYPE || + head->nodeClass == UA_NODECLASS_OBJECTTYPE || + head->nodeClass == UA_NODECLASS_REFERENCETYPE || + head->nodeClass == UA_NODECLASS_DATATYPE) { + if(UA_NodeId_equal(referenceTypeId, &UA_NODEID_NULL)) + referenceTypeId = &hasSubtype; + const UA_Node *parentNode = UA_NODESTORE_GET(server, parentNodeId); + if(parentNode) { + if(parentNode->head.nodeClass == head->nodeClass) + typeDefinitionId = parentNodeId; + UA_NODESTORE_RELEASE(server, parentNode); + } + } + + UA_StatusCode retval; + /* Make sure newly created node does not have itself as parent */ + if(UA_NodeId_equal(nodeId, parentNodeId)) { + logAddNode(&server->config.logger, session, nodeId, + "A node cannot have itself as parent"); + retval = UA_STATUSCODE_BADINVALIDARGUMENT; + goto cleanup; + } + + + /* Check parent reference. Objects may have no parent. */ + retval = checkParentReference(server, session, head, parentNodeId, referenceTypeId); + if(retval != UA_STATUSCODE_GOOD) { + logAddNode(&server->config.logger, session, nodeId, + "The parent reference for is invalid"); + goto cleanup; + } + + /* Replace empty typeDefinition with the most permissive default */ + if((head->nodeClass == UA_NODECLASS_VARIABLE || + head->nodeClass == UA_NODECLASS_OBJECT) && + UA_NodeId_isNull(typeDefinitionId)) { + logAddNode(&server->config.logger, session, nodeId, + "No TypeDefinition. Use the default " + "TypeDefinition for the Variable/Object"); + if(head->nodeClass == UA_NODECLASS_VARIABLE) + typeDefinitionId = &baseDataVariableType; + else + typeDefinitionId = &baseObjectType; + } + + /* Get the node type. There must be a typedefinition for variables, objects + * and type-nodes. See the above checks. */ + if(!UA_NodeId_isNull(typeDefinitionId)) { + /* Get the type node */ + type = UA_NODESTORE_GET(server, typeDefinitionId); + if(!type) { + logAddNode(&server->config.logger, session, nodeId, "Node type not found"); + retval = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + goto cleanup; + } + + UA_Boolean typeOk = false; + const UA_NodeHead *typeHead = &type->head; + switch(head->nodeClass) { + case UA_NODECLASS_DATATYPE: + typeOk = typeHead->nodeClass == UA_NODECLASS_DATATYPE; + break; + case UA_NODECLASS_METHOD: + typeOk = typeHead->nodeClass == UA_NODECLASS_METHOD; + break; + case UA_NODECLASS_OBJECT: + case UA_NODECLASS_OBJECTTYPE: + typeOk = typeHead->nodeClass == UA_NODECLASS_OBJECTTYPE; + break; + case UA_NODECLASS_REFERENCETYPE: + typeOk = typeHead->nodeClass == UA_NODECLASS_REFERENCETYPE; + break; + case UA_NODECLASS_VARIABLE: + case UA_NODECLASS_VARIABLETYPE: + typeOk = typeHead->nodeClass == UA_NODECLASS_VARIABLETYPE; + break; + case UA_NODECLASS_VIEW: + typeOk = typeHead->nodeClass == UA_NODECLASS_VIEW; + break; + default: + typeOk = false; + } + if(!typeOk) { + logAddNode(&server->config.logger, session, nodeId, + "Type does not match the NodeClass"); + retval = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + goto cleanup; + } + + /* See if the type has the correct node class. For type-nodes, we know + * that type has the same nodeClass from checkParentReference. */ + if(head->nodeClass == UA_NODECLASS_VARIABLE && + type->variableTypeNode.isAbstract) { + /* Get subtypes of the parent reference types */ + UA_ReferenceTypeSet refTypes1, refTypes2; + retval |= referenceTypeIndices(server, &parentReferences[0], &refTypes1, true); + retval |= referenceTypeIndices(server, &parentReferences[1], &refTypes2, true); + UA_ReferenceTypeSet refTypes = UA_ReferenceTypeSet_union(refTypes1, refTypes2); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Abstract variable is allowed if parent is a children of a + * base data variable. An abstract variable may be part of an + * object type which again is below BaseObjectType */ + const UA_NodeId variableTypes = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEDATAVARIABLETYPE); + const UA_NodeId objectTypes = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE); + if(!isNodeInTree(server, parentNodeId, &variableTypes, &refTypes) && + !isNodeInTree(server, parentNodeId, &objectTypes, &refTypes)) { + logAddNode(&server->config.logger, session, nodeId, + "Type of variable node must be a " + "VariableType and not cannot be abstract"); + retval = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + goto cleanup; + } + } + + if(head->nodeClass == UA_NODECLASS_OBJECT && + type->objectTypeNode.isAbstract) { + /* Get subtypes of the parent reference types */ + UA_ReferenceTypeSet refTypes1, refTypes2; + retval |= referenceTypeIndices(server, &parentReferences[0], &refTypes1, true); + retval |= referenceTypeIndices(server, &parentReferences[1], &refTypes2, true); + UA_ReferenceTypeSet refTypes = UA_ReferenceTypeSet_union(refTypes1, refTypes2); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + + /* Object node created of an abstract ObjectType. Only allowed if + * within BaseObjectType folder or if it's an event (subType of + * BaseEventType) */ + const UA_NodeId objectTypes = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE); + UA_Boolean isInBaseObjectType = + isNodeInTree(server, parentNodeId, &objectTypes, &refTypes); + + const UA_NodeId eventTypes = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE); + UA_Boolean isInBaseEventType = + isNodeInTree_singleRef(server, &type->head.nodeId, &eventTypes, + UA_REFERENCETYPEINDEX_HASSUBTYPE); + + if(!isInBaseObjectType && + !(isInBaseEventType && UA_NodeId_isNull(parentNodeId))) { + logAddNode(&server->config.logger, session, nodeId, + "Type of ObjectNode must be ObjectType and not be abstract"); + retval = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + goto cleanup; + } + } + } + + /* Add reference to the parent */ + if(!UA_NodeId_isNull(parentNodeId)) { + if(UA_NodeId_isNull(referenceTypeId)) { + logAddNode(&server->config.logger, session, nodeId, + "Reference to parent cannot be null"); + retval = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + goto cleanup; + } + + retval = addRef(server, session, &head->nodeId, referenceTypeId, + parentNodeId, false); + if(retval != UA_STATUSCODE_GOOD) { + logAddNode(&server->config.logger, session, nodeId, + "Adding reference to parent failed"); + goto cleanup; + } + } + + /* Add a hasTypeDefinition reference */ + if(head->nodeClass == UA_NODECLASS_VARIABLE || + head->nodeClass == UA_NODECLASS_OBJECT) { + UA_assert(type != NULL); /* see above */ + retval = addRef(server, session, &head->nodeId, &hasTypeDefinition, &type->head.nodeId, true); + if(retval != UA_STATUSCODE_GOOD) { + logAddNode(&server->config.logger, session, nodeId, + "Adding a reference to the type definition failed"); + } + } + + cleanup: + UA_NODESTORE_RELEASE(server, node); + if(type) + UA_NODESTORE_RELEASE(server, type); + return retval; +} + +/* Create the node and add it to the nodestore. But don't typecheck and add + * references so far */ +UA_StatusCode +AddNode_raw(UA_Server *server, UA_Session *session, void *nodeContext, + const UA_AddNodesItem *item, UA_NodeId *outNewNodeId) { + /* Do not check access for server */ + if(session != &server->adminSession && server->config.accessControl.allowAddNode) { + UA_UNLOCK(&server->serviceMutex); + if (!server->config.accessControl.allowAddNode(server, &server->config.accessControl, + &session->sessionId, session->sessionHandle, item)) { + UA_LOCK(&server->serviceMutex); + return UA_STATUSCODE_BADUSERACCESSDENIED; + } + UA_LOCK(&server->serviceMutex); + } + + /* Check the namespaceindex */ + if(item->requestedNewNodeId.nodeId.namespaceIndex >= server->namespacesSize) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode: Namespace invalid"); + return UA_STATUSCODE_BADNODEIDINVALID; + } + + if(item->nodeAttributes.encoding != UA_EXTENSIONOBJECT_DECODED && + item->nodeAttributes.encoding != UA_EXTENSIONOBJECT_DECODED_NODELETE) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode: Node attributes invalid"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Create a node */ + UA_Node *node = UA_NODESTORE_NEW(server, item->nodeClass); + if(!node) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode: Node could not create a node " + "in the nodestore"); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_NodeId tmpOutId = UA_NODEID_NULL; + /* Fill the node attributes */ + node->head.context = nodeContext; + UA_StatusCode retval = UA_NodeId_copy(&item->requestedNewNodeId.nodeId, &node->head.nodeId); + if(retval != UA_STATUSCODE_GOOD) + goto create_error; + + retval = UA_QualifiedName_copy(&item->browseName, &node->head.browseName); + if(retval != UA_STATUSCODE_GOOD) + goto create_error; + + retval = UA_Node_setAttributes(node, item->nodeAttributes.content.decoded.data, + item->nodeAttributes.content.decoded.type); + if(retval != UA_STATUSCODE_GOOD) + goto create_error; + + /* Add the node to the nodestore */ + if(!outNewNodeId) + outNewNodeId = &tmpOutId; + retval = UA_NODESTORE_INSERT(server, node, outNewNodeId); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode: Node could not add the new node " + "to the nodestore with error code %s", + UA_StatusCode_name(retval)); + return retval; + } + + if(outNewNodeId == &tmpOutId) + UA_NodeId_clear(&tmpOutId); + + return UA_STATUSCODE_GOOD; + +create_error: + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode: Node could not create a node " + "with error code %s", UA_StatusCode_name(retval)); + UA_NODESTORE_DELETE(server, node); + return retval; +} + +static UA_StatusCode +findDefaultInstanceBrowseNameNode(UA_Server *server, UA_NodeId startingNode, + UA_NodeId *foundId) { + UA_NodeId_init(foundId); + UA_RelativePathElement rpe; + UA_RelativePathElement_init(&rpe); + rpe.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY); + rpe.targetName = UA_QUALIFIEDNAME(0, "DefaultInstanceBrowseName"); + UA_BrowsePath bp; + UA_BrowsePath_init(&bp); + bp.startingNode = startingNode; + bp.relativePath.elementsSize = 1; + bp.relativePath.elements = &rpe; + UA_BrowsePathResult bpr = translateBrowsePathToNodeIds(server, &bp); + UA_StatusCode retval = bpr.statusCode; + if(retval == UA_STATUSCODE_GOOD && bpr.targetsSize > 0) + retval = UA_NodeId_copy(&bpr.targets[0].targetId.nodeId, foundId); + UA_BrowsePathResult_clear(&bpr); + return retval; +} + +/* Check if we got a valid browse name for the new node. For object nodes the + * BrowseName may only be null if the parent type has a + * 'DefaultInstanceBrowseName' property. */ +static UA_StatusCode +checkSetBrowseName(UA_Server *server, UA_Session *session, UA_AddNodesItem *item) { + /* If the object node already has a browse name we are done here. */ + if(!UA_QualifiedName_isNull(&item->browseName)) + return UA_STATUSCODE_GOOD; + + /* Nodes other than Objects must have a BrowseName */ + if(item->nodeClass != UA_NODECLASS_OBJECT) + return UA_STATUSCODE_BADBROWSENAMEINVALID; + + /* At this point we have an object with an empty browse name. Check the type + * node if it has a DefaultInstanceBrowseName property. */ + UA_NodeId defaultBrowseNameNode; + UA_StatusCode retval = + findDefaultInstanceBrowseNameNode(server, item->typeDefinition.nodeId, + &defaultBrowseNameNode); + if(retval != UA_STATUSCODE_GOOD) + return UA_STATUSCODE_BADBROWSENAMEINVALID; + + UA_Variant defaultBrowseName; + retval = readWithReadValue(server, &defaultBrowseNameNode, + UA_ATTRIBUTEID_VALUE, &defaultBrowseName); + UA_NodeId_clear(&defaultBrowseNameNode); + if(retval != UA_STATUSCODE_GOOD) + return UA_STATUSCODE_BADBROWSENAMEINVALID; + + if(UA_Variant_hasScalarType(&defaultBrowseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME])) { + item->browseName = *(UA_QualifiedName*)defaultBrowseName.data; + UA_QualifiedName_init((UA_QualifiedName*)defaultBrowseName.data); + } else { + retval = UA_STATUSCODE_BADBROWSENAMEINVALID; + } + + UA_Variant_clear(&defaultBrowseName); + return retval; +} + +/* Prepare the node, then add it to the nodestore */ +static UA_StatusCode +Operation_addNode_begin(UA_Server *server, UA_Session *session, void *nodeContext, + const UA_AddNodesItem *item, const UA_NodeId *parentNodeId, + const UA_NodeId *referenceTypeId, UA_NodeId *outNewNodeId) { + /* Create a temporary NodeId if none is returned */ + UA_NodeId newId; + if(!outNewNodeId) { + UA_NodeId_init(&newId); + outNewNodeId = &newId; + } + + /* Set the BrowsenName before adding to the Nodestore. The BrowseName is + * immutable afterwards. */ + UA_Boolean noBrowseName = UA_QualifiedName_isNull(&item->browseName); + UA_StatusCode retval = checkSetBrowseName(server, session, (UA_AddNodesItem*)(uintptr_t)item); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Create the node and add it to the nodestore */ + retval = AddNode_raw(server, session, nodeContext, item, outNewNodeId); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Typecheck and add references to parent and type definition */ + retval = AddNode_addRefs(server, session, outNewNodeId, parentNodeId, + referenceTypeId, &item->typeDefinition.nodeId); + if(retval != UA_STATUSCODE_GOOD) + deleteNode(server, *outNewNodeId, true); + + if(outNewNodeId == &newId) + UA_NodeId_clear(&newId); + + cleanup: + if(noBrowseName) + UA_QualifiedName_clear((UA_QualifiedName*)(uintptr_t)&item->browseName); + return retval; +} + +static UA_StatusCode +recursiveTypeCheckAddChildren(UA_Server *server, UA_Session *session, + const UA_Node **nodeptr, const UA_Node *type) { + UA_assert(type != NULL); + UA_StatusCode retval = UA_STATUSCODE_GOOD; + const UA_Node *node = *nodeptr; + + /* Use attributes from the type. The value and value constraints are the + * same for the variable and variabletype attribute structs. */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLE || + node->head.nodeClass == UA_NODECLASS_VARIABLETYPE) { + retval = useVariableTypeAttributes(server, session, + (const UA_VariableNode**)nodeptr, + &type->variableTypeNode); + node = *nodeptr; /* If the node was replaced */ + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode (%.*s): Using attributes for from " + "the variable type failed with error code %s", + (int)nodeIdStr.length, nodeIdStr.data, + UA_StatusCode_name(retval))); + return retval; + } + + /* Check NodeClass for 'hasSubtype'. UA_NODECLASS_VARIABLE not allowed + * to have subtype */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLE) { + for(size_t i = 0; i < node->head.referencesSize; i++) { + if(node->head.references[i].referenceTypeIndex == + UA_REFERENCETYPEINDEX_HASSUBTYPE) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode (%.*s): VariableType not allowed to have HasSubType", + (int)nodeIdStr.length, nodeIdStr.data)); + return UA_STATUSCODE_BADREFERENCENOTALLOWED; + } + } + } + + /* Check if all attributes hold the constraints of the type now. The initial + * attributes must type-check. The constructor might change the attributes + * again. Then, the changes are type-checked by the normal write service. */ + retval = typeCheckVariableNode(server, session, &node->variableNode, + &type->variableTypeNode); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode (%.*s): Type-checking " + "failed with error code %s", (int)nodeIdStr.length, + nodeIdStr.data, UA_StatusCode_name(retval))); + return retval; + } + } + + /* Add (mandatory) child nodes from the type definition */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLE || + node->head.nodeClass == UA_NODECLASS_OBJECT) { + retval = addTypeChildren(server, session, &node->head, &type->head); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode (%.*s): Adding child nodes " + "failed with error code %s", (int)nodeIdStr.length, + nodeIdStr.data, UA_StatusCode_name(retval))); + return retval; + } + } + + /* Add (mandatory) child nodes from the HasInterface references */ + if(node->head.nodeClass == UA_NODECLASS_OBJECT) { + retval = addInterfaceChildren(server, session, &node->head, type); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode (%.*s): Adding child nodes " + "interface failed with error code %s", + (int)nodeIdStr.length, nodeIdStr.data, + UA_StatusCode_name(retval))); + return retval; + } + } + + return retval; +} + +/* Construct children first */ +static UA_StatusCode +recursiveCallConstructors(UA_Server *server, UA_Session *session, + const UA_NodeHead *head, const UA_Node *type) { + if(head->constructed) + return UA_STATUSCODE_GOOD; + + /* Construct the children */ + UA_BrowseDescription bd; + UA_BrowseDescription_init(&bd); + bd.nodeId = head->nodeId; + bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_AGGREGATES); + bd.includeSubtypes = true; + bd.browseDirection = UA_BROWSEDIRECTION_FORWARD; + + UA_BrowseResult br; + UA_BrowseResult_init(&br); + UA_UInt32 maxrefs = 0; + Operation_Browse(server, session, &maxrefs, &bd, &br); + if(br.statusCode != UA_STATUSCODE_GOOD) + return br.statusCode; + + /* Call the constructor for every unconstructed child node */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < br.referencesSize; ++i) { + UA_ReferenceDescription *rd = &br.references[i]; + const UA_Node *target = UA_NODESTORE_GET(server, &rd->nodeId.nodeId); + if(!target) + continue; + if(target->head.constructed) { + UA_NODESTORE_RELEASE(server, target); + continue; + } + + const UA_Node *targetType = NULL; + if(target->head.nodeClass == UA_NODECLASS_VARIABLE || + target->head.nodeClass == UA_NODECLASS_OBJECT) { + targetType = getNodeType(server, &target->head); + if(!targetType) { + UA_NODESTORE_RELEASE(server, target); + retval = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + break; + } + } + retval = recursiveCallConstructors(server, session, &target->head, targetType); + UA_NODESTORE_RELEASE(server, target); + if(targetType) + UA_NODESTORE_RELEASE(server, targetType); + if(retval != UA_STATUSCODE_GOOD) + break; + } + + UA_BrowseResult_clear(&br); + + /* If a child could not be constructed or the node is already constructed */ + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Call the global constructor */ + void *context = head->context; + if(server->config.nodeLifecycle.constructor) { + UA_UNLOCK(&server->serviceMutex); + retval = server->config.nodeLifecycle.constructor(server, &session->sessionId, + session->sessionHandle, + &head->nodeId, &context); + UA_LOCK(&server->serviceMutex); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + /* Call the local (per-type) constructor */ + const UA_NodeTypeLifecycle *lifecycle = NULL; + if(type && head->nodeClass == UA_NODECLASS_OBJECT) + lifecycle = &type->objectTypeNode.lifecycle; + else if(type && head->nodeClass == UA_NODECLASS_VARIABLE) + lifecycle = &type->variableTypeNode.lifecycle; + if(lifecycle && lifecycle->constructor) { + UA_UNLOCK(&server->serviceMutex); + retval = lifecycle->constructor(server, &session->sessionId, + session->sessionHandle, &type->head.nodeId, + type->head.context, &head->nodeId, &context); + UA_LOCK(&server->serviceMutex); + if(retval != UA_STATUSCODE_GOOD) + goto global_destructor; + } + + /* Set the context *and* mark the node as constructed */ + retval = UA_Server_editNode(server, &server->adminSession, &head->nodeId, + (UA_EditNodeCallback)setConstructedNodeContext, context); + if(retval != UA_STATUSCODE_GOOD) + goto local_destructor; + + /* All good, return */ + return retval; + + /* Fail. Call the destructors. */ + local_destructor: + if(lifecycle && lifecycle->destructor) { + UA_UNLOCK(&server->serviceMutex); + lifecycle->destructor(server, &session->sessionId, session->sessionHandle, + &type->head.nodeId, type->head.context, &head->nodeId, + &context); + UA_LOCK(&server->serviceMutex); + } + + global_destructor: + if(server->config.nodeLifecycle.destructor) { + UA_UNLOCK(&server->serviceMutex); + server->config.nodeLifecycle.destructor(server, &session->sessionId, + session->sessionHandle, + &head->nodeId, context); + UA_LOCK(&server->serviceMutex); + } + return retval; +} + +/* Add new ReferenceType to the subtypes bitfield */ +static UA_StatusCode +addReferenceTypeSubtype(UA_Server *server, UA_Session *session, + UA_Node *node, void *context) { + node->referenceTypeNode.subTypes = + UA_ReferenceTypeSet_union(node->referenceTypeNode.subTypes, + *(UA_ReferenceTypeSet*)context); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +setReferenceTypeSubtypes(UA_Server *server, const UA_ReferenceTypeNode *node) { + /* Get the ReferenceTypes upwards in the hierarchy */ + size_t parentsSize = 0; + UA_ExpandedNodeId *parents = NULL; + UA_ReferenceTypeSet reftypes_subtype = UA_REFTYPESET(UA_REFERENCETYPEINDEX_HASSUBTYPE); + UA_StatusCode res = + browseRecursive(server, 1, &node->head.nodeId, UA_BROWSEDIRECTION_INVERSE, + &reftypes_subtype, UA_NODECLASS_UNSPECIFIED, + false, &parentsSize, &parents); + if(res != UA_STATUSCODE_GOOD) + return res; + + /* Add the ReferenceTypeIndex of this node */ + const UA_ReferenceTypeSet *newRefSet = &node->subTypes; + for(size_t i = 0; i < parentsSize; i++) { + UA_Server_editNode(server, &server->adminSession, &parents[i].nodeId, + addReferenceTypeSubtype, (void*)(uintptr_t)newRefSet); + } + + UA_Array_delete(parents, parentsSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +setVariableNodeDynamic(UA_Server *server, UA_Session *session, + UA_Node *node, const void *_) { + (void)_; /* unused */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLE) + ((UA_VariableNode*)node)->isDynamic = true; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +checkSetIsDynamicVariable(UA_Server *server, UA_Session *session, + const UA_NodeId *nodeId) { + /* Get all hierarchical reference types */ + UA_ReferenceTypeSet reftypes_hierarchical; + UA_ReferenceTypeSet_init(&reftypes_hierarchical); + UA_NodeId hierarchicalRefs = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES); + UA_StatusCode res = + referenceTypeIndices(server, &hierarchicalRefs, &reftypes_hierarchical, true); + if(res != UA_STATUSCODE_GOOD) + return res; + + /* Is the variable under the server object? */ + UA_NodeId serverNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER); + if(isNodeInTree(server, nodeId, &serverNodeId, &reftypes_hierarchical)) + return UA_STATUSCODE_GOOD; + + /* Is the variable in the type hierarchy? */ + UA_NodeId typesNodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_TYPESFOLDER); + if(isNodeInTree(server, nodeId, &typesNodeId, &reftypes_hierarchical)) + return UA_STATUSCODE_GOOD; + + /* Is the variable a property of a method node (InputArguments / + * OutputArguments)? */ + UA_BrowseDescription bd; + UA_BrowseDescription_init(&bd); + bd.nodeId = *nodeId; + bd.browseDirection = UA_BROWSEDIRECTION_INVERSE; + bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY); + bd.includeSubtypes = false; + bd.nodeClassMask = UA_NODECLASS_METHOD; + UA_BrowseResult br; + UA_BrowseResult_init(&br); + UA_UInt32 maxrefs = 0; + Operation_Browse(server, session, &maxrefs, &bd, &br); + UA_Boolean hasParentMethod = (br.referencesSize > 0); + UA_BrowseResult_clear(&br); + if(hasParentMethod) + return UA_STATUSCODE_GOOD; + + /* Set the variable to "dynamic" */ + UA_Server_editNode(server, session, nodeId, + (UA_EditNodeCallback)setVariableNodeDynamic, NULL); + + return UA_STATUSCODE_GOOD; +} + +/* Children, references, type-checking, constructors. */ +UA_StatusCode +AddNode_finish(UA_Server *server, UA_Session *session, const UA_NodeId *nodeId) { + /* Get the node */ + const UA_Node *node = UA_NODESTORE_GET(server, nodeId); + if(!node) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + + const UA_Node *type = NULL; + const UA_NodeHead *head = &node->head; + + /* Set the ReferenceTypesSet of subtypes in the ReferenceTypeNode */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(node->head.nodeClass == UA_NODECLASS_REFERENCETYPE) { + retval = setReferenceTypeSubtypes(server, &node->referenceTypeNode); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + } + + /* Instantiate variables and objects */ + if(head->nodeClass == UA_NODECLASS_VARIABLE || + head->nodeClass == UA_NODECLASS_VARIABLETYPE || + head->nodeClass == UA_NODECLASS_OBJECT) { + /* Get the type node */ + type = getNodeType(server, head); + if(!type) { + if(server->bootstrapNS0) + goto constructor; + logAddNode(&server->config.logger, session, &head->nodeId, + "Node type not found"); + retval = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + goto cleanup; + } + + retval = recursiveTypeCheckAddChildren(server, session, &node, type); + head = &node->head; /* Pointer might have changed */ + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + } + + /* Set variables to dynamic (source and server timestamps are meaningful) if + * they fulfill some conditions */ + if(node->head.nodeClass == UA_NODECLASS_VARIABLE) { + retval = checkSetIsDynamicVariable(server, session, nodeId); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + } + + /* Call the constructor(s) */ + constructor: + retval = recursiveCallConstructors(server, session, head, type); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, + "AddNode (%.*s): Calling the node constructor(s) " + "failed with status code %s", (int)nodeIdStr.length, + nodeIdStr.data, UA_StatusCode_name(retval))); + } + + cleanup: + if(type) + UA_NODESTORE_RELEASE(server, type); + if(retval != UA_STATUSCODE_GOOD) { + deleteNode(server, head->nodeId, true); + } + UA_NODESTORE_RELEASE(server, node); + return retval; +} + +static void +Operation_addNode(UA_Server *server, UA_Session *session, void *nodeContext, + const UA_AddNodesItem *item, UA_AddNodesResult *result) { + result->statusCode = + Operation_addNode_begin(server, session, nodeContext, item, &item->parentNodeId.nodeId, + &item->referenceTypeId, &result->addedNodeId); + if(result->statusCode != UA_STATUSCODE_GOOD) + return; + + /* AddNodes_finish */ + result->statusCode = AddNode_finish(server, session, &result->addedNodeId); + + /* If finishing failed, the node was deleted */ + if(result->statusCode != UA_STATUSCODE_GOOD) + UA_NodeId_clear(&result->addedNodeId); +} + +void +Service_AddNodes(UA_Server *server, UA_Session *session, + const UA_AddNodesRequest *request, + UA_AddNodesResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, "Processing AddNodesRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxNodesPerNodeManagement != 0 && + request->nodesToAddSize > server->config.maxNodesPerNodeManagement) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_addNode, NULL, + &request->nodesToAddSize, &UA_TYPES[UA_TYPES_ADDNODESITEM], + &response->resultsSize, &UA_TYPES[UA_TYPES_ADDNODESRESULT]); +} + +UA_StatusCode +addNode(UA_Server *server, const UA_NodeClass nodeClass, const UA_NodeId *requestedNewNodeId, + const UA_NodeId *parentNodeId, const UA_NodeId *referenceTypeId, + const UA_QualifiedName browseName, const UA_NodeId *typeDefinition, + const UA_NodeAttributes *attr, const UA_DataType *attributeType, + void *nodeContext, UA_NodeId *outNewNodeId) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Create the AddNodesItem */ + UA_AddNodesItem item; + UA_AddNodesItem_init(&item); + item.nodeClass = nodeClass; + item.requestedNewNodeId.nodeId = *requestedNewNodeId; + item.browseName = browseName; + item.parentNodeId.nodeId = *parentNodeId; + item.referenceTypeId = *referenceTypeId; + item.typeDefinition.nodeId = *typeDefinition; + UA_ExtensionObject_setValueNoDelete(&item.nodeAttributes, + (void*)(uintptr_t)attr, attributeType); + + /* Call the normal addnodes service */ + UA_AddNodesResult result; + UA_AddNodesResult_init(&result); + Operation_addNode(server, &server->adminSession, nodeContext, &item, &result); + if(outNewNodeId) + *outNewNodeId = result.addedNodeId; + else + UA_NodeId_clear(&result.addedNodeId); + return result.statusCode; +} + +UA_StatusCode +__UA_Server_addNode(UA_Server *server, const UA_NodeClass nodeClass, + const UA_NodeId *requestedNewNodeId, + const UA_NodeId *parentNodeId, + const UA_NodeId *referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId *typeDefinition, + const UA_NodeAttributes *attr, + const UA_DataType *attributeType, + void *nodeContext, UA_NodeId *outNewNodeId) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode reval = + addNode(server, nodeClass, requestedNewNodeId, parentNodeId, + referenceTypeId, browseName, typeDefinition, attr, + attributeType, nodeContext, outNewNodeId); + UA_UNLOCK(&server->serviceMutex); + return reval; +} + +UA_StatusCode +UA_Server_addNode_begin(UA_Server *server, const UA_NodeClass nodeClass, + const UA_NodeId requestedNewNodeId, const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, const void *attr, + const UA_DataType *attributeType, void *nodeContext, + UA_NodeId *outNewNodeId) { + UA_AddNodesItem item; + UA_AddNodesItem_init(&item); + item.nodeClass = nodeClass; + item.requestedNewNodeId.nodeId = requestedNewNodeId; + item.browseName = browseName; + item.typeDefinition.nodeId = typeDefinition; + UA_ExtensionObject_setValueNoDelete(&item.nodeAttributes, + (void*)(uintptr_t)attr, attributeType); + + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = + Operation_addNode_begin(server, &server->adminSession, nodeContext, &item, + &parentNodeId, &referenceTypeId, outNewNodeId); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +UA_Server_addNode_finish(UA_Server *server, const UA_NodeId nodeId) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = AddNode_finish(server, &server->adminSession, &nodeId); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/****************/ +/* Delete Nodes */ +/****************/ + +static void +Operation_deleteReference(UA_Server *server, UA_Session *session, void *context, + const UA_DeleteReferencesItem *item, UA_StatusCode *retval); + +/* Remove references to this node (in the other nodes) */ +static void +removeIncomingReferences(UA_Server *server, UA_Session *session, const UA_NodeHead *head) { + UA_DeleteReferencesItem item; + UA_DeleteReferencesItem_init(&item); + item.targetNodeId.nodeId = head->nodeId; + item.deleteBidirectional = false; + + UA_StatusCode dummy; + for(size_t i = 0; i < head->referencesSize; ++i) { + const UA_NodeReferenceKind *rk = &head->references[i]; + item.isForward = rk->isInverse; + item.referenceTypeId = + *UA_NODESTORE_GETREFERENCETYPEID(server, rk->referenceTypeIndex); + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + if(!UA_NodePointer_isLocal(t->targetId)) + continue; + item.sourceNodeId = UA_NodePointer_toNodeId(t->targetId); + Operation_deleteReference(server, session, NULL, &item, &dummy); + } + } +} + +/* A node is auto-deleted if all its hierarchical parents are being deleted */ +static UA_Boolean +hasParentRef(const UA_NodeHead *head, const UA_ReferenceTypeSet *refSet, + RefTree *refTree) { + for(size_t i = 0; i < head->referencesSize; i++) { + const UA_NodeReferenceKind *rk = &head->references[i]; + if(!rk->isInverse) + continue; + if(!UA_ReferenceTypeSet_contains(refSet, rk->referenceTypeIndex)) + continue; + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(rk, t))) { + if(!UA_NodePointer_isLocal(t->targetId)) + continue; + UA_NodeId tmpId = UA_NodePointer_toNodeId(t->targetId); + if(!RefTree_containsNodeId(refTree, &tmpId)) + return true; + } + } + return false; +} + +static void +deconstructNodeSet(UA_Server *server, UA_Session *session, + UA_ReferenceTypeSet *hierarchRefsSet, RefTree *refTree) { + /* Deconstruct the nodes based on the RefTree entries, parent nodes first */ + for(size_t i = 0; i < refTree->size; i++) { + const UA_Node *member = UA_NODESTORE_GET(server, &refTree->targets[i].nodeId); + if(!member) + continue; + + /* Call the type-level destructor */ + void *context = member->head.context; /* No longer needed after this function */ + if(member->head.nodeClass == UA_NODECLASS_OBJECT || + member->head.nodeClass == UA_NODECLASS_VARIABLE) { + const UA_Node *type = getNodeType(server, &member->head); + if(!type) + continue; + + /* Get the lifecycle */ + const UA_NodeTypeLifecycle *lifecycle; + if(member->head.nodeClass == UA_NODECLASS_OBJECT) + lifecycle = &type->objectTypeNode.lifecycle; + else + lifecycle = &type->variableTypeNode.lifecycle; + + /* Call the destructor */ + if(lifecycle->destructor) { + UA_UNLOCK(&server->serviceMutex); + lifecycle->destructor(server, + &session->sessionId, session->sessionHandle, + &type->head.nodeId, type->head.context, + &member->head.nodeId, &context); + UA_LOCK(&server->serviceMutex); + } + + /* Release the type node */ + UA_NODESTORE_RELEASE(server, type); + } + + /* Call the global destructor */ + if(server->config.nodeLifecycle.destructor) { + UA_UNLOCK(&server->serviceMutex); + server->config.nodeLifecycle.destructor(server, &session->sessionId, + session->sessionHandle, + &member->head.nodeId, context); + UA_LOCK(&server->serviceMutex); + } + + /* Release the node. Don't access the node context from here on. */ + UA_NODESTORE_RELEASE(server, member); + + /* Set the constructed flag to false */ + UA_Server_editNode(server, &server->adminSession, &refTree->targets[i].nodeId, + (UA_EditNodeCallback)setDeconstructedNode, NULL); + } +} + +/* The processNodeLayer function searches all children's of the head node and + * adds the children node to the RefTree if all incoming references sources are + * contained in the RefTree (No external references to this node --> node can be + * deleted) */ +static UA_StatusCode +autoDeleteChildren(UA_Server *server, UA_Session *session, RefTree *refTree, + const UA_ReferenceTypeSet *hierarchRefsSet, const UA_NodeHead *head){ + UA_StatusCode res = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < head->referencesSize; ++i) { + /* Check if the ReferenceType is hierarchical */ + UA_NodeReferenceKind *refs = &head->references[i]; + if(!UA_ReferenceTypeSet_contains(hierarchRefsSet, refs->referenceTypeIndex)) + continue; + + /* Check if the references are forward (to a child) */ + if(refs->isInverse) + continue; + + /* Loop over the references */ + const UA_ReferenceTarget *t = NULL; + while((t = UA_NodeReferenceKind_iterate(refs, t))) { + /* Get the child */ + const UA_Node *child = UA_NODESTORE_GETFROMREF(server, t->targetId); + if(!child) + continue; + + /* Only delete child nodes that have no other parent */ + if(!hasParentRef(&child->head, hierarchRefsSet, refTree)) + res = RefTree_addNodeId(refTree, &child->head.nodeId, NULL); + UA_NODESTORE_RELEASE(server, child); + if(res != UA_STATUSCODE_GOOD) + return res; + } + } + return UA_STATUSCODE_GOOD; +} + +/* Build up an ordered set (tree) of all nodes that can be deleted. Step through + * the ordered set in order to avoid recursion. */ +static UA_StatusCode +buildDeleteNodeSet(UA_Server *server, UA_Session *session, + const UA_ReferenceTypeSet *hierarchRefsSet, + const UA_NodeId *initial, UA_Boolean removeTargetRefs, + RefTree *refTree) { + /* Add the initial node to delete */ + UA_StatusCode res = RefTree_addNodeId(refTree, initial, NULL); + if(res != UA_STATUSCODE_GOOD) + return res; + + /* Find out which hierarchical children should also be deleted. We know + * there are no "external" ExpandedNodeId in the RefTree. */ + size_t pos = 0; + while(pos < refTree->size) { + const UA_Node *member = UA_NODESTORE_GET(server, &refTree->targets[pos].nodeId); + pos++; + if(!member) + continue; + res |= autoDeleteChildren(server, session, refTree, hierarchRefsSet, &member->head); + UA_NODESTORE_RELEASE(server, member); + } + return res; +} + +static void +deleteNodeSet(UA_Server *server, UA_Session *session, + const UA_ReferenceTypeSet *hierarchRefsSet, + UA_Boolean removeTargetRefs, RefTree *refTree) { + /* Delete the nodes based on the RefTree entries */ + for(size_t i = refTree->size; i > 0; --i) { + const UA_Node *member = UA_NODESTORE_GET(server, &refTree->targets[i-1].nodeId); + if(!member) + continue; + UA_NODESTORE_RELEASE(server, member); + if(removeTargetRefs) + removeIncomingReferences(server, session, &member->head); + UA_NODESTORE_REMOVE(server, &member->head.nodeId); + } +} + +static void +deleteNodeOperation(UA_Server *server, UA_Session *session, void *context, + const UA_DeleteNodesItem *item, UA_StatusCode *result) { + /* Do not check access for server */ + if(session != &server->adminSession && server->config.accessControl.allowDeleteNode) { + UA_UNLOCK(&server->serviceMutex); + if( !server->config.accessControl.allowDeleteNode(server, &server->config.accessControl, + &session->sessionId, session->sessionHandle, item)) { + UA_LOCK(&server->serviceMutex); + *result = UA_STATUSCODE_BADUSERACCESSDENIED; + return; + } + UA_LOCK(&server->serviceMutex); + } + + const UA_Node *node = UA_NODESTORE_GET(server, &item->nodeId); + if(!node) { + *result = UA_STATUSCODE_BADNODEIDUNKNOWN; + return; + } + + if(UA_Node_hasSubTypeOrInstances(&node->head)) { + UA_LOG_NODEID_INFO(&node->head.nodeId, + UA_LOG_INFO_SESSION(&server->config.logger, session, "DeleteNode (%.*s): " + "Cannot delete a type node with active instances or " + "subtypes", (int)nodeIdStr.length, nodeIdStr.data)); + UA_NODESTORE_RELEASE(server, node); + *result = UA_STATUSCODE_BADINTERNALERROR; + return; + } + + /* TODO: Check if the information model consistency is violated */ + /* TODO: Check if the node is a mandatory child of a parent */ + + /* Relase the node. Don't access the pointer after this! */ + UA_NODESTORE_RELEASE(server, node); + + /* A node can be referenced with hierarchical references from several + * parents in the information model. (But not in a circular way.) The + * hierarchical references are checked to see if a node can be deleted. + * Getting the type hierarchy can fail in case of low RAM. In that case the + * nodes are always deleted. */ + UA_ReferenceTypeSet hierarchRefsSet; + UA_NodeId hr = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES); + *result = referenceTypeIndices(server, &hr, &hierarchRefsSet, true); + if(*result != UA_STATUSCODE_GOOD) + return; + + /* The list of childs is needed for the deconstructing and deleting phase. + * Within the processNodeLayer we generate a RefTree based set of childs + * which can be deleted beside the parent node. */ + RefTree refTree; + *result = RefTree_init(&refTree); + if(*result != UA_STATUSCODE_GOOD) + return; + *result = buildDeleteNodeSet(server, session, &hierarchRefsSet, &item->nodeId, + item->deleteTargetReferences, &refTree); + if(*result != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SESSION(&server->config.logger, session, + "DeleteNode: Incomplete lookup of nodes. " + "Still deleting what we have."); + /* Continue, so the RefTree is cleaned up. Return the error message + * anyway. */ + } + + /* Deconstruct, then delete, then clean up the set */ + deconstructNodeSet(server, session, &hierarchRefsSet, &refTree); + deleteNodeSet(server, session, &hierarchRefsSet, + item->deleteTargetReferences, &refTree); + RefTree_clear(&refTree); +} + +void +Service_DeleteNodes(UA_Server *server, UA_Session *session, + const UA_DeleteNodesRequest *request, + UA_DeleteNodesResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing DeleteNodesRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxNodesPerNodeManagement != 0 && + request->nodesToDeleteSize > server->config.maxNodesPerNodeManagement) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)deleteNodeOperation, + NULL, &request->nodesToDeleteSize, + &UA_TYPES[UA_TYPES_DELETENODESITEM], + &response->resultsSize, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +UA_StatusCode +UA_Server_deleteNode(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean deleteReferences) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = deleteNode(server, nodeId, deleteReferences); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +deleteNode(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean deleteReferences) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_DeleteNodesItem item; + item.deleteTargetReferences = deleteReferences; + item.nodeId = nodeId; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + deleteNodeOperation(server, &server->adminSession, NULL, &item, &retval); + return retval; +} + +/******************/ +/* Add References */ +/******************/ + +struct AddNodeInfo { + UA_Byte refTypeIndex; + UA_Boolean isForward; + const UA_ExpandedNodeId *targetNodeId; + UA_UInt32 targetBrowseNameHash; +}; + +static UA_StatusCode +addOneWayReference(UA_Server *server, UA_Session *session, UA_Node *node, + const struct AddNodeInfo *info) { + return UA_Node_addReference(node, info->refTypeIndex, info->isForward, + info->targetNodeId, info->targetBrowseNameHash); +} + +static UA_StatusCode +deleteOneWayReference(UA_Server *server, UA_Session *session, UA_Node *node, + const UA_DeleteReferencesItem *item) { + const UA_Node *refType = UA_NODESTORE_GET(server, &item->referenceTypeId); + if(!refType) + return UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + if(refType->head.nodeClass != UA_NODECLASS_REFERENCETYPE) { + UA_NODESTORE_RELEASE(server, refType); + return UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + } + UA_Byte refTypeIndex = refType->referenceTypeNode.referenceTypeIndex; + UA_NODESTORE_RELEASE(server, refType); + return UA_Node_deleteReference(node, refTypeIndex, item->isForward, &item->targetNodeId); +} + +static void +Operation_addReference(UA_Server *server, UA_Session *session, void *context, + const UA_AddReferencesItem *item, UA_StatusCode *retval) { + (void)context; + UA_assert(session); + + /* Check access rights */ + if(session != &server->adminSession && server->config.accessControl.allowAddReference) { + UA_UNLOCK(&server->serviceMutex); + if (!server->config.accessControl. + allowAddReference(server, &server->config.accessControl, + &session->sessionId, session->sessionHandle, item)) { + UA_LOCK(&server->serviceMutex); + *retval = UA_STATUSCODE_BADUSERACCESSDENIED; + return; + } + UA_LOCK(&server->serviceMutex); + } + + /* TODO: Currently no expandednodeids are allowed */ + if(item->targetServerUri.length > 0) { + *retval = UA_STATUSCODE_BADNOTIMPLEMENTED; + return; + } + + /* Check the ReferenceType and get the index */ + const UA_Node *refType = UA_NODESTORE_GET(server, &item->referenceTypeId); + if(!refType) { + *retval = UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + return; + } + if(refType->head.nodeClass != UA_NODECLASS_REFERENCETYPE) { + UA_NODESTORE_RELEASE(server, refType); + *retval = UA_STATUSCODE_BADREFERENCETYPEIDINVALID; + return; + } + UA_Byte refTypeIndex = refType->referenceTypeNode.referenceTypeIndex; + UA_NODESTORE_RELEASE(server, refType); + + /* Get the source and target node BrowseName hash */ + const UA_Node *targetNode = UA_NODESTORE_GET(server, &item->targetNodeId.nodeId); + if(!targetNode) { + *retval = UA_STATUSCODE_BADTARGETNODEIDINVALID; + return; + } + UA_UInt32 targetNameHash = UA_QualifiedName_hash(&targetNode->head.browseName); + UA_NODESTORE_RELEASE(server, targetNode); + + const UA_Node *sourceNode = UA_NODESTORE_GET(server, &item->sourceNodeId); + if(!sourceNode) { + *retval = UA_STATUSCODE_BADSOURCENODEIDINVALID; + return; + } + UA_UInt32 sourceNameHash = UA_QualifiedName_hash(&sourceNode->head.browseName); + UA_NODESTORE_RELEASE(server, sourceNode); + + /* Compute the BrowseName hash and release the target */ + struct AddNodeInfo info; + info.refTypeIndex = refTypeIndex; + info.targetNodeId = &item->targetNodeId; + info.isForward = item->isForward; + info.targetBrowseNameHash = targetNameHash; + + /* Add the first direction */ + *retval = UA_Server_editNode(server, session, &item->sourceNodeId, + (UA_EditNodeCallback)addOneWayReference, &info); + UA_Boolean firstExisted = false; + if(*retval == UA_STATUSCODE_BADDUPLICATEREFERENCENOTALLOWED) { + *retval = UA_STATUSCODE_GOOD; + firstExisted = true; + } + if(*retval != UA_STATUSCODE_GOOD) + return; + + /* Add the second direction */ + UA_ExpandedNodeId target2; + UA_ExpandedNodeId_init(&target2); + target2.nodeId = item->sourceNodeId; + info.targetNodeId = &target2; + info.isForward = !info.isForward; + info.targetBrowseNameHash = sourceNameHash; + *retval = UA_Server_editNode(server, session, &item->targetNodeId.nodeId, + (UA_EditNodeCallback)addOneWayReference, &info); + + /* Second direction existed already */ + if(*retval == UA_STATUSCODE_BADDUPLICATEREFERENCENOTALLOWED) { + /* Calculate common duplicate reference not allowed result and set bad + * result if BOTH directions already existed */ + if(firstExisted) { + *retval = UA_STATUSCODE_BADDUPLICATEREFERENCENOTALLOWED; + return; + } + *retval = UA_STATUSCODE_GOOD; + } + + /* Remove first direction if the second direction failed */ + if(*retval != UA_STATUSCODE_GOOD && !firstExisted) { + UA_DeleteReferencesItem deleteItem; + deleteItem.sourceNodeId = item->sourceNodeId; + deleteItem.referenceTypeId = item->referenceTypeId; + deleteItem.isForward = item->isForward; + deleteItem.targetNodeId = item->targetNodeId; + deleteItem.deleteBidirectional = false; + /* Ignore status code */ + UA_Server_editNode(server, session, &item->sourceNodeId, + (UA_EditNodeCallback)deleteOneWayReference, &deleteItem); + } +} + +void +Service_AddReferences(UA_Server *server, UA_Session *session, + const UA_AddReferencesRequest *request, + UA_AddReferencesResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing AddReferencesRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_assert(session); + + if(server->config.maxNodesPerNodeManagement != 0 && + request->referencesToAddSize > server->config.maxNodesPerNodeManagement) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_addReference, + NULL, &request->referencesToAddSize, + &UA_TYPES[UA_TYPES_ADDREFERENCESITEM], + &response->resultsSize, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +UA_StatusCode +UA_Server_addReference(UA_Server *server, const UA_NodeId sourceId, + const UA_NodeId refTypeId, + const UA_ExpandedNodeId targetId, + UA_Boolean isForward) { + UA_AddReferencesItem item; + UA_AddReferencesItem_init(&item); + item.sourceNodeId = sourceId; + item.referenceTypeId = refTypeId; + item.isForward = isForward; + item.targetNodeId = targetId; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_LOCK(&server->serviceMutex); + Operation_addReference(server, &server->adminSession, NULL, &item, &retval); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/*********************/ +/* Delete References */ +/*********************/ + +static void +Operation_deleteReference(UA_Server *server, UA_Session *session, void *context, + const UA_DeleteReferencesItem *item, UA_StatusCode *retval) { + /* Do not check access for server */ + if(session != &server->adminSession && server->config.accessControl.allowDeleteReference) { + UA_UNLOCK(&server->serviceMutex); + if (!server->config.accessControl. + allowDeleteReference(server, &server->config.accessControl, + &session->sessionId, session->sessionHandle, item)){ + UA_LOCK(&server->serviceMutex); + *retval = UA_STATUSCODE_BADUSERACCESSDENIED; + return; + } + UA_LOCK(&server->serviceMutex); + } + + // TODO: Check consistency constraints, remove the references. + *retval = UA_Server_editNode(server, session, &item->sourceNodeId, + (UA_EditNodeCallback)deleteOneWayReference, + /* cast away const qualifier because callback uses it anyway */ + (UA_DeleteReferencesItem *)(uintptr_t)item); + if(*retval != UA_STATUSCODE_GOOD) + return; + + if(!item->deleteBidirectional || item->targetNodeId.serverIndex != 0) + return; + + UA_DeleteReferencesItem secondItem; + UA_DeleteReferencesItem_init(&secondItem); + secondItem.isForward = !item->isForward; + secondItem.sourceNodeId = item->targetNodeId.nodeId; + secondItem.targetNodeId.nodeId = item->sourceNodeId; + secondItem.referenceTypeId = item->referenceTypeId; + *retval = UA_Server_editNode(server, session, &secondItem.sourceNodeId, + (UA_EditNodeCallback)deleteOneWayReference, + &secondItem); +} + +void +Service_DeleteReferences(UA_Server *server, UA_Session *session, + const UA_DeleteReferencesRequest *request, + UA_DeleteReferencesResponse *response) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Processing DeleteReferencesRequest"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(server->config.maxNodesPerNodeManagement != 0 && + request->referencesToDeleteSize > server->config.maxNodesPerNodeManagement) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYOPERATIONS; + return; + } + + response->responseHeader.serviceResult = + UA_Server_processServiceOperations(server, session, + (UA_ServiceOperation)Operation_deleteReference, + NULL, &request->referencesToDeleteSize, + &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM], + &response->resultsSize, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +UA_StatusCode +UA_Server_deleteReference(UA_Server *server, const UA_NodeId sourceNodeId, + const UA_NodeId referenceTypeId, UA_Boolean isForward, + const UA_ExpandedNodeId targetNodeId, + UA_Boolean deleteBidirectional) { + UA_DeleteReferencesItem item; + item.sourceNodeId = sourceNodeId; + item.referenceTypeId = referenceTypeId; + item.isForward = isForward; + item.targetNodeId = targetNodeId; + item.deleteBidirectional = deleteBidirectional; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_LOCK(&server->serviceMutex); + Operation_deleteReference(server, &server->adminSession, NULL, &item, &retval); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/**********************/ +/* Set Value Callback */ +/**********************/ + +static UA_StatusCode +setValueCallback(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_ValueCallback *callback) { + if(node->head.nodeClass != UA_NODECLASS_VARIABLE) + return UA_STATUSCODE_BADNODECLASSINVALID; + node->value.data.callback = *callback; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_setVariableNode_valueCallback(UA_Server *server, + const UA_NodeId nodeId, + const UA_ValueCallback callback) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = UA_Server_editNode(server, &server->adminSession, &nodeId, + (UA_EditNodeCallback)setValueCallback, + /* cast away const because callback uses const anyway */ + (UA_ValueCallback *)(uintptr_t) &callback); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/***************************************************/ +/* Special Handling of Variables with Data Sources */ +/***************************************************/ + +UA_StatusCode +UA_Server_addDataSourceVariableNode(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, const UA_NodeId typeDefinition, + const UA_VariableAttributes attr, const UA_DataSource dataSource, + void *nodeContext, UA_NodeId *outNewNodeId) { + UA_AddNodesItem item; + UA_AddNodesItem_init(&item); + item.nodeClass = UA_NODECLASS_VARIABLE; + item.requestedNewNodeId.nodeId = requestedNewNodeId; + item.browseName = browseName; + UA_ExpandedNodeId typeDefinitionId; + UA_ExpandedNodeId_init(&typeDefinitionId); + typeDefinitionId.nodeId = typeDefinition; + item.typeDefinition = typeDefinitionId; + UA_ExtensionObject_setValueNoDelete(&item.nodeAttributes, (void*)(uintptr_t)&attr, + &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]); + UA_NodeId newNodeId; + if(!outNewNodeId) { + newNodeId = UA_NODEID_NULL; + outNewNodeId = &newNodeId; + } + + UA_LOCK(&server->serviceMutex); + /* Create the node and add it to the nodestore */ + UA_StatusCode retval = AddNode_raw(server, &server->adminSession, nodeContext, + &item, outNewNodeId); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Set the data source */ + retval = setVariableNode_dataSource(server, *outNewNodeId, dataSource); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Typecheck and add references to parent and type definition */ + retval = AddNode_addRefs(server, &server->adminSession, outNewNodeId, &parentNodeId, + &referenceTypeId, &typeDefinition); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Call the constructors */ + retval = AddNode_finish(server, &server->adminSession, outNewNodeId); + + cleanup: + UA_UNLOCK(&server->serviceMutex); + if(outNewNodeId == &newNodeId) + UA_NodeId_clear(&newNodeId); + + return retval; +} + +static UA_StatusCode +setDataSource(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_DataSource *dataSource) { + if(node->head.nodeClass != UA_NODECLASS_VARIABLE) + return UA_STATUSCODE_BADNODECLASSINVALID; + if(node->valueSource == UA_VALUESOURCE_DATA) + UA_DataValue_clear(&node->value.data.value); + node->value.dataSource = *dataSource; + node->valueSource = UA_VALUESOURCE_DATASOURCE; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +setVariableNode_dataSource(UA_Server *server, const UA_NodeId nodeId, + const UA_DataSource dataSource) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + return UA_Server_editNode(server, &server->adminSession, &nodeId, + (UA_EditNodeCallback)setDataSource, + /* casting away const because callback casts it back anyway */ + (UA_DataSource *) (uintptr_t)&dataSource); +} + +UA_StatusCode +UA_Server_setVariableNode_dataSource(UA_Server *server, const UA_NodeId nodeId, + const UA_DataSource dataSource) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = setVariableNode_dataSource(server, nodeId, dataSource); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/******************************/ +/* Set External Value Source */ +/******************************/ +static UA_StatusCode +setExternalValueSource(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_ValueBackend *externalValueSource) { + if(node->head.nodeClass != UA_NODECLASS_VARIABLE) + return UA_STATUSCODE_BADNODECLASSINVALID; + node->valueBackend.backendType = UA_VALUEBACKENDTYPE_EXTERNAL; + node->valueBackend.backend.external.value = externalValueSource->backend.external.value; + node->valueBackend.backend.external.callback.notificationRead = externalValueSource->backend.external.callback.notificationRead; + node->valueBackend.backend.external.callback.userWrite = externalValueSource->backend.external.callback.userWrite; + return UA_STATUSCODE_GOOD; +} + +/****************************/ +/* Set Data Source Callback */ +/****************************/ +static UA_StatusCode +setDataSourceCallback(UA_Server *server, UA_Session *session, + UA_VariableNode *node, const UA_DataSource *dataSource) { + if(node->head.nodeClass != UA_NODECLASS_VARIABLE) + return UA_STATUSCODE_BADNODECLASSINVALID; + node->valueBackend.backendType = UA_VALUEBACKENDTYPE_DATA_SOURCE_CALLBACK; + node->valueBackend.backend.dataSource.ua_read = dataSource->ua_read; + node->valueBackend.backend.dataSource.ua_write = dataSource->ua_write; + return UA_STATUSCODE_GOOD; +} + +/**********************/ +/* Set Value Backend */ +/**********************/ + +UA_StatusCode +UA_Server_setVariableNode_valueBackend(UA_Server *server, const UA_NodeId nodeId, + const UA_ValueBackend valueBackend){ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_LOCK(&server->serviceMutex); + switch(valueBackend.backendType){ + case UA_VALUEBACKENDTYPE_NONE: + return UA_STATUSCODE_BADCONFIGURATIONERROR; + case UA_VALUEBACKENDTYPE_DATA_SOURCE_CALLBACK: + retval = UA_Server_editNode(server, &server->adminSession, &nodeId, + (UA_EditNodeCallback) setDataSourceCallback, + (UA_DataSource *)(uintptr_t) &valueBackend.backend.dataSource); + break; + case UA_VALUEBACKENDTYPE_INTERNAL: + break; + case UA_VALUEBACKENDTYPE_EXTERNAL: + retval = UA_Server_editNode(server, &server->adminSession, &nodeId, + (UA_EditNodeCallback) setExternalValueSource, + /* cast away const because callback uses const anyway */ + (UA_ValueCallback *)(uintptr_t) &valueBackend); + break; + } + + + // UA_StatusCode retval = UA_Server_editNode(server, &server->adminSession, &nodeId, + // (UA_EditNodeCallback)setValueCallback, + /* cast away const because callback uses const anyway */ + // (UA_ValueCallback *)(uintptr_t) &callback); + + + UA_UNLOCK(&server->serviceMutex); + return retval; +} + + +/************************************/ +/* Special Handling of Method Nodes */ +/************************************/ + +#ifdef UA_ENABLE_METHODCALLS + +static const UA_NodeId hasproperty = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASPROPERTY}}; +static const UA_NodeId propertytype = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_PROPERTYTYPE}}; + +static UA_StatusCode +UA_Server_addMethodNodeEx_finish(UA_Server *server, const UA_NodeId nodeId, UA_MethodCallback method, + const size_t inputArgumentsSize, const UA_Argument *inputArguments, + const UA_NodeId inputArgumentsRequestedNewNodeId, + UA_NodeId *inputArgumentsOutNewNodeId, + const size_t outputArgumentsSize, const UA_Argument *outputArguments, + const UA_NodeId outputArgumentsRequestedNewNodeId, + UA_NodeId *outputArgumentsOutNewNodeId) { + /* Browse to see which argument nodes exist */ + UA_BrowseDescription bd; + UA_BrowseDescription_init(&bd); + bd.nodeId = nodeId; + bd.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HASPROPERTY); + bd.includeSubtypes = false; + bd.browseDirection = UA_BROWSEDIRECTION_FORWARD; + bd.nodeClassMask = UA_NODECLASS_VARIABLE; + bd.resultMask = UA_BROWSERESULTMASK_BROWSENAME; + + UA_BrowseResult br; + UA_BrowseResult_init(&br); + UA_UInt32 maxrefs = 0; + Operation_Browse(server, &server->adminSession, &maxrefs, &bd, &br); + + UA_StatusCode retval = br.statusCode; + if(retval != UA_STATUSCODE_GOOD) { + deleteNode(server, nodeId, true); + UA_BrowseResult_clear(&br); + return retval; + } + + /* Filter out the argument nodes */ + UA_NodeId inputArgsId = UA_NODEID_NULL; + UA_NodeId outputArgsId = UA_NODEID_NULL; + const UA_QualifiedName inputArgsName = UA_QUALIFIEDNAME(0, "InputArguments"); + const UA_QualifiedName outputArgsName = UA_QUALIFIEDNAME(0, "OutputArguments"); + for(size_t i = 0; i < br.referencesSize; i++) { + UA_ReferenceDescription *rd = &br.references[i]; + if(rd->browseName.namespaceIndex == 0 && + UA_String_equal(&rd->browseName.name, &inputArgsName.name)) + inputArgsId = rd->nodeId.nodeId; + else if(rd->browseName.namespaceIndex == 0 && + UA_String_equal(&rd->browseName.name, &outputArgsName.name)) + outputArgsId = rd->nodeId.nodeId; + } + + /* Add the Input Arguments VariableNode */ + if(inputArgumentsSize > 0 && UA_NodeId_isNull(&inputArgsId)) { + UA_VariableAttributes attr = UA_VariableAttributes_default; + char *name = "InputArguments"; + attr.displayName = UA_LOCALIZEDTEXT("", name); + attr.dataType = UA_TYPES[UA_TYPES_ARGUMENT].typeId; + attr.valueRank = UA_VALUERANK_ONE_DIMENSION; + UA_UInt32 inputArgsSize32 = (UA_UInt32)inputArgumentsSize; + attr.arrayDimensions = &inputArgsSize32; + attr.arrayDimensionsSize = 1; + UA_Variant_setArray(&attr.value, (void *)(uintptr_t)inputArguments, + inputArgumentsSize, &UA_TYPES[UA_TYPES_ARGUMENT]); + retval = addNode(server, UA_NODECLASS_VARIABLE, &inputArgumentsRequestedNewNodeId, + &nodeId, &hasproperty, UA_QUALIFIEDNAME(0, name), + &propertytype, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES], + NULL, &inputArgsId); + if(retval != UA_STATUSCODE_GOOD) + goto error; + } + + /* Add the Output Arguments VariableNode */ + if(outputArgumentsSize > 0 && UA_NodeId_isNull(&outputArgsId)) { + UA_VariableAttributes attr = UA_VariableAttributes_default; + char *name = "OutputArguments"; + attr.displayName = UA_LOCALIZEDTEXT("", name); + attr.dataType = UA_TYPES[UA_TYPES_ARGUMENT].typeId; + attr.valueRank = UA_VALUERANK_ONE_DIMENSION; + UA_UInt32 outputArgsSize32 = (UA_UInt32)outputArgumentsSize; + attr.arrayDimensions = &outputArgsSize32; + attr.arrayDimensionsSize = 1; + UA_Variant_setArray(&attr.value, (void *)(uintptr_t)outputArguments, + outputArgumentsSize, &UA_TYPES[UA_TYPES_ARGUMENT]); + retval = addNode(server, UA_NODECLASS_VARIABLE, &outputArgumentsRequestedNewNodeId, + &nodeId, &hasproperty, UA_QUALIFIEDNAME(0, name), + &propertytype, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES], + NULL, &outputArgsId); + if(retval != UA_STATUSCODE_GOOD) + goto error; + } + + retval = setMethodNode_callback(server, nodeId, method); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + /* Call finish to add the parent reference */ + retval = AddNode_finish(server, &server->adminSession, &nodeId); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + if(inputArgumentsOutNewNodeId != NULL) { + UA_NodeId_copy(&inputArgsId, inputArgumentsOutNewNodeId); + } + if(outputArgumentsOutNewNodeId != NULL) { + UA_NodeId_copy(&outputArgsId, outputArgumentsOutNewNodeId); + } + UA_BrowseResult_clear(&br); + return retval; + +error: + deleteNode(server, nodeId, true); + deleteNode(server, inputArgsId, true); + deleteNode(server, outputArgsId, true); + UA_BrowseResult_clear(&br); + return retval; +} + +UA_StatusCode +UA_Server_addMethodNode_finish(UA_Server *server, const UA_NodeId nodeId, + UA_MethodCallback method, + size_t inputArgumentsSize, const UA_Argument* inputArguments, + size_t outputArgumentsSize, const UA_Argument* outputArguments) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = UA_Server_addMethodNodeEx_finish(server, nodeId, method, + inputArgumentsSize, inputArguments, UA_NODEID_NULL, NULL, + outputArgumentsSize, outputArguments, UA_NODEID_NULL, NULL); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +UA_StatusCode +UA_Server_addMethodNodeEx(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_MethodAttributes attr, UA_MethodCallback method, + size_t inputArgumentsSize, const UA_Argument *inputArguments, + const UA_NodeId inputArgumentsRequestedNewNodeId, + UA_NodeId *inputArgumentsOutNewNodeId, + size_t outputArgumentsSize, const UA_Argument *outputArguments, + const UA_NodeId outputArgumentsRequestedNewNodeId, + UA_NodeId *outputArgumentsOutNewNodeId, + void *nodeContext, UA_NodeId *outNewNodeId) { + UA_AddNodesItem item; + UA_AddNodesItem_init(&item); + item.nodeClass = UA_NODECLASS_METHOD; + item.requestedNewNodeId.nodeId = requestedNewNodeId; + item.browseName = browseName; + UA_ExtensionObject_setValueNoDelete(&item.nodeAttributes, (void*)(uintptr_t)&attr, + &UA_TYPES[UA_TYPES_METHODATTRIBUTES]); + UA_NodeId newId; + if(!outNewNodeId) { + UA_NodeId_init(&newId); + outNewNodeId = &newId; + } + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = Operation_addNode_begin(server, &server->adminSession, + nodeContext, &item, &parentNodeId, + &referenceTypeId, outNewNodeId); + if(retval != UA_STATUSCODE_GOOD) { + UA_UNLOCK(&server->serviceMutex); + return retval; + } + + retval = UA_Server_addMethodNodeEx_finish(server, *outNewNodeId, method, + inputArgumentsSize, inputArguments, + inputArgumentsRequestedNewNodeId, + inputArgumentsOutNewNodeId, + outputArgumentsSize, outputArguments, + outputArgumentsRequestedNewNodeId, + outputArgumentsOutNewNodeId); + UA_UNLOCK(&server->serviceMutex); + if(outNewNodeId == &newId) + UA_NodeId_clear(&newId); + return retval; +} + +static UA_StatusCode +editMethodCallback(UA_Server *server, UA_Session* session, + UA_Node *node, UA_MethodCallback methodCallback) { + if(node->head.nodeClass != UA_NODECLASS_METHOD) + return UA_STATUSCODE_BADNODECLASSINVALID; + node->methodNode.method = methodCallback; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +setMethodNode_callback(UA_Server *server, + const UA_NodeId methodNodeId, + UA_MethodCallback methodCallback) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + return UA_Server_editNode(server, &server->adminSession, &methodNodeId, + (UA_EditNodeCallback)editMethodCallback, + (void*)(uintptr_t)methodCallback); +} + +UA_StatusCode +UA_Server_setMethodNodeCallback(UA_Server *server, + const UA_NodeId methodNodeId, + UA_MethodCallback methodCallback) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retVal = setMethodNode_callback(server, methodNodeId, methodCallback); + UA_UNLOCK(&server->serviceMutex); + return retVal; +} + +UA_StatusCode +UA_Server_getMethodNodeCallback(UA_Server *server, + const UA_NodeId methodNodeId, + UA_MethodCallback *outMethodCallback) { + UA_LOCK(&server->serviceMutex); + const UA_Node *node = UA_NODESTORE_GET(server, &methodNodeId); + if(!node) { + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADNODEIDUNKNOWN; + } + + if(node->head.nodeClass != UA_NODECLASS_METHOD) { + UA_NODESTORE_RELEASE(server, node); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADNODECLASSINVALID; + } + + *outMethodCallback = node->methodNode.method; + UA_NODESTORE_RELEASE(server, node); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_GOOD; +} + +#endif + +/************************/ +/* Lifecycle Management */ +/************************/ + +void UA_EXPORT +UA_Server_setAdminSessionContext(UA_Server *server, + void *context) { + server->adminSession.sessionHandle = context; +} + +static UA_StatusCode +setNodeTypeLifecycle(UA_Server *server, UA_Session *session, + UA_Node *node, UA_NodeTypeLifecycle *lifecycle) { + if(node->head.nodeClass == UA_NODECLASS_OBJECTTYPE) { + node->objectTypeNode.lifecycle = *lifecycle; + } else if(node->head.nodeClass == UA_NODECLASS_VARIABLETYPE) { + node->variableTypeNode.lifecycle = *lifecycle; + } else { + return UA_STATUSCODE_BADNODECLASSINVALID; + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_setNodeTypeLifecycle(UA_Server *server, UA_NodeId nodeId, + UA_NodeTypeLifecycle lifecycle) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode retval = UA_Server_editNode(server, &server->adminSession, &nodeId, + (UA_EditNodeCallback)setNodeTypeLifecycle, + &lifecycle); + UA_UNLOCK(&server->serviceMutex); + return retval; +} + +/**** amalgamated original file "/src/server/ua_services_discovery_multicast.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Thomas Stalder, Blue Time Concept SA + */ + + +#if defined(UA_ENABLE_DISCOVERY) && defined(UA_ENABLE_DISCOVERY_MULTICAST) + +#if UA_MULTITHREADING >= 100 + +static void * +multicastWorkerLoop(UA_Server *server) { + struct timeval next_sleep = {.tv_sec = 0, .tv_usec = 0}; + volatile UA_Boolean *running = &server->discoveryManager.mdnsRunning; + fd_set fds; + + while(*running) { + FD_ZERO(&fds); + UA_fd_set(server->discoveryManager.mdnsSocket, &fds); + select(server->discoveryManager.mdnsSocket + 1, &fds, 0, 0, &next_sleep); + + if(!*running) + break; + + unsigned short retVal = + mdnsd_step(server->discoveryManager.mdnsDaemon, server->discoveryManager.mdnsSocket, + FD_ISSET(server->discoveryManager.mdnsSocket, &fds), true, &next_sleep); + if(retVal == 1) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast error: Can not read from socket. %s", errno_str)); + break; + } else if (retVal == 2) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast error: Can not write to socket. %s", errno_str)); + break; + } + } + return NULL; +} + +static UA_StatusCode +multicastListenStart(UA_Server* server) { + int err = pthread_create(&server->discoveryManager.mdnsThread, NULL, + (void* (*)(void*))multicastWorkerLoop, server); + if(err != 0) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast error: Can not create multicast thread."); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +multicastListenStop(UA_Server* server) { + mdnsd_shutdown(server->discoveryManager.mdnsDaemon); + // wake up select + if (write(server->discoveryManager.mdnsSocket, "\0", 1)) { + // TODO: if makes no sense here? + } // TODO: move to arch? + if (pthread_join(server->discoveryManager.mdnsThread, NULL)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, "Multicast error: Can not stop thread."); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + return UA_STATUSCODE_BADNOTIMPLEMENTED; +} + +# endif /* UA_MULTITHREADING */ + +static UA_StatusCode +addMdnsRecordForNetworkLayer(UA_Server *server, const UA_String *appName, + const UA_ServerNetworkLayer* nl) { + UA_String hostname = UA_STRING_NULL; + UA_UInt16 port = 4840; + UA_String path = UA_STRING_NULL; + UA_StatusCode retval = UA_parseEndpointUrl(&nl->discoveryUrl, &hostname, + &port, &path); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_NETWORK, + "Server url is invalid: %.*s", + (int)nl->discoveryUrl.length, nl->discoveryUrl.data); + return retval; + } + + retval = UA_Discovery_addRecord(server, appName, &hostname, port, + &path, UA_DISCOVERY_TCP, true, + server->config.mdnsConfig.serverCapabilities, + server->config.mdnsConfig.serverCapabilitiesSize, + true); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_NETWORK, + "Cannot add mDNS Record: %s", + UA_StatusCode_name(retval)); + return retval; + } + return UA_STATUSCODE_GOOD; +} + +void startMulticastDiscoveryServer(UA_Server *server) { + UA_String *appName = &server->config.mdnsConfig.mdnsServerName; + for(size_t i = 0; i < server->config.networkLayersSize; i++) + addMdnsRecordForNetworkLayer(server, appName, &server->config.networkLayers[i]); + + /* find any other server on the net */ + UA_Discovery_multicastQuery(server); + +#if UA_MULTITHREADING >= 100 + multicastListenStart(server); +# endif +} + +void +stopMulticastDiscoveryServer(UA_Server *server) { + if (!server->discoveryManager.mdnsDaemon) + return; + + for (size_t i=0; iconfig.networkLayersSize; i++) { + + UA_String hostname = UA_STRING_NULL; + UA_String path = UA_STRING_NULL; + UA_UInt16 port = 0; + + UA_StatusCode retval = UA_parseEndpointUrl(&server->config.networkLayers[i].discoveryUrl, &hostname, + &port, &path); + + if (retval != UA_STATUSCODE_GOOD) + continue; + + UA_Discovery_removeRecord(server, &server->config.mdnsConfig.mdnsServerName, + &hostname, port, true); + + } + +#if UA_MULTITHREADING >= 100 + multicastListenStop(server); +# else + // send out last package with TTL = 0 + iterateMulticastDiscoveryServer(server, NULL, false); +# endif +} + +/* All filter criteria must be fulfilled in the list entry. The comparison is case + * insensitive. + * @returns true if the entry matches the filter. False if the filter does not match. + * */ +static UA_Boolean +entryMatchesCapabilityFilter(size_t serverCapabilityFilterSize, UA_String *serverCapabilityFilter, + serverOnNetwork_list_entry* current) { + // if the entry has less capabilities defined than the filter, there's no match + if (serverCapabilityFilterSize > current->serverOnNetwork.serverCapabilitiesSize) + return UA_FALSE; + for(size_t i = 0; i < serverCapabilityFilterSize; i++) { + UA_Boolean capabilityFound = UA_FALSE; + for(size_t j = 0; j < current->serverOnNetwork.serverCapabilitiesSize; j++) { + if(UA_String_equal_ignorecase(&serverCapabilityFilter[i], + ¤t->serverOnNetwork.serverCapabilities[j])) { + capabilityFound = UA_TRUE; + break; + } + } + if (!capabilityFound) + return UA_FALSE; // entry does not match capability + } + return UA_TRUE; +} + +void Service_FindServersOnNetwork(UA_Server *server, UA_Session *session, + const UA_FindServersOnNetworkRequest *request, + UA_FindServersOnNetworkResponse *response) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if (!server->config.mdnsEnabled) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOTIMPLEMENTED; + return; + } + + /* Set LastCounterResetTime */ + UA_DateTime_copy(&server->discoveryManager.serverOnNetworkRecordIdLastReset, + &response->lastCounterResetTime); + + /* Compute the max number of records to return */ + UA_UInt32 recordCount = 0; + if(request->startingRecordId < server->discoveryManager.serverOnNetworkRecordIdCounter) + recordCount = server->discoveryManager.serverOnNetworkRecordIdCounter - + request->startingRecordId; + if(request->maxRecordsToReturn && recordCount > request->maxRecordsToReturn) + recordCount = UA_MIN(recordCount, request->maxRecordsToReturn); + if(recordCount == 0) { + response->serversSize = 0; + return; + } + + /* Iterate over all records and add to filtered list */ + UA_UInt32 filteredCount = 0; + UA_STACKARRAY(UA_ServerOnNetwork*, filtered, recordCount); + serverOnNetwork_list_entry* current; + LIST_FOREACH(current, &server->discoveryManager.serverOnNetwork, pointers) { + if(filteredCount >= recordCount) + break; + if(current->serverOnNetwork.recordId < request->startingRecordId) + continue; + if(!entryMatchesCapabilityFilter(request->serverCapabilityFilterSize, + request->serverCapabilityFilter, current)) + continue; + filtered[filteredCount++] = ¤t->serverOnNetwork; + } + + if(filteredCount == 0) + return; + + /* Allocate the array for the response */ + response->servers = + (UA_ServerOnNetwork*)UA_malloc(sizeof(UA_ServerOnNetwork)*filteredCount); + if(!response->servers) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return; + } + response->serversSize = filteredCount; + + /* Copy the server names */ + for(size_t i = 0; i < filteredCount; i++) + UA_ServerOnNetwork_copy(filtered[i], &response->servers[filteredCount-i-1]); +} + +void +UA_Server_updateMdnsForDiscoveryUrl(UA_Server *server, const UA_String *serverName, + const UA_MdnsDiscoveryConfiguration *mdnsConfig, + const UA_String *discoveryUrl, + UA_Boolean isOnline, UA_Boolean updateTxt) { + UA_String hostname = UA_STRING_NULL; + UA_UInt16 port = 4840; + UA_String path = UA_STRING_NULL; + UA_StatusCode retval = UA_parseEndpointUrl(discoveryUrl, &hostname, &port, &path); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_NETWORK, + "Server url invalid: %.*s", + (int)discoveryUrl->length, discoveryUrl->data); + return; + } + + if(!isOnline) { + UA_StatusCode removeRetval = + UA_Discovery_removeRecord(server, serverName, &hostname, + port, updateTxt); + if(removeRetval != UA_STATUSCODE_GOOD) + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Could not remove mDNS record for hostname %.*s.", + (int)serverName->length, serverName->data); + return; + } + + UA_String *capabilities = NULL; + size_t capabilitiesSize = 0; + if(mdnsConfig) { + capabilities = mdnsConfig->serverCapabilities; + capabilitiesSize = mdnsConfig->serverCapabilitiesSize; + } + + UA_StatusCode addRetval = + UA_Discovery_addRecord(server, serverName, &hostname, + port, &path, UA_DISCOVERY_TCP, updateTxt, + capabilities, capabilitiesSize, + false); + if(addRetval != UA_STATUSCODE_GOOD) + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Could not add mDNS record for hostname %.*s.", + (int)serverName->length, serverName->data); +} + +void +UA_Server_setServerOnNetworkCallback(UA_Server *server, + UA_Server_serverOnNetworkCallback cb, + void* data) { + UA_LOCK(&server->serviceMutex); + server->discoveryManager.serverOnNetworkCallback = cb; + server->discoveryManager.serverOnNetworkCallbackData = data; + UA_UNLOCK(&server->serviceMutex); +} + +static void +UA_Discovery_multicastConflict(char *name, int type, void *arg) { + // cppcheck-suppress unreadVariable + UA_Server *server = (UA_Server*) arg; + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS name conflict detected: " + "'%s' for type %d", name, type); +} + +/* Create a service domain with the format [servername]-[hostname]._opcua-tcp._tcp.local. */ +static void +createFullServiceDomain(char *outServiceDomain, size_t maxLen, + const UA_String *servername, const UA_String *hostname) { + size_t hostnameLen = hostname->length; + size_t servernameLen = servername->length; + + maxLen -= 24; /* the length we have remaining before the opc ua postfix and + * the trailing zero */ + + /* Can we use hostname and servername with full length? */ + if(hostnameLen + servernameLen + 1 > maxLen) { + if(servernameLen + 2 > maxLen) { + servernameLen = maxLen; + hostnameLen = 0; + } else { + hostnameLen = maxLen - servernameLen - 1; + } + } + + size_t offset = 0; + if (hostnameLen > 0) { + UA_snprintf(outServiceDomain, maxLen + 1, "%.*s-%.*s", + (int) servernameLen, (char *) servername->data, + (int) hostnameLen, (char *) hostname->data); + offset = servernameLen + hostnameLen + 1; + //replace all dots with minus. Otherwise mDNS is not valid + for (size_t i=servernameLen+1; idata); + offset = servernameLen; + } + UA_snprintf(&outServiceDomain[offset], 24, "._opcua-tcp._tcp.local."); +} + +/* Check if mDNS already has an entry for given hostname and port combination */ +static UA_Boolean +UA_Discovery_recordExists(UA_Server* server, const char* fullServiceDomain, + unsigned short port, const UA_DiscoveryProtocol protocol) { + // [servername]-[hostname]._opcua-tcp._tcp.local. 86400 IN SRV 0 5 port [hostname]. + mdns_record_t *r = mdnsd_get_published(server->discoveryManager.mdnsDaemon, fullServiceDomain); + while(r) { + const mdns_answer_t *data = mdnsd_record_data(r); + if(data->type == QTYPE_SRV && (port == 0 || data->srv.port == port)) + return true; + r = mdnsd_record_next(r); + } + return false; +} + +static int +discovery_multicastQueryAnswer(mdns_answer_t *a, void *arg) { + UA_Server *server = (UA_Server*) arg; + if(a->type != QTYPE_PTR) + return 0; + + if(a->rdname == NULL) + return 0; + + /* Skip, if we already know about this server */ + UA_Boolean exists = + UA_Discovery_recordExists(server, a->rdname, 0, UA_DISCOVERY_TCP); + if(exists == true) + return 0; + + if(mdnsd_has_query(server->discoveryManager.mdnsDaemon, a->rdname)) + return 0; + + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "mDNS send query for: %s SRV&TXT %s", a->name, a->rdname); + + mdnsd_query(server->discoveryManager.mdnsDaemon, a->rdname, QTYPE_SRV, + discovery_multicastQueryAnswer, server); + mdnsd_query(server->discoveryManager.mdnsDaemon, a->rdname, QTYPE_TXT, + discovery_multicastQueryAnswer, server); + return 0; +} + +UA_StatusCode +UA_Discovery_multicastQuery(UA_Server* server) { + mdnsd_query(server->discoveryManager.mdnsDaemon, "_opcua-tcp._tcp.local.", + QTYPE_PTR,discovery_multicastQueryAnswer, server); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Discovery_addRecord(UA_Server *server, const UA_String *servername, + const UA_String *hostname, UA_UInt16 port, + const UA_String *path, const UA_DiscoveryProtocol protocol, + UA_Boolean createTxt, const UA_String* capabilites, + const size_t capabilitiesSize, + UA_Boolean isSelf) { + // we assume that the hostname is not an IP address, but a valid domain name + // It is required by the OPC UA spec (see Part 12, DiscoveryURL to DNS SRV mapping) + // to always use the hostname instead of the IP address + + if(capabilitiesSize > 0 && !capabilites) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + size_t hostnameLen = hostname->length; + size_t servernameLen = servername->length; + if(hostnameLen == 0 || servernameLen == 0) + return UA_STATUSCODE_BADOUTOFRANGE; + + // use a limit for the hostname length to make sure full string fits into 63 + // chars (limited by DNS spec) + if(hostnameLen+servernameLen + 1 > 63) { // include dash between servername-hostname + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS: Combination of hostname+servername exceeds " + "maximum of 62 chars. It will be truncated."); + } else if(hostnameLen > 63) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS: Hostname length exceeds maximum of 63 chars. " + "It will be truncated."); + } + + if(!server->discoveryManager.mdnsMainSrvAdded) { + mdns_record_t *r = + mdnsd_shared(server->discoveryManager.mdnsDaemon, "_services._dns-sd._udp.local.", + QTYPE_PTR, 600); + mdnsd_set_host(server->discoveryManager.mdnsDaemon, r, "_opcua-tcp._tcp.local."); + server->discoveryManager.mdnsMainSrvAdded = true; + } + + // [servername]-[hostname]._opcua-tcp._tcp.local. + char fullServiceDomain[63+24]; + createFullServiceDomain(fullServiceDomain, 63+24, servername, hostname); + + UA_Boolean exists = UA_Discovery_recordExists(server, fullServiceDomain, port, protocol); + if(exists == true) + return UA_STATUSCODE_GOOD; + + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS: add record for domain: %s", fullServiceDomain); + + + if (isSelf && server->discoveryManager.selfFqdnMdnsRecord.length == 0) { + server->discoveryManager.selfFqdnMdnsRecord = UA_STRING_ALLOC(fullServiceDomain); + if (!server->discoveryManager.selfFqdnMdnsRecord.data) + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + + struct serverOnNetwork_list_entry *listEntry; + // The servername is servername + hostname. It is the same which we get through mDNS and therefore we need to match servername + UA_StatusCode retval = UA_DiscoveryManager_addEntryToServersOnNetwork(server, fullServiceDomain, fullServiceDomain, + UA_MIN(63, (servernameLen+hostnameLen)+1), &listEntry); + if (retval != UA_STATUSCODE_GOOD && retval != UA_STATUSCODE_BADALREADYEXISTS) + return retval; + + // If entry is already in list, skip initialization of capabilities and txt+srv + if (retval != UA_STATUSCODE_BADALREADYEXISTS) { + // if capabilitiesSize is 0, then add default cap 'NA' + listEntry->serverOnNetwork.serverCapabilitiesSize = UA_MAX(1, capabilitiesSize); + listEntry->serverOnNetwork.serverCapabilities = + (UA_String *) UA_Array_new(listEntry->serverOnNetwork.serverCapabilitiesSize, &UA_TYPES[UA_TYPES_STRING]); + if (!listEntry->serverOnNetwork.serverCapabilities) + return UA_STATUSCODE_BADOUTOFMEMORY; + if (capabilitiesSize == 0) { + UA_String na; + na.length = 2; + na.data = (UA_Byte *) (uintptr_t) "NA"; + UA_String_copy(&na, &listEntry->serverOnNetwork.serverCapabilities[0]); + } else { + for (size_t i = 0; i < capabilitiesSize; i++) { + UA_String_copy(&capabilites[i], &listEntry->serverOnNetwork.serverCapabilities[i]); + } + } + + listEntry->txtSet = true; + + UA_STACKARRAY(char, newUrl, 10 + hostnameLen + 8 + path->length + 1); + UA_snprintf(newUrl, 10 + hostnameLen + 8 + path->length + 1, "opc.tcp://%.*s:%d%s%.*s", (int) hostnameLen, + hostname->data, port, path->length > 0 ? "/" : "", (int) path->length, path->data); + listEntry->serverOnNetwork.discoveryUrl = UA_String_fromChars(newUrl); + listEntry->srvSet = true; + } + + // _services._dns-sd._udp.local. PTR _opcua-tcp._tcp.local + + // check if there is already a PTR entry for the given service. + + // _opcua-tcp._tcp.local. PTR [servername]-[hostname]._opcua-tcp._tcp.local. + mdns_record_t *r = mdns_find_record(server->discoveryManager.mdnsDaemon, QTYPE_PTR, + "_opcua-tcp._tcp.local.", fullServiceDomain); + if(!r) { + r = mdnsd_shared(server->discoveryManager.mdnsDaemon, "_opcua-tcp._tcp.local.", QTYPE_PTR, 600); + mdnsd_set_host(server->discoveryManager.mdnsDaemon, r, fullServiceDomain); + } + + /* The first 63 characters of the hostname (or less) */ + size_t maxHostnameLen = UA_MIN(hostnameLen, 63); + char localDomain[65]; + memcpy(localDomain, hostname->data, maxHostnameLen); + localDomain[maxHostnameLen] = '.'; + localDomain[maxHostnameLen+1] = '\0'; + + // [servername]-[hostname]._opcua-tcp._tcp.local. 86400 IN SRV 0 5 port [hostname]. + r = mdnsd_unique(server->discoveryManager.mdnsDaemon, fullServiceDomain, QTYPE_SRV, 600, + UA_Discovery_multicastConflict, server); + mdnsd_set_srv(server->discoveryManager.mdnsDaemon, r, 0, 0, port, localDomain); + + // A/AAAA record for all ip addresses. + // [servername]-[hostname]._opcua-tcp._tcp.local. A [ip]. + // [hostname]. A [ip]. + mdns_set_address_record(server, fullServiceDomain, localDomain); + + // TXT record: [servername]-[hostname]._opcua-tcp._tcp.local. TXT path=/ caps=NA,DA,... + UA_STACKARRAY(char, pathChars, path->length + 1); + if(createTxt) { + if(path->length > 0) + memcpy(pathChars, path->data, path->length); + pathChars[path->length] = 0; + mdns_create_txt(server, fullServiceDomain, pathChars, capabilites, + capabilitiesSize, UA_Discovery_multicastConflict); + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Discovery_removeRecord(UA_Server *server, const UA_String *servername, + const UA_String *hostname, UA_UInt16 port, + UA_Boolean removeTxt) { + // use a limit for the hostname length to make sure full string fits into 63 + // chars (limited by DNS spec) + size_t hostnameLen = hostname->length; + size_t servernameLen = servername->length; + if(hostnameLen == 0 || servernameLen == 0) + return UA_STATUSCODE_BADOUTOFRANGE; + + if(hostnameLen+servernameLen+1 > 63) { // include dash between servername-hostname + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS: Combination of hostname+servername exceeds " + "maximum of 62 chars. It will be truncated."); + } + + // [servername]-[hostname]._opcua-tcp._tcp.local. + char fullServiceDomain[63 + 24]; + createFullServiceDomain(fullServiceDomain, 63+24, servername, hostname); + + UA_LOG_INFO(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS: remove record for domain: %s", fullServiceDomain); + + UA_StatusCode retval = UA_DiscoveryManager_removeEntryFromServersOnNetwork( + server, fullServiceDomain, fullServiceDomain, UA_MIN(63, (servernameLen+hostnameLen)+1)); + if (retval != UA_STATUSCODE_GOOD) + return retval; + + // _opcua-tcp._tcp.local. PTR [servername]-[hostname]._opcua-tcp._tcp.local. + mdns_record_t *r = mdns_find_record(server->discoveryManager.mdnsDaemon, QTYPE_PTR, + "_opcua-tcp._tcp.local.", fullServiceDomain); + if(!r) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS: could not remove record. " + "PTR Record not found for domain: %s", fullServiceDomain); + return UA_STATUSCODE_BADNOTHINGTODO; + } + mdnsd_done(server->discoveryManager.mdnsDaemon, r); + + // looks for [servername]-[hostname]._opcua-tcp._tcp.local. 86400 IN SRV 0 5 port hostname.local. + // and TXT record: [servername]-[hostname]._opcua-tcp._tcp.local. TXT path=/ caps=NA,DA,... + // and A record: [servername]-[hostname]._opcua-tcp._tcp.local. A [ip] + mdns_record_t *r2 = mdnsd_get_published(server->discoveryManager.mdnsDaemon, fullServiceDomain); + if(!r2) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast DNS: could not remove record. Record not " + "found for domain: %s", fullServiceDomain); + return UA_STATUSCODE_BADNOTHINGTODO; + } + + while(r2) { + const mdns_answer_t *data = mdnsd_record_data(r2); + mdns_record_t *next = mdnsd_record_next(r2); + if((removeTxt && data->type == QTYPE_TXT) || + (removeTxt && data->type == QTYPE_A) || + data->srv.port == port) { + mdnsd_done(server->discoveryManager.mdnsDaemon, r2); + } + r2 = next; + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +iterateMulticastDiscoveryServer(UA_Server* server, UA_DateTime *nextRepeat, + UA_Boolean processIn) { + struct timeval next_sleep = { 0, 0 }; + unsigned short retval = mdnsd_step(server->discoveryManager.mdnsDaemon, + (int)server->discoveryManager.mdnsSocket, + processIn, true, &next_sleep); + if(retval == 1) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast error: Can not read from socket. %s", errno_str)); + return UA_STATUSCODE_BADNOCOMMUNICATION; + } else if(retval == 2) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Multicast error: Can not write to socket. %s", errno_str)); + return UA_STATUSCODE_BADNOCOMMUNICATION; + } + + if(nextRepeat) + *nextRepeat = UA_DateTime_now() + + (UA_DateTime)((next_sleep.tv_sec * UA_DATETIME_SEC) + + (next_sleep.tv_usec * UA_DATETIME_USEC)); + return UA_STATUSCODE_GOOD; +} + +#endif /* defined(UA_ENABLE_DISCOVERY) && defined(UA_ENABLE_DISCOVERY_MULTICAST) */ + +/**** amalgamated original file "/src/client/ua_client.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015 (c) hfaham + * Copyright 2015-2017 (c) Florian Palm + * Copyright 2017-2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2015 (c) Holger Jeromin + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016 (c) TorbenD + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2016 (c) Lykurg + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2018 (c) Kalycito Infotech Private Limited + * Copyright 2020 (c) Christian von Arnim, ISW University of Stuttgart + */ + + + +/********************/ +/* Client Lifecycle */ +/********************/ + +static void +UA_Client_init(UA_Client* client) { + UA_SecureChannel_init(&client->channel, &client->config.localConnectionConfig); + client->connectStatus = UA_STATUSCODE_GOOD; + UA_Timer_init(&client->timer); + notifyClientState(client); +} + +UA_Client UA_EXPORT * +UA_Client_newWithConfig(const UA_ClientConfig *config) { + if(!config) + return NULL; + UA_Client *client = (UA_Client*)UA_malloc(sizeof(UA_Client)); + if(!client) + return NULL; + memset(client, 0, sizeof(UA_Client)); + client->config = *config; + UA_Client_init(client); + return client; +} + +static void +UA_ClientConfig_clear(UA_ClientConfig *config) { + UA_ApplicationDescription_clear(&config->clientDescription); + + UA_ExtensionObject_clear(&config->userIdentityToken); + UA_String_clear(&config->securityPolicyUri); + + UA_EndpointDescription_clear(&config->endpoint); + UA_UserTokenPolicy_clear(&config->userTokenPolicy); + + if(config->certificateVerification.clear) + config->certificateVerification.clear(&config->certificateVerification); + + /* Delete the SecurityPolicies */ + if(config->securityPolicies == 0) + return; + for(size_t i = 0; i < config->securityPoliciesSize; i++) + config->securityPolicies[i].clear(&config->securityPolicies[i]); + UA_free(config->securityPolicies); + config->securityPolicies = 0; + + /* Logger */ + if(config->logger.clear) + config->logger.clear(config->logger.context); + config->logger.log = NULL; + config->logger.clear = NULL; + + if (config->sessionLocaleIdsSize > 0 && config->sessionLocaleIds) { + UA_Array_delete(config->sessionLocaleIds, config->sessionLocaleIdsSize, &UA_TYPES[UA_TYPES_LOCALEID]); + } + config->sessionLocaleIds = NULL; + config->sessionLocaleIdsSize = 0; +} + +static void +UA_Client_clear(UA_Client *client) { + /* Delete the async service calls with BADHSUTDOWN */ + UA_Client_AsyncService_removeAll(client, UA_STATUSCODE_BADSHUTDOWN); + + UA_Client_disconnect(client); + UA_String_clear(&client->endpointUrl); + + UA_String_clear(&client->remoteNonce); + UA_String_clear(&client->localNonce); + + /* Delete the subscriptions */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_Client_Subscriptions_clean(client); +#endif + + /* Delete the timed work */ + UA_Timer_clear(&client->timer); +} + +void +UA_Client_delete(UA_Client* client) { + UA_Client_clear(client); + UA_ClientConfig_clear(&client->config); + UA_free(client); +} + +void +UA_Client_getState(UA_Client *client, UA_SecureChannelState *channelState, + UA_SessionState *sessionState, UA_StatusCode *connectStatus) { + if(channelState) + *channelState = client->channel.state; + if(sessionState) + *sessionState = client->sessionState; + if(connectStatus) + *connectStatus = client->connectStatus; +} + +UA_ClientConfig * +UA_Client_getConfig(UA_Client *client) { + if(!client) + return NULL; + return &client->config; +} + +#if UA_LOGLEVEL <= 300 +static const char *channelStateTexts[9] = { + "Fresh", "HELSent", "HELReceived", "ACKSent", + "AckReceived", "OPNSent", "Open", "Closing", "Closed"}; +static const char *sessionStateTexts[6] = + {"Closed", "CreateRequested", "Created", + "ActivateRequested", "Activated", "Closing"}; +#endif + +void +notifyClientState(UA_Client *client) { + if(client->connectStatus == client->oldConnectStatus && + client->channel.state == client->oldChannelState && + client->sessionState == client->oldSessionState) + return; + +#if UA_LOGLEVEL <= 300 + UA_Boolean info = (client->connectStatus != UA_STATUSCODE_GOOD); + if(client->oldChannelState != client->channel.state) + info |= (client->channel.state == UA_SECURECHANNELSTATE_OPEN || + client->channel.state == UA_SECURECHANNELSTATE_CLOSED); + if(client->oldSessionState != client->sessionState) + info |= (client->sessionState == UA_SESSIONSTATE_CREATED || + client->sessionState == UA_SESSIONSTATE_ACTIVATED || + client->sessionState == UA_SESSIONSTATE_CLOSED); + + const char *channelStateText = channelStateTexts[client->channel.state]; + const char *sessionStateText = sessionStateTexts[client->sessionState]; + const char *connectStatusText = UA_StatusCode_name(client->connectStatus); + + if(info) + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Client Status: ChannelState: %s, SessionState: %s, ConnectStatus: %s", + channelStateText, sessionStateText, connectStatusText); + else + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Client Status: ChannelState: %s, SessionState: %s, ConnectStatus: %s", + channelStateText, sessionStateText, connectStatusText); +#endif + + client->oldConnectStatus = client->connectStatus; + client->oldChannelState = client->channel.state; + client->oldSessionState = client->sessionState; + + if(client->config.stateCallback) + client->config.stateCallback(client, client->channel.state, + client->sessionState, client->connectStatus); +} + +/****************/ +/* Raw Services */ +/****************/ + +/* For synchronous service calls. Execute async responses with a callback. When + * the response with the correct requestId turns up, return it via the + * SyncResponseDescription pointer. */ +typedef struct { + UA_Client *client; + UA_Boolean received; + UA_UInt32 requestId; + void *response; + const UA_DataType *responseType; +} SyncResponseDescription; + +/* For both synchronous and asynchronous service calls */ +static UA_StatusCode +sendSymmetricServiceRequest(UA_Client *client, const void *request, + const UA_DataType *requestType, UA_UInt32 *requestId) { + /* Renew SecureChannel if necessary */ + UA_Client_renewSecureChannel(client); + if(client->connectStatus != UA_STATUSCODE_GOOD) + return client->connectStatus; + + /* Adjusting the request header. The const attribute is violated, but we + * only touch the following members: */ + UA_RequestHeader *rr = (UA_RequestHeader*)(uintptr_t)request; + UA_NodeId oldToken = rr->authenticationToken; /* Put back in place later */ + rr->authenticationToken = client->authenticationToken; + rr->timestamp = UA_DateTime_now(); + rr->requestHandle = ++client->requestHandle; + UA_UInt32 rqId = ++client->requestId; + +#ifdef UA_ENABLE_TYPEDESCRIPTION + UA_LOG_DEBUG_CHANNEL(&client->config.logger, &client->channel, + "Sending request with RequestId %u of type %s", + (unsigned)rqId, requestType->typeName); +#else + UA_LOG_DEBUG_CHANNEL(&client->config.logger, &client->channel, + "Sending request with RequestId %u of type %" PRIu32, + (unsigned)rqId, requestType->binaryEncodingId.identifier.numeric); +#endif + + /* Send the message */ + UA_StatusCode retval = + UA_SecureChannel_sendSymmetricMessage(&client->channel, rqId, + UA_MESSAGETYPE_MSG, rr, requestType); + rr->authenticationToken = oldToken; /* Set the original token */ + + *requestId = rqId; + return retval; +} + +static const UA_NodeId +serviceFaultId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_SERVICEFAULT_ENCODING_DEFAULTBINARY}}; + +/* Look for the async callback in the linked list, execute and delete it */ +static UA_StatusCode +processAsyncResponse(UA_Client *client, UA_UInt32 requestId, const UA_NodeId *responseTypeId, + const UA_ByteString *responseMessage, size_t *offset) { + /* Find the callback */ + AsyncServiceCall *ac; + LIST_FOREACH(ac, &client->asyncServiceCalls, pointers) { + if(ac->requestId == requestId) + break; + } + + /* Part 6, 6.7.6: After the security validation is complete the receiver + * shall verify the RequestId and the SequenceNumber. If these checks fail a + * Bad_SecurityChecksFailed error is reported. The RequestId only needs to + * be verified by the Client since only the Client knows if it is valid or + * not.*/ + if(!ac) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + /* Dequeue ac. We might disconnect (remove all ac) in the callback. */ + LIST_REMOVE(ac, pointers); + + /* Verify the type of the response */ + UA_Response response; + const UA_DataType *responseType = ac->responseType; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(!UA_NodeId_equal(responseTypeId, &ac->responseType->binaryEncodingId)) { + UA_init(&response, ac->responseType); + if(UA_NodeId_equal(responseTypeId, &serviceFaultId)) { + /* Decode as a ServiceFault, i.e. only the response header */ + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Received a ServiceFault response"); + responseType = &UA_TYPES[UA_TYPES_SERVICEFAULT]; + } else { + /* Close the connection */ + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Reply contains the wrong service response"); + retval = UA_STATUSCODE_BADCOMMUNICATIONERROR; + goto process; + } + } + + /* Decode the response */ + retval = UA_decodeBinaryInternal(responseMessage, offset, &response, responseType, + client->config.customDataTypes); + + process: + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Could not decode the response with id %u due to %s", + (unsigned)requestId, UA_StatusCode_name(retval)); + response.responseHeader.serviceResult = retval; + } else if(response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + /* Decode as a ServiceFault, i.e. only the response header */ + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "The ServiceResult has the StatusCode %s", + UA_StatusCode_name(response.responseHeader.serviceResult)); + } + + /* Call the callback */ + if(ac->callback) + ac->callback(client, ac->userdata, requestId, &response); + UA_clear(&response, ac->responseType); + + /* Remove the callback */ + UA_free(ac); + return retval; +} + +/* Processes the received service response. Either with an async callback or by + * decoding the message and returning it "upwards" in the + * SyncResponseDescription. */ +static UA_StatusCode +processServiceResponse(void *application, UA_SecureChannel *channel, + UA_MessageType messageType, UA_UInt32 requestId, + UA_ByteString *message) { + SyncResponseDescription *rd = (SyncResponseDescription*)application; + + /* Process ACK response */ + switch(messageType) { + case UA_MESSAGETYPE_ACK: + processACKResponse(rd->client, message); + return UA_STATUSCODE_GOOD; + case UA_MESSAGETYPE_OPN: + processOPNResponse(rd->client, message); + return UA_STATUSCODE_GOOD; + case UA_MESSAGETYPE_ERR: + processERRResponse(rd->client, message); + return UA_STATUSCODE_GOOD; + case UA_MESSAGETYPE_MSG: + /* Continue below */ + break; + default: + UA_LOG_TRACE_CHANNEL(&rd->client->config.logger, channel, "Invalid message type"); + channel->state = UA_SECURECHANNELSTATE_CLOSING; + return UA_STATUSCODE_BADTCPMESSAGETYPEINVALID; + } + + /* Decode the data type identifier of the response */ + size_t offset = 0; + UA_NodeId responseId; + UA_StatusCode retval = UA_NodeId_decodeBinary(message, &offset, &responseId); + if(retval != UA_STATUSCODE_GOOD) + goto finish; + + /* Got an asynchronous response. Don't expected a synchronous response + * (responseType NULL) or the id does not match. */ + if(!rd->responseType || requestId != rd->requestId) { + retval = processAsyncResponse(rd->client, requestId, &responseId, message, &offset); + goto finish; + } + + /* Got the synchronous response */ + rd->received = true; + + /* Check that the response type matches */ + if(!UA_NodeId_equal(&responseId, &rd->responseType->binaryEncodingId)) { + if(UA_NodeId_equal(&responseId, &serviceFaultId)) { + UA_init(rd->response, rd->responseType); + retval = UA_decodeBinaryInternal(message, &offset, rd->response, + &UA_TYPES[UA_TYPES_SERVICEFAULT], + rd->client->config.customDataTypes); + if(retval != UA_STATUSCODE_GOOD) + ((UA_ResponseHeader*)rd->response)->serviceResult = retval; + UA_LOG_INFO(&rd->client->config.logger, UA_LOGCATEGORY_CLIENT, + "Received a ServiceFault response with StatusCode %s", + UA_StatusCode_name(((UA_ResponseHeader*)rd->response)->serviceResult)); + } else { + /* Close the connection */ + UA_LOG_ERROR(&rd->client->config.logger, UA_LOGCATEGORY_CLIENT, + "Reply contains the wrong service response"); + retval = UA_STATUSCODE_BADCOMMUNICATIONERROR; + } + goto finish; + } + +#ifdef UA_ENABLE_TYPEDESCRIPTION + UA_LOG_DEBUG(&rd->client->config.logger, UA_LOGCATEGORY_CLIENT, + "Decode a message of type %s", rd->responseType->typeName); +#else + UA_LOG_DEBUG(&rd->client->config.logger, UA_LOGCATEGORY_CLIENT, + "Decode a message of type %" PRIu32, responseId.identifier.numeric); +#endif + + /* Decode the response */ + retval = UA_decodeBinaryInternal(message, &offset, rd->response, rd->responseType, + rd->client->config.customDataTypes); + +finish: + UA_NodeId_clear(&responseId); + if(retval != UA_STATUSCODE_GOOD) { + if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED) + retval = UA_STATUSCODE_BADRESPONSETOOLARGE; + UA_LOG_INFO(&rd->client->config.logger, UA_LOGCATEGORY_CLIENT, + "Error receiving the response with status code %s", + UA_StatusCode_name(retval)); + + if(rd->response) { + UA_ResponseHeader *respHeader = (UA_ResponseHeader*)rd->response; + respHeader->serviceResult = retval; + } + } + + return retval; +} + +/* Receive and process messages until a synchronous message arrives or the + * timout finishes */ +static UA_StatusCode +receiveResponse(UA_Client *client, void *response, const UA_DataType *responseType, + UA_DateTime maxDate, const UA_UInt32 *synchronousRequestId) { + /* Prepare the response and the structure we give into processServiceResponse */ + SyncResponseDescription rd = { client, false, 0, response, responseType }; + + /* Return upon receiving the synchronized response. All other responses are + * processed with a callback "in the background". */ + if(synchronousRequestId) + rd.requestId = *synchronousRequestId; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + UA_DateTime now = UA_DateTime_nowMonotonic(); + do { + UA_UInt32 timeout2 = (UA_UInt32)((maxDate - now) / UA_DATETIME_MSEC); + if(maxDate < now) + timeout2 = 0; + retval = UA_SecureChannel_receive(&client->channel, &rd, processServiceResponse, timeout2); + if(retval == UA_STATUSCODE_GOODNONCRITICALTIMEOUT) + break; + if(retval != UA_STATUSCODE_GOOD || + client->channel.state == UA_SECURECHANNELSTATE_CLOSING) { + UA_LOG_WARNING_CHANNEL(&client->config.logger, &client->channel, + "Receiving the response failed with StatusCode %s", + UA_StatusCode_name(retval)); + ua_print("ua: [%s] state %d ret %d %#x\n", __func__, client->channel.state, retval, retval); + closeSecureChannel(client); + retval = UA_STATUSCODE_BADCONNECTIONCLOSED; + break; + } + now = UA_DateTime_nowMonotonic(); + if(maxDate < now) + break; + } while(!rd.received && responseType); /* Return if we don't wait for an async response */ + + return retval; +} + +UA_StatusCode +receiveResponseAsync(UA_Client *client, UA_UInt32 timeout) { + UA_DateTime maxDate = UA_DateTime_nowMonotonic() + ((UA_DateTime)timeout * UA_DATETIME_MSEC); + UA_StatusCode res = receiveResponse(client, NULL, NULL, maxDate, NULL); + return (res != UA_STATUSCODE_GOODNONCRITICALTIMEOUT) ? res : UA_STATUSCODE_GOOD; +} + +void +__UA_Client_Service(UA_Client *client, const void *request, + const UA_DataType *requestType, void *response, + const UA_DataType *responseType) { + /* Initialize. Response is valied in case of aborting. */ + UA_init(response, responseType); + + if(client->channel.state != UA_SECURECHANNELSTATE_OPEN) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "SecureChannel must be connected before sending requests"); + UA_ResponseHeader *respHeader = (UA_ResponseHeader*)response; + respHeader->serviceResult = UA_STATUSCODE_BADCONNECTIONCLOSED; + return; + } + + /* Send the request */ + UA_UInt32 requestId; + UA_StatusCode retval = sendSymmetricServiceRequest(client, request, requestType, &requestId); + + UA_ResponseHeader *respHeader = (UA_ResponseHeader*)response; + if(retval == UA_STATUSCODE_GOOD) { + /* Retrieve the response */ + UA_DateTime maxDate = UA_DateTime_nowMonotonic() + ((UA_DateTime)client->config.timeout * UA_DATETIME_MSEC); + retval = receiveResponse(client, response, responseType, maxDate, &requestId); + } else if(retval == UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED) { + respHeader->serviceResult = UA_STATUSCODE_BADREQUESTTOOLARGE; + return; + } + + /* In synchronous service, if we have don't have a reply we need to close + * the connection. For all other error cases, receiveResponse has already + * closed the channel. */ + if(retval == UA_STATUSCODE_GOODNONCRITICALTIMEOUT || + client->channel.state == UA_SECURECHANNELSTATE_CLOSING) { + closeSecureChannel(client); + retval = UA_STATUSCODE_BADCONNECTIONCLOSED; + } + + if(retval != UA_STATUSCODE_GOOD) + respHeader->serviceResult = retval; + + notifyClientState(client); +} + +void +UA_Client_AsyncService_cancel(UA_Client *client, AsyncServiceCall *ac, + UA_StatusCode statusCode) { + /* Create an empty response with the statuscode */ + UA_Response response; + UA_init(&response, ac->responseType); + response.responseHeader.serviceResult = statusCode; + + if(ac->callback) + ac->callback(client, ac->userdata, ac->requestId, &response); + + /* Clean up the response. Users might move data into it. For whatever reasons. */ + UA_clear(&response, ac->responseType); +} + +void UA_Client_AsyncService_removeAll(UA_Client *client, UA_StatusCode statusCode) { + AsyncServiceCall *ac, *ac_tmp; + LIST_FOREACH_SAFE(ac, &client->asyncServiceCalls, pointers, ac_tmp) { + LIST_REMOVE(ac, pointers); + UA_Client_AsyncService_cancel(client, ac, statusCode); + UA_free(ac); + } +} + +UA_StatusCode UA_Client_modifyAsyncCallback(UA_Client *client, UA_UInt32 requestId, + void *userdata, UA_ClientAsyncServiceCallback callback) { + AsyncServiceCall *ac; + LIST_FOREACH(ac, &client->asyncServiceCalls, pointers) { + if(ac->requestId == requestId) { + ac->callback = callback; + ac->userdata = userdata; + return UA_STATUSCODE_GOOD; + } + } + + return UA_STATUSCODE_BADNOTFOUND; +} + +UA_StatusCode +__UA_Client_AsyncServiceEx(UA_Client *client, const void *request, + const UA_DataType *requestType, + UA_ClientAsyncServiceCallback callback, + const UA_DataType *responseType, + void *userdata, UA_UInt32 *requestId, + UA_UInt32 timeout) { + if(client->channel.state != UA_SECURECHANNELSTATE_OPEN) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "SecureChannel must be connected before sending requests"); + return UA_STATUSCODE_BADSERVERNOTCONNECTED; + } + + /* Prepare the entry for the linked list */ + AsyncServiceCall *ac = (AsyncServiceCall*)UA_malloc(sizeof(AsyncServiceCall)); + if(!ac) + return UA_STATUSCODE_BADOUTOFMEMORY; + ac->callback = callback; + ac->responseType = responseType; + ac->userdata = userdata; + ac->timeout = timeout; + + /* Call the service and set the requestId */ + UA_StatusCode retval = sendSymmetricServiceRequest(client, request, requestType, &ac->requestId); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(ac); + closeSecureChannel(client); + notifyClientState(client); + return retval; + } + + ac->start = UA_DateTime_nowMonotonic(); + + /* Store the entry for async processing */ + LIST_INSERT_HEAD(&client->asyncServiceCalls, ac, pointers); + if(requestId) + *requestId = ac->requestId; + + notifyClientState(client); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +__UA_Client_AsyncService(UA_Client *client, const void *request, + const UA_DataType *requestType, + UA_ClientAsyncServiceCallback callback, + const UA_DataType *responseType, + void *userdata, UA_UInt32 *requestId) { + return __UA_Client_AsyncServiceEx(client, request, requestType, callback, responseType, + userdata, requestId, client->config.timeout); +} + +UA_StatusCode +UA_Client_sendAsyncRequest(UA_Client *client, const void *request, + const UA_DataType *requestType, + UA_ClientAsyncServiceCallback callback, + const UA_DataType *responseType, void *userdata, + UA_UInt32 *requestId) { + return __UA_Client_AsyncService(client, request, requestType, callback, + responseType, userdata, requestId); +} + +UA_StatusCode UA_EXPORT +UA_Client_addTimedCallback(UA_Client *client, UA_ClientCallback callback, + void *data, UA_DateTime date, UA_UInt64 *callbackId) { + return UA_Timer_addTimedCallback(&client->timer, (UA_ApplicationCallback)callback, + client, data, date, callbackId); +} + +UA_StatusCode +UA_Client_addRepeatedCallback(UA_Client *client, UA_ClientCallback callback, + void *data, UA_Double interval_ms, UA_UInt64 *callbackId) { + return UA_Timer_addRepeatedCallback(&client->timer, (UA_ApplicationCallback)callback, + client, data, interval_ms, NULL, + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, callbackId); +} + +UA_StatusCode +UA_Client_changeRepeatedCallbackInterval(UA_Client *client, UA_UInt64 callbackId, + UA_Double interval_ms) { + return UA_Timer_changeRepeatedCallback(&client->timer, callbackId, interval_ms, NULL, UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME); +} + +void +UA_Client_removeCallback(UA_Client *client, UA_UInt64 callbackId) { + UA_Timer_removeCallback(&client->timer, callbackId); +} + +static void +asyncServiceTimeoutCheck(UA_Client *client) { + AsyncServiceCall *ac, *ac_tmp; + UA_DateTime now = UA_DateTime_nowMonotonic(); + LIST_FOREACH_SAFE(ac, &client->asyncServiceCalls, pointers, ac_tmp) { + if(!ac->timeout) + continue; + if(ac->start + (UA_DateTime)(ac->timeout * UA_DATETIME_MSEC) <= now) { + LIST_REMOVE(ac, pointers); + UA_Client_AsyncService_cancel(client, ac, UA_STATUSCODE_BADTIMEOUT); + UA_free(ac); + } + } +} + +static void +backgroundConnectivityCallback(UA_Client *client, void *userdata, + UA_UInt32 requestId, const UA_ReadResponse *response) { + if(response->responseHeader.serviceResult == UA_STATUSCODE_BADTIMEOUT) { + if(client->config.inactivityCallback) + client->config.inactivityCallback(client); + } + client->pendingConnectivityCheck = false; + client->lastConnectivityCheck = UA_DateTime_nowMonotonic(); +} + +static void +UA_Client_backgroundConnectivity(UA_Client *client) { + if(!client->config.connectivityCheckInterval) + return; + + if(client->pendingConnectivityCheck) + return; + + UA_DateTime now = UA_DateTime_nowMonotonic(); + UA_DateTime nextDate = client->lastConnectivityCheck + + (UA_DateTime)(client->config.connectivityCheckInterval * UA_DATETIME_MSEC); + if(now <= nextDate) + return; + + /* Prepare the request */ + UA_ReadValueId rvid; + UA_ReadValueId_init(&rvid); + rvid.attributeId = UA_ATTRIBUTEID_VALUE; + rvid.nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_STATE); + UA_ReadRequest request; + UA_ReadRequest_init(&request); + request.nodesToRead = &rvid; + request.nodesToReadSize = 1; + UA_StatusCode retval = + __UA_Client_AsyncService(client, &request, &UA_TYPES[UA_TYPES_READREQUEST], + (UA_ClientAsyncServiceCallback)backgroundConnectivityCallback, + &UA_TYPES[UA_TYPES_READRESPONSE], NULL, NULL); + if(retval == UA_STATUSCODE_GOOD) + client->pendingConnectivityCheck = true; +} + +static void +clientExecuteRepeatedCallback(void *executionApplication, UA_ApplicationCallback cb, + void *callbackApplication, void *data) { + cb(callbackApplication, data); +} + +UA_StatusCode +UA_Client_run_iterate(UA_Client *client, UA_UInt32 timeout) { + /* Process timed (repeated) jobs */ + UA_DateTime now = UA_DateTime_nowMonotonic(); + UA_DateTime maxDate = + UA_Timer_process(&client->timer, now, (UA_TimerExecutionCallback) + clientExecuteRepeatedCallback, client); + if(maxDate > now + ((UA_DateTime)timeout * UA_DATETIME_MSEC)) + maxDate = now + ((UA_DateTime)timeout * UA_DATETIME_MSEC); + + /* Make sure we have an open channel */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if((client->noSession && client->channel.state != UA_SECURECHANNELSTATE_OPEN) || + client->sessionState < UA_SESSIONSTATE_ACTIVATED) { + retval = connectIterate(client, timeout); + notifyClientState(client); + return retval; + } + + /* Renew Secure Channel */ + UA_Client_renewSecureChannel(client); + if(client->connectStatus != UA_STATUSCODE_GOOD) + return client->connectStatus; + + /* Feed the server PublishRequests for the Subscriptions */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_Client_Subscriptions_backgroundPublish(client); +#endif + + /* Send read requests from time to time to test the connectivity */ + UA_Client_backgroundConnectivity(client); + + /* Listen on the network for the given timeout */ + retval = receiveResponse(client, NULL, NULL, maxDate, NULL); + if(retval == UA_STATUSCODE_GOODNONCRITICALTIMEOUT) + retval = UA_STATUSCODE_GOOD; + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_CHANNEL(&client->config.logger, &client->channel, + "Could not receive with StatusCode %s", + UA_StatusCode_name(retval)); + } + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* The inactivity check must be done after receiveServiceResponse*/ + UA_Client_Subscriptions_backgroundPublishInactivityCheck(client); +#endif + + /* Did async services time out? Process callbacks with an error code */ + asyncServiceTimeoutCheck(client); + + /* Log and notify user if the client state has changed */ + notifyClientState(client); + + return client->connectStatus; +} + +const UA_DataType * +UA_Client_findDataType(UA_Client *client, const UA_NodeId *typeId) { + return UA_findDataTypeWithCustom(typeId, client->config.customDataTypes); +} + +/**** amalgamated original file "/src/client/ua_client_connect.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017-2019 (c) Fraunhofer IOSB (Author: Mark Giraud) + */ + + + +#define UA_MINMESSAGESIZE 8192 +#define UA_SESSION_LOCALNONCELENGTH 32 +#define MAX_DATA_SIZE 4096 + +static void closeSession(UA_Client *client); +static UA_StatusCode createSessionAsync(UA_Client *client); + +static UA_SecurityPolicy * +getSecurityPolicy(UA_Client *client, UA_String policyUri) { + for(size_t i = 0; i < client->config.securityPoliciesSize; i++) { + if(UA_String_equal(&policyUri, &client->config.securityPolicies[i].policyUri)) + return &client->config.securityPolicies[i]; + } + return NULL; +} + +static UA_Boolean +endpointUnconfigured(UA_Client *client) { + char test = 0; + char *pos = (char *)&client->config.endpoint; + for(size_t i = 0; i < sizeof(UA_EndpointDescription); i++) + test = test | *(pos + i); + pos = (char *)&client->config.userTokenPolicy; + for(size_t i = 0; i < sizeof(UA_UserTokenPolicy); i++) + test = test | *(pos + i); + return (test == 0); +} + +#ifdef UA_ENABLE_ENCRYPTION + +/* Function to create a signature using remote certificate and nonce */ +static UA_StatusCode +signActivateSessionRequest(UA_Client *client, UA_SecureChannel *channel, + UA_ActivateSessionRequest *request) { + if(channel->securityMode != UA_MESSAGESECURITYMODE_SIGN && + channel->securityMode != UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + return UA_STATUSCODE_GOOD; + + const UA_SecurityPolicy *sp = channel->securityPolicy; + UA_SignatureData *sd = &request->clientSignature; + + /* Prepare the signature */ + size_t signatureSize = sp->certificateSigningAlgorithm. + getLocalSignatureSize(channel->channelContext); + UA_StatusCode retval = UA_String_copy(&sp->certificateSigningAlgorithm.uri, + &sd->algorithm); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + retval = UA_ByteString_allocBuffer(&sd->signature, signatureSize); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Allocate a temporary buffer */ + size_t dataToSignSize = channel->remoteCertificate.length + client->remoteNonce.length; + if(dataToSignSize > MAX_DATA_SIZE) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString dataToSign; + retval = UA_ByteString_allocBuffer(&dataToSign, dataToSignSize); + if(retval != UA_STATUSCODE_GOOD) + return retval; /* sd->signature is cleaned up with the response */ + + /* Sign the signature */ + memcpy(dataToSign.data, channel->remoteCertificate.data, + channel->remoteCertificate.length); + memcpy(dataToSign.data + channel->remoteCertificate.length, + client->remoteNonce.data, client->remoteNonce.length); + retval = sp->certificateSigningAlgorithm.sign(channel->channelContext, + &dataToSign, &sd->signature); + + /* Clean up */ + UA_ByteString_clear(&dataToSign); + return retval; +} + +static UA_StatusCode +encryptUserIdentityToken(UA_Client *client, const UA_String *userTokenSecurityPolicy, + UA_ExtensionObject *userIdentityToken) { + UA_IssuedIdentityToken *iit = NULL; + UA_UserNameIdentityToken *unit = NULL; + UA_ByteString *tokenData; + if(userIdentityToken->content.decoded.type == &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]) { + iit = (UA_IssuedIdentityToken*)userIdentityToken->content.decoded.data; + tokenData = &iit->tokenData; + } else if(userIdentityToken->content.decoded.type == &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]) { + unit = (UA_UserNameIdentityToken*)userIdentityToken->content.decoded.data; + tokenData = &unit->password; + } else { + return UA_STATUSCODE_GOOD; + } + + /* No encryption */ + const UA_String none = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None"); + if(userTokenSecurityPolicy->length == 0 || + UA_String_equal(userTokenSecurityPolicy, &none)) { + return UA_STATUSCODE_GOOD; + } + + UA_SecurityPolicy *sp = getSecurityPolicy(client, *userTokenSecurityPolicy); + if(!sp) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_NETWORK, + "Could not find the required SecurityPolicy for the UserToken"); + return UA_STATUSCODE_BADSECURITYPOLICYREJECTED; + } + + /* Create a temp channel context */ + + void *channelContext; + UA_StatusCode retval = sp->channelModule. + newContext(sp, &client->config.endpoint.serverCertificate, &channelContext); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_NETWORK, + "Could not instantiate the SecurityPolicy for the UserToken"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Compute the encrypted length (at least one byte padding) */ + size_t plainTextBlockSize = sp->asymmetricModule.cryptoModule. + encryptionAlgorithm.getRemotePlainTextBlockSize(channelContext); + size_t encryptedBlockSize = sp->asymmetricModule.cryptoModule. + encryptionAlgorithm.getRemoteBlockSize(channelContext); + UA_UInt32 length = (UA_UInt32)(tokenData->length + client->remoteNonce.length); + UA_UInt32 totalLength = length + 4; /* Including the length field */ + size_t blocks = totalLength / plainTextBlockSize; + if(totalLength % plainTextBlockSize != 0) + blocks++; + size_t encryptedLength = blocks * encryptedBlockSize; + + /* Allocate memory for encryption overhead */ + UA_ByteString encrypted; + retval = UA_ByteString_allocBuffer(&encrypted, encryptedLength); + if(retval != UA_STATUSCODE_GOOD) { + sp->channelModule.deleteContext(channelContext); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_Byte *pos = encrypted.data; + const UA_Byte *end = &encrypted.data[encrypted.length]; + retval = UA_UInt32_encodeBinary(&length, &pos, end); + memcpy(pos, tokenData->data, tokenData->length); + memcpy(&pos[tokenData->length], client->remoteNonce.data, client->remoteNonce.length); + UA_assert(retval == UA_STATUSCODE_GOOD); + + /* Add padding + * + * 7.36.2.2 Legacy Encrypted Token Secret Format: A Client should not add any + * padding after the secret. If a Client adds padding then all bytes shall + * be zero. A Server shall check for padding added by Clients and ensure + * that all padding bytes are zeros. */ + size_t paddedLength = plainTextBlockSize * blocks; + for(size_t i = totalLength; i < paddedLength; i++) + encrypted.data[i] = 0; + encrypted.length = paddedLength; + + retval = sp->asymmetricModule.cryptoModule.encryptionAlgorithm. + encrypt(channelContext, &encrypted); + encrypted.length = encryptedLength; + + if(iit) { + retval |= UA_String_copy(&sp->asymmetricModule.cryptoModule.encryptionAlgorithm.uri, + &iit->encryptionAlgorithm); + } else { + retval |= UA_String_copy(&sp->asymmetricModule.cryptoModule.encryptionAlgorithm.uri, + &unit->encryptionAlgorithm); + } + + UA_ByteString_clear(tokenData); + *tokenData = encrypted; + + /* Delete the temp channel context */ + sp->channelModule.deleteContext(channelContext); + + return retval; +} + +/* Function to verify the signature corresponds to ClientNonce + * using the local certificate */ +static UA_StatusCode +checkCreateSessionSignature(UA_Client *client, const UA_SecureChannel *channel, + const UA_CreateSessionResponse *response) { + if(channel->securityMode != UA_MESSAGESECURITYMODE_SIGN && + channel->securityMode != UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) + return UA_STATUSCODE_GOOD; + + if(!channel->securityPolicy) + return UA_STATUSCODE_BADINTERNALERROR; + + const UA_SecurityPolicy *sp = channel->securityPolicy; + const UA_ByteString *lc = &sp->localCertificate; + + size_t dataToVerifySize = lc->length + client->localNonce.length; + UA_ByteString dataToVerify = UA_BYTESTRING_NULL; + UA_StatusCode retval = UA_ByteString_allocBuffer(&dataToVerify, dataToVerifySize); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + memcpy(dataToVerify.data, lc->data, lc->length); + memcpy(dataToVerify.data + lc->length, + client->localNonce.data, client->localNonce.length); + + retval = sp->certificateSigningAlgorithm.verify(channel->channelContext, &dataToVerify, + &response->serverSignature.signature); + UA_ByteString_clear(&dataToVerify); + return retval; +} + +#endif + +/***********************/ +/* Open the Connection */ +/***********************/ + +void +processERRResponse(UA_Client *client, const UA_ByteString *chunk) { + client->channel.state = UA_SECURECHANNELSTATE_CLOSING; + + size_t offset = 0; + UA_TcpErrorMessage errMessage; + UA_StatusCode res = + UA_decodeBinaryInternal(chunk, &offset, &errMessage, + &UA_TRANSPORT[UA_TRANSPORT_TCPERRORMESSAGE], NULL); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR_CHANNEL(&client->config.logger, &client->channel, + "Received an ERR response that could not be decoded with StatusCode %s", + UA_StatusCode_name(res)); + client->connectStatus = res; + return; + } + + UA_LOG_ERROR_CHANNEL(&client->config.logger, &client->channel, + "Received an ERR response with StatusCode %s and the following reason: %.*s", + UA_StatusCode_name(errMessage.error), (int)errMessage.reason.length, errMessage.reason.data); + client->connectStatus = errMessage.error; + UA_TcpErrorMessage_clear(&errMessage); +} + +void +processACKResponse(UA_Client *client, const UA_ByteString *chunk) { + UA_SecureChannel *channel = &client->channel; + if(channel->state != UA_SECURECHANNELSTATE_HEL_SENT) { + UA_LOG_ERROR_CHANNEL(&client->config.logger, channel, + "Expected an ACK response"); + channel->state = UA_SECURECHANNELSTATE_CLOSING; + return; + } + + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Received ACK message"); + + /* Decode the message */ + size_t offset = 0; + UA_TcpAcknowledgeMessage ackMessage; + client->connectStatus = + UA_decodeBinaryInternal(chunk, &offset, &ackMessage, + &UA_TRANSPORT[UA_TRANSPORT_TCPACKNOWLEDGEMESSAGE], NULL); + if(client->connectStatus != UA_STATUSCODE_GOOD) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_NETWORK, + "Decoding ACK message failed"); + closeSecureChannel(client); + return; + } + + client->connectStatus = + UA_SecureChannel_processHELACK(channel, &ackMessage); + if(client->connectStatus != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_NETWORK, + "Processing the ACK message failed with StatusCode %s", + UA_StatusCode_name(client->connectStatus)); + closeSecureChannel(client); + return; + } + + client->channel.state = UA_SECURECHANNELSTATE_ACK_RECEIVED; +} + +static UA_StatusCode +sendHELMessage(UA_Client *client) { + /* Get a buffer */ + UA_ByteString message; + UA_Connection *conn = &client->connection; + UA_StatusCode retval = conn->getSendBuffer(conn, UA_MINMESSAGESIZE, &message); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Prepare the HEL message and encode at offset 8 */ + UA_TcpHelloMessage hello; + hello.protocolVersion = 0; + hello.receiveBufferSize = client->config.localConnectionConfig.recvBufferSize; + hello.sendBufferSize = client->config.localConnectionConfig.sendBufferSize; + hello.maxMessageSize = client->config.localConnectionConfig.localMaxMessageSize; + hello.maxChunkCount = client->config.localConnectionConfig.localMaxChunkCount; + hello.endpointUrl = client->endpointUrl; + + UA_Byte *bufPos = &message.data[8]; /* skip the header */ + const UA_Byte *bufEnd = &message.data[message.length]; + client->connectStatus = + UA_encodeBinaryInternal(&hello, &UA_TRANSPORT[UA_TRANSPORT_TCPHELLOMESSAGE], + &bufPos, &bufEnd, NULL, NULL); + + /* Encode the message header at offset 0 */ + UA_TcpMessageHeader messageHeader; + messageHeader.messageTypeAndChunkType = UA_CHUNKTYPE_FINAL + UA_MESSAGETYPE_HEL; + messageHeader.messageSize = (UA_UInt32) ((uintptr_t)bufPos - (uintptr_t)message.data); + bufPos = message.data; + retval = UA_encodeBinaryInternal(&messageHeader, + &UA_TRANSPORT[UA_TRANSPORT_TCPMESSAGEHEADER], + &bufPos, &bufEnd, NULL, NULL); + if(retval != UA_STATUSCODE_GOOD) { + conn->releaseSendBuffer(conn, &message); + return retval; + } + + /* Send the HEL message */ + message.length = messageHeader.messageSize; + retval = conn->ua_send(conn, &message); + if(retval == UA_STATUSCODE_GOOD) { + client->channel.state = UA_SECURECHANNELSTATE_HEL_SENT; + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Sent HEL message"); + } else { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_NETWORK, "Sending HEL failed"); + } + return retval; +} + +void +processOPNResponse(UA_Client *client, const UA_ByteString *message) { + /* Is the content of the expected type? */ + size_t offset = 0; + UA_NodeId responseId; + UA_NodeId expectedId = + UA_NODEID_NUMERIC(0, UA_NS0ID_OPENSECURECHANNELRESPONSE_ENCODING_DEFAULTBINARY); + UA_StatusCode retval = UA_NodeId_decodeBinary(message, &offset, &responseId); + if(retval != UA_STATUSCODE_GOOD) { + closeSecureChannel(client); + return; + } + + if(!UA_NodeId_equal(&responseId, &expectedId)) { + UA_NodeId_clear(&responseId); + closeSecureChannel(client); + return; + } + + /* Decode the response */ + UA_OpenSecureChannelResponse response; + retval = UA_decodeBinaryInternal(message, &offset, &response, + &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE], NULL); + if(retval != UA_STATUSCODE_GOOD) { + closeSecureChannel(client); + return; + } + + /* Check whether the nonce was reused */ + if(client->channel.securityMode != UA_MESSAGESECURITYMODE_NONE && + UA_ByteString_equal(&client->channel.remoteNonce, + &response.serverNonce)) { + UA_LOG_ERROR_CHANNEL(&client->config.logger, &client->channel, + "The server reused the last nonce"); + client->connectStatus = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + closeSecureChannel(client); + return; + } + + /* Response.securityToken.revisedLifetime is UInt32 we need to cast it to + * DateTime=Int64 we take 75% of lifetime to start renewing as described in + * standard */ + client->nextChannelRenewal = UA_DateTime_nowMonotonic() + + (UA_DateTime) (response.securityToken.revisedLifetime + * (UA_Double) UA_DATETIME_MSEC * 0.75); + + /* Move the nonce out of the response */ + UA_ByteString_clear(&client->channel.remoteNonce); + client->channel.remoteNonce = response.serverNonce; + UA_ByteString_init(&response.serverNonce); + UA_ResponseHeader_clear(&response.responseHeader); + + /* Replace the token. Keep the current token as the old token. Messages + * might still arrive for the old token. */ + client->channel.altSecurityToken = client->channel.securityToken; + client->channel.securityToken = response.securityToken; + client->channel.renewState = UA_SECURECHANNELRENEWSTATE_NEWTOKEN_CLIENT; + + /* Compute the new local keys. The remote keys are updated when a message + * with the new SecurityToken is received. */ + retval = UA_SecureChannel_generateLocalKeys(&client->channel); + if(retval != UA_STATUSCODE_GOOD) { + closeSecureChannel(client); + return; + } + + UA_Float lifetime = (UA_Float)response.securityToken.revisedLifetime / 1000; + UA_Boolean renew = (client->channel.state == UA_SECURECHANNELSTATE_OPEN); + if(renew) { + UA_LOG_INFO_CHANNEL(&client->config.logger, &client->channel, "SecureChannel " + "renewed with a revised lifetime of %.2fs", lifetime); + } else { + UA_LOG_INFO_CHANNEL(&client->config.logger, &client->channel, + "SecureChannel opened with SecurityPolicy %.*s " + "and a revised lifetime of %.2fs", + (int)client->channel.securityPolicy->policyUri.length, + client->channel.securityPolicy->policyUri.data, lifetime); + } + + client->channel.state = UA_SECURECHANNELSTATE_OPEN; +} + +/* OPN messges to renew the channel are sent asynchronous */ +static UA_StatusCode +sendOPNAsync(UA_Client *client, UA_Boolean renew) { + UA_Connection *conn = &client->connection; + if(conn->state != UA_CONNECTIONSTATE_ESTABLISHED) { + closeSecureChannel(client); + return UA_STATUSCODE_BADNOTCONNECTED; + } + + UA_StatusCode retval = UA_SecureChannel_generateLocalNonce(&client->channel); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Prepare the OpenSecureChannelRequest */ + UA_OpenSecureChannelRequest opnSecRq; + UA_OpenSecureChannelRequest_init(&opnSecRq); + opnSecRq.requestHeader.timestamp = UA_DateTime_now(); + opnSecRq.requestHeader.authenticationToken = client->authenticationToken; + opnSecRq.securityMode = client->channel.securityMode; + opnSecRq.clientNonce = client->channel.localNonce; + opnSecRq.requestedLifetime = client->config.secureChannelLifeTime; + if(renew) { + opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_RENEW; + UA_LOG_DEBUG_CHANNEL(&client->config.logger, &client->channel, + "Requesting to renew the SecureChannel"); + } else { + opnSecRq.requestType = UA_SECURITYTOKENREQUESTTYPE_ISSUE; + UA_LOG_DEBUG_CHANNEL(&client->config.logger, &client->channel, + "Requesting to open a SecureChannel"); + } + + /* Prepare the entry for the linked list */ + UA_UInt32 requestId = ++client->requestId; + + /* Send the OPN message */ + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL, + "Requesting to open a SecureChannel"); + retval = + UA_SecureChannel_sendAsymmetricOPNMessage(&client->channel, requestId, &opnSecRq, + &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]); + if(retval != UA_STATUSCODE_GOOD) { + client->connectStatus = retval; + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL, + "Sending OPN message failed with error %s", + UA_StatusCode_name(retval)); + closeSecureChannel(client); + return retval; + } + + client->channel.renewState = UA_SECURECHANNELRENEWSTATE_SENT; + if(client->channel.state < UA_SECURECHANNELSTATE_OPN_SENT) + client->channel.state = UA_SECURECHANNELSTATE_OPN_SENT; + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_SECURECHANNEL, "OPN message sent"); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Client_renewSecureChannel(UA_Client *client) { + /* Check if OPN has been sent or the SecureChannel is still valid */ + if(client->channel.state != UA_SECURECHANNELSTATE_OPEN || + client->channel.renewState == UA_SECURECHANNELRENEWSTATE_SENT || + client->nextChannelRenewal > UA_DateTime_nowMonotonic()) + return UA_STATUSCODE_GOODCALLAGAIN; + sendOPNAsync(client, true); + return client->connectStatus; +} + +static void +responseActivateSession(UA_Client *client, void *userdata, UA_UInt32 requestId, + void *response) { + UA_ActivateSessionResponse *activateResponse = + (UA_ActivateSessionResponse *)response; + if(activateResponse->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "ActivateSession failed with error code %s", + UA_StatusCode_name(activateResponse->responseHeader.serviceResult)); + if(activateResponse->responseHeader.serviceResult == UA_STATUSCODE_BADSESSIONIDINVALID || + activateResponse->responseHeader.serviceResult == UA_STATUSCODE_BADSESSIONCLOSED) { + /* The session is lost. Create a new one. */ + closeSession(client); + createSessionAsync(client); + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Session cannot be activated. Create a new Session."); + } else { + /* Something else is wrong. Give up. */ + client->connectStatus = activateResponse->responseHeader.serviceResult; + } + return; + } + + client->sessionState = UA_SESSIONSTATE_ACTIVATED; + notifyClientState(client); +} + +static UA_StatusCode +activateSessionAsync(UA_Client *client) { + UA_ActivateSessionRequest request; + UA_ActivateSessionRequest_init(&request); + request.requestHeader.requestHandle = ++client->requestHandle; + request.requestHeader.timestamp = UA_DateTime_now (); + request.requestHeader.timeoutHint = 600000; + UA_StatusCode retval = + UA_ExtensionObject_copy(&client->config.userIdentityToken, &request.userIdentityToken); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + if (client->config.sessionLocaleIdsSize && client->config.sessionLocaleIds) { + retval = UA_Array_copy(client->config.sessionLocaleIds, client->config.sessionLocaleIdsSize, + (void **)&request.localeIds, &UA_TYPES[UA_TYPES_LOCALEID]); + if (retval != UA_STATUSCODE_GOOD) + return retval; + + request.localeIdsSize = client->config.sessionLocaleIdsSize; + } + + /* If not token is set, use anonymous */ + if(request.userIdentityToken.encoding == UA_EXTENSIONOBJECT_ENCODED_NOBODY) { + UA_AnonymousIdentityToken *t = UA_AnonymousIdentityToken_new(); + if(!t) { + UA_ActivateSessionRequest_clear(&request); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + request.userIdentityToken.content.decoded.data = t; + request.userIdentityToken.content.decoded.type = &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]; + request.userIdentityToken.encoding = UA_EXTENSIONOBJECT_DECODED; + } + + /* Set the policy-Id from the endpoint. Every IdentityToken starts with a + * string. */ + retval = UA_String_copy(&client->config.userTokenPolicy.policyId, + (UA_String*)request.userIdentityToken.content.decoded.data); + +#ifdef UA_ENABLE_ENCRYPTION + /* Encrypt the UserIdentityToken */ + const UA_String *userTokenPolicy = &client->channel.securityPolicy->policyUri; + if(client->config.userTokenPolicy.securityPolicyUri.length > 0) + userTokenPolicy = &client->config.userTokenPolicy.securityPolicyUri; + retval |= encryptUserIdentityToken(client, userTokenPolicy, &request.userIdentityToken); + retval |= signActivateSessionRequest(client, &client->channel, &request); +#endif + + if(retval == UA_STATUSCODE_GOOD) + retval = UA_Client_sendAsyncRequest(client, &request, + &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST], + (UA_ClientAsyncServiceCallback) responseActivateSession, + &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE], NULL, NULL); + + UA_ActivateSessionRequest_clear(&request); + if(retval == UA_STATUSCODE_GOOD) + client->sessionState = UA_SESSIONSTATE_ACTIVATE_REQUESTED; + else + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "ActivateSession failed when sending the request with error code %s", + UA_StatusCode_name(retval)); + + return retval; +} + +/* Combination of UA_Client_getEndpointsInternal and getEndpoints */ +static void +responseGetEndpoints(UA_Client *client, void *userdata, UA_UInt32 requestId, + void *response) { + client->endpointsHandshake = false; + + UA_GetEndpointsResponse *resp = (UA_GetEndpointsResponse*)response; + /* GetEndpoints not possible. Fail the connection */ + if(resp->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + client->connectStatus = resp->responseHeader.serviceResult; + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "GetEndpointRequest failed with error code %s", + UA_StatusCode_name(client->connectStatus)); + UA_GetEndpointsResponse_clear(resp); + return; + } + + UA_Boolean endpointFound = false; + UA_Boolean tokenFound = false; + const UA_String binaryTransport = UA_STRING("http://opcfoundation.org/UA-Profile/" + "Transport/uatcp-uasc-uabinary"); + + // TODO: compare endpoint information with client->endpointUri + UA_EndpointDescription* endpointArray = resp->endpoints; + size_t endpointArraySize = resp->endpointsSize; + for(size_t i = 0; i < endpointArraySize; ++i) { + UA_EndpointDescription* endpoint = &endpointArray[i]; + /* Look out for binary transport endpoints. + * Note: Siemens returns empty ProfileUrl, we will accept it as binary. */ + if(endpoint->transportProfileUri.length != 0 && + !UA_String_equal (&endpoint->transportProfileUri, &binaryTransport)) + continue; + + /* Valid SecurityMode? */ + if(endpoint->securityMode < 1 || endpoint->securityMode > 3) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting endpoint %lu: invalid security mode", + (long unsigned)i); + continue; + } + + /* Selected SecurityMode? */ + if(client->config.securityMode > 0 && + client->config.securityMode != endpoint->securityMode) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting endpoint %lu: security mode doesn't match", + (long unsigned)i); + continue; + } + + /* Matching SecurityPolicy? */ + if(client->config.securityPolicyUri.length > 0 && + !UA_String_equal(&client->config.securityPolicyUri, + &endpoint->securityPolicyUri)) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting endpoint %lu: security policy doesn't match", + (long unsigned)i); + continue; + } + + /* SecurityPolicy available? */ + if(!getSecurityPolicy(client, endpoint->securityPolicyUri)) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting endpoint %lu: security policy not available", + (long unsigned)i); + continue; + } + + endpointFound = true; + + /* Look for a user token policy with an anonymous token */ + for(size_t j = 0; j < endpoint->userIdentityTokensSize; ++j) { + UA_UserTokenPolicy* tokenPolicy = &endpoint->userIdentityTokens[j]; + const UA_DataType *tokenType = client->config.userIdentityToken.content.decoded.type; + + /* Usertokens also have a security policy... */ + if(tokenPolicy->tokenType != UA_USERTOKENTYPE_ANONYMOUS && + tokenPolicy->securityPolicyUri.length > 0 && + !getSecurityPolicy(client, tokenPolicy->securityPolicyUri)) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting UserTokenPolicy %lu in endpoint %lu: " + "security policy '%.*s' not available", (long unsigned)j, (long unsigned)i, + (int)tokenPolicy->securityPolicyUri.length, + tokenPolicy->securityPolicyUri.data); + continue; + } + + if(tokenPolicy->tokenType > 3) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting UserTokenPolicy %lu in endpoint %lu: invalid token type", + (long unsigned)j, (long unsigned)i); + continue; + } + + if(tokenPolicy->tokenType == UA_USERTOKENTYPE_ANONYMOUS && + tokenType != &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN] && + tokenType != NULL) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting UserTokenPolicy %lu (anonymous) in endpoint %lu: " + "configuration doesn't match", (long unsigned)j, (long unsigned)i); + continue; + } + if(tokenPolicy->tokenType == UA_USERTOKENTYPE_USERNAME && + tokenType != &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting UserTokenPolicy %lu (username) in endpoint %lu: " + "configuration doesn't match", (long unsigned)j, (long unsigned)i); + continue; + } + if(tokenPolicy->tokenType == UA_USERTOKENTYPE_CERTIFICATE && + tokenType != &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting UserTokenPolicy %lu (certificate) in endpoint %lu: " + "configuration doesn't match", (long unsigned)j, (long unsigned)i); + continue; + } + if(tokenPolicy->tokenType == UA_USERTOKENTYPE_ISSUEDTOKEN && + tokenType != &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Rejecting UserTokenPolicy %lu (token) in endpoint %lu: " + "configuration doesn't match", (long unsigned)j, (long unsigned)i); + continue; + } + + /* Endpoint with matching usertokenpolicy found */ + +#if UA_LOGLEVEL <= 300 + const char *securityModeNames[3] = {"None", "Sign", "SignAndEncrypt"}; + const char *userTokenTypeNames[4] = {"Anonymous", "UserName", + "Certificate", "IssuedToken"}; + UA_String *securityPolicyUri = &tokenPolicy->securityPolicyUri; + if(securityPolicyUri->length == 0) + securityPolicyUri = &endpoint->securityPolicyUri; + + /* Log the selected endpoint */ + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Selected endpoint %lu in URL %.*s with SecurityMode %s and SecurityPolicy %.*s", + (long unsigned)i, (int)endpoint->endpointUrl.length, endpoint->endpointUrl.data, + securityModeNames[endpoint->securityMode - 1], + (int)endpoint->securityPolicyUri.length, + endpoint->securityPolicyUri.data); + + /* Log the selected UserTokenPolicy */ + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Selected UserTokenPolicy %.*s with UserTokenType %s and SecurityPolicy %.*s", + (int)tokenPolicy->policyId.length, tokenPolicy->policyId.data, + userTokenTypeNames[tokenPolicy->tokenType], + (int)securityPolicyUri->length, securityPolicyUri->data); +#endif + + /* Move to the client config */ + tokenFound = true; + UA_EndpointDescription_clear(&client->config.endpoint); + client->config.endpoint = *endpoint; + UA_EndpointDescription_init(endpoint); + UA_UserTokenPolicy_clear(&client->config.userTokenPolicy); + client->config.userTokenPolicy = *tokenPolicy; + UA_UserTokenPolicy_init(tokenPolicy); + + break; + } + + if(tokenFound) + break; + } + + if(!endpointFound) { + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "No suitable endpoint found"); + client->connectStatus = UA_STATUSCODE_BADINTERNALERROR; + } else if(!tokenFound) { + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "No suitable UserTokenPolicy found for the possible endpoints"); + client->connectStatus = UA_STATUSCODE_BADINTERNALERROR; + } + + /* Close the SecureChannel if a different SecurityPolicy is defined by the Endpoint */ + if(client->config.endpoint.securityMode != client->channel.securityMode || + !UA_String_equal(&client->config.endpoint.securityPolicyUri, + &client->channel.securityPolicy->policyUri)) + closeSecureChannel(client); +} + +static UA_StatusCode +requestGetEndpoints(UA_Client *client) { + UA_GetEndpointsRequest request; + UA_GetEndpointsRequest_init(&request); + request.requestHeader.timestamp = UA_DateTime_now(); + request.requestHeader.timeoutHint = 10000; + request.endpointUrl = client->endpointUrl; + UA_StatusCode retval = + UA_Client_sendAsyncRequest(client, &request, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST], + (UA_ClientAsyncServiceCallback) responseGetEndpoints, + &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE], NULL, NULL); + if(retval == UA_STATUSCODE_GOOD) + client->endpointsHandshake = true; + else + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "RequestGetEndpoints failed when sending the request with error code %s", + UA_StatusCode_name(retval)); + return retval; +} + +static void +responseSessionCallback(UA_Client *client, void *userdata, + UA_UInt32 requestId, void *response) { + UA_CreateSessionResponse *sessionResponse = (UA_CreateSessionResponse*)response; + UA_StatusCode res = sessionResponse->responseHeader.serviceResult; + if(res != UA_STATUSCODE_GOOD) + goto cleanup; + +#ifdef UA_ENABLE_ENCRYPTION + if(client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGN || + client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + /* Verify the session response was created with the same certificate as + * the SecureChannel */ + if(!UA_ByteString_equal(&sessionResponse->serverCertificate, + &client->channel.remoteCertificate)) { + res = UA_STATUSCODE_BADCERTIFICATEINVALID; + goto cleanup; + } + + /* Verify the client signature */ + res = checkCreateSessionSignature(client, &client->channel, sessionResponse); + if(res != UA_STATUSCODE_GOOD) + goto cleanup; + } +#endif + + /* Copy nonce and AuthenticationToken */ + UA_ByteString_clear(&client->remoteNonce); + UA_NodeId_clear(&client->authenticationToken); + res |= UA_ByteString_copy(&sessionResponse->serverNonce, &client->remoteNonce); + res |= UA_NodeId_copy(&sessionResponse->authenticationToken, &client->authenticationToken); + if(res != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Activate the new Session */ + client->sessionState = UA_SESSIONSTATE_CREATED; + + cleanup: + client->connectStatus = res; + if(client->connectStatus != UA_STATUSCODE_GOOD) + client->sessionState = UA_SESSIONSTATE_CLOSED; +} + +static UA_StatusCode +createSessionAsync(UA_Client *client) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGN || + client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + if(client->localNonce.length != UA_SESSION_LOCALNONCELENGTH) { + UA_ByteString_clear(&client->localNonce); + retval = UA_ByteString_allocBuffer(&client->localNonce, + UA_SESSION_LOCALNONCELENGTH); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + retval = client->channel.securityPolicy->symmetricModule. + generateNonce(client->channel.securityPolicy->policyContext, + &client->localNonce); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + UA_CreateSessionRequest request; + UA_CreateSessionRequest_init(&request); + request.requestHeader.requestHandle = ++client->requestHandle; + request.requestHeader.timestamp = UA_DateTime_now(); + request.requestHeader.timeoutHint = 10000; + UA_ByteString_copy(&client->localNonce, &request.clientNonce); + request.requestedSessionTimeout = client->config.requestedSessionTimeout; + request.maxResponseMessageSize = UA_INT32_MAX; + UA_String_copy(&client->config.endpoint.endpointUrl, &request.endpointUrl); + UA_ApplicationDescription_copy(&client->config.clientDescription, + &request.clientDescription); + + if(client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGN || + client->channel.securityMode == UA_MESSAGESECURITYMODE_SIGNANDENCRYPT) { + UA_ByteString_copy(&client->channel.securityPolicy->localCertificate, + &request.clientCertificate); + } + + retval = UA_Client_sendAsyncRequest(client, &request, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST], + (UA_ClientAsyncServiceCallback)responseSessionCallback, + &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE], NULL, NULL); + UA_CreateSessionRequest_clear(&request); + + if(retval == UA_STATUSCODE_GOOD) + client->sessionState = UA_SESSIONSTATE_CREATE_REQUESTED; + else + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "CreateSession failed when sending the request with error code %s", + UA_StatusCode_name(retval)); + + return retval; +} + +static UA_StatusCode +initConnect(UA_Client *client); + +UA_StatusCode +connectIterate(UA_Client *client, UA_UInt32 timeout) { + UA_LOG_TRACE(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Client connect iterate"); + + /* Already connected */ + if(client->sessionState == UA_SESSIONSTATE_ACTIVATED) + return UA_STATUSCODE_GOOD; + + /* Could not connect */ + if(client->connectStatus != UA_STATUSCODE_GOOD) + return client->connectStatus; + + /* The connection was already closed */ + if(client->channel.state == UA_SECURECHANNELSTATE_CLOSING) { + client->connectStatus = UA_STATUSCODE_BADCONNECTIONCLOSED; + return UA_STATUSCODE_BADCONNECTIONCLOSED; + } + + /* The connection is closed. Reset the SecureChannel and open a new TCP + * connection */ + if(client->connection.state == UA_CONNECTIONSTATE_CLOSED) + return initConnect(client); + + ua_print("ua: [%s] state %d %d handle %p\n", __func__, client->connectStatus, + client->connection.state, client->connection.handle); + + /* Poll the connection status */ + if(client->connection.state == UA_CONNECTIONSTATE_OPENING) { + client->connectStatus = + client->config.pollConnectionFunc(&client->connection, timeout, + &client->config.logger); + + ua_print("ua: [%s] exit conn %x %d time %d handle %p\n", __func__, + client->connectStatus, + client->connection.state, timeout, client->connection.handle); + + return client->connectStatus; + } + + /* Attach the connection to the SecureChannel */ + if(!client->channel.connection) + UA_Connection_attachSecureChannel(&client->connection, &client->channel); + + /* Set the SecurityPolicy */ + if(!client->channel.securityPolicy) { + client->channel.securityMode = client->config.endpoint.securityMode; + if(client->channel.securityMode == UA_MESSAGESECURITYMODE_INVALID) + client->channel.securityMode = UA_MESSAGESECURITYMODE_NONE; + + UA_SecurityPolicy *sp = NULL; + if(client->config.endpoint.securityPolicyUri.length == 0) { + sp = getSecurityPolicy(client, + UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None")); + } else { + sp = getSecurityPolicy(client, client->config.endpoint.securityPolicyUri); + } + if(!sp) { + client->connectStatus = UA_STATUSCODE_BADINTERNALERROR; + return client->connectStatus; + } + + client->connectStatus = + UA_SecureChannel_setSecurityPolicy(&client->channel, sp, + &client->config.endpoint.serverCertificate); + if(client->connectStatus != UA_STATUSCODE_GOOD) + return client->connectStatus; + } + + /* Open the SecureChannel */ + switch(client->channel.state) { + case UA_SECURECHANNELSTATE_FRESH: + client->connectStatus = sendHELMessage(client); + if(client->connectStatus == UA_STATUSCODE_GOOD) { + client->channel.state = UA_SECURECHANNELSTATE_HEL_SENT; + } else { + client->connection.ua_close(&client->connection); + client->connection.free(&client->connection); + } + return client->connectStatus; + case UA_SECURECHANNELSTATE_ACK_RECEIVED: + client->connectStatus = sendOPNAsync(client, false); + return client->connectStatus; + case UA_SECURECHANNELSTATE_HEL_SENT: + case UA_SECURECHANNELSTATE_OPN_SENT: + client->connectStatus = receiveResponseAsync(client, timeout); + return client->connectStatus; + default: + break; + } + + /* Have a SecureChannel but no session */ + if(client->noSession) + return client->connectStatus; + + /* Create and Activate the Session */ + switch(client->sessionState) { + case UA_SESSIONSTATE_CLOSED: + if(!endpointUnconfigured(client)) { + client->connectStatus = createSessionAsync(client); + return client->connectStatus; + } + if(!client->endpointsHandshake) { + client->connectStatus = requestGetEndpoints(client); + return client->connectStatus; + } + receiveResponseAsync(client, timeout); + return client->connectStatus; + case UA_SESSIONSTATE_CREATE_REQUESTED: + case UA_SESSIONSTATE_ACTIVATE_REQUESTED: + receiveResponseAsync(client, timeout); + return client->connectStatus; + case UA_SESSIONSTATE_CREATED: + client->connectStatus = activateSessionAsync(client); + return client->connectStatus; + default: + break; + } + + return client->connectStatus; +} + +/* The local ApplicationURI has to match the certificates of the + * SecurityPolicies */ +static void +verifyClientApplicationURI(const UA_Client *client) { +#if defined(UA_ENABLE_ENCRYPTION) && (UA_LOGLEVEL <= 400) + for(size_t i = 0; i < client->config.securityPoliciesSize; i++) { + UA_SecurityPolicy *sp = &client->config.securityPolicies[i]; + UA_StatusCode retval = + client->config.certificateVerification. + verifyApplicationURI(client->config.certificateVerification.context, + &sp->localCertificate, + &client->config.clientDescription.applicationUri); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "The configured ApplicationURI does not match the URI " + "specified in the certificate for the SecurityPolicy %.*s", + (int)sp->policyUri.length, sp->policyUri.data); + } + } +#endif +} + +static UA_StatusCode +client_configure_securechannel(void *application, UA_SecureChannel *channel, + const UA_AsymmetricAlgorithmSecurityHeader *asymHeader) { + // TODO: Verify if certificate is the same as configured in the client endpoint config + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +initConnect(UA_Client *client) { + if(client->connection.state > UA_CONNECTIONSTATE_CLOSED) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Client already connected"); + return UA_STATUSCODE_GOOD; + } + + if(client->config.initConnectionFunc == NULL) { + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Client connection not configured"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Consistency check the client's own ApplicationURI */ + verifyClientApplicationURI(client); + + /* Reset the connect status */ + client->connectStatus = UA_STATUSCODE_GOOD; + client->channel.renewState = UA_SECURECHANNELRENEWSTATE_NORMAL; + client->endpointsHandshake = false; + + /* Initialize the SecureChannel */ + UA_SecureChannel_init(&client->channel, &client->config.localConnectionConfig); + client->channel.certificateVerification = &client->config.certificateVerification; + client->channel.processOPNHeader = client_configure_securechannel; + + if(client->connection.free) + client->connection.free(&client->connection); + + ua_print("ua: [%s] init %d %s\n", __func__, client->endpointUrl.length, client->endpointUrl.data); + + /* Initialize the TCP connection */ + client->connection = + client->config.initConnectionFunc(client->config.localConnectionConfig, + client->endpointUrl, client->config.timeout, + &client->config.logger); + if(client->connection.state != UA_CONNECTIONSTATE_OPENING) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Could not open a TCP connection to %.*s", + (int)client->endpointUrl.length, client->endpointUrl.data); + client->connectStatus = UA_STATUSCODE_BADCONNECTIONCLOSED; + closeSecureChannel(client); + } + + return client->connectStatus; +} + +UA_StatusCode +UA_Client_connectAsync(UA_Client *client, const char *endpointUrl) { + /* Set the endpoint URL the client connects to */ + UA_String_clear(&client->endpointUrl); + client->endpointUrl = UA_STRING_ALLOC(endpointUrl); + + /* Open a Session when possible */ + client->noSession = false; + + /* Connect Async */ + return initConnect(client); +} + +UA_StatusCode +UA_Client_connectSecureChannelAsync(UA_Client *client, const char *endpointUrl) { + /* Set the endpoint URL the client connects to */ + UA_String_clear(&client->endpointUrl); + client->endpointUrl = UA_STRING_ALLOC(endpointUrl); + + /* Don't open a Session */ + client->noSession = true; + + /* Connect Async */ + return initConnect(client); +} + +static UA_StatusCode +connectSync(UA_Client *client) { + UA_DateTime now = UA_DateTime_nowMonotonic(); + UA_DateTime maxDate = now + ((UA_DateTime)client->config.timeout * UA_DATETIME_MSEC); + + UA_StatusCode retval = initConnect(client); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + while(retval == UA_STATUSCODE_GOOD) { + if(client->sessionState == UA_SESSIONSTATE_ACTIVATED) + break; + if(client->noSession && client->channel.state == UA_SECURECHANNELSTATE_OPEN) + break; + now = UA_DateTime_nowMonotonic(); + if(maxDate < now) + return UA_STATUSCODE_BADTIMEOUT; + retval = UA_Client_run_iterate(client, + (UA_UInt32)((maxDate - now) / UA_DATETIME_MSEC)); + } + + return retval; +} + +UA_StatusCode +UA_Client_connect(UA_Client *client, const char *endpointUrl) { + /* Set the endpoint URL the client connects to */ + UA_String_clear(&client->endpointUrl); + client->endpointUrl = UA_STRING_ALLOC(endpointUrl); + + /* Open a Session when possible */ + client->noSession = false; + + /* Connect Synchronous */ + return connectSync(client); +} + +UA_StatusCode +UA_Client_connectSecureChannel(UA_Client *client, const char *endpointUrl) { + /* Set the endpoint URL the client connects to */ + UA_String_clear(&client->endpointUrl); + client->endpointUrl = UA_STRING_ALLOC(endpointUrl); + + /* Don't open a Session */ + client->noSession = true; + + /* Connect Synchronous */ + return connectSync(client); +} + +/************************/ +/* Close the Connection */ +/************************/ + +void +closeSecureChannel(UA_Client *client) { + /* Send CLO if the SecureChannel is open */ + if(client->channel.state == UA_SECURECHANNELSTATE_OPEN) { + UA_CloseSecureChannelRequest request; + UA_CloseSecureChannelRequest_init(&request); + request.requestHeader.requestHandle = ++client->requestHandle; + request.requestHeader.timestamp = UA_DateTime_now(); + request.requestHeader.timeoutHint = 10000; + request.requestHeader.authenticationToken = client->authenticationToken; + UA_SecureChannel_sendSymmetricMessage(&client->channel, ++client->requestId, + UA_MESSAGETYPE_CLO, &request, + &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]); + } + + /* Clean up */ + client->channel.renewState = UA_SECURECHANNELRENEWSTATE_NORMAL; + UA_SecureChannel_close(&client->channel); + if(client->connection.free) + client->connection.free(&client->connection); + + /* Set the Session to "Created" if it was "Activated" */ + if(client->sessionState > UA_SESSIONSTATE_CREATED) + client->sessionState = UA_SESSIONSTATE_CREATED; +} + +static void +sendCloseSession(UA_Client *client) { + /* Set before sending the message to prevent recursion */ + client->sessionState = UA_SESSIONSTATE_CLOSING; + + UA_CloseSessionRequest request; + UA_CloseSessionRequest_init(&request); + request.requestHeader.timestamp = UA_DateTime_now(); + request.requestHeader.timeoutHint = 10000; + request.deleteSubscriptions = true; + UA_CloseSessionResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST], + &response, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]); + UA_CloseSessionRequest_clear(&request); + UA_CloseSessionResponse_clear(&response); +} + +static void +closeSession(UA_Client *client) { + /* Is a session established? */ + if(client->sessionState == UA_SESSIONSTATE_ACTIVATED) + sendCloseSession(client); + + UA_NodeId_clear(&client->authenticationToken); + client->requestHandle = 0; + client->sessionState = UA_SESSIONSTATE_CLOSED; + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* We need to clean up the subscriptions */ + UA_Client_Subscriptions_clean(client); +#endif + + /* Reset so the next async connect creates a session by default */ + client->noSession = false; + + /* Delete outstanding async services */ + UA_Client_AsyncService_removeAll(client, UA_STATUSCODE_BADSESSIONCLOSED); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + client->currentlyOutStandingPublishRequests = 0; +#endif +} + +static void +closeSessionCallback(UA_Client *client, void *userdata, + UA_UInt32 requestId, void *response) { + closeSession(client); + closeSecureChannel(client); + notifyClientState(client); +} + +UA_StatusCode UA_EXPORT +UA_Client_disconnectAsync(UA_Client *client) { + /* Set before sending the message to prevent recursion */ + client->sessionState = UA_SESSIONSTATE_CLOSING; + + UA_CloseSessionRequest request; + UA_CloseSessionRequest_init(&request); + request.requestHeader.timestamp = UA_DateTime_now(); + request.requestHeader.timeoutHint = 10000; + request.deleteSubscriptions = true; + UA_StatusCode res = + UA_Client_sendAsyncRequest(client, &request, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST], + (UA_ClientAsyncServiceCallback)closeSessionCallback, + &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE], NULL, NULL); + notifyClientState(client); + return res; +} + +UA_StatusCode +UA_Client_disconnectSecureChannel(UA_Client *client) { + closeSecureChannel(client); + notifyClientState(client); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Client_disconnect(UA_Client *client) { + closeSession(client); + closeSecureChannel(client); + notifyClientState(client); + return UA_STATUSCODE_GOOD; +} + + +/**** amalgamated original file "/src/client/ua_client_discovery.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + +/* Gets a list of endpoints. Memory is allocated for endpointDescription array */ +static UA_StatusCode +UA_Client_getEndpointsInternal(UA_Client *client, const UA_String endpointUrl, + size_t *endpointDescriptionsSize, + UA_EndpointDescription **endpointDescriptions) { + UA_GetEndpointsRequest request; + UA_GetEndpointsRequest_init(&request); + request.requestHeader.timestamp = UA_DateTime_now(); + request.requestHeader.timeoutHint = 10000; + // assume the endpointurl outlives the service call + request.endpointUrl = endpointUrl; + + UA_GetEndpointsResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST], + &response, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]); + + if(response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_StatusCode retval = response.responseHeader.serviceResult; + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "GetEndpointRequest failed with error code %s", + UA_StatusCode_name(retval)); + UA_GetEndpointsResponse_clear(&response); + return retval; + } + *endpointDescriptions = response.endpoints; + *endpointDescriptionsSize = response.endpointsSize; + response.endpoints = NULL; + response.endpointsSize = 0; + UA_GetEndpointsResponse_clear(&response); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Client_getEndpoints(UA_Client *client, const char *serverUrl, + size_t* endpointDescriptionsSize, + UA_EndpointDescription** endpointDescriptions) { + UA_Boolean connected = (client->channel.state == UA_SECURECHANNELSTATE_OPEN); + /* Client is already connected to a different server */ + if(connected && strncmp((const char*)client->config.endpoint.endpointUrl.data, serverUrl, + client->config.endpoint.endpointUrl.length) != 0) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval; + const UA_String url = UA_STRING((char*)(uintptr_t)serverUrl); + if(!connected) { + retval = UA_Client_connectSecureChannel(client, serverUrl); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + retval = UA_Client_getEndpointsInternal(client, url, endpointDescriptionsSize, + endpointDescriptions); + + if(!connected) + UA_Client_disconnect(client); + return retval; +} + +UA_StatusCode +UA_Client_findServers(UA_Client *client, const char *serverUrl, + size_t serverUrisSize, UA_String *serverUris, + size_t localeIdsSize, UA_String *localeIds, + size_t *registeredServersSize, + UA_ApplicationDescription **registeredServers) { + UA_Boolean connected = (client->channel.state == UA_SECURECHANNELSTATE_OPEN); + /* Client is already connected to a different server */ + if(connected && strncmp((const char*)client->config.endpoint.endpointUrl.data, serverUrl, + client->config.endpoint.endpointUrl.length) != 0) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval; + if(!connected) { + retval = UA_Client_connectSecureChannel(client, serverUrl); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + /* Prepare the request */ + UA_FindServersRequest request; + UA_FindServersRequest_init(&request); + request.serverUrisSize = serverUrisSize; + request.serverUris = serverUris; + request.localeIdsSize = localeIdsSize; + request.localeIds = localeIds; + + /* Send the request */ + UA_FindServersResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST], + &response, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]); + + /* Process the response */ + retval = response.responseHeader.serviceResult; + if(retval == UA_STATUSCODE_GOOD) { + *registeredServersSize = response.serversSize; + *registeredServers = response.servers; + response.serversSize = 0; + response.servers = NULL; + } else { + *registeredServersSize = 0; + *registeredServers = NULL; + } + + /* Clean up */ + UA_FindServersResponse_clear(&response); + if(!connected) + UA_Client_disconnect(client); + return retval; +} + +#ifdef UA_ENABLE_DISCOVERY + +UA_StatusCode +UA_Client_findServersOnNetwork(UA_Client *client, const char *serverUrl, + UA_UInt32 startingRecordId, UA_UInt32 maxRecordsToReturn, + size_t serverCapabilityFilterSize, UA_String *serverCapabilityFilter, + size_t *serverOnNetworkSize, UA_ServerOnNetwork **serverOnNetwork) { + UA_Boolean connected = (client->channel.state == UA_SECURECHANNELSTATE_OPEN); + /* Client is already connected to a different server */ + if(connected && strncmp((const char*)client->config.endpoint.endpointUrl.data, serverUrl, + client->config.endpoint.endpointUrl.length) != 0) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval; + if(!connected) { + retval = UA_Client_connectSecureChannel(client, serverUrl); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + /* Prepare the request */ + UA_FindServersOnNetworkRequest request; + UA_FindServersOnNetworkRequest_init(&request); + request.startingRecordId = startingRecordId; + request.maxRecordsToReturn = maxRecordsToReturn; + request.serverCapabilityFilterSize = serverCapabilityFilterSize; + request.serverCapabilityFilter = serverCapabilityFilter; + + /* Send the request */ + UA_FindServersOnNetworkResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKREQUEST], + &response, &UA_TYPES[UA_TYPES_FINDSERVERSONNETWORKRESPONSE]); + + /* Process the response */ + retval = response.responseHeader.serviceResult; + if(retval == UA_STATUSCODE_GOOD) { + *serverOnNetworkSize = response.serversSize; + *serverOnNetwork = response.servers; + response.serversSize = 0; + response.servers = NULL; + } else { + *serverOnNetworkSize = 0; + *serverOnNetwork = NULL; + } + + /* Clean up */ + UA_FindServersOnNetworkResponse_clear(&response); + if(!connected) + UA_Client_disconnect(client); + return retval; +} + +#endif + +/**** amalgamated original file "/src/client/ua_client_highlevel.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2021 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Florian Palm + * Copyright 2016 (c) Chris Iatrou + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Fabian Arndt + * Copyright 2018 (c) Peter Rustler, basyskom GmbH + */ + + +/* The highlevel client API is an "outer onion layer". This file does not + * include ua_client_internal.h on purpose. */ + +UA_StatusCode +UA_Client_NamespaceGetIndex(UA_Client *client, UA_String *namespaceUri, + UA_UInt16 *namespaceIndex) { + UA_ReadRequest request; + UA_ReadRequest_init(&request); + UA_ReadValueId id; + UA_ReadValueId_init(&id); + id.attributeId = UA_ATTRIBUTEID_VALUE; + id.nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_NAMESPACEARRAY); + request.nodesToRead = &id; + request.nodesToReadSize = 1; + + UA_ReadResponse response = UA_Client_Service_read(client, request); + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) + retval = response.responseHeader.serviceResult; + else if(response.resultsSize != 1 || !response.results[0].hasValue) + retval = UA_STATUSCODE_BADNODEATTRIBUTESINVALID; + else if(response.results[0].value.type != &UA_TYPES[UA_TYPES_STRING]) + retval = UA_STATUSCODE_BADTYPEMISMATCH; + + if(retval != UA_STATUSCODE_GOOD) { + UA_ReadResponse_clear(&response); + return retval; + } + + retval = UA_STATUSCODE_BADNOTFOUND; + UA_String *ns = (UA_String *)response.results[0].value.data; + for(size_t i = 0; i < response.results[0].value.arrayLength; ++i) { + if(UA_String_equal(namespaceUri, &ns[i])) { + *namespaceIndex = (UA_UInt16)i; + retval = UA_STATUSCODE_GOOD; + break; + } + } + + UA_ReadResponse_clear(&response); + return retval; +} + +UA_StatusCode +UA_Client_forEachChildNodeCall(UA_Client *client, UA_NodeId parentNodeId, + UA_NodeIteratorCallback callback, void *handle) { + UA_BrowseRequest bReq; + UA_BrowseRequest_init(&bReq); + bReq.requestedMaxReferencesPerNode = 0; + bReq.nodesToBrowse = UA_BrowseDescription_new(); + bReq.nodesToBrowseSize = 1; + UA_NodeId_copy(&parentNodeId, &bReq.nodesToBrowse[0].nodeId); + bReq.nodesToBrowse[0].resultMask = UA_BROWSERESULTMASK_ALL; //return everything + bReq.nodesToBrowse[0].browseDirection = UA_BROWSEDIRECTION_BOTH; + + UA_BrowseResponse bResp = UA_Client_Service_browse(client, bReq); + + UA_StatusCode retval = bResp.responseHeader.serviceResult; + if(retval == UA_STATUSCODE_GOOD) { + for(size_t i = 0; i < bResp.resultsSize; ++i) { + for(size_t j = 0; j < bResp.results[i].referencesSize; ++j) { + UA_ReferenceDescription *ref = &bResp.results[i].references[j]; + retval |= callback(ref->nodeId.nodeId, !ref->isForward, + ref->referenceTypeId, handle); + } + } + } + + UA_BrowseRequest_clear(&bReq); + UA_BrowseResponse_clear(&bResp); + return retval; +} + +/*******************/ +/* Node Management */ +/*******************/ + +UA_StatusCode +UA_Client_addReference(UA_Client *client, const UA_NodeId sourceNodeId, + const UA_NodeId referenceTypeId, UA_Boolean isForward, + const UA_String targetServerUri, + const UA_ExpandedNodeId targetNodeId, + UA_NodeClass targetNodeClass) { + UA_AddReferencesItem item; + UA_AddReferencesItem_init(&item); + item.sourceNodeId = sourceNodeId; + item.referenceTypeId = referenceTypeId; + item.isForward = isForward; + item.targetServerUri = targetServerUri; + item.targetNodeId = targetNodeId; + item.targetNodeClass = targetNodeClass; + UA_AddReferencesRequest request; + UA_AddReferencesRequest_init(&request); + request.referencesToAdd = &item; + request.referencesToAddSize = 1; + UA_AddReferencesResponse response = UA_Client_Service_addReferences(client, request); + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval != UA_STATUSCODE_GOOD) { + UA_AddReferencesResponse_clear(&response); + return retval; + } + if(response.resultsSize != 1) { + UA_AddReferencesResponse_clear(&response); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + retval = response.results[0]; + UA_AddReferencesResponse_clear(&response); + return retval; +} + +UA_StatusCode +UA_Client_deleteReference(UA_Client *client, const UA_NodeId sourceNodeId, + const UA_NodeId referenceTypeId, UA_Boolean isForward, + const UA_ExpandedNodeId targetNodeId, + UA_Boolean deleteBidirectional) { + UA_DeleteReferencesItem item; + UA_DeleteReferencesItem_init(&item); + item.sourceNodeId = sourceNodeId; + item.referenceTypeId = referenceTypeId; + item.isForward = isForward; + item.targetNodeId = targetNodeId; + item.deleteBidirectional = deleteBidirectional; + UA_DeleteReferencesRequest request; + UA_DeleteReferencesRequest_init(&request); + request.referencesToDelete = &item; + request.referencesToDeleteSize = 1; + UA_DeleteReferencesResponse response = UA_Client_Service_deleteReferences(client, request); + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval != UA_STATUSCODE_GOOD) { + UA_DeleteReferencesResponse_clear(&response); + return retval; + } + if(response.resultsSize != 1) { + UA_DeleteReferencesResponse_clear(&response); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + retval = response.results[0]; + UA_DeleteReferencesResponse_clear(&response); + return retval; +} + +UA_StatusCode +UA_Client_deleteNode(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean deleteTargetReferences) { + UA_DeleteNodesItem item; + UA_DeleteNodesItem_init(&item); + item.nodeId = nodeId; + item.deleteTargetReferences = deleteTargetReferences; + UA_DeleteNodesRequest request; + UA_DeleteNodesRequest_init(&request); + request.nodesToDelete = &item; + request.nodesToDeleteSize = 1; + UA_DeleteNodesResponse response = UA_Client_Service_deleteNodes(client, request); + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval != UA_STATUSCODE_GOOD) { + UA_DeleteNodesResponse_clear(&response); + return retval; + } + if(response.resultsSize != 1) { + UA_DeleteNodesResponse_clear(&response); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + retval = response.results[0]; + UA_DeleteNodesResponse_clear(&response); + return retval; +} + +UA_StatusCode +__UA_Client_addNode(UA_Client *client, const UA_NodeClass nodeClass, + const UA_NodeId requestedNewNodeId, const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, const UA_NodeAttributes *attr, + const UA_DataType *attributeType, UA_NodeId *outNewNodeId) { + UA_AddNodesRequest request; + UA_AddNodesRequest_init(&request); + UA_AddNodesItem item; + UA_AddNodesItem_init(&item); + item.parentNodeId.nodeId = parentNodeId; + item.referenceTypeId = referenceTypeId; + item.requestedNewNodeId.nodeId = requestedNewNodeId; + item.browseName = browseName; + item.nodeClass = nodeClass; + item.typeDefinition.nodeId = typeDefinition; + item.nodeAttributes.encoding = UA_EXTENSIONOBJECT_DECODED_NODELETE; + item.nodeAttributes.content.decoded.type = attributeType; + item.nodeAttributes.content.decoded.data = (void*)(uintptr_t)attr; // hack. is not written into. + request.nodesToAdd = &item; + request.nodesToAddSize = 1; + UA_AddNodesResponse response = UA_Client_Service_addNodes(client, request); + + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval != UA_STATUSCODE_GOOD) { + UA_AddNodesResponse_clear(&response); + return retval; + } + + if(response.resultsSize != 1) { + UA_AddNodesResponse_clear(&response); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + + /* Move the id of the created node */ + retval = response.results[0].statusCode; + if(retval == UA_STATUSCODE_GOOD && outNewNodeId) { + *outNewNodeId = response.results[0].addedNodeId; + UA_NodeId_init(&response.results[0].addedNodeId); + } + + UA_AddNodesResponse_clear(&response); + return retval; +} + +/********/ +/* Call */ +/********/ + +#ifdef UA_ENABLE_METHODCALLS + +UA_StatusCode +UA_Client_call(UA_Client *client, const UA_NodeId objectId, + const UA_NodeId methodId, size_t inputSize, + const UA_Variant *input, size_t *outputSize, + UA_Variant **output) { + /* Set up the request */ + UA_CallRequest request; + UA_CallRequest_init(&request); + UA_CallMethodRequest item; + UA_CallMethodRequest_init(&item); + item.methodId = methodId; + item.objectId = objectId; + item.inputArguments = (UA_Variant *)(void*)(uintptr_t)input; // cast const... + item.inputArgumentsSize = inputSize; + request.methodsToCall = &item; + request.methodsToCallSize = 1; + + /* Call the service */ + UA_CallResponse response = UA_Client_Service_call(client, request); + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval == UA_STATUSCODE_GOOD) { + if(response.resultsSize == 1) + retval = response.results[0].statusCode; + else + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + } + if(retval != UA_STATUSCODE_GOOD) { + UA_CallResponse_clear(&response); + return retval; + } + + /* Move the output arguments */ + if(output != NULL && outputSize != NULL) { + *output = response.results[0].outputArguments; + *outputSize = response.results[0].outputArgumentsSize; + response.results[0].outputArguments = NULL; + response.results[0].outputArgumentsSize = 0; + } + UA_CallResponse_clear(&response); + return retval; +} + +#endif + +/********************/ +/* Write Attributes */ +/********************/ + +UA_StatusCode +__UA_Client_writeAttribute(UA_Client *client, const UA_NodeId *nodeId, + UA_AttributeId attributeId, const void *in, + const UA_DataType *inDataType) { + if(!in) + return UA_STATUSCODE_BADTYPEMISMATCH; + + UA_WriteValue wValue; + UA_WriteValue_init(&wValue); + wValue.nodeId = *nodeId; + wValue.attributeId = attributeId; + if(attributeId == UA_ATTRIBUTEID_VALUE) + wValue.value.value = *(const UA_Variant*)in; + else + /* hack. is never written into. */ + UA_Variant_setScalar(&wValue.value.value, (void*)(uintptr_t)in, inDataType); + wValue.value.hasValue = true; + UA_WriteRequest wReq; + UA_WriteRequest_init(&wReq); + wReq.nodesToWrite = &wValue; + wReq.nodesToWriteSize = 1; + + UA_WriteResponse wResp = UA_Client_Service_write(client, wReq); + + UA_StatusCode retval = wResp.responseHeader.serviceResult; + if(retval == UA_STATUSCODE_GOOD) { + if(wResp.resultsSize == 1) + retval = wResp.results[0]; + else + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + } + + UA_WriteResponse_clear(&wResp); + return retval; +} + +UA_StatusCode +UA_Client_writeArrayDimensionsAttribute(UA_Client *client, const UA_NodeId nodeId, + size_t newArrayDimensionsSize, + const UA_UInt32 *newArrayDimensions) { + if(!newArrayDimensions) + return UA_STATUSCODE_BADTYPEMISMATCH; + + UA_WriteValue wValue; + UA_WriteValue_init(&wValue); + wValue.nodeId = nodeId; + wValue.attributeId = UA_ATTRIBUTEID_ARRAYDIMENSIONS; + UA_Variant_setArray(&wValue.value.value, (void*)(uintptr_t)newArrayDimensions, + newArrayDimensionsSize, &UA_TYPES[UA_TYPES_UINT32]); + wValue.value.hasValue = true; + UA_WriteRequest wReq; + UA_WriteRequest_init(&wReq); + wReq.nodesToWrite = &wValue; + wReq.nodesToWriteSize = 1; + + UA_WriteResponse wResp = UA_Client_Service_write(client, wReq); + + UA_StatusCode retval = wResp.responseHeader.serviceResult; + if(retval == UA_STATUSCODE_GOOD) { + if(wResp.resultsSize == 1) + retval = wResp.results[0]; + else + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + } + UA_WriteResponse_clear(&wResp); + return retval; +} + +/*******************/ +/* Read Attributes */ +/*******************/ + +UA_StatusCode +__UA_Client_readAttribute(UA_Client *client, const UA_NodeId *nodeId, + UA_AttributeId attributeId, void *out, + const UA_DataType *outDataType) { + UA_ReadValueId item; + UA_ReadValueId_init(&item); + item.nodeId = *nodeId; + item.attributeId = attributeId; + UA_ReadRequest request; + UA_ReadRequest_init(&request); + request.nodesToRead = &item; + request.nodesToReadSize = 1; + UA_ReadResponse response = UA_Client_Service_read(client, request); + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval == UA_STATUSCODE_GOOD) { + if(response.resultsSize == 1) + retval = response.results[0].status; + else + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + } + if(retval != UA_STATUSCODE_GOOD) { + UA_ReadResponse_clear(&response); + return retval; + } + + /* Set the StatusCode */ + UA_DataValue *res = response.results; + if(res->hasStatus) + retval = res->status; + + /* Return early of no value is given */ + if(!res->hasValue) { + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + UA_ReadResponse_clear(&response); + return retval; + } + + /* Copy value into out */ + if(attributeId == UA_ATTRIBUTEID_VALUE) { + memcpy(out, &res->value, sizeof(UA_Variant)); + UA_Variant_init(&res->value); + } else if(attributeId == UA_ATTRIBUTEID_NODECLASS) { + memcpy(out, (UA_NodeClass*)res->value.data, sizeof(UA_NodeClass)); + } else if(UA_Variant_isScalar(&res->value) && + res->value.type == outDataType) { + memcpy(out, res->value.data, res->value.type->memSize); + UA_free(res->value.data); + res->value.data = NULL; + } else { + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + } + + UA_ReadResponse_clear(&response); + return retval; +} + +static UA_StatusCode +processReadArrayDimensionsResult(UA_ReadResponse *response, + UA_UInt32 **outArrayDimensions, + size_t *outArrayDimensionsSize) { + UA_StatusCode retval = response->responseHeader.serviceResult; + if(retval != UA_STATUSCODE_GOOD) + return retval; + + if(response->resultsSize != 1) + return UA_STATUSCODE_BADUNEXPECTEDERROR; + + retval = response->results[0].status; + if(retval != UA_STATUSCODE_GOOD) + return retval; + + UA_DataValue *res = &response->results[0]; + if(!res->hasValue || + UA_Variant_isScalar(&res->value) || + res->value.type != &UA_TYPES[UA_TYPES_UINT32]) + return UA_STATUSCODE_BADUNEXPECTEDERROR; + + /* Move results */ + *outArrayDimensions = (UA_UInt32*)res->value.data; + *outArrayDimensionsSize = res->value.arrayLength; + res->value.data = NULL; + res->value.arrayLength = 0; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Client_readArrayDimensionsAttribute(UA_Client *client, const UA_NodeId nodeId, + size_t *outArrayDimensionsSize, + UA_UInt32 **outArrayDimensions) { + UA_ReadValueId item; + UA_ReadValueId_init(&item); + item.nodeId = nodeId; + item.attributeId = UA_ATTRIBUTEID_ARRAYDIMENSIONS; + UA_ReadRequest request; + UA_ReadRequest_init(&request); + request.nodesToRead = &item; + request.nodesToReadSize = 1; + + UA_ReadResponse response = UA_Client_Service_read(client, request); + UA_StatusCode retval = processReadArrayDimensionsResult(&response, outArrayDimensions, + outArrayDimensionsSize); + UA_ReadResponse_clear(&response); + return retval; +} + +/*********************/ +/* Historical Access */ +/*********************/ +#ifdef UA_ENABLE_HISTORIZING +static UA_HistoryReadResponse +__UA_Client_HistoryRead(UA_Client *client, const UA_NodeId *nodeId, + UA_ExtensionObject* details, UA_String indexRange, + UA_TimestampsToReturn timestampsToReturn, + UA_ByteString continuationPoint, UA_Boolean releaseConti) { + + UA_HistoryReadValueId item; + UA_HistoryReadValueId_init(&item); + + item.nodeId = *nodeId; + item.indexRange = indexRange; + item.continuationPoint = continuationPoint; + item.dataEncoding = UA_QUALIFIEDNAME(0, "Default Binary"); + + UA_HistoryReadRequest request; + UA_HistoryReadRequest_init(&request); + + request.nodesToRead = &item; + request.nodesToReadSize = 1; + request.timestampsToReturn = timestampsToReturn; // Defaults to Source + request.releaseContinuationPoints = releaseConti; // No values are returned, if true + + /* Build ReadDetails */ + request.historyReadDetails = *details; + + return UA_Client_Service_historyRead(client, request); +} + +static UA_StatusCode +__UA_Client_HistoryRead_service(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_ExtensionObject *details, UA_String indexRange, + UA_TimestampsToReturn timestampsToReturn, + void *callbackContext) { + + UA_ByteString continuationPoint = UA_BYTESTRING_NULL; + UA_Boolean continuationAvail = false; + UA_Boolean fetchMore = false; + UA_StatusCode retval = UA_STATUSCODE_GOOD; + + do { + /* We release the continuation point, if no more data is requested by the user */ + UA_Boolean cleanup = !fetchMore && continuationAvail; + UA_HistoryReadResponse response = + __UA_Client_HistoryRead(client, nodeId, details, indexRange, timestampsToReturn, continuationPoint, cleanup); + + if (cleanup) { + retval = response.responseHeader.serviceResult; +cleanup: UA_HistoryReadResponse_clear(&response); + UA_ByteString_clear(&continuationPoint); + return retval; + } + + retval = response.responseHeader.serviceResult; + if (retval == UA_STATUSCODE_GOOD) { + if (response.resultsSize == 1) + retval = response.results[0].statusCode; + else + retval = UA_STATUSCODE_BADUNEXPECTEDERROR; + } + if (retval != UA_STATUSCODE_GOOD) + goto cleanup; + + UA_HistoryReadResult *res = response.results; + + /* Clear old and check / store new continuation point */ + UA_ByteString_clear(&continuationPoint); + UA_ByteString_copy(&res->continuationPoint, &continuationPoint); + continuationAvail = !UA_ByteString_equal(&continuationPoint, &UA_BYTESTRING_NULL); + + /* Client callback with possibility to request further values */ + fetchMore = callback(client, nodeId, continuationAvail, &res->historyData, callbackContext); + + /* Regular cleanup */ + UA_HistoryReadResponse_clear(&response); + } while (continuationAvail); + + return retval; +} + +#ifdef UA_ENABLE_EXPERIMENTAL_HISTORIZING +UA_StatusCode +UA_Client_HistoryRead_events(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_DateTime startTime, UA_DateTime endTime, + UA_String indexRange, const UA_EventFilter filter, UA_UInt32 numValuesPerNode, + UA_TimestampsToReturn timestampsToReturn, void *callbackContext) { + + UA_ReadEventDetails details; + UA_ReadEventDetails_init(&details); + details.filter = filter; + + // At least two of the following parameters must be set + details.numValuesPerNode = numValuesPerNode; // 0 = return all / max server is capable of + details.startTime = startTime; + details.endTime = endTime; + + UA_ExtensionObject detailsExtensionObject; + UA_ExtensionObject_init(&detailsExtensionObject); + detailsExtensionObject.content.decoded.type = &UA_TYPES[UA_TYPES_READEVENTDETAILS]; + detailsExtensionObject.content.decoded.data = &details; + detailsExtensionObject.encoding = UA_EXTENSIONOBJECT_DECODED; + + return __UA_Client_HistoryRead_service(client, nodeId, callback, &detailsExtensionObject, + indexRange, timestampsToReturn, callbackContext); +} +#endif // UA_ENABLE_EXPERIMENTAL_HISTORIZING + +static UA_StatusCode +__UA_Client_HistoryRead_service_rawMod(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_DateTime startTime,UA_DateTime endTime, + UA_String indexRange, UA_Boolean returnBounds, UA_UInt32 numValuesPerNode, + UA_Boolean readModified, UA_TimestampsToReturn timestampsToReturn, + void *callbackContext) { + + UA_ReadRawModifiedDetails details; + UA_ReadRawModifiedDetails_init(&details); + details.isReadModified = readModified; // Return only modified values + details.returnBounds = returnBounds; // Return values pre / post given range + + // At least two of the following parameters must be set + details.numValuesPerNode = numValuesPerNode; // 0 = return all / max server is capable of + details.startTime = startTime; + details.endTime = endTime; + + UA_ExtensionObject detailsExtensionObject; + UA_ExtensionObject_init(&detailsExtensionObject); + detailsExtensionObject.content.decoded.type = &UA_TYPES[UA_TYPES_READRAWMODIFIEDDETAILS]; + detailsExtensionObject.content.decoded.data = &details; + detailsExtensionObject.encoding = UA_EXTENSIONOBJECT_DECODED; + + return __UA_Client_HistoryRead_service(client, nodeId, callback, + &detailsExtensionObject, indexRange, + timestampsToReturn, callbackContext); +} + +UA_StatusCode +UA_Client_HistoryRead_raw(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_DateTime startTime, UA_DateTime endTime, + UA_String indexRange, UA_Boolean returnBounds, UA_UInt32 numValuesPerNode, + UA_TimestampsToReturn timestampsToReturn, void *callbackContext) { + + return __UA_Client_HistoryRead_service_rawMod(client, nodeId, callback, startTime, endTime, indexRange, returnBounds, + numValuesPerNode, false, timestampsToReturn, callbackContext); +} + +#ifdef UA_ENABLE_EXPERIMENTAL_HISTORIZING +UA_StatusCode +UA_Client_HistoryRead_modified(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_DateTime startTime, UA_DateTime endTime, + UA_String indexRange, UA_Boolean returnBounds, UA_UInt32 maxItems, + UA_TimestampsToReturn timestampsToReturn, void *callbackContext) { + + return __UA_Client_HistoryRead_service_rawMod(client, nodeId, callback, startTime, endTime, indexRange, returnBounds, + maxItems, true, timestampsToReturn, callbackContext); +} +#endif // UA_ENABLE_EXPERIMENTAL_HISTORIZING + +static UA_HistoryUpdateResponse +__UA_Client_HistoryUpdate(UA_Client *client, + void *details, + size_t typeId) +{ + UA_HistoryUpdateRequest request; + UA_HistoryUpdateRequest_init(&request); + + UA_ExtensionObject extension; + UA_ExtensionObject_init(&extension); + request.historyUpdateDetailsSize = 1; + request.historyUpdateDetails = &extension; + + extension.encoding = UA_EXTENSIONOBJECT_DECODED; + extension.content.decoded.type = &UA_TYPES[typeId]; + extension.content.decoded.data = details; + + UA_HistoryUpdateResponse response; + response = UA_Client_Service_historyUpdate(client, request); + return response; +} + +static UA_StatusCode +__UA_Client_HistoryUpdate_updateData(UA_Client *client, + const UA_NodeId *nodeId, + UA_PerformUpdateType type, + UA_DataValue *value) +{ + UA_StatusCode ret = UA_STATUSCODE_GOOD; + UA_UpdateDataDetails details; + UA_UpdateDataDetails_init(&details); + + details.performInsertReplace = type; + details.updateValuesSize = 1; + details.updateValues = value; + UA_NodeId_copy(nodeId, &details.nodeId); + + UA_HistoryUpdateResponse response; + response = __UA_Client_HistoryUpdate(client, &details, UA_TYPES_UPDATEDATADETAILS); + if (response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + ret = response.responseHeader.serviceResult; + goto cleanup; + } + if (response.resultsSize != 1 || response.results[0].operationResultsSize != 1) { + ret = UA_STATUSCODE_BADUNEXPECTEDERROR; + goto cleanup; + } + if (response.results[0].statusCode != UA_STATUSCODE_GOOD) { + ret = response.results[0].statusCode; + goto cleanup; + } + ret = response.results[0].operationResults[0]; +cleanup: + UA_HistoryUpdateResponse_clear(&response); + UA_NodeId_clear(&details.nodeId); + return ret; +} + +UA_StatusCode +UA_Client_HistoryUpdate_insert(UA_Client *client, + const UA_NodeId *nodeId, + UA_DataValue *value) +{ + return __UA_Client_HistoryUpdate_updateData(client, + nodeId, + UA_PERFORMUPDATETYPE_INSERT, + value); +} + +UA_StatusCode +UA_Client_HistoryUpdate_replace(UA_Client *client, + const UA_NodeId *nodeId, + UA_DataValue *value) +{ + return __UA_Client_HistoryUpdate_updateData(client, + nodeId, + UA_PERFORMUPDATETYPE_REPLACE, + value); +} + +UA_StatusCode +UA_Client_HistoryUpdate_update(UA_Client *client, + const UA_NodeId *nodeId, + UA_DataValue *value) +{ + return __UA_Client_HistoryUpdate_updateData(client, + nodeId, + UA_PERFORMUPDATETYPE_UPDATE, + value); +} + +UA_StatusCode +UA_Client_HistoryUpdate_deleteRaw(UA_Client *client, + const UA_NodeId *nodeId, + UA_DateTime startTimestamp, + UA_DateTime endTimestamp) +{ + UA_StatusCode ret = UA_STATUSCODE_GOOD; + + UA_DeleteRawModifiedDetails details; + UA_DeleteRawModifiedDetails_init(&details); + + details.isDeleteModified = false; + details.startTime = startTimestamp; + details.endTime = endTimestamp; + UA_NodeId_copy(nodeId, &details.nodeId); + + UA_HistoryUpdateResponse response; + response = __UA_Client_HistoryUpdate(client, &details, UA_TYPES_DELETERAWMODIFIEDDETAILS); + if (response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + ret = response.responseHeader.serviceResult; + goto cleanup; + } + if (response.resultsSize != 1) { + ret = UA_STATUSCODE_BADUNEXPECTEDERROR; + goto cleanup; + } + + ret = response.results[0].statusCode; + +cleanup: + UA_HistoryUpdateResponse_clear(&response); + UA_NodeId_clear(&details.nodeId); + return ret; +} +#endif // UA_ENABLE_HISTORIZING + +/*******************/ +/* Async Functions */ +/*******************/ + +/*Write Attributes*/ +UA_StatusCode __UA_Client_writeAttribute_async(UA_Client *client, + const UA_NodeId *nodeId, UA_AttributeId attributeId, const void *in, + const UA_DataType *inDataType, UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + if (!in) + return UA_STATUSCODE_BADTYPEMISMATCH; + + UA_WriteValue wValue; + UA_WriteValue_init(&wValue); + wValue.nodeId = *nodeId; + wValue.attributeId = attributeId; + if (attributeId == UA_ATTRIBUTEID_VALUE) + wValue.value.value = *(const UA_Variant*) in; + else + /* hack. is never written into. */ + UA_Variant_setScalar(&wValue.value.value, (void*) (uintptr_t) in, + inDataType); + wValue.value.hasValue = true; + UA_WriteRequest wReq; + UA_WriteRequest_init(&wReq); + wReq.nodesToWrite = &wValue; + wReq.nodesToWriteSize = 1; + + return __UA_Client_AsyncService(client, &wReq, + &UA_TYPES[UA_TYPES_WRITEREQUEST], callback, + &UA_TYPES[UA_TYPES_WRITERESPONSE], userdata, reqId); +} + +/*Node Management*/ + +UA_StatusCode UA_EXPORT +__UA_Client_addNode_async(UA_Client *client, const UA_NodeClass nodeClass, + const UA_NodeId requestedNewNodeId, const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, const UA_NodeAttributes *attr, + const UA_DataType *attributeType, UA_NodeId *outNewNodeId, + UA_ClientAsyncServiceCallback callback, void *userdata, + UA_UInt32 *reqId) { + UA_AddNodesRequest request; + UA_AddNodesRequest_init(&request); + UA_AddNodesItem item; + UA_AddNodesItem_init(&item); + item.parentNodeId.nodeId = parentNodeId; + item.referenceTypeId = referenceTypeId; + item.requestedNewNodeId.nodeId = requestedNewNodeId; + item.browseName = browseName; + item.nodeClass = nodeClass; + item.typeDefinition.nodeId = typeDefinition; + item.nodeAttributes.encoding = UA_EXTENSIONOBJECT_DECODED_NODELETE; + item.nodeAttributes.content.decoded.type = attributeType; + item.nodeAttributes.content.decoded.data = (void*) (uintptr_t) attr; // hack. is not written into. + request.nodesToAdd = &item; + request.nodesToAddSize = 1; + + return __UA_Client_AsyncService(client, &request, + &UA_TYPES[UA_TYPES_ADDNODESREQUEST], callback, + &UA_TYPES[UA_TYPES_ADDNODESRESPONSE], userdata, reqId); + +} + +/* Misc Highlevel Functions */ +#ifdef UA_ENABLE_METHODCALLS +UA_StatusCode __UA_Client_call_async(UA_Client *client, + const UA_NodeId objectId, const UA_NodeId methodId, size_t inputSize, + const UA_Variant *input, UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + + UA_CallRequest request; + UA_CallRequest_init(&request); + UA_CallMethodRequest item; + UA_CallMethodRequest_init(&item); + item.methodId = methodId; + item.objectId = objectId; + item.inputArguments = (UA_Variant *) (void*) (uintptr_t) input; // cast const... + item.inputArgumentsSize = inputSize; + request.methodsToCall = &item; + request.methodsToCallSize = 1; + + return __UA_Client_AsyncService(client, &request, + &UA_TYPES[UA_TYPES_CALLREQUEST], callback, + &UA_TYPES[UA_TYPES_CALLRESPONSE], userdata, reqId); +} +#endif + +UA_StatusCode __UA_Client_translateBrowsePathsToNodeIds_async(UA_Client *client, + char *paths[], UA_UInt32 ids[], size_t pathSize, + UA_ClientAsyncServiceCallback callback, void *userdata, + UA_UInt32 *reqId) { + return UA_STATUSCODE_BADNOTIMPLEMENTED; +} + +UA_StatusCode +UA_Cient_translateBrowsePathsToNodeIds_async(UA_Client *client, char **paths, + UA_UInt32 *ids, size_t pathSize, + UA_ClientAsyncTranslateCallback callback, + void *userdata, UA_UInt32 *reqId) { + return UA_STATUSCODE_BADNOTIMPLEMENTED; +} + +/*************************/ +/* Read Single Attribute */ +/*************************/ + +typedef struct { + UA_ClientAsyncOperationCallback userCallback; + void *userContext; + const UA_DataType *resultType; /* DataValue -> Value attribute, + * Variant -> ArrayDimensions attribute */ +} UA_AttributeReadContext; + +static void +AttributeReadCallback(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_ReadResponse *rr) { + UA_AttributeReadContext *ctx = (UA_AttributeReadContext*)userdata; + UA_LOG_DEBUG(&UA_Client_getConfig(client)->logger, UA_LOGCATEGORY_CLIENT, + "Async read response for request %" PRIu32, requestId); + + /* Check the ServiceResult */ + UA_StatusCode res = rr->responseHeader.serviceResult; + if(res != UA_STATUSCODE_GOOD) + goto finish; + + /* Check result array size */ + if(rr->resultsSize != 1) { + res = UA_STATUSCODE_BADINTERNALERROR; + goto finish; + } + + /* A Value attribute */ + UA_DataValue *dv = &rr->results[0]; + if(ctx->resultType == &UA_TYPES[UA_TYPES_DATAVALUE]) { + ctx->userCallback(client, ctx->userContext, requestId, + UA_STATUSCODE_GOOD, dv); + goto finish; + } + + /* An ArrayDimensions attribute. Has to be an array of UInt32. */ + if(ctx->resultType == &UA_TYPES[UA_TYPES_VARIANT]) { + if(dv->hasValue && + UA_Variant_hasArrayType(&dv->value, &UA_TYPES[UA_TYPES_UINT32])) { + ctx->userCallback(client, ctx->userContext, requestId, + UA_STATUSCODE_GOOD, &dv->value); + } else { + res = UA_STATUSCODE_BADINTERNALERROR; + } + goto finish; + } + + /* Check we have a scalar value of the right datatype */ + if(!dv->hasValue || + !UA_Variant_hasScalarType(&dv->value, ctx->resultType)) { + res = UA_STATUSCODE_BADINTERNALERROR; + goto finish; + } + + /* Callback into userland */ + ctx->userCallback(client, ctx->userContext, requestId, + UA_STATUSCODE_GOOD, dv->value.data); + + finish: + if(res != UA_STATUSCODE_GOOD) + ctx->userCallback(client, ctx->userContext, requestId, res, NULL); + UA_free(ctx); +} + +static UA_StatusCode +readAttribute_async(UA_Client *client, const UA_ReadValueId *rvi, + UA_TimestampsToReturn timestampsToReturn, + const UA_DataType *resultType, /* For the specialized reads */ + UA_ClientAsyncOperationCallback callback, + void *userdata, UA_UInt32 *requestId) { + UA_AttributeReadContext *ctx = (UA_AttributeReadContext*) + UA_malloc(sizeof(UA_AttributeReadContext)); + if(!ctx) + return UA_STATUSCODE_BADOUTOFMEMORY; + + ctx->userCallback = callback; + ctx->userContext = userdata; + ctx->resultType = resultType; + + UA_ReadRequest request; + UA_ReadRequest_init(&request); + request.nodesToRead = (UA_ReadValueId*)(uintptr_t)rvi; /* hack, treated as const */ + request.nodesToReadSize = 1; + request.timestampsToReturn = timestampsToReturn; + + UA_StatusCode res = + __UA_Client_AsyncService(client, &request, &UA_TYPES[UA_TYPES_READREQUEST], + (UA_ClientAsyncServiceCallback)AttributeReadCallback, + &UA_TYPES[UA_TYPES_READRESPONSE], ctx, requestId); + if(res != UA_STATUSCODE_GOOD) + UA_free(ctx); + return res; +} + +UA_StatusCode +UA_Client_readAttribute_async(UA_Client *client, const UA_ReadValueId *rvi, + UA_TimestampsToReturn timestampsToReturn, + UA_ClientAsyncReadAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_async(client, rvi, timestampsToReturn, + &UA_TYPES[UA_TYPES_DATAVALUE], /* special handling */ + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +/* Helper to keep the code short */ +static UA_StatusCode +readAttribute_simpleAsync(UA_Client *client, const UA_NodeId *nodeId, + UA_AttributeId attributeId, const UA_DataType *resultType, + UA_ClientAsyncOperationCallback callback, + void *userdata, UA_UInt32 *requestId) { + UA_ReadValueId rvi; + UA_ReadValueId_init(&rvi); + rvi.nodeId = *nodeId; + rvi.attributeId = attributeId; + return readAttribute_async(client, &rvi, UA_TIMESTAMPSTORETURN_NEITHER, + resultType, callback, userdata, requestId); +} + +UA_StatusCode +UA_Client_readValueAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadValueAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_VALUE, + &UA_TYPES[UA_TYPES_DATAVALUE], /* special hndling */ + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readDataTypeAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadDataTypeAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_DATATYPE, + &UA_TYPES[UA_TYPES_NODEID], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readArrayDimensionsAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientReadArrayDimensionsAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_ARRAYDIMENSIONS, + &UA_TYPES[UA_TYPES_VARIANT], /* special handling */ + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readNodeClassAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadNodeClassAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_NODECLASS, + &UA_TYPES[UA_TYPES_NODECLASS], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readBrowseNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadBrowseNameAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_BROWSENAME, + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readDisplayNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadDisplayNameAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readDescriptionAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadDescriptionAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_DESCRIPTION, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readWriteMaskAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadWriteMaskAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_WRITEMASK, + &UA_TYPES[UA_TYPES_UINT32], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode UA_EXPORT +UA_Client_readUserWriteMaskAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadUserWriteMaskAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_USERWRITEMASK, + &UA_TYPES[UA_TYPES_UINT32], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readIsAbstractAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadIsAbstractAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_ISABSTRACT, + &UA_TYPES[UA_TYPES_BOOLEAN], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readSymmetricAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadSymmetricAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_SYMMETRIC, + &UA_TYPES[UA_TYPES_BOOLEAN], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readInverseNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadInverseNameAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_INVERSENAME, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readContainsNoLoopsAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadContainsNoLoopsAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_CONTAINSNOLOOPS, + &UA_TYPES[UA_TYPES_BOOLEAN], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readEventNotifierAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadEventNotifierAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_EVENTNOTIFIER, + &UA_TYPES[UA_TYPES_BYTE], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readValueRankAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadValueRankAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_VALUERANK, + &UA_TYPES[UA_TYPES_INT32], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readAccessLevelAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadAccessLevelAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL, + &UA_TYPES[UA_TYPES_BYTE], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readUserAccessLevelAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadUserAccessLevelAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_USERACCESSLEVEL, + &UA_TYPES[UA_TYPES_BYTE], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readMinimumSamplingIntervalAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadMinimumSamplingIntervalAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL, + &UA_TYPES[UA_TYPES_DOUBLE], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readHistorizingAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadHistorizingAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_HISTORIZING, + &UA_TYPES[UA_TYPES_BOOLEAN], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readExecutableAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadExecutableAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_EXECUTABLE, + &UA_TYPES[UA_TYPES_BOOLEAN], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +UA_StatusCode +UA_Client_readUserExecutableAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadUserExecutableAttributeCallback callback, + void *userdata, UA_UInt32 *requestId) { + return readAttribute_simpleAsync(client, &nodeId, UA_ATTRIBUTEID_USEREXECUTABLE, + &UA_TYPES[UA_TYPES_BOOLEAN], + (UA_ClientAsyncOperationCallback)callback, + userdata, requestId); +} + +/**** amalgamated original file "/src/client/ua_client_subscriptions.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2016 (c) Sten Grüner + * Copyright 2017-2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2016-2017 (c) Florian Palm + * Copyright 2017 (c) Frank Meerkötter + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +#ifdef UA_ENABLE_SUBSCRIPTIONS /* conditional compilation */ + +/*****************/ +/* Subscriptions */ +/*****************/ + +static void +MonitoredItem_delete(UA_Client *client, UA_Client_Subscription *sub, + UA_Client_MonitoredItem *mon); + +static void +ua_Subscriptions_create(UA_Client *client, UA_Client_Subscription *newSub, + UA_CreateSubscriptionResponse *response) { + newSub->subscriptionId = response->subscriptionId; + newSub->sequenceNumber = 0; + newSub->lastActivity = UA_DateTime_nowMonotonic(); + newSub->publishingInterval = response->revisedPublishingInterval; + newSub->maxKeepAliveCount = response->revisedMaxKeepAliveCount; + LIST_INIT(&newSub->monitoredItems); + LIST_INSERT_HEAD(&client->subscriptions, newSub, listEntry); +} + +static void +ua_Subscriptions_create_handler(UA_Client *client, void *data, UA_UInt32 requestId, + void *r) { + UA_CreateSubscriptionResponse *response = (UA_CreateSubscriptionResponse *)r; + CustomCallback *cc = (CustomCallback *)data; + UA_Client_Subscription *newSub = (UA_Client_Subscription *)cc->clientData; + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_free(newSub); + goto cleanup; + } + + /* Prepare the internal representation */ + ua_Subscriptions_create(client, newSub, response); + +cleanup: + if(cc->userCallback) + cc->userCallback(client, cc->userData, requestId, response); + UA_free(cc); +} + +UA_CreateSubscriptionResponse +UA_Client_Subscriptions_create(UA_Client *client, + const UA_CreateSubscriptionRequest request, + void *subscriptionContext, + UA_Client_StatusChangeNotificationCallback statusChangeCallback, + UA_Client_DeleteSubscriptionCallback deleteCallback) { + UA_CreateSubscriptionResponse response; + UA_Client_Subscription *sub = (UA_Client_Subscription *) + UA_malloc(sizeof(UA_Client_Subscription)); + if(!sub) { + UA_CreateSubscriptionResponse_init(&response); + response.responseHeader.serviceResult = UA_STATUSCODE_BADOUTOFMEMORY; + return response; + } + sub->context = subscriptionContext; + sub->statusChangeCallback = statusChangeCallback; + sub->deleteCallback = deleteCallback; + + /* Send the request as a synchronous service call */ + __UA_Client_Service(client, + &request, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST], + &response, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]); + + ua_Subscriptions_create(client, sub, &response); + + return response; +} + +UA_StatusCode +UA_Client_Subscriptions_create_async(UA_Client *client, + const UA_CreateSubscriptionRequest request, + void *subscriptionContext, + UA_Client_StatusChangeNotificationCallback statusChangeCallback, + UA_Client_DeleteSubscriptionCallback deleteCallback, + UA_ClientAsyncServiceCallback createCallback, + void *userdata, + UA_UInt32 *requestId) { + CustomCallback *cc = (CustomCallback *)UA_calloc(1, sizeof(CustomCallback)); + if(!cc) + return UA_STATUSCODE_BADOUTOFMEMORY; + + UA_Client_Subscription *sub = (UA_Client_Subscription *) + UA_malloc(sizeof(UA_Client_Subscription)); + if(!sub) { + UA_free(cc); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + sub->context = subscriptionContext; + sub->statusChangeCallback = statusChangeCallback; + sub->deleteCallback = deleteCallback; + + cc->userCallback = createCallback; + cc->userData = userdata; + cc->clientData = sub; + + /* Send the request as asynchronous service call */ + return __UA_Client_AsyncService( + client, &request, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST], + ua_Subscriptions_create_handler, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE], + cc, requestId); +} + +static UA_Client_Subscription * +findSubscription(const UA_Client *client, UA_UInt32 subscriptionId) { + UA_Client_Subscription *sub = NULL; + LIST_FOREACH(sub, &client->subscriptions, listEntry) { + if(sub->subscriptionId == subscriptionId) + break; + } + return sub; +} + +static void +ua_Subscriptions_modify(UA_Client *client, UA_Client_Subscription *sub, + const UA_ModifySubscriptionResponse *response) { + sub->publishingInterval = response->revisedPublishingInterval; + sub->maxKeepAliveCount = response->revisedMaxKeepAliveCount; +} + +static void +ua_Subscriptions_modify_handler(UA_Client *client, void *data, UA_UInt32 requestId, + void *r) { + UA_ModifySubscriptionResponse *response = (UA_ModifySubscriptionResponse *)r; + CustomCallback *cc = (CustomCallback *)data; + UA_Client_Subscription *sub = + findSubscription(client, (UA_UInt32)(uintptr_t)cc->clientData); + if(sub) { + ua_Subscriptions_modify(client, sub, response); + } else { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "No internal representation of subscription %" PRIu32, + (UA_UInt32)(uintptr_t)cc->clientData); + } + + if(cc->userCallback) + cc->userCallback(client, cc->userData, requestId, response); + UA_free(cc); +} + +UA_ModifySubscriptionResponse +UA_Client_Subscriptions_modify(UA_Client *client, + const UA_ModifySubscriptionRequest request) { + UA_ModifySubscriptionResponse response; + UA_ModifySubscriptionResponse_init(&response); + + /* Find the internal representation */ + UA_Client_Subscription *sub = findSubscription(client, request.subscriptionId); + if(!sub) { + response.responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return response; + } + + /* Call the service */ + __UA_Client_Service(client, + &request, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST], + &response, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]); + + /* Adjust the internal representation */ + ua_Subscriptions_modify(client, sub, &response); + return response; +} + +UA_StatusCode +UA_Client_Subscriptions_modify_async(UA_Client *client, + const UA_ModifySubscriptionRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId) { + /* Find the internal representation */ + UA_Client_Subscription *sub = findSubscription(client, request.subscriptionId); + if(!sub) + return UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + + CustomCallback *cc = (CustomCallback *)UA_calloc(1, sizeof(CustomCallback)); + if(!cc) + return UA_STATUSCODE_BADOUTOFMEMORY; + + cc->clientData = (void *)(uintptr_t)request.subscriptionId; + cc->userData = userdata; + cc->userCallback = callback; + + return __UA_Client_AsyncService( + client, &request, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST], + ua_Subscriptions_modify_handler, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE], + cc, requestId); +} + +static void +UA_Client_Subscription_deleteInternal(UA_Client *client, + UA_Client_Subscription *sub) { + /* Remove the MonitoredItems */ + UA_Client_MonitoredItem *mon; + UA_Client_MonitoredItem *mon_tmp; + LIST_FOREACH_SAFE(mon, &sub->monitoredItems, listEntry, mon_tmp) + MonitoredItem_delete(client, sub, mon); + + /* Call the delete callback */ + if(sub->deleteCallback) + sub->deleteCallback(client, sub->subscriptionId, sub->context); + + /* Remove */ + LIST_REMOVE(sub, listEntry); + UA_free(sub); +} + +static void +UA_Client_Subscription_processDelete(UA_Client *client, + const UA_DeleteSubscriptionsRequest *request, + const UA_DeleteSubscriptionsResponse *response) { + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) + return; + + /* Check that the request and response size -- use the same index for both */ + if(request->subscriptionIdsSize != response->resultsSize) + return; + + for(size_t i = 0; i < request->subscriptionIdsSize; i++) { + if(response->results[i] != UA_STATUSCODE_GOOD && + response->results[i] != UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID) + continue; + + /* Get the Subscription */ + UA_Client_Subscription *sub = + findSubscription(client, request->subscriptionIds[i]); + if(!sub) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "No internal representation of subscription %" PRIu32, + request->subscriptionIds[i]); + continue; + } + + /* Delete the Subscription */ + UA_Client_Subscription_deleteInternal(client, sub); + } + +} + +typedef struct { + UA_DeleteSubscriptionsRequest request; + UA_ClientAsyncServiceCallback userCallback; + void *userData; +} DeleteSubscriptionCallback; + +static void +ua_Subscriptions_delete_handler(UA_Client *client, void *data, UA_UInt32 requestId, + void *r) { + UA_DeleteSubscriptionsResponse *response = + (UA_DeleteSubscriptionsResponse *)r; + DeleteSubscriptionCallback *dsc = + (DeleteSubscriptionCallback*)data; + + /* Delete */ + UA_Client_Subscription_processDelete(client, &dsc->request, response); + + /* Userland Callback */ + dsc->userCallback(client, dsc->userData, requestId, response); + + /* Cleanup */ + UA_DeleteSubscriptionsRequest_clear(&dsc->request); + UA_free(dsc); +} + +UA_StatusCode +UA_Client_Subscriptions_delete_async(UA_Client *client, + const UA_DeleteSubscriptionsRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId) { + /* Make a copy of the request that persists into the async callback */ + DeleteSubscriptionCallback *dsc = + (DeleteSubscriptionCallback*)UA_malloc(sizeof(DeleteSubscriptionCallback)); + if(!dsc) + return UA_STATUSCODE_BADOUTOFMEMORY; + dsc->userCallback = callback; + dsc->userData = userdata; + UA_StatusCode res = UA_DeleteSubscriptionsRequest_copy(&request, &dsc->request); + if(res != UA_STATUSCODE_GOOD) { + UA_free(dsc); + return res; + } + + /* Make the async call */ + return __UA_Client_AsyncService( + client, &request, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST], + ua_Subscriptions_delete_handler, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE], + dsc, requestId); +} + +UA_DeleteSubscriptionsResponse +UA_Client_Subscriptions_delete(UA_Client *client, + const UA_DeleteSubscriptionsRequest request) { + /* Send the request */ + UA_DeleteSubscriptionsResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST], + &response, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]); + + /* Process */ + UA_Client_Subscription_processDelete(client, &request, &response); + return response; +} + +UA_StatusCode +UA_Client_Subscriptions_deleteSingle(UA_Client *client, UA_UInt32 subscriptionId) { + UA_DeleteSubscriptionsRequest request; + UA_DeleteSubscriptionsRequest_init(&request); + request.subscriptionIds = &subscriptionId; + request.subscriptionIdsSize = 1; + + UA_DeleteSubscriptionsResponse response = + UA_Client_Subscriptions_delete(client, request); + + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval != UA_STATUSCODE_GOOD) { + UA_DeleteSubscriptionsResponse_clear(&response); + return retval; + } + + if(response.resultsSize != 1) { + UA_DeleteSubscriptionsResponse_clear(&response); + return UA_STATUSCODE_BADINTERNALERROR; + } + + retval = response.results[0]; + UA_DeleteSubscriptionsResponse_clear(&response); + return retval; +} + +/******************/ +/* MonitoredItems */ +/******************/ + +static void +MonitoredItem_delete(UA_Client *client, UA_Client_Subscription *sub, + UA_Client_MonitoredItem *mon) { + LIST_REMOVE(mon, listEntry); + if(mon->deleteCallback) + mon->deleteCallback(client, sub->subscriptionId, sub->context, + mon->monitoredItemId, mon->context); + UA_free(mon); +} + +typedef struct { + void **contexts; + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks; + void **handlingCallbacks; + UA_CreateMonitoredItemsRequest request; + + /* Notify the user that the async callback was processed */ + UA_ClientAsyncServiceCallback userCallback; + void *userData; +} MonitoredItems_CreateData; + +static void +MonitoredItems_CreateData_clear(UA_Client *client, MonitoredItems_CreateData *data) { + UA_free(data->contexts); + UA_free(data->deleteCallbacks); + UA_free(data->handlingCallbacks); + UA_CreateMonitoredItemsRequest_clear(&data->request); +} + +static void +ua_MonitoredItems_create(UA_Client *client, MonitoredItems_CreateData *data, + UA_CreateMonitoredItemsResponse *response) { + UA_CreateMonitoredItemsRequest *request = &data->request; + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks = data->deleteCallbacks; + + UA_Client_Subscription *sub = findSubscription(client, data->request.subscriptionId); + if(!sub) + goto cleanup; + + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) + goto cleanup; + + if(response->resultsSize != request->itemsToCreateSize) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + /* Add internally */ + for(size_t i = 0; i < request->itemsToCreateSize; i++) { + if(response->results[i].statusCode != UA_STATUSCODE_GOOD) { + if(deleteCallbacks[i]) + deleteCallbacks[i](client, sub->subscriptionId, sub->context, + 0, data->contexts[i]); + continue; + } + + UA_Client_MonitoredItem *newMon = (UA_Client_MonitoredItem *) + UA_malloc(sizeof(UA_Client_MonitoredItem)); + if(!newMon) { + if(deleteCallbacks[i]) + deleteCallbacks[i](client, sub->subscriptionId, sub->context, 0, + data->contexts[i]); + continue; + } + + newMon->monitoredItemId = response->results[i].monitoredItemId; + newMon->clientHandle = request->itemsToCreate[i].requestedParameters.clientHandle; + newMon->context = data->contexts[i]; + newMon->deleteCallback = deleteCallbacks[i]; + newMon->handler.dataChangeCallback = + (UA_Client_DataChangeNotificationCallback)(uintptr_t) + data->handlingCallbacks[i]; + newMon->isEventMonitoredItem = + (request->itemsToCreate[i].itemToMonitor.attributeId == + UA_ATTRIBUTEID_EVENTNOTIFIER); + LIST_INSERT_HEAD(&sub->monitoredItems, newMon, listEntry); + + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Subscription %" PRIu32 + " | Added a MonitoredItem with handle %" PRIu32, + sub->subscriptionId, newMon->clientHandle); + } + return; + + /* Adding failed */ + cleanup: + for(size_t i = 0; i < request->itemsToCreateSize; i++) { + if(deleteCallbacks[i]) + deleteCallbacks[i](client, data->request.subscriptionId, + sub ? sub->context : NULL, 0, data->contexts[i]); + } +} + +static void +ua_MonitoredItems_create_async_handler(UA_Client *client, void *d, UA_UInt32 requestId, + void *r) { + UA_CreateMonitoredItemsResponse *response = (UA_CreateMonitoredItemsResponse *)r; + MonitoredItems_CreateData *data = (MonitoredItems_CreateData *)d; + + ua_MonitoredItems_create(client, data, response); + + if(data->userCallback) + data->userCallback(client, data->userData, requestId, response); + + MonitoredItems_CreateData_clear(client, data); + UA_free(data); +} + +static UA_StatusCode +MonitoredItems_CreateData_prepare(UA_Client *client, + const UA_CreateMonitoredItemsRequest *request, + void **contexts, void **handlingCallbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks, + MonitoredItems_CreateData *data) { + /* Align arrays and copy over */ + UA_StatusCode retval = UA_STATUSCODE_BADOUTOFMEMORY; + data->contexts = (void **)UA_malloc(sizeof(void *) * request->itemsToCreateSize); + if(!data->contexts) + goto cleanup; + memcpy(data->contexts, contexts, request->itemsToCreateSize * sizeof(void *)); + + data->deleteCallbacks = (UA_Client_DeleteMonitoredItemCallback *) + UA_malloc(request->itemsToCreateSize * sizeof(UA_Client_DeleteMonitoredItemCallback)); + if(!data->deleteCallbacks) + goto cleanup; + memcpy(data->deleteCallbacks, deleteCallbacks, + request->itemsToCreateSize * sizeof(UA_Client_DeleteMonitoredItemCallback)); + + data->handlingCallbacks = (void **) + UA_malloc(request->itemsToCreateSize * sizeof(void *)); + if(!data->handlingCallbacks) + goto cleanup; + memcpy(data->handlingCallbacks, handlingCallbacks, + request->itemsToCreateSize * sizeof(void *)); + + retval = UA_CreateMonitoredItemsRequest_copy(request, &data->request); + if(retval != UA_STATUSCODE_GOOD) + goto cleanup; + + /* Set the clientHandle */ + for(size_t i = 0; i < data->request.itemsToCreateSize; i++) + data->request.itemsToCreate[i].requestedParameters.clientHandle = + ++client->monitoredItemHandles; + + return UA_STATUSCODE_GOOD; + +cleanup: + MonitoredItems_CreateData_clear(client, data); + return retval; +} + +static void +ua_Client_MonitoredItems_create(UA_Client *client, + const UA_CreateMonitoredItemsRequest *request, + void **contexts, void **handlingCallbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks, + UA_CreateMonitoredItemsResponse *response) { + UA_CreateMonitoredItemsResponse_init(response); + + if(!request->itemsToCreateSize) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR; + return; + } + + /* Test if the subscription is valid */ + UA_Client_Subscription *sub = findSubscription(client, request->subscriptionId); + if(!sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return; + } + + MonitoredItems_CreateData data; + memset(&data, 0, sizeof(MonitoredItems_CreateData)); + + UA_StatusCode res = + MonitoredItems_CreateData_prepare(client, request, contexts, handlingCallbacks, + deleteCallbacks, &data); + if(res != UA_STATUSCODE_GOOD) { + response->responseHeader.serviceResult = res; + return; + } + + /* Call the service. Use data->request as it contains the client handle + * information. */ + __UA_Client_Service(client, &data.request, + &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST], + response, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]); + + /* Add internal representation */ + ua_MonitoredItems_create(client, &data, response); + + MonitoredItems_CreateData_clear(client, &data); +} + +static UA_StatusCode +ua_Client_MonitoredItems_createDataChanges_async( + UA_Client *client, const UA_CreateMonitoredItemsRequest request, void **contexts, + void **callbacks, UA_Client_DeleteMonitoredItemCallback *deleteCallbacks, + UA_ClientAsyncServiceCallback createCallback, void *userdata, UA_UInt32 *requestId) { + UA_Client_Subscription *sub = findSubscription(client, request.subscriptionId); + if(!sub) + return UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + + MonitoredItems_CreateData *data = (MonitoredItems_CreateData *) + UA_calloc(1, sizeof(MonitoredItems_CreateData)); + if(!data) + return UA_STATUSCODE_BADOUTOFMEMORY; + data->userCallback = createCallback; + data->userData = userdata; + + UA_StatusCode res = MonitoredItems_CreateData_prepare( + client, &request, contexts, callbacks, deleteCallbacks, data); + if(res != UA_STATUSCODE_GOOD) { + UA_free(data); + return res; + } + + return __UA_Client_AsyncService( + client, &data->request, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST], + ua_MonitoredItems_create_async_handler, + &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE], data, requestId); +} + +UA_CreateMonitoredItemsResponse +UA_Client_MonitoredItems_createDataChanges(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, + void **contexts, + UA_Client_DataChangeNotificationCallback *callbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks) { + UA_CreateMonitoredItemsResponse response; + ua_Client_MonitoredItems_create(client, &request, contexts, (void **)callbacks, + deleteCallbacks, &response); + return response; +} + +UA_StatusCode +UA_Client_MonitoredItems_createDataChanges_async(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, + void **contexts, + UA_Client_DataChangeNotificationCallback *callbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks, + UA_ClientAsyncServiceCallback createCallback, + void *userdata, UA_UInt32 *requestId) { + return ua_Client_MonitoredItems_createDataChanges_async( + client, request, contexts, (void **)callbacks, deleteCallbacks, createCallback, + userdata, requestId); +} + +UA_MonitoredItemCreateResult +UA_Client_MonitoredItems_createDataChange(UA_Client *client, UA_UInt32 subscriptionId, + UA_TimestampsToReturn timestampsToReturn, + const UA_MonitoredItemCreateRequest item, + void *context, + UA_Client_DataChangeNotificationCallback callback, + UA_Client_DeleteMonitoredItemCallback deleteCallback) { + UA_CreateMonitoredItemsRequest request; + UA_CreateMonitoredItemsRequest_init(&request); + request.subscriptionId = subscriptionId; + request.timestampsToReturn = timestampsToReturn; + request.itemsToCreate = (UA_MonitoredItemCreateRequest*)(uintptr_t)&item; + request.itemsToCreateSize = 1; + UA_CreateMonitoredItemsResponse response = + UA_Client_MonitoredItems_createDataChanges(client, request, &context, + &callback, &deleteCallback); + UA_MonitoredItemCreateResult result; + UA_MonitoredItemCreateResult_init(&result); + if(response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) + result.statusCode = response.responseHeader.serviceResult; + + if(result.statusCode == UA_STATUSCODE_GOOD && + response.resultsSize != 1) + result.statusCode = UA_STATUSCODE_BADINTERNALERROR; + + if(result.statusCode == UA_STATUSCODE_GOOD) + UA_MonitoredItemCreateResult_copy(&response.results[0] , &result); + UA_CreateMonitoredItemsResponse_clear(&response); + return result; +} + +UA_CreateMonitoredItemsResponse +UA_Client_MonitoredItems_createEvents(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, + void **contexts, + UA_Client_EventNotificationCallback *callback, + UA_Client_DeleteMonitoredItemCallback *deleteCallback) { + UA_CreateMonitoredItemsResponse response; + ua_Client_MonitoredItems_create(client, &request, contexts, (void **)callback, + deleteCallback, &response); + return response; +} + +/* Monitor the EventNotifier attribute only */ +UA_StatusCode +UA_Client_MonitoredItems_createEvents_async(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, + void **contexts, + UA_Client_EventNotificationCallback *callbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks, + UA_ClientAsyncServiceCallback createCallback, + void *userdata, UA_UInt32 *requestId) { + return ua_Client_MonitoredItems_createDataChanges_async( + client, request, contexts, (void **)callbacks, deleteCallbacks, createCallback, + userdata, requestId); +} + +UA_MonitoredItemCreateResult +UA_Client_MonitoredItems_createEvent(UA_Client *client, UA_UInt32 subscriptionId, + UA_TimestampsToReturn timestampsToReturn, + const UA_MonitoredItemCreateRequest item, void *context, + UA_Client_EventNotificationCallback callback, + UA_Client_DeleteMonitoredItemCallback deleteCallback) { + UA_CreateMonitoredItemsRequest request; + UA_CreateMonitoredItemsRequest_init(&request); + request.subscriptionId = subscriptionId; + request.timestampsToReturn = timestampsToReturn; + request.itemsToCreate = (UA_MonitoredItemCreateRequest*)(uintptr_t)&item; + request.itemsToCreateSize = 1; + UA_CreateMonitoredItemsResponse response = + UA_Client_MonitoredItems_createEvents(client, request, &context, + &callback, &deleteCallback); + UA_StatusCode retval = response.responseHeader.serviceResult; + UA_MonitoredItemCreateResult result; + UA_MonitoredItemCreateResult_init(&result); + if(retval != UA_STATUSCODE_GOOD) { + UA_CreateMonitoredItemsResponse_clear(&response); + result.statusCode = retval; + return result; + } + UA_MonitoredItemCreateResult_copy(response.results , &result); + UA_CreateMonitoredItemsResponse_clear(&response); + return result; +} + +static void +ua_MonitoredItems_delete(UA_Client *client, UA_Client_Subscription *sub, + const UA_DeleteMonitoredItemsRequest *request, + const UA_DeleteMonitoredItemsResponse *response) { +#ifdef __clang_analyzer__ + return; +#endif + + /* Loop over deleted MonitoredItems */ + for(size_t i = 0; i < response->resultsSize; i++) { + if(response->results[i] != UA_STATUSCODE_GOOD && + response->results[i] != UA_STATUSCODE_BADMONITOREDITEMIDINVALID) { + continue; + } + + /* Delete the internal representation */ + UA_Client_MonitoredItem *mon; + LIST_FOREACH(mon, &sub->monitoredItems, listEntry) { + if(mon->monitoredItemId == request->monitoredItemIds[i]) { + MonitoredItem_delete(client, sub, mon); + break; + } + } + } +} + +static void +ua_MonitoredItems_delete_handler(UA_Client *client, void *d, UA_UInt32 requestId, + void *r) { + CustomCallback *cc = (CustomCallback *)d; + UA_DeleteMonitoredItemsResponse *response = (UA_DeleteMonitoredItemsResponse *)r; + UA_DeleteMonitoredItemsRequest *request = + (UA_DeleteMonitoredItemsRequest *)cc->clientData; + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) + goto cleanup; + + UA_Client_Subscription *sub = findSubscription(client, request->subscriptionId); + if(!sub) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "No internal representation of subscription %" PRIu32, + request->subscriptionId); + goto cleanup; + } + + /* Delete MonitoredItems from the internal representation */ + ua_MonitoredItems_delete(client, sub, request, response); + +cleanup: + if(cc->userCallback) + cc->userCallback(client, cc->userData, requestId, response); + UA_DeleteMonitoredItemsRequest_delete(request); + UA_free(cc); +} + +UA_DeleteMonitoredItemsResponse +UA_Client_MonitoredItems_delete(UA_Client *client, + const UA_DeleteMonitoredItemsRequest request) { + /* Send the request */ + UA_DeleteMonitoredItemsResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST], + &response, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]); + + /* A problem occured remote? */ + if(response.responseHeader.serviceResult != UA_STATUSCODE_GOOD) + return response; + + /* Find the internal subscription representation */ + UA_Client_Subscription *sub = findSubscription(client, request.subscriptionId); + if(!sub) { + UA_LOG_INFO(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "No internal representation of subscription %" PRIu32, + request.subscriptionId); + return response; + } + + /* Remove MonitoredItems in the internal representation */ + ua_MonitoredItems_delete(client, sub, &request, &response); + return response; +} + +UA_StatusCode +UA_Client_MonitoredItems_delete_async(UA_Client *client, + const UA_DeleteMonitoredItemsRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId) { + /* Send the request */ + CustomCallback *cc = (CustomCallback *)UA_calloc(1, sizeof(CustomCallback)); + if(!cc) + return UA_STATUSCODE_BADOUTOFMEMORY; + + UA_DeleteMonitoredItemsRequest *req_copy = UA_DeleteMonitoredItemsRequest_new(); + if(!req_copy) { + UA_free(cc); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_DeleteMonitoredItemsRequest_copy(&request, req_copy); + cc->clientData = req_copy; + cc->userCallback = callback; + cc->userData = userdata; + + return __UA_Client_AsyncService( + client, &request, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST], + ua_MonitoredItems_delete_handler, + &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE], cc, requestId); +} + +UA_StatusCode +UA_Client_MonitoredItems_deleteSingle(UA_Client *client, UA_UInt32 subscriptionId, + UA_UInt32 monitoredItemId) { + UA_DeleteMonitoredItemsRequest request; + UA_DeleteMonitoredItemsRequest_init(&request); + request.subscriptionId = subscriptionId; + request.monitoredItemIds = &monitoredItemId; + request.monitoredItemIdsSize = 1; + + UA_DeleteMonitoredItemsResponse response = + UA_Client_MonitoredItems_delete(client, request); + + UA_StatusCode retval = response.responseHeader.serviceResult; + if(retval != UA_STATUSCODE_GOOD) { + UA_DeleteMonitoredItemsResponse_clear(&response); + return retval; + } + + if(response.resultsSize != 1) { + UA_DeleteMonitoredItemsResponse_clear(&response); + return UA_STATUSCODE_BADINTERNALERROR; + } + + retval = response.results[0]; + UA_DeleteMonitoredItemsResponse_clear(&response); + return retval; +} + +UA_ModifyMonitoredItemsResponse +UA_Client_MonitoredItems_modify(UA_Client *client, + const UA_ModifyMonitoredItemsRequest request) { + UA_ModifyMonitoredItemsResponse response; + + UA_Client_Subscription *sub; + LIST_FOREACH(sub, &client->subscriptions, listEntry) { + if (sub->subscriptionId == request.subscriptionId) + break; + } + + if (!sub) { + UA_ModifyMonitoredItemsResponse_init(&response); + response.responseHeader.serviceResult = UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID; + return response; + } + + UA_ModifyMonitoredItemsRequest modifiedRequest; + UA_ModifyMonitoredItemsRequest_copy(&request, &modifiedRequest); + + for (size_t i = 0; i < modifiedRequest.itemsToModifySize; ++i) { + UA_Client_MonitoredItem *mon; + LIST_FOREACH(mon, &sub->monitoredItems, listEntry) { + if(mon->monitoredItemId == modifiedRequest.itemsToModify[i].monitoredItemId) { + modifiedRequest.itemsToModify[i].requestedParameters.clientHandle = mon->clientHandle; + break; + } + } + } + + __UA_Client_Service(client, + &modifiedRequest, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST], + &response, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]); + + UA_ModifyMonitoredItemsRequest_clear(&modifiedRequest); + return response; +} + +/*************************************/ +/* Async Processing of Notifications */ +/*************************************/ + +/* Assume the request is already initialized */ +UA_StatusCode +UA_Client_preparePublishRequest(UA_Client *client, UA_PublishRequest *request) { + /* Count acks */ + UA_Client_NotificationsAckNumber *ack; + LIST_FOREACH(ack, &client->pendingNotificationsAcks, listEntry) + ++request->subscriptionAcknowledgementsSize; + + /* Create the array. Returns a sentinel pointer if the length is zero. */ + request->subscriptionAcknowledgements = (UA_SubscriptionAcknowledgement*) + UA_Array_new(request->subscriptionAcknowledgementsSize, + &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]); + if(!request->subscriptionAcknowledgements) { + request->subscriptionAcknowledgementsSize = 0; + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + size_t i = 0; + UA_Client_NotificationsAckNumber *ack_tmp; + LIST_FOREACH_SAFE(ack, &client->pendingNotificationsAcks, listEntry, ack_tmp) { + request->subscriptionAcknowledgements[i].sequenceNumber = ack->subAck.sequenceNumber; + request->subscriptionAcknowledgements[i].subscriptionId = ack->subAck.subscriptionId; + ++i; + LIST_REMOVE(ack, listEntry); + UA_free(ack); + } + return UA_STATUSCODE_GOOD; +} + +/* According to OPC Unified Architecture, Part 4 5.13.1.1 i) */ +/* The value 0 is never used for the sequence number */ +static UA_UInt32 +UA_Client_Subscriptions_nextSequenceNumber(UA_UInt32 sequenceNumber) { + UA_UInt32 nextSequenceNumber = sequenceNumber + 1; + if(nextSequenceNumber == 0) + nextSequenceNumber = 1; + return nextSequenceNumber; +} + +static void +processDataChangeNotification(UA_Client *client, UA_Client_Subscription *sub, + UA_DataChangeNotification *dataChangeNotification) { + for(size_t j = 0; j < dataChangeNotification->monitoredItemsSize; ++j) { + UA_MonitoredItemNotification *min = &dataChangeNotification->monitoredItems[j]; + + /* Find the MonitoredItem */ + UA_Client_MonitoredItem *mon; + LIST_FOREACH(mon, &sub->monitoredItems, listEntry) { + if(mon->clientHandle == min->clientHandle) + break; + } + + if(!mon) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Could not process a notification with clienthandle %" PRIu32 + " on subscription %" PRIu32, min->clientHandle, sub->subscriptionId); + continue; + } + + if(mon->isEventMonitoredItem) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "MonitoredItem is configured for Events. But received a " + "DataChangeNotification."); + continue; + } + + mon->handler.dataChangeCallback(client, sub->subscriptionId, sub->context, + mon->monitoredItemId, mon->context, + &min->value); + } +} + +static void +processEventNotification(UA_Client *client, UA_Client_Subscription *sub, + UA_EventNotificationList *eventNotificationList) { + for(size_t j = 0; j < eventNotificationList->eventsSize; ++j) { + UA_EventFieldList *eventFieldList = &eventNotificationList->events[j]; + + /* Find the MonitoredItem */ + UA_Client_MonitoredItem *mon; + LIST_FOREACH(mon, &sub->monitoredItems, listEntry) { + if(mon->clientHandle == eventFieldList->clientHandle) + break; + } + + if(!mon) { + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Could not process a notification with clienthandle %" PRIu32 + " on subscription %" PRIu32, eventFieldList->clientHandle, + sub->subscriptionId); + continue; + } + + if(!mon->isEventMonitoredItem) { + UA_LOG_DEBUG(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "MonitoredItem is configured for DataChanges. But received a " + "EventNotification."); + continue; + } + + mon->handler.eventCallback(client, sub->subscriptionId, sub->context, + mon->monitoredItemId, mon->context, + eventFieldList->eventFieldsSize, + eventFieldList->eventFields); + } +} + +static void +processNotificationMessage(UA_Client *client, UA_Client_Subscription *sub, + UA_ExtensionObject *msg) { + if(msg->encoding != UA_EXTENSIONOBJECT_DECODED) + return; + + /* Handle DataChangeNotification */ + if(msg->content.decoded.type == &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]) { + UA_DataChangeNotification *dataChangeNotification = + (UA_DataChangeNotification *)msg->content.decoded.data; + processDataChangeNotification(client, sub, dataChangeNotification); + return; + } + + /* Handle EventNotification */ + if(msg->content.decoded.type == &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]) { + UA_EventNotificationList *eventNotificationList = + (UA_EventNotificationList *)msg->content.decoded.data; + processEventNotification(client, sub, eventNotificationList); + return; + } + + /* Handle StatusChangeNotification */ + if(msg->content.decoded.type == &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]) { + if(sub->statusChangeCallback) { + sub->statusChangeCallback(client, sub->subscriptionId, sub->context, + (UA_StatusChangeNotification*)msg->content.decoded.data); + } else { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Dropped a StatusChangeNotification since no " + "callback is registered"); + } + return; + } + + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Unknown notification message type"); +} + +static void +UA_Client_Subscriptions_processPublishResponse(UA_Client *client, UA_PublishRequest *request, + UA_PublishResponse *response) { + UA_NotificationMessage *msg = &response->notificationMessage; + + client->currentlyOutStandingPublishRequests--; + + if(response->responseHeader.serviceResult == UA_STATUSCODE_BADTOOMANYPUBLISHREQUESTS) { + if(client->config.outStandingPublishRequests > 1) { + client->config.outStandingPublishRequests--; + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Too many publishrequest, reduce outStandingPublishRequests " + "to %" PRId16, client->config.outStandingPublishRequests); + } else { + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Too many publishrequest when outStandingPublishRequests = 1"); + UA_Client_Subscriptions_deleteSingle(client, response->subscriptionId); + } + return; + } + + if(response->responseHeader.serviceResult == UA_STATUSCODE_BADSHUTDOWN) + return; + + if(!LIST_FIRST(&client->subscriptions)) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADNOSUBSCRIPTION; + return; + } + + if(response->responseHeader.serviceResult == UA_STATUSCODE_BADSESSIONCLOSED) { + if(client->sessionState != UA_SESSIONSTATE_ACTIVATED) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Received Publish Response with code %s", + UA_StatusCode_name(response->responseHeader.serviceResult)); + UA_Client_Subscription* sub = findSubscription(client, response->subscriptionId); + if (sub != NULL) + UA_Client_Subscription_deleteInternal(client, sub); + } + return; + } + + if(response->responseHeader.serviceResult == UA_STATUSCODE_BADSESSIONIDINVALID) { + UA_Client_disconnect(client); /* TODO: This should be handled before the process callback */ + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Received BadSessionIdInvalid"); + return; + } + + if(response->responseHeader.serviceResult == UA_STATUSCODE_BADTIMEOUT) { + if (client->config.inactivityCallback) + client->config.inactivityCallback(client); + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Received Timeout for Publish Response"); + return; + } + + if(response->responseHeader.serviceResult != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Received Publish Response with code %s", + UA_StatusCode_name(response->responseHeader.serviceResult)); + return; + } + + UA_Client_Subscription *sub = findSubscription(client, response->subscriptionId); + if(!sub) { + response->responseHeader.serviceResult = UA_STATUSCODE_BADINTERNALERROR; + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Received Publish Response for a non-existant subscription"); + return; + } + + sub->lastActivity = UA_DateTime_nowMonotonic(); + + /* Detect missing message - OPC Unified Architecture, Part 4 5.13.1.1 e) */ + if(UA_Client_Subscriptions_nextSequenceNumber(sub->sequenceNumber) != msg->sequenceNumber) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Invalid subscription sequence number: expected %" PRIu32 + " but got %" PRIu32, + UA_Client_Subscriptions_nextSequenceNumber(sub->sequenceNumber), + msg->sequenceNumber); + /* This is an error. But we do not abort the connection. Some server + * SDKs misbehave from time to time and send out-of-order sequence + * numbers. (Probably some multi-threading synchronization issue.) */ + /* UA_Client_disconnect(client); + return; */ + } + /* According to f), a keep-alive message contains no notifications and has + * the sequence number of the next NotificationMessage that is to be sent => + * More than one consecutive keep-alive message or a NotificationMessage + * following a keep-alive message will share the same sequence number. */ + if (msg->notificationDataSize) + sub->sequenceNumber = msg->sequenceNumber; + + /* Process the notification messages */ + for(size_t k = 0; k < msg->notificationDataSize; ++k) + processNotificationMessage(client, sub, &msg->notificationData[k]); + + /* Add to the list of pending acks */ + for(size_t i = 0; i < response->availableSequenceNumbersSize; i++) { + if(response->availableSequenceNumbers[i] != msg->sequenceNumber) + continue; + UA_Client_NotificationsAckNumber *tmpAck = (UA_Client_NotificationsAckNumber*) + UA_malloc(sizeof(UA_Client_NotificationsAckNumber)); + if(!tmpAck) { + UA_LOG_WARNING(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Not enough memory to store the acknowledgement for a publish " + "message on subscription %" PRIu32, sub->subscriptionId); + break; + } + tmpAck->subAck.sequenceNumber = msg->sequenceNumber; + tmpAck->subAck.subscriptionId = sub->subscriptionId; + LIST_INSERT_HEAD(&client->pendingNotificationsAcks, tmpAck, listEntry); + break; + } +} + +static void +processPublishResponseAsync(UA_Client *client, void *userdata, + UA_UInt32 requestId, void *response) { + UA_PublishRequest *req = (UA_PublishRequest*)userdata; + UA_PublishResponse *res = (UA_PublishResponse*)response; + + /* Process the response */ + UA_Client_Subscriptions_processPublishResponse(client, req, res); + + /* Delete the cached request */ + UA_PublishRequest_delete(req); + + /* Fill up the outstanding publish requests */ + UA_Client_Subscriptions_backgroundPublish(client); +} + +void +UA_Client_Subscriptions_clean(UA_Client *client) { + UA_Client_NotificationsAckNumber *n; + UA_Client_NotificationsAckNumber *tmp; + LIST_FOREACH_SAFE(n, &client->pendingNotificationsAcks, listEntry, tmp) { + LIST_REMOVE(n, listEntry); + UA_free(n); + } + + UA_Client_Subscription *sub; + UA_Client_Subscription *tmps; + LIST_FOREACH_SAFE(sub, &client->subscriptions, listEntry, tmps) + UA_Client_Subscription_deleteInternal(client, sub); /* force local removal */ + + client->monitoredItemHandles = 0; +} + +void +UA_Client_Subscriptions_backgroundPublishInactivityCheck(UA_Client *client) { + if(client->sessionState < UA_SESSIONSTATE_ACTIVATED) + return; + + /* Is the lack of responses the client's fault? */ + if(client->currentlyOutStandingPublishRequests == 0) + return; + + UA_Client_Subscription *sub; + LIST_FOREACH(sub, &client->subscriptions, listEntry) { + UA_DateTime maxSilence = (UA_DateTime) + ((sub->publishingInterval * sub->maxKeepAliveCount) + + client->config.timeout) * UA_DATETIME_MSEC; + if(maxSilence + sub->lastActivity < UA_DateTime_nowMonotonic()) { + /* Reset activity */ + sub->lastActivity = UA_DateTime_nowMonotonic(); + + if(client->config.subscriptionInactivityCallback) + client->config.subscriptionInactivityCallback(client, sub->subscriptionId, + sub->context); + UA_LOG_ERROR(&client->config.logger, UA_LOGCATEGORY_CLIENT, + "Inactivity for Subscription %" PRIu32 ".", sub->subscriptionId); + } + } +} + +void +UA_Client_Subscriptions_backgroundPublish(UA_Client *client) { + if(client->sessionState < UA_SESSIONSTATE_ACTIVATED) + return; + + /* The session must have at least one subscription */ + if(!LIST_FIRST(&client->subscriptions)) + return; + + while(client->currentlyOutStandingPublishRequests < client->config.outStandingPublishRequests) { + UA_PublishRequest *request = UA_PublishRequest_new(); + if(!request) + return; + + request->requestHeader.timeoutHint=60000; + UA_StatusCode retval = UA_Client_preparePublishRequest(client, request); + if(retval != UA_STATUSCODE_GOOD) { + UA_PublishRequest_delete(request); + return; + } + + UA_UInt32 requestId; + client->currentlyOutStandingPublishRequests++; + + /* Disable the timeout, it is treat in + * UA_Client_Subscriptions_backgroundPublishInactivityCheck */ + retval = __UA_Client_AsyncServiceEx(client, request, + &UA_TYPES[UA_TYPES_PUBLISHREQUEST], + processPublishResponseAsync, + &UA_TYPES[UA_TYPES_PUBLISHRESPONSE], + (void*)request, &requestId, 0); + if(retval != UA_STATUSCODE_GOOD) { + UA_PublishRequest_delete(request); + return; + } + } +} + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +/**** amalgamated original file "/deps/libc_time.c" ****/ + +/* Originally released by the musl project (http://www.musl-libc.org/) under the + * MIT license. Taken from the file /src/time/__secs_to_tm.c */ + +#include + +/* 2000-03-01 (mod 400 year, immediately after feb29 */ +#define LEAPOCH (946684800LL + 86400*(31+29)) + +#define DAYS_PER_400Y (365*400 + 97) +#define DAYS_PER_100Y (365*100 + 24) +#define DAYS_PER_4Y (365*4 + 1) + +int __secs_to_tm(long long t, struct mytm *tm) { + long long days, secs, years; + int remdays, remsecs, remyears; + int qc_cycles, c_cycles, q_cycles; + int months; + static const char days_in_month[] = {31,30,31,30,31,31,30,31,30,31,31,29}; + + /* Reject time_t values whose year would overflow int */ + if (t < INT_MIN * 31622400LL || t > INT_MAX * 31622400LL) + return -1; + + secs = t - LEAPOCH; + days = secs / 86400LL; + remsecs = (int)(secs % 86400); + if (remsecs < 0) { + remsecs += 86400; + --days; + } + + qc_cycles = (int)(days / DAYS_PER_400Y); + remdays = (int)(days % DAYS_PER_400Y); + if (remdays < 0) { + remdays += DAYS_PER_400Y; + --qc_cycles; + } + + c_cycles = remdays / DAYS_PER_100Y; + if (c_cycles == 4) --c_cycles; + remdays -= c_cycles * DAYS_PER_100Y; + + q_cycles = remdays / DAYS_PER_4Y; + if (q_cycles == 25) --q_cycles; + remdays -= q_cycles * DAYS_PER_4Y; + + remyears = remdays / 365; + if (remyears == 4) --remyears; + remdays -= remyears * 365; + + years = remyears + 4*q_cycles + 100*c_cycles + 400LL*qc_cycles; + + for (months=0; days_in_month[months] <= remdays; ++months) + remdays -= days_in_month[months]; + + if (years+100 > INT_MAX || years+100 < INT_MIN) + return -1; + + tm->tm_year = (int)(years + 100); + tm->tm_mon = months + 2; + if (tm->tm_mon >= 12) { + tm->tm_mon -=12; + ++tm->tm_year; + } + tm->tm_mday = remdays + 1; + tm->tm_hour = remsecs / 3600; + tm->tm_min = remsecs / 60 % 60; + tm->tm_sec = remsecs % 60; + + return 0; +} + +static const int secs_through_month[] = + {0, 31*86400, 59*86400, 90*86400, + 120*86400, 151*86400, 181*86400, 212*86400, + 243*86400, 273*86400, 304*86400, 334*86400 }; + +static int +__month_to_secs(int month, int is_leap) { + int t = secs_through_month[month]; + if (is_leap && month >= 2) + t+=86400; + return t; +} + +static long long +__year_to_secs(const long long year, int *is_leap) { + int cycles, centuries, leaps, rem; + int is_leap_val = 0; + if (!is_leap) { + is_leap = &is_leap_val; + } + cycles = (int)((year-100) / 400); + rem = (int)((year-100) % 400); + if (rem < 0) { + cycles--; + rem += 400; + } + if (!rem) { + *is_leap = 1; + centuries = 0; + leaps = 0; + } else { + if (rem >= 200) { + if (rem >= 300) centuries = 3, rem -= 300; + else centuries = 2, rem -= 200; + } else { + if (rem >= 100) centuries = 1, rem -= 100; + else centuries = 0; + } + if (!rem) { + *is_leap = 0; + leaps = 0; + } else { + leaps = (rem / (int)4U); + rem %= (int)4U; + *is_leap = !rem; + } + } + + leaps += 97*cycles + 24*centuries - *is_leap; + + return (year-100) * 31536000LL + leaps * 86400LL + 946684800 + 86400; +} + +long long __tm_to_secs(const struct mytm *tm) { + int is_leap; + long long year = tm->tm_year; + int month = tm->tm_mon; + if (month >= 12 || month < 0) { + int adj = month / 12; + month %= 12; + if (month < 0) { + adj--; + month += 12; + } + year += adj; + } + long long t = __year_to_secs(year, &is_leap); + t += __month_to_secs(month, is_leap); + t += 86400LL * (tm->tm_mday-1); + t += 3600LL * tm->tm_hour; + t += 60LL * tm->tm_min; + t += tm->tm_sec; + return t; +} + +/**** amalgamated original file "/deps/pcg_basic.c" ****/ + +/* + * PCG Random Number Generation for C. + * + * Copyright 2014 Melissa O'Neill + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + * For additional information about the PCG random number generation scheme, + * including its license and other licensing options, visit + * + * http://www.pcg-random.org + */ + + +void pcg32_srandom_r(pcg32_random_t* rng, uint64_t initial_state, uint64_t initseq) { + rng->state = 0U; + rng->inc = (initseq << 1u) | 1u; + pcg32_random_r(rng); + rng->state += initial_state; + pcg32_random_r(rng); +} + +uint32_t pcg32_random_r(pcg32_random_t* rng) { + uint64_t oldstate = rng->state; + rng->state = oldstate * 6364136223846793005ULL + rng->inc; + uint32_t xorshifted = (uint32_t)(((oldstate >> 18u) ^ oldstate) >> 27u); + uint32_t rot = (uint32_t)(oldstate >> 59u); + return (xorshifted >> rot) | (xorshifted << ((~rot + 1u) & 31)); /* was (xorshifted >> rot) | (xorshifted << ((-rot) & 31)) */ +} + +/**** amalgamated original file "/deps/base64.c" ****/ + +/* + * Base64 encoding: Copyright (c) 2005-2011, Jouni Malinen + * This software may be distributed under the terms of the BSD license. + * + * Base64 decoding: Copyright (c) 2016, polfosol + * Posted at https://stackoverflow.com/a/37109258 under the CC-BY-SA Creative + * Commons license. + */ + + +static const unsigned char base64_table[65] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +unsigned char * +UA_base64(const unsigned char *src, size_t len, size_t *out_len) { + if(len == 0) { + *out_len = 0; + return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; + } + + size_t olen = 4*((len + 2) / 3); /* 3-byte blocks to 4-byte */ + if(olen < len) + return NULL; /* integer overflow */ + + unsigned char *out = (unsigned char*)UA_malloc(olen); + if(!out) + return NULL; + + const unsigned char *end = src + len; + const unsigned char *in = src; + unsigned char *pos = out; + while(end - in >= 3) { + *pos++ = base64_table[in[0] >> 2]; + *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)]; + *pos++ = base64_table[((in[1] & 0x0f) << 2) | (in[2] >> 6)]; + *pos++ = base64_table[in[2] & 0x3f]; + in += 3; + } + + if(end - in) { + *pos++ = base64_table[in[0] >> 2]; + if(end - in == 1) { + *pos++ = base64_table[(in[0] & 0x03) << 4]; + *pos++ = '='; + } else { + *pos++ = base64_table[((in[0] & 0x03) << 4) | (in[1] >> 4)]; + *pos++ = base64_table[(in[1] & 0x0f) << 2]; + } + *pos++ = '='; + } + + *out_len = (size_t)(pos - out); + return out; +} + +static const uint32_t from_b64[256] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 62, 63, 62, 62, 63, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0, 0, 0, 0, 0, + 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, + 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0, 63, + 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, + 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51}; + +unsigned char * +UA_unbase64(const unsigned char *src, size_t len, size_t *out_len) { + // we need a minimum length + if(len <= 2) { + *out_len = 0; + return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; + } + + const unsigned char *p = src; + size_t pad1 = len % 4 || p[len - 1] == '='; + size_t pad2 = pad1 && (len % 4 > 2 || p[len - 2] != '='); + const size_t last = (len - pad1) / 4 << 2; + + unsigned char *str = (unsigned char*)UA_malloc(last / 4 * 3 + pad1 + pad2); + if(!str) + return NULL; + + unsigned char *pos = str; + for(size_t i = 0; i < last; i += 4) { + uint32_t n = from_b64[p[i]] << 18 | from_b64[p[i + 1]] << 12 | + from_b64[p[i + 2]] << 6 | from_b64[p[i + 3]]; + *pos++ = (unsigned char)(n >> 16); + *pos++ = (unsigned char)(n >> 8 & 0xFF); + *pos++ = (unsigned char)(n & 0xFF); + } + + if(pad1) { + if (last + 1 >= len) { + UA_free(str); + *out_len = 0; + return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; + } + uint32_t n = from_b64[p[last]] << 18 | from_b64[p[last + 1]] << 12; + *pos++ = (unsigned char)(n >> 16); + if(pad2) { + if (last + 2 >= len) { + UA_free(str); + *out_len = 0; + return (unsigned char*)UA_EMPTY_ARRAY_SENTINEL; + } + n |= from_b64[p[last + 2]] << 6; + *pos++ = (unsigned char)(n >> 8 & 0xFF); + } + } + + *out_len = (uintptr_t)(pos - str); + return str; +} + +/**** amalgamated original file "/deps/aa_tree.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + +#include + +#if !defined(_MSC_VER) || _MSC_VER >= 1800 +# include +#elif !defined(uintptr_t) + /* Workaround missing standard includes in older Visual Studio */ +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +typedef _W64 unsigned int uintptr_t; +# else +typedef unsigned __int64 uintptr_t; +# endif +#endif + +#define aa_entry_container(head, entry) \ + ((void*)((uintptr_t)entry - head->entry_offset)) +#define aa_entry_key(head, entry) \ + ((const void*)((uintptr_t)entry + head->key_offset - head->entry_offset)) +#define aa_container_entry(head, container) \ + ((struct aa_entry*)((uintptr_t)container + head->entry_offset)) +#define aa_container_key(head, container) \ + ((const void*)((uintptr_t)container + head->key_offset)) + +void +aa_init(struct aa_head *head, + enum aa_cmp (*cmp)(const void*, const void*), + unsigned int entry_offset, unsigned int key_offset) { + head->root = NULL; + head->cmp = cmp; + head->entry_offset = entry_offset; + head->key_offset = key_offset; +} + +static struct aa_entry * +_aa_skew(struct aa_entry *n) { + if(!n) + return NULL; + if(n->left && n->level == n->left->level) { + struct aa_entry *l = n->left; + n->left = l->right; + l->right = n; + return l; + } + return n; +} + +static struct aa_entry * +_aa_split(struct aa_entry *n) { + if(!n) + return NULL; + if(n->right && n->right->right && + n->right->right->level == n->level) { + struct aa_entry *r = n->right; + n->right = r->left; + r->left = n; + r->level++; + return r; + } + return n; +} + +static struct aa_entry * +_aa_fixup(struct aa_entry *n) { + unsigned int should_be = 0; + if(n->left) + should_be = n->left->level; + if(n->right && n->right->level < should_be) + should_be = n->right->level; + should_be++; + if(should_be < n->level) + n->level = should_be; + if(n->right && n->right->level > should_be) + n->right->level = should_be; + n = _aa_skew(n); + n->right = _aa_skew(n->right); + if(n->right) + n->right->right = _aa_skew(n->right->right); + n = _aa_split(n); + n->right = _aa_split(n->right); + return n; +} + +static struct aa_entry * +_aa_insert(struct aa_head *h, struct aa_entry *n, void *elem) { + if(!n) { + struct aa_entry *e = aa_container_entry(h, elem); + e->left = NULL; + e->right = NULL; + e->level = 1; + return e; + } + const void *n_key = aa_entry_key(h, n); + const void *key = aa_container_key(h, elem); + enum aa_cmp eq = h->cmp(key, n_key); + if(eq == AA_CMP_EQ) + eq = (key > n_key) ? AA_CMP_MORE : AA_CMP_LESS; + if(eq == AA_CMP_LESS) + n->left = _aa_insert(h, n->left, elem); + else + n->right = _aa_insert(h, n->right, elem); + return _aa_split(_aa_skew(n)); +} + +void +aa_insert(struct aa_head *h, void *elem) { + h->root = _aa_insert(h, h->root, elem); +} + +void * +aa_find(const struct aa_head *h, const void *key) { + struct aa_entry *n = h->root; + while(n) { + enum aa_cmp eq = h->cmp(key, aa_entry_key(h, n)); + if(eq == AA_CMP_EQ) + return aa_entry_container(h, n); + n = (eq == AA_CMP_LESS) ? n->left : n->right; + } + return NULL; +} + +static struct aa_entry * +unlink_succ(struct aa_entry *n, struct aa_entry **succ) { + if(!n->left) { + *succ = n; + return n->right; + } + n->left = unlink_succ(n->left, succ); + return _aa_fixup(n); +} + +static struct aa_entry * +unlink_pred(struct aa_entry *n, struct aa_entry **pred) { + if(!n->right) { + *pred = n; + return n->left; + } + n->right = unlink_pred(n->right, pred); + return _aa_fixup(n); +} + +static struct aa_entry * +_aa_remove(struct aa_head *h, void *elem, struct aa_entry *n) { + if(!n) + return NULL; + + const void *elem_key = aa_container_key(h, elem); + const void *n_key = aa_entry_key(h, n); + if(n_key == elem_key) { + if(!n->left && !n->right) + return NULL; + struct aa_entry *replace = NULL; + if(!n->left) + n->right = unlink_succ(n->right, &replace); + else + n->left = unlink_pred(n->left, &replace); + replace->left = n->left; + replace->right = n->right; + replace->level = n->level; + return _aa_fixup(replace); + } + + enum aa_cmp eq = h->cmp(elem_key, n_key); + if(eq == AA_CMP_EQ) + eq = (elem_key > n_key) ? AA_CMP_MORE : AA_CMP_LESS; + if(eq == AA_CMP_LESS) + n->left = _aa_remove(h, elem, n->left); + else + n->right = _aa_remove(h, elem, n->right); + return _aa_fixup(n); +} + +void +aa_remove(struct aa_head *head, void *elem) { + head->root = _aa_remove(head, elem, head->root); +} + +void * +aa_min(const struct aa_head *head) { + struct aa_entry *e = head->root; + if(!e) + return NULL; + while(e->left) + e = e->left; + return aa_entry_container(head, e); +} + +void * +aa_max(const struct aa_head *head) { + struct aa_entry *e = head->root; + if(!e) + return NULL; + while(e->right) + e = e->right; + return aa_entry_container(head, e); +} + +void * +aa_next(const struct aa_head *head, const void *elem) { + struct aa_entry *e = aa_container_entry(head, elem); + if(e->right) { + e = e->right; + while(e->left) + e = e->left; + return aa_entry_container(head, e); + } + struct aa_entry *next = NULL; + struct aa_entry *n = head->root; + const void *key = aa_container_key(head, elem); + while(n && n != e) { + const void *n_key = aa_entry_key(head, n); + enum aa_cmp eq = head->cmp(key, n_key); + if(eq == AA_CMP_EQ) + eq = (key > n_key) ? AA_CMP_MORE : AA_CMP_LESS; + if(eq == AA_CMP_MORE) { + n = n->right; + } else { + next = n; + n = n->left; + } + } + return (next) ? aa_entry_container(head, next) : NULL; +} + +void * +aa_prev(const struct aa_head *head, const void *elem) { + struct aa_entry *e = aa_container_entry(head, elem); + if(e->left) { + e = e->left; + while(e->right) + e = e->right; + return aa_entry_container(head, e); + } + struct aa_entry *prev = NULL; + struct aa_entry *n = head->root; + const void *key = aa_container_key(head, elem); + while(n && n != e) { + const void *n_key = aa_entry_key(head, n); + enum aa_cmp eq = head->cmp(key, n_key); + if(eq == AA_CMP_EQ) + eq = (key > n_key) ? AA_CMP_MORE : AA_CMP_LESS; + if(eq == AA_CMP_MORE) { + prev = n; + n = n->right; + } else { + n = n->left; + } + } + return (prev) ? aa_entry_container(head, prev) : NULL; +} + +/**** amalgamated original file "/src/pubsub/ua_pubsub_config.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2020 Yannick Wallerer, Siemens AG + * Copyright (c) 2020 Thomas Fischer, Siemens AG + */ + + +#ifdef UA_ENABLE_PUBSUB +#ifdef UA_ENABLE_PUBSUB_ETH_UADP +#endif +#endif + + +#ifdef UA_ENABLE_PUBSUB_FILE_CONFIG + +static UA_StatusCode +createPubSubConnection(UA_Server *server, + const UA_PubSubConnectionDataType *connection, + UA_UInt32 pdsCount, UA_NodeId *pdsIdent); + +static UA_StatusCode +createWriterGroup(UA_Server *server, + const UA_WriterGroupDataType *writerGroupParameters, + UA_NodeId connectionIdent, UA_UInt32 pdsCount, + const UA_NodeId *pdsIdent); + +static UA_StatusCode +createDataSetWriter(UA_Server *server, + const UA_DataSetWriterDataType *dataSetWriterParameters, + UA_NodeId writerGroupIdent, UA_UInt32 pdsCount, + const UA_NodeId *pdsIdent); + +static UA_StatusCode +createReaderGroup(UA_Server *server, + const UA_ReaderGroupDataType *readerGroupParameters, + UA_NodeId connectionIdent); + +static UA_StatusCode +createDataSetReader(UA_Server *server, + const UA_DataSetReaderDataType *dataSetReaderParameters, + UA_NodeId readerGroupIdent); + +static UA_StatusCode +createPublishedDataSet(UA_Server *server, + const UA_PublishedDataSetDataType *publishedDataSetParameters, + UA_NodeId *publishedDataSetIdent); + +static UA_StatusCode +createDataSetFields(UA_Server *server, + const UA_NodeId *publishedDataSetIdent, + const UA_PublishedDataSetDataType *publishedDataSetParameters); + +static UA_StatusCode +generatePubSubConfigurationDataType(const UA_Server *server, + UA_PubSubConfigurationDataType *pubSubConfiguration); + +/* Gets PubSub Configuration from an ExtensionObject */ +static UA_StatusCode +extractPubSubConfigFromExtensionObject(const UA_ExtensionObject *src, + UA_PubSubConfigurationDataType **dst) { + if(src->encoding != UA_EXTENSIONOBJECT_DECODED || + src->content.decoded.type != &UA_TYPES[UA_TYPES_UABINARYFILEDATATYPE]) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_extractPubSubConfigFromDecodedObject] " + "Reading extensionObject failed"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_UABinaryFileDataType *binFile = (UA_UABinaryFileDataType*)src->content.decoded.data; + + if(binFile->body.arrayLength != 0 || binFile->body.arrayDimensionsSize != 0) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_extractPubSubConfigFromDecodedObject] " + "Loading multiple configurations is not supported"); + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + + if(binFile->body.type != &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONDATATYPE]) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_extractPubSubConfigFromDecodedObject] " + "Invalid datatype encoded in the binary file"); + return UA_STATUSCODE_BADTYPEMISMATCH; + } + + *dst = (UA_PubSubConfigurationDataType*)binFile->body.data; + return UA_STATUSCODE_GOOD; +} + +/* Configures a PubSub Server with given PubSubConfigurationDataType object */ +static UA_StatusCode +updatePubSubConfig(UA_Server *server, + const UA_PubSubConfigurationDataType *configurationParameters) { + if(server == NULL || configurationParameters == NULL) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_updatePubSubConfig] Invalid argument"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_PubSubManager_delete(server, &server->pubSubManager); + + /* Configuration of Published DataSets: */ + UA_UInt32 pdsCount = (UA_UInt32)configurationParameters->publishedDataSetsSize; + UA_NodeId *publishedDataSetIdent = (UA_NodeId*)UA_calloc(pdsCount, sizeof(UA_NodeId)); + if(!publishedDataSetIdent) + return UA_STATUSCODE_BADOUTOFMEMORY; + + UA_StatusCode res = UA_STATUSCODE_GOOD; + for(UA_UInt32 i = 0; i < pdsCount; i++) { + res = createPublishedDataSet(server, + &configurationParameters->publishedDataSets[i], + &publishedDataSetIdent[i]); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_updatePubSubConfig] PDS creation failed"); + UA_free(publishedDataSetIdent); + return res; + } + } + + /* Configuration of PubSub Connections: */ + if(configurationParameters->connectionsSize < 1) { + UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_updatePubSubConfig] no connection in " + "UA_PubSubConfigurationDataType"); + UA_free(publishedDataSetIdent); + return UA_STATUSCODE_GOOD; + } + + for(size_t i = 0; i < configurationParameters->connectionsSize; i++) { + res = createPubSubConnection(server, + &configurationParameters->connections[i], + pdsCount, publishedDataSetIdent); + if(res != UA_STATUSCODE_GOOD) + break; + } + + UA_free(publishedDataSetIdent); + return res; +} + +/* Function called by UA_PubSubManager_createPubSubConnection to set the + * PublisherId of a certain connection. */ +static UA_StatusCode +setConnectionPublisherId(const UA_PubSubConnectionDataType *src, + UA_PubSubConnectionConfig *dst) { + if(src->publisherId.type == &UA_TYPES[UA_TYPES_STRING]) { + dst->publisherIdType = UA_PUBSUB_PUBLISHERID_STRING; + dst->publisherId.string = *(UA_String*)src->publisherId.data; + } else if(src->publisherId.type == &UA_TYPES[UA_TYPES_BYTE] || + src->publisherId.type == &UA_TYPES[UA_TYPES_UINT16] || + src->publisherId.type == &UA_TYPES[UA_TYPES_UINT32]) { + dst->publisherIdType = UA_PUBSUB_PUBLISHERID_NUMERIC; + dst->publisherId.numeric = *(UA_UInt32*)src->publisherId.data; + } else if(src->publisherId.type == &UA_TYPES[UA_TYPES_UINT64]) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_setConnectionPublisherId] PublisherId is UInt64 " + "(not implemented); Recommended dataType for PublisherId: UInt32"); + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } else { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_setConnectionPublisherId] PublisherId is not valid."); + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_GOOD; +} + +/* Function called by UA_PubSubManager_createPubSubConnection to create all WriterGroups + * and ReaderGroups that belong to a certain connection. */ +static UA_StatusCode +createComponentsForConnection(UA_Server *server, + const UA_PubSubConnectionDataType *connParams, + UA_NodeId connectionIdent, UA_UInt32 pdsCount, + const UA_NodeId *pdsIdent) { + /* WriterGroups configuration */ + UA_StatusCode res = UA_STATUSCODE_GOOD; + for(size_t i = 0; i < connParams->writerGroupsSize; i++) { + res = createWriterGroup(server, &connParams->writerGroups[i], + connectionIdent, pdsCount, pdsIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createComponentsForConnection] " + "Error occured during %d. WriterGroup Creation", (UA_UInt32)i+1); + return res; + } + } + + /* ReaderGroups configuration */ + for(size_t j = 0; j < connParams->readerGroupsSize; j++) { + res = createReaderGroup(server, &connParams->readerGroups[j], connectionIdent); + if(res == UA_STATUSCODE_GOOD) + res |= UA_PubSubConnection_regist(server, &connectionIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createComponentsForConnection] " + "Error occured during %d. ReaderGroup Creation", (UA_UInt32)j+1); + return res; + } + } + + return res; +} + +/* Checks if transportLayer for the specified transportProfileUri exists. + * + * @param server Server object that shall be configured + * @param transportProfileUri String that specifies the transport protocol */ +static UA_Boolean +transportLayerExists(UA_Server *server, UA_String transportProfileUri) { + for(size_t i = 0; i < server->config.pubSubConfig.transportLayersSize; i++) { + if(UA_String_equal(&server->config.pubSubConfig.transportLayers[i].transportProfileUri, + &transportProfileUri)) { + return true; + } + } + return false; +} + +/* Creates transportlayer for specified transport protocol if this layer doesn't exist yet */ +static UA_StatusCode +createTransportLayer(UA_Server *server, const UA_String transportProfileUri) { + if(transportLayerExists(server, transportProfileUri)) + return UA_STATUSCODE_GOOD; + + UA_ServerConfig *config = UA_Server_getConfig(server); + UA_PubSubTransportLayer tl; + + do { + UA_String strUDP = + UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-udp-uadp"); + if(UA_String_equal(&transportProfileUri, &strUDP)) { + tl = UA_PubSubTransportLayerUDPMP(); + break; + } + +#ifdef UA_ENABLE_PUBSUB_ETH_UADP + UA_String strETH = + UA_STRING("http://opcfoundation.org/UA-Profile/Transport/pubsub-eth-uadp"); + if(UA_String_equal(&transportProfileUri, &strETH)) { + tl = UA_PubSubTransportLayerEthernet(); + break; + } +#endif + + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createTransportLayer] " + "invalid transportProfileUri"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } while(0); + + if(config->pubSubConfig.transportLayersSize > 0) { + config->pubSubConfig.transportLayers = (UA_PubSubTransportLayer *) + UA_realloc(config->pubSubConfig.transportLayers, + (config->pubSubConfig.transportLayersSize + 1) * + sizeof(UA_PubSubTransportLayer)); + } else { + config->pubSubConfig.transportLayers = (UA_PubSubTransportLayer *) + UA_calloc(1, sizeof(UA_PubSubTransportLayer)); + } + + if(config->pubSubConfig.transportLayers == NULL) { + UA_Server_delete(server); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + config->pubSubConfig.transportLayers[config->pubSubConfig.transportLayersSize] = tl; + config->pubSubConfig.transportLayersSize++; + return UA_STATUSCODE_GOOD; +} + +/* Creates PubSubConnection configuration from PubSubConnectionDataType object + * + * @param server Server object that shall be configured + * @param connParams PubSub connection configuration + * @param pdsCount Number of published DataSets + * @param pdsIdent Array of NodeIds of the published DataSets */ +static UA_StatusCode +createPubSubConnection(UA_Server *server, const UA_PubSubConnectionDataType *connParams, + UA_UInt32 pdsCount, UA_NodeId *pdsIdent) { + UA_PubSubConnectionConfig config; + memset(&config, 0, sizeof(UA_PubSubConnectionConfig)); + + config.name = connParams->name; + config.enabled = connParams->enabled; + config.transportProfileUri = connParams->transportProfileUri; + config.connectionPropertiesSize = connParams->connectionPropertiesSize; + if(config.connectionPropertiesSize > 0) { + config.connectionProperties = connParams->connectionProperties; + } + + UA_StatusCode res = setConnectionPublisherId(connParams, &config); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createPubSubConnection] " + "Setting PublisherId failed"); + return res; + } + + if(connParams->address.encoding == UA_EXTENSIONOBJECT_DECODED) { + UA_Variant_setScalar(&(config.address), + connParams->address.content.decoded.data, + connParams->address.content.decoded.type); + } else { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createPubSubConnection] " + "Reading connection address failed"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + if(connParams->transportSettings.encoding == UA_EXTENSIONOBJECT_DECODED) { + UA_Variant_setScalar(&(config.connectionTransportSettings), + connParams->transportSettings.content.decoded.data, + connParams->transportSettings.content.decoded.type); + } else { + UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createPubSubConnection] " + "TransportSettings can not be read"); + } + + res = createTransportLayer(server, connParams->transportProfileUri); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createPubSubConnection] " + "Creating transportLayer failed"); + return res; + } + + /* Load connection config into server: */ + UA_NodeId connectionIdent; + res = UA_Server_addPubSubConnection(server, &config, &connectionIdent); + if(res == UA_STATUSCODE_GOOD) { + /* Configuration of all Components that belong to this connection: */ + res = createComponentsForConnection(server, connParams, connectionIdent, + pdsCount, pdsIdent); + } else { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createPubSubConnection] " + "Connection creation failed"); + } + + return res; +} + +/* Function called by UA_PubSubManager_createWriterGroup to configure the messageSettings + * of a writerGroup */ +static UA_StatusCode +setWriterGroupEncodingType(const UA_WriterGroupDataType *writerGroupParameters, + UA_WriterGroupConfig *config) { + if(writerGroupParameters->messageSettings.encoding != UA_EXTENSIONOBJECT_DECODED) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_setWriterGroupEncodingType] " + "getting message type information failed"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + if(writerGroupParameters->messageSettings.content.decoded.type == + &UA_TYPES[UA_TYPES_UADPWRITERGROUPMESSAGEDATATYPE]) { + config->encodingMimeType = UA_PUBSUB_ENCODING_UADP; + } else if(writerGroupParameters->messageSettings.content.decoded.type == + &UA_TYPES[UA_TYPES_JSONWRITERGROUPMESSAGEDATATYPE]) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_setWriterGroupEncodingType] " + "encoding type: JSON (not implemented!)"); + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } else { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_setWriterGroupEncodingType] " + "invalid message encoding type"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + return UA_STATUSCODE_GOOD; +} + +/* WriterGroup configuration from WriterGroup object + * + * @param server Server object that shall be configured + * @param writerGroupParameters WriterGroup configuration + * @param connectionIdent NodeId of the PubSub connection, the WriterGroup belongs to + * @param pdsCount Number of published DataSets + * @param pdsIdent Array of NodeIds of the published DataSets */ +static UA_StatusCode +createWriterGroup(UA_Server *server, + const UA_WriterGroupDataType *writerGroupParameters, + UA_NodeId connectionIdent, UA_UInt32 pdsCount, + const UA_NodeId *pdsIdent) { + UA_WriterGroupConfig config; + memset(&config, 0, sizeof(UA_WriterGroupConfig)); + config.name = writerGroupParameters->name; + config.enabled = writerGroupParameters->enabled; + config.writerGroupId = writerGroupParameters->writerGroupId; + config.publishingInterval = writerGroupParameters->publishingInterval; + config.keepAliveTime = writerGroupParameters->keepAliveTime; + config.priority = writerGroupParameters->priority; + config.securityMode = writerGroupParameters->securityMode; + config.transportSettings = writerGroupParameters->transportSettings; + config.messageSettings = writerGroupParameters->messageSettings; + config.groupPropertiesSize = writerGroupParameters->groupPropertiesSize; + if(config.groupPropertiesSize > 0) + config.groupProperties = writerGroupParameters->groupProperties; + + config.maxEncapsulatedDataSetMessageCount = 255; /* non std parameter */ + + UA_StatusCode res = setWriterGroupEncodingType(writerGroupParameters, &config); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createWriterGroup] " + "Setting message settings failed"); + return res; + } + + /* Load config into server: */ + UA_NodeId writerGroupIdent; + res = UA_Server_addWriterGroup(server, connectionIdent, &config, &writerGroupIdent); + UA_Server_setWriterGroupOperational(server, writerGroupIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createWriterGroup] " + "Adding WriterGroup to server failed: 0x%x", res); + return res; + } + + /* Configuration of all DataSetWriters that belong to this WriterGroup */ + for(size_t dsw = 0; dsw < writerGroupParameters->dataSetWritersSize; dsw++) { + res = createDataSetWriter(server, &writerGroupParameters->dataSetWriters[dsw], + writerGroupIdent, pdsCount, pdsIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createWriterGroup] " + "DataSetWriter Creation failed."); + break; + } + } + return res; +} + +/* Function called by UA_PubSubManager_createDataSetWriter. It searches for a + * PublishedDataSet that is referenced by the DataSetWriter. If a related PDS is found, + * the DSWriter will be added to the server, otherwise, no DSWriter will be added. + * + * @param server UA_Server object that shall be configured + * @param writerGroupIdent NodeId of writerGroup, the DataSetWriter belongs to + * @param dsWriterConfig WriterGroup configuration + * @param pdsCount Number of published DataSets + * @param pdsIdent Array of NodeIds of the published DataSets */ +static UA_StatusCode +addDataSetWriterWithPdsReference(UA_Server *server, UA_NodeId writerGroupIdent, + const UA_DataSetWriterConfig *dsWriterConfig, + UA_UInt32 pdsCount, const UA_NodeId *pdsIdent) { + UA_NodeId dataSetWriterIdent; + UA_PublishedDataSetConfig pdsConfig; + UA_Boolean pdsFound = false; + + UA_StatusCode res = UA_STATUSCODE_GOOD; + for(size_t pds = 0; pds < pdsCount && res == UA_STATUSCODE_GOOD; pds++) { + res = UA_Server_getPublishedDataSetConfig(server, pdsIdent[pds], &pdsConfig); + /* members of pdsConfig must be deleted manually */ + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_addDataSetWriterWithPdsReference] " + "Getting pdsConfig from NodeId failed."); + return res; + } + + if(dsWriterConfig->dataSetName.length == pdsConfig.name.length && + 0 == strncmp((const char *)dsWriterConfig->dataSetName.data, + (const char *)pdsConfig.name.data, + dsWriterConfig->dataSetName.length)) { + /* DSWriter will only be created, if a matching PDS is found: */ + res = UA_Server_addDataSetWriter(server, writerGroupIdent, pdsIdent[pds], + dsWriterConfig, &dataSetWriterIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_addDataSetWriterWithPdsReference] " + "Adding DataSetWriter failed"); + } else { + pdsFound = true; + } + + UA_PublishedDataSetConfig_clear(&pdsConfig); + if(pdsFound) + break; /* break loop if corresponding publishedDataSet was found */ + } + } + + if(!pdsFound) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_addDataSetWriterWithPdsReference] " + "No matching DataSet found; no DataSetWriter created"); + } + + return res; +} + +/* Creates DataSetWriter configuration from DataSetWriter object + * + * @param server UA_Server object that shall be configured + * @param dataSetWriterParameters DataSetWriter Configuration + * @param writerGroupIdent NodeId of writerGroup, the DataSetWriter belongs to + * @param pdsCount Number of published DataSets + * @param pdsIdent Array of NodeIds of the published DataSets */ +static UA_StatusCode +createDataSetWriter(UA_Server *server, + const UA_DataSetWriterDataType *dataSetWriterParameters, + UA_NodeId writerGroupIdent, UA_UInt32 pdsCount, + const UA_NodeId *pdsIdent) { + UA_DataSetWriterConfig config; + memset(&config, 0, sizeof(UA_DataSetWriterConfig)); + config.name = dataSetWriterParameters->name; + config.dataSetWriterId = dataSetWriterParameters->dataSetWriterId; + config.keyFrameCount = dataSetWriterParameters->keyFrameCount; + config.dataSetFieldContentMask = dataSetWriterParameters->dataSetFieldContentMask; + config.messageSettings = dataSetWriterParameters->messageSettings; + config.dataSetName = dataSetWriterParameters->dataSetName; + config.dataSetWriterPropertiesSize = dataSetWriterParameters->dataSetWriterPropertiesSize; + if(config.dataSetWriterPropertiesSize > 0) + config.dataSetWriterProperties = dataSetWriterParameters->dataSetWriterProperties; + + UA_StatusCode res = addDataSetWriterWithPdsReference(server, writerGroupIdent, + &config, pdsCount, pdsIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createDataSetWriter] " + "Referencing related PDS failed"); + } + + return res; +} + +/* Creates ReaderGroup configuration from ReaderGroup object + * + * @param server UA_Server object that shall be configured + * @param readerGroupParameters ReaderGroup configuration + * @param connectionIdent NodeId of the PubSub connection, the ReaderGroup belongs to */ +static UA_StatusCode +createReaderGroup(UA_Server *server, + const UA_ReaderGroupDataType *readerGroupParameters, + UA_NodeId connectionIdent) { + UA_ReaderGroupConfig config; + memset(&config, 0, sizeof(UA_ReaderGroupConfig)); + + config.name = readerGroupParameters->name; + config.securityParameters.securityMode = readerGroupParameters->securityMode; + + UA_NodeId readerGroupIdent; + UA_StatusCode res = + UA_Server_addReaderGroup(server, connectionIdent, &config, &readerGroupIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createReaderGroup] Adding ReaderGroup " + "to server failed: 0x%x", res); + return res; + } + + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createReaderGroup] ReaderGroup successfully added."); + for(UA_UInt32 i = 0; i < readerGroupParameters->dataSetReadersSize; i++) { + res = createDataSetReader(server, &readerGroupParameters->dataSetReaders[i], + readerGroupIdent); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createReaderGroup] Creating DataSetReader failed"); + break; + } + } + + if(res == UA_STATUSCODE_GOOD) + UA_Server_setReaderGroupOperational(server, readerGroupIdent); + + return res; +} + +/* Creates TargetVariables or SubscribedDataSetMirror for a given DataSetReader + * + * @param server UA_Server object that shall be configured + * @param dsReaderIdent NodeId of the DataSetReader the SubscribedDataSet belongs to + * @param dataSetReaderParameters Configuration Parameters of the DataSetReader */ +static UA_StatusCode +addSubscribedDataSet(UA_Server *server, const UA_NodeId dsReaderIdent, + const UA_ExtensionObject *subscribedDataSet) { + if(subscribedDataSet->content.decoded.type == + &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]) { + UA_TargetVariablesDataType *tmpTargetVars = (UA_TargetVariablesDataType*) + subscribedDataSet->content.decoded.data; + UA_FieldTargetVariable *targetVars = (UA_FieldTargetVariable *) + UA_calloc(tmpTargetVars->targetVariablesSize, sizeof(UA_FieldTargetVariable)); + + for(size_t index = 0; index < tmpTargetVars->targetVariablesSize; index++) { + UA_FieldTargetDataType_copy(&tmpTargetVars->targetVariables[index], + &targetVars[index].targetVariable); + } + + UA_StatusCode res = + UA_Server_DataSetReader_createTargetVariables(server, dsReaderIdent, + tmpTargetVars->targetVariablesSize, + targetVars); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_addSubscribedDataSet] " + "create TargetVariables failed"); + } + + for(size_t index = 0; index < tmpTargetVars->targetVariablesSize; index++) { + UA_FieldTargetDataType_clear(&targetVars[index].targetVariable); + } + + UA_free(targetVars); + return res; + } + + if(subscribedDataSet->content.decoded.type == + &UA_TYPES[UA_TYPES_SUBSCRIBEDDATASETMIRRORDATATYPE]) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_addSubscribedDataSet] " + "DataSetMirror is currently not supported"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_addSubscribedDataSet] " + "Invalid Type of SubscribedDataSet"); + return UA_STATUSCODE_BADINTERNALERROR; +} + +/* Creates DataSetReader configuration from DataSetReader object + * + * @param server UA_Server object that shall be configured + * @param dataSetReaderParameters DataSetReader configuration + * @param writerGroupIdent NodeId of readerGroupParameters, the DataSetReader belongs to */ +static UA_StatusCode +createDataSetReader(UA_Server *server, const UA_DataSetReaderDataType *dsrParams, + UA_NodeId readerGroupIdent) { + UA_DataSetReaderConfig config; + memset(&config, 0, sizeof(UA_DataSetReaderConfig)); + + config.name = dsrParams->name; + config.publisherId = dsrParams->publisherId; + config.writerGroupId = dsrParams->writerGroupId; + config.dataSetWriterId = dsrParams->dataSetWriterId; + config.dataSetMetaData = dsrParams->dataSetMetaData; + config.dataSetFieldContentMask = dsrParams->dataSetFieldContentMask; + config.messageReceiveTimeout = dsrParams->messageReceiveTimeout; + config.messageSettings = dsrParams->messageSettings; + + UA_NodeId dsReaderIdent; + UA_StatusCode res = UA_Server_addDataSetReader(server, readerGroupIdent, + &config, &dsReaderIdent); + if(res == UA_STATUSCODE_GOOD) + res = addSubscribedDataSet(server, dsReaderIdent, + &dsrParams->subscribedDataSet); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createDataSetReader] " + "create subscribedDataSet failed"); + } + + return res; +} + +/* Determines whether PublishedDataSet is of type PublishedItems or PublishedEvents. + * (PublishedEvents are currently not supported!) + * + * @param publishedDataSetParameters PublishedDataSet parameters + * @param config PublishedDataSet configuration object */ +static UA_StatusCode +setPublishedDataSetType(const UA_PublishedDataSetDataType *pdsParams, + UA_PublishedDataSetConfig *config) { + if(pdsParams->dataSetSource.encoding != UA_EXTENSIONOBJECT_DECODED) + return UA_STATUSCODE_BADINTERNALERROR; + + const UA_DataType *sourceType = pdsParams->dataSetSource.content.decoded.type; + if(sourceType == &UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]) { + config->publishedDataSetType = UA_PUBSUB_DATASET_PUBLISHEDITEMS; + return UA_STATUSCODE_GOOD; + } else if(sourceType == &UA_TYPES[UA_TYPES_PUBLISHEDEVENTSDATATYPE]) { + /* config.publishedDataSetType = UA_PUBSUB_DATASET_PUBLISHEDEVENTS; */ + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_setPublishedDataSetType] Published events not supported."); + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_setPublishedDataSetType] Invalid DataSetSourceDataType."); + return UA_STATUSCODE_BADINTERNALERROR; +} + +/* Creates PublishedDataSetConfig object from PublishedDataSet object + * + * @param server UA_Server object that shall be configured + * @param pdsParams publishedDataSet configuration + * @param pdsIdent NodeId of the publishedDataSet */ +static UA_StatusCode +createPublishedDataSet(UA_Server *server, + const UA_PublishedDataSetDataType *pdsParams, + UA_NodeId *pdsIdent) { + UA_PublishedDataSetConfig config; + memset(&config, 0, sizeof(UA_PublishedDataSetConfig)); + + config.name = pdsParams->name; + UA_StatusCode res = setPublishedDataSetType(pdsParams, &config); + if(res != UA_STATUSCODE_GOOD) + return res; + + res = UA_Server_addPublishedDataSet(server, &config, pdsIdent).addResult; + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createPublishedDataSet] " + "Adding PublishedDataSet failed."); + return res; + } + + /* DataSetField configuration for this publishedDataSet: */ + res = createDataSetFields(server, pdsIdent, pdsParams); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createPublishedDataSet] " + "Creating DataSetFieldConfig failed."); + } + + return res; +} + +/* Adds DataSetField Variables bound to a certain PublishedDataSet. This method does NOT + * check, whether the PublishedDataSet actually contains Variables instead of Events! + * + * @param server UA_Server object that shall be configured + * @param pdsIdent NodeId of the publishedDataSet, the DataSetField belongs to + * @param publishedDataSetParameters publishedDataSet configuration */ +static UA_StatusCode +addDataSetFieldVariables(UA_Server *server, const UA_NodeId *pdsIdent, + const UA_PublishedDataSetDataType *pdsParams) { + UA_PublishedDataItemsDataType *pdItems = (UA_PublishedDataItemsDataType *) + pdsParams->dataSetSource.content.decoded.data; + if(pdItems->publishedDataSize != pdsParams->dataSetMetaData.fieldsSize) + return UA_STATUSCODE_BADINTERNALERROR; + + for(size_t i = 0; i < pdItems->publishedDataSize; i++) { + UA_DataSetFieldConfig fc; + memset(&fc, 0, sizeof(UA_DataSetFieldConfig)); + fc.dataSetFieldType = UA_PUBSUB_DATASETFIELD_VARIABLE; + fc.field.variable.configurationVersion = pdsParams->dataSetMetaData.configurationVersion; + fc.field.variable.fieldNameAlias = pdsParams->dataSetMetaData.fields[i].name; + fc.field.variable.promotedField = pdsParams->dataSetMetaData. + fields[i].fieldFlags & 0x0001; + fc.field.variable.publishParameters = pdItems->publishedData[i]; + + UA_NodeId fieldIdent; + UA_StatusCode res = UA_Server_addDataSetField(server, *pdsIdent, &fc, &fieldIdent).result; + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_addDataSetFieldVariables] " + "Adding DataSetField Variable failed."); + return res; + } + } + + return UA_STATUSCODE_GOOD; +} + +/* Checks if PublishedDataSet contains event or variable fields and calls the + * corresponding method to add these fields to the server. + * + * @param server UA_Server object that shall be configured + * @param pdsIdent NodeId of the publishedDataSet, the DataSetFields belongs to + * @param pdsParams publishedDataSet configuration */ +static UA_StatusCode +createDataSetFields(UA_Server *server, const UA_NodeId *pdsIdent, + const UA_PublishedDataSetDataType *pdsParams) { + if(pdsParams->dataSetSource.encoding != UA_EXTENSIONOBJECT_DECODED) + return UA_STATUSCODE_BADINTERNALERROR; + + if(pdsParams->dataSetSource.content.decoded.type == + &UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]) + return addDataSetFieldVariables(server, pdsIdent, pdsParams); + + /* TODO: Implement Routine for adding Event DataSetFields */ + if(pdsParams->dataSetSource.content.decoded.type == + &UA_TYPES[UA_TYPES_PUBLISHEDEVENTSDATATYPE]) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createDataSetFields] " + "Published events not supported."); + return UA_STATUSCODE_BADNOTIMPLEMENTED; + } + + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_createDataSetFields] " + "Invalid DataSetSourceDataType."); + return UA_STATUSCODE_BADINTERNALERROR; +} + +UA_StatusCode +UA_PubSubManager_loadPubSubConfigFromByteString(UA_Server *server, + const UA_ByteString buffer) { + size_t offset = 0; + UA_ExtensionObject decodedFile; + UA_StatusCode res = UA_ExtensionObject_decodeBinary(&buffer, &offset, &decodedFile); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_decodeBinFile] decoding UA_Binary failed"); + goto cleanup; + } + + UA_PubSubConfigurationDataType *pubSubConfig = NULL; + res = extractPubSubConfigFromExtensionObject(&decodedFile, &pubSubConfig); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_loadPubSubConfigFromByteString] " + "Extracting PubSub Configuration failed"); + goto cleanup; + } + + res = updatePubSubConfig(server, pubSubConfig); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_loadPubSubConfigFromByteString] " + "Loading PubSub configuration into server failed"); + goto cleanup; + } + + cleanup: + UA_ExtensionObject_clear(&decodedFile); + return res; +} + +/* Encodes a PubSubConfigurationDataType object as ByteString using the UA Binary Data + * Encoding */ +static UA_StatusCode +encodePubSubConfiguration(UA_PubSubConfigurationDataType *configurationParameters, + UA_ByteString *buffer) { + UA_UABinaryFileDataType binFile; + memset(&binFile, 0, sizeof(UA_UABinaryFileDataType)); + /*Perhaps, additional initializations of binFile are necessary here.*/ + + UA_Variant_setScalar(&binFile.body, configurationParameters, + &UA_TYPES[UA_TYPES_PUBSUBCONFIGURATIONDATATYPE]); + + UA_ExtensionObject container; + memset(&container, 0, sizeof(UA_ExtensionObject)); + container.encoding = UA_EXTENSIONOBJECT_DECODED; + container.content.decoded.type = &UA_TYPES[UA_TYPES_UABINARYFILEDATATYPE]; + container.content.decoded.data = &binFile; + + size_t fileSize = UA_ExtensionObject_calcSizeBinary(&container); + buffer->data = (UA_Byte*)UA_calloc(fileSize, sizeof(UA_Byte)); + if(buffer->data == NULL) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_encodePubSubConfiguration] Allocating buffer failed"); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + buffer->length = fileSize; + + UA_Byte *bufferPos = buffer->data; + UA_StatusCode res = + UA_ExtensionObject_encodeBinary(&container, &bufferPos, bufferPos + fileSize); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_encodePubSubConfiguration] Encoding failed"); + } + return res; +} + +static UA_StatusCode +generatePublishedDataSetDataType(const UA_PublishedDataSet *src, + UA_PublishedDataSetDataType *dst) { + if(src->config.publishedDataSetType != UA_PUBSUB_DATASET_PUBLISHEDITEMS) + return UA_STATUSCODE_BADNOTIMPLEMENTED; + + memset(dst, 0, sizeof(UA_PublishedDataSetDataType)); + + UA_PublishedDataItemsDataType *tmp = UA_PublishedDataItemsDataType_new(); + UA_String_copy(&src->config.name, &dst->name); + dst->dataSetMetaData.fieldsSize = src->fieldSize; + + size_t index = 0; + tmp->publishedDataSize = src->fieldSize; + tmp->publishedData = (UA_PublishedVariableDataType*) + UA_Array_new(tmp->publishedDataSize, &UA_TYPES[UA_TYPES_PUBLISHEDVARIABLEDATATYPE]); + if(tmp->publishedData == NULL) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Allocation memory failed"); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + dst->dataSetMetaData.fields = (UA_FieldMetaData*) + UA_Array_new(dst->dataSetMetaData.fieldsSize, &UA_TYPES[UA_TYPES_FIELDMETADATA]); + if(dst->dataSetMetaData.fields == NULL) { + UA_free(tmp->publishedData); + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Allocation memory failed"); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_DataSetField *dsf, *dsf_tmp = NULL; + TAILQ_FOREACH_SAFE(dsf ,&src->fields, listEntry, dsf_tmp) { + UA_String_copy(&dsf->config.field.variable.fieldNameAlias, + &dst->dataSetMetaData.fields[index].name); + UA_PublishedVariableDataType_copy(&dsf->config.field.variable.publishParameters, + &tmp->publishedData[index]); + UA_ConfigurationVersionDataType_copy(&dsf->config.field.variable.configurationVersion, + &dst->dataSetMetaData.configurationVersion); + dst->dataSetMetaData.fields[index].fieldFlags = + dsf->config.field.variable.promotedField; + index++; + } + UA_ExtensionObject_setValue(&dst->dataSetSource, tmp, + &UA_TYPES[UA_TYPES_PUBLISHEDDATAITEMSDATATYPE]); + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +generateDataSetWriterDataType(const UA_DataSetWriter *src, + UA_DataSetWriterDataType *dst) { + memset(dst, 0, sizeof(UA_DataSetWriterDataType)); + + UA_String_copy(&src->config.name, &dst->name); + dst->dataSetWriterId = src->config.dataSetWriterId; + dst->keyFrameCount = src->config.keyFrameCount; + dst->dataSetFieldContentMask = src->config.dataSetFieldContentMask; + UA_ExtensionObject_copy(&src->config.messageSettings, &dst->messageSettings); + UA_String_copy(&src->config.dataSetName, &dst->dataSetName); + + dst->dataSetWriterPropertiesSize = src->config.dataSetWriterPropertiesSize; + for(size_t i = 0; i < src->config.dataSetWriterPropertiesSize; i++) { + UA_KeyValuePair_copy(&src->config.dataSetWriterProperties[i], + &dst->dataSetWriterProperties[i]); + } + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +generateWriterGroupDataType(const UA_WriterGroup *src, + UA_WriterGroupDataType *dst) { + memset(dst, 0, sizeof(UA_WriterGroupDataType)); + + UA_String_copy(&src->config.name, &dst->name); + dst->enabled = src->config.enabled; + dst->writerGroupId = src->config.writerGroupId; + dst->publishingInterval = src->config.publishingInterval; + dst->keepAliveTime = src->config.keepAliveTime; + dst->priority = src->config.priority; + dst->securityMode = src->config.securityMode; + + UA_ExtensionObject_copy(&src->config.transportSettings, &dst->transportSettings); + UA_ExtensionObject_copy(&src->config.messageSettings, &dst->messageSettings); + + dst->groupPropertiesSize = src->config.groupPropertiesSize; + dst->groupProperties = (UA_KeyValuePair*) + UA_Array_new(dst->groupPropertiesSize, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); + for(size_t index = 0; index < dst->groupPropertiesSize; index++) { + UA_KeyValuePair_copy(&src->config.groupProperties[index], + &dst->groupProperties[index]); + } + + dst->dataSetWriters = (UA_DataSetWriterDataType*) + UA_calloc(src->writersCount, sizeof(UA_DataSetWriterDataType)); + if(!dst->dataSetWriters) + return UA_STATUSCODE_BADOUTOFMEMORY; + + dst->dataSetWritersSize = src->writersCount; + + UA_DataSetWriter *dsw; + size_t dsWriterIndex = 0; + LIST_FOREACH(dsw, &src->writers, listEntry) { + UA_StatusCode res = + generateDataSetWriterDataType(dsw, &dst->dataSetWriters[dsWriterIndex]); + if(res != UA_STATUSCODE_GOOD) + return res; + dsWriterIndex++; + } + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +generateDataSetReaderDataType(const UA_DataSetReader *src, + UA_DataSetReaderDataType *dst) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + memset(dst, 0, sizeof(UA_DataSetReaderDataType)); + dst->writerGroupId = src->config.writerGroupId; + dst->dataSetWriterId = src->config.dataSetWriterId; + dst->dataSetFieldContentMask = src->config.dataSetFieldContentMask; + dst->messageReceiveTimeout = src->config.messageReceiveTimeout; + res |= UA_String_copy(&src->config.name, &dst->name); + res |= UA_Variant_copy(&src->config.publisherId, &dst->publisherId); + res |= UA_DataSetMetaDataType_copy(&src->config.dataSetMetaData, + &dst->dataSetMetaData); + res |= UA_ExtensionObject_copy(&src->config.messageSettings, &dst->messageSettings); + + UA_TargetVariablesDataType *tmpTarget = UA_TargetVariablesDataType_new(); + if(!tmpTarget) + return UA_STATUSCODE_BADOUTOFMEMORY; + UA_ExtensionObject_setValue(&dst->subscribedDataSet, tmpTarget, + &UA_TYPES[UA_TYPES_TARGETVARIABLESDATATYPE]); + + const UA_TargetVariables *targets = + &src->config.subscribedDataSet.subscribedDataSetTarget; + tmpTarget->targetVariables = (UA_FieldTargetDataType *) + UA_calloc(targets->targetVariablesSize, sizeof(UA_FieldTargetDataType)); + if(!tmpTarget->targetVariables) + return UA_STATUSCODE_BADOUTOFMEMORY; + tmpTarget->targetVariablesSize = targets->targetVariablesSize; + + for(size_t i = 0; i < tmpTarget->targetVariablesSize; i++) { + res |= UA_FieldTargetDataType_copy(&targets->targetVariables[i].targetVariable, + &tmpTarget->targetVariables[i]); + } + + return res; +} + +static UA_StatusCode +generateReaderGroupDataType(const UA_ReaderGroup *src, + UA_ReaderGroupDataType *dst) { + memset(dst, 0, sizeof(UA_ReaderGroupDataType)); + + UA_String_copy(&src->config.name, &dst->name); + dst->dataSetReaders = (UA_DataSetReaderDataType*) + UA_calloc(src->readersCount, sizeof(UA_DataSetReaderDataType)); + if(dst->dataSetReaders == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + dst->dataSetReadersSize = src->readersCount; + + size_t i = 0; + UA_DataSetReader *dsr, *dsr_tmp = NULL; + LIST_FOREACH_SAFE(dsr, &src->readers, listEntry, dsr_tmp) { + UA_StatusCode res = + generateDataSetReaderDataType(dsr, &dst->dataSetReaders[i]); + if(res != UA_STATUSCODE_GOOD) + return res; + i++; + } + + return UA_STATUSCODE_GOOD; +} + +/* Generates a PubSubConnectionDataType object from a PubSubConnection. */ +static UA_StatusCode +generatePubSubConnectionDataType(const UA_PubSubConnection *src, + UA_PubSubConnectionDataType *dst) { + memset(dst, 0, sizeof(UA_PubSubConnectionDataType)); + + UA_String_copy(&src->config->name, &dst->name); + UA_String_copy(&src->config->transportProfileUri, &dst->transportProfileUri); + dst->enabled = src->config->enabled; + + dst->connectionPropertiesSize = src->config->connectionPropertiesSize; + for(size_t i = 0; i < src->config->connectionPropertiesSize; i++) { + UA_KeyValuePair_copy(&src->config->connectionProperties[i], + &dst->connectionProperties[i]); + } + + if(src->config->publisherIdType == UA_PUBSUB_PUBLISHERID_NUMERIC) { + UA_Variant_setScalarCopy(&dst->publisherId, + &src->config->publisherId.numeric, + &UA_TYPES[UA_TYPES_UINT32]); + } else if(src->config->publisherIdType == UA_PUBSUB_PUBLISHERID_STRING) { + UA_Variant_setScalarCopy(&dst->publisherId, + &src->config->publisherId.string, + &UA_TYPES[UA_TYPES_STRING]); + } + + /* Possibly, array size and dimensions of src->config->address and + * src->config->connectionTransportSettings should be checked beforehand. */ + dst->address.encoding = UA_EXTENSIONOBJECT_DECODED; + dst->address.content.decoded.type = src->config->address.type; + UA_StatusCode res = + UA_Array_copy(src->config->address.data, 1, + &dst->address.content.decoded.data, src->config->address.type); + if(res != UA_STATUSCODE_GOOD) + return res; + + if(src->config->connectionTransportSettings.data) { + dst->transportSettings.encoding = UA_EXTENSIONOBJECT_DECODED; + dst->transportSettings.content.decoded.type = + src->config->connectionTransportSettings.type; + res = UA_Array_copy(src->config->connectionTransportSettings.data, 1, + &dst->transportSettings.content.decoded.data, + src->config->connectionTransportSettings.type); + + if(res != UA_STATUSCODE_GOOD) + return res; + } + + dst->writerGroups = (UA_WriterGroupDataType*) + UA_calloc(src->writerGroupsSize, sizeof(UA_WriterGroupDataType)); + if(dst->writerGroups == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + dst->writerGroupsSize = src->writerGroupsSize; + UA_WriterGroup *wg, *wg_tmp = NULL; + size_t wgIndex = 0; + LIST_FOREACH_SAFE(wg ,&src->writerGroups, listEntry, wg_tmp) { + res = generateWriterGroupDataType(wg, &dst->writerGroups[wgIndex]); + if(res != UA_STATUSCODE_GOOD) + return res; + wgIndex++; + } + + dst->readerGroups = (UA_ReaderGroupDataType*) + UA_calloc(src->readerGroupsSize, sizeof(UA_ReaderGroupDataType)); + if(dst->readerGroups == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + dst->readerGroupsSize = src->readerGroupsSize; + UA_ReaderGroup *rg = NULL; + size_t rgIndex = 0; + LIST_FOREACH(rg, &src->readerGroups, listEntry) { + res = generateReaderGroupDataType(rg, &dst->readerGroups[rgIndex]); + if(res != UA_STATUSCODE_GOOD) + return res; + rgIndex++; + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +generatePubSubConfigurationDataType(const UA_Server* server, + UA_PubSubConfigurationDataType *configDT) { + UA_StatusCode res = UA_STATUSCODE_GOOD; + const UA_PubSubManager *manager = &server->pubSubManager; + memset(configDT, 0, sizeof(UA_PubSubConfigurationDataType)); + + configDT->publishedDataSets = (UA_PublishedDataSetDataType*) + UA_calloc(manager->publishedDataSetsSize, + sizeof(UA_PublishedDataSetDataType)); + if(configDT->publishedDataSets == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + configDT->publishedDataSetsSize = manager->publishedDataSetsSize; + + UA_PublishedDataSet *pds; + UA_UInt32 pdsIndex = 0; + TAILQ_FOREACH(pds, &manager->publishedDataSets, listEntry) { + UA_PublishedDataSetDataType *dst = &configDT->publishedDataSets[pdsIndex]; + res = generatePublishedDataSetDataType(pds, dst); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_generatePubSubConfigurationDataType] " + "retrieving PublishedDataSet configuration failed"); + return res; + } + pdsIndex++; + } + + configDT->connections = (UA_PubSubConnectionDataType*) + UA_calloc(manager->connectionsSize, sizeof(UA_PubSubConnectionDataType)); + if(configDT->connections == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + configDT->connectionsSize = manager->connectionsSize; + + UA_UInt32 connectionIndex = 0; + UA_PubSubConnection *connection; + TAILQ_FOREACH(connection, &manager->connections, listEntry) { + UA_PubSubConnectionDataType *cdt = &configDT->connections[connectionIndex]; + res = generatePubSubConnectionDataType(connection, cdt); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "[UA_PubSubManager_generatePubSubConfigurationDataType] " + "retrieving PubSubConnection configuration failed"); + return res; + } + connectionIndex++; + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_PubSubManager_getEncodedPubSubConfiguration(UA_Server *server, + UA_ByteString *buffer) { + UA_PubSubConfigurationDataType config; + memset(&config, 0, sizeof(UA_PubSubConfigurationDataType)); + + UA_StatusCode res = generatePubSubConfigurationDataType(server, &config); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "retrieving PubSub configuration from server failed"); + goto cleanup; + } + + res = encodePubSubConfiguration(&config, buffer); + if(res != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "encoding PubSub configuration failed"); + goto cleanup; + } + + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Saving PubSub config was successful"); + + cleanup: + UA_PubSubConfigurationDataType_clear(&config); + return res; +} + +#endif /* UA_ENABLE_PUBSUB_FILE_CONFIG */ + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/namespace0_generated.c" ****/ + +/* WARNING: This is a generated file. + * Any manual changes will be overwritten. */ + + + +/* HasAddIn - ns=0;i=17604 */ + +static UA_StatusCode function_namespace0_generated_0_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ReferenceTypeAttributes attr = UA_ReferenceTypeAttributes_default; +attr.inverseName = UA_LOCALIZEDTEXT("", "AddInOf"); +attr.displayName = UA_LOCALIZEDTEXT("", "HasAddIn"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_REFERENCETYPE, +UA_NODEID_NUMERIC(ns[0], 17604LU), +UA_NODEID_NUMERIC(ns[0], 32LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "HasAddIn"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_0_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 17604LU) +); +} + +/* HasHistoricalConfiguration - ns=0;i=56 */ + +static UA_StatusCode function_namespace0_generated_1_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ReferenceTypeAttributes attr = UA_ReferenceTypeAttributes_default; +attr.inverseName = UA_LOCALIZEDTEXT("", "HistoricalConfigurationOf"); +attr.displayName = UA_LOCALIZEDTEXT("", "HasHistoricalConfiguration"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_REFERENCETYPE, +UA_NODEID_NUMERIC(ns[0], 56LU), +UA_NODEID_NUMERIC(ns[0], 44LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "HasHistoricalConfiguration"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_1_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 56LU) +); +} + +/* HasEffect - ns=0;i=54 */ + +static UA_StatusCode function_namespace0_generated_2_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ReferenceTypeAttributes attr = UA_ReferenceTypeAttributes_default; +attr.inverseName = UA_LOCALIZEDTEXT("", "MayBeEffectedBy"); +attr.displayName = UA_LOCALIZEDTEXT("", "HasEffect"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_REFERENCETYPE, +UA_NODEID_NUMERIC(ns[0], 54LU), +UA_NODEID_NUMERIC(ns[0], 32LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "HasEffect"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_2_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 54LU) +); +} + +/* HasCause - ns=0;i=53 */ + +static UA_StatusCode function_namespace0_generated_3_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ReferenceTypeAttributes attr = UA_ReferenceTypeAttributes_default; +attr.inverseName = UA_LOCALIZEDTEXT("", "MayBeCausedBy"); +attr.displayName = UA_LOCALIZEDTEXT("", "HasCause"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_REFERENCETYPE, +UA_NODEID_NUMERIC(ns[0], 53LU), +UA_NODEID_NUMERIC(ns[0], 32LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "HasCause"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_3_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 53LU) +); +} + +/* ToState - ns=0;i=52 */ + +static UA_StatusCode function_namespace0_generated_4_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ReferenceTypeAttributes attr = UA_ReferenceTypeAttributes_default; +attr.inverseName = UA_LOCALIZEDTEXT("", "FromTransition"); +attr.displayName = UA_LOCALIZEDTEXT("", "ToState"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_REFERENCETYPE, +UA_NODEID_NUMERIC(ns[0], 52LU), +UA_NODEID_NUMERIC(ns[0], 32LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ToState"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_4_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 52LU) +); +} + +/* FromState - ns=0;i=51 */ + +static UA_StatusCode function_namespace0_generated_5_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ReferenceTypeAttributes attr = UA_ReferenceTypeAttributes_default; +attr.inverseName = UA_LOCALIZEDTEXT("", "ToTransition"); +attr.displayName = UA_LOCALIZEDTEXT("", "FromState"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_REFERENCETYPE, +UA_NODEID_NUMERIC(ns[0], 51LU), +UA_NODEID_NUMERIC(ns[0], 32LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "FromState"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_5_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 51LU) +); +} + +/* DiagnosticInfo - ns=0;i=25 */ + +static UA_StatusCode function_namespace0_generated_6_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "DiagnosticInfo"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 25LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DiagnosticInfo"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_6_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 25LU) +); +} + +/* DataValue - ns=0;i=23 */ + +static UA_StatusCode function_namespace0_generated_7_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "DataValue"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 23LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DataValue"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_7_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 23LU) +); +} + +/* Structure - ns=0;i=22 */ + +static UA_StatusCode function_namespace0_generated_8_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "Structure"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Structure"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_8_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 22LU) +); +} + +/* TimeZoneDataType - ns=0;i=8912 */ + +static UA_StatusCode function_namespace0_generated_9_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "TimeZoneDataType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 8912LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "TimeZoneDataType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_9_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 8912LU) +); +} + +/* EUInformation - ns=0;i=887 */ + +static UA_StatusCode function_namespace0_generated_10_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "EUInformation"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 887LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "EUInformation"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_10_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 887LU) +); +} + +/* Range - ns=0;i=884 */ + +static UA_StatusCode function_namespace0_generated_11_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Range"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 884LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Range"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_11_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 884LU) +); +} + +/* ServerStatusDataType - ns=0;i=862 */ + +static UA_StatusCode function_namespace0_generated_12_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerStatusDataType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 862LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerStatusDataType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_12_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 862LU) +); +} + +/* ServerDiagnosticsSummaryDataType - ns=0;i=859 */ + +static UA_StatusCode function_namespace0_generated_13_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerDiagnosticsSummaryDataType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 859LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerDiagnosticsSummaryDataType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_13_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 859LU) +); +} + +/* EnumValueType - ns=0;i=7594 */ + +static UA_StatusCode function_namespace0_generated_14_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "EnumValueType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 7594LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "EnumValueType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_14_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 7594LU) +); +} + +/* SignedSoftwareCertificate - ns=0;i=344 */ + +static UA_StatusCode function_namespace0_generated_15_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "SignedSoftwareCertificate"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 344LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "SignedSoftwareCertificate"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_15_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 344LU) +); +} + +/* BuildInfo - ns=0;i=338 */ + +static UA_StatusCode function_namespace0_generated_16_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "BuildInfo"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 338LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "BuildInfo"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_16_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 338LU) +); +} + +/* Argument - ns=0;i=296 */ + +static UA_StatusCode function_namespace0_generated_17_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Argument"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 296LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Argument"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_17_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 296LU) +); +} + +/* Union - ns=0;i=12756 */ + +static UA_StatusCode function_namespace0_generated_18_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "Union"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 12756LU), +UA_NODEID_NUMERIC(ns[0], 22LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Union"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_18_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 12756LU) +); +} + +/* LocalizedText - ns=0;i=21 */ + +static UA_StatusCode function_namespace0_generated_19_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "LocalizedText"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 21LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "LocalizedText"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_19_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 21LU) +); +} + +/* QualifiedName - ns=0;i=20 */ + +static UA_StatusCode function_namespace0_generated_20_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "QualifiedName"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 20LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "QualifiedName"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_20_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 20LU) +); +} + +/* StatusCode - ns=0;i=19 */ + +static UA_StatusCode function_namespace0_generated_21_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "StatusCode"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 19LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "StatusCode"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_21_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 19LU) +); +} + +/* ExpandedNodeId - ns=0;i=18 */ + +static UA_StatusCode function_namespace0_generated_22_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ExpandedNodeId"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 18LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ExpandedNodeId"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_22_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 18LU) +); +} + +/* NodeId - ns=0;i=17 */ + +static UA_StatusCode function_namespace0_generated_23_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "NodeId"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 17LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "NodeId"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_23_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 17LU) +); +} + +/* XmlElement - ns=0;i=16 */ + +static UA_StatusCode function_namespace0_generated_24_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "XmlElement"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 16LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "XmlElement"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_24_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 16LU) +); +} + +/* ByteString - ns=0;i=15 */ + +static UA_StatusCode function_namespace0_generated_25_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ByteString"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 15LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ByteString"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_25_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 15LU) +); +} + +/* Image - ns=0;i=30 */ + +static UA_StatusCode function_namespace0_generated_26_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "Image"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 30LU), +UA_NODEID_NUMERIC(ns[0], 15LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Image"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_26_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 30LU) +); +} + +/* Guid - ns=0;i=14 */ + +static UA_StatusCode function_namespace0_generated_27_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Guid"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 14LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Guid"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_27_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 14LU) +); +} + +/* DateTime - ns=0;i=13 */ + +static UA_StatusCode function_namespace0_generated_28_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "DateTime"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 13LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DateTime"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_28_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 13LU) +); +} + +/* UtcTime - ns=0;i=294 */ + +static UA_StatusCode function_namespace0_generated_29_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "UtcTime"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 294LU), +UA_NODEID_NUMERIC(ns[0], 13LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "UtcTime"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_29_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 294LU) +); +} + +/* String - ns=0;i=12 */ + +static UA_StatusCode function_namespace0_generated_30_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "String"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 12LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "String"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_30_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 12LU) +); +} + +/* LocaleId - ns=0;i=295 */ + +static UA_StatusCode function_namespace0_generated_31_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "LocaleId"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 295LU), +UA_NODEID_NUMERIC(ns[0], 12LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "LocaleId"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_31_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 295LU) +); +} + +/* Boolean - ns=0;i=1 */ + +static UA_StatusCode function_namespace0_generated_32_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Boolean"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 1LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Boolean"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_32_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 1LU) +); +} + +/* Enumeration - ns=0;i=29 */ + +static UA_StatusCode function_namespace0_generated_33_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "Enumeration"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 29LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Enumeration"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_33_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 29LU) +); +} + +/* ServerState - ns=0;i=852 */ + +static UA_StatusCode function_namespace0_generated_34_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerState"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 852LU), +UA_NODEID_NUMERIC(ns[0], 29LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerState"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_34_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 852LU) +); +} + +/* RedundancySupport - ns=0;i=851 */ + +static UA_StatusCode function_namespace0_generated_35_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "RedundancySupport"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 851LU), +UA_NODEID_NUMERIC(ns[0], 29LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "RedundancySupport"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_35_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 851LU) +); +} + +/* EnumStrings - ns=0;i=7611 */ + +static UA_StatusCode function_namespace0_generated_36_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +UA_LocalizedText variablenode_ns_0_i_7611_variant_DataContents[6]; +variablenode_ns_0_i_7611_variant_DataContents[0] = UA_LOCALIZEDTEXT("", "None"); +variablenode_ns_0_i_7611_variant_DataContents[1] = UA_LOCALIZEDTEXT("", "Cold"); +variablenode_ns_0_i_7611_variant_DataContents[2] = UA_LOCALIZEDTEXT("", "Warm"); +variablenode_ns_0_i_7611_variant_DataContents[3] = UA_LOCALIZEDTEXT("", "Hot"); +variablenode_ns_0_i_7611_variant_DataContents[4] = UA_LOCALIZEDTEXT("", "Transparent"); +variablenode_ns_0_i_7611_variant_DataContents[5] = UA_LOCALIZEDTEXT("", "HotAndMirrored"); +UA_Variant_setArray(&attr.value, &variablenode_ns_0_i_7611_variant_DataContents, (UA_Int32) 6, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +attr.displayName = UA_LOCALIZEDTEXT("", "EnumStrings"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 7611LU), +UA_NODEID_NUMERIC(ns[0], 851LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EnumStrings"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_36_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 7611LU) +); +} + +/* AxisScaleEnumeration - ns=0;i=12077 */ + +static UA_StatusCode function_namespace0_generated_37_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "AxisScaleEnumeration"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 12077LU), +UA_NODEID_NUMERIC(ns[0], 29LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "AxisScaleEnumeration"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_37_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 12077LU) +); +} + +/* EnumStrings - ns=0;i=12078 */ + +static UA_StatusCode function_namespace0_generated_38_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +UA_LocalizedText variablenode_ns_0_i_12078_variant_DataContents[3]; +variablenode_ns_0_i_12078_variant_DataContents[0] = UA_LOCALIZEDTEXT("", "Linear"); +variablenode_ns_0_i_12078_variant_DataContents[1] = UA_LOCALIZEDTEXT("", "Log"); +variablenode_ns_0_i_12078_variant_DataContents[2] = UA_LOCALIZEDTEXT("", "Ln"); +UA_Variant_setArray(&attr.value, &variablenode_ns_0_i_12078_variant_DataContents, (UA_Int32) 3, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +attr.displayName = UA_LOCALIZEDTEXT("", "EnumStrings"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 12078LU), +UA_NODEID_NUMERIC(ns[0], 12077LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EnumStrings"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_38_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 12078LU) +); +} + +/* NamingRuleType - ns=0;i=120 */ + +static UA_StatusCode function_namespace0_generated_39_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "NamingRuleType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 120LU), +UA_NODEID_NUMERIC(ns[0], 29LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "NamingRuleType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_39_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 120LU) +); +} + +/* EnumValues - ns=0;i=12169 */ + +static UA_StatusCode function_namespace0_generated_40_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7594LU); +UA_EnumValueType variablenode_ns_0_i_12169_variant_DataContents[3]; + +UA_init(&variablenode_ns_0_i_12169_variant_DataContents[0], &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +variablenode_ns_0_i_12169_variant_DataContents[0].value = (UA_Int64) 1; +variablenode_ns_0_i_12169_variant_DataContents[0].displayName = UA_LOCALIZEDTEXT("", "Mandatory"); +variablenode_ns_0_i_12169_variant_DataContents[0].description = UA_LOCALIZEDTEXT("", "The BrowseName must appear in all instances of the type."); + +UA_init(&variablenode_ns_0_i_12169_variant_DataContents[1], &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +variablenode_ns_0_i_12169_variant_DataContents[1].value = (UA_Int64) 2; +variablenode_ns_0_i_12169_variant_DataContents[1].displayName = UA_LOCALIZEDTEXT("", "Optional"); +variablenode_ns_0_i_12169_variant_DataContents[1].description = UA_LOCALIZEDTEXT("", "The BrowseName may appear in an instance of the type."); + +UA_init(&variablenode_ns_0_i_12169_variant_DataContents[2], &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +variablenode_ns_0_i_12169_variant_DataContents[2].value = (UA_Int64) 3; +variablenode_ns_0_i_12169_variant_DataContents[2].displayName = UA_LOCALIZEDTEXT("", "Constraint"); +variablenode_ns_0_i_12169_variant_DataContents[2].description = UA_LOCALIZEDTEXT("", "The modelling rule defines a constraint and the BrowseName is not used in an instance of the type."); +UA_Variant_setArray(&attr.value, &variablenode_ns_0_i_12169_variant_DataContents, (UA_Int32) 3, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +attr.displayName = UA_LOCALIZEDTEXT("", "EnumValues"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 12169LU), +UA_NODEID_NUMERIC(ns[0], 120LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EnumValues"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); + + + +return retVal; +} + +static UA_StatusCode function_namespace0_generated_40_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 12169LU) +); +} + +/* Number - ns=0;i=26 */ + +static UA_StatusCode function_namespace0_generated_41_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "Number"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 26LU), +UA_NODEID_NUMERIC(ns[0], 24LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Number"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_41_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 26LU) +); +} + +/* Decimal - ns=0;i=50 */ + +static UA_StatusCode function_namespace0_generated_42_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Decimal"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 50LU), +UA_NODEID_NUMERIC(ns[0], 26LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Decimal"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_42_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 50LU) +); +} + +/* UInteger - ns=0;i=28 */ + +static UA_StatusCode function_namespace0_generated_43_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "UInteger"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 28LU), +UA_NODEID_NUMERIC(ns[0], 26LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "UInteger"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_43_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 28LU) +); +} + +/* UInt64 - ns=0;i=9 */ + +static UA_StatusCode function_namespace0_generated_44_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "UInt64"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 9LU), +UA_NODEID_NUMERIC(ns[0], 28LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "UInt64"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_44_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 9LU) +); +} + +/* UInt32 - ns=0;i=7 */ + +static UA_StatusCode function_namespace0_generated_45_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "UInt32"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 7LU), +UA_NODEID_NUMERIC(ns[0], 28LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "UInt32"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_45_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 7LU) +); +} + +/* UInt16 - ns=0;i=5 */ + +static UA_StatusCode function_namespace0_generated_46_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "UInt16"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 5LU), +UA_NODEID_NUMERIC(ns[0], 28LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "UInt16"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_46_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 5LU) +); +} + +/* Byte - ns=0;i=3 */ + +static UA_StatusCode function_namespace0_generated_47_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Byte"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 3LU), +UA_NODEID_NUMERIC(ns[0], 28LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Byte"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_47_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3LU) +); +} + +/* Integer - ns=0;i=27 */ + +static UA_StatusCode function_namespace0_generated_48_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "Integer"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 27LU), +UA_NODEID_NUMERIC(ns[0], 26LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Integer"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_48_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 27LU) +); +} + +/* Int64 - ns=0;i=8 */ + +static UA_StatusCode function_namespace0_generated_49_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Int64"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 8LU), +UA_NODEID_NUMERIC(ns[0], 27LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Int64"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_49_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 8LU) +); +} + +/* Int32 - ns=0;i=6 */ + +static UA_StatusCode function_namespace0_generated_50_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Int32"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 6LU), +UA_NODEID_NUMERIC(ns[0], 27LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Int32"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_50_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 6LU) +); +} + +/* Int16 - ns=0;i=4 */ + +static UA_StatusCode function_namespace0_generated_51_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Int16"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 4LU), +UA_NODEID_NUMERIC(ns[0], 27LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Int16"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_51_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 4LU) +); +} + +/* SByte - ns=0;i=2 */ + +static UA_StatusCode function_namespace0_generated_52_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "SByte"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 2LU), +UA_NODEID_NUMERIC(ns[0], 27LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "SByte"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_52_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2LU) +); +} + +/* Double - ns=0;i=11 */ + +static UA_StatusCode function_namespace0_generated_53_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Double"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 11LU), +UA_NODEID_NUMERIC(ns[0], 26LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Double"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_53_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11LU) +); +} + +/* Duration - ns=0;i=290 */ + +static UA_StatusCode function_namespace0_generated_54_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Duration"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 290LU), +UA_NODEID_NUMERIC(ns[0], 11LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Duration"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_54_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 290LU) +); +} + +/* Float - ns=0;i=10 */ + +static UA_StatusCode function_namespace0_generated_55_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_DataTypeAttributes attr = UA_DataTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Float"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_DATATYPE, +UA_NODEID_NUMERIC(ns[0], 10LU), +UA_NODEID_NUMERIC(ns[0], 26LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "Float"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_55_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 10LU) +); +} + +/* DataItemType - ns=0;i=2365 */ + +static UA_StatusCode function_namespace0_generated_56_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +attr.valueRank = -2; +/* DataType inherited */ +attr.dataType = UA_NODEID_NUMERIC(ns[0], 24LU); +attr.displayName = UA_LOCALIZEDTEXT("", "DataItemType"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "A variable that contains live automation data."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 2365LU), +UA_NODEID_NUMERIC(ns[0], 63LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DataItemType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_56_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2365LU) +); +} + +/* DiscreteItemType - ns=0;i=2372 */ + +static UA_StatusCode function_namespace0_generated_57_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +attr.isAbstract = true; +attr.valueRank = -2; +/* DataType inherited */ +attr.dataType = UA_NODEID_NUMERIC(ns[0], 24LU); +attr.displayName = UA_LOCALIZEDTEXT("", "DiscreteItemType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 2372LU), +UA_NODEID_NUMERIC(ns[0], 2365LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DiscreteItemType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_57_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2372LU) +); +} + +/* MultiStateDiscreteType - ns=0;i=2376 */ + +static UA_StatusCode function_namespace0_generated_58_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +attr.valueRank = -2; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 28LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MultiStateDiscreteType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 2376LU), +UA_NODEID_NUMERIC(ns[0], 2372LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "MultiStateDiscreteType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_58_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2376LU) +); +} + +/* EnumStrings - ns=0;i=2377 */ + +static UA_StatusCode function_namespace0_generated_59_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +attr.displayName = UA_LOCALIZEDTEXT("", "EnumStrings"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2377LU), +UA_NODEID_NUMERIC(ns[0], 2376LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EnumStrings"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_59_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2377LU) +); +} + +/* TwoStateDiscreteType - ns=0;i=2373 */ + +static UA_StatusCode function_namespace0_generated_60_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +attr.valueRank = -2; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 1LU); +attr.displayName = UA_LOCALIZEDTEXT("", "TwoStateDiscreteType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 2373LU), +UA_NODEID_NUMERIC(ns[0], 2372LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "TwoStateDiscreteType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_60_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2373LU) +); +} + +/* TrueState - ns=0;i=2375 */ + +static UA_StatusCode function_namespace0_generated_61_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +attr.displayName = UA_LOCALIZEDTEXT("", "TrueState"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2375LU), +UA_NODEID_NUMERIC(ns[0], 2373LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "TrueState"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_61_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2375LU) +); +} + +/* FalseState - ns=0;i=2374 */ + +static UA_StatusCode function_namespace0_generated_62_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +attr.displayName = UA_LOCALIZEDTEXT("", "FalseState"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2374LU), +UA_NODEID_NUMERIC(ns[0], 2373LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "FalseState"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_62_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2374LU) +); +} + +/* MultiStateValueDiscreteType - ns=0;i=11238 */ + +static UA_StatusCode function_namespace0_generated_63_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +attr.valueRank = -2; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 26LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MultiStateValueDiscreteType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 11238LU), +UA_NODEID_NUMERIC(ns[0], 2372LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "MultiStateValueDiscreteType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_63_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11238LU) +); +} + +/* ValueAsText - ns=0;i=11461 */ + +static UA_StatusCode function_namespace0_generated_64_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ValueAsText"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11461LU), +UA_NODEID_NUMERIC(ns[0], 11238LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "ValueAsText"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_64_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11461LU) +); +} + +/* EnumValues - ns=0;i=11241 */ + +static UA_StatusCode function_namespace0_generated_65_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7594LU); +attr.displayName = UA_LOCALIZEDTEXT("", "EnumValues"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11241LU), +UA_NODEID_NUMERIC(ns[0], 11238LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EnumValues"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_65_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11241LU) +); +} + +/* AnalogItemType - ns=0;i=2368 */ + +static UA_StatusCode function_namespace0_generated_66_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +attr.valueRank = -2; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 26LU); +attr.displayName = UA_LOCALIZEDTEXT("", "AnalogItemType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 2368LU), +UA_NODEID_NUMERIC(ns[0], 2365LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "AnalogItemType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_66_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2368LU) +); +} + +/* EngineeringUnits - ns=0;i=2371 */ + +static UA_StatusCode function_namespace0_generated_67_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 887LU); +attr.displayName = UA_LOCALIZEDTEXT("", "EngineeringUnits"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2371LU), +UA_NODEID_NUMERIC(ns[0], 2368LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EngineeringUnits"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_67_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2371LU) +); +} + +/* InstrumentRange - ns=0;i=2370 */ + +static UA_StatusCode function_namespace0_generated_68_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 884LU); +attr.displayName = UA_LOCALIZEDTEXT("", "InstrumentRange"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2370LU), +UA_NODEID_NUMERIC(ns[0], 2368LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "InstrumentRange"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_68_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2370LU) +); +} + +/* EURange - ns=0;i=2369 */ + +static UA_StatusCode function_namespace0_generated_69_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 3; +attr.accessLevel = 3; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 884LU); +attr.displayName = UA_LOCALIZEDTEXT("", "EURange"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2369LU), +UA_NODEID_NUMERIC(ns[0], 2368LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EURange"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_69_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2369LU) +); +} + +/* ValuePrecision - ns=0;i=2367 */ + +static UA_StatusCode function_namespace0_generated_70_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 11LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ValuePrecision"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "The maximum precision that the server can maintain for the item based on restrictions in the target environment."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2367LU), +UA_NODEID_NUMERIC(ns[0], 2365LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "ValuePrecision"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_70_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2367LU) +); +} + +/* Definition - ns=0;i=2366 */ + +static UA_StatusCode function_namespace0_generated_71_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "Definition"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "A vendor-specific, human readable string that specifies how the value of this DataItem is calculated."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2366LU), +UA_NODEID_NUMERIC(ns[0], 2365LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "Definition"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_71_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2366LU) +); +} + +/* EventQueueOverflowEventType - ns=0;i=3035 */ + +static UA_StatusCode function_namespace0_generated_72_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "EventQueueOverflowEventType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 3035LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "EventQueueOverflowEventType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_72_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3035LU) +); +} + +/* Severity - ns=0;i=2051 */ + +static UA_StatusCode function_namespace0_generated_73_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 5LU); +attr.displayName = UA_LOCALIZEDTEXT("", "Severity"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "Indicates how urgent an event is."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2051LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "Severity"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_73_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2051LU) +); +} + +/* Message - ns=0;i=2050 */ + +static UA_StatusCode function_namespace0_generated_74_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +attr.displayName = UA_LOCALIZEDTEXT("", "Message"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "A localized description of the event."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2050LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "Message"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_74_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2050LU) +); +} + +/* LocalTime - ns=0;i=3190 */ + +static UA_StatusCode function_namespace0_generated_75_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 8912LU); +attr.displayName = UA_LOCALIZEDTEXT("", "LocalTime"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "Information about the local time where the event originated."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 3190LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "LocalTime"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_75_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3190LU) +); +} + +/* ReceiveTime - ns=0;i=2047 */ + +static UA_StatusCode function_namespace0_generated_76_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 294LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ReceiveTime"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "When the server received the event from the underlying system."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2047LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "ReceiveTime"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_76_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2047LU) +); +} + +/* Time - ns=0;i=2046 */ + +static UA_StatusCode function_namespace0_generated_77_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 294LU); +attr.displayName = UA_LOCALIZEDTEXT("", "Time"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "When the event occurred."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2046LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "Time"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_77_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2046LU) +); +} + +/* SourceName - ns=0;i=2045 */ + +static UA_StatusCode function_namespace0_generated_78_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SourceName"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "A description of the source of the event."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2045LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "SourceName"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_78_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2045LU) +); +} + +/* SourceNode - ns=0;i=2044 */ + +static UA_StatusCode function_namespace0_generated_79_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 17LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SourceNode"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "The source of the event."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2044LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "SourceNode"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_79_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2044LU) +); +} + +/* EventType - ns=0;i=2043 */ + +static UA_StatusCode function_namespace0_generated_80_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 17LU); +attr.displayName = UA_LOCALIZEDTEXT("", "EventType"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "The identifier for the event type."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2043LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EventType"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_80_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2043LU) +); +} + +/* EventId - ns=0;i=2042 */ + +static UA_StatusCode function_namespace0_generated_81_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 15LU); +attr.displayName = UA_LOCALIZEDTEXT("", "EventId"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "A globally unique identifier for the event."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2042LU), +UA_NODEID_NUMERIC(ns[0], 2041LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EventId"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_81_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2042LU) +); +} + +/* InterfaceTypes - ns=0;i=17708 */ + +static UA_StatusCode function_namespace0_generated_82_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "InterfaceTypes"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 17708LU), +UA_NODEID_NUMERIC(ns[0], 86LU), +UA_NODEID_NUMERIC(ns[0], 35LU), +UA_QUALIFIEDNAME(ns[0], "InterfaceTypes"), +UA_NODEID_NUMERIC(ns[0], 61LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_82_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 17708LU) +); +} + +/* BaseInterfaceType - ns=0;i=17602 */ + +static UA_StatusCode function_namespace0_generated_83_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.isAbstract = true; +attr.displayName = UA_LOCALIZEDTEXT("", "BaseInterfaceType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 17602LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "BaseInterfaceType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 17602LU), UA_NODEID_NUMERIC(ns[0], 35LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 17708LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_83_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 17602LU) +); +} + +/* ServerDiagnosticsSummaryType - ns=0;i=2150 */ + +static UA_StatusCode function_namespace0_generated_84_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 859LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerDiagnosticsSummaryType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 63LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerDiagnosticsSummaryType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_84_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2150LU) +); +} + +/* RejectedRequestsCount - ns=0;i=2163 */ + +static UA_StatusCode function_namespace0_generated_85_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "RejectedRequestsCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2163LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "RejectedRequestsCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_85_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2163LU) +); +} + +/* SecurityRejectedRequestsCount - ns=0;i=2162 */ + +static UA_StatusCode function_namespace0_generated_86_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SecurityRejectedRequestsCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2162LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SecurityRejectedRequestsCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_86_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2162LU) +); +} + +/* CumulatedSubscriptionCount - ns=0;i=2161 */ + +static UA_StatusCode function_namespace0_generated_87_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CumulatedSubscriptionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2161LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CumulatedSubscriptionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_87_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2161LU) +); +} + +/* CurrentSubscriptionCount - ns=0;i=2160 */ + +static UA_StatusCode function_namespace0_generated_88_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CurrentSubscriptionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2160LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CurrentSubscriptionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_88_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2160LU) +); +} + +/* PublishingIntervalCount - ns=0;i=2159 */ + +static UA_StatusCode function_namespace0_generated_89_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "PublishingIntervalCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2159LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "PublishingIntervalCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_89_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2159LU) +); +} + +/* SessionAbortCount - ns=0;i=2157 */ + +static UA_StatusCode function_namespace0_generated_90_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SessionAbortCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2157LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SessionAbortCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_90_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2157LU) +); +} + +/* SessionTimeoutCount - ns=0;i=2156 */ + +static UA_StatusCode function_namespace0_generated_91_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SessionTimeoutCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2156LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SessionTimeoutCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_91_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2156LU) +); +} + +/* RejectedSessionCount - ns=0;i=2155 */ + +static UA_StatusCode function_namespace0_generated_92_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "RejectedSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2155LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "RejectedSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_92_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2155LU) +); +} + +/* SecurityRejectedSessionCount - ns=0;i=2154 */ + +static UA_StatusCode function_namespace0_generated_93_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SecurityRejectedSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2154LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SecurityRejectedSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_93_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2154LU) +); +} + +/* CumulatedSessionCount - ns=0;i=2153 */ + +static UA_StatusCode function_namespace0_generated_94_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CumulatedSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2153LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CumulatedSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_94_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2153LU) +); +} + +/* CurrentSessionCount - ns=0;i=2152 */ + +static UA_StatusCode function_namespace0_generated_95_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CurrentSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2152LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CurrentSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_95_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2152LU) +); +} + +/* ServerViewCount - ns=0;i=2151 */ + +static UA_StatusCode function_namespace0_generated_96_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerViewCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2151LU), +UA_NODEID_NUMERIC(ns[0], 2150LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ServerViewCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_96_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2151LU) +); +} + +/* BuildInfoType - ns=0;i=3051 */ + +static UA_StatusCode function_namespace0_generated_97_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 338LU); +attr.displayName = UA_LOCALIZEDTEXT("", "BuildInfoType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 3051LU), +UA_NODEID_NUMERIC(ns[0], 63LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "BuildInfoType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_97_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3051LU) +); +} + +/* ServerStatusType - ns=0;i=2138 */ + +static UA_StatusCode function_namespace0_generated_98_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 862LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerStatusType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 2138LU), +UA_NODEID_NUMERIC(ns[0], 63LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerStatusType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_98_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2138LU) +); +} + +/* OperationLimitsType - ns=0;i=11564 */ + +static UA_StatusCode function_namespace0_generated_99_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "OperationLimitsType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 61LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "OperationLimitsType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_99_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11564LU) +); +} + +/* MaxMonitoredItemsPerCall - ns=0;i=11574 */ + +static UA_StatusCode function_namespace0_generated_100_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxMonitoredItemsPerCall"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11574LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxMonitoredItemsPerCall"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_100_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11574LU) +); +} + +/* MaxNodesPerNodeManagement - ns=0;i=11573 */ + +static UA_StatusCode function_namespace0_generated_101_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerNodeManagement"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11573LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerNodeManagement"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_101_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11573LU) +); +} + +/* MaxNodesPerTranslateBrowsePathsToNodeIds - ns=0;i=11572 */ + +static UA_StatusCode function_namespace0_generated_102_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerTranslateBrowsePathsToNodeIds"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11572LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerTranslateBrowsePathsToNodeIds"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_102_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11572LU) +); +} + +/* MaxNodesPerRegisterNodes - ns=0;i=11571 */ + +static UA_StatusCode function_namespace0_generated_103_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerRegisterNodes"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11571LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerRegisterNodes"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_103_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11571LU) +); +} + +/* MaxNodesPerBrowse - ns=0;i=11570 */ + +static UA_StatusCode function_namespace0_generated_104_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerBrowse"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11570LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerBrowse"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_104_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11570LU) +); +} + +/* MaxNodesPerMethodCall - ns=0;i=11569 */ + +static UA_StatusCode function_namespace0_generated_105_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerMethodCall"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11569LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerMethodCall"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_105_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11569LU) +); +} + +/* MaxNodesPerWrite - ns=0;i=11567 */ + +static UA_StatusCode function_namespace0_generated_106_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerWrite"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11567LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerWrite"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_106_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11567LU) +); +} + +/* MaxNodesPerRead - ns=0;i=11565 */ + +static UA_StatusCode function_namespace0_generated_107_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerRead"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11565LU), +UA_NODEID_NUMERIC(ns[0], 11564LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerRead"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_107_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11565LU) +); +} + +/* ServerRedundancyType - ns=0;i=2034 */ + +static UA_StatusCode function_namespace0_generated_108_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerRedundancyType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 2034LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerRedundancyType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_108_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2034LU) +); +} + +/* RedundancySupport - ns=0;i=2035 */ + +static UA_StatusCode function_namespace0_generated_109_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 851LU); +attr.displayName = UA_LOCALIZEDTEXT("", "RedundancySupport"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2035LU), +UA_NODEID_NUMERIC(ns[0], 2034LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "RedundancySupport"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_109_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2035LU) +); +} + +/* VendorServerInfoType - ns=0;i=2033 */ + +static UA_StatusCode function_namespace0_generated_110_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "VendorServerInfoType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 2033LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "VendorServerInfoType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_110_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2033LU) +); +} + +/* ServerDiagnosticsType - ns=0;i=2020 */ + +static UA_StatusCode function_namespace0_generated_111_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerDiagnosticsType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 2020LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerDiagnosticsType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_111_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2020LU) +); +} + +/* ServerCapabilitiesType - ns=0;i=2013 */ + +static UA_StatusCode function_namespace0_generated_112_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerCapabilitiesType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 2013LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerCapabilitiesType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_112_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2013LU) +); +} + +/* OperationLimits - ns=0;i=11551 */ + +static UA_StatusCode function_namespace0_generated_113_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "OperationLimits"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 11551LU), +UA_NODEID_NUMERIC(ns[0], 2013LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "OperationLimits"), +UA_NODEID_NUMERIC(ns[0], 11564LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_113_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11551LU) +); +} + +/* ServerType - ns=0;i=2004 */ + +static UA_StatusCode function_namespace0_generated_114_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 2004LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ServerType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_114_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2004LU) +); +} + +/* Server - ns=0;i=2253 */ + +static UA_StatusCode function_namespace0_generated_115_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.eventNotifier = UA_EVENTNOTIFIER_SUBSCRIBE_TO_EVENT; +attr.displayName = UA_LOCALIZEDTEXT("", "Server"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 85LU), +UA_NODEID_NUMERIC(ns[0], 35LU), +UA_QUALIFIEDNAME(ns[0], "Server"), +UA_NODEID_NUMERIC(ns[0], 2004LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_115_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2253LU) +); +} + +/* Auditing - ns=0;i=2994 */ + +static UA_StatusCode function_namespace0_generated_116_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 1LU); +attr.displayName = UA_LOCALIZEDTEXT("", "Auditing"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2994LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "Auditing"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_116_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2994LU) +); +} + +/* ServerRedundancy - ns=0;i=2296 */ + +static UA_StatusCode function_namespace0_generated_117_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerRedundancy"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2296LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ServerRedundancy"), +UA_NODEID_NUMERIC(ns[0], 2034LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_117_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2296LU) +); +} + +/* RedundancySupport - ns=0;i=3709 */ + +static UA_StatusCode function_namespace0_generated_118_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 851LU); +attr.displayName = UA_LOCALIZEDTEXT("", "RedundancySupport"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 3709LU), +UA_NODEID_NUMERIC(ns[0], 2296LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "RedundancySupport"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_118_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3709LU) +); +} + +/* VendorServerInfo - ns=0;i=2295 */ + +static UA_StatusCode function_namespace0_generated_119_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "VendorServerInfo"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2295LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "VendorServerInfo"), +UA_NODEID_NUMERIC(ns[0], 2033LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_119_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2295LU) +); +} + +/* ServerDiagnostics - ns=0;i=2274 */ + +static UA_StatusCode function_namespace0_generated_120_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerDiagnostics"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2274LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ServerDiagnostics"), +UA_NODEID_NUMERIC(ns[0], 2020LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_120_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2274LU) +); +} + +/* EnabledFlag - ns=0;i=2294 */ + +static UA_StatusCode function_namespace0_generated_121_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 3; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 1LU); +attr.displayName = UA_LOCALIZEDTEXT("", "EnabledFlag"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2294LU), +UA_NODEID_NUMERIC(ns[0], 2274LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "EnabledFlag"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_121_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2294LU) +); +} + +/* ServerDiagnosticsSummary - ns=0;i=2275 */ + +static UA_StatusCode function_namespace0_generated_122_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 859LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerDiagnosticsSummary"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 2274LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ServerDiagnosticsSummary"), +UA_NODEID_NUMERIC(ns[0], 2150LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_122_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2275LU) +); +} + +/* RejectedSessionCount - ns=0;i=3705 */ + +static UA_StatusCode function_namespace0_generated_123_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "RejectedSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 3705LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "RejectedSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_123_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3705LU) +); +} + +/* RejectedRequestsCount - ns=0;i=2288 */ + +static UA_StatusCode function_namespace0_generated_124_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "RejectedRequestsCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2288LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "RejectedRequestsCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_124_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2288LU) +); +} + +/* SecurityRejectedRequestsCount - ns=0;i=2287 */ + +static UA_StatusCode function_namespace0_generated_125_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SecurityRejectedRequestsCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2287LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SecurityRejectedRequestsCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_125_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2287LU) +); +} + +/* CumulatedSubscriptionCount - ns=0;i=2286 */ + +static UA_StatusCode function_namespace0_generated_126_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CumulatedSubscriptionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2286LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CumulatedSubscriptionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_126_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2286LU) +); +} + +/* CurrentSubscriptionCount - ns=0;i=2285 */ + +static UA_StatusCode function_namespace0_generated_127_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CurrentSubscriptionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2285LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CurrentSubscriptionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_127_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2285LU) +); +} + +/* PublishingIntervalCount - ns=0;i=2284 */ + +static UA_StatusCode function_namespace0_generated_128_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "PublishingIntervalCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2284LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "PublishingIntervalCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_128_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2284LU) +); +} + +/* SessionAbortCount - ns=0;i=2282 */ + +static UA_StatusCode function_namespace0_generated_129_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SessionAbortCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2282LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SessionAbortCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_129_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2282LU) +); +} + +/* SessionTimeoutCount - ns=0;i=2281 */ + +static UA_StatusCode function_namespace0_generated_130_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SessionTimeoutCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2281LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SessionTimeoutCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_130_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2281LU) +); +} + +/* SecurityRejectedSessionCount - ns=0;i=2279 */ + +static UA_StatusCode function_namespace0_generated_131_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SecurityRejectedSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2279LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SecurityRejectedSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_131_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2279LU) +); +} + +/* CumulatedSessionCount - ns=0;i=2278 */ + +static UA_StatusCode function_namespace0_generated_132_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CumulatedSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2278LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CumulatedSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_132_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2278LU) +); +} + +/* CurrentSessionCount - ns=0;i=2277 */ + +static UA_StatusCode function_namespace0_generated_133_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CurrentSessionCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2277LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CurrentSessionCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_133_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2277LU) +); +} + +/* ServerViewCount - ns=0;i=2276 */ + +static UA_StatusCode function_namespace0_generated_134_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerViewCount"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2276LU), +UA_NODEID_NUMERIC(ns[0], 2275LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ServerViewCount"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_134_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2276LU) +); +} + +/* ServerCapabilities - ns=0;i=2268 */ + +static UA_StatusCode function_namespace0_generated_135_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ServerCapabilities"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ServerCapabilities"), +UA_NODEID_NUMERIC(ns[0], 2013LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_135_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2268LU) +); +} + +/* SoftwareCertificates - ns=0;i=3704 */ + +static UA_StatusCode function_namespace0_generated_136_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 344LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SoftwareCertificates"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 3704LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "SoftwareCertificates"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_136_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3704LU) +); +} + +/* AggregateFunctions - ns=0;i=2997 */ + +static UA_StatusCode function_namespace0_generated_137_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "AggregateFunctions"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2997LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "AggregateFunctions"), +UA_NODEID_NUMERIC(ns[0], 61LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_137_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2997LU) +); +} + +/* ModellingRules - ns=0;i=2996 */ + +static UA_StatusCode function_namespace0_generated_138_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ModellingRules"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2996LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ModellingRules"), +UA_NODEID_NUMERIC(ns[0], 61LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_138_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2996LU) +); +} + +/* MaxHistoryContinuationPoints - ns=0;i=2737 */ + +static UA_StatusCode function_namespace0_generated_139_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 5LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxHistoryContinuationPoints"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2737LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxHistoryContinuationPoints"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_139_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2737LU) +); +} + +/* MaxQueryContinuationPoints - ns=0;i=2736 */ + +static UA_StatusCode function_namespace0_generated_140_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 5LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxQueryContinuationPoints"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2736LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxQueryContinuationPoints"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_140_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2736LU) +); +} + +/* MaxBrowseContinuationPoints - ns=0;i=2735 */ + +static UA_StatusCode function_namespace0_generated_141_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 5LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxBrowseContinuationPoints"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2735LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxBrowseContinuationPoints"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_141_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2735LU) +); +} + +/* MinSupportedSampleRate - ns=0;i=2272 */ + +static UA_StatusCode function_namespace0_generated_142_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 290LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MinSupportedSampleRate"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2272LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MinSupportedSampleRate"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_142_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2272LU) +); +} + +/* LocaleIdArray - ns=0;i=2271 */ + +static UA_StatusCode function_namespace0_generated_143_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 295LU); +attr.displayName = UA_LOCALIZEDTEXT("", "LocaleIdArray"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2271LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "LocaleIdArray"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_143_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2271LU) +); +} + +/* ServerProfileArray - ns=0;i=2269 */ + +static UA_StatusCode function_namespace0_generated_144_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerProfileArray"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2269LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "ServerProfileArray"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_144_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2269LU) +); +} + +/* OperationLimits - ns=0;i=11704 */ + +static UA_StatusCode function_namespace0_generated_145_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "OperationLimits"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 2268LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "OperationLimits"), +UA_NODEID_NUMERIC(ns[0], 11564LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_145_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11704LU) +); +} + +/* MaxMonitoredItemsPerCall - ns=0;i=11714 */ + +static UA_StatusCode function_namespace0_generated_146_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxMonitoredItemsPerCall"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11714LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxMonitoredItemsPerCall"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_146_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11714LU) +); +} + +/* MaxNodesPerNodeManagement - ns=0;i=11713 */ + +static UA_StatusCode function_namespace0_generated_147_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerNodeManagement"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11713LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerNodeManagement"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_147_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11713LU) +); +} + +/* MaxNodesPerTranslateBrowsePathsToNodeIds - ns=0;i=11712 */ + +static UA_StatusCode function_namespace0_generated_148_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerTranslateBrowsePathsToNodeIds"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11712LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerTranslateBrowsePathsToNodeIds"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_148_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11712LU) +); +} + +/* MaxNodesPerRegisterNodes - ns=0;i=11711 */ + +static UA_StatusCode function_namespace0_generated_149_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerRegisterNodes"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11711LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerRegisterNodes"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_149_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11711LU) +); +} + +/* MaxNodesPerBrowse - ns=0;i=11710 */ + +static UA_StatusCode function_namespace0_generated_150_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerBrowse"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11710LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerBrowse"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_150_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11710LU) +); +} + +/* MaxNodesPerMethodCall - ns=0;i=11709 */ + +static UA_StatusCode function_namespace0_generated_151_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerMethodCall"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11709LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerMethodCall"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_151_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11709LU) +); +} + +/* MaxNodesPerWrite - ns=0;i=11707 */ + +static UA_StatusCode function_namespace0_generated_152_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerWrite"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11707LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerWrite"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_152_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11707LU) +); +} + +/* MaxNodesPerRead - ns=0;i=11705 */ + +static UA_StatusCode function_namespace0_generated_153_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "MaxNodesPerRead"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11705LU), +UA_NODEID_NUMERIC(ns[0], 11704LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "MaxNodesPerRead"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_153_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11705LU) +); +} + +/* ServiceLevel - ns=0;i=2267 */ + +static UA_StatusCode function_namespace0_generated_154_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 3LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServiceLevel"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2267LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "ServiceLevel"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_154_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2267LU) +); +} + +/* ServerStatus - ns=0;i=2256 */ + +static UA_StatusCode function_namespace0_generated_155_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 862LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerStatus"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2256LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ServerStatus"), +UA_NODEID_NUMERIC(ns[0], 2138LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_155_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2256LU) +); +} + +/* ShutdownReason - ns=0;i=2993 */ + +static UA_StatusCode function_namespace0_generated_156_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 21LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ShutdownReason"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2993LU), +UA_NODEID_NUMERIC(ns[0], 2256LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ShutdownReason"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_156_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2993LU) +); +} + +/* SecondsTillShutdown - ns=0;i=2992 */ + +static UA_StatusCode function_namespace0_generated_157_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SecondsTillShutdown"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2992LU), +UA_NODEID_NUMERIC(ns[0], 2256LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SecondsTillShutdown"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_157_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2992LU) +); +} + +/* BuildInfo - ns=0;i=2260 */ + +static UA_StatusCode function_namespace0_generated_158_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 338LU); +attr.displayName = UA_LOCALIZEDTEXT("", "BuildInfo"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2260LU), +UA_NODEID_NUMERIC(ns[0], 2256LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "BuildInfo"), +UA_NODEID_NUMERIC(ns[0], 3051LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_158_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2260LU) +); +} + +/* BuildDate - ns=0;i=2266 */ + +static UA_StatusCode function_namespace0_generated_159_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 294LU); +attr.displayName = UA_LOCALIZEDTEXT("", "BuildDate"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2266LU), +UA_NODEID_NUMERIC(ns[0], 2260LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "BuildDate"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_159_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2266LU) +); +} + +/* BuildNumber - ns=0;i=2265 */ + +static UA_StatusCode function_namespace0_generated_160_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "BuildNumber"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2265LU), +UA_NODEID_NUMERIC(ns[0], 2260LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "BuildNumber"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_160_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2265LU) +); +} + +/* SoftwareVersion - ns=0;i=2264 */ + +static UA_StatusCode function_namespace0_generated_161_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "SoftwareVersion"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2264LU), +UA_NODEID_NUMERIC(ns[0], 2260LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "SoftwareVersion"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_161_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2264LU) +); +} + +/* ManufacturerName - ns=0;i=2263 */ + +static UA_StatusCode function_namespace0_generated_162_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ManufacturerName"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2263LU), +UA_NODEID_NUMERIC(ns[0], 2260LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ManufacturerName"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_162_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2263LU) +); +} + +/* ProductUri - ns=0;i=2262 */ + +static UA_StatusCode function_namespace0_generated_163_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ProductUri"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2262LU), +UA_NODEID_NUMERIC(ns[0], 2260LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ProductUri"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_163_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2262LU) +); +} + +/* ProductName - ns=0;i=2261 */ + +static UA_StatusCode function_namespace0_generated_164_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ProductName"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2261LU), +UA_NODEID_NUMERIC(ns[0], 2260LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "ProductName"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_164_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2261LU) +); +} + +/* State - ns=0;i=2259 */ + +static UA_StatusCode function_namespace0_generated_165_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 852LU); +attr.displayName = UA_LOCALIZEDTEXT("", "State"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2259LU), +UA_NODEID_NUMERIC(ns[0], 2256LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "State"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_165_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2259LU) +); +} + +/* CurrentTime - ns=0;i=2258 */ + +static UA_StatusCode function_namespace0_generated_166_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 294LU); +attr.displayName = UA_LOCALIZEDTEXT("", "CurrentTime"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2258LU), +UA_NODEID_NUMERIC(ns[0], 2256LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "CurrentTime"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_166_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2258LU) +); +} + +/* StartTime - ns=0;i=2257 */ + +static UA_StatusCode function_namespace0_generated_167_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 294LU); +attr.displayName = UA_LOCALIZEDTEXT("", "StartTime"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2257LU), +UA_NODEID_NUMERIC(ns[0], 2256LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "StartTime"), +UA_NODEID_NUMERIC(ns[0], 63LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_167_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2257LU) +); +} + +/* NamespaceArray - ns=0;i=2255 */ + +static UA_StatusCode function_namespace0_generated_168_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "NamespaceArray"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2255LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "NamespaceArray"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_168_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2255LU) +); +} + +/* ServerArray - ns=0;i=2254 */ + +static UA_StatusCode function_namespace0_generated_169_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 1000.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "ServerArray"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 2254LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "ServerArray"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_169_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2254LU) +); +} + +/* GetMonitoredItems - ns=0;i=11492 */ + +static UA_StatusCode function_namespace0_generated_170_begin(UA_Server *server, UA_UInt16* ns) { +#ifdef UA_ENABLE_METHODCALLS +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_MethodAttributes attr = UA_MethodAttributes_default; +attr.executable = true; +attr.userExecutable = true; +attr.displayName = UA_LOCALIZEDTEXT("", "GetMonitoredItems"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_METHOD, +UA_NODEID_NUMERIC(ns[0], 11492LU), +UA_NODEID_NUMERIC(ns[0], 2253LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "GetMonitoredItems"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_METHODATTRIBUTES],NULL, NULL); +return retVal; +#else +return UA_STATUSCODE_GOOD; +#endif /* UA_ENABLE_METHODCALLS */ +} + +static UA_StatusCode function_namespace0_generated_170_finish(UA_Server *server, UA_UInt16* ns) { +#ifdef UA_ENABLE_METHODCALLS +return UA_Server_addMethodNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11492LU) +, NULL, 0, NULL, 0, NULL); +#else +return UA_STATUSCODE_GOOD; +#endif /* UA_ENABLE_METHODCALLS */ +} + +/* OutputArguments - ns=0;i=11494 */ + +static UA_StatusCode function_namespace0_generated_171_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 296LU); +UA_Argument variablenode_ns_0_i_11494_variant_DataContents[2]; + +UA_init(&variablenode_ns_0_i_11494_variant_DataContents[0], &UA_TYPES[UA_TYPES_ARGUMENT]); +variablenode_ns_0_i_11494_variant_DataContents[0].name = UA_STRING("ServerHandles"); +variablenode_ns_0_i_11494_variant_DataContents[0].dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +variablenode_ns_0_i_11494_variant_DataContents[0].valueRank = (UA_Int32) 1; +UA_STACKARRAY(UA_UInt32, variablenode_ns_0_i_11494_variant_DataContents0_arrayDimensions, 1); +UA_init(variablenode_ns_0_i_11494_variant_DataContents0_arrayDimensions, &UA_TYPES[UA_TYPES_UINT32]); +variablenode_ns_0_i_11494_variant_DataContents0_arrayDimensions[0] = (UA_UInt32) 0; +variablenode_ns_0_i_11494_variant_DataContents[0].arrayDimensionsSize = 1; +variablenode_ns_0_i_11494_variant_DataContents[0].arrayDimensions = variablenode_ns_0_i_11494_variant_DataContents0_arrayDimensions; + +UA_init(&variablenode_ns_0_i_11494_variant_DataContents[1], &UA_TYPES[UA_TYPES_ARGUMENT]); +variablenode_ns_0_i_11494_variant_DataContents[1].name = UA_STRING("ClientHandles"); +variablenode_ns_0_i_11494_variant_DataContents[1].dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +variablenode_ns_0_i_11494_variant_DataContents[1].valueRank = (UA_Int32) 1; +UA_STACKARRAY(UA_UInt32, variablenode_ns_0_i_11494_variant_DataContents1_arrayDimensions, 1); +UA_init(variablenode_ns_0_i_11494_variant_DataContents1_arrayDimensions, &UA_TYPES[UA_TYPES_UINT32]); +variablenode_ns_0_i_11494_variant_DataContents1_arrayDimensions[0] = (UA_UInt32) 0; +variablenode_ns_0_i_11494_variant_DataContents[1].arrayDimensionsSize = 1; +variablenode_ns_0_i_11494_variant_DataContents[1].arrayDimensions = variablenode_ns_0_i_11494_variant_DataContents1_arrayDimensions; +UA_Variant_setArray(&attr.value, &variablenode_ns_0_i_11494_variant_DataContents, (UA_Int32) 2, &UA_TYPES[UA_TYPES_ARGUMENT]); +attr.displayName = UA_LOCALIZEDTEXT("", "OutputArguments"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11494LU), +UA_NODEID_NUMERIC(ns[0], 11492LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "OutputArguments"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); + + +return retVal; +} + +static UA_StatusCode function_namespace0_generated_171_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11494LU) +); +} + +/* InputArguments - ns=0;i=11493 */ + +static UA_StatusCode function_namespace0_generated_172_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +attr.valueRank = 1; +attr.arrayDimensionsSize = 1; +UA_UInt32 arrayDimensions[1]; +arrayDimensions[0] = 0; +attr.arrayDimensions = &arrayDimensions[0]; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 296LU); +UA_Argument variablenode_ns_0_i_11493_variant_DataContents[1]; + +UA_init(&variablenode_ns_0_i_11493_variant_DataContents[0], &UA_TYPES[UA_TYPES_ARGUMENT]); +variablenode_ns_0_i_11493_variant_DataContents[0].name = UA_STRING("SubscriptionId"); +variablenode_ns_0_i_11493_variant_DataContents[0].dataType = UA_NODEID_NUMERIC(ns[0], 7LU); +variablenode_ns_0_i_11493_variant_DataContents[0].valueRank = (UA_Int32) -1; +UA_Variant_setArray(&attr.value, &variablenode_ns_0_i_11493_variant_DataContents, (UA_Int32) 1, &UA_TYPES[UA_TYPES_ARGUMENT]); +attr.displayName = UA_LOCALIZEDTEXT("", "InputArguments"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 11493LU), +UA_NODEID_NUMERIC(ns[0], 11492LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "InputArguments"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); + +return retVal; +} + +static UA_StatusCode function_namespace0_generated_172_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 11493LU) +); +} + +/* VendorServerInfo - ns=0;i=2011 */ + +static UA_StatusCode function_namespace0_generated_173_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "VendorServerInfo"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 2011LU), +UA_NODEID_NUMERIC(ns[0], 2004LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "VendorServerInfo"), +UA_NODEID_NUMERIC(ns[0], 2033LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_173_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 2011LU) +); +} + +/* ModellingRuleType - ns=0;i=77 */ + +static UA_StatusCode function_namespace0_generated_174_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "ModellingRuleType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 77LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "ModellingRuleType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_174_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 77LU) +); +} + +/* Optional - ns=0;i=80 */ + +static UA_StatusCode function_namespace0_generated_175_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Optional"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 80LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Optional"), +UA_NODEID_NUMERIC(ns[0], 77LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11572LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11571LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2367LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11574LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2366LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11569LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2370LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2371LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11573LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11551LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11567LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11570LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 3190LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 80LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11565LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_175_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 80LU) +); +} + +/* NamingRule - ns=0;i=113 */ + +static UA_StatusCode function_namespace0_generated_176_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 120LU); +UA_Int32 *variablenode_ns_0_i_113_variant_DataContents = UA_Int32_new(); +if (!variablenode_ns_0_i_113_variant_DataContents) return UA_STATUSCODE_BADOUTOFMEMORY; +UA_Int32_init(variablenode_ns_0_i_113_variant_DataContents); +*variablenode_ns_0_i_113_variant_DataContents = (UA_Int32) 2; +UA_Variant_setScalar(&attr.value, variablenode_ns_0_i_113_variant_DataContents, &UA_TYPES[UA_TYPES_INT32]); +attr.displayName = UA_LOCALIZEDTEXT("", "NamingRule"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 113LU), +UA_NODEID_NUMERIC(ns[0], 80LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "NamingRule"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +UA_Int32_delete(variablenode_ns_0_i_113_variant_DataContents); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_176_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 113LU) +); +} + +/* Mandatory - ns=0;i=78 */ + +static UA_StatusCode function_namespace0_generated_177_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Mandatory"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 78LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Mandatory"), +UA_NODEID_NUMERIC(ns[0], 77LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2159LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2375LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2369LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2156LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2161LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11461LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 12169LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2155LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2153LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2047LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2050LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2163LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 7611LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 11241LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2152LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2051LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2044LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2160LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2011LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2151LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2043LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 12078LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2157LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2035LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2377LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2045LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2154LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2042LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2046LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2374LU), false); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 78LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 2162LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_177_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 78LU) +); +} + +/* NamingRule - ns=0;i=112 */ + +static UA_StatusCode function_namespace0_generated_178_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 120LU); +UA_Int32 *variablenode_ns_0_i_112_variant_DataContents = UA_Int32_new(); +if (!variablenode_ns_0_i_112_variant_DataContents) return UA_STATUSCODE_BADOUTOFMEMORY; +UA_Int32_init(variablenode_ns_0_i_112_variant_DataContents); +*variablenode_ns_0_i_112_variant_DataContents = (UA_Int32) 1; +UA_Variant_setScalar(&attr.value, variablenode_ns_0_i_112_variant_DataContents, &UA_TYPES[UA_TYPES_INT32]); +attr.displayName = UA_LOCALIZEDTEXT("", "NamingRule"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 112LU), +UA_NODEID_NUMERIC(ns[0], 78LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "NamingRule"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +UA_Int32_delete(variablenode_ns_0_i_112_variant_DataContents); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_178_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 112LU) +); +} + +/* NamingRule - ns=0;i=111 */ + +static UA_StatusCode function_namespace0_generated_179_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 120LU); +UA_Int32 *variablenode_ns_0_i_111_variant_DataContents = UA_Int32_new(); +if (!variablenode_ns_0_i_111_variant_DataContents) return UA_STATUSCODE_BADOUTOFMEMORY; +UA_Int32_init(variablenode_ns_0_i_111_variant_DataContents); +*variablenode_ns_0_i_111_variant_DataContents = (UA_Int32) 1; +UA_Variant_setScalar(&attr.value, variablenode_ns_0_i_111_variant_DataContents, &UA_TYPES[UA_TYPES_INT32]); +attr.displayName = UA_LOCALIZEDTEXT("", "NamingRule"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 111LU), +UA_NODEID_NUMERIC(ns[0], 77LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "NamingRule"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +UA_Int32_delete(variablenode_ns_0_i_111_variant_DataContents); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 111LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 78LU), true); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_179_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 111LU) +); +} + +/* DataTypeEncodingType - ns=0;i=76 */ + +static UA_StatusCode function_namespace0_generated_180_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "DataTypeEncodingType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 76LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DataTypeEncodingType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_180_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 76LU) +); +} + +/* Default Binary - ns=0;i=8251 */ + +static UA_StatusCode function_namespace0_generated_181_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Default Binary"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 8251LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Default Binary"), +UA_NODEID_NUMERIC(ns[0], 76LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 8251LU), UA_NODEID_NUMERIC(ns[0], 38LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 7594LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_181_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 8251LU) +); +} + +/* Default Binary - ns=0;i=298 */ + +static UA_StatusCode function_namespace0_generated_182_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Default Binary"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 298LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Default Binary"), +UA_NODEID_NUMERIC(ns[0], 76LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 298LU), UA_NODEID_NUMERIC(ns[0], 38LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 296LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_182_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 298LU) +); +} + +/* Default JSON - ns=0;i=15376 */ + +static UA_StatusCode function_namespace0_generated_183_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Default JSON"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 15376LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Default JSON"), +UA_NODEID_NUMERIC(ns[0], 76LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 15376LU), UA_NODEID_NUMERIC(ns[0], 38LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 887LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_183_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 15376LU) +); +} + +/* Default JSON - ns=0;i=15375 */ + +static UA_StatusCode function_namespace0_generated_184_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Default JSON"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 15375LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Default JSON"), +UA_NODEID_NUMERIC(ns[0], 76LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 15375LU), UA_NODEID_NUMERIC(ns[0], 38LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 884LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_184_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 15375LU) +); +} + +/* DataTypeSystemType - ns=0;i=75 */ + +static UA_StatusCode function_namespace0_generated_185_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectTypeAttributes attr = UA_ObjectTypeAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "DataTypeSystemType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECTTYPE, +UA_NODEID_NUMERIC(ns[0], 75LU), +UA_NODEID_NUMERIC(ns[0], 58LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DataTypeSystemType"), + UA_NODEID_NULL, +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_185_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 75LU) +); +} + +/* OPC Binary - ns=0;i=93 */ + +static UA_StatusCode function_namespace0_generated_186_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "OPC Binary"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 93LU), +UA_NODEID_NUMERIC(ns[0], 90LU), +UA_NODEID_NUMERIC(ns[0], 35LU), +UA_QUALIFIEDNAME(ns[0], "OPC Binary"), +UA_NODEID_NUMERIC(ns[0], 75LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_186_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 93LU) +); +} + +/* XML Schema - ns=0;i=92 */ + +static UA_StatusCode function_namespace0_generated_187_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "XML Schema"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 92LU), +UA_NODEID_NUMERIC(ns[0], 90LU), +UA_NODEID_NUMERIC(ns[0], 35LU), +UA_QUALIFIEDNAME(ns[0], "XML Schema"), +UA_NODEID_NUMERIC(ns[0], 75LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_187_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 92LU) +); +} + +/* DataTypeDictionaryType - ns=0;i=72 */ + +static UA_StatusCode function_namespace0_generated_188_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 15LU); +attr.displayName = UA_LOCALIZEDTEXT("", "DataTypeDictionaryType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 72LU), +UA_NODEID_NUMERIC(ns[0], 63LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DataTypeDictionaryType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_188_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 72LU) +); +} + +static UA_StatusCode function_namespace0_generated_189_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 15LU); +UA_ByteString *variablenode_ns_0_i_7617_variant_DataContents = UA_ByteString_new(); +if (!variablenode_ns_0_i_7617_variant_DataContents) return UA_STATUSCODE_BADOUTOFMEMORY; +UA_ByteString_init(variablenode_ns_0_i_7617_variant_DataContents); +variablenode_ns_0_i_7617_variant_DataContents->length = 177218; +variablenode_ns_0_i_7617_variant_DataContents->data = (UA_Byte *)(void*)(uintptr_t)variablenode_ns_0_i_7617_variant_DataContents_byteArray; +UA_Variant_setScalar(&attr.value, variablenode_ns_0_i_7617_variant_DataContents, &UA_TYPES[UA_TYPES_BYTESTRING]); +attr.displayName = UA_LOCALIZEDTEXT("", "Opc.Ua"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 7617LU), +UA_NODEID_NUMERIC(ns[0], 93LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "Opc.Ua"), +UA_NODEID_NUMERIC(ns[0], 72LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +variablenode_ns_0_i_7617_variant_DataContents->data = NULL; +variablenode_ns_0_i_7617_variant_DataContents->length = 0; +UA_ByteString_delete(variablenode_ns_0_i_7617_variant_DataContents); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_189_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 7617LU) +); +} + +/* NamespaceUri - ns=0;i=107 */ + +static UA_StatusCode function_namespace0_generated_190_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "NamespaceUri"); +#ifdef UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +attr.description = UA_LOCALIZEDTEXT("", "A URI that uniquely identifies the dictionary."); +#endif +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 107LU), +UA_NODEID_NUMERIC(ns[0], 72LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "NamespaceUri"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 107LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 80LU), true); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_190_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 107LU) +); +} + +/* DataTypeVersion - ns=0;i=106 */ + +static UA_StatusCode function_namespace0_generated_191_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "DataTypeVersion"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 106LU), +UA_NODEID_NUMERIC(ns[0], 72LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "DataTypeVersion"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 106LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 80LU), true); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_191_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 106LU) +); +} + +/* DataTypeDescriptionType - ns=0;i=69 */ + +static UA_StatusCode function_namespace0_generated_192_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableTypeAttributes attr = UA_VariableTypeAttributes_default; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "DataTypeDescriptionType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLETYPE, +UA_NODEID_NUMERIC(ns[0], 69LU), +UA_NODEID_NUMERIC(ns[0], 63LU), +UA_NODEID_NUMERIC(ns[0], 45LU), +UA_QUALIFIEDNAME(ns[0], "DataTypeDescriptionType"), +UA_NODEID_NUMERIC(ns[0], 0LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_192_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 69LU) +); +} + +/* EnumValueType - ns=0;i=7656 */ + +static UA_StatusCode function_namespace0_generated_193_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +UA_String *variablenode_ns_0_i_7656_variant_DataContents = UA_String_new(); +if (!variablenode_ns_0_i_7656_variant_DataContents) return UA_STATUSCODE_BADOUTOFMEMORY; +UA_String_init(variablenode_ns_0_i_7656_variant_DataContents); +*variablenode_ns_0_i_7656_variant_DataContents = UA_STRING_ALLOC("EnumValueType"); +UA_Variant_setScalar(&attr.value, variablenode_ns_0_i_7656_variant_DataContents, &UA_TYPES[UA_TYPES_STRING]); +attr.displayName = UA_LOCALIZEDTEXT("", "EnumValueType"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 7656LU), +UA_NODEID_NUMERIC(ns[0], 7617LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "EnumValueType"), +UA_NODEID_NUMERIC(ns[0], 69LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +UA_String_delete(variablenode_ns_0_i_7656_variant_DataContents); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 7656LU), UA_NODEID_NUMERIC(ns[0], 39LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 8251LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_193_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 7656LU) +); +} + +/* Argument - ns=0;i=7650 */ + +static UA_StatusCode function_namespace0_generated_194_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +UA_String *variablenode_ns_0_i_7650_variant_DataContents = UA_String_new(); +if (!variablenode_ns_0_i_7650_variant_DataContents) return UA_STATUSCODE_BADOUTOFMEMORY; +UA_String_init(variablenode_ns_0_i_7650_variant_DataContents); +*variablenode_ns_0_i_7650_variant_DataContents = UA_STRING_ALLOC("Argument"); +UA_Variant_setScalar(&attr.value, variablenode_ns_0_i_7650_variant_DataContents, &UA_TYPES[UA_TYPES_STRING]); +attr.displayName = UA_LOCALIZEDTEXT("", "Argument"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 7650LU), +UA_NODEID_NUMERIC(ns[0], 7617LU), +UA_NODEID_NUMERIC(ns[0], 47LU), +UA_QUALIFIEDNAME(ns[0], "Argument"), +UA_NODEID_NUMERIC(ns[0], 69LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +UA_String_delete(variablenode_ns_0_i_7650_variant_DataContents); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 7650LU), UA_NODEID_NUMERIC(ns[0], 39LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 298LU), false); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_194_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 7650LU) +); +} + +/* DictionaryFragment - ns=0;i=105 */ + +static UA_StatusCode function_namespace0_generated_195_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 15LU); +attr.displayName = UA_LOCALIZEDTEXT("", "DictionaryFragment"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 105LU), +UA_NODEID_NUMERIC(ns[0], 69LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "DictionaryFragment"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 105LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 80LU), true); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_195_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 105LU) +); +} + +/* DataTypeVersion - ns=0;i=104 */ + +static UA_StatusCode function_namespace0_generated_196_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_VariableAttributes attr = UA_VariableAttributes_default; +attr.minimumSamplingInterval = 0.000000; +attr.userAccessLevel = 1; +attr.accessLevel = 1; +/* Value rank inherited */ +attr.valueRank = -1; +attr.dataType = UA_NODEID_NUMERIC(ns[0], 12LU); +attr.displayName = UA_LOCALIZEDTEXT("", "DataTypeVersion"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_VARIABLE, +UA_NODEID_NUMERIC(ns[0], 104LU), +UA_NODEID_NUMERIC(ns[0], 69LU), +UA_NODEID_NUMERIC(ns[0], 46LU), +UA_QUALIFIEDNAME(ns[0], "DataTypeVersion"), +UA_NODEID_NUMERIC(ns[0], 68LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES],NULL, NULL); +retVal |= UA_Server_addReference(server, UA_NODEID_NUMERIC(ns[0], 104LU), UA_NODEID_NUMERIC(ns[0], 37LU), UA_EXPANDEDNODEID_NUMERIC(ns[0], 80LU), true); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_196_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 104LU) +); +} + +/* Default XML - ns=0;i=3063 */ + +static UA_StatusCode function_namespace0_generated_197_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Default XML"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 3063LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Default XML"), +UA_NODEID_NUMERIC(ns[0], 58LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_197_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3063LU) +); +} + +/* Default Binary - ns=0;i=3062 */ + +static UA_StatusCode function_namespace0_generated_198_begin(UA_Server *server, UA_UInt16* ns) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +UA_ObjectAttributes attr = UA_ObjectAttributes_default; +attr.displayName = UA_LOCALIZEDTEXT("", "Default Binary"); +retVal |= UA_Server_addNode_begin(server, UA_NODECLASS_OBJECT, +UA_NODEID_NUMERIC(ns[0], 3062LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_NODEID_NUMERIC(ns[0], 0LU), +UA_QUALIFIEDNAME(ns[0], "Default Binary"), +UA_NODEID_NUMERIC(ns[0], 58LU), +(const UA_NodeAttributes*)&attr, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES],NULL, NULL); +return retVal; +} + +static UA_StatusCode function_namespace0_generated_198_finish(UA_Server *server, UA_UInt16* ns) { +return UA_Server_addNode_finish(server, +UA_NODEID_NUMERIC(ns[0], 3062LU) +); +} + +UA_StatusCode namespace0_generated(UA_Server *server) { +UA_StatusCode retVal = UA_STATUSCODE_GOOD; +/* Use namespace ids generated by the server */ +UA_UInt16 ns[1]; +ns[0] = UA_Server_addNamespace(server, "http://opcfoundation.org/UA/"); + +/* Load custom datatype definitions into the server */ +if((retVal = function_namespace0_generated_0_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_0_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_1_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_1_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_2_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_2_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_3_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_3_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_4_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_4_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_5_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_5_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_6_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_7_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_8_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_9_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_10_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_11_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_12_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_13_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_14_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_15_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_16_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_17_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_18_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_19_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_20_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_21_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_22_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_23_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_24_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_25_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_26_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_27_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_28_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_29_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_30_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_31_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_32_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_33_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_34_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_35_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_36_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_37_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_38_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_39_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_40_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_41_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_42_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_43_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_44_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_45_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_46_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_47_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_48_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_49_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_50_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_51_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_52_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_53_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_54_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_55_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_56_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_57_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_58_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_59_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_60_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_61_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_62_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_63_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_64_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_65_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_66_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_67_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_68_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_69_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_70_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_71_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_72_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_73_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_74_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_75_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_76_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_77_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_78_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_79_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_80_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_81_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_82_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_83_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_84_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_85_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_86_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_87_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_88_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_89_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_90_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_91_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_92_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_93_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_94_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_95_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_96_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_97_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_98_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_99_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_100_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_101_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_102_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_103_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_104_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_105_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_106_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_107_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_108_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_109_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_110_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_111_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_112_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_113_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_114_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_115_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_116_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_117_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_118_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_119_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_120_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_121_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_122_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_123_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_124_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_125_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_126_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_127_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_128_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_129_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_130_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_131_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_132_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_133_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_134_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_135_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_136_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_137_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_138_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_139_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_140_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_141_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_142_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_143_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_144_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_145_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_146_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_147_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_148_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_149_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_150_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_151_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_152_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_153_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_154_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_155_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_156_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_157_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_158_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_159_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_160_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_161_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_162_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_163_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_164_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_165_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_166_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_167_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_168_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_169_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_170_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_171_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_172_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_173_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_174_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_175_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_176_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_177_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_178_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_179_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_180_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_181_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_182_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_183_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_184_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_185_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_186_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_187_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_188_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_189_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_190_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_191_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_192_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_193_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_194_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_195_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_196_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_197_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_198_begin(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_198_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_197_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_196_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_195_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_194_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_193_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_192_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_191_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_190_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_189_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_188_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_187_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_186_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_185_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_184_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_183_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_182_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_181_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_180_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_179_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_178_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_177_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_176_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_175_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_174_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_173_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_172_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_171_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_170_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_169_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_168_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_167_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_166_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_165_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_164_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_163_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_162_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_161_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_160_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_159_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_158_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_157_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_156_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_155_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_154_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_153_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_152_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_151_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_150_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_149_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_148_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_147_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_146_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_145_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_144_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_143_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_142_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_141_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_140_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_139_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_138_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_137_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_136_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_135_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_134_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_133_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_132_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_131_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_130_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_129_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_128_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_127_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_126_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_125_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_124_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_123_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_122_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_121_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_120_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_119_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_118_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_117_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_116_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_115_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_114_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_113_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_112_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_111_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_110_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_109_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_108_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_107_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_106_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_105_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_104_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_103_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_102_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_101_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_100_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_99_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_98_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_97_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_96_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_95_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_94_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_93_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_92_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_91_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_90_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_89_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_88_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_87_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_86_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_85_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_84_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_83_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_82_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_81_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_80_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_79_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_78_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_77_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_76_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_75_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_74_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_73_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_72_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_71_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_70_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_69_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_68_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_67_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_66_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_65_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_64_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_63_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_62_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_61_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_60_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_59_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_58_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_57_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_56_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_55_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_54_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_53_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_52_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_51_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_50_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_49_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_48_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_47_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_46_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_45_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_44_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_43_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_42_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_41_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_40_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_39_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_38_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_37_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_36_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_35_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_34_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_33_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_32_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_31_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_30_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_29_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_28_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_27_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_26_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_25_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_24_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_23_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_22_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_21_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_20_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_19_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_18_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_17_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_16_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_15_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_14_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_13_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_12_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_11_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_10_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_9_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_8_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_7_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +if((retVal = function_namespace0_generated_6_finish(server, ns)) != UA_STATUSCODE_GOOD) return retVal; +return retVal; +} + +/**** amalgamated original file "/src/ua_types_lex.c" ****/ + +/* Generated by re2c 1.1.1 */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * + */ + + +/* Lexing and parsing of builtin data types. These are helper functions that not + * required by the SDK internally. But they are useful for users who want to use + * standard-specified humand readable encodings for NodeIds, etc. + * + * This compilation unit uses the re2c lexer generator. The final C source is + * generated with the following script: + * + * re2c -i --no-generation-date ua_types_lex.re > ua_types_lex.c + * + * In order that users of the SDK don't need to install re2c, always commit a + * recent ua_types_lex.c if changes are made to the lexer. */ + +#define YYCURSOR pos +#define YYMARKER context.marker +#define YYPEEK() (YYCURSOR < end) ? *YYCURSOR : 0 /* The lexer sees a stream of + * \0 when the input ends*/ +#define YYSKIP() ++YYCURSOR; +#define YYBACKUP() YYMARKER = YYCURSOR +#define YYRESTORE() YYCURSOR = YYMARKER +#define YYSTAGP(t) t = YYCURSOR +#define YYSTAGN(t) t = NULL + +typedef struct { + const char *marker; + const char *yyt1;const char *yyt2;const char *yyt3;const char *yyt4;const char *yyt5; +} LexContext; + + + +static UA_StatusCode +parse_guid(UA_Guid *guid, const UA_Byte *s, const UA_Byte *e) { + size_t len = (size_t)(e - s); + if(len != 36 || s[8] != '-' || s[13] != '-' || s[23] != '-') + return UA_STATUSCODE_BADINTERNALERROR; + + UA_UInt32 tmp; + if(UA_readNumberWithBase(s, 8, &tmp, 16) != 8) + return UA_STATUSCODE_BADINTERNALERROR; + guid->data1 = tmp; + + if(UA_readNumberWithBase(&s[9], 4, &tmp, 16) != 4) + return UA_STATUSCODE_BADINTERNALERROR; + guid->data2 = (UA_UInt16)tmp; + + if(UA_readNumberWithBase(&s[14], 4, &tmp, 16) != 4) + return UA_STATUSCODE_BADINTERNALERROR; + guid->data3 = (UA_UInt16)tmp; + + if(UA_readNumberWithBase(&s[19], 2, &tmp, 16) != 2) + return UA_STATUSCODE_BADINTERNALERROR; + guid->data4[0] = (UA_Byte)tmp; + + if(UA_readNumberWithBase(&s[21], 2, &tmp, 16) != 2) + return UA_STATUSCODE_BADINTERNALERROR; + guid->data4[1] = (UA_Byte)tmp; + + for(size_t pos = 2, spos = 24; pos < 8; pos++, spos += 2) { + if(UA_readNumberWithBase(&s[spos], 2, &tmp, 16) != 2) + return UA_STATUSCODE_BADINTERNALERROR; + guid->data4[pos] = (UA_Byte)tmp; + } + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Guid_parse(UA_Guid *guid, const UA_String str) { + UA_StatusCode res = parse_guid(guid, str.data, str.data + str.length); + if(res != UA_STATUSCODE_GOOD) + *guid = UA_GUID_NULL; + return res; +} + +static UA_StatusCode +parse_nodeid_body(UA_NodeId *id, const char *body, const char *end) { + size_t len = (size_t)(end - (body+2)); + UA_StatusCode res = UA_STATUSCODE_GOOD; + switch(*body) { + case 'i': { + if(UA_readNumber((const UA_Byte*)body+2, len, &id->identifier.numeric) != len) + return UA_STATUSCODE_BADINTERNALERROR; + id->identifierType = UA_NODEIDTYPE_NUMERIC; + break; + } + case 's': { + UA_String tmpstr; + tmpstr.data = (UA_Byte*)(uintptr_t)body+2; + tmpstr.length = len; + res = UA_String_copy(&tmpstr, &id->identifier.string); + if(res != UA_STATUSCODE_GOOD) + break; + id->identifierType = UA_NODEIDTYPE_STRING; + break; + } + case 'g': + res = parse_guid(&id->identifier.guid, (const UA_Byte*)body+2, (const UA_Byte*)end); + if(res == UA_STATUSCODE_GOOD) + id->identifierType = UA_NODEIDTYPE_GUID; + break; + case 'b': + id->identifier.byteString.data = + UA_unbase64((const unsigned char*)body+2, len, + &id->identifier.byteString.length); + if(!id->identifier.byteString.data && len > 0) + return UA_STATUSCODE_BADINTERNALERROR; + id->identifierType = UA_NODEIDTYPE_BYTESTRING; + break; + default: + return UA_STATUSCODE_BADINTERNALERROR; + } + return res; +} + +static UA_StatusCode +parse_nodeid(UA_NodeId *id, const char *pos, const char *end) { + *id = UA_NODEID_NULL; /* Reset the NodeId */ + LexContext context; + memset(&context, 0, sizeof(LexContext)); + const char *ns = NULL, *nse= NULL; + + +{ + char yych; + yych = YYPEEK (); + switch (yych) { + case 'b': + case 'g': + case 'i': + case 's': + YYSTAGN (context.yyt1); + YYSTAGN (context.yyt2); + goto yy4; + case 'n': goto yy5; + default: goto yy2; + } +yy2: + YYSKIP (); +yy3: + { (void)pos; return UA_STATUSCODE_BADINTERNALERROR; } +yy4: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy6; + default: goto yy3; + } +yy5: + YYSKIP (); + YYBACKUP (); + yych = YYPEEK (); + switch (yych) { + case 's': goto yy8; + default: goto yy3; + } +yy6: + YYSKIP (); + ns = context.yyt1; + nse = context.yyt2; + { + (void)pos; // Get rid of a dead store clang-analyzer warning + if(ns) { + UA_UInt32 tmp; + size_t len = (size_t)(nse - ns); + if(UA_readNumber((const UA_Byte*)ns, len, &tmp) != len) + return UA_STATUSCODE_BADINTERNALERROR; + id->namespaceIndex = (UA_UInt16)tmp; + } + + // From the current position until the end + return parse_nodeid_body(id, &pos[-2], end); + } +yy8: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy10; + default: goto yy9; + } +yy9: + YYRESTORE (); + goto yy3; +yy10: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + YYSTAGP (context.yyt1); + goto yy11; + default: goto yy9; + } +yy11: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': goto yy11; + case ';': + YYSTAGP (context.yyt2); + goto yy13; + default: goto yy9; + } +yy13: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 'b': + case 'g': + case 'i': + case 's': goto yy14; + default: goto yy9; + } +yy14: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy6; + default: goto yy9; + } +} + +} + +UA_StatusCode +UA_NodeId_parse(UA_NodeId *id, const UA_String str) { + UA_StatusCode res = + parse_nodeid(id, (const char*)str.data, (const char*)str.data+str.length); + if(res != UA_STATUSCODE_GOOD) + UA_NodeId_clear(id); + return res; +} + +static UA_StatusCode +parse_expandednodeid(UA_ExpandedNodeId *id, const char *pos, const char *end) { + *id = UA_EXPANDEDNODEID_NULL; /* Reset the NodeId */ + LexContext context; + memset(&context, 0, sizeof(LexContext)); + const char *svr = NULL, *svre = NULL, *nsu = NULL, *ns = NULL, *body = NULL; + + +{ + char yych; + yych = YYPEEK (); + switch (yych) { + case 'b': + case 'g': + case 'i': + YYSTAGN (context.yyt1); + YYSTAGN (context.yyt2); + YYSTAGN (context.yyt3); + YYSTAGP (context.yyt4); + YYSTAGN (context.yyt5); + goto yy19; + case 'n': + YYSTAGN (context.yyt1); + YYSTAGN (context.yyt2); + goto yy20; + case 's': + YYSTAGN (context.yyt1); + YYSTAGN (context.yyt2); + YYSTAGN (context.yyt3); + YYSTAGP (context.yyt4); + YYSTAGN (context.yyt5); + goto yy21; + default: goto yy17; + } +yy17: + YYSKIP (); +yy18: + { (void)pos; return UA_STATUSCODE_BADINTERNALERROR; } +yy19: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy22; + default: goto yy18; + } +yy20: + YYSKIP (); + YYBACKUP (); + yych = YYPEEK (); + switch (yych) { + case 's': goto yy24; + default: goto yy18; + } +yy21: + YYSKIP (); + YYBACKUP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy22; + case 'v': goto yy26; + default: goto yy18; + } +yy22: + YYSKIP (); + svr = context.yyt1; + svre = context.yyt2; + ns = context.yyt3; + nsu = context.yyt5; + body = context.yyt4; + { + (void)pos; // Get rid of a dead store clang-analyzer warning + if(svr) { + size_t len = (size_t)((svre) - svr); + if(UA_readNumber((const UA_Byte*)svr, len, &id->serverIndex) != len) + return UA_STATUSCODE_BADINTERNALERROR; + } + + if(nsu) { + size_t len = (size_t)((body-1) - nsu); + UA_String nsuri; + nsuri.data = (UA_Byte*)(uintptr_t)nsu; + nsuri.length = len; + UA_StatusCode res = UA_String_copy(&nsuri, &id->namespaceUri); + if(res != UA_STATUSCODE_GOOD) + return res; + } else if(ns) { + UA_UInt32 tmp; + size_t len = (size_t)((body-1) - ns); + if(UA_readNumber((const UA_Byte*)ns, len, &tmp) != len) + return UA_STATUSCODE_BADINTERNALERROR; + id->nodeId.namespaceIndex = (UA_UInt16)tmp; + } + + // From the current position until the end + return parse_nodeid_body(&id->nodeId, &pos[-2], end); + } +yy24: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy27; + case 'u': goto yy28; + default: goto yy25; + } +yy25: + YYRESTORE (); + goto yy18; +yy26: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 'r': goto yy29; + default: goto yy25; + } +yy27: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + YYSTAGP (context.yyt3); + goto yy30; + default: goto yy25; + } +yy28: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy32; + default: goto yy25; + } +yy29: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy33; + default: goto yy25; + } +yy30: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': goto yy30; + case ';': goto yy34; + default: goto yy25; + } +yy32: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '\n': goto yy25; + case ';': + YYSTAGP (context.yyt5); + goto yy37; + default: + YYSTAGP (context.yyt5); + goto yy35; + } +yy33: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + YYSTAGP (context.yyt1); + goto yy38; + default: goto yy25; + } +yy34: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 'b': + case 'g': + case 'i': + case 's': + YYSTAGP (context.yyt4); + YYSTAGN (context.yyt5); + goto yy40; + default: goto yy25; + } +yy35: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '\n': goto yy25; + case ';': goto yy37; + default: goto yy35; + } +yy37: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 'b': + case 'g': + case 'i': + case 's': + YYSTAGN (context.yyt3); + YYSTAGP (context.yyt4); + goto yy40; + default: goto yy25; + } +yy38: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': goto yy38; + case ';': + YYSTAGP (context.yyt2); + goto yy41; + default: goto yy25; + } +yy40: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case '=': goto yy22; + default: goto yy25; + } +yy41: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 'b': + case 'g': + case 'i': + case 's': + YYSTAGN (context.yyt3); + YYSTAGP (context.yyt4); + YYSTAGN (context.yyt5); + goto yy40; + case 'n': goto yy42; + default: goto yy25; + } +yy42: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 's': goto yy24; + default: goto yy25; + } +} + +} + +UA_StatusCode +UA_ExpandedNodeId_parse(UA_ExpandedNodeId *id, const UA_String str) { + UA_StatusCode res = + parse_expandednodeid(id, (const char*)str.data, (const char*)str.data+str.length); + if(res != UA_STATUSCODE_GOOD) + UA_ExpandedNodeId_clear(id); + return res; +} + +static UA_StatusCode +relativepath_addelem(UA_RelativePath *rp, UA_RelativePathElement *el) { + /* Allocate memory */ + UA_RelativePathElement *newArray = (UA_RelativePathElement*) + UA_realloc(rp->elements, sizeof(UA_RelativePathElement) * (rp->elementsSize + 1)); + if(!newArray) + return UA_STATUSCODE_BADOUTOFMEMORY; + rp->elements = newArray; + + /* Move to the target */ + rp->elements[rp->elementsSize] = *el; + rp->elementsSize++; + return UA_STATUSCODE_GOOD; +} + +/* Parse name string with '&' as the escape character */ +static UA_StatusCode +parse_refpath_qn_name(UA_QualifiedName *qn, const char **pos, const char *end) { + /* Allocate the max length the name can have */ + size_t maxlen = (size_t)(end - *pos); + if(maxlen == 0) { + qn->name.data = (UA_Byte*)UA_EMPTY_ARRAY_SENTINEL; + return UA_STATUSCODE_GOOD; + } + char *name = (char*)UA_malloc(maxlen); + if(!name) + return UA_STATUSCODE_BADOUTOFMEMORY; + + size_t index = 0; + for(; *pos < end; (*pos)++) { + char c = **pos; + /* Unescaped special characer: The end of the QualifiedName */ + if(c == '/' || c == '.' || c == '<' || c == '>' || + c == ':' || c == '#' || c == '!') + break; + + /* Escaped character */ + if(c == '&') { + (*pos)++; + if(*pos >= end || + (**pos != '/' && **pos != '.' && **pos != '<' && **pos != '>' && + **pos != ':' && **pos != '#' && **pos != '!' && **pos != '&')) { + UA_free(name); + return UA_STATUSCODE_BADINTERNALERROR; + } + c = **pos; + } + + /* Unescaped normal character */ + name[index] = c; + index++; + } + + if(index > 0) { + qn->name.data = (UA_Byte*)name; + qn->name.length = index; + } else { + qn->name.data = (UA_Byte*)UA_EMPTY_ARRAY_SENTINEL; + UA_free(name); + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +parse_refpath_qn(UA_QualifiedName *qn, const char *pos, const char *end) { + LexContext context; + memset(&context, 0, sizeof(LexContext)); + const char *ns = NULL, *nse = NULL; + UA_QualifiedName_init(qn); + + +{ + char yych; + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + YYSTAGP (context.yyt1); + goto yy47; + default: goto yy45; + } +yy45: + YYSKIP (); +yy46: + { pos--; goto parse_qn_name; } +yy47: + YYSKIP (); + YYBACKUP (); + yych = YYPEEK (); + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case ':': goto yy49; + default: goto yy46; + } +yy48: + YYSKIP (); + yych = YYPEEK (); +yy49: + switch (yych) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': goto yy48; + case ':': + YYSTAGP (context.yyt2); + goto yy51; + default: goto yy50; + } +yy50: + YYRESTORE (); + goto yy46; +yy51: + YYSKIP (); + ns = context.yyt1; + nse = context.yyt2; + { + UA_UInt32 tmp; + size_t len = (size_t)(nse - ns); + if(UA_readNumber((const UA_Byte*)ns, len, &tmp) != len) + return UA_STATUSCODE_BADINTERNALERROR; + qn->namespaceIndex = (UA_UInt16)tmp; + goto parse_qn_name; + } +} + + + parse_qn_name: + return parse_refpath_qn_name(qn, &pos, end); +} + +/* List of well-known ReferenceTypes that don't require lookup in the server */ + +typedef struct { + char *browseName; + UA_UInt32 identifier; +} RefTypeNames; + +#define KNOWNREFTYPES 17 +static const RefTypeNames knownRefTypes[KNOWNREFTYPES] = { + {"References", UA_NS0ID_REFERENCES}, + {"HierachicalReferences", UA_NS0ID_HIERARCHICALREFERENCES}, + {"NonHierachicalReferences", UA_NS0ID_NONHIERARCHICALREFERENCES}, + {"HasChild", UA_NS0ID_HASCHILD}, + {"Aggregates", UA_NS0ID_AGGREGATES}, + {"HasComponent", UA_NS0ID_HASCOMPONENT}, + {"HasProperty", UA_NS0ID_HASPROPERTY}, + {"HasOrderedComponent", UA_NS0ID_HASORDEREDCOMPONENT}, + {"HasSubtype", UA_NS0ID_HASSUBTYPE}, + {"Organizes", UA_NS0ID_ORGANIZES}, + {"HasModellingRule", UA_NS0ID_HASMODELLINGRULE}, + {"HasTypeDefinition", UA_NS0ID_HASTYPEDEFINITION}, + {"HasEncoding", UA_NS0ID_HASENCODING}, + {"GeneratesEvent", UA_NS0ID_GENERATESEVENT}, + {"AlwaysGeneratesEvent", UA_NS0ID_ALWAYSGENERATESEVENT}, + {"HasEventSource", UA_NS0ID_HASEVENTSOURCE}, + {"HasNotifier", UA_NS0ID_HASNOTIFIER} +}; + +static UA_StatusCode +lookup_reftype(UA_NodeId *refTypeId, UA_QualifiedName *qn) { + if(qn->namespaceIndex != 0) + return UA_STATUSCODE_BADNOTFOUND; + + for(size_t i = 0; i < KNOWNREFTYPES; i++) { + UA_String tmp = UA_STRING(knownRefTypes[i].browseName); + if(UA_String_equal(&qn->name, &tmp)) { + *refTypeId = UA_NODEID_NUMERIC(0, knownRefTypes[i].identifier); + return UA_STATUSCODE_GOOD; + } + } + + return UA_STATUSCODE_BADNOTFOUND; +} + +static UA_StatusCode +parse_relativepath(UA_RelativePath *rp, const char *pos, const char *end) { + LexContext context; + memset(&context, 0, sizeof(LexContext)); + const char *begin = NULL, *finish = NULL; + UA_StatusCode res = UA_STATUSCODE_GOOD; + UA_RelativePath_init(rp); /* Reset the BrowsePath */ + + /* Add one element to the path in every iteration */ + UA_RelativePathElement current; + loop: + UA_RelativePathElement_init(¤t); + current.includeSubtypes = true; /* Follow subtypes by default */ + + /* Get the ReferenceType and its modifiers */ + +{ + char yych; + unsigned int yyaccept = 0; + yych = YYPEEK (); + switch (yych) { + case 0x00: goto yy55; + case '.': goto yy59; + case '/': goto yy61; + case '<': goto yy63; + default: goto yy57; + } +yy55: + YYSKIP (); + { (void)pos; return UA_STATUSCODE_GOOD; } +yy57: + YYSKIP (); +yy58: + { (void)pos; return UA_STATUSCODE_BADINTERNALERROR; } +yy59: + YYSKIP (); + { + current.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_AGGREGATES); + goto reftype_target; + } +yy61: + YYSKIP (); + { + current.referenceTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_HIERARCHICALREFERENCES); + goto reftype_target; + } +yy63: + yyaccept = 0; + YYSKIP (); + YYBACKUP (); + yych = YYPEEK (); + switch (yych) { + case 0x00: + case '>': goto yy58; + case '&': + YYSTAGP (context.yyt1); + goto yy67; + default: + YYSTAGP (context.yyt1); + goto yy64; + } +yy64: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 0x00: goto yy66; + case '&': goto yy67; + case '>': + YYSTAGP (context.yyt2); + goto yy69; + default: goto yy64; + } +yy66: + YYRESTORE (); + if (yyaccept == 0) { + goto yy58; + } else { + goto yy70; + } +yy67: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 0x00: goto yy66; + case '&': goto yy67; + case '>': + YYSTAGP (context.yyt2); + goto yy71; + default: goto yy64; + } +yy69: + YYSKIP (); +yy70: + begin = context.yyt1; + finish = context.yyt2; + { + for(; begin < finish; begin++) { + if(*begin== '#') + current.includeSubtypes = false; + else if(*begin == '!') + current.isInverse = true; + else + break; + } + UA_QualifiedName refqn; + res |= parse_refpath_qn(&refqn, begin, finish); + res |= lookup_reftype(¤t.referenceTypeId, &refqn); + UA_QualifiedName_clear(&refqn); + goto reftype_target; + } +yy71: + yyaccept = 1; + YYSKIP (); + YYBACKUP (); + yych = YYPEEK (); + switch (yych) { + case 0x00: goto yy70; + case '&': goto yy67; + case '>': + YYSTAGP (context.yyt2); + goto yy69; + default: goto yy64; + } +} + + + /* Get the TargetName component */ + reftype_target: + if(res != UA_STATUSCODE_GOOD) + return res; + + +{ + char yych; + yych = YYPEEK (); + switch (yych) { + case 0x00: + case '.': + case '/': + case '<': goto yy74; + case '&': + YYSTAGP (context.yyt1); + goto yy79; + default: + YYSTAGP (context.yyt1); + goto yy76; + } +yy74: + YYSKIP (); + { pos--; goto add_element; } +yy76: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 0x00: + case '.': + case '/': + case '<': goto yy78; + case '&': goto yy79; + default: goto yy76; + } +yy78: + begin = context.yyt1; + { + res = parse_refpath_qn(¤t.targetName, begin, pos); + goto add_element; + } +yy79: + YYSKIP (); + yych = YYPEEK (); + switch (yych) { + case 0x00: goto yy78; + case '&': goto yy79; + default: goto yy76; + } +} + + + /* Add the current element to the path and continue to the next element */ + add_element: + res |= relativepath_addelem(rp, ¤t); + if(res != UA_STATUSCODE_GOOD) { + UA_RelativePathElement_clear(¤t); + return res; + } + goto loop; +} + +UA_StatusCode +UA_RelativePath_parse(UA_RelativePath *rp, const UA_String str) { + UA_StatusCode res = + parse_relativepath(rp, (const char*)str.data, (const char*)str.data+str.length); + if(res != UA_STATUSCODE_GOOD) + UA_RelativePath_clear(rp); + return res; +} + +/**** amalgamated original file "/src/server/ua_subscription.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015 (c) Chris Iatrou + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2017-2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2015 (c) Joakim L. Gilje + * Copyright 2016-2017 (c) Florian Palm + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) frax2222 + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Ari Breitkreuz, fortiss GmbH + * Copyright 2017 (c) Mattias Bornhager + * Copyright 2018 (c) Hilscher Gesellschaft für Systemautomation mbH (Author: Martin Lang) + * Copyright 2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + +#ifdef UA_ENABLE_SUBSCRIPTIONS /* conditional compilation */ + +#define UA_MAX_RETRANSMISSIONQUEUESIZE 256 + +UA_Subscription * +UA_Subscription_new() { + /* Allocate the memory */ + UA_Subscription *newSub = (UA_Subscription*)UA_calloc(1, sizeof(UA_Subscription)); + if(!newSub) + return NULL; + + /* The first publish response is sent immediately */ + newSub->state = UA_SUBSCRIPTIONSTATE_NORMAL; + + /* Even if the first publish response is a keepalive the sequence number is 1. + * This can happen by a subscription without a monitored item (see CTT test scripts). */ + newSub->nextSequenceNumber = 1; + + TAILQ_INIT(&newSub->retransmissionQueue); + TAILQ_INIT(&newSub->notificationQueue); + return newSub; +} + +void +UA_Subscription_delete(UA_Server *server, UA_Subscription *sub) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Unregister the publish callback */ + Subscription_unregisterPublishCallback(server, sub); + + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, sub, "Subscription deleted"); + + /* Detach from the session if necessary */ + if(sub->session) + UA_Session_detachSubscription(server, sub->session, sub); + + /* Remove from the server if not previously registered */ + if(sub->serverListEntry.le_prev) { + LIST_REMOVE(sub, serverListEntry); + UA_assert(server->subscriptionsSize > 0); + server->subscriptionsSize--; + } + + /* Delete monitored Items */ + UA_assert(server->monitoredItemsSize >= sub->monitoredItemsSize); + UA_MonitoredItem *mon, *tmp_mon; + LIST_FOREACH_SAFE(mon, &sub->monitoredItems, listEntry, tmp_mon) { + UA_MonitoredItem_delete(server, mon); + } + UA_assert(sub->monitoredItemsSize == 0); + + /* Delete Retransmission Queue */ + UA_NotificationMessageEntry *nme, *nme_tmp; + TAILQ_FOREACH_SAFE(nme, &sub->retransmissionQueue, listEntry, nme_tmp) { + TAILQ_REMOVE(&sub->retransmissionQueue, nme, listEntry); + UA_NotificationMessage_clear(&nme->message); + UA_free(nme); + if(sub->session) + --sub->session->totalRetransmissionQueueSize; + --sub->retransmissionQueueSize; + } + UA_assert(sub->retransmissionQueueSize == 0); + + /* Add a delayed callback to remove the Subscription when the current jobs + * have completed. Pointers to the subscription may still exist upwards in + * the call stack. */ + sub->delayedFreePointers.callback = NULL; + sub->delayedFreePointers.application = server; + sub->delayedFreePointers.data = NULL; + sub->delayedFreePointers.nextTime = UA_DateTime_nowMonotonic() + 1; + sub->delayedFreePointers.interval = 0; /* Remove the structure */ + UA_Timer_addTimerEntry(&server->timer, &sub->delayedFreePointers, NULL); +} + +UA_MonitoredItem * +UA_Subscription_getMonitoredItem(UA_Subscription *sub, UA_UInt32 monitoredItemId) { + UA_MonitoredItem *mon; + LIST_FOREACH(mon, &sub->monitoredItems, listEntry) { + if(mon->monitoredItemId == monitoredItemId) + break; + } + return mon; +} + +static void +removeOldestRetransmissionMessageFromSub(UA_Subscription *sub) { + UA_NotificationMessageEntry *oldestEntry = + TAILQ_LAST(&sub->retransmissionQueue, NotificationMessageQueue); + TAILQ_REMOVE(&sub->retransmissionQueue, oldestEntry, listEntry); + UA_NotificationMessage_clear(&oldestEntry->message); + UA_free(oldestEntry); + --sub->retransmissionQueueSize; + if(sub->session) + --sub->session->totalRetransmissionQueueSize; +} + +static void +removeOldestRetransmissionMessageFromSession(UA_Session *session) { + UA_NotificationMessageEntry *oldestEntry = NULL; + UA_Subscription *oldestSub = NULL; + UA_Subscription *sub; + TAILQ_FOREACH(sub, &session->subscriptions, sessionListEntry) { + UA_NotificationMessageEntry *first = + TAILQ_LAST(&sub->retransmissionQueue, NotificationMessageQueue); + if(!first) + continue; + if(!oldestEntry || oldestEntry->message.publishTime > first->message.publishTime) { + oldestEntry = first; + oldestSub = sub; + } + } + UA_assert(oldestEntry); + UA_assert(oldestSub); + + removeOldestRetransmissionMessageFromSub(oldestSub); +} + +static void +UA_Subscription_addRetransmissionMessage(UA_Server *server, UA_Subscription *sub, + UA_NotificationMessageEntry *entry) { + /* Release the oldest entry if there is not enough space */ + UA_Session *session = sub->session; + if(sub->retransmissionQueueSize >= UA_MAX_RETRANSMISSIONQUEUESIZE) { + removeOldestRetransmissionMessageFromSub(sub); + } else if(session && server->config.maxRetransmissionQueueSize > 0 && + session->totalRetransmissionQueueSize >= server->config.maxRetransmissionQueueSize) { + UA_LOG_WARNING_SUBSCRIPTION(&server->config.logger, sub, + "Retransmission queue overflow"); + removeOldestRetransmissionMessageFromSession(sub->session); + } + + /* Add entry */ + TAILQ_INSERT_TAIL(&sub->retransmissionQueue, entry, listEntry); + ++sub->retransmissionQueueSize; + if(session) + ++session->totalRetransmissionQueueSize; +} + +UA_StatusCode +UA_Subscription_removeRetransmissionMessage(UA_Subscription *sub, UA_UInt32 sequenceNumber) { + /* Find the retransmission message */ + UA_NotificationMessageEntry *entry; + TAILQ_FOREACH(entry, &sub->retransmissionQueue, listEntry) { + if(entry->message.sequenceNumber == sequenceNumber) + break; + } + if(!entry) + return UA_STATUSCODE_BADSEQUENCENUMBERUNKNOWN; + + /* Remove the retransmission message */ + TAILQ_REMOVE(&sub->retransmissionQueue, entry, listEntry); + --sub->retransmissionQueueSize; + UA_NotificationMessage_clear(&entry->message); + UA_free(entry); + + if(sub->session) + --sub->session->totalRetransmissionQueueSize; + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +prepareNotificationMessage(UA_Server *server, UA_Subscription *sub, + UA_NotificationMessage *message, size_t notifications) { + UA_assert(notifications > 0); + + /* Allocate an ExtensionObject for Event- and DataChange-Notifications. Also + * there can be StatusChange-Notifications. The standard says in Part 4, + * 7.2.1: + * + * If a Subscription contains MonitoredItems for events and data, this array + * should have not more than 2 elements. */ + message->notificationData = (UA_ExtensionObject*) + UA_Array_new(2, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); + if(!message->notificationData) + return UA_STATUSCODE_BADOUTOFMEMORY; + message->notificationDataSize = 2; + + /* Pre-allocate DataChangeNotifications */ + size_t notificationDataIdx = 0; + UA_DataChangeNotification *dcn = NULL; + size_t dcnPos = 0; /* How many DataChangeNotifications were moved into the list? */ + if(sub->dataChangeNotifications > 0) { + dcn = UA_DataChangeNotification_new(); + if(!dcn) { + UA_NotificationMessage_clear(message); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + UA_ExtensionObject_setValue(message->notificationData, dcn, + &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]); + size_t dcnSize = sub->dataChangeNotifications; + if(dcnSize > notifications) + dcnSize = notifications; + dcn->monitoredItems = (UA_MonitoredItemNotification*) + UA_Array_new(dcnSize, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]); + if(!dcn->monitoredItems) { + UA_NotificationMessage_clear(message); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + dcn->monitoredItemsSize = dcnSize; + notificationDataIdx++; + } + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + UA_EventNotificationList *enl = NULL; + size_t enlPos = 0; /* How many EventNotifications were moved into the list? */ + if(sub->eventNotifications > 0) { + enl = UA_EventNotificationList_new(); + if(!enl) { + UA_NotificationMessage_clear(message); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + UA_ExtensionObject_setValue(&message->notificationData[notificationDataIdx], + enl, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]); + size_t enlSize = sub->eventNotifications; + if(enlSize > notifications) + enlSize = notifications; + enl->events = (UA_EventFieldList*) + UA_Array_new(enlSize, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]); + if(!enl->events) { + UA_NotificationMessage_clear(message); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + enl->eventsSize = enlSize; + notificationDataIdx++; + } +#endif + + UA_assert(notificationDataIdx > 0); + message->notificationDataSize = notificationDataIdx; + + /* <-- The point of no return --> */ + + size_t totalNotifications = 0; /* How many notifications were moved to the response overall? */ + UA_Notification *notification, *notification_tmp; + TAILQ_FOREACH_SAFE(notification, &sub->notificationQueue, globalEntry, notification_tmp) { + if(totalNotifications >= notifications) + break; + + /* Move the content to the response */ + switch(notification->mon->itemToMonitor.attributeId) { +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + case UA_ATTRIBUTEID_EVENTNOTIFIER: + UA_assert(enl != NULL); /* Have at least one event notification */ + enl->events[enlPos] = notification->data.event; + UA_EventFieldList_init(¬ification->data.event); + enlPos++; + break; +#endif + default: + UA_assert(dcn != NULL); /* Have at least one change notification */ + dcn->monitoredItems[dcnPos] = notification->data.dataChange; + UA_DataValue_init(¬ification->data.dataChange.value); + dcnPos++; + break; + } + + /* If there are Notifications *before this one* in the MonitoredItem- + * local queue, remove all of them. These are earlier Notifications that + * are non-reporting. And we don't want them to show up after the + * current Notification has been sent out. */ + UA_Notification *prev; + while((prev = TAILQ_PREV(notification, NotificationQueue, localEntry))) { + UA_Notification_delete(prev); + } + + /* Delete the notification, remove from the queues and decrease the counters */ + UA_Notification_delete(notification); + + totalNotifications++; + } + + /* Set sizes */ + if(dcn) { + dcn->monitoredItemsSize = dcnPos; + if(dcnPos == 0) { + UA_free(dcn->monitoredItems); + dcn->monitoredItems = NULL; + } + } + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + if(enl) { + enl->eventsSize = enlPos; + if(enlPos == 0) { + UA_free(enl->events); + enl->events = NULL; + } + } +#endif + + return UA_STATUSCODE_GOOD; +} + +/* According to OPC Unified Architecture, Part 4 5.13.1.1 i) The value 0 is + * never used for the sequence number */ +static UA_UInt32 +UA_Subscription_nextSequenceNumber(UA_UInt32 sequenceNumber) { + UA_UInt32 nextSequenceNumber = sequenceNumber + 1; + if(nextSequenceNumber == 0) + nextSequenceNumber = 1; + return nextSequenceNumber; +} + +static void +publishCallback(UA_Server *server, UA_Subscription *sub) { + UA_LOCK(&server->serviceMutex); + sub->readyNotifications = sub->notificationQueueSize; + UA_Subscription_publish(server, sub); + UA_UNLOCK(&server->serviceMutex); +} + +static void +sendStatusChangeDelete(UA_Server *server, UA_Subscription *sub, + UA_PublishResponseEntry *pre) { + /* Cannot send out the StatusChange because no response is queued. + * Delete the Subscription without sending the StatusChange. */ + if(!pre) { + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "Cannot send the StatusChange notification. " + "Removing the subscription."); + UA_Subscription_delete(server, sub); + return; + } + + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "Sending out a StatusChange " + "notification and removing the subscription"); + + /* Populate the response */ + UA_PublishResponse *response = &pre->response; + + UA_StatusChangeNotification scn; + UA_StatusChangeNotification_init(&scn); + scn.status = sub->statusChange; + + UA_ExtensionObject notificationData; + UA_ExtensionObject_setValue(¬ificationData, &scn, + &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]); + + response->responseHeader.timestamp = UA_DateTime_now(); + response->notificationMessage.notificationData = ¬ificationData; + response->notificationMessage.notificationDataSize = 1; + response->subscriptionId = sub->subscriptionId; + response->notificationMessage.publishTime = response->responseHeader.timestamp; + response->notificationMessage.sequenceNumber = sub->nextSequenceNumber; + + /* Send the response */ + UA_assert(sub->session); /* Otherwise pre is NULL */ + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "Sending out a publish response"); + sendResponse(server, sub->session, sub->session->header.channel, pre->requestId, + (UA_Response *)response, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); + + /* Clean up */ + response->notificationMessage.notificationData = NULL; + response->notificationMessage.notificationDataSize = 0; + UA_PublishResponse_clear(&pre->response); + UA_free(pre); + + /* Delete the subscription */ + UA_Subscription_delete(server, sub); +} + +void +UA_Subscription_publish(UA_Server *server, UA_Subscription *sub) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, "Publish Callback"); + UA_assert(sub); + + /* Dequeue a response */ + UA_PublishResponseEntry *pre = NULL; + if(sub->session) + pre = UA_Session_dequeuePublishReq(sub->session); + + /* Update the LifetimeCounter */ + if(pre) { + sub->currentLifetimeCount = 0; + } else { + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "The publish queue is empty"); + ++sub->currentLifetimeCount; + if(sub->currentLifetimeCount > sub->lifeTimeCount) { + UA_LOG_WARNING_SUBSCRIPTION(&server->config.logger, sub, + "End of subscription lifetime"); + /* Set the StatusChange to delete the subscription. */ + sub->statusChange = UA_STATUSCODE_BADTIMEOUT; + } + } + + /* Send a StatusChange notification if possible and delete the + * Subscription */ + if(sub->statusChange != UA_STATUSCODE_GOOD) { + sendStatusChangeDelete(server, sub, pre); + return; + } + + /* If there are several late publish responses... */ + if(sub->readyNotifications > sub->notificationQueueSize) + sub->readyNotifications = sub->notificationQueueSize; + + /* Count the available notifications */ + UA_UInt32 notifications = (sub->publishingEnabled) ? sub->readyNotifications : 0; + UA_Boolean moreNotifications = false; + if(notifications > sub->notificationsPerPublish) { + notifications = sub->notificationsPerPublish; + moreNotifications = true; + } + + /* Return if no notifications and no keepalive */ + if(notifications == 0) { + ++sub->currentKeepAliveCount; + if(sub->currentKeepAliveCount < sub->maxKeepAliveCount) { + if(pre) + UA_Session_queuePublishReq(sub->session, pre, true); /* Re-enqueue */ + return; + } + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, "Sending a KeepAlive"); + } + + /* We want to send a response, but cannot. Either because there is no queued + * response or because the Subscription is detached from a Session or because + * the SecureChannel for the Session is closed. */ + if(!pre || !sub->session || !sub->session->header.channel) { + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "Want to send a publish response but cannot. " + "The subscription is late."); + sub->state = UA_SUBSCRIPTIONSTATE_LATE; + if(pre) + UA_Session_queuePublishReq(sub->session, pre, true); /* Re-enqueue */ + return; + } + + UA_assert(sub->session); /* Otherwise pre is NULL */ + + /* Prepare the response */ + UA_PublishResponse *response = &pre->response; + UA_NotificationMessage *message = &response->notificationMessage; + UA_NotificationMessageEntry *retransmission = NULL; + if(notifications > 0) { + if(server->config.enableRetransmissionQueue) { + /* Allocate the retransmission entry */ + retransmission = (UA_NotificationMessageEntry*) + UA_malloc(sizeof(UA_NotificationMessageEntry)); + if(!retransmission) { + UA_LOG_WARNING_SUBSCRIPTION(&server->config.logger, sub, + "Could not allocate memory for retransmission. " + "The subscription is late."); + sub->state = UA_SUBSCRIPTIONSTATE_LATE; + UA_Session_queuePublishReq(sub->session, pre, true); /* Re-enqueue */ + return; + } + } + + /* Prepare the response */ + UA_StatusCode retval = prepareNotificationMessage(server, sub, message, notifications); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING_SUBSCRIPTION(&server->config.logger, sub, + "Could not prepare the notification message. " + "The subscription is late."); + /* If the retransmission queue is enabled a retransmission message is allocated */ + if(retransmission) + UA_free(retransmission); + sub->state = UA_SUBSCRIPTIONSTATE_LATE; + UA_Session_queuePublishReq(sub->session, pre, true); /* Re-enqueue */ + return; + } + } + + /* <-- The point of no return --> */ + + /* Adjust the number of ready notifications */ + UA_assert(sub->readyNotifications >= notifications); + sub->readyNotifications -= notifications; + + /* Set up the response */ + response->responseHeader.timestamp = UA_DateTime_now(); + response->subscriptionId = sub->subscriptionId; + response->moreNotifications = moreNotifications; + message->publishTime = response->responseHeader.timestamp; + + /* Set sequence number to message. Started at 1 which is given during + * creating a new subscription. The 1 is required for initial publish + * response with or without an monitored item. */ + message->sequenceNumber = sub->nextSequenceNumber; + + if(notifications > 0) { + /* If the retransmission queue is enabled a retransmission message is + * allocated */ + if(retransmission) { + /* Put the notification message into the retransmission queue. This + * needs to be done here, so that the message itself is included in + * the available sequence numbers for acknowledgement. */ + retransmission->message = response->notificationMessage; + UA_Subscription_addRetransmissionMessage(server, sub, retransmission); + } + /* Only if a notification was created, the sequence number must be + * increased. For a keepalive the sequence number can be reused. */ + sub->nextSequenceNumber = UA_Subscription_nextSequenceNumber(sub->nextSequenceNumber); + } + + /* Get the available sequence numbers from the retransmission queue */ + UA_assert(sub->retransmissionQueueSize <= UA_MAX_RETRANSMISSIONQUEUESIZE); + UA_UInt32 seqNumbers[UA_MAX_RETRANSMISSIONQUEUESIZE]; + response->availableSequenceNumbers = seqNumbers; + response->availableSequenceNumbersSize = sub->retransmissionQueueSize; + size_t i = 0; + UA_NotificationMessageEntry *nme; + TAILQ_FOREACH(nme, &sub->retransmissionQueue, listEntry) { + response->availableSequenceNumbers[i] = nme->message.sequenceNumber; + ++i; + } + UA_assert(i == sub->retransmissionQueueSize); + + /* Send the response */ + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, "Sending out a publish response " + "with %" PRIu32 " notifications", notifications); + sendResponse(server, sub->session, sub->session->header.channel, pre->requestId, + (UA_Response*)response, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); + + /* Reset subscription state to normal */ + sub->state = UA_SUBSCRIPTIONSTATE_NORMAL; + sub->currentKeepAliveCount = 0; + + /* Free the response */ + if(retransmission) + /* NotificationMessage was moved into retransmission queue */ + UA_NotificationMessage_init(&response->notificationMessage); + response->availableSequenceNumbers = NULL; + response->availableSequenceNumbersSize = 0; + UA_PublishResponse_clear(&pre->response); + UA_free(pre); + + /* Repeat sending responses if there are more notifications to send */ + if(moreNotifications) + UA_Subscription_publish(server, sub); +} + +UA_Boolean +UA_Session_reachedPublishReqLimit(UA_Server *server, UA_Session *session) { + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Reached number of publish request limit"); + + /* Dequeue a response */ + UA_PublishResponseEntry *pre = UA_Session_dequeuePublishReq(session); + + /* Cannot publish without a response */ + if(!pre) { + UA_LOG_FATAL_SESSION(&server->config.logger, session, "No publish requests available"); + return false; + } + + /* <-- The point of no return --> */ + + UA_PublishResponse *response = &pre->response; + UA_NotificationMessage *message = &response->notificationMessage; + + /* Set up the response. Note that this response has no related subscription id */ + response->responseHeader.timestamp = UA_DateTime_now(); + response->responseHeader.serviceResult = UA_STATUSCODE_BADTOOMANYPUBLISHREQUESTS; + response->subscriptionId = 0; + response->moreNotifications = false; + message->publishTime = response->responseHeader.timestamp; + message->sequenceNumber = 0; + response->availableSequenceNumbersSize = 0; + + /* Send the response */ + UA_LOG_DEBUG_SESSION(&server->config.logger, session, + "Sending out a publish response triggered by too many publish requests"); + sendResponse(server, session, session->header.channel, pre->requestId, + (UA_Response*)response, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); + + /* Free the response */ + UA_Array_delete(response->results, response->resultsSize, &UA_TYPES[UA_TYPES_UINT32]); + UA_free(pre); /* no need for UA_PublishResponse_clear */ + + return true; +} + +UA_StatusCode +Subscription_registerPublishCallback(UA_Server *server, UA_Subscription *sub) { + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "Register subscription publishing callback"); + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(sub->publishCallbackId > 0) + return UA_STATUSCODE_GOOD; + + UA_StatusCode retval = + addRepeatedCallback(server, (UA_ServerCallback)publishCallback, + sub, sub->publishingInterval, &sub->publishCallbackId); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + UA_assert(sub->publishCallbackId > 0); + return UA_STATUSCODE_GOOD; +} + +void +Subscription_unregisterPublishCallback(UA_Server *server, UA_Subscription *sub) { + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "Unregister subscription publishing callback"); + + if(sub->publishCallbackId == 0) + return; + + removeCallback(server, sub->publishCallbackId); + sub->publishCallbackId = 0; +} + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +/**** amalgamated original file "/src/server/ua_subscription_monitoreditem.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Ari Breitkreuz, fortiss GmbH + * Copyright 2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2018 (c) Fabian Arndt, Root-Core + * Copyright 2020-2021 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + */ + + +#ifdef UA_ENABLE_SUBSCRIPTIONS /* conditional compilation */ + +/****************/ +/* Notification */ +/****************/ + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + +static const UA_NodeId eventQueueOverflowEventType = + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE}}; + +/* The specification states in Part 4 5.12.1.5 that an EventQueueOverflowEvent + * "is generated when the first Event has to be discarded [...] without + * discarding any other event". So only generate one for all deleted events. */ +static UA_StatusCode +createEventOverflowNotification(UA_Server *server, UA_Subscription *sub, + UA_MonitoredItem *mon) { + /* Avoid creating two adjacent overflow events */ + UA_Notification *indicator = NULL; + if(mon->parameters.discardOldest) { + indicator = TAILQ_FIRST(&mon->queue); + UA_assert(indicator); /* must exist */ + if(indicator->isOverflowEvent) + return UA_STATUSCODE_GOOD; + } else { + indicator = TAILQ_LAST(&mon->queue, NotificationQueue); + UA_assert(indicator); /* must exist */ + /* Skip the last element. It is the recently added notification that + * shall be kept. We know it is not an OverflowEvent. */ + UA_Notification *before = TAILQ_PREV(indicator, NotificationQueue, localEntry); + if(before && before->isOverflowEvent) + return UA_STATUSCODE_GOOD; + } + + /* A Notification is inserted into the queue which includes only the + * NodeId of the OverflowEventType. */ + + /* Allocate the notification */ + UA_Notification *overflowNotification = UA_Notification_new(); + if(!overflowNotification) + return UA_STATUSCODE_BADOUTOFMEMORY; + + /* Set the notification fields */ + overflowNotification->isOverflowEvent = true; + overflowNotification->mon = mon; + overflowNotification->data.event.clientHandle = mon->parameters.clientHandle; + overflowNotification->data.event.eventFields = UA_Variant_new(); + if(!overflowNotification->data.event.eventFields) { + UA_free(overflowNotification); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + overflowNotification->data.event.eventFieldsSize = 1; + UA_StatusCode retval = + UA_Variant_setScalarCopy(overflowNotification->data.event.eventFields, + &eventQueueOverflowEventType, &UA_TYPES[UA_TYPES_NODEID]); + if(retval != UA_STATUSCODE_GOOD) { + UA_Notification_delete(overflowNotification); + return retval; + } + + /* Insert before the removed notification. This is either first in the + * queue (if the oldest notification was removed) or before the new event + * that remains the last element of the queue. + * + * Ensure that the following is consistent with UA_Notification_enqueueMon + * and UA_Notification_enqueueSub! */ + TAILQ_INSERT_BEFORE(indicator, overflowNotification, localEntry); + ++mon->eventOverflows; + ++mon->queueSize; + + /* Test for consistency */ + UA_assert(mon->queueSize >= mon->eventOverflows); + UA_assert(mon->eventOverflows <= mon->queueSize - mon->eventOverflows + 1); + + if(TAILQ_NEXT(indicator, globalEntry) != UA_SUBSCRIPTION_QUEUE_SENTINEL) { + /* Insert just before the indicator */ + TAILQ_INSERT_BEFORE(indicator, overflowNotification, globalEntry); + } else { + /* The indicator was not reporting or not added yet. */ + if(!mon->parameters.discardOldest) { + /* Add last to the per-Subscription queue */ + TAILQ_INSERT_TAIL(&mon->subscription->notificationQueue, + overflowNotification, globalEntry); + } else { + /* Find the oldest reported element. Add before that. */ + while(indicator) { + indicator = TAILQ_PREV(indicator, NotificationQueue, localEntry); + if(!indicator) { + TAILQ_INSERT_TAIL(&mon->subscription->notificationQueue, + overflowNotification, globalEntry); + break; + } + if(TAILQ_NEXT(indicator, globalEntry) != UA_SUBSCRIPTION_QUEUE_SENTINEL) { + TAILQ_INSERT_BEFORE(indicator, overflowNotification, globalEntry); + break; + } + } + } + } + ++sub->notificationQueueSize; + ++sub->eventNotifications; + return UA_STATUSCODE_GOOD; +} + +#endif + +/* Set the InfoBits that a datachange notification was removed */ +static void +setOverflowInfoBits(UA_MonitoredItem *mon) { + /* Only for queues with more than one element */ + if(mon->parameters.queueSize == 1) + return; + + UA_Notification *indicator = NULL; + if(mon->parameters.discardOldest) { + indicator = TAILQ_FIRST(&mon->queue); + } else { + indicator = TAILQ_LAST(&mon->queue, NotificationQueue); + } + UA_assert(indicator); /* must exist */ + + indicator->data.dataChange.value.hasStatus = true; + indicator->data.dataChange.value.status |= + (UA_STATUSCODE_INFOTYPE_DATAVALUE | UA_STATUSCODE_INFOBITS_OVERFLOW); +} + +/* Remove the InfoBits when the queueSize was reduced to 1 */ +void +UA_MonitoredItem_removeOverflowInfoBits(UA_MonitoredItem *mon) { + /* Don't consider queue size > 1 and Event MonitoredItems */ + if(mon->parameters.queueSize > 1 || + mon->itemToMonitor.attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER) + return; + + /* Get the first notification */ + UA_Notification *n = TAILQ_FIRST(&mon->queue); + if(!n) + return; + + /* Assertion that at most one notification is in the queue */ + UA_assert(n == TAILQ_LAST(&mon->queue, NotificationQueue)); + + /* Remve the Infobits */ + n->data.dataChange.value.status &= ~(UA_StatusCode) + (UA_STATUSCODE_INFOTYPE_DATAVALUE | UA_STATUSCODE_INFOBITS_OVERFLOW); +} + +UA_Notification * +UA_Notification_new(void) { + UA_Notification *n = (UA_Notification*)UA_calloc(1, sizeof(UA_Notification)); + if(n) { + /* Set the sentinel for a notification that is not enqueued */ + TAILQ_NEXT(n, globalEntry) = UA_SUBSCRIPTION_QUEUE_SENTINEL; + TAILQ_NEXT(n, localEntry) = UA_SUBSCRIPTION_QUEUE_SENTINEL; + } + return n; +} + +static void UA_Notification_dequeueMon(UA_Notification *n); +static void UA_Notification_enqueueSub(UA_Notification *n); +static void UA_Notification_dequeueSub(UA_Notification *n); + +void +UA_Notification_delete(UA_Notification *n) { + UA_assert(n != UA_SUBSCRIPTION_QUEUE_SENTINEL); + if(n->mon) { + UA_Notification_dequeueMon(n); + UA_Notification_dequeueSub(n); + switch(n->mon->itemToMonitor.attributeId) { +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + case UA_ATTRIBUTEID_EVENTNOTIFIER: + UA_EventFieldList_clear(&n->data.event); + UA_EventFilterResult_clear(&n->result); + break; +#endif + default: + UA_MonitoredItemNotification_clear(&n->data.dataChange); + break; + } + } + UA_free(n); +} + +/* Add to the MonitoredItem queue, update all counters and then handle overflow */ +static void +UA_Notification_enqueueMon(UA_Server *server, UA_Notification *n) { + UA_MonitoredItem *mon = n->mon; + UA_assert(mon); + UA_assert(TAILQ_NEXT(n, localEntry) == UA_SUBSCRIPTION_QUEUE_SENTINEL); + + /* Add to the MonitoredItem */ + TAILQ_INSERT_TAIL(&mon->queue, n, localEntry); + ++mon->queueSize; + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + if(n->isOverflowEvent) + ++mon->eventOverflows; +#endif + + /* Test for consistency */ + UA_assert(mon->queueSize >= mon->eventOverflows); + UA_assert(mon->eventOverflows <= mon->queueSize - mon->eventOverflows + 1); + + /* Ensure enough space is available in the MonitoredItem. Do this only after + * adding the new Notification. */ + UA_MonitoredItem_ensureQueueSpace(server, mon); +} + +void +UA_Notification_enqueueSub(UA_Notification *n) { + UA_MonitoredItem *mon = n->mon; + UA_assert(mon); + + UA_Subscription *sub = mon->subscription; + UA_assert(sub); + + if(TAILQ_NEXT(n, globalEntry) != UA_SUBSCRIPTION_QUEUE_SENTINEL) + return; + + /* Add to the subscription if reporting is enabled */ + TAILQ_INSERT_TAIL(&sub->notificationQueue, n, globalEntry); + ++sub->notificationQueueSize; + + switch(mon->itemToMonitor.attributeId) { +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + case UA_ATTRIBUTEID_EVENTNOTIFIER: + ++sub->eventNotifications; + break; +#endif + default: + ++sub->dataChangeNotifications; + break; + } +} + +void +UA_Notification_enqueueAndTrigger(UA_Server *server, UA_Notification *n) { + /* If reporting, enqueue into the Subscription first and then into the + * MonitoredItem. Otherwise the reinsertion in + * UA_MonitoredItem_ensureQueueSpace might not work. */ + UA_MonitoredItem *mon = n->mon; + if(mon->monitoringMode == UA_MONITORINGMODE_REPORTING || + (mon->monitoringMode == UA_MONITORINGMODE_SAMPLING && + mon->triggeredUntil > UA_DateTime_nowMonotonic())) { + UA_Notification_enqueueSub(n); + mon->triggeredUntil = UA_INT64_MIN; + } + + /* Insert into the MonitoredItem. This checks the queue size and + * handles overflow. */ + UA_Notification_enqueueMon(server, n); + + UA_Subscription *sub = mon->subscription; + for(size_t i = mon->triggeringLinksSize - 1; i < mon->triggeringLinksSize; i--) { + /* Get the triggered MonitoredItem. Remove the link if the MI doesn't exist. */ + UA_MonitoredItem *triggeredMon = + UA_Subscription_getMonitoredItem(sub, mon->triggeringLinks[i]); + if(!triggeredMon) { + UA_MonitoredItem_removeLink(sub, mon, mon->triggeringLinks[i]); + continue; + } + + /* Only sampling MonitoredItems receive a trigger. Reporting + * MonitoredItems send out Notifications anyway and disabled + * MonitoredItems don't create samples to send. */ + if(triggeredMon->monitoringMode != UA_MONITORINGMODE_SAMPLING) + continue; + + /* Get the latest sampled Notification from the triggered MonitoredItem. + * Enqueue for publication. */ + UA_Notification *n2 = TAILQ_LAST(&triggeredMon->queue, NotificationQueue); + if(n2) + UA_Notification_enqueueSub(n2); + + /* The next Notification within the publishing interval is going to be + * published as well. (Falsely) assume that the publishing cycle has + * started right now, so that we don't have to loop over MonitoredItems + * to deactivate the triggering after the publishing cycle. */ + triggeredMon->triggeredUntil = UA_DateTime_nowMonotonic() + + (UA_DateTime)(sub->publishingInterval * (UA_Double)UA_DATETIME_MSEC); + + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %u triggers MonitoredItem %u", + mon->monitoredItemId, triggeredMon->monitoredItemId); + } +} + +/* Remove from the MonitoredItem queue and adjust all counters */ +static void +UA_Notification_dequeueMon(UA_Notification *n) { + UA_MonitoredItem *mon = n->mon; + UA_assert(mon); + + if(TAILQ_NEXT(n, localEntry) == UA_SUBSCRIPTION_QUEUE_SENTINEL) + return; + + /* Remove from the MonitoredItem queue */ +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + if(n->isOverflowEvent) + --mon->eventOverflows; +#endif + + TAILQ_REMOVE(&mon->queue, n, localEntry); + --mon->queueSize; + + /* Test for consistency */ + UA_assert(mon->queueSize >= mon->eventOverflows); + UA_assert(mon->eventOverflows <= mon->queueSize - mon->eventOverflows + 1); + + /* Reset the sentintel */ + TAILQ_NEXT(n, localEntry) = UA_SUBSCRIPTION_QUEUE_SENTINEL; +} + +void +UA_Notification_dequeueSub(UA_Notification *n) { + if(TAILQ_NEXT(n, globalEntry) == UA_SUBSCRIPTION_QUEUE_SENTINEL) + return; + + UA_MonitoredItem *mon = n->mon; + UA_assert(mon); + UA_Subscription *sub = mon->subscription; + UA_assert(sub); + + switch(mon->itemToMonitor.attributeId) { +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + case UA_ATTRIBUTEID_EVENTNOTIFIER: + --sub->eventNotifications; + break; +#endif + default: + --sub->dataChangeNotifications; + break; + } + + TAILQ_REMOVE(&sub->notificationQueue, n, globalEntry); + --sub->notificationQueueSize; + + /* Reset the sentinel */ + TAILQ_NEXT(n, globalEntry) = UA_SUBSCRIPTION_QUEUE_SENTINEL; +} + +/*****************/ +/* MonitoredItem */ +/*****************/ + +void +UA_MonitoredItem_init(UA_MonitoredItem *mon) { + memset(mon, 0, sizeof(UA_MonitoredItem)); + mon->next = (UA_MonitoredItem*)~0; /* Not added to a node */ + TAILQ_INIT(&mon->queue); + mon->triggeredUntil = UA_INT64_MIN; +} + +static UA_StatusCode +addMonitoredItemBackpointer(UA_Server *server, UA_Session *session, + UA_Node *node, void *data) { + UA_MonitoredItem *mon = (UA_MonitoredItem*)data; + UA_assert(mon != (UA_MonitoredItem*)~0); + mon->next = node->head.monitoredItems; + node->head.monitoredItems = mon; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +removeMonitoredItemBackPointer(UA_Server *server, UA_Session *session, + UA_Node *node, void *data) { + if(!node->head.monitoredItems) + return UA_STATUSCODE_GOOD; + + /* Edge case that it's the first element */ + UA_MonitoredItem *remove = (UA_MonitoredItem*)data; + if(node->head.monitoredItems == remove) { + node->head.monitoredItems = remove->next; + remove->next = (UA_MonitoredItem*)~0; + return UA_STATUSCODE_GOOD; + } + + UA_MonitoredItem *prev = node->head.monitoredItems; + UA_MonitoredItem *entry = prev->next; + for(; entry != NULL; prev = entry, entry = entry->next) { + if(entry == remove) { + prev->next = entry->next; + remove->next = (UA_MonitoredItem*)~0; + break; + } + } + + return UA_STATUSCODE_GOOD; +} + +void +UA_Server_registerMonitoredItem(UA_Server *server, UA_MonitoredItem *mon) { + if(mon->registered) + return; + + /* Register in Subscription and Server */ + UA_Subscription *sub = mon->subscription; + if(sub) { + mon->monitoredItemId = ++sub->lastMonitoredItemId; + mon->subscription = sub; + sub->monitoredItemsSize++; + LIST_INSERT_HEAD(&sub->monitoredItems, mon, listEntry); + } else { + mon->monitoredItemId = ++server->lastLocalMonitoredItemId; + LIST_INSERT_HEAD(&server->localMonitoredItems, mon, listEntry); + } + server->monitoredItemsSize++; + + /* Register the MonitoredItem in userland */ + if(server->config.monitoredItemRegisterCallback) { + UA_Session *session = &server->adminSession; + if(sub) + session = sub->session; + + void *targetContext = NULL; + getNodeContext(server, mon->itemToMonitor.nodeId, &targetContext); + UA_UNLOCK(&server->serviceMutex); + server->config.monitoredItemRegisterCallback(server, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &mon->itemToMonitor.nodeId, + targetContext, + mon->itemToMonitor.attributeId, false); + UA_LOCK(&server->serviceMutex); + } + + mon->registered = true; +} + +static void +UA_Server_unregisterMonitoredItem(UA_Server *server, UA_MonitoredItem *mon) { + if(!mon->registered) + return; + + UA_Subscription *sub = mon->subscription; + UA_LOG_INFO_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %" PRIi32 " | Deleting the MonitoredItem", + mon->monitoredItemId); + + /* Deregister MonitoredItem in userland */ + if(server->config.monitoredItemRegisterCallback) { + UA_Session *session = &server->adminSession; + if(sub) + session = sub->session; + + void *targetContext = NULL; + getNodeContext(server, mon->itemToMonitor.nodeId, &targetContext); + UA_UNLOCK(&server->serviceMutex); + server->config.monitoredItemRegisterCallback(server, + session ? &session->sessionId : NULL, + session ? session->sessionHandle : NULL, + &mon->itemToMonitor.nodeId, + targetContext, + mon->itemToMonitor.attributeId, true); + UA_LOCK(&server->serviceMutex); + } + + /* Deregister in Subscription and server */ + if(sub) + sub->monitoredItemsSize--; + LIST_REMOVE(mon, listEntry); /* Also for LocalMonitoredItems */ + server->monitoredItemsSize--; + + mon->registered = false; +} + +UA_StatusCode +UA_MonitoredItem_setMonitoringMode(UA_Server *server, UA_MonitoredItem *mon, + UA_MonitoringMode monitoringMode) { + /* Check if the MonitoringMode is valid or not */ + if(monitoringMode > UA_MONITORINGMODE_REPORTING) + return UA_STATUSCODE_BADMONITORINGMODEINVALID; + + /* Set the MonitoringMode, store the old mode */ + UA_MonitoringMode oldMode = mon->monitoringMode; + mon->monitoringMode = monitoringMode; + + UA_Notification *notification; + /* Reporting is disabled. This causes all Notifications to be dequeued and + * deleted. Also remove the last samples so that we immediately generate a + * Notification when re-activated. */ + if(mon->monitoringMode == UA_MONITORINGMODE_DISABLED) { + UA_Notification *notification_tmp; + UA_MonitoredItem_unregisterSampling(server, mon); + TAILQ_FOREACH_SAFE(notification, &mon->queue, localEntry, notification_tmp) { + UA_Notification_delete(notification); + } + UA_DataValue_clear(&mon->lastValue); + return UA_STATUSCODE_GOOD; + } + + /* When reporting is enabled, put all notifications that were already + * sampled into the global queue of the subscription. When sampling is + * enabled, remove all notifications from the global queue. !!! This needs + * to be the same operation as in UA_Notification_enqueue !!! */ + if(mon->monitoringMode == UA_MONITORINGMODE_REPORTING) { + /* Make all notifications reporting. Re-enqueue to ensure they have the + * right order if some notifications are already reported by a trigger + * link. */ + TAILQ_FOREACH(notification, &mon->queue, localEntry) { + UA_Notification_dequeueSub(notification); + UA_Notification_enqueueSub(notification); + } + } else /* mon->monitoringMode == UA_MONITORINGMODE_SAMPLING */ { + /* Make all notifications non-reporting */ + TAILQ_FOREACH(notification, &mon->queue, localEntry) + UA_Notification_dequeueSub(notification); + } + + /* Register the sampling callback with an interval. If registering the + * sampling callback failed, set to disabled. But don't delete the current + * notifications. */ + UA_StatusCode res = UA_MonitoredItem_registerSampling(server, mon); + if(res != UA_STATUSCODE_GOOD) { + mon->monitoringMode = UA_MONITORINGMODE_DISABLED; + return res; + } + + /* Manually create the first sample if the MonitoredItem was disabled, the + * MonitoredItem is now sampling (or reporting) and it is not an + * Event-MonitoredItem */ + if(oldMode == UA_MONITORINGMODE_DISABLED && + mon->monitoringMode > UA_MONITORINGMODE_DISABLED && + mon->itemToMonitor.attributeId != UA_ATTRIBUTEID_EVENTNOTIFIER) + monitoredItem_sampleCallback(server, mon); + + return UA_STATUSCODE_GOOD; +} + +void +UA_MonitoredItem_delete(UA_Server *server, UA_MonitoredItem *mon) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Remove the sampling callback */ + UA_MonitoredItem_unregisterSampling(server, mon); + + UA_assert(mon->next == (UA_MonitoredItem*)~0); /* Not attached to any node */ + + /* Deregister in Server and Subscription */ + if(mon->registered) + UA_Server_unregisterMonitoredItem(server, mon); + + /* Remove the TriggeringLinks */ + if(mon->triggeringLinksSize > 0) { + UA_free(mon->triggeringLinks); + mon->triggeringLinks = NULL; + mon->triggeringLinksSize = 0; + } + + /* Remove the queued notifications attached to the subscription */ + UA_Notification *notification, *notification_tmp; + TAILQ_FOREACH_SAFE(notification, &mon->queue, localEntry, notification_tmp) { + UA_Notification_delete(notification); + } + + /* Remove the settings */ + UA_ReadValueId_clear(&mon->itemToMonitor); + UA_MonitoringParameters_clear(&mon->parameters); + + /* Remove the last samples */ + UA_DataValue_clear(&mon->lastValue); + + /* Add a delayed callback to remove the MonitoredItem when the current jobs + * have completed. This is needed to allow that a local MonitoredItem can + * remove itself in the callback. */ + mon->delayedFreePointers.callback = NULL; + mon->delayedFreePointers.application = server; + mon->delayedFreePointers.data = NULL; + mon->delayedFreePointers.nextTime = UA_DateTime_nowMonotonic() + 1; + mon->delayedFreePointers.interval = 0; + UA_Timer_addTimerEntry(&server->timer, &mon->delayedFreePointers, NULL); +} + +void +UA_MonitoredItem_ensureQueueSpace(UA_Server *server, UA_MonitoredItem *mon) { + /* There can be only one EventOverflow more than normal entries. Because + * EventOverflows are never adjacent. */ + UA_assert(mon->queueSize >= mon->eventOverflows); + UA_assert(mon->eventOverflows <= mon->queueSize - mon->eventOverflows + 1); + + /* Nothing to do */ + if(mon->queueSize - mon->eventOverflows <= mon->parameters.queueSize) + return; + + /* Remove notifications until the required queue size is reached */ + UA_Subscription *sub = mon->subscription; + UA_Boolean reporting = false; + size_t remove = mon->queueSize - mon->eventOverflows - mon->parameters.queueSize; + while(remove > 0) { + /* The minimum queue size (without EventOverflows) is 1. At least two + * notifications that are not EventOverflows are in the queue. */ + UA_assert(mon->queueSize - mon->eventOverflows >= 2); + + /* Select the next notification to delete. Skip over overflow events. */ + UA_Notification *del = NULL; + if(mon->parameters.discardOldest) { + /* Remove the oldest */ + del = TAILQ_FIRST(&mon->queue); +#if defined(UA_ENABLE_SUBSCRIPTIONS_EVENTS) && !defined(__clang_analyzer__) + while(del->isOverflowEvent) + del = TAILQ_NEXT(del, localEntry); /* skip overflow events */ +#endif + } else { + /* Remove the second newest (to keep the up-to-date notification). + * The last entry is not an OverflowEvent -- we just added it. */ + del = TAILQ_LAST(&mon->queue, NotificationQueue); + del = TAILQ_PREV(del, NotificationQueue, localEntry); +#if defined(UA_ENABLE_SUBSCRIPTIONS_EVENTS) && !defined(__clang_analyzer__) + while(del->isOverflowEvent) + del = TAILQ_PREV(del, NotificationQueue, localEntry); /* skip overflow events */ +#endif + } + + UA_assert(del); /* There must have been one entry that can be deleted */ + + /* Only create OverflowEvents (and set InfoBits) if the notification + * that is removed is reported */ + if(TAILQ_NEXT(del, globalEntry) != UA_SUBSCRIPTION_QUEUE_SENTINEL) + reporting = true; + + /* Move the entry after del in the per-MonitoredItem queue right after + * del in the per-Subscription queue. So we don't starve MonitoredItems + * with a high sampling interval in the Subscription queue by always + * removing their first appearance in the per-Subscription queue. + * + * With MonitoringMode == SAMPLING, the Notifications are not (all) in + * the per-Subscription queue. Don't reinsert in that case. + * + * For the reinsertion to work, first insert into the per-Subscription + * queue. */ + if(TAILQ_NEXT(del, globalEntry) != UA_SUBSCRIPTION_QUEUE_SENTINEL) { + UA_Notification *after_del = TAILQ_NEXT(del, localEntry); + UA_assert(after_del); /* There must be one remaining element after del */ + if(TAILQ_NEXT(after_del, globalEntry) != UA_SUBSCRIPTION_QUEUE_SENTINEL) { + TAILQ_REMOVE(&sub->notificationQueue, after_del, globalEntry); + TAILQ_INSERT_AFTER(&sub->notificationQueue, del, after_del, globalEntry); + } + } + + remove--; + + /* Delete the notification and remove it from the queues */ + UA_Notification_delete(del); + + /* Assertions to help Clang's scan-analyzer */ + UA_assert(del != TAILQ_FIRST(&mon->queue)); + UA_assert(del != TAILQ_LAST(&mon->queue, NotificationQueue)); + UA_assert(del != TAILQ_PREV(TAILQ_LAST(&mon->queue, NotificationQueue), + NotificationQueue, localEntry)); + } + + /* Leave an entry to indicate that notifications were removed */ + if(reporting) { +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + if(mon->itemToMonitor.attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER) + createEventOverflowNotification(server, sub, mon); + else +#endif + setOverflowInfoBits(mon); + } +} + +UA_StatusCode +UA_MonitoredItem_registerSampling(UA_Server *server, UA_MonitoredItem *mon) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + if(mon->sampleCallbackIsRegistered) + return UA_STATUSCODE_GOOD; + + UA_assert(mon->next == (UA_MonitoredItem*)~0); /* Not registered in a node */ + + /* Only DataChange MonitoredItems with a positive sampling interval have a + * repeated callback. Other MonitoredItems are attached to the Node in a + * linked list of backpointers. */ + UA_StatusCode res; + if(mon->itemToMonitor.attributeId == UA_ATTRIBUTEID_EVENTNOTIFIER || + mon->parameters.samplingInterval == 0.0) { + UA_Subscription *sub = mon->subscription; + UA_Session *session = &server->adminSession; + if(sub) + session = sub->session; + res = UA_Server_editNode(server, session, &mon->itemToMonitor.nodeId, + addMonitoredItemBackpointer, mon); + } else { + res = addRepeatedCallback(server, + (UA_ServerCallback)UA_MonitoredItem_sampleCallback, + mon, mon->parameters.samplingInterval, + &mon->sampleCallbackId); + } + + if(res == UA_STATUSCODE_GOOD) + mon->sampleCallbackIsRegistered = true; + return res; +} + +void +UA_MonitoredItem_unregisterSampling(UA_Server *server, UA_MonitoredItem *mon) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + if(!mon->sampleCallbackIsRegistered) + return; + + mon->sampleCallbackIsRegistered = false; + + /* Check for mon->next and not the samplingInterval. Because that might + * currently be changed. */ + if(mon->next != (UA_MonitoredItem*)~0) { + /* Added to a node */ + UA_Subscription *sub = mon->subscription; + UA_Session *session = &server->adminSession; + if(sub) + session = sub->session; + UA_Server_editNode(server, session, &mon->itemToMonitor.nodeId, + removeMonitoredItemBackPointer, mon); + } else { + /* Registered with a repeated callback */ + removeCallback(server, mon->sampleCallbackId); + } +} + +UA_StatusCode +UA_MonitoredItem_removeLink(UA_Subscription *sub, UA_MonitoredItem *mon, UA_UInt32 linkId) { + /* Find the index */ + size_t i = 0; + for(; i < mon->triggeringLinksSize; i++) { + if(mon->triggeringLinks[i] == linkId) + break; + } + + /* Not existing / already removed */ + if(i == mon->triggeringLinksSize) + return UA_STATUSCODE_BADMONITOREDITEMIDINVALID; + + /* Remove the link */ + mon->triggeringLinksSize--; + if(mon->triggeringLinksSize == 0) { + UA_free(mon->triggeringLinks); + mon->triggeringLinks = NULL; + } else { + mon->triggeringLinks[i] = mon->triggeringLinks[mon->triggeringLinksSize]; + UA_UInt32 *tmpLinks = (UA_UInt32*) + UA_realloc(mon->triggeringLinks, mon->triggeringLinksSize * sizeof(UA_UInt32)); + if(tmpLinks) + mon->triggeringLinks = tmpLinks; + } + + /* Does the target MonitoredItem exist? This is stupid, but the CTT wants us + * to to this. We don't auto-remove links together with the target + * MonitoredItem. Links to removed MonitoredItems are removed when the link + * triggers and the target no longer exists. */ + UA_MonitoredItem *mon2 = UA_Subscription_getMonitoredItem(sub, linkId); + if(!mon2) + return UA_STATUSCODE_BADMONITOREDITEMIDINVALID; + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_MonitoredItem_addLink(UA_Subscription *sub, UA_MonitoredItem *mon, UA_UInt32 linkId) { + /* Does the target MonitoredItem exist? */ + UA_MonitoredItem *mon2 = UA_Subscription_getMonitoredItem(sub, linkId); + if(!mon2) + return UA_STATUSCODE_BADMONITOREDITEMIDINVALID; + + /* Does the link already exist? */ + for(size_t i = 0 ; i < mon->triggeringLinksSize; i++) { + if(mon->triggeringLinks[i] == linkId) + return UA_STATUSCODE_GOOD; + } + + /* Allocate the memory */ + UA_UInt32 *tmpLinkIds = (UA_UInt32*) + UA_realloc(mon->triggeringLinks, (mon->triggeringLinksSize + 1) * sizeof(UA_UInt32)); + if(!tmpLinkIds) + return UA_STATUSCODE_BADOUTOFMEMORY; + mon->triggeringLinks = tmpLinkIds; + + /* Add the link */ + mon->triggeringLinks[mon->triggeringLinksSize] = linkId; + mon->triggeringLinksSize++; + return UA_STATUSCODE_GOOD; +} + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +/**** amalgamated original file "/src/server/ua_subscription_datachange.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Ari Breitkreuz, fortiss GmbH + * Copyright 2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2018 (c) Fabian Arndt, Root-Core + */ + + +#ifdef UA_ENABLE_SUBSCRIPTIONS /* conditional compilation */ + +/* Detect value changes outside the deadband */ +#define UA_DETECT_DEADBAND(TYPE) do { \ + TYPE v1 = *(const TYPE*)data1; \ + TYPE v2 = *(const TYPE*)data2; \ + TYPE diff = (v1 > v2) ? (TYPE)(v1 - v2) : (TYPE)(v2 - v1); \ + return ((UA_Double)diff > deadband); \ +} while(false); + +static UA_Boolean +detectScalarDeadBand(const void *data1, const void *data2, + const UA_DataType *type, const UA_Double deadband) { + if(type->typeKind == UA_DATATYPEKIND_SBYTE) { + UA_DETECT_DEADBAND(UA_SByte); + } else if(type->typeKind == UA_DATATYPEKIND_BYTE) { + UA_DETECT_DEADBAND(UA_Byte); + } else if(type->typeKind == UA_DATATYPEKIND_INT16) { + UA_DETECT_DEADBAND(UA_Int16); + } else if(type->typeKind == UA_DATATYPEKIND_UINT16) { + UA_DETECT_DEADBAND(UA_UInt16); + } else if(type->typeKind == UA_DATATYPEKIND_INT32) { + UA_DETECT_DEADBAND(UA_Int32); + } else if(type->typeKind == UA_DATATYPEKIND_UINT32) { + UA_DETECT_DEADBAND(UA_UInt32); + } else if(type->typeKind == UA_DATATYPEKIND_INT64) { + UA_DETECT_DEADBAND(UA_Int64); + } else if(type->typeKind == UA_DATATYPEKIND_UINT64) { + UA_DETECT_DEADBAND(UA_UInt64); + } else if(type->typeKind == UA_DATATYPEKIND_FLOAT) { + UA_DETECT_DEADBAND(UA_Float); + } else if(type->typeKind == UA_DATATYPEKIND_DOUBLE) { + UA_DETECT_DEADBAND(UA_Double); + } else { + return false; /* Not a known numerical type */ + } +} + +static UA_Boolean +detectVariantDeadband(const UA_Variant *value, const UA_Variant *oldValue, + const UA_Double deadbandValue) { + if(value->arrayLength != oldValue->arrayLength) + return true; + if(value->type != oldValue->type) + return true; + size_t length = 1; + if(!UA_Variant_isScalar(value)) + length = value->arrayLength; + uintptr_t data = (uintptr_t)value->data; + uintptr_t oldData = (uintptr_t)oldValue->data; + UA_UInt32 memSize = value->type->memSize; + for(size_t i = 0; i < length; ++i) { + if(detectScalarDeadBand((const void*)data, (const void*)oldData, + value->type, deadbandValue)) + return true; + data += memSize; + oldData += memSize; + } + return false; +} + +static UA_Boolean +detectValueChange(UA_Server *server, UA_MonitoredItem *mon, + const UA_DataValue *value) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + /* Status changes are always reported */ + if(value->hasStatus != mon->lastValue.hasStatus || + value->status != mon->lastValue.status) { + return true; + } + + /* Default trigger is Status + Value */ + UA_DataChangeTrigger trigger = UA_DATACHANGETRIGGER_STATUSVALUE; + + /* Use the configured trigger */ + const UA_DataChangeFilter *dcf = NULL; + const UA_ExtensionObject *filter = &mon->parameters.filter; + if(filter->content.decoded.type == &UA_TYPES[UA_TYPES_DATACHANGEFILTER]) { + dcf = (UA_DataChangeFilter*)filter->content.decoded.data; + trigger = dcf->trigger; + } + + /* The status was already tested above */ + if(trigger == UA_DATACHANGETRIGGER_STATUS) + return false; + + UA_assert(trigger == UA_DATACHANGETRIGGER_STATUSVALUE || + trigger == UA_DATACHANGETRIGGER_STATUSVALUETIMESTAMP); + + /* Test absolute deadband */ + if(dcf && dcf->deadbandType == UA_DEADBANDTYPE_ABSOLUTE && + value->value.type != NULL && UA_DataType_isNumeric(value->value.type)) + return detectVariantDeadband(&value->value, &mon->lastValue.value, + dcf->deadbandValue); + + /* Compare the source timestamp if the trigger requires that */ + if(trigger == UA_DATACHANGETRIGGER_STATUSVALUETIMESTAMP) { + if(value->hasSourceTimestamp != mon->lastValue.hasSourceTimestamp) + return true; + if(value->hasSourceTimestamp && + value->sourceTimestamp != mon->lastValue.sourceTimestamp) + return true; + } + + /* Has the value changed? */ + if(value->hasValue != mon->lastValue.hasValue) + return true; + return (UA_order(&value->value, &mon->lastValue.value, + &UA_TYPES[UA_TYPES_VARIANT]) != UA_ORDER_EQ); +} + +UA_StatusCode +UA_MonitoredItem_createDataChangeNotification(UA_Server *server, UA_Subscription *sub, + UA_MonitoredItem *mon, + const UA_DataValue *value) { + /* Allocate a new notification */ + UA_Notification *newNotification = UA_Notification_new(); + if(!newNotification) + return UA_STATUSCODE_BADOUTOFMEMORY; + + /* Prepare the notification */ + newNotification->mon = mon; + newNotification->data.dataChange.clientHandle = mon->parameters.clientHandle; + UA_StatusCode retval = UA_DataValue_copy(value, &newNotification->data.dataChange.value); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(newNotification); + return retval; + } + + /* Enqueue the notification */ + UA_Notification_enqueueAndTrigger(server, newNotification); + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %" PRIi32 " | " + "Enqueued a new notification", mon->monitoredItemId); + return UA_STATUSCODE_GOOD; +} + +/* Moves the value to the MonitoredItem if successful */ +UA_StatusCode +sampleCallbackWithValue(UA_Server *server, UA_Subscription *sub, + UA_MonitoredItem *mon, UA_DataValue *value) { + UA_assert(mon->itemToMonitor.attributeId != UA_ATTRIBUTEID_EVENTNOTIFIER); + + /* Has the value changed (with the filters applied)? */ + UA_Boolean changed = detectValueChange(server, mon, value); + if(!changed) { + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %" PRIi32 " | " + "The value has not changed", mon->monitoredItemId); + UA_DataValue_clear(value); + return UA_STATUSCODE_GOOD; + } + + /* The MonitoredItem is attached to a subscription (not server-local). + * Prepare a notification and enqueue it. */ + if(sub) { + UA_StatusCode retval = + UA_MonitoredItem_createDataChangeNotification(server, sub, mon, value); + if(retval != UA_STATUSCODE_GOOD) + return retval; + } + + /* <-- Point of no return --> */ + + /* Move/store the value for filter comparison and TransferSubscription */ + UA_DataValue_clear(&mon->lastValue); + mon->lastValue = *value; + + /* Call the local callback if the MonitoredItem is not attached to a + * subscription. Do this at the very end. Because the callback might delete + * the subscription. */ + if(!sub) { + UA_LocalMonitoredItem *localMon = (UA_LocalMonitoredItem*) mon; + void *nodeContext = NULL; + getNodeContext(server, mon->itemToMonitor.nodeId, &nodeContext); + UA_UNLOCK(&server->serviceMutex); + localMon->callback.dataChangeCallback(server, + mon->monitoredItemId, localMon->context, + &mon->itemToMonitor.nodeId, nodeContext, + mon->itemToMonitor.attributeId, value); + UA_LOCK(&server->serviceMutex); + } + + return UA_STATUSCODE_GOOD; +} + +void +UA_MonitoredItem_sampleCallback(UA_Server *server, UA_MonitoredItem *monitoredItem) { + UA_LOCK(&server->serviceMutex); + monitoredItem_sampleCallback(server, monitoredItem); + UA_UNLOCK(&server->serviceMutex); +} + +void +monitoredItem_sampleCallback(UA_Server *server, UA_MonitoredItem *monitoredItem) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_Subscription *sub = monitoredItem->subscription; + UA_Session *session = &server->adminSession; + if(sub) + session = sub->session; + + UA_LOG_DEBUG_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %" PRIi32 " | " + "Sample callback called", monitoredItem->monitoredItemId); + + UA_assert(monitoredItem->itemToMonitor.attributeId != UA_ATTRIBUTEID_EVENTNOTIFIER); + + /* Sample the value. The sample can still point into the node. */ + UA_DataValue value = UA_Server_readWithSession(server, session, + &monitoredItem->itemToMonitor, + monitoredItem->timestampsToReturn); + + /* Operate on the sample. The sample is consumed when the status is good. */ + UA_StatusCode res = sampleCallbackWithValue(server, sub, monitoredItem, &value); + if(res != UA_STATUSCODE_GOOD) { + UA_DataValue_clear(&value); + UA_LOG_WARNING_SUBSCRIPTION(&server->config.logger, sub, + "MonitoredItem %" PRIi32 " | " + "Sampling returned the statuscode %s", + monitoredItem->monitoredItemId, + UA_StatusCode_name(res)); + } +} + +#endif /* UA_ENABLE_SUBSCRIPTIONS */ + +/**** amalgamated original file "/src/server/ua_subscription_events.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Ari Breitkreuz, fortiss GmbH + * Copyright 2020 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + * Copyright 2021 (c) Fraunhofer IOSB (Author: Andreas Ebner) + */ + + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + +//forward declaration +static UA_StatusCode +evaluateWhereClauseContentFilter(UA_Server *server, UA_Session *session, + const UA_NodeId *eventNode, + const UA_ContentFilter *contentFilter, + UA_ContentFilterResult *contentFilterResult, + UA_Variant* valueResult, UA_UInt16 index); + +/* We use a 16-Byte ByteString as an identifier */ +UA_StatusCode +UA_Event_generateEventId(UA_ByteString *generatedId) { + /* EventId is a ByteString, which is basically just a string + * We will use a 16-Byte ByteString as an identifier */ + UA_StatusCode res = UA_ByteString_allocBuffer(generatedId, 16 * sizeof(UA_Byte)); + if(res != UA_STATUSCODE_GOOD) + return res; + UA_UInt32 *ids = (UA_UInt32*)generatedId->data; + ids[0] = UA_UInt32_random(); + ids[1] = UA_UInt32_random(); + ids[2] = UA_UInt32_random(); + ids[3] = UA_UInt32_random(); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_createEvent(UA_Server *server, const UA_NodeId eventType, + UA_NodeId *outNodeId) { + UA_LOCK(&server->serviceMutex); + if(!outNodeId) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "outNodeId must not be NULL. The event's NodeId must be returned " + "so it can be triggered."); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + /* Make sure the eventType is a subtype of BaseEventType */ + UA_NodeId baseEventTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE); + if(!isNodeInTree_singleRef(server, &eventType, &baseEventTypeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "Event type must be a subtype of BaseEventType!"); + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + /* Create an ObjectNode which represents the event */ + UA_QualifiedName name; + // set a dummy name. This is not used. + name = UA_QUALIFIEDNAME(0,"E"); + UA_NodeId newNodeId = UA_NODEID_NULL; + UA_ObjectAttributes oAttr = UA_ObjectAttributes_default; + UA_StatusCode retval = addNode(server, UA_NODECLASS_OBJECT, + &UA_NODEID_NULL, /* Set a random unused NodeId */ + &UA_NODEID_NULL, /* No parent */ + &UA_NODEID_NULL, /* No parent reference */ + name, /* an event does not have a name */ + &eventType, /* the type of the event */ + (const UA_NodeAttributes*)&oAttr, /* default attributes are fine */ + &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES], + NULL, /* no node context */ + &newNodeId); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "Adding event failed. StatusCode %s", UA_StatusCode_name(retval)); + return retval; + } + + /* Find the eventType variable */ + name = UA_QUALIFIEDNAME(0, "EventType"); + UA_BrowsePathResult bpr = browseSimplifiedBrowsePath(server, newNodeId, 1, &name); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + retval = bpr.statusCode; + UA_BrowsePathResult_clear(&bpr); + deleteNode(server, newNodeId, true); + UA_NodeId_clear(&newNodeId); + UA_UNLOCK(&server->serviceMutex); + return retval; + } + + /* Set the EventType */ + UA_Variant value; + UA_Variant_init(&value); + UA_Variant_setScalar(&value, (void*)(uintptr_t)&eventType, &UA_TYPES[UA_TYPES_NODEID]); + retval = writeValueAttribute(server, &server->adminSession, + &bpr.targets[0].targetId.nodeId, &value); + UA_BrowsePathResult_clear(&bpr); + if(retval != UA_STATUSCODE_GOOD) { + deleteNode(server, newNodeId, true); + UA_NodeId_clear(&newNodeId); + UA_UNLOCK(&server->serviceMutex); + return retval; + } + + *outNodeId = newNodeId; + UA_UNLOCK(&server->serviceMutex); + return UA_STATUSCODE_GOOD; +} + +static UA_Boolean +isValidEvent(UA_Server *server, const UA_NodeId *validEventParent, + const UA_NodeId *eventId) { + /* find the eventType variableNode */ + UA_QualifiedName findName = UA_QUALIFIEDNAME(0, "EventType"); + UA_BrowsePathResult bpr = browseSimplifiedBrowsePath(server, *eventId, 1, &findName); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + UA_BrowsePathResult_clear(&bpr); + return false; + } + + /* Get the EventType Property Node */ + UA_Variant tOutVariant; + UA_Variant_init(&tOutVariant); + + /* Read the Value of EventType Property Node (the Value should be a NodeId) */ + UA_StatusCode retval = readWithReadValue(server, &bpr.targets[0].targetId.nodeId, + UA_ATTRIBUTEID_VALUE, &tOutVariant); + if(retval != UA_STATUSCODE_GOOD || + !UA_Variant_hasScalarType(&tOutVariant, &UA_TYPES[UA_TYPES_NODEID])) { + UA_BrowsePathResult_clear(&bpr); + return false; + } + + const UA_NodeId *tEventType = (UA_NodeId*)tOutVariant.data; + + /* check whether the EventType is a Subtype of CondtionType + * (Part 9 first implementation) */ + UA_NodeId conditionTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_CONDITIONTYPE); + if(UA_NodeId_equal(validEventParent, &conditionTypeId) && + isNodeInTree_singleRef(server, tEventType, &conditionTypeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) { + UA_BrowsePathResult_clear(&bpr); + UA_Variant_clear(&tOutVariant); + return true; + } + + /*EventType is not a Subtype of CondtionType + *(ConditionId Clause won't be present in Events, which are not Conditions)*/ + /* check whether Valid Event other than Conditions */ + UA_NodeId baseEventTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE); + UA_Boolean isSubtypeOfBaseEvent = + isNodeInTree_singleRef(server, tEventType, &baseEventTypeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE); + + UA_BrowsePathResult_clear(&bpr); + UA_Variant_clear(&tOutVariant); + return isSubtypeOfBaseEvent; +} + +/* Part 4: 7.4.4.5 SimpleAttributeOperand + * The clause can point to any attribute of nodes. Either a child of the event + * node and also the event type. */ +static UA_StatusCode +resolveSimpleAttributeOperand(UA_Server *server, UA_Session *session, const UA_NodeId *origin, + const UA_SimpleAttributeOperand *sao, UA_Variant *value) { + /* Prepare the ReadValueId */ + UA_ReadValueId rvi; + UA_ReadValueId_init(&rvi); + rvi.indexRange = sao->indexRange; + rvi.attributeId = sao->attributeId; + + UA_DataValue v; + + if(sao->browsePathSize == 0) { + /* If this list (browsePath) is empty, the Node is the instance of the + * TypeDefinition. */ + rvi.nodeId = sao->typeDefinitionId; + + /* A Condition is an indirection. Look up the target node. */ + /* TODO: check for Branches! One Condition could have multiple Branches */ + UA_NodeId conditionTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_CONDITIONTYPE); + if(UA_NodeId_equal(&sao->typeDefinitionId, &conditionTypeId)) { +#ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS + UA_StatusCode res = UA_getConditionId(server, origin, &rvi.nodeId); + if(res != UA_STATUSCODE_GOOD) + return res; +#else + return UA_STATUSCODE_BADNOTSUPPORTED; +#endif + } + + v = UA_Server_readWithSession(server, session, &rvi, UA_TIMESTAMPSTORETURN_NEITHER); + + } else { + /* Resolve the browse path, starting from the event-source (and not the + * typeDefinitionId). */ + UA_BrowsePathResult bpr = + browseSimplifiedBrowsePath(server, *origin, sao->browsePathSize, sao->browsePath); + if(bpr.targetsSize == 0 && bpr.statusCode == UA_STATUSCODE_GOOD) + bpr.statusCode = UA_STATUSCODE_BADNOTFOUND; + if(bpr.statusCode != UA_STATUSCODE_GOOD) { + UA_StatusCode res = bpr.statusCode; + UA_BrowsePathResult_clear(&bpr); + return res; + } + + /* Use the first match */ + rvi.nodeId = bpr.targets[0].targetId.nodeId; + v = UA_Server_readWithSession(server, session, &rvi, UA_TIMESTAMPSTORETURN_NEITHER); + UA_BrowsePathResult_clear(&bpr); + } + + /* Move the result to the output */ + if(v.status == UA_STATUSCODE_GOOD && v.hasValue) + *value = v.value; + else + UA_Variant_clear(&v.value); + return v.status; +} + +/* Resolve operands to variants according to the operand type. + * Part 4: 7.17.3 Table 142 specifies the allowed types. */ +static UA_Variant +resolveOperand(UA_Server *server, UA_Session *session, const UA_NodeId *origin, + const UA_ContentFilter *contentFilter, + UA_ContentFilterResult *contentFilterResult, UA_Variant *valueResult, + UA_UInt16 index, UA_UInt16 nr) { + + UA_StatusCode res; + UA_Variant variant; + /*SimpleAttributeOperands*/ + if(contentFilter->elements[index].filterOperands[nr].content.decoded.type == + &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]) { + res = resolveSimpleAttributeOperand( + server, session, origin, + (UA_SimpleAttributeOperand *)contentFilter->elements[index] + .filterOperands[nr] + .content.decoded.data, + &variant); + /*LiteralAttribute*/ + } else if(contentFilter->elements[index].filterOperands[nr].content.decoded.type == + &UA_TYPES[UA_TYPES_LITERALOPERAND]) { + variant = ((UA_LiteralOperand *)contentFilter->elements[index] + .filterOperands[nr] + .content.decoded.data) + ->value; + res = UA_STATUSCODE_GOOD; + } else if(contentFilter->elements[index].filterOperands[nr].content.decoded.type == + &UA_TYPES[UA_TYPES_ELEMENTOPERAND]) { + res = evaluateWhereClauseContentFilter( + server, session, origin, contentFilter, contentFilterResult, valueResult, + (UA_UInt16)((UA_ElementOperand *)contentFilter->elements[index] + .filterOperands[nr] + .content.decoded.data) + ->index); + variant = + valueResult[(UA_UInt16)((UA_ElementOperand *)contentFilter->elements[index] + .filterOperands[nr] + .content.decoded.data) + ->index]; + /*ElementOperands*/ + } else { + res = UA_STATUSCODE_BADFILTEROPERANDINVALID; + } + if(res != UA_STATUSCODE_GOOD && res != UA_STATUSCODE_BADNOMATCH) { + variant.type = NULL; + contentFilterResult->elementResults[index].operandStatusCodes[nr] = res; + } + return variant; +} + +static UA_StatusCode +evaluateWhereClauseContentFilter(UA_Server *server, UA_Session *session, + const UA_NodeId *eventNode, + const UA_ContentFilter *contentFilter, + UA_ContentFilterResult *contentFilterResult, + UA_Variant* valueResult, UA_UInt16 index) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + if(contentFilter->elements == NULL || contentFilter->elementsSize == 0) { + /* Nothing to do.*/ + return UA_STATUSCODE_GOOD; + } + + /* The first element needs to be evaluated, this might be linked to other + * elements, which are evaluated in these cases. See 7.4.1 in Part 4. */ + UA_ContentFilterElement *pElement = &contentFilter->elements[0]; + switch(pElement->filterOperator) { + case UA_FILTEROPERATOR_INVIEW: + case UA_FILTEROPERATOR_RELATEDTO: { + /* Not allowed for event WhereClause according to 7.17.3 in Part 4 */ + return UA_STATUSCODE_BADEVENTFILTERINVALID; + } + case UA_FILTEROPERATOR_EQUALS: + case UA_FILTEROPERATOR_ISNULL: { + /* Checking if operand is NULL. This is done by reducing the operand to a + * variant and then checking if it is empty. */ + UA_Variant operand = + resolveOperand(server, session, eventNode, contentFilter, + contentFilterResult, valueResult, index, 0); + valueResult[index].type = &UA_TYPES[UA_TYPES_BOOLEAN]; + if(UA_Variant_isEmpty(&operand)) { + contentFilterResult->elementResults[index].statusCode = + UA_STATUSCODE_GOOD; + break; + } + contentFilterResult->elementResults[index].statusCode = + UA_STATUSCODE_BADNOMATCH; + break; + } + case UA_FILTEROPERATOR_GREATERTHAN: + case UA_FILTEROPERATOR_LESSTHAN: + case UA_FILTEROPERATOR_GREATERTHANOREQUAL: + case UA_FILTEROPERATOR_LESSTHANOREQUAL: + case UA_FILTEROPERATOR_LIKE: + case UA_FILTEROPERATOR_NOT: + case UA_FILTEROPERATOR_BETWEEN: + case UA_FILTEROPERATOR_INLIST: + case UA_FILTEROPERATOR_AND: + case UA_FILTEROPERATOR_OR: + case UA_FILTEROPERATOR_CAST: + case UA_FILTEROPERATOR_BITWISEAND: + case UA_FILTEROPERATOR_BITWISEOR: + return UA_STATUSCODE_BADFILTEROPERATORUNSUPPORTED; + + case UA_FILTEROPERATOR_OFTYPE: { + UA_Boolean result = UA_FALSE; + if(pElement->filterOperandsSize != 1) + return UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH; + if(pElement->filterOperands[0].content.decoded.type != + &UA_TYPES[UA_TYPES_LITERALOPERAND]) + return UA_STATUSCODE_BADFILTEROPERATORUNSUPPORTED; + + UA_LiteralOperand *pOperand = + (UA_LiteralOperand *) pElement->filterOperands[0].content.decoded.data; + if(!UA_Variant_isScalar(&pOperand->value)) + return UA_STATUSCODE_BADEVENTFILTERINVALID; + + if(pOperand->value.type != &UA_TYPES[UA_TYPES_NODEID] || + pOperand->value.data == NULL) { + result = UA_FALSE; + } else { + UA_NodeId *pOperandNodeId = (UA_NodeId *) pOperand->value.data; + UA_QualifiedName eventTypeQualifiedName = UA_QUALIFIEDNAME(0, "EventType"); + UA_Variant typeNodeIdVariant; + UA_Variant_init(&typeNodeIdVariant); + UA_StatusCode readStatusCode = + readObjectProperty(server, *eventNode, eventTypeQualifiedName, + &typeNodeIdVariant); + if(readStatusCode != UA_STATUSCODE_GOOD) + return readStatusCode; + + if(!UA_Variant_isScalar(&typeNodeIdVariant) || + typeNodeIdVariant.type != &UA_TYPES[UA_TYPES_NODEID] || + typeNodeIdVariant.data == NULL) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_SERVER, + "EventType has an invalid type."); + UA_Variant_clear(&typeNodeIdVariant); + return UA_STATUSCODE_BADINTERNALERROR; + } + + result = isNodeInTree_singleRef(server, + (UA_NodeId*) typeNodeIdVariant.data, + pOperandNodeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE); + UA_Variant_clear(&typeNodeIdVariant); + } + + if(result) + return UA_STATUSCODE_GOOD; + else + return UA_STATUSCODE_BADNOMATCH; + } + break; + default: + return UA_STATUSCODE_BADFILTEROPERATORINVALID; + break; + } + return contentFilterResult->elementResults[index].statusCode; +} + +UA_StatusCode +UA_Server_evaluateWhereClauseContentFilter(UA_Server *server, UA_Session *session, + const UA_NodeId *eventNode, + const UA_ContentFilter *contentFilter, + UA_ContentFilterResult *contentFilterResult) { + if(contentFilter->elementsSize == 0) + return UA_STATUSCODE_GOOD; + //TODO add maximum lenth size to the server config + if (contentFilter->elementsSize > 256) + return UA_STATUSCODE_BADINVALIDARGUMENT; + UA_STACKARRAY(UA_Variant, valueResult, contentFilter->elementsSize); + for(size_t i = 0; i < contentFilter->elementsSize; ++i) { + UA_Variant_init(&valueResult[i]); + } + UA_StatusCode res = evaluateWhereClauseContentFilter( + server, session, eventNode, contentFilter, contentFilterResult, valueResult, 0); + for(size_t i = 0; i < contentFilter->elementsSize; i++) { + if(!UA_Variant_isEmpty(&valueResult[i])) + UA_Variant_clear(&valueResult[i]); + } + return res; +} + +/* Filters the given event with the given filter and writes the results into a + * notification */ +static UA_StatusCode +UA_Server_filterEvent(UA_Server *server, UA_Session *session, + const UA_NodeId *eventNode, UA_EventFilter *filter, + UA_EventFieldList *efl, UA_EventFilterResult *result) { + if(filter->selectClausesSize == 0) + return UA_STATUSCODE_BADEVENTFILTERINVALID; + + UA_EventFieldList_init(efl); + efl->eventFields = (UA_Variant *) + UA_Array_new(filter->selectClausesSize, &UA_TYPES[UA_TYPES_VARIANT]); + if(!efl->eventFields) + return UA_STATUSCODE_BADOUTOFMEMORY; + efl->eventFieldsSize = filter->selectClausesSize; + + //empty event filter result + UA_EventFilterResult_init(result); + result->selectClauseResultsSize = filter->selectClausesSize; + result->selectClauseResults = (UA_StatusCode *) + UA_Array_new(filter->selectClausesSize, &UA_TYPES[UA_TYPES_STATUSCODE]); + if(!result->selectClauseResults) { + UA_EventFieldList_clear(efl); + UA_EventFilterResult_clear(result); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + //prepare content filter result structure + if(filter->whereClause.elementsSize != 0) { + result->whereClauseResult.elementResultsSize = filter->whereClause.elementsSize; + result->whereClauseResult.elementResults = (UA_ContentFilterElementResult *) + UA_Array_new(filter->whereClause.elementsSize, + &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]); + if(!result->whereClauseResult.elementResults) { + UA_EventFieldList_clear(efl); + UA_EventFilterResult_clear(result); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + for(size_t i = 0; i < result->whereClauseResult.elementResultsSize; ++i) { + result->whereClauseResult.elementResults[i].operandStatusCodesSize = + filter->whereClause.elements->filterOperandsSize; + result->whereClauseResult.elementResults[i].operandStatusCodes = + (UA_StatusCode *)UA_Array_new( + filter->whereClause.elements->filterOperandsSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); + if(!result->whereClauseResult.elementResults[i].operandStatusCodes) { + UA_EventFieldList_clear(efl); + UA_EventFilterResult_clear(result); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + } + } + + /* Apply the content (where) filter */ + UA_StatusCode res = + UA_Server_evaluateWhereClauseContentFilter(server, session, eventNode, + &filter->whereClause, &result->whereClauseResult); + if(res != UA_STATUSCODE_GOOD){ + UA_EventFieldList_clear(efl); + UA_EventFilterResult_clear(result); + return res; + } + + /* Apply the select filter */ + /* Check if the browsePath is BaseEventType, in which case nothing more + * needs to be checked */ + UA_NodeId baseEventTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE); + for(size_t i = 0; i < filter->selectClausesSize; i++) { + if(!UA_NodeId_equal(&filter->selectClauses[i].typeDefinitionId, &baseEventTypeId) && + !isValidEvent(server, &filter->selectClauses[i].typeDefinitionId, eventNode)) { + UA_Variant_init(&efl->eventFields[i]); + /* EventFilterResult currently isn't being used + notification->result.selectClauseResults[i] = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; */ + continue; + } + + /* TODO: Put the result into the selectClausResults */ + resolveSimpleAttributeOperand(server, session, eventNode, + &filter->selectClauses[i], &efl->eventFields[i]); + } + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +eventSetStandardFields(UA_Server *server, const UA_NodeId *event, + const UA_NodeId *origin, UA_ByteString *outEventId) { + /* Set the SourceNode */ + UA_StatusCode retval; + UA_QualifiedName name = UA_QUALIFIEDNAME(0, "SourceNode"); + UA_BrowsePathResult bpr = browseSimplifiedBrowsePath(server, *event, 1, &name); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + retval = bpr.statusCode; + UA_BrowsePathResult_clear(&bpr); + return retval; + } + UA_Variant value; + UA_Variant_init(&value); + UA_Variant_setScalarCopy(&value, origin, &UA_TYPES[UA_TYPES_NODEID]); + retval = writeValueAttribute(server, &server->adminSession, + &bpr.targets[0].targetId.nodeId, &value); + UA_Variant_clear(&value); + UA_BrowsePathResult_clear(&bpr); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Set the ReceiveTime */ + name = UA_QUALIFIEDNAME(0, "ReceiveTime"); + bpr = browseSimplifiedBrowsePath(server, *event, 1, &name); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + retval = bpr.statusCode; + UA_BrowsePathResult_clear(&bpr); + return retval; + } + UA_DateTime rcvTime = UA_DateTime_now(); + UA_Variant_setScalar(&value, &rcvTime, &UA_TYPES[UA_TYPES_DATETIME]); + retval = writeValueAttribute(server, &server->adminSession, + &bpr.targets[0].targetId.nodeId, &value); + UA_BrowsePathResult_clear(&bpr); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Set the EventId */ + UA_ByteString eventId = UA_BYTESTRING_NULL; + retval = UA_Event_generateEventId(&eventId); + if(retval != UA_STATUSCODE_GOOD) + return retval; + name = UA_QUALIFIEDNAME(0, "EventId"); + bpr = browseSimplifiedBrowsePath(server, *event, 1, &name); + if(bpr.statusCode != UA_STATUSCODE_GOOD || bpr.targetsSize < 1) { + retval = bpr.statusCode; + UA_ByteString_clear(&eventId); + UA_BrowsePathResult_clear(&bpr); + return retval; + } + UA_Variant_init(&value); + UA_Variant_setScalar(&value, &eventId, &UA_TYPES[UA_TYPES_BYTESTRING]); + retval = writeValueAttribute(server, &server->adminSession, + &bpr.targets[0].targetId.nodeId, &value); + UA_BrowsePathResult_clear(&bpr); + if(retval != UA_STATUSCODE_GOOD) { + UA_ByteString_clear(&eventId); + return retval; + } + + /* Return the EventId */ + if(outEventId) + *outEventId = eventId; + else + UA_ByteString_clear(&eventId); + + return UA_STATUSCODE_GOOD; +} + +/* Filters an event according to the filter specified by mon and then adds it to + * mons notification queue */ +UA_StatusCode +UA_Event_addEventToMonitoredItem(UA_Server *server, const UA_NodeId *event, + UA_MonitoredItem *mon) { + UA_Notification *notification = UA_Notification_new(); + if(!notification) + return UA_STATUSCODE_BADOUTOFMEMORY; + + if(mon->parameters.filter.content.decoded.type != &UA_TYPES[UA_TYPES_EVENTFILTER]) + return UA_STATUSCODE_BADFILTERNOTALLOWED; + UA_EventFilter *eventFilter = (UA_EventFilter*) + mon->parameters.filter.content.decoded.data; + + UA_Subscription *sub = mon->subscription; + UA_Session *session = sub->session; + UA_StatusCode retval = UA_Server_filterEvent(server, session, event, + eventFilter, ¬ification->data.event, + ¬ification->result); + if(retval != UA_STATUSCODE_GOOD) { + UA_Notification_delete(notification); + if(retval == UA_STATUSCODE_BADNOMATCH) + return UA_STATUSCODE_GOOD; + return retval; + } + + notification->data.event.clientHandle = mon->parameters.clientHandle; + notification->mon = mon; + + UA_Notification_enqueueAndTrigger(server, notification); + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_HISTORIZING +static void +setHistoricalEvent(UA_Server *server, const UA_NodeId *origin, + const UA_NodeId *emitNodeId, const UA_NodeId *eventNodeId) { + UA_Variant historicalEventFilterValue; + UA_Variant_init(&historicalEventFilterValue); + + /* A HistoricalEventNode that has event history available will provide this property */ + UA_StatusCode retval = + readObjectProperty(server, *emitNodeId, + UA_QUALIFIEDNAME(0, "HistoricalEventFilter"), + &historicalEventFilterValue); + if(retval != UA_STATUSCODE_GOOD) { + /* Do not vex users with no match errors */ + if(retval != UA_STATUSCODE_BADNOMATCH) + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Cannot read the HistoricalEventFilter property of a " + "listening node. StatusCode %s", + UA_StatusCode_name(retval)); + return; + } + + /* If found then check if HistoricalEventFilter property has a valid value */ + if(UA_Variant_isEmpty(&historicalEventFilterValue) || + !UA_Variant_isScalar(&historicalEventFilterValue) || + historicalEventFilterValue.type != &UA_TYPES[UA_TYPES_EVENTFILTER]) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "HistoricalEventFilter property of a listening node " + "does not have a valid value"); + UA_Variant_clear(&historicalEventFilterValue); + return; + } + + /* Finally, if found and valid then filter */ + UA_EventFilter *filter = (UA_EventFilter*) historicalEventFilterValue.data; + UA_EventFieldList efl; + UA_EventFilterResult result; + retval = UA_Server_filterEvent(server, &server->adminSession, + eventNodeId, filter, &efl, &result); + if(retval == UA_STATUSCODE_GOOD) + server->config.historyDatabase.setEvent(server, server->config.historyDatabase.context, + origin, emitNodeId, filter, &efl); + UA_EventFilterResult_clear(&result); + UA_Variant_clear(&historicalEventFilterValue); + UA_EventFieldList_clear(&efl); +} +#endif + +static const UA_NodeId objectsFolderId = {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_OBJECTSFOLDER}}; +#define EMIT_REFS_ROOT_COUNT 4 +static const UA_NodeId emitReferencesRoots[EMIT_REFS_ROOT_COUNT] = + {{0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_ORGANIZES}}, + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASCOMPONENT}}, + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASEVENTSOURCE}}, + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASNOTIFIER}}}; + +static const UA_NodeId isInFolderReferences[2] = + {{0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_ORGANIZES}}, + {0, UA_NODEIDTYPE_NUMERIC, {UA_NS0ID_HASCOMPONENT}}}; + +UA_StatusCode +triggerEvent(UA_Server *server, const UA_NodeId eventNodeId, + const UA_NodeId origin, UA_ByteString *outEventId, + const UA_Boolean deleteEventNode) { + UA_LOCK_ASSERT(&server->serviceMutex, 1); + + UA_LOG_NODEID_DEBUG(&origin, + UA_LOG_DEBUG(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Events: An event is triggered on node %.*s", + (int)nodeIdStr.length, nodeIdStr.data)); + +#ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS + UA_Boolean isCallerAC = false; + if(isConditionOrBranch(server, &eventNodeId, &origin, &isCallerAC)) { + if(!isCallerAC) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Condition Events: Please use A&C API to trigger Condition Events 0x%08X", + UA_STATUSCODE_BADINVALIDARGUMENT); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + } +#endif /* UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS */ + + /* Check that the origin node exists */ + const UA_Node *originNode = UA_NODESTORE_GET(server, &origin); + if(!originNode) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "Origin node for event does not exist."); + return UA_STATUSCODE_BADNOTFOUND; + } + UA_NODESTORE_RELEASE(server, originNode); + + /* Make sure the origin is in the ObjectsFolder (TODO: or in the ViewsFolder) */ + /* Only use Organizes and HasComponent to check if we are below the ObjectsFolder */ + UA_StatusCode retval; + UA_ReferenceTypeSet refTypes; + UA_ReferenceTypeSet_init(&refTypes); + for(int i = 0; i < 2; ++i) { + UA_ReferenceTypeSet tmpRefTypes; + retval = referenceTypeIndices(server, &isInFolderReferences[i], &tmpRefTypes, true); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Events: Could not create the list of references and their subtypes " + "with StatusCode %s", UA_StatusCode_name(retval)); + } + refTypes = UA_ReferenceTypeSet_union(refTypes, tmpRefTypes); + } + + if(!isNodeInTree(server, &origin, &objectsFolderId, &refTypes)) { + UA_LOG_ERROR(&server->config.logger, UA_LOGCATEGORY_USERLAND, + "Node for event must be in ObjectsFolder!"); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + /* Update the standard fields of the event */ + retval = eventSetStandardFields(server, &eventNodeId, &origin, outEventId); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Events: Could not set the standard event fields with StatusCode %s", + UA_StatusCode_name(retval)); + return retval; + } + + /* List of nodes that emit the node. Events propagate upwards (bubble up) in + * the node hierarchy. */ + UA_ExpandedNodeId *emitNodes = NULL; + size_t emitNodesSize = 0; + + /* Add the server node to the list of nodes from which the event is emitted. + * The server node emits all events. + * + * Part 3, 7.17: In particular, the root notifier of a Server, the Server + * Object defined in Part 5, is always capable of supplying all Events from + * a Server and as such has implied HasEventSource References to every event + * source in a Server. */ + UA_NodeId emitStartNodes[2]; + emitStartNodes[0] = origin; + emitStartNodes[1] = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER); + + /* Get all ReferenceTypes over which the events propagate */ + UA_ReferenceTypeSet emitRefTypes; + UA_ReferenceTypeSet_init(&emitRefTypes); + for(size_t i = 0; i < EMIT_REFS_ROOT_COUNT; i++) { + UA_ReferenceTypeSet tmpRefTypes; + retval = referenceTypeIndices(server, &emitReferencesRoots[i], &tmpRefTypes, true); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Events: Could not create the list of references for event " + "propagation with StatusCode %s", UA_StatusCode_name(retval)); + goto cleanup; + } + emitRefTypes = UA_ReferenceTypeSet_union(emitRefTypes, tmpRefTypes); + } + + /* Get the list of nodes in the hierarchy that emits the event. */ + retval = browseRecursive(server, 2, emitStartNodes, UA_BROWSEDIRECTION_INVERSE, + &emitRefTypes, UA_NODECLASS_UNSPECIFIED, true, + &emitNodesSize, &emitNodes); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Events: Could not create the list of nodes listening on the " + "event with StatusCode %s", UA_StatusCode_name(retval)); + goto cleanup; + } + + /* Add the event to the listening MonitoredItems at each relevant node */ + for(size_t i = 0; i < emitNodesSize; i++) { + /* Get the node */ + const UA_Node *node = UA_NODESTORE_GET(server, &emitNodes[i].nodeId); + if(!node) + continue; + + /* Only consider objects */ + if(node->head.nodeClass != UA_NODECLASS_OBJECT) { + UA_NODESTORE_RELEASE(server, node); + continue; + } + + /* Add event to monitoreditems */ + for(UA_MonitoredItem *mon = node->head.monitoredItems; mon != NULL; mon = mon->next) { + /* Is this an Event-MonitoredItem? */ + if(mon->itemToMonitor.attributeId != UA_ATTRIBUTEID_EVENTNOTIFIER) + continue; + retval = UA_Event_addEventToMonitoredItem(server, &eventNodeId, mon); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Events: Could not add the event to a listening " + "node with StatusCode %s", UA_StatusCode_name(retval)); + retval = UA_STATUSCODE_GOOD; /* Only log problems with individual emit nodes */ + } + } + + UA_NODESTORE_RELEASE(server, node); + + /* Add event entry in the historical database */ +#ifdef UA_ENABLE_HISTORIZING + if(server->config.historyDatabase.setEvent) + setHistoricalEvent(server, &origin, &emitNodes[i].nodeId, &eventNodeId); +#endif + } + + /* Delete the node representation of the event */ + if(deleteEventNode) { + retval = deleteNode(server, eventNodeId, true); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&server->config.logger, UA_LOGCATEGORY_SERVER, + "Attempt to remove event using deleteNode failed. StatusCode %s", + UA_StatusCode_name(retval)); + } + } + + cleanup: + UA_Array_delete(emitNodes, emitNodesSize, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); + return retval; +} + +/* + * Initial select clause validation. The following checks are currently performed: + * - Check if typedefenitionid or browsepath of any clause is NULL + * - Check if the eventType is a subtype of BaseEventType + * - Check if attributeId is valid + * - Check if browsePath contains null + * - Check if indexRange is defined and if it is parsable + * - Check if attributeId is value + */ +void +UA_Event_staticSelectClauseValidation(UA_Server *server, + const UA_EventFilter *eventFilter, + UA_StatusCode *result) { + /* The selectClause only has to be checked, if the size is not zero */ + if(eventFilter->selectClausesSize == 0) + return; + for(size_t i = 0; i < eventFilter->selectClausesSize; ++i) { + result[i] = UA_STATUSCODE_GOOD; + ///typedefenitionid or browsepath of any clause is not NULL ? + if(UA_NodeId_isNull(&eventFilter->selectClauses[i].typeDefinitionId)) { + result[i] = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + continue; + } + /*ToDo: Check the following workaround. In UaExpert Event View the selection + * of the Server Object set up 7 select filter entries by default. The last + * element ist from node 2782 (A&C ConditionType). Since the reduced + * information model dos not contain this type, the result has a brows path of + * "null" which results in an error. */ + UA_NodeId ac_conditionType = UA_NODEID_NUMERIC(0, UA_NS0ID_CONDITIONTYPE); + if(UA_NodeId_equal(&eventFilter->selectClauses[i].typeDefinitionId, &ac_conditionType)) { + continue; + } + if(&eventFilter->selectClauses[i].browsePath[0] == NULL) { + result[i] = UA_STATUSCODE_BADBROWSENAMEINVALID; + continue; + } + //eventType is a subtype of BaseEventType ? + UA_NodeId baseEventTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE); + if(!isNodeInTree_singleRef( + server, &eventFilter->selectClauses[i].typeDefinitionId, + &baseEventTypeId, UA_REFERENCETYPEINDEX_HASSUBTYPE)) { + result[i] = UA_STATUSCODE_BADTYPEDEFINITIONINVALID; + continue; + } + //attributeId is valid ? + if(!((0 < eventFilter->selectClauses[i].attributeId) && + (eventFilter->selectClauses[i].attributeId < 28))) { + result[i] = UA_STATUSCODE_BADATTRIBUTEIDINVALID; + continue; + } + //browsePath contains null ? + for(size_t j = 0; j < eventFilter->selectClauses[i].browsePathSize; ++j) { + if(UA_QualifiedName_isNull( + &eventFilter->selectClauses[i].browsePath[j])) { + result[i] = UA_STATUSCODE_BADBROWSENAMEINVALID; + break; + } + } + if(result[i] != UA_STATUSCODE_GOOD) + continue; + //indexRange is defined ? + if(!UA_String_equal(&eventFilter->selectClauses[i].indexRange, + &UA_STRING_NULL)) { + //indexRange is parsable ? + UA_NumericRange numericRange = UA_NUMERICRANGE(""); + if(UA_NumericRange_parse(&numericRange, + eventFilter->selectClauses[i].indexRange) != + UA_STATUSCODE_GOOD) { + result[i] = UA_STATUSCODE_BADINDEXRANGEINVALID; + continue; + } + UA_free(numericRange.dimensions); + //attributeId is value ? + if(eventFilter->selectClauses[i].attributeId != UA_ATTRIBUTEID_VALUE) { + result[i] = UA_STATUSCODE_BADTYPEMISMATCH; + continue; + } + } + } +} + +/* + * Initial content filter (where clause) check. Current checks: + * - Number of operands for each (supported) operator + */ +UA_StatusCode +UA_Event_staticWhereClauseValidation(UA_Server *server, + const UA_ContentFilter *filter, + UA_ContentFilterResult *result) { + UA_ContentFilterResult_init(result); + result->elementResultsSize = filter->elementsSize; + if(result->elementResultsSize == 0) + return UA_STATUSCODE_GOOD; + result->elementResults = + (UA_ContentFilterElementResult *)UA_Array_new( + result->elementResultsSize, + &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]); + if(!result->elementResults) + return UA_STATUSCODE_BADOUTOFMEMORY; + for(size_t i = 0; i < result->elementResultsSize; ++i) { + UA_ContentFilterElementResult *er = &result->elementResults[i]; + UA_ContentFilterElement ef = filter->elements[i]; + UA_ContentFilterElementResult_init(er); + er->operandStatusCodes = + (UA_StatusCode *)UA_Array_new( + ef.filterOperandsSize, + &UA_TYPES[UA_TYPES_STATUSCODE]); + er->operandStatusCodesSize = ef.filterOperandsSize; + + switch(ef.filterOperator) { + case UA_FILTEROPERATOR_INVIEW: + case UA_FILTEROPERATOR_RELATEDTO: { + /* Not allowed for event WhereClause according to 7.17.3 in Part 4 */ + er->statusCode = + UA_STATUSCODE_BADEVENTFILTERINVALID; + break; + } + case UA_FILTEROPERATOR_EQUALS: + case UA_FILTEROPERATOR_GREATERTHAN: + case UA_FILTEROPERATOR_LESSTHAN: + case UA_FILTEROPERATOR_GREATERTHANOREQUAL: + case UA_FILTEROPERATOR_LESSTHANOREQUAL: + case UA_FILTEROPERATOR_LIKE: + case UA_FILTEROPERATOR_CAST: + case UA_FILTEROPERATOR_BITWISEAND: + case UA_FILTEROPERATOR_BITWISEOR: { + if(ef.filterOperandsSize != 2) { + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH; + break; + } + er->statusCode = UA_STATUSCODE_GOOD; + break; + } + case UA_FILTEROPERATOR_AND: + case UA_FILTEROPERATOR_OR: { + if(ef.filterOperandsSize != 2) { + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH; + break; + } + for(size_t j = 0; j < 2; ++j) { + if(ef.filterOperands[j].content.decoded.type != + &UA_TYPES[UA_TYPES_ELEMENTOPERAND]) { + er->operandStatusCodes[j] = + UA_STATUSCODE_BADFILTEROPERANDINVALID; + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDINVALID; + break; + } + if(((UA_ElementOperand *)ef.filterOperands[j] + .content.decoded.data)->index > filter->elementsSize - 1) { + er->operandStatusCodes[j] = + UA_STATUSCODE_BADINDEXRANGEINVALID; + er->statusCode = + UA_STATUSCODE_BADINDEXRANGEINVALID; + break; + } + } + er->statusCode = UA_STATUSCODE_GOOD; + break; + } + case UA_FILTEROPERATOR_ISNULL: + case UA_FILTEROPERATOR_NOT: { + if(ef.filterOperandsSize != 1) { + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH; + break; + } + er->statusCode = UA_STATUSCODE_GOOD; + break; + } + case UA_FILTEROPERATOR_INLIST: { + if(ef.filterOperandsSize >= 2) { + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH; + break; + } + er->statusCode = UA_STATUSCODE_GOOD; + break; + } + case UA_FILTEROPERATOR_BETWEEN: { + if(ef.filterOperandsSize != 3) { + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH; + break; + } + er->statusCode = UA_STATUSCODE_GOOD; + break; + } + case UA_FILTEROPERATOR_OFTYPE: { + if(ef.filterOperandsSize != 1) { + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH; + break; + } + er->operandStatusCodesSize = ef.filterOperandsSize; + if(ef.filterOperands[0].content.decoded.type != + &UA_TYPES[UA_TYPES_LITERALOPERAND]) { + er->statusCode = + UA_STATUSCODE_BADFILTEROPERANDINVALID; + break; + } + UA_LiteralOperand *literalOperand = + (UA_LiteralOperand *)ef.filterOperands[0] + .content.decoded.data; + + if(((UA_NodeId *)literalOperand->value.data)->identifierType != + UA_NODEIDTYPE_NUMERIC) { + er->statusCode = + UA_STATUSCODE_BADATTRIBUTEIDINVALID; + break; + } + /* Make sure the &pOperand->nodeId is a subtype of BaseEventType */ + UA_NodeId baseEventTypeId = UA_NODEID_NUMERIC(0, UA_NS0ID_BASEEVENTTYPE); + if(!isNodeInTree_singleRef( + server, (UA_NodeId *)literalOperand->value.data, &baseEventTypeId, + UA_REFERENCETYPEINDEX_HASSUBTYPE)) { + er->statusCode = + UA_STATUSCODE_BADNODEIDINVALID; + break; + } + er->statusCode = UA_STATUSCODE_GOOD; + break; + } + default: + er->statusCode = + UA_STATUSCODE_BADFILTEROPERATORUNSUPPORTED; + break; + } + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Server_triggerEvent(UA_Server *server, const UA_NodeId eventNodeId, + const UA_NodeId origin, UA_ByteString *outEventId, + const UA_Boolean deleteEventNode) { + UA_LOCK(&server->serviceMutex); + UA_StatusCode res = + triggerEvent(server, eventNodeId, origin, outEventId, deleteEventNode); + UA_UNLOCK(&server->serviceMutex); + return res; +} +#endif /* UA_ENABLE_SUBSCRIPTIONS_EVENTS */ + +/**** amalgamated original file "/plugins/crypto/openssl/securitypolicy_openssl_common.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + * + */ + + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + +#include +#include + +_UA_BEGIN_DECLS + +void saveDataToFile(const char *fileName, const UA_ByteString *str); +void UA_Openssl_Init(void); + +UA_StatusCode +UA_copyCertificate(UA_ByteString *dst, const UA_ByteString *src); + +UA_StatusCode +UA_OpenSSL_RSA_PKCS1_V15_SHA256_Verify(const UA_ByteString *msg, + X509 *publicKeyX509, + const UA_ByteString *signature); +UA_StatusCode +UA_Openssl_X509_GetCertificateThumbprint(const UA_ByteString *certficate, + UA_ByteString *pThumbprint, + bool bThumbPrint); +UA_StatusCode +UA_Openssl_RSA_Oaep_Decrypt(UA_ByteString *data, + EVP_PKEY *privateKey); +UA_StatusCode +UA_Openssl_RSA_OAEP_Encrypt(UA_ByteString *data, /* The data that is encrypted. + The encrypted data will overwrite + the data that was supplied. */ + size_t paddingSize, X509 *publicX509); + +UA_StatusCode +UA_Openssl_Random_Key_PSHA256_Derive(const UA_ByteString *secret, + const UA_ByteString *seed, + UA_ByteString *out); + +UA_StatusCode +UA_Openssl_RSA_Public_GetKeyLength(X509 *publicKeyX509, UA_Int32 *keyLen); + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_SHA256_Sign(const UA_ByteString *data, + EVP_PKEY *privateKey, + UA_ByteString *outSignature); + +UA_StatusCode +UA_OpenSSL_HMAC_SHA256_Verify(const UA_ByteString *message, + const UA_ByteString *key, + const UA_ByteString *signature); + +UA_StatusCode +UA_OpenSSL_HMAC_SHA256_Sign(const UA_ByteString *message, + const UA_ByteString *key, + UA_ByteString *signature); + +UA_StatusCode +UA_OpenSSL_AES_256_CBC_Decrypt(const UA_ByteString *iv, + const UA_ByteString *key, + UA_ByteString *data /* [in/out]*/); + +UA_StatusCode +UA_OpenSSL_AES_256_CBC_Encrypt(const UA_ByteString *iv, + const UA_ByteString *key, + UA_ByteString *data /* [in/out]*/); + +UA_StatusCode +UA_OpenSSL_X509_compare(const UA_ByteString *cert, const X509 *b); + +UA_StatusCode +UA_Openssl_RSA_Private_GetKeyLength(EVP_PKEY *privateKey, + UA_Int32 *keyLen) ; + +UA_StatusCode +UA_OpenSSL_RSA_PKCS1_V15_SHA1_Verify(const UA_ByteString *msg, + X509 *publicKeyX509, + const UA_ByteString *signature); + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_SHA1_Sign(const UA_ByteString *message, + EVP_PKEY *privateKey, + UA_ByteString *outSignature); +UA_StatusCode +UA_Openssl_Random_Key_PSHA1_Derive(const UA_ByteString *secret, + const UA_ByteString *seed, + UA_ByteString *out); +UA_StatusCode +UA_OpenSSL_HMAC_SHA1_Verify(const UA_ByteString *message, + const UA_ByteString *key, + const UA_ByteString *signature); + +UA_StatusCode +UA_OpenSSL_HMAC_SHA1_Sign(const UA_ByteString *message, + const UA_ByteString *key, + UA_ByteString *signature); + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_Decrypt(UA_ByteString *data, + EVP_PKEY *privateKey); + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_Encrypt(UA_ByteString *data, + size_t paddingSize, + X509 *publicX509); + +UA_StatusCode +UA_OpenSSL_AES_128_CBC_Decrypt(const UA_ByteString *iv, + const UA_ByteString *key, + UA_ByteString *data /* [in/out]*/); + +UA_StatusCode +UA_OpenSSL_AES_128_CBC_Encrypt(const UA_ByteString *iv, + const UA_ByteString *key, + UA_ByteString *data /* [in/out]*/); + +EVP_PKEY * +UA_OpenSSL_LoadPrivateKey(const UA_ByteString *privateKey); + +X509 * +UA_OpenSSL_LoadCertificate(const UA_ByteString *certificate); + +X509 * +UA_OpenSSL_LoadDerCertificate(const UA_ByteString *certificate); + +X509 * +UA_OpenSSL_LoadPemCertificate(const UA_ByteString *certificate); + +UA_StatusCode +UA_OpenSSL_LoadLocalCertificate(const UA_ByteString *certificate, UA_ByteString *target); + +_UA_END_DECLS + +#endif /* defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) */ + + +/**** amalgamated original file "/plugins/crypto/openssl/ua_openssl_version_abstraction.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2021 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + * + */ + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + +#include + +#if !defined(OPENSSL_VERSION_NUMBER) +#error "OPENSSL_VERSION_NUMBER is not defined." +#endif + +#if OPENSSL_VERSION_NUMBER < 0x10100000L || defined(LIBRESSL_VERSION_NUMBER) +#define X509_STORE_CTX_set0_trusted_stack(STORE_CTX, CTX_SKTRUSTED) X509_STORE_CTX_trusted_stack(STORE_CTX, CTX_SKTRUSTED) +#endif + +#if OPENSSL_VERSION_NUMBER < 0x1010000fL || defined(LIBRESSL_VERSION_NUMBER) +#define X509_STORE_CTX_get_check_issued(STORE_CTX) storeCtx->check_issued +#endif + +#if OPENSSL_VERSION_NUMBER < 0x1010000fL || defined(LIBRESSL_VERSION_NUMBER) +#define get_pkey_rsa(evp) ((evp)->pkey.rsa) +#else +#define get_pkey_rsa(evp) EVP_PKEY_get0_RSA(evp) +#endif + +#if OPENSSL_VERSION_NUMBER < 0x1010000fL || defined(LIBRESSL_VERSION_NUMBER) +#define X509_get0_subject_key_id(PX509_CERT) (const ASN1_OCTET_STRING *)X509_get_ext_d2i(PX509_CERT, NID_subject_key_identifier, NULL, NULL); +#endif + +#endif /* defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) */ + +/**** amalgamated original file "/plugins/crypto/openssl/securitypolicy_openssl_common.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + */ + +/* +modification history +-------------------- +01feb20,lan written +*/ + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + +#include +#include +#include +#include +#include +#include +#include +#include + + +#define SHA1_DIGEST_LENGTH 20 /* 160 bits */ + +/** P_SHA256 Context */ +typedef struct UA_Openssl_P_SHA256_Ctx_ { + size_t seedLen; + size_t secretLen; + UA_Byte A[32]; /* 32 bytes of SHA256 output */ + /* + char seed[seedLen]; + char secret[secretLen]; */ +} UA_Openssl_P_SHA256_Ctx; + +#define UA_Openssl_P_SHA256_SEED(ctx) ((ctx)->A+32) +#define UA_Openssl_P_SHA256_SECRET(ctx) ((ctx)->A+32+(ctx)->seedLen) + +/** P_SHA1 Context */ +typedef struct UA_Openssl_P_SHA1_Ctx_ { + size_t seedLen; + size_t secretLen; + UA_Byte A[SHA1_DIGEST_LENGTH]; /* 20 bytes of SHA1 output */ + /* + char seed[seedLen]; + char secret[secretLen]; */ +} UA_Openssl_P_SHA1_Ctx; + +#define UA_Openssl_P_SHA1_SEED(ctx) ((ctx)->A + SHA1_DIGEST_LENGTH) +#define UA_Openssl_P_SHA1_SECRET(ctx) ((ctx)->A + SHA1_DIGEST_LENGTH +(ctx)->seedLen) + +void +UA_Openssl_Init (void) { + /* VxWorks7 has initialized the openssl. */ +#ifndef __VXWORKS__ + static UA_Int16 bInit = 0; + if (bInit == 1) + return; +#if defined(OPENSSL_API_COMPAT) && (OPENSSL_API_COMPAT < 0x10100000L) + /* only needed, if OpenSSL < V1.1 */ + OpenSSL_add_all_algorithms (); + ERR_load_crypto_strings (); +#endif + bInit = 1; +#endif +} + +/* UA_copyCertificate - allocalte the buffer, copy the certificate and + * add a NULL to the end + */ + +UA_StatusCode +UA_copyCertificate (UA_ByteString * dst, + const UA_ByteString * src) { + UA_StatusCode retval = UA_ByteString_allocBuffer (dst, src->length + 1); + if (retval != UA_STATUSCODE_GOOD) + return retval; + (void) memcpy (dst->data, src->data, src->length); + dst->data[dst->length - 1] = '\0'; + dst->length--; + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_OpenSSL_RSA_Public_Verify (const UA_ByteString * message, + const EVP_MD * evpMd, + X509 * publicKeyX509, + UA_Int16 padding, + const UA_ByteString * signature + ) { + EVP_MD_CTX * mdctx = NULL; + int opensslRet; + EVP_PKEY_CTX * evpKeyCtx; + EVP_PKEY * evpPublicKey = NULL; + UA_StatusCode ret; + + mdctx = EVP_MD_CTX_create (); + if (mdctx == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto errout; + } + evpPublicKey = X509_get_pubkey (publicKeyX509); + if (evpPublicKey == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto errout; + } + + opensslRet = EVP_DigestVerifyInit (mdctx, &evpKeyCtx, evpMd, NULL, + evpPublicKey); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + EVP_PKEY_CTX_set_rsa_padding (evpKeyCtx, padding); + opensslRet = EVP_DigestVerifyUpdate (mdctx, message->data, message->length); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + opensslRet = EVP_DigestVerifyFinal(mdctx, signature->data, signature->length); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + + ret = UA_STATUSCODE_GOOD; +errout: + if (evpPublicKey != NULL) { + EVP_PKEY_free (evpPublicKey); + } + if (mdctx != NULL) { + EVP_MD_CTX_destroy (mdctx); + } + return ret; +} + +UA_StatusCode +UA_OpenSSL_RSA_PKCS1_V15_SHA256_Verify (const UA_ByteString * msg, + X509 * publicKeyX509, + const UA_ByteString * signature + ) { + return UA_OpenSSL_RSA_Public_Verify (msg, EVP_sha256(), publicKeyX509, + NID_sha256, signature); +} + +/* Get certificate thumbprint, and allocate the buffer. */ + +UA_StatusCode +UA_Openssl_X509_GetCertificateThumbprint (const UA_ByteString * certficate, + UA_ByteString * pThumbprint, + bool bThumbPrint) { + if (bThumbPrint) { + pThumbprint->length = SHA_DIGEST_LENGTH; + UA_StatusCode ret = UA_ByteString_allocBuffer (pThumbprint, pThumbprint->length); + if (ret != UA_STATUSCODE_GOOD) { + return ret; + } + } + else { + if (pThumbprint->length != SHA_DIGEST_LENGTH) { + return UA_STATUSCODE_BADINTERNALERROR; + } + } + X509 * x509Certificate = UA_OpenSSL_LoadCertificate(certficate); + + if (x509Certificate == NULL) { + if (bThumbPrint) { + UA_ByteString_clear (pThumbprint); + } + return UA_STATUSCODE_BADINTERNALERROR; + } + + if (X509_digest (x509Certificate, EVP_sha1(), pThumbprint->data, NULL) + != 1) { + if (bThumbPrint) { + UA_ByteString_clear (pThumbprint); + } + return UA_STATUSCODE_BADINTERNALERROR; + } + X509_free(x509Certificate); + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_Openssl_RSA_Private_Decrypt (UA_ByteString * data, + EVP_PKEY * privateKey, + UA_Int16 padding) { + if (data == NULL || privateKey == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + if (privateKey == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_Int32 keySize = RSA_size(get_pkey_rsa(privateKey)); + size_t cipherOffset = 0; + size_t outOffset = 0; + unsigned char buf[2048]; + UA_Int32 decryptedBytes; + + while (cipherOffset < data->length) { + decryptedBytes = RSA_private_decrypt (keySize, + data->data + cipherOffset, /* what to decrypt */ + buf, /* where to decrypt */ + get_pkey_rsa(privateKey), /* private key */ + padding + ); + if (decryptedBytes < 0) { + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + memcpy(data->data + outOffset, buf, (size_t) decryptedBytes); + cipherOffset += (size_t) keySize; + outOffset += (size_t) decryptedBytes; + } + data->length = outOffset; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Openssl_RSA_Oaep_Decrypt (UA_ByteString * data, + EVP_PKEY * privateKey) { + return UA_Openssl_RSA_Private_Decrypt (data, privateKey, + RSA_PKCS1_OAEP_PADDING); +} + +static UA_StatusCode +UA_Openssl_RSA_Public_Encrypt (const UA_ByteString * message, + X509 * publicX509, + UA_Int16 padding, + size_t paddingSize, + UA_ByteString * encrypted) { + EVP_PKEY_CTX * ctx = NULL; + EVP_PKEY * evpPublicKey = NULL; + int opensslRet; + UA_StatusCode ret; + size_t encryptedTextLen = 0; + size_t dataPos = 0; + size_t encryptedPos = 0; + size_t bytesToEncrypt = 0; + size_t encryptedBlockSize = 0; + RSA * rsa = NULL; + size_t keySize = 0; + + evpPublicKey = X509_get_pubkey (publicX509); + if (evpPublicKey == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto errout; + } + ctx = EVP_PKEY_CTX_new (evpPublicKey, NULL); + if (ctx == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto errout; + } + opensslRet = EVP_PKEY_encrypt_init (ctx); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + opensslRet = EVP_PKEY_CTX_set_rsa_padding (ctx, padding); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + + /* get the encrypted block size */ + rsa = get_pkey_rsa (evpPublicKey); + keySize = (size_t) RSA_size (rsa); + if (keySize == 0) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + + switch (padding) { + case RSA_PKCS1_OAEP_PADDING: + case RSA_PKCS1_PADDING: + if (keySize <= paddingSize) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + encryptedBlockSize = keySize - paddingSize; + break; + default: + ret = UA_STATUSCODE_BADNOTSUPPORTED; + goto errout; + break; + } + + /* encrypt in reverse order so that [data] may alias [encrypted] */ + + dataPos = message->length; + encryptedPos = ((dataPos - 1) / encryptedBlockSize + 1) * keySize; + bytesToEncrypt = (dataPos - 1) % encryptedBlockSize + 1; + encryptedTextLen = encryptedPos; + + while (dataPos > 0) { + size_t outlen = keySize; + encryptedPos -= keySize; + dataPos -= bytesToEncrypt; + opensslRet = EVP_PKEY_encrypt (ctx, encrypted->data + encryptedPos, &outlen, + message->data + dataPos, bytesToEncrypt); + + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + bytesToEncrypt = encryptedBlockSize; + } + encrypted->length = encryptedTextLen; + + ret = UA_STATUSCODE_GOOD; +errout: + if (evpPublicKey != NULL) { + EVP_PKEY_free (evpPublicKey); + } + if (ctx != NULL) { + EVP_PKEY_CTX_free (ctx); + } + return ret; +} + +UA_StatusCode +UA_Openssl_RSA_OAEP_Encrypt (UA_ByteString * data, + size_t paddingSize, + X509 * publicX509) { + UA_ByteString message; + UA_StatusCode ret; + + ret = UA_ByteString_copy (data, &message); + if (ret != UA_STATUSCODE_GOOD) { + return ret; + } + ret = UA_Openssl_RSA_Public_Encrypt (&message, publicX509, + RSA_PKCS1_OAEP_PADDING, + paddingSize, + data); + UA_ByteString_clear (&message); + return ret; +} + +static UA_Openssl_P_SHA256_Ctx * +P_SHA256_Ctx_Create (const UA_ByteString * secret, + const UA_ByteString * seed) { + size_t size = (UA_Int32)sizeof (UA_Openssl_P_SHA256_Ctx) + secret->length + + seed->length; + UA_Openssl_P_SHA256_Ctx * ctx = (UA_Openssl_P_SHA256_Ctx *) UA_malloc (size); + if (ctx == NULL) { + return NULL; + } + ctx->secretLen = secret->length; + ctx->seedLen = seed->length; + (void) memcpy (UA_Openssl_P_SHA256_SEED(ctx), seed->data, seed->length); + (void) memcpy (UA_Openssl_P_SHA256_SECRET(ctx), secret->data, secret->length); + /* A(0) = seed + A(n) = HMAC_HASH(secret, A(n-1)) */ + + if (HMAC (EVP_sha256(), secret->data, (int) secret->length, seed->data, + seed->length, ctx->A, NULL) == NULL) { + UA_free (ctx); + return NULL; + } + + return ctx; +} + +static UA_StatusCode +P_SHA256_Hash_Generate (UA_Openssl_P_SHA256_Ctx * ctx, + UA_Byte * pHas + ) { + /* Calculate P_SHA256(n) = HMAC_SHA256(secret, A(n)+seed) */ + if (HMAC (EVP_sha256(),UA_Openssl_P_SHA256_SECRET(ctx), (int) ctx->secretLen, + ctx->A, sizeof (ctx->A) + ctx->seedLen, pHas, NULL) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Calculate A(n) = HMAC_SHA256(secret, A(n-1)) */ + if (HMAC (EVP_sha256(),UA_Openssl_P_SHA256_SECRET(ctx), (int) ctx->secretLen, + ctx->A, sizeof (ctx->A), ctx->A, NULL) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Openssl_Random_Key_PSHA256_Derive (const UA_ByteString * secret, + const UA_ByteString * seed, + UA_ByteString * out) { + size_t keyLen = out->length; + size_t iter = keyLen/32 + ((keyLen%32)?1:0); + size_t bufferLen = iter * 32; + size_t i; + UA_StatusCode st; + + UA_Byte * pBuffer = (UA_Byte *) UA_malloc (bufferLen); + if (pBuffer == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_Openssl_P_SHA256_Ctx * ctx = P_SHA256_Ctx_Create (secret, seed); + if (ctx == NULL) { + UA_free (pBuffer); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + for (i = 0; i < iter; i++) { + st = P_SHA256_Hash_Generate (ctx, pBuffer + (i * 32)); + if (st != UA_STATUSCODE_GOOD) { + UA_free (pBuffer); + UA_free (ctx); + return st; + } + } + + (void) memcpy (out->data, pBuffer, keyLen); + UA_free (pBuffer); + UA_free (ctx); + return UA_STATUSCODE_GOOD; +} + +/* return the key bytes */ +UA_StatusCode +UA_Openssl_RSA_Public_GetKeyLength (X509 * publicKeyX509, + UA_Int32 * keyLen) { + EVP_PKEY * evpKey = X509_get_pubkey (publicKeyX509); + if (evpKey == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + RSA * rsa = get_pkey_rsa (evpKey); + *keyLen = RSA_size(rsa); + EVP_PKEY_free (evpKey); + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Openssl_RSA_Private_GetKeyLength (EVP_PKEY * privateKey, + UA_Int32 * keyLen) { + if (privateKey == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + *keyLen = RSA_size(get_pkey_rsa(privateKey)); + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_Openssl_RSA_Private_Sign (const UA_ByteString * message, + EVP_PKEY * privateKey, + const EVP_MD * evpMd, + UA_Int16 padding, + UA_ByteString * outSignature) { + EVP_MD_CTX * mdctx = NULL; + int opensslRet; + EVP_PKEY_CTX * evpKeyCtx; + UA_StatusCode ret; + + mdctx = EVP_MD_CTX_create (); + if (mdctx == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto errout; + } + + if (privateKey == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + opensslRet = EVP_DigestSignInit (mdctx, &evpKeyCtx, evpMd, NULL, privateKey); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + EVP_PKEY_CTX_set_rsa_padding (evpKeyCtx, padding); + + opensslRet = EVP_DigestSignUpdate (mdctx, message->data, message->length); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + opensslRet = EVP_DigestSignFinal (mdctx, outSignature->data, &outSignature->length); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + + ret = UA_STATUSCODE_GOOD; +errout: + if (mdctx != NULL) { + EVP_MD_CTX_destroy (mdctx); + } + return ret; +} + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_SHA256_Sign (const UA_ByteString * message, + EVP_PKEY * privateKey, + UA_ByteString * outSignature) { + return UA_Openssl_RSA_Private_Sign (message, privateKey, EVP_sha256(), + NID_sha256, outSignature); +} + +UA_StatusCode +UA_OpenSSL_HMAC_SHA256_Verify (const UA_ByteString * message, + const UA_ByteString * key, + const UA_ByteString * signature + ) { + unsigned char buf[SHA256_DIGEST_LENGTH] = {0}; + UA_ByteString mac = {SHA256_DIGEST_LENGTH, buf}; + + if (HMAC (EVP_sha256(), key->data, (int) key->length, message->data, message->length, + mac.data, (unsigned int *) &mac.length) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + if (UA_ByteString_equal (signature, &mac)) { + return UA_STATUSCODE_GOOD; + } + else { + return UA_STATUSCODE_BADINTERNALERROR; + } +} + +UA_StatusCode +UA_OpenSSL_HMAC_SHA256_Sign (const UA_ByteString * message, + const UA_ByteString * key, + UA_ByteString * signature + ) { + if (HMAC (EVP_sha256(), key->data, (int) key->length, message->data, + message->length, + signature->data, (unsigned int *) &(signature->length)) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_OpenSSL_Decrypt (const UA_ByteString * iv, + const UA_ByteString * key, + const EVP_CIPHER * cipherAlg, + UA_ByteString * data /* [in/out]*/) { + UA_ByteString ivCopy = {0, NULL}; + UA_ByteString cipherTxt = {0, NULL}; + EVP_CIPHER_CTX * ctx = NULL; + UA_StatusCode ret; + int opensslRet; + int outLen; + int tmpLen; + + /* copy the IV because the AES_cbc_encrypt function overwrites it. */ + + ret = UA_ByteString_copy (iv, &ivCopy); + if (ret != UA_STATUSCODE_GOOD) { + goto errout; + } + + ret = UA_ByteString_copy (data, &cipherTxt); + if (ret != UA_STATUSCODE_GOOD) { + goto errout; + } + + ctx = EVP_CIPHER_CTX_new (); + if (ctx == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto errout; + } + + /* call EVP_* to decrypt */ + + opensslRet = EVP_DecryptInit_ex (ctx, cipherAlg, NULL, key->data, ivCopy.data); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + /* EVP_DecryptFinal() will return an error code if padding is enabled + * and the final block is not correctly formatted. + */ + EVP_CIPHER_CTX_set_padding (ctx, 0); + opensslRet = EVP_DecryptUpdate (ctx, data->data, &outLen, + cipherTxt.data, (int) cipherTxt.length); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + opensslRet = EVP_DecryptFinal_ex (ctx, data->data + outLen, &tmpLen); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + outLen += tmpLen; + data->length = (size_t) outLen; + ret = UA_STATUSCODE_GOOD; + +errout: + UA_ByteString_clear (&ivCopy); + UA_ByteString_clear (&cipherTxt); + if (ctx != NULL) { + EVP_CIPHER_CTX_free(ctx); + } + return ret; +} + +static UA_StatusCode +UA_OpenSSL_Encrypt (const UA_ByteString * iv, + const UA_ByteString * key, + const EVP_CIPHER * cipherAlg, + UA_ByteString * data /* [in/out]*/ + ) { + + UA_ByteString ivCopy = {0, NULL}; + UA_ByteString plainTxt = {0, NULL}; + EVP_CIPHER_CTX * ctx = NULL; + UA_StatusCode ret; + int opensslRet; + int outLen; + int tmpLen; + + /* copy the IV because the AES_cbc_encrypt function overwrites it. */ + + ret = UA_ByteString_copy (iv, &ivCopy); + if (ret != UA_STATUSCODE_GOOD) { + goto errout; + } + + ret = UA_ByteString_copy (data, &plainTxt); + if (ret != UA_STATUSCODE_GOOD) { + goto errout; + } + + ctx = EVP_CIPHER_CTX_new (); + if (ctx == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto errout; + } + + /* call EVP_* to encrypt */ + + opensslRet = EVP_EncryptInit_ex (ctx, cipherAlg, NULL, key->data, ivCopy.data); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + opensslRet = EVP_EncryptUpdate (ctx, data->data, &outLen, + plainTxt.data, (int) plainTxt.length); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + /* + * Buffer passed to EVP_EncryptFinal() must be after data just + * encrypted to avoid overwriting it. + */ + opensslRet = EVP_EncryptFinal_ex(ctx, data->data + outLen, &tmpLen); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + outLen += tmpLen; + data->length = (size_t) outLen; + ret = UA_STATUSCODE_GOOD; + +errout: + UA_ByteString_clear (&ivCopy); + UA_ByteString_clear (&plainTxt); + if (ctx != NULL) { + EVP_CIPHER_CTX_free(ctx); + } + return ret; +} + +UA_StatusCode +UA_OpenSSL_AES_256_CBC_Decrypt (const UA_ByteString * iv, + const UA_ByteString * key, + UA_ByteString * data /* [in/out]*/ + ) { + return UA_OpenSSL_Decrypt (iv, key, EVP_aes_256_cbc (), data); +} + +UA_StatusCode +UA_OpenSSL_AES_256_CBC_Encrypt (const UA_ByteString * iv, + const UA_ByteString * key, + UA_ByteString * data /* [in/out]*/ + ) { + return UA_OpenSSL_Encrypt (iv, key, EVP_aes_256_cbc (), data); +} + +UA_StatusCode +UA_OpenSSL_X509_compare (const UA_ByteString * cert, + const X509 * bcert) { + X509 * acert = UA_OpenSSL_LoadCertificate(cert); + if (acert == NULL) { + return UA_STATUSCODE_BADCERTIFICATEINVALID; + } + int opensslRet = X509_cmp (acert, bcert); + X509_free (acert); + + if (opensslRet == 0) + return UA_STATUSCODE_GOOD; + return UA_STATUSCODE_UNCERTAINSUBNORMAL; +} + +UA_StatusCode +UA_OpenSSL_RSA_PKCS1_V15_SHA1_Verify (const UA_ByteString * msg, + X509 * publicKeyX509, + const UA_ByteString * signature) { + return UA_OpenSSL_RSA_Public_Verify (msg, EVP_sha1(), publicKeyX509, + NID_sha1, signature); +} + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_SHA1_Sign (const UA_ByteString * message, + EVP_PKEY * privateKey, + UA_ByteString * outSignature) { + return UA_Openssl_RSA_Private_Sign (message, privateKey, EVP_sha1(), + NID_sha1, outSignature); +} + +static UA_Openssl_P_SHA1_Ctx * +P_SHA1_Ctx_Create (const UA_ByteString * secret, + const UA_ByteString * seed) { + size_t size = (UA_Int32)sizeof (UA_Openssl_P_SHA1_Ctx) + secret->length + + seed->length; + UA_Openssl_P_SHA1_Ctx * ctx = (UA_Openssl_P_SHA1_Ctx *) UA_malloc (size); + if (ctx == NULL) { + return NULL; + } + + ctx->secretLen = secret->length; + ctx->seedLen = seed->length; + (void) memcpy (UA_Openssl_P_SHA1_SEED(ctx), seed->data, seed->length); + (void) memcpy (UA_Openssl_P_SHA1_SECRET(ctx), secret->data, secret->length); + /* A(0) = seed + A(n) = HMAC_HASH(secret, A(n-1)) */ + + if (HMAC (EVP_sha1(), secret->data, (int) secret->length, seed->data, + seed->length, ctx->A, NULL) == NULL) { + UA_free (ctx); + return NULL; + } + + return ctx; +} + +static UA_StatusCode +P_SHA1_Hash_Generate (UA_Openssl_P_SHA1_Ctx * ctx, + UA_Byte * pHas + ) { + /* Calculate P_SHA1(n) = HMAC_SHA1(secret, A(n)+seed) */ + if (HMAC (EVP_sha1 (), UA_Openssl_P_SHA1_SECRET(ctx), (int) ctx->secretLen, + ctx->A, sizeof (ctx->A) + ctx->seedLen, pHas, NULL) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Calculate A(n) = HMAC_SHA1(secret, A(n-1)) */ + if (HMAC (EVP_sha1(), UA_Openssl_P_SHA1_SECRET(ctx), (int) ctx->secretLen, + ctx->A, sizeof (ctx->A), ctx->A, NULL) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Openssl_Random_Key_PSHA1_Derive (const UA_ByteString * secret, + const UA_ByteString * seed, + UA_ByteString * out) { + size_t keyLen = out->length; + size_t iter = keyLen / SHA1_DIGEST_LENGTH + ((keyLen % SHA1_DIGEST_LENGTH)?1:0); + size_t bufferLen = iter * SHA1_DIGEST_LENGTH; + UA_Byte * pBuffer = (UA_Byte *) UA_malloc (bufferLen); + if (pBuffer == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_Openssl_P_SHA1_Ctx * ctx = P_SHA1_Ctx_Create (secret, seed); + if (ctx == NULL) { + UA_free (pBuffer); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + size_t i; + UA_StatusCode st; + + for (i = 0; i < iter; i++) { + st = P_SHA1_Hash_Generate (ctx, pBuffer + (i * SHA1_DIGEST_LENGTH)); + if (st != UA_STATUSCODE_GOOD) { + UA_free (pBuffer); + UA_free (ctx); + return st; + } + } + + (void) memcpy (out->data, pBuffer, keyLen); + UA_free (pBuffer); + UA_free (ctx); + + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_OpenSSL_HMAC_SHA1_Verify (const UA_ByteString * message, + const UA_ByteString * key, + const UA_ByteString * signature + ) { + unsigned char buf[SHA1_DIGEST_LENGTH] = {0}; + UA_ByteString mac = {SHA1_DIGEST_LENGTH, buf}; + + if(HMAC (EVP_sha1(), key->data, (int) key->length, message->data, message->length, + mac.data, (unsigned int *) &mac.length) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + if (UA_ByteString_equal (signature, &mac)) { + return UA_STATUSCODE_GOOD; + } + else { + return UA_STATUSCODE_BADINTERNALERROR; + } +} + +UA_StatusCode +UA_OpenSSL_HMAC_SHA1_Sign (const UA_ByteString * message, + const UA_ByteString * key, + UA_ByteString * signature + ) { + if (HMAC (EVP_sha1(), key->data, (int) key->length, message->data, + message->length, + signature->data, (unsigned int *) &(signature->length)) == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_Decrypt (UA_ByteString * data, + EVP_PKEY * privateKey) { + return UA_Openssl_RSA_Private_Decrypt (data, privateKey, + RSA_PKCS1_PADDING); +} + +UA_StatusCode +UA_Openssl_RSA_PKCS1_V15_Encrypt (UA_ByteString * data, + size_t paddingSize, + X509 * publicX509) { + UA_ByteString message; + UA_StatusCode ret = UA_ByteString_copy (data, &message); + if (ret != UA_STATUSCODE_GOOD) { + return ret; + } + ret = UA_Openssl_RSA_Public_Encrypt (&message, publicX509, + RSA_PKCS1_PADDING, + paddingSize, + data); + UA_ByteString_clear (&message); + return ret; +} + +UA_StatusCode +UA_OpenSSL_AES_128_CBC_Decrypt (const UA_ByteString * iv, + const UA_ByteString * key, + UA_ByteString * data /* [in/out]*/ + ) { + return UA_OpenSSL_Decrypt (iv, key, EVP_aes_128_cbc (), data); +} + +UA_StatusCode +UA_OpenSSL_AES_128_CBC_Encrypt (const UA_ByteString * iv, + const UA_ByteString * key, + UA_ByteString * data /* [in/out]*/ + ) { + return UA_OpenSSL_Encrypt (iv, key, EVP_aes_128_cbc (), data); +} + +EVP_PKEY * +UA_OpenSSL_LoadPrivateKey(const UA_ByteString *privateKey) { + const unsigned char * pkData = privateKey->data; + long len = (long) privateKey->length; + + EVP_PKEY *result = NULL; + + if (len > 1 && pkData[0] == 0x30 && pkData[1] == 0x82) { // Magic number for DER encoded keys + result = d2i_PrivateKey(EVP_PKEY_RSA, NULL, + &pkData, len); + } else { + BIO *bio = NULL; + bio = BIO_new_mem_buf((void *) privateKey->data, (int) privateKey->length); + result = PEM_read_bio_PrivateKey(bio, NULL, NULL, NULL); + BIO_free(bio); + } + + return result; +} + +X509 * +UA_OpenSSL_LoadCertificate(const UA_ByteString *certificate) { + X509 * result = NULL; + const unsigned char *pData = certificate->data; + + if (certificate->length > 1 && pData[0] == 0x30 && pData[1] == 0x82) { // Magic number for DER encoded files + result = UA_OpenSSL_LoadDerCertificate(certificate); + } else { + result = UA_OpenSSL_LoadPemCertificate(certificate); + } + + return result; +} + +X509 * +UA_OpenSSL_LoadDerCertificate(const UA_ByteString *certificate) { + const unsigned char *pData = certificate->data; + return d2i_X509(NULL, &pData, (long) certificate->length); +} + +X509 * +UA_OpenSSL_LoadPemCertificate(const UA_ByteString *certificate) { + X509 * result = NULL; + + BIO* bio = NULL; + bio = BIO_new_mem_buf((void *) certificate->data, (int) certificate->length); + result = PEM_read_bio_X509(bio, NULL, NULL, NULL); + BIO_free(bio); + + return result; +} + +UA_StatusCode +UA_OpenSSL_LoadLocalCertificate(const UA_ByteString *certificate, UA_ByteString *target) { + X509 *cert = UA_OpenSSL_LoadCertificate(certificate); + + if (!cert) { + UA_ByteString_init(target); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + unsigned char *derData = NULL; + int length = i2d_X509(cert, &derData); + X509_free(cert); + + if (length > 0) { + UA_ByteString temp; + temp.length = (size_t) length; + temp.data = derData; + UA_ByteString_copy(&temp, target); + OPENSSL_free(derData); + return UA_STATUSCODE_GOOD; + } else { + UA_ByteString_init(target); + } + + return UA_STATUSCODE_BADINVALIDARGUMENT; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/openssl/ua_openssl_basic128rsa15.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + */ + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + + +#include +#include +#include + +#define UA_SHA1_LENGTH 20 +#define UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN 11 +#define UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_KEY_LENGTH 16 +#define UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC128RSA15_SYM_SIGNING_KEY_LENGTH 16 +#define UA_SHA1_LENGTH 20 + +typedef struct { + EVP_PKEY * localPrivateKey; + UA_ByteString localCertThumbprint; + const UA_Logger * logger; +} Policy_Context_Basic128Rsa15; + +typedef struct { + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + Policy_Context_Basic128Rsa15 * policyContext; + UA_ByteString remoteCertificate; + X509 * remoteCertificateX509; +} Channel_Context_Basic128Rsa15; + +static UA_StatusCode +UA_Policy_Basic128Rsa15_New_Context (UA_SecurityPolicy * securityPolicy, + const UA_ByteString localPrivateKey, + const UA_Logger * logger) { + Policy_Context_Basic128Rsa15 * context = (Policy_Context_Basic128Rsa15 *) + UA_malloc (sizeof (Policy_Context_Basic128Rsa15)); + if (context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + context->localPrivateKey = UA_OpenSSL_LoadPrivateKey(&localPrivateKey); + + if (!context->localPrivateKey) { + UA_free(context); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval = UA_Openssl_X509_GetCertificateThumbprint ( + &securityPolicy->localCertificate, + &context->localCertThumbprint, true + ); + if (retval != UA_STATUSCODE_GOOD) { + EVP_PKEY_free(context->localPrivateKey); + UA_free (context); + return retval; + } + + context->logger = logger; + securityPolicy->policyContext = context; + + return UA_STATUSCODE_GOOD; +} + +static void +UA_Policy_Basic128Rsa15_Clear_Context (UA_SecurityPolicy *policy) { + if (policy == NULL) { + return; + } + UA_ByteString_clear(&policy->localCertificate); + + Policy_Context_Basic128Rsa15 * ctx = (Policy_Context_Basic128Rsa15 *) policy->policyContext; + if (ctx == NULL) { + return; + } + + /* delete all allocated members in the context */ + + EVP_PKEY_free(ctx->localPrivateKey); + UA_ByteString_clear(&ctx->localCertThumbprint); + UA_free (ctx); + + return; +} + +/* create the channel context */ + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_New_Context (const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * remoteCertificate, + void ** channelContext) { + if (securityPolicy == NULL || remoteCertificate == NULL || + channelContext == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + Channel_Context_Basic128Rsa15 * context = (Channel_Context_Basic128Rsa15 *) + UA_malloc (sizeof (Channel_Context_Basic128Rsa15)); + if (context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_ByteString_init(&context->localSymSigningKey); + UA_ByteString_init(&context->localSymEncryptingKey); + UA_ByteString_init(&context->localSymIv); + UA_ByteString_init(&context->remoteSymSigningKey); + UA_ByteString_init(&context->remoteSymEncryptingKey); + UA_ByteString_init(&context->remoteSymIv); + + UA_StatusCode retval = UA_copyCertificate (&context->remoteCertificate, + remoteCertificate); + if (retval != UA_STATUSCODE_GOOD) { + UA_free (context); + return retval; + } + + /* decode to X509 */ + context->remoteCertificateX509 = UA_OpenSSL_LoadCertificate(&context->remoteCertificate); + if (context->remoteCertificateX509 == NULL) { + UA_ByteString_clear (&context->remoteCertificate); + UA_free (context); + return UA_STATUSCODE_BADCERTIFICATECHAININCOMPLETE; + } + + context->policyContext = (Policy_Context_Basic128Rsa15 *) + (securityPolicy->policyContext); + + *channelContext = context; + + UA_LOG_INFO (securityPolicy->logger, + UA_LOGCATEGORY_SECURITYPOLICY, + "The Basic128Rsa15 security policy channel with openssl is created."); + + return UA_STATUSCODE_GOOD; +} + +/* delete the channel context */ + +static void +UA_ChannelModule_Basic128Rsa15_Delete_Context (void * channelContext) { + if (channelContext != NULL) { + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) + channelContext; + X509_free (cc->remoteCertificateX509); + UA_ByteString_clear (&cc->remoteCertificate); + UA_ByteString_clear (&cc->localSymSigningKey); + UA_ByteString_clear (&cc->localSymEncryptingKey); + UA_ByteString_clear (&cc->localSymIv); + UA_ByteString_clear (&cc->remoteSymSigningKey); + UA_ByteString_clear (&cc->remoteSymEncryptingKey); + UA_ByteString_clear (&cc->remoteSymIv); + UA_LOG_INFO (cc->policyContext->logger, + UA_LOGCATEGORY_SECURITYPOLICY, + "The Basic128Rsa15 security policy channel with openssl is deleted."); + + UA_free (cc); + } +} + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_setLocalSymSigningKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_setLocalSymEncryptingKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_setLocalSymIv (void * channelContext, + const UA_ByteString * iv) { + if (iv == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_setRemoteSymSigningKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_setRemoteSymEncryptingKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_setRemoteSymIv (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(key, &cc->remoteSymIv); +} + +static UA_StatusCode +UA_ChannelModule_Basic128Rsa15_compareCertificate (const void * channelContext, + const UA_ByteString * certificate) { + if(channelContext == NULL || certificate == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic128Rsa15 * cc = + (const Channel_Context_Basic128Rsa15 *) channelContext; + return UA_OpenSSL_X509_compare (certificate, cc->remoteCertificateX509); +} + +static UA_StatusCode +UA_Asy_Basic128Rsa15_compareCertificateThumbprint (const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * certificateThumbprint) { + if (securityPolicy == NULL || certificateThumbprint == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + Policy_Context_Basic128Rsa15 *pc = (Policy_Context_Basic128Rsa15 *) + securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) { + return UA_STATUSCODE_BADCERTIFICATEINVALID; + } + return UA_STATUSCODE_GOOD; +} + +/* Generates a thumbprint for the specified certificate */ + +static UA_StatusCode +UA_Asy_Basic128Rsa15_makeCertificateThumbprint (const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * certificate, + UA_ByteString * thumbprint) { + return UA_Openssl_X509_GetCertificateThumbprint (certificate, + thumbprint, false); +} + +static size_t +UA_AsySig_Basic128Rsa15_getRemoteSignatureSize (const void * channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic128Rsa15 * cc = (const Channel_Context_Basic128Rsa15 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen; +} + +static size_t +UA_AsySig_Basic128Rsa15_getLocalSignatureSize (const void * channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic128Rsa15 * cc = (const Channel_Context_Basic128Rsa15 *) channelContext; + Policy_Context_Basic128Rsa15 * pc = (Policy_Context_Basic128Rsa15 *) cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength (pc->localPrivateKey, &keyLen); + + return (size_t) keyLen; +} + +static UA_StatusCode +UA_AsySig_Basic128Rsa15_Verify (void * channelContext, + const UA_ByteString * message, + const UA_ByteString * signature) { + if (message == NULL || signature == NULL || + channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_StatusCode retval = UA_OpenSSL_RSA_PKCS1_V15_SHA1_Verify (message, + cc->remoteCertificateX509, signature); + + return retval; +} + +static UA_StatusCode +UA_AsySig_Basic128Rsa15_Sign (void * channelContext, + const UA_ByteString * message, + UA_ByteString * signature) { + if (channelContext == NULL || message == NULL || signature == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic128Rsa15 * cc = (const Channel_Context_Basic128Rsa15 *) channelContext; + Policy_Context_Basic128Rsa15 *pc = cc->policyContext; + return UA_Openssl_RSA_PKCS1_V15_SHA1_Sign (message, pc->localPrivateKey, signature); +} + +static size_t +UA_AsymEn_Basic128Rsa15_getRemotePlainTextBlockSize (const void *channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic128Rsa15 * cc = (const Channel_Context_Basic128Rsa15 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen - UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN; +} + +static size_t +UA_AsymEn_Basic128Rsa15_getRemoteBlockSize (const void *channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic128Rsa15 * cc = (const Channel_Context_Basic128Rsa15 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen; +} + +static size_t +UA_AsymEn_Basic128Rsa15_getRemoteKeyLength (const void *channelContext) { + if (channelContext == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + const Channel_Context_Basic128Rsa15 * cc = (const Channel_Context_Basic128Rsa15 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen * 8; +} + +static size_t +UA_AsymEn_Basic128Rsa15_getLocalKeyLength (const void *channelContext) { + if (channelContext == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + const Channel_Context_Basic128Rsa15 *cc = (const Channel_Context_Basic128Rsa15 *) channelContext; + Policy_Context_Basic128Rsa15 *pc = cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength (pc->localPrivateKey, &keyLen); + return (size_t) keyLen * 8; +} + +static UA_StatusCode +UA_AsymEn_Basic128Rsa15_Decrypt (void * channelContext, + UA_ByteString * data) { + if (channelContext == NULL || data == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + UA_StatusCode ret = UA_Openssl_RSA_PKCS1_V15_Decrypt (data, + cc->policyContext->localPrivateKey); + return ret; +} + +static UA_StatusCode +UA_AsymEn_Basic128Rsa15_Encrypt (void * channelContext, + UA_ByteString * data) { + if (channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + return UA_Openssl_RSA_PKCS1_V15_Encrypt (data, + UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN, + cc->remoteCertificateX509); +} + +static UA_StatusCode +UA_Sym_Basic128Rsa15_generateNonce(void *policyContext, + UA_ByteString *out) { + UA_Int32 rc = RAND_bytes(out->data, (int) out->length); + if (rc != 1) { + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_Sym_Basic128Rsa15_generateKey(void *policyContext, + const UA_ByteString *secret, + const UA_ByteString *seed, + UA_ByteString *out) { + return UA_Openssl_Random_Key_PSHA1_Derive(secret, seed, out); +} + +static size_t +UA_SymEn_Basic128Rsa15_getLocalKeyLength (const void *channelContext) { + /* 16 bytes 128 bits */ + return UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_KEY_LENGTH; +} + +static size_t +UA_SymEn_Basic128Rsa15_getBlockSize (const void *channelContext) { + return UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +UA_SymEn_Basic128Rsa15_getRemoteKeyLength (const void * channelContext) { + return UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_KEY_LENGTH; +} + +static UA_StatusCode +UA_SymEn_Basic128Rsa15_Encrypt (void *channelContext, + UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + return UA_OpenSSL_AES_128_CBC_Encrypt (&cc->localSymIv, &cc->localSymEncryptingKey, data); +} + +static UA_StatusCode +UA_SymEn_Basic128Rsa15_Decrypt (void * channelContext, + UA_ByteString * data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + return UA_OpenSSL_AES_128_CBC_Decrypt (&cc->remoteSymIv, &cc->remoteSymEncryptingKey, data); +} + +static size_t +UA_SymSig_Basic128Rsa15_getKeyLength (const void *channelContext) { + return UA_SECURITYPOLICY_BASIC128RSA15_SYM_SIGNING_KEY_LENGTH; +} + +static size_t +UA_SymSig_Basic128Rsa15_getSignatureSize (const void *channelContext) { + return UA_SHA1_LENGTH; +} + +static UA_StatusCode +UA_SymSig_Basic128Rsa15_Verify (void * channelContext, + const UA_ByteString * message, + const UA_ByteString * signature) { + if (channelContext == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + return UA_OpenSSL_HMAC_SHA1_Verify (message, + &cc->remoteSymSigningKey, + signature); +} + +static UA_StatusCode +UA_SymSig_Basic128Rsa15_Sign (void * channelContext, + const UA_ByteString * message, + UA_ByteString * signature) { + if (channelContext == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic128Rsa15 * cc = (Channel_Context_Basic128Rsa15 *) channelContext; + return UA_OpenSSL_HMAC_SHA1_Sign (message, &cc->localSymSigningKey, signature); +} + +/* the main entry of Basic128Rsa15 */ + +UA_StatusCode +UA_SecurityPolicy_Basic128Rsa15 (UA_SecurityPolicy * policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger * logger) { + + UA_SecurityPolicyAsymmetricModule * const asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule * const symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule * const channelModule = &policy->channelModule; + UA_StatusCode retval; + + UA_LOG_INFO (logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The Basic128Rsa15 security policy with openssl is added."); + + UA_Openssl_Init (); + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Basic128Rsa15\0"); + + /* set ChannelModule context */ + + channelModule->newContext = UA_ChannelModule_Basic128Rsa15_New_Context; + channelModule->deleteContext = UA_ChannelModule_Basic128Rsa15_Delete_Context; + + channelModule->setLocalSymSigningKey = UA_ChannelModule_Basic128Rsa15_setLocalSymSigningKey; + channelModule->setLocalSymEncryptingKey = UA_ChannelModule_Basic128Rsa15_setLocalSymEncryptingKey; + channelModule->setLocalSymIv = UA_ChannelModule_Basic128Rsa15_setLocalSymIv; + channelModule->setRemoteSymSigningKey = UA_ChannelModule_Basic128Rsa15_setRemoteSymSigningKey; + channelModule->setRemoteSymEncryptingKey = UA_ChannelModule_Basic128Rsa15_setRemoteSymEncryptingKey; + channelModule->setRemoteSymIv = UA_ChannelModule_Basic128Rsa15_setRemoteSymIv; + channelModule->compareCertificate = UA_ChannelModule_Basic128Rsa15_compareCertificate; + + retval = UA_OpenSSL_LoadLocalCertificate(&localCertificate, &policy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* asymmetricModule */ + + asymmetricModule->compareCertificateThumbprint = UA_Asy_Basic128Rsa15_compareCertificateThumbprint; + asymmetricModule->makeCertificateThumbprint = UA_Asy_Basic128Rsa15_makeCertificateThumbprint; + + /* AsymmetricModule - signature algorithm */ + + UA_SecurityPolicySignatureAlgorithm * asySigAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asySigAlgorithm->uri = UA_STRING("http://www.w3.org/2000/09/xmldsig#rsa-sha1\0"); + asySigAlgorithm->getRemoteSignatureSize = UA_AsySig_Basic128Rsa15_getRemoteSignatureSize; + asySigAlgorithm->getLocalSignatureSize = UA_AsySig_Basic128Rsa15_getLocalSignatureSize; + asySigAlgorithm->getLocalKeyLength = NULL; + asySigAlgorithm->getRemoteKeyLength = NULL; + asySigAlgorithm->verify = UA_AsySig_Basic128Rsa15_Verify; + asySigAlgorithm->sign = UA_AsySig_Basic128Rsa15_Sign; + + /* AsymmetricModule encryption algorithm */ + + UA_SecurityPolicyEncryptionAlgorithm * asymEncryAlg = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asymEncryAlg->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-1_5\0"); + asymEncryAlg->getRemotePlainTextBlockSize = UA_AsymEn_Basic128Rsa15_getRemotePlainTextBlockSize; + asymEncryAlg->getRemoteBlockSize = UA_AsymEn_Basic128Rsa15_getRemoteBlockSize; + asymEncryAlg->getRemoteKeyLength = UA_AsymEn_Basic128Rsa15_getRemoteKeyLength; + asymEncryAlg->getLocalKeyLength = UA_AsymEn_Basic128Rsa15_getLocalKeyLength; + asymEncryAlg->decrypt = UA_AsymEn_Basic128Rsa15_Decrypt; + asymEncryAlg->encrypt = UA_AsymEn_Basic128Rsa15_Encrypt; + + /* SymmetricModule */ + + symmetricModule->secureChannelNonceLength = 16; /* 128 bits*/ + symmetricModule->generateNonce = UA_Sym_Basic128Rsa15_generateNonce; + symmetricModule->generateKey = UA_Sym_Basic128Rsa15_generateKey; + + /* Symmetric encryption Algorithm */ + + UA_SecurityPolicyEncryptionAlgorithm * symEncryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + symEncryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#aes128-cbc\0"); + symEncryptionAlgorithm->getLocalKeyLength = UA_SymEn_Basic128Rsa15_getLocalKeyLength; + symEncryptionAlgorithm->getRemoteKeyLength = UA_SymEn_Basic128Rsa15_getRemoteKeyLength; + symEncryptionAlgorithm->getRemoteBlockSize = UA_SymEn_Basic128Rsa15_getBlockSize; + symEncryptionAlgorithm->getRemotePlainTextBlockSize = UA_SymEn_Basic128Rsa15_getBlockSize; + symEncryptionAlgorithm->decrypt = UA_SymEn_Basic128Rsa15_Decrypt; + symEncryptionAlgorithm->encrypt = UA_SymEn_Basic128Rsa15_Encrypt; + + /* Symmetric signature Algorithm */ + + UA_SecurityPolicySignatureAlgorithm * symSignatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + symSignatureAlgorithm->uri = UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha1\0"); + symSignatureAlgorithm->getLocalKeyLength = UA_SymSig_Basic128Rsa15_getKeyLength; + symSignatureAlgorithm->getRemoteKeyLength = UA_SymSig_Basic128Rsa15_getKeyLength; + symSignatureAlgorithm->getRemoteSignatureSize = UA_SymSig_Basic128Rsa15_getSignatureSize; + symSignatureAlgorithm->getLocalSignatureSize = UA_SymSig_Basic128Rsa15_getSignatureSize; + + symSignatureAlgorithm->verify = UA_SymSig_Basic128Rsa15_Verify; + symSignatureAlgorithm->sign = UA_SymSig_Basic128Rsa15_Sign; + + /* set the policy context */ + + retval = UA_Policy_Basic128Rsa15_New_Context (policy, localPrivateKey, logger); + if (retval != UA_STATUSCODE_GOOD) { + UA_ByteString_clear (&policy->localCertificate); + return retval; + } + policy->clear = UA_Policy_Basic128Rsa15_Clear_Context; + + /* Use the same signature algorithm as the asymmetric component for + certificate signing (see standard) */ + policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + return UA_STATUSCODE_GOOD; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/openssl/ua_openssl_basic256.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + */ + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + + +#include +#include + +#define UA_SECURITYPOLICY_BASIC256SHA1_RSAPADDING_LEN 42 +#define UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC256_SYM_SIGNING_KEY_LENGTH 24 +#define UA_SHA1_LENGTH 20 + +typedef struct { + EVP_PKEY * localPrivateKey; + UA_ByteString localCertThumbprint; + const UA_Logger * logger; +} Policy_Context_Basic256; + +typedef struct { + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + Policy_Context_Basic256 * policyContext; + UA_ByteString remoteCertificate; + X509 * remoteCertificateX509; +} Channel_Context_Basic256; + +static UA_StatusCode +UA_Policy_Basic256_New_Context (UA_SecurityPolicy * securityPolicy, + const UA_ByteString localPrivateKey, + const UA_Logger * logger) { + Policy_Context_Basic256 * context = (Policy_Context_Basic256 *) + UA_malloc (sizeof (Policy_Context_Basic256)); + if (context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + context->localPrivateKey = UA_OpenSSL_LoadPrivateKey(&localPrivateKey); + + if (!context->localPrivateKey) { + UA_free (context); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval = UA_Openssl_X509_GetCertificateThumbprint ( + &securityPolicy->localCertificate, + &context->localCertThumbprint, true + ); + if (retval != UA_STATUSCODE_GOOD) { + EVP_PKEY_free(context->localPrivateKey); + UA_free (context); + return retval; + } + + context->logger = logger; + securityPolicy->policyContext = context; + + return UA_STATUSCODE_GOOD; +} + +static void +UA_Policy_Basic256_Clear_Context (UA_SecurityPolicy *policy) { + if (policy == NULL) { + return; + } + UA_ByteString_clear(&policy->localCertificate); + + Policy_Context_Basic256 * ctx = (Policy_Context_Basic256 *) policy->policyContext; + if (ctx == NULL) { + return; + } + + /* delete all allocated members in the context */ + + EVP_PKEY_free(ctx->localPrivateKey); + UA_ByteString_clear(&ctx->localCertThumbprint); + UA_free (ctx); + + return; +} + +/* create the channel context */ + +static UA_StatusCode +UA_ChannelModule_Basic256_New_Context (const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * remoteCertificate, + void ** channelContext) { + if (securityPolicy == NULL || remoteCertificate == NULL || + channelContext == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + Channel_Context_Basic256 * context = (Channel_Context_Basic256 *) + UA_malloc (sizeof (Channel_Context_Basic256)); + if (context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_ByteString_init(&context->localSymSigningKey); + UA_ByteString_init(&context->localSymEncryptingKey); + UA_ByteString_init(&context->localSymIv); + UA_ByteString_init(&context->remoteSymSigningKey); + UA_ByteString_init(&context->remoteSymEncryptingKey); + UA_ByteString_init(&context->remoteSymIv); + + UA_StatusCode retval = UA_copyCertificate (&context->remoteCertificate, + remoteCertificate); + if (retval != UA_STATUSCODE_GOOD) { + UA_free (context); + return retval; + } + + /* decode to X509 */ + context->remoteCertificateX509 = UA_OpenSSL_LoadCertificate(&context->remoteCertificate); + if (context->remoteCertificateX509 == NULL) { + UA_ByteString_clear (&context->remoteCertificate); + UA_free (context); + return UA_STATUSCODE_BADCERTIFICATECHAININCOMPLETE; + } + + context->policyContext = (Policy_Context_Basic256 *) + (securityPolicy->policyContext); + + *channelContext = context; + + UA_LOG_INFO (securityPolicy->logger, + UA_LOGCATEGORY_SECURITYPOLICY, + "The basic256 security policy channel with openssl is created."); + + return UA_STATUSCODE_GOOD; +} + +/* delete the channel context */ + +static void +UA_ChannelModule_Basic256_Delete_Context (void * channelContext) { + if (channelContext != NULL) { + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) + channelContext; + X509_free (cc->remoteCertificateX509); + UA_ByteString_clear (&cc->remoteCertificate); + UA_ByteString_clear (&cc->localSymSigningKey); + UA_ByteString_clear (&cc->localSymEncryptingKey); + UA_ByteString_clear (&cc->localSymIv); + UA_ByteString_clear (&cc->remoteSymSigningKey); + UA_ByteString_clear (&cc->remoteSymEncryptingKey); + UA_ByteString_clear (&cc->remoteSymIv); + UA_LOG_INFO (cc->policyContext->logger, + UA_LOGCATEGORY_SECURITYPOLICY, + "The basic256 security policy channel with openssl is deleted."); + + UA_free (cc); + } +} + +/* Compares the supplied certificate with the certificate + * in the endpoint context + */ + +static UA_StatusCode +UA_Asy_Basic256_compareCertificateThumbprint (const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * certificateThumbprint) { + if (securityPolicy == NULL || certificateThumbprint == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + Policy_Context_Basic256 *pc = (Policy_Context_Basic256 *) + securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) { + return UA_STATUSCODE_BADCERTIFICATEINVALID; + } + return UA_STATUSCODE_GOOD; +} + +/* Generates a thumbprint for the specified certificate */ + +static UA_StatusCode +UA_Asy_Basic256_makeCertificateThumbprint (const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * certificate, + UA_ByteString * thumbprint) { + return UA_Openssl_X509_GetCertificateThumbprint (certificate, + thumbprint, false); +} + +static UA_StatusCode +UA_ChannelModule_Basic256_setLocalSymSigningKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic256_setLocalSymEncryptingKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic256_setLocalSymIv (void * channelContext, + const UA_ByteString * iv) { + if (iv == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static UA_StatusCode +UA_ChannelModule_Basic256_setRemoteSymSigningKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic256_setRemoteSymEncryptingKey (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelModule_Basic256_setRemoteSymIv (void * channelContext, + const UA_ByteString * key) { + if (key == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(key, &cc->remoteSymIv); +} + +static UA_StatusCode +UA_ChannelModule_Basic256_compareCertificate (const void * channelContext, + const UA_ByteString * certificate) { + if(channelContext == NULL || certificate == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic256 * cc = + (const Channel_Context_Basic256 *) channelContext; + return UA_OpenSSL_X509_compare (certificate, cc->remoteCertificateX509); +} + +static size_t +UA_AsySig_Basic256_getRemoteSignatureSize (const void *channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic256 * cc = (const Channel_Context_Basic256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen; +} + +static size_t +UA_AsySig_Basic256_getLocalSignatureSize (const void *channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic256 * cc = (const Channel_Context_Basic256 *) channelContext; + Policy_Context_Basic256 * pc = cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength (pc->localPrivateKey, &keyLen); + + return (size_t) keyLen; +} + +static UA_StatusCode +UA_AsySig_Basic256_Verify (void * channelContext, + const UA_ByteString * message, + const UA_ByteString * signature) { + if (message == NULL || signature == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_StatusCode retval = UA_OpenSSL_RSA_PKCS1_V15_SHA1_Verify (message, + cc->remoteCertificateX509, signature); + return retval; +} + +static UA_StatusCode +UA_AsySig_Basic256_Sign (void * channelContext, + const UA_ByteString * message, + UA_ByteString * signature) { + if (channelContext == NULL || message == NULL || signature == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + Policy_Context_Basic256 * pc = cc->policyContext; + return UA_Openssl_RSA_PKCS1_V15_SHA1_Sign (message, pc->localPrivateKey, + signature); +} + +static size_t +UA_AsymEn_Basic256_getRemotePlainTextBlockSize (const void *channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic256 * cc = (const Channel_Context_Basic256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen - UA_SECURITYPOLICY_BASIC256SHA1_RSAPADDING_LEN; +} + +static size_t +UA_AsymEn_Basic256_getRemoteBlockSize (const void *channelContext) { + if (channelContext == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + const Channel_Context_Basic256 * cc = (const Channel_Context_Basic256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen; +} + +static size_t +UA_AsymEn_Basic256_getRemoteKeyLength (const void *channelContext) { + if (channelContext == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + const Channel_Context_Basic256 * cc = (const Channel_Context_Basic256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength (cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen * 8; +} + +static size_t +UA_AsymEn_Basic256_getLocalKeyLength (const void *channelContext) { + if (channelContext == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + const Channel_Context_Basic256 *cc = (const Channel_Context_Basic256 *) channelContext; + Policy_Context_Basic256 *pc = cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength (pc->localPrivateKey, &keyLen); + + return (size_t) keyLen * 8; +} + +static UA_StatusCode +UA_AsymEn_Basic256_Decrypt (void * channelContext, + UA_ByteString * data) { + if (channelContext == NULL || data == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + UA_StatusCode ret = UA_Openssl_RSA_Oaep_Decrypt (data, + cc->policyContext->localPrivateKey); + return ret; +} + +static UA_StatusCode +UA_AsymEn_Basic256_Encrypt (void * channelContext, + UA_ByteString * data) { + if (channelContext == NULL || data == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + return UA_Openssl_RSA_OAEP_Encrypt (data, UA_SECURITYPOLICY_BASIC256SHA1_RSAPADDING_LEN, + cc->remoteCertificateX509); +} + +static UA_StatusCode +UA_Sym_Basic256_generateNonce(void *policyContext, + UA_ByteString *out) { + UA_Int32 rc = RAND_bytes(out->data, (int) out->length); + if (rc != 1) { + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_Sym_Basic256_generateKey(void *policyContext, const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) { + return UA_Openssl_Random_Key_PSHA1_Derive(secret, seed, out); +} + +static size_t +UA_SymEn_Basic256_getLocalKeyLength (const void * channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_KEY_LENGTH; +} + +static size_t +UA_SymEn_Basic256_getBlockSize (const void * channelContext) { + return UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +UA_SymEn_Basic256_getRemoteKeyLength (const void * channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_KEY_LENGTH; +} + +static UA_StatusCode +UA_SymEn_Basic256_Encrypt (void * channelContext, + UA_ByteString * data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + return UA_OpenSSL_AES_256_CBC_Encrypt (&cc->localSymIv, &cc->localSymEncryptingKey, data); +} + +static UA_StatusCode +UA_SymEn_Basic256_Decrypt (void * channelContext, + UA_ByteString * data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + return UA_OpenSSL_AES_256_CBC_Decrypt (&cc->remoteSymIv, &cc->remoteSymEncryptingKey, data); +} + +static size_t +UA_SymSig_Basic256_getKeyLength (const void * channelContext) { + return UA_SECURITYPOLICY_BASIC256_SYM_SIGNING_KEY_LENGTH; +} + +static size_t +UA_SymSig_Basic256_getSignatureSize (const void * channelContext) { + return UA_SHA1_LENGTH; +} + +static UA_StatusCode +UA_SymSig_Basic256_Verify (void * channelContext, + const UA_ByteString * message, + const UA_ByteString * signature) { + if (channelContext == NULL || + message == NULL || signature == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + return UA_OpenSSL_HMAC_SHA1_Verify (message, + &cc->remoteSymSigningKey, + signature); +} + +static UA_StatusCode +UA_SymSig_Basic256_Sign (void * channelContext, + const UA_ByteString * message, + UA_ByteString * signature) { + if (channelContext == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic256 * cc = (Channel_Context_Basic256 *) channelContext; + return UA_OpenSSL_HMAC_SHA1_Sign (message, &cc->localSymSigningKey, signature); +} + +/* the main entry of Basic256 */ + +UA_StatusCode +UA_SecurityPolicy_Basic256 (UA_SecurityPolicy * policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger * logger) { + UA_SecurityPolicyAsymmetricModule * const asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule * const symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule * const channelModule = &policy->channelModule; + UA_StatusCode retval; + + UA_LOG_INFO (logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The basic256 security policy with openssl is added."); + + UA_Openssl_Init (); + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Basic256\0"); + + /* set ChannelModule context */ + + channelModule->newContext = UA_ChannelModule_Basic256_New_Context; + channelModule->deleteContext = UA_ChannelModule_Basic256_Delete_Context; + + channelModule->setLocalSymSigningKey = UA_ChannelModule_Basic256_setLocalSymSigningKey; + channelModule->setLocalSymEncryptingKey = UA_ChannelModule_Basic256_setLocalSymEncryptingKey; + channelModule->setLocalSymIv = UA_ChannelModule_Basic256_setLocalSymIv; + channelModule->setRemoteSymSigningKey = UA_ChannelModule_Basic256_setRemoteSymSigningKey; + channelModule->setRemoteSymEncryptingKey = UA_ChannelModule_Basic256_setRemoteSymEncryptingKey; + channelModule->setRemoteSymIv = UA_ChannelModule_Basic256_setRemoteSymIv; + channelModule->compareCertificate = UA_ChannelModule_Basic256_compareCertificate; + + retval = UA_OpenSSL_LoadLocalCertificate(&localCertificate, &policy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* asymmetricModule */ + + asymmetricModule->compareCertificateThumbprint = UA_Asy_Basic256_compareCertificateThumbprint; + asymmetricModule->makeCertificateThumbprint = UA_Asy_Basic256_makeCertificateThumbprint; + + /* AsymmetricModule - signature algorithm */ + + UA_SecurityPolicySignatureAlgorithm * asySigAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asySigAlgorithm->uri = UA_STRING("http://www.w3.org/2000/09/xmldsig#rsa-sha1\0"); + asySigAlgorithm->getRemoteSignatureSize = UA_AsySig_Basic256_getRemoteSignatureSize; + asySigAlgorithm->getLocalSignatureSize = UA_AsySig_Basic256_getLocalSignatureSize; + asySigAlgorithm->verify = UA_AsySig_Basic256_Verify; + asySigAlgorithm->sign = UA_AsySig_Basic256_Sign; + asySigAlgorithm->getLocalKeyLength = NULL; + asySigAlgorithm->getRemoteKeyLength = NULL; + + /* AsymmetricModule encryption algorithm */ + + UA_SecurityPolicyEncryptionAlgorithm * asymEncryAlg = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asymEncryAlg->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-oaep\0"); + asymEncryAlg->getRemotePlainTextBlockSize = UA_AsymEn_Basic256_getRemotePlainTextBlockSize; + asymEncryAlg->getRemoteBlockSize = UA_AsymEn_Basic256_getRemoteBlockSize; + asymEncryAlg->getRemoteKeyLength = UA_AsymEn_Basic256_getRemoteKeyLength; + asymEncryAlg->getLocalKeyLength = UA_AsymEn_Basic256_getLocalKeyLength; + asymEncryAlg->decrypt = UA_AsymEn_Basic256_Decrypt; + asymEncryAlg->encrypt = UA_AsymEn_Basic256_Encrypt; + + /* SymmetricModule */ + + symmetricModule->secureChannelNonceLength = 32; + symmetricModule->generateNonce = UA_Sym_Basic256_generateNonce; + symmetricModule->generateKey = UA_Sym_Basic256_generateKey; + + /* Symmetric encryption Algorithm */ + + UA_SecurityPolicyEncryptionAlgorithm * symEncryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + symEncryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#aes256-cbc\0"); + symEncryptionAlgorithm->getLocalKeyLength = UA_SymEn_Basic256_getLocalKeyLength; + symEncryptionAlgorithm->getRemoteKeyLength = UA_SymEn_Basic256_getRemoteKeyLength; + symEncryptionAlgorithm->getRemoteBlockSize = UA_SymEn_Basic256_getBlockSize; + symEncryptionAlgorithm->getRemotePlainTextBlockSize = UA_SymEn_Basic256_getBlockSize; + symEncryptionAlgorithm->decrypt = UA_SymEn_Basic256_Decrypt; + symEncryptionAlgorithm->encrypt = UA_SymEn_Basic256_Encrypt; + + /* Symmetric signature Algorithm */ + + UA_SecurityPolicySignatureAlgorithm * symSignatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + symSignatureAlgorithm->uri = UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha1\0"); + symSignatureAlgorithm->getLocalKeyLength = UA_SymSig_Basic256_getKeyLength; + symSignatureAlgorithm->getRemoteKeyLength = UA_SymSig_Basic256_getKeyLength; + symSignatureAlgorithm->getRemoteSignatureSize = UA_SymSig_Basic256_getSignatureSize; + symSignatureAlgorithm->getLocalSignatureSize = UA_SymSig_Basic256_getSignatureSize; + symSignatureAlgorithm->verify = UA_SymSig_Basic256_Verify; + symSignatureAlgorithm->sign = UA_SymSig_Basic256_Sign; + + /* set the policy context */ + + retval = UA_Policy_Basic256_New_Context (policy, localPrivateKey, logger); + if (retval != UA_STATUSCODE_GOOD) { + UA_ByteString_clear (&policy->localCertificate); + return retval; + } + policy->clear = UA_Policy_Basic256_Clear_Context; + + /* Use the same signature algorithm as the asymmetric component for + certificate signing (see standard) */ + policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + return UA_STATUSCODE_GOOD; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/openssl/ua_openssl_basic256sha256.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + */ + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + + +#include +#include +#include +#include +#include +#include + +#define UA_SHA256_LENGTH 32 /* 256 bit */ +#define UA_SECURITYPOLICY_BASIC256SHA256_RSAPADDING_LEN 42 +#define UA_SECURITYPOLICY_BASIC256SHA256_SYM_SIGNING_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC256SHA256_SYM_PLAIN_TEXT_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC256SHA256_MINASYMKEYLENGTH 256 +#define UA_SECURITYPOLICY_BASIC256SHA256_MAXASYMKEYLENGTH 512 + +typedef struct { + EVP_PKEY *localPrivateKey; + UA_ByteString localCertThumbprint; + const UA_Logger *logger; +} Policy_Context_Basic256Sha256; + +typedef struct { + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + Policy_Context_Basic256Sha256 *policyContext; + UA_ByteString remoteCertificate; + X509 *remoteCertificateX509; /* X509 */ +} Channel_Context_Basic256Sha256; + +/* create the policy context */ + +static UA_StatusCode +UA_Policy_New_Context(UA_SecurityPolicy * securityPolicy, + const UA_ByteString localPrivateKey, + const UA_Logger *logger) { + Policy_Context_Basic256Sha256 *context = (Policy_Context_Basic256Sha256 *) + UA_malloc(sizeof(Policy_Context_Basic256Sha256)); + if(context == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + context->localPrivateKey = UA_OpenSSL_LoadPrivateKey(&localPrivateKey); + + if(!context->localPrivateKey) { + UA_free(context); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval = + UA_Openssl_X509_GetCertificateThumbprint(&securityPolicy->localCertificate, + &context->localCertThumbprint, true); + if(retval != UA_STATUSCODE_GOOD) { + EVP_PKEY_free(context->localPrivateKey); + UA_free(context); + return retval; + } + + context->logger = logger; + securityPolicy->policyContext = context; + return UA_STATUSCODE_GOOD; +} + +/* Clear the policy context */ +static void +UA_Policy_Clear_Context(UA_SecurityPolicy *policy) { + if(policy == NULL) + return; + + UA_ByteString_clear(&policy->localCertificate); + + /* Delete all allocated members in the context */ + Policy_Context_Basic256Sha256 *pc = + (Policy_Context_Basic256Sha256 *) policy->policyContext; + EVP_PKEY_free(pc->localPrivateKey); + UA_ByteString_clear(&pc->localCertThumbprint); + UA_free(pc); + return; +} + +/* create the channel context */ + +static UA_StatusCode +UA_ChannelModule_New_Context(const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * remoteCertificate, + void ** channelContext) { + if(securityPolicy == NULL || remoteCertificate == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Basic256Sha256 *context = (Channel_Context_Basic256Sha256 *) + UA_malloc(sizeof(Channel_Context_Basic256Sha256)); + if(context == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + + UA_ByteString_init(&context->localSymSigningKey); + UA_ByteString_init(&context->localSymEncryptingKey); + UA_ByteString_init(&context->localSymIv); + UA_ByteString_init(&context->remoteSymSigningKey); + UA_ByteString_init(&context->remoteSymEncryptingKey); + UA_ByteString_init(&context->remoteSymIv); + + UA_StatusCode retval = + UA_copyCertificate(&context->remoteCertificate, remoteCertificate); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(context); + return retval; + } + + /* decode to X509 */ + context->remoteCertificateX509 = UA_OpenSSL_LoadCertificate(&context->remoteCertificate); + if(context->remoteCertificateX509 == NULL) { + UA_ByteString_clear(&context->remoteCertificate); + UA_free(context); + } + + context->policyContext = + (Policy_Context_Basic256Sha256 *)securityPolicy->policyContext; + *channelContext = context; + + UA_LOG_INFO(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The basic256sha256 security policy channel with openssl is created."); + + return UA_STATUSCODE_GOOD; +} + +/* delete the channel context */ + +static void +UA_ChannelModule_Delete_Context(void * channelContext) { + if(!channelContext) + return; + + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *)channelContext; + X509_free(cc->remoteCertificateX509); + UA_ByteString_clear(&cc->remoteCertificate); + UA_ByteString_clear(&cc->localSymSigningKey); + UA_ByteString_clear(&cc->localSymEncryptingKey); + UA_ByteString_clear(&cc->localSymIv); + UA_ByteString_clear(&cc->remoteSymSigningKey); + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + UA_ByteString_clear(&cc->remoteSymIv); + + UA_LOG_INFO(cc->policyContext->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The basic256sha256 security policy channel with openssl is deleted."); + UA_free(cc); +} + +/* Verifies the signature of the message using the provided keys in the context. + * AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 */ +static UA_StatusCode +UA_AsySig_Basic256Sha256_Verify(void *channelContext, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(message == NULL || signature == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Basic256Sha256 * cc = + (Channel_Context_Basic256Sha256 *) channelContext; + return UA_OpenSSL_RSA_PKCS1_V15_SHA256_Verify(message, cc->remoteCertificateX509, + signature); +} + +/* Compares the supplied certificate with the certificate + * in the endpoint context + */ + +static UA_StatusCode +UA_compareCertificateThumbprint(const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * certificateThumbprint) { + if(securityPolicy == NULL || certificateThumbprint == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + Policy_Context_Basic256Sha256 *pc = (Policy_Context_Basic256Sha256 *) + securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) + return UA_STATUSCODE_BADCERTIFICATEINVALID; + return UA_STATUSCODE_GOOD; +} + +/* Generates a thumbprint for the specified certificate */ + +static UA_StatusCode +UA_makeCertificateThumbprint(const UA_SecurityPolicy * securityPolicy, + const UA_ByteString * certificate, + UA_ByteString * thumbprint) { + return UA_Openssl_X509_GetCertificateThumbprint(certificate, thumbprint, false); +} + +static UA_StatusCode +UA_Asym_Basic256Sha256_Decrypt(void * channelContext, UA_ByteString * data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Basic256Sha256 * cc = + (Channel_Context_Basic256Sha256 *) channelContext; + return UA_Openssl_RSA_Oaep_Decrypt(data, cc->policyContext->localPrivateKey); +} + +static size_t +UA_Asym_Basic256Sha256_getRemoteSignatureSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Basic256Sha256 * cc = + (const Channel_Context_Basic256Sha256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + UA_assert(keyLen == 256); /* 256 bytes 2048 bit */ + return (size_t) keyLen; +} + +static size_t +UA_AsySig_Basic256Sha256_getLocalSignatureSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Basic256Sha256 *cc = + (const Channel_Context_Basic256Sha256 *) channelContext; + Policy_Context_Basic256Sha256 * pc = cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength(pc->localPrivateKey, &keyLen); + UA_assert(keyLen == 256); /* 256 bytes 2048 bits */ + return (size_t) keyLen; +} + +static size_t +UA_AsymEn_Basic256Sha256_getRemotePlainTextBlockSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Basic256Sha256 *cc = + (const Channel_Context_Basic256Sha256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen - UA_SECURITYPOLICY_BASIC256SHA256_RSAPADDING_LEN; +} + +static size_t +UA_AsymEn_Basic256Sha256_getRemoteBlockSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Basic256Sha256 * cc = + (const Channel_Context_Basic256Sha256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen; +} + +static size_t +UA_AsymEn_Basic256Sha256_getRemoteKeyLength(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Basic256Sha256 *cc = + (const Channel_Context_Basic256Sha256 *) channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + return (size_t) keyLen * 8; +} + +static UA_StatusCode +UA_Sym_Basic256Sha256_generateNonce(void *policyContext, + UA_ByteString *out) { + UA_Int32 rc = RAND_bytes(out->data, (int) out->length); + if(rc != 1) + return UA_STATUSCODE_BADUNEXPECTEDERROR; + return UA_STATUSCODE_GOOD; +} + +static size_t +UA_SymEn_Basic256Sha256_getLocalKeyLength(const void *channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_KEY_LENGTH; +} + +static size_t +UA_SymSig_Basic256Sha256_getLocalKeyLength(const void *channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_SIGNING_KEY_LENGTH; +} + +static UA_StatusCode +UA_Sym_Basic256Sha256_generateKey(void *policyContext, + const UA_ByteString *secret, + const UA_ByteString *seed, + UA_ByteString *out) { + return UA_Openssl_Random_Key_PSHA256_Derive(secret, seed, out); +} + +static UA_StatusCode +UA_ChannelModule_Basic256Sha256_setLocalSymSigningKey(void * channelContext, + const UA_ByteString * key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + +static UA_StatusCode +UA_ChannelM_Basic256Sha256_setLocalSymEncryptingKey(void * channelContext, + const UA_ByteString * key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelM_Basic256Sha256_setLocalSymIv(void * channelContext, + const UA_ByteString * iv) { + if(iv == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static size_t +UA_SymEn_Basic256Sha256_getRemoteKeyLength(const void * channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_KEY_LENGTH; +} + +static size_t +UA_SymEn_Basic256Sha256_getBlockSize(const void *channelContext) { + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +UA_SymSig_Basic256Sha256_getRemoteKeyLength(const void * channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_SIGNING_KEY_LENGTH; +} + +static UA_StatusCode +UA_ChannelM_Basic256Sha256_setRemoteSymSigningKey(void *channelContext, + const UA_ByteString * key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +UA_ChannelM_Basic256Sha256_setRemoteSymEncryptingKey(void *channelContext, + const UA_ByteString * key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelM_Basic256Sha256_setRemoteSymIv(void *channelContext, + const UA_ByteString * key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(key, &cc->remoteSymIv); +} + +static UA_StatusCode +UA_AsySig_Basic256Sha256_sign(void *channelContext, const UA_ByteString * message, + UA_ByteString *signature) { + if(channelContext == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 *cc = (Channel_Context_Basic256Sha256 *) channelContext; + Policy_Context_Basic256Sha256 *pc = cc->policyContext; + return UA_Openssl_RSA_PKCS1_V15_SHA256_Sign(message, pc->localPrivateKey, signature); +} + +static UA_StatusCode +UA_AsymEn_Basic256Sha256_encrypt(void *channelContext, UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = + (Channel_Context_Basic256Sha256 *) channelContext; + return UA_Openssl_RSA_OAEP_Encrypt(data, UA_SECURITYPOLICY_BASIC256SHA256_RSAPADDING_LEN, + cc->remoteCertificateX509); +} + +static size_t +UA_SymSig_Basic256Sha256_getRemoteSignatureSize(const void *channelContext) { + return UA_SHA256_LENGTH; +} + +static UA_StatusCode +UA_SymSig_Basic256Sha256_verify(void *channelContext, const UA_ByteString *message, + const UA_ByteString *signature) { + if(channelContext == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + return UA_OpenSSL_HMAC_SHA256_Verify(message, &cc->remoteSymSigningKey, signature); +} + +static UA_StatusCode +UA_SymSig_Basic256Sha256_sign(void *channelContext, const UA_ByteString *message, + UA_ByteString *signature) { + if(channelContext == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + return UA_OpenSSL_HMAC_SHA256_Sign(message, &cc->localSymSigningKey, signature); +} + +static size_t +UA_SymSig_Basic256Sha256_getLocalSignatureSize(const void * channelContext) { + return UA_SHA256_LENGTH; +} + +static UA_StatusCode +UA_SymEn_Basic256Sha256_decrypt(void *channelContext, UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + return UA_OpenSSL_AES_256_CBC_Decrypt(&cc->remoteSymIv, + &cc->remoteSymEncryptingKey, data); +} + +static UA_StatusCode +UA_SymEn_Basic256Sha256_encrypt(void *channelContext, UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Basic256Sha256 * cc = (Channel_Context_Basic256Sha256 *) channelContext; + return UA_OpenSSL_AES_256_CBC_Encrypt(&cc->localSymIv, &cc->localSymEncryptingKey, data); +} + +static UA_StatusCode +UA_ChannelM_Basic256Sha256_compareCertificate(const void *channelContext, + const UA_ByteString *certificate) { + if(channelContext == NULL || certificate == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Basic256Sha256 * cc = + (const Channel_Context_Basic256Sha256 *) channelContext; + return UA_OpenSSL_X509_compare(certificate, cc->remoteCertificateX509); +} + +static size_t +UA_AsymEn_Basic256Sha256_getLocalKeyLength(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Basic256Sha256 * cc = + (const Channel_Context_Basic256Sha256 *) channelContext; + Policy_Context_Basic256Sha256 *pc = cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength(pc->localPrivateKey, &keyLen); + UA_assert(keyLen == 256); /* 256 bytes 2048 bits */ + return (size_t) keyLen * 8; +} + +/* the main entry of Basic256Sha256 */ + +UA_StatusCode +UA_SecurityPolicy_Basic256Sha256(UA_SecurityPolicy *policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger *logger) { + UA_SecurityPolicyAsymmetricModule *asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule *symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule *channelModule = &policy->channelModule; + UA_LOG_INFO(logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The basic256sha256 security policy with openssl is added."); + + UA_Openssl_Init(); + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + policy->policyUri = + UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Basic256Sha256\0"); + + /* Set ChannelModule context */ + channelModule->newContext = UA_ChannelModule_New_Context; + channelModule->deleteContext = UA_ChannelModule_Delete_Context; + channelModule->setLocalSymSigningKey = + UA_ChannelModule_Basic256Sha256_setLocalSymSigningKey; + channelModule->setLocalSymEncryptingKey = + UA_ChannelM_Basic256Sha256_setLocalSymEncryptingKey; + channelModule->setLocalSymIv = UA_ChannelM_Basic256Sha256_setLocalSymIv; + channelModule->setRemoteSymSigningKey = + UA_ChannelM_Basic256Sha256_setRemoteSymSigningKey; + channelModule->setRemoteSymEncryptingKey = + UA_ChannelM_Basic256Sha256_setRemoteSymEncryptingKey; + channelModule->setRemoteSymIv = UA_ChannelM_Basic256Sha256_setRemoteSymIv; + channelModule->compareCertificate = UA_ChannelM_Basic256Sha256_compareCertificate; + UA_StatusCode retval = + UA_OpenSSL_LoadLocalCertificate(&localCertificate, &policy->localCertificate); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* AsymmetricModule - signature algorithm */ + UA_SecurityPolicySignatureAlgorithm *asySigAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asySigAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256\0"); + asySigAlgorithm->verify = UA_AsySig_Basic256Sha256_Verify; + asySigAlgorithm->sign = UA_AsySig_Basic256Sha256_sign; + asySigAlgorithm->getLocalSignatureSize = UA_AsySig_Basic256Sha256_getLocalSignatureSize; + asySigAlgorithm->getRemoteSignatureSize = UA_Asym_Basic256Sha256_getRemoteSignatureSize; + asySigAlgorithm->getLocalKeyLength = NULL; + asySigAlgorithm->getRemoteKeyLength = NULL; + + /* AsymmetricModule encryption algorithm */ + UA_SecurityPolicyEncryptionAlgorithm *asymEncryAlg = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asymEncryAlg->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-oaep\0"); + asymEncryAlg->encrypt = UA_AsymEn_Basic256Sha256_encrypt; + asymEncryAlg->decrypt = UA_Asym_Basic256Sha256_Decrypt; + asymEncryAlg->getLocalKeyLength = UA_AsymEn_Basic256Sha256_getLocalKeyLength; + asymEncryAlg->getRemoteKeyLength = UA_AsymEn_Basic256Sha256_getRemoteKeyLength; + asymEncryAlg->getRemoteBlockSize = UA_AsymEn_Basic256Sha256_getRemoteBlockSize; + asymEncryAlg->getRemotePlainTextBlockSize = + UA_AsymEn_Basic256Sha256_getRemotePlainTextBlockSize; + + /* AsymmetricModule */ + asymmetricModule->compareCertificateThumbprint = UA_compareCertificateThumbprint; + asymmetricModule->makeCertificateThumbprint = UA_makeCertificateThumbprint; + + /* SymmetricModule */ + symmetricModule->secureChannelNonceLength = 32; + symmetricModule->generateNonce = UA_Sym_Basic256Sha256_generateNonce; + symmetricModule->generateKey = UA_Sym_Basic256Sha256_generateKey; + + /* Symmetric encryption Algorithm */ + UA_SecurityPolicyEncryptionAlgorithm *symEncryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + symEncryptionAlgorithm->uri = + UA_STRING("http://www.w3.org/2001/04/xmlenc#aes256-cbc\0"); + symEncryptionAlgorithm->encrypt = UA_SymEn_Basic256Sha256_encrypt; + symEncryptionAlgorithm->decrypt = UA_SymEn_Basic256Sha256_decrypt; + symEncryptionAlgorithm->getLocalKeyLength = UA_SymEn_Basic256Sha256_getLocalKeyLength; + symEncryptionAlgorithm->getRemoteKeyLength = UA_SymEn_Basic256Sha256_getRemoteKeyLength; + symEncryptionAlgorithm->getRemoteBlockSize = UA_SymEn_Basic256Sha256_getBlockSize; + symEncryptionAlgorithm->getRemotePlainTextBlockSize = UA_SymEn_Basic256Sha256_getBlockSize; + + /* Symmetric signature Algorithm */ + UA_SecurityPolicySignatureAlgorithm *symSignatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + symSignatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha2-256\0"); + symSignatureAlgorithm->verify = UA_SymSig_Basic256Sha256_verify; + symSignatureAlgorithm->sign = UA_SymSig_Basic256Sha256_sign; + symSignatureAlgorithm->getLocalSignatureSize = + UA_SymSig_Basic256Sha256_getLocalSignatureSize; + symSignatureAlgorithm->getRemoteSignatureSize = + UA_SymSig_Basic256Sha256_getRemoteSignatureSize; + symSignatureAlgorithm->getLocalKeyLength = + UA_SymSig_Basic256Sha256_getLocalKeyLength; + symSignatureAlgorithm->getRemoteKeyLength = + UA_SymSig_Basic256Sha256_getRemoteKeyLength; + + policy->clear = UA_Policy_Clear_Context; + retval = UA_Policy_New_Context(policy, localPrivateKey, logger); + if(retval != UA_STATUSCODE_GOOD) { + UA_ByteString_clear(&policy->localCertificate); + return retval; + } + + /* Use the same signature algorithm as the asymmetric component for + * certificate signing (see standard) */ + policy->certificateSigningAlgorithm = + policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + return UA_STATUSCODE_GOOD; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/openssl/ua_openssl_aes128sha256rsaoaep.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Wind River Systems, Inc. + */ + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + + +#include +#include +#include +#include +#include +#include + +#define UA_SHA256_LENGTH 32 /* 256 bit */ +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_RSAPADDING_LEN 42 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_SIGNING_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_KEY_LENGTH 16 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_PLAIN_TEXT_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_MINASYMKEYLENGTH 256 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_MAXASYMKEYLENGTH 512 + +typedef struct { + EVP_PKEY *localPrivateKey; + UA_ByteString localCertThumbprint; + const UA_Logger *logger; +} Policy_Context_Aes128Sha256RsaOaep; + +typedef struct { + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + Policy_Context_Aes128Sha256RsaOaep *policyContext; + UA_ByteString remoteCertificate; + X509 *remoteCertificateX509; /* X509 */ +} Channel_Context_Aes128Sha256RsaOaep; + +/* create the policy context */ + +static UA_StatusCode +UA_Policy_Aes128Sha256RsaOaep_New_Context(UA_SecurityPolicy *securityPolicy, + const UA_ByteString localPrivateKey, + const UA_Logger *logger) { + Policy_Context_Aes128Sha256RsaOaep *context = + (Policy_Context_Aes128Sha256RsaOaep *)UA_malloc( + sizeof(Policy_Context_Aes128Sha256RsaOaep)); + if(context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + context->localPrivateKey = UA_OpenSSL_LoadPrivateKey(&localPrivateKey); + if (!context->localPrivateKey) { + UA_free(context); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + UA_StatusCode retval = UA_Openssl_X509_GetCertificateThumbprint( + &securityPolicy->localCertificate, &context->localCertThumbprint, true); + if(retval != UA_STATUSCODE_GOOD) { + EVP_PKEY_free(context->localPrivateKey); + UA_free(context); + return retval; + } + + context->logger = logger; + securityPolicy->policyContext = context; + + return UA_STATUSCODE_GOOD; +} + +/* clear the policy context */ + +static void +UA_Policy_Aes128Sha256RsaOaep_Clear_Context(UA_SecurityPolicy *policy) { + if(policy == NULL) + return; + + UA_ByteString_clear(&policy->localCertificate); + + /* delete all allocated members in the context */ + + Policy_Context_Aes128Sha256RsaOaep *pc = + (Policy_Context_Aes128Sha256RsaOaep *)policy->policyContext; + if (pc == NULL) { + return; + } + + EVP_PKEY_free(pc->localPrivateKey); + UA_ByteString_clear(&pc->localCertThumbprint); + UA_free(pc); + + return; +} + +/* create the channel context */ + +static UA_StatusCode +UA_ChannelModule_Aes128Sha256RsaOaep_New_Context(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate, + void **channelContext) { + if(securityPolicy == NULL || remoteCertificate == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + Channel_Context_Aes128Sha256RsaOaep *context = + (Channel_Context_Aes128Sha256RsaOaep *)UA_malloc( + sizeof(Channel_Context_Aes128Sha256RsaOaep)); + if(context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_ByteString_init(&context->localSymSigningKey); + UA_ByteString_init(&context->localSymEncryptingKey); + UA_ByteString_init(&context->localSymIv); + UA_ByteString_init(&context->remoteSymSigningKey); + UA_ByteString_init(&context->remoteSymEncryptingKey); + UA_ByteString_init(&context->remoteSymIv); + + UA_StatusCode retval = + UA_copyCertificate(&context->remoteCertificate, remoteCertificate); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(context); + return retval; + } + + /* decode to X509 */ + context->remoteCertificateX509 = UA_OpenSSL_LoadCertificate(&context->remoteCertificate); + if (context->remoteCertificateX509 == NULL) { + UA_ByteString_clear (&context->remoteCertificate); + UA_free (context); + return UA_STATUSCODE_BADCERTIFICATECHAININCOMPLETE; + } + + context->policyContext = + (Policy_Context_Aes128Sha256RsaOaep *)(securityPolicy->policyContext); + + *channelContext = context; + + UA_LOG_INFO( + securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The Aes128Sha256RsaOaep security policy channel with openssl is created."); + + return UA_STATUSCODE_GOOD; +} + +/* delete the channel context */ + +static void +UA_ChannelModule_Aes128Sha256RsaOaep_Delete_Context(void *channelContext) { + if(channelContext != NULL) { + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + X509_free(cc->remoteCertificateX509); + UA_ByteString_clear(&cc->remoteCertificate); + UA_ByteString_clear(&cc->localSymSigningKey); + UA_ByteString_clear(&cc->localSymEncryptingKey); + UA_ByteString_clear(&cc->localSymIv); + UA_ByteString_clear(&cc->remoteSymSigningKey); + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + UA_ByteString_clear(&cc->remoteSymIv); + + UA_LOG_INFO( + cc->policyContext->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The Aes128Sha256RsaOaep security policy channel with openssl is deleted."); + UA_free(cc); + } +} + +/* Verifies the signature of the message using the provided keys in the context. + * AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 + */ + +static UA_StatusCode +UA_AsySig_Aes128Sha256RsaOaep_Verify(void *channelContext, const UA_ByteString *message, + const UA_ByteString *signature) { + if(message == NULL || signature == NULL || channelContext == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_StatusCode retval = UA_OpenSSL_RSA_PKCS1_V15_SHA256_Verify( + message, cc->remoteCertificateX509, signature); + + return retval; +} + +/* Compares the supplied certificate with the certificate + * in the endpoint context + */ + +static UA_StatusCode +UA_compareCertificateThumbprint_Aes128Sha256RsaOaep(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificateThumbprint) { + if(securityPolicy == NULL || certificateThumbprint == NULL) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + Policy_Context_Aes128Sha256RsaOaep *pc = + (Policy_Context_Aes128Sha256RsaOaep *)securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) + return UA_STATUSCODE_BADCERTIFICATEINVALID; + return UA_STATUSCODE_GOOD; +} + +/* Generates a thumbprint for the specified certificate */ + +static UA_StatusCode +UA_makeCertificateThumbprint_Aes128Sha256RsaOaep(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificate, + UA_ByteString *thumbprint) { + return UA_Openssl_X509_GetCertificateThumbprint(certificate, thumbprint, false); +} + +static UA_StatusCode +UA_Asym_Aes128Sha256RsaOaep_Decrypt(void *channelContext, UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + Channel_Context_Aes128Sha256RsaOaep *cc = (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_StatusCode ret = UA_Openssl_RSA_Oaep_Decrypt(data, cc->policyContext->localPrivateKey); + return ret; +} + +static size_t +UA_Asym_Aes128Sha256RsaOaep_getRemoteSignatureSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Aes128Sha256RsaOaep *cc = (const Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + return (size_t)keyLen; +} + +static size_t +UA_AsySig_Aes128Sha256RsaOaep_getLocalSignatureSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Aes128Sha256RsaOaep *cc = (const Channel_Context_Aes128Sha256RsaOaep *)channelContext; + Policy_Context_Aes128Sha256RsaOaep *pc = cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength(pc->localPrivateKey, &keyLen); + return (size_t)keyLen; +} + +static size_t +UA_AsymEn_Aes128Sha256RsaOaep_getRemotePlainTextBlockSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Aes128Sha256RsaOaep *cc = + (const Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + return (size_t)keyLen - UA_SECURITYPOLICY_AES128SHA256RSAOAEP_RSAPADDING_LEN; +} + +static size_t +UA_AsymEn_Aes128Sha256RsaOaep_getRemoteBlockSize(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Aes128Sha256RsaOaep *cc = + (const Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + return (size_t)keyLen; +} + +static size_t +UA_AsymEn_Aes128Sha256RsaOaep_getRemoteKeyLength(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Aes128Sha256RsaOaep *cc = + (const Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Public_GetKeyLength(cc->remoteCertificateX509, &keyLen); + return (size_t)keyLen * 8; +} + +static UA_StatusCode +UA_Sym_Aes128Sha256RsaOaep_generateNonce(void *policyContext, + UA_ByteString *out) { + UA_Int32 rc = RAND_bytes(out->data, (int)out->length); + if(rc != 1) { + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + return UA_STATUSCODE_GOOD; +} + +static size_t +UA_SymEn_Aes128Sha256RsaOaep_getLocalKeyLength(const void *channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_KEY_LENGTH; +} + +static size_t +UA_SymSig_Aes128Sha256RsaOaep_getLocalKeyLength(const void *channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_SIGNING_KEY_LENGTH; +} + +static UA_StatusCode +UA_Sym_Aes128Sha256RsaOaep_generateKey(void *policyContext, + const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) { + return UA_Openssl_Random_Key_PSHA256_Derive(secret, seed, out); +} + +static UA_StatusCode +UA_ChannelModule_Aes128Sha256RsaOaep_setLocalSymSigningKey(void *channelContext, + const UA_ByteString *key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + +static UA_StatusCode +UA_ChannelM_Aes128Sha256RsaOaep_setLocalSymEncryptingKey(void *channelContext, + const UA_ByteString *key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelM_Aes128Sha256RsaOaep_setLocalSymIv(void *channelContext, + const UA_ByteString *iv) { + if(iv == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static size_t +UA_SymEn_Aes128Sha256RsaOaep_getRemoteKeyLength(const void *channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_KEY_LENGTH; +} + +static size_t +UA_SymEn_Aes128Sha256RsaOaep_getBlockSize(const void *channelContext) { + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +UA_SymSig_Aes128Sha256RsaOaep_getRemoteKeyLength(const void *channelContext) { + /* 32 bytes 256 bits */ + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_SIGNING_KEY_LENGTH; +} + +static UA_StatusCode +UA_ChannelM_Aes128Sha256RsaOaep_setRemoteSymSigningKey(void *channelContext, + const UA_ByteString *key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +UA_ChannelM_Aes128Sha256RsaOaep_setRemoteSymEncryptingKey(void *channelContext, + const UA_ByteString *key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +UA_ChannelM_Aes128Sha256RsaOaep_setRemoteSymIv(void *channelContext, + const UA_ByteString *key) { + if(key == NULL || channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(key, &cc->remoteSymIv); +} + +static UA_StatusCode +UA_AsySig_Aes128Sha256RsaOaep_sign(void *channelContext, const UA_ByteString *message, + UA_ByteString *signature) { + if(channelContext == NULL || message == NULL || + signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + Policy_Context_Aes128Sha256RsaOaep *pc = cc->policyContext; + return UA_Openssl_RSA_PKCS1_V15_SHA256_Sign(message, pc->localPrivateKey, signature); +} + +static UA_StatusCode +UA_AsymEn_Aes128Sha256RsaOaep_encrypt(void *channelContext, UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + return UA_Openssl_RSA_OAEP_Encrypt( + data, UA_SECURITYPOLICY_AES128SHA256RSAOAEP_RSAPADDING_LEN, + cc->remoteCertificateX509); +} + +static size_t +UA_SymSig_Aes128Sha256RsaOaep_getRemoteSignatureSize(const void *channelContext) { + return UA_SHA256_LENGTH; +} + +static UA_StatusCode +UA_SymSig_Aes128Sha256RsaOaep_verify(void *channelContext, const UA_ByteString *message, + const UA_ByteString *signature) { + if(channelContext == NULL || message == NULL || + signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + return UA_OpenSSL_HMAC_SHA256_Verify(message, &cc->remoteSymSigningKey, signature); +} + +static UA_StatusCode +UA_SymSig_Aes128Sha256RsaOaep_sign(void *channelContext, const UA_ByteString *message, + UA_ByteString *signature) { + if(channelContext == NULL || message == NULL || + signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + return UA_OpenSSL_HMAC_SHA256_Sign(message, &cc->localSymSigningKey, signature); +} + +static size_t +UA_SymSig_Aes128Sha256RsaOaep_getLocalSignatureSize(const void *channelContext) { + return UA_SHA256_LENGTH; +} + +static UA_StatusCode +UA_SymEn_Aes128Sha256RsaOaep_decrypt(void *channelContext, UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + return UA_OpenSSL_AES_128_CBC_Decrypt(&cc->remoteSymIv, &cc->remoteSymEncryptingKey, + data); +} + +static UA_StatusCode +UA_SymEn_Aes128Sha256RsaOaep_encrypt(void *channelContext, UA_ByteString *data) { + if(channelContext == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Channel_Context_Aes128Sha256RsaOaep *cc = + (Channel_Context_Aes128Sha256RsaOaep *)channelContext; + return UA_OpenSSL_AES_128_CBC_Encrypt(&cc->localSymIv, &cc->localSymEncryptingKey, + data); +} + +static UA_StatusCode +UA_ChannelM_Aes128Sha256RsaOaep_compareCertificate(const void *channelContext, + const UA_ByteString *certificate) { + if(channelContext == NULL || certificate == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Aes128Sha256RsaOaep *cc = (const Channel_Context_Aes128Sha256RsaOaep *)channelContext; + return UA_OpenSSL_X509_compare(certificate, cc->remoteCertificateX509); +} + +static size_t +UA_AsymEn_Aes128Sha256RsaOaep_getLocalKeyLength(const void *channelContext) { + if(channelContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const Channel_Context_Aes128Sha256RsaOaep *cc = (const Channel_Context_Aes128Sha256RsaOaep *)channelContext; + Policy_Context_Aes128Sha256RsaOaep *pc = cc->policyContext; + UA_Int32 keyLen = 0; + UA_Openssl_RSA_Private_GetKeyLength(pc->localPrivateKey, &keyLen); + return (size_t)keyLen * 8; +} + +/* the main entry of Aes128Sha256RsaOaep */ + +UA_StatusCode +UA_SecurityPolicy_Aes128Sha256RsaOaep(UA_SecurityPolicy *policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger *logger) { + + UA_SecurityPolicyAsymmetricModule *const asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule *const symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule *const channelModule = &policy->channelModule; + UA_StatusCode retval; + + UA_LOG_INFO(logger, UA_LOGCATEGORY_SECURITYPOLICY, + "The Aes128Sha256RsaOaep security policy with openssl is added."); + + UA_Openssl_Init(); + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + policy->policyUri = + UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Aes128_Sha256_RsaOaep\0"); + + /* set ChannelModule context */ + + channelModule->newContext = UA_ChannelModule_Aes128Sha256RsaOaep_New_Context; + channelModule->deleteContext = UA_ChannelModule_Aes128Sha256RsaOaep_Delete_Context; + channelModule->setLocalSymSigningKey = + UA_ChannelModule_Aes128Sha256RsaOaep_setLocalSymSigningKey; + channelModule->setLocalSymEncryptingKey = + UA_ChannelM_Aes128Sha256RsaOaep_setLocalSymEncryptingKey; + channelModule->setLocalSymIv = UA_ChannelM_Aes128Sha256RsaOaep_setLocalSymIv; + channelModule->setRemoteSymSigningKey = + UA_ChannelM_Aes128Sha256RsaOaep_setRemoteSymSigningKey; + channelModule->setRemoteSymEncryptingKey = + UA_ChannelM_Aes128Sha256RsaOaep_setRemoteSymEncryptingKey; + channelModule->setRemoteSymIv = UA_ChannelM_Aes128Sha256RsaOaep_setRemoteSymIv; + channelModule->compareCertificate = + UA_ChannelM_Aes128Sha256RsaOaep_compareCertificate; + + /* Copy the certificate and add a NULL to the end */ + + retval = UA_copyCertificate(&policy->localCertificate, &localCertificate); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* AsymmetricModule - signature algorithm */ + + UA_SecurityPolicySignatureAlgorithm *asySigAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asySigAlgorithm->uri = + UA_STRING("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256\0"); + asySigAlgorithm->verify = UA_AsySig_Aes128Sha256RsaOaep_Verify; + asySigAlgorithm->getRemoteSignatureSize = + UA_Asym_Aes128Sha256RsaOaep_getRemoteSignatureSize; + asySigAlgorithm->getLocalSignatureSize = + UA_AsySig_Aes128Sha256RsaOaep_getLocalSignatureSize; + asySigAlgorithm->sign = UA_AsySig_Aes128Sha256RsaOaep_sign; + asySigAlgorithm->getLocalKeyLength = NULL; + asySigAlgorithm->getRemoteKeyLength = NULL; + + /* AsymmetricModule encryption algorithm */ + + UA_SecurityPolicyEncryptionAlgorithm *asymEncryAlg = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asymEncryAlg->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-oaep\0"); + asymEncryAlg->decrypt = UA_Asym_Aes128Sha256RsaOaep_Decrypt; + asymEncryAlg->getRemotePlainTextBlockSize = + UA_AsymEn_Aes128Sha256RsaOaep_getRemotePlainTextBlockSize; + asymEncryAlg->getRemoteBlockSize = UA_AsymEn_Aes128Sha256RsaOaep_getRemoteBlockSize; + asymEncryAlg->getRemoteKeyLength = UA_AsymEn_Aes128Sha256RsaOaep_getRemoteKeyLength; + asymEncryAlg->encrypt = UA_AsymEn_Aes128Sha256RsaOaep_encrypt; + asymEncryAlg->getLocalKeyLength = UA_AsymEn_Aes128Sha256RsaOaep_getLocalKeyLength; + + /* asymmetricModule */ + + asymmetricModule->compareCertificateThumbprint = + UA_compareCertificateThumbprint_Aes128Sha256RsaOaep; + asymmetricModule->makeCertificateThumbprint = + UA_makeCertificateThumbprint_Aes128Sha256RsaOaep; + + /* SymmetricModule */ + + symmetricModule->secureChannelNonceLength = 32; + symmetricModule->generateNonce = UA_Sym_Aes128Sha256RsaOaep_generateNonce; + symmetricModule->generateKey = UA_Sym_Aes128Sha256RsaOaep_generateKey; + + /* Symmetric encryption Algorithm */ + + UA_SecurityPolicyEncryptionAlgorithm *symEncryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + symEncryptionAlgorithm->uri = + UA_STRING("http://www.w3.org/2001/04/xmlenc#aes128-cbc\0"); + symEncryptionAlgorithm->getLocalKeyLength = UA_SymEn_Aes128Sha256RsaOaep_getLocalKeyLength; + symEncryptionAlgorithm->getRemoteKeyLength = UA_SymEn_Aes128Sha256RsaOaep_getRemoteKeyLength; + symEncryptionAlgorithm->getRemoteBlockSize = UA_SymEn_Aes128Sha256RsaOaep_getBlockSize; + symEncryptionAlgorithm->getRemotePlainTextBlockSize = UA_SymEn_Aes128Sha256RsaOaep_getBlockSize; + symEncryptionAlgorithm->decrypt = UA_SymEn_Aes128Sha256RsaOaep_decrypt; + symEncryptionAlgorithm->encrypt = UA_SymEn_Aes128Sha256RsaOaep_encrypt; + + /* Symmetric signature Algorithm */ + + UA_SecurityPolicySignatureAlgorithm *symSignatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + symSignatureAlgorithm->uri = UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha2-256\0"); + symSignatureAlgorithm->getLocalKeyLength = UA_SymSig_Aes128Sha256RsaOaep_getLocalKeyLength; + symSignatureAlgorithm->getRemoteKeyLength = UA_SymSig_Aes128Sha256RsaOaep_getRemoteKeyLength; + symSignatureAlgorithm->getRemoteSignatureSize = UA_SymSig_Aes128Sha256RsaOaep_getRemoteSignatureSize; + symSignatureAlgorithm->verify = UA_SymSig_Aes128Sha256RsaOaep_verify; + symSignatureAlgorithm->sign = UA_SymSig_Aes128Sha256RsaOaep_sign; + symSignatureAlgorithm->getLocalSignatureSize = UA_SymSig_Aes128Sha256RsaOaep_getLocalSignatureSize; + + retval = UA_Policy_Aes128Sha256RsaOaep_New_Context(policy, localPrivateKey, logger); + if(retval != UA_STATUSCODE_GOOD) { + UA_ByteString_clear(&policy->localCertificate); + return retval; + } + policy->clear = UA_Policy_Aes128Sha256RsaOaep_Clear_Context; + + /* Use the same signature algorithm as the asymmetric component for + certificate signing (see standard) */ + + policy->certificateSigningAlgorithm = + policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + return UA_STATUSCODE_GOOD; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/openssl/ua_openssl_create_certificate.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2021 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + * + */ + + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + + +#include +#include + +/** + * Join an array of UA_String to a single NULL-Terminated UA_String + * separated by character sep + */ +static UA_StatusCode +join_string_with_sep(const UA_String *strings, size_t stringsSize, + char sep, UA_String *out) { + if(!out) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + UA_String_clear(out); + size_t totalSize = stringsSize; + for(size_t iStr = 0; iStr < stringsSize; ++iStr) { + totalSize += strings[iStr].length; + } + + UA_ByteString_allocBuffer(out, totalSize); + if(!out->data) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + size_t pos = 0; + for(size_t iStr = 0; iStr < stringsSize; ++iStr) { + memcpy(&out->data[pos], strings[iStr].data, strings[iStr].length); + pos += strings[iStr].length; + out->data[pos] = (UA_Byte) sep; + ++pos; + } + out->data[out->length-1] = 0; + + return UA_STATUSCODE_GOOD; +} + +/** + * Search for a character in a string (like strchr). + * \todo Handle UTF-8 + * + * \return index of the character or -1 on case of an error. + */ + +static UA_Int32 +UA_String_chr(const UA_String *pUaStr, char needl) { + UA_Byte byteNeedl = (UA_Byte)needl; + for(size_t i = 0; (size_t)i < pUaStr->length; ++i) { + if(pUaStr->data[i] == byteNeedl) { + return (UA_Int32) i; + } + } + return -1; +} + +static UA_StatusCode +add_x509V3ext(X509 *x509, int nid, const char *value) { + X509_EXTENSION *ex; + X509V3_CTX ctx; + X509V3_set_ctx_nodb(&ctx); + X509V3_set_ctx(&ctx, x509, x509, NULL, NULL, 0); + ex = X509V3_EXT_conf_nid(NULL, &ctx, nid, value); + if(!ex) + return UA_STATUSCODE_BADINTERNALERROR; + X509_add_ext(x509, ex, -1); + X509_EXTENSION_free(ex); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +UA_CreateCertificate(const UA_Logger *logger, + const UA_String *subject, size_t subjectSize, + const UA_String *subjectAltName, size_t subjectAltNameSize, + size_t keySizeBits, UA_CertificateFormat certFormat, + UA_ByteString *outPrivateKey, UA_ByteString *outCertificate) { + if(!outPrivateKey || !outCertificate || !logger || !subjectAltName || + !subject || subjectAltNameSize == 0 || subjectSize == 0 || + (certFormat != UA_CERTIFICATEFORMAT_DER && certFormat != UA_CERTIFICATEFORMAT_PEM )) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + /* Use the maximum size */ + if(keySizeBits == 0) + keySizeBits = 4096; + + UA_ByteString_init(outPrivateKey); + UA_ByteString_init(outCertificate); + + UA_String fullAltSubj = UA_STRING_NULL; + UA_Int32 serial = 1; + + /** \TODO: Seed Random generator + * See: (https://www.openssl.org/docs/man1.1.0/man3/RAND_add.html) */ + BIO *memCert = NULL; + BIO *memPKey = NULL; + + UA_StatusCode errRet = UA_STATUSCODE_GOOD; + + BIGNUM *exponent = BN_new(); + EVP_PKEY *pkey = EVP_PKEY_new(); + X509 *x509 = X509_new(); + RSA *rsa = RSA_new(); + + if(!pkey || !x509 || !exponent || !rsa) { + errRet = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } + + UA_LOG_INFO(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Generating RSA key. This may take a while."); + + if(BN_set_word(exponent, RSA_F4) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting RSA exponent failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + if(RSA_generate_key_ex(rsa, (int) keySizeBits, exponent, NULL) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Generating RSA key failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + if(EVP_PKEY_assign_RSA(pkey, rsa) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Assign RSA key failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + /* rsa will be freed by pkey */ + rsa = NULL; + + /* x509v3 has version 2 + * (https://www.openssl.org/docs/man1.1.0/man3/X509_set_version.html) */ + if(X509_set_version(x509, 2) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting version failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + if(ASN1_INTEGER_set(X509_get_serialNumber(x509), serial) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting serial number failed."); + /* Only memory errors are possible */ + errRet = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } + + if(X509_gmtime_adj(X509_get_notBefore(x509), 0) == NULL) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting 'not before' failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + if(X509_gmtime_adj(X509_get_notAfter(x509), (UA_Int64) 60 * 60 * 24 * 365) == NULL) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting 'not before' failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + if(X509_set_pubkey(x509, pkey) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting publik key failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + X509_NAME *name = X509_get_subject_name(x509); + if(name == NULL) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Getting name failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + for(UA_UInt32 iSubject = 0; iSubject < subjectSize; ++iSubject) { + UA_Int32 sep = UA_String_chr(&subject[iSubject], '='); + char field[16]; + if(sep == -1 || sep == 0 || + ((size_t) sep == (subject[iSubject].length - 1)) || sep >= 15) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Subject must contain one '=' with " + "content before and after."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + memcpy(field, subject[iSubject].data, (size_t) sep); + field[sep] = 0; + UA_Byte* pData = &subject[iSubject].data[sep + 1]; + if(X509_NAME_add_entry_by_txt( + name, field, MBSTRING_ASC, + (const unsigned char *)pData, + (int) subject[iSubject].length - (int) sep - 1, -1, 0) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting subject failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + } + /* Self signed, so issuer == subject */ + if(X509_set_issuer_name(x509, name) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting name failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + errRet = add_x509V3ext(x509, NID_basic_constraints, "CA:FALSE"); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting 'Basic Constraints' failed."); + goto cleanup; + } + + /* See https://datatracker.ietf.org/doc/html/rfc5280#section-4.2.1.3 for + * possible values */ + errRet = add_x509V3ext(x509, NID_key_usage, + "digitalSignature,nonRepudiation,keyEncipherment,dataEncipherment,keyCertSign"); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting 'Key Usage' failed."); + goto cleanup; + } + + errRet = add_x509V3ext(x509, NID_ext_key_usage, "serverAuth,clientAuth"); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting 'Extended Key Usage' failed."); + goto cleanup; + } + + errRet = add_x509V3ext(x509, NID_subject_key_identifier, "hash"); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting 'Subject Key Identifier' failed."); + goto cleanup; + } + + errRet = join_string_with_sep(subjectAltName, subjectAltNameSize, ',', &fullAltSubj); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Joining altSubject failed."); + goto cleanup; + } + + errRet = add_x509V3ext(x509, NID_subject_alt_name, (const char*) fullAltSubj.data); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Setting 'Subject Alternative Name:' failed."); + goto cleanup; + } + + if(X509_sign(x509, pkey, EVP_sha256()) == 0) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Signing failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + switch(certFormat) { + case UA_CERTIFICATEFORMAT_DER: { + int tmpLen = i2d_PrivateKey(pkey, &outPrivateKey->data); + if(tmpLen <= 0) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Create private DER key failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + outPrivateKey->length = (size_t) tmpLen; + + tmpLen = i2d_X509(x509, &outCertificate->data); + if(tmpLen <= 0) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Create DER-certificate failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + outCertificate->length = (size_t) tmpLen; + break; + } + case UA_CERTIFICATEFORMAT_PEM: { + /* Private Key */ + memPKey = BIO_new(BIO_s_mem()); + if(!memPKey) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Allocate Membuffer for PKey failed."); + errRet = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } + + if(PEM_write_bio_PrivateKey(memPKey, pkey, NULL, NULL, 0, 0, NULL) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Generate PEM-PrivateKey failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + UA_ByteString tmpPem = UA_BYTESTRING_NULL; + tmpPem.length = (size_t) BIO_get_mem_data(memPKey, &tmpPem.data); + errRet = UA_ByteString_copy(&tmpPem, outPrivateKey); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Copy PEM PKey failed."); + goto cleanup; + } + + /* Certificate */ + memCert = BIO_new(BIO_s_mem()); + if(!memCert) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Allocate Membuffer for Cert failed."); + errRet = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } + + if(PEM_write_bio_X509(memCert, x509) != 1) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Generate PEM-Certifcate failed."); + errRet = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + tmpPem.length = (size_t) BIO_get_mem_data(memCert, &tmpPem.data); + errRet = UA_ByteString_copy(&tmpPem, outCertificate); + if(errRet != UA_STATUSCODE_GOOD) { + UA_LOG_ERROR(logger, UA_LOGCATEGORY_SECURECHANNEL, + "Create Certificate: Copy PEM Certificate failed."); + goto cleanup; + } + break; + } + } + +cleanup: + UA_String_clear(&fullAltSubj); + RSA_free(rsa); + X509_free(x509); + EVP_PKEY_free(pkey); + BIO_free(memCert); + BIO_free(memPKey); + BN_free(exponent); + return errRet; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/openssl/ua_pki_openssl.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + + */ + + + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) +#include +#include +#include +#include + + +/* Find binary substring. Taken and adjusted from + * http://tungchingkai.blogspot.com/2011/07/binary-strstr.html */ + +static const unsigned char * +bstrchr(const unsigned char *s, const unsigned char ch, size_t l) { + /* find first occurrence of c in char s[] for length l*/ + for(; l > 0; ++s, --l) { + if(*s == ch) + return s; + } + return NULL; +} + +static const unsigned char * +UA_Bstrstr(const unsigned char *s1, size_t l1, const unsigned char *s2, size_t l2) { + /* find first occurrence of s2[] in s1[] for length l1*/ + const unsigned char *ss1 = s1; + const unsigned char *ss2 = s2; + /* handle special case */ + if(l1 == 0) + return (NULL); + if(l2 == 0) + return s1; + + /* match prefix */ + for (; (s1 = bstrchr(s1, *s2, (uintptr_t)ss1-(uintptr_t)s1+(uintptr_t)l1)) != NULL && + (uintptr_t)ss1-(uintptr_t)s1+(uintptr_t)l1 != 0; ++s1) { + + /* match rest of prefix */ + const unsigned char *sc1, *sc2; + for (sc1 = s1, sc2 = s2; ;) + if (++sc2 >= ss2+l2) + return s1; + else if (*++sc1 != *sc2) + break; + } + return NULL; +} + +typedef struct { + /* + * If the folders are defined, we use them to reload the certificates during + * runtime + */ + + UA_String trustListFolder; + UA_String issuerListFolder; + UA_String revocationListFolder; + + STACK_OF(X509) * skIssue; + STACK_OF(X509) * skTrusted; + STACK_OF(X509_CRL) * skCrls; /* Revocation list*/ +} CertContext; + +static UA_StatusCode +UA_CertContext_sk_Init (CertContext * context) { + context->skTrusted = sk_X509_new_null(); + context->skIssue = sk_X509_new_null(); + context->skCrls = sk_X509_CRL_new_null(); + if (context->skTrusted == NULL || context->skIssue == NULL || + context->skCrls == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + return UA_STATUSCODE_GOOD; +} + +static void +UA_CertContext_sk_free (CertContext * context) { + sk_X509_pop_free (context->skTrusted, X509_free); + sk_X509_pop_free (context->skIssue, X509_free); + sk_X509_CRL_pop_free (context->skCrls, X509_CRL_free); +} + +static UA_StatusCode +UA_CertContext_Init (CertContext * context) { + (void) memset (context, 0, sizeof (CertContext)); + UA_ByteString_init (&context->trustListFolder); + UA_ByteString_init (&context->issuerListFolder); + UA_ByteString_init (&context->revocationListFolder); + return UA_CertContext_sk_Init (context); +} + +static void +UA_CertificateVerification_clear (UA_CertificateVerification * cv) { + if (cv == NULL) { + return ; + } + CertContext * context = (CertContext *) cv->context; + if (context == NULL) { + return; + } + UA_ByteString_clear (&context->trustListFolder); + UA_ByteString_clear (&context->issuerListFolder); + UA_ByteString_clear (&context->revocationListFolder); + + UA_CertContext_sk_free (context); + UA_free (context); + + cv->context = NULL; + + return; +} + +static UA_StatusCode +UA_skTrusted_Cert2X509 (const UA_ByteString * certificateTrustList, + size_t certificateTrustListSize, + CertContext * ctx) { + size_t i; + + for (i = 0; i < certificateTrustListSize; i++) { + X509 * x509 = UA_OpenSSL_LoadCertificate(&certificateTrustList[i]); + + if (x509 == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + sk_X509_push (ctx->skTrusted, x509); + } + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_skIssuer_Cert2X509 (const UA_ByteString * certificateIssuerList, + size_t certificateIssuerListSize, + CertContext * ctx) { + size_t i; + + for (i = 0; i < certificateIssuerListSize; i++) { + X509 * x509 = UA_OpenSSL_LoadCertificate(&certificateIssuerList[i]); + + if (x509 == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + sk_X509_push (ctx->skIssue, x509); + } + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_skCrls_Cert2X509 (const UA_ByteString * certificateRevocationList, + size_t certificateRevocationListSize, + CertContext * ctx) { + size_t i; + const unsigned char * pData; + + for (i = 0; i < certificateRevocationListSize; i++) { + pData = certificateRevocationList[i].data; + X509_CRL * crl = NULL; + + if (certificateRevocationList[i].length > 1 && pData[0] == 0x30 && pData[1] == 0x82) { // Magic number for DER encoded files + crl = d2i_X509_CRL (NULL, &pData, (long) certificateRevocationList[i].length); + } else { + BIO* bio = NULL; + bio = BIO_new_mem_buf((void *) certificateRevocationList[i].data, + (int) certificateRevocationList[i].length); + crl = PEM_read_bio_X509_CRL(bio, NULL, NULL, NULL); + BIO_free(bio); + } + + if (crl == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + sk_X509_CRL_push (ctx->skCrls, crl); + } + + return UA_STATUSCODE_GOOD; +} + +#ifdef __linux__ +#include + +static int UA_Certificate_Filter_der_pem (const struct dirent * entry) { + /* ignore hidden files */ + if (entry->d_name[0] == '.') return 0; + + /* check file extension */ + const char *pszFind = strrchr(entry->d_name, '.'); + if (pszFind == 0) + return 0; + pszFind++; + if (strcmp (pszFind, "der") == 0 || strcmp (pszFind, "pem") == 0) + return 1; + + return 0; +} + +static int UA_Certificate_Filter_crl (const struct dirent * entry) { + + /* ignore hidden files */ + if (entry->d_name[0] == '.') return 0; + + /* check file extension */ + const char *pszFind = strrchr(entry->d_name, '.'); + if (pszFind == 0) + return 0; + pszFind++; + if (strcmp (pszFind, "crl") == 0) + return 1; + + return 0; +} + +static UA_StatusCode +UA_BuildFullPath (const char * path, + const char * fileName, + size_t fullPathBufferLength, + char * fullPath) { + size_t pathLen = strlen (path); + size_t fileNameLen = strlen (fileName); + if ((pathLen + fileNameLen + 2) > fullPathBufferLength) { + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + strcpy (fullPath, path); + strcat (fullPath, "/"); + strcat (fullPath, fileName); + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_loadCertFromFile (const char * fileName, + UA_ByteString * cert) { + + FILE * fp = fopen(fileName, "rb"); + + if (fp == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + fseek(fp, 0, SEEK_END); + cert->length = (size_t) ftell(fp); + if (UA_ByteString_allocBuffer (cert, cert->length) != UA_STATUSCODE_GOOD) { + fclose (fp); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + fseek(fp, 0, SEEK_SET); + size_t readLen = fread (cert->data, 1, cert->length, fp); + if (readLen != cert->length) { + UA_ByteString_clear (cert); + cert->length = 0; + fclose (fp); + return UA_STATUSCODE_BADINTERNALERROR; + } + fclose (fp); + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_ReloadCertFromFolder (CertContext * ctx) { + UA_StatusCode ret; + struct dirent ** dirlist = NULL; + int i; + int numCertificates; + char certFile[PATH_MAX]; + UA_ByteString strCert; + char folderPath[PATH_MAX]; + + UA_ByteString_init (&strCert); + + if (ctx->trustListFolder.length > 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Reloading the trust-list"); + + sk_X509_pop_free (ctx->skTrusted, X509_free); + ctx->skTrusted = sk_X509_new_null(); + if (ctx->skTrusted == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + (void) memcpy (folderPath, ctx->trustListFolder.data, + ctx->trustListFolder.length); + folderPath[ctx->trustListFolder.length] = 0; + numCertificates = scandir(folderPath, &dirlist, + UA_Certificate_Filter_der_pem, + alphasort); + for (i = 0; i < numCertificates; i++) { + if (UA_BuildFullPath (folderPath, dirlist[i]->d_name, + PATH_MAX, certFile) != UA_STATUSCODE_GOOD) { + continue; + } + ret = UA_loadCertFromFile (certFile, &strCert); + if (ret != UA_STATUSCODE_GOOD) { + UA_LOG_INFO (UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to load the certificate file %s", certFile); + continue; /* continue or return ? */ + } + if (UA_skTrusted_Cert2X509 (&strCert, 1, ctx) != UA_STATUSCODE_GOOD) { + UA_LOG_INFO (UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to decode the certificate file %s", certFile); + UA_ByteString_clear (&strCert); + continue; /* continue or return ? */ + } + UA_ByteString_clear (&strCert); + } + } + + if (ctx->issuerListFolder.length > 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Reloading the issuer-list"); + + sk_X509_pop_free (ctx->skIssue, X509_free); + ctx->skIssue = sk_X509_new_null(); + if (ctx->skIssue == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + memcpy (folderPath, ctx->issuerListFolder.data, ctx->issuerListFolder.length); + folderPath[ctx->issuerListFolder.length] = 0; + numCertificates = scandir(folderPath, &dirlist, + UA_Certificate_Filter_der_pem, + alphasort); + for (i = 0; i < numCertificates; i++) { + if (UA_BuildFullPath (folderPath, dirlist[i]->d_name, + PATH_MAX, certFile) != UA_STATUSCODE_GOOD) { + continue; + } + ret = UA_loadCertFromFile (certFile, &strCert); + if (ret != UA_STATUSCODE_GOOD) { + UA_LOG_INFO (UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to load the certificate file %s", certFile); + continue; /* continue or return ? */ + } + if (UA_skIssuer_Cert2X509 (&strCert, 1, ctx) != UA_STATUSCODE_GOOD) { + UA_LOG_INFO (UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to decode the certificate file %s", certFile); + UA_ByteString_clear (&strCert); + continue; /* continue or return ? */ + } + UA_ByteString_clear (&strCert); + } + } + + if (ctx->revocationListFolder.length > 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Reloading the revocation-list"); + + sk_X509_CRL_pop_free (ctx->skCrls, X509_CRL_free); + ctx->skCrls = sk_X509_CRL_new_null(); + if (ctx->skCrls == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + memcpy (folderPath, ctx->revocationListFolder.data, ctx->revocationListFolder.length); + folderPath[ctx->revocationListFolder.length] = 0; + numCertificates = scandir(folderPath, &dirlist, + UA_Certificate_Filter_crl, + alphasort); + for (i = 0; i < numCertificates; i++) { + if (UA_BuildFullPath (folderPath, dirlist[i]->d_name, + PATH_MAX, certFile) != UA_STATUSCODE_GOOD) { + continue; + } + ret = UA_loadCertFromFile (certFile, &strCert); + if (ret != UA_STATUSCODE_GOOD) { + UA_LOG_INFO (UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to load the revocation file %s", certFile); + continue; /* continue or return ? */ + } + if (UA_skCrls_Cert2X509 (&strCert, 1, ctx) != UA_STATUSCODE_GOOD) { + UA_LOG_INFO (UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to decode the revocation file %s", certFile); + UA_ByteString_clear (&strCert); + continue; /* continue or return ? */ + } + UA_ByteString_clear (&strCert); + } + } + + ret = UA_STATUSCODE_GOOD; + return ret; +} + +#endif /* end of __linux__ */ + +static UA_StatusCode +UA_X509_Store_CTX_Error_To_UAError (int opensslErr) { + UA_StatusCode ret; + + switch (opensslErr) { + case X509_V_ERR_CERT_HAS_EXPIRED: + case X509_V_ERR_CERT_NOT_YET_VALID: + case X509_V_ERR_CRL_NOT_YET_VALID: + case X509_V_ERR_CRL_HAS_EXPIRED: + case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: + case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: + case X509_V_ERR_ERROR_IN_CRL_LAST_UPDATE_FIELD: + case X509_V_ERR_ERROR_IN_CRL_NEXT_UPDATE_FIELD: + ret = UA_STATUSCODE_BADCERTIFICATETIMEINVALID; + break; + case X509_V_ERR_CERT_REVOKED: + ret = UA_STATUSCODE_BADCERTIFICATEREVOKED; + break; + case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT: + case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY: + case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: + ret = UA_STATUSCODE_BADCERTIFICATEUNTRUSTED; + break; + case X509_V_ERR_CERT_SIGNATURE_FAILURE: + case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN: + ret = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + break; + case X509_V_ERR_UNABLE_TO_GET_CRL: + ret = UA_STATUSCODE_BADCERTIFICATEREVOCATIONUNKNOWN; + break; + default: + ret = UA_STATUSCODE_BADCERTIFICATEINVALID; + break; + } + return ret; + } + +static UA_StatusCode +UA_CertificateVerification_Verify (void * verificationContext, + const UA_ByteString * certificate) { + X509_STORE_CTX* storeCtx; + X509_STORE* store; + CertContext * ctx; + UA_StatusCode ret; + int opensslRet; + X509 * certificateX509 = NULL; + + if (verificationContext == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + ctx = (CertContext *) verificationContext; + + store = X509_STORE_new(); + storeCtx = X509_STORE_CTX_new(); + + if (store == NULL || storeCtx == NULL) { + ret = UA_STATUSCODE_BADOUTOFMEMORY; + goto cleanup; + } +#ifdef __linux__ + ret = UA_ReloadCertFromFolder (ctx); + if (ret != UA_STATUSCODE_GOOD) { + goto cleanup; + } +#endif + + certificateX509 = UA_OpenSSL_LoadCertificate(certificate); + if (certificateX509 == NULL) { + ret = UA_STATUSCODE_BADCERTIFICATEINVALID; + goto cleanup; + } + + X509_STORE_set_flags(store, 0); + opensslRet = X509_STORE_CTX_init (storeCtx, store, certificateX509, + ctx->skIssue); + if (opensslRet != 1) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto cleanup; + } + + (void) X509_STORE_CTX_set0_trusted_stack (storeCtx, ctx->skTrusted); + + + /* Set crls to ctx */ + if (sk_X509_CRL_num (ctx->skCrls) > 0) { + X509_STORE_CTX_set0_crls (storeCtx, ctx->skCrls); + } + + /* Set flag to check if the certificate has an invalid signature */ + X509_STORE_CTX_set_flags (storeCtx, X509_V_FLAG_CHECK_SS_SIGNATURE); + + if (X509_STORE_CTX_get_check_issued(storeCtx) (storeCtx,certificateX509, certificateX509) != 1) { + X509_STORE_CTX_set_flags (storeCtx, X509_V_FLAG_CRL_CHECK); + } + + /* This condition will check whether the certificate is a User certificate or a CA certificate. + * If the KU_KEY_CERT_SIGN and KU_CRL_SIGN of key_usage are set, then the certificate shall be + * condidered as CA Certificate and cannot be used to establish a connection. Refer the test case + * CTT/Security/Security Certificate Validation/029.js for more details */ + /** \todo Can the ca-parameter of X509_check_purpose can be used? */ + if(X509_check_purpose(certificateX509, X509_PURPOSE_CRL_SIGN, 0) && X509_check_ca(certificateX509)) { + return UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED; + } + + opensslRet = X509_verify_cert (storeCtx); + if (opensslRet == 1) { + ret = UA_STATUSCODE_GOOD; + + /* Check if the not trusted certificate has a CRL file. If there is no CRL file available for the corresponding + * parent certificate then return status code UA_STATUSCODE_BADCERTIFICATEISSUERREVOCATIONUNKNOWN. Refer the test + * case CTT/Security/Security Certificate Validation/002.js */ + if (X509_STORE_CTX_get_check_issued (storeCtx) (storeCtx,certificateX509, certificateX509) != 1) { + /* Free X509_STORE_CTX and reuse it for certification verification */ + if (storeCtx != NULL) { + X509_STORE_CTX_free(storeCtx); + } + + /* Initialised X509_STORE_CTX sructure*/ + storeCtx = X509_STORE_CTX_new(); + + /* Sets up X509_STORE_CTX structure for a subsequent verification operation */ + X509_STORE_set_flags(store, 0); + X509_STORE_CTX_init (storeCtx, store, certificateX509,ctx->skIssue); + + /* Set trust list to ctx */ + (void) X509_STORE_CTX_trusted_stack (storeCtx, ctx->skTrusted); + + /* Set crls to ctx */ + X509_STORE_CTX_set0_crls (storeCtx, ctx->skCrls); + + /* Set flags for CRL check */ + X509_STORE_CTX_set_flags (storeCtx, X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL); + + opensslRet = X509_verify_cert (storeCtx); + if (opensslRet != 1) { + opensslRet = X509_STORE_CTX_get_error (storeCtx); + if (opensslRet == X509_V_ERR_UNABLE_TO_GET_CRL) { + ret = UA_STATUSCODE_BADCERTIFICATEISSUERREVOCATIONUNKNOWN; + } + } + } + } + else { + opensslRet = X509_STORE_CTX_get_error (storeCtx); + + /* Check the issued certificate of a CA that is not trusted but available */ + if(opensslRet == X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN){ + int trusted_cert_len = sk_X509_num(ctx->skTrusted); + int cmpVal; + X509 *trusted_cert; + const ASN1_OCTET_STRING *trusted_cert_keyid; + const ASN1_OCTET_STRING *remote_cert_keyid; + + for (int i = 0; i < trusted_cert_len; i++) { + trusted_cert = sk_X509_value(ctx->skTrusted, i); + + /* Fetch the Subject key identifier of the certificate in trust list */ + trusted_cert_keyid = X509_get0_subject_key_id(trusted_cert); + + /* Fetch the Subject key identifier of the remote certificate */ + remote_cert_keyid = X509_get0_subject_key_id(certificateX509); + + /* Check remote certificate is present in the trust list */ + cmpVal = ASN1_OCTET_STRING_cmp(trusted_cert_keyid, remote_cert_keyid); + if (cmpVal == 0){ + ret = UA_STATUSCODE_GOOD; + goto cleanup; + } + } + } + + /* Return expected OPCUA error code */ + ret = UA_X509_Store_CTX_Error_To_UAError (opensslRet); + } +cleanup: + if (store != NULL) { + X509_STORE_free (store); + } + if (storeCtx != NULL) { + X509_STORE_CTX_free (storeCtx); + } + if (certificateX509 != NULL) { + X509_free (certificateX509); + } + return ret; +} + +static UA_StatusCode +UA_VerifyCertificateAllowAll (void * verificationContext, + const UA_ByteString * certificate) { + (void) verificationContext; + (void) certificate; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +UA_CertificateVerification_VerifyApplicationURI (void * verificationContext, + const UA_ByteString * certificate, + const UA_String * applicationURI) { + (void) verificationContext; + + const unsigned char * pData; + X509 * certificateX509; + UA_String subjectURI; + GENERAL_NAMES * pNames; + int i; + UA_StatusCode ret; + + pData = certificate->data; + if (pData == NULL) { + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + + certificateX509 = UA_OpenSSL_LoadCertificate(certificate); + if (certificateX509 == NULL) { + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + + pNames = (GENERAL_NAMES *) X509_get_ext_d2i(certificateX509, NID_subject_alt_name, + NULL, NULL); + if (pNames == NULL) { + X509_free (certificateX509); + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + for (i = 0; i < sk_GENERAL_NAME_num (pNames); i++) { + GENERAL_NAME * value = sk_GENERAL_NAME_value (pNames, i); + if (value->type == GEN_URI) { + subjectURI.length = (size_t) (value->d.ia5->length); + subjectURI.data = (UA_Byte *) UA_malloc (subjectURI.length); + if (subjectURI.data == NULL) { + X509_free (certificateX509); + sk_GENERAL_NAME_pop_free(pNames, GENERAL_NAME_free); + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + (void) memcpy (subjectURI.data, value->d.ia5->data, subjectURI.length); + break; + } + + } + + ret = UA_STATUSCODE_GOOD; + if (UA_Bstrstr (subjectURI.data, subjectURI.length, + applicationURI->data, applicationURI->length) == NULL) { + ret = UA_STATUSCODE_BADCERTIFICATEURIINVALID; + } + + X509_free (certificateX509); + sk_GENERAL_NAME_pop_free(pNames, GENERAL_NAME_free); + UA_String_clear (&subjectURI); + return ret; +} + +/* main entry */ + +UA_StatusCode +UA_CertificateVerification_Trustlist(UA_CertificateVerification * cv, + const UA_ByteString * certificateTrustList, + size_t certificateTrustListSize, + const UA_ByteString * certificateIssuerList, + size_t certificateIssuerListSize, + const UA_ByteString * certificateRevocationList, + size_t certificateRevocationListSize) { + UA_StatusCode ret; + + if (cv == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + + CertContext * context = (CertContext *) UA_malloc (sizeof (CertContext)); + if (context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + ret = UA_CertContext_Init (context); + if (ret != UA_STATUSCODE_GOOD) { + return ret; + } + + cv->verifyApplicationURI = UA_CertificateVerification_VerifyApplicationURI; + cv->clear = UA_CertificateVerification_clear; + cv->context = context; + if (certificateTrustListSize > 0) + cv->verifyCertificate = UA_CertificateVerification_Verify; + else + cv->verifyCertificate = UA_VerifyCertificateAllowAll; + + if (certificateTrustListSize > 0) { + if (UA_skTrusted_Cert2X509 (certificateTrustList, certificateTrustListSize, + context) != UA_STATUSCODE_GOOD) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + } + + if (certificateIssuerListSize > 0) { + if (UA_skIssuer_Cert2X509 (certificateIssuerList, certificateIssuerListSize, + context) != UA_STATUSCODE_GOOD) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + } + + if (certificateRevocationListSize > 0) { + if (UA_skCrls_Cert2X509 (certificateRevocationList, certificateRevocationListSize, + context) != UA_STATUSCODE_GOOD) { + ret = UA_STATUSCODE_BADINTERNALERROR; + goto errout; + } + } + + return UA_STATUSCODE_GOOD; + +errout: + UA_CertificateVerification_clear (cv); + return ret; +} + +#ifdef __linux__ /* Linux only so far */ +UA_StatusCode +UA_CertificateVerification_CertFolders(UA_CertificateVerification * cv, + const char * trustListFolder, + const char * issuerListFolder, + const char * revocationListFolder) { + UA_StatusCode ret; + if (cv == NULL) { + return UA_STATUSCODE_BADINTERNALERROR; + } + + CertContext * context = (CertContext *) UA_malloc (sizeof (CertContext)); + if (context == NULL) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + ret = UA_CertContext_Init (context); + if (ret != UA_STATUSCODE_GOOD) { + return ret; + } + + cv->verifyApplicationURI = UA_CertificateVerification_VerifyApplicationURI; + cv->clear = UA_CertificateVerification_clear; + cv->context = context; + if(trustListFolder == NULL && + issuerListFolder == NULL && + revocationListFolder == NULL) { + cv->verifyCertificate = UA_VerifyCertificateAllowAll; + } else { + cv->verifyCertificate = UA_CertificateVerification_Verify; + } + + /* Only set the folder paths. They will be reloaded during runtime. */ + + context->trustListFolder = UA_STRING_ALLOC(trustListFolder); + context->issuerListFolder = UA_STRING_ALLOC(issuerListFolder); + context->revocationListFolder = UA_STRING_ALLOC(revocationListFolder); + + return UA_STATUSCODE_GOOD; +} +#endif + +#endif /* end of defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) */ + +/**** amalgamated original file "/plugins/crypto/mbedtls/securitypolicy_mbedtls_common.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2019 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + + +#if defined(UA_ENABLE_ENCRYPTION_MBEDTLS) || defined(UA_ENABLE_PUBSUB_ENCRYPTION) + +#include +#include +#include + +#if !defined(MBEDTLS_NO_PLATFORM_ENTROPY) +#define MBEDTLS_ENTROPY_POLL_METHOD mbedtls_platform_entropy_poll +#else +// MBEDTLS_ENTROPY_HARDWARE_ALT should be defined if your hardware does not supportd platform entropy +#define MBEDTLS_ENTROPY_POLL_METHOD mbedtls_hardware_poll +#endif + +#define UA_SHA1_LENGTH 20 + +_UA_BEGIN_DECLS + +void +swapBuffers(UA_ByteString *const bufA, UA_ByteString *const bufB); + +void +mbedtls_hmac(mbedtls_md_context_t *context, const UA_ByteString *key, + const UA_ByteString *in, unsigned char *out); + +UA_StatusCode +mbedtls_generateKey(mbedtls_md_context_t *context, + const UA_ByteString *secret, const UA_ByteString *seed, + UA_ByteString *out); + +UA_StatusCode +mbedtls_verifySig_sha1(mbedtls_x509_crt *certificate, const UA_ByteString *message, + const UA_ByteString *signature); + +UA_StatusCode +mbedtls_sign_sha1(mbedtls_pk_context *localPrivateKey, + mbedtls_ctr_drbg_context *drbgContext, + const UA_ByteString *message, + UA_ByteString *signature); + +UA_StatusCode +mbedtls_thumbprint_sha1(const UA_ByteString *certificate, + UA_ByteString *thumbprint); + +/* Set the hashing scheme before calling + * E.g. mbedtls_rsa_set_padding(context, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); */ +UA_StatusCode +mbedtls_encrypt_rsaOaep(mbedtls_rsa_context *context, + mbedtls_ctr_drbg_context *drbgContext, + UA_ByteString *data, const size_t plainTextBlockSize); + +UA_StatusCode +mbedtls_decrypt_rsaOaep(mbedtls_pk_context *localPrivateKey, + mbedtls_ctr_drbg_context *drbgContext, + UA_ByteString *data); + +int UA_mbedTLS_LoadPrivateKey(const UA_ByteString *key, mbedtls_pk_context *target); + +UA_StatusCode UA_mbedTLS_LoadLocalCertificate(const UA_ByteString *certData, UA_ByteString *target); + +UA_ByteString UA_mbedTLS_CopyDataFormatAware(const UA_ByteString *data); + +_UA_END_DECLS + +#endif + + +/**** amalgamated original file "/plugins/crypto/mbedtls/ua_securitypolicy_basic128rsa15.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018-2019 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2018 (c) HMS Industrial Networks AB (Author: Jonas Green) + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + * + */ + + +#ifdef UA_ENABLE_ENCRYPTION_MBEDTLS + + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Notes: + * mbedTLS' AES allows in-place encryption and decryption. Sow we don't have to + * allocate temp buffers. + * https://tls.mbed.org/discussions/generic/in-place-decryption-with-aes256-same-input-output-buffer + */ + +#define UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN 11 +#define UA_SECURITYPOLICY_BASIC128RSA15_SYM_KEY_LENGTH 16 +#define UA_BASIC128RSA15_SYM_SIGNING_KEY_LENGTH 16 +#define UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC128RSA15_SYM_PLAIN_TEXT_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC128RSA15_MINASYMKEYLENGTH 128 +#define UA_SECURITYPOLICY_BASIC128RSA15_MAXASYMKEYLENGTH 512 + +typedef struct { + UA_ByteString localCertThumbprint; + + mbedtls_ctr_drbg_context drbgContext; + mbedtls_entropy_context entropyContext; + mbedtls_md_context_t sha1MdContext; + mbedtls_pk_context localPrivateKey; +} Basic128Rsa15_PolicyContext; + +typedef struct { + Basic128Rsa15_PolicyContext *policyContext; + + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + mbedtls_x509_crt remoteCertificate; +} Basic128Rsa15_ChannelContext; + +/********************/ +/* AsymmetricModule */ +/********************/ + +static UA_StatusCode +asym_verify_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + return mbedtls_verifySig_sha1(&cc->remoteCertificate, message, signature); +} + +static UA_StatusCode +asym_sign_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *message, + UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic128Rsa15_PolicyContext *pc = cc->policyContext; + return mbedtls_sign_sha1(&pc->localPrivateKey, &pc->drbgContext, + message, signature); +} + +static size_t +asym_getLocalSignatureSize_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc) { + if(cc == NULL) + return 0; + + return mbedtls_pk_rsa(cc->policyContext->localPrivateKey)->len; +} + +static size_t +asym_getRemoteSignatureSize_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc) { + if(cc == NULL) + return 0; + + return mbedtls_pk_rsa(cc->remoteCertificate.pk)->len; +} + +static UA_StatusCode +asym_encrypt_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_rsa_context *remoteRsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + mbedtls_rsa_set_padding(remoteRsaContext, MBEDTLS_RSA_PKCS_V15, 0); + + size_t plainTextBlockSize = remoteRsaContext->len - UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN; + if(data->length % plainTextBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t blocks = data->length / plainTextBlockSize; + UA_ByteString encrypted; + UA_StatusCode retval = UA_ByteString_allocBuffer(&encrypted, blocks * remoteRsaContext->len); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + size_t lenDataToEncrypt = data->length; + size_t inOffset = 0; + size_t offset = 0; + size_t outLength = 0; + Basic128Rsa15_PolicyContext *pc = cc->policyContext; + while(lenDataToEncrypt >= plainTextBlockSize) { + int mbedErr = mbedtls_pk_encrypt(&cc->remoteCertificate.pk, + data->data + inOffset, plainTextBlockSize, + encrypted.data + offset, &outLength, + encrypted.length - offset, + mbedtls_ctr_drbg_random, + &pc->drbgContext); + if(mbedErr) { + UA_ByteString_clear(&encrypted); + return UA_STATUSCODE_BADINTERNALERROR; + } + + inOffset += plainTextBlockSize; + offset += outLength; + lenDataToEncrypt -= plainTextBlockSize; + } + + memcpy(data->data, encrypted.data, offset); + UA_ByteString_clear(&encrypted); + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +asym_decrypt_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->policyContext->localPrivateKey); + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, 0); + + if(data->length % rsaContext->len != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t inOffset = 0; + size_t outOffset = 0; + size_t outLength = 0; + unsigned char buf[512]; + + while(inOffset < data->length) { + int mbedErr = mbedtls_pk_decrypt(&cc->policyContext->localPrivateKey, + data->data + inOffset, rsaContext->len, + buf, &outLength, 512, NULL, NULL); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + memcpy(data->data + outOffset, buf, outLength); + inOffset += rsaContext->len; + outOffset += outLength; + } + + data->length = outOffset; + return UA_STATUSCODE_GOOD; +} + +static size_t +asym_getLocalEncryptionKeyLength_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->policyContext->localPrivateKey) * 8; +} + +static size_t +asym_getRemoteEncryptionKeyLength_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->remoteCertificate.pk) * 8; +} + +static size_t +asym_getRemoteBlockSize_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc) { + mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + return rsaContext->len; +} + +static size_t +asym_getRemotePlainTextBlockSize_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc) { + mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + return rsaContext->len - UA_SECURITYPOLICY_BASIC128RSA15_RSAPADDING_LEN; +} + +static UA_StatusCode +asym_makeThumbprint_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificate, + UA_ByteString *thumbprint) { + if(securityPolicy == NULL || certificate == NULL || thumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + return mbedtls_thumbprint_sha1(certificate, thumbprint); +} + +static UA_StatusCode +asymmetricModule_compareCertificateThumbprint_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificateThumbprint) { + if(securityPolicy == NULL || certificateThumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) + return UA_STATUSCODE_BADCERTIFICATEINVALID; + + return UA_STATUSCODE_GOOD; +} + +/*******************/ +/* SymmetricModule */ +/*******************/ + +static UA_StatusCode +sym_verify_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(cc == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Compute MAC */ + if(signature->length != UA_SHA1_LENGTH) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + Basic128Rsa15_PolicyContext *pc = cc->policyContext; + + unsigned char mac[UA_SHA1_LENGTH]; + mbedtls_hmac(&pc->sha1MdContext, &cc->remoteSymSigningKey, message, mac); + + /* Compare with Signature */ + if(!UA_constantTimeEqual(signature->data, mac, UA_SHA1_LENGTH)) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +sym_sign_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *message, + UA_ByteString *signature) { + if(signature->length != UA_SHA1_LENGTH) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_hmac(&cc->policyContext->sha1MdContext, &cc->localSymSigningKey, + message, signature->data); + return UA_STATUSCODE_GOOD; +} + +static size_t +sym_getSignatureSize_sp_basic128rsa15(const void *channelContext) { + return UA_SHA1_LENGTH; +} + +static size_t +sym_getSigningKeyLength_sp_basic128rsa15(const void *const channelContext) { + return UA_BASIC128RSA15_SYM_SIGNING_KEY_LENGTH; +} + +static size_t +sym_getEncryptionKeyLength_sp_basic128rsa15(const void *channelContext) { + return UA_SECURITYPOLICY_BASIC128RSA15_SYM_KEY_LENGTH; +} + +static size_t +sym_getEncryptionBlockSize_sp_basic128rsa15(const void *const channelContext) { + return UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +sym_getPlainTextBlockSize_sp_basic128rsa15(const void *const channelContext) { + return UA_SECURITYPOLICY_BASIC128RSA15_SYM_PLAIN_TEXT_BLOCK_SIZE; +} + +static UA_StatusCode +sym_encrypt_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(cc->localSymIv.length != UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t plainTextBlockSize = UA_SECURITYPOLICY_BASIC128RSA15_SYM_PLAIN_TEXT_BLOCK_SIZE; + if(data->length % plainTextBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Keylength in bits */ + unsigned int keylength = (unsigned int)(cc->localSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_enc(&aesContext, cc->localSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->localSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_ENCRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_decrypt_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t encryptionBlockSize = UA_SECURITYPOLICY_BASIC128RSA15_SYM_ENCRYPTION_BLOCK_SIZE; + if(cc->remoteSymIv.length != encryptionBlockSize) + return UA_STATUSCODE_BADINTERNALERROR; + + if(data->length % encryptionBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned int keylength = (unsigned int)(cc->remoteSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_dec(&aesContext, + cc->remoteSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->remoteSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_DECRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_generateKey_sp_basic128rsa15(void *policyContext, const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) { + if(secret == NULL || seed == NULL || out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)policyContext; + return mbedtls_generateKey(&pc->sha1MdContext, secret, seed, out); +} + +static UA_StatusCode +sym_generateNonce_sp_basic128rsa15(void *policyContext, UA_ByteString *out) { + if(out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)policyContext; + int mbedErr = mbedtls_ctr_drbg_random(&pc->drbgContext, out->data, out->length); + if(mbedErr) + return UA_STATUSCODE_BADUNEXPECTEDERROR; + return UA_STATUSCODE_GOOD; +} + +/*****************/ +/* ChannelModule */ +/*****************/ + +/* Assumes that the certificate has been verified externally */ +static UA_StatusCode +parseRemoteCertificate_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *remoteCertificate) { + if(remoteCertificate == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Parse the certificate */ + int mbedErr = mbedtls_x509_crt_parse(&cc->remoteCertificate, remoteCertificate->data, + remoteCertificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + /* Check the key length */ + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + if(rsaContext->len < UA_SECURITYPOLICY_BASIC128RSA15_MINASYMKEYLENGTH || + rsaContext->len > UA_SECURITYPOLICY_BASIC128RSA15_MAXASYMKEYLENGTH) + return UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED; + + return UA_STATUSCODE_GOOD; +} + +static void +channelContext_deleteContext_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc) { + UA_ByteString_clear(&cc->localSymSigningKey); + UA_ByteString_clear(&cc->localSymEncryptingKey); + UA_ByteString_clear(&cc->localSymIv); + UA_ByteString_clear(&cc->remoteSymSigningKey); + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + UA_ByteString_clear(&cc->remoteSymIv); + mbedtls_x509_crt_free(&cc->remoteCertificate); + UA_free(cc); +} + +static UA_StatusCode +channelContext_newContext_sp_basic128rsa15(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate, + void **pp_contextData) { + if(securityPolicy == NULL || remoteCertificate == NULL || pp_contextData == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Allocate the channel context */ + *pp_contextData = UA_malloc(sizeof(Basic128Rsa15_ChannelContext)); + if(*pp_contextData == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + + Basic128Rsa15_ChannelContext *cc = (Basic128Rsa15_ChannelContext *)*pp_contextData; + + /* Initialize the channel context */ + cc->policyContext = (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext; + + UA_ByteString_init(&cc->localSymSigningKey); + UA_ByteString_init(&cc->localSymEncryptingKey); + UA_ByteString_init(&cc->localSymIv); + + UA_ByteString_init(&cc->remoteSymSigningKey); + UA_ByteString_init(&cc->remoteSymEncryptingKey); + UA_ByteString_init(&cc->remoteSymIv); + + mbedtls_x509_crt_init(&cc->remoteCertificate); + + // TODO: this can be optimized so that we dont allocate memory before parsing the certificate + UA_StatusCode retval = parseRemoteCertificate_sp_basic128rsa15(cc, remoteCertificate); + if(retval != UA_STATUSCODE_GOOD) { + channelContext_deleteContext_sp_basic128rsa15(cc); + *pp_contextData = NULL; + } + return retval; +} + +static UA_StatusCode +channelContext_setLocalSymEncryptingKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setLocalSymSigningKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + + +static UA_StatusCode +channelContext_setLocalSymIv_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static UA_StatusCode +channelContext_setRemoteSymEncryptingKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setRemoteSymSigningKey_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +channelContext_setRemoteSymIv_sp_basic128rsa15(Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(iv, &cc->remoteSymIv); +} + +static UA_StatusCode +channelContext_compareCertificate_sp_basic128rsa15(const Basic128Rsa15_ChannelContext *cc, + const UA_ByteString *certificate) { + if(cc == NULL || certificate == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_x509_crt cert; + mbedtls_x509_crt_init(&cert); + int mbedErr = mbedtls_x509_crt_parse(&cert, certificate->data, certificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(cert.raw.len != cc->remoteCertificate.raw.len || + memcmp(cert.raw.p, cc->remoteCertificate.raw.p, cert.raw.len) != 0) + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + mbedtls_x509_crt_free(&cert); + return retval; +} + +static void +clear_sp_basic128rsa15(UA_SecurityPolicy *securityPolicy) { + if(securityPolicy == NULL) + return; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + if(securityPolicy->policyContext == NULL) + return; + + /* delete all allocated members in the context */ + Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *) + securityPolicy->policyContext; + + mbedtls_ctr_drbg_free(&pc->drbgContext); + mbedtls_entropy_free(&pc->entropyContext); + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_md_free(&pc->sha1MdContext); + UA_ByteString_clear(&pc->localCertThumbprint); + + UA_LOG_DEBUG(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Deleted members of EndpointContext for sp_basic128rsa15"); + + UA_free(pc); + securityPolicy->policyContext = NULL; +} + +static UA_StatusCode +updateCertificateAndPrivateKey_sp_basic128rsa15(UA_SecurityPolicy *securityPolicy, + const UA_ByteString newCertificate, + const UA_ByteString newPrivateKey) { + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(securityPolicy->policyContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *)securityPolicy->policyContext; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + UA_StatusCode retval = UA_mbedTLS_LoadLocalCertificate(&newCertificate, &securityPolicy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* Set the new private key */ + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_pk_init(&pc->localPrivateKey); + int mbedErr = UA_mbedTLS_LoadPrivateKey(&newPrivateKey, &pc->localPrivateKey); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + retval = asym_makeThumbprint_sp_basic128rsa15(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return retval; + + error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not update certificate and private key"); + if(securityPolicy->policyContext != NULL) + clear_sp_basic128rsa15(securityPolicy); + return retval; +} + +static UA_StatusCode +policyContext_newContext_sp_basic128rsa15(UA_SecurityPolicy *securityPolicy, + const UA_ByteString localPrivateKey) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if (localPrivateKey.length == 0) { + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Can not initialize security policy. Private key is empty."); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Basic128Rsa15_PolicyContext *pc = (Basic128Rsa15_PolicyContext *) + UA_malloc(sizeof(Basic128Rsa15_PolicyContext)); + securityPolicy->policyContext = (void *)pc; + if(!pc) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Initialize the PolicyContext */ + memset(pc, 0, sizeof(Basic128Rsa15_PolicyContext)); + mbedtls_ctr_drbg_init(&pc->drbgContext); + mbedtls_entropy_init(&pc->entropyContext); + mbedtls_pk_init(&pc->localPrivateKey); + mbedtls_md_init(&pc->sha1MdContext); + + /* Initialized the message digest */ + const mbedtls_md_info_t *const mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1); + int mbedErr = mbedtls_md_setup(&pc->sha1MdContext, mdInfo, MBEDTLS_MD_SHA1); + if(mbedErr) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Add the system entropy source */ + mbedErr = mbedtls_entropy_add_source(&pc->entropyContext, + MBEDTLS_ENTROPY_POLL_METHOD, NULL, 0, + MBEDTLS_ENTROPY_SOURCE_STRONG); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Seed the RNG */ + char *personalization = "open62541-drbg"; + mbedErr = mbedtls_ctr_drbg_seed(&pc->drbgContext, mbedtls_entropy_func, + &pc->entropyContext, + (const unsigned char *)personalization, 14); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the private key */ + mbedErr = UA_mbedTLS_LoadPrivateKey(&localPrivateKey, &pc->localPrivateKey); + + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the local certificate thumbprint */ + retval = UA_ByteString_allocBuffer(&pc->localCertThumbprint, UA_SHA1_LENGTH); + if(retval != UA_STATUSCODE_GOOD) + goto error; + retval = asym_makeThumbprint_sp_basic128rsa15(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return UA_STATUSCODE_GOOD; + +error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not create securityContext: %s", UA_StatusCode_name(retval)); + if(securityPolicy->policyContext != NULL) + clear_sp_basic128rsa15(securityPolicy); + return retval; +} + +UA_StatusCode +UA_SecurityPolicy_Basic128Rsa15(UA_SecurityPolicy *policy, const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, const UA_Logger *logger) { + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + + policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Basic128Rsa15\0"); + + UA_SecurityPolicyAsymmetricModule *const asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule *const symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule *const channelModule = &policy->channelModule; + + UA_StatusCode retval = UA_mbedTLS_LoadLocalCertificate(&localCertificate, &policy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* AsymmetricModule */ + UA_SecurityPolicySignatureAlgorithm *asym_signatureAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2000/09/xmldsig#rsa-sha1\0"); + asym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, const UA_ByteString *))asym_verify_sp_basic128rsa15; + asym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))asym_sign_sp_basic128rsa15; + asym_signatureAlgorithm->getLocalSignatureSize = + (size_t (*)(const void *))asym_getLocalSignatureSize_sp_basic128rsa15; + asym_signatureAlgorithm->getRemoteSignatureSize = + (size_t (*)(const void *))asym_getRemoteSignatureSize_sp_basic128rsa15; + asym_signatureAlgorithm->getLocalKeyLength = NULL; // TODO: Write function + asym_signatureAlgorithm->getRemoteKeyLength = NULL; // TODO: Write function + + UA_SecurityPolicyEncryptionAlgorithm *asym_encryptionAlgorithm = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-1_5"); + asym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))asym_encrypt_sp_basic128rsa15; + asym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *)) asym_decrypt_sp_basic128rsa15; + asym_encryptionAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))asym_getLocalEncryptionKeyLength_sp_basic128rsa15; + asym_encryptionAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))asym_getRemoteEncryptionKeyLength_sp_basic128rsa15; + asym_encryptionAlgorithm->getRemoteBlockSize = + (size_t (*)(const void *))asym_getRemoteBlockSize_sp_basic128rsa15; + asym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))asym_getRemotePlainTextBlockSize_sp_basic128rsa15; + + asymmetricModule->makeCertificateThumbprint = asym_makeThumbprint_sp_basic128rsa15; + asymmetricModule->compareCertificateThumbprint = + asymmetricModule_compareCertificateThumbprint_sp_basic128rsa15; + + /* SymmetricModule */ + symmetricModule->generateKey = sym_generateKey_sp_basic128rsa15; + symmetricModule->generateNonce = sym_generateNonce_sp_basic128rsa15; + + UA_SecurityPolicySignatureAlgorithm *sym_signatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + sym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha1\0"); + sym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, + const UA_ByteString *))sym_verify_sp_basic128rsa15; + sym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))sym_sign_sp_basic128rsa15; + sym_signatureAlgorithm->getLocalSignatureSize = sym_getSignatureSize_sp_basic128rsa15; + sym_signatureAlgorithm->getRemoteSignatureSize = sym_getSignatureSize_sp_basic128rsa15; + sym_signatureAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_basic128rsa15; + sym_signatureAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_basic128rsa15; + + UA_SecurityPolicyEncryptionAlgorithm *sym_encryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + sym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#aes128-cbc"); + sym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_encrypt_sp_basic128rsa15; + sym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_decrypt_sp_basic128rsa15; + sym_encryptionAlgorithm->getLocalKeyLength = sym_getEncryptionKeyLength_sp_basic128rsa15; + sym_encryptionAlgorithm->getRemoteKeyLength = sym_getEncryptionKeyLength_sp_basic128rsa15; + sym_encryptionAlgorithm->getRemoteBlockSize = + (size_t (*)(const void *))sym_getEncryptionBlockSize_sp_basic128rsa15; + sym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))sym_getPlainTextBlockSize_sp_basic128rsa15; + symmetricModule->secureChannelNonceLength = 16; + + // Use the same signature algorithm as the asymmetric component for certificate signing (see standard) + policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + /* ChannelModule */ + channelModule->newContext = channelContext_newContext_sp_basic128rsa15; + channelModule->deleteContext = (void (*)(void *)) + channelContext_deleteContext_sp_basic128rsa15; + + channelModule->setLocalSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymEncryptingKey_sp_basic128rsa15; + channelModule->setLocalSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymSigningKey_sp_basic128rsa15; + channelModule->setLocalSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymIv_sp_basic128rsa15; + + channelModule->setRemoteSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymEncryptingKey_sp_basic128rsa15; + channelModule->setRemoteSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymSigningKey_sp_basic128rsa15; + channelModule->setRemoteSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymIv_sp_basic128rsa15; + + channelModule->compareCertificate = (UA_StatusCode (*)(const void *, const UA_ByteString *)) + channelContext_compareCertificate_sp_basic128rsa15; + + policy->updateCertificateAndPrivateKey = updateCertificateAndPrivateKey_sp_basic128rsa15; + policy->clear = clear_sp_basic128rsa15; + + UA_StatusCode res = policyContext_newContext_sp_basic128rsa15(policy, localPrivateKey); + if(res != UA_STATUSCODE_GOOD) + clear_sp_basic128rsa15(policy); + + return res; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/mbedtls/ua_securitypolicy_basic256.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2018 (c) Daniel Feist, Precitec GmbH & Co. KG + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + * + */ + + +#ifdef UA_ENABLE_ENCRYPTION_MBEDTLS + + +#include +#include +#include +#include +#include +#include + +/* Notes: + * mbedTLS' AES allows in-place encryption and decryption. Sow we don't have to + * allocate temp buffers. + * https://tls.mbed.org/discussions/generic/in-place-decryption-with-aes256-same-input-output-buffer + */ + +#define UA_SECURITYPOLICY_BASIC256SHA1_RSAPADDING_LEN 42 +#define UA_SHA1_LENGTH 20 +#define UA_BASIC256_SYM_SIGNING_KEY_LENGTH 24 +#define UA_SECURITYPOLICY_BASIC256_SYM_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC256_SYM_PLAIN_TEXT_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC256_MINASYMKEYLENGTH 128 +#define UA_SECURITYPOLICY_BASIC256_MAXASYMKEYLENGTH 512 + +typedef struct { + UA_ByteString localCertThumbprint; + + mbedtls_ctr_drbg_context drbgContext; + mbedtls_entropy_context entropyContext; + mbedtls_md_context_t sha1MdContext; + mbedtls_pk_context localPrivateKey; +} Basic256_PolicyContext; + +typedef struct { + Basic256_PolicyContext *policyContext; + + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + mbedtls_x509_crt remoteCertificate; +} Basic256_ChannelContext; + +/********************/ +/* AsymmetricModule */ +/********************/ + +/* VERIFY AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 */ +static UA_StatusCode +asym_verify_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + return mbedtls_verifySig_sha1(&cc->remoteCertificate, message, signature); +} + +/* AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 */ +static UA_StatusCode +asym_sign_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *message, + UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic256_PolicyContext *pc = cc->policyContext; + return mbedtls_sign_sha1(&pc->localPrivateKey, &pc->drbgContext, + message, signature); +} + +static size_t +asym_getLocalSignatureSize_sp_basic256(const Basic256_ChannelContext *cc) { + if(cc == NULL) + return 0; + return mbedtls_pk_rsa(cc->policyContext->localPrivateKey)->len; +} + +static size_t +asym_getRemoteSignatureSize_sp_basic256(const Basic256_ChannelContext *cc) { + if(cc == NULL) + return 0; + return mbedtls_pk_rsa(cc->remoteCertificate.pk)->len; +} + +static size_t +asym_getRemotePlainTextBlockSize_sp_basic256(const Basic256_ChannelContext *cc) { + mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + return rsaContext->len - UA_SECURITYPOLICY_BASIC256SHA1_RSAPADDING_LEN; +} + +/* AsymmetricEncryptionAlgorithm_RSA-OAEP-SHA1 */ +static UA_StatusCode +asym_encrypt_sp_basic256(Basic256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const size_t plainTextBlockSize = asym_getRemotePlainTextBlockSize_sp_basic256(cc); + + mbedtls_rsa_context *remoteRsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + mbedtls_rsa_set_padding(remoteRsaContext, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + + return mbedtls_encrypt_rsaOaep(remoteRsaContext, &cc->policyContext->drbgContext, + data, plainTextBlockSize); +} + +/* AsymmetricEncryptionAlgorithm_RSA-OAEP-SHA1 */ +static UA_StatusCode +asym_decrypt_sp_basic256(Basic256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + return mbedtls_decrypt_rsaOaep(&cc->policyContext->localPrivateKey, + &cc->policyContext->drbgContext, data); +} + +static size_t +asym_getLocalEncryptionKeyLength_sp_basic256(const Basic256_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->policyContext->localPrivateKey) * 8; +} + +static size_t +asym_getRemoteEncryptionKeyLength_sp_basic256(const Basic256_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->remoteCertificate.pk) * 8; +} + +static size_t +asym_getRemoteBlockSize_sp_basic256(const Basic256_ChannelContext *cc) { + mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + return rsaContext->len; +} + +static UA_StatusCode +asym_makeThumbprint_sp_basic256(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificate, + UA_ByteString *thumbprint) { + if(securityPolicy == NULL || certificate == NULL || thumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + return mbedtls_thumbprint_sha1(certificate, thumbprint); +} + +static UA_StatusCode +asymmetricModule_compareCertificateThumbprint_sp_basic256(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificateThumbprint) { + if(securityPolicy == NULL || certificateThumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic256_PolicyContext *pc = (Basic256_PolicyContext *)securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) + return UA_STATUSCODE_BADCERTIFICATEINVALID; + + return UA_STATUSCODE_GOOD; +} + +/*******************/ +/* SymmetricModule */ +/*******************/ + +static UA_StatusCode +sym_verify_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(cc == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Compute MAC */ + if(signature->length != UA_SHA1_LENGTH) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + Basic256_PolicyContext *pc = cc->policyContext; + + unsigned char mac[UA_SHA1_LENGTH]; + mbedtls_hmac(&pc->sha1MdContext, &cc->remoteSymSigningKey, message, mac); + + /* Compare with Signature */ + if(!UA_constantTimeEqual(signature->data, mac, UA_SHA1_LENGTH)) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +sym_sign_sp_basic256(const Basic256_ChannelContext *cc, + const UA_ByteString *message, UA_ByteString *signature) { + if(signature->length != UA_SHA1_LENGTH) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_hmac(&cc->policyContext->sha1MdContext, &cc->localSymSigningKey, + message, signature->data); + return UA_STATUSCODE_GOOD; +} + +static size_t +sym_getSignatureSize_sp_basic256(const void *channelContext) { + return UA_SHA1_LENGTH; +} + +static size_t +sym_getSigningKeyLength_sp_basic256(const void *const channelContext) { + return UA_BASIC256_SYM_SIGNING_KEY_LENGTH; +} + +static size_t +sym_getEncryptionKeyLength_sp_basic256(const void *channelContext) { + return UA_SECURITYPOLICY_BASIC256_SYM_KEY_LENGTH; +} + +static size_t +sym_getEncryptionBlockSize_sp_basic256(const void *const channelContext) { + return UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +sym_getPlainTextBlockSize_sp_basic256(const void *const channelContext) { + return UA_SECURITYPOLICY_BASIC256_SYM_PLAIN_TEXT_BLOCK_SIZE; +} + +static UA_StatusCode +sym_encrypt_sp_basic256(const Basic256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(cc->localSymIv.length != UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_BLOCK_SIZE) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t plainTextBlockSize = UA_SECURITYPOLICY_BASIC256_SYM_PLAIN_TEXT_BLOCK_SIZE; + if(data->length % plainTextBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Keylength in bits */ + unsigned int keylength = (unsigned int)(cc->localSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_enc(&aesContext, cc->localSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->localSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_ENCRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_decrypt_sp_basic256(const Basic256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t encryptionBlockSize = UA_SECURITYPOLICY_BASIC256_SYM_ENCRYPTION_BLOCK_SIZE; + if(cc->remoteSymIv.length != encryptionBlockSize) + return UA_STATUSCODE_BADINTERNALERROR; + + if(data->length % encryptionBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned int keylength = (unsigned int)(cc->remoteSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_dec(&aesContext, cc->remoteSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->remoteSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_DECRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_generateKey_sp_basic256(void *policyContext, const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) { + if(secret == NULL || seed == NULL || out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Basic256_PolicyContext *pc = (Basic256_PolicyContext *)policyContext; + return mbedtls_generateKey(&pc->sha1MdContext, secret, seed, out); +} + +static UA_StatusCode +sym_generateNonce_sp_basic256(void *policyContext, UA_ByteString *out) { + if(out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Basic256_PolicyContext *pc = (Basic256_PolicyContext *)policyContext; + int mbedErr = mbedtls_ctr_drbg_random(&pc->drbgContext, out->data, out->length); + if(mbedErr) + return UA_STATUSCODE_BADUNEXPECTEDERROR; + return UA_STATUSCODE_GOOD; +} + +/*****************/ +/* ChannelModule */ +/*****************/ + +/* Assumes that the certificate has been verified externally */ +static UA_StatusCode +parseRemoteCertificate_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *remoteCertificate) { + if(remoteCertificate == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Parse the certificate */ + int mbedErr = mbedtls_x509_crt_parse(&cc->remoteCertificate, remoteCertificate->data, + remoteCertificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + /* Check the key length */ + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + if(rsaContext->len < UA_SECURITYPOLICY_BASIC256_MINASYMKEYLENGTH || + rsaContext->len > UA_SECURITYPOLICY_BASIC256_MAXASYMKEYLENGTH) + return UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED; + + return UA_STATUSCODE_GOOD; +} + +static void +channelContext_deleteContext_sp_basic256(Basic256_ChannelContext *cc) { + UA_ByteString_clear(&cc->localSymSigningKey); + UA_ByteString_clear(&cc->localSymEncryptingKey); + UA_ByteString_clear(&cc->localSymIv); + + UA_ByteString_clear(&cc->remoteSymSigningKey); + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + UA_ByteString_clear(&cc->remoteSymIv); + + mbedtls_x509_crt_free(&cc->remoteCertificate); + + UA_free(cc); +} + +static UA_StatusCode +channelContext_newContext_sp_basic256(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate, + void **pp_contextData) { + if(securityPolicy == NULL || remoteCertificate == NULL || pp_contextData == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Allocate the channel context */ + *pp_contextData = UA_malloc(sizeof(Basic256_ChannelContext)); + if(*pp_contextData == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + + Basic256_ChannelContext *cc = (Basic256_ChannelContext *)*pp_contextData; + + /* Initialize the channel context */ + cc->policyContext = (Basic256_PolicyContext *)securityPolicy->policyContext; + + UA_ByteString_init(&cc->localSymSigningKey); + UA_ByteString_init(&cc->localSymEncryptingKey); + UA_ByteString_init(&cc->localSymIv); + + UA_ByteString_init(&cc->remoteSymSigningKey); + UA_ByteString_init(&cc->remoteSymEncryptingKey); + UA_ByteString_init(&cc->remoteSymIv); + + mbedtls_x509_crt_init(&cc->remoteCertificate); + + // TODO: this can be optimized so that we dont allocate memory before parsing the certificate + UA_StatusCode retval = parseRemoteCertificate_sp_basic256(cc, remoteCertificate); + if(retval != UA_STATUSCODE_GOOD) { + channelContext_deleteContext_sp_basic256(cc); + *pp_contextData = NULL; + } + return retval; +} + +static UA_StatusCode +channelContext_setLocalSymEncryptingKey_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setLocalSymSigningKey_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + + +static UA_StatusCode +channelContext_setLocalSymIv_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static UA_StatusCode +channelContext_setRemoteSymEncryptingKey_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setRemoteSymSigningKey_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +channelContext_setRemoteSymIv_sp_basic256(Basic256_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(iv, &cc->remoteSymIv); +} + +static UA_StatusCode +channelContext_compareCertificate_sp_basic256(const Basic256_ChannelContext *cc, + const UA_ByteString *certificate) { + if(cc == NULL || certificate == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_x509_crt cert; + mbedtls_x509_crt_init(&cert); + int mbedErr = mbedtls_x509_crt_parse(&cert, certificate->data, certificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(cert.raw.len != cc->remoteCertificate.raw.len || + memcmp(cert.raw.p, cc->remoteCertificate.raw.p, cert.raw.len) != 0) + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + mbedtls_x509_crt_free(&cert); + return retval; +} + +static void +clear_sp_basic256(UA_SecurityPolicy *securityPolicy) { + if(securityPolicy == NULL) + return; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + if(securityPolicy->policyContext == NULL) + return; + + /* delete all allocated members in the context */ + Basic256_PolicyContext *pc = (Basic256_PolicyContext *) + securityPolicy->policyContext; + + mbedtls_ctr_drbg_free(&pc->drbgContext); + mbedtls_entropy_free(&pc->entropyContext); + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_md_free(&pc->sha1MdContext); + UA_ByteString_clear(&pc->localCertThumbprint); + + UA_LOG_DEBUG(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Deleted members of EndpointContext for sp_basic256"); + + UA_free(pc); + securityPolicy->policyContext = NULL; +} + +static UA_StatusCode +updateCertificateAndPrivateKey_sp_basic256(UA_SecurityPolicy *securityPolicy, + const UA_ByteString newCertificate, + const UA_ByteString newPrivateKey) { + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(securityPolicy->policyContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic256_PolicyContext *pc = (Basic256_PolicyContext *) + securityPolicy->policyContext; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + UA_StatusCode retval = UA_mbedTLS_LoadLocalCertificate(&newCertificate, &securityPolicy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* Set the new private key */ + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_pk_init(&pc->localPrivateKey); + + int mbedErr = UA_mbedTLS_LoadPrivateKey(&newPrivateKey, &pc->localPrivateKey); + + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + retval = asym_makeThumbprint_sp_basic256(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return retval; + + error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not update certificate and private key"); + if(securityPolicy->policyContext != NULL) + clear_sp_basic256(securityPolicy); + return retval; +} + +static UA_StatusCode +policyContext_newContext_sp_basic256(UA_SecurityPolicy *securityPolicy, + const UA_ByteString localPrivateKey) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if (localPrivateKey.length == 0) { + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Can not initialize security policy. Private key is empty."); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Basic256_PolicyContext *pc = (Basic256_PolicyContext *) + UA_malloc(sizeof(Basic256_PolicyContext)); + securityPolicy->policyContext = (void *)pc; + if(!pc) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Initialize the PolicyContext */ + memset(pc, 0, sizeof(Basic256_PolicyContext)); + mbedtls_ctr_drbg_init(&pc->drbgContext); + mbedtls_entropy_init(&pc->entropyContext); + mbedtls_pk_init(&pc->localPrivateKey); + mbedtls_md_init(&pc->sha1MdContext); + + /* Initialized the message digest */ + const mbedtls_md_info_t *mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1); + int mbedErr = mbedtls_md_setup(&pc->sha1MdContext, mdInfo, MBEDTLS_MD_SHA1); + if(mbedErr) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Add the system entropy source */ + mbedErr = mbedtls_entropy_add_source(&pc->entropyContext, + MBEDTLS_ENTROPY_POLL_METHOD, NULL, 0, + MBEDTLS_ENTROPY_SOURCE_STRONG); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Seed the RNG */ + char *personalization = "open62541-drbg"; + mbedErr = mbedtls_ctr_drbg_seed(&pc->drbgContext, mbedtls_entropy_func, + &pc->entropyContext, + (const unsigned char *)personalization, 14); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the private key */ + mbedErr = UA_mbedTLS_LoadPrivateKey(&localPrivateKey, &pc->localPrivateKey); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the local certificate thumbprint */ + retval = UA_ByteString_allocBuffer(&pc->localCertThumbprint, UA_SHA1_LENGTH); + if(retval != UA_STATUSCODE_GOOD) + goto error; + retval = asym_makeThumbprint_sp_basic256(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return UA_STATUSCODE_GOOD; + +error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not create securityContext: %s", UA_StatusCode_name(retval)); + if(securityPolicy->policyContext != NULL) + clear_sp_basic256(securityPolicy); + return retval; +} + +UA_StatusCode +UA_SecurityPolicy_Basic256(UA_SecurityPolicy *policy, const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, const UA_Logger *logger) { + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + + policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Basic256\0"); + + UA_SecurityPolicyAsymmetricModule *const asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule *const symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule *const channelModule = &policy->channelModule; + + UA_StatusCode retval = UA_mbedTLS_LoadLocalCertificate(&localCertificate, &policy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* AsymmetricModule */ + UA_SecurityPolicySignatureAlgorithm *asym_signatureAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2000/09/xmldsig#rsa-sha1\0"); + asym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, const UA_ByteString *))asym_verify_sp_basic256; + asym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))asym_sign_sp_basic256; + asym_signatureAlgorithm->getLocalSignatureSize = + (size_t (*)(const void *))asym_getLocalSignatureSize_sp_basic256; + asym_signatureAlgorithm->getRemoteSignatureSize = + (size_t (*)(const void *))asym_getRemoteSignatureSize_sp_basic256; + asym_signatureAlgorithm->getLocalKeyLength = NULL; // TODO: Write function + asym_signatureAlgorithm->getRemoteKeyLength = NULL; // TODO: Write function + + UA_SecurityPolicyEncryptionAlgorithm *asym_encryptionAlgorithm = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-oaep\0"); + asym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))asym_encrypt_sp_basic256; + asym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))asym_decrypt_sp_basic256; + asym_encryptionAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))asym_getLocalEncryptionKeyLength_sp_basic256; + asym_encryptionAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))asym_getRemoteEncryptionKeyLength_sp_basic256; + asym_encryptionAlgorithm->getRemoteBlockSize = + (size_t (*)(const void *))asym_getRemoteBlockSize_sp_basic256; + asym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))asym_getRemotePlainTextBlockSize_sp_basic256; + + asymmetricModule->makeCertificateThumbprint = asym_makeThumbprint_sp_basic256; + asymmetricModule->compareCertificateThumbprint = + asymmetricModule_compareCertificateThumbprint_sp_basic256; + + /* SymmetricModule */ + symmetricModule->generateKey = sym_generateKey_sp_basic256; + symmetricModule->generateNonce = sym_generateNonce_sp_basic256; + + UA_SecurityPolicySignatureAlgorithm *sym_signatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + sym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha1\0"); + sym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, + const UA_ByteString *))sym_verify_sp_basic256; + sym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))sym_sign_sp_basic256; + sym_signatureAlgorithm->getLocalSignatureSize = sym_getSignatureSize_sp_basic256; + sym_signatureAlgorithm->getRemoteSignatureSize = sym_getSignatureSize_sp_basic256; + sym_signatureAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_basic256; + sym_signatureAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_basic256; + + UA_SecurityPolicyEncryptionAlgorithm *sym_encryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + sym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#aes256-cbc\0"); + sym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_encrypt_sp_basic256; + sym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_decrypt_sp_basic256; + sym_encryptionAlgorithm->getLocalKeyLength = sym_getEncryptionKeyLength_sp_basic256; + sym_encryptionAlgorithm->getRemoteKeyLength = sym_getEncryptionKeyLength_sp_basic256; + sym_encryptionAlgorithm->getRemoteBlockSize = + (size_t (*)(const void *))sym_getEncryptionBlockSize_sp_basic256; + sym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))sym_getPlainTextBlockSize_sp_basic256; + symmetricModule->secureChannelNonceLength = 32; + + // Use the same signature algorithm as the asymmetric component for certificate signing (see standard) + policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + /* ChannelModule */ + channelModule->newContext = channelContext_newContext_sp_basic256; + channelModule->deleteContext = (void (*)(void *)) + channelContext_deleteContext_sp_basic256; + + channelModule->setLocalSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymEncryptingKey_sp_basic256; + channelModule->setLocalSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymSigningKey_sp_basic256; + channelModule->setLocalSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymIv_sp_basic256; + + channelModule->setRemoteSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymEncryptingKey_sp_basic256; + channelModule->setRemoteSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymSigningKey_sp_basic256; + channelModule->setRemoteSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymIv_sp_basic256; + + channelModule->compareCertificate = (UA_StatusCode (*)(const void *, const UA_ByteString *)) + channelContext_compareCertificate_sp_basic256; + + policy->updateCertificateAndPrivateKey = updateCertificateAndPrivateKey_sp_basic256; + policy->clear = clear_sp_basic256; + + UA_StatusCode res = policyContext_newContext_sp_basic256(policy, localPrivateKey); + if(res != UA_STATUSCODE_GOOD) + clear_sp_basic256(policy); + + return res; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/mbedtls/ua_securitypolicy_basic256sha256.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2018 (c) Daniel Feist, Precitec GmbH & Co. KG + * Copyright 2018 (c) HMS Industrial Networks AB (Author: Jonas Green) + * Copyright 2020 (c) Wind River Systems, Inc. + * Copyright 2020 (c) basysKom GmbH + */ + + +#ifdef UA_ENABLE_ENCRYPTION_MBEDTLS + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Notes: + * mbedTLS' AES allows in-place encryption and decryption. Sow we don't have to + * allocate temp buffers. + * https://tls.mbed.org/discussions/generic/in-place-decryption-with-aes256-same-input-output-buffer + */ + +#define UA_SECURITYPOLICY_BASIC256SHA256_RSAPADDING_LEN 42 +#define UA_SHA1_LENGTH 20 +#define UA_SHA256_LENGTH 32 +#define UA_BASIC256SHA256_SYM_SIGNING_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_BASIC256SHA256_SYM_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC256SHA256_SYM_PLAIN_TEXT_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_BASIC256SHA256_MINASYMKEYLENGTH 256 +#define UA_SECURITYPOLICY_BASIC256SHA256_MAXASYMKEYLENGTH 512 + +typedef struct { + UA_ByteString localCertThumbprint; + + mbedtls_ctr_drbg_context drbgContext; + mbedtls_entropy_context entropyContext; + mbedtls_md_context_t sha256MdContext; + mbedtls_pk_context localPrivateKey; +} Basic256Sha256_PolicyContext; + +typedef struct { + Basic256Sha256_PolicyContext *policyContext; + + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + mbedtls_x509_crt remoteCertificate; +} Basic256Sha256_ChannelContext; + +/********************/ +/* AsymmetricModule */ +/********************/ + +/* VERIFY AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 */ +static UA_StatusCode +asym_verify_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned char hash[UA_SHA256_LENGTH]; +#if MBEDTLS_VERSION_NUMBER >= 0x02070000 + // TODO check return status + mbedtls_sha256_ret(message->data, message->length, hash, 0); +#else + mbedtls_sha256(message->data, message->length, hash, 0); +#endif + + /* Set the RSA settings */ + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_SHA256); + + /* For RSA keys, the default padding type is PKCS#1 v1.5 in mbedtls_pk_verify() */ + /* Alternatively, use more specific function mbedtls_rsa_rsassa_pkcs1_v15_verify(), i.e. */ + /* int mbedErr = mbedtls_rsa_rsassa_pkcs1_v15_verify(rsaContext, NULL, NULL, + MBEDTLS_RSA_PUBLIC, MBEDTLS_MD_SHA256, + UA_SHA256_LENGTH, hash, + signature->data); */ + int mbedErr = mbedtls_pk_verify(&cc->remoteCertificate.pk, + MBEDTLS_MD_SHA256, hash, UA_SHA256_LENGTH, + signature->data, signature->length); + + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + return UA_STATUSCODE_GOOD; +} + +/* AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 */ +static UA_StatusCode +asym_sign_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *message, + UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned char hash[UA_SHA256_LENGTH]; +#if MBEDTLS_VERSION_NUMBER >= 0x02070000 + // TODO check return status + mbedtls_sha256_ret(message->data, message->length, hash, 0); +#else + mbedtls_sha256(message->data, message->length, hash, 0); +#endif + + Basic256Sha256_PolicyContext *pc = cc->policyContext; + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(pc->localPrivateKey); + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_SHA256); + + size_t sigLen = 0; + + /* For RSA keys, the default padding type is PKCS#1 v1.5 in mbedtls_pk_sign */ + /* Alternatively use more specific function mbedtls_rsa_rsassa_pkcs1_v15_sign() */ + int mbedErr = mbedtls_pk_sign(&pc->localPrivateKey, + MBEDTLS_MD_SHA256, hash, + UA_SHA256_LENGTH, signature->data, + &sigLen, mbedtls_ctr_drbg_random, + &pc->drbgContext); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + return UA_STATUSCODE_GOOD; +} + +static size_t +asym_getLocalSignatureSize_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc) { + if(cc == NULL) + return 0; + + return mbedtls_pk_rsa(cc->policyContext->localPrivateKey)->len; +} + +static size_t +asym_getRemoteSignatureSize_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc) { + if(cc == NULL) + return 0; + + return mbedtls_pk_rsa(cc->remoteCertificate.pk)->len; +} + +static size_t +asym_getRemoteBlockSize_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc) { + mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + return rsaContext->len; +} + +static size_t +asym_getRemotePlainTextBlockSize_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc) { + mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + return rsaContext->len - UA_SECURITYPOLICY_BASIC256SHA256_RSAPADDING_LEN; +} + + +/* AsymmetricEncryptionAlgorithm_RSA-OAEP-SHA1 */ +static UA_StatusCode +asym_encrypt_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const size_t plainTextBlockSize = asym_getRemotePlainTextBlockSize_sp_basic256sha256(cc); + + mbedtls_rsa_context *remoteRsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + mbedtls_rsa_set_padding(remoteRsaContext, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + + return mbedtls_encrypt_rsaOaep(remoteRsaContext, &cc->policyContext->drbgContext, + data, plainTextBlockSize); +} + +/* AsymmetricEncryptionAlgorithm_RSA-OAEP-SHA1 */ +static UA_StatusCode +asym_decrypt_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + return mbedtls_decrypt_rsaOaep(&cc->policyContext->localPrivateKey, + &cc->policyContext->drbgContext, data); +} + +static size_t +asym_getLocalEncryptionKeyLength_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->policyContext->localPrivateKey) * 8; +} + +static size_t +asym_getRemoteEncryptionKeyLength_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->remoteCertificate.pk) * 8; +} + +static UA_StatusCode +asym_makeThumbprint_sp_basic256sha256(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificate, + UA_ByteString *thumbprint) { + if(securityPolicy == NULL || certificate == NULL || thumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + return mbedtls_thumbprint_sha1(certificate, thumbprint); +} + +static UA_StatusCode +asymmetricModule_compareCertificateThumbprint_sp_basic256sha256(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificateThumbprint) { + if(securityPolicy == NULL || certificateThumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic256Sha256_PolicyContext *pc = (Basic256Sha256_PolicyContext *)securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) + return UA_STATUSCODE_BADCERTIFICATEINVALID; + + return UA_STATUSCODE_GOOD; +} + +/*******************/ +/* SymmetricModule */ +/*******************/ + +static UA_StatusCode +sym_verify_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(cc == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Compute MAC */ + if(signature->length != UA_SHA256_LENGTH) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + Basic256Sha256_PolicyContext *pc = cc->policyContext; + unsigned char mac[UA_SHA256_LENGTH]; + mbedtls_hmac(&pc->sha256MdContext, &cc->remoteSymSigningKey, message, mac); + + /* Compare with Signature */ + if(!UA_constantTimeEqual(signature->data, mac, UA_SHA256_LENGTH)) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +sym_sign_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc, + const UA_ByteString *message, + UA_ByteString *signature) { + if(signature->length != UA_SHA256_LENGTH) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_hmac(&cc->policyContext->sha256MdContext, &cc->localSymSigningKey, + message, signature->data); + return UA_STATUSCODE_GOOD; +} + +static size_t +sym_getSignatureSize_sp_basic256sha256(const void *channelContext) { + return UA_SHA256_LENGTH; +} + +static size_t +sym_getSigningKeyLength_sp_basic256sha256(const void *channelContext) { + return UA_BASIC256SHA256_SYM_SIGNING_KEY_LENGTH; +} + +static size_t +sym_getEncryptionKeyLength_sp_basic256sha256(const void *channelContext) { + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_KEY_LENGTH; +} + +static size_t +sym_getEncryptionBlockSize_sp_basic256sha256(const void *channelContext) { + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +sym_getPlainTextBlockSize_sp_basic256sha256(const void *channelContext) { + return UA_SECURITYPOLICY_BASIC256SHA256_SYM_PLAIN_TEXT_BLOCK_SIZE; +} + +static UA_StatusCode +sym_encrypt_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(cc->localSymIv.length != UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_BLOCK_SIZE) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t plainTextBlockSize = UA_SECURITYPOLICY_BASIC256SHA256_SYM_PLAIN_TEXT_BLOCK_SIZE; + + if(data->length % plainTextBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Keylength in bits */ + unsigned int keylength = (unsigned int)(cc->localSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_enc(&aesContext, cc->localSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->localSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_ENCRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_decrypt_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t encryptionBlockSize = UA_SECURITYPOLICY_BASIC256SHA256_SYM_ENCRYPTION_BLOCK_SIZE; + if(cc->remoteSymIv.length != encryptionBlockSize) + return UA_STATUSCODE_BADINTERNALERROR; + + if(data->length % encryptionBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned int keylength = (unsigned int)(cc->remoteSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_dec(&aesContext, cc->remoteSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->remoteSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_DECRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_generateKey_sp_basic256sha256(void *policyContext, const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) { + if(secret == NULL || seed == NULL || out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Basic256Sha256_PolicyContext *pc = (Basic256Sha256_PolicyContext *)policyContext; + return mbedtls_generateKey(&pc->sha256MdContext, secret, seed, out); +} + +static UA_StatusCode +sym_generateNonce_sp_basic256sha256(void *policyContext, UA_ByteString *out) { + if(out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Basic256Sha256_PolicyContext *pc = (Basic256Sha256_PolicyContext *)policyContext; + int mbedErr = mbedtls_ctr_drbg_random(&pc->drbgContext, out->data, out->length); + if(mbedErr) + return UA_STATUSCODE_BADUNEXPECTEDERROR; + return UA_STATUSCODE_GOOD; +} + +/*****************/ +/* ChannelModule */ +/*****************/ + +/* Assumes that the certificate has been verified externally */ +static UA_StatusCode +parseRemoteCertificate_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *remoteCertificate) { + if(remoteCertificate == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Parse the certificate */ + int mbedErr = mbedtls_x509_crt_parse(&cc->remoteCertificate, remoteCertificate->data, + remoteCertificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + /* Check the key length */ + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + if(rsaContext->len < UA_SECURITYPOLICY_BASIC256SHA256_MINASYMKEYLENGTH || + rsaContext->len > UA_SECURITYPOLICY_BASIC256SHA256_MAXASYMKEYLENGTH) + return UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED; + + return UA_STATUSCODE_GOOD; +} + +static void +channelContext_deleteContext_sp_basic256sha256(Basic256Sha256_ChannelContext *cc) { + UA_ByteString_clear(&cc->localSymSigningKey); + UA_ByteString_clear(&cc->localSymEncryptingKey); + UA_ByteString_clear(&cc->localSymIv); + + UA_ByteString_clear(&cc->remoteSymSigningKey); + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + UA_ByteString_clear(&cc->remoteSymIv); + + mbedtls_x509_crt_free(&cc->remoteCertificate); + + UA_free(cc); +} + +static UA_StatusCode +channelContext_newContext_sp_basic256sha256(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate, + void **pp_contextData) { + if(securityPolicy == NULL || remoteCertificate == NULL || pp_contextData == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Allocate the channel context */ + *pp_contextData = UA_malloc(sizeof(Basic256Sha256_ChannelContext)); + if(*pp_contextData == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + + Basic256Sha256_ChannelContext *cc = (Basic256Sha256_ChannelContext *)*pp_contextData; + + /* Initialize the channel context */ + cc->policyContext = (Basic256Sha256_PolicyContext *)securityPolicy->policyContext; + + UA_ByteString_init(&cc->localSymSigningKey); + UA_ByteString_init(&cc->localSymEncryptingKey); + UA_ByteString_init(&cc->localSymIv); + + UA_ByteString_init(&cc->remoteSymSigningKey); + UA_ByteString_init(&cc->remoteSymEncryptingKey); + UA_ByteString_init(&cc->remoteSymIv); + + mbedtls_x509_crt_init(&cc->remoteCertificate); + + // TODO: this can be optimized so that we dont allocate memory before parsing the certificate + UA_StatusCode retval = parseRemoteCertificate_sp_basic256sha256(cc, remoteCertificate); + if(retval != UA_STATUSCODE_GOOD) { + channelContext_deleteContext_sp_basic256sha256(cc); + *pp_contextData = NULL; + } + return retval; +} + +static UA_StatusCode +channelContext_setLocalSymEncryptingKey_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setLocalSymSigningKey_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + + +static UA_StatusCode +channelContext_setLocalSymIv_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static UA_StatusCode +channelContext_setRemoteSymEncryptingKey_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setRemoteSymSigningKey_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +channelContext_setRemoteSymIv_sp_basic256sha256(Basic256Sha256_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(iv, &cc->remoteSymIv); +} + +static UA_StatusCode +channelContext_compareCertificate_sp_basic256sha256(const Basic256Sha256_ChannelContext *cc, + const UA_ByteString *certificate) { + if(cc == NULL || certificate == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_x509_crt cert; + mbedtls_x509_crt_init(&cert); + int mbedErr = mbedtls_x509_crt_parse(&cert, certificate->data, certificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(cert.raw.len != cc->remoteCertificate.raw.len || + memcmp(cert.raw.p, cc->remoteCertificate.raw.p, cert.raw.len) != 0) + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + mbedtls_x509_crt_free(&cert); + return retval; +} + +static void +clear_sp_basic256sha256(UA_SecurityPolicy *securityPolicy) { + if(securityPolicy == NULL) + return; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + if(securityPolicy->policyContext == NULL) + return; + + /* delete all allocated members in the context */ + Basic256Sha256_PolicyContext *pc = (Basic256Sha256_PolicyContext *) + securityPolicy->policyContext; + + mbedtls_ctr_drbg_free(&pc->drbgContext); + mbedtls_entropy_free(&pc->entropyContext); + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_md_free(&pc->sha256MdContext); + UA_ByteString_clear(&pc->localCertThumbprint); + + UA_LOG_DEBUG(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Deleted members of EndpointContext for sp_basic256sha256"); + + UA_free(pc); + securityPolicy->policyContext = NULL; +} + +static UA_StatusCode +updateCertificateAndPrivateKey_sp_basic256sha256(UA_SecurityPolicy *securityPolicy, + const UA_ByteString newCertificate, + const UA_ByteString newPrivateKey) { + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(securityPolicy->policyContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Basic256Sha256_PolicyContext *pc = + (Basic256Sha256_PolicyContext *) securityPolicy->policyContext; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + UA_StatusCode retval = UA_mbedTLS_LoadLocalCertificate(&newCertificate, &securityPolicy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* Set the new private key */ + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_pk_init(&pc->localPrivateKey); + int mbedErr = UA_mbedTLS_LoadPrivateKey(&newPrivateKey, &pc->localPrivateKey); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + retval = asym_makeThumbprint_sp_basic256sha256(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return retval; + + error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not update certificate and private key"); + if(securityPolicy->policyContext != NULL) + clear_sp_basic256sha256(securityPolicy); + return retval; +} + +static UA_StatusCode +policyContext_newContext_sp_basic256sha256(UA_SecurityPolicy *securityPolicy, + const UA_ByteString localPrivateKey) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if (localPrivateKey.length == 0) { + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Can not initialize security policy. Private key is empty."); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Basic256Sha256_PolicyContext *pc = (Basic256Sha256_PolicyContext *) + UA_malloc(sizeof(Basic256Sha256_PolicyContext)); + securityPolicy->policyContext = (void *)pc; + if(!pc) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Initialize the PolicyContext */ + memset(pc, 0, sizeof(Basic256Sha256_PolicyContext)); + mbedtls_ctr_drbg_init(&pc->drbgContext); + mbedtls_entropy_init(&pc->entropyContext); + mbedtls_pk_init(&pc->localPrivateKey); + mbedtls_md_init(&pc->sha256MdContext); + + /* Initialized the message digest */ + const mbedtls_md_info_t *const mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); + int mbedErr = mbedtls_md_setup(&pc->sha256MdContext, mdInfo, MBEDTLS_MD_SHA256); + if(mbedErr) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Add the system entropy source */ + mbedErr = mbedtls_entropy_add_source(&pc->entropyContext, + MBEDTLS_ENTROPY_POLL_METHOD, NULL, 0, + MBEDTLS_ENTROPY_SOURCE_STRONG); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Seed the RNG */ + char *personalization = "open62541-drbg"; + mbedErr = mbedtls_ctr_drbg_seed(&pc->drbgContext, mbedtls_entropy_func, + &pc->entropyContext, + (const unsigned char *)personalization, 14); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the private key */ + mbedErr = UA_mbedTLS_LoadPrivateKey(&localPrivateKey, &pc->localPrivateKey); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the local certificate thumbprint */ + retval = UA_ByteString_allocBuffer(&pc->localCertThumbprint, UA_SHA1_LENGTH); + if(retval != UA_STATUSCODE_GOOD) + goto error; + retval = asym_makeThumbprint_sp_basic256sha256(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return UA_STATUSCODE_GOOD; + +error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not create securityContext: %s", UA_StatusCode_name(retval)); + if(securityPolicy->policyContext != NULL) + clear_sp_basic256sha256(securityPolicy); + return retval; +} + +UA_StatusCode +UA_SecurityPolicy_Basic256Sha256(UA_SecurityPolicy *policy, const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, const UA_Logger *logger) { + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + + policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Basic256Sha256"); + + UA_SecurityPolicyAsymmetricModule *const asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule *const symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule *const channelModule = &policy->channelModule; + + UA_StatusCode retval = UA_mbedTLS_LoadLocalCertificate(&localCertificate, &policy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* AsymmetricModule */ + UA_SecurityPolicySignatureAlgorithm *asym_signatureAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256\0"); + asym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, const UA_ByteString *))asym_verify_sp_basic256sha256; + asym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))asym_sign_sp_basic256sha256; + asym_signatureAlgorithm->getLocalSignatureSize = + (size_t (*)(const void *))asym_getLocalSignatureSize_sp_basic256sha256; + asym_signatureAlgorithm->getRemoteSignatureSize = + (size_t (*)(const void *))asym_getRemoteSignatureSize_sp_basic256sha256; + asym_signatureAlgorithm->getLocalKeyLength = NULL; // TODO: Write function + asym_signatureAlgorithm->getRemoteKeyLength = NULL; // TODO: Write function + + UA_SecurityPolicyEncryptionAlgorithm *asym_encryptionAlgorithm = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-oaep\0"); + asym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))asym_encrypt_sp_basic256sha256; + asym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *)) + asym_decrypt_sp_basic256sha256; + asym_encryptionAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))asym_getLocalEncryptionKeyLength_sp_basic256sha256; + asym_encryptionAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))asym_getRemoteEncryptionKeyLength_sp_basic256sha256; + asym_encryptionAlgorithm->getRemoteBlockSize = + (size_t (*)(const void *))asym_getRemoteBlockSize_sp_basic256sha256; + asym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))asym_getRemotePlainTextBlockSize_sp_basic256sha256; + + asymmetricModule->makeCertificateThumbprint = asym_makeThumbprint_sp_basic256sha256; + asymmetricModule->compareCertificateThumbprint = + asymmetricModule_compareCertificateThumbprint_sp_basic256sha256; + + /* SymmetricModule */ + symmetricModule->generateKey = sym_generateKey_sp_basic256sha256; + symmetricModule->generateNonce = sym_generateNonce_sp_basic256sha256; + + UA_SecurityPolicySignatureAlgorithm *sym_signatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + sym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha1\0"); + sym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, const UA_ByteString *))sym_verify_sp_basic256sha256; + sym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))sym_sign_sp_basic256sha256; + sym_signatureAlgorithm->getLocalSignatureSize = sym_getSignatureSize_sp_basic256sha256; + sym_signatureAlgorithm->getRemoteSignatureSize = sym_getSignatureSize_sp_basic256sha256; + sym_signatureAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_basic256sha256; + sym_signatureAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_basic256sha256; + + UA_SecurityPolicyEncryptionAlgorithm *sym_encryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + sym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#aes256-cbc"); + sym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_encrypt_sp_basic256sha256; + sym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_decrypt_sp_basic256sha256; + sym_encryptionAlgorithm->getLocalKeyLength = sym_getEncryptionKeyLength_sp_basic256sha256; + sym_encryptionAlgorithm->getRemoteKeyLength = sym_getEncryptionKeyLength_sp_basic256sha256; + sym_encryptionAlgorithm->getRemoteBlockSize = + (size_t (*)(const void *))sym_getEncryptionBlockSize_sp_basic256sha256; + sym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))sym_getPlainTextBlockSize_sp_basic256sha256; + symmetricModule->secureChannelNonceLength = 32; + + // Use the same signature algorithm as the asymmetric component for certificate signing (see standard) + policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + /* ChannelModule */ + channelModule->newContext = channelContext_newContext_sp_basic256sha256; + channelModule->deleteContext = (void (*)(void *)) + channelContext_deleteContext_sp_basic256sha256; + + channelModule->setLocalSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymEncryptingKey_sp_basic256sha256; + channelModule->setLocalSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymSigningKey_sp_basic256sha256; + channelModule->setLocalSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymIv_sp_basic256sha256; + + channelModule->setRemoteSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymEncryptingKey_sp_basic256sha256; + channelModule->setRemoteSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymSigningKey_sp_basic256sha256; + channelModule->setRemoteSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymIv_sp_basic256sha256; + + channelModule->compareCertificate = (UA_StatusCode (*)(const void *, const UA_ByteString *)) + channelContext_compareCertificate_sp_basic256sha256; + + policy->updateCertificateAndPrivateKey = updateCertificateAndPrivateKey_sp_basic256sha256; + policy->clear = clear_sp_basic256sha256; + + UA_StatusCode res = policyContext_newContext_sp_basic256sha256(policy, localPrivateKey); + if(res != UA_STATUSCODE_GOOD) + clear_sp_basic256sha256(policy); + + return res; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/mbedtls/ua_securitypolicy_aes128sha256rsaoaep.c" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2018 (c) Daniel Feist, Precitec GmbH & Co. KG + * Copyright 2018 (c) HMS Industrial Networks AB (Author: Jonas Green) + * Copyright 2020 (c) Wind River Systems, Inc. + */ + + +#ifdef UA_ENABLE_ENCRYPTION_MBEDTLS + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Notes: + * mbedTLS' AES allows in-place encryption and decryption. So we don't have to + * allocate temp buffers. + * https://tls.mbed.org/discussions/generic/in-place-decryption-with-aes256-same-input-output-buffer + */ + +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_RSAPADDING_LEN 42 +#define UA_SHA1_LENGTH 20 +#define UA_SHA256_LENGTH 32 +#define UA_AES128SHA256RSAOAEP_SYM_SIGNING_KEY_LENGTH 32 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_KEY_LENGTH 16 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_PLAIN_TEXT_BLOCK_SIZE 16 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_MINASYMKEYLENGTH 256 +#define UA_SECURITYPOLICY_AES128SHA256RSAOAEP_MAXASYMKEYLENGTH 512 + +typedef struct { + UA_ByteString localCertThumbprint; + + mbedtls_ctr_drbg_context drbgContext; + mbedtls_entropy_context entropyContext; + mbedtls_md_context_t sha256MdContext; + mbedtls_pk_context localPrivateKey; +} Aes128Sha256PsaOaep_PolicyContext; + +typedef struct { + Aes128Sha256PsaOaep_PolicyContext *policyContext; + + UA_ByteString localSymSigningKey; + UA_ByteString localSymEncryptingKey; + UA_ByteString localSymIv; + + UA_ByteString remoteSymSigningKey; + UA_ByteString remoteSymEncryptingKey; + UA_ByteString remoteSymIv; + + mbedtls_x509_crt remoteCertificate; +} Aes128Sha256PsaOaep_ChannelContext; + +/********************/ +/* AsymmetricModule */ +/********************/ + +/* VERIFY AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 */ +static UA_StatusCode +asym_verify_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned char hash[UA_SHA256_LENGTH]; +#if MBEDTLS_VERSION_NUMBER >= 0x02070000 + // TODO check return status + mbedtls_sha256_ret(message->data, message->length, hash, 0); +#else + mbedtls_sha256(message->data, message->length, hash, 0); +#endif + + /* Set the RSA settings */ + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_SHA256); + + /* For RSA keys, the default padding type is PKCS#1 v1.5 in mbedtls_pk_verify() */ + /* Alternatively, use more specific function mbedtls_rsa_rsassa_pkcs1_v15_verify(), i.e. */ + /* int mbedErr = mbedtls_rsa_rsassa_pkcs1_v15_verify(rsaContext, NULL, NULL, + MBEDTLS_RSA_PUBLIC, MBEDTLS_MD_SHA256, + UA_SHA256_LENGTH, hash, + signature->data); */ + int mbedErr = mbedtls_pk_verify(&cc->remoteCertificate.pk, + MBEDTLS_MD_SHA256, hash, UA_SHA256_LENGTH, + signature->data, signature->length); + + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + return UA_STATUSCODE_GOOD; +} + +/* AsymmetricSignatureAlgorithm_RSA-PKCS15-SHA2-256 */ +static UA_StatusCode +asym_sign_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *message, + UA_ByteString *signature) { + if(message == NULL || signature == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned char hash[UA_SHA256_LENGTH]; +#if MBEDTLS_VERSION_NUMBER >= 0x02070000 + // TODO check return status + mbedtls_sha256_ret(message->data, message->length, hash, 0); +#else + mbedtls_sha256(message->data, message->length, hash, 0); +#endif + + Aes128Sha256PsaOaep_PolicyContext *pc = cc->policyContext; + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(pc->localPrivateKey); + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, MBEDTLS_MD_SHA256); + + size_t sigLen = 0; + + /* For RSA keys, the default padding type is PKCS#1 v1.5 in mbedtls_pk_sign */ + /* Alternatively use more specific function mbedtls_rsa_rsassa_pkcs1_v15_sign() */ + int mbedErr = mbedtls_pk_sign(&pc->localPrivateKey, + MBEDTLS_MD_SHA256, hash, + UA_SHA256_LENGTH, signature->data, + &sigLen, mbedtls_ctr_drbg_random, + &pc->drbgContext); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + return UA_STATUSCODE_GOOD; +} + +static size_t +asym_getLocalSignatureSize_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc) { + return mbedtls_pk_rsa(cc->policyContext->localPrivateKey)->len; +} + +static size_t +asym_getRemoteSignatureSize_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc) { + return mbedtls_pk_rsa(cc->remoteCertificate.pk)->len; +} + +static size_t +asym_getRemoteBlockSize_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc) { + return mbedtls_pk_rsa(cc->remoteCertificate.pk)->len; +} + +static size_t +asym_getRemotePlainTextBlockSize_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc) { + mbedtls_rsa_context *const rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + return rsaContext->len - UA_SECURITYPOLICY_AES128SHA256RSAOAEP_RSAPADDING_LEN; +} + + +/* AsymmetricEncryptionAlgorithm_RSA-OAEP-SHA1 */ +static UA_StatusCode +asym_encrypt_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + const size_t plainTextBlockSize = asym_getRemotePlainTextBlockSize_sp_aes128sha256rsaoaep(cc); + + mbedtls_rsa_context *remoteRsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + mbedtls_rsa_set_padding(remoteRsaContext, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + + return mbedtls_encrypt_rsaOaep(remoteRsaContext, &cc->policyContext->drbgContext, + data, plainTextBlockSize); +} + +/* AsymmetricEncryptionAlgorithm_RSA-OAEP-SHA1 */ +static UA_StatusCode +asym_decrypt_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + return mbedtls_decrypt_rsaOaep(&cc->policyContext->localPrivateKey, + &cc->policyContext->drbgContext, data); +} + +static size_t +asym_getLocalEncryptionKeyLength_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->policyContext->localPrivateKey) * 8; +} + +static size_t +asym_getRemoteEncryptionKeyLength_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc) { + return mbedtls_pk_get_len(&cc->remoteCertificate.pk) * 8; +} + +static UA_StatusCode +asym_makeThumbprint_sp_aes128sha256rsaoaep(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificate, + UA_ByteString *thumbprint) { + if(securityPolicy == NULL || certificate == NULL || thumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + return mbedtls_thumbprint_sha1(certificate, thumbprint); +} + +static UA_StatusCode +asymmetricModule_compareCertificateThumbprint_sp_aes128sha256rsaoaep(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificateThumbprint) { + if(securityPolicy == NULL || certificateThumbprint == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Aes128Sha256PsaOaep_PolicyContext *pc = (Aes128Sha256PsaOaep_PolicyContext *)securityPolicy->policyContext; + if(!UA_ByteString_equal(certificateThumbprint, &pc->localCertThumbprint)) + return UA_STATUSCODE_BADCERTIFICATEINVALID; + + return UA_STATUSCODE_GOOD; +} + +/*******************/ +/* SymmetricModule */ +/*******************/ + +static UA_StatusCode +sym_verify_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *message, + const UA_ByteString *signature) { + if(cc == NULL || message == NULL || signature == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Compute MAC */ + if(signature->length != UA_SHA256_LENGTH) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + Aes128Sha256PsaOaep_PolicyContext *pc = cc->policyContext; + unsigned char mac[UA_SHA256_LENGTH]; + mbedtls_hmac(&pc->sha256MdContext, &cc->remoteSymSigningKey, message, mac); + + /* Compare with Signature */ + if(!UA_constantTimeEqual(signature->data, mac, UA_SHA256_LENGTH)) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +sym_sign_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *message, + UA_ByteString *signature) { + if(signature->length != UA_SHA256_LENGTH) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_hmac(&cc->policyContext->sha256MdContext, &cc->localSymSigningKey, + message, signature->data); + return UA_STATUSCODE_GOOD; +} + +static size_t +sym_getSignatureSize_sp_aes128sha256rsaoaep(const void *channelContext) { + return UA_SHA256_LENGTH; +} + +static size_t +sym_getSigningKeyLength_sp_aes128sha256rsaoaep(const void *channelContext) { + return UA_AES128SHA256RSAOAEP_SYM_SIGNING_KEY_LENGTH; +} + +static size_t +sym_getEncryptionKeyLength_sp_aes128sha256rsaoaep(const void *channelContext) { + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_KEY_LENGTH; +} + +static size_t +sym_getEncryptionBlockSize_sp_aes128sha256rsaoaep(const void *channelContext) { + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_BLOCK_SIZE; +} + +static size_t +sym_getPlainTextBlockSize_sp_aes128sha256rsaoaep(const void *channelContext) { + return UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_PLAIN_TEXT_BLOCK_SIZE; +} + +static UA_StatusCode +sym_encrypt_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(cc->localSymIv.length != UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_BLOCK_SIZE) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t plainTextBlockSize = UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_PLAIN_TEXT_BLOCK_SIZE; + + if(data->length % plainTextBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Keylength in bits */ + unsigned int keylength = (unsigned int)(cc->localSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_enc(&aesContext, cc->localSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->localSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_ENCRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_decrypt_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc, + UA_ByteString *data) { + if(cc == NULL || data == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t encryptionBlockSize = UA_SECURITYPOLICY_AES128SHA256RSAOAEP_SYM_ENCRYPTION_BLOCK_SIZE; + + if(cc->remoteSymIv.length != encryptionBlockSize) + return UA_STATUSCODE_BADINTERNALERROR; + + if(data->length % encryptionBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + unsigned int keylength = (unsigned int)(cc->remoteSymEncryptingKey.length * 8); + mbedtls_aes_context aesContext; + int mbedErr = mbedtls_aes_setkey_dec(&aesContext, cc->remoteSymEncryptingKey.data, keylength); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString ivCopy; + UA_StatusCode retval = UA_ByteString_copy(&cc->remoteSymIv, &ivCopy); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + mbedErr = mbedtls_aes_crypt_cbc(&aesContext, MBEDTLS_AES_DECRYPT, data->length, + ivCopy.data, data->data, data->data); + if(mbedErr) + retval = UA_STATUSCODE_BADINTERNALERROR; + UA_ByteString_clear(&ivCopy); + return retval; +} + +static UA_StatusCode +sym_generateKey_sp_aes128sha256rsaoaep(void *policyContext, const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) { + if(secret == NULL || seed == NULL || out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Aes128Sha256PsaOaep_PolicyContext *pc = (Aes128Sha256PsaOaep_PolicyContext *)policyContext; + return mbedtls_generateKey(&pc->sha256MdContext, secret, seed, out); +} + +static UA_StatusCode +sym_generateNonce_sp_aes128sha256rsaoaep(void *policyContext, UA_ByteString *out) { + if(out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + Aes128Sha256PsaOaep_PolicyContext *pc = + (Aes128Sha256PsaOaep_PolicyContext *)policyContext; + int mbedErr = mbedtls_ctr_drbg_random(&pc->drbgContext, out->data, out->length); + if(mbedErr) + return UA_STATUSCODE_BADUNEXPECTEDERROR; + return UA_STATUSCODE_GOOD; +} + +/*****************/ +/* ChannelModule */ +/*****************/ + +/* Assumes that the certificate has been verified externally */ +static UA_StatusCode +parseRemoteCertificate_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *remoteCertificate) { + if(remoteCertificate == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Parse the certificate */ + int mbedErr = mbedtls_x509_crt_parse(&cc->remoteCertificate, remoteCertificate->data, + remoteCertificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + /* Check the key length */ + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(cc->remoteCertificate.pk); + if(rsaContext->len < UA_SECURITYPOLICY_AES128SHA256RSAOAEP_MINASYMKEYLENGTH || + rsaContext->len > UA_SECURITYPOLICY_AES128SHA256RSAOAEP_MAXASYMKEYLENGTH) + return UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED; + + return UA_STATUSCODE_GOOD; +} + +static void +channelContext_deleteContext_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc) { + UA_ByteString_clear(&cc->localSymSigningKey); + UA_ByteString_clear(&cc->localSymEncryptingKey); + UA_ByteString_clear(&cc->localSymIv); + + UA_ByteString_clear(&cc->remoteSymSigningKey); + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + UA_ByteString_clear(&cc->remoteSymIv); + + mbedtls_x509_crt_free(&cc->remoteCertificate); + + UA_free(cc); +} + +static UA_StatusCode +channelContext_newContext_sp_aes128sha256rsaoaep(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate, + void **pp_contextData) { + if(securityPolicy == NULL || remoteCertificate == NULL || pp_contextData == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Allocate the channel context */ + *pp_contextData = UA_malloc(sizeof(Aes128Sha256PsaOaep_ChannelContext)); + if(*pp_contextData == NULL) + return UA_STATUSCODE_BADOUTOFMEMORY; + + Aes128Sha256PsaOaep_ChannelContext *cc = (Aes128Sha256PsaOaep_ChannelContext *)*pp_contextData; + + /* Initialize the channel context */ + cc->policyContext = (Aes128Sha256PsaOaep_PolicyContext *)securityPolicy->policyContext; + + UA_ByteString_init(&cc->localSymSigningKey); + UA_ByteString_init(&cc->localSymEncryptingKey); + UA_ByteString_init(&cc->localSymIv); + + UA_ByteString_init(&cc->remoteSymSigningKey); + UA_ByteString_init(&cc->remoteSymEncryptingKey); + UA_ByteString_init(&cc->remoteSymIv); + + mbedtls_x509_crt_init(&cc->remoteCertificate); + + // TODO: this can be optimized so that we dont allocate memory before parsing the certificate + UA_StatusCode retval = parseRemoteCertificate_sp_aes128sha256rsaoaep(cc, remoteCertificate); + if(retval != UA_STATUSCODE_GOOD) { + channelContext_deleteContext_sp_aes128sha256rsaoaep(cc); + *pp_contextData = NULL; + } + return retval; +} + +static UA_StatusCode +channelContext_setLocalSymEncryptingKey_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymEncryptingKey); + return UA_ByteString_copy(key, &cc->localSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setLocalSymSigningKey_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymSigningKey); + return UA_ByteString_copy(key, &cc->localSymSigningKey); +} + + +static UA_StatusCode +channelContext_setLocalSymIv_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->localSymIv); + return UA_ByteString_copy(iv, &cc->localSymIv); +} + +static UA_StatusCode +channelContext_setRemoteSymEncryptingKey_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymEncryptingKey); + return UA_ByteString_copy(key, &cc->remoteSymEncryptingKey); +} + +static UA_StatusCode +channelContext_setRemoteSymSigningKey_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *key) { + if(key == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymSigningKey); + return UA_ByteString_copy(key, &cc->remoteSymSigningKey); +} + +static UA_StatusCode +channelContext_setRemoteSymIv_sp_aes128sha256rsaoaep(Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *iv) { + if(iv == NULL || cc == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + UA_ByteString_clear(&cc->remoteSymIv); + return UA_ByteString_copy(iv, &cc->remoteSymIv); +} + +static UA_StatusCode +channelContext_compareCertificate_sp_aes128sha256rsaoaep(const Aes128Sha256PsaOaep_ChannelContext *cc, + const UA_ByteString *certificate) { + if(cc == NULL || certificate == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + mbedtls_x509_crt cert; + mbedtls_x509_crt_init(&cert); + int mbedErr = mbedtls_x509_crt_parse(&cert, certificate->data, certificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(cert.raw.len != cc->remoteCertificate.raw.len || + memcmp(cert.raw.p, cc->remoteCertificate.raw.p, cert.raw.len) != 0) + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + mbedtls_x509_crt_free(&cert); + return retval; +} + +static void +clear_sp_aes128sha256rsaoaep(UA_SecurityPolicy *securityPolicy) { + if(securityPolicy == NULL) + return; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + if(securityPolicy->policyContext == NULL) + return; + + /* delete all allocated members in the context */ + Aes128Sha256PsaOaep_PolicyContext *pc = (Aes128Sha256PsaOaep_PolicyContext *) + securityPolicy->policyContext; + + mbedtls_ctr_drbg_free(&pc->drbgContext); + mbedtls_entropy_free(&pc->entropyContext); + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_md_free(&pc->sha256MdContext); + UA_ByteString_clear(&pc->localCertThumbprint); + + UA_LOG_DEBUG(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Deleted members of EndpointContext for sp_aes128sha256rsaoaep"); + + UA_free(pc); + securityPolicy->policyContext = NULL; +} + +static UA_StatusCode +updateCertificateAndPrivateKey_sp_aes128sha256rsaoaep(UA_SecurityPolicy *securityPolicy, + const UA_ByteString newCertificate, + const UA_ByteString newPrivateKey) { + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(securityPolicy->policyContext == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + Aes128Sha256PsaOaep_PolicyContext *pc = + (Aes128Sha256PsaOaep_PolicyContext *) securityPolicy->policyContext; + + UA_ByteString_clear(&securityPolicy->localCertificate); + + UA_StatusCode retval = UA_ByteString_allocBuffer(&securityPolicy->localCertificate, + newCertificate.length + 1); + if(retval != UA_STATUSCODE_GOOD) + return retval; + memcpy(securityPolicy->localCertificate.data, newCertificate.data, newCertificate.length); + securityPolicy->localCertificate.data[newCertificate.length] = '\0'; + securityPolicy->localCertificate.length--; + + /* Set the new private key */ + mbedtls_pk_free(&pc->localPrivateKey); + mbedtls_pk_init(&pc->localPrivateKey); + int mbedErr = mbedtls_pk_parse_key(&pc->localPrivateKey, newPrivateKey.data, + newPrivateKey.length, NULL, 0); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + retval = asym_makeThumbprint_sp_aes128sha256rsaoaep(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return retval; + + error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not update certificate and private key"); + if(securityPolicy->policyContext != NULL) + clear_sp_aes128sha256rsaoaep(securityPolicy); + return retval; +} + +static UA_StatusCode +policyContext_newContext_sp_aes128sha256rsaoaep(UA_SecurityPolicy *securityPolicy, + const UA_ByteString localPrivateKey) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(securityPolicy == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if (localPrivateKey.length == 0) { + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Can not initialize security policy. Private key is empty."); + return UA_STATUSCODE_BADINVALIDARGUMENT; + } + + Aes128Sha256PsaOaep_PolicyContext *pc = (Aes128Sha256PsaOaep_PolicyContext *) + UA_malloc(sizeof(Aes128Sha256PsaOaep_PolicyContext)); + securityPolicy->policyContext = (void *)pc; + if(!pc) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Initialize the PolicyContext */ + memset(pc, 0, sizeof(Aes128Sha256PsaOaep_PolicyContext)); + mbedtls_ctr_drbg_init(&pc->drbgContext); + mbedtls_entropy_init(&pc->entropyContext); + mbedtls_pk_init(&pc->localPrivateKey); + mbedtls_md_init(&pc->sha256MdContext); + + /* Initialized the message digest */ + const mbedtls_md_info_t *const mdInfo = mbedtls_md_info_from_type(MBEDTLS_MD_SHA256); + int mbedErr = mbedtls_md_setup(&pc->sha256MdContext, mdInfo, MBEDTLS_MD_SHA256); + if(mbedErr) { + retval = UA_STATUSCODE_BADOUTOFMEMORY; + goto error; + } + + /* Add the system entropy source */ + mbedErr = mbedtls_entropy_add_source(&pc->entropyContext, + MBEDTLS_ENTROPY_POLL_METHOD, NULL, 0, + MBEDTLS_ENTROPY_SOURCE_STRONG); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Seed the RNG */ + char *personalization = "open62541-drbg"; + mbedErr = mbedtls_ctr_drbg_seed(&pc->drbgContext, mbedtls_entropy_func, + &pc->entropyContext, + (const unsigned char *)personalization, 14); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the private key */ + mbedErr = UA_mbedTLS_LoadPrivateKey(&localPrivateKey, &pc->localPrivateKey); + if(mbedErr) { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + goto error; + } + + /* Set the local certificate thumbprint */ + retval = UA_ByteString_allocBuffer(&pc->localCertThumbprint, UA_SHA1_LENGTH); + if(retval != UA_STATUSCODE_GOOD) + goto error; + retval = asym_makeThumbprint_sp_aes128sha256rsaoaep(securityPolicy, + &securityPolicy->localCertificate, + &pc->localCertThumbprint); + if(retval != UA_STATUSCODE_GOOD) + goto error; + + return UA_STATUSCODE_GOOD; + +error: + UA_LOG_ERROR(securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, + "Could not create securityContext: %s", UA_StatusCode_name(retval)); + if(securityPolicy->policyContext != NULL) + clear_sp_aes128sha256rsaoaep(securityPolicy); + return retval; +} + +UA_StatusCode +UA_SecurityPolicy_Aes128Sha256RsaOaep(UA_SecurityPolicy *policy, const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, const UA_Logger *logger) { + memset(policy, 0, sizeof(UA_SecurityPolicy)); + policy->logger = logger; + + policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#Aes128_Sha256_RsaOaep"); + + UA_SecurityPolicyAsymmetricModule *const asymmetricModule = &policy->asymmetricModule; + UA_SecurityPolicySymmetricModule *const symmetricModule = &policy->symmetricModule; + UA_SecurityPolicyChannelModule *const channelModule = &policy->channelModule; + + UA_StatusCode retval = UA_mbedTLS_LoadLocalCertificate(&localCertificate, &policy->localCertificate); + + if (retval != UA_STATUSCODE_GOOD) + return retval; + + /* AsymmetricModule */ + UA_SecurityPolicySignatureAlgorithm *asym_signatureAlgorithm = + &asymmetricModule->cryptoModule.signatureAlgorithm; + asym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2001/04/xmldsig-more#rsa-sha256\0"); + asym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, const UA_ByteString *))asym_verify_sp_aes128sha256rsaoaep; + asym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))asym_sign_sp_aes128sha256rsaoaep; + asym_signatureAlgorithm->getLocalSignatureSize = + (size_t (*)(const void *))asym_getLocalSignatureSize_sp_aes128sha256rsaoaep; + asym_signatureAlgorithm->getRemoteSignatureSize = + (size_t (*)(const void *))asym_getRemoteSignatureSize_sp_aes128sha256rsaoaep; + asym_signatureAlgorithm->getLocalKeyLength = NULL; // TODO: Write function + asym_signatureAlgorithm->getRemoteKeyLength = NULL; // TODO: Write function + + UA_SecurityPolicyEncryptionAlgorithm *asym_encryptionAlgorithm = + &asymmetricModule->cryptoModule.encryptionAlgorithm; + asym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#rsa-oaep\0"); + asym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))asym_encrypt_sp_aes128sha256rsaoaep; + asym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *)) asym_decrypt_sp_aes128sha256rsaoaep; + asym_encryptionAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))asym_getLocalEncryptionKeyLength_sp_aes128sha256rsaoaep; + asym_encryptionAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))asym_getRemoteEncryptionKeyLength_sp_aes128sha256rsaoaep; + asym_encryptionAlgorithm->getRemoteBlockSize = (size_t (*)(const void *))asym_getRemoteBlockSize_sp_aes128sha256rsaoaep; + asym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))asym_getRemotePlainTextBlockSize_sp_aes128sha256rsaoaep; + + asymmetricModule->makeCertificateThumbprint = asym_makeThumbprint_sp_aes128sha256rsaoaep; + asymmetricModule->compareCertificateThumbprint = + asymmetricModule_compareCertificateThumbprint_sp_aes128sha256rsaoaep; + + /* SymmetricModule */ + symmetricModule->generateKey = sym_generateKey_sp_aes128sha256rsaoaep; + symmetricModule->generateNonce = sym_generateNonce_sp_aes128sha256rsaoaep; + + UA_SecurityPolicySignatureAlgorithm *sym_signatureAlgorithm = + &symmetricModule->cryptoModule.signatureAlgorithm; + sym_signatureAlgorithm->uri = + UA_STRING("http://www.w3.org/2000/09/xmldsig#hmac-sha1\0"); + sym_signatureAlgorithm->verify = + (UA_StatusCode (*)(void *, const UA_ByteString *, const UA_ByteString *))sym_verify_sp_aes128sha256rsaoaep; + sym_signatureAlgorithm->sign = + (UA_StatusCode (*)(void *, const UA_ByteString *, UA_ByteString *))sym_sign_sp_aes128sha256rsaoaep; + sym_signatureAlgorithm->getLocalSignatureSize = sym_getSignatureSize_sp_aes128sha256rsaoaep; + sym_signatureAlgorithm->getRemoteSignatureSize = sym_getSignatureSize_sp_aes128sha256rsaoaep; + sym_signatureAlgorithm->getLocalKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_aes128sha256rsaoaep; + sym_signatureAlgorithm->getRemoteKeyLength = + (size_t (*)(const void *))sym_getSigningKeyLength_sp_aes128sha256rsaoaep; + + UA_SecurityPolicyEncryptionAlgorithm *sym_encryptionAlgorithm = + &symmetricModule->cryptoModule.encryptionAlgorithm; + sym_encryptionAlgorithm->uri = UA_STRING("http://www.w3.org/2001/04/xmlenc#aes128-cbc"); + sym_encryptionAlgorithm->encrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_encrypt_sp_aes128sha256rsaoaep; + sym_encryptionAlgorithm->decrypt = + (UA_StatusCode(*)(void *, UA_ByteString *))sym_decrypt_sp_aes128sha256rsaoaep; + sym_encryptionAlgorithm->getLocalKeyLength = sym_getEncryptionKeyLength_sp_aes128sha256rsaoaep; + sym_encryptionAlgorithm->getRemoteKeyLength = sym_getEncryptionKeyLength_sp_aes128sha256rsaoaep; + sym_encryptionAlgorithm->getRemoteBlockSize = + (size_t (*)(const void *))sym_getEncryptionBlockSize_sp_aes128sha256rsaoaep; + sym_encryptionAlgorithm->getRemotePlainTextBlockSize = + (size_t (*)(const void *))sym_getPlainTextBlockSize_sp_aes128sha256rsaoaep; + symmetricModule->secureChannelNonceLength = 32; + + // Use the same signature algorithm as the asymmetric component for certificate signing (see standard) + policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + /* ChannelModule */ + channelModule->newContext = channelContext_newContext_sp_aes128sha256rsaoaep; + channelModule->deleteContext = (void (*)(void *)) + channelContext_deleteContext_sp_aes128sha256rsaoaep; + + channelModule->setLocalSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymEncryptingKey_sp_aes128sha256rsaoaep; + channelModule->setLocalSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymSigningKey_sp_aes128sha256rsaoaep; + channelModule->setLocalSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setLocalSymIv_sp_aes128sha256rsaoaep; + + channelModule->setRemoteSymEncryptingKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymEncryptingKey_sp_aes128sha256rsaoaep; + channelModule->setRemoteSymSigningKey = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymSigningKey_sp_aes128sha256rsaoaep; + channelModule->setRemoteSymIv = (UA_StatusCode (*)(void *, const UA_ByteString *)) + channelContext_setRemoteSymIv_sp_aes128sha256rsaoaep; + + channelModule->compareCertificate = (UA_StatusCode (*)(const void *, const UA_ByteString *)) + channelContext_compareCertificate_sp_aes128sha256rsaoaep; + + policy->updateCertificateAndPrivateKey = updateCertificateAndPrivateKey_sp_aes128sha256rsaoaep; + policy->clear = clear_sp_aes128sha256rsaoaep; + + UA_StatusCode res = policyContext_newContext_sp_aes128sha256rsaoaep(policy, localPrivateKey); + if(res != UA_STATUSCODE_GOOD) + clear_sp_aes128sha256rsaoaep(policy); + + return res; +} + +#endif + +/**** amalgamated original file "/plugins/crypto/mbedtls/ua_pki_mbedtls.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2019 (c) Julius Pfrommer, Fraunhofer IOSB + */ + + +#ifdef UA_ENABLE_ENCRYPTION_MBEDTLS + +#include +#include +#include + +#define REMOTECERTIFICATETRUSTED 1 +#define ISSUERKNOWN 2 +#define DUALPARENT 3 +#define PARENTFOUND 4 + +/* Find binary substring. Taken and adjusted from + * http://tungchingkai.blogspot.com/2011/07/binary-strstr.html */ + +static const unsigned char * +bstrchr(const unsigned char *s, const unsigned char ch, size_t l) { + /* find first occurrence of c in char s[] for length l*/ + for(; l > 0; ++s, --l) { + if(*s == ch) + return s; + } + return NULL; +} + +static const unsigned char * +UA_Bstrstr(const unsigned char *s1, size_t l1, const unsigned char *s2, size_t l2) { + /* find first occurrence of s2[] in s1[] for length l1*/ + const unsigned char *ss1 = s1; + const unsigned char *ss2 = s2; + /* handle special case */ + if(l1 == 0) + return (NULL); + if(l2 == 0) + return s1; + + /* match prefix */ + for (; (s1 = bstrchr(s1, *s2, (uintptr_t)ss1-(uintptr_t)s1+(uintptr_t)l1)) != NULL && + (uintptr_t)ss1-(uintptr_t)s1+(uintptr_t)l1 != 0; ++s1) { + + /* match rest of prefix */ + const unsigned char *sc1, *sc2; + for (sc1 = s1, sc2 = s2; ;) + if (++sc2 >= ss2+l2) + return s1; + else if (*++sc1 != *sc2) + break; + } + return NULL; +} + +// mbedTLS expects PEM data to be null terminated +// The data length parameter must include the null terminator +static UA_ByteString copyDataFormatAware(const UA_ByteString *data) +{ + UA_ByteString result; + UA_ByteString_init(&result); + + if (!data->length) + return result; + + if (data->length && data->data[0] == '-') { + UA_ByteString_allocBuffer(&result, data->length + 1); + memcpy(result.data, data->data, data->length); + result.data[data->length] = '\0'; + } else { + UA_ByteString_copy(data, &result); + } + + return result; +} + +typedef struct { + /* If the folders are defined, we use them to reload the certificates during + * runtime */ + UA_String trustListFolder; + UA_String issuerListFolder; + UA_String revocationListFolder; + + mbedtls_x509_crt certificateTrustList; + mbedtls_x509_crt certificateIssuerList; + mbedtls_x509_crl certificateRevocationList; +} CertInfo; + +#ifdef __linux__ /* Linux only so far */ + +#include +#include + +static UA_StatusCode +fileNamesFromFolder(const UA_String *folder, size_t *pathsSize, UA_String **paths) { + char buf[PATH_MAX + 1]; + if(folder->length > PATH_MAX) + return UA_STATUSCODE_BADINTERNALERROR; + + memcpy(buf, folder->data, folder->length); + buf[folder->length] = 0; + + DIR *dir = opendir(buf); + if(!dir) + return UA_STATUSCODE_BADINTERNALERROR; + + *paths = (UA_String*)UA_Array_new(256, &UA_TYPES[UA_TYPES_STRING]); + if(*paths == NULL) { + closedir(dir); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + struct dirent *ent; + char buf2[PATH_MAX + 1]; + char *res = realpath(buf, buf2); + if(!res) { + closedir(dir); + return UA_STATUSCODE_BADINTERNALERROR; + } + size_t pathlen = strlen(buf2); + *pathsSize = 0; + while((ent = readdir (dir)) != NULL && *pathsSize < 256) { + if(ent->d_type != DT_REG) + continue; + buf2[pathlen] = '/'; + buf2[pathlen+1] = 0; + strcat(buf2, ent->d_name); + (*paths)[*pathsSize] = UA_STRING_ALLOC(buf2); + *pathsSize += 1; + } + closedir(dir); + + if(*pathsSize == 0) { + UA_free(*paths); + *paths = NULL; + } + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +reloadCertificates(CertInfo *ci) { + UA_StatusCode retval = UA_STATUSCODE_GOOD; + int err = 0; + int internalErrorFlag = 0; + + /* Load the trustlists */ + if(ci->trustListFolder.length > 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Reloading the trust-list"); + mbedtls_x509_crt_free(&ci->certificateTrustList); + mbedtls_x509_crt_init(&ci->certificateTrustList); + + char f[PATH_MAX]; + memcpy(f, ci->trustListFolder.data, ci->trustListFolder.length); + f[ci->trustListFolder.length] = 0; + err = mbedtls_x509_crt_parse_path(&ci->certificateTrustList, f); + if(err == 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Loaded certificate from %s", f); + } else { + char errBuff[300]; + mbedtls_strerror(err, errBuff, 300); + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to load certificate from %s, mbedTLS error: %s (error code: %d)", f, errBuff, err); + internalErrorFlag = 1; + } + } + + /* Load the revocationlists */ + if(ci->revocationListFolder.length > 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Reloading the revocation-list"); + size_t pathsSize = 0; + UA_String *paths = NULL; + retval = fileNamesFromFolder(&ci->revocationListFolder, &pathsSize, &paths); + if(retval != UA_STATUSCODE_GOOD) + return retval; + mbedtls_x509_crl_free(&ci->certificateRevocationList); + mbedtls_x509_crl_init(&ci->certificateRevocationList); + for(size_t i = 0; i < pathsSize; i++) { + char f[PATH_MAX]; + memcpy(f, paths[i].data, paths[i].length); + f[paths[i].length] = 0; + err = mbedtls_x509_crl_parse_file(&ci->certificateRevocationList, f); + if(err == 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Loaded certificate from %.*s", + (int)paths[i].length, paths[i].data); + } else { + char errBuff[300]; + mbedtls_strerror(err, errBuff, 300); + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to load certificate from %.*s, mbedTLS error: %s (error code: %d)", + (int)paths[i].length, paths[i].data, errBuff, err); + internalErrorFlag = 1; + } + } + UA_Array_delete(paths, pathsSize, &UA_TYPES[UA_TYPES_STRING]); + paths = NULL; + pathsSize = 0; + } + + /* Load the issuerlists */ + if(ci->issuerListFolder.length > 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "Reloading the issuer-list"); + mbedtls_x509_crt_free(&ci->certificateIssuerList); + mbedtls_x509_crt_init(&ci->certificateIssuerList); + char f[PATH_MAX]; + memcpy(f, ci->issuerListFolder.data, ci->issuerListFolder.length); + f[ci->issuerListFolder.length] = 0; + err = mbedtls_x509_crt_parse_path(&ci->certificateIssuerList, f); + if(err == 0) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Loaded certificate from %s", f); + } else { + char errBuff[300]; + mbedtls_strerror(err, errBuff, 300); + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "Failed to load certificate from %s, mbedTLS error: %s (error code: %d)", + f, errBuff, err); + internalErrorFlag = 1; + } + } + + if(internalErrorFlag) { + retval = UA_STATUSCODE_BADINTERNALERROR; + } + return retval; +} + +#endif + +static UA_StatusCode +certificateVerification_allow(void *verificationContext, + const UA_ByteString *certificate) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +certificateVerification_verify(void *verificationContext, + const UA_ByteString *certificate) { + CertInfo *ci = (CertInfo*)verificationContext; + if(!ci) + return UA_STATUSCODE_BADINTERNALERROR; + +#ifdef __linux__ /* Reload certificates if folder paths are specified */ + UA_StatusCode certFlag = reloadCertificates(ci); + if(certFlag != UA_STATUSCODE_GOOD) { + return certFlag; + } +#endif + + if(ci->trustListFolder.length == 0 && + ci->issuerListFolder.length == 0 && + ci->revocationListFolder.length == 0 && + ci->certificateTrustList.raw.len == 0 && + ci->certificateIssuerList.raw.len == 0 && + ci->certificateRevocationList.raw.len == 0) { + UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, + "PKI plugin unconfigured. Accepting the certificate."); + return UA_STATUSCODE_GOOD; + } + + /* Parse the certificate */ + mbedtls_x509_crt remoteCertificate; + + /* Temporary Object to parse the trustList */ + mbedtls_x509_crt *tempCert = NULL; + + /* Temporary Object to parse the revocationList */ + mbedtls_x509_crl *tempCrl = NULL; + + /* Temporary Object to identify the parent CA when there is no intermediate CA */ + mbedtls_x509_crt *parentCert = NULL; + + /* Temporary Object to identify the parent CA when there is intermediate CA */ + mbedtls_x509_crt *parentCert_2 = NULL; + + /* Flag value to identify if the issuer certificate is found */ + int issuerKnown = 0; + + /* Flag value to identify if the parent certificate found */ + int parentFound = 0; + + mbedtls_x509_crt_init(&remoteCertificate); + int mbedErr = mbedtls_x509_crt_parse(&remoteCertificate, certificate->data, + certificate->length); + if(mbedErr) { + /* char errBuff[300]; */ + /* mbedtls_strerror(mbedErr, errBuff, 300); */ + /* UA_LOG_WARNING(data->policyContext->securityPolicy->logger, UA_LOGCATEGORY_SECURITYPOLICY, */ + /* "Could not parse the remote certificate with error: %s", errBuff); */ + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + + /* Verify */ + mbedtls_x509_crt_profile crtProfile = { + MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA1) | MBEDTLS_X509_ID_FLAG(MBEDTLS_MD_SHA256), + 0xFFFFFF, 0x000000, 128 * 8 // in bits + }; // TODO: remove magic numbers + + uint32_t flags = 0; + mbedErr = mbedtls_x509_crt_verify_with_profile(&remoteCertificate, + &ci->certificateTrustList, + &ci->certificateRevocationList, + &crtProfile, NULL, &flags, NULL, NULL); + + /* Flag to check if the remote certificate is trusted or not */ + int TRUSTED = 0; + + /* Check if the remoteCertificate is present in the trustList while mbedErr value is not zero */ + if(mbedErr && !(flags & MBEDTLS_X509_BADCERT_EXPIRED) && !(flags & MBEDTLS_X509_BADCERT_FUTURE)) { + for(tempCert = &ci->certificateTrustList; tempCert != NULL; tempCert = tempCert->next) { + if(remoteCertificate.raw.len == tempCert->raw.len && + memcmp(remoteCertificate.raw.p, tempCert->raw.p, remoteCertificate.raw.len) == 0) { + TRUSTED = REMOTECERTIFICATETRUSTED; + break; + } + } + } + + /* If the remote certificate is present in the trustList then check if the issuer certificate + * of remoteCertificate is present in issuerList */ + if(TRUSTED && mbedErr) { + mbedErr = mbedtls_x509_crt_verify_with_profile(&remoteCertificate, + &ci->certificateIssuerList, + &ci->certificateRevocationList, + &crtProfile, NULL, &flags, NULL, NULL); + + /* Check if the parent certificate has a CRL file available */ + if(!mbedErr) { + /* Flag value to identify if that there is an intermediate CA present */ + int dualParent = 0; + + /* Identify the topmost parent certificate for the remoteCertificate */ + for(parentCert = &ci->certificateIssuerList; parentCert != NULL; parentCert = parentCert->next ) { + if(memcmp(remoteCertificate.issuer_raw.p, parentCert->subject_raw.p, parentCert->subject_raw.len) == 0) { + for(parentCert_2 = &ci->certificateTrustList; parentCert_2 != NULL; parentCert_2 = parentCert_2->next) { + if(memcmp(parentCert->issuer_raw.p, parentCert_2->subject_raw.p, parentCert_2->subject_raw.len) == 0) { + dualParent = DUALPARENT; + break; + } + } + parentFound = PARENTFOUND; + } + + if(parentFound == PARENTFOUND) + break; + } + + /* Check if there is an intermediate certificate between the topmost parent + * certificate and child certificate + * If yes the topmost parent certificate is to be checked whether it has a + * CRL file avaiable */ + if(dualParent == DUALPARENT && parentFound == PARENTFOUND) { + parentCert = parentCert_2; + } + + /* If a parent certificate is found traverse the revocationList and identify + * if there is any CRL file that corresponds to the parentCertificate */ + if(parentFound == PARENTFOUND) { + tempCrl = &ci->certificateRevocationList; + while(tempCrl != NULL) { + if(tempCrl->version != 0 && + tempCrl->issuer_raw.len == parentCert->subject_raw.len && + memcmp(tempCrl->issuer_raw.p, + parentCert->subject_raw.p, + tempCrl->issuer_raw.len) == 0) { + issuerKnown = ISSUERKNOWN; + break; + } + + tempCrl = tempCrl->next; + } + + /* If the CRL file corresponding to the parent certificate is not present + * then return UA_STATUSCODE_BADCERTIFICATEISSUERREVOCATIONUNKNOWN */ + if(!issuerKnown) { + return UA_STATUSCODE_BADCERTIFICATEISSUERREVOCATIONUNKNOWN; + } + + } + + } + + } + else if(!mbedErr && !TRUSTED) { + /* This else if section is to identify if the parent certificate which is present in trustList + * has CRL file corresponding to it */ + + /* Identify the parent certificate of the remoteCertificate */ + for(parentCert = &ci->certificateTrustList; parentCert != NULL; parentCert = parentCert->next) { + if(memcmp(remoteCertificate.issuer_raw.p, parentCert->subject_raw.p, parentCert->subject_raw.len) == 0) { + parentFound = PARENTFOUND; + break; + } + + } + + /* If the parent certificate is found traverse the revocationList and identify + * if there is any CRL file that corresponds to the parentCertificate */ + if(parentFound == PARENTFOUND && + memcmp(remoteCertificate.issuer_raw.p, remoteCertificate.subject_raw.p, remoteCertificate.subject_raw.len) != 0) { + tempCrl = &ci->certificateRevocationList; + while(tempCrl != NULL) { + if(tempCrl->version != 0 && + tempCrl->issuer_raw.len == parentCert->subject_raw.len && + memcmp(tempCrl->issuer_raw.p, + parentCert->subject_raw.p, + tempCrl->issuer_raw.len) == 0) { + issuerKnown = ISSUERKNOWN; + break; + } + + tempCrl = tempCrl->next; + } + + /* If the CRL file corresponding to the parent certificate is not present + * then return UA_STATUSCODE_BADCERTIFICATEREVOCATIONUNKNOWN */ + if(!issuerKnown) { + return UA_STATUSCODE_BADCERTIFICATEREVOCATIONUNKNOWN; + } + + } + + } + + // TODO: Extend verification + + /* This condition will check whether the certificate is a User certificate + * or a CA certificate. If the MBEDTLS_X509_KU_KEY_CERT_SIGN and + * MBEDTLS_X509_KU_CRL_SIGN of key_usage are set, then the certificate + * shall be condidered as CA Certificate and cannot be used to establish a + * connection. Refer the test case CTT/Security/Security Certificate Validation/029.js + * for more details */ + if((remoteCertificate.key_usage & MBEDTLS_X509_KU_KEY_CERT_SIGN) && + (remoteCertificate.key_usage & MBEDTLS_X509_KU_CRL_SIGN)) { + return UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED; + } + + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(mbedErr) { +#if UA_LOGLEVEL <= 400 + char buff[100]; + int len = mbedtls_x509_crt_verify_info(buff, 100, "", flags); + UA_LOG_WARNING(UA_Log_Stdout, UA_LOGCATEGORY_SECURITYPOLICY, + "Verifying the certificate failed with error: %.*s", len-1, buff); +#endif + if(flags & (uint32_t)MBEDTLS_X509_BADCERT_NOT_TRUSTED) { + retval = UA_STATUSCODE_BADCERTIFICATEUNTRUSTED; + } else if(flags & (uint32_t)MBEDTLS_X509_BADCERT_FUTURE || + flags & (uint32_t)MBEDTLS_X509_BADCERT_EXPIRED) { + retval = UA_STATUSCODE_BADCERTIFICATETIMEINVALID; + } else if(flags & (uint32_t)MBEDTLS_X509_BADCERT_REVOKED || + flags & (uint32_t)MBEDTLS_X509_BADCRL_EXPIRED) { + retval = UA_STATUSCODE_BADCERTIFICATEREVOKED; + } else { + retval = UA_STATUSCODE_BADSECURITYCHECKSFAILED; + } + } + + mbedtls_x509_crt_free(&remoteCertificate); + return retval; +} + +static UA_StatusCode +certificateVerification_verifyApplicationURI(void *verificationContext, + const UA_ByteString *certificate, + const UA_String *applicationURI) { + CertInfo *ci = (CertInfo*)verificationContext; + if(!ci) + return UA_STATUSCODE_BADINTERNALERROR; + + /* Parse the certificate */ + mbedtls_x509_crt remoteCertificate; + mbedtls_x509_crt_init(&remoteCertificate); + int mbedErr = mbedtls_x509_crt_parse(&remoteCertificate, certificate->data, + certificate->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + /* Poor man's ApplicationUri verification. mbedTLS does not parse all fields + * of the Alternative Subject Name. Instead test whether the URI-string is + * present in the v3_ext field in general. + * + * TODO: Improve parsing of the Alternative Subject Name */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(UA_Bstrstr(remoteCertificate.v3_ext.p, remoteCertificate.v3_ext.len, + applicationURI->data, applicationURI->length) == NULL) + retval = UA_STATUSCODE_BADCERTIFICATEURIINVALID; + + mbedtls_x509_crt_free(&remoteCertificate); + return retval; +} + +static void +certificateVerification_clear(UA_CertificateVerification *cv) { + CertInfo *ci = (CertInfo*)cv->context; + if(!ci) + return; + mbedtls_x509_crt_free(&ci->certificateTrustList); + mbedtls_x509_crl_free(&ci->certificateRevocationList); + mbedtls_x509_crt_free(&ci->certificateIssuerList); + UA_String_clear(&ci->trustListFolder); + UA_String_clear(&ci->issuerListFolder); + UA_String_clear(&ci->revocationListFolder); + UA_free(ci); + cv->context = NULL; +} + +UA_StatusCode +UA_CertificateVerification_Trustlist(UA_CertificateVerification *cv, + const UA_ByteString *certificateTrustList, + size_t certificateTrustListSize, + const UA_ByteString *certificateIssuerList, + size_t certificateIssuerListSize, + const UA_ByteString *certificateRevocationList, + size_t certificateRevocationListSize) { + CertInfo *ci = (CertInfo*)UA_malloc(sizeof(CertInfo)); + if(!ci) + return UA_STATUSCODE_BADOUTOFMEMORY; + memset(ci, 0, sizeof(CertInfo)); + mbedtls_x509_crt_init(&ci->certificateTrustList); + mbedtls_x509_crl_init(&ci->certificateRevocationList); + mbedtls_x509_crt_init(&ci->certificateIssuerList); + + cv->context = (void*)ci; + if(certificateTrustListSize > 0) + cv->verifyCertificate = certificateVerification_verify; + else + cv->verifyCertificate = certificateVerification_allow; + cv->clear = certificateVerification_clear; + cv->verifyApplicationURI = certificateVerification_verifyApplicationURI; + + int err; + UA_ByteString data; + UA_ByteString_init(&data); + + for(size_t i = 0; i < certificateTrustListSize; i++) { + data = copyDataFormatAware(&certificateTrustList[i]); + err = mbedtls_x509_crt_parse(&ci->certificateTrustList, + data.data, + data.length); + UA_ByteString_clear(&data); + if(err) + goto error; + } + for(size_t i = 0; i < certificateIssuerListSize; i++) { + data = copyDataFormatAware(&certificateIssuerList[i]); + err = mbedtls_x509_crt_parse(&ci->certificateIssuerList, + data.data, + data.length); + UA_ByteString_clear(&data); + if(err) + goto error; + } + for(size_t i = 0; i < certificateRevocationListSize; i++) { + data = copyDataFormatAware(&certificateRevocationList[i]); + err = mbedtls_x509_crl_parse(&ci->certificateRevocationList, + data.data, + data.length); + UA_ByteString_clear(&data); + if(err) + goto error; + } + + return UA_STATUSCODE_GOOD; +error: + certificateVerification_clear(cv); + return UA_STATUSCODE_BADINTERNALERROR; +} + +#ifdef __linux__ /* Linux only so far */ + +UA_StatusCode +UA_CertificateVerification_CertFolders(UA_CertificateVerification *cv, + const char *trustListFolder, + const char *issuerListFolder, + const char *revocationListFolder) { + CertInfo *ci = (CertInfo*)UA_malloc(sizeof(CertInfo)); + if(!ci) + return UA_STATUSCODE_BADOUTOFMEMORY; + memset(ci, 0, sizeof(CertInfo)); + mbedtls_x509_crt_init(&ci->certificateTrustList); + mbedtls_x509_crl_init(&ci->certificateRevocationList); + mbedtls_x509_crt_init(&ci->certificateIssuerList); + + /* Only set the folder paths. They will be reloaded during runtime. + * TODO: Add a more efficient reloading of only the changes */ + ci->trustListFolder = UA_STRING_ALLOC(trustListFolder); + ci->issuerListFolder = UA_STRING_ALLOC(issuerListFolder); + ci->revocationListFolder = UA_STRING_ALLOC(revocationListFolder); + + reloadCertificates(ci); + + cv->context = (void*)ci; + cv->verifyCertificate = certificateVerification_verify; + cv->clear = certificateVerification_clear; + cv->verifyApplicationURI = certificateVerification_verifyApplicationURI; + + return UA_STATUSCODE_GOOD; +} + +#endif +#endif + +/**** amalgamated original file "/plugins/crypto/mbedtls/securitypolicy_mbedtls_common.c" ****/ + + +#if defined(UA_ENABLE_ENCRYPTION_MBEDTLS) || defined(UA_ENABLE_PUBSUB_ENCRYPTION) + + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +void +swapBuffers(UA_ByteString *const bufA, UA_ByteString *const bufB) { + UA_ByteString tmp = *bufA; + *bufA = *bufB; + *bufB = tmp; +} + +void +mbedtls_hmac(mbedtls_md_context_t *context, const UA_ByteString *key, + const UA_ByteString *in, unsigned char *out) { + mbedtls_md_hmac_starts(context, key->data, key->length); + mbedtls_md_hmac_update(context, in->data, in->length); + mbedtls_md_hmac_finish(context, out); +} + +UA_StatusCode +mbedtls_generateKey(mbedtls_md_context_t *context, + const UA_ByteString *secret, const UA_ByteString *seed, + UA_ByteString *out) { + size_t hashLen = (size_t)mbedtls_md_get_size(context->md_info); + + UA_ByteString A_and_seed; + UA_ByteString_allocBuffer(&A_and_seed, hashLen + seed->length); + memcpy(A_and_seed.data + hashLen, seed->data, seed->length); + + UA_ByteString ANext_and_seed; + UA_ByteString_allocBuffer(&ANext_and_seed, hashLen + seed->length); + memcpy(ANext_and_seed.data + hashLen, seed->data, seed->length); + + UA_ByteString A = { + hashLen, + A_and_seed.data + }; + + UA_ByteString ANext = { + hashLen, + ANext_and_seed.data + }; + + mbedtls_hmac(context, secret, seed, A.data); + + UA_StatusCode retval = 0; + for(size_t offset = 0; offset < out->length; offset += hashLen) { + UA_ByteString outSegment = { + hashLen, + out->data + offset + }; + UA_Boolean bufferAllocated = UA_FALSE; + // Not enough room in out buffer to write the hash. + if(offset + hashLen > out->length) { + outSegment.data = NULL; + outSegment.length = 0; + retval = UA_ByteString_allocBuffer(&outSegment, hashLen); + if(retval != UA_STATUSCODE_GOOD) { + UA_ByteString_clear(&A_and_seed); + UA_ByteString_clear(&ANext_and_seed); + return retval; + } + bufferAllocated = UA_TRUE; + } + + mbedtls_hmac(context, secret, &A_and_seed, outSegment.data); + mbedtls_hmac(context, secret, &A, ANext.data); + + if(retval != UA_STATUSCODE_GOOD) { + if(bufferAllocated) + UA_ByteString_clear(&outSegment); + UA_ByteString_clear(&A_and_seed); + UA_ByteString_clear(&ANext_and_seed); + return retval; + } + + if(bufferAllocated) { + memcpy(out->data + offset, outSegment.data, out->length - offset); + UA_ByteString_clear(&outSegment); + } + + swapBuffers(&ANext_and_seed, &A_and_seed); + swapBuffers(&ANext, &A); + } + + UA_ByteString_clear(&A_and_seed); + UA_ByteString_clear(&ANext_and_seed); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +mbedtls_verifySig_sha1(mbedtls_x509_crt *certificate, const UA_ByteString *message, + const UA_ByteString *signature) { + /* Compute the sha1 hash */ + unsigned char hash[UA_SHA1_LENGTH]; +#if MBEDTLS_VERSION_NUMBER >= 0x02070000 + mbedtls_sha1_ret(message->data, message->length, hash); +#else + mbedtls_sha1(message->data, message->length, hash); +#endif + + /* Set the RSA settings */ + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(certificate->pk); + if(!rsaContext) + return UA_STATUSCODE_BADINTERNALERROR; + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, 0); + + /* Verify */ + int mbedErr = mbedtls_pk_verify(&certificate->pk, + MBEDTLS_MD_SHA1, hash, UA_SHA1_LENGTH, + signature->data, signature->length); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +mbedtls_sign_sha1(mbedtls_pk_context *localPrivateKey, + mbedtls_ctr_drbg_context *drbgContext, + const UA_ByteString *message, + UA_ByteString *signature) { + unsigned char hash[UA_SHA1_LENGTH]; +#if MBEDTLS_VERSION_NUMBER >= 0x02070000 + mbedtls_sha1_ret(message->data, message->length, hash); +#else + mbedtls_sha1(message->data, message->length, hash); +#endif + + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(*localPrivateKey); + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V15, 0); + + size_t sigLen = 0; + int mbedErr = mbedtls_pk_sign(localPrivateKey, MBEDTLS_MD_SHA1, hash, + UA_SHA1_LENGTH, signature->data, &sigLen, + mbedtls_ctr_drbg_random, drbgContext); + if(mbedErr) + return UA_STATUSCODE_BADINTERNALERROR; + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +mbedtls_thumbprint_sha1(const UA_ByteString *certificate, + UA_ByteString *thumbprint) { + if(UA_ByteString_equal(certificate, &UA_BYTESTRING_NULL)) + return UA_STATUSCODE_BADINTERNALERROR; + + if(thumbprint->length != UA_SHA1_LENGTH) + return UA_STATUSCODE_BADINTERNALERROR; + + /* The certificate thumbprint is always a 20 bit sha1 hash, see Part 4 of the Specification. */ +#if MBEDTLS_VERSION_NUMBER >= 0x02070000 + mbedtls_sha1_ret(certificate->data, certificate->length, thumbprint->data); +#else + mbedtls_sha1(certificate->data, certificate->length, thumbprint->data); +#endif + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +mbedtls_encrypt_rsaOaep(mbedtls_rsa_context *context, + mbedtls_ctr_drbg_context *drbgContext, + UA_ByteString *data, const size_t plainTextBlockSize) { + if(data->length % plainTextBlockSize != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t max_blocks = data->length / plainTextBlockSize; + + UA_ByteString encrypted; + UA_StatusCode retval = UA_ByteString_allocBuffer(&encrypted, max_blocks * context->len); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + size_t lenDataToEncrypt = data->length; + size_t inOffset = 0; + size_t offset = 0; + const unsigned char *label = NULL; + while(lenDataToEncrypt >= plainTextBlockSize) { + int mbedErr = mbedtls_rsa_rsaes_oaep_encrypt(context, mbedtls_ctr_drbg_random, + drbgContext, MBEDTLS_RSA_PUBLIC, + label, 0, plainTextBlockSize, + data->data + inOffset, encrypted.data + offset); + if(mbedErr) { + UA_ByteString_clear(&encrypted); + return UA_STATUSCODE_BADINTERNALERROR; + } + + inOffset += plainTextBlockSize; + offset += context->len; + lenDataToEncrypt -= plainTextBlockSize; + } + + memcpy(data->data, encrypted.data, offset); + UA_ByteString_clear(&encrypted); + return UA_STATUSCODE_GOOD; +} + +UA_StatusCode +mbedtls_decrypt_rsaOaep(mbedtls_pk_context *localPrivateKey, + mbedtls_ctr_drbg_context *drbgContext, + UA_ByteString *data) { + mbedtls_rsa_context *rsaContext = mbedtls_pk_rsa(*localPrivateKey); + mbedtls_rsa_set_padding(rsaContext, MBEDTLS_RSA_PKCS_V21, MBEDTLS_MD_SHA1); + + if(data->length % rsaContext->len != 0) + return UA_STATUSCODE_BADINTERNALERROR; + + size_t inOffset = 0; + size_t outOffset = 0; + size_t outLength = 0; + unsigned char buf[512]; + + while(inOffset < data->length) { + int mbedErr = mbedtls_rsa_rsaes_oaep_decrypt(rsaContext, mbedtls_ctr_drbg_random, + drbgContext, MBEDTLS_RSA_PRIVATE, + NULL, 0, &outLength, + data->data + inOffset, + buf, 512); + if(mbedErr) + return UA_STATUSCODE_BADSECURITYCHECKSFAILED; + + memcpy(data->data + outOffset, buf, outLength); + inOffset += rsaContext->len; + outOffset += outLength; + } + + data->length = outOffset; + return UA_STATUSCODE_GOOD; +} + +int UA_mbedTLS_LoadPrivateKey(const UA_ByteString *key, mbedtls_pk_context *target) +{ + UA_ByteString data = UA_mbedTLS_CopyDataFormatAware(key); + int mbedErr = mbedtls_pk_parse_key(target, data.data, data.length, NULL, 0); + UA_ByteString_clear(&data); + + return mbedErr; +} + +UA_StatusCode UA_mbedTLS_LoadLocalCertificate(const UA_ByteString *certData, UA_ByteString *target) +{ + UA_ByteString data = UA_mbedTLS_CopyDataFormatAware(certData); + + mbedtls_x509_crt cert; + mbedtls_x509_crt_init(&cert); + + int mbedErr = mbedtls_x509_crt_parse(&cert, data.data, data.length); + + UA_StatusCode result = UA_STATUSCODE_BADINVALIDARGUMENT; + + if (!mbedErr) { + UA_ByteString tmp; + tmp.data = cert.raw.p; + tmp.length = cert.raw.len; + + result = UA_ByteString_copy(&tmp, target); + } else { + UA_ByteString_init(target); + } + + UA_ByteString_clear(&data); + mbedtls_x509_crt_free(&cert); + return result; +} + +// mbedTLS expects PEM data to be null terminated +// The data length parameter must include the null terminator +UA_ByteString UA_mbedTLS_CopyDataFormatAware(const UA_ByteString *data) +{ + UA_ByteString result; + UA_ByteString_init(&result); + + if (!data->length) + return result; + + if (data->length && data->data[0] == '-') { + UA_ByteString_allocBuffer(&result, data->length + 1); + memcpy(result.data, data->data, data->length); + result.data[data->length] = '\0'; + } else { + UA_ByteString_copy(data, &result); + } + + return result; +} + +#endif + +/**** amalgamated original file "/plugins/ua_log_stdout.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Thomas Stalder, Blue Time Concept SA + */ + + +#include + +#if UA_MULTITHREADING >= 100 +#include +static pthread_mutex_t printf_mutex = PTHREAD_MUTEX_INITIALIZER; +#endif + +/* ANSI escape sequences for color output taken from here: + * https://stackoverflow.com/questions/3219393/stdlib-and-colored-output-in-c*/ + +#ifdef UA_ENABLE_LOG_COLORS +# define ANSI_COLOR_RED "\x1b[31m" +# define ANSI_COLOR_GREEN "\x1b[32m" +# define ANSI_COLOR_YELLOW "\x1b[33m" +# define ANSI_COLOR_BLUE "\x1b[34m" +# define ANSI_COLOR_MAGENTA "\x1b[35m" +# define ANSI_COLOR_CYAN "\x1b[36m" +# define ANSI_COLOR_RESET "\x1b[0m" +#else +# define ANSI_COLOR_RED "" +# define ANSI_COLOR_GREEN "" +# define ANSI_COLOR_YELLOW "" +# define ANSI_COLOR_BLUE "" +# define ANSI_COLOR_MAGENTA "" +# define ANSI_COLOR_CYAN "" +# define ANSI_COLOR_RESET "" +#endif + +const char *logLevelNames[6] = {"trace", "debug", + ANSI_COLOR_GREEN "info", + ANSI_COLOR_YELLOW "warn", + ANSI_COLOR_RED "error", + ANSI_COLOR_MAGENTA "fatal"}; +const char *logCategoryNames[7] = {"network", "channel", "session", "server", + "client", "userland", "securitypolicy"}; + +#ifdef __clang__ +__attribute__((__format__(__printf__, 4 , 0))) +#endif +void +UA_Log_Stdout_log(void *context, UA_LogLevel level, UA_LogCategory category, + const char *msg, va_list args) { + + /* Assume that context is casted to UA_LogLevel */ + /* TODO we may later change this to a struct with bitfields to filter on category */ + if ( context != NULL && (UA_LogLevel)(uintptr_t)context > level ) + return; + + UA_Int64 tOffset = UA_DateTime_localTimeUtcOffset(); + UA_DateTimeStruct dts = UA_DateTime_toStruct(UA_DateTime_now() + tOffset); + +#if UA_MULTITHREADING >= 100 + pthread_mutex_lock(&printf_mutex); +#endif + + // printf("[%04u-%02u-%02u %02u:%02u:%02u.%03u (UTC%+05d)] %s/%s" ANSI_COLOR_RESET "\t", + // dts.year, dts.month, dts.day, dts.hour, dts.min, dts.sec, dts.milliSec, + // (int)(tOffset / UA_DATETIME_SEC / 36), logLevelNames[level], logCategoryNames[category]); + // vprintf(msg, args); + + KPrintf("%s/%s" ANSI_COLOR_RESET "\t", + logLevelNames[level], logCategoryNames[category]); + + KPrintf(msg, args); + KPrintf("\n"); + + // printf("\n"); + fflush(stdout); + +#if UA_MULTITHREADING >= 100 + pthread_mutex_unlock(&printf_mutex); +#endif +} + +void +UA_Log_Stdout_clear(void *logContext) { + +} + +const UA_Logger UA_Log_Stdout_ = {UA_Log_Stdout_log, NULL, UA_Log_Stdout_clear}; +const UA_Logger *UA_Log_Stdout = &UA_Log_Stdout_; + +/* By default the client and server is configured with UA_Log_Stdout + This constructs a logger with a configurable max log level */ + +UA_Logger UA_Log_Stdout_withLevel(UA_LogLevel minlevel) +{ + UA_Logger logger = {UA_Log_Stdout_log, (void*)minlevel, UA_Log_Stdout_clear}; + return logger; +} + +/**** amalgamated original file "/plugins/ua_accesscontrol_default.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2019 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + +/* Example access control management. Anonymous and username / password login. + * The access rights are maximally permissive. + * + * FOR PRODUCTION USE, THIS EXAMPLE PLUGIN SHOULD BE REPLACED WITH LESS + * PERMISSIVE ACCESS CONTROL. + * + * For TransferSubscriptions, we check whether the transfer happens between + * Sessions for the same user. */ + +typedef struct { + UA_Boolean allowAnonymous; + size_t usernamePasswordLoginSize; + UA_UsernamePasswordLogin *usernamePasswordLogin; + UA_CertificateVerification verifyX509; +} AccessControlContext; + +#define ANONYMOUS_POLICY "open62541-anonymous-policy" +#define CERTIFICATE_POLICY "open62541-certificate-policy" +#define USERNAME_POLICY "open62541-username-policy" +const UA_String anonymous_policy = UA_STRING_STATIC(ANONYMOUS_POLICY); +const UA_String certificate_policy = UA_STRING_STATIC(CERTIFICATE_POLICY); +const UA_String username_policy = UA_STRING_STATIC(USERNAME_POLICY); + +/************************/ +/* Access Control Logic */ +/************************/ + +static UA_StatusCode +activateSession_default(UA_Server *server, UA_AccessControl *ac, + const UA_EndpointDescription *endpointDescription, + const UA_ByteString *secureChannelRemoteCertificate, + const UA_NodeId *sessionId, + const UA_ExtensionObject *userIdentityToken, + void **sessionContext) { + AccessControlContext *context = (AccessControlContext*)ac->context; + + /* The empty token is interpreted as anonymous */ + if(userIdentityToken->encoding == UA_EXTENSIONOBJECT_ENCODED_NOBODY) { + if(!context->allowAnonymous) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + /* No userdata atm */ + *sessionContext = NULL; + return UA_STATUSCODE_GOOD; + } + + /* Could the token be decoded? */ + if(userIdentityToken->encoding < UA_EXTENSIONOBJECT_DECODED) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + /* Anonymous login */ + if(userIdentityToken->content.decoded.type == &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]) { + if(!context->allowAnonymous) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + const UA_AnonymousIdentityToken *token = (UA_AnonymousIdentityToken*) + userIdentityToken->content.decoded.data; + + /* Compatibility notice: Siemens OPC Scout v10 provides an empty + * policyId. This is not compliant. For compatibility, assume that empty + * policyId == ANONYMOUS_POLICY */ + if(token->policyId.data && !UA_String_equal(&token->policyId, &anonymous_policy)) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + /* No userdata atm */ + *sessionContext = NULL; + return UA_STATUSCODE_GOOD; + } + + /* Username and password */ + if(userIdentityToken->content.decoded.type == &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]) { + const UA_UserNameIdentityToken *userToken = + (UA_UserNameIdentityToken*)userIdentityToken->content.decoded.data; + + if(!UA_String_equal(&userToken->policyId, &username_policy)) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + /* The userToken has been decrypted by the server before forwarding + * it to the plugin. This information can be used here. */ + /* if(userToken->encryptionAlgorithm.length > 0) {} */ + + /* Empty username and password */ + if(userToken->userName.length == 0 && userToken->password.length == 0) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + /* Try to match username/pw */ + UA_Boolean match = false; + for(size_t i = 0; i < context->usernamePasswordLoginSize; i++) { + if(UA_String_equal(&userToken->userName, &context->usernamePasswordLogin[i].username) && + UA_String_equal(&userToken->password, &context->usernamePasswordLogin[i].password)) { + match = true; + break; + } + } + if(!match) + return UA_STATUSCODE_BADUSERACCESSDENIED; + + /* For the CTT, recognize whether two sessions are */ + UA_ByteString *username = UA_ByteString_new(); + if(username) + UA_ByteString_copy(&userToken->userName, username); + *sessionContext = username; + return UA_STATUSCODE_GOOD; + } + + /* x509 certificate */ + if(userIdentityToken->content.decoded.type == &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]) { + const UA_X509IdentityToken *userToken = (UA_X509IdentityToken*) + userIdentityToken->content.decoded.data; + + if(!UA_String_equal(&userToken->policyId, &certificate_policy)) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + if(!context->verifyX509.verifyCertificate) + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; + + return context->verifyX509. + verifyCertificate(context->verifyX509.context, + &userToken->certificateData); + } + + /* Unsupported token type */ + return UA_STATUSCODE_BADIDENTITYTOKENINVALID; +} + +static void +closeSession_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext) { + if(sessionContext) + UA_ByteString_delete((UA_ByteString*)sessionContext); +} + +static UA_UInt32 +getUserRightsMask_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext) { + return 0xFFFFFFFF; +} + +static UA_Byte +getUserAccessLevel_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext) { + return 0xFF; +} + +static UA_Boolean +getUserExecutable_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *methodId, void *methodContext) { + return true; +} + +static UA_Boolean +getUserExecutableOnObject_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext) { + return true; +} + +static UA_Boolean +allowAddNode_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_AddNodesItem *item) { + return true; +} + +static UA_Boolean +allowAddReference_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_AddReferencesItem *item) { + return true; +} + +static UA_Boolean +allowDeleteNode_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_DeleteNodesItem *item) { + return true; +} + +static UA_Boolean +allowDeleteReference_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_DeleteReferencesItem *item) { + return true; +} + +static UA_Boolean +allowBrowseNode_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext) { + return true; +} + +#ifdef UA_ENABLE_SUBSCRIPTIONS +static UA_Boolean +allowTransferSubscription_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *oldSessionId, void *oldSessionContext, + const UA_NodeId *newSessionId, void *newSessionContext) { + if(oldSessionContext == newSessionContext) + return true; + if(oldSessionContext && newSessionContext) + return UA_ByteString_equal((UA_ByteString*)oldSessionContext, + (UA_ByteString*)newSessionContext); + return false; +} +#endif + +#ifdef UA_ENABLE_HISTORIZING +static UA_Boolean +allowHistoryUpdateUpdateData_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, + UA_PerformUpdateType performInsertReplace, + const UA_DataValue *value) { + return true; +} + +static UA_Boolean +allowHistoryUpdateDeleteRawModified_default(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, + UA_DateTime startTimestamp, + UA_DateTime endTimestamp, + bool isDeleteModified) { + return true; +} +#endif + +/***************************************/ +/* Create Delete Access Control Plugin */ +/***************************************/ + +static void clear_default(UA_AccessControl *ac) { + UA_Array_delete((void*)(uintptr_t)ac->userTokenPolicies, + ac->userTokenPoliciesSize, + &UA_TYPES[UA_TYPES_USERTOKENPOLICY]); + ac->userTokenPolicies = NULL; + ac->userTokenPoliciesSize = 0; + + AccessControlContext *context = (AccessControlContext*)ac->context; + + if (context) { + for(size_t i = 0; i < context->usernamePasswordLoginSize; i++) { + UA_String_clear(&context->usernamePasswordLogin[i].username); + UA_String_clear(&context->usernamePasswordLogin[i].password); + } + if(context->usernamePasswordLoginSize > 0) + UA_free(context->usernamePasswordLogin); + + if(context->verifyX509.clear) + context->verifyX509.clear(&context->verifyX509); + + UA_free(ac->context); + ac->context = NULL; + } +} + +UA_StatusCode +UA_AccessControl_default(UA_ServerConfig *config, + UA_Boolean allowAnonymous, + UA_CertificateVerification *verifyX509, + const UA_ByteString *userTokenPolicyUri, + size_t usernamePasswordLoginSize, + const UA_UsernamePasswordLogin *usernamePasswordLogin) { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_SERVER, + "AccessControl: Unconfigured AccessControl. Users have all permissions."); + UA_AccessControl *ac = &config->accessControl; + + if(ac->clear) + clear_default(ac); + + ac->clear = clear_default; + ac->activateSession = activateSession_default; + ac->closeSession = closeSession_default; + ac->getUserRightsMask = getUserRightsMask_default; + ac->getUserAccessLevel = getUserAccessLevel_default; + ac->getUserExecutable = getUserExecutable_default; + ac->getUserExecutableOnObject = getUserExecutableOnObject_default; + ac->allowAddNode = allowAddNode_default; + ac->allowAddReference = allowAddReference_default; + ac->allowBrowseNode = allowBrowseNode_default; + +#ifdef UA_ENABLE_SUBSCRIPTIONS + ac->allowTransferSubscription = allowTransferSubscription_default; +#endif + +#ifdef UA_ENABLE_HISTORIZING + ac->allowHistoryUpdateUpdateData = allowHistoryUpdateUpdateData_default; + ac->allowHistoryUpdateDeleteRawModified = allowHistoryUpdateDeleteRawModified_default; +#endif + + ac->allowDeleteNode = allowDeleteNode_default; + ac->allowDeleteReference = allowDeleteReference_default; + + AccessControlContext *context = (AccessControlContext*) + UA_malloc(sizeof(AccessControlContext)); + if(!context) + return UA_STATUSCODE_BADOUTOFMEMORY; + memset(context, 0, sizeof(AccessControlContext)); + ac->context = context; + + /* Allow anonymous? */ + context->allowAnonymous = allowAnonymous; + if(allowAnonymous) { + UA_LOG_INFO(&config->logger, UA_LOGCATEGORY_SERVER, + "AccessControl: Anonymous login is enabled"); + } + + /* Allow x509 certificates? Move the plugin over. */ + if(verifyX509) { + context->verifyX509 = *verifyX509; + memset(verifyX509, 0, sizeof(UA_CertificateVerification)); + } else { + memset(&context->verifyX509, 0, sizeof(UA_CertificateVerification)); + UA_LOG_INFO(&config->logger, UA_LOGCATEGORY_SERVER, + "AccessControl: x509 certificate user authentication is enabled"); + } + + /* Copy username/password to the access control plugin */ + if(usernamePasswordLoginSize > 0) { + context->usernamePasswordLogin = (UA_UsernamePasswordLogin*) + UA_malloc(usernamePasswordLoginSize * sizeof(UA_UsernamePasswordLogin)); + if(!context->usernamePasswordLogin) + return UA_STATUSCODE_BADOUTOFMEMORY; + context->usernamePasswordLoginSize = usernamePasswordLoginSize; + for(size_t i = 0; i < usernamePasswordLoginSize; i++) { + UA_String_copy(&usernamePasswordLogin[i].username, + &context->usernamePasswordLogin[i].username); + UA_String_copy(&usernamePasswordLogin[i].password, + &context->usernamePasswordLogin[i].password); + } + } + + /* Set the allowed policies */ + size_t policies = 0; + if(allowAnonymous) + policies++; + if(verifyX509) + policies++; + if(usernamePasswordLoginSize > 0) + policies++; + ac->userTokenPoliciesSize = 0; + ac->userTokenPolicies = (UA_UserTokenPolicy *) + UA_Array_new(policies, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]); + if(!ac->userTokenPolicies) + return UA_STATUSCODE_BADOUTOFMEMORY; + ac->userTokenPoliciesSize = policies; + + policies = 0; + if(allowAnonymous) { + ac->userTokenPolicies[policies].tokenType = UA_USERTOKENTYPE_ANONYMOUS; + ac->userTokenPolicies[policies].policyId = UA_STRING_ALLOC(ANONYMOUS_POLICY); + if (!ac->userTokenPolicies[policies].policyId.data) + return UA_STATUSCODE_BADOUTOFMEMORY; + policies++; + } + + if(verifyX509) { + ac->userTokenPolicies[policies].tokenType = UA_USERTOKENTYPE_CERTIFICATE; + ac->userTokenPolicies[policies].policyId = UA_STRING_ALLOC(CERTIFICATE_POLICY); + if (!ac->userTokenPolicies[policies].policyId.data) + return UA_STATUSCODE_BADOUTOFMEMORY; + policies++; + } + + if(usernamePasswordLoginSize > 0) { + ac->userTokenPolicies[policies].tokenType = UA_USERTOKENTYPE_USERNAME; + ac->userTokenPolicies[policies].policyId = UA_STRING_ALLOC(USERNAME_POLICY); + if(!ac->userTokenPolicies[policies].policyId.data) + return UA_STATUSCODE_BADOUTOFMEMORY; + +#if UA_LOGLEVEL <= 400 + const UA_String noneUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None"); + if(UA_ByteString_equal(userTokenPolicyUri, &noneUri)) { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_SERVER, + "Username/Password configured, but no encrypting SecurityPolicy. " + "This can leak credentials on the network."); + } +#endif + return UA_ByteString_copy(userTokenPolicyUri, + &ac->userTokenPolicies[policies].securityPolicyUri); + } + return UA_STATUSCODE_GOOD; +} + + +/**** amalgamated original file "/plugins/ua_nodestore_ziptree.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2014-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Julian Grothoff + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + +#ifndef container_of +#define container_of(ptr, type, member) \ + (type *)((uintptr_t)ptr - offsetof(type,member)) +#endif + +struct NodeEntry; +typedef struct NodeEntry NodeEntry; + +struct NodeEntry { + ZIP_ENTRY(NodeEntry) zipfields; + UA_UInt32 nodeIdHash; + UA_UInt16 refCount; /* How many consumers have a reference to the node? */ + UA_Boolean deleted; /* Node was marked as deleted and can be deleted when refCount == 0 */ + NodeEntry *orig; /* If a copy is made to replace a node, track that we + * replace only the node from which the copy was made. + * Important for concurrent operations. */ + UA_NodeId nodeId; /* This is actually a UA_Node that also starts with a NodeId */ +}; + +/* Absolute ordering for NodeIds */ +static enum ZIP_CMP +cmpNodeId(const void *a, const void *b) { + const NodeEntry *aa = (const NodeEntry*)a; + const NodeEntry *bb = (const NodeEntry*)b; + + /* Compare hash */ + if(aa->nodeIdHash < bb->nodeIdHash) + return ZIP_CMP_LESS; + if(aa->nodeIdHash > bb->nodeIdHash) + return ZIP_CMP_MORE; + + /* Compore nodes in detail */ + return (enum ZIP_CMP)UA_NodeId_order(&aa->nodeId, &bb->nodeId); +} + +ZIP_HEAD(NodeTree, NodeEntry); +typedef struct NodeTree NodeTree; + +typedef struct { + NodeTree root; + + /* Maps ReferenceTypeIndex to the NodeId of the ReferenceType */ + UA_NodeId referenceTypeIds[UA_REFERENCETYPESET_MAX]; + UA_Byte referenceTypeCounter; +} ZipContext; + +ZIP_PROTOTYPE(NodeTree, NodeEntry, NodeEntry) +ZIP_IMPL(NodeTree, NodeEntry, zipfields, NodeEntry, zipfields, cmpNodeId) + +static NodeEntry * +newEntry(UA_NodeClass nodeClass) { + size_t size = sizeof(NodeEntry) - sizeof(UA_NodeId); + switch(nodeClass) { + case UA_NODECLASS_OBJECT: + size += sizeof(UA_ObjectNode); + break; + case UA_NODECLASS_VARIABLE: + size += sizeof(UA_VariableNode); + break; + case UA_NODECLASS_METHOD: + size += sizeof(UA_MethodNode); + break; + case UA_NODECLASS_OBJECTTYPE: + size += sizeof(UA_ObjectTypeNode); + break; + case UA_NODECLASS_VARIABLETYPE: + size += sizeof(UA_VariableTypeNode); + break; + case UA_NODECLASS_REFERENCETYPE: + size += sizeof(UA_ReferenceTypeNode); + break; + case UA_NODECLASS_DATATYPE: + size += sizeof(UA_DataTypeNode); + break; + case UA_NODECLASS_VIEW: + size += sizeof(UA_ViewNode); + break; + default: + return NULL; + } + NodeEntry *entry = (NodeEntry*)UA_calloc(1, size); + if(!entry) + return NULL; + UA_Node *node = (UA_Node*)&entry->nodeId; + node->head.nodeClass = nodeClass; + return entry; +} + +static void +deleteEntry(NodeEntry *entry) { + UA_Node_clear((UA_Node*)&entry->nodeId); + UA_free(entry); +} + +static void +cleanupEntry(NodeEntry *entry) { + if(entry->refCount > 0) + return; + if(entry->deleted) { + deleteEntry(entry); + return; + } + UA_NodeHead *head = (UA_NodeHead*)&entry->nodeId; + for(size_t i = 0; i < head->referencesSize; i++) { + UA_NodeReferenceKind *rk = &head->references[i]; + if(rk->targetsSize > 16 && !rk->hasRefTree) + UA_NodeReferenceKind_switch(rk); + } +} + +/***********************/ +/* Interface functions */ +/***********************/ + +/* Not yet inserted into the ZipContext */ +static UA_Node * +zipNsNewNode(void *nsCtx, UA_NodeClass nodeClass) { + NodeEntry *entry = newEntry(nodeClass); + if(!entry) + return NULL; + return (UA_Node*)&entry->nodeId; +} + +/* Not yet inserted into the ZipContext */ +static void +zipNsDeleteNode(void *nsCtx, UA_Node *node) { + deleteEntry(container_of(node, NodeEntry, nodeId)); +} + +static const UA_Node * +zipNsGetNode(void *nsCtx, const UA_NodeId *nodeId) { + ZipContext *ns = (ZipContext*)nsCtx; + NodeEntry dummy; + dummy.nodeIdHash = UA_NodeId_hash(nodeId); + dummy.nodeId = *nodeId; + NodeEntry *entry = ZIP_FIND(NodeTree, &ns->root, &dummy); + if(!entry) + return NULL; + ++entry->refCount; + return (const UA_Node*)&entry->nodeId; +} + +static void +zipNsReleaseNode(void *nsCtx, const UA_Node *node) { + if(!node) + return; + NodeEntry *entry = container_of(node, NodeEntry, nodeId); + UA_assert(entry->refCount > 0); + --entry->refCount; + cleanupEntry(entry); +} + +static UA_StatusCode +zipNsGetNodeCopy(void *nsCtx, const UA_NodeId *nodeId, + UA_Node **outNode) { + /* Find the node */ + const UA_Node *node = zipNsGetNode(nsCtx, nodeId); + if(!node) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + + /* Create the new entry */ + NodeEntry *ne = newEntry(node->head.nodeClass); + if(!ne) { + zipNsReleaseNode(nsCtx, node); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + /* Copy the node content */ + UA_Node *nnode = (UA_Node*)&ne->nodeId; + UA_StatusCode retval = UA_Node_copy(node, nnode); + zipNsReleaseNode(nsCtx, node); + if(retval != UA_STATUSCODE_GOOD) { + deleteEntry(ne); + return retval; + } + + ne->orig = container_of(node, NodeEntry, nodeId); + *outNode = nnode; + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +zipNsInsertNode(void *nsCtx, UA_Node *node, UA_NodeId *addedNodeId) { + NodeEntry *entry = container_of(node, NodeEntry, nodeId); + ZipContext *ns = (ZipContext*)nsCtx; + + /* Ensure that the NodeId is unique */ + NodeEntry dummy; + memset(&dummy, 0, sizeof(NodeEntry)); + dummy.nodeId = node->head.nodeId; + if(node->head.nodeId.identifierType == UA_NODEIDTYPE_NUMERIC && + node->head.nodeId.identifier.numeric == 0) { + do { /* Create a random nodeid until we find an unoccupied id */ + UA_UInt32 numId = UA_UInt32_random(); +#if SIZE_MAX <= UA_UINT32_MAX + /* The compressed "immediate" representation of nodes does not + * support the full range on 32bit systems. Generate smaller + * identifiers as they can be stored more compactly. */ + if(numId >= (0x01 << 24)) + numId = numId % (0x01 << 24); +#endif + node->head.nodeId.identifier.numeric = numId; + dummy.nodeId.identifier.numeric = numId; + dummy.nodeIdHash = UA_NodeId_hash(&node->head.nodeId); + } while(ZIP_FIND(NodeTree, &ns->root, &dummy)); + } else { + dummy.nodeIdHash = UA_NodeId_hash(&node->head.nodeId); + if(ZIP_FIND(NodeTree, &ns->root, &dummy)) { /* The nodeid exists */ + deleteEntry(entry); + return UA_STATUSCODE_BADNODEIDEXISTS; + } + } + + /* Copy the NodeId */ + if(addedNodeId) { + UA_StatusCode retval = UA_NodeId_copy(&node->head.nodeId, addedNodeId); + if(retval != UA_STATUSCODE_GOOD) { + deleteEntry(entry); + return retval; + } + } + + /* For new ReferencetypeNodes add to the index map */ + if(node->head.nodeClass == UA_NODECLASS_REFERENCETYPE) { + UA_ReferenceTypeNode *refNode = &node->referenceTypeNode; + if(ns->referenceTypeCounter >= UA_REFERENCETYPESET_MAX) { + deleteEntry(entry); + return UA_STATUSCODE_BADINTERNALERROR; + } + + UA_StatusCode retval = + UA_NodeId_copy(&node->head.nodeId, &ns->referenceTypeIds[ns->referenceTypeCounter]); + if(retval != UA_STATUSCODE_GOOD) { + deleteEntry(entry); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Assign the ReferenceTypeIndex to the new ReferenceTypeNode */ + refNode->referenceTypeIndex = ns->referenceTypeCounter; + refNode->subTypes = UA_REFTYPESET(ns->referenceTypeCounter); + + ns->referenceTypeCounter++; + } + + /* Insert the node */ + entry->nodeIdHash = dummy.nodeIdHash; + ZIP_INSERT(NodeTree, &ns->root, entry, ZIP_FFS32(UA_UInt32_random())); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +zipNsReplaceNode(void *nsCtx, UA_Node *node) { + /* Find the node */ + const UA_Node *oldNode = zipNsGetNode(nsCtx, &node->head.nodeId); + if(!oldNode) { + deleteEntry(container_of(node, NodeEntry, nodeId)); + return UA_STATUSCODE_BADNODEIDUNKNOWN; + } + + /* Test if the copy is current */ + NodeEntry *entry = container_of(node, NodeEntry, nodeId); + NodeEntry *oldEntry = container_of(oldNode, NodeEntry, nodeId); + if(oldEntry != entry->orig) { + /* The node was already updated since the copy was made */ + deleteEntry(entry); + zipNsReleaseNode(nsCtx, oldNode); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Replace */ + ZipContext *ns = (ZipContext*)nsCtx; + ZIP_REMOVE(NodeTree, &ns->root, oldEntry); + entry->nodeIdHash = oldEntry->nodeIdHash; + ZIP_INSERT(NodeTree, &ns->root, entry, ZIP_RANK(entry, zipfields)); + oldEntry->deleted = true; + + zipNsReleaseNode(nsCtx, oldNode); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +zipNsRemoveNode(void *nsCtx, const UA_NodeId *nodeId) { + ZipContext *ns = (ZipContext*)nsCtx; + NodeEntry dummy; + dummy.nodeIdHash = UA_NodeId_hash(nodeId); + dummy.nodeId = *nodeId; + NodeEntry *entry = ZIP_FIND(NodeTree, &ns->root, &dummy); + if(!entry) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + ZIP_REMOVE(NodeTree, &ns->root, entry); + entry->deleted = true; + cleanupEntry(entry); + return UA_STATUSCODE_GOOD; +} + +static const UA_NodeId * +zipNsGetReferenceTypeId(void *nsCtx, UA_Byte refTypeIndex) { + ZipContext *ns = (ZipContext*)nsCtx; + if(refTypeIndex > ns->referenceTypeCounter) + return NULL; + return &ns->referenceTypeIds[refTypeIndex]; +} + +struct VisitorData { + UA_NodestoreVisitor visitor; + void *visitorContext; +}; + +static void +nodeVisitor(NodeEntry *entry, void *data) { + struct VisitorData *d = (struct VisitorData*)data; + d->visitor(d->visitorContext, (UA_Node*)&entry->nodeId); +} + +static void +zipNsIterate(void *nsCtx, UA_NodestoreVisitor visitor, + void *visitorCtx) { + struct VisitorData d; + d.visitor = visitor; + d.visitorContext = visitorCtx; + ZipContext *ns = (ZipContext*)nsCtx; + ZIP_ITER(NodeTree, &ns->root, nodeVisitor, &d); +} + +static void +deleteNodeVisitor(NodeEntry *entry, void *data) { + deleteEntry(entry); +} + +/***********************/ +/* Nodestore Lifecycle */ +/***********************/ + +static void +zipNsClear(void *nsCtx) { + if (!nsCtx) + return; + ZipContext *ns = (ZipContext*)nsCtx; + ZIP_ITER(NodeTree, &ns->root, deleteNodeVisitor, NULL); + + /* Clean up the ReferenceTypes index array */ + for(size_t i = 0; i < ns->referenceTypeCounter; i++) + UA_NodeId_clear(&ns->referenceTypeIds[i]); + + UA_free(ns); +} + +UA_StatusCode +UA_Nodestore_ZipTree(UA_Nodestore *ns) { + /* Allocate and initialize the context */ + ZipContext *ctx = (ZipContext*)UA_malloc(sizeof(ZipContext)); + if(!ctx) + return UA_STATUSCODE_BADOUTOFMEMORY; + + ZIP_INIT(&ctx->root); + ctx->referenceTypeCounter = 0; + + /* Populate the nodestore */ + ns->context = (void*)ctx; + ns->clear = zipNsClear; + ns->newNode = zipNsNewNode; + ns->deleteNode = zipNsDeleteNode; + ns->getNode = zipNsGetNode; + ns->releaseNode = zipNsReleaseNode; + ns->getNodeCopy = zipNsGetNodeCopy; + ns->insertNode = zipNsInsertNode; + ns->replaceNode = zipNsReplaceNode; + ns->removeNode = zipNsRemoveNode; + ns->getReferenceTypeId = zipNsGetReferenceTypeId; + ns->iterate = zipNsIterate; + + return UA_STATUSCODE_GOOD; +} + +/**** amalgamated original file "/plugins/ua_nodestore_hashmap.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2014-2019 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Julian Grothoff + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + +#ifndef container_of +#define container_of(ptr, type, member) \ + (type *)((uintptr_t)ptr - offsetof(type,member)) +#endif + +/* The default Nodestore is simply a hash-map from NodeIds to Nodes. To find an + * entry, iterate over candidate positions according to the NodeId hash. + * + * - Tombstone or non-matching NodeId: continue searching + * - Matching NodeId: Return the entry + * - NULL: Abort the search */ + +typedef struct UA_NodeMapEntry { + struct UA_NodeMapEntry *orig; /* the version this is a copy from (or NULL) */ + UA_UInt16 refCount; /* How many consumers have a reference to the node? */ + UA_Boolean deleted; /* Node was marked as deleted and can be deleted when refCount == 0 */ + UA_Node node; +} UA_NodeMapEntry; + +#define UA_NODEMAP_MINSIZE 64 +#define UA_NODEMAP_TOMBSTONE ((UA_NodeMapEntry*)0x01) + +typedef struct { + UA_NodeMapEntry *entry; + UA_UInt32 nodeIdHash; +} UA_NodeMapSlot; + +typedef struct { + UA_NodeMapSlot *slots; + UA_UInt32 size; + UA_UInt32 count; + UA_UInt32 sizePrimeIndex; + + /* Maps ReferenceTypeIndex to the NodeId of the ReferenceType */ + UA_NodeId referenceTypeIds[UA_REFERENCETYPESET_MAX]; + UA_Byte referenceTypeCounter; +} UA_NodeMap; + +/*********************/ +/* HashMap Utilities */ +/*********************/ + +/* The size of the hash-map is always a prime number. They are chosen to be + * close to the next power of 2. So the size ca. doubles with each prime. */ +static UA_UInt32 const primes[] = { + 7, 13, 31, 61, 127, 251, + 509, 1021, 2039, 4093, 8191, 16381, + 32749, 65521, 131071, 262139, 524287, 1048573, + 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, + 134217689, 268435399, 536870909, 1073741789, 2147483647, 4294967291 +}; + +static UA_UInt32 mod(UA_UInt32 h, UA_UInt32 size) { return h % size; } +static UA_UInt32 mod2(UA_UInt32 h, UA_UInt32 size) { return 1 + (h % (size - 2)); } + +static UA_UInt16 +higher_prime_index(UA_UInt32 n) { + UA_UInt16 low = 0; + UA_UInt16 high = (UA_UInt16)(sizeof(primes) / sizeof(UA_UInt32)); + while(low != high) { + UA_UInt16 mid = (UA_UInt16)(low + ((high - low) / 2)); + if(n > primes[mid]) + low = (UA_UInt16)(mid + 1); + else + high = mid; + } + return low; +} + +/* Returns an empty slot or null if the nodeid exists or if no empty slot is found. */ +static UA_NodeMapSlot * +findFreeSlot(const UA_NodeMap *ns, const UA_NodeId *nodeid) { + UA_UInt32 h = UA_NodeId_hash(nodeid); + UA_UInt32 size = ns->size; + UA_UInt64 idx = mod(h, size); /* Use 64bit container to avoid overflow */ + UA_UInt32 startIdx = (UA_UInt32)idx; + UA_UInt32 hash2 = mod2(h, size); + + UA_NodeMapSlot *candidate = NULL; + do { + UA_NodeMapSlot *slot = &ns->slots[(UA_UInt32)idx]; + + if(slot->entry > UA_NODEMAP_TOMBSTONE) { + /* A Node with the NodeId does already exist */ + if(slot->nodeIdHash == h && + UA_NodeId_equal(&slot->entry->node.head.nodeId, nodeid)) + return NULL; + } else { + /* Found a candidate node */ + if(!candidate) + candidate = slot; + /* No matching node can come afterwards */ + if(slot->entry == NULL) + return candidate; + } + + idx += hash2; + if(idx >= size) + idx -= size; + } while((UA_UInt32)idx != startIdx); + + return candidate; +} + +/* The occupancy of the table after the call will be about 50% */ +static UA_StatusCode +expand(UA_NodeMap *ns) { + UA_UInt32 osize = ns->size; + UA_UInt32 count = ns->count; + /* Resize only when table after removal of unused elements is either too + full or too empty */ + if(count * 2 < osize && (count * 8 > osize || osize <= UA_NODEMAP_MINSIZE)) + return UA_STATUSCODE_GOOD; + + UA_NodeMapSlot *oslots = ns->slots; + UA_UInt32 nindex = higher_prime_index(count * 2); + UA_UInt32 nsize = primes[nindex]; + UA_NodeMapSlot *nslots= (UA_NodeMapSlot*)UA_calloc(nsize, sizeof(UA_NodeMapSlot)); + if(!nslots) + return UA_STATUSCODE_BADOUTOFMEMORY; + + ns->slots = nslots; + ns->size = nsize; + ns->sizePrimeIndex = nindex; + + /* recompute the position of every entry and insert the pointer */ + for(size_t i = 0, j = 0; i < osize && j < count; ++i) { + if(oslots[i].entry <= UA_NODEMAP_TOMBSTONE) + continue; + UA_NodeMapSlot *s = findFreeSlot(ns, &oslots[i].entry->node.head.nodeId); + UA_assert(s); + *s = oslots[i]; + ++j; + } + + UA_free(oslots); + return UA_STATUSCODE_GOOD; +} + +static UA_NodeMapEntry * +createEntry(UA_NodeClass nodeClass) { + size_t size = sizeof(UA_NodeMapEntry) - sizeof(UA_Node); + switch(nodeClass) { + case UA_NODECLASS_OBJECT: + size += sizeof(UA_ObjectNode); + break; + case UA_NODECLASS_VARIABLE: + size += sizeof(UA_VariableNode); + break; + case UA_NODECLASS_METHOD: + size += sizeof(UA_MethodNode); + break; + case UA_NODECLASS_OBJECTTYPE: + size += sizeof(UA_ObjectTypeNode); + break; + case UA_NODECLASS_VARIABLETYPE: + size += sizeof(UA_VariableTypeNode); + break; + case UA_NODECLASS_REFERENCETYPE: + size += sizeof(UA_ReferenceTypeNode); + break; + case UA_NODECLASS_DATATYPE: + size += sizeof(UA_DataTypeNode); + break; + case UA_NODECLASS_VIEW: + size += sizeof(UA_ViewNode); + break; + default: + return NULL; + } + UA_NodeMapEntry *entry = (UA_NodeMapEntry*)UA_calloc(1, size); + if(!entry) + return NULL; + entry->node.head.nodeClass = nodeClass; + return entry; +} + +static void +deleteNodeMapEntry(UA_NodeMapEntry *entry) { + UA_Node_clear(&entry->node); + UA_free(entry); +} + +static void +cleanupNodeMapEntry(UA_NodeMapEntry *entry) { + if(entry->refCount > 0) + return; + if(entry->deleted) { + deleteNodeMapEntry(entry); + return; + } + for(size_t i = 0; i < entry->node.head.referencesSize; i++) { + UA_NodeReferenceKind *rk = &entry->node.head.references[i]; + if(rk->targetsSize > 16 && !rk->hasRefTree) + UA_NodeReferenceKind_switch(rk); + } +} + +static UA_NodeMapSlot * +findOccupiedSlot(const UA_NodeMap *ns, const UA_NodeId *nodeid) { + UA_UInt32 h = UA_NodeId_hash(nodeid); + UA_UInt32 size = ns->size; + UA_UInt64 idx = mod(h, size); /* Use 64bit container to avoid overflow */ + UA_UInt32 hash2 = mod2(h, size); + UA_UInt32 startIdx = (UA_UInt32)idx; + + do { + UA_NodeMapSlot *slot= &ns->slots[(UA_UInt32)idx]; + if(slot->entry > UA_NODEMAP_TOMBSTONE) { + if(slot->nodeIdHash == h && + UA_NodeId_equal(&slot->entry->node.head.nodeId, nodeid)) + return slot; + } else { + if(slot->entry == NULL) + return NULL; /* No further entry possible */ + } + + idx += hash2; + if(idx >= size) + idx -= size; + } while((UA_UInt32)idx != startIdx); + + return NULL; +} + +/***********************/ +/* Interface functions */ +/***********************/ + +static UA_Node * +UA_NodeMap_newNode(void *context, UA_NodeClass nodeClass) { + UA_NodeMapEntry *entry = createEntry(nodeClass); + if(!entry) + return NULL; + return &entry->node; +} + +static void +UA_NodeMap_deleteNode(void *context, UA_Node *node) { + UA_NodeMapEntry *entry = container_of(node, UA_NodeMapEntry, node); + UA_assert(&entry->node == node); + deleteNodeMapEntry(entry); +} + +static const UA_Node * +UA_NodeMap_getNode(void *context, const UA_NodeId *nodeid) { + UA_NodeMap *ns = (UA_NodeMap*)context; + UA_NodeMapSlot *slot = findOccupiedSlot(ns, nodeid); + if(!slot) + return NULL; + ++slot->entry->refCount; + return &slot->entry->node; +} + +static void +UA_NodeMap_releaseNode(void *context, const UA_Node *node) { + if (!node) + return; + UA_NodeMapEntry *entry = container_of(node, UA_NodeMapEntry, node); + UA_assert(&entry->node == node); + UA_assert(entry->refCount > 0); + --entry->refCount; + cleanupNodeMapEntry(entry); +} + +static UA_StatusCode +UA_NodeMap_getNodeCopy(void *context, const UA_NodeId *nodeid, + UA_Node **outNode) { + UA_NodeMap *ns = (UA_NodeMap*)context; + UA_NodeMapSlot *slot = findOccupiedSlot(ns, nodeid); + if(!slot) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + UA_NodeMapEntry *entry = slot->entry; + UA_NodeMapEntry *newItem = createEntry(entry->node.head.nodeClass); + if(!newItem) + return UA_STATUSCODE_BADOUTOFMEMORY; + UA_StatusCode retval = UA_Node_copy(&entry->node, &newItem->node); + if(retval == UA_STATUSCODE_GOOD) { + newItem->orig = entry; /* Store the pointer to the original */ + *outNode = &newItem->node; + } else { + deleteNodeMapEntry(newItem); + } + return retval; +} + +static UA_StatusCode +UA_NodeMap_removeNode(void *context, const UA_NodeId *nodeid) { + UA_NodeMap *ns = (UA_NodeMap*)context; + UA_NodeMapSlot *slot = findOccupiedSlot(ns, nodeid); + if(!slot) + return UA_STATUSCODE_BADNODEIDUNKNOWN; + + UA_NodeMapEntry *entry = slot->entry; + slot->entry = UA_NODEMAP_TOMBSTONE; + UA_atomic_sync(); /* Set the tombstone before cleaning up. E.g. if the + * nodestore is accessed from an interrupt. */ + entry->deleted = true; + cleanupNodeMapEntry(entry); + --ns->count; + /* Downsize the hashmap if it is very empty */ + if(ns->count * 8 < ns->size && ns->size > UA_NODEMAP_MINSIZE) + expand(ns); /* Can fail. Just continue with the bigger hashmap. */ + return UA_STATUSCODE_GOOD; +} + +/* + * If this function fails in any way, the node parameter is deleted here, + * so the caller function does not need to take care of it anymore + */ +static UA_StatusCode +UA_NodeMap_insertNode(void *context, UA_Node *node, + UA_NodeId *addedNodeId) { + UA_NodeMap *ns = (UA_NodeMap*)context; + if(ns->size * 3 <= ns->count * 4) { + if(expand(ns) != UA_STATUSCODE_GOOD){ + deleteNodeMapEntry(container_of(node, UA_NodeMapEntry, node)); + return UA_STATUSCODE_BADINTERNALERROR; + } + } + + UA_NodeMapSlot *slot; + if(node->head.nodeId.identifierType == UA_NODEIDTYPE_NUMERIC && + node->head.nodeId.identifier.numeric == 0) { + /* Create a random nodeid: Start at least with 50,000 to make sure we + * don not conflict with nodes from the spec. If we find a conflict, we + * just try another identifier until we have tried all possible + * identifiers. Since the size is prime and we don't change the increase + * val, we will reach the starting id again. E.g. adding a nodeset will + * create children while there are still other nodes which need to be + * created. Thus the node ids may collide. */ + UA_UInt32 size = ns->size; + UA_UInt64 identifier = mod(50000 + size+1, UA_UINT32_MAX); /* Use 64bit to + * avoid overflow */ + UA_UInt32 increase = mod2(ns->count+1, size); + UA_UInt32 startId = (UA_UInt32)identifier; /* mod ensures us that the id + * is a valid 32 bit integer */ + + do { + node->head.nodeId.identifier.numeric = (UA_UInt32)identifier; + slot = findFreeSlot(ns, &node->head.nodeId); + if(slot) + break; + identifier += increase; + if(identifier >= size) + identifier -= size; +#if SIZE_MAX <= UA_UINT32_MAX + /* The compressed "immediate" representation of nodes does not + * support the full range on 32bit systems. Generate smaller + * identifiers as they can be stored more compactly. */ + if(identifier >= (0x01 << 24)) + identifier = identifier % (0x01 << 24); +#endif + } while((UA_UInt32)identifier != startId); + } else { + slot = findFreeSlot(ns, &node->head.nodeId); + } + + if(!slot) { + deleteNodeMapEntry(container_of(node, UA_NodeMapEntry, node)); + return UA_STATUSCODE_BADNODEIDEXISTS; + } + + /* Copy the NodeId */ + UA_StatusCode retval = UA_STATUSCODE_GOOD; + if(addedNodeId) { + retval = UA_NodeId_copy(&node->head.nodeId, addedNodeId); + if(retval != UA_STATUSCODE_GOOD) { + deleteNodeMapEntry(container_of(node, UA_NodeMapEntry, node)); + return retval; + } + } + + /* For new ReferencetypeNodes add to the index map */ + if(node->head.nodeClass == UA_NODECLASS_REFERENCETYPE) { + UA_ReferenceTypeNode *refNode = &node->referenceTypeNode; + if(ns->referenceTypeCounter >= UA_REFERENCETYPESET_MAX) { + deleteNodeMapEntry(container_of(node, UA_NodeMapEntry, node)); + return UA_STATUSCODE_BADINTERNALERROR; + } + + retval = UA_NodeId_copy(&node->head.nodeId, &ns->referenceTypeIds[ns->referenceTypeCounter]); + if(retval != UA_STATUSCODE_GOOD) { + deleteNodeMapEntry(container_of(node, UA_NodeMapEntry, node)); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Assign the ReferenceTypeIndex to the new ReferenceTypeNode */ + refNode->referenceTypeIndex = ns->referenceTypeCounter; + refNode->subTypes = UA_REFTYPESET(ns->referenceTypeCounter); + + ns->referenceTypeCounter++; + } + + /* Insert the node */ + UA_NodeMapEntry *newEntry = container_of(node, UA_NodeMapEntry, node); + slot->nodeIdHash = UA_NodeId_hash(&node->head.nodeId); + UA_atomic_sync(); /* Set the hash first */ + slot->entry = newEntry; + ++ns->count; + return retval; +} + +static UA_StatusCode +UA_NodeMap_replaceNode(void *context, UA_Node *node) { + UA_NodeMap *ns = (UA_NodeMap*)context; + UA_NodeMapEntry *newEntry = container_of(node, UA_NodeMapEntry, node); + + /* Find the node */ + UA_NodeMapSlot *slot = findOccupiedSlot(ns, &node->head.nodeId); + if(!slot) { + deleteNodeMapEntry(newEntry); + return UA_STATUSCODE_BADNODEIDUNKNOWN; + } + + /* The node was already updated since the copy was made? */ + UA_NodeMapEntry *oldEntry = slot->entry; + if(oldEntry != newEntry->orig) { + deleteNodeMapEntry(newEntry); + return UA_STATUSCODE_BADINTERNALERROR; + } + + /* Replace the entry */ + slot->entry = newEntry; + UA_atomic_sync(); + oldEntry->deleted = true; + cleanupNodeMapEntry(oldEntry); + return UA_STATUSCODE_GOOD; +} + +static const UA_NodeId * +UA_NodeMap_getReferenceTypeId(void *nsCtx, UA_Byte refTypeIndex) { + UA_NodeMap *ns = (UA_NodeMap*)nsCtx; + if(refTypeIndex > ns->referenceTypeCounter) + return NULL; + return &ns->referenceTypeIds[refTypeIndex]; +} + +static void +UA_NodeMap_iterate(void *context, UA_NodestoreVisitor visitor, + void *visitorContext) { + UA_NodeMap *ns = (UA_NodeMap*)context; + for(UA_UInt32 i = 0; i < ns->size; ++i) { + UA_NodeMapSlot *slot = &ns->slots[i]; + if(slot->entry > UA_NODEMAP_TOMBSTONE) { + /* The visitor can delete the node. So refcount here. */ + slot->entry->refCount++; + visitor(visitorContext, &slot->entry->node); + slot->entry->refCount--; + cleanupNodeMapEntry(slot->entry); + } + } +} + +static void +UA_NodeMap_delete(void *context) { + /* Already cleaned up? */ + if(!context) + return; + + UA_NodeMap *ns = (UA_NodeMap*)context; + UA_UInt32 size = ns->size; + UA_NodeMapSlot *slots = ns->slots; + for(UA_UInt32 i = 0; i < size; ++i) { + if(slots[i].entry > UA_NODEMAP_TOMBSTONE) { + /* On debugging builds, check that all nodes were release */ + UA_assert(slots[i].entry->refCount == 0); + /* Delete the node */ + deleteNodeMapEntry(slots[i].entry); + } + } + UA_free(ns->slots); + + /* Clean up the ReferenceTypes index array */ + for(size_t i = 0; i < ns->referenceTypeCounter; i++) + UA_NodeId_clear(&ns->referenceTypeIds[i]); + + UA_free(ns); +} + +UA_StatusCode +UA_Nodestore_HashMap(UA_Nodestore *ns) { + /* Allocate and initialize the nodemap */ + UA_NodeMap *nodemap = (UA_NodeMap*)UA_malloc(sizeof(UA_NodeMap)); + if(!nodemap) + return UA_STATUSCODE_BADOUTOFMEMORY; + nodemap->sizePrimeIndex = higher_prime_index(UA_NODEMAP_MINSIZE); + nodemap->size = primes[nodemap->sizePrimeIndex]; + nodemap->count = 0; + nodemap->slots = (UA_NodeMapSlot*) + UA_calloc(nodemap->size, sizeof(UA_NodeMapSlot)); + if(!nodemap->slots) { + UA_free(nodemap); + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + nodemap->referenceTypeCounter = 0; + + /* Populate the nodestore */ + ns->context = nodemap; + ns->clear = UA_NodeMap_delete; + ns->newNode = UA_NodeMap_newNode; + ns->deleteNode = UA_NodeMap_deleteNode; + ns->getNode = UA_NodeMap_getNode; + ns->releaseNode = UA_NodeMap_releaseNode; + ns->getNodeCopy = UA_NodeMap_getNodeCopy; + ns->insertNode = UA_NodeMap_insertNode; + ns->replaceNode = UA_NodeMap_replaceNode; + ns->removeNode = UA_NodeMap_removeNode; + ns->getReferenceTypeId = UA_NodeMap_getReferenceTypeId; + ns->iterate = UA_NodeMap_iterate; + return UA_STATUSCODE_GOOD; +} + +/**** amalgamated original file "/plugins/ua_config_default.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Julian Grothoff + * Copyright 2017-2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2018 (c) Daniel Feist, Precitec GmbH & Co. KG + * Copyright 2018 (c) Fabian Arndt, Root-Core + * Copyright 2019 (c) Kalycito Infotech Private Limited + * Copyright 2017-2020 (c) HMS Industrial Networks AB (Author: Jonas Green) + * Copyright 2020 (c) Wind River Systems, Inc. + */ + +#ifdef UA_ENABLE_WEBSOCKET_SERVER +#endif + +/* Struct initialization works across ANSI C/C99/C++ if it is done when the + * variable is first declared. Assigning values to existing structs is + * heterogeneous across the three. */ +static UA_INLINE UA_UInt32Range +UA_UINT32RANGE(UA_UInt32 min, UA_UInt32 max) { + UA_UInt32Range range = {min, max}; + return range; +} + +static UA_INLINE UA_DurationRange +UA_DURATIONRANGE(UA_Duration min, UA_Duration max) { + UA_DurationRange range = {min, max}; + return range; +} + +UA_Server * +UA_Server_new() { + UA_ServerConfig config; + memset(&config, 0, sizeof(UA_ServerConfig)); + /* Set a default logger and NodeStore for the initialization */ + config.logger = UA_Log_Stdout_; + if(UA_STATUSCODE_GOOD != UA_Nodestore_HashMap(&config.nodestore)) { + return NULL; + } + + return UA_Server_newWithConfig(&config); +} + +/*******************************/ +/* Default Connection Settings */ +/*******************************/ + +const UA_ConnectionConfig UA_ConnectionConfig_default = { + 0, /* .protocolVersion */ + 65535, /* .sendBufferSize, 64k per chunk */ + 65535, /* .recvBufferSize, 64k per chunk */ + 0, /* .localMaxMessageSize, 0 -> unlimited */ + 0, /* .remoteMaxMessageSize, 0 -> unlimited */ + 0, /* .localMaxChunkCount, 0 -> unlimited */ + 0 /* .remoteMaxChunkCount, 0 -> unlimited */ +}; + +/***************************/ +/* Default Server Settings */ +/***************************/ + +#define MANUFACTURER_NAME "open62541" +#define PRODUCT_NAME "open62541 OPC UA Server" +#define PRODUCT_URI "http://open62541.org" +#define APPLICATION_NAME "open62541-based OPC UA Application" +#define APPLICATION_URI "urn:unconfigured:application" +#define APPLICATION_URI_SERVER "urn:open62541.server.application" + +#define STRINGIFY(arg) #arg +#define VERSION(MAJOR, MINOR, PATCH, LABEL) \ + STRINGIFY(MAJOR) "." STRINGIFY(MINOR) "." STRINGIFY(PATCH) LABEL + +static UA_StatusCode +createEndpoint(UA_ServerConfig *conf, UA_EndpointDescription *endpoint, + const UA_SecurityPolicy *securityPolicy, + UA_MessageSecurityMode securityMode) { + UA_EndpointDescription_init(endpoint); + + endpoint->securityMode = securityMode; + UA_String_copy(&securityPolicy->policyUri, &endpoint->securityPolicyUri); + endpoint->transportProfileUri = + UA_STRING_ALLOC("http://opcfoundation.org/UA-Profile/Transport/uatcp-uasc-uabinary"); + + /* Add security level value for the corresponding message security mode */ + endpoint->securityLevel = (UA_Byte) securityMode; + + /* Enable all login mechanisms from the access control plugin */ + UA_StatusCode retval = UA_Array_copy(conf->accessControl.userTokenPolicies, + conf->accessControl.userTokenPoliciesSize, + (void **)&endpoint->userIdentityTokens, + &UA_TYPES[UA_TYPES_USERTOKENPOLICY]); + if(retval != UA_STATUSCODE_GOOD){ + UA_String_clear(&endpoint->securityPolicyUri); + UA_String_clear(&endpoint->transportProfileUri); + return retval; + } + endpoint->userIdentityTokensSize = conf->accessControl.userTokenPoliciesSize; + + UA_String_copy(&securityPolicy->localCertificate, &endpoint->serverCertificate); + UA_ApplicationDescription_copy(&conf->applicationDescription, &endpoint->server); + + return UA_STATUSCODE_GOOD; +} + +static const size_t usernamePasswordsSize = 2; +static UA_UsernamePasswordLogin usernamePasswords[2] = { + {UA_STRING_STATIC("user1"), UA_STRING_STATIC("password")}, + {UA_STRING_STATIC("user2"), UA_STRING_STATIC("password1")}}; + +static UA_StatusCode +setDefaultConfig(UA_ServerConfig *conf) { + if(!conf) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + if(conf->nodestore.context == NULL) + UA_Nodestore_HashMap(&conf->nodestore); + + /* --> Start setting the default static config <-- */ + /* Allow user to set his own logger */ + if(!conf->logger.log) + conf->logger = UA_Log_Stdout_; + + conf->shutdownDelay = 0.0; + + /* Server Description */ + UA_BuildInfo_clear(&conf->buildInfo); + conf->buildInfo.productUri = UA_STRING_ALLOC(PRODUCT_URI); + conf->buildInfo.manufacturerName = UA_STRING_ALLOC(MANUFACTURER_NAME); + conf->buildInfo.productName = UA_STRING_ALLOC(PRODUCT_NAME); + conf->buildInfo.softwareVersion = + UA_STRING_ALLOC(VERSION(UA_OPEN62541_VER_MAJOR, UA_OPEN62541_VER_MINOR, + UA_OPEN62541_VER_PATCH, UA_OPEN62541_VER_LABEL)); +#ifdef UA_PACK_DEBIAN + conf->buildInfo.buildNumber = UA_STRING_ALLOC("deb"); +#else + conf->buildInfo.buildNumber = UA_STRING_ALLOC(__DATE__ " " __TIME__); +#endif + conf->buildInfo.buildDate = UA_DateTime_now(); + + UA_ApplicationDescription_clear(&conf->applicationDescription); + conf->applicationDescription.applicationUri = UA_STRING_ALLOC(APPLICATION_URI_SERVER); + conf->applicationDescription.productUri = UA_STRING_ALLOC(PRODUCT_URI); + conf->applicationDescription.applicationName = + UA_LOCALIZEDTEXT_ALLOC("en", APPLICATION_NAME); + conf->applicationDescription.applicationType = UA_APPLICATIONTYPE_SERVER; + /* conf->applicationDescription.gatewayServerUri = UA_STRING_NULL; */ + /* conf->applicationDescription.discoveryProfileUri = UA_STRING_NULL; */ + /* conf->applicationDescription.discoveryUrlsSize = 0; */ + /* conf->applicationDescription.discoveryUrls = NULL; */ + +#ifdef UA_ENABLE_DISCOVERY_MULTICAST + UA_MdnsDiscoveryConfiguration_clear(&conf->mdnsConfig); + conf->mdnsInterfaceIP = UA_STRING_NULL; +# if !defined(UA_HAS_GETIFADDR) + conf->mdnsIpAddressList = NULL; + conf->mdnsIpAddressListSize = 0; +# endif +#endif + + /* Custom DataTypes */ + /* conf->customDataTypesSize = 0; */ + /* conf->customDataTypes = NULL; */ + + /* Networking */ + /* conf->networkLayersSize = 0; */ + /* conf->networkLayers = NULL; */ + /* conf->customHostname = UA_STRING_NULL; */ + + /* Endpoints */ + /* conf->endpoints = {0, NULL}; */ + + /* Certificate Verification that accepts every certificate. Can be + * overwritten when the policy is specialized. */ + UA_CertificateVerification_AcceptAll(&conf->certificateVerification); + + /* * Global Node Lifecycle * */ + /* conf->nodeLifecycle.constructor = NULL; */ + /* conf->nodeLifecycle.destructor = NULL; */ + /* conf->nodeLifecycle.createOptionalChild = NULL; */ + /* conf->nodeLifecycle.generateChildNodeId = NULL; */ + conf->modellingRulesOnInstances = UA_TRUE; + + /* Limits for SecureChannels */ + conf->maxSecureChannels = 40; + conf->maxSecurityTokenLifetime = 10 * 60 * 1000; /* 10 minutes */ + + /* Limits for Sessions */ + conf->maxSessions = 100; + conf->maxSessionTimeout = 60.0 * 60.0 * 1000.0; /* 1h */ + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* Limits for Subscriptions */ + conf->publishingIntervalLimits = UA_DURATIONRANGE(100.0, 3600.0 * 1000.0); + conf->lifeTimeCountLimits = UA_UINT32RANGE(3, 15000); + conf->keepAliveCountLimits = UA_UINT32RANGE(1, 100); + conf->maxNotificationsPerPublish = 1000; + conf->enableRetransmissionQueue = true; + conf->maxRetransmissionQueueSize = 0; /* unlimited */ +# ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + conf->maxEventsPerNode = 0; /* unlimited */ +# endif + + /* Limits for MonitoredItems */ + conf->samplingIntervalLimits = UA_DURATIONRANGE(50.0, 24.0 * 3600.0 * 1000.0); + conf->queueSizeLimits = UA_UINT32RANGE(1, 100); +#endif + +#ifdef UA_ENABLE_DISCOVERY + conf->discoveryCleanupTimeout = 60 * 60; +#endif + +#ifdef UA_ENABLE_HISTORIZING + /* conf->accessHistoryDataCapability = UA_FALSE; */ + /* conf->maxReturnDataValues = 0; */ + + /* conf->accessHistoryEventsCapability = UA_FALSE; */ + /* conf->maxReturnEventValues = 0; */ + + /* conf->insertDataCapability = UA_FALSE; */ + /* conf->insertEventCapability = UA_FALSE; */ + /* conf->insertAnnotationsCapability = UA_FALSE; */ + + /* conf->replaceDataCapability = UA_FALSE; */ + /* conf->replaceEventCapability = UA_FALSE; */ + + /* conf->updateDataCapability = UA_FALSE; */ + /* conf->updateEventCapability = UA_FALSE; */ + + /* conf->deleteRawCapability = UA_FALSE; */ + /* conf->deleteEventCapability = UA_FALSE; */ + /* conf->deleteAtTimeDataCapability = UA_FALSE; */ +#endif + +#if UA_MULTITHREADING >= 100 + conf->maxAsyncOperationQueueSize = 0; + conf->asyncOperationTimeout = 120000; /* Async Operation Timeout in ms (2 minutes) */ +#endif + + /* --> Finish setting the default static config <-- */ + + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_setBasics(UA_ServerConfig* conf) { + UA_StatusCode res = setDefaultConfig(conf); + UA_LOG_WARNING(&conf->logger, UA_LOGCATEGORY_USERLAND, + "AcceptAll Certificate Verification. " + "Any remote certificate will be accepted."); + return res; +} + +static UA_StatusCode +addDefaultNetworkLayers(UA_ServerConfig *conf, UA_UInt16 portNumber, + UA_UInt32 sendBufferSize, UA_UInt32 recvBufferSize) { + return UA_ServerConfig_addNetworkLayerTCP(conf, portNumber, sendBufferSize, recvBufferSize); +} + +#ifdef UA_ENABLE_WEBSOCKET_SERVER +UA_EXPORT UA_StatusCode +UA_ServerConfig_addNetworkLayerWS(UA_ServerConfig *conf, UA_UInt16 portNumber, + UA_UInt32 sendBufferSize, UA_UInt32 recvBufferSize, const UA_ByteString* certificate, const UA_ByteString* privateKey) { + /* Add a network layer */ + UA_ServerNetworkLayer *tmp = (UA_ServerNetworkLayer *) + UA_realloc(conf->networkLayers, + sizeof(UA_ServerNetworkLayer) * (1 + conf->networkLayersSize)); + if(!tmp) + return UA_STATUSCODE_BADOUTOFMEMORY; + conf->networkLayers = tmp; + + UA_ConnectionConfig config = UA_ConnectionConfig_default; + if(sendBufferSize > 0) + config.sendBufferSize = sendBufferSize; + if(recvBufferSize > 0) + config.recvBufferSize = recvBufferSize; + + conf->networkLayers[conf->networkLayersSize] = + UA_ServerNetworkLayerWS(config, portNumber, certificate, privateKey); + if(!conf->networkLayers[conf->networkLayersSize].handle) + return UA_STATUSCODE_BADOUTOFMEMORY; + conf->networkLayersSize++; + + return UA_STATUSCODE_GOOD; +} +#endif + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addNetworkLayerTCP(UA_ServerConfig *conf, UA_UInt16 portNumber, + UA_UInt32 sendBufferSize, UA_UInt32 recvBufferSize) { + /* Add a network layer */ + UA_ServerNetworkLayer *tmp = (UA_ServerNetworkLayer *) + UA_realloc(conf->networkLayers, + sizeof(UA_ServerNetworkLayer) * (1 + conf->networkLayersSize)); + if(!tmp) + return UA_STATUSCODE_BADOUTOFMEMORY; + conf->networkLayers = tmp; + + UA_ConnectionConfig config = UA_ConnectionConfig_default; + if (sendBufferSize > 0) + config.sendBufferSize = sendBufferSize; + if (recvBufferSize > 0) + config.recvBufferSize = recvBufferSize; + + conf->networkLayers[conf->networkLayersSize] = + UA_ServerNetworkLayerTCP(config, portNumber, 0); + if (!conf->networkLayers[conf->networkLayersSize].handle) + return UA_STATUSCODE_BADOUTOFMEMORY; + conf->networkLayersSize++; + + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyNone(UA_ServerConfig *config, + const UA_ByteString *certificate) { + /* Allocate the SecurityPolicies */ + UA_SecurityPolicy *tmp = (UA_SecurityPolicy *) + UA_realloc(config->securityPolicies, + sizeof(UA_SecurityPolicy) * (1 + config->securityPoliciesSize)); + if(!tmp) + return UA_STATUSCODE_BADOUTOFMEMORY; + config->securityPolicies = tmp; + + /* Populate the SecurityPolicies */ + UA_ByteString localCertificate = UA_BYTESTRING_NULL; + if(certificate) + localCertificate = *certificate; + UA_StatusCode retval = + UA_SecurityPolicy_None(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, &config->logger); + if(retval != UA_STATUSCODE_GOOD) { + if(config->securityPoliciesSize == 0) { + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + } + return retval; + } + + config->securityPoliciesSize++; + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addEndpoint(UA_ServerConfig *config, const UA_String securityPolicyUri, + UA_MessageSecurityMode securityMode) { + /* Allocate the endpoint */ + UA_EndpointDescription *tmp = (UA_EndpointDescription *) + UA_realloc(config->endpoints, + sizeof(UA_EndpointDescription) * (1 + config->endpointsSize)); + if(!tmp) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + config->endpoints = tmp; + + /* Lookup the security policy */ + const UA_SecurityPolicy *policy = NULL; + for (size_t i = 0; i < config->securityPoliciesSize; ++i) { + if (UA_String_equal(&securityPolicyUri, &config->securityPolicies[i].policyUri)) { + policy = &config->securityPolicies[i]; + break; + } + } + if (!policy) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + /* Populate the endpoint */ + UA_StatusCode retval = + createEndpoint(config, &config->endpoints[config->endpointsSize], + policy, securityMode); + if(retval != UA_STATUSCODE_GOOD) + return retval; + config->endpointsSize++; + + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addAllEndpoints(UA_ServerConfig *config) { + /* Allocate the endpoints */ + UA_EndpointDescription * tmp = (UA_EndpointDescription *) + UA_realloc(config->endpoints, + sizeof(UA_EndpointDescription) * + (2 * config->securityPoliciesSize + config->endpointsSize)); + if(!tmp) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + config->endpoints = tmp; + + /* Populate the endpoints */ + for(size_t i = 0; i < config->securityPoliciesSize; ++i) { + if(UA_String_equal(&UA_SECURITY_POLICY_NONE_URI, &config->securityPolicies[i].policyUri)) { + UA_StatusCode retval = + createEndpoint(config, &config->endpoints[config->endpointsSize], + &config->securityPolicies[i], UA_MESSAGESECURITYMODE_NONE); + if(retval != UA_STATUSCODE_GOOD) + return retval; + config->endpointsSize++; + } else { + UA_StatusCode retval = + createEndpoint(config, &config->endpoints[config->endpointsSize], + &config->securityPolicies[i], UA_MESSAGESECURITYMODE_SIGN); + if(retval != UA_STATUSCODE_GOOD) + return retval; + config->endpointsSize++; + + retval = createEndpoint(config, &config->endpoints[config->endpointsSize], + &config->securityPolicies[i], + UA_MESSAGESECURITYMODE_SIGNANDENCRYPT); + if(retval != UA_STATUSCODE_GOOD) + return retval; + config->endpointsSize++; + } + } + + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_setMinimalCustomBuffer(UA_ServerConfig *config, UA_UInt16 portNumber, + const UA_ByteString *certificate, + UA_UInt32 sendBufferSize, + UA_UInt32 recvBufferSize) { + if(!config) + return UA_STATUSCODE_BADINVALIDARGUMENT; + + UA_StatusCode retval = setDefaultConfig(config); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(config); + return retval; + } + + retval = addDefaultNetworkLayers(config, portNumber, sendBufferSize, recvBufferSize); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(config); + return retval; + } + + /* Allocate the SecurityPolicies */ + retval = UA_ServerConfig_addSecurityPolicyNone(config, certificate); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(config); + return retval; + } + + /* Initialize the Access Control plugin */ + retval = UA_AccessControl_default(config, true, NULL, + &config->securityPolicies[config->securityPoliciesSize-1].policyUri, + usernamePasswordsSize, usernamePasswords); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(config); + return retval; + } + + /* Allocate the endpoint */ + retval = UA_ServerConfig_addEndpoint(config, UA_SECURITY_POLICY_NONE_URI, + UA_MESSAGESECURITYMODE_NONE); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(config); + return retval; + } + + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "AcceptAll Certificate Verification. " + "Any remote certificate will be accepted."); + + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_ENCRYPTION + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyBasic128Rsa15(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey) { + /* Allocate the SecurityPolicies */ + UA_SecurityPolicy *tmp = (UA_SecurityPolicy *) + UA_realloc(config->securityPolicies, + sizeof(UA_SecurityPolicy) * (1 + config->securityPoliciesSize)); + if(!tmp) + return UA_STATUSCODE_BADOUTOFMEMORY; + config->securityPolicies = tmp; + + /* Populate the SecurityPolicies */ + UA_ByteString localCertificate = UA_BYTESTRING_NULL; + UA_ByteString localPrivateKey = UA_BYTESTRING_NULL; + if(certificate) + localCertificate = *certificate; + if(privateKey) + localPrivateKey = *privateKey; + UA_StatusCode retval = + UA_SecurityPolicy_Basic128Rsa15(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, localPrivateKey, &config->logger); + if(retval != UA_STATUSCODE_GOOD) { + if(config->securityPoliciesSize == 0) { + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + } + return retval; + } + + config->securityPoliciesSize++; + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyBasic256(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey) { + /* Allocate the SecurityPolicies */ + UA_SecurityPolicy *tmp = (UA_SecurityPolicy *) + UA_realloc(config->securityPolicies, + sizeof(UA_SecurityPolicy) * (1 + config->securityPoliciesSize)); + if(!tmp) + return UA_STATUSCODE_BADOUTOFMEMORY; + config->securityPolicies = tmp; + + /* Populate the SecurityPolicies */ + UA_ByteString localCertificate = UA_BYTESTRING_NULL; + UA_ByteString localPrivateKey = UA_BYTESTRING_NULL; + if(certificate) + localCertificate = *certificate; + if(privateKey) + localPrivateKey = *privateKey; + UA_StatusCode retval = + UA_SecurityPolicy_Basic256(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, localPrivateKey, &config->logger); + if(retval != UA_STATUSCODE_GOOD) { + if(config->securityPoliciesSize == 0) { + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + } + return retval; + } + + config->securityPoliciesSize++; + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyBasic256Sha256(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey) { + /* Allocate the SecurityPolicies */ + UA_SecurityPolicy *tmp = (UA_SecurityPolicy *) + UA_realloc(config->securityPolicies, + sizeof(UA_SecurityPolicy) * (1 + config->securityPoliciesSize)); + if(!tmp) + return UA_STATUSCODE_BADOUTOFMEMORY; + config->securityPolicies = tmp; + + /* Populate the SecurityPolicies */ + UA_ByteString localCertificate = UA_BYTESTRING_NULL; + UA_ByteString localPrivateKey = UA_BYTESTRING_NULL; + if(certificate) + localCertificate = *certificate; + if(privateKey) + localPrivateKey = *privateKey; + UA_StatusCode retval = + UA_SecurityPolicy_Basic256Sha256(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, localPrivateKey, &config->logger); + if(retval != UA_STATUSCODE_GOOD) { + if(config->securityPoliciesSize == 0) { + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + } + return retval; + } + + config->securityPoliciesSize++; + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyAes128Sha256RsaOaep(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey) { + /* Allocate the SecurityPolicies */ + UA_SecurityPolicy *tmp = (UA_SecurityPolicy *) + UA_realloc(config->securityPolicies, + sizeof(UA_SecurityPolicy) * (1 + config->securityPoliciesSize)); + if(!tmp) + return UA_STATUSCODE_BADOUTOFMEMORY; + config->securityPolicies = tmp; + + /* Populate the SecurityPolicies */ + UA_ByteString localCertificate = UA_BYTESTRING_NULL; + UA_ByteString localPrivateKey = UA_BYTESTRING_NULL; + if(certificate) + localCertificate = *certificate; + if(privateKey) + localPrivateKey = *privateKey; + UA_StatusCode retval = + UA_SecurityPolicy_Aes128Sha256RsaOaep(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, localPrivateKey, &config->logger); + if(retval != UA_STATUSCODE_GOOD) { + if(config->securityPoliciesSize == 0) { + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + } + return retval; + } + + config->securityPoliciesSize++; + return UA_STATUSCODE_GOOD; +} + +/* Always returns UA_STATUSCODE_GOOD. Logs a warning if policies could not be added. */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addAllSecurityPolicies(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey) { + /* Populate the SecurityPolicies */ + UA_ByteString localCertificate = UA_BYTESTRING_NULL; + UA_ByteString localPrivateKey = UA_BYTESTRING_NULL; + if(certificate) + localCertificate = *certificate; + if(privateKey) + localPrivateKey = *privateKey; + + UA_StatusCode retval = UA_ServerConfig_addSecurityPolicyNone(config, &localCertificate); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#None with error code %s", + UA_StatusCode_name(retval)); + } + + retval = UA_ServerConfig_addSecurityPolicyBasic128Rsa15(config, &localCertificate, &localPrivateKey); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Basic128Rsa15 with error code %s", + UA_StatusCode_name(retval)); + } + + retval = UA_ServerConfig_addSecurityPolicyBasic256(config, &localCertificate, &localPrivateKey); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Basic256 with error code %s", + UA_StatusCode_name(retval)); + } + + retval = UA_ServerConfig_addSecurityPolicyBasic256Sha256(config, &localCertificate, &localPrivateKey); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Basic256Sha256 with error code %s", + UA_StatusCode_name(retval)); + } + + retval = UA_ServerConfig_addSecurityPolicyAes128Sha256RsaOaep(config, &localCertificate, &localPrivateKey); + if(retval != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Aes128Sha256RsaOaep with error code %s", + UA_StatusCode_name(retval)); + } + + return UA_STATUSCODE_GOOD; +} + +UA_EXPORT UA_StatusCode +UA_ServerConfig_setDefaultWithSecurityPolicies(UA_ServerConfig *conf, + UA_UInt16 portNumber, + const UA_ByteString *certificate, + const UA_ByteString *privateKey, + const UA_ByteString *trustList, + size_t trustListSize, + const UA_ByteString *issuerList, + size_t issuerListSize, + const UA_ByteString *revocationList, + size_t revocationListSize) { + UA_StatusCode retval = setDefaultConfig(conf); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(conf); + return retval; + } + + retval = UA_CertificateVerification_Trustlist(&conf->certificateVerification, + trustList, trustListSize, + issuerList, issuerListSize, + revocationList, revocationListSize); + if (retval != UA_STATUSCODE_GOOD) + return retval; + + retval = addDefaultNetworkLayers(conf, portNumber, 0, 0); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(conf); + return retval; + } + + retval = UA_ServerConfig_addAllSecurityPolicies(conf, certificate, privateKey); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(conf); + return retval; + } + + UA_CertificateVerification accessControlVerification; + retval = UA_CertificateVerification_Trustlist(&accessControlVerification, + trustList, trustListSize, + issuerList, issuerListSize, + revocationList, revocationListSize); + retval |= UA_AccessControl_default(conf, true, &accessControlVerification, + &conf->securityPolicies[conf->securityPoliciesSize-1].policyUri, + usernamePasswordsSize, usernamePasswords); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(conf); + return retval; + } + + retval = UA_ServerConfig_addAllEndpoints(conf); + if(retval != UA_STATUSCODE_GOOD) { + UA_ServerConfig_clean(conf); + return retval; + } + + return UA_STATUSCODE_GOOD; +} + +#endif + +/***************************/ +/* Default Client Settings */ +/***************************/ + +UA_Client * UA_Client_new() { + UA_ClientConfig config; + memset(&config, 0, sizeof(UA_ClientConfig)); + config.logger.log = UA_Log_Stdout_log; + config.logger.context = NULL; + config.logger.clear = UA_Log_Stdout_clear; + return UA_Client_newWithConfig(&config); +} + +UA_StatusCode +UA_ClientConfig_setDefault(UA_ClientConfig *config) { + config->timeout = 5000; + config->secureChannelLifeTime = 10 * 60 * 1000; /* 10 minutes */ + + if(!config->logger.log) { + config->logger.log = UA_Log_Stdout_log; + config->logger.context = NULL; + config->logger.clear = UA_Log_Stdout_clear; + } + + if (config->sessionLocaleIdsSize > 0 && config->sessionLocaleIds) { + UA_Array_delete(config->sessionLocaleIds, config->sessionLocaleIdsSize, &UA_TYPES[UA_TYPES_LOCALEID]); + } + config->sessionLocaleIds = NULL; + config->sessionLocaleIds = 0; + + config->localConnectionConfig = UA_ConnectionConfig_default; + + /* Certificate Verification that accepts every certificate. Can be + * overwritten when the policy is specialized. */ + UA_CertificateVerification_AcceptAll(&config->certificateVerification); + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "AcceptAll Certificate Verification. " + "Any remote certificate will be accepted."); + + /* With encryption enabled, the applicationUri needs to match the URI from + * the certificate */ + config->clientDescription.applicationUri = UA_STRING_ALLOC(APPLICATION_URI); + config->clientDescription.applicationType = UA_APPLICATIONTYPE_CLIENT; + + if(config->securityPoliciesSize > 0) { + UA_LOG_ERROR(&config->logger, UA_LOGCATEGORY_NETWORK, + "Could not initialize a config that already has SecurityPolicies"); + return UA_STATUSCODE_BADINTERNALERROR; + } + + config->securityPolicies = (UA_SecurityPolicy*)UA_malloc(sizeof(UA_SecurityPolicy)); + if(!config->securityPolicies) + return UA_STATUSCODE_BADOUTOFMEMORY; + UA_StatusCode retval = UA_SecurityPolicy_None(config->securityPolicies, + UA_BYTESTRING_NULL, &config->logger); + if(retval != UA_STATUSCODE_GOOD) { + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + return retval; + } + config->securityPoliciesSize = 1; + + config->initConnectionFunc = UA_ClientConnectionTCP_init; /* for async client */ + config->pollConnectionFunc = UA_ClientConnectionTCP_poll; /* for async connection */ + + config->customDataTypes = NULL; + config->stateCallback = NULL; + config->connectivityCheckInterval = 0; + + config->requestedSessionTimeout = 1200000; /* requestedSessionTimeout */ + + config->inactivityCallback = NULL; + config->clientContext = NULL; + +#ifdef UA_ENABLE_SUBSCRIPTIONS + config->outStandingPublishRequests = 10; + config->subscriptionInactivityCallback = NULL; +#endif + + return UA_STATUSCODE_GOOD; +} + +#ifdef UA_ENABLE_ENCRYPTION +UA_StatusCode +UA_ClientConfig_setDefaultEncryption(UA_ClientConfig *config, + UA_ByteString localCertificate, UA_ByteString privateKey, + const UA_ByteString *trustList, size_t trustListSize, + const UA_ByteString *revocationList, size_t revocationListSize) { + UA_StatusCode retval = UA_ClientConfig_setDefault(config); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + retval = UA_CertificateVerification_Trustlist(&config->certificateVerification, + trustList, trustListSize, + NULL, 0, + revocationList, revocationListSize); + if(retval != UA_STATUSCODE_GOOD) + return retval; + + /* Populate SecurityPolicies */ + UA_SecurityPolicy *sp = (UA_SecurityPolicy*) + UA_realloc(config->securityPolicies, sizeof(UA_SecurityPolicy) * 5); + if(!sp) + return UA_STATUSCODE_BADOUTOFMEMORY; + config->securityPolicies = sp; + + retval = UA_SecurityPolicy_Basic128Rsa15(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, privateKey, &config->logger); + if(retval == UA_STATUSCODE_GOOD) { + ++config->securityPoliciesSize; + } else { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Basic128Rsa15 with error code %s", + UA_StatusCode_name(retval)); + } + + retval = UA_SecurityPolicy_Basic256(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, privateKey, &config->logger); + if(retval == UA_STATUSCODE_GOOD) { + ++config->securityPoliciesSize; + } else { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Basic256 with error code %s", + UA_StatusCode_name(retval)); + } + + retval = UA_SecurityPolicy_Basic256Sha256(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, privateKey, &config->logger); + if(retval == UA_STATUSCODE_GOOD) { + ++config->securityPoliciesSize; + } else { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Basic256Sha256 with error code %s", + UA_StatusCode_name(retval)); + } + + retval = UA_SecurityPolicy_Aes128Sha256RsaOaep(&config->securityPolicies[config->securityPoliciesSize], + localCertificate, privateKey, &config->logger); + if(retval == UA_STATUSCODE_GOOD) { + ++config->securityPoliciesSize; + } else { + UA_LOG_WARNING(&config->logger, UA_LOGCATEGORY_USERLAND, + "Could not add SecurityPolicy#Aes128Sha256RsaOaep with error code %s", + UA_StatusCode_name(retval)); + } + + if(config->securityPoliciesSize == 0) { + UA_free(config->securityPolicies); + config->securityPolicies = NULL; + } + + return UA_STATUSCODE_GOOD; +} +#endif + +/**** amalgamated original file "/plugins/crypto/ua_pki_none.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2020 (c) Julius Pfrommer, Fraunhofer IOSB + */ + + +static UA_StatusCode +verifyCertificateAllowAll(void *verificationContext, + const UA_ByteString *certificate) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +verifyApplicationURIAllowAll(void *verificationContext, + const UA_ByteString *certificate, + const UA_String *applicationURI) { + return UA_STATUSCODE_GOOD; +} + +static void +clearVerifyAllowAll(UA_CertificateVerification *cv) { + +} + +void UA_CertificateVerification_AcceptAll(UA_CertificateVerification *cv) { + cv->verifyCertificate = verifyCertificateAllowAll; + cv->verifyApplicationURI = verifyApplicationURIAllowAll; + cv->clear = clearVerifyAllowAll; +} + +/**** amalgamated original file "/plugins/crypto/ua_securitypolicy_none.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2017-2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + +#ifdef UA_ENABLE_ENCRYPTION_MBEDTLS +#endif + +#if defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) +#endif + +static UA_StatusCode +verify_none(void *channelContext, + const UA_ByteString *message, + const UA_ByteString *signature) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +sign_none(void *channelContext, const UA_ByteString *message, + UA_ByteString *signature) { + return UA_STATUSCODE_GOOD; +} + +static size_t +length_none(const void *channelContext) { + return 0; +} + +static UA_StatusCode +encrypt_none(void *channelContext, UA_ByteString *data) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +decrypt_none(void *channelContext, UA_ByteString *data) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +makeThumbprint_none(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificate, + UA_ByteString *thumbprint) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +compareThumbprint_none(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificateThumbprint) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +generateKey_none(void *policyContext, const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) { + return UA_STATUSCODE_GOOD; +} + +/* Use the non-cryptographic RNG to set the nonce */ +static UA_StatusCode +generateNonce_none(void *policyContext, UA_ByteString *out) { + if(out == NULL) + return UA_STATUSCODE_BADINTERNALERROR; + + if(out->length == 0) + return UA_STATUSCODE_GOOD; + + /* Fill blocks of four byte */ + size_t i = 0; + while(i + 3 < out->length) { + UA_UInt32 randNumber = UA_UInt32_random(); + memcpy(&out->data[i], &randNumber, 4); + i = i+4; + } + + /* Fill the remaining byte */ + UA_UInt32 randNumber = UA_UInt32_random(); + memcpy(&out->data[i], &randNumber, out->length % 4); + + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +newContext_none(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate, + void **channelContext) { + return UA_STATUSCODE_GOOD; +} + +static void +deleteContext_none(void *channelContext) { +} + +static UA_StatusCode +setContextValue_none(void *channelContext, + const UA_ByteString *key) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +compareCertificate_none(const void *channelContext, + const UA_ByteString *certificate) { + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +updateCertificateAndPrivateKey_none(UA_SecurityPolicy *policy, + const UA_ByteString newCertificate, + const UA_ByteString newPrivateKey) { + UA_ByteString_clear(&policy->localCertificate); + UA_ByteString_copy(&newCertificate, &policy->localCertificate); + return UA_STATUSCODE_GOOD; +} + + +static void +policy_clear_none(UA_SecurityPolicy *policy) { + UA_ByteString_clear(&policy->localCertificate); +} + +UA_StatusCode +UA_SecurityPolicy_None(UA_SecurityPolicy *policy, const UA_ByteString localCertificate, + const UA_Logger *logger) { + policy->policyContext = (void *)(uintptr_t)logger; + policy->policyUri = UA_STRING("http://opcfoundation.org/UA/SecurityPolicy#None"); + policy->logger = logger; + +#ifdef UA_ENABLE_ENCRYPTION_MBEDTLS + UA_mbedTLS_LoadLocalCertificate(&localCertificate, &policy->localCertificate); +#elif defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) + UA_OpenSSL_LoadLocalCertificate(&localCertificate, &policy->localCertificate); +#else + UA_ByteString_copy(&localCertificate, &policy->localCertificate); +#endif + + policy->symmetricModule.generateKey = generateKey_none; + policy->symmetricModule.generateNonce = generateNonce_none; + + UA_SecurityPolicySignatureAlgorithm *sym_signatureAlgorithm = + &policy->symmetricModule.cryptoModule.signatureAlgorithm; + sym_signatureAlgorithm->uri = UA_STRING_NULL; + sym_signatureAlgorithm->verify = verify_none; + sym_signatureAlgorithm->sign = sign_none; + sym_signatureAlgorithm->getLocalSignatureSize = length_none; + sym_signatureAlgorithm->getRemoteSignatureSize = length_none; + sym_signatureAlgorithm->getLocalKeyLength = length_none; + sym_signatureAlgorithm->getRemoteKeyLength = length_none; + + UA_SecurityPolicyEncryptionAlgorithm *sym_encryptionAlgorithm = + &policy->symmetricModule.cryptoModule.encryptionAlgorithm; + sym_encryptionAlgorithm->uri = UA_STRING_NULL; + sym_encryptionAlgorithm->encrypt = encrypt_none; + sym_encryptionAlgorithm->decrypt = decrypt_none; + sym_encryptionAlgorithm->getLocalKeyLength = length_none; + sym_encryptionAlgorithm->getRemoteKeyLength = length_none; + sym_encryptionAlgorithm->getRemoteBlockSize = length_none; + sym_encryptionAlgorithm->getRemotePlainTextBlockSize = length_none; + policy->symmetricModule.secureChannelNonceLength = 0; + + policy->asymmetricModule.makeCertificateThumbprint = makeThumbprint_none; + policy->asymmetricModule.compareCertificateThumbprint = compareThumbprint_none; + + // This only works for none since symmetric and asymmetric crypto modules do the same i.e. nothing + policy->asymmetricModule.cryptoModule = policy->symmetricModule.cryptoModule; + + // Use the same signing algorithm as for asymmetric signing + policy->certificateSigningAlgorithm = policy->asymmetricModule.cryptoModule.signatureAlgorithm; + + policy->channelModule.newContext = newContext_none; + policy->channelModule.deleteContext = deleteContext_none; + policy->channelModule.setLocalSymEncryptingKey = setContextValue_none; + policy->channelModule.setLocalSymSigningKey = setContextValue_none; + policy->channelModule.setLocalSymIv = setContextValue_none; + policy->channelModule.setRemoteSymEncryptingKey = setContextValue_none; + policy->channelModule.setRemoteSymSigningKey = setContextValue_none; + policy->channelModule.setRemoteSymIv = setContextValue_none; + policy->channelModule.compareCertificate = compareCertificate_none; + policy->updateCertificateAndPrivateKey = updateCertificateAndPrivateKey_none; + policy->clear = policy_clear_none; + + return UA_STATUSCODE_GOOD; +} + +/**** amalgamated original file "/plugins/ua_log_syslog.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + +#if defined(__linux__) || defined(__unix__) + +#include + +const char *syslogLevelNames[6] = {"trace", "debug", "info", + "warn", "error", "fatal"}; +const char *syslogCategoryNames[7] = {"network", "channel", "session", "server", + "client", "userland", "securitypolicy"}; + +#ifdef __clang__ +__attribute__((__format__(__printf__, 4 , 0))) +#endif +static void +UA_Log_Syslog_log(void *context, UA_LogLevel level, UA_LogCategory category, + const char *msg, va_list args) { + /* Assume that context is casted to UA_LogLevel */ + if(context != NULL && (UA_LogLevel)(uintptr_t)context > level) + return; + + int priority = LOG_INFO; + switch(level) { + case UA_LOGLEVEL_DEBUG: + priority = LOG_DEBUG; + break; + case UA_LOGLEVEL_INFO: + priority = LOG_INFO; + break; + case UA_LOGLEVEL_WARNING: + priority = LOG_WARNING; + break; + case UA_LOGLEVEL_ERROR: + priority = LOG_ERR; + break; + case UA_LOGLEVEL_FATAL: + priority = LOG_CRIT; + break; + case UA_LOGLEVEL_TRACE: + default: + return; + } + +#define LOGBUFSIZE 512 + char logbuf[LOGBUFSIZE]; + int pos = snprintf(logbuf, LOGBUFSIZE, "[%s/%s] ", + syslogLevelNames[level], syslogCategoryNames[category]); + if(pos < 0) { + syslog(LOG_WARNING, "Log message too long for syslog"); + return; + } + pos = vsnprintf(&logbuf[pos], LOGBUFSIZE - (size_t)pos, msg, args); + if(pos < 0) { + syslog(LOG_WARNING, "Log message too long for syslog"); + return; + } + + syslog(priority, "%s", logbuf); +} + +static void +UA_Log_Syslog_clear(void *logContext) { + /* closelog is optional. We don't use it as several loggers might be + * instantiated in parallel. */ + /* closelog(); */ +} + +UA_Logger +UA_Log_Syslog(void) { + return UA_Log_Syslog_withLevel(UA_LOGLEVEL_TRACE); +} + +UA_Logger +UA_Log_Syslog_withLevel(UA_LogLevel minlevel) { + UA_Logger logger = {UA_Log_Syslog_log, (void*)minlevel, UA_Log_Syslog_clear}; + return logger; +} + +#endif + +/**** amalgamated original file "/arch/freertosLWIP/ua_clock.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016-2017 (c) Julius Pfrommer, Fraunhofer IOSB + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Thomas Stalder + * Copyright 2021 (c) Simon Kueppers, 2pi-Labs GmbH + */ + +#ifdef UA_ARCHITECTURE_FREERTOSLWIP + +#include "xs_ktick.h" +#define configTICK_RATE_HZ TICK_PER_SECOND +#define xTaskGetTickCount CurrentTicksGain + +#define EHOSTUNREACH 113 /* No route to host */ +#define EINPROGRESS 115 /* Operation now in progress */ +#define EADDRINUSE 98 /* Address already in use */ +#define EALREADY 114 /* Operation already in progress */ +#define EISCONN 106 /* Transport endpoint is already connected */ +#define ENOTCONN 107 /* Transport endpoint is not connected */ +#define ECONNABORTED 103 /* Software caused connection abort */ + +#ifdef UA_ARCHITECTURE_FREERTOSLWIP_POSIX_CLOCK + +UA_DateTime UA_DateTime_now(void) { + struct timeval tv; + gettimeofday(&tv, NULL); + return (tv.tv_sec * UA_DATETIME_SEC) + (tv.tv_usec * UA_DATETIME_USEC) + UA_DATETIME_UNIX_EPOCH; +} + +/* Credit to https://stackoverflow.com/questions/13804095/get-the-time-zone-gmt-offset-in-c */ +UA_Int64 UA_DateTime_localTimeUtcOffset(void) { + time_t gmt, rawtime = time(NULL); + struct tm *ptm; + struct tm gbuf; + ptm = gmtime_r(&rawtime, &gbuf); + // Request that mktime() looksup dst in timezone database + ptm->tm_isdst = -1; + gmt = mktime(ptm); + return (UA_Int64) (difftime(rawtime, gmt) * UA_DATETIME_SEC); +} + +#else /* UA_ARCHITECTURE_FREERTOSLWIP_POSIX_CLOCK */ + +/* The current time in UTC time */ +UA_DateTime UA_DateTime_now(void) { + UA_DateTime microSeconds = ((UA_DateTime)xTaskGetTickCount()) * (1000000 / configTICK_RATE_HZ); + return ((microSeconds / 1000000) * UA_DATETIME_SEC) + ((microSeconds % 1000000) * UA_DATETIME_USEC) + UA_DATETIME_UNIX_EPOCH; +} + +/* Offset between local time and UTC time */ +UA_Int64 UA_DateTime_localTimeUtcOffset(void) { + return 0; //TODO: this is set to zero since UA_DateTime_now() is just the local time, and not UTC. +} + +#endif /* UA_ARCHITECTURE_FREERTOSLWIP_POSIX_CLOCK */ + +/* CPU clock invariant to system time changes. Use only to measure durations, + * not absolute time. */ +UA_DateTime UA_DateTime_nowMonotonic(void) { + return (((UA_DateTime)xTaskGetTickCount()) * 1000 / configTICK_RATE_HZ) * UA_DATETIME_MSEC; +} + +#endif /* UA_ARCHITECTURE_FREERTOSLWIP */ + +/**** amalgamated original file "/arch/freertosLWIP/ua_architecture_functions.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2018 (c) Jose Cabral, fortiss GmbH + * Copyright 2018 (c) Stefan Profanter, fortiss GmbH + * Copyright 2021 (c) Simon Kueppers, 2pi-Labs GmbH + */ + +#ifdef UA_ARCHITECTURE_FREERTOSLWIP + + +unsigned int UA_socket_set_blocking(UA_SOCKET sockfd){ + int on = 0; + if(lwip_ioctl(sockfd, FIONBIO, &on) < 0) + return UA_STATUSCODE_BADINTERNALERROR; + return UA_STATUSCODE_GOOD; +} + +unsigned int UA_socket_set_nonblocking(UA_SOCKET sockfd){ + int on = 1; + if(lwip_ioctl(sockfd, FIONBIO, &on) < 0) + return UA_STATUSCODE_BADINTERNALERROR; + return UA_STATUSCODE_GOOD; +} + +int gethostname_lwip(char* name, size_t len){ + /* gethostname() returns the null-terminated hostname in the + * character array name, which has a length of len bytes. If the + * null-terminated hostname is too large to fit, then the name is + * truncated, and no error is returned (but see NOTES below). + */ +#if LWIP_NETIF_HOSTNAME + if ( (netif_default != NULL) && (netif_get_hostname(netif_default) != NULL) ) { + /* LWIP has one hostname per netif. However majority of embedded systems using LWIP + * use a single netif anyway (LWIP_SINGLE_NETIF). + * Use the default netif for retrieving hostname. */ + const char * hostname = netif_get_hostname(netif_default); + int result = 0; + +#if LWIP_TCPIP_CORE_LOCKING + /* Lock TCP/IP thread */ + LOCK_TCPIP_CORE(); +#endif + /* The GNU C library does not employ the gethostname() system call; + * instead, it implements gethostname() as a library function that + * calls uname(2) and copies up to len bytes from the returned + * nodename field into name. Having performed the copy, the + * function then checks if the length of the nodename was greater + * than or equal to len, and if it is, then the function returns -1 + * with errno set to ENAMETOOLONG; in this case, a terminating null + * byte is not included in the returned name. */ + strncpy(name, hostname, len); + + if (strlen(hostname) >= len) { + /* Error ENAMETOOLONG, hostname is larger than given buffer */ + result = -1; + } + +#if LWIP_TCPIP_CORE_LOCKING + /* Unlock TCP/IP thread */ + UNLOCK_TCPIP_CORE(); +#endif + + return result; + } +#endif /* LWIP_NETIF_HOSTNAME */ + + /* No valid hostname, due to one of the following + * 1. LWIP_NETIF_HOSTNAME not defined + * 2. no default netif set + * 3. no hostname on default netif set. + * use UA_ServerConfig_set_customHostname to set your hostname as the IP manually */ + return -1; +} + +void UA_initialize_architecture_network(void){ + return; +} + +void UA_deinitialize_architecture_network(void){ + return; +} + +#if UA_IPV6 +# if LWIP_VERSION_IS_RELEASE //lwip_if_nametoindex is not yet released +unsigned int lwip_if_nametoindex(const char *ifname){ + return 1; //TODO: assume for now that it only has one interface +} +# endif //LWIP_VERSION_IS_RELEASE +#endif //UA_IPV6 + +#endif /* UA_ARCHITECTURE_FREERTOSLWIP */ + +/**** amalgamated original file "/arch/network_tcp.c" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) frax2222 + * Copyright 2017 (c) Jose Cabral + * Copyright 2017 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2020 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + +#define UA_INTERNAL + + + +#include // memset + +#ifndef MSG_NOSIGNAL +#define MSG_NOSIGNAL 0 +#endif + +/****************************/ +/* Generic Socket Functions */ +/****************************/ + +static UA_StatusCode +connection_getsendbuffer(UA_Connection *connection, + size_t length, UA_ByteString *buf) { + UA_SecureChannel *channel = connection->channel; + if(channel && channel->config.sendBufferSize < length) + return UA_STATUSCODE_BADCOMMUNICATIONERROR; + return UA_ByteString_allocBuffer(buf, length); +} + +static void +connection_releasesendbuffer(UA_Connection *connection, + UA_ByteString *buf) { + UA_ByteString_clear(buf); +} + +static void +connection_releaserecvbuffer(UA_Connection *connection, + UA_ByteString *buf) { + UA_ByteString_clear(buf); +} + +static UA_StatusCode +connection_write(UA_Connection *connection, UA_ByteString *buf) { + if(connection->state == UA_CONNECTIONSTATE_CLOSED) { + UA_ByteString_clear(buf); + return UA_STATUSCODE_BADCONNECTIONCLOSED; + } + + /* Prevent OS signals when sending to a closed socket */ + int flags = 0; + flags |= MSG_NOSIGNAL; + + /* Send the full buffer. This may require several calls to send */ + size_t nWritten = 0; + do { + ssize_t n = 0; + do { + size_t bytes_to_send = buf->length - nWritten; + n = UA_send(connection->sockfd, + (const char*)buf->data + nWritten, + bytes_to_send, flags); + if(n < 0 && UA_ERRNO != UA_INTERRUPTED && UA_ERRNO != UA_AGAIN) { + connection->ua_close(connection); + UA_ByteString_clear(buf); + return UA_STATUSCODE_BADCONNECTIONCLOSED; + } + } while(n < 0); + nWritten += (size_t)n; + } while(nWritten < buf->length); + + /* Free the buffer */ + UA_ByteString_clear(buf); + return UA_STATUSCODE_GOOD; +} + +static UA_StatusCode +connection_recv(UA_Connection *connection, UA_ByteString *response, + UA_UInt32 timeout) { + if(connection->state == UA_CONNECTIONSTATE_CLOSED) + return UA_STATUSCODE_BADCONNECTIONCLOSED; + + /* Listen on the socket for the given timeout until a message arrives */ + fd_set fdset; + FD_ZERO(&fdset); + UA_fd_set(connection->sockfd, &fdset); + UA_UInt32 timeout_usec = timeout * 1000; + struct timeval tmptv = {(long int)(timeout_usec / 1000000), + (int)(timeout_usec % 1000000)}; + int resultsize = UA_select(connection->sockfd+1, &fdset, NULL, NULL, &tmptv); + + /* No result */ + if(resultsize == 0) + return UA_STATUSCODE_GOODNONCRITICALTIMEOUT; + + if(resultsize == -1) { + /* The call to select was interrupted. Act as if it timed out. */ + if(UA_ERRNO == UA_INTERRUPTED) + return UA_STATUSCODE_GOODNONCRITICALTIMEOUT; + + /* The error cannot be recovered. Close the connection. */ + connection->ua_close(connection); + return UA_STATUSCODE_BADCONNECTIONCLOSED; + } + + UA_Boolean internallyAllocated = !response->length; + + /* Allocate the buffer */ + if(internallyAllocated) { + size_t bufferSize = 16384; /* Use as default for a new SecureChannel */ + UA_SecureChannel *channel = connection->channel; + if(channel && channel->config.recvBufferSize > 0) + bufferSize = channel->config.recvBufferSize; + UA_StatusCode res = UA_ByteString_allocBuffer(response, bufferSize); + if(res != UA_STATUSCODE_GOOD) + return res; + } + + /* Get the received packet(s) */ + ssize_t ret = UA_recv(connection->sockfd, (char*)response->data, response->length, 0); + + /* The remote side closed the connection */ + if(ret == 0) { + if(internallyAllocated) + UA_ByteString_clear(response); + connection->ua_close(connection); + return UA_STATUSCODE_BADCONNECTIONCLOSED; + } + + /* Error case */ + if(ret < 0) { + if(internallyAllocated) + UA_ByteString_clear(response); + if(UA_ERRNO == UA_INTERRUPTED || (timeout > 0) ? + false : (UA_ERRNO == UA_EAGAIN || UA_ERRNO == UA_WOULDBLOCK)) + return UA_STATUSCODE_GOOD; /* statuscode_good but no data -> retry */ + connection->ua_close(connection); + return UA_STATUSCODE_BADCONNECTIONCLOSED; + } + + /* Set the length of the received buffer */ + response->length = (size_t)ret; + return UA_STATUSCODE_GOOD; +} + + +/***************************/ +/* Server NetworkLayer TCP */ +/***************************/ + +#define MAXBACKLOG 100 +#define NOHELLOTIMEOUT 120000 /* timeout in ms before close the connection + * if server does not receive Hello Message */ + +typedef struct ConnectionEntry { + UA_Connection connection; + LIST_ENTRY(ConnectionEntry) pointers; +} ConnectionEntry; + +typedef struct { + const UA_Logger *logger; + UA_UInt16 port; + UA_UInt16 maxConnections; + UA_SOCKET serverSockets[FD_SETSIZE]; + UA_UInt16 serverSocketsSize; + LIST_HEAD(, ConnectionEntry) connections; + UA_UInt16 connectionsSize; +} ServerNetworkLayerTCP; + +static void +ServerNetworkLayerTCP_freeConnection(UA_Connection *connection) { + UA_free(connection); +} + +/* This performs only 'shutdown'. 'close' is called when the shutdown + * socket is returned from select. */ +static void +ServerNetworkLayerTCP_close(UA_Connection *connection) { + if(connection->state == UA_CONNECTIONSTATE_CLOSED) + return; + UA_shutdown((UA_SOCKET)connection->sockfd, 2); + connection->state = UA_CONNECTIONSTATE_CLOSED; +} + +static UA_Boolean +purgeFirstConnectionWithoutChannel(ServerNetworkLayerTCP *layer) { + ConnectionEntry *e; + LIST_FOREACH(e, &layer->connections, pointers) { + if(e->connection.channel == NULL) { + LIST_REMOVE(e, pointers); + layer->connectionsSize--; + UA_close(e->connection.sockfd); + e->connection.free(&e->connection); + return true; + } + } + return false; +} + +static UA_StatusCode +ServerNetworkLayerTCP_add(UA_ServerNetworkLayer *nl, ServerNetworkLayerTCP *layer, + UA_Int32 newsockfd, struct sockaddr_storage *remote) { + if(layer->maxConnections && layer->connectionsSize >= layer->maxConnections && + !purgeFirstConnectionWithoutChannel(layer)) { + return UA_STATUSCODE_BADTCPNOTENOUGHRESOURCES; + } + + /* Set nonblocking */ + UA_socket_set_nonblocking(newsockfd);//TODO: check return value + + /* Do not merge packets on the socket (disable Nagle's algorithm) */ + int dummy = 1; + if(UA_setsockopt(newsockfd, IPPROTO_TCP, TCP_NODELAY, + (const char *)&dummy, sizeof(dummy)) < 0) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_ERROR(layer->logger, UA_LOGCATEGORY_NETWORK, + "Cannot set socket option TCP_NODELAY. Error: %s", + errno_str)); + return UA_STATUSCODE_BADUNEXPECTEDERROR; + } + +#if defined(UA_getnameinfo) + /* Get the peer name for logging */ + char remote_name[100]; + int res = UA_getnameinfo((struct sockaddr*)remote, + sizeof(struct sockaddr_storage), + remote_name, sizeof(remote_name), + NULL, 0, NI_NUMERICHOST); + if(res == 0) { + UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | New connection over TCP from %s", + (int)newsockfd, remote_name); + } else { + UA_LOG_SOCKET_ERRNO_WRAP(UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | New connection over TCP, " + "getnameinfo failed with error: %s", + (int)newsockfd, errno_str)); + } +#else + UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | New connection over TCP", + (int)newsockfd); +#endif + /* Allocate and initialize the connection */ + ConnectionEntry *e = (ConnectionEntry*)UA_malloc(sizeof(ConnectionEntry)); + if(!e) { + return UA_STATUSCODE_BADOUTOFMEMORY; + } + + UA_Connection *c = &e->connection; + memset(c, 0, sizeof(UA_Connection)); + c->sockfd = newsockfd; + c->handle = layer; + c->ua_send = connection_write; + c->ua_close = ServerNetworkLayerTCP_close; + c->free = ServerNetworkLayerTCP_freeConnection; + c->getSendBuffer = connection_getsendbuffer; + c->releaseSendBuffer = connection_releasesendbuffer; + c->releaseRecvBuffer = connection_releaserecvbuffer; + c->state = UA_CONNECTIONSTATE_OPENING; + c->openingDate = UA_DateTime_nowMonotonic(); + + layer->connectionsSize++; + + /* Add to the linked list */ + LIST_INSERT_HEAD(&layer->connections, e, pointers); + if(nl->statistics) { + nl->statistics->currentConnectionCount++; + nl->statistics->cumulatedConnectionCount++; + } + return UA_STATUSCODE_GOOD; +} + +#if LWIP_DNS +static UA_StatusCode +addServerSocket(ServerNetworkLayerTCP *layer, struct addrinfo *ai) { + /* Create the server socket */ + ua_print("ua: [%s] %d %d %d\n", __func__, ai->ai_family, ai->ai_socktype, ai->ai_protocol); + UA_SOCKET newsock = UA_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol); + if(newsock == UA_INVALID_SOCKET) + { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "Error opening the server socket: %s", errno_str)); + return UA_STATUSCODE_BADCOMMUNICATIONERROR; + } + + /* Some Linux distributions have net.ipv6.bindv6only not activated. So + * sockets can double-bind to IPv4 and IPv6. This leads to problems. Use + * AF_INET6 sockets only for IPv6. */ + + int optval = 1; +#if UA_IPV6 + if(ai->ai_family == AF_INET6 && + UA_setsockopt(newsock, IPPROTO_IPV6, IPV6_V6ONLY, + (const char*)&optval, sizeof(optval)) == -1) { + UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "Could not set an IPv6 socket to IPv6 only"); + UA_close(newsock); + return UA_STATUSCODE_BADCOMMUNICATIONERROR; + + } +#endif + if(UA_setsockopt(newsock, SOL_SOCKET, SO_REUSEADDR, + (const char *)&optval, sizeof(optval)) == -1) { + UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "Could not make the socket reusable"); + UA_close(newsock); + return UA_STATUSCODE_BADCOMMUNICATIONERROR; + } + + + if(UA_socket_set_nonblocking(newsock) != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "Could not set the server socket to nonblocking"); + UA_close(newsock); + return UA_STATUSCODE_BADCOMMUNICATIONERROR; + } + + /* Bind socket to address */ + int ret = UA_bind(newsock, ai->ai_addr, (socklen_t)ai->ai_addrlen); + if(ret < 0) { + /* If bind to specific address failed, try to bind *-socket */ + if(ai->ai_family == AF_INET) { + struct sockaddr_in *sin = (struct sockaddr_in *)ai->ai_addr; + if(sin->sin_addr.s_addr != htonl(INADDR_ANY)) { + sin->sin_addr.s_addr = 0; + ret = 0; + } + } +#if UA_IPV6 + else if(ai->ai_family == AF_INET6) { + struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)ai->ai_addr; + if(!IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { + memset(&sin6->sin6_addr, 0, sizeof(sin6->sin6_addr)); + sin6->sin6_scope_id = 0; + ret = 0; + } + } +#endif // UA_IPV6 + if(ret == 0) { + ret = UA_bind(newsock, ai->ai_addr, (socklen_t)ai->ai_addrlen); + if(ret == 0) { + /* The second bind fixed the issue, inform the user. */ + UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, + "Server socket bound to unspecified address"); + } + } + } + if(ret < 0) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "Error binding a server socket: %s", errno_str)); + UA_close(newsock); + return UA_STATUSCODE_BADCOMMUNICATIONERROR; + } + + /* Start listening */ + if(UA_listen(newsock, MAXBACKLOG) < 0) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "Error listening on server socket: %s", errno_str)); + UA_close(newsock); + return UA_STATUSCODE_BADCOMMUNICATIONERROR; + } + + if(layer->port == 0) { + /* Port was automatically chosen. Read it from the OS */ + struct sockaddr_in returned_addr; + memset(&returned_addr, 0, sizeof(returned_addr)); + socklen_t len = sizeof(returned_addr); + UA_getsockname(newsock, (struct sockaddr *)&returned_addr, &len); + layer->port = ntohs(returned_addr.sin_port); + } + + layer->serverSockets[layer->serverSocketsSize] = newsock; + layer->serverSocketsSize++; + return UA_STATUSCODE_GOOD; +} +#endif + +static UA_StatusCode +ServerNetworkLayerTCP_start(UA_ServerNetworkLayer *nl, const UA_Logger *logger, + const UA_String *customHostname) { + UA_initialize_architecture_network(); + + ServerNetworkLayerTCP *layer = (ServerNetworkLayerTCP *)nl->handle; + layer->logger = logger; + + /* Get addrinfo of the server and create server sockets */ + char hostname[512]; + if(customHostname->length) { + if(customHostname->length >= sizeof(hostname)) + return UA_STATUSCODE_BADOUTOFMEMORY; + memcpy(hostname, customHostname->data, customHostname->length); + hostname[customHostname->length] = '\0'; + } + char portno[6]; + UA_snprintf(portno, 6, "%d", layer->port); + struct addrinfo hints, *res; + memset(&hints, 0, sizeof hints); + hints.ai_family = AF_UNSPEC; + hints.ai_socktype = SOCK_STREAM; + hints.ai_flags = AI_PASSIVE; +#ifdef AI_ADDRCONFIG + hints.ai_flags |= AI_ADDRCONFIG; +#endif + hints.ai_protocol = IPPROTO_TCP; + +#if LWIP_DNS + int retcode = UA_getaddrinfo(customHostname->length ? hostname : NULL, + portno, &hints, &res); + + ua_print("ua: [%s] host %s pro %d ret %d\n", __func__, hostname, portno, retcode); + + if(retcode != 0) { + UA_LOG_SOCKET_ERRNO_GAI_WRAP(UA_LOG_WARNING(layer->logger, UA_LOGCATEGORY_NETWORK, + "getaddrinfo lookup of %s failed with error %d - %s", hostname, retcode, errno_str)); + return UA_STATUSCODE_BADINTERNALERROR; + } + + ua_print("ua: [%s] res %p fam %d len %d %s\n", __func__, res, res->ai_family, + customHostname->length, + customHostname->data); + + /* There might be serveral addrinfos (for different network cards, + * IPv4/IPv6). Add a server socket for all of them. */ + struct addrinfo *ai = res; + for(layer->serverSocketsSize = 0; + layer->serverSocketsSize < FD_SETSIZE && ai != NULL; + ai = ai->ai_next) { + UA_StatusCode statusCode = addServerSocket(layer, ai); + if(statusCode != UA_STATUSCODE_GOOD) + { + UA_freeaddrinfo(res); + return statusCode; + } + } + UA_freeaddrinfo(res); +#endif + + /* Get the discovery url from the hostname */ + UA_String du = UA_STRING_NULL; + char discoveryUrlBuffer[256]; + if(customHostname->length) { + du.length = (size_t)UA_snprintf(discoveryUrlBuffer, 255, "opc.tcp://%.*s:%d/", + (int)customHostname->length, customHostname->data, + layer->port); + du.data = (UA_Byte*)discoveryUrlBuffer; + } else { + char hostnameBuffer[256]; + if(UA_gethostname(hostnameBuffer, 255) == 0) { + du.length = (size_t)UA_snprintf(discoveryUrlBuffer, 255, "opc.tcp://%s:%d/", + hostnameBuffer, layer->port); + du.data = (UA_Byte*)discoveryUrlBuffer; + } else { + UA_LOG_ERROR(layer->logger, UA_LOGCATEGORY_NETWORK, "Could not get the hostname"); + return UA_STATUSCODE_BADINTERNALERROR; + } + } + UA_String_copy(&du, &nl->discoveryUrl); + + UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, + "TCP network layer listening on %.*s", + (int)nl->discoveryUrl.length, nl->discoveryUrl.data); + return UA_STATUSCODE_GOOD; +} + +/* After every select, reset the sockets to listen on */ +static UA_Int32 +setFDSet(ServerNetworkLayerTCP *layer, fd_set *fdset) { + FD_ZERO(fdset); + UA_Int32 highestfd = 0; + for(UA_UInt16 i = 0; i < layer->serverSocketsSize; i++) { + UA_fd_set(layer->serverSockets[i], fdset); + if((UA_Int32)layer->serverSockets[i] > highestfd) + highestfd = (UA_Int32)layer->serverSockets[i]; + } + + ConnectionEntry *e; + LIST_FOREACH(e, &layer->connections, pointers) { + UA_fd_set(e->connection.sockfd, fdset); + if((UA_Int32)e->connection.sockfd > highestfd) + highestfd = (UA_Int32)e->connection.sockfd; + } + + return highestfd; +} + +static UA_StatusCode +ServerNetworkLayerTCP_listen(UA_ServerNetworkLayer *nl, UA_Server *server, + UA_UInt16 timeout) { + /* Every open socket can generate two jobs */ + ServerNetworkLayerTCP *layer = (ServerNetworkLayerTCP *)nl->handle; + + if(layer->serverSocketsSize == 0) + return UA_STATUSCODE_GOOD; + + /* Listen on open sockets (including the server) */ + fd_set fdset, errset; + UA_Int32 highestfd = setFDSet(layer, &fdset); + setFDSet(layer, &errset); + struct timeval tmptv = {0, timeout * 1000}; + if(UA_select(highestfd+1, &fdset, NULL, &errset, &tmptv) < 0) { + UA_LOG_SOCKET_ERRNO_WRAP( + UA_LOG_DEBUG(layer->logger, UA_LOGCATEGORY_NETWORK, + "Socket select failed with %s", errno_str)); + // we will retry, so do not return bad + return UA_STATUSCODE_GOOD; + } + + /* Accept new connections via the server sockets */ + for(UA_UInt16 i = 0; i < layer->serverSocketsSize; i++) { + if(!UA_fd_isset(layer->serverSockets[i], &fdset)) + continue; + + struct sockaddr_storage remote; + socklen_t remote_size = sizeof(remote); + UA_SOCKET newsockfd = UA_accept(layer->serverSockets[i], + (struct sockaddr*)&remote, &remote_size); + if(newsockfd == UA_INVALID_SOCKET) + continue; + + UA_LOG_TRACE(layer->logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | New TCP connection on server socket %i", + (int)newsockfd, (int)(layer->serverSockets[i])); + + if(ServerNetworkLayerTCP_add(nl, layer, (UA_Int32)newsockfd, &remote) != UA_STATUSCODE_GOOD) { + UA_close(newsockfd); + } + } + + /* Read from established sockets */ + ConnectionEntry *e, *e_tmp; + UA_DateTime now = UA_DateTime_nowMonotonic(); + LIST_FOREACH_SAFE(e, &layer->connections, pointers, e_tmp) { + if((e->connection.state == UA_CONNECTIONSTATE_OPENING) && + (now > (e->connection.openingDate + (NOHELLOTIMEOUT * UA_DATETIME_MSEC)))) { + UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | Closed by the server (no Hello Message)", + (int)(e->connection.sockfd)); + LIST_REMOVE(e, pointers); + layer->connectionsSize--; + UA_close(e->connection.sockfd); + UA_Server_removeConnection(server, &e->connection); + if(nl->statistics) { + nl->statistics->connectionTimeoutCount--; + nl->statistics->currentConnectionCount--; + } + continue; + } + + if(!UA_fd_isset(e->connection.sockfd, &errset) && + !UA_fd_isset(e->connection.sockfd, &fdset)) + continue; + + UA_LOG_TRACE(layer->logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | Activity on the socket", + (int)(e->connection.sockfd)); + + UA_ByteString buf = UA_BYTESTRING_NULL; + UA_StatusCode retval = connection_recv(&e->connection, &buf, 0); + + if(retval == UA_STATUSCODE_GOOD) { + /* Process packets */ + UA_Server_processBinaryMessage(server, &e->connection, &buf); + connection_releaserecvbuffer(&e->connection, &buf); + } else if(retval == UA_STATUSCODE_BADCONNECTIONCLOSED) { + /* The socket is shutdown but not closed */ + UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, + "Connection %i | Closed", + (int)(e->connection.sockfd)); + LIST_REMOVE(e, pointers); + layer->connectionsSize--; + UA_close(e->connection.sockfd); + UA_Server_removeConnection(server, &e->connection); + if(nl->statistics) { + nl->statistics->currentConnectionCount--; + } + } + } + return UA_STATUSCODE_GOOD; +} + +static void +ServerNetworkLayerTCP_stop(UA_ServerNetworkLayer *nl, UA_Server *server) { + ServerNetworkLayerTCP *layer = (ServerNetworkLayerTCP *)nl->handle; + UA_LOG_INFO(layer->logger, UA_LOGCATEGORY_NETWORK, + "Shutting down the TCP network layer"); + + /* Close the server sockets */ + for(UA_UInt16 i = 0; i < layer->serverSocketsSize; i++) { + UA_shutdown(layer->serverSockets[i], 2); + UA_close(layer->serverSockets[i]); + } + layer->serverSocketsSize = 0; + + /* Close open connections */ + ConnectionEntry *e; + LIST_FOREACH(e, &layer->connections, pointers) + ServerNetworkLayerTCP_close(&e->connection); + + /* Run recv on client sockets. This picks up the closed sockets and frees + * the connection. */ + ServerNetworkLayerTCP_listen(nl, server, 0); + + UA_deinitialize_architecture_network(); +} + +/* run only when the server is stopped */ +static void +ServerNetworkLayerTCP_clear(UA_ServerNetworkLayer *nl) { + ServerNetworkLayerTCP *layer = (ServerNetworkLayerTCP *)nl->handle; + UA_String_clear(&nl->discoveryUrl); + + /* Hard-close and remove remaining connections. The server is no longer + * running. So this is safe. */ + ConnectionEntry *e, *e_tmp; + LIST_FOREACH_SAFE(e, &layer->connections, pointers, e_tmp) { + LIST_REMOVE(e, pointers); + layer->connectionsSize--; + UA_close(e->connection.sockfd); + UA_free(e); + if(nl->statistics) { + nl->statistics->currentConnectionCount--; + } + } + + /* Free the layer */ + UA_free(layer); +} + +UA_ServerNetworkLayer +UA_ServerNetworkLayerTCP(UA_ConnectionConfig config, UA_UInt16 port, + UA_UInt16 maxConnections) { + UA_ServerNetworkLayer nl; + memset(&nl, 0, sizeof(UA_ServerNetworkLayer)); + nl.clear = ServerNetworkLayerTCP_clear; + nl.localConnectionConfig = config; + nl.start = ServerNetworkLayerTCP_start; + nl.ua_listen = ServerNetworkLayerTCP_listen; + nl.stop = ServerNetworkLayerTCP_stop; + nl.handle = NULL; + + ServerNetworkLayerTCP *layer = (ServerNetworkLayerTCP*) + UA_calloc(1,sizeof(ServerNetworkLayerTCP)); + if(!layer) + return nl; + nl.handle = layer; + + layer->port = port; + layer->maxConnections = maxConnections; + + return nl; +} + +typedef struct TCPClientConnection { + struct addrinfo hints, *server; + UA_DateTime connStart; + UA_String endpointUrl; + UA_UInt32 timeout; +} TCPClientConnection; + +/***************************/ +/* Client NetworkLayer TCP */ +/***************************/ + +static void +ClientNetworkLayerTCP_close(UA_Connection *connection) { + if(connection->state == UA_CONNECTIONSTATE_CLOSED) + return; + + if(connection->sockfd != UA_INVALID_SOCKET) { + UA_shutdown(connection->sockfd, 2); + UA_close(connection->sockfd); + } + connection->state = UA_CONNECTIONSTATE_CLOSED; +} + +static void +ClientNetworkLayerTCP_free(UA_Connection *connection) { + if(!connection->handle) + return; + + TCPClientConnection *tcpConnection = (TCPClientConnection *)connection->handle; + if(tcpConnection->server) + UA_freeaddrinfo(tcpConnection->server); + UA_String_clear(&tcpConnection->endpointUrl); + UA_free(tcpConnection); + connection->handle = NULL; +} + +UA_StatusCode +UA_ClientConnectionTCP_poll(UA_Connection *connection, UA_UInt32 timeout, + const UA_Logger *logger) { + if(connection->state == UA_CONNECTIONSTATE_CLOSED) + return UA_STATUSCODE_BADDISCONNECT; + if(connection->state == UA_CONNECTIONSTATE_ESTABLISHED) + return UA_STATUSCODE_GOOD; + + /* Connection timeout? */ + TCPClientConnection *tcpConnection = (TCPClientConnection*) connection->handle; + if((UA_Double) (UA_DateTime_nowMonotonic() - tcpConnection->connStart) + > (UA_Double) tcpConnection->timeout * UA_DATETIME_MSEC ) { + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, "Timed out"); + ClientNetworkLayerTCP_close(connection); + return UA_STATUSCODE_BADDISCONNECT; + } + + ua_print("ua: [%s] conn handle %p fam %d sa %d\n", __func__, + connection->handle, tcpConnection->server->ai_family, + tcpConnection->server->ai_addr->sa_family); + + /* Get a socket and connect (only once) if not already done in a previous + * call. On win32, calling connect multiple times is not recommended on + * non-blocking sockets + * (https://docs.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect). + * On posix it is also not necessary to call connect multiple times. + * + * Identification of successfull connection is done using select (writeable/errorfd) + * and getsockopt using SO_ERROR on win32 and posix. + */ + if(connection->sockfd == UA_INVALID_SOCKET) { + ua_print("ua: [%s] start socket %p ai %d sa %d\n", __func__, + tcpConnection->server, + tcpConnection->server->ai_family, + tcpConnection->server->ai_addr->sa_family); + connection->sockfd = UA_socket(tcpConnection->server->ai_family, + tcpConnection->server->ai_socktype, + tcpConnection->server->ai_protocol); + if(connection->sockfd == UA_INVALID_SOCKET) { + ua_print("ua: [%s] %s\n", __func__, strerror(UA_ERRNO)); + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, + "Could not create client socket: %s", strerror(UA_ERRNO)); + ClientNetworkLayerTCP_close(connection); + return UA_STATUSCODE_BADDISCONNECT; + } + + ua_print("ua: [%s] socket fd %d %p fam %d sa %d\n", __func__, + connection->sockfd, + tcpConnection->server, + tcpConnection->server->ai_family, + tcpConnection->server->ai_addr->sa_family); + + /* Non blocking connect to be able to timeout */ + if(UA_socket_set_nonblocking(connection->sockfd) != UA_STATUSCODE_GOOD) { + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, + "Could not set the client socket to nonblocking"); + ClientNetworkLayerTCP_close(connection); + return UA_STATUSCODE_BADDISCONNECT; + } + + ua_print("ua: [%s] check fd %d %p fam %d sa %d\n", __func__, + connection->sockfd, + tcpConnection->server, + tcpConnection->server->ai_family, + tcpConnection->server->ai_addr->sa_family); + /* Don't have the socket create interrupt signals */ +#ifdef SO_NOSIGPIPE + int val = 1; + int sso_result = setsockopt(connection->sockfd, SOL_SOCKET, SO_NOSIGPIPE, + (void *)&val, sizeof(val)); + if(sso_result < 0) + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, "Couldn't set SO_NOSIGPIPE"); +#endif + ua_print("ua: [%s] connect ai %d sa fam %d len %d %x addr len %d\n", __func__, + tcpConnection->server->ai_family, + tcpConnection->server->ai_addr->sa_family, + tcpConnection->server->ai_addr->sa_len, + tcpConnection->server->ai_addr->sa_data[0], + tcpConnection->server->ai_addrlen); + + int error = UA_connect(connection->sockfd, tcpConnection->server->ai_addr, + tcpConnection->server->ai_addrlen); + + /* Connection successful */ + if(error == 0) { + connection->state = UA_CONNECTIONSTATE_ESTABLISHED; + return UA_STATUSCODE_GOOD; + } + ua_print("ua: [%s] connected failed %d\n", __func__, error); + + /* The connection failed */ + if((UA_ERRNO != UA_ERR_CONNECTION_PROGRESS)) { + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, + "Connection 1 to %x %.*s failed with error:%d - %s\n", + tcpConnection->endpointUrl.length, + (int)tcpConnection->endpointUrl.length, + tcpConnection->endpointUrl.data, UA_ERRNO, strerror(UA_ERRNO)); + ClientNetworkLayerTCP_close(connection); + return UA_STATUSCODE_BADDISCONNECT; + } + } + + /* Use select to wait until connected. Return with a half-opened connection + * after a timeout. */ + UA_UInt32 timeout_usec = timeout * 1000; + +#ifdef _OS9000 + /* OS-9 cannot use select for checking write sockets. Therefore, we need to + * use connect until success or failed */ + int resultsize = 0; + do { + u_int32 time = 0x80000001; + signal_code sig; + + timeout_usec -= 1000000/256; // Sleep 1/256 second + if(timeout_usec < 0) + break; + + _os_sleep(&time, &sig); + error = connect(connection->sockfd, tcpConnection->server->ai_addr, + tcpConnection->server->ai_addrlen); + if((error == -1 && UA_ERRNO == EISCONN) || (error == 0)) + resultsize = 1; + if(error == -1 && UA_ERRNO != EALREADY && UA_ERRNO != EINPROGRESS) + break; + } while(resultsize == 0); +#else + /* Wait in a select-call until the connection fully opens or the timeout + * happens */ + + /* On windows select both writing and error fdset */ + fd_set writing_fdset; + FD_ZERO(&writing_fdset); + UA_fd_set(connection->sockfd, &writing_fdset); + fd_set error_fdset; + FD_ZERO(&error_fdset); +#ifdef _WIN32 + UA_fd_set(connection->sockfd, &error_fdset); +#endif + struct timeval tmptv = {(long int)(timeout_usec / 1000000), + (int)(timeout_usec % 1000000)}; + + int ret = UA_select((UA_Int32)(connection->sockfd + 1), NULL, &writing_fdset, + &error_fdset, &tmptv); + + // When select fails abort connection + if(ret == -1) { + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, + "Connection to %.*s failed with error: %s", + (int)tcpConnection->endpointUrl.length, + tcpConnection->endpointUrl.data, strerror(UA_ERRNO)); + ClientNetworkLayerTCP_close(connection); + return UA_STATUSCODE_BADDISCONNECT; + } + + int resultsize = UA_fd_isset(connection->sockfd, &writing_fdset); +#endif + + /* Any errors on the socket reported? */ + OPTVAL_TYPE so_error = 0; + socklen_t len = sizeof(so_error); + ret = UA_getsockopt(connection->sockfd, SOL_SOCKET, SO_ERROR, &so_error, &len); + if(ret != 0 || so_error != 0) { + // UA_LOG_SOCKET_ERRNO_GAI_WRAP because of so_error +#ifndef _WIN32 + char *errno_str = strerror(ret == 0 ? so_error : UA_ERRNO); +#else + char *errno_str = NULL; + FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, ret == 0 ? so_error : WSAGetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&errno_str, 0, + NULL); +#endif + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, + "Connection to %.*s failed with error: %s", + (int)tcpConnection->endpointUrl.length, + tcpConnection->endpointUrl.data, errno_str); +#ifdef _WIN32 + LocalFree(errno_str); +#endif + ClientNetworkLayerTCP_close(connection); + return UA_STATUSCODE_BADDISCONNECT; + } + + /* The connection is fully opened. Otherwise, select has timed out. But we + * can retry. */ + if(resultsize == 1) + connection->state = UA_CONNECTIONSTATE_ESTABLISHED; + + return UA_STATUSCODE_GOOD; +} + +UA_Connection +UA_ClientConnectionTCP_init(UA_ConnectionConfig config, const UA_String endpointUrl, + UA_UInt32 timeout, const UA_Logger *logger) { + UA_initialize_architecture_network(); + + UA_Connection connection; + memset(&connection, 0, sizeof(UA_Connection)); + + connection.state = UA_CONNECTIONSTATE_OPENING; + connection.sockfd = UA_INVALID_SOCKET; + connection.ua_send = connection_write; + connection.ua_recv = connection_recv; + connection.ua_close = ClientNetworkLayerTCP_close; + connection.free = ClientNetworkLayerTCP_free; + connection.getSendBuffer = connection_getsendbuffer; + connection.releaseSendBuffer = connection_releasesendbuffer; + connection.releaseRecvBuffer = connection_releaserecvbuffer; + + ua_print("ua: [%s] endpoint url (%d)%.28s %d\n", __func__, endpointUrl.length, endpointUrl.data, + sizeof(TCPClientConnection)); + + TCPClientConnection *tcpClientConnection = (TCPClientConnection*) + UA_malloc(sizeof(TCPClientConnection)); + if(!tcpClientConnection) { + connection.state = UA_CONNECTIONSTATE_CLOSED; + ua_print("ua: [%s] malloc %d failed\n", __func__, sizeof(TCPClientConnection)); + return connection; + } + memset(tcpClientConnection, 0, sizeof(TCPClientConnection)); + connection.handle = (void*) tcpClientConnection; + tcpClientConnection->timeout = timeout; + UA_String hostnameString = UA_STRING_NULL; + UA_String pathString = UA_STRING_NULL; + UA_UInt16 port = 0; + char hostname[512]; + tcpClientConnection->connStart = UA_DateTime_nowMonotonic(); + + ua_print("ua: [%s] line %d!\n", __func__, __LINE__); + + UA_String_copy(&endpointUrl, &tcpClientConnection->endpointUrl); + + UA_StatusCode parse_retval = + UA_parseEndpointUrl(&endpointUrl, &hostnameString, &port, &pathString); + if(parse_retval != UA_STATUSCODE_GOOD || hostnameString.length > 511) { + UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, + "Server url is invalid: %.*s", + (int)endpointUrl.length, endpointUrl.data); + connection.state = UA_CONNECTIONSTATE_CLOSED; + return connection; + } + + ua_print("ua: [%s] line %d!\n", __func__, __LINE__); + + memcpy(hostname, hostnameString.data, hostnameString.length); + hostname[hostnameString.length] = 0; + + if(port == 0) { + port = 4840; + UA_LOG_INFO(logger, UA_LOGCATEGORY_NETWORK, + "No port defined, using default port %" PRIu16, port); + } + + ua_print("ua: [%s] line %d!\n", __func__, __LINE__); + + memset(&tcpClientConnection->hints, 0, sizeof(tcpClientConnection->hints)); + tcpClientConnection->hints.ai_family = AF_UNSPEC; + tcpClientConnection->hints.ai_socktype = SOCK_STREAM; + char portStr[6]; + UA_snprintf(portStr, 6, "%d", port); + +// ua_print("ua: [%s] host %s port %s fam %d\n", __func__, hostname, portStr, +// tcpClientConnection->server->ai_addr->sa_family); + +#if LWIP_DNS + int error = UA_getaddrinfo(hostname, portStr, &tcpClientConnection->hints, + &tcpClientConnection->server); + if(error != 0 || !tcpClientConnection->server) { + ua_print("ua: [%s] host %s error %d\n", __func__, hostname, error); + UA_LOG_SOCKET_ERRNO_GAI_WRAP(UA_LOG_WARNING(logger, UA_LOGCATEGORY_NETWORK, + "DNS lookup of %s failed with error %d - %s", + hostname, error, errno_str)); + connection.state = UA_CONNECTIONSTATE_CLOSED; + return connection; + } +#endif + + /* Return connection with state UA_CONNECTIONSTATE_OPENING */ + return connection; +} diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.h b/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.h new file mode 100755 index 00000000..81513401 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/open62541.h @@ -0,0 +1,31298 @@ +/* THIS IS A SINGLE-FILE DISTRIBUTION CONCATENATED FROM THE OPEN62541 SOURCES + * visit http://open62541.org/ for information about this software + * Git-Revision: v1.2.2-506-g998e2523-dirty + */ + +/* + * Copyright (C) 2014-2021 the contributors as stated in the AUTHORS file + * + * This file is part of open62541. open62541 is free software: you can + * redistribute it and/or modify it under the terms of the Mozilla Public + * License v2.0 as stated in the LICENSE file provided with open62541. + * + * open62541 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. + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file open62541.c + * @brief Support OPCUA protocol + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.12.15 + */ + +#ifndef OPEN62541_H_ +#define OPEN62541_H_ + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/config.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + +/** + * open62541 Version + * ----------------- */ +#define UA_OPEN62541_VER_MAJOR 1 +#define UA_OPEN62541_VER_MINOR 2 +#define UA_OPEN62541_VER_PATCH 2 +#define UA_OPEN62541_VER_LABEL "-506-g998e2523-dirty" /* Release candidate label, etc. */ +#define UA_OPEN62541_VER_COMMIT "v1.2.2-506-g998e2523-dirty" +#define UA_OPEN62541_VERSION "v1.2.2-506-g998e2523-dirty" + +/** + * Feature Options + * --------------- + * Changing the feature options has no effect on a pre-compiled library. */ + +#define UA_LOGLEVEL 300 +#ifndef UA_ENABLE_AMALGAMATION +#define UA_ENABLE_AMALGAMATION +#endif +#define UA_ENABLE_METHODCALLS +#define UA_ENABLE_NODEMANAGEMENT +#define UA_ENABLE_SUBSCRIPTIONS +/* #undef UA_ENABLE_PUBSUB */ +/* #undef UA_ENABLE_PUBSUB_ENCRYPTION */ +/* #undef UA_ENABLE_PUBSUB_FILE_CONFIG */ +/* #undef UA_ENABLE_PUBSUB_ETH_UADP */ +/* #undef UA_ENABLE_PUBSUB_DELTAFRAMES */ +/* #undef UA_ENABLE_PUBSUB_INFORMATIONMODEL */ +/* #undef UA_ENABLE_PUBSUB_INFORMATIONMODEL_METHODS */ +#define UA_ENABLE_DA +/* #undef UA_ENABLE_HISTORIZING */ +#define UA_ENABLE_PARSING +/* #undef UA_ENABLE_EXPERIMENTAL_HISTORIZING */ +#define UA_ENABLE_SUBSCRIPTIONS_EVENTS +/* #undef UA_ENABLE_JSON_ENCODING */ +/* #undef UA_ENABLE_PUBSUB_MQTT */ +/* #undef UA_ENABLE_MQTT_TLS */ +/* #undef UA_ENABLE_MQTT_TLS_OPENSSL */ +/* #undef UA_ENABLE_ENCRYPTION_MBEDTLS */ +/* #undef UA_ENABLE_TPM2_SECURITY */ +/* #undef UA_ENABLE_ENCRYPTION_OPENSSL */ +/* #undef UA_ENABLE_ENCRYPTION_LIBRESSL */ +#if defined(UA_ENABLE_ENCRYPTION_MBEDTLS) || defined(UA_ENABLE_ENCRYPTION_OPENSSL) || defined(UA_ENABLE_ENCRYPTION_LIBRESSL) +#define UA_ENABLE_ENCRYPTION +#endif +/* #undef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS */ + +/* Multithreading */ +/* #undef UA_ENABLE_IMMUTABLE_NODES */ +#define UA_MULTITHREADING 0//100 + +/* Advanced Options */ +#define UA_ENABLE_STATUSCODE_DESCRIPTIONS +#define UA_ENABLE_TYPEDESCRIPTION +#define UA_ENABLE_NODESET_COMPILER_DESCRIPTIONS +/* #undef UA_ENABLE_DETERMINISTIC_RNG */ +/* #undef UA_ENABLE_DISCOVERY */ +/* #undef UA_ENABLE_DISCOVERY_MULTICAST */ +/* #undef UA_ENABLE_WEBSOCKET_SERVER */ +/* #undef UA_ENABLE_QUERY */ +/* #undef UA_ENABLE_MALLOC_SINGLETON */ +#define UA_ENABLE_DISCOVERY_SEMAPHORE +/* #undef UA_ENABLE_UNIT_TEST_FAILURE_HOOKS */ +/* #undef UA_ENABLE_VALGRIND_INTERACTIVE */ +#define UA_VALGRIND_INTERACTIVE_INTERVAL 1000 +#define UA_GENERATED_NAMESPACE_ZERO +/* #undef UA_GENERATED_NAMESPACE_ZERO_FULL */ +/* #undef UA_ENABLE_PUBSUB_MONITORING */ +/* #undef UA_ENABLE_PUBSUB_BUFMALLOC */ + +/* #undef UA_PACK_DEBIAN */ + +/* Options for Debugging */ +/* #undef UA_DEBUG */ +/* #undef UA_DEBUG_DUMP_PKGS */ +/* #undef UA_DEBUG_FILE_LINE_INFO */ +/** + * Function Export + * --------------- + * On Win32: Define ``UA_DYNAMIC_LINKING`` and ``UA_DYNAMIC_LINKING_EXPORT`` in + * order to export symbols for a DLL. Define ``UA_DYNAMIC_LINKING`` only to + * import symbols from a DLL.*/ +/* #undef UA_DYNAMIC_LINKING */ + +/* Shortcuts for extern "C" declarations */ +#if !defined(_UA_BEGIN_DECLS) +# ifdef __cplusplus +# define _UA_BEGIN_DECLS extern "C" { +# else +# define _UA_BEGIN_DECLS +# endif +#endif +#if !defined(_UA_END_DECLS) +# ifdef __cplusplus +# define _UA_END_DECLS } +# else +# define _UA_END_DECLS +# endif +#endif + +/* Select default architecture if non is selected through CMake or compiler define */ +#if 1 && !defined(UA_ARCHITECTURE_ECOS) && !defined(UA_ARCHITECTURE_FREERTOSLWIP) && !defined(UA_ARCHITECTURE_POSIX) && !defined(UA_ARCHITECTURE_VXWORKS) && !defined(UA_ARCHITECTURE_WEC7) && !defined(UA_ARCHITECTURE_WIN32) +# ifdef _WIN32 +# define UA_ARCHITECTURE_WIN32 +# else +# define UA_ARCHITECTURE_POSIX +# endif +#endif + +// specific architectures can undef this +#define UA_HAS_GETIFADDR + +/**** amalgamated original file "/arch/freertosLWIP/../common/ua_freeRTOS.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2018 (c) Jose Cabral, fortiss GmbH + */ + +#ifndef ARCH_COMMON_FREERTOS62541_H_ +#define ARCH_COMMON_FREERTOS62541_H_ + +#include +#include + +#ifdef BYTE_ORDER +# undef BYTE_ORDER +#endif + +#define UA_sleep_ms(X) vTaskDelay(pdMS_TO_TICKS(X)) + +#ifdef OPEN62541_FEERTOS_USE_OWN_MEM +# define UA_free vPortFree +# define UA_malloc pvPortMalloc +# define UA_calloc pvPortCalloc +# define UA_realloc pvPortRealloc +#else +# define UA_free free +# define UA_malloc malloc +# define UA_calloc calloc +# define UA_realloc realloc +#endif + +#ifdef UA_ENABLE_DISCOVERY_SEMAPHORE +# ifndef UA_fileExists +# define UA_fileExists(X) (0) //file managing is not part of freeRTOS. If the system provides it, please define it before +# endif // UA_fileExists +#endif + +// No log colors on freeRTOS +// #define UA_ENABLE_LOG_COLORS + +#include +#define UA_snprintf snprintf + +#define UA_LOG_SOCKET_ERRNO_WRAP(LOG) { \ + char *errno_str = ""; \ + LOG; \ +} + +#endif /* ARCH_COMMON_FREERTOS62541_H_ */ + +/**** amalgamated original file "/arch/freertosLWIP/../common/ua_lwip.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2018 (c) Jose Cabral, fortiss GmbH + */ + +#ifndef ARCH_COMMON_LWIP62541_H_ +#define ARCH_COMMON_LWIP62541_H_ + +/* + * Needed flags to be set before including this file. Normally done in lwipopts.h + * #define LWIP_COMPAT_SOCKETS 0 // Don't do name define-transformation in networking function names. + * #define LWIP_SOCKET 1 // Enable Socket API (normally already set) + * #define LWIP_DNS 1 // enable the lwip_getaddrinfo function, struct addrinfo and more. + * #define SO_REUSE 1 // Allows to set the socket as reusable + * #define LWIP_TIMEVAL_PRIVATE 0 // This is optional. Set this flag if you get a compilation error about redefinition of struct timeval + * + * Why not define these here? This stack is used as middleware so other code might use this header file with other flags (specially LWIP_COMPAT_SOCKETS) + */ + +//#include "lwipopts.h" +#include +#include +#include +#include + + +#define OPTVAL_TYPE int + +#define UA_fd_set(fd, fds) FD_SET((unsigned int)fd, fds) +#define UA_fd_isset(fd, fds) FD_ISSET((unsigned int)fd, fds) + +#define UA_IPV6 LWIP_IPV6 +#define UA_SOCKET int +#define UA_INVALID_SOCKET -1 +#define UA_ERRNO errno +#define UA_INTERRUPTED EINTR +#define UA_AGAIN EAGAIN +#define UA_EAGAIN EAGAIN +#define UA_WOULDBLOCK EWOULDBLOCK +#define UA_ERR_CONNECTION_PROGRESS EINPROGRESS + +#define UA_send lwip_send +#define UA_recv lwip_recv +#define UA_sendto lwip_sendto +#define UA_recvfrom lwip_recvfrom +#define UA_htonl lwip_htonl +#define UA_ntohl lwip_ntohl +#define UA_close lwip_close +#define UA_select lwip_select +#define UA_shutdown lwip_shutdown +#define UA_socket lwip_socket +#define UA_bind lwip_bind +#define UA_listen lwip_listen +#define UA_accept lwip_accept +#define UA_connect lwip_connect +#define UA_getsockopt lwip_getsockopt +#define UA_setsockopt lwip_setsockopt +#if LWIP_DNS +#define UA_freeaddrinfo lwip_freeaddrinfo +#else +#define UA_freeaddrinfo +#endif +#ifndef UA_gethostname +#define UA_gethostname gethostname_lwip +#else +extern int UA_gethostname(char* name, size_t len); +#endif +#ifndef UA_getsockname +#define UA_getsockname lwip_getsockname +#else +extern int UA_getsockname((int s, struct sockaddr *name, socklen_t *namelen); +#endif +#ifndef UA_getaddrinfo +#if LWIP_DNS +#define UA_getaddrinfo lwip_getaddrinfo +#else +#define UA_getaddrinfo +#endif +#else +extern int UA_getaddrinfo(const char *nodename, const char *servname, + const struct addrinfo *hints, struct addrinfo **res); +#endif + +#if UA_IPV6 +# define UA_inet_pton(af, src, dst) \ + (((af) == AF_INET6) ? ip6addr_aton((src),(ip6_addr_t*)(dst)) \ + : (((af) == AF_INET) ? ip4addr_aton((src),(ip4_addr_t*)(dst)) : 0)) +#else +# define UA_inet_pton(af, src, dst) \ + (((af) == AF_INET) ? ip4addr_aton((src),(ip4_addr_t*)(dst)) : 0) +#endif + +#if UA_IPV6 +# define UA_if_nametoindex lwip_if_nametoindex + +# if LWIP_VERSION_IS_RELEASE //lwip_if_nametoindex is not yet released +unsigned int lwip_if_nametoindex(const char *ifname); +# endif +#endif + +int gethostname_lwip(char* name, size_t len); + +#define UA_LOG_SOCKET_ERRNO_GAI_WRAP UA_LOG_SOCKET_ERRNO_WRAP + +#endif /* ARCH_COMMON_LWIP62541_H_ */ + +/**** amalgamated original file "/arch/freertosLWIP/ua_architecture.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016-2017 (c) Julius Pfrommer, Fraunhofer IOSB + * Copyright 2017-2018 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Jose Cabral, fortiss GmbH + */ + +#define UA_ARCHITECTURE_FREERTOSLWIP 1 + +#ifdef UA_ARCHITECTURE_FREERTOSLWIP + +#if UA_MULTITHREADING >= 100 +#error Multithreading unsupported +#else +#define UA_LOCK_INIT(lock) +#define UA_LOCK_DESTROY(lock) +#define UA_LOCK(lock) +#define UA_UNLOCK(lock) +#define UA_LOCK_ASSERT(lock, num) +#endif + +#define UA_Lock pthread_mutex_t + +#define UA_strncasecmp strncasecmp + +// freeRTOS does not have getifaddr +#undef UA_HAS_GETIFADDR + +#ifndef IN6_IS_ADDR_UNSPECIFIED +# define IN6_IS_ADDR_UNSPECIFIED(a) \ + (((const uint32_t *) (a))[0] == 0 \ + && ((const uint32_t *) (a))[1] == 0 \ + && ((const uint32_t *) (a))[2] == 0 \ + && ((const uint32_t *) (a))[3] == 0) +#endif + +#endif /* UA_ARCHITECTURE_FREERTOSLWIP */ + +/**** amalgamated original file "/deps/ms_stdint.h" ****/ + +// ISO C9x compliant stdint.h for Microsoft Visual Studio +// Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124 +// +// Copyright (c) 2006-2013 Alexander Chemeris +// +// 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 product 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 AUTHOR ``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 AUTHOR 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. +// +/////////////////////////////////////////////////////////////////////////////// + +#if !defined(_MSC_VER) || _MSC_VER >= 1600 // [ +#include +#else + + +#if _MSC_VER > 1000 +#pragma once +#endif + +#include + +// For Visual Studio 6 in C++ mode and for many Visual Studio versions when +// compiling for ARM we should wrap include with 'extern "C++" {}' +// or compiler give many errors like this: +// error C2733: second C linkage of overloaded function 'wmemchr' not allowed +#ifndef UNDER_CE +#ifdef __cplusplus +extern "C" { +#endif +# include +#ifdef __cplusplus +} +#endif +#endif + +// Define _W64 macros to mark types changing their size, like intptr_t. +#ifndef _W64 +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif + + +// 7.18.1 Integer types + +// 7.18.1.1 Exact-width integer types + +// Visual Studio 6 and Embedded Visual C++ 4 doesn't +// realize that, e.g. char has the same size as __int8 +// so we give up on __intX for them. +#if (_MSC_VER < 1300) + typedef signed char int8_t; + typedef signed short int16_t; + typedef signed int int32_t; + typedef unsigned char uint8_t; + typedef unsigned short uint16_t; + typedef unsigned int uint32_t; +#else + typedef signed __int8 int8_t; + typedef signed __int16 int16_t; + typedef signed __int32 int32_t; + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; +#endif +typedef signed __int64 int64_t; +typedef unsigned __int64 uint64_t; + + +// 7.18.1.2 Minimum-width integer types +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +typedef int64_t int_least64_t; +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +typedef uint64_t uint_least64_t; + +// 7.18.1.3 Fastest minimum-width integer types +typedef int8_t int_fast8_t; +typedef int16_t int_fast16_t; +typedef int32_t int_fast32_t; +typedef int64_t int_fast64_t; +typedef uint8_t uint_fast8_t; +typedef uint16_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +typedef uint64_t uint_fast64_t; + +// 7.18.1.4 Integer types capable of holding object pointers +#ifdef _WIN64 // [ + typedef signed __int64 intptr_t; + typedef unsigned __int64 uintptr_t; +#else // _WIN64 ][ + typedef _W64 signed int intptr_t; + typedef _W64 unsigned int uintptr_t; +#endif // _WIN64 ] + +// 7.18.1.5 Greatest-width integer types +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; + + +// 7.18.2 Limits of specified-width integer types + +#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS) // [ See footnote 220 at page 257 and footnote 221 at page 259 + +// 7.18.2.1 Limits of exact-width integer types +#define INT8_MIN ((int8_t)_I8_MIN) +#define INT8_MAX _I8_MAX +#define INT16_MIN ((int16_t)_I16_MIN) +#define INT16_MAX _I16_MAX +#define INT32_MIN ((int32_t)_I32_MIN) +#define INT32_MAX _I32_MAX +#define INT64_MIN ((int64_t)_I64_MIN) +#define INT64_MAX _I64_MAX +#define UINT8_MAX _UI8_MAX +#define UINT16_MAX _UI16_MAX +#define UINT32_MAX _UI32_MAX +#define UINT64_MAX _UI64_MAX + +// 7.18.2.2 Limits of minimum-width integer types +#define INT_LEAST8_MIN INT8_MIN +#define INT_LEAST8_MAX INT8_MAX +#define INT_LEAST16_MIN INT16_MIN +#define INT_LEAST16_MAX INT16_MAX +#define INT_LEAST32_MIN INT32_MIN +#define INT_LEAST32_MAX INT32_MAX +#define INT_LEAST64_MIN INT64_MIN +#define INT_LEAST64_MAX INT64_MAX +#define UINT_LEAST8_MAX UINT8_MAX +#define UINT_LEAST16_MAX UINT16_MAX +#define UINT_LEAST32_MAX UINT32_MAX +#define UINT_LEAST64_MAX UINT64_MAX + +// 7.18.2.3 Limits of fastest minimum-width integer types +#define INT_FAST8_MIN INT8_MIN +#define INT_FAST8_MAX INT8_MAX +#define INT_FAST16_MIN INT16_MIN +#define INT_FAST16_MAX INT16_MAX +#define INT_FAST32_MIN INT32_MIN +#define INT_FAST32_MAX INT32_MAX +#define INT_FAST64_MIN INT64_MIN +#define INT_FAST64_MAX INT64_MAX +#define UINT_FAST8_MAX UINT8_MAX +#define UINT_FAST16_MAX UINT16_MAX +#define UINT_FAST32_MAX UINT32_MAX +#define UINT_FAST64_MAX UINT64_MAX + +// 7.18.2.4 Limits of integer types capable of holding object pointers +#ifdef _WIN64 // [ +# define INTPTR_MIN INT64_MIN +# define INTPTR_MAX INT64_MAX +# define UINTPTR_MAX UINT64_MAX +#else // _WIN64 ][ +# define INTPTR_MIN INT32_MIN +# define INTPTR_MAX INT32_MAX +# define UINTPTR_MAX UINT32_MAX +#endif // _WIN64 ] + +// 7.18.2.5 Limits of greatest-width integer types +#define INTMAX_MIN INT64_MIN +#define INTMAX_MAX INT64_MAX +#define UINTMAX_MAX UINT64_MAX + +// 7.18.3 Limits of other integer types + +#ifdef _WIN64 // [ +# define PTRDIFF_MIN _I64_MIN +# define PTRDIFF_MAX _I64_MAX +#else // _WIN64 ][ +# define PTRDIFF_MIN _I32_MIN +# define PTRDIFF_MAX _I32_MAX +#endif // _WIN64 ] + +#define SIG_ATOMIC_MIN INT_MIN +#define SIG_ATOMIC_MAX INT_MAX + +#ifndef SIZE_MAX // [ +# ifdef _WIN64 // [ +# define SIZE_MAX _UI64_MAX +# else // _WIN64 ][ +# define SIZE_MAX _UI32_MAX +# endif // _WIN64 ] +#endif // SIZE_MAX ] + +// WCHAR_MIN and WCHAR_MAX are also defined in +#ifndef WCHAR_MIN // [ +# define WCHAR_MIN 0 +#endif // WCHAR_MIN ] +#ifndef WCHAR_MAX // [ +# define WCHAR_MAX _UI16_MAX +#endif // WCHAR_MAX ] + +#define WINT_MIN 0 +#define WINT_MAX _UI16_MAX + +#endif // __STDC_LIMIT_MACROS ] + + +// 7.18.4 Limits of other integer types + +#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS) // [ See footnote 224 at page 260 + +// 7.18.4.1 Macros for minimum-width integer constants + +#define INT8_C(val) val##i8 +#define INT16_C(val) val##i16 +#define INT32_C(val) val##i32 +#define INT64_C(val) val##i64 + +#define UINT8_C(val) val##ui8 +#define UINT16_C(val) val##ui16 +#define UINT32_C(val) val##ui32 +#define UINT64_C(val) val##ui64 + +// 7.18.4.2 Macros for greatest-width integer constants +// These #ifndef's are needed to prevent collisions with . +// Check out Issue 9 for the details. +#ifndef INTMAX_C // [ +# define INTMAX_C INT64_C +#endif // INTMAX_C ] +#ifndef UINTMAX_C // [ +# define UINTMAX_C UINT64_C +#endif // UINTMAX_C ] + +#endif // __STDC_CONSTANT_MACROS ] + + +#endif // !defined(_MSC_VER) || _MSC_VER >= 1600 ] + +/**** amalgamated original file "/include/open62541/architecture_definitions.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Jose Cabral, fortiss GmbH + */ + + + +/** + * C99 Definitions + * --------------- */ +#include +#include + +/* Include stdint.h and stdbool.h or workaround for older Visual Studios */ +#ifdef UNDER_CE +#endif +#if !defined(_MSC_VER) || _MSC_VER >= 1800 +# include +# include /* C99 Boolean */ +#else +# if !defined(__bool_true_false_are_defined) +# define bool unsigned char +# define true 1 +# define false 0 +# define __bool_true_false_are_defined +# endif +#endif + +/* Include inttypes.h or workaround for older Visual Studios */ +#if !defined(_MSC_VER) || _MSC_VER >= 1800 +# include +#else +# define __PRI_8_LENGTH_MODIFIER__ "hh" +# define __PRI_64_LENGTH_MODIFIER__ "ll" + +# define PRId8 __PRI_8_LENGTH_MODIFIER__ "d" +# define PRIi8 __PRI_8_LENGTH_MODIFIER__ "i" +# define PRIo8 __PRI_8_LENGTH_MODIFIER__ "o" +# define PRIu8 __PRI_8_LENGTH_MODIFIER__ "u" +# define PRIx8 __PRI_8_LENGTH_MODIFIER__ "x" +# define PRIX8 __PRI_8_LENGTH_MODIFIER__ "X" + +# define PRId16 "hd" +# define PRIi16 "hi" +# define PRIo16 "ho" +# define PRIu16 "hu" +# define PRIx16 "hx" +# define PRIX16 "hX" + +# define PRId32 "ld" +# define PRIi32 "li" +# define PRIo32 "lo" +# define PRIu32 "lu" +# define PRIx32 "lx" +# define PRIX32 "lX" + +# define PRId64 __PRI_64_LENGTH_MODIFIER__ "d" +# define PRIi64 __PRI_64_LENGTH_MODIFIER__ "i" +# define PRIo64 __PRI_64_LENGTH_MODIFIER__ "o" +# define PRIu64 __PRI_64_LENGTH_MODIFIER__ "u" +# define PRIx64 __PRI_64_LENGTH_MODIFIER__ "x" +# define PRIX64 __PRI_64_LENGTH_MODIFIER__ "X" +#endif + +/** + * Thread-local variables + * ---------------------- */ +#if UA_MULTITHREADING >= 100 +# if defined(__GNUC__) /* Also covers clang */ +# define UA_THREAD_LOCAL __thread +# elif defined(_MSC_VER) +# define UA_THREAD_LOCAL __declspec(thread) +# endif +#endif +#ifndef UA_THREAD_LOCAL +# define UA_THREAD_LOCAL +#endif + +/** + * Memory Management + * ----------------- + * + * The flag ``UA_ENABLE_MALLOC_SINGLETON`` enables singleton (global) variables + * with method pointers for memory management (malloc et al.). The method + * pointers can be switched out at runtime. Use-cases for this are testing of + * constrained memory conditions and arena-based custom memory management. + * + * If the flag is undefined, then ``UA_malloc`` etc. are set to the default + * malloc, as defined in ``/arch//ua_architecture.h``. + */ + +#ifdef UA_ENABLE_MALLOC_SINGLETON +extern UA_THREAD_LOCAL void * (*UA_mallocSingleton)(size_t size); +extern UA_THREAD_LOCAL void (*UA_freeSingleton)(void *ptr); +extern UA_THREAD_LOCAL void * (*UA_callocSingleton)(size_t nelem, size_t elsize); +extern UA_THREAD_LOCAL void * (*UA_reallocSingleton)(void *ptr, size_t size); +# define UA_malloc(size) UA_mallocSingleton(size) +# define UA_free(ptr) UA_freeSingleton(ptr) +# define UA_calloc(num, size) UA_callocSingleton(num, size) +# define UA_realloc(ptr, size) UA_reallocSingleton(ptr, size) +#endif + +/* Stack-allocation of memory. Use C99 variable-length arrays if possible. + * Otherwise revert to alloca. Note that alloca is not supported on some + * plattforms. */ +#ifndef UA_STACKARRAY +# if defined(__GNUC__) || defined(__clang__) +# define UA_STACKARRAY(TYPE, NAME, SIZE) TYPE NAME[SIZE] +# else +# if defined(__GNUC__) || defined(__clang__) +# define UA_alloca(size) __builtin_alloca (size) +# elif defined(_WIN32) +# define UA_alloca(SIZE) _alloca(SIZE) +# else +# include +# define UA_alloca(SIZE) alloca(SIZE) +# endif +# define UA_STACKARRAY(TYPE, NAME, SIZE) \ + /* cppcheck-suppress allocaCalled */ \ + TYPE *(NAME) = (TYPE*)UA_alloca(sizeof(TYPE) * (SIZE)) +# endif +#endif + +/** + * Assertions + * ---------- + * The assert macro is disabled by defining NDEBUG. It is often forgotten to + * include -DNDEBUG in the compiler flags when using the single-file release. So + * we make assertions dependent on the UA_DEBUG definition handled by CMake. */ +#ifdef UA_DEBUG +# include +# define UA_assert(ignore) assert(ignore) +#else +# define UA_assert(ignore) do {} while(0) +#endif + +/* Outputs an error message at compile time if the assert fails. + * Example usage: + * UA_STATIC_ASSERT(sizeof(long)==7, use_another_compiler_luke) + * See: https://stackoverflow.com/a/4815532/869402 */ +#if defined(__cplusplus) && __cplusplus >= 201103L /* C++11 or above */ +# define UA_STATIC_ASSERT(cond,msg) static_assert(cond, #msg) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L /* C11 or above */ +# define UA_STATIC_ASSERT(cond,msg) _Static_assert(cond, #msg) +#elif defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER) /* GCC, Clang, MSC */ +# define UA_CTASTR2(pre,post) pre ## post +# define UA_CTASTR(pre,post) UA_CTASTR2(pre,post) +# ifndef __COUNTER__ /* PPC GCC fix */ +# define __COUNTER__ __LINE__ +# endif +# define UA_STATIC_ASSERT(cond,msg) \ + typedef struct { \ + int UA_CTASTR(static_assertion_failed_,msg) : !!(cond); \ + } UA_CTASTR(static_assertion_failed_,__COUNTER__) +#else /* Everybody else */ +# define UA_STATIC_ASSERT(cond,msg) typedef char static_assertion_##msg[(cond)?1:-1] +#endif + +/** + * Dynamic Linking + * --------------- + * Explicit attribute for functions to be exported in a shared library. */ +#if defined(_WIN32) && defined(UA_DYNAMIC_LINKING) +# ifdef UA_DYNAMIC_LINKING_EXPORT /* export dll */ +# ifdef __GNUC__ +# define UA_EXPORT __attribute__ ((dllexport)) +# else +# define UA_EXPORT __declspec(dllexport) +# endif +# else /* import dll */ +# ifdef __GNUC__ +# define UA_EXPORT __attribute__ ((dllimport)) +# else +# define UA_EXPORT __declspec(dllimport) +# endif +# endif +#else /* non win32 */ +# if __GNUC__ || __clang__ +# define UA_EXPORT __attribute__ ((visibility ("default"))) +# endif +#endif +#ifndef UA_EXPORT +# define UA_EXPORT /* fallback to default */ +#endif + +/** + * Threadsafe functions + * -------------------- + * Functions that can be called from independent threads are marked with + * the UA_THREADSAFE macro. This is currently only an information for the + * developer. It can be used in the future for instrumentation and static + * code analysis. */ +#define UA_THREADSAFE + +/** + * Inline Functions + * ---------------- */ +#ifdef _MSC_VER +# define UA_INLINE __inline +#else +# define UA_INLINE inline +#endif + +/** + * Non-aliasing pointers + * -------------------- */ +#ifdef _MSC_VER +# define UA_RESTRICT __restrict +#elif defined(__GNUC__) +# define UA_RESTRICT __restrict__ +#elif defined(__CODEGEARC__) +# define UA_RESTRICT _RESTRICT +#else +# define UA_RESTRICT restrict +#endif + +/** + * Likely/Unlikely Conditions + * -------------------------- + * Condition is likely/unlikely, to help branch prediction. */ +#if defined(__GNUC__) || defined(__clang__) +# define UA_LIKELY(x) __builtin_expect((x), 1) +# define UA_UNLIKELY(x) __builtin_expect((x), 0) +#else +# define UA_LIKELY(x) x +# define UA_UNLIKELY(x) x +#endif + +/** + * Function attributes + * ------------------- */ +#if defined(__GNUC__) || defined(__clang__) +# define UA_FUNC_ATTR_MALLOC __attribute__((malloc)) +# define UA_FUNC_ATTR_PURE __attribute__ ((pure)) +# define UA_FUNC_ATTR_CONST __attribute__((const)) +# define UA_FUNC_ATTR_WARN_UNUSED_RESULT __attribute__((warn_unused_result)) +# define UA_FORMAT(X,Y) __attribute__ ((format (printf, X, Y))) +#elif defined(_MSC_VER) && _MSC_VER >= 1800 +# include +# define UA_FUNC_ATTR_MALLOC +# define UA_FUNC_ATTR_PURE +# define UA_FUNC_ATTR_CONST +# define UA_FUNC_ATTR_WARN_UNUSED_RESULT _Check_return_ +# define UA_FORMAT(X,Y) +#else +# define UA_FUNC_ATTR_MALLOC +# define UA_FUNC_ATTR_PURE +# define UA_FUNC_ATTR_CONST +# define UA_FUNC_ATTR_WARN_UNUSED_RESULT +# define UA_FORMAT(X,Y) +#endif + +#if defined(__GNUC__) || defined(__clang__) +# define UA_DEPRECATED __attribute__((deprecated)) +#elif defined(_MSC_VER) +# define UA_DEPRECATED __declspec(deprecated) +#else +# define UA_DEPRECATED +#endif + +/** + * Internal Attributes + * ------------------- + * These attributes are only defined if the macro UA_INTERNAL is defined. That + * way public methods can be annotated (e.g. to warn for unused results) but + * warnings are only triggered for internal code. */ + +#if defined(UA_INTERNAL) && (defined(__GNUC__) || defined(__clang__)) +# define UA_INTERNAL_DEPRECATED \ + _Pragma ("GCC warning \"Macro is deprecated for internal use\"") +#else +# define UA_INTERNAL_DEPRECATED +#endif + +#if defined(UA_INTERNAL) && (defined(__GNUC__) || defined(__clang__)) +# define UA_INTERNAL_FUNC_ATTR_WARN_UNUSED_RESULT \ + __attribute__((warn_unused_result)) +#else +# define UA_INTERNAL_FUNC_ATTR_WARN_UNUSED_RESULT +#endif + +/** + * Detect Endianness and IEEE 754 floating point + * --------------------------------------------- + * Integers and floating point numbers are transmitted in little-endian (IEEE + * 754 for floating point) encoding. If the target architecture uses the same + * format, numeral datatypes can be memcpy'd (overlayed) on the network buffer. + * Otherwise, a slow default encoding routine is used that works for every + * architecture. + * + * Integer Endianness + * ^^^^^^^^^^^^^^^^^^ + * The definition ``UA_LITTLE_ENDIAN`` is true when the integer representation + * of the target architecture is little-endian. */ +#if defined(_WIN32) +# define UA_LITTLE_ENDIAN 1 +#elif defined(__i386__) || defined(__x86_64__) || defined(__amd64__) +# define UA_LITTLE_ENDIAN 1 +#elif (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \ + (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)) +# define UA_LITTLE_ENDIAN 1 +#elif defined(__linux__) /* Linux (including Android) */ +# include +# if __BYTE_ORDER == __LITTLE_ENDIAN +# define UA_LITTLE_ENDIAN 1 +# endif +#elif defined(__OpenBSD__) /* OpenBSD */ +# include +# if BYTE_ORDER == LITTLE_ENDIAN +# define UA_LITTLE_ENDIAN 1 +# endif +#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) /* Other BSD */ +# include +# if _BYTE_ORDER == _LITTLE_ENDIAN +# define UA_LITTLE_ENDIAN 1 +# endif +#elif defined(__APPLE__) /* Apple (MacOS, iOS) */ +# include +# if defined(__LITTLE_ENDIAN__) +# define UA_LITTLE_ENDIAN 1 +# endif +#elif defined(__QNX__) || defined(__QNXNTO__) /* QNX */ +# include +# if defined(__LITTLEENDIAN__) +# define UA_LITTLE_ENDIAN 1 +# endif +#elif defined(_OS9000) /* OS-9 */ +# if defined(_LIL_END) +# define UA_LITTLE_ENDIAN 1 +# endif +#endif +#ifndef UA_LITTLE_ENDIAN +# define UA_LITTLE_ENDIAN 0 +#endif + +/* Can the integers be memcpy'd onto the network buffer? Add additional checks + * here. Some platforms (e.g. QNX) have sizeof(bool) > 1. Manually disable + * overlayed integer encoding if that is the case. */ +#if (UA_LITTLE_ENDIAN == 1) +UA_STATIC_ASSERT(sizeof(bool) == 1, cannot_overlay_integers_with_large_bool); +# define UA_BINARY_OVERLAYABLE_INTEGER 1 +#else +# define UA_BINARY_OVERLAYABLE_INTEGER 0 +#endif + +/** + * Float Endianness + * ^^^^^^^^^^^^^^^^ + * The definition ``UA_FLOAT_IEEE754`` is set to true when the floating point + * number representation of the target architecture is IEEE 754. The definition + * ``UA_FLOAT_LITTLE_ENDIAN`` is set to true when the floating point number + * representation is in little-endian encoding. */ + +#if defined(_WIN32) +# define UA_FLOAT_IEEE754 1 +#elif defined(__i386__) || defined(__x86_64__) || defined(__amd64__) || \ + defined(__ia64__) || defined(__powerpc__) || defined(__sparc__) || \ + defined(__arm__) +# define UA_FLOAT_IEEE754 1 +#elif defined(__STDC_IEC_559__) +# define UA_FLOAT_IEEE754 1 +#else +# define UA_FLOAT_IEEE754 0 +#endif + +/* Wikipedia says (https://en.wikipedia.org/wiki/Endianness): Although the + * ubiquitous x86 processors of today use little-endian storage for all types of + * data (integer, floating point, BCD), there are a number of hardware + * architectures where floating-point numbers are represented in big-endian form + * while integers are represented in little-endian form. */ +#if defined(_WIN32) +# define UA_FLOAT_LITTLE_ENDIAN 1 +#elif defined(__i386__) || defined(__x86_64__) || defined(__amd64__) +# define UA_FLOAT_LITTLE_ENDIAN 1 +#elif defined(__FLOAT_WORD_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \ + (__FLOAT_WORD_ORDER__ == __ORDER_LITTLE_ENDIAN__) /* Defined only in GCC */ +# define UA_FLOAT_LITTLE_ENDIAN 1 +#elif defined(__FLOAT_WORD_ORDER) && defined(__LITTLE_ENDIAN) && \ + (__FLOAT_WORD_ORDER == __LITTLE_ENDIAN) /* Defined only in GCC */ +# define UA_FLOAT_LITTLE_ENDIAN 1 +#endif +#ifndef UA_FLOAT_LITTLE_ENDIAN +# define UA_FLOAT_LITTLE_ENDIAN 0 +#endif + +/* Only if the floating points are litle-endian **and** in IEEE 754 format can + * we memcpy directly onto the network buffer. */ +#if (UA_FLOAT_IEEE754 == 1) && (UA_FLOAT_LITTLE_ENDIAN == 1) +# define UA_BINARY_OVERLAYABLE_FLOAT 1 +#else +# define UA_BINARY_OVERLAYABLE_FLOAT 0 +#endif + +/* Atomic Operations + * ----------------- + * Atomic operations that synchronize across processor cores (for + * multithreading). Only the inline-functions defined next are used. Replace + * with architecture-specific operations if necessary. */ +#if UA_MULTITHREADING >= 100 + #ifdef _MSC_VER /* Visual Studio */ + #define UA_atomic_sync() _ReadWriteBarrier() + #else /* GCC/Clang */ + #define UA_atomic_sync() __sync_synchronize() + #endif +#else + #define UA_atomic_sync() +#endif + +static UA_INLINE void * +UA_atomic_xchg(void * volatile * addr, void *newptr) { +#if UA_MULTITHREADING >= 100 +#ifdef _MSC_VER /* Visual Studio */ + return _InterlockedExchangePointer(addr, newptr); +#else /* GCC/Clang */ + return __sync_lock_test_and_set(addr, newptr); +#endif +#else + void *old = *addr; + *addr = newptr; + return old; +#endif +} + +static UA_INLINE void * +UA_atomic_cmpxchg(void * volatile * addr, void *expected, void *newptr) { +#if UA_MULTITHREADING >= 100 +#ifdef _MSC_VER /* Visual Studio */ + return _InterlockedCompareExchangePointer(addr, expected, newptr); +#else /* GCC/Clang */ + return __sync_val_compare_and_swap(addr, expected, newptr); +#endif +#else + void *old = *addr; + if(old == expected) { + *addr = newptr; + } + return old; +#endif +} + +static UA_INLINE uint32_t +UA_atomic_addUInt32(volatile uint32_t *addr, uint32_t increase) { +#if UA_MULTITHREADING >= 100 +#ifdef _MSC_VER /* Visual Studio */ + return _InterlockedExchangeAdd(addr, increase) + increase; +#else /* GCC/Clang */ + return __sync_add_and_fetch(addr, increase); +#endif +#else + *addr += increase; + return *addr; +#endif +} + +static UA_INLINE size_t +UA_atomic_addSize(volatile size_t *addr, size_t increase) { +#if UA_MULTITHREADING >= 100 +#ifdef _MSC_VER /* Visual Studio */ + return _InterlockedExchangeAdd(addr, increase) + increase; +#else /* GCC/Clang */ + return __sync_add_and_fetch(addr, increase); +#endif +#else + *addr += increase; + return *addr; +#endif +} + +static UA_INLINE uint32_t +UA_atomic_subUInt32(volatile uint32_t *addr, uint32_t decrease) { +#if UA_MULTITHREADING >= 100 +#ifdef _MSC_VER /* Visual Studio */ + return _InterlockedExchangeSub(addr, decrease) - decrease; +#else /* GCC/Clang */ + return __sync_sub_and_fetch(addr, decrease); +#endif +#else + *addr -= decrease; + return *addr; +#endif +} + +static UA_INLINE size_t +UA_atomic_subSize(volatile size_t *addr, size_t decrease) { +#if UA_MULTITHREADING >= 100 +#ifdef _MSC_VER /* Visual Studio */ + return _InterlockedExchangeSub(addr, decrease) - decrease; +#else /* GCC/Clang */ + return __sync_sub_and_fetch(addr, decrease); +#endif +#else + *addr -= decrease; + return *addr; +#endif +} + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/statuscodes.h" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + +/** + * .. _statuscodes: + * + * StatusCodes + * ----------- + * StatusCodes are extensively used in the OPC UA protocol and in the open62541 + * API. They are represented by the :ref:`statuscode` data type. The following + * definitions are autogenerated from the ``Opc.Ua.StatusCodes.csv`` file provided + * with the OPC UA standard. */ + +/* These StatusCodes are manually generated. */ +#define UA_STATUSCODE_INFOTYPE_DATAVALUE 0x00000400 +#define UA_STATUSCODE_INFOBITS_OVERFLOW 0x00000080 + +/* "The operation succeeded." */ +#define UA_STATUSCODE_GOOD 0x00000000 + +/* "The operation was uncertain." */ +#define UA_STATUSCODE_UNCERTAIN 0x40000000 + +/* "The operation failed." */ +#define UA_STATUSCODE_BAD 0x80000000 + +/* "An unexpected error occurred." */ +#define UA_STATUSCODE_BADUNEXPECTEDERROR 0x80010000 + +/* "An internal error occurred as a result of a programming or configuration error." */ +#define UA_STATUSCODE_BADINTERNALERROR 0x80020000 + +/* "Not enough memory to complete the operation." */ +#define UA_STATUSCODE_BADOUTOFMEMORY 0x80030000 + +/* "An operating system resource is not available." */ +#define UA_STATUSCODE_BADRESOURCEUNAVAILABLE 0x80040000 + +/* "A low level communication error occurred." */ +#define UA_STATUSCODE_BADCOMMUNICATIONERROR 0x80050000 + +/* "Encoding halted because of invalid data in the objects being serialized." */ +#define UA_STATUSCODE_BADENCODINGERROR 0x80060000 + +/* "Decoding halted because of invalid data in the stream." */ +#define UA_STATUSCODE_BADDECODINGERROR 0x80070000 + +/* "The message encoding/decoding limits imposed by the stack have been exceeded." */ +#define UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED 0x80080000 + +/* "The request message size exceeds limits set by the server." */ +#define UA_STATUSCODE_BADREQUESTTOOLARGE 0x80B80000 + +/* "The response message size exceeds limits set by the client." */ +#define UA_STATUSCODE_BADRESPONSETOOLARGE 0x80B90000 + +/* "An unrecognized response was received from the server." */ +#define UA_STATUSCODE_BADUNKNOWNRESPONSE 0x80090000 + +/* "The operation timed out." */ +#define UA_STATUSCODE_BADTIMEOUT 0x800A0000 + +/* "The server does not support the requested service." */ +#define UA_STATUSCODE_BADSERVICEUNSUPPORTED 0x800B0000 + +/* "The operation was cancelled because the application is shutting down." */ +#define UA_STATUSCODE_BADSHUTDOWN 0x800C0000 + +/* "The operation could not complete because the client is not connected to the server." */ +#define UA_STATUSCODE_BADSERVERNOTCONNECTED 0x800D0000 + +/* "The server has stopped and cannot process any requests." */ +#define UA_STATUSCODE_BADSERVERHALTED 0x800E0000 + +/* "There was nothing to do because the client passed a list of operations with no elements." */ +#define UA_STATUSCODE_BADNOTHINGTODO 0x800F0000 + +/* "The request could not be processed because it specified too many operations." */ +#define UA_STATUSCODE_BADTOOMANYOPERATIONS 0x80100000 + +/* "The request could not be processed because there are too many monitored items in the subscription." */ +#define UA_STATUSCODE_BADTOOMANYMONITOREDITEMS 0x80DB0000 + +/* "The extension object cannot be (de)serialized because the data type id is not recognized." */ +#define UA_STATUSCODE_BADDATATYPEIDUNKNOWN 0x80110000 + +/* "The certificate provided as a parameter is not valid." */ +#define UA_STATUSCODE_BADCERTIFICATEINVALID 0x80120000 + +/* "An error occurred verifying security." */ +#define UA_STATUSCODE_BADSECURITYCHECKSFAILED 0x80130000 + +/* "The certificate does not meet the requirements of the security policy." */ +#define UA_STATUSCODE_BADCERTIFICATEPOLICYCHECKFAILED 0x81140000 + +/* "The certificate has expired or is not yet valid." */ +#define UA_STATUSCODE_BADCERTIFICATETIMEINVALID 0x80140000 + +/* "An issuer certificate has expired or is not yet valid." */ +#define UA_STATUSCODE_BADCERTIFICATEISSUERTIMEINVALID 0x80150000 + +/* "The HostName used to connect to a server does not match a HostName in the certificate." */ +#define UA_STATUSCODE_BADCERTIFICATEHOSTNAMEINVALID 0x80160000 + +/* "The URI specified in the ApplicationDescription does not match the URI in the certificate." */ +#define UA_STATUSCODE_BADCERTIFICATEURIINVALID 0x80170000 + +/* "The certificate may not be used for the requested operation." */ +#define UA_STATUSCODE_BADCERTIFICATEUSENOTALLOWED 0x80180000 + +/* "The issuer certificate may not be used for the requested operation." */ +#define UA_STATUSCODE_BADCERTIFICATEISSUERUSENOTALLOWED 0x80190000 + +/* "The certificate is not trusted." */ +#define UA_STATUSCODE_BADCERTIFICATEUNTRUSTED 0x801A0000 + +/* "It was not possible to determine if the certificate has been revoked." */ +#define UA_STATUSCODE_BADCERTIFICATEREVOCATIONUNKNOWN 0x801B0000 + +/* "It was not possible to determine if the issuer certificate has been revoked." */ +#define UA_STATUSCODE_BADCERTIFICATEISSUERREVOCATIONUNKNOWN 0x801C0000 + +/* "The certificate has been revoked." */ +#define UA_STATUSCODE_BADCERTIFICATEREVOKED 0x801D0000 + +/* "The issuer certificate has been revoked." */ +#define UA_STATUSCODE_BADCERTIFICATEISSUERREVOKED 0x801E0000 + +/* "The certificate chain is incomplete." */ +#define UA_STATUSCODE_BADCERTIFICATECHAININCOMPLETE 0x810D0000 + +/* "User does not have permission to perform the requested operation." */ +#define UA_STATUSCODE_BADUSERACCESSDENIED 0x801F0000 + +/* "The user identity token is not valid." */ +#define UA_STATUSCODE_BADIDENTITYTOKENINVALID 0x80200000 + +/* "The user identity token is valid but the server has rejected it." */ +#define UA_STATUSCODE_BADIDENTITYTOKENREJECTED 0x80210000 + +/* "The specified secure channel is no longer valid." */ +#define UA_STATUSCODE_BADSECURECHANNELIDINVALID 0x80220000 + +/* "The timestamp is outside the range allowed by the server." */ +#define UA_STATUSCODE_BADINVALIDTIMESTAMP 0x80230000 + +/* "The nonce does appear to be not a random value or it is not the correct length." */ +#define UA_STATUSCODE_BADNONCEINVALID 0x80240000 + +/* "The session id is not valid." */ +#define UA_STATUSCODE_BADSESSIONIDINVALID 0x80250000 + +/* "The session was closed by the client." */ +#define UA_STATUSCODE_BADSESSIONCLOSED 0x80260000 + +/* "The session cannot be used because ActivateSession has not been called." */ +#define UA_STATUSCODE_BADSESSIONNOTACTIVATED 0x80270000 + +/* "The subscription id is not valid." */ +#define UA_STATUSCODE_BADSUBSCRIPTIONIDINVALID 0x80280000 + +/* "The header for the request is missing or invalid." */ +#define UA_STATUSCODE_BADREQUESTHEADERINVALID 0x802A0000 + +/* "The timestamps to return parameter is invalid." */ +#define UA_STATUSCODE_BADTIMESTAMPSTORETURNINVALID 0x802B0000 + +/* "The request was cancelled by the client." */ +#define UA_STATUSCODE_BADREQUESTCANCELLEDBYCLIENT 0x802C0000 + +/* "Too many arguments were provided." */ +#define UA_STATUSCODE_BADTOOMANYARGUMENTS 0x80E50000 + +/* "The server requires a license to operate in general or to perform a service or operation */ +#define UA_STATUSCODE_BADLICENSEEXPIRED 0x810E0000 + +/* "The server has limits on number of allowed operations / objects */ +#define UA_STATUSCODE_BADLICENSELIMITSEXCEEDED 0x810F0000 + +/* "The server does not have a license which is required to operate in general or to perform a service or operation." */ +#define UA_STATUSCODE_BADLICENSENOTAVAILABLE 0x81100000 + +/* "The subscription was transferred to another session." */ +#define UA_STATUSCODE_GOODSUBSCRIPTIONTRANSFERRED 0x002D0000 + +/* "The processing will complete asynchronously." */ +#define UA_STATUSCODE_GOODCOMPLETESASYNCHRONOUSLY 0x002E0000 + +/* "Sampling has slowed down due to resource limitations." */ +#define UA_STATUSCODE_GOODOVERLOAD 0x002F0000 + +/* "The value written was accepted but was clamped." */ +#define UA_STATUSCODE_GOODCLAMPED 0x00300000 + +/* "Communication with the data source is defined */ +#define UA_STATUSCODE_BADNOCOMMUNICATION 0x80310000 + +/* "Waiting for the server to obtain values from the underlying data source." */ +#define UA_STATUSCODE_BADWAITINGFORINITIALDATA 0x80320000 + +/* "The syntax of the node id is not valid." */ +#define UA_STATUSCODE_BADNODEIDINVALID 0x80330000 + +/* "The node id refers to a node that does not exist in the server address space." */ +#define UA_STATUSCODE_BADNODEIDUNKNOWN 0x80340000 + +/* "The attribute is not supported for the specified Node." */ +#define UA_STATUSCODE_BADATTRIBUTEIDINVALID 0x80350000 + +/* "The syntax of the index range parameter is invalid." */ +#define UA_STATUSCODE_BADINDEXRANGEINVALID 0x80360000 + +/* "No data exists within the range of indexes specified." */ +#define UA_STATUSCODE_BADINDEXRANGENODATA 0x80370000 + +/* "The data encoding is invalid." */ +#define UA_STATUSCODE_BADDATAENCODINGINVALID 0x80380000 + +/* "The server does not support the requested data encoding for the node." */ +#define UA_STATUSCODE_BADDATAENCODINGUNSUPPORTED 0x80390000 + +/* "The access level does not allow reading or subscribing to the Node." */ +#define UA_STATUSCODE_BADNOTREADABLE 0x803A0000 + +/* "The access level does not allow writing to the Node." */ +#define UA_STATUSCODE_BADNOTWRITABLE 0x803B0000 + +/* "The value was out of range." */ +#define UA_STATUSCODE_BADOUTOFRANGE 0x803C0000 + +/* "The requested operation is not supported." */ +#define UA_STATUSCODE_BADNOTSUPPORTED 0x803D0000 + +/* "A requested item was not found or a search operation ended without success." */ +#define UA_STATUSCODE_BADNOTFOUND 0x803E0000 + +/* "The object cannot be used because it has been deleted." */ +#define UA_STATUSCODE_BADOBJECTDELETED 0x803F0000 + +/* "Requested operation is not implemented." */ +#define UA_STATUSCODE_BADNOTIMPLEMENTED 0x80400000 + +/* "The monitoring mode is invalid." */ +#define UA_STATUSCODE_BADMONITORINGMODEINVALID 0x80410000 + +/* "The monitoring item id does not refer to a valid monitored item." */ +#define UA_STATUSCODE_BADMONITOREDITEMIDINVALID 0x80420000 + +/* "The monitored item filter parameter is not valid." */ +#define UA_STATUSCODE_BADMONITOREDITEMFILTERINVALID 0x80430000 + +/* "The server does not support the requested monitored item filter." */ +#define UA_STATUSCODE_BADMONITOREDITEMFILTERUNSUPPORTED 0x80440000 + +/* "A monitoring filter cannot be used in combination with the attribute specified." */ +#define UA_STATUSCODE_BADFILTERNOTALLOWED 0x80450000 + +/* "A mandatory structured parameter was missing or null." */ +#define UA_STATUSCODE_BADSTRUCTUREMISSING 0x80460000 + +/* "The event filter is not valid." */ +#define UA_STATUSCODE_BADEVENTFILTERINVALID 0x80470000 + +/* "The content filter is not valid." */ +#define UA_STATUSCODE_BADCONTENTFILTERINVALID 0x80480000 + +/* "An unrecognized operator was provided in a filter." */ +#define UA_STATUSCODE_BADFILTEROPERATORINVALID 0x80C10000 + +/* "A valid operator was provided */ +#define UA_STATUSCODE_BADFILTEROPERATORUNSUPPORTED 0x80C20000 + +/* "The number of operands provided for the filter operator was less then expected for the operand provided." */ +#define UA_STATUSCODE_BADFILTEROPERANDCOUNTMISMATCH 0x80C30000 + +/* "The operand used in a content filter is not valid." */ +#define UA_STATUSCODE_BADFILTEROPERANDINVALID 0x80490000 + +/* "The referenced element is not a valid element in the content filter." */ +#define UA_STATUSCODE_BADFILTERELEMENTINVALID 0x80C40000 + +/* "The referenced literal is not a valid value." */ +#define UA_STATUSCODE_BADFILTERLITERALINVALID 0x80C50000 + +/* "The continuation point provide is longer valid." */ +#define UA_STATUSCODE_BADCONTINUATIONPOINTINVALID 0x804A0000 + +/* "The operation could not be processed because all continuation points have been allocated." */ +#define UA_STATUSCODE_BADNOCONTINUATIONPOINTS 0x804B0000 + +/* "The reference type id does not refer to a valid reference type node." */ +#define UA_STATUSCODE_BADREFERENCETYPEIDINVALID 0x804C0000 + +/* "The browse direction is not valid." */ +#define UA_STATUSCODE_BADBROWSEDIRECTIONINVALID 0x804D0000 + +/* "The node is not part of the view." */ +#define UA_STATUSCODE_BADNODENOTINVIEW 0x804E0000 + +/* "The number was not accepted because of a numeric overflow." */ +#define UA_STATUSCODE_BADNUMERICOVERFLOW 0x81120000 + +/* "The ServerUri is not a valid URI." */ +#define UA_STATUSCODE_BADSERVERURIINVALID 0x804F0000 + +/* "No ServerName was specified." */ +#define UA_STATUSCODE_BADSERVERNAMEMISSING 0x80500000 + +/* "No DiscoveryUrl was specified." */ +#define UA_STATUSCODE_BADDISCOVERYURLMISSING 0x80510000 + +/* "The semaphore file specified by the client is not valid." */ +#define UA_STATUSCODE_BADSEMPAHOREFILEMISSING 0x80520000 + +/* "The security token request type is not valid." */ +#define UA_STATUSCODE_BADREQUESTTYPEINVALID 0x80530000 + +/* "The security mode does not meet the requirements set by the server." */ +#define UA_STATUSCODE_BADSECURITYMODEREJECTED 0x80540000 + +/* "The security policy does not meet the requirements set by the server." */ +#define UA_STATUSCODE_BADSECURITYPOLICYREJECTED 0x80550000 + +/* "The server has reached its maximum number of sessions." */ +#define UA_STATUSCODE_BADTOOMANYSESSIONS 0x80560000 + +/* "The user token signature is missing or invalid." */ +#define UA_STATUSCODE_BADUSERSIGNATUREINVALID 0x80570000 + +/* "The signature generated with the client certificate is missing or invalid." */ +#define UA_STATUSCODE_BADAPPLICATIONSIGNATUREINVALID 0x80580000 + +/* "The client did not provide at least one software certificate that is valid and meets the profile requirements for the server." */ +#define UA_STATUSCODE_BADNOVALIDCERTIFICATES 0x80590000 + +/* "The server does not support changing the user identity assigned to the session." */ +#define UA_STATUSCODE_BADIDENTITYCHANGENOTSUPPORTED 0x80C60000 + +/* "The request was cancelled by the client with the Cancel service." */ +#define UA_STATUSCODE_BADREQUESTCANCELLEDBYREQUEST 0x805A0000 + +/* "The parent node id does not to refer to a valid node." */ +#define UA_STATUSCODE_BADPARENTNODEIDINVALID 0x805B0000 + +/* "The reference could not be created because it violates constraints imposed by the data model." */ +#define UA_STATUSCODE_BADREFERENCENOTALLOWED 0x805C0000 + +/* "The requested node id was reject because it was either invalid or server does not allow node ids to be specified by the client." */ +#define UA_STATUSCODE_BADNODEIDREJECTED 0x805D0000 + +/* "The requested node id is already used by another node." */ +#define UA_STATUSCODE_BADNODEIDEXISTS 0x805E0000 + +/* "The node class is not valid." */ +#define UA_STATUSCODE_BADNODECLASSINVALID 0x805F0000 + +/* "The browse name is invalid." */ +#define UA_STATUSCODE_BADBROWSENAMEINVALID 0x80600000 + +/* "The browse name is not unique among nodes that share the same relationship with the parent." */ +#define UA_STATUSCODE_BADBROWSENAMEDUPLICATED 0x80610000 + +/* "The node attributes are not valid for the node class." */ +#define UA_STATUSCODE_BADNODEATTRIBUTESINVALID 0x80620000 + +/* "The type definition node id does not reference an appropriate type node." */ +#define UA_STATUSCODE_BADTYPEDEFINITIONINVALID 0x80630000 + +/* "The source node id does not reference a valid node." */ +#define UA_STATUSCODE_BADSOURCENODEIDINVALID 0x80640000 + +/* "The target node id does not reference a valid node." */ +#define UA_STATUSCODE_BADTARGETNODEIDINVALID 0x80650000 + +/* "The reference type between the nodes is already defined." */ +#define UA_STATUSCODE_BADDUPLICATEREFERENCENOTALLOWED 0x80660000 + +/* "The server does not allow this type of self reference on this node." */ +#define UA_STATUSCODE_BADINVALIDSELFREFERENCE 0x80670000 + +/* "The reference type is not valid for a reference to a remote server." */ +#define UA_STATUSCODE_BADREFERENCELOCALONLY 0x80680000 + +/* "The server will not allow the node to be deleted." */ +#define UA_STATUSCODE_BADNODELETERIGHTS 0x80690000 + +/* "The server was not able to delete all target references." */ +#define UA_STATUSCODE_UNCERTAINREFERENCENOTDELETED 0x40BC0000 + +/* "The server index is not valid." */ +#define UA_STATUSCODE_BADSERVERINDEXINVALID 0x806A0000 + +/* "The view id does not refer to a valid view node." */ +#define UA_STATUSCODE_BADVIEWIDUNKNOWN 0x806B0000 + +/* "The view timestamp is not available or not supported." */ +#define UA_STATUSCODE_BADVIEWTIMESTAMPINVALID 0x80C90000 + +/* "The view parameters are not consistent with each other." */ +#define UA_STATUSCODE_BADVIEWPARAMETERMISMATCH 0x80CA0000 + +/* "The view version is not available or not supported." */ +#define UA_STATUSCODE_BADVIEWVERSIONINVALID 0x80CB0000 + +/* "The list of references may not be complete because the underlying system is not available." */ +#define UA_STATUSCODE_UNCERTAINNOTALLNODESAVAILABLE 0x40C00000 + +/* "The server should have followed a reference to a node in a remote server but did not. The result set may be incomplete." */ +#define UA_STATUSCODE_GOODRESULTSMAYBEINCOMPLETE 0x00BA0000 + +/* "The provided Nodeid was not a type definition nodeid." */ +#define UA_STATUSCODE_BADNOTTYPEDEFINITION 0x80C80000 + +/* "One of the references to follow in the relative path references to a node in the address space in another server." */ +#define UA_STATUSCODE_UNCERTAINREFERENCEOUTOFSERVER 0x406C0000 + +/* "The requested operation has too many matches to return." */ +#define UA_STATUSCODE_BADTOOMANYMATCHES 0x806D0000 + +/* "The requested operation requires too many resources in the server." */ +#define UA_STATUSCODE_BADQUERYTOOCOMPLEX 0x806E0000 + +/* "The requested operation has no match to return." */ +#define UA_STATUSCODE_BADNOMATCH 0x806F0000 + +/* "The max age parameter is invalid." */ +#define UA_STATUSCODE_BADMAXAGEINVALID 0x80700000 + +/* "The operation is not permitted over the current secure channel." */ +#define UA_STATUSCODE_BADSECURITYMODEINSUFFICIENT 0x80E60000 + +/* "The history details parameter is not valid." */ +#define UA_STATUSCODE_BADHISTORYOPERATIONINVALID 0x80710000 + +/* "The server does not support the requested operation." */ +#define UA_STATUSCODE_BADHISTORYOPERATIONUNSUPPORTED 0x80720000 + +/* "The defined timestamp to return was invalid." */ +#define UA_STATUSCODE_BADINVALIDTIMESTAMPARGUMENT 0x80BD0000 + +/* "The server does not support writing the combination of value */ +#define UA_STATUSCODE_BADWRITENOTSUPPORTED 0x80730000 + +/* "The value supplied for the attribute is not of the same type as the attribute's value." */ +#define UA_STATUSCODE_BADTYPEMISMATCH 0x80740000 + +/* "The method id does not refer to a method for the specified object." */ +#define UA_STATUSCODE_BADMETHODINVALID 0x80750000 + +/* "The client did not specify all of the input arguments for the method." */ +#define UA_STATUSCODE_BADARGUMENTSMISSING 0x80760000 + +/* "The executable attribute does not allow the execution of the method." */ +#define UA_STATUSCODE_BADNOTEXECUTABLE 0x81110000 + +/* "The server has reached its maximum number of subscriptions." */ +#define UA_STATUSCODE_BADTOOMANYSUBSCRIPTIONS 0x80770000 + +/* "The server has reached the maximum number of queued publish requests." */ +#define UA_STATUSCODE_BADTOOMANYPUBLISHREQUESTS 0x80780000 + +/* "There is no subscription available for this session." */ +#define UA_STATUSCODE_BADNOSUBSCRIPTION 0x80790000 + +/* "The sequence number is unknown to the server." */ +#define UA_STATUSCODE_BADSEQUENCENUMBERUNKNOWN 0x807A0000 + +/* "The Server does not support retransmission queue and acknowledgement of sequence numbers is not available." */ +#define UA_STATUSCODE_GOODRETRANSMISSIONQUEUENOTSUPPORTED 0x00DF0000 + +/* "The requested notification message is no longer available." */ +#define UA_STATUSCODE_BADMESSAGENOTAVAILABLE 0x807B0000 + +/* "The client of the current session does not support one or more Profiles that are necessary for the subscription." */ +#define UA_STATUSCODE_BADINSUFFICIENTCLIENTPROFILE 0x807C0000 + +/* "The sub-state machine is not currently active." */ +#define UA_STATUSCODE_BADSTATENOTACTIVE 0x80BF0000 + +/* "An equivalent rule already exists." */ +#define UA_STATUSCODE_BADALREADYEXISTS 0x81150000 + +/* "The server cannot process the request because it is too busy." */ +#define UA_STATUSCODE_BADTCPSERVERTOOBUSY 0x807D0000 + +/* "The type of the message specified in the header invalid." */ +#define UA_STATUSCODE_BADTCPMESSAGETYPEINVALID 0x807E0000 + +/* "The SecureChannelId and/or TokenId are not currently in use." */ +#define UA_STATUSCODE_BADTCPSECURECHANNELUNKNOWN 0x807F0000 + +/* "The size of the message chunk specified in the header is too large." */ +#define UA_STATUSCODE_BADTCPMESSAGETOOLARGE 0x80800000 + +/* "There are not enough resources to process the request." */ +#define UA_STATUSCODE_BADTCPNOTENOUGHRESOURCES 0x80810000 + +/* "An internal error occurred." */ +#define UA_STATUSCODE_BADTCPINTERNALERROR 0x80820000 + +/* "The server does not recognize the QueryString specified." */ +#define UA_STATUSCODE_BADTCPENDPOINTURLINVALID 0x80830000 + +/* "The request could not be sent because of a network interruption." */ +#define UA_STATUSCODE_BADREQUESTINTERRUPTED 0x80840000 + +/* "Timeout occurred while processing the request." */ +#define UA_STATUSCODE_BADREQUESTTIMEOUT 0x80850000 + +/* "The secure channel has been closed." */ +#define UA_STATUSCODE_BADSECURECHANNELCLOSED 0x80860000 + +/* "The token has expired or is not recognized." */ +#define UA_STATUSCODE_BADSECURECHANNELTOKENUNKNOWN 0x80870000 + +/* "The sequence number is not valid." */ +#define UA_STATUSCODE_BADSEQUENCENUMBERINVALID 0x80880000 + +/* "The applications do not have compatible protocol versions." */ +#define UA_STATUSCODE_BADPROTOCOLVERSIONUNSUPPORTED 0x80BE0000 + +/* "There is a problem with the configuration that affects the usefulness of the value." */ +#define UA_STATUSCODE_BADCONFIGURATIONERROR 0x80890000 + +/* "The variable should receive its value from another variable */ +#define UA_STATUSCODE_BADNOTCONNECTED 0x808A0000 + +/* "There has been a failure in the device/data source that generates the value that has affected the value." */ +#define UA_STATUSCODE_BADDEVICEFAILURE 0x808B0000 + +/* "There has been a failure in the sensor from which the value is derived by the device/data source." */ +#define UA_STATUSCODE_BADSENSORFAILURE 0x808C0000 + +/* "The source of the data is not operational." */ +#define UA_STATUSCODE_BADOUTOFSERVICE 0x808D0000 + +/* "The deadband filter is not valid." */ +#define UA_STATUSCODE_BADDEADBANDFILTERINVALID 0x808E0000 + +/* "Communication to the data source has failed. The variable value is the last value that had a good quality." */ +#define UA_STATUSCODE_UNCERTAINNOCOMMUNICATIONLASTUSABLEVALUE 0x408F0000 + +/* "Whatever was updating this value has stopped doing so." */ +#define UA_STATUSCODE_UNCERTAINLASTUSABLEVALUE 0x40900000 + +/* "The value is an operational value that was manually overwritten." */ +#define UA_STATUSCODE_UNCERTAINSUBSTITUTEVALUE 0x40910000 + +/* "The value is an initial value for a variable that normally receives its value from another variable." */ +#define UA_STATUSCODE_UNCERTAININITIALVALUE 0x40920000 + +/* "The value is at one of the sensor limits." */ +#define UA_STATUSCODE_UNCERTAINSENSORNOTACCURATE 0x40930000 + +/* "The value is outside of the range of values defined for this parameter." */ +#define UA_STATUSCODE_UNCERTAINENGINEERINGUNITSEXCEEDED 0x40940000 + +/* "The value is derived from multiple sources and has less than the required number of Good sources." */ +#define UA_STATUSCODE_UNCERTAINSUBNORMAL 0x40950000 + +/* "The value has been overridden." */ +#define UA_STATUSCODE_GOODLOCALOVERRIDE 0x00960000 + +/* "This Condition refresh failed */ +#define UA_STATUSCODE_BADREFRESHINPROGRESS 0x80970000 + +/* "This condition has already been disabled." */ +#define UA_STATUSCODE_BADCONDITIONALREADYDISABLED 0x80980000 + +/* "This condition has already been enabled." */ +#define UA_STATUSCODE_BADCONDITIONALREADYENABLED 0x80CC0000 + +/* "Property not available */ +#define UA_STATUSCODE_BADCONDITIONDISABLED 0x80990000 + +/* "The specified event id is not recognized." */ +#define UA_STATUSCODE_BADEVENTIDUNKNOWN 0x809A0000 + +/* "The event cannot be acknowledged." */ +#define UA_STATUSCODE_BADEVENTNOTACKNOWLEDGEABLE 0x80BB0000 + +/* "The dialog condition is not active." */ +#define UA_STATUSCODE_BADDIALOGNOTACTIVE 0x80CD0000 + +/* "The response is not valid for the dialog." */ +#define UA_STATUSCODE_BADDIALOGRESPONSEINVALID 0x80CE0000 + +/* "The condition branch has already been acknowledged." */ +#define UA_STATUSCODE_BADCONDITIONBRANCHALREADYACKED 0x80CF0000 + +/* "The condition branch has already been confirmed." */ +#define UA_STATUSCODE_BADCONDITIONBRANCHALREADYCONFIRMED 0x80D00000 + +/* "The condition has already been shelved." */ +#define UA_STATUSCODE_BADCONDITIONALREADYSHELVED 0x80D10000 + +/* "The condition is not currently shelved." */ +#define UA_STATUSCODE_BADCONDITIONNOTSHELVED 0x80D20000 + +/* "The shelving time not within an acceptable range." */ +#define UA_STATUSCODE_BADSHELVINGTIMEOUTOFRANGE 0x80D30000 + +/* "No data exists for the requested time range or event filter." */ +#define UA_STATUSCODE_BADNODATA 0x809B0000 + +/* "No data found to provide upper or lower bound value." */ +#define UA_STATUSCODE_BADBOUNDNOTFOUND 0x80D70000 + +/* "The server cannot retrieve a bound for the variable." */ +#define UA_STATUSCODE_BADBOUNDNOTSUPPORTED 0x80D80000 + +/* "Data is missing due to collection started/stopped/lost." */ +#define UA_STATUSCODE_BADDATALOST 0x809D0000 + +/* "Expected data is unavailable for the requested time range due to an un-mounted volume */ +#define UA_STATUSCODE_BADDATAUNAVAILABLE 0x809E0000 + +/* "The data or event was not successfully inserted because a matching entry exists." */ +#define UA_STATUSCODE_BADENTRYEXISTS 0x809F0000 + +/* "The data or event was not successfully updated because no matching entry exists." */ +#define UA_STATUSCODE_BADNOENTRYEXISTS 0x80A00000 + +/* "The client requested history using a timestamp format the server does not support (i.e requested ServerTimestamp when server only supports SourceTimestamp)." */ +#define UA_STATUSCODE_BADTIMESTAMPNOTSUPPORTED 0x80A10000 + +/* "The data or event was successfully inserted into the historical database." */ +#define UA_STATUSCODE_GOODENTRYINSERTED 0x00A20000 + +/* "The data or event field was successfully replaced in the historical database." */ +#define UA_STATUSCODE_GOODENTRYREPLACED 0x00A30000 + +/* "The value is derived from multiple values and has less than the required number of Good values." */ +#define UA_STATUSCODE_UNCERTAINDATASUBNORMAL 0x40A40000 + +/* "No data exists for the requested time range or event filter." */ +#define UA_STATUSCODE_GOODNODATA 0x00A50000 + +/* "The data or event field was successfully replaced in the historical database." */ +#define UA_STATUSCODE_GOODMOREDATA 0x00A60000 + +/* "The requested number of Aggregates does not match the requested number of NodeIds." */ +#define UA_STATUSCODE_BADAGGREGATELISTMISMATCH 0x80D40000 + +/* "The requested Aggregate is not support by the server." */ +#define UA_STATUSCODE_BADAGGREGATENOTSUPPORTED 0x80D50000 + +/* "The aggregate value could not be derived due to invalid data inputs." */ +#define UA_STATUSCODE_BADAGGREGATEINVALIDINPUTS 0x80D60000 + +/* "The aggregate configuration is not valid for specified node." */ +#define UA_STATUSCODE_BADAGGREGATECONFIGURATIONREJECTED 0x80DA0000 + +/* "The request specifies fields which are not valid for the EventType or cannot be saved by the historian." */ +#define UA_STATUSCODE_GOODDATAIGNORED 0x00D90000 + +/* "The request was rejected by the server because it did not meet the criteria set by the server." */ +#define UA_STATUSCODE_BADREQUESTNOTALLOWED 0x80E40000 + +/* "The request has not been processed by the server yet." */ +#define UA_STATUSCODE_BADREQUESTNOTCOMPLETE 0x81130000 + +/* "The device identity needs a ticket before it can be accepted." */ +#define UA_STATUSCODE_BADTICKETREQUIRED 0x811F0000 + +/* "The device identity needs a ticket before it can be accepted." */ +#define UA_STATUSCODE_BADTICKETINVALID 0x81200000 + +/* "The value does not come from the real source and has been edited by the server." */ +#define UA_STATUSCODE_GOODEDITED 0x00DC0000 + +/* "There was an error in execution of these post-actions." */ +#define UA_STATUSCODE_GOODPOSTACTIONFAILED 0x00DD0000 + +/* "The related EngineeringUnit has been changed but the Variable Value is still provided based on the previous unit." */ +#define UA_STATUSCODE_UNCERTAINDOMINANTVALUECHANGED 0x40DE0000 + +/* "A dependent value has been changed but the change has not been applied to the device." */ +#define UA_STATUSCODE_GOODDEPENDENTVALUECHANGED 0x00E00000 + +/* "The related EngineeringUnit has been changed but this change has not been applied to the device. The Variable Value is still dependent on the previous unit but its status is currently Bad." */ +#define UA_STATUSCODE_BADDOMINANTVALUECHANGED 0x80E10000 + +/* "A dependent value has been changed but the change has not been applied to the device. The quality of the dominant variable is uncertain." */ +#define UA_STATUSCODE_UNCERTAINDEPENDENTVALUECHANGED 0x40E20000 + +/* "A dependent value has been changed but the change has not been applied to the device. The quality of the dominant variable is Bad." */ +#define UA_STATUSCODE_BADDEPENDENTVALUECHANGED 0x80E30000 + +/* "It is delivered with a dominant Variable value when a dependent Variable has changed but the change has not been applied." */ +#define UA_STATUSCODE_GOODEDITED_DEPENDENTVALUECHANGED 0x01160000 + +/* "It is delivered with a dependent Variable value when a dominant Variable has changed but the change has not been applied." */ +#define UA_STATUSCODE_GOODEDITED_DOMINANTVALUECHANGED 0x01170000 + +/* "It is delivered with a dependent Variable value when a dominant or dependent Variable has changed but change has not been applied." */ +#define UA_STATUSCODE_GOODEDITED_DOMINANTVALUECHANGED_DEPENDENTVALUECHANGED 0x01180000 + +/* "It is delivered with a Variable value when Variable has changed but the value is not legal." */ +#define UA_STATUSCODE_BADEDITED_OUTOFRANGE 0x81190000 + +/* "It is delivered with a Variable value when a source Variable has changed but the value is not legal." */ +#define UA_STATUSCODE_BADINITIALVALUE_OUTOFRANGE 0x811A0000 + +/* "It is delivered with a dependent Variable value when a dominant Variable has changed and the value is not legal." */ +#define UA_STATUSCODE_BADOUTOFRANGE_DOMINANTVALUECHANGED 0x811B0000 + +/* "It is delivered with a dependent Variable value when a dominant Variable has changed */ +#define UA_STATUSCODE_BADEDITED_OUTOFRANGE_DOMINANTVALUECHANGED 0x811C0000 + +/* "It is delivered with a dependent Variable value when a dominant or dependent Variable has changed and the value is not legal." */ +#define UA_STATUSCODE_BADOUTOFRANGE_DOMINANTVALUECHANGED_DEPENDENTVALUECHANGED 0x811D0000 + +/* "It is delivered with a dependent Variable value when a dominant or dependent Variable has changed */ +#define UA_STATUSCODE_BADEDITED_OUTOFRANGE_DOMINANTVALUECHANGED_DEPENDENTVALUECHANGED 0x811E0000 + +/* "The communication layer has raised an event." */ +#define UA_STATUSCODE_GOODCOMMUNICATIONEVENT 0x00A70000 + +/* "The system is shutting down." */ +#define UA_STATUSCODE_GOODSHUTDOWNEVENT 0x00A80000 + +/* "The operation is not finished and needs to be called again." */ +#define UA_STATUSCODE_GOODCALLAGAIN 0x00A90000 + +/* "A non-critical timeout occurred." */ +#define UA_STATUSCODE_GOODNONCRITICALTIMEOUT 0x00AA0000 + +/* "One or more arguments are invalid." */ +#define UA_STATUSCODE_BADINVALIDARGUMENT 0x80AB0000 + +/* "Could not establish a network connection to remote server." */ +#define UA_STATUSCODE_BADCONNECTIONREJECTED 0x80AC0000 + +/* "The server has disconnected from the client." */ +#define UA_STATUSCODE_BADDISCONNECT 0x80AD0000 + +/* "The network connection has been closed." */ +#define UA_STATUSCODE_BADCONNECTIONCLOSED 0x80AE0000 + +/* "The operation cannot be completed because the object is closed */ +#define UA_STATUSCODE_BADINVALIDSTATE 0x80AF0000 + +/* "Cannot move beyond end of the stream." */ +#define UA_STATUSCODE_BADENDOFSTREAM 0x80B00000 + +/* "No data is currently available for reading from a non-blocking stream." */ +#define UA_STATUSCODE_BADNODATAAVAILABLE 0x80B10000 + +/* "The asynchronous operation is waiting for a response." */ +#define UA_STATUSCODE_BADWAITINGFORRESPONSE 0x80B20000 + +/* "The asynchronous operation was abandoned by the caller." */ +#define UA_STATUSCODE_BADOPERATIONABANDONED 0x80B30000 + +/* "The stream did not return all data requested (possibly because it is a non-blocking stream)." */ +#define UA_STATUSCODE_BADEXPECTEDSTREAMTOBLOCK 0x80B40000 + +/* "Non blocking behaviour is required and the operation would block." */ +#define UA_STATUSCODE_BADWOULDBLOCK 0x80B50000 + +/* "A value had an invalid syntax." */ +#define UA_STATUSCODE_BADSYNTAXERROR 0x80B60000 + +/* "The operation could not be finished because all available connections are in use." */ +#define UA_STATUSCODE_BADMAXCONNECTIONSREACHED 0x80B70000 + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/nodeids.h" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + +#ifndef UA_NODEIDS_NS0_H_ +#define UA_NODEIDS_NS0_H_ + +/** + * Namespace Zero NodeIds + * ---------------------- + * Numeric identifiers of standard-defined nodes in namespace zero. The + * following definitions are autogenerated from a CSV file */ + +#define UA_NS0ID_BOOLEAN 1 /* DataType */ +#define UA_NS0ID_SBYTE 2 /* DataType */ +#define UA_NS0ID_BYTE 3 /* DataType */ +#define UA_NS0ID_INT16 4 /* DataType */ +#define UA_NS0ID_UINT16 5 /* DataType */ +#define UA_NS0ID_INT32 6 /* DataType */ +#define UA_NS0ID_UINT32 7 /* DataType */ +#define UA_NS0ID_INT64 8 /* DataType */ +#define UA_NS0ID_UINT64 9 /* DataType */ +#define UA_NS0ID_FLOAT 10 /* DataType */ +#define UA_NS0ID_DOUBLE 11 /* DataType */ +#define UA_NS0ID_STRING 12 /* DataType */ +#define UA_NS0ID_DATETIME 13 /* DataType */ +#define UA_NS0ID_GUID 14 /* DataType */ +#define UA_NS0ID_BYTESTRING 15 /* DataType */ +#define UA_NS0ID_XMLELEMENT 16 /* DataType */ +#define UA_NS0ID_NODEID 17 /* DataType */ +#define UA_NS0ID_EXPANDEDNODEID 18 /* DataType */ +#define UA_NS0ID_STATUSCODE 19 /* DataType */ +#define UA_NS0ID_QUALIFIEDNAME 20 /* DataType */ +#define UA_NS0ID_LOCALIZEDTEXT 21 /* DataType */ +#define UA_NS0ID_STRUCTURE 22 /* DataType */ +#define UA_NS0ID_DATAVALUE 23 /* DataType */ +#define UA_NS0ID_BASEDATATYPE 24 /* DataType */ +#define UA_NS0ID_DIAGNOSTICINFO 25 /* DataType */ +#define UA_NS0ID_NUMBER 26 /* DataType */ +#define UA_NS0ID_INTEGER 27 /* DataType */ +#define UA_NS0ID_UINTEGER 28 /* DataType */ +#define UA_NS0ID_ENUMERATION 29 /* DataType */ +#define UA_NS0ID_IMAGE 30 /* DataType */ +#define UA_NS0ID_REFERENCES 31 /* ReferenceType */ +#define UA_NS0ID_NONHIERARCHICALREFERENCES 32 /* ReferenceType */ +#define UA_NS0ID_HIERARCHICALREFERENCES 33 /* ReferenceType */ +#define UA_NS0ID_HASCHILD 34 /* ReferenceType */ +#define UA_NS0ID_ORGANIZES 35 /* ReferenceType */ +#define UA_NS0ID_HASEVENTSOURCE 36 /* ReferenceType */ +#define UA_NS0ID_HASMODELLINGRULE 37 /* ReferenceType */ +#define UA_NS0ID_HASENCODING 38 /* ReferenceType */ +#define UA_NS0ID_HASDESCRIPTION 39 /* ReferenceType */ +#define UA_NS0ID_HASTYPEDEFINITION 40 /* ReferenceType */ +#define UA_NS0ID_GENERATESEVENT 41 /* ReferenceType */ +#define UA_NS0ID_AGGREGATES 44 /* ReferenceType */ +#define UA_NS0ID_HASSUBTYPE 45 /* ReferenceType */ +#define UA_NS0ID_HASPROPERTY 46 /* ReferenceType */ +#define UA_NS0ID_HASCOMPONENT 47 /* ReferenceType */ +#define UA_NS0ID_HASNOTIFIER 48 /* ReferenceType */ +#define UA_NS0ID_HASORDEREDCOMPONENT 49 /* ReferenceType */ +#define UA_NS0ID_DECIMAL 50 /* DataType */ +#define UA_NS0ID_FROMSTATE 51 /* ReferenceType */ +#define UA_NS0ID_TOSTATE 52 /* ReferenceType */ +#define UA_NS0ID_HASCAUSE 53 /* ReferenceType */ +#define UA_NS0ID_HASEFFECT 54 /* ReferenceType */ +#define UA_NS0ID_HASHISTORICALCONFIGURATION 56 /* ReferenceType */ +#define UA_NS0ID_BASEOBJECTTYPE 58 /* ObjectType */ +#define UA_NS0ID_FOLDERTYPE 61 /* ObjectType */ +#define UA_NS0ID_BASEVARIABLETYPE 62 /* VariableType */ +#define UA_NS0ID_BASEDATAVARIABLETYPE 63 /* VariableType */ +#define UA_NS0ID_PROPERTYTYPE 68 /* VariableType */ +#define UA_NS0ID_DATATYPEDESCRIPTIONTYPE 69 /* VariableType */ +#define UA_NS0ID_DATATYPEDICTIONARYTYPE 72 /* VariableType */ +#define UA_NS0ID_DATATYPESYSTEMTYPE 75 /* ObjectType */ +#define UA_NS0ID_DATATYPEENCODINGTYPE 76 /* ObjectType */ +#define UA_NS0ID_MODELLINGRULETYPE 77 /* ObjectType */ +#define UA_NS0ID_MODELLINGRULE_MANDATORY 78 /* Object */ +#define UA_NS0ID_MODELLINGRULE_OPTIONAL 80 /* Object */ +#define UA_NS0ID_MODELLINGRULE_EXPOSESITSARRAY 83 /* Object */ +#define UA_NS0ID_ROOTFOLDER 84 /* Object */ +#define UA_NS0ID_OBJECTSFOLDER 85 /* Object */ +#define UA_NS0ID_TYPESFOLDER 86 /* Object */ +#define UA_NS0ID_VIEWSFOLDER 87 /* Object */ +#define UA_NS0ID_OBJECTTYPESFOLDER 88 /* Object */ +#define UA_NS0ID_VARIABLETYPESFOLDER 89 /* Object */ +#define UA_NS0ID_DATATYPESFOLDER 90 /* Object */ +#define UA_NS0ID_REFERENCETYPESFOLDER 91 /* Object */ +#define UA_NS0ID_XMLSCHEMA_TYPESYSTEM 92 /* Object */ +#define UA_NS0ID_OPCBINARYSCHEMA_TYPESYSTEM 93 /* Object */ +#define UA_NS0ID_PERMISSIONTYPE 94 /* DataType */ +#define UA_NS0ID_ACCESSRESTRICTIONTYPE 95 /* DataType */ +#define UA_NS0ID_ROLEPERMISSIONTYPE 96 /* DataType */ +#define UA_NS0ID_DATATYPEDEFINITION 97 /* DataType */ +#define UA_NS0ID_STRUCTURETYPE 98 /* DataType */ +#define UA_NS0ID_STRUCTUREDEFINITION 99 /* DataType */ +#define UA_NS0ID_ENUMDEFINITION 100 /* DataType */ +#define UA_NS0ID_STRUCTUREFIELD 101 /* DataType */ +#define UA_NS0ID_ENUMFIELD 102 /* DataType */ +#define UA_NS0ID_DATATYPEDESCRIPTIONTYPE_DATATYPEVERSION 104 /* Variable */ +#define UA_NS0ID_DATATYPEDESCRIPTIONTYPE_DICTIONARYFRAGMENT 105 /* Variable */ +#define UA_NS0ID_DATATYPEDICTIONARYTYPE_DATATYPEVERSION 106 /* Variable */ +#define UA_NS0ID_DATATYPEDICTIONARYTYPE_NAMESPACEURI 107 /* Variable */ +#define UA_NS0ID_MODELLINGRULETYPE_NAMINGRULE 111 /* Variable */ +#define UA_NS0ID_MODELLINGRULE_MANDATORY_NAMINGRULE 112 /* Variable */ +#define UA_NS0ID_MODELLINGRULE_OPTIONAL_NAMINGRULE 113 /* Variable */ +#define UA_NS0ID_MODELLINGRULE_EXPOSESITSARRAY_NAMINGRULE 114 /* Variable */ +#define UA_NS0ID_HASSUBSTATEMACHINE 117 /* ReferenceType */ +#define UA_NS0ID_NAMINGRULETYPE 120 /* DataType */ +#define UA_NS0ID_DATATYPEDEFINITION_ENCODING_DEFAULTBINARY 121 /* Object */ +#define UA_NS0ID_STRUCTUREDEFINITION_ENCODING_DEFAULTBINARY 122 /* Object */ +#define UA_NS0ID_ENUMDEFINITION_ENCODING_DEFAULTBINARY 123 /* Object */ +#define UA_NS0ID_DATASETMETADATATYPE_ENCODING_DEFAULTBINARY 124 /* Object */ +#define UA_NS0ID_DATATYPEDESCRIPTION_ENCODING_DEFAULTBINARY 125 /* Object */ +#define UA_NS0ID_STRUCTUREDESCRIPTION_ENCODING_DEFAULTBINARY 126 /* Object */ +#define UA_NS0ID_ENUMDESCRIPTION_ENCODING_DEFAULTBINARY 127 /* Object */ +#define UA_NS0ID_ROLEPERMISSIONTYPE_ENCODING_DEFAULTBINARY 128 /* Object */ +#define UA_NS0ID_HASARGUMENTDESCRIPTION 129 /* ReferenceType */ +#define UA_NS0ID_HASOPTIONALINPUTARGUMENTDESCRIPTION 131 /* ReferenceType */ +#define UA_NS0ID_IDTYPE 256 /* DataType */ +#define UA_NS0ID_NODECLASS 257 /* DataType */ +#define UA_NS0ID_NODE 258 /* DataType */ +#define UA_NS0ID_NODE_ENCODING_DEFAULTXML 259 /* Object */ +#define UA_NS0ID_NODE_ENCODING_DEFAULTBINARY 260 /* Object */ +#define UA_NS0ID_OBJECTNODE 261 /* DataType */ +#define UA_NS0ID_OBJECTNODE_ENCODING_DEFAULTXML 262 /* Object */ +#define UA_NS0ID_OBJECTNODE_ENCODING_DEFAULTBINARY 263 /* Object */ +#define UA_NS0ID_OBJECTTYPENODE 264 /* DataType */ +#define UA_NS0ID_OBJECTTYPENODE_ENCODING_DEFAULTXML 265 /* Object */ +#define UA_NS0ID_OBJECTTYPENODE_ENCODING_DEFAULTBINARY 266 /* Object */ +#define UA_NS0ID_VARIABLENODE 267 /* DataType */ +#define UA_NS0ID_VARIABLENODE_ENCODING_DEFAULTXML 268 /* Object */ +#define UA_NS0ID_VARIABLENODE_ENCODING_DEFAULTBINARY 269 /* Object */ +#define UA_NS0ID_VARIABLETYPENODE 270 /* DataType */ +#define UA_NS0ID_VARIABLETYPENODE_ENCODING_DEFAULTXML 271 /* Object */ +#define UA_NS0ID_VARIABLETYPENODE_ENCODING_DEFAULTBINARY 272 /* Object */ +#define UA_NS0ID_REFERENCETYPENODE 273 /* DataType */ +#define UA_NS0ID_REFERENCETYPENODE_ENCODING_DEFAULTXML 274 /* Object */ +#define UA_NS0ID_REFERENCETYPENODE_ENCODING_DEFAULTBINARY 275 /* Object */ +#define UA_NS0ID_METHODNODE 276 /* DataType */ +#define UA_NS0ID_METHODNODE_ENCODING_DEFAULTXML 277 /* Object */ +#define UA_NS0ID_METHODNODE_ENCODING_DEFAULTBINARY 278 /* Object */ +#define UA_NS0ID_VIEWNODE 279 /* DataType */ +#define UA_NS0ID_VIEWNODE_ENCODING_DEFAULTXML 280 /* Object */ +#define UA_NS0ID_VIEWNODE_ENCODING_DEFAULTBINARY 281 /* Object */ +#define UA_NS0ID_DATATYPENODE 282 /* DataType */ +#define UA_NS0ID_DATATYPENODE_ENCODING_DEFAULTXML 283 /* Object */ +#define UA_NS0ID_DATATYPENODE_ENCODING_DEFAULTBINARY 284 /* Object */ +#define UA_NS0ID_REFERENCENODE 285 /* DataType */ +#define UA_NS0ID_REFERENCENODE_ENCODING_DEFAULTXML 286 /* Object */ +#define UA_NS0ID_REFERENCENODE_ENCODING_DEFAULTBINARY 287 /* Object */ +#define UA_NS0ID_INTEGERID 288 /* DataType */ +#define UA_NS0ID_COUNTER 289 /* DataType */ +#define UA_NS0ID_DURATION 290 /* DataType */ +#define UA_NS0ID_NUMERICRANGE 291 /* DataType */ +#define UA_NS0ID_UTCTIME 294 /* DataType */ +#define UA_NS0ID_LOCALEID 295 /* DataType */ +#define UA_NS0ID_ARGUMENT 296 /* DataType */ +#define UA_NS0ID_ARGUMENT_ENCODING_DEFAULTXML 297 /* Object */ +#define UA_NS0ID_ARGUMENT_ENCODING_DEFAULTBINARY 298 /* Object */ +#define UA_NS0ID_STATUSRESULT 299 /* DataType */ +#define UA_NS0ID_STATUSRESULT_ENCODING_DEFAULTXML 300 /* Object */ +#define UA_NS0ID_STATUSRESULT_ENCODING_DEFAULTBINARY 301 /* Object */ +#define UA_NS0ID_MESSAGESECURITYMODE 302 /* DataType */ +#define UA_NS0ID_USERTOKENTYPE 303 /* DataType */ +#define UA_NS0ID_USERTOKENPOLICY 304 /* DataType */ +#define UA_NS0ID_USERTOKENPOLICY_ENCODING_DEFAULTXML 305 /* Object */ +#define UA_NS0ID_USERTOKENPOLICY_ENCODING_DEFAULTBINARY 306 /* Object */ +#define UA_NS0ID_APPLICATIONTYPE 307 /* DataType */ +#define UA_NS0ID_APPLICATIONDESCRIPTION 308 /* DataType */ +#define UA_NS0ID_APPLICATIONDESCRIPTION_ENCODING_DEFAULTXML 309 /* Object */ +#define UA_NS0ID_APPLICATIONDESCRIPTION_ENCODING_DEFAULTBINARY 310 /* Object */ +#define UA_NS0ID_APPLICATIONINSTANCECERTIFICATE 311 /* DataType */ +#define UA_NS0ID_ENDPOINTDESCRIPTION 312 /* DataType */ +#define UA_NS0ID_ENDPOINTDESCRIPTION_ENCODING_DEFAULTXML 313 /* Object */ +#define UA_NS0ID_ENDPOINTDESCRIPTION_ENCODING_DEFAULTBINARY 314 /* Object */ +#define UA_NS0ID_SECURITYTOKENREQUESTTYPE 315 /* DataType */ +#define UA_NS0ID_USERIDENTITYTOKEN 316 /* DataType */ +#define UA_NS0ID_USERIDENTITYTOKEN_ENCODING_DEFAULTXML 317 /* Object */ +#define UA_NS0ID_USERIDENTITYTOKEN_ENCODING_DEFAULTBINARY 318 /* Object */ +#define UA_NS0ID_ANONYMOUSIDENTITYTOKEN 319 /* DataType */ +#define UA_NS0ID_ANONYMOUSIDENTITYTOKEN_ENCODING_DEFAULTXML 320 /* Object */ +#define UA_NS0ID_ANONYMOUSIDENTITYTOKEN_ENCODING_DEFAULTBINARY 321 /* Object */ +#define UA_NS0ID_USERNAMEIDENTITYTOKEN 322 /* DataType */ +#define UA_NS0ID_USERNAMEIDENTITYTOKEN_ENCODING_DEFAULTXML 323 /* Object */ +#define UA_NS0ID_USERNAMEIDENTITYTOKEN_ENCODING_DEFAULTBINARY 324 /* Object */ +#define UA_NS0ID_X509IDENTITYTOKEN 325 /* DataType */ +#define UA_NS0ID_X509IDENTITYTOKEN_ENCODING_DEFAULTXML 326 /* Object */ +#define UA_NS0ID_X509IDENTITYTOKEN_ENCODING_DEFAULTBINARY 327 /* Object */ +#define UA_NS0ID_ENDPOINTCONFIGURATION 331 /* DataType */ +#define UA_NS0ID_ENDPOINTCONFIGURATION_ENCODING_DEFAULTXML 332 /* Object */ +#define UA_NS0ID_ENDPOINTCONFIGURATION_ENCODING_DEFAULTBINARY 333 /* Object */ +#define UA_NS0ID_BUILDINFO 338 /* DataType */ +#define UA_NS0ID_BUILDINFO_ENCODING_DEFAULTXML 339 /* Object */ +#define UA_NS0ID_BUILDINFO_ENCODING_DEFAULTBINARY 340 /* Object */ +#define UA_NS0ID_SIGNEDSOFTWARECERTIFICATE 344 /* DataType */ +#define UA_NS0ID_SIGNEDSOFTWARECERTIFICATE_ENCODING_DEFAULTXML 345 /* Object */ +#define UA_NS0ID_SIGNEDSOFTWARECERTIFICATE_ENCODING_DEFAULTBINARY 346 /* Object */ +#define UA_NS0ID_ATTRIBUTEWRITEMASK 347 /* DataType */ +#define UA_NS0ID_NODEATTRIBUTESMASK 348 /* DataType */ +#define UA_NS0ID_NODEATTRIBUTES 349 /* DataType */ +#define UA_NS0ID_NODEATTRIBUTES_ENCODING_DEFAULTXML 350 /* Object */ +#define UA_NS0ID_NODEATTRIBUTES_ENCODING_DEFAULTBINARY 351 /* Object */ +#define UA_NS0ID_OBJECTATTRIBUTES 352 /* DataType */ +#define UA_NS0ID_OBJECTATTRIBUTES_ENCODING_DEFAULTXML 353 /* Object */ +#define UA_NS0ID_OBJECTATTRIBUTES_ENCODING_DEFAULTBINARY 354 /* Object */ +#define UA_NS0ID_VARIABLEATTRIBUTES 355 /* DataType */ +#define UA_NS0ID_VARIABLEATTRIBUTES_ENCODING_DEFAULTXML 356 /* Object */ +#define UA_NS0ID_VARIABLEATTRIBUTES_ENCODING_DEFAULTBINARY 357 /* Object */ +#define UA_NS0ID_METHODATTRIBUTES 358 /* DataType */ +#define UA_NS0ID_METHODATTRIBUTES_ENCODING_DEFAULTXML 359 /* Object */ +#define UA_NS0ID_METHODATTRIBUTES_ENCODING_DEFAULTBINARY 360 /* Object */ +#define UA_NS0ID_OBJECTTYPEATTRIBUTES 361 /* DataType */ +#define UA_NS0ID_OBJECTTYPEATTRIBUTES_ENCODING_DEFAULTXML 362 /* Object */ +#define UA_NS0ID_OBJECTTYPEATTRIBUTES_ENCODING_DEFAULTBINARY 363 /* Object */ +#define UA_NS0ID_VARIABLETYPEATTRIBUTES 364 /* DataType */ +#define UA_NS0ID_VARIABLETYPEATTRIBUTES_ENCODING_DEFAULTXML 365 /* Object */ +#define UA_NS0ID_VARIABLETYPEATTRIBUTES_ENCODING_DEFAULTBINARY 366 /* Object */ +#define UA_NS0ID_REFERENCETYPEATTRIBUTES 367 /* DataType */ +#define UA_NS0ID_REFERENCETYPEATTRIBUTES_ENCODING_DEFAULTXML 368 /* Object */ +#define UA_NS0ID_REFERENCETYPEATTRIBUTES_ENCODING_DEFAULTBINARY 369 /* Object */ +#define UA_NS0ID_DATATYPEATTRIBUTES 370 /* DataType */ +#define UA_NS0ID_DATATYPEATTRIBUTES_ENCODING_DEFAULTXML 371 /* Object */ +#define UA_NS0ID_DATATYPEATTRIBUTES_ENCODING_DEFAULTBINARY 372 /* Object */ +#define UA_NS0ID_VIEWATTRIBUTES 373 /* DataType */ +#define UA_NS0ID_VIEWATTRIBUTES_ENCODING_DEFAULTXML 374 /* Object */ +#define UA_NS0ID_VIEWATTRIBUTES_ENCODING_DEFAULTBINARY 375 /* Object */ +#define UA_NS0ID_ADDNODESITEM 376 /* DataType */ +#define UA_NS0ID_ADDNODESITEM_ENCODING_DEFAULTXML 377 /* Object */ +#define UA_NS0ID_ADDNODESITEM_ENCODING_DEFAULTBINARY 378 /* Object */ +#define UA_NS0ID_ADDREFERENCESITEM 379 /* DataType */ +#define UA_NS0ID_ADDREFERENCESITEM_ENCODING_DEFAULTXML 380 /* Object */ +#define UA_NS0ID_ADDREFERENCESITEM_ENCODING_DEFAULTBINARY 381 /* Object */ +#define UA_NS0ID_DELETENODESITEM 382 /* DataType */ +#define UA_NS0ID_DELETENODESITEM_ENCODING_DEFAULTXML 383 /* Object */ +#define UA_NS0ID_DELETENODESITEM_ENCODING_DEFAULTBINARY 384 /* Object */ +#define UA_NS0ID_DELETEREFERENCESITEM 385 /* DataType */ +#define UA_NS0ID_DELETEREFERENCESITEM_ENCODING_DEFAULTXML 386 /* Object */ +#define UA_NS0ID_DELETEREFERENCESITEM_ENCODING_DEFAULTBINARY 387 /* Object */ +#define UA_NS0ID_SESSIONAUTHENTICATIONTOKEN 388 /* DataType */ +#define UA_NS0ID_REQUESTHEADER 389 /* DataType */ +#define UA_NS0ID_REQUESTHEADER_ENCODING_DEFAULTXML 390 /* Object */ +#define UA_NS0ID_REQUESTHEADER_ENCODING_DEFAULTBINARY 391 /* Object */ +#define UA_NS0ID_RESPONSEHEADER 392 /* DataType */ +#define UA_NS0ID_RESPONSEHEADER_ENCODING_DEFAULTXML 393 /* Object */ +#define UA_NS0ID_RESPONSEHEADER_ENCODING_DEFAULTBINARY 394 /* Object */ +#define UA_NS0ID_SERVICEFAULT 395 /* DataType */ +#define UA_NS0ID_SERVICEFAULT_ENCODING_DEFAULTXML 396 /* Object */ +#define UA_NS0ID_SERVICEFAULT_ENCODING_DEFAULTBINARY 397 /* Object */ +#define UA_NS0ID_FINDSERVERSREQUEST 420 /* DataType */ +#define UA_NS0ID_FINDSERVERSREQUEST_ENCODING_DEFAULTXML 421 /* Object */ +#define UA_NS0ID_FINDSERVERSREQUEST_ENCODING_DEFAULTBINARY 422 /* Object */ +#define UA_NS0ID_FINDSERVERSRESPONSE 423 /* DataType */ +#define UA_NS0ID_FINDSERVERSRESPONSE_ENCODING_DEFAULTXML 424 /* Object */ +#define UA_NS0ID_FINDSERVERSRESPONSE_ENCODING_DEFAULTBINARY 425 /* Object */ +#define UA_NS0ID_GETENDPOINTSREQUEST 426 /* DataType */ +#define UA_NS0ID_GETENDPOINTSREQUEST_ENCODING_DEFAULTXML 427 /* Object */ +#define UA_NS0ID_GETENDPOINTSREQUEST_ENCODING_DEFAULTBINARY 428 /* Object */ +#define UA_NS0ID_GETENDPOINTSRESPONSE 429 /* DataType */ +#define UA_NS0ID_GETENDPOINTSRESPONSE_ENCODING_DEFAULTXML 430 /* Object */ +#define UA_NS0ID_GETENDPOINTSRESPONSE_ENCODING_DEFAULTBINARY 431 /* Object */ +#define UA_NS0ID_REGISTEREDSERVER 432 /* DataType */ +#define UA_NS0ID_REGISTEREDSERVER_ENCODING_DEFAULTXML 433 /* Object */ +#define UA_NS0ID_REGISTEREDSERVER_ENCODING_DEFAULTBINARY 434 /* Object */ +#define UA_NS0ID_REGISTERSERVERREQUEST 435 /* DataType */ +#define UA_NS0ID_REGISTERSERVERREQUEST_ENCODING_DEFAULTXML 436 /* Object */ +#define UA_NS0ID_REGISTERSERVERREQUEST_ENCODING_DEFAULTBINARY 437 /* Object */ +#define UA_NS0ID_REGISTERSERVERRESPONSE 438 /* DataType */ +#define UA_NS0ID_REGISTERSERVERRESPONSE_ENCODING_DEFAULTXML 439 /* Object */ +#define UA_NS0ID_REGISTERSERVERRESPONSE_ENCODING_DEFAULTBINARY 440 /* Object */ +#define UA_NS0ID_CHANNELSECURITYTOKEN 441 /* DataType */ +#define UA_NS0ID_CHANNELSECURITYTOKEN_ENCODING_DEFAULTXML 442 /* Object */ +#define UA_NS0ID_CHANNELSECURITYTOKEN_ENCODING_DEFAULTBINARY 443 /* Object */ +#define UA_NS0ID_OPENSECURECHANNELREQUEST 444 /* DataType */ +#define UA_NS0ID_OPENSECURECHANNELREQUEST_ENCODING_DEFAULTXML 445 /* Object */ +#define UA_NS0ID_OPENSECURECHANNELREQUEST_ENCODING_DEFAULTBINARY 446 /* Object */ +#define UA_NS0ID_OPENSECURECHANNELRESPONSE 447 /* DataType */ +#define UA_NS0ID_OPENSECURECHANNELRESPONSE_ENCODING_DEFAULTXML 448 /* Object */ +#define UA_NS0ID_OPENSECURECHANNELRESPONSE_ENCODING_DEFAULTBINARY 449 /* Object */ +#define UA_NS0ID_CLOSESECURECHANNELREQUEST 450 /* DataType */ +#define UA_NS0ID_CLOSESECURECHANNELREQUEST_ENCODING_DEFAULTXML 451 /* Object */ +#define UA_NS0ID_CLOSESECURECHANNELREQUEST_ENCODING_DEFAULTBINARY 452 /* Object */ +#define UA_NS0ID_CLOSESECURECHANNELRESPONSE 453 /* DataType */ +#define UA_NS0ID_CLOSESECURECHANNELRESPONSE_ENCODING_DEFAULTXML 454 /* Object */ +#define UA_NS0ID_CLOSESECURECHANNELRESPONSE_ENCODING_DEFAULTBINARY 455 /* Object */ +#define UA_NS0ID_SIGNATUREDATA 456 /* DataType */ +#define UA_NS0ID_SIGNATUREDATA_ENCODING_DEFAULTXML 457 /* Object */ +#define UA_NS0ID_SIGNATUREDATA_ENCODING_DEFAULTBINARY 458 /* Object */ +#define UA_NS0ID_CREATESESSIONREQUEST 459 /* DataType */ +#define UA_NS0ID_CREATESESSIONREQUEST_ENCODING_DEFAULTXML 460 /* Object */ +#define UA_NS0ID_CREATESESSIONREQUEST_ENCODING_DEFAULTBINARY 461 /* Object */ +#define UA_NS0ID_CREATESESSIONRESPONSE 462 /* DataType */ +#define UA_NS0ID_CREATESESSIONRESPONSE_ENCODING_DEFAULTXML 463 /* Object */ +#define UA_NS0ID_CREATESESSIONRESPONSE_ENCODING_DEFAULTBINARY 464 /* Object */ +#define UA_NS0ID_ACTIVATESESSIONREQUEST 465 /* DataType */ +#define UA_NS0ID_ACTIVATESESSIONREQUEST_ENCODING_DEFAULTXML 466 /* Object */ +#define UA_NS0ID_ACTIVATESESSIONREQUEST_ENCODING_DEFAULTBINARY 467 /* Object */ +#define UA_NS0ID_ACTIVATESESSIONRESPONSE 468 /* DataType */ +#define UA_NS0ID_ACTIVATESESSIONRESPONSE_ENCODING_DEFAULTXML 469 /* Object */ +#define UA_NS0ID_ACTIVATESESSIONRESPONSE_ENCODING_DEFAULTBINARY 470 /* Object */ +#define UA_NS0ID_CLOSESESSIONREQUEST 471 /* DataType */ +#define UA_NS0ID_CLOSESESSIONREQUEST_ENCODING_DEFAULTXML 472 /* Object */ +#define UA_NS0ID_CLOSESESSIONREQUEST_ENCODING_DEFAULTBINARY 473 /* Object */ +#define UA_NS0ID_CLOSESESSIONRESPONSE 474 /* DataType */ +#define UA_NS0ID_CLOSESESSIONRESPONSE_ENCODING_DEFAULTXML 475 /* Object */ +#define UA_NS0ID_CLOSESESSIONRESPONSE_ENCODING_DEFAULTBINARY 476 /* Object */ +#define UA_NS0ID_CANCELREQUEST 477 /* DataType */ +#define UA_NS0ID_CANCELREQUEST_ENCODING_DEFAULTXML 478 /* Object */ +#define UA_NS0ID_CANCELREQUEST_ENCODING_DEFAULTBINARY 479 /* Object */ +#define UA_NS0ID_CANCELRESPONSE 480 /* DataType */ +#define UA_NS0ID_CANCELRESPONSE_ENCODING_DEFAULTXML 481 /* Object */ +#define UA_NS0ID_CANCELRESPONSE_ENCODING_DEFAULTBINARY 482 /* Object */ +#define UA_NS0ID_ADDNODESRESULT 483 /* DataType */ +#define UA_NS0ID_ADDNODESRESULT_ENCODING_DEFAULTXML 484 /* Object */ +#define UA_NS0ID_ADDNODESRESULT_ENCODING_DEFAULTBINARY 485 /* Object */ +#define UA_NS0ID_ADDNODESREQUEST 486 /* DataType */ +#define UA_NS0ID_ADDNODESREQUEST_ENCODING_DEFAULTXML 487 /* Object */ +#define UA_NS0ID_ADDNODESREQUEST_ENCODING_DEFAULTBINARY 488 /* Object */ +#define UA_NS0ID_ADDNODESRESPONSE 489 /* DataType */ +#define UA_NS0ID_ADDNODESRESPONSE_ENCODING_DEFAULTXML 490 /* Object */ +#define UA_NS0ID_ADDNODESRESPONSE_ENCODING_DEFAULTBINARY 491 /* Object */ +#define UA_NS0ID_ADDREFERENCESREQUEST 492 /* DataType */ +#define UA_NS0ID_ADDREFERENCESREQUEST_ENCODING_DEFAULTXML 493 /* Object */ +#define UA_NS0ID_ADDREFERENCESREQUEST_ENCODING_DEFAULTBINARY 494 /* Object */ +#define UA_NS0ID_ADDREFERENCESRESPONSE 495 /* DataType */ +#define UA_NS0ID_ADDREFERENCESRESPONSE_ENCODING_DEFAULTXML 496 /* Object */ +#define UA_NS0ID_ADDREFERENCESRESPONSE_ENCODING_DEFAULTBINARY 497 /* Object */ +#define UA_NS0ID_DELETENODESREQUEST 498 /* DataType */ +#define UA_NS0ID_DELETENODESREQUEST_ENCODING_DEFAULTXML 499 /* Object */ +#define UA_NS0ID_DELETENODESREQUEST_ENCODING_DEFAULTBINARY 500 /* Object */ +#define UA_NS0ID_DELETENODESRESPONSE 501 /* DataType */ +#define UA_NS0ID_DELETENODESRESPONSE_ENCODING_DEFAULTXML 502 /* Object */ +#define UA_NS0ID_DELETENODESRESPONSE_ENCODING_DEFAULTBINARY 503 /* Object */ +#define UA_NS0ID_DELETEREFERENCESREQUEST 504 /* DataType */ +#define UA_NS0ID_DELETEREFERENCESREQUEST_ENCODING_DEFAULTXML 505 /* Object */ +#define UA_NS0ID_DELETEREFERENCESREQUEST_ENCODING_DEFAULTBINARY 506 /* Object */ +#define UA_NS0ID_DELETEREFERENCESRESPONSE 507 /* DataType */ +#define UA_NS0ID_DELETEREFERENCESRESPONSE_ENCODING_DEFAULTXML 508 /* Object */ +#define UA_NS0ID_DELETEREFERENCESRESPONSE_ENCODING_DEFAULTBINARY 509 /* Object */ +#define UA_NS0ID_BROWSEDIRECTION 510 /* DataType */ +#define UA_NS0ID_VIEWDESCRIPTION 511 /* DataType */ +#define UA_NS0ID_VIEWDESCRIPTION_ENCODING_DEFAULTXML 512 /* Object */ +#define UA_NS0ID_VIEWDESCRIPTION_ENCODING_DEFAULTBINARY 513 /* Object */ +#define UA_NS0ID_BROWSEDESCRIPTION 514 /* DataType */ +#define UA_NS0ID_BROWSEDESCRIPTION_ENCODING_DEFAULTXML 515 /* Object */ +#define UA_NS0ID_BROWSEDESCRIPTION_ENCODING_DEFAULTBINARY 516 /* Object */ +#define UA_NS0ID_BROWSERESULTMASK 517 /* DataType */ +#define UA_NS0ID_REFERENCEDESCRIPTION 518 /* DataType */ +#define UA_NS0ID_REFERENCEDESCRIPTION_ENCODING_DEFAULTXML 519 /* Object */ +#define UA_NS0ID_REFERENCEDESCRIPTION_ENCODING_DEFAULTBINARY 520 /* Object */ +#define UA_NS0ID_CONTINUATIONPOINT 521 /* DataType */ +#define UA_NS0ID_BROWSERESULT 522 /* DataType */ +#define UA_NS0ID_BROWSERESULT_ENCODING_DEFAULTXML 523 /* Object */ +#define UA_NS0ID_BROWSERESULT_ENCODING_DEFAULTBINARY 524 /* Object */ +#define UA_NS0ID_BROWSEREQUEST 525 /* DataType */ +#define UA_NS0ID_BROWSEREQUEST_ENCODING_DEFAULTXML 526 /* Object */ +#define UA_NS0ID_BROWSEREQUEST_ENCODING_DEFAULTBINARY 527 /* Object */ +#define UA_NS0ID_BROWSERESPONSE 528 /* DataType */ +#define UA_NS0ID_BROWSERESPONSE_ENCODING_DEFAULTXML 529 /* Object */ +#define UA_NS0ID_BROWSERESPONSE_ENCODING_DEFAULTBINARY 530 /* Object */ +#define UA_NS0ID_BROWSENEXTREQUEST 531 /* DataType */ +#define UA_NS0ID_BROWSENEXTREQUEST_ENCODING_DEFAULTXML 532 /* Object */ +#define UA_NS0ID_BROWSENEXTREQUEST_ENCODING_DEFAULTBINARY 533 /* Object */ +#define UA_NS0ID_BROWSENEXTRESPONSE 534 /* DataType */ +#define UA_NS0ID_BROWSENEXTRESPONSE_ENCODING_DEFAULTXML 535 /* Object */ +#define UA_NS0ID_BROWSENEXTRESPONSE_ENCODING_DEFAULTBINARY 536 /* Object */ +#define UA_NS0ID_RELATIVEPATHELEMENT 537 /* DataType */ +#define UA_NS0ID_RELATIVEPATHELEMENT_ENCODING_DEFAULTXML 538 /* Object */ +#define UA_NS0ID_RELATIVEPATHELEMENT_ENCODING_DEFAULTBINARY 539 /* Object */ +#define UA_NS0ID_RELATIVEPATH 540 /* DataType */ +#define UA_NS0ID_RELATIVEPATH_ENCODING_DEFAULTXML 541 /* Object */ +#define UA_NS0ID_RELATIVEPATH_ENCODING_DEFAULTBINARY 542 /* Object */ +#define UA_NS0ID_BROWSEPATH 543 /* DataType */ +#define UA_NS0ID_BROWSEPATH_ENCODING_DEFAULTXML 544 /* Object */ +#define UA_NS0ID_BROWSEPATH_ENCODING_DEFAULTBINARY 545 /* Object */ +#define UA_NS0ID_BROWSEPATHTARGET 546 /* DataType */ +#define UA_NS0ID_BROWSEPATHTARGET_ENCODING_DEFAULTXML 547 /* Object */ +#define UA_NS0ID_BROWSEPATHTARGET_ENCODING_DEFAULTBINARY 548 /* Object */ +#define UA_NS0ID_BROWSEPATHRESULT 549 /* DataType */ +#define UA_NS0ID_BROWSEPATHRESULT_ENCODING_DEFAULTXML 550 /* Object */ +#define UA_NS0ID_BROWSEPATHRESULT_ENCODING_DEFAULTBINARY 551 /* Object */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST 552 /* DataType */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST_ENCODING_DEFAULTXML 553 /* Object */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST_ENCODING_DEFAULTBINARY 554 /* Object */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE 555 /* DataType */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE_ENCODING_DEFAULTXML 556 /* Object */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE_ENCODING_DEFAULTBINARY 557 /* Object */ +#define UA_NS0ID_REGISTERNODESREQUEST 558 /* DataType */ +#define UA_NS0ID_REGISTERNODESREQUEST_ENCODING_DEFAULTXML 559 /* Object */ +#define UA_NS0ID_REGISTERNODESREQUEST_ENCODING_DEFAULTBINARY 560 /* Object */ +#define UA_NS0ID_REGISTERNODESRESPONSE 561 /* DataType */ +#define UA_NS0ID_REGISTERNODESRESPONSE_ENCODING_DEFAULTXML 562 /* Object */ +#define UA_NS0ID_REGISTERNODESRESPONSE_ENCODING_DEFAULTBINARY 563 /* Object */ +#define UA_NS0ID_UNREGISTERNODESREQUEST 564 /* DataType */ +#define UA_NS0ID_UNREGISTERNODESREQUEST_ENCODING_DEFAULTXML 565 /* Object */ +#define UA_NS0ID_UNREGISTERNODESREQUEST_ENCODING_DEFAULTBINARY 566 /* Object */ +#define UA_NS0ID_UNREGISTERNODESRESPONSE 567 /* DataType */ +#define UA_NS0ID_UNREGISTERNODESRESPONSE_ENCODING_DEFAULTXML 568 /* Object */ +#define UA_NS0ID_UNREGISTERNODESRESPONSE_ENCODING_DEFAULTBINARY 569 /* Object */ +#define UA_NS0ID_QUERYDATADESCRIPTION 570 /* DataType */ +#define UA_NS0ID_QUERYDATADESCRIPTION_ENCODING_DEFAULTXML 571 /* Object */ +#define UA_NS0ID_QUERYDATADESCRIPTION_ENCODING_DEFAULTBINARY 572 /* Object */ +#define UA_NS0ID_NODETYPEDESCRIPTION 573 /* DataType */ +#define UA_NS0ID_NODETYPEDESCRIPTION_ENCODING_DEFAULTXML 574 /* Object */ +#define UA_NS0ID_NODETYPEDESCRIPTION_ENCODING_DEFAULTBINARY 575 /* Object */ +#define UA_NS0ID_FILTEROPERATOR 576 /* DataType */ +#define UA_NS0ID_QUERYDATASET 577 /* DataType */ +#define UA_NS0ID_QUERYDATASET_ENCODING_DEFAULTXML 578 /* Object */ +#define UA_NS0ID_QUERYDATASET_ENCODING_DEFAULTBINARY 579 /* Object */ +#define UA_NS0ID_NODEREFERENCE 580 /* DataType */ +#define UA_NS0ID_NODEREFERENCE_ENCODING_DEFAULTXML 581 /* Object */ +#define UA_NS0ID_NODEREFERENCE_ENCODING_DEFAULTBINARY 582 /* Object */ +#define UA_NS0ID_CONTENTFILTERELEMENT 583 /* DataType */ +#define UA_NS0ID_CONTENTFILTERELEMENT_ENCODING_DEFAULTXML 584 /* Object */ +#define UA_NS0ID_CONTENTFILTERELEMENT_ENCODING_DEFAULTBINARY 585 /* Object */ +#define UA_NS0ID_CONTENTFILTER 586 /* DataType */ +#define UA_NS0ID_CONTENTFILTER_ENCODING_DEFAULTXML 587 /* Object */ +#define UA_NS0ID_CONTENTFILTER_ENCODING_DEFAULTBINARY 588 /* Object */ +#define UA_NS0ID_FILTEROPERAND 589 /* DataType */ +#define UA_NS0ID_FILTEROPERAND_ENCODING_DEFAULTXML 590 /* Object */ +#define UA_NS0ID_FILTEROPERAND_ENCODING_DEFAULTBINARY 591 /* Object */ +#define UA_NS0ID_ELEMENTOPERAND 592 /* DataType */ +#define UA_NS0ID_ELEMENTOPERAND_ENCODING_DEFAULTXML 593 /* Object */ +#define UA_NS0ID_ELEMENTOPERAND_ENCODING_DEFAULTBINARY 594 /* Object */ +#define UA_NS0ID_LITERALOPERAND 595 /* DataType */ +#define UA_NS0ID_LITERALOPERAND_ENCODING_DEFAULTXML 596 /* Object */ +#define UA_NS0ID_LITERALOPERAND_ENCODING_DEFAULTBINARY 597 /* Object */ +#define UA_NS0ID_ATTRIBUTEOPERAND 598 /* DataType */ +#define UA_NS0ID_ATTRIBUTEOPERAND_ENCODING_DEFAULTXML 599 /* Object */ +#define UA_NS0ID_ATTRIBUTEOPERAND_ENCODING_DEFAULTBINARY 600 /* Object */ +#define UA_NS0ID_SIMPLEATTRIBUTEOPERAND 601 /* DataType */ +#define UA_NS0ID_SIMPLEATTRIBUTEOPERAND_ENCODING_DEFAULTXML 602 /* Object */ +#define UA_NS0ID_SIMPLEATTRIBUTEOPERAND_ENCODING_DEFAULTBINARY 603 /* Object */ +#define UA_NS0ID_CONTENTFILTERELEMENTRESULT 604 /* DataType */ +#define UA_NS0ID_CONTENTFILTERELEMENTRESULT_ENCODING_DEFAULTXML 605 /* Object */ +#define UA_NS0ID_CONTENTFILTERELEMENTRESULT_ENCODING_DEFAULTBINARY 606 /* Object */ +#define UA_NS0ID_CONTENTFILTERRESULT 607 /* DataType */ +#define UA_NS0ID_CONTENTFILTERRESULT_ENCODING_DEFAULTXML 608 /* Object */ +#define UA_NS0ID_CONTENTFILTERRESULT_ENCODING_DEFAULTBINARY 609 /* Object */ +#define UA_NS0ID_PARSINGRESULT 610 /* DataType */ +#define UA_NS0ID_PARSINGRESULT_ENCODING_DEFAULTXML 611 /* Object */ +#define UA_NS0ID_PARSINGRESULT_ENCODING_DEFAULTBINARY 612 /* Object */ +#define UA_NS0ID_QUERYFIRSTREQUEST 613 /* DataType */ +#define UA_NS0ID_QUERYFIRSTREQUEST_ENCODING_DEFAULTXML 614 /* Object */ +#define UA_NS0ID_QUERYFIRSTREQUEST_ENCODING_DEFAULTBINARY 615 /* Object */ +#define UA_NS0ID_QUERYFIRSTRESPONSE 616 /* DataType */ +#define UA_NS0ID_QUERYFIRSTRESPONSE_ENCODING_DEFAULTXML 617 /* Object */ +#define UA_NS0ID_QUERYFIRSTRESPONSE_ENCODING_DEFAULTBINARY 618 /* Object */ +#define UA_NS0ID_QUERYNEXTREQUEST 619 /* DataType */ +#define UA_NS0ID_QUERYNEXTREQUEST_ENCODING_DEFAULTXML 620 /* Object */ +#define UA_NS0ID_QUERYNEXTREQUEST_ENCODING_DEFAULTBINARY 621 /* Object */ +#define UA_NS0ID_QUERYNEXTRESPONSE 622 /* DataType */ +#define UA_NS0ID_QUERYNEXTRESPONSE_ENCODING_DEFAULTXML 623 /* Object */ +#define UA_NS0ID_QUERYNEXTRESPONSE_ENCODING_DEFAULTBINARY 624 /* Object */ +#define UA_NS0ID_TIMESTAMPSTORETURN 625 /* DataType */ +#define UA_NS0ID_READVALUEID 626 /* DataType */ +#define UA_NS0ID_READVALUEID_ENCODING_DEFAULTXML 627 /* Object */ +#define UA_NS0ID_READVALUEID_ENCODING_DEFAULTBINARY 628 /* Object */ +#define UA_NS0ID_READREQUEST 629 /* DataType */ +#define UA_NS0ID_READREQUEST_ENCODING_DEFAULTXML 630 /* Object */ +#define UA_NS0ID_READREQUEST_ENCODING_DEFAULTBINARY 631 /* Object */ +#define UA_NS0ID_READRESPONSE 632 /* DataType */ +#define UA_NS0ID_READRESPONSE_ENCODING_DEFAULTXML 633 /* Object */ +#define UA_NS0ID_READRESPONSE_ENCODING_DEFAULTBINARY 634 /* Object */ +#define UA_NS0ID_HISTORYREADVALUEID 635 /* DataType */ +#define UA_NS0ID_HISTORYREADVALUEID_ENCODING_DEFAULTXML 636 /* Object */ +#define UA_NS0ID_HISTORYREADVALUEID_ENCODING_DEFAULTBINARY 637 /* Object */ +#define UA_NS0ID_HISTORYREADRESULT 638 /* DataType */ +#define UA_NS0ID_HISTORYREADRESULT_ENCODING_DEFAULTXML 639 /* Object */ +#define UA_NS0ID_HISTORYREADRESULT_ENCODING_DEFAULTBINARY 640 /* Object */ +#define UA_NS0ID_HISTORYREADDETAILS 641 /* DataType */ +#define UA_NS0ID_HISTORYREADDETAILS_ENCODING_DEFAULTXML 642 /* Object */ +#define UA_NS0ID_HISTORYREADDETAILS_ENCODING_DEFAULTBINARY 643 /* Object */ +#define UA_NS0ID_READEVENTDETAILS 644 /* DataType */ +#define UA_NS0ID_READEVENTDETAILS_ENCODING_DEFAULTXML 645 /* Object */ +#define UA_NS0ID_READEVENTDETAILS_ENCODING_DEFAULTBINARY 646 /* Object */ +#define UA_NS0ID_READRAWMODIFIEDDETAILS 647 /* DataType */ +#define UA_NS0ID_READRAWMODIFIEDDETAILS_ENCODING_DEFAULTXML 648 /* Object */ +#define UA_NS0ID_READRAWMODIFIEDDETAILS_ENCODING_DEFAULTBINARY 649 /* Object */ +#define UA_NS0ID_READPROCESSEDDETAILS 650 /* DataType */ +#define UA_NS0ID_READPROCESSEDDETAILS_ENCODING_DEFAULTXML 651 /* Object */ +#define UA_NS0ID_READPROCESSEDDETAILS_ENCODING_DEFAULTBINARY 652 /* Object */ +#define UA_NS0ID_READATTIMEDETAILS 653 /* DataType */ +#define UA_NS0ID_READATTIMEDETAILS_ENCODING_DEFAULTXML 654 /* Object */ +#define UA_NS0ID_READATTIMEDETAILS_ENCODING_DEFAULTBINARY 655 /* Object */ +#define UA_NS0ID_HISTORYDATA 656 /* DataType */ +#define UA_NS0ID_HISTORYDATA_ENCODING_DEFAULTXML 657 /* Object */ +#define UA_NS0ID_HISTORYDATA_ENCODING_DEFAULTBINARY 658 /* Object */ +#define UA_NS0ID_HISTORYEVENT 659 /* DataType */ +#define UA_NS0ID_HISTORYEVENT_ENCODING_DEFAULTXML 660 /* Object */ +#define UA_NS0ID_HISTORYEVENT_ENCODING_DEFAULTBINARY 661 /* Object */ +#define UA_NS0ID_HISTORYREADREQUEST 662 /* DataType */ +#define UA_NS0ID_HISTORYREADREQUEST_ENCODING_DEFAULTXML 663 /* Object */ +#define UA_NS0ID_HISTORYREADREQUEST_ENCODING_DEFAULTBINARY 664 /* Object */ +#define UA_NS0ID_HISTORYREADRESPONSE 665 /* DataType */ +#define UA_NS0ID_HISTORYREADRESPONSE_ENCODING_DEFAULTXML 666 /* Object */ +#define UA_NS0ID_HISTORYREADRESPONSE_ENCODING_DEFAULTBINARY 667 /* Object */ +#define UA_NS0ID_WRITEVALUE 668 /* DataType */ +#define UA_NS0ID_WRITEVALUE_ENCODING_DEFAULTXML 669 /* Object */ +#define UA_NS0ID_WRITEVALUE_ENCODING_DEFAULTBINARY 670 /* Object */ +#define UA_NS0ID_WRITEREQUEST 671 /* DataType */ +#define UA_NS0ID_WRITEREQUEST_ENCODING_DEFAULTXML 672 /* Object */ +#define UA_NS0ID_WRITEREQUEST_ENCODING_DEFAULTBINARY 673 /* Object */ +#define UA_NS0ID_WRITERESPONSE 674 /* DataType */ +#define UA_NS0ID_WRITERESPONSE_ENCODING_DEFAULTXML 675 /* Object */ +#define UA_NS0ID_WRITERESPONSE_ENCODING_DEFAULTBINARY 676 /* Object */ +#define UA_NS0ID_HISTORYUPDATEDETAILS 677 /* DataType */ +#define UA_NS0ID_HISTORYUPDATEDETAILS_ENCODING_DEFAULTXML 678 /* Object */ +#define UA_NS0ID_HISTORYUPDATEDETAILS_ENCODING_DEFAULTBINARY 679 /* Object */ +#define UA_NS0ID_UPDATEDATADETAILS 680 /* DataType */ +#define UA_NS0ID_UPDATEDATADETAILS_ENCODING_DEFAULTXML 681 /* Object */ +#define UA_NS0ID_UPDATEDATADETAILS_ENCODING_DEFAULTBINARY 682 /* Object */ +#define UA_NS0ID_UPDATEEVENTDETAILS 683 /* DataType */ +#define UA_NS0ID_UPDATEEVENTDETAILS_ENCODING_DEFAULTXML 684 /* Object */ +#define UA_NS0ID_UPDATEEVENTDETAILS_ENCODING_DEFAULTBINARY 685 /* Object */ +#define UA_NS0ID_DELETERAWMODIFIEDDETAILS 686 /* DataType */ +#define UA_NS0ID_DELETERAWMODIFIEDDETAILS_ENCODING_DEFAULTXML 687 /* Object */ +#define UA_NS0ID_DELETERAWMODIFIEDDETAILS_ENCODING_DEFAULTBINARY 688 /* Object */ +#define UA_NS0ID_DELETEATTIMEDETAILS 689 /* DataType */ +#define UA_NS0ID_DELETEATTIMEDETAILS_ENCODING_DEFAULTXML 690 /* Object */ +#define UA_NS0ID_DELETEATTIMEDETAILS_ENCODING_DEFAULTBINARY 691 /* Object */ +#define UA_NS0ID_DELETEEVENTDETAILS 692 /* DataType */ +#define UA_NS0ID_DELETEEVENTDETAILS_ENCODING_DEFAULTXML 693 /* Object */ +#define UA_NS0ID_DELETEEVENTDETAILS_ENCODING_DEFAULTBINARY 694 /* Object */ +#define UA_NS0ID_HISTORYUPDATERESULT 695 /* DataType */ +#define UA_NS0ID_HISTORYUPDATERESULT_ENCODING_DEFAULTXML 696 /* Object */ +#define UA_NS0ID_HISTORYUPDATERESULT_ENCODING_DEFAULTBINARY 697 /* Object */ +#define UA_NS0ID_HISTORYUPDATEREQUEST 698 /* DataType */ +#define UA_NS0ID_HISTORYUPDATEREQUEST_ENCODING_DEFAULTXML 699 /* Object */ +#define UA_NS0ID_HISTORYUPDATEREQUEST_ENCODING_DEFAULTBINARY 700 /* Object */ +#define UA_NS0ID_HISTORYUPDATERESPONSE 701 /* DataType */ +#define UA_NS0ID_HISTORYUPDATERESPONSE_ENCODING_DEFAULTXML 702 /* Object */ +#define UA_NS0ID_HISTORYUPDATERESPONSE_ENCODING_DEFAULTBINARY 703 /* Object */ +#define UA_NS0ID_CALLMETHODREQUEST 704 /* DataType */ +#define UA_NS0ID_CALLMETHODREQUEST_ENCODING_DEFAULTXML 705 /* Object */ +#define UA_NS0ID_CALLMETHODREQUEST_ENCODING_DEFAULTBINARY 706 /* Object */ +#define UA_NS0ID_CALLMETHODRESULT 707 /* DataType */ +#define UA_NS0ID_CALLMETHODRESULT_ENCODING_DEFAULTXML 708 /* Object */ +#define UA_NS0ID_CALLMETHODRESULT_ENCODING_DEFAULTBINARY 709 /* Object */ +#define UA_NS0ID_CALLREQUEST 710 /* DataType */ +#define UA_NS0ID_CALLREQUEST_ENCODING_DEFAULTXML 711 /* Object */ +#define UA_NS0ID_CALLREQUEST_ENCODING_DEFAULTBINARY 712 /* Object */ +#define UA_NS0ID_CALLRESPONSE 713 /* DataType */ +#define UA_NS0ID_CALLRESPONSE_ENCODING_DEFAULTXML 714 /* Object */ +#define UA_NS0ID_CALLRESPONSE_ENCODING_DEFAULTBINARY 715 /* Object */ +#define UA_NS0ID_MONITORINGMODE 716 /* DataType */ +#define UA_NS0ID_DATACHANGETRIGGER 717 /* DataType */ +#define UA_NS0ID_DEADBANDTYPE 718 /* DataType */ +#define UA_NS0ID_MONITORINGFILTER 719 /* DataType */ +#define UA_NS0ID_MONITORINGFILTER_ENCODING_DEFAULTXML 720 /* Object */ +#define UA_NS0ID_MONITORINGFILTER_ENCODING_DEFAULTBINARY 721 /* Object */ +#define UA_NS0ID_DATACHANGEFILTER 722 /* DataType */ +#define UA_NS0ID_DATACHANGEFILTER_ENCODING_DEFAULTXML 723 /* Object */ +#define UA_NS0ID_DATACHANGEFILTER_ENCODING_DEFAULTBINARY 724 /* Object */ +#define UA_NS0ID_EVENTFILTER 725 /* DataType */ +#define UA_NS0ID_EVENTFILTER_ENCODING_DEFAULTXML 726 /* Object */ +#define UA_NS0ID_EVENTFILTER_ENCODING_DEFAULTBINARY 727 /* Object */ +#define UA_NS0ID_AGGREGATEFILTER 728 /* DataType */ +#define UA_NS0ID_AGGREGATEFILTER_ENCODING_DEFAULTXML 729 /* Object */ +#define UA_NS0ID_AGGREGATEFILTER_ENCODING_DEFAULTBINARY 730 /* Object */ +#define UA_NS0ID_MONITORINGFILTERRESULT 731 /* DataType */ +#define UA_NS0ID_MONITORINGFILTERRESULT_ENCODING_DEFAULTXML 732 /* Object */ +#define UA_NS0ID_MONITORINGFILTERRESULT_ENCODING_DEFAULTBINARY 733 /* Object */ +#define UA_NS0ID_EVENTFILTERRESULT 734 /* DataType */ +#define UA_NS0ID_EVENTFILTERRESULT_ENCODING_DEFAULTXML 735 /* Object */ +#define UA_NS0ID_EVENTFILTERRESULT_ENCODING_DEFAULTBINARY 736 /* Object */ +#define UA_NS0ID_AGGREGATEFILTERRESULT 737 /* DataType */ +#define UA_NS0ID_AGGREGATEFILTERRESULT_ENCODING_DEFAULTXML 738 /* Object */ +#define UA_NS0ID_AGGREGATEFILTERRESULT_ENCODING_DEFAULTBINARY 739 /* Object */ +#define UA_NS0ID_MONITORINGPARAMETERS 740 /* DataType */ +#define UA_NS0ID_MONITORINGPARAMETERS_ENCODING_DEFAULTXML 741 /* Object */ +#define UA_NS0ID_MONITORINGPARAMETERS_ENCODING_DEFAULTBINARY 742 /* Object */ +#define UA_NS0ID_MONITOREDITEMCREATEREQUEST 743 /* DataType */ +#define UA_NS0ID_MONITOREDITEMCREATEREQUEST_ENCODING_DEFAULTXML 744 /* Object */ +#define UA_NS0ID_MONITOREDITEMCREATEREQUEST_ENCODING_DEFAULTBINARY 745 /* Object */ +#define UA_NS0ID_MONITOREDITEMCREATERESULT 746 /* DataType */ +#define UA_NS0ID_MONITOREDITEMCREATERESULT_ENCODING_DEFAULTXML 747 /* Object */ +#define UA_NS0ID_MONITOREDITEMCREATERESULT_ENCODING_DEFAULTBINARY 748 /* Object */ +#define UA_NS0ID_CREATEMONITOREDITEMSREQUEST 749 /* DataType */ +#define UA_NS0ID_CREATEMONITOREDITEMSREQUEST_ENCODING_DEFAULTXML 750 /* Object */ +#define UA_NS0ID_CREATEMONITOREDITEMSREQUEST_ENCODING_DEFAULTBINARY 751 /* Object */ +#define UA_NS0ID_CREATEMONITOREDITEMSRESPONSE 752 /* DataType */ +#define UA_NS0ID_CREATEMONITOREDITEMSRESPONSE_ENCODING_DEFAULTXML 753 /* Object */ +#define UA_NS0ID_CREATEMONITOREDITEMSRESPONSE_ENCODING_DEFAULTBINARY 754 /* Object */ +#define UA_NS0ID_MONITOREDITEMMODIFYREQUEST 755 /* DataType */ +#define UA_NS0ID_MONITOREDITEMMODIFYREQUEST_ENCODING_DEFAULTXML 756 /* Object */ +#define UA_NS0ID_MONITOREDITEMMODIFYREQUEST_ENCODING_DEFAULTBINARY 757 /* Object */ +#define UA_NS0ID_MONITOREDITEMMODIFYRESULT 758 /* DataType */ +#define UA_NS0ID_MONITOREDITEMMODIFYRESULT_ENCODING_DEFAULTXML 759 /* Object */ +#define UA_NS0ID_MONITOREDITEMMODIFYRESULT_ENCODING_DEFAULTBINARY 760 /* Object */ +#define UA_NS0ID_MODIFYMONITOREDITEMSREQUEST 761 /* DataType */ +#define UA_NS0ID_MODIFYMONITOREDITEMSREQUEST_ENCODING_DEFAULTXML 762 /* Object */ +#define UA_NS0ID_MODIFYMONITOREDITEMSREQUEST_ENCODING_DEFAULTBINARY 763 /* Object */ +#define UA_NS0ID_MODIFYMONITOREDITEMSRESPONSE 764 /* DataType */ +#define UA_NS0ID_MODIFYMONITOREDITEMSRESPONSE_ENCODING_DEFAULTXML 765 /* Object */ +#define UA_NS0ID_MODIFYMONITOREDITEMSRESPONSE_ENCODING_DEFAULTBINARY 766 /* Object */ +#define UA_NS0ID_SETMONITORINGMODEREQUEST 767 /* DataType */ +#define UA_NS0ID_SETMONITORINGMODEREQUEST_ENCODING_DEFAULTXML 768 /* Object */ +#define UA_NS0ID_SETMONITORINGMODEREQUEST_ENCODING_DEFAULTBINARY 769 /* Object */ +#define UA_NS0ID_SETMONITORINGMODERESPONSE 770 /* DataType */ +#define UA_NS0ID_SETMONITORINGMODERESPONSE_ENCODING_DEFAULTXML 771 /* Object */ +#define UA_NS0ID_SETMONITORINGMODERESPONSE_ENCODING_DEFAULTBINARY 772 /* Object */ +#define UA_NS0ID_SETTRIGGERINGREQUEST 773 /* DataType */ +#define UA_NS0ID_SETTRIGGERINGREQUEST_ENCODING_DEFAULTXML 774 /* Object */ +#define UA_NS0ID_SETTRIGGERINGREQUEST_ENCODING_DEFAULTBINARY 775 /* Object */ +#define UA_NS0ID_SETTRIGGERINGRESPONSE 776 /* DataType */ +#define UA_NS0ID_SETTRIGGERINGRESPONSE_ENCODING_DEFAULTXML 777 /* Object */ +#define UA_NS0ID_SETTRIGGERINGRESPONSE_ENCODING_DEFAULTBINARY 778 /* Object */ +#define UA_NS0ID_DELETEMONITOREDITEMSREQUEST 779 /* DataType */ +#define UA_NS0ID_DELETEMONITOREDITEMSREQUEST_ENCODING_DEFAULTXML 780 /* Object */ +#define UA_NS0ID_DELETEMONITOREDITEMSREQUEST_ENCODING_DEFAULTBINARY 781 /* Object */ +#define UA_NS0ID_DELETEMONITOREDITEMSRESPONSE 782 /* DataType */ +#define UA_NS0ID_DELETEMONITOREDITEMSRESPONSE_ENCODING_DEFAULTXML 783 /* Object */ +#define UA_NS0ID_DELETEMONITOREDITEMSRESPONSE_ENCODING_DEFAULTBINARY 784 /* Object */ +#define UA_NS0ID_CREATESUBSCRIPTIONREQUEST 785 /* DataType */ +#define UA_NS0ID_CREATESUBSCRIPTIONREQUEST_ENCODING_DEFAULTXML 786 /* Object */ +#define UA_NS0ID_CREATESUBSCRIPTIONREQUEST_ENCODING_DEFAULTBINARY 787 /* Object */ +#define UA_NS0ID_CREATESUBSCRIPTIONRESPONSE 788 /* DataType */ +#define UA_NS0ID_CREATESUBSCRIPTIONRESPONSE_ENCODING_DEFAULTXML 789 /* Object */ +#define UA_NS0ID_CREATESUBSCRIPTIONRESPONSE_ENCODING_DEFAULTBINARY 790 /* Object */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONREQUEST 791 /* DataType */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONREQUEST_ENCODING_DEFAULTXML 792 /* Object */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONREQUEST_ENCODING_DEFAULTBINARY 793 /* Object */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONRESPONSE 794 /* DataType */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONRESPONSE_ENCODING_DEFAULTXML 795 /* Object */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONRESPONSE_ENCODING_DEFAULTBINARY 796 /* Object */ +#define UA_NS0ID_SETPUBLISHINGMODEREQUEST 797 /* DataType */ +#define UA_NS0ID_SETPUBLISHINGMODEREQUEST_ENCODING_DEFAULTXML 798 /* Object */ +#define UA_NS0ID_SETPUBLISHINGMODEREQUEST_ENCODING_DEFAULTBINARY 799 /* Object */ +#define UA_NS0ID_SETPUBLISHINGMODERESPONSE 800 /* DataType */ +#define UA_NS0ID_SETPUBLISHINGMODERESPONSE_ENCODING_DEFAULTXML 801 /* Object */ +#define UA_NS0ID_SETPUBLISHINGMODERESPONSE_ENCODING_DEFAULTBINARY 802 /* Object */ +#define UA_NS0ID_NOTIFICATIONMESSAGE 803 /* DataType */ +#define UA_NS0ID_NOTIFICATIONMESSAGE_ENCODING_DEFAULTXML 804 /* Object */ +#define UA_NS0ID_NOTIFICATIONMESSAGE_ENCODING_DEFAULTBINARY 805 /* Object */ +#define UA_NS0ID_MONITOREDITEMNOTIFICATION 806 /* DataType */ +#define UA_NS0ID_MONITOREDITEMNOTIFICATION_ENCODING_DEFAULTXML 807 /* Object */ +#define UA_NS0ID_MONITOREDITEMNOTIFICATION_ENCODING_DEFAULTBINARY 808 /* Object */ +#define UA_NS0ID_DATACHANGENOTIFICATION 809 /* DataType */ +#define UA_NS0ID_DATACHANGENOTIFICATION_ENCODING_DEFAULTXML 810 /* Object */ +#define UA_NS0ID_DATACHANGENOTIFICATION_ENCODING_DEFAULTBINARY 811 /* Object */ +#define UA_NS0ID_STATUSCHANGENOTIFICATION 818 /* DataType */ +#define UA_NS0ID_STATUSCHANGENOTIFICATION_ENCODING_DEFAULTXML 819 /* Object */ +#define UA_NS0ID_STATUSCHANGENOTIFICATION_ENCODING_DEFAULTBINARY 820 /* Object */ +#define UA_NS0ID_SUBSCRIPTIONACKNOWLEDGEMENT 821 /* DataType */ +#define UA_NS0ID_SUBSCRIPTIONACKNOWLEDGEMENT_ENCODING_DEFAULTXML 822 /* Object */ +#define UA_NS0ID_SUBSCRIPTIONACKNOWLEDGEMENT_ENCODING_DEFAULTBINARY 823 /* Object */ +#define UA_NS0ID_PUBLISHREQUEST 824 /* DataType */ +#define UA_NS0ID_PUBLISHREQUEST_ENCODING_DEFAULTXML 825 /* Object */ +#define UA_NS0ID_PUBLISHREQUEST_ENCODING_DEFAULTBINARY 826 /* Object */ +#define UA_NS0ID_PUBLISHRESPONSE 827 /* DataType */ +#define UA_NS0ID_PUBLISHRESPONSE_ENCODING_DEFAULTXML 828 /* Object */ +#define UA_NS0ID_PUBLISHRESPONSE_ENCODING_DEFAULTBINARY 829 /* Object */ +#define UA_NS0ID_REPUBLISHREQUEST 830 /* DataType */ +#define UA_NS0ID_REPUBLISHREQUEST_ENCODING_DEFAULTXML 831 /* Object */ +#define UA_NS0ID_REPUBLISHREQUEST_ENCODING_DEFAULTBINARY 832 /* Object */ +#define UA_NS0ID_REPUBLISHRESPONSE 833 /* DataType */ +#define UA_NS0ID_REPUBLISHRESPONSE_ENCODING_DEFAULTXML 834 /* Object */ +#define UA_NS0ID_REPUBLISHRESPONSE_ENCODING_DEFAULTBINARY 835 /* Object */ +#define UA_NS0ID_TRANSFERRESULT 836 /* DataType */ +#define UA_NS0ID_TRANSFERRESULT_ENCODING_DEFAULTXML 837 /* Object */ +#define UA_NS0ID_TRANSFERRESULT_ENCODING_DEFAULTBINARY 838 /* Object */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSREQUEST 839 /* DataType */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSREQUEST_ENCODING_DEFAULTXML 840 /* Object */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSREQUEST_ENCODING_DEFAULTBINARY 841 /* Object */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSRESPONSE 842 /* DataType */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSRESPONSE_ENCODING_DEFAULTXML 843 /* Object */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSRESPONSE_ENCODING_DEFAULTBINARY 844 /* Object */ +#define UA_NS0ID_DELETESUBSCRIPTIONSREQUEST 845 /* DataType */ +#define UA_NS0ID_DELETESUBSCRIPTIONSREQUEST_ENCODING_DEFAULTXML 846 /* Object */ +#define UA_NS0ID_DELETESUBSCRIPTIONSREQUEST_ENCODING_DEFAULTBINARY 847 /* Object */ +#define UA_NS0ID_DELETESUBSCRIPTIONSRESPONSE 848 /* DataType */ +#define UA_NS0ID_DELETESUBSCRIPTIONSRESPONSE_ENCODING_DEFAULTXML 849 /* Object */ +#define UA_NS0ID_DELETESUBSCRIPTIONSRESPONSE_ENCODING_DEFAULTBINARY 850 /* Object */ +#define UA_NS0ID_REDUNDANCYSUPPORT 851 /* DataType */ +#define UA_NS0ID_SERVERSTATE 852 /* DataType */ +#define UA_NS0ID_REDUNDANTSERVERDATATYPE 853 /* DataType */ +#define UA_NS0ID_REDUNDANTSERVERDATATYPE_ENCODING_DEFAULTXML 854 /* Object */ +#define UA_NS0ID_REDUNDANTSERVERDATATYPE_ENCODING_DEFAULTBINARY 855 /* Object */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSDATATYPE 856 /* DataType */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSDATATYPE_ENCODING_DEFAULTXML 857 /* Object */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSDATATYPE_ENCODING_DEFAULTBINARY 858 /* Object */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYDATATYPE 859 /* DataType */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYDATATYPE_ENCODING_DEFAULTXML 860 /* Object */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYDATATYPE_ENCODING_DEFAULTBINARY 861 /* Object */ +#define UA_NS0ID_SERVERSTATUSDATATYPE 862 /* DataType */ +#define UA_NS0ID_SERVERSTATUSDATATYPE_ENCODING_DEFAULTXML 863 /* Object */ +#define UA_NS0ID_SERVERSTATUSDATATYPE_ENCODING_DEFAULTBINARY 864 /* Object */ +#define UA_NS0ID_SESSIONDIAGNOSTICSDATATYPE 865 /* DataType */ +#define UA_NS0ID_SESSIONDIAGNOSTICSDATATYPE_ENCODING_DEFAULTXML 866 /* Object */ +#define UA_NS0ID_SESSIONDIAGNOSTICSDATATYPE_ENCODING_DEFAULTBINARY 867 /* Object */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSDATATYPE 868 /* DataType */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSDATATYPE_ENCODING_DEFAULTXML 869 /* Object */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSDATATYPE_ENCODING_DEFAULTBINARY 870 /* Object */ +#define UA_NS0ID_SERVICECOUNTERDATATYPE 871 /* DataType */ +#define UA_NS0ID_SERVICECOUNTERDATATYPE_ENCODING_DEFAULTXML 872 /* Object */ +#define UA_NS0ID_SERVICECOUNTERDATATYPE_ENCODING_DEFAULTBINARY 873 /* Object */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSDATATYPE 874 /* DataType */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSDATATYPE_ENCODING_DEFAULTXML 875 /* Object */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSDATATYPE_ENCODING_DEFAULTBINARY 876 /* Object */ +#define UA_NS0ID_MODELCHANGESTRUCTUREDATATYPE 877 /* DataType */ +#define UA_NS0ID_MODELCHANGESTRUCTUREDATATYPE_ENCODING_DEFAULTXML 878 /* Object */ +#define UA_NS0ID_MODELCHANGESTRUCTUREDATATYPE_ENCODING_DEFAULTBINARY 879 /* Object */ +#define UA_NS0ID_RANGE 884 /* DataType */ +#define UA_NS0ID_RANGE_ENCODING_DEFAULTXML 885 /* Object */ +#define UA_NS0ID_RANGE_ENCODING_DEFAULTBINARY 886 /* Object */ +#define UA_NS0ID_EUINFORMATION 887 /* DataType */ +#define UA_NS0ID_EUINFORMATION_ENCODING_DEFAULTXML 888 /* Object */ +#define UA_NS0ID_EUINFORMATION_ENCODING_DEFAULTBINARY 889 /* Object */ +#define UA_NS0ID_EXCEPTIONDEVIATIONFORMAT 890 /* DataType */ +#define UA_NS0ID_ANNOTATION 891 /* DataType */ +#define UA_NS0ID_ANNOTATION_ENCODING_DEFAULTXML 892 /* Object */ +#define UA_NS0ID_ANNOTATION_ENCODING_DEFAULTBINARY 893 /* Object */ +#define UA_NS0ID_PROGRAMDIAGNOSTICDATATYPE 894 /* DataType */ +#define UA_NS0ID_PROGRAMDIAGNOSTICDATATYPE_ENCODING_DEFAULTXML 895 /* Object */ +#define UA_NS0ID_PROGRAMDIAGNOSTICDATATYPE_ENCODING_DEFAULTBINARY 896 /* Object */ +#define UA_NS0ID_SEMANTICCHANGESTRUCTUREDATATYPE 897 /* DataType */ +#define UA_NS0ID_SEMANTICCHANGESTRUCTUREDATATYPE_ENCODING_DEFAULTXML 898 /* Object */ +#define UA_NS0ID_SEMANTICCHANGESTRUCTUREDATATYPE_ENCODING_DEFAULTBINARY 899 /* Object */ +#define UA_NS0ID_EVENTNOTIFICATIONLIST 914 /* DataType */ +#define UA_NS0ID_EVENTNOTIFICATIONLIST_ENCODING_DEFAULTXML 915 /* Object */ +#define UA_NS0ID_EVENTNOTIFICATIONLIST_ENCODING_DEFAULTBINARY 916 /* Object */ +#define UA_NS0ID_EVENTFIELDLIST 917 /* DataType */ +#define UA_NS0ID_EVENTFIELDLIST_ENCODING_DEFAULTXML 918 /* Object */ +#define UA_NS0ID_EVENTFIELDLIST_ENCODING_DEFAULTBINARY 919 /* Object */ +#define UA_NS0ID_HISTORYEVENTFIELDLIST 920 /* DataType */ +#define UA_NS0ID_HISTORYEVENTFIELDLIST_ENCODING_DEFAULTXML 921 /* Object */ +#define UA_NS0ID_HISTORYEVENTFIELDLIST_ENCODING_DEFAULTBINARY 922 /* Object */ +#define UA_NS0ID_ISSUEDIDENTITYTOKEN 938 /* DataType */ +#define UA_NS0ID_ISSUEDIDENTITYTOKEN_ENCODING_DEFAULTXML 939 /* Object */ +#define UA_NS0ID_ISSUEDIDENTITYTOKEN_ENCODING_DEFAULTBINARY 940 /* Object */ +#define UA_NS0ID_NOTIFICATIONDATA 945 /* DataType */ +#define UA_NS0ID_NOTIFICATIONDATA_ENCODING_DEFAULTXML 946 /* Object */ +#define UA_NS0ID_NOTIFICATIONDATA_ENCODING_DEFAULTBINARY 947 /* Object */ +#define UA_NS0ID_AGGREGATECONFIGURATION 948 /* DataType */ +#define UA_NS0ID_AGGREGATECONFIGURATION_ENCODING_DEFAULTXML 949 /* Object */ +#define UA_NS0ID_AGGREGATECONFIGURATION_ENCODING_DEFAULTBINARY 950 /* Object */ +#define UA_NS0ID_IMAGEBMP 2000 /* DataType */ +#define UA_NS0ID_IMAGEGIF 2001 /* DataType */ +#define UA_NS0ID_IMAGEJPG 2002 /* DataType */ +#define UA_NS0ID_IMAGEPNG 2003 /* DataType */ +#define UA_NS0ID_SERVERTYPE 2004 /* ObjectType */ +#define UA_NS0ID_SERVERTYPE_SERVERARRAY 2005 /* Variable */ +#define UA_NS0ID_SERVERTYPE_NAMESPACEARRAY 2006 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS 2007 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVICELEVEL 2008 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES 2009 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS 2010 /* Object */ +#define UA_NS0ID_SERVERTYPE_VENDORSERVERINFO 2011 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERREDUNDANCY 2012 /* Object */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE 2013 /* ObjectType */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_SERVERPROFILEARRAY 2014 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_LOCALEIDARRAY 2016 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MINSUPPORTEDSAMPLERATE 2017 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MODELLINGRULES 2019 /* Object */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE 2020 /* ObjectType */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY 2021 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SAMPLINGINTERVALDIAGNOSTICSARRAY 2022 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SUBSCRIPTIONDIAGNOSTICSARRAY 2023 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_ENABLEDFLAG 2025 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE 2026 /* ObjectType */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_SESSIONDIAGNOSTICSARRAY 2027 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_SESSIONSECURITYDIAGNOSTICSARRAY 2028 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE 2029 /* ObjectType */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS 2030 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS 2031 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SUBSCRIPTIONDIAGNOSTICSARRAY 2032 /* Variable */ +#define UA_NS0ID_VENDORSERVERINFOTYPE 2033 /* ObjectType */ +#define UA_NS0ID_SERVERREDUNDANCYTYPE 2034 /* ObjectType */ +#define UA_NS0ID_SERVERREDUNDANCYTYPE_REDUNDANCYSUPPORT 2035 /* Variable */ +#define UA_NS0ID_TRANSPARENTREDUNDANCYTYPE 2036 /* ObjectType */ +#define UA_NS0ID_TRANSPARENTREDUNDANCYTYPE_CURRENTSERVERID 2037 /* Variable */ +#define UA_NS0ID_TRANSPARENTREDUNDANCYTYPE_REDUNDANTSERVERARRAY 2038 /* Variable */ +#define UA_NS0ID_NONTRANSPARENTREDUNDANCYTYPE 2039 /* ObjectType */ +#define UA_NS0ID_NONTRANSPARENTREDUNDANCYTYPE_SERVERURIARRAY 2040 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE 2041 /* ObjectType */ +#define UA_NS0ID_BASEEVENTTYPE_EVENTID 2042 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_EVENTTYPE 2043 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_SOURCENODE 2044 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_SOURCENAME 2045 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_TIME 2046 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_RECEIVETIME 2047 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_MESSAGE 2050 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_SEVERITY 2051 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE 2052 /* ObjectType */ +#define UA_NS0ID_AUDITEVENTTYPE_ACTIONTIMESTAMP 2053 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_STATUS 2054 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_SERVERID 2055 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_CLIENTAUDITENTRYID 2056 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_CLIENTUSERID 2057 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE 2058 /* ObjectType */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE 2059 /* ObjectType */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE 2060 /* ObjectType */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_CLIENTCERTIFICATE 2061 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_REQUESTTYPE 2062 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_SECURITYPOLICYURI 2063 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_SECURITYMODE 2065 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_REQUESTEDLIFETIME 2066 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE 2069 /* ObjectType */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_SESSIONID 2070 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE 2071 /* ObjectType */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_SECURECHANNELID 2072 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_CLIENTCERTIFICATE 2073 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_REVISEDSESSIONTIMEOUT 2074 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE 2075 /* ObjectType */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_CLIENTSOFTWARECERTIFICATES 2076 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_USERIDENTITYTOKEN 2077 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE 2078 /* ObjectType */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_REQUESTHANDLE 2079 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE 2080 /* ObjectType */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_CERTIFICATE 2081 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE 2082 /* ObjectType */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_INVALIDHOSTNAME 2083 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_INVALIDURI 2084 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE 2085 /* ObjectType */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE 2086 /* ObjectType */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE 2087 /* ObjectType */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE 2088 /* ObjectType */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE 2089 /* ObjectType */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE 2090 /* ObjectType */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE 2091 /* ObjectType */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_NODESTOADD 2092 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE 2093 /* ObjectType */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_NODESTODELETE 2094 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE 2095 /* ObjectType */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_REFERENCESTOADD 2096 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE 2097 /* ObjectType */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_REFERENCESTODELETE 2098 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE 2099 /* ObjectType */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE 2100 /* ObjectType */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_INDEXRANGE 2101 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_OLDVALUE 2102 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_NEWVALUE 2103 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE 2104 /* ObjectType */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE 2127 /* ObjectType */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_METHODID 2128 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_INPUTARGUMENTS 2129 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE 2130 /* ObjectType */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE 2131 /* ObjectType */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE 2132 /* ObjectType */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE 2133 /* ObjectType */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_CHANGES 2134 /* Variable */ +#define UA_NS0ID_SERVERVENDORCAPABILITYTYPE 2137 /* VariableType */ +#define UA_NS0ID_SERVERSTATUSTYPE 2138 /* VariableType */ +#define UA_NS0ID_SERVERSTATUSTYPE_STARTTIME 2139 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_CURRENTTIME 2140 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_STATE 2141 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_BUILDINFO 2142 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE 2150 /* VariableType */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_SERVERVIEWCOUNT 2151 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_CURRENTSESSIONCOUNT 2152 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_CUMULATEDSESSIONCOUNT 2153 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_SECURITYREJECTEDSESSIONCOUNT 2154 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_REJECTEDSESSIONCOUNT 2155 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_SESSIONTIMEOUTCOUNT 2156 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_SESSIONABORTCOUNT 2157 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_PUBLISHINGINTERVALCOUNT 2159 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_CURRENTSUBSCRIPTIONCOUNT 2160 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_CUMULATEDSUBSCRIPTIONCOUNT 2161 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_SECURITYREJECTEDREQUESTSCOUNT 2162 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYTYPE_REJECTEDREQUESTSCOUNT 2163 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSARRAYTYPE 2164 /* VariableType */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSTYPE 2165 /* VariableType */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSTYPE_SAMPLINGINTERVAL 2166 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE 2171 /* VariableType */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE 2172 /* VariableType */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_SESSIONID 2173 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_SUBSCRIPTIONID 2174 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_PRIORITY 2175 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_PUBLISHINGINTERVAL 2176 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_MAXKEEPALIVECOUNT 2177 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_MAXNOTIFICATIONSPERPUBLISH 2179 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_PUBLISHINGENABLED 2180 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_MODIFYCOUNT 2181 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_ENABLECOUNT 2182 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_DISABLECOUNT 2183 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_REPUBLISHREQUESTCOUNT 2184 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_REPUBLISHMESSAGEREQUESTCOUNT 2185 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_REPUBLISHMESSAGECOUNT 2186 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_TRANSFERREQUESTCOUNT 2187 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_TRANSFERREDTOALTCLIENTCOUNT 2188 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_TRANSFERREDTOSAMECLIENTCOUNT 2189 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_PUBLISHREQUESTCOUNT 2190 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_DATACHANGENOTIFICATIONSCOUNT 2191 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_NOTIFICATIONSCOUNT 2193 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE 2196 /* VariableType */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE 2197 /* VariableType */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_SESSIONID 2198 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_SESSIONNAME 2199 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CLIENTDESCRIPTION 2200 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_SERVERURI 2201 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_ENDPOINTURL 2202 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_LOCALEIDS 2203 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_ACTUALSESSIONTIMEOUT 2204 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CLIENTCONNECTIONTIME 2205 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CLIENTLASTCONTACTTIME 2206 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CURRENTSUBSCRIPTIONSCOUNT 2207 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CURRENTMONITOREDITEMSCOUNT 2208 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CURRENTPUBLISHREQUESTSINQUEUE 2209 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_READCOUNT 2217 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_HISTORYREADCOUNT 2218 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_WRITECOUNT 2219 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_HISTORYUPDATECOUNT 2220 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CALLCOUNT 2221 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CREATEMONITOREDITEMSCOUNT 2222 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_MODIFYMONITOREDITEMSCOUNT 2223 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_SETMONITORINGMODECOUNT 2224 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_SETTRIGGERINGCOUNT 2225 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_DELETEMONITOREDITEMSCOUNT 2226 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_CREATESUBSCRIPTIONCOUNT 2227 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_MODIFYSUBSCRIPTIONCOUNT 2228 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_SETPUBLISHINGMODECOUNT 2229 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_PUBLISHCOUNT 2230 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_REPUBLISHCOUNT 2231 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_TRANSFERSUBSCRIPTIONSCOUNT 2232 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_DELETESUBSCRIPTIONSCOUNT 2233 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_ADDNODESCOUNT 2234 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_ADDREFERENCESCOUNT 2235 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_DELETENODESCOUNT 2236 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_DELETEREFERENCESCOUNT 2237 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_BROWSECOUNT 2238 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_BROWSENEXTCOUNT 2239 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_TRANSLATEBROWSEPATHSTONODEIDSCOUNT 2240 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_QUERYFIRSTCOUNT 2241 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_QUERYNEXTCOUNT 2242 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE 2243 /* VariableType */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE 2244 /* VariableType */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_SESSIONID 2245 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_CLIENTUSERIDOFSESSION 2246 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_CLIENTUSERIDHISTORY 2247 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_AUTHENTICATIONMECHANISM 2248 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_ENCODING 2249 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_TRANSPORTPROTOCOL 2250 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_SECURITYMODE 2251 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_SECURITYPOLICYURI 2252 /* Variable */ +#define UA_NS0ID_SERVER 2253 /* Object */ +#define UA_NS0ID_SERVER_SERVERARRAY 2254 /* Variable */ +#define UA_NS0ID_SERVER_NAMESPACEARRAY 2255 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS 2256 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_STARTTIME 2257 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME 2258 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_STATE 2259 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO 2260 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTNAME 2261 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_PRODUCTURI 2262 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_MANUFACTURERNAME 2263 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_SOFTWAREVERSION 2264 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDNUMBER 2265 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_BUILDINFO_BUILDDATE 2266 /* Variable */ +#define UA_NS0ID_SERVER_SERVICELEVEL 2267 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES 2268 /* Object */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_SERVERPROFILEARRAY 2269 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_LOCALEIDARRAY 2271 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MINSUPPORTEDSAMPLERATE 2272 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS 2274 /* Object */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY 2275 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SERVERVIEWCOUNT 2276 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CURRENTSESSIONCOUNT 2277 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CUMULATEDSESSIONCOUNT 2278 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SECURITYREJECTEDSESSIONCOUNT 2279 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SESSIONTIMEOUTCOUNT 2281 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SESSIONABORTCOUNT 2282 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_PUBLISHINGINTERVALCOUNT 2284 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CURRENTSUBSCRIPTIONCOUNT 2285 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CUMULATEDSUBSCRIPTIONCOUNT 2286 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SECURITYREJECTEDREQUESTSCOUNT 2287 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_REJECTEDREQUESTSCOUNT 2288 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SAMPLINGINTERVALDIAGNOSTICSARRAY 2289 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SUBSCRIPTIONDIAGNOSTICSARRAY 2290 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_ENABLEDFLAG 2294 /* Variable */ +#define UA_NS0ID_SERVER_VENDORSERVERINFO 2295 /* Object */ +#define UA_NS0ID_SERVER_SERVERREDUNDANCY 2296 /* Object */ +#define UA_NS0ID_STATEMACHINETYPE 2299 /* ObjectType */ +#define UA_NS0ID_STATETYPE 2307 /* ObjectType */ +#define UA_NS0ID_STATETYPE_STATENUMBER 2308 /* Variable */ +#define UA_NS0ID_INITIALSTATETYPE 2309 /* ObjectType */ +#define UA_NS0ID_TRANSITIONTYPE 2310 /* ObjectType */ +#define UA_NS0ID_TRANSITIONEVENTTYPE 2311 /* ObjectType */ +#define UA_NS0ID_TRANSITIONTYPE_TRANSITIONNUMBER 2312 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE 2315 /* ObjectType */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE 2318 /* ObjectType */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_STEPPED 2323 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_DEFINITION 2324 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_MAXTIMEINTERVAL 2325 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_MINTIMEINTERVAL 2326 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_EXCEPTIONDEVIATION 2327 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_EXCEPTIONDEVIATIONFORMAT 2328 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE 2330 /* ObjectType */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_ACCESSHISTORYDATACAPABILITY 2331 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_ACCESSHISTORYEVENTSCAPABILITY 2332 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_INSERTDATACAPABILITY 2334 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_REPLACEDATACAPABILITY 2335 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_UPDATEDATACAPABILITY 2336 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_DELETERAWCAPABILITY 2337 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_DELETEATTIMECAPABILITY 2338 /* Variable */ +#define UA_NS0ID_AGGREGATEFUNCTIONTYPE 2340 /* ObjectType */ +#define UA_NS0ID_AGGREGATEFUNCTION_INTERPOLATIVE 2341 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_AVERAGE 2342 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_TIMEAVERAGE 2343 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_TOTAL 2344 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MINIMUM 2346 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MAXIMUM 2347 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MINIMUMACTUALTIME 2348 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MAXIMUMACTUALTIME 2349 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_RANGE 2350 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_ANNOTATIONCOUNT 2351 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_COUNT 2352 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_NUMBEROFTRANSITIONS 2355 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_START 2357 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_END 2358 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_DELTA 2359 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_DURATIONGOOD 2360 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_DURATIONBAD 2361 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_PERCENTGOOD 2362 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_PERCENTBAD 2363 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_WORSTQUALITY 2364 /* Object */ +#define UA_NS0ID_DATAITEMTYPE 2365 /* VariableType */ +#define UA_NS0ID_DATAITEMTYPE_DEFINITION 2366 /* Variable */ +#define UA_NS0ID_DATAITEMTYPE_VALUEPRECISION 2367 /* Variable */ +#define UA_NS0ID_ANALOGITEMTYPE 2368 /* VariableType */ +#define UA_NS0ID_ANALOGITEMTYPE_EURANGE 2369 /* Variable */ +#define UA_NS0ID_ANALOGITEMTYPE_INSTRUMENTRANGE 2370 /* Variable */ +#define UA_NS0ID_ANALOGITEMTYPE_ENGINEERINGUNITS 2371 /* Variable */ +#define UA_NS0ID_DISCRETEITEMTYPE 2372 /* VariableType */ +#define UA_NS0ID_TWOSTATEDISCRETETYPE 2373 /* VariableType */ +#define UA_NS0ID_TWOSTATEDISCRETETYPE_FALSESTATE 2374 /* Variable */ +#define UA_NS0ID_TWOSTATEDISCRETETYPE_TRUESTATE 2375 /* Variable */ +#define UA_NS0ID_MULTISTATEDISCRETETYPE 2376 /* VariableType */ +#define UA_NS0ID_MULTISTATEDISCRETETYPE_ENUMSTRINGS 2377 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE 2378 /* ObjectType */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_INTERMEDIATERESULT 2379 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE 2380 /* VariableType */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_CREATESESSIONID 2381 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_CREATECLIENTNAME 2382 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_INVOCATIONCREATIONTIME 2383 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_LASTTRANSITIONTIME 2384 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_LASTMETHODCALL 2385 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_LASTMETHODSESSIONID 2386 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_LASTMETHODINPUTARGUMENTS 2387 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_LASTMETHODOUTPUTARGUMENTS 2388 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_LASTMETHODCALLTIME 2389 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTICTYPE_LASTMETHODRETURNSTATUS 2390 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE 2391 /* ObjectType */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_CREATABLE 2392 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_DELETABLE 2393 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_AUTODELETE 2394 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RECYCLECOUNT 2395 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_INSTANCECOUNT 2396 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_MAXINSTANCECOUNT 2397 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_MAXRECYCLECOUNT 2398 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC 2399 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_READY 2400 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_READY_STATENUMBER 2401 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNING 2402 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNING_STATENUMBER 2403 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDED 2404 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDED_STATENUMBER 2405 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_HALTED 2406 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_HALTED_STATENUMBER 2407 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_HALTEDTOREADY 2408 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_HALTEDTOREADY_TRANSITIONNUMBER 2409 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_READYTORUNNING 2410 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_READYTORUNNING_TRANSITIONNUMBER 2411 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNINGTOHALTED 2412 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNINGTOHALTED_TRANSITIONNUMBER 2413 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNINGTOREADY 2414 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNINGTOREADY_TRANSITIONNUMBER 2415 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNINGTOSUSPENDED 2416 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RUNNINGTOSUSPENDED_TRANSITIONNUMBER 2417 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDEDTORUNNING 2418 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDEDTORUNNING_TRANSITIONNUMBER 2419 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDEDTOHALTED 2420 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDEDTOHALTED_TRANSITIONNUMBER 2421 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDEDTOREADY 2422 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPENDEDTOREADY_TRANSITIONNUMBER 2423 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_READYTOHALTED 2424 /* Object */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_READYTOHALTED_TRANSITIONNUMBER 2425 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_START 2426 /* Method */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_SUSPEND 2427 /* Method */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RESUME 2428 /* Method */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_HALT 2429 /* Method */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_RESET 2430 /* Method */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_REGISTERNODESCOUNT 2730 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_UNREGISTERNODESCOUNT 2731 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MAXBROWSECONTINUATIONPOINTS 2732 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MAXQUERYCONTINUATIONPOINTS 2733 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MAXHISTORYCONTINUATIONPOINTS 2734 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXBROWSECONTINUATIONPOINTS 2735 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXQUERYCONTINUATIONPOINTS 2736 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXHISTORYCONTINUATIONPOINTS 2737 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE 2738 /* ObjectType */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_CHANGES 2739 /* Variable */ +#define UA_NS0ID_SERVERTYPE_AUDITING 2742 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SESSIONSDIAGNOSTICSSUMMARY 2744 /* Object */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_SECURECHANNELID 2745 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_CLIENTCERTIFICATETHUMBPRINT 2746 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_CLIENTCERTIFICATETHUMBPRINT 2747 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE 2748 /* ObjectType */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_ENDPOINTURL 2749 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_ATTRIBUTEID 2750 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_PARAMETERDATATYPEID 2751 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_SECONDSTILLSHUTDOWN 2752 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_SHUTDOWNREASON 2753 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_AGGREGATEFUNCTIONS 2754 /* Object */ +#define UA_NS0ID_STATEVARIABLETYPE 2755 /* VariableType */ +#define UA_NS0ID_STATEVARIABLETYPE_ID 2756 /* Variable */ +#define UA_NS0ID_STATEVARIABLETYPE_NAME 2757 /* Variable */ +#define UA_NS0ID_STATEVARIABLETYPE_NUMBER 2758 /* Variable */ +#define UA_NS0ID_STATEVARIABLETYPE_EFFECTIVEDISPLAYNAME 2759 /* Variable */ +#define UA_NS0ID_FINITESTATEVARIABLETYPE 2760 /* VariableType */ +#define UA_NS0ID_FINITESTATEVARIABLETYPE_ID 2761 /* Variable */ +#define UA_NS0ID_TRANSITIONVARIABLETYPE 2762 /* VariableType */ +#define UA_NS0ID_TRANSITIONVARIABLETYPE_ID 2763 /* Variable */ +#define UA_NS0ID_TRANSITIONVARIABLETYPE_NAME 2764 /* Variable */ +#define UA_NS0ID_TRANSITIONVARIABLETYPE_NUMBER 2765 /* Variable */ +#define UA_NS0ID_TRANSITIONVARIABLETYPE_TRANSITIONTIME 2766 /* Variable */ +#define UA_NS0ID_FINITETRANSITIONVARIABLETYPE 2767 /* VariableType */ +#define UA_NS0ID_FINITETRANSITIONVARIABLETYPE_ID 2768 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_CURRENTSTATE 2769 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_LASTTRANSITION 2770 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE 2771 /* ObjectType */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_CURRENTSTATE 2772 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_LASTTRANSITION 2773 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TRANSITION 2774 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_FROMSTATE 2775 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TOSTATE 2776 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_OLDSTATEID 2777 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_NEWSTATEID 2778 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE 2782 /* ObjectType */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE 2787 /* ObjectType */ +#define UA_NS0ID_REFRESHENDEVENTTYPE 2788 /* ObjectType */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE 2789 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE 2790 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE 2803 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE 2829 /* ObjectType */ +#define UA_NS0ID_DIALOGCONDITIONTYPE 2830 /* ObjectType */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_PROMPT 2831 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE 2881 /* ObjectType */ +#define UA_NS0ID_ALARMCONDITIONTYPE 2915 /* ObjectType */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE 2929 /* ObjectType */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVED 2930 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVED 2932 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_ONESHOTSHELVED 2933 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVEDTOTIMEDSHELVED 2935 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVEDTOONESHOTSHELVED 2936 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVEDTOUNSHELVED 2940 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVEDTOONESHOTSHELVED 2942 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_ONESHOTSHELVEDTOUNSHELVED 2943 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_ONESHOTSHELVEDTOTIMEDSHELVED 2945 /* Object */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVE 2947 /* Method */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_ONESHOTSHELVE 2948 /* Method */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVE 2949 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE 2955 /* ObjectType */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVE_INPUTARGUMENTS 2991 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_SECONDSTILLSHUTDOWN 2992 /* Variable */ +#define UA_NS0ID_SERVER_SERVERSTATUS_SHUTDOWNREASON 2993 /* Variable */ +#define UA_NS0ID_SERVER_AUDITING 2994 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MODELLINGRULES 2996 /* Object */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_AGGREGATEFUNCTIONS 2997 /* Object */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_EVENTNOTIFICATIONSCOUNT 2998 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE 2999 /* ObjectType */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_FILTER 3003 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE 3006 /* ObjectType */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE 3012 /* ObjectType */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE 3014 /* ObjectType */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_ISDELETEMODIFIED 3015 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_STARTTIME 3016 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_ENDTIME 3017 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE 3019 /* ObjectType */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_REQTIMES 3020 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_OLDVALUES 3021 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE 3022 /* ObjectType */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_EVENTIDS 3023 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_OLDVALUES 3024 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_UPDATEDNODE 3025 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_UPDATEDNODE 3026 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_UPDATEDNODE 3027 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_PERFORMINSERTREPLACE 3028 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_NEWVALUES 3029 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_OLDVALUES 3030 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_PERFORMINSERTREPLACE 3031 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_NEWVALUES 3032 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_OLDVALUES 3033 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_OLDVALUES 3034 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE 3035 /* ObjectType */ +#define UA_NS0ID_EVENTTYPESFOLDER 3048 /* Object */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_SOFTWARECERTIFICATES 3049 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_MAXRESPONSEMESSAGESIZE 3050 /* Variable */ +#define UA_NS0ID_BUILDINFOTYPE 3051 /* VariableType */ +#define UA_NS0ID_BUILDINFOTYPE_PRODUCTURI 3052 /* Variable */ +#define UA_NS0ID_BUILDINFOTYPE_MANUFACTURERNAME 3053 /* Variable */ +#define UA_NS0ID_BUILDINFOTYPE_PRODUCTNAME 3054 /* Variable */ +#define UA_NS0ID_BUILDINFOTYPE_SOFTWAREVERSION 3055 /* Variable */ +#define UA_NS0ID_BUILDINFOTYPE_BUILDNUMBER 3056 /* Variable */ +#define UA_NS0ID_BUILDINFOTYPE_BUILDDATE 3057 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSTYPE_CLIENTCERTIFICATE 3058 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_AGGREGATECONFIGURATION 3059 /* Object */ +#define UA_NS0ID_DEFAULTBINARY 3062 /* Object */ +#define UA_NS0ID_DEFAULTXML 3063 /* Object */ +#define UA_NS0ID_ALWAYSGENERATESEVENT 3065 /* ReferenceType */ +#define UA_NS0ID_ICON 3067 /* Variable */ +#define UA_NS0ID_NODEVERSION 3068 /* Variable */ +#define UA_NS0ID_LOCALTIME 3069 /* Variable */ +#define UA_NS0ID_ALLOWNULLS 3070 /* Variable */ +#define UA_NS0ID_ENUMVALUES 3071 /* Variable */ +#define UA_NS0ID_INPUTARGUMENTS 3072 /* Variable */ +#define UA_NS0ID_OUTPUTARGUMENTS 3073 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_STARTTIME 3074 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_CURRENTTIME 3075 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_STATE 3076 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_BUILDINFO 3077 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_BUILDINFO_PRODUCTURI 3078 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_BUILDINFO_MANUFACTURERNAME 3079 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_BUILDINFO_PRODUCTNAME 3080 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_BUILDINFO_SOFTWAREVERSION 3081 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_BUILDINFO_BUILDNUMBER 3082 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_BUILDINFO_BUILDDATE 3083 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_SECONDSTILLSHUTDOWN 3084 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERSTATUS_SHUTDOWNREASON 3085 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_SERVERPROFILEARRAY 3086 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_LOCALEIDARRAY 3087 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MINSUPPORTEDSAMPLERATE 3088 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MAXBROWSECONTINUATIONPOINTS 3089 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MAXQUERYCONTINUATIONPOINTS 3090 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MAXHISTORYCONTINUATIONPOINTS 3091 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_SOFTWARECERTIFICATES 3092 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MODELLINGRULES 3093 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_AGGREGATEFUNCTIONS 3094 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY 3095 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SERVERVIEWCOUNT 3096 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CURRENTSESSIONCOUNT 3097 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CUMULATEDSESSIONCOUNT 3098 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SECURITYREJECTEDSESSIONCOUNT 3099 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_REJECTEDSESSIONCOUNT 3100 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SESSIONTIMEOUTCOUNT 3101 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SESSIONABORTCOUNT 3102 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_PUBLISHINGINTERVALCOUNT 3104 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CURRENTSUBSCRIPTIONCOUNT 3105 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_CUMULATEDSUBSCRIPTIONCOUNT 3106 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_SECURITYREJECTEDREQUESTSCOUNT 3107 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_REJECTEDREQUESTSCOUNT 3108 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SAMPLINGINTERVALDIAGNOSTICSARRAY 3109 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SUBSCRIPTIONDIAGNOSTICSARRAY 3110 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SESSIONSDIAGNOSTICSSUMMARY 3111 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SESSIONSDIAGNOSTICSSUMMARY_SESSIONDIAGNOSTICSARRAY 3112 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_SESSIONSDIAGNOSTICSSUMMARY_SESSIONSECURITYDIAGNOSTICSARRAY 3113 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERDIAGNOSTICS_ENABLEDFLAG 3114 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERREDUNDANCY_REDUNDANCYSUPPORT 3115 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_SERVERVIEWCOUNT 3116 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_CURRENTSESSIONCOUNT 3117 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_CUMULATEDSESSIONCOUNT 3118 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_SECURITYREJECTEDSESSIONCOUNT 3119 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_REJECTEDSESSIONCOUNT 3120 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_SESSIONTIMEOUTCOUNT 3121 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_SESSIONABORTCOUNT 3122 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_PUBLISHINGINTERVALCOUNT 3124 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_CURRENTSUBSCRIPTIONCOUNT 3125 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_CUMULATEDSUBSCRIPTIONCOUNT 3126 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_SECURITYREJECTEDREQUESTSCOUNT 3127 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SERVERDIAGNOSTICSSUMMARY_REJECTEDREQUESTSCOUNT 3128 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SESSIONSDIAGNOSTICSSUMMARY_SESSIONDIAGNOSTICSARRAY 3129 /* Variable */ +#define UA_NS0ID_SERVERDIAGNOSTICSTYPE_SESSIONSDIAGNOSTICSSUMMARY_SESSIONSECURITYDIAGNOSTICSARRAY 3130 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_SESSIONID 3131 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_SESSIONNAME 3132 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CLIENTDESCRIPTION 3133 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_SERVERURI 3134 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_ENDPOINTURL 3135 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_LOCALEIDS 3136 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_ACTUALSESSIONTIMEOUT 3137 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_MAXRESPONSEMESSAGESIZE 3138 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CLIENTCONNECTIONTIME 3139 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CLIENTLASTCONTACTTIME 3140 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CURRENTSUBSCRIPTIONSCOUNT 3141 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CURRENTMONITOREDITEMSCOUNT 3142 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CURRENTPUBLISHREQUESTSINQUEUE 3143 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_READCOUNT 3151 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_HISTORYREADCOUNT 3152 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_WRITECOUNT 3153 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_HISTORYUPDATECOUNT 3154 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CALLCOUNT 3155 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CREATEMONITOREDITEMSCOUNT 3156 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_MODIFYMONITOREDITEMSCOUNT 3157 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_SETMONITORINGMODECOUNT 3158 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_SETTRIGGERINGCOUNT 3159 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_DELETEMONITOREDITEMSCOUNT 3160 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_CREATESUBSCRIPTIONCOUNT 3161 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_MODIFYSUBSCRIPTIONCOUNT 3162 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_SETPUBLISHINGMODECOUNT 3163 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_PUBLISHCOUNT 3164 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_REPUBLISHCOUNT 3165 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_TRANSFERSUBSCRIPTIONSCOUNT 3166 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_DELETESUBSCRIPTIONSCOUNT 3167 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_ADDNODESCOUNT 3168 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_ADDREFERENCESCOUNT 3169 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_DELETENODESCOUNT 3170 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_DELETEREFERENCESCOUNT 3171 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_BROWSECOUNT 3172 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_BROWSENEXTCOUNT 3173 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_TRANSLATEBROWSEPATHSTONODEIDSCOUNT 3174 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_QUERYFIRSTCOUNT 3175 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_QUERYNEXTCOUNT 3176 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_REGISTERNODESCOUNT 3177 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_UNREGISTERNODESCOUNT 3178 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_SESSIONID 3179 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_CLIENTUSERIDOFSESSION 3180 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_CLIENTUSERIDHISTORY 3181 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_AUTHENTICATIONMECHANISM 3182 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_ENCODING 3183 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_TRANSPORTPROTOCOL 3184 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_SECURITYMODE 3185 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_SECURITYPOLICYURI 3186 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONSECURITYDIAGNOSTICS_CLIENTCERTIFICATE 3187 /* Variable */ +#define UA_NS0ID_TRANSPARENTREDUNDANCYTYPE_REDUNDANCYSUPPORT 3188 /* Variable */ +#define UA_NS0ID_NONTRANSPARENTREDUNDANCYTYPE_REDUNDANCYSUPPORT 3189 /* Variable */ +#define UA_NS0ID_BASEEVENTTYPE_LOCALTIME 3190 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_EVENTID 3191 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_EVENTTYPE 3192 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_SOURCENODE 3193 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_SOURCENAME 3194 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_TIME 3195 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_RECEIVETIME 3196 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_LOCALTIME 3197 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_MESSAGE 3198 /* Variable */ +#define UA_NS0ID_EVENTQUEUEOVERFLOWEVENTTYPE_SEVERITY 3199 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_EVENTID 3200 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_EVENTTYPE 3201 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_SOURCENODE 3202 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_SOURCENAME 3203 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_TIME 3204 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_RECEIVETIME 3205 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_LOCALTIME 3206 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_MESSAGE 3207 /* Variable */ +#define UA_NS0ID_AUDITEVENTTYPE_SEVERITY 3208 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_EVENTID 3209 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_EVENTTYPE 3210 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_SOURCENODE 3211 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_SOURCENAME 3212 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_TIME 3213 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_RECEIVETIME 3214 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_LOCALTIME 3215 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_MESSAGE 3216 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_SEVERITY 3217 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_ACTIONTIMESTAMP 3218 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_STATUS 3219 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_SERVERID 3220 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_CLIENTAUDITENTRYID 3221 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_CLIENTUSERID 3222 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_EVENTID 3223 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_EVENTTYPE 3224 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_SOURCENODE 3225 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_SOURCENAME 3226 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_TIME 3227 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_RECEIVETIME 3228 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_LOCALTIME 3229 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_MESSAGE 3230 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_SEVERITY 3231 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_ACTIONTIMESTAMP 3232 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_STATUS 3233 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_SERVERID 3234 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_CLIENTAUDITENTRYID 3235 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_CLIENTUSERID 3236 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_EVENTID 3237 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_EVENTTYPE 3238 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_SOURCENODE 3239 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_SOURCENAME 3240 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_TIME 3241 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_RECEIVETIME 3242 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_LOCALTIME 3243 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_MESSAGE 3244 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_SEVERITY 3245 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_ACTIONTIMESTAMP 3246 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_STATUS 3247 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_SERVERID 3248 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_CLIENTAUDITENTRYID 3249 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_CLIENTUSERID 3250 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_SECURECHANNELID 3251 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_EVENTID 3252 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_EVENTTYPE 3253 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_SOURCENODE 3254 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_SOURCENAME 3255 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_TIME 3256 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_RECEIVETIME 3257 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_LOCALTIME 3258 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_MESSAGE 3259 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_SEVERITY 3260 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_ACTIONTIMESTAMP 3261 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_STATUS 3262 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_SERVERID 3263 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_CLIENTAUDITENTRYID 3264 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_CLIENTUSERID 3265 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_EVENTID 3266 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_EVENTTYPE 3267 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_SOURCENODE 3268 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_SOURCENAME 3269 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_TIME 3270 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_RECEIVETIME 3271 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_LOCALTIME 3272 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_MESSAGE 3273 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_SEVERITY 3274 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_ACTIONTIMESTAMP 3275 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_STATUS 3276 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_SERVERID 3277 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_CLIENTAUDITENTRYID 3278 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_CLIENTUSERID 3279 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_EVENTID 3281 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_EVENTTYPE 3282 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_SOURCENODE 3283 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_SOURCENAME 3284 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_TIME 3285 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_RECEIVETIME 3286 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_LOCALTIME 3287 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_MESSAGE 3288 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_SEVERITY 3289 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_ACTIONTIMESTAMP 3290 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_STATUS 3291 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_SERVERID 3292 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_CLIENTAUDITENTRYID 3293 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_CLIENTUSERID 3294 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_SECURECHANNELID 3296 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_CLIENTCERTIFICATE 3297 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_CLIENTCERTIFICATETHUMBPRINT 3298 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_REVISEDSESSIONTIMEOUT 3299 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_EVENTID 3300 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_EVENTTYPE 3301 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_SOURCENODE 3302 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_SOURCENAME 3303 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_TIME 3304 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_RECEIVETIME 3305 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_LOCALTIME 3306 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_MESSAGE 3307 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_SEVERITY 3308 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_ACTIONTIMESTAMP 3309 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_STATUS 3310 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_SERVERID 3311 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_CLIENTAUDITENTRYID 3312 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_CLIENTUSERID 3313 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_SESSIONID 3314 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_EVENTID 3315 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_EVENTTYPE 3316 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_SOURCENODE 3317 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_SOURCENAME 3318 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_TIME 3319 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_RECEIVETIME 3320 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_LOCALTIME 3321 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_MESSAGE 3322 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_SEVERITY 3323 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_ACTIONTIMESTAMP 3324 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_STATUS 3325 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_SERVERID 3326 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_CLIENTAUDITENTRYID 3327 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_CLIENTUSERID 3328 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_SESSIONID 3329 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_EVENTID 3330 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_EVENTTYPE 3331 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_SOURCENODE 3332 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_SOURCENAME 3333 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_TIME 3334 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_RECEIVETIME 3335 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_LOCALTIME 3336 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_MESSAGE 3337 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_SEVERITY 3338 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_ACTIONTIMESTAMP 3339 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_STATUS 3340 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_SERVERID 3341 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_CLIENTAUDITENTRYID 3342 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_CLIENTUSERID 3343 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_EVENTID 3344 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_EVENTTYPE 3345 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_SOURCENODE 3346 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_SOURCENAME 3347 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_TIME 3348 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_RECEIVETIME 3349 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_LOCALTIME 3350 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_MESSAGE 3351 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_SEVERITY 3352 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_ACTIONTIMESTAMP 3353 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_STATUS 3354 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_SERVERID 3355 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_CLIENTAUDITENTRYID 3356 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_CLIENTUSERID 3357 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_CERTIFICATE 3358 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_EVENTID 3359 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_EVENTTYPE 3360 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_SOURCENODE 3361 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_SOURCENAME 3362 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_TIME 3363 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_RECEIVETIME 3364 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_LOCALTIME 3365 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_MESSAGE 3366 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_SEVERITY 3367 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_ACTIONTIMESTAMP 3368 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_STATUS 3369 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_SERVERID 3370 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_CLIENTAUDITENTRYID 3371 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_CLIENTUSERID 3372 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_CERTIFICATE 3373 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_EVENTID 3374 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_EVENTTYPE 3375 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_SOURCENODE 3376 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_SOURCENAME 3377 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_TIME 3378 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_RECEIVETIME 3379 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_LOCALTIME 3380 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_MESSAGE 3381 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_SEVERITY 3382 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_ACTIONTIMESTAMP 3383 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_STATUS 3384 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_SERVERID 3385 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_CLIENTAUDITENTRYID 3386 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_CLIENTUSERID 3387 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_CERTIFICATE 3388 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_EVENTID 3389 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_EVENTTYPE 3390 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_SOURCENODE 3391 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_SOURCENAME 3392 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_TIME 3393 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_RECEIVETIME 3394 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_LOCALTIME 3395 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_MESSAGE 3396 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_SEVERITY 3397 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_ACTIONTIMESTAMP 3398 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_STATUS 3399 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_SERVERID 3400 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_CLIENTAUDITENTRYID 3401 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_CLIENTUSERID 3402 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_CERTIFICATE 3403 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_EVENTID 3404 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_EVENTTYPE 3405 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_SOURCENODE 3406 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_SOURCENAME 3407 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_TIME 3408 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_RECEIVETIME 3409 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_LOCALTIME 3410 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_MESSAGE 3411 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_SEVERITY 3412 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_ACTIONTIMESTAMP 3413 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_STATUS 3414 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_SERVERID 3415 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_CLIENTAUDITENTRYID 3416 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_CLIENTUSERID 3417 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_CERTIFICATE 3418 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_EVENTID 3419 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_EVENTTYPE 3420 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_SOURCENODE 3421 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_SOURCENAME 3422 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_TIME 3423 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_RECEIVETIME 3424 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_LOCALTIME 3425 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_MESSAGE 3426 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_SEVERITY 3427 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_ACTIONTIMESTAMP 3428 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_STATUS 3429 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_SERVERID 3430 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_CLIENTAUDITENTRYID 3431 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_CLIENTUSERID 3432 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_CERTIFICATE 3433 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_EVENTID 3434 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_EVENTTYPE 3435 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_SOURCENODE 3436 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_SOURCENAME 3437 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_TIME 3438 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_RECEIVETIME 3439 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_LOCALTIME 3440 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_MESSAGE 3441 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_SEVERITY 3442 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_ACTIONTIMESTAMP 3443 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_STATUS 3444 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_SERVERID 3445 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_CLIENTAUDITENTRYID 3446 /* Variable */ +#define UA_NS0ID_AUDITNODEMANAGEMENTEVENTTYPE_CLIENTUSERID 3447 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_EVENTID 3448 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_EVENTTYPE 3449 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_SOURCENODE 3450 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_SOURCENAME 3451 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_TIME 3452 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_RECEIVETIME 3453 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_LOCALTIME 3454 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_MESSAGE 3455 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_SEVERITY 3456 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_ACTIONTIMESTAMP 3457 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_STATUS 3458 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_SERVERID 3459 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_CLIENTAUDITENTRYID 3460 /* Variable */ +#define UA_NS0ID_AUDITADDNODESEVENTTYPE_CLIENTUSERID 3461 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_EVENTID 3462 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_EVENTTYPE 3463 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_SOURCENODE 3464 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_SOURCENAME 3465 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_TIME 3466 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_RECEIVETIME 3467 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_LOCALTIME 3468 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_MESSAGE 3469 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_SEVERITY 3470 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_ACTIONTIMESTAMP 3471 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_STATUS 3472 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_SERVERID 3473 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_CLIENTAUDITENTRYID 3474 /* Variable */ +#define UA_NS0ID_AUDITDELETENODESEVENTTYPE_CLIENTUSERID 3475 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_EVENTID 3476 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_EVENTTYPE 3477 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_SOURCENODE 3478 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_SOURCENAME 3479 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_TIME 3480 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_RECEIVETIME 3481 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_LOCALTIME 3482 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_MESSAGE 3483 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_SEVERITY 3484 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_ACTIONTIMESTAMP 3485 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_STATUS 3486 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_SERVERID 3487 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_CLIENTAUDITENTRYID 3488 /* Variable */ +#define UA_NS0ID_AUDITADDREFERENCESEVENTTYPE_CLIENTUSERID 3489 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_EVENTID 3490 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_EVENTTYPE 3491 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_SOURCENODE 3492 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_SOURCENAME 3493 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_TIME 3494 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_RECEIVETIME 3495 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_LOCALTIME 3496 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_MESSAGE 3497 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_SEVERITY 3498 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_ACTIONTIMESTAMP 3499 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_STATUS 3500 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_SERVERID 3501 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_CLIENTAUDITENTRYID 3502 /* Variable */ +#define UA_NS0ID_AUDITDELETEREFERENCESEVENTTYPE_CLIENTUSERID 3503 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_EVENTID 3504 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_EVENTTYPE 3505 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_SOURCENODE 3506 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_SOURCENAME 3507 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_TIME 3508 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_RECEIVETIME 3509 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_LOCALTIME 3510 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_MESSAGE 3511 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_SEVERITY 3512 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_ACTIONTIMESTAMP 3513 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_STATUS 3514 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_SERVERID 3515 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_CLIENTAUDITENTRYID 3516 /* Variable */ +#define UA_NS0ID_AUDITUPDATEEVENTTYPE_CLIENTUSERID 3517 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_EVENTID 3518 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_EVENTTYPE 3519 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_SOURCENODE 3520 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_SOURCENAME 3521 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_TIME 3522 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_RECEIVETIME 3523 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_LOCALTIME 3524 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_MESSAGE 3525 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_SEVERITY 3526 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_ACTIONTIMESTAMP 3527 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_STATUS 3528 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_SERVERID 3529 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_CLIENTAUDITENTRYID 3530 /* Variable */ +#define UA_NS0ID_AUDITWRITEUPDATEEVENTTYPE_CLIENTUSERID 3531 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_EVENTID 3532 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_EVENTTYPE 3533 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_SOURCENODE 3534 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_SOURCENAME 3535 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_TIME 3536 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_RECEIVETIME 3537 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_LOCALTIME 3538 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_MESSAGE 3539 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_SEVERITY 3540 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_ACTIONTIMESTAMP 3541 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_STATUS 3542 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_SERVERID 3543 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_CLIENTAUDITENTRYID 3544 /* Variable */ +#define UA_NS0ID_AUDITHISTORYUPDATEEVENTTYPE_CLIENTUSERID 3545 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_EVENTID 3546 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_EVENTTYPE 3547 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_SOURCENODE 3548 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_SOURCENAME 3549 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_TIME 3550 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_RECEIVETIME 3551 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_LOCALTIME 3552 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_MESSAGE 3553 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_SEVERITY 3554 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_ACTIONTIMESTAMP 3555 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_STATUS 3556 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_SERVERID 3557 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_CLIENTAUDITENTRYID 3558 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_CLIENTUSERID 3559 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTUPDATEEVENTTYPE_PARAMETERDATATYPEID 3560 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_EVENTID 3561 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_EVENTTYPE 3562 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_SOURCENODE 3563 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_SOURCENAME 3564 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_TIME 3565 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_RECEIVETIME 3566 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_LOCALTIME 3567 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_MESSAGE 3568 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_SEVERITY 3569 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_ACTIONTIMESTAMP 3570 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_STATUS 3571 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_SERVERID 3572 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_CLIENTAUDITENTRYID 3573 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_CLIENTUSERID 3574 /* Variable */ +#define UA_NS0ID_AUDITHISTORYVALUEUPDATEEVENTTYPE_PARAMETERDATATYPEID 3575 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_EVENTID 3576 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_EVENTTYPE 3577 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_SOURCENODE 3578 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_SOURCENAME 3579 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_TIME 3580 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_RECEIVETIME 3581 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_LOCALTIME 3582 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_MESSAGE 3583 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_SEVERITY 3584 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_ACTIONTIMESTAMP 3585 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_STATUS 3586 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_SERVERID 3587 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_CLIENTAUDITENTRYID 3588 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_CLIENTUSERID 3589 /* Variable */ +#define UA_NS0ID_AUDITHISTORYDELETEEVENTTYPE_PARAMETERDATATYPEID 3590 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_EVENTID 3591 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_EVENTTYPE 3592 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_SOURCENODE 3593 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_SOURCENAME 3594 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_TIME 3595 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_RECEIVETIME 3596 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_LOCALTIME 3597 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_MESSAGE 3598 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_SEVERITY 3599 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_ACTIONTIMESTAMP 3600 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_STATUS 3601 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_SERVERID 3602 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_CLIENTAUDITENTRYID 3603 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_CLIENTUSERID 3604 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_PARAMETERDATATYPEID 3605 /* Variable */ +#define UA_NS0ID_AUDITHISTORYRAWMODIFYDELETEEVENTTYPE_UPDATEDNODE 3606 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_EVENTID 3607 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_EVENTTYPE 3608 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_SOURCENODE 3609 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_SOURCENAME 3610 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_TIME 3611 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_RECEIVETIME 3612 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_LOCALTIME 3613 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_MESSAGE 3614 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_SEVERITY 3615 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_ACTIONTIMESTAMP 3616 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_STATUS 3617 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_SERVERID 3618 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_CLIENTAUDITENTRYID 3619 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_CLIENTUSERID 3620 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_PARAMETERDATATYPEID 3621 /* Variable */ +#define UA_NS0ID_AUDITHISTORYATTIMEDELETEEVENTTYPE_UPDATEDNODE 3622 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_EVENTID 3623 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_EVENTTYPE 3624 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_SOURCENODE 3625 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_SOURCENAME 3626 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_TIME 3627 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_RECEIVETIME 3628 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_LOCALTIME 3629 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_MESSAGE 3630 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_SEVERITY 3631 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_ACTIONTIMESTAMP 3632 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_STATUS 3633 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_SERVERID 3634 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_CLIENTAUDITENTRYID 3635 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_CLIENTUSERID 3636 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_PARAMETERDATATYPEID 3637 /* Variable */ +#define UA_NS0ID_AUDITHISTORYEVENTDELETEEVENTTYPE_UPDATEDNODE 3638 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_EVENTID 3639 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_EVENTTYPE 3640 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_SOURCENODE 3641 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_SOURCENAME 3642 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_TIME 3643 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_RECEIVETIME 3644 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_LOCALTIME 3645 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_MESSAGE 3646 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_SEVERITY 3647 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_ACTIONTIMESTAMP 3648 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_STATUS 3649 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_SERVERID 3650 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_CLIENTAUDITENTRYID 3651 /* Variable */ +#define UA_NS0ID_AUDITUPDATEMETHODEVENTTYPE_CLIENTUSERID 3652 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_EVENTID 3653 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_EVENTTYPE 3654 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_SOURCENODE 3655 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_SOURCENAME 3656 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_TIME 3657 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_RECEIVETIME 3658 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_LOCALTIME 3659 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_MESSAGE 3660 /* Variable */ +#define UA_NS0ID_SYSTEMEVENTTYPE_SEVERITY 3661 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_EVENTID 3662 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_EVENTTYPE 3663 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_SOURCENODE 3664 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_SOURCENAME 3665 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_TIME 3666 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_RECEIVETIME 3667 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_LOCALTIME 3668 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_MESSAGE 3669 /* Variable */ +#define UA_NS0ID_DEVICEFAILUREEVENTTYPE_SEVERITY 3670 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_EVENTID 3671 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_EVENTTYPE 3672 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_SOURCENODE 3673 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_SOURCENAME 3674 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_TIME 3675 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_RECEIVETIME 3676 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_LOCALTIME 3677 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_MESSAGE 3678 /* Variable */ +#define UA_NS0ID_BASEMODELCHANGEEVENTTYPE_SEVERITY 3679 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_EVENTID 3680 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_EVENTTYPE 3681 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_SOURCENODE 3682 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_SOURCENAME 3683 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_TIME 3684 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_RECEIVETIME 3685 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_LOCALTIME 3686 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_MESSAGE 3687 /* Variable */ +#define UA_NS0ID_GENERALMODELCHANGEEVENTTYPE_SEVERITY 3688 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_EVENTID 3689 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_EVENTTYPE 3690 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_SOURCENODE 3691 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_SOURCENAME 3692 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_TIME 3693 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_RECEIVETIME 3694 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_LOCALTIME 3695 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_MESSAGE 3696 /* Variable */ +#define UA_NS0ID_SEMANTICCHANGEEVENTTYPE_SEVERITY 3697 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_BUILDINFO_PRODUCTURI 3698 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_BUILDINFO_MANUFACTURERNAME 3699 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_BUILDINFO_PRODUCTNAME 3700 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_BUILDINFO_SOFTWAREVERSION 3701 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_BUILDINFO_BUILDNUMBER 3702 /* Variable */ +#define UA_NS0ID_SERVERSTATUSTYPE_BUILDINFO_BUILDDATE 3703 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_SOFTWARECERTIFICATES 3704 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SERVERDIAGNOSTICSSUMMARY_REJECTEDSESSIONCOUNT 3705 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SESSIONSDIAGNOSTICSSUMMARY 3706 /* Object */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SESSIONSDIAGNOSTICSSUMMARY_SESSIONDIAGNOSTICSARRAY 3707 /* Variable */ +#define UA_NS0ID_SERVER_SERVERDIAGNOSTICS_SESSIONSDIAGNOSTICSSUMMARY_SESSIONSECURITYDIAGNOSTICSARRAY 3708 /* Variable */ +#define UA_NS0ID_SERVER_SERVERREDUNDANCY_REDUNDANCYSUPPORT 3709 /* Variable */ +#define UA_NS0ID_FINITESTATEVARIABLETYPE_NAME 3714 /* Variable */ +#define UA_NS0ID_FINITESTATEVARIABLETYPE_NUMBER 3715 /* Variable */ +#define UA_NS0ID_FINITESTATEVARIABLETYPE_EFFECTIVEDISPLAYNAME 3716 /* Variable */ +#define UA_NS0ID_FINITETRANSITIONVARIABLETYPE_NAME 3717 /* Variable */ +#define UA_NS0ID_FINITETRANSITIONVARIABLETYPE_NUMBER 3718 /* Variable */ +#define UA_NS0ID_FINITETRANSITIONVARIABLETYPE_TRANSITIONTIME 3719 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_CURRENTSTATE_ID 3720 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_CURRENTSTATE_NAME 3721 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_CURRENTSTATE_NUMBER 3722 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 3723 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_LASTTRANSITION_ID 3724 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_LASTTRANSITION_NAME 3725 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_LASTTRANSITION_NUMBER 3726 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_LASTTRANSITION_TRANSITIONTIME 3727 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_CURRENTSTATE_ID 3728 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_CURRENTSTATE_NAME 3729 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_CURRENTSTATE_NUMBER 3730 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 3731 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_LASTTRANSITION_ID 3732 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_LASTTRANSITION_NAME 3733 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_LASTTRANSITION_NUMBER 3734 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_LASTTRANSITION_TRANSITIONTIME 3735 /* Variable */ +#define UA_NS0ID_INITIALSTATETYPE_STATENUMBER 3736 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_EVENTID 3737 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_EVENTTYPE 3738 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_SOURCENODE 3739 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_SOURCENAME 3740 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TIME 3741 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_RECEIVETIME 3742 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_LOCALTIME 3743 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_MESSAGE 3744 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_SEVERITY 3745 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_FROMSTATE_ID 3746 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_FROMSTATE_NAME 3747 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_FROMSTATE_NUMBER 3748 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_FROMSTATE_EFFECTIVEDISPLAYNAME 3749 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TOSTATE_ID 3750 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TOSTATE_NAME 3751 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TOSTATE_NUMBER 3752 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TOSTATE_EFFECTIVEDISPLAYNAME 3753 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TRANSITION_ID 3754 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TRANSITION_NAME 3755 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TRANSITION_NUMBER 3756 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TRANSITION_TRANSITIONTIME 3757 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_EVENTID 3758 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_EVENTTYPE 3759 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_SOURCENODE 3760 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_SOURCENAME 3761 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_TIME 3762 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_RECEIVETIME 3763 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_LOCALTIME 3764 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_MESSAGE 3765 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_SEVERITY 3766 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_ACTIONTIMESTAMP 3767 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_STATUS 3768 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_SERVERID 3769 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_CLIENTAUDITENTRYID 3770 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_CLIENTUSERID 3771 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_METHODID 3772 /* Variable */ +#define UA_NS0ID_AUDITUPDATESTATEEVENTTYPE_INPUTARGUMENTS 3773 /* Variable */ +#define UA_NS0ID_ANALOGITEMTYPE_DEFINITION 3774 /* Variable */ +#define UA_NS0ID_ANALOGITEMTYPE_VALUEPRECISION 3775 /* Variable */ +#define UA_NS0ID_DISCRETEITEMTYPE_DEFINITION 3776 /* Variable */ +#define UA_NS0ID_DISCRETEITEMTYPE_VALUEPRECISION 3777 /* Variable */ +#define UA_NS0ID_TWOSTATEDISCRETETYPE_DEFINITION 3778 /* Variable */ +#define UA_NS0ID_TWOSTATEDISCRETETYPE_VALUEPRECISION 3779 /* Variable */ +#define UA_NS0ID_MULTISTATEDISCRETETYPE_DEFINITION 3780 /* Variable */ +#define UA_NS0ID_MULTISTATEDISCRETETYPE_VALUEPRECISION 3781 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_EVENTID 3782 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_EVENTTYPE 3783 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_SOURCENODE 3784 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_SOURCENAME 3785 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TIME 3786 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_RECEIVETIME 3787 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_LOCALTIME 3788 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_MESSAGE 3789 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_SEVERITY 3790 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_FROMSTATE 3791 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_FROMSTATE_ID 3792 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_FROMSTATE_NAME 3793 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_FROMSTATE_NUMBER 3794 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_FROMSTATE_EFFECTIVEDISPLAYNAME 3795 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TOSTATE 3796 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TOSTATE_ID 3797 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TOSTATE_NAME 3798 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TOSTATE_NUMBER 3799 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TOSTATE_EFFECTIVEDISPLAYNAME 3800 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TRANSITION 3801 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TRANSITION_ID 3802 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TRANSITION_NAME 3803 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TRANSITION_NUMBER 3804 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TRANSITION_TRANSITIONTIME 3805 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE 3806 /* ObjectType */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_EVENTID 3807 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_EVENTTYPE 3808 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_SOURCENODE 3809 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_SOURCENAME 3810 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_TIME 3811 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_RECEIVETIME 3812 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_LOCALTIME 3813 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_MESSAGE 3814 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_SEVERITY 3815 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_ACTIONTIMESTAMP 3816 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_STATUS 3817 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_SERVERID 3818 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_CLIENTAUDITENTRYID 3819 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_CLIENTUSERID 3820 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_METHODID 3821 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_INPUTARGUMENTS 3822 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_OLDSTATEID 3823 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_NEWSTATEID 3824 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_TRANSITION 3825 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_TRANSITION_ID 3826 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_TRANSITION_NAME 3827 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_TRANSITION_NUMBER 3828 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_TRANSITION_TRANSITIONTIME 3829 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_CURRENTSTATE 3830 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_CURRENTSTATE_ID 3831 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_CURRENTSTATE_NAME 3832 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_CURRENTSTATE_NUMBER 3833 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 3834 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_LASTTRANSITION 3835 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_LASTTRANSITION_ID 3836 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_LASTTRANSITION_NAME 3837 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_LASTTRANSITION_NUMBER 3838 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_LASTTRANSITION_TRANSITIONTIME 3839 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_CREATESESSIONID 3840 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_CREATECLIENTNAME 3841 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_INVOCATIONCREATIONTIME 3842 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTTRANSITIONTIME 3843 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODCALL 3844 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODSESSIONID 3845 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODINPUTARGUMENTS 3846 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODOUTPUTARGUMENTS 3847 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODCALLTIME 3848 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODRETURNSTATUS 3849 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_FINALRESULTDATA 3850 /* Object */ +#define UA_NS0ID_ADDCOMMENTMETHODTYPE 3863 /* Method */ +#define UA_NS0ID_ADDCOMMENTMETHODTYPE_INPUTARGUMENTS 3864 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_EVENTID 3865 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_EVENTTYPE 3866 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_SOURCENODE 3867 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_SOURCENAME 3868 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_TIME 3869 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_RECEIVETIME 3870 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_LOCALTIME 3871 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_MESSAGE 3872 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_SEVERITY 3873 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_RETAIN 3874 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONREFRESH 3875 /* Method */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONREFRESH_INPUTARGUMENTS 3876 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_EVENTID 3969 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_EVENTTYPE 3970 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_SOURCENODE 3971 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_SOURCENAME 3972 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_TIME 3973 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_RECEIVETIME 3974 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_LOCALTIME 3975 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_MESSAGE 3976 /* Variable */ +#define UA_NS0ID_REFRESHSTARTEVENTTYPE_SEVERITY 3977 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_EVENTID 3978 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_EVENTTYPE 3979 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_SOURCENODE 3980 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_SOURCENAME 3981 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_TIME 3982 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_RECEIVETIME 3983 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_LOCALTIME 3984 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_MESSAGE 3985 /* Variable */ +#define UA_NS0ID_REFRESHENDEVENTTYPE_SEVERITY 3986 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_EVENTID 3987 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_EVENTTYPE 3988 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_SOURCENODE 3989 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_SOURCENAME 3990 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_TIME 3991 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_RECEIVETIME 3992 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_LOCALTIME 3993 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_MESSAGE 3994 /* Variable */ +#define UA_NS0ID_REFRESHREQUIREDEVENTTYPE_SEVERITY 3995 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_EVENTID 3996 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_EVENTTYPE 3997 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_SOURCENODE 3998 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_SOURCENAME 3999 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_TIME 4000 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_RECEIVETIME 4001 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_LOCALTIME 4002 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_MESSAGE 4003 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_SEVERITY 4004 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_ACTIONTIMESTAMP 4005 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_STATUS 4006 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_SERVERID 4007 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_CLIENTAUDITENTRYID 4008 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_CLIENTUSERID 4009 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_METHODID 4010 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONEVENTTYPE_INPUTARGUMENTS 4011 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_EVENTID 4106 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_EVENTTYPE 4107 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_SOURCENODE 4108 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_SOURCENAME 4109 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_TIME 4110 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_RECEIVETIME 4111 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_LOCALTIME 4112 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_MESSAGE 4113 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_SEVERITY 4114 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_ACTIONTIMESTAMP 4115 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_STATUS 4116 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_SERVERID 4117 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_CLIENTAUDITENTRYID 4118 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_CLIENTUSERID 4119 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_METHODID 4120 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONENABLEEVENTTYPE_INPUTARGUMENTS 4121 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_EVENTID 4170 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_EVENTTYPE 4171 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_SOURCENODE 4172 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_SOURCENAME 4173 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_TIME 4174 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_RECEIVETIME 4175 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_LOCALTIME 4176 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_MESSAGE 4177 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_SEVERITY 4178 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_ACTIONTIMESTAMP 4179 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_STATUS 4180 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_SERVERID 4181 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_CLIENTAUDITENTRYID 4182 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_CLIENTUSERID 4183 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_METHODID 4184 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_INPUTARGUMENTS 4185 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_EVENTID 4188 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_EVENTTYPE 4189 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_SOURCENODE 4190 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_SOURCENAME 4191 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_TIME 4192 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_RECEIVETIME 4193 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_LOCALTIME 4194 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_MESSAGE 4195 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_SEVERITY 4196 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_RETAIN 4197 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONREFRESH 4198 /* Method */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONREFRESH_INPUTARGUMENTS 4199 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_EVENTID 5113 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_EVENTTYPE 5114 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_SOURCENODE 5115 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_SOURCENAME 5116 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_TIME 5117 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_RECEIVETIME 5118 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_LOCALTIME 5119 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_MESSAGE 5120 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_SEVERITY 5121 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_RETAIN 5122 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONREFRESH 5123 /* Method */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONREFRESH_INPUTARGUMENTS 5124 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_EVENTID 5540 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_EVENTTYPE 5541 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SOURCENODE 5542 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SOURCENAME 5543 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_TIME 5544 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_RECEIVETIME 5545 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LOCALTIME 5546 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_MESSAGE 5547 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SEVERITY 5548 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_RETAIN 5549 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONREFRESH 5550 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONREFRESH_INPUTARGUMENTS 5551 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_CURRENTSTATE 6088 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_CURRENTSTATE_ID 6089 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_CURRENTSTATE_NAME 6090 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_CURRENTSTATE_NUMBER 6091 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 6092 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_LASTTRANSITION 6093 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_LASTTRANSITION_ID 6094 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_LASTTRANSITION_NAME 6095 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_LASTTRANSITION_NUMBER 6096 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_LASTTRANSITION_TRANSITIONTIME 6097 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVED_STATENUMBER 6098 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVED_STATENUMBER 6100 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_ONESHOTSHELVED_STATENUMBER 6101 /* Variable */ +#define UA_NS0ID_TIMEDSHELVEMETHODTYPE 6102 /* Method */ +#define UA_NS0ID_TIMEDSHELVEMETHODTYPE_INPUTARGUMENTS 6103 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_EVENTID 6116 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_EVENTTYPE 6117 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SOURCENODE 6118 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SOURCENAME 6119 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_TIME 6120 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_RECEIVETIME 6121 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LOCALTIME 6122 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_MESSAGE 6123 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SEVERITY 6124 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_RETAIN 6125 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONREFRESH 6126 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 6127 /* Variable */ +#define UA_NS0ID_IDTYPE_ENUMSTRINGS 7591 /* Variable */ +#define UA_NS0ID_ENUMVALUETYPE 7594 /* DataType */ +#define UA_NS0ID_MESSAGESECURITYMODE_ENUMSTRINGS 7595 /* Variable */ +#define UA_NS0ID_USERTOKENTYPE_ENUMSTRINGS 7596 /* Variable */ +#define UA_NS0ID_APPLICATIONTYPE_ENUMSTRINGS 7597 /* Variable */ +#define UA_NS0ID_SECURITYTOKENREQUESTTYPE_ENUMSTRINGS 7598 /* Variable */ +#define UA_NS0ID_BROWSEDIRECTION_ENUMSTRINGS 7603 /* Variable */ +#define UA_NS0ID_FILTEROPERATOR_ENUMSTRINGS 7605 /* Variable */ +#define UA_NS0ID_TIMESTAMPSTORETURN_ENUMSTRINGS 7606 /* Variable */ +#define UA_NS0ID_MONITORINGMODE_ENUMSTRINGS 7608 /* Variable */ +#define UA_NS0ID_DATACHANGETRIGGER_ENUMSTRINGS 7609 /* Variable */ +#define UA_NS0ID_DEADBANDTYPE_ENUMSTRINGS 7610 /* Variable */ +#define UA_NS0ID_REDUNDANCYSUPPORT_ENUMSTRINGS 7611 /* Variable */ +#define UA_NS0ID_SERVERSTATE_ENUMSTRINGS 7612 /* Variable */ +#define UA_NS0ID_EXCEPTIONDEVIATIONFORMAT_ENUMSTRINGS 7614 /* Variable */ +#define UA_NS0ID_ENUMVALUETYPE_ENCODING_DEFAULTXML 7616 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA 7617 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPEVERSION 7618 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NAMESPACEURI 7619 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ARGUMENT 7650 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ARGUMENT_DATATYPEVERSION 7651 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ARGUMENT_DICTIONARYFRAGMENT 7652 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMVALUETYPE 7656 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMVALUETYPE_DATATYPEVERSION 7657 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMVALUETYPE_DICTIONARYFRAGMENT 7658 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STATUSRESULT 7659 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STATUSRESULT_DATATYPEVERSION 7660 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STATUSRESULT_DICTIONARYFRAGMENT 7661 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERTOKENPOLICY 7662 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERTOKENPOLICY_DATATYPEVERSION 7663 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERTOKENPOLICY_DICTIONARYFRAGMENT 7664 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_APPLICATIONDESCRIPTION 7665 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_APPLICATIONDESCRIPTION_DATATYPEVERSION 7666 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_APPLICATIONDESCRIPTION_DICTIONARYFRAGMENT 7667 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTDESCRIPTION 7668 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTDESCRIPTION_DATATYPEVERSION 7669 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTDESCRIPTION_DICTIONARYFRAGMENT 7670 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERIDENTITYTOKEN 7671 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERIDENTITYTOKEN_DATATYPEVERSION 7672 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERIDENTITYTOKEN_DICTIONARYFRAGMENT 7673 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ANONYMOUSIDENTITYTOKEN 7674 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ANONYMOUSIDENTITYTOKEN_DATATYPEVERSION 7675 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ANONYMOUSIDENTITYTOKEN_DICTIONARYFRAGMENT 7676 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERNAMEIDENTITYTOKEN 7677 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERNAMEIDENTITYTOKEN_DATATYPEVERSION 7678 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_USERNAMEIDENTITYTOKEN_DICTIONARYFRAGMENT 7679 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_X509IDENTITYTOKEN 7680 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_X509IDENTITYTOKEN_DATATYPEVERSION 7681 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_X509IDENTITYTOKEN_DICTIONARYFRAGMENT 7682 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ISSUEDIDENTITYTOKEN 7683 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ISSUEDIDENTITYTOKEN_DATATYPEVERSION 7684 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ISSUEDIDENTITYTOKEN_DICTIONARYFRAGMENT 7685 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTCONFIGURATION 7686 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTCONFIGURATION_DATATYPEVERSION 7687 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTCONFIGURATION_DICTIONARYFRAGMENT 7688 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BUILDINFO 7692 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BUILDINFO_DATATYPEVERSION 7693 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BUILDINFO_DICTIONARYFRAGMENT 7694 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIGNEDSOFTWARECERTIFICATE 7698 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIGNEDSOFTWARECERTIFICATE_DATATYPEVERSION 7699 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIGNEDSOFTWARECERTIFICATE_DICTIONARYFRAGMENT 7700 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDNODESITEM 7728 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDNODESITEM_DATATYPEVERSION 7729 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDNODESITEM_DICTIONARYFRAGMENT 7730 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDREFERENCESITEM 7731 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDREFERENCESITEM_DATATYPEVERSION 7732 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDREFERENCESITEM_DICTIONARYFRAGMENT 7733 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DELETENODESITEM 7734 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DELETENODESITEM_DATATYPEVERSION 7735 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DELETENODESITEM_DICTIONARYFRAGMENT 7736 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DELETEREFERENCESITEM 7737 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DELETEREFERENCESITEM_DATATYPEVERSION 7738 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DELETEREFERENCESITEM_DICTIONARYFRAGMENT 7739 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_REGISTEREDSERVER 7782 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_REGISTEREDSERVER_DATATYPEVERSION 7783 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_REGISTEREDSERVER_DICTIONARYFRAGMENT 7784 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONTENTFILTERELEMENT 7929 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONTENTFILTERELEMENT_DATATYPEVERSION 7930 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONTENTFILTERELEMENT_DICTIONARYFRAGMENT 7931 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONTENTFILTER 7932 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONTENTFILTER_DATATYPEVERSION 7933 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONTENTFILTER_DICTIONARYFRAGMENT 7934 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FILTEROPERAND 7935 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FILTEROPERAND_DATATYPEVERSION 7936 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FILTEROPERAND_DICTIONARYFRAGMENT 7937 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ELEMENTOPERAND 7938 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ELEMENTOPERAND_DATATYPEVERSION 7939 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ELEMENTOPERAND_DICTIONARYFRAGMENT 7940 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_LITERALOPERAND 7941 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_LITERALOPERAND_DATATYPEVERSION 7942 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_LITERALOPERAND_DICTIONARYFRAGMENT 7943 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ATTRIBUTEOPERAND 7944 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ATTRIBUTEOPERAND_DATATYPEVERSION 7945 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ATTRIBUTEOPERAND_DICTIONARYFRAGMENT 7946 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIMPLEATTRIBUTEOPERAND 7947 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIMPLEATTRIBUTEOPERAND_DATATYPEVERSION 7948 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIMPLEATTRIBUTEOPERAND_DICTIONARYFRAGMENT 7949 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_HISTORYEVENT 8004 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_HISTORYEVENT_DATATYPEVERSION 8005 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_HISTORYEVENT_DICTIONARYFRAGMENT 8006 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MONITORINGFILTER 8067 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MONITORINGFILTER_DATATYPEVERSION 8068 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MONITORINGFILTER_DICTIONARYFRAGMENT 8069 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EVENTFILTER 8073 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EVENTFILTER_DATATYPEVERSION 8074 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EVENTFILTER_DICTIONARYFRAGMENT 8075 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_AGGREGATECONFIGURATION 8076 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_AGGREGATECONFIGURATION_DATATYPEVERSION 8077 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_AGGREGATECONFIGURATION_DICTIONARYFRAGMENT 8078 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_HISTORYEVENTFIELDLIST 8172 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_HISTORYEVENTFIELDLIST_DATATYPEVERSION 8173 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_HISTORYEVENTFIELDLIST_DICTIONARYFRAGMENT 8174 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_REDUNDANTSERVERDATATYPE 8208 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_REDUNDANTSERVERDATATYPE_DATATYPEVERSION 8209 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_REDUNDANTSERVERDATATYPE_DICTIONARYFRAGMENT 8210 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SAMPLINGINTERVALDIAGNOSTICSDATATYPE 8211 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SAMPLINGINTERVALDIAGNOSTICSDATATYPE_DATATYPEVERSION 8212 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SAMPLINGINTERVALDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8213 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERDIAGNOSTICSSUMMARYDATATYPE 8214 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERDIAGNOSTICSSUMMARYDATATYPE_DATATYPEVERSION 8215 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERDIAGNOSTICSSUMMARYDATATYPE_DICTIONARYFRAGMENT 8216 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERSTATUSDATATYPE 8217 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERSTATUSDATATYPE_DATATYPEVERSION 8218 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERSTATUSDATATYPE_DICTIONARYFRAGMENT 8219 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SESSIONDIAGNOSTICSDATATYPE 8220 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SESSIONDIAGNOSTICSDATATYPE_DATATYPEVERSION 8221 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SESSIONDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8222 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SESSIONSECURITYDIAGNOSTICSDATATYPE 8223 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SESSIONSECURITYDIAGNOSTICSDATATYPE_DATATYPEVERSION 8224 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SESSIONSECURITYDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8225 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVICECOUNTERDATATYPE 8226 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVICECOUNTERDATATYPE_DATATYPEVERSION 8227 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVICECOUNTERDATATYPE_DICTIONARYFRAGMENT 8228 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIPTIONDIAGNOSTICSDATATYPE 8229 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIPTIONDIAGNOSTICSDATATYPE_DATATYPEVERSION 8230 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIPTIONDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8231 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MODELCHANGESTRUCTUREDATATYPE 8232 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MODELCHANGESTRUCTUREDATATYPE_DATATYPEVERSION 8233 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MODELCHANGESTRUCTUREDATATYPE_DICTIONARYFRAGMENT 8234 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SEMANTICCHANGESTRUCTUREDATATYPE 8235 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SEMANTICCHANGESTRUCTUREDATATYPE_DATATYPEVERSION 8236 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SEMANTICCHANGESTRUCTUREDATATYPE_DICTIONARYFRAGMENT 8237 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RANGE 8238 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RANGE_DATATYPEVERSION 8239 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RANGE_DICTIONARYFRAGMENT 8240 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EUINFORMATION 8241 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EUINFORMATION_DATATYPEVERSION 8242 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EUINFORMATION_DICTIONARYFRAGMENT 8243 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ANNOTATION 8244 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ANNOTATION_DATATYPEVERSION 8245 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ANNOTATION_DICTIONARYFRAGMENT 8246 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PROGRAMDIAGNOSTICDATATYPE 8247 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PROGRAMDIAGNOSTICDATATYPE_DATATYPEVERSION 8248 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PROGRAMDIAGNOSTICDATATYPE_DICTIONARYFRAGMENT 8249 /* Variable */ +#define UA_NS0ID_ENUMVALUETYPE_ENCODING_DEFAULTBINARY 8251 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA 8252 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPEVERSION 8253 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NAMESPACEURI 8254 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ARGUMENT 8285 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ARGUMENT_DATATYPEVERSION 8286 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ARGUMENT_DICTIONARYFRAGMENT 8287 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMVALUETYPE 8291 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMVALUETYPE_DATATYPEVERSION 8292 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMVALUETYPE_DICTIONARYFRAGMENT 8293 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STATUSRESULT 8294 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STATUSRESULT_DATATYPEVERSION 8295 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STATUSRESULT_DICTIONARYFRAGMENT 8296 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERTOKENPOLICY 8297 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERTOKENPOLICY_DATATYPEVERSION 8298 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERTOKENPOLICY_DICTIONARYFRAGMENT 8299 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_APPLICATIONDESCRIPTION 8300 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_APPLICATIONDESCRIPTION_DATATYPEVERSION 8301 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_APPLICATIONDESCRIPTION_DICTIONARYFRAGMENT 8302 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTDESCRIPTION 8303 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTDESCRIPTION_DATATYPEVERSION 8304 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTDESCRIPTION_DICTIONARYFRAGMENT 8305 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERIDENTITYTOKEN 8306 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERIDENTITYTOKEN_DATATYPEVERSION 8307 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERIDENTITYTOKEN_DICTIONARYFRAGMENT 8308 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ANONYMOUSIDENTITYTOKEN 8309 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ANONYMOUSIDENTITYTOKEN_DATATYPEVERSION 8310 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ANONYMOUSIDENTITYTOKEN_DICTIONARYFRAGMENT 8311 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERNAMEIDENTITYTOKEN 8312 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERNAMEIDENTITYTOKEN_DATATYPEVERSION 8313 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_USERNAMEIDENTITYTOKEN_DICTIONARYFRAGMENT 8314 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_X509IDENTITYTOKEN 8315 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_X509IDENTITYTOKEN_DATATYPEVERSION 8316 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_X509IDENTITYTOKEN_DICTIONARYFRAGMENT 8317 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ISSUEDIDENTITYTOKEN 8318 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ISSUEDIDENTITYTOKEN_DATATYPEVERSION 8319 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ISSUEDIDENTITYTOKEN_DICTIONARYFRAGMENT 8320 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTCONFIGURATION 8321 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTCONFIGURATION_DATATYPEVERSION 8322 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTCONFIGURATION_DICTIONARYFRAGMENT 8323 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BUILDINFO 8327 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BUILDINFO_DATATYPEVERSION 8328 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BUILDINFO_DICTIONARYFRAGMENT 8329 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIGNEDSOFTWARECERTIFICATE 8333 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIGNEDSOFTWARECERTIFICATE_DATATYPEVERSION 8334 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIGNEDSOFTWARECERTIFICATE_DICTIONARYFRAGMENT 8335 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDNODESITEM 8363 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDNODESITEM_DATATYPEVERSION 8364 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDNODESITEM_DICTIONARYFRAGMENT 8365 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDREFERENCESITEM 8366 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDREFERENCESITEM_DATATYPEVERSION 8367 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDREFERENCESITEM_DICTIONARYFRAGMENT 8368 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DELETENODESITEM 8369 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DELETENODESITEM_DATATYPEVERSION 8370 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DELETENODESITEM_DICTIONARYFRAGMENT 8371 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DELETEREFERENCESITEM 8372 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DELETEREFERENCESITEM_DATATYPEVERSION 8373 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DELETEREFERENCESITEM_DICTIONARYFRAGMENT 8374 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_REGISTEREDSERVER 8417 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_REGISTEREDSERVER_DATATYPEVERSION 8418 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_REGISTEREDSERVER_DICTIONARYFRAGMENT 8419 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONTENTFILTERELEMENT 8564 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONTENTFILTERELEMENT_DATATYPEVERSION 8565 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONTENTFILTERELEMENT_DICTIONARYFRAGMENT 8566 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONTENTFILTER 8567 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONTENTFILTER_DATATYPEVERSION 8568 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONTENTFILTER_DICTIONARYFRAGMENT 8569 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FILTEROPERAND 8570 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FILTEROPERAND_DATATYPEVERSION 8571 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FILTEROPERAND_DICTIONARYFRAGMENT 8572 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ELEMENTOPERAND 8573 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ELEMENTOPERAND_DATATYPEVERSION 8574 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ELEMENTOPERAND_DICTIONARYFRAGMENT 8575 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_LITERALOPERAND 8576 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_LITERALOPERAND_DATATYPEVERSION 8577 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_LITERALOPERAND_DICTIONARYFRAGMENT 8578 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ATTRIBUTEOPERAND 8579 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ATTRIBUTEOPERAND_DATATYPEVERSION 8580 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ATTRIBUTEOPERAND_DICTIONARYFRAGMENT 8581 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIMPLEATTRIBUTEOPERAND 8582 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIMPLEATTRIBUTEOPERAND_DATATYPEVERSION 8583 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIMPLEATTRIBUTEOPERAND_DICTIONARYFRAGMENT 8584 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_HISTORYEVENT 8639 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_HISTORYEVENT_DATATYPEVERSION 8640 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_HISTORYEVENT_DICTIONARYFRAGMENT 8641 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MONITORINGFILTER 8702 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MONITORINGFILTER_DATATYPEVERSION 8703 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MONITORINGFILTER_DICTIONARYFRAGMENT 8704 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EVENTFILTER 8708 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EVENTFILTER_DATATYPEVERSION 8709 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EVENTFILTER_DICTIONARYFRAGMENT 8710 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_AGGREGATECONFIGURATION 8711 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_AGGREGATECONFIGURATION_DATATYPEVERSION 8712 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_AGGREGATECONFIGURATION_DICTIONARYFRAGMENT 8713 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_HISTORYEVENTFIELDLIST 8807 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_HISTORYEVENTFIELDLIST_DATATYPEVERSION 8808 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_HISTORYEVENTFIELDLIST_DICTIONARYFRAGMENT 8809 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_REDUNDANTSERVERDATATYPE 8843 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_REDUNDANTSERVERDATATYPE_DATATYPEVERSION 8844 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_REDUNDANTSERVERDATATYPE_DICTIONARYFRAGMENT 8845 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SAMPLINGINTERVALDIAGNOSTICSDATATYPE 8846 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SAMPLINGINTERVALDIAGNOSTICSDATATYPE_DATATYPEVERSION 8847 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SAMPLINGINTERVALDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8848 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERDIAGNOSTICSSUMMARYDATATYPE 8849 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERDIAGNOSTICSSUMMARYDATATYPE_DATATYPEVERSION 8850 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERDIAGNOSTICSSUMMARYDATATYPE_DICTIONARYFRAGMENT 8851 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERSTATUSDATATYPE 8852 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERSTATUSDATATYPE_DATATYPEVERSION 8853 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERSTATUSDATATYPE_DICTIONARYFRAGMENT 8854 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SESSIONDIAGNOSTICSDATATYPE 8855 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SESSIONDIAGNOSTICSDATATYPE_DATATYPEVERSION 8856 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SESSIONDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8857 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SESSIONSECURITYDIAGNOSTICSDATATYPE 8858 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SESSIONSECURITYDIAGNOSTICSDATATYPE_DATATYPEVERSION 8859 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SESSIONSECURITYDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8860 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVICECOUNTERDATATYPE 8861 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVICECOUNTERDATATYPE_DATATYPEVERSION 8862 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVICECOUNTERDATATYPE_DICTIONARYFRAGMENT 8863 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIPTIONDIAGNOSTICSDATATYPE 8864 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIPTIONDIAGNOSTICSDATATYPE_DATATYPEVERSION 8865 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIPTIONDIAGNOSTICSDATATYPE_DICTIONARYFRAGMENT 8866 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MODELCHANGESTRUCTUREDATATYPE 8867 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MODELCHANGESTRUCTUREDATATYPE_DATATYPEVERSION 8868 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MODELCHANGESTRUCTUREDATATYPE_DICTIONARYFRAGMENT 8869 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SEMANTICCHANGESTRUCTUREDATATYPE 8870 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SEMANTICCHANGESTRUCTUREDATATYPE_DATATYPEVERSION 8871 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SEMANTICCHANGESTRUCTUREDATATYPE_DICTIONARYFRAGMENT 8872 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RANGE 8873 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RANGE_DATATYPEVERSION 8874 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RANGE_DICTIONARYFRAGMENT 8875 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EUINFORMATION 8876 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EUINFORMATION_DATATYPEVERSION 8877 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EUINFORMATION_DICTIONARYFRAGMENT 8878 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ANNOTATION 8879 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ANNOTATION_DATATYPEVERSION 8880 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ANNOTATION_DICTIONARYFRAGMENT 8881 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PROGRAMDIAGNOSTICDATATYPE 8882 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PROGRAMDIAGNOSTICDATATYPE_DATATYPEVERSION 8883 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PROGRAMDIAGNOSTICDATATYPE_DICTIONARYFRAGMENT 8884 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_MAXLIFETIMECOUNT 8888 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_LATEPUBLISHREQUESTCOUNT 8889 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_CURRENTKEEPALIVECOUNT 8890 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_CURRENTLIFETIMECOUNT 8891 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_UNACKNOWLEDGEDMESSAGECOUNT 8892 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_DISCARDEDMESSAGECOUNT 8893 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_MONITOREDITEMCOUNT 8894 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_DISABLEDMONITOREDITEMCOUNT 8895 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_MONITORINGQUEUEOVERFLOWCOUNT 8896 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_NEXTSEQUENCENUMBER 8897 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_TOTALREQUESTCOUNT 8898 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_TOTALREQUESTCOUNT 8900 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSTYPE_EVENTQUEUEOVERFLOWCOUNT 8902 /* Variable */ +#define UA_NS0ID_TIMEZONEDATATYPE 8912 /* DataType */ +#define UA_NS0ID_TIMEZONEDATATYPE_ENCODING_DEFAULTXML 8913 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TIMEZONEDATATYPE 8914 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TIMEZONEDATATYPE_DATATYPEVERSION 8915 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TIMEZONEDATATYPE_DICTIONARYFRAGMENT 8916 /* Variable */ +#define UA_NS0ID_TIMEZONEDATATYPE_ENCODING_DEFAULTBINARY 8917 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TIMEZONEDATATYPE 8918 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TIMEZONEDATATYPE_DATATYPEVERSION 8919 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TIMEZONEDATATYPE_DICTIONARYFRAGMENT 8920 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE 8927 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_EVENTID 8928 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_EVENTTYPE 8929 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_SOURCENODE 8930 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_SOURCENAME 8931 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_TIME 8932 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_RECEIVETIME 8933 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_LOCALTIME 8934 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_MESSAGE 8935 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_SEVERITY 8936 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_ACTIONTIMESTAMP 8937 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_STATUS 8938 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_SERVERID 8939 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_CLIENTAUDITENTRYID 8940 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_CLIENTUSERID 8941 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_METHODID 8942 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_INPUTARGUMENTS 8943 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE 8944 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_EVENTID 8945 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_EVENTTYPE 8946 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_SOURCENODE 8947 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_SOURCENAME 8948 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_TIME 8949 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_RECEIVETIME 8950 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_LOCALTIME 8951 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_MESSAGE 8952 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_SEVERITY 8953 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_ACTIONTIMESTAMP 8954 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_STATUS 8955 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_SERVERID 8956 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_CLIENTAUDITENTRYID 8957 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_CLIENTUSERID 8958 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_METHODID 8959 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_INPUTARGUMENTS 8960 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE 8961 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_EVENTID 8962 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_EVENTTYPE 8963 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_SOURCENODE 8964 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_SOURCENAME 8965 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_TIME 8966 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_RECEIVETIME 8967 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_LOCALTIME 8968 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_MESSAGE 8969 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_SEVERITY 8970 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_ACTIONTIMESTAMP 8971 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_STATUS 8972 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_SERVERID 8973 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_CLIENTAUDITENTRYID 8974 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_CLIENTUSERID 8975 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_METHODID 8976 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_INPUTARGUMENTS 8977 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE 8995 /* VariableType */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_ID 8996 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_NAME 8997 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_NUMBER 8998 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_EFFECTIVEDISPLAYNAME 8999 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_TRANSITIONTIME 9000 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_EFFECTIVETRANSITIONTIME 9001 /* Variable */ +#define UA_NS0ID_CONDITIONVARIABLETYPE 9002 /* VariableType */ +#define UA_NS0ID_CONDITIONVARIABLETYPE_SOURCETIMESTAMP 9003 /* Variable */ +#define UA_NS0ID_HASTRUESUBSTATE 9004 /* ReferenceType */ +#define UA_NS0ID_HASFALSESUBSTATE 9005 /* ReferenceType */ +#define UA_NS0ID_HASCONDITION 9006 /* ReferenceType */ +#define UA_NS0ID_CONDITIONREFRESHMETHODTYPE 9007 /* Method */ +#define UA_NS0ID_CONDITIONREFRESHMETHODTYPE_INPUTARGUMENTS 9008 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONNAME 9009 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_BRANCHID 9010 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE 9011 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_ID 9012 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_NAME 9013 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_NUMBER 9014 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9015 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_TRANSITIONTIME 9016 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9017 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_TRUESTATE 9018 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLEDSTATE_FALSESTATE 9019 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_QUALITY 9020 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_QUALITY_SOURCETIMESTAMP 9021 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_LASTSEVERITY 9022 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_LASTSEVERITY_SOURCETIMESTAMP 9023 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_COMMENT 9024 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_COMMENT_SOURCETIMESTAMP 9025 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_CLIENTUSERID 9026 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_ENABLE 9027 /* Method */ +#define UA_NS0ID_CONDITIONTYPE_DISABLE 9028 /* Method */ +#define UA_NS0ID_CONDITIONTYPE_ADDCOMMENT 9029 /* Method */ +#define UA_NS0ID_CONDITIONTYPE_ADDCOMMENT_INPUTARGUMENTS 9030 /* Variable */ +#define UA_NS0ID_DIALOGRESPONSEMETHODTYPE 9031 /* Method */ +#define UA_NS0ID_DIALOGRESPONSEMETHODTYPE_INPUTARGUMENTS 9032 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONNAME 9033 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_BRANCHID 9034 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE 9035 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_ID 9036 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_NAME 9037 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_NUMBER 9038 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9039 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_TRANSITIONTIME 9040 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9041 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_TRUESTATE 9042 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLEDSTATE_FALSESTATE 9043 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_QUALITY 9044 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_QUALITY_SOURCETIMESTAMP 9045 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_LASTSEVERITY 9046 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_LASTSEVERITY_SOURCETIMESTAMP 9047 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_COMMENT 9048 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_COMMENT_SOURCETIMESTAMP 9049 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CLIENTUSERID 9050 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ENABLE 9051 /* Method */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DISABLE 9052 /* Method */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ADDCOMMENT 9053 /* Method */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_ADDCOMMENT_INPUTARGUMENTS 9054 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE 9055 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_ID 9056 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_NAME 9057 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_NUMBER 9058 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_EFFECTIVEDISPLAYNAME 9059 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_TRANSITIONTIME 9060 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_EFFECTIVETRANSITIONTIME 9061 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_TRUESTATE 9062 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DIALOGSTATE_FALSESTATE 9063 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_RESPONSEOPTIONSET 9064 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_DEFAULTRESPONSE 9065 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_OKRESPONSE 9066 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CANCELRESPONSE 9067 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_LASTRESPONSE 9068 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_RESPOND 9069 /* Method */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_RESPOND_INPUTARGUMENTS 9070 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONNAME 9071 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_BRANCHID 9072 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE 9073 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_ID 9074 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_NAME 9075 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_NUMBER 9076 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9077 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_TRANSITIONTIME 9078 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9079 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_TRUESTATE 9080 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLEDSTATE_FALSESTATE 9081 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_QUALITY 9082 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_QUALITY_SOURCETIMESTAMP 9083 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_LASTSEVERITY 9084 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_LASTSEVERITY_SOURCETIMESTAMP 9085 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_COMMENT 9086 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_COMMENT_SOURCETIMESTAMP 9087 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CLIENTUSERID 9088 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ENABLE 9089 /* Method */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_DISABLE 9090 /* Method */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ADDCOMMENT 9091 /* Method */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ADDCOMMENT_INPUTARGUMENTS 9092 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE 9093 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_ID 9094 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_NAME 9095 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_NUMBER 9096 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9097 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_TRANSITIONTIME 9098 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9099 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_TRUESTATE 9100 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKEDSTATE_FALSESTATE 9101 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE 9102 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_ID 9103 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_NAME 9104 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_NUMBER 9105 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9106 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9107 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9108 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_TRUESTATE 9109 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRMEDSTATE_FALSESTATE 9110 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKNOWLEDGE 9111 /* Method */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9112 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRM 9113 /* Method */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONFIRM_INPUTARGUMENTS 9114 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVETIME 9115 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONNAME 9116 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_BRANCHID 9117 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE 9118 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_ID 9119 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_NAME 9120 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_NUMBER 9121 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9122 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_TRANSITIONTIME 9123 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9124 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_TRUESTATE 9125 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLEDSTATE_FALSESTATE 9126 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_QUALITY 9127 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_QUALITY_SOURCETIMESTAMP 9128 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LASTSEVERITY 9129 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LASTSEVERITY_SOURCETIMESTAMP 9130 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_COMMENT 9131 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_COMMENT_SOURCETIMESTAMP 9132 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CLIENTUSERID 9133 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ENABLE 9134 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_DISABLE 9135 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ADDCOMMENT 9136 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ADDCOMMENT_INPUTARGUMENTS 9137 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE 9138 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_ID 9139 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_NAME 9140 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_NUMBER 9141 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9142 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_TRANSITIONTIME 9143 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9144 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_TRUESTATE 9145 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKEDSTATE_FALSESTATE 9146 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE 9147 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_ID 9148 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_NAME 9149 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_NUMBER 9150 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9151 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9152 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9153 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_TRUESTATE 9154 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRMEDSTATE_FALSESTATE 9155 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKNOWLEDGE 9156 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9157 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRM 9158 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONFIRM_INPUTARGUMENTS 9159 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE 9160 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_ID 9161 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_NAME 9162 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_NUMBER 9163 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 9164 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_TRANSITIONTIME 9165 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 9166 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_TRUESTATE 9167 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ACTIVESTATE_FALSESTATE 9168 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE 9169 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_ID 9170 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_NAME 9171 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_NUMBER 9172 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 9173 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 9174 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 9175 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_TRUESTATE 9176 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDSTATE_FALSESTATE 9177 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE 9178 /* Object */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_CURRENTSTATE 9179 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_CURRENTSTATE_ID 9180 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 9181 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 9182 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9183 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_LASTTRANSITION 9184 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_LASTTRANSITION_ID 9185 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 9186 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 9187 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 9188 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_UNSHELVETIME 9189 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_UNSHELVE 9211 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_ONESHOTSHELVE 9212 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_TIMEDSHELVE 9213 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 9214 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESSEDORSHELVED 9215 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_MAXTIMESHELVED 9216 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONNAME 9217 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_BRANCHID 9218 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE 9219 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_ID 9220 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_NAME 9221 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_NUMBER 9222 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9223 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 9224 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9225 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_TRUESTATE 9226 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLEDSTATE_FALSESTATE 9227 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_QUALITY 9228 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_QUALITY_SOURCETIMESTAMP 9229 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LASTSEVERITY 9230 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 9231 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_COMMENT 9232 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_COMMENT_SOURCETIMESTAMP 9233 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CLIENTUSERID 9234 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ENABLE 9235 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_DISABLE 9236 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_ADDCOMMENT 9237 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 9238 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE 9239 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_ID 9240 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_NAME 9241 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_NUMBER 9242 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9243 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_TRANSITIONTIME 9244 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9245 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_TRUESTATE 9246 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKEDSTATE_FALSESTATE 9247 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE 9248 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_ID 9249 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_NAME 9250 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_NUMBER 9251 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9252 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9253 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9254 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_TRUESTATE 9255 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRMEDSTATE_FALSESTATE 9256 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACKNOWLEDGE 9257 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9258 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRM 9259 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_CONFIRM_INPUTARGUMENTS 9260 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE 9261 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_ID 9262 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_NAME 9263 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_NUMBER 9264 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 9265 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_TRANSITIONTIME 9266 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 9267 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_TRUESTATE 9268 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ACTIVESTATE_FALSESTATE 9269 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE 9270 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_ID 9271 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_NAME 9272 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_NUMBER 9273 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 9274 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 9275 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 9276 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 9277 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 9278 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE 9279 /* Object */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE 9280 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 9281 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 9282 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 9283 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9284 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION 9285 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 9286 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 9287 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 9288 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 9289 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_UNSHELVETIME 9290 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_UNSHELVE 9312 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 9313 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 9314 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 9315 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESSEDORSHELVED 9316 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_MAXTIMESHELVED 9317 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE 9318 /* ObjectType */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_CURRENTSTATE 9319 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_CURRENTSTATE_ID 9320 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_CURRENTSTATE_NAME 9321 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_CURRENTSTATE_NUMBER 9322 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9323 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LASTTRANSITION 9324 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LASTTRANSITION_ID 9325 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LASTTRANSITION_NAME 9326 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LASTTRANSITION_NUMBER 9327 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LASTTRANSITION_TRANSITIONTIME 9328 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGHHIGH 9329 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGHHIGH_STATENUMBER 9330 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGH 9331 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGH_STATENUMBER 9332 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOW 9333 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOW_STATENUMBER 9334 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOWLOW 9335 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOWLOW_STATENUMBER 9336 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOWLOWTOLOW 9337 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOWTOLOWLOW 9338 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGHHIGHTOHIGH 9339 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGHTOHIGHHIGH 9340 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE 9341 /* ObjectType */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_EVENTID 9342 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_EVENTTYPE 9343 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SOURCENODE 9344 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SOURCENAME 9345 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_TIME 9346 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_RECEIVETIME 9347 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LOCALTIME 9348 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_MESSAGE 9349 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SEVERITY 9350 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONNAME 9351 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_BRANCHID 9352 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_RETAIN 9353 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE 9354 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_ID 9355 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_NAME 9356 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_NUMBER 9357 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9358 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 9359 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9360 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_TRUESTATE 9361 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_FALSESTATE 9362 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_QUALITY 9363 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_QUALITY_SOURCETIMESTAMP 9364 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LASTSEVERITY 9365 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 9366 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_COMMENT 9367 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_COMMENT_SOURCETIMESTAMP 9368 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CLIENTUSERID 9369 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ENABLE 9370 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_DISABLE 9371 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ADDCOMMENT 9372 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 9373 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH 9374 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 9375 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE 9376 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_ID 9377 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_NAME 9378 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_NUMBER 9379 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9380 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_TRANSITIONTIME 9381 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9382 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_TRUESTATE 9383 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKEDSTATE_FALSESTATE 9384 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE 9385 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_ID 9386 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_NAME 9387 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_NUMBER 9388 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9389 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9390 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9391 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_TRUESTATE 9392 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_FALSESTATE 9393 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKNOWLEDGE 9394 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9395 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRM 9396 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONFIRM_INPUTARGUMENTS 9397 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE 9398 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_ID 9399 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_NAME 9400 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_NUMBER 9401 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 9402 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_TRANSITIONTIME 9403 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 9404 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_TRUESTATE 9405 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ACTIVESTATE_FALSESTATE 9406 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE 9407 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_ID 9408 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_NAME 9409 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_NUMBER 9410 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 9411 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 9412 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 9413 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 9414 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 9415 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE 9416 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE 9417 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 9418 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 9419 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 9420 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9421 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION 9422 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 9423 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 9424 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 9425 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 9426 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_UNSHELVETIME 9427 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_UNSHELVE 9449 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 9450 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 9451 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 9452 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESSEDORSHELVED 9453 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_MAXTIMESHELVED 9454 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE 9455 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_CURRENTSTATE 9456 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_CURRENTSTATE_ID 9457 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_CURRENTSTATE_NAME 9458 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_CURRENTSTATE_NUMBER 9459 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9460 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_LASTTRANSITION 9461 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_LASTTRANSITION_ID 9462 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_LASTTRANSITION_NAME 9463 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_LASTTRANSITION_NUMBER 9464 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_LASTTRANSITION_TRANSITIONTIME 9465 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_HIGHHIGHLIMIT 9478 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_HIGHLIMIT 9479 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LOWLIMIT 9480 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LOWLOWLIMIT 9481 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE 9482 /* ObjectType */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_EVENTID 9483 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_EVENTTYPE 9484 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SOURCENODE 9485 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SOURCENAME 9486 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_TIME 9487 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_RECEIVETIME 9488 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LOCALTIME 9489 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_MESSAGE 9490 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SEVERITY 9491 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONNAME 9492 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_BRANCHID 9493 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_RETAIN 9494 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE 9495 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_ID 9496 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_NAME 9497 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_NUMBER 9498 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9499 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 9500 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9501 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_TRUESTATE 9502 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_FALSESTATE 9503 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_QUALITY 9504 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_QUALITY_SOURCETIMESTAMP 9505 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LASTSEVERITY 9506 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 9507 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_COMMENT 9508 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_COMMENT_SOURCETIMESTAMP 9509 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CLIENTUSERID 9510 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ENABLE 9511 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_DISABLE 9512 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ADDCOMMENT 9513 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 9514 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH 9515 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 9516 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE 9517 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_ID 9518 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_NAME 9519 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_NUMBER 9520 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9521 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_TRANSITIONTIME 9522 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9523 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_TRUESTATE 9524 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKEDSTATE_FALSESTATE 9525 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE 9526 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_ID 9527 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_NAME 9528 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_NUMBER 9529 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9530 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9531 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9532 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_TRUESTATE 9533 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_FALSESTATE 9534 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKNOWLEDGE 9535 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9536 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRM 9537 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONFIRM_INPUTARGUMENTS 9538 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE 9539 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_ID 9540 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_NAME 9541 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_NUMBER 9542 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 9543 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_TRANSITIONTIME 9544 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 9545 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_TRUESTATE 9546 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ACTIVESTATE_FALSESTATE 9547 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE 9548 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_ID 9549 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_NAME 9550 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_NUMBER 9551 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 9552 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 9553 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 9554 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 9555 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 9556 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE 9557 /* Object */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE 9558 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 9559 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 9560 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 9561 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9562 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION 9563 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 9564 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 9565 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 9566 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 9567 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_UNSHELVETIME 9568 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_UNSHELVE 9590 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 9591 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 9592 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 9593 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESSEDORSHELVED 9594 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_MAXTIMESHELVED 9595 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE 9596 /* Object */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_CURRENTSTATE 9597 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_CURRENTSTATE_ID 9598 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_CURRENTSTATE_NAME 9599 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_CURRENTSTATE_NUMBER 9600 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9601 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_LASTTRANSITION 9602 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_LASTTRANSITION_ID 9603 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_LASTTRANSITION_NAME 9604 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_LASTTRANSITION_NUMBER 9605 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_LASTTRANSITION_TRANSITIONTIME 9606 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_HIGHHIGHLIMIT 9619 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_HIGHLIMIT 9620 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LOWLIMIT 9621 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LOWLOWLIMIT 9622 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE 9623 /* ObjectType */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_EVENTID 9624 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_EVENTTYPE 9625 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SOURCENODE 9626 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SOURCENAME 9627 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_TIME 9628 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_RECEIVETIME 9629 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LOCALTIME 9630 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_MESSAGE 9631 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SEVERITY 9632 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONNAME 9633 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_BRANCHID 9634 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_RETAIN 9635 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE 9636 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_ID 9637 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_NAME 9638 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_NUMBER 9639 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9640 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 9641 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9642 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_TRUESTATE 9643 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_FALSESTATE 9644 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_QUALITY 9645 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_QUALITY_SOURCETIMESTAMP 9646 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LASTSEVERITY 9647 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 9648 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_COMMENT 9649 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_COMMENT_SOURCETIMESTAMP 9650 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CLIENTUSERID 9651 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENABLE 9652 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_DISABLE 9653 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ADDCOMMENT 9654 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 9655 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH 9656 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 9657 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE 9658 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_ID 9659 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_NAME 9660 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_NUMBER 9661 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9662 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_TRANSITIONTIME 9663 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9664 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_TRUESTATE 9665 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_FALSESTATE 9666 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE 9667 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_ID 9668 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_NAME 9669 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_NUMBER 9670 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9671 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9672 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9673 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_TRUESTATE 9674 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_FALSESTATE 9675 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKNOWLEDGE 9676 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9677 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRM 9678 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRM_INPUTARGUMENTS 9679 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE 9680 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_ID 9681 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_NAME 9682 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_NUMBER 9683 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 9684 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_TRANSITIONTIME 9685 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 9686 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_TRUESTATE 9687 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_FALSESTATE 9688 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE 9689 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_ID 9690 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_NAME 9691 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_NUMBER 9692 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 9693 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 9694 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 9695 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 9696 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 9697 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE 9698 /* Object */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE 9699 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 9700 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 9701 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 9702 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9703 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION 9704 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 9705 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 9706 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 9707 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 9708 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_UNSHELVETIME 9709 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_UNSHELVE 9731 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 9732 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 9733 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 9734 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDORSHELVED 9735 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_MAXTIMESHELVED 9736 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE 9737 /* Object */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_CURRENTSTATE 9738 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_CURRENTSTATE_ID 9739 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_CURRENTSTATE_NAME 9740 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_CURRENTSTATE_NUMBER 9741 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9742 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_LASTTRANSITION 9743 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_LASTTRANSITION_ID 9744 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_LASTTRANSITION_NAME 9745 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_LASTTRANSITION_NUMBER 9746 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_LASTTRANSITION_TRANSITIONTIME 9747 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHLIMIT 9760 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_HIGHLIMIT 9761 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LOWLIMIT 9762 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWLIMIT 9763 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE 9764 /* ObjectType */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_EVENTID 9765 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_EVENTTYPE 9766 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SOURCENODE 9767 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SOURCENAME 9768 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_TIME 9769 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_RECEIVETIME 9770 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LOCALTIME 9771 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_MESSAGE 9772 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SEVERITY 9773 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONNAME 9774 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_BRANCHID 9775 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_RETAIN 9776 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE 9777 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_ID 9778 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_NAME 9779 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_NUMBER 9780 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9781 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 9782 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9783 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_TRUESTATE 9784 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_FALSESTATE 9785 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_QUALITY 9786 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_QUALITY_SOURCETIMESTAMP 9787 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LASTSEVERITY 9788 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 9789 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_COMMENT 9790 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_COMMENT_SOURCETIMESTAMP 9791 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CLIENTUSERID 9792 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ENABLE 9793 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_DISABLE 9794 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ADDCOMMENT 9795 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 9796 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH 9797 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 9798 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE 9799 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_ID 9800 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_NAME 9801 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_NUMBER 9802 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9803 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_TRANSITIONTIME 9804 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9805 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_TRUESTATE 9806 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_FALSESTATE 9807 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE 9808 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_ID 9809 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_NAME 9810 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_NUMBER 9811 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9812 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9813 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9814 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_TRUESTATE 9815 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_FALSESTATE 9816 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKNOWLEDGE 9817 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9818 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRM 9819 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONFIRM_INPUTARGUMENTS 9820 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE 9821 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_ID 9822 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_NAME 9823 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_NUMBER 9824 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 9825 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_TRANSITIONTIME 9826 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 9827 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_TRUESTATE 9828 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_FALSESTATE 9829 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE 9830 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_ID 9831 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_NAME 9832 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_NUMBER 9833 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 9834 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 9835 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 9836 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 9837 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 9838 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE 9839 /* Object */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE 9840 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 9841 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 9842 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 9843 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9844 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION 9845 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 9846 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 9847 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 9848 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 9849 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_UNSHELVETIME 9850 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_UNSHELVE 9872 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 9873 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 9874 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 9875 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDORSHELVED 9876 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_MAXTIMESHELVED 9877 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE 9878 /* Object */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_CURRENTSTATE 9879 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_CURRENTSTATE_ID 9880 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_CURRENTSTATE_NAME 9881 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_CURRENTSTATE_NUMBER 9882 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9883 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_LASTTRANSITION 9884 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_LASTTRANSITION_ID 9885 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_LASTTRANSITION_NAME 9886 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_LASTTRANSITION_NUMBER 9887 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_LASTTRANSITION_TRANSITIONTIME 9888 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHLIMIT 9901 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_HIGHLIMIT 9902 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LOWLIMIT 9903 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LOWLOWLIMIT 9904 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SETPOINTNODE 9905 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE 9906 /* ObjectType */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_EVENTID 9907 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_EVENTTYPE 9908 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SOURCENODE 9909 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SOURCENAME 9910 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_TIME 9911 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_RECEIVETIME 9912 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOCALTIME 9913 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_MESSAGE 9914 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SEVERITY 9915 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONNAME 9916 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_BRANCHID 9917 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_RETAIN 9918 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE 9919 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_ID 9920 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_NAME 9921 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_NUMBER 9922 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 9923 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 9924 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 9925 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_TRUESTATE 9926 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLEDSTATE_FALSESTATE 9927 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_QUALITY 9928 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_QUALITY_SOURCETIMESTAMP 9929 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LASTSEVERITY 9930 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 9931 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_COMMENT 9932 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_COMMENT_SOURCETIMESTAMP 9933 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CLIENTUSERID 9934 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ENABLE 9935 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_DISABLE 9936 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ADDCOMMENT 9937 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 9938 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH 9939 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 9940 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE 9941 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_ID 9942 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_NAME 9943 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_NUMBER 9944 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 9945 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_TRANSITIONTIME 9946 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 9947 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_TRUESTATE 9948 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKEDSTATE_FALSESTATE 9949 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE 9950 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_ID 9951 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_NAME 9952 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_NUMBER 9953 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 9954 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 9955 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 9956 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_TRUESTATE 9957 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRMEDSTATE_FALSESTATE 9958 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKNOWLEDGE 9959 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 9960 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRM 9961 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONFIRM_INPUTARGUMENTS 9962 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE 9963 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_ID 9964 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_NAME 9965 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_NUMBER 9966 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 9967 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_TRANSITIONTIME 9968 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 9969 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_TRUESTATE 9970 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ACTIVESTATE_FALSESTATE 9971 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE 9972 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_ID 9973 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_NAME 9974 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_NUMBER 9975 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 9976 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 9977 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 9978 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 9979 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 9980 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE 9981 /* Object */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE 9982 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 9983 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 9984 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 9985 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 9986 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION 9987 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 9988 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 9989 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 9990 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 9991 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_UNSHELVETIME 9992 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_UNSHELVE 10014 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 10015 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 10016 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 10017 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESSEDORSHELVED 10018 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_MAXTIMESHELVED 10019 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE 10020 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_ID 10021 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_NAME 10022 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_NUMBER 10023 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_EFFECTIVEDISPLAYNAME 10024 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_TRANSITIONTIME 10025 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_EFFECTIVETRANSITIONTIME 10026 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_TRUESTATE 10027 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHSTATE_FALSESTATE 10028 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE 10029 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_ID 10030 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_NAME 10031 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_NUMBER 10032 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_EFFECTIVEDISPLAYNAME 10033 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_TRANSITIONTIME 10034 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_EFFECTIVETRANSITIONTIME 10035 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_TRUESTATE 10036 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHSTATE_FALSESTATE 10037 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE 10038 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_ID 10039 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_NAME 10040 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_NUMBER 10041 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_EFFECTIVEDISPLAYNAME 10042 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_TRANSITIONTIME 10043 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_EFFECTIVETRANSITIONTIME 10044 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_TRUESTATE 10045 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWSTATE_FALSESTATE 10046 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE 10047 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_ID 10048 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_NAME 10049 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_NUMBER 10050 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_EFFECTIVEDISPLAYNAME 10051 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_TRANSITIONTIME 10052 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_EFFECTIVETRANSITIONTIME 10053 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_TRUESTATE 10054 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWSTATE_FALSESTATE 10055 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHHIGHLIMIT 10056 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_HIGHLIMIT 10057 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLIMIT 10058 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LOWLOWLIMIT 10059 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE 10060 /* ObjectType */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_EVENTID 10061 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_EVENTTYPE 10062 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SOURCENODE 10063 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SOURCENAME 10064 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_TIME 10065 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_RECEIVETIME 10066 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOCALTIME 10067 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_MESSAGE 10068 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SEVERITY 10069 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONNAME 10070 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_BRANCHID 10071 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_RETAIN 10072 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE 10073 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_ID 10074 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_NAME 10075 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_NUMBER 10076 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 10077 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 10078 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 10079 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_TRUESTATE 10080 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLEDSTATE_FALSESTATE 10081 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_QUALITY 10082 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_QUALITY_SOURCETIMESTAMP 10083 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LASTSEVERITY 10084 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 10085 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_COMMENT 10086 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_COMMENT_SOURCETIMESTAMP 10087 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CLIENTUSERID 10088 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ENABLE 10089 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_DISABLE 10090 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ADDCOMMENT 10091 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 10092 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH 10093 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 10094 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE 10095 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_ID 10096 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_NAME 10097 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_NUMBER 10098 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 10099 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_TRANSITIONTIME 10100 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 10101 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_TRUESTATE 10102 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKEDSTATE_FALSESTATE 10103 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE 10104 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_ID 10105 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_NAME 10106 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_NUMBER 10107 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 10108 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 10109 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 10110 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_TRUESTATE 10111 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRMEDSTATE_FALSESTATE 10112 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKNOWLEDGE 10113 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 10114 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRM 10115 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONFIRM_INPUTARGUMENTS 10116 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE 10117 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_ID 10118 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_NAME 10119 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_NUMBER 10120 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 10121 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_TRANSITIONTIME 10122 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 10123 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_TRUESTATE 10124 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ACTIVESTATE_FALSESTATE 10125 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE 10126 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_ID 10127 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_NAME 10128 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_NUMBER 10129 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 10130 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 10131 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 10132 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 10133 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 10134 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE 10135 /* Object */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE 10136 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 10137 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 10138 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 10139 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 10140 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION 10141 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 10142 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 10143 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 10144 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 10145 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_UNSHELVETIME 10146 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_UNSHELVE 10168 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 10169 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 10170 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 10171 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESSEDORSHELVED 10172 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_MAXTIMESHELVED 10173 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE 10174 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_ID 10175 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_NAME 10176 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_NUMBER 10177 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_EFFECTIVEDISPLAYNAME 10178 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_TRANSITIONTIME 10179 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_EFFECTIVETRANSITIONTIME 10180 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_TRUESTATE 10181 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHSTATE_FALSESTATE 10182 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE 10183 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_ID 10184 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_NAME 10185 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_NUMBER 10186 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_EFFECTIVEDISPLAYNAME 10187 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_TRANSITIONTIME 10188 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_EFFECTIVETRANSITIONTIME 10189 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_TRUESTATE 10190 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHSTATE_FALSESTATE 10191 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE 10192 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_ID 10193 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_NAME 10194 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_NUMBER 10195 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_EFFECTIVEDISPLAYNAME 10196 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_TRANSITIONTIME 10197 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_EFFECTIVETRANSITIONTIME 10198 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_TRUESTATE 10199 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWSTATE_FALSESTATE 10200 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE 10201 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_ID 10202 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_NAME 10203 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_NUMBER 10204 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_EFFECTIVEDISPLAYNAME 10205 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_TRANSITIONTIME 10206 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_EFFECTIVETRANSITIONTIME 10207 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_TRUESTATE 10208 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWSTATE_FALSESTATE 10209 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHHIGHLIMIT 10210 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_HIGHLIMIT 10211 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLIMIT 10212 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LOWLOWLIMIT 10213 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE 10214 /* ObjectType */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_EVENTID 10215 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_EVENTTYPE 10216 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SOURCENODE 10217 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SOURCENAME 10218 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_TIME 10219 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_RECEIVETIME 10220 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOCALTIME 10221 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_MESSAGE 10222 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SEVERITY 10223 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONNAME 10224 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_BRANCHID 10225 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_RETAIN 10226 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE 10227 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_ID 10228 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_NAME 10229 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_NUMBER 10230 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 10231 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 10232 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 10233 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_TRUESTATE 10234 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLEDSTATE_FALSESTATE 10235 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_QUALITY 10236 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_QUALITY_SOURCETIMESTAMP 10237 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LASTSEVERITY 10238 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 10239 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_COMMENT 10240 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_COMMENT_SOURCETIMESTAMP 10241 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CLIENTUSERID 10242 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENABLE 10243 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_DISABLE 10244 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ADDCOMMENT 10245 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 10246 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH 10247 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 10248 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE 10249 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_ID 10250 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_NAME 10251 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_NUMBER 10252 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 10253 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_TRANSITIONTIME 10254 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 10255 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_TRUESTATE 10256 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKEDSTATE_FALSESTATE 10257 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE 10258 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_ID 10259 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_NAME 10260 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_NUMBER 10261 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 10262 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 10263 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 10264 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_TRUESTATE 10265 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRMEDSTATE_FALSESTATE 10266 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKNOWLEDGE 10267 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 10268 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRM 10269 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONFIRM_INPUTARGUMENTS 10270 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE 10271 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_ID 10272 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_NAME 10273 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_NUMBER 10274 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 10275 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_TRANSITIONTIME 10276 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 10277 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_TRUESTATE 10278 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ACTIVESTATE_FALSESTATE 10279 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE 10280 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_ID 10281 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_NAME 10282 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_NUMBER 10283 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 10284 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 10285 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 10286 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 10287 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 10288 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE 10289 /* Object */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE 10290 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 10291 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 10292 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 10293 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 10294 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION 10295 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 10296 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 10297 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 10298 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 10299 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_UNSHELVETIME 10300 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_UNSHELVE 10322 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 10323 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 10324 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 10325 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESSEDORSHELVED 10326 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_MAXTIMESHELVED 10327 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE 10328 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_ID 10329 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_NAME 10330 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_NUMBER 10331 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_EFFECTIVEDISPLAYNAME 10332 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_TRANSITIONTIME 10333 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_EFFECTIVETRANSITIONTIME 10334 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_TRUESTATE 10335 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHSTATE_FALSESTATE 10336 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE 10337 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_ID 10338 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_NAME 10339 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_NUMBER 10340 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_EFFECTIVEDISPLAYNAME 10341 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_TRANSITIONTIME 10342 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_EFFECTIVETRANSITIONTIME 10343 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_TRUESTATE 10344 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHSTATE_FALSESTATE 10345 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE 10346 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_ID 10347 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_NAME 10348 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_NUMBER 10349 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_EFFECTIVEDISPLAYNAME 10350 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_TRANSITIONTIME 10351 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_EFFECTIVETRANSITIONTIME 10352 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_TRUESTATE 10353 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWSTATE_FALSESTATE 10354 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE 10355 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_ID 10356 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_NAME 10357 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_NUMBER 10358 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_EFFECTIVEDISPLAYNAME 10359 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_TRANSITIONTIME 10360 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_EFFECTIVETRANSITIONTIME 10361 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_TRUESTATE 10362 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWSTATE_FALSESTATE 10363 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHHIGHLIMIT 10364 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_HIGHLIMIT 10365 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLIMIT 10366 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LOWLOWLIMIT 10367 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE 10368 /* ObjectType */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_EVENTID 10369 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_EVENTTYPE 10370 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SOURCENODE 10371 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SOURCENAME 10372 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_TIME 10373 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_RECEIVETIME 10374 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOCALTIME 10375 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_MESSAGE 10376 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SEVERITY 10377 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONNAME 10378 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_BRANCHID 10379 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_RETAIN 10380 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE 10381 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_ID 10382 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_NAME 10383 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_NUMBER 10384 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 10385 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 10386 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 10387 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_TRUESTATE 10388 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLEDSTATE_FALSESTATE 10389 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_QUALITY 10390 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_QUALITY_SOURCETIMESTAMP 10391 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LASTSEVERITY 10392 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 10393 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_COMMENT 10394 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_COMMENT_SOURCETIMESTAMP 10395 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CLIENTUSERID 10396 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ENABLE 10397 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_DISABLE 10398 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ADDCOMMENT 10399 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 10400 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH 10401 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 10402 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE 10403 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_ID 10404 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_NAME 10405 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_NUMBER 10406 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 10407 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_TRANSITIONTIME 10408 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 10409 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_TRUESTATE 10410 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKEDSTATE_FALSESTATE 10411 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE 10412 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_ID 10413 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_NAME 10414 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_NUMBER 10415 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 10416 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 10417 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 10418 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_TRUESTATE 10419 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRMEDSTATE_FALSESTATE 10420 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKNOWLEDGE 10421 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 10422 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRM 10423 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONFIRM_INPUTARGUMENTS 10424 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE 10425 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_ID 10426 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_NAME 10427 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_NUMBER 10428 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 10429 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_TRANSITIONTIME 10430 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 10431 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_TRUESTATE 10432 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ACTIVESTATE_FALSESTATE 10433 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE 10434 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_ID 10435 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_NAME 10436 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_NUMBER 10437 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 10438 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 10439 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 10440 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 10441 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 10442 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE 10443 /* Object */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE 10444 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 10445 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 10446 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 10447 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 10448 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION 10449 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 10450 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 10451 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 10452 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 10453 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_UNSHELVETIME 10454 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_UNSHELVE 10476 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 10477 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 10478 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 10479 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESSEDORSHELVED 10480 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_MAXTIMESHELVED 10481 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE 10482 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_ID 10483 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_NAME 10484 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_NUMBER 10485 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_EFFECTIVEDISPLAYNAME 10486 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_TRANSITIONTIME 10487 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_EFFECTIVETRANSITIONTIME 10488 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_TRUESTATE 10489 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHSTATE_FALSESTATE 10490 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE 10491 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_ID 10492 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_NAME 10493 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_NUMBER 10494 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_EFFECTIVEDISPLAYNAME 10495 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_TRANSITIONTIME 10496 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_EFFECTIVETRANSITIONTIME 10497 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_TRUESTATE 10498 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHSTATE_FALSESTATE 10499 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE 10500 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_ID 10501 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_NAME 10502 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_NUMBER 10503 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_EFFECTIVEDISPLAYNAME 10504 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_TRANSITIONTIME 10505 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_EFFECTIVETRANSITIONTIME 10506 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_TRUESTATE 10507 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWSTATE_FALSESTATE 10508 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE 10509 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_ID 10510 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_NAME 10511 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_NUMBER 10512 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_EFFECTIVEDISPLAYNAME 10513 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_TRANSITIONTIME 10514 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_EFFECTIVETRANSITIONTIME 10515 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_TRUESTATE 10516 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWSTATE_FALSESTATE 10517 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHHIGHLIMIT 10518 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_HIGHLIMIT 10519 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLIMIT 10520 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LOWLOWLIMIT 10521 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SETPOINTNODE 10522 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE 10523 /* ObjectType */ +#define UA_NS0ID_DISCRETEALARMTYPE_EVENTID 10524 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_EVENTTYPE 10525 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SOURCENODE 10526 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SOURCENAME 10527 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_TIME 10528 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_RECEIVETIME 10529 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LOCALTIME 10530 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_MESSAGE 10531 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SEVERITY 10532 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONNAME 10533 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_BRANCHID 10534 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_RETAIN 10535 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE 10536 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_ID 10537 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_NAME 10538 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_NUMBER 10539 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 10540 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 10541 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 10542 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_TRUESTATE 10543 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLEDSTATE_FALSESTATE 10544 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_QUALITY 10545 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_QUALITY_SOURCETIMESTAMP 10546 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LASTSEVERITY 10547 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 10548 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_COMMENT 10549 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_COMMENT_SOURCETIMESTAMP 10550 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CLIENTUSERID 10551 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ENABLE 10552 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_DISABLE 10553 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_ADDCOMMENT 10554 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 10555 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONREFRESH 10556 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 10557 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE 10558 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_ID 10559 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_NAME 10560 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_NUMBER 10561 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 10562 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_TRANSITIONTIME 10563 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 10564 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_TRUESTATE 10565 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKEDSTATE_FALSESTATE 10566 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE 10567 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_ID 10568 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_NAME 10569 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_NUMBER 10570 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 10571 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 10572 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 10573 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_TRUESTATE 10574 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRMEDSTATE_FALSESTATE 10575 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKNOWLEDGE 10576 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 10577 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRM 10578 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONFIRM_INPUTARGUMENTS 10579 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE 10580 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_ID 10581 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_NAME 10582 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_NUMBER 10583 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 10584 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_TRANSITIONTIME 10585 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 10586 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_TRUESTATE 10587 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ACTIVESTATE_FALSESTATE 10588 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE 10589 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_ID 10590 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_NAME 10591 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_NUMBER 10592 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 10593 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 10594 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 10595 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 10596 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 10597 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE 10598 /* Object */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_CURRENTSTATE 10599 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 10600 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 10601 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 10602 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 10603 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_LASTTRANSITION 10604 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 10605 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 10606 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 10607 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 10608 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_UNSHELVETIME 10609 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_UNSHELVE 10631 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 10632 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 10633 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 10634 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESSEDORSHELVED 10635 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_MAXTIMESHELVED 10636 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE 10637 /* ObjectType */ +#define UA_NS0ID_OFFNORMALALARMTYPE_EVENTID 10638 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_EVENTTYPE 10639 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SOURCENODE 10640 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SOURCENAME 10641 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_TIME 10642 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_RECEIVETIME 10643 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LOCALTIME 10644 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_MESSAGE 10645 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SEVERITY 10646 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONNAME 10647 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_BRANCHID 10648 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_RETAIN 10649 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE 10650 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_ID 10651 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_NAME 10652 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_NUMBER 10653 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 10654 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 10655 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 10656 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_TRUESTATE 10657 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLEDSTATE_FALSESTATE 10658 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_QUALITY 10659 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_QUALITY_SOURCETIMESTAMP 10660 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LASTSEVERITY 10661 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 10662 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_COMMENT 10663 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_COMMENT_SOURCETIMESTAMP 10664 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CLIENTUSERID 10665 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ENABLE 10666 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_DISABLE 10667 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ADDCOMMENT 10668 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 10669 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONREFRESH 10670 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 10671 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE 10672 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_ID 10673 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_NAME 10674 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_NUMBER 10675 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 10676 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_TRANSITIONTIME 10677 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 10678 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_TRUESTATE 10679 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKEDSTATE_FALSESTATE 10680 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE 10681 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_ID 10682 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_NAME 10683 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_NUMBER 10684 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 10685 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 10686 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 10687 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_TRUESTATE 10688 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRMEDSTATE_FALSESTATE 10689 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKNOWLEDGE 10690 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 10691 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRM 10692 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONFIRM_INPUTARGUMENTS 10693 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE 10694 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_ID 10695 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_NAME 10696 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_NUMBER 10697 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 10698 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_TRANSITIONTIME 10699 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 10700 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_TRUESTATE 10701 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ACTIVESTATE_FALSESTATE 10702 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE 10703 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_ID 10704 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_NAME 10705 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_NUMBER 10706 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 10707 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 10708 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 10709 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 10710 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 10711 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE 10712 /* Object */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE 10713 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 10714 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 10715 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 10716 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 10717 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION 10718 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 10719 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 10720 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 10721 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 10722 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_UNSHELVETIME 10723 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_UNSHELVE 10745 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 10746 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 10747 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 10748 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESSEDORSHELVED 10749 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_MAXTIMESHELVED 10750 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE 10751 /* ObjectType */ +#define UA_NS0ID_TRIPALARMTYPE_EVENTID 10752 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_EVENTTYPE 10753 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SOURCENODE 10754 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SOURCENAME 10755 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_TIME 10756 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_RECEIVETIME 10757 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LOCALTIME 10758 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_MESSAGE 10759 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SEVERITY 10760 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONNAME 10761 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_BRANCHID 10762 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_RETAIN 10763 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE 10764 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_ID 10765 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_NAME 10766 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_NUMBER 10767 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 10768 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 10769 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 10770 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_TRUESTATE 10771 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLEDSTATE_FALSESTATE 10772 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_QUALITY 10773 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_QUALITY_SOURCETIMESTAMP 10774 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LASTSEVERITY 10775 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 10776 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_COMMENT 10777 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_COMMENT_SOURCETIMESTAMP 10778 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CLIENTUSERID 10779 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ENABLE 10780 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_DISABLE 10781 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_ADDCOMMENT 10782 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 10783 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONREFRESH 10784 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 10785 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE 10786 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_ID 10787 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_NAME 10788 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_NUMBER 10789 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 10790 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_TRANSITIONTIME 10791 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 10792 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_TRUESTATE 10793 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKEDSTATE_FALSESTATE 10794 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE 10795 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_ID 10796 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_NAME 10797 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_NUMBER 10798 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 10799 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 10800 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 10801 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_TRUESTATE 10802 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRMEDSTATE_FALSESTATE 10803 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACKNOWLEDGE 10804 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 10805 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRM 10806 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_CONFIRM_INPUTARGUMENTS 10807 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE 10808 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_ID 10809 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_NAME 10810 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_NUMBER 10811 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 10812 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_TRANSITIONTIME 10813 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 10814 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_TRUESTATE 10815 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_ACTIVESTATE_FALSESTATE 10816 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE 10817 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_ID 10818 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_NAME 10819 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_NUMBER 10820 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 10821 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 10822 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 10823 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 10824 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 10825 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE 10826 /* Object */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_CURRENTSTATE 10827 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 10828 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 10829 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 10830 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 10831 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_LASTTRANSITION 10832 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 10833 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 10834 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 10835 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 10836 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_UNSHELVETIME 10837 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_UNSHELVE 10859 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 10860 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 10861 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 10862 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESSEDORSHELVED 10863 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_MAXTIMESHELVED 10864 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE 11093 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_EVENTID 11094 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_EVENTTYPE 11095 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_SOURCENODE 11096 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_SOURCENAME 11097 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_TIME 11098 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_RECEIVETIME 11099 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_LOCALTIME 11100 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_MESSAGE 11101 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_SEVERITY 11102 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_ACTIONTIMESTAMP 11103 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_STATUS 11104 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_SERVERID 11105 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_CLIENTAUDITENTRYID 11106 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_CLIENTUSERID 11107 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_METHODID 11108 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_INPUTARGUMENTS 11109 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_TRUESTATE 11110 /* Variable */ +#define UA_NS0ID_TWOSTATEVARIABLETYPE_FALSESTATE 11111 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONCLASSID 11112 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONCLASSNAME 11113 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONCLASSID 11114 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONCLASSNAME 11115 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONCLASSID 11116 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONCLASSNAME 11117 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONCLASSID 11118 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONCLASSNAME 11119 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_INPUTNODE 11120 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONCLASSID 11121 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONCLASSNAME 11122 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_INPUTNODE 11123 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_HIGHHIGHLIMIT 11124 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_HIGHLIMIT 11125 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LOWLIMIT 11126 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LOWLOWLIMIT 11127 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONCLASSID 11128 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONCLASSNAME 11129 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_INPUTNODE 11130 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONCLASSID 11131 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONCLASSNAME 11132 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_INPUTNODE 11133 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONCLASSID 11134 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONCLASSNAME 11135 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_INPUTNODE 11136 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONCLASSID 11137 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONCLASSNAME 11138 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_INPUTNODE 11139 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONCLASSID 11140 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONCLASSNAME 11141 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_INPUTNODE 11142 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONCLASSID 11143 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONCLASSNAME 11144 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_INPUTNODE 11145 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONCLASSID 11146 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONCLASSNAME 11147 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_INPUTNODE 11148 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONCLASSID 11149 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONCLASSNAME 11150 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_INPUTNODE 11151 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONCLASSID 11152 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONCLASSNAME 11153 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_INPUTNODE 11154 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONCLASSID 11155 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONCLASSNAME 11156 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_INPUTNODE 11157 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_NORMALSTATE 11158 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONCLASSID 11159 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONCLASSNAME 11160 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_INPUTNODE 11161 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_NORMALSTATE 11162 /* Variable */ +#define UA_NS0ID_BASECONDITIONCLASSTYPE 11163 /* ObjectType */ +#define UA_NS0ID_PROCESSCONDITIONCLASSTYPE 11164 /* ObjectType */ +#define UA_NS0ID_MAINTENANCECONDITIONCLASSTYPE 11165 /* ObjectType */ +#define UA_NS0ID_SYSTEMCONDITIONCLASSTYPE 11166 /* ObjectType */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_AGGREGATECONFIGURATION_TREATUNCERTAINASBAD 11168 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_AGGREGATECONFIGURATION_PERCENTDATABAD 11169 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_AGGREGATECONFIGURATION_PERCENTDATAGOOD 11170 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_AGGREGATECONFIGURATION_USESLOPEDEXTRAPOLATION 11171 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_AGGREGATEFUNCTIONS 11172 /* Object */ +#define UA_NS0ID_AGGREGATECONFIGURATIONTYPE 11187 /* ObjectType */ +#define UA_NS0ID_AGGREGATECONFIGURATIONTYPE_TREATUNCERTAINASBAD 11188 /* Variable */ +#define UA_NS0ID_AGGREGATECONFIGURATIONTYPE_PERCENTDATABAD 11189 /* Variable */ +#define UA_NS0ID_AGGREGATECONFIGURATIONTYPE_PERCENTDATAGOOD 11190 /* Variable */ +#define UA_NS0ID_AGGREGATECONFIGURATIONTYPE_USESLOPEDEXTRAPOLATION 11191 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES 11192 /* Object */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_ACCESSHISTORYDATACAPABILITY 11193 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_INSERTDATACAPABILITY 11196 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_REPLACEDATACAPABILITY 11197 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_UPDATEDATACAPABILITY 11198 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_DELETERAWCAPABILITY 11199 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_DELETEATTIMECAPABILITY 11200 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_AGGREGATEFUNCTIONS 11201 /* Object */ +#define UA_NS0ID_HACONFIGURATION 11202 /* Object */ +#define UA_NS0ID_HACONFIGURATION_AGGREGATECONFIGURATION 11203 /* Object */ +#define UA_NS0ID_HACONFIGURATION_AGGREGATECONFIGURATION_TREATUNCERTAINASBAD 11204 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_AGGREGATECONFIGURATION_PERCENTDATABAD 11205 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_AGGREGATECONFIGURATION_PERCENTDATAGOOD 11206 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_AGGREGATECONFIGURATION_USESLOPEDEXTRAPOLATION 11207 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_STEPPED 11208 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_DEFINITION 11209 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_MAXTIMEINTERVAL 11210 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_MINTIMEINTERVAL 11211 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_EXCEPTIONDEVIATION 11212 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_EXCEPTIONDEVIATIONFORMAT 11213 /* Variable */ +#define UA_NS0ID_ANNOTATIONS 11214 /* Variable */ +#define UA_NS0ID_HISTORICALEVENTFILTER 11215 /* Variable */ +#define UA_NS0ID_MODIFICATIONINFO 11216 /* DataType */ +#define UA_NS0ID_HISTORYMODIFIEDDATA 11217 /* DataType */ +#define UA_NS0ID_MODIFICATIONINFO_ENCODING_DEFAULTXML 11218 /* Object */ +#define UA_NS0ID_HISTORYMODIFIEDDATA_ENCODING_DEFAULTXML 11219 /* Object */ +#define UA_NS0ID_MODIFICATIONINFO_ENCODING_DEFAULTBINARY 11226 /* Object */ +#define UA_NS0ID_HISTORYMODIFIEDDATA_ENCODING_DEFAULTBINARY 11227 /* Object */ +#define UA_NS0ID_HISTORYUPDATETYPE 11234 /* DataType */ +#define UA_NS0ID_MULTISTATEVALUEDISCRETETYPE 11238 /* VariableType */ +#define UA_NS0ID_MULTISTATEVALUEDISCRETETYPE_DEFINITION 11239 /* Variable */ +#define UA_NS0ID_MULTISTATEVALUEDISCRETETYPE_VALUEPRECISION 11240 /* Variable */ +#define UA_NS0ID_MULTISTATEVALUEDISCRETETYPE_ENUMVALUES 11241 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_ACCESSHISTORYEVENTSCAPABILITY 11242 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_MAXRETURNDATAVALUES 11268 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_MAXRETURNEVENTVALUES 11269 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_INSERTANNOTATIONCAPABILITY 11270 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_MAXRETURNDATAVALUES 11273 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_MAXRETURNEVENTVALUES 11274 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_INSERTANNOTATIONCAPABILITY 11275 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_INSERTEVENTCAPABILITY 11278 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_REPLACEEVENTCAPABILITY 11279 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_UPDATEEVENTCAPABILITY 11280 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_INSERTEVENTCAPABILITY 11281 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_REPLACEEVENTCAPABILITY 11282 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_UPDATEEVENTCAPABILITY 11283 /* Variable */ +#define UA_NS0ID_AGGREGATEFUNCTION_TIMEAVERAGE2 11285 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MINIMUM2 11286 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MAXIMUM2 11287 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_RANGE2 11288 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_WORSTQUALITY2 11292 /* Object */ +#define UA_NS0ID_PERFORMUPDATETYPE 11293 /* DataType */ +#define UA_NS0ID_UPDATESTRUCTUREDATADETAILS 11295 /* DataType */ +#define UA_NS0ID_UPDATESTRUCTUREDATADETAILS_ENCODING_DEFAULTXML 11296 /* Object */ +#define UA_NS0ID_UPDATESTRUCTUREDATADETAILS_ENCODING_DEFAULTBINARY 11300 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_TOTAL2 11304 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MINIMUMACTUALTIME2 11305 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_MAXIMUMACTUALTIME2 11306 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_DURATIONINSTATEZERO 11307 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_DURATIONINSTATENONZERO 11308 /* Object */ +#define UA_NS0ID_SERVER_SERVERREDUNDANCY_CURRENTSERVERID 11312 /* Variable */ +#define UA_NS0ID_SERVER_SERVERREDUNDANCY_REDUNDANTSERVERARRAY 11313 /* Variable */ +#define UA_NS0ID_SERVER_SERVERREDUNDANCY_SERVERURIARRAY 11314 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVEDTOTIMEDSHELVED_TRANSITIONNUMBER 11322 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_UNSHELVEDTOONESHOTSHELVED_TRANSITIONNUMBER 11323 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVEDTOUNSHELVED_TRANSITIONNUMBER 11324 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_TIMEDSHELVEDTOONESHOTSHELVED_TRANSITIONNUMBER 11325 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_ONESHOTSHELVEDTOUNSHELVED_TRANSITIONNUMBER 11326 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_ONESHOTSHELVEDTOTIMEDSHELVED_TRANSITIONNUMBER 11327 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOWLOWTOLOW_TRANSITIONNUMBER 11340 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LOWTOLOWLOW_TRANSITIONNUMBER 11341 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGHHIGHTOHIGH_TRANSITIONNUMBER 11342 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_HIGHTOHIGHHIGH_TRANSITIONNUMBER 11343 /* Variable */ +#define UA_NS0ID_AGGREGATEFUNCTION_STANDARDDEVIATIONSAMPLE 11426 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_STANDARDDEVIATIONPOPULATION 11427 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_VARIANCESAMPLE 11428 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_VARIANCEPOPULATION 11429 /* Object */ +#define UA_NS0ID_ENUMSTRINGS 11432 /* Variable */ +#define UA_NS0ID_VALUEASTEXT 11433 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE 11436 /* ObjectType */ +#define UA_NS0ID_PROGRESSEVENTTYPE_EVENTID 11437 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_EVENTTYPE 11438 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_SOURCENODE 11439 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_SOURCENAME 11440 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_TIME 11441 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_RECEIVETIME 11442 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_LOCALTIME 11443 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_MESSAGE 11444 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_SEVERITY 11445 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE 11446 /* ObjectType */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_EVENTID 11447 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_EVENTTYPE 11448 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_SOURCENODE 11449 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_SOURCENAME 11450 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_TIME 11451 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_RECEIVETIME 11452 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_LOCALTIME 11453 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_MESSAGE 11454 /* Variable */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_SEVERITY 11455 /* Variable */ +#define UA_NS0ID_TRANSITIONVARIABLETYPE_EFFECTIVETRANSITIONTIME 11456 /* Variable */ +#define UA_NS0ID_FINITETRANSITIONVARIABLETYPE_EFFECTIVETRANSITIONTIME 11457 /* Variable */ +#define UA_NS0ID_STATEMACHINETYPE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11458 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11459 /* Variable */ +#define UA_NS0ID_TRANSITIONEVENTTYPE_TRANSITION_EFFECTIVETRANSITIONTIME 11460 /* Variable */ +#define UA_NS0ID_MULTISTATEVALUEDISCRETETYPE_VALUEASTEXT 11461 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONEVENTTYPE_TRANSITION_EFFECTIVETRANSITIONTIME 11462 /* Variable */ +#define UA_NS0ID_PROGRAMTRANSITIONAUDITEVENTTYPE_TRANSITION_EFFECTIVETRANSITIONTIME 11463 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11464 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11465 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11466 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11467 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11468 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11469 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11470 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11471 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11472 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11473 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11474 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11475 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11476 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11477 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11478 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11479 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11480 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11481 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11482 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11483 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_SECURECHANNELID 11485 /* Variable */ +#define UA_NS0ID_OPTIONSETTYPE 11487 /* VariableType */ +#define UA_NS0ID_OPTIONSETTYPE_OPTIONSETVALUES 11488 /* Variable */ +#define UA_NS0ID_SERVERTYPE_GETMONITOREDITEMS 11489 /* Method */ +#define UA_NS0ID_SERVERTYPE_GETMONITOREDITEMS_INPUTARGUMENTS 11490 /* Variable */ +#define UA_NS0ID_SERVERTYPE_GETMONITOREDITEMS_OUTPUTARGUMENTS 11491 /* Variable */ +#define UA_NS0ID_SERVER_GETMONITOREDITEMS 11492 /* Method */ +#define UA_NS0ID_SERVER_GETMONITOREDITEMS_INPUTARGUMENTS 11493 /* Variable */ +#define UA_NS0ID_SERVER_GETMONITOREDITEMS_OUTPUTARGUMENTS 11494 /* Variable */ +#define UA_NS0ID_GETMONITOREDITEMSMETHODTYPE 11495 /* Method */ +#define UA_NS0ID_GETMONITOREDITEMSMETHODTYPE_INPUTARGUMENTS 11496 /* Variable */ +#define UA_NS0ID_GETMONITOREDITEMSMETHODTYPE_OUTPUTARGUMENTS 11497 /* Variable */ +#define UA_NS0ID_MAXSTRINGLENGTH 11498 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_STARTOFARCHIVE 11499 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_STARTOFONLINEARCHIVE 11500 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_DELETEEVENTCAPABILITY 11501 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_DELETEEVENTCAPABILITY 11502 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_STARTOFARCHIVE 11503 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_STARTOFONLINEARCHIVE 11504 /* Variable */ +#define UA_NS0ID_AGGREGATEFUNCTION_STARTBOUND 11505 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_ENDBOUND 11506 /* Object */ +#define UA_NS0ID_AGGREGATEFUNCTION_DELTABOUNDS 11507 /* Object */ +#define UA_NS0ID_MODELLINGRULE_OPTIONALPLACEHOLDER 11508 /* Object */ +#define UA_NS0ID_MODELLINGRULE_OPTIONALPLACEHOLDER_NAMINGRULE 11509 /* Variable */ +#define UA_NS0ID_MODELLINGRULE_MANDATORYPLACEHOLDER 11510 /* Object */ +#define UA_NS0ID_MODELLINGRULE_MANDATORYPLACEHOLDER_NAMINGRULE 11511 /* Variable */ +#define UA_NS0ID_MAXARRAYLENGTH 11512 /* Variable */ +#define UA_NS0ID_ENGINEERINGUNITS 11513 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MAXARRAYLENGTH 11514 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MAXSTRINGLENGTH 11515 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS 11516 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERREAD 11517 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERWRITE 11519 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERMETHODCALL 11521 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERBROWSE 11522 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERREGISTERNODES 11523 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERTRANSLATEBROWSEPATHSTONODEIDS 11524 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERNODEMANAGEMENT 11525 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXMONITOREDITEMSPERCALL 11526 /* Variable */ +#define UA_NS0ID_SERVERTYPE_NAMESPACES 11527 /* Object */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MAXARRAYLENGTH 11549 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MAXSTRINGLENGTH 11550 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS 11551 /* Object */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERREAD 11552 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERWRITE 11554 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERMETHODCALL 11556 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERBROWSE 11557 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERREGISTERNODES 11558 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERTRANSLATEBROWSEPATHSTONODEIDS 11559 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERNODEMANAGEMENT 11560 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXMONITOREDITEMSPERCALL 11561 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_VENDORCAPABILITY_PLACEHOLDER 11562 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE 11564 /* ObjectType */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERREAD 11565 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERWRITE 11567 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERMETHODCALL 11569 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERBROWSE 11570 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERREGISTERNODES 11571 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERTRANSLATEBROWSEPATHSTONODEIDS 11572 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERNODEMANAGEMENT 11573 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXMONITOREDITEMSPERCALL 11574 /* Variable */ +#define UA_NS0ID_FILETYPE 11575 /* ObjectType */ +#define UA_NS0ID_FILETYPE_SIZE 11576 /* Variable */ +#define UA_NS0ID_FILETYPE_OPENCOUNT 11579 /* Variable */ +#define UA_NS0ID_FILETYPE_OPEN 11580 /* Method */ +#define UA_NS0ID_FILETYPE_OPEN_INPUTARGUMENTS 11581 /* Variable */ +#define UA_NS0ID_FILETYPE_OPEN_OUTPUTARGUMENTS 11582 /* Variable */ +#define UA_NS0ID_FILETYPE_CLOSE 11583 /* Method */ +#define UA_NS0ID_FILETYPE_CLOSE_INPUTARGUMENTS 11584 /* Variable */ +#define UA_NS0ID_FILETYPE_READ 11585 /* Method */ +#define UA_NS0ID_FILETYPE_READ_INPUTARGUMENTS 11586 /* Variable */ +#define UA_NS0ID_FILETYPE_READ_OUTPUTARGUMENTS 11587 /* Variable */ +#define UA_NS0ID_FILETYPE_WRITE 11588 /* Method */ +#define UA_NS0ID_FILETYPE_WRITE_INPUTARGUMENTS 11589 /* Variable */ +#define UA_NS0ID_FILETYPE_GETPOSITION 11590 /* Method */ +#define UA_NS0ID_FILETYPE_GETPOSITION_INPUTARGUMENTS 11591 /* Variable */ +#define UA_NS0ID_FILETYPE_GETPOSITION_OUTPUTARGUMENTS 11592 /* Variable */ +#define UA_NS0ID_FILETYPE_SETPOSITION 11593 /* Method */ +#define UA_NS0ID_FILETYPE_SETPOSITION_INPUTARGUMENTS 11594 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE 11595 /* ObjectType */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_SIZE 11596 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_OPENCOUNT 11599 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_OPEN 11600 /* Method */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_OPEN_INPUTARGUMENTS 11601 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_OPEN_OUTPUTARGUMENTS 11602 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_CLOSE 11603 /* Method */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_CLOSE_INPUTARGUMENTS 11604 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_READ 11605 /* Method */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_READ_INPUTARGUMENTS 11606 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_READ_OUTPUTARGUMENTS 11607 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_WRITE 11608 /* Method */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_WRITE_INPUTARGUMENTS 11609 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_GETPOSITION 11610 /* Method */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_GETPOSITION_INPUTARGUMENTS 11611 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_GETPOSITION_OUTPUTARGUMENTS 11612 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_SETPOSITION 11613 /* Method */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_SETPOSITION_INPUTARGUMENTS 11614 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_EXPORTNAMESPACE 11615 /* Method */ +#define UA_NS0ID_NAMESPACEMETADATATYPE 11616 /* ObjectType */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEURI 11617 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEVERSION 11618 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEPUBLICATIONDATE 11619 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_ISNAMESPACESUBSET 11620 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_STATICNODEIDTYPES 11621 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_STATICNUMERICNODEIDRANGE 11622 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_STATICSTRINGNODEIDPATTERN 11623 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE 11624 /* Object */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_SIZE 11625 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_OPENCOUNT 11628 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_OPEN 11629 /* Method */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_OPEN_INPUTARGUMENTS 11630 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_OPEN_OUTPUTARGUMENTS 11631 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_CLOSE 11632 /* Method */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_CLOSE_INPUTARGUMENTS 11633 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_READ 11634 /* Method */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_READ_INPUTARGUMENTS 11635 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_READ_OUTPUTARGUMENTS 11636 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_WRITE 11637 /* Method */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_WRITE_INPUTARGUMENTS 11638 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_GETPOSITION 11639 /* Method */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_GETPOSITION_INPUTARGUMENTS 11640 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_GETPOSITION_OUTPUTARGUMENTS 11641 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_SETPOSITION 11642 /* Method */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_SETPOSITION_INPUTARGUMENTS 11643 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_EXPORTNAMESPACE 11644 /* Method */ +#define UA_NS0ID_NAMESPACESTYPE 11645 /* ObjectType */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER 11646 /* Object */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEURI 11647 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEVERSION 11648 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEPUBLICATIONDATE 11649 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_ISNAMESPACESUBSET 11650 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_STATICNODEIDTYPES 11651 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_STATICNUMERICNODEIDRANGE 11652 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_STATICSTRINGNODEIDPATTERN 11653 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE 11654 /* Object */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_SIZE 11655 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_OPENCOUNT 11658 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_OPEN 11659 /* Method */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_OPEN_INPUTARGUMENTS 11660 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_OPEN_OUTPUTARGUMENTS 11661 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_CLOSE 11662 /* Method */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_CLOSE_INPUTARGUMENTS 11663 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_READ 11664 /* Method */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_READ_INPUTARGUMENTS 11665 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_READ_OUTPUTARGUMENTS 11666 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_WRITE 11667 /* Method */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_WRITE_INPUTARGUMENTS 11668 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_GETPOSITION 11669 /* Method */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_GETPOSITION_INPUTARGUMENTS 11670 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_GETPOSITION_OUTPUTARGUMENTS 11671 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_SETPOSITION 11672 /* Method */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_SETPOSITION_INPUTARGUMENTS 11673 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_EXPORTNAMESPACE 11674 /* Method */ +#define UA_NS0ID_SYSTEMSTATUSCHANGEEVENTTYPE_SYSTEMSTATE 11696 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSTYPE_SAMPLEDMONITOREDITEMSCOUNT 11697 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSTYPE_MAXSAMPLEDMONITOREDITEMSCOUNT 11698 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSTYPE_DISABLEDMONITOREDITEMSSAMPLINGCOUNT 11699 /* Variable */ +#define UA_NS0ID_OPTIONSETTYPE_BITMASK 11701 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXARRAYLENGTH 11702 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXSTRINGLENGTH 11703 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS 11704 /* Object */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERREAD 11705 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERWRITE 11707 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERMETHODCALL 11709 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERBROWSE 11710 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERREGISTERNODES 11711 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERTRANSLATEBROWSEPATHSTONODEIDS 11712 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERNODEMANAGEMENT 11713 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXMONITOREDITEMSPERCALL 11714 /* Variable */ +#define UA_NS0ID_SERVER_NAMESPACES 11715 /* Object */ +#define UA_NS0ID_BITFIELDMASKDATATYPE 11737 /* DataType */ +#define UA_NS0ID_OPENMETHODTYPE 11738 /* Method */ +#define UA_NS0ID_OPENMETHODTYPE_INPUTARGUMENTS 11739 /* Variable */ +#define UA_NS0ID_OPENMETHODTYPE_OUTPUTARGUMENTS 11740 /* Variable */ +#define UA_NS0ID_CLOSEMETHODTYPE 11741 /* Method */ +#define UA_NS0ID_CLOSEMETHODTYPE_INPUTARGUMENTS 11742 /* Variable */ +#define UA_NS0ID_READMETHODTYPE 11743 /* Method */ +#define UA_NS0ID_READMETHODTYPE_INPUTARGUMENTS 11744 /* Variable */ +#define UA_NS0ID_READMETHODTYPE_OUTPUTARGUMENTS 11745 /* Variable */ +#define UA_NS0ID_WRITEMETHODTYPE 11746 /* Method */ +#define UA_NS0ID_WRITEMETHODTYPE_INPUTARGUMENTS 11747 /* Variable */ +#define UA_NS0ID_GETPOSITIONMETHODTYPE 11748 /* Method */ +#define UA_NS0ID_GETPOSITIONMETHODTYPE_INPUTARGUMENTS 11749 /* Variable */ +#define UA_NS0ID_GETPOSITIONMETHODTYPE_OUTPUTARGUMENTS 11750 /* Variable */ +#define UA_NS0ID_SETPOSITIONMETHODTYPE 11751 /* Method */ +#define UA_NS0ID_SETPOSITIONMETHODTYPE_INPUTARGUMENTS 11752 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE 11753 /* ObjectType */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_EVENTID 11754 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_EVENTTYPE 11755 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SOURCENODE 11756 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SOURCENAME 11757 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_TIME 11758 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_RECEIVETIME 11759 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LOCALTIME 11760 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_MESSAGE 11761 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SEVERITY 11762 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONCLASSID 11763 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONCLASSNAME 11764 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONNAME 11765 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_BRANCHID 11766 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_RETAIN 11767 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE 11768 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_ID 11769 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_NAME 11770 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_NUMBER 11771 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 11772 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 11773 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 11774 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_TRUESTATE 11775 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLEDSTATE_FALSESTATE 11776 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_QUALITY 11777 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_QUALITY_SOURCETIMESTAMP 11778 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LASTSEVERITY 11779 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 11780 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_COMMENT 11781 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_COMMENT_SOURCETIMESTAMP 11782 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CLIENTUSERID 11783 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_DISABLE 11784 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ENABLE 11785 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ADDCOMMENT 11786 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 11787 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONREFRESH 11788 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 11789 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE 11790 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_ID 11791 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_NAME 11792 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_NUMBER 11793 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 11794 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_TRANSITIONTIME 11795 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 11796 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_TRUESTATE 11797 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKEDSTATE_FALSESTATE 11798 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE 11799 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_ID 11800 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_NAME 11801 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_NUMBER 11802 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 11803 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 11804 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 11805 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_TRUESTATE 11806 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRMEDSTATE_FALSESTATE 11807 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKNOWLEDGE 11808 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 11809 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRM 11810 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONFIRM_INPUTARGUMENTS 11811 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE 11812 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_ID 11813 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_NAME 11814 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_NUMBER 11815 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 11816 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_TRANSITIONTIME 11817 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 11818 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_TRUESTATE 11819 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ACTIVESTATE_FALSESTATE 11820 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_INPUTNODE 11821 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE 11822 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_ID 11823 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_NAME 11824 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_NUMBER 11825 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 11826 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 11827 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 11828 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 11829 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 11830 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE 11831 /* Object */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE 11832 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 11833 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 11834 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 11835 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 11836 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION 11837 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 11838 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 11839 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 11840 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 11841 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 11842 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_UNSHELVETIME 11843 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_UNSHELVE 11844 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 11845 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 11846 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 11847 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESSEDORSHELVED 11848 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_MAXTIMESHELVED 11849 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_NORMALSTATE 11850 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_COMMENT 11851 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESPONDEVENTTYPE_SELECTEDRESPONSE 11852 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_COMMENT 11853 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_COMMENT 11854 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSHELVINGEVENTTYPE_SHELVINGTIME 11855 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE 11856 /* ObjectType */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_EVENTID 11857 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_EVENTTYPE 11858 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_SOURCENODE 11859 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_SOURCENAME 11860 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_TIME 11861 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_RECEIVETIME 11862 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_LOCALTIME 11863 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_MESSAGE 11864 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_SEVERITY 11865 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_ACTIONTIMESTAMP 11866 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_STATUS 11867 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_SERVERID 11868 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_CLIENTAUDITENTRYID 11869 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_CLIENTUSERID 11870 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_METHODID 11871 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_INPUTARGUMENTS 11872 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_OLDSTATEID 11873 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_NEWSTATEID 11874 /* Variable */ +#define UA_NS0ID_AUDITPROGRAMTRANSITIONEVENTTYPE_TRANSITIONNUMBER 11875 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_AGGREGATEFUNCTIONS 11876 /* Object */ +#define UA_NS0ID_HACONFIGURATION_AGGREGATEFUNCTIONS 11877 /* Object */ +#define UA_NS0ID_NODECLASS_ENUMVALUES 11878 /* Variable */ +#define UA_NS0ID_INSTANCENODE 11879 /* DataType */ +#define UA_NS0ID_TYPENODE 11880 /* DataType */ +#define UA_NS0ID_NODEATTRIBUTESMASK_ENUMVALUES 11881 /* Variable */ +#define UA_NS0ID_BROWSERESULTMASK_ENUMVALUES 11883 /* Variable */ +#define UA_NS0ID_HISTORYUPDATETYPE_ENUMVALUES 11884 /* Variable */ +#define UA_NS0ID_PERFORMUPDATETYPE_ENUMVALUES 11885 /* Variable */ +#define UA_NS0ID_INSTANCENODE_ENCODING_DEFAULTXML 11887 /* Object */ +#define UA_NS0ID_TYPENODE_ENCODING_DEFAULTXML 11888 /* Object */ +#define UA_NS0ID_INSTANCENODE_ENCODING_DEFAULTBINARY 11889 /* Object */ +#define UA_NS0ID_TYPENODE_ENCODING_DEFAULTBINARY 11890 /* Object */ +#define UA_NS0ID_SESSIONDIAGNOSTICSOBJECTTYPE_SESSIONDIAGNOSTICS_UNAUTHORIZEDREQUESTCOUNT 11891 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSVARIABLETYPE_UNAUTHORIZEDREQUESTCOUNT 11892 /* Variable */ +#define UA_NS0ID_OPENFILEMODE 11939 /* DataType */ +#define UA_NS0ID_OPENFILEMODE_ENUMVALUES 11940 /* Variable */ +#define UA_NS0ID_MODELCHANGESTRUCTUREVERBMASK 11941 /* DataType */ +#define UA_NS0ID_MODELCHANGESTRUCTUREVERBMASK_ENUMVALUES 11942 /* Variable */ +#define UA_NS0ID_ENDPOINTURLLISTDATATYPE 11943 /* DataType */ +#define UA_NS0ID_NETWORKGROUPDATATYPE 11944 /* DataType */ +#define UA_NS0ID_NONTRANSPARENTNETWORKREDUNDANCYTYPE 11945 /* ObjectType */ +#define UA_NS0ID_NONTRANSPARENTNETWORKREDUNDANCYTYPE_REDUNDANCYSUPPORT 11946 /* Variable */ +#define UA_NS0ID_NONTRANSPARENTNETWORKREDUNDANCYTYPE_SERVERURIARRAY 11947 /* Variable */ +#define UA_NS0ID_NONTRANSPARENTNETWORKREDUNDANCYTYPE_SERVERNETWORKGROUPS 11948 /* Variable */ +#define UA_NS0ID_ENDPOINTURLLISTDATATYPE_ENCODING_DEFAULTXML 11949 /* Object */ +#define UA_NS0ID_NETWORKGROUPDATATYPE_ENCODING_DEFAULTXML 11950 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTURLLISTDATATYPE 11951 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTURLLISTDATATYPE_DATATYPEVERSION 11952 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTURLLISTDATATYPE_DICTIONARYFRAGMENT 11953 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKGROUPDATATYPE 11954 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKGROUPDATATYPE_DATATYPEVERSION 11955 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKGROUPDATATYPE_DICTIONARYFRAGMENT 11956 /* Variable */ +#define UA_NS0ID_ENDPOINTURLLISTDATATYPE_ENCODING_DEFAULTBINARY 11957 /* Object */ +#define UA_NS0ID_NETWORKGROUPDATATYPE_ENCODING_DEFAULTBINARY 11958 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTURLLISTDATATYPE 11959 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTURLLISTDATATYPE_DATATYPEVERSION 11960 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTURLLISTDATATYPE_DICTIONARYFRAGMENT 11961 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKGROUPDATATYPE 11962 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKGROUPDATATYPE_DATATYPEVERSION 11963 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKGROUPDATATYPE_DICTIONARYFRAGMENT 11964 /* Variable */ +#define UA_NS0ID_ARRAYITEMTYPE 12021 /* VariableType */ +#define UA_NS0ID_ARRAYITEMTYPE_DEFINITION 12022 /* Variable */ +#define UA_NS0ID_ARRAYITEMTYPE_VALUEPRECISION 12023 /* Variable */ +#define UA_NS0ID_ARRAYITEMTYPE_INSTRUMENTRANGE 12024 /* Variable */ +#define UA_NS0ID_ARRAYITEMTYPE_EURANGE 12025 /* Variable */ +#define UA_NS0ID_ARRAYITEMTYPE_ENGINEERINGUNITS 12026 /* Variable */ +#define UA_NS0ID_ARRAYITEMTYPE_TITLE 12027 /* Variable */ +#define UA_NS0ID_ARRAYITEMTYPE_AXISSCALETYPE 12028 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE 12029 /* VariableType */ +#define UA_NS0ID_YARRAYITEMTYPE_DEFINITION 12030 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE_VALUEPRECISION 12031 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE_INSTRUMENTRANGE 12032 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE_EURANGE 12033 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE_ENGINEERINGUNITS 12034 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE_TITLE 12035 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE_AXISSCALETYPE 12036 /* Variable */ +#define UA_NS0ID_YARRAYITEMTYPE_XAXISDEFINITION 12037 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE 12038 /* VariableType */ +#define UA_NS0ID_XYARRAYITEMTYPE_DEFINITION 12039 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE_VALUEPRECISION 12040 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE_INSTRUMENTRANGE 12041 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE_EURANGE 12042 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE_ENGINEERINGUNITS 12043 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE_TITLE 12044 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE_AXISSCALETYPE 12045 /* Variable */ +#define UA_NS0ID_XYARRAYITEMTYPE_XAXISDEFINITION 12046 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE 12047 /* VariableType */ +#define UA_NS0ID_IMAGEITEMTYPE_DEFINITION 12048 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_VALUEPRECISION 12049 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_INSTRUMENTRANGE 12050 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_EURANGE 12051 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_ENGINEERINGUNITS 12052 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_TITLE 12053 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_AXISSCALETYPE 12054 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_XAXISDEFINITION 12055 /* Variable */ +#define UA_NS0ID_IMAGEITEMTYPE_YAXISDEFINITION 12056 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE 12057 /* VariableType */ +#define UA_NS0ID_CUBEITEMTYPE_DEFINITION 12058 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_VALUEPRECISION 12059 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_INSTRUMENTRANGE 12060 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_EURANGE 12061 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_ENGINEERINGUNITS 12062 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_TITLE 12063 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_AXISSCALETYPE 12064 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_XAXISDEFINITION 12065 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_YAXISDEFINITION 12066 /* Variable */ +#define UA_NS0ID_CUBEITEMTYPE_ZAXISDEFINITION 12067 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE 12068 /* VariableType */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_DEFINITION 12069 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_VALUEPRECISION 12070 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_INSTRUMENTRANGE 12071 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_EURANGE 12072 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_ENGINEERINGUNITS 12073 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_TITLE 12074 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_AXISSCALETYPE 12075 /* Variable */ +#define UA_NS0ID_NDIMENSIONARRAYITEMTYPE_AXISDEFINITION 12076 /* Variable */ +#define UA_NS0ID_AXISSCALEENUMERATION 12077 /* DataType */ +#define UA_NS0ID_AXISSCALEENUMERATION_ENUMSTRINGS 12078 /* Variable */ +#define UA_NS0ID_AXISINFORMATION 12079 /* DataType */ +#define UA_NS0ID_XVTYPE 12080 /* DataType */ +#define UA_NS0ID_AXISINFORMATION_ENCODING_DEFAULTXML 12081 /* Object */ +#define UA_NS0ID_XVTYPE_ENCODING_DEFAULTXML 12082 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_AXISINFORMATION 12083 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_AXISINFORMATION_DATATYPEVERSION 12084 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_AXISINFORMATION_DICTIONARYFRAGMENT 12085 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_XVTYPE 12086 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_XVTYPE_DATATYPEVERSION 12087 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_XVTYPE_DICTIONARYFRAGMENT 12088 /* Variable */ +#define UA_NS0ID_AXISINFORMATION_ENCODING_DEFAULTBINARY 12089 /* Object */ +#define UA_NS0ID_XVTYPE_ENCODING_DEFAULTBINARY 12090 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_AXISINFORMATION 12091 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_AXISINFORMATION_DATATYPEVERSION 12092 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_AXISINFORMATION_DICTIONARYFRAGMENT 12093 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_XVTYPE 12094 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_XVTYPE_DATATYPEVERSION 12095 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_XVTYPE_DICTIONARYFRAGMENT 12096 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER 12097 /* Object */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS 12098 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_SESSIONID 12099 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_SESSIONNAME 12100 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CLIENTDESCRIPTION 12101 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_SERVERURI 12102 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_ENDPOINTURL 12103 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_LOCALEIDS 12104 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_ACTUALSESSIONTIMEOUT 12105 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_MAXRESPONSEMESSAGESIZE 12106 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CLIENTCONNECTIONTIME 12107 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CLIENTLASTCONTACTTIME 12108 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CURRENTSUBSCRIPTIONSCOUNT 12109 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CURRENTMONITOREDITEMSCOUNT 12110 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CURRENTPUBLISHREQUESTSINQUEUE 12111 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_TOTALREQUESTCOUNT 12112 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_UNAUTHORIZEDREQUESTCOUNT 12113 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_READCOUNT 12114 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_HISTORYREADCOUNT 12115 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_WRITECOUNT 12116 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_HISTORYUPDATECOUNT 12117 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CALLCOUNT 12118 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CREATEMONITOREDITEMSCOUNT 12119 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_MODIFYMONITOREDITEMSCOUNT 12120 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_SETMONITORINGMODECOUNT 12121 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_SETTRIGGERINGCOUNT 12122 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_DELETEMONITOREDITEMSCOUNT 12123 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_CREATESUBSCRIPTIONCOUNT 12124 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_MODIFYSUBSCRIPTIONCOUNT 12125 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_SETPUBLISHINGMODECOUNT 12126 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_PUBLISHCOUNT 12127 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_REPUBLISHCOUNT 12128 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_TRANSFERSUBSCRIPTIONSCOUNT 12129 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_DELETESUBSCRIPTIONSCOUNT 12130 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_ADDNODESCOUNT 12131 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_ADDREFERENCESCOUNT 12132 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_DELETENODESCOUNT 12133 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_DELETEREFERENCESCOUNT 12134 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_BROWSECOUNT 12135 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_BROWSENEXTCOUNT 12136 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_TRANSLATEBROWSEPATHSTONODEIDSCOUNT 12137 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_QUERYFIRSTCOUNT 12138 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_QUERYNEXTCOUNT 12139 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_REGISTERNODESCOUNT 12140 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONDIAGNOSTICS_UNREGISTERNODESCOUNT 12141 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS 12142 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_SESSIONID 12143 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_CLIENTUSERIDOFSESSION 12144 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_CLIENTUSERIDHISTORY 12145 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_AUTHENTICATIONMECHANISM 12146 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_ENCODING 12147 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_TRANSPORTPROTOCOL 12148 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_SECURITYMODE 12149 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_SECURITYPOLICYURI 12150 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SESSIONSECURITYDIAGNOSTICS_CLIENTCERTIFICATE 12151 /* Variable */ +#define UA_NS0ID_SESSIONSDIAGNOSTICSSUMMARYTYPE_CLIENTNAME_PLACEHOLDER_SUBSCRIPTIONDIAGNOSTICSARRAY 12152 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYREADDATA 12153 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYREADEVENTS 12154 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEDATA 12155 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEEVENTS 12156 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERHISTORYREADDATA 12157 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERHISTORYREADEVENTS 12158 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEDATA 12159 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEEVENTS 12160 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERHISTORYREADDATA 12161 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERHISTORYREADEVENTS 12162 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERHISTORYUPDATEDATA 12163 /* Variable */ +#define UA_NS0ID_OPERATIONLIMITSTYPE_MAXNODESPERHISTORYUPDATEEVENTS 12164 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYREADDATA 12165 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYREADEVENTS 12166 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEDATA 12167 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_OPERATIONLIMITS_MAXNODESPERHISTORYUPDATEEVENTS 12168 /* Variable */ +#define UA_NS0ID_NAMINGRULETYPE_ENUMVALUES 12169 /* Variable */ +#define UA_NS0ID_VIEWVERSION 12170 /* Variable */ +#define UA_NS0ID_COMPLEXNUMBERTYPE 12171 /* DataType */ +#define UA_NS0ID_DOUBLECOMPLEXNUMBERTYPE 12172 /* DataType */ +#define UA_NS0ID_COMPLEXNUMBERTYPE_ENCODING_DEFAULTXML 12173 /* Object */ +#define UA_NS0ID_DOUBLECOMPLEXNUMBERTYPE_ENCODING_DEFAULTXML 12174 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_COMPLEXNUMBERTYPE 12175 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_COMPLEXNUMBERTYPE_DATATYPEVERSION 12176 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_COMPLEXNUMBERTYPE_DICTIONARYFRAGMENT 12177 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DOUBLECOMPLEXNUMBERTYPE 12178 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DOUBLECOMPLEXNUMBERTYPE_DATATYPEVERSION 12179 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DOUBLECOMPLEXNUMBERTYPE_DICTIONARYFRAGMENT 12180 /* Variable */ +#define UA_NS0ID_COMPLEXNUMBERTYPE_ENCODING_DEFAULTBINARY 12181 /* Object */ +#define UA_NS0ID_DOUBLECOMPLEXNUMBERTYPE_ENCODING_DEFAULTBINARY 12182 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_COMPLEXNUMBERTYPE 12183 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_COMPLEXNUMBERTYPE_DATATYPEVERSION 12184 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_COMPLEXNUMBERTYPE_DICTIONARYFRAGMENT 12185 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DOUBLECOMPLEXNUMBERTYPE 12186 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DOUBLECOMPLEXNUMBERTYPE_DATATYPEVERSION 12187 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DOUBLECOMPLEXNUMBERTYPE_DICTIONARYFRAGMENT 12188 /* Variable */ +#define UA_NS0ID_SERVERONNETWORK 12189 /* DataType */ +#define UA_NS0ID_FINDSERVERSONNETWORKREQUEST 12190 /* DataType */ +#define UA_NS0ID_FINDSERVERSONNETWORKRESPONSE 12191 /* DataType */ +#define UA_NS0ID_REGISTERSERVER2REQUEST 12193 /* DataType */ +#define UA_NS0ID_REGISTERSERVER2RESPONSE 12194 /* DataType */ +#define UA_NS0ID_SERVERONNETWORK_ENCODING_DEFAULTXML 12195 /* Object */ +#define UA_NS0ID_FINDSERVERSONNETWORKREQUEST_ENCODING_DEFAULTXML 12196 /* Object */ +#define UA_NS0ID_FINDSERVERSONNETWORKRESPONSE_ENCODING_DEFAULTXML 12197 /* Object */ +#define UA_NS0ID_REGISTERSERVER2REQUEST_ENCODING_DEFAULTXML 12199 /* Object */ +#define UA_NS0ID_REGISTERSERVER2RESPONSE_ENCODING_DEFAULTXML 12200 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERONNETWORK 12201 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERONNETWORK_DATATYPEVERSION 12202 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SERVERONNETWORK_DICTIONARYFRAGMENT 12203 /* Variable */ +#define UA_NS0ID_SERVERONNETWORK_ENCODING_DEFAULTBINARY 12207 /* Object */ +#define UA_NS0ID_FINDSERVERSONNETWORKREQUEST_ENCODING_DEFAULTBINARY 12208 /* Object */ +#define UA_NS0ID_FINDSERVERSONNETWORKRESPONSE_ENCODING_DEFAULTBINARY 12209 /* Object */ +#define UA_NS0ID_REGISTERSERVER2REQUEST_ENCODING_DEFAULTBINARY 12211 /* Object */ +#define UA_NS0ID_REGISTERSERVER2RESPONSE_ENCODING_DEFAULTBINARY 12212 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERONNETWORK 12213 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERONNETWORK_DATATYPEVERSION 12214 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SERVERONNETWORK_DICTIONARYFRAGMENT 12215 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_CONTEXT 12502 /* Variable */ +#define UA_NS0ID_PROGRESSEVENTTYPE_PROGRESS 12503 /* Variable */ +#define UA_NS0ID_OPENWITHMASKSMETHODTYPE 12513 /* Method */ +#define UA_NS0ID_OPENWITHMASKSMETHODTYPE_INPUTARGUMENTS 12514 /* Variable */ +#define UA_NS0ID_OPENWITHMASKSMETHODTYPE_OUTPUTARGUMENTS 12515 /* Variable */ +#define UA_NS0ID_CLOSEANDUPDATEMETHODTYPE 12516 /* Method */ +#define UA_NS0ID_CLOSEANDUPDATEMETHODTYPE_OUTPUTARGUMENTS 12517 /* Variable */ +#define UA_NS0ID_ADDCERTIFICATEMETHODTYPE 12518 /* Method */ +#define UA_NS0ID_ADDCERTIFICATEMETHODTYPE_INPUTARGUMENTS 12519 /* Variable */ +#define UA_NS0ID_REMOVECERTIFICATEMETHODTYPE 12520 /* Method */ +#define UA_NS0ID_REMOVECERTIFICATEMETHODTYPE_INPUTARGUMENTS 12521 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE 12522 /* ObjectType */ +#define UA_NS0ID_TRUSTLISTTYPE_SIZE 12523 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_OPENCOUNT 12526 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_OPEN 12527 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_OPEN_INPUTARGUMENTS 12528 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_OPEN_OUTPUTARGUMENTS 12529 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_CLOSE 12530 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_CLOSE_INPUTARGUMENTS 12531 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_READ 12532 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_READ_INPUTARGUMENTS 12533 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_READ_OUTPUTARGUMENTS 12534 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_WRITE 12535 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_WRITE_INPUTARGUMENTS 12536 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_GETPOSITION 12537 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_GETPOSITION_INPUTARGUMENTS 12538 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_GETPOSITION_OUTPUTARGUMENTS 12539 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_SETPOSITION 12540 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_SETPOSITION_INPUTARGUMENTS 12541 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_LASTUPDATETIME 12542 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_OPENWITHMASKS 12543 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_OPENWITHMASKS_INPUTARGUMENTS 12544 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_OPENWITHMASKS_OUTPUTARGUMENTS 12545 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_CLOSEANDUPDATE 12546 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_CLOSEANDUPDATE_OUTPUTARGUMENTS 12547 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_ADDCERTIFICATE 12548 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_ADDCERTIFICATE_INPUTARGUMENTS 12549 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_REMOVECERTIFICATE 12550 /* Method */ +#define UA_NS0ID_TRUSTLISTTYPE_REMOVECERTIFICATE_INPUTARGUMENTS 12551 /* Variable */ +#define UA_NS0ID_TRUSTLISTMASKS 12552 /* DataType */ +#define UA_NS0ID_TRUSTLISTMASKS_ENUMVALUES 12553 /* Variable */ +#define UA_NS0ID_TRUSTLISTDATATYPE 12554 /* DataType */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE 12555 /* ObjectType */ +#define UA_NS0ID_CERTIFICATETYPE 12556 /* ObjectType */ +#define UA_NS0ID_APPLICATIONCERTIFICATETYPE 12557 /* ObjectType */ +#define UA_NS0ID_HTTPSCERTIFICATETYPE 12558 /* ObjectType */ +#define UA_NS0ID_RSAMINAPPLICATIONCERTIFICATETYPE 12559 /* ObjectType */ +#define UA_NS0ID_RSASHA256APPLICATIONCERTIFICATETYPE 12560 /* ObjectType */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE 12561 /* ObjectType */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_EVENTID 12562 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_EVENTTYPE 12563 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_SOURCENODE 12564 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_SOURCENAME 12565 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_TIME 12566 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_RECEIVETIME 12567 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_LOCALTIME 12568 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_MESSAGE 12569 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_SEVERITY 12570 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_ACTIONTIMESTAMP 12571 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_STATUS 12572 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_SERVERID 12573 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_CLIENTAUDITENTRYID 12574 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_CLIENTUSERID 12575 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_METHODID 12576 /* Variable */ +#define UA_NS0ID_TRUSTLISTUPDATEDAUDITEVENTTYPE_INPUTARGUMENTS 12577 /* Variable */ +#define UA_NS0ID_UPDATECERTIFICATEMETHODTYPE 12578 /* Method */ +#define UA_NS0ID_UPDATECERTIFICATEMETHODTYPE_INPUTARGUMENTS 12579 /* Variable */ +#define UA_NS0ID_UPDATECERTIFICATEMETHODTYPE_OUTPUTARGUMENTS 12580 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE 12581 /* ObjectType */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_SUPPORTEDPRIVATEKEYFORMATS 12583 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_MAXTRUSTLISTSIZE 12584 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_MULTICASTDNSENABLED 12585 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_UPDATECERTIFICATE 12616 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_UPDATECERTIFICATE_INPUTARGUMENTS 12617 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_UPDATECERTIFICATE_OUTPUTARGUMENTS 12618 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE 12620 /* ObjectType */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_EVENTID 12621 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_EVENTTYPE 12622 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_SOURCENODE 12623 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_SOURCENAME 12624 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_TIME 12625 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_RECEIVETIME 12626 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_LOCALTIME 12627 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_MESSAGE 12628 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_SEVERITY 12629 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_ACTIONTIMESTAMP 12630 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_STATUS 12631 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_SERVERID 12632 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_CLIENTAUDITENTRYID 12633 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_CLIENTUSERID 12634 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_METHODID 12635 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_INPUTARGUMENTS 12636 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION 12637 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_SUPPORTEDPRIVATEKEYFORMATS 12639 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_MAXTRUSTLISTSIZE 12640 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_MULTICASTDNSENABLED 12641 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST 12642 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SIZE 12643 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENCOUNT 12646 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN 12647 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 12648 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 12649 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSE 12650 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 12651 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ 12652 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ_INPUTARGUMENTS 12653 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 12654 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITE 12655 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 12656 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION 12657 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 12658 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 12659 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SETPOSITION 12660 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 12661 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_LASTUPDATETIME 12662 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS 12663 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 12664 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 12665 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE 12666 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 12667 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_ADDCERTIFICATE 12668 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 12669 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_REMOVECERTIFICATE 12670 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 12671 /* Variable */ +#define UA_NS0ID_TRUSTLISTDATATYPE_ENCODING_DEFAULTXML 12676 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TRUSTLISTDATATYPE 12677 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TRUSTLISTDATATYPE_DATATYPEVERSION 12678 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TRUSTLISTDATATYPE_DICTIONARYFRAGMENT 12679 /* Variable */ +#define UA_NS0ID_TRUSTLISTDATATYPE_ENCODING_DEFAULTBINARY 12680 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TRUSTLISTDATATYPE 12681 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TRUSTLISTDATATYPE_DATATYPEVERSION 12682 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TRUSTLISTDATATYPE_DICTIONARYFRAGMENT 12683 /* Variable */ +#define UA_NS0ID_FILETYPE_WRITABLE 12686 /* Variable */ +#define UA_NS0ID_FILETYPE_USERWRITABLE 12687 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_WRITABLE 12688 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_USERWRITABLE 12689 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_WRITABLE 12690 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_USERWRITABLE 12691 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_WRITABLE 12692 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_USERWRITABLE 12693 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_WRITABLE 12698 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_USERWRITABLE 12699 /* Variable */ +#define UA_NS0ID_CLOSEANDUPDATEMETHODTYPE_INPUTARGUMENTS 12704 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_CLOSEANDUPDATE_INPUTARGUMENTS 12705 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_SERVERCAPABILITIES 12708 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_SERVERCAPABILITIES 12710 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RELATIVEPATHELEMENT 12712 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RELATIVEPATHELEMENT_DATATYPEVERSION 12713 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RELATIVEPATHELEMENT_DICTIONARYFRAGMENT 12714 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RELATIVEPATH 12715 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RELATIVEPATH_DATATYPEVERSION 12716 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RELATIVEPATH_DICTIONARYFRAGMENT 12717 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RELATIVEPATHELEMENT 12718 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RELATIVEPATHELEMENT_DATATYPEVERSION 12719 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RELATIVEPATHELEMENT_DICTIONARYFRAGMENT 12720 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RELATIVEPATH 12721 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RELATIVEPATH_DATATYPEVERSION 12722 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RELATIVEPATH_DICTIONARYFRAGMENT 12723 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CREATESIGNINGREQUEST 12731 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CREATESIGNINGREQUEST_INPUTARGUMENTS 12732 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CREATESIGNINGREQUEST_OUTPUTARGUMENTS 12733 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_APPLYCHANGES 12734 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CREATESIGNINGREQUEST 12737 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CREATESIGNINGREQUEST_INPUTARGUMENTS 12738 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CREATESIGNINGREQUEST_OUTPUTARGUMENTS 12739 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_APPLYCHANGES 12740 /* Method */ +#define UA_NS0ID_CREATESIGNINGREQUESTMETHODTYPE 12741 /* Method */ +#define UA_NS0ID_CREATESIGNINGREQUESTMETHODTYPE_INPUTARGUMENTS 12742 /* Variable */ +#define UA_NS0ID_CREATESIGNINGREQUESTMETHODTYPE_OUTPUTARGUMENTS 12743 /* Variable */ +#define UA_NS0ID_OPTIONSETVALUES 12745 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SETSUBSCRIPTIONDURABLE 12746 /* Method */ +#define UA_NS0ID_SERVERTYPE_SETSUBSCRIPTIONDURABLE_INPUTARGUMENTS 12747 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SETSUBSCRIPTIONDURABLE_OUTPUTARGUMENTS 12748 /* Variable */ +#define UA_NS0ID_SERVER_SETSUBSCRIPTIONDURABLE 12749 /* Method */ +#define UA_NS0ID_SERVER_SETSUBSCRIPTIONDURABLE_INPUTARGUMENTS 12750 /* Variable */ +#define UA_NS0ID_SERVER_SETSUBSCRIPTIONDURABLE_OUTPUTARGUMENTS 12751 /* Variable */ +#define UA_NS0ID_SETSUBSCRIPTIONDURABLEMETHODTYPE 12752 /* Method */ +#define UA_NS0ID_SETSUBSCRIPTIONDURABLEMETHODTYPE_INPUTARGUMENTS 12753 /* Variable */ +#define UA_NS0ID_SETSUBSCRIPTIONDURABLEMETHODTYPE_OUTPUTARGUMENTS 12754 /* Variable */ +#define UA_NS0ID_OPTIONSET 12755 /* DataType */ +#define UA_NS0ID_UNION 12756 /* DataType */ +#define UA_NS0ID_OPTIONSET_ENCODING_DEFAULTXML 12757 /* Object */ +#define UA_NS0ID_UNION_ENCODING_DEFAULTXML 12758 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_OPTIONSET 12759 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_OPTIONSET_DATATYPEVERSION 12760 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_OPTIONSET_DICTIONARYFRAGMENT 12761 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UNION 12762 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UNION_DATATYPEVERSION 12763 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UNION_DICTIONARYFRAGMENT 12764 /* Variable */ +#define UA_NS0ID_OPTIONSET_ENCODING_DEFAULTBINARY 12765 /* Object */ +#define UA_NS0ID_UNION_ENCODING_DEFAULTBINARY 12766 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_OPTIONSET 12767 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_OPTIONSET_DATATYPEVERSION 12768 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_OPTIONSET_DICTIONARYFRAGMENT 12769 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UNION 12770 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UNION_DATATYPEVERSION 12771 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UNION_DICTIONARYFRAGMENT 12772 /* Variable */ +#define UA_NS0ID_GETREJECTEDLISTMETHODTYPE 12773 /* Method */ +#define UA_NS0ID_GETREJECTEDLISTMETHODTYPE_OUTPUTARGUMENTS 12774 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_GETREJECTEDLIST 12775 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_GETREJECTEDLIST_OUTPUTARGUMENTS 12776 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_GETREJECTEDLIST 12777 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_GETREJECTEDLIST_OUTPUTARGUMENTS 12778 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSARRAYTYPE_SAMPLINGINTERVALDIAGNOSTICS 12779 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSARRAYTYPE_SAMPLINGINTERVALDIAGNOSTICS_SAMPLINGINTERVAL 12780 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSARRAYTYPE_SAMPLINGINTERVALDIAGNOSTICS_SAMPLEDMONITOREDITEMSCOUNT 12781 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSARRAYTYPE_SAMPLINGINTERVALDIAGNOSTICS_MAXSAMPLEDMONITOREDITEMSCOUNT 12782 /* Variable */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSARRAYTYPE_SAMPLINGINTERVALDIAGNOSTICS_DISABLEDMONITOREDITEMSSAMPLINGCOUNT 12783 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS 12784 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_SESSIONID 12785 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_SUBSCRIPTIONID 12786 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_PRIORITY 12787 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_PUBLISHINGINTERVAL 12788 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_MAXKEEPALIVECOUNT 12789 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_MAXLIFETIMECOUNT 12790 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_MAXNOTIFICATIONSPERPUBLISH 12791 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_PUBLISHINGENABLED 12792 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_MODIFYCOUNT 12793 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_ENABLECOUNT 12794 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_DISABLECOUNT 12795 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_REPUBLISHREQUESTCOUNT 12796 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_REPUBLISHMESSAGEREQUESTCOUNT 12797 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_REPUBLISHMESSAGECOUNT 12798 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_TRANSFERREQUESTCOUNT 12799 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_TRANSFERREDTOALTCLIENTCOUNT 12800 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_TRANSFERREDTOSAMECLIENTCOUNT 12801 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_PUBLISHREQUESTCOUNT 12802 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_DATACHANGENOTIFICATIONSCOUNT 12803 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_EVENTNOTIFICATIONSCOUNT 12804 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_NOTIFICATIONSCOUNT 12805 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_LATEPUBLISHREQUESTCOUNT 12806 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_CURRENTKEEPALIVECOUNT 12807 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_CURRENTLIFETIMECOUNT 12808 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_UNACKNOWLEDGEDMESSAGECOUNT 12809 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_DISCARDEDMESSAGECOUNT 12810 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_MONITOREDITEMCOUNT 12811 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_DISABLEDMONITOREDITEMCOUNT 12812 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_MONITORINGQUEUEOVERFLOWCOUNT 12813 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_NEXTSEQUENCENUMBER 12814 /* Variable */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSARRAYTYPE_SUBSCRIPTIONDIAGNOSTICS_EVENTQUEUEOVERFLOWCOUNT 12815 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS 12816 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_SESSIONID 12817 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_SESSIONNAME 12818 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CLIENTDESCRIPTION 12819 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_SERVERURI 12820 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_ENDPOINTURL 12821 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_LOCALEIDS 12822 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_ACTUALSESSIONTIMEOUT 12823 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_MAXRESPONSEMESSAGESIZE 12824 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CLIENTCONNECTIONTIME 12825 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CLIENTLASTCONTACTTIME 12826 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CURRENTSUBSCRIPTIONSCOUNT 12827 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CURRENTMONITOREDITEMSCOUNT 12828 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CURRENTPUBLISHREQUESTSINQUEUE 12829 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_TOTALREQUESTCOUNT 12830 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_UNAUTHORIZEDREQUESTCOUNT 12831 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_READCOUNT 12832 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_HISTORYREADCOUNT 12833 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_WRITECOUNT 12834 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_HISTORYUPDATECOUNT 12835 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CALLCOUNT 12836 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CREATEMONITOREDITEMSCOUNT 12837 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_MODIFYMONITOREDITEMSCOUNT 12838 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_SETMONITORINGMODECOUNT 12839 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_SETTRIGGERINGCOUNT 12840 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_DELETEMONITOREDITEMSCOUNT 12841 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_CREATESUBSCRIPTIONCOUNT 12842 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_MODIFYSUBSCRIPTIONCOUNT 12843 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_SETPUBLISHINGMODECOUNT 12844 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_PUBLISHCOUNT 12845 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_REPUBLISHCOUNT 12846 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_TRANSFERSUBSCRIPTIONSCOUNT 12847 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_DELETESUBSCRIPTIONSCOUNT 12848 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_ADDNODESCOUNT 12849 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_ADDREFERENCESCOUNT 12850 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_DELETENODESCOUNT 12851 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_DELETEREFERENCESCOUNT 12852 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_BROWSECOUNT 12853 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_BROWSENEXTCOUNT 12854 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_TRANSLATEBROWSEPATHSTONODEIDSCOUNT 12855 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_QUERYFIRSTCOUNT 12856 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_QUERYNEXTCOUNT 12857 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_REGISTERNODESCOUNT 12858 /* Variable */ +#define UA_NS0ID_SESSIONDIAGNOSTICSARRAYTYPE_SESSIONDIAGNOSTICS_UNREGISTERNODESCOUNT 12859 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS 12860 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_SESSIONID 12861 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_CLIENTUSERIDOFSESSION 12862 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_CLIENTUSERIDHISTORY 12863 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_AUTHENTICATIONMECHANISM 12864 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_ENCODING 12865 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_TRANSPORTPROTOCOL 12866 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_SECURITYMODE 12867 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_SECURITYPOLICYURI 12868 /* Variable */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSARRAYTYPE_SESSIONSECURITYDIAGNOSTICS_CLIENTCERTIFICATE 12869 /* Variable */ +#define UA_NS0ID_SERVERTYPE_RESENDDATA 12871 /* Method */ +#define UA_NS0ID_SERVERTYPE_RESENDDATA_INPUTARGUMENTS 12872 /* Variable */ +#define UA_NS0ID_SERVER_RESENDDATA 12873 /* Method */ +#define UA_NS0ID_SERVER_RESENDDATA_INPUTARGUMENTS 12874 /* Variable */ +#define UA_NS0ID_RESENDDATAMETHODTYPE 12875 /* Method */ +#define UA_NS0ID_RESENDDATAMETHODTYPE_INPUTARGUMENTS 12876 /* Variable */ +#define UA_NS0ID_NORMALIZEDSTRING 12877 /* DataType */ +#define UA_NS0ID_DECIMALSTRING 12878 /* DataType */ +#define UA_NS0ID_DURATIONSTRING 12879 /* DataType */ +#define UA_NS0ID_TIMESTRING 12880 /* DataType */ +#define UA_NS0ID_DATESTRING 12881 /* DataType */ +#define UA_NS0ID_SERVERTYPE_ESTIMATEDRETURNTIME 12882 /* Variable */ +#define UA_NS0ID_SERVERTYPE_REQUESTSERVERSTATECHANGE 12883 /* Method */ +#define UA_NS0ID_SERVERTYPE_REQUESTSERVERSTATECHANGE_INPUTARGUMENTS 12884 /* Variable */ +#define UA_NS0ID_SERVER_ESTIMATEDRETURNTIME 12885 /* Variable */ +#define UA_NS0ID_SERVER_REQUESTSERVERSTATECHANGE 12886 /* Method */ +#define UA_NS0ID_SERVER_REQUESTSERVERSTATECHANGE_INPUTARGUMENTS 12887 /* Variable */ +#define UA_NS0ID_REQUESTSERVERSTATECHANGEMETHODTYPE 12888 /* Method */ +#define UA_NS0ID_REQUESTSERVERSTATECHANGEMETHODTYPE_INPUTARGUMENTS 12889 /* Variable */ +#define UA_NS0ID_DISCOVERYCONFIGURATION 12890 /* DataType */ +#define UA_NS0ID_MDNSDISCOVERYCONFIGURATION 12891 /* DataType */ +#define UA_NS0ID_DISCOVERYCONFIGURATION_ENCODING_DEFAULTXML 12892 /* Object */ +#define UA_NS0ID_MDNSDISCOVERYCONFIGURATION_ENCODING_DEFAULTXML 12893 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DISCOVERYCONFIGURATION 12894 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DISCOVERYCONFIGURATION_DATATYPEVERSION 12895 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DISCOVERYCONFIGURATION_DICTIONARYFRAGMENT 12896 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MDNSDISCOVERYCONFIGURATION 12897 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MDNSDISCOVERYCONFIGURATION_DATATYPEVERSION 12898 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_MDNSDISCOVERYCONFIGURATION_DICTIONARYFRAGMENT 12899 /* Variable */ +#define UA_NS0ID_DISCOVERYCONFIGURATION_ENCODING_DEFAULTBINARY 12900 /* Object */ +#define UA_NS0ID_MDNSDISCOVERYCONFIGURATION_ENCODING_DEFAULTBINARY 12901 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DISCOVERYCONFIGURATION 12902 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DISCOVERYCONFIGURATION_DATATYPEVERSION 12903 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DISCOVERYCONFIGURATION_DICTIONARYFRAGMENT 12904 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MDNSDISCOVERYCONFIGURATION 12905 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MDNSDISCOVERYCONFIGURATION_DATATYPEVERSION 12906 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_MDNSDISCOVERYCONFIGURATION_DICTIONARYFRAGMENT 12907 /* Variable */ +#define UA_NS0ID_MAXBYTESTRINGLENGTH 12908 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_MAXBYTESTRINGLENGTH 12909 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_MAXBYTESTRINGLENGTH 12910 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_MAXBYTESTRINGLENGTH 12911 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONREFRESH2 12912 /* Method */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12913 /* Variable */ +#define UA_NS0ID_CONDITIONREFRESH2METHODTYPE 12914 /* Method */ +#define UA_NS0ID_CONDITIONREFRESH2METHODTYPE_INPUTARGUMENTS 12915 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONREFRESH2 12916 /* Method */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12917 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONREFRESH2 12918 /* Method */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12919 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONREFRESH2 12984 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12985 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONREFRESH2 12986 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12987 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH2 12988 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12989 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH2 12990 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12991 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH2 12992 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12993 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH2 12994 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12995 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH2 12996 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12997 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH2 12998 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 12999 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH2 13000 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 13001 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH2 13002 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 13003 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONREFRESH2 13004 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 13005 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONREFRESH2 13006 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 13007 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONREFRESH2 13008 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 13009 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONREFRESH2 13010 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 13011 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE 13225 /* ObjectType */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_EVENTID 13226 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_EVENTTYPE 13227 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SOURCENODE 13228 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SOURCENAME 13229 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_TIME 13230 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_RECEIVETIME 13231 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LOCALTIME 13232 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_MESSAGE 13233 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SEVERITY 13234 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONCLASSID 13235 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONCLASSNAME 13236 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONNAME 13237 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_BRANCHID 13238 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_RETAIN 13239 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE 13240 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_ID 13241 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_NAME 13242 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_NUMBER 13243 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 13244 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 13245 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 13246 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_TRUESTATE 13247 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLEDSTATE_FALSESTATE 13248 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_QUALITY 13249 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_QUALITY_SOURCETIMESTAMP 13250 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LASTSEVERITY 13251 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 13252 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_COMMENT 13253 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_COMMENT_SOURCETIMESTAMP 13254 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CLIENTUSERID 13255 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_DISABLE 13256 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ENABLE 13257 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ADDCOMMENT 13258 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 13259 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONREFRESH 13260 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 13261 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONREFRESH2 13262 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 13263 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE 13264 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_ID 13265 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_NAME 13266 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_NUMBER 13267 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 13268 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_TRANSITIONTIME 13269 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 13270 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_TRUESTATE 13271 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKEDSTATE_FALSESTATE 13272 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE 13273 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_ID 13274 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_NAME 13275 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_NUMBER 13276 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 13277 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 13278 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 13279 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_TRUESTATE 13280 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRMEDSTATE_FALSESTATE 13281 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKNOWLEDGE 13282 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 13283 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRM 13284 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONFIRM_INPUTARGUMENTS 13285 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE 13286 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_ID 13287 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_NAME 13288 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_NUMBER 13289 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 13290 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_TRANSITIONTIME 13291 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 13292 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_TRUESTATE 13293 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ACTIVESTATE_FALSESTATE 13294 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_INPUTNODE 13295 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE 13296 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_ID 13297 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_NAME 13298 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_NUMBER 13299 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 13300 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 13301 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 13302 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 13303 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 13304 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE 13305 /* Object */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE 13306 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 13307 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 13308 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 13309 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 13310 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION 13311 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 13312 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 13313 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 13314 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 13315 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 13316 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_UNSHELVETIME 13317 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_UNSHELVE 13318 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 13319 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 13320 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 13321 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESSEDORSHELVED 13322 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_MAXTIMESHELVED 13323 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_NORMALSTATE 13324 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_EXPIRATIONDATE 13325 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CERTIFICATETYPE 13326 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CERTIFICATE 13327 /* Variable */ +#define UA_NS0ID_FILETYPE_MIMETYPE 13341 /* Variable */ +#define UA_NS0ID_CREATEDIRECTORYMETHODTYPE 13342 /* Method */ +#define UA_NS0ID_CREATEDIRECTORYMETHODTYPE_INPUTARGUMENTS 13343 /* Variable */ +#define UA_NS0ID_CREATEDIRECTORYMETHODTYPE_OUTPUTARGUMENTS 13344 /* Variable */ +#define UA_NS0ID_CREATEFILEMETHODTYPE 13345 /* Method */ +#define UA_NS0ID_CREATEFILEMETHODTYPE_INPUTARGUMENTS 13346 /* Variable */ +#define UA_NS0ID_CREATEFILEMETHODTYPE_OUTPUTARGUMENTS 13347 /* Variable */ +#define UA_NS0ID_DELETEFILEMETHODTYPE 13348 /* Method */ +#define UA_NS0ID_DELETEFILEMETHODTYPE_INPUTARGUMENTS 13349 /* Variable */ +#define UA_NS0ID_MOVEORCOPYMETHODTYPE 13350 /* Method */ +#define UA_NS0ID_MOVEORCOPYMETHODTYPE_INPUTARGUMENTS 13351 /* Variable */ +#define UA_NS0ID_MOVEORCOPYMETHODTYPE_OUTPUTARGUMENTS 13352 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE 13353 /* ObjectType */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER 13354 /* Object */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_CREATEDIRECTORY 13355 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_CREATEDIRECTORY_INPUTARGUMENTS 13356 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_CREATEDIRECTORY_OUTPUTARGUMENTS 13357 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_CREATEFILE 13358 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_CREATEFILE_INPUTARGUMENTS 13359 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_CREATEFILE_OUTPUTARGUMENTS 13360 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_MOVEORCOPY 13363 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_MOVEORCOPY_INPUTARGUMENTS 13364 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_MOVEORCOPY_OUTPUTARGUMENTS 13365 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER 13366 /* Object */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_SIZE 13367 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_WRITABLE 13368 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_USERWRITABLE 13369 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_OPENCOUNT 13370 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_MIMETYPE 13371 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_OPEN 13372 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_OPEN_INPUTARGUMENTS 13373 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_OPEN_OUTPUTARGUMENTS 13374 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_CLOSE 13375 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_CLOSE_INPUTARGUMENTS 13376 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_READ 13377 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_READ_INPUTARGUMENTS 13378 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_READ_OUTPUTARGUMENTS 13379 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_WRITE 13380 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_WRITE_INPUTARGUMENTS 13381 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_GETPOSITION 13382 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_GETPOSITION_INPUTARGUMENTS 13383 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_GETPOSITION_OUTPUTARGUMENTS 13384 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_SETPOSITION 13385 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILENAME_PLACEHOLDER_SETPOSITION_INPUTARGUMENTS 13386 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_CREATEDIRECTORY 13387 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_CREATEDIRECTORY_INPUTARGUMENTS 13388 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_CREATEDIRECTORY_OUTPUTARGUMENTS 13389 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_CREATEFILE 13390 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_CREATEFILE_INPUTARGUMENTS 13391 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_CREATEFILE_OUTPUTARGUMENTS 13392 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_DELETEFILESYSTEMOBJECT 13393 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_DELETEFILESYSTEMOBJECT_INPUTARGUMENTS 13394 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_MOVEORCOPY 13395 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_MOVEORCOPY_INPUTARGUMENTS 13396 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_MOVEORCOPY_OUTPUTARGUMENTS 13397 /* Variable */ +#define UA_NS0ID_ADDRESSSPACEFILETYPE_MIMETYPE 13398 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_NAMESPACEFILE_MIMETYPE 13399 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_NAMESPACEFILE_MIMETYPE 13400 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_MIMETYPE 13403 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST 13599 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_SIZE 13600 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_WRITABLE 13601 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_USERWRITABLE 13602 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_OPENCOUNT 13603 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_MIMETYPE 13604 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_OPEN 13605 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_OPEN_INPUTARGUMENTS 13606 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_OPEN_OUTPUTARGUMENTS 13607 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_CLOSE 13608 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_CLOSE_INPUTARGUMENTS 13609 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_READ 13610 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_READ_INPUTARGUMENTS 13611 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_READ_OUTPUTARGUMENTS 13612 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_WRITE 13613 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_WRITE_INPUTARGUMENTS 13614 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_GETPOSITION 13615 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 13616 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 13617 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_SETPOSITION 13618 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 13619 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_LASTUPDATETIME 13620 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_OPENWITHMASKS 13621 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 13622 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 13623 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_CLOSEANDUPDATE 13624 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 13625 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 13626 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_ADDCERTIFICATE 13627 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 13628 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_REMOVECERTIFICATE 13629 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 13630 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_CERTIFICATETYPES 13631 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_CERTIFICATEGROUP 13735 /* Variable */ +#define UA_NS0ID_CERTIFICATEUPDATEDAUDITEVENTTYPE_CERTIFICATETYPE 13736 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_UPDATECERTIFICATE 13737 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_UPDATECERTIFICATE_INPUTARGUMENTS 13738 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_UPDATECERTIFICATE_OUTPUTARGUMENTS 13739 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE 13813 /* ObjectType */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP 13814 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST 13815 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SIZE 13816 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITABLE 13817 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_USERWRITABLE 13818 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENCOUNT 13819 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_MIMETYPE 13820 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN 13821 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 13822 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 13823 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSE 13824 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 13825 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ 13826 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ_INPUTARGUMENTS 13827 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 13828 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITE 13829 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 13830 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION 13831 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 13832 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 13833 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SETPOSITION 13834 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 13835 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_LASTUPDATETIME 13836 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS 13837 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 13838 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 13839 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE 13840 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 13841 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 13842 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_ADDCERTIFICATE 13843 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 13844 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_REMOVECERTIFICATE 13845 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 13846 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_CERTIFICATETYPES 13847 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP 13848 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST 13849 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_SIZE 13850 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_WRITABLE 13851 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_USERWRITABLE 13852 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_OPENCOUNT 13853 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_MIMETYPE 13854 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN 13855 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 13856 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 13857 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSE 13858 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 13859 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_READ 13860 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_READ_INPUTARGUMENTS 13861 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 13862 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_WRITE 13863 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 13864 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION 13865 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 13866 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 13867 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_SETPOSITION 13868 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 13869 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_LASTUPDATETIME 13870 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS 13871 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 13872 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 13873 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE 13874 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 13875 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 13876 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_ADDCERTIFICATE 13877 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 13878 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_REMOVECERTIFICATE 13879 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 13880 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_CERTIFICATETYPES 13881 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP 13882 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST 13883 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_SIZE 13884 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITABLE 13885 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_USERWRITABLE 13886 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENCOUNT 13887 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_MIMETYPE 13888 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN 13889 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 13890 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 13891 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSE 13892 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 13893 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ 13894 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ_INPUTARGUMENTS 13895 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 13896 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITE 13897 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 13898 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION 13899 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 13900 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 13901 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_SETPOSITION 13902 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 13903 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_LASTUPDATETIME 13904 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS 13905 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 13906 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 13907 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE 13908 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 13909 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 13910 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_ADDCERTIFICATE 13911 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 13912 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_REMOVECERTIFICATE 13913 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 13914 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_CERTIFICATETYPES 13915 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER 13916 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST 13917 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_SIZE 13918 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_WRITABLE 13919 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_USERWRITABLE 13920 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_OPENCOUNT 13921 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_MIMETYPE 13922 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_OPEN 13923 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_OPEN_INPUTARGUMENTS 13924 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_OPEN_OUTPUTARGUMENTS 13925 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_CLOSE 13926 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_CLOSE_INPUTARGUMENTS 13927 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_READ 13928 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_READ_INPUTARGUMENTS 13929 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_READ_OUTPUTARGUMENTS 13930 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_WRITE 13931 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_WRITE_INPUTARGUMENTS 13932 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_GETPOSITION 13933 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 13934 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 13935 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_SETPOSITION 13936 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 13937 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_LASTUPDATETIME 13938 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_OPENWITHMASKS 13939 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 13940 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 13941 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_CLOSEANDUPDATE 13942 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 13943 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 13944 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_ADDCERTIFICATE 13945 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 13946 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_REMOVECERTIFICATE 13947 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 13948 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_CERTIFICATETYPES 13949 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS 13950 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP 13951 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST 13952 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SIZE 13953 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITABLE 13954 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_USERWRITABLE 13955 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENCOUNT 13956 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_MIMETYPE 13957 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN 13958 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 13959 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 13960 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSE 13961 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 13962 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ 13963 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ_INPUTARGUMENTS 13964 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 13965 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITE 13966 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 13967 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION 13968 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 13969 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 13970 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SETPOSITION 13971 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 13972 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_LASTUPDATETIME 13973 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS 13974 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 13975 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 13976 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE 13977 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 13978 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 13979 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_ADDCERTIFICATE 13980 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 13981 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_REMOVECERTIFICATE 13982 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 13983 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_CERTIFICATETYPES 13984 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP 13985 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST 13986 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_SIZE 13987 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_WRITABLE 13988 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_USERWRITABLE 13989 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENCOUNT 13990 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_MIMETYPE 13991 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN 13992 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 13993 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 13994 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSE 13995 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 13996 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_READ 13997 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_READ_INPUTARGUMENTS 13998 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 13999 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_WRITE 14000 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 14001 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION 14002 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 14003 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 14004 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_SETPOSITION 14005 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 14006 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_LASTUPDATETIME 14007 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS 14008 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 14009 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 14010 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE 14011 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 14012 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 14013 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_ADDCERTIFICATE 14014 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 14015 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_REMOVECERTIFICATE 14016 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 14017 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_CERTIFICATETYPES 14018 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP 14019 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST 14020 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_SIZE 14021 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITABLE 14022 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_USERWRITABLE 14023 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENCOUNT 14024 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_MIMETYPE 14025 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN 14026 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 14027 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 14028 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSE 14029 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 14030 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ 14031 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ_INPUTARGUMENTS 14032 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 14033 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITE 14034 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 14035 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION 14036 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 14037 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 14038 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_SETPOSITION 14039 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 14040 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_LASTUPDATETIME 14041 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS 14042 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 14043 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 14044 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE 14045 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 14046 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 14047 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_ADDCERTIFICATE 14048 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 14049 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_REMOVECERTIFICATE 14050 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 14051 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_CERTIFICATETYPES 14052 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS 14053 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP 14088 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST 14089 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_SIZE 14090 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_WRITABLE 14091 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_USERWRITABLE 14092 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENCOUNT 14093 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_MIMETYPE 14094 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN 14095 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 14096 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 14097 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSE 14098 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 14099 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_READ 14100 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_READ_INPUTARGUMENTS 14101 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 14102 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_WRITE 14103 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 14104 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION 14105 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 14106 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 14107 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_SETPOSITION 14108 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 14109 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_LASTUPDATETIME 14110 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS 14111 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 14112 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 14113 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE 14114 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 14115 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 14116 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_ADDCERTIFICATE 14117 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 14118 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_REMOVECERTIFICATE 14119 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 14120 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_CERTIFICATETYPES 14121 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP 14122 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST 14123 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_SIZE 14124 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITABLE 14125 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_USERWRITABLE 14126 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENCOUNT 14127 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_MIMETYPE 14128 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN 14129 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN_INPUTARGUMENTS 14130 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPEN_OUTPUTARGUMENTS 14131 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSE 14132 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSE_INPUTARGUMENTS 14133 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ 14134 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ_INPUTARGUMENTS 14135 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_READ_OUTPUTARGUMENTS 14136 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITE 14137 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_WRITE_INPUTARGUMENTS 14138 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION 14139 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION_INPUTARGUMENTS 14140 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_GETPOSITION_OUTPUTARGUMENTS 14141 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_SETPOSITION 14142 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_SETPOSITION_INPUTARGUMENTS 14143 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_LASTUPDATETIME 14144 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS 14145 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS_INPUTARGUMENTS 14146 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_OPENWITHMASKS_OUTPUTARGUMENTS 14147 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE 14148 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 14149 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_CLOSEANDUPDATE_OUTPUTARGUMENTS 14150 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_ADDCERTIFICATE 14151 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_ADDCERTIFICATE_INPUTARGUMENTS 14152 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_REMOVECERTIFICATE 14153 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_REMOVECERTIFICATE_INPUTARGUMENTS 14154 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_CERTIFICATETYPES 14155 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP 14156 /* Object */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_WRITABLE 14157 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_USERWRITABLE 14158 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_MIMETYPE 14159 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_CLOSEANDUPDATE_INPUTARGUMENTS 14160 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_CERTIFICATETYPES 14161 /* Variable */ +#define UA_NS0ID_REMOVECONNECTIONMETHODTYPE 14183 /* Method */ +#define UA_NS0ID_REMOVECONNECTIONMETHODTYPE_INPUTARGUMENTS 14184 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE 14209 /* ObjectType */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDRESS 14221 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_REMOVEGROUP 14225 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_REMOVEGROUP_INPUTARGUMENTS 14226 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPE 14232 /* ObjectType */ +#define UA_NS0ID_PUBLISHEDVARIABLEDATATYPE 14273 /* DataType */ +#define UA_NS0ID_PUBLISHEDVARIABLEDATATYPE_ENCODING_DEFAULTXML 14319 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDVARIABLEDATATYPE 14320 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDVARIABLEDATATYPE_DATATYPEVERSION 14321 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDVARIABLEDATATYPE_DICTIONARYFRAGMENT 14322 /* Variable */ +#define UA_NS0ID_PUBLISHEDVARIABLEDATATYPE_ENCODING_DEFAULTBINARY 14323 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDVARIABLEDATATYPE 14324 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDVARIABLEDATATYPE_DATATYPEVERSION 14325 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDVARIABLEDATATYPE_DICTIONARYFRAGMENT 14326 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_SESSIONID 14413 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_SESSIONID 14414 /* Variable */ +#define UA_NS0ID_SERVER_SERVERREDUNDANCY_SERVERNETWORKGROUPS 14415 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE 14416 /* ObjectType */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER 14417 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_PUBLISHERID 14418 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_STATUS 14419 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_STATUS_STATE 14420 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_STATUS_ENABLE 14421 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_STATUS_DISABLE 14422 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDRESS 14423 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_REMOVEGROUP 14424 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_REMOVEGROUP_INPUTARGUMENTS 14425 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_REMOVECONNECTION 14432 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_REMOVECONNECTION_INPUTARGUMENTS 14433 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS 14434 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMS 14435 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMS_INPUTARGUMENTS 14436 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMS_OUTPUTARGUMENTS 14437 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTS 14438 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTS_INPUTARGUMENTS 14439 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTS_OUTPUTARGUMENTS 14440 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_REMOVEPUBLISHEDDATASET 14441 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_REMOVEPUBLISHEDDATASET_INPUTARGUMENTS 14442 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE 14443 /* Object */ +#define UA_NS0ID_HASPUBSUBCONNECTION 14476 /* ReferenceType */ +#define UA_NS0ID_DATASETFOLDERTYPE 14477 /* ObjectType */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER 14478 /* Object */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDDATAITEMS 14479 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDDATAITEMS_INPUTARGUMENTS 14480 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDDATAITEMS_OUTPUTARGUMENTS 14481 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDEVENTS 14482 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDEVENTS_INPUTARGUMENTS 14483 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDEVENTS_OUTPUTARGUMENTS 14484 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_REMOVEPUBLISHEDDATASET 14485 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_REMOVEPUBLISHEDDATASET_INPUTARGUMENTS 14486 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER 14487 /* Object */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_CONFIGURATIONVERSION 14489 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMS 14493 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMS_INPUTARGUMENTS 14494 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMS_OUTPUTARGUMENTS 14495 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDEVENTS 14496 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDEVENTS_INPUTARGUMENTS 14497 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDEVENTS_OUTPUTARGUMENTS 14498 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_REMOVEPUBLISHEDDATASET 14499 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_REMOVEPUBLISHEDDATASET_INPUTARGUMENTS 14500 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDDATAITEMSMETHODTYPE 14501 /* Method */ +#define UA_NS0ID_ADDPUBLISHEDDATAITEMSMETHODTYPE_INPUTARGUMENTS 14502 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDDATAITEMSMETHODTYPE_OUTPUTARGUMENTS 14503 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDEVENTSMETHODTYPE 14504 /* Method */ +#define UA_NS0ID_ADDPUBLISHEDEVENTSMETHODTYPE_INPUTARGUMENTS 14505 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDEVENTSMETHODTYPE_OUTPUTARGUMENTS 14506 /* Variable */ +#define UA_NS0ID_REMOVEPUBLISHEDDATASETMETHODTYPE 14507 /* Method */ +#define UA_NS0ID_REMOVEPUBLISHEDDATASETMETHODTYPE_INPUTARGUMENTS 14508 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE 14509 /* ObjectType */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_CONFIGURATIONVERSION 14519 /* Variable */ +#define UA_NS0ID_DATASETMETADATATYPE 14523 /* DataType */ +#define UA_NS0ID_FIELDMETADATA 14524 /* DataType */ +#define UA_NS0ID_DATATYPEDESCRIPTION 14525 /* DataType */ +#define UA_NS0ID_STRUCTURETYPE_ENUMSTRINGS 14528 /* Variable */ +#define UA_NS0ID_KEYVALUEPAIR 14533 /* DataType */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE 14534 /* ObjectType */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_CONFIGURATIONVERSION 14544 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_PUBLISHEDDATA 14548 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_ADDVARIABLES 14555 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_ADDVARIABLES_INPUTARGUMENTS 14556 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_ADDVARIABLES_OUTPUTARGUMENTS 14557 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_REMOVEVARIABLES 14558 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_REMOVEVARIABLES_INPUTARGUMENTS 14559 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_REMOVEVARIABLES_OUTPUTARGUMENTS 14560 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSADDVARIABLESMETHODTYPE 14564 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSADDVARIABLESMETHODTYPE_INPUTARGUMENTS 14565 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSADDVARIABLESMETHODTYPE_OUTPUTARGUMENTS 14566 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSREMOVEVARIABLESMETHODTYPE 14567 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSREMOVEVARIABLESMETHODTYPE_INPUTARGUMENTS 14568 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSREMOVEVARIABLESMETHODTYPE_OUTPUTARGUMENTS 14569 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE 14572 /* ObjectType */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_CONFIGURATIONVERSION 14582 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_PUBSUBEVENTNOTIFIER 14586 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_SELECTEDFIELDS 14587 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_FILTER 14588 /* Variable */ +#define UA_NS0ID_CONFIGURATIONVERSIONDATATYPE 14593 /* DataType */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_PUBLISHERID 14595 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_STATUS 14600 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_STATUS_STATE 14601 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_STATUS_ENABLE 14602 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_STATUS_DISABLE 14603 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPEREMOVEGROUPMETHODTYPE 14604 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPEREMOVEGROUPMETHODTYPE_INPUTARGUMENTS 14605 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPEREMOVEWRITERMETHODTYPE 14623 /* Method */ +#define UA_NS0ID_PUBSUBGROUPTYPEREMOVEWRITERMETHODTYPE_INPUTARGUMENTS 14624 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPEREMOVEREADERMETHODTYPE 14625 /* Method */ +#define UA_NS0ID_PUBSUBGROUPTYPEREMOVEREADERMETHODTYPE_INPUTARGUMENTS 14626 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSTYPE 14643 /* ObjectType */ +#define UA_NS0ID_PUBSUBSTATUSTYPE_STATE 14644 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSTYPE_ENABLE 14645 /* Method */ +#define UA_NS0ID_PUBSUBSTATUSTYPE_DISABLE 14646 /* Method */ +#define UA_NS0ID_PUBSUBSTATE 14647 /* DataType */ +#define UA_NS0ID_PUBSUBSTATE_ENUMSTRINGS 14648 /* Variable */ +#define UA_NS0ID_FIELDTARGETDATATYPE 14744 /* DataType */ +#define UA_NS0ID_DATASETMETADATATYPE_ENCODING_DEFAULTXML 14794 /* Object */ +#define UA_NS0ID_FIELDMETADATA_ENCODING_DEFAULTXML 14795 /* Object */ +#define UA_NS0ID_DATATYPEDESCRIPTION_ENCODING_DEFAULTXML 14796 /* Object */ +#define UA_NS0ID_DATATYPEDEFINITION_ENCODING_DEFAULTXML 14797 /* Object */ +#define UA_NS0ID_STRUCTUREDEFINITION_ENCODING_DEFAULTXML 14798 /* Object */ +#define UA_NS0ID_ENUMDEFINITION_ENCODING_DEFAULTXML 14799 /* Object */ +#define UA_NS0ID_STRUCTUREFIELD_ENCODING_DEFAULTXML 14800 /* Object */ +#define UA_NS0ID_ENUMFIELD_ENCODING_DEFAULTXML 14801 /* Object */ +#define UA_NS0ID_KEYVALUEPAIR_ENCODING_DEFAULTXML 14802 /* Object */ +#define UA_NS0ID_CONFIGURATIONVERSIONDATATYPE_ENCODING_DEFAULTXML 14803 /* Object */ +#define UA_NS0ID_FIELDTARGETDATATYPE_ENCODING_DEFAULTXML 14804 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETMETADATATYPE 14805 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETMETADATATYPE_DATATYPEVERSION 14806 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETMETADATATYPE_DICTIONARYFRAGMENT 14807 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FIELDMETADATA 14808 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FIELDMETADATA_DATATYPEVERSION 14809 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FIELDMETADATA_DICTIONARYFRAGMENT 14810 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPEDESCRIPTION 14811 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPEDESCRIPTION_DATATYPEVERSION 14812 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPEDESCRIPTION_DICTIONARYFRAGMENT 14813 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMFIELD 14826 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMFIELD_DATATYPEVERSION 14827 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMFIELD_DICTIONARYFRAGMENT 14828 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_KEYVALUEPAIR 14829 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_KEYVALUEPAIR_DATATYPEVERSION 14830 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_KEYVALUEPAIR_DICTIONARYFRAGMENT 14831 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONFIGURATIONVERSIONDATATYPE 14832 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONFIGURATIONVERSIONDATATYPE_DATATYPEVERSION 14833 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONFIGURATIONVERSIONDATATYPE_DICTIONARYFRAGMENT 14834 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FIELDTARGETDATATYPE 14835 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FIELDTARGETDATATYPE_DATATYPEVERSION 14836 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FIELDTARGETDATATYPE_DICTIONARYFRAGMENT 14837 /* Variable */ +#define UA_NS0ID_FIELDMETADATA_ENCODING_DEFAULTBINARY 14839 /* Object */ +#define UA_NS0ID_STRUCTUREFIELD_ENCODING_DEFAULTBINARY 14844 /* Object */ +#define UA_NS0ID_ENUMFIELD_ENCODING_DEFAULTBINARY 14845 /* Object */ +#define UA_NS0ID_KEYVALUEPAIR_ENCODING_DEFAULTBINARY 14846 /* Object */ +#define UA_NS0ID_CONFIGURATIONVERSIONDATATYPE_ENCODING_DEFAULTBINARY 14847 /* Object */ +#define UA_NS0ID_FIELDTARGETDATATYPE_ENCODING_DEFAULTBINARY 14848 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETMETADATATYPE 14849 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETMETADATATYPE_DATATYPEVERSION 14850 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETMETADATATYPE_DICTIONARYFRAGMENT 14851 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FIELDMETADATA 14852 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FIELDMETADATA_DATATYPEVERSION 14853 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FIELDMETADATA_DICTIONARYFRAGMENT 14854 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPEDESCRIPTION 14855 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPEDESCRIPTION_DATATYPEVERSION 14856 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPEDESCRIPTION_DICTIONARYFRAGMENT 14857 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMFIELD 14870 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMFIELD_DATATYPEVERSION 14871 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMFIELD_DICTIONARYFRAGMENT 14872 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_KEYVALUEPAIR 14873 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_KEYVALUEPAIR_DATATYPEVERSION 14874 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_KEYVALUEPAIR_DICTIONARYFRAGMENT 14875 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONFIGURATIONVERSIONDATATYPE 14876 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONFIGURATIONVERSIONDATATYPE_DATATYPEVERSION 14877 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONFIGURATIONVERSIONDATATYPE_DICTIONARYFRAGMENT 14878 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FIELDTARGETDATATYPE_DATATYPEVERSION 14880 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FIELDTARGETDATATYPE_DICTIONARYFRAGMENT 14881 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_EXPIRATIONLIMIT 14900 /* Variable */ +#define UA_NS0ID_DATASETTOWRITER 14936 /* ReferenceType */ +#define UA_NS0ID_DATATYPEDICTIONARYTYPE_DEPRECATED 15001 /* Variable */ +#define UA_NS0ID_MAXCHARACTERS 15002 /* Variable */ +#define UA_NS0ID_SERVERTYPE_URISVERSION 15003 /* Variable */ +#define UA_NS0ID_SERVER_URISVERSION 15004 /* Variable */ +#define UA_NS0ID_SIMPLETYPEDESCRIPTION 15005 /* DataType */ +#define UA_NS0ID_UABINARYFILEDATATYPE 15006 /* DataType */ +#define UA_NS0ID_BROKERCONNECTIONTRANSPORTDATATYPE 15007 /* DataType */ +#define UA_NS0ID_BROKERTRANSPORTQUALITYOFSERVICE 15008 /* DataType */ +#define UA_NS0ID_BROKERTRANSPORTQUALITYOFSERVICE_ENUMSTRINGS 15009 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPNAME_PLACEHOLDER_KEYLIFETIME 15010 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPNAME_PLACEHOLDER_SECURITYPOLICYURI 15011 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPNAME_PLACEHOLDER_MAXFUTUREKEYCOUNT 15012 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE 15013 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_EVENTID 15014 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_EVENTTYPE 15015 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_SOURCENODE 15016 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_SOURCENAME 15017 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_TIME 15018 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_RECEIVETIME 15019 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_LOCALTIME 15020 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_MESSAGE 15021 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_SEVERITY 15022 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_ACTIONTIMESTAMP 15023 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_STATUS 15024 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_SERVERID 15025 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_CLIENTAUDITENTRYID 15026 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_CLIENTUSERID 15027 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_METHODID 15028 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONRESETEVENTTYPE_INPUTARGUMENTS 15029 /* Variable */ +#define UA_NS0ID_PERMISSIONTYPE_OPTIONSETVALUES 15030 /* Variable */ +#define UA_NS0ID_ACCESSLEVELTYPE 15031 /* DataType */ +#define UA_NS0ID_ACCESSLEVELTYPE_OPTIONSETVALUES 15032 /* Variable */ +#define UA_NS0ID_EVENTNOTIFIERTYPE 15033 /* DataType */ +#define UA_NS0ID_EVENTNOTIFIERTYPE_OPTIONSETVALUES 15034 /* Variable */ +#define UA_NS0ID_ACCESSRESTRICTIONTYPE_OPTIONSETVALUES 15035 /* Variable */ +#define UA_NS0ID_ATTRIBUTEWRITEMASK_OPTIONSETVALUES 15036 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DEPRECATED 15037 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODINPUTVALUES 15038 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DEPRECATED 15039 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_PROGRAMDIAGNOSTIC_LASTMETHODOUTPUTVALUES 15040 /* Variable */ +#define UA_NS0ID_KEYVALUEPAIR_ENCODING_DEFAULTJSON 15041 /* Object */ +#define UA_NS0ID_IDENTITYMAPPINGRULETYPE_ENCODING_DEFAULTJSON 15042 /* Object */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPNAME_PLACEHOLDER_MAXPASTKEYCOUNT 15043 /* Variable */ +#define UA_NS0ID_TRUSTLISTDATATYPE_ENCODING_DEFAULTJSON 15044 /* Object */ +#define UA_NS0ID_DECIMALDATATYPE_ENCODING_DEFAULTJSON 15045 /* Object */ +#define UA_NS0ID_SECURITYGROUPTYPE_KEYLIFETIME 15046 /* Variable */ +#define UA_NS0ID_SECURITYGROUPTYPE_SECURITYPOLICYURI 15047 /* Variable */ +#define UA_NS0ID_SECURITYGROUPTYPE_MAXFUTUREKEYCOUNT 15048 /* Variable */ +#define UA_NS0ID_CONFIGURATIONVERSIONDATATYPE_ENCODING_DEFAULTJSON 15049 /* Object */ +#define UA_NS0ID_DATASETMETADATATYPE_ENCODING_DEFAULTJSON 15050 /* Object */ +#define UA_NS0ID_FIELDMETADATA_ENCODING_DEFAULTJSON 15051 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_MODIFYFIELDSELECTION 15052 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_MODIFYFIELDSELECTION_INPUTARGUMENTS 15053 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPEMODIFYFIELDSELECTIONMETHODTYPE 15054 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPEMODIFYFIELDSELECTIONMETHODTYPE_INPUTARGUMENTS 15055 /* Variable */ +#define UA_NS0ID_SECURITYGROUPTYPE_MAXPASTKEYCOUNT 15056 /* Variable */ +#define UA_NS0ID_DATATYPEDESCRIPTION_ENCODING_DEFAULTJSON 15057 /* Object */ +#define UA_NS0ID_STRUCTUREDESCRIPTION_ENCODING_DEFAULTJSON 15058 /* Object */ +#define UA_NS0ID_ENUMDESCRIPTION_ENCODING_DEFAULTJSON 15059 /* Object */ +#define UA_NS0ID_PUBLISHEDVARIABLEDATATYPE_ENCODING_DEFAULTJSON 15060 /* Object */ +#define UA_NS0ID_FIELDTARGETDATATYPE_ENCODING_DEFAULTJSON 15061 /* Object */ +#define UA_NS0ID_ROLEPERMISSIONTYPE_ENCODING_DEFAULTJSON 15062 /* Object */ +#define UA_NS0ID_DATATYPEDEFINITION_ENCODING_DEFAULTJSON 15063 /* Object */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTTYPE 15064 /* ObjectType */ +#define UA_NS0ID_STRUCTUREFIELD_ENCODING_DEFAULTJSON 15065 /* Object */ +#define UA_NS0ID_STRUCTUREDEFINITION_ENCODING_DEFAULTJSON 15066 /* Object */ +#define UA_NS0ID_ENUMDEFINITION_ENCODING_DEFAULTJSON 15067 /* Object */ +#define UA_NS0ID_NODE_ENCODING_DEFAULTJSON 15068 /* Object */ +#define UA_NS0ID_INSTANCENODE_ENCODING_DEFAULTJSON 15069 /* Object */ +#define UA_NS0ID_TYPENODE_ENCODING_DEFAULTJSON 15070 /* Object */ +#define UA_NS0ID_OBJECTNODE_ENCODING_DEFAULTJSON 15071 /* Object */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTTYPE_DISCOVERYADDRESS 15072 /* Object */ +#define UA_NS0ID_OBJECTTYPENODE_ENCODING_DEFAULTJSON 15073 /* Object */ +#define UA_NS0ID_VARIABLENODE_ENCODING_DEFAULTJSON 15074 /* Object */ +#define UA_NS0ID_VARIABLETYPENODE_ENCODING_DEFAULTJSON 15075 /* Object */ +#define UA_NS0ID_REFERENCETYPENODE_ENCODING_DEFAULTJSON 15076 /* Object */ +#define UA_NS0ID_METHODNODE_ENCODING_DEFAULTJSON 15077 /* Object */ +#define UA_NS0ID_VIEWNODE_ENCODING_DEFAULTJSON 15078 /* Object */ +#define UA_NS0ID_DATATYPENODE_ENCODING_DEFAULTJSON 15079 /* Object */ +#define UA_NS0ID_REFERENCENODE_ENCODING_DEFAULTJSON 15080 /* Object */ +#define UA_NS0ID_ARGUMENT_ENCODING_DEFAULTJSON 15081 /* Object */ +#define UA_NS0ID_ENUMVALUETYPE_ENCODING_DEFAULTJSON 15082 /* Object */ +#define UA_NS0ID_ENUMFIELD_ENCODING_DEFAULTJSON 15083 /* Object */ +#define UA_NS0ID_OPTIONSET_ENCODING_DEFAULTJSON 15084 /* Object */ +#define UA_NS0ID_UNION_ENCODING_DEFAULTJSON 15085 /* Object */ +#define UA_NS0ID_TIMEZONEDATATYPE_ENCODING_DEFAULTJSON 15086 /* Object */ +#define UA_NS0ID_APPLICATIONDESCRIPTION_ENCODING_DEFAULTJSON 15087 /* Object */ +#define UA_NS0ID_REQUESTHEADER_ENCODING_DEFAULTJSON 15088 /* Object */ +#define UA_NS0ID_RESPONSEHEADER_ENCODING_DEFAULTJSON 15089 /* Object */ +#define UA_NS0ID_SERVICEFAULT_ENCODING_DEFAULTJSON 15090 /* Object */ +#define UA_NS0ID_SESSIONLESSINVOKEREQUESTTYPE_ENCODING_DEFAULTJSON 15091 /* Object */ +#define UA_NS0ID_SESSIONLESSINVOKERESPONSETYPE_ENCODING_DEFAULTJSON 15092 /* Object */ +#define UA_NS0ID_FINDSERVERSREQUEST_ENCODING_DEFAULTJSON 15093 /* Object */ +#define UA_NS0ID_FINDSERVERSRESPONSE_ENCODING_DEFAULTJSON 15094 /* Object */ +#define UA_NS0ID_SERVERONNETWORK_ENCODING_DEFAULTJSON 15095 /* Object */ +#define UA_NS0ID_FINDSERVERSONNETWORKREQUEST_ENCODING_DEFAULTJSON 15096 /* Object */ +#define UA_NS0ID_FINDSERVERSONNETWORKRESPONSE_ENCODING_DEFAULTJSON 15097 /* Object */ +#define UA_NS0ID_USERTOKENPOLICY_ENCODING_DEFAULTJSON 15098 /* Object */ +#define UA_NS0ID_ENDPOINTDESCRIPTION_ENCODING_DEFAULTJSON 15099 /* Object */ +#define UA_NS0ID_GETENDPOINTSREQUEST_ENCODING_DEFAULTJSON 15100 /* Object */ +#define UA_NS0ID_GETENDPOINTSRESPONSE_ENCODING_DEFAULTJSON 15101 /* Object */ +#define UA_NS0ID_REGISTEREDSERVER_ENCODING_DEFAULTJSON 15102 /* Object */ +#define UA_NS0ID_REGISTERSERVERREQUEST_ENCODING_DEFAULTJSON 15103 /* Object */ +#define UA_NS0ID_REGISTERSERVERRESPONSE_ENCODING_DEFAULTJSON 15104 /* Object */ +#define UA_NS0ID_DISCOVERYCONFIGURATION_ENCODING_DEFAULTJSON 15105 /* Object */ +#define UA_NS0ID_MDNSDISCOVERYCONFIGURATION_ENCODING_DEFAULTJSON 15106 /* Object */ +#define UA_NS0ID_REGISTERSERVER2REQUEST_ENCODING_DEFAULTJSON 15107 /* Object */ +#define UA_NS0ID_SUBSCRIBEDDATASETTYPE 15108 /* ObjectType */ +#define UA_NS0ID_CHOICESTATETYPE 15109 /* ObjectType */ +#define UA_NS0ID_CHOICESTATETYPE_STATENUMBER 15110 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPE 15111 /* ObjectType */ +#define UA_NS0ID_HASGUARD 15112 /* ReferenceType */ +#define UA_NS0ID_GUARDVARIABLETYPE 15113 /* VariableType */ +#define UA_NS0ID_TARGETVARIABLESTYPE_TARGETVARIABLES 15114 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPE_ADDTARGETVARIABLES 15115 /* Method */ +#define UA_NS0ID_TARGETVARIABLESTYPE_ADDTARGETVARIABLES_INPUTARGUMENTS 15116 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPE_ADDTARGETVARIABLES_OUTPUTARGUMENTS 15117 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPE_REMOVETARGETVARIABLES 15118 /* Method */ +#define UA_NS0ID_TARGETVARIABLESTYPE_REMOVETARGETVARIABLES_INPUTARGUMENTS 15119 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPE_REMOVETARGETVARIABLES_OUTPUTARGUMENTS 15120 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPEADDTARGETVARIABLESMETHODTYPE 15121 /* Method */ +#define UA_NS0ID_TARGETVARIABLESTYPEADDTARGETVARIABLESMETHODTYPE_INPUTARGUMENTS 15122 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPEADDTARGETVARIABLESMETHODTYPE_OUTPUTARGUMENTS 15123 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPEREMOVETARGETVARIABLESMETHODTYPE 15124 /* Method */ +#define UA_NS0ID_TARGETVARIABLESTYPEREMOVETARGETVARIABLESMETHODTYPE_INPUTARGUMENTS 15125 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESTYPEREMOVETARGETVARIABLESMETHODTYPE_OUTPUTARGUMENTS 15126 /* Variable */ +#define UA_NS0ID_SUBSCRIBEDDATASETMIRRORTYPE 15127 /* ObjectType */ +#define UA_NS0ID_EXPRESSIONGUARDVARIABLETYPE 15128 /* VariableType */ +#define UA_NS0ID_EXPRESSIONGUARDVARIABLETYPE_EXPRESSION 15129 /* Variable */ +#define UA_NS0ID_REGISTERSERVER2RESPONSE_ENCODING_DEFAULTJSON 15130 /* Object */ +#define UA_NS0ID_CHANNELSECURITYTOKEN_ENCODING_DEFAULTJSON 15131 /* Object */ +#define UA_NS0ID_OPENSECURECHANNELREQUEST_ENCODING_DEFAULTJSON 15132 /* Object */ +#define UA_NS0ID_OPENSECURECHANNELRESPONSE_ENCODING_DEFAULTJSON 15133 /* Object */ +#define UA_NS0ID_CLOSESECURECHANNELREQUEST_ENCODING_DEFAULTJSON 15134 /* Object */ +#define UA_NS0ID_CLOSESECURECHANNELRESPONSE_ENCODING_DEFAULTJSON 15135 /* Object */ +#define UA_NS0ID_SIGNEDSOFTWARECERTIFICATE_ENCODING_DEFAULTJSON 15136 /* Object */ +#define UA_NS0ID_SIGNATUREDATA_ENCODING_DEFAULTJSON 15137 /* Object */ +#define UA_NS0ID_CREATESESSIONREQUEST_ENCODING_DEFAULTJSON 15138 /* Object */ +#define UA_NS0ID_CREATESESSIONRESPONSE_ENCODING_DEFAULTJSON 15139 /* Object */ +#define UA_NS0ID_USERIDENTITYTOKEN_ENCODING_DEFAULTJSON 15140 /* Object */ +#define UA_NS0ID_ANONYMOUSIDENTITYTOKEN_ENCODING_DEFAULTJSON 15141 /* Object */ +#define UA_NS0ID_USERNAMEIDENTITYTOKEN_ENCODING_DEFAULTJSON 15142 /* Object */ +#define UA_NS0ID_X509IDENTITYTOKEN_ENCODING_DEFAULTJSON 15143 /* Object */ +#define UA_NS0ID_ISSUEDIDENTITYTOKEN_ENCODING_DEFAULTJSON 15144 /* Object */ +#define UA_NS0ID_ACTIVATESESSIONREQUEST_ENCODING_DEFAULTJSON 15145 /* Object */ +#define UA_NS0ID_ACTIVATESESSIONRESPONSE_ENCODING_DEFAULTJSON 15146 /* Object */ +#define UA_NS0ID_CLOSESESSIONREQUEST_ENCODING_DEFAULTJSON 15147 /* Object */ +#define UA_NS0ID_CLOSESESSIONRESPONSE_ENCODING_DEFAULTJSON 15148 /* Object */ +#define UA_NS0ID_CANCELREQUEST_ENCODING_DEFAULTJSON 15149 /* Object */ +#define UA_NS0ID_CANCELRESPONSE_ENCODING_DEFAULTJSON 15150 /* Object */ +#define UA_NS0ID_NODEATTRIBUTES_ENCODING_DEFAULTJSON 15151 /* Object */ +#define UA_NS0ID_OBJECTATTRIBUTES_ENCODING_DEFAULTJSON 15152 /* Object */ +#define UA_NS0ID_VARIABLEATTRIBUTES_ENCODING_DEFAULTJSON 15153 /* Object */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTTYPE_DISCOVERYADDRESS_NETWORKINTERFACE 15154 /* Variable */ +#define UA_NS0ID_BROKERCONNECTIONTRANSPORTTYPE 15155 /* ObjectType */ +#define UA_NS0ID_BROKERCONNECTIONTRANSPORTTYPE_RESOURCEURI 15156 /* Variable */ +#define UA_NS0ID_METHODATTRIBUTES_ENCODING_DEFAULTJSON 15157 /* Object */ +#define UA_NS0ID_OBJECTTYPEATTRIBUTES_ENCODING_DEFAULTJSON 15158 /* Object */ +#define UA_NS0ID_VARIABLETYPEATTRIBUTES_ENCODING_DEFAULTJSON 15159 /* Object */ +#define UA_NS0ID_REFERENCETYPEATTRIBUTES_ENCODING_DEFAULTJSON 15160 /* Object */ +#define UA_NS0ID_DATATYPEATTRIBUTES_ENCODING_DEFAULTJSON 15161 /* Object */ +#define UA_NS0ID_VIEWATTRIBUTES_ENCODING_DEFAULTJSON 15162 /* Object */ +#define UA_NS0ID_GENERICATTRIBUTEVALUE_ENCODING_DEFAULTJSON 15163 /* Object */ +#define UA_NS0ID_GENERICATTRIBUTES_ENCODING_DEFAULTJSON 15164 /* Object */ +#define UA_NS0ID_ADDNODESITEM_ENCODING_DEFAULTJSON 15165 /* Object */ +#define UA_NS0ID_ADDNODESRESULT_ENCODING_DEFAULTJSON 15166 /* Object */ +#define UA_NS0ID_ADDNODESREQUEST_ENCODING_DEFAULTJSON 15167 /* Object */ +#define UA_NS0ID_ADDNODESRESPONSE_ENCODING_DEFAULTJSON 15168 /* Object */ +#define UA_NS0ID_ADDREFERENCESITEM_ENCODING_DEFAULTJSON 15169 /* Object */ +#define UA_NS0ID_ADDREFERENCESREQUEST_ENCODING_DEFAULTJSON 15170 /* Object */ +#define UA_NS0ID_ADDREFERENCESRESPONSE_ENCODING_DEFAULTJSON 15171 /* Object */ +#define UA_NS0ID_DELETENODESITEM_ENCODING_DEFAULTJSON 15172 /* Object */ +#define UA_NS0ID_DELETENODESREQUEST_ENCODING_DEFAULTJSON 15173 /* Object */ +#define UA_NS0ID_DELETENODESRESPONSE_ENCODING_DEFAULTJSON 15174 /* Object */ +#define UA_NS0ID_DELETEREFERENCESITEM_ENCODING_DEFAULTJSON 15175 /* Object */ +#define UA_NS0ID_DELETEREFERENCESREQUEST_ENCODING_DEFAULTJSON 15176 /* Object */ +#define UA_NS0ID_DELETEREFERENCESRESPONSE_ENCODING_DEFAULTJSON 15177 /* Object */ +#define UA_NS0ID_BROKERCONNECTIONTRANSPORTTYPE_AUTHENTICATIONPROFILEURI 15178 /* Variable */ +#define UA_NS0ID_VIEWDESCRIPTION_ENCODING_DEFAULTJSON 15179 /* Object */ +#define UA_NS0ID_BROWSEDESCRIPTION_ENCODING_DEFAULTJSON 15180 /* Object */ +#define UA_NS0ID_USERCREDENTIALCERTIFICATETYPE 15181 /* ObjectType */ +#define UA_NS0ID_REFERENCEDESCRIPTION_ENCODING_DEFAULTJSON 15182 /* Object */ +#define UA_NS0ID_BROWSERESULT_ENCODING_DEFAULTJSON 15183 /* Object */ +#define UA_NS0ID_BROWSEREQUEST_ENCODING_DEFAULTJSON 15184 /* Object */ +#define UA_NS0ID_BROWSERESPONSE_ENCODING_DEFAULTJSON 15185 /* Object */ +#define UA_NS0ID_BROWSENEXTREQUEST_ENCODING_DEFAULTJSON 15186 /* Object */ +#define UA_NS0ID_BROWSENEXTRESPONSE_ENCODING_DEFAULTJSON 15187 /* Object */ +#define UA_NS0ID_RELATIVEPATHELEMENT_ENCODING_DEFAULTJSON 15188 /* Object */ +#define UA_NS0ID_RELATIVEPATH_ENCODING_DEFAULTJSON 15189 /* Object */ +#define UA_NS0ID_BROWSEPATH_ENCODING_DEFAULTJSON 15190 /* Object */ +#define UA_NS0ID_BROWSEPATHTARGET_ENCODING_DEFAULTJSON 15191 /* Object */ +#define UA_NS0ID_BROWSEPATHRESULT_ENCODING_DEFAULTJSON 15192 /* Object */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSREQUEST_ENCODING_DEFAULTJSON 15193 /* Object */ +#define UA_NS0ID_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE_ENCODING_DEFAULTJSON 15194 /* Object */ +#define UA_NS0ID_REGISTERNODESREQUEST_ENCODING_DEFAULTJSON 15195 /* Object */ +#define UA_NS0ID_REGISTERNODESRESPONSE_ENCODING_DEFAULTJSON 15196 /* Object */ +#define UA_NS0ID_UNREGISTERNODESREQUEST_ENCODING_DEFAULTJSON 15197 /* Object */ +#define UA_NS0ID_UNREGISTERNODESRESPONSE_ENCODING_DEFAULTJSON 15198 /* Object */ +#define UA_NS0ID_ENDPOINTCONFIGURATION_ENCODING_DEFAULTJSON 15199 /* Object */ +#define UA_NS0ID_QUERYDATADESCRIPTION_ENCODING_DEFAULTJSON 15200 /* Object */ +#define UA_NS0ID_NODETYPEDESCRIPTION_ENCODING_DEFAULTJSON 15201 /* Object */ +#define UA_NS0ID_QUERYDATASET_ENCODING_DEFAULTJSON 15202 /* Object */ +#define UA_NS0ID_NODEREFERENCE_ENCODING_DEFAULTJSON 15203 /* Object */ +#define UA_NS0ID_CONTENTFILTERELEMENT_ENCODING_DEFAULTJSON 15204 /* Object */ +#define UA_NS0ID_CONTENTFILTER_ENCODING_DEFAULTJSON 15205 /* Object */ +#define UA_NS0ID_FILTEROPERAND_ENCODING_DEFAULTJSON 15206 /* Object */ +#define UA_NS0ID_ELEMENTOPERAND_ENCODING_DEFAULTJSON 15207 /* Object */ +#define UA_NS0ID_LITERALOPERAND_ENCODING_DEFAULTJSON 15208 /* Object */ +#define UA_NS0ID_ATTRIBUTEOPERAND_ENCODING_DEFAULTJSON 15209 /* Object */ +#define UA_NS0ID_SIMPLEATTRIBUTEOPERAND_ENCODING_DEFAULTJSON 15210 /* Object */ +#define UA_NS0ID_CONTENTFILTERELEMENTRESULT_ENCODING_DEFAULTJSON 15211 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_GETSECURITYKEYS 15212 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_GETSECURITYKEYS_INPUTARGUMENTS 15213 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_GETSECURITYKEYS_OUTPUTARGUMENTS 15214 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_GETSECURITYKEYS 15215 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_GETSECURITYKEYS_INPUTARGUMENTS 15216 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_GETSECURITYKEYS_OUTPUTARGUMENTS 15217 /* Variable */ +#define UA_NS0ID_GETSECURITYKEYSMETHODTYPE 15218 /* Method */ +#define UA_NS0ID_GETSECURITYKEYSMETHODTYPE_INPUTARGUMENTS 15219 /* Variable */ +#define UA_NS0ID_GETSECURITYKEYSMETHODTYPE_OUTPUTARGUMENTS 15220 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_DATASETMETADATA 15221 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER 15222 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS 15223 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_STATE 15224 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_ENABLE 15225 /* Method */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_DISABLE 15226 /* Method */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_TRANSPORTSETTINGS 15227 /* Object */ +#define UA_NS0ID_CONTENTFILTERRESULT_ENCODING_DEFAULTJSON 15228 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETMETADATA 15229 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER 15230 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS 15231 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_STATE 15232 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_ENABLE 15233 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_DISABLE 15234 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_TRANSPORTSETTINGS 15235 /* Object */ +#define UA_NS0ID_PARSINGRESULT_ENCODING_DEFAULTJSON 15236 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETMETADATA 15237 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER 15238 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS 15239 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_STATE 15240 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_ENABLE 15241 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_DISABLE 15242 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_TRANSPORTSETTINGS 15243 /* Object */ +#define UA_NS0ID_QUERYFIRSTREQUEST_ENCODING_DEFAULTJSON 15244 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETMETADATA 15245 /* Variable */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTTYPE_RESOURCEURI 15246 /* Variable */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTTYPE_AUTHENTICATIONPROFILEURI 15247 /* Variable */ +#define UA_NS0ID_CREATECREDENTIALMETHODTYPE 15248 /* Method */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTTYPE_REQUESTEDDELIVERYGUARANTEE 15249 /* Variable */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTTYPE_RESOURCEURI 15250 /* Variable */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTTYPE_AUTHENTICATIONPROFILEURI 15251 /* Variable */ +#define UA_NS0ID_QUERYFIRSTRESPONSE_ENCODING_DEFAULTJSON 15252 /* Object */ +#define UA_NS0ID_CREATECREDENTIALMETHODTYPE_INPUTARGUMENTS 15253 /* Variable */ +#define UA_NS0ID_QUERYNEXTREQUEST_ENCODING_DEFAULTJSON 15254 /* Object */ +#define UA_NS0ID_QUERYNEXTRESPONSE_ENCODING_DEFAULTJSON 15255 /* Object */ +#define UA_NS0ID_READVALUEID_ENCODING_DEFAULTJSON 15256 /* Object */ +#define UA_NS0ID_READREQUEST_ENCODING_DEFAULTJSON 15257 /* Object */ +#define UA_NS0ID_READRESPONSE_ENCODING_DEFAULTJSON 15258 /* Object */ +#define UA_NS0ID_HISTORYREADVALUEID_ENCODING_DEFAULTJSON 15259 /* Object */ +#define UA_NS0ID_HISTORYREADRESULT_ENCODING_DEFAULTJSON 15260 /* Object */ +#define UA_NS0ID_HISTORYREADDETAILS_ENCODING_DEFAULTJSON 15261 /* Object */ +#define UA_NS0ID_READEVENTDETAILS_ENCODING_DEFAULTJSON 15262 /* Object */ +#define UA_NS0ID_READRAWMODIFIEDDETAILS_ENCODING_DEFAULTJSON 15263 /* Object */ +#define UA_NS0ID_READPROCESSEDDETAILS_ENCODING_DEFAULTJSON 15264 /* Object */ +#define UA_NS0ID_PUBSUBGROUPTYPE_STATUS 15265 /* Object */ +#define UA_NS0ID_PUBSUBGROUPTYPE_STATUS_STATE 15266 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPE_STATUS_ENABLE 15267 /* Method */ +#define UA_NS0ID_PUBSUBGROUPTYPE_STATUS_DISABLE 15268 /* Method */ +#define UA_NS0ID_READATTIMEDETAILS_ENCODING_DEFAULTJSON 15269 /* Object */ +#define UA_NS0ID_HISTORYDATA_ENCODING_DEFAULTJSON 15270 /* Object */ +#define UA_NS0ID_MODIFICATIONINFO_ENCODING_DEFAULTJSON 15271 /* Object */ +#define UA_NS0ID_HISTORYMODIFIEDDATA_ENCODING_DEFAULTJSON 15272 /* Object */ +#define UA_NS0ID_HISTORYEVENT_ENCODING_DEFAULTJSON 15273 /* Object */ +#define UA_NS0ID_HISTORYREADREQUEST_ENCODING_DEFAULTJSON 15274 /* Object */ +#define UA_NS0ID_HISTORYREADRESPONSE_ENCODING_DEFAULTJSON 15275 /* Object */ +#define UA_NS0ID_WRITEVALUE_ENCODING_DEFAULTJSON 15276 /* Object */ +#define UA_NS0ID_WRITEREQUEST_ENCODING_DEFAULTJSON 15277 /* Object */ +#define UA_NS0ID_WRITERESPONSE_ENCODING_DEFAULTJSON 15278 /* Object */ +#define UA_NS0ID_HISTORYUPDATEDETAILS_ENCODING_DEFAULTJSON 15279 /* Object */ +#define UA_NS0ID_UPDATEDATADETAILS_ENCODING_DEFAULTJSON 15280 /* Object */ +#define UA_NS0ID_UPDATESTRUCTUREDATADETAILS_ENCODING_DEFAULTJSON 15281 /* Object */ +#define UA_NS0ID_UPDATEEVENTDETAILS_ENCODING_DEFAULTJSON 15282 /* Object */ +#define UA_NS0ID_DELETERAWMODIFIEDDETAILS_ENCODING_DEFAULTJSON 15283 /* Object */ +#define UA_NS0ID_DELETEATTIMEDETAILS_ENCODING_DEFAULTJSON 15284 /* Object */ +#define UA_NS0ID_DELETEEVENTDETAILS_ENCODING_DEFAULTJSON 15285 /* Object */ +#define UA_NS0ID_HISTORYUPDATERESULT_ENCODING_DEFAULTJSON 15286 /* Object */ +#define UA_NS0ID_HISTORYUPDATEREQUEST_ENCODING_DEFAULTJSON 15287 /* Object */ +#define UA_NS0ID_HISTORYUPDATERESPONSE_ENCODING_DEFAULTJSON 15288 /* Object */ +#define UA_NS0ID_CALLMETHODREQUEST_ENCODING_DEFAULTJSON 15289 /* Object */ +#define UA_NS0ID_CALLMETHODRESULT_ENCODING_DEFAULTJSON 15290 /* Object */ +#define UA_NS0ID_CALLREQUEST_ENCODING_DEFAULTJSON 15291 /* Object */ +#define UA_NS0ID_CALLRESPONSE_ENCODING_DEFAULTJSON 15292 /* Object */ +#define UA_NS0ID_MONITORINGFILTER_ENCODING_DEFAULTJSON 15293 /* Object */ +#define UA_NS0ID_DATACHANGEFILTER_ENCODING_DEFAULTJSON 15294 /* Object */ +#define UA_NS0ID_EVENTFILTER_ENCODING_DEFAULTJSON 15295 /* Object */ +#define UA_NS0ID_HASDATASETWRITER 15296 /* ReferenceType */ +#define UA_NS0ID_HASDATASETREADER 15297 /* ReferenceType */ +#define UA_NS0ID_DATASETWRITERTYPE 15298 /* ObjectType */ +#define UA_NS0ID_DATASETWRITERTYPE_STATUS 15299 /* Object */ +#define UA_NS0ID_DATASETWRITERTYPE_STATUS_STATE 15300 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_STATUS_ENABLE 15301 /* Method */ +#define UA_NS0ID_DATASETWRITERTYPE_STATUS_DISABLE 15302 /* Method */ +#define UA_NS0ID_DATASETWRITERTYPE_TRANSPORTSETTINGS 15303 /* Object */ +#define UA_NS0ID_AGGREGATECONFIGURATION_ENCODING_DEFAULTJSON 15304 /* Object */ +#define UA_NS0ID_DATASETWRITERTRANSPORTTYPE 15305 /* ObjectType */ +#define UA_NS0ID_DATASETREADERTYPE 15306 /* ObjectType */ +#define UA_NS0ID_DATASETREADERTYPE_STATUS 15307 /* Object */ +#define UA_NS0ID_DATASETREADERTYPE_STATUS_STATE 15308 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_STATUS_ENABLE 15309 /* Method */ +#define UA_NS0ID_DATASETREADERTYPE_STATUS_DISABLE 15310 /* Method */ +#define UA_NS0ID_DATASETREADERTYPE_TRANSPORTSETTINGS 15311 /* Object */ +#define UA_NS0ID_AGGREGATEFILTER_ENCODING_DEFAULTJSON 15312 /* Object */ +#define UA_NS0ID_MONITORINGFILTERRESULT_ENCODING_DEFAULTJSON 15313 /* Object */ +#define UA_NS0ID_EVENTFILTERRESULT_ENCODING_DEFAULTJSON 15314 /* Object */ +#define UA_NS0ID_AGGREGATEFILTERRESULT_ENCODING_DEFAULTJSON 15315 /* Object */ +#define UA_NS0ID_DATASETREADERTYPE_SUBSCRIBEDDATASET 15316 /* Object */ +#define UA_NS0ID_ELSEGUARDVARIABLETYPE 15317 /* VariableType */ +#define UA_NS0ID_BASEANALOGTYPE 15318 /* VariableType */ +#define UA_NS0ID_DATASETREADERTRANSPORTTYPE 15319 /* ObjectType */ +#define UA_NS0ID_MONITORINGPARAMETERS_ENCODING_DEFAULTJSON 15320 /* Object */ +#define UA_NS0ID_MONITOREDITEMCREATEREQUEST_ENCODING_DEFAULTJSON 15321 /* Object */ +#define UA_NS0ID_MONITOREDITEMCREATERESULT_ENCODING_DEFAULTJSON 15322 /* Object */ +#define UA_NS0ID_CREATEMONITOREDITEMSREQUEST_ENCODING_DEFAULTJSON 15323 /* Object */ +#define UA_NS0ID_CREATEMONITOREDITEMSRESPONSE_ENCODING_DEFAULTJSON 15324 /* Object */ +#define UA_NS0ID_MONITOREDITEMMODIFYREQUEST_ENCODING_DEFAULTJSON 15325 /* Object */ +#define UA_NS0ID_MONITOREDITEMMODIFYRESULT_ENCODING_DEFAULTJSON 15326 /* Object */ +#define UA_NS0ID_MODIFYMONITOREDITEMSREQUEST_ENCODING_DEFAULTJSON 15327 /* Object */ +#define UA_NS0ID_MODIFYMONITOREDITEMSRESPONSE_ENCODING_DEFAULTJSON 15328 /* Object */ +#define UA_NS0ID_SETMONITORINGMODEREQUEST_ENCODING_DEFAULTJSON 15329 /* Object */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTTYPE_REQUESTEDDELIVERYGUARANTEE 15330 /* Variable */ +#define UA_NS0ID_SETMONITORINGMODERESPONSE_ENCODING_DEFAULTJSON 15331 /* Object */ +#define UA_NS0ID_SETTRIGGERINGREQUEST_ENCODING_DEFAULTJSON 15332 /* Object */ +#define UA_NS0ID_SETTRIGGERINGRESPONSE_ENCODING_DEFAULTJSON 15333 /* Object */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTTYPE_RESOURCEURI 15334 /* Variable */ +#define UA_NS0ID_DELETEMONITOREDITEMSREQUEST_ENCODING_DEFAULTJSON 15335 /* Object */ +#define UA_NS0ID_DELETEMONITOREDITEMSRESPONSE_ENCODING_DEFAULTJSON 15336 /* Object */ +#define UA_NS0ID_CREATESUBSCRIPTIONREQUEST_ENCODING_DEFAULTJSON 15337 /* Object */ +#define UA_NS0ID_CREATESUBSCRIPTIONRESPONSE_ENCODING_DEFAULTJSON 15338 /* Object */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONREQUEST_ENCODING_DEFAULTJSON 15339 /* Object */ +#define UA_NS0ID_MODIFYSUBSCRIPTIONRESPONSE_ENCODING_DEFAULTJSON 15340 /* Object */ +#define UA_NS0ID_SETPUBLISHINGMODEREQUEST_ENCODING_DEFAULTJSON 15341 /* Object */ +#define UA_NS0ID_SETPUBLISHINGMODERESPONSE_ENCODING_DEFAULTJSON 15342 /* Object */ +#define UA_NS0ID_NOTIFICATIONMESSAGE_ENCODING_DEFAULTJSON 15343 /* Object */ +#define UA_NS0ID_NOTIFICATIONDATA_ENCODING_DEFAULTJSON 15344 /* Object */ +#define UA_NS0ID_DATACHANGENOTIFICATION_ENCODING_DEFAULTJSON 15345 /* Object */ +#define UA_NS0ID_MONITOREDITEMNOTIFICATION_ENCODING_DEFAULTJSON 15346 /* Object */ +#define UA_NS0ID_EVENTNOTIFICATIONLIST_ENCODING_DEFAULTJSON 15347 /* Object */ +#define UA_NS0ID_EVENTFIELDLIST_ENCODING_DEFAULTJSON 15348 /* Object */ +#define UA_NS0ID_HISTORYEVENTFIELDLIST_ENCODING_DEFAULTJSON 15349 /* Object */ +#define UA_NS0ID_STATUSCHANGENOTIFICATION_ENCODING_DEFAULTJSON 15350 /* Object */ +#define UA_NS0ID_SUBSCRIPTIONACKNOWLEDGEMENT_ENCODING_DEFAULTJSON 15351 /* Object */ +#define UA_NS0ID_PUBLISHREQUEST_ENCODING_DEFAULTJSON 15352 /* Object */ +#define UA_NS0ID_PUBLISHRESPONSE_ENCODING_DEFAULTJSON 15353 /* Object */ +#define UA_NS0ID_REPUBLISHREQUEST_ENCODING_DEFAULTJSON 15354 /* Object */ +#define UA_NS0ID_REPUBLISHRESPONSE_ENCODING_DEFAULTJSON 15355 /* Object */ +#define UA_NS0ID_TRANSFERRESULT_ENCODING_DEFAULTJSON 15356 /* Object */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSREQUEST_ENCODING_DEFAULTJSON 15357 /* Object */ +#define UA_NS0ID_TRANSFERSUBSCRIPTIONSRESPONSE_ENCODING_DEFAULTJSON 15358 /* Object */ +#define UA_NS0ID_DELETESUBSCRIPTIONSREQUEST_ENCODING_DEFAULTJSON 15359 /* Object */ +#define UA_NS0ID_DELETESUBSCRIPTIONSRESPONSE_ENCODING_DEFAULTJSON 15360 /* Object */ +#define UA_NS0ID_BUILDINFO_ENCODING_DEFAULTJSON 15361 /* Object */ +#define UA_NS0ID_REDUNDANTSERVERDATATYPE_ENCODING_DEFAULTJSON 15362 /* Object */ +#define UA_NS0ID_ENDPOINTURLLISTDATATYPE_ENCODING_DEFAULTJSON 15363 /* Object */ +#define UA_NS0ID_NETWORKGROUPDATATYPE_ENCODING_DEFAULTJSON 15364 /* Object */ +#define UA_NS0ID_SAMPLINGINTERVALDIAGNOSTICSDATATYPE_ENCODING_DEFAULTJSON 15365 /* Object */ +#define UA_NS0ID_SERVERDIAGNOSTICSSUMMARYDATATYPE_ENCODING_DEFAULTJSON 15366 /* Object */ +#define UA_NS0ID_SERVERSTATUSDATATYPE_ENCODING_DEFAULTJSON 15367 /* Object */ +#define UA_NS0ID_SESSIONDIAGNOSTICSDATATYPE_ENCODING_DEFAULTJSON 15368 /* Object */ +#define UA_NS0ID_SESSIONSECURITYDIAGNOSTICSDATATYPE_ENCODING_DEFAULTJSON 15369 /* Object */ +#define UA_NS0ID_SERVICECOUNTERDATATYPE_ENCODING_DEFAULTJSON 15370 /* Object */ +#define UA_NS0ID_STATUSRESULT_ENCODING_DEFAULTJSON 15371 /* Object */ +#define UA_NS0ID_SUBSCRIPTIONDIAGNOSTICSDATATYPE_ENCODING_DEFAULTJSON 15372 /* Object */ +#define UA_NS0ID_MODELCHANGESTRUCTUREDATATYPE_ENCODING_DEFAULTJSON 15373 /* Object */ +#define UA_NS0ID_SEMANTICCHANGESTRUCTUREDATATYPE_ENCODING_DEFAULTJSON 15374 /* Object */ +#define UA_NS0ID_RANGE_ENCODING_DEFAULTJSON 15375 /* Object */ +#define UA_NS0ID_EUINFORMATION_ENCODING_DEFAULTJSON 15376 /* Object */ +#define UA_NS0ID_COMPLEXNUMBERTYPE_ENCODING_DEFAULTJSON 15377 /* Object */ +#define UA_NS0ID_DOUBLECOMPLEXNUMBERTYPE_ENCODING_DEFAULTJSON 15378 /* Object */ +#define UA_NS0ID_AXISINFORMATION_ENCODING_DEFAULTJSON 15379 /* Object */ +#define UA_NS0ID_XVTYPE_ENCODING_DEFAULTJSON 15380 /* Object */ +#define UA_NS0ID_PROGRAMDIAGNOSTICDATATYPE_ENCODING_DEFAULTJSON 15381 /* Object */ +#define UA_NS0ID_ANNOTATION_ENCODING_DEFAULTJSON 15382 /* Object */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE 15383 /* VariableType */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_CREATESESSIONID 15384 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_CREATECLIENTNAME 15385 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_INVOCATIONCREATIONTIME 15386 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTTRANSITIONTIME 15387 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODCALL 15388 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODSESSIONID 15389 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODINPUTARGUMENTS 15390 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODOUTPUTARGUMENTS 15391 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODINPUTVALUES 15392 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODOUTPUTVALUES 15393 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODCALLTIME 15394 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2TYPE_LASTMETHODRETURNSTATUS 15395 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2DATATYPE 15396 /* DataType */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2DATATYPE_ENCODING_DEFAULTBINARY 15397 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PROGRAMDIAGNOSTIC2DATATYPE 15398 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PROGRAMDIAGNOSTIC2DATATYPE_DATATYPEVERSION 15399 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PROGRAMDIAGNOSTIC2DATATYPE_DICTIONARYFRAGMENT 15400 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2DATATYPE_ENCODING_DEFAULTXML 15401 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PROGRAMDIAGNOSTIC2DATATYPE 15402 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PROGRAMDIAGNOSTIC2DATATYPE_DATATYPEVERSION 15403 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PROGRAMDIAGNOSTIC2DATATYPE_DICTIONARYFRAGMENT 15404 /* Variable */ +#define UA_NS0ID_PROGRAMDIAGNOSTIC2DATATYPE_ENCODING_DEFAULTJSON 15405 /* Object */ +#define UA_NS0ID_ACCESSLEVELEXTYPE 15406 /* DataType */ +#define UA_NS0ID_ACCESSLEVELEXTYPE_OPTIONSETVALUES 15407 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_APPLICATIONSEXCLUDE 15408 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ENDPOINTSEXCLUDE 15409 /* Variable */ +#define UA_NS0ID_ROLETYPE_APPLICATIONSEXCLUDE 15410 /* Variable */ +#define UA_NS0ID_ROLETYPE_ENDPOINTSEXCLUDE 15411 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_APPLICATIONSEXCLUDE 15412 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ENDPOINTSEXCLUDE 15413 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_APPLICATIONSEXCLUDE 15414 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ENDPOINTSEXCLUDE 15415 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_APPLICATIONSEXCLUDE 15416 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ENDPOINTSEXCLUDE 15417 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_APPLICATIONSEXCLUDE 15418 /* Variable */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTTYPE_AUTHENTICATIONPROFILEURI 15419 /* Variable */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTTYPE_REQUESTEDDELIVERYGUARANTEE 15420 /* Variable */ +#define UA_NS0ID_SIMPLETYPEDESCRIPTION_ENCODING_DEFAULTBINARY 15421 /* Object */ +#define UA_NS0ID_UABINARYFILEDATATYPE_ENCODING_DEFAULTBINARY 15422 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ENDPOINTSEXCLUDE 15423 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_APPLICATIONSEXCLUDE 15424 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ENDPOINTSEXCLUDE 15425 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_APPLICATIONSEXCLUDE 15426 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ENDPOINTSEXCLUDE 15427 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_APPLICATIONSEXCLUDE 15428 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ENDPOINTSEXCLUDE 15429 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_APPLICATIONSEXCLUDE 15430 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_GETSECURITYGROUP 15431 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_GETSECURITYGROUP_INPUTARGUMENTS 15432 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_GETSECURITYGROUP_OUTPUTARGUMENTS 15433 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SECURITYGROUPS 15434 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SECURITYGROUPS_ADDSECURITYGROUP 15435 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SECURITYGROUPS_ADDSECURITYGROUP_INPUTARGUMENTS 15436 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SECURITYGROUPS_ADDSECURITYGROUP_OUTPUTARGUMENTS 15437 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SECURITYGROUPS_REMOVESECURITYGROUP 15438 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SECURITYGROUPS_REMOVESECURITYGROUP_INPUTARGUMENTS 15439 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_GETSECURITYGROUP 15440 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_GETSECURITYGROUP_INPUTARGUMENTS 15441 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_GETSECURITYGROUP_OUTPUTARGUMENTS 15442 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SECURITYGROUPS 15443 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SECURITYGROUPS_ADDSECURITYGROUP 15444 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SECURITYGROUPS_ADDSECURITYGROUP_INPUTARGUMENTS 15445 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SECURITYGROUPS_ADDSECURITYGROUP_OUTPUTARGUMENTS 15446 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SECURITYGROUPS_REMOVESECURITYGROUP 15447 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SECURITYGROUPS_REMOVESECURITYGROUP_INPUTARGUMENTS 15448 /* Variable */ +#define UA_NS0ID_GETSECURITYGROUPMETHODTYPE 15449 /* Method */ +#define UA_NS0ID_GETSECURITYGROUPMETHODTYPE_INPUTARGUMENTS 15450 /* Variable */ +#define UA_NS0ID_GETSECURITYGROUPMETHODTYPE_OUTPUTARGUMENTS 15451 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE 15452 /* ObjectType */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPFOLDERNAME_PLACEHOLDER 15453 /* Object */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPFOLDERNAME_PLACEHOLDER_ADDSECURITYGROUP 15454 /* Method */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPFOLDERNAME_PLACEHOLDER_ADDSECURITYGROUP_INPUTARGUMENTS 15455 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPFOLDERNAME_PLACEHOLDER_ADDSECURITYGROUP_OUTPUTARGUMENTS 15456 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPFOLDERNAME_PLACEHOLDER_REMOVESECURITYGROUP 15457 /* Method */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPFOLDERNAME_PLACEHOLDER_REMOVESECURITYGROUP_INPUTARGUMENTS 15458 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPNAME_PLACEHOLDER 15459 /* Object */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_SECURITYGROUPNAME_PLACEHOLDER_SECURITYGROUPID 15460 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_ADDSECURITYGROUP 15461 /* Method */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_ADDSECURITYGROUP_INPUTARGUMENTS 15462 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_ADDSECURITYGROUP_OUTPUTARGUMENTS 15463 /* Variable */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_REMOVESECURITYGROUP 15464 /* Method */ +#define UA_NS0ID_SECURITYGROUPFOLDERTYPE_REMOVESECURITYGROUP_INPUTARGUMENTS 15465 /* Variable */ +#define UA_NS0ID_ADDSECURITYGROUPMETHODTYPE 15466 /* Method */ +#define UA_NS0ID_ADDSECURITYGROUPMETHODTYPE_INPUTARGUMENTS 15467 /* Variable */ +#define UA_NS0ID_ADDSECURITYGROUPMETHODTYPE_OUTPUTARGUMENTS 15468 /* Variable */ +#define UA_NS0ID_REMOVESECURITYGROUPMETHODTYPE 15469 /* Method */ +#define UA_NS0ID_REMOVESECURITYGROUPMETHODTYPE_INPUTARGUMENTS 15470 /* Variable */ +#define UA_NS0ID_SECURITYGROUPTYPE 15471 /* ObjectType */ +#define UA_NS0ID_SECURITYGROUPTYPE_SECURITYGROUPID 15472 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_EXTENSIONFIELDS 15473 /* Object */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_EXTENSIONFIELDS_ADDEXTENSIONFIELD 15474 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_EXTENSIONFIELDS_ADDEXTENSIONFIELD_INPUTARGUMENTS 15475 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_EXTENSIONFIELDS_ADDEXTENSIONFIELD_OUTPUTARGUMENTS 15476 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD 15477 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD_INPUTARGUMENTS 15478 /* Variable */ +#define UA_NS0ID_BROKERCONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15479 /* Object */ +#define UA_NS0ID_WRITERGROUPDATATYPE 15480 /* DataType */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_EXTENSIONFIELDS 15481 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD 15482 /* Method */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD_INPUTARGUMENTS 15483 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD_OUTPUTARGUMENTS 15484 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD 15485 /* Method */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD_INPUTARGUMENTS 15486 /* Variable */ +#define UA_NS0ID_STRUCTUREDESCRIPTION 15487 /* DataType */ +#define UA_NS0ID_ENUMDESCRIPTION 15488 /* DataType */ +#define UA_NS0ID_EXTENSIONFIELDSTYPE 15489 /* ObjectType */ +#define UA_NS0ID_EXTENSIONFIELDSTYPE_EXTENSIONFIELDNAME_PLACEHOLDER 15490 /* Variable */ +#define UA_NS0ID_EXTENSIONFIELDSTYPE_ADDEXTENSIONFIELD 15491 /* Method */ +#define UA_NS0ID_EXTENSIONFIELDSTYPE_ADDEXTENSIONFIELD_INPUTARGUMENTS 15492 /* Variable */ +#define UA_NS0ID_EXTENSIONFIELDSTYPE_ADDEXTENSIONFIELD_OUTPUTARGUMENTS 15493 /* Variable */ +#define UA_NS0ID_EXTENSIONFIELDSTYPE_REMOVEEXTENSIONFIELD 15494 /* Method */ +#define UA_NS0ID_EXTENSIONFIELDSTYPE_REMOVEEXTENSIONFIELD_INPUTARGUMENTS 15495 /* Variable */ +#define UA_NS0ID_ADDEXTENSIONFIELDMETHODTYPE 15496 /* Method */ +#define UA_NS0ID_ADDEXTENSIONFIELDMETHODTYPE_INPUTARGUMENTS 15497 /* Variable */ +#define UA_NS0ID_ADDEXTENSIONFIELDMETHODTYPE_OUTPUTARGUMENTS 15498 /* Variable */ +#define UA_NS0ID_REMOVEEXTENSIONFIELDMETHODTYPE 15499 /* Method */ +#define UA_NS0ID_REMOVEEXTENSIONFIELDMETHODTYPE_INPUTARGUMENTS 15500 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIMPLETYPEDESCRIPTION 15501 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSDATATYPE 15502 /* DataType */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_EXTENSIONFIELDS 15503 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD 15504 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD_INPUTARGUMENTS 15505 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD_OUTPUTARGUMENTS 15506 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD 15507 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD_INPUTARGUMENTS 15508 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIMPLETYPEDESCRIPTION_DATATYPEVERSION 15509 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSURLDATATYPE 15510 /* DataType */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_EXTENSIONFIELDS 15511 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD 15512 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD_INPUTARGUMENTS 15513 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_EXTENSIONFIELDS_ADDEXTENSIONFIELD_OUTPUTARGUMENTS 15514 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD 15515 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_EXTENSIONFIELDS_REMOVEEXTENSIONFIELD_INPUTARGUMENTS 15516 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_MODIFYFIELDSELECTION_OUTPUTARGUMENTS 15517 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPEMODIFYFIELDSELECTIONMETHODTYPE_OUTPUTARGUMENTS 15518 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SIMPLETYPEDESCRIPTION_DICTIONARYFRAGMENT 15519 /* Variable */ +#define UA_NS0ID_READERGROUPDATATYPE 15520 /* DataType */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UABINARYFILEDATATYPE 15521 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UABINARYFILEDATATYPE_DATATYPEVERSION 15522 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UABINARYFILEDATATYPE_DICTIONARYFRAGMENT 15523 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERCONNECTIONTRANSPORTDATATYPE 15524 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERCONNECTIONTRANSPORTDATATYPE_DATATYPEVERSION 15525 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERCONNECTIONTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15526 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ENDPOINTSEXCLUDE 15527 /* Variable */ +#define UA_NS0ID_ENDPOINTTYPE 15528 /* DataType */ +#define UA_NS0ID_SIMPLETYPEDESCRIPTION_ENCODING_DEFAULTXML 15529 /* Object */ +#define UA_NS0ID_PUBSUBCONFIGURATIONDATATYPE 15530 /* DataType */ +#define UA_NS0ID_UABINARYFILEDATATYPE_ENCODING_DEFAULTXML 15531 /* Object */ +#define UA_NS0ID_DATAGRAMWRITERGROUPTRANSPORTDATATYPE 15532 /* DataType */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE 15533 /* Variable */ +#define UA_NS0ID_DATATYPESCHEMAHEADER 15534 /* DataType */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE 15535 /* ObjectType */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_EVENTID 15536 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_EVENTTYPE 15537 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_SOURCENODE 15538 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_SOURCENAME 15539 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_TIME 15540 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_RECEIVETIME 15541 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_LOCALTIME 15542 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_MESSAGE 15543 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_SEVERITY 15544 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_CONNECTIONID 15545 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_GROUPID 15546 /* Variable */ +#define UA_NS0ID_PUBSUBSTATUSEVENTTYPE_STATE 15547 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE 15548 /* ObjectType */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_EVENTID 15549 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_EVENTTYPE 15550 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_SOURCENODE 15551 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_SOURCENAME 15552 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_TIME 15553 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_RECEIVETIME 15554 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_LOCALTIME 15555 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_MESSAGE 15556 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_SEVERITY 15557 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_CONNECTIONID 15558 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_GROUPID 15559 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_STATE 15560 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_ACTUAL 15561 /* Variable */ +#define UA_NS0ID_PUBSUBTRANSPORTLIMITSEXCEEDEVENTTYPE_MAXIMUM 15562 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE 15563 /* ObjectType */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_EVENTID 15564 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_EVENTTYPE 15565 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_SOURCENODE 15566 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_SOURCENAME 15567 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_TIME 15568 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_RECEIVETIME 15569 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_LOCALTIME 15570 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_MESSAGE 15571 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_SEVERITY 15572 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_CONNECTIONID 15573 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_GROUPID 15574 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_STATE 15575 /* Variable */ +#define UA_NS0ID_PUBSUBCOMMUNICATIONFAILUREEVENTTYPE_ERROR 15576 /* Variable */ +#define UA_NS0ID_DATASETFIELDFLAGS_OPTIONSETVALUES 15577 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETDATATYPE 15578 /* DataType */ +#define UA_NS0ID_BROKERCONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTXML 15579 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETSOURCEDATATYPE 15580 /* DataType */ +#define UA_NS0ID_PUBLISHEDDATAITEMSDATATYPE 15581 /* DataType */ +#define UA_NS0ID_PUBLISHEDEVENTSDATATYPE 15582 /* DataType */ +#define UA_NS0ID_DATASETFIELDCONTENTMASK 15583 /* DataType */ +#define UA_NS0ID_DATASETFIELDCONTENTMASK_OPTIONSETVALUES 15584 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIMPLETYPEDESCRIPTION 15585 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIMPLETYPEDESCRIPTION_DATATYPEVERSION 15586 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SIMPLETYPEDESCRIPTION_DICTIONARYFRAGMENT 15587 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UABINARYFILEDATATYPE 15588 /* Variable */ +#define UA_NS0ID_STRUCTUREDESCRIPTION_ENCODING_DEFAULTXML 15589 /* Object */ +#define UA_NS0ID_ENUMDESCRIPTION_ENCODING_DEFAULTXML 15590 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREDESCRIPTION 15591 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREDESCRIPTION_DATATYPEVERSION 15592 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREDESCRIPTION_DICTIONARYFRAGMENT 15593 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMDESCRIPTION 15594 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMDESCRIPTION_DATATYPEVERSION 15595 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMDESCRIPTION_DICTIONARYFRAGMENT 15596 /* Variable */ +#define UA_NS0ID_DATASETWRITERDATATYPE 15597 /* DataType */ +#define UA_NS0ID_DATASETWRITERTRANSPORTDATATYPE 15598 /* DataType */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREDESCRIPTION 15599 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREDESCRIPTION_DATATYPEVERSION 15600 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREDESCRIPTION_DICTIONARYFRAGMENT 15601 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMDESCRIPTION 15602 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMDESCRIPTION_DATATYPEVERSION 15603 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMDESCRIPTION_DICTIONARYFRAGMENT 15604 /* Variable */ +#define UA_NS0ID_DATASETWRITERMESSAGEDATATYPE 15605 /* DataType */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_ROLESET 15606 /* Object */ +#define UA_NS0ID_ROLESETTYPE 15607 /* ObjectType */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER 15608 /* Object */ +#define UA_NS0ID_PUBSUBGROUPDATATYPE 15609 /* DataType */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UABINARYFILEDATATYPE_DATATYPEVERSION 15610 /* Variable */ +#define UA_NS0ID_WRITERGROUPTRANSPORTDATATYPE 15611 /* DataType */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ADDIDENTITY 15612 /* Method */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ADDIDENTITY_INPUTARGUMENTS 15613 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_REMOVEIDENTITY 15614 /* Method */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_REMOVEIDENTITY_INPUTARGUMENTS 15615 /* Variable */ +#define UA_NS0ID_WRITERGROUPMESSAGEDATATYPE 15616 /* DataType */ +#define UA_NS0ID_PUBSUBCONNECTIONDATATYPE 15617 /* DataType */ +#define UA_NS0ID_CONNECTIONTRANSPORTDATATYPE 15618 /* DataType */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UABINARYFILEDATATYPE_DICTIONARYFRAGMENT 15619 /* Variable */ +#define UA_NS0ID_ROLETYPE 15620 /* ObjectType */ +#define UA_NS0ID_READERGROUPTRANSPORTDATATYPE 15621 /* DataType */ +#define UA_NS0ID_READERGROUPMESSAGEDATATYPE 15622 /* DataType */ +#define UA_NS0ID_DATASETREADERDATATYPE 15623 /* DataType */ +#define UA_NS0ID_ROLETYPE_ADDIDENTITY 15624 /* Method */ +#define UA_NS0ID_ROLETYPE_ADDIDENTITY_INPUTARGUMENTS 15625 /* Variable */ +#define UA_NS0ID_ROLETYPE_REMOVEIDENTITY 15626 /* Method */ +#define UA_NS0ID_ROLETYPE_REMOVEIDENTITY_INPUTARGUMENTS 15627 /* Variable */ +#define UA_NS0ID_DATASETREADERTRANSPORTDATATYPE 15628 /* DataType */ +#define UA_NS0ID_DATASETREADERMESSAGEDATATYPE 15629 /* DataType */ +#define UA_NS0ID_SUBSCRIBEDDATASETDATATYPE 15630 /* DataType */ +#define UA_NS0ID_TARGETVARIABLESDATATYPE 15631 /* DataType */ +#define UA_NS0ID_IDENTITYCRITERIATYPE 15632 /* DataType */ +#define UA_NS0ID_IDENTITYCRITERIATYPE_ENUMVALUES 15633 /* Variable */ +#define UA_NS0ID_IDENTITYMAPPINGRULETYPE 15634 /* DataType */ +#define UA_NS0ID_SUBSCRIBEDDATASETMIRRORDATATYPE 15635 /* DataType */ +#define UA_NS0ID_ADDIDENTITYMETHODTYPE 15636 /* Method */ +#define UA_NS0ID_ADDIDENTITYMETHODTYPE_INPUTARGUMENTS 15637 /* Variable */ +#define UA_NS0ID_REMOVEIDENTITYMETHODTYPE 15638 /* Method */ +#define UA_NS0ID_REMOVEIDENTITYMETHODTYPE_INPUTARGUMENTS 15639 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERCONNECTIONTRANSPORTDATATYPE 15640 /* Variable */ +#define UA_NS0ID_DATASETORDERINGTYPE_ENUMSTRINGS 15641 /* Variable */ +#define UA_NS0ID_UADPNETWORKMESSAGECONTENTMASK 15642 /* DataType */ +#define UA_NS0ID_UADPNETWORKMESSAGECONTENTMASK_OPTIONSETVALUES 15643 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS 15644 /* Object */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGEDATATYPE 15645 /* DataType */ +#define UA_NS0ID_UADPDATASETMESSAGECONTENTMASK 15646 /* DataType */ +#define UA_NS0ID_UADPDATASETMESSAGECONTENTMASK_OPTIONSETVALUES 15647 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ADDIDENTITY 15648 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ADDIDENTITY_INPUTARGUMENTS 15649 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_REMOVEIDENTITY 15650 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_REMOVEIDENTITY_INPUTARGUMENTS 15651 /* Variable */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGEDATATYPE 15652 /* DataType */ +#define UA_NS0ID_UADPDATASETREADERMESSAGEDATATYPE 15653 /* DataType */ +#define UA_NS0ID_JSONNETWORKMESSAGECONTENTMASK 15654 /* DataType */ +#define UA_NS0ID_JSONNETWORKMESSAGECONTENTMASK_OPTIONSETVALUES 15655 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER 15656 /* Object */ +#define UA_NS0ID_JSONWRITERGROUPMESSAGEDATATYPE 15657 /* DataType */ +#define UA_NS0ID_JSONDATASETMESSAGECONTENTMASK 15658 /* DataType */ +#define UA_NS0ID_JSONDATASETMESSAGECONTENTMASK_OPTIONSETVALUES 15659 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ADDIDENTITY 15660 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ADDIDENTITY_INPUTARGUMENTS 15661 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_REMOVEIDENTITY 15662 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_REMOVEIDENTITY_INPUTARGUMENTS 15663 /* Variable */ +#define UA_NS0ID_JSONDATASETWRITERMESSAGEDATATYPE 15664 /* DataType */ +#define UA_NS0ID_JSONDATASETREADERMESSAGEDATATYPE 15665 /* DataType */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERCONNECTIONTRANSPORTDATATYPE_DATATYPEVERSION 15666 /* Variable */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTDATATYPE 15667 /* DataType */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER 15668 /* Object */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTDATATYPE 15669 /* DataType */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTDATATYPE 15670 /* DataType */ +#define UA_NS0ID_ENDPOINTTYPE_ENCODING_DEFAULTBINARY 15671 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ADDIDENTITY 15672 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ADDIDENTITY_INPUTARGUMENTS 15673 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_REMOVEIDENTITY 15674 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_REMOVEIDENTITY_INPUTARGUMENTS 15675 /* Variable */ +#define UA_NS0ID_DATATYPESCHEMAHEADER_ENCODING_DEFAULTBINARY 15676 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETDATATYPE_ENCODING_DEFAULTBINARY 15677 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETSOURCEDATATYPE_ENCODING_DEFAULTBINARY 15678 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSDATATYPE_ENCODING_DEFAULTBINARY 15679 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR 15680 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSDATATYPE_ENCODING_DEFAULTBINARY 15681 /* Object */ +#define UA_NS0ID_DATASETWRITERDATATYPE_ENCODING_DEFAULTBINARY 15682 /* Object */ +#define UA_NS0ID_DATASETWRITERTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15683 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ADDIDENTITY 15684 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ADDIDENTITY_INPUTARGUMENTS 15685 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_REMOVEIDENTITY 15686 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_REMOVEIDENTITY_INPUTARGUMENTS 15687 /* Variable */ +#define UA_NS0ID_DATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15688 /* Object */ +#define UA_NS0ID_PUBSUBGROUPDATATYPE_ENCODING_DEFAULTBINARY 15689 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERCONNECTIONTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15690 /* Variable */ +#define UA_NS0ID_WRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15691 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR 15692 /* Object */ +#define UA_NS0ID_WRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15693 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONDATATYPE_ENCODING_DEFAULTBINARY 15694 /* Object */ +#define UA_NS0ID_CONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15695 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ADDIDENTITY 15696 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ADDIDENTITY_INPUTARGUMENTS 15697 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_REMOVEIDENTITY 15698 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_REMOVEIDENTITY_INPUTARGUMENTS 15699 /* Variable */ +#define UA_NS0ID_SIMPLETYPEDESCRIPTION_ENCODING_DEFAULTJSON 15700 /* Object */ +#define UA_NS0ID_READERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15701 /* Object */ +#define UA_NS0ID_READERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15702 /* Object */ +#define UA_NS0ID_DATASETREADERDATATYPE_ENCODING_DEFAULTBINARY 15703 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN 15704 /* Object */ +#define UA_NS0ID_DATASETREADERTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15705 /* Object */ +#define UA_NS0ID_DATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15706 /* Object */ +#define UA_NS0ID_SUBSCRIBEDDATASETDATATYPE_ENCODING_DEFAULTBINARY 15707 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ADDIDENTITY 15708 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ADDIDENTITY_INPUTARGUMENTS 15709 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_REMOVEIDENTITY 15710 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_REMOVEIDENTITY_INPUTARGUMENTS 15711 /* Variable */ +#define UA_NS0ID_TARGETVARIABLESDATATYPE_ENCODING_DEFAULTBINARY 15712 /* Object */ +#define UA_NS0ID_SUBSCRIBEDDATASETMIRRORDATATYPE_ENCODING_DEFAULTBINARY 15713 /* Object */ +#define UA_NS0ID_UABINARYFILEDATATYPE_ENCODING_DEFAULTJSON 15714 /* Object */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15715 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN 15716 /* Object */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15717 /* Object */ +#define UA_NS0ID_UADPDATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15718 /* Object */ +#define UA_NS0ID_JSONWRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15719 /* Object */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ADDIDENTITY 15720 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ADDIDENTITY_INPUTARGUMENTS 15721 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_REMOVEIDENTITY 15722 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_REMOVEIDENTITY_INPUTARGUMENTS 15723 /* Variable */ +#define UA_NS0ID_JSONDATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15724 /* Object */ +#define UA_NS0ID_JSONDATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTBINARY 15725 /* Object */ +#define UA_NS0ID_BROKERCONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 15726 /* Object */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15727 /* Object */ +#define UA_NS0ID_IDENTITYMAPPINGRULETYPE_ENCODING_DEFAULTXML 15728 /* Object */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15729 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_IDENTITYMAPPINGRULETYPE 15730 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_IDENTITYMAPPINGRULETYPE_DATATYPEVERSION 15731 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_IDENTITYMAPPINGRULETYPE_DICTIONARYFRAGMENT 15732 /* Variable */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 15733 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTTYPE 15734 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTTYPE_DATATYPEVERSION 15735 /* Variable */ +#define UA_NS0ID_IDENTITYMAPPINGRULETYPE_ENCODING_DEFAULTBINARY 15736 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENDPOINTTYPE_DICTIONARYFRAGMENT 15737 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_IDENTITYMAPPINGRULETYPE 15738 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_IDENTITYMAPPINGRULETYPE_DATATYPEVERSION 15739 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_IDENTITYMAPPINGRULETYPE_DICTIONARYFRAGMENT 15740 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPESCHEMAHEADER 15741 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPESCHEMAHEADER_DATATYPEVERSION 15742 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPESCHEMAHEADER_DICTIONARYFRAGMENT 15743 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE 15744 /* ObjectType */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_CLIENTPROCESSINGTIMEOUT 15745 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_GENERATEFILEFORREAD 15746 /* Method */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_GENERATEFILEFORREAD_INPUTARGUMENTS 15747 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_GENERATEFILEFORREAD_OUTPUTARGUMENTS 15748 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_GENERATEFILEFORWRITE 15749 /* Method */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_GENERATEFILEFORWRITE_OUTPUTARGUMENTS 15750 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_CLOSEANDCOMMIT 15751 /* Method */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_CLOSEANDCOMMIT_INPUTARGUMENTS 15752 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_CLOSEANDCOMMIT_OUTPUTARGUMENTS 15753 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER 15754 /* Object */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_CURRENTSTATE 15755 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_CURRENTSTATE_ID 15756 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_CURRENTSTATE_NAME 15757 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_CURRENTSTATE_NUMBER 15758 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_CURRENTSTATE_EFFECTIVEDISPLAYNAME 15759 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_LASTTRANSITION 15760 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_LASTTRANSITION_ID 15761 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_LASTTRANSITION_NAME 15762 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_LASTTRANSITION_NUMBER 15763 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_LASTTRANSITION_TRANSITIONTIME 15764 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_LASTTRANSITION_EFFECTIVETRANSITIONTIME 15765 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATASETDATATYPE 15766 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATASETDATATYPE_DATATYPEVERSION 15767 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATASETDATATYPE_DICTIONARYFRAGMENT 15768 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATASETSOURCEDATATYPE 15769 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATASETSOURCEDATATYPE_DATATYPEVERSION 15770 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATASETSOURCEDATATYPE_DICTIONARYFRAGMENT 15771 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATAITEMSDATATYPE 15772 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATAITEMSDATATYPE_DATATYPEVERSION 15773 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDDATAITEMSDATATYPE_DICTIONARYFRAGMENT 15774 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDEVENTSDATATYPE 15775 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDEVENTSDATATYPE_DATATYPEVERSION 15776 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBLISHEDEVENTSDATATYPE_DICTIONARYFRAGMENT 15777 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERDATATYPE 15778 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERDATATYPE_DATATYPEVERSION 15779 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERDATATYPE_DICTIONARYFRAGMENT 15780 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERTRANSPORTDATATYPE 15781 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERTRANSPORTDATATYPE_DATATYPEVERSION 15782 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15783 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERMESSAGEDATATYPE 15784 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERMESSAGEDATATYPE_DATATYPEVERSION 15785 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETWRITERMESSAGEDATATYPE_DICTIONARYFRAGMENT 15786 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBGROUPDATATYPE 15787 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBGROUPDATATYPE_DATATYPEVERSION 15788 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBGROUPDATATYPE_DICTIONARYFRAGMENT 15789 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER 15790 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_PUBLISHERID 15791 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI 15792 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPTRANSPORTDATATYPE 15793 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_RESET 15794 /* Method */ +#define UA_NS0ID_GENERATEFILEFORREADMETHODTYPE 15795 /* Method */ +#define UA_NS0ID_GENERATEFILEFORREADMETHODTYPE_INPUTARGUMENTS 15796 /* Variable */ +#define UA_NS0ID_GENERATEFILEFORREADMETHODTYPE_OUTPUTARGUMENTS 15797 /* Variable */ +#define UA_NS0ID_GENERATEFILEFORWRITEMETHODTYPE 15798 /* Method */ +#define UA_NS0ID_GENERATEFILEFORWRITEMETHODTYPE_OUTPUTARGUMENTS 15799 /* Variable */ +#define UA_NS0ID_CLOSEANDCOMMITMETHODTYPE 15800 /* Method */ +#define UA_NS0ID_CLOSEANDCOMMITMETHODTYPE_INPUTARGUMENTS 15801 /* Variable */ +#define UA_NS0ID_CLOSEANDCOMMITMETHODTYPE_OUTPUTARGUMENTS 15802 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE 15803 /* ObjectType */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_CURRENTSTATE 15804 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_CURRENTSTATE_ID 15805 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_CURRENTSTATE_NAME 15806 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_CURRENTSTATE_NUMBER 15807 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 15808 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_LASTTRANSITION 15809 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_LASTTRANSITION_ID 15810 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_LASTTRANSITION_NAME 15811 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_LASTTRANSITION_NUMBER 15812 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_LASTTRANSITION_TRANSITIONTIME 15813 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 15814 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_IDLE 15815 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_IDLE_STATENUMBER 15816 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READPREPARE 15817 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READPREPARE_STATENUMBER 15818 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READTRANSFER 15819 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READTRANSFER_STATENUMBER 15820 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_APPLYWRITE 15821 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_APPLYWRITE_STATENUMBER 15822 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_ERROR 15823 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_ERROR_STATENUMBER 15824 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_IDLETOREADPREPARE 15825 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_IDLETOREADPREPARE_TRANSITIONNUMBER 15826 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READPREPARETOREADTRANSFER 15827 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READPREPARETOREADTRANSFER_TRANSITIONNUMBER 15828 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READTRANSFERTOIDLE 15829 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READTRANSFERTOIDLE_TRANSITIONNUMBER 15830 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_IDLETOAPPLYWRITE 15831 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_IDLETOAPPLYWRITE_TRANSITIONNUMBER 15832 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_APPLYWRITETOIDLE 15833 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_APPLYWRITETOIDLE_TRANSITIONNUMBER 15834 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READPREPARETOERROR 15835 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READPREPARETOERROR_TRANSITIONNUMBER 15836 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READTRANSFERTOERROR 15837 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_READTRANSFERTOERROR_TRANSITIONNUMBER 15838 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_APPLYWRITETOERROR 15839 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_APPLYWRITETOERROR_TRANSITIONNUMBER 15840 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_ERRORTOIDLE 15841 /* Object */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_ERRORTOIDLE_TRANSITIONNUMBER 15842 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_RESET 15843 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_STATUS 15844 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_STATUS_STATE 15845 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_STATUS_ENABLE 15846 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_STATUS_DISABLE 15847 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI_SELECTIONS 15848 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI_SELECTIONDESCRIPTIONS 15849 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI_RESTRICTTOLIST 15850 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDRESS 15851 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 15852 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15853 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPMESSAGEDATATYPE 15854 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPMESSAGEDATATYPE_DATATYPEVERSION 15855 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 15856 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBCONNECTIONDATATYPE 15857 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBCONNECTIONDATATYPE_DATATYPEVERSION 15858 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBCONNECTIONDATATYPE_DICTIONARYFRAGMENT 15859 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONNECTIONTRANSPORTDATATYPE 15860 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONNECTIONTRANSPORTDATATYPE_DATATYPEVERSION 15861 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CONNECTIONTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15862 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE 15863 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTSETTINGS 15864 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_STATUS 15865 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPTRANSPORTDATATYPE 15866 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 15867 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15868 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPMESSAGEDATATYPE 15869 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPMESSAGEDATATYPE_DATATYPEVERSION 15870 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 15871 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERDATATYPE 15872 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERDATATYPE_DATATYPEVERSION 15873 /* Variable */ +#define UA_NS0ID_OVERRIDEVALUEHANDLING 15874 /* DataType */ +#define UA_NS0ID_OVERRIDEVALUEHANDLING_ENUMSTRINGS 15875 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERDATATYPE_DICTIONARYFRAGMENT 15876 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERTRANSPORTDATATYPE 15877 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERTRANSPORTDATATYPE_DATATYPEVERSION 15878 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15879 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERMESSAGEDATATYPE 15880 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERMESSAGEDATATYPE_DATATYPEVERSION 15881 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATASETREADERMESSAGEDATATYPE_DICTIONARYFRAGMENT 15882 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIBEDDATASETDATATYPE 15883 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIBEDDATASETDATATYPE_DATATYPEVERSION 15884 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIBEDDATASETDATATYPE_DICTIONARYFRAGMENT 15885 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TARGETVARIABLESDATATYPE 15886 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TARGETVARIABLESDATATYPE_DATATYPEVERSION 15887 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_TARGETVARIABLESDATATYPE_DICTIONARYFRAGMENT 15888 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIBEDDATASETMIRRORDATATYPE 15889 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIBEDDATASETMIRRORDATATYPE_DATATYPEVERSION 15890 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_SUBSCRIBEDDATASETMIRRORDATATYPE_DICTIONARYFRAGMENT 15891 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_STATUS_STATE 15892 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_STATUS_ENABLE 15893 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_STATUS_DISABLE 15894 /* Method */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPWRITERGROUPMESSAGEDATATYPE 15895 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPWRITERGROUPMESSAGEDATATYPE_DATATYPEVERSION 15896 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPWRITERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 15897 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPDATASETWRITERMESSAGEDATATYPE 15898 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPDATASETWRITERMESSAGEDATATYPE_DATATYPEVERSION 15899 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPDATASETWRITERMESSAGEDATATYPE_DICTIONARYFRAGMENT 15900 /* Variable */ +#define UA_NS0ID_SESSIONLESSINVOKEREQUESTTYPE 15901 /* DataType */ +#define UA_NS0ID_SESSIONLESSINVOKEREQUESTTYPE_ENCODING_DEFAULTXML 15902 /* Object */ +#define UA_NS0ID_SESSIONLESSINVOKEREQUESTTYPE_ENCODING_DEFAULTBINARY 15903 /* Object */ +#define UA_NS0ID_DATASETFIELDFLAGS 15904 /* DataType */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTSETTINGS 15905 /* Object */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE 15906 /* ObjectType */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_GETSECURITYKEYS 15907 /* Method */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_GETSECURITYKEYS_INPUTARGUMENTS 15908 /* Variable */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_GETSECURITYKEYS_OUTPUTARGUMENTS 15909 /* Variable */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_GETSECURITYGROUP 15910 /* Method */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_GETSECURITYGROUP_INPUTARGUMENTS 15911 /* Variable */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_GETSECURITYGROUP_OUTPUTARGUMENTS 15912 /* Variable */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_SECURITYGROUPS 15913 /* Object */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_SECURITYGROUPS_ADDSECURITYGROUP 15914 /* Method */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_SECURITYGROUPS_ADDSECURITYGROUP_INPUTARGUMENTS 15915 /* Variable */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_SECURITYGROUPS_ADDSECURITYGROUP_OUTPUTARGUMENTS 15916 /* Variable */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_SECURITYGROUPS_REMOVESECURITYGROUP 15917 /* Method */ +#define UA_NS0ID_PUBSUBKEYSERVICETYPE_SECURITYGROUPS_REMOVESECURITYGROUP_INPUTARGUMENTS 15918 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPDATASETREADERMESSAGEDATATYPE 15919 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPDATASETREADERMESSAGEDATATYPE_DATATYPEVERSION 15920 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_UADPDATASETREADERMESSAGEDATATYPE_DICTIONARYFRAGMENT 15921 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONWRITERGROUPMESSAGEDATATYPE 15922 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONWRITERGROUPMESSAGEDATATYPE_DATATYPEVERSION 15923 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONWRITERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 15924 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONDATASETWRITERMESSAGEDATATYPE 15925 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPE_SECURITYMODE 15926 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPE_SECURITYGROUPID 15927 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPE_SECURITYKEYSERVICES 15928 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONDATASETWRITERMESSAGEDATATYPE_DATATYPEVERSION 15929 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONDATASETWRITERMESSAGEDATATYPE_DICTIONARYFRAGMENT 15930 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONDATASETREADERMESSAGEDATATYPE 15931 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_SECURITYMODE 15932 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_SECURITYGROUPID 15933 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_SECURITYKEYSERVICES 15934 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONDATASETREADERMESSAGEDATATYPE_DATATYPEVERSION 15935 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_JSONDATASETREADERMESSAGEDATATYPE_DICTIONARYFRAGMENT 15936 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS 15937 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 15938 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 15939 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERWRITERGROUPTRANSPORTDATATYPE 15940 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERWRITERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 15941 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERWRITERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15942 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERDATASETWRITERTRANSPORTDATATYPE 15943 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERDATASETWRITERTRANSPORTDATATYPE_DATATYPEVERSION 15944 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERDATASETWRITERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15945 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERDATASETREADERTRANSPORTDATATYPE 15946 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERDATASETREADERTRANSPORTDATATYPE_DATATYPEVERSION 15947 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_BROKERDATASETREADERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 15948 /* Variable */ +#define UA_NS0ID_ENDPOINTTYPE_ENCODING_DEFAULTXML 15949 /* Object */ +#define UA_NS0ID_DATATYPESCHEMAHEADER_ENCODING_DEFAULTXML 15950 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETDATATYPE_ENCODING_DEFAULTXML 15951 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETSOURCEDATATYPE_ENCODING_DEFAULTXML 15952 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSDATATYPE_ENCODING_DEFAULTXML 15953 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSDATATYPE_ENCODING_DEFAULTXML 15954 /* Object */ +#define UA_NS0ID_DATASETWRITERDATATYPE_ENCODING_DEFAULTXML 15955 /* Object */ +#define UA_NS0ID_DATASETWRITERTRANSPORTDATATYPE_ENCODING_DEFAULTXML 15956 /* Object */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA 15957 /* Object */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEURI 15958 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEVERSION 15959 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEPUBLICATIONDATE 15960 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_ISNAMESPACESUBSET 15961 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_STATICNODEIDTYPES 15962 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_STATICNUMERICNODEIDRANGE 15963 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_STATICSTRINGNODEIDPATTERN 15964 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE 15965 /* Object */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_SIZE 15966 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_WRITABLE 15967 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_USERWRITABLE 15968 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_OPENCOUNT 15969 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_MIMETYPE 15970 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_OPEN 15971 /* Method */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_OPEN_INPUTARGUMENTS 15972 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_OPEN_OUTPUTARGUMENTS 15973 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_CLOSE 15974 /* Method */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_CLOSE_INPUTARGUMENTS 15975 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_READ 15976 /* Method */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_READ_INPUTARGUMENTS 15977 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_READ_OUTPUTARGUMENTS 15978 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_WRITE 15979 /* Method */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_WRITE_INPUTARGUMENTS 15980 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_GETPOSITION 15981 /* Method */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_GETPOSITION_INPUTARGUMENTS 15982 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_GETPOSITION_OUTPUTARGUMENTS 15983 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_SETPOSITION 15984 /* Method */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_SETPOSITION_INPUTARGUMENTS 15985 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_NAMESPACEFILE_EXPORTNAMESPACE 15986 /* Method */ +#define UA_NS0ID_DATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTXML 15987 /* Object */ +#define UA_NS0ID_PUBSUBGROUPDATATYPE_ENCODING_DEFAULTXML 15988 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 15989 /* Variable */ +#define UA_NS0ID_WRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTXML 15990 /* Object */ +#define UA_NS0ID_WRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTXML 15991 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONDATATYPE_ENCODING_DEFAULTXML 15992 /* Object */ +#define UA_NS0ID_CONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTXML 15993 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 15994 /* Variable */ +#define UA_NS0ID_READERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTXML 15995 /* Object */ +#define UA_NS0ID_READERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTXML 15996 /* Object */ +#define UA_NS0ID_ROLESETTYPE_ADDROLE 15997 /* Method */ +#define UA_NS0ID_ROLESETTYPE_ADDROLE_INPUTARGUMENTS 15998 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ADDROLE_OUTPUTARGUMENTS 15999 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_REMOVEROLE 16000 /* Method */ +#define UA_NS0ID_ROLESETTYPE_REMOVEROLE_INPUTARGUMENTS 16001 /* Variable */ +#define UA_NS0ID_ADDROLEMETHODTYPE 16002 /* Method */ +#define UA_NS0ID_ADDROLEMETHODTYPE_INPUTARGUMENTS 16003 /* Variable */ +#define UA_NS0ID_ADDROLEMETHODTYPE_OUTPUTARGUMENTS 16004 /* Variable */ +#define UA_NS0ID_REMOVEROLEMETHODTYPE 16005 /* Method */ +#define UA_NS0ID_REMOVEROLEMETHODTYPE_INPUTARGUMENTS 16006 /* Variable */ +#define UA_NS0ID_DATASETREADERDATATYPE_ENCODING_DEFAULTXML 16007 /* Object */ +#define UA_NS0ID_DATASETREADERTRANSPORTDATATYPE_ENCODING_DEFAULTXML 16008 /* Object */ +#define UA_NS0ID_DATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTXML 16009 /* Object */ +#define UA_NS0ID_SUBSCRIBEDDATASETDATATYPE_ENCODING_DEFAULTXML 16010 /* Object */ +#define UA_NS0ID_TARGETVARIABLESDATATYPE_ENCODING_DEFAULTXML 16011 /* Object */ +#define UA_NS0ID_SUBSCRIBEDDATASETMIRRORDATATYPE_ENCODING_DEFAULTXML 16012 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 16013 /* Variable */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTXML 16014 /* Object */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTXML 16015 /* Object */ +#define UA_NS0ID_UADPDATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTXML 16016 /* Object */ +#define UA_NS0ID_JSONWRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTXML 16017 /* Object */ +#define UA_NS0ID_JSONDATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTXML 16018 /* Object */ +#define UA_NS0ID_JSONDATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTXML 16019 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 16020 /* Variable */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTXML 16021 /* Object */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTDATATYPE_ENCODING_DEFAULTXML 16022 /* Object */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTDATATYPE_ENCODING_DEFAULTXML 16023 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTTYPE 16024 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTTYPE_DATATYPEVERSION 16025 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENDPOINTTYPE_DICTIONARYFRAGMENT 16026 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPESCHEMAHEADER 16027 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPESCHEMAHEADER_DATATYPEVERSION 16028 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPESCHEMAHEADER_DICTIONARYFRAGMENT 16029 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATASETDATATYPE 16030 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATASETDATATYPE_DATATYPEVERSION 16031 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATASETDATATYPE_DICTIONARYFRAGMENT 16032 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATASETSOURCEDATATYPE 16033 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATASETSOURCEDATATYPE_DATATYPEVERSION 16034 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATASETSOURCEDATATYPE_DICTIONARYFRAGMENT 16035 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER 16036 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATAITEMSDATATYPE 16037 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATAITEMSDATATYPE_DATATYPEVERSION 16038 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDDATAITEMSDATATYPE_DICTIONARYFRAGMENT 16039 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDEVENTSDATATYPE 16040 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ADDIDENTITY 16041 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ADDIDENTITY_INPUTARGUMENTS 16042 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_REMOVEIDENTITY 16043 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_REMOVEIDENTITY_INPUTARGUMENTS 16044 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDEVENTSDATATYPE_DATATYPEVERSION 16045 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBLISHEDEVENTSDATATYPE_DICTIONARYFRAGMENT 16046 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERDATATYPE 16047 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERDATATYPE_DATATYPEVERSION 16048 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERDATATYPE_DICTIONARYFRAGMENT 16049 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERTRANSPORTDATATYPE 16050 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERTRANSPORTDATATYPE_DATATYPEVERSION 16051 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16052 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERMESSAGEDATATYPE 16053 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERMESSAGEDATATYPE_DATATYPEVERSION 16054 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETWRITERMESSAGEDATATYPE_DICTIONARYFRAGMENT 16055 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBGROUPDATATYPE 16056 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBGROUPDATATYPE_DATATYPEVERSION 16057 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBGROUPDATATYPE_DICTIONARYFRAGMENT 16058 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 16059 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 16060 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 16061 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPTRANSPORTDATATYPE 16062 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 16063 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16064 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPMESSAGEDATATYPE 16065 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPMESSAGEDATATYPE_DATATYPEVERSION 16066 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 16067 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBCONNECTIONDATATYPE 16068 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBCONNECTIONDATATYPE_DATATYPEVERSION 16069 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBCONNECTIONDATATYPE_DICTIONARYFRAGMENT 16070 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONNECTIONTRANSPORTDATATYPE 16071 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONNECTIONTRANSPORTDATATYPE_DATATYPEVERSION 16072 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CONNECTIONTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16073 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 16074 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 16075 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_RESET 16076 /* Method */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPTRANSPORTDATATYPE 16077 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 16078 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16079 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPMESSAGEDATATYPE 16080 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPMESSAGEDATATYPE_DATATYPEVERSION 16081 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 16082 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERDATATYPE 16083 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERDATATYPE_DATATYPEVERSION 16084 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERDATATYPE_DICTIONARYFRAGMENT 16085 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERTRANSPORTDATATYPE 16086 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERTRANSPORTDATATYPE_DATATYPEVERSION 16087 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16088 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERMESSAGEDATATYPE 16089 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERMESSAGEDATATYPE_DATATYPEVERSION 16090 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATASETREADERMESSAGEDATATYPE_DICTIONARYFRAGMENT 16091 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIBEDDATASETDATATYPE 16092 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIBEDDATASETDATATYPE_DATATYPEVERSION 16093 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIBEDDATASETDATATYPE_DICTIONARYFRAGMENT 16094 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TARGETVARIABLESDATATYPE 16095 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TARGETVARIABLESDATATYPE_DATATYPEVERSION 16096 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_TARGETVARIABLESDATATYPE_DICTIONARYFRAGMENT 16097 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIBEDDATASETMIRRORDATATYPE 16098 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIBEDDATASETMIRRORDATATYPE_DATATYPEVERSION 16099 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_SUBSCRIBEDDATASETMIRRORDATATYPE_DICTIONARYFRAGMENT 16100 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 16101 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 16102 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 16103 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPWRITERGROUPMESSAGEDATATYPE 16104 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPWRITERGROUPMESSAGEDATATYPE_DATATYPEVERSION 16105 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPWRITERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 16106 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPDATASETWRITERMESSAGEDATATYPE 16107 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPDATASETWRITERMESSAGEDATATYPE_DATATYPEVERSION 16108 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPDATASETWRITERMESSAGEDATATYPE_DICTIONARYFRAGMENT 16109 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPDATASETREADERMESSAGEDATATYPE 16110 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPDATASETREADERMESSAGEDATATYPE_DATATYPEVERSION 16111 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_UADPDATASETREADERMESSAGEDATATYPE_DICTIONARYFRAGMENT 16112 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONWRITERGROUPMESSAGEDATATYPE 16113 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONWRITERGROUPMESSAGEDATATYPE_DATATYPEVERSION 16114 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONWRITERGROUPMESSAGEDATATYPE_DICTIONARYFRAGMENT 16115 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONDATASETWRITERMESSAGEDATATYPE 16116 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONDATASETWRITERMESSAGEDATATYPE_DATATYPEVERSION 16117 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONDATASETWRITERMESSAGEDATATYPE_DICTIONARYFRAGMENT 16118 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONDATASETREADERMESSAGEDATATYPE 16119 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONDATASETREADERMESSAGEDATATYPE_DATATYPEVERSION 16120 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_JSONDATASETREADERMESSAGEDATATYPE_DICTIONARYFRAGMENT 16121 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 16122 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 16123 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 16124 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERWRITERGROUPTRANSPORTDATATYPE 16125 /* Variable */ +#define UA_NS0ID_ROLEPERMISSIONTYPE_ENCODING_DEFAULTXML 16126 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ROLEPERMISSIONTYPE 16127 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ROLEPERMISSIONTYPE_DATATYPEVERSION 16128 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ROLEPERMISSIONTYPE_DICTIONARYFRAGMENT 16129 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERWRITERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 16130 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ROLEPERMISSIONTYPE 16131 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ROLEPERMISSIONTYPE_DATATYPEVERSION 16132 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ROLEPERMISSIONTYPE_DICTIONARYFRAGMENT 16133 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_DEFAULTROLEPERMISSIONS 16134 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_DEFAULTUSERROLEPERMISSIONS 16135 /* Variable */ +#define UA_NS0ID_OPCUANAMESPACEMETADATA_DEFAULTACCESSRESTRICTIONS 16136 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_DEFAULTROLEPERMISSIONS 16137 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_DEFAULTUSERROLEPERMISSIONS 16138 /* Variable */ +#define UA_NS0ID_NAMESPACEMETADATATYPE_DEFAULTACCESSRESTRICTIONS 16139 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_DEFAULTROLEPERMISSIONS 16140 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_DEFAULTUSERROLEPERMISSIONS 16141 /* Variable */ +#define UA_NS0ID_NAMESPACESTYPE_NAMESPACEIDENTIFIER_PLACEHOLDER_DEFAULTACCESSRESTRICTIONS 16142 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERWRITERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16143 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERDATASETWRITERTRANSPORTDATATYPE 16144 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERDATASETWRITERTRANSPORTDATATYPE_DATATYPEVERSION 16145 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERDATASETWRITERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16146 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERDATASETREADERTRANSPORTDATATYPE 16147 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERDATASETREADERTRANSPORTDATATYPE_DATATYPEVERSION 16148 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_BROKERDATASETREADERTRANSPORTDATATYPE_DICTIONARYFRAGMENT 16149 /* Variable */ +#define UA_NS0ID_ENDPOINTTYPE_ENCODING_DEFAULTJSON 16150 /* Object */ +#define UA_NS0ID_DATATYPESCHEMAHEADER_ENCODING_DEFAULTJSON 16151 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETDATATYPE_ENCODING_DEFAULTJSON 16152 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETSOURCEDATATYPE_ENCODING_DEFAULTJSON 16153 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSDATATYPE_ENCODING_DEFAULTJSON 16154 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSDATATYPE_ENCODING_DEFAULTJSON 16155 /* Object */ +#define UA_NS0ID_DATASETWRITERDATATYPE_ENCODING_DEFAULTJSON 16156 /* Object */ +#define UA_NS0ID_DATASETWRITERTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16157 /* Object */ +#define UA_NS0ID_DATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16158 /* Object */ +#define UA_NS0ID_PUBSUBGROUPDATATYPE_ENCODING_DEFAULTJSON 16159 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 16160 /* Variable */ +#define UA_NS0ID_WRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16161 /* Object */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_IDENTITIES 16162 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_APPLICATIONS 16163 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ENDPOINTS 16164 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ADDAPPLICATION 16165 /* Method */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ADDAPPLICATION_INPUTARGUMENTS 16166 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_REMOVEAPPLICATION 16167 /* Method */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_REMOVEAPPLICATION_INPUTARGUMENTS 16168 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ADDENDPOINT 16169 /* Method */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_ADDENDPOINT_INPUTARGUMENTS 16170 /* Variable */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_REMOVEENDPOINT 16171 /* Method */ +#define UA_NS0ID_ROLESETTYPE_ROLENAME_PLACEHOLDER_REMOVEENDPOINT_INPUTARGUMENTS 16172 /* Variable */ +#define UA_NS0ID_ROLETYPE_IDENTITIES 16173 /* Variable */ +#define UA_NS0ID_ROLETYPE_APPLICATIONS 16174 /* Variable */ +#define UA_NS0ID_ROLETYPE_ENDPOINTS 16175 /* Variable */ +#define UA_NS0ID_ROLETYPE_ADDAPPLICATION 16176 /* Method */ +#define UA_NS0ID_ROLETYPE_ADDAPPLICATION_INPUTARGUMENTS 16177 /* Variable */ +#define UA_NS0ID_ROLETYPE_REMOVEAPPLICATION 16178 /* Method */ +#define UA_NS0ID_ROLETYPE_REMOVEAPPLICATION_INPUTARGUMENTS 16179 /* Variable */ +#define UA_NS0ID_ROLETYPE_ADDENDPOINT 16180 /* Method */ +#define UA_NS0ID_ROLETYPE_ADDENDPOINT_INPUTARGUMENTS 16181 /* Variable */ +#define UA_NS0ID_ROLETYPE_REMOVEENDPOINT 16182 /* Method */ +#define UA_NS0ID_ROLETYPE_REMOVEENDPOINT_INPUTARGUMENTS 16183 /* Variable */ +#define UA_NS0ID_ADDAPPLICATIONMETHODTYPE 16184 /* Method */ +#define UA_NS0ID_ADDAPPLICATIONMETHODTYPE_INPUTARGUMENTS 16185 /* Variable */ +#define UA_NS0ID_REMOVEAPPLICATIONMETHODTYPE 16186 /* Method */ +#define UA_NS0ID_REMOVEAPPLICATIONMETHODTYPE_INPUTARGUMENTS 16187 /* Variable */ +#define UA_NS0ID_ADDENDPOINTMETHODTYPE 16188 /* Method */ +#define UA_NS0ID_ADDENDPOINTMETHODTYPE_INPUTARGUMENTS 16189 /* Variable */ +#define UA_NS0ID_REMOVEENDPOINTMETHODTYPE 16190 /* Method */ +#define UA_NS0ID_REMOVEENDPOINTMETHODTYPE_INPUTARGUMENTS 16191 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_IDENTITIES 16192 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_APPLICATIONS 16193 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ENDPOINTS 16194 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ADDAPPLICATION 16195 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ADDAPPLICATION_INPUTARGUMENTS 16196 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_REMOVEAPPLICATION 16197 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_REMOVEAPPLICATION_INPUTARGUMENTS 16198 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ADDENDPOINT 16199 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_ADDENDPOINT_INPUTARGUMENTS 16200 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_REMOVEENDPOINT 16201 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ANONYMOUS_REMOVEENDPOINT_INPUTARGUMENTS 16202 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_IDENTITIES 16203 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_APPLICATIONS 16204 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ENDPOINTS 16205 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ADDAPPLICATION 16206 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ADDAPPLICATION_INPUTARGUMENTS 16207 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_REMOVEAPPLICATION 16208 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_REMOVEAPPLICATION_INPUTARGUMENTS 16209 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ADDENDPOINT 16210 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_ADDENDPOINT_INPUTARGUMENTS 16211 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_REMOVEENDPOINT 16212 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_AUTHENTICATEDUSER_REMOVEENDPOINT_INPUTARGUMENTS 16213 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_IDENTITIES 16214 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_APPLICATIONS 16215 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ENDPOINTS 16216 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ADDAPPLICATION 16217 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ADDAPPLICATION_INPUTARGUMENTS 16218 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_REMOVEAPPLICATION 16219 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_REMOVEAPPLICATION_INPUTARGUMENTS 16220 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ADDENDPOINT 16221 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_ADDENDPOINT_INPUTARGUMENTS 16222 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_REMOVEENDPOINT 16223 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OBSERVER_REMOVEENDPOINT_INPUTARGUMENTS 16224 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_IDENTITIES 16225 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_APPLICATIONS 16226 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ENDPOINTS 16227 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ADDAPPLICATION 16228 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ADDAPPLICATION_INPUTARGUMENTS 16229 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_REMOVEAPPLICATION 16230 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_REMOVEAPPLICATION_INPUTARGUMENTS 16231 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ADDENDPOINT 16232 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_ADDENDPOINT_INPUTARGUMENTS 16233 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_REMOVEENDPOINT 16234 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_OPERATOR_REMOVEENDPOINT_INPUTARGUMENTS 16235 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_IDENTITIES 16236 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_APPLICATIONS 16237 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ENDPOINTS 16238 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ADDAPPLICATION 16239 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ADDAPPLICATION_INPUTARGUMENTS 16240 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_REMOVEAPPLICATION 16241 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_REMOVEAPPLICATION_INPUTARGUMENTS 16242 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ADDENDPOINT 16243 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_ADDENDPOINT_INPUTARGUMENTS 16244 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_REMOVEENDPOINT 16245 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_ENGINEER_REMOVEENDPOINT_INPUTARGUMENTS 16246 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_IDENTITIES 16247 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_APPLICATIONS 16248 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ENDPOINTS 16249 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ADDAPPLICATION 16250 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ADDAPPLICATION_INPUTARGUMENTS 16251 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_REMOVEAPPLICATION 16252 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_REMOVEAPPLICATION_INPUTARGUMENTS 16253 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ADDENDPOINT 16254 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_ADDENDPOINT_INPUTARGUMENTS 16255 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_REMOVEENDPOINT 16256 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SUPERVISOR_REMOVEENDPOINT_INPUTARGUMENTS 16257 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_IDENTITIES 16258 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_APPLICATIONS 16259 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ENDPOINTS 16260 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ADDAPPLICATION 16261 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ADDAPPLICATION_INPUTARGUMENTS 16262 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_REMOVEAPPLICATION 16263 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_REMOVEAPPLICATION_INPUTARGUMENTS 16264 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ADDENDPOINT 16265 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_ADDENDPOINT_INPUTARGUMENTS 16266 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_REMOVEENDPOINT 16267 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_SECURITYADMIN_REMOVEENDPOINT_INPUTARGUMENTS 16268 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_IDENTITIES 16269 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_APPLICATIONS 16270 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ENDPOINTS 16271 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ADDAPPLICATION 16272 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ADDAPPLICATION_INPUTARGUMENTS 16273 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_REMOVEAPPLICATION 16274 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_REMOVEAPPLICATION_INPUTARGUMENTS 16275 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ADDENDPOINT 16276 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_ADDENDPOINT_INPUTARGUMENTS 16277 /* Variable */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_REMOVEENDPOINT 16278 /* Method */ +#define UA_NS0ID_WELLKNOWNROLE_CONFIGUREADMIN_REMOVEENDPOINT_INPUTARGUMENTS 16279 /* Variable */ +#define UA_NS0ID_WRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16280 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONDATATYPE_ENCODING_DEFAULTJSON 16281 /* Object */ +#define UA_NS0ID_CONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16282 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 16283 /* Variable */ +#define UA_NS0ID_READERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16284 /* Object */ +#define UA_NS0ID_READERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16285 /* Object */ +#define UA_NS0ID_DATASETREADERDATATYPE_ENCODING_DEFAULTJSON 16286 /* Object */ +#define UA_NS0ID_DATASETREADERTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16287 /* Object */ +#define UA_NS0ID_DATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16288 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_ROLESET 16289 /* Object */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_ROLESET_ADDROLE 16290 /* Method */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_ROLESET_ADDROLE_INPUTARGUMENTS 16291 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_ROLESET_ADDROLE_OUTPUTARGUMENTS 16292 /* Variable */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_ROLESET_REMOVEROLE 16293 /* Method */ +#define UA_NS0ID_SERVERTYPE_SERVERCAPABILITIES_ROLESET_REMOVEROLE_INPUTARGUMENTS 16294 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_ROLESET 16295 /* Object */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_ROLESET_ADDROLE 16296 /* Method */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_ROLESET_ADDROLE_INPUTARGUMENTS 16297 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_ROLESET_ADDROLE_OUTPUTARGUMENTS 16298 /* Variable */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_ROLESET_REMOVEROLE 16299 /* Method */ +#define UA_NS0ID_SERVERCAPABILITIESTYPE_ROLESET_REMOVEROLE_INPUTARGUMENTS 16300 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_ROLESET_ADDROLE 16301 /* Method */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_ROLESET_ADDROLE_INPUTARGUMENTS 16302 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_ROLESET_ADDROLE_OUTPUTARGUMENTS 16303 /* Variable */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_ROLESET_REMOVEROLE 16304 /* Method */ +#define UA_NS0ID_SERVER_SERVERCAPABILITIES_ROLESET_REMOVEROLE_INPUTARGUMENTS 16305 /* Variable */ +#define UA_NS0ID_AUDIODATATYPE 16307 /* DataType */ +#define UA_NS0ID_SUBSCRIBEDDATASETDATATYPE_ENCODING_DEFAULTJSON 16308 /* Object */ +#define UA_NS0ID_SELECTIONLISTTYPE 16309 /* VariableType */ +#define UA_NS0ID_TARGETVARIABLESDATATYPE_ENCODING_DEFAULTJSON 16310 /* Object */ +#define UA_NS0ID_SUBSCRIBEDDATASETMIRRORDATATYPE_ENCODING_DEFAULTJSON 16311 /* Object */ +#define UA_NS0ID_SELECTIONLISTTYPE_RESTRICTTOLIST 16312 /* Variable */ +#define UA_NS0ID_ADDITIONALPARAMETERSTYPE 16313 /* DataType */ +#define UA_NS0ID_FILESYSTEM 16314 /* Object */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER 16315 /* Object */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_CREATEDIRECTORY 16316 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_CREATEDIRECTORY_INPUTARGUMENTS 16317 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_CREATEDIRECTORY_OUTPUTARGUMENTS 16318 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_CREATEFILE 16319 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_CREATEFILE_INPUTARGUMENTS 16320 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_CREATEFILE_OUTPUTARGUMENTS 16321 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 16322 /* Variable */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16323 /* Object */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_MOVEORCOPY 16324 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_MOVEORCOPY_INPUTARGUMENTS 16325 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_MOVEORCOPY_OUTPUTARGUMENTS 16326 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER 16327 /* Object */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_SIZE 16328 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_WRITABLE 16329 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_USERWRITABLE 16330 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_OPENCOUNT 16331 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_MIMETYPE 16332 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_OPEN 16333 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_OPEN_INPUTARGUMENTS 16334 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_OPEN_OUTPUTARGUMENTS 16335 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_CLOSE 16336 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_CLOSE_INPUTARGUMENTS 16337 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_READ 16338 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_READ_INPUTARGUMENTS 16339 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_READ_OUTPUTARGUMENTS 16340 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_WRITE 16341 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_WRITE_INPUTARGUMENTS 16342 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_GETPOSITION 16343 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_GETPOSITION_INPUTARGUMENTS 16344 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_GETPOSITION_OUTPUTARGUMENTS 16345 /* Variable */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_SETPOSITION 16346 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILENAME_PLACEHOLDER_SETPOSITION_INPUTARGUMENTS 16347 /* Variable */ +#define UA_NS0ID_FILESYSTEM_CREATEDIRECTORY 16348 /* Method */ +#define UA_NS0ID_FILESYSTEM_CREATEDIRECTORY_INPUTARGUMENTS 16349 /* Variable */ +#define UA_NS0ID_FILESYSTEM_CREATEDIRECTORY_OUTPUTARGUMENTS 16350 /* Variable */ +#define UA_NS0ID_FILESYSTEM_CREATEFILE 16351 /* Method */ +#define UA_NS0ID_FILESYSTEM_CREATEFILE_INPUTARGUMENTS 16352 /* Variable */ +#define UA_NS0ID_FILESYSTEM_CREATEFILE_OUTPUTARGUMENTS 16353 /* Variable */ +#define UA_NS0ID_FILESYSTEM_DELETEFILESYSTEMOBJECT 16354 /* Method */ +#define UA_NS0ID_FILESYSTEM_DELETEFILESYSTEMOBJECT_INPUTARGUMENTS 16355 /* Variable */ +#define UA_NS0ID_FILESYSTEM_MOVEORCOPY 16356 /* Method */ +#define UA_NS0ID_FILESYSTEM_MOVEORCOPY_INPUTARGUMENTS 16357 /* Variable */ +#define UA_NS0ID_FILESYSTEM_MOVEORCOPY_OUTPUTARGUMENTS 16358 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_GENERATEFILEFORWRITE_INPUTARGUMENTS 16359 /* Variable */ +#define UA_NS0ID_GENERATEFILEFORWRITEMETHODTYPE_INPUTARGUMENTS 16360 /* Variable */ +#define UA_NS0ID_HASALARMSUPPRESSIONGROUP 16361 /* ReferenceType */ +#define UA_NS0ID_ALARMGROUPMEMBER 16362 /* ReferenceType */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONSUBCLASSID 16363 /* Variable */ +#define UA_NS0ID_CONDITIONTYPE_CONDITIONSUBCLASSNAME 16364 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONSUBCLASSID 16365 /* Variable */ +#define UA_NS0ID_DIALOGCONDITIONTYPE_CONDITIONSUBCLASSNAME 16366 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONSUBCLASSID 16367 /* Variable */ +#define UA_NS0ID_ACKNOWLEDGEABLECONDITIONTYPE_CONDITIONSUBCLASSNAME 16368 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONSUBCLASSID 16369 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_CONDITIONSUBCLASSNAME 16370 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE 16371 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_ID 16372 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_NAME 16373 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_NUMBER 16374 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16375 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16376 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16377 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_TRUESTATE 16378 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OUTOFSERVICESTATE_FALSESTATE 16379 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE 16380 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_ID 16381 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_NAME 16382 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_NUMBER 16383 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16384 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_TRANSITIONTIME 16385 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16386 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_TRUESTATE 16387 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCESTATE_FALSESTATE 16388 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_AUDIBLEENABLED 16389 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_AUDIBLESOUND 16390 /* Variable */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16391 /* Object */ +#define UA_NS0ID_UADPDATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16392 /* Object */ +#define UA_NS0ID_JSONWRITERGROUPMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16393 /* Object */ +#define UA_NS0ID_JSONDATASETWRITERMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16394 /* Object */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ONDELAY 16395 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_OFFDELAY 16396 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_FIRSTINGROUPFLAG 16397 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_FIRSTINGROUP 16398 /* Object */ +#define UA_NS0ID_ALARMCONDITIONTYPE_ALARMGROUP_PLACEHOLDER 16399 /* Object */ +#define UA_NS0ID_ALARMCONDITIONTYPE_REALARMTIME 16400 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_REALARMREPEATCOUNT 16401 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SILENCE 16402 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SUPPRESS 16403 /* Method */ +#define UA_NS0ID_JSONDATASETREADERMESSAGEDATATYPE_ENCODING_DEFAULTJSON 16404 /* Object */ +#define UA_NS0ID_ALARMGROUPTYPE 16405 /* ObjectType */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER 16406 /* Object */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_EVENTID 16407 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_EVENTTYPE 16408 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SOURCENODE 16409 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SOURCENAME 16410 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_TIME 16411 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_RECEIVETIME 16412 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LOCALTIME 16413 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_MESSAGE 16414 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SEVERITY 16415 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONDITIONCLASSID 16416 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONDITIONCLASSNAME 16417 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONDITIONSUBCLASSID 16418 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONDITIONSUBCLASSNAME 16419 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONDITIONNAME 16420 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_BRANCHID 16421 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_RETAIN 16422 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE 16423 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_ID 16424 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_NAME 16425 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_NUMBER 16426 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 16427 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_TRANSITIONTIME 16428 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 16429 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_TRUESTATE 16430 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLEDSTATE_FALSESTATE 16431 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_QUALITY 16432 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_QUALITY_SOURCETIMESTAMP 16433 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LASTSEVERITY 16434 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LASTSEVERITY_SOURCETIMESTAMP 16435 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_COMMENT 16436 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_COMMENT_SOURCETIMESTAMP 16437 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CLIENTUSERID 16438 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_DISABLE 16439 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ENABLE 16440 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ADDCOMMENT 16441 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ADDCOMMENT_INPUTARGUMENTS 16442 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE 16443 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_ID 16444 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_NAME 16445 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_NUMBER 16446 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_EFFECTIVEDISPLAYNAME 16447 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_TRANSITIONTIME 16448 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_EFFECTIVETRANSITIONTIME 16449 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_TRUESTATE 16450 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKEDSTATE_FALSESTATE 16451 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE 16452 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_ID 16453 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_NAME 16454 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_NUMBER 16455 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 16456 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_TRANSITIONTIME 16457 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 16458 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_TRUESTATE 16459 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRMEDSTATE_FALSESTATE 16460 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKNOWLEDGE 16461 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACKNOWLEDGE_INPUTARGUMENTS 16462 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRM 16463 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_CONFIRM_INPUTARGUMENTS 16464 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE 16465 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_ID 16466 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_NAME 16467 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_NUMBER 16468 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_EFFECTIVEDISPLAYNAME 16469 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_TRANSITIONTIME 16470 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_EFFECTIVETRANSITIONTIME 16471 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_TRUESTATE 16472 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ACTIVESTATE_FALSESTATE 16473 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_INPUTNODE 16474 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE 16475 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_ID 16476 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_NAME 16477 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_NUMBER 16478 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 16479 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_TRANSITIONTIME 16480 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 16481 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_TRUESTATE 16482 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDSTATE_FALSESTATE 16483 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE 16484 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_ID 16485 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_NAME 16486 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_NUMBER 16487 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16488 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_TRANSITIONTIME 16489 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16490 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_TRUESTATE 16491 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OUTOFSERVICESTATE_FALSESTATE 16492 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE 16493 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_ID 16494 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_NAME 16495 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_NUMBER 16496 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_EFFECTIVEDISPLAYNAME 16497 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_TRANSITIONTIME 16498 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_EFFECTIVETRANSITIONTIME 16499 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_TRUESTATE 16500 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCESTATE_FALSESTATE 16501 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE 16502 /* Object */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_CURRENTSTATE 16503 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_CURRENTSTATE_ID 16504 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_CURRENTSTATE_NAME 16505 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_CURRENTSTATE_NUMBER 16506 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 16507 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_LASTTRANSITION 16508 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_LASTTRANSITION_ID 16509 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_LASTTRANSITION_NAME 16510 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_LASTTRANSITION_NUMBER 16511 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 16512 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 16513 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_UNSHELVETIME 16514 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_UNSHELVE 16515 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_ONESHOTSHELVE 16516 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_TIMEDSHELVE 16517 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 16518 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESSEDORSHELVED 16519 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_MAXTIMESHELVED 16520 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_AUDIBLEENABLED 16521 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_AUDIBLESOUND 16522 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 16523 /* Variable */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16524 /* Object */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16525 /* Object */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 16526 /* Object */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_ONDELAY 16527 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_OFFDELAY 16528 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_FIRSTINGROUPFLAG 16529 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_FIRSTINGROUP 16530 /* Object */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_REALARMTIME 16531 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_REALARMREPEATCOUNT 16532 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SILENCE 16533 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SUPPRESS 16534 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDWRITERGROUP 16535 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONSUBCLASSID 16536 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_CONDITIONSUBCLASSNAME 16537 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE 16538 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_ID 16539 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_NAME 16540 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_NUMBER 16541 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16542 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16543 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16544 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16545 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16546 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE 16547 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_ID 16548 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_NAME 16549 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_NUMBER 16550 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16551 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_TRANSITIONTIME 16552 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16553 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_TRUESTATE 16554 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCESTATE_FALSESTATE 16555 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_AUDIBLEENABLED 16556 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_AUDIBLESOUND 16557 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDWRITERGROUP_INPUTARGUMENTS 16558 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDWRITERGROUP_OUTPUTARGUMENTS 16559 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDREADERGROUP 16560 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDREADERGROUP_INPUTARGUMENTS 16561 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_ONDELAY 16562 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_OFFDELAY 16563 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_FIRSTINGROUPFLAG 16564 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_FIRSTINGROUP 16565 /* Object */ +#define UA_NS0ID_LIMITALARMTYPE_ALARMGROUP_PLACEHOLDER 16566 /* Object */ +#define UA_NS0ID_LIMITALARMTYPE_REALARMTIME 16567 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_REALARMREPEATCOUNT 16568 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SILENCE 16569 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_SUPPRESS 16570 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDREADERGROUP_OUTPUTARGUMENTS 16571 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_BASEHIGHHIGHLIMIT 16572 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_BASEHIGHLIMIT 16573 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_BASELOWLIMIT 16574 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_BASELOWLOWLIMIT 16575 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONSUBCLASSID 16576 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_CONDITIONSUBCLASSNAME 16577 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE 16578 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_ID 16579 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_NAME 16580 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_NUMBER 16581 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16582 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16583 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16584 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16585 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16586 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE 16587 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_ID 16588 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_NAME 16589 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_NUMBER 16590 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16591 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_TRANSITIONTIME 16592 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16593 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_TRUESTATE 16594 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCESTATE_FALSESTATE 16595 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_AUDIBLEENABLED 16596 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_AUDIBLESOUND 16597 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_ADDCONNECTION 16598 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_ADDCONNECTION_INPUTARGUMENTS 16599 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_ADDCONNECTION_OUTPUTARGUMENTS 16600 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMSTEMPLATE 16601 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ONDELAY 16602 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_OFFDELAY 16603 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_FIRSTINGROUPFLAG 16604 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_FIRSTINGROUP 16605 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_ALARMGROUP_PLACEHOLDER 16606 /* Object */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_REALARMTIME 16607 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_REALARMREPEATCOUNT 16608 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SILENCE 16609 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SUPPRESS 16610 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMSTEMPLATE_INPUTARGUMENTS 16611 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_BASEHIGHHIGHLIMIT 16612 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_BASEHIGHLIMIT 16613 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_BASELOWLIMIT 16614 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_BASELOWLOWLIMIT 16615 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONSUBCLASSID 16616 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_CONDITIONSUBCLASSNAME 16617 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE 16618 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_ID 16619 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_NAME 16620 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_NUMBER 16621 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16622 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16623 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16624 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16625 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16626 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE 16627 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_ID 16628 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_NAME 16629 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_NUMBER 16630 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16631 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_TRANSITIONTIME 16632 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16633 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_TRUESTATE 16634 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCESTATE_FALSESTATE 16635 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_AUDIBLEENABLED 16636 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_AUDIBLESOUND 16637 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMSTEMPLATE_OUTPUTARGUMENTS 16638 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTSTEMPLATE 16639 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTSTEMPLATE_INPUTARGUMENTS 16640 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTSTEMPLATE_OUTPUTARGUMENTS 16641 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ONDELAY 16642 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_OFFDELAY 16643 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_FIRSTINGROUPFLAG 16644 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_FIRSTINGROUP 16645 /* Object */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_ALARMGROUP_PLACEHOLDER 16646 /* Object */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_REALARMTIME 16647 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_REALARMREPEATCOUNT 16648 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SILENCE 16649 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SUPPRESS 16650 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDDATASETFOLDER 16651 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_BASEHIGHHIGHLIMIT 16652 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_BASEHIGHLIMIT 16653 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_BASELOWLIMIT 16654 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_BASELOWLOWLIMIT 16655 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONSUBCLASSID 16656 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_CONDITIONSUBCLASSNAME 16657 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE 16658 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_ID 16659 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_NAME 16660 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_NUMBER 16661 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16662 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16663 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16664 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16665 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16666 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE 16667 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_ID 16668 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_NAME 16669 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_NUMBER 16670 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16671 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_TRANSITIONTIME 16672 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16673 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_TRUESTATE 16674 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCESTATE_FALSESTATE 16675 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_AUDIBLEENABLED 16676 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_AUDIBLESOUND 16677 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDDATASETFOLDER_INPUTARGUMENTS 16678 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_ADDDATASETFOLDER_OUTPUTARGUMENTS 16679 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_REMOVEDATASETFOLDER 16680 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_PUBLISHEDDATASETS_REMOVEDATASETFOLDER_INPUTARGUMENTS 16681 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ONDELAY 16682 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_OFFDELAY 16683 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_FIRSTINGROUPFLAG 16684 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_FIRSTINGROUP 16685 /* Object */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_ALARMGROUP_PLACEHOLDER 16686 /* Object */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_REALARMTIME 16687 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_REALARMREPEATCOUNT 16688 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SILENCE 16689 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SUPPRESS 16690 /* Method */ +#define UA_NS0ID_ADDCONNECTIONMETHODTYPE 16691 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_BASEHIGHHIGHLIMIT 16692 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_BASEHIGHLIMIT 16693 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_BASELOWLIMIT 16694 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_BASELOWLOWLIMIT 16695 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONSUBCLASSID 16696 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_CONDITIONSUBCLASSNAME 16697 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE 16698 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_ID 16699 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_NAME 16700 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_NUMBER 16701 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16702 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16703 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16704 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16705 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16706 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE 16707 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_ID 16708 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_NAME 16709 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_NUMBER 16710 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16711 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_TRANSITIONTIME 16712 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16713 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_TRUESTATE 16714 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCESTATE_FALSESTATE 16715 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_AUDIBLEENABLED 16716 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_AUDIBLESOUND 16717 /* Variable */ +#define UA_NS0ID_ADDCONNECTIONMETHODTYPE_INPUTARGUMENTS 16718 /* Variable */ +#define UA_NS0ID_ADDCONNECTIONMETHODTYPE_OUTPUTARGUMENTS 16719 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERID 16720 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETFIELDCONTENTMASK 16721 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ONDELAY 16722 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_OFFDELAY 16723 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_FIRSTINGROUPFLAG 16724 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_FIRSTINGROUP 16725 /* Object */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_ALARMGROUP_PLACEHOLDER 16726 /* Object */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_REALARMTIME 16727 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_REALARMREPEATCOUNT 16728 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SILENCE 16729 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SUPPRESS 16730 /* Method */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_KEYFRAMECOUNT 16731 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_BASEHIGHHIGHLIMIT 16732 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_BASEHIGHLIMIT 16733 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_BASELOWLIMIT 16734 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_BASELOWLOWLIMIT 16735 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONSUBCLASSID 16736 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_CONDITIONSUBCLASSNAME 16737 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE 16738 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_ID 16739 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_NAME 16740 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_NUMBER 16741 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16742 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16743 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16744 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16745 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16746 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE 16747 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_ID 16748 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_NAME 16749 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_NUMBER 16750 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16751 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_TRANSITIONTIME 16752 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16753 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_TRUESTATE 16754 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_FALSESTATE 16755 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_AUDIBLEENABLED 16756 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND 16757 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_MESSAGESETTINGS 16758 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETCLASSID 16759 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERID 16760 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETFIELDCONTENTMASK 16761 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ONDELAY 16762 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_OFFDELAY 16763 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_FIRSTINGROUPFLAG 16764 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_FIRSTINGROUP 16765 /* Object */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_ALARMGROUP_PLACEHOLDER 16766 /* Object */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_REALARMTIME 16767 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_REALARMREPEATCOUNT 16768 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SILENCE 16769 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SUPPRESS 16770 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_KEYFRAMECOUNT 16771 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_BASEHIGHHIGHLIMIT 16772 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_BASEHIGHLIMIT 16773 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_BASELOWLIMIT 16774 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_BASELOWLOWLIMIT 16775 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_BASESETPOINTNODE 16776 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONSUBCLASSID 16777 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_CONDITIONSUBCLASSNAME 16778 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE 16779 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_ID 16780 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_NAME 16781 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_NUMBER 16782 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16783 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16784 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16785 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16786 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16787 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE 16788 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_ID 16789 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_NAME 16790 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_NUMBER 16791 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16792 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_TRANSITIONTIME 16793 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16794 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_TRUESTATE 16795 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCESTATE_FALSESTATE 16796 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_AUDIBLEENABLED 16797 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND 16798 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_MESSAGESETTINGS 16799 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETCLASSID 16800 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERID 16801 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETFIELDCONTENTMASK 16802 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ONDELAY 16803 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_OFFDELAY 16804 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_FIRSTINGROUPFLAG 16805 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_FIRSTINGROUP 16806 /* Object */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_ALARMGROUP_PLACEHOLDER 16807 /* Object */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_REALARMTIME 16808 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_REALARMREPEATCOUNT 16809 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SILENCE 16810 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SUPPRESS 16811 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_KEYFRAMECOUNT 16812 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_BASEHIGHHIGHLIMIT 16813 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_BASEHIGHLIMIT 16814 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_BASELOWLIMIT 16815 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_BASELOWLOWLIMIT 16816 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_BASESETPOINTNODE 16817 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONSUBCLASSID 16818 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONSUBCLASSNAME 16819 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE 16820 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_ID 16821 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_NAME 16822 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_NUMBER 16823 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16824 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16825 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16826 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16827 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16828 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE 16829 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_ID 16830 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_NAME 16831 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_NUMBER 16832 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16833 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_TRANSITIONTIME 16834 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16835 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_TRUESTATE 16836 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_FALSESTATE 16837 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLEENABLED 16838 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND 16839 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_MESSAGESETTINGS 16840 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETCLASSID 16841 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDDATAITEMSTEMPLATE 16842 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDDATAITEMSTEMPLATE_INPUTARGUMENTS 16843 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ONDELAY 16844 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_OFFDELAY 16845 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_FIRSTINGROUPFLAG 16846 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_FIRSTINGROUP 16847 /* Object */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ALARMGROUP_PLACEHOLDER 16848 /* Object */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_REALARMTIME 16849 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_REALARMREPEATCOUNT 16850 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SILENCE 16851 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESS 16852 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDDATAITEMSTEMPLATE_OUTPUTARGUMENTS 16853 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_BASEHIGHHIGHLIMIT 16854 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_BASEHIGHLIMIT 16855 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_BASELOWLIMIT 16856 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_BASELOWLOWLIMIT 16857 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_ENGINEERINGUNITS 16858 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONSUBCLASSID 16859 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_CONDITIONSUBCLASSNAME 16860 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE 16861 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_ID 16862 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_NAME 16863 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_NUMBER 16864 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16865 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16866 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16867 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16868 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16869 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE 16870 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_ID 16871 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_NAME 16872 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_NUMBER 16873 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16874 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_TRANSITIONTIME 16875 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16876 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_TRUESTATE 16877 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCESTATE_FALSESTATE 16878 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLEENABLED 16879 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND 16880 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDEVENTSTEMPLATE 16881 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDEVENTSTEMPLATE_INPUTARGUMENTS 16882 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDPUBLISHEDEVENTSTEMPLATE_OUTPUTARGUMENTS 16883 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDDATASETFOLDER 16884 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ONDELAY 16885 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_OFFDELAY 16886 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_FIRSTINGROUPFLAG 16887 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_FIRSTINGROUP 16888 /* Object */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ALARMGROUP_PLACEHOLDER 16889 /* Object */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_REALARMTIME 16890 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_REALARMREPEATCOUNT 16891 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SILENCE 16892 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SUPPRESS 16893 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDDATASETFOLDER_INPUTARGUMENTS 16894 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_BASEHIGHHIGHLIMIT 16895 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_BASEHIGHLIMIT 16896 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_BASELOWLIMIT 16897 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_BASELOWLOWLIMIT 16898 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_ENGINEERINGUNITS 16899 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONSUBCLASSID 16900 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_CONDITIONSUBCLASSNAME 16901 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE 16902 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_ID 16903 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_NAME 16904 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_NUMBER 16905 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16906 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16907 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16908 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16909 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16910 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE 16911 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_ID 16912 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_NAME 16913 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_NUMBER 16914 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16915 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_TRANSITIONTIME 16916 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16917 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_TRUESTATE 16918 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCESTATE_FALSESTATE 16919 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_AUDIBLEENABLED 16920 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_AUDIBLESOUND 16921 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_ADDDATASETFOLDER_OUTPUTARGUMENTS 16922 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_REMOVEDATASETFOLDER 16923 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_DATASETFOLDERNAME_PLACEHOLDER_REMOVEDATASETFOLDER_INPUTARGUMENTS 16924 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_PUBLISHEDDATASETNAME_PLACEHOLDER_DATASETCLASSID 16925 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_ONDELAY 16926 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_OFFDELAY 16927 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_FIRSTINGROUPFLAG 16928 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_FIRSTINGROUP 16929 /* Object */ +#define UA_NS0ID_DISCRETEALARMTYPE_ALARMGROUP_PLACEHOLDER 16930 /* Object */ +#define UA_NS0ID_DISCRETEALARMTYPE_REALARMTIME 16931 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_REALARMREPEATCOUNT 16932 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SILENCE 16933 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_SUPPRESS 16934 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMSTEMPLATE 16935 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONSUBCLASSID 16936 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_CONDITIONSUBCLASSNAME 16937 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE 16938 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_ID 16939 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_NAME 16940 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_NUMBER 16941 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16942 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16943 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16944 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16945 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16946 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE 16947 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_ID 16948 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_NAME 16949 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_NUMBER 16950 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16951 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_TRANSITIONTIME 16952 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16953 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_TRUESTATE 16954 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCESTATE_FALSESTATE 16955 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_AUDIBLEENABLED 16956 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_AUDIBLESOUND 16957 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMSTEMPLATE_INPUTARGUMENTS 16958 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDDATAITEMSTEMPLATE_OUTPUTARGUMENTS 16959 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDEVENTSTEMPLATE 16960 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDEVENTSTEMPLATE_INPUTARGUMENTS 16961 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ONDELAY 16962 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_OFFDELAY 16963 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_FIRSTINGROUPFLAG 16964 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_FIRSTINGROUP 16965 /* Object */ +#define UA_NS0ID_OFFNORMALALARMTYPE_ALARMGROUP_PLACEHOLDER 16966 /* Object */ +#define UA_NS0ID_OFFNORMALALARMTYPE_REALARMTIME 16967 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_REALARMREPEATCOUNT 16968 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SILENCE 16969 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SUPPRESS 16970 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDPUBLISHEDEVENTSTEMPLATE_OUTPUTARGUMENTS 16971 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONSUBCLASSID 16972 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_CONDITIONSUBCLASSNAME 16973 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE 16974 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_ID 16975 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_NAME 16976 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_NUMBER 16977 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 16978 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 16979 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 16980 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 16981 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 16982 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE 16983 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_ID 16984 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_NAME 16985 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_NUMBER 16986 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 16987 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_TRANSITIONTIME 16988 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 16989 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_TRUESTATE 16990 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCESTATE_FALSESTATE 16991 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_AUDIBLEENABLED 16992 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_AUDIBLESOUND 16993 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDDATASETFOLDER 16994 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDDATASETFOLDER_INPUTARGUMENTS 16995 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_ADDDATASETFOLDER_OUTPUTARGUMENTS 16996 /* Variable */ +#define UA_NS0ID_DATASETFOLDERTYPE_REMOVEDATASETFOLDER 16997 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ONDELAY 16998 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_OFFDELAY 16999 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_FIRSTINGROUPFLAG 17000 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_FIRSTINGROUP 17001 /* Object */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_ALARMGROUP_PLACEHOLDER 17002 /* Object */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_REALARMTIME 17003 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_REALARMREPEATCOUNT 17004 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SILENCE 17005 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SUPPRESS 17006 /* Method */ +#define UA_NS0ID_DATASETFOLDERTYPE_REMOVEDATASETFOLDER_INPUTARGUMENTS 17007 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONSUBCLASSID 17008 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_CONDITIONSUBCLASSNAME 17009 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE 17010 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_ID 17011 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_NAME 17012 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_NUMBER 17013 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 17014 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 17015 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 17016 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 17017 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 17018 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE 17019 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_ID 17020 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_NAME 17021 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_NUMBER 17022 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 17023 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_TRANSITIONTIME 17024 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 17025 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_TRUESTATE 17026 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCESTATE_FALSESTATE 17027 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_AUDIBLEENABLED 17028 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_AUDIBLESOUND 17029 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDDATAITEMSTEMPLATEMETHODTYPE 17030 /* Method */ +#define UA_NS0ID_ADDPUBLISHEDDATAITEMSTEMPLATEMETHODTYPE_INPUTARGUMENTS 17031 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDDATAITEMSTEMPLATEMETHODTYPE_OUTPUTARGUMENTS 17032 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDEVENTSTEMPLATEMETHODTYPE 17033 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_ONDELAY 17034 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_OFFDELAY 17035 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_FIRSTINGROUPFLAG 17036 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_FIRSTINGROUP 17037 /* Object */ +#define UA_NS0ID_TRIPALARMTYPE_ALARMGROUP_PLACEHOLDER 17038 /* Object */ +#define UA_NS0ID_TRIPALARMTYPE_REALARMTIME 17039 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_REALARMREPEATCOUNT 17040 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SILENCE 17041 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_SUPPRESS 17042 /* Method */ +#define UA_NS0ID_ADDPUBLISHEDEVENTSTEMPLATEMETHODTYPE_INPUTARGUMENTS 17043 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONSUBCLASSID 17044 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_CONDITIONSUBCLASSNAME 17045 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE 17046 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_ID 17047 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_NAME 17048 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_NUMBER 17049 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 17050 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 17051 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 17052 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 17053 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 17054 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE 17055 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_ID 17056 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_NAME 17057 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_NUMBER 17058 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 17059 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_TRANSITIONTIME 17060 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 17061 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_TRUESTATE 17062 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCESTATE_FALSESTATE 17063 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_AUDIBLEENABLED 17064 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_AUDIBLESOUND 17065 /* Variable */ +#define UA_NS0ID_ADDPUBLISHEDEVENTSTEMPLATEMETHODTYPE_OUTPUTARGUMENTS 17066 /* Variable */ +#define UA_NS0ID_ADDDATASETFOLDERMETHODTYPE 17067 /* Method */ +#define UA_NS0ID_ADDDATASETFOLDERMETHODTYPE_INPUTARGUMENTS 17068 /* Variable */ +#define UA_NS0ID_ADDDATASETFOLDERMETHODTYPE_OUTPUTARGUMENTS 17069 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ONDELAY 17070 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_OFFDELAY 17071 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_FIRSTINGROUPFLAG 17072 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_FIRSTINGROUP 17073 /* Object */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_ALARMGROUP_PLACEHOLDER 17074 /* Object */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_REALARMTIME 17075 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_REALARMREPEATCOUNT 17076 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SILENCE 17077 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SUPPRESS 17078 /* Method */ +#define UA_NS0ID_REMOVEDATASETFOLDERMETHODTYPE 17079 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE 17080 /* ObjectType */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_EVENTID 17081 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_EVENTTYPE 17082 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SOURCENODE 17083 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SOURCENAME 17084 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_TIME 17085 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_RECEIVETIME 17086 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LOCALTIME 17087 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_MESSAGE 17088 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SEVERITY 17089 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONCLASSID 17090 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONCLASSNAME 17091 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONSUBCLASSID 17092 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONSUBCLASSNAME 17093 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONNAME 17094 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_BRANCHID 17095 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_RETAIN 17096 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE 17097 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_ID 17098 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_NAME 17099 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_NUMBER 17100 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 17101 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 17102 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 17103 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_TRUESTATE 17104 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLEDSTATE_FALSESTATE 17105 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_QUALITY 17106 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_QUALITY_SOURCETIMESTAMP 17107 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LASTSEVERITY 17108 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 17109 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_COMMENT 17110 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_COMMENT_SOURCETIMESTAMP 17111 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CLIENTUSERID 17112 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_DISABLE 17113 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ENABLE 17114 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ADDCOMMENT 17115 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 17116 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONREFRESH 17117 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 17118 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONREFRESH2 17119 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 17120 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE 17121 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_ID 17122 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_NAME 17123 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_NUMBER 17124 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 17125 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_TRANSITIONTIME 17126 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 17127 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_TRUESTATE 17128 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKEDSTATE_FALSESTATE 17129 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE 17130 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_ID 17131 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_NAME 17132 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_NUMBER 17133 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 17134 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 17135 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 17136 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_TRUESTATE 17137 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRMEDSTATE_FALSESTATE 17138 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKNOWLEDGE 17139 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 17140 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRM 17141 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_CONFIRM_INPUTARGUMENTS 17142 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE 17143 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_ID 17144 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_NAME 17145 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_NUMBER 17146 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 17147 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_TRANSITIONTIME 17148 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 17149 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_TRUESTATE 17150 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ACTIVESTATE_FALSESTATE 17151 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_INPUTNODE 17152 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE 17153 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_ID 17154 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_NAME 17155 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_NUMBER 17156 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 17157 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 17158 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 17159 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 17160 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 17161 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE 17162 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_ID 17163 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_NAME 17164 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_NUMBER 17165 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 17166 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 17167 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 17168 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 17169 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 17170 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE 17171 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_ID 17172 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_NAME 17173 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_NUMBER 17174 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 17175 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_TRANSITIONTIME 17176 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 17177 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_TRUESTATE 17178 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCESTATE_FALSESTATE 17179 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE 17180 /* Object */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_CURRENTSTATE 17181 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 17182 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 17183 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 17184 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 17185 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_LASTTRANSITION 17186 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 17187 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 17188 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 17189 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 17190 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 17191 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_UNSHELVETIME 17192 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_UNSHELVE 17193 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 17194 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 17195 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 17196 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESSEDORSHELVED 17197 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_MAXTIMESHELVED 17198 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_AUDIBLEENABLED 17199 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_AUDIBLESOUND 17200 /* Variable */ +#define UA_NS0ID_REMOVEDATASETFOLDERMETHODTYPE_INPUTARGUMENTS 17201 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDRESS_NETWORKINTERFACE 17202 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_TRANSPORTSETTINGS 17203 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_MAXNETWORKMESSAGESIZE 17204 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ONDELAY 17205 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_OFFDELAY 17206 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_FIRSTINGROUPFLAG 17207 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_FIRSTINGROUP 17208 /* Object */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_ALARMGROUP_PLACEHOLDER 17209 /* Object */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_REALARMTIME 17210 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_REALARMREPEATCOUNT 17211 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SILENCE 17212 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SUPPRESS 17213 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_WRITERGROUPID 17214 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_TARGETVALUENODE 17215 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_EXPECTEDTIME 17216 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_TOLERANCE 17217 /* Variable */ +#define UA_NS0ID_SAFETYCONDITIONCLASSTYPE 17218 /* ObjectType */ +#define UA_NS0ID_HIGHLYMANAGEDALARMCONDITIONCLASSTYPE 17219 /* ObjectType */ +#define UA_NS0ID_TRAININGCONDITIONCLASSTYPE 17220 /* ObjectType */ +#define UA_NS0ID_TESTINGCONDITIONSUBCLASSTYPE 17221 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONCOMMENTEVENTTYPE_CONDITIONEVENTID 17222 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONACKNOWLEDGEEVENTTYPE_CONDITIONEVENTID 17223 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONCONFIRMEVENTTYPE_CONDITIONEVENTID 17224 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE 17225 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_EVENTID 17226 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_EVENTTYPE 17227 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_SOURCENODE 17228 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_SOURCENAME 17229 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_TIME 17230 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_RECEIVETIME 17231 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_LOCALTIME 17232 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_MESSAGE 17233 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_SEVERITY 17234 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_ACTIONTIMESTAMP 17235 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_STATUS 17236 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_SERVERID 17237 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_CLIENTAUDITENTRYID 17238 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_CLIENTUSERID 17239 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_METHODID 17240 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSUPPRESSIONEVENTTYPE_INPUTARGUMENTS 17241 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE 17242 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_EVENTID 17243 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_EVENTTYPE 17244 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_SOURCENODE 17245 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_SOURCENAME 17246 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_TIME 17247 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_RECEIVETIME 17248 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_LOCALTIME 17249 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_MESSAGE 17250 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_SEVERITY 17251 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_ACTIONTIMESTAMP 17252 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_STATUS 17253 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_SERVERID 17254 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_CLIENTAUDITENTRYID 17255 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_CLIENTUSERID 17256 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_METHODID 17257 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONSILENCEEVENTTYPE_INPUTARGUMENTS 17258 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE 17259 /* ObjectType */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_EVENTID 17260 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_EVENTTYPE 17261 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_SOURCENODE 17262 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_SOURCENAME 17263 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_TIME 17264 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_RECEIVETIME 17265 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_LOCALTIME 17266 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_MESSAGE 17267 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_SEVERITY 17268 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_ACTIONTIMESTAMP 17269 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_STATUS 17270 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_SERVERID 17271 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_CLIENTAUDITENTRYID 17272 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_CLIENTUSERID 17273 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_METHODID 17274 /* Variable */ +#define UA_NS0ID_AUDITCONDITIONOUTOFSERVICEEVENTTYPE_INPUTARGUMENTS 17275 /* Variable */ +#define UA_NS0ID_HASEFFECTDISABLE 17276 /* ReferenceType */ +#define UA_NS0ID_ALARMRATEVARIABLETYPE 17277 /* VariableType */ +#define UA_NS0ID_ALARMRATEVARIABLETYPE_RATE 17278 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE 17279 /* ObjectType */ +#define UA_NS0ID_ALARMMETRICSTYPE_ALARMCOUNT 17280 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_MAXIMUMACTIVESTATE 17281 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_MAXIMUMUNACK 17282 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_MAXIMUMREALARMCOUNT 17283 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_CURRENTALARMRATE 17284 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_CURRENTALARMRATE_RATE 17285 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_MAXIMUMALARMRATE 17286 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_MAXIMUMALARMRATE_RATE 17287 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_AVERAGEALARMRATE 17288 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_AVERAGEALARMRATE_RATE 17289 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_TRANSPORTSETTINGS 17290 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_MESSAGESETTINGS 17291 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI 17292 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_ADDDATASETWRITER 17293 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_ADDDATASETWRITER_INPUTARGUMENTS 17294 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI_RESTRICTTOLIST 17295 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SETSECURITYKEYS 17296 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SETSECURITYKEYS_INPUTARGUMENTS 17297 /* Variable */ +#define UA_NS0ID_SETSECURITYKEYSMETHODTYPE 17298 /* Method */ +#define UA_NS0ID_SETSECURITYKEYSMETHODTYPE_INPUTARGUMENTS 17299 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 17300 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_ADDDATASETWRITER_OUTPUTARGUMENTS 17301 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_MAXNETWORKMESSAGESIZE 17302 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 17303 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 17304 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 17305 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_TRANSPORTPROFILEURI 17306 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_TRANSPORTSETTINGS 17307 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_MESSAGESETTINGS 17308 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_TRANSPORTPROFILEURI_RESTRICTTOLIST 17309 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER 17310 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_SECURITYMODE 17311 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_SECURITYGROUPID 17312 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_SECURITYKEYSERVICES 17313 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_STATUS 17314 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_STATUS_STATE 17315 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_STATUS_ENABLE 17316 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_STATUS_DISABLE 17317 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_PUBLISHINGINTERVAL 17318 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_KEEPALIVETIME 17319 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 17320 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_PRIORITY 17321 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_LOCALEIDS 17322 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_REMOVEDATASETWRITER 17323 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_REMOVEDATASETWRITER_INPUTARGUMENTS 17324 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER 17325 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_SECURITYMODE 17326 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_SECURITYGROUPID 17327 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_SECURITYKEYSERVICES 17328 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_STATUS 17329 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_STATUS_STATE 17330 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_STATUS_ENABLE 17331 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_STATUS_DISABLE 17332 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_REMOVEDATASETREADER 17333 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_REMOVEDATASETREADER_INPUTARGUMENTS 17334 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 17335 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 17336 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 17337 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 17338 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 17339 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 17340 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 17341 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 17342 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 17343 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 17344 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 17345 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 17346 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 17347 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 17348 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 17349 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 17350 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 17351 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 17352 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_RESOLVEDADDRESS 17353 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_RESOLVEDADDRESS_DIAGNOSTICSLEVEL 17354 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_ADDDATASETREADER 17355 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDWRITERGROUP 17356 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDWRITERGROUP_INPUTARGUMENTS 17357 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDWRITERGROUP_OUTPUTARGUMENTS 17358 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDREADERGROUP 17359 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDREADERGROUP_INPUTARGUMENTS 17360 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDREADERGROUP_OUTPUTARGUMENTS 17361 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_REMOVEGROUP 17362 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_REMOVEGROUP_INPUTARGUMENTS 17363 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SETSECURITYKEYS 17364 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SETSECURITYKEYS_INPUTARGUMENTS 17365 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_ADDCONNECTION 17366 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_ADDCONNECTION_INPUTARGUMENTS 17367 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_ADDCONNECTION_OUTPUTARGUMENTS 17368 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_REMOVECONNECTION 17369 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_REMOVECONNECTION_INPUTARGUMENTS 17370 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS 17371 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMS 17372 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMS_INPUTARGUMENTS 17373 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMS_OUTPUTARGUMENTS 17374 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTS 17375 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTS_INPUTARGUMENTS 17376 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTS_OUTPUTARGUMENTS 17377 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMSTEMPLATE 17378 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMSTEMPLATE_INPUTARGUMENTS 17379 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDDATAITEMSTEMPLATE_OUTPUTARGUMENTS 17380 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTSTEMPLATE 17381 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTSTEMPLATE_INPUTARGUMENTS 17382 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDPUBLISHEDEVENTSTEMPLATE_OUTPUTARGUMENTS 17383 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_REMOVEPUBLISHEDDATASET 17384 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_REMOVEPUBLISHEDDATASET_INPUTARGUMENTS 17385 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_CREATETARGETVARIABLES 17386 /* Method */ +#define UA_NS0ID_DATASETREADERTYPE_CREATETARGETVARIABLES_INPUTARGUMENTS 17387 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_CREATETARGETVARIABLES_OUTPUTARGUMENTS 17388 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_CREATEDATASETMIRROR 17389 /* Method */ +#define UA_NS0ID_DATASETREADERTYPE_CREATEDATASETMIRROR_INPUTARGUMENTS 17390 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_CREATEDATASETMIRROR_OUTPUTARGUMENTS 17391 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPECREATETARGETVARIABLESMETHODTYPE 17392 /* Method */ +#define UA_NS0ID_DATASETREADERTYPECREATETARGETVARIABLESMETHODTYPE_INPUTARGUMENTS 17393 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPECREATETARGETVARIABLESMETHODTYPE_OUTPUTARGUMENTS 17394 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPECREATEDATASETMIRRORMETHODTYPE 17395 /* Method */ +#define UA_NS0ID_DATASETREADERTYPECREATEDATASETMIRRORMETHODTYPE_INPUTARGUMENTS 17396 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPECREATEDATASETMIRRORMETHODTYPE_OUTPUTARGUMENTS 17397 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDDATASETFOLDER 17398 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_ADDDATASETREADER_INPUTARGUMENTS 17399 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_ADDDATASETREADER_OUTPUTARGUMENTS 17400 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDDATASETFOLDER_INPUTARGUMENTS 17401 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_ADDDATASETFOLDER_OUTPUTARGUMENTS 17402 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_REMOVEDATASETFOLDER 17403 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_PUBLISHEDDATASETS_REMOVEDATASETFOLDER_INPUTARGUMENTS 17404 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_STATUS 17405 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_STATUS_STATE 17406 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_STATUS_ENABLE 17407 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_STATUS_DISABLE 17408 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS 17409 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_DIAGNOSTICSLEVEL 17410 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALINFORMATION 17411 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 17412 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 17413 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 17414 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 17415 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALERROR 17416 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALERROR_ACTIVE 17417 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 17418 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 17419 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 17420 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_RESET 17421 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_SUBERROR 17422 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS 17423 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEERROR 17424 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 17425 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 17426 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDWRITERGROUP 17427 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDWRITERGROUP_INPUTARGUMENTS 17428 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 17429 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 17430 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 17431 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 17432 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 17433 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 17434 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 17435 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 17436 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 17437 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 17438 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 17439 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 17440 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 17441 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 17442 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 17443 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 17444 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 17445 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 17446 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 17447 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 17448 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 17449 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 17450 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 17451 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 17452 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 17453 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 17454 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 17455 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDWRITERGROUP_OUTPUTARGUMENTS 17456 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES 17457 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS 17458 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS_DIAGNOSTICSLEVEL 17459 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS 17460 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS_DIAGNOSTICSLEVEL 17461 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS 17462 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS_DIAGNOSTICSLEVEL 17463 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS 17464 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDREADERGROUP 17465 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS_DIAGNOSTICSLEVEL 17466 /* Variable */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTDATATYPE 17467 /* DataType */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 17468 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATAGRAMCONNECTIONTRANSPORTDATATYPE 17469 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATAGRAMCONNECTIONTRANSPORTDATATYPE_DATATYPEVERSION 17470 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATAGRAMCONNECTIONTRANSPORTDATATYPE_DICTIONARYFRAGMENT 17471 /* Variable */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTXML 17472 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATAGRAMCONNECTIONTRANSPORTDATATYPE 17473 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATAGRAMCONNECTIONTRANSPORTDATATYPE_DATATYPEVERSION 17474 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATAGRAMCONNECTIONTRANSPORTDATATYPE_DICTIONARYFRAGMENT 17475 /* Variable */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 17476 /* Object */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_DATASETOFFSET 17477 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_CONNECTIONPROPERTIES 17478 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_SUPPORTEDTRANSPORTPROFILES 17479 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_CONNECTIONPROPERTIES 17480 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_SUPPORTEDTRANSPORTPROFILES 17481 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERPROPERTIES 17482 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERPROPERTIES 17483 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERPROPERTIES 17484 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_CONNECTIONPROPERTIES 17485 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_GROUPPROPERTIES 17486 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_GROUPPROPERTIES 17487 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPE_GROUPPROPERTIES 17488 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_GROUPPROPERTIES 17489 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERPROPERTIES 17490 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_GROUPPROPERTIES 17491 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DATASETREADERPROPERTIES 17492 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DATASETWRITERPROPERTIES 17493 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DATASETREADERPROPERTIES 17494 /* Variable */ +#define UA_NS0ID_CREATECREDENTIALMETHODTYPE_OUTPUTARGUMENTS 17495 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE 17496 /* ObjectType */ +#define UA_NS0ID_ANALOGUNITTYPE 17497 /* VariableType */ +#define UA_NS0ID_ANALOGUNITTYPE_DEFINITION 17498 /* Variable */ +#define UA_NS0ID_ANALOGUNITTYPE_VALUEPRECISION 17499 /* Variable */ +#define UA_NS0ID_ANALOGUNITTYPE_INSTRUMENTRANGE 17500 /* Variable */ +#define UA_NS0ID_ANALOGUNITTYPE_EURANGE 17501 /* Variable */ +#define UA_NS0ID_ANALOGUNITTYPE_ENGINEERINGUNITS 17502 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE_SELECTIONS 17503 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE_SELECTIONDESCRIPTIONS 17504 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE_RESTRICTTOLIST 17505 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE_SELECTIONS 17506 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDREADERGROUP_INPUTARGUMENTS 17507 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDREADERGROUP_OUTPUTARGUMENTS 17508 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE_SELECTIONDESCRIPTIONS 17509 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBE_CONNECTIONNAME_PLACEHOLDER_ADDRESS_NETWORKINTERFACE_RESTRICTTOLIST 17510 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER 17511 /* Object */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_RESOURCEURI 17512 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_PROFILEURI 17513 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_ENDPOINTURLS 17514 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_SERVICESTATUS 17515 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_GETENCRYPTINGKEY 17516 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_GETENCRYPTINGKEY_INPUTARGUMENTS 17517 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_GETENCRYPTINGKEY_OUTPUTARGUMENTS 17518 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_UPDATECREDENTIAL 17519 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_UPDATECREDENTIAL_INPUTARGUMENTS 17520 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_DELETECREDENTIAL 17521 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_CREATECREDENTIAL 17522 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_CREATECREDENTIAL_INPUTARGUMENTS 17523 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONFOLDERTYPE_CREATECREDENTIAL_OUTPUTARGUMENTS 17524 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_GETENCRYPTINGKEY 17525 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_GETENCRYPTINGKEY_INPUTARGUMENTS 17526 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_GETENCRYPTINGKEY_OUTPUTARGUMENTS 17527 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_CREATECREDENTIAL 17528 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_CREATECREDENTIAL_INPUTARGUMENTS 17529 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_CREATECREDENTIAL_OUTPUTARGUMENTS 17530 /* Variable */ +#define UA_NS0ID_GETENCRYPTINGKEYMETHODTYPE 17531 /* Method */ +#define UA_NS0ID_GETENCRYPTINGKEYMETHODTYPE_INPUTARGUMENTS 17532 /* Variable */ +#define UA_NS0ID_GETENCRYPTINGKEYMETHODTYPE_OUTPUTARGUMENTS 17533 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_GETENCRYPTINGKEY 17534 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_GETENCRYPTINGKEY_INPUTARGUMENTS 17535 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_GETENCRYPTINGKEY_OUTPUTARGUMENTS 17536 /* Variable */ +#define UA_NS0ID_ADDITIONALPARAMETERSTYPE_ENCODING_DEFAULTBINARY 17537 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDITIONALPARAMETERSTYPE 17538 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDITIONALPARAMETERSTYPE_DATATYPEVERSION 17539 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ADDITIONALPARAMETERSTYPE_DICTIONARYFRAGMENT 17540 /* Variable */ +#define UA_NS0ID_ADDITIONALPARAMETERSTYPE_ENCODING_DEFAULTXML 17541 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDITIONALPARAMETERSTYPE 17542 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDITIONALPARAMETERSTYPE_DATATYPEVERSION 17543 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ADDITIONALPARAMETERSTYPE_DICTIONARYFRAGMENT 17544 /* Variable */ +#define UA_NS0ID_RSAENCRYPTEDSECRET 17545 /* DataType */ +#define UA_NS0ID_ECCENCRYPTEDSECRET 17546 /* DataType */ +#define UA_NS0ID_ADDITIONALPARAMETERSTYPE_ENCODING_DEFAULTJSON 17547 /* Object */ +#define UA_NS0ID_EPHEMERALKEYTYPE 17548 /* DataType */ +#define UA_NS0ID_EPHEMERALKEYTYPE_ENCODING_DEFAULTBINARY 17549 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EPHEMERALKEYTYPE 17550 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EPHEMERALKEYTYPE_DATATYPEVERSION 17551 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_EPHEMERALKEYTYPE_DICTIONARYFRAGMENT 17552 /* Variable */ +#define UA_NS0ID_EPHEMERALKEYTYPE_ENCODING_DEFAULTXML 17553 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EPHEMERALKEYTYPE 17554 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EPHEMERALKEYTYPE_DATATYPEVERSION 17555 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_EPHEMERALKEYTYPE_DICTIONARYFRAGMENT 17556 /* Variable */ +#define UA_NS0ID_EPHEMERALKEYTYPE_ENCODING_DEFAULTJSON 17557 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_HEADERLAYOUTURI 17558 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_HEADERLAYOUTURI 17559 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_KEYFRAMECOUNT 17560 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPEADDWRITERGROUPMETHODTYPE 17561 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_HEADERLAYOUTURI 17562 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_KEYFRAMECOUNT 17563 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_HEADERLAYOUTURI 17564 /* Variable */ +#define UA_NS0ID_BASEANALOGTYPE_DEFINITION 17565 /* Variable */ +#define UA_NS0ID_BASEANALOGTYPE_VALUEPRECISION 17566 /* Variable */ +#define UA_NS0ID_BASEANALOGTYPE_INSTRUMENTRANGE 17567 /* Variable */ +#define UA_NS0ID_BASEANALOGTYPE_EURANGE 17568 /* Variable */ +#define UA_NS0ID_BASEANALOGTYPE_ENGINEERINGUNITS 17569 /* Variable */ +#define UA_NS0ID_ANALOGUNITRANGETYPE 17570 /* VariableType */ +#define UA_NS0ID_ANALOGUNITRANGETYPE_DEFINITION 17571 /* Variable */ +#define UA_NS0ID_ANALOGUNITRANGETYPE_VALUEPRECISION 17572 /* Variable */ +#define UA_NS0ID_ANALOGUNITRANGETYPE_INSTRUMENTRANGE 17573 /* Variable */ +#define UA_NS0ID_ANALOGUNITRANGETYPE_EURANGE 17574 /* Variable */ +#define UA_NS0ID_ANALOGUNITRANGETYPE_ENGINEERINGUNITS 17575 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDRESS_NETWORKINTERFACE_SELECTIONS 17576 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDRESS_NETWORKINTERFACE_SELECTIONDESCRIPTIONS 17577 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_ADDRESS_NETWORKINTERFACE_RESTRICTTOLIST 17578 /* Variable */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTTYPE_DISCOVERYADDRESS_NETWORKINTERFACE_SELECTIONS 17579 /* Variable */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTTYPE_DISCOVERYADDRESS_NETWORKINTERFACE_SELECTIONDESCRIPTIONS 17580 /* Variable */ +#define UA_NS0ID_DATAGRAMCONNECTIONTRANSPORTTYPE_DISCOVERYADDRESS_NETWORKINTERFACE_RESTRICTTOLIST 17581 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSTYPE_NETWORKINTERFACE_SELECTIONS 17582 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSTYPE_NETWORKINTERFACE_SELECTIONDESCRIPTIONS 17583 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSTYPE_NETWORKINTERFACE_RESTRICTTOLIST 17584 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSURLTYPE_NETWORKINTERFACE_SELECTIONS 17585 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSURLTYPE_NETWORKINTERFACE_SELECTIONDESCRIPTIONS 17586 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSURLTYPE_NETWORKINTERFACE_RESTRICTTOLIST 17587 /* Variable */ +#define UA_NS0ID_INDEX 17588 /* DataType */ +#define UA_NS0ID_DICTIONARYENTRYTYPE 17589 /* ObjectType */ +#define UA_NS0ID_DICTIONARYENTRYTYPE_DICTIONARYENTRYNAME_PLACEHOLDER 17590 /* Object */ +#define UA_NS0ID_DICTIONARYFOLDERTYPE 17591 /* ObjectType */ +#define UA_NS0ID_DICTIONARYFOLDERTYPE_DICTIONARYFOLDERNAME_PLACEHOLDER 17592 /* Object */ +#define UA_NS0ID_DICTIONARYFOLDERTYPE_DICTIONARYENTRYNAME_PLACEHOLDER 17593 /* Object */ +#define UA_NS0ID_DICTIONARIES 17594 /* Object */ +#define UA_NS0ID_DICTIONARIES_DICTIONARYFOLDERNAME_PLACEHOLDER 17595 /* Object */ +#define UA_NS0ID_DICTIONARIES_DICTIONARYENTRYNAME_PLACEHOLDER 17596 /* Object */ +#define UA_NS0ID_HASDICTIONARYENTRY 17597 /* ReferenceType */ +#define UA_NS0ID_IRDIDICTIONARYENTRYTYPE 17598 /* ObjectType */ +#define UA_NS0ID_IRDIDICTIONARYENTRYTYPE_DICTIONARYENTRYNAME_PLACEHOLDER 17599 /* Object */ +#define UA_NS0ID_URIDICTIONARYENTRYTYPE 17600 /* ObjectType */ +#define UA_NS0ID_URIDICTIONARYENTRYTYPE_DICTIONARYENTRYNAME_PLACEHOLDER 17601 /* Object */ +#define UA_NS0ID_BASEINTERFACETYPE 17602 /* ObjectType */ +#define UA_NS0ID_HASINTERFACE 17603 /* ReferenceType */ +#define UA_NS0ID_HASADDIN 17604 /* ReferenceType */ +#define UA_NS0ID_DEFAULTINSTANCEBROWSENAME 17605 /* Variable */ +#define UA_NS0ID_GENERICATTRIBUTEVALUE 17606 /* DataType */ +#define UA_NS0ID_GENERICATTRIBUTES 17607 /* DataType */ +#define UA_NS0ID_GENERICATTRIBUTEVALUE_ENCODING_DEFAULTXML 17608 /* Object */ +#define UA_NS0ID_GENERICATTRIBUTES_ENCODING_DEFAULTXML 17609 /* Object */ +#define UA_NS0ID_GENERICATTRIBUTEVALUE_ENCODING_DEFAULTBINARY 17610 /* Object */ +#define UA_NS0ID_GENERICATTRIBUTES_ENCODING_DEFAULTBINARY 17611 /* Object */ +#define UA_NS0ID_SERVERTYPE_LOCALTIME 17612 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPEADDWRITERGROUPMETHODTYPE_INPUTARGUMENTS 17613 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPEADDWRITERGROUPMETHODTYPE_OUTPUTARGUMENTS 17614 /* Variable */ +#define UA_NS0ID_AUDITSECURITYEVENTTYPE_STATUSCODEID 17615 /* Variable */ +#define UA_NS0ID_AUDITCHANNELEVENTTYPE_STATUSCODEID 17616 /* Variable */ +#define UA_NS0ID_AUDITOPENSECURECHANNELEVENTTYPE_STATUSCODEID 17617 /* Variable */ +#define UA_NS0ID_AUDITSESSIONEVENTTYPE_STATUSCODEID 17618 /* Variable */ +#define UA_NS0ID_AUDITCREATESESSIONEVENTTYPE_STATUSCODEID 17619 /* Variable */ +#define UA_NS0ID_AUDITURLMISMATCHEVENTTYPE_STATUSCODEID 17620 /* Variable */ +#define UA_NS0ID_AUDITACTIVATESESSIONEVENTTYPE_STATUSCODEID 17621 /* Variable */ +#define UA_NS0ID_AUDITCANCELEVENTTYPE_STATUSCODEID 17622 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEVENTTYPE_STATUSCODEID 17623 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEDATAMISMATCHEVENTTYPE_STATUSCODEID 17624 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEEXPIREDEVENTTYPE_STATUSCODEID 17625 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEINVALIDEVENTTYPE_STATUSCODEID 17626 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEUNTRUSTEDEVENTTYPE_STATUSCODEID 17627 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEREVOKEDEVENTTYPE_STATUSCODEID 17628 /* Variable */ +#define UA_NS0ID_AUDITCERTIFICATEMISMATCHEVENTTYPE_STATUSCODEID 17629 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONADDREADERGROUPGROUPMETHODTYPE 17630 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONADDREADERGROUPGROUPMETHODTYPE_INPUTARGUMENTS 17631 /* Variable */ +#define UA_NS0ID_SELECTIONLISTTYPE_SELECTIONS 17632 /* Variable */ +#define UA_NS0ID_SELECTIONLISTTYPE_SELECTIONDESCRIPTIONS 17633 /* Variable */ +#define UA_NS0ID_SERVER_LOCALTIME 17634 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_AVAILABLESTATES 17635 /* Variable */ +#define UA_NS0ID_FINITESTATEMACHINETYPE_AVAILABLETRANSITIONS 17636 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_AVAILABLESTATES 17637 /* Variable */ +#define UA_NS0ID_TEMPORARYFILETRANSFERTYPE_TRANSFERSTATE_PLACEHOLDER_AVAILABLETRANSITIONS 17638 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_AVAILABLESTATES 17639 /* Variable */ +#define UA_NS0ID_FILETRANSFERSTATEMACHINETYPE_AVAILABLETRANSITIONS 17640 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE 17641 /* ObjectType */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_EVENTID 17642 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_EVENTTYPE 17643 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_SOURCENODE 17644 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_SOURCENAME 17645 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_TIME 17646 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_RECEIVETIME 17647 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_LOCALTIME 17648 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_MESSAGE 17649 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_SEVERITY 17650 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_ACTIONTIMESTAMP 17651 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_STATUS 17652 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_SERVERID 17653 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_CLIENTAUDITENTRYID 17654 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_CLIENTUSERID 17655 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_METHODID 17656 /* Variable */ +#define UA_NS0ID_ROLEMAPPINGRULECHANGEDAUDITEVENTTYPE_INPUTARGUMENTS 17657 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_AVAILABLESTATES 17658 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17659 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_AVAILABLESTATES 17660 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_SHELVINGSTATE_AVAILABLETRANSITIONS 17661 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_AVAILABLESTATES 17662 /* Variable */ +#define UA_NS0ID_SHELVEDSTATEMACHINETYPE_AVAILABLETRANSITIONS 17663 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17664 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17665 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_AVAILABLESTATES 17666 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITSTATEMACHINETYPE_AVAILABLETRANSITIONS 17667 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17668 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17669 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_AVAILABLESTATES 17670 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LIMITSTATE_AVAILABLETRANSITIONS 17671 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17672 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17673 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17674 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17675 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17676 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17677 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_AVAILABLESTATES 17678 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LIMITSTATE_AVAILABLETRANSITIONS 17679 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17680 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17681 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17682 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17683 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_AVAILABLESTATES 17684 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LIMITSTATE_AVAILABLETRANSITIONS 17685 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17686 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17687 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17688 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17689 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_AVAILABLESTATES 17690 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LIMITSTATE_AVAILABLETRANSITIONS 17691 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17692 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17693 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17694 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17695 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17696 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17697 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17698 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17699 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17700 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17701 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 17702 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 17703 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_AVAILABLESTATES 17704 /* Variable */ +#define UA_NS0ID_PROGRAMSTATEMACHINETYPE_AVAILABLETRANSITIONS 17705 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI_SELECTIONS 17706 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_TRANSPORTPROFILEURI_SELECTIONDESCRIPTIONS 17707 /* Variable */ +#define UA_NS0ID_INTERFACETYPES 17708 /* Object */ +#define UA_NS0ID_RATIONALNUMBERTYPE 17709 /* VariableType */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_TRANSPORTPROFILEURI_SELECTIONS 17710 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_TRANSPORTPROFILEURI_SELECTIONDESCRIPTIONS 17711 /* Variable */ +#define UA_NS0ID_RATIONALNUMBERTYPE_NUMERATOR 17712 /* Variable */ +#define UA_NS0ID_RATIONALNUMBERTYPE_DENOMINATOR 17713 /* Variable */ +#define UA_NS0ID_VECTORTYPE 17714 /* VariableType */ +#define UA_NS0ID_VECTORTYPE_VECTORUNIT 17715 /* Variable */ +#define UA_NS0ID_THREEDVECTORTYPE 17716 /* VariableType */ +#define UA_NS0ID_THREEDVECTORTYPE_VECTORUNIT 17717 /* Variable */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_DELETEFILESYSTEMOBJECT 17718 /* Method */ +#define UA_NS0ID_FILEDIRECTORYTYPE_FILEDIRECTORYNAME_PLACEHOLDER_DELETEFILESYSTEMOBJECT_INPUTARGUMENTS 17719 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONADDREADERGROUPGROUPMETHODTYPE_OUTPUTARGUMENTS 17720 /* Variable */ +#define UA_NS0ID_CONNECTIONTRANSPORTTYPE 17721 /* ObjectType */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_DELETEFILESYSTEMOBJECT 17722 /* Method */ +#define UA_NS0ID_FILESYSTEM_FILEDIRECTORYNAME_PLACEHOLDER_DELETEFILESYSTEMOBJECT_INPUTARGUMENTS 17723 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPE_MAXNETWORKMESSAGESIZE 17724 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE 17725 /* ObjectType */ +#define UA_NS0ID_WRITERGROUPTYPE_SECURITYMODE 17726 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_SECURITYGROUPID 17727 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_SECURITYKEYSERVICES 17728 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_MAXNETWORKMESSAGESIZE 17729 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_STATUS 17730 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_STATUS_STATE 17731 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICES 17732 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_STATUS_ENABLE 17734 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_STATUS_DISABLE 17735 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_WRITERGROUPID 17736 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_PUBLISHINGINTERVAL 17737 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_KEEPALIVETIME 17738 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_PRIORITY 17739 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_LOCALEIDS 17740 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_TRANSPORTSETTINGS 17741 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_MESSAGESETTINGS 17742 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER 17743 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETWRITERID 17744 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DATASETFIELDCONTENTMASK 17745 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_KEYFRAMECOUNT 17746 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_TRANSPORTSETTINGS 17747 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_MESSAGESETTINGS 17748 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS 17749 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_STATE 17750 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_ENABLE 17751 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_STATUS_DISABLE 17752 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS 17753 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 17754 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 17755 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 17756 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 17757 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 17758 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 17759 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 17760 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 17761 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 17762 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 17763 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 17764 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_RESET 17765 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 17766 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 17767 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 17768 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 17769 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 17770 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 17771 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 17772 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 17773 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 17774 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 17775 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 17776 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 17777 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 17778 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 17779 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 17780 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 17781 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 17782 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 17783 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 17784 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 17785 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 17786 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 17787 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 17788 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 17789 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 17790 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 17791 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 17792 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 17793 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 17794 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 17795 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 17796 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 17797 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 17798 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES 17799 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 17800 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 17801 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 17802 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 17803 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER 17804 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 17805 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE 17806 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 17807 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION 17808 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 17809 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION 17810 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 17811 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS 17812 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_DIAGNOSTICSLEVEL 17813 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION 17814 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 17815 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 17816 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 17817 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 17818 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALERROR 17819 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALERROR_ACTIVE 17820 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 17821 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 17822 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 17823 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_RESET 17824 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_SUBERROR 17825 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS 17826 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR 17827 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 17828 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 17829 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 17830 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 17831 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 17832 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 17833 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 17834 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 17835 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 17836 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 17837 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 17838 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 17839 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 17840 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 17841 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 17842 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 17843 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 17844 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 17845 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 17846 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 17847 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 17848 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 17849 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 17850 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 17851 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICECONFIGURATIONTYPE 17852 /* ObjectType */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 17853 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 17854 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 17855 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 17856 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 17857 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES 17858 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES 17859 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICECONFIGURATIONTYPE_SERVICECERTIFICATE 17860 /* Variable */ +#define UA_NS0ID_DECIMALDATATYPE 17861 /* DataType */ +#define UA_NS0ID_DECIMALDATATYPE_ENCODING_DEFAULTXML 17862 /* Object */ +#define UA_NS0ID_DECIMALDATATYPE_ENCODING_DEFAULTBINARY 17863 /* Object */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_ACTIVE 17864 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_AUDIBLESOUND_LISTID 17865 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_AUDIBLESOUND_AGENCYID 17866 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_AUDIBLESOUND_VERSIONID 17867 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_UNSUPPRESS 17868 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_REMOVEFROMSERVICE 17869 /* Method */ +#define UA_NS0ID_ALARMCONDITIONTYPE_PLACEINSERVICE 17870 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_CLASSIFICATION 17871 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_DIAGNOSTICSLEVEL 17872 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_TIMEFIRSTCHANGE 17873 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS 17874 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_UNSUPPRESS 17875 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_REMOVEFROMSERVICE 17876 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_PLACEINSERVICE 17877 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_ACTIVE 17878 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_AUDIBLESOUND_LISTID 17879 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_AUDIBLESOUND_AGENCYID 17880 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_AUDIBLESOUND_VERSIONID 17881 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_UNSUPPRESS 17882 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_REMOVEFROMSERVICE 17883 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_PLACEINSERVICE 17884 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_CLASSIFICATION 17885 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_AUDIBLESOUND_LISTID 17886 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_AUDIBLESOUND_AGENCYID 17887 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_AUDIBLESOUND_VERSIONID 17888 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_UNSUPPRESS 17889 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_REMOVEFROMSERVICE 17890 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_PLACEINSERVICE 17891 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_DIAGNOSTICSLEVEL 17892 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_AUDIBLESOUND_LISTID 17893 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_AUDIBLESOUND_AGENCYID 17894 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_AUDIBLESOUND_VERSIONID 17895 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_UNSUPPRESS 17896 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_REMOVEFROMSERVICE 17897 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_PLACEINSERVICE 17898 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_TIMEFIRSTCHANGE 17899 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS 17900 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_ACTIVE 17901 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_CLASSIFICATION 17902 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_DIAGNOSTICSLEVEL 17903 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_REMOVEFROMSERVICE 17904 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_PLACEINSERVICE 17905 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_TIMEFIRSTCHANGE 17906 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_AUDIBLESOUND_LISTID 17907 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_AUDIBLESOUND_AGENCYID 17908 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_AUDIBLESOUND_VERSIONID 17909 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_UNSUPPRESS 17910 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_REMOVEFROMSERVICE 17911 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_PLACEINSERVICE 17912 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS 17913 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND_LISTID 17914 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND_AGENCYID 17915 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND_VERSIONID 17916 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_UNSUPPRESS 17917 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_REMOVEFROMSERVICE 17918 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_PLACEINSERVICE 17919 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS_DIAGNOSTICSLEVEL 17920 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND_LISTID 17921 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND_AGENCYID 17922 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND_VERSIONID 17923 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_UNSUPPRESS 17924 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_REMOVEFROMSERVICE 17925 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_PLACEINSERVICE 17926 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS 17927 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND_LISTID 17928 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND_AGENCYID 17929 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_AUDIBLESOUND_VERSIONID 17930 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_UNSUPPRESS 17931 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_REMOVEFROMSERVICE 17932 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_PLACEINSERVICE 17933 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS_DIAGNOSTICSLEVEL 17934 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND_LISTID 17935 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND_AGENCYID 17936 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_AUDIBLESOUND_VERSIONID 17937 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_UNSUPPRESS 17938 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_REMOVEFROMSERVICE 17939 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_PLACEINSERVICE 17940 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID 17941 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_AUDIBLESOUND_LISTID 17942 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_AUDIBLESOUND_AGENCYID 17943 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_AUDIBLESOUND_VERSIONID 17944 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_UNSUPPRESS 17945 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_REMOVEFROMSERVICE 17946 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_PLACEINSERVICE 17947 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID_DIAGNOSTICSLEVEL 17948 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_AUDIBLESOUND_LISTID 17949 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_AUDIBLESOUND_AGENCYID 17950 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_AUDIBLESOUND_VERSIONID 17951 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_UNSUPPRESS 17952 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_REMOVEFROMSERVICE 17953 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_PLACEINSERVICE 17954 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID 17955 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_AUDIBLESOUND_LISTID 17956 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_AUDIBLESOUND_AGENCYID 17957 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_AUDIBLESOUND_VERSIONID 17958 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_UNSUPPRESS 17959 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_REMOVEFROMSERVICE 17960 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_PLACEINSERVICE 17961 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID_DIAGNOSTICSLEVEL 17962 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_AUDIBLESOUND_LISTID 17963 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_AUDIBLESOUND_AGENCYID 17964 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_AUDIBLESOUND_VERSIONID 17965 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_UNSUPPRESS 17966 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_REMOVEFROMSERVICE 17967 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_PLACEINSERVICE 17968 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_ADDDATASETWRITER 17969 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_AUDIBLESOUND_LISTID 17970 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_AUDIBLESOUND_AGENCYID 17971 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_AUDIBLESOUND_VERSIONID 17972 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_UNSUPPRESS 17973 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_REMOVEFROMSERVICE 17974 /* Method */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_PLACEINSERVICE 17975 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_ADDDATASETWRITER_INPUTARGUMENTS 17976 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_AUDIBLESOUND_LISTID 17977 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_AUDIBLESOUND_AGENCYID 17978 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_AUDIBLESOUND_VERSIONID 17979 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_UNSUPPRESS 17980 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_REMOVEFROMSERVICE 17981 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_PLACEINSERVICE 17982 /* Method */ +#define UA_NS0ID_HASEFFECTENABLE 17983 /* ReferenceType */ +#define UA_NS0ID_HASEFFECTSUPPRESSED 17984 /* ReferenceType */ +#define UA_NS0ID_HASEFFECTUNSUPPRESSED 17985 /* ReferenceType */ +#define UA_NS0ID_AUDIOVARIABLETYPE 17986 /* VariableType */ +#define UA_NS0ID_WRITERGROUPTYPE_ADDDATASETWRITER_OUTPUTARGUMENTS 17987 /* Variable */ +#define UA_NS0ID_AUDIOVARIABLETYPE_LISTID 17988 /* Variable */ +#define UA_NS0ID_AUDIOVARIABLETYPE_AGENCYID 17989 /* Variable */ +#define UA_NS0ID_AUDIOVARIABLETYPE_VERSIONID 17990 /* Variable */ +#define UA_NS0ID_ALARMMETRICSTYPE_STARTTIME 17991 /* Variable */ +#define UA_NS0ID_WRITERGROUPTYPE_REMOVEDATASETWRITER 17992 /* Method */ +#define UA_NS0ID_WRITERGROUPTYPE_REMOVEDATASETWRITER_INPUTARGUMENTS 17993 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPEADDWRITERRMETHODTYPE 17994 /* Method */ +#define UA_NS0ID_PUBSUBGROUPTYPEADDWRITERRMETHODTYPE_INPUTARGUMENTS 17995 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPEADDWRITERRMETHODTYPE_OUTPUTARGUMENTS 17996 /* Variable */ +#define UA_NS0ID_WRITERGROUPTRANSPORTTYPE 17997 /* ObjectType */ +#define UA_NS0ID_WRITERGROUPMESSAGETYPE 17998 /* ObjectType */ +#define UA_NS0ID_READERGROUPTYPE 17999 /* ObjectType */ +#define UA_NS0ID_READERGROUPTYPE_SECURITYMODE 18000 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE 18001 /* ObjectType */ +#define UA_NS0ID_READERGROUPTYPE_SECURITYGROUPID 18002 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_SECURITYKEYSERVICES 18003 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_ENDPOINTURLS 18004 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_SERVICESTATUS 18005 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_UPDATECREDENTIAL 18006 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_UPDATECREDENTIAL_INPUTARGUMENTS 18007 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_DELETECREDENTIAL 18008 /* Method */ +#define UA_NS0ID_KEYCREDENTIALUPDATEMETHODTYPE 18009 /* Method */ +#define UA_NS0ID_KEYCREDENTIALUPDATEMETHODTYPE_INPUTARGUMENTS 18010 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE 18011 /* ObjectType */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_EVENTID 18012 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_EVENTTYPE 18013 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_SOURCENODE 18014 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_SOURCENAME 18015 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_TIME 18016 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_RECEIVETIME 18017 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_LOCALTIME 18018 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_MESSAGE 18019 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_SEVERITY 18020 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_ACTIONTIMESTAMP 18021 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_STATUS 18022 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_SERVERID 18023 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_CLIENTAUDITENTRYID 18024 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_CLIENTUSERID 18025 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_METHODID 18026 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_INPUTARGUMENTS 18027 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALAUDITEVENTTYPE_RESOURCEURI 18028 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE 18029 /* ObjectType */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_EVENTID 18030 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_EVENTTYPE 18031 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_SOURCENODE 18032 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_SOURCENAME 18033 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_TIME 18034 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_RECEIVETIME 18035 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_LOCALTIME 18036 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_MESSAGE 18037 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_SEVERITY 18038 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_ACTIONTIMESTAMP 18039 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_STATUS 18040 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_SERVERID 18041 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_CLIENTAUDITENTRYID 18042 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_CLIENTUSERID 18043 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_METHODID 18044 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_INPUTARGUMENTS 18045 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALUPDATEDAUDITEVENTTYPE_RESOURCEURI 18046 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE 18047 /* ObjectType */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_EVENTID 18048 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_EVENTTYPE 18049 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_SOURCENODE 18050 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_SOURCENAME 18051 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_TIME 18052 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_RECEIVETIME 18053 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_LOCALTIME 18054 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_MESSAGE 18055 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_SEVERITY 18056 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_ACTIONTIMESTAMP 18057 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_STATUS 18058 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_SERVERID 18059 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_CLIENTAUDITENTRYID 18060 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_CLIENTUSERID 18061 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_METHODID 18062 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_INPUTARGUMENTS 18063 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALDELETEDAUDITEVENTTYPE_RESOURCEURI 18064 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_MAXNETWORKMESSAGESIZE 18065 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_STATUS 18067 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_STATUS_STATE 18068 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_RESOURCEURI 18069 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICECONFIGURATIONTYPE_SERVICEURI 18072 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICECONFIGURATIONTYPE_ISSUERENDPOINTURL 18073 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_STATUS_ENABLE 18074 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_STATUS_DISABLE 18075 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER 18076 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_PUBLISHERID 18077 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_WRITERGROUPID 18078 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DATASETWRITERID 18079 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DATASETMETADATA 18080 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DATASETFIELDCONTENTMASK 18081 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_MESSAGERECEIVETIMEOUT 18082 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_SECURITYMODE 18083 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_SECURITYGROUPID 18084 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_SECURITYKEYSERVICES 18085 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_TRANSPORTSETTINGS 18086 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_MESSAGESETTINGS 18087 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_STATUS 18088 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_STATUS_STATE 18089 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_STATUS_ENABLE 18090 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_STATUS_DISABLE 18091 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS 18092 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 18093 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 18094 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 18095 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 18096 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 18097 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 18098 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 18099 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 18100 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 18101 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 18102 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 18103 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_RESET 18104 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 18105 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 18106 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 18107 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 18108 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 18109 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 18110 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 18111 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 18112 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 18113 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 18114 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 18115 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 18116 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 18117 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 18118 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 18119 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 18120 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 18121 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 18122 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 18123 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 18124 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 18125 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 18126 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 18127 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 18128 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 18129 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 18130 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 18131 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 18132 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 18133 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 18134 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 18135 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 18136 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 18137 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES 18138 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 18139 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 18140 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 18141 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 18142 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS 18143 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_ACTIVE 18144 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_CLASSIFICATION 18145 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_DIAGNOSTICSLEVEL 18146 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_TIMEFIRSTCHANGE 18147 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER 18148 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 18149 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE 18150 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 18151 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION 18152 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 18153 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION 18154 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION 18155 /* Object */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER 18156 /* Object */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_RESOURCEURI 18157 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 18158 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_ENDPOINTURLS 18159 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_SERVICESTATUS 18160 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_UPDATECREDENTIAL 18161 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_UPDATECREDENTIAL_INPUTARGUMENTS 18162 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_DELETECREDENTIAL 18163 /* Method */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATION_SERVICENAME_PLACEHOLDER_PROFILEURI 18164 /* Variable */ +#define UA_NS0ID_KEYCREDENTIALCONFIGURATIONTYPE_PROFILEURI 18165 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPEDEFINITION 18166 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPEDEFINITION_DATATYPEVERSION 18167 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATATYPEDEFINITION_DICTIONARYFRAGMENT 18168 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREFIELD 18169 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREFIELD_DATATYPEVERSION 18170 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREFIELD_DICTIONARYFRAGMENT 18171 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREDEFINITION 18172 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREDEFINITION_DATATYPEVERSION 18173 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_STRUCTUREDEFINITION_DICTIONARYFRAGMENT 18174 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMDEFINITION 18175 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMDEFINITION_DATATYPEVERSION 18176 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ENUMDEFINITION_DICTIONARYFRAGMENT 18177 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPEDEFINITION 18178 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPEDEFINITION_DATATYPEVERSION 18179 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATATYPEDEFINITION_DICTIONARYFRAGMENT 18180 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREFIELD 18181 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREFIELD_DATATYPEVERSION 18182 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREFIELD_DICTIONARYFRAGMENT 18183 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREDEFINITION 18184 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREDEFINITION_DATATYPEVERSION 18185 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_STRUCTUREDEFINITION_DICTIONARYFRAGMENT 18186 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMDEFINITION 18187 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMDEFINITION_DATATYPEVERSION 18188 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ENUMDEFINITION_DICTIONARYFRAGMENT 18189 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE 18190 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_ID 18191 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_NAME 18192 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_NUMBER 18193 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18194 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_TRANSITIONTIME 18195 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18196 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_TRUESTATE 18197 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_LATCHEDSTATE_FALSESTATE 18198 /* Variable */ +#define UA_NS0ID_ALARMCONDITIONTYPE_RESET 18199 /* Method */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_AUDIBLESOUND_LISTID 18200 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_AUDIBLESOUND_AGENCYID 18201 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_AUDIBLESOUND_VERSIONID 18202 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE 18203 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_ID 18204 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_NAME 18205 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_NUMBER 18206 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18207 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_TRANSITIONTIME 18208 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18209 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_TRUESTATE 18210 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_LATCHEDSTATE_FALSESTATE 18211 /* Variable */ +#define UA_NS0ID_ALARMGROUPTYPE_ALARMCONDITIONINSTANCE_PLACEHOLDER_RESET 18212 /* Method */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE 18213 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_ID 18214 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_NAME 18215 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_NUMBER 18216 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18217 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18218 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18219 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_TRUESTATE 18220 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_LATCHEDSTATE_FALSESTATE 18221 /* Variable */ +#define UA_NS0ID_LIMITALARMTYPE_RESET 18222 /* Method */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE 18223 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_ID 18224 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_NAME 18225 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_NUMBER 18226 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18227 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18228 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18229 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_TRUESTATE 18230 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_FALSESTATE 18231 /* Variable */ +#define UA_NS0ID_EXCLUSIVELIMITALARMTYPE_RESET 18232 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE 18233 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_ID 18234 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_NAME 18235 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_NUMBER 18236 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18237 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18238 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18239 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_TRUESTATE 18240 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_LATCHEDSTATE_FALSESTATE 18241 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELIMITALARMTYPE_RESET 18242 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_AUDIBLESOUND_LISTID 18243 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_AUDIBLESOUND_AGENCYID 18244 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_AUDIBLESOUND_VERSIONID 18245 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE 18246 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_ID 18247 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_NAME 18248 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_NUMBER 18249 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18250 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18251 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18252 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_TRUESTATE 18253 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_FALSESTATE 18254 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_UNSUPPRESS 18255 /* Method */ +#define UA_NS0ID_NONEXCLUSIVELEVELALARMTYPE_RESET 18256 /* Method */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE 18257 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_ID 18258 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_NAME 18259 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_NUMBER 18260 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18261 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18262 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18263 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_TRUESTATE 18264 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_LATCHEDSTATE_FALSESTATE 18265 /* Variable */ +#define UA_NS0ID_EXCLUSIVELEVELALARMTYPE_RESET 18266 /* Method */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE 18267 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_ID 18268 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_NAME 18269 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_NUMBER 18270 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18271 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18272 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18273 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_TRUESTATE 18274 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_FALSESTATE 18275 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVEDEVIATIONALARMTYPE_RESET 18276 /* Method */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE 18277 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_ID 18278 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_NAME 18279 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_NUMBER 18280 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18281 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18282 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18283 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_TRUESTATE 18284 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_FALSESTATE 18285 /* Variable */ +#define UA_NS0ID_NONEXCLUSIVERATEOFCHANGEALARMTYPE_RESET 18286 /* Method */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE 18287 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_ID 18288 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_NAME 18289 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_NUMBER 18290 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18291 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18292 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18293 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_TRUESTATE 18294 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_LATCHEDSTATE_FALSESTATE 18295 /* Variable */ +#define UA_NS0ID_EXCLUSIVEDEVIATIONALARMTYPE_RESET 18296 /* Method */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE 18297 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_ID 18298 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_NAME 18299 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_NUMBER 18300 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18301 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18302 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18303 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_TRUESTATE 18304 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_LATCHEDSTATE_FALSESTATE 18305 /* Variable */ +#define UA_NS0ID_EXCLUSIVERATEOFCHANGEALARMTYPE_RESET 18306 /* Method */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE 18307 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_ID 18308 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_NAME 18309 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_NUMBER 18310 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18311 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18312 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18313 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_TRUESTATE 18314 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_LATCHEDSTATE_FALSESTATE 18315 /* Variable */ +#define UA_NS0ID_DISCRETEALARMTYPE_RESET 18316 /* Method */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE 18317 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_ID 18318 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_NAME 18319 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_NUMBER 18320 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18321 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18322 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18323 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_TRUESTATE 18324 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_LATCHEDSTATE_FALSESTATE 18325 /* Variable */ +#define UA_NS0ID_OFFNORMALALARMTYPE_RESET 18326 /* Method */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE 18327 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_ID 18328 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_NAME 18329 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_NUMBER 18330 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18331 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18332 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18333 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_TRUESTATE 18334 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_LATCHEDSTATE_FALSESTATE 18335 /* Variable */ +#define UA_NS0ID_SYSTEMOFFNORMALALARMTYPE_RESET 18336 /* Method */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE 18337 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_ID 18338 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_NAME 18339 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_NUMBER 18340 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18341 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18342 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18343 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_TRUESTATE 18344 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_LATCHEDSTATE_FALSESTATE 18345 /* Variable */ +#define UA_NS0ID_TRIPALARMTYPE_RESET 18346 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE 18347 /* ObjectType */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_EVENTID 18348 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_EVENTTYPE 18349 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SOURCENODE 18350 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SOURCENAME 18351 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_TIME 18352 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_RECEIVETIME 18353 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LOCALTIME 18354 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_MESSAGE 18355 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SEVERITY 18356 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONCLASSID 18357 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONCLASSNAME 18358 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONSUBCLASSID 18359 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONSUBCLASSNAME 18360 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONNAME 18361 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_BRANCHID 18362 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_RETAIN 18363 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE 18364 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_ID 18365 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_NAME 18366 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_NUMBER 18367 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 18368 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 18369 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 18370 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_TRUESTATE 18371 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLEDSTATE_FALSESTATE 18372 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_QUALITY 18373 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_QUALITY_SOURCETIMESTAMP 18374 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LASTSEVERITY 18375 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 18376 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_COMMENT 18377 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_COMMENT_SOURCETIMESTAMP 18378 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CLIENTUSERID 18379 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_DISABLE 18380 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ENABLE 18381 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ADDCOMMENT 18382 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 18383 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONREFRESH 18384 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 18385 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONREFRESH2 18386 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 18387 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE 18388 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_ID 18389 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_NAME 18390 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_NUMBER 18391 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 18392 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_TRANSITIONTIME 18393 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 18394 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_TRUESTATE 18395 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKEDSTATE_FALSESTATE 18396 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE 18397 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_ID 18398 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_NAME 18399 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_NUMBER 18400 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 18401 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 18402 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 18403 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_TRUESTATE 18404 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_FALSESTATE 18405 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKNOWLEDGE 18406 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 18407 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRM 18408 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_CONFIRM_INPUTARGUMENTS 18409 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE 18410 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_ID 18411 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_NAME 18412 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_NUMBER 18413 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 18414 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_TRANSITIONTIME 18415 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 18416 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_TRUESTATE 18417 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ACTIVESTATE_FALSESTATE 18418 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_INPUTNODE 18419 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE 18420 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_ID 18421 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_NAME 18422 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_NUMBER 18423 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 18424 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 18425 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 18426 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 18427 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 18428 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE 18429 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_ID 18430 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_NAME 18431 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_NUMBER 18432 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 18433 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 18434 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 18435 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 18436 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 18437 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE 18438 /* Object */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE 18439 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 18440 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 18441 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 18442 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 18443 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION 18444 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 18445 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 18446 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 18447 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 18448 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 18449 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 18450 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 18451 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_UNSHELVETIME 18452 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 18453 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 18454 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_UNSHELVE 18455 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 18456 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESSEDORSHELVED 18457 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_MAXTIMESHELVED 18458 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_AUDIBLEENABLED 18459 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_AUDIBLESOUND 18460 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_AUDIBLESOUND_LISTID 18461 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_AUDIBLESOUND_AGENCYID 18462 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_AUDIBLESOUND_VERSIONID 18463 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE 18464 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_ID 18465 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_NAME 18466 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_NUMBER 18467 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 18468 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_TRANSITIONTIME 18469 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 18470 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_TRUESTATE 18471 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCESTATE_FALSESTATE 18472 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ONDELAY 18473 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_OFFDELAY 18474 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_FIRSTINGROUPFLAG 18475 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_FIRSTINGROUP 18476 /* Object */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE 18477 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_ID 18478 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_NAME 18479 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_NUMBER 18480 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18481 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18482 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18483 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_TRUESTATE 18484 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_LATCHEDSTATE_FALSESTATE 18485 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_ALARMGROUP_PLACEHOLDER 18486 /* Object */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_REALARMTIME 18487 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_REALARMREPEATCOUNT 18488 /* Variable */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SILENCE 18489 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_SUPPRESS 18490 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_UNSUPPRESS 18491 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_REMOVEFROMSERVICE 18492 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_PLACEINSERVICE 18493 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_RESET 18494 /* Method */ +#define UA_NS0ID_INSTRUMENTDIAGNOSTICALARMTYPE_NORMALSTATE 18495 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE 18496 /* ObjectType */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_EVENTID 18497 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_EVENTTYPE 18498 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SOURCENODE 18499 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SOURCENAME 18500 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_TIME 18501 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_RECEIVETIME 18502 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LOCALTIME 18503 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_MESSAGE 18504 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SEVERITY 18505 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONCLASSID 18506 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONCLASSNAME 18507 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONSUBCLASSID 18508 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONSUBCLASSNAME 18509 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONNAME 18510 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_BRANCHID 18511 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_RETAIN 18512 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE 18513 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_ID 18514 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_NAME 18515 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_NUMBER 18516 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 18517 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 18518 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 18519 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_TRUESTATE 18520 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLEDSTATE_FALSESTATE 18521 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_QUALITY 18522 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_QUALITY_SOURCETIMESTAMP 18523 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LASTSEVERITY 18524 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 18525 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_COMMENT 18526 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_COMMENT_SOURCETIMESTAMP 18527 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CLIENTUSERID 18528 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_DISABLE 18529 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ENABLE 18530 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ADDCOMMENT 18531 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 18532 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONREFRESH 18533 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 18534 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONREFRESH2 18535 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 18536 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE 18537 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_ID 18538 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_NAME 18539 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_NUMBER 18540 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 18541 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_TRANSITIONTIME 18542 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 18543 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_TRUESTATE 18544 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKEDSTATE_FALSESTATE 18545 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE 18546 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_ID 18547 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_NAME 18548 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_NUMBER 18549 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 18550 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 18551 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 18552 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_TRUESTATE 18553 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRMEDSTATE_FALSESTATE 18554 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKNOWLEDGE 18555 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 18556 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRM 18557 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_CONFIRM_INPUTARGUMENTS 18558 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE 18559 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_ID 18560 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_NAME 18561 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_NUMBER 18562 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 18563 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_TRANSITIONTIME 18564 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 18565 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_TRUESTATE 18566 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ACTIVESTATE_FALSESTATE 18567 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_INPUTNODE 18568 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE 18569 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_ID 18570 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_NAME 18571 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_NUMBER 18572 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 18573 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 18574 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 18575 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 18576 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 18577 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE 18578 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_ID 18579 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_NAME 18580 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_NUMBER 18581 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 18582 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 18583 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 18584 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 18585 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 18586 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE 18587 /* Object */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE 18588 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 18589 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 18590 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 18591 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 18592 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION 18593 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 18594 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 18595 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 18596 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 18597 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 18598 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 18599 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 18600 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_UNSHELVETIME 18601 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 18602 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 18603 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_UNSHELVE 18604 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 18605 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESSEDORSHELVED 18606 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_MAXTIMESHELVED 18607 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_AUDIBLEENABLED 18608 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_AUDIBLESOUND 18609 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_AUDIBLESOUND_LISTID 18610 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_AUDIBLESOUND_AGENCYID 18611 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_AUDIBLESOUND_VERSIONID 18612 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE 18613 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_ID 18614 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_NAME 18615 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_NUMBER 18616 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 18617 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_TRANSITIONTIME 18618 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 18619 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_TRUESTATE 18620 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCESTATE_FALSESTATE 18621 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ONDELAY 18622 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_OFFDELAY 18623 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_FIRSTINGROUPFLAG 18624 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_FIRSTINGROUP 18625 /* Object */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE 18626 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_ID 18627 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_NAME 18628 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_NUMBER 18629 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18630 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18631 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18632 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_TRUESTATE 18633 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_LATCHEDSTATE_FALSESTATE 18634 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_ALARMGROUP_PLACEHOLDER 18635 /* Object */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_REALARMTIME 18636 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_REALARMREPEATCOUNT 18637 /* Variable */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SILENCE 18638 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_SUPPRESS 18639 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_UNSUPPRESS 18640 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_REMOVEFROMSERVICE 18641 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_PLACEINSERVICE 18642 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_RESET 18643 /* Method */ +#define UA_NS0ID_SYSTEMDIAGNOSTICALARMTYPE_NORMALSTATE 18644 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE 18645 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_ID 18646 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_NAME 18647 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_NUMBER 18648 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18649 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18650 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18651 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_TRUESTATE 18652 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_LATCHEDSTATE_FALSESTATE 18653 /* Variable */ +#define UA_NS0ID_CERTIFICATEEXPIRATIONALARMTYPE_RESET 18654 /* Method */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE 18655 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_ID 18656 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_NAME 18657 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_NUMBER 18658 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 18659 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 18660 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 18661 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_TRUESTATE 18662 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_LATCHEDSTATE_FALSESTATE 18663 /* Variable */ +#define UA_NS0ID_DISCREPANCYALARMTYPE_RESET 18664 /* Method */ +#define UA_NS0ID_STATISTICALCONDITIONCLASSTYPE 18665 /* ObjectType */ +#define UA_NS0ID_ALARMMETRICSTYPE_RESET 18666 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS 18667 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 18668 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 18669 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 18670 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 18671 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 18672 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 18673 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 18674 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 18675 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 18676 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 18677 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 18678 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_RESET 18679 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 18680 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 18681 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 18682 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 18683 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 18684 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 18685 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 18686 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 18687 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 18688 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 18689 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 18690 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 18691 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 18692 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 18693 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 18694 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 18695 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 18696 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 18697 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 18698 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 18699 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 18700 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 18701 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 18702 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 18703 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 18704 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 18705 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 18706 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 18707 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 18708 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 18709 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 18710 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 18711 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 18712 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_RESOLVEDADDRESS 18713 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_CONNECTIONNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_RESOLVEDADDRESS_DIAGNOSTICSLEVEL 18714 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS 18715 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_DIAGNOSTICSLEVEL 18716 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALINFORMATION 18717 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 18718 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 18719 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 18720 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 18721 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALERROR 18722 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALERROR_ACTIVE 18723 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 18724 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 18725 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 18726 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_RESET 18727 /* Method */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_SUBERROR 18728 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS 18729 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEERROR 18730 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 18731 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 18732 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 18733 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 18734 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 18735 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 18736 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 18737 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 18738 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 18739 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 18740 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 18741 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 18742 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 18743 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 18744 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 18745 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 18746 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 18747 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 18748 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 18749 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 18750 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 18751 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 18752 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 18753 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 18754 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 18755 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 18756 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 18757 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 18758 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 18759 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES 18760 /* Object */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS 18761 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS_DIAGNOSTICSLEVEL 18762 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS 18763 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS_DIAGNOSTICSLEVEL 18764 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS 18765 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS_DIAGNOSTICSLEVEL 18766 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS 18767 /* Variable */ +#define UA_NS0ID_PUBLISHSUBSCRIBETYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS_DIAGNOSTICSLEVEL 18768 /* Variable */ +#define UA_NS0ID_THREEDVECTORTYPE_X 18769 /* Variable */ +#define UA_NS0ID_THREEDVECTORTYPE_Y 18770 /* Variable */ +#define UA_NS0ID_THREEDVECTORTYPE_Z 18771 /* Variable */ +#define UA_NS0ID_CARTESIANCOORDINATESTYPE 18772 /* VariableType */ +#define UA_NS0ID_CARTESIANCOORDINATESTYPE_LENGTHUNIT 18773 /* Variable */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATESTYPE 18774 /* VariableType */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATESTYPE_LENGTHUNIT 18775 /* Variable */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATESTYPE_X 18776 /* Variable */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATESTYPE_Y 18777 /* Variable */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATESTYPE_Z 18778 /* Variable */ +#define UA_NS0ID_ORIENTATIONTYPE 18779 /* VariableType */ +#define UA_NS0ID_ORIENTATIONTYPE_ANGLEUNIT 18780 /* Variable */ +#define UA_NS0ID_THREEDORIENTATIONTYPE 18781 /* VariableType */ +#define UA_NS0ID_THREEDORIENTATIONTYPE_ANGLEUNIT 18782 /* Variable */ +#define UA_NS0ID_THREEDORIENTATIONTYPE_A 18783 /* Variable */ +#define UA_NS0ID_THREEDORIENTATIONTYPE_B 18784 /* Variable */ +#define UA_NS0ID_THREEDORIENTATIONTYPE_C 18785 /* Variable */ +#define UA_NS0ID_FRAMETYPE 18786 /* VariableType */ +#define UA_NS0ID_FRAMETYPE_ORIENTATION 18787 /* Variable */ +#define UA_NS0ID_FRAMETYPE_CONSTANT 18788 /* Variable */ +#define UA_NS0ID_FRAMETYPE_BASEFRAME 18789 /* Variable */ +#define UA_NS0ID_FRAMETYPE_FIXEDBASE 18790 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE 18791 /* VariableType */ +#define UA_NS0ID_THREEDFRAMETYPE_ORIENTATION 18792 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_CONSTANT 18793 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_BASEFRAME 18794 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_FIXEDBASE 18795 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_CARTESIANCOORDINATES 18796 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_CARTESIANCOORDINATES_LENGTHUNIT 18797 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_CARTESIANCOORDINATES_X 18798 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_CARTESIANCOORDINATES_Y 18799 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_CARTESIANCOORDINATES_Z 18800 /* Variable */ +#define UA_NS0ID_FRAMETYPE_CARTESIANCOORDINATES 18801 /* Variable */ +#define UA_NS0ID_FRAMETYPE_CARTESIANCOORDINATES_LENGTHUNIT 18802 /* Variable */ +#define UA_NS0ID_FRAMETYPE_ORIENTATION_ANGLEUNIT 18803 /* Variable */ +#define UA_NS0ID_HASWRITERGROUP 18804 /* ReferenceType */ +#define UA_NS0ID_HASREADERGROUP 18805 /* ReferenceType */ +#define UA_NS0ID_RATIONALNUMBER 18806 /* DataType */ +#define UA_NS0ID_VECTOR 18807 /* DataType */ +#define UA_NS0ID_THREEDVECTOR 18808 /* DataType */ +#define UA_NS0ID_CARTESIANCOORDINATES 18809 /* DataType */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATES 18810 /* DataType */ +#define UA_NS0ID_ORIENTATION 18811 /* DataType */ +#define UA_NS0ID_THREEDORIENTATION 18812 /* DataType */ +#define UA_NS0ID_FRAME 18813 /* DataType */ +#define UA_NS0ID_THREEDFRAME 18814 /* DataType */ +#define UA_NS0ID_RATIONALNUMBER_ENCODING_DEFAULTBINARY 18815 /* Object */ +#define UA_NS0ID_VECTOR_ENCODING_DEFAULTBINARY 18816 /* Object */ +#define UA_NS0ID_THREEDVECTOR_ENCODING_DEFAULTBINARY 18817 /* Object */ +#define UA_NS0ID_CARTESIANCOORDINATES_ENCODING_DEFAULTBINARY 18818 /* Object */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATES_ENCODING_DEFAULTBINARY 18819 /* Object */ +#define UA_NS0ID_ORIENTATION_ENCODING_DEFAULTBINARY 18820 /* Object */ +#define UA_NS0ID_THREEDORIENTATION_ENCODING_DEFAULTBINARY 18821 /* Object */ +#define UA_NS0ID_FRAME_ENCODING_DEFAULTBINARY 18822 /* Object */ +#define UA_NS0ID_THREEDFRAME_ENCODING_DEFAULTBINARY 18823 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RATIONALNUMBER 18824 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RATIONALNUMBER_DATATYPEVERSION 18825 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_RATIONALNUMBER_DICTIONARYFRAGMENT 18826 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_VECTOR 18827 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_VECTOR_DATATYPEVERSION 18828 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_VECTOR_DICTIONARYFRAGMENT 18829 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDVECTOR 18830 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDVECTOR_DATATYPEVERSION 18831 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDVECTOR_DICTIONARYFRAGMENT 18832 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CARTESIANCOORDINATES 18833 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CARTESIANCOORDINATES_DATATYPEVERSION 18834 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CARTESIANCOORDINATES_DICTIONARYFRAGMENT 18835 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDCARTESIANCOORDINATES 18836 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDCARTESIANCOORDINATES_DATATYPEVERSION 18837 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDCARTESIANCOORDINATES_DICTIONARYFRAGMENT 18838 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ORIENTATION 18839 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ORIENTATION_DATATYPEVERSION 18840 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ORIENTATION_DICTIONARYFRAGMENT 18841 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDORIENTATION 18842 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDORIENTATION_DATATYPEVERSION 18843 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDORIENTATION_DICTIONARYFRAGMENT 18844 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FRAME 18845 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FRAME_DATATYPEVERSION 18846 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FRAME_DICTIONARYFRAGMENT 18847 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDFRAME 18848 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDFRAME_DATATYPEVERSION 18849 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_THREEDFRAME_DICTIONARYFRAGMENT 18850 /* Variable */ +#define UA_NS0ID_RATIONALNUMBER_ENCODING_DEFAULTXML 18851 /* Object */ +#define UA_NS0ID_VECTOR_ENCODING_DEFAULTXML 18852 /* Object */ +#define UA_NS0ID_THREEDVECTOR_ENCODING_DEFAULTXML 18853 /* Object */ +#define UA_NS0ID_CARTESIANCOORDINATES_ENCODING_DEFAULTXML 18854 /* Object */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATES_ENCODING_DEFAULTXML 18855 /* Object */ +#define UA_NS0ID_ORIENTATION_ENCODING_DEFAULTXML 18856 /* Object */ +#define UA_NS0ID_THREEDORIENTATION_ENCODING_DEFAULTXML 18857 /* Object */ +#define UA_NS0ID_FRAME_ENCODING_DEFAULTXML 18858 /* Object */ +#define UA_NS0ID_THREEDFRAME_ENCODING_DEFAULTXML 18859 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RATIONALNUMBER 18860 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RATIONALNUMBER_DATATYPEVERSION 18861 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_RATIONALNUMBER_DICTIONARYFRAGMENT 18862 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_VECTOR 18863 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_VECTOR_DATATYPEVERSION 18864 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_VECTOR_DICTIONARYFRAGMENT 18865 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDVECTOR 18866 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDVECTOR_DATATYPEVERSION 18867 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDVECTOR_DICTIONARYFRAGMENT 18868 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CARTESIANCOORDINATES 18869 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CARTESIANCOORDINATES_DATATYPEVERSION 18870 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS 18871 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 18872 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 18873 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 18874 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 18875 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 18876 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 18877 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 18878 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 18879 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 18880 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 18881 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 18882 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_RESET 18883 /* Method */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 18884 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 18885 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 18886 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 18887 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 18888 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 18889 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 18890 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 18891 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 18892 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 18893 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 18894 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 18895 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 18896 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 18897 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 18898 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 18899 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 18900 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 18901 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 18902 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 18903 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 18904 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 18905 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 18906 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 18907 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 18908 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 18909 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 18910 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 18911 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 18912 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 18913 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 18914 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 18915 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 18916 /* Object */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES 18917 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 18918 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 18919 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 18920 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 18921 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER 18922 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 18923 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE 18924 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 18925 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION 18926 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 18927 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION 18928 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATASETTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 18929 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS 18930 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 18931 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 18932 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 18933 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 18934 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 18935 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 18936 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 18937 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 18938 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 18939 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 18940 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 18941 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_RESET 18942 /* Method */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 18943 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 18944 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 18945 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 18946 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 18947 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 18948 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 18949 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 18950 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 18951 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 18952 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 18953 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 18954 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 18955 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 18956 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 18957 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 18958 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 18959 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 18960 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 18961 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 18962 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 18963 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 18964 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 18965 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 18966 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 18967 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 18968 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 18969 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 18970 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 18971 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 18972 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 18973 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 18974 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 18975 /* Object */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES 18976 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 18977 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 18978 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 18979 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 18980 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER 18981 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 18982 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE 18983 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 18984 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION 18985 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 18986 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION 18987 /* Variable */ +#define UA_NS0ID_PUBLISHEDDATAITEMSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 18988 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS 18989 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 18990 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 18991 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 18992 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 18993 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 18994 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 18995 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 18996 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 18997 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 18998 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 18999 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 19000 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_RESET 19001 /* Method */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 19002 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 19003 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 19004 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 19005 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 19006 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19007 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19008 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 19009 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19010 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19011 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19012 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19013 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 19014 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19015 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19016 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19017 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19018 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 19019 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19020 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19021 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19022 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19023 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 19024 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19025 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19026 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19027 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19028 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 19029 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19030 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19031 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19032 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19033 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 19034 /* Object */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES 19035 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 19036 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 19037 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 19038 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 19039 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER 19040 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 19041 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE 19042 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 19043 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION 19044 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 19045 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION 19046 /* Variable */ +#define UA_NS0ID_PUBLISHEDEVENTSTYPE_DATASETWRITERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 19047 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CARTESIANCOORDINATES_DICTIONARYFRAGMENT 19048 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDCARTESIANCOORDINATES 19049 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDCARTESIANCOORDINATES_DATATYPEVERSION 19050 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDCARTESIANCOORDINATES_DICTIONARYFRAGMENT 19051 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ORIENTATION 19052 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ORIENTATION_DATATYPEVERSION 19053 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ORIENTATION_DICTIONARYFRAGMENT 19054 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDORIENTATION 19055 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDORIENTATION_DATATYPEVERSION 19056 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDORIENTATION_DICTIONARYFRAGMENT 19057 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FRAME 19058 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FRAME_DATATYPEVERSION 19059 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_FRAME_DICTIONARYFRAGMENT 19060 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDFRAME 19061 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDFRAME_DATATYPEVERSION 19062 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_THREEDFRAME_DICTIONARYFRAGMENT 19063 /* Variable */ +#define UA_NS0ID_RATIONALNUMBER_ENCODING_DEFAULTJSON 19064 /* Object */ +#define UA_NS0ID_VECTOR_ENCODING_DEFAULTJSON 19065 /* Object */ +#define UA_NS0ID_THREEDVECTOR_ENCODING_DEFAULTJSON 19066 /* Object */ +#define UA_NS0ID_CARTESIANCOORDINATES_ENCODING_DEFAULTJSON 19067 /* Object */ +#define UA_NS0ID_THREEDCARTESIANCOORDINATES_ENCODING_DEFAULTJSON 19068 /* Object */ +#define UA_NS0ID_ORIENTATION_ENCODING_DEFAULTJSON 19069 /* Object */ +#define UA_NS0ID_THREEDORIENTATION_ENCODING_DEFAULTJSON 19070 /* Object */ +#define UA_NS0ID_FRAME_ENCODING_DEFAULTJSON 19071 /* Object */ +#define UA_NS0ID_THREEDFRAME_ENCODING_DEFAULTJSON 19072 /* Object */ +#define UA_NS0ID_THREEDFRAMETYPE_ORIENTATION_ANGLEUNIT 19073 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_ORIENTATION_A 19074 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_ORIENTATION_B 19075 /* Variable */ +#define UA_NS0ID_THREEDFRAMETYPE_ORIENTATION_C 19076 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETEBASETYPE 19077 /* VariableType */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETEBASETYPE_DEFINITION 19078 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETEBASETYPE_VALUEPRECISION 19079 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETEBASETYPE_ENUMVALUES 19080 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETEBASETYPE_VALUEASTEXT 19081 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETEBASETYPE_ENUMDICTIONARYENTRIES 19082 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETEBASETYPE_VALUEASDICTIONARYENTRIES 19083 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETETYPE 19084 /* VariableType */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETETYPE_DEFINITION 19085 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETETYPE_VALUEPRECISION 19086 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETETYPE_ENUMVALUES 19087 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETETYPE_VALUEASTEXT 19088 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETETYPE_ENUMDICTIONARYENTRIES 19089 /* Variable */ +#define UA_NS0ID_MULTISTATEDICTIONARYENTRYDISCRETETYPE_VALUEASDICTIONARYENTRIES 19090 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIES_SERVERTIMESTAMPSUPPORTED 19091 /* Variable */ +#define UA_NS0ID_HISTORICALDATACONFIGURATIONTYPE_SERVERTIMESTAMPSUPPORTED 19092 /* Variable */ +#define UA_NS0ID_HACONFIGURATION_SERVERTIMESTAMPSUPPORTED 19093 /* Variable */ +#define UA_NS0ID_HISTORYSERVERCAPABILITIESTYPE_SERVERTIMESTAMPSUPPORTED 19094 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE 19095 /* ObjectType */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_EVENTID 19096 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_EVENTTYPE 19097 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_SOURCENODE 19098 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_SOURCENAME 19099 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_TIME 19100 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_RECEIVETIME 19101 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_LOCALTIME 19102 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_MESSAGE 19103 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_SEVERITY 19104 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_ACTIONTIMESTAMP 19105 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_STATUS 19106 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS 19107 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 19108 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 19109 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 19110 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 19111 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 19112 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 19113 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 19114 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 19115 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 19116 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 19117 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 19118 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_RESET 19119 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 19120 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 19121 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 19122 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 19123 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 19124 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19125 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19126 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 19127 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19128 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19129 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19130 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19131 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 19132 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19133 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19134 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19135 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19136 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 19137 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19138 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19139 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19140 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19141 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 19142 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19143 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19144 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19145 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19146 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 19147 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19148 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19149 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19150 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19151 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 19152 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES 19153 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_ACTIVE 19154 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_CLASSIFICATION 19155 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_DIAGNOSTICSLEVEL 19156 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_SENTNETWORKMESSAGES_TIMEFIRSTCHANGE 19157 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS 19158 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_ACTIVE 19159 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_CLASSIFICATION 19160 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_DIAGNOSTICSLEVEL 19161 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_FAILEDTRANSMISSIONS_TIMEFIRSTCHANGE 19162 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS 19163 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_ACTIVE 19164 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_CLASSIFICATION 19165 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_DIAGNOSTICSLEVEL 19166 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_ENCRYPTIONERRORS_TIMEFIRSTCHANGE 19167 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS 19168 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETWRITERS_DIAGNOSTICSLEVEL 19169 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS 19170 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETWRITERS_DIAGNOSTICSLEVEL 19171 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID 19172 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID_DIAGNOSTICSLEVEL 19173 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID 19174 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_WRITERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID_DIAGNOSTICSLEVEL 19175 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS 19176 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_DIAGNOSTICSLEVEL 19177 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION 19178 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 19179 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 19180 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 19181 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 19182 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR 19183 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_ACTIVE 19184 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 19185 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 19186 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 19187 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_RESET 19188 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_SUBERROR 19189 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS 19190 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR 19191 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 19192 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 19193 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19194 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19195 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 19196 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19197 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19198 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19199 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19200 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 19201 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19202 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19203 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19204 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19205 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 19206 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19207 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19208 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19209 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19210 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 19211 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19212 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19213 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19214 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19215 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 19216 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19217 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19218 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19219 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19220 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES 19221 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES 19222 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_ACTIVE 19223 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_CLASSIFICATION 19224 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_DIAGNOSTICSLEVEL 19225 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_TIMEFIRSTCHANGE 19226 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES 19227 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_ACTIVE 19228 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_CLASSIFICATION 19229 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_DIAGNOSTICSLEVEL 19230 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_TIMEFIRSTCHANGE 19231 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS 19232 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_ACTIVE 19233 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_CLASSIFICATION 19234 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_DIAGNOSTICSLEVEL 19235 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_TIMEFIRSTCHANGE 19236 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS 19237 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS_DIAGNOSTICSLEVEL 19238 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS 19239 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_READERGROUPNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS_DIAGNOSTICSLEVEL 19240 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS 19241 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_DIAGNOSTICSLEVEL 19242 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALINFORMATION 19243 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 19244 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 19245 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 19246 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 19247 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALERROR 19248 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALERROR_ACTIVE 19249 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 19250 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 19251 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 19252 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_RESET 19253 /* Method */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_SUBERROR 19254 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS 19255 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEERROR 19256 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 19257 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 19258 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19259 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19260 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 19261 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19262 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19263 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19264 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19265 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 19266 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19267 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19268 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19269 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19270 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 19271 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19272 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19273 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19274 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19275 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 19276 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19277 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19278 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19279 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19280 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 19281 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19282 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19283 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19284 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19285 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_LIVEVALUES 19286 /* Object */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_LIVEVALUES_RESOLVEDADDRESS 19287 /* Variable */ +#define UA_NS0ID_PUBSUBCONNECTIONTYPE_DIAGNOSTICS_LIVEVALUES_RESOLVEDADDRESS_DIAGNOSTICSLEVEL 19288 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_SERVERID 19289 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_CLIENTAUDITENTRYID 19290 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_CLIENTUSERID 19291 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_PARAMETERDATATYPEID 19292 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_PERFORMINSERTREPLACE 19293 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_NEWVALUES 19294 /* Variable */ +#define UA_NS0ID_AUDITHISTORYANNOTATIONUPDATEEVENTTYPE_OLDVALUES 19295 /* Variable */ +#define UA_NS0ID_TRUSTLISTTYPE_UPDATEFREQUENCY 19296 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE 19297 /* ObjectType */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_EVENTID 19298 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_EVENTTYPE 19299 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SOURCENODE 19300 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SOURCENAME 19301 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_TIME 19302 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_RECEIVETIME 19303 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LOCALTIME 19304 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_MESSAGE 19305 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SEVERITY 19306 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONCLASSID 19307 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONCLASSNAME 19308 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONSUBCLASSID 19309 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONSUBCLASSNAME 19310 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONNAME 19311 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_BRANCHID 19312 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_RETAIN 19313 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE 19314 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_ID 19315 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_NAME 19316 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_NUMBER 19317 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_EFFECTIVEDISPLAYNAME 19318 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_TRANSITIONTIME 19319 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_EFFECTIVETRANSITIONTIME 19320 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_TRUESTATE 19321 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLEDSTATE_FALSESTATE 19322 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_QUALITY 19323 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_QUALITY_SOURCETIMESTAMP 19324 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LASTSEVERITY 19325 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LASTSEVERITY_SOURCETIMESTAMP 19326 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_COMMENT 19327 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_COMMENT_SOURCETIMESTAMP 19328 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CLIENTUSERID 19329 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_DISABLE 19330 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ENABLE 19331 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ADDCOMMENT 19332 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ADDCOMMENT_INPUTARGUMENTS 19333 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONREFRESH 19334 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONREFRESH_INPUTARGUMENTS 19335 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONREFRESH2 19336 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONDITIONREFRESH2_INPUTARGUMENTS 19337 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE 19338 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_ID 19339 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_NAME 19340 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_NUMBER 19341 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_EFFECTIVEDISPLAYNAME 19342 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_TRANSITIONTIME 19343 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_EFFECTIVETRANSITIONTIME 19344 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_TRUESTATE 19345 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKEDSTATE_FALSESTATE 19346 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE 19347 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_ID 19348 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_NAME 19349 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_NUMBER 19350 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_EFFECTIVEDISPLAYNAME 19351 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_TRANSITIONTIME 19352 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_EFFECTIVETRANSITIONTIME 19353 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_TRUESTATE 19354 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRMEDSTATE_FALSESTATE 19355 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKNOWLEDGE 19356 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACKNOWLEDGE_INPUTARGUMENTS 19357 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRM 19358 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_CONFIRM_INPUTARGUMENTS 19359 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE 19360 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_ID 19361 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_NAME 19362 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_NUMBER 19363 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_EFFECTIVEDISPLAYNAME 19364 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_TRANSITIONTIME 19365 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_EFFECTIVETRANSITIONTIME 19366 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_TRUESTATE 19367 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ACTIVESTATE_FALSESTATE 19368 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_INPUTNODE 19369 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE 19370 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_ID 19371 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_NAME 19372 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_NUMBER 19373 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVEDISPLAYNAME 19374 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_TRANSITIONTIME 19375 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_EFFECTIVETRANSITIONTIME 19376 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_TRUESTATE 19377 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDSTATE_FALSESTATE 19378 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE 19379 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_ID 19380 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_NAME 19381 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_NUMBER 19382 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVEDISPLAYNAME 19383 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_TRANSITIONTIME 19384 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_EFFECTIVETRANSITIONTIME 19385 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_TRUESTATE 19386 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OUTOFSERVICESTATE_FALSESTATE 19387 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE 19388 /* Object */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_CURRENTSTATE 19389 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_ID 19390 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NAME 19391 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_NUMBER 19392 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_CURRENTSTATE_EFFECTIVEDISPLAYNAME 19393 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_LASTTRANSITION 19394 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_ID 19395 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NAME 19396 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_NUMBER 19397 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_TRANSITIONTIME 19398 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_LASTTRANSITION_EFFECTIVETRANSITIONTIME 19399 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_AVAILABLESTATES 19400 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_AVAILABLETRANSITIONS 19401 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_UNSHELVETIME 19402 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE 19403 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_TIMEDSHELVE_INPUTARGUMENTS 19404 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_UNSHELVE 19405 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SHELVINGSTATE_ONESHOTSHELVE 19406 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESSEDORSHELVED 19407 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_MAXTIMESHELVED 19408 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_AUDIBLEENABLED 19409 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_AUDIBLESOUND 19410 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_AUDIBLESOUND_LISTID 19411 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_AUDIBLESOUND_AGENCYID 19412 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_AUDIBLESOUND_VERSIONID 19413 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE 19414 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_ID 19415 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_NAME 19416 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_NUMBER 19417 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_EFFECTIVEDISPLAYNAME 19418 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_TRANSITIONTIME 19419 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_EFFECTIVETRANSITIONTIME 19420 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_TRUESTATE 19421 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCESTATE_FALSESTATE 19422 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ONDELAY 19423 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_OFFDELAY 19424 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_FIRSTINGROUPFLAG 19425 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_FIRSTINGROUP 19426 /* Object */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE 19427 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_ID 19428 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_NAME 19429 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_NUMBER 19430 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_EFFECTIVEDISPLAYNAME 19431 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_TRANSITIONTIME 19432 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_EFFECTIVETRANSITIONTIME 19433 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_TRUESTATE 19434 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LATCHEDSTATE_FALSESTATE 19435 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_ALARMGROUP_PLACEHOLDER 19436 /* Object */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_REALARMTIME 19437 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_REALARMREPEATCOUNT 19438 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SILENCE 19439 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_SUPPRESS 19440 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_UNSUPPRESS 19441 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_REMOVEFROMSERVICE 19442 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_PLACEINSERVICE 19443 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_RESET 19444 /* Method */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_NORMALSTATE 19445 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_TRUSTLISTID 19446 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_LASTUPDATETIME 19447 /* Variable */ +#define UA_NS0ID_TRUSTLISTOUTOFDATEALARMTYPE_UPDATEFREQUENCY 19448 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_TRUSTLIST_UPDATEFREQUENCY 19449 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS 19550 /* Object */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_DIAGNOSTICSLEVEL 19551 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALINFORMATION 19552 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 19553 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 19554 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 19555 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 19556 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALERROR 19557 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALERROR_ACTIVE 19558 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 19559 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 19560 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 19561 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_RESET 19562 /* Method */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_SUBERROR 19563 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS 19564 /* Object */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR 19565 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 19566 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 19567 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19568 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19569 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 19570 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19571 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19572 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19573 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19574 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 19575 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19576 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19577 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19578 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19579 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 19580 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19581 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19582 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19583 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19584 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 19585 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19586 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19587 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19588 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19589 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 19590 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19591 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19592 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19593 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19594 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES 19595 /* Object */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES 19596 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 19597 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 19598 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 19599 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 19600 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER 19601 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 19602 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_STATUSCODE 19603 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 19604 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_MAJORVERSION 19605 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 19606 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_MINORVERSION 19607 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DIAGNOSTICS_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 19608 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS 19609 /* Object */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_DIAGNOSTICSLEVEL 19610 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALINFORMATION 19611 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 19612 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 19613 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 19614 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 19615 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALERROR 19616 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALERROR_ACTIVE 19617 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 19618 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 19619 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 19620 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_RESET 19621 /* Method */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_SUBERROR 19622 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS 19623 /* Object */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR 19624 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 19625 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 19626 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19627 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19628 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 19629 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19630 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19631 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19632 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19633 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 19634 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19635 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19636 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19637 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19638 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 19639 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19640 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19641 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19642 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19643 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 19644 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19645 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19646 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19647 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19648 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 19649 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19650 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19651 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19652 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19653 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES 19654 /* Object */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES 19655 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 19656 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 19657 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 19658 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 19659 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS 19660 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_ACTIVE 19661 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_CLASSIFICATION 19662 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_DIAGNOSTICSLEVEL 19663 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_TIMEFIRSTCHANGE 19664 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER 19665 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 19666 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_STATUSCODE 19667 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 19668 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_MAJORVERSION 19669 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 19670 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_MINORVERSION 19671 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 19672 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID 19673 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID_DIAGNOSTICSLEVEL 19674 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID 19675 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID_DIAGNOSTICSLEVEL 19676 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE 19677 /* ObjectType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_DIAGNOSTICSLEVEL 19678 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALINFORMATION 19679 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALINFORMATION_ACTIVE 19680 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALINFORMATION_CLASSIFICATION 19681 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALINFORMATION_DIAGNOSTICSLEVEL 19682 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALINFORMATION_TIMEFIRSTCHANGE 19683 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALERROR 19684 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALERROR_ACTIVE 19685 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALERROR_CLASSIFICATION 19686 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALERROR_DIAGNOSTICSLEVEL 19687 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_TOTALERROR_TIMEFIRSTCHANGE 19688 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_RESET 19689 /* Method */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_SUBERROR 19690 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS 19691 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEERROR 19692 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEERROR_ACTIVE 19693 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEERROR_CLASSIFICATION 19694 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19695 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19696 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYMETHOD 19697 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19698 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19699 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19700 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19701 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYPARENT 19702 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19703 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19704 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19705 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19706 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALFROMERROR 19707 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19708 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19709 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19710 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19711 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEPAUSEDBYPARENT 19712 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19713 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19714 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19715 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19716 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEDISABLEDBYMETHOD 19717 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19718 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19719 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19720 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19721 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSTYPE_LIVEVALUES 19722 /* Object */ +#define UA_NS0ID_DIAGNOSTICSLEVEL 19723 /* DataType */ +#define UA_NS0ID_DIAGNOSTICSLEVEL_ENUMSTRINGS 19724 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCOUNTERTYPE 19725 /* VariableType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCOUNTERTYPE_ACTIVE 19726 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCOUNTERTYPE_CLASSIFICATION 19727 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCOUNTERTYPE_DIAGNOSTICSLEVEL 19728 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCOUNTERTYPE_TIMEFIRSTCHANGE 19729 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION 19730 /* DataType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCOUNTERCLASSIFICATION_ENUMSTRINGS 19731 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE 19732 /* ObjectType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_DIAGNOSTICSLEVEL 19733 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALINFORMATION 19734 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALINFORMATION_ACTIVE 19735 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALINFORMATION_CLASSIFICATION 19736 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALINFORMATION_DIAGNOSTICSLEVEL 19737 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALINFORMATION_TIMEFIRSTCHANGE 19738 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALERROR 19739 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALERROR_ACTIVE 19740 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALERROR_CLASSIFICATION 19741 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALERROR_DIAGNOSTICSLEVEL 19742 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_TOTALERROR_TIMEFIRSTCHANGE 19743 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_RESET 19744 /* Method */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_SUBERROR 19745 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS 19746 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEERROR 19747 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEERROR_ACTIVE 19748 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEERROR_CLASSIFICATION 19749 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19750 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19751 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYMETHOD 19752 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19753 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19754 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19755 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19756 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYPARENT 19757 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19758 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19759 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19760 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19761 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALFROMERROR 19762 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19763 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19764 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19765 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19766 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEPAUSEDBYPARENT 19767 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19768 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19769 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19770 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19771 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEDISABLEDBYMETHOD 19772 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19773 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19774 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19775 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19776 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES 19777 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_CONFIGUREDDATASETWRITERS 19778 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_CONFIGUREDDATASETWRITERS_DIAGNOSTICSLEVEL 19779 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_CONFIGUREDDATASETREADERS 19780 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_CONFIGUREDDATASETREADERS_DIAGNOSTICSLEVEL 19781 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_OPERATIONALDATASETWRITERS 19782 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_OPERATIONALDATASETWRITERS_DIAGNOSTICSLEVEL 19783 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_OPERATIONALDATASETREADERS 19784 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSROOTTYPE_LIVEVALUES_OPERATIONALDATASETREADERS_DIAGNOSTICSLEVEL 19785 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE 19786 /* ObjectType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_DIAGNOSTICSLEVEL 19787 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALINFORMATION 19788 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALINFORMATION_ACTIVE 19789 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALINFORMATION_CLASSIFICATION 19790 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALINFORMATION_DIAGNOSTICSLEVEL 19791 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALINFORMATION_TIMEFIRSTCHANGE 19792 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALERROR 19793 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALERROR_ACTIVE 19794 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALERROR_CLASSIFICATION 19795 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALERROR_DIAGNOSTICSLEVEL 19796 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_TOTALERROR_TIMEFIRSTCHANGE 19797 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_RESET 19798 /* Method */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_SUBERROR 19799 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS 19800 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEERROR 19801 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEERROR_ACTIVE 19802 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEERROR_CLASSIFICATION 19803 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19804 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19805 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYMETHOD 19806 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19807 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19808 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19809 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19810 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYPARENT 19811 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19812 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19813 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19814 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19815 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALFROMERROR 19816 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19817 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19818 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19819 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19820 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEPAUSEDBYPARENT 19821 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19822 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19823 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19824 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19825 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEDISABLEDBYMETHOD 19826 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19827 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19828 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19829 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19830 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_LIVEVALUES 19831 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_LIVEVALUES_RESOLVEDADDRESS 19832 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSCONNECTIONTYPE_LIVEVALUES_RESOLVEDADDRESS_DIAGNOSTICSLEVEL 19833 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE 19834 /* ObjectType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_DIAGNOSTICSLEVEL 19835 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALINFORMATION 19836 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALINFORMATION_ACTIVE 19837 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALINFORMATION_CLASSIFICATION 19838 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALINFORMATION_DIAGNOSTICSLEVEL 19839 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALINFORMATION_TIMEFIRSTCHANGE 19840 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALERROR 19841 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALERROR_ACTIVE 19842 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALERROR_CLASSIFICATION 19843 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALERROR_DIAGNOSTICSLEVEL 19844 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_TOTALERROR_TIMEFIRSTCHANGE 19845 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_RESET 19846 /* Method */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_SUBERROR 19847 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS 19848 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEERROR 19849 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEERROR_ACTIVE 19850 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEERROR_CLASSIFICATION 19851 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19852 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19853 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD 19854 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19855 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19856 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19857 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19858 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT 19859 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19860 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19861 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19862 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19863 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR 19864 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19865 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19866 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19867 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19868 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT 19869 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19870 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19871 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19872 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19873 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD 19874 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19875 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19876 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19877 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19878 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES 19879 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_SENTNETWORKMESSAGES 19880 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_SENTNETWORKMESSAGES_ACTIVE 19881 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_SENTNETWORKMESSAGES_CLASSIFICATION 19882 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_SENTNETWORKMESSAGES_DIAGNOSTICSLEVEL 19883 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_SENTNETWORKMESSAGES_TIMEFIRSTCHANGE 19884 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_FAILEDTRANSMISSIONS 19885 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_FAILEDTRANSMISSIONS_ACTIVE 19886 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_FAILEDTRANSMISSIONS_CLASSIFICATION 19887 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_FAILEDTRANSMISSIONS_DIAGNOSTICSLEVEL 19888 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_FAILEDTRANSMISSIONS_TIMEFIRSTCHANGE 19889 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_ENCRYPTIONERRORS 19890 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_ENCRYPTIONERRORS_ACTIVE 19891 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_ENCRYPTIONERRORS_CLASSIFICATION 19892 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_ENCRYPTIONERRORS_DIAGNOSTICSLEVEL 19893 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_COUNTERS_ENCRYPTIONERRORS_TIMEFIRSTCHANGE 19894 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_CONFIGUREDDATASETWRITERS 19895 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_CONFIGUREDDATASETWRITERS_DIAGNOSTICSLEVEL 19896 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_OPERATIONALDATASETWRITERS 19897 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_OPERATIONALDATASETWRITERS_DIAGNOSTICSLEVEL 19898 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_SECURITYTOKENID 19899 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_SECURITYTOKENID_DIAGNOSTICSLEVEL 19900 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_TIMETONEXTTOKENID 19901 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSWRITERGROUPTYPE_LIVEVALUES_TIMETONEXTTOKENID_DIAGNOSTICSLEVEL 19902 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE 19903 /* ObjectType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_DIAGNOSTICSLEVEL 19904 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALINFORMATION 19905 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALINFORMATION_ACTIVE 19906 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALINFORMATION_CLASSIFICATION 19907 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALINFORMATION_DIAGNOSTICSLEVEL 19908 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALINFORMATION_TIMEFIRSTCHANGE 19909 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALERROR 19910 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALERROR_ACTIVE 19911 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALERROR_CLASSIFICATION 19912 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALERROR_DIAGNOSTICSLEVEL 19913 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_TOTALERROR_TIMEFIRSTCHANGE 19914 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_RESET 19915 /* Method */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_SUBERROR 19916 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS 19917 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEERROR 19918 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEERROR_ACTIVE 19919 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEERROR_CLASSIFICATION 19920 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19921 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19922 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD 19923 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19924 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19925 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19926 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19927 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT 19928 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19929 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19930 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19931 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19932 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR 19933 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19934 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 19935 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 19936 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 19937 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT 19938 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 19939 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 19940 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 19941 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 19942 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD 19943 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 19944 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 19945 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 19946 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 19947 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_LIVEVALUES 19948 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDNETWORKMESSAGES 19949 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDNETWORKMESSAGES_ACTIVE 19950 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDNETWORKMESSAGES_CLASSIFICATION 19951 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDNETWORKMESSAGES_DIAGNOSTICSLEVEL 19952 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDNETWORKMESSAGES_TIMEFIRSTCHANGE 19953 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES 19954 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_ACTIVE 19955 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_CLASSIFICATION 19956 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_DIAGNOSTICSLEVEL 19957 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_TIMEFIRSTCHANGE 19958 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_DECRYPTIONERRORS 19959 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_DECRYPTIONERRORS_ACTIVE 19960 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_DECRYPTIONERRORS_CLASSIFICATION 19961 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_DECRYPTIONERRORS_DIAGNOSTICSLEVEL 19962 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_COUNTERS_DECRYPTIONERRORS_TIMEFIRSTCHANGE 19963 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_LIVEVALUES_CONFIGUREDDATASETREADERS 19964 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_LIVEVALUES_CONFIGUREDDATASETREADERS_DIAGNOSTICSLEVEL 19965 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_LIVEVALUES_OPERATIONALDATASETREADERS 19966 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSREADERGROUPTYPE_LIVEVALUES_OPERATIONALDATASETREADERS_DIAGNOSTICSLEVEL 19967 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE 19968 /* ObjectType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_DIAGNOSTICSLEVEL 19969 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALINFORMATION 19970 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALINFORMATION_ACTIVE 19971 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALINFORMATION_CLASSIFICATION 19972 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALINFORMATION_DIAGNOSTICSLEVEL 19973 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALINFORMATION_TIMEFIRSTCHANGE 19974 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALERROR 19975 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALERROR_ACTIVE 19976 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALERROR_CLASSIFICATION 19977 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALERROR_DIAGNOSTICSLEVEL 19978 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_TOTALERROR_TIMEFIRSTCHANGE 19979 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_RESET 19980 /* Method */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_SUBERROR 19981 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS 19982 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEERROR 19983 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEERROR_ACTIVE 19984 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEERROR_CLASSIFICATION 19985 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 19986 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 19987 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD 19988 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 19989 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 19990 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 19991 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 19992 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYPARENT 19993 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 19994 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 19995 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 19996 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 19997 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALFROMERROR 19998 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 19999 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 20000 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 20001 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 20002 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEPAUSEDBYPARENT 20003 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 20004 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 20005 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 20006 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 20007 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEDISABLEDBYMETHOD 20008 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 20009 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 20010 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 20011 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 20012 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES 20013 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_FAILEDDATASETMESSAGES 20014 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 20015 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 20016 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 20017 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 20018 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_MESSAGESEQUENCENUMBER 20019 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 20020 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_STATUSCODE 20021 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 20022 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_MAJORVERSION 20023 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 20024 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_MINORVERSION 20025 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETWRITERTYPE_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 20026 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE 20027 /* ObjectType */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_DIAGNOSTICSLEVEL 20028 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALINFORMATION 20029 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALINFORMATION_ACTIVE 20030 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALINFORMATION_CLASSIFICATION 20031 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALINFORMATION_DIAGNOSTICSLEVEL 20032 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALINFORMATION_TIMEFIRSTCHANGE 20033 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALERROR 20034 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALERROR_ACTIVE 20035 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALERROR_CLASSIFICATION 20036 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALERROR_DIAGNOSTICSLEVEL 20037 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_TOTALERROR_TIMEFIRSTCHANGE 20038 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_RESET 20039 /* Method */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_SUBERROR 20040 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS 20041 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEERROR 20042 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEERROR_ACTIVE 20043 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEERROR_CLASSIFICATION 20044 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 20045 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 20046 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD 20047 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 20048 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 20049 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 20050 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 20051 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYPARENT 20052 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 20053 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 20054 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 20055 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 20056 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALFROMERROR 20057 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 20058 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 20059 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 20060 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 20061 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEPAUSEDBYPARENT 20062 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 20063 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 20064 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 20065 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 20066 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEDISABLEDBYMETHOD 20067 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 20068 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 20069 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 20070 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 20071 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES 20072 /* Object */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_FAILEDDATASETMESSAGES 20073 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_FAILEDDATASETMESSAGES_ACTIVE 20074 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_FAILEDDATASETMESSAGES_CLASSIFICATION 20075 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_FAILEDDATASETMESSAGES_DIAGNOSTICSLEVEL 20076 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_FAILEDDATASETMESSAGES_TIMEFIRSTCHANGE 20077 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_DECRYPTIONERRORS 20078 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_DECRYPTIONERRORS_ACTIVE 20079 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_DECRYPTIONERRORS_CLASSIFICATION 20080 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_DECRYPTIONERRORS_DIAGNOSTICSLEVEL 20081 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_COUNTERS_DECRYPTIONERRORS_TIMEFIRSTCHANGE 20082 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_MESSAGESEQUENCENUMBER 20083 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_MESSAGESEQUENCENUMBER_DIAGNOSTICSLEVEL 20084 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_STATUSCODE 20085 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_STATUSCODE_DIAGNOSTICSLEVEL 20086 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_MAJORVERSION 20087 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_MAJORVERSION_DIAGNOSTICSLEVEL 20088 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_MINORVERSION 20089 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_MINORVERSION_DIAGNOSTICSLEVEL 20090 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_SECURITYTOKENID 20091 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_SECURITYTOKENID_DIAGNOSTICSLEVEL 20092 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_TIMETONEXTTOKENID 20093 /* Variable */ +#define UA_NS0ID_PUBSUBDIAGNOSTICSDATASETREADERTYPE_LIVEVALUES_TIMETONEXTTOKENID_DIAGNOSTICSLEVEL 20094 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_TRUSTLIST_UPDATEFREQUENCY 20290 /* Variable */ +#define UA_NS0ID_DATASETORDERINGTYPE 20408 /* DataType */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID 20409 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_TRUSTLIST_UPDATEFREQUENCY 20588 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_TRUSTLIST_UPDATEFREQUENCY 20884 /* Variable */ +#define UA_NS0ID_VERSIONTIME 20998 /* DataType */ +#define UA_NS0ID_SESSIONLESSINVOKERESPONSETYPE 20999 /* DataType */ +#define UA_NS0ID_SESSIONLESSINVOKERESPONSETYPE_ENCODING_DEFAULTXML 21000 /* Object */ +#define UA_NS0ID_SESSIONLESSINVOKERESPONSETYPE_ENCODING_DEFAULTBINARY 21001 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_FIELDTARGETDATATYPE 21002 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_SECURITYTOKENID_DIAGNOSTICSLEVEL 21003 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID 21004 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_DIAGNOSTICS_LIVEVALUES_TIMETONEXTTOKENID_DIAGNOSTICSLEVEL 21005 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_SUBSCRIBEDDATASET 21006 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_CREATETARGETVARIABLES 21009 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_CREATETARGETVARIABLES_INPUTARGUMENTS 21010 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_CREATETARGETVARIABLES_OUTPUTARGUMENTS 21011 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_CREATEDATASETMIRROR 21012 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_CREATEDATASETMIRROR_INPUTARGUMENTS 21013 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DATASETREADERNAME_PLACEHOLDER_CREATEDATASETMIRROR_OUTPUTARGUMENTS 21014 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS 21015 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_DIAGNOSTICSLEVEL 21016 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION 21017 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_ACTIVE 21018 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_CLASSIFICATION 21019 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_DIAGNOSTICSLEVEL 21020 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALINFORMATION_TIMEFIRSTCHANGE 21021 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALERROR 21022 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALERROR_ACTIVE 21023 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALERROR_CLASSIFICATION 21024 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALERROR_DIAGNOSTICSLEVEL 21025 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_TOTALERROR_TIMEFIRSTCHANGE 21026 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_RESET 21027 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_SUBERROR 21028 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS 21029 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR 21030 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_ACTIVE 21031 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_CLASSIFICATION 21032 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_DIAGNOSTICSLEVEL 21033 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEERROR_TIMEFIRSTCHANGE 21034 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD 21035 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_ACTIVE 21036 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_CLASSIFICATION 21037 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_DIAGNOSTICSLEVEL 21038 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYMETHOD_TIMEFIRSTCHANGE 21039 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT 21040 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_ACTIVE 21041 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_CLASSIFICATION 21042 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_DIAGNOSTICSLEVEL 21043 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALBYPARENT_TIMEFIRSTCHANGE 21044 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR 21045 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_ACTIVE 21046 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_CLASSIFICATION 21047 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_DIAGNOSTICSLEVEL 21048 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEOPERATIONALFROMERROR_TIMEFIRSTCHANGE 21049 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT 21050 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_ACTIVE 21051 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_CLASSIFICATION 21052 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_DIAGNOSTICSLEVEL 21053 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEPAUSEDBYPARENT_TIMEFIRSTCHANGE 21054 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD 21055 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_ACTIVE 21056 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_CLASSIFICATION 21057 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_DIAGNOSTICSLEVEL 21058 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_STATEDISABLEDBYMETHOD_TIMEFIRSTCHANGE 21059 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_LIVEVALUES 21060 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES 21061 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_ACTIVE 21062 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_CLASSIFICATION 21063 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_DIAGNOSTICSLEVEL 21064 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDNETWORKMESSAGES_TIMEFIRSTCHANGE 21065 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES 21066 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_ACTIVE 21067 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_CLASSIFICATION 21068 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_DIAGNOSTICSLEVEL 21069 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_RECEIVEDINVALIDNETWORKMESSAGES_TIMEFIRSTCHANGE 21070 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS 21071 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_ACTIVE 21072 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_CLASSIFICATION 21073 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_DIAGNOSTICSLEVEL 21074 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_COUNTERS_DECRYPTIONERRORS_TIMEFIRSTCHANGE 21075 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS 21076 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_CONFIGUREDDATASETREADERS_DIAGNOSTICSLEVEL 21077 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS 21078 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_DIAGNOSTICS_LIVEVALUES_OPERATIONALDATASETREADERS_DIAGNOSTICSLEVEL 21079 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_TRANSPORTSETTINGS 21080 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_MESSAGESETTINGS 21081 /* Object */ +#define UA_NS0ID_READERGROUPTYPE_ADDDATASETREADER 21082 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_ADDDATASETREADER_INPUTARGUMENTS 21083 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_ADDDATASETREADER_OUTPUTARGUMENTS 21084 /* Variable */ +#define UA_NS0ID_READERGROUPTYPE_REMOVEDATASETREADER 21085 /* Method */ +#define UA_NS0ID_READERGROUPTYPE_REMOVEDATASETREADER_INPUTARGUMENTS 21086 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPEADDREADERMETHODTYPE 21087 /* Method */ +#define UA_NS0ID_PUBSUBGROUPTYPEADDREADERMETHODTYPE_INPUTARGUMENTS 21088 /* Variable */ +#define UA_NS0ID_PUBSUBGROUPTYPEADDREADERMETHODTYPE_OUTPUTARGUMENTS 21089 /* Variable */ +#define UA_NS0ID_READERGROUPTRANSPORTTYPE 21090 /* ObjectType */ +#define UA_NS0ID_READERGROUPMESSAGETYPE 21091 /* ObjectType */ +#define UA_NS0ID_DATASETWRITERTYPE_DATASETWRITERID 21092 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_DATASETFIELDCONTENTMASK 21093 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_KEYFRAMECOUNT 21094 /* Variable */ +#define UA_NS0ID_DATASETWRITERTYPE_MESSAGESETTINGS 21095 /* Object */ +#define UA_NS0ID_DATASETWRITERMESSAGETYPE 21096 /* ObjectType */ +#define UA_NS0ID_DATASETREADERTYPE_PUBLISHERID 21097 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_WRITERGROUPID 21098 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DATASETWRITERID 21099 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DATASETMETADATA 21100 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_DATASETFIELDCONTENTMASK 21101 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_MESSAGERECEIVETIMEOUT 21102 /* Variable */ +#define UA_NS0ID_DATASETREADERTYPE_MESSAGESETTINGS 21103 /* Object */ +#define UA_NS0ID_DATASETREADERMESSAGETYPE 21104 /* ObjectType */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGETYPE 21105 /* ObjectType */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGETYPE_GROUPVERSION 21106 /* Variable */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGETYPE_DATASETORDERING 21107 /* Variable */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGETYPE_NETWORKMESSAGECONTENTMASK 21108 /* Variable */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGETYPE_SAMPLINGOFFSET 21109 /* Variable */ +#define UA_NS0ID_UADPWRITERGROUPMESSAGETYPE_PUBLISHINGOFFSET 21110 /* Variable */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGETYPE 21111 /* ObjectType */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGETYPE_DATASETMESSAGECONTENTMASK 21112 /* Variable */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGETYPE_CONFIGUREDSIZE 21113 /* Variable */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGETYPE_NETWORKMESSAGENUMBER 21114 /* Variable */ +#define UA_NS0ID_UADPDATASETWRITERMESSAGETYPE_DATASETOFFSET 21115 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE 21116 /* ObjectType */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_GROUPVERSION 21117 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_NETWORKMESSAGENUMBER 21119 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_DATASETCLASSID 21120 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_NETWORKMESSAGECONTENTMASK 21121 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_DATASETMESSAGECONTENTMASK 21122 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_PUBLISHINGINTERVAL 21123 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_PROCESSINGOFFSET 21124 /* Variable */ +#define UA_NS0ID_UADPDATASETREADERMESSAGETYPE_RECEIVEOFFSET 21125 /* Variable */ +#define UA_NS0ID_JSONWRITERGROUPMESSAGETYPE 21126 /* ObjectType */ +#define UA_NS0ID_JSONWRITERGROUPMESSAGETYPE_NETWORKMESSAGECONTENTMASK 21127 /* Variable */ +#define UA_NS0ID_JSONDATASETWRITERMESSAGETYPE 21128 /* ObjectType */ +#define UA_NS0ID_JSONDATASETWRITERMESSAGETYPE_DATASETMESSAGECONTENTMASK 21129 /* Variable */ +#define UA_NS0ID_JSONDATASETREADERMESSAGETYPE 21130 /* ObjectType */ +#define UA_NS0ID_JSONDATASETREADERMESSAGETYPE_NETWORKMESSAGECONTENTMASK 21131 /* Variable */ +#define UA_NS0ID_JSONDATASETREADERMESSAGETYPE_DATASETMESSAGECONTENTMASK 21132 /* Variable */ +#define UA_NS0ID_DATAGRAMWRITERGROUPTRANSPORTTYPE 21133 /* ObjectType */ +#define UA_NS0ID_DATAGRAMWRITERGROUPTRANSPORTTYPE_MESSAGEREPEATCOUNT 21134 /* Variable */ +#define UA_NS0ID_DATAGRAMWRITERGROUPTRANSPORTTYPE_MESSAGEREPEATDELAY 21135 /* Variable */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTTYPE 21136 /* ObjectType */ +#define UA_NS0ID_BROKERWRITERGROUPTRANSPORTTYPE_QUEUENAME 21137 /* Variable */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTTYPE 21138 /* ObjectType */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTTYPE_QUEUENAME 21139 /* Variable */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTTYPE_METADATAQUEUENAME 21140 /* Variable */ +#define UA_NS0ID_BROKERDATASETWRITERTRANSPORTTYPE_METADATAUPDATETIME 21141 /* Variable */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTTYPE 21142 /* ObjectType */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTTYPE_QUEUENAME 21143 /* Variable */ +#define UA_NS0ID_BROKERDATASETREADERTRANSPORTTYPE_METADATAQUEUENAME 21144 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSTYPE 21145 /* ObjectType */ +#define UA_NS0ID_NETWORKADDRESSTYPE_NETWORKINTERFACE 21146 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSURLTYPE 21147 /* ObjectType */ +#define UA_NS0ID_NETWORKADDRESSURLTYPE_NETWORKINTERFACE 21148 /* Variable */ +#define UA_NS0ID_NETWORKADDRESSURLTYPE_URL 21149 /* Variable */ +#define UA_NS0ID_WRITERGROUPDATATYPE_ENCODING_DEFAULTBINARY 21150 /* Object */ +#define UA_NS0ID_NETWORKADDRESSDATATYPE_ENCODING_DEFAULTBINARY 21151 /* Object */ +#define UA_NS0ID_NETWORKADDRESSURLDATATYPE_ENCODING_DEFAULTBINARY 21152 /* Object */ +#define UA_NS0ID_READERGROUPDATATYPE_ENCODING_DEFAULTBINARY 21153 /* Object */ +#define UA_NS0ID_PUBSUBCONFIGURATIONDATATYPE_ENCODING_DEFAULTBINARY 21154 /* Object */ +#define UA_NS0ID_DATAGRAMWRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTBINARY 21155 /* Object */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPDATATYPE 21156 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPDATATYPE_DATATYPEVERSION 21157 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_WRITERGROUPDATATYPE_DICTIONARYFRAGMENT 21158 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKADDRESSDATATYPE 21159 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKADDRESSDATATYPE_DATATYPEVERSION 21160 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKADDRESSDATATYPE_DICTIONARYFRAGMENT 21161 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKADDRESSURLDATATYPE 21162 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKADDRESSURLDATATYPE_DATATYPEVERSION 21163 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_NETWORKADDRESSURLDATATYPE_DICTIONARYFRAGMENT 21164 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPDATATYPE 21165 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPDATATYPE_DATATYPEVERSION 21166 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_READERGROUPDATATYPE_DICTIONARYFRAGMENT 21167 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBCONFIGURATIONDATATYPE 21168 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBCONFIGURATIONDATATYPE_DATATYPEVERSION 21169 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_PUBSUBCONFIGURATIONDATATYPE_DICTIONARYFRAGMENT 21170 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATAGRAMWRITERGROUPTRANSPORTDATATYPE 21171 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATAGRAMWRITERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 21172 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_DATAGRAMWRITERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 21173 /* Variable */ +#define UA_NS0ID_WRITERGROUPDATATYPE_ENCODING_DEFAULTXML 21174 /* Object */ +#define UA_NS0ID_NETWORKADDRESSDATATYPE_ENCODING_DEFAULTXML 21175 /* Object */ +#define UA_NS0ID_NETWORKADDRESSURLDATATYPE_ENCODING_DEFAULTXML 21176 /* Object */ +#define UA_NS0ID_READERGROUPDATATYPE_ENCODING_DEFAULTXML 21177 /* Object */ +#define UA_NS0ID_PUBSUBCONFIGURATIONDATATYPE_ENCODING_DEFAULTXML 21178 /* Object */ +#define UA_NS0ID_DATAGRAMWRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTXML 21179 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPDATATYPE 21180 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPDATATYPE_DATATYPEVERSION 21181 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_WRITERGROUPDATATYPE_DICTIONARYFRAGMENT 21182 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKADDRESSDATATYPE 21183 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKADDRESSDATATYPE_DATATYPEVERSION 21184 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKADDRESSDATATYPE_DICTIONARYFRAGMENT 21185 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKADDRESSURLDATATYPE 21186 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKADDRESSURLDATATYPE_DATATYPEVERSION 21187 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_NETWORKADDRESSURLDATATYPE_DICTIONARYFRAGMENT 21188 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPDATATYPE 21189 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPDATATYPE_DATATYPEVERSION 21190 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_READERGROUPDATATYPE_DICTIONARYFRAGMENT 21191 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBCONFIGURATIONDATATYPE 21192 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBCONFIGURATIONDATATYPE_DATATYPEVERSION 21193 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_PUBSUBCONFIGURATIONDATATYPE_DICTIONARYFRAGMENT 21194 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATAGRAMWRITERGROUPTRANSPORTDATATYPE 21195 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATAGRAMWRITERGROUPTRANSPORTDATATYPE_DATATYPEVERSION 21196 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_DATAGRAMWRITERGROUPTRANSPORTDATATYPE_DICTIONARYFRAGMENT 21197 /* Variable */ +#define UA_NS0ID_WRITERGROUPDATATYPE_ENCODING_DEFAULTJSON 21198 /* Object */ +#define UA_NS0ID_NETWORKADDRESSDATATYPE_ENCODING_DEFAULTJSON 21199 /* Object */ +#define UA_NS0ID_NETWORKADDRESSURLDATATYPE_ENCODING_DEFAULTJSON 21200 /* Object */ +#define UA_NS0ID_READERGROUPDATATYPE_ENCODING_DEFAULTJSON 21201 /* Object */ +#define UA_NS0ID_PUBSUBCONFIGURATIONDATATYPE_ENCODING_DEFAULTJSON 21202 /* Object */ +#define UA_NS0ID_DATAGRAMWRITERGROUPTRANSPORTDATATYPE_ENCODING_DEFAULTJSON 21203 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_TRUSTLIST_UPDATEFREQUENCY 21383 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_UPDATEFREQUENCY 21679 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_UPDATEFREQUENCY 21975 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_UPDATEFREQUENCY 22271 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_TRUSTLIST_UPDATEFREQUENCY 22567 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_TRUSTLIST_UPDATEFREQUENCY 22863 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_TRUSTLIST_UPDATEFREQUENCY 23159 /* Variable */ +#define UA_NS0ID_ALIASNAMETYPE 23455 /* ObjectType */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE 23456 /* ObjectType */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_ALIAS_PLACEHOLDER 23457 /* Object */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_SUBALIASNAMECATEGORIES_PLACEHOLDER 23458 /* Object */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS 23459 /* Method */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_INPUTARGUMENTS 23460 /* Variable */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_OUTPUTARGUMENTS 23461 /* Variable */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_FINDALIAS 23462 /* Method */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_FINDALIAS_INPUTARGUMENTS 23463 /* Variable */ +#define UA_NS0ID_ALIASNAMECATEGORYTYPE_FINDALIAS_OUTPUTARGUMENTS 23464 /* Variable */ +#define UA_NS0ID_FINDALIASMETHODTYPE 23465 /* Method */ +#define UA_NS0ID_FINDALIASMETHODTYPE_INPUTARGUMENTS 23466 /* Variable */ +#define UA_NS0ID_FINDALIASMETHODTYPE_OUTPUTARGUMENTS 23467 /* Variable */ +#define UA_NS0ID_ALIASNAMEDATATYPE 23468 /* DataType */ +#define UA_NS0ID_ALIASFOR 23469 /* ReferenceType */ +#define UA_NS0ID_ALIASES 23470 /* Object */ +#define UA_NS0ID_ALIASES_ALIAS_PLACEHOLDER 23471 /* Object */ +#define UA_NS0ID_ALIASES_SUBALIASNAMECATEGORIES_PLACEHOLDER 23472 /* Object */ +#define UA_NS0ID_ALIASES_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS 23473 /* Method */ +#define UA_NS0ID_ALIASES_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_INPUTARGUMENTS 23474 /* Variable */ +#define UA_NS0ID_ALIASES_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_OUTPUTARGUMENTS 23475 /* Variable */ +#define UA_NS0ID_ALIASES_FINDALIAS 23476 /* Method */ +#define UA_NS0ID_ALIASES_FINDALIAS_INPUTARGUMENTS 23477 /* Variable */ +#define UA_NS0ID_ALIASES_FINDALIAS_OUTPUTARGUMENTS 23478 /* Variable */ +#define UA_NS0ID_TAGVARIABLES 23479 /* Object */ +#define UA_NS0ID_TAGVARIABLES_ALIAS_PLACEHOLDER 23480 /* Object */ +#define UA_NS0ID_TAGVARIABLES_SUBALIASNAMECATEGORIES_PLACEHOLDER 23481 /* Object */ +#define UA_NS0ID_TAGVARIABLES_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS 23482 /* Method */ +#define UA_NS0ID_TAGVARIABLES_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_INPUTARGUMENTS 23483 /* Variable */ +#define UA_NS0ID_TAGVARIABLES_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_OUTPUTARGUMENTS 23484 /* Variable */ +#define UA_NS0ID_TAGVARIABLES_FINDALIAS 23485 /* Method */ +#define UA_NS0ID_TAGVARIABLES_FINDALIAS_INPUTARGUMENTS 23486 /* Variable */ +#define UA_NS0ID_TAGVARIABLES_FINDALIAS_OUTPUTARGUMENTS 23487 /* Variable */ +#define UA_NS0ID_TOPICS 23488 /* Object */ +#define UA_NS0ID_TOPICS_ALIAS_PLACEHOLDER 23489 /* Object */ +#define UA_NS0ID_TOPICS_SUBALIASNAMECATEGORIES_PLACEHOLDER 23490 /* Object */ +#define UA_NS0ID_TOPICS_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS 23491 /* Method */ +#define UA_NS0ID_TOPICS_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_INPUTARGUMENTS 23492 /* Variable */ +#define UA_NS0ID_TOPICS_SUBALIASNAMECATEGORIES_PLACEHOLDER_FINDALIAS_OUTPUTARGUMENTS 23493 /* Variable */ +#define UA_NS0ID_TOPICS_FINDALIAS 23494 /* Method */ +#define UA_NS0ID_TOPICS_FINDALIAS_INPUTARGUMENTS 23495 /* Variable */ +#define UA_NS0ID_TOPICS_FINDALIAS_OUTPUTARGUMENTS 23496 /* Variable */ +#define UA_NS0ID_READANNOTATIONDATADETAILS 23497 /* DataType */ +#define UA_NS0ID_CURRENCYUNITTYPE 23498 /* DataType */ +#define UA_NS0ID_ALIASNAMEDATATYPE_ENCODING_DEFAULTBINARY 23499 /* Object */ +#define UA_NS0ID_READANNOTATIONDATADETAILS_ENCODING_DEFAULTBINARY 23500 /* Object */ +#define UA_NS0ID_CURRENCYUNIT 23501 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ALIASNAMEDATATYPE 23502 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ALIASNAMEDATATYPE_DATATYPEVERSION 23503 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_ALIASNAMEDATATYPE_DICTIONARYFRAGMENT 23504 /* Variable */ +#define UA_NS0ID_ALIASNAMEDATATYPE_ENCODING_DEFAULTXML 23505 /* Object */ +#define UA_NS0ID_READANNOTATIONDATADETAILS_ENCODING_DEFAULTXML 23506 /* Object */ +#define UA_NS0ID_CURRENCYUNITTYPE_ENCODING_DEFAULTBINARY 23507 /* Object */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ALIASNAMEDATATYPE 23508 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ALIASNAMEDATATYPE_DATATYPEVERSION 23509 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_ALIASNAMEDATATYPE_DICTIONARYFRAGMENT 23510 /* Variable */ +#define UA_NS0ID_ALIASNAMEDATATYPE_ENCODING_DEFAULTJSON 23511 /* Object */ +#define UA_NS0ID_READANNOTATIONDATADETAILS_ENCODING_DEFAULTJSON 23512 /* Object */ +#define UA_NS0ID_IORDEREDOBJECTTYPE 23513 /* ObjectType */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CURRENCYUNITTYPE 23514 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CURRENCYUNITTYPE_DATATYPEVERSION 23515 /* Variable */ +#define UA_NS0ID_OPCUA_BINARYSCHEMA_CURRENCYUNITTYPE_DICTIONARYFRAGMENT 23516 /* Variable */ +#define UA_NS0ID_IORDEREDOBJECTTYPE_NUMBERINLIST 23517 /* Variable */ +#define UA_NS0ID_ORDEREDLISTTYPE 23518 /* ObjectType */ +#define UA_NS0ID_ORDEREDLISTTYPE_ORDEREDOBJECT_PLACEHOLDER 23519 /* Object */ +#define UA_NS0ID_CURRENCYUNITTYPE_ENCODING_DEFAULTXML 23520 /* Object */ +#define UA_NS0ID_ORDEREDLISTTYPE_ORDEREDOBJECT_PLACEHOLDER_NUMBERINLIST 23521 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CURRENCYUNITTYPE 23522 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CURRENCYUNITTYPE_DATATYPEVERSION 23523 /* Variable */ +#define UA_NS0ID_OPCUA_XMLSCHEMA_CURRENCYUNITTYPE_DICTIONARYFRAGMENT 23524 /* Variable */ +#define UA_NS0ID_ORDEREDLISTTYPE_NODEVERSION 23525 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_GETREJECTEDLIST 23526 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPTYPE_GETREJECTEDLIST_OUTPUTARGUMENTS 23527 /* Variable */ +#define UA_NS0ID_CURRENCYUNITTYPE_ENCODING_DEFAULTJSON 23528 /* Object */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_GETREJECTEDLIST 23529 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTAPPLICATIONGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23530 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_GETREJECTEDLIST 23531 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTHTTPSGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23532 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_GETREJECTEDLIST 23533 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_DEFAULTUSERTOKENGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23534 /* Variable */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_GETREJECTEDLIST 23535 /* Method */ +#define UA_NS0ID_CERTIFICATEGROUPFOLDERTYPE_ADDITIONALGROUP_PLACEHOLDER_GETREJECTEDLIST_OUTPUTARGUMENTS 23536 /* Variable */ +#define UA_NS0ID_ECCAPPLICATIONCERTIFICATETYPE 23537 /* ObjectType */ +#define UA_NS0ID_ECCNISTP256APPLICATIONCERTIFICATETYPE 23538 /* ObjectType */ +#define UA_NS0ID_ECCNISTP384APPLICATIONCERTIFICATETYPE 23539 /* ObjectType */ +#define UA_NS0ID_ECCBRAINPOOLP256R1APPLICATIONCERTIFICATETYPE 23540 /* ObjectType */ +#define UA_NS0ID_ECCBRAINPOOLP384R1APPLICATIONCERTIFICATETYPE 23541 /* ObjectType */ +#define UA_NS0ID_ECCCURVE25519APPLICATIONCERTIFICATETYPE 23542 /* ObjectType */ +#define UA_NS0ID_ECCCURVE448APPLICATIONCERTIFICATETYPE 23543 /* ObjectType */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_GETREJECTEDLIST 23544 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23545 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_GETREJECTEDLIST 23546 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23547 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_GETREJECTEDLIST 23548 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATIONTYPE_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23549 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_GETREJECTEDLIST 23550 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTAPPLICATIONGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23551 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_GETREJECTEDLIST 23552 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTHTTPSGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23553 /* Variable */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_GETREJECTEDLIST 23554 /* Method */ +#define UA_NS0ID_SERVERCONFIGURATION_CERTIFICATEGROUPS_DEFAULTUSERTOKENGROUP_GETREJECTEDLIST_OUTPUTARGUMENTS 23555 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICESCONFIGURATIONFOLDERTYPE 23556 /* ObjectType */ +#define UA_NS0ID_AUTHORIZATIONSERVICESCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER 23557 /* Object */ +#define UA_NS0ID_AUTHORIZATIONSERVICESCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_SERVICEURI 23558 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICESCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_SERVICECERTIFICATE 23559 /* Variable */ +#define UA_NS0ID_AUTHORIZATIONSERVICESCONFIGURATIONFOLDERTYPE_SERVICENAME_PLACEHOLDER_ISSUERENDPOINTURL 23560 /* Variable */ +#endif /* UA_NODEIDS_NS0_H_ */ + +/**** amalgamated original file "/include/open62541/common.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2016-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2016 (c) Sten Grüner + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Florian Palm + * Copyright 2020 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + + +_UA_BEGIN_DECLS + +/** + * Common Definitions + * ================== + * + * Common definitions for Client, Server and PubSub. + * + * .. _attribute-id: + * + * Attribute Id + * ------------ + * Every node in an OPC UA information model contains attributes depending on + * the node type. Possible attributes are as follows: */ + +typedef enum { + UA_ATTRIBUTEID_NODEID = 1, + UA_ATTRIBUTEID_NODECLASS = 2, + UA_ATTRIBUTEID_BROWSENAME = 3, + UA_ATTRIBUTEID_DISPLAYNAME = 4, + UA_ATTRIBUTEID_DESCRIPTION = 5, + UA_ATTRIBUTEID_WRITEMASK = 6, + UA_ATTRIBUTEID_USERWRITEMASK = 7, + UA_ATTRIBUTEID_ISABSTRACT = 8, + UA_ATTRIBUTEID_SYMMETRIC = 9, + UA_ATTRIBUTEID_INVERSENAME = 10, + UA_ATTRIBUTEID_CONTAINSNOLOOPS = 11, + UA_ATTRIBUTEID_EVENTNOTIFIER = 12, + UA_ATTRIBUTEID_VALUE = 13, + UA_ATTRIBUTEID_DATATYPE = 14, + UA_ATTRIBUTEID_VALUERANK = 15, + UA_ATTRIBUTEID_ARRAYDIMENSIONS = 16, + UA_ATTRIBUTEID_ACCESSLEVEL = 17, + UA_ATTRIBUTEID_USERACCESSLEVEL = 18, + UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL = 19, + UA_ATTRIBUTEID_HISTORIZING = 20, + UA_ATTRIBUTEID_EXECUTABLE = 21, + UA_ATTRIBUTEID_USEREXECUTABLE = 22, + UA_ATTRIBUTEID_DATATYPEDEFINITION = 23, + UA_ATTRIBUTEID_ROLEPERMISSIONS = 24, + UA_ATTRIBUTEID_USERROLEPERMISSIONS = 25, + UA_ATTRIBUTEID_ACCESSRESTRICTIONS = 26, + UA_ATTRIBUTEID_ACCESSLEVELEX = 27 +} UA_AttributeId; + +/** + * Access Level Masks + * ------------------ + * The access level to a node is given by the following constants that are ANDed + * with the overall access level. */ + +#define UA_ACCESSLEVELMASK_READ (0x01u << 0u) +#define UA_ACCESSLEVELMASK_WRITE (0x01u << 1u) +#define UA_ACCESSLEVELMASK_HISTORYREAD (0x01u << 2u) +#define UA_ACCESSLEVELMASK_HISTORYWRITE (0x01u << 3u) +#define UA_ACCESSLEVELMASK_SEMANTICCHANGE (0x01u << 4u) +#define UA_ACCESSLEVELMASK_STATUSWRITE (0x01u << 5u) +#define UA_ACCESSLEVELMASK_TIMESTAMPWRITE (0x01u << 6u) + +/** + * Write Masks + * ----------- + * The write mask and user write mask is given by the following constants that + * are ANDed for the overall write mask. Part 3: 5.2.7 Table 2 */ + +#define UA_WRITEMASK_ACCESSLEVEL (0x01u << 0u) +#define UA_WRITEMASK_ARRRAYDIMENSIONS (0x01u << 1u) +#define UA_WRITEMASK_BROWSENAME (0x01u << 2u) +#define UA_WRITEMASK_CONTAINSNOLOOPS (0x01u << 3u) +#define UA_WRITEMASK_DATATYPE (0x01u << 4u) +#define UA_WRITEMASK_DESCRIPTION (0x01u << 5u) +#define UA_WRITEMASK_DISPLAYNAME (0x01u << 6u) +#define UA_WRITEMASK_EVENTNOTIFIER (0x01u << 7u) +#define UA_WRITEMASK_EXECUTABLE (0x01u << 8u) +#define UA_WRITEMASK_HISTORIZING (0x01u << 9u) +#define UA_WRITEMASK_INVERSENAME (0x01u << 10u) +#define UA_WRITEMASK_ISABSTRACT (0x01u << 11u) +#define UA_WRITEMASK_MINIMUMSAMPLINGINTERVAL (0x01u << 12u) +#define UA_WRITEMASK_NODECLASS (0x01u << 13u) +#define UA_WRITEMASK_NODEID (0x01u << 14u) +#define UA_WRITEMASK_SYMMETRIC (0x01u << 15u) +#define UA_WRITEMASK_USERACCESSLEVEL (0x01u << 16u) +#define UA_WRITEMASK_USEREXECUTABLE (0x01u << 17u) +#define UA_WRITEMASK_USERWRITEMASK (0x01u << 18u) +#define UA_WRITEMASK_VALUERANK (0x01u << 19u) +#define UA_WRITEMASK_WRITEMASK (0x01u << 20u) +#define UA_WRITEMASK_VALUEFORVARIABLETYPE (0x01u << 21u) + +/** + * ValueRanks + * ---------- + * The following are the most common ValueRanks used for Variables, + * VariableTypes and method arguments. ValueRanks higher than 3 are valid as + * well (but less common). */ + +#define UA_VALUERANK_SCALAR_OR_ONE_DIMENSION -3 +#define UA_VALUERANK_ANY -2 +#define UA_VALUERANK_SCALAR -1 +#define UA_VALUERANK_ONE_OR_MORE_DIMENSIONS 0 +#define UA_VALUERANK_ONE_DIMENSION 1 +#define UA_VALUERANK_TWO_DIMENSIONS 2 +#define UA_VALUERANK_THREE_DIMENSIONS 3 + +/** + * EventNotifier + * ------------- + * The following are the available EventNotifier used for Nodes. + * The EventNotifier Attribute is used to indicate if the Node can be used + * to subscribe to Events or to read / write historic Events. + * Part 3: 5.4 Table 10 */ + +#define UA_EVENTNOTIFIER_SUBSCRIBE_TO_EVENT (0x01u << 0u) +#define UA_EVENTNOTIFIER_HISTORY_READ (0x01u << 2u) +#define UA_EVENTNOTIFIER_HISTORY_WRITE (0x01u << 3u) + +/** + * Rule Handling + * ------------- + * + * The RuleHanding settings define how error cases that result from rules in the + * OPC UA specification shall be handled. The rule handling can be softened, + * e.g. to workaround misbehaving implementations or to mitigate the impact of + * additional rules that are introduced in later versions of the OPC UA + * specification. */ +typedef enum { + UA_RULEHANDLING_DEFAULT = 0, + UA_RULEHANDLING_ABORT, /* Abort the operation and return an error code */ + UA_RULEHANDLING_WARN, /* Print a message in the logs and continue */ + UA_RULEHANDLING_ACCEPT, /* Continue and disregard the broken rule */ +} UA_RuleHandling; + +/** + * Order + * ----- + * + * The Order enum is used to establish an absolute ordering between elements. + */ + +typedef enum { + UA_ORDER_LESS = -1, + UA_ORDER_EQ = 0, + UA_ORDER_MORE = 1 +} UA_Order; + +/** + * Connection State + * ---------------- */ + +typedef enum { + UA_SECURECHANNELSTATE_FRESH = 0, + UA_SECURECHANNELSTATE_HEL_SENT, + UA_SECURECHANNELSTATE_HEL_RECEIVED, + UA_SECURECHANNELSTATE_ACK_SENT, + UA_SECURECHANNELSTATE_ACK_RECEIVED, + UA_SECURECHANNELSTATE_OPN_SENT, + UA_SECURECHANNELSTATE_OPEN, + UA_SECURECHANNELSTATE_CLOSING, + UA_SECURECHANNELSTATE_CLOSED +} UA_SecureChannelState; + +typedef enum { + UA_SESSIONSTATE_CLOSED, + UA_SESSIONSTATE_CREATE_REQUESTED, + UA_SESSIONSTATE_CREATED, + UA_SESSIONSTATE_ACTIVATE_REQUESTED, + UA_SESSIONSTATE_ACTIVATED, + UA_SESSIONSTATE_CLOSING +} UA_SessionState; + +/** + * Statistic counters + * ------------------ + * + * The stack manages statistic counters for the following layers: + * + * - Network + * - Secure channel + * - Session + * + * The session layer counters are matching the counters of the + * ServerDiagnosticsSummaryDataType that are defined in the OPC UA Part 5 + * specification. Counters of the other layers are not specified by OPC UA but + * are harmonized with the session layer counters if possible. */ + +typedef struct { + size_t currentConnectionCount; + size_t cumulatedConnectionCount; + size_t rejectedConnectionCount; + size_t connectionTimeoutCount; + size_t connectionAbortCount; +} UA_NetworkStatistics; + +typedef struct { + size_t currentChannelCount; + size_t cumulatedChannelCount; + size_t rejectedChannelCount; + size_t channelTimeoutCount; /* only used by servers */ + size_t channelAbortCount; + size_t channelPurgeCount; /* only used by servers */ +} UA_SecureChannelStatistics; + +typedef struct { + size_t currentSessionCount; + size_t cumulatedSessionCount; + size_t securityRejectedSessionCount; /* only used by servers */ + size_t rejectedSessionCount; + size_t sessionTimeoutCount; /* only used by servers */ + size_t sessionAbortCount; /* only used by servers */ +} UA_SessionStatistics; + +/** + * .. include:: util.rst */ + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/types.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014 (c) Leon Urbas + * Copyright 2014, 2016-2017 (c) Florian Palm + * Copyright 2014-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015 (c) Nick Goossens + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Thomas Stalder, Blue Time Concept SA + */ + + + +_UA_BEGIN_DECLS + +#define UA_BUILTIN_TYPES_COUNT 25U + +/** + * .. _types: + * + * Data Types + * ========== + * + * The OPC UA protocol defines 25 builtin data types and three ways of combining + * them into higher-order types: arrays, structures and unions. In open62541, + * only the builtin data types are defined manually. All other data types are + * generated from standard XML definitions. Their exact definitions can be + * looked up at https://opcfoundation.org/UA/schemas/Opc.Ua.Types.bsd. + * + * For users that are new to open62541, take a look at the :ref:`tutorial for + * working with data types` before diving into the + * implementation details. + * + * Builtin Types + * ------------- + * + * Boolean + * ^^^^^^^ + * A two-state logical value (true or false). */ +typedef bool UA_Boolean; +#define UA_TRUE true UA_INTERNAL_DEPRECATED +#define UA_FALSE false UA_INTERNAL_DEPRECATED + +/** + * SByte + * ^^^^^ + * An integer value between -128 and 127. */ +typedef int8_t UA_SByte; +#define UA_SBYTE_MIN (-128) +#define UA_SBYTE_MAX 127 + +/** + * Byte + * ^^^^ + * An integer value between 0 and 255. */ +typedef uint8_t UA_Byte; +#define UA_BYTE_MIN 0 +#define UA_BYTE_MAX 255 + +/** + * Int16 + * ^^^^^ + * An integer value between -32 768 and 32 767. */ +typedef int16_t UA_Int16; +#define UA_INT16_MIN (-32768) +#define UA_INT16_MAX 32767 + +/** + * UInt16 + * ^^^^^^ + * An integer value between 0 and 65 535. */ +typedef uint16_t UA_UInt16; +#define UA_UINT16_MIN 0 +#define UA_UINT16_MAX 65535 + +/** + * Int32 + * ^^^^^ + * An integer value between -2 147 483 648 and 2 147 483 647. */ +typedef int32_t UA_Int32; +#define UA_INT32_MIN (-2147483648) +#define UA_INT32_MAX 2147483647 + +/** + * UInt32 + * ^^^^^^ + * An integer value between 0 and 4 294 967 295. */ +typedef uint32_t UA_UInt32; +#define UA_UINT32_MIN 0 +#define UA_UINT32_MAX 4294967295 + +/** + * Int64 + * ^^^^^ + * An integer value between -9 223 372 036 854 775 808 and + * 9 223 372 036 854 775 807. */ +typedef int64_t UA_Int64; +#define UA_INT64_MAX (int64_t)9223372036854775807LL +#define UA_INT64_MIN ((int64_t)-UA_INT64_MAX-1LL) + +/** + * UInt64 + * ^^^^^^ + * An integer value between 0 and 18 446 744 073 709 551 615. */ +typedef uint64_t UA_UInt64; +#define UA_UINT64_MIN (uint64_t)0 +#define UA_UINT64_MAX (uint64_t)18446744073709551615ULL + +/** + * Float + * ^^^^^ + * An IEEE single precision (32 bit) floating point value. */ +typedef float UA_Float; + +/** + * Double + * ^^^^^^ + * An IEEE double precision (64 bit) floating point value. */ +typedef double UA_Double; + +/** + * .. _statuscode: + * + * StatusCode + * ^^^^^^^^^^ + * A numeric identifier for an error or condition that is associated with a + * value or an operation. See the section :ref:`statuscodes` for the meaning of + * a specific code. */ +typedef uint32_t UA_StatusCode; + +/* Returns the human-readable name of the StatusCode. If no matching StatusCode + * is found, a default string for "Unknown" is returned. This feature might be + * disabled to create a smaller binary with the + * UA_ENABLE_STATUSCODE_DESCRIPTIONS build-flag. Then the function returns an + * empty string for every StatusCode. */ +UA_EXPORT const char * +UA_StatusCode_name(UA_StatusCode code); + +/** + * String + * ^^^^^^ + * A sequence of Unicode characters. Strings are just an array of UA_Byte. */ +typedef struct { + size_t length; /* The length of the string */ + UA_Byte *data; /* The content (not null-terminated) */ +} UA_String; + +/* Copies the content on the heap. Returns a null-string when alloc fails */ +UA_String UA_EXPORT +UA_String_fromChars(const char *src) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +UA_Boolean UA_EXPORT +UA_String_equal(const UA_String *s1, const UA_String *s2); + +UA_EXPORT extern const UA_String UA_STRING_NULL; + +/** + * ``UA_STRING`` returns a string pointing to the original char-array. + * ``UA_STRING_ALLOC`` is shorthand for ``UA_String_fromChars`` and makes a copy + * of the char-array. */ +static UA_INLINE UA_String +UA_STRING(char *chars) { + UA_String s; s.length = 0; s.data = NULL; + if(!chars) + return s; + s.length = strlen(chars); s.data = (UA_Byte*)chars; return s; +} + +#define UA_STRING_ALLOC(CHARS) UA_String_fromChars(CHARS) + +/* Define strings at compile time (in ROM) */ +#define UA_STRING_STATIC(CHARS) {sizeof(CHARS)-1, (UA_Byte*)CHARS} + +/** + * .. _datetime: + * + * DateTime + * ^^^^^^^^ + * An instance in time. A DateTime value is encoded as a 64-bit signed integer + * which represents the number of 100 nanosecond intervals since January 1, 1601 + * (UTC). + * + * The methods providing an interface to the system clock are architecture- + * specific. Usually, they provide a UTC clock that includes leap seconds. The + * OPC UA standard allows the use of International Atomic Time (TAI) for the + * DateTime instead. But this is still unusual and not implemented for most + * SDKs. Currently (2019), UTC and TAI are 37 seconds apart due to leap + * seconds. */ + +typedef int64_t UA_DateTime; + +/* Multiples to convert durations to DateTime */ +#define UA_DATETIME_USEC 10LL +#define UA_DATETIME_MSEC (UA_DATETIME_USEC * 1000LL) +#define UA_DATETIME_SEC (UA_DATETIME_MSEC * 1000LL) + +/* The current time in UTC time */ +UA_DateTime UA_EXPORT UA_DateTime_now(void); + +/* Offset between local time and UTC time */ +UA_Int64 UA_EXPORT UA_DateTime_localTimeUtcOffset(void); + +/* CPU clock invariant to system time changes. Use only to measure durations, + * not absolute time. */ +UA_DateTime UA_EXPORT UA_DateTime_nowMonotonic(void); + +/* Represents a Datetime as a structure */ +typedef struct UA_DateTimeStruct { + UA_UInt16 nanoSec; + UA_UInt16 microSec; + UA_UInt16 milliSec; + UA_UInt16 sec; + UA_UInt16 min; + UA_UInt16 hour; + UA_UInt16 day; /* From 1 to 31 */ + UA_UInt16 month; /* From 1 to 12 */ + UA_UInt16 year; +} UA_DateTimeStruct; + +UA_DateTimeStruct UA_EXPORT UA_DateTime_toStruct(UA_DateTime t); +UA_DateTime UA_EXPORT UA_DateTime_fromStruct(UA_DateTimeStruct ts); + +/* The C99 standard (7.23.1) says: "The range and precision of times + * representable in clock_t and time_t are implementation-defined." On most + * systems, time_t is a 4 or 8 byte integer counting seconds since the UTC Unix + * epoch. The following methods are used for conversion. */ + +/* Datetime of 1 Jan 1970 00:00 */ +#define UA_DATETIME_UNIX_EPOCH (11644473600LL * UA_DATETIME_SEC) + +static UA_INLINE UA_Int64 +UA_DateTime_toUnixTime(UA_DateTime date) { + return (date - UA_DATETIME_UNIX_EPOCH) / UA_DATETIME_SEC; +} + +static UA_INLINE UA_DateTime +UA_DateTime_fromUnixTime(UA_Int64 unixDate) { + return (unixDate * UA_DATETIME_SEC) + UA_DATETIME_UNIX_EPOCH; +} + +/** + * Guid + * ^^^^ + * A 16 byte value that can be used as a globally unique identifier. */ +typedef struct { + UA_UInt32 data1; + UA_UInt16 data2; + UA_UInt16 data3; + UA_Byte data4[8]; +} UA_Guid; + +UA_EXPORT extern const UA_Guid UA_GUID_NULL; + +UA_Boolean UA_EXPORT UA_Guid_equal(const UA_Guid *g1, const UA_Guid *g2); + +#ifdef UA_ENABLE_PARSING +/* Parse the Guid format defined in Part 6, 5.1.3. + * Format: C496578A-0DFE-4B8F-870A-745238C6AEAE + * | | | | | | + * 0 8 13 18 23 36 */ +UA_StatusCode UA_EXPORT +UA_Guid_parse(UA_Guid *guid, const UA_String str); + +static UA_INLINE UA_Guid +UA_GUID(const char *chars) { + UA_Guid guid; + UA_Guid_parse(&guid, UA_STRING((char*)(uintptr_t)chars)); + return guid; +} +#endif + +/** + * ByteString + * ^^^^^^^^^^ + * A sequence of octets. */ +typedef UA_String UA_ByteString; + +UA_EXPORT extern const UA_ByteString UA_BYTESTRING_NULL; + +/* Allocates memory of size length for the bytestring. + * The content is not set to zero. */ +UA_StatusCode UA_EXPORT +UA_ByteString_allocBuffer(UA_ByteString *bs, size_t length); + +/* Converts a ByteString to the corresponding + * base64 representation */ +UA_StatusCode UA_EXPORT +UA_ByteString_toBase64(const UA_ByteString *bs, + UA_String *output); + +/* Parse a ByteString from a base64 representation */ +UA_StatusCode UA_EXPORT +UA_ByteString_fromBase64(UA_ByteString *bs, + const UA_String *input); + +static UA_INLINE UA_ByteString +UA_BYTESTRING(char *chars) { + UA_ByteString bs; bs.length = 0; bs.data = NULL; + if(!chars) + return bs; + bs.length = strlen(chars); bs.data = (UA_Byte*)chars; return bs; +} + +static UA_INLINE UA_ByteString +UA_BYTESTRING_ALLOC(const char *chars) { + UA_String str = UA_String_fromChars(chars); UA_ByteString bstr; + bstr.length = str.length; bstr.data = str.data; return bstr; +} + +static UA_INLINE UA_Boolean +UA_ByteString_equal(const UA_ByteString *string1, + const UA_ByteString *string2) { + return UA_String_equal((const UA_String*)string1, + (const UA_String*)string2); +} + +/* Returns a non-cryptographic hash of a bytestring */ +UA_UInt32 UA_EXPORT +UA_ByteString_hash(UA_UInt32 initialHashValue, + const UA_Byte *data, size_t size); + +/** + * XmlElement + * ^^^^^^^^^^ + * An XML element. */ +typedef UA_String UA_XmlElement; + +/** + * .. _nodeid: + * + * NodeId + * ^^^^^^ + * An identifier for a node in the address space of an OPC UA Server. */ +enum UA_NodeIdType { + UA_NODEIDTYPE_NUMERIC = 0, /* In the binary encoding, this can also + * become 1 or 2 (two-byte and four-byte + * encoding of small numeric nodeids) */ + UA_NODEIDTYPE_STRING = 3, + UA_NODEIDTYPE_GUID = 4, + UA_NODEIDTYPE_BYTESTRING = 5 +}; + +typedef struct { + UA_UInt16 namespaceIndex; + enum UA_NodeIdType identifierType; + union { + UA_UInt32 numeric; + UA_String string; + UA_Guid guid; + UA_ByteString byteString; + } identifier; +} UA_NodeId; + +UA_EXPORT extern const UA_NodeId UA_NODEID_NULL; + +UA_Boolean UA_EXPORT UA_NodeId_isNull(const UA_NodeId *p); + +/* Print the NodeId in the human-readable format defined in Part 6, + * 5.3.1.10. + * + * Examples: + * UA_NODEID("i=13") + * UA_NODEID("ns=10;i=1") + * UA_NODEID("ns=10;s=Hello:World") + * UA_NODEID("g=09087e75-8e5e-499b-954f-f2a9603db28a") + * UA_NODEID("ns=1;b=b3BlbjYyNTQxIQ==") // base64 + * */ +UA_StatusCode UA_EXPORT +UA_NodeId_print(const UA_NodeId *id, UA_String *output); + +#ifdef UA_ENABLE_PARSING +/* Parse the human-readable NodeId format. Attention! String and + * ByteString NodeIds have their identifier malloc'ed and need to be + * cleaned up. */ +UA_StatusCode UA_EXPORT +UA_NodeId_parse(UA_NodeId *id, const UA_String str); + +static UA_INLINE UA_NodeId +UA_NODEID(const char *chars) { + UA_NodeId id; + UA_NodeId_parse(&id, UA_STRING((char*)(uintptr_t)chars)); + return id; +} +#endif + +/** The following functions are shorthand for creating NodeIds. */ +static UA_INLINE UA_NodeId +UA_NODEID_NUMERIC(UA_UInt16 nsIndex, UA_UInt32 identifier) { + UA_NodeId id; id.namespaceIndex = nsIndex; + id.identifierType = UA_NODEIDTYPE_NUMERIC; + id.identifier.numeric = identifier; return id; +} + +static UA_INLINE UA_NodeId +UA_NODEID_STRING(UA_UInt16 nsIndex, char *chars) { + UA_NodeId id; id.namespaceIndex = nsIndex; + id.identifierType = UA_NODEIDTYPE_STRING; + id.identifier.string = UA_STRING(chars); return id; +} + +static UA_INLINE UA_NodeId +UA_NODEID_STRING_ALLOC(UA_UInt16 nsIndex, const char *chars) { + UA_NodeId id; id.namespaceIndex = nsIndex; + id.identifierType = UA_NODEIDTYPE_STRING; + id.identifier.string = UA_STRING_ALLOC(chars); return id; +} + +static UA_INLINE UA_NodeId +UA_NODEID_GUID(UA_UInt16 nsIndex, UA_Guid guid) { + UA_NodeId id; id.namespaceIndex = nsIndex; + id.identifierType = UA_NODEIDTYPE_GUID; + id.identifier.guid = guid; return id; +} + +static UA_INLINE UA_NodeId +UA_NODEID_BYTESTRING(UA_UInt16 nsIndex, char *chars) { + UA_NodeId id; id.namespaceIndex = nsIndex; + id.identifierType = UA_NODEIDTYPE_BYTESTRING; + id.identifier.byteString = UA_BYTESTRING(chars); return id; +} + +static UA_INLINE UA_NodeId +UA_NODEID_BYTESTRING_ALLOC(UA_UInt16 nsIndex, const char *chars) { + UA_NodeId id; id.namespaceIndex = nsIndex; + id.identifierType = UA_NODEIDTYPE_BYTESTRING; + id.identifier.byteString = UA_BYTESTRING_ALLOC(chars); return id; +} + +/* Total ordering of NodeId */ +UA_Order UA_EXPORT +UA_NodeId_order(const UA_NodeId *n1, const UA_NodeId *n2); + +/* Check for equality */ +static UA_INLINE UA_Boolean +UA_NodeId_equal(const UA_NodeId *n1, const UA_NodeId *n2) { + return (UA_NodeId_order(n1, n2) == UA_ORDER_EQ); +} + +/* Returns a non-cryptographic hash for NodeId */ +UA_UInt32 UA_EXPORT UA_NodeId_hash(const UA_NodeId *n); + +/** + * ExpandedNodeId + * ^^^^^^^^^^^^^^ + * A NodeId that allows the namespace URI to be specified instead of an index. */ +typedef struct { + UA_NodeId nodeId; + UA_String namespaceUri; + UA_UInt32 serverIndex; +} UA_ExpandedNodeId; + +UA_EXPORT extern const UA_ExpandedNodeId UA_EXPANDEDNODEID_NULL; + +UA_StatusCode UA_EXPORT +UA_ExpandedNodeId_print(const UA_ExpandedNodeId *id, UA_String *output); + +#ifdef UA_ENABLE_PARSING +/* Parse the ExpandedNodeId format defined in Part 6, 5.3.1.11: + * + * svr=;ns=;= + * or + * svr=;nsu=;= + * + * The definitions for svr, ns and nsu can be omitted and will be set to zero / + * the empty string.*/ +UA_StatusCode UA_EXPORT +UA_ExpandedNodeId_parse(UA_ExpandedNodeId *id, const UA_String str); + +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID(const char *chars) { + UA_ExpandedNodeId id; + UA_ExpandedNodeId_parse(&id, UA_STRING((char*)(uintptr_t)chars)); + return id; +} +#endif + +/** The following functions are shorthand for creating ExpandedNodeIds. */ +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID_NUMERIC(UA_UInt16 nsIndex, UA_UInt32 identifier) { + UA_ExpandedNodeId id; id.nodeId = UA_NODEID_NUMERIC(nsIndex, identifier); + id.serverIndex = 0; id.namespaceUri = UA_STRING_NULL; return id; +} + +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID_STRING(UA_UInt16 nsIndex, char *chars) { + UA_ExpandedNodeId id; id.nodeId = UA_NODEID_STRING(nsIndex, chars); + id.serverIndex = 0; id.namespaceUri = UA_STRING_NULL; return id; +} + +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID_STRING_ALLOC(UA_UInt16 nsIndex, const char *chars) { + UA_ExpandedNodeId id; id.nodeId = UA_NODEID_STRING_ALLOC(nsIndex, chars); + id.serverIndex = 0; id.namespaceUri = UA_STRING_NULL; return id; +} + +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID_STRING_GUID(UA_UInt16 nsIndex, UA_Guid guid) { + UA_ExpandedNodeId id; id.nodeId = UA_NODEID_GUID(nsIndex, guid); + id.serverIndex = 0; id.namespaceUri = UA_STRING_NULL; return id; +} + +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID_BYTESTRING(UA_UInt16 nsIndex, char *chars) { + UA_ExpandedNodeId id; id.nodeId = UA_NODEID_BYTESTRING(nsIndex, chars); + id.serverIndex = 0; id.namespaceUri = UA_STRING_NULL; return id; +} + +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID_BYTESTRING_ALLOC(UA_UInt16 nsIndex, const char *chars) { + UA_ExpandedNodeId id; id.nodeId = UA_NODEID_BYTESTRING_ALLOC(nsIndex, chars); + id.serverIndex = 0; id.namespaceUri = UA_STRING_NULL; return id; +} + +static UA_INLINE UA_ExpandedNodeId +UA_EXPANDEDNODEID_NODEID(UA_NodeId nodeId) { + UA_ExpandedNodeId id = {0}; id.nodeId = nodeId; return id; +} + +/* Does the ExpandedNodeId point to a local node? That is, are namespaceUri and + * serverIndex empty? */ +UA_Boolean UA_EXPORT +UA_ExpandedNodeId_isLocal(const UA_ExpandedNodeId *n); + +/* Total ordering of ExpandedNodeId */ +UA_Order UA_EXPORT +UA_ExpandedNodeId_order(const UA_ExpandedNodeId *n1, + const UA_ExpandedNodeId *n2); + +/* Check for equality */ +static UA_INLINE UA_Boolean +UA_ExpandedNodeId_equal(const UA_ExpandedNodeId *n1, + const UA_ExpandedNodeId *n2) { + return (UA_ExpandedNodeId_order(n1, n2) == UA_ORDER_EQ); +} + +/* Returns a non-cryptographic hash for ExpandedNodeId. The hash of an + * ExpandedNodeId is identical to the hash of the embedded (simple) NodeId if + * the ServerIndex is zero and no NamespaceUri is set. */ +UA_UInt32 UA_EXPORT +UA_ExpandedNodeId_hash(const UA_ExpandedNodeId *n); + +/** + * .. _qualifiedname: + * + * QualifiedName + * ^^^^^^^^^^^^^ + * A name qualified by a namespace. */ +typedef struct { + UA_UInt16 namespaceIndex; + UA_String name; +} UA_QualifiedName; + +static UA_INLINE UA_Boolean +UA_QualifiedName_isNull(const UA_QualifiedName *q) { + return (q->namespaceIndex == 0 && q->name.length == 0); +} + +/* Returns a non-cryptographic hash for QualifiedName */ +UA_UInt32 UA_EXPORT +UA_QualifiedName_hash(const UA_QualifiedName *q); + +static UA_INLINE UA_QualifiedName +UA_QUALIFIEDNAME(UA_UInt16 nsIndex, char *chars) { + UA_QualifiedName qn; qn.namespaceIndex = nsIndex; + qn.name = UA_STRING(chars); return qn; +} + +static UA_INLINE UA_QualifiedName +UA_QUALIFIEDNAME_ALLOC(UA_UInt16 nsIndex, const char *chars) { + UA_QualifiedName qn; qn.namespaceIndex = nsIndex; + qn.name = UA_STRING_ALLOC(chars); return qn; +} + +UA_Boolean UA_EXPORT +UA_QualifiedName_equal(const UA_QualifiedName *qn1, + const UA_QualifiedName *qn2); + +/** + * LocalizedText + * ^^^^^^^^^^^^^ + * Human readable text with an optional locale identifier. */ +typedef struct { + UA_String locale; + UA_String text; +} UA_LocalizedText; + +static UA_INLINE UA_LocalizedText +UA_LOCALIZEDTEXT(char *locale, char *text) { + UA_LocalizedText lt; lt.locale = UA_STRING(locale); + lt.text = UA_STRING(text); return lt; +} + +static UA_INLINE UA_LocalizedText +UA_LOCALIZEDTEXT_ALLOC(const char *locale, const char *text) { + UA_LocalizedText lt; lt.locale = UA_STRING_ALLOC(locale); + lt.text = UA_STRING_ALLOC(text); return lt; +} + +/* + * Check if the StatusCode is bad. + * @return Returns UA_TRUE if StatusCode is bad, else UA_FALSE. */ +UA_EXPORT UA_Boolean +UA_StatusCode_isBad(const UA_StatusCode code); + +/** + * .. _numericrange: + * + * NumericRange + * ^^^^^^^^^^^^ + * + * NumericRanges are used to indicate subsets of a (multidimensional) array. + * They no official data type in the OPC UA standard and are transmitted only + * with a string encoding, such as "1:2,0:3,5". The colon separates min/max + * index and the comma separates dimensions. A single value indicates a range + * with a single element (min==max). */ +typedef struct { + UA_UInt32 min; + UA_UInt32 max; +} UA_NumericRangeDimension; + +typedef struct { + size_t dimensionsSize; + UA_NumericRangeDimension *dimensions; +} UA_NumericRange; + +UA_StatusCode UA_EXPORT +UA_NumericRange_parse(UA_NumericRange *range, const UA_String str); + +static UA_INLINE UA_NumericRange +UA_NUMERICRANGE(const char *s) { + UA_NumericRange nr; nr.dimensionsSize = 0; nr.dimensions = NULL; + UA_NumericRange_parse(&nr, UA_STRING((char*)(uintptr_t)s)); return nr; +} + +UA_DEPRECATED static UA_INLINE UA_StatusCode +UA_NumericRange_parseFromString(UA_NumericRange *range, const UA_String *str) { + return UA_NumericRange_parse(range, *str); +} + +/** + * .. _variant: + * + * Variant + * ^^^^^^^ + * + * Variants may contain values of any type together with a description of the + * content. See the section on :ref:`generic-types` on how types are described. + * The standard mandates that variants contain built-in data types only. If the + * value is not of a builtin type, it is wrapped into an :ref:`extensionobject`. + * open62541 hides this wrapping transparently in the encoding layer. If the + * data type is unknown to the receiver, the variant contains the original + * ExtensionObject in binary or XML encoding. + * + * Variants may contain a scalar value or an array. For details on the handling + * of arrays, see the section on :ref:`array-handling`. Array variants can have + * an additional dimensionality (matrix, 3-tensor, ...) defined in an array of + * dimension lengths. The actual values are kept in an array of dimensions one. + * For users who work with higher-dimensions arrays directly, keep in mind that + * dimensions of higher rank are serialized first (the highest rank dimension + * has stride 1 and elements follow each other directly). Usually it is simplest + * to interact with higher-dimensional arrays via ``UA_NumericRange`` + * descriptions (see :ref:`array-handling`). + * + * To differentiate between scalar / array variants, the following definition is + * used. ``UA_Variant_isScalar`` provides simplified access to these checks. + * + * - ``arrayLength == 0 && data == NULL``: undefined array of length -1 + * - ``arrayLength == 0 && data == UA_EMPTY_ARRAY_SENTINEL``: array of length 0 + * - ``arrayLength == 0 && data > UA_EMPTY_ARRAY_SENTINEL``: scalar value + * - ``arrayLength > 0``: array of the given length + * + * Variants can also be *empty*. Then, the pointer to the type description is + * ``NULL``. */ +/* Forward declaration. See the section on Generic Type Handling */ +struct UA_DataType; +typedef struct UA_DataType UA_DataType; + +#define UA_EMPTY_ARRAY_SENTINEL ((void*)0x01) + +typedef enum { + UA_VARIANT_DATA, /* The data has the same lifecycle as the variant */ + UA_VARIANT_DATA_NODELETE /* The data is "borrowed" by the variant and is + * not deleted when the variant is cleared up. + * The array dimensions also borrowed. */ +} UA_VariantStorageType; + +typedef struct { + const UA_DataType *type; /* The data type description */ + UA_VariantStorageType storageType; + size_t arrayLength; /* The number of elements in the data array */ + void *data; /* Points to the scalar or array data */ + size_t arrayDimensionsSize; /* The number of dimensions */ + UA_UInt32 *arrayDimensions; /* The length of each dimension */ +} UA_Variant; + +/* Returns true if the variant has no value defined (contains neither an array + * nor a scalar value). + * + * @param v The variant + * @return Is the variant empty */ +static UA_INLINE UA_Boolean +UA_Variant_isEmpty(const UA_Variant *v) { + return v->type == NULL; +} + +/* Returns true if the variant contains a scalar value. Note that empty variants + * contain an array of length -1 (undefined). + * + * @param v The variant + * @return Does the variant contain a scalar value */ +static UA_INLINE UA_Boolean +UA_Variant_isScalar(const UA_Variant *v) { + return (v->arrayLength == 0 && v->data > UA_EMPTY_ARRAY_SENTINEL); +} + +/* Returns true if the variant contains a scalar value of the given type. + * + * @param v The variant + * @param type The data type + * @return Does the variant contain a scalar value of the given type */ +static UA_INLINE UA_Boolean +UA_Variant_hasScalarType(const UA_Variant *v, const UA_DataType *type) { + return UA_Variant_isScalar(v) && type == v->type; +} + +/* Returns true if the variant contains an array of the given type. + * + * @param v The variant + * @param type The data type + * @return Does the variant contain an array of the given type */ +static UA_INLINE UA_Boolean +UA_Variant_hasArrayType(const UA_Variant *v, const UA_DataType *type) { + return (!UA_Variant_isScalar(v)) && type == v->type; +} + +/* Set the variant to a scalar value that already resides in memory. The value + * takes on the lifecycle of the variant and is deleted with it. + * + * @param v The variant + * @param p A pointer to the value data + * @param type The datatype of the value in question */ +void UA_EXPORT +UA_Variant_setScalar(UA_Variant *v, void * UA_RESTRICT p, + const UA_DataType *type); + +/* Set the variant to a scalar value that is copied from an existing variable. + * @param v The variant + * @param p A pointer to the value data + * @param type The datatype of the value + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Variant_setScalarCopy(UA_Variant *v, const void * UA_RESTRICT p, + const UA_DataType *type); + +/* Set the variant to an array that already resides in memory. The array takes + * on the lifecycle of the variant and is deleted with it. + * + * @param v The variant + * @param array A pointer to the array data + * @param arraySize The size of the array + * @param type The datatype of the array */ +void UA_EXPORT +UA_Variant_setArray(UA_Variant *v, void * UA_RESTRICT array, + size_t arraySize, const UA_DataType *type); + +/* Set the variant to an array that is copied from an existing array. + * + * @param v The variant + * @param array A pointer to the array data + * @param arraySize The size of the array + * @param type The datatype of the array + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Variant_setArrayCopy(UA_Variant *v, const void * UA_RESTRICT array, + size_t arraySize, const UA_DataType *type); + +/* Copy the variant, but use only a subset of the (multidimensional) array into + * a variant. Returns an error code if the variant is not an array or if the + * indicated range does not fit. + * + * @param src The source variant + * @param dst The target variant + * @param range The range of the copied data + * @return Returns UA_STATUSCODE_GOOD or an error code */ +UA_StatusCode UA_EXPORT +UA_Variant_copyRange(const UA_Variant *src, UA_Variant * UA_RESTRICT dst, + const UA_NumericRange range); + +/* Insert a range of data into an existing variant. The data array cannot be + * reused afterwards if it contains types without a fixed size (e.g. strings) + * since the members are moved into the variant and take on its lifecycle. + * + * @param v The variant + * @param dataArray The data array. The type must match the variant + * @param dataArraySize The length of the data array. This is checked to match + * the range size. + * @param range The range of where the new data is inserted + * @return Returns UA_STATUSCODE_GOOD or an error code */ +UA_StatusCode UA_EXPORT +UA_Variant_setRange(UA_Variant *v, void * UA_RESTRICT array, + size_t arraySize, const UA_NumericRange range); + +/* Deep-copy a range of data into an existing variant. + * + * @param v The variant + * @param dataArray The data array. The type must match the variant + * @param dataArraySize The length of the data array. This is checked to match + * the range size. + * @param range The range of where the new data is inserted + * @return Returns UA_STATUSCODE_GOOD or an error code */ +UA_StatusCode UA_EXPORT +UA_Variant_setRangeCopy(UA_Variant *v, const void * UA_RESTRICT array, + size_t arraySize, const UA_NumericRange range); + +/** + * .. _extensionobject: + * + * ExtensionObject + * ^^^^^^^^^^^^^^^ + * + * ExtensionObjects may contain scalars of any data type. Even those that are + * unknown to the receiver. See the section on :ref:`generic-types` on how types + * are described. If the received data type is unknown, the encoded string and + * target NodeId is stored instead of the decoded value. */ +typedef enum { + UA_EXTENSIONOBJECT_ENCODED_NOBODY = 0, + UA_EXTENSIONOBJECT_ENCODED_BYTESTRING = 1, + UA_EXTENSIONOBJECT_ENCODED_XML = 2, + UA_EXTENSIONOBJECT_DECODED = 3, + UA_EXTENSIONOBJECT_DECODED_NODELETE = 4 /* Don't delete the content + together with the + ExtensionObject */ +} UA_ExtensionObjectEncoding; + +typedef struct { + UA_ExtensionObjectEncoding encoding; + union { + struct { + UA_NodeId typeId; /* The nodeid of the datatype */ + UA_ByteString body; /* The bytestring of the encoded data */ + } encoded; + struct { + const UA_DataType *type; + void *data; + } decoded; + } content; +} UA_ExtensionObject; + +/* Initialize the ExtensionObject and set the "decoded" value to the given + * pointer. The value will be deleted when the ExtensionObject is cleared. */ +void UA_EXPORT +UA_ExtensionObject_setValue(UA_ExtensionObject *eo, + void * UA_RESTRICT p, + const UA_DataType *type); + +/* Initialize the ExtensionObject and set the "decoded" value to the given + * pointer. The value will *not* be deleted when the ExtensionObject is + * cleared. */ +void UA_EXPORT +UA_ExtensionObject_setValueNoDelete(UA_ExtensionObject *eo, + void * UA_RESTRICT p, + const UA_DataType *type); + +/* Initialize the ExtensionObject and set the "decoded" value to a fresh copy of + * the given value pointer. The value will be deleted when the ExtensionObject + * is cleared. */ +UA_StatusCode UA_EXPORT +UA_ExtensionObject_setValueCopy(UA_ExtensionObject *eo, + void * UA_RESTRICT p, + const UA_DataType *type); + +/** + * .. _datavalue: + * + * DataValue + * ^^^^^^^^^ + * A data value with an associated status code and timestamps. */ +typedef struct { + UA_Variant value; + UA_DateTime sourceTimestamp; + UA_DateTime serverTimestamp; + UA_UInt16 sourcePicoseconds; + UA_UInt16 serverPicoseconds; + UA_StatusCode status; + UA_Boolean hasValue : 1; + UA_Boolean hasStatus : 1; + UA_Boolean hasSourceTimestamp : 1; + UA_Boolean hasServerTimestamp : 1; + UA_Boolean hasSourcePicoseconds : 1; + UA_Boolean hasServerPicoseconds : 1; +} UA_DataValue; + +/** + * DiagnosticInfo + * ^^^^^^^^^^^^^^ + * A structure that contains detailed error and diagnostic information + * associated with a StatusCode. */ +typedef struct UA_DiagnosticInfo { + UA_Boolean hasSymbolicId : 1; + UA_Boolean hasNamespaceUri : 1; + UA_Boolean hasLocalizedText : 1; + UA_Boolean hasLocale : 1; + UA_Boolean hasAdditionalInfo : 1; + UA_Boolean hasInnerStatusCode : 1; + UA_Boolean hasInnerDiagnosticInfo : 1; + UA_Int32 symbolicId; + UA_Int32 namespaceUri; + UA_Int32 localizedText; + UA_Int32 locale; + UA_String additionalInfo; + UA_StatusCode innerStatusCode; + struct UA_DiagnosticInfo *innerDiagnosticInfo; +} UA_DiagnosticInfo; + +/** + * .. _generic-types: + * + * Generic Type Handling + * --------------------- + * + * All information about a (builtin/structured) data type is stored in a + * ``UA_DataType``. The array ``UA_TYPES`` contains the description of all + * standard-defined types. This type description is used for the following + * generic operations that work on all types: + * + * - ``void T_init(T *ptr)``: Initialize the data type. This is synonymous with + * zeroing out the memory, i.e. ``memset(ptr, 0, sizeof(T))``. + * - ``T* T_new()``: Allocate and return the memory for the data type. The + * value is already initialized. + * - ``UA_StatusCode T_copy(const T *src, T *dst)``: Copy the content of the + * data type. Returns ``UA_STATUSCODE_GOOD`` or + * ``UA_STATUSCODE_BADOUTOFMEMORY``. + * - ``void T_clear(T *ptr)``: Delete the dynamically allocated content + * of the data type and perform a ``T_init`` to reset the type. + * - ``void T_delete(T *ptr)``: Delete the content of the data type and the + * memory for the data type itself. + * + * Specializations, such as ``UA_Int32_new()`` are derived from the generic + * type operations as static inline functions. */ + +typedef struct { +#ifdef UA_ENABLE_TYPEDESCRIPTION + const char *memberName; /* Human-readable member name */ +#endif + const UA_DataType *memberType;/* The member data type description */ + UA_Byte padding : 6; /* How much padding is there before this + member element? For arrays this is the + padding before the size_t length member. + (No padding between size_t and the + following ptr.) For unions, the padding + includes the size of the switchfield (the + offset from the start of the union + type). */ + UA_Byte isArray : 1; /* The member is an array */ + UA_Byte isOptional : 1; /* The member is an optional field */ +} UA_DataTypeMember; + +/* The DataType "kind" is an internal type classification. It is used to + * dispatch handling to the correct routines. */ +#define UA_DATATYPEKINDS 31 +typedef enum { + UA_DATATYPEKIND_BOOLEAN = 0, + UA_DATATYPEKIND_SBYTE = 1, + UA_DATATYPEKIND_BYTE = 2, + UA_DATATYPEKIND_INT16 = 3, + UA_DATATYPEKIND_UINT16 = 4, + UA_DATATYPEKIND_INT32 = 5, + UA_DATATYPEKIND_UINT32 = 6, + UA_DATATYPEKIND_INT64 = 7, + UA_DATATYPEKIND_UINT64 = 8, + UA_DATATYPEKIND_FLOAT = 9, + UA_DATATYPEKIND_DOUBLE = 10, + UA_DATATYPEKIND_STRING = 11, + UA_DATATYPEKIND_DATETIME = 12, + UA_DATATYPEKIND_GUID = 13, + UA_DATATYPEKIND_BYTESTRING = 14, + UA_DATATYPEKIND_XMLELEMENT = 15, + UA_DATATYPEKIND_NODEID = 16, + UA_DATATYPEKIND_EXPANDEDNODEID = 17, + UA_DATATYPEKIND_STATUSCODE = 18, + UA_DATATYPEKIND_QUALIFIEDNAME = 19, + UA_DATATYPEKIND_LOCALIZEDTEXT = 20, + UA_DATATYPEKIND_EXTENSIONOBJECT = 21, + UA_DATATYPEKIND_DATAVALUE = 22, + UA_DATATYPEKIND_VARIANT = 23, + UA_DATATYPEKIND_DIAGNOSTICINFO = 24, + UA_DATATYPEKIND_DECIMAL = 25, + UA_DATATYPEKIND_ENUM = 26, + UA_DATATYPEKIND_STRUCTURE = 27, + UA_DATATYPEKIND_OPTSTRUCT = 28, /* struct with optional fields */ + UA_DATATYPEKIND_UNION = 29, + UA_DATATYPEKIND_BITFIELDCLUSTER = 30 /* bitfields + padding */ +} UA_DataTypeKind; + +struct UA_DataType { +#ifdef UA_ENABLE_TYPEDESCRIPTION + const char *typeName; +#endif + UA_NodeId typeId; /* The nodeid of the type */ + UA_NodeId binaryEncodingId; /* NodeId of datatype when encoded as binary */ + //UA_NodeId xmlEncodingId; /* NodeId of datatype when encoded as XML */ + UA_UInt32 memSize : 16; /* Size of the struct in memory */ + UA_UInt32 typeKind : 6; /* Dispatch index for the handling routines */ + UA_UInt32 pointerFree : 1; /* The type (and its members) contains no + * pointers that need to be freed */ + UA_UInt32 overlayable : 1; /* The type has the identical memory layout + * in memory and on the binary stream. */ + UA_UInt32 membersSize : 8; /* How many members does the type have? */ + UA_DataTypeMember *members; +}; + +/* Datatype arrays with custom type definitions can be added in a linked list to + * the client or server configuration. */ +typedef struct UA_DataTypeArray { + const struct UA_DataTypeArray *next; + const size_t typesSize; + const UA_DataType *types; +} UA_DataTypeArray; + +/* Test if the data type is a numeric builtin data type (via the typeKind field + * of UA_DataType). This includes integers and floating point numbers. Not + * included are Boolean, DateTime, StatusCode and Enums. */ +UA_Boolean +UA_DataType_isNumeric(const UA_DataType *type); + +/** + * Builtin data types can be accessed as UA_TYPES[UA_TYPES_XXX], where XXX is + * the name of the data type. If only the NodeId of a type is known, use the + * following method to retrieve the data type description. */ + +/* Returns the data type description for the type's identifier or NULL if no + * matching data type was found. */ +const UA_DataType UA_EXPORT * +UA_findDataType(const UA_NodeId *typeId); + +/** The following functions are used for generic handling of data types. */ + +/* Allocates and initializes a variable of type dataType + * + * @param type The datatype description + * @return Returns the memory location of the variable or NULL if no + * memory could be allocated */ +void UA_EXPORT * UA_new(const UA_DataType *type) UA_FUNC_ATTR_MALLOC; + +/* Initializes a variable to default values + * + * @param p The memory location of the variable + * @param type The datatype description */ +static UA_INLINE void +UA_init(void *p, const UA_DataType *type) { + memset(p, 0, type->memSize); +} + +/* Copies the content of two variables. If copying fails (e.g. because no memory + * was available for an array), then dst is emptied and initialized to prevent + * memory leaks. + * + * @param src The memory location of the source variable + * @param dst The memory location of the destination variable + * @param type The datatype description + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_copy(const void *src, void *dst, const UA_DataType *type); + +/* Deletes the dynamically allocated content of a variable (e.g. resets all + * arrays to undefined arrays). Afterwards, the variable can be safely deleted + * without causing memory leaks. But the variable is not initialized and may + * contain old data that is not memory-relevant. + * + * @param p The memory location of the variable + * @param type The datatype description of the variable */ +void UA_EXPORT UA_clear(void *p, const UA_DataType *type); + +#define UA_deleteMembers(p, type) UA_clear(p, type) + +/* Frees a variable and all of its content. + * + * @param p The memory location of the variable + * @param type The datatype description of the variable */ +void UA_EXPORT UA_delete(void *p, const UA_DataType *type); + +/* Pretty-print the value from the datatype. + * + * @param p The memory location of the variable + * @param type The datatype description of the variable + * @param output A string that is memory-allocated for the pretty-printed output + * @return Indicates whether the operation succeeded*/ +#ifdef UA_ENABLE_TYPEDESCRIPTION +UA_StatusCode UA_EXPORT +UA_print(const void *p, const UA_DataType *type, UA_String *output); +#endif + +/* Compare two variables and return their order. This can also be used to test + * for equality of two values. + * + * For numerical types (including StatusCodes and Enums), their natural order is + * used. NaN is the "smallest" value for floating point values. Different bit + * representations of NaN are considered identical. + * + * All other types have *some* absolute ordering so that a < b, b < c -> a < c. + * + * The ordering of arrays (also strings) is in "shortlex": A shorter array is + * always smaller than a longer array. Otherwise the first different element + * defines the order. + * + * When members of different types are permitted (in Variants and + * ExtensionObjects), the memory address in the "UA_DataType*" pointer + * determines which variable is smaller. + * + * @param p1 The memory location of the first value + * @param p2 The memory location of the first value + * @param type The datatype description of both values */ +UA_Order UA_EXPORT +UA_order(const void *p1, const void *p2, const UA_DataType *type); + +/** + * Encoding/Decoding + * ^^^^^^^^^^^^^^^^^^ + * Encoding and decoding routines for the available formats. For all formats + * the _calcSize, _encode and _decode methods are provided. */ + +/* Returns the number of bytes the value p takes in binary encoding. Returns + * zero if an error occurs. */ +UA_EXPORT size_t +UA_calcSizeBinary(const void *p, const UA_DataType *type); + +/* Encodes a data-structure in the binary format. If outBuf has a length of + * zero, a buffer of the required size is allocated. Otherwise, encoding into + * the existing outBuf is attempted (and may fail if the buffer is too + * small). */ +UA_EXPORT UA_StatusCode +UA_encodeBinary(const void *p, const UA_DataType *type, + UA_ByteString *outBuf); + +/* The structure with the decoding options may be extended in the future. + * Zero-out the entire structure initially to ensure code-compatibility when + * more fields are added in a later release. */ +typedef struct { + const UA_DataTypeArray *customTypes; /* Begin of a linked list with custom + * datatype definitions */ +} UA_DecodeBinaryOptions; + +/* Decodes a data structure from the input buffer in the binary format. It is + * assumed that `p` points to valid memory (not necessarily zeroed out). The + * options can be NULL and will be disregarded in that case. */ +UA_EXPORT UA_StatusCode +UA_decodeBinary(const UA_ByteString *inBuf, + void *p, const UA_DataType *type, + const UA_DecodeBinaryOptions *options); + +typedef struct { + const UA_String *namespaces; + size_t namespacesSize; + const UA_String *serverUris; + size_t serverUrisSize; + UA_Boolean useReversible; +} UA_EncodeJsonOptions; + +/* Returns the number of bytes the value src takes in json encoding. Returns + * zero if an error occurs. */ +UA_EXPORT size_t +UA_calcSizeJson(const void *src, const UA_DataType *type, + const UA_EncodeJsonOptions *options); + +/* Encodes the scalar value described by type to json encoding. + * + * @param src The value. Must not be NULL. + * @param type The value type. Must not be NULL. + * @param outBuf Pointer to ByteString containing the result if the encoding was + * successful + * @return Returns a statuscode whether encoding succeeded. */ +UA_StatusCode UA_EXPORT +UA_encodeJson(const void *src, const UA_DataType *type, UA_ByteString *outBuf, + const UA_EncodeJsonOptions *options); + +/* The structure with the decoding options may be extended in the future. + * Zero-out the entire structure initially to ensure code-compatibility when + * more fields are added in a later release. */ +typedef struct { + const UA_DataTypeArray *customTypes; /* Begin of a linked list with custom + * datatype definitions */ +} UA_DecodeJsonOptions; + +/* Decodes a scalar value described by type from json encoding. + * + * @param src The buffer with the json encoded value. Must not be NULL. + * @param dst The target value. Must not be NULL. The target is assumed to have + * size type->memSize. The value is reset to zero before decoding. If + * decoding fails, members are deleted and the value is reset (zeroed) + * again. + * @param type The value type. Must not be NULL. + * @param options The options struct for decoding, currently unused + * @return Returns a statuscode whether decoding succeeded. */ +UA_StatusCode UA_EXPORT +UA_decodeJson(const UA_ByteString *src, void *dst, const UA_DataType *type, + const UA_DecodeJsonOptions *options); +/** + * .. _array-handling: + * + * Array handling + * -------------- + * In OPC UA, arrays can have a length of zero or more with the usual meaning. + * In addition, arrays can be undefined. Then, they don't even have a length. In + * the binary encoding, this is indicated by an array of length -1. + * + * In open62541 however, we use ``size_t`` for array lengths. An undefined array + * has length 0 and the data pointer is ``NULL``. An array of length 0 also has + * length 0 but a data pointer ``UA_EMPTY_ARRAY_SENTINEL``. */ + +/* Allocates and initializes an array of variables of a specific type + * + * @param size The requested array length + * @param type The datatype description + * @return Returns the memory location of the variable or NULL if no memory + could be allocated */ +void UA_EXPORT * +UA_Array_new(size_t size, const UA_DataType *type) UA_FUNC_ATTR_MALLOC; + +/* Allocates and copies an array + * + * @param src The memory location of the source array + * @param size The size of the array + * @param dst The location of the pointer to the new array + * @param type The datatype of the array members + * @return Returns UA_STATUSCODE_GOOD or UA_STATUSCODE_BADOUTOFMEMORY */ +UA_StatusCode UA_EXPORT +UA_Array_copy(const void *src, size_t size, void **dst, + const UA_DataType *type) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +/* Resizes (and reallocates) an array. The last entries are initialized to zero + * if the array length is increased. If the array length is decreased, the last + * entries are removed if the size is decreased. + * + * @param p Double pointer to the array memory. Can be overwritten by the result of a + * realloc. + * @param size The current size of the array. Overwritten in case of success. + * @param newSize The new size of the array + * @param type The datatype of the array members + * @return Returns UA_STATUSCODE_GOOD or UA_STATUSCODE_BADOUTOFMEMORY. The original array + * is left untouched in the failure case. */ +UA_StatusCode UA_EXPORT +UA_Array_resize(void **p, size_t *size, size_t newSize, + const UA_DataType *type) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +/* Append the given element at the end of the array. The content is moved + * (shallow copy) and the original memory is _init'ed if appending is + * successful. + * + * @param p Double pointer to the array memory. Can be overwritten by the result of a + * realloc. + * @param size The current size of the array. Overwritten in case of success. + * @param newElem The element to be appended. The memory is reset upon success. + * @param type The datatype of the array members + * @return Returns UA_STATUSCODE_GOOD or UA_STATUSCODE_BADOUTOFMEMORY. The original array + * is left untouched in the failure case. */ +UA_StatusCode UA_EXPORT +UA_Array_append(void **p, size_t *size, void *newElem, + const UA_DataType *type) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +/* Append a copy of the given element at the end of the array. + * + * @param p Double pointer to the array memory. Can be overwritten by the result of a + * realloc. + * @param size The current size of the array. Overwritten in case of success. + * @param newElem The element to be appended. + * @param type The datatype of the array members + * @return Returns UA_STATUSCODE_GOOD or UA_STATUSCODE_BADOUTOFMEMORY. The original array + * is left untouched in the failure case. */ +UA_StatusCode UA_EXPORT +UA_Array_appendCopy(void **p, size_t *size, const void *newElem, + const UA_DataType *type) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + +/* Deletes an array. + * + * @param p The memory location of the array + * @param size The size of the array + * @param type The datatype of the array members */ +void UA_EXPORT +UA_Array_delete(void *p, size_t size, const UA_DataType *type); + +/** + * Random Number Generator + * ----------------------- + * If UA_MULTITHREADING is defined, then the seed is stored in thread + * local storage. The seed is initialized for every thread in the + * server/client. */ +void UA_EXPORT UA_random_seed(UA_UInt64 seed); +UA_UInt32 UA_EXPORT UA_UInt32_random(void); /* no cryptographic entropy */ +UA_Guid UA_EXPORT UA_Guid_random(void); /* no cryptographic entropy */ + +/** + * .. _generated-types: + * + * Generated Data Type Definitions + * ------------------------------- + * + * The following data types were auto-generated from a definition in XML format. + */ + +/* The following is used to exclude type names in the definition of UA_DataType + * structures if the feature is disabled. */ +#ifdef UA_ENABLE_TYPEDESCRIPTION +# define UA_TYPENAME(name) name, +#else +# define UA_TYPENAME(name) +#endif + +/** + * .. include:: types_generated.rst */ + +_UA_END_DECLS + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/types_generated.h" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + + +#ifdef UA_ENABLE_AMALGAMATION +#else + +#endif + + + +_UA_BEGIN_DECLS + + +/** + * Every type is assigned an index in an array containing the type descriptions. + * These descriptions are used during type handling (copying, deletion, + * binary encoding, ...). */ +#define UA_TYPES_COUNT 191 +extern UA_EXPORT const UA_DataType UA_TYPES[UA_TYPES_COUNT]; + +/** + * Boolean + * ^^^^^^^ + */ +#define UA_TYPES_BOOLEAN 0 + +/** + * SByte + * ^^^^^ + */ +#define UA_TYPES_SBYTE 1 + +/** + * Byte + * ^^^^ + */ +#define UA_TYPES_BYTE 2 + +/** + * Int16 + * ^^^^^ + */ +#define UA_TYPES_INT16 3 + +/** + * UInt16 + * ^^^^^^ + */ +#define UA_TYPES_UINT16 4 + +/** + * Int32 + * ^^^^^ + */ +#define UA_TYPES_INT32 5 + +/** + * UInt32 + * ^^^^^^ + */ +#define UA_TYPES_UINT32 6 + +/** + * Int64 + * ^^^^^ + */ +#define UA_TYPES_INT64 7 + +/** + * UInt64 + * ^^^^^^ + */ +#define UA_TYPES_UINT64 8 + +/** + * Float + * ^^^^^ + */ +#define UA_TYPES_FLOAT 9 + +/** + * Double + * ^^^^^^ + */ +#define UA_TYPES_DOUBLE 10 + +/** + * String + * ^^^^^^ + */ +#define UA_TYPES_STRING 11 + +/** + * DateTime + * ^^^^^^^^ + */ +#define UA_TYPES_DATETIME 12 + +/** + * Guid + * ^^^^ + */ +#define UA_TYPES_GUID 13 + +/** + * ByteString + * ^^^^^^^^^^ + */ +#define UA_TYPES_BYTESTRING 14 + +/** + * XmlElement + * ^^^^^^^^^^ + */ +#define UA_TYPES_XMLELEMENT 15 + +/** + * NodeId + * ^^^^^^ + */ +#define UA_TYPES_NODEID 16 + +/** + * ExpandedNodeId + * ^^^^^^^^^^^^^^ + */ +#define UA_TYPES_EXPANDEDNODEID 17 + +/** + * StatusCode + * ^^^^^^^^^^ + */ +#define UA_TYPES_STATUSCODE 18 + +/** + * QualifiedName + * ^^^^^^^^^^^^^ + */ +#define UA_TYPES_QUALIFIEDNAME 19 + +/** + * LocalizedText + * ^^^^^^^^^^^^^ + */ +#define UA_TYPES_LOCALIZEDTEXT 20 + +/** + * ExtensionObject + * ^^^^^^^^^^^^^^^ + */ +#define UA_TYPES_EXTENSIONOBJECT 21 + +/** + * DataValue + * ^^^^^^^^^ + */ +#define UA_TYPES_DATAVALUE 22 + +/** + * Variant + * ^^^^^^^ + */ +#define UA_TYPES_VARIANT 23 + +/** + * DiagnosticInfo + * ^^^^^^^^^^^^^^ + */ +#define UA_TYPES_DIAGNOSTICINFO 24 + +/** + * KeyValuePair + * ^^^^^^^^^^^^ + */ +typedef struct { + UA_QualifiedName key; + UA_Variant value; +} UA_KeyValuePair; + +#define UA_TYPES_KEYVALUEPAIR 25 + +/** + * NodeClass + * ^^^^^^^^^ + */ +typedef enum { + UA_NODECLASS_UNSPECIFIED = 0, + UA_NODECLASS_OBJECT = 1, + UA_NODECLASS_VARIABLE = 2, + UA_NODECLASS_METHOD = 4, + UA_NODECLASS_OBJECTTYPE = 8, + UA_NODECLASS_VARIABLETYPE = 16, + UA_NODECLASS_REFERENCETYPE = 32, + UA_NODECLASS_DATATYPE = 64, + UA_NODECLASS_VIEW = 128, + __UA_NODECLASS_FORCE32BIT = 0x7fffffff +} UA_NodeClass; +UA_STATIC_ASSERT(sizeof(UA_NodeClass) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_NODECLASS 26 + +/** + * StructureType + * ^^^^^^^^^^^^^ + */ +typedef enum { + UA_STRUCTURETYPE_STRUCTURE = 0, + UA_STRUCTURETYPE_STRUCTUREWITHOPTIONALFIELDS = 1, + UA_STRUCTURETYPE_UNION = 2, + __UA_STRUCTURETYPE_FORCE32BIT = 0x7fffffff +} UA_StructureType; +UA_STATIC_ASSERT(sizeof(UA_StructureType) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_STRUCTURETYPE 27 + +/** + * StructureField + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String name; + UA_LocalizedText description; + UA_NodeId dataType; + UA_Int32 valueRank; + size_t arrayDimensionsSize; + UA_UInt32 *arrayDimensions; + UA_UInt32 maxStringLength; + UA_Boolean isOptional; +} UA_StructureField; + +#define UA_TYPES_STRUCTUREFIELD 28 + +/** + * StructureDefinition + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId defaultEncodingId; + UA_NodeId baseDataType; + UA_StructureType structureType; + size_t fieldsSize; + UA_StructureField *fields; +} UA_StructureDefinition; + +#define UA_TYPES_STRUCTUREDEFINITION 29 + +/** + * Argument + * ^^^^^^^^ + */ +typedef struct { + UA_String name; + UA_NodeId dataType; + UA_Int32 valueRank; + size_t arrayDimensionsSize; + UA_UInt32 *arrayDimensions; + UA_LocalizedText description; +} UA_Argument; + +#define UA_TYPES_ARGUMENT 30 + +/** + * EnumValueType + * ^^^^^^^^^^^^^ + */ +typedef struct { + UA_Int64 value; + UA_LocalizedText displayName; + UA_LocalizedText description; +} UA_EnumValueType; + +#define UA_TYPES_ENUMVALUETYPE 31 + +/** + * EnumField + * ^^^^^^^^^ + */ +typedef struct { + UA_Int64 value; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_String name; +} UA_EnumField; + +#define UA_TYPES_ENUMFIELD 32 + +/** + * Duration + * ^^^^^^^^ + */ +typedef UA_Double UA_Duration; + +#define UA_TYPES_DURATION 33 + +/** + * UtcTime + * ^^^^^^^ + */ +typedef UA_DateTime UA_UtcTime; + +#define UA_TYPES_UTCTIME 34 + +/** + * LocaleId + * ^^^^^^^^ + */ +typedef UA_String UA_LocaleId; + +#define UA_TYPES_LOCALEID 35 + +/** + * TimeZoneDataType + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_Int16 offset; + UA_Boolean daylightSavingInOffset; +} UA_TimeZoneDataType; + +#define UA_TYPES_TIMEZONEDATATYPE 36 + +/** + * ApplicationType + * ^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_APPLICATIONTYPE_SERVER = 0, + UA_APPLICATIONTYPE_CLIENT = 1, + UA_APPLICATIONTYPE_CLIENTANDSERVER = 2, + UA_APPLICATIONTYPE_DISCOVERYSERVER = 3, + __UA_APPLICATIONTYPE_FORCE32BIT = 0x7fffffff +} UA_ApplicationType; +UA_STATIC_ASSERT(sizeof(UA_ApplicationType) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_APPLICATIONTYPE 37 + +/** + * ApplicationDescription + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String applicationUri; + UA_String productUri; + UA_LocalizedText applicationName; + UA_ApplicationType applicationType; + UA_String gatewayServerUri; + UA_String discoveryProfileUri; + size_t discoveryUrlsSize; + UA_String *discoveryUrls; +} UA_ApplicationDescription; + +#define UA_TYPES_APPLICATIONDESCRIPTION 38 + +/** + * RequestHeader + * ^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId authenticationToken; + UA_DateTime timestamp; + UA_UInt32 requestHandle; + UA_UInt32 returnDiagnostics; + UA_String auditEntryId; + UA_UInt32 timeoutHint; + UA_ExtensionObject additionalHeader; +} UA_RequestHeader; + +#define UA_TYPES_REQUESTHEADER 39 + +/** + * ResponseHeader + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_DateTime timestamp; + UA_UInt32 requestHandle; + UA_StatusCode serviceResult; + UA_DiagnosticInfo serviceDiagnostics; + size_t stringTableSize; + UA_String *stringTable; + UA_ExtensionObject additionalHeader; +} UA_ResponseHeader; + +#define UA_TYPES_RESPONSEHEADER 40 + +/** + * ServiceFault + * ^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; +} UA_ServiceFault; + +#define UA_TYPES_SERVICEFAULT 41 + +/** + * FindServersRequest + * ^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_String endpointUrl; + size_t localeIdsSize; + UA_String *localeIds; + size_t serverUrisSize; + UA_String *serverUris; +} UA_FindServersRequest; + +#define UA_TYPES_FINDSERVERSREQUEST 42 + +/** + * FindServersResponse + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t serversSize; + UA_ApplicationDescription *servers; +} UA_FindServersResponse; + +#define UA_TYPES_FINDSERVERSRESPONSE 43 + +/** + * MessageSecurityMode + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_MESSAGESECURITYMODE_INVALID = 0, + UA_MESSAGESECURITYMODE_NONE = 1, + UA_MESSAGESECURITYMODE_SIGN = 2, + UA_MESSAGESECURITYMODE_SIGNANDENCRYPT = 3, + __UA_MESSAGESECURITYMODE_FORCE32BIT = 0x7fffffff +} UA_MessageSecurityMode; +UA_STATIC_ASSERT(sizeof(UA_MessageSecurityMode) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_MESSAGESECURITYMODE 44 + +/** + * UserTokenType + * ^^^^^^^^^^^^^ + */ +typedef enum { + UA_USERTOKENTYPE_ANONYMOUS = 0, + UA_USERTOKENTYPE_USERNAME = 1, + UA_USERTOKENTYPE_CERTIFICATE = 2, + UA_USERTOKENTYPE_ISSUEDTOKEN = 3, + __UA_USERTOKENTYPE_FORCE32BIT = 0x7fffffff +} UA_UserTokenType; +UA_STATIC_ASSERT(sizeof(UA_UserTokenType) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_USERTOKENTYPE 45 + +/** + * UserTokenPolicy + * ^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String policyId; + UA_UserTokenType tokenType; + UA_String issuedTokenType; + UA_String issuerEndpointUrl; + UA_String securityPolicyUri; +} UA_UserTokenPolicy; + +#define UA_TYPES_USERTOKENPOLICY 46 + +/** + * EndpointDescription + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String endpointUrl; + UA_ApplicationDescription server; + UA_ByteString serverCertificate; + UA_MessageSecurityMode securityMode; + UA_String securityPolicyUri; + size_t userIdentityTokensSize; + UA_UserTokenPolicy *userIdentityTokens; + UA_String transportProfileUri; + UA_Byte securityLevel; +} UA_EndpointDescription; + +#define UA_TYPES_ENDPOINTDESCRIPTION 47 + +/** + * GetEndpointsRequest + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_String endpointUrl; + size_t localeIdsSize; + UA_String *localeIds; + size_t profileUrisSize; + UA_String *profileUris; +} UA_GetEndpointsRequest; + +#define UA_TYPES_GETENDPOINTSREQUEST 48 + +/** + * GetEndpointsResponse + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t endpointsSize; + UA_EndpointDescription *endpoints; +} UA_GetEndpointsResponse; + +#define UA_TYPES_GETENDPOINTSRESPONSE 49 + +/** + * SecurityTokenRequestType + * ^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_SECURITYTOKENREQUESTTYPE_ISSUE = 0, + UA_SECURITYTOKENREQUESTTYPE_RENEW = 1, + __UA_SECURITYTOKENREQUESTTYPE_FORCE32BIT = 0x7fffffff +} UA_SecurityTokenRequestType; +UA_STATIC_ASSERT(sizeof(UA_SecurityTokenRequestType) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_SECURITYTOKENREQUESTTYPE 50 + +/** + * ChannelSecurityToken + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 channelId; + UA_UInt32 tokenId; + UA_DateTime createdAt; + UA_UInt32 revisedLifetime; +} UA_ChannelSecurityToken; + +#define UA_TYPES_CHANNELSECURITYTOKEN 51 + +/** + * OpenSecureChannelRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 clientProtocolVersion; + UA_SecurityTokenRequestType requestType; + UA_MessageSecurityMode securityMode; + UA_ByteString clientNonce; + UA_UInt32 requestedLifetime; +} UA_OpenSecureChannelRequest; + +#define UA_TYPES_OPENSECURECHANNELREQUEST 52 + +/** + * OpenSecureChannelResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + UA_UInt32 serverProtocolVersion; + UA_ChannelSecurityToken securityToken; + UA_ByteString serverNonce; +} UA_OpenSecureChannelResponse; + +#define UA_TYPES_OPENSECURECHANNELRESPONSE 53 + +/** + * CloseSecureChannelRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; +} UA_CloseSecureChannelRequest; + +#define UA_TYPES_CLOSESECURECHANNELREQUEST 54 + +/** + * CloseSecureChannelResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; +} UA_CloseSecureChannelResponse; + +#define UA_TYPES_CLOSESECURECHANNELRESPONSE 55 + +/** + * SignedSoftwareCertificate + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ByteString certificateData; + UA_ByteString signature; +} UA_SignedSoftwareCertificate; + +#define UA_TYPES_SIGNEDSOFTWARECERTIFICATE 56 + +/** + * SignatureData + * ^^^^^^^^^^^^^ + */ +typedef struct { + UA_String algorithm; + UA_ByteString signature; +} UA_SignatureData; + +#define UA_TYPES_SIGNATUREDATA 57 + +/** + * CreateSessionRequest + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_ApplicationDescription clientDescription; + UA_String serverUri; + UA_String endpointUrl; + UA_String sessionName; + UA_ByteString clientNonce; + UA_ByteString clientCertificate; + UA_Double requestedSessionTimeout; + UA_UInt32 maxResponseMessageSize; +} UA_CreateSessionRequest; + +#define UA_TYPES_CREATESESSIONREQUEST 58 + +/** + * CreateSessionResponse + * ^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + UA_NodeId sessionId; + UA_NodeId authenticationToken; + UA_Double revisedSessionTimeout; + UA_ByteString serverNonce; + UA_ByteString serverCertificate; + size_t serverEndpointsSize; + UA_EndpointDescription *serverEndpoints; + size_t serverSoftwareCertificatesSize; + UA_SignedSoftwareCertificate *serverSoftwareCertificates; + UA_SignatureData serverSignature; + UA_UInt32 maxRequestMessageSize; +} UA_CreateSessionResponse; + +#define UA_TYPES_CREATESESSIONRESPONSE 59 + +/** + * UserIdentityToken + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String policyId; +} UA_UserIdentityToken; + +#define UA_TYPES_USERIDENTITYTOKEN 60 + +/** + * AnonymousIdentityToken + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String policyId; +} UA_AnonymousIdentityToken; + +#define UA_TYPES_ANONYMOUSIDENTITYTOKEN 61 + +/** + * UserNameIdentityToken + * ^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String policyId; + UA_String userName; + UA_ByteString password; + UA_String encryptionAlgorithm; +} UA_UserNameIdentityToken; + +#define UA_TYPES_USERNAMEIDENTITYTOKEN 62 + +/** + * X509IdentityToken + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String policyId; + UA_ByteString certificateData; +} UA_X509IdentityToken; + +#define UA_TYPES_X509IDENTITYTOKEN 63 + +/** + * IssuedIdentityToken + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_String policyId; + UA_ByteString tokenData; + UA_String encryptionAlgorithm; +} UA_IssuedIdentityToken; + +#define UA_TYPES_ISSUEDIDENTITYTOKEN 64 + +/** + * ActivateSessionRequest + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_SignatureData clientSignature; + size_t clientSoftwareCertificatesSize; + UA_SignedSoftwareCertificate *clientSoftwareCertificates; + size_t localeIdsSize; + UA_String *localeIds; + UA_ExtensionObject userIdentityToken; + UA_SignatureData userTokenSignature; +} UA_ActivateSessionRequest; + +#define UA_TYPES_ACTIVATESESSIONREQUEST 65 + +/** + * ActivateSessionResponse + * ^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + UA_ByteString serverNonce; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_ActivateSessionResponse; + +#define UA_TYPES_ACTIVATESESSIONRESPONSE 66 + +/** + * CloseSessionRequest + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_Boolean deleteSubscriptions; +} UA_CloseSessionRequest; + +#define UA_TYPES_CLOSESESSIONREQUEST 67 + +/** + * CloseSessionResponse + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; +} UA_CloseSessionResponse; + +#define UA_TYPES_CLOSESESSIONRESPONSE 68 + +/** + * NodeAttributesMask + * ^^^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_NODEATTRIBUTESMASK_NONE = 0, + UA_NODEATTRIBUTESMASK_ACCESSLEVEL = 1, + UA_NODEATTRIBUTESMASK_ARRAYDIMENSIONS = 2, + UA_NODEATTRIBUTESMASK_BROWSENAME = 4, + UA_NODEATTRIBUTESMASK_CONTAINSNOLOOPS = 8, + UA_NODEATTRIBUTESMASK_DATATYPE = 16, + UA_NODEATTRIBUTESMASK_DESCRIPTION = 32, + UA_NODEATTRIBUTESMASK_DISPLAYNAME = 64, + UA_NODEATTRIBUTESMASK_EVENTNOTIFIER = 128, + UA_NODEATTRIBUTESMASK_EXECUTABLE = 256, + UA_NODEATTRIBUTESMASK_HISTORIZING = 512, + UA_NODEATTRIBUTESMASK_INVERSENAME = 1024, + UA_NODEATTRIBUTESMASK_ISABSTRACT = 2048, + UA_NODEATTRIBUTESMASK_MINIMUMSAMPLINGINTERVAL = 4096, + UA_NODEATTRIBUTESMASK_NODECLASS = 8192, + UA_NODEATTRIBUTESMASK_NODEID = 16384, + UA_NODEATTRIBUTESMASK_SYMMETRIC = 32768, + UA_NODEATTRIBUTESMASK_USERACCESSLEVEL = 65536, + UA_NODEATTRIBUTESMASK_USEREXECUTABLE = 131072, + UA_NODEATTRIBUTESMASK_USERWRITEMASK = 262144, + UA_NODEATTRIBUTESMASK_VALUERANK = 524288, + UA_NODEATTRIBUTESMASK_WRITEMASK = 1048576, + UA_NODEATTRIBUTESMASK_VALUE = 2097152, + UA_NODEATTRIBUTESMASK_DATATYPEDEFINITION = 4194304, + UA_NODEATTRIBUTESMASK_ROLEPERMISSIONS = 8388608, + UA_NODEATTRIBUTESMASK_ACCESSRESTRICTIONS = 16777216, + UA_NODEATTRIBUTESMASK_ALL = 33554431, + UA_NODEATTRIBUTESMASK_BASENODE = 26501220, + UA_NODEATTRIBUTESMASK_OBJECT = 26501348, + UA_NODEATTRIBUTESMASK_OBJECTTYPE = 26503268, + UA_NODEATTRIBUTESMASK_VARIABLE = 26571383, + UA_NODEATTRIBUTESMASK_VARIABLETYPE = 28600438, + UA_NODEATTRIBUTESMASK_METHOD = 26632548, + UA_NODEATTRIBUTESMASK_REFERENCETYPE = 26537060, + UA_NODEATTRIBUTESMASK_VIEW = 26501356, + __UA_NODEATTRIBUTESMASK_FORCE32BIT = 0x7fffffff +} UA_NodeAttributesMask; +UA_STATIC_ASSERT(sizeof(UA_NodeAttributesMask) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_NODEATTRIBUTESMASK 69 + +/** + * NodeAttributes + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; +} UA_NodeAttributes; + +#define UA_TYPES_NODEATTRIBUTES 70 + +/** + * ObjectAttributes + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Byte eventNotifier; +} UA_ObjectAttributes; + +#define UA_TYPES_OBJECTATTRIBUTES 71 + +/** + * VariableAttributes + * ^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Variant value; + UA_NodeId dataType; + UA_Int32 valueRank; + size_t arrayDimensionsSize; + UA_UInt32 *arrayDimensions; + UA_Byte accessLevel; + UA_Byte userAccessLevel; + UA_Double minimumSamplingInterval; + UA_Boolean historizing; +} UA_VariableAttributes; + +#define UA_TYPES_VARIABLEATTRIBUTES 72 + +/** + * MethodAttributes + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Boolean executable; + UA_Boolean userExecutable; +} UA_MethodAttributes; + +#define UA_TYPES_METHODATTRIBUTES 73 + +/** + * ObjectTypeAttributes + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Boolean isAbstract; +} UA_ObjectTypeAttributes; + +#define UA_TYPES_OBJECTTYPEATTRIBUTES 74 + +/** + * VariableTypeAttributes + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Variant value; + UA_NodeId dataType; + UA_Int32 valueRank; + size_t arrayDimensionsSize; + UA_UInt32 *arrayDimensions; + UA_Boolean isAbstract; +} UA_VariableTypeAttributes; + +#define UA_TYPES_VARIABLETYPEATTRIBUTES 75 + +/** + * ReferenceTypeAttributes + * ^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Boolean isAbstract; + UA_Boolean symmetric; + UA_LocalizedText inverseName; +} UA_ReferenceTypeAttributes; + +#define UA_TYPES_REFERENCETYPEATTRIBUTES 76 + +/** + * DataTypeAttributes + * ^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Boolean isAbstract; +} UA_DataTypeAttributes; + +#define UA_TYPES_DATATYPEATTRIBUTES 77 + +/** + * ViewAttributes + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 specifiedAttributes; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + UA_UInt32 userWriteMask; + UA_Boolean containsNoLoops; + UA_Byte eventNotifier; +} UA_ViewAttributes; + +#define UA_TYPES_VIEWATTRIBUTES 78 + +/** + * AddNodesItem + * ^^^^^^^^^^^^ + */ +typedef struct { + UA_ExpandedNodeId parentNodeId; + UA_NodeId referenceTypeId; + UA_ExpandedNodeId requestedNewNodeId; + UA_QualifiedName browseName; + UA_NodeClass nodeClass; + UA_ExtensionObject nodeAttributes; + UA_ExpandedNodeId typeDefinition; +} UA_AddNodesItem; + +#define UA_TYPES_ADDNODESITEM 79 + +/** + * AddNodesResult + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + UA_NodeId addedNodeId; +} UA_AddNodesResult; + +#define UA_TYPES_ADDNODESRESULT 80 + +/** + * AddNodesRequest + * ^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t nodesToAddSize; + UA_AddNodesItem *nodesToAdd; +} UA_AddNodesRequest; + +#define UA_TYPES_ADDNODESREQUEST 81 + +/** + * AddNodesResponse + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_AddNodesResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_AddNodesResponse; + +#define UA_TYPES_ADDNODESRESPONSE 82 + +/** + * AddReferencesItem + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId sourceNodeId; + UA_NodeId referenceTypeId; + UA_Boolean isForward; + UA_String targetServerUri; + UA_ExpandedNodeId targetNodeId; + UA_NodeClass targetNodeClass; +} UA_AddReferencesItem; + +#define UA_TYPES_ADDREFERENCESITEM 83 + +/** + * AddReferencesRequest + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t referencesToAddSize; + UA_AddReferencesItem *referencesToAdd; +} UA_AddReferencesRequest; + +#define UA_TYPES_ADDREFERENCESREQUEST 84 + +/** + * AddReferencesResponse + * ^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_AddReferencesResponse; + +#define UA_TYPES_ADDREFERENCESRESPONSE 85 + +/** + * DeleteNodesItem + * ^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId nodeId; + UA_Boolean deleteTargetReferences; +} UA_DeleteNodesItem; + +#define UA_TYPES_DELETENODESITEM 86 + +/** + * DeleteNodesRequest + * ^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t nodesToDeleteSize; + UA_DeleteNodesItem *nodesToDelete; +} UA_DeleteNodesRequest; + +#define UA_TYPES_DELETENODESREQUEST 87 + +/** + * DeleteNodesResponse + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_DeleteNodesResponse; + +#define UA_TYPES_DELETENODESRESPONSE 88 + +/** + * DeleteReferencesItem + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId sourceNodeId; + UA_NodeId referenceTypeId; + UA_Boolean isForward; + UA_ExpandedNodeId targetNodeId; + UA_Boolean deleteBidirectional; +} UA_DeleteReferencesItem; + +#define UA_TYPES_DELETEREFERENCESITEM 89 + +/** + * DeleteReferencesRequest + * ^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t referencesToDeleteSize; + UA_DeleteReferencesItem *referencesToDelete; +} UA_DeleteReferencesRequest; + +#define UA_TYPES_DELETEREFERENCESREQUEST 90 + +/** + * DeleteReferencesResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_DeleteReferencesResponse; + +#define UA_TYPES_DELETEREFERENCESRESPONSE 91 + +/** + * BrowseDirection + * ^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_BROWSEDIRECTION_FORWARD = 0, + UA_BROWSEDIRECTION_INVERSE = 1, + UA_BROWSEDIRECTION_BOTH = 2, + UA_BROWSEDIRECTION_INVALID = 3, + __UA_BROWSEDIRECTION_FORCE32BIT = 0x7fffffff +} UA_BrowseDirection; +UA_STATIC_ASSERT(sizeof(UA_BrowseDirection) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_BROWSEDIRECTION 92 + +/** + * ViewDescription + * ^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId viewId; + UA_DateTime timestamp; + UA_UInt32 viewVersion; +} UA_ViewDescription; + +#define UA_TYPES_VIEWDESCRIPTION 93 + +/** + * BrowseDescription + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId nodeId; + UA_BrowseDirection browseDirection; + UA_NodeId referenceTypeId; + UA_Boolean includeSubtypes; + UA_UInt32 nodeClassMask; + UA_UInt32 resultMask; +} UA_BrowseDescription; + +#define UA_TYPES_BROWSEDESCRIPTION 94 + +/** + * BrowseResultMask + * ^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_BROWSERESULTMASK_NONE = 0, + UA_BROWSERESULTMASK_REFERENCETYPEID = 1, + UA_BROWSERESULTMASK_ISFORWARD = 2, + UA_BROWSERESULTMASK_NODECLASS = 4, + UA_BROWSERESULTMASK_BROWSENAME = 8, + UA_BROWSERESULTMASK_DISPLAYNAME = 16, + UA_BROWSERESULTMASK_TYPEDEFINITION = 32, + UA_BROWSERESULTMASK_ALL = 63, + UA_BROWSERESULTMASK_REFERENCETYPEINFO = 3, + UA_BROWSERESULTMASK_TARGETINFO = 60, + __UA_BROWSERESULTMASK_FORCE32BIT = 0x7fffffff +} UA_BrowseResultMask; +UA_STATIC_ASSERT(sizeof(UA_BrowseResultMask) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_BROWSERESULTMASK 95 + +/** + * ReferenceDescription + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId referenceTypeId; + UA_Boolean isForward; + UA_ExpandedNodeId nodeId; + UA_QualifiedName browseName; + UA_LocalizedText displayName; + UA_NodeClass nodeClass; + UA_ExpandedNodeId typeDefinition; +} UA_ReferenceDescription; + +#define UA_TYPES_REFERENCEDESCRIPTION 96 + +/** + * BrowseResult + * ^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + UA_ByteString continuationPoint; + size_t referencesSize; + UA_ReferenceDescription *references; +} UA_BrowseResult; + +#define UA_TYPES_BROWSERESULT 97 + +/** + * BrowseRequest + * ^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_ViewDescription view; + UA_UInt32 requestedMaxReferencesPerNode; + size_t nodesToBrowseSize; + UA_BrowseDescription *nodesToBrowse; +} UA_BrowseRequest; + +#define UA_TYPES_BROWSEREQUEST 98 + +/** + * BrowseResponse + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_BrowseResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_BrowseResponse; + +#define UA_TYPES_BROWSERESPONSE 99 + +/** + * BrowseNextRequest + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_Boolean releaseContinuationPoints; + size_t continuationPointsSize; + UA_ByteString *continuationPoints; +} UA_BrowseNextRequest; + +#define UA_TYPES_BROWSENEXTREQUEST 100 + +/** + * BrowseNextResponse + * ^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_BrowseResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_BrowseNextResponse; + +#define UA_TYPES_BROWSENEXTRESPONSE 101 + +/** + * RelativePathElement + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId referenceTypeId; + UA_Boolean isInverse; + UA_Boolean includeSubtypes; + UA_QualifiedName targetName; +} UA_RelativePathElement; + +#define UA_TYPES_RELATIVEPATHELEMENT 102 + +/** + * RelativePath + * ^^^^^^^^^^^^ + */ +typedef struct { + size_t elementsSize; + UA_RelativePathElement *elements; +} UA_RelativePath; + +#define UA_TYPES_RELATIVEPATH 103 + +/** + * BrowsePath + * ^^^^^^^^^^ + */ +typedef struct { + UA_NodeId startingNode; + UA_RelativePath relativePath; +} UA_BrowsePath; + +#define UA_TYPES_BROWSEPATH 104 + +/** + * BrowsePathTarget + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ExpandedNodeId targetId; + UA_UInt32 remainingPathIndex; +} UA_BrowsePathTarget; + +#define UA_TYPES_BROWSEPATHTARGET 105 + +/** + * BrowsePathResult + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + size_t targetsSize; + UA_BrowsePathTarget *targets; +} UA_BrowsePathResult; + +#define UA_TYPES_BROWSEPATHRESULT 106 + +/** + * TranslateBrowsePathsToNodeIdsRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t browsePathsSize; + UA_BrowsePath *browsePaths; +} UA_TranslateBrowsePathsToNodeIdsRequest; + +#define UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST 107 + +/** + * TranslateBrowsePathsToNodeIdsResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_BrowsePathResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_TranslateBrowsePathsToNodeIdsResponse; + +#define UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE 108 + +/** + * RegisterNodesRequest + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t nodesToRegisterSize; + UA_NodeId *nodesToRegister; +} UA_RegisterNodesRequest; + +#define UA_TYPES_REGISTERNODESREQUEST 109 + +/** + * RegisterNodesResponse + * ^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t registeredNodeIdsSize; + UA_NodeId *registeredNodeIds; +} UA_RegisterNodesResponse; + +#define UA_TYPES_REGISTERNODESRESPONSE 110 + +/** + * UnregisterNodesRequest + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t nodesToUnregisterSize; + UA_NodeId *nodesToUnregister; +} UA_UnregisterNodesRequest; + +#define UA_TYPES_UNREGISTERNODESREQUEST 111 + +/** + * UnregisterNodesResponse + * ^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; +} UA_UnregisterNodesResponse; + +#define UA_TYPES_UNREGISTERNODESRESPONSE 112 + +/** + * FilterOperator + * ^^^^^^^^^^^^^^ + */ +typedef enum { + UA_FILTEROPERATOR_EQUALS = 0, + UA_FILTEROPERATOR_ISNULL = 1, + UA_FILTEROPERATOR_GREATERTHAN = 2, + UA_FILTEROPERATOR_LESSTHAN = 3, + UA_FILTEROPERATOR_GREATERTHANOREQUAL = 4, + UA_FILTEROPERATOR_LESSTHANOREQUAL = 5, + UA_FILTEROPERATOR_LIKE = 6, + UA_FILTEROPERATOR_NOT = 7, + UA_FILTEROPERATOR_BETWEEN = 8, + UA_FILTEROPERATOR_INLIST = 9, + UA_FILTEROPERATOR_AND = 10, + UA_FILTEROPERATOR_OR = 11, + UA_FILTEROPERATOR_CAST = 12, + UA_FILTEROPERATOR_INVIEW = 13, + UA_FILTEROPERATOR_OFTYPE = 14, + UA_FILTEROPERATOR_RELATEDTO = 15, + UA_FILTEROPERATOR_BITWISEAND = 16, + UA_FILTEROPERATOR_BITWISEOR = 17, + __UA_FILTEROPERATOR_FORCE32BIT = 0x7fffffff +} UA_FilterOperator; +UA_STATIC_ASSERT(sizeof(UA_FilterOperator) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_FILTEROPERATOR 113 + +/** + * ContentFilterElement + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_FilterOperator filterOperator; + size_t filterOperandsSize; + UA_ExtensionObject *filterOperands; +} UA_ContentFilterElement; + +#define UA_TYPES_CONTENTFILTERELEMENT 114 + +/** + * ContentFilter + * ^^^^^^^^^^^^^ + */ +typedef struct { + size_t elementsSize; + UA_ContentFilterElement *elements; +} UA_ContentFilter; + +#define UA_TYPES_CONTENTFILTER 115 + +/** + * ElementOperand + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 index; +} UA_ElementOperand; + +#define UA_TYPES_ELEMENTOPERAND 116 + +/** + * LiteralOperand + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_Variant value; +} UA_LiteralOperand; + +#define UA_TYPES_LITERALOPERAND 117 + +/** + * AttributeOperand + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId nodeId; + UA_String alias; + UA_RelativePath browsePath; + UA_UInt32 attributeId; + UA_String indexRange; +} UA_AttributeOperand; + +#define UA_TYPES_ATTRIBUTEOPERAND 118 + +/** + * SimpleAttributeOperand + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId typeDefinitionId; + size_t browsePathSize; + UA_QualifiedName *browsePath; + UA_UInt32 attributeId; + UA_String indexRange; +} UA_SimpleAttributeOperand; + +#define UA_TYPES_SIMPLEATTRIBUTEOPERAND 119 + +/** + * ContentFilterElementResult + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + size_t operandStatusCodesSize; + UA_StatusCode *operandStatusCodes; + size_t operandDiagnosticInfosSize; + UA_DiagnosticInfo *operandDiagnosticInfos; +} UA_ContentFilterElementResult; + +#define UA_TYPES_CONTENTFILTERELEMENTRESULT 120 + +/** + * ContentFilterResult + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + size_t elementResultsSize; + UA_ContentFilterElementResult *elementResults; + size_t elementDiagnosticInfosSize; + UA_DiagnosticInfo *elementDiagnosticInfos; +} UA_ContentFilterResult; + +#define UA_TYPES_CONTENTFILTERRESULT 121 + +/** + * TimestampsToReturn + * ^^^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_TIMESTAMPSTORETURN_SOURCE = 0, + UA_TIMESTAMPSTORETURN_SERVER = 1, + UA_TIMESTAMPSTORETURN_BOTH = 2, + UA_TIMESTAMPSTORETURN_NEITHER = 3, + UA_TIMESTAMPSTORETURN_INVALID = 4, + __UA_TIMESTAMPSTORETURN_FORCE32BIT = 0x7fffffff +} UA_TimestampsToReturn; +UA_STATIC_ASSERT(sizeof(UA_TimestampsToReturn) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_TIMESTAMPSTORETURN 122 + +/** + * ReadValueId + * ^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId nodeId; + UA_UInt32 attributeId; + UA_String indexRange; + UA_QualifiedName dataEncoding; +} UA_ReadValueId; + +#define UA_TYPES_READVALUEID 123 + +/** + * ReadRequest + * ^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_Double maxAge; + UA_TimestampsToReturn timestampsToReturn; + size_t nodesToReadSize; + UA_ReadValueId *nodesToRead; +} UA_ReadRequest; + +#define UA_TYPES_READREQUEST 124 + +/** + * ReadResponse + * ^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_DataValue *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_ReadResponse; + +#define UA_TYPES_READRESPONSE 125 + +/** + * WriteValue + * ^^^^^^^^^^ + */ +typedef struct { + UA_NodeId nodeId; + UA_UInt32 attributeId; + UA_String indexRange; + UA_DataValue value; +} UA_WriteValue; + +#define UA_TYPES_WRITEVALUE 126 + +/** + * WriteRequest + * ^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t nodesToWriteSize; + UA_WriteValue *nodesToWrite; +} UA_WriteRequest; + +#define UA_TYPES_WRITEREQUEST 127 + +/** + * WriteResponse + * ^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_WriteResponse; + +#define UA_TYPES_WRITERESPONSE 128 + +/** + * CallMethodRequest + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_NodeId objectId; + UA_NodeId methodId; + size_t inputArgumentsSize; + UA_Variant *inputArguments; +} UA_CallMethodRequest; + +#define UA_TYPES_CALLMETHODREQUEST 129 + +/** + * CallMethodResult + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + size_t inputArgumentResultsSize; + UA_StatusCode *inputArgumentResults; + size_t inputArgumentDiagnosticInfosSize; + UA_DiagnosticInfo *inputArgumentDiagnosticInfos; + size_t outputArgumentsSize; + UA_Variant *outputArguments; +} UA_CallMethodResult; + +#define UA_TYPES_CALLMETHODRESULT 130 + +/** + * CallRequest + * ^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t methodsToCallSize; + UA_CallMethodRequest *methodsToCall; +} UA_CallRequest; + +#define UA_TYPES_CALLREQUEST 131 + +/** + * CallResponse + * ^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_CallMethodResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_CallResponse; + +#define UA_TYPES_CALLRESPONSE 132 + +/** + * MonitoringMode + * ^^^^^^^^^^^^^^ + */ +typedef enum { + UA_MONITORINGMODE_DISABLED = 0, + UA_MONITORINGMODE_SAMPLING = 1, + UA_MONITORINGMODE_REPORTING = 2, + __UA_MONITORINGMODE_FORCE32BIT = 0x7fffffff +} UA_MonitoringMode; +UA_STATIC_ASSERT(sizeof(UA_MonitoringMode) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_MONITORINGMODE 133 + +/** + * DataChangeTrigger + * ^^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_DATACHANGETRIGGER_STATUS = 0, + UA_DATACHANGETRIGGER_STATUSVALUE = 1, + UA_DATACHANGETRIGGER_STATUSVALUETIMESTAMP = 2, + __UA_DATACHANGETRIGGER_FORCE32BIT = 0x7fffffff +} UA_DataChangeTrigger; +UA_STATIC_ASSERT(sizeof(UA_DataChangeTrigger) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_DATACHANGETRIGGER 134 + +/** + * DeadbandType + * ^^^^^^^^^^^^ + */ +typedef enum { + UA_DEADBANDTYPE_NONE = 0, + UA_DEADBANDTYPE_ABSOLUTE = 1, + UA_DEADBANDTYPE_PERCENT = 2, + __UA_DEADBANDTYPE_FORCE32BIT = 0x7fffffff +} UA_DeadbandType; +UA_STATIC_ASSERT(sizeof(UA_DeadbandType) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_DEADBANDTYPE 135 + +/** + * DataChangeFilter + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_DataChangeTrigger trigger; + UA_UInt32 deadbandType; + UA_Double deadbandValue; +} UA_DataChangeFilter; + +#define UA_TYPES_DATACHANGEFILTER 136 + +/** + * EventFilter + * ^^^^^^^^^^^ + */ +typedef struct { + size_t selectClausesSize; + UA_SimpleAttributeOperand *selectClauses; + UA_ContentFilter whereClause; +} UA_EventFilter; + +#define UA_TYPES_EVENTFILTER 137 + +/** + * AggregateConfiguration + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_Boolean useServerCapabilitiesDefaults; + UA_Boolean treatUncertainAsBad; + UA_Byte percentDataBad; + UA_Byte percentDataGood; + UA_Boolean useSlopedExtrapolation; +} UA_AggregateConfiguration; + +#define UA_TYPES_AGGREGATECONFIGURATION 138 + +/** + * AggregateFilter + * ^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_DateTime startTime; + UA_NodeId aggregateType; + UA_Double processingInterval; + UA_AggregateConfiguration aggregateConfiguration; +} UA_AggregateFilter; + +#define UA_TYPES_AGGREGATEFILTER 139 + +/** + * EventFilterResult + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + size_t selectClauseResultsSize; + UA_StatusCode *selectClauseResults; + size_t selectClauseDiagnosticInfosSize; + UA_DiagnosticInfo *selectClauseDiagnosticInfos; + UA_ContentFilterResult whereClauseResult; +} UA_EventFilterResult; + +#define UA_TYPES_EVENTFILTERRESULT 140 + +/** + * MonitoringParameters + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 clientHandle; + UA_Double samplingInterval; + UA_ExtensionObject filter; + UA_UInt32 queueSize; + UA_Boolean discardOldest; +} UA_MonitoringParameters; + +#define UA_TYPES_MONITORINGPARAMETERS 141 + +/** + * MonitoredItemCreateRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ReadValueId itemToMonitor; + UA_MonitoringMode monitoringMode; + UA_MonitoringParameters requestedParameters; +} UA_MonitoredItemCreateRequest; + +#define UA_TYPES_MONITOREDITEMCREATEREQUEST 142 + +/** + * MonitoredItemCreateResult + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + UA_UInt32 monitoredItemId; + UA_Double revisedSamplingInterval; + UA_UInt32 revisedQueueSize; + UA_ExtensionObject filterResult; +} UA_MonitoredItemCreateResult; + +#define UA_TYPES_MONITOREDITEMCREATERESULT 143 + +/** + * CreateMonitoredItemsRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 subscriptionId; + UA_TimestampsToReturn timestampsToReturn; + size_t itemsToCreateSize; + UA_MonitoredItemCreateRequest *itemsToCreate; +} UA_CreateMonitoredItemsRequest; + +#define UA_TYPES_CREATEMONITOREDITEMSREQUEST 144 + +/** + * CreateMonitoredItemsResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_MonitoredItemCreateResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_CreateMonitoredItemsResponse; + +#define UA_TYPES_CREATEMONITOREDITEMSRESPONSE 145 + +/** + * MonitoredItemModifyRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 monitoredItemId; + UA_MonitoringParameters requestedParameters; +} UA_MonitoredItemModifyRequest; + +#define UA_TYPES_MONITOREDITEMMODIFYREQUEST 146 + +/** + * MonitoredItemModifyResult + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + UA_Double revisedSamplingInterval; + UA_UInt32 revisedQueueSize; + UA_ExtensionObject filterResult; +} UA_MonitoredItemModifyResult; + +#define UA_TYPES_MONITOREDITEMMODIFYRESULT 147 + +/** + * ModifyMonitoredItemsRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 subscriptionId; + UA_TimestampsToReturn timestampsToReturn; + size_t itemsToModifySize; + UA_MonitoredItemModifyRequest *itemsToModify; +} UA_ModifyMonitoredItemsRequest; + +#define UA_TYPES_MODIFYMONITOREDITEMSREQUEST 148 + +/** + * ModifyMonitoredItemsResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_MonitoredItemModifyResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_ModifyMonitoredItemsResponse; + +#define UA_TYPES_MODIFYMONITOREDITEMSRESPONSE 149 + +/** + * SetMonitoringModeRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 subscriptionId; + UA_MonitoringMode monitoringMode; + size_t monitoredItemIdsSize; + UA_UInt32 *monitoredItemIds; +} UA_SetMonitoringModeRequest; + +#define UA_TYPES_SETMONITORINGMODEREQUEST 150 + +/** + * SetMonitoringModeResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_SetMonitoringModeResponse; + +#define UA_TYPES_SETMONITORINGMODERESPONSE 151 + +/** + * SetTriggeringRequest + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 subscriptionId; + UA_UInt32 triggeringItemId; + size_t linksToAddSize; + UA_UInt32 *linksToAdd; + size_t linksToRemoveSize; + UA_UInt32 *linksToRemove; +} UA_SetTriggeringRequest; + +#define UA_TYPES_SETTRIGGERINGREQUEST 152 + +/** + * SetTriggeringResponse + * ^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t addResultsSize; + UA_StatusCode *addResults; + size_t addDiagnosticInfosSize; + UA_DiagnosticInfo *addDiagnosticInfos; + size_t removeResultsSize; + UA_StatusCode *removeResults; + size_t removeDiagnosticInfosSize; + UA_DiagnosticInfo *removeDiagnosticInfos; +} UA_SetTriggeringResponse; + +#define UA_TYPES_SETTRIGGERINGRESPONSE 153 + +/** + * DeleteMonitoredItemsRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 subscriptionId; + size_t monitoredItemIdsSize; + UA_UInt32 *monitoredItemIds; +} UA_DeleteMonitoredItemsRequest; + +#define UA_TYPES_DELETEMONITOREDITEMSREQUEST 154 + +/** + * DeleteMonitoredItemsResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_DeleteMonitoredItemsResponse; + +#define UA_TYPES_DELETEMONITOREDITEMSRESPONSE 155 + +/** + * CreateSubscriptionRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_Double requestedPublishingInterval; + UA_UInt32 requestedLifetimeCount; + UA_UInt32 requestedMaxKeepAliveCount; + UA_UInt32 maxNotificationsPerPublish; + UA_Boolean publishingEnabled; + UA_Byte priority; +} UA_CreateSubscriptionRequest; + +#define UA_TYPES_CREATESUBSCRIPTIONREQUEST 156 + +/** + * CreateSubscriptionResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + UA_UInt32 subscriptionId; + UA_Double revisedPublishingInterval; + UA_UInt32 revisedLifetimeCount; + UA_UInt32 revisedMaxKeepAliveCount; +} UA_CreateSubscriptionResponse; + +#define UA_TYPES_CREATESUBSCRIPTIONRESPONSE 157 + +/** + * ModifySubscriptionRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 subscriptionId; + UA_Double requestedPublishingInterval; + UA_UInt32 requestedLifetimeCount; + UA_UInt32 requestedMaxKeepAliveCount; + UA_UInt32 maxNotificationsPerPublish; + UA_Byte priority; +} UA_ModifySubscriptionRequest; + +#define UA_TYPES_MODIFYSUBSCRIPTIONREQUEST 158 + +/** + * ModifySubscriptionResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + UA_Double revisedPublishingInterval; + UA_UInt32 revisedLifetimeCount; + UA_UInt32 revisedMaxKeepAliveCount; +} UA_ModifySubscriptionResponse; + +#define UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE 159 + +/** + * SetPublishingModeRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_Boolean publishingEnabled; + size_t subscriptionIdsSize; + UA_UInt32 *subscriptionIds; +} UA_SetPublishingModeRequest; + +#define UA_TYPES_SETPUBLISHINGMODEREQUEST 160 + +/** + * SetPublishingModeResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_SetPublishingModeResponse; + +#define UA_TYPES_SETPUBLISHINGMODERESPONSE 161 + +/** + * NotificationMessage + * ^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 sequenceNumber; + UA_DateTime publishTime; + size_t notificationDataSize; + UA_ExtensionObject *notificationData; +} UA_NotificationMessage; + +#define UA_TYPES_NOTIFICATIONMESSAGE 162 + +/** + * MonitoredItemNotification + * ^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 clientHandle; + UA_DataValue value; +} UA_MonitoredItemNotification; + +#define UA_TYPES_MONITOREDITEMNOTIFICATION 163 + +/** + * EventFieldList + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 clientHandle; + size_t eventFieldsSize; + UA_Variant *eventFields; +} UA_EventFieldList; + +#define UA_TYPES_EVENTFIELDLIST 164 + +/** + * StatusChangeNotification + * ^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode status; + UA_DiagnosticInfo diagnosticInfo; +} UA_StatusChangeNotification; + +#define UA_TYPES_STATUSCHANGENOTIFICATION 165 + +/** + * SubscriptionAcknowledgement + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 subscriptionId; + UA_UInt32 sequenceNumber; +} UA_SubscriptionAcknowledgement; + +#define UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT 166 + +/** + * PublishRequest + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t subscriptionAcknowledgementsSize; + UA_SubscriptionAcknowledgement *subscriptionAcknowledgements; +} UA_PublishRequest; + +#define UA_TYPES_PUBLISHREQUEST 167 + +/** + * PublishResponse + * ^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + UA_UInt32 subscriptionId; + size_t availableSequenceNumbersSize; + UA_UInt32 *availableSequenceNumbers; + UA_Boolean moreNotifications; + UA_NotificationMessage notificationMessage; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_PublishResponse; + +#define UA_TYPES_PUBLISHRESPONSE 168 + +/** + * RepublishRequest + * ^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + UA_UInt32 subscriptionId; + UA_UInt32 retransmitSequenceNumber; +} UA_RepublishRequest; + +#define UA_TYPES_REPUBLISHREQUEST 169 + +/** + * RepublishResponse + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + UA_NotificationMessage notificationMessage; +} UA_RepublishResponse; + +#define UA_TYPES_REPUBLISHRESPONSE 170 + +/** + * TransferResult + * ^^^^^^^^^^^^^^ + */ +typedef struct { + UA_StatusCode statusCode; + size_t availableSequenceNumbersSize; + UA_UInt32 *availableSequenceNumbers; +} UA_TransferResult; + +#define UA_TYPES_TRANSFERRESULT 171 + +/** + * TransferSubscriptionsRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t subscriptionIdsSize; + UA_UInt32 *subscriptionIds; + UA_Boolean sendInitialValues; +} UA_TransferSubscriptionsRequest; + +#define UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST 172 + +/** + * TransferSubscriptionsResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_TransferResult *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_TransferSubscriptionsResponse; + +#define UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE 173 + +/** + * DeleteSubscriptionsRequest + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_RequestHeader requestHeader; + size_t subscriptionIdsSize; + UA_UInt32 *subscriptionIds; +} UA_DeleteSubscriptionsRequest; + +#define UA_TYPES_DELETESUBSCRIPTIONSREQUEST 174 + +/** + * DeleteSubscriptionsResponse + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_ResponseHeader responseHeader; + size_t resultsSize; + UA_StatusCode *results; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_DeleteSubscriptionsResponse; + +#define UA_TYPES_DELETESUBSCRIPTIONSRESPONSE 175 + +/** + * BuildInfo + * ^^^^^^^^^ + */ +typedef struct { + UA_String productUri; + UA_String manufacturerName; + UA_String productName; + UA_String softwareVersion; + UA_String buildNumber; + UA_DateTime buildDate; +} UA_BuildInfo; + +#define UA_TYPES_BUILDINFO 176 + +/** + * RedundancySupport + * ^^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_REDUNDANCYSUPPORT_NONE = 0, + UA_REDUNDANCYSUPPORT_COLD = 1, + UA_REDUNDANCYSUPPORT_WARM = 2, + UA_REDUNDANCYSUPPORT_HOT = 3, + UA_REDUNDANCYSUPPORT_TRANSPARENT = 4, + UA_REDUNDANCYSUPPORT_HOTANDMIRRORED = 5, + __UA_REDUNDANCYSUPPORT_FORCE32BIT = 0x7fffffff +} UA_RedundancySupport; +UA_STATIC_ASSERT(sizeof(UA_RedundancySupport) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_REDUNDANCYSUPPORT 177 + +/** + * ServerState + * ^^^^^^^^^^^ + */ +typedef enum { + UA_SERVERSTATE_RUNNING = 0, + UA_SERVERSTATE_FAILED = 1, + UA_SERVERSTATE_NOCONFIGURATION = 2, + UA_SERVERSTATE_SUSPENDED = 3, + UA_SERVERSTATE_SHUTDOWN = 4, + UA_SERVERSTATE_TEST = 5, + UA_SERVERSTATE_COMMUNICATIONFAULT = 6, + UA_SERVERSTATE_UNKNOWN = 7, + __UA_SERVERSTATE_FORCE32BIT = 0x7fffffff +} UA_ServerState; +UA_STATIC_ASSERT(sizeof(UA_ServerState) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_SERVERSTATE 178 + +/** + * ServerDiagnosticsSummaryDataType + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_UInt32 serverViewCount; + UA_UInt32 currentSessionCount; + UA_UInt32 cumulatedSessionCount; + UA_UInt32 securityRejectedSessionCount; + UA_UInt32 rejectedSessionCount; + UA_UInt32 sessionTimeoutCount; + UA_UInt32 sessionAbortCount; + UA_UInt32 currentSubscriptionCount; + UA_UInt32 cumulatedSubscriptionCount; + UA_UInt32 publishingIntervalCount; + UA_UInt32 securityRejectedRequestsCount; + UA_UInt32 rejectedRequestsCount; +} UA_ServerDiagnosticsSummaryDataType; + +#define UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE 179 + +/** + * ServerStatusDataType + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_DateTime startTime; + UA_DateTime currentTime; + UA_ServerState state; + UA_BuildInfo buildInfo; + UA_UInt32 secondsTillShutdown; + UA_LocalizedText shutdownReason; +} UA_ServerStatusDataType; + +#define UA_TYPES_SERVERSTATUSDATATYPE 180 + +/** + * Range + * ^^^^^ + */ +typedef struct { + UA_Double low; + UA_Double high; +} UA_Range; + +#define UA_TYPES_RANGE 181 + +/** + * EUInformation + * ^^^^^^^^^^^^^ + */ +typedef struct { + UA_String namespaceUri; + UA_Int32 unitId; + UA_LocalizedText displayName; + UA_LocalizedText description; +} UA_EUInformation; + +#define UA_TYPES_EUINFORMATION 182 + +/** + * AxisScaleEnumeration + * ^^^^^^^^^^^^^^^^^^^^ + */ +typedef enum { + UA_AXISSCALEENUMERATION_LINEAR = 0, + UA_AXISSCALEENUMERATION_LOG = 1, + UA_AXISSCALEENUMERATION_LN = 2, + __UA_AXISSCALEENUMERATION_FORCE32BIT = 0x7fffffff +} UA_AxisScaleEnumeration; +UA_STATIC_ASSERT(sizeof(UA_AxisScaleEnumeration) == sizeof(UA_Int32), enum_must_be_32bit); + +#define UA_TYPES_AXISSCALEENUMERATION 183 + +/** + * ComplexNumberType + * ^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_Float real; + UA_Float imaginary; +} UA_ComplexNumberType; + +#define UA_TYPES_COMPLEXNUMBERTYPE 184 + +/** + * DoubleComplexNumberType + * ^^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_Double real; + UA_Double imaginary; +} UA_DoubleComplexNumberType; + +#define UA_TYPES_DOUBLECOMPLEXNUMBERTYPE 185 + +/** + * AxisInformation + * ^^^^^^^^^^^^^^^ + */ +typedef struct { + UA_EUInformation engineeringUnits; + UA_Range eURange; + UA_LocalizedText title; + UA_AxisScaleEnumeration axisScaleType; + size_t axisStepsSize; + UA_Double *axisSteps; +} UA_AxisInformation; + +#define UA_TYPES_AXISINFORMATION 186 + +/** + * XVType + * ^^^^^^ + */ +typedef struct { + UA_Double x; + UA_Float value; +} UA_XVType; + +#define UA_TYPES_XVTYPE 187 + +/** + * EnumDefinition + * ^^^^^^^^^^^^^^ + */ +typedef struct { + size_t fieldsSize; + UA_EnumField *fields; +} UA_EnumDefinition; + +#define UA_TYPES_ENUMDEFINITION 188 + +/** + * DataChangeNotification + * ^^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + size_t monitoredItemsSize; + UA_MonitoredItemNotification *monitoredItems; + size_t diagnosticInfosSize; + UA_DiagnosticInfo *diagnosticInfos; +} UA_DataChangeNotification; + +#define UA_TYPES_DATACHANGENOTIFICATION 189 + +/** + * EventNotificationList + * ^^^^^^^^^^^^^^^^^^^^^ + */ +typedef struct { + size_t eventsSize; + UA_EventFieldList *events; +} UA_EventNotificationList; + +#define UA_TYPES_EVENTNOTIFICATIONLIST 190 + + +_UA_END_DECLS + + +/**** amalgamated original file "/build_freeRTOS/src_generated/open62541/types_generated_handling.h" ****/ + +/********************************** + * Autogenerated -- do not modify * + **********************************/ + + + +_UA_BEGIN_DECLS + +#if defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 6 +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wmissing-field-initializers" +# pragma GCC diagnostic ignored "-Wmissing-braces" +#endif + + +/* Boolean */ +static UA_INLINE void +UA_Boolean_init(UA_Boolean *p) { + memset(p, 0, sizeof(UA_Boolean)); +} + +static UA_INLINE UA_Boolean * +UA_Boolean_new(void) { + return (UA_Boolean*)UA_new(&UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Boolean_copy(const UA_Boolean *src, UA_Boolean *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Boolean_deleteMembers(UA_Boolean *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE void +UA_Boolean_clear(UA_Boolean *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE void +UA_Boolean_delete(UA_Boolean *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +/* SByte */ +static UA_INLINE void +UA_SByte_init(UA_SByte *p) { + memset(p, 0, sizeof(UA_SByte)); +} + +static UA_INLINE UA_SByte * +UA_SByte_new(void) { + return (UA_SByte*)UA_new(&UA_TYPES[UA_TYPES_SBYTE]); +} + +static UA_INLINE UA_StatusCode +UA_SByte_copy(const UA_SByte *src, UA_SByte *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SBYTE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SByte_deleteMembers(UA_SByte *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SBYTE]); +} + +static UA_INLINE void +UA_SByte_clear(UA_SByte *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SBYTE]); +} + +static UA_INLINE void +UA_SByte_delete(UA_SByte *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SBYTE]); +} + +/* Byte */ +static UA_INLINE void +UA_Byte_init(UA_Byte *p) { + memset(p, 0, sizeof(UA_Byte)); +} + +static UA_INLINE UA_Byte * +UA_Byte_new(void) { + return (UA_Byte*)UA_new(&UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE UA_StatusCode +UA_Byte_copy(const UA_Byte *src, UA_Byte *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BYTE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Byte_deleteMembers(UA_Byte *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE void +UA_Byte_clear(UA_Byte *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE void +UA_Byte_delete(UA_Byte *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BYTE]); +} + +/* Int16 */ +static UA_INLINE void +UA_Int16_init(UA_Int16 *p) { + memset(p, 0, sizeof(UA_Int16)); +} + +static UA_INLINE UA_Int16 * +UA_Int16_new(void) { + return (UA_Int16*)UA_new(&UA_TYPES[UA_TYPES_INT16]); +} + +static UA_INLINE UA_StatusCode +UA_Int16_copy(const UA_Int16 *src, UA_Int16 *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT16]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Int16_deleteMembers(UA_Int16 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_INT16]); +} + +static UA_INLINE void +UA_Int16_clear(UA_Int16 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_INT16]); +} + +static UA_INLINE void +UA_Int16_delete(UA_Int16 *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_INT16]); +} + +/* UInt16 */ +static UA_INLINE void +UA_UInt16_init(UA_UInt16 *p) { + memset(p, 0, sizeof(UA_UInt16)); +} + +static UA_INLINE UA_UInt16 * +UA_UInt16_new(void) { + return (UA_UInt16*)UA_new(&UA_TYPES[UA_TYPES_UINT16]); +} + +static UA_INLINE UA_StatusCode +UA_UInt16_copy(const UA_UInt16 *src, UA_UInt16 *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT16]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UInt16_deleteMembers(UA_UInt16 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UINT16]); +} + +static UA_INLINE void +UA_UInt16_clear(UA_UInt16 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UINT16]); +} + +static UA_INLINE void +UA_UInt16_delete(UA_UInt16 *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_UINT16]); +} + +/* Int32 */ +static UA_INLINE void +UA_Int32_init(UA_Int32 *p) { + memset(p, 0, sizeof(UA_Int32)); +} + +static UA_INLINE UA_Int32 * +UA_Int32_new(void) { + return (UA_Int32*)UA_new(&UA_TYPES[UA_TYPES_INT32]); +} + +static UA_INLINE UA_StatusCode +UA_Int32_copy(const UA_Int32 *src, UA_Int32 *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT32]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Int32_deleteMembers(UA_Int32 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_INT32]); +} + +static UA_INLINE void +UA_Int32_clear(UA_Int32 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_INT32]); +} + +static UA_INLINE void +UA_Int32_delete(UA_Int32 *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_INT32]); +} + +/* UInt32 */ +static UA_INLINE void +UA_UInt32_init(UA_UInt32 *p) { + memset(p, 0, sizeof(UA_UInt32)); +} + +static UA_INLINE UA_UInt32 * +UA_UInt32_new(void) { + return (UA_UInt32*)UA_new(&UA_TYPES[UA_TYPES_UINT32]); +} + +static UA_INLINE UA_StatusCode +UA_UInt32_copy(const UA_UInt32 *src, UA_UInt32 *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT32]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UInt32_deleteMembers(UA_UInt32 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UINT32]); +} + +static UA_INLINE void +UA_UInt32_clear(UA_UInt32 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UINT32]); +} + +static UA_INLINE void +UA_UInt32_delete(UA_UInt32 *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_UINT32]); +} + +/* Int64 */ +static UA_INLINE void +UA_Int64_init(UA_Int64 *p) { + memset(p, 0, sizeof(UA_Int64)); +} + +static UA_INLINE UA_Int64 * +UA_Int64_new(void) { + return (UA_Int64*)UA_new(&UA_TYPES[UA_TYPES_INT64]); +} + +static UA_INLINE UA_StatusCode +UA_Int64_copy(const UA_Int64 *src, UA_Int64 *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_INT64]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Int64_deleteMembers(UA_Int64 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_INT64]); +} + +static UA_INLINE void +UA_Int64_clear(UA_Int64 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_INT64]); +} + +static UA_INLINE void +UA_Int64_delete(UA_Int64 *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_INT64]); +} + +/* UInt64 */ +static UA_INLINE void +UA_UInt64_init(UA_UInt64 *p) { + memset(p, 0, sizeof(UA_UInt64)); +} + +static UA_INLINE UA_UInt64 * +UA_UInt64_new(void) { + return (UA_UInt64*)UA_new(&UA_TYPES[UA_TYPES_UINT64]); +} + +static UA_INLINE UA_StatusCode +UA_UInt64_copy(const UA_UInt64 *src, UA_UInt64 *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UINT64]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UInt64_deleteMembers(UA_UInt64 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UINT64]); +} + +static UA_INLINE void +UA_UInt64_clear(UA_UInt64 *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UINT64]); +} + +static UA_INLINE void +UA_UInt64_delete(UA_UInt64 *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_UINT64]); +} + +/* Float */ +static UA_INLINE void +UA_Float_init(UA_Float *p) { + memset(p, 0, sizeof(UA_Float)); +} + +static UA_INLINE UA_Float * +UA_Float_new(void) { + return (UA_Float*)UA_new(&UA_TYPES[UA_TYPES_FLOAT]); +} + +static UA_INLINE UA_StatusCode +UA_Float_copy(const UA_Float *src, UA_Float *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FLOAT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Float_deleteMembers(UA_Float *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FLOAT]); +} + +static UA_INLINE void +UA_Float_clear(UA_Float *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FLOAT]); +} + +static UA_INLINE void +UA_Float_delete(UA_Float *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_FLOAT]); +} + +/* Double */ +static UA_INLINE void +UA_Double_init(UA_Double *p) { + memset(p, 0, sizeof(UA_Double)); +} + +static UA_INLINE UA_Double * +UA_Double_new(void) { + return (UA_Double*)UA_new(&UA_TYPES[UA_TYPES_DOUBLE]); +} + +static UA_INLINE UA_StatusCode +UA_Double_copy(const UA_Double *src, UA_Double *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DOUBLE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Double_deleteMembers(UA_Double *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLE]); +} + +static UA_INLINE void +UA_Double_clear(UA_Double *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLE]); +} + +static UA_INLINE void +UA_Double_delete(UA_Double *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DOUBLE]); +} + +/* String */ +static UA_INLINE void +UA_String_init(UA_String *p) { + memset(p, 0, sizeof(UA_String)); +} + +static UA_INLINE UA_String * +UA_String_new(void) { + return (UA_String*)UA_new(&UA_TYPES[UA_TYPES_STRING]); +} + +static UA_INLINE UA_StatusCode +UA_String_copy(const UA_String *src, UA_String *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRING]); +} + +UA_DEPRECATED static UA_INLINE void +UA_String_deleteMembers(UA_String *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRING]); +} + +static UA_INLINE void +UA_String_clear(UA_String *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRING]); +} + +static UA_INLINE void +UA_String_delete(UA_String *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_STRING]); +} + +/* DateTime */ +static UA_INLINE void +UA_DateTime_init(UA_DateTime *p) { + memset(p, 0, sizeof(UA_DateTime)); +} + +static UA_INLINE UA_DateTime * +UA_DateTime_new(void) { + return (UA_DateTime*)UA_new(&UA_TYPES[UA_TYPES_DATETIME]); +} + +static UA_INLINE UA_StatusCode +UA_DateTime_copy(const UA_DateTime *src, UA_DateTime *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATETIME]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DateTime_deleteMembers(UA_DateTime *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATETIME]); +} + +static UA_INLINE void +UA_DateTime_clear(UA_DateTime *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATETIME]); +} + +static UA_INLINE void +UA_DateTime_delete(UA_DateTime *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DATETIME]); +} + +/* Guid */ +static UA_INLINE void +UA_Guid_init(UA_Guid *p) { + memset(p, 0, sizeof(UA_Guid)); +} + +static UA_INLINE UA_Guid * +UA_Guid_new(void) { + return (UA_Guid*)UA_new(&UA_TYPES[UA_TYPES_GUID]); +} + +static UA_INLINE UA_StatusCode +UA_Guid_copy(const UA_Guid *src, UA_Guid *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GUID]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Guid_deleteMembers(UA_Guid *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_GUID]); +} + +static UA_INLINE void +UA_Guid_clear(UA_Guid *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_GUID]); +} + +static UA_INLINE void +UA_Guid_delete(UA_Guid *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_GUID]); +} + +/* ByteString */ +static UA_INLINE void +UA_ByteString_init(UA_ByteString *p) { + memset(p, 0, sizeof(UA_ByteString)); +} + +static UA_INLINE UA_ByteString * +UA_ByteString_new(void) { + return (UA_ByteString*)UA_new(&UA_TYPES[UA_TYPES_BYTESTRING]); +} + +static UA_INLINE UA_StatusCode +UA_ByteString_copy(const UA_ByteString *src, UA_ByteString *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BYTESTRING]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ByteString_deleteMembers(UA_ByteString *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BYTESTRING]); +} + +static UA_INLINE void +UA_ByteString_clear(UA_ByteString *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BYTESTRING]); +} + +static UA_INLINE void +UA_ByteString_delete(UA_ByteString *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BYTESTRING]); +} + +/* XmlElement */ +static UA_INLINE void +UA_XmlElement_init(UA_XmlElement *p) { + memset(p, 0, sizeof(UA_XmlElement)); +} + +static UA_INLINE UA_XmlElement * +UA_XmlElement_new(void) { + return (UA_XmlElement*)UA_new(&UA_TYPES[UA_TYPES_XMLELEMENT]); +} + +static UA_INLINE UA_StatusCode +UA_XmlElement_copy(const UA_XmlElement *src, UA_XmlElement *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_XMLELEMENT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_XmlElement_deleteMembers(UA_XmlElement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_XMLELEMENT]); +} + +static UA_INLINE void +UA_XmlElement_clear(UA_XmlElement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_XMLELEMENT]); +} + +static UA_INLINE void +UA_XmlElement_delete(UA_XmlElement *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_XMLELEMENT]); +} + +/* NodeId */ +static UA_INLINE void +UA_NodeId_init(UA_NodeId *p) { + memset(p, 0, sizeof(UA_NodeId)); +} + +static UA_INLINE UA_NodeId * +UA_NodeId_new(void) { + return (UA_NodeId*)UA_new(&UA_TYPES[UA_TYPES_NODEID]); +} + +static UA_INLINE UA_StatusCode +UA_NodeId_copy(const UA_NodeId *src, UA_NodeId *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEID]); +} + +UA_DEPRECATED static UA_INLINE void +UA_NodeId_deleteMembers(UA_NodeId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODEID]); +} + +static UA_INLINE void +UA_NodeId_clear(UA_NodeId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODEID]); +} + +static UA_INLINE void +UA_NodeId_delete(UA_NodeId *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_NODEID]); +} + +/* ExpandedNodeId */ +static UA_INLINE void +UA_ExpandedNodeId_init(UA_ExpandedNodeId *p) { + memset(p, 0, sizeof(UA_ExpandedNodeId)); +} + +static UA_INLINE UA_ExpandedNodeId * +UA_ExpandedNodeId_new(void) { + return (UA_ExpandedNodeId*)UA_new(&UA_TYPES[UA_TYPES_EXPANDEDNODEID]); +} + +static UA_INLINE UA_StatusCode +UA_ExpandedNodeId_copy(const UA_ExpandedNodeId *src, UA_ExpandedNodeId *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ExpandedNodeId_deleteMembers(UA_ExpandedNodeId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); +} + +static UA_INLINE void +UA_ExpandedNodeId_clear(UA_ExpandedNodeId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); +} + +static UA_INLINE void +UA_ExpandedNodeId_delete(UA_ExpandedNodeId *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_EXPANDEDNODEID]); +} + +/* StatusCode */ +static UA_INLINE void +UA_StatusCode_init(UA_StatusCode *p) { + memset(p, 0, sizeof(UA_StatusCode)); +} + +static UA_INLINE UA_StatusCode * +UA_StatusCode_new(void) { + return (UA_StatusCode*)UA_new(&UA_TYPES[UA_TYPES_STATUSCODE]); +} + +static UA_INLINE UA_StatusCode +UA_StatusCode_copy(const UA_StatusCode *src, UA_StatusCode *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_StatusCode_deleteMembers(UA_StatusCode *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +static UA_INLINE void +UA_StatusCode_clear(UA_StatusCode *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +static UA_INLINE void +UA_StatusCode_delete(UA_StatusCode *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_STATUSCODE]); +} + +/* QualifiedName */ +static UA_INLINE void +UA_QualifiedName_init(UA_QualifiedName *p) { + memset(p, 0, sizeof(UA_QualifiedName)); +} + +static UA_INLINE UA_QualifiedName * +UA_QualifiedName_new(void) { + return (UA_QualifiedName*)UA_new(&UA_TYPES[UA_TYPES_QUALIFIEDNAME]); +} + +static UA_INLINE UA_StatusCode +UA_QualifiedName_copy(const UA_QualifiedName *src, UA_QualifiedName *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); +} + +UA_DEPRECATED static UA_INLINE void +UA_QualifiedName_deleteMembers(UA_QualifiedName *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); +} + +static UA_INLINE void +UA_QualifiedName_clear(UA_QualifiedName *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); +} + +static UA_INLINE void +UA_QualifiedName_delete(UA_QualifiedName *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); +} + +/* LocalizedText */ +static UA_INLINE void +UA_LocalizedText_init(UA_LocalizedText *p) { + memset(p, 0, sizeof(UA_LocalizedText)); +} + +static UA_INLINE UA_LocalizedText * +UA_LocalizedText_new(void) { + return (UA_LocalizedText*)UA_new(&UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE UA_StatusCode +UA_LocalizedText_copy(const UA_LocalizedText *src, UA_LocalizedText *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_LocalizedText_deleteMembers(UA_LocalizedText *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE void +UA_LocalizedText_clear(UA_LocalizedText *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE void +UA_LocalizedText_delete(UA_LocalizedText *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +/* ExtensionObject */ +static UA_INLINE void +UA_ExtensionObject_init(UA_ExtensionObject *p) { + memset(p, 0, sizeof(UA_ExtensionObject)); +} + +static UA_INLINE UA_ExtensionObject * +UA_ExtensionObject_new(void) { + return (UA_ExtensionObject*)UA_new(&UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); +} + +static UA_INLINE UA_StatusCode +UA_ExtensionObject_copy(const UA_ExtensionObject *src, UA_ExtensionObject *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ExtensionObject_deleteMembers(UA_ExtensionObject *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); +} + +static UA_INLINE void +UA_ExtensionObject_clear(UA_ExtensionObject *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); +} + +static UA_INLINE void +UA_ExtensionObject_delete(UA_ExtensionObject *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_EXTENSIONOBJECT]); +} + +/* DataValue */ +static UA_INLINE void +UA_DataValue_init(UA_DataValue *p) { + memset(p, 0, sizeof(UA_DataValue)); +} + +static UA_INLINE UA_DataValue * +UA_DataValue_new(void) { + return (UA_DataValue*)UA_new(&UA_TYPES[UA_TYPES_DATAVALUE]); +} + +static UA_INLINE UA_StatusCode +UA_DataValue_copy(const UA_DataValue *src, UA_DataValue *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATAVALUE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DataValue_deleteMembers(UA_DataValue *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATAVALUE]); +} + +static UA_INLINE void +UA_DataValue_clear(UA_DataValue *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATAVALUE]); +} + +static UA_INLINE void +UA_DataValue_delete(UA_DataValue *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DATAVALUE]); +} + +/* Variant */ +static UA_INLINE void +UA_Variant_init(UA_Variant *p) { + memset(p, 0, sizeof(UA_Variant)); +} + +static UA_INLINE UA_Variant * +UA_Variant_new(void) { + return (UA_Variant*)UA_new(&UA_TYPES[UA_TYPES_VARIANT]); +} + +static UA_INLINE UA_StatusCode +UA_Variant_copy(const UA_Variant *src, UA_Variant *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIANT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Variant_deleteMembers(UA_Variant *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VARIANT]); +} + +static UA_INLINE void +UA_Variant_clear(UA_Variant *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VARIANT]); +} + +static UA_INLINE void +UA_Variant_delete(UA_Variant *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_VARIANT]); +} + +/* DiagnosticInfo */ +static UA_INLINE void +UA_DiagnosticInfo_init(UA_DiagnosticInfo *p) { + memset(p, 0, sizeof(UA_DiagnosticInfo)); +} + +static UA_INLINE UA_DiagnosticInfo * +UA_DiagnosticInfo_new(void) { + return (UA_DiagnosticInfo*)UA_new(&UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); +} + +static UA_INLINE UA_StatusCode +UA_DiagnosticInfo_copy(const UA_DiagnosticInfo *src, UA_DiagnosticInfo *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DiagnosticInfo_deleteMembers(UA_DiagnosticInfo *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); +} + +static UA_INLINE void +UA_DiagnosticInfo_clear(UA_DiagnosticInfo *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); +} + +static UA_INLINE void +UA_DiagnosticInfo_delete(UA_DiagnosticInfo *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DIAGNOSTICINFO]); +} + +/* KeyValuePair */ +static UA_INLINE void +UA_KeyValuePair_init(UA_KeyValuePair *p) { + memset(p, 0, sizeof(UA_KeyValuePair)); +} + +static UA_INLINE UA_KeyValuePair * +UA_KeyValuePair_new(void) { + return (UA_KeyValuePair*)UA_new(&UA_TYPES[UA_TYPES_KEYVALUEPAIR]); +} + +static UA_INLINE UA_StatusCode +UA_KeyValuePair_copy(const UA_KeyValuePair *src, UA_KeyValuePair *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); +} + +UA_DEPRECATED static UA_INLINE void +UA_KeyValuePair_deleteMembers(UA_KeyValuePair *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); +} + +static UA_INLINE void +UA_KeyValuePair_clear(UA_KeyValuePair *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); +} + +static UA_INLINE void +UA_KeyValuePair_delete(UA_KeyValuePair *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_KEYVALUEPAIR]); +} + +/* NodeClass */ +static UA_INLINE void +UA_NodeClass_init(UA_NodeClass *p) { + memset(p, 0, sizeof(UA_NodeClass)); +} + +static UA_INLINE UA_NodeClass * +UA_NodeClass_new(void) { + return (UA_NodeClass*)UA_new(&UA_TYPES[UA_TYPES_NODECLASS]); +} + +static UA_INLINE UA_StatusCode +UA_NodeClass_copy(const UA_NodeClass *src, UA_NodeClass *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODECLASS]); +} + +UA_DEPRECATED static UA_INLINE void +UA_NodeClass_deleteMembers(UA_NodeClass *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODECLASS]); +} + +static UA_INLINE void +UA_NodeClass_clear(UA_NodeClass *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODECLASS]); +} + +static UA_INLINE void +UA_NodeClass_delete(UA_NodeClass *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_NODECLASS]); +} + +/* StructureType */ +static UA_INLINE void +UA_StructureType_init(UA_StructureType *p) { + memset(p, 0, sizeof(UA_StructureType)); +} + +static UA_INLINE UA_StructureType * +UA_StructureType_new(void) { + return (UA_StructureType*)UA_new(&UA_TYPES[UA_TYPES_STRUCTURETYPE]); +} + +static UA_INLINE UA_StatusCode +UA_StructureType_copy(const UA_StructureType *src, UA_StructureType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTURETYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_StructureType_deleteMembers(UA_StructureType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]); +} + +static UA_INLINE void +UA_StructureType_clear(UA_StructureType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]); +} + +static UA_INLINE void +UA_StructureType_delete(UA_StructureType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTURETYPE]); +} + +/* StructureField */ +static UA_INLINE void +UA_StructureField_init(UA_StructureField *p) { + memset(p, 0, sizeof(UA_StructureField)); +} + +static UA_INLINE UA_StructureField * +UA_StructureField_new(void) { + return (UA_StructureField*)UA_new(&UA_TYPES[UA_TYPES_STRUCTUREFIELD]); +} + +static UA_INLINE UA_StatusCode +UA_StructureField_copy(const UA_StructureField *src, UA_StructureField *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]); +} + +UA_DEPRECATED static UA_INLINE void +UA_StructureField_deleteMembers(UA_StructureField *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]); +} + +static UA_INLINE void +UA_StructureField_clear(UA_StructureField *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]); +} + +static UA_INLINE void +UA_StructureField_delete(UA_StructureField *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTUREFIELD]); +} + +/* StructureDefinition */ +static UA_INLINE void +UA_StructureDefinition_init(UA_StructureDefinition *p) { + memset(p, 0, sizeof(UA_StructureDefinition)); +} + +static UA_INLINE UA_StructureDefinition * +UA_StructureDefinition_new(void) { + return (UA_StructureDefinition*)UA_new(&UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]); +} + +static UA_INLINE UA_StatusCode +UA_StructureDefinition_copy(const UA_StructureDefinition *src, UA_StructureDefinition *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_StructureDefinition_deleteMembers(UA_StructureDefinition *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]); +} + +static UA_INLINE void +UA_StructureDefinition_clear(UA_StructureDefinition *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]); +} + +static UA_INLINE void +UA_StructureDefinition_delete(UA_StructureDefinition *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_STRUCTUREDEFINITION]); +} + +/* Argument */ +static UA_INLINE void +UA_Argument_init(UA_Argument *p) { + memset(p, 0, sizeof(UA_Argument)); +} + +static UA_INLINE UA_Argument * +UA_Argument_new(void) { + return (UA_Argument*)UA_new(&UA_TYPES[UA_TYPES_ARGUMENT]); +} + +static UA_INLINE UA_StatusCode +UA_Argument_copy(const UA_Argument *src, UA_Argument *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ARGUMENT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Argument_deleteMembers(UA_Argument *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ARGUMENT]); +} + +static UA_INLINE void +UA_Argument_clear(UA_Argument *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ARGUMENT]); +} + +static UA_INLINE void +UA_Argument_delete(UA_Argument *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ARGUMENT]); +} + +/* EnumValueType */ +static UA_INLINE void +UA_EnumValueType_init(UA_EnumValueType *p) { + memset(p, 0, sizeof(UA_EnumValueType)); +} + +static UA_INLINE UA_EnumValueType * +UA_EnumValueType_new(void) { + return (UA_EnumValueType*)UA_new(&UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +} + +static UA_INLINE UA_StatusCode +UA_EnumValueType_copy(const UA_EnumValueType *src, UA_EnumValueType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EnumValueType_deleteMembers(UA_EnumValueType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +} + +static UA_INLINE void +UA_EnumValueType_clear(UA_EnumValueType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +} + +static UA_INLINE void +UA_EnumValueType_delete(UA_EnumValueType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ENUMVALUETYPE]); +} + +/* EnumField */ +static UA_INLINE void +UA_EnumField_init(UA_EnumField *p) { + memset(p, 0, sizeof(UA_EnumField)); +} + +static UA_INLINE UA_EnumField * +UA_EnumField_new(void) { + return (UA_EnumField*)UA_new(&UA_TYPES[UA_TYPES_ENUMFIELD]); +} + +static UA_INLINE UA_StatusCode +UA_EnumField_copy(const UA_EnumField *src, UA_EnumField *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMFIELD]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EnumField_deleteMembers(UA_EnumField *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENUMFIELD]); +} + +static UA_INLINE void +UA_EnumField_clear(UA_EnumField *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENUMFIELD]); +} + +static UA_INLINE void +UA_EnumField_delete(UA_EnumField *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ENUMFIELD]); +} + +/* Duration */ +static UA_INLINE void +UA_Duration_init(UA_Duration *p) { + memset(p, 0, sizeof(UA_Duration)); +} + +static UA_INLINE UA_Duration * +UA_Duration_new(void) { + return (UA_Duration*)UA_new(&UA_TYPES[UA_TYPES_DURATION]); +} + +static UA_INLINE UA_StatusCode +UA_Duration_copy(const UA_Duration *src, UA_Duration *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DURATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Duration_deleteMembers(UA_Duration *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DURATION]); +} + +static UA_INLINE void +UA_Duration_clear(UA_Duration *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DURATION]); +} + +static UA_INLINE void +UA_Duration_delete(UA_Duration *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DURATION]); +} + +/* UtcTime */ +static UA_INLINE void +UA_UtcTime_init(UA_UtcTime *p) { + memset(p, 0, sizeof(UA_UtcTime)); +} + +static UA_INLINE UA_UtcTime * +UA_UtcTime_new(void) { + return (UA_UtcTime*)UA_new(&UA_TYPES[UA_TYPES_UTCTIME]); +} + +static UA_INLINE UA_StatusCode +UA_UtcTime_copy(const UA_UtcTime *src, UA_UtcTime *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UTCTIME]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UtcTime_deleteMembers(UA_UtcTime *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UTCTIME]); +} + +static UA_INLINE void +UA_UtcTime_clear(UA_UtcTime *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UTCTIME]); +} + +static UA_INLINE void +UA_UtcTime_delete(UA_UtcTime *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_UTCTIME]); +} + +/* LocaleId */ +static UA_INLINE void +UA_LocaleId_init(UA_LocaleId *p) { + memset(p, 0, sizeof(UA_LocaleId)); +} + +static UA_INLINE UA_LocaleId * +UA_LocaleId_new(void) { + return (UA_LocaleId*)UA_new(&UA_TYPES[UA_TYPES_LOCALEID]); +} + +static UA_INLINE UA_StatusCode +UA_LocaleId_copy(const UA_LocaleId *src, UA_LocaleId *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LOCALEID]); +} + +UA_DEPRECATED static UA_INLINE void +UA_LocaleId_deleteMembers(UA_LocaleId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_LOCALEID]); +} + +static UA_INLINE void +UA_LocaleId_clear(UA_LocaleId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_LOCALEID]); +} + +static UA_INLINE void +UA_LocaleId_delete(UA_LocaleId *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_LOCALEID]); +} + +/* TimeZoneDataType */ +static UA_INLINE void +UA_TimeZoneDataType_init(UA_TimeZoneDataType *p) { + memset(p, 0, sizeof(UA_TimeZoneDataType)); +} + +static UA_INLINE UA_TimeZoneDataType * +UA_TimeZoneDataType_new(void) { + return (UA_TimeZoneDataType*)UA_new(&UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]); +} + +static UA_INLINE UA_StatusCode +UA_TimeZoneDataType_copy(const UA_TimeZoneDataType *src, UA_TimeZoneDataType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TimeZoneDataType_deleteMembers(UA_TimeZoneDataType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]); +} + +static UA_INLINE void +UA_TimeZoneDataType_clear(UA_TimeZoneDataType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]); +} + +static UA_INLINE void +UA_TimeZoneDataType_delete(UA_TimeZoneDataType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_TIMEZONEDATATYPE]); +} + +/* ApplicationType */ +static UA_INLINE void +UA_ApplicationType_init(UA_ApplicationType *p) { + memset(p, 0, sizeof(UA_ApplicationType)); +} + +static UA_INLINE UA_ApplicationType * +UA_ApplicationType_new(void) { + return (UA_ApplicationType*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_ApplicationType_copy(const UA_ApplicationType *src, UA_ApplicationType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ApplicationType_deleteMembers(UA_ApplicationType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]); +} + +static UA_INLINE void +UA_ApplicationType_clear(UA_ApplicationType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]); +} + +static UA_INLINE void +UA_ApplicationType_delete(UA_ApplicationType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONTYPE]); +} + +/* ApplicationDescription */ +static UA_INLINE void +UA_ApplicationDescription_init(UA_ApplicationDescription *p) { + memset(p, 0, sizeof(UA_ApplicationDescription)); +} + +static UA_INLINE UA_ApplicationDescription * +UA_ApplicationDescription_new(void) { + return (UA_ApplicationDescription*)UA_new(&UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]); +} + +static UA_INLINE UA_StatusCode +UA_ApplicationDescription_copy(const UA_ApplicationDescription *src, UA_ApplicationDescription *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ApplicationDescription_deleteMembers(UA_ApplicationDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]); +} + +static UA_INLINE void +UA_ApplicationDescription_clear(UA_ApplicationDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]); +} + +static UA_INLINE void +UA_ApplicationDescription_delete(UA_ApplicationDescription *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_APPLICATIONDESCRIPTION]); +} + +/* RequestHeader */ +static UA_INLINE void +UA_RequestHeader_init(UA_RequestHeader *p) { + memset(p, 0, sizeof(UA_RequestHeader)); +} + +static UA_INLINE UA_RequestHeader * +UA_RequestHeader_new(void) { + return (UA_RequestHeader*)UA_new(&UA_TYPES[UA_TYPES_REQUESTHEADER]); +} + +static UA_INLINE UA_StatusCode +UA_RequestHeader_copy(const UA_RequestHeader *src, UA_RequestHeader *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REQUESTHEADER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RequestHeader_deleteMembers(UA_RequestHeader *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]); +} + +static UA_INLINE void +UA_RequestHeader_clear(UA_RequestHeader *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]); +} + +static UA_INLINE void +UA_RequestHeader_delete(UA_RequestHeader *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REQUESTHEADER]); +} + +/* ResponseHeader */ +static UA_INLINE void +UA_ResponseHeader_init(UA_ResponseHeader *p) { + memset(p, 0, sizeof(UA_ResponseHeader)); +} + +static UA_INLINE UA_ResponseHeader * +UA_ResponseHeader_new(void) { + return (UA_ResponseHeader*)UA_new(&UA_TYPES[UA_TYPES_RESPONSEHEADER]); +} + +static UA_INLINE UA_StatusCode +UA_ResponseHeader_copy(const UA_ResponseHeader *src, UA_ResponseHeader *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RESPONSEHEADER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ResponseHeader_deleteMembers(UA_ResponseHeader *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]); +} + +static UA_INLINE void +UA_ResponseHeader_clear(UA_ResponseHeader *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]); +} + +static UA_INLINE void +UA_ResponseHeader_delete(UA_ResponseHeader *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_RESPONSEHEADER]); +} + +/* ServiceFault */ +static UA_INLINE void +UA_ServiceFault_init(UA_ServiceFault *p) { + memset(p, 0, sizeof(UA_ServiceFault)); +} + +static UA_INLINE UA_ServiceFault * +UA_ServiceFault_new(void) { + return (UA_ServiceFault*)UA_new(&UA_TYPES[UA_TYPES_SERVICEFAULT]); +} + +static UA_INLINE UA_StatusCode +UA_ServiceFault_copy(const UA_ServiceFault *src, UA_ServiceFault *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVICEFAULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ServiceFault_deleteMembers(UA_ServiceFault *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]); +} + +static UA_INLINE void +UA_ServiceFault_clear(UA_ServiceFault *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]); +} + +static UA_INLINE void +UA_ServiceFault_delete(UA_ServiceFault *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SERVICEFAULT]); +} + +/* FindServersRequest */ +static UA_INLINE void +UA_FindServersRequest_init(UA_FindServersRequest *p) { + memset(p, 0, sizeof(UA_FindServersRequest)); +} + +static UA_INLINE UA_FindServersRequest * +UA_FindServersRequest_new(void) { + return (UA_FindServersRequest*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_FindServersRequest_copy(const UA_FindServersRequest *src, UA_FindServersRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_FindServersRequest_deleteMembers(UA_FindServersRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]); +} + +static UA_INLINE void +UA_FindServersRequest_clear(UA_FindServersRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]); +} + +static UA_INLINE void +UA_FindServersRequest_delete(UA_FindServersRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSREQUEST]); +} + +/* FindServersResponse */ +static UA_INLINE void +UA_FindServersResponse_init(UA_FindServersResponse *p) { + memset(p, 0, sizeof(UA_FindServersResponse)); +} + +static UA_INLINE UA_FindServersResponse * +UA_FindServersResponse_new(void) { + return (UA_FindServersResponse*)UA_new(&UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_FindServersResponse_copy(const UA_FindServersResponse *src, UA_FindServersResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_FindServersResponse_deleteMembers(UA_FindServersResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]); +} + +static UA_INLINE void +UA_FindServersResponse_clear(UA_FindServersResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]); +} + +static UA_INLINE void +UA_FindServersResponse_delete(UA_FindServersResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_FINDSERVERSRESPONSE]); +} + +/* MessageSecurityMode */ +static UA_INLINE void +UA_MessageSecurityMode_init(UA_MessageSecurityMode *p) { + memset(p, 0, sizeof(UA_MessageSecurityMode)); +} + +static UA_INLINE UA_MessageSecurityMode * +UA_MessageSecurityMode_new(void) { + return (UA_MessageSecurityMode*)UA_new(&UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]); +} + +static UA_INLINE UA_StatusCode +UA_MessageSecurityMode_copy(const UA_MessageSecurityMode *src, UA_MessageSecurityMode *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MessageSecurityMode_deleteMembers(UA_MessageSecurityMode *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]); +} + +static UA_INLINE void +UA_MessageSecurityMode_clear(UA_MessageSecurityMode *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]); +} + +static UA_INLINE void +UA_MessageSecurityMode_delete(UA_MessageSecurityMode *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MESSAGESECURITYMODE]); +} + +/* UserTokenType */ +static UA_INLINE void +UA_UserTokenType_init(UA_UserTokenType *p) { + memset(p, 0, sizeof(UA_UserTokenType)); +} + +static UA_INLINE UA_UserTokenType * +UA_UserTokenType_new(void) { + return (UA_UserTokenType*)UA_new(&UA_TYPES[UA_TYPES_USERTOKENTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_UserTokenType_copy(const UA_UserTokenType *src, UA_UserTokenType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERTOKENTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UserTokenType_deleteMembers(UA_UserTokenType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]); +} + +static UA_INLINE void +UA_UserTokenType_clear(UA_UserTokenType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]); +} + +static UA_INLINE void +UA_UserTokenType_delete(UA_UserTokenType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_USERTOKENTYPE]); +} + +/* UserTokenPolicy */ +static UA_INLINE void +UA_UserTokenPolicy_init(UA_UserTokenPolicy *p) { + memset(p, 0, sizeof(UA_UserTokenPolicy)); +} + +static UA_INLINE UA_UserTokenPolicy * +UA_UserTokenPolicy_new(void) { + return (UA_UserTokenPolicy*)UA_new(&UA_TYPES[UA_TYPES_USERTOKENPOLICY]); +} + +static UA_INLINE UA_StatusCode +UA_UserTokenPolicy_copy(const UA_UserTokenPolicy *src, UA_UserTokenPolicy *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UserTokenPolicy_deleteMembers(UA_UserTokenPolicy *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]); +} + +static UA_INLINE void +UA_UserTokenPolicy_clear(UA_UserTokenPolicy *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]); +} + +static UA_INLINE void +UA_UserTokenPolicy_delete(UA_UserTokenPolicy *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_USERTOKENPOLICY]); +} + +/* EndpointDescription */ +static UA_INLINE void +UA_EndpointDescription_init(UA_EndpointDescription *p) { + memset(p, 0, sizeof(UA_EndpointDescription)); +} + +static UA_INLINE UA_EndpointDescription * +UA_EndpointDescription_new(void) { + return (UA_EndpointDescription*)UA_new(&UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); +} + +static UA_INLINE UA_StatusCode +UA_EndpointDescription_copy(const UA_EndpointDescription *src, UA_EndpointDescription *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EndpointDescription_deleteMembers(UA_EndpointDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); +} + +static UA_INLINE void +UA_EndpointDescription_clear(UA_EndpointDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); +} + +static UA_INLINE void +UA_EndpointDescription_delete(UA_EndpointDescription *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); +} + +/* GetEndpointsRequest */ +static UA_INLINE void +UA_GetEndpointsRequest_init(UA_GetEndpointsRequest *p) { + memset(p, 0, sizeof(UA_GetEndpointsRequest)); +} + +static UA_INLINE UA_GetEndpointsRequest * +UA_GetEndpointsRequest_new(void) { + return (UA_GetEndpointsRequest*)UA_new(&UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_GetEndpointsRequest_copy(const UA_GetEndpointsRequest *src, UA_GetEndpointsRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_GetEndpointsRequest_deleteMembers(UA_GetEndpointsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]); +} + +static UA_INLINE void +UA_GetEndpointsRequest_clear(UA_GetEndpointsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]); +} + +static UA_INLINE void +UA_GetEndpointsRequest_delete(UA_GetEndpointsRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_GETENDPOINTSREQUEST]); +} + +/* GetEndpointsResponse */ +static UA_INLINE void +UA_GetEndpointsResponse_init(UA_GetEndpointsResponse *p) { + memset(p, 0, sizeof(UA_GetEndpointsResponse)); +} + +static UA_INLINE UA_GetEndpointsResponse * +UA_GetEndpointsResponse_new(void) { + return (UA_GetEndpointsResponse*)UA_new(&UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_GetEndpointsResponse_copy(const UA_GetEndpointsResponse *src, UA_GetEndpointsResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_GetEndpointsResponse_deleteMembers(UA_GetEndpointsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]); +} + +static UA_INLINE void +UA_GetEndpointsResponse_clear(UA_GetEndpointsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]); +} + +static UA_INLINE void +UA_GetEndpointsResponse_delete(UA_GetEndpointsResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_GETENDPOINTSRESPONSE]); +} + +/* SecurityTokenRequestType */ +static UA_INLINE void +UA_SecurityTokenRequestType_init(UA_SecurityTokenRequestType *p) { + memset(p, 0, sizeof(UA_SecurityTokenRequestType)); +} + +static UA_INLINE UA_SecurityTokenRequestType * +UA_SecurityTokenRequestType_new(void) { + return (UA_SecurityTokenRequestType*)UA_new(&UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_SecurityTokenRequestType_copy(const UA_SecurityTokenRequestType *src, UA_SecurityTokenRequestType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SecurityTokenRequestType_deleteMembers(UA_SecurityTokenRequestType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]); +} + +static UA_INLINE void +UA_SecurityTokenRequestType_clear(UA_SecurityTokenRequestType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]); +} + +static UA_INLINE void +UA_SecurityTokenRequestType_delete(UA_SecurityTokenRequestType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SECURITYTOKENREQUESTTYPE]); +} + +/* ChannelSecurityToken */ +static UA_INLINE void +UA_ChannelSecurityToken_init(UA_ChannelSecurityToken *p) { + memset(p, 0, sizeof(UA_ChannelSecurityToken)); +} + +static UA_INLINE UA_ChannelSecurityToken * +UA_ChannelSecurityToken_new(void) { + return (UA_ChannelSecurityToken*)UA_new(&UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]); +} + +static UA_INLINE UA_StatusCode +UA_ChannelSecurityToken_copy(const UA_ChannelSecurityToken *src, UA_ChannelSecurityToken *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ChannelSecurityToken_deleteMembers(UA_ChannelSecurityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]); +} + +static UA_INLINE void +UA_ChannelSecurityToken_clear(UA_ChannelSecurityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]); +} + +static UA_INLINE void +UA_ChannelSecurityToken_delete(UA_ChannelSecurityToken *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CHANNELSECURITYTOKEN]); +} + +/* OpenSecureChannelRequest */ +static UA_INLINE void +UA_OpenSecureChannelRequest_init(UA_OpenSecureChannelRequest *p) { + memset(p, 0, sizeof(UA_OpenSecureChannelRequest)); +} + +static UA_INLINE UA_OpenSecureChannelRequest * +UA_OpenSecureChannelRequest_new(void) { + return (UA_OpenSecureChannelRequest*)UA_new(&UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_OpenSecureChannelRequest_copy(const UA_OpenSecureChannelRequest *src, UA_OpenSecureChannelRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_OpenSecureChannelRequest_deleteMembers(UA_OpenSecureChannelRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]); +} + +static UA_INLINE void +UA_OpenSecureChannelRequest_clear(UA_OpenSecureChannelRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]); +} + +static UA_INLINE void +UA_OpenSecureChannelRequest_delete(UA_OpenSecureChannelRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELREQUEST]); +} + +/* OpenSecureChannelResponse */ +static UA_INLINE void +UA_OpenSecureChannelResponse_init(UA_OpenSecureChannelResponse *p) { + memset(p, 0, sizeof(UA_OpenSecureChannelResponse)); +} + +static UA_INLINE UA_OpenSecureChannelResponse * +UA_OpenSecureChannelResponse_new(void) { + return (UA_OpenSecureChannelResponse*)UA_new(&UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_OpenSecureChannelResponse_copy(const UA_OpenSecureChannelResponse *src, UA_OpenSecureChannelResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_OpenSecureChannelResponse_deleteMembers(UA_OpenSecureChannelResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]); +} + +static UA_INLINE void +UA_OpenSecureChannelResponse_clear(UA_OpenSecureChannelResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]); +} + +static UA_INLINE void +UA_OpenSecureChannelResponse_delete(UA_OpenSecureChannelResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_OPENSECURECHANNELRESPONSE]); +} + +/* CloseSecureChannelRequest */ +static UA_INLINE void +UA_CloseSecureChannelRequest_init(UA_CloseSecureChannelRequest *p) { + memset(p, 0, sizeof(UA_CloseSecureChannelRequest)); +} + +static UA_INLINE UA_CloseSecureChannelRequest * +UA_CloseSecureChannelRequest_new(void) { + return (UA_CloseSecureChannelRequest*)UA_new(&UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_CloseSecureChannelRequest_copy(const UA_CloseSecureChannelRequest *src, UA_CloseSecureChannelRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CloseSecureChannelRequest_deleteMembers(UA_CloseSecureChannelRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]); +} + +static UA_INLINE void +UA_CloseSecureChannelRequest_clear(UA_CloseSecureChannelRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]); +} + +static UA_INLINE void +UA_CloseSecureChannelRequest_delete(UA_CloseSecureChannelRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELREQUEST]); +} + +/* CloseSecureChannelResponse */ +static UA_INLINE void +UA_CloseSecureChannelResponse_init(UA_CloseSecureChannelResponse *p) { + memset(p, 0, sizeof(UA_CloseSecureChannelResponse)); +} + +static UA_INLINE UA_CloseSecureChannelResponse * +UA_CloseSecureChannelResponse_new(void) { + return (UA_CloseSecureChannelResponse*)UA_new(&UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_CloseSecureChannelResponse_copy(const UA_CloseSecureChannelResponse *src, UA_CloseSecureChannelResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CloseSecureChannelResponse_deleteMembers(UA_CloseSecureChannelResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]); +} + +static UA_INLINE void +UA_CloseSecureChannelResponse_clear(UA_CloseSecureChannelResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]); +} + +static UA_INLINE void +UA_CloseSecureChannelResponse_delete(UA_CloseSecureChannelResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESECURECHANNELRESPONSE]); +} + +/* SignedSoftwareCertificate */ +static UA_INLINE void +UA_SignedSoftwareCertificate_init(UA_SignedSoftwareCertificate *p) { + memset(p, 0, sizeof(UA_SignedSoftwareCertificate)); +} + +static UA_INLINE UA_SignedSoftwareCertificate * +UA_SignedSoftwareCertificate_new(void) { + return (UA_SignedSoftwareCertificate*)UA_new(&UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]); +} + +static UA_INLINE UA_StatusCode +UA_SignedSoftwareCertificate_copy(const UA_SignedSoftwareCertificate *src, UA_SignedSoftwareCertificate *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SignedSoftwareCertificate_deleteMembers(UA_SignedSoftwareCertificate *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]); +} + +static UA_INLINE void +UA_SignedSoftwareCertificate_clear(UA_SignedSoftwareCertificate *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]); +} + +static UA_INLINE void +UA_SignedSoftwareCertificate_delete(UA_SignedSoftwareCertificate *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SIGNEDSOFTWARECERTIFICATE]); +} + +/* SignatureData */ +static UA_INLINE void +UA_SignatureData_init(UA_SignatureData *p) { + memset(p, 0, sizeof(UA_SignatureData)); +} + +static UA_INLINE UA_SignatureData * +UA_SignatureData_new(void) { + return (UA_SignatureData*)UA_new(&UA_TYPES[UA_TYPES_SIGNATUREDATA]); +} + +static UA_INLINE UA_StatusCode +UA_SignatureData_copy(const UA_SignatureData *src, UA_SignatureData *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIGNATUREDATA]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SignatureData_deleteMembers(UA_SignatureData *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]); +} + +static UA_INLINE void +UA_SignatureData_clear(UA_SignatureData *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]); +} + +static UA_INLINE void +UA_SignatureData_delete(UA_SignatureData *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SIGNATUREDATA]); +} + +/* CreateSessionRequest */ +static UA_INLINE void +UA_CreateSessionRequest_init(UA_CreateSessionRequest *p) { + memset(p, 0, sizeof(UA_CreateSessionRequest)); +} + +static UA_INLINE UA_CreateSessionRequest * +UA_CreateSessionRequest_new(void) { + return (UA_CreateSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_CreateSessionRequest_copy(const UA_CreateSessionRequest *src, UA_CreateSessionRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CreateSessionRequest_deleteMembers(UA_CreateSessionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]); +} + +static UA_INLINE void +UA_CreateSessionRequest_clear(UA_CreateSessionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]); +} + +static UA_INLINE void +UA_CreateSessionRequest_delete(UA_CreateSessionRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CREATESESSIONREQUEST]); +} + +/* CreateSessionResponse */ +static UA_INLINE void +UA_CreateSessionResponse_init(UA_CreateSessionResponse *p) { + memset(p, 0, sizeof(UA_CreateSessionResponse)); +} + +static UA_INLINE UA_CreateSessionResponse * +UA_CreateSessionResponse_new(void) { + return (UA_CreateSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_CreateSessionResponse_copy(const UA_CreateSessionResponse *src, UA_CreateSessionResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CreateSessionResponse_deleteMembers(UA_CreateSessionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]); +} + +static UA_INLINE void +UA_CreateSessionResponse_clear(UA_CreateSessionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]); +} + +static UA_INLINE void +UA_CreateSessionResponse_delete(UA_CreateSessionResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CREATESESSIONRESPONSE]); +} + +/* UserIdentityToken */ +static UA_INLINE void +UA_UserIdentityToken_init(UA_UserIdentityToken *p) { + memset(p, 0, sizeof(UA_UserIdentityToken)); +} + +static UA_INLINE UA_UserIdentityToken * +UA_UserIdentityToken_new(void) { + return (UA_UserIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]); +} + +static UA_INLINE UA_StatusCode +UA_UserIdentityToken_copy(const UA_UserIdentityToken *src, UA_UserIdentityToken *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UserIdentityToken_deleteMembers(UA_UserIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_UserIdentityToken_clear(UA_UserIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_UserIdentityToken_delete(UA_UserIdentityToken *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_USERIDENTITYTOKEN]); +} + +/* AnonymousIdentityToken */ +static UA_INLINE void +UA_AnonymousIdentityToken_init(UA_AnonymousIdentityToken *p) { + memset(p, 0, sizeof(UA_AnonymousIdentityToken)); +} + +static UA_INLINE UA_AnonymousIdentityToken * +UA_AnonymousIdentityToken_new(void) { + return (UA_AnonymousIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]); +} + +static UA_INLINE UA_StatusCode +UA_AnonymousIdentityToken_copy(const UA_AnonymousIdentityToken *src, UA_AnonymousIdentityToken *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AnonymousIdentityToken_deleteMembers(UA_AnonymousIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_AnonymousIdentityToken_clear(UA_AnonymousIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_AnonymousIdentityToken_delete(UA_AnonymousIdentityToken *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ANONYMOUSIDENTITYTOKEN]); +} + +/* UserNameIdentityToken */ +static UA_INLINE void +UA_UserNameIdentityToken_init(UA_UserNameIdentityToken *p) { + memset(p, 0, sizeof(UA_UserNameIdentityToken)); +} + +static UA_INLINE UA_UserNameIdentityToken * +UA_UserNameIdentityToken_new(void) { + return (UA_UserNameIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]); +} + +static UA_INLINE UA_StatusCode +UA_UserNameIdentityToken_copy(const UA_UserNameIdentityToken *src, UA_UserNameIdentityToken *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UserNameIdentityToken_deleteMembers(UA_UserNameIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_UserNameIdentityToken_clear(UA_UserNameIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_UserNameIdentityToken_delete(UA_UserNameIdentityToken *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]); +} + +/* X509IdentityToken */ +static UA_INLINE void +UA_X509IdentityToken_init(UA_X509IdentityToken *p) { + memset(p, 0, sizeof(UA_X509IdentityToken)); +} + +static UA_INLINE UA_X509IdentityToken * +UA_X509IdentityToken_new(void) { + return (UA_X509IdentityToken*)UA_new(&UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]); +} + +static UA_INLINE UA_StatusCode +UA_X509IdentityToken_copy(const UA_X509IdentityToken *src, UA_X509IdentityToken *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_X509IdentityToken_deleteMembers(UA_X509IdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]); +} + +static UA_INLINE void +UA_X509IdentityToken_clear(UA_X509IdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]); +} + +static UA_INLINE void +UA_X509IdentityToken_delete(UA_X509IdentityToken *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_X509IDENTITYTOKEN]); +} + +/* IssuedIdentityToken */ +static UA_INLINE void +UA_IssuedIdentityToken_init(UA_IssuedIdentityToken *p) { + memset(p, 0, sizeof(UA_IssuedIdentityToken)); +} + +static UA_INLINE UA_IssuedIdentityToken * +UA_IssuedIdentityToken_new(void) { + return (UA_IssuedIdentityToken*)UA_new(&UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]); +} + +static UA_INLINE UA_StatusCode +UA_IssuedIdentityToken_copy(const UA_IssuedIdentityToken *src, UA_IssuedIdentityToken *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_IssuedIdentityToken_deleteMembers(UA_IssuedIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_IssuedIdentityToken_clear(UA_IssuedIdentityToken *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]); +} + +static UA_INLINE void +UA_IssuedIdentityToken_delete(UA_IssuedIdentityToken *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ISSUEDIDENTITYTOKEN]); +} + +/* ActivateSessionRequest */ +static UA_INLINE void +UA_ActivateSessionRequest_init(UA_ActivateSessionRequest *p) { + memset(p, 0, sizeof(UA_ActivateSessionRequest)); +} + +static UA_INLINE UA_ActivateSessionRequest * +UA_ActivateSessionRequest_new(void) { + return (UA_ActivateSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_ActivateSessionRequest_copy(const UA_ActivateSessionRequest *src, UA_ActivateSessionRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ActivateSessionRequest_deleteMembers(UA_ActivateSessionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]); +} + +static UA_INLINE void +UA_ActivateSessionRequest_clear(UA_ActivateSessionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]); +} + +static UA_INLINE void +UA_ActivateSessionRequest_delete(UA_ActivateSessionRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONREQUEST]); +} + +/* ActivateSessionResponse */ +static UA_INLINE void +UA_ActivateSessionResponse_init(UA_ActivateSessionResponse *p) { + memset(p, 0, sizeof(UA_ActivateSessionResponse)); +} + +static UA_INLINE UA_ActivateSessionResponse * +UA_ActivateSessionResponse_new(void) { + return (UA_ActivateSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_ActivateSessionResponse_copy(const UA_ActivateSessionResponse *src, UA_ActivateSessionResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ActivateSessionResponse_deleteMembers(UA_ActivateSessionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]); +} + +static UA_INLINE void +UA_ActivateSessionResponse_clear(UA_ActivateSessionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]); +} + +static UA_INLINE void +UA_ActivateSessionResponse_delete(UA_ActivateSessionResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ACTIVATESESSIONRESPONSE]); +} + +/* CloseSessionRequest */ +static UA_INLINE void +UA_CloseSessionRequest_init(UA_CloseSessionRequest *p) { + memset(p, 0, sizeof(UA_CloseSessionRequest)); +} + +static UA_INLINE UA_CloseSessionRequest * +UA_CloseSessionRequest_new(void) { + return (UA_CloseSessionRequest*)UA_new(&UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_CloseSessionRequest_copy(const UA_CloseSessionRequest *src, UA_CloseSessionRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CloseSessionRequest_deleteMembers(UA_CloseSessionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]); +} + +static UA_INLINE void +UA_CloseSessionRequest_clear(UA_CloseSessionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]); +} + +static UA_INLINE void +UA_CloseSessionRequest_delete(UA_CloseSessionRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESESSIONREQUEST]); +} + +/* CloseSessionResponse */ +static UA_INLINE void +UA_CloseSessionResponse_init(UA_CloseSessionResponse *p) { + memset(p, 0, sizeof(UA_CloseSessionResponse)); +} + +static UA_INLINE UA_CloseSessionResponse * +UA_CloseSessionResponse_new(void) { + return (UA_CloseSessionResponse*)UA_new(&UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_CloseSessionResponse_copy(const UA_CloseSessionResponse *src, UA_CloseSessionResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CloseSessionResponse_deleteMembers(UA_CloseSessionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]); +} + +static UA_INLINE void +UA_CloseSessionResponse_clear(UA_CloseSessionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]); +} + +static UA_INLINE void +UA_CloseSessionResponse_delete(UA_CloseSessionResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CLOSESESSIONRESPONSE]); +} + +/* NodeAttributesMask */ +static UA_INLINE void +UA_NodeAttributesMask_init(UA_NodeAttributesMask *p) { + memset(p, 0, sizeof(UA_NodeAttributesMask)); +} + +static UA_INLINE UA_NodeAttributesMask * +UA_NodeAttributesMask_new(void) { + return (UA_NodeAttributesMask*)UA_new(&UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]); +} + +static UA_INLINE UA_StatusCode +UA_NodeAttributesMask_copy(const UA_NodeAttributesMask *src, UA_NodeAttributesMask *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]); +} + +UA_DEPRECATED static UA_INLINE void +UA_NodeAttributesMask_deleteMembers(UA_NodeAttributesMask *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]); +} + +static UA_INLINE void +UA_NodeAttributesMask_clear(UA_NodeAttributesMask *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]); +} + +static UA_INLINE void +UA_NodeAttributesMask_delete(UA_NodeAttributesMask *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTESMASK]); +} + +/* NodeAttributes */ +static UA_INLINE void +UA_NodeAttributes_init(UA_NodeAttributes *p) { + memset(p, 0, sizeof(UA_NodeAttributes)); +} + +static UA_INLINE UA_NodeAttributes * +UA_NodeAttributes_new(void) { + return (UA_NodeAttributes*)UA_new(&UA_TYPES[UA_TYPES_NODEATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_NodeAttributes_copy(const UA_NodeAttributes *src, UA_NodeAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_NodeAttributes_deleteMembers(UA_NodeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]); +} + +static UA_INLINE void +UA_NodeAttributes_clear(UA_NodeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]); +} + +static UA_INLINE void +UA_NodeAttributes_delete(UA_NodeAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_NODEATTRIBUTES]); +} + +/* ObjectAttributes */ +static UA_INLINE void +UA_ObjectAttributes_init(UA_ObjectAttributes *p) { + memset(p, 0, sizeof(UA_ObjectAttributes)); +} + +static UA_INLINE UA_ObjectAttributes * +UA_ObjectAttributes_new(void) { + return (UA_ObjectAttributes*)UA_new(&UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_ObjectAttributes_copy(const UA_ObjectAttributes *src, UA_ObjectAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ObjectAttributes_deleteMembers(UA_ObjectAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]); +} + +static UA_INLINE void +UA_ObjectAttributes_clear(UA_ObjectAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]); +} + +static UA_INLINE void +UA_ObjectAttributes_delete(UA_ObjectAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES]); +} + +/* VariableAttributes */ +static UA_INLINE void +UA_VariableAttributes_init(UA_VariableAttributes *p) { + memset(p, 0, sizeof(UA_VariableAttributes)); +} + +static UA_INLINE UA_VariableAttributes * +UA_VariableAttributes_new(void) { + return (UA_VariableAttributes*)UA_new(&UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_VariableAttributes_copy(const UA_VariableAttributes *src, UA_VariableAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_VariableAttributes_deleteMembers(UA_VariableAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]); +} + +static UA_INLINE void +UA_VariableAttributes_clear(UA_VariableAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]); +} + +static UA_INLINE void +UA_VariableAttributes_delete(UA_VariableAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES]); +} + +/* MethodAttributes */ +static UA_INLINE void +UA_MethodAttributes_init(UA_MethodAttributes *p) { + memset(p, 0, sizeof(UA_MethodAttributes)); +} + +static UA_INLINE UA_MethodAttributes * +UA_MethodAttributes_new(void) { + return (UA_MethodAttributes*)UA_new(&UA_TYPES[UA_TYPES_METHODATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_MethodAttributes_copy(const UA_MethodAttributes *src, UA_MethodAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MethodAttributes_deleteMembers(UA_MethodAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]); +} + +static UA_INLINE void +UA_MethodAttributes_clear(UA_MethodAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]); +} + +static UA_INLINE void +UA_MethodAttributes_delete(UA_MethodAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_METHODATTRIBUTES]); +} + +/* ObjectTypeAttributes */ +static UA_INLINE void +UA_ObjectTypeAttributes_init(UA_ObjectTypeAttributes *p) { + memset(p, 0, sizeof(UA_ObjectTypeAttributes)); +} + +static UA_INLINE UA_ObjectTypeAttributes * +UA_ObjectTypeAttributes_new(void) { + return (UA_ObjectTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_ObjectTypeAttributes_copy(const UA_ObjectTypeAttributes *src, UA_ObjectTypeAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ObjectTypeAttributes_deleteMembers(UA_ObjectTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_ObjectTypeAttributes_clear(UA_ObjectTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_ObjectTypeAttributes_delete(UA_ObjectTypeAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES]); +} + +/* VariableTypeAttributes */ +static UA_INLINE void +UA_VariableTypeAttributes_init(UA_VariableTypeAttributes *p) { + memset(p, 0, sizeof(UA_VariableTypeAttributes)); +} + +static UA_INLINE UA_VariableTypeAttributes * +UA_VariableTypeAttributes_new(void) { + return (UA_VariableTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_VariableTypeAttributes_copy(const UA_VariableTypeAttributes *src, UA_VariableTypeAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_VariableTypeAttributes_deleteMembers(UA_VariableTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_VariableTypeAttributes_clear(UA_VariableTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_VariableTypeAttributes_delete(UA_VariableTypeAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES]); +} + +/* ReferenceTypeAttributes */ +static UA_INLINE void +UA_ReferenceTypeAttributes_init(UA_ReferenceTypeAttributes *p) { + memset(p, 0, sizeof(UA_ReferenceTypeAttributes)); +} + +static UA_INLINE UA_ReferenceTypeAttributes * +UA_ReferenceTypeAttributes_new(void) { + return (UA_ReferenceTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_ReferenceTypeAttributes_copy(const UA_ReferenceTypeAttributes *src, UA_ReferenceTypeAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ReferenceTypeAttributes_deleteMembers(UA_ReferenceTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_ReferenceTypeAttributes_clear(UA_ReferenceTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_ReferenceTypeAttributes_delete(UA_ReferenceTypeAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES]); +} + +/* DataTypeAttributes */ +static UA_INLINE void +UA_DataTypeAttributes_init(UA_DataTypeAttributes *p) { + memset(p, 0, sizeof(UA_DataTypeAttributes)); +} + +static UA_INLINE UA_DataTypeAttributes * +UA_DataTypeAttributes_new(void) { + return (UA_DataTypeAttributes*)UA_new(&UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_DataTypeAttributes_copy(const UA_DataTypeAttributes *src, UA_DataTypeAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DataTypeAttributes_deleteMembers(UA_DataTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_DataTypeAttributes_clear(UA_DataTypeAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]); +} + +static UA_INLINE void +UA_DataTypeAttributes_delete(UA_DataTypeAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES]); +} + +/* ViewAttributes */ +static UA_INLINE void +UA_ViewAttributes_init(UA_ViewAttributes *p) { + memset(p, 0, sizeof(UA_ViewAttributes)); +} + +static UA_INLINE UA_ViewAttributes * +UA_ViewAttributes_new(void) { + return (UA_ViewAttributes*)UA_new(&UA_TYPES[UA_TYPES_VIEWATTRIBUTES]); +} + +static UA_INLINE UA_StatusCode +UA_ViewAttributes_copy(const UA_ViewAttributes *src, UA_ViewAttributes *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ViewAttributes_deleteMembers(UA_ViewAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]); +} + +static UA_INLINE void +UA_ViewAttributes_clear(UA_ViewAttributes *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]); +} + +static UA_INLINE void +UA_ViewAttributes_delete(UA_ViewAttributes *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_VIEWATTRIBUTES]); +} + +/* AddNodesItem */ +static UA_INLINE void +UA_AddNodesItem_init(UA_AddNodesItem *p) { + memset(p, 0, sizeof(UA_AddNodesItem)); +} + +static UA_INLINE UA_AddNodesItem * +UA_AddNodesItem_new(void) { + return (UA_AddNodesItem*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESITEM]); +} + +static UA_INLINE UA_StatusCode +UA_AddNodesItem_copy(const UA_AddNodesItem *src, UA_AddNodesItem *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESITEM]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AddNodesItem_deleteMembers(UA_AddNodesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]); +} + +static UA_INLINE void +UA_AddNodesItem_clear(UA_AddNodesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]); +} + +static UA_INLINE void +UA_AddNodesItem_delete(UA_AddNodesItem *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESITEM]); +} + +/* AddNodesResult */ +static UA_INLINE void +UA_AddNodesResult_init(UA_AddNodesResult *p) { + memset(p, 0, sizeof(UA_AddNodesResult)); +} + +static UA_INLINE UA_AddNodesResult * +UA_AddNodesResult_new(void) { + return (UA_AddNodesResult*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_AddNodesResult_copy(const UA_AddNodesResult *src, UA_AddNodesResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AddNodesResult_deleteMembers(UA_AddNodesResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]); +} + +static UA_INLINE void +UA_AddNodesResult_clear(UA_AddNodesResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]); +} + +static UA_INLINE void +UA_AddNodesResult_delete(UA_AddNodesResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESRESULT]); +} + +/* AddNodesRequest */ +static UA_INLINE void +UA_AddNodesRequest_init(UA_AddNodesRequest *p) { + memset(p, 0, sizeof(UA_AddNodesRequest)); +} + +static UA_INLINE UA_AddNodesRequest * +UA_AddNodesRequest_new(void) { + return (UA_AddNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_AddNodesRequest_copy(const UA_AddNodesRequest *src, UA_AddNodesRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AddNodesRequest_deleteMembers(UA_AddNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]); +} + +static UA_INLINE void +UA_AddNodesRequest_clear(UA_AddNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]); +} + +static UA_INLINE void +UA_AddNodesRequest_delete(UA_AddNodesRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESREQUEST]); +} + +/* AddNodesResponse */ +static UA_INLINE void +UA_AddNodesResponse_init(UA_AddNodesResponse *p) { + memset(p, 0, sizeof(UA_AddNodesResponse)); +} + +static UA_INLINE UA_AddNodesResponse * +UA_AddNodesResponse_new(void) { + return (UA_AddNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_ADDNODESRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_AddNodesResponse_copy(const UA_AddNodesResponse *src, UA_AddNodesResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AddNodesResponse_deleteMembers(UA_AddNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]); +} + +static UA_INLINE void +UA_AddNodesResponse_clear(UA_AddNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]); +} + +static UA_INLINE void +UA_AddNodesResponse_delete(UA_AddNodesResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]); +} + +/* AddReferencesItem */ +static UA_INLINE void +UA_AddReferencesItem_init(UA_AddReferencesItem *p) { + memset(p, 0, sizeof(UA_AddReferencesItem)); +} + +static UA_INLINE UA_AddReferencesItem * +UA_AddReferencesItem_new(void) { + return (UA_AddReferencesItem*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESITEM]); +} + +static UA_INLINE UA_StatusCode +UA_AddReferencesItem_copy(const UA_AddReferencesItem *src, UA_AddReferencesItem *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AddReferencesItem_deleteMembers(UA_AddReferencesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]); +} + +static UA_INLINE void +UA_AddReferencesItem_clear(UA_AddReferencesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]); +} + +static UA_INLINE void +UA_AddReferencesItem_delete(UA_AddReferencesItem *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESITEM]); +} + +/* AddReferencesRequest */ +static UA_INLINE void +UA_AddReferencesRequest_init(UA_AddReferencesRequest *p) { + memset(p, 0, sizeof(UA_AddReferencesRequest)); +} + +static UA_INLINE UA_AddReferencesRequest * +UA_AddReferencesRequest_new(void) { + return (UA_AddReferencesRequest*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_AddReferencesRequest_copy(const UA_AddReferencesRequest *src, UA_AddReferencesRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AddReferencesRequest_deleteMembers(UA_AddReferencesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]); +} + +static UA_INLINE void +UA_AddReferencesRequest_clear(UA_AddReferencesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]); +} + +static UA_INLINE void +UA_AddReferencesRequest_delete(UA_AddReferencesRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST]); +} + +/* AddReferencesResponse */ +static UA_INLINE void +UA_AddReferencesResponse_init(UA_AddReferencesResponse *p) { + memset(p, 0, sizeof(UA_AddReferencesResponse)); +} + +static UA_INLINE UA_AddReferencesResponse * +UA_AddReferencesResponse_new(void) { + return (UA_AddReferencesResponse*)UA_new(&UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_AddReferencesResponse_copy(const UA_AddReferencesResponse *src, UA_AddReferencesResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AddReferencesResponse_deleteMembers(UA_AddReferencesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]); +} + +static UA_INLINE void +UA_AddReferencesResponse_clear(UA_AddReferencesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]); +} + +static UA_INLINE void +UA_AddReferencesResponse_delete(UA_AddReferencesResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]); +} + +/* DeleteNodesItem */ +static UA_INLINE void +UA_DeleteNodesItem_init(UA_DeleteNodesItem *p) { + memset(p, 0, sizeof(UA_DeleteNodesItem)); +} + +static UA_INLINE UA_DeleteNodesItem * +UA_DeleteNodesItem_new(void) { + return (UA_DeleteNodesItem*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESITEM]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteNodesItem_copy(const UA_DeleteNodesItem *src, UA_DeleteNodesItem *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESITEM]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteNodesItem_deleteMembers(UA_DeleteNodesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]); +} + +static UA_INLINE void +UA_DeleteNodesItem_clear(UA_DeleteNodesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]); +} + +static UA_INLINE void +UA_DeleteNodesItem_delete(UA_DeleteNodesItem *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESITEM]); +} + +/* DeleteNodesRequest */ +static UA_INLINE void +UA_DeleteNodesRequest_init(UA_DeleteNodesRequest *p) { + memset(p, 0, sizeof(UA_DeleteNodesRequest)); +} + +static UA_INLINE UA_DeleteNodesRequest * +UA_DeleteNodesRequest_new(void) { + return (UA_DeleteNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteNodesRequest_copy(const UA_DeleteNodesRequest *src, UA_DeleteNodesRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteNodesRequest_deleteMembers(UA_DeleteNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]); +} + +static UA_INLINE void +UA_DeleteNodesRequest_clear(UA_DeleteNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]); +} + +static UA_INLINE void +UA_DeleteNodesRequest_delete(UA_DeleteNodesRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESREQUEST]); +} + +/* DeleteNodesResponse */ +static UA_INLINE void +UA_DeleteNodesResponse_init(UA_DeleteNodesResponse *p) { + memset(p, 0, sizeof(UA_DeleteNodesResponse)); +} + +static UA_INLINE UA_DeleteNodesResponse * +UA_DeleteNodesResponse_new(void) { + return (UA_DeleteNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETENODESRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteNodesResponse_copy(const UA_DeleteNodesResponse *src, UA_DeleteNodesResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteNodesResponse_deleteMembers(UA_DeleteNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]); +} + +static UA_INLINE void +UA_DeleteNodesResponse_clear(UA_DeleteNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]); +} + +static UA_INLINE void +UA_DeleteNodesResponse_delete(UA_DeleteNodesResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]); +} + +/* DeleteReferencesItem */ +static UA_INLINE void +UA_DeleteReferencesItem_init(UA_DeleteReferencesItem *p) { + memset(p, 0, sizeof(UA_DeleteReferencesItem)); +} + +static UA_INLINE UA_DeleteReferencesItem * +UA_DeleteReferencesItem_new(void) { + return (UA_DeleteReferencesItem*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteReferencesItem_copy(const UA_DeleteReferencesItem *src, UA_DeleteReferencesItem *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteReferencesItem_deleteMembers(UA_DeleteReferencesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]); +} + +static UA_INLINE void +UA_DeleteReferencesItem_clear(UA_DeleteReferencesItem *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]); +} + +static UA_INLINE void +UA_DeleteReferencesItem_delete(UA_DeleteReferencesItem *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESITEM]); +} + +/* DeleteReferencesRequest */ +static UA_INLINE void +UA_DeleteReferencesRequest_init(UA_DeleteReferencesRequest *p) { + memset(p, 0, sizeof(UA_DeleteReferencesRequest)); +} + +static UA_INLINE UA_DeleteReferencesRequest * +UA_DeleteReferencesRequest_new(void) { + return (UA_DeleteReferencesRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteReferencesRequest_copy(const UA_DeleteReferencesRequest *src, UA_DeleteReferencesRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteReferencesRequest_deleteMembers(UA_DeleteReferencesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]); +} + +static UA_INLINE void +UA_DeleteReferencesRequest_clear(UA_DeleteReferencesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]); +} + +static UA_INLINE void +UA_DeleteReferencesRequest_delete(UA_DeleteReferencesRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST]); +} + +/* DeleteReferencesResponse */ +static UA_INLINE void +UA_DeleteReferencesResponse_init(UA_DeleteReferencesResponse *p) { + memset(p, 0, sizeof(UA_DeleteReferencesResponse)); +} + +static UA_INLINE UA_DeleteReferencesResponse * +UA_DeleteReferencesResponse_new(void) { + return (UA_DeleteReferencesResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteReferencesResponse_copy(const UA_DeleteReferencesResponse *src, UA_DeleteReferencesResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteReferencesResponse_deleteMembers(UA_DeleteReferencesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]); +} + +static UA_INLINE void +UA_DeleteReferencesResponse_clear(UA_DeleteReferencesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]); +} + +static UA_INLINE void +UA_DeleteReferencesResponse_delete(UA_DeleteReferencesResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]); +} + +/* BrowseDirection */ +static UA_INLINE void +UA_BrowseDirection_init(UA_BrowseDirection *p) { + memset(p, 0, sizeof(UA_BrowseDirection)); +} + +static UA_INLINE UA_BrowseDirection * +UA_BrowseDirection_new(void) { + return (UA_BrowseDirection*)UA_new(&UA_TYPES[UA_TYPES_BROWSEDIRECTION]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseDirection_copy(const UA_BrowseDirection *src, UA_BrowseDirection *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseDirection_deleteMembers(UA_BrowseDirection *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]); +} + +static UA_INLINE void +UA_BrowseDirection_clear(UA_BrowseDirection *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]); +} + +static UA_INLINE void +UA_BrowseDirection_delete(UA_BrowseDirection *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEDIRECTION]); +} + +/* ViewDescription */ +static UA_INLINE void +UA_ViewDescription_init(UA_ViewDescription *p) { + memset(p, 0, sizeof(UA_ViewDescription)); +} + +static UA_INLINE UA_ViewDescription * +UA_ViewDescription_new(void) { + return (UA_ViewDescription*)UA_new(&UA_TYPES[UA_TYPES_VIEWDESCRIPTION]); +} + +static UA_INLINE UA_StatusCode +UA_ViewDescription_copy(const UA_ViewDescription *src, UA_ViewDescription *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ViewDescription_deleteMembers(UA_ViewDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]); +} + +static UA_INLINE void +UA_ViewDescription_clear(UA_ViewDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]); +} + +static UA_INLINE void +UA_ViewDescription_delete(UA_ViewDescription *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_VIEWDESCRIPTION]); +} + +/* BrowseDescription */ +static UA_INLINE void +UA_BrowseDescription_init(UA_BrowseDescription *p) { + memset(p, 0, sizeof(UA_BrowseDescription)); +} + +static UA_INLINE UA_BrowseDescription * +UA_BrowseDescription_new(void) { + return (UA_BrowseDescription*)UA_new(&UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseDescription_copy(const UA_BrowseDescription *src, UA_BrowseDescription *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseDescription_deleteMembers(UA_BrowseDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]); +} + +static UA_INLINE void +UA_BrowseDescription_clear(UA_BrowseDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]); +} + +static UA_INLINE void +UA_BrowseDescription_delete(UA_BrowseDescription *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEDESCRIPTION]); +} + +/* BrowseResultMask */ +static UA_INLINE void +UA_BrowseResultMask_init(UA_BrowseResultMask *p) { + memset(p, 0, sizeof(UA_BrowseResultMask)); +} + +static UA_INLINE UA_BrowseResultMask * +UA_BrowseResultMask_new(void) { + return (UA_BrowseResultMask*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESULTMASK]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseResultMask_copy(const UA_BrowseResultMask *src, UA_BrowseResultMask *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseResultMask_deleteMembers(UA_BrowseResultMask *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]); +} + +static UA_INLINE void +UA_BrowseResultMask_clear(UA_BrowseResultMask *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]); +} + +static UA_INLINE void +UA_BrowseResultMask_delete(UA_BrowseResultMask *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESULTMASK]); +} + +/* ReferenceDescription */ +static UA_INLINE void +UA_ReferenceDescription_init(UA_ReferenceDescription *p) { + memset(p, 0, sizeof(UA_ReferenceDescription)); +} + +static UA_INLINE UA_ReferenceDescription * +UA_ReferenceDescription_new(void) { + return (UA_ReferenceDescription*)UA_new(&UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]); +} + +static UA_INLINE UA_StatusCode +UA_ReferenceDescription_copy(const UA_ReferenceDescription *src, UA_ReferenceDescription *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ReferenceDescription_deleteMembers(UA_ReferenceDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]); +} + +static UA_INLINE void +UA_ReferenceDescription_clear(UA_ReferenceDescription *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]); +} + +static UA_INLINE void +UA_ReferenceDescription_delete(UA_ReferenceDescription *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REFERENCEDESCRIPTION]); +} + +/* BrowseResult */ +static UA_INLINE void +UA_BrowseResult_init(UA_BrowseResult *p) { + memset(p, 0, sizeof(UA_BrowseResult)); +} + +static UA_INLINE UA_BrowseResult * +UA_BrowseResult_new(void) { + return (UA_BrowseResult*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESULT]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseResult_copy(const UA_BrowseResult *src, UA_BrowseResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseResult_deleteMembers(UA_BrowseResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULT]); +} + +static UA_INLINE void +UA_BrowseResult_clear(UA_BrowseResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESULT]); +} + +static UA_INLINE void +UA_BrowseResult_delete(UA_BrowseResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESULT]); +} + +/* BrowseRequest */ +static UA_INLINE void +UA_BrowseRequest_init(UA_BrowseRequest *p) { + memset(p, 0, sizeof(UA_BrowseRequest)); +} + +static UA_INLINE UA_BrowseRequest * +UA_BrowseRequest_new(void) { + return (UA_BrowseRequest*)UA_new(&UA_TYPES[UA_TYPES_BROWSEREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseRequest_copy(const UA_BrowseRequest *src, UA_BrowseRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseRequest_deleteMembers(UA_BrowseRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]); +} + +static UA_INLINE void +UA_BrowseRequest_clear(UA_BrowseRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]); +} + +static UA_INLINE void +UA_BrowseRequest_delete(UA_BrowseRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEREQUEST]); +} + +/* BrowseResponse */ +static UA_INLINE void +UA_BrowseResponse_init(UA_BrowseResponse *p) { + memset(p, 0, sizeof(UA_BrowseResponse)); +} + +static UA_INLINE UA_BrowseResponse * +UA_BrowseResponse_new(void) { + return (UA_BrowseResponse*)UA_new(&UA_TYPES[UA_TYPES_BROWSERESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseResponse_copy(const UA_BrowseResponse *src, UA_BrowseResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSERESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseResponse_deleteMembers(UA_BrowseResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]); +} + +static UA_INLINE void +UA_BrowseResponse_clear(UA_BrowseResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]); +} + +static UA_INLINE void +UA_BrowseResponse_delete(UA_BrowseResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSERESPONSE]); +} + +/* BrowseNextRequest */ +static UA_INLINE void +UA_BrowseNextRequest_init(UA_BrowseNextRequest *p) { + memset(p, 0, sizeof(UA_BrowseNextRequest)); +} + +static UA_INLINE UA_BrowseNextRequest * +UA_BrowseNextRequest_new(void) { + return (UA_BrowseNextRequest*)UA_new(&UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseNextRequest_copy(const UA_BrowseNextRequest *src, UA_BrowseNextRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseNextRequest_deleteMembers(UA_BrowseNextRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]); +} + +static UA_INLINE void +UA_BrowseNextRequest_clear(UA_BrowseNextRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]); +} + +static UA_INLINE void +UA_BrowseNextRequest_delete(UA_BrowseNextRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST]); +} + +/* BrowseNextResponse */ +static UA_INLINE void +UA_BrowseNextResponse_init(UA_BrowseNextResponse *p) { + memset(p, 0, sizeof(UA_BrowseNextResponse)); +} + +static UA_INLINE UA_BrowseNextResponse * +UA_BrowseNextResponse_new(void) { + return (UA_BrowseNextResponse*)UA_new(&UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_BrowseNextResponse_copy(const UA_BrowseNextResponse *src, UA_BrowseNextResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowseNextResponse_deleteMembers(UA_BrowseNextResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]); +} + +static UA_INLINE void +UA_BrowseNextResponse_clear(UA_BrowseNextResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]); +} + +static UA_INLINE void +UA_BrowseNextResponse_delete(UA_BrowseNextResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]); +} + +/* RelativePathElement */ +static UA_INLINE void +UA_RelativePathElement_init(UA_RelativePathElement *p) { + memset(p, 0, sizeof(UA_RelativePathElement)); +} + +static UA_INLINE UA_RelativePathElement * +UA_RelativePathElement_new(void) { + return (UA_RelativePathElement*)UA_new(&UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]); +} + +static UA_INLINE UA_StatusCode +UA_RelativePathElement_copy(const UA_RelativePathElement *src, UA_RelativePathElement *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RelativePathElement_deleteMembers(UA_RelativePathElement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]); +} + +static UA_INLINE void +UA_RelativePathElement_clear(UA_RelativePathElement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]); +} + +static UA_INLINE void +UA_RelativePathElement_delete(UA_RelativePathElement *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_RELATIVEPATHELEMENT]); +} + +/* RelativePath */ +static UA_INLINE void +UA_RelativePath_init(UA_RelativePath *p) { + memset(p, 0, sizeof(UA_RelativePath)); +} + +static UA_INLINE UA_RelativePath * +UA_RelativePath_new(void) { + return (UA_RelativePath*)UA_new(&UA_TYPES[UA_TYPES_RELATIVEPATH]); +} + +static UA_INLINE UA_StatusCode +UA_RelativePath_copy(const UA_RelativePath *src, UA_RelativePath *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RELATIVEPATH]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RelativePath_deleteMembers(UA_RelativePath *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]); +} + +static UA_INLINE void +UA_RelativePath_clear(UA_RelativePath *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]); +} + +static UA_INLINE void +UA_RelativePath_delete(UA_RelativePath *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_RELATIVEPATH]); +} + +/* BrowsePath */ +static UA_INLINE void +UA_BrowsePath_init(UA_BrowsePath *p) { + memset(p, 0, sizeof(UA_BrowsePath)); +} + +static UA_INLINE UA_BrowsePath * +UA_BrowsePath_new(void) { + return (UA_BrowsePath*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATH]); +} + +static UA_INLINE UA_StatusCode +UA_BrowsePath_copy(const UA_BrowsePath *src, UA_BrowsePath *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATH]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowsePath_deleteMembers(UA_BrowsePath *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATH]); +} + +static UA_INLINE void +UA_BrowsePath_clear(UA_BrowsePath *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATH]); +} + +static UA_INLINE void +UA_BrowsePath_delete(UA_BrowsePath *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATH]); +} + +/* BrowsePathTarget */ +static UA_INLINE void +UA_BrowsePathTarget_init(UA_BrowsePathTarget *p) { + memset(p, 0, sizeof(UA_BrowsePathTarget)); +} + +static UA_INLINE UA_BrowsePathTarget * +UA_BrowsePathTarget_new(void) { + return (UA_BrowsePathTarget*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATHTARGET]); +} + +static UA_INLINE UA_StatusCode +UA_BrowsePathTarget_copy(const UA_BrowsePathTarget *src, UA_BrowsePathTarget *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowsePathTarget_deleteMembers(UA_BrowsePathTarget *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]); +} + +static UA_INLINE void +UA_BrowsePathTarget_clear(UA_BrowsePathTarget *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]); +} + +static UA_INLINE void +UA_BrowsePathTarget_delete(UA_BrowsePathTarget *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATHTARGET]); +} + +/* BrowsePathResult */ +static UA_INLINE void +UA_BrowsePathResult_init(UA_BrowsePathResult *p) { + memset(p, 0, sizeof(UA_BrowsePathResult)); +} + +static UA_INLINE UA_BrowsePathResult * +UA_BrowsePathResult_new(void) { + return (UA_BrowsePathResult*)UA_new(&UA_TYPES[UA_TYPES_BROWSEPATHRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_BrowsePathResult_copy(const UA_BrowsePathResult *src, UA_BrowsePathResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BrowsePathResult_deleteMembers(UA_BrowsePathResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]); +} + +static UA_INLINE void +UA_BrowsePathResult_clear(UA_BrowsePathResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]); +} + +static UA_INLINE void +UA_BrowsePathResult_delete(UA_BrowsePathResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BROWSEPATHRESULT]); +} + +/* TranslateBrowsePathsToNodeIdsRequest */ +static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsRequest_init(UA_TranslateBrowsePathsToNodeIdsRequest *p) { + memset(p, 0, sizeof(UA_TranslateBrowsePathsToNodeIdsRequest)); +} + +static UA_INLINE UA_TranslateBrowsePathsToNodeIdsRequest * +UA_TranslateBrowsePathsToNodeIdsRequest_new(void) { + return (UA_TranslateBrowsePathsToNodeIdsRequest*)UA_new(&UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_TranslateBrowsePathsToNodeIdsRequest_copy(const UA_TranslateBrowsePathsToNodeIdsRequest *src, UA_TranslateBrowsePathsToNodeIdsRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsRequest_deleteMembers(UA_TranslateBrowsePathsToNodeIdsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]); +} + +static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsRequest_clear(UA_TranslateBrowsePathsToNodeIdsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]); +} + +static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsRequest_delete(UA_TranslateBrowsePathsToNodeIdsRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST]); +} + +/* TranslateBrowsePathsToNodeIdsResponse */ +static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsResponse_init(UA_TranslateBrowsePathsToNodeIdsResponse *p) { + memset(p, 0, sizeof(UA_TranslateBrowsePathsToNodeIdsResponse)); +} + +static UA_INLINE UA_TranslateBrowsePathsToNodeIdsResponse * +UA_TranslateBrowsePathsToNodeIdsResponse_new(void) { + return (UA_TranslateBrowsePathsToNodeIdsResponse*)UA_new(&UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_TranslateBrowsePathsToNodeIdsResponse_copy(const UA_TranslateBrowsePathsToNodeIdsResponse *src, UA_TranslateBrowsePathsToNodeIdsResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsResponse_deleteMembers(UA_TranslateBrowsePathsToNodeIdsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]); +} + +static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsResponse_clear(UA_TranslateBrowsePathsToNodeIdsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]); +} + +static UA_INLINE void +UA_TranslateBrowsePathsToNodeIdsResponse_delete(UA_TranslateBrowsePathsToNodeIdsResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]); +} + +/* RegisterNodesRequest */ +static UA_INLINE void +UA_RegisterNodesRequest_init(UA_RegisterNodesRequest *p) { + memset(p, 0, sizeof(UA_RegisterNodesRequest)); +} + +static UA_INLINE UA_RegisterNodesRequest * +UA_RegisterNodesRequest_new(void) { + return (UA_RegisterNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_RegisterNodesRequest_copy(const UA_RegisterNodesRequest *src, UA_RegisterNodesRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RegisterNodesRequest_deleteMembers(UA_RegisterNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]); +} + +static UA_INLINE void +UA_RegisterNodesRequest_clear(UA_RegisterNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]); +} + +static UA_INLINE void +UA_RegisterNodesRequest_delete(UA_RegisterNodesRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST]); +} + +/* RegisterNodesResponse */ +static UA_INLINE void +UA_RegisterNodesResponse_init(UA_RegisterNodesResponse *p) { + memset(p, 0, sizeof(UA_RegisterNodesResponse)); +} + +static UA_INLINE UA_RegisterNodesResponse * +UA_RegisterNodesResponse_new(void) { + return (UA_RegisterNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_RegisterNodesResponse_copy(const UA_RegisterNodesResponse *src, UA_RegisterNodesResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RegisterNodesResponse_deleteMembers(UA_RegisterNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]); +} + +static UA_INLINE void +UA_RegisterNodesResponse_clear(UA_RegisterNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]); +} + +static UA_INLINE void +UA_RegisterNodesResponse_delete(UA_RegisterNodesResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]); +} + +/* UnregisterNodesRequest */ +static UA_INLINE void +UA_UnregisterNodesRequest_init(UA_UnregisterNodesRequest *p) { + memset(p, 0, sizeof(UA_UnregisterNodesRequest)); +} + +static UA_INLINE UA_UnregisterNodesRequest * +UA_UnregisterNodesRequest_new(void) { + return (UA_UnregisterNodesRequest*)UA_new(&UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_UnregisterNodesRequest_copy(const UA_UnregisterNodesRequest *src, UA_UnregisterNodesRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UnregisterNodesRequest_deleteMembers(UA_UnregisterNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]); +} + +static UA_INLINE void +UA_UnregisterNodesRequest_clear(UA_UnregisterNodesRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]); +} + +static UA_INLINE void +UA_UnregisterNodesRequest_delete(UA_UnregisterNodesRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST]); +} + +/* UnregisterNodesResponse */ +static UA_INLINE void +UA_UnregisterNodesResponse_init(UA_UnregisterNodesResponse *p) { + memset(p, 0, sizeof(UA_UnregisterNodesResponse)); +} + +static UA_INLINE UA_UnregisterNodesResponse * +UA_UnregisterNodesResponse_new(void) { + return (UA_UnregisterNodesResponse*)UA_new(&UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_UnregisterNodesResponse_copy(const UA_UnregisterNodesResponse *src, UA_UnregisterNodesResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_UnregisterNodesResponse_deleteMembers(UA_UnregisterNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]); +} + +static UA_INLINE void +UA_UnregisterNodesResponse_clear(UA_UnregisterNodesResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]); +} + +static UA_INLINE void +UA_UnregisterNodesResponse_delete(UA_UnregisterNodesResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]); +} + +/* FilterOperator */ +static UA_INLINE void +UA_FilterOperator_init(UA_FilterOperator *p) { + memset(p, 0, sizeof(UA_FilterOperator)); +} + +static UA_INLINE UA_FilterOperator * +UA_FilterOperator_new(void) { + return (UA_FilterOperator*)UA_new(&UA_TYPES[UA_TYPES_FILTEROPERATOR]); +} + +static UA_INLINE UA_StatusCode +UA_FilterOperator_copy(const UA_FilterOperator *src, UA_FilterOperator *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_FILTEROPERATOR]); +} + +UA_DEPRECATED static UA_INLINE void +UA_FilterOperator_deleteMembers(UA_FilterOperator *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]); +} + +static UA_INLINE void +UA_FilterOperator_clear(UA_FilterOperator *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]); +} + +static UA_INLINE void +UA_FilterOperator_delete(UA_FilterOperator *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_FILTEROPERATOR]); +} + +/* ContentFilterElement */ +static UA_INLINE void +UA_ContentFilterElement_init(UA_ContentFilterElement *p) { + memset(p, 0, sizeof(UA_ContentFilterElement)); +} + +static UA_INLINE UA_ContentFilterElement * +UA_ContentFilterElement_new(void) { + return (UA_ContentFilterElement*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]); +} + +static UA_INLINE UA_StatusCode +UA_ContentFilterElement_copy(const UA_ContentFilterElement *src, UA_ContentFilterElement *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ContentFilterElement_deleteMembers(UA_ContentFilterElement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]); +} + +static UA_INLINE void +UA_ContentFilterElement_clear(UA_ContentFilterElement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]); +} + +static UA_INLINE void +UA_ContentFilterElement_delete(UA_ContentFilterElement *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENT]); +} + +/* ContentFilter */ +static UA_INLINE void +UA_ContentFilter_init(UA_ContentFilter *p) { + memset(p, 0, sizeof(UA_ContentFilter)); +} + +static UA_INLINE UA_ContentFilter * +UA_ContentFilter_new(void) { + return (UA_ContentFilter*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTER]); +} + +static UA_INLINE UA_StatusCode +UA_ContentFilter_copy(const UA_ContentFilter *src, UA_ContentFilter *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ContentFilter_deleteMembers(UA_ContentFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]); +} + +static UA_INLINE void +UA_ContentFilter_clear(UA_ContentFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]); +} + +static UA_INLINE void +UA_ContentFilter_delete(UA_ContentFilter *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTER]); +} + +/* ElementOperand */ +static UA_INLINE void +UA_ElementOperand_init(UA_ElementOperand *p) { + memset(p, 0, sizeof(UA_ElementOperand)); +} + +static UA_INLINE UA_ElementOperand * +UA_ElementOperand_new(void) { + return (UA_ElementOperand*)UA_new(&UA_TYPES[UA_TYPES_ELEMENTOPERAND]); +} + +static UA_INLINE UA_StatusCode +UA_ElementOperand_copy(const UA_ElementOperand *src, UA_ElementOperand *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ElementOperand_deleteMembers(UA_ElementOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]); +} + +static UA_INLINE void +UA_ElementOperand_clear(UA_ElementOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]); +} + +static UA_INLINE void +UA_ElementOperand_delete(UA_ElementOperand *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ELEMENTOPERAND]); +} + +/* LiteralOperand */ +static UA_INLINE void +UA_LiteralOperand_init(UA_LiteralOperand *p) { + memset(p, 0, sizeof(UA_LiteralOperand)); +} + +static UA_INLINE UA_LiteralOperand * +UA_LiteralOperand_new(void) { + return (UA_LiteralOperand*)UA_new(&UA_TYPES[UA_TYPES_LITERALOPERAND]); +} + +static UA_INLINE UA_StatusCode +UA_LiteralOperand_copy(const UA_LiteralOperand *src, UA_LiteralOperand *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_LITERALOPERAND]); +} + +UA_DEPRECATED static UA_INLINE void +UA_LiteralOperand_deleteMembers(UA_LiteralOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]); +} + +static UA_INLINE void +UA_LiteralOperand_clear(UA_LiteralOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]); +} + +static UA_INLINE void +UA_LiteralOperand_delete(UA_LiteralOperand *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_LITERALOPERAND]); +} + +/* AttributeOperand */ +static UA_INLINE void +UA_AttributeOperand_init(UA_AttributeOperand *p) { + memset(p, 0, sizeof(UA_AttributeOperand)); +} + +static UA_INLINE UA_AttributeOperand * +UA_AttributeOperand_new(void) { + return (UA_AttributeOperand*)UA_new(&UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]); +} + +static UA_INLINE UA_StatusCode +UA_AttributeOperand_copy(const UA_AttributeOperand *src, UA_AttributeOperand *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AttributeOperand_deleteMembers(UA_AttributeOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]); +} + +static UA_INLINE void +UA_AttributeOperand_clear(UA_AttributeOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]); +} + +static UA_INLINE void +UA_AttributeOperand_delete(UA_AttributeOperand *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ATTRIBUTEOPERAND]); +} + +/* SimpleAttributeOperand */ +static UA_INLINE void +UA_SimpleAttributeOperand_init(UA_SimpleAttributeOperand *p) { + memset(p, 0, sizeof(UA_SimpleAttributeOperand)); +} + +static UA_INLINE UA_SimpleAttributeOperand * +UA_SimpleAttributeOperand_new(void) { + return (UA_SimpleAttributeOperand*)UA_new(&UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]); +} + +static UA_INLINE UA_StatusCode +UA_SimpleAttributeOperand_copy(const UA_SimpleAttributeOperand *src, UA_SimpleAttributeOperand *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SimpleAttributeOperand_deleteMembers(UA_SimpleAttributeOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]); +} + +static UA_INLINE void +UA_SimpleAttributeOperand_clear(UA_SimpleAttributeOperand *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]); +} + +static UA_INLINE void +UA_SimpleAttributeOperand_delete(UA_SimpleAttributeOperand *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]); +} + +/* ContentFilterElementResult */ +static UA_INLINE void +UA_ContentFilterElementResult_init(UA_ContentFilterElementResult *p) { + memset(p, 0, sizeof(UA_ContentFilterElementResult)); +} + +static UA_INLINE UA_ContentFilterElementResult * +UA_ContentFilterElementResult_new(void) { + return (UA_ContentFilterElementResult*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_ContentFilterElementResult_copy(const UA_ContentFilterElementResult *src, UA_ContentFilterElementResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ContentFilterElementResult_deleteMembers(UA_ContentFilterElementResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]); +} + +static UA_INLINE void +UA_ContentFilterElementResult_clear(UA_ContentFilterElementResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]); +} + +static UA_INLINE void +UA_ContentFilterElementResult_delete(UA_ContentFilterElementResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERELEMENTRESULT]); +} + +/* ContentFilterResult */ +static UA_INLINE void +UA_ContentFilterResult_init(UA_ContentFilterResult *p) { + memset(p, 0, sizeof(UA_ContentFilterResult)); +} + +static UA_INLINE UA_ContentFilterResult * +UA_ContentFilterResult_new(void) { + return (UA_ContentFilterResult*)UA_new(&UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_ContentFilterResult_copy(const UA_ContentFilterResult *src, UA_ContentFilterResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ContentFilterResult_deleteMembers(UA_ContentFilterResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]); +} + +static UA_INLINE void +UA_ContentFilterResult_clear(UA_ContentFilterResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]); +} + +static UA_INLINE void +UA_ContentFilterResult_delete(UA_ContentFilterResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CONTENTFILTERRESULT]); +} + +/* TimestampsToReturn */ +static UA_INLINE void +UA_TimestampsToReturn_init(UA_TimestampsToReturn *p) { + memset(p, 0, sizeof(UA_TimestampsToReturn)); +} + +static UA_INLINE UA_TimestampsToReturn * +UA_TimestampsToReturn_new(void) { + return (UA_TimestampsToReturn*)UA_new(&UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]); +} + +static UA_INLINE UA_StatusCode +UA_TimestampsToReturn_copy(const UA_TimestampsToReturn *src, UA_TimestampsToReturn *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TimestampsToReturn_deleteMembers(UA_TimestampsToReturn *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]); +} + +static UA_INLINE void +UA_TimestampsToReturn_clear(UA_TimestampsToReturn *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]); +} + +static UA_INLINE void +UA_TimestampsToReturn_delete(UA_TimestampsToReturn *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_TIMESTAMPSTORETURN]); +} + +/* ReadValueId */ +static UA_INLINE void +UA_ReadValueId_init(UA_ReadValueId *p) { + memset(p, 0, sizeof(UA_ReadValueId)); +} + +static UA_INLINE UA_ReadValueId * +UA_ReadValueId_new(void) { + return (UA_ReadValueId*)UA_new(&UA_TYPES[UA_TYPES_READVALUEID]); +} + +static UA_INLINE UA_StatusCode +UA_ReadValueId_copy(const UA_ReadValueId *src, UA_ReadValueId *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READVALUEID]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ReadValueId_deleteMembers(UA_ReadValueId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_READVALUEID]); +} + +static UA_INLINE void +UA_ReadValueId_clear(UA_ReadValueId *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_READVALUEID]); +} + +static UA_INLINE void +UA_ReadValueId_delete(UA_ReadValueId *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_READVALUEID]); +} + +/* ReadRequest */ +static UA_INLINE void +UA_ReadRequest_init(UA_ReadRequest *p) { + memset(p, 0, sizeof(UA_ReadRequest)); +} + +static UA_INLINE UA_ReadRequest * +UA_ReadRequest_new(void) { + return (UA_ReadRequest*)UA_new(&UA_TYPES[UA_TYPES_READREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_ReadRequest_copy(const UA_ReadRequest *src, UA_ReadRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ReadRequest_deleteMembers(UA_ReadRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_READREQUEST]); +} + +static UA_INLINE void +UA_ReadRequest_clear(UA_ReadRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_READREQUEST]); +} + +static UA_INLINE void +UA_ReadRequest_delete(UA_ReadRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_READREQUEST]); +} + +/* ReadResponse */ +static UA_INLINE void +UA_ReadResponse_init(UA_ReadResponse *p) { + memset(p, 0, sizeof(UA_ReadResponse)); +} + +static UA_INLINE UA_ReadResponse * +UA_ReadResponse_new(void) { + return (UA_ReadResponse*)UA_new(&UA_TYPES[UA_TYPES_READRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_ReadResponse_copy(const UA_ReadResponse *src, UA_ReadResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_READRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ReadResponse_deleteMembers(UA_ReadResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_READRESPONSE]); +} + +static UA_INLINE void +UA_ReadResponse_clear(UA_ReadResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_READRESPONSE]); +} + +static UA_INLINE void +UA_ReadResponse_delete(UA_ReadResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_READRESPONSE]); +} + +/* WriteValue */ +static UA_INLINE void +UA_WriteValue_init(UA_WriteValue *p) { + memset(p, 0, sizeof(UA_WriteValue)); +} + +static UA_INLINE UA_WriteValue * +UA_WriteValue_new(void) { + return (UA_WriteValue*)UA_new(&UA_TYPES[UA_TYPES_WRITEVALUE]); +} + +static UA_INLINE UA_StatusCode +UA_WriteValue_copy(const UA_WriteValue *src, UA_WriteValue *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITEVALUE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_WriteValue_deleteMembers(UA_WriteValue *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_WRITEVALUE]); +} + +static UA_INLINE void +UA_WriteValue_clear(UA_WriteValue *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_WRITEVALUE]); +} + +static UA_INLINE void +UA_WriteValue_delete(UA_WriteValue *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_WRITEVALUE]); +} + +/* WriteRequest */ +static UA_INLINE void +UA_WriteRequest_init(UA_WriteRequest *p) { + memset(p, 0, sizeof(UA_WriteRequest)); +} + +static UA_INLINE UA_WriteRequest * +UA_WriteRequest_new(void) { + return (UA_WriteRequest*)UA_new(&UA_TYPES[UA_TYPES_WRITEREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_WriteRequest_copy(const UA_WriteRequest *src, UA_WriteRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITEREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_WriteRequest_deleteMembers(UA_WriteRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]); +} + +static UA_INLINE void +UA_WriteRequest_clear(UA_WriteRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]); +} + +static UA_INLINE void +UA_WriteRequest_delete(UA_WriteRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_WRITEREQUEST]); +} + +/* WriteResponse */ +static UA_INLINE void +UA_WriteResponse_init(UA_WriteResponse *p) { + memset(p, 0, sizeof(UA_WriteResponse)); +} + +static UA_INLINE UA_WriteResponse * +UA_WriteResponse_new(void) { + return (UA_WriteResponse*)UA_new(&UA_TYPES[UA_TYPES_WRITERESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_WriteResponse_copy(const UA_WriteResponse *src, UA_WriteResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_WRITERESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_WriteResponse_deleteMembers(UA_WriteResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]); +} + +static UA_INLINE void +UA_WriteResponse_clear(UA_WriteResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]); +} + +static UA_INLINE void +UA_WriteResponse_delete(UA_WriteResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_WRITERESPONSE]); +} + +/* CallMethodRequest */ +static UA_INLINE void +UA_CallMethodRequest_init(UA_CallMethodRequest *p) { + memset(p, 0, sizeof(UA_CallMethodRequest)); +} + +static UA_INLINE UA_CallMethodRequest * +UA_CallMethodRequest_new(void) { + return (UA_CallMethodRequest*)UA_new(&UA_TYPES[UA_TYPES_CALLMETHODREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_CallMethodRequest_copy(const UA_CallMethodRequest *src, UA_CallMethodRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CallMethodRequest_deleteMembers(UA_CallMethodRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]); +} + +static UA_INLINE void +UA_CallMethodRequest_clear(UA_CallMethodRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]); +} + +static UA_INLINE void +UA_CallMethodRequest_delete(UA_CallMethodRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CALLMETHODREQUEST]); +} + +/* CallMethodResult */ +static UA_INLINE void +UA_CallMethodResult_init(UA_CallMethodResult *p) { + memset(p, 0, sizeof(UA_CallMethodResult)); +} + +static UA_INLINE UA_CallMethodResult * +UA_CallMethodResult_new(void) { + return (UA_CallMethodResult*)UA_new(&UA_TYPES[UA_TYPES_CALLMETHODRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_CallMethodResult_copy(const UA_CallMethodResult *src, UA_CallMethodResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CallMethodResult_deleteMembers(UA_CallMethodResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]); +} + +static UA_INLINE void +UA_CallMethodResult_clear(UA_CallMethodResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]); +} + +static UA_INLINE void +UA_CallMethodResult_delete(UA_CallMethodResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CALLMETHODRESULT]); +} + +/* CallRequest */ +static UA_INLINE void +UA_CallRequest_init(UA_CallRequest *p) { + memset(p, 0, sizeof(UA_CallRequest)); +} + +static UA_INLINE UA_CallRequest * +UA_CallRequest_new(void) { + return (UA_CallRequest*)UA_new(&UA_TYPES[UA_TYPES_CALLREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_CallRequest_copy(const UA_CallRequest *src, UA_CallRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CallRequest_deleteMembers(UA_CallRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLREQUEST]); +} + +static UA_INLINE void +UA_CallRequest_clear(UA_CallRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLREQUEST]); +} + +static UA_INLINE void +UA_CallRequest_delete(UA_CallRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CALLREQUEST]); +} + +/* CallResponse */ +static UA_INLINE void +UA_CallResponse_init(UA_CallResponse *p) { + memset(p, 0, sizeof(UA_CallResponse)); +} + +static UA_INLINE UA_CallResponse * +UA_CallResponse_new(void) { + return (UA_CallResponse*)UA_new(&UA_TYPES[UA_TYPES_CALLRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_CallResponse_copy(const UA_CallResponse *src, UA_CallResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CALLRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CallResponse_deleteMembers(UA_CallResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]); +} + +static UA_INLINE void +UA_CallResponse_clear(UA_CallResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]); +} + +static UA_INLINE void +UA_CallResponse_delete(UA_CallResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CALLRESPONSE]); +} + +/* MonitoringMode */ +static UA_INLINE void +UA_MonitoringMode_init(UA_MonitoringMode *p) { + memset(p, 0, sizeof(UA_MonitoringMode)); +} + +static UA_INLINE UA_MonitoringMode * +UA_MonitoringMode_new(void) { + return (UA_MonitoringMode*)UA_new(&UA_TYPES[UA_TYPES_MONITORINGMODE]); +} + +static UA_INLINE UA_StatusCode +UA_MonitoringMode_copy(const UA_MonitoringMode *src, UA_MonitoringMode *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITORINGMODE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MonitoringMode_deleteMembers(UA_MonitoringMode *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]); +} + +static UA_INLINE void +UA_MonitoringMode_clear(UA_MonitoringMode *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]); +} + +static UA_INLINE void +UA_MonitoringMode_delete(UA_MonitoringMode *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MONITORINGMODE]); +} + +/* DataChangeTrigger */ +static UA_INLINE void +UA_DataChangeTrigger_init(UA_DataChangeTrigger *p) { + memset(p, 0, sizeof(UA_DataChangeTrigger)); +} + +static UA_INLINE UA_DataChangeTrigger * +UA_DataChangeTrigger_new(void) { + return (UA_DataChangeTrigger*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGETRIGGER]); +} + +static UA_INLINE UA_StatusCode +UA_DataChangeTrigger_copy(const UA_DataChangeTrigger *src, UA_DataChangeTrigger *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DataChangeTrigger_deleteMembers(UA_DataChangeTrigger *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]); +} + +static UA_INLINE void +UA_DataChangeTrigger_clear(UA_DataChangeTrigger *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]); +} + +static UA_INLINE void +UA_DataChangeTrigger_delete(UA_DataChangeTrigger *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGETRIGGER]); +} + +/* DeadbandType */ +static UA_INLINE void +UA_DeadbandType_init(UA_DeadbandType *p) { + memset(p, 0, sizeof(UA_DeadbandType)); +} + +static UA_INLINE UA_DeadbandType * +UA_DeadbandType_new(void) { + return (UA_DeadbandType*)UA_new(&UA_TYPES[UA_TYPES_DEADBANDTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_DeadbandType_copy(const UA_DeadbandType *src, UA_DeadbandType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DEADBANDTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeadbandType_deleteMembers(UA_DeadbandType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]); +} + +static UA_INLINE void +UA_DeadbandType_clear(UA_DeadbandType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]); +} + +static UA_INLINE void +UA_DeadbandType_delete(UA_DeadbandType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DEADBANDTYPE]); +} + +/* DataChangeFilter */ +static UA_INLINE void +UA_DataChangeFilter_init(UA_DataChangeFilter *p) { + memset(p, 0, sizeof(UA_DataChangeFilter)); +} + +static UA_INLINE UA_DataChangeFilter * +UA_DataChangeFilter_new(void) { + return (UA_DataChangeFilter*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGEFILTER]); +} + +static UA_INLINE UA_StatusCode +UA_DataChangeFilter_copy(const UA_DataChangeFilter *src, UA_DataChangeFilter *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DataChangeFilter_deleteMembers(UA_DataChangeFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]); +} + +static UA_INLINE void +UA_DataChangeFilter_clear(UA_DataChangeFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]); +} + +static UA_INLINE void +UA_DataChangeFilter_delete(UA_DataChangeFilter *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGEFILTER]); +} + +/* EventFilter */ +static UA_INLINE void +UA_EventFilter_init(UA_EventFilter *p) { + memset(p, 0, sizeof(UA_EventFilter)); +} + +static UA_INLINE UA_EventFilter * +UA_EventFilter_new(void) { + return (UA_EventFilter*)UA_new(&UA_TYPES[UA_TYPES_EVENTFILTER]); +} + +static UA_INLINE UA_StatusCode +UA_EventFilter_copy(const UA_EventFilter *src, UA_EventFilter *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFILTER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EventFilter_deleteMembers(UA_EventFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTER]); +} + +static UA_INLINE void +UA_EventFilter_clear(UA_EventFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTER]); +} + +static UA_INLINE void +UA_EventFilter_delete(UA_EventFilter *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFILTER]); +} + +/* AggregateConfiguration */ +static UA_INLINE void +UA_AggregateConfiguration_init(UA_AggregateConfiguration *p) { + memset(p, 0, sizeof(UA_AggregateConfiguration)); +} + +static UA_INLINE UA_AggregateConfiguration * +UA_AggregateConfiguration_new(void) { + return (UA_AggregateConfiguration*)UA_new(&UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]); +} + +static UA_INLINE UA_StatusCode +UA_AggregateConfiguration_copy(const UA_AggregateConfiguration *src, UA_AggregateConfiguration *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AggregateConfiguration_deleteMembers(UA_AggregateConfiguration *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]); +} + +static UA_INLINE void +UA_AggregateConfiguration_clear(UA_AggregateConfiguration *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]); +} + +static UA_INLINE void +UA_AggregateConfiguration_delete(UA_AggregateConfiguration *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_AGGREGATECONFIGURATION]); +} + +/* AggregateFilter */ +static UA_INLINE void +UA_AggregateFilter_init(UA_AggregateFilter *p) { + memset(p, 0, sizeof(UA_AggregateFilter)); +} + +static UA_INLINE UA_AggregateFilter * +UA_AggregateFilter_new(void) { + return (UA_AggregateFilter*)UA_new(&UA_TYPES[UA_TYPES_AGGREGATEFILTER]); +} + +static UA_INLINE UA_StatusCode +UA_AggregateFilter_copy(const UA_AggregateFilter *src, UA_AggregateFilter *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AggregateFilter_deleteMembers(UA_AggregateFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]); +} + +static UA_INLINE void +UA_AggregateFilter_clear(UA_AggregateFilter *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]); +} + +static UA_INLINE void +UA_AggregateFilter_delete(UA_AggregateFilter *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_AGGREGATEFILTER]); +} + +/* EventFilterResult */ +static UA_INLINE void +UA_EventFilterResult_init(UA_EventFilterResult *p) { + memset(p, 0, sizeof(UA_EventFilterResult)); +} + +static UA_INLINE UA_EventFilterResult * +UA_EventFilterResult_new(void) { + return (UA_EventFilterResult*)UA_new(&UA_TYPES[UA_TYPES_EVENTFILTERRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_EventFilterResult_copy(const UA_EventFilterResult *src, UA_EventFilterResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EventFilterResult_deleteMembers(UA_EventFilterResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]); +} + +static UA_INLINE void +UA_EventFilterResult_clear(UA_EventFilterResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]); +} + +static UA_INLINE void +UA_EventFilterResult_delete(UA_EventFilterResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFILTERRESULT]); +} + +/* MonitoringParameters */ +static UA_INLINE void +UA_MonitoringParameters_init(UA_MonitoringParameters *p) { + memset(p, 0, sizeof(UA_MonitoringParameters)); +} + +static UA_INLINE UA_MonitoringParameters * +UA_MonitoringParameters_new(void) { + return (UA_MonitoringParameters*)UA_new(&UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]); +} + +static UA_INLINE UA_StatusCode +UA_MonitoringParameters_copy(const UA_MonitoringParameters *src, UA_MonitoringParameters *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MonitoringParameters_deleteMembers(UA_MonitoringParameters *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]); +} + +static UA_INLINE void +UA_MonitoringParameters_clear(UA_MonitoringParameters *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]); +} + +static UA_INLINE void +UA_MonitoringParameters_delete(UA_MonitoringParameters *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MONITORINGPARAMETERS]); +} + +/* MonitoredItemCreateRequest */ +static UA_INLINE void +UA_MonitoredItemCreateRequest_init(UA_MonitoredItemCreateRequest *p) { + memset(p, 0, sizeof(UA_MonitoredItemCreateRequest)); +} + +static UA_INLINE UA_MonitoredItemCreateRequest * +UA_MonitoredItemCreateRequest_new(void) { + return (UA_MonitoredItemCreateRequest*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_MonitoredItemCreateRequest_copy(const UA_MonitoredItemCreateRequest *src, UA_MonitoredItemCreateRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MonitoredItemCreateRequest_deleteMembers(UA_MonitoredItemCreateRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]); +} + +static UA_INLINE void +UA_MonitoredItemCreateRequest_clear(UA_MonitoredItemCreateRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]); +} + +static UA_INLINE void +UA_MonitoredItemCreateRequest_delete(UA_MonitoredItemCreateRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATEREQUEST]); +} + +/* MonitoredItemCreateResult */ +static UA_INLINE void +UA_MonitoredItemCreateResult_init(UA_MonitoredItemCreateResult *p) { + memset(p, 0, sizeof(UA_MonitoredItemCreateResult)); +} + +static UA_INLINE UA_MonitoredItemCreateResult * +UA_MonitoredItemCreateResult_new(void) { + return (UA_MonitoredItemCreateResult*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]); +} + +static UA_INLINE UA_StatusCode +UA_MonitoredItemCreateResult_copy(const UA_MonitoredItemCreateResult *src, UA_MonitoredItemCreateResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MonitoredItemCreateResult_deleteMembers(UA_MonitoredItemCreateResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]); +} + +static UA_INLINE void +UA_MonitoredItemCreateResult_clear(UA_MonitoredItemCreateResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]); +} + +static UA_INLINE void +UA_MonitoredItemCreateResult_delete(UA_MonitoredItemCreateResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMCREATERESULT]); +} + +/* CreateMonitoredItemsRequest */ +static UA_INLINE void +UA_CreateMonitoredItemsRequest_init(UA_CreateMonitoredItemsRequest *p) { + memset(p, 0, sizeof(UA_CreateMonitoredItemsRequest)); +} + +static UA_INLINE UA_CreateMonitoredItemsRequest * +UA_CreateMonitoredItemsRequest_new(void) { + return (UA_CreateMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_CreateMonitoredItemsRequest_copy(const UA_CreateMonitoredItemsRequest *src, UA_CreateMonitoredItemsRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CreateMonitoredItemsRequest_deleteMembers(UA_CreateMonitoredItemsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]); +} + +static UA_INLINE void +UA_CreateMonitoredItemsRequest_clear(UA_CreateMonitoredItemsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]); +} + +static UA_INLINE void +UA_CreateMonitoredItemsRequest_delete(UA_CreateMonitoredItemsRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSREQUEST]); +} + +/* CreateMonitoredItemsResponse */ +static UA_INLINE void +UA_CreateMonitoredItemsResponse_init(UA_CreateMonitoredItemsResponse *p) { + memset(p, 0, sizeof(UA_CreateMonitoredItemsResponse)); +} + +static UA_INLINE UA_CreateMonitoredItemsResponse * +UA_CreateMonitoredItemsResponse_new(void) { + return (UA_CreateMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_CreateMonitoredItemsResponse_copy(const UA_CreateMonitoredItemsResponse *src, UA_CreateMonitoredItemsResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CreateMonitoredItemsResponse_deleteMembers(UA_CreateMonitoredItemsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE void +UA_CreateMonitoredItemsResponse_clear(UA_CreateMonitoredItemsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE void +UA_CreateMonitoredItemsResponse_delete(UA_CreateMonitoredItemsResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CREATEMONITOREDITEMSRESPONSE]); +} + +/* MonitoredItemModifyRequest */ +static UA_INLINE void +UA_MonitoredItemModifyRequest_init(UA_MonitoredItemModifyRequest *p) { + memset(p, 0, sizeof(UA_MonitoredItemModifyRequest)); +} + +static UA_INLINE UA_MonitoredItemModifyRequest * +UA_MonitoredItemModifyRequest_new(void) { + return (UA_MonitoredItemModifyRequest*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_MonitoredItemModifyRequest_copy(const UA_MonitoredItemModifyRequest *src, UA_MonitoredItemModifyRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MonitoredItemModifyRequest_deleteMembers(UA_MonitoredItemModifyRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]); +} + +static UA_INLINE void +UA_MonitoredItemModifyRequest_clear(UA_MonitoredItemModifyRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]); +} + +static UA_INLINE void +UA_MonitoredItemModifyRequest_delete(UA_MonitoredItemModifyRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYREQUEST]); +} + +/* MonitoredItemModifyResult */ +static UA_INLINE void +UA_MonitoredItemModifyResult_init(UA_MonitoredItemModifyResult *p) { + memset(p, 0, sizeof(UA_MonitoredItemModifyResult)); +} + +static UA_INLINE UA_MonitoredItemModifyResult * +UA_MonitoredItemModifyResult_new(void) { + return (UA_MonitoredItemModifyResult*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_MonitoredItemModifyResult_copy(const UA_MonitoredItemModifyResult *src, UA_MonitoredItemModifyResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MonitoredItemModifyResult_deleteMembers(UA_MonitoredItemModifyResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]); +} + +static UA_INLINE void +UA_MonitoredItemModifyResult_clear(UA_MonitoredItemModifyResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]); +} + +static UA_INLINE void +UA_MonitoredItemModifyResult_delete(UA_MonitoredItemModifyResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMMODIFYRESULT]); +} + +/* ModifyMonitoredItemsRequest */ +static UA_INLINE void +UA_ModifyMonitoredItemsRequest_init(UA_ModifyMonitoredItemsRequest *p) { + memset(p, 0, sizeof(UA_ModifyMonitoredItemsRequest)); +} + +static UA_INLINE UA_ModifyMonitoredItemsRequest * +UA_ModifyMonitoredItemsRequest_new(void) { + return (UA_ModifyMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_ModifyMonitoredItemsRequest_copy(const UA_ModifyMonitoredItemsRequest *src, UA_ModifyMonitoredItemsRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ModifyMonitoredItemsRequest_deleteMembers(UA_ModifyMonitoredItemsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]); +} + +static UA_INLINE void +UA_ModifyMonitoredItemsRequest_clear(UA_ModifyMonitoredItemsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]); +} + +static UA_INLINE void +UA_ModifyMonitoredItemsRequest_delete(UA_ModifyMonitoredItemsRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST]); +} + +/* ModifyMonitoredItemsResponse */ +static UA_INLINE void +UA_ModifyMonitoredItemsResponse_init(UA_ModifyMonitoredItemsResponse *p) { + memset(p, 0, sizeof(UA_ModifyMonitoredItemsResponse)); +} + +static UA_INLINE UA_ModifyMonitoredItemsResponse * +UA_ModifyMonitoredItemsResponse_new(void) { + return (UA_ModifyMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_ModifyMonitoredItemsResponse_copy(const UA_ModifyMonitoredItemsResponse *src, UA_ModifyMonitoredItemsResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ModifyMonitoredItemsResponse_deleteMembers(UA_ModifyMonitoredItemsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE void +UA_ModifyMonitoredItemsResponse_clear(UA_ModifyMonitoredItemsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE void +UA_ModifyMonitoredItemsResponse_delete(UA_ModifyMonitoredItemsResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE]); +} + +/* SetMonitoringModeRequest */ +static UA_INLINE void +UA_SetMonitoringModeRequest_init(UA_SetMonitoringModeRequest *p) { + memset(p, 0, sizeof(UA_SetMonitoringModeRequest)); +} + +static UA_INLINE UA_SetMonitoringModeRequest * +UA_SetMonitoringModeRequest_new(void) { + return (UA_SetMonitoringModeRequest*)UA_new(&UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_SetMonitoringModeRequest_copy(const UA_SetMonitoringModeRequest *src, UA_SetMonitoringModeRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SetMonitoringModeRequest_deleteMembers(UA_SetMonitoringModeRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]); +} + +static UA_INLINE void +UA_SetMonitoringModeRequest_clear(UA_SetMonitoringModeRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]); +} + +static UA_INLINE void +UA_SetMonitoringModeRequest_delete(UA_SetMonitoringModeRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST]); +} + +/* SetMonitoringModeResponse */ +static UA_INLINE void +UA_SetMonitoringModeResponse_init(UA_SetMonitoringModeResponse *p) { + memset(p, 0, sizeof(UA_SetMonitoringModeResponse)); +} + +static UA_INLINE UA_SetMonitoringModeResponse * +UA_SetMonitoringModeResponse_new(void) { + return (UA_SetMonitoringModeResponse*)UA_new(&UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_SetMonitoringModeResponse_copy(const UA_SetMonitoringModeResponse *src, UA_SetMonitoringModeResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SetMonitoringModeResponse_deleteMembers(UA_SetMonitoringModeResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]); +} + +static UA_INLINE void +UA_SetMonitoringModeResponse_clear(UA_SetMonitoringModeResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]); +} + +static UA_INLINE void +UA_SetMonitoringModeResponse_delete(UA_SetMonitoringModeResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]); +} + +/* SetTriggeringRequest */ +static UA_INLINE void +UA_SetTriggeringRequest_init(UA_SetTriggeringRequest *p) { + memset(p, 0, sizeof(UA_SetTriggeringRequest)); +} + +static UA_INLINE UA_SetTriggeringRequest * +UA_SetTriggeringRequest_new(void) { + return (UA_SetTriggeringRequest*)UA_new(&UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_SetTriggeringRequest_copy(const UA_SetTriggeringRequest *src, UA_SetTriggeringRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SetTriggeringRequest_deleteMembers(UA_SetTriggeringRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]); +} + +static UA_INLINE void +UA_SetTriggeringRequest_clear(UA_SetTriggeringRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]); +} + +static UA_INLINE void +UA_SetTriggeringRequest_delete(UA_SetTriggeringRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST]); +} + +/* SetTriggeringResponse */ +static UA_INLINE void +UA_SetTriggeringResponse_init(UA_SetTriggeringResponse *p) { + memset(p, 0, sizeof(UA_SetTriggeringResponse)); +} + +static UA_INLINE UA_SetTriggeringResponse * +UA_SetTriggeringResponse_new(void) { + return (UA_SetTriggeringResponse*)UA_new(&UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_SetTriggeringResponse_copy(const UA_SetTriggeringResponse *src, UA_SetTriggeringResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SetTriggeringResponse_deleteMembers(UA_SetTriggeringResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]); +} + +static UA_INLINE void +UA_SetTriggeringResponse_clear(UA_SetTriggeringResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]); +} + +static UA_INLINE void +UA_SetTriggeringResponse_delete(UA_SetTriggeringResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]); +} + +/* DeleteMonitoredItemsRequest */ +static UA_INLINE void +UA_DeleteMonitoredItemsRequest_init(UA_DeleteMonitoredItemsRequest *p) { + memset(p, 0, sizeof(UA_DeleteMonitoredItemsRequest)); +} + +static UA_INLINE UA_DeleteMonitoredItemsRequest * +UA_DeleteMonitoredItemsRequest_new(void) { + return (UA_DeleteMonitoredItemsRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteMonitoredItemsRequest_copy(const UA_DeleteMonitoredItemsRequest *src, UA_DeleteMonitoredItemsRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteMonitoredItemsRequest_deleteMembers(UA_DeleteMonitoredItemsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]); +} + +static UA_INLINE void +UA_DeleteMonitoredItemsRequest_clear(UA_DeleteMonitoredItemsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]); +} + +static UA_INLINE void +UA_DeleteMonitoredItemsRequest_delete(UA_DeleteMonitoredItemsRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSREQUEST]); +} + +/* DeleteMonitoredItemsResponse */ +static UA_INLINE void +UA_DeleteMonitoredItemsResponse_init(UA_DeleteMonitoredItemsResponse *p) { + memset(p, 0, sizeof(UA_DeleteMonitoredItemsResponse)); +} + +static UA_INLINE UA_DeleteMonitoredItemsResponse * +UA_DeleteMonitoredItemsResponse_new(void) { + return (UA_DeleteMonitoredItemsResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteMonitoredItemsResponse_copy(const UA_DeleteMonitoredItemsResponse *src, UA_DeleteMonitoredItemsResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteMonitoredItemsResponse_deleteMembers(UA_DeleteMonitoredItemsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE void +UA_DeleteMonitoredItemsResponse_clear(UA_DeleteMonitoredItemsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]); +} + +static UA_INLINE void +UA_DeleteMonitoredItemsResponse_delete(UA_DeleteMonitoredItemsResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETEMONITOREDITEMSRESPONSE]); +} + +/* CreateSubscriptionRequest */ +static UA_INLINE void +UA_CreateSubscriptionRequest_init(UA_CreateSubscriptionRequest *p) { + memset(p, 0, sizeof(UA_CreateSubscriptionRequest)); +} + +static UA_INLINE UA_CreateSubscriptionRequest * +UA_CreateSubscriptionRequest_new(void) { + return (UA_CreateSubscriptionRequest*)UA_new(&UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_CreateSubscriptionRequest_copy(const UA_CreateSubscriptionRequest *src, UA_CreateSubscriptionRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CreateSubscriptionRequest_deleteMembers(UA_CreateSubscriptionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]); +} + +static UA_INLINE void +UA_CreateSubscriptionRequest_clear(UA_CreateSubscriptionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]); +} + +static UA_INLINE void +UA_CreateSubscriptionRequest_delete(UA_CreateSubscriptionRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONREQUEST]); +} + +/* CreateSubscriptionResponse */ +static UA_INLINE void +UA_CreateSubscriptionResponse_init(UA_CreateSubscriptionResponse *p) { + memset(p, 0, sizeof(UA_CreateSubscriptionResponse)); +} + +static UA_INLINE UA_CreateSubscriptionResponse * +UA_CreateSubscriptionResponse_new(void) { + return (UA_CreateSubscriptionResponse*)UA_new(&UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_CreateSubscriptionResponse_copy(const UA_CreateSubscriptionResponse *src, UA_CreateSubscriptionResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_CreateSubscriptionResponse_deleteMembers(UA_CreateSubscriptionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]); +} + +static UA_INLINE void +UA_CreateSubscriptionResponse_clear(UA_CreateSubscriptionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]); +} + +static UA_INLINE void +UA_CreateSubscriptionResponse_delete(UA_CreateSubscriptionResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_CREATESUBSCRIPTIONRESPONSE]); +} + +/* ModifySubscriptionRequest */ +static UA_INLINE void +UA_ModifySubscriptionRequest_init(UA_ModifySubscriptionRequest *p) { + memset(p, 0, sizeof(UA_ModifySubscriptionRequest)); +} + +static UA_INLINE UA_ModifySubscriptionRequest * +UA_ModifySubscriptionRequest_new(void) { + return (UA_ModifySubscriptionRequest*)UA_new(&UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_ModifySubscriptionRequest_copy(const UA_ModifySubscriptionRequest *src, UA_ModifySubscriptionRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ModifySubscriptionRequest_deleteMembers(UA_ModifySubscriptionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]); +} + +static UA_INLINE void +UA_ModifySubscriptionRequest_clear(UA_ModifySubscriptionRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]); +} + +static UA_INLINE void +UA_ModifySubscriptionRequest_delete(UA_ModifySubscriptionRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONREQUEST]); +} + +/* ModifySubscriptionResponse */ +static UA_INLINE void +UA_ModifySubscriptionResponse_init(UA_ModifySubscriptionResponse *p) { + memset(p, 0, sizeof(UA_ModifySubscriptionResponse)); +} + +static UA_INLINE UA_ModifySubscriptionResponse * +UA_ModifySubscriptionResponse_new(void) { + return (UA_ModifySubscriptionResponse*)UA_new(&UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_ModifySubscriptionResponse_copy(const UA_ModifySubscriptionResponse *src, UA_ModifySubscriptionResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ModifySubscriptionResponse_deleteMembers(UA_ModifySubscriptionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]); +} + +static UA_INLINE void +UA_ModifySubscriptionResponse_clear(UA_ModifySubscriptionResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]); +} + +static UA_INLINE void +UA_ModifySubscriptionResponse_delete(UA_ModifySubscriptionResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MODIFYSUBSCRIPTIONRESPONSE]); +} + +/* SetPublishingModeRequest */ +static UA_INLINE void +UA_SetPublishingModeRequest_init(UA_SetPublishingModeRequest *p) { + memset(p, 0, sizeof(UA_SetPublishingModeRequest)); +} + +static UA_INLINE UA_SetPublishingModeRequest * +UA_SetPublishingModeRequest_new(void) { + return (UA_SetPublishingModeRequest*)UA_new(&UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_SetPublishingModeRequest_copy(const UA_SetPublishingModeRequest *src, UA_SetPublishingModeRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SetPublishingModeRequest_deleteMembers(UA_SetPublishingModeRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]); +} + +static UA_INLINE void +UA_SetPublishingModeRequest_clear(UA_SetPublishingModeRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]); +} + +static UA_INLINE void +UA_SetPublishingModeRequest_delete(UA_SetPublishingModeRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST]); +} + +/* SetPublishingModeResponse */ +static UA_INLINE void +UA_SetPublishingModeResponse_init(UA_SetPublishingModeResponse *p) { + memset(p, 0, sizeof(UA_SetPublishingModeResponse)); +} + +static UA_INLINE UA_SetPublishingModeResponse * +UA_SetPublishingModeResponse_new(void) { + return (UA_SetPublishingModeResponse*)UA_new(&UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_SetPublishingModeResponse_copy(const UA_SetPublishingModeResponse *src, UA_SetPublishingModeResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SetPublishingModeResponse_deleteMembers(UA_SetPublishingModeResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]); +} + +static UA_INLINE void +UA_SetPublishingModeResponse_clear(UA_SetPublishingModeResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]); +} + +static UA_INLINE void +UA_SetPublishingModeResponse_delete(UA_SetPublishingModeResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]); +} + +/* NotificationMessage */ +static UA_INLINE void +UA_NotificationMessage_init(UA_NotificationMessage *p) { + memset(p, 0, sizeof(UA_NotificationMessage)); +} + +static UA_INLINE UA_NotificationMessage * +UA_NotificationMessage_new(void) { + return (UA_NotificationMessage*)UA_new(&UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]); +} + +static UA_INLINE UA_StatusCode +UA_NotificationMessage_copy(const UA_NotificationMessage *src, UA_NotificationMessage *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_NotificationMessage_deleteMembers(UA_NotificationMessage *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]); +} + +static UA_INLINE void +UA_NotificationMessage_clear(UA_NotificationMessage *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]); +} + +static UA_INLINE void +UA_NotificationMessage_delete(UA_NotificationMessage *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_NOTIFICATIONMESSAGE]); +} + +/* MonitoredItemNotification */ +static UA_INLINE void +UA_MonitoredItemNotification_init(UA_MonitoredItemNotification *p) { + memset(p, 0, sizeof(UA_MonitoredItemNotification)); +} + +static UA_INLINE UA_MonitoredItemNotification * +UA_MonitoredItemNotification_new(void) { + return (UA_MonitoredItemNotification*)UA_new(&UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]); +} + +static UA_INLINE UA_StatusCode +UA_MonitoredItemNotification_copy(const UA_MonitoredItemNotification *src, UA_MonitoredItemNotification *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_MonitoredItemNotification_deleteMembers(UA_MonitoredItemNotification *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]); +} + +static UA_INLINE void +UA_MonitoredItemNotification_clear(UA_MonitoredItemNotification *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]); +} + +static UA_INLINE void +UA_MonitoredItemNotification_delete(UA_MonitoredItemNotification *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_MONITOREDITEMNOTIFICATION]); +} + +/* EventFieldList */ +static UA_INLINE void +UA_EventFieldList_init(UA_EventFieldList *p) { + memset(p, 0, sizeof(UA_EventFieldList)); +} + +static UA_INLINE UA_EventFieldList * +UA_EventFieldList_new(void) { + return (UA_EventFieldList*)UA_new(&UA_TYPES[UA_TYPES_EVENTFIELDLIST]); +} + +static UA_INLINE UA_StatusCode +UA_EventFieldList_copy(const UA_EventFieldList *src, UA_EventFieldList *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EventFieldList_deleteMembers(UA_EventFieldList *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]); +} + +static UA_INLINE void +UA_EventFieldList_clear(UA_EventFieldList *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]); +} + +static UA_INLINE void +UA_EventFieldList_delete(UA_EventFieldList *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_EVENTFIELDLIST]); +} + +/* StatusChangeNotification */ +static UA_INLINE void +UA_StatusChangeNotification_init(UA_StatusChangeNotification *p) { + memset(p, 0, sizeof(UA_StatusChangeNotification)); +} + +static UA_INLINE UA_StatusChangeNotification * +UA_StatusChangeNotification_new(void) { + return (UA_StatusChangeNotification*)UA_new(&UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]); +} + +static UA_INLINE UA_StatusCode +UA_StatusChangeNotification_copy(const UA_StatusChangeNotification *src, UA_StatusChangeNotification *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_StatusChangeNotification_deleteMembers(UA_StatusChangeNotification *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]); +} + +static UA_INLINE void +UA_StatusChangeNotification_clear(UA_StatusChangeNotification *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]); +} + +static UA_INLINE void +UA_StatusChangeNotification_delete(UA_StatusChangeNotification *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_STATUSCHANGENOTIFICATION]); +} + +/* SubscriptionAcknowledgement */ +static UA_INLINE void +UA_SubscriptionAcknowledgement_init(UA_SubscriptionAcknowledgement *p) { + memset(p, 0, sizeof(UA_SubscriptionAcknowledgement)); +} + +static UA_INLINE UA_SubscriptionAcknowledgement * +UA_SubscriptionAcknowledgement_new(void) { + return (UA_SubscriptionAcknowledgement*)UA_new(&UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]); +} + +static UA_INLINE UA_StatusCode +UA_SubscriptionAcknowledgement_copy(const UA_SubscriptionAcknowledgement *src, UA_SubscriptionAcknowledgement *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_SubscriptionAcknowledgement_deleteMembers(UA_SubscriptionAcknowledgement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]); +} + +static UA_INLINE void +UA_SubscriptionAcknowledgement_clear(UA_SubscriptionAcknowledgement *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]); +} + +static UA_INLINE void +UA_SubscriptionAcknowledgement_delete(UA_SubscriptionAcknowledgement *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SUBSCRIPTIONACKNOWLEDGEMENT]); +} + +/* PublishRequest */ +static UA_INLINE void +UA_PublishRequest_init(UA_PublishRequest *p) { + memset(p, 0, sizeof(UA_PublishRequest)); +} + +static UA_INLINE UA_PublishRequest * +UA_PublishRequest_new(void) { + return (UA_PublishRequest*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_PublishRequest_copy(const UA_PublishRequest *src, UA_PublishRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_PublishRequest_deleteMembers(UA_PublishRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]); +} + +static UA_INLINE void +UA_PublishRequest_clear(UA_PublishRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]); +} + +static UA_INLINE void +UA_PublishRequest_delete(UA_PublishRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHREQUEST]); +} + +/* PublishResponse */ +static UA_INLINE void +UA_PublishResponse_init(UA_PublishResponse *p) { + memset(p, 0, sizeof(UA_PublishResponse)); +} + +static UA_INLINE UA_PublishResponse * +UA_PublishResponse_new(void) { + return (UA_PublishResponse*)UA_new(&UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_PublishResponse_copy(const UA_PublishResponse *src, UA_PublishResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_PublishResponse_deleteMembers(UA_PublishResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); +} + +static UA_INLINE void +UA_PublishResponse_clear(UA_PublishResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); +} + +static UA_INLINE void +UA_PublishResponse_delete(UA_PublishResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_PUBLISHRESPONSE]); +} + +/* RepublishRequest */ +static UA_INLINE void +UA_RepublishRequest_init(UA_RepublishRequest *p) { + memset(p, 0, sizeof(UA_RepublishRequest)); +} + +static UA_INLINE UA_RepublishRequest * +UA_RepublishRequest_new(void) { + return (UA_RepublishRequest*)UA_new(&UA_TYPES[UA_TYPES_REPUBLISHREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_RepublishRequest_copy(const UA_RepublishRequest *src, UA_RepublishRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RepublishRequest_deleteMembers(UA_RepublishRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]); +} + +static UA_INLINE void +UA_RepublishRequest_clear(UA_RepublishRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]); +} + +static UA_INLINE void +UA_RepublishRequest_delete(UA_RepublishRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REPUBLISHREQUEST]); +} + +/* RepublishResponse */ +static UA_INLINE void +UA_RepublishResponse_init(UA_RepublishResponse *p) { + memset(p, 0, sizeof(UA_RepublishResponse)); +} + +static UA_INLINE UA_RepublishResponse * +UA_RepublishResponse_new(void) { + return (UA_RepublishResponse*)UA_new(&UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_RepublishResponse_copy(const UA_RepublishResponse *src, UA_RepublishResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RepublishResponse_deleteMembers(UA_RepublishResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]); +} + +static UA_INLINE void +UA_RepublishResponse_clear(UA_RepublishResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]); +} + +static UA_INLINE void +UA_RepublishResponse_delete(UA_RepublishResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REPUBLISHRESPONSE]); +} + +/* TransferResult */ +static UA_INLINE void +UA_TransferResult_init(UA_TransferResult *p) { + memset(p, 0, sizeof(UA_TransferResult)); +} + +static UA_INLINE UA_TransferResult * +UA_TransferResult_new(void) { + return (UA_TransferResult*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERRESULT]); +} + +static UA_INLINE UA_StatusCode +UA_TransferResult_copy(const UA_TransferResult *src, UA_TransferResult *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERRESULT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TransferResult_deleteMembers(UA_TransferResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]); +} + +static UA_INLINE void +UA_TransferResult_clear(UA_TransferResult *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]); +} + +static UA_INLINE void +UA_TransferResult_delete(UA_TransferResult *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERRESULT]); +} + +/* TransferSubscriptionsRequest */ +static UA_INLINE void +UA_TransferSubscriptionsRequest_init(UA_TransferSubscriptionsRequest *p) { + memset(p, 0, sizeof(UA_TransferSubscriptionsRequest)); +} + +static UA_INLINE UA_TransferSubscriptionsRequest * +UA_TransferSubscriptionsRequest_new(void) { + return (UA_TransferSubscriptionsRequest*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_TransferSubscriptionsRequest_copy(const UA_TransferSubscriptionsRequest *src, UA_TransferSubscriptionsRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TransferSubscriptionsRequest_deleteMembers(UA_TransferSubscriptionsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]); +} + +static UA_INLINE void +UA_TransferSubscriptionsRequest_clear(UA_TransferSubscriptionsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]); +} + +static UA_INLINE void +UA_TransferSubscriptionsRequest_delete(UA_TransferSubscriptionsRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSREQUEST]); +} + +/* TransferSubscriptionsResponse */ +static UA_INLINE void +UA_TransferSubscriptionsResponse_init(UA_TransferSubscriptionsResponse *p) { + memset(p, 0, sizeof(UA_TransferSubscriptionsResponse)); +} + +static UA_INLINE UA_TransferSubscriptionsResponse * +UA_TransferSubscriptionsResponse_new(void) { + return (UA_TransferSubscriptionsResponse*)UA_new(&UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_TransferSubscriptionsResponse_copy(const UA_TransferSubscriptionsResponse *src, UA_TransferSubscriptionsResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_TransferSubscriptionsResponse_deleteMembers(UA_TransferSubscriptionsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]); +} + +static UA_INLINE void +UA_TransferSubscriptionsResponse_clear(UA_TransferSubscriptionsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]); +} + +static UA_INLINE void +UA_TransferSubscriptionsResponse_delete(UA_TransferSubscriptionsResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_TRANSFERSUBSCRIPTIONSRESPONSE]); +} + +/* DeleteSubscriptionsRequest */ +static UA_INLINE void +UA_DeleteSubscriptionsRequest_init(UA_DeleteSubscriptionsRequest *p) { + memset(p, 0, sizeof(UA_DeleteSubscriptionsRequest)); +} + +static UA_INLINE UA_DeleteSubscriptionsRequest * +UA_DeleteSubscriptionsRequest_new(void) { + return (UA_DeleteSubscriptionsRequest*)UA_new(&UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteSubscriptionsRequest_copy(const UA_DeleteSubscriptionsRequest *src, UA_DeleteSubscriptionsRequest *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteSubscriptionsRequest_deleteMembers(UA_DeleteSubscriptionsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]); +} + +static UA_INLINE void +UA_DeleteSubscriptionsRequest_clear(UA_DeleteSubscriptionsRequest *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]); +} + +static UA_INLINE void +UA_DeleteSubscriptionsRequest_delete(UA_DeleteSubscriptionsRequest *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSREQUEST]); +} + +/* DeleteSubscriptionsResponse */ +static UA_INLINE void +UA_DeleteSubscriptionsResponse_init(UA_DeleteSubscriptionsResponse *p) { + memset(p, 0, sizeof(UA_DeleteSubscriptionsResponse)); +} + +static UA_INLINE UA_DeleteSubscriptionsResponse * +UA_DeleteSubscriptionsResponse_new(void) { + return (UA_DeleteSubscriptionsResponse*)UA_new(&UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]); +} + +static UA_INLINE UA_StatusCode +UA_DeleteSubscriptionsResponse_copy(const UA_DeleteSubscriptionsResponse *src, UA_DeleteSubscriptionsResponse *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DeleteSubscriptionsResponse_deleteMembers(UA_DeleteSubscriptionsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]); +} + +static UA_INLINE void +UA_DeleteSubscriptionsResponse_clear(UA_DeleteSubscriptionsResponse *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]); +} + +static UA_INLINE void +UA_DeleteSubscriptionsResponse_delete(UA_DeleteSubscriptionsResponse *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DELETESUBSCRIPTIONSRESPONSE]); +} + +/* BuildInfo */ +static UA_INLINE void +UA_BuildInfo_init(UA_BuildInfo *p) { + memset(p, 0, sizeof(UA_BuildInfo)); +} + +static UA_INLINE UA_BuildInfo * +UA_BuildInfo_new(void) { + return (UA_BuildInfo*)UA_new(&UA_TYPES[UA_TYPES_BUILDINFO]); +} + +static UA_INLINE UA_StatusCode +UA_BuildInfo_copy(const UA_BuildInfo *src, UA_BuildInfo *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_BUILDINFO]); +} + +UA_DEPRECATED static UA_INLINE void +UA_BuildInfo_deleteMembers(UA_BuildInfo *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BUILDINFO]); +} + +static UA_INLINE void +UA_BuildInfo_clear(UA_BuildInfo *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_BUILDINFO]); +} + +static UA_INLINE void +UA_BuildInfo_delete(UA_BuildInfo *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_BUILDINFO]); +} + +/* RedundancySupport */ +static UA_INLINE void +UA_RedundancySupport_init(UA_RedundancySupport *p) { + memset(p, 0, sizeof(UA_RedundancySupport)); +} + +static UA_INLINE UA_RedundancySupport * +UA_RedundancySupport_new(void) { + return (UA_RedundancySupport*)UA_new(&UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]); +} + +static UA_INLINE UA_StatusCode +UA_RedundancySupport_copy(const UA_RedundancySupport *src, UA_RedundancySupport *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]); +} + +UA_DEPRECATED static UA_INLINE void +UA_RedundancySupport_deleteMembers(UA_RedundancySupport *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]); +} + +static UA_INLINE void +UA_RedundancySupport_clear(UA_RedundancySupport *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]); +} + +static UA_INLINE void +UA_RedundancySupport_delete(UA_RedundancySupport *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_REDUNDANCYSUPPORT]); +} + +/* ServerState */ +static UA_INLINE void +UA_ServerState_init(UA_ServerState *p) { + memset(p, 0, sizeof(UA_ServerState)); +} + +static UA_INLINE UA_ServerState * +UA_ServerState_new(void) { + return (UA_ServerState*)UA_new(&UA_TYPES[UA_TYPES_SERVERSTATE]); +} + +static UA_INLINE UA_StatusCode +UA_ServerState_copy(const UA_ServerState *src, UA_ServerState *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERSTATE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ServerState_deleteMembers(UA_ServerState *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATE]); +} + +static UA_INLINE void +UA_ServerState_clear(UA_ServerState *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATE]); +} + +static UA_INLINE void +UA_ServerState_delete(UA_ServerState *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SERVERSTATE]); +} + +/* ServerDiagnosticsSummaryDataType */ +static UA_INLINE void +UA_ServerDiagnosticsSummaryDataType_init(UA_ServerDiagnosticsSummaryDataType *p) { + memset(p, 0, sizeof(UA_ServerDiagnosticsSummaryDataType)); +} + +static UA_INLINE UA_ServerDiagnosticsSummaryDataType * +UA_ServerDiagnosticsSummaryDataType_new(void) { + return (UA_ServerDiagnosticsSummaryDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]); +} + +static UA_INLINE UA_StatusCode +UA_ServerDiagnosticsSummaryDataType_copy(const UA_ServerDiagnosticsSummaryDataType *src, UA_ServerDiagnosticsSummaryDataType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ServerDiagnosticsSummaryDataType_deleteMembers(UA_ServerDiagnosticsSummaryDataType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]); +} + +static UA_INLINE void +UA_ServerDiagnosticsSummaryDataType_clear(UA_ServerDiagnosticsSummaryDataType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]); +} + +static UA_INLINE void +UA_ServerDiagnosticsSummaryDataType_delete(UA_ServerDiagnosticsSummaryDataType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SERVERDIAGNOSTICSSUMMARYDATATYPE]); +} + +/* ServerStatusDataType */ +static UA_INLINE void +UA_ServerStatusDataType_init(UA_ServerStatusDataType *p) { + memset(p, 0, sizeof(UA_ServerStatusDataType)); +} + +static UA_INLINE UA_ServerStatusDataType * +UA_ServerStatusDataType_new(void) { + return (UA_ServerStatusDataType*)UA_new(&UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]); +} + +static UA_INLINE UA_StatusCode +UA_ServerStatusDataType_copy(const UA_ServerStatusDataType *src, UA_ServerStatusDataType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ServerStatusDataType_deleteMembers(UA_ServerStatusDataType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]); +} + +static UA_INLINE void +UA_ServerStatusDataType_clear(UA_ServerStatusDataType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]); +} + +static UA_INLINE void +UA_ServerStatusDataType_delete(UA_ServerStatusDataType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_SERVERSTATUSDATATYPE]); +} + +/* Range */ +static UA_INLINE void +UA_Range_init(UA_Range *p) { + memset(p, 0, sizeof(UA_Range)); +} + +static UA_INLINE UA_Range * +UA_Range_new(void) { + return (UA_Range*)UA_new(&UA_TYPES[UA_TYPES_RANGE]); +} + +static UA_INLINE UA_StatusCode +UA_Range_copy(const UA_Range *src, UA_Range *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_RANGE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_Range_deleteMembers(UA_Range *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RANGE]); +} + +static UA_INLINE void +UA_Range_clear(UA_Range *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_RANGE]); +} + +static UA_INLINE void +UA_Range_delete(UA_Range *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_RANGE]); +} + +/* EUInformation */ +static UA_INLINE void +UA_EUInformation_init(UA_EUInformation *p) { + memset(p, 0, sizeof(UA_EUInformation)); +} + +static UA_INLINE UA_EUInformation * +UA_EUInformation_new(void) { + return (UA_EUInformation*)UA_new(&UA_TYPES[UA_TYPES_EUINFORMATION]); +} + +static UA_INLINE UA_StatusCode +UA_EUInformation_copy(const UA_EUInformation *src, UA_EUInformation *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EUINFORMATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EUInformation_deleteMembers(UA_EUInformation *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EUINFORMATION]); +} + +static UA_INLINE void +UA_EUInformation_clear(UA_EUInformation *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EUINFORMATION]); +} + +static UA_INLINE void +UA_EUInformation_delete(UA_EUInformation *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_EUINFORMATION]); +} + +/* AxisScaleEnumeration */ +static UA_INLINE void +UA_AxisScaleEnumeration_init(UA_AxisScaleEnumeration *p) { + memset(p, 0, sizeof(UA_AxisScaleEnumeration)); +} + +static UA_INLINE UA_AxisScaleEnumeration * +UA_AxisScaleEnumeration_new(void) { + return (UA_AxisScaleEnumeration*)UA_new(&UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]); +} + +static UA_INLINE UA_StatusCode +UA_AxisScaleEnumeration_copy(const UA_AxisScaleEnumeration *src, UA_AxisScaleEnumeration *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AxisScaleEnumeration_deleteMembers(UA_AxisScaleEnumeration *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]); +} + +static UA_INLINE void +UA_AxisScaleEnumeration_clear(UA_AxisScaleEnumeration *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]); +} + +static UA_INLINE void +UA_AxisScaleEnumeration_delete(UA_AxisScaleEnumeration *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_AXISSCALEENUMERATION]); +} + +/* ComplexNumberType */ +static UA_INLINE void +UA_ComplexNumberType_init(UA_ComplexNumberType *p) { + memset(p, 0, sizeof(UA_ComplexNumberType)); +} + +static UA_INLINE UA_ComplexNumberType * +UA_ComplexNumberType_new(void) { + return (UA_ComplexNumberType*)UA_new(&UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_ComplexNumberType_copy(const UA_ComplexNumberType *src, UA_ComplexNumberType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_ComplexNumberType_deleteMembers(UA_ComplexNumberType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]); +} + +static UA_INLINE void +UA_ComplexNumberType_clear(UA_ComplexNumberType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]); +} + +static UA_INLINE void +UA_ComplexNumberType_delete(UA_ComplexNumberType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_COMPLEXNUMBERTYPE]); +} + +/* DoubleComplexNumberType */ +static UA_INLINE void +UA_DoubleComplexNumberType_init(UA_DoubleComplexNumberType *p) { + memset(p, 0, sizeof(UA_DoubleComplexNumberType)); +} + +static UA_INLINE UA_DoubleComplexNumberType * +UA_DoubleComplexNumberType_new(void) { + return (UA_DoubleComplexNumberType*)UA_new(&UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_DoubleComplexNumberType_copy(const UA_DoubleComplexNumberType *src, UA_DoubleComplexNumberType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DoubleComplexNumberType_deleteMembers(UA_DoubleComplexNumberType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]); +} + +static UA_INLINE void +UA_DoubleComplexNumberType_clear(UA_DoubleComplexNumberType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]); +} + +static UA_INLINE void +UA_DoubleComplexNumberType_delete(UA_DoubleComplexNumberType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DOUBLECOMPLEXNUMBERTYPE]); +} + +/* AxisInformation */ +static UA_INLINE void +UA_AxisInformation_init(UA_AxisInformation *p) { + memset(p, 0, sizeof(UA_AxisInformation)); +} + +static UA_INLINE UA_AxisInformation * +UA_AxisInformation_new(void) { + return (UA_AxisInformation*)UA_new(&UA_TYPES[UA_TYPES_AXISINFORMATION]); +} + +static UA_INLINE UA_StatusCode +UA_AxisInformation_copy(const UA_AxisInformation *src, UA_AxisInformation *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_AXISINFORMATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_AxisInformation_deleteMembers(UA_AxisInformation *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]); +} + +static UA_INLINE void +UA_AxisInformation_clear(UA_AxisInformation *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]); +} + +static UA_INLINE void +UA_AxisInformation_delete(UA_AxisInformation *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_AXISINFORMATION]); +} + +/* XVType */ +static UA_INLINE void +UA_XVType_init(UA_XVType *p) { + memset(p, 0, sizeof(UA_XVType)); +} + +static UA_INLINE UA_XVType * +UA_XVType_new(void) { + return (UA_XVType*)UA_new(&UA_TYPES[UA_TYPES_XVTYPE]); +} + +static UA_INLINE UA_StatusCode +UA_XVType_copy(const UA_XVType *src, UA_XVType *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_XVTYPE]); +} + +UA_DEPRECATED static UA_INLINE void +UA_XVType_deleteMembers(UA_XVType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_XVTYPE]); +} + +static UA_INLINE void +UA_XVType_clear(UA_XVType *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_XVTYPE]); +} + +static UA_INLINE void +UA_XVType_delete(UA_XVType *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_XVTYPE]); +} + +/* EnumDefinition */ +static UA_INLINE void +UA_EnumDefinition_init(UA_EnumDefinition *p) { + memset(p, 0, sizeof(UA_EnumDefinition)); +} + +static UA_INLINE UA_EnumDefinition * +UA_EnumDefinition_new(void) { + return (UA_EnumDefinition*)UA_new(&UA_TYPES[UA_TYPES_ENUMDEFINITION]); +} + +static UA_INLINE UA_StatusCode +UA_EnumDefinition_copy(const UA_EnumDefinition *src, UA_EnumDefinition *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_ENUMDEFINITION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EnumDefinition_deleteMembers(UA_EnumDefinition *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]); +} + +static UA_INLINE void +UA_EnumDefinition_clear(UA_EnumDefinition *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]); +} + +static UA_INLINE void +UA_EnumDefinition_delete(UA_EnumDefinition *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_ENUMDEFINITION]); +} + +/* DataChangeNotification */ +static UA_INLINE void +UA_DataChangeNotification_init(UA_DataChangeNotification *p) { + memset(p, 0, sizeof(UA_DataChangeNotification)); +} + +static UA_INLINE UA_DataChangeNotification * +UA_DataChangeNotification_new(void) { + return (UA_DataChangeNotification*)UA_new(&UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]); +} + +static UA_INLINE UA_StatusCode +UA_DataChangeNotification_copy(const UA_DataChangeNotification *src, UA_DataChangeNotification *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]); +} + +UA_DEPRECATED static UA_INLINE void +UA_DataChangeNotification_deleteMembers(UA_DataChangeNotification *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]); +} + +static UA_INLINE void +UA_DataChangeNotification_clear(UA_DataChangeNotification *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]); +} + +static UA_INLINE void +UA_DataChangeNotification_delete(UA_DataChangeNotification *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_DATACHANGENOTIFICATION]); +} + +/* EventNotificationList */ +static UA_INLINE void +UA_EventNotificationList_init(UA_EventNotificationList *p) { + memset(p, 0, sizeof(UA_EventNotificationList)); +} + +static UA_INLINE UA_EventNotificationList * +UA_EventNotificationList_new(void) { + return (UA_EventNotificationList*)UA_new(&UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]); +} + +static UA_INLINE UA_StatusCode +UA_EventNotificationList_copy(const UA_EventNotificationList *src, UA_EventNotificationList *dst) { + return UA_copy(src, dst, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]); +} + +UA_DEPRECATED static UA_INLINE void +UA_EventNotificationList_deleteMembers(UA_EventNotificationList *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]); +} + +static UA_INLINE void +UA_EventNotificationList_clear(UA_EventNotificationList *p) { + UA_clear(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]); +} + +static UA_INLINE void +UA_EventNotificationList_delete(UA_EventNotificationList *p) { + UA_delete(p, &UA_TYPES[UA_TYPES_EVENTNOTIFICATIONLIST]); +} + +#if defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 6 +# pragma GCC diagnostic pop +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/util.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Stefan Profanter, fortiss GmbH + */ + + + +_UA_BEGIN_DECLS + +/** + * Forward Declarations + * -------------------- + * Opaque pointers used by the plugins. */ + +struct UA_Server; +typedef struct UA_Server UA_Server; + +struct UA_ServerConfig; +typedef struct UA_ServerConfig UA_ServerConfig; + +typedef void (*UA_ServerCallback)(UA_Server *server, void *data); + +struct UA_Client; +typedef struct UA_Client UA_Client; + +/* Timer policy to handle cycle misses */ +typedef enum { + UA_TIMER_HANDLE_CYCLEMISS_WITH_CURRENTTIME, + UA_TIMER_HANDLE_CYCLEMISS_WITH_BASETIME +} UA_TimerPolicy; + +/** + * Key Value Map + * ------------- + * Helper functions to work with configuration parameters in an array of + * UA_KeyValuePair. Lookup is linear. So this is for small numbers of + * keys. */ + +/* Makes a copy of the value. Can reallocate the underlying array. This + * invalidates pointers into the previous array. If the key exists already, the + * value is overwritten. */ +UA_EXPORT UA_StatusCode +UA_KeyValueMap_setQualified(UA_KeyValuePair **map, size_t *mapSize, + const UA_QualifiedName *key, + const UA_Variant *value); + +/* Simplified version that assumes the key is in namespace 0 */ +UA_EXPORT UA_StatusCode +UA_KeyValueMap_set(UA_KeyValuePair **map, size_t *mapSize, + const char *key, const UA_Variant *value); + +/* Returns a pointer into underlying array or NULL if the key is not found.*/ +UA_EXPORT const UA_Variant * +UA_KeyValueMap_getQualified(UA_KeyValuePair *map, size_t mapSize, + const UA_QualifiedName *key); + +/* Simplified version that assumes the key is in namespace 0 */ +UA_EXPORT const UA_Variant * +UA_KeyValueMap_get(UA_KeyValuePair *map, size_t mapSize, + const char *key); + +/* Returns NULL if the value for the key is not defined or not of the right + * datatype and scalar/array */ +UA_EXPORT const UA_Variant * +UA_KeyValueMap_getScalar(UA_KeyValuePair *map, size_t mapSize, + const char *key, const UA_DataType *type); + +UA_EXPORT const UA_Variant * +UA_KeyValueMap_getArray(UA_KeyValuePair *map, size_t mapSize, + const char *key, const UA_DataType *type); + +/* Remove a single entry. To delete the entire map, use UA_Array_delete. */ +UA_EXPORT void +UA_KeyValueMap_deleteQualified(UA_KeyValuePair **map, size_t *mapSize, + const UA_QualifiedName *key); + +/* Simplified version that assumes the key is in namespace 0 */ +UA_EXPORT void +UA_KeyValueMap_delete(UA_KeyValuePair **map, size_t *mapSize, + const char *key); + +/** + * Endpoint URL Parser + * ------------------- + * The endpoint URL parser is generally useful for the implementation of network + * layer plugins. */ + +/* Split the given endpoint url into hostname, port and path. All arguments must + * be non-NULL. EndpointUrls have the form "opc.tcp://hostname:port/path", port + * and path may be omitted (together with the prefix colon and slash). + * + * @param endpointUrl The endpoint URL. + * @param outHostname Set to the parsed hostname. The string points into the + * original endpointUrl, so no memory is allocated. If an IPv6 address is + * given, hostname contains e.g. '[2001:0db8:85a3::8a2e:0370:7334]' + * @param outPort Set to the port of the url or left unchanged. + * @param outPath Set to the path if one is present in the endpointUrl. + * Starting or trailing '/' are NOT included in the path. The string + * points into the original endpointUrl, so no memory is allocated. + * @return Returns UA_STATUSCODE_BADTCPENDPOINTURLINVALID if parsing failed. */ +UA_StatusCode UA_EXPORT +UA_parseEndpointUrl(const UA_String *endpointUrl, UA_String *outHostname, + UA_UInt16 *outPort, UA_String *outPath); + +/* Split the given endpoint url into hostname, vid and pcp. All arguments must + * be non-NULL. EndpointUrls have the form "opc.eth://[:[.PCP]]". + * The host is a MAC address, an IP address or a registered name like a + * hostname. The format of a MAC address is six groups of hexadecimal digits, + * separated by hyphens (e.g. 01-23-45-67-89-ab). A system may also accept + * hostnames and/or IP addresses if it provides means to resolve it to a MAC + * address (e.g. DNS and Reverse-ARP). + * + * Note: currently only parsing MAC address is supported. + * + * @param endpointUrl The endpoint URL. + * @param vid Set to VLAN ID. + * @param pcp Set to Priority Code Point. + * @return Returns UA_STATUSCODE_BADINTERNALERROR if parsing failed. */ +UA_StatusCode UA_EXPORT +UA_parseEndpointUrlEthernet(const UA_String *endpointUrl, UA_String *target, + UA_UInt16 *vid, UA_Byte *pcp); + +/* Convert given byte string to a positive number. Returns the number of valid + * digits. Stops if a non-digit char is found and returns the number of digits + * up to that point. */ +size_t UA_EXPORT +UA_readNumber(const UA_Byte *buf, size_t buflen, UA_UInt32 *number); + +/* Same as UA_ReadNumber but with a base parameter */ +size_t UA_EXPORT +UA_readNumberWithBase(const UA_Byte *buf, size_t buflen, + UA_UInt32 *number, UA_Byte base); + +#ifndef UA_MIN +#define UA_MIN(A, B) ((A) > (B) ? (B) : (A)) +#endif + +#ifndef UA_MAX +#define UA_MAX(A, B) ((A) > (B) ? (A) : (B)) +#endif + +/** + * Parse RelativePath Expressions + * ------------------------------ + * + * Parse a RelativePath according to the format defined in Part 4, A2. This is + * used e.g. for the BrowsePath structure. For now, only the standard + * ReferenceTypes from Namespace 0 are recognized (see Part 3). + * + * ``RelativePath := ( ReferenceType [BrowseName]? )*`` + * + * The ReferenceTypes have either of the following formats: + * + * - ``/``: *HierarchicalReferences* and subtypes + * - ``.``: *Aggregates* ReferenceTypesand subtypes + * - ``< [!#]* BrowseName >``: The ReferenceType is indicated by its BrowseName + * (a QualifiedName). Prefixed modifiers can be as follows: ``!`` switches to + * inverse References. ``#`` excludes subtypes of the ReferenceType. + * + * QualifiedNames consist of an optional NamespaceIndex and the nameitself: + * + * ``QualifiedName := ([0-9]+ ":")? Name`` + * + * The QualifiedName representation for RelativePaths uses ``&`` as the escape + * character. Occurences of the characters ``/.<>:#!&`` in a QualifiedName have + * to be escaped (prefixed with ``&``). + * + * Example RelativePaths + * ````````````````````` + * + * - ``/2:Block&.Output`` + * - ``/3:Truck.0:NodeVersion`` + * - ``<0:HasProperty>1:Boiler/1:HeatSensor`` + * - ``<0:HasChild>2:Wheel`` + * - ``<#Aggregates>1:Boiler/`` + * - ``Truck`` + * - ```` + */ +#ifdef UA_ENABLE_PARSING +UA_EXPORT UA_StatusCode +UA_RelativePath_parse(UA_RelativePath *rp, const UA_String str); +#endif + +/** + * Convenience macros for complex types + * ------------------------------------ */ +#define UA_PRINTF_GUID_FORMAT "%08" PRIx32 "-%04" PRIx16 "-%04" PRIx16 \ + "-%02" PRIx8 "%02" PRIx8 "-%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 "%02" PRIx8 +#define UA_PRINTF_GUID_DATA(GUID) (GUID).data1, (GUID).data2, (GUID).data3, \ + (GUID).data4[0], (GUID).data4[1], (GUID).data4[2], (GUID).data4[3], \ + (GUID).data4[4], (GUID).data4[5], (GUID).data4[6], (GUID).data4[7] + +#define UA_PRINTF_STRING_FORMAT "\"%.*s\"" +#define UA_PRINTF_STRING_DATA(STRING) (int)(STRING).length, (STRING).data + +/** + * Helper functions for converting data types + * ------------------------------------------ */ + +/* Converts a bytestring to the corresponding base64 representation */ +UA_DEPRECATED static UA_INLINE UA_StatusCode +UA_ByteString_toBase64String(const UA_ByteString *byteString, + UA_String *str) { + return UA_ByteString_toBase64(byteString, str); +} + +/* Converts a node id to the corresponding string representation. + * It can be one of: + * - Numeric: ns=0;i=123 + * - String: ns=0;s=Some String + * - Guid: ns=0;g=A123456C-0ABC-1A2B-815F-687212AAEE1B + * - ByteString: ns=0;b=AA== */ +UA_DEPRECATED static UA_INLINE UA_StatusCode +UA_NodeId_toString(const UA_NodeId *nodeId, UA_String *nodeIdStr) { + return UA_NodeId_print(nodeId, nodeIdStr); +} + +/* Compare memory in constant time to mitigate timing attacks. + * Returns true if ptr1 and ptr2 are equal for length bytes. */ +static UA_INLINE UA_Boolean +UA_constantTimeEqual(const void *ptr1, const void *ptr2, size_t length) { + volatile const UA_Byte *a = (volatile const UA_Byte *)ptr1; + volatile const UA_Byte *b = (volatile const UA_Byte *)ptr2; + volatile UA_Byte c = 0; + for(size_t i = 0; i < length; ++i) { + UA_Byte x = a[i], y = b[i]; + c |= x ^ y; + } + return !c; +} + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/plugin/log.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +#include + +_UA_BEGIN_DECLS + +/** + * Logging Plugin API + * ================== + * + * Servers and clients define a logger in their configuration. The logger is a + * plugin. A default plugin that logs to ``stdout`` is provided as an example. + * The logger plugin is stateful and can point to custom data. So it is possible + * to keep open file handlers in the logger context. + * + * Every log message consists of a log level, a log category and a string + * message content. The timestamp of the log message is created within the + * logger. */ + +typedef enum { + UA_LOGLEVEL_TRACE = 0, + UA_LOGLEVEL_DEBUG, + UA_LOGLEVEL_INFO, + UA_LOGLEVEL_WARNING, + UA_LOGLEVEL_ERROR, + UA_LOGLEVEL_FATAL +} UA_LogLevel; + +typedef enum { + UA_LOGCATEGORY_NETWORK = 0, + UA_LOGCATEGORY_SECURECHANNEL, + UA_LOGCATEGORY_SESSION, + UA_LOGCATEGORY_SERVER, + UA_LOGCATEGORY_CLIENT, + UA_LOGCATEGORY_USERLAND, + UA_LOGCATEGORY_SECURITYPOLICY +} UA_LogCategory; + +typedef struct { + /* Log a message. The message string and following varargs are formatted + * according to the rules of the printf command. Use the convenience macros + * below that take the minimum log level defined in ua_config.h into + * account. */ + void (*log)(void *logContext, UA_LogLevel level, UA_LogCategory category, + const char *msg, va_list args); + + void *context; /* Logger state */ + + void (*clear)(void *context); /* Clean up the logger plugin */ +} UA_Logger; + +static UA_INLINE UA_FORMAT(3,4) void +UA_LOG_TRACE(const UA_Logger *logger, UA_LogCategory category, const char *msg, ...) { +#if UA_LOGLEVEL <= 100 + if(!logger || !logger->log) + return; + va_list args; va_start(args, msg); + logger->log(logger->context, UA_LOGLEVEL_TRACE, category, msg, args); + va_end(args); +#else + (void) logger; + (void) category; + (void) msg; +#endif +} + +static UA_INLINE UA_FORMAT(3,4) void +UA_LOG_DEBUG(const UA_Logger *logger, UA_LogCategory category, const char *msg, ...) { +#if UA_LOGLEVEL <= 200 + if(!logger || !logger->log) + return; + va_list args; va_start(args, msg); + logger->log(logger->context, UA_LOGLEVEL_DEBUG, category, msg, args); + va_end(args); +#else + (void) logger; + (void) category; + (void) msg; +#endif +} + +static UA_INLINE UA_FORMAT(3,4) void +UA_LOG_INFO(const UA_Logger *logger, UA_LogCategory category, const char *msg, ...) { +#if UA_LOGLEVEL <= 300 + if(!logger || !logger->log) + return; + va_list args; va_start(args, msg); + logger->log(logger->context, UA_LOGLEVEL_INFO, category, msg, args); + va_end(args); +#else + (void) logger; + (void) category; + (void) msg; +#endif +} + +static UA_INLINE UA_FORMAT(3,4) void +UA_LOG_WARNING(const UA_Logger *logger, UA_LogCategory category, const char *msg, ...) { +#if UA_LOGLEVEL <= 400 + if(!logger || !logger->log) + return; + va_list args; va_start(args, msg); + logger->log(logger->context, UA_LOGLEVEL_WARNING, category, msg, args); + va_end(args); +#else + (void) logger; + (void) category; + (void) msg; +#endif +} + +static UA_INLINE UA_FORMAT(3,4) void +UA_LOG_ERROR(const UA_Logger *logger, UA_LogCategory category, const char *msg, ...) { +#if UA_LOGLEVEL <= 500 + if(!logger || !logger->log) + return; + va_list args; va_start(args, msg); + logger->log(logger->context, UA_LOGLEVEL_ERROR, category, msg, args); + va_end(args); +#else + (void) logger; + (void) category; + (void) msg; +#endif +} + +static UA_INLINE UA_FORMAT(3,4) void +UA_LOG_FATAL(const UA_Logger *logger, UA_LogCategory category, const char *msg, ...) { +#if UA_LOGLEVEL <= 600 + if(!logger || !logger->log) + return; + va_list args; va_start(args, msg); + logger->log(logger->context, UA_LOGLEVEL_FATAL, category, msg, args); + va_end(args); +#else + (void) logger; + (void) category; + (void) msg; +#endif +} + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/plugin/network.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +_UA_BEGIN_DECLS + +/* Forward declarations */ +struct UA_Connection; +typedef struct UA_Connection UA_Connection; + +struct UA_SecureChannel; +typedef struct UA_SecureChannel UA_SecureChannel; + +struct UA_ServerNetworkLayer; +typedef struct UA_ServerNetworkLayer UA_ServerNetworkLayer; + +/** + * .. _networking: + * + * Networking Plugin API + * ===================== + * + * Connection + * ---------- + * Client-server connections are represented by a `UA_Connection`. The + * connection is stateful and stores partially received messages, and so on. In + * addition, the connection contains function pointers to the underlying + * networking implementation. An example for this is the `send` function. So the + * connection encapsulates all the required networking functionality. This lets + * users on embedded (or otherwise exotic) systems implement their own + * networking plugins with a clear interface to the main open62541 library. */ + +typedef struct { + UA_UInt32 protocolVersion; + UA_UInt32 recvBufferSize; + UA_UInt32 sendBufferSize; + UA_UInt32 localMaxMessageSize; /* (0 = unbounded) */ + UA_UInt32 remoteMaxMessageSize; /* (0 = unbounded) */ + UA_UInt32 localMaxChunkCount; /* (0 = unbounded) */ + UA_UInt32 remoteMaxChunkCount; /* (0 = unbounded) */ +} UA_ConnectionConfig; + +typedef enum { + UA_CONNECTIONSTATE_CLOSED, /* The socket has been closed and the connection + * will be deleted */ + UA_CONNECTIONSTATE_OPENING, /* The socket is open, but the HEL/ACK handshake + * is not done */ + UA_CONNECTIONSTATE_ESTABLISHED /* The socket is open and the connection + * configured */ +} UA_ConnectionState; + +struct UA_Connection { + UA_ConnectionState state; + UA_SecureChannel *channel; /* The securechannel that is attached to + * this connection */ + UA_SOCKET sockfd; /* Most connectivity solutions run on + * sockets. Having the socket id here + * simplifies the design. */ + UA_DateTime openingDate; /* The date the connection was created */ + void *handle; /* A pointer to internal data */ + + /* Get a buffer for sending */ + UA_StatusCode (*getSendBuffer)(UA_Connection *connection, size_t length, + UA_ByteString *buf); + + /* Release the send buffer manually */ + void (*releaseSendBuffer)(UA_Connection *connection, UA_ByteString *buf); + + /* Sends a message over the connection. The message buffer is always freed, + * even if sending fails. + * + * @param connection The connection + * @param buf The message buffer + * @return Returns an error code or UA_STATUSCODE_GOOD. */ + UA_StatusCode (*ua_send)(UA_Connection *connection, UA_ByteString *buf); + + /* Receive a message from the remote connection + * + * @param connection The connection + + * @param response The response string. If this is empty, it will be + * allocated by the connection and needs to be freed with + * connection->releaseBuffer. If the response string is non-empty, it + * will be used as the receive buffer. If bytes are received, the + * length of the buffer is adjusted to match the length of the + * received bytes. + * @param timeout Timeout of the recv operation in milliseconds + * @return Returns UA_STATUSCODE_BADCOMMUNICATIONERROR if the recv operation + * can be repeated, UA_STATUSCODE_GOOD if it succeeded and + * UA_STATUSCODE_BADCONNECTIONCLOSED if the connection was + * closed. */ + UA_StatusCode (*ua_recv)(UA_Connection *connection, UA_ByteString *response, + UA_UInt32 timeout); + + /* Release the buffer of a received message */ + void (*releaseRecvBuffer)(UA_Connection *connection, UA_ByteString *buf); + + /* Close the connection. The network layer closes the socket. This is picked + * up during the next 'listen' and the connection is freed in the network + * layer. */ + void (*ua_close)(UA_Connection *connection); + + /* To be called only from within the server (and not the network layer). + * Frees up the connection's memory. */ + void (*free)(UA_Connection *connection); +}; + +/** + * Server Network Layer + * -------------------- + * The server exposes two functions to interact with remote clients: + * `processBinaryMessage` and `removeConnection`. These functions are called by + * the server network layer. + * + * It is the job of the server network layer to listen on a TCP socket, to + * accept new connections, to call the server with received messages and to + * signal closed connections to the server. + * + * The network layer is part of the server config. So users can provide a custom + * implementation if the provided example does not fit their architecture. The + * network layer is invoked only from the server's main loop. So the network + * layer does not need to be thread-safe. If the network layer receives a + * positive duration for blocking listening, the server's main loop will block + * until a message is received or the duration times out. */ + +/* Process a binary message (TCP packet). The message can contain partial + * chunks. (TCP is a streaming protocol and packets may be split/merge during + * transport.) After processing, the message is freed with + * connection->releaseRecvBuffer. */ +void UA_EXPORT +UA_Server_processBinaryMessage(UA_Server *server, UA_Connection *connection, + UA_ByteString *message); + +/* The server internally cleans up the connection and then calls + * connection->free. */ +void UA_EXPORT +UA_Server_removeConnection(UA_Server *server, UA_Connection *connection); + +struct UA_ServerNetworkLayer { + void *handle; /* Internal data */ + + /* Points to external memory, i.e. handled by server or client */ + UA_NetworkStatistics *statistics; + + UA_String discoveryUrl; + + UA_ConnectionConfig localConnectionConfig; + + /* Start listening on the network layer. + * + * @param nl The network layer + * @return Returns UA_STATUSCODE_GOOD or an error code. */ + UA_StatusCode (*start)(UA_ServerNetworkLayer *nl, const UA_Logger *logger, + const UA_String *customHostname); + + /* Listen for new and closed connections and arriving packets. Calls + * UA_Server_processBinaryMessage for the arriving packets. Closed + * connections are picked up here and forwarded to + * UA_Server_removeConnection where they are cleaned up and freed. + * + * @param nl The network layer + * @param server The server for processing the incoming packets and for + * closing connections. + * @param timeout The timeout during which an event must arrive in + * milliseconds + * @return A statuscode for the status of the network layer. */ + UA_StatusCode (*ua_listen)(UA_ServerNetworkLayer *nl, UA_Server *server, + UA_UInt16 timeout); + + /* Close the network socket and all open connections. Afterwards, the + * network layer can be safely deleted. + * + * @param nl The network layer + * @param server The server that processes the incoming packets and for + * closing connections before deleting them. + * @return A statuscode for the status of the closing operation. */ + void (*stop)(UA_ServerNetworkLayer *nl, UA_Server *server); + + /* Deletes the network layer context. Call only after stopping. */ + void (*clear)(UA_ServerNetworkLayer *nl); +}; + +/** + * Client Network Layer + * -------------------- + * The client has only a single connection used for sending and receiving binary + * messages. */ + +/* @param config the connection config for this client + * @param endpointUrl to where to connect + * @param timeout in ms until the connection try times out if remote not reachable + * @param logger the logger to use */ +typedef UA_Connection +(*UA_ConnectClientConnection)(UA_ConnectionConfig config, UA_String endpointUrl, + UA_UInt32 timeout, const UA_Logger *logger); + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/plugin/accesscontrol.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +_UA_BEGIN_DECLS + +struct UA_AccessControl; +typedef struct UA_AccessControl UA_AccessControl; + +/** + * .. _access-control: + * + * Access Control Plugin API + * ========================= + * The access control callback is used to authenticate sessions and grant access + * rights accordingly. + * + * The ``sessionId`` and ``sessionContext`` can be both NULL. This is the case + * when, for example, a MonitoredItem (the underlying Subscription) is detached + * from its Session but continues to run. */ + +struct UA_AccessControl { + void *context; + void (*clear)(UA_AccessControl *ac); + + /* Supported login mechanisms. The server endpoints are created from here. */ + size_t userTokenPoliciesSize; + UA_UserTokenPolicy *userTokenPolicies; + + /* Authenticate a session. The session context is attached to the session + * and later passed into the node-based access control callbacks. The new + * session is rejected if a StatusCode other than UA_STATUSCODE_GOOD is + * returned. */ + UA_StatusCode (*activateSession)(UA_Server *server, UA_AccessControl *ac, + const UA_EndpointDescription *endpointDescription, + const UA_ByteString *secureChannelRemoteCertificate, + const UA_NodeId *sessionId, + const UA_ExtensionObject *userIdentityToken, + void **sessionContext); + + /* Deauthenticate a session and cleanup */ + void (*closeSession)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext); + + /* Access control for all nodes*/ + UA_UInt32 (*getUserRightsMask)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext); + + /* Additional access control for variable nodes */ + UA_Byte (*getUserAccessLevel)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext); + + /* Additional access control for method nodes */ + UA_Boolean (*getUserExecutable)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *methodId, void *methodContext); + + /* Additional access control for calling a method node in the context of a + * specific object */ + UA_Boolean (*getUserExecutableOnObject)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *methodId, void *methodContext, + const UA_NodeId *objectId, void *objectContext); + + /* Allow adding a node */ + UA_Boolean (*allowAddNode)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_AddNodesItem *item); + + /* Allow adding a reference */ + UA_Boolean (*allowAddReference)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_AddReferencesItem *item); + + /* Allow deleting a node */ + UA_Boolean (*allowDeleteNode)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_DeleteNodesItem *item); + + /* Allow deleting a reference */ + UA_Boolean (*allowDeleteReference)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_DeleteReferencesItem *item); + + /* Allow browsing a node */ + UA_Boolean (*allowBrowseNode)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* Allow transfer of a subscription to another session. The Server shall + * validate that the Client of that Session is operating on behalf of the + * same user */ + UA_Boolean (*allowTransferSubscription)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *oldSessionId, void *oldSessionContext, + const UA_NodeId *newSessionId, void *newSessionContext); +#endif + +#ifdef UA_ENABLE_HISTORIZING + /* Allow insert,replace,update of historical data */ + UA_Boolean (*allowHistoryUpdateUpdateData)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, + UA_PerformUpdateType performInsertReplace, + const UA_DataValue *value); + + /* Allow delete of historical data */ + UA_Boolean (*allowHistoryUpdateDeleteRawModified)(UA_Server *server, UA_AccessControl *ac, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, + UA_DateTime startTimestamp, + UA_DateTime endTimestamp, + bool isDeleteModified); +#endif +}; + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/plugin/pki.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + */ + + + +_UA_BEGIN_DECLS + +/** + * Public Key Infrastructure Integration + * ===================================== + * This file contains interface definitions for integration in a Public Key + * Infrastructure (PKI). Currently only one plugin interface is defined. + * + * Certificate Verification + * ------------------------ + * This plugin verifies that the origin of the certificate is trusted. It does + * not assign any access rights/roles to the holder of the certificate. + * + * Usually, implementations of the certificate verification plugin provide an + * initialization method that takes a trust-list and a revocation-list as input. + * The lifecycle of the plugin is attached to a server or client config. The + * ``clear`` method is called automatically when the config is destroyed. */ + +struct UA_CertificateVerification; +typedef struct UA_CertificateVerification UA_CertificateVerification; + +struct UA_CertificateVerification { + void *context; + + /* Verify the certificate against the configured policies and trust chain. */ + UA_StatusCode (*verifyCertificate)(void *verificationContext, + const UA_ByteString *certificate); + + /* Verify that the certificate has the applicationURI in the subject name. */ + UA_StatusCode (*verifyApplicationURI)(void *verificationContext, + const UA_ByteString *certificate, + const UA_String *applicationURI); + + /* Delete the certificate verification context */ + void (*clear)(UA_CertificateVerification *cv); +}; + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/plugin/securitypolicy.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017-2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +_UA_BEGIN_DECLS + +extern UA_EXPORT const UA_ByteString UA_SECURITY_POLICY_NONE_URI; + +struct UA_SecurityPolicy; +typedef struct UA_SecurityPolicy UA_SecurityPolicy; + +/** + * SecurityPolicy Interface Definition + * ----------------------------------- */ + +typedef struct { + UA_String uri; + + /* Verifies the signature of the message using the provided keys in the context. + * + * @param channelContext the channelContext that contains the key to verify + * the supplied message with. + * @param message the message to which the signature is supposed to belong. + * @param signature the signature of the message, that should be verified. */ + UA_StatusCode (*verify)(void *channelContext, const UA_ByteString *message, + const UA_ByteString *signature) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Signs the given message using this policys signing algorithm and the + * provided keys in the context. + * + * @param channelContext the channelContext that contains the key to sign + * the supplied message with. + * @param message the message to sign. + * @param signature an output buffer to which the signature is written. The + * buffer needs to be allocated by the caller. The + * necessary size can be acquired with the signatureSize + * attribute of this module. */ + UA_StatusCode (*sign)(void *channelContext, const UA_ByteString *message, + UA_ByteString *signature) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Gets the signature size that depends on the local (private) key. + * + * @param channelContext the channelContext that contains the + * certificate/key. + * @return the size of the local signature. Returns 0 if no local + * certificate was set. */ + size_t (*getLocalSignatureSize)(const void *channelContext); + + /* Gets the signature size that depends on the remote (public) key. + * + * @param channelContext the context to retrieve data from. + * @return the size of the remote signature. Returns 0 if no + * remote certificate was set previousely. */ + size_t (*getRemoteSignatureSize)(const void *channelContext); + + /* Gets the local signing key length. + * + * @param channelContext the context to retrieve data from. + * @return the length of the signing key in bytes. Returns 0 if no length can be found. + */ + size_t (*getLocalKeyLength)(const void *channelContext); + + /* Gets the local signing key length. + * + * @param channelContext the context to retrieve data from. + * @return the length of the signing key in bytes. Returns 0 if no length can be found. + */ + size_t (*getRemoteKeyLength)(const void *channelContext); +} UA_SecurityPolicySignatureAlgorithm; + +typedef struct { + UA_String uri; + + /* Encrypt the given data in place. For asymmetric encryption, the block + * size for plaintext and cypher depend on the remote key (certificate). + * + * @param channelContext the channelContext which contains information about + * the keys to encrypt data. + * @param data the data that is encrypted. The encrypted data will overwrite + * the data that was supplied. */ + UA_StatusCode (*encrypt)(void *channelContext, + UA_ByteString *data) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Decrypts the given ciphertext in place. For asymmetric encryption, the + * block size for plaintext and cypher depend on the local private key. + * + * @param channelContext the channelContext which contains information about + * the keys needed to decrypt the message. + * @param data the data to decrypt. The decryption is done in place. */ + UA_StatusCode (*decrypt)(void *channelContext, + UA_ByteString *data) UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Returns the length of the key used to encrypt messages in bits. For + * asymmetric encryption the key length is for the local private key. + * + * @param channelContext the context to retrieve data from. + * @return the length of the local key. Returns 0 if no + * key length is known. */ + size_t (*getLocalKeyLength)(const void *channelContext); + + /* Returns the length of the key to encrypt messages in bits. Depends on the + * key (certificate) from the remote side. + * + * @param channelContext the context to retrieve data from. + * @return the length of the remote key. Returns 0 if no + * key length is known. */ + size_t (*getRemoteKeyLength)(const void *channelContext); + + /* Returns the size of encrypted blocks for sending. For asymmetric + * encryption this depends on the remote key (certificate). For symmetric + * encryption the local and remote encrypted block size are identical. + * + * @param channelContext the context to retrieve data from. + * @return the size of encrypted blocks in bytes. Returns 0 if no key length is known. + */ + size_t (*getRemoteBlockSize)(const void *channelContext); + + /* Returns the size of plaintext blocks for sending. For asymmetric + * encryption this depends on the remote key (certificate). For symmetric + * encryption the local and remote plaintext block size are identical. + * + * @param channelContext the context to retrieve data from. + * @return the size of plaintext blocks in bytes. Returns 0 if no key length is known. + */ + size_t (*getRemotePlainTextBlockSize)(const void *channelContext); +} UA_SecurityPolicyEncryptionAlgorithm; + +typedef struct { + /* The algorithm used to sign and verify certificates. */ + UA_SecurityPolicySignatureAlgorithm signatureAlgorithm; + + /* The algorithm used to encrypt and decrypt messages. */ + UA_SecurityPolicyEncryptionAlgorithm encryptionAlgorithm; + +} UA_SecurityPolicyCryptoModule; + +typedef struct { + /* Generates a thumbprint for the specified certificate. + * + * @param certificate the certificate to make a thumbprint of. + * @param thumbprint an output buffer for the resulting thumbprint. Always + * has the length specified in the thumbprintLength in the + * asymmetricModule. */ + UA_StatusCode (*makeCertificateThumbprint)(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificate, + UA_ByteString *thumbprint) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Compares the supplied certificate with the certificate in the endpoint context. + * + * @param securityPolicy the policy data that contains the certificate + * to compare to. + * @param certificateThumbprint the certificate thumbprint to compare to the + * one stored in the context. + * @return if the thumbprints match UA_STATUSCODE_GOOD is returned. If they + * don't match or an error occurred an error code is returned. */ + UA_StatusCode (*compareCertificateThumbprint)(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *certificateThumbprint) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + UA_SecurityPolicyCryptoModule cryptoModule; +} UA_SecurityPolicyAsymmetricModule; + +typedef struct { + /* Pseudo random function that is used to generate the symmetric keys. + * + * For information on what parameters this function receives in what situation, + * refer to the OPC UA specification 1.03 Part6 Table 33 + * + * @param policyContext The context of the policy instance + * @param secret + * @param seed + * @param out an output to write the data to. The length defines the maximum + * number of output bytes that are produced. */ + UA_StatusCode (*generateKey)(void *policyContext, const UA_ByteString *secret, + const UA_ByteString *seed, UA_ByteString *out) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Random generator for generating nonces. + * + * @param policyContext The context of the policy instance + * @param out pointer to a buffer to store the nonce in. Needs to be + * allocated by the caller. The buffer is filled with random + * data. */ + UA_StatusCode (*generateNonce)(void *policyContext, UA_ByteString *out) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* + * The length of the nonce used in the SecureChannel as specified in the standard. + */ + size_t secureChannelNonceLength; + + UA_SecurityPolicyCryptoModule cryptoModule; +} UA_SecurityPolicySymmetricModule; + +typedef struct { + /* This method creates a new context data object. + * + * The caller needs to call delete on the received object to free allocated + * memory. Memory is only allocated if the function succeeds so there is no + * need to manually free the memory pointed to by *channelContext or to + * call delete in case of failure. + * + * @param securityPolicy the policy context of the endpoint that is connected + * to. It will be stored in the channelContext for + * further access by the policy. + * @param remoteCertificate the remote certificate contains the remote + * asymmetric key. The certificate will be verified + * and then stored in the context so that its + * details may be accessed. + * @param channelContext the initialized channelContext that is passed to + * functions that work on a context. */ + UA_StatusCode (*newContext)(const UA_SecurityPolicy *securityPolicy, + const UA_ByteString *remoteCertificate, + void **channelContext) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Deletes the the security context. */ + void (*deleteContext)(void *channelContext); + + /* Sets the local encrypting key in the supplied context. + * + * @param channelContext the context to work on. + * @param key the local encrypting key to store in the context. */ + UA_StatusCode (*setLocalSymEncryptingKey)(void *channelContext, + const UA_ByteString *key) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Sets the local signing key in the supplied context. + * + * @param channelContext the context to work on. + * @param key the local signing key to store in the context. */ + UA_StatusCode (*setLocalSymSigningKey)(void *channelContext, + const UA_ByteString *key) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Sets the local initialization vector in the supplied context. + * + * @param channelContext the context to work on. + * @param iv the local initialization vector to store in the context. */ + UA_StatusCode (*setLocalSymIv)(void *channelContext, + const UA_ByteString *iv) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Sets the remote encrypting key in the supplied context. + * + * @param channelContext the context to work on. + * @param key the remote encrypting key to store in the context. */ + UA_StatusCode (*setRemoteSymEncryptingKey)(void *channelContext, + const UA_ByteString *key) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Sets the remote signing key in the supplied context. + * + * @param channelContext the context to work on. + * @param key the remote signing key to store in the context. */ + UA_StatusCode (*setRemoteSymSigningKey)(void *channelContext, + const UA_ByteString *key) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Sets the remote initialization vector in the supplied context. + * + * @param channelContext the context to work on. + * @param iv the remote initialization vector to store in the context. */ + UA_StatusCode (*setRemoteSymIv)(void *channelContext, + const UA_ByteString *iv) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* Compares the supplied certificate with the certificate in the channel + * context. + * + * @param channelContext the channel context data that contains the + * certificate to compare to. + * @param certificate the certificate to compare to the one stored in the context. + * @return if the certificates match UA_STATUSCODE_GOOD is returned. If they + * don't match or an errror occurred an error code is returned. */ + UA_StatusCode (*compareCertificate)(const void *channelContext, + const UA_ByteString *certificate) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; +} UA_SecurityPolicyChannelModule; + +struct UA_SecurityPolicy { + /* Additional data */ + void *policyContext; + + /* The policy uri that identifies the implemented algorithms */ + UA_ByteString policyUri; + + /* The local certificate is specific for each SecurityPolicy since it + * depends on the used key length. */ + UA_ByteString localCertificate; + + /* Function pointers grouped into modules */ + UA_SecurityPolicyAsymmetricModule asymmetricModule; + UA_SecurityPolicySymmetricModule symmetricModule; + UA_SecurityPolicySignatureAlgorithm certificateSigningAlgorithm; + UA_SecurityPolicyChannelModule channelModule; + + const UA_Logger *logger; + + /* Updates the ApplicationInstanceCertificate and the corresponding private + * key at runtime. */ + UA_StatusCode (*updateCertificateAndPrivateKey)(UA_SecurityPolicy *policy, + const UA_ByteString newCertificate, + const UA_ByteString newPrivateKey); + + /* Deletes the dynamic content of the policy */ + void (*clear)(UA_SecurityPolicy *policy); +}; + +/** + * PubSub SecurityPolicy + * --------------------- + * + * For PubSub encryption, the message nonce is part of the (unencrypted) + * SecurityHeader. The nonce is required for the de- and encryption and has to + * be set in the channel context before de/encrypting. */ + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION +struct UA_PubSubSecurityPolicy; +typedef struct UA_PubSubSecurityPolicy UA_PubSubSecurityPolicy; + +struct UA_PubSubSecurityPolicy { + UA_ByteString policyUri; /* The policy uri that identifies the implemented + * algorithms */ + UA_SecurityPolicySymmetricModule symmetricModule; + + /* Create the context for the WriterGroup. The keys and nonce can be NULL + * here. Then they have to be set before the first encryption or signing + * operation. */ + UA_StatusCode + (*newContext)(void *policyContext, + const UA_ByteString *signingKey, + const UA_ByteString *encryptingKey, + const UA_ByteString *keyNonce, + void **wgContext); + + /* Delete the WriterGroup SecurityPolicy context */ + void (*deleteContext)(void *wgContext); + + /* Set the keys and nonce for the WriterGroup. This is returned from the + * GetSecurityKeys method of a Security Key Service (SKS). Otherwise, set + * manually via out-of-band transmission of the keys. */ + UA_StatusCode + (*setSecurityKeys)(void *wgContext, + const UA_ByteString *signingKey, + const UA_ByteString *encryptingKey, + const UA_ByteString *keyNonce) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + /* The nonce is contained in the NetworkMessage SecurityHeader. Set before + * each en-/decryption step. */ + UA_StatusCode + (*setMessageNonce)(void *wgContext, + const UA_ByteString *nonce) + UA_FUNC_ATTR_WARN_UNUSED_RESULT; + + const UA_Logger *logger; + + /* Deletes the dynamic content of the policy */ + void (*clear)(UA_PubSubSecurityPolicy *policy); + void *policyContext; +}; + +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/plugin/pubsub.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2018 Fraunhofer IOSB (Author: Andreas Ebner) + */ + + + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_PUBSUB + +/** + * .. _pubsub_connection: + * + * PubSub Connection Plugin API + * ============================ + * + * The PubSub Connection API is the interface between concrete network + * implementations and the internal pubsub code. + * + * The PubSub specification enables the creation of new connections on runtime. + * Wording: 'Connection' -> OPC UA standard 'highlevel' perspective, 'Channel' + * -> open62541 implementation 'lowlevel' perspective. A channel can be assigned + * with different network implementations like UDP, MQTT, AMQP. The channel + * provides basis services like send, regist, unregist, receive, close. */ + +struct UA_PubSubConnectionConfig; +typedef struct UA_PubSubConnectionConfig UA_PubSubConnectionConfig; + +struct UA_PubSubChannel; +typedef struct UA_PubSubChannel UA_PubSubChannel; + +typedef enum { + UA_PUBSUB_CHANNEL_RDY, + UA_PUBSUB_CHANNEL_PUB, + UA_PUBSUB_CHANNEL_SUB, + UA_PUBSUB_CHANNEL_PUB_SUB, + UA_PUBSUB_CHANNEL_ERROR, + UA_PUBSUB_CHANNEL_CLOSED +} UA_PubSubChannelState; + +typedef UA_StatusCode +(*UA_PubSubReceiveCallback)(UA_PubSubChannel *channel, + void *callbackContext, + const UA_ByteString *buffer); + +/* Interface structure between network plugin and internal implementation */ +struct UA_PubSubChannel { + UA_UInt32 publisherId; /* unique identifier */ + UA_PubSubChannelState state; + UA_PubSubConnectionConfig *connectionConfig; /* link to parent connection config */ + UA_SOCKET sockfd; + void *handle; /* implementation specific data */ + /*@info for handle: each network implementation should provide an structure + * UA_PubSubChannelData[ImplementationName] This structure can be used by the + * network implementation to store network implementation specific data.*/ + + /* Sending out the content of the buf parameter */ + UA_StatusCode (*send)(UA_PubSubChannel *channel, UA_ExtensionObject *transportSettings, + const UA_ByteString *buf); + + /* Register to an specified message source, e.g. multicast group or topic. Callback is used for mqtt. */ + UA_StatusCode (*regist)(UA_PubSubChannel *channel, UA_ExtensionObject *transportSettings, + void (*callback)(UA_ByteString *encodedBuffer, UA_ByteString *topic)); + + /* Remove subscription to an specified message source, e.g. multicast group or topic */ + UA_StatusCode (*unregist)(UA_PubSubChannel *channel, UA_ExtensionObject *transportSettings); + + /* Receive messages. A regist to the message source is needed before. */ + UA_StatusCode (*receive)(UA_PubSubChannel *channel, + UA_ExtensionObject *transportSettings, + UA_PubSubReceiveCallback receiveCallback, + void *receiveCallbackContext, + UA_UInt32 timeout); + + /* Closing the connection and implicit free of the channel structures. */ + UA_StatusCode (*close)(UA_PubSubChannel *channel); + + /* Giving the connection protocoll time to process inbound and outbound traffic. */ + UA_StatusCode (*yield)(UA_PubSubChannel *channel, UA_UInt16 timeout); +}; + +/** + * The UA_PubSubTransportLayer is used for the creation of new connections. + * Whenever in runtime a new connection is requested, the internal PubSub + * implementation calls the 'createPubSubChannel' function. The + * 'transportProfileUri' contains the standard defined transport profile + * information and is used to identify the type of connections which can be + * created by the TransportLayer. The server config contains a list of + * UA_PubSubTransportLayer. Take a look in the tutorial_pubsub_connection to get + * information about the TransportLayer handling. */ + +typedef struct { + UA_String transportProfileUri; + UA_PubSubChannel *(*createPubSubChannel)(UA_PubSubConnectionConfig *connectionConfig); +} UA_PubSubTransportLayer; + +#endif /* UA_ENABLE_PUBSUB */ + +_UA_END_DECLS + + +/**** amalgamated original file "/deps/ziptree.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Julius Pfrommer + */ + + +#ifdef __cplusplus +extern "C" { +#endif + +/* Reusable zip tree implementation. The style is inspired by the BSD + * sys/queue.h linked list definition. + * + * Zip trees were developed in: Tarjan, R. E., Levy, C. C., and Timmel, S. "Zip + * Trees." arXiv preprint arXiv:1806.06726 (2018). The original definition was + * modified so that several elements with the same key can be inserted. However, + * ZIP_FIND will only return the topmost of these elements in the tree. + * + * The ZIP_ENTRY definitions are to be contained in the tree entries themselves. + * Use ZIP_PROTOTYPE to define the signature of the zip tree and ZIP_IMPL (in a + * .c compilation unit) for the method implementations. + * + * Zip trees are a probabilistic data structure. Entries are assigned a + * (nonzero) rank k with probability 1/2^{k+1}. This header file does not assume + * a specific random number generator. So the rank must be given when an entry + * is inserted. A fast way (with a single call to a pseudo random generator) to + * compute the rank is with ZIP_FFS32(random()). The ZIP_FFS32 returns the least + * significant nonzero bit of a 32bit number. */ + +#define ZIP_HEAD(name, type) \ +struct name { \ + struct type *zip_root; \ +} + +#define ZIP_INIT(head) do { (head)->zip_root = NULL; } while (0) +#define ZIP_ROOT(head) (head)->zip_root +#define ZIP_EMPTY(head) (ZIP_ROOT(head) == NULL) + +#define ZIP_ENTRY(type) \ +struct { \ + struct type *zip_left; \ + struct type *zip_right; \ + unsigned char rank; \ +} + +#define ZIP_LEFT(elm, field) (elm)->field.zip_left +#define ZIP_RIGHT(elm, field) (elm)->field.zip_right +#define ZIP_RANK(elm, field) (elm)->field.rank + +/* Shortcuts */ +#define ZIP_INSERT(name, head, elm, rank) name##_ZIP_INSERT(head, elm, rank) +#define ZIP_REMOVE(name, head, elm) name##_ZIP_REMOVE(head, elm) +#define ZIP_FIND(name, head, key) name##_ZIP_FIND(head, key) +#define ZIP_MIN(name, head) name##_ZIP_MIN(head) +#define ZIP_MAX(name, head) name##_ZIP_MAX(head) +#define ZIP_ITER(name, head, cb, d) name##_ZIP_ITER(head, cb, d) + +/* Zip tree method prototypes */ +#define ZIP_PROTOTYPE(name, type, keytype) \ +void name##_ZIP_INSERT(struct name *head, struct type *elm, unsigned char rank); \ +void name##_ZIP_REMOVE(struct name *head, struct type *elm); \ +struct type *name##_ZIP_FIND(struct name *head, const keytype *key); \ +struct type *name##_ZIP_MIN(struct name *head); \ +struct type *name##_ZIP_MAX(struct name *head); \ +typedef void (*name##_cb)(struct type *elm, void *data); \ +void name##_ZIP_ITER(struct name *head, name##_cb cb, void *data); \ + +/* The comparison method "cmp" defined for every zip tree has the signature + * + * enum ZIP_CMP cmpDateTime(const keytype *a, const keytype *b); + * + * The entries need an absolute ordering. So ZIP_CMP_EQ must only be returned if + * a and b point to the same memory. (E.g. assured by unique identifiers.) */ +enum ZIP_CMP { + ZIP_CMP_LESS = -1, + ZIP_CMP_EQ = 0, + ZIP_CMP_MORE = 1 +}; + +/* Find the position of the first bit in an unsigned 32bit integer */ +#ifdef _MSC_VER +static __inline +#else +static inline +#endif +unsigned char +ZIP_FFS32(unsigned int v) { + unsigned int t = 1; + unsigned char r = 1; + if(v == 0) return 0; + while((v & t) == 0) { + t = t << 1; r++; + } + return r; +} + +/* Zip tree method implementations */ +#define ZIP_IMPL(name, type, field, keytype, keyfield, cmp) \ +static struct type * \ +__##name##_ZIP_INSERT(struct type *root, struct type *elm) { \ + if(!root) { \ + ZIP_LEFT(elm, field) = NULL; \ + ZIP_RIGHT(elm, field) = NULL; \ + return elm; \ + } \ + if((cmp)(&(elm)->keyfield, &(root)->keyfield) == ZIP_CMP_LESS) { \ + if(__##name##_ZIP_INSERT(ZIP_LEFT(root, field), elm) == elm) { \ + if(ZIP_RANK(elm, field) < ZIP_RANK(root, field)) { \ + ZIP_LEFT(root, field) = elm; \ + } else { \ + ZIP_LEFT(root, field) = ZIP_RIGHT(elm, field); \ + ZIP_RIGHT(elm, field) = root; \ + return elm; \ + } \ + } \ + } else { \ + if(__##name##_ZIP_INSERT(ZIP_RIGHT(root, field), elm) == elm) { \ + if(ZIP_RANK(elm, field) <= ZIP_RANK(root, field)) { \ + ZIP_RIGHT(root, field) = elm; \ + } else { \ + ZIP_RIGHT(root, field) = ZIP_LEFT(elm, field); \ + ZIP_LEFT(elm, field) = root; \ + return elm; \ + } \ + } \ + } \ + return root; \ +} \ + \ +void \ +name##_ZIP_INSERT(struct name *head, struct type *elm, \ + unsigned char rank) { \ + ZIP_RANK(elm, field) = rank; \ + ZIP_ROOT(head) = __##name##_ZIP_INSERT(ZIP_ROOT(head), elm); \ +} \ + \ +static struct type * \ +__##name##ZIP(struct type *x, struct type *y) { \ + if(!x) return y; \ + if(!y) return x; \ + if(ZIP_RANK(x, field) < ZIP_RANK(y, field)) { \ + ZIP_LEFT(y, field) = __##name##ZIP(x, ZIP_LEFT(y, field)); \ + return y; \ + } \ + ZIP_RIGHT(x, field) = __##name##ZIP(ZIP_RIGHT(x, field), y); \ + return x; \ +} \ + \ +/* Modified from the original algorithm. Allow multiple */ \ +/* elements with the same key. */ \ +static struct type * \ +__##name##_ZIP_REMOVE(struct type *root, struct type *elm) { \ + if(root == elm) \ + return __##name##ZIP(ZIP_LEFT(root, field), \ + ZIP_RIGHT(root, field)); \ + enum ZIP_CMP eq = (cmp)(&(elm)->keyfield, &(root)->keyfield); \ + struct type *left = ZIP_LEFT(root, field); \ + struct type *right = ZIP_RIGHT(root, field); \ + if(eq == ZIP_CMP_LESS) { \ + if(elm == left) \ + ZIP_LEFT(root, field) = \ + __##name##ZIP(ZIP_LEFT(left, field), \ + ZIP_RIGHT(left, field)); \ + else if(left) \ + __##name##_ZIP_REMOVE(left, elm); \ + } else if(eq == ZIP_CMP_MORE) { \ + if(elm == right) \ + ZIP_RIGHT(root, field) = \ + __##name##ZIP(ZIP_LEFT(right, field), \ + ZIP_RIGHT(right, field)); \ + else if(right) \ + __##name##_ZIP_REMOVE(right, elm); \ + } else { /* ZIP_CMP_EQ, but root != elm */ \ + if(right) \ + ZIP_RIGHT(root, field) = __##name##_ZIP_REMOVE(right, elm); \ + if(left) \ + ZIP_LEFT(root, field) = __##name##_ZIP_REMOVE(left, elm); \ + } \ + return root; \ +} \ + \ +void \ +name##_ZIP_REMOVE(struct name *head, struct type *elm) { \ + ZIP_ROOT(head) = __##name##_ZIP_REMOVE(ZIP_ROOT(head), elm); \ +} \ + \ +static struct type * \ +__##name##_ZIP_FIND(struct type *root, const keytype *key) { \ + if(!root) \ + return NULL; \ + enum ZIP_CMP eq = (cmp)(key, &(root)->keyfield); \ + if(eq == ZIP_CMP_EQ) { \ + return root; \ + } \ + if(eq == ZIP_CMP_LESS) { \ + return __##name##_ZIP_FIND(ZIP_LEFT(root, field), key); \ + } \ + return __##name##_ZIP_FIND(ZIP_RIGHT(root, field), key); \ +} \ + \ +struct type * \ +name##_ZIP_FIND(struct name *head, const keytype *key) { \ + return __##name##_ZIP_FIND(ZIP_ROOT(head), key); \ +} \ + \ +struct type * \ +name##_ZIP_MIN(struct name *head) { \ + struct type *cur = ZIP_ROOT(head); \ + if(!cur) return NULL; \ + while(ZIP_LEFT(cur, field)) { \ + cur = ZIP_LEFT(cur, field); \ + } \ + return cur; \ +} \ + \ +struct type * \ +name##_ZIP_MAX(struct name *head) { \ + struct type *cur = ZIP_ROOT(head); \ + if(!cur) return NULL; \ + while(ZIP_RIGHT(cur, field)) { \ + cur = ZIP_RIGHT(cur, field); \ + } \ + return cur; \ +} \ + \ +static void \ +__##name##_ZIP_ITER(struct type *elm, name##_cb cb, void *data) { \ + if(!elm) \ + return; \ + __##name##_ZIP_ITER(ZIP_LEFT(elm, field), cb, data); \ + __##name##_ZIP_ITER(ZIP_RIGHT(elm, field), cb, data); \ + cb(elm, data); \ +} \ + \ +void \ +name##_ZIP_ITER(struct name *head, name##_cb cb, void *data) { \ + __##name##_ZIP_ITER(ZIP_ROOT(head), cb, data); \ +} + +#ifdef __cplusplus +} /* extern "C" */ +#endif + + +/**** amalgamated original file "/deps/aa_tree.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + +#ifdef __cplusplus +extern "C" { +#endif + +enum aa_cmp { + AA_CMP_LESS = -1, + AA_CMP_EQ = 0, + AA_CMP_MORE = 1 +}; + +struct aa_entry { + struct aa_entry *left; + struct aa_entry *right; + unsigned int level; +}; + +struct aa_head { + struct aa_entry *root; + enum aa_cmp (*cmp)(const void* a, const void* b); + /* Offset from the container element to the aa_entry and the key */ + unsigned int entry_offset; + unsigned int key_offset; +}; + +/* The AA-Tree allows duplicate entries. The first matching key is returned in + * aa_find. */ + +void aa_init(struct aa_head *head, + enum aa_cmp (*cmp)(const void*, const void*), + unsigned int entry_offset, unsigned int key_offset); +void aa_insert(struct aa_head *head, void *elem); +void aa_remove(struct aa_head *head, void *elem); +void * aa_find(const struct aa_head *head, const void *key); +void * aa_min(const struct aa_head *head); +void * aa_max(const struct aa_head *head); +void * aa_next(const struct aa_head *head, const void *elem); +void * aa_prev(const struct aa_head *head, const void *elem); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + + +/**** amalgamated original file "/include/open62541/plugin/nodestore.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2017, 2021 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Julian Grothoff + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + +/* !!! Warning !!! + * + * If you are not developing a nodestore plugin, then you should not work with + * the definitions from this file directly. The underlying node structures are + * not meant to be used directly by end users. Please use the public server API + * / OPC UA services to interact with the information model. */ + + +_UA_BEGIN_DECLS + +/* Forward declaration */ +#ifdef UA_ENABLE_SUBSCRIPTIONS +struct UA_MonitoredItem; +typedef struct UA_MonitoredItem UA_MonitoredItem; +#endif + +/** + * .. _information-modelling: + * + * Information Modelling + * ===================== + * + * Information modelling in OPC UA combines concepts from object-orientation and + * semantic modelling. At the core, an OPC UA information model is a graph made + * up of + * + * - Nodes: There are eight possible Node types (variable, object, method, ...) + * - References: Typed and directed relations between two nodes + * + * Every node is identified by a unique (within the server) :ref:`nodeid`. + * Reference are triples of the form ``(source-nodeid, referencetype-nodeid, + * target-nodeid)``. An example reference between nodes is a + * ``hasTypeDefinition`` reference between a Variable and its VariableType. Some + * ReferenceTypes are *hierarchic* and must not form *directed loops*. See the + * section on :ref:`ReferenceTypes ` for more details on + * possible references and their semantics. + * + * **Warning!!** The structures defined in this section are only relevant for + * the developers of custom Nodestores. The interaction with the information + * model is possible only via the OPC UA :ref:`services`. So the following + * sections are purely informational so that users may have a clear mental + * model of the underlying representation. + * + * .. _node-lifecycle: + * + * Node Lifecycle: Constructors, Destructors and Node Contexts + * ----------------------------------------------------------- + * + * To finalize the instantiation of a node, a (user-defined) constructor + * callback is executed. There can be both a global constructor for all nodes + * and node-type constructor specific to the TypeDefinition of the new node + * (attached to an ObjectTypeNode or VariableTypeNode). + * + * In the hierarchy of ObjectTypes and VariableTypes, only the constructor of + * the (lowest) type defined for the new node is executed. Note that every + * Object and Variable can have only one ``isTypeOf`` reference. But type-nodes + * can technically have several ``hasSubType`` references to implement multiple + * inheritance. Issues of (multiple) inheritance in the constructor need to be + * solved by the user. + * + * When a node is destroyed, the node-type destructor is called before the + * global destructor. So the overall node lifecycle is as follows: + * + * 1. Global Constructor (set in the server config) + * 2. Node-Type Constructor (for VariableType or ObjectTypes) + * 3. (Usage-period of the Node) + * 4. Node-Type Destructor + * 5. Global Destructor + * + * The constructor and destructor callbacks can be set to ``NULL`` and are not + * used in that case. If the node-type constructor fails, the global destructor + * will be called before removing the node. The destructors are assumed to never + * fail. + * + * Every node carries a user-context and a constructor-context pointer. The + * user-context is used to attach custom data to a node. But the (user-defined) + * constructors and destructors may replace the user-context pointer if they + * wish to do so. The initial value for the constructor-context is ``NULL``. + * When the ``AddNodes`` service is used over the network, the user-context + * pointer of the new node is also initially set to ``NULL``. + * + * Global Node Lifecycle + * ~~~~~~~~~~~~~~~~~~~~~~ + * Global constructor and destructor callbacks used for every node type. + * To be set in the server config. + */ + +typedef struct { + /* Can be NULL. May replace the nodeContext */ + UA_StatusCode (*constructor)(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void **nodeContext); + + /* Can be NULL. The context cannot be replaced since the node is destroyed + * immediately afterwards anyway. */ + void (*destructor)(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext); + + /* Can be NULL. Called during recursive node instantiation. While mandatory + * child nodes are automatically created if not already present, optional child + * nodes are not. This callback can be used to define whether an optional child + * node should be created. + * + * @param server The server executing the callback + * @param sessionId The identifier of the session + * @param sessionContext Additional data attached to the session in the + * access control layer + * @param sourceNodeId Source node from the type definition. If the new node + * shall be created, it will be a copy of this node. + * @param targetParentNodeId Parent of the potential new child node + * @param referenceTypeId Identifies the reference type which that the parent + * node has to the new node. + * @return Return UA_TRUE if the child node shall be instantiated, + * UA_FALSE otherwise. */ + UA_Boolean (*createOptionalChild)(UA_Server *server, + const UA_NodeId *sessionId, + void *sessionContext, + const UA_NodeId *sourceNodeId, + const UA_NodeId *targetParentNodeId, + const UA_NodeId *referenceTypeId); + + /* Can be NULL. Called when a node is to be copied during recursive + * node instantiation. Allows definition of the NodeId for the new node. + * If the callback is set to NULL or the resulting NodeId is UA_NODEID_NUMERIC(X,0) + * an unused nodeid in namespace X will be used. E.g. passing UA_NODEID_NULL will + * result in a NodeId in namespace 0. + * + * @param server The server executing the callback + * @param sessionId The identifier of the session + * @param sessionContext Additional data attached to the session in the + * access control layer + * @param sourceNodeId Source node of the copy operation + * @param targetParentNodeId Parent node of the new node + * @param referenceTypeId Identifies the reference type which that the parent + * node has to the new node. */ + UA_StatusCode (*generateChildNodeId)(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *sourceNodeId, + const UA_NodeId *targetParentNodeId, + const UA_NodeId *referenceTypeId, + UA_NodeId *targetNodeId); +} UA_GlobalNodeLifecycle; + +/** + * Node Type Lifecycle + * ~~~~~~~~~~~~~~~~~~~ + * Constructor and destructors for specific object and variable types. */ +typedef struct { + /* Can be NULL. May replace the nodeContext */ + UA_StatusCode (*constructor)(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeNodeId, void *typeNodeContext, + const UA_NodeId *nodeId, void **nodeContext); + + /* Can be NULL. May replace the nodeContext. */ + void (*destructor)(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *typeNodeId, void *typeNodeContext, + const UA_NodeId *nodeId, void **nodeContext); +} UA_NodeTypeLifecycle; + +/** + * ReferenceType Bitfield Representation + * ------------------------------------- + * ReferenceTypes have an alternative represention as an index into a bitfield + * for fast comparison. The index is generated when the corresponding + * ReferenceTypeNode is added. By bounding the number of ReferenceTypes that can + * exist in the server, the bitfield can represent a set of an combination of + * ReferenceTypes. + * + * Every ReferenceTypeNode contains a bitfield with the set of all its subtypes. + * This speeds up the Browse services substantially. + * + * The following ReferenceTypes have a fixed index. The NS0 bootstrapping + * creates these ReferenceTypes in-order. */ +#define UA_REFERENCETYPEINDEX_REFERENCES 0 +#define UA_REFERENCETYPEINDEX_HASSUBTYPE 1 +#define UA_REFERENCETYPEINDEX_AGGREGATES 2 +#define UA_REFERENCETYPEINDEX_HIERARCHICALREFERENCES 3 +#define UA_REFERENCETYPEINDEX_NONHIERARCHICALREFERENCES 4 +#define UA_REFERENCETYPEINDEX_HASCHILD 5 +#define UA_REFERENCETYPEINDEX_ORGANIZES 6 +#define UA_REFERENCETYPEINDEX_HASEVENTSOURCE 7 +#define UA_REFERENCETYPEINDEX_HASMODELLINGRULE 8 +#define UA_REFERENCETYPEINDEX_HASENCODING 9 +#define UA_REFERENCETYPEINDEX_HASDESCRIPTION 10 +#define UA_REFERENCETYPEINDEX_HASTYPEDEFINITION 11 +#define UA_REFERENCETYPEINDEX_GENERATESEVENT 12 +#define UA_REFERENCETYPEINDEX_HASPROPERTY 13 +#define UA_REFERENCETYPEINDEX_HASCOMPONENT 14 +#define UA_REFERENCETYPEINDEX_HASNOTIFIER 15 +#define UA_REFERENCETYPEINDEX_HASORDEREDCOMPONENT 16 +#define UA_REFERENCETYPEINDEX_HASINTERFACE 17 + +/* The maximum number of ReferrenceTypes. Must be a multiple of 32. */ +#define UA_REFERENCETYPESET_MAX 128 +typedef struct { UA_UInt32 bits[UA_REFERENCETYPESET_MAX / 32]; } UA_ReferenceTypeSet; + +static UA_INLINE void +UA_ReferenceTypeSet_init(UA_ReferenceTypeSet *set) { + memset(set, 0, sizeof(UA_ReferenceTypeSet)); +} + +static UA_INLINE void +UA_ReferenceTypeSet_any(UA_ReferenceTypeSet *set) { + memset(set, -1, sizeof(UA_ReferenceTypeSet)); +} + +static UA_INLINE UA_ReferenceTypeSet +UA_REFTYPESET(UA_Byte index) { + UA_Byte i = index / 32, j = index % 32; + UA_ReferenceTypeSet set; + UA_ReferenceTypeSet_init(&set); + set.bits[i] |= ((UA_UInt32)1) << j; + return set; +} + +static UA_INLINE UA_ReferenceTypeSet +UA_ReferenceTypeSet_union(const UA_ReferenceTypeSet setA, + const UA_ReferenceTypeSet setB) { + UA_ReferenceTypeSet set; + for(size_t i = 0; i < UA_REFERENCETYPESET_MAX / 32; i++) + set.bits[i] = setA.bits[i] | setB.bits[i]; + return set; +} + +static UA_INLINE UA_Boolean +UA_ReferenceTypeSet_contains(const UA_ReferenceTypeSet *set, UA_Byte index) { + UA_Byte i = index / 32, j = index % 32; + return !!(set->bits[i] & (((UA_UInt32)1) << j)); +} + +/** + * Node Pointer + * ============ + * + * The "native" format for reference between nodes is the ExpandedNodeId. That + * is, references can also point to external servers. In practice, most + * references point to local nodes using numerical NodeIds from the + * standard-defined namespace zero. In order to save space (and time), + * pointer-tagging is used for compressed "NodePointer" representations. + * Numerical NodeIds are immediately contained in the pointer. Full NodeIds and + * ExpandedNodeIds are behind a pointer indirection. If the Nodestore supports + * it, a NodePointer can also be an actual pointer to the target node. + * + * Depending on the processor architecture, some numerical NodeIds don't fit + * into an immediate encoding and are kept as pointers. ExpandedNodeIds may be + * internally translated to "normal" NodeIds. Use the provided functions to + * generate NodePointers that fit the assumptions for the local architecture. */ + +/* Forward declaration. All node structures begin with the NodeHead. */ +struct UA_NodeHead; +typedef struct UA_NodeHead UA_NodeHead; + +/* Tagged Pointer structure. */ +typedef union { + uintptr_t immediate; /* 00: Small numerical NodeId */ + const UA_NodeId *id; /* 01: Pointer to NodeId */ + const UA_ExpandedNodeId *expandedId; /* 10: Pointer to ExternalNodeId */ + const UA_NodeHead *node; /* 11: Pointer to a node */ +} UA_NodePointer; + +/* Sets the pointer to an immediate NodeId "ns=0;i=0" similar to a freshly + * initialized UA_NodeId */ +static UA_INLINE void +UA_NodePointer_init(UA_NodePointer *np) { np->immediate = 0; } + +/* NodeId and ExpandedNodeId targets are freed */ +void UA_EXPORT +UA_NodePointer_clear(UA_NodePointer *np); + +/* Makes a deep copy */ +UA_StatusCode UA_EXPORT +UA_NodePointer_copy(UA_NodePointer in, UA_NodePointer *out); + +/* Test if an ExpandedNodeId or a local NodeId */ +UA_Boolean UA_EXPORT +UA_NodePointer_isLocal(UA_NodePointer np); + +UA_Order UA_EXPORT +UA_NodePointer_order(UA_NodePointer p1, UA_NodePointer p2); + +static UA_INLINE UA_Boolean +UA_NodePointer_equal(UA_NodePointer p1, UA_NodePointer p2) { + return (UA_NodePointer_order(p1, p2) == UA_ORDER_EQ); +} + +/* Cannot fail. The resulting NodePointer can point to the memory from the + * NodeId. Make a deep copy if required. */ +UA_NodePointer UA_EXPORT +UA_NodePointer_fromNodeId(const UA_NodeId *id); + +/* Cannot fail. The resulting NodePointer can point to the memory from the + * ExpandedNodeId. Make a deep copy if required. */ +UA_NodePointer UA_EXPORT +UA_NodePointer_fromExpandedNodeId(const UA_ExpandedNodeId *id); + +/* Can point to the memory from the NodePointer */ +UA_ExpandedNodeId UA_EXPORT +UA_NodePointer_toExpandedNodeId(UA_NodePointer np); + +/* Can point to the memory from the NodePointer. Discards the ServerIndex and + * NamespaceUri of a potential ExpandedNodeId inside the NodePointer. Test + * before if the NodePointer is local. */ +UA_NodeId UA_EXPORT +UA_NodePointer_toNodeId(UA_NodePointer np); + +/** + * Base Node Attributes + * -------------------- + * + * Nodes contain attributes according to their node type. The base node + * attributes are common to all node types. In the OPC UA :ref:`services`, + * attributes are referred to via the :ref:`nodeid` of the containing node and + * an integer :ref:`attribute-id`. + * + * Internally, open62541 uses ``UA_Node`` in places where the exact node type is + * not known or not important. The ``nodeClass`` attribute is used to ensure the + * correctness of casting from ``UA_Node`` to a specific node type. */ + +typedef struct { + UA_NodePointer targetId; /* Has to be the first entry */ + UA_UInt32 targetNameHash; /* Hash of the target's BrowseName. Set to zero + * if the target is remote. */ +} UA_ReferenceTarget; + +typedef struct { + UA_ReferenceTarget target; /* Has to be the first entry */ + UA_UInt32 targetIdHash; /* Hash of the targetId */ + struct aa_entry idTreeEntry; /* Binary-Tree for fast lookup */ + struct aa_entry nameTreeEntry; +} UA_ReferenceTargetTreeElem; + +/* List of reference targets with the same reference type and direction. Uses + * either an array or a tree structure. The SDK will not change the type of + * reference target structure internally. The nodestore implementations may + * switch internally when a node is updated. + * + * The recommendation is to switch to a tree once the number of refs > 8. */ +typedef struct { + union { + /* Organize the references in an array. Uses less memory, but incurs + * lookups in linear time. Recommended if the number of references is + * known to be small. */ + UA_ReferenceTarget *array; + + /* Organize the references in a tree for fast lookup */ + struct { + struct aa_entry *idTreeRoot; /* Fast lookup based on the target id */ + struct aa_entry *nameTreeRoot; /* Fast lookup based on the target browseName*/ + } tree; + } targets; + size_t targetsSize; + UA_Boolean hasRefTree; /* RefTree or RefArray? */ + UA_Byte referenceTypeIndex; + UA_Boolean isInverse; +} UA_NodeReferenceKind; + +/* Iterate over the references. Assumes that "prev" points to a + * NodeReferenceKind. If prev == NULL, the first element is returned. At the end + * of the iteration, NULL is returned. + * + * Do not continue the iteration after the rk was modified. */ +UA_EXPORT const UA_ReferenceTarget * +UA_NodeReferenceKind_iterate(const UA_NodeReferenceKind *rk, + const UA_ReferenceTarget *prev); + +/* Switch between array and tree representation. Does nothing upon error (e.g. + * out-of-memory). */ +UA_EXPORT UA_StatusCode +UA_NodeReferenceKind_switch(UA_NodeReferenceKind *rk); + +/* Every Node starts with these attributes */ +struct UA_NodeHead { + UA_NodeId nodeId; + UA_NodeClass nodeClass; + UA_QualifiedName browseName; + UA_LocalizedText displayName; + UA_LocalizedText description; + UA_UInt32 writeMask; + size_t referencesSize; + UA_NodeReferenceKind *references; + + /* Members specific to open62541 */ + void *context; + UA_Boolean constructed; /* Constructors were called */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_MonitoredItem *monitoredItems; /* MonitoredItems for Events and immediate + * DataChanges (no sampling interval). */ +#endif +}; + +/** + * VariableNode + * ------------ + * + * Variables store values in a :ref:`datavalue` together with + * metadata for introspection. Most notably, the attributes data type, value + * rank and array dimensions constrain the possible values the variable can take + * on. + * + * Variables come in two flavours: properties and datavariables. Properties are + * related to a parent with a ``hasProperty`` reference and may not have child + * nodes themselves. Datavariables may contain properties (``hasProperty``) and + * also datavariables (``hasComponents``). + * + * All variables are instances of some :ref:`variabletypenode` in return + * constraining the possible data type, value rank and array dimensions + * attributes. + * + * Data Type + * ~~~~~~~~~ + * + * The (scalar) data type of the variable is constrained to be of a specific + * type or one of its children in the type hierarchy. The data type is given as + * a NodeId pointing to a :ref:`datatypenode` in the type hierarchy. See the + * Section :ref:`datatypenode` for more details. + * + * If the data type attribute points to ``UInt32``, then the value attribute + * must be of that exact type since ``UInt32`` does not have children in the + * type hierarchy. If the data type attribute points ``Number``, then the type + * of the value attribute may still be ``UInt32``, but also ``Float`` or + * ``Byte``. + * + * Consistency between the data type attribute in the variable and its + * :ref:`VariableTypeNode` is ensured. + * + * Value Rank + * ~~~~~~~~~~ + * + * This attribute indicates whether the value attribute of the variable is an + * array and how many dimensions the array has. It may have the following + * values: + * + * - ``n >= 1``: the value is an array with the specified number of dimensions + * - ``n = 0``: the value is an array with one or more dimensions + * - ``n = -1``: the value is a scalar + * - ``n = -2``: the value can be a scalar or an array with any number of dimensions + * - ``n = -3``: the value can be a scalar or a one dimensional array + * + * Consistency between the value rank attribute in the variable and its + * :ref:`variabletypenode` is ensured. + * + * Array Dimensions + * ~~~~~~~~~~~~~~~~ + * + * If the value rank permits the value to be a (multi-dimensional) array, the + * exact length in each dimensions can be further constrained with this + * attribute. + * + * - For positive lengths, the variable value is guaranteed to be of the same + * length in this dimension. + * - The dimension length zero is a wildcard and the actual value may have any + * length in this dimension. + * + * Consistency between the array dimensions attribute in the variable and its + * :ref:`variabletypenode` is ensured. */ + +/* Indicates whether a variable contains data inline or whether it points to an + * external data source */ +typedef enum { + UA_VALUESOURCE_DATA, + UA_VALUESOURCE_DATASOURCE +} UA_ValueSource; + +typedef struct { + /* Called before the value attribute is read. It is possible to write into the + * value attribute during onRead (using the write service). The node is + * re-opened afterwards so that changes are considered in the following read + * operation. + * + * @param handle Points to user-provided data for the callback. + * @param nodeid The identifier of the node. + * @param data Points to the current node value. + * @param range Points to the numeric range the client wants to read from + * (or NULL). */ + void (*onRead)(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeid, + void *nodeContext, const UA_NumericRange *range, + const UA_DataValue *value); + + /* Called after writing the value attribute. The node is re-opened after + * writing so that the new value is visible in the callback. + * + * @param server The server executing the callback + * @sessionId The identifier of the session + * @sessionContext Additional data attached to the session + * in the access control layer + * @param nodeid The identifier of the node. + * @param nodeUserContext Additional data attached to the node by + * the user. + * @param nodeConstructorContext Additional data attached to the node + * by the type constructor(s). + * @param range Points to the numeric range the client wants to write to (or + * NULL). */ + void (*onWrite)(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeId, + void *nodeContext, const UA_NumericRange *range, + const UA_DataValue *data); +} UA_ValueCallback; + +typedef struct { + /* Copies the data from the source into the provided value. + * + * !! ZERO-COPY OPERATIONS POSSIBLE !! + * It is not required to return a copy of the actual content data. You can + * return a pointer to memory owned by the user. Memory can be reused + * between read callbacks of a DataSource, as the result is already encoded + * on the network buffer between each read operation. + * + * To use zero-copy reads, set the value of the `value->value` Variant + * without copying, e.g. with `UA_Variant_setScalar`. Then, also set + * `value->value.storageType` to `UA_VARIANT_DATA_NODELETE` to prevent the + * memory being cleaned up. Don't forget to also set `value->hasValue` to + * true to indicate the presence of a value. + * + * @param server The server executing the callback + * @param sessionId The identifier of the session + * @param sessionContext Additional data attached to the session in the + * access control layer + * @param nodeId The identifier of the node being read from + * @param nodeContext Additional data attached to the node by the user + * @param includeSourceTimeStamp If true, then the datasource is expected to + * set the source timestamp in the returned value + * @param range If not null, then the datasource shall return only a + * selection of the (nonscalar) data. Set + * UA_STATUSCODE_BADINDEXRANGEINVALID in the value if this does not + * apply + * @param value The (non-null) DataValue that is returned to the client. The + * data source sets the read data, the result status and optionally a + * sourcetimestamp. + * @return Returns a status code for logging. Error codes intended for the + * original caller are set in the value. If an error is returned, + * then no releasing of the value is done + */ + UA_StatusCode (*ua_read)(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeId, + void *nodeContext, UA_Boolean includeSourceTimeStamp, + const UA_NumericRange *range, UA_DataValue *value); + + /* Write into a data source. This method pointer can be NULL if the + * operation is unsupported. + * + * @param server The server executing the callback + * @param sessionId The identifier of the session + * @param sessionContext Additional data attached to the session in the + * access control layer + * @param nodeId The identifier of the node being written to + * @param nodeContext Additional data attached to the node by the user + * @param range If not NULL, then the datasource shall return only a + * selection of the (nonscalar) data. Set + * UA_STATUSCODE_BADINDEXRANGEINVALID in the value if this does not + * apply + * @param value The (non-NULL) DataValue that has been written by the client. + * The data source contains the written data, the result status and + * optionally a sourcetimestamp + * @return Returns a status code for logging. Error codes intended for the + * original caller are set in the value. If an error is returned, + * then no releasing of the value is done + */ + UA_StatusCode (*ua_write)(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeId, + void *nodeContext, const UA_NumericRange *range, + const UA_DataValue *value); +} UA_DataSource; + +/** + * .. _value-callback: + * + * Value Callback + * ~~~~~~~~~~~~~~ + * Value Callbacks can be attached to variable and variable type nodes. If + * not ``NULL``, they are called before reading and after writing respectively. */ +typedef struct { + /* Called before the value attribute is read. The external value source can be + * be updated and/or locked during this notification call. After this function returns + * to the core, the external value source is readed immediately. + */ + UA_StatusCode (*notificationRead)(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeid, + void *nodeContext, const UA_NumericRange *range); + + /* Called after writing the value attribute. The node is re-opened after + * writing so that the new value is visible in the callback. + * + * @param server The server executing the callback + * @sessionId The identifier of the session + * @sessionContext Additional data attached to the session + * in the access control layer + * @param nodeid The identifier of the node. + * @param nodeUserContext Additional data attached to the node by + * the user. + * @param nodeConstructorContext Additional data attached to the node + * by the type constructor(s). + * @param range Points to the numeric range the client wants to write to (or + * NULL). */ + UA_StatusCode (*userWrite)(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *nodeId, + void *nodeContext, const UA_NumericRange *range, + const UA_DataValue *data); +} UA_ExternalValueCallback; + +typedef enum { + UA_VALUEBACKENDTYPE_NONE, + UA_VALUEBACKENDTYPE_INTERNAL, + UA_VALUEBACKENDTYPE_DATA_SOURCE_CALLBACK, + UA_VALUEBACKENDTYPE_EXTERNAL +} UA_ValueBackendType; + +typedef struct { + UA_ValueBackendType backendType; + union { + struct { + UA_DataValue value; + UA_ValueCallback callback; + } internal; + UA_DataSource dataSource; + struct { + UA_DataValue **value; + UA_ExternalValueCallback callback; + } external; + } backend; +} UA_ValueBackend; + +#define UA_NODE_VARIABLEATTRIBUTES \ + /* Constraints on possible values */ \ + UA_NodeId dataType; \ + UA_Int32 valueRank; \ + size_t arrayDimensionsSize; \ + UA_UInt32 *arrayDimensions; \ + \ + UA_ValueBackend valueBackend; \ + \ + /* The current value */ \ + UA_ValueSource valueSource; \ + union { \ + struct { \ + UA_DataValue value; \ + UA_ValueCallback callback; \ + } data; \ + UA_DataSource dataSource; \ + } value; + +typedef struct { + UA_NodeHead head; + UA_NODE_VARIABLEATTRIBUTES + UA_Byte accessLevel; + UA_Double minimumSamplingInterval; + UA_Boolean historizing; + + /* Members specific to open62541 */ + UA_Boolean isDynamic; /* Some variables are "static" in the sense that they + * are not attached to a dynamic process in the + * background. Only dynamic variables conserve source + * and server timestamp for the value attribute. + * Static variables have timestamps of "now". */ +} UA_VariableNode; + +/** + * .. _variabletypenode: + * + * VariableTypeNode + * ---------------- + * + * VariableTypes are used to provide type definitions for variables. + * VariableTypes constrain the data type, value rank and array dimensions + * attributes of variable instances. Furthermore, instantiating from a specific + * variable type may provide semantic information. For example, an instance from + * ``MotorTemperatureVariableType`` is more meaningful than a float variable + * instantiated from ``BaseDataVariable``. */ + +typedef struct { + UA_NodeHead head; + UA_NODE_VARIABLEATTRIBUTES + UA_Boolean isAbstract; + + /* Members specific to open62541 */ + UA_NodeTypeLifecycle lifecycle; +} UA_VariableTypeNode; + +/** + * .. _methodnode: + * + * MethodNode + * ---------- + * + * Methods define callable functions and are invoked using the :ref:`Call + * ` service. MethodNodes may have special properties (variable + * children with a ``hasProperty`` reference) with the :ref:`qualifiedname` ``(0, + * "InputArguments")`` and ``(0, "OutputArguments")``. The input and output + * arguments are both described via an array of ``UA_Argument``. While the Call + * service uses a generic array of :ref:`variant` for input and output, the + * actual argument values are checked to match the signature of the MethodNode. + * + * Note that the same MethodNode may be referenced from several objects (and + * object types). For this, the NodeId of the method *and of the object + * providing context* is part of a Call request message. */ + +typedef UA_StatusCode +(*UA_MethodCallback)(UA_Server *server, const UA_NodeId *sessionId, + void *sessionContext, const UA_NodeId *methodId, + void *methodContext, const UA_NodeId *objectId, + void *objectContext, size_t inputSize, + const UA_Variant *input, size_t outputSize, + UA_Variant *output); + +typedef struct { + UA_NodeHead head; + UA_Boolean executable; + + /* Members specific to open62541 */ + UA_MethodCallback method; +#if UA_MULTITHREADING >= 100 + UA_Boolean async; /* Indicates an async method call */ +#endif +} UA_MethodNode; + +/** + * ObjectNode + * ---------- + * + * Objects are used to represent systems, system components, real-world objects + * and software objects. Objects are instances of an :ref:`object + * type` and may contain variables, methods and further + * objects. */ + +typedef struct { + UA_NodeHead head; + UA_Byte eventNotifier; +} UA_ObjectNode; + +/** + * .. _objecttypenode: + * + * ObjectTypeNode + * -------------- + * + * ObjectTypes provide definitions for Objects. Abstract objects cannot be + * instantiated. See :ref:`node-lifecycle` for the use of constructor and + * destructor callbacks. */ + +typedef struct { + UA_NodeHead head; + UA_Boolean isAbstract; + + /* Members specific to open62541 */ + UA_NodeTypeLifecycle lifecycle; +} UA_ObjectTypeNode; + +/** + * .. _referencetypenode: + * + * ReferenceTypeNode + * ----------------- + * + * Each reference between two nodes is typed with a ReferenceType that gives + * meaning to the relation. The OPC UA standard defines a set of ReferenceTypes + * as a mandatory part of OPC UA information models. + * + * - Abstract ReferenceTypes cannot be used in actual references and are only + * used to structure the ReferenceTypes hierarchy + * - Symmetric references have the same meaning from the perspective of the + * source and target node + * + * The figure below shows the hierarchy of the standard ReferenceTypes (arrows + * indicate a ``hasSubType`` relation). Refer to Part 3 of the OPC UA + * specification for the full semantics of each ReferenceType. + * + * .. graphviz:: + * + * digraph tree { + * + * node [height=0, shape=box, fillcolor="#E5E5E5", concentrate=true] + * + * references [label="References\n(Abstract, Symmetric)"] + * hierarchical_references [label="HierarchicalReferences\n(Abstract)"] + * references -> hierarchical_references + * + * nonhierarchical_references [label="NonHierarchicalReferences\n(Abstract, Symmetric)"] + * references -> nonhierarchical_references + * + * haschild [label="HasChild\n(Abstract)"] + * hierarchical_references -> haschild + * + * aggregates [label="Aggregates\n(Abstract)"] + * haschild -> aggregates + * + * organizes [label="Organizes"] + * hierarchical_references -> organizes + * + * hascomponent [label="HasComponent"] + * aggregates -> hascomponent + * + * hasorderedcomponent [label="HasOrderedComponent"] + * hascomponent -> hasorderedcomponent + * + * hasproperty [label="HasProperty"] + * aggregates -> hasproperty + * + * hassubtype [label="HasSubtype"] + * haschild -> hassubtype + * + * hasmodellingrule [label="HasModellingRule"] + * nonhierarchical_references -> hasmodellingrule + * + * hastypedefinition [label="HasTypeDefinition"] + * nonhierarchical_references -> hastypedefinition + * + * hasencoding [label="HasEncoding"] + * nonhierarchical_references -> hasencoding + * + * hasdescription [label="HasDescription"] + * nonhierarchical_references -> hasdescription + * + * haseventsource [label="HasEventSource"] + * hierarchical_references -> haseventsource + * + * hasnotifier [label="HasNotifier"] + * hierarchical_references -> hasnotifier + * + * generatesevent [label="GeneratesEvent"] + * nonhierarchical_references -> generatesevent + * + * alwaysgeneratesevent [label="AlwaysGeneratesEvent"] + * generatesevent -> alwaysgeneratesevent + * + * {rank=same hierarchical_references nonhierarchical_references} + * {rank=same generatesevent haseventsource hasmodellingrule + * hasencoding hassubtype} + * {rank=same alwaysgeneratesevent hasproperty} + * + * } + * + * The ReferenceType hierarchy can be extended with user-defined ReferenceTypes. + * Many Companion Specifications for OPC UA define new ReferenceTypes to be used + * in their domain of interest. + * + * For the following example of custom ReferenceTypes, we attempt to model the + * structure of a technical system. For this, we introduce two custom + * ReferenceTypes. First, the hierarchical ``contains`` ReferenceType indicates + * that a system (represented by an OPC UA object) contains a component (or + * subsystem). This gives rise to a tree-structure of containment relations. For + * example, the motor (object) is contained in the car and the crankshaft is + * contained in the motor. Second, the symmetric ``connectedTo`` ReferenceType + * indicates that two components are connected. For example, the motor's + * crankshaft is connected to the gear box. Connections are independent of the + * containment hierarchy and can induce a general graph-structure. Further + * subtypes of ``connectedTo`` could be used to differentiate between physical, + * electrical and information related connections. A client can then learn the + * layout of a (physical) system represented in an OPC UA information model + * based on a common understanding of just two custom reference types. */ + +typedef struct { + UA_NodeHead head; + UA_Boolean isAbstract; + UA_Boolean symmetric; + UA_LocalizedText inverseName; + + /* Members specific to open62541 */ + UA_Byte referenceTypeIndex; + UA_ReferenceTypeSet subTypes; /* contains the type itself as well */ +} UA_ReferenceTypeNode; + +/** + * .. _datatypenode: + * + * DataTypeNode + * ------------ + * + * DataTypes represent simple and structured data types. DataTypes may contain + * arrays. But they always describe the structure of a single instance. In + * open62541, DataTypeNodes in the information model hierarchy are matched to + * ``UA_DataType`` type descriptions for :ref:`generic-types` via their NodeId. + * + * Abstract DataTypes (e.g. ``Number``) cannot be the type of actual values. + * They are used to constrain values to possible child DataTypes (e.g. + * ``UInt32``). */ + +typedef struct { + UA_NodeHead head; + UA_Boolean isAbstract; +} UA_DataTypeNode; + +/** + * ViewNode + * -------- + * + * Each View defines a subset of the Nodes in the AddressSpace. Views can be + * used when browsing an information model to focus on a subset of nodes and + * references only. ViewNodes can be created and be interacted with. But their + * use in the :ref:`Browse` service is currently unsupported in + * open62541. */ + +typedef struct { + UA_NodeHead head; + UA_Byte eventNotifier; + UA_Boolean containsNoLoops; +} UA_ViewNode; + +/** + * Node Union + * ---------- + * + * A union that represents any kind of node. The node head can always be used. + * Check the NodeClass before accessing specific content. + */ + +typedef union { + UA_NodeHead head; + UA_VariableNode variableNode; + UA_VariableTypeNode variableTypeNode; + UA_MethodNode methodNode; + UA_ObjectNode objectNode; + UA_ObjectTypeNode objectTypeNode; + UA_ReferenceTypeNode referenceTypeNode; + UA_DataTypeNode dataTypeNode; + UA_ViewNode viewNode; +} UA_Node; + +/** + * Nodestore Plugin API + * -------------------- + * + * The following definitions are used for implementing custom node storage + * backends. **Most users will want to use the default nodestore and don't need + * to work with the nodestore API**. + * + * Outside of custom nodestore implementations, users should not manually edit + * nodes. Please use the OPC UA services for that. Otherwise, all consistency + * checks are omitted. This can crash the application eventually. */ + +typedef void (*UA_NodestoreVisitor)(void *visitorCtx, const UA_Node *node); + +typedef struct { + /* Nodestore context and lifecycle */ + void *context; + void (*clear)(void *nsCtx); + + /* The following definitions are used to create empty nodes of the different + * node types. The memory is managed by the nodestore. Therefore, the node + * has to be removed via a special deleteNode function. (If the new node is + * not added to the nodestore.) */ + UA_Node * (*newNode)(void *nsCtx, UA_NodeClass nodeClass); + + void (*deleteNode)(void *nsCtx, UA_Node *node); + + /* ``Get`` returns a pointer to an immutable node. ``Release`` indicates + * that the pointer is no longer accessed afterwards. */ + const UA_Node * (*getNode)(void *nsCtx, const UA_NodeId *nodeId); + + void (*releaseNode)(void *nsCtx, const UA_Node *node); + + /* Returns an editable copy of a node (needs to be deleted with the + * deleteNode function or inserted / replaced into the nodestore). */ + UA_StatusCode (*getNodeCopy)(void *nsCtx, const UA_NodeId *nodeId, + UA_Node **outNode); + + /* Inserts a new node into the nodestore. If the NodeId is zero, then a + * fresh numeric NodeId is assigned. If insertion fails, the node is + * deleted. */ + UA_StatusCode (*insertNode)(void *nsCtx, UA_Node *node, + UA_NodeId *addedNodeId); + + /* To replace a node, get an editable copy of the node, edit and replace + * with this function. If the node was already replaced since the copy was + * made, UA_STATUSCODE_BADINTERNALERROR is returned. If the NodeId is not + * found, UA_STATUSCODE_BADNODEIDUNKNOWN is returned. In both error cases, + * the editable node is deleted. */ + UA_StatusCode (*replaceNode)(void *nsCtx, UA_Node *node); + + /* Removes a node from the nodestore. */ + UA_StatusCode (*removeNode)(void *nsCtx, const UA_NodeId *nodeId); + + /* Maps the ReferenceTypeIndex used for the references to the NodeId of the + * ReferenceType. The returned pointer is stable until the Nodestore is + * deleted. */ + const UA_NodeId * (*getReferenceTypeId)(void *nsCtx, UA_Byte refTypeIndex); + + /* Execute a callback for every node in the nodestore. */ + void (*iterate)(void *nsCtx, UA_NodestoreVisitor visitor, + void *visitorCtx); +} UA_Nodestore; + +/* Attributes must be of a matching type (VariableAttributes, ObjectAttributes, + * and so on). The attributes are copied. Note that the attributes structs do + * not contain NodeId, NodeClass and BrowseName. The NodeClass of the node needs + * to be correctly set before calling this method. UA_Node_clear is called on + * the node when an error occurs internally. */ +UA_StatusCode UA_EXPORT +UA_Node_setAttributes(UA_Node *node, const void *attributes, + const UA_DataType *attributeType); + +/* Reset the destination node and copy the content of the source */ +UA_StatusCode UA_EXPORT +UA_Node_copy(const UA_Node *src, UA_Node *dst); + +/* Allocate new node and copy the values from src */ +UA_EXPORT UA_Node * +UA_Node_copy_alloc(const UA_Node *src); + +/* Add a single reference to the node */ +UA_StatusCode UA_EXPORT +UA_Node_addReference(UA_Node *node, UA_Byte refTypeIndex, UA_Boolean isForward, + const UA_ExpandedNodeId *targetNodeId, + UA_UInt32 targetBrowseNameHash); + +/* Delete a single reference from the node */ +UA_StatusCode UA_EXPORT +UA_Node_deleteReference(UA_Node *node, UA_Byte refTypeIndex, UA_Boolean isForward, + const UA_ExpandedNodeId *targetNodeId); + +/* Deletes references from the node which are not matching any type in the given + * array. Could be used to e.g. delete all the references, except + * 'HASMODELINGRULE' */ +void UA_EXPORT +UA_Node_deleteReferencesSubset(UA_Node *node, const UA_ReferenceTypeSet *keepSet); + +/* Delete all references of the node */ +void UA_EXPORT +UA_Node_deleteReferences(UA_Node *node); + +/* Remove all malloc'ed members of the node and reset */ +void UA_EXPORT +UA_Node_clear(UA_Node *node); + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/server_pubsub.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright (c) 2017-2018 Fraunhofer IOSB (Author: Andreas Ebner) + * Copyright (c) 2019 Kalycito Infotech Private Limited + * Copyright (c) 2021 Fraunhofer IOSB (Author: Jan Hermes) + */ + +#ifndef UA_SERVER_PUBSUB_H +#define UA_SERVER_PUBSUB_H + + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_PUBSUB + +/** + * .. _pubsub: + * + * PubSub + * ====== + * + * In PubSub the participating OPC UA Applications take their roles as + * Publishers and Subscribers. Publishers are the sources of data, while + * Subscribers consume that data. Communication in PubSub is message-based. + * Publishers send messages to a Message Oriented Middleware, without knowledge + * of what, if any, Subscribers there may be. Similarly, Subscribers express + * interest in specific types of data, and process messages that contain this + * data, without knowledge of what Publishers there are. + * + * Message Oriented Middleware is software or hardware infrastructure that + * supports sending and receiving messages between distributed systems. OPC UA + * PubSub supports two different Message Oriented Middleware variants, namely + * the broker-less form and broker-based form. A broker-less form is where the + * Message Oriented Middleware is the network infrastructure that is able to + * route datagram-based messages. Subscribers and Publishers use datagram + * protocols like UDP. In a broker-based form, the core component of the Message + * Oriented Middleware is a message Broker. Subscribers and Publishers use + * standard messaging protocols like AMQP or MQTT to communicate with the + * Broker. + * + * This makes PubSub suitable for applications where location independence + * and/or scalability are required. + * + * The Publish/Subscribe (PubSub) extension for OPC UA enables fast and + * efficient 1:m communication. The PubSub extension is protocol agnostic and + * can be used with broker based protocols like MQTT and AMQP or brokerless + * implementations like UDP-Multicasting. + * + * The PubSub API uses the following scheme: + * + * 1. Create a configuration for the needed PubSub element. + * + * 2. Call the add[element] function and pass in the configuration. + * + * 3. The add[element] function returns the unique nodeId of the internally created element. + * + * Take a look on the PubSub Tutorials for more details about the API usage:: + * + * +-----------+ + * | UA_Server | + * +-----------+ + * | | + * | | + * | | + * | | +----------------------+ + * | +--> UA_PubSubConnection | UA_Server_addPubSubConnection + * | +----------------------+ + * | | | + * | | | +----------------+ + * | | +----> UA_WriterGroup | UA_PubSubConnection_addWriterGroup + * | | +----------------+ + * | | | + * | | | +------------------+ + * | | +----> UA_DataSetWriter | UA_WriterGroup_addDataSetWriter +-+ + * | | +------------------+ | + * | | | + * | | +----------------+ | r + * | +---------> UA_ReaderGroup | UA_PubSubConnection_addReaderGroup | e + * | +----------------+ | f + * | | | + * | | +------------------+ | + * | +----> UA_DataSetReader | UA_ReaderGroup_addDataSetReader | + * | +------------------+ | + * | | | + * | | +----------------------+ | + * | +----> UA_SubscribedDataSet | | + * | +----------------------+ | + * | | | + * | | +----------------------------+ | + * | +----> UA_TargetVariablesDataType | | + * | | +----------------------------+ | + * | | | + * | | +------------------------------------+ | + * | +----> UA_SubscribedDataSetMirrorDataType | | + * | +------------------------------------+ | + * | | + * | +---------------------------+ | + * +-------> UA_PubSubPublishedDataSet | UA_Server_addPublishedDataSet <-+ + * +---------------------------+ + * | + * | +-----------------+ + * +----> UA_DataSetField | UA_PublishedDataSet_addDataSetField + * +-----------------+ + * + * PubSub Information Model Representation + * --------------------------------------- + * .. _pubsub_informationmodel: + * + * The complete PubSub configuration is available inside the information model. + * The entry point is the node 'PublishSubscribe', located under the Server + * node. + * The standard defines for PubSub no new Service set. The configuration can + * optionally be done over methods inside the information model. + * The information model representation of the current PubSub configuration is + * generated automatically. This feature can be enabled/disabled by changing the + * UA_ENABLE_PUBSUB_INFORMATIONMODEL option. + * + * Connections + * ----------- + * The PubSub connections are the abstraction between the concrete transport protocol + * and the PubSub functionality. It is possible to create multiple connections with + * different transport protocols at runtime. + * + * Take a look on the PubSub Tutorials for mor details about the API usage. + */ + +typedef enum { + UA_PUBSUB_COMPONENT_CONNECTION, + UA_PUBSUB_COMPONENT_WRITERGROUP, + UA_PUBSUB_COMPONENT_DATASETWRITER, + UA_PUBSUB_COMPONENT_READERGROUP, + UA_PUBSUB_COMPONENT_DATASETREADER +} UA_PubSubComponentEnumType; + +typedef enum { + UA_PUBSUB_PUBLISHERID_NUMERIC, + UA_PUBSUB_PUBLISHERID_STRING +} UA_PublisherIdType; + +struct UA_PubSubConnectionConfig { + UA_String name; + UA_Boolean enabled; + UA_PublisherIdType publisherIdType; + union { /* std: valid types UInt or String */ + UA_UInt32 numeric; + UA_String string; + } publisherId; + UA_String transportProfileUri; + UA_Variant address; + size_t connectionPropertiesSize; + UA_KeyValuePair *connectionProperties; + UA_Variant connectionTransportSettings; +}; + +#ifdef UA_ENABLE_PUBSUB_MONITORING + +typedef enum { + UA_PUBSUB_MONITORING_MESSAGE_RECEIVE_TIMEOUT + // extend as needed +} UA_PubSubMonitoringType; + +/* PubSub monitoring interface */ +typedef struct { + UA_StatusCode (*createMonitoring)(UA_Server *server, UA_NodeId Id, + UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, + void *data, UA_ServerCallback callback); + UA_StatusCode (*startMonitoring)(UA_Server *server, UA_NodeId Id, + UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data); + UA_StatusCode (*stopMonitoring)(UA_Server *server, UA_NodeId Id, + UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data); + UA_StatusCode (*updateMonitoringInterval)(UA_Server *server, UA_NodeId Id, + UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, + void *data); + UA_StatusCode (*deleteMonitoring)(UA_Server *server, UA_NodeId Id, + UA_PubSubComponentEnumType eComponentType, + UA_PubSubMonitoringType eMonitoringType, void *data); +} UA_PubSubMonitoringInterface; + +#endif /* UA_ENABLE_PUBSUB_MONITORING */ + +/* General PubSub configuration */ +struct UA_PubSubConfiguration { + /* PubSub network layer */ + size_t transportLayersSize; + UA_PubSubTransportLayer *transportLayers; + + /* Callback for PubSub component state changes: If provided this callback + * informs the application about PubSub component state changes. E.g. state + * change from operational to error in case of a DataSetReader + * MessageReceiveTimeout. The status code provides additional + * information. */ + void (*stateChangeCallback)(UA_NodeId *Id, UA_PubSubState state, + UA_StatusCode status); + /* TODO: maybe status code provides not enough information about the state change */ + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + /* PubSub security policies */ + size_t securityPoliciesSize; + UA_PubSubSecurityPolicy *securityPolicies; +#endif + +#ifdef UA_ENABLE_PUBSUB_MONITORING + UA_PubSubMonitoringInterface monitoringInterface; +#endif +}; + + +/** + * The UA_ServerConfig_addPubSubTransportLayer is used to add a transport layer + * to the server configuration. The list memory is allocated and will be freed + * with UA_PubSubManager_delete. + * + * .. note:: If the UA_String transportProfileUri was dynamically allocated + * the memory has to be freed when no longer required. + * + * .. note:: This has to be done before the server is started with UA_Server_run. */ + +UA_StatusCode UA_EXPORT +UA_ServerConfig_addPubSubTransportLayer(UA_ServerConfig *config, + UA_PubSubTransportLayer pubsubTransportLayer); + +UA_StatusCode UA_EXPORT +UA_Server_addPubSubConnection(UA_Server *server, + const UA_PubSubConnectionConfig *connectionConfig, + UA_NodeId *connectionIdentifier); + +/* Returns a deep copy of the config */ +UA_StatusCode UA_EXPORT +UA_Server_getPubSubConnectionConfig(UA_Server *server, + const UA_NodeId connection, + UA_PubSubConnectionConfig *config); + +/* Remove Connection, identified by the NodeId. Deletion of Connection + * removes all contained WriterGroups and Writers. */ +UA_StatusCode UA_EXPORT +UA_Server_removePubSubConnection(UA_Server *server, const UA_NodeId connection); + +/** + * PublishedDataSets + * ----------------- + * The PublishedDataSets (PDS) are containers for the published information. The + * PDS contain the published variables and meta information. The metadata is + * commonly autogenerated or given as constant argument as part of the template + * functions. The template functions are standard defined and intended for + * configuration tools. You should normally create an empty PDS and call the + * functions to add new fields. */ + +/* The UA_PUBSUB_DATASET_PUBLISHEDITEMS has currently no additional members and + * thus no dedicated config structure. */ + +typedef enum { + UA_PUBSUB_DATASET_PUBLISHEDITEMS, + UA_PUBSUB_DATASET_PUBLISHEDEVENTS, + UA_PUBSUB_DATASET_PUBLISHEDITEMS_TEMPLATE, + UA_PUBSUB_DATASET_PUBLISHEDEVENTS_TEMPLATE, +} UA_PublishedDataSetType; + +typedef struct { + UA_DataSetMetaDataType metaData; + size_t variablesToAddSize; + UA_PublishedVariableDataType *variablesToAdd; +} UA_PublishedDataItemsTemplateConfig; + +typedef struct { + UA_NodeId eventNotfier; + UA_ContentFilter filter; +} UA_PublishedEventConfig; + +typedef struct { + UA_DataSetMetaDataType metaData; + UA_NodeId eventNotfier; + size_t selectedFieldsSize; + UA_SimpleAttributeOperand *selectedFields; + UA_ContentFilter filter; +} UA_PublishedEventTemplateConfig; + +/* Configuration structure for PublishedDataSet */ +typedef struct { + UA_String name; + UA_PublishedDataSetType publishedDataSetType; + union { + /* The UA_PUBSUB_DATASET_PUBLISHEDITEMS has currently no additional members + * and thus no dedicated config structure.*/ + UA_PublishedDataItemsTemplateConfig itemsTemplate; + UA_PublishedEventConfig event; + UA_PublishedEventTemplateConfig eventTemplate; + } config; +} UA_PublishedDataSetConfig; + +void UA_EXPORT +UA_PublishedDataSetConfig_clear(UA_PublishedDataSetConfig *pdsConfig); + +typedef struct { + UA_StatusCode addResult; + size_t fieldAddResultsSize; + UA_StatusCode *fieldAddResults; + UA_ConfigurationVersionDataType configurationVersion; +} UA_AddPublishedDataSetResult; + +UA_AddPublishedDataSetResult UA_EXPORT +UA_Server_addPublishedDataSet(UA_Server *server, + const UA_PublishedDataSetConfig *publishedDataSetConfig, + UA_NodeId *pdsIdentifier); + +/* Returns a deep copy of the config */ +UA_StatusCode UA_EXPORT +UA_Server_getPublishedDataSetConfig(UA_Server *server, const UA_NodeId pds, + UA_PublishedDataSetConfig *config); + +/* Returns a deep copy of the DataSetMetaData for an specific PDS */ +UA_StatusCode UA_EXPORT +UA_Server_getPublishedDataSetMetaData(UA_Server *server, const UA_NodeId pds, + UA_DataSetMetaDataType *metaData); + +/* Remove PublishedDataSet, identified by the NodeId. Deletion of PDS removes + * all contained and linked PDS Fields. Connected WriterGroups will be also + * removed. */ +UA_StatusCode UA_EXPORT +UA_Server_removePublishedDataSet(UA_Server *server, const UA_NodeId pds); + +/** + * DataSetFields + * ------------- + * The description of published variables is named DataSetField. Each + * DataSetField contains the selection of one information model node. The + * DataSetField has additional parameters for the publishing, sampling and error + * handling process. */ + +typedef struct{ + UA_ConfigurationVersionDataType configurationVersion; + UA_String fieldNameAlias; + UA_Boolean promotedField; + UA_PublishedVariableDataType publishParameters; + + /* non std. field */ + struct { + UA_Boolean rtFieldSourceEnabled; + /* If the rtInformationModelNode is set, the nodeid in publishParameter must point + * to a node with external data source backend defined + * */ + UA_Boolean rtInformationModelNode; + //TODO -> decide if suppress C++ warnings and use 'UA_DataValue * * const staticValueSource;' + UA_DataValue ** staticValueSource; + } rtValueSource; + + +} UA_DataSetVariableConfig; + +typedef enum { + UA_PUBSUB_DATASETFIELD_VARIABLE, + UA_PUBSUB_DATASETFIELD_EVENT +} UA_DataSetFieldType; + +typedef struct { + UA_DataSetFieldType dataSetFieldType; + union { + /* events need other config later */ + UA_DataSetVariableConfig variable; + } field; +} UA_DataSetFieldConfig; + +void UA_EXPORT +UA_DataSetFieldConfig_clear(UA_DataSetFieldConfig *dataSetFieldConfig); + +typedef struct { + UA_StatusCode result; + UA_ConfigurationVersionDataType configurationVersion; +} UA_DataSetFieldResult; + +UA_DataSetFieldResult UA_EXPORT +UA_Server_addDataSetField(UA_Server *server, + const UA_NodeId publishedDataSet, + const UA_DataSetFieldConfig *fieldConfig, + UA_NodeId *fieldIdentifier); + +/* Returns a deep copy of the config */ +UA_StatusCode UA_EXPORT +UA_Server_getDataSetFieldConfig(UA_Server *server, const UA_NodeId dsf, + UA_DataSetFieldConfig *config); + +UA_DataSetFieldResult UA_EXPORT +UA_Server_removeDataSetField(UA_Server *server, const UA_NodeId dsf); + +/** + * Custom Callback Implementation + * ------------------------------ + * The user can use his own callback implementation for publishing + * and subscribing. The user must take care of the callback to call for + * every publishing or subscibing interval */ + +typedef struct { + /* User's callback implementation. The user configured base time and timer policy + * will be provided as an argument to this callback so that the user can + * implement his callback (thread) considering base time and timer policies */ + UA_StatusCode (*addCustomCallback)(UA_Server *server, UA_NodeId identifier, + UA_ServerCallback callback, + void *data, UA_Double interval_ms, + UA_DateTime *baseTime, UA_TimerPolicy timerPolicy, + UA_UInt64 *callbackId); + + UA_StatusCode (*changeCustomCallback)(UA_Server *server, UA_NodeId identifier, + UA_UInt64 callbackId, UA_Double interval_ms, + UA_DateTime *baseTime, UA_TimerPolicy timerPolicy); + + void (*removeCustomCallback)(UA_Server *server, UA_NodeId identifier, UA_UInt64 callbackId); + +} UA_PubSub_CallbackLifecycle; + +/** + * WriterGroup + * ----------- + * All WriterGroups are created within a PubSubConnection and automatically + * deleted if the connection is removed. The WriterGroup is primary used as + * container for :ref:`dsw` and network message settings. The WriterGroup can be + * imagined as producer of the network messages. The creation of network + * messages is controlled by parameters like the publish interval, which is e.g. + * contained in the WriterGroup. */ + +typedef enum { + UA_PUBSUB_ENCODING_BINARY, + UA_PUBSUB_ENCODING_JSON, + UA_PUBSUB_ENCODING_UADP +} UA_PubSubEncodingType; + +/** + * WriterGroup + * ----------- + * The message publishing can be configured for realtime requirements. The RT-levels + * go along with different requirements. The below listed levels can be configured: + * + * UA_PUBSUB_RT_NONE - + * ---> Description: Default "none-RT" Mode + * ---> Requirements: - + * ---> Restrictions: - + * UA_PUBSUB_RT_DIRECT_VALUE_ACCESS (Preview - not implemented) + * ---> Description: Normally, the latest value for each DataSetField is read out of the information model. Within this RT-mode, the + * value source of each field configured as static pointer to an DataValue. The publish cycle won't use call the server read function. + * ---> Requirements: All fields must be configured with a 'staticValueSource'. + * ---> Restrictions: - + * UA_PUBSUB_RT_FIXED_LENGTH (Preview - not implemented) + * ---> Description: All DataSetFields have a known, non-changing length. The server will pre-generate some + * buffers and use only memcopy operations to generate requested PubSub packages. + * ---> Requirements: DataSetFields with variable size cannot be used within this mode. + * ---> Restrictions: The configuration must be frozen and changes are not allowed while the WriterGroup is 'Operational'. + * UA_PUBSUB_RT_DETERMINISTIC (Preview - not implemented) + * ---> Description: - + * ---> Requirements: - + * ---> Restrictions: - + * + * WARNING! For hard real time requirements the underlying system must be rt-capable. + * + */ +typedef enum { + UA_PUBSUB_RT_NONE = 0, + UA_PUBSUB_RT_DIRECT_VALUE_ACCESS = 1, + UA_PUBSUB_RT_FIXED_SIZE = 2, + UA_PUBSUB_RT_DETERMINISTIC = 4, +} UA_PubSubRTLevel; + +typedef struct { + UA_String name; + UA_Boolean enabled; + UA_UInt16 writerGroupId; + UA_Duration publishingInterval; + UA_Double keepAliveTime; + UA_Byte priority; + UA_ExtensionObject transportSettings; + UA_ExtensionObject messageSettings; + size_t groupPropertiesSize; + UA_KeyValuePair *groupProperties; + UA_PubSubEncodingType encodingMimeType; + /* PubSub Manager Callback */ + UA_PubSub_CallbackLifecycle pubsubManagerCallback; + /* non std. config parameter. maximum count of embedded DataSetMessage in + * one NetworkMessage */ + UA_UInt16 maxEncapsulatedDataSetMessageCount; + /* non std. field */ + UA_PubSubRTLevel rtLevel; + + /* Message are encrypted if a SecurityPolicy is configured and the + * securityMode set accordingly. The symmetric key is a runtime information + * and has to be set via UA_Server_setWriterGroupEncryptionKey. */ + UA_MessageSecurityMode securityMode; /* via the UA_WriterGroupDataType */ +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + UA_PubSubSecurityPolicy *securityPolicy; +#endif +} UA_WriterGroupConfig; + +void UA_EXPORT +UA_WriterGroupConfig_clear(UA_WriterGroupConfig *writerGroupConfig); + +/* Add a new WriterGroup to an existing Connection */ +UA_StatusCode UA_EXPORT +UA_Server_addWriterGroup(UA_Server *server, const UA_NodeId connection, + const UA_WriterGroupConfig *writerGroupConfig, + UA_NodeId *writerGroupIdentifier); + +/* Returns a deep copy of the config */ +UA_StatusCode UA_EXPORT +UA_Server_getWriterGroupConfig(UA_Server *server, const UA_NodeId writerGroup, + UA_WriterGroupConfig *config); + +UA_StatusCode UA_EXPORT +UA_Server_updateWriterGroupConfig(UA_Server *server, UA_NodeId writerGroupIdentifier, + const UA_WriterGroupConfig *config); + +/* Get state of WriterGroup */ +UA_StatusCode UA_EXPORT +UA_Server_WriterGroup_getState(UA_Server *server, UA_NodeId writerGroupIdentifier, + UA_PubSubState *state); + +UA_StatusCode UA_EXPORT +UA_Server_removeWriterGroup(UA_Server *server, const UA_NodeId writerGroup); + +UA_StatusCode UA_EXPORT +UA_Server_freezeWriterGroupConfiguration(UA_Server *server, const UA_NodeId writerGroup); + +UA_StatusCode UA_EXPORT +UA_Server_unfreezeWriterGroupConfiguration(UA_Server *server, const UA_NodeId writerGroup); + +UA_StatusCode UA_EXPORT +UA_Server_setWriterGroupOperational(UA_Server *server, const UA_NodeId writerGroup); + +UA_StatusCode UA_EXPORT +UA_Server_setWriterGroupDisabled(UA_Server *server, const UA_NodeId writerGroup); + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION +/* Set the group key for the message encryption */ +UA_StatusCode UA_EXPORT +UA_Server_setWriterGroupEncryptionKeys(UA_Server *server, const UA_NodeId writerGroup, + UA_UInt32 securityTokenId, + const UA_ByteString signingKey, + const UA_ByteString encryptingKey, + const UA_ByteString keyNonce); +#endif + +/** + * .. _dsw: + * + * DataSetWriter + * ------------- + * The DataSetWriters are the glue between the WriterGroups and the + * PublishedDataSets. The DataSetWriter contain configuration parameters and + * flags which influence the creation of DataSet messages. These messages are + * encapsulated inside the network message. The DataSetWriter must be linked + * with an existing PublishedDataSet and be contained within a WriterGroup. */ + +typedef struct { + UA_String name; + UA_UInt16 dataSetWriterId; + UA_DataSetFieldContentMask dataSetFieldContentMask; + UA_UInt32 keyFrameCount; + UA_ExtensionObject messageSettings; + UA_ExtensionObject transportSettings; + UA_String dataSetName; + size_t dataSetWriterPropertiesSize; + UA_KeyValuePair *dataSetWriterProperties; +} UA_DataSetWriterConfig; + +void UA_EXPORT +UA_DataSetWriterConfig_clear(UA_DataSetWriterConfig *pdsConfig); + +/* Add a new DataSetWriter to an existing WriterGroup. The DataSetWriter must be + * coupled with a PublishedDataSet on creation. + * + * Part 14, 7.1.5.2.1 defines: The link between the PublishedDataSet and + * DataSetWriter shall be created when an instance of the DataSetWriterType is + * created. */ +UA_StatusCode UA_EXPORT +UA_Server_addDataSetWriter(UA_Server *server, + const UA_NodeId writerGroup, const UA_NodeId dataSet, + const UA_DataSetWriterConfig *dataSetWriterConfig, + UA_NodeId *writerIdentifier); + +/* Returns a deep copy of the config */ +UA_StatusCode UA_EXPORT +UA_Server_getDataSetWriterConfig(UA_Server *server, const UA_NodeId dsw, + UA_DataSetWriterConfig *config); + +/* Get state of DataSetWriter */ +UA_StatusCode UA_EXPORT +UA_Server_DataSetWriter_getState(UA_Server *server, UA_NodeId dataSetWriterIdentifier, + UA_PubSubState *state); + +UA_StatusCode UA_EXPORT +UA_Server_removeDataSetWriter(UA_Server *server, const UA_NodeId dsw); + +/** + * SubscribedDataSet + * ----------------- + * SubscribedDataSet describes the processing of the received DataSet. + * SubscribedDataSet defines which field in the DataSet is mapped to which + * Variable in the OPC UA Application. SubscribedDataSet has two sub-types + * called the TargetVariablesType and SubscribedDataSetMirrorType. + * SubscribedDataSetMirrorType is currently not supported. SubscribedDataSet is + * set to TargetVariablesType and then the list of target Variables are created + * in the Subscriber AddressSpace. TargetVariables are a list of variables that + * are to be added in the Subscriber AddressSpace. It defines a list of Variable + * mappings between received DataSet fields and added Variables in the + * Subscriber AddressSpace. */ + +/* SubscribedDataSetDataType Definition */ +typedef enum { + UA_PUBSUB_SDS_TARGET, + UA_PUBSUB_SDS_MIRROR +} UA_SubscribedDataSetEnumType; + +typedef struct { + /* Standard-defined FieldTargetDataType */ + UA_FieldTargetDataType targetVariable; + + /* If realtime-handling is required, set this pointer non-NULL and it will be used + * to memcpy the value instead of using the Write service. + * If the beforeWrite method pointer is set, it will be called before a memcpy update + * to the value. But param externalDataValue already contains the new value. + * If the afterWrite method pointer is set, it will be called after a memcpy update + * to the value. */ + UA_DataValue **externalDataValue; + void *targetVariableContext; /* user-defined pointer */ + void (*beforeWrite)(UA_Server *server, + const UA_NodeId *readerIdentifier, + const UA_NodeId *readerGroupIdentifier, + const UA_NodeId *targetVariableIdentifier, + void *targetVariableContext, + UA_DataValue **externalDataValue); + void (*afterWrite)(UA_Server *server, + const UA_NodeId *readerIdentifier, + const UA_NodeId *readerGroupIdentifier, + const UA_NodeId *targetVariableIdentifier, + void *targetVariableContext, + UA_DataValue **externalDataValue); +} UA_FieldTargetVariable; + +typedef struct { + size_t targetVariablesSize; + UA_FieldTargetVariable *targetVariables; +} UA_TargetVariables; + +/* Return Status Code after creating TargetVariables in Subscriber AddressSpace */ +UA_StatusCode UA_EXPORT +UA_Server_DataSetReader_createTargetVariables(UA_Server *server, + UA_NodeId dataSetReaderIdentifier, + size_t targetVariablesSize, + const UA_FieldTargetVariable *targetVariables); + +/* To Do:Implementation of SubscribedDataSetMirrorType + * UA_StatusCode + * A_PubSubDataSetReader_createDataSetMirror(UA_Server *server, UA_NodeId dataSetReaderIdentifier, + * UA_SubscribedDataSetMirrorDataType* mirror) */ + +/** + * DataSetReader + * ------------- + * DataSetReader can receive NetworkMessages with the DataSetMessage + * of interest sent by the Publisher. DataSetReaders represent + * the configuration necessary to receive and process DataSetMessages + * on the Subscriber side. DataSetReader must be linked with a + * SubscribedDataSet and be contained within a ReaderGroup. */ + +/* Parameters for PubSubSecurity */ +typedef struct { + UA_Int32 securityMode; /* placeholder datatype 'MessageSecurityMode' */ + UA_String securityGroupId; + size_t keyServersSize; + UA_Int32 *keyServers; +} UA_PubSubSecurityParameters; + +typedef enum { + UA_PUBSUB_RT_UNKNOWN = 0, + UA_PUBSUB_RT_VARIANT = 1, + UA_PUBSUB_RT_DATA_VALUE = 2, + UA_PUBSUB_RT_RAW = 4, +} UA_PubSubRtEncoding; + +/* Parameters for PubSub DataSetReader Configuration */ +typedef struct { + UA_String name; + UA_Variant publisherId; + UA_UInt16 writerGroupId; + UA_UInt16 dataSetWriterId; + UA_DataSetMetaDataType dataSetMetaData; + UA_DataSetFieldContentMask dataSetFieldContentMask; + UA_Double messageReceiveTimeout; + UA_PubSubSecurityParameters securityParameters; + UA_ExtensionObject messageSettings; + UA_ExtensionObject transportSettings; + UA_SubscribedDataSetEnumType subscribedDataSetType; + /* TODO UA_SubscribedDataSetMirrorDataType subscribedDataSetMirror */ + union { + UA_TargetVariables subscribedDataSetTarget; + // UA_SubscribedDataSetMirrorDataType subscribedDataSetMirror; + } subscribedDataSet; + /* non std. fields */ + UA_PubSubRtEncoding expectedEncoding; +} UA_DataSetReaderConfig; + +/* Update configuration to the dataSetReader */ +UA_StatusCode UA_EXPORT +UA_Server_DataSetReader_updateConfig(UA_Server *server, UA_NodeId dataSetReaderIdentifier, + UA_NodeId readerGroupIdentifier, + const UA_DataSetReaderConfig *config); + +/* Get configuration of the dataSetReader */ +UA_StatusCode UA_EXPORT +UA_Server_DataSetReader_getConfig(UA_Server *server, UA_NodeId dataSetReaderIdentifier, + UA_DataSetReaderConfig *config); + +/* Get state of DataSetReader */ +UA_StatusCode UA_EXPORT +UA_Server_DataSetReader_getState(UA_Server *server, UA_NodeId dataSetReaderIdentifier, + UA_PubSubState *state); + +/** + * ReaderGroup + * ----------- + + * ReaderGroup is used to group a list of DataSetReaders. All ReaderGroups are + * created within a PubSubConnection and automatically deleted if the connection + * is removed. All network message related filters are only available in the + * DataSetReader. + * + * The RT-levels go along with different requirements. The below listed levels + * can be configured for a ReaderGroup. + * + * - UA_PUBSUB_RT_NONE: RT applied to this level + * - PUBSUB_CONFIG_FASTPATH_FIXED_OFFSETS: Extends PubSub RT functionality and + * implements fast path message decoding in the Subscriber. Uses a buffered + * network message and only decodes the necessary offsets stored in an offset + * buffer. */ + +/* ReaderGroup configuration */ +typedef struct { + UA_String name; + UA_PubSubSecurityParameters securityParameters; + /* PubSub Manager Callback */ + UA_PubSub_CallbackLifecycle pubsubManagerCallback; + /* non std. field */ + UA_Duration subscribingInterval; // Callback interval for subscriber: set the least publishingInterval value of all DSRs in this RG + UA_Boolean enableBlockingSocket; // To enable or disable blocking socket option + UA_UInt32 timeout; // Timeout for receive to wait for the packets + UA_PubSubRTLevel rtLevel; + size_t groupPropertiesSize; + UA_KeyValuePair *groupProperties; + + /* Messages are decrypted if a SecurityPolicy is configured and the + * securityMode set accordingly. The symmetric key is a runtime information + * and has to be set via UA_Server_setReaderGroupEncryptionKey. */ + UA_MessageSecurityMode securityMode; +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + UA_PubSubSecurityPolicy *securityPolicy; +#endif +} UA_ReaderGroupConfig; + +void UA_EXPORT +UA_ReaderGroupConfig_clear(UA_ReaderGroupConfig *readerGroupConfig); + +/* Add DataSetReader to the ReaderGroup */ +UA_StatusCode UA_EXPORT +UA_Server_addDataSetReader(UA_Server *server, UA_NodeId readerGroupIdentifier, + const UA_DataSetReaderConfig *dataSetReaderConfig, + UA_NodeId *readerIdentifier); + +/* Remove DataSetReader from ReaderGroup */ +UA_StatusCode UA_EXPORT +UA_Server_removeDataSetReader(UA_Server *server, UA_NodeId readerIdentifier); + +/* To Do: Update Configuration of ReaderGroup + * UA_StatusCode UA_EXPORT + * UA_Server_ReaderGroup_updateConfig(UA_Server *server, UA_NodeId readerGroupIdentifier, + * const UA_ReaderGroupConfig *config); + */ + +/* Get configuraiton of ReaderGroup */ +UA_StatusCode UA_EXPORT +UA_Server_ReaderGroup_getConfig(UA_Server *server, UA_NodeId readerGroupIdentifier, + UA_ReaderGroupConfig *config); + +/* Get state of ReaderGroup */ +UA_StatusCode UA_EXPORT +UA_Server_ReaderGroup_getState(UA_Server *server, UA_NodeId readerGroupIdentifier, + UA_PubSubState *state); + +/* Add ReaderGroup to the created connection */ +UA_StatusCode UA_EXPORT +UA_Server_addReaderGroup(UA_Server *server, UA_NodeId connectionIdentifier, + const UA_ReaderGroupConfig *readerGroupConfig, + UA_NodeId *readerGroupIdentifier); + +/* Remove ReaderGroup from connection */ +UA_StatusCode UA_EXPORT +UA_Server_removeReaderGroup(UA_Server *server, UA_NodeId groupIdentifier); + +UA_StatusCode UA_EXPORT +UA_Server_freezeReaderGroupConfiguration(UA_Server *server, const UA_NodeId readerGroupId); + +UA_StatusCode UA_EXPORT +UA_Server_unfreezeReaderGroupConfiguration(UA_Server *server, const UA_NodeId readerGroupId); + +UA_StatusCode UA_EXPORT +UA_Server_setReaderGroupOperational(UA_Server *server, const UA_NodeId readerGroupId); + +UA_StatusCode UA_EXPORT +UA_Server_setReaderGroupDisabled(UA_Server *server, const UA_NodeId readerGroupId); + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION +/* Set the group key for the message encryption */ +UA_StatusCode UA_EXPORT +UA_Server_setReaderGroupEncryptionKeys(UA_Server *server, UA_NodeId readerGroup, + UA_UInt32 securityTokenId, + UA_ByteString signingKey, + UA_ByteString encryptingKey, + UA_ByteString keyNonce); +#endif + + +#endif /* UA_ENABLE_PUBSUB */ + +_UA_END_DECLS + +#endif /* UA_SERVER_PUBSUB_H */ + +/**** amalgamated original file "/include/open62541/server.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2014-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2014-2015, 2017 (c) Florian Palm + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015-2016 (c) Oleksiy Vasylyev + * Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Henrik Norrman + * Copyright 2018 (c) Fabian Arndt, Root-Core + * Copyright 2017-2020 (c) HMS Industrial Networks AB (Author: Jonas Green) + * Copyright 2020-2021 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + */ + + + + +#ifdef UA_ENABLE_PUBSUB +#endif + +#ifdef UA_ENABLE_HISTORIZING +#endif + +_UA_BEGIN_DECLS + +/** + * .. _server: + * + * Server + * ====== + * + * .. _server-configuration: + * + * Server Configuration + * -------------------- + * + * The configuration structure is passed to the server during initialization. + * The server expects that the configuration is not modified during runtime. + * Currently, only one server can use a configuration at a time. During + * shutdown, the server will clean up the parts of the configuration that are + * modified at runtime through the provided API. + * + * Examples for configurations are provided in the ``/plugins`` folder. + * The usual usage is as follows: + * + * 1. Create a server configuration with default settings as a starting point + * 2. Modifiy the configuration, e.g. by adding a server certificate + * 3. Instantiate a server with it + * 4. After shutdown of the server, clean up the configuration (free memory) + * + * The :ref:`tutorials` provide a good starting point for this. */ + +struct UA_PubSubConfiguration; +typedef struct UA_PubSubConfiguration UA_PubSubConfiguration; + +typedef struct { + UA_UInt32 min; + UA_UInt32 max; +} UA_UInt32Range; + +typedef struct { + UA_Duration min; + UA_Duration max; +} UA_DurationRange; + +typedef void (*UA_Server_AsyncOperationNotifyCallback)(UA_Server *server); + +struct UA_ServerConfig { + UA_Logger logger; + + /* Server Description: + * The description must be internally consistent. + * - The ApplicationUri set in the ApplicationDescription must match the + * URI set in the server certificate */ + UA_BuildInfo buildInfo; + UA_ApplicationDescription applicationDescription; + UA_ByteString serverCertificate; + + UA_Double shutdownDelay; /* Delay in ms from the shutdown signal (ctrl-c) + until the actual shutdown. Clients need to be + able to get a notification ahead of time. */ + + /* Rule Handling */ + UA_RuleHandling verifyRequestTimestamp; /* Verify that the server sends a + * timestamp in the request header */ + UA_RuleHandling allowEmptyVariables; /* Variables (that don't have a + * DataType of BaseDataType) must not + * have an empty variant value. The + * default behaviour is to auto-create + * a matching zeroed-out value for + * empty VariableNodes when they are + * added. */ + + /* Custom DataTypes. Attention! Custom datatypes are not cleaned up together + * with the configuration. So it is possible to allocate them on ROM. */ + const UA_DataTypeArray *customDataTypes; + + /** + * .. note:: See the section on :ref:`generic-types`. Examples for working + * with custom data types are provided in + * ``/examples/custom_datatype/``. */ + + /* Networking */ + size_t networkLayersSize; + UA_ServerNetworkLayer *networkLayers; + UA_String customHostname; + + /* PubSub */ +#ifdef UA_ENABLE_PUBSUB + UA_PubSubConfiguration pubSubConfig; +#endif + + /* Available security policies */ + size_t securityPoliciesSize; + UA_SecurityPolicy* securityPolicies; + + /* Available endpoints */ + size_t endpointsSize; + UA_EndpointDescription *endpoints; + + /* Only allow the following discovery services to be executed on a + * SecureChannel with SecurityPolicyNone: GetEndpointsRequest, + * FindServersRequest and FindServersOnNetworkRequest. + * + * Only enable this option if there is no endpoint with SecurityPolicy#None + * in the endpoints list. The SecurityPolicy#None must be present in the + * securityPolicies list. */ + UA_Boolean securityPolicyNoneDiscoveryOnly; + + /* Node Lifecycle callbacks */ + UA_GlobalNodeLifecycle nodeLifecycle; + + /** Copy the HasModellingRule reference in instances from the type + * definition in UA_Server_addObjectNode and UA_Server_addVariableNode. + * Part 3 - 6.4.4 + * https://reference.opcfoundation.org/v104/Core/docs/Part3/6.4.4/#6.4.4.4 + * [...] it is not required that newly created or referenced instances + * based on InstanceDeclarations have a ModellingRule, however, it is + * allowed that they have any ModellingRule independent of the + * ModellingRule of their InstanceDeclaration */ + UA_Boolean modellingRulesOnInstances; + + /** + * .. note:: See the section for :ref:`node lifecycle + * handling`. */ + + /* Access Control */ + UA_AccessControl accessControl; + + /** + * .. note:: See the section for :ref:`access-control + * handling`. */ + + /* Async Operations */ +#if UA_MULTITHREADING >= 100 + UA_Double asyncOperationTimeout; /* in ms, 0 => unlimited */ + size_t maxAsyncOperationQueueSize; /* 0 => unlimited */ + /* Notify workers when an async operation was enqueued */ + UA_Server_AsyncOperationNotifyCallback asyncOperationNotifyCallback; +#endif + + /** + * .. note:: See the section for :ref:`async + * operations`. */ + + /* Nodestore */ + UA_Nodestore nodestore; + + /* Certificate Verification */ + UA_CertificateVerification certificateVerification; + + /* Limits for SecureChannels */ + UA_UInt16 maxSecureChannels; + UA_UInt32 maxSecurityTokenLifetime; /* in ms */ + + /* Limits for Sessions */ + UA_UInt16 maxSessions; + UA_Double maxSessionTimeout; /* in ms */ + + /* Operation limits */ + UA_UInt32 maxNodesPerRead; + UA_UInt32 maxNodesPerWrite; + UA_UInt32 maxNodesPerMethodCall; + UA_UInt32 maxNodesPerBrowse; + UA_UInt32 maxNodesPerRegisterNodes; + UA_UInt32 maxNodesPerTranslateBrowsePathsToNodeIds; + UA_UInt32 maxNodesPerNodeManagement; + UA_UInt32 maxMonitoredItemsPerCall; + + /* Limits for Requests */ + UA_UInt32 maxReferencesPerNode; + + /* Discovery */ +#ifdef UA_ENABLE_DISCOVERY + /* Timeout in seconds when to automatically remove a registered server from + * the list, if it doesn't re-register within the given time frame. A value + * of 0 disables automatic removal. Default is 60 Minutes (60*60). Must be + * bigger than 10 seconds, because cleanup is only triggered approximately + * every 10 seconds. The server will still be removed depending on the + * state of the semaphore file. */ + UA_UInt32 discoveryCleanupTimeout; + +# ifdef UA_ENABLE_DISCOVERY_MULTICAST + UA_Boolean mdnsEnabled; + UA_MdnsDiscoveryConfiguration mdnsConfig; + UA_String mdnsInterfaceIP; +# if !defined(UA_HAS_GETIFADDR) + size_t mdnsIpAddressListSize; + UA_UInt32 *mdnsIpAddressList; +# endif +# endif +#endif + + /* Subscriptions */ +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* Limits for Subscriptions */ + UA_UInt32 maxSubscriptions; + UA_UInt32 maxSubscriptionsPerSession; + UA_DurationRange publishingIntervalLimits; /* in ms (must not be less than 5) */ + UA_UInt32Range lifeTimeCountLimits; + UA_UInt32Range keepAliveCountLimits; + UA_UInt32 maxNotificationsPerPublish; + UA_Boolean enableRetransmissionQueue; + UA_UInt32 maxRetransmissionQueueSize; /* 0 -> unlimited size */ +# ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + UA_UInt32 maxEventsPerNode; /* 0 -> unlimited size */ +# endif + + /* Limits for MonitoredItems */ + UA_UInt32 maxMonitoredItems; + UA_UInt32 maxMonitoredItemsPerSubscription; + UA_DurationRange samplingIntervalLimits; /* in ms (must not be less than 5) */ + UA_UInt32Range queueSizeLimits; /* Negotiated with the client */ + + /* Limits for PublishRequests */ + UA_UInt32 maxPublishReqPerSession; + + /* Register MonitoredItem in Userland + * + * @param server Allows the access to the server object + * @param sessionId The session id, represented as an node id + * @param sessionContext An optional pointer to user-defined data for the specific data source + * @param nodeid Id of the node in question + * @param nodeidContext An optional pointer to user-defined data, associated + * with the node in the nodestore. Note that, if the node has already been removed, + * this value contains a NULL pointer. + * @param attributeId Identifies which attribute (value, data type etc.) is monitored + * @param removed Determines if the MonitoredItem was removed or created. */ + void (*monitoredItemRegisterCallback)(UA_Server *server, + const UA_NodeId *sessionId, void *sessionContext, + const UA_NodeId *nodeId, void *nodeContext, + UA_UInt32 attibuteId, UA_Boolean removed); +#endif + + /* Historical Access */ +#ifdef UA_ENABLE_HISTORIZING + UA_HistoryDatabase historyDatabase; + + UA_Boolean accessHistoryDataCapability; + UA_UInt32 maxReturnDataValues; /* 0 -> unlimited size */ + + UA_Boolean accessHistoryEventsCapability; + UA_UInt32 maxReturnEventValues; /* 0 -> unlimited size */ + + UA_Boolean insertDataCapability; + UA_Boolean insertEventCapability; + UA_Boolean insertAnnotationsCapability; + + UA_Boolean replaceDataCapability; + UA_Boolean replaceEventCapability; + + UA_Boolean updateDataCapability; + UA_Boolean updateEventCapability; + + UA_Boolean deleteRawCapability; + UA_Boolean deleteEventCapability; + UA_Boolean deleteAtTimeDataCapability; +#endif +}; + +void UA_EXPORT +UA_ServerConfig_clean(UA_ServerConfig *config); + +/* Set a custom hostname in server configuration */ +UA_DEPRECATED static UA_INLINE void +UA_ServerConfig_setCustomHostname(UA_ServerConfig *config, + const UA_String customHostname) { + UA_String_clear(&config->customHostname); + UA_String_copy(&customHostname, &config->customHostname); +} + +/** + * .. _server-lifecycle: + * + * Server Lifecycle + * ---------------- */ + +/* The method UA_Server_new is defined in server_config_default.h. So default + * plugins outside of the core library (for logging, etc) are already available + * during the initialization. + * + * UA_Server UA_EXPORT * UA_Server_new(void); + */ + +/* Creates a new server. Moves the config into the server with a shallow copy. + * The config content is cleared together with the server. */ +UA_Server UA_EXPORT * +UA_Server_newWithConfig(UA_ServerConfig *config); + +void UA_EXPORT UA_Server_delete(UA_Server *server); + +UA_ServerConfig UA_EXPORT * +UA_Server_getConfig(UA_Server *server); + +/* Runs the main loop of the server. In each iteration, this calls into the + * networklayers to see if messages have arrived. + * + * @param server The server object. + * @param running The loop is run as long as *running is true. + * Otherwise, the server shuts down. + * @return Returns the statuscode of the UA_Server_run_shutdown method */ +UA_StatusCode UA_EXPORT +UA_Server_run(UA_Server *server, const volatile UA_Boolean *running); + +/* The prologue part of UA_Server_run (no need to use if you call + * UA_Server_run) */ +UA_StatusCode UA_EXPORT +UA_Server_run_startup(UA_Server *server); + +/* Executes a single iteration of the server's main loop. + * + * @param server The server object. + * @param waitInternal Should we wait for messages in the networklayer? + * Otherwise, the timouts for the networklayers are set to zero. + * The default max wait time is 50millisec. + * @return Returns how long we can wait until the next scheduled + * callback (in ms) */ +UA_UInt16 UA_EXPORT +UA_Server_run_iterate(UA_Server *server, UA_Boolean waitInternal); + +/* The epilogue part of UA_Server_run (no need to use if you call + * UA_Server_run) */ +UA_StatusCode UA_EXPORT +UA_Server_run_shutdown(UA_Server *server); + +/** + * Timed Callbacks + * --------------- */ + +/* Add a callback for execution at a specified time. If the indicated time lies + * in the past, then the callback is executed at the next iteration of the + * server's main loop. + * + * @param server The server object. + * @param callback The callback that shall be added. + * @param data Data that is forwarded to the callback. + * @param date The timestamp for the execution time. + * @param callbackId Set to the identifier of the repeated callback . This can + * be used to cancel the callback later on. If the pointer is null, the + * identifier is not set. + * @return Upon success, UA_STATUSCODE_GOOD is returned. An error code + * otherwise. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addTimedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_DateTime date, UA_UInt64 *callbackId); + +/* Add a callback for cyclic repetition to the server. + * + * @param server The server object. + * @param callback The callback that shall be added. + * @param data Data that is forwarded to the callback. + * @param interval_ms The callback shall be repeatedly executed with the given + * interval (in ms). The interval must be positive. The first execution + * occurs at now() + interval at the latest. + * @param callbackId Set to the identifier of the repeated callback . This can + * be used to cancel the callback later on. If the pointer is null, the + * identifier is not set. + * @return Upon success, UA_STATUSCODE_GOOD is returned. An error code + * otherwise. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addRepeatedCallback(UA_Server *server, UA_ServerCallback callback, + void *data, UA_Double interval_ms, UA_UInt64 *callbackId); + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_changeRepeatedCallbackInterval(UA_Server *server, UA_UInt64 callbackId, + UA_Double interval_ms); + +/* Remove a repeated callback. Does nothing if the callback is not found. + * + * @param server The server object. + * @param callbackId The id of the callback */ +void UA_EXPORT UA_THREADSAFE +UA_Server_removeCallback(UA_Server *server, UA_UInt64 callbackId); + +#define UA_Server_removeRepeatedCallback(server, callbackId) \ + UA_Server_removeCallback(server, callbackId); + +/** + * Session Handling + * ---------------- + * A new session is announced via the AccessControl plugin. The session + * identifier is forwarded to the relevant callbacks back into userland. The + * following methods enable an interaction with a particular session. */ + +/* Manually close a session */ +UA_EXPORT UA_StatusCode UA_THREADSAFE +UA_Server_closeSession(UA_Server *server, const UA_NodeId *sessionId); + +/* Session Parameters: Besides the user-definable session context pointer, + * so-called session parameters are a way to attach key-value parameters to a + * session. This enables "plugins" to attach data to a session without impacting + * the user-definedable session context pointer. */ + +UA_EXPORT UA_StatusCode UA_THREADSAFE +UA_Server_setSessionParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, const UA_Variant *parameter); + +UA_EXPORT void UA_THREADSAFE +UA_Server_deleteSessionParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name); + +/* Returns NULL if the session or the parameter are not defined. Returns a deep + * copy otherwise */ +UA_EXPORT UA_StatusCode UA_THREADSAFE +UA_Server_getSessionParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, UA_Variant *outParameter); + +/* Returns NULL if the parameter is not defined or not of the right datatype */ +UA_EXPORT UA_StatusCode UA_THREADSAFE +UA_Server_getSessionScalarParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, const UA_DataType *type, + UA_Variant *outParameter); + +UA_EXPORT UA_StatusCode UA_THREADSAFE +UA_Server_getSessionArrayParameter(UA_Server *server, const UA_NodeId *sessionId, + const char *name, const UA_DataType *type, + UA_Variant *outParameter); + +/** + * Reading and Writing Node Attributes + * ----------------------------------- + * The functions for reading and writing node attributes call the regular read + * and write service in the background that are also used over the network. + * + * The following attributes cannot be read, since the local "admin" user always + * has full rights. + * + * - UserWriteMask + * - UserAccessLevel + * - UserExecutable */ +/* Read an attribute of a node. The specialized functions below provide a more + * concise syntax. + * + * @param server The server object. + * @param item ReadValueIds contain the NodeId of the target node, the id of the + * attribute to read and (optionally) an index range to read parts + * of an array only. See the section on NumericRange for the format + * used for array ranges. + * @param timestamps Which timestamps to return for the attribute. + * @return Returns a DataValue that contains either an error code, or a variant + * with the attribute value and the timestamps. */ +UA_DataValue UA_EXPORT UA_THREADSAFE +UA_Server_read(UA_Server *server, const UA_ReadValueId *item, + UA_TimestampsToReturn timestamps); + +/* Don't use this function. There are typed versions for every supported + * attribute. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +__UA_Server_read(UA_Server *server, const UA_NodeId *nodeId, + UA_AttributeId attributeId, void *v); + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readNodeId(UA_Server *server, const UA_NodeId nodeId, + UA_NodeId *outNodeId) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_NODEID, outNodeId); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readNodeClass(UA_Server *server, const UA_NodeId nodeId, + UA_NodeClass *outNodeClass) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_NODECLASS, + outNodeClass); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readBrowseName(UA_Server *server, const UA_NodeId nodeId, + UA_QualifiedName *outBrowseName) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_BROWSENAME, + outBrowseName); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readDisplayName(UA_Server *server, const UA_NodeId nodeId, + UA_LocalizedText *outDisplayName) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME, + outDisplayName); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readDescription(UA_Server *server, const UA_NodeId nodeId, + UA_LocalizedText *outDescription) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_DESCRIPTION, + outDescription); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readWriteMask(UA_Server *server, const UA_NodeId nodeId, + UA_UInt32 *outWriteMask) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_WRITEMASK, + outWriteMask); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readIsAbstract(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean *outIsAbstract) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_ISABSTRACT, + outIsAbstract); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readSymmetric(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean *outSymmetric) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_SYMMETRIC, + outSymmetric); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readInverseName(UA_Server *server, const UA_NodeId nodeId, + UA_LocalizedText *outInverseName) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_INVERSENAME, + outInverseName); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readContainsNoLoops(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean *outContainsNoLoops) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_CONTAINSNOLOOPS, + outContainsNoLoops); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readEventNotifier(UA_Server *server, const UA_NodeId nodeId, + UA_Byte *outEventNotifier) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_EVENTNOTIFIER, + outEventNotifier); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readValue(UA_Server *server, const UA_NodeId nodeId, + UA_Variant *outValue) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_VALUE, outValue); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readDataType(UA_Server *server, const UA_NodeId nodeId, + UA_NodeId *outDataType) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_DATATYPE, + outDataType); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readValueRank(UA_Server *server, const UA_NodeId nodeId, + UA_Int32 *outValueRank) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_VALUERANK, + outValueRank); +} + +/* Returns a variant with an int32 array */ +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readArrayDimensions(UA_Server *server, const UA_NodeId nodeId, + UA_Variant *outArrayDimensions) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_ARRAYDIMENSIONS, + outArrayDimensions); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readAccessLevel(UA_Server *server, const UA_NodeId nodeId, + UA_Byte *outAccessLevel) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL, + outAccessLevel); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readMinimumSamplingInterval(UA_Server *server, const UA_NodeId nodeId, + UA_Double *outMinimumSamplingInterval) { + return __UA_Server_read(server, &nodeId, + UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL, + outMinimumSamplingInterval); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readHistorizing(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean *outHistorizing) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_HISTORIZING, + outHistorizing); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_readExecutable(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean *outExecutable) { + return __UA_Server_read(server, &nodeId, UA_ATTRIBUTEID_EXECUTABLE, + outExecutable); +} + +/** + * The following node attributes cannot be changed once a node has been created: + * + * - NodeClass + * - NodeId + * - Symmetric + * - ContainsNoLoops + * + * The following attributes cannot be written from the server, as they are + * specific to the different users and set by the access control callback: + * + * - UserWriteMask + * - UserAccessLevel + * - UserExecutable + */ + +/* Overwrite an attribute of a node. The specialized functions below provide a + * more concise syntax. + * + * @param server The server object. + * @param value WriteValues contain the NodeId of the target node, the id of the + * attribute to overwritten, the actual value and (optionally) an + * index range to replace parts of an array only. of an array only. + * See the section on NumericRange for the format used for array + * ranges. + * @return Returns a status code. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_write(UA_Server *server, const UA_WriteValue *value); + +/* Don't use this function. There are typed versions with no additional + * overhead. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +__UA_Server_write(UA_Server *server, const UA_NodeId *nodeId, + const UA_AttributeId attributeId, + const UA_DataType *attr_type, const void *attr); + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeBrowseName(UA_Server *server, const UA_NodeId nodeId, + const UA_QualifiedName browseName) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_BROWSENAME, + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], &browseName); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeDisplayName(UA_Server *server, const UA_NodeId nodeId, + const UA_LocalizedText displayName) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], &displayName); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeDescription(UA_Server *server, const UA_NodeId nodeId, + const UA_LocalizedText description) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_DESCRIPTION, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], &description); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeWriteMask(UA_Server *server, const UA_NodeId nodeId, + const UA_UInt32 writeMask) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_WRITEMASK, + &UA_TYPES[UA_TYPES_UINT32], &writeMask); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeIsAbstract(UA_Server *server, const UA_NodeId nodeId, + const UA_Boolean isAbstract) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_ISABSTRACT, + &UA_TYPES[UA_TYPES_BOOLEAN], &isAbstract); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeInverseName(UA_Server *server, const UA_NodeId nodeId, + const UA_LocalizedText inverseName) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_INVERSENAME, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], &inverseName); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeEventNotifier(UA_Server *server, const UA_NodeId nodeId, + const UA_Byte eventNotifier) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_EVENTNOTIFIER, + &UA_TYPES[UA_TYPES_BYTE], &eventNotifier); +} + +/** + * Writes an UA_Variant to a variable/variableType node. + * StatusCode is set to UA_STATUSCODE_GOOD, sourceTimestamp and + * serverTimestamp are set to UA_DateTime_now() + */ +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeValue(UA_Server *server, const UA_NodeId nodeId, + const UA_Variant value) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_VALUE, + &UA_TYPES[UA_TYPES_VARIANT], &value); +} + +/** + * Writes an UA_DataValue to a variable/variableType node. + * In contrast to UA_Server_writeValue, this functions can also write + * sourceTimestamp, serverTimestamp and statusCode. + */ +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeDataValue(UA_Server *server, const UA_NodeId nodeId, + const UA_DataValue value) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_VALUE, + &UA_TYPES[UA_TYPES_DATAVALUE], &value); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeDataType(UA_Server *server, const UA_NodeId nodeId, + const UA_NodeId dataType) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_DATATYPE, + &UA_TYPES[UA_TYPES_NODEID], &dataType); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeValueRank(UA_Server *server, const UA_NodeId nodeId, + const UA_Int32 valueRank) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_VALUERANK, + &UA_TYPES[UA_TYPES_INT32], &valueRank); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeArrayDimensions(UA_Server *server, const UA_NodeId nodeId, + const UA_Variant arrayDimensions) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_ARRAYDIMENSIONS, + &UA_TYPES[UA_TYPES_VARIANT], &arrayDimensions); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeAccessLevel(UA_Server *server, const UA_NodeId nodeId, + const UA_Byte accessLevel) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL, + &UA_TYPES[UA_TYPES_BYTE], &accessLevel); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeMinimumSamplingInterval(UA_Server *server, const UA_NodeId nodeId, + const UA_Double miniumSamplingInterval) { + return __UA_Server_write(server, &nodeId, + UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL, + &UA_TYPES[UA_TYPES_DOUBLE], + &miniumSamplingInterval); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeHistorizing(UA_Server *server, const UA_NodeId nodeId, + const UA_Boolean historizing) { + return __UA_Server_write(server, &nodeId, + UA_ATTRIBUTEID_HISTORIZING, + &UA_TYPES[UA_TYPES_BOOLEAN], + &historizing); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_writeExecutable(UA_Server *server, const UA_NodeId nodeId, + const UA_Boolean executable) { + return __UA_Server_write(server, &nodeId, UA_ATTRIBUTEID_EXECUTABLE, + &UA_TYPES[UA_TYPES_BOOLEAN], &executable); } + +/** + * Browsing + * -------- */ + +/* Browse the references of a particular node. See the definition of + * BrowseDescription structure for details. */ +UA_BrowseResult UA_EXPORT UA_THREADSAFE +UA_Server_browse(UA_Server *server, UA_UInt32 maxReferences, + const UA_BrowseDescription *bd); + +UA_BrowseResult UA_EXPORT UA_THREADSAFE +UA_Server_browseNext(UA_Server *server, UA_Boolean releaseContinuationPoint, + const UA_ByteString *continuationPoint); + +/* Non-standard version of the Browse service that recurses into child nodes. + * + * Possible loops (that can occur for non-hierarchical references) are handled + * internally. Every node is added at most once to the results array. + * + * Nodes are only added if they match the NodeClassMask in the + * BrowseDescription. However, child nodes are still recursed into if the + * NodeClass does not match. So it is possible, for example, to get all + * VariableNodes below a certain ObjectNode, with additional objects in the + * hierarchy below. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_browseRecursive(UA_Server *server, const UA_BrowseDescription *bd, + size_t *resultsSize, UA_ExpandedNodeId **results); + +UA_BrowsePathResult UA_EXPORT UA_THREADSAFE +UA_Server_translateBrowsePathToNodeIds(UA_Server *server, + const UA_BrowsePath *browsePath); + +/* A simplified TranslateBrowsePathsToNodeIds based on the + * SimpleAttributeOperand type (Part 4, 7.4.4.5). + * + * This specifies a relative path using a list of BrowseNames instead of the + * RelativePath structure. The list of BrowseNames is equivalent to a + * RelativePath that specifies forward references which are subtypes of the + * HierarchicalReferences ReferenceType. All Nodes followed by the browsePath + * shall be of the NodeClass Object or Variable. */ +UA_BrowsePathResult UA_EXPORT UA_THREADSAFE +UA_Server_browseSimplifiedBrowsePath(UA_Server *server, const UA_NodeId origin, + size_t browsePathSize, + const UA_QualifiedName *browsePath); + +#ifndef HAVE_NODEITER_CALLBACK +#define HAVE_NODEITER_CALLBACK +/* Iterate over all nodes referenced by parentNodeId by calling the callback + * function for each child node (in ifdef because GCC/CLANG handle include order + * differently) */ +typedef UA_StatusCode +(*UA_NodeIteratorCallback)(UA_NodeId childId, UA_Boolean isInverse, + UA_NodeId referenceTypeId, void *handle); +#endif + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_forEachChildNodeCall(UA_Server *server, UA_NodeId parentNodeId, + UA_NodeIteratorCallback callback, void *handle); + +#ifdef UA_ENABLE_DISCOVERY + +/** + * Discovery + * --------- */ +/* Register the given server instance at the discovery server. + * This should be called periodically. + * The semaphoreFilePath is optional. If the given file is deleted, + * the server will automatically be unregistered. This could be + * for example a pid file which is deleted if the server crashes. + * + * When the server shuts down you need to call unregister. + * + * @param server + * @param client the client which is used to call the RegisterServer. It must + * already be connected to the correct endpoint + * @param semaphoreFilePath optional parameter pointing to semaphore file. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_register_discovery(UA_Server *server, struct UA_Client *client, + const char* semaphoreFilePath); + +/* Unregister the given server instance from the discovery server. + * This should only be called when the server is shutting down. + * @param server + * @param client the client which is used to call the RegisterServer. It must + * already be connected to the correct endpoint */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_unregister_discovery(UA_Server *server, struct UA_Client *client); + + /* Adds a periodic callback to register the server with the LDS (local + * discovery server) periodically. The interval between each register call is + * given as second parameter. It should be 10 minutes by default (= + * 10*60*1000). + * + * The delayFirstRegisterMs parameter indicates the delay for the first + * register call. If it is 0, the first register call will be after intervalMs + * milliseconds, otherwise the server's first register will be after + * delayFirstRegisterMs. + * + * When you manually unregister the server, you also need to cancel the + * periodic callback, otherwise it will be automatically be registered again. + * + * If you call this method multiple times for the same discoveryServerUrl, the + * older periodic callback will be removed. + * + * @param server + * @param client the client which is used to call the RegisterServer. It must + * not yet be connected and will be connected for every register call + * to the given discoveryServerUrl. + * @param discoveryServerUrl where this server should register itself. The + * string will be copied internally. Therefore you can free it after + * calling this method. + * @param intervalMs + * @param delayFirstRegisterMs + * @param periodicCallbackId */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addPeriodicServerRegisterCallback(UA_Server *server, struct UA_Client *client, + const char* discoveryServerUrl, + UA_Double intervalMs, + UA_Double delayFirstRegisterMs, + UA_UInt64 *periodicCallbackId); + +/* Callback for RegisterServer. Data is passed from the register call */ +typedef void (*UA_Server_registerServerCallback)(const UA_RegisteredServer *registeredServer, + void* data); + +/* Set the callback which is called if another server registeres or unregisters + * with this instance. This callback is called every time the server gets a register + * call. This especially means that for every periodic server register the callback will + * be called. + * + * @param server + * @param cb the callback + * @param data data passed to the callback + * @return UA_STATUSCODE_SUCCESS on success */ +void UA_EXPORT UA_THREADSAFE +UA_Server_setRegisterServerCallback(UA_Server *server, UA_Server_registerServerCallback cb, + void* data); + +#ifdef UA_ENABLE_DISCOVERY_MULTICAST + +/* Callback for server detected through mDNS. Data is passed from the register + * call + * + * @param isServerAnnounce indicates if the server has just been detected. If + * set to false, this means the server is shutting down. + * @param isTxtReceived indicates if we already received the corresponding TXT + * record with the path and caps data */ +typedef void (*UA_Server_serverOnNetworkCallback)(const UA_ServerOnNetwork *serverOnNetwork, + UA_Boolean isServerAnnounce, + UA_Boolean isTxtReceived, void* data); + +/* Set the callback which is called if another server is found through mDNS or + * deleted. It will be called for any mDNS message from the remote server, thus + * it may be called multiple times for the same instance. Also the SRV and TXT + * records may arrive later, therefore for the first call the server + * capabilities may not be set yet. If called multiple times, previous data will + * be overwritten. + * + * @param server + * @param cb the callback + * @param data data passed to the callback + * @return UA_STATUSCODE_SUCCESS on success */ +void UA_EXPORT UA_THREADSAFE +UA_Server_setServerOnNetworkCallback(UA_Server *server, + UA_Server_serverOnNetworkCallback cb, + void* data); + +#endif /* UA_ENABLE_DISCOVERY_MULTICAST */ + +#endif /* UA_ENABLE_DISCOVERY */ + +/** + * Information Model Callbacks + * --------------------------- + * + * There are three places where a callback from an information model to + * user-defined code can happen. + * + * - Custom node constructors and destructors + * - Linking VariableNodes with an external data source + * - MethodNode callbacks + */ + +void UA_EXPORT +UA_Server_setAdminSessionContext(UA_Server *server, + void *context); + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_setNodeTypeLifecycle(UA_Server *server, UA_NodeId nodeId, + UA_NodeTypeLifecycle lifecycle); + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_getNodeContext(UA_Server *server, UA_NodeId nodeId, + void **nodeContext); + +/* Careful! The user has to ensure that the destructor callbacks still work. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_setNodeContext(UA_Server *server, UA_NodeId nodeId, + void *nodeContext); + +/** + * .. _datasource: + * + * Data Source Callback + * ^^^^^^^^^^^^^^^^^^^^ + * + * The server has a unique way of dealing with the content of variables. Instead + * of storing a variant attached to the variable node, the node can point to a + * function with a local data provider. Whenever the value attribute is read, + * the function will be called and asked to provide a UA_DataValue return value + * that contains the value content and additional timestamps. + * + * It is expected that the read callback is implemented. The write callback can + * be set to a null-pointer. */ + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_setVariableNode_dataSource(UA_Server *server, const UA_NodeId nodeId, + const UA_DataSource dataSource); + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_setVariableNode_valueCallback(UA_Server *server, + const UA_NodeId nodeId, + const UA_ValueCallback callback); + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_setVariableNode_valueBackend(UA_Server *server, + const UA_NodeId nodeId, + const UA_ValueBackend valueBackend); + +/** + * .. _local-monitoreditems: + * + * Local MonitoredItems + * ^^^^^^^^^^^^^^^^^^^^ + * + * MonitoredItems are used with the Subscription mechanism of OPC UA to + * transported notifications for data changes and events. MonitoredItems can + * also be registered locally. Notifications are then forwarded to a + * user-defined callback instead of a remote client. */ + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +typedef void (*UA_Server_DataChangeNotificationCallback) + (UA_Server *server, UA_UInt32 monitoredItemId, void *monitoredItemContext, + const UA_NodeId *nodeId, void *nodeContext, UA_UInt32 attributeId, + const UA_DataValue *value); + +typedef void (*UA_Server_EventNotificationCallback) + (UA_Server *server, UA_UInt32 monId, void *monContext, + size_t nEventFields, const UA_Variant *eventFields); + +/* Create a local MonitoredItem with a sampling interval that detects data + * changes. + * + * @param server The server executing the MonitoredItem + * @timestampsToReturn Shall timestamps be added to the value for the callback? + * @item The parameters of the new MonitoredItem. Note that the attribute of the + * ReadValueId (the node that is monitored) can not be + * ``UA_ATTRIBUTEID_EVENTNOTIFIER``. A different callback type needs to be + * registered for event notifications. + * @monitoredItemContext A pointer that is forwarded with the callback + * @callback The callback that is executed on detected data changes + * + * @return Returns a description of the created MonitoredItem. The structure + * also contains a StatusCode (in case of an error) and the identifier of the + * new MonitoredItem. */ +UA_MonitoredItemCreateResult UA_EXPORT UA_THREADSAFE +UA_Server_createDataChangeMonitoredItem(UA_Server *server, + UA_TimestampsToReturn timestampsToReturn, + const UA_MonitoredItemCreateRequest item, + void *monitoredItemContext, + UA_Server_DataChangeNotificationCallback callback); + +/* UA_MonitoredItemCreateResult UA_EXPORT */ +/* UA_Server_createEventMonitoredItem(UA_Server *server, */ +/* UA_TimestampsToReturn timestampsToReturn, */ +/* const UA_MonitoredItemCreateRequest item, void *context, */ +/* UA_Server_EventNotificationCallback callback); */ + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_deleteMonitoredItem(UA_Server *server, UA_UInt32 monitoredItemId); + +#endif + +/** + * Method Callbacks + * ^^^^^^^^^^^^^^^^ + * Method callbacks are set to `NULL` (not executable) when a method node is + * added over the network. In theory, it is possible to add a callback via + * ``UA_Server_setMethodNode_callback`` within the global constructor when + * adding methods over the network is really wanted. See the Section + * :ref:`object-interaction` for calling methods on an object. */ + +#ifdef UA_ENABLE_METHODCALLS +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_setMethodNodeCallback(UA_Server *server, + const UA_NodeId methodNodeId, + UA_MethodCallback methodCallback); + +/* Backwards compatibility definition */ +#define UA_Server_setMethodNode_callback(server, methodNodeId, methodCallback) \ + UA_Server_setMethodNodeCallback(server, methodNodeId, methodCallback) + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_getMethodNodeCallback(UA_Server *server, + const UA_NodeId methodNodeId, + UA_MethodCallback *outMethodCallback); + +UA_CallMethodResult UA_EXPORT UA_THREADSAFE +UA_Server_call(UA_Server *server, const UA_CallMethodRequest *request); +#endif + +/** + * .. _object-interaction: + * + * Interacting with Objects + * ------------------------ + * Objects in the information model are represented as ObjectNodes. Some + * convenience functions are provided to simplify the interaction with objects. + */ + +/* Write an object property. The property is represented as a VariableNode with + * a ``HasProperty`` reference from the ObjectNode. The VariableNode is + * identified by its BrowseName. Writing the property sets the value attribute + * of the VariableNode. + * + * @param server The server object + * @param objectId The identifier of the object (node) + * @param propertyName The name of the property + * @param value The value to be set for the event attribute + * @return The StatusCode for setting the event attribute */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_writeObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + const UA_Variant value); + +/* Directly point to the scalar value instead of a variant */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_writeObjectProperty_scalar(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + const void *value, const UA_DataType *type); + +/* Read an object property. + * + * @param server The server object + * @param objectId The identifier of the object (node) + * @param propertyName The name of the property + * @param value Contains the property value after reading. Must not be NULL. + * @return The StatusCode for setting the event attribute */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_readObjectProperty(UA_Server *server, const UA_NodeId objectId, + const UA_QualifiedName propertyName, + UA_Variant *value); + +/** + * .. _addnodes: + * + * Node Addition and Deletion + * -------------------------- + * When creating dynamic node instances at runtime, chances are that you will + * not care about the specific NodeId of the new node, as long as you can + * reference it later. When passing numeric NodeIds with a numeric identifier 0, + * the stack evaluates this as "select a random unassigned numeric NodeId in + * that namespace". To find out which NodeId was actually assigned to the new + * node, you may pass a pointer `outNewNodeId`, which will (after a successful + * node insertion) contain the nodeId of the new node. You may also pass a + * ``NULL`` pointer if this result is not needed. + * + * See the Section :ref:`node-lifecycle` on constructors and on attaching + * user-defined data to nodes. + * + * The methods for node addition and deletion take mostly const arguments that + * are not modified. When creating a node, a deep copy of the node identifier, + * node attributes, etc. is created. Therefore, it is possible to call for + * example ``UA_Server_addVariablenode`` with a value attribute (a + * :ref:`variant`) pointing to a memory location on the stack. If you need + * changes to a variable value to manifest at a specific memory location, please + * use a :ref:`datasource` or a :ref:`value-callback`. */ + +/* Protect against redundant definitions for server/client */ +#ifndef UA_DEFAULT_ATTRIBUTES_DEFINED +#define UA_DEFAULT_ATTRIBUTES_DEFINED +/* The default for variables is "BaseDataType" for the datatype, -2 for the + * valuerank and a read-accesslevel. */ +UA_EXPORT extern const UA_VariableAttributes UA_VariableAttributes_default; +UA_EXPORT extern const UA_VariableTypeAttributes UA_VariableTypeAttributes_default; +/* Methods are executable by default */ +UA_EXPORT extern const UA_MethodAttributes UA_MethodAttributes_default; +/* The remaining attribute definitions are currently all zeroed out */ +UA_EXPORT extern const UA_ObjectAttributes UA_ObjectAttributes_default; +UA_EXPORT extern const UA_ObjectTypeAttributes UA_ObjectTypeAttributes_default; +UA_EXPORT extern const UA_ReferenceTypeAttributes UA_ReferenceTypeAttributes_default; +UA_EXPORT extern const UA_DataTypeAttributes UA_DataTypeAttributes_default; +UA_EXPORT extern const UA_ViewAttributes UA_ViewAttributes_default; +#endif + +/* Don't use this function. There are typed versions as inline functions. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +__UA_Server_addNode(UA_Server *server, const UA_NodeClass nodeClass, + const UA_NodeId *requestedNewNodeId, + const UA_NodeId *parentNodeId, + const UA_NodeId *referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId *typeDefinition, + const UA_NodeAttributes *attr, + const UA_DataType *attributeType, + void *nodeContext, UA_NodeId *outNewNodeId); + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addVariableNode(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_VariableAttributes attr, + void *nodeContext, UA_NodeId *outNewNodeId) { + return __UA_Server_addNode(server, UA_NODECLASS_VARIABLE, &requestedNewNodeId, + &parentNodeId, &referenceTypeId, browseName, + &typeDefinition, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES], + nodeContext, outNewNodeId); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addVariableTypeNode(UA_Server *server, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_VariableTypeAttributes attr, + void *nodeContext, UA_NodeId *outNewNodeId) { + return __UA_Server_addNode(server, UA_NODECLASS_VARIABLETYPE, + &requestedNewNodeId, &parentNodeId, &referenceTypeId, + browseName, &typeDefinition, + (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES], + nodeContext, outNewNodeId); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addObjectNode(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_ObjectAttributes attr, + void *nodeContext, UA_NodeId *outNewNodeId) { + return __UA_Server_addNode(server, UA_NODECLASS_OBJECT, &requestedNewNodeId, + &parentNodeId, &referenceTypeId, browseName, + &typeDefinition, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES], + nodeContext, outNewNodeId); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addObjectTypeNode(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_ObjectTypeAttributes attr, + void *nodeContext, UA_NodeId *outNewNodeId) { + return __UA_Server_addNode(server, UA_NODECLASS_OBJECTTYPE, &requestedNewNodeId, + &parentNodeId, &referenceTypeId, browseName, + &UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES], + nodeContext, outNewNodeId); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addViewNode(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_ViewAttributes attr, + void *nodeContext, UA_NodeId *outNewNodeId) { + return __UA_Server_addNode(server, UA_NODECLASS_VIEW, &requestedNewNodeId, + &parentNodeId, &referenceTypeId, browseName, + &UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VIEWATTRIBUTES], + nodeContext, outNewNodeId); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addReferenceTypeNode(UA_Server *server, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_ReferenceTypeAttributes attr, + void *nodeContext, UA_NodeId *outNewNodeId) { + return __UA_Server_addNode(server, UA_NODECLASS_REFERENCETYPE, + &requestedNewNodeId, &parentNodeId, &referenceTypeId, + browseName, &UA_NODEID_NULL, + (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES], + nodeContext, outNewNodeId); +} + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addDataTypeNode(UA_Server *server, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_DataTypeAttributes attr, + void *nodeContext, UA_NodeId *outNewNodeId) { + return __UA_Server_addNode(server, UA_NODECLASS_DATATYPE, &requestedNewNodeId, + &parentNodeId, &referenceTypeId, browseName, + &UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES], + nodeContext, outNewNodeId); +} + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addDataSourceVariableNode(UA_Server *server, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_VariableAttributes attr, + const UA_DataSource dataSource, + void *nodeContext, UA_NodeId *outNewNodeId); + +#ifdef UA_ENABLE_METHODCALLS + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addMethodNodeEx(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_MethodAttributes attr, UA_MethodCallback method, + size_t inputArgumentsSize, const UA_Argument *inputArguments, + const UA_NodeId inputArgumentsRequestedNewNodeId, + UA_NodeId *inputArgumentsOutNewNodeId, + size_t outputArgumentsSize, const UA_Argument *outputArguments, + const UA_NodeId outputArgumentsRequestedNewNodeId, + UA_NodeId *outputArgumentsOutNewNodeId, + void *nodeContext, UA_NodeId *outNewNodeId); + +static UA_INLINE UA_THREADSAFE UA_StatusCode +UA_Server_addMethodNode(UA_Server *server, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, const UA_MethodAttributes attr, + UA_MethodCallback method, + size_t inputArgumentsSize, const UA_Argument *inputArguments, + size_t outputArgumentsSize, const UA_Argument *outputArguments, + void *nodeContext, UA_NodeId *outNewNodeId) { + return UA_Server_addMethodNodeEx(server, requestedNewNodeId, parentNodeId, + referenceTypeId, browseName, attr, method, + inputArgumentsSize, inputArguments, UA_NODEID_NULL, NULL, + outputArgumentsSize, outputArguments, UA_NODEID_NULL, NULL, + nodeContext, outNewNodeId); +} + +#endif + + +/** + * The method pair UA_Server_addNode_begin and _finish splits the AddNodes + * service in two parts. This is useful if the node shall be modified before + * finish the instantiation. For example to add children with specific NodeIds. + * Otherwise, mandatory children (e.g. of an ObjectType) are added with + * pseudo-random unique NodeIds. Existing children are detected during the + * _finish part via their matching BrowseName. + * + * The _begin method: + * - prepares the node and adds it to the nodestore + * - copies some unassigned attributes from the TypeDefinition node internally + * - adds the references to the parent (and the TypeDefinition if applicable) + * - performs type-checking of variables. + * + * You can add an object node without a parent if you set the parentNodeId and + * referenceTypeId to UA_NODE_ID_NULL. Then you need to add the parent reference + * and hasTypeDef reference yourself before calling the _finish method. + * Not that this is only allowed for object nodes. + * + * The _finish method: + * - copies mandatory children + * - calls the node constructor(s) at the end + * - may remove the node if it encounters an error. + * + * The special UA_Server_addMethodNode_finish method needs to be used for method + * nodes, since there you need to explicitly specifiy the input and output + * arguments which are added in the finish step (if not yet already there) */ + +/* The ``attr`` argument must have a type according to the NodeClass. + * ``VariableAttributes`` for variables, ``ObjectAttributes`` for objects, and + * so on. Missing attributes are taken from the TypeDefinition node if + * applicable. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addNode_begin(UA_Server *server, const UA_NodeClass nodeClass, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const void *attr, const UA_DataType *attributeType, + void *nodeContext, UA_NodeId *outNewNodeId); + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addNode_finish(UA_Server *server, const UA_NodeId nodeId); + +#ifdef UA_ENABLE_METHODCALLS + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addMethodNode_finish(UA_Server *server, const UA_NodeId nodeId, + UA_MethodCallback method, + size_t inputArgumentsSize, const UA_Argument* inputArguments, + size_t outputArgumentsSize, const UA_Argument* outputArguments); + +#endif + +/* Deletes a node and optionally all references leading to the node. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_deleteNode(UA_Server *server, const UA_NodeId nodeId, + UA_Boolean deleteReferences); + +/** + * Reference Management + * -------------------- */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_addReference(UA_Server *server, const UA_NodeId sourceId, + const UA_NodeId refTypeId, + const UA_ExpandedNodeId targetId, UA_Boolean isForward); + +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_deleteReference(UA_Server *server, const UA_NodeId sourceNodeId, + const UA_NodeId referenceTypeId, UA_Boolean isForward, + const UA_ExpandedNodeId targetNodeId, + UA_Boolean deleteBidirectional); + +/** + * .. _events: + * + * Events + * ------ + * The method ``UA_Server_createEvent`` creates an event and represents it as + * node. The node receives a unique `EventId` which is automatically added to + * the node. The method returns a `NodeId` to the object node which represents + * the event through ``outNodeId``. The `NodeId` can be used to set the + * attributes of the event. The generated `NodeId` is always numeric. + * ``outNodeId`` cannot be ``NULL``. + * + * Note: In order to see an event in UAExpert, the field `Time` must be given a value! + * + * The method ``UA_Server_triggerEvent`` "triggers" an event by adding it to all + * monitored items of the specified origin node and those of all its parents. + * Any filters specified by the monitored items are automatically applied. Using + * this method deletes the node generated by ``UA_Server_createEvent``. The + * `EventId` for the new event is generated automatically and is returned + * through ``outEventId``. ``NULL`` can be passed if the `EventId` is not + * needed. ``deleteEventNode`` specifies whether the node representation of the + * event should be deleted after invoking the method. This can be useful if + * events with the similar attributes are triggered frequently. ``UA_TRUE`` + * would cause the node to be deleted. */ + +#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS + +/* Creates a node representation of an event + * + * @param server The server object + * @param eventType The type of the event for which a node should be created + * @param outNodeId The NodeId of the newly created node for the event + * @return The StatusCode of the UA_Server_createEvent method */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_createEvent(UA_Server *server, const UA_NodeId eventType, + UA_NodeId *outNodeId); + +/* Triggers a node representation of an event by applying EventFilters and + * adding the event to the appropriate queues. + * + * @param server The server object + * @param eventNodeId The NodeId of the node representation of the event which should be triggered + * @param outEvent the EventId of the new event + * @param deleteEventNode Specifies whether the node representation of the event should be deleted + * @return The StatusCode of the UA_Server_triggerEvent method */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_triggerEvent(UA_Server *server, const UA_NodeId eventNodeId, const UA_NodeId originId, + UA_ByteString *outEventId, const UA_Boolean deleteEventNode); + +#endif /* UA_ENABLE_SUBSCRIPTIONS_EVENTS */ + +#ifdef UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS +typedef enum UA_TwoStateVariableCallbackType { + UA_ENTERING_ENABLEDSTATE, + UA_ENTERING_ACKEDSTATE, + UA_ENTERING_CONFIRMEDSTATE, + UA_ENTERING_ACTIVESTATE +} UA_TwoStateVariableCallbackType; + +/* Callback prototype to set user specific callbacks */ +typedef UA_StatusCode +(*UA_TwoStateVariableChangeCallback)(UA_Server *server, const UA_NodeId *condition); + +/* Create condition instance. The function checks first whether the passed + * conditionType is a subType of ConditionType. Then checks whether the + * condition source has HasEventSource reference to its parent. If not, a + * HasEventSource reference will be created between condition source and server + * object. To expose the condition in address space, a hierarchical + * ReferenceType should be passed to create the reference to condition source. + * Otherwise, UA_NODEID_NULL should be passed to make the condition not exposed. + * + * @param server The server object + * @param conditionId The NodeId of the requested Condition Object. When passing + * UA_NODEID_NUMERIC(X,0) an unused nodeid in namespace X + * will be used. E.g. passing UA_NODEID_NULL will result in a + * NodeId in namespace 0. + * @param conditionType The NodeId of the node representation of the ConditionType + * @param conditionName The name of the condition to be created + * @param conditionSource The NodeId of the Condition Source (Parent of the Condition) + * @param hierarchialReferenceType The NodeId of Hierarchical ReferenceType + * between Condition and its source + * @param outConditionId The NodeId of the created Condition + * @return The StatusCode of the UA_Server_createCondition method */ +UA_StatusCode UA_EXPORT +UA_Server_createCondition(UA_Server *server, + const UA_NodeId conditionId, const UA_NodeId conditionType, + UA_QualifiedName conditionName, const UA_NodeId conditionSource, + const UA_NodeId hierarchialReferenceType, UA_NodeId *outConditionId); + +/* Set the value of condition field. + * + * @param server The server object + * @param condition The NodeId of the node representation of the Condition Instance + * @param value Variant Value to be written to the Field + * @param fieldName Name of the Field in which the value should be written + * @return The StatusCode of the UA_Server_setConditionField method*/ +UA_StatusCode UA_EXPORT +UA_Server_setConditionField(UA_Server *server, + const UA_NodeId condition, + const UA_Variant* value, + const UA_QualifiedName fieldName); + +/* Set the value of property of condition field. + * + * @param server The server object + * @param condition The NodeId of the node representation of the Condition Instance + * @param value Variant Value to be written to the Field + * @param variableFieldName Name of the Field which has a property + * @param variablePropertyName Name of the Field Property in which the value should be written + * @return The StatusCode of the UA_Server_setConditionVariableFieldProperty*/ +UA_StatusCode UA_EXPORT +UA_Server_setConditionVariableFieldProperty(UA_Server *server, + const UA_NodeId condition, + const UA_Variant* value, + const UA_QualifiedName variableFieldName, + const UA_QualifiedName variablePropertyName); + +/* Triggers an event only for an enabled condition. The condition list is + * updated then with the last generated EventId. + * + * @param server The server object + * @param condition The NodeId of the node representation of the Condition Instance + * @param conditionSource The NodeId of the node representation of the Condition Source + * @param outEventId last generated EventId + * @return The StatusCode of the UA_Server_triggerConditionEvent method*/ +UA_StatusCode UA_EXPORT +UA_Server_triggerConditionEvent(UA_Server *server, const UA_NodeId condition, + const UA_NodeId conditionSource, + UA_ByteString *outEventId); + +/* Add an optional condition field using its name. (TODO Adding optional methods + * is not implemented yet) + * + * @param server The server object + * @param condition The NodeId of the node representation of the Condition Instance + * @param conditionType The NodeId of the node representation of the Condition Type + * from which the optional field comes + * @param fieldName Name of the optional field + * @param outOptionalVariable The NodeId of the created field (Variable Node) + * @return The StatusCode of the UA_Server_addConditionOptionalField method*/ +UA_StatusCode UA_EXPORT +UA_Server_addConditionOptionalField(UA_Server *server, const UA_NodeId condition, + const UA_NodeId conditionType, + const UA_QualifiedName fieldName, + UA_NodeId *outOptionalVariable); + +/* Function used to set a user specific callback to TwoStateVariable Fields of a + * condition. The callbacks will be called before triggering the events when + * transition to true State of EnabledState/Id, AckedState/Id, ConfirmedState/Id + * and ActiveState/Id occurs. + * + * @param server The server object + * @param condition The NodeId of the node representation of the Condition Instance + * @param conditionSource The NodeId of the node representation of the Condition Source + * @param removeBranch (Not Implemented yet) + * @param callback User specific callback function + * @param callbackType Callback function type, indicates where it should be called + * @return The StatusCode of the UA_Server_setConditionTwoStateVariableCallback method*/ +UA_StatusCode UA_EXPORT +UA_Server_setConditionTwoStateVariableCallback(UA_Server *server, const UA_NodeId condition, + const UA_NodeId conditionSource, + UA_Boolean removeBranch, + UA_TwoStateVariableChangeCallback callback, + UA_TwoStateVariableCallbackType callbackType); + +/* Delete a condition from the address space and the internal lists. + * + * @param server The server object + * @param condition The NodeId of the node representation of the Condition Instance + * @param conditionSource The NodeId of the node representation of the Condition Source + * @return UA_STATUSCODE_GOOD on success + */ +UA_StatusCode UA_EXPORT +UA_Server_deleteCondition(UA_Server *server, const UA_NodeId condition, + const UA_NodeId conditionSource); + +#endif /* UA_ENABLE_SUBSCRIPTIONS_ALARMS_CONDITIONS */ + +UA_StatusCode UA_EXPORT +UA_Server_updateCertificate(UA_Server *server, + const UA_ByteString *oldCertificate, + const UA_ByteString *newCertificate, + const UA_ByteString *newPrivateKey, + UA_Boolean closeSessions, + UA_Boolean closeSecureChannels); + +/** + * Utility Functions + * ----------------- */ + +/* Lookup a datatype by its NodeId. Takes the custom types in the server + * configuration into account. Return NULL if none found. */ +UA_EXPORT const UA_DataType * +UA_Server_findDataType(UA_Server *server, const UA_NodeId *typeId); + +/* Add a new namespace to the server. Returns the index of the new namespace */ +UA_UInt16 UA_EXPORT UA_THREADSAFE +UA_Server_addNamespace(UA_Server *server, const char* name); + +/* Get namespace by name from the server. */ +UA_StatusCode UA_EXPORT UA_THREADSAFE +UA_Server_getNamespaceByName(UA_Server *server, const UA_String namespaceUri, + size_t* foundIndex); + +/** +* .. _async-operations: +* +* Async Operations +* ---------------- +* Some operations (such as reading out a sensor that needs to warm up) can take +* quite some time. In order not to block the server during such an operation, it +* can be "outsourced" to a worker thread. +* +* Take the example of a CallRequest. It is split into the individual method call +* operations. If the method is marked as async, then the operation is put into a +* queue where it is be retrieved by a worker. The worker returns the result when +* ready. See the examples in ``/examples/tutorial_server_method_async.c`` for +* the usage. +* +* Note that the operation can time out (see the asyncOperationTimeout setting in +* the server config) also when it has been retrieved by the worker. */ + +#if UA_MULTITHREADING >= 100 + +/* Set the async flag in a method node */ +UA_StatusCode UA_EXPORT +UA_Server_setMethodNodeAsync(UA_Server *server, const UA_NodeId id, + UA_Boolean isAsync); + +typedef enum { + UA_ASYNCOPERATIONTYPE_INVALID, /* 0, the default */ + UA_ASYNCOPERATIONTYPE_CALL + /* UA_ASYNCOPERATIONTYPE_READ, */ + /* UA_ASYNCOPERATIONTYPE_WRITE, */ +} UA_AsyncOperationType; + +typedef union { + UA_CallMethodRequest callMethodRequest; + /* UA_ReadValueId readValueId; */ + /* UA_WriteValue writeValue; */ +} UA_AsyncOperationRequest; + +typedef union { + UA_CallMethodResult callMethodResult; + /* UA_DataValue readResult; */ + /* UA_StatusCode writeResult; */ +} UA_AsyncOperationResponse; + +/* Get the next async operation without blocking + * + * @param server The server object + * @param type The type of the async operation + * @param request Receives pointer to the operation + * @param context Receives the pointer to the operation context + * @param timeout The timestamp when the operation times out and can + * no longer be returned to the client. The response has to + * be set in UA_Server_setAsyncOperationResult in any case. + * @return false if queue is empty, true else */ +UA_Boolean UA_EXPORT +UA_Server_getAsyncOperationNonBlocking(UA_Server *server, UA_AsyncOperationType *type, + const UA_AsyncOperationRequest **request, + void **context, UA_DateTime *timeout); + +/* UA_Boolean UA_EXPORT */ +/* UA_Server_getAsyncOperationBlocking(UA_Server *server, UA_AsyncOperationType *type, */ +/* const UA_AsyncOperationRequest **request, */ +/* void **context, UA_DateTime *timeout); */ + +/* Submit an async operation result + * + * @param server The server object + * @param response Pointer to the operation result + * @param context Pointer to the operation context */ +void UA_EXPORT +UA_Server_setAsyncOperationResult(UA_Server *server, + const UA_AsyncOperationResponse *response, + void *context); + +/* Get the next async operation. Attention! This method is deprecated and has + * been replaced by UA_Server_getAsyncOperationNonBlocking! */ +UA_DEPRECATED UA_Boolean UA_EXPORT +UA_Server_getAsyncOperation(UA_Server *server, UA_AsyncOperationType *type, + const UA_AsyncOperationRequest **request, + void **context); + +#endif /* !UA_MULTITHREADING >= 100 */ + +/** +* Statistics +* ---------- +* +* Statistic counters keeping track of the current state of the stack. Counters +* are structured per OPC UA communication layer. */ + +typedef struct { + UA_NetworkStatistics ns; + UA_SecureChannelStatistics scs; + UA_SessionStatistics ss; +} UA_ServerStatistics; + +UA_ServerStatistics UA_EXPORT +UA_Server_getStatistics(UA_Server *server); + +_UA_END_DECLS + +#ifdef UA_ENABLE_PUBSUB +#endif + + +/**** amalgamated original file "/include/open62541/client.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015-2016 (c) Sten Grüner + * Copyright 2015-2016 (c) Chris Iatrou + * Copyright 2015-2017 (c) Florian Palm + * Copyright 2015 (c) Holger Jeromin + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2018 (c) Kalycito Infotech Private Limited + * Copyright 2020 (c) Christian von Arnim, ISW University of Stuttgart + */ + + + + +_UA_BEGIN_DECLS + +/** + * .. _client: + * + * Client + * ====== + * + * The client implementation allows remote access to all OPC UA services. For + * convenience, some functionality has been wrapped in :ref:`high-level + * abstractions `. + * + * **However**: At this time, the client does not yet contain its own thread or + * event-driven main-loop, meaning that the client will not perform any actions + * automatically in the background. This is especially relevant for + * connection/session management and subscriptions. The user will have to + * periodically call `UA_Client_run_iterate` to ensure that asynchronous events + * are handled, including keeping a secure connection established. + * See more about :ref:`asynchronicity` and + * :ref:`subscriptions`. + * + * .. _client-config: + * + * Client Configuration + * -------------------- + * + * The client configuration is used for setting connection parameters and + * additional settings used by the client. + * The configuration should not be modified after it is passed to a client. + * Currently, only one client can use a configuration at a time. + * + * Examples for configurations are provided in the ``/plugins`` folder. + * The usual usage is as follows: + * + * 1. Create a client configuration with default settings as a starting point + * 2. Modifiy the configuration, e.g. modifying the timeout + * 3. Instantiate a client with it + * 4. After shutdown of the client, clean up the configuration (free memory) + * + * The :ref:`tutorials` provide a good starting point for this. */ + +typedef struct { + /* Basic client configuration */ + void *clientContext; /* User-defined data attached to the client */ + UA_Logger logger; /* Logger used by the client */ + UA_UInt32 timeout; /* Response timeout in ms */ + + /* The description must be internally consistent. + * - The ApplicationUri set in the ApplicationDescription must match the + * URI set in the server certificate */ + UA_ApplicationDescription clientDescription; + + /* Basic connection configuration */ + UA_ExtensionObject userIdentityToken; /* Configured User-Identity Token */ + UA_MessageSecurityMode securityMode; /* None, Sign, SignAndEncrypt. The + * default is invalid. This indicates + * the client to select any matching + * endpoint. */ + UA_String securityPolicyUri; /* SecurityPolicy for the SecureChannel. An + * empty string indicates the client to select + * any matching SecurityPolicy. */ + + /* Advanced connection configuration + * + * If either endpoint or userTokenPolicy has been set (at least one non-zero + * byte in either structure), then the selected Endpoint and UserTokenPolicy + * overwrite the settings in the basic connection configuration. The + * userTokenPolicy array in the EndpointDescription is ignored. The selected + * userTokenPolicy is set in the dedicated configuration field. + * + * If the advanced configuration is not set, the client will write to it the + * selected Endpoint and UserTokenPolicy during GetEndpoints. + * + * The information in the advanced configuration is used during reconnect + * when the SecureChannel was broken. */ + UA_EndpointDescription endpoint; + UA_UserTokenPolicy userTokenPolicy; + + /* Advanced client configuration */ + + UA_UInt32 secureChannelLifeTime; /* Lifetime in ms (then the channel needs + to be renewed) */ + UA_UInt32 requestedSessionTimeout; /* Session timeout in ms */ + UA_ConnectionConfig localConnectionConfig; + UA_UInt32 connectivityCheckInterval; /* Connectivity check interval in ms. + * 0 = background task disabled */ + const UA_DataTypeArray *customDataTypes; /* Custom DataTypes. Attention! + * Custom datatypes are not cleaned + * up together with the + * configuration. So it is possible + * to allocate them on ROM. */ + + /* Available SecurityPolicies */ + size_t securityPoliciesSize; + UA_SecurityPolicy *securityPolicies; + + /* Certificate Verification Plugin */ + UA_CertificateVerification certificateVerification; + + /* Callbacks for async connection handshakes */ + UA_ConnectClientConnection initConnectionFunc; + UA_StatusCode (*pollConnectionFunc)(UA_Connection *connection, + UA_UInt32 timeout, + const UA_Logger *logger); + + /* Callback for state changes. The client state is differentated into the + * SecureChannel state and the Session state. The connectStatus is set if + * the client connection (including reconnects) has failed and the client + * has to "give up". If the connectStatus is not set, the client still has + * hope to connect or recover. */ + void (*stateCallback)(UA_Client *client, + UA_SecureChannelState channelState, + UA_SessionState sessionState, + UA_StatusCode connectStatus); + + /* When connectivityCheckInterval is greater than 0, every + * connectivityCheckInterval (in ms), an async read request is performed on + * the server. inactivityCallback is called when the client receive no + * response for this read request The connection can be closed, this in an + * attempt to recreate a healthy connection. */ + void (*inactivityCallback)(UA_Client *client); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* Number of PublishResponse queued up in the server */ + UA_UInt16 outStandingPublishRequests; + + /* If the client does not receive a PublishResponse after the defined delay + * of ``(sub->publishingInterval * sub->maxKeepAliveCount) + + * client->config.timeout)``, then subscriptionInactivityCallback is called + * for the subscription.. */ + void (*subscriptionInactivityCallback)(UA_Client *client, + UA_UInt32 subscriptionId, + void *subContext); +#endif + + UA_LocaleId *sessionLocaleIds; + size_t sessionLocaleIdsSize; +} UA_ClientConfig; + + /** + * Client Lifecycle + * ---------------- */ + +/* The method UA_Client_new is defined in client_config_default.h. So default + * plugins outside of the core library (for logging, etc) are already available + * during the initialization. + * + * UA_Client UA_EXPORT * UA_Client_new(void); + */ + +/* Creates a new client. Moves the config into the client with a shallow copy. + * The config content is cleared together with the client. */ +UA_Client UA_EXPORT * +UA_Client_newWithConfig(const UA_ClientConfig *config); + +/* Returns the current state. All arguments except ``client`` can be NULL. */ +void UA_EXPORT +UA_Client_getState(UA_Client *client, + UA_SecureChannelState *channelState, + UA_SessionState *sessionState, + UA_StatusCode *connectStatus); + +/* Get the client configuration */ +UA_EXPORT UA_ClientConfig * +UA_Client_getConfig(UA_Client *client); + +/* Get the client context */ +static UA_INLINE void * +UA_Client_getContext(UA_Client *client) { + return UA_Client_getConfig(client)->clientContext; /* Cannot fail */ +} + +/* (Disconnect and) delete the client */ +void UA_EXPORT +UA_Client_delete(UA_Client *client); + +/** + * Connect to a Server + * ------------------- + * + * Once a client is connected to an endpointUrl, it is not possible to switch to + * another server. A new client has to be created for that. + * + * Once a connection is established, the client keeps the connection open and + * reconnects if necessary. + * + * If the connection fails unrecoverably (state->connectStatus is set to an + * error), the client is no longer usable. Create a new client if required. */ + +/* Connect to the server. First a SecureChannel is opened, then a Session. The + * client configuration restricts the SecureChannel selection and contains the + * UserIdentityToken for the Session. + * + * @param client to use + * @param endpointURL to connect (for example "opc.tcp://localhost:4840") + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Client_connect(UA_Client *client, const char *endpointUrl); + +/* Connect async (non-blocking) to the server. After initiating the connection, + * call UA_Client_run_iterate repeatedly until the connection is fully + * established. You can set a callback to client->config.stateCallback to be + * notified when the connection status changes. Or use UA_Client_getState to get + * the state manually. */ +UA_StatusCode UA_EXPORT +UA_Client_connectAsync(UA_Client *client, const char *endpointUrl); + +/* Connect to the server without creating a session + * + * @param client to use + * @param endpointURL to connect (for example "opc.tcp://localhost:4840") + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Client_connectSecureChannel(UA_Client *client, const char *endpointUrl); + +/* Connect async (non-blocking) only the SecureChannel */ +UA_StatusCode UA_EXPORT +UA_Client_connectSecureChannelAsync(UA_Client *client, const char *endpointUrl); + +/* Connect to the server and create+activate a Session with the given username + * and password. This first set the UserIdentityToken in the client config and + * then calls the regular connect method. */ +static UA_INLINE UA_StatusCode +UA_Client_connectUsername(UA_Client *client, const char *endpointUrl, + const char *username, const char *password) { + UA_UserNameIdentityToken* identityToken = UA_UserNameIdentityToken_new(); + if(!identityToken) + return UA_STATUSCODE_BADOUTOFMEMORY; + identityToken->userName = UA_STRING_ALLOC(username); + identityToken->password = UA_STRING_ALLOC(password); + UA_ClientConfig *cc = UA_Client_getConfig(client); + UA_ExtensionObject_clear(&cc->userIdentityToken); + cc->userIdentityToken.encoding = UA_EXTENSIONOBJECT_DECODED; + cc->userIdentityToken.content.decoded.type = &UA_TYPES[UA_TYPES_USERNAMEIDENTITYTOKEN]; + cc->userIdentityToken.content.decoded.data = identityToken; + return UA_Client_connect(client, endpointUrl); +} + +/* Disconnect and close a connection to the selected server. Disconnection is + * always performed async (without blocking). */ +UA_StatusCode UA_EXPORT +UA_Client_disconnect(UA_Client *client); + +/* Disconnect async. Run UA_Client_run_iterate until the callback notifies that + * all connections are closed. */ +UA_StatusCode UA_EXPORT +UA_Client_disconnectAsync(UA_Client *client); + +/* Disconnect the SecureChannel but keep the Session intact (if it exists). + * This is always an async (non-blocking) operation. */ +UA_StatusCode UA_EXPORT +UA_Client_disconnectSecureChannel(UA_Client *client); + +/** + * Discovery + * --------- */ + +/* Gets a list of endpoints of a server + * + * @param client to use. Must be connected to the same endpoint given in + * serverUrl or otherwise in disconnected state. + * @param serverUrl url to connect (for example "opc.tcp://localhost:4840") + * @param endpointDescriptionsSize size of the array of endpoint descriptions + * @param endpointDescriptions array of endpoint descriptions that is allocated + * by the function (you need to free manually) + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Client_getEndpoints(UA_Client *client, const char *serverUrl, + size_t* endpointDescriptionsSize, + UA_EndpointDescription** endpointDescriptions); + +/* Gets a list of all registered servers at the given server. + * + * You can pass an optional filter for serverUris. If the given server is not registered, + * an empty array will be returned. If the server is registered, only that application + * description will be returned. + * + * Additionally you can optionally indicate which locale you want for the server name + * in the returned application description. The array indicates the order of preference. + * A server may have localized names. + * + * @param client to use. Must be connected to the same endpoint given in + * serverUrl or otherwise in disconnected state. + * @param serverUrl url to connect (for example "opc.tcp://localhost:4840") + * @param serverUrisSize Optional filter for specific server uris + * @param serverUris Optional filter for specific server uris + * @param localeIdsSize Optional indication which locale you prefer + * @param localeIds Optional indication which locale you prefer + * @param registeredServersSize size of returned array, i.e., number of found/registered servers + * @param registeredServers array containing found/registered servers + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Client_findServers(UA_Client *client, const char *serverUrl, + size_t serverUrisSize, UA_String *serverUris, + size_t localeIdsSize, UA_String *localeIds, + size_t *registeredServersSize, + UA_ApplicationDescription **registeredServers); + +#ifdef UA_ENABLE_DISCOVERY +/* Get a list of all known server in the network. Only supported by LDS servers. + * + * @param client to use. Must be connected to the same endpoint given in + * serverUrl or otherwise in disconnected state. + * @param serverUrl url to connect (for example "opc.tcp://localhost:4840") + * @param startingRecordId optional. Only return the records with an ID higher + * or equal the given. Can be used for pagination to only get a subset of + * the full list + * @param maxRecordsToReturn optional. Only return this number of records + + * @param serverCapabilityFilterSize optional. Filter the returned list to only + * get servers with given capabilities, e.g. "LDS" + * @param serverCapabilityFilter optional. Filter the returned list to only get + * servers with given capabilities, e.g. "LDS" + * @param serverOnNetworkSize size of returned array, i.e., number of + * known/registered servers + * @param serverOnNetwork array containing known/registered servers + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Client_findServersOnNetwork(UA_Client *client, const char *serverUrl, + UA_UInt32 startingRecordId, UA_UInt32 maxRecordsToReturn, + size_t serverCapabilityFilterSize, UA_String *serverCapabilityFilter, + size_t *serverOnNetworkSize, UA_ServerOnNetwork **serverOnNetwork); +#endif + +/** + * .. _client-services: + * + * Services + * -------- + * + * The raw OPC UA services are exposed to the client. But most of them time, it + * is better to use the convenience functions from ``ua_client_highlevel.h`` + * that wrap the raw services. */ +/* Don't use this function. Use the type versions below instead. */ +void UA_EXPORT +__UA_Client_Service(UA_Client *client, const void *request, + const UA_DataType *requestType, void *response, + const UA_DataType *responseType); + +/* + * Attribute Service Set + * ^^^^^^^^^^^^^^^^^^^^^ */ +static UA_INLINE UA_ReadResponse +UA_Client_Service_read(UA_Client *client, const UA_ReadRequest request) { + UA_ReadResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_READREQUEST], + &response, &UA_TYPES[UA_TYPES_READRESPONSE]); + return response; +} + +static UA_INLINE UA_WriteResponse +UA_Client_Service_write(UA_Client *client, const UA_WriteRequest request) { + UA_WriteResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_WRITEREQUEST], + &response, &UA_TYPES[UA_TYPES_WRITERESPONSE]); + return response; +} + +/* +* Historical Access Service Set +* ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ +#ifdef UA_ENABLE_HISTORIZING +static UA_INLINE UA_HistoryReadResponse +UA_Client_Service_historyRead(UA_Client *client, const UA_HistoryReadRequest request) { + UA_HistoryReadResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_HISTORYREADREQUEST], + &response, &UA_TYPES[UA_TYPES_HISTORYREADRESPONSE]); + return response; +} + +static UA_INLINE UA_HistoryUpdateResponse +UA_Client_Service_historyUpdate(UA_Client *client, const UA_HistoryUpdateRequest request) { + UA_HistoryUpdateResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_HISTORYUPDATEREQUEST], + &response, &UA_TYPES[UA_TYPES_HISTORYUPDATERESPONSE]); + return response; +} +#endif + +/* + * Method Service Set + * ^^^^^^^^^^^^^^^^^^ */ +#ifdef UA_ENABLE_METHODCALLS +static UA_INLINE UA_CallResponse +UA_Client_Service_call(UA_Client *client, const UA_CallRequest request) { + UA_CallResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_CALLREQUEST], + &response, &UA_TYPES[UA_TYPES_CALLRESPONSE]); + return response; +} +#endif + +/* + * NodeManagement Service Set + * ^^^^^^^^^^^^^^^^^^^^^^^^^^ */ +static UA_INLINE UA_AddNodesResponse +UA_Client_Service_addNodes(UA_Client *client, const UA_AddNodesRequest request) { + UA_AddNodesResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_ADDNODESREQUEST], + &response, &UA_TYPES[UA_TYPES_ADDNODESRESPONSE]); + return response; +} + +static UA_INLINE UA_AddReferencesResponse +UA_Client_Service_addReferences(UA_Client *client, + const UA_AddReferencesRequest request) { + UA_AddReferencesResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_ADDREFERENCESREQUEST], + &response, &UA_TYPES[UA_TYPES_ADDREFERENCESRESPONSE]); + return response; +} + +static UA_INLINE UA_DeleteNodesResponse +UA_Client_Service_deleteNodes(UA_Client *client, + const UA_DeleteNodesRequest request) { + UA_DeleteNodesResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_DELETENODESREQUEST], + &response, &UA_TYPES[UA_TYPES_DELETENODESRESPONSE]); + return response; +} + +static UA_INLINE UA_DeleteReferencesResponse +UA_Client_Service_deleteReferences(UA_Client *client, + const UA_DeleteReferencesRequest request) { + UA_DeleteReferencesResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_DELETEREFERENCESREQUEST], + &response, &UA_TYPES[UA_TYPES_DELETEREFERENCESRESPONSE]); + return response; +} + +/* + * View Service Set + * ^^^^^^^^^^^^^^^^ */ +static UA_INLINE UA_BrowseResponse +UA_Client_Service_browse(UA_Client *client, const UA_BrowseRequest request) { + UA_BrowseResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], + &response, &UA_TYPES[UA_TYPES_BROWSERESPONSE]); + return response; +} + +static UA_INLINE UA_BrowseNextResponse +UA_Client_Service_browseNext(UA_Client *client, + const UA_BrowseNextRequest request) { + UA_BrowseNextResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_BROWSENEXTREQUEST], + &response, &UA_TYPES[UA_TYPES_BROWSENEXTRESPONSE]); + return response; +} + +static UA_INLINE UA_TranslateBrowsePathsToNodeIdsResponse +UA_Client_Service_translateBrowsePathsToNodeIds(UA_Client *client, + const UA_TranslateBrowsePathsToNodeIdsRequest request) { + UA_TranslateBrowsePathsToNodeIdsResponse response; + __UA_Client_Service(client, &request, + &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSREQUEST], + &response, + &UA_TYPES[UA_TYPES_TRANSLATEBROWSEPATHSTONODEIDSRESPONSE]); + return response; +} + +static UA_INLINE UA_RegisterNodesResponse +UA_Client_Service_registerNodes(UA_Client *client, + const UA_RegisterNodesRequest request) { + UA_RegisterNodesResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_REGISTERNODESREQUEST], + &response, &UA_TYPES[UA_TYPES_REGISTERNODESRESPONSE]); + return response; +} + +static UA_INLINE UA_UnregisterNodesResponse +UA_Client_Service_unregisterNodes(UA_Client *client, + const UA_UnregisterNodesRequest request) { + UA_UnregisterNodesResponse response; + __UA_Client_Service(client, &request, + &UA_TYPES[UA_TYPES_UNREGISTERNODESREQUEST], + &response, &UA_TYPES[UA_TYPES_UNREGISTERNODESRESPONSE]); + return response; +} + +/* + * Query Service Set + * ^^^^^^^^^^^^^^^^^ */ +#ifdef UA_ENABLE_QUERY + +static UA_INLINE UA_QueryFirstResponse +UA_Client_Service_queryFirst(UA_Client *client, + const UA_QueryFirstRequest request) { + UA_QueryFirstResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_QUERYFIRSTREQUEST], + &response, &UA_TYPES[UA_TYPES_QUERYFIRSTRESPONSE]); + return response; +} + +static UA_INLINE UA_QueryNextResponse +UA_Client_Service_queryNext(UA_Client *client, + const UA_QueryNextRequest request) { + UA_QueryNextResponse response; + __UA_Client_Service(client, &request, &UA_TYPES[UA_TYPES_QUERYFIRSTREQUEST], + &response, &UA_TYPES[UA_TYPES_QUERYFIRSTRESPONSE]); + return response; +} + +#endif + +/** + * .. _client-async-services: + * + * Asynchronous Services + * --------------------- + * All OPC UA services are asynchronous in nature. So several service calls can + * be made without waiting for the individual responses. Depending on the + * server's priorities responses may come in a different ordering than sent. + * + * As noted in :ref:`the client overview` currently no means + * of handling asynchronous events automatically is provided. However, some + * synchronous function calls will trigger handling, but to ensure this + * happens a client should periodically call `UA_Client_run_iterate` + * explicitly. + * + * Connection and session management are also performed in + * `UA_Client_run_iterate`, so to keep a connection healthy any client need to + * consider how and when it is appropriate to do the call. + * This is especially true for the periodic renewal of a SecureChannel's + * SecurityToken which is designed to have a limited lifetime and will + * invalidate the connection if not renewed. + */ + +/* Use the type versions of this method. See below. However, the general + * mechanism of async service calls is explained here. + * + * We say that an async service call has been dispatched once this method + * returns UA_STATUSCODE_GOOD. If there is an error after an async service has + * been dispatched, the callback is called with an "empty" response where the + * statusCode has been set accordingly. This is also done if the client is + * shutting down and the list of dispatched async services is emptied. + * + * The statusCode received when the client is shutting down is + * UA_STATUSCODE_BADSHUTDOWN. + * + * The statusCode received when the client don't receive response + * after specified config->timeout (in ms) is + * UA_STATUSCODE_BADTIMEOUT. + * + * Instead, you can use __UA_Client_AsyncServiceEx to specify + * a custom timeout + * + * The userdata and requestId arguments can be NULL. */ + +typedef void (*UA_ClientAsyncServiceCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, void *response); + +UA_StatusCode UA_EXPORT +__UA_Client_AsyncService(UA_Client *client, const void *request, + const UA_DataType *requestType, + UA_ClientAsyncServiceCallback callback, + const UA_DataType *responseType, + void *userdata, UA_UInt32 *requestId); + +UA_StatusCode UA_EXPORT +UA_Client_sendAsyncRequest(UA_Client *client, const void *request, + const UA_DataType *requestType, UA_ClientAsyncServiceCallback callback, + const UA_DataType *responseType, void *userdata, UA_UInt32 *requestId); + +/** + * Set new userdata and callback for an existing request. + * + * @param client Pointer to the UA_Client + * @param requestId RequestId of the request, which was returned by + * UA_Client_sendAsyncRequest before + * @param userdata The new userdata. + * @param callback The new callback + * @return UA_StatusCode UA_STATUSCODE_GOOD on success + * UA_STATUSCODE_BADNOTFOUND when no request with requestId is found. + */ +UA_StatusCode UA_EXPORT +UA_Client_modifyAsyncCallback(UA_Client *client, UA_UInt32 requestId, + void *userdata, UA_ClientAsyncServiceCallback callback); + +/* Listen on the network and process arriving asynchronous responses in the + * background. Internal housekeeping, renewal of SecureChannels and subscription + * management is done as well. */ +UA_StatusCode UA_EXPORT +UA_Client_run_iterate(UA_Client *client, UA_UInt32 timeout); + +/* Force the manual renewal of the SecureChannel. This is useful to renew the + * SecureChannel during a downtime when no time-critical operations are + * performed. This method is asynchronous. The renewal is triggered (the OPN + * message is sent) but not completed. The OPN response is handled with + * ``UA_Client_run_iterate`` or a synchronous servica-call operation. + * + * @return The return value is UA_STATUSCODE_GOODCALLAGAIN if the SecureChannel + * has not elapsed at least 75% of its lifetime. Otherwise the + * ``connectStatus`` is returned. */ +UA_StatusCode UA_EXPORT +UA_Client_renewSecureChannel(UA_Client *client); + +/* Use the type versions of this method. See below. However, the general + * mechanism of async service calls is explained here. + * + * We say that an async service call has been dispatched once this method + * returns UA_STATUSCODE_GOOD. If there is an error after an async service has + * been dispatched, the callback is called with an "empty" response where the + * statusCode has been set accordingly. This is also done if the client is + * shutting down and the list of dispatched async services is emptied. + * + * The statusCode received when the client is shutting down is + * UA_STATUSCODE_BADSHUTDOWN. + * + * The statusCode received when the client don't receive response + * after specified timeout (in ms) is + * UA_STATUSCODE_BADTIMEOUT. + * + * The timeout can be disabled by setting timeout to 0 + * + * The userdata and requestId arguments can be NULL. */ +UA_StatusCode UA_EXPORT +__UA_Client_AsyncServiceEx(UA_Client *client, const void *request, + const UA_DataType *requestType, + UA_ClientAsyncServiceCallback callback, + const UA_DataType *responseType, + void *userdata, UA_UInt32 *requestId, + UA_UInt32 timeout); + +/** + * Timed Callbacks + * --------------- + * Repeated callbacks can be attached to a client and will be executed in the + * defined interval. */ + +typedef void (*UA_ClientCallback)(UA_Client *client, void *data); + +/* Add a callback for execution at a specified time. If the indicated time lies + * in the past, then the callback is executed at the next iteration of the + * server's main loop. + * + * @param client The client object. + * @param callback The callback that shall be added. + * @param data Data that is forwarded to the callback. + * @param date The timestamp for the execution time. + * @param callbackId Set to the identifier of the repeated callback . This can + * be used to cancel the callback later on. If the pointer is null, the + * identifier is not set. + * @return Upon success, UA_STATUSCODE_GOOD is returned. An error code + * otherwise. */ +UA_StatusCode UA_EXPORT +UA_Client_addTimedCallback(UA_Client *client, UA_ClientCallback callback, + void *data, UA_DateTime date, UA_UInt64 *callbackId); + +/* Add a callback for cyclic repetition to the client. + * + * @param client The client object. + * @param callback The callback that shall be added. + * @param data Data that is forwarded to the callback. + * @param interval_ms The callback shall be repeatedly executed with the given + * interval (in ms). The interval must be positive. The first execution + * occurs at now() + interval at the latest. + * @param callbackId Set to the identifier of the repeated callback . This can + * be used to cancel the callback later on. If the pointer is null, the + * identifier is not set. + * @return Upon success, UA_STATUSCODE_GOOD is returned. An error code + * otherwise. */ +UA_StatusCode UA_EXPORT +UA_Client_addRepeatedCallback(UA_Client *client, UA_ClientCallback callback, + void *data, UA_Double interval_ms, + UA_UInt64 *callbackId); + +UA_StatusCode UA_EXPORT +UA_Client_changeRepeatedCallbackInterval(UA_Client *client, + UA_UInt64 callbackId, + UA_Double interval_ms); + +void UA_EXPORT +UA_Client_removeCallback(UA_Client *client, UA_UInt64 callbackId); + +/** + * Client Utility Functions + * ------------------------ */ + +/* Lookup a datatype by its NodeId. Takes the custom types in the client + * configuration into account. Return NULL if none found. */ +UA_EXPORT const UA_DataType * +UA_Client_findDataType(UA_Client *client, const UA_NodeId *typeId); + +/** + * .. toctree:: + * + * client_highlevel + * client_subscriptions */ + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/client_highlevel.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2015-2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2015 (c) Oleksiy Vasylyev + * Copyright 2017 (c) Florian Palm + * Copyright 2016 (c) Chris Iatrou + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2017 (c) Frank Meerkötter + * Copyright 2018 (c) Fabian Arndt + * Copyright 2018 (c) Peter Rustler, basyskom GmbH + */ + + + +_UA_BEGIN_DECLS + +/** + * .. _client-highlevel: + * + * Highlevel Client Functionality + * ------------------------------ + * + * The following definitions are convenience functions making use of the + * standard OPC UA services in the background. This is a less flexible way of + * handling the stack, because at many places sensible defaults are presumed; at + * the same time using these functions is the easiest way of implementing an OPC + * UA application, as you will not have to consider all the details that go into + * the OPC UA services. If more flexibility is needed, you can always achieve + * the same functionality using the raw :ref:`OPC UA services + * `. + * + * Read Attributes + * ^^^^^^^^^^^^^^^ + * The following functions can be used to retrieve a single node attribute. Use + * the regular service to read several attributes at once. */ + +/* Don't call this function, use the typed versions */ +UA_StatusCode UA_EXPORT +__UA_Client_readAttribute(UA_Client *client, const UA_NodeId *nodeId, + UA_AttributeId attributeId, void *out, + const UA_DataType *outDataType); + +static UA_INLINE UA_StatusCode +UA_Client_readNodeIdAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_NodeId *outNodeId) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_NODEID, + outNodeId, &UA_TYPES[UA_TYPES_NODEID]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readNodeClassAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_NodeClass *outNodeClass) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_NODECLASS, + outNodeClass, &UA_TYPES[UA_TYPES_NODECLASS]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readBrowseNameAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_QualifiedName *outBrowseName) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_BROWSENAME, + outBrowseName, + &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readDisplayNameAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_LocalizedText *outDisplayName) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME, + outDisplayName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readDescriptionAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_LocalizedText *outDescription) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_DESCRIPTION, + outDescription, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_UInt32 *outWriteMask) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_WRITEMASK, + outWriteMask, &UA_TYPES[UA_TYPES_UINT32]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readUserWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_UInt32 *outUserWriteMask) { + return __UA_Client_readAttribute(client, &nodeId, + UA_ATTRIBUTEID_USERWRITEMASK, + outUserWriteMask, + &UA_TYPES[UA_TYPES_UINT32]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readIsAbstractAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean *outIsAbstract) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_ISABSTRACT, + outIsAbstract, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readSymmetricAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean *outSymmetric) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_SYMMETRIC, + outSymmetric, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readInverseNameAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_LocalizedText *outInverseName) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_INVERSENAME, + outInverseName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readContainsNoLoopsAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean *outContainsNoLoops) { + return __UA_Client_readAttribute(client, &nodeId, + UA_ATTRIBUTEID_CONTAINSNOLOOPS, + outContainsNoLoops, + &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readEventNotifierAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Byte *outEventNotifier) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_EVENTNOTIFIER, + outEventNotifier, &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readValueAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Variant *outValue) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUE, + outValue, &UA_TYPES[UA_TYPES_VARIANT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readDataTypeAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_NodeId *outDataType) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_DATATYPE, + outDataType, &UA_TYPES[UA_TYPES_NODEID]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readValueRankAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Int32 *outValueRank) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUERANK, + outValueRank, &UA_TYPES[UA_TYPES_INT32]); +} + +UA_StatusCode UA_EXPORT +UA_Client_readArrayDimensionsAttribute(UA_Client *client, const UA_NodeId nodeId, + size_t *outArrayDimensionsSize, + UA_UInt32 **outArrayDimensions); + +static UA_INLINE UA_StatusCode +UA_Client_readAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Byte *outAccessLevel) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL, + outAccessLevel, &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readUserAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Byte *outUserAccessLevel) { + return __UA_Client_readAttribute(client, &nodeId, + UA_ATTRIBUTEID_USERACCESSLEVEL, + outUserAccessLevel, + &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readMinimumSamplingIntervalAttribute(UA_Client *client, + const UA_NodeId nodeId, + UA_Double *outMinSamplingInterval) { + return __UA_Client_readAttribute(client, &nodeId, + UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL, + outMinSamplingInterval, + &UA_TYPES[UA_TYPES_DOUBLE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readHistorizingAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean *outHistorizing) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_HISTORIZING, + outHistorizing, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readExecutableAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean *outExecutable) { + return __UA_Client_readAttribute(client, &nodeId, UA_ATTRIBUTEID_EXECUTABLE, + outExecutable, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_readUserExecutableAttribute(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean *outUserExecutable) { + return __UA_Client_readAttribute(client, &nodeId, + UA_ATTRIBUTEID_USEREXECUTABLE, + outUserExecutable, + &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +/** + * Historical Access + * ^^^^^^^^^^^^^^^^^ + * The following functions can be used to read a single node historically. + * Use the regular service to read several nodes at once. */ + +#ifdef UA_ENABLE_HISTORIZING +typedef UA_Boolean +(*UA_HistoricalIteratorCallback)(UA_Client *client, + const UA_NodeId *nodeId, + UA_Boolean moreDataAvailable, + const UA_ExtensionObject *data, void *callbackContext); + +#ifdef UA_ENABLE_EXPERIMENTAL_HISTORIZING +UA_StatusCode UA_EXPORT +UA_Client_HistoryRead_events(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_DateTime startTime, UA_DateTime endTime, + UA_String indexRange, const UA_EventFilter filter, UA_UInt32 numValuesPerNode, + UA_TimestampsToReturn timestampsToReturn, void *callbackContext); +#endif // UA_ENABLE_EXPERIMENTAL_HISTORIZING + +UA_StatusCode UA_EXPORT +UA_Client_HistoryRead_raw(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_DateTime startTime, UA_DateTime endTime, + UA_String indexRange, UA_Boolean returnBounds, UA_UInt32 numValuesPerNode, + UA_TimestampsToReturn timestampsToReturn, void *callbackContext); + +#ifdef UA_ENABLE_EXPERIMENTAL_HISTORIZING +UA_StatusCode UA_EXPORT +UA_Client_HistoryRead_modified(UA_Client *client, const UA_NodeId *nodeId, + const UA_HistoricalIteratorCallback callback, + UA_DateTime startTime, UA_DateTime endTime, + UA_String indexRange, UA_Boolean returnBounds, UA_UInt32 numValuesPerNode, + UA_TimestampsToReturn timestampsToReturn, void *callbackContext); +#endif // UA_ENABLE_EXPERIMENTAL_HISTORIZING + +UA_StatusCode UA_EXPORT +UA_Client_HistoryUpdate_insert(UA_Client *client, + const UA_NodeId *nodeId, + UA_DataValue *value); + +UA_StatusCode UA_EXPORT +UA_Client_HistoryUpdate_replace(UA_Client *client, + const UA_NodeId *nodeId, + UA_DataValue *value); + +UA_StatusCode UA_EXPORT +UA_Client_HistoryUpdate_update(UA_Client *client, + const UA_NodeId *nodeId, + UA_DataValue *value); + +UA_StatusCode UA_EXPORT +UA_Client_HistoryUpdate_deleteRaw(UA_Client *client, + const UA_NodeId *nodeId, + UA_DateTime startTimestamp, + UA_DateTime endTimestamp); + +#endif // UA_ENABLE_HISTORIZING + +/** + * Write Attributes + * ^^^^^^^^^^^^^^^^ + * + * The following functions can be use to write a single node attribute at a + * time. Use the regular write service to write several attributes at once. */ + +/* Don't call this function, use the typed versions */ +UA_StatusCode UA_EXPORT +__UA_Client_writeAttribute(UA_Client *client, const UA_NodeId *nodeId, + UA_AttributeId attributeId, const void *in, + const UA_DataType *inDataType); + +static UA_INLINE UA_StatusCode +UA_Client_writeNodeIdAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_NodeId *newNodeId) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_NODEID, + newNodeId, &UA_TYPES[UA_TYPES_NODEID]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeNodeClassAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_NodeClass *newNodeClass) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_NODECLASS, + newNodeClass, &UA_TYPES[UA_TYPES_NODECLASS]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeBrowseNameAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_QualifiedName *newBrowseName) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_BROWSENAME, + newBrowseName, + &UA_TYPES[UA_TYPES_QUALIFIEDNAME]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeDisplayNameAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_LocalizedText *newDisplayName) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME, + newDisplayName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeDescriptionAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_LocalizedText *newDescription) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_DESCRIPTION, + newDescription, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_UInt32 *newWriteMask) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_WRITEMASK, + newWriteMask, &UA_TYPES[UA_TYPES_UINT32]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeUserWriteMaskAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_UInt32 *newUserWriteMask) { + return __UA_Client_writeAttribute(client, &nodeId, + UA_ATTRIBUTEID_USERWRITEMASK, + newUserWriteMask, + &UA_TYPES[UA_TYPES_UINT32]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeIsAbstractAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *newIsAbstract) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_ISABSTRACT, + newIsAbstract, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeSymmetricAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *newSymmetric) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_SYMMETRIC, + newSymmetric, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeInverseNameAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_LocalizedText *newInverseName) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_INVERSENAME, + newInverseName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeContainsNoLoopsAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *newContainsNoLoops) { + return __UA_Client_writeAttribute(client, &nodeId, + UA_ATTRIBUTEID_CONTAINSNOLOOPS, + newContainsNoLoops, + &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeEventNotifierAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Byte *newEventNotifier) { + return __UA_Client_writeAttribute(client, &nodeId, + UA_ATTRIBUTEID_EVENTNOTIFIER, + newEventNotifier, + &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeValueAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Variant *newValue) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUE, + newValue, &UA_TYPES[UA_TYPES_VARIANT]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeDataTypeAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_NodeId *newDataType) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_DATATYPE, + newDataType, &UA_TYPES[UA_TYPES_NODEID]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeValueRankAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Int32 *newValueRank) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_VALUERANK, + newValueRank, &UA_TYPES[UA_TYPES_INT32]); +} + +UA_StatusCode UA_EXPORT +UA_Client_writeArrayDimensionsAttribute(UA_Client *client, const UA_NodeId nodeId, + size_t newArrayDimensionsSize, + const UA_UInt32 *newArrayDimensions); + +static UA_INLINE UA_StatusCode +UA_Client_writeAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Byte *newAccessLevel) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL, + newAccessLevel, &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeUserAccessLevelAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Byte *newUserAccessLevel) { + return __UA_Client_writeAttribute(client, &nodeId, + UA_ATTRIBUTEID_USERACCESSLEVEL, + newUserAccessLevel, + &UA_TYPES[UA_TYPES_BYTE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeMinimumSamplingIntervalAttribute(UA_Client *client, + const UA_NodeId nodeId, + const UA_Double *newMinInterval) { + return __UA_Client_writeAttribute(client, &nodeId, + UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL, + newMinInterval, &UA_TYPES[UA_TYPES_DOUBLE]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeHistorizingAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *newHistorizing) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_HISTORIZING, + newHistorizing, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeExecutableAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *newExecutable) { + return __UA_Client_writeAttribute(client, &nodeId, UA_ATTRIBUTEID_EXECUTABLE, + newExecutable, &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeUserExecutableAttribute(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *newUserExecutable) { + return __UA_Client_writeAttribute(client, &nodeId, + UA_ATTRIBUTEID_USEREXECUTABLE, + newUserExecutable, + &UA_TYPES[UA_TYPES_BOOLEAN]); +} + +/** + * Method Calling + * ^^^^^^^^^^^^^^ */ + +#ifdef UA_ENABLE_METHODCALLS +UA_StatusCode UA_EXPORT +UA_Client_call(UA_Client *client, const UA_NodeId objectId, + const UA_NodeId methodId, size_t inputSize, const UA_Variant *input, + size_t *outputSize, UA_Variant **output); +#endif + +/** + * Node Management + * ^^^^^^^^^^^^^^^ + * See the section on :ref:`server-side node management `. */ + +UA_StatusCode UA_EXPORT +UA_Client_addReference(UA_Client *client, const UA_NodeId sourceNodeId, + const UA_NodeId referenceTypeId, UA_Boolean isForward, + const UA_String targetServerUri, + const UA_ExpandedNodeId targetNodeId, + UA_NodeClass targetNodeClass); + +UA_StatusCode UA_EXPORT +UA_Client_deleteReference(UA_Client *client, const UA_NodeId sourceNodeId, + const UA_NodeId referenceTypeId, UA_Boolean isForward, + const UA_ExpandedNodeId targetNodeId, + UA_Boolean deleteBidirectional); + +UA_StatusCode UA_EXPORT +UA_Client_deleteNode(UA_Client *client, const UA_NodeId nodeId, + UA_Boolean deleteTargetReferences); + +/* Protect against redundant definitions for server/client */ +#ifndef UA_DEFAULT_ATTRIBUTES_DEFINED +#define UA_DEFAULT_ATTRIBUTES_DEFINED +/* The default for variables is "BaseDataType" for the datatype, -2 for the + * valuerank and a read-accesslevel. */ +UA_EXPORT extern const UA_VariableAttributes UA_VariableAttributes_default; +UA_EXPORT extern const UA_VariableTypeAttributes UA_VariableTypeAttributes_default; +/* Methods are executable by default */ +UA_EXPORT extern const UA_MethodAttributes UA_MethodAttributes_default; +/* The remaining attribute definitions are currently all zeroed out */ +UA_EXPORT extern const UA_ObjectAttributes UA_ObjectAttributes_default; +UA_EXPORT extern const UA_ObjectTypeAttributes UA_ObjectTypeAttributes_default; +UA_EXPORT extern const UA_ReferenceTypeAttributes UA_ReferenceTypeAttributes_default; +UA_EXPORT extern const UA_DataTypeAttributes UA_DataTypeAttributes_default; +UA_EXPORT extern const UA_ViewAttributes UA_ViewAttributes_default; +#endif + +/* Don't call this function, use the typed versions */ +UA_StatusCode UA_EXPORT +__UA_Client_addNode(UA_Client *client, const UA_NodeClass nodeClass, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, const UA_NodeAttributes *attr, + const UA_DataType *attributeType, UA_NodeId *outNewNodeId); + +static UA_INLINE UA_StatusCode +UA_Client_addVariableNode(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_VariableAttributes attr, + UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_VARIABLE, requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + typeDefinition, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES], + outNewNodeId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addVariableTypeNode(UA_Client *client, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_VariableTypeAttributes attr, + UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_VARIABLETYPE, + requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES], + outNewNodeId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addObjectNode(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_ObjectAttributes attr, UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_OBJECT, requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + typeDefinition, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES], outNewNodeId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addObjectTypeNode(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_ObjectTypeAttributes attr, + UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_OBJECTTYPE, requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES], + outNewNodeId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addViewNode(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_ViewAttributes attr, + UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_VIEW, requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_VIEWATTRIBUTES], outNewNodeId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addReferenceTypeNode(UA_Client *client, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_ReferenceTypeAttributes attr, + UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_REFERENCETYPE, + requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES], + outNewNodeId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addDataTypeNode(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_DataTypeAttributes attr, + UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_DATATYPE, requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES], + outNewNodeId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addMethodNode(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_MethodAttributes attr, + UA_NodeId *outNewNodeId) { + return __UA_Client_addNode(client, UA_NODECLASS_METHOD, requestedNewNodeId, + parentNodeId, referenceTypeId, browseName, + UA_NODEID_NULL, (const UA_NodeAttributes*)&attr, + &UA_TYPES[UA_TYPES_METHODATTRIBUTES], outNewNodeId); +} + +/** + * Misc Highlevel Functionality + * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ */ + +/* Get the namespace-index of a namespace-URI + * + * @param client The UA_Client struct for this connection + * @param namespaceUri The interested namespace URI + * @param namespaceIndex The namespace index of the URI. The value is unchanged + * in case of an error + * @return Indicates whether the operation succeeded or returns an error code */ +UA_StatusCode UA_EXPORT +UA_Client_NamespaceGetIndex(UA_Client *client, UA_String *namespaceUri, + UA_UInt16 *namespaceIndex); + +#ifndef HAVE_NODEITER_CALLBACK +#define HAVE_NODEITER_CALLBACK +/* Iterate over all nodes referenced by parentNodeId by calling the callback + function for each child node */ +typedef UA_StatusCode (*UA_NodeIteratorCallback)(UA_NodeId childId, UA_Boolean isInverse, + UA_NodeId referenceTypeId, void *handle); +#endif + +UA_StatusCode UA_EXPORT +UA_Client_forEachChildNodeCall(UA_Client *client, UA_NodeId parentNodeId, + UA_NodeIteratorCallback callback, void *handle); + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/client_subscriptions.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + + + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_SUBSCRIPTIONS + +/** + * .. _client-subscriptions: + * + * Subscriptions + * ------------- + * + * Subscriptions in OPC UA are asynchronous. That is, the client sends several + * PublishRequests to the server. The server returns PublishResponses with + * notifications. But only when a notification has been generated. The client + * does not wait for the responses and continues normal operations. + * + * Note the difference between Subscriptions and MonitoredItems. Subscriptions + * are used to report back notifications. MonitoredItems are used to generate + * notifications. Every MonitoredItem is attached to exactly one Subscription. + * And a Subscription can contain many MonitoredItems. + * + * The client automatically processes PublishResponses (with a callback) in the + * background and keeps enough PublishRequests in transit. The PublishResponses + * may be recieved during a synchronous service call or in + * ``UA_Client_run_iterate``. See more about + * :ref:`asynchronicity`. + */ + +/* Callbacks defined for Subscriptions */ +typedef void (*UA_Client_DeleteSubscriptionCallback) + (UA_Client *client, UA_UInt32 subId, void *subContext); + +typedef void (*UA_Client_StatusChangeNotificationCallback) + (UA_Client *client, UA_UInt32 subId, void *subContext, + UA_StatusChangeNotification *notification); + +/* Provides default values for a new subscription. + * + * RequestedPublishingInterval: 500.0 [ms] + * RequestedLifetimeCount: 10000 + * RequestedMaxKeepAliveCount: 10 + * MaxNotificationsPerPublish: 0 (unlimited) + * PublishingEnabled: true + * Priority: 0 */ +static UA_INLINE UA_CreateSubscriptionRequest +UA_CreateSubscriptionRequest_default(void) { + UA_CreateSubscriptionRequest request; + UA_CreateSubscriptionRequest_init(&request); + + request.requestedPublishingInterval = 500.0; + request.requestedLifetimeCount = 10000; + request.requestedMaxKeepAliveCount = 10; + request.maxNotificationsPerPublish = 0; + request.publishingEnabled = true; + request.priority = 0; + return request; +} + +UA_CreateSubscriptionResponse UA_EXPORT +UA_Client_Subscriptions_create(UA_Client *client, + const UA_CreateSubscriptionRequest request, + void *subscriptionContext, + UA_Client_StatusChangeNotificationCallback statusChangeCallback, + UA_Client_DeleteSubscriptionCallback deleteCallback); + +UA_StatusCode UA_EXPORT +UA_Client_Subscriptions_create_async(UA_Client *client, + const UA_CreateSubscriptionRequest request, + void *subscriptionContext, + UA_Client_StatusChangeNotificationCallback statusChangeCallback, + UA_Client_DeleteSubscriptionCallback deleteCallback, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId); + +UA_ModifySubscriptionResponse UA_EXPORT +UA_Client_Subscriptions_modify(UA_Client *client, + const UA_ModifySubscriptionRequest request); + +UA_StatusCode UA_EXPORT +UA_Client_Subscriptions_modify_async(UA_Client *client, + const UA_ModifySubscriptionRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId); + +UA_DeleteSubscriptionsResponse UA_EXPORT +UA_Client_Subscriptions_delete(UA_Client *client, + const UA_DeleteSubscriptionsRequest request); + +UA_StatusCode UA_EXPORT +UA_Client_Subscriptions_delete_async(UA_Client *client, + const UA_DeleteSubscriptionsRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Delete a single subscription */ +UA_StatusCode UA_EXPORT +UA_Client_Subscriptions_deleteSingle(UA_Client *client, UA_UInt32 subscriptionId); + +static UA_INLINE UA_SetPublishingModeResponse +UA_Client_Subscriptions_setPublishingMode(UA_Client *client, + const UA_SetPublishingModeRequest request) { + UA_SetPublishingModeResponse response; + __UA_Client_Service(client, + &request, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODEREQUEST], + &response, &UA_TYPES[UA_TYPES_SETPUBLISHINGMODERESPONSE]); + return response; +} + +/** + * MonitoredItems + * -------------- + * + * MonitoredItems for Events indicate the ``EventNotifier`` attribute. This + * indicates to the server not to monitor changes of the attribute, but to + * forward Event notifications from that node. + * + * During the creation of a MonitoredItem, the server may return changed + * adjusted parameters. Check the returned ``UA_CreateMonitoredItemsResponse`` + * to get the current parameters. */ + +/* Provides default values for a new monitored item. */ +static UA_INLINE UA_MonitoredItemCreateRequest +UA_MonitoredItemCreateRequest_default(UA_NodeId nodeId) { + UA_MonitoredItemCreateRequest request; + UA_MonitoredItemCreateRequest_init(&request); + request.itemToMonitor.nodeId = nodeId; + request.itemToMonitor.attributeId = UA_ATTRIBUTEID_VALUE; + request.monitoringMode = UA_MONITORINGMODE_REPORTING; + request.requestedParameters.samplingInterval = 250; + request.requestedParameters.discardOldest = true; + request.requestedParameters.queueSize = 1; + return request; +} + +/** + * The clientHandle parameter cannot be set by the user, any value will be replaced + * by the client before sending the request to the server. */ + +/* Callback for the deletion of a MonitoredItem */ +typedef void (*UA_Client_DeleteMonitoredItemCallback) + (UA_Client *client, UA_UInt32 subId, void *subContext, + UA_UInt32 monId, void *monContext); + +/* Callback for DataChange notifications */ +typedef void (*UA_Client_DataChangeNotificationCallback) + (UA_Client *client, UA_UInt32 subId, void *subContext, + UA_UInt32 monId, void *monContext, + UA_DataValue *value); + +/* Callback for Event notifications */ +typedef void (*UA_Client_EventNotificationCallback) + (UA_Client *client, UA_UInt32 subId, void *subContext, + UA_UInt32 monId, void *monContext, + size_t nEventFields, UA_Variant *eventFields); + +/* Don't use to monitor the EventNotifier attribute */ +UA_CreateMonitoredItemsResponse UA_EXPORT +UA_Client_MonitoredItems_createDataChanges(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, void **contexts, + UA_Client_DataChangeNotificationCallback *callbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks); + +UA_StatusCode UA_EXPORT +UA_Client_MonitoredItems_createDataChanges_async(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, void **contexts, + UA_Client_DataChangeNotificationCallback *callbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks, + UA_ClientAsyncServiceCallback createCallback, + void *userdata, UA_UInt32 *requestId); + +UA_MonitoredItemCreateResult UA_EXPORT +UA_Client_MonitoredItems_createDataChange(UA_Client *client, + UA_UInt32 subscriptionId, + UA_TimestampsToReturn timestampsToReturn, + const UA_MonitoredItemCreateRequest item, + void *context, UA_Client_DataChangeNotificationCallback callback, + UA_Client_DeleteMonitoredItemCallback deleteCallback); + +/* Monitor the EventNotifier attribute only */ +UA_CreateMonitoredItemsResponse UA_EXPORT +UA_Client_MonitoredItems_createEvents(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, void **contexts, + UA_Client_EventNotificationCallback *callback, + UA_Client_DeleteMonitoredItemCallback *deleteCallback); + +/* Monitor the EventNotifier attribute only */ +UA_StatusCode UA_EXPORT +UA_Client_MonitoredItems_createEvents_async(UA_Client *client, + const UA_CreateMonitoredItemsRequest request, void **contexts, + UA_Client_EventNotificationCallback *callbacks, + UA_Client_DeleteMonitoredItemCallback *deleteCallbacks, + UA_ClientAsyncServiceCallback createCallback, + void *userdata, UA_UInt32 *requestId); + +UA_MonitoredItemCreateResult UA_EXPORT +UA_Client_MonitoredItems_createEvent(UA_Client *client, + UA_UInt32 subscriptionId, + UA_TimestampsToReturn timestampsToReturn, + const UA_MonitoredItemCreateRequest item, + void *context, UA_Client_EventNotificationCallback callback, + UA_Client_DeleteMonitoredItemCallback deleteCallback); + +UA_DeleteMonitoredItemsResponse UA_EXPORT +UA_Client_MonitoredItems_delete(UA_Client *client, + const UA_DeleteMonitoredItemsRequest); + +UA_StatusCode UA_EXPORT +UA_Client_MonitoredItems_delete_async(UA_Client *client, + const UA_DeleteMonitoredItemsRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId); + +UA_StatusCode UA_EXPORT +UA_Client_MonitoredItems_deleteSingle(UA_Client *client, + UA_UInt32 subscriptionId, UA_UInt32 monitoredItemId); + +/* The clientHandle parameter will be filled automatically */ +UA_ModifyMonitoredItemsResponse UA_EXPORT +UA_Client_MonitoredItems_modify(UA_Client *client, + const UA_ModifyMonitoredItemsRequest request); + +/** + * The following service calls go directly to the server. The MonitoredItem + * settings are not stored in the client. */ + +static UA_INLINE UA_SetMonitoringModeResponse +UA_Client_MonitoredItems_setMonitoringMode(UA_Client *client, + const UA_SetMonitoringModeRequest request) { + UA_SetMonitoringModeResponse response; + __UA_Client_Service(client, + &request, &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST], + &response, &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE]); + return response; +} + +static UA_INLINE UA_SetTriggeringResponse +UA_Client_MonitoredItems_setTriggering(UA_Client *client, + const UA_SetTriggeringRequest request) { + UA_SetTriggeringResponse response; + __UA_Client_Service(client, + &request, &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST], + &response, &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE]); + return response; +} + +static UA_INLINE UA_StatusCode +UA_Client_MonitoredItems_modify_async(UA_Client *client, + const UA_ModifyMonitoredItemsRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId) { + return __UA_Client_AsyncService(client, &request, + &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSREQUEST], callback, + &UA_TYPES[UA_TYPES_MODIFYMONITOREDITEMSRESPONSE], + userdata, requestId); +} + +static UA_INLINE UA_StatusCode +UA_Client_MonitoredItems_setMonitoringMode_async(UA_Client *client, + const UA_SetMonitoringModeRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId) { + return __UA_Client_AsyncService(client, &request, + &UA_TYPES[UA_TYPES_SETMONITORINGMODEREQUEST], callback, + &UA_TYPES[UA_TYPES_SETMONITORINGMODERESPONSE], + userdata, requestId); +} + +static UA_INLINE UA_StatusCode +UA_Client_MonitoredItems_setTriggering_async(UA_Client *client, + const UA_SetTriggeringRequest request, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *requestId) { + return __UA_Client_AsyncService(client, &request, + &UA_TYPES[UA_TYPES_SETTRIGGERINGREQUEST], callback, + &UA_TYPES[UA_TYPES_SETTRIGGERINGRESPONSE], + userdata, requestId); +} + +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/client_highlevel_async.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2018 (c) Thomas Stalder, Blue Time Concept SA + * Copyright 2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + + +_UA_BEGIN_DECLS + +/** + * Async Services + * ^^^^^^^^^^^^^^ + * + * Call OPC UA Services asynchronously with a callback. The (optional) requestId + * output can be used to cancel the service while it is still pending. */ + +typedef void (*UA_ClientAsyncReadCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_ReadResponse *rr); +static UA_INLINE UA_StatusCode +UA_Client_sendAsyncReadRequest(UA_Client *client, UA_ReadRequest *request, + UA_ClientAsyncReadCallback readCallback, void *userdata, + UA_UInt32 *reqId) { + return UA_Client_sendAsyncRequest(client, request, &UA_TYPES[UA_TYPES_READREQUEST], + (UA_ClientAsyncServiceCallback)readCallback, + &UA_TYPES[UA_TYPES_READRESPONSE], userdata, reqId); +} + +typedef void (*UA_ClientAsyncWriteCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_WriteResponse *wr); +static UA_INLINE UA_StatusCode +UA_Client_sendAsyncWriteRequest(UA_Client *client, UA_WriteRequest *request, + UA_ClientAsyncWriteCallback writeCallback, void *userdata, + UA_UInt32 *reqId) { + return UA_Client_sendAsyncRequest(client, request, &UA_TYPES[UA_TYPES_WRITEREQUEST], + (UA_ClientAsyncServiceCallback)writeCallback, + &UA_TYPES[UA_TYPES_WRITERESPONSE], userdata, reqId); +} + +typedef void (*UA_ClientAsyncBrowseCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_BrowseResponse *wr); +static UA_INLINE UA_StatusCode +UA_Client_sendAsyncBrowseRequest(UA_Client *client, UA_BrowseRequest *request, + UA_ClientAsyncBrowseCallback browseCallback, + void *userdata, UA_UInt32 *reqId) { + return UA_Client_sendAsyncRequest(client, request, &UA_TYPES[UA_TYPES_BROWSEREQUEST], + (UA_ClientAsyncServiceCallback)browseCallback, + &UA_TYPES[UA_TYPES_BROWSERESPONSE], userdata, + reqId); +} + +/** + * Asynchronous Operations + * ^^^^^^^^^^^^^^^^^^^^^^^ + * + * Many Services can be called with an array of operations. For example, a + * request to the Read Service contains an array of ReadValueId, each + * corresponding to a single read operation. For convenience, wrappers are + * provided to call single operations for the most common Services. + * + * All async operations have a callback of the following structure: The returned + * StatusCode is split in two parts. The status indicates the overall success of + * the request and the operation. The result argument is non-NULL only if the + * status is no good. */ +typedef void +(*UA_ClientAsyncOperationCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + void *result); + +/** + * Read Attribute + * ^^^^^^^^^^^^^^ + * + * Asynchronously read a single attribute. The attribute is unpacked from the + * response as the datatype of the attribute is known ahead of time. Value + * attributes are variants. + * + * Note that the last argument (value pointer) of the callbacks can be NULL if + * the status of the operation is not good. */ + +/* Reading a single attribute */ +typedef void +(*UA_ClientAsyncReadAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_DataValue *attribute); +UA_StatusCode UA_EXPORT +UA_Client_readAttribute_async(UA_Client *client, const UA_ReadValueId *rvi, + UA_TimestampsToReturn timestampsToReturn, + UA_ClientAsyncReadAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single Value attribute */ +typedef void +(*UA_ClientAsyncReadValueAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_DataValue *value); +UA_StatusCode UA_EXPORT +UA_Client_readValueAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadValueAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single DataType attribute */ +typedef void +(*UA_ClientAsyncReadDataTypeAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_NodeId *dataType); +UA_StatusCode UA_EXPORT +UA_Client_readDataTypeAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadDataTypeAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single ArrayDimensions attribute. If the status is good, the variant + * carries an UInt32 array. */ +typedef void +(*UA_ClientReadArrayDimensionsAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Variant *arrayDimensions); +UA_StatusCode UA_EXPORT +UA_Client_readArrayDimensionsAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientReadArrayDimensionsAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single NodeClass attribute */ +typedef void +(*UA_ClientAsyncReadNodeClassAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_NodeClass *nodeClass); +UA_StatusCode UA_EXPORT +UA_Client_readNodeClassAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadNodeClassAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single BrowseName attribute */ +typedef void +(*UA_ClientAsyncReadBrowseNameAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_QualifiedName *browseName); +UA_StatusCode UA_EXPORT +UA_Client_readBrowseNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadBrowseNameAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single DisplayName attribute */ +typedef void +(*UA_ClientAsyncReadDisplayNameAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_LocalizedText *displayName); +UA_StatusCode UA_EXPORT +UA_Client_readDisplayNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadDisplayNameAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single Description attribute */ +typedef void +(*UA_ClientAsyncReadDescriptionAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_LocalizedText *description); +UA_StatusCode UA_EXPORT +UA_Client_readDescriptionAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadDescriptionAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single WriteMask attribute */ +typedef void +(*UA_ClientAsyncReadWriteMaskAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_UInt32 *writeMask); +UA_StatusCode UA_EXPORT +UA_Client_readWriteMaskAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadWriteMaskAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single UserWriteMask attribute */ +typedef void +(*UA_ClientAsyncReadUserWriteMaskAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_UInt32 *writeMask); +UA_StatusCode UA_EXPORT +UA_Client_readUserWriteMaskAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadUserWriteMaskAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single IsAbstract attribute */ +typedef void +(*UA_ClientAsyncReadIsAbstractAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Boolean *isAbstract); +UA_StatusCode UA_EXPORT +UA_Client_readIsAbstractAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadIsAbstractAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single Symmetric attribute */ +typedef void +(*UA_ClientAsyncReadSymmetricAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Boolean *symmetric); +UA_StatusCode UA_EXPORT +UA_Client_readSymmetricAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadSymmetricAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single InverseName attribute */ +typedef void +(*UA_ClientAsyncReadInverseNameAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_LocalizedText *inverseName); +UA_StatusCode UA_EXPORT +UA_Client_readInverseNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadInverseNameAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single ContainsNoLoops attribute */ +typedef void +(*UA_ClientAsyncReadContainsNoLoopsAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Boolean *containsNoLoops); +UA_StatusCode UA_EXPORT +UA_Client_readContainsNoLoopsAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadContainsNoLoopsAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single EventNotifier attribute */ +typedef void +(*UA_ClientAsyncReadEventNotifierAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Byte *eventNotifier); +UA_StatusCode UA_EXPORT +UA_Client_readEventNotifierAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadEventNotifierAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single ValueRank attribute */ +typedef void +(*UA_ClientAsyncReadValueRankAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Int32 *valueRank); +UA_StatusCode UA_EXPORT +UA_Client_readValueRankAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadValueRankAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single AccessLevel attribute */ +typedef void +(*UA_ClientAsyncReadAccessLevelAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Byte *accessLevel); +UA_StatusCode UA_EXPORT +UA_Client_readAccessLevelAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadAccessLevelAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single UserAccessLevel attribute */ +typedef void +(*UA_ClientAsyncReadUserAccessLevelAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Byte *userAccessLevel); +UA_StatusCode UA_EXPORT +UA_Client_readUserAccessLevelAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadUserAccessLevelAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single MinimumSamplingInterval attribute */ +typedef void +(*UA_ClientAsyncReadMinimumSamplingIntervalAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Double *minimumSamplingInterval); +UA_StatusCode UA_EXPORT +UA_Client_readMinimumSamplingIntervalAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadMinimumSamplingIntervalAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single Historizing attribute */ +typedef void +(*UA_ClientAsyncReadHistorizingAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Boolean *historizing); +UA_StatusCode UA_EXPORT +UA_Client_readHistorizingAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadHistorizingAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single Executable attribute */ +typedef void +(*UA_ClientAsyncReadExecutableAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Boolean *executable); +UA_StatusCode UA_EXPORT +UA_Client_readExecutableAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadExecutableAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/* Read a single UserExecutable attribute */ +typedef void +(*UA_ClientAsyncReadUserExecutableAttributeCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_StatusCode status, + UA_Boolean *userExecutable); +UA_StatusCode UA_EXPORT +UA_Client_readUserExecutableAttribute_async(UA_Client *client, const UA_NodeId nodeId, + UA_ClientAsyncReadUserExecutableAttributeCallback callback, + void *userdata, UA_UInt32 *requestId); + +/** + * Write Attribute + * ^^^^^^^^^^^^^^ */ + +UA_StatusCode UA_EXPORT +__UA_Client_writeAttribute_async(UA_Client *client, const UA_NodeId *nodeId, + UA_AttributeId attributeId, const void *in, + const UA_DataType *inDataType, + UA_ClientAsyncServiceCallback callback, void *userdata, + UA_UInt32 *reqId); + +static UA_INLINE UA_StatusCode +UA_Client_writeValueAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Variant *newValue, + UA_ClientAsyncWriteCallback callback, void *userdata, + UA_UInt32 *reqId) { + + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_VALUE, newValue, &UA_TYPES[UA_TYPES_VARIANT], + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_writeNodeIdAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_NodeId *outNodeId, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_NODEID, + outNodeId, &UA_TYPES[UA_TYPES_NODEID], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeNodeClassAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_NodeClass *outNodeClass, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_NODECLASS, + outNodeClass, &UA_TYPES[UA_TYPES_NODECLASS], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeBrowseNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_QualifiedName *outBrowseName, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_BROWSENAME, outBrowseName, + &UA_TYPES[UA_TYPES_QUALIFIEDNAME], callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeDisplayNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_LocalizedText *outDisplayName, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_DISPLAYNAME, outDisplayName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeDescriptionAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_LocalizedText *outDescription, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_DESCRIPTION, outDescription, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeWriteMaskAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_UInt32 *outWriteMask, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_WRITEMASK, + outWriteMask, &UA_TYPES[UA_TYPES_UINT32], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeUserWriteMaskAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_UInt32 *outUserWriteMask, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_USERWRITEMASK, + outUserWriteMask, &UA_TYPES[UA_TYPES_UINT32], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeIsAbstractAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *outIsAbstract, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_ISABSTRACT, + outIsAbstract, &UA_TYPES[UA_TYPES_BOOLEAN], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeSymmetricAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *outSymmetric, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_SYMMETRIC, + outSymmetric, &UA_TYPES[UA_TYPES_BOOLEAN], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeInverseNameAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_LocalizedText *outInverseName, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_INVERSENAME, outInverseName, + &UA_TYPES[UA_TYPES_LOCALIZEDTEXT], callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeContainsNoLoopsAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *outContainsNoLoops, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_CONTAINSNOLOOPS, outContainsNoLoops, + &UA_TYPES[UA_TYPES_BOOLEAN], callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeEventNotifierAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Byte *outEventNotifier, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_EVENTNOTIFIER, + outEventNotifier, &UA_TYPES[UA_TYPES_BYTE], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeDataTypeAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_NodeId *outDataType, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_DATATYPE, + outDataType, &UA_TYPES[UA_TYPES_NODEID], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeValueRankAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Int32 *outValueRank, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_VALUERANK, + outValueRank, &UA_TYPES[UA_TYPES_INT32], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeAccessLevelAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Byte *outAccessLevel, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_ACCESSLEVEL, + outAccessLevel, &UA_TYPES[UA_TYPES_BYTE], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeUserAccessLevelAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Byte *outUserAccessLevel, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_USERACCESSLEVEL, outUserAccessLevel, + &UA_TYPES[UA_TYPES_BYTE], callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeMinimumSamplingIntervalAttribute_async( + UA_Client *client, const UA_NodeId nodeId, + const UA_Double *outMinimumSamplingInterval, UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL, + outMinimumSamplingInterval, &UA_TYPES[UA_TYPES_DOUBLE], callback, userdata, + reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeHistorizingAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *outHistorizing, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_HISTORIZING, + outHistorizing, &UA_TYPES[UA_TYPES_BOOLEAN], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeExecutableAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *outExecutable, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async(client, &nodeId, UA_ATTRIBUTEID_EXECUTABLE, + outExecutable, &UA_TYPES[UA_TYPES_BOOLEAN], + callback, userdata, reqId); +} +static UA_INLINE UA_StatusCode +UA_Client_writeUserExecutableAttribute_async(UA_Client *client, const UA_NodeId nodeId, + const UA_Boolean *outUserExecutable, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId) { + return __UA_Client_writeAttribute_async( + client, &nodeId, UA_ATTRIBUTEID_USEREXECUTABLE, outUserExecutable, + &UA_TYPES[UA_TYPES_BOOLEAN], callback, userdata, reqId); +} + +/** + * Method Calling + * ^^^^^^^^^^^^^^ */ +#ifdef UA_ENABLE_METHODCALLS +UA_StatusCode UA_EXPORT +__UA_Client_call_async(UA_Client *client, const UA_NodeId objectId, + const UA_NodeId methodId, size_t inputSize, + const UA_Variant *input, UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId); + +typedef void (*UA_ClientAsyncCallCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, UA_CallResponse *cr); + +static UA_INLINE UA_StatusCode +UA_Client_call_async(UA_Client *client, const UA_NodeId objectId, + const UA_NodeId methodId, size_t inputSize, const UA_Variant *input, + UA_ClientAsyncCallCallback callback, void *userdata, + UA_UInt32 *reqId) { + return __UA_Client_call_async(client, objectId, methodId, inputSize, input, + (UA_ClientAsyncServiceCallback)callback, userdata, + reqId); +} +#endif + +/** + * Node Management + * ^^^^^^^^^^^^^^^ */ +typedef void (*UA_ClientAsyncAddNodesCallback)(UA_Client *client, void *userdata, + UA_UInt32 requestId, + UA_AddNodesResponse *ar); + +UA_StatusCode UA_EXPORT +__UA_Client_addNode_async(UA_Client *client, const UA_NodeClass nodeClass, + const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, const UA_NodeAttributes *attr, + const UA_DataType *attributeType, UA_NodeId *outNewNodeId, + UA_ClientAsyncServiceCallback callback, void *userdata, + UA_UInt32 *reqId); + +static UA_INLINE UA_StatusCode +UA_Client_addVariableNode_async(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_VariableAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, + UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_VARIABLE, requestedNewNodeId, parentNodeId, referenceTypeId, + browseName, typeDefinition, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_VARIABLEATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addVariableTypeNode_async( + UA_Client *client, const UA_NodeId requestedNewNodeId, const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, const UA_QualifiedName browseName, + const UA_VariableTypeAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_VARIABLETYPE, requestedNewNodeId, parentNodeId, + referenceTypeId, browseName, UA_NODEID_NULL, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_VARIABLETYPEATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addObjectNode_async(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_NodeId typeDefinition, + const UA_ObjectAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, + UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_OBJECT, requestedNewNodeId, parentNodeId, referenceTypeId, + browseName, typeDefinition, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_OBJECTATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addObjectTypeNode_async( + UA_Client *client, const UA_NodeId requestedNewNodeId, const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, const UA_QualifiedName browseName, + const UA_ObjectTypeAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_OBJECTTYPE, requestedNewNodeId, parentNodeId, + referenceTypeId, browseName, UA_NODEID_NULL, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_OBJECTTYPEATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addViewNode_async(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_ViewAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, + UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_VIEW, requestedNewNodeId, parentNodeId, referenceTypeId, + browseName, UA_NODEID_NULL, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_VIEWATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addReferenceTypeNode_async( + UA_Client *client, const UA_NodeId requestedNewNodeId, const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, const UA_QualifiedName browseName, + const UA_ReferenceTypeAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_REFERENCETYPE, requestedNewNodeId, parentNodeId, + referenceTypeId, browseName, UA_NODEID_NULL, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_REFERENCETYPEATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addDataTypeNode_async(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_DataTypeAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, + UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_DATATYPE, requestedNewNodeId, parentNodeId, referenceTypeId, + browseName, UA_NODEID_NULL, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_DATATYPEATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +static UA_INLINE UA_StatusCode +UA_Client_addMethodNode_async(UA_Client *client, const UA_NodeId requestedNewNodeId, + const UA_NodeId parentNodeId, + const UA_NodeId referenceTypeId, + const UA_QualifiedName browseName, + const UA_MethodAttributes attr, UA_NodeId *outNewNodeId, + UA_ClientAsyncAddNodesCallback callback, void *userdata, + UA_UInt32 *reqId) { + return __UA_Client_addNode_async( + client, UA_NODECLASS_METHOD, requestedNewNodeId, parentNodeId, referenceTypeId, + browseName, UA_NODEID_NULL, (const UA_NodeAttributes *)&attr, + &UA_TYPES[UA_TYPES_METHODATTRIBUTES], outNewNodeId, + (UA_ClientAsyncServiceCallback)callback, userdata, reqId); +} + +/** + * Misc Functionalities + * ^^^^^^^^^^^^^^^^^^^^ */ + +UA_DEPRECATED UA_StatusCode UA_EXPORT +__UA_Client_translateBrowsePathsToNodeIds_async(UA_Client *client, char *paths[], + UA_UInt32 ids[], size_t pathSize, + UA_ClientAsyncServiceCallback callback, + void *userdata, UA_UInt32 *reqId); + +typedef void (*UA_ClientAsyncTranslateCallback)( + UA_Client *client, void *userdata, UA_UInt32 requestId, + UA_TranslateBrowsePathsToNodeIdsResponse *tr); + +UA_DEPRECATED UA_StatusCode UA_EXPORT +UA_Cient_translateBrowsePathsToNodeIds_async(UA_Client *client, char **paths, + UA_UInt32 *ids, size_t pathSize, + UA_ClientAsyncTranslateCallback callback, + void *userdata, UA_UInt32 *reqId); + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/plugin/accesscontrol_default.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016-2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + */ + + + +_UA_BEGIN_DECLS + +typedef struct { + UA_String username; + UA_String password; +} UA_UsernamePasswordLogin; + +/* Default access control. The log-in can be anonymous or username-password. A + * logged-in user has all access rights. + * + * The certificate verification plugin lifecycle is moved to the access control + * system. So it is cleared up eventually together with the AccessControl. */ +UA_EXPORT UA_StatusCode +UA_AccessControl_default(UA_ServerConfig *config, + UA_Boolean allowAnonymous, + UA_CertificateVerification *verifyX509, + const UA_ByteString *userTokenPolicyUri, + size_t usernamePasswordLoginSize, + const UA_UsernamePasswordLogin *usernamePasswordLogin); + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/plugin/pki_default.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2019 (c) Kalycito Infotech Private Limited + */ + + + +_UA_BEGIN_DECLS + +/* Default implementation that accepts all certificates */ +UA_EXPORT void +UA_CertificateVerification_AcceptAll(UA_CertificateVerification *cv); + +#ifdef UA_ENABLE_ENCRYPTION + +/* Accept certificates based on a trust-list and a revocation-list. Based on + * mbedTLS. */ +UA_EXPORT UA_StatusCode +UA_CertificateVerification_Trustlist(UA_CertificateVerification *cv, + const UA_ByteString *certificateTrustList, + size_t certificateTrustListSize, + const UA_ByteString *certificateIssuerList, + size_t certificateIssuerListSize, + const UA_ByteString *certificateRevocationList, + size_t certificateRevocationListSize); + +#ifdef __linux__ /* Linux only so far */ +UA_EXPORT UA_StatusCode +UA_CertificateVerification_CertFolders(UA_CertificateVerification *cv, + const char *trustListFolder, + const char *issuerListFolder, + const char *revocationListFolder); +#endif + +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/plugin/log_stdout.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016, 2018 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + + +_UA_BEGIN_DECLS + +extern UA_EXPORT const UA_Logger UA_Log_Stdout_; /* Logger structure */ +extern UA_EXPORT const UA_Logger *UA_Log_Stdout; /* Shorthand pointer */ + +/* Don't use these definitions. They are only exported as long as the client + * config is static and required compile-time */ +UA_EXPORT void +UA_Log_Stdout_log(void *_, UA_LogLevel level, UA_LogCategory category, + const char *msg, va_list args); +UA_EXPORT void +UA_Log_Stdout_clear(void *logContext); + +/* By default the client and server is configured with UA_Log_Stdout + This constructs a logger with a configurable max log level */ + +UA_EXPORT UA_Logger UA_Log_Stdout_withLevel(UA_LogLevel minlevel); + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/plugin/nodestore_default.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2019 (c) Julius Pfrommer, Fraunhofer IOSB + */ + + + +_UA_BEGIN_DECLS + +/* The HashMap Nodestore holds all nodes in RAM in single hash-map. Lookip is + * done based on hashing/comparison of the NodeId with close to O(1) lookup + * time. However, sometimes the underlying array has to be resized when nodes + * are added/removed. This can take O(n) time. */ +UA_EXPORT UA_StatusCode +UA_Nodestore_HashMap(UA_Nodestore *ns); + +/* The ZipTree Nodestore holds all nodes in RAM in a tree structure. The lookup + * time is about O(log n). Adding/removing nodes does not require resizing of + * the underlying array with the linear overhead. + * + * For most usage scenarios the hash-map Nodestore will be faster. + */ +UA_EXPORT UA_StatusCode +UA_Nodestore_ZipTree(UA_Nodestore *ns); + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/server_config_default.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2019 (c) Kalycito Infotech Private Limited + */ + + + +_UA_BEGIN_DECLS + +/* Create a new server with default plugins for logging etc. used during + * initialization. No network layer and SecurityPolicies are set so far. */ +UA_Server UA_EXPORT * UA_Server_new(void); + +/**********************/ +/* Default Connection */ +/**********************/ + +extern const UA_EXPORT +UA_ConnectionConfig UA_ConnectionConfig_default; + +/*************************/ +/* Default Server Config */ +/*************************/ + +/* Creates a new server config with one endpoint and custom buffer size. + * + * The config will set the tcp network layer to the given port and adds a single + * endpoint with the security policy ``SecurityPolicy#None`` to the server. A + * server certificate may be supplied but is optional. + * Additionally you can define a custom buffer size for send and receive buffer. + * + * @param portNumber The port number for the tcp network layer + * @param certificate Optional certificate for the server endpoint. Can be + * ``NULL``. + * @param sendBufferSize The size in bytes for the network send buffer + * @param recvBufferSize The size in bytes for the network receive buffer + * + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_setMinimalCustomBuffer(UA_ServerConfig *config, + UA_UInt16 portNumber, + const UA_ByteString *certificate, + UA_UInt32 sendBufferSize, + UA_UInt32 recvBufferSize); + +/* Creates a new server config with one endpoint. + * + * The config will set the tcp network layer to the given port and adds a single + * endpoint with the security policy ``SecurityPolicy#None`` to the server. A + * server certificate may be supplied but is optional. */ +static UA_INLINE UA_StatusCode +UA_ServerConfig_setMinimal(UA_ServerConfig *config, UA_UInt16 portNumber, + const UA_ByteString *certificate) { + return UA_ServerConfig_setMinimalCustomBuffer(config, portNumber, + certificate, 0, 0); +} + +#ifdef UA_ENABLE_ENCRYPTION + +UA_EXPORT UA_StatusCode +UA_ServerConfig_setDefaultWithSecurityPolicies(UA_ServerConfig *conf, + UA_UInt16 portNumber, + const UA_ByteString *certificate, + const UA_ByteString *privateKey, + const UA_ByteString *trustList, + size_t trustListSize, + const UA_ByteString *issuerList, + size_t issuerListSize, + const UA_ByteString *revocationList, + size_t revocationListSize); + +#endif + +/* Creates a server config on the default port 4840 with no server + * certificate. */ +static UA_INLINE UA_StatusCode +UA_ServerConfig_setDefault(UA_ServerConfig *config) { + return UA_ServerConfig_setMinimal(config, 4840, NULL); +} + +/* Creates a new server config with no network layer and no endpoints. + * + * It initializes reasonable defaults for many things, but does not + * add any network layer, security policies and endpoints. + * Use the various UA_ServerConfig_addXxx functions to add them. + * + * @param conf The configuration to manipulate + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_setBasics(UA_ServerConfig *conf); + +/* Adds a TCP network layer with custom buffer sizes + * + * @param conf The configuration to manipulate + * @param portNumber The port number for the tcp network layer + * @param sendBufferSize The size in bytes for the network send buffer. Pass 0 + * to use defaults. + * @param recvBufferSize The size in bytes for the network receive buffer. + * Pass 0 to use defaults. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addNetworkLayerTCP(UA_ServerConfig *conf, UA_UInt16 portNumber, + UA_UInt32 sendBufferSize, UA_UInt32 recvBufferSize); + +#ifdef UA_ENABLE_WEBSOCKET_SERVER +/* Adds a Websocket network layer with custom buffer sizes + * + * @param conf The configuration to manipulate + * @param portNumber The port number for the tcp network layer + * @param sendBufferSize The size in bytes for the network send buffer. Pass 0 + * to use defaults. + * @param recvBufferSize The size in bytes for the network receive buffer. + * Pass 0 to use defaults. + * @param certificate certificate data. Pass NULL to disable WS security + * @param privateKey privateKey data. Pass NULL to disable WS security + */ + +UA_EXPORT UA_StatusCode +UA_ServerConfig_addNetworkLayerWS(UA_ServerConfig *conf, UA_UInt16 portNumber, + UA_UInt32 sendBufferSize, UA_UInt32 recvBufferSize, const UA_ByteString* certificate, const UA_ByteString* privateKey); +#endif + +/* Adds the security policy ``SecurityPolicy#None`` to the server. A + * server certificate may be supplied but is optional. + * + * @param config The configuration to manipulate + * @param certificate The optional server certificate. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyNone(UA_ServerConfig *config, + const UA_ByteString *certificate); + +#ifdef UA_ENABLE_ENCRYPTION + +/* Adds the security policy ``SecurityPolicy#Basic128Rsa15`` to the server. A + * server certificate may be supplied but is optional. + * + * Certificate verification should be configured before calling this + * function. See PKI plugin. + * + * @param config The configuration to manipulate + * @param certificate The server certificate. + * @param privateKey The private key that corresponds to the certificate. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyBasic128Rsa15(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey); + +/* Adds the security policy ``SecurityPolicy#Basic256`` to the server. A + * server certificate may be supplied but is optional. + * + * Certificate verification should be configured before calling this + * function. See PKI plugin. + * + * @param config The configuration to manipulate + * @param certificate The server certificate. + * @param privateKey The private key that corresponds to the certificate. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyBasic256(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey); + +/* Adds the security policy ``SecurityPolicy#Basic256Sha256`` to the server. A + * server certificate may be supplied but is optional. + * + * Certificate verification should be configured before calling this + * function. See PKI plugin. + * + * @param config The configuration to manipulate + * @param certificate The server certificate. + * @param privateKey The private key that corresponds to the certificate. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyBasic256Sha256(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey); + +/* Adds the security policy ``SecurityPolicy#Aes128Sha256RsaOaep`` to the server. A + * server certificate may be supplied but is optional. + * + * Certificate verification should be configured before calling this + * function. See PKI plugin. + * + * @param config The configuration to manipulate + * @param certificate The server certificate. + * @param privateKey The private key that corresponds to the certificate. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addSecurityPolicyAes128Sha256RsaOaep(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey); + +/* Adds all supported security policies and sets up certificate + * validation procedures. + * + * Certificate verification should be configured before calling this + * function. See PKI plugin. + * + * @param config The configuration to manipulate + * @param certificate The server certificate. + * @param privateKey The private key that corresponds to the certificate. + * @param trustList The trustList for client certificate validation. + * @param trustListSize The trustList size. + * @param revocationList The revocationList for client certificate validation. + * @param revocationListSize The revocationList size. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addAllSecurityPolicies(UA_ServerConfig *config, + const UA_ByteString *certificate, + const UA_ByteString *privateKey); + +#endif + +/* Adds an endpoint for the given security policy and mode. The security + * policy has to be added already. See UA_ServerConfig_addXxx functions. + * + * @param config The configuration to manipulate + * @param securityPolicyUri The security policy for which to add the endpoint. + * @param securityMode The security mode for which to add the endpoint. + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addEndpoint(UA_ServerConfig *config, const UA_String securityPolicyUri, + UA_MessageSecurityMode securityMode); + +/* Adds endpoints for all configured security policies in each mode. + * + * @param config The configuration to manipulate + */ +UA_EXPORT UA_StatusCode +UA_ServerConfig_addAllEndpoints(UA_ServerConfig *config); + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/client_config_default.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2017 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Mark Giraud, Fraunhofer IOSB + */ + + + +_UA_BEGIN_DECLS + +UA_Client UA_EXPORT * UA_Client_new(void); + +UA_StatusCode UA_EXPORT +UA_ClientConfig_setDefault(UA_ClientConfig *config); + +#ifdef UA_ENABLE_ENCRYPTION +UA_StatusCode UA_EXPORT +UA_ClientConfig_setDefaultEncryption(UA_ClientConfig *config, + UA_ByteString localCertificate, UA_ByteString privateKey, + const UA_ByteString *trustList, size_t trustListSize, + const UA_ByteString *revocationList, size_t revocationListSize); +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/plugin/securitypolicy_default.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2017-2018 (c) Mark Giraud, Fraunhofer IOSB + * Copyright 2017 (c) Stefan Profanter, fortiss GmbH + * Copyright 2018 (c) Daniel Feist, Precitec GmbH & Co. KG + */ + + + +_UA_BEGIN_DECLS + +UA_EXPORT UA_StatusCode +UA_SecurityPolicy_None(UA_SecurityPolicy *policy, + const UA_ByteString localCertificate, + const UA_Logger *logger); + +#ifdef UA_ENABLE_ENCRYPTION + +UA_EXPORT UA_StatusCode +UA_SecurityPolicy_Basic128Rsa15(UA_SecurityPolicy *policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger *logger); + +UA_EXPORT UA_StatusCode +UA_SecurityPolicy_Basic256(UA_SecurityPolicy *policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger *logger); + +UA_EXPORT UA_StatusCode +UA_SecurityPolicy_Basic256Sha256(UA_SecurityPolicy *policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger *logger); + +UA_EXPORT UA_StatusCode +UA_SecurityPolicy_Aes128Sha256RsaOaep(UA_SecurityPolicy *policy, + const UA_ByteString localCertificate, + const UA_ByteString localPrivateKey, + const UA_Logger *logger); + +#endif + +#ifdef UA_ENABLE_PUBSUB_ENCRYPTION + +UA_EXPORT UA_StatusCode +UA_PubSubSecurityPolicy_Aes128Ctr(UA_PubSubSecurityPolicy *policy, + const UA_Logger *logger); +UA_EXPORT UA_StatusCode +UA_PubSubSecurityPolicy_Aes256Ctr(UA_PubSubSecurityPolicy *policy, + const UA_Logger *logger); + +#endif + +#ifdef UA_ENABLE_TPM2_SECURITY + +UA_EXPORT UA_StatusCode +UA_PubSubSecurityPolicy_Aes128CtrTPM(UA_PubSubSecurityPolicy *policy, char *userpin, unsigned long slotId, + char *encryptionKeyLabel, char *signingKeyLabel, const UA_Logger *logger); +UA_EXPORT UA_StatusCode +UA_PubSubSecurityPolicy_Aes256CtrTPM(UA_PubSubSecurityPolicy *policy, char *userpin, unsigned long slotId, + char *encryptionKeyLabel, char *signingKeyLabel, const UA_Logger *logger); + +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/plugin/log_syslog.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2020 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + */ + + + +_UA_BEGIN_DECLS + +/* Syslog-logging is available only for Linux/Unices. + * + * open62541 log levels are translated to syslog levels as follows: + * + * UA_LOGLEVEL_TRACE => not available for syslog + * UA_LOGLEVEL_DEBUG => LOG_DEBUG + * UA_LOGLEVEL_INFO => LOG_INFO + * UA_LOGLEVEL_WARNING => LOG_WARNING + * UA_LOGLEVEL_ERROR => LOG_ERR + * UA_LOGLEVEL_FATAL => LOG_CRIT + */ + +#if defined(__linux__) || defined(__unix__) + +/* Returns a syslog-logger for messages up to the specified level. + * The programm must call openlog(3) before using this logger. */ +UA_EXPORT UA_Logger +UA_Log_Syslog_withLevel(UA_LogLevel minlevel); + +/* Log all warning levels supported by syslog (no trace-warnings). + * The programm must call openlog(3) before using this logger. */ +UA_EXPORT UA_Logger +UA_Log_Syslog(void); + +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/plugins/include/open62541/plugin/create_certificate.h" ****/ + +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. + * + * Copyright 2021 (c) Christian von Arnim, ISW University of Stuttgart (for VDW and umati) + */ + + + +_UA_BEGIN_DECLS + +#ifdef UA_ENABLE_ENCRYPTION +typedef enum { + UA_CERTIFICATEFORMAT_DER, + UA_CERTIFICATEFORMAT_PEM +} UA_CertificateFormat; + +/** + * Create a self-signed certificate + * + * It is recommended to store the generated certificate on disk for reuse, so the + * application can be recognized across several executions. + * + * \param subject Elements for the subject, + * e.g. ["C=DE", "O=SampleOrganization", "CN=Open62541Server@localhost"] + * \param subjectAltName Elements for SubjectAltName, + * e.g. ["DNS:localhost", "URI:urn:open62541.server.application"] + * \param keySizeBits Size of the generated key in bits. If set to 0, the maximum key + * size is used. Possible values are: [0, 1024 (deprecated), 2048, 4096] + */ +UA_StatusCode UA_EXPORT +UA_CreateCertificate(const UA_Logger *logger, + const UA_String *subject, size_t subjectSize, + const UA_String *subjectAltName, size_t subjectAltNameSize, + size_t keySizeBits, UA_CertificateFormat certFormat, + UA_ByteString *outPrivateKey, UA_ByteString *outCertificate); +#endif + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/network_tcp.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2016 (c) Fraunhofer IOSB (Author: Julius Pfrommer) + * Copyright 2020 (c) HMS Industrial Networks AB (Author: Jonas Green) + */ + + + +_UA_BEGIN_DECLS + +/* Initializes a TCP network layer. + * + * @param config The connection config. + * @param port The TCP port to listen to. + * @param maxConnections Maximum number of TCP connections this network layer + * instance is allowed to allocate. Set to 0 for unlimited + * number of connections. + * @param logger Pointer to a logger + * @return Returns the network layer instance */ +UA_ServerNetworkLayer UA_EXPORT +UA_ServerNetworkLayerTCP(UA_ConnectionConfig config, UA_UInt16 port, + UA_UInt16 maxConnections); + +/* Open a non-blocking client TCP socket. The connection might not be fully + * opened yet. Drop into the _poll function withe a timeout to complete the + * connection. */ +UA_Connection UA_EXPORT +UA_ClientConnectionTCP_init(UA_ConnectionConfig config, const UA_String endpointUrl, + UA_UInt32 timeout, const UA_Logger *logger); + +/* Wait for a half-opened connection to fully open. Returns UA_STATUSCODE_GOOD + * even if the timeout was hit. Returns UA_STATUSCODE_BADDISCONNECT if the + * connection is lost. */ +UA_StatusCode UA_EXPORT +UA_ClientConnectionTCP_poll(UA_Connection *connection, UA_UInt32 timeout, + const UA_Logger *logger); + +_UA_END_DECLS + + +/**** amalgamated original file "/include/open62541/architecture_functions.h" ****/ + +/* This work is licensed under a Creative Commons CCZero 1.0 Universal License. + * See http://creativecommons.org/publicdomain/zero/1.0/ for more information. + * + * Copyright 2018 (c) Jose Cabral, fortiss GmbH + */ + +/* + * This header has all the functions that are architecture dependent. The + * declaration is behind an ifndef since they can be previously defined in the + * ua_architecture.h which include this files at the end + */ + + + +_UA_BEGIN_DECLS + +/* Sleep function */ +#ifndef UA_sleep_ms +int UA_sleep_ms(unsigned int miliSeconds); //suspend the thread for a certain amount of mili seconds +#endif + +/* Socket functions */ +#ifndef UA_send +ssize_t UA_send(UA_SOCKET sockfd, const void *buf, size_t len, int flags); //equivalent to posix send implementation +#endif + +#ifndef UA_sendto +ssize_t UA_sendto(UA_SOCKET sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen); //equivalent to posix sendto implementation +#endif + +#ifndef UA_select +int UA_select(UA_SOCKET nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout); //equivalent to posix select implementation +#endif + +#ifndef UA_recv +ssize_t UA_recv(UA_SOCKET sockfd, void *buf, size_t len, int flags); //equivalent to posix recv implementation +#endif + +#ifndef UA_recvfrom +ssize_t UA_recvfrom(UA_SOCKET sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);//equivalent to posix recvfrom implementation +#endif + +#ifndef UA_recvmsg +ssize_t UA_recvmsg(int sockfd, struct msghdr *msg, int flags);//equivalent to posix recvmsg implementation +#endif + +#ifndef UA_shutdown +int UA_shutdown(UA_SOCKET sockfd, int how); //equivalent to posix shutdown implementation +#endif + +#ifndef UA_socket +UA_SOCKET UA_socket(int domain, int type, int protocol);//equivalent to posix socket implementation +#endif + +#ifndef UA_bind +int UA_bind(UA_SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen);//equivalent to posix bind implementation +#endif + +#ifndef UA_listen +int UA_listen(UA_SOCKET sockfd, int backlog);//equivalent to posix listen implementation +#endif + +#ifndef UA_accept +int UA_accept(UA_SOCKET sockfd, struct sockaddr *addr, socklen_t *addrlen);//equivalent to posix accept implementation +#endif + +#ifndef UA_close +int UA_close(UA_SOCKET sockfd);//equivalent to posix close implementation +#endif + +#ifndef UA_connect +int UA_connect(UA_SOCKET sockfd, const struct sockaddr *addr, socklen_t addrlen);//equivalent to posix connect implementation +#endif + +#ifndef UA_fd_set +void UA_fd_set(UA_SOCKET fd, fd_set *set); //equivalent to posix FD_SET implementation +#endif + +#ifndef UA_fd_isset +int UA_fd_isset(UA_SOCKET fd, fd_set *set);//equivalent to posix FD_ISSET implementation +#endif + +#ifndef UA_getaddrinfo +int UA_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res);//equivalent to posix getaddrinfo implementation +#endif + +#ifndef UA_htonl +uint32_t UA_htonl(uint32_t hostlong);//equivalent to posix UA_htonl implementation +#endif + +#ifndef UA_ntohl +uint32_t UA_ntohl(uint32_t netlong);//equivalent to posix ntohl implementation +#endif + +#ifndef UA_inet_pton +int UA_inet_pton(int af, const char *src, void *dst);//equivalent to ANSI inet_pton implementation +#endif + +#if UA_IPV6 +# ifndef UA_if_nametoindex +unsigned int UA_if_nametoindex(const char *ifname);//equivalent to posix if_nametoindex implementation +# endif +#endif + +#ifndef UA_socket_set_blocking +unsigned int UA_socket_set_blocking(UA_SOCKET sockfd);//set a socket as blocking. Returns 0 if OK, other value otherwise +#endif + +#ifndef UA_socket_set_nonblocking +unsigned int UA_socket_set_nonblocking(UA_SOCKET sockfd);//set a socket as non-blocking. Returns 0 if OK, other value otherwise +#endif + +#ifndef UA_ioctl +int UA_ioctl(int fildes, int request, ...);//equivalent to posix ioctl implementation +#endif + +#ifndef UA_getsockopt +int UA_getsockopt(int sockfd, int level, int optname, void *optval, socklen_t *optlen); //equivalent to posix getsockopt implementation. Only in non windows architectures +#endif + +#ifndef UA_setsockopt +int UA_setsockopt(int sockfd, int level, int optname, const void *optval, socklen_t optlen);//equivalent to posix setsockopt implementation +#endif + +#ifndef UA_freeaddrinfo +void UA_freeaddrinfo(struct addrinfo *res);//equivalent to posix freeaddrinfo implementation +#endif + +#ifndef UA_gethostname +int UA_gethostname(char *name, size_t len);//equivalent to posix gethostname implementation +#endif + +#ifndef UA_getsockname +int UA_getsockname(int sockfd, struct sockaddr *addr, socklen_t *addrlen);//equivalent to posix getsockname implementation +#endif + +#ifndef UA_initialize_architecture_network +void UA_initialize_architecture_network(void);//initializes all needed for using the network interfaces +#endif + +#ifndef UA_deinitialize_architecture_network +void UA_deinitialize_architecture_network(void);//de-initializes the network interfaces +#endif + +/* Print function */ +#ifndef UA_snprintf +int UA_snprintf(char* pa_stream, size_t pa_size, const char* pa_format, ...); //prints text to output +#endif + +#ifndef UA_strncasecmp +int UA_strncasecmp(const char* s1, const char* s2, size_t n); +#endif + +/* Access to file function */ +#ifndef UA_access +int UA_access(const char *pathname, int mode); //equivalent implementation of https://linux.die.net/man/2/access +#endif + +#ifndef UA_fileExists +#define UA_fileExists(X) ( UA_access(X, 0) == 0) +#endif + +extern const UA_Byte variablenode_ns_0_i_7617_variant_DataContents_byteArray[]; + + +_UA_END_DECLS + +#endif /* OPEN62541_H_ */ diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.h b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.h new file mode 100755 index 00000000..19790b2a --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_api.h @@ -0,0 +1,25 @@ +/* +* Copyright (c) 2021 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ +#ifndef __UA_API_H__ +#define __UA_API_H__ + +#include "open62541.h" + +#define OPC_SERVER "opc.tcp://192.168.250.5:4840" +#define ua_print printf + +int ua_server_connect(void); +int ua_get_server_info(UA_Client *client); +void ua_read_time(UA_Client *client); +int16 ua_test(void); + +#endif diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_client.c b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_client.c new file mode 100755 index 00000000..a6795b61 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_client.c @@ -0,0 +1,342 @@ +/* +* Copyright (c) 2021 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +#include "open62541.h" +#include + +#define OPC_SERVER "opc.tcp://192.168.250.5:4840" +#define ua_print printf + +#ifdef UA_ENABLE_SUBSCRIPTIONS +static void handler_TheAnswerChanged(UA_Client *client, UA_UInt32 subId, void *subContext, + UA_UInt32 monId, void *monContext, UA_DataValue *value) +{ + ua_print("The Answer has changed!\n"); +} +#endif + +static UA_StatusCode nodeIter(UA_NodeId childId, UA_Boolean isInverse, UA_NodeId referenceTypeId, void *handle) +{ + if(isInverse) + { + return UA_STATUSCODE_GOOD; + } + + UA_NodeId *parent = (UA_NodeId *)handle; + ua_print("%d, %d --- %d ---> NodeId %d, %d\n", + parent->namespaceIndex, parent->identifier.numeric, + referenceTypeId.identifier.numeric, childId.namespaceIndex, + childId.identifier.numeric); + + return UA_STATUSCODE_GOOD; +} + +int ua_get_points(UA_Client *client) +{ + /* Listing endpoints */ + UA_EndpointDescription* endpointArray = NULL; + size_t endpointArraySize = 0; + UA_StatusCode retval = UA_Client_getEndpoints(client, OPC_SERVER, + &endpointArraySize, &endpointArray); + if(retval != UA_STATUSCODE_GOOD) + { + UA_Array_delete(endpointArray, endpointArraySize, &UA_TYPES[UA_TYPES_ENDPOINTDESCRIPTION]); + return EXIT_FAILURE; + } + + ua_print("%i endpoints found\n", (int)endpointArraySize); + for(size_t i=0;inodeId.nodeId.identifierType == UA_NODEIDTYPE_NUMERIC) { + ua_print("%-9d %-16d %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex, + ref->nodeId.nodeId.identifier.numeric, (int)ref->browseName.name.length, + ref->browseName.name.data, (int)ref->displayName.text.length, + ref->displayName.text.data); + } else if(ref->nodeId.nodeId.identifierType == UA_NODEIDTYPE_STRING) { + ua_print("%-9d %-16.*s %-16.*s %-16.*s\n", ref->nodeId.nodeId.namespaceIndex, + (int)ref->nodeId.nodeId.identifier.string.length, + ref->nodeId.nodeId.identifier.string.data, + (int)ref->browseName.name.length, ref->browseName.name.data, + (int)ref->displayName.text.length, ref->displayName.text.data); + } + /* TODO: distinguish further types */ + } + } + UA_BrowseRequest_clear(&bReq); + UA_BrowseResponse_clear(&bResp); +} + +void ua_browser_nodes(UA_Client *client) +{ + /* Same thing, this time using the node iterator... */ + UA_NodeId *parent = UA_NodeId_new(); + *parent = UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER); + UA_Client_forEachChildNodeCall(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), + nodeIter, (void *) parent); + UA_NodeId_delete(parent); +} + +UA_UInt32 ua_start_sub(UA_Client *client) +{ + /* Create a subscription */ + UA_CreateSubscriptionRequest request = UA_CreateSubscriptionRequest_default(); + UA_CreateSubscriptionResponse response = UA_Client_Subscriptions_create(client, request, + NULL, NULL, NULL); + + UA_UInt32 subId = response.subscriptionId; + if(response.responseHeader.serviceResult == UA_STATUSCODE_GOOD) + ua_print("Create subscription succeeded, id %u\n", subId); + + UA_MonitoredItemCreateRequest monRequest = + UA_MonitoredItemCreateRequest_default(UA_NODEID_STRING(1, "the.answer")); + + UA_MonitoredItemCreateResult monResponse = + UA_Client_MonitoredItems_createDataChange(client, response.subscriptionId, + UA_TIMESTAMPSTORETURN_BOTH, + monRequest, NULL, handler_TheAnswerChanged, NULL); + if(monResponse.statusCode == UA_STATUSCODE_GOOD) + ua_print("Monitoring 'the.answer', id %u\n", monResponse.monitoredItemId); + + + /* The first publish request should return the initial value of the variable */ + UA_Client_run_iterate(client, 1000); + return subId; +} + +void ua_read_attr(UA_Client *client) +{ + /* Read attribute */ + UA_Int32 value = 0; + ua_print("\nReading the value of node (1, \"the.answer\"):\n"); + UA_Variant *val = UA_Variant_new(); + UA_StatusCode retval = UA_Client_readValueAttribute(client, UA_NODEID_STRING(1, "the.answer"), val); + if(retval == UA_STATUSCODE_GOOD && UA_Variant_isScalar(val) && + val->type == &UA_TYPES[UA_TYPES_INT32]) { + value = *(UA_Int32*)val->data; + ua_print("the value is: %i\n", value); + } + UA_Variant_delete(val); + + /* Write node attribute */ + value++; + ua_print("\nWriting a value of node (1, \"the.answer\"):\n"); + UA_WriteRequest wReq; + UA_WriteRequest_init(&wReq); + wReq.nodesToWrite = UA_WriteValue_new(); + wReq.nodesToWriteSize = 1; + wReq.nodesToWrite[0].nodeId = UA_NODEID_STRING_ALLOC(1, "the.answer"); + wReq.nodesToWrite[0].attributeId = UA_ATTRIBUTEID_VALUE; + wReq.nodesToWrite[0].value.hasValue = true; + wReq.nodesToWrite[0].value.value.type = &UA_TYPES[UA_TYPES_INT32]; + wReq.nodesToWrite[0].value.value.storageType = UA_VARIANT_DATA_NODELETE; /* do not free the integer on deletion */ + wReq.nodesToWrite[0].value.value.data = &value; + UA_WriteResponse wResp = UA_Client_Service_write(client, wReq); + if(wResp.responseHeader.serviceResult == UA_STATUSCODE_GOOD) + ua_print("the new value is: %i\n", value); + UA_WriteRequest_clear(&wReq); + UA_WriteResponse_clear(&wResp); + + /* Write node attribute (using the highlevel API) */ + value++; + UA_Variant *myVariant = UA_Variant_new(); + UA_Variant_setScalarCopy(myVariant, &value, &UA_TYPES[UA_TYPES_INT32]); + UA_Client_writeValueAttribute(client, UA_NODEID_STRING(1, "the.answer"), myVariant); + UA_Variant_delete(myVariant); + +} + +void ua_call_remote(UA_Client *client) +{ + /* Call a remote method */ + UA_Variant input; + UA_String argString = UA_STRING("Hello Server"); + UA_Variant_init(&input); + UA_Variant_setScalarCopy(&input, &argString, &UA_TYPES[UA_TYPES_STRING]); + size_t outputSize; + UA_Variant *output; + UA_StatusCode retval = UA_Client_call(client, UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), + UA_NODEID_NUMERIC(1, 62541), 1, &input, &outputSize, &output); + if(retval == UA_STATUSCODE_GOOD) { + ua_print("Method call was successful, and %lu returned values available.\n", + (unsigned long)outputSize); + UA_Array_delete(output, outputSize, &UA_TYPES[UA_TYPES_VARIANT]); + } else { + ua_print("Method call was unsuccessful, and %x returned values available.\n", retval); + } + UA_Variant_clear(&input); +} + + +void ua_add_nodes(UA_Client *client) +{ + /* Add new nodes*/ + /* New ReferenceType */ + UA_NodeId ref_id; + UA_ReferenceTypeAttributes ref_attr = UA_ReferenceTypeAttributes_default; + ref_attr.displayName = UA_LOCALIZEDTEXT("en-US", "NewReference"); + ref_attr.description = UA_LOCALIZEDTEXT("en-US", "References something that might or might not exist"); + ref_attr.inverseName = UA_LOCALIZEDTEXT("en-US", "IsNewlyReferencedBy"); + UA_StatusCode retval = UA_Client_addReferenceTypeNode(client, + UA_NODEID_NUMERIC(1, 12133), + UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE), + UA_QUALIFIEDNAME(1, "NewReference"), + ref_attr, &ref_id); + if(retval == UA_STATUSCODE_GOOD ) + ua_print("Created 'NewReference' with numeric NodeID %u\n", ref_id.identifier.numeric); + + /* New ObjectType */ + UA_NodeId objt_id; + UA_ObjectTypeAttributes objt_attr = UA_ObjectTypeAttributes_default; + objt_attr.displayName = UA_LOCALIZEDTEXT("en-US", "TheNewObjectType"); + objt_attr.description = UA_LOCALIZEDTEXT("en-US", "Put innovative description here"); + retval = UA_Client_addObjectTypeNode(client, + UA_NODEID_NUMERIC(1, 12134), + UA_NODEID_NUMERIC(0, UA_NS0ID_BASEOBJECTTYPE), + UA_NODEID_NUMERIC(0, UA_NS0ID_HASSUBTYPE), + UA_QUALIFIEDNAME(1, "NewObjectType"), + objt_attr, &objt_id); + if(retval == UA_STATUSCODE_GOOD) + ua_print("Created 'NewObjectType' with numeric NodeID %u\n", objt_id.identifier.numeric); + + /* New Object */ + UA_NodeId obj_id; + UA_ObjectAttributes obj_attr = UA_ObjectAttributes_default; + obj_attr.displayName = UA_LOCALIZEDTEXT("en-US", "TheNewGreatNode"); + obj_attr.description = UA_LOCALIZEDTEXT("de-DE", "Hier koennte Ihre Webung stehen!"); + retval = UA_Client_addObjectNode(client, + UA_NODEID_NUMERIC(1, 0), + UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), + UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), + UA_QUALIFIEDNAME(1, "TheGreatNode"), + UA_NODEID_NUMERIC(1, 12134), + obj_attr, &obj_id); + if(retval == UA_STATUSCODE_GOOD ) + ua_print("Created 'NewObject' with numeric NodeID %u\n", obj_id.identifier.numeric); + + /* New Integer Variable */ + UA_NodeId var_id; + UA_VariableAttributes var_attr = UA_VariableAttributes_default; + var_attr.displayName = UA_LOCALIZEDTEXT("en-US", "TheNewVariableNode"); + var_attr.description = + UA_LOCALIZEDTEXT("en-US", "This integer is just amazing - it has digits and everything."); + UA_Int32 int_value = 1234; + /* This does not copy the value */ + UA_Variant_setScalar(&var_attr.value, &int_value, &UA_TYPES[UA_TYPES_INT32]); + var_attr.dataType = UA_TYPES[UA_TYPES_INT32].typeId; + retval = UA_Client_addVariableNode(client, + UA_NODEID_NUMERIC(1, 0), // Assign new/random NodeID + UA_NODEID_NUMERIC(0, UA_NS0ID_OBJECTSFOLDER), + UA_NODEID_NUMERIC(0, UA_NS0ID_ORGANIZES), + UA_QUALIFIEDNAME(0, "VariableNode"), + UA_NODEID_NULL, // no variable type + var_attr, &var_id); + if(retval == UA_STATUSCODE_GOOD ) + ua_print("Created 'NewVariable' with numeric NodeID %u\n", var_id.identifier.numeric); + +} + +int ua_get_server_info(UA_Client *client) +{ + UA_StatusCode retval; + + /* Listing endpoints */ + retval = ua_get_points(client); + if(retval != UA_STATUSCODE_GOOD) { + UA_Client_delete(client); + return EXIT_FAILURE; + } + + /* Connect to a server */ + /* anonymous connect would be: retval = UA_Client_connect(client, "opc.tcp://localhost:4840"); */ + retval = UA_Client_connect(client, OPC_SERVER); + if(retval != UA_STATUSCODE_GOOD) { + UA_Client_delete(client); + return EXIT_FAILURE; + } + + ua_browser_objects(client); + + /* Same thing, this time using the node iterator... */ + ua_browser_nodes(client); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + UA_Int32 subId = ua_start_sub(client); +#endif + + ua_read_attr(client); + +#ifdef UA_ENABLE_SUBSCRIPTIONS + /* Take another look at the.answer */ + UA_Client_run_iterate(client, 100); + /* Delete the subscription */ + if(UA_Client_Subscriptions_deleteSingle(client, subId) == UA_STATUSCODE_GOOD) + ua_print("Subscription removed\n"); +#endif + +#ifdef UA_ENABLE_METHODCALLS + ua_call_remote(client); +#endif + +#ifdef UA_ENABLE_NODEMANAGEMENT + ua_add_nodes(client); +#endif + + return EXIT_SUCCESS; +} + +void ua_read_time(UA_Client *client) +{ + /* Read the value attribute of the node. UA_Client_readValueAttribute is a + * wrapper for the raw read service available as UA_Client_Service_read. */ + UA_Variant value; /* Variants can hold scalar values and arrays of any type */ + UA_Variant_init(&value); + + /* NodeId of the variable holding the current time */ + const UA_NodeId nodeId = UA_NODEID_NUMERIC(0, UA_NS0ID_SERVER_SERVERSTATUS_CURRENTTIME); + UA_StatusCode retval = UA_Client_readValueAttribute(client, nodeId, &value); + + if(retval == UA_STATUSCODE_GOOD && UA_Variant_hasScalarType(&value, &UA_TYPES[UA_TYPES_DATETIME])) + { + UA_DateTime raw_date = *(UA_DateTime *) value.data; + UA_DateTimeStruct dts = UA_DateTime_toStruct(raw_date); + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_USERLAND, "date is: %u-%u-%u %u:%u:%u.%03u\n", + dts.day, dts.month, dts.year, dts.hour, dts.min, dts.sec, dts.milliSec); + } + /* Clean up */ + UA_Variant_clear(&value); +} + diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_data.c b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_data.c new file mode 100755 index 00000000..118598e7 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_data.c @@ -0,0 +1,201 @@ +#include "open62541.h" + +/* Opc.Ua - ns=0;i=7617 */ +const UA_Byte variablenode_ns_0_i_7617_variant_DataContents_byteArray[177218] = {60, 111, 112, 99, 58, 84, 121, 112, 101, 68, 105, 99, 116, 105, 111, 110, 97, 114, 121, 13, 10, 32, 32, 120, 109, 108, 110, 115, 58, 111, 112, 99, 61, 34, 104, 116, 116, 112, 58, 47, 47, 111, 112, 99, 102, 111, 117, 110, 100, 97, 116, 105, 111, 110, 46, 111, 114, 103, 47, 66, 105, 110, 97, 114, 121, 83, 99, 104, 101, 109, 97, 47, 34, 13, 10, 32, 32, 120, 109, 108, 110, 115, 58, 120, 115, 105, 61, 34, 104, 116, 116, 112, 58, 47, 47, 119, 119, 119, 46, 119, 51, 46, 111, 114, 103, 47, 50, 48, 48, 49, 47, 88, 77, 76, 83, 99, 104, 101, 109, 97, 45, 105, 110, 115, 116, 97, 110, 99, 101, 34, 13, 10, 32, 32, 120, 109, 108, 110, 115, 58, 117, 97, 61, 34, 104, 116, 116, 112, 58, 47, 47, 111, 112, 99, 102, 111, 117, 110, 100, 97, 116, 105, 111, 110, 46, 111, 114, 103, 47, 85, 65, 47, 34, 13, 10, 32, 32, 120, 109, 108, 110, 115, 58, 116, 110, 115, 61, 34, 104, 116, 116, 112, 58, 47, 47, 111, 112, 99, 102, 111, 117, 110, 100, 97, 116, 105, 111, 110, 46, 111, 114, 103, 47, 85, 65, 47, 34, 13, 10, 32, 32, 68, 101, 102, 97, 117, 108, 116, 66, 121, 116, 101, 79, 114, 100, 101, 114, 61, 34, 76, 105, 116, 116, 108, 101, 69, 110, 100, 105, 97, 110, 34, 13, 10, 32, 32, 84, 97, 114, 103, 101, 116, 78, 97, 109, 101, 115, 112, 97, 99, 101, 61, 34, 104, 116, 116, 112, 58, 47, 47, 111, 112, 99, 102, 111, 117, 110, 100, 97, 116, 105, 111, 110, 46, 111, 114, 103, 47, 85, 65, 47, 34, 13, 10, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 73, 109, 112, 111, 114, 116, 32, 78, 97, 109, 101, 115, 112, 97, 99, 101, 61, 34, 104, 116, 116, 112, 58, 47, 47, 111, 112, 99, 102, 111, 117, 110, 100, 97, 116, 105, 111, 110, 46, 111, 114, 103, 47, 66, 105, 110, 97, 114, 121, 83, 99, 104, 101, 109, 97, 47, 34, 32, 47, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 88, 109, 108, 69, 108, 101, 109, 101, 110, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 110, 32, 88, 77, 76, 32, 101, 108, 101, 109, 101, 110, 116, 32, 101, 110, 99, 111, 100, 101, 100, 32, 97, 115, 32, 97, 32, 85, 84, 70, 45, 56, 32, 115, 116, 114, 105, 110, 103, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 76, 101, 110, 103, 116, 104, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 54, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 84, 104, 101, 32, 112, 111, 115, 115, 105, 98, 108, 101, 32, 101, 110, 99, 111, 100, 105, 110, 103, 115, 32, 102, 111, 114, 32, 97, 32, 78, 111, 100, 101, 73, 100, 32, 118, 97, 108, 117, 101, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 119, 111, 66, 121, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, +101, 32, 78, 97, 109, 101, 61, 34, 70, 111, 117, 114, 66, 121, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 105, 99, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 71, 117, 105, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 119, 111, 66, 121, 116, 101, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 111, 117, 114, 66, 121, 116, 101, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 105, 99, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 105, 110, 103, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34 +, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 65, 114, 114, 97, 121, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 71, 117, 105, 100, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 71, 117, 105, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 100, 101, 110, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 32, 102, 111, 114, 32, 97, 32, 110, 111, 100, 101, 32, 105, 110, 32, 97, 32, 85, 65, 32, 115, 101, 114, 118, 101, 114, 32, 97, 100, 100, 114, 101, 115, 115, 32, 115, 112, 97, 99, 101, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 101, 114, 118, 101, 100, 49, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 119, 111, 66, 121, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 84, 119, 111, 66, 121, 116, 101, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 111, 117, 114, 66, 121, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 70, 111, 117, 114, 66, 121, 116, 101, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34 +, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 105, 99, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 117, 109, 101, 114, 105, 99, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 114, 105, 110, 103, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 117, 105, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 71, 117, 105, 100, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 110, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 32, 102, 111, 114, 32, 97, 32, 110, 111, 100, 101, 32, 105, 110, 32, 97, 32, 85, 65, 32, 115, 101, 114, 118, 101, 114, 32, 97, 100, 100, 114, 101, 115, 115, 32, 115, 112, 97, 99, 101, 32, 113, 117, 97, 108, 105, 102, 105, 101, 100, 32, 119, 105, 116, 104, 32, 97, 32, 99, 111, 109, 112, 108, 101, 116, 101, 32, 110, 97, 109, 101, 115, 112, 97, 99, 101, 32, 115, 116, 114, 105, 110, 103, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 73, 110, 100, 101, 120, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 82, 73, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 119, 111, 66, 121, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 84, 119, 111, 66, 121, 116, 101, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, +101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 111, 117, 114, 66, 121, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 70, 111, 117, 114, 66, 121, 116, 101, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 105, 99, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 117, 109, 101, 114, 105, 99, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 114, 105, 110, 103, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 117, 105, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 71, 117, 105, 100, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 100, 101, 73, 100, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 82, 73, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 65, 114, 114, 97, 121, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 82, 73, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 83, 101, 114, 118, 101, 114, 73, 110, 100, 101, 120, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 66, 121, 116, 101, 79, 114, 100, 101, 114, 83, 105, 103, 110, 105, 102, 105, 99, 97, 110, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 32, 51, 50, 45, 98, 105, 116, 32, 115, 116, 97, 116, 117, 115, 32, 99, 111, 100, 101, 32, 118, 97, 108, 117, 101, 46, 60, 47, 111, +112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 32, 114, 101, 99, 117, 114, 115, 105, 118, 101, 32, 115, 116, 114, 117, 99, 116, 117, 114, 101, 32, 99, 111, 110, 116, 97, 105, 110, 105, 110, 103, 32, 100, 105, 97, 103, 110, 111, 115, 116, 105, 99, 32, 105, 110, 102, 111, 114, 109, 97, 116, 105, 111, 110, 32, 97, 115, 115, 111, 99, 105, 97, 116, 101, 100, 32, 119, 105, 116, 104, 32, 97, 32, 115, 116, 97, 116, 117, 115, 32, 99, 111, 100, 101, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 121, 109, 98, 111, 108, 105, 99, 73, 100, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 82, 73, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 105, 116, 105, 111, 110, 97, 108, 73, 110, 102, 111, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 110, 101, 114, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 110, 101, 114, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 101, 114, 118, 101, 100, 49, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 121, 109, 98, 111, 108, 105, 99, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 83, 121, 109, 98, 111, 108, 105, 99, 73, 100, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 82, 73, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 83, 119, +105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 82, 73, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 76, 111, 99, 97, 108, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 105, 116, 105, 111, 110, 97, 108, 73, 110, 102, 111, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 65, 114, 114, 97, 121, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 65, 100, 100, 105, 116, 105, 111, 110, 97, 108, 73, 110, 102, 111, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 110, 101, 114, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 73, 110, 110, 101, 114, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 110, 101, 114, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 73, 110, 110, 101, 114, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 32, 115, 116, 114, 105, 110, 103, 32, 113, 117, 97, 108, 105, 102, 105, 101, 100, 32, 119, 105, 116, 104, 32, 97, 32, 110, 97, 109, 101, 115, 112, 97, 99, 101, 32, 105, 110, 100, 101, 120, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 65, 114, 114, 97, 121, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, +58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 32, 115, 116, 114, 105, 110, 103, 32, 113, 117, 97, 108, 105, 102, 105, 101, 100, 32, 119, 105, 116, 104, 32, 97, 32, 110, 97, 109, 101, 115, 112, 97, 99, 101, 32, 105, 110, 100, 101, 120, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 101, 120, 116, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 101, 114, 118, 101, 100, 49, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 65, 114, 114, 97, 121, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 76, 111, 99, 97, 108, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 101, 120, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 65, 114, 114, 97, 121, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 84, 101, 120, 116, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 32, 118, 97, 108, 117, 101, 32, 119, 105, 116, 104, 32, 97, 110, 32, 97, 115, 115, 111, 99, 105, 97, 116, 101, 100, 32, 116, 105, 109, 101, 115, 116, 97, 109, 112, 44, 32, 97, 110, 100, 32, 113, 117, 97, 108, 105, 116, 121, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 84, 105, 109, 101, 115, 116, 97, 109, 112, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 84, 105, 109, 101, 115, 116, 97, 109, 112, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 80, 105, 99, 111, 115, 101, 99, 111, 110, 100, 115, 83, 112, 101, 99, 105, +102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 80, 105, 99, 111, 115, 101, 99, 111, 110, 100, 115, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 101, 114, 118, 101, 100, 49, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 108, 117, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 83, 111, 117, 114, 99, 101, 84, 105, 109, 101, 115, 116, 97, 109, 112, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 80, 105, 99, 111, 115, 101, 99, 111, 110, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 83, 111, 117, 114, 99, 101, 80, 105, 99, 111, 115, 101, 99, 111, 110, 100, 115, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 83, 101, 114, 118, 101, 114, 84, 105, 109, 101, 115, 116, 97, 109, 112, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 80, 105, 99, 111, 115, 101, 99, 111, 110, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 83, 101, 114, 118, 101, 114, 80, 105, 99, 111, 115, 101, 99, 111, 110, 100, 115, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 32, 115, 101, 114, 105, 97, 108, 105, 122, 101, 100, 32, 111, 98, 106, 101, 99, 116, 32, 112, 114, 101, 102, 105, 120, 101, 100, 32, 119, 105, 116, 104, 32, 105, 116, +115, 32, 100, 97, 116, 97, 32, 116, 121, 112, 101, 32, 105, 100, 101, 110, 116, 105, 102, 105, 101, 114, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 73, 100, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 105, 110, 97, 114, 121, 66, 111, 100, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 88, 109, 108, 66, 111, 100, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 101, 114, 118, 101, 100, 49, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 84, 121, 112, 101, 73, 100, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 111, 100, 121, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 111, 100, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 66, 111, 100, 121, 76, 101, 110, 103, 116, 104, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 110, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 65, 32, 117, 110, 105, 111, 110, 32, 111, 102, 32, 115, 101, 118, 101, 114, 97, 108, 32, 116, 121, 112, 101, 115, 46, 60, 47, 111, 112, 99, 58, 68, 111, 99, 117, 109, 101, 110, 116, 97, 116, 105, 111, 110, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 49, 34, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 105, 116, 34, 32, 76, 101, 110, 103, 116, 104, 61, 34, 49, 34, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, +111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 111, 111, 108, 101, 97, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 66, 121, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 66, 121, 116, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 121, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 116, 49, 54, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 49, 54, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 73, 110, 116, 49, 54, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 116, 51, 50, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 73, 110, 116, 51, 50, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 55, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, +58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 116, 54, 52, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 54, 52, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 73, 110, 116, 54, 52, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 54, 52, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 57, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 108, 111, 97, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 70, 108, 111, 97, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 111, 117, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 67, 104, 97, 114, 65, 114, 114, 97, 121, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 117, 105, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 71, 117, 105, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116 +, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 88, 109, 108, 69, 108, 101, 109, 101, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 88, 109, 108, 69, 108, 101, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 55, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 49, 57, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 120, 116, 101, 110, 115, 105 +, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 86, 97, 114, 105, 97, 110, 116, 84, 121, 112, 101, 34, 32, 83, 119, 105, 116, 99, 104, 86, 97, 108, 117, 101, 61, 34, 50, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 83, 119, 105, 116, 99, 104, 70, 105, 101, 108, 100, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 105, 110, 103, 82, 117, 108, 101, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 97, 110, 100, 97, 116, 111, 114, 121, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, +110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 112, 116, 105, 111, 110, 97, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 115, 116, 114, 97, 105, 110, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 32, 32, 32, 32, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 109, 97, 103, 101, 66, 77, 80, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 109, 97, 103, 101, 71, 73, 70, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 109, 97, 103, 101, 74, 80, 71, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 109, 97, 103, 101, 80, 78, 71, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 117, 100, 105, 111, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 105, 116, 70, 105, 101, 108, 100, 77, 97, 115, 107, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 75, 101, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 105, 116, 105, 111, 110, 97, 108, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, +108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 112, 104, 101, 109, 101, 114, 97, 108, 75, 101, 121, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 99, 75, 101, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 97, 116, 117, 114, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 80, 111, 108, 105, 99, 121, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 97, 116, 105, 111, 110, 97, 108, 78, 117, 109, 98, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 97, 116, 111, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 110, 111, 109, 105, 110, 97, 116, 111, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, +32, 78, 97, 109, 101, 61, 34, 86, 101, 99, 116, 111, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 104, 114, 101, 101, 68, 86, 101, 99, 116, 111, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 86, 101, 99, 116, 111, 114, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 88, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 89, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 90, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 114, 116, 101, 115, 105, 97, 110, 67, 111, 111, 114, 100, 105, 110, 97, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 104, 114, 101, 101, 68, 67, 97, 114, 116, 101, 115, 105, 97, 110, 67, 111, 111, 114, 100, 105, 110, 97, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 67, 97, 114, 116, 101, 115, 105, 97, 110, 67, 111, 111, 114, 100, 105, 110, 97, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 88, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 89, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 90, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 114, 105, 101, 110, 116, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 104, 114, 101, 101, 68, 79, 114, 105, 101, 110, 116, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 79, 114, 105, 101, 110, 116, 97, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, +111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 114, 97, 109, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 104, 114, 101, 101, 68, 70, 114, 97, 109, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 70, 114, 97, 109, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 97, 114, 116, 101, 115, 105, 97, 110, 67, 111, 111, 114, 100, 105, 110, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 84, 104, 114, 101, 101, 68, 67, 97, 114, 116, 101, 115, 105, 97, 110, 67, 111, 111, 114, 100, 105, 110, 97, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 114, 105, 101, 110, 116, 97, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 84, 104, 114, 101, 101, 68, 79, 114, 105, 101, 110, 116, 97, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 110, 70, 105, 108, 101, 77, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 114, 97, 115, 101, 69, 120, 105, 115, 116, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 101, 110, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 100, 101, 110, 116, 105, 116, 121, 67, 114, 105, 116, 101, 114, 105, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10 +, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 104, 117, 109, 98, 112, 114, 105, 110, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 110, 111, 110, 121, 109, 111, 117, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 101, 100, 85, 115, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 100, 101, 110, 116, 105, 116, 121, 77, 97, 112, 112, 105, 110, 103, 82, 117, 108, 101, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 105, 116, 101, 114, 105, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 73, 100, 101, 110, 116, 105, 116, 121, 67, 114, 105, 116, 101, 114, 105, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 105, 116, 101, 114, 105, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 99, 121, 85, 110, 105, 116, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 105, 99, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 120, 112, 111, 110, 101, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 108, 112, 104, 97, 98, 101, 116, 105, 99, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 99, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114 +, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 117, 115, 116, 76, 105, 115, 116, 77, 97, 115, 107, 115, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 117, 115, 116, 101, 100, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 117, 115, 116, 101, 100, 67, 114, 108, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 114, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 114, 67, 114, 108, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 108, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 53, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 117, 115, 116, 76, 105, 115, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 76, 105, 115, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 84, 114, 117, 115, 116, 101, 100, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 117, 115, 116, 101, 100, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 84, 114, 117, 115, 116, 101, 100, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 84, 114, 117, 115, 116, 101, 100, 67, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 117, 115, 116, 101, 100, 67, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 84, 114, 117, 115, 116, 101, 100, 67, 114, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, +60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 73, 115, 115, 117, 101, 114, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 114, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 73, 115, 115, 117, 101, 114, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 73, 115, 115, 117, 101, 114, 67, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 114, 67, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 73, 115, 115, 117, 101, 114, 67, 114, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 99, 105, 109, 97, 108, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 99, 97, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 83, 99, 104, 101, 109, 97, 72, 101, 97, 100, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, +34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 109, 112, 108, 101, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105 +, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 117, 105, 108, 116, 73, 110, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 109, 112, 108, 101, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 97, 115, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101 +, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 117, 105, 108, 116, 73, 110, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 65, 66, 105, 110, 97, 114, 121, 70, 105, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 83, 99, 104, 101, 109, 97, 72, 101, 97, 100, 101, 114, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 109, 112, 108, 101, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 99, 104, 101, 109, 97, 76, 111, 99, 97, +116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 70, 105, 108, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 70, 105, 108, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 111, 100, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 83, 117, 98, 83, 116, 97, 116, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 97, 98, 108, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 97, 117, 115, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 114, 97, 116, 105, 111, 110, 97, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 114, 114, 111, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 116, 97, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 83, 99, 104, 101, 109, 97, 72, 101, 97, 100, 101, 114, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112 +, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 110, 117, 109, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 109, 112, 108, 101, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 105, 109, 112, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 70, 105, 101, 108, 100, 77, 101, 116, 97, 68, 97, 116, 97, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 70, 105, 101, 108, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 67, 108, 97, 115, 115, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 71, 117, 105, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 86, 101, 114, 115, 105, 111, 110, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 101, 108, 100, 77, 101, +116, 97, 68, 97, 116, 97, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 101, 108, 100, 70, 108, 97, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 70, 108, 97, 103, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 117, 105, 108, 116, 73, 110, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 83, 116, 114, 105, 110, 103, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 71, 117, 105, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 70, 108, +97, 103, 115, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 49, 54, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 109, 111, 116, 101, 100, 70, 105, 101, 108, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 86, 101, 114, 115, 105, 111, 110, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 106, 111, 114, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 105, 110, 111, 114, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 70, 111, 108, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 70, 111, 108, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 70, 111, 108, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 116, 97, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 77, 101, 116, 97, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 120, 116, 101, 110, 115, 105, 111, 110, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 120, 116, 101, 110, 115, 105, 111, 110, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, +115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 120, 116, 101, 110, 115, 105, 111, 110, 70, 105, 101, 108, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 83, 111, 117, 114, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 83, 111, 117, 114, 99, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 86, 97, 114, 105, 97, 98, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 86, 97, 114, 105, 97, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 72, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 97, 100, 98, 97, 110, 100, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 97, 100, 98, 97, 110, 100, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 116, 105, 116, 117, 116, 101, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 77, 101, 116, 97, 68, 97, 116, 97, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 97, 68, 97, 116, 97, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97 +, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 77, 101, 116, 97, 68, 97, 116, 97, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 73, 116, 101, 109, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 83, 111, 117, 114, 99, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 108, 105, 115, 104, 101, 100, 86, 97, 114, 105, 97, 98, 108, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 69, 118, 101, 110, 116, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 83, 111, 117, 114, 99, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 101, 100, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 108, 101, 99, 116, 101, 100, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 109, 112, 108, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 79, 112, 101, 114, 97, 110, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 101, 100, 70, 105, 101, 108, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, +105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 80, 105, 99, 111, 83, 101, 99, 111, 110, 100, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 80, 105, 99, 111, 83, 101, 99, 111, 110, 100, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 97, 119, 68, 97, 116, 97, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 75, 101, 121, 70, 114, 97, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, +105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121 +, 71, 114, 111, 117, 112, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 100, 112, 111, 105, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 71, 114, 111 +, 117, 112, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 100, 112, 111, 105, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 75, 101, 101, 112, 65, 108, 105, 118, 101, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 105, 111, 114, 105, 116, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, +100, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 101, 97, 100, 101, 114, 76, 97, 121, 111, 117, 116, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 83, 117, 98, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 114, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, +97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 114, 101, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 97, 100, 101, 114, 71, 114, 111, 117, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 101, 114, 71, 114, 111, 117, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 97, 100, 101, 114, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 97, 100, 101, 114, 71, 114, 111, 117, 112, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, +100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 65, 100, 100, 114, 101, 115, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 73, 110, 116, 101, 114, 102, 97, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 65, 100, 100, 114, 101, 115, 115, 85, 114, 108, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 101, 116, 119, 111, 114, 107, 65, 100, 100, 114, 101, 115, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 73, 110, 116, 101, 114, 102, 97, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 101, 116, 119, 111, 114, 107, 65, 100, 100, 114, 101, 115, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 101, 114, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 71, 114, 111, 117, 112, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, +117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 100, 112, 111, 105, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 71, 114, 111, 117, 112, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 101, 114, 71, 114, 111, 117, 112, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, +120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 101, 114, 71, 114, 111, 117, 112, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 114, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 116, 97, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 77, 101, 116, 97, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 82, 101, 99, 101, 105, 118, 101, 84, 105, 109, 101, 111, 117, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 75, 101, 121, 70, 114, 97, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 101, 97, 100, 101, 114, 76, 97, 121, 111, 117, 116, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32 +, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 71, 114, 111, 117, 112, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 100, 112, 111, 105, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 99, 117, 114, 105, 116, 121, 75, 101, 121, 83, 101, 114, 118, 105, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 75, 101, 121, 86, 97, 108, 117, 101, 80, 97, 105, 114, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 80, 114, 111, 112, 101, 114, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 83, 101, 116, 116, 105, 110, 103, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 98, 101, 100, 68, 97, 116, 97, 83, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, +116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 98, 101, 100, 68, 97, 116, 97, 83, 101, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 86, 97, 114, 105, 97, 98, 108, 101, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 83, 117, 98, 115, 99, 114, 105, 98, 101, 100, 68, 97, 116, 97, 83, 101, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 84, 97, 114, 103, 101, 116, 86, 97, 114, 105, 97, 98, 108, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 86, 97, 114, 105, 97, 98, 108, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 70, 105, 101, 108, 100, 84, 97, 114, 103, 101, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 84, 97, 114, 103, 101, 116, 86, 97, 114, 105, 97, 98, 108, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 101, 108, 100, 84, 97, 114, 103, 101, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 70, 105, 101, 108, 100, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 71, 117, 105, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 99, 101, 105, 118, 101, 114, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, +109, 101, 61, 34, 79, 118, 101, 114, 114, 105, 100, 101, 86, 97, 108, 117, 101, 72, 97, 110, 100, 108, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 79, 118, 101, 114, 114, 105, 100, 101, 86, 97, 108, 117, 101, 72, 97, 110, 100, 108, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 118, 101, 114, 114, 105, 100, 101, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 118, 101, 114, 114, 105, 100, 101, 86, 97, 108, 117, 101, 72, 97, 110, 100, 108, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 97, 98, 108, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 85, 115, 97, 98, 108, 101, 86, 97, 108, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 118, 101, 114, 114, 105, 100, 101, 86, 97, 108, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 98, 101, 100, 68, 97, 116, 97, 83, 101, 116, 77, 105, 114, 114, 111, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 83, 117, 98, 115, 99, 114, 105, 98, 101, 100, 68, 97, 116, 97, 83, 101, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 97, 114, 101, 110, 116, 78, 111, 100, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 83, 117, 98, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32 +, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 80, 117, 98, 108, 105, 115, 104, 101, 100, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 117, 98, 83, 117, 98, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 79, 114, 100, 101, 114, 105, 110, 103, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 100, 101, 102, 105, 110, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 115, 99, 101, 110, 100, 105, 110, 103, 87, 114, 105, 116, 101, 114, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 115, 99, 101, 110, 100, 105, 110, 103, 87, 114, 105, 116, 101, 114, 73, 100, 83, 105, 110, 103, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 97, 100, 112, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 114, 73, 100, 34, 32, +86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 72, 101, 97, 100, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 86, 101, 114, 115, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 78, 117, 109, 98, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 97, 121, 108, 111, 97, 100, 72, 101, 97, 100, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 50, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 105, 99, 111, 83, 101, 99, 111, 110, 100, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 53, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 67, 108, 97, 115, 115, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 49, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 109, 111, 116, 101, 100, 70, 105, 101, 108, 100, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 48, 50, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 97, 100, 112, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 79, 114, 100, 101, 114, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 79, 114, 100, 101, 114, 105, 110, 103, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, +34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 85, 97, 100, 112, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 97, 109, 112, 108, 105, 110, 103, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 79, 102, 102, 115, 101, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 97, 100, 112, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 105, 99, 111, 83, 101, 99, 111, 110, 100, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 97, 106, 111, 114, 86, 101, 114, 115, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 105, 110, 111, 114, 86, 101, 114, 115, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 97, 100, 112, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 77, 101, 115, 115, 97, 103 +, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 85, 97, 100, 112, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 102, 105, 103, 117, 114, 101, 100, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 78, 117, 109, 98, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 97, 100, 112, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 114, 111, 117, 112, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 78, 117, 109, 98, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 67, 108, 97, 115, 115, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 71, 117, 105, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 85, 97, 100, 112, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 85, 97, 100, 112, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103 +, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 99, 101, 105, 118, 101, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 99, 101, 115, 115, 105, 110, 103, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 74, 115, 111, 110, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 72, 101, 97, 100, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 72, 101, 97, 100, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 110, 103, 108, 101, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 101, 114, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 67, 108, 97, 115, 115, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 108, 121, 84, 111, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 74, 115, 111, 110, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, +97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 74, 115, 111, 110, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 74, 115, 111, 110, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 97, 68, 97, 116, 97, 86, 101, 114, 115, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 74, 115, 111, 110, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 74, 115, 111, 110, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 74, 115, 111, 110, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 77, 101, 115, 115, 97, 103, 101, 68 +, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 74, 115, 111, 110, 78, 101, 116, 119, 111, 114, 107, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 74, 115, 111, 110, 68, 97, 116, 97, 83, 101, 116, 77, 101, 115, 115, 97, 103, 101, 67, 111, 110, 116, 101, 110, 116, 77, 97, 115, 107, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 103, 114, 97, 109, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 65, 100, 100, 114, 101, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 103, 114, 97, 109, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 82, 101, 112, 101, 97, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 82, 101, 112, 101, 97, 116, 68, 101, 108, 97, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 107, 101, 114, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 111, 117, 114, 99, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61 +, 34, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 107, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 81, 117, 97, 108, 105, 116, 121, 79, 102, 83, 101, 114, 118, 105, 99, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 83, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 101, 115, 116, 69, 102, 102, 111, 114, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 116, 76, 101, 97, 115, 116, 79, 110, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 116, 77, 111, 115, 116, 79, 110, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 120, 97, 99, 116, 108, 121, 79, 110, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 107, 101, 114, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 87, 114, 105, 116, 101, 114, 71, 114, 111, 117, 112, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 117, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 111, 117, 114, 99, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 68, 101, 108, 105, 118, 101, 114, 121, 71, 117, 97, 114, 97, 110, 116, 101, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 107, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 81, 117, 97, 108, 105, 116, 121, 79, 102, 83, 101, 114, 118, 105, 99, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, +32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 107, 101, 114, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 87, 114, 105, 116, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 117, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 111, 117, 114, 99, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 68, 101, 108, 105, 118, 101, 114, 121, 71, 117, 97, 114, 97, 110, 116, 101, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 107, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 81, 117, 97, 108, 105, 116, 121, 79, 102, 83, 101, 114, 118, 105, 99, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 97, 68, 97, 116, 97, 81, 117, 101, 117, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 97, 68, 97, 116, 97, 85, 112, 100, 97, 116, 101, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 107, 101, 114, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 83, 101, 116, 82, 101, 97, 100, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 117, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 111, 117, 114, 99, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 68, 101, 108, 105, 118, 101, +114, 121, 71, 117, 97, 114, 97, 110, 116, 101, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 107, 101, 114, 84, 114, 97, 110, 115, 112, 111, 114, 116, 81, 117, 97, 108, 105, 116, 121, 79, 102, 83, 101, 114, 118, 105, 99, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 97, 68, 97, 116, 97, 81, 117, 101, 117, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 76, 101, 118, 101, 108, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 97, 115, 105, 99, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 118, 97, 110, 99, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 102, 111, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 76, 111, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 98, 117, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 83, 117, 98, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 67, 111, 117, 110, 116, 101, 114, 67, 108, 97, 115, 115, 105, 102, 105, 99, 97, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 102, 111, 114, 109, 97, 116, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 114, 114, 111, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 108, 105, 97, 115, 78, 97, 109, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 108, 105, 97, 115, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 100, 78, +111, 100, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 100, 78, 111, 100, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 100, 78, 111, 100, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 100, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 105, 99, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 71, 117, 105, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 112, 97, 113, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 115, 112, 101, 99, 105, 102, 105, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 104, 111, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111 +, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 50, 56, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 72, 105, 115, 116, 111, 114, 105, 122, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 72, 105, 115, 116, 111, 114, 121, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 50, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 115, 101, 114, 116, 72, 105, 115, 116, 111, 114, 121, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 53, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 72, 105, 115, 116, 111, 114, 121, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 49, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 72, 105, 115, 116, 111, 114, 121, 34, 32, 86, 97, 108, 117, +101, 61, 34, 49, 48, 50, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 99, 101, 105, 118, 101, 69, 118, 101, 110, 116, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 48, 52, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 108, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 48, 57, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 82, 101, 102, 101, 114, 101, 110, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 49, 57, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 109, 111, 118, 101, 82, 101, 102, 101, 114, 101, 110, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 51, 56, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 78, 111, 100, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 55, 54, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 78, 111, 100, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 53, 53, 51, 54, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 56, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 109, 97, 110, 116, 105, 99, 67, 104, 97, 110, 103, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, +109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 69, 120, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 109, 97, 110, 116, 105, 99, 67, 104, 97, 110, 103, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 97, 116, 111, 109, 105, 99, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 53, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 97, 116, 111, 109, 105, 99, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 49, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 70, 117, 108, 108, 65, 114, 114, 97, 121, 79, 110, 108, 121, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 48, 50, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 83, 117, 98, 68, 97, 116, 97, 84, 121, 112, 101, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 48, 52, 56, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84 +, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 56, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 98, 101, 84, 111, 69, 118, 101, 110, 116, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 87, 114, 105, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 49, 54, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 105, 110, 103, 82, 101, 113, 117, 105, 114, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 99, 114, 121, 112, 116, 105, 111, 110, 82, 101, 113, 117, 105, 114, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 82, 101, 113, 117, 105, 114, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 108, 121, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 84, 111, 66, 114, 111, 119, 115, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, +34, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 87, 105, 116, 104, 79, 112, 116, 105, 111, 110, 97, 108, 70, 105, 101, 108, 100, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 70, 105, 101, 108, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 83, 116, 114, 105, 110, 103, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 79, 112, 116, 105, 111, +110, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 102, 97, 117, 108, 116, 69, 110, 99, 111, 100, 105, 110, 103, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 97, 115, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 117, 99, 116, 117, 114, 101, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 70, 105, 101, 108, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 70, 105, 101, 108, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 70, 105, 101, 108, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 70, 105, 101, 108, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, +34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, +103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 115, 116, 97, 110, 99, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102 +, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, +116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 73, 110, 115, 116, 97, 110, 99, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, +101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, +111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 84, 121, 112, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 84, 121, 112, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, +117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 73, 110, 115, 116, 97, 110, 99, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, +100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82 +, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 105, 110, 105, 109, 117, 109, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 105, 122, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 69, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32 +, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 84, 121, 112, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 84, 121, 112, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, +121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 84, 121, 112, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121 +, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, +101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 121, 109, 109, 101, 116, 114, 105, 99, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 101, 114, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 104, 111, 100, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 73, 110, 115, 116, 97, 110, 99, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34 +, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, +32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 73, 110, 115, 116, 97, 110, 99, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32 +, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 97, 105, 110, 115, 78, 111, 76, 111, 111, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 84, 121, 112, 101, 78, 111, 100, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112 +, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 49, 54, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99 +, 101, 78, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 78, 111, 100, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 73, 110, 118, 101, 114, 115, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 114, 103, 117, 109, 101, 110, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, +101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 86, 97, 108, 117, 101, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 117, 109, 70, 105, 101, 108, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 86, 97, 108, 117, 101, 84, 121, 112, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 54, 52, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 86, 97, 108, 117, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 86, 97, 108, 117, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 69, 110, 117, 109, 86, 97, 108, 117, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 112, 116, 105, 111, 110, 83, 101, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34 +, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 105, 100, 66, 105, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 114, 109, 97, 108, 105, 122, 101, 100, 83, 116, 114, 105, 110, 103, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 99, 105, 109, 97, 108, 83, 116, 114, 105, 110, 103, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 117, 114, 97, 116, 105, 111, 110, 83, 116, 114, 105, 110, 103, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 83, 116, 114, 105, 110, 103, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 101, 83, 116, 114, 105, 110, 103, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 117, 114, 97, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 116, 99, 84, 105, 109, 101, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 73, 100, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 90, 111, 110, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 121, 108, 105, 103, 104, 116, 83, 97, 118, 105, 110, 103, 73, 110, 79, 102, 102, 115, 101, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60 +, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 116, 101, 103, 101, 114, 73, 100, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 65, 110, 100, 83, 101, 114, 118, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 83, 101, 114, 118, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 100, 117, 99, 116, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 97, 116, 101, 119, 97, 121, 83, 101, 114, 118, 101, 114, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, +103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 115, 99, 111, 118, 101, 114, 121, 85, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 85, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 115, 99, 111, 118, 101, 114, 121, 85, 114, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 84, 111, 107, 101, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 97, 110, 100, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 116, 117, 114, 110, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 117, 100, 105, 116, 69, 110, 116, 114, 121, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 111, 117, 116, 72, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 105, 116, 105, 111, 110, 97, 108, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 97, 110, 100 +, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 105, 99, 101, 82, 101, 115, 117, 108, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 105, 99, 101, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 116, 114, 105, 110, 103, 84, 97, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 114, 105, 110, 103, 84, 97, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 116, 114, 105, 110, 103, 84, 97, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 105, 116, 105, 111, 110, 97, 108, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 101, 114, 115, 105, 111, 110, 84, 105, 109, 101, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 105, 99, 101, 70, 97, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 108, 101, 115, 115, 73, 110, 118, 111, 107, 101, 82, 101, 113, 117, 101, 115, 116, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 114, 105, 115, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 114, 105, 115, 34, 32, 84, 121, 112, +101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 114, 105, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 105, 99, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 108, 101, 115, 115, 73, 110, 118, 111, 107, 101, 82, 101, 115, 112, 111, 110, 115, 101, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 114, 105, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 105, 99, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, +100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 110, 100, 83, 101, 114, 118, 101, 114, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 85, 114, 105, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 110, 100, 83, 101, 114, 118, 101, 114, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34 +, 83, 101, 114, 118, 101, 114, 79, 110, 78, 101, 116, 119, 111, 114, 107, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 99, 111, 114, 100, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 110, 100, 83, 101, 114, 118, 101, 114, 115, 79, 110, 78, 101, 116, 119, 111, 114, 107, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 105, 110, 103, 82, 101, 99, 111, 114, 100, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 82, 101, 99, 111, 114, 100, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 121, 70, 105, 108, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 121, 70, 105, 108, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 121, 70, 105, 108, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, +112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 110, 100, 83, 101, 114, 118, 101, 114, 115, 79, 110, 78, 101, 116, 119, 111, 114, 107, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 67, 111, 117, 110, 116, 101, 114, 82, 101, 115, 101, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 101, 114, 79, 110, 78, 101, 116, 119, 111, 114, 107, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 73, 110, 115, 116, 97, 110, 99, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 97, 108, 105, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 65, 110, 100, 69, 110, 99, 114, 121, 112, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 84, 111, 107, 101, 110, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, +97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 110, 111, 110, 121, 109, 111, 117, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 100, 84, 111, 107, 101, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 84, 111, 107, 101, 110, 80, 111, 108, 105, 99, 121, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 111, 108, 105, 99, 121, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 111, 107, 101, 110, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 84, 111, 107, 101, 110, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 100, 84, 111, 107, 101, 110, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 114, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 80, 111, 108, 105, 99, 121, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 84, +121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 80, 111, 108, 105, 99, 121, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 84, 111, 107, 101, 110, 80, 111, 108, 105, 99, 121, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 76, 101, 118, 101, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 71, 101, 116, 69, 110, 100, 112, 111, 105, 110, 116, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78 +, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 80, 114, 111, 102, 105, 108, 101, 85, 114, 105, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 71, 101, 116, 69, 110, 100, 112, 111, 105, 110, 116, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 110, 100, 112, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 100, 112, 111, 105, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 110, 100, 112, 111, 105, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 101, 100, 83, 101, 114, 118, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 100, 117, 99, 116, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 78, 97, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 78, 97, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 78, 97, 109, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, +112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 71, 97, 116, 101, 119, 97, 121, 83, 101, 114, 118, 101, 114, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 115, 99, 111, 118, 101, 114, 121, 85, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 85, 114, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 115, 99, 111, 118, 101, 114, 121, 85, 114, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 109, 97, 112, 104, 111, 114, 101, 70, 105, 108, 101, 80, 97, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 79, 110, 108, 105, 110, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 83, 101, 114, 118, 101, 114, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 103, 105, 115, 116, 101, 114, 101, 100, 83, 101, 114, 118, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 83, 101, 114, 118, 101, 114, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13 +, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 100, 110, 115, 68, 105, 115, 99, 111, 118, 101, 114, 121, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 68, 105, 115, 99, 111, 118, 101, 114, 121, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 100, 110, 115, 83, 101, 114, 118, 101, 114, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 105, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 105, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 83, 101, 114, 118, 101, 114, 50, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 103, 105, 115, 116, 101, 114, 101, 100, 83, 101, 114, 118, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 115, 99, 111, 118, 101, 114, 121, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 111, 118, 101, 114, 121, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 115, 99, 111, 118, 101, 114, 121, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 83, 101, 114, 118, 101, 114, 50, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, +108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 84, 111, 107, 101, 110, 82, 101, 113, 117, 101, 115, 116, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 110, 101, 119, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 104, 97, 110, 110, 101, 108, 83, 101, 99, 117, 114, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 104, 97, 110, 110, 101, 108, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 111, 107, 101, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 100, 65, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112 +, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 76, 105, 102, 101, 116, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 110, 83, 101, 99, 117, 114, 101, 67, 104, 97, 110, 110, 101, 108, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 80, 114, 111, 116, 111, 99, 111, 108, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 99, 117, 114, 105, 116, 121, 84, 111, 107, 101, 110, 82, 101, 113, 117, 101, 115, 116, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 78, 111, 110, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 76, 105, 102, 101, 116, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 110, 83, 101, 99, 117, 114, 101, 67, 104, 97, 110, 110, 101, 108, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 80, 114, 111, 116, 111, 99, 111, 108, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 104, 97, 110, 110, 101, 108, 83 +, 101, 99, 117, 114, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 78, 111, 110, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 108, 111, 115, 101, 83, 101, 99, 117, 114, 101, 67, 104, 97, 110, 110, 101, 108, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 108, 111, 115, 101, 83, 101, 99, 117, 114, 101, 67, 104, 97, 110, 110, 101, 108, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 101, 100, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 97, 116, 117, 114, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 84, 111, 107, 101, 110, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 97, 116, 117, 114, 101, 68, 97, 116, 97, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 108, 103, 111, 114, 105, 116, +104, 109, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 105, 103, 110, 97, 116, 117, 114, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 83, 101, 115, 115, 105, 111, 110, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 78, 111, 110, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 83, 101, 115, 115, 105, 111, 110, 84, 105, 109, 101, 111, 117, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 82, 101, 115, 112, 111, 110, 115, 101, 77, 101, 115, 115, 97, 103, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 83, 101, 115, 115, 105, 111, 110, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, +111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 117, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 84, 111, 107, 101, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 83, 101, 115, 115, 105, 111, 110, 84, 105, 109, 101, 111, 117, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 78, 111, 110, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 69, 110, 100, 112, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 69, 110, 100, 112, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 100, 112, 111, 105, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 69, 110, 100, 112, 111, 105, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 103, 110, 101, 100, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 114, 118, 101, 114, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 83, 105, 103, 110, 97, 116, 117, 114, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 103, 110, 97, 116, 117, 114, 101, 68, 97, 116, 97, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 82, 101, +113, 117, 101, 115, 116, 77, 101, 115, 115, 97, 103, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 111, 108, 105, 99, 121, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 110, 111, 110, 121, 109, 111, 117, 115, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 111, 108, 105, 99, 121, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 78, 97, 109, 101, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 111, 108, 105, 99, 121, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 97, 115, 115, 119, 111, 114, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 99, 114, 121, 112, 116, 105, 111, 110, 65, 108, 103, 111, 114, 105, 116, 104, 109, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 88, 53, 48, 57, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105 +, 116, 121, 84, 111, 107, 101, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 111, 108, 105, 99, 121, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 115, 117, 101, 100, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 111, 108, 105, 99, 121, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 111, 107, 101, 110, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 99, 114, 121, 112, 116, 105, 111, 110, 65, 108, 103, 111, 114, 105, 116, 104, 109, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 115, 97, 69, 110, 99, 114, 121, 112, 116, 101, 100, 83, 101, 99, 114, 101, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 99, 99, 69, 110, 99, 114, 121, 112, 116, 101, 100, 83, 101, 99, 114, 101, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 116, 105, 118, 97, 116, 101, 83, 101, 115, 115, 105, 111, 110, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 83, 105, 103, 110, 97, 116, 117, 114, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 103, 110, 97, 116, 117, 114, 101, 68, 97, 116, 97, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, +108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 67, 108, 105, 101, 110, 116, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 103, 110, 101, 100, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 67, 108, 105, 101, 110, 116, 83, 111, 102, 116, 119, 97, 114, 101, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 73, 100, 101, 110, 116, 105, 116, 121, 84, 111, 107, 101, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 84, 111, 107, 101, 110, 83, 105, 103, 110, 97, 116, 117, 114, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 103, 110, 97, 116, 117, 114, 101, 68, 97, 116, 97, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 116, 105, 118, 97, 116, 101, 83, 101, 115, 115, 105, 111, 110, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 78, 111, 110, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, +32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 108, 111, 115, 101, 83, 101, 115, 115, 105, 111, 110, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 108, 111, 115, 101, 83, 101, 115, 115, 105, 111, 110, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 110, 99, 101, 108, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 97, 110, 100, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 110, 99, 101, 108, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116 +, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 97, 110, 99, 101, 108, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 97, 105, 110, 115, 78, 111, 76, 111, 111, 112, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 50, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 53, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 105, 122, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 49, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61 +, 34, 73, 110, 118, 101, 114, 115, 101, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 48, 50, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 48, 52, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 105, 110, 105, 109, 117, 109, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 48, 57, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 49, 57, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 51, 56, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 121, 109, 109, 101, 116, 114, 105, 99, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 55, 54, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 53, 53, 51, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 51, 49, 48, 55, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 50, 49, 52, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 50, 52, 50, 56, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 48, 52, 56, 53, 55, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 48, 57, 55, 49, 53, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 49, 57, 52, 51, 48, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 51, 56, 56, 54, 48, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 55, 55, 55, 50, 49, 54, 34, 32, 47, +62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 108, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 51, 53, 53, 52, 52, 51, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 97, 115, 101, 78, 111, 100, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 53, 48, 49, 50, 50, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 53, 48, 49, 51, 52, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 53, 48, 51, 50, 54, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 53, 55, 49, 51, 56, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 56, 54, 48, 48, 52, 51, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 104, 111, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 54, 51, 50, 53, 52, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 53, 51, 55, 48, 54, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 53, 48, 49, 51, 53, 54, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, +99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62 +, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 105, 110, 105, 109, 117, 109, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, +99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 105, 122, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 104, 111, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 84, 121, 112, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, +114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 114, 105, 97, 98, 108, 101, 84, 121, 112, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117 +, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97 +, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 121, 109, 109, 101, 116, 114, 105, 99, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 101, 114, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, +83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 97, 105, 110, 115, 78, 111, 76, 111, 111, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, +116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 71, 101, 110, 101, 114, 105, 99, 65, 116, 116, 114, 105, 98, 117, 116, 101, 86, 97, 108, 117, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 71, 101, 110, 101, 114, 105, 99, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 112, 101, 99, 105, 102, 105, 101, 100, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 116, 116, 114, 105, 98, 117, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 84, +121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 71, 101, 110, 101, 114, 105, 99, 65, 116, 116, 114, 105, 98, 117, 116, 101, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 116, 116, 114, 105, 98, 117, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 78, 111, 100, 101, 115, 73, 116, 101, 109, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 97, 114, 101, 110, 116, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 78, 101, 119, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 78, 111, 100, 101, 115, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117 +, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 78, 111, 100, 101, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 65, 100, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 65, 100, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 100, 100, 78, 111, 100, 101, 115, 73, 116, 101, 109, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 65, 100, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 78, 111, 100, 101, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 100, 100, 78, 111, 100, 101, 115, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 73, 116, 101, 109, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105 +, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 70, 111, 114, 119, 97, 114, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 83, 101, 114, 118, 101, 114, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 84, 111, 65, 100, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 84, 111, 65, 100, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 100, 100, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 73, 116, 101, 109, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 84, 111, 65, 100, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32 +, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 78, 111, 100, 101, 115, 73, 116, 101, 109, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 84, 97, 114, 103, 101, 116, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 78, 111, 100, 101, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 68, 101, 108, 101, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 68, 101, 108, 101, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 101, 108, 101, 116, 101, 78, 111, 100, 101, 115, 73, 116, 101, 109, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 68, 101, 108, 101, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100 +, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 78, 111, 100, 101, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 73, 116, 101, 109, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 70, 111, 114, 119, 97, 114, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 66, 105, 100, 105, 114, 101, 99, 116, 105, 111, 110, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47 +, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 84, 111, 68, 101, 108, 101, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 84, 111, 68, 101, 108, 101, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 101, 108, 101, 116, 101, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 73, 116, 101, 109, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 84, 111, 68, 101, 108, 101, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, +109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 32, 73, 115, 79, 112, 116, 105, 111, 110, 83, 101, 116, 61, 34, 116, 114, 117, 101, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 114, 114, 97, 121, 68, 105, 109, 101, 110, 115, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 97, 105, 110, 115, 78, 111, 76, 111, 111, 112, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 50, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 53, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 105, 122, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 49, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 101, 114, 115, 101, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 48, 50, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 65, 98, 115, 116, 114, 97, 99, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 48, 52, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 77, 105, 110, 105, 109, 117, 109, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 48, 57, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32 +, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 49, 57, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 51, 56, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 121, 109, 109, 101, 116, 114, 105, 99, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 55, 54, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 53, 53, 51, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 69, 120, 101, 99, 117, 116, 97, 98, 108, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 51, 49, 48, 55, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 54, 50, 49, 52, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 82, 97, 110, 107, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 50, 52, 50, 56, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 77, 97, 115, 107, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 48, 52, 56, 53, 55, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 70, 111, 114, 86, 97, 114, 105, 97, 98, 108, 101, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 48, 57, 55, 49, 53, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 49, 57, 52, 51, 48, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 111, 108, 101, 80, 101, 114, 109, 105, 115, 115, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 51, 56, 56, 54, 48, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 82, 101, 115, 116, 114, 105, 99, 116, 105, 111, 110, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 55, 55, 55, 50, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 99, 99, 101, 115, 115, 76, 101, 118, 101, 108, 69, 120, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 51, 53, 53, 52, 52, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 68, 105, 114, 101, 99, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 73, +110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 70, 111, 114, 119, 97, 114, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 101, 114, 115, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 111, 116, 104, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 97, 108, 105, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 68, 105, 114, 101, 99, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 119, 115, 101, 68, 105, 114, 101, 99, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 99, 108, 117, 100, 101, 83, 117, 98, 116, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58 +, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 77, 97, 115, 107, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 82, 101, 115, 117, 108, 116, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 70, 111, 114, 119, 97, 114, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 108, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 110, 102, 111, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 73, 110, 102, 111, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 48, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, +111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 70, 111, 114, 119, 97, 114, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 67, 108, 97, 115, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 102, 101, 114, 101, 110, 99, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 82, 101, 113, 117, 101 +, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 86, 105, 101, 119, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 77, 97, 120, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 80, 101, 114, 78, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 66, 114, 111, 119, 115, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 66, 114, 111, 119, 115, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 119, 115, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 66, 114, 111, 119, 115, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 119, 115, 101, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, +47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 101, 120, 116, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 101, 97, 115, 101, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 101, 120, 116, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 119, 115, 101, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61 +, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 69, 108, 101, 109, 101, 110, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 73, 110, 118, 101, 114, 115, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 99, 108, 117, 100, 101, 83, 117, 98, 116, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 108, 101, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 69, 108, 101, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 105, 110, 103, 78, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, +116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 84, 97, 114, 103, 101, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 109, 97, 105, 110, 105, 110, 103, 80, 97, 116, 104, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 84, 97, 114, 103, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 97, 114, 103, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 84, 97, 114, 103, 101, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 84, 97, 114, 103, 101, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 108, 97, 116, 101, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 115, 84, 111, 78, 111, 100, 101, 73, 100, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114 +, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 108, 97, 116, 101, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 115, 84, 111, 78, 111, 100, 101, 73, 100, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 78, 111, 100, 101, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 82, 101, 103, 105, 115, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 82, 101, 103, 105, 115, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 82, 101, 103, 105, 115, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 78, 111, 100, 101, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101 +, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 103, 105, 115, 116, 101, 114, 101, 100, 78, 111, 100, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 101, 100, 78, 111, 100, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 103, 105, 115, 116, 101, 114, 101, 100, 78, 111, 100, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 114, 101, 103, 105, 115, 116, 101, 114, 78, 111, 100, 101, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 85, 110, 114, 101, 103, 105, 115, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 85, 110, 114, 101, 103, 105, 115, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 85, 110, 114, 101, 103, 105, 115, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 114, 101, 103, 105, 115, 116, 101, 114, 78, 111, 100, 101, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 117, 110, 116, 101, 114, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121 +, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 101, 114, 105, 99, 82, 97, 110, 103, 101, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 79, 112, 97, 113, 117, 101, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 114, 97, 116, 105, 111, 110, 84, 105, 109, 101, 111, 117, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 66, 105, 110, 97, 114, 121, 69, 110, 99, 111, 100, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 83, 116, 114, 105, 110, 103, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 65, 114, 114, 97, 121, 76, 101, 110, 103, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 77, 101, 115, 115, 97, 103, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 66, 117, 102, 102, 101, 114, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 104, 97, 110, 110, 101, 108, 76, 105, 102, 101, 116, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 84, 111, 107, 101, 110, 76, 105, 102, 101, 116, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 68, 97, 116, 97, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117 +, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 78, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 99, 108, 117, 100, 101, 83, 117, 98, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 81, 117, 101, 114, 121, 68, 97, 116, 97, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 116, 111, 114, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 69, 113, 117, 97, 108, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 115, 78, 117, 108, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 71, 114, 101, 97, 116, 101, 114, 84, 104, 97, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 76, 101, 115, 115, 84, 104, 97, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 71, 114, 101, 97, 116, 101, 114, 84, 104, 97, 110, 79, 114, 69, 113, 117, 97, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34 +, 76, 101, 115, 115, 84, 104, 97, 110, 79, 114, 69, 113, 117, 97, 108, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 76, 105, 107, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 55, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 101, 116, 119, 101, 101, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 76, 105, 115, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 57, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 110, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 115, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 86, 105, 101, 119, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 79, 102, 84, 121, 112, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 97, 116, 101, 100, 84, 111, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 105, 116, 119, 105, 115, 101, 65, 110, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 105, 116, 119, 105, 115, 101, 79, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 55, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 78, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 112, 97, 110, 100, 101, 100, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108 +, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 82, 101, 102, 101, 114, 101, 110, 99, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 84, 121, 112, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 70, 111, 114, 119, 97, 114, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 100, 78, 111, 100, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 100, 78, 111, 100, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 102, 101, 114, 101, 110, 99, 101, 100, 78, 111, 100, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 69, 108, 101, 109, 101, 110, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 116, 111, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 116, 111, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 110, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 110, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 70, 105, 108, 116, 101, +114, 79, 112, 101, 114, 97, 110, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 108, 101, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 69, 108, 101, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 110, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 108, 101, 109, 101, 110, 116, 79, 112, 101, 114, 97, 110, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 110, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 76, 105, 116, 101, 114, 97, 108, 79, 112, 101, 114, 97, 110, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 110, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 79, 112, 101, 114, 97, 110, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 110, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 108, 105, 97, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, +112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 108, 97, 116, 105, 118, 101, 80, 97, 116, 104, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 105, 109, 112, 108, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 79, 112, 101, 114, 97, 110, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 70, 105, 108, 116, 101, 114, 79, 112, 101, 114, 97, 110, 100, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 121, 112, 101, 68, 101, 102, 105, 110, 105, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 69, 108, 101, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 79, 112, 101, 114, 97, 110, 100, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 114, 97, 110, 100, 83, 116, 97, 116, 117, 115, 67, 111, 100 +, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 79, 112, 101, 114, 97, 110, 100, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 79, 112, 101, 114, 97, 110, 100, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 114, 97, 110, 100, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 79, 112, 101, 114, 97, 110, 100, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 108, 101, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 69, 108, 101, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 108, 101, 109, 101, 110, 116, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 108, 101, 109, 101, 110, 116, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 97, 114, 115, 105, 110, 103, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, +115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 70, 105, 114, 115, 116, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 105, 101, 119, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 86, 105, 101, 119, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 84, 121, 112, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 100, 101, 84, 121, 112, 101, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 84, 121, 112, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 68, 97, 116, 97, 83, 101, 116, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34 +, 77, 97, 120, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 70, 105, 114, 115, 116, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 80, 97, 114, 115, 105, 110, 103, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 97, 114, 115, 105, 110, 103, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 97, 114, 115, 105, 110, 103, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 80, 97, 114, 115, 105, 110, 103, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, +32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 78, 101, 120, 116, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 101, 97, 115, 101, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 78, 101, 120, 116, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 81, 117, 101, 114, 121, 68, 97, 116, 97, 83, 101, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 111, 117, 114, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, +32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 66, 111, 116, 104, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 101, 105, 116, 104, 101, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 97, 108, 105, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 86, 97, 108, 117, 101, 73, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 69, 110, 99, 111, 100, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 65, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 82, 101, 97, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 82, 101, 97, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, +115, 58, 82, 101, 97, 100, 86, 97, 108, 117, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 82, 101, 97, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 86, 97, 108, 117, 101, 73, 100, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 69, 110, 99, 111, 100, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 81, 117, 97, 108, 105, 102, 105, 101, 100, 78, 97, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101 +, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 69, 118, 101, 110, 116, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 86, 97, 108, 117, 101, 115, 80, 101, 114, 78, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 118, 101, 110, 116, 70, 105, 108, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 82, 97, 119, 77, 111, 100, 105, 102, 105, 101, 100, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 82, 101, 97, 100, 77, 111, 100, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, +101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 117, 109, 86, 97, 108, 117, 101, 115, 80, 101, 114, 78, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 116, 117, 114, 110, 66, 111, 117, 110, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 80, 114, 111, 99, 101, 115, 115, 101, 100, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 99, 101, 115, 115, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 103, 103, 114, 101, 103, 97, 116, 101, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 103, 103, 114, 101, 103, 97, 116, 101, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 103, 103, 114, 101, 103, 97, 116, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 103, 103, 114, 101, 103, 97, 116, 101, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 103, 103, 114, 101, 103, 97, 116, 101, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 65, 116, 84, 105, 109, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 68, 101, 116 +, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 83, 105, 109, 112, 108, 101, 66, 111, 117, 110, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 65, 110, 110, 111, 116, 97, 116, 105, 111, 110, 68, 97, 116, 97, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 68, 97, 116, 97, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 73, 110, 102, 111, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, +111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 77, 111, 100, 105, 102, 105, 101, 100, 68, 97, 116, 97, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 68, 97, 116, 97, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 97, 116, 97, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 77, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 77, 111, 100, 105, 102, 105, 99, 97, 116, 105, 111, 110, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 69, 118, 101, 110, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 76, 105, 115, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110 +, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 68, 101, 116, 97, 105, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 108, 101, 97, 115, 101, 67, 111, 110, 116, 105, 110, 117, 97, 116, 105, 111, 110, 80, 111, 105, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 82, 101, 97, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 82, 101, 97, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 86, 97, 108, 117, 101, 73, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 82, 101, 97, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, +73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 86, 97, 108, 117, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 116, 116, 114, 105, 98, 117, 116, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 100, 101, 120, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 87, 114, 105, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 115, 84, 111, 87, 114, 105, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 87, 114, 105, 116, 101, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 100, 101, 115, 84, 111, 87, 114, 105, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, +60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 115, 101, 114, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 108, 97, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 102, 111, 114, 109, 85, 112, 100, 97, 116, 101, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 73, 110, 115, 101, +114, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 108, 97, 99, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 109, 111, 118, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 68, 97, 116, 97, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 102, 111, 114, 109, 73, 110, 115, 101, 114, 116, 82, 101, 112, 108, 97, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 101, 114, 102, 111, 114, 109, 85, 112, 100, 97, 116, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 112, 100, 97, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 112, 100, 97, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 102, 111, 114, 109, 73, 110, 115, 101, 114, 116, 82, 101, 112, 108, 97, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 101, 114, 102, 111, 114, 109, 85, 112, 100, 97, 116, 101, 84, 121, 112, 101, 34, 32 +, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 85, 112, 100, 97, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 85, 112, 100, 97, 116, 101, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 85, 112, 100, 97, 116, 101, 69, 118, 101, 110, 116, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 102, 111, 114, 109, 73, 110, 115, 101, 114, 116, 82, 101, 112, 108, 97, 99, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 80, 101, 114, 102, 111, 114, 109, 85, 112, 100, 97, 116, 101, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 118, 101, 110, 116, 70, 105, 108, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 76, 105, 115, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 68, 97, 116, 97, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 82, 97, 119, 77, 111, 100, 105, 102, 105, 101, 100, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 115, 68, 101, 108, +101, 116, 101, 77, 111, 100, 105, 102, 105, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 65, 116, 84, 105, 109, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 113, 84, 105, 109, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 69, 118, 101, 110, 116, 68, 101, 116, 97, 105, 108, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 83, 111, 117, 114, 99, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84 +, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 79, 112, 101, 114, 97, 116, 105, 111, 110, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 112, 101, 114, 97, 116, 105, 111, 110, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 79, 112, 101, 114, 97, 116, 105, 111, 110, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 68, 101, 116, 97, 105, 108, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 82 +, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 108, 108, 77, 101, 116, 104, 111, 100, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 98, 106, 101, 99, 116, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 104, 111, 100, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 108, 108, 77, 101, 116, 104, 111, 100, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, +116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 108, 108, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 77, 101, 116, 104, 111, 100, 115, 84, 111, 67, 97, 108, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 116, 104, 111, 100, 115, 84, 111, 67 +, 97, 108, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 97, 108, 108, 77, 101, 116, 104, 111, 100, 82, 101, 113, 117, 101, 115, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 77, 101, 116, 104, 111, 100, 115, 84, 111, 67, 97, 108, 108, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 97, 108, 108, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 97, 108, 108, 77, 101, 116, 104, 111, 100, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 77, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 97, 98, 108, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 97, 109, 112, 108, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 111, 114, 116, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 67, 104, 97, 110, 103, 101, 84, 114, 105, 103, 103, 101, 114, 34, 32, 76, 101, 110, 103, 116, 104, +73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 86, 97, 108, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 86, 97, 108, 117, 101, 84, 105, 109, 101, 115, 116, 97, 109, 112, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 97, 100, 98, 97, 110, 100, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 98, 115, 111, 108, 117, 116, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 99, 101, 110, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 70, 105, 108, 116, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 67, 104, 97, 110, 103, 101, 70, 105, 108, 116, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 70, 105, 108, 116, 101, 114, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 105, 103, 103, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 68, 97, 116, 97, 67, 104, 97, 110, 103, 101, 84, 114, 105, 103, 103, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 97, 100, 98, 97, 110, 100, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 97, 100, 98, 97, 110, 100, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 70, 105, 108, 116, 101, 114, 34, 32, 66, 97, 115 +, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 70, 105, 108, 116, 101, 114, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 105, 109, 112, 108, 101, 65, 116, 116, 114, 105, 98, 117, 116, 101, 79, 112, 101, 114, 97, 110, 100, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 104, 101, 114, 101, 67, 108, 97, 117, 115, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 103, 103, 114, 101, 103, 97, 116, 101, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 83, 101, 114, 118, 101, 114, 67, 97, 112, 97, 98, 105, 108, 105, 116, 105, 101, 115, 68, 101, 102, 97, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 101, 97, 116, 85, 110, 99, 101, 114, 116, 97, 105, 110, 65, 115, 66, 97, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 99, 101, 110, 116, 68, 97, 116, 97, 66, 97, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 99, 101, 110, 116, 68, 97, 116, 97, 71, 111, 111, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 83, 108, 111, 112, 101, 100, 69, 120, 116, 114, 97, 112, 111, 108, 97, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 103, 103, 114, 101, 103, 97, 116, 101, 70, 105, 108, 116, 101, 114, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 70, 105, 108, 116, 101, 114, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, +100, 32, 78, 97, 109, 101, 61, 34, 65, 103, 103, 114, 101, 103, 97, 116, 101, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 99, 101, 115, 115, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 103, 103, 114, 101, 103, 97, 116, 101, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 103, 103, 114, 101, 103, 97, 116, 101, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 101, 108, 101, 99, 116, 67, 108, 97, 117, 115, 101, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 104, 101, 114, 101, 67, 108, 97, 117, 115, 101, 82, 101, 115, 117, 108, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 67, 111, 110, 116, 101, 110, 116, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112 +, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 103, 103, 114, 101, 103, 97, 116, 101, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 83, 116, 97, 114, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 80, 114, 111, 99, 101, 115, 115, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 65, 103, 103, 114, 101, 103, 97, 116, 101, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 103, 103, 114, 101, 103, 97, 116, 101, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 72, 97, 110, 100, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 117, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 97, 114, 100, 79, 108, 100, 101, 115, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 114, 101, 97, 116, 101, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, +116, 101, 109, 84, 111, 77, 111, 110, 105, 116, 111, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 97, 100, 86, 97, 108, 117, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 114, 101, 97, 116, 101, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 81, 117, 101, 117, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, +100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 73, 116, 101, 109, 115, 84, 111, 67, 114, 101, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 116, 101, 109, 115, 84, 111, 67, 114, 101, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 114, 101, 97, 116, 101, 82, 101, 113, 117, 101, 115, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 73, 116, 101, 109, 115, 84, 111, 67, 114, 101, 97, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 114, 101, 97, 116, 101, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 77, 111, 100, 105, 102, 121, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, +77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 80, 97, 114, 97, 109, 101, 116, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 77, 111, 100, 105, 102, 121, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 81, 117, 101, 117, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 70, 105, 108, 116, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 84, 105, 109, 101, 115, 116, 97, 109, 112, 115, 84, 111, 82, 101, 116, 117, 114, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 73, 116, 101, 109, 115, 84, 111, 77, 111, 100, 105, 102, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, +112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 116, 101, 109, 115, 84, 111, 77, 111, 100, 105, 102, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 77, 111, 100, 105, 102, 121, 82, 101, 113, 117, 101, 115, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 73, 116, 101, 109, 115, 84, 111, 77, 111, 100, 105, 102, 121, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 77, 111, 100, 105, 102, 121, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 77, 111, 100, 101, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, +114, 105, 110, 103, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 77, 111, 100, 101, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 84, 114, 105, 103, 103, 101, 114, 105, 110, 103, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108 +, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 105, 103, 103, 101, 114, 105, 110, 103, 73, 116, 101, 109, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 105, 110, 107, 115, 84, 111, 65, 100, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 105, 110, 107, 115, 84, 111, 65, 100, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 105, 110, 107, 115, 84, 111, 65, 100, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 105, 110, 107, 115, 84, 111, 82, 101, 109, 111, 118, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 105, 110, 107, 115, 84, 111, 82, 101, 109, 111, 118, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 105, 110, 107, 115, 84, 111, 82, 101, 109, 111, 118, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 84, 114, 105, 103, 103, 101, 114, 105, 110, 103, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 100, 100, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 100, 100, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 100, 100, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, +61, 34, 78, 111, 79, 102, 65, 100, 100, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 109, 111, 118, 101, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 109, 111, 118, 101, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 109, 111, 118, 101, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 109, 111, 118, 101, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 109, 111, 118, 101, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 109, 111, 118, 101, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, +105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 76, 105, 102, 101, 116, 105, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 77, 97, 120, 75, 101, 101, 112, 65, 108, 105, 118, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 80, 101, 114, 80, 117, 98, 108, 105, 115, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, +104, 105, 110, 103, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 105, 111, 114, 105, 116, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 76, 105, 102, 101, 116, 105, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 77, 97, 120, 75, 101, 101, 112, 65, 108, 105, 118, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117 +, 101, 115, 116, 101, 100, 76, 105, 102, 101, 116, 105, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 101, 100, 77, 97, 120, 75, 101, 101, 112, 65, 108, 105, 118, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 80, 101, 114, 80, 117, 98, 108, 105, 115, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 105, 111, 114, 105, 116, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 76, 105, 102, 101, 116, 105, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 118, 105, 115, 101, 100, 77, 97, 120, 75, 101, 101, 112, 65, 108, 105, 118, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 77, 111, 100, 101, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32 +, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 77, 111, 100, 101, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 77, 101, 115, 115, 97, 103, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108 +, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 68, 97, 116, 97, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 68, 97, 116, 97, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 68, 97, 116, 97, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 67, 104, 97, 110, 103, 101, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 68, 97, 116, 97, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 72, 97, 110, 100, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, +34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 97, 116, 97, 86, 97, 108, 117, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 76, 105, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 68, 97, 116, 97, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 76, 105, 115, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 76, 105, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 72, 97, 110, 100, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 76, 105, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 118, 101, 110, 116, 70, 105, 101, 108, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116 +, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 104, 97, 110, 103, 101, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 116, 110, 115, 58, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 68, 97, 116, 97, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 65, 99, 107, 110, 111, 119, 108, 101, 100, 103, 101, 109, 101, 110, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 65, 99, 107, 110, 111, 119, 108, 101, 100, 103, 101, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 65, 99, 107, 110, 111, 119, 108, 101, 100, 103, 101, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 65, 99, 107, 110, 111, 119, 108, 101, 100, 103, 101, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 65, 99, 107, 110, 111, 119, 108, 101, 100, 103, 101, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60 +, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 118, 97, 105, 108, 97, 98, 108, 101, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 118, 97, 105, 108, 97, 98, 108, 101, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 118, 97, 105, 108, 97, 98, 108, 101, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 114, 101, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 77, 101, 115, 115, 97, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 77, 101, 115, 115, 97, 103, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, +100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 117, 98, 108, 105, 115, 104, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 116, 114, 97, 110, 115, 109, 105, 116, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 117, 98, 108, 105, 115, 104, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 77, 101, 115, 115, 97, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 77, 101, 115, 115, 97, 103, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 102, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 118, 97, 105, 108, 97, 98, 108, 101, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 118, 97, 105, 108, 97, 98, 108, 101, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 118, 97, 105, 108, 97, 98, 108, 101, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13 +, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 102, 101, 114, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 110, 100, 73, 110, 105, 116, 105, 97, 108, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 102, 101, 114, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 84, 114, 97, 110, 115, 102, 101, 114, 82, 101, 115, 117, 108, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32 +, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 82, 101, 113, 117, 101, 115, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 113, 117, 101, 115, 116, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 82, 101, 115, 112, 111, 110, 115, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 82, 101, 115, 112, 111, 110, 115, 101, 72, 101, 97, 100, 101, 114, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 115, 117, 108, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 82, 101, 115, 117, 108, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, +61, 34, 66, 117, 105, 108, 100, 73, 110, 102, 111, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 100, 117, 99, 116, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 110, 117, 102, 97, 99, 116, 117, 114, 101, 114, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 100, 117, 99, 116, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 111, 102, 116, 119, 97, 114, 101, 86, 101, 114, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 117, 105, 108, 100, 78, 117, 109, 98, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 117, 105, 108, 100, 68, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 100, 117, 110, 100, 97, 110, 99, 121, 83, 117, 112, 112, 111, 114, 116, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 110, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 108, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 87, 97, 114, 109, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 111, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 97, 114, 101, 110, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 72, 111, 116, 65, 110, 100, 77, 105, 114, 114, 111, 114, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 83, 116, 97, 116, 101, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, +10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 117, 110, 110, 105, 110, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 70, 97, 105, 108, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 67, 111, 110, 102, 105, 103, 117, 114, 97, 116, 105, 111, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 117, 115, 112, 101, 110, 100, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 83, 104, 117, 116, 100, 111, 119, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 84, 101, 115, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 53, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 109, 109, 117, 110, 105, 99, 97, 116, 105, 111, 110, 70, 97, 117, 108, 116, 34, 32, 86, 97, 108, 117, 101, 61, 34, 54, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 107, 110, 111, 119, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 55, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 100, 117, 110, 100, 97, 110, 116, 83, 101, 114, 118, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 105, 99, 101, 76, 101, 118, 101, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 83, 116, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 101, 114, 83, 116, 97, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 76, 105, 115, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 76, 105, 115, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73 +, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 76, 105, 115, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 76, 105, 115, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 71, 114, 111, 117, 112, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 78, 101, 116, 119, 111, 114, 107, 80, 97, 116, 104, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 116, 119, 111, 114, 107, 80, 97, 116, 104, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 76, 105, 115, 116, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 78, 101, 116, 119, 111, 114, 107, 80, 97, 116, 104, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 97, 109, 112, 108, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 97, 98, 108, 101, 100, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, +114, 118, 101, 114, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 83, 117, 109, 109, 97, 114, 121, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 86, 105, 101, 119, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 83, 101, 115, 115, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 109, 117, 108, 97, 116, 101, 100, 83, 101, 115, 115, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 82, 101, 106, 101, 99, 116, 101, 100, 83, 101, 115, 115, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 106, 101, 99, 116, 101, 100, 83, 101, 115, 115, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 84, 105, 109, 101, 111, 117, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 65, 98, 111, 114, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 109, 117, 108, 97, 116, 101, 100, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 82, 101, 106, 101, 99, 116, 101, 100, 82, 101, 113, 117, 101, 115, 116, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 106, 101, 99, 116, 101, 100, 82, 101, 113, 117, 101, 115, 116, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32 +, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 83, 116, 97, 116, 117, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 114, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 101, 114, 83, 116, 97, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 117, 105, 108, 100, 73, 110, 102, 111, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 66, 117, 105, 108, 100, 73, 110, 102, 111, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 111, 110, 100, 115, 84, 105, 108, 108, 83, 104, 117, 116, 100, 111, 119, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 104, 117, 116, 100, 111, 119, 110, 82, 101, 97, 115, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 112, 112, 108, 105, 99, 97, 116, 105, 111, 110, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 101, 114, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 100, 112, 111, 105, 110, 116, 85, 114, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112 +, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 111, 99, 97, 108, 101, 73, 100, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 99, 116, 117, 97, 108, 83, 101, 115, 115, 105, 111, 110, 84, 105, 109, 101, 111, 117, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 82, 101, 115, 112, 111, 110, 115, 101, 77, 101, 115, 115, 97, 103, 101, 83, 105, 122, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 76, 97, 115, 116, 67, 111, 110, 116, 97, 99, 116, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 80, 117, 98, 108, 105, 115, 104, 82, 101, 113, 117, 101, 115, 116, 115, 73, 110, 81, 117, 101, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 111, 116, 97, 108, 82, 101, 113, 117, 101, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 110, 97, 117, 116, 104, 111, 114, 105, 122, 101, 100, 82, 101, 113, 117, 101, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 100, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, +101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 82, 101, 97, 100, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 87, 114, 105, 116, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 115, 116, 111, 114, 121, 85, 112, 100, 97, 116, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 97, 108, 108, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 77, 111, 100, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 84, 114, 105, 103, 103, 101, 114, 105, 110, 103, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, +111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 116, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 77, 111, 100, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 117, 98, 108, 105, 115, 104, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 102, 101, 114, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 78, 111, 100, 101, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 100, 100, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 78, 111, 100, 101, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 108, 101, 116, 101, 82, 101, 102, 101, 114, 101, 110, 99, 101, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 66, 114, 111, 119, 115, 101, 78, 101, 120, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101 +, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 108, 97, 116, 101, 66, 114, 111, 119, 115, 101, 80, 97, 116, 104, 115, 84, 111, 78, 111, 100, 101, 73, 100, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 70, 105, 114, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 81, 117, 101, 114, 121, 78, 101, 120, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 103, 105, 115, 116, 101, 114, 78, 111, 100, 101, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 110, 114, 101, 103, 105, 115, 116, 101, 114, 78, 111, 100, 101, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 83, 101, 99, 117, 114, 105, 116, 121, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 85, 115, 101, 114, 73, 100, 79, 102, 83, 101, 115, 115, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 67, 108, 105, 101, 110, 116, 85, 115, 101, 114, 73, 100, 72, 105, 115, 116, 111, 114, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 85, 115, 101, 114, 73, 100, 72, 105, 115, 116, 111, 114, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 67, 108, 105, 101, 110, 116, 85, 115, 101, 114, 73, 100, 72, 105, 115, 116, 111, 114, 121, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 117 +, 116, 104, 101, 110, 116, 105, 99, 97, 116, 105, 111, 110, 77, 101, 99, 104, 97, 110, 105, 115, 109, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 99, 111, 100, 105, 110, 103, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 112, 111, 114, 116, 80, 114, 111, 116, 111, 99, 111, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 77, 101, 115, 115, 97, 103, 101, 83, 101, 99, 117, 114, 105, 116, 121, 77, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 99, 117, 114, 105, 116, 121, 80, 111, 108, 105, 99, 121, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 108, 105, 101, 110, 116, 67, 101, 114, 116, 105, 102, 105, 99, 97, 116, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 114, 118, 105, 99, 101, 67, 111, 117, 110, 116, 101, 114, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 111, 116, 97, 108, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 114, 114, 111, 114, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 82, 101, 115, 117, 108, 116, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 83, 116, 97, 116, 117, 115, 67, 111, 100, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 73, 110, 102, 111, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105 +, 111, 110, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 115, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 83, 117, 98, 115, 99, 114, 105, 112, 116, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 114, 105, 111, 114, 105, 116, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 73, 110, 116, 101, 114, 118, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 75, 101, 101, 112, 65, 108, 105, 118, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 76, 105, 102, 101, 116, 105, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 97, 120, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 80, 101, 114, 80, 117, 98, 108, 105, 115, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 105, 110, 103, 69, 110, 97, 98, 108, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 111, 111, 108, 101, 97, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 105, 102, 121, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 97, 98, 108, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 97, 98, 108, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 117, 98, 108, 105, 115, 104, 82, 101, 113, 117, 101, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 112, 117, 98, 108, 105, 115, 104, 77, 101, 115, 115, 97, 103, 101, 82, 101, 113, 117, 101, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101 +, 61, 34, 82, 101, 112, 117, 98, 108, 105, 115, 104, 77, 101, 115, 115, 97, 103, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 102, 101, 114, 82, 101, 113, 117, 101, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 102, 101, 114, 114, 101, 100, 84, 111, 65, 108, 116, 67, 108, 105, 101, 110, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 114, 97, 110, 115, 102, 101, 114, 114, 101, 100, 84, 111, 83, 97, 109, 101, 67, 108, 105, 101, 110, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 80, 117, 98, 108, 105, 115, 104, 82, 101, 113, 117, 101, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 67, 104, 97, 110, 103, 101, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 116, 101, 80, 117, 98, 108, 105, 115, 104, 82, 101, 113, 117, 101, 115, 116, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 75, 101, 101, 112, 65, 108, 105, 118, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 117, 114, 114, 101, 110, 116, 76, 105, 102, 101, 116, 105, 109, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 110, 97, 99, 107, 110, 111, 119, 108, 101, 100, 103, 101, 100, 77, 101, 115, 115, 97, 103, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 99, 97, 114, 100, 101, 100, 77, 101, 115, 115, 97, 103, 101, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, +10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 97, 98, 108, 101, 100, 77, 111, 110, 105, 116, 111, 114, 101, 100, 73, 116, 101, 109, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 111, 110, 105, 116, 111, 114, 105, 110, 103, 81, 117, 101, 117, 101, 79, 118, 101, 114, 102, 108, 111, 119, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 101, 120, 116, 83, 101, 113, 117, 101, 110, 99, 101, 78, 117, 109, 98, 101, 114, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 118, 101, 110, 116, 81, 117, 101, 117, 101, 79, 118, 101, 114, 70, 108, 111, 119, 67, 111, 117, 110, 116, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 85, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 101, 108, 67, 104, 97, 110, 103, 101, 83, 116, 114, 117, 99, 116, 117, 114, 101, 86, 101, 114, 98, 77, 97, 115, 107, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 65, 100, 100, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 78, 111, 100, 101, 68, 101, 108, 101, 116, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 65, 100, 100, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 82, 101, 102, 101, 114, 101, 110, 99, 101, 68, 101, 108, 101, 116, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 56, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 68, 97, 116, 97, 84, 121, 112, 101, 67, 104, 97, 110, 103, 101, 100, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 54, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 77, 111, 100, 101, 108, 67, 104, 97, 110, 103, 101, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 102, 102, 101, 99, 116, 101, 100 +, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 102, 102, 101, 99, 116, 101, 100, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 101, 114, 98, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 66, 121, 116, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 83, 101, 109, 97, 110, 116, 105, 99, 67, 104, 97, 110, 103, 101, 83, 116, 114, 117, 99, 116, 117, 114, 101, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 102, 102, 101, 99, 116, 101, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 102, 102, 101, 99, 116, 101, 100, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 82, 97, 110, 103, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 111, 119, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 72, 105, 103, 104, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 85, 73, 110, 102, 111, 114, 109, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 97, 109, 101, 115, 112, 97, 99, 101, 85, 114, 105, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 110, 105, 116, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 105, 115, 112, 108, 97, 121, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 68, 101, 115, 99, 114, 105, 112, 116, 105, 111, 110, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, +116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 120, 105, 115, 83, 99, 97, 108, 101, 69, 110, 117, 109, 101, 114, 97, 116, 105, 111, 110, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 76, 105, 110, 101, 97, 114, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 76, 111, 103, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 76, 110, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 67, 111, 109, 112, 108, 101, 120, 78, 117, 109, 98, 101, 114, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 70, 108, 111, 97, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 109, 97, 103, 105, 110, 97, 114, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 70, 108, 111, 97, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 68, 111, 117, 98, 108, 101, 67, 111, 109, 112, 108, 101, 120, 78, 117, 109, 98, 101, 114, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 82, 101, 97, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 109, 97, 103, 105, 110, 97, 114, 121, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 120, 105, 115, 73, 110, 102, 111, 114, 109, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 110, 103, 105, 110, 101, 101, 114, 105, 110, 103, 85, 110, 105, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 69, 85, 73, 110, 102, 111, 114, 109, 97, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 69, 85, 82, 97, 110, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, +58, 82, 97, 110, 103, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 84, 105, 116, 108, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 76, 111, 99, 97, 108, 105, 122, 101, 100, 84, 101, 120, 116, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 120, 105, 115, 83, 99, 97, 108, 101, 84, 121, 112, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 120, 105, 115, 83, 99, 97, 108, 101, 69, 110, 117, 109, 101, 114, 97, 116, 105, 111, 110, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 65, 120, 105, 115, 83, 116, 101, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 120, 105, 115, 83, 116, 101, 112, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 65, 120, 105, 115, 83, 116, 101, 112, 115, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 88, 86, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 88, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 111, 117, 98, 108, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 86, 97, 108, 117, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 70, 108, 111, 97, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 103, 114, 97, 109, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 67, 108, 105, 101, 110, 116, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 111, 99, 97, 116, 105, 111, 110, 67, 114, 101, 97, 116, 105, 111, 110, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 84, 114, 97, 110, 115, 105, 116, 105, 111, 110, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 67, 97, 108, 108, 34, 32, +84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 114, 103, 117, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 114, 103, 117, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 67, 97, 108, 108, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 82, 101, 116, 117, 114, 110, 83, 116, 97, 116, 117, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 97, 116, 117, 115, 82, 101, 115, 117, 108, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 80, 114, 111, 103, 114, 97, 109, 68, 105, 97, 103, 110, 111, 115, 116, 105, 99, 50, 68, 97, 116, 97, 84, 121, 112, 101, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 67, 114, 101, 97, 116, 101, 67, 108, 105, 101, 110, 116, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 73, 110, 118, 111, 99, 97, 116, 105, 111, 110 +, 67, 114, 101, 97, 116, 105, 111, 110, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 84, 114, 97, 110, 115, 105, 116, 105, 111, 110, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 67, 97, 108, 108, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 83, 101, 115, 115, 105, 111, 110, 73, 100, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 78, 111, 100, 101, 73, 100, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 114, 103, 117, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 65, 114, 103, 117, 109, 101, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 65, 114, 103, 117, 109, 101, 110, 116, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 73, 110, 112, 117, 116, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 73, 110, 116, 51, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, +78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 86, 97, 108, 117, 101, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 117, 97, 58, 86, 97, 114, 105, 97, 110, 116, 34, 32, 76, 101, 110, 103, 116, 104, 70, 105, 101, 108, 100, 61, 34, 78, 111, 79, 102, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 79, 117, 116, 112, 117, 116, 86, 97, 108, 117, 101, 115, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 67, 97, 108, 108, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 76, 97, 115, 116, 77, 101, 116, 104, 111, 100, 82, 101, 116, 117, 114, 110, 83, 116, 97, 116, 117, 115, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 116, 110, 115, 58, 83, 116, 97, 116, 117, 115, 82, 101, 115, 117, 108, 116, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 65, 110, 110, 111, 116, 97, 116, 105, 111, 110, 34, 32, 66, 97, 115, 101, 84, 121, 112, 101, 61, 34, 117, 97, 58, 69, 120, 116, 101, 110, 115, 105, 111, 110, 79, 98, 106, 101, 99, 116, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 77, 101, 115, 115, 97, 103, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 85, 115, 101, 114, 78, 97, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 83, 116, 114, 105, 110, 103, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 70, 105, 101, 108, 100, 32, 78, 97, 109, 101, 61, 34, 65, 110, 110, 111, 116, 97, 116, 105, 111, 110, 84, 105, 109, 101, 34, 32, 84, 121, 112, 101, 78, 97, 109, 101, 61, 34, 111, 112, 99, 58, 68, 97, 116, 101, 84, 105, 109, 101, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 83, 116, 114, 117, 99, 116, 117, 114, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 32, 78, 97, 109, 101, 61, 34, 69, 120, 99, 101, 112, 116, 105, 111, 110, 68, 101, 118, 105, 97, 116, 105, 111, 110, 70, 111, 114, 109, 97, 116, 34, 32, 76, 101, 110, 103, 116, 104, 73, 110, 66, 105, 116, 115, 61, 34, 51, 50, 34, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 65, 98, 115, 111, 108, 117, 116, 101, 86, 97, 108, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 48, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 99, 101, 110, 116, 79, 102, 86, 97, 108, 117, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 49, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 99, 101, 110, 116, 79, 102, 82, 97, 110, 103, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 50, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 80, 101, 114, 99, 101, 110, 116, 79, 102, 69, 85, 82, 97, 110, 103, 101, 34, 32, 86, 97, 108, 117, 101, 61, 34, 51, 34, 32, 47, 62, 13, 10, 32, 32, 32, 32, 60, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 86, 97, 108, 117, 101, 32, 78, 97, 109, 101, 61, 34, 85, 110, 107, 110, 111, 119, 110, 34, 32, 86, 97, 108, 117, +101, 61, 34, 52, 34, 32, 47, 62, 13, 10, 32, 32, 60, 47, 111, 112, 99, 58, 69, 110, 117, 109, 101, 114, 97, 116, 101, 100, 84, 121, 112, 101, 62, 13, 10, 13, 10, 60, 47, 111, 112, 99, 58, 84, 121, 112, 101, 68, 105, 99, 116, 105, 111, 110, 97, 114, 121, 62}; + + diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_server.c b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_server.c new file mode 100755 index 00000000..b3d24eba --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_server.c @@ -0,0 +1,38 @@ +/* +* Copyright (c) 2021 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + + +#include "open62541.h" + +#include +#include + +UA_Boolean running = true; + +static void stopHandler(int sign) { + UA_LOG_INFO(UA_Log_Stdout, UA_LOGCATEGORY_SERVER, "received ctrl-c"); + running = false; +} + +int ua_server_connect(void) +{ + signal(SIGINT, stopHandler); + signal(SIGTERM, stopHandler); + + UA_Server *server = UA_Server_new(); + UA_ServerConfig_setDefault(UA_Server_getConfig(server)); + UA_StatusCode retval = UA_Server_run(server, &running); + + UA_Server_delete(server); + + return retval == UA_STATUSCODE_GOOD ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/APP_Framework/Framework/control/plc/interoperability/opcua/ua_test.c b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_test.c new file mode 100755 index 00000000..60da4348 --- /dev/null +++ b/APP_Framework/Framework/control/plc/interoperability/opcua/ua_test.c @@ -0,0 +1,30 @@ +/* +* Copyright (c) 2021 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +int16 ua_test(void) +{ + UA_Client *client = UA_Client_new(); + UA_StatusCode retval = UA_Client_connect(client, OPC_SERVER); + if(retval != UA_STATUSCODE_GOOD) { + UA_Client_delete(client); + return (int)retval; + } + + ua_read_time(client); + ua_run_test(client); + + /* Clean up */ + UA_Client_disconnect(client); + UA_Client_delete(client); /* Disconnects the client internally */ + return EXIT_SUCCESS; +} + diff --git a/APP_Framework/Framework/control/plc/shared/Kconfig b/APP_Framework/Framework/control/plc/shared/Kconfig new file mode 100755 index 00000000..1ad617c8 --- /dev/null +++ b/APP_Framework/Framework/control/plc/shared/Kconfig @@ -0,0 +1,4 @@ +menuconfig USING_CONTROL_PLC_COMMON + bool "PLC common" + default y + diff --git a/APP_Framework/Framework/control/plc/shared/Makefile b/APP_Framework/Framework/control/plc/shared/Makefile new file mode 100755 index 00000000..03bb1bbf --- /dev/null +++ b/APP_Framework/Framework/control/plc/shared/Makefile @@ -0,0 +1,4 @@ +SRC_FILES := plc.c + +include $(KERNEL_ROOT)/compiler.mk + diff --git a/APP_Framework/Framework/control/plc/shared/plc.c b/APP_Framework/Framework/control/plc/shared/plc.c new file mode 100755 index 00000000..b3020683 --- /dev/null +++ b/APP_Framework/Framework/control/plc/shared/plc.c @@ -0,0 +1,57 @@ +/* +* Copyright (c) 2021 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** + * @file plc.c + * @brief plc relative activities + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.12.15 + */ + +#include "../interoperability/opcua/open62541.h" +#include "plc.h" + + +struct PlcDevice plc_device; + +// open and connect PLC device +void plc_open(struct PlcDevice *pdev) +{ +} + +// close and disconnect PLC device +void plc_close(struct PlcDevice *pdev) +{ +} + +// read data from PLC +void plc_read(struct PlcDevice *pdev, void *buf, size_t len) +{ +} + +// write data from PLC +void plc_write(struct PlcDevice *pdev, const void *buf, size_t len) +{ +} + +// send control command to PLC +void plc_ioctl(struct PlcDevice *pdev, int cmd, void *arg) +{ +} + + +void plc_init(struct PlcDevice *plc_dev) +{ +} + + diff --git a/APP_Framework/Framework/control/plc/shared/plc.h b/APP_Framework/Framework/control/plc/shared/plc.h new file mode 100755 index 00000000..a36ef33b --- /dev/null +++ b/APP_Framework/Framework/control/plc/shared/plc.h @@ -0,0 +1,124 @@ +/* +* Copyright (c) 2021 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** + * @file plc.h + * @brief plc relative definition and structure + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.12.15 + */ + +#include "xs_klist.h" + +#define IP_ADDR_SIZE 32 +#define PLC_NAME_SIZE 32 + +// PLC device information +struct PlcInfo { + uint32_t ability; // PLC ability + uint32_t id; // PLC Device ID + uint32_t soft_version; // software version + uint32_t hard_version; // hardware version + uint32_t date; // manufact date + const char *vendor; // vendor + const char *model; // product model +}; + +enum PlcSerialType { + PLC_SERIAL_232, + PLC_SERIAL_485, + PLC_SERIAL_CAN +}; + +union PlcCfg { + struct { + char ip_addr[IP_ADDR_SIZE]; + uint32_t ip_port; + } PlcIpCfg; + struct { + enum PlcSerialType serial_type; + char station_id; + char serial_port; + } PlcSerialCfg; +}; + +struct PlcDevice; + +// operation API +struct PlcOps { + int (*open)(struct PlcDevice *pdev); // open and connect PLC device + void (*close)(struct PlcDevice*pdev); // close and disconnect PLC device + int (*read)(struct PlcDevice* pdev, void *buf, size_t len); // read data from PLC + int (*write)(struct PlcDevice* pdev, const void *buf, size_t len); // write data from PLC + int (*ioctl)(struct PlcDevice* pdev, int cmd, void *arg); // send control command to PLC +}; + +enum PlcCtlType { + PLC_CTRL_TYPE_HSC, + PLC_CTRL_TYPE_PID, + PLC_CTRL_TYPE_PHASING +}; + + +#define PLC_ABILITY_HSC ((uint32_t)(1 << PLC_CTRL_TYPE_HSC)) +#define PLC_ABILITY_PID ((uint32_t)(1 << PLC_CTRL_TYPE_PID)) +#define PLC_ABILITY_PHASING ((uint32_t)(1 << PLC_CTRL_TYPE_PHASING)) + + +enum PlcIndHybridNet +{ + //PLC Field Bus + PLC_IND_FIELD_MODBUS_485, + PLC_IND_FIELD_PROFIBUS, + PLC_IND_FIELD_CANOPEN, + PLC_IND_FIELD_DEVICENET, + PLC_IND_FIELD_CONTROLNET, + + // PLC ETHERNET + PLC_IND_ENET_ETHERNET_IP, + PLC_IND_ENET_PROFINET, + PLC_IND_ENET_ETHERCAT, + PLC_IND_ENET_SERCOS, + PLC_IND_ENET_OPCUA, + + //PLC wireless net + PLC_IND_WIRELESS +}; + +enum PlcTransType +{ + PLC_TRANS_TCP, + PLC_TRANS_UDP, + PLC_TRANS_SERIAL +}; + +//communication interface +struct PlcInterface +{ + enum PlcIndHybridNet net; + enum PlcTransType trans; + char ip_addr[IP_ADDR_SIZE]; + char attrib; +}; + +// identify PLC device +struct PlcDevice { + const char name[PLC_NAME_SIZE]; /* name of the device */ + enum PlcCtlType type; /* PLC Control Type */ + struct PlcInfo info;/* Plc info, such as vendor name and model name */ + union PlcCfg cfg; + struct PlcOps ops; /* filesystem-like APIs for data transferring */ + struct PlcInterface interface; /* protocols used for transferring data from program to plc */ + DoubleLinklistType link;/* link list node */ +}; + diff --git a/APP_Framework/Framework/control/shared/Makefile b/APP_Framework/Framework/control/shared/Makefile new file mode 100755 index 00000000..f16a4f9b --- /dev/null +++ b/APP_Framework/Framework/control/shared/Makefile @@ -0,0 +1,5 @@ +SRC_DIR := + +include $(KERNEL_ROOT)/compiler.mk + + diff --git a/APP_Framework/Framework/control/shared/control.c b/APP_Framework/Framework/control/shared/control.c new file mode 100755 index 00000000..4ec32b19 --- /dev/null +++ b/APP_Framework/Framework/control/shared/control.c @@ -0,0 +1,11 @@ + +void control_init(void) +{ + +} + +void control_read_file() +{ +} + + diff --git a/Ubiquitous/XiUOS/arch/arm/cortex-m7/arch_interrupt.h b/Ubiquitous/XiUOS/arch/arm/cortex-m7/arch_interrupt.h index d222a7c5..589d49e2 100644 --- a/Ubiquitous/XiUOS/arch/arm/cortex-m7/arch_interrupt.h +++ b/Ubiquitous/XiUOS/arch/arm/cortex-m7/arch_interrupt.h @@ -17,11 +17,17 @@ #define ARCH_MAX_IRQ_NUM (256) -#define ARCH_IRQ_NUM_OFFSET 0 +//#define ARCH_IRQ_NUM_OFFSET 0 -#define SYSTICK_IRQN 15 -#define UART1_IRQn 36 -#define UART2_IRQn 37 +//#define SYSTICK_IRQN 15 +//#define UART1_IRQn 36 +//#define UART2_IRQn 37 + +#define ARCH_IRQ_NUM_OFFSET 16 + +#define SYSTICK_IRQN -1 +#define UART1_IRQn 20 +#define UART2_IRQn 21 int32 ArchEnableHwIrq(uint32 irq_num); int32 ArchDisableHwIrq(uint32 irq_num); diff --git a/Ubiquitous/XiUOS/board/ok1052-c/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/Makefile index 7d8e5a55..83711842 100644 --- a/Ubiquitous/XiUOS/board/ok1052-c/Makefile +++ b/Ubiquitous/XiUOS/board/ok1052-c/Makefile @@ -1,5 +1,5 @@ -SRC_DIR := third_party_driver +SRC_DIR := third_party_driver -SRC_FILES := board.c clock_config.c pin_mux.c +SRC_FILES := board.c include $(KERNEL_ROOT)/compiler.mk \ No newline at end of file diff --git a/Ubiquitous/XiUOS/board/ok1052-c/board.c b/Ubiquitous/XiUOS/board/ok1052-c/board.c index 1462ec89..fe07ae86 100644 --- a/Ubiquitous/XiUOS/board/ok1052-c/board.c +++ b/Ubiquitous/XiUOS/board/ok1052-c/board.c @@ -5,32 +5,40 @@ * SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + /** -* @file board.c -* @brief support imxrt1052-board init configure and start-up -* @version 1.0 -* @author AIIT XUOS Lab -* @date 2021-05-29 -*/ - -/************************************************* -File name: board.c -Description: support imxrt1052-board init configure and driver/task/... init -Others: take SDK_2.6.1_MIMXRT1052xxxxB/devices/MIMXRT1052/project_template/board.c -History: -1. Date: 2021-05-29 -Author: AIIT XUOS Lab -Modification: -1. support imxrt1052-board InitBoardHardware -*************************************************/ + * @file board.c + * @brief relative configure for ok1052-c + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ +#include "fsl_common.h" #include "board.h" #include "pin_mux.h" + +#if defined(SDK_I2C_BASED_COMPONENT_USED) && SDK_I2C_BASED_COMPONENT_USED +#include "fsl_lpi2c.h" +#endif /* SDK_I2C_BASED_COMPONENT_USED */ #include "fsl_iomuxc.h" #include "fsl_gpio.h" -#include #include "fsl_lpuart.h" +#include +#include + #define NVIC_PRIORITYGROUP_0 0x00000007U /*!< 0 bits for pre-emption priority 4 bits for subpriority */ #define NVIC_PRIORITYGROUP_1 0x00000006U /*!< 1 bits for pre-emption priority @@ -40,57 +48,478 @@ Modification: #define NVIC_PRIORITYGROUP_3 0x00000004U /*!< 3 bits for pre-emption priority 1 bits for subpriority */ #define NVIC_PRIORITYGROUP_4 0x00000003U /*!< 4 bits for pre-emption priority - 0 bits for subpriority */ + + + +/******************************************************************************* + * Variables + ******************************************************************************/ + +/******************************************************************************* + * Code + ******************************************************************************/ + +#if 0 +/* Get debug console frequency. */ +uint32_t BOARD_DebugConsoleSrcFreq(void) +{ + uint32_t freq; + + /* To make it simple, we assume default PLL and divider settings, and the only variable + from application is use PLL3 source or OSC source */ + if (CLOCK_GetMux(kCLOCK_UartMux) == 0) /* PLL3 div6 80M */ + { + freq = (CLOCK_GetPllFreq(kCLOCK_PllUsb1) / 6U) / (CLOCK_GetDiv(kCLOCK_UartDiv) + 1U); + } + else + { + freq = CLOCK_GetOscFreq() / (CLOCK_GetDiv(kCLOCK_UartDiv) + 1U); + } + + return freq; +} + +/* Initialize debug console. */ +void BOARD_InitDebugConsole(void) +{ + uint32_t uartClkSrcFreq = BOARD_DebugConsoleSrcFreq(); + + DbgConsole_Init(BOARD_DEBUG_UART_INSTANCE, BOARD_DEBUG_UART_BAUDRATE, BOARD_DEBUG_UART_TYPE, uartClkSrcFreq); +} + +#if defined(SDK_I2C_BASED_COMPONENT_USED) && SDK_I2C_BASED_COMPONENT_USED +void BOARD_LPI2C_Init(LPI2C_Type *base, uint32_t clkSrc_Hz) +{ + lpi2c_master_config_t lpi2cConfig = {0}; + + /* + * lpi2cConfig.debugEnable = false; + * lpi2cConfig.ignoreAck = false; + * lpi2cConfig.pinConfig = kLPI2C_2PinOpenDrain; + * lpi2cConfig.baudRate_Hz = 100000U; + * lpi2cConfig.busIdleTimeout_ns = 0; + * lpi2cConfig.pinLowTimeout_ns = 0; + * lpi2cConfig.sdaGlitchFilterWidth_ns = 0; + * lpi2cConfig.sclGlitchFilterWidth_ns = 0; + */ + LPI2C_MasterGetDefaultConfig(&lpi2cConfig); + LPI2C_MasterInit(base, &lpi2cConfig, clkSrc_Hz); +} + +status_t BOARD_LPI2C_Send(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *txBuff, + uint8_t txBuffSize) +{ + status_t reVal; + + /* Send master blocking data to slave */ + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Write); + if (kStatus_Success == reVal) + { + while (LPI2C_MasterGetStatusFlags(base) & kLPI2C_MasterNackDetectFlag) + { + } + + reVal = LPI2C_MasterSend(base, &subAddress, subAddressSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterSend(base, txBuff, txBuffSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStop(base); + if (reVal != kStatus_Success) + { + return reVal; + } + } + + return reVal; +} + +status_t BOARD_LPI2C_Receive(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *rxBuff, + uint8_t rxBuffSize) +{ + status_t reVal; + + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Write); + if (kStatus_Success == reVal) + { + while (LPI2C_MasterGetStatusFlags(base) & kLPI2C_MasterNackDetectFlag) + { + } + + reVal = LPI2C_MasterSend(base, &subAddress, subAddressSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterRepeatedStart(base, deviceAddress, kLPI2C_Read); + + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterReceive(base, rxBuff, rxBuffSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStop(base); + if (reVal != kStatus_Success) + { + return reVal; + } + } + return reVal; +} + +status_t BOARD_LPI2C_SendSCCB(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *txBuff, + uint8_t txBuffSize) +{ + return BOARD_LPI2C_Send(base, deviceAddress, subAddress, subAddressSize, txBuff, txBuffSize); +} + +status_t BOARD_LPI2C_ReceiveSCCB(LPI2C_Type *base, + uint8_t deviceAddress, + uint32_t subAddress, + uint8_t subAddressSize, + uint8_t *rxBuff, + uint8_t rxBuffSize) +{ + status_t reVal; + + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Write); + if (kStatus_Success == reVal) + { + while (LPI2C_MasterGetStatusFlags(base) & kLPI2C_MasterNackDetectFlag) + { + } + + reVal = LPI2C_MasterSend(base, &subAddress, subAddressSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + /* SCCB does not support LPI2C repeat start, must stop then start. */ + reVal = LPI2C_MasterStop(base); + + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStart(base, deviceAddress, kLPI2C_Read); + + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterReceive(base, rxBuff, rxBuffSize); + if (reVal != kStatus_Success) + { + return reVal; + } + + reVal = LPI2C_MasterStop(base); + if (reVal != kStatus_Success) + { + return reVal; + } + } + return reVal; +} + +void BOARD_Accel_I2C_Init(void) +{ + BOARD_LPI2C_Init(BOARD_ACCEL_I2C_BASEADDR, BOARD_ACCEL_I2C_CLOCK_FREQ); +} + +status_t BOARD_Accel_I2C_Send(uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint32_t txBuff) +{ + uint8_t data = (uint8_t)txBuff; + + return BOARD_LPI2C_Send(BOARD_ACCEL_I2C_BASEADDR, deviceAddress, subAddress, subaddressSize, &data, 1); +} + +status_t BOARD_Accel_I2C_Receive( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subaddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_Receive(BOARD_ACCEL_I2C_BASEADDR, deviceAddress, subAddress, subaddressSize, rxBuff, rxBuffSize); +} + +void BOARD_Codec_I2C_Init(void) +{ + BOARD_LPI2C_Init(BOARD_CODEC_I2C_BASEADDR, BOARD_CODEC_I2C_CLOCK_FREQ); +} + +status_t BOARD_Codec_I2C_Send( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, const uint8_t *txBuff, uint8_t txBuffSize) +{ + return BOARD_LPI2C_Send(BOARD_CODEC_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, (uint8_t *)txBuff, + txBuffSize); +} + +status_t BOARD_Codec_I2C_Receive( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_Receive(BOARD_CODEC_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, rxBuff, rxBuffSize); +} + +void BOARD_Camera_I2C_Init(void) +{ + CLOCK_SetMux(kCLOCK_Lpi2cMux, BOARD_CAMERA_I2C_CLOCK_SOURCE_SELECT); + CLOCK_SetDiv(kCLOCK_Lpi2cDiv, BOARD_CAMERA_I2C_CLOCK_SOURCE_DIVIDER); + BOARD_LPI2C_Init(BOARD_CAMERA_I2C_BASEADDR, BOARD_CAMERA_I2C_CLOCK_FREQ); +} + +status_t BOARD_Camera_I2C_Send( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, const uint8_t *txBuff, uint8_t txBuffSize) +{ + return BOARD_LPI2C_Send(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, (uint8_t *)txBuff, + txBuffSize); +} + +status_t BOARD_Camera_I2C_Receive( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_Receive(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, rxBuff, + rxBuffSize); +} + +status_t BOARD_Camera_I2C_SendSCCB( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, const uint8_t *txBuff, uint8_t txBuffSize) +{ + return BOARD_LPI2C_SendSCCB(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, (uint8_t *)txBuff, + txBuffSize); +} + +status_t BOARD_Camera_I2C_ReceiveSCCB( + uint8_t deviceAddress, uint32_t subAddress, uint8_t subAddressSize, uint8_t *rxBuff, uint8_t rxBuffSize) +{ + return BOARD_LPI2C_ReceiveSCCB(BOARD_CAMERA_I2C_BASEADDR, deviceAddress, subAddress, subAddressSize, rxBuff, + rxBuffSize); +} +#endif /* SDK_I2C_BASED_COMPONENT_USED */ +#endif + + +void BOARD_SD_Pin_Config(uint32_t speed, uint32_t strength) +{ + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_00_USDHC1_CMD, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_01_USDHC1_CLK, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(0) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_02_USDHC1_DATA0, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_03_USDHC1_DATA1, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_04_USDHC1_DATA2, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B0_05_USDHC1_DATA3, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); +} + +void BOARD_MMC_Pin_Config(uint32_t speed, uint32_t strength) +{ + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_05_USDHC2_CMD, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_04_USDHC2_CLK, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(0) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_03_USDHC2_DATA0, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_02_USDHC2_DATA1, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_01_USDHC2_DATA2, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_00_USDHC2_DATA3, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_08_USDHC2_DATA4, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_09_USDHC2_DATA5, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_10_USDHC2_DATA6, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); + IOMUXC_SetPinConfig(IOMUXC_GPIO_SD_B1_11_USDHC2_DATA7, + IOMUXC_SW_PAD_CTL_PAD_SPEED(speed) | IOMUXC_SW_PAD_CTL_PAD_SRE_MASK | + IOMUXC_SW_PAD_CTL_PAD_PKE_MASK | IOMUXC_SW_PAD_CTL_PAD_PUE_MASK | + IOMUXC_SW_PAD_CTL_PAD_HYS_MASK | IOMUXC_SW_PAD_CTL_PAD_PUS(1) | + IOMUXC_SW_PAD_CTL_PAD_DSE(strength)); +} /* MPU configuration. */ -static void BOARD_ConfigMPU(void) +void BOARD_ConfigMPU(void) { /* Disable I cache and D cache */ - SCB_DisableICache(); - SCB_DisableDCache(); + if (SCB_CCR_IC_Msk == (SCB_CCR_IC_Msk & SCB->CCR)) + { + SCB_DisableICache(); + } + if (SCB_CCR_DC_Msk == (SCB_CCR_DC_Msk & SCB->CCR)) + { + SCB_DisableDCache(); + } /* Disable MPU */ ARM_MPU_Disable(); - /* Region 0 setting */ + /* MPU configure: + * Use ARM_MPU_RASR(DisableExec, AccessPermission, TypeExtField, IsShareable, IsCacheable, IsBufferable, + * SubRegionDisable, Size) + * API in mpu_armv7.h. + * param DisableExec Instruction access (XN) disable bit,0=instruction fetches enabled, 1=instruction fetches + * disabled. + * param AccessPermission Data access permissions, allows you to configure read/write access for User and + * Privileged mode. + * Use MACROS defined in mpu_armv7.h: + * ARM_MPU_AP_NONE/ARM_MPU_AP_PRIV/ARM_MPU_AP_URO/ARM_MPU_AP_FULL/ARM_MPU_AP_PRO/ARM_MPU_AP_RO + * Combine TypeExtField/IsShareable/IsCacheable/IsBufferable to configure MPU memory access attributes. + * TypeExtField IsShareable IsCacheable IsBufferable Memory Attribtue Shareability Cache + * 0 x 0 0 Strongly Ordered shareable + * 0 x 0 1 Device shareable + * 0 0 1 0 Normal not shareable Outer and inner write + * through no write allocate + * 0 0 1 1 Normal not shareable Outer and inner write + * back no write allocate + * 0 1 1 0 Normal shareable Outer and inner write + * through no write allocate + * 0 1 1 1 Normal shareable Outer and inner write + * back no write allocate + * 1 0 0 0 Normal not shareable outer and inner + * noncache + * 1 1 0 0 Normal shareable outer and inner + * noncache + * 1 0 1 1 Normal not shareable outer and inner write + * back write/read acllocate + * 1 1 1 1 Normal shareable outer and inner write + * back write/read acllocate + * 2 x 0 0 Device not shareable + * Above are normal use settings, if your want to see more details or want to config different inner/outter cache + * policy. + * please refer to Table 4-55 /4-56 in arm cortex-M7 generic user guide + * param SubRegionDisable Sub-region disable field. 0=sub-region is enabled, 1=sub-region is disabled. + * param Size Region size of the region to be configured. use ARM_MPU_REGION_SIZE_xxx MACRO in + * mpu_armv7.h. + */ + + /* Region 0 setting: Memory with Device type, not shareable, non-cacheable. */ MPU->RBAR = ARM_MPU_RBAR(0, 0xC0000000U); MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_512MB); - /* Region 1 setting */ + /* Region 1 setting: Memory with Device type, not shareable, non-cacheable. */ MPU->RBAR = ARM_MPU_RBAR(1, 0x80000000U); MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_1GB); - /* Region 2 setting */ - // spi flash: normal type, cacheable, no bufferable, no shareable +/* Region 2 setting */ +#if defined(XIP_EXTERNAL_FLASH) && (XIP_EXTERNAL_FLASH == 1) + /* Setting Memory with Normal type, not shareable, outer/inner write back. */ MPU->RBAR = ARM_MPU_RBAR(2, 0x60000000U); - MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 0, 0, ARM_MPU_REGION_SIZE_512MB); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_RO, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_64MB); +#else + /* Setting Memory with Device type, not shareable, non-cacheable. */ + MPU->RBAR = ARM_MPU_RBAR(2, 0x60000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_RO, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_64MB); +#endif - /* Region 3 setting */ + /* Region 3 setting: Memory with Device type, not shareable, non-cacheable. */ MPU->RBAR = ARM_MPU_RBAR(3, 0x00000000U); MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 2, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_1GB); - /* Region 4 setting */ + /* Region 4 setting: Memory with Normal type, not shareable, outer/inner write back */ MPU->RBAR = ARM_MPU_RBAR(4, 0x00000000U); MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_128KB); - /* Region 5 setting */ + /* Region 5 setting: Memory with Normal type, not shareable, outer/inner write back */ MPU->RBAR = ARM_MPU_RBAR(5, 0x20000000U); MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_128KB); - /* Region 6 setting */ + /* Region 6 setting: Memory with Normal type, not shareable, outer/inner write back */ MPU->RBAR = ARM_MPU_RBAR(6, 0x20200000U); MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_256KB); -#if defined(BSP_USING_SDRAM) - /* Region 7 setting */ +/* The define sets the cacheable memory to shareable, + * this suggestion is referred from chapter 2.2.1 Memory regions, + * types and attributes in Cortex-M7 Devices, Generic User Guide */ +#if defined(SDRAM_IS_SHAREABLE) + /* Region 7 setting: Memory with Normal type, shareable, outer/inner write back */ + MPU->RBAR = ARM_MPU_RBAR(7, 0x80000000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 1, 1, 1, 0, ARM_MPU_REGION_SIZE_32MB); +#else + /* Region 7 setting: Memory with Normal type, not shareable, outer/inner write back */ MPU->RBAR = ARM_MPU_RBAR(7, 0x80000000U); MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 0, 0, 1, 1, 0, ARM_MPU_REGION_SIZE_32MB); - - /* Region 8 setting */ - MPU->RBAR = ARM_MPU_RBAR(8, 0x81E00000U); - MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 1, 1, 0, 0, 0, ARM_MPU_REGION_SIZE_2MB); #endif + /* Region 8 setting, set last 2MB of SDRAM can't be accessed by cache, glocal variables which are not expected to be + * accessed by cache can be put here */ + /* Memory with Normal type, not shareable, non-cacheable */ + MPU->RBAR = ARM_MPU_RBAR(8, 0x81E00000U); + MPU->RASR = ARM_MPU_RASR(0, ARM_MPU_AP_FULL, 1, 0, 0, 0, 0, ARM_MPU_REGION_SIZE_2MB); + /* Enable MPU */ ARM_MPU_Enable(MPU_CTRL_PRIVDEFENA_Msk); @@ -168,8 +597,10 @@ void InitBoardHardware() BOARD_InitPins(); BOARD_BootClockRUN(); +#ifndef BSP_USING_LWIP NVIC_SetPriorityGrouping(NVIC_PRIORITYGROUP_4); SysTick_Config(SystemCoreClock / TICK_PER_SECOND); +#endif #ifdef BSP_USING_LPUART imxrt_uart_pins_init(); @@ -177,8 +608,13 @@ void InitBoardHardware() InitBoardMemory((void *)HEAP_BEGIN, (void *)HEAP_END); - Imrt1052HwUartInit(); +#ifdef BSP_USING_LWIP + ETH_BSP_Config(); +#endif +#ifdef BSP_USING_LPUART + Imrt1052HwUartInit(); +#endif InstallConsole(KERNEL_CONSOLE_BUS_NAME, KERNEL_CONSOLE_DRV_NAME, KERNEL_CONSOLE_DEVICE_NAME); } diff --git a/Ubiquitous/XiUOS/board/ok1052-c/board.h b/Ubiquitous/XiUOS/board/ok1052-c/board.h deleted file mode 100644 index 82928ea5..00000000 --- a/Ubiquitous/XiUOS/board/ok1052-c/board.h +++ /dev/null @@ -1,52 +0,0 @@ -/* -* Copyright (c) 2020 AIIT XUOS Lab -* XiUOS is licensed under Mulan PSL v2. -* You can use this software according to the terms and conditions of the Mulan PSL v2. -* You may obtain a copy of Mulan PSL v2 at: -* http://license.coscl.org.cn/MulanPSL2 -* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, -* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, -* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. -* See the Mulan PSL v2 for more details. -*/ - -/** -* @file board.h -* @brief define imxrt1052-board init configure and start-up function -* @version 1.0 -* @author AIIT XUOS Lab -* @date 2021-05-28 -*/ - -/************************************************* -File name: board.h -Description: define imxrt1052-board board init function and struct -Others: -History: -1. Date: 2021-05-28 -Author: AIIT XUOS Lab -Modification: -1. define imxrt-board InitBoardHardware -2. define imxrt-board heap struct -*************************************************/ - -#ifndef __BOARD_H__ -#define __BOARD_H__ - -#include "fsl_common.h" -#include "clock_config.h" -#include -#include - -extern int heap_start; -extern int heap_end; -#define HEAP_BEGIN (&heap_start) -#define HEAP_END (&heap_end) - - -#define HEAP_SIZE ((uint32_t)HEAP_END - (uint32_t)HEAP_BEGIN) - -void InitBoardHardware(void); - -#endif - diff --git a/Ubiquitous/XiUOS/board/ok1052-c/include/board.h b/Ubiquitous/XiUOS/board/ok1052-c/include/board.h new file mode 100755 index 00000000..60d1a97b --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/include/board.h @@ -0,0 +1,323 @@ +/* + * Copyright 2017-2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + + +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file board.h +* @brief define imxrt1052-board init configure and start-up function +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-28 +*/ + +/************************************************* +File name: board.h +Description: define imxrt1052-board board init function and struct +Others: +History: +1. Date: 2021-05-28 +Author: AIIT XUOS Lab +Modification: +1. define imxrt-board InitBoardHardware +2. define imxrt-board heap struct +*************************************************/ + +#ifndef __BOARD_H__ +#define __BOARD_H__ + +#include "fsl_common.h" +#include "fsl_gpio.h" +#include "fsl_clock.h" +#include "fsl_enet.h" +#include "clock_config.h" +#include +#include +#include "enet_ethernetif.h" + +extern int heap_start; +extern int heap_end; +#define HEAP_BEGIN (&heap_start) +#define HEAP_END (&heap_end) + +#define HEAP_SIZE ((uint32_t)HEAP_END - (uint32_t)HEAP_BEGIN) + +void InitBoardHardware(void); + +/******************************************************************************* + * Definitions + ******************************************************************************/ +/*! @brief The board name */ +#define BOARD_NAME "IMXRT1050-EVKB" + +/* The UART to use for debug messages. */ +#define BOARD_DEBUG_UART_TYPE kSerialPort_Uart +#define BOARD_DEBUG_UART_BASEADDR (uint32_t) LPUART1 +#define BOARD_DEBUG_UART_INSTANCE 1U + +#define BOARD_DEBUG_UART_CLK_FREQ BOARD_DebugConsoleSrcFreq() + +#define BOARD_UART_IRQ LPUART1_IRQn +#define BOARD_UART_IRQ_HANDLER LPUART1_IRQHandler + +#ifndef BOARD_DEBUG_UART_BAUDRATE +#define BOARD_DEBUG_UART_BAUDRATE (115200U) +#endif /* BOARD_DEBUG_UART_BAUDRATE */ + +/*! @brief The USER_LED used for board */ +#define LOGIC_LED_ON (0U) +#define LOGIC_LED_OFF (1U) +#ifndef BOARD_USER_LED_GPIO +#define BOARD_USER_LED_GPIO GPIO1 +#endif +#ifndef BOARD_USER_LED_GPIO_PIN +#define BOARD_USER_LED_GPIO_PIN (9U) +#endif + +#define USER_LED_INIT(output) \ + GPIO_PinWrite(BOARD_USER_LED_GPIO, BOARD_USER_LED_GPIO_PIN, output); \ + BOARD_USER_LED_GPIO->GDIR |= (1U << BOARD_USER_LED_GPIO_PIN) /*!< Enable target USER_LED */ +#define USER_LED_ON() \ + GPIO_PortClear(BOARD_USER_LED_GPIO, 1U << BOARD_USER_LED_GPIO_PIN) /*!< Turn off target USER_LED */ +#define USER_LED_OFF() GPIO_PortSet(BOARD_USER_LED_GPIO, 1U << BOARD_USER_LED_GPIO_PIN) /*! m_data + } > m_data2 - PROVIDE(heap_end = ORIGIN(m_data) + LENGTH(m_data)); + PROVIDE(heap_end = ORIGIN(m_data2) + LENGTH(m_data2)); .ARM.attributes 0 : { *(.ARM.attributes) } } diff --git a/Ubiquitous/XiUOS/board/ok1052-c/pin_mux.c b/Ubiquitous/XiUOS/board/ok1052-c/pin_mux.c deleted file mode 100644 index a267fc1b..00000000 --- a/Ubiquitous/XiUOS/board/ok1052-c/pin_mux.c +++ /dev/null @@ -1,81 +0,0 @@ -/* - * Copyright 2017-2019 NXP - * All rights reserved. - * - * SPDX-License-Identifier: BSD-3-Clause - */ - -/** -* @file pin_mux.c -* @brief support imxrt1052-board pin configure -* @version 1.0 -* @author AIIT XUOS Lab -* @date 2021-05-29 -*/ - -/*********************************************************************************************************************** - * This file was generated by the MCUXpresso Config Tools. Any manual edits made to this file - * will be overwritten if the respective MCUXpresso Config Tools is used to update this file. - **********************************************************************************************************************/ - -/* - * TEXT BELOW IS USED AS SETTING FOR TOOLS ************************************* -!!GlobalInfo -product: Pins v5.0 -processor: MIMXRT1052xxxxB -package_id: MIMXRT1052DVL6B -mcu_data: ksdk2_0 -processor_version: 5.0.2 -board: IMXRT1050-EVKB -pin_labels: -- {pin_num: F14, pin_signal: GPIO_AD_B0_09, label: BSP_LED, identifier: BSP_LED} - * BE CAREFUL MODIFYING THIS COMMENT - IT IS YAML SETTINGS FOR TOOLS *********** - */ - -#include "fsl_common.h" -#include "fsl_iomuxc.h" -#include "pin_mux.h" - -/* FUNCTION ************************************************************************************************************ - * - * Function Name : BOARD_InitBootPins - * Description : Calls initialization functions. - * - * END ****************************************************************************************************************/ -void BOARD_InitBootPins(void) { -} - -/* - * TEXT BELOW IS USED AS SETTING FOR TOOLS ************************************* -BOARD_InitPins: -- options: {callFromInitBoot: 'false', coreID: core0, enableClock: 'true'} -- pin_list: - - {pin_num: L14, peripheral: LPUART1, signal: RX, pin_signal: GPIO_AD_B0_13} - - {pin_num: K14, peripheral: LPUART1, signal: TX, pin_signal: GPIO_AD_B0_12} - - {pin_num: F14, peripheral: GPIO1, signal: 'gpio_io, 09', pin_signal: GPIO_AD_B0_09} - * BE CAREFUL MODIFYING THIS COMMENT - IT IS YAML SETTINGS FOR TOOLS *********** - */ - -/* FUNCTION ************************************************************************************************************ - * - * Function Name : BOARD_InitPins - * Description : Configures pin routing and optionally pin electrical features. - * - * END ****************************************************************************************************************/ -void BOARD_InitPins(void) { - CLOCK_EnableClock(kCLOCK_Iomuxc); /* iomuxc clock (iomuxc_clk_enable): 0x03U */ - - IOMUXC_SetPinMux( - IOMUXC_GPIO_AD_B0_09_GPIO1_IO09, /* GPIO_AD_B0_09 is configured as GPIO1_IO09 */ - 0U); /* Software Input On Field: Input Path is determined by functionality */ - IOMUXC_SetPinMux( - IOMUXC_GPIO_AD_B0_12_LPUART1_TX, /* GPIO_AD_B0_12 is configured as LPUART1_TX */ - 0U); /* Software Input On Field: Input Path is determined by functionality */ - IOMUXC_SetPinMux( - IOMUXC_GPIO_AD_B0_13_LPUART1_RX, /* GPIO_AD_B0_13 is configured as LPUART1_RX */ - 0U); /* Software Input On Field: Input Path is determined by functionality */ -} - -/*********************************************************************************************************************** - * EOF - **********************************************************************************************************************/ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Kconfig b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Kconfig index e90a8e5c..8674a2ef 100644 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Kconfig +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Kconfig @@ -5,3 +5,8 @@ select RESOURCES_SERIAL if BSP_USING_LPUART source "$BSP_DIR/third_party_driver/uart/Kconfig" endif + +menuconfig BSP_USING_LWIP +bool "Using LwIP device" +default n +select RESOURCES_LWIP diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/Makefile deleted file mode 100644 index 91fb0eee..00000000 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/Makefile +++ /dev/null @@ -1,6 +0,0 @@ -SRC_DIR := drivers - -SRC_FILES := system_MIMXRT1052.c - - -include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/Makefile deleted file mode 100644 index d1ab3fd1..00000000 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/Makefile +++ /dev/null @@ -1,5 +0,0 @@ - -SRC_FILES := fsl_clock.c fsl_common.c fsl_lpuart.c - - -include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Makefile index 01bad48d..71b25e5e 100644 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Makefile +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/Makefile @@ -1,7 +1,11 @@ -SRC_DIR := MIMXRT1052 +SRC_DIR := common gpio ifeq ($(CONFIG_BSP_USING_LPUART),y) SRC_DIR += uart endif +ifeq ($(CONFIG_BSP_USING_LWIP),y) + SRC_DIR += ethernet +endif + include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/Makefile new file mode 100755 index 00000000..e88d0225 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/Makefile @@ -0,0 +1,3 @@ +SRC_FILES := system_MIMXRT1052.c fsl_cache.c fsl_clock.c fsl_common.c pin_mux.c clock_config.c + +include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/board/ok1052-c/clock_config.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/clock_config.c old mode 100644 new mode 100755 similarity index 100% rename from Ubiquitous/XiUOS/board/ok1052-c/clock_config.c rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/clock_config.c diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_cache.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_cache.c new file mode 100755 index 00000000..b601d33d --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_cache.c @@ -0,0 +1,623 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2017 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_cache.c + * @brief cache drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#include "fsl_cache.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/* Component ID definition, used by tools. */ +#ifndef FSL_COMPONENT_ID +#define FSL_COMPONENT_ID "platform.drivers.cache_armv7_m7" +#endif + +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT +#define L2CACHE_OPERATION_TIMEOUT 0xFFFFFU +#define L2CACHE_8WAYS_MASK 0xFFU +#define L2CACHE_16WAYS_MASK 0xFFFFU +#define L2CACHE_SMALLWAYS_NUM 8U +#define L2CACHE_1KBCOVERTOB 1024U +#define L2CACHE_SAMLLWAYS_SIZE 16U +#define L2CACHE_LOCKDOWN_REGNUM 8 /*!< Lock down register numbers.*/ + /******************************************************************************* + * Prototypes + ******************************************************************************/ +/*! + * @brief Set for all ways and waiting for the operation finished. + * This is provided for all the background operations. + * + * @param auxCtlReg The auxiliary control register. + * @param regAddr The register address to be operated. + */ +static void L2CACHE_SetAndWaitBackGroundOperate(uint32_t auxCtlReg, uint32_t regAddr); + +/*! + * @brief Invalidates the Level 2 cache line by physical address. + * This function invalidates a cache line by physcial address. + * + * @param address The physical addderss of the cache. + * The format of the address shall be : + * bit 31 ~ bit n+1 | bitn ~ bit5 | bit4 ~ bit0 + * Tag | index | 0 + * Note: the physical address shall be aligned to the line size - 32B (256 bit). + * so keep the last 5 bits (bit 4 ~ bit 0) of the physical address always be zero. + * If the input address is not aligned, it will be changed to 32-byte aligned address. + * The n is varies according to the index width. + * @return The actual 32-byte aligned physical address be operated. + */ +static uint32_t L2CACHE_InvalidateLineByAddr(uint32_t address); + +/*! + * @brief Cleans the Level 2 cache line based on the physical address. + * This function cleans a cache line based on a physcial address. + * + * @param address The physical addderss of the cache. + * The format of the address shall be : + * bit 31 ~ bit n+1 | bitn ~ bit5 | bit4 ~ bit0 + * Tag | index | 0 + * Note: the physical address shall be aligned to the line size - 32B (256 bit). + * so keep the last 5 bits (bit 4 ~ bit 0) of the physical address always be zero. + * If the input address is not aligned, it will be changed to 32-byte aligned address. + * The n is varies according to the index width. + * @return The actual 32-byte aligned physical address be operated. + */ +static uint32_t L2CACHE_CleanLineByAddr(uint32_t address); + +/*! + * @brief Cleans and invalidates the Level 2 cache line based on the physical address. + * This function cleans and invalidates a cache line based on a physcial address. + * + * @param address The physical addderss of the cache. + * The format of the address shall be : + * bit 31 ~ bit n+1 | bitn ~ bit5 | bit4 ~ bit0 + * Tag | index | 0 + * Note: the physical address shall be aligned to the line size - 32B (256 bit). + * so keep the last 5 bits (bit 4 ~ bit 0) of the physical address always be zero. + * If the input address is not aligned, it will be changed to 32-byte aligned address. + * The n is varies according to the index width. + * @return The actual 32-byte aligned physical address be operated. + */ +static uint32_t L2CACHE_CleanInvalidateLineByAddr(uint32_t address); + +/*! + * @brief Gets the number of the Level 2 cache and the way size. + * This function cleans and invalidates a cache line based on a physcial address. + * + * @param num_ways The number of the cache way. + * @param size_way The way size. + */ +static void L2CACHE_GetWayNumSize(uint32_t *num_ways, uint32_t *size_way); +/******************************************************************************* + * Code + ******************************************************************************/ +static void L2CACHE_SetAndWaitBackGroundOperate(uint32_t auxCtlReg, uint32_t regAddr) +{ + uint16_t mask = L2CACHE_8WAYS_MASK; + uint32_t timeout = L2CACHE_OPERATION_TIMEOUT; + + /* Check the ways used at first. */ + if (auxCtlReg & L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_MASK) + { + mask = L2CACHE_16WAYS_MASK; + } + + /* Set the opeartion for all ways/entries of the cache. */ + *(uint32_t *)regAddr = mask; + /* Waiting for until the operation is complete. */ + while ((*(volatile uint32_t *)regAddr & mask) && timeout) + { + __ASM("nop"); + timeout--; + } +} + +static uint32_t L2CACHE_InvalidateLineByAddr(uint32_t address) +{ + /* Align the address first. */ + address &= ~(uint32_t)(FSL_FEATURE_L2CACHE_LINESIZE_BYTE - 1); + /* Invalidate the cache line by physical address. */ + L2CACHEC->REG7_INV_PA = address; + + return address; +} + +static uint32_t L2CACHE_CleanLineByAddr(uint32_t address) +{ + /* Align the address first. */ + address &= ~(uint32_t)(FSL_FEATURE_L2CACHE_LINESIZE_BYTE - 1); + /* Invalidate the cache line by physical address. */ + L2CACHEC->REG7_CLEAN_PA = address; + + return address; +} + +static uint32_t L2CACHE_CleanInvalidateLineByAddr(uint32_t address) +{ + /* Align the address first. */ + address &= ~(uint32_t)(FSL_FEATURE_L2CACHE_LINESIZE_BYTE - 1); + /* Clean and invalidate the cache line by physical address. */ + L2CACHEC->REG7_CLEAN_INV_PA = address; + + return address; +} + +static void L2CACHE_GetWayNumSize(uint32_t *num_ways, uint32_t *size_way) +{ + assert(num_ways); + assert(size_way); + + uint32_t number = (L2CACHEC->REG1_AUX_CONTROL & L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_MASK) >> + L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_SHIFT; + uint32_t size = (L2CACHEC->REG1_AUX_CONTROL & L2CACHEC_REG1_AUX_CONTROL_WAYSIZE_MASK) >> + L2CACHEC_REG1_AUX_CONTROL_WAYSIZE_SHIFT; + + *num_ways = (number + 1) * L2CACHE_SMALLWAYS_NUM; + if (!size) + { + /* 0 internally mapped to the same size as 1 - 16KB.*/ + size += 1; + } + *size_way = (1 << (size - 1)) * L2CACHE_SAMLLWAYS_SIZE * L2CACHE_1KBCOVERTOB; +} + +/*! + * brief Initializes the level 2 cache controller module. + * + * param config Pointer to configuration structure. See "l2cache_config_t". + */ +void L2CACHE_Init(l2cache_config_t *config) +{ + assert(config); + + uint16_t waysNum = 0xFFU; /* Default use the 8-way mask. */ + uint8_t count; + uint32_t auxReg = 0; + + /*The aux register must be configured when the cachec is disabled + * So disable first if the cache controller is enabled. + */ + if (L2CACHEC->REG1_CONTROL & L2CACHEC_REG1_CONTROL_CE_MASK) + { + L2CACHE_Disable(); + } + + /* Unlock all entries. */ + if (L2CACHEC->REG1_AUX_CONTROL & L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_MASK) + { + waysNum = 0xFFFFU; + } + + for (count = 0; count < L2CACHE_LOCKDOWN_REGNUM; count++) + { + L2CACHE_LockdownByWayEnable(count, waysNum, false); + } + + /* Set the ways and way-size etc. */ + auxReg = L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY(config->wayNum) | + L2CACHEC_REG1_AUX_CONTROL_WAYSIZE(config->waySize) | L2CACHEC_REG1_AUX_CONTROL_CRP(config->repacePolicy) | + L2CACHEC_REG1_AUX_CONTROL_IPE(config->istrPrefetchEnable) | + L2CACHEC_REG1_AUX_CONTROL_DPE(config->dataPrefetchEnable) | + L2CACHEC_REG1_AUX_CONTROL_NLE(config->nsLockdownEnable) | + L2CACHEC_REG1_AUX_CONTROL_FWA(config->writeAlloc) | L2CACHEC_REG1_AUX_CONTROL_HPSDRE(config->writeAlloc); + L2CACHEC->REG1_AUX_CONTROL = auxReg; + + /* Set the tag/data ram latency. */ + if (config->lateConfig) + { + uint32_t data = 0; + /* Tag latency. */ + data = L2CACHEC_REG1_TAG_RAM_CONTROL_SL(config->lateConfig->tagSetupLate) | + L2CACHEC_REG1_TAG_RAM_CONTROL_SL(config->lateConfig->tagSetupLate) | + L2CACHEC_REG1_TAG_RAM_CONTROL_RAL(config->lateConfig->tagReadLate) | + L2CACHEC_REG1_TAG_RAM_CONTROL_WAL(config->lateConfig->dataWriteLate); + L2CACHEC->REG1_TAG_RAM_CONTROL = data; + /* Data latency. */ + data = L2CACHEC_REG1_DATA_RAM_CONTROL_SL(config->lateConfig->dataSetupLate) | + L2CACHEC_REG1_DATA_RAM_CONTROL_SL(config->lateConfig->dataSetupLate) | + L2CACHEC_REG1_DATA_RAM_CONTROL_RAL(config->lateConfig->dataReadLate) | + L2CACHEC_REG1_DATA_RAM_CONTROL_WAL(config->lateConfig->dataWriteLate); + L2CACHEC->REG1_DATA_RAM_CONTROL = data; + } +} + +/*! + * brief Gets an available default settings for the cache controller. + * + * This function initializes the cache controller configuration structure with default settings. + * The default values are: + * code + * config->waysNum = kL2CACHE_8ways; + * config->waySize = kL2CACHE_32KbSize; + * config->repacePolicy = kL2CACHE_Roundrobin; + * config->lateConfig = NULL; + * config->istrPrefetchEnable = false; + * config->dataPrefetchEnable = false; + * config->nsLockdownEnable = false; + * config->writeAlloc = kL2CACHE_UseAwcache; + * endcode + * param config Pointer to the configuration structure. + */ +void L2CACHE_GetDefaultConfig(l2cache_config_t *config) +{ + assert(config); + + /* Initializes the configure structure to zero. */ + memset(config, 0, sizeof(*config)); + + uint32_t number = (L2CACHEC->REG1_AUX_CONTROL & L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_MASK) >> + L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_SHIFT; + uint32_t size = (L2CACHEC->REG1_AUX_CONTROL & L2CACHEC_REG1_AUX_CONTROL_WAYSIZE_MASK) >> + L2CACHEC_REG1_AUX_CONTROL_WAYSIZE_SHIFT; + + /* Get the default value */ + config->wayNum = (l2cache_way_num_t)number; + config->waySize = (l2cache_way_size)size; + config->repacePolicy = kL2CACHE_Roundrobin; + config->lateConfig = NULL; + config->istrPrefetchEnable = false; + config->dataPrefetchEnable = false; + config->nsLockdownEnable = false; + config->writeAlloc = kL2CACHE_UseAwcache; +} + +/*! + * brief Enables the level 2 cache controller. + * This function enables the cache controller. Must be written using a secure access. + * If write with a Non-secure access will cause a DECERR response. + * + */ +void L2CACHE_Enable(void) +{ + /* Invalidate first. */ + L2CACHE_Invalidate(); + /* Enable the level 2 cache controller. */ + L2CACHEC->REG1_CONTROL = L2CACHEC_REG1_CONTROL_CE_MASK; +} + +/*! + * brief Disables the level 2 cache controller. + * This function disables the cache controller. Must be written using a secure access. + * If write with a Non-secure access will cause a DECERR response. + * + */ +void L2CACHE_Disable(void) +{ + /* First CleanInvalidate all enties in the cache. */ + L2CACHE_CleanInvalidate(); + /* Disable the level 2 cache controller. */ + L2CACHEC->REG1_CONTROL &= ~L2CACHEC_REG1_CONTROL_CE_MASK; + /* DSB - data sync barrier.*/ + __DSB(); +} + +/*! + * brief Invalidates the Level 2 cache. + * This function invalidates all entries in cache. + * + */ +void L2CACHE_Invalidate(void) +{ + /* Invalidate all entries in cache. */ + L2CACHE_SetAndWaitBackGroundOperate(L2CACHEC->REG1_AUX_CONTROL, (uint32_t)&L2CACHEC->REG7_INV_WAY); + /* Cache sync. */ + L2CACHEC->REG7_CACHE_SYNC = 0; +} + +/*! + * brief Cleans the level 2 cache controller. + * This function cleans all entries in the level 2 cache controller. + * + */ +void L2CACHE_Clean(void) +{ + /* Clean all entries of the cache. */ + L2CACHE_SetAndWaitBackGroundOperate(L2CACHEC->REG1_AUX_CONTROL, (uint32_t)&L2CACHEC->REG7_CLEAN_WAY); + /* Cache sync. */ + L2CACHEC->REG7_CACHE_SYNC = 0; +} + +/*! + * brief Cleans and invalidates the level 2 cache controller. + * This function cleans and invalidates all entries in the level 2 cache controller. + * + */ +void L2CACHE_CleanInvalidate(void) +{ + /* Clean all entries of the cache. */ + L2CACHE_SetAndWaitBackGroundOperate(L2CACHEC->REG1_AUX_CONTROL, (uint32_t)&L2CACHEC->REG7_CLEAN_INV_WAY); + /* Cache sync. */ + L2CACHEC->REG7_CACHE_SYNC = 0; +} + +/*! + * brief Invalidates the Level 2 cache lines in the range of two physical addresses. + * This function invalidates all cache lines between two physical addresses. + * + * param address The start address of the memory to be invalidated. + * param size_byte The memory size. + * note The start address and size_byte should be 32-byte(FSL_FEATURE_L2CACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L2 line size if startAddr + * is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L2CACHE_InvalidateByRange(uint32_t address, uint32_t size_byte) +{ + uint32_t endAddr = address + size_byte; + + /* Invalidate addresses in the range. */ + while (address < endAddr) + { + address = L2CACHE_InvalidateLineByAddr(address); + /* Update the size. */ + address += FSL_FEATURE_L2CACHE_LINESIZE_BYTE; + } + + /* Cache sync. */ + L2CACHEC->REG7_CACHE_SYNC = 0; +} + +/*! + * brief Cleans the Level 2 cache lines in the range of two physical addresses. + * This function cleans all cache lines between two physical addresses. + * + * param address The start address of the memory to be cleaned. + * param size_byte The memory size. + * note The start address and size_byte should be 32-byte(FSL_FEATURE_L2CACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L2 line size if startAddr + * is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L2CACHE_CleanByRange(uint32_t address, uint32_t size_byte) +{ + uint32_t num_ways = 0; + uint32_t size_way = 0; + uint32_t endAddr = address + size_byte; + + /* Get the number and size of the cache way. */ + L2CACHE_GetWayNumSize(&num_ways, &size_way); + + /* Check if the clean size is over the cache size. */ + if ((endAddr - address) > num_ways * size_way) + { + L2CACHE_Clean(); + return; + } + + /* Clean addresses in the range. */ + while ((address & ~(uint32_t)(FSL_FEATURE_L2CACHE_LINESIZE_BYTE - 1)) < endAddr) + { + /* Clean the address in the range. */ + address = L2CACHE_CleanLineByAddr(address); + address += FSL_FEATURE_L2CACHE_LINESIZE_BYTE; + } + + L2CACHEC->REG7_CACHE_SYNC = 0; +} + +/*! + * brief Cleans and invalidates the Level 2 cache lines in the range of two physical addresses. + * This function cleans and invalidates all cache lines between two physical addresses. + * + * param address The start address of the memory to be cleaned and invalidated. + * param size_byte The memory size. + * note The start address and size_byte should be 32-byte(FSL_FEATURE_L2CACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L2 line size if startAddr + * is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L2CACHE_CleanInvalidateByRange(uint32_t address, uint32_t size_byte) +{ + uint32_t num_ways = 0; + uint32_t size_way = 0; + uint32_t endAddr = address + size_byte; + + /* Get the number and size of the cache way. */ + L2CACHE_GetWayNumSize(&num_ways, &size_way); + + /* Check if the clean size is over the cache size. */ + if ((endAddr - address) > num_ways * size_way) + { + L2CACHE_CleanInvalidate(); + return; + } + + /* Clean addresses in the range. */ + while ((address & ~(uint32_t)(FSL_FEATURE_L2CACHE_LINESIZE_BYTE - 1)) < endAddr) + { + /* Clean the address in the range. */ + address = L2CACHE_CleanInvalidateLineByAddr(address); + address += FSL_FEATURE_L2CACHE_LINESIZE_BYTE; + } + + L2CACHEC->REG7_CACHE_SYNC = 0; +} + +/*! + * brief Enables or disables to lock down the data and instruction by way. + * This function locks down the cached instruction/data by way and prevent the adresses from + * being allocated and prevent dara from being evicted out of the level 2 cache. + * But the normal cache maintenance operations that invalidate, clean or clean + * and validate cache contents affect the locked-down cache lines as normal. + * + * param masterId The master id, range from 0 ~ 7. + * param mask The ways to be enabled or disabled to lockdown. + * each bit in value is related to each way of the cache. for example: + * value: bit 0 ------ way 0. + * value: bit 1 ------ way 1. + * -------------------------- + * value: bit 15 ------ way 15. + * Note: please make sure the value setting is align with your supported ways. + * param enable True enable the lockdown, false to disable the lockdown. + */ +void L2CACHE_LockdownByWayEnable(uint32_t masterId, uint32_t mask, bool enable) +{ + uint8_t num_ways = (L2CACHEC->REG1_AUX_CONTROL & L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_MASK) >> + L2CACHEC_REG1_AUX_CONTROL_ASSOCIATIVITY_SHIFT; + num_ways = (num_ways + 1) * L2CACHE_SMALLWAYS_NUM; + + assert(mask < (1U << num_ways)); + assert(masterId < L2CACHE_LOCKDOWN_REGNUM); + + uint32_t dataReg = L2CACHEC->LOCKDOWN[masterId].REG9_D_LOCKDOWN; + uint32_t istrReg = L2CACHEC->LOCKDOWN[masterId].REG9_I_LOCKDOWN; + + if (enable) + { + /* Data lockdown. */ + L2CACHEC->LOCKDOWN[masterId].REG9_D_LOCKDOWN = dataReg | mask; + /* Instruction lockdown. */ + L2CACHEC->LOCKDOWN[masterId].REG9_I_LOCKDOWN = istrReg | mask; + } + else + { + /* Data lockdown. */ + L2CACHEC->LOCKDOWN[masterId].REG9_D_LOCKDOWN = dataReg & ~mask; + /* Instruction lockdown. */ + L2CACHEC->LOCKDOWN[masterId].REG9_I_LOCKDOWN = istrReg & ~mask; + } +} +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ + +/*! + * brief Invalidate cortex-m7 L1 instruction cache by range. + * + * param address The start address of the memory to be invalidated. + * param size_byte The memory size. + * note The start address and size_byte should be 32-byte(FSL_FEATURE_L1ICACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L1 I-cache line size if + * startAddr is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L1CACHE_InvalidateICacheByRange(uint32_t address, uint32_t size_byte) +{ +#if (__DCACHE_PRESENT == 1U) + uint32_t addr = address & (uint32_t) ~(FSL_FEATURE_L1ICACHE_LINESIZE_BYTE - 1); + int32_t size = size_byte + address - addr; + uint32_t linesize = 32U; + + __DSB(); + while (size > 0) + { + SCB->ICIMVAU = addr; + addr += linesize; + size -= linesize; + } + __DSB(); + __ISB(); +#endif +} + +/*! + * brief Invalidates all instruction caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * param address The physical address. + * param size_byte size of the memory to be invalidated. + * note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void ICACHE_InvalidateByRange(uint32_t address, uint32_t size_byte) +{ +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT +#if defined(FSL_SDK_DISBLE_L2CACHE_PRESENT) && !FSL_SDK_DISBLE_L2CACHE_PRESENT + L2CACHE_InvalidateByRange(address, size_byte); +#endif /* !FSL_SDK_DISBLE_L2CACHE_PRESENT */ +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ + + L1CACHE_InvalidateICacheByRange(address, size_byte); +} + +/*! + * brief Invalidates all data caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * param address The physical address. + * param size_byte size of the memory to be invalidated. + * note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void DCACHE_InvalidateByRange(uint32_t address, uint32_t size_byte) +{ +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT +#if defined(FSL_SDK_DISBLE_L2CACHE_PRESENT) && !FSL_SDK_DISBLE_L2CACHE_PRESENT + L2CACHE_InvalidateByRange(address, size_byte); +#endif /* !FSL_SDK_DISBLE_L2CACHE_PRESENT */ +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ + L1CACHE_InvalidateDCacheByRange(address, size_byte); +} + +/*! + * brief Cleans all data caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * param address The physical address. + * param size_byte size of the memory to be cleaned. + * note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void DCACHE_CleanByRange(uint32_t address, uint32_t size_byte) +{ + L1CACHE_CleanDCacheByRange(address, size_byte); +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT +#if defined(FSL_SDK_DISBLE_L2CACHE_PRESENT) && !FSL_SDK_DISBLE_L2CACHE_PRESENT + L2CACHE_CleanByRange(address, size_byte); +#endif /* !FSL_SDK_DISBLE_L2CACHE_PRESENT */ +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ +} + +/*! + * brief Cleans and Invalidates all data caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * param address The physical address. + * param size_byte size of the memory to be cleaned and invalidated. + * note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void DCACHE_CleanInvalidateByRange(uint32_t address, uint32_t size_byte) +{ + L1CACHE_CleanInvalidateDCacheByRange(address, size_byte); +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT +#if defined(FSL_SDK_DISBLE_L2CACHE_PRESENT) && !FSL_SDK_DISBLE_L2CACHE_PRESENT + L2CACHE_CleanInvalidateByRange(address, size_byte); +#endif /* !FSL_SDK_DISBLE_L2CACHE_PRESENT */ +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ +} diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_clock.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_clock.c old mode 100644 new mode 100755 similarity index 98% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_clock.c rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_clock.c index e12179b9..fdb1032d --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_clock.c +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_clock.c @@ -5,6 +5,26 @@ * SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_clock.c + * @brief clock drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + #include "fsl_clock.h" /* Component ID definition, used by tools. */ #ifndef FSL_COMPONENT_ID diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_common.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_common.c old mode 100644 new mode 100755 similarity index 87% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_common.c rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_common.c index 39e78bcd..21cd99e4 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_common.c +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_common.c @@ -7,6 +7,26 @@ * SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_common.c + * @brief common drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + #include "fsl_common.h" #define SDK_MEM_MAGIC_NUMBER 12345U diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_debug_console.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_debug_console.c new file mode 100755 index 00000000..4a0ccd30 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/fsl_debug_console.c @@ -0,0 +1,1123 @@ +/* + * This is a modified version of the file printf.c, which was distributed + * by Motorola as part of the M5407C3BOOT.zip package used to initialize + * the M5407C3 evaluation board. + * + * Copyright: + * 1999-2000 MOTOROLA, INC. All Rights Reserved. + * You are hereby granted a copyright license to use, modify, and + * distribute the SOFTWARE so long as this entire notice is + * retained without alteration in any modified and/or redistributed + * versions, and that such modified versions are clearly identified + * as such. No licenses are granted by implication, estoppel or + * otherwise under any patents or trademarks of Motorola, Inc. This + * software is provided on an "AS IS" basis and without warranty. + * + * To the maximum extent permitted by applicable law, MOTOROLA + * DISCLAIMS ALL WARRANTIES WHETHER EXPRESS OR IMPLIED, INCLUDING + * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR + * PURPOSE AND ANY WARRANTY AGAINST INFRINGEMENT WITH REGARD TO THE + * SOFTWARE (INCLUDING ANY MODIFIED VERSIONS THEREOF) AND ANY + * ACCOMPANYING WRITTEN MATERIALS. + * + * To the maximum extent permitted by applicable law, IN NO EVENT + * SHALL MOTOROLA BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING + * WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, BUSINESS + * INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY + * LOSS) ARISING OF THE USE OR INABILITY TO USE THE SOFTWARE. + * + * Motorola assumes no responsibility for the maintenance and support + * of this software + + * Copyright (c) 2015, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include +#include +#if defined(__CC_ARM) || defined(__ARMCC_VERSION) +#include +#endif + +#ifdef FSL_RTOS_FREE_RTOS +#include "FreeRTOS.h" +#include "semphr.h" +#include "task.h" +#endif + +#include "fsl_debug_console_conf.h" +#include "fsl_str.h" + +#include "fsl_common.h" +//#include "serial_manager.h" + +#include "fsl_debug_console.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ +#ifndef NDEBUG +#if (defined(DEBUG_CONSOLE_ASSERT_DISABLE) && (DEBUG_CONSOLE_ASSERT_DISABLE > 0U)) +#undef assert +#define assert(n) +#endif +#endif + +#if SDK_DEBUGCONSOLE +#define DEBUG_CONSOLE_FUNCTION_PREFIX +#else +#define DEBUG_CONSOLE_FUNCTION_PREFIX static +#endif + +/*! @brief character backspace ASCII value */ +#define DEBUG_CONSOLE_BACKSPACE 127U + +/* lock definition */ +#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS) + +static SemaphoreHandle_t s_debugConsoleReadSemaphore; +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) +static SemaphoreHandle_t s_debugConsoleReadWaitSemaphore; +#endif + +#elif (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) + +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) +static volatile uint8_t s_debugConsoleReadWaitSemaphore; +#endif + +#else + +#endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */ + +/*! @brief get current runing environment is ISR or not */ +#ifdef __CA7_REV +#define IS_RUNNING_IN_ISR() SystemGetIRQNestingLevel() +#else +#define IS_RUNNING_IN_ISR() __get_IPSR() +#endif /* __CA7_REV */ + +/* semaphore definition */ +#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS) + +/* mutex semaphore */ +#define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) ((mutex) = xSemaphoreCreateMutex()) + +/* clang-format off */ +#define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) \ +{ \ + if (IS_RUNNING_IN_ISR() == 0U) \ + { \ + (void)xSemaphoreGive(mutex); \ + } \ +} + +#define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) \ +{ \ + if (IS_RUNNING_IN_ISR() == 0U) \ + { \ + (void)xSemaphoreTake(mutex, portMAX_DELAY); \ + } \ +} + +#define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) \ +{ \ + if (IS_RUNNING_IN_ISR() == 0U) \ + { \ + result = xSemaphoreTake(mutex, 0U); \ + } \ + else \ + { \ + result = 1U; \ + } \ +} +/* clang-format on */ + +/* Binary semaphore */ +#define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) ((binary) = xSemaphoreCreateBinary()) +#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) ((void)xSemaphoreTake(binary, portMAX_DELAY)) +#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) ((void)xSemaphoreGiveFromISR(binary, NULL)) + +#elif (DEBUG_CONSOLE_SYNCHRONIZATION_BM == DEBUG_CONSOLE_SYNCHRONIZATION_MODE) + +#define DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(mutex) +#define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(mutex) +#define DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(mutex) +#define DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_NONBLOCKING(mutex, result) (result = 1U) + +#define DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(binary) +#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING +#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) \ + { \ + while (!binary) \ + { \ + } \ + binary = false; \ + } +#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) (binary = true) +#else +#define DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(binary) +#define DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(binary) +#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */ + +/* add other implementation here + *such as : + * #elif(DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DDEBUG_CONSOLE_SYNCHRONIZATION_xxx) + */ + +#else + +#error RTOS type is not defined by DEBUG_CONSOLE_SYNCHRONIZATION_MODE. + +#endif /* DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS */ + +#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING +/* receive state structure */ +typedef struct _debug_console_write_ring_buffer +{ + uint32_t ringBufferSize; + volatile uint32_t ringHead; + volatile uint32_t ringTail; + uint8_t ringBuffer[DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN]; +} debug_console_write_ring_buffer_t; +#endif + +typedef struct _debug_console_state_struct +{ + uint8_t serialHandleBuffer[SERIAL_MANAGER_HANDLE_SIZE]; + serial_handle_t serialHandle; /*!< serial manager handle */ +#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING + debug_console_write_ring_buffer_t writeRingBuffer; + uint8_t readRingBuffer[DEBUG_CONSOLE_RECEIVE_BUFFER_LEN]; +#endif + uint8_t serialWriteHandleBuffer[SERIAL_MANAGER_WRITE_HANDLE_SIZE]; + uint8_t serialReadHandleBuffer[SERIAL_MANAGER_READ_HANDLE_SIZE]; +} debug_console_state_struct_t; + +/******************************************************************************* + * Variables + ******************************************************************************/ + +/*! @brief Debug console state information. */ +static debug_console_state_struct_t s_debugConsoleState; +serial_handle_t g_serialHandle; /*!< serial manager handle */ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ +/*! + * @brief This is a printf call back function which is used to relocate the log to buffer + * or print the log immediately when the local buffer is full. + * + * @param[in] buf Buffer to store log. + * @param[in] indicator Buffer index. + * @param[in] val Target character to store. + * @param[in] len length of the character + * + */ +#if SDK_DEBUGCONSOLE +static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len); +#endif + +status_t DbgConsole_ReadOneCharacter(uint8_t *ch); +int DbgConsole_SendData(uint8_t *ch, size_t size); +int DbgConsole_SendDataReliable(uint8_t *ch, size_t size); +int DbgConsole_ReadLine(uint8_t *buf, size_t size); +int DbgConsole_ReadCharacter(uint8_t *ch); + +#if ((SDK_DEBUGCONSOLE > 0U) || \ + ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \ + (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U)))) +DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void); +#endif +/******************************************************************************* + * Code + ******************************************************************************/ + +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + +static void DbgConsole_SerialManagerTxCallback(void *callbackParam, + serial_manager_callback_message_t *message, + serial_manager_status_t status) +{ + debug_console_state_struct_t *ioState; + uint32_t sendDataLength; + + if ((NULL == callbackParam) || (NULL == message)) + { + return; + } + + ioState = (debug_console_state_struct_t *)callbackParam; + + ioState->writeRingBuffer.ringTail += message->length; + if (ioState->writeRingBuffer.ringTail >= ioState->writeRingBuffer.ringBufferSize) + { + ioState->writeRingBuffer.ringTail = 0U; + } + + if (kStatus_SerialManager_Success == status) + { + if (ioState->writeRingBuffer.ringTail != ioState->writeRingBuffer.ringHead) + { + if (ioState->writeRingBuffer.ringHead > ioState->writeRingBuffer.ringTail) + { + sendDataLength = ioState->writeRingBuffer.ringHead - ioState->writeRingBuffer.ringTail; + } + else + { + sendDataLength = ioState->writeRingBuffer.ringBufferSize - ioState->writeRingBuffer.ringTail; + } + + (void)SerialManager_WriteNonBlocking( + ((serial_write_handle_t)&ioState->serialWriteHandleBuffer[0]), + &ioState->writeRingBuffer.ringBuffer[ioState->writeRingBuffer.ringTail], sendDataLength); + } + } + else if (kStatus_SerialManager_Canceled == status) + { + ioState->writeRingBuffer.ringTail = 0U; + ioState->writeRingBuffer.ringHead = 0U; + } + else + { + /*MISRA rule 16.4*/ + } +} + +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) + +static void DbgConsole_SerialManagerRxCallback(void *callbackParam, + serial_manager_callback_message_t *message, + serial_manager_status_t status) +{ + if ((NULL == callbackParam) || (NULL == message)) + { + return; + } + + if (kStatus_SerialManager_Notify == status) + { + } + else if (kStatus_SerialManager_Success == status) + { + /* release s_debugConsoleReadWaitSemaphore from RX callback */ + DEBUG_CONSOLE_GIVE_BINARY_SEMAPHORE_FROM_ISR(s_debugConsoleReadWaitSemaphore); + } + else + { + /*MISRA rule 16.4*/ + } +} +#endif + +#endif + +status_t DbgConsole_ReadOneCharacter(uint8_t *ch) +{ +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) + +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \ + (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED) + return kStatus_Fail; +#else + status_t status = (status_t)kStatus_SerialManager_Error; + +/* recieve one char every time */ +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + status = (status_t)SerialManager_ReadNonBlocking( + ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1); +#else + status = (status_t)SerialManager_ReadBlocking( + ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), ch, 1); +#endif + if ((status_t)kStatus_SerialManager_Success != status) + { + return (status_t)kStatus_Fail; + } + /* wait s_debugConsoleReadWaitSemaphore from RX callback */ + DEBUG_CONSOLE_TAKE_BINARY_SEMAPHORE_BLOCKING(s_debugConsoleReadWaitSemaphore); + + return (status_t)kStatus_Success; +#endif + +#else + + return (status_t)kStatus_Fail; + +#endif +} + +#if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION +static status_t DbgConsole_EchoCharacter(uint8_t *ch, bool isGetChar, int *index) +{ + /* Due to scanf take \n and \r as end of string,should not echo */ + if (((*ch != (uint8_t)'\r') && (*ch != (uint8_t)'\n')) || (isGetChar)) + { + /* recieve one char every time */ + if (1 != DbgConsole_SendDataReliable(ch, 1U)) + { + return (status_t)kStatus_Fail; + } + } + + if ((!isGetChar) && (index != NULL)) + { + if (DEBUG_CONSOLE_BACKSPACE == *ch) + { + if ((*index >= 2)) + { + *index -= 2; + } + else + { + *index = 0; + } + } + } + + return (status_t)kStatus_Success; +} +#endif + +int DbgConsole_SendData(uint8_t *ch, size_t size) +{ + status_t status = (status_t)kStatus_SerialManager_Error; +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + uint32_t sendDataLength; + int txBusy = 0; +#endif + assert(NULL != ch); + assert(0 != size); + +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + uint32_t regPrimask = DisableGlobalIRQ(); + if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail) + { + txBusy = 1; + sendDataLength = + (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize - + s_debugConsoleState.writeRingBuffer.ringTail) % + s_debugConsoleState.writeRingBuffer.ringBufferSize; + } + else + { + sendDataLength = 0U; + } + sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1; + if (sendDataLength <= size) + { + EnableGlobalIRQ(regPrimask); + return -1; + } + for (int i = 0; i < (int)size; i++) + { + s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringHead++] = ch[i]; + if (s_debugConsoleState.writeRingBuffer.ringHead >= s_debugConsoleState.writeRingBuffer.ringBufferSize) + { + s_debugConsoleState.writeRingBuffer.ringHead = 0U; + } + } + + status = (status_t)kStatus_SerialManager_Success; + + if (txBusy == 0) + { + if (s_debugConsoleState.writeRingBuffer.ringHead > s_debugConsoleState.writeRingBuffer.ringTail) + { + sendDataLength = + s_debugConsoleState.writeRingBuffer.ringHead - s_debugConsoleState.writeRingBuffer.ringTail; + } + else + { + sendDataLength = + s_debugConsoleState.writeRingBuffer.ringBufferSize - s_debugConsoleState.writeRingBuffer.ringTail; + } + + status = (status_t)SerialManager_WriteNonBlocking( + ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), + &s_debugConsoleState.writeRingBuffer.ringBuffer[s_debugConsoleState.writeRingBuffer.ringTail], + sendDataLength); + } + EnableGlobalIRQ(regPrimask); +#else + status = (status_t)SerialManager_WriteBlocking( + ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size); +#endif + return (((status_t)kStatus_Success == status) ? (int)size : -1); +} + +int DbgConsole_SendDataReliable(uint8_t *ch, size_t size) +{ +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) +#if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U)) + status_t status = kStatus_SerialManager_Error; + uint32_t sendDataLength; + uint32_t totalLength = size; + int sentLength; +#endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */ +#else + status_t status = kStatus_SerialManager_Error; +#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */ + + assert(NULL != ch); + assert(0 != size); + +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + +#if (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U)) + do + { + uint32_t regPrimask = DisableGlobalIRQ(); + if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail) + { + sendDataLength = + (s_debugConsoleState.writeRingBuffer.ringHead + s_debugConsoleState.writeRingBuffer.ringBufferSize - + s_debugConsoleState.writeRingBuffer.ringTail) % + s_debugConsoleState.writeRingBuffer.ringBufferSize; + } + else + { + sendDataLength = 0U; + } + sendDataLength = s_debugConsoleState.writeRingBuffer.ringBufferSize - sendDataLength - 1U; + + if (sendDataLength > 0U) + { + if (sendDataLength > totalLength) + { + sendDataLength = totalLength; + } + + sentLength = DbgConsole_SendData(&ch[size - totalLength], sendDataLength); + if (sentLength > 0) + { + totalLength = totalLength - (uint32_t)sentLength; + } + } + EnableGlobalIRQ(regPrimask); + + if (totalLength != 0U) + { + status = DbgConsole_Flush(); + if ((status_t)kStatus_Success != status) + { + break; + } + } + } while (totalLength != 0U); + return (status_t)(uint32_t)((uint32_t)size - totalLength); +#else + return DbgConsole_SendData(ch, size); +#endif /* DEBUG_CONSOLE_TX_RELIABLE_ENABLE */ + +#else + status = (status_t)SerialManager_WriteBlocking( + ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), ch, size); + return (((status_t)kStatus_Success == status) ? (int)size : -1); +#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */ +} + +int DbgConsole_ReadLine(uint8_t *buf, size_t size) +{ + int i = 0; + + assert(buf != NULL); + + /* take mutex lock function */ + DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore); + + do + { + /* recieve one char every time */ + if ((status_t)kStatus_Success != DbgConsole_ReadOneCharacter(&buf[i])) + { + /* release mutex lock function */ + DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore); + i = -1; + break; + } +#if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION + (void)DbgConsole_EchoCharacter(&buf[i], false, &i); +#endif + /* analysis data */ + if (((uint8_t)'\r' == buf[i]) || ((uint8_t)'\n' == buf[i])) + { + /* End of Line. */ + if (0 == i) + { + buf[i] = (uint8_t)'\0'; + continue; + } + else + { + break; + } + } + i++; + } while (i < (int)size); + + /* get char should not add '\0'*/ + if (i == (int)size) + { + buf[i] = (uint8_t)'\0'; + } + else + { + buf[i + 1] = (uint8_t)'\0'; + } + + /* release mutex lock function */ + DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore); + + return i; +} + +int DbgConsole_ReadCharacter(uint8_t *ch) +{ + int ret; + + assert(ch); + + /* take mutex lock function */ + DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore); + /* read one character */ + if ((status_t)kStatus_Success == DbgConsole_ReadOneCharacter(ch)) + { + ret = 1; +#if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION + (void)DbgConsole_EchoCharacter(ch, true, NULL); +#endif + } + else + { + ret = -1; + } + + /* release mutex lock function */ + DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore); + + return ret; +} + +#if SDK_DEBUGCONSOLE +static void DbgConsole_PrintCallback(char *buf, int32_t *indicator, char dbgVal, int len) +{ + int i = 0; + + for (i = 0; i < len; i++) + { + if (((uint32_t)*indicator + 1UL) >= DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN) + { + (void)DbgConsole_SendDataReliable((uint8_t *)buf, (uint32_t)(*indicator)); + *indicator = 0; + } + + buf[*indicator] = dbgVal; + (*indicator)++; + } +} +#endif + +/*************Code for DbgConsole Init, Deinit, Printf, Scanf *******************************/ + +/* See fsl_debug_console.h for documentation of this function. */ +status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq) +{ + serial_manager_config_t serialConfig; + status_t status = (status_t)kStatus_SerialManager_Error; + +#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U)) + serial_port_uart_config_t uartConfig = { + .instance = instance, + .clockRate = clkSrcFreq, + .baudRate = baudRate, + .parityMode = kSerialManager_UartParityDisabled, + .stopBitCount = kSerialManager_UartOneStopBit, + .enableRx = 1, + .enableTx = 1, + }; +#endif + +#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U)) + serial_port_usb_cdc_config_t usbCdcConfig = { + .controllerIndex = (serial_port_usb_cdc_controller_index_t)instance, + }; +#endif + +#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U)) + serial_port_swo_config_t swoConfig = { + .clockRate = clkSrcFreq, + .baudRate = baudRate, + .port = instance, + .protocol = kSerialManager_SwoProtocolNrz, + }; +#endif + +#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U)) + serial_port_usb_cdc_virtual_config_t usbCdcVirtualConfig = { + .controllerIndex = (serial_port_usb_cdc_virtual_controller_index_t)instance, + }; +#endif + serialConfig.type = device; +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + serialConfig.ringBuffer = &s_debugConsoleState.readRingBuffer[0]; + serialConfig.ringBufferSize = DEBUG_CONSOLE_RECEIVE_BUFFER_LEN; +#endif + + if (kSerialPort_Uart == device) + { +#if (defined(SERIAL_PORT_TYPE_UART) && (SERIAL_PORT_TYPE_UART > 0U)) + serialConfig.portConfig = &uartConfig; +#else + return status; +#endif + } + else if (kSerialPort_UsbCdc == device) + { +#if (defined(SERIAL_PORT_TYPE_USBCDC) && (SERIAL_PORT_TYPE_USBCDC > 0U)) + serialConfig.portConfig = &usbCdcConfig; +#else + return status; +#endif + } + else if (kSerialPort_Swo == device) + { +#if (defined(SERIAL_PORT_TYPE_SWO) && (SERIAL_PORT_TYPE_SWO > 0U)) + serialConfig.portConfig = &swoConfig; +#else + return status; +#endif + } + else if (kSerialPort_UsbCdcVirtual == device) + { +#if (defined(SERIAL_PORT_TYPE_USBCDC_VIRTUAL) && (SERIAL_PORT_TYPE_USBCDC_VIRTUAL > 0U)) + serialConfig.portConfig = &usbCdcVirtualConfig; +#else + return status; +#endif + } + else + { + return status; + } + + (void)memset(&s_debugConsoleState, 0, sizeof(s_debugConsoleState)); + +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + s_debugConsoleState.writeRingBuffer.ringBufferSize = DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN; +#endif + + s_debugConsoleState.serialHandle = (serial_handle_t)&s_debugConsoleState.serialHandleBuffer[0]; + status = (status_t)SerialManager_Init(s_debugConsoleState.serialHandle, &serialConfig); + + assert(kStatus_SerialManager_Success == status); + + DEBUG_CONSOLE_CREATE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore); +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) + DEBUG_CONSOLE_CREATE_BINARY_SEMAPHORE(s_debugConsoleReadWaitSemaphore); +#endif + + { + status = (status_t)SerialManager_OpenWriteHandle( + s_debugConsoleState.serialHandle, ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0])); + assert(kStatus_SerialManager_Success == status); +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + (void)SerialManager_InstallTxCallback(((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0]), + DbgConsole_SerialManagerTxCallback, &s_debugConsoleState); +#endif + } + +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) + { + status = (status_t)SerialManager_OpenReadHandle( + s_debugConsoleState.serialHandle, ((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0])); + assert(kStatus_SerialManager_Success == status); +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + (void)SerialManager_InstallRxCallback(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), + DbgConsole_SerialManagerRxCallback, &s_debugConsoleState); +#endif + } +#endif + + g_serialHandle = s_debugConsoleState.serialHandle; + + return kStatus_Success; +} + +/* See fsl_debug_console.h for documentation of this function. */ +status_t DbgConsole_Deinit(void) +{ + { + if (s_debugConsoleState.serialHandle != NULL) + { + (void)SerialManager_CloseWriteHandle( + ((serial_write_handle_t)&s_debugConsoleState.serialWriteHandleBuffer[0])); + } + } +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) + { + if (s_debugConsoleState.serialHandle != NULL) + { + (void)SerialManager_CloseReadHandle(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0])); + } + } +#endif + return (status_t)kStatus_Success; +} + +#if ((SDK_DEBUGCONSOLE > 0U) || \ + ((SDK_DEBUGCONSOLE == 0U) && defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) && \ + (defined(DEBUG_CONSOLE_TX_RELIABLE_ENABLE) && (DEBUG_CONSOLE_TX_RELIABLE_ENABLE > 0U)))) +DEBUG_CONSOLE_FUNCTION_PREFIX status_t DbgConsole_Flush(void) +{ +#if defined(DEBUG_CONSOLE_TRANSFER_NON_BLOCKING) + +#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_BM) && defined(OSA_USED) + + if (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail) + { + return (status_t)kStatus_Fail; + } + +#else + + while (s_debugConsoleState.writeRingBuffer.ringHead != s_debugConsoleState.writeRingBuffer.ringTail) + { +#if (DEBUG_CONSOLE_SYNCHRONIZATION_MODE == DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS) + if (0U == IS_RUNNING_IN_ISR()) + { + if (taskSCHEDULER_RUNNING == xTaskGetSchedulerState()) + { + vTaskDelay(1); + } + } + else + { + return (status_t)kStatus_Fail; + } +#endif + } + +#endif + +#endif + return (status_t)kStatus_Success; +} +#endif + +#if SDK_DEBUGCONSOLE +/* See fsl_debug_console.h for documentation of this function. */ +int DbgConsole_Printf(const char *formatString, ...) +{ + va_list ap; + int logLength = 0, dbgResult = 0; + char printBuf[DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN] = {'\0'}; + + if (NULL == g_serialHandle) + { + return 0; + } + + va_start(ap, formatString); + /* format print log first */ + logLength = StrFormatPrintf(formatString, ap, printBuf, DbgConsole_PrintCallback); + /* print log */ + dbgResult = DbgConsole_SendDataReliable((uint8_t *)printBuf, (size_t)logLength); + + va_end(ap); + + return dbgResult; +} + +/* See fsl_debug_console.h for documentation of this function. */ +int DbgConsole_Putchar(int ch) +{ + /* print char */ + return DbgConsole_SendDataReliable((uint8_t *)&ch, 1U); +} + +/* See fsl_debug_console.h for documentation of this function. */ +int DbgConsole_Scanf(char *formatString, ...) +{ + va_list ap; + int formatResult; + char scanfBuf[DEBUG_CONSOLE_SCANF_MAX_LOG_LEN + 1U] = {'\0'}; + + /* scanf log */ + (void)DbgConsole_ReadLine((uint8_t *)scanfBuf, DEBUG_CONSOLE_SCANF_MAX_LOG_LEN); + /* get va_list */ + va_start(ap, formatString); + /* format scanf log */ + formatResult = StrFormatScanf(scanfBuf, formatString, ap); + + va_end(ap); + + return formatResult; +} + +#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING +status_t DbgConsole_TryGetchar(char *ch) +{ +#if (defined(DEBUG_CONSOLE_RX_ENABLE) && (DEBUG_CONSOLE_RX_ENABLE > 0U)) + uint32_t length = 0; + status_t status = (status_t)kStatus_Fail; + + assert(ch); + + /* take mutex lock function */ + DEBUG_CONSOLE_TAKE_MUTEX_SEMAPHORE_BLOCKING(s_debugConsoleReadSemaphore); + + if (kStatus_SerialManager_Success == + SerialManager_TryRead(((serial_read_handle_t)&s_debugConsoleState.serialReadHandleBuffer[0]), (uint8_t *)ch, 1, + &length)) + { + if (length != 0U) + { +#if DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION + (void)DbgConsole_EchoCharacter((uint8_t *)ch, true, NULL); +#endif + status = (status_t)kStatus_Success; + } + } + /* release mutex lock function */ + DEBUG_CONSOLE_GIVE_MUTEX_SEMAPHORE(s_debugConsoleReadSemaphore); + return status; +#else + return (status_t)kStatus_Fail; +#endif +} +#endif + +/* See fsl_debug_console.h for documentation of this function. */ +int DbgConsole_Getchar(void) +{ + uint8_t ch = 0U; + + /* Get char */ + (void)DbgConsole_ReadCharacter(&ch); + + return (int)ch; +} + +#endif /* SDK_DEBUGCONSOLE */ + +/*************Code to support toolchain's printf, scanf *******************************/ +/* These function __write and __read is used to support IAR toolchain to printf and scanf*/ +#if (defined(__ICCARM__)) +#if defined(SDK_DEBUGCONSOLE_UART) +#pragma weak __write +size_t __write(int handle, const unsigned char *buffer, size_t size) +{ + if (buffer == 0) + { + /* + * This means that we should flush internal buffers. Since we don't we just return. + * (Remember, "handle" == -1 means that all handles should be flushed.) + */ + return 0; + } + + /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */ + if ((handle != 1) && (handle != 2)) + { + return ((size_t)-1); + } + + /* Send data. */ + DbgConsole_SendDataReliable((uint8_t *)buffer, size); + + return size; +} + +#pragma weak __read +size_t __read(int handle, unsigned char *buffer, size_t size) +{ + uint8_t ch = 0U; + int actualSize = 0U; + + /* This function only reads from "standard in", for all other file handles it returns failure. */ + if (handle != 0) + { + return ((size_t)-1); + } + + /* Receive data.*/ + for (; size > 0; size--) + { + DbgConsole_ReadCharacter(&ch); + if (ch == 0) + { + break; + } + + *buffer++ = ch; + actualSize++; + } + + return actualSize; +} +#endif /* SDK_DEBUGCONSOLE_UART */ + +/* support LPC Xpresso with RedLib */ +#elif (defined(__REDLIB__)) + +#if (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART)) +int __attribute__((weak)) __sys_write(int handle, char *buffer, int size) +{ + if (buffer == 0) + { + /* return -1 if error. */ + return -1; + } + + /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */ + if ((handle != 1) && (handle != 2)) + { + return -1; + } + + /* Send data. */ + DbgConsole_SendDataReliable((uint8_t *)buffer, size); + + return 0; +} + +int __attribute__((weak)) __sys_readc(void) +{ + char tmp; + + /* Receive data. */ + DbgConsole_ReadCharacter((uint8_t *)&tmp); + + return tmp; +} +#endif + +/* These function fputc and fgetc is used to support KEIL toolchain to printf and scanf*/ +#elif defined(__CC_ARM) || defined(__ARMCC_VERSION) +#if defined(SDK_DEBUGCONSOLE_UART) +#if defined(__CC_ARM) +struct __FILE +{ + int handle; + /* + * Whatever you require here. If the only file you are using is standard output using printf() for debugging, + * no file handling is required. + */ +}; +#endif + +/* FILE is typedef in stdio.h. */ +#pragma weak __stdout +#pragma weak __stdin +FILE __stdout; +FILE __stdin; + +#pragma weak fputc +int fputc(int ch, FILE *f) +{ + /* Send data. */ + return DbgConsole_SendDataReliable((uint8_t *)(&ch), 1); +} + +#pragma weak fgetc +int fgetc(FILE *f) +{ + char ch; + + /* Receive data. */ + DbgConsole_ReadCharacter((uint8_t *)&ch); + + return ch; +} + +/* + * Terminate the program, passing a return code back to the user. + * This function may not return. + */ +void _sys_exit(int returncode) +{ + while (1) + { + } +} + +/* + * Writes a character to the output channel. This function is used + * for last-resort error message output. + */ +void _ttywrch(int ch) +{ + char ench = ch; + DbgConsole_SendDataReliable((uint8_t *)(&ench), 1); +} + +char *_sys_command_string(char *cmd, int len) +{ + return (cmd); +} +#endif /* SDK_DEBUGCONSOLE_UART */ + +/* These function __write and __read is used to support ARM_GCC, KDS, Atollic toolchains to printf and scanf*/ +#elif (defined(__GNUC__)) + +#if ((defined(__GNUC__) && (!defined(__MCUXPRESSO)) && (defined(SDK_DEBUGCONSOLE_UART))) || \ + (defined(__MCUXPRESSO) && (!SDK_DEBUGCONSOLE) && (defined(SDK_DEBUGCONSOLE_UART)))) +int __attribute__((weak)) _write(int handle, char *buffer, int size); +int __attribute__((weak)) _write(int handle, char *buffer, int size) +{ + if (buffer == NULL) + { + /* return -1 if error. */ + return -1; + } + + /* This function only writes to "standard out" and "standard err" for all other file handles it returns failure. */ + if ((handle != 1) && (handle != 2)) + { + return -1; + } + + /* Send data. */ + (void)DbgConsole_SendDataReliable((uint8_t *)buffer, (size_t)size); + + return size; +} + +int __attribute__((weak)) _read(int handle, char *buffer, int size); +int __attribute__((weak)) _read(int handle, char *buffer, int size) +{ + uint8_t ch = 0U; + int actualSize = 0; + + /* This function only reads from "standard in", for all other file handles it returns failure. */ + if (handle != 0) + { + return -1; + } + + /* Receive data. */ + for (; size > 0; size--) + { + if (DbgConsole_ReadCharacter(&ch) < 0) + { + break; + } + + *buffer++ = (char)ch; + actualSize++; + + if ((ch == 0U) || (ch == (uint8_t)'\n') || (ch == (uint8_t)'\r')) + { + break; + } + } + + return (actualSize > 0) ? actualSize : -1; +} +#endif + +#endif /* __ICCARM__ */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/pin_mux.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/pin_mux.c new file mode 100755 index 00000000..8d0a4cf5 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/pin_mux.c @@ -0,0 +1,304 @@ +/* + * Copyright 2017-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/** +* @file pin_mux.c +* @brief support imxrt1052-board pin configure +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-29 +*/ + +/*********************************************************************************************************************** + * This file was generated by the MCUXpresso Config Tools. Any manual edits made to this file + * will be overwritten if the respective MCUXpresso Config Tools is used to update this file. + **********************************************************************************************************************/ + +/* + * TEXT BELOW IS USED AS SETTING FOR TOOLS ************************************* +!!GlobalInfo +product: Pins v4.1 +processor: MIMXRT1052xxxxB +package_id: MIMXRT1052DVL6B +mcu_data: ksdk2_0 +processor_version: 5.0.2 +board: IMXRT1050-EVKB +pin_labels: +- {pin_num: F14, pin_signal: GPIO_AD_B0_09, label: BSP_LED, identifier: BSP_LED} + * BE CAREFUL MODIFYING THIS COMMENT - IT IS YAML SETTINGS FOR TOOLS *********** + */ + +#include "fsl_common.h" +#include "fsl_iomuxc.h" +#include "pin_mux.h" + +/* FUNCTION ************************************************************************************************************ + * + * Function Name : BOARD_InitBootPins + * Description : Calls initialization functions. + * + * END ****************************************************************************************************************/ +void BOARD_InitBootPins(void) { + BOARD_InitPins(); +} + +/* + * TEXT BELOW IS USED AS SETTING FOR TOOLS ************************************* +BOARD_InitPins: +- options: {callFromInitBoot: 'true', coreID: core0, enableClock: 'true'} +- pin_list: + - {pin_num: L14, peripheral: LPUART1, signal: RX, pin_signal: GPIO_AD_B0_13, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Down_100K_Ohm, + pull_keeper_select: Keeper, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_100, drive_strength: R0_6, slew_rate: Slow} + - {pin_num: K14, peripheral: LPUART1, signal: TX, pin_signal: GPIO_AD_B0_12, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Down_100K_Ohm, + pull_keeper_select: Keeper, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_100, drive_strength: R0_6, slew_rate: Slow} + - {pin_num: A7, peripheral: ENET, signal: enet_mdc, pin_signal: GPIO_EMC_40, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: C7, peripheral: ENET, signal: enet_mdio, pin_signal: GPIO_EMC_41, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Enable, speed: MHZ_50, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: B13, peripheral: ENET, signal: enet_ref_clk, pin_signal: GPIO_B1_10, software_input_on: Enable, hysteresis_enable: Disable, pull_up_down_config: Pull_Down_100K_Ohm, + pull_keeper_select: Keeper, pull_keeper_enable: Disable, open_drain: Disable, speed: MHZ_50, drive_strength: R0_6, slew_rate: Fast} + - {pin_num: E12, peripheral: ENET, signal: 'enet_rx_data, 0', pin_signal: GPIO_B1_04, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: D12, peripheral: ENET, signal: 'enet_rx_data, 1', pin_signal: GPIO_B1_05, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: C12, peripheral: ENET, signal: enet_rx_en, pin_signal: GPIO_B1_06, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: C13, peripheral: ENET, signal: enet_rx_er, pin_signal: GPIO_B1_11, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: B12, peripheral: ENET, signal: 'enet_tx_data, 0', pin_signal: GPIO_B1_07, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: A12, peripheral: ENET, signal: 'enet_tx_data, 1', pin_signal: GPIO_B1_08, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: A13, peripheral: ENET, signal: enet_tx_en, pin_signal: GPIO_B1_09, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_200, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: F14, peripheral: GPIO1, signal: 'gpio_io, 09', pin_signal: GPIO_AD_B0_09, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_100, drive_strength: R0_5, slew_rate: Fast} + - {pin_num: G13, peripheral: GPIO1, signal: 'gpio_io, 10', pin_signal: GPIO_AD_B0_10, software_input_on: Disable, hysteresis_enable: Disable, pull_up_down_config: Pull_Up_100K_Ohm, + pull_keeper_select: Pull, pull_keeper_enable: Enable, open_drain: Disable, speed: MHZ_100, drive_strength: R0_5, slew_rate: Fast} + * BE CAREFUL MODIFYING THIS COMMENT - IT IS YAML SETTINGS FOR TOOLS *********** + */ + +/* FUNCTION ************************************************************************************************************ + * + * Function Name : BOARD_InitPins + * Description : Configures pin routing and optionally pin electrical features. + * + * END ****************************************************************************************************************/ +void BOARD_InitPins(void) { + CLOCK_EnableClock(kCLOCK_Iomuxc); /* iomuxc clock (iomuxc_clk_enable): 0x03u */ + +// IOMUXC_SetPinMux( +// IOMUXC_GPIO_AD_B0_09_GPIO1_IO09, /* GPIO_AD_B0_09 is configured as GPIO1_IO09 */ +// 0U); /* Software Input On Field: Input Path is determined by functionality */ + + + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_03_GPIO1_IO03, /* GPIO_AD_B0_09 is configured as GPIO1_IO09 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_10_GPIO1_IO10, /* GPIO_AD_B0_10 is configured as GPIO1_IO10 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_12_LPUART1_TX, /* GPIO_AD_B0_12 is configured as LPUART1_TX */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_AD_B0_13_LPUART1_RX, /* GPIO_AD_B0_13 is configured as LPUART1_RX */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_04_ENET_RX_DATA00, /* GPIO_B1_04 is configured as ENET_RX_DATA00 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_05_ENET_RX_DATA01, /* GPIO_B1_05 is configured as ENET_RX_DATA01 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_06_ENET_RX_EN, /* GPIO_B1_06 is configured as ENET_RX_EN */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_07_ENET_TX_DATA00, /* GPIO_B1_07 is configured as ENET_TX_DATA00 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_08_ENET_TX_DATA01, /* GPIO_B1_08 is configured as ENET_TX_DATA01 */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_09_ENET_TX_EN, /* GPIO_B1_09 is configured as ENET_TX_EN */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_10_ENET_REF_CLK, /* GPIO_B1_10 is configured as ENET_REF_CLK */ + 1U); /* Software Input On Field: Force input path of pad GPIO_B1_10 */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_B1_11_ENET_RX_ER, /* GPIO_B1_11 is configured as ENET_RX_ER */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_40_ENET_MDC, /* GPIO_EMC_40 is configured as ENET_MDC */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ + IOMUXC_SetPinMux( + IOMUXC_GPIO_EMC_41_ENET_MDIO, /* GPIO_EMC_41 is configured as ENET_MDIO */ + 0U); /* Software Input On Field: Input Path is determined by functionality */ +// IOMUXC_SetPinConfig( +// IOMUXC_GPIO_AD_B0_09_GPIO1_IO09, /* GPIO_AD_B0_09 PAD functional properties : */ +// 0xB0A9u); /* Slew Rate Field: Fast Slew Rate +// Drive Strength Field: R0/5 +// Speed Field: medium(100MHz) +// Open Drain Enable Field: Open Drain Disabled +// Pull / Keep Enable Field: Pull/Keeper Enabled +// Pull / Keep Select Field: Pull +// Pull Up / Down Config. Field: 100K Ohm Pull Up +// Hyst. Enable Field: Hysteresis Disabled */ + + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_03_GPIO1_IO03, /* GPIO_AD_B0_09 PAD functional properties : */ + 0xB0A9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_10_GPIO1_IO10, /* GPIO_AD_B0_10 PAD functional properties : */ + 0xB0A9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + +#if UART_DEBUG + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_12_LPUART1_TX, /* GPIO_AD_B0_12 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_AD_B0_13_LPUART1_RX, /* GPIO_AD_B0_13 PAD functional properties : */ + 0x10B0u); /* Slew Rate Field: Slow Slew Rate + Drive Strength Field: R0/6 + Speed Field: medium(100MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + +#endif + + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_04_ENET_RX_DATA00, /* GPIO_B1_04 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_05_ENET_RX_DATA01, /* GPIO_B1_05 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_06_ENET_RX_EN, /* GPIO_B1_06 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_07_ENET_TX_DATA00, /* GPIO_B1_07 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_08_ENET_TX_DATA01, /* GPIO_B1_08 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_09_ENET_TX_EN, /* GPIO_B1_09 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_10_ENET_REF_CLK, /* GPIO_B1_10 PAD functional properties : */ + 0x31u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/6 + Speed Field: low(50MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Disabled + Pull / Keep Select Field: Keeper + Pull Up / Down Config. Field: 100K Ohm Pull Down + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_B1_11_ENET_RX_ER, /* GPIO_B1_11 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_40_ENET_MDC, /* GPIO_EMC_40 PAD functional properties : */ + 0xB0E9u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: max(200MHz) + Open Drain Enable Field: Open Drain Disabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ + IOMUXC_SetPinConfig( + IOMUXC_GPIO_EMC_41_ENET_MDIO, /* GPIO_EMC_41 PAD functional properties : */ + 0xB829u); /* Slew Rate Field: Fast Slew Rate + Drive Strength Field: R0/5 + Speed Field: low(50MHz) + Open Drain Enable Field: Open Drain Enabled + Pull / Keep Enable Field: Pull/Keeper Enabled + Pull / Keep Select Field: Pull + Pull Up / Down Config. Field: 100K Ohm Pull Up + Hyst. Enable Field: Hysteresis Disabled */ +} + +/*********************************************************************************************************************** + * EOF + **********************************************************************************************************************/ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/system_MIMXRT1052.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/system_MIMXRT1052.c old mode 100644 new mode 100755 similarity index 99% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/system_MIMXRT1052.c rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/system_MIMXRT1052.c index e5b034d1..7c0b1659 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/system_MIMXRT1052.c +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/common/system_MIMXRT1052.c @@ -157,6 +157,7 @@ void SystemCoreClockUpdate (void) { case CCM_CBCMR_PERIPH_CLK2_SEL(2U): freq = (((CCM_ANALOG->PLL_SYS & CCM_ANALOG_PLL_SYS_BYPASS_CLK_SRC_MASK) >> CCM_ANALOG_PLL_SYS_BYPASS_CLK_SRC_SHIFT) == 0U) ? CPU_XTAL_CLK_HZ : CPU_CLK1_HZ; + break; case CCM_CBCMR_PERIPH_CLK2_SEL(3U): default: diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/Kconfig b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/Kconfig new file mode 100755 index 00000000..8b137891 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/Kconfig @@ -0,0 +1 @@ + diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/Makefile new file mode 100755 index 00000000..14be7282 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/Makefile @@ -0,0 +1,3 @@ +SRC_FILES := enet_ethernetif.c enet_ethernetif_kinetis.c fsl_enet.c +SRC_DIR := ksz8081 +include $(KERNEL_ROOT)/compiler.mk \ No newline at end of file diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif.c new file mode 100755 index 00000000..39d9f45b --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif.c @@ -0,0 +1,326 @@ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/* + * Copyright (c) 2013-2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file enet_ethernetif.c + * @brief ethernet drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#include "lwip/opt.h" +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/pbuf.h" +#include "lwip/stats.h" +#include "lwip/snmp.h" +#include "lwip/ethip6.h" +#include "netif/etharp.h" +#include "netif/ppp/pppoe.h" +#include "lwip/igmp.h" +#include "lwip/mld6.h" + +#if USE_RTOS && defined(FSL_RTOS_FREE_RTOS) +//#include "FreeRTOS.h" +//#include "event_groups.h" +#endif + +#include "netif/ethernet.h" +#include "enet_ethernetif.h" +#include "enet_ethernetif_priv.h" + +#include "fsl_enet.h" +#include "fsl_phy.h" +#include "fsl_gpio.h" +#include "fsl_iomuxc.h" + +#include "sys_arch.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + + +/******************************************************************************* + * Code + ******************************************************************************/ + +void enet_delay(void) +{ + volatile uint32_t i = 0; + for (i = 0; i < 1000000; ++i) + { + __asm("NOP"); /* delay */ + } +} + +void Time_Update_LwIP(void) +{ +} + +void ethernetif_clk_init(void) +{ + const clock_enet_pll_config_t config = {.enableClkOutput = true, .enableClkOutput25M = false, .loopDivider = 1}; + CLOCK_InitEnetPll(&config); + SysTick_Config(USEC_TO_COUNT(1000U, CLOCK_GetFreq(kCLOCK_CoreSysClk))); +} + +void ethernetif_gpio_init(void) +{ + gpio_pin_config_t gpio_config = {kGPIO_DigitalOutput, 0, kGPIO_NoIntmode}; + + IOMUXC_EnableMode(IOMUXC_GPR, kIOMUXC_GPR_ENET1TxClkOutputDir, true); + + GPIO_PinInit(GPIO1, 3, &gpio_config); + GPIO_PinInit(GPIO1, 10, &gpio_config); + /* pull up the ENET_INT before RESET. */ + GPIO_WritePinOutput(GPIO1, 10, 1); + GPIO_WritePinOutput(GPIO1, 3, 0); + enet_delay(); + GPIO_WritePinOutput(GPIO1, 3, 1); +} + +void ETH_BSP_Config(void) +{ + static int flag = 0; + if(flag == 0) + { + ethernetif_clk_init(); + ethernetif_gpio_init(); + flag = 1; + } +} + +void ethernetif_phy_init(struct ethernetif *ethernetif, + const ethernetif_config_t *ethernetifConfig, + enet_config_t *config) +{ + uint32_t sysClock; + status_t status; + bool link = false; + uint32_t count = 0; + phy_speed_t speed; + phy_duplex_t duplex; + + sysClock = CLOCK_GetFreq(ethernetifConfig->clockName); + + LWIP_PLATFORM_DIAG(("Initializing PHY...\r\n")); + + while ((count < ENET_ATONEGOTIATION_TIMEOUT) && (!link)) + { + status = PHY_Init(*ethernetif_enet_ptr(ethernetif), ethernetifConfig->phyAddress, sysClock); + + if (kStatus_Success == status) + { + PHY_GetLinkStatus(*ethernetif_enet_ptr(ethernetif), ethernetifConfig->phyAddress, &link); + } + else if (kStatus_PHY_AutoNegotiateFail == status) + { + LWIP_PLATFORM_DIAG(("PHY Auto-negotiation failed. Please check the ENET cable connection and link partner setting.")); + } + else + { + LWIP_ASSERT("\r\nCannot initialize PHY.\r\n", 0); + } + + count++; + } + + if (link) + { + /* Get the actual PHY link speed. */ + PHY_GetLinkSpeedDuplex(*ethernetif_enet_ptr(ethernetif), ethernetifConfig->phyAddress, &speed, &duplex); + /* Change the MII speed and duplex for actual link status. */ + config->miiSpeed = (enet_mii_speed_t)speed; + config->miiDuplex = (enet_mii_duplex_t)duplex; + } +#if 0 /* Disable assert. If initial auto-negation is timeout, \ \ + the ENET is set to default (100Mbs and full-duplex). */ + else + { + LWIP_ASSERT("\r\nGiving up PHY initialization. Please check the ENET cable connection and link partner setting and reset the board.\r\n", 0); + } +#endif +} + +/** + * This function should be called when a packet is ready to be read + * from the interface. It uses the function ethernetif_linkinput() that + * should handle the actual reception of bytes from the network + * interface. Then the type of the received packet is determined and + * the appropriate input function is called. + * + * @param netif the lwip network interface structure for this ethernetif + */ + +void ethernetif_input(struct netif *netif) +{ + struct pbuf *p; + err_t ret = 0; + + LWIP_ASSERT("netif != NULL", (netif != NULL)); + + /* move received packet into a new pbuf */ + while ((p = ethernetif_linkinput(netif)) != NULL) + { + /* pass all packets to ethernet_input, which decides what packets it supports */ + if ((ret = netif->input(p, netif)) != ERR_OK) + { +// LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_input: IP input error\n")); + lw_print("lw: [%s] ret %d p %p\n", __func__, ret, p); + pbuf_free(p); + p = NULL; + } + } +} + +static ENET_Type *ethernetif_get_enet_base(const uint8_t enetIdx) +{ + ENET_Type* enets[] = ENET_BASE_PTRS; + int arrayIdx; + int enetCount; + + for (arrayIdx = 0, enetCount = 0; arrayIdx < ARRAY_SIZE(enets); arrayIdx++) + { + if (enets[arrayIdx] != 0U) /* process only defined positions */ + { /* (some SOC headers count ENETs from 1 instead of 0) */ + if (enetCount == enetIdx) + { + return enets[arrayIdx]; + } + enetCount++; + } + } + return NULL; +} + +err_t ethernetif_init(struct netif *netif, struct ethernetif *ethernetif, + const uint8_t enetIdx, + const ethernetif_config_t *ethernetifConfig) +{ + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("ethernetifConfig != NULL", (ethernetifConfig != NULL)); + +#if LWIP_NETIF_HOSTNAME + /* Initialize interface hostname */ + netif->hostname = "lwip"; +#endif /* LWIP_NETIF_HOSTNAME */ + + /* + * Initialize the snmp variables and counters inside the struct netif. + * The last argument should be replaced with your link speed, in units + * of bits per second. + */ + MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, LINK_SPEED_OF_YOUR_NETIF_IN_BPS); + + netif->state = ethernetif; + netif->name[0] = IFNAME0; + netif->name[1] = IFNAME1; +/* We directly use etharp_output() here to save a function call. + * You can instead declare your own function an call etharp_output() + * from it if you have to do some checks before sending (e.g. if link + * is available...) */ +#if LWIP_IPV4 + netif->output = etharp_output; +#endif +#if LWIP_IPV6 + netif->output_ip6 = ethip6_output; +#endif /* LWIP_IPV6 */ + netif->linkoutput = ethernetif_linkoutput; + +#if LWIP_IPV4 && LWIP_IGMP + netif_set_igmp_mac_filter(netif, ethernetif_igmp_mac_filter); + netif->flags |= NETIF_FLAG_IGMP; +#endif +#if LWIP_IPV6 && LWIP_IPV6_MLD + netif_set_mld_mac_filter(netif, ethernetif_mld_mac_filter); + netif->flags |= NETIF_FLAG_MLD6; +#endif + + /* Init ethernetif parameters.*/ + *ethernetif_enet_ptr(ethernetif) = ethernetif_get_enet_base(enetIdx); + LWIP_ASSERT("*ethernetif_enet_ptr(ethernetif) != NULL", (*ethernetif_enet_ptr(ethernetif) != NULL)); + + /* set MAC hardware address length */ + netif->hwaddr_len = ETH_HWADDR_LEN; + + /* set MAC hardware address */ + memcpy(netif->hwaddr, ethernetifConfig->macAddress, NETIF_MAX_HWADDR_LEN); + + /* maximum transfer unit */ + netif->mtu = 1500; /* TODO: define a config */ + + /* device capabilities */ + /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */ + netif->flags |= NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_LINK_UP; + + /* ENET driver initialization.*/ + ethernetif_enet_init(netif, ethernetif, ethernetifConfig); + +#if LWIP_IPV6 && LWIP_IPV6_MLD + /* + * For hardware/netifs that implement MAC filtering. + * All-nodes link-local is handled by default, so we must let the hardware know + * to allow multicast packets in. + * Should set mld_mac_filter previously. */ + if (netif->mld_mac_filter != NULL) + { + ip6_addr_t ip6_allnodes_ll; + ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll); + netif->mld_mac_filter(netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER); + } +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ + + return ERR_OK; +} + diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif_kinetis.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif_kinetis.c new file mode 100755 index 00000000..68c63777 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif_kinetis.c @@ -0,0 +1,735 @@ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/* + * Copyright (c) 2013-2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file enet_ethernetif_kinetis.c + * @brief ethernet drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#include "lwip/opt.h" +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/pbuf.h" +#include "lwip/stats.h" +#include "lwip/snmp.h" +#include "lwip/ethip6.h" +#include "netif/etharp.h" +#include "netif/ppp/pppoe.h" +#include "lwip/igmp.h" +#include "lwip/mld6.h" + +//#define USE_RTOS 1 +//#define FSL_RTOS_FREE_RTOS +//#define FSL_RTOS_XIUOS + +#if USE_RTOS && defined(FSL_RTOS_FREE_RTOS) + +#ifdef FSL_RTOS_XIUOS +#include "xs_sem.h" + +#else +#include "FreeRTOS.h" +#include "event_groups.h" +#include "list.h" +#endif + +typedef uint32_t TickType_t; +#define portMAX_DELAY ( TickType_t ) 0xffffffffUL + +typedef TickType_t EventBits_t; + +typedef long BaseType_t; +typedef unsigned long UBaseType_t; + +#define portBASE_TYPE long + +#define pdFALSE ( ( BaseType_t ) 0 ) +#define pdTRUE ( ( BaseType_t ) 1 ) + +#define pdPASS ( pdTRUE ) +#define pdFAIL ( pdFALSE ) + +#ifndef FSL_RTOS_XIUOS +typedef struct EventGroupDef_t +{ + EventBits_t uxEventBits; + List_t xTasksWaitingForBits; /*< List of tasks waiting for a bit to be set. */ + + #if ( configUSE_TRACE_FACILITY == 1 ) + UBaseType_t uxEventGroupNumber; + #endif + + #if ( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) + uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the event group is statically allocated to ensure no attempt is made to free the memory. */ + #endif +} EventGroup_t; + +struct EventGroupDef_t; +typedef struct EventGroupDef_t * EventGroupHandle_t; +#endif + +#endif + +#include "enet_ethernetif.h" +#include "enet_ethernetif_priv.h" + +#include "fsl_enet.h" +#include "fsl_phy.h" + +#include "sys_arch.h" + + + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/** + * Helper struct to hold private data used to operate your ethernet interface. + */ +struct ethernetif +{ + ENET_Type *base; +#if (defined(FSL_FEATURE_SOC_ENET_COUNT) && (FSL_FEATURE_SOC_ENET_COUNT > 0)) || \ + (USE_RTOS && defined(FSL_RTOS_FREE_RTOS)) + enet_handle_t handle; +#endif +#if USE_RTOS && defined(FSL_RTOS_FREE_RTOS) + +#ifdef FSL_RTOS_XIUOS + int enetSemaphore; +#else + EventGroupHandle_t enetTransmitAccessEvent; +#endif + EventBits_t txFlag; +#endif + enet_rx_bd_struct_t *RxBuffDescrip; + enet_tx_bd_struct_t *TxBuffDescrip; + rx_buffer_t *RxDataBuff; + tx_buffer_t *TxDataBuff; +}; + + +/******************************************************************************* + * Code + ******************************************************************************/ +#if USE_RTOS && defined(FSL_RTOS_FREE_RTOS) +#if FSL_FEATURE_ENET_QUEUE > 1 +static void ethernet_callback(ENET_Type *base, enet_handle_t *handle, uint32_t ringId, enet_event_t event, void *param) +#else +static void ethernet_callback(ENET_Type *base, enet_handle_t *handle, enet_event_t event, void *param) +#endif /* FSL_FEATURE_ENET_QUEUE */ +{ + struct netif *netif = (struct netif *)param; + struct ethernetif *ethernetif = netif->state; + BaseType_t xResult; + + + lw_print("lw: [%s] input event %#x \n", __func__, event); + + switch (event) + { + case kENET_RxEvent: + ethernetif_input(netif); + break; + case kENET_TxEvent: + { + portBASE_TYPE taskToWake = pdFALSE; + +#ifdef FSL_RTOS_XIUOS + +#else +#ifdef __CA7_REV + if (SystemGetIRQNestingLevel()) +#else + if (__get_IPSR()) +#endif + { + xResult = xEventGroupSetBitsFromISR(ethernetif->enetTransmitAccessEvent, ethernetif->txFlag, &taskToWake); + if ((pdPASS == xResult) && (pdTRUE == taskToWake)) + { + portYIELD_FROM_ISR(taskToWake); + } + } + else + { + xEventGroupSetBits(ethernetif->enetTransmitAccessEvent, ethernetif->txFlag); + } +#endif + } + break; + default: + break; + } + + KSemaphoreAbandon(ethernetif->enetSemaphore); +} +#endif + +#if LWIP_IPV4 && LWIP_IGMP +err_t ethernetif_igmp_mac_filter(struct netif *netif, const ip4_addr_t *group, + enum netif_mac_filter_action action) +{ + struct ethernetif *ethernetif = netif->state; + uint8_t multicastMacAddr[6]; + err_t result; + + multicastMacAddr[0] = 0x01U; + multicastMacAddr[1] = 0x00U; + multicastMacAddr[2] = 0x5EU; + multicastMacAddr[3] = (group->addr >> 8) & 0x7FU; + multicastMacAddr[4] = (group->addr >> 16) & 0xFFU; + multicastMacAddr[5] = (group->addr >> 24) & 0xFFU; + + switch (action) + { + case IGMP_ADD_MAC_FILTER: + /* Adds the ENET device to a multicast group.*/ + ENET_AddMulticastGroup(ethernetif->base, multicastMacAddr); + result = ERR_OK; + break; + case IGMP_DEL_MAC_FILTER: + /* + * Moves the ENET device from a multicast group. + * Since the ENET_LeaveMulticastGroup() could filter out also other + * group addresses having the same hash, the call is commented out. + */ + /* ENET_LeaveMulticastGroup(ethernetif->base, multicastMacAddr); */ + result = ERR_OK; + break; + default: + result = ERR_IF; + break; + } + + return result; +} +#endif + +#if LWIP_IPV6 && LWIP_IPV6_MLD +err_t ethernetif_mld_mac_filter(struct netif *netif, const ip6_addr_t *group, + enum netif_mac_filter_action action) +{ + struct ethernetif *ethernetif = netif->state; + uint8_t multicastMacAddr[6]; + err_t result; + + multicastMacAddr[0] = 0x33U; + multicastMacAddr[1] = 0x33U; + multicastMacAddr[2] = (group->addr[3]) & 0xFFU; + multicastMacAddr[3] = (group->addr[3] >> 8) & 0xFFU; + multicastMacAddr[4] = (group->addr[3] >> 16) & 0xFFU; + multicastMacAddr[5] = (group->addr[3] >> 24) & 0xFFU; + + switch (action) + { + case NETIF_ADD_MAC_FILTER: + /* Adds the ENET device to a multicast group.*/ + ENET_AddMulticastGroup(ethernetif->base, multicastMacAddr); + result = ERR_OK; + break; + case NETIF_DEL_MAC_FILTER: + /* + * Moves the ENET device from a multicast group. + * Since the ENET_LeaveMulticastGroup() could filter out also other + * group addresses having the same hash, the call is commented out. + */ + /* ENET_LeaveMulticastGroup(ethernetif->base, multicastMacAddr); */ + result = ERR_OK; + break; + default: + result = ERR_IF; + break; + } + + return result; +} +#endif + +#define netifINTERFACE_TASK_STACK_SIZE ( 4096 ) + +/** + * This function is the ethernetif_input task, it is processed when a packet + * is ready to be read from the interface. It uses the function low_level_input() + * that should handle the actual reception of bytes from the network + * interface. Then the type of the received packet is determined and + * the appropriate input function is called. + * + * @param netif the lwip network interface structure for this ethernetif + */ +//void eth_input( void * pvParameters ) +//{ +// struct pbuf *p; +// +// for( ;; ) +// { +// if (KSemaphoreObtain( s_xSemaphore, WAITING_FOREVER)==EOK) +// { +// p = low_level_input( s_pxNetIf ); +// +// if (ERR_OK != s_pxNetIf->input( p, s_pxNetIf)) +// { +// KPrintf("netif input return not OK ! \n"); +// pbuf_free(p); +// p=NULL; +// } +// } +// } +//} +// +//void low_level_init() +//{ +// /* create the task that handles the ETH_MAC */ +// uint32 thr_id = KTaskCreate((signed char*) "eth_input", +// eth_input, +// NULL, +// netifINTERFACE_TASK_STACK_SIZE, +// 15); +// if (thr_id >= 0) +// { +// StartupKTask(thr_id); +// } +// else +// { +// KPrintf("Eth create failed !"); +// } +//} + + +/** + * Initializes ENET driver. + */ +void ethernetif_enet_init(struct netif *netif, struct ethernetif *ethernetif, + const ethernetif_config_t *ethernetifConfig) +{ + enet_config_t config; + uint32_t sysClock; + enet_buffer_config_t buffCfg[ENET_RING_NUM]; + + /* prepare the buffer configuration. */ + buffCfg[0].rxBdNumber = ENET_RXBD_NUM; /* Receive buffer descriptor number. */ + buffCfg[0].txBdNumber = ENET_TXBD_NUM; /* Transmit buffer descriptor number. */ + buffCfg[0].rxBuffSizeAlign = sizeof(rx_buffer_t); /* Aligned receive data buffer size. */ + buffCfg[0].txBuffSizeAlign = sizeof(tx_buffer_t); /* Aligned transmit data buffer size. */ + buffCfg[0].rxBdStartAddrAlign = &(ethernetif->RxBuffDescrip[0]); /* Aligned receive buffer descriptor start address. */ + buffCfg[0].txBdStartAddrAlign = &(ethernetif->TxBuffDescrip[0]); /* Aligned transmit buffer descriptor start address. */ + buffCfg[0].rxBufferAlign = &(ethernetif->RxDataBuff[0][0]); /* Receive data buffer start address. */ + buffCfg[0].txBufferAlign = &(ethernetif->TxDataBuff[0][0]); /* Transmit data buffer start address. */ + + sysClock = CLOCK_GetFreq(ethernetifConfig->clockName); + + ENET_GetDefaultConfig(&config); + config.ringNum = ENET_RING_NUM; + + ethernetif_phy_init(ethernetif, ethernetifConfig, &config); + +#if USE_RTOS && defined(FSL_RTOS_FREE_RTOS) + uint32_t instance; + static ENET_Type *const enetBases[] = ENET_BASE_PTRS; + static const IRQn_Type enetTxIrqId[] = ENET_Transmit_IRQS; + /*! @brief Pointers to enet receive IRQ number for each instance. */ + static const IRQn_Type enetRxIrqId[] = ENET_Receive_IRQS; +#if defined(ENET_ENHANCEDBUFFERDESCRIPTOR_MODE) && ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /*! @brief Pointers to enet timestamp IRQ number for each instance. */ + static const IRQn_Type enetTsIrqId[] = ENET_1588_Timer_IRQS; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + /* Create the Event for transmit busy release trigger. */ +#ifdef FSL_RTOS_XIUOS + if(ethernetif->enetSemaphore < 0) + { + ethernetif->enetSemaphore = KSemaphoreCreate(0); + } +#else + ethernetif->enetTransmitAccessEvent = xEventGroupCreate(); +#endif + ethernetif->txFlag = 0x1; + + config.interrupt |= kENET_RxFrameInterrupt | kENET_TxFrameInterrupt | kENET_TxBufferInterrupt; + + for (instance = 0; instance < ARRAY_SIZE(enetBases); instance++) + { + if (enetBases[instance] == ethernetif->base) + { +#ifdef __CA7_REV + GIC_SetPriority(enetRxIrqId[instance], ENET_PRIORITY); + GIC_SetPriority(enetTxIrqId[instance], ENET_PRIORITY); +#if defined(ENET_ENHANCEDBUFFERDESCRIPTOR_MODE) && ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + GIC_SetPriority(enetTsIrqId[instance], ENET_1588_PRIORITY); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +#else + NVIC_SetPriority(enetRxIrqId[instance], ENET_PRIORITY); + NVIC_SetPriority(enetTxIrqId[instance], ENET_PRIORITY); +#if defined(ENET_ENHANCEDBUFFERDESCRIPTOR_MODE) && ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + NVIC_SetPriority(enetTsIrqId[instance], ENET_1588_PRIORITY); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +#endif /* __CA7_REV */ + break; + } + } + + LWIP_ASSERT("Input Ethernet base error!", (instance != ARRAY_SIZE(enetBases))); +#endif /* USE_RTOS */ + + /* Initialize the ENET module.*/ + ENET_Init(ethernetif->base, ðernetif->handle, &config, &buffCfg[0], netif->hwaddr, sysClock); + +#if USE_RTOS && defined(FSL_RTOS_FREE_RTOS) + ENET_SetCallback(ðernetif->handle, ethernet_callback, netif); +#endif + + ENET_ActiveRead(ethernetif->base); +// low_level_init(); +} + +ENET_Type **ethernetif_enet_ptr(struct ethernetif *ethernetif) +{ + return &(ethernetif->base); +} + +/** + * Returns next buffer for TX. + * Can wait if no buffer available. + */ +static unsigned char *enet_get_tx_buffer(struct ethernetif *ethernetif) +{ + static unsigned char ucBuffer[ENET_FRAME_MAX_FRAMELEN]; + return ucBuffer; +} + +/** + * Sends frame via ENET. + */ +static err_t enet_send_frame(struct ethernetif *ethernetif, unsigned char *data, const uint32_t length) +{ +#if USE_RTOS && defined(FSL_RTOS_FREE_RTOS) + { + status_t result; + + lw_print("lw: [%s] len %d\n", __func__, length); + + do + { + result = ENET_SendFrame(ethernetif->base, ðernetif->handle, data, length); + + if (result == kStatus_ENET_TxFrameBusy) + { +#ifdef FSL_RTOS_XIUOS +// KSemaphoreObtain(ethernetif->enetSemaphore, portMAX_DELAY); +#else + xEventGroupWaitBits(ethernetif->enetTransmitAccessEvent, ethernetif->txFlag, pdTRUE, (BaseType_t) false, + portMAX_DELAY); +#endif + } + + } while (result == kStatus_ENET_TxFrameBusy); + + return ERR_OK; + } +#else + { + uint32_t counter; + + for (counter = ENET_TIMEOUT; counter != 0U; counter--) + { + if (ENET_SendFrame(ethernetif->base, ðernetif->handle, data, length) != kStatus_ENET_TxFrameBusy) + { + return ERR_OK; + } + } + + return ERR_TIMEOUT; + } +#endif +} + +struct pbuf *ethernetif_linkinput(struct netif *netif) +{ + struct ethernetif *ethernetif = netif->state; + struct pbuf *p = NULL; + struct pbuf *q; + uint32_t len; + status_t status; + + /* Obtain the size of the packet and put it into the "len" + variable. */ + status = ENET_GetRxFrameSize(ðernetif->handle, &len); + + if (kStatus_ENET_RxFrameEmpty != status) + { + /* Call ENET_ReadFrame when there is a received frame. */ + if (len != 0) + { +#if ETH_PAD_SIZE + len += ETH_PAD_SIZE; /* allow room for Ethernet padding */ +#endif + + /* We allocate a pbuf chain of pbufs from the pool. */ + p = pbuf_alloc(PBUF_RAW, len, PBUF_POOL); + + if (p != NULL) + { +#if ETH_PAD_SIZE + pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */ +#endif + if (p->next == 0) /* One-chain buffer.*/ + { + ENET_ReadFrame(ethernetif->base, ðernetif->handle, p->payload, p->len); + } + else /* Multi-chain buffer.*/ + { + uint8_t data_tmp[ENET_FRAME_MAX_FRAMELEN]; + uint32_t data_tmp_len = 0; + + ENET_ReadFrame(ethernetif->base, ðernetif->handle, data_tmp, p->tot_len); + + /* We iterate over the pbuf chain until we have read the entire + * packet into the pbuf. */ + for (q = p; (q != NULL) && ((data_tmp_len + q->len) <= sizeof(data_tmp)); q = q->next) + { + /* Read enough bytes to fill this pbuf in the chain. The + * available data in the pbuf is given by the q->len + * variable. */ + memcpy(q->payload, &data_tmp[data_tmp_len], q->len); + data_tmp_len += q->len; + } + } + + MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len); + if (((u8_t *)p->payload)[0] & 1) + { + /* broadcast or multicast packet*/ + MIB2_STATS_NETIF_INC(netif, ifinnucastpkts); + } + else + { + /* unicast packet*/ + MIB2_STATS_NETIF_INC(netif, ifinucastpkts); + } +#if ETH_PAD_SIZE + pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */ +#endif + + LINK_STATS_INC(link.recv); + } + else + { + /* drop packet*/ + ENET_ReadFrame(ethernetif->base, ðernetif->handle, NULL, 0U); + + LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_linkinput: Fail to allocate new memory space\n")); + + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(netif, ifindiscards); + } + } + else + { + /* Update the received buffer when error happened. */ + if (status == kStatus_ENET_RxFrameError) + { +#if 0 && defined(FSL_FEATURE_SOC_ENET_COUNT) && (FSL_FEATURE_SOC_ENET_COUNT > 0) /* Error statisctics */ + enet_data_error_stats_t eErrStatic; + /* Get the error information of the received g_frame. */ + ENET_GetRxErrBeforeReadFrame(ðernetif->handle, &eErrStatic); +#endif + + /* Update the receive buffer. */ + ENET_ReadFrame(ethernetif->base, ðernetif->handle, NULL, 0U); + + LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_linkinput: RxFrameError\n")); + + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(netif, ifindiscards); + } + } + } + + return p; +} + +err_t ethernetif_linkoutput(struct netif *netif, struct pbuf *p) +{ + err_t result; + struct ethernetif *ethernetif = netif->state; + struct pbuf *q; + unsigned char *pucBuffer; + unsigned char *pucChar; + + LWIP_ASSERT("Output packet buffer empty", p); + + pucBuffer = enet_get_tx_buffer(ethernetif); + if (pucBuffer == NULL) + { + return ERR_BUF; + } + +/* Initiate transfer. */ + +#if ETH_PAD_SIZE + pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */ +#endif + + if (p->len == p->tot_len) + { + /* No pbuf chain, don't have to copy -> faster. */ + pucBuffer = (unsigned char *)p->payload; + } + else + { + /* pbuf chain, copy into contiguous ucBuffer. */ + if (p->tot_len > ENET_FRAME_MAX_FRAMELEN) + { + return ERR_BUF; + } + else + { + pucChar = pucBuffer; + + for (q = p; q != NULL; q = q->next) + { + /* Send the data from the pbuf to the interface, one pbuf at a + time. The size of the data in each pbuf is kept in the ->len + variable. */ + /* send data from(q->payload, q->len); */ + memcpy(pucChar, q->payload, q->len); + pucChar += q->len; + } + } + } + + /* Send frame. */ + result = enet_send_frame(ethernetif, pucBuffer, p->tot_len); + + MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len); + if (((u8_t *)p->payload)[0] & 1) + { + /* broadcast or multicast packet*/ + MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts); + } + else + { + /* unicast packet */ + MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); + } +/* increase ifoutdiscards or ifouterrors on error */ + +#if ETH_PAD_SIZE + pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */ +#endif + + LINK_STATS_INC(link.xmit); + + return result; +} + +/** + * Should be called at the beginning of the program to set up the + * first network interface. It calls the function ethernetif_init() to do the + * actual setup of the hardware. + * + * This function should be passed as a parameter to netif_add(). + * + * @param netif the lwip network interface structure for this ethernetif + * @return ERR_OK if the loopif is initialized + * ERR_MEM if private data couldn't be allocated + * any other err_t on error + */ +err_t ethernetif0_init(struct netif *netif) +{ + static struct ethernetif ethernetif_0; + AT_NONCACHEABLE_SECTION_ALIGN(static enet_rx_bd_struct_t rxBuffDescrip_0[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + AT_NONCACHEABLE_SECTION_ALIGN(static enet_tx_bd_struct_t txBuffDescrip_0[ENET_TXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + SDK_ALIGN(static rx_buffer_t rxDataBuff_0[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + SDK_ALIGN(static tx_buffer_t txDataBuff_0[ENET_TXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + + ethernetif_0.RxBuffDescrip = &(rxBuffDescrip_0[0]); + ethernetif_0.TxBuffDescrip = &(txBuffDescrip_0[0]); + ethernetif_0.RxDataBuff = &(rxDataBuff_0[0]); + ethernetif_0.TxDataBuff = &(txDataBuff_0[0]); + + return ethernetif_init(netif, ðernetif_0, 0U, (ethernetif_config_t *)netif->state); +} + +#if defined(FSL_FEATURE_SOC_ENET_COUNT) && (FSL_FEATURE_SOC_ENET_COUNT > 1) +/** + * Should be called at the beginning of the program to set up the + * second network interface. It calls the function ethernetif_init() to do the + * actual setup of the hardware. + * + * This function should be passed as a parameter to netif_add(). + * + * @param netif the lwip network interface structure for this ethernetif + * @return ERR_OK if the loopif is initialized + * ERR_MEM if private data couldn't be allocated + * any other err_t on error + */ +err_t ethernetif1_init(struct netif *netif) +{ + static struct ethernetif ethernetif_1; + AT_NONCACHEABLE_SECTION_ALIGN(static enet_rx_bd_struct_t rxBuffDescrip_1[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + AT_NONCACHEABLE_SECTION_ALIGN(static enet_tx_bd_struct_t txBuffDescrip_1[ENET_TXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + SDK_ALIGN(static rx_buffer_t rxDataBuff_1[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + SDK_ALIGN(static tx_buffer_t txDataBuff_1[ENET_TXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + + ethernetif_1.RxBuffDescrip = &(rxBuffDescrip_1[0]); + ethernetif_1.TxBuffDescrip = &(txBuffDescrip_1[0]); + ethernetif_1.RxDataBuff = &(rxDataBuff_1[0]); + ethernetif_1.TxDataBuff = &(txDataBuff_1[0]); + + return ethernetif_init(netif, ðernetif_1, 1U, (ethernetif_config_t *)netif->state); +} +#endif /* FSL_FEATURE_SOC_*_ENET_COUNT */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif_lpc.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif_lpc.c new file mode 100755 index 00000000..3afc0da4 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/enet_ethernetif_lpc.c @@ -0,0 +1,972 @@ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/* + * Copyright (c) 2013-2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file enet_ethernetif_lpc.c + * @brief ethernet drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + + +#include "lwip/opt.h" +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/pbuf.h" +#include "lwip/stats.h" +#include "lwip/snmp.h" +#include "lwip/sys.h" +#include "lwip/ethip6.h" +#include "netif/etharp.h" +#include "netif/ppp/pppoe.h" +#include "lwip/igmp.h" +#include "lwip/mld6.h" + +//#if !NO_SYS +//#include "FreeRTOS.h" +//#include "event_groups.h" +//#include "lwip/tcpip.h" +//#endif /* !NO_SYS */ + +#include "enet_ethernetif.h" +#include "enet_ethernetif_priv.h" + +#include "fsl_enet.h" +#include "fsl_phy.h" + +//#if MEM_ALIGNMENT != FSL_ENET_BUFF_ALIGNMENT +///* These two has to match for zero-copy functionality */ +//#error "MEM_ALIGNMENT != FSL_ENET_BUFF_ALIGNMENT" +//#endif /* MEM_ALIGNMENT != FSL_ENET_BUFF_ALIGNMENT */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! + * @brief Used to wrap received data in a pbuf to be passed into lwIP + * without copying. + * Once last reference is released, RX descriptor will be returned to DMA. + */ +typedef struct rx_pbuf_wrapper +{ + struct pbuf_custom p; /*!< Pbuf wrapper. Has to be first. */ + enet_rx_bd_struct_t* rxDesc; /*!< Descriptor holding the data. */ + struct ethernetif *ethernetif; /*!< Ethernet interface context data. */ + volatile bool ownedByLwip; /*!< If true, descriptor cannot be reused by DMA yet. */ +} rx_pbuf_wrapper_t; + +/*! + * @brief Helper struct to hold private data used to operate + * your ethernet interface. + */ +struct ethernetif +{ + ENET_Type *base; + enet_handle_t handle; +#if !NO_SYS + EventGroupHandle_t enetTransmitAccessEvent; + EventBits_t txFlag; +#endif /* !NO_SYS */ + enet_rx_bd_struct_t *RxBuffDescrip; + enet_tx_bd_struct_t *TxBuffDescrip; + rx_buffer_t *RxDataBuff; + volatile struct pbuf *txPbufs[ENET_TXBD_NUM]; + volatile uint8_t txIdx; + volatile uint8_t txReleaseIdx; + rx_pbuf_wrapper_t rxPbufs[ENET_RXBD_NUM]; + uint8_t rxIdx; + const mem_range_t *non_dma_memory; +}; + +static void ethernetif_tx_release(struct ethernetif *ethernetif); +static void ethernetif_rx_release(struct pbuf *p); + +/******************************************************************************* + * Code + ******************************************************************************/ + +/** + * Called from ENET ISR. + */ +static void ethernet_callback(ENET_Type *base, enet_handle_t *handle, + enet_event_t event, uint8_t channel, void *param) +#if NO_SYS +{ + struct netif *netif = (struct netif *)param; + struct ethernetif *ethernetif = netif->state; + + if (event == kENET_TxIntEvent) + { + ethernetif_tx_release(ethernetif); + } +} +#else +{ + struct netif *netif = (struct netif *)param; + struct ethernetif *ethernetif = netif->state; + BaseType_t xResult; + + switch (event) + { + case kENET_RxIntEvent: + ethernetif_input(netif); + break; + case kENET_TxIntEvent: + { + portBASE_TYPE taskToWake = pdFALSE; + + ethernetif_tx_release(ethernetif); + +#ifdef __CA7_REV + if (SystemGetIRQNestingLevel()) +#else + if (__get_IPSR()) +#endif + { + xResult = xEventGroupSetBitsFromISR( + ethernetif->enetTransmitAccessEvent, + ethernetif->txFlag, &taskToWake); + if ((pdPASS == xResult) && (pdTRUE == taskToWake)) + { + portYIELD_FROM_ISR(taskToWake); + } + } + else + { + xEventGroupSetBits(ethernetif->enetTransmitAccessEvent, + ethernetif->txFlag); + } + + break; + } + default: + break; + } +} +#endif /* NO_SYS */ + +#if LWIP_IPV4 && LWIP_IGMP +err_t ethernetif_igmp_mac_filter(struct netif *netif, const ip4_addr_t *group, + enum netif_mac_filter_action action) +{ + struct ethernetif *ethernetif = netif->state; + err_t result; + + switch (action) + { + case IGMP_ADD_MAC_FILTER: + /* LPC ENET does not accept multicast selectively, + * so all multicast has to be passed through. */ + ENET_AcceptAllMulticast(ethernetif->base); + result = ERR_OK; + break; + case IGMP_DEL_MAC_FILTER: + /* + * Moves the ENET device from a multicast group. + * Since we don't keep track of which multicast groups + * are still to enabled, the call is commented out. + */ + /* ENET_RejectAllMulticast(ethernetif->base); */ + result = ERR_OK; + break; + default: + result = ERR_IF; + break; + } + + return result; +} +#endif + +#if LWIP_IPV6 && LWIP_IPV6_MLD +err_t ethernetif_mld_mac_filter(struct netif *netif, const ip6_addr_t *group, + enum netif_mac_filter_action action) +{ + struct ethernetif *ethernetif = netif->state; + err_t result; + + switch (action) + { + case NETIF_ADD_MAC_FILTER: + /* LPC ENET does not accept multicast selectively, + * so all multicast has to be passed through. */ + ENET_AcceptAllMulticast(ethernetif->base); + result = ERR_OK; + break; + case NETIF_DEL_MAC_FILTER: + /* + * Moves the ENET device from a multicast group. + * Since we don't keep track of which multicast groups + * are still to enabled, the call is commented out. + */ + /* ENET_RejectAllMulticast(ethernetif->base); */ + result = ERR_OK; + break; + default: + result = ERR_IF; + break; + } + + return result; +} +#endif + +/** + * Gets the RX descriptor by its index. + */ +static inline enet_rx_bd_struct_t *ethernetif_get_rx_desc( + struct ethernetif *ethernetif, + uint32_t index) +{ + return &(ethernetif->RxBuffDescrip[index]); +} + +/** + * Gets the TX descriptor by its index. + */ +static inline enet_tx_bd_struct_t *ethernetif_get_tx_desc( + struct ethernetif *ethernetif, + uint32_t index) +{ + return &(ethernetif->TxBuffDescrip[index]); +} + +/** + * Initializes ENET driver. + */ +void ethernetif_enet_init(struct netif *netif, struct ethernetif *ethernetif, + const ethernetif_config_t *ethernetifConfig) +{ + enet_config_t config; + uint32_t sysClock; + enet_buffer_config_t buffCfg[ENET_RING_NUM]; + uint32_t rxBufferStartAddr[ENET_RXBD_NUM]; + uint32_t i; + + /* calculate start addresses of all rx buffers */ + for (i = 0; i < ENET_RXBD_NUM; i++) + { + rxBufferStartAddr[i] = (uint32_t)&(ethernetif->RxDataBuff[i][ETH_PAD_SIZE]); + } + + /* prepare the buffer configuration. */ + buffCfg[0].rxRingLen = ENET_RXBD_NUM; /* The length of receive buffer descriptor ring. */ + buffCfg[0].txRingLen = ENET_TXBD_NUM; /* The length of transmit buffer descriptor ring. */ + buffCfg[0].txDescStartAddrAlign = ethernetif_get_tx_desc(ethernetif, 0U); /* Aligned transmit descriptor start address. */ + buffCfg[0].txDescTailAddrAlign = ethernetif_get_tx_desc(ethernetif, 0U); /* Aligned transmit descriptor tail address. */ + buffCfg[0].rxDescStartAddrAlign = ethernetif_get_rx_desc(ethernetif, 0U); /* Aligned receive descriptor start address. */ + buffCfg[0].rxDescTailAddrAlign = ethernetif_get_rx_desc(ethernetif, ENET_RXBD_NUM); /* Aligned receive descriptor tail address. */ + buffCfg[0].rxBufferStartAddr = rxBufferStartAddr; /* Start addresses of the rx buffers. */ + buffCfg[0].rxBuffSizeAlign = sizeof(rx_buffer_t); /* Aligned receive data buffer size. */ + + sysClock = CLOCK_GetFreq(ethernetifConfig->clockName); + + LWIP_ASSERT("ethernetifConfig->non_dma_memory == NULL", (ethernetifConfig->non_dma_memory != NULL)); + ethernetif->non_dma_memory = ethernetifConfig->non_dma_memory; + + ENET_GetDefaultConfig(&config); + config.multiqueueCfg = NULL; + + ethernetif_phy_init(ethernetif, ethernetifConfig, &config); + +#if !NO_SYS + /* Create the Event for transmit busy release trigger. */ + ethernetif->enetTransmitAccessEvent = xEventGroupCreate(); + ethernetif->txFlag = 0x1; +#endif /* !NO_SYS */ + NVIC_SetPriority(ETHERNET_IRQn, ENET_PRIORITY); + + ethernetif->txIdx = 0U; + ethernetif->rxIdx = 0U; + ethernetif->txReleaseIdx = 0U; + + for (i = 0; i < ENET_RXBD_NUM; i++) + { + ethernetif->rxPbufs[i].p.custom_free_function = ethernetif_rx_release; + ethernetif->rxPbufs[i].rxDesc = ðernetif->RxBuffDescrip[i]; + ethernetif->rxPbufs[i].ethernetif = ethernetif; + ethernetif->rxPbufs[i].ownedByLwip = false; + } + + ENET_Init(ethernetif->base, &config, netif->hwaddr, sysClock); + +#if defined(LPC54018_SERIES) + /* Workaround for receive issue on lpc54018 */ + ethernetif->base->MAC_FRAME_FILTER |= ENET_MAC_FRAME_FILTER_RA_MASK; +#endif + + /* Create the handler. */ +#if NO_SYS + ENET_EnableInterrupts(ethernetif->base, kENET_DmaTx); +#else + ENET_EnableInterrupts(ethernetif->base, kENET_DmaTx | kENET_DmaRx); +#endif /* NO_SYS */ + ENET_CreateHandler(ethernetif->base, ðernetif->handle, &config, + &buffCfg[0], ethernet_callback, netif); + + ENET_DescriptorInit(ethernetif->base, &config, &buffCfg[0]); + + /* Active TX/RX. */ + ENET_StartRxTx(ethernetif->base, 1, 1); +} + +ENET_Type **ethernetif_enet_ptr(struct ethernetif *ethernetif) +{ + return &(ethernetif->base); +} + +/** + * Find the ENET instance index from its base address. + */ +static uint32_t ethernetif_get_enet_idx(ENET_Type *base) +{ + static ENET_Type *const s_enetBases[] = ENET_BASE_PTRS; + uint32_t instance; + + for (instance = 0; instance < FSL_FEATURE_SOC_LPC_ENET_COUNT; instance++) + { + if (s_enetBases[instance] == base) + { + break; + } + } + + LWIP_ASSERT("Cannot find ENET instance index from its base address.", + instance < FSL_FEATURE_SOC_LPC_ENET_COUNT); + + return instance; +} + +/** + * Sends (part of) a frame via ENET. + * TODO: Since ENET_SendFrame() could not be used, some functionality it does + * is missing here for now (channel selection depending on AVB content, + * timestamping. + */ +static void ethernetif_send_buffer(struct ethernetif *ethernetif, + unsigned char *data, + const uint32_t length, + struct pbuf *p_to_release, + enet_desc_flag flag) +{ + static const IRQn_Type s_enetIrqId[] = ENET_IRQS; + enet_tx_bd_struct_t *txDesc = ethernetif_get_tx_desc(ethernetif, + ethernetif->txIdx); + ethernetif->txPbufs[ethernetif->txIdx] = p_to_release; + ethernetif->txIdx = (ethernetif->txIdx + 1) % ENET_TXBD_NUM; + + /* Prepare the descriptor for transmit. */ + txDesc->buff1Addr = (uint32_t)data; + txDesc->buff2Addr = (uint32_t)NULL; + txDesc->buffLen = + ENET_TXDESCRIP_RD_BL1(length) | ENET_TXDESCRIP_RD_IOC_MASK; + + txDesc->controlStat = + ENET_TXDESCRIP_RD_FL(length) | ENET_TXDESCRIP_RD_LDFD(flag); + if ((flag & kENET_FirstFlagOnly) == 0) + { + /* + * Submit to DMA if not the first descriptor in chain. + * All the descriptors have to be prepared before the first one + * is flagged for DMA and transfer starts. ENET could output invalid + * frames otherwise (the exception is Store and Forward mode, where + * delays between preparing of descriptors does not matter). + */ + txDesc->controlStat |= ENET_TXDESCRIP_RD_OWN_MASK; + } + + enet_tx_bd_ring_t *txBdRing = (enet_tx_bd_ring_t *) + ðernetif->handle.txBdRing[0]; + + /* + * Increment txDescUsed. + * Without this, callback would not fire from ENET ISR on finished TX. + * This is kind of a hack. Alternative could be to define + * void ETHERNET_DriverIRQHandler(void) and handle IRQs completely + * in this file. + */ + DisableIRQ(s_enetIrqId[ethernetif_get_enet_idx(ethernetif->base)]); + txBdRing->txDescUsed++; + EnableIRQ(s_enetIrqId[ethernetif_get_enet_idx(ethernetif->base)]); +} + +/** + * Reclaims exactly one TX descriptor after its data has been sent out. + * Then the descriptor can be used by application to prepare next data to send. + */ +static void ethernetif_tx_release(struct ethernetif *ethernetif) +{ + LWIP_ASSERT("Attempt to release more TX buffers than acquired.", + ethernetif->txIdx != ethernetif->txReleaseIdx); + enet_tx_bd_struct_t *txDesc + = ðernetif->TxBuffDescrip[ethernetif->txReleaseIdx]; + LWIP_ASSERT("TX buffer still owned by DMA.", + !ENET_IsTxDescriptorDmaOwn(txDesc)); + + struct pbuf *p = (struct pbuf *) + ethernetif->txPbufs[ethernetif->txReleaseIdx]; + if (p != NULL) + { +#if ETH_PAD_SIZE + /* Reclaim the padding, force because it may be REF pbuf. */ + pbuf_header_force(p, ETH_PAD_SIZE); +#endif + +#if NO_SYS +#if defined(LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT) && LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + pbuf_free(p); +#else + #error "Bare metal requires LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT=1 because pbuf_free() is being called from an ISR" +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ +#else + if (pbuf_free_callback(p) != ERR_OK) + { +#if defined(LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT) && LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + pbuf_free(p); +#else + LWIP_ASSERT("Failed to enqueue pbuf deallocation on tcpip_thread", + 0); +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + } +#endif /* NO_SYS */ + + ethernetif->txPbufs[ethernetif->txReleaseIdx] = NULL; + } + + ethernetif->txReleaseIdx = (ethernetif->txReleaseIdx + 1) % ENET_TXBD_NUM; +} + +/** + * Reclaims RX descriptor which holds the p's buffer after p is no longer used + * by the application / lwIP. The DMA can receive new data into + * the descriptor's buffer then. + * Note that RX buffers may be freed by lwIP out of the order in which they were + * passed to lwIP. Therefore there may be spaces between the RX descriptors + * flagged as owned by DMA and DMA could still wait until it's actual position + * is released. + */ +static void ethernetif_rx_release(struct pbuf *p) +{ + SYS_ARCH_DECL_PROTECT(old_level); + rx_pbuf_wrapper_t *wrapper = (rx_pbuf_wrapper_t *)p; +#if NO_SYS + bool intEnable = false; +#else + bool intEnable = true; +#endif /* NO_SYS */ + + SYS_ARCH_PROTECT(old_level); + + wrapper->ownedByLwip = false; + + /* Update the receive buffer descriptor. */ + ENET_UpdateRxDescriptor(wrapper->rxDesc, NULL, NULL, intEnable, false); + ENET_UpdateRxDescriptorTail(wrapper->ethernetif->base, 0U, + (uint32_t)ethernetif_get_rx_desc(wrapper->ethernetif, ENET_RXBD_NUM)); + + SYS_ARCH_UNPROTECT(old_level); +} + +/** + * Gets the length of a received frame (if there is some). + */ +static status_t ethernetif_get_rx_frame_size(struct ethernetif *ethernetif, + uint32_t *length) +{ + uint8_t index = ethernetif->rxIdx; + enet_rx_bd_struct_t *rxDesc; + uint32_t rxControl; + + /* Reset the length to zero. */ + *length = 0; + + do + { + rxDesc = ethernetif_get_rx_desc(ethernetif, index); + rxControl = ENET_GetRxDescriptor(rxDesc); + + if ((rxControl & ENET_RXDESCRIP_WR_OWN_MASK) + || (ethernetif->rxPbufs[index].ownedByLwip)) + { + /* + * Buffer descriptor is owned by DMA or lwIP. + * We haven't received any complete frame yet. + */ + return kStatus_ENET_RxFrameEmpty; + } + + /* Application owns the buffer descriptor. */ + if (rxControl & ENET_RXDESCRIP_WR_LD_MASK) + { + /* It's last descriptor of a frame, get its status or length. */ + if (rxControl & ENET_RXDESCRIP_WR_ERRSUM_MASK) + { + return kStatus_ENET_RxFrameError; + } + else + { + *length = rxControl & ENET_RXDESCRIP_WR_PACKETLEN_MASK; + return kStatus_Success; + } + } + + index = (index + 1U) % ENET_RXBD_NUM; + } while (index != ethernetif->rxIdx); + + /* + * All descriptors have data but the end of the frame not detected. + */ + return kStatus_ENET_RxFrameError; +} + +/** + * Drops (releases) receive descriptors until the last one of a frame is reached + * or drops entire descriptor ring when all descriptors have data but end + * of the frame not detected among them. + * Function can be called only after ethernetif_get_rx_frame_size() indicates + * that there actually is a frame error or a received frame. + */ +static void ethernetif_drop_frame(struct ethernetif *ethernetif) +{ +#if NO_SYS + bool intEnable = false; +#else + bool intEnable = true; +#endif /* NO_SYS */ + + enet_rx_bd_struct_t *rxDesc; + uint8_t index = ethernetif->rxIdx; + uint32_t rxControl; + + do + { + rxDesc = ethernetif_get_rx_desc(ethernetif, ethernetif->rxIdx); + ethernetif->rxIdx = (ethernetif->rxIdx + 1U) % ENET_RXBD_NUM; + rxControl = ENET_GetRxDescriptor(rxDesc); + + /* Update the receive buffer descriptor. */ + ENET_UpdateRxDescriptor(rxDesc, NULL, NULL, intEnable, false); + + /* Find the last buffer descriptor for the frame. */ + if (rxControl & ENET_RXDESCRIP_WR_LD_MASK) + { + break; + } + } while (ethernetif->rxIdx != index); + + ENET_UpdateRxDescriptorTail(ethernetif->base, 0U, + (uint32_t)ethernetif_get_rx_desc(ethernetif, ENET_RXBD_NUM)); +} + +/** + * Reads a received frame - wraps its descriptor buffer(s) into a pbuf + * or a pbuf chain, flag descriptors as owned by lwIP and returns the pbuf. + * The descriptors are returned to DMA only after the returned pbuf is released. + * Function can be called only after ethernetif_get_rx_frame_size() indicates + * that there actually is a received frame. + */ +static struct pbuf *ethernetif_read_frame(struct ethernetif *ethernetif, + uint32_t length) +{ + rx_pbuf_wrapper_t *wrapper; + enet_rx_bd_struct_t *rxDesc; + uint32_t rxControl; + uint32_t len = 0; + struct pbuf *p = NULL; + struct pbuf *q = NULL; + + do + { + wrapper = ðernetif->rxPbufs[ethernetif->rxIdx]; + wrapper->ownedByLwip = true; + ethernetif->rxIdx = (ethernetif->rxIdx + 1U) % ENET_RXBD_NUM; + + rxDesc = wrapper->rxDesc; + rxControl = ENET_GetRxDescriptor(rxDesc); + + len = (rxControl & ENET_RXDESCRIP_WR_PACKETLEN_MASK); + + /* Wrap the receive buffer in pbuf. */ + if (p == NULL) + { + p = pbuf_alloced_custom(PBUF_RAW, len, PBUF_REF, &wrapper->p, + (void *)rxDesc->buff1Addr, len); + LWIP_ASSERT("pbuf_alloced_custom() failed", p); + +#if ETH_PAD_SIZE + /* Add the padding header, force because it is a REF type buffer. */ + pbuf_header_force(p, ETH_PAD_SIZE); +#endif + } + else + { + q = pbuf_alloced_custom(PBUF_RAW, len, PBUF_REF, &wrapper->p, + (void *)rxDesc->buff1Addr, len); + LWIP_ASSERT("pbuf_alloced_custom() failed", q); + + pbuf_cat(p, q); + } + } while (((rxControl & ENET_RXDESCRIP_WR_LD_MASK) == 0U) + && (p->tot_len < length)); + + MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len); + if (((u8_t *)p->payload)[0] & 1) + { + /* broadcast or multicast packet */ + MIB2_STATS_NETIF_INC(netif, ifinnucastpkts); + } + else + { + /* unicast packet */ + MIB2_STATS_NETIF_INC(netif, ifinucastpkts); + } + + LINK_STATS_INC(link.recv); + + return p; +} + +/** + * Attempts to read a frame from ENET and returns it wrapped in a pbuf + * or returns NULL when no frame is received. Discards invalid frames. + */ +struct pbuf *ethernetif_linkinput(struct netif *netif) +{ + struct ethernetif *ethernetif = netif->state; + struct pbuf *p = NULL; + uint32_t len; + status_t status; + + /* Obtain the size of the packet and put it into the "len" variable. */ + status = ethernetif_get_rx_frame_size(ethernetif, &len); + + if (status == kStatus_Success) + { + p = ethernetif_read_frame(ethernetif, len); + + if (p == NULL) + { + /* Could not initialise wrapper pbuf(s) - drop the frame. */ + ethernetif_drop_frame(ethernetif); + + LWIP_DEBUGF(NETIF_DEBUG, + ("ethernetif_linkinput: Fail to allocate new memory space\n")); + + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(netif, ifindiscards); + } + } + else if (status == kStatus_ENET_RxFrameError) + { + /* Update the received buffer when error happened. */ + ethernetif_drop_frame(ethernetif); + + LWIP_DEBUGF(NETIF_DEBUG, ("ethernetif_linkinput: RxFrameError\n")); + + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(netif, ifindiscards); + } + + return p; +} + +/** + * Returns the number of TX descriptors which could be used by lwIP/application + * to put new TX data into. + * + * The max number of free descriptors is (ENET_TXBD_NUM - 1), that is when + * ethernetif->txReleaseIdx == ethernetif->txIdx. Having the capacity decreased + * by one allows to avoid locking: txReleaseIdx is advanced only from ISR + * and txIdx from tcpip_thread/main loop. Should we use full capacity and have + * some variable to indicate between the "all buffers are free" vs. "all buffers + * are used" situation, it would be manipulated from two contexts hence locking + * would be needed. + */ +static inline int ethernetif_avail_tx_descs(struct ethernetif *ethernetif) +{ + return (ethernetif->txReleaseIdx + ENET_TXBD_NUM - 1 - ethernetif->txIdx) + % ENET_TXBD_NUM; +} + +/** + * Attempts to output a frame from ENET. The function avoids copying of + * p's payload when possible. In such situation it increases p's reference count + * and decreases it (and possibly releases p) after the payload is sent. + */ +err_t ethernetif_linkoutput(struct netif *netif, struct pbuf *p) +{ + struct ethernetif *ethernetif = netif->state; + struct pbuf *q; + struct pbuf *pbuf_to_free = NULL; + struct pbuf *p_copy; + uint16_t clen; + bool copy = false; + const mem_range_t *non_dma_memory; + uint8_t *dst; + uint32_t cnt = 0; + uint8_t first_idx; + uint32_t tail_address; + + LWIP_ASSERT("Output packet buffer empty", p); + + if ((p->tot_len - ETH_PAD_SIZE) > ENET_FRAME_MAX_FRAMELEN) + { + return ERR_BUF; + } + + clen = pbuf_clen(p); + + /* Check if relocation is needed */ + + if (clen > (ENET_TXBD_NUM - 1)) + { + /* Pbuf chain is too long to be prepared for DMA at once. */ + copy = true; + } + + for (q = p; (q != NULL) && !copy; q = q->next) + { + /* + * Check if payload is aligned is not desired: lwIP creates RAM pbufs + * in a way that the data coming after the headers are aligned, but not + * the beginning of the ethernet header. LPC ENET DMA will read from + * the aligned address, which is ok, because there is additional space + * before the headers to make up for alignment - so DMA will not read + * from invalid address or unrelated data. + */ + + /* Check payload address is usable by ENET DMA */ + for (non_dma_memory = ethernetif->non_dma_memory; + (non_dma_memory->start != 0U) + || (non_dma_memory->end != 0U); non_dma_memory++) + { + if ((q->payload >= (void *) non_dma_memory->start) + && (q->payload < (void *) non_dma_memory->end)) + { + copy = true; + break; + } + } + } + + if (copy) + { + /* Pbuf needs to be copied. */ + + p_copy = pbuf_alloc(PBUF_RAW, (uint16_t) p->tot_len, PBUF_POOL); + if (p_copy == NULL) + { + return ERR_MEM; + } + + dst = (uint8_t *) p_copy->payload; + for (q = p; q != NULL; q = q->next) + { + LWIP_ASSERT("Copied bytes would exceed p->tot_len", + (q->len + dst - (uint8_t *) p_copy->payload) <= p->tot_len); + memcpy(dst, (uint8_t *)q->payload, q->len); + dst += q->len; + } + LWIP_ASSERT("Copied bytes != p->tot_len", + (dst - (uint8_t *) p_copy->payload) == p->tot_len); + p_copy->len = p_copy->tot_len = p->tot_len; + + p = p_copy; + } + else + { + /* + * Increase reference count so p is released only after it is sent. + * For copied pbuf, ref is already 1 after pbuf_alloc(). + */ + pbuf_ref(p); + } + + /* + * Wait until the sufficient number of descriptors are available, + * as we have to start the transfer of the first buffer only + * after all buffers in chain are prepared. + */ + while (ethernetif_avail_tx_descs(ethernetif) < clen) + { +#if !NO_SYS + xEventGroupWaitBits(ethernetif->enetTransmitAccessEvent, + ethernetif->txFlag, pdTRUE, (BaseType_t) false, + portMAX_DELAY); +#endif /* !NO_SYS */ + cnt++; + if (cnt >= ENET_TIMEOUT) + { + return ERR_TIMEOUT; + } + } + +#if ETH_PAD_SIZE + /* Drop the padding. */ + pbuf_header(p, -ETH_PAD_SIZE); +#endif + + /* Initiate transfer. */ + + first_idx = ethernetif->txIdx; + + for (q = p; q != NULL; q = q->next) + { + enet_desc_flag flag = kENET_MiddleFlag; + pbuf_to_free = NULL; + + if (q == p) + { + flag |= kENET_FirstFlagOnly; + } + + if (q->next == NULL) + { + flag |= kENET_LastFlagOnly; + + /* On last TX interrupt, free pbuf chain. */ + pbuf_to_free = p; + } + + ethernetif_send_buffer(ethernetif, q->payload, q->len, pbuf_to_free, + flag); + } + + /* All pbufs from chain are prepared, allow DMA to access the first one. */ + ethernetif_get_tx_desc(ethernetif, first_idx)->controlStat |= + ENET_TXDESCRIP_RD_OWN_MASK; + + /* Update the transmit tail address. */ + if (ethernetif->txIdx == 0U) + { + tail_address = (uint32_t)ethernetif_get_tx_desc(ethernetif, + ENET_TXBD_NUM); + } + else + { + tail_address = (uint32_t)ethernetif_get_tx_desc(ethernetif, + ethernetif->txIdx); + } + ENET_UpdateTxDescriptorTail(ethernetif->base, 0, tail_address); + + MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len); + if (((uint8_t *)p->payload)[0] & 1) + { + /* broadcast or multicast packet */ + MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts); + } + else + { + /* unicast packet */ + MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); + } + LINK_STATS_INC(link.xmit); + + return ERR_OK; +} + +/** + * Should be called at the beginning of the program to set up the + * first network interface. It calls the function ethernetif_init() to do the + * actual setup of the hardware. + * + * This function should be passed as a parameter to netif_add(). + * + * @param netif the lwip network interface structure for this ethernetif + * @return ERR_OK if the loopif is initialized + * ERR_MEM if private data couldn't be allocated + * any other err_t on error + */ +err_t ethernetif0_init(struct netif *netif) +{ + static struct ethernetif ethernetif_0; + AT_NONCACHEABLE_SECTION_ALIGN(static enet_rx_bd_struct_t rxBuffDescrip_0[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + AT_NONCACHEABLE_SECTION_ALIGN(static enet_tx_bd_struct_t txBuffDescrip_0[ENET_TXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + SDK_ALIGN(static rx_buffer_t rxDataBuff_0[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + + ethernetif_0.RxBuffDescrip = &(rxBuffDescrip_0[0]); + ethernetif_0.TxBuffDescrip = &(txBuffDescrip_0[0]); + ethernetif_0.RxDataBuff = &(rxDataBuff_0[0]); + + return ethernetif_init(netif, ðernetif_0, 0U, (ethernetif_config_t *)netif->state); +} + +#if defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 1) +/** + * Should be called at the beginning of the program to set up the + * second network interface. It calls the function ethernetif_init() to do the + * actual setup of the hardware. + * + * This function should be passed as a parameter to netif_add(). + * + * @param netif the lwip network interface structure for this ethernetif + * @return ERR_OK if the loopif is initialized + * ERR_MEM if private data couldn't be allocated + * any other err_t on error + */ +err_t ethernetif1_init(struct netif *netif) +{ + static struct ethernetif ethernetif_1; + AT_NONCACHEABLE_SECTION_ALIGN(static enet_rx_bd_struct_t rxBuffDescrip_1[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + AT_NONCACHEABLE_SECTION_ALIGN(static enet_tx_bd_struct_t txBuffDescrip_1[ENET_TXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + SDK_ALIGN(static rx_buffer_t rxDataBuff_1[ENET_RXBD_NUM], FSL_ENET_BUFF_ALIGNMENT); + + ethernetif_1.RxBuffDescrip = &(rxBuffDescrip_1[0]); + ethernetif_1.TxBuffDescrip = &(txBuffDescrip_1[0]); + ethernetif_1.RxDataBuff = &(rxDataBuff_1[0]); + + return ethernetif_init(netif, ðernetif_1, 1U, (ethernetif_config_t *)netif->state); +} +#endif /* FSL_FEATURE_SOC_*_ENET_COUNT */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/fsl_enet.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/fsl_enet.c new file mode 100755 index 00000000..4da401fa --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/fsl_enet.c @@ -0,0 +1,3493 @@ +/* + * Copyright (c) 2015 - 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_enet.c + * @brief ethernet drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#include "fsl_enet.h" +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL +#include "fsl_cache.h" +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + +#include "lwipopts.h" +#include + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/* Component ID definition, used by tools. */ +#ifndef FSL_COMPONENT_ID +#define FSL_COMPONENT_ID "platform.drivers.enet" +#endif + +/*! @brief IPv4 PTP message IP version offset. */ +#define ENET_PTP1588_IPVERSION_OFFSET 0x0EU +/*! @brief IPv4 PTP message UDP protocol offset. */ +#define ENET_PTP1588_IPV4_UDP_PROTOCOL_OFFSET 0x17U +/*! @brief IPv4 PTP message UDP port offset. */ +#define ENET_PTP1588_IPV4_UDP_PORT_OFFSET 0x24U +/*! @brief IPv4 PTP message UDP message type offset. */ +#define ENET_PTP1588_IPV4_UDP_MSGTYPE_OFFSET 0x2AU +/*! @brief IPv4 PTP message UDP version offset. */ +#define ENET_PTP1588_IPV4_UDP_VERSION_OFFSET 0x2BU +/*! @brief IPv4 PTP message UDP clock id offset. */ +#define ENET_PTP1588_IPV4_UDP_CLKID_OFFSET 0x3EU +/*! @brief IPv4 PTP message UDP sequence id offset. */ +#define ENET_PTP1588_IPV4_UDP_SEQUENCEID_OFFSET 0x48U +/*! @brief IPv4 PTP message UDP control offset. */ +#define ENET_PTP1588_IPV4_UDP_CTL_OFFSET 0x4AU +/*! @brief IPv6 PTP message UDP protocol offset. */ +#define ENET_PTP1588_IPV6_UDP_PROTOCOL_OFFSET 0x14U +/*! @brief IPv6 PTP message UDP port offset. */ +#define ENET_PTP1588_IPV6_UDP_PORT_OFFSET 0x38U +/*! @brief IPv6 PTP message UDP message type offset. */ +#define ENET_PTP1588_IPV6_UDP_MSGTYPE_OFFSET 0x3EU +/*! @brief IPv6 PTP message UDP version offset. */ +#define ENET_PTP1588_IPV6_UDP_VERSION_OFFSET 0x3FU +/*! @brief IPv6 PTP message UDP clock id offset. */ +#define ENET_PTP1588_IPV6_UDP_CLKID_OFFSET 0x52U +/*! @brief IPv6 PTP message UDP sequence id offset. */ +#define ENET_PTP1588_IPV6_UDP_SEQUENCEID_OFFSET 0x5CU +/*! @brief IPv6 PTP message UDP control offset. */ +#define ENET_PTP1588_IPV6_UDP_CTL_OFFSET 0x5EU +/*! @brief PTPv2 message Ethernet packet type offset. */ +#define ENET_PTP1588_ETHL2_PACKETTYPE_OFFSET 0x0CU +/*! @brief PTPv2 message Ethernet message type offset. */ +#define ENET_PTP1588_ETHL2_MSGTYPE_OFFSET 0x0EU +/*! @brief PTPv2 message Ethernet version type offset. */ +#define ENET_PTP1588_ETHL2_VERSION_OFFSET 0X0FU +/*! @brief PTPv2 message Ethernet clock id offset. */ +#define ENET_PTP1588_ETHL2_CLOCKID_OFFSET 0x22 +/*! @brief PTPv2 message Ethernet sequence id offset. */ +#define ENET_PTP1588_ETHL2_SEQUENCEID_OFFSET 0x2c +/*! @brief Packet type Ethernet IEEE802.3 for PTPv2. */ +#define ENET_ETHERNETL2 0x88F7U +/*! @brief Packet type IPv4. */ +#define ENET_IPV4 0x0800U +/*! @brief Packet type IPv6. */ +#define ENET_IPV6 0x86ddU +/*! @brief Packet type VLAN. */ +#define ENET_8021QVLAN 0x8100U +/*! @brief UDP protocol type. */ +#define ENET_UDPVERSION 0x0011U +/*! @brief Packet IP version IPv4. */ +#define ENET_IPV4VERSION 0x0004U +/*! @brief Packet IP version IPv6. */ +#define ENET_IPV6VERSION 0x0006U +/*! @brief Ethernet mac address length. */ +#define ENET_FRAME_MACLEN 6U +/*! @brief Ethernet VLAN header length. */ +#define ENET_FRAME_VLAN_TAGLEN 4U +/*! @brief MDC frequency. */ +#define ENET_MDC_FREQUENCY 2500000U +/*! @brief NanoSecond in one second. */ +#define ENET_NANOSECOND_ONE_SECOND 1000000000U +/*! @brief Define a common clock cycle delays used for time stamp capture. */ +#ifndef ENET_1588TIME_DELAY_COUNT +#define ENET_1588TIME_DELAY_COUNT 10U +#endif + +/*! @brief Defines the macro for converting constants from host byte order to network byte order. */ +#define ENET_HTONS(n) __REV16(n) +#define ENET_HTONL(n) __REV(n) +#define ENET_NTOHS(n) __REV16(n) +#define ENET_NTOHL(n) __REV(n) + +/*! @brief Define the ENET ring/class bumber . */ +enum _enet_ring_number +{ + kENET_Ring0 = 0U, /*!< ENET ring/class 0. */ +#if FSL_FEATURE_ENET_QUEUE > 1 + kENET_Ring1 = 1U, /*!< ENET ring/class 1. */ + kENET_Ring2 = 2U /*!< ENET ring/class 2. */ +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ +}; + +/*! @brief Define interrupt IRQ handler. */ +#if FSL_FEATURE_ENET_QUEUE > 1 +typedef void (*enet_isr_ring_t)(ENET_Type *base, enet_handle_t *handle, uint32_t ringId); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ +typedef void (*enet_isr_t)(ENET_Type *base, enet_handle_t *handle); + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/*! + * @brief Get the ENET instance from peripheral base address. + * + * @param base ENET peripheral base address. + * @return ENET instance. + */ +uint32_t ENET_GetInstance(ENET_Type *base); +/*! + * @brief Set ENET MAC controller with the configuration. + * + * @param base ENET peripheral base address. + * @param handle The ENET handle pointer. + * @param config ENET Mac configuration. + * @param bufferConfig ENET buffer configuration. + * @param macAddr ENET six-byte mac address. + * @param srcClock_Hz ENET module clock source, normally it's system clock. + */ +static void ENET_SetMacController(ENET_Type *base, + enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig, + uint8_t *macAddr, + uint32_t srcClock_Hz); +/*! + * @brief Set ENET handler. + * + * @param base ENET peripheral base address. + * @param handle The ENET handle pointer. + * @param config ENET configuration stucture pointer. + * @param bufferConfig ENET buffer configuration. + */ +static void ENET_SetHandler(ENET_Type *base, + enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig); +/*! + * @brief Set ENET MAC transmit buffer descriptors. + * + * @param handle The ENET handle pointer. + * @param config The ENET configuration structure. + * @param bufferConfig The ENET buffer configuration. + */ +static void ENET_SetTxBufferDescriptors(enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig); + +/*! + * @brief Set ENET MAC receive buffer descriptors. + * + * @param handle The ENET handle pointer. + * @param config The ENET configuration structure. + * @param bufferConfig The ENET buffer configuration. + */ +static void ENET_SetRxBufferDescriptors(enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig); + +/*! + * @brief Updates the ENET read buffer descriptors. + * + * @param base ENET peripheral base address. + * @param handle The ENET handle pointer. + * @param ringId The descriptor ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1. + * 0 ----- for single ring kinetis platform. + * 0 ~ 2 for mulit-ring supported IMX8qm. + */ +static void ENET_UpdateReadBuffers(ENET_Type *base, enet_handle_t *handle, uint32_t ringId); + +/*! + * @brief Activates ENET send for multiple tx rings. + * + * @param base ENET peripheral base address. + * @param ringId The descriptor ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1. + * 0 ----- for single ring kinetis platform. + * 0 ~ 2 for mulit-ring supported IMX8qm. + * + * @note This must be called after the MAC configuration and + * state are ready. It must be called after the ENET_Init() and + * this should be called when the ENET receive required. + */ +static void ENET_ActiveSend(ENET_Type *base, uint32_t ringId); +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! + * @brief Parses the ENET frame for time-stamp process of PTP 1588 frame. + * + * @param data The ENET read data for frame parse. + * @param ptpTsData The ENET PTP message and time-stamp data pointer. + * @param isFastEnabled The fast parse flag. + * - true , Fast processing, only check if this is a PTP message. + * - false, Store the PTP message data after check the PTP message. + */ +static bool ENET_Ptp1588ParseFrame(const uint8_t *data, enet_ptp_time_data_t *ptpTsData, bool isFastEnabled); + +/*! + * @brief Updates the new PTP 1588 time-stamp to the time-stamp buffer ring. + * + * @param ptpTsDataRing The PTP message and time-stamp data ring pointer. + * @param ptpTimeData The new PTP 1588 time-stamp data pointer. + */ +static status_t ENET_Ptp1588UpdateTimeRing(enet_ptp_time_data_ring_t *ptpTsDataRing, enet_ptp_time_data_t *ptpTimeData); + +/*! + * @brief Search up the right PTP 1588 time-stamp from the time-stamp buffer ring. + * + * @param ptpTsDataRing The PTP message and time-stamp data ring pointer. + * @param ptpTimeData The find out right PTP 1588 time-stamp data pointer with the specific PTP message. + */ +static status_t ENET_Ptp1588SearchTimeRing(enet_ptp_time_data_ring_t *ptpTsDataRing, enet_ptp_time_data_t *ptpTimedata); + +/*! + * @brief Store the transmit time-stamp for event PTP frame in the time-stamp buffer ring. + * + * @param base ENET peripheral base address. + * @param handle The ENET handle pointer. + * @param ringId The descriptor ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1. + * 0 ----- for single ring kinetis platform. + * 0 ~ 2 for mulit-ring supported IMX8qm. + */ +static status_t ENET_StoreTxFrameTime(ENET_Type *base, enet_handle_t *handle, uint32_t ringId); + +/*! + * @brief Store the receive time-stamp for event PTP frame in the time-stamp buffer ring. + * + * @param base ENET peripheral base address. + * @param handle The ENET handle pointer. + * @param ptpTimeData The PTP 1588 time-stamp data pointer. + */ +static status_t ENET_StoreRxFrameTime(ENET_Type *base, enet_handle_t *handle, enet_ptp_time_data_t *ptpTimeData); + +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_AVB +/*! + * @brief Gets the ring index for transmission. + * + * @param base ENET peripheral base address. + * @param data The ENET transmit data. + * @param handle The ENET handle pointer. + * + * @note This must be called after the MAC configuration and + * state are ready. It must be called after the ENET_Init() and + * this should be called when the ENET receive required. + */ +static uint8_t ENET_GetTxRingId(ENET_Type *base, uint8_t *data, enet_handle_t *handle); +#endif /* FSL_FEATURE_ENET_HAS_AVB */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +/*! @brief Pointers to enet handles for each instance. */ +static enet_handle_t *s_ENETHandle[FSL_FEATURE_SOC_ENET_COUNT] = {NULL}; + +/*! @brief Pointers to enet clocks for each instance. */ +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) +const clock_ip_name_t s_enetClock[] = ENET_CLOCKS; +#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ + +/*! @brief Pointers to enet transmit IRQ number for each instance. */ +static const IRQn_Type s_enetTxIrqId[] = ENET_Transmit_IRQS; +/*! @brief Pointers to enet receive IRQ number for each instance. */ +static const IRQn_Type s_enetRxIrqId[] = ENET_Receive_IRQS; +#if defined(ENET_ENHANCEDBUFFERDESCRIPTOR_MODE) && ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! @brief Pointers to enet timestamp IRQ number for each instance. */ +static const IRQn_Type s_enetTsIrqId[] = ENET_1588_Timer_IRQS; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +/*! @brief Pointers to enet error IRQ number for each instance. */ +static const IRQn_Type s_enetErrIrqId[] = ENET_Error_IRQS; + +/*! @brief Pointers to enet bases for each instance. */ +static ENET_Type *const s_enetBases[] = ENET_BASE_PTRS; + +/* ENET ISR for transactional APIs. */ +#if FSL_FEATURE_ENET_QUEUE > 1 +static enet_isr_ring_t s_enetTxIsr; +static enet_isr_ring_t s_enetRxIsr; +#else +static enet_isr_t s_enetTxIsr; +static enet_isr_t s_enetRxIsr; +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ +static enet_isr_t s_enetErrIsr; +static enet_isr_t s_enetTsIsr; +/******************************************************************************* + * Code + ******************************************************************************/ + +uint32_t ENET_GetInstance(ENET_Type *base) +{ + uint32_t instance; + + /* Find the instance index from base address mappings. */ + for (instance = 0; instance < ARRAY_SIZE(s_enetBases); instance++) + { + if (s_enetBases[instance] == base) + { + break; + } + } + + assert(instance < ARRAY_SIZE(s_enetBases)); + + return instance; +} + +/*! + * brief Gets the ENET default configuration structure. + * + * The purpose of this API is to get the default ENET MAC controller + * configure structure for ENET_Init(). User may use the initialized + * structure unchanged in ENET_Init(), or modify some fields of the + * structure before calling ENET_Init(). + * Example: + code + enet_config_t config; + ENET_GetDefaultConfig(&config); + endcode + * param config The ENET mac controller configuration structure pointer. + */ +void ENET_GetDefaultConfig(enet_config_t *config) +{ + /* Checks input parameter. */ + assert(config); + + /* Initializes the MAC configure structure to zero. */ + memset(config, 0, sizeof(enet_config_t)); + +/* Sets MII mode, full duplex, 100Mbps for MAC and PHY data interface. */ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + config->miiMode = kENET_RgmiiMode; +#else + config->miiMode = kENET_RmiiMode; +#endif + config->miiSpeed = kENET_MiiSpeed100M; + config->miiDuplex = kENET_MiiFullDuplex; + + config->ringNum = 1; + + /* Sets the maximum receive frame length. */ + config->rxMaxFrameLen = ENET_FRAME_MAX_FRAMELEN; +} + +/*! + * brief Initializes the ENET module. + * + * This function ungates the module clock and initializes it with the ENET configuration. + * + * param base ENET peripheral base address. + * param handle ENET handler pointer. + * param config ENET mac configuration structure pointer. + * The "enet_config_t" type mac configuration return from ENET_GetDefaultConfig + * can be used directly. It is also possible to verify the Mac configuration using other methods. + * param bufferConfig ENET buffer configuration structure pointer. + * The buffer configuration should be prepared for ENET Initialization. + * It is the start address of "ringNum" enet_buffer_config structures. + * To support added multi-ring features in some soc and compatible with the previous + * enet driver version. For single ring supported, this bufferConfig is a buffer + * configure structure pointer, for multi-ring supported and used case, this bufferConfig + * pointer should be a buffer configure structure array pointer. + * param macAddr ENET mac address of Ethernet device. This MAC address should be + * provided. + * param srcClock_Hz The internal module clock source for MII clock. + * + * note ENET has two buffer descriptors legacy buffer descriptors and + * enhanced IEEE 1588 buffer descriptors. The legacy descriptor is used by default. To + * use the IEEE 1588 feature, use the enhanced IEEE 1588 buffer descriptor + * by defining "ENET_ENHANCEDBUFFERDESCRIPTOR_MODE" and calling ENET_Ptp1588Configure() + * to configure the 1588 feature and related buffers after calling ENET_Init(). + */ +void ENET_Init(ENET_Type *base, + enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig, + uint8_t *macAddr, + uint32_t srcClock_Hz) +{ + /* Checks input parameters. */ + assert(handle); + assert(config); + assert(bufferConfig); + assert(macAddr); + assert(config->ringNum <= FSL_FEATURE_ENET_QUEUE); + +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) + uint32_t instance = ENET_GetInstance(base); + + /* Ungate ENET clock. */ + CLOCK_EnableClock(s_enetClock[instance]); +#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ + /* Reset ENET module. */ + ENET_Reset(base); + + /* Initializes the ENET transmit buffer descriptors. */ + ENET_SetTxBufferDescriptors(handle, config, bufferConfig); + + /* Initializes the ENET receive buffer descriptors. */ + ENET_SetRxBufferDescriptors(handle, config, bufferConfig); + + /* Initializes the ENET MAC controller with basic function. */ + ENET_SetMacController(base, handle, config, bufferConfig, macAddr, srcClock_Hz); + + /* Set all buffers or data in handler for data transmit/receive process. */ + ENET_SetHandler(base, handle, config, bufferConfig); +} + +/*! + * brief Deinitializes the ENET module. + + * This function gates the module clock, clears ENET interrupts, and disables the ENET module. + * + * param base ENET peripheral base address. + */ +void ENET_Deinit(ENET_Type *base) +{ + /* Disable interrupt. */ + base->EIMR = 0; + + /* Disable ENET. */ + base->ECR &= ~ENET_ECR_ETHEREN_MASK; + +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) + /* Disables the clock source. */ + CLOCK_DisableClock(s_enetClock[ENET_GetInstance(base)]); +#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ +} + +/*! + * brief Sets the callback function. + * This API is provided for the application callback required case when ENET + * interrupt is enabled. This API should be called after calling ENET_Init. + * + * param handle ENET handler pointer. Should be provided by application. + * param callback The ENET callback function. + * param userData The callback function parameter. + */ +void ENET_SetCallback(enet_handle_t *handle, enet_callback_t callback, void *userData) +{ + assert(handle); + + /* Set callback and userData. */ + handle->callback = callback; + handle->userData = userData; +} + +static void ENET_SetHandler(ENET_Type *base, + enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig) +{ + uint8_t count; + uint32_t instance = ENET_GetInstance(base); + const enet_buffer_config_t *buffCfg = bufferConfig; + + /* Store transfer parameters in handle pointer. */ + memset(handle, 0, sizeof(enet_handle_t)); + + handle->ringNum = (config->ringNum > FSL_FEATURE_ENET_QUEUE) ? FSL_FEATURE_ENET_QUEUE : config->ringNum; + for (count = 0; count < handle->ringNum; count++) + { + assert(buffCfg->rxBuffSizeAlign * buffCfg->rxBdNumber > config->rxMaxFrameLen); + + handle->rxBdBase[count] = buffCfg->rxBdStartAddrAlign; + handle->rxBdCurrent[count] = buffCfg->rxBdStartAddrAlign; + handle->rxBuffSizeAlign[count] = buffCfg->rxBuffSizeAlign; + handle->txBdBase[count] = buffCfg->txBdStartAddrAlign; + handle->txBdCurrent[count] = buffCfg->txBdStartAddrAlign; + handle->txBuffSizeAlign[count] = buffCfg->txBuffSizeAlign; + + buffCfg++; + } + + /* Save the handle pointer in the global variables. */ + s_ENETHandle[instance] = handle; + + /* Set the IRQ handler when the interrupt is enabled. */ + if (config->interrupt & ENET_TX_INTERRUPT) + { + s_enetTxIsr = ENET_TransmitIRQHandler; + EnableIRQ(s_enetTxIrqId[instance]); + } + if (config->interrupt & ENET_RX_INTERRUPT) + { + s_enetRxIsr = ENET_ReceiveIRQHandler; + EnableIRQ(s_enetRxIrqId[instance]); + } + if (config->interrupt & ENET_ERR_INTERRUPT) + { + s_enetErrIsr = ENET_ErrorIRQHandler; + EnableIRQ(s_enetErrIrqId[instance]); + } +} + +static void ENET_SetMacController(ENET_Type *base, + enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig, + uint8_t *macAddr, + uint32_t srcClock_Hz) +{ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + /* Check the MII mode/speed/duplex setting. */ + if (config->miiSpeed == kENET_MiiSpeed1000M) + { + /* Only RGMII mode has the 1000M bit/s. The 1000M only support full duplex. */ + assert(config->miiMode == kENET_RgmiiMode); + assert(config->miiDuplex == kENET_MiiFullDuplex); + } +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + + uint32_t rcr = 0; + uint32_t tcr = 0; + uint32_t ecr = base->ECR; + uint32_t macSpecialConfig = config->macSpecialConfig; + uint32_t maxFrameLen = config->rxMaxFrameLen; + + /* Maximum frame length check. */ + if ((macSpecialConfig & kENET_ControlVLANTagEnable) && (maxFrameLen <= ENET_FRAME_MAX_FRAMELEN)) + { + maxFrameLen = (ENET_FRAME_MAX_FRAMELEN + ENET_FRAME_VLAN_TAGLEN); +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + if (macSpecialConfig & kENET_ControlSVLANEnable) + { + /* Double vlan tag (SVLAN) supported. */ + maxFrameLen += ENET_FRAME_VLAN_TAGLEN; + } + ecr |= ((macSpecialConfig & kENET_ControlSVLANEnable) ? (ENET_ECR_SVLANEN_MASK | ENET_ECR_SVLANDBL_MASK) : 0) | + ((macSpecialConfig & kENET_ControlVLANUseSecondTag) ? ENET_ECR_VLANUSE2ND_MASK : 0); +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + } + + /* Configures MAC receive controller with user configure structure. */ + rcr = ((macSpecialConfig & kENET_ControlRxPayloadCheckEnable) ? ENET_RCR_NLC_MASK : 0) | + ((macSpecialConfig & kENET_ControlFlowControlEnable) ? ENET_RCR_CFEN_MASK : 0) | + ((macSpecialConfig & kENET_ControlFlowControlEnable) ? ENET_RCR_FCE_MASK : 0) | + ((macSpecialConfig & kENET_ControlRxPadRemoveEnable) ? ENET_RCR_PADEN_MASK : 0) | + ((macSpecialConfig & kENET_ControlRxBroadCastRejectEnable) ? ENET_RCR_BC_REJ_MASK : 0) | + ((macSpecialConfig & kENET_ControlPromiscuousEnable) ? ENET_RCR_PROM_MASK : 0) | + ENET_RCR_MAX_FL(maxFrameLen) | ENET_RCR_CRCFWD_MASK; + +/* Set the RGMII or RMII, MII mode and control register. */ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + if (config->miiMode == kENET_RgmiiMode) + { + rcr |= ENET_RCR_RGMII_EN_MASK; + rcr &= ~ENET_RCR_MII_MODE_MASK; + } + else + { + rcr &= ~ENET_RCR_RGMII_EN_MASK; +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + rcr |= ENET_RCR_MII_MODE_MASK; + if (config->miiMode == kENET_RmiiMode) + { + rcr |= ENET_RCR_RMII_MODE_MASK; + } +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + } +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + /* Speed. */ + if (config->miiSpeed == kENET_MiiSpeed10M) + { + rcr |= ENET_RCR_RMII_10T_MASK; + } +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + if (config->miiSpeed == kENET_MiiSpeed1000M) + { + ecr |= ENET_ECR_SPEED_MASK; + } +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + + /* Receive setting for half duplex. */ + if (config->miiDuplex == kENET_MiiHalfDuplex) + { + rcr |= ENET_RCR_DRT_MASK; + } + /* Sets internal loop only for MII mode. */ + if ((config->macSpecialConfig & kENET_ControlMIILoopEnable) && (config->miiMode != kENET_RmiiMode)) + { + rcr |= ENET_RCR_LOOP_MASK; + rcr &= ~ENET_RCR_DRT_MASK; + } + base->RCR = rcr; + + /* Configures MAC transmit controller: duplex mode, mac address insertion. */ + tcr = base->TCR & ~(ENET_TCR_FDEN_MASK | ENET_TCR_ADDINS_MASK); + tcr |= (config->miiDuplex ? ENET_TCR_FDEN_MASK : 0) | + ((macSpecialConfig & kENET_ControlMacAddrInsert) ? ENET_TCR_ADDINS_MASK : 0); + base->TCR = tcr; + + /* Configures receive and transmit accelerator. */ + base->TACC = config->txAccelerConfig; + base->RACC = config->rxAccelerConfig; + + /* Sets the pause duration and FIFO threshold for the flow control enabled case. */ + if (macSpecialConfig & kENET_ControlFlowControlEnable) + { + uint32_t reemReg; + base->OPD = config->pauseDuration; + reemReg = ENET_RSEM_RX_SECTION_EMPTY(config->rxFifoEmptyThreshold); +#if defined(FSL_FEATURE_ENET_HAS_RECEIVE_STATUS_THRESHOLD) && FSL_FEATURE_ENET_HAS_RECEIVE_STATUS_THRESHOLD + reemReg |= ENET_RSEM_STAT_SECTION_EMPTY(config->rxFifoStatEmptyThreshold); +#endif /* FSL_FEATURE_ENET_HAS_RECEIVE_STATUS_THRESHOLD */ + base->RSEM = reemReg; + } + + /* FIFO threshold setting for store and forward enable/disable case. */ + if (macSpecialConfig & kENET_ControlStoreAndFwdDisable) + { + /* Transmit fifo watermark settings. */ + base->TFWR = config->txFifoWatermark & ENET_TFWR_TFWR_MASK; + /* Receive fifo full threshold settings. */ + base->RSFL = config->rxFifoFullThreshold & ENET_RSFL_RX_SECTION_FULL_MASK; + } + else + { + /* Transmit fifo watermark settings. */ + base->TFWR = ENET_TFWR_STRFWD_MASK; + base->RSFL = 0; + } + + /* Enable store and forward when accelerator is enabled */ + if (config->txAccelerConfig & (kENET_TxAccelIpCheckEnabled | kENET_TxAccelProtoCheckEnabled)) + { + base->TFWR = ENET_TFWR_STRFWD_MASK; + } + if (config->rxAccelerConfig & (kENET_RxAccelIpCheckEnabled | kENET_RxAccelProtoCheckEnabled)) + { + base->RSFL = 0; + } + +/* Initializes the ring 0. */ +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + base->TDSR = MEMORY_ConvertMemoryMapAddress((uint32_t)bufferConfig->txBdStartAddrAlign, kMEMORY_Local2DMA); + base->RDSR = MEMORY_ConvertMemoryMapAddress((uint32_t)bufferConfig->rxBdStartAddrAlign, kMEMORY_Local2DMA); +#else + base->TDSR = (uint32_t)bufferConfig->txBdStartAddrAlign; + base->RDSR = (uint32_t)bufferConfig->rxBdStartAddrAlign; +#endif + base->MRBR = bufferConfig->rxBuffSizeAlign; + +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + const enet_buffer_config_t *buffCfg = bufferConfig; + + if (config->ringNum > 1) + { + /* Initializes the ring 1. */ + buffCfg++; +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + base->TDSR1 = MEMORY_ConvertMemoryMapAddress((uint32_t)buffCfg->txBdStartAddrAlign, kMEMORY_Local2DMA); + base->RDSR1 = MEMORY_ConvertMemoryMapAddress((uint32_t)buffCfg->rxBdStartAddrAlign, kMEMORY_Local2DMA); +#else + base->TDSR1 = (uint32_t)buffCfg->txBdStartAddrAlign; + base->RDSR1 = (uint32_t)buffCfg->rxBdStartAddrAlign; +#endif + base->MRBR1 = buffCfg->rxBuffSizeAlign; + /* Enable the DMAC for ring 1 and with no rx classification set. */ + base->DMACFG[0] = ENET_DMACFG_DMA_CLASS_EN_MASK; + } + if (config->ringNum > 2) + { + /* Initializes the ring 2. */ + buffCfg++; +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + base->TDSR2 = MEMORY_ConvertMemoryMapAddress((uint32_t)buffCfg->txBdStartAddrAlign, kMEMORY_Local2DMA); + base->RDSR2 = MEMORY_ConvertMemoryMapAddress((uint32_t)buffCfg->rxBdStartAddrAlign, kMEMORY_Local2DMA); +#else + base->TDSR2 = (uint32_t)buffCfg->txBdStartAddrAlign; + base->RDSR2 = (uint32_t)buffCfg->rxBdStartAddrAlign; +#endif + base->MRBR2 = buffCfg->rxBuffSizeAlign; + /* Enable the DMAC for ring 2 and with no rx classification set. */ + base->DMACFG[1] = ENET_DMACFG_DMA_CLASS_EN_MASK; + } + + /* Default the class/ring 1 and 2 are not enabled and the receive classification is disabled + * so we set the default transmit scheme with the round-robin mode. beacuse the legacy bd mode + * only support the round-robin mode. if the avb feature is required, just call the setup avb + * feature API. */ + base->QOS |= ENET_QOS_TX_SCHEME(1); +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + + /* Configures the Mac address. */ + ENET_SetMacAddr(base, macAddr); + + /* Initialize the SMI if uninitialized. */ + if (!ENET_GetSMI(base)) + { + ENET_SetSMI(base, srcClock_Hz, !!(config->macSpecialConfig & kENET_ControlSMIPreambleDisable)); + } + +/* Enables Ethernet interrupt, enables the interrupt coalsecing if it is required. */ +#if defined(FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE) && FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE + if (config->intCoalesceCfg) + { + uint32_t intMask = (ENET_EIMR_TXB_MASK | ENET_EIMR_RXB_MASK); + +#if FSL_FEATURE_ENET_QUEUE > 1 + uint8_t queue = 0; + intMask |= ENET_EIMR_TXB2_MASK | ENET_EIMR_RXB2_MASK | ENET_EIMR_TXB1_MASK | ENET_EIMR_RXB1_MASK; +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + + /* Clear all buffer interrupts. */ + base->EIMR &= ~intMask; + +/* Set the interrupt coalescence. */ +#if FSL_FEATURE_ENET_QUEUE > 1 + for (queue = 0; queue < FSL_FEATURE_ENET_QUEUE; queue++) + { + base->TXIC[queue] = ENET_TXIC_ICFT(config->intCoalesceCfg->txCoalesceFrameCount[queue]) | + config->intCoalesceCfg->txCoalesceTimeCount[queue] | ENET_TXIC_ICCS_MASK | + ENET_TXIC_ICEN_MASK; + base->RXIC[queue] = ENET_RXIC_ICFT(config->intCoalesceCfg->rxCoalesceFrameCount[queue]) | + config->intCoalesceCfg->rxCoalesceTimeCount[queue] | ENET_RXIC_ICCS_MASK | + ENET_RXIC_ICEN_MASK; + } +#else + base->TXIC = ENET_TXIC_ICFT(config->intCoalesceCfg->txCoalesceFrameCount[0]) | + config->intCoalesceCfg->txCoalesceTimeCount[0] | ENET_TXIC_ICCS_MASK | ENET_TXIC_ICEN_MASK; + base->RXIC = ENET_RXIC_ICFT(config->intCoalesceCfg->rxCoalesceFrameCount[0]) | + config->intCoalesceCfg->rxCoalesceTimeCount[0] | ENET_RXIC_ICCS_MASK | ENET_RXIC_ICEN_MASK; +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } +#endif /* FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE */ + ENET_EnableInterrupts(base, config->interrupt); + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* Sets the 1588 enhanced feature. */ + ecr |= ENET_ECR_EN1588_MASK; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + /* Enables Ethernet module after all configuration except the buffer descriptor active. */ + ecr |= ENET_ECR_ETHEREN_MASK | ENET_ECR_DBSWP_MASK; + base->ECR = ecr; +} + +static void ENET_SetTxBufferDescriptors(enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig) +{ + assert(config); + assert(bufferConfig); + + /* Default single ring is supported. */ + uint8_t ringNum; + uint32_t count; + uint32_t txBuffSizeAlign; + uint8_t *txBuffer; + const enet_buffer_config_t *buffCfg = bufferConfig; + + /* Check the input parameters. */ + for (ringNum = 0; ringNum < config->ringNum; ringNum++) + { + if ((buffCfg->txBdStartAddrAlign > 0) && (buffCfg->txBufferAlign > 0)) + { + volatile enet_tx_bd_struct_t *curBuffDescrip = buffCfg->txBdStartAddrAlign; + txBuffSizeAlign = buffCfg->txBuffSizeAlign; +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + txBuffer = (uint8_t *)MEMORY_ConvertMemoryMapAddress((uint32_t)buffCfg->txBufferAlign, kMEMORY_Local2DMA); +#else + txBuffer = buffCfg->txBufferAlign; +#endif + for (count = 0; count < buffCfg->txBdNumber; count++) + { + /* Set data buffer address. */ + curBuffDescrip->buffer = (uint8_t *)((uint32_t)&txBuffer[count * txBuffSizeAlign]); + /* Initializes data length. */ + curBuffDescrip->length = 0; + /* Sets the crc. */ + curBuffDescrip->control = ENET_BUFFDESCRIPTOR_TX_TRANMITCRC_MASK; + /* Sets the last buffer descriptor with the wrap flag. */ + if (count == buffCfg->txBdNumber - 1) + { + curBuffDescrip->control |= ENET_BUFFDESCRIPTOR_TX_WRAP_MASK; + } + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* Enable transmit interrupt for store the transmit timestamp. */ + curBuffDescrip->controlExtend1 |= ENET_BUFFDESCRIPTOR_TX_INTERRUPT_MASK; +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + /* Set the type of the frame when the credit-based scheme is used. */ + curBuffDescrip->controlExtend1 |= ENET_BD_FTYPE(ringNum); +#endif /* FSL_FEATURE_ENET_HAS_AVB */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + /* Increase the index. */ + curBuffDescrip++; + } + } + buffCfg++; + } +} + +static void ENET_SetRxBufferDescriptors(enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig) +{ + assert(config); + assert(bufferConfig); + + /* Default single ring is supported. */ + uint8_t ringNum; + uint32_t count; + uint32_t rxBuffSizeAlign; + uint8_t *rxBuffer; + const enet_buffer_config_t *buffCfg = bufferConfig; +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + uint32_t mask = (kENET_RxFrameInterrupt | kENET_RxBufferInterrupt); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + /* Check the input parameters. */ + for (ringNum = 0; ringNum < config->ringNum; ringNum++) + { + assert(buffCfg->rxBuffSizeAlign >= ENET_RX_MIN_BUFFERSIZE); +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +#if FSL_FEATURE_ENET_QUEUE > 1 + if (ringNum == 1) + { + mask = (kENET_RxFrame1Interrupt | kENET_RxBuffer1Interrupt); + } + else if (ringNum == 2) + { + mask = (kENET_RxFrame2Interrupt | kENET_RxBuffer2Interrupt); + } +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + if ((buffCfg->rxBdStartAddrAlign > 0) && (buffCfg->rxBufferAlign > 0)) + { + volatile enet_rx_bd_struct_t *curBuffDescrip = buffCfg->rxBdStartAddrAlign; + rxBuffSizeAlign = buffCfg->rxBuffSizeAlign; +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + rxBuffer = (uint8_t *)MEMORY_ConvertMemoryMapAddress((uint32_t)buffCfg->rxBufferAlign, kMEMORY_Local2DMA); +#else + rxBuffer = buffCfg->rxBufferAlign; +#endif + +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Invalidate rx buffers before DMA transfer data into them. */ + DCACHE_InvalidateByRange((uint32_t)rxBuffer, (buffCfg->rxBdNumber * rxBuffSizeAlign)); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + + for (count = 0; count < buffCfg->rxBdNumber; count++) + { + /* Set data buffer and the length. */ + curBuffDescrip->buffer = (uint8_t *)((uint32_t)&rxBuffer[count * rxBuffSizeAlign]); + curBuffDescrip->length = 0; + + /* Initializes the buffer descriptors with empty bit. */ + curBuffDescrip->control = ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK; + /* Sets the last buffer descriptor with the wrap flag. */ + if (count == buffCfg->rxBdNumber - 1) + { + curBuffDescrip->control |= ENET_BUFFDESCRIPTOR_RX_WRAP_MASK; + } + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + if (config->interrupt & mask) + { + /* Enable receive interrupt. */ + curBuffDescrip->controlExtend1 |= ENET_BUFFDESCRIPTOR_RX_INTERRUPT_MASK; + } + else + { + curBuffDescrip->controlExtend1 = 0; + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + /* Increase the index. */ + curBuffDescrip++; + } + } + buffCfg++; + } +} + +static void ENET_ActiveSend(ENET_Type *base, uint32_t ringId) +{ + assert(ringId < FSL_FEATURE_ENET_QUEUE); + + /* Ensure previous data update is completed with Data Synchronization Barrier before activing Tx BD. */ + __DSB(); + + switch (ringId) + { + case kENET_Ring0: + base->TDAR = ENET_TDAR_TDAR_MASK; + break; +#if FSL_FEATURE_ENET_QUEUE > 1 + case kENET_Ring1: + base->TDAR1 = ENET_TDAR1_TDAR_MASK; + break; + case kENET_Ring2: + base->TDAR2 = ENET_TDAR2_TDAR_MASK; + break; +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + default: + base->TDAR = ENET_TDAR_TDAR_MASK; + break; + } +} + +/*! + * brief Sets the ENET MII speed and duplex. + * + * This API is provided to dynamically change the speed and dulpex for MAC. + * + * param base ENET peripheral base address. + * param speed The speed of the RMII mode. + * param duplex The duplex of the RMII mode. + */ +void ENET_SetMII(ENET_Type *base, enet_mii_speed_t speed, enet_mii_duplex_t duplex) +{ + uint32_t rcr = base->RCR; + uint32_t tcr = base->TCR; + +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + uint32_t ecr = base->ECR; + + if (kENET_MiiSpeed1000M == speed) + { + assert(duplex == kENET_MiiFullDuplex); + ecr |= ENET_ECR_SPEED_MASK; + } + else + { + ecr &= ~ENET_ECR_SPEED_MASK; + } + + base->ECR = ecr; +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + + /* Sets speed mode. */ + if (kENET_MiiSpeed10M == speed) + { + rcr |= ENET_RCR_RMII_10T_MASK; + } + else + { + rcr &= ~ENET_RCR_RMII_10T_MASK; + } + /* Set duplex mode. */ + if (duplex == kENET_MiiHalfDuplex) + { + rcr |= ENET_RCR_DRT_MASK; + tcr &= ~ENET_TCR_FDEN_MASK; + } + else + { + rcr &= ~ENET_RCR_DRT_MASK; + tcr |= ENET_TCR_FDEN_MASK; + } + + base->RCR = rcr; + base->TCR = tcr; +} + +/*! + * brief Sets the ENET module Mac address. + * + * param base ENET peripheral base address. + * param macAddr The six-byte Mac address pointer. + * The pointer is allocated by application and input into the API. + */ +void ENET_SetMacAddr(ENET_Type *base, uint8_t *macAddr) +{ + uint32_t address; + + /* Set physical address lower register. */ + address = (uint32_t)(((uint32_t)macAddr[0] << 24U) | ((uint32_t)macAddr[1] << 16U) | ((uint32_t)macAddr[2] << 8U) | + (uint32_t)macAddr[3]); + base->PALR = address; + /* Set physical address high register. */ + address = (uint32_t)(((uint32_t)macAddr[4] << 8U) | ((uint32_t)macAddr[5])); + base->PAUR = address << ENET_PAUR_PADDR2_SHIFT; +} + +/*! + * brief Gets the ENET module Mac address. + * + * param base ENET peripheral base address. + * param macAddr The six-byte Mac address pointer. + * The pointer is allocated by application and input into the API. + */ +void ENET_GetMacAddr(ENET_Type *base, uint8_t *macAddr) +{ + assert(macAddr); + + uint32_t address; + + /* Get from physical address lower register. */ + address = base->PALR; + macAddr[0] = 0xFFU & (address >> 24U); + macAddr[1] = 0xFFU & (address >> 16U); + macAddr[2] = 0xFFU & (address >> 8U); + macAddr[3] = 0xFFU & address; + + /* Get from physical address high register. */ + address = (base->PAUR & ENET_PAUR_PADDR2_MASK) >> ENET_PAUR_PADDR2_SHIFT; + macAddr[4] = 0xFFU & (address >> 8U); + macAddr[5] = 0xFFU & address; +} + +/*! + * brief Sets the ENET SMI(serial management interface)- MII management interface. + * + * param base ENET peripheral base address. + * param srcClock_Hz This is the ENET module clock frequency. Normally it's the system clock. See clock distribution. + * param isPreambleDisabled The preamble disable flag. + * - true Enables the preamble. + * - false Disables the preamble. + */ +void ENET_SetSMI(ENET_Type *base, uint32_t srcClock_Hz, bool isPreambleDisabled) +{ + assert(srcClock_Hz); + + uint32_t clkCycle = 0; + uint32_t speed = 0; + uint32_t mscr = 0; + + /* Calculate the MII speed which controls the frequency of the MDC. */ + speed = srcClock_Hz / (2 * ENET_MDC_FREQUENCY); + /* Calculate the hold time on the MDIO output. */ + clkCycle = (10 + ENET_NANOSECOND_ONE_SECOND / srcClock_Hz - 1) / (ENET_NANOSECOND_ONE_SECOND / srcClock_Hz) - 1; + /* Build the configuration for MDC/MDIO control. */ + mscr = + ENET_MSCR_MII_SPEED(speed) | ENET_MSCR_HOLDTIME(clkCycle) | (isPreambleDisabled ? ENET_MSCR_DIS_PRE_MASK : 0); + base->MSCR = mscr; +} + +/*! + * brief Starts an SMI write command. + * + * Used for standard IEEE802.3 MDIO Clause 22 format. + * + * param base ENET peripheral base address. + * param phyAddr The PHY address. + * param phyReg The PHY register. Range from 0 ~ 31. + * param operation The write operation. + * param data The data written to PHY. + */ +void ENET_StartSMIWrite(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, enet_mii_write_t operation, uint32_t data) +{ + uint32_t mmfr = 0; + + /* Build MII write command. */ + mmfr = ENET_MMFR_ST(1) | ENET_MMFR_OP(operation) | ENET_MMFR_PA(phyAddr) | ENET_MMFR_RA(phyReg) | ENET_MMFR_TA(2) | + (data & 0xFFFF); + base->MMFR = mmfr; +} + +/*! + * brief Starts an SMI (Serial Management Interface) read command. + * + * Used for standard IEEE802.3 MDIO Clause 22 format. + * + * param base ENET peripheral base address. + * param phyAddr The PHY address. + * param phyReg The PHY register. Range from 0 ~ 31. + * param operation The read operation. + */ +void ENET_StartSMIRead(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, enet_mii_read_t operation) +{ + uint32_t mmfr = 0; + + /* Build MII read command. */ + mmfr = ENET_MMFR_ST(1) | ENET_MMFR_OP(operation) | ENET_MMFR_PA(phyAddr) | ENET_MMFR_RA(phyReg) | ENET_MMFR_TA(2); + base->MMFR = mmfr; +} + +#if defined(FSL_FEATURE_ENET_HAS_EXTEND_MDIO) && FSL_FEATURE_ENET_HAS_EXTEND_MDIO +/*! + * brief Starts the extended IEEE802.3 Clause 45 MDIO format SMI write command. + * + * param base ENET peripheral base address. + * param phyAddr The PHY address. + * param phyReg The PHY register. For MDIO IEEE802.3 Clause 45, + * the phyReg is a 21-bits combination of the devaddr (5 bits device address) + * and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr. + * param data The data written to PHY. + */ +void ENET_StartExtC45SMIWrite(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t data) +{ + uint32_t mmfr = 0; + + /* Parse the address from the input register. */ + uint16_t devAddr = (phyReg >> ENET_MMFR_TA_SHIFT) & 0x1FU; + uint16_t regAddr = (uint16_t)(phyReg & 0xFFFFU); + + /* Address write firstly. */ + mmfr = ENET_MMFR_ST(0) | ENET_MMFR_OP(kENET_MiiAddrWrite_C45) | ENET_MMFR_PA(phyAddr) | ENET_MMFR_RA(devAddr) | + ENET_MMFR_TA(2) | ENET_MMFR_DATA(regAddr); + base->MMFR = mmfr; + + /* Build MII write command. */ + mmfr = ENET_MMFR_ST(0) | ENET_MMFR_OP(kENET_MiiWriteFrame_C45) | ENET_MMFR_PA(phyAddr) | ENET_MMFR_RA(devAddr) | + ENET_MMFR_TA(2) | ENET_MMFR_DATA(data); + base->MMFR = mmfr; +} + +/*! + * brief Starts the extended IEEE802.3 Clause 45 MDIO format SMI read command. + * + * param base ENET peripheral base address. + * param phyAddr The PHY address. + * param phyReg The PHY register. For MDIO IEEE802.3 Clause 45, + * the phyReg is a 21-bits combination of the devaddr (5 bits device address) + * and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr. + */ +void ENET_StartExtC45SMIRead(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg) +{ + uint32_t mmfr = 0; + + /* Parse the address from the input register. */ + uint16_t devAddr = (phyReg >> ENET_MMFR_TA_SHIFT) & 0x1FU; + uint16_t regAddr = (uint16_t)(phyReg & 0xFFFFU); + + /* Address write firstly. */ + mmfr = ENET_MMFR_ST(0) | ENET_MMFR_OP(kENET_MiiAddrWrite_C45) | ENET_MMFR_PA(phyAddr) | ENET_MMFR_RA(devAddr) | + ENET_MMFR_TA(2) | ENET_MMFR_DATA(regAddr); + base->MMFR = mmfr; + + /* Build MII read command. */ + mmfr = ENET_MMFR_ST(0) | ENET_MMFR_OP(kENET_MiiReadFrame_C45) | ENET_MMFR_PA(phyAddr) | ENET_MMFR_RA(devAddr) | + ENET_MMFR_TA(2); + base->MMFR = mmfr; +} +#endif /* FSL_FEATURE_ENET_HAS_EXTEND_MDIO */ + +/*! + * brief Gets the error statistics of a received frame for ENET single ring. + * + * This API must be called after the ENET_GetRxFrameSize and before the ENET_ReadFrame(). + * If the ENET_GetRxFrameSize returns kStatus_ENET_RxFrameError, + * the ENET_GetRxErrBeforeReadFrame can be used to get the exact error statistics. + * This is an example. + * code + * status = ENET_GetRxFrameSize(&g_handle, &length); + * if (status == kStatus_ENET_RxFrameError) + * { + * // Get the error information of the received frame. + * ENET_GetRxErrBeforeReadFrame(&g_handle, &eErrStatic); + * // update the receive buffer. + * ENET_ReadFrame(EXAMPLE_ENET, &g_handle, NULL, 0); + * } + * endcode + * param handle The ENET handler structure pointer. This is the same handler pointer used in the ENET_Init. + * param eErrorStatic The error statistics structure pointer. + */ +void ENET_GetRxErrBeforeReadFrame(enet_handle_t *handle, enet_data_error_stats_t *eErrorStatic) +{ + assert(handle); + assert(handle->rxBdCurrent[0]); + assert(eErrorStatic); + + uint16_t control = 0; + volatile enet_rx_bd_struct_t *curBuffDescrip = handle->rxBdCurrent[0]; + + do + { + /* The last buffer descriptor of a frame. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + control = curBuffDescrip->control; + if (control & ENET_BUFFDESCRIPTOR_RX_TRUNC_MASK) + { + /* The receive truncate error. */ + eErrorStatic->statsRxTruncateErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_OVERRUN_MASK) + { + /* The receive over run error. */ + eErrorStatic->statsRxOverRunErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_LENVLIOLATE_MASK) + { + /* The receive length violation error. */ + eErrorStatic->statsRxLenGreaterErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_NOOCTET_MASK) + { + /* The receive alignment error. */ + eErrorStatic->statsRxAlignErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_CRC_MASK) + { + /* The receive CRC error. */ + eErrorStatic->statsRxFcsErr++; + } +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + uint16_t controlExt = curBuffDescrip->controlExtend1; + if (controlExt & ENET_BUFFDESCRIPTOR_RX_MACERR_MASK) + { + /* The MAC error. */ + eErrorStatic->statsRxMacErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_RX_PHYERR_MASK) + { + /* The PHY error. */ + eErrorStatic->statsRxPhyErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_RX_COLLISION_MASK) + { + /* The receive collision error. */ + eErrorStatic->statsRxCollisionErr++; + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + break; + } + + /* Increase the buffer descriptor, if it is the last one, increase to first one of the ring buffer. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_WRAP_MASK) + { + curBuffDescrip = handle->rxBdBase[0]; + } + else + { + curBuffDescrip++; + } + + } while (curBuffDescrip != handle->rxBdCurrent[0]); +} + +/*! + * brief Gets the size of the read frame for single ring. + * + * This function gets a received frame size from the ENET buffer descriptors. + * note The FCS of the frame is automatically removed by MAC and the size is the length without the FCS. + * After calling ENET_GetRxFrameSize, ENET_ReadFrame() should be called to update the + * receive buffers If the result is not "kStatus_ENET_RxFrameEmpty". + * + * param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * param length The length of the valid frame received. + * retval kStatus_ENET_RxFrameEmpty No frame received. Should not call ENET_ReadFrame to read frame. + * retval kStatus_ENET_RxFrameError Data error happens. ENET_ReadFrame should be called with NULL data + * and NULL length to update the receive buffers. + * retval kStatus_Success Receive a frame Successfully then the ENET_ReadFrame + * should be called with the right data buffer and the captured data length input. + */ +status_t ENET_GetRxFrameSize(enet_handle_t *handle, uint32_t *length) +{ + assert(handle); + assert(handle->rxBdCurrent[0]); + assert(length); + + /* Reset the length to zero. */ + *length = 0; + + uint16_t validLastMask = ENET_BUFFDESCRIPTOR_RX_LAST_MASK | ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK; + volatile enet_rx_bd_struct_t *curBuffDescrip = handle->rxBdCurrent[0]; + + /* Check the current buffer descriptor's empty flag. if empty means there is no frame received. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK) + { + return kStatus_ENET_RxFrameEmpty; + } + + do + { + /* Add check for abnormal case. */ + if ((!(curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK)) && (!curBuffDescrip->length)) + { + return kStatus_ENET_RxFrameError; + } + + /* Find the last buffer descriptor. */ + if ((curBuffDescrip->control & validLastMask) == ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + /* The last buffer descriptor in the frame check the status of the received frame. */ + if ((curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_ERR_MASK) +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + || (curBuffDescrip->controlExtend1 & ENET_BUFFDESCRIPTOR_RX_EXT_ERR_MASK) +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + ) + { + return kStatus_ENET_RxFrameError; + } + /* FCS is removed by MAC. */ + *length = curBuffDescrip->length; + return kStatus_Success; + } + + /* Increase the buffer descriptor, if it is the last one, increase to first one of the ring buffer. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_WRAP_MASK) + { + curBuffDescrip = handle->rxBdBase[0]; + } + else + { + curBuffDescrip++; + } + } while (curBuffDescrip != handle->rxBdCurrent[0]); + + /* The frame is on processing - set to empty status to make application to receive it next time. */ + return kStatus_ENET_RxFrameEmpty; +} + +/*! + * brief Reads a frame from the ENET device for single ring. + * This function reads a frame (both the data and the length) from the ENET buffer descriptors. + * The ENET_GetRxFrameSize should be used to get the size of the prepared data buffer. + * This is an example: + * code + * uint32_t length; + * enet_handle_t g_handle; + * //Get the received frame size firstly. + * status = ENET_GetRxFrameSize(&g_handle, &length); + * if (length != 0) + * { + * //Allocate memory here with the size of "length" + * uint8_t *data = memory allocate interface; + * if (!data) + * { + * ENET_ReadFrame(ENET, &g_handle, NULL, 0); + * //Add the console warning log. + * } + * else + * { + * status = ENET_ReadFrame(ENET, &g_handle, data, length); + * //Call stack input API to deliver the data to stack + * } + * } + * else if (status == kStatus_ENET_RxFrameError) + * { + * //Update the received buffer when a error frame is received. + * ENET_ReadFrame(ENET, &g_handle, NULL, 0); + * } + * endcode + * param base ENET peripheral base address. + * param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * param data The data buffer provided by user to store the frame which memory size should be at least "length". + * param length The size of the data buffer which is still the length of the received frame. + * return The execute status, successful or failure. + */ +status_t ENET_ReadFrame(ENET_Type *base, enet_handle_t *handle, uint8_t *data, uint32_t length) +{ + assert(handle); + assert(handle->rxBdCurrent[0]); + + uint32_t len = 0; + uint32_t offset = 0; + uint16_t control; + bool isLastBuff = false; + volatile enet_rx_bd_struct_t *curBuffDescrip = handle->rxBdCurrent[0]; + status_t result = kStatus_Success; + uint32_t address; + + /* For data-NULL input, only update the buffer descriptor. */ + if (!data) + { + do + { + /* Update the control flag. */ + control = handle->rxBdCurrent[0]->control; + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, 0); + + /* Find the last buffer descriptor for the frame. */ + if (control & ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + break; + } + + } while (handle->rxBdCurrent[0] != curBuffDescrip); + + return result; + } + else + { + +/* A frame on one buffer or several receive buffers are both considered. */ +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache invalidate maintain. */ + DCACHE_InvalidateByRange(address, handle->rxBuffSizeAlign[0]); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + enet_ptp_time_data_t ptpTimestamp; + bool isPtpEventMessage = false; + /* Parse the PTP message according to the header message. */ + isPtpEventMessage = ENET_Ptp1588ParseFrame((uint8_t *)address, &ptpTimestamp, false); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + while (!isLastBuff) + { + /* The last buffer descriptor of a frame. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + /* This is a valid frame. */ + isLastBuff = true; + if (length == curBuffDescrip->length) + { + /* Copy the frame to user's buffer without FCS. */ + len = curBuffDescrip->length - offset; + memcpy(data + offset, (void *)address, len); +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* Store the PTP 1588 timestamp for received PTP event frame. */ + if (isPtpEventMessage) + { + /* Set the timestamp to the timestamp ring. */ + ptpTimestamp.timeStamp.nanosecond = curBuffDescrip->timestamp; + result = ENET_StoreRxFrameTime(base, handle, &ptpTimestamp); + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, 0); + return result; + } + else + { + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, 0); + } + } + else + { + /* Store a frame on several buffer descriptors. */ + isLastBuff = false; + /* Length check. */ + if (offset >= length) + { + break; + } + + memcpy(data + offset, (void *)address, handle->rxBuffSizeAlign[0]); + offset += handle->rxBuffSizeAlign[0]; + + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, 0); + } + + /* Get the current buffer descriptor. */ + curBuffDescrip = handle->rxBdCurrent[0]; + +/* Add the cache invalidate maintain. */ +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + DCACHE_InvalidateByRange(address, handle->rxBuffSizeAlign[0]); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + } + } + + return kStatus_ENET_RxFrameFail; +} + +static void ENET_UpdateReadBuffers(ENET_Type *base, enet_handle_t *handle, uint32_t ringId) +{ + assert(handle); + assert(ringId < FSL_FEATURE_ENET_QUEUE); + + /* Clears status. */ + handle->rxBdCurrent[ringId]->control &= ENET_BUFFDESCRIPTOR_RX_WRAP_MASK; + /* Sets the receive buffer descriptor with the empty flag. */ + handle->rxBdCurrent[ringId]->control |= ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK; + + /* Increase current buffer descriptor to the next one. */ + if (handle->rxBdCurrent[ringId]->control & ENET_BUFFDESCRIPTOR_RX_WRAP_MASK) + { + handle->rxBdCurrent[ringId] = handle->rxBdBase[ringId]; + } + else + { + handle->rxBdCurrent[ringId]++; + } + + /* Ensure previous data update is completed with Data Synchronization Barrier before activing Rx BD. */ + __DSB(); + + /* Actives the receive buffer descriptor. */ + switch (ringId) + { + case kENET_Ring0: + base->RDAR = ENET_RDAR_RDAR_MASK; + break; +#if FSL_FEATURE_ENET_QUEUE > 1 + case kENET_Ring1: + base->RDAR1 = ENET_RDAR1_RDAR_MASK; + break; + case kENET_Ring2: + base->RDAR2 = ENET_RDAR2_RDAR_MASK; + break; +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + default: + base->RDAR = ENET_RDAR_RDAR_MASK; + break; + } +} + +/*! + * brief Transmits an ENET frame for single ring. + * note The CRC is automatically appended to the data. Input the data + * to send without the CRC. + * + * + * param base ENET peripheral base address. + * param handle The ENET handler pointer. This is the same handler pointer used in the ENET_Init. + * param data The data buffer provided by user to be send. + * param length The length of the data to be send. + * retval kStatus_Success Send frame succeed. + * retval kStatus_ENET_TxFrameBusy Transmit buffer descriptor is busy under transmission. + * The transmit busy happens when the data send rate is over the MAC capacity. + * The waiting mechanism is recommended to be added after each call return with + * kStatus_ENET_TxFrameBusy. + */ +status_t ENET_SendFrame(ENET_Type *base, enet_handle_t *handle, const uint8_t *data, uint32_t length) +{ + assert(handle); + assert(data); + + volatile enet_tx_bd_struct_t *curBuffDescrip; + uint32_t len = 0; + uint32_t sizeleft = 0; + uint32_t address; + + /* Check the frame length. */ + if (length > ENET_FRAME_MAX_FRAMELEN) + { + return kStatus_ENET_TxFrameOverLen; + } + + /* Check if the transmit buffer is ready. */ + curBuffDescrip = handle->txBdCurrent[0]; + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_READY_MASK) + { + return kStatus_ENET_TxFrameBusy; + } +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + bool isPtpEventMessage = false; + /* Check PTP message with the PTP header. */ + isPtpEventMessage = ENET_Ptp1588ParseFrame(data, NULL, true); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +// lw_print("lw: [%s] size %d len %d\n", __func__, handle->txBuffSizeAlign[0], length); + + /* One transmit buffer is enough for one frame. */ + if (handle->txBuffSizeAlign[0] >= length) + { +/* Copy data to the buffer for uDMA transfer. */ +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ + memcpy((void *)address, data, length); +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + DCACHE_CleanByRange(address, length); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + /* Set data length. */ + curBuffDescrip->length = length; +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* For enable the timestamp. */ + if (isPtpEventMessage) + { + curBuffDescrip->controlExtend1 |= ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } + else + { + curBuffDescrip->controlExtend1 &= ~ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } + +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + curBuffDescrip->control |= (ENET_BUFFDESCRIPTOR_TX_READY_MASK | ENET_BUFFDESCRIPTOR_TX_LAST_MASK); + + /* Increase the buffer descriptor address. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdCurrent[0] = handle->txBdBase[0]; + } + else + { + handle->txBdCurrent[0]++; + } + + /* Active the transmit buffer descriptor. */ + ENET_ActiveSend(base, 0); + + return kStatus_Success; + } + else + { + /* One frame requires more than one transmit buffers. */ + do + { +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* For enable the timestamp. */ + if (isPtpEventMessage) + { + curBuffDescrip->controlExtend1 |= ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } + else + { + curBuffDescrip->controlExtend1 &= ~ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + /* Increase the buffer descriptor address. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdCurrent[0] = handle->txBdBase[0]; + } + else + { + handle->txBdCurrent[0]++; + } + /* update the size left to be transmit. */ + sizeleft = length - len; +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ + if (sizeleft > handle->txBuffSizeAlign[0]) + { + /* Data copy. */ + memcpy((void *)address, data + len, handle->txBuffSizeAlign[0]); +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache clean maintain. */ + DCACHE_CleanByRange(address, handle->txBuffSizeAlign[0]); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + /* Data length update. */ + curBuffDescrip->length = handle->txBuffSizeAlign[0]; + len += handle->txBuffSizeAlign[0]; + /* Sets the control flag. */ + curBuffDescrip->control &= ~ENET_BUFFDESCRIPTOR_TX_LAST_MASK; + curBuffDescrip->control |= ENET_BUFFDESCRIPTOR_TX_READY_MASK; + /* Active the transmit buffer descriptor*/ + ENET_ActiveSend(base, 0); + } + else + { + memcpy((void *)address, data + len, sizeleft); +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache clean maintain. */ + DCACHE_CleanByRange(address, sizeleft); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + curBuffDescrip->length = sizeleft; + /* Set Last buffer wrap flag. */ + curBuffDescrip->control |= ENET_BUFFDESCRIPTOR_TX_READY_MASK | ENET_BUFFDESCRIPTOR_TX_LAST_MASK; + /* Active the transmit buffer descriptor. */ + ENET_ActiveSend(base, 0); + + return kStatus_Success; + } + + /* Get the current buffer descriptor address. */ + curBuffDescrip = handle->txBdCurrent[0]; + + } while (!(curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_READY_MASK)); + + return kStatus_ENET_TxFrameBusy; + } +} + +#if FSL_FEATURE_ENET_QUEUE > 1 +/*! + * brief Gets the error statistics of received frame for extended multi-ring. + * + * This API must be called after the ENET_GetRxFrameSizeMultiRing and before the ENET_ReadFrameMultiRing(). + * If the ENET_GetRxFrameSizeMultiRing returns kStatus_ENET_RxFrameError, + * the ENET_GetRxErrBeforeReadFrameMultiRing can be used to get the exact error statistics. + * + * param handle The ENET handler structure pointer. This is the same handler pointer used in the ENET_Init. + * param eErrorStatic The error statistics structure pointer. + * param ringId The ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1. + */ +void ENET_GetRxErrBeforeReadFrameMultiRing(enet_handle_t *handle, + enet_data_error_stats_t *eErrorStatic, + uint32_t ringId) +{ + assert(handle); + assert(eErrorStatic); + assert(ringId < FSL_FEATURE_ENET_QUEUE); + + uint16_t control = 0; + volatile enet_rx_bd_struct_t *curBuffDescrip = handle->rxBdCurrent[ringId]; + + do + { + /* The last buffer descriptor of a frame. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + control = curBuffDescrip->control; + if (control & ENET_BUFFDESCRIPTOR_RX_TRUNC_MASK) + { + /* The receive truncate error. */ + eErrorStatic->statsRxTruncateErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_OVERRUN_MASK) + { + /* The receive over run error. */ + eErrorStatic->statsRxOverRunErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_LENVLIOLATE_MASK) + { + /* The receive length violation error. */ + eErrorStatic->statsRxLenGreaterErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_NOOCTET_MASK) + { + /* The receive alignment error. */ + eErrorStatic->statsRxAlignErr++; + } + if (control & ENET_BUFFDESCRIPTOR_RX_CRC_MASK) + { + /* The receive CRC error. */ + eErrorStatic->statsRxFcsErr++; + } +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + uint16_t controlExt = curBuffDescrip->controlExtend1; + if (controlExt & ENET_BUFFDESCRIPTOR_RX_MACERR_MASK) + { + /* The MAC error. */ + eErrorStatic->statsRxMacErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_RX_PHYERR_MASK) + { + /* The PHY error. */ + eErrorStatic->statsRxPhyErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_RX_COLLISION_MASK) + { + /* The receive collision error. */ + eErrorStatic->statsRxCollisionErr++; + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + break; + } + + /* Increase the buffer descriptor, if it is the last one, increase to first one of the ring buffer. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_WRAP_MASK) + { + curBuffDescrip = handle->rxBdBase[ringId]; + } + else + { + curBuffDescrip++; + } + + } while (curBuffDescrip != handle->rxBdCurrent[ringId]); +} + +/*! + * brief Gets the size of the read frame for extended mutli-ring. + * + * This function gets a received frame size from the ENET buffer descriptors. + * note The FCS of the frame is automatically removed by MAC and the size is the length without the FCS. + * After calling ENET_GetRxFrameSizeMultiRing, ENET_ReadFrameMultiRing() should be called to update the + * receive buffers If the result is not "kStatus_ENET_RxFrameEmpty". The usage is + * the same to the single ring, refer to ENET_GetRxFrameSize. + * + * param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * param length The length of the valid frame received. + * param ringId The ring index or ring number; + * retval kStatus_ENET_RxFrameEmpty No frame received. Should not call ENET_ReadFrameMultiRing to read frame. + * retval kStatus_ENET_RxFrameError Data error happens. ENET_ReadFrameMultiRing should be called with NULL data + * and NULL length to update the receive buffers. + * retval kStatus_Success Receive a frame Successfully then the ENET_ReadFrame + * should be called with the right data buffer and the captured data length input. + */ +status_t ENET_GetRxFrameSizeMultiRing(enet_handle_t *handle, uint32_t *length, uint32_t ringId) +{ + assert(handle); + assert(length); + assert(ringId < FSL_FEATURE_ENET_QUEUE); + + /* Reset the length to zero. */ + *length = 0; + uint16_t validLastMask = ENET_BUFFDESCRIPTOR_RX_LAST_MASK | ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK; + volatile enet_rx_bd_struct_t *curBuffDescrip; + + curBuffDescrip = handle->rxBdCurrent[ringId]; + /* Check the current buffer descriptor's empty flag. if empty means there is no frame received. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK) + { + return kStatus_ENET_RxFrameEmpty; + } + + do + { + /* Add check for abnormal case. */ + if ((!(curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK)) && (!curBuffDescrip->length)) + { + return kStatus_ENET_RxFrameError; + } + /* Find the last buffer descriptor. */ + if ((curBuffDescrip->control & validLastMask) == ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + /* The last buffer descriptor in the frame check the status of the received frame. */ + if ((curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_ERR_MASK) +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + || (curBuffDescrip->controlExtend1 & ENET_BUFFDESCRIPTOR_RX_EXT_ERR_MASK) +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + ) + { + return kStatus_ENET_RxFrameError; + } + /* FCS is removed by MAC. */ + *length = curBuffDescrip->length; + return kStatus_Success; + } + /* Increase the buffer descriptor, if it is the last one, increase to first one of the ring buffer. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_WRAP_MASK) + { + curBuffDescrip = handle->rxBdBase[ringId]; + } + else + { + curBuffDescrip++; + } + } while (curBuffDescrip != handle->rxBdCurrent[ringId]); + + /* The frame is on processing - set to empty status to make application to receive it next time. */ + return kStatus_ENET_RxFrameEmpty; +} + +/*! + * brief Reads a frame from the ENET device for multi-ring. + * + * This function reads a frame (both the data and the length) from the ENET buffer descriptors. + * The ENET_GetRxFrameSizeMultiRing should be used to get the size of the prepared data buffer. + * This usage is the same as the single ring, refer to ENET_ReadFrame. + + * param base ENET peripheral base address. + * param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * param data The data buffer provided by user to store the frame which memory size should be at least "length". + * param length The size of the data buffer which is still the length of the received frame. + * param ringId The ring index or ring number; + * return The execute status, successful or failure. + */ +status_t ENET_ReadFrameMultiRing( + ENET_Type *base, enet_handle_t *handle, uint8_t *data, uint32_t length, uint32_t ringId) +{ + assert(handle); + assert(ringId < FSL_FEATURE_ENET_QUEUE); + + uint32_t len = 0; + uint32_t offset = 0; + uint16_t control; + bool isLastBuff = false; + volatile enet_rx_bd_struct_t *curBuffDescrip = handle->rxBdCurrent[ringId]; + status_t result = kStatus_Success; + uint32_t address; + + /* For data-NULL input, only update the buffer descriptor. */ + if (!data) + { + do + { + /* Update the control flag. */ + control = handle->rxBdCurrent[ringId]->control; + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, ringId); + + /* Find the last buffer descriptor for the frame. */ + if (control & ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + break; + } + + } while (handle->rxBdCurrent[ringId] != curBuffDescrip); + + return result; + } + else + { +/* A frame on one buffer or several receive buffers are both considered. */ +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache invalidate maintain. */ + DCACHE_InvalidateByRange(address, handle->rxBuffSizeAlign[ringId]); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + enet_ptp_time_data_t ptpTimestamp; + bool isPtpEventMessage = false; + /* Parse the PTP message according to the header message. */ + isPtpEventMessage = ENET_Ptp1588ParseFrame((uint8_t *)address, &ptpTimestamp, false); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + while (!isLastBuff) + { + /* The last buffer descriptor of a frame. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_RX_LAST_MASK) + { + /* This is a valid frame. */ + isLastBuff = true; + if (length == curBuffDescrip->length) + { + /* Copy the frame to user's buffer without FCS. */ + len = curBuffDescrip->length - offset; + memcpy(data + offset, (void *)address, len); +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* Store the PTP 1588 timestamp for received PTP event frame. */ + if (isPtpEventMessage) + { + /* Set the timestamp to the timestamp ring. */ + ptpTimestamp.timeStamp.nanosecond = curBuffDescrip->timestamp; + result = ENET_StoreRxFrameTime(base, handle, &ptpTimestamp); + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, ringId); + return result; + } + else + { + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, ringId); + } + } + else + { + /* Store a frame on several buffer descriptors. */ + isLastBuff = false; + /* Length check. */ + if (offset >= length) + { + break; + } + memcpy(data + offset, (void *)address, handle->rxBuffSizeAlign[ringId]); + offset += handle->rxBuffSizeAlign[ringId]; + + /* Updates the receive buffer descriptors. */ + ENET_UpdateReadBuffers(base, handle, ringId); + } + + /* Get the current buffer descriptor. */ + + curBuffDescrip = handle->rxBdCurrent[ringId]; +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache invalidate maintain. */ + DCACHE_InvalidateByRange(address, handle->rxBuffSizeAlign[ringId]); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + } + } + + return kStatus_ENET_RxFrameFail; +} + +/*! + * brief Transmits an ENET frame for extended multi-ring. + * note The CRC is automatically appended to the data. Input the data + * to send without the CRC. + * + * In this API, multiple-ring are mainly used for extended avb frames are supported. + * The transmit scheme for avb frames is the credit-based scheme, the AVB class A, AVB class B + * and the non-AVB frame are transmitted in ring 1, ring 2 and ring 0 independently. + * So application should care about the transmit ring index when use multiple-ring transmission. + * + * param base ENET peripheral base address. + * param handle The ENET handler pointer. This is the same handler pointer used in the ENET_Init. + * param data The data buffer provided by user to be send. + * param length The length of the data to be send. + * param ringId The ring index for transmission. + * retval kStatus_Success Send frame succeed. + * retval kStatus_ENET_TxFrameBusy Transmit buffer descriptor is busy under transmission. + * The transmit busy happens when the data send rate is over the MAC capacity. + * The waiting mechanism is recommended to be added after each call return with + * kStatus_ENET_TxFrameBusy. + */ +status_t ENET_SendFrameMultiRing( + ENET_Type *base, enet_handle_t *handle, uint8_t *data, uint32_t length, uint32_t ringId) +{ + assert(handle); + assert(data); + assert(ringId < FSL_FEATURE_ENET_QUEUE); + + volatile enet_tx_bd_struct_t *curBuffDescrip; + uint32_t len = 0; + uint32_t sizeleft = 0; + uint32_t address; + + /* Check the frame length. */ + if (length > ENET_FRAME_MAX_FRAMELEN) + { + return kStatus_ENET_TxFrameOverLen; + } + + /* Check if the transmit buffer is ready. */ + curBuffDescrip = handle->txBdCurrent[ringId]; + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_READY_MASK) + { + return kStatus_ENET_TxFrameBusy; + } +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + bool isPtpEventMessage = false; + /* Check PTP message with the PTP header. */ + isPtpEventMessage = ENET_Ptp1588ParseFrame(data, NULL, true); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + /* One transmit buffer is enough for one frame. */ + if (handle->txBuffSizeAlign[ringId] >= length) + { +/* Copy data to the buffer for uDMA transfer. */ +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ + memcpy((void *)address, data, length); + +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache clean maintain. */ + DCACHE_CleanByRange(address, length); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + + /* Set data length. */ + curBuffDescrip->length = length; +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* For enable the timestamp. */ + if (isPtpEventMessage) + { + curBuffDescrip->controlExtend1 |= ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } + else + { + curBuffDescrip->controlExtend1 &= ~ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } + +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + curBuffDescrip->control |= (ENET_BUFFDESCRIPTOR_TX_READY_MASK | ENET_BUFFDESCRIPTOR_TX_LAST_MASK); + + /* Increase the buffer descriptor address. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdCurrent[ringId] = handle->txBdBase[ringId]; + } + else + { + handle->txBdCurrent[ringId]++; + } + + /* Active the transmit buffer descriptor. */ + ENET_ActiveSend(base, ringId); + + return kStatus_Success; + } + else + { + /* One frame requires more than one transmit buffers. */ + do + { +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + /* For enable the timestamp. */ + if (isPtpEventMessage) + { + curBuffDescrip->controlExtend1 |= ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } + else + { + curBuffDescrip->controlExtend1 &= ~ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK; + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + /* Increase the buffer descriptor address. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdCurrent[ringId] = handle->txBdBase[ringId]; + } + else + { + handle->txBdCurrent[ringId]++; + } + /* update the size left to be transmit. */ + sizeleft = length - len; +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); +#else + address = (uint32_t)curBuffDescrip->buffer; +#endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ + if (sizeleft > handle->txBuffSizeAlign[ringId]) + { + /* Data copy. */ + memcpy((void *)address, data + len, handle->txBuffSizeAlign[ringId]); +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache clean maintain. */ + DCACHE_CleanByRange(address, handle->txBuffSizeAlign[ringId]); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + /* Data length update. */ + curBuffDescrip->length = handle->txBuffSizeAlign[ringId]; + len += handle->txBuffSizeAlign[ringId]; + /* Sets the control flag. */ + curBuffDescrip->control &= ~ENET_BUFFDESCRIPTOR_TX_LAST_MASK; + curBuffDescrip->control |= ENET_BUFFDESCRIPTOR_TX_READY_MASK; + + /* Active the transmit buffer descriptor*/ + ENET_ActiveSend(base, ringId); + } + else + { + memcpy((void *)address, data + len, sizeleft); +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + /* Add the cache clean maintain. */ + DCACHE_CleanByRange(address, sizeleft); +#endif /* FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL */ + curBuffDescrip->length = sizeleft; + /* Set Last buffer wrap flag. */ + curBuffDescrip->control |= ENET_BUFFDESCRIPTOR_TX_READY_MASK | ENET_BUFFDESCRIPTOR_TX_LAST_MASK; + + /* Active the transmit buffer descriptor. */ + ENET_ActiveSend(base, ringId); + + return kStatus_Success; + } + + /* Get the current buffer descriptor address. */ + curBuffDescrip = handle->txBdCurrent[ringId]; + } while (!(curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_READY_MASK)); + + return kStatus_ENET_TxFrameBusy; + } +} +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + +/*! + * brief Adds the ENET device to a multicast group. + * + * param base ENET peripheral base address. + * param address The six-byte multicast group address which is provided by application. + */ +void ENET_AddMulticastGroup(ENET_Type *base, uint8_t *address) +{ + assert(address); + + uint32_t crc = 0xFFFFFFFFU; + uint32_t count1 = 0; + uint32_t count2 = 0; + + /* Calculates the CRC-32 polynomial on the multicast group address. */ + for (count1 = 0; count1 < ENET_FRAME_MACLEN; count1++) + { + uint8_t c = address[count1]; + for (count2 = 0; count2 < 0x08U; count2++) + { + if ((c ^ crc) & 1U) + { + crc >>= 1U; + c >>= 1U; + crc ^= 0xEDB88320U; + } + else + { + crc >>= 1U; + c >>= 1U; + } + } + } + + /* Enable a multicast group address. */ + if (!((crc >> 0x1FU) & 1U)) + { + base->GALR |= 1U << ((crc >> 0x1AU) & 0x1FU); + } + else + { + base->GAUR |= 1U << ((crc >> 0x1AU) & 0x1FU); + } +} + +/*! + * brief Moves the ENET device from a multicast group. + * + * param base ENET peripheral base address. + * param address The six-byte multicast group address which is provided by application. + */ +void ENET_LeaveMulticastGroup(ENET_Type *base, uint8_t *address) +{ + assert(address); + + uint32_t crc = 0xFFFFFFFFU; + uint32_t count1 = 0; + uint32_t count2 = 0; + + /* Calculates the CRC-32 polynomial on the multicast group address. */ + for (count1 = 0; count1 < ENET_FRAME_MACLEN; count1++) + { + uint8_t c = address[count1]; + for (count2 = 0; count2 < 0x08U; count2++) + { + if ((c ^ crc) & 1U) + { + crc >>= 1U; + c >>= 1U; + crc ^= 0xEDB88320U; + } + else + { + crc >>= 1U; + c >>= 1U; + } + } + } + + /* Set the hash table. */ + if (!((crc >> 0x1FU) & 1U)) + { + base->GALR &= ~(1U << ((crc >> 0x1AU) & 0x1FU)); + } + else + { + base->GAUR &= ~(1U << ((crc >> 0x1AU) & 0x1FU)); + } +} + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! + * brief Gets the ENET transmit frame statistics after the data send for single ring. + * + * This interface gets the error statistics of the transmit frame. + * Because the error information is reported by the uDMA after the data delivery, this interface + * should be called after the data transmit API. It is recommended to call this function on + * transmit interrupt handler. After calling the ENET_SendFrame, the + * transmit interrupt notifies the transmit completion. + * + * param handle The PTP handler pointer. This is the same handler pointer used in the ENET_Init. + * param eErrorStatic The error statistics structure pointer. + * return The execute status. + */ +status_t ENET_GetTxErrAfterSendFrame(enet_handle_t *handle, enet_data_error_stats_t *eErrorStatic) +{ + assert(handle); + assert(eErrorStatic); + + uint16_t control = 0; + uint16_t controlExt = 0; + + do + { + /* Get the current dirty transmit buffer descriptor. */ + control = handle->txBdDirtyStatic[0]->control; + controlExt = handle->txBdDirtyStatic[0]->controlExtend0; + + /* Get the control status data, If the buffer descriptor has not been processed break out. */ + if (control & ENET_BUFFDESCRIPTOR_TX_READY_MASK) + { + return kStatus_ENET_TxFrameBusy; + } + /* Increase the transmit dirty static pointer. */ + if (handle->txBdDirtyStatic[0]->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdDirtyStatic[0] = handle->txBdBase[0]; + } + else + { + handle->txBdDirtyStatic[0]++; + } + + /* If the transmit buffer descriptor is ready and the last buffer descriptor, store packet statistic. */ + if (control & ENET_BUFFDESCRIPTOR_TX_LAST_MASK) + { + if (controlExt & ENET_BUFFDESCRIPTOR_TX_ERR_MASK) + { + /* Transmit error. */ + eErrorStatic->statsTxErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_EXCCOLLISIONERR_MASK) + { + /* Transmit excess collision error. */ + eErrorStatic->statsTxExcessCollisionErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_LATECOLLISIONERR_MASK) + { + /* Transmit late collision error. */ + eErrorStatic->statsTxLateCollisionErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_UNDERFLOWERR_MASK) + { + /* Transmit under flow error. */ + eErrorStatic->statsTxUnderFlowErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_OVERFLOWERR_MASK) + { + /* Transmit over flow error. */ + eErrorStatic->statsTxOverFlowErr++; + } + return kStatus_Success; + } + + } while (handle->txBdDirtyStatic[0] != handle->txBdCurrent[0]); + + return kStatus_ENET_TxFrameFail; +} + +#if FSL_FEATURE_ENET_QUEUE > 1 +/*! + * brief Gets the ENET transmit frame statistics after the data send for extended multi-ring. + * + * This interface gets the error statistics of the transmit frame. + * Because the error information is reported by the uDMA after the data delivery, this interface + * should be called after the data transmit API and shall be called by transmit interrupt handler. + * After calling the ENET_SendFrame, the transmit interrupt notifies the transmit completion. + * + * param handle The PTP handler pointer. This is the same handler pointer used in the ENET_Init. + * param eErrorStatic The error statistics structure pointer. + * param ringId The ring index. + * return The execute status. + */ +status_t ENET_GetTxErrAfterSendFrameMultiRing(enet_handle_t *handle, + enet_data_error_stats_t *eErrorStatic, + uint32_t ringId) +{ + assert(handle); + assert(eErrorStatic); + assert(ringId < FSL_FEATURE_ENET_QUEUE); + + uint16_t control = 0; + uint16_t controlExt = 0; + + do + { + /* Get the current dirty transmit buffer descriptor. */ + control = handle->txBdDirtyStatic[ringId]->control; + controlExt = handle->txBdDirtyStatic[ringId]->controlExtend0; + /* Get the control status data, If the buffer descriptor has not been processed break out. */ + if (control & ENET_BUFFDESCRIPTOR_TX_READY_MASK) + { + return kStatus_ENET_TxFrameBusy; + } + /* Increase the transmit dirty static pointer. */ + if (handle->txBdDirtyStatic[ringId]->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdDirtyStatic[ringId] = handle->txBdBase[ringId]; + } + else + { + handle->txBdDirtyStatic[ringId]++; + } + + /* If the transmit buffer descriptor is ready and the last buffer descriptor, store packet statistic. */ + if (control & ENET_BUFFDESCRIPTOR_TX_LAST_MASK) + { + if (controlExt & ENET_BUFFDESCRIPTOR_TX_ERR_MASK) + { + /* Transmit error. */ + eErrorStatic->statsTxErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_EXCCOLLISIONERR_MASK) + { + /* Transmit excess collision error. */ + eErrorStatic->statsTxExcessCollisionErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_LATECOLLISIONERR_MASK) + { + /* Transmit late collision error. */ + eErrorStatic->statsTxLateCollisionErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_UNDERFLOWERR_MASK) + { + /* Transmit under flow error. */ + eErrorStatic->statsTxUnderFlowErr++; + } + if (controlExt & ENET_BUFFDESCRIPTOR_TX_OVERFLOWERR_MASK) + { + /* Transmit over flow error. */ + eErrorStatic->statsTxOverFlowErr++; + } + return kStatus_Success; + } + + } while (handle->txBdDirtyStatic[ringId] != handle->txBdCurrent[ringId]); + + return kStatus_ENET_TxFrameFail; +} +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + +static bool ENET_Ptp1588ParseFrame(const uint8_t *data, enet_ptp_time_data_t *ptpTsData, bool isFastEnabled) +{ + assert(data); + if (!isFastEnabled) + { + assert(ptpTsData); + } + + bool isPtpMsg = false; + const uint8_t *buffer = data; + uint16_t ptpType; + + /* Check for VLAN frame. + * Add Double vlan tag check for receiving extended QIN vlan frame. */ + if (*(uint16_t *)(buffer + ENET_PTP1588_ETHL2_PACKETTYPE_OFFSET) == (ENET_HTONS(ENET_8021QVLAN) +#if defined(FSL_FEATUR_ENET_HAS_AVB) && FSL_FEATURE_HAS_AVB + || ENET_HTONS(ENET_8021QSVLAN) +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + )) + { + buffer += ENET_FRAME_VLAN_TAGLEN; +#if defined(FSL_FEATUR_ENET_HAS_AVB) && FSL_FEATURE_HAS_AVB + if (*(uint16_t *)(buffer + ENET_PTP1588_ETHL2_PACKETTYPE_OFFSET) == ENET_HTONS(ENET_8021QVLAN) + { + buffer += ENET_FRAME_VLAN_TAGLEN; + } +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + } + + ptpType = *(uint16_t *)(buffer + ENET_PTP1588_ETHL2_PACKETTYPE_OFFSET); + switch (ENET_HTONS(ptpType)) + { /* Ethernet layer 2. */ + case ENET_ETHERNETL2: + if ((*(uint8_t *)(buffer + ENET_PTP1588_ETHL2_MSGTYPE_OFFSET) & 0x0F) <= kENET_PtpEventMsgType) + { + isPtpMsg = true; + if (!isFastEnabled) + { + /* It's a ptpv2 message and store the ptp header information. */ + ptpTsData->version = (*(uint8_t *)(buffer + ENET_PTP1588_ETHL2_VERSION_OFFSET)) & 0x0F; + ptpTsData->messageType = (*(uint8_t *)(buffer + ENET_PTP1588_ETHL2_MSGTYPE_OFFSET)) & 0x0F; + ptpTsData->sequenceId = ENET_HTONS(*(uint16_t *)(buffer + ENET_PTP1588_ETHL2_SEQUENCEID_OFFSET)); + memcpy((void *)&ptpTsData->sourcePortId[0], (void *)(buffer + ENET_PTP1588_ETHL2_CLOCKID_OFFSET), + kENET_PtpSrcPortIdLen); + } + } + break; + /* IPV4. */ + case ENET_IPV4: + if ((*(uint8_t *)(buffer + ENET_PTP1588_IPVERSION_OFFSET) >> 4) == ENET_IPV4VERSION) + { + if (((*(uint16_t *)(buffer + ENET_PTP1588_IPV4_UDP_PORT_OFFSET)) == ENET_HTONS(kENET_PtpEventPort)) && + (*(uint8_t *)(buffer + ENET_PTP1588_IPV4_UDP_PROTOCOL_OFFSET) == ENET_UDPVERSION)) + { + /* Set the PTP message flag. */ + isPtpMsg = true; + if (!isFastEnabled) + { + /* It's a IPV4 ptp message and store the ptp header information. */ + ptpTsData->version = (*(uint8_t *)(buffer + ENET_PTP1588_IPV4_UDP_VERSION_OFFSET)) & 0x0F; + ptpTsData->messageType = (*(uint8_t *)(buffer + ENET_PTP1588_IPV4_UDP_MSGTYPE_OFFSET)) & 0x0F; + ptpTsData->sequenceId = + ENET_HTONS(*(uint16_t *)(buffer + ENET_PTP1588_IPV4_UDP_SEQUENCEID_OFFSET)); + memcpy((void *)&ptpTsData->sourcePortId[0], + (void *)(buffer + ENET_PTP1588_IPV4_UDP_CLKID_OFFSET), kENET_PtpSrcPortIdLen); + } + } + } + break; + /* IPV6. */ + case ENET_IPV6: + if ((*(uint8_t *)(buffer + ENET_PTP1588_IPVERSION_OFFSET) >> 4) == ENET_IPV6VERSION) + { + if (((*(uint16_t *)(buffer + ENET_PTP1588_IPV6_UDP_PORT_OFFSET)) == ENET_HTONS(kENET_PtpEventPort)) && + (*(uint8_t *)(buffer + ENET_PTP1588_IPV6_UDP_PROTOCOL_OFFSET) == ENET_UDPVERSION)) + { + /* Set the PTP message flag. */ + isPtpMsg = true; + if (!isFastEnabled) + { + /* It's a IPV6 ptp message and store the ptp header information. */ + ptpTsData->version = (*(uint8_t *)(buffer + ENET_PTP1588_IPV6_UDP_VERSION_OFFSET)) & 0x0F; + ptpTsData->messageType = (*(uint8_t *)(buffer + ENET_PTP1588_IPV6_UDP_MSGTYPE_OFFSET)) & 0x0F; + ptpTsData->sequenceId = + ENET_HTONS(*(uint16_t *)(buffer + ENET_PTP1588_IPV6_UDP_SEQUENCEID_OFFSET)); + memcpy((void *)&ptpTsData->sourcePortId[0], + (void *)(buffer + ENET_PTP1588_IPV6_UDP_CLKID_OFFSET), kENET_PtpSrcPortIdLen); + } + } + } + break; + default: + break; + } + return isPtpMsg; +} + +/*! + * brief Configures the ENET PTP IEEE 1588 feature with the basic configuration. + * The function sets the clock for PTP 1588 timer and enables + * time stamp interrupts and transmit interrupts for PTP 1588 features. + * This API should be called when the 1588 feature is enabled + * or the ENET_ENHANCEDBUFFERDESCRIPTOR_MODE is defined. + * ENET_Init should be called before calling this API. + * + * note The PTP 1588 time-stamp second increase though time-stamp interrupt handler + * and the transmit time-stamp store is done through transmit interrupt handler. + * As a result, the TS interrupt and TX interrupt are enabled when you call this API. + * + * param base ENET peripheral base address. + * param handle ENET handler pointer. + * param ptpConfig The ENET PTP1588 configuration. + */ +void ENET_Ptp1588Configure(ENET_Type *base, enet_handle_t *handle, enet_ptp_config_t *ptpConfig) +{ + assert(handle); + assert(ptpConfig); + uint8_t count; + + uint32_t instance = ENET_GetInstance(base); + uint32_t mask = kENET_TxBufferInterrupt; +#if FSL_FEATURE_ENET_QUEUE > 1 + mask |= kENET_TxBuffer1Interrupt | kENET_TxBuffer2Interrupt; +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + + /* Start the 1588 timer. */ + ENET_Ptp1588StartTimer(base, ptpConfig->ptp1588ClockSrc_Hz); + + for (count = 0; count < handle->ringNum; count++) + { + handle->txBdDirtyTime[count] = handle->txBdBase[count]; + handle->txBdDirtyStatic[count] = handle->txBdBase[count]; + } + + /* Setting the receive and transmit state for transaction. */ + handle->rxPtpTsDataRing.ptpTsData = ptpConfig->rxPtpTsData; + handle->rxPtpTsDataRing.size = ptpConfig->ptpTsRxBuffNum; + handle->rxPtpTsDataRing.front = 0; + handle->rxPtpTsDataRing.end = 0; + handle->txPtpTsDataRing.ptpTsData = ptpConfig->txPtpTsData; + handle->txPtpTsDataRing.size = ptpConfig->ptpTsTxBuffNum; + handle->txPtpTsDataRing.front = 0; + handle->txPtpTsDataRing.end = 0; + handle->msTimerSecond = 0; + + /* Set the IRQ handler when the interrupt is enabled. */ + s_enetTxIsr = ENET_TransmitIRQHandler; + s_enetTsIsr = ENET_Ptp1588TimerIRQHandler; + + /* Enables the time stamp interrupt and transmit frame interrupt to + * handle the time-stamp . */ + ENET_EnableInterrupts(base, (ENET_TS_INTERRUPT | ENET_TX_INTERRUPT)); + ENET_DisableInterrupts(base, mask); + + EnableIRQ(s_enetTsIrqId[instance]); + EnableIRQ(s_enetTxIrqId[instance]); +} + +/*! + * brief Starts the ENET PTP 1588 Timer. + * This function is used to initialize the PTP timer. After the PTP starts, + * the PTP timer starts running. + * + * param base ENET peripheral base address. + * param ptpClkSrc The clock source of the PTP timer. + */ +void ENET_Ptp1588StartTimer(ENET_Type *base, uint32_t ptpClkSrc) +{ + /* Restart PTP 1588 timer, master clock. */ + base->ATCR = ENET_ATCR_RESTART_MASK; + + /* Initializes PTP 1588 timer. */ + base->ATINC = ENET_ATINC_INC(ENET_NANOSECOND_ONE_SECOND / ptpClkSrc); + base->ATPER = ENET_NANOSECOND_ONE_SECOND; + /* Sets periodical event and the event signal output assertion and Actives PTP 1588 timer. */ + base->ATCR = ENET_ATCR_PEREN_MASK | ENET_ATCR_PINPER_MASK | ENET_ATCR_EN_MASK; +} + +/*! + * brief Gets the current ENET time from the PTP 1588 timer. + * + * param base ENET peripheral base address. + * param handle The ENET state pointer. This is the same state pointer used in the ENET_Init. + * param ptpTime The PTP timer structure. + */ +void ENET_Ptp1588GetTimer(ENET_Type *base, enet_handle_t *handle, enet_ptp_time_t *ptpTime) +{ + assert(handle); + assert(ptpTime); + uint16_t count = ENET_1588TIME_DELAY_COUNT; + uint32_t primask; + + /* Disables the interrupt. */ + primask = DisableGlobalIRQ(); + + /* Get the current PTP time. */ + ptpTime->second = handle->msTimerSecond; + /* Get the nanosecond from the master timer. */ + base->ATCR |= ENET_ATCR_CAPTURE_MASK; + /* Add at least six clock cycle delay to get accurate time. + It's the requirement when the 1588 clock source is slower + than the register clock. + */ + while (count--) + { + __NOP(); + } + /* Get the captured time. */ + ptpTime->nanosecond = base->ATVR; + + /* Get PTP timer wrap event. */ + if (base->EIR & kENET_TsTimerInterrupt) + { + ptpTime->second++; + } + + /* Enables the interrupt. */ + EnableGlobalIRQ(primask); +} + +/*! + * brief Sets the ENET PTP 1588 timer to the assigned time. + * + * param base ENET peripheral base address. + * param handle The ENET state pointer. This is the same state pointer used in the ENET_Init. + * param ptpTime The timer to be set to the PTP timer. + */ +void ENET_Ptp1588SetTimer(ENET_Type *base, enet_handle_t *handle, enet_ptp_time_t *ptpTime) +{ + assert(handle); + assert(ptpTime); + + uint32_t primask; + + /* Disables the interrupt. */ + primask = DisableGlobalIRQ(); + + /* Sets PTP timer. */ + handle->msTimerSecond = ptpTime->second; + base->ATVR = ptpTime->nanosecond; + + /* Enables the interrupt. */ + EnableGlobalIRQ(primask); +} + +/*! + * brief Adjusts the ENET PTP 1588 timer. + * + * param base ENET peripheral base address. + * param corrIncrease The correction increment value. This value is added every time the correction + * timer expires. A value less than the PTP timer frequency(1/ptpClkSrc) slows down the timer, + * a value greater than the 1/ptpClkSrc speeds up the timer. + * param corrPeriod The PTP timer correction counter wrap-around value. This defines after how + * many timer clock the correction counter should be reset and trigger a correction + * increment on the timer. A value of 0 disables the correction counter and no correction occurs. + */ +void ENET_Ptp1588AdjustTimer(ENET_Type *base, uint32_t corrIncrease, uint32_t corrPeriod) +{ + /* Set correction for PTP timer increment. */ + base->ATINC = (base->ATINC & ~ENET_ATINC_INC_CORR_MASK) | (corrIncrease << ENET_ATINC_INC_CORR_SHIFT); + /* Set correction for PTP timer period. */ + base->ATCOR = (base->ATCOR & ~ENET_ATCOR_COR_MASK) | (corrPeriod << ENET_ATCOR_COR_SHIFT); +} + +static status_t ENET_Ptp1588UpdateTimeRing(enet_ptp_time_data_ring_t *ptpTsDataRing, enet_ptp_time_data_t *ptpTimeData) +{ + assert(ptpTsDataRing); + assert(ptpTsDataRing->ptpTsData); + assert(ptpTimeData); + + uint16_t usedBuffer = 0; + + /* Check if the buffers ring is full. */ + if (ptpTsDataRing->end >= ptpTsDataRing->front) + { + usedBuffer = ptpTsDataRing->end - ptpTsDataRing->front; + } + else + { + usedBuffer = ptpTsDataRing->size - (ptpTsDataRing->front - ptpTsDataRing->end); + } + + if (usedBuffer == (ptpTsDataRing->size - 1)) + { + /* Ptp timestamp ring full, drop one in the front. */ + ptpTsDataRing->front = (ptpTsDataRing->front + 1) % ptpTsDataRing->size; + } + + /* Copy the new data into the buffer. */ + memcpy((ptpTsDataRing->ptpTsData + ptpTsDataRing->end), ptpTimeData, sizeof(enet_ptp_time_data_t)); + + /* Increase the buffer pointer to the next empty one. */ + ptpTsDataRing->end = (ptpTsDataRing->end + 1) % ptpTsDataRing->size; + + return kStatus_Success; +} + +static status_t ENET_Ptp1588SearchTimeRing(enet_ptp_time_data_ring_t *ptpTsDataRing, enet_ptp_time_data_t *ptpTimedata) +{ + assert(ptpTsDataRing); + assert(ptpTsDataRing->ptpTsData); + assert(ptpTimedata); + + uint32_t index; + uint32_t size; + uint16_t usedBuffer = 0; + bool isRingBufferFull = false; + + /* Check the PTP 1588 timestamp ring. */ + if (ptpTsDataRing->front == ptpTsDataRing->end) + { + return kStatus_ENET_PtpTsRingEmpty; + } + + /* Check if buffers is full. */ + if (ptpTsDataRing->end >= ptpTsDataRing->front) + { + usedBuffer = ptpTsDataRing->end - ptpTsDataRing->front; + } + else + { + usedBuffer = ptpTsDataRing->size - (ptpTsDataRing->front - ptpTsDataRing->end); + } + + if (usedBuffer == (ptpTsDataRing->size-1)) + { + isRingBufferFull = true; + } + + /* Search the element in the ring buffer */ + index = ptpTsDataRing->front; + size = ptpTsDataRing->size; + while (index != ptpTsDataRing->end) + { + if (((ptpTsDataRing->ptpTsData + index)->sequenceId == ptpTimedata->sequenceId) && + (!memcmp(((void *)&(ptpTsDataRing->ptpTsData + index)->sourcePortId[0]), + (void *)&ptpTimedata->sourcePortId[0], kENET_PtpSrcPortIdLen)) && + ((ptpTsDataRing->ptpTsData + index)->version == ptpTimedata->version) && + ((ptpTsDataRing->ptpTsData + index)->messageType == ptpTimedata->messageType)) + { + break; + } + + /* Increase the ptp ring index. */ + index = (index + 1) % size; + } + + if (index == ptpTsDataRing->end) + { + if (isRingBufferFull == true) + { + /* PTP timestamp buffer ring full, data in index ptpTsDataRing->end is valid. */ + if (((ptpTsDataRing->ptpTsData + index)->sequenceId != ptpTimedata->sequenceId) || + (memcmp(((void *)&(ptpTsDataRing->ptpTsData + index)->sourcePortId[0]), + (void *)&ptpTimedata->sourcePortId[0], kENET_PtpSrcPortIdLen)) || + ((ptpTsDataRing->ptpTsData + index)->version != ptpTimedata->version) || + ((ptpTsDataRing->ptpTsData + index)->messageType != ptpTimedata->messageType)) + { + return kStatus_ENET_PtpTsRingFull; + } + } + else + { + return kStatus_ENET_PtpTsRingFull; + } + } + + /* Get the right timestamp of the required ptp messag. */ + ptpTimedata->timeStamp.second = (ptpTsDataRing->ptpTsData + index)->timeStamp.second; + ptpTimedata->timeStamp.nanosecond = (ptpTsDataRing->ptpTsData + index)->timeStamp.nanosecond; + + if( isRingBufferFull == true) + { + /* If ring buffer full, move front pointer to next pointer behind end pointer, then next + read will still read whole ring. */ + ptpTsDataRing->end = index; + } + + /* Drop previous ptp stamp. */ + ptpTsDataRing->front = (index + 1) % size; + + return kStatus_Success; +} + +static status_t ENET_StoreRxFrameTime(ENET_Type *base, enet_handle_t *handle, enet_ptp_time_data_t *ptpTimeData) +{ + assert(handle); + assert(ptpTimeData); + + enet_ptp_time_t ptpTimer; + + /* Get current PTP timer nanosecond value. */ + ENET_Ptp1588GetTimer(base, handle, &ptpTimer); + + /* Get transmit time stamp second. */ + if (ptpTimer.nanosecond >= ptpTimeData->timeStamp.nanosecond) + { + ptpTimeData->timeStamp.second = ptpTimer.second; + } + else + { + ptpTimeData->timeStamp.second = ptpTimer.second - 1; + } + + /* Store the timestamp to the receive time stamp ring. */ + /* Check if the buffers ring is full. */ + return ENET_Ptp1588UpdateTimeRing(&handle->rxPtpTsDataRing, ptpTimeData); +} + +static status_t ENET_StoreTxFrameTime(ENET_Type *base, enet_handle_t *handle, uint32_t ringId) +{ + assert(handle); + + bool isPtpEventMessage = false; + enet_ptp_time_data_t ptpTimeData; + volatile enet_tx_bd_struct_t *curBuffDescrip; + volatile enet_tx_bd_struct_t *endBuffDescrip; + uint32_t address; + bool isReadLastBd = false; + bool readLastBd = false; + + /* Treat the txBdCurrent[ringId] as the tx bd write buffer pointer, + txBdDirtyTime[ringId] as the tx bd read buffer pointer. Considering + that the tx frame time read is driven by tx frame send, so the read + pointer txBdDirtyTime[ringId] should always behind write pointer + txBdDirtyTime[ringId]. Then if the read pointer equals write pointer, + we could treat the tx bd buffer is full. We could read out all + available bds. */ + if(handle->txBdDirtyTime[ringId] == handle->txBdCurrent[ringId]) + { + isReadLastBd = true; + if(handle->txBdDirtyTime[ringId] == handle->txBdBase[ringId]) + { + endBuffDescrip = handle->txBdDirtyTime[ringId] + 3; + } + else + { + endBuffDescrip = handle->txBdDirtyTime[ringId] - 1; + } + } + else + { + endBuffDescrip = handle->txBdCurrent[ringId]; + } + + /* Read tx bd buffer until read pointer txBdDirtyTime[ringId] equals to the end pointer of + tx bd buffer. */ + while((handle->txBdDirtyTime[ringId] != endBuffDescrip) || (readLastBd == true)) + { + curBuffDescrip = handle->txBdDirtyTime[ringId]; + + /* Get the control status data, If the buffer descriptor has not been processed break out. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_READY_MASK) + { + return kStatus_ENET_TxFrameBusy; + } + + /* Parse the PTP message. */ + #if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET + address = MEMORY_ConvertMemoryMapAddress((uint32_t)curBuffDescrip->buffer, kMEMORY_DMA2Local); + #else + address = (uint32_t)curBuffDescrip->buffer; + #endif /* FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET */ + isPtpEventMessage = ENET_Ptp1588ParseFrame((uint8_t *)address, &ptpTimeData, false); + if (isPtpEventMessage) + { + /* Only store tx timestamp for ptp event message. */ + /* Increase current buffer descriptor to the next one. */ + if (handle->txBdDirtyTime[ringId]->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdDirtyTime[ringId] = handle->txBdBase[ringId]; + } + else + { + handle->txBdDirtyTime[ringId]++; + } + + /* Do time stamp check on the last buffer descriptor of the frame. */ + if (curBuffDescrip->control & ENET_BUFFDESCRIPTOR_TX_LAST_MASK) + { + /* Get current PTP timer nanosecond value. */ + ENET_Ptp1588GetTimer(base, handle, &ptpTimeData.timeStamp); + + /* Get transmit time stamp second. */ + if (ptpTimeData.timeStamp.nanosecond < curBuffDescrip->timestamp) + { + ptpTimeData.timeStamp.second--; + } + + /* Save transmit time stamp nanosecond. */ + ptpTimeData.timeStamp.nanosecond = curBuffDescrip->timestamp; + + /* Store the timestamp to the transmit timestamp ring. */ + ENET_Ptp1588UpdateTimeRing(&handle->txPtpTsDataRing, &ptpTimeData); + } + } + else + { + /* Only increase current buffer descriptor to the next one. */ + if (handle->txBdDirtyTime[ringId]->control & ENET_BUFFDESCRIPTOR_TX_WRAP_MASK) + { + handle->txBdDirtyTime[ringId] = handle->txBdBase[ringId]; + } + else + { + handle->txBdDirtyTime[ringId]++; + } + } + + if(readLastBd == true) + { + break; + } + + /* If if read pointer equals write pointer, the end pointer is set at the pointer before + current write pointer and the buffer in the end pointer is available, so read last bd at + the end pointer. */ + if((isReadLastBd == true) && (handle->txBdDirtyTime[ringId] == endBuffDescrip)) + { + readLastBd = true; + } + } + return kStatus_Success; +} + +/*! + * brief Gets the time stamp of the transmit frame. + * + * This function is used for PTP stack to get the timestamp captured by the ENET driver. + * + * param handle The ENET handler pointer.This is the same state pointer used in + * ENET_Init. + * param ptpTimeData The special PTP timestamp data for search the receive timestamp. + * retval kStatus_Success Get 1588 timestamp success. + * retval kStatus_ENET_PtpTsRingEmpty 1588 timestamp ring empty. + * retval kStatus_ENET_PtpTsRingFull 1588 timestamp ring full. + */ +status_t ENET_GetTxFrameTime(enet_handle_t *handle, enet_ptp_time_data_t *ptpTimeData) +{ + assert(handle); + assert(ptpTimeData); + + return ENET_Ptp1588SearchTimeRing(&handle->txPtpTsDataRing, ptpTimeData); +} + +/*! + * brief Gets the time stamp of the received frame. + * + * This function is used for PTP stack to get the timestamp captured by the ENET driver. + * + * param handle The ENET handler pointer.This is the same state pointer used in + * ENET_Init. + * param ptpTimeData The special PTP timestamp data for search the receive timestamp. + * retval kStatus_Success Get 1588 timestamp success. + * retval kStatus_ENET_PtpTsRingEmpty 1588 timestamp ring empty. + * retval kStatus_ENET_PtpTsRingFull 1588 timestamp ring full. + */ +status_t ENET_GetRxFrameTime(enet_handle_t *handle, enet_ptp_time_data_t *ptpTimeData) +{ + assert(handle); + assert(ptpTimeData); + + return ENET_Ptp1588SearchTimeRing(&handle->rxPtpTsDataRing, ptpTimeData); +} + +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB +/*! + * brief Sets the ENET AVB feature. + * + * ENET AVB feature configuration, set the Receive classification match and transmit + * bandwidth. This API is called when the AVB feature is required. + * + * Note: The AVB frames transmission scheme is credit-based tx scheme and it's only supported + * with the Enhanced buffer descriptors. so the AVB configuration should only done with + * Enhanced buffer descriptor. so when the AVB feature is required, please make sure the + * the "ENET_ENHANCEDBUFFERDESCRIPTOR_MODE" is defined. + * + * param base ENET peripheral base address. + * param handle ENET handler pointer. + * param config The ENET AVB feature configuration structure. + */ +void ENET_AVBConfigure(ENET_Type *base, enet_handle_t *handle, const enet_avb_config_t *config) +{ + assert(config); + + uint8_t count = 0; + + for (count = 0; count < FSL_FEATURE_ENET_QUEUE - 1; count++) + { + /* Set the AVB receive ring classification match when the match is not 0. */ + if (config->rxClassifyMatch[count]) + { + base->RCMR[count] = (config->rxClassifyMatch[count] & 0xFFFF) | ENET_RCMR_MATCHEN_MASK; + } + /* Set the dma controller for the extended ring. */ + base->DMACFG[count] |= ENET_DMACFG_IDLE_SLOPE(config->idleSlope[count]); + } + + /* Shall use the credit-based scheme for avb. */ + base->QOS &= ~ENET_QOS_TX_SCHEME_MASK; + base->QOS |= ENET_QOS_RX_FLUSH0_MASK; +} +#endif /* FSL_FETAURE_ENET_HAS_AVB */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +#if FSL_FEATURE_ENET_QUEUE > 1 +/*! + * brief The transmit IRQ handler. + * + * param base ENET peripheral base address. + * param handle The ENET handler pointer. + */ +void ENET_TransmitIRQHandler(ENET_Type *base, enet_handle_t *handle, uint32_t ringId) +#else +/*! + * brief The transmit IRQ handler. + * + * param base ENET peripheral base address. + * param handle The ENET handler pointer. + */ +void ENET_TransmitIRQHandler(ENET_Type *base, enet_handle_t *handle) +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ +{ + assert(handle); + uint32_t mask = kENET_TxBufferInterrupt | kENET_TxFrameInterrupt; +#if defined(ENET_ENHANCEDBUFFERDESCRIPTOR_MODE) || (FSL_FEATURE_ENET_QUEUE > 1) + uint32_t index = 0; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTORMODE || (FSL_FEATURE_ENET_QUEUE > 1) */ + +/* Check if the transmit interrupt happen. */ +#if FSL_FEATURE_ENET_QUEUE > 1 + switch (ringId) + { + case kENET_Ring1: + mask = (kENET_TxFrame1Interrupt | kENET_TxBuffer1Interrupt); + break; + case kENET_Ring2: + mask = (kENET_TxFrame2Interrupt | kENET_TxBuffer2Interrupt); + break; + default: + break; + } + index = ringId; +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + + while (mask & base->EIR) + { +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + if (base->EIR & kENET_TxFrameInterrupt) + { + /* Store the transmit timestamp from the buffer descriptor should be done here. */ + ENET_StoreTxFrameTime(base, handle, index); + } +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + + /* Clear the transmit interrupt event. */ + base->EIR = mask; + + /* Callback function. */ + if (handle->callback) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + handle->callback(base, handle, index, kENET_TxEvent, handle->userData); +#else + handle->callback(base, handle, kENET_TxEvent, handle->userData); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + } +} + +#if FSL_FEATURE_ENET_QUEUE > 1 +/*! + * brief The receive IRQ handler. + * + * param base ENET peripheral base address. + * param handle The ENET handler pointer. + */ +void ENET_ReceiveIRQHandler(ENET_Type *base, enet_handle_t *handle, uint32_t ringId) +#else +/*! + * brief The receive IRQ handler. + * + * param base ENET peripheral base address. + * param handle The ENET handler pointer. + */ +void ENET_ReceiveIRQHandler(ENET_Type *base, enet_handle_t *handle) +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ +{ + assert(handle); + uint32_t mask = kENET_RxFrameInterrupt | kENET_RxBufferInterrupt; + +/* Check if the receive interrupt happen. */ +#if FSL_FEATURE_ENET_QUEUE > 1 + switch (ringId) + { + case kENET_Ring1: + mask = (kENET_RxFrame1Interrupt | kENET_RxBuffer1Interrupt); + break; + case kENET_Ring2: + mask = (kENET_RxFrame2Interrupt | kENET_RxBuffer2Interrupt); + break; + default: + break; + } +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + + while (mask & base->EIR) + { + /* Clear the transmit interrupt event. */ + base->EIR = mask; + + /* Callback function. */ + if (handle->callback) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + handle->callback(base, handle, ringId, kENET_RxEvent, handle->userData); +#else + handle->callback(base, handle, kENET_RxEvent, handle->userData); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + } +} + +/*! + * brief Some special IRQ handler including the error, mii, wakeup irq handler. + * + * param base ENET peripheral base address. + * param handle The ENET handler pointer. + */ +void ENET_ErrorIRQHandler(ENET_Type *base, enet_handle_t *handle) +{ + assert(handle); + + uint32_t errMask = kENET_BabrInterrupt | kENET_BabtInterrupt | kENET_EBusERInterrupt | kENET_PayloadRxInterrupt | + kENET_LateCollisionInterrupt | kENET_RetryLimitInterrupt | kENET_UnderrunInterrupt; + + /* Check if the error interrupt happen. */ + if (kENET_WakeupInterrupt & base->EIR) + { + /* Clear the wakeup interrupt. */ + base->EIR = kENET_WakeupInterrupt; + /* wake up and enter the normal mode. */ + ENET_EnableSleepMode(base, false); + /* Callback function. */ + if (handle->callback) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + handle->callback(base, handle, 0, kENET_WakeUpEvent, handle->userData); +#else + handle->callback(base, handle, kENET_WakeUpEvent, handle->userData); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + } + else + { + /* Clear the error interrupt event status. */ + errMask &= base->EIR; + base->EIR = errMask; + /* Callback function. */ + if (handle->callback) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + handle->callback(base, handle, 0, kENET_ErrEvent, handle->userData); +#else + handle->callback(base, handle, kENET_ErrEvent, handle->userData); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + } +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! + * brief The IEEE 1588 PTP time stamp interrupt handler. + * + * param base ENET peripheral base address. + * param handle The ENET state pointer. This is the same state pointer used in the ENET_Init. + */ +void ENET_Ptp1588TimerIRQHandler(ENET_Type *base, enet_handle_t *handle) +{ + assert(handle); + + /* Check if the PTP time stamp interrupt happen. */ + if (kENET_TsTimerInterrupt & base->EIR) + { + /* Clear the time stamp interrupt. */ + base->EIR = kENET_TsTimerInterrupt; + + /* Increase timer second counter. */ + handle->msTimerSecond++; + + /* Callback function. */ + if (handle->callback) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + handle->callback(base, handle, 0, kENET_TimeStampEvent, handle->userData); +#else + handle->callback(base, handle, kENET_TimeStampEvent, handle->userData); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + } + else + { + /* Clear the time stamp interrupt. */ + base->EIR = kENET_TsAvailInterrupt; + /* Callback function. */ + if (handle->callback) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + handle->callback(base, handle, 0, kENET_TimeStampAvailEvent, handle->userData); +#else + handle->callback(base, handle, kENET_TimeStampAvailEvent, handle->userData); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + } +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +/*! + * brief the common IRQ handler for the tx/rx/error etc irq handler. + * + * This is used for the combined tx/rx/error interrupt for single/mutli-ring (frame 0). + * + * param base ENET peripheral base address. + */ +void ENET_CommonFrame0IRQHandler(ENET_Type *base) +{ + uint32_t event = base->EIR; + uint32_t instance = ENET_GetInstance(base); + + if (event & (kENET_TxBufferInterrupt | kENET_TxFrameInterrupt)) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + s_enetTxIsr(base, s_ENETHandle[instance], 0); +#else + s_enetTxIsr(base, s_ENETHandle[instance]); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + + if (event & (kENET_RxBufferInterrupt | kENET_RxFrameInterrupt)) + { +#if FSL_FEATURE_ENET_QUEUE > 1 + s_enetRxIsr(base, s_ENETHandle[instance], 0); +#else + s_enetRxIsr(base, s_ENETHandle[instance]); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + } + + if (event & ENET_TS_INTERRUPT) + { + s_enetTsIsr(base, s_ENETHandle[instance]); + } + if (event & ENET_ERR_INTERRUPT) + { + s_enetErrIsr(base, s_ENETHandle[instance]); + } +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +#if FSL_FEATURE_ENET_QUEUE > 1 +/*! + * brief the common IRQ handler for the tx/rx irq handler. + * + * This is used for the combined tx/rx interrupt for multi-ring (frame 1). + * + * param base ENET peripheral base address. + */ +void ENET_CommonFrame1IRQHandler(ENET_Type *base) +{ + uint32_t event = base->EIR; + uint32_t instance = ENET_GetInstance(base); + + if (event & (kENET_TxBuffer1Interrupt | kENET_TxFrame1Interrupt)) + { + s_enetTxIsr(base, s_ENETHandle[instance], 1); + } + + if (event & (kENET_RxBuffer1Interrupt | kENET_RxFrame1Interrupt)) + { + s_enetRxIsr(base, s_ENETHandle[instance], 1); + } +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +/*! + * brief the common IRQ handler for the tx/rx irq handler. + * + * This is used for the combined tx/rx interrupt for multi-ring (frame 2). + * + * param base ENET peripheral base address. + */ +void ENET_CommonFrame2IRQHandler(ENET_Type *base) +{ + uint32_t event = base->EIR; + uint32_t instance = ENET_GetInstance(base); + + if (event & (kENET_TxBuffer2Interrupt | kENET_TxFrame2Interrupt)) + { + s_enetTxIsr(base, s_ENETHandle[instance], 2); + } + + if (event & (kENET_RxBuffer2Interrupt | kENET_RxFrame2Interrupt)) + { + s_enetRxIsr(base, s_ENETHandle[instance], 2); + } +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + +#if defined(ENET) +void ENET_Transmit_IRQHandler(void) +{ + s_enetTxIsr(ENET, s_ENETHandle[0]); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +void ENET_Receive_IRQHandler(void) +{ + s_enetRxIsr(ENET, s_ENETHandle[0]); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +void ENET_Error_IRQHandler(void) +{ + s_enetErrIsr(ENET, s_ENETHandle[0]); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +void ENET_1588_Timer_IRQHandler(void) +{ + s_enetTsIsr(ENET, s_ENETHandle[0]); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +//void ENET_DriverIRQHandler(void) +void ENET_DriverIRQHandler(int vector, void *param) +{ + ENET_CommonFrame0IRQHandler(ENET); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} + +DECLARE_HW_IRQ(ENET_IRQn, ENET_DriverIRQHandler, NONE); + +#endif + +#if defined(ENET1) +void ENET1_DriverIRQHandler(void) +{ + ENET_CommonFrame0IRQHandler(ENET1); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#endif + +#if defined(ENET2) +void ENET2_DriverIRQHandler(void) +{ + ENET_CommonFrame0IRQHandler(ENET2); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#endif + +#if defined(CONNECTIVITY__ENET0) +void CONNECTIVITY_ENET0_FRAME0_EVENT_INT_DriverIRQHandler(void) +{ + ENET_CommonFrame0IRQHandler(CONNECTIVITY__ENET0); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#if FSL_FEATURE_ENET_QUEUE > 1 +void CONNECTIVITY_ENET0_FRAME1_INT_DriverIRQHandler(void) +{ + ENET_CommonFrame1IRQHandler(CONNECTIVITY__ENET0); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +void CONNECTIVITY_ENET0_FRAME2_INT_DriverIRQHandler(void) +{ + ENET_CommonFrame2IRQHandler(CONNECTIVITY__ENET0); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#endif +#endif +#if defined(CONNECTIVITY__ENET1) +void CONNECTIVITY_ENET1_FRAME0_EVENT_INT_DriverIRQHandler(void) +{ + ENET_CommonFrame0IRQHandler(CONNECTIVITY__ENET1); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#if FSL_FEATURE_ENET_QUEUE > 1 +void CONNECTIVITY_ENET1_FRAME1_INT_DriverIRQHandler(void) +{ + ENET_CommonFrame1IRQHandler(CONNECTIVITY__ENET1); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +void CONNECTIVITY_ENET1_FRAME2_INT_DriverIRQHandler(void) +{ + ENET_CommonFrame2IRQHandler(CONNECTIVITY__ENET1); +/* Add for ARM errata 838869, affects Cortex-M4, Cortex-M4F Store immediate overlapping + exception return operation might vector to incorrect interrupt */ +#if defined __CORTEX_M && (__CORTEX_M == 4U) + __DSB(); +#endif +} +#endif +#endif diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/Makefile new file mode 100755 index 00000000..b6d80e5e --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/Makefile @@ -0,0 +1,2 @@ +SRC_FILES := fsl_phy.c +include $(KERNEL_ROOT)/compiler.mk \ No newline at end of file diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/fsl_phy.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/fsl_phy.c new file mode 100755 index 00000000..4edcc918 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/fsl_phy.c @@ -0,0 +1,336 @@ +/* + * Copyright (c) 2015, Freescale Semiconductor, Inc. + * Copyright 2016-2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_phy.c + * @brief phy drivers for ksz8081 + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#include "lwipopts.h" +#include "fsl_phy.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! @brief Defines the timeout macro. */ +#define PHY_TIMEOUT_COUNT 100000 + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/*! + * @brief Get the ENET instance from peripheral base address. + * + * @param base ENET peripheral base address. + * @return ENET instance. + */ +extern uint32_t ENET_GetInstance(ENET_Type *base); + +/******************************************************************************* + * Variables + ******************************************************************************/ + +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) +/*! @brief Pointers to enet clocks for each instance. */ +extern clock_ip_name_t s_enetClock[FSL_FEATURE_SOC_ENET_COUNT]; +#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ + +/******************************************************************************* + * Code + ******************************************************************************/ + +status_t PHY_Init(ENET_Type *base, uint32_t phyAddr, uint32_t srcClock_Hz) +{ + uint32_t bssReg; + uint32_t counter = PHY_TIMEOUT_COUNT; + uint32_t idReg = 0; + status_t result = kStatus_Success; + uint32_t instance = ENET_GetInstance(base); + uint32_t timeDelay; + uint32_t ctlReg = 0; + +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) + /* Set SMI first. */ + CLOCK_EnableClock(s_enetClock[instance]); +#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ + ENET_SetSMI(base, srcClock_Hz, false); + + /* Initialization after PHY stars to work. */ + while ((idReg != PHY_CONTROL_ID1) && (counter != 0)) + { + PHY_Read(base, phyAddr, PHY_ID1_REG, &idReg); + counter--; + } + + if (!counter) + { + return kStatus_Fail; + } + + /* Reset PHY. */ + counter = PHY_TIMEOUT_COUNT; + result = PHY_Write(base, phyAddr, PHY_BASICCONTROL_REG, PHY_BCTL_RESET_MASK); + if (result == kStatus_Success) + { +#if defined(FSL_FEATURE_PHYKSZ8081_USE_RMII50M_MODE) + uint32_t data = 0; + result = PHY_Read(base, phyAddr, PHY_CONTROL2_REG, &data); + if (result != kStatus_Success) + { + return result; + } + result = PHY_Write(base, phyAddr, PHY_CONTROL2_REG, (data | PHY_CTL2_REFCLK_SELECT_MASK)); + if (result != kStatus_Success) + { + return result; + } +#endif /* FSL_FEATURE_PHYKSZ8081_USE_RMII50M_MODE */ + + /* Set the negotiation. */ + result = PHY_Write(base, phyAddr, PHY_AUTONEG_ADVERTISE_REG, + (PHY_100BASETX_FULLDUPLEX_MASK | PHY_100BASETX_HALFDUPLEX_MASK | + PHY_10BASETX_FULLDUPLEX_MASK | PHY_10BASETX_HALFDUPLEX_MASK | 0x1U)); + if (result == kStatus_Success) + { + result = + PHY_Write(base, phyAddr, PHY_BASICCONTROL_REG, (PHY_BCTL_AUTONEG_MASK | PHY_BCTL_RESTART_AUTONEG_MASK)); + if (result == kStatus_Success) + { + /* Check auto negotiation complete. */ + while (counter--) + { + result = PHY_Read(base, phyAddr, PHY_BASICSTATUS_REG, &bssReg); + if (result == kStatus_Success) + { + PHY_Read(base, phyAddr, PHY_CONTROL1_REG, &ctlReg); + if (((bssReg & PHY_BSTATUS_AUTONEGCOMP_MASK) != 0) && (ctlReg & PHY_LINK_READY_MASK)) + { + /* Wait a moment for Phy status stable. */ + for (timeDelay = 0; timeDelay < PHY_TIMEOUT_COUNT; timeDelay++) + { + __ASM("nop"); + } + break; + } + } + + if (!counter) + { + return kStatus_PHY_AutoNegotiateFail; + } + } + } + } + } + + return result; +} + +status_t PHY_Write(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t data) +{ + uint32_t counter; + + /* Clear the SMI interrupt event. */ + ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK); + + /* Starts a SMI write command. */ + ENET_StartSMIWrite(base, phyAddr, phyReg, kENET_MiiWriteValidFrame, data); + + /* Wait for SMI complete. */ + for (counter = PHY_TIMEOUT_COUNT; counter > 0; counter--) + { + if (ENET_GetInterruptStatus(base) & ENET_EIR_MII_MASK) + { + break; + } + } + + /* Check for timeout. */ + if (!counter) + { + return kStatus_PHY_SMIVisitTimeout; + } + + /* Clear MII interrupt event. */ + ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK); + + return kStatus_Success; +} + +status_t PHY_Read(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t *dataPtr) +{ + assert(dataPtr); + + uint32_t counter; + + /* Clear the MII interrupt event. */ + ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK); + + /* Starts a SMI read command operation. */ + ENET_StartSMIRead(base, phyAddr, phyReg, kENET_MiiReadValidFrame); + + /* Wait for MII complete. */ + for (counter = PHY_TIMEOUT_COUNT; counter > 0; counter--) + { + if (ENET_GetInterruptStatus(base) & ENET_EIR_MII_MASK) + { + break; + } + } + + /* Check for timeout. */ + if (!counter) + { + return kStatus_PHY_SMIVisitTimeout; + } + + /* Get data from MII register. */ + *dataPtr = ENET_ReadSMIData(base); + + /* Clear MII interrupt event. */ + ENET_ClearInterruptStatus(base, ENET_EIR_MII_MASK); + + return kStatus_Success; +} + +status_t PHY_EnableLoopback(ENET_Type *base, uint32_t phyAddr, phy_loop_t mode, phy_speed_t speed, bool enable) +{ + status_t result; + uint32_t data = 0; + + /* Set the loop mode. */ + if (enable) + { + if (mode == kPHY_LocalLoop) + { + if (speed == kPHY_Speed100M) + { + data = PHY_BCTL_SPEED_100M_MASK | PHY_BCTL_DUPLEX_MASK | PHY_BCTL_LOOP_MASK; + } + else + { + data = PHY_BCTL_DUPLEX_MASK | PHY_BCTL_LOOP_MASK; + } + return PHY_Write(base, phyAddr, PHY_BASICCONTROL_REG, data); + } + else + { + /* First read the current status in control register. */ + result = PHY_Read(base, phyAddr, PHY_CONTROL2_REG, &data); + if (result == kStatus_Success) + { + return PHY_Write(base, phyAddr, PHY_CONTROL2_REG, (data | PHY_CTL2_REMOTELOOP_MASK)); + } + } + } + else + { + /* Disable the loop mode. */ + if (mode == kPHY_LocalLoop) + { + /* First read the current status in control register. */ + result = PHY_Read(base, phyAddr, PHY_BASICCONTROL_REG, &data); + if (result == kStatus_Success) + { + data &= ~PHY_BCTL_LOOP_MASK; + return PHY_Write(base, phyAddr, PHY_BASICCONTROL_REG, (data | PHY_BCTL_RESTART_AUTONEG_MASK)); + } + } + else + { + /* First read the current status in control one register. */ + result = PHY_Read(base, phyAddr, PHY_CONTROL2_REG, &data); + if (result == kStatus_Success) + { + return PHY_Write(base, phyAddr, PHY_CONTROL2_REG, (data & ~PHY_CTL2_REMOTELOOP_MASK)); + } + } + } + return result; +} + +status_t PHY_GetLinkStatus(ENET_Type *base, uint32_t phyAddr, bool *status) +{ + assert(status); + + status_t result = kStatus_Success; + uint32_t data; + + /* Read the basic status register. */ + result = PHY_Read(base, phyAddr, PHY_BASICSTATUS_REG, &data); + if (result == kStatus_Success) + { + if (!(PHY_BSTATUS_LINKSTATUS_MASK & data)) + { + /* link down. */ + *status = false; + } + else + { + /* link up. */ + *status = true; + } + } + return result; +} + +status_t PHY_GetLinkSpeedDuplex(ENET_Type *base, uint32_t phyAddr, phy_speed_t *speed, phy_duplex_t *duplex) +{ + assert(duplex); + + status_t result = kStatus_Success; + uint32_t data, ctlReg; + + + /* Read the control two register. */ + result = PHY_Read(base, phyAddr, PHY_CONTROL1_REG, &ctlReg); + if (result == kStatus_Success) + { + data = ctlReg & PHY_CTL1_SPEEDUPLX_MASK; + if ((PHY_CTL1_10FULLDUPLEX_MASK == data) || (PHY_CTL1_100FULLDUPLEX_MASK == data)) + { + /* Full duplex. */ + *duplex = kPHY_FullDuplex; + } + else + { + /* Half duplex. */ + *duplex = kPHY_HalfDuplex; + } + + data = ctlReg & PHY_CTL1_SPEEDUPLX_MASK; + if ((PHY_CTL1_100HALFDUPLEX_MASK == data) || (PHY_CTL1_100FULLDUPLEX_MASK == data)) + { + /* 100M speed. */ + *speed = kPHY_Speed100M; + } + else + { /* 10M speed. */ + *speed = kPHY_Speed10M; + } + } + + return result; +} diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/fsl_phy.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/fsl_phy.h new file mode 100755 index 00000000..4d7b8246 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/ethernet/ksz8081/fsl_phy.h @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2015, Freescale Semiconductor, Inc. + * Copyright 2016-2017 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_phy.h + * @brief phy drivers for ksz8081 + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#ifndef _FSL_PHY_H_ +#define _FSL_PHY_H_ + +#include "fsl_enet.h" + +/*! + * @addtogroup phy_driver + * @{ + */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! @brief PHY driver version */ +#define FSL_PHY_DRIVER_VERSION (MAKE_VERSION(2, 0, 0)) /*!< Version 2.0.0. */ + +/*! @brief Defines the PHY registers. */ +#define PHY_BASICCONTROL_REG 0x00U /*!< The PHY basic control register. */ +#define PHY_BASICSTATUS_REG 0x01U /*!< The PHY basic status register. */ +#define PHY_ID1_REG 0x02U /*!< The PHY ID one register. */ +#define PHY_ID2_REG 0x03U /*!< The PHY ID two register. */ +#define PHY_AUTONEG_ADVERTISE_REG 0x04U /*!< The PHY auto-negotiate advertise register. */ +#define PHY_CONTROL1_REG 0x1EU /*!< The PHY control one register. */ +#define PHY_CONTROL2_REG 0x1FU /*!< The PHY control two register. */ + +#define PHY_CONTROL_ID1 0x22U /*!< The PHY ID1*/ + +/*! @brief Defines the mask flag in basic control register. */ +#define PHY_BCTL_DUPLEX_MASK 0x0100U /*!< The PHY duplex bit mask. */ +#define PHY_BCTL_RESTART_AUTONEG_MASK 0x0200U /*!< The PHY restart auto negotiation mask. */ +#define PHY_BCTL_AUTONEG_MASK 0x1000U /*!< The PHY auto negotiation bit mask. */ +#define PHY_BCTL_SPEED_MASK 0x2000U /*!< The PHY speed bit mask. */ +#define PHY_BCTL_LOOP_MASK 0x4000U /*!< The PHY loop bit mask. */ +#define PHY_BCTL_RESET_MASK 0x8000U /*!< The PHY reset bit mask. */ +#define PHY_BCTL_SPEED_100M_MASK 0x2000U /*!< The PHY 100M speed mask. */ + +/*!@brief Defines the mask flag of operation mode in control two register*/ +#define PHY_CTL2_REMOTELOOP_MASK 0x0004U /*!< The PHY remote loopback mask. */ +#define PHY_CTL2_REFCLK_SELECT_MASK 0x0080U /*!< The PHY RMII reference clock select. */ +#define PHY_CTL1_10HALFDUPLEX_MASK 0x0001U /*!< The PHY 10M half duplex mask. */ +#define PHY_CTL1_100HALFDUPLEX_MASK 0x0002U /*!< The PHY 100M half duplex mask. */ +#define PHY_CTL1_10FULLDUPLEX_MASK 0x0005U /*!< The PHY 10M full duplex mask. */ +#define PHY_CTL1_100FULLDUPLEX_MASK 0x0006U /*!< The PHY 100M full duplex mask. */ +#define PHY_CTL1_SPEEDUPLX_MASK 0x0007U /*!< The PHY speed and duplex mask. */ +#define PHY_CTL1_ENERGYDETECT_MASK 0x10U /*!< The PHY signal present on rx differential pair. */ +#define PHY_CTL1_LINKUP_MASK 0x100U /*!< The PHY link up. */ +#define PHY_LINK_READY_MASK (PHY_CTL1_ENERGYDETECT_MASK | PHY_CTL1_LINKUP_MASK) + +/*! @brief Defines the mask flag in basic status register. */ +#define PHY_BSTATUS_LINKSTATUS_MASK 0x0004U /*!< The PHY link status mask. */ +#define PHY_BSTATUS_AUTONEGABLE_MASK 0x0008U /*!< The PHY auto-negotiation ability mask. */ +#define PHY_BSTATUS_AUTONEGCOMP_MASK 0x0020U /*!< The PHY auto-negotiation complete mask. */ + +/*! @brief Defines the mask flag in PHY auto-negotiation advertise register. */ +#define PHY_100BaseT4_ABILITY_MASK 0x200U /*!< The PHY have the T4 ability. */ +#define PHY_100BASETX_FULLDUPLEX_MASK 0x100U /*!< The PHY has the 100M full duplex ability.*/ +#define PHY_100BASETX_HALFDUPLEX_MASK 0x080U /*!< The PHY has the 100M full duplex ability.*/ +#define PHY_10BASETX_FULLDUPLEX_MASK 0x040U /*!< The PHY has the 10M full duplex ability.*/ +#define PHY_10BASETX_HALFDUPLEX_MASK 0x020U /*!< The PHY has the 10M full duplex ability.*/ + +/*! @brief Defines the PHY status. */ +enum _phy_status +{ + kStatus_PHY_SMIVisitTimeout = MAKE_STATUS(kStatusGroup_PHY, 1), /*!< ENET PHY SMI visit timeout. */ + kStatus_PHY_AutoNegotiateFail = MAKE_STATUS(kStatusGroup_PHY, 2) /*!< ENET PHY AutoNegotiate Fail. */ +}; + +/*! @brief Defines the PHY link speed. This is align with the speed for ENET MAC. */ +typedef enum _phy_speed +{ + kPHY_Speed10M = 0U, /*!< ENET PHY 10M speed. */ + kPHY_Speed100M /*!< ENET PHY 100M speed. */ +} phy_speed_t; + +/*! @brief Defines the PHY link duplex. */ +typedef enum _phy_duplex +{ + kPHY_HalfDuplex = 0U, /*!< ENET PHY half duplex. */ + kPHY_FullDuplex /*!< ENET PHY full duplex. */ +} phy_duplex_t; + +/*! @brief Defines the PHY loopback mode. */ +typedef enum _phy_loop +{ + kPHY_LocalLoop = 0U, /*!< ENET PHY local loopback. */ + kPHY_RemoteLoop /*!< ENET PHY remote loopback. */ +} phy_loop_t; + +/******************************************************************************* + * API + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif + +/*! + * @name PHY Driver + * @{ + */ + +/*! + * @brief Initializes PHY. + * + * This function initialize the SMI interface and initialize PHY. + * The SMI is the MII management interface between PHY and MAC, which should be + * firstly initialized before any other operation for PHY. The PHY initialize with auto-negotiation. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param srcClock_Hz The module clock frequency - system clock for MII management interface - SMI. + * @retval kStatus_Success PHY initialize success + * @retval kStatus_PHY_SMIVisitTimeout PHY SMI visit time out + * @retval kStatus_PHY_AutoNegotiateFail PHY auto negotiate fail + */ +status_t PHY_Init(ENET_Type *base, uint32_t phyAddr, uint32_t srcClock_Hz); + +/*! + * @brief PHY Write function. This function write data over the SMI to + * the specified PHY register. This function is called by all PHY interfaces. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param phyReg The PHY register. + * @param data The data written to the PHY register. + * @retval kStatus_Success PHY write success + * @retval kStatus_PHY_SMIVisitTimeout PHY SMI visit time out + */ +status_t PHY_Write(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t data); + +/*! + * @brief PHY Read function. This interface read data over the SMI from the + * specified PHY register. This function is called by all PHY interfaces. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param phyReg The PHY register. + * @param dataPtr The address to store the data read from the PHY register. + * @retval kStatus_Success PHY read success + * @retval kStatus_PHY_SMIVisitTimeout PHY SMI visit time out + */ +status_t PHY_Read(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t *dataPtr); + +/*! + * @brief Enables/disables PHY loopback. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param mode The loopback mode to be enabled, please see "phy_loop_t". + * the two loopback mode should not be both set. when one loopback mode is set + * the other one should be disabled. + * @param speed PHY speed for loopback mode. + * @param enable True to enable, false to disable. + * @retval kStatus_Success PHY loopback success + * @retval kStatus_PHY_SMIVisitTimeout PHY SMI visit time out + */ +status_t PHY_EnableLoopback(ENET_Type *base, uint32_t phyAddr, phy_loop_t mode, phy_speed_t speed, bool enable); + +/*! + * @brief Gets the PHY link status. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param status The link up or down status of the PHY. + * - true the link is up. + * - false the link is down. + * @retval kStatus_Success PHY get link status success + * @retval kStatus_PHY_SMIVisitTimeout PHY SMI visit time out + */ +status_t PHY_GetLinkStatus(ENET_Type *base, uint32_t phyAddr, bool *status); + +/*! + * @brief Gets the PHY link speed and duplex. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param speed The address of PHY link speed. + * @param duplex The link duplex of PHY. + * @retval kStatus_Success PHY get link speed and duplex success + * @retval kStatus_PHY_SMIVisitTimeout PHY SMI visit time out + */ +status_t PHY_GetLinkSpeedDuplex(ENET_Type *base, uint32_t phyAddr, phy_speed_t *speed, phy_duplex_t *duplex); + +/* @} */ + +#if defined(__cplusplus) +} +#endif + +/*! @}*/ + +#endif /* _FSL_PHY_H_ */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/gpio/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/gpio/Makefile new file mode 100755 index 00000000..2776af73 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/gpio/Makefile @@ -0,0 +1,3 @@ +SRC_FILES := fsl_gpio.c + +include $(KERNEL_ROOT)/compiler.mk \ No newline at end of file diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/gpio/fsl_gpio.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/gpio/fsl_gpio.c new file mode 100755 index 00000000..d2de24c3 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/gpio/fsl_gpio.c @@ -0,0 +1,171 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2017 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include "fsl_gpio.h" + +/* Component ID definition, used by tools. */ +#ifndef FSL_COMPONENT_ID +#define FSL_COMPONENT_ID "platform.drivers.igpio" +#endif + +/******************************************************************************* + * Variables + ******************************************************************************/ + +/* Array of GPIO peripheral base address. */ +static GPIO_Type *const s_gpioBases[] = GPIO_BASE_PTRS; + +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) +/* Array of GPIO clock name. */ +static const clock_ip_name_t s_gpioClock[] = GPIO_CLOCKS; +#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/*! + * @brief Gets the GPIO instance according to the GPIO base + * + * @param base GPIO peripheral base pointer(PTA, PTB, PTC, etc.) + * @retval GPIO instance + */ +static uint32_t GPIO_GetInstance(GPIO_Type *base); + +/******************************************************************************* + * Code + ******************************************************************************/ + +static uint32_t GPIO_GetInstance(GPIO_Type *base) +{ + uint32_t instance; + + /* Find the instance index from base address mappings. */ + for (instance = 0; instance < ARRAY_SIZE(s_gpioBases); instance++) + { + if (s_gpioBases[instance] == base) + { + break; + } + } + + assert(instance < ARRAY_SIZE(s_gpioBases)); + + return instance; +} + +/*! + * brief Initializes the GPIO peripheral according to the specified + * parameters in the initConfig. + * + * param base GPIO base pointer. + * param pin Specifies the pin number + * param initConfig pointer to a ref gpio_pin_config_t structure that + * contains the configuration information. + */ +void GPIO_PinInit(GPIO_Type *base, uint32_t pin, const gpio_pin_config_t *Config) +{ +#if !(defined(FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) && FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL) + /* Enable GPIO clock. */ + uint32_t instance = GPIO_GetInstance(base); + + /* If The clock IP is valid, enable the clock gate. */ + if ((instance < ARRAY_SIZE(s_gpioClock)) && (kCLOCK_IpInvalid != s_gpioClock[instance])) + { + CLOCK_EnableClock(s_gpioClock[instance]); + } +#endif /* FSL_SDK_DISABLE_DRIVER_CLOCK_CONTROL */ + + /* Register reset to default value */ + base->IMR &= ~(1U << pin); + + /* Configure GPIO pin direction */ + if (Config->direction == kGPIO_DigitalInput) + { + base->GDIR &= ~(1U << pin); + } + else + { + GPIO_PinWrite(base, pin, Config->outputLogic); + base->GDIR |= (1U << pin); + } + + /* Configure GPIO pin interrupt mode */ + GPIO_SetPinInterruptConfig(base, pin, Config->interruptMode); +} + +/*! + * brief Sets the output level of the individual GPIO pin to logic 1 or 0. + * + * param base GPIO base pointer. + * param pin GPIO port pin number. + * param output GPIOpin output logic level. + * - 0: corresponding pin output low-logic level. + * - 1: corresponding pin output high-logic level. + */ +void GPIO_PinWrite(GPIO_Type *base, uint32_t pin, uint8_t output) +{ + assert(pin < 32); + if (output == 0U) + { + base->DR &= ~(1U << pin); /* Set pin output to low level.*/ + } + else + { + base->DR |= (1U << pin); /* Set pin output to high level.*/ + } +} + +/*! + * brief Sets the current pin interrupt mode. + * + * param base GPIO base pointer. + * param pin GPIO port pin number. + * param pininterruptMode pointer to a ref gpio_interrupt_mode_t structure + * that contains the interrupt mode information. + */ +void GPIO_PinSetInterruptConfig(GPIO_Type *base, uint32_t pin, gpio_interrupt_mode_t pinInterruptMode) +{ + volatile uint32_t *icr; + uint32_t icrShift; + + icrShift = pin; + + /* Register reset to default value */ + base->EDGE_SEL &= ~(1U << pin); + + if (pin < 16) + { + icr = &(base->ICR1); + } + else + { + icr = &(base->ICR2); + icrShift -= 16; + } + switch (pinInterruptMode) + { + case (kGPIO_IntLowLevel): + *icr &= ~(3U << (2 * icrShift)); + break; + case (kGPIO_IntHighLevel): + *icr = (*icr & (~(3U << (2 * icrShift)))) | (1U << (2 * icrShift)); + break; + case (kGPIO_IntRisingEdge): + *icr = (*icr & (~(3U << (2 * icrShift)))) | (2U << (2 * icrShift)); + break; + case (kGPIO_IntFallingEdge): + *icr |= (3U << (2 * icrShift)); + break; + case (kGPIO_IntRisingOrFallingEdge): + base->EDGE_SEL |= (1U << pin); + break; + default: + break; + } +} diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/MIMXRT1052.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/MIMXRT1052.h old mode 100644 new mode 100755 similarity index 100% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/MIMXRT1052.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/MIMXRT1052.h diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/MIMXRT1052_features.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/MIMXRT1052_features.h old mode 100644 new mode 100755 similarity index 100% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/MIMXRT1052_features.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/MIMXRT1052_features.h diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/connect_ethernet.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/connect_ethernet.h new file mode 100755 index 00000000..fa18d0e8 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/connect_ethernet.h @@ -0,0 +1,75 @@ +/** + ****************************************************************************** + * @file connect_ethernet.h + * @author MCD Application Team + * @version V1.0.0 + * @date 31-October-2011 + * @brief STM32F4x7 Ethernet hardware configuration. + ****************************************************************************** + * @attention + * + * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS + * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE + * TIME. AS A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY + * DIRECT, INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING + * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE + * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. + * + *

© COPYRIGHT 2011 STMicroelectronics

+ ****************************************************************************** + */ + + /* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file connect_ethernet.h +* @brief Adapted network software protocol stack and hardware operation functions +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-12-7 +*/ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __ETH_BSP_H +#define __ETH_BSP_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* Includes ------------------------------------------------------------------*/ + + + +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ + + +/* Exported macro ------------------------------------------------------------*/ + +#ifndef sourceClock +#define sourceClock CLOCK_GetFreq(kCLOCK_CoreSysClk) +#endif + +/* Exported functions ------------------------------------------------------- */ + +void enet_delay(void); + +#ifdef __cplusplus +} +#endif + +#endif /* __STM32F4x7_ETH_BSP_H */ + + +/******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/enet_ethernetif.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/enet_ethernetif.h new file mode 100755 index 00000000..b7009bc3 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/enet_ethernetif.h @@ -0,0 +1,202 @@ +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/* + * Copyright (c) 2013-2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file enet_ethernetif.h + * @brief ethernet drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + + +#ifndef ENET_ETHERNETIF_H +#define ENET_ETHERNETIF_H + +#include "lwip/err.h" +#include "lwip/netif.h" +#include "fsl_enet.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ +#ifndef ENET_RXBD_NUM + #define ENET_RXBD_NUM (5) +#endif +#ifndef ENET_TXBD_NUM +#if defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0) + #define ENET_TXBD_NUM (5) +#else + #define ENET_TXBD_NUM (3) +#endif +#endif +#ifndef ENET_RXBUFF_SIZE +#if defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0) + #define ENET_RXBUFF_SIZE (ENET_FRAME_MAX_FRAMELEN + ETH_PAD_SIZE) +#else + #define ENET_RXBUFF_SIZE ENET_FRAME_MAX_FRAMELEN +#endif +#endif + +#ifndef ENET_TXBUFF_SIZE + #define ENET_TXBUFF_SIZE (ENET_FRAME_MAX_FRAMELEN) +#endif + +#define ENET_TIMEOUT (0xFFFU) + +/* ENET IRQ priority. Used in FreeRTOS. */ +/* Interrupt priorities. */ +#ifdef __CA7_REV +#ifndef ENET_PRIORITY + #define ENET_PRIORITY (21U) +#endif +#ifndef ENET_1588_PRIORITY + #define ENET_1588_PRIORITY (20U) +#endif +#else +#ifndef ENET_PRIORITY + #define ENET_PRIORITY (15U)//(6U) +#endif +#ifndef ENET_1588_PRIORITY + #define ENET_1588_PRIORITY (5U) +#endif +#endif + +/* Defines Ethernet Autonegotiation Timeout during initialization. + * Set it to 0 to disable the waiting. */ +#ifndef ENET_ATONEGOTIATION_TIMEOUT + #define ENET_ATONEGOTIATION_TIMEOUT (0xFFFU) +#endif + +/* Define those to better describe your network interface. */ +#define IFNAME0 'e' +#define IFNAME1 'n' + +#if defined(FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL) && FSL_SDK_ENABLE_DRIVER_CACHE_CONTROL + #if defined(FSL_FEATURE_L2CACHE_LINESIZE_BYTE) \ + && ((!defined(FSL_SDK_DISBLE_L2CACHE_PRESENT)) || (FSL_SDK_DISBLE_L2CACHE_PRESENT == 0)) + #if defined(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE) + #define FSL_CACHE_LINESIZE_MAX MAX(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE, FSL_FEATURE_L2CACHE_LINESIZE_BYTE) + #define FSL_ENET_BUFF_ALIGNMENT MAX(ENET_BUFF_ALIGNMENT, FSL_CACHE_LINESIZE_MAX) + #else + #define FSL_ENET_BUFF_ALIGNMENT MAX(ENET_BUFF_ALIGNMENT, FSL_FEATURE_L2CACHE_LINESIZE_BYTE) + #endif + #elif defined(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE) + #define FSL_ENET_BUFF_ALIGNMENT MAX(ENET_BUFF_ALIGNMENT, FSL_FEATURE_L1DCACHE_LINESIZE_BYTE) + #else + #define FSL_ENET_BUFF_ALIGNMENT ENET_BUFF_ALIGNMENT + #endif +#else + #define FSL_ENET_BUFF_ALIGNMENT ENET_BUFF_ALIGNMENT +#endif + +#define ENET_RING_NUM 1U + +typedef uint8_t rx_buffer_t[SDK_SIZEALIGN(ENET_RXBUFF_SIZE, FSL_ENET_BUFF_ALIGNMENT)]; +typedef uint8_t tx_buffer_t[SDK_SIZEALIGN(ENET_TXBUFF_SIZE, FSL_ENET_BUFF_ALIGNMENT)]; + +#if (defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0)) +typedef struct mem_range +{ + uint32_t start; + uint32_t end; +} mem_range_t; +#endif /* FSL_FEATURE_SOC_LPC_ENET_COUNT */ + +/** + * Helper struct to hold data for configuration of ethernet interface. + */ +typedef struct ethernetif_config +{ + uint32_t phyAddress; + clock_name_t clockName; + uint8_t macAddress[NETIF_MAX_HWADDR_LEN]; +#if (defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0)) + const mem_range_t *non_dma_memory; +#endif /* FSL_FEATURE_SOC_LPC_ENET_COUNT */ +} ethernetif_config_t; + +#if defined(__cplusplus) +extern "C" { +#endif /* __cplusplus */ + +/** + * This function should be passed as a parameter to netif_add() + * if you initialize the first ENET interface. + */ +err_t ethernetif0_init(struct netif *netif); + +#if (defined(FSL_FEATURE_SOC_ENET_COUNT) && (FSL_FEATURE_SOC_ENET_COUNT > 1)) \ + || (defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 1)) +/** + * This function should be passed as a parameter to netif_add() + * if you initialize the second ENET interface. + */ +err_t ethernetif1_init(struct netif *netif); +#endif /* FSL_FEATURE_SOC_*_ENET_COUNT */ + +/** + * This function should be called when a packet is ready to be read + * from the interface. + * It is used by bare-metal applications. + * + * @param netif the lwip network interface structure for this ethernetif + */ +void ethernetif_input( struct netif *netif); + +void ETH_BSP_Config(void); + +#if defined(__cplusplus) +} +#endif /* __cplusplus */ + +#endif /* ENET_ETHERNETIF_H */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/enet_ethernetif_priv.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/enet_ethernetif_priv.h new file mode 100755 index 00000000..7fa9050b --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/enet_ethernetif_priv.h @@ -0,0 +1,94 @@ +/* + * Copyright 2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file enet_ethernetif_priv.h + * @brief ethernet drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + + +#ifndef ENET_ETHERNETIF_PRIV_H +#define ENET_ETHERNETIF_PRIV_H + +#include "lwip/err.h" + +struct ethernetif; + +#if defined(__cplusplus) +extern "C" { +#endif /* __cplusplus */ + +err_t ethernetif_init(struct netif *netif, struct ethernetif *ethernetif, + const uint8_t enetIdx, + const ethernetif_config_t *ethernetifConfig); + +void ethernetif_enet_init(struct netif *netif, struct ethernetif *ethernetif, + const ethernetif_config_t *ethernetifConfig); + +void ethernetif_phy_init(struct ethernetif *ethernetif, + const ethernetif_config_t *ethernetifConfig, + enet_config_t *config); + +ENET_Type **ethernetif_enet_ptr(struct ethernetif *ethernetif); + +#if LWIP_IPV4 && LWIP_IGMP +err_t ethernetif_igmp_mac_filter(struct netif *netif, const ip4_addr_t *group, + enum netif_mac_filter_action action); +#endif + +#if LWIP_IPV6 && LWIP_IPV6_MLD +err_t ethernetif_mld_mac_filter(struct netif *netif, const ip6_addr_t *group, + enum netif_mac_filter_action action); +#endif + +/** + * Should allocate a pbuf and transfer the bytes of the incoming + * packet from the interface into the pbuf. + * + * @param netif the lwip network interface structure for this ethernetif + * @return a pbuf filled with the received packet (including MAC header) + * NULL on memory error + */ +struct pbuf *ethernetif_linkinput(struct netif *netif); + +/** + * This function should do the actual transmission of the packet. The packet is + * contained in the pbuf that is passed to the function. This pbuf + * might be chained. + * + * @param netif the lwip network interface structure for this ethernetif + * @param p the MAC packet to send (e.g. IP packet including MAC addresses and type) + * @return ERR_OK if the packet could be sent + * an err_t value if the packet couldn't be sent + * + * @note Returning ERR_MEM here if a DMA queue of your MAC is full can lead to + * strange results. You might consider waiting for space in the DMA queue + * to become available since the stack doesn't retry to send a packet + * dropped because of memory failure (except for the TCP timers). + */ +err_t ethernetif_linkoutput(struct netif *netif, struct pbuf *p); + +#if defined(__cplusplus) +} +#endif /* __cplusplus */ + +#endif /* ENET_ETHERNETIF_PRIV_H */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_cache.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_cache.h new file mode 100755 index 00000000..daf80e3d --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_cache.h @@ -0,0 +1,488 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2017 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_cache.h + * @brief cache drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#ifndef _FSL_CACHE_H_ +#define _FSL_CACHE_H_ + +#include "fsl_common.h" + +/*! + * @addtogroup cache + * @{ + */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! @name Driver version */ +/*@{*/ +/*! @brief cache driver version 2.0.1. */ +#define FSL_CACHE_DRIVER_VERSION (MAKE_VERSION(2, 0, 1)) +/*@}*/ + +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT +#ifndef FSL_SDK_DISBLE_L2CACHE_PRESENT +#define FSL_SDK_DISBLE_L2CACHE_PRESENT 0 +#endif +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ +/******************************************************************************* + * Definitions + ******************************************************************************/ +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT + +/*! @brief Number of level 2 cache controller ways. */ +typedef enum _l2cache_way_num +{ + kL2CACHE_8ways = 0, /*!< 8 ways. */ +#if defined(FSL_FEATURE_L2CACHE_SUPPORT_16_WAY_ASSOCIATIVITY) && FSL_FEATURE_L2CACHE_SUPPORT_16_WAY_ASSOCIATIVITY + kL2CACHE_16ways /*!< 16 ways. */ +#endif /* FSL_FEATURE_L2CACHE_SUPPORT_16_WAY_ASSOCIATIVITY */ +} l2cache_way_num_t; + +/*! @brief Level 2 cache controller way size. */ +typedef enum _l2cache_way_size +{ + kL2CACHE_16KBSize = 1, /*!< 16 KB way size. */ + kL2CACHE_32KBSize = 2, /*!< 32 KB way size. */ + kL2CACHE_64KBSize = 3, /*!< 64 KB way size. */ + kL2CACHE_128KBSize = 4, /*!< 128 KB way size. */ + kL2CACHE_256KBSize = 5, /*!< 256 KB way size. */ + kL2CACHE_512KBSize = 6 /*!< 512 KB way size. */ +} l2cache_way_size; + +/*! @brief Level 2 cache controller replacement policy. */ +typedef enum _l2cache_replacement +{ + kL2CACHE_Pseudorandom = 0U, /*!< Peseudo-random replacement policy using an lfsr. */ + kL2CACHE_Roundrobin /*!< Round-robin replacemnt policy. */ +} l2cache_replacement_t; + +/*! @brief Level 2 cache controller force write allocate options. */ +typedef enum _l2cache_writealloc +{ + kL2CACHE_UseAwcache = 0, /*!< Use AWCAHE attribute for the write allocate. */ + kL2CACHE_NoWriteallocate, /*!< Force no write allocate. */ + kL2CACHE_forceWriteallocate /*!< Force write allocate when write misses. */ +} l2cache_writealloc_t; + +/*! @brief Level 2 cache controller tag/data ram latency. */ +typedef enum _l2cache_latency +{ + kL2CACHE_1CycleLate = 0, /*!< 1 cycle of latency. */ + kL2CACHE_2CycleLate, /*!< 2 cycle of latency. */ + kL2CACHE_3CycleLate, /*!< 3 cycle of latency. */ + kL2CACHE_4CycleLate, /*!< 4 cycle of latency. */ + kL2CACHE_5CycleLate, /*!< 5 cycle of latency. */ + kL2CACHE_6CycleLate, /*!< 6 cycle of latency. */ + kL2CACHE_7CycleLate, /*!< 7 cycle of latency. */ + kL2CACHE_8CycleLate /*!< 8 cycle of latency. */ +} l2cache_latency_t; + +/*! @brief Level 2 cache controller tag/data ram latency configure structure. */ +typedef struct _l2cache_latency_config +{ + l2cache_latency_t tagWriteLate; /*!< Tag write latency. */ + l2cache_latency_t tagReadLate; /*!< Tag Read latency. */ + l2cache_latency_t tagSetupLate; /*!< Tag setup latency. */ + l2cache_latency_t dataWriteLate; /*!< Data write latency. */ + l2cache_latency_t dataReadLate; /*!< Data Read latency. */ + l2cache_latency_t dataSetupLate; /*!< Data setup latency. */ +} L2cache_latency_config_t; + +/*! @brief Level 2 cache controller configure structure. */ +typedef struct _l2cache_config +{ + /* ------------------------ l2 cachec basic settings ---------------------------- */ + l2cache_way_num_t wayNum; /*!< The number of ways. */ + l2cache_way_size waySize; /*!< The way size = Cache Ram size / wayNum. */ + l2cache_replacement_t repacePolicy; /*!< Replacemnet policy. */ + /* ------------------------ tag/data ram latency settings ----------------------- */ + L2cache_latency_config_t *lateConfig; /*!< Tag/data latency configure. Set NUll if not required. */ + /* ------------------------ Prefetch enable settings ---------------------------- */ + bool istrPrefetchEnable; /*!< Instruction prefetch enable. */ + bool dataPrefetchEnable; /*!< Data prefetch enable. */ + /* ------------------------ Non-secure access settings -------------------------- */ + bool nsLockdownEnable; /*!< None-secure lockdown enable. */ + /* ------------------------ other settings -------------------------------------- */ + l2cache_writealloc_t writeAlloc; /*!< Write allcoate force option. */ +} l2cache_config_t; +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ +/******************************************************************************* + * API + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif + +/*! + * @name Control for cortex-m7 L1 cache + *@{ + */ + +/*! + * @brief Enables cortex-m7 L1 instruction cache. + * + */ +static inline void L1CACHE_EnableICache(void) +{ + SCB_EnableICache(); +} + +/*! + * @brief Disables cortex-m7 L1 instruction cache. + * + */ +static inline void L1CACHE_DisableICache(void) +{ + SCB_DisableICache(); +} + +/*! + * @brief Invalidate cortex-m7 L1 instruction cache. + * + */ +static inline void L1CACHE_InvalidateICache(void) +{ + SCB_InvalidateICache(); +} + +/*! + * @brief Invalidate cortex-m7 L1 instruction cache by range. + * + * @param address The start address of the memory to be invalidated. + * @param size_byte The memory size. + * @note The start address and size_byte should be 32-byte(FSL_FEATURE_L1ICACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L1 I-cache line size if + * startAddr is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L1CACHE_InvalidateICacheByRange(uint32_t address, uint32_t size_byte); + +/*! + * @brief Enables cortex-m7 L1 data cache. + * + */ +static inline void L1CACHE_EnableDCache(void) +{ + SCB_EnableDCache(); +} + +/*! + * @brief Disables cortex-m7 L1 data cache. + * + */ +static inline void L1CACHE_DisableDCache(void) +{ + SCB_DisableDCache(); +} + +/*! + * @brief Invalidates cortex-m7 L1 data cache. + * + */ +static inline void L1CACHE_InvalidateDCache(void) +{ + SCB_InvalidateDCache(); +} + +/*! + * @brief Cleans cortex-m7 L1 data cache. + * + */ +static inline void L1CACHE_CleanDCache(void) +{ + SCB_CleanDCache(); +} + +/*! + * @brief Cleans and Invalidates cortex-m7 L1 data cache. + * + */ +static inline void L1CACHE_CleanInvalidateDCache(void) +{ + SCB_CleanInvalidateDCache(); +} + +/*! + * @brief Invalidates cortex-m7 L1 data cache by range. + * + * @param address The start address of the memory to be invalidated. + * @param size_byte The memory size. + * @note The start address and size_byte should be 32-byte(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L1 D-cache line size if + * startAddr is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +static inline void L1CACHE_InvalidateDCacheByRange(uint32_t address, uint32_t size_byte) +{ + uint32_t startAddr = address & (uint32_t) ~(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE - 1); + uint32_t size = size_byte + address - startAddr; + + SCB_InvalidateDCache_by_Addr((uint32_t *)startAddr, size); +} + +/*! + * @brief Cleans cortex-m7 L1 data cache by range. + * + * @param address The start address of the memory to be cleaned. + * @param size_byte The memory size. + * @note The start address and size_byte should be 32-byte(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L1 D-cache line size if + * startAddr is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +static inline void L1CACHE_CleanDCacheByRange(uint32_t address, uint32_t size_byte) +{ + uint32_t startAddr = address & (uint32_t) ~(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE - 1); + uint32_t size = size_byte + address - startAddr; + + SCB_CleanDCache_by_Addr((uint32_t *)startAddr, size); +} + +/*! + * @brief Cleans and Invalidates cortex-m7 L1 data cache by range. + * + * @param address The start address of the memory to be clean and invalidated. + * @param size_byte The memory size. + * @note The start address and size_byte should be 32-byte(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L1 D-cache line size if + * startAddr is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +static inline void L1CACHE_CleanInvalidateDCacheByRange(uint32_t address, uint32_t size_byte) +{ + uint32_t startAddr = address & (uint32_t) ~(FSL_FEATURE_L1DCACHE_LINESIZE_BYTE - 1); + uint32_t size = size_byte + address - startAddr; + + SCB_CleanInvalidateDCache_by_Addr((uint32_t *)startAddr, size); +} +/*@}*/ + +#if defined(FSL_FEATURE_SOC_L2CACHEC_COUNT) && FSL_FEATURE_SOC_L2CACHEC_COUNT +/*! + * @name Control for L2 pl310 cache + *@{ + */ + +/*! + * @brief Initializes the level 2 cache controller module. + * + * @param config Pointer to configuration structure. See "l2cache_config_t". + */ +void L2CACHE_Init(l2cache_config_t *config); + +/*! + * @brief Gets an available default settings for the cache controller. + * + * This function initializes the cache controller configuration structure with default settings. + * The default values are: + * @code + * config->waysNum = kL2CACHE_8ways; + * config->waySize = kL2CACHE_32KbSize; + * config->repacePolicy = kL2CACHE_Roundrobin; + * config->lateConfig = NULL; + * config->istrPrefetchEnable = false; + * config->dataPrefetchEnable = false; + * config->nsLockdownEnable = false; + * config->writeAlloc = kL2CACHE_UseAwcache; + * @endcode + * @param config Pointer to the configuration structure. + */ +void L2CACHE_GetDefaultConfig(l2cache_config_t *config); + +/*! + * @brief Enables the level 2 cache controller. + * This function enables the cache controller. Must be written using a secure access. + * If write with a Non-secure access will cause a DECERR response. + * + */ +void L2CACHE_Enable(void); + +/*! + * @brief Disables the level 2 cache controller. + * This function disables the cache controller. Must be written using a secure access. + * If write with a Non-secure access will cause a DECERR response. + * + */ +void L2CACHE_Disable(void); + +/*! + * @brief Invalidates the Level 2 cache. + * This function invalidates all entries in cache. + * + */ +void L2CACHE_Invalidate(void); + +/*! + * @brief Invalidates the Level 2 cache lines in the range of two physical addresses. + * This function invalidates all cache lines between two physical addresses. + * + * @param address The start address of the memory to be invalidated. + * @param size_byte The memory size. + * @note The start address and size_byte should be 32-byte(FSL_FEATURE_L2CACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L2 line size if startAddr + * is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L2CACHE_InvalidateByRange(uint32_t address, uint32_t size_byte); + +/*! + * @brief Cleans the level 2 cache controller. + * This function cleans all entries in the level 2 cache controller. + * + */ +void L2CACHE_Clean(void); + +/*! + * @brief Cleans the Level 2 cache lines in the range of two physical addresses. + * This function cleans all cache lines between two physical addresses. + * + * @param address The start address of the memory to be cleaned. + * @param size_byte The memory size. + * @note The start address and size_byte should be 32-byte(FSL_FEATURE_L2CACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L2 line size if startAddr + * is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L2CACHE_CleanByRange(uint32_t address, uint32_t size_byte); + +/*! + * @brief Cleans and invalidates the level 2 cache controller. + * This function cleans and invalidates all entries in the level 2 cache controller. + * + */ +void L2CACHE_CleanInvalidate(void); + +/*! + * @brief Cleans and invalidates the Level 2 cache lines in the range of two physical addresses. + * This function cleans and invalidates all cache lines between two physical addresses. + * + * @param address The start address of the memory to be cleaned and invalidated. + * @param size_byte The memory size. + * @note The start address and size_byte should be 32-byte(FSL_FEATURE_L2CACHE_LINESIZE_BYTE) aligned. + * The startAddr here will be forced to align to L2 line size if startAddr + * is not aligned. For the size_byte, application should make sure the + * alignment or make sure the right operation order if the size_byte is not aligned. + */ +void L2CACHE_CleanInvalidateByRange(uint32_t address, uint32_t size_byte); + +/*! + * @brief Enables or disables to lock down the data and instruction by way. + * This function locks down the cached instruction/data by way and prevent the adresses from + * being allocated and prevent dara from being evicted out of the level 2 cache. + * But the normal cache maintenance operations that invalidate, clean or clean + * and validate cache contents affect the locked-down cache lines as normal. + * + * @param masterId The master id, range from 0 ~ 7. + * @param mask The ways to be enabled or disabled to lockdown. + * each bit in value is related to each way of the cache. for example: + * value: bit 0 ------ way 0. + * value: bit 1 ------ way 1. + * -------------------------- + * value: bit 15 ------ way 15. + * Note: please make sure the value setting is align with your supported ways. + * @param enable True enable the lockdown, false to disable the lockdown. + */ +void L2CACHE_LockdownByWayEnable(uint32_t masterId, uint32_t mask, bool enable); + +/*@}*/ +#endif /* FSL_FEATURE_SOC_L2CACHEC_COUNT */ + +/*! + * @name Unified Cache Control for all caches (cortex-m7 L1 cache + l2 pl310) + * Mainly used for many drivers for easy cache operation. + *@{ + */ + +/*! + * @brief Invalidates all instruction caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * @param address The physical address. + * @param size_byte size of the memory to be invalidated. + * @note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void ICACHE_InvalidateByRange(uint32_t address, uint32_t size_byte); + +/*! + * @brief Invalidates all data caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * @param address The physical address. + * @param size_byte size of the memory to be invalidated. + * @note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void DCACHE_InvalidateByRange(uint32_t address, uint32_t size_byte); + +/*! + * @brief Cleans all data caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * @param address The physical address. + * @param size_byte size of the memory to be cleaned. + * @note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void DCACHE_CleanByRange(uint32_t address, uint32_t size_byte); + +/*! + * @brief Cleans and Invalidates all data caches by range. + * + * Both cortex-m7 L1 cache line and L2 PL310 cache line length is 32-byte. + * + * @param address The physical address. + * @param size_byte size of the memory to be cleaned and invalidated. + * @note address and size should be aligned to cache line size + * 32-Byte due to the cache operation unit is one cache line. The startAddr here will be forced + * to align to the cache line size if startAddr is not aligned. For the size_byte, application should + * make sure the alignment or make sure the right operation order if the size_byte is not aligned. + */ +void DCACHE_CleanInvalidateByRange(uint32_t address, uint32_t size_byte); + +/*@}*/ + +#if defined(__cplusplus) +} +#endif + +/*! @}*/ + +#endif /* _FSL_CACHE_H_*/ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_clock.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_clock.h old mode 100644 new mode 100755 similarity index 66% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_clock.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_clock.h index a562eda0..6324f1f0 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_clock.h +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_clock.h @@ -1,10 +1,30 @@ /* - * Copyright 2017 NXP + * Copyright 2017 - 2019 NXP * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_clock.h + * @brief clock drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + #ifndef _FSL_CLOCK_H_ #define _FSL_CLOCK_H_ @@ -39,8 +59,13 @@ /*! @name Driver version */ /*@{*/ -/*! @brief CLOCK driver version 2.1.5. */ -#define FSL_CLOCK_DRIVER_VERSION (MAKE_VERSION(2, 1, 5)) +/*! @brief CLOCK driver version 2.2.0. */ +#define FSL_CLOCK_DRIVER_VERSION (MAKE_VERSION(2, 2, 0)) + +/* Definition for delay API in clock driver, users can redefine it to the real application. */ +#ifndef SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY +#define SDK_DEVICE_MAXIMUM_CPU_CLOCK_FREQUENCY (600000000UL) +#endif /* analog pll definition */ #define CCM_ANALOG_PLL_BYPASS_SHIFT (16U) @@ -48,9 +73,36 @@ #define CCM_ANALOG_PLL_BYPASS_CLK_SRC_SHIFT (14U) /*@}*/ -#define CCM_TUPLE(reg, shift, mask, busyShift) \ - (int)((((uint32_t)(&((CCM_Type *)0U)->reg)) & 0xFFU) | ((shift) << 8U) | \ - ((((mask) >> (shift)) & 0x1FFFU) << 13U) | ((busyShift) << 26U)) + +/*! + * @brief CCM registers offset. + */ +#define CCSR_OFFSET 0x0C +#define CBCDR_OFFSET 0x14 +#define CBCMR_OFFSET 0x18 +#define CSCMR1_OFFSET 0x1C +#define CSCMR2_OFFSET 0x20 +#define CSCDR1_OFFSET 0x24 +#define CDCDR_OFFSET 0x30 +#define CSCDR2_OFFSET 0x38 +#define CSCDR3_OFFSET 0x3C +#define CACRR_OFFSET 0x10 +#define CS1CDR_OFFSET 0x28 +#define CS2CDR_OFFSET 0x2C + +/*! + * @brief CCM Analog registers offset. + */ +#define PLL_ARM_OFFSET 0x00 +#define PLL_SYS_OFFSET 0x30 +#define PLL_USB1_OFFSET 0x10 +#define PLL_AUDIO_OFFSET 0x70 +#define PLL_VIDEO_OFFSET 0xA0 +#define PLL_ENET_OFFSET 0xE0 +#define PLL_USB2_OFFSET 0x20 + +#define CCM_TUPLE(reg, shift, mask, busyShift) \ + (int)((reg & 0xFFU) | ((shift) << 8U) | ((((mask) >> (shift)) & 0x1FFFU) << 13U) | ((busyShift) << 26U)) #define CCM_TUPLE_REG(base, tuple) (*((volatile uint32_t *)(((uint32_t)(base)) + ((tuple)&0xFFU)))) #define CCM_TUPLE_SHIFT(tuple) (((tuple) >> 8U) & 0x1FU) #define CCM_TUPLE_MASK(tuple) ((uint32_t)((((tuple) >> 13U) & 0x1FFFU) << ((((tuple) >> 8U) & 0x1FU)))) @@ -61,7 +113,7 @@ /*! * @brief CCM ANALOG tuple macros to map corresponding registers and bit fields. */ -#define CCM_ANALOG_TUPLE(reg, shift) ((((uint32_t)(&((CCM_ANALOG_Type *)0U)->reg) & 0xFFFU) << 16U) | (shift)) +#define CCM_ANALOG_TUPLE(reg, shift) (((reg & 0xFFFU) << 16U) | (shift)) #define CCM_ANALOG_TUPLE_SHIFT(tuple) (((uint32_t)tuple) & 0x1FU) #define CCM_ANALOG_TUPLE_REG_OFF(base, tuple, off) \ (*((volatile uint32_t *)((uint32_t)base + (((uint32_t)tuple >> 16U) & 0xFFFU) + off))) @@ -271,16 +323,15 @@ extern volatile uint32_t g_rtcXtalFreq; } /*! @brief Clock ip name array for PWM. */ -#define PWM_CLOCKS \ - { \ - { \ - kCLOCK_IpInvalid, kCLOCK_IpInvalid, kCLOCK_IpInvalid, kCLOCK_IpInvalid \ - } \ - , {kCLOCK_Pwm1, kCLOCK_Pwm1, kCLOCK_Pwm1, kCLOCK_Pwm1}, {kCLOCK_Pwm2, kCLOCK_Pwm2, kCLOCK_Pwm2, kCLOCK_Pwm2}, \ - {kCLOCK_Pwm3, kCLOCK_Pwm3, kCLOCK_Pwm3, kCLOCK_Pwm3}, \ - { \ - kCLOCK_Pwm4, kCLOCK_Pwm4, kCLOCK_Pwm4, kCLOCK_Pwm4 \ - } \ +#define PWM_CLOCKS \ + { \ + {kCLOCK_IpInvalid, kCLOCK_IpInvalid, kCLOCK_IpInvalid, kCLOCK_IpInvalid}, \ + {kCLOCK_Pwm1, kCLOCK_Pwm1, kCLOCK_Pwm1, kCLOCK_Pwm1}, \ + {kCLOCK_Pwm2, kCLOCK_Pwm2, kCLOCK_Pwm2, kCLOCK_Pwm2}, \ + {kCLOCK_Pwm3, kCLOCK_Pwm3, kCLOCK_Pwm3, kCLOCK_Pwm3}, \ + { \ + kCLOCK_Pwm4, kCLOCK_Pwm4, kCLOCK_Pwm4, kCLOCK_Pwm4 \ + } \ } /*! @brief Clock ip name array for PXP. */ @@ -364,18 +415,18 @@ extern volatile uint32_t g_rtcXtalFreq; /*! @brief Clock name used to get clock frequency. */ typedef enum _clock_name { - kCLOCK_CpuClk = 0x0U, /*!< CPU clock */ - kCLOCK_AhbClk = 0x1U, /*!< AHB clock */ + kCLOCK_CpuClk = 0x0U, /*!< CPU clock */ + kCLOCK_AhbClk = 0x1U, /*!< AHB clock */ kCLOCK_SemcClk = 0x2U, /*!< SEMC clock */ - kCLOCK_IpgClk = 0x3U, /*!< IPG clock */ - kCLOCK_PerClk = 0x4U, /*!< PER clock */ + kCLOCK_IpgClk = 0x3U, /*!< IPG clock */ + kCLOCK_PerClk = 0x4U, /*!< PER clock */ kCLOCK_OscClk = 0x5U, /*!< OSC clock selected by PMU_LOWPWR_CTRL[OSC_SEL]. */ kCLOCK_RtcClk = 0x6U, /*!< RTC clock. (RTCCLK) */ kCLOCK_ArmPllClk = 0x7U, /*!< ARMPLLCLK. */ - kCLOCK_Usb1PllClk = 0x8U, /*!< USB1PLLCLK. */ + kCLOCK_Usb1PllClk = 0x8U, /*!< USB1PLLCLK. */ kCLOCK_Usb1PllPfd0Clk = 0x9U, /*!< USB1PLLPDF0CLK. */ kCLOCK_Usb1PllPfd1Clk = 0xAU, /*!< USB1PLLPFD1CLK. */ kCLOCK_Usb1PllPfd2Clk = 0xBU, /*!< USB1PLLPFD2CLK. */ @@ -383,7 +434,7 @@ typedef enum _clock_name kCLOCK_Usb2PllClk = 0xDU, /*!< USB2PLLCLK. */ - kCLOCK_SysPllClk = 0xEU, /*!< SYSPLLCLK. */ + kCLOCK_SysPllClk = 0xEU, /*!< SYSPLLCLK. */ kCLOCK_SysPllPfd0Clk = 0xFU, /*!< SYSPLLPDF0CLK. */ kCLOCK_SysPllPfd1Clk = 0x10U, /*!< SYSPLLPFD1CLK. */ kCLOCK_SysPllPfd2Clk = 0x11U, /*!< SYSPLLPFD2CLK. */ @@ -407,151 +458,151 @@ typedef enum _clock_ip_name kCLOCK_IpInvalid = -1, /* CCM CCGR0 */ - kCLOCK_Aips_tz1 = (0U << 8U) | CCM_CCGR0_CG0_SHIFT, /*!< CCGR0, CG0 */ - kCLOCK_Aips_tz2 = (0U << 8U) | CCM_CCGR0_CG1_SHIFT, /*!< CCGR0, CG1 */ - kCLOCK_Mqs = (0U << 8U) | CCM_CCGR0_CG2_SHIFT, /*!< CCGR0, CG2 */ - kCLOCK_FlexSpiExsc = (0U << 8U) | CCM_CCGR0_CG3_SHIFT, /*!< CCGR0, CG3 */ - kCLOCK_Sim_M_Main = (0U << 8U) | CCM_CCGR0_CG4_SHIFT, /*!< CCGR0, CG4 */ - kCLOCK_Dcp = (0U << 8U) | CCM_CCGR0_CG5_SHIFT, /*!< CCGR0, CG5 */ - kCLOCK_Lpuart3 = (0U << 8U) | CCM_CCGR0_CG6_SHIFT, /*!< CCGR0, CG6 */ - kCLOCK_Can1 = (0U << 8U) | CCM_CCGR0_CG7_SHIFT, /*!< CCGR0, CG7 */ - kCLOCK_Can1S = (0U << 8U) | CCM_CCGR0_CG8_SHIFT, /*!< CCGR0, CG8 */ - kCLOCK_Can2 = (0U << 8U) | CCM_CCGR0_CG9_SHIFT, /*!< CCGR0, CG9 */ - kCLOCK_Can2S = (0U << 8U) | CCM_CCGR0_CG10_SHIFT, /*!< CCGR0, CG10 */ - kCLOCK_Trace = (0U << 8U) | CCM_CCGR0_CG11_SHIFT, /*!< CCGR0, CG11 */ - kCLOCK_Gpt2 = (0U << 8U) | CCM_CCGR0_CG12_SHIFT, /*!< CCGR0, CG12 */ - kCLOCK_Gpt2S = (0U << 8U) | CCM_CCGR0_CG13_SHIFT, /*!< CCGR0, CG13 */ - kCLOCK_Lpuart2 = (0U << 8U) | CCM_CCGR0_CG14_SHIFT, /*!< CCGR0, CG14 */ - kCLOCK_Gpio2 = (0U << 8U) | CCM_CCGR0_CG15_SHIFT, /*!< CCGR0, CG15 */ + kCLOCK_Aips_tz1 = (0U << 8U) | CCM_CCGR0_CG0_SHIFT, /*!< CCGR0, CG0 */ + kCLOCK_Aips_tz2 = (0U << 8U) | CCM_CCGR0_CG1_SHIFT, /*!< CCGR0, CG1 */ + kCLOCK_Mqs = (0U << 8U) | CCM_CCGR0_CG2_SHIFT, /*!< CCGR0, CG2 */ + kCLOCK_FlexSpiExsc = (0U << 8U) | CCM_CCGR0_CG3_SHIFT, /*!< CCGR0, CG3 */ + kCLOCK_Sim_M_Main = (0U << 8U) | CCM_CCGR0_CG4_SHIFT, /*!< CCGR0, CG4 */ + kCLOCK_Dcp = (0U << 8U) | CCM_CCGR0_CG5_SHIFT, /*!< CCGR0, CG5 */ + kCLOCK_Lpuart3 = (0U << 8U) | CCM_CCGR0_CG6_SHIFT, /*!< CCGR0, CG6 */ + kCLOCK_Can1 = (0U << 8U) | CCM_CCGR0_CG7_SHIFT, /*!< CCGR0, CG7 */ + kCLOCK_Can1S = (0U << 8U) | CCM_CCGR0_CG8_SHIFT, /*!< CCGR0, CG8 */ + kCLOCK_Can2 = (0U << 8U) | CCM_CCGR0_CG9_SHIFT, /*!< CCGR0, CG9 */ + kCLOCK_Can2S = (0U << 8U) | CCM_CCGR0_CG10_SHIFT, /*!< CCGR0, CG10 */ + kCLOCK_Trace = (0U << 8U) | CCM_CCGR0_CG11_SHIFT, /*!< CCGR0, CG11 */ + kCLOCK_Gpt2 = (0U << 8U) | CCM_CCGR0_CG12_SHIFT, /*!< CCGR0, CG12 */ + kCLOCK_Gpt2S = (0U << 8U) | CCM_CCGR0_CG13_SHIFT, /*!< CCGR0, CG13 */ + kCLOCK_Lpuart2 = (0U << 8U) | CCM_CCGR0_CG14_SHIFT, /*!< CCGR0, CG14 */ + kCLOCK_Gpio2 = (0U << 8U) | CCM_CCGR0_CG15_SHIFT, /*!< CCGR0, CG15 */ /* CCM CCGR1 */ - kCLOCK_Lpspi1 = (1U << 8U) | CCM_CCGR1_CG0_SHIFT, /*!< CCGR1, CG0 */ - kCLOCK_Lpspi2 = (1U << 8U) | CCM_CCGR1_CG1_SHIFT, /*!< CCGR1, CG1 */ - kCLOCK_Lpspi3 = (1U << 8U) | CCM_CCGR1_CG2_SHIFT, /*!< CCGR1, CG2 */ - kCLOCK_Lpspi4 = (1U << 8U) | CCM_CCGR1_CG3_SHIFT, /*!< CCGR1, CG3 */ - kCLOCK_Adc2 = (1U << 8U) | CCM_CCGR1_CG4_SHIFT, /*!< CCGR1, CG4 */ - kCLOCK_Enet = (1U << 8U) | CCM_CCGR1_CG5_SHIFT, /*!< CCGR1, CG5 */ - kCLOCK_Pit = (1U << 8U) | CCM_CCGR1_CG6_SHIFT, /*!< CCGR1, CG6 */ - kCLOCK_Aoi2 = (1U << 8U) | CCM_CCGR1_CG7_SHIFT, /*!< CCGR1, CG7 */ - kCLOCK_Adc1 = (1U << 8U) | CCM_CCGR1_CG8_SHIFT, /*!< CCGR1, CG8 */ - kCLOCK_SemcExsc = (1U << 8U) | CCM_CCGR1_CG9_SHIFT, /*!< CCGR1, CG9 */ - kCLOCK_Gpt1 = (1U << 8U) | CCM_CCGR1_CG10_SHIFT, /*!< CCGR1, CG10 */ - kCLOCK_Gpt1S = (1U << 8U) | CCM_CCGR1_CG11_SHIFT, /*!< CCGR1, CG11 */ - kCLOCK_Lpuart4 = (1U << 8U) | CCM_CCGR1_CG12_SHIFT, /*!< CCGR1, CG12 */ - kCLOCK_Gpio1 = (1U << 8U) | CCM_CCGR1_CG13_SHIFT, /*!< CCGR1, CG13 */ - kCLOCK_Csu = (1U << 8U) | CCM_CCGR1_CG14_SHIFT, /*!< CCGR1, CG14 */ - kCLOCK_Gpio5 = (1U << 8U) | CCM_CCGR1_CG15_SHIFT, /*!< CCGR1, CG15 */ + kCLOCK_Lpspi1 = (1U << 8U) | CCM_CCGR1_CG0_SHIFT, /*!< CCGR1, CG0 */ + kCLOCK_Lpspi2 = (1U << 8U) | CCM_CCGR1_CG1_SHIFT, /*!< CCGR1, CG1 */ + kCLOCK_Lpspi3 = (1U << 8U) | CCM_CCGR1_CG2_SHIFT, /*!< CCGR1, CG2 */ + kCLOCK_Lpspi4 = (1U << 8U) | CCM_CCGR1_CG3_SHIFT, /*!< CCGR1, CG3 */ + kCLOCK_Adc2 = (1U << 8U) | CCM_CCGR1_CG4_SHIFT, /*!< CCGR1, CG4 */ + kCLOCK_Enet = (1U << 8U) | CCM_CCGR1_CG5_SHIFT, /*!< CCGR1, CG5 */ + kCLOCK_Pit = (1U << 8U) | CCM_CCGR1_CG6_SHIFT, /*!< CCGR1, CG6 */ + kCLOCK_Aoi2 = (1U << 8U) | CCM_CCGR1_CG7_SHIFT, /*!< CCGR1, CG7 */ + kCLOCK_Adc1 = (1U << 8U) | CCM_CCGR1_CG8_SHIFT, /*!< CCGR1, CG8 */ + kCLOCK_SemcExsc = (1U << 8U) | CCM_CCGR1_CG9_SHIFT, /*!< CCGR1, CG9 */ + kCLOCK_Gpt1 = (1U << 8U) | CCM_CCGR1_CG10_SHIFT, /*!< CCGR1, CG10 */ + kCLOCK_Gpt1S = (1U << 8U) | CCM_CCGR1_CG11_SHIFT, /*!< CCGR1, CG11 */ + kCLOCK_Lpuart4 = (1U << 8U) | CCM_CCGR1_CG12_SHIFT, /*!< CCGR1, CG12 */ + kCLOCK_Gpio1 = (1U << 8U) | CCM_CCGR1_CG13_SHIFT, /*!< CCGR1, CG13 */ + kCLOCK_Csu = (1U << 8U) | CCM_CCGR1_CG14_SHIFT, /*!< CCGR1, CG14 */ + kCLOCK_Gpio5 = (1U << 8U) | CCM_CCGR1_CG15_SHIFT, /*!< CCGR1, CG15 */ /* CCM CCGR2 */ - kCLOCK_OcramExsc = (2U << 8U) | CCM_CCGR2_CG0_SHIFT, /*!< CCGR2, CG0 */ - kCLOCK_Csi = (2U << 8U) | CCM_CCGR2_CG1_SHIFT, /*!< CCGR2, CG1 */ - kCLOCK_IomuxcSnvs = (2U << 8U) | CCM_CCGR2_CG2_SHIFT, /*!< CCGR2, CG2 */ - kCLOCK_Lpi2c1 = (2U << 8U) | CCM_CCGR2_CG3_SHIFT, /*!< CCGR2, CG3 */ - kCLOCK_Lpi2c2 = (2U << 8U) | CCM_CCGR2_CG4_SHIFT, /*!< CCGR2, CG4 */ - kCLOCK_Lpi2c3 = (2U << 8U) | CCM_CCGR2_CG5_SHIFT, /*!< CCGR2, CG5 */ - kCLOCK_Ocotp = (2U << 8U) | CCM_CCGR2_CG6_SHIFT, /*!< CCGR2, CG6 */ - kCLOCK_Xbar3 = (2U << 8U) | CCM_CCGR2_CG7_SHIFT, /*!< CCGR2, CG7 */ - kCLOCK_Ipmux1 = (2U << 8U) | CCM_CCGR2_CG8_SHIFT, /*!< CCGR2, CG8 */ - kCLOCK_Ipmux2 = (2U << 8U) | CCM_CCGR2_CG9_SHIFT, /*!< CCGR2, CG9 */ - kCLOCK_Ipmux3 = (2U << 8U) | CCM_CCGR2_CG10_SHIFT, /*!< CCGR2, CG10 */ - kCLOCK_Xbar1 = (2U << 8U) | CCM_CCGR2_CG11_SHIFT, /*!< CCGR2, CG11 */ - kCLOCK_Xbar2 = (2U << 8U) | CCM_CCGR2_CG12_SHIFT, /*!< CCGR2, CG12 */ - kCLOCK_Gpio3 = (2U << 8U) | CCM_CCGR2_CG13_SHIFT, /*!< CCGR2, CG13 */ - kCLOCK_Lcd = (2U << 8U) | CCM_CCGR2_CG14_SHIFT, /*!< CCGR2, CG14 */ - kCLOCK_Pxp = (2U << 8U) | CCM_CCGR2_CG15_SHIFT, /*!< CCGR2, CG15 */ + kCLOCK_OcramExsc = (2U << 8U) | CCM_CCGR2_CG0_SHIFT, /*!< CCGR2, CG0 */ + kCLOCK_Csi = (2U << 8U) | CCM_CCGR2_CG1_SHIFT, /*!< CCGR2, CG1 */ + kCLOCK_IomuxcSnvs = (2U << 8U) | CCM_CCGR2_CG2_SHIFT, /*!< CCGR2, CG2 */ + kCLOCK_Lpi2c1 = (2U << 8U) | CCM_CCGR2_CG3_SHIFT, /*!< CCGR2, CG3 */ + kCLOCK_Lpi2c2 = (2U << 8U) | CCM_CCGR2_CG4_SHIFT, /*!< CCGR2, CG4 */ + kCLOCK_Lpi2c3 = (2U << 8U) | CCM_CCGR2_CG5_SHIFT, /*!< CCGR2, CG5 */ + kCLOCK_Ocotp = (2U << 8U) | CCM_CCGR2_CG6_SHIFT, /*!< CCGR2, CG6 */ + kCLOCK_Xbar3 = (2U << 8U) | CCM_CCGR2_CG7_SHIFT, /*!< CCGR2, CG7 */ + kCLOCK_Ipmux1 = (2U << 8U) | CCM_CCGR2_CG8_SHIFT, /*!< CCGR2, CG8 */ + kCLOCK_Ipmux2 = (2U << 8U) | CCM_CCGR2_CG9_SHIFT, /*!< CCGR2, CG9 */ + kCLOCK_Ipmux3 = (2U << 8U) | CCM_CCGR2_CG10_SHIFT, /*!< CCGR2, CG10 */ + kCLOCK_Xbar1 = (2U << 8U) | CCM_CCGR2_CG11_SHIFT, /*!< CCGR2, CG11 */ + kCLOCK_Xbar2 = (2U << 8U) | CCM_CCGR2_CG12_SHIFT, /*!< CCGR2, CG12 */ + kCLOCK_Gpio3 = (2U << 8U) | CCM_CCGR2_CG13_SHIFT, /*!< CCGR2, CG13 */ + kCLOCK_Lcd = (2U << 8U) | CCM_CCGR2_CG14_SHIFT, /*!< CCGR2, CG14 */ + kCLOCK_Pxp = (2U << 8U) | CCM_CCGR2_CG15_SHIFT, /*!< CCGR2, CG15 */ /* CCM CCGR3 */ - kCLOCK_Flexio2 = (3U << 8U) | CCM_CCGR3_CG0_SHIFT, /*!< CCGR3, CG0 */ - kCLOCK_Lpuart5 = (3U << 8U) | CCM_CCGR3_CG1_SHIFT, /*!< CCGR3, CG1 */ - kCLOCK_Semc = (3U << 8U) | CCM_CCGR3_CG2_SHIFT, /*!< CCGR3, CG2 */ - kCLOCK_Lpuart6 = (3U << 8U) | CCM_CCGR3_CG3_SHIFT, /*!< CCGR3, CG3 */ - kCLOCK_Aoi1 = (3U << 8U) | CCM_CCGR3_CG4_SHIFT, /*!< CCGR3, CG4 */ - kCLOCK_LcdPixel = (3U << 8U) | CCM_CCGR3_CG5_SHIFT, /*!< CCGR3, CG5 */ - kCLOCK_Gpio4 = (3U << 8U) | CCM_CCGR3_CG6_SHIFT, /*!< CCGR3, CG6 */ - kCLOCK_Ewm0 = (3U << 8U) | CCM_CCGR3_CG7_SHIFT, /*!< CCGR3, CG7 */ - kCLOCK_Wdog1 = (3U << 8U) | CCM_CCGR3_CG8_SHIFT, /*!< CCGR3, CG8 */ - kCLOCK_FlexRam = (3U << 8U) | CCM_CCGR3_CG9_SHIFT, /*!< CCGR3, CG9 */ - kCLOCK_Acmp1 = (3U << 8U) | CCM_CCGR3_CG10_SHIFT, /*!< CCGR3, CG10 */ - kCLOCK_Acmp2 = (3U << 8U) | CCM_CCGR3_CG11_SHIFT, /*!< CCGR3, CG11 */ - kCLOCK_Acmp3 = (3U << 8U) | CCM_CCGR3_CG12_SHIFT, /*!< CCGR3, CG12 */ - kCLOCK_Acmp4 = (3U << 8U) | CCM_CCGR3_CG13_SHIFT, /*!< CCGR3, CG13 */ - kCLOCK_Ocram = (3U << 8U) | CCM_CCGR3_CG14_SHIFT, /*!< CCGR3, CG14 */ + kCLOCK_Flexio2 = (3U << 8U) | CCM_CCGR3_CG0_SHIFT, /*!< CCGR3, CG0 */ + kCLOCK_Lpuart5 = (3U << 8U) | CCM_CCGR3_CG1_SHIFT, /*!< CCGR3, CG1 */ + kCLOCK_Semc = (3U << 8U) | CCM_CCGR3_CG2_SHIFT, /*!< CCGR3, CG2 */ + kCLOCK_Lpuart6 = (3U << 8U) | CCM_CCGR3_CG3_SHIFT, /*!< CCGR3, CG3 */ + kCLOCK_Aoi1 = (3U << 8U) | CCM_CCGR3_CG4_SHIFT, /*!< CCGR3, CG4 */ + kCLOCK_LcdPixel = (3U << 8U) | CCM_CCGR3_CG5_SHIFT, /*!< CCGR3, CG5 */ + kCLOCK_Gpio4 = (3U << 8U) | CCM_CCGR3_CG6_SHIFT, /*!< CCGR3, CG6 */ + kCLOCK_Ewm0 = (3U << 8U) | CCM_CCGR3_CG7_SHIFT, /*!< CCGR3, CG7 */ + kCLOCK_Wdog1 = (3U << 8U) | CCM_CCGR3_CG8_SHIFT, /*!< CCGR3, CG8 */ + kCLOCK_FlexRam = (3U << 8U) | CCM_CCGR3_CG9_SHIFT, /*!< CCGR3, CG9 */ + kCLOCK_Acmp1 = (3U << 8U) | CCM_CCGR3_CG10_SHIFT, /*!< CCGR3, CG10 */ + kCLOCK_Acmp2 = (3U << 8U) | CCM_CCGR3_CG11_SHIFT, /*!< CCGR3, CG11 */ + kCLOCK_Acmp3 = (3U << 8U) | CCM_CCGR3_CG12_SHIFT, /*!< CCGR3, CG12 */ + kCLOCK_Acmp4 = (3U << 8U) | CCM_CCGR3_CG13_SHIFT, /*!< CCGR3, CG13 */ + kCLOCK_Ocram = (3U << 8U) | CCM_CCGR3_CG14_SHIFT, /*!< CCGR3, CG14 */ kCLOCK_IomuxcSnvsGpr = (3U << 8U) | CCM_CCGR3_CG15_SHIFT, /*!< CCGR3, CG15 */ /* CCM CCGR4 */ - kCLOCK_Iomuxc = (4U << 8U) | CCM_CCGR4_CG1_SHIFT, /*!< CCGR4, CG1 */ - kCLOCK_IomuxcGpr = (4U << 8U) | CCM_CCGR4_CG2_SHIFT, /*!< CCGR4, CG2 */ - kCLOCK_Bee = (4U << 8U) | CCM_CCGR4_CG3_SHIFT, /*!< CCGR4, CG3 */ - kCLOCK_SimM7 = (4U << 8U) | CCM_CCGR4_CG4_SHIFT, /*!< CCGR4, CG4 */ - kCLOCK_Tsc = (4U << 8U) | CCM_CCGR4_CG5_SHIFT, /*!< CCGR4, CG5 */ - kCLOCK_SimM = (4U << 8U) | CCM_CCGR4_CG6_SHIFT, /*!< CCGR4, CG6 */ - kCLOCK_SimEms = (4U << 8U) | CCM_CCGR4_CG7_SHIFT, /*!< CCGR4, CG7 */ - kCLOCK_Pwm1 = (4U << 8U) | CCM_CCGR4_CG8_SHIFT, /*!< CCGR4, CG8 */ - kCLOCK_Pwm2 = (4U << 8U) | CCM_CCGR4_CG9_SHIFT, /*!< CCGR4, CG9 */ - kCLOCK_Pwm3 = (4U << 8U) | CCM_CCGR4_CG10_SHIFT, /*!< CCGR4, CG10 */ - kCLOCK_Pwm4 = (4U << 8U) | CCM_CCGR4_CG11_SHIFT, /*!< CCGR4, CG11 */ - kCLOCK_Enc1 = (4U << 8U) | CCM_CCGR4_CG12_SHIFT, /*!< CCGR4, CG12 */ - kCLOCK_Enc2 = (4U << 8U) | CCM_CCGR4_CG13_SHIFT, /*!< CCGR4, CG13 */ - kCLOCK_Enc3 = (4U << 8U) | CCM_CCGR4_CG14_SHIFT, /*!< CCGR4, CG14 */ - kCLOCK_Enc4 = (4U << 8U) | CCM_CCGR4_CG15_SHIFT, /*!< CCGR4, CG15 */ + kCLOCK_Iomuxc = (4U << 8U) | CCM_CCGR4_CG1_SHIFT, /*!< CCGR4, CG1 */ + kCLOCK_IomuxcGpr = (4U << 8U) | CCM_CCGR4_CG2_SHIFT, /*!< CCGR4, CG2 */ + kCLOCK_Bee = (4U << 8U) | CCM_CCGR4_CG3_SHIFT, /*!< CCGR4, CG3 */ + kCLOCK_SimM7 = (4U << 8U) | CCM_CCGR4_CG4_SHIFT, /*!< CCGR4, CG4 */ + kCLOCK_Tsc = (4U << 8U) | CCM_CCGR4_CG5_SHIFT, /*!< CCGR4, CG5 */ + kCLOCK_SimM = (4U << 8U) | CCM_CCGR4_CG6_SHIFT, /*!< CCGR4, CG6 */ + kCLOCK_SimEms = (4U << 8U) | CCM_CCGR4_CG7_SHIFT, /*!< CCGR4, CG7 */ + kCLOCK_Pwm1 = (4U << 8U) | CCM_CCGR4_CG8_SHIFT, /*!< CCGR4, CG8 */ + kCLOCK_Pwm2 = (4U << 8U) | CCM_CCGR4_CG9_SHIFT, /*!< CCGR4, CG9 */ + kCLOCK_Pwm3 = (4U << 8U) | CCM_CCGR4_CG10_SHIFT, /*!< CCGR4, CG10 */ + kCLOCK_Pwm4 = (4U << 8U) | CCM_CCGR4_CG11_SHIFT, /*!< CCGR4, CG11 */ + kCLOCK_Enc1 = (4U << 8U) | CCM_CCGR4_CG12_SHIFT, /*!< CCGR4, CG12 */ + kCLOCK_Enc2 = (4U << 8U) | CCM_CCGR4_CG13_SHIFT, /*!< CCGR4, CG13 */ + kCLOCK_Enc3 = (4U << 8U) | CCM_CCGR4_CG14_SHIFT, /*!< CCGR4, CG14 */ + kCLOCK_Enc4 = (4U << 8U) | CCM_CCGR4_CG15_SHIFT, /*!< CCGR4, CG15 */ /* CCM CCGR5 */ - kCLOCK_Rom = (5U << 8U) | CCM_CCGR5_CG0_SHIFT, /*!< CCGR5, CG0 */ - kCLOCK_Flexio1 = (5U << 8U) | CCM_CCGR5_CG1_SHIFT, /*!< CCGR5, CG1 */ - kCLOCK_Wdog3 = (5U << 8U) | CCM_CCGR5_CG2_SHIFT, /*!< CCGR5, CG2 */ - kCLOCK_Dma = (5U << 8U) | CCM_CCGR5_CG3_SHIFT, /*!< CCGR5, CG3 */ - kCLOCK_Kpp = (5U << 8U) | CCM_CCGR5_CG4_SHIFT, /*!< CCGR5, CG4 */ - kCLOCK_Wdog2 = (5U << 8U) | CCM_CCGR5_CG5_SHIFT, /*!< CCGR5, CG5 */ - kCLOCK_Aips_tz4 = (5U << 8U) | CCM_CCGR5_CG6_SHIFT, /*!< CCGR5, CG6 */ - kCLOCK_Spdif = (5U << 8U) | CCM_CCGR5_CG7_SHIFT, /*!< CCGR5, CG7 */ - kCLOCK_SimMain = (5U << 8U) | CCM_CCGR5_CG8_SHIFT, /*!< CCGR5, CG8 */ - kCLOCK_Sai1 = (5U << 8U) | CCM_CCGR5_CG9_SHIFT, /*!< CCGR5, CG9 */ - kCLOCK_Sai2 = (5U << 8U) | CCM_CCGR5_CG10_SHIFT, /*!< CCGR5, CG10 */ - kCLOCK_Sai3 = (5U << 8U) | CCM_CCGR5_CG11_SHIFT, /*!< CCGR5, CG11 */ - kCLOCK_Lpuart1 = (5U << 8U) | CCM_CCGR5_CG12_SHIFT, /*!< CCGR5, CG12 */ - kCLOCK_Lpuart7 = (5U << 8U) | CCM_CCGR5_CG13_SHIFT, /*!< CCGR5, CG13 */ - kCLOCK_SnvsHp = (5U << 8U) | CCM_CCGR5_CG14_SHIFT, /*!< CCGR5, CG14 */ - kCLOCK_SnvsLp = (5U << 8U) | CCM_CCGR5_CG15_SHIFT, /*!< CCGR5, CG15 */ + kCLOCK_Rom = (5U << 8U) | CCM_CCGR5_CG0_SHIFT, /*!< CCGR5, CG0 */ + kCLOCK_Flexio1 = (5U << 8U) | CCM_CCGR5_CG1_SHIFT, /*!< CCGR5, CG1 */ + kCLOCK_Wdog3 = (5U << 8U) | CCM_CCGR5_CG2_SHIFT, /*!< CCGR5, CG2 */ + kCLOCK_Dma = (5U << 8U) | CCM_CCGR5_CG3_SHIFT, /*!< CCGR5, CG3 */ + kCLOCK_Kpp = (5U << 8U) | CCM_CCGR5_CG4_SHIFT, /*!< CCGR5, CG4 */ + kCLOCK_Wdog2 = (5U << 8U) | CCM_CCGR5_CG5_SHIFT, /*!< CCGR5, CG5 */ + kCLOCK_Aips_tz4 = (5U << 8U) | CCM_CCGR5_CG6_SHIFT, /*!< CCGR5, CG6 */ + kCLOCK_Spdif = (5U << 8U) | CCM_CCGR5_CG7_SHIFT, /*!< CCGR5, CG7 */ + kCLOCK_SimMain = (5U << 8U) | CCM_CCGR5_CG8_SHIFT, /*!< CCGR5, CG8 */ + kCLOCK_Sai1 = (5U << 8U) | CCM_CCGR5_CG9_SHIFT, /*!< CCGR5, CG9 */ + kCLOCK_Sai2 = (5U << 8U) | CCM_CCGR5_CG10_SHIFT, /*!< CCGR5, CG10 */ + kCLOCK_Sai3 = (5U << 8U) | CCM_CCGR5_CG11_SHIFT, /*!< CCGR5, CG11 */ + kCLOCK_Lpuart1 = (5U << 8U) | CCM_CCGR5_CG12_SHIFT, /*!< CCGR5, CG12 */ + kCLOCK_Lpuart7 = (5U << 8U) | CCM_CCGR5_CG13_SHIFT, /*!< CCGR5, CG13 */ + kCLOCK_SnvsHp = (5U << 8U) | CCM_CCGR5_CG14_SHIFT, /*!< CCGR5, CG14 */ + kCLOCK_SnvsLp = (5U << 8U) | CCM_CCGR5_CG15_SHIFT, /*!< CCGR5, CG15 */ /* CCM CCGR6 */ - kCLOCK_UsbOh3 = (6U << 8U) | CCM_CCGR6_CG0_SHIFT, /*!< CCGR6, CG0 */ - kCLOCK_Usdhc1 = (6U << 8U) | CCM_CCGR6_CG1_SHIFT, /*!< CCGR6, CG1 */ - kCLOCK_Usdhc2 = (6U << 8U) | CCM_CCGR6_CG2_SHIFT, /*!< CCGR6, CG2 */ - kCLOCK_Dcdc = (6U << 8U) | CCM_CCGR6_CG3_SHIFT, /*!< CCGR6, CG3 */ - kCLOCK_Ipmux4 = (6U << 8U) | CCM_CCGR6_CG4_SHIFT, /*!< CCGR6, CG4 */ - kCLOCK_FlexSpi = (6U << 8U) | CCM_CCGR6_CG5_SHIFT, /*!< CCGR6, CG5 */ - kCLOCK_Trng = (6U << 8U) | CCM_CCGR6_CG6_SHIFT, /*!< CCGR6, CG6 */ - kCLOCK_Lpuart8 = (6U << 8U) | CCM_CCGR6_CG7_SHIFT, /*!< CCGR6, CG7 */ - kCLOCK_Timer4 = (6U << 8U) | CCM_CCGR6_CG8_SHIFT, /*!< CCGR6, CG8 */ - kCLOCK_Aips_tz3 = (6U << 8U) | CCM_CCGR6_CG9_SHIFT, /*!< CCGR6, CG9 */ - kCLOCK_SimPer = (6U << 8U) | CCM_CCGR6_CG10_SHIFT, /*!< CCGR6, CG10 */ - kCLOCK_Anadig = (6U << 8U) | CCM_CCGR6_CG11_SHIFT, /*!< CCGR6, CG11 */ - kCLOCK_Lpi2c4 = (6U << 8U) | CCM_CCGR6_CG12_SHIFT, /*!< CCGR6, CG12 */ - kCLOCK_Timer1 = (6U << 8U) | CCM_CCGR6_CG13_SHIFT, /*!< CCGR6, CG13 */ - kCLOCK_Timer2 = (6U << 8U) | CCM_CCGR6_CG14_SHIFT, /*!< CCGR6, CG14 */ - kCLOCK_Timer3 = (6U << 8U) | CCM_CCGR6_CG15_SHIFT, /*!< CCGR6, CG15 */ + kCLOCK_UsbOh3 = (6U << 8U) | CCM_CCGR6_CG0_SHIFT, /*!< CCGR6, CG0 */ + kCLOCK_Usdhc1 = (6U << 8U) | CCM_CCGR6_CG1_SHIFT, /*!< CCGR6, CG1 */ + kCLOCK_Usdhc2 = (6U << 8U) | CCM_CCGR6_CG2_SHIFT, /*!< CCGR6, CG2 */ + kCLOCK_Dcdc = (6U << 8U) | CCM_CCGR6_CG3_SHIFT, /*!< CCGR6, CG3 */ + kCLOCK_Ipmux4 = (6U << 8U) | CCM_CCGR6_CG4_SHIFT, /*!< CCGR6, CG4 */ + kCLOCK_FlexSpi = (6U << 8U) | CCM_CCGR6_CG5_SHIFT, /*!< CCGR6, CG5 */ + kCLOCK_Trng = (6U << 8U) | CCM_CCGR6_CG6_SHIFT, /*!< CCGR6, CG6 */ + kCLOCK_Lpuart8 = (6U << 8U) | CCM_CCGR6_CG7_SHIFT, /*!< CCGR6, CG7 */ + kCLOCK_Timer4 = (6U << 8U) | CCM_CCGR6_CG8_SHIFT, /*!< CCGR6, CG8 */ + kCLOCK_Aips_tz3 = (6U << 8U) | CCM_CCGR6_CG9_SHIFT, /*!< CCGR6, CG9 */ + kCLOCK_SimPer = (6U << 8U) | CCM_CCGR6_CG10_SHIFT, /*!< CCGR6, CG10 */ + kCLOCK_Anadig = (6U << 8U) | CCM_CCGR6_CG11_SHIFT, /*!< CCGR6, CG11 */ + kCLOCK_Lpi2c4 = (6U << 8U) | CCM_CCGR6_CG12_SHIFT, /*!< CCGR6, CG12 */ + kCLOCK_Timer1 = (6U << 8U) | CCM_CCGR6_CG13_SHIFT, /*!< CCGR6, CG13 */ + kCLOCK_Timer2 = (6U << 8U) | CCM_CCGR6_CG14_SHIFT, /*!< CCGR6, CG14 */ + kCLOCK_Timer3 = (6U << 8U) | CCM_CCGR6_CG15_SHIFT, /*!< CCGR6, CG15 */ } clock_ip_name_t; /*! @brief OSC 24M sorce select */ typedef enum _clock_osc { - kCLOCK_RcOsc = 0U, /*!< On chip OSC. */ + kCLOCK_RcOsc = 0U, /*!< On chip OSC. */ kCLOCK_XtalOsc = 1U, /*!< 24M Xtal OSC */ } clock_osc_t; /*! @brief Clock gate value */ typedef enum _clock_gate_value { - kCLOCK_ClockNotNeeded = 0U, /*!< Clock is off during all modes. */ - kCLOCK_ClockNeededRun = 1U, /*!< Clock is on in run mode, but off in WAIT and STOP modes */ + kCLOCK_ClockNotNeeded = 0U, /*!< Clock is off during all modes. */ + kCLOCK_ClockNeededRun = 1U, /*!< Clock is on in run mode, but off in WAIT and STOP modes */ kCLOCK_ClockNeededRunWait = 3U, /*!< Clock is on during all modes, except STOP mode */ } clock_gate_value_t; /*! @brief System clock mode */ typedef enum _clock_mode_t { - kCLOCK_ModeRun = 0U, /*!< Remain in run mode. */ + kCLOCK_ModeRun = 0U, /*!< Remain in run mode. */ kCLOCK_ModeWait = 1U, /*!< Transfer to wait mode. */ kCLOCK_ModeStop = 2U, /*!< Transfer to stop mode. */ } clock_mode_t; @@ -566,84 +617,106 @@ typedef enum _clock_mode_t */ typedef enum _clock_mux { - kCLOCK_Pll3SwMux = CCM_TUPLE(CCSR, + kCLOCK_Pll3SwMux = CCM_TUPLE(CCSR_OFFSET, CCM_CCSR_PLL3_SW_CLK_SEL_SHIFT, CCM_CCSR_PLL3_SW_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< pll3_sw_clk mux name */ - kCLOCK_PeriphMux = CCM_TUPLE(CBCDR, + kCLOCK_PeriphMux = CCM_TUPLE(CBCDR_OFFSET, CCM_CBCDR_PERIPH_CLK_SEL_SHIFT, CCM_CBCDR_PERIPH_CLK_SEL_MASK, CCM_CDHIPR_PERIPH_CLK_SEL_BUSY_SHIFT), /*!< periph mux name */ - kCLOCK_SemcAltMux = CCM_TUPLE(CBCDR, + kCLOCK_SemcAltMux = CCM_TUPLE(CBCDR_OFFSET, CCM_CBCDR_SEMC_ALT_CLK_SEL_SHIFT, CCM_CBCDR_SEMC_ALT_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< semc mux name */ - kCLOCK_SemcMux = CCM_TUPLE( - CBCDR, CCM_CBCDR_SEMC_CLK_SEL_SHIFT, CCM_CBCDR_SEMC_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< semc mux name */ + kCLOCK_SemcMux = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_SEMC_CLK_SEL_SHIFT, + CCM_CBCDR_SEMC_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< semc mux name */ - kCLOCK_PrePeriphMux = CCM_TUPLE(CBCMR, + kCLOCK_PrePeriphMux = CCM_TUPLE(CBCMR_OFFSET, CCM_CBCMR_PRE_PERIPH_CLK_SEL_SHIFT, CCM_CBCMR_PRE_PERIPH_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< pre-periph mux name */ - kCLOCK_TraceMux = CCM_TUPLE( - CBCMR, CCM_CBCMR_TRACE_CLK_SEL_SHIFT, CCM_CBCMR_TRACE_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< trace mux name */ - kCLOCK_PeriphClk2Mux = CCM_TUPLE(CBCMR, + kCLOCK_TraceMux = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_TRACE_CLK_SEL_SHIFT, + CCM_CBCMR_TRACE_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< trace mux name */ + kCLOCK_PeriphClk2Mux = CCM_TUPLE(CBCMR_OFFSET, CCM_CBCMR_PERIPH_CLK2_SEL_SHIFT, CCM_CBCMR_PERIPH_CLK2_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< periph clock2 mux name */ - kCLOCK_LpspiMux = CCM_TUPLE( - CBCMR, CCM_CBCMR_LPSPI_CLK_SEL_SHIFT, CCM_CBCMR_LPSPI_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< lpspi mux name */ + kCLOCK_LpspiMux = CCM_TUPLE(CBCMR_OFFSET, + CCM_CBCMR_LPSPI_CLK_SEL_SHIFT, + CCM_CBCMR_LPSPI_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< lpspi mux name */ - kCLOCK_FlexspiMux = CCM_TUPLE(CSCMR1, + kCLOCK_FlexspiMux = CCM_TUPLE(CSCMR1_OFFSET, CCM_CSCMR1_FLEXSPI_CLK_SEL_SHIFT, CCM_CSCMR1_FLEXSPI_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< flexspi mux name */ - kCLOCK_Usdhc2Mux = CCM_TUPLE(CSCMR1, + kCLOCK_Usdhc2Mux = CCM_TUPLE(CSCMR1_OFFSET, CCM_CSCMR1_USDHC2_CLK_SEL_SHIFT, CCM_CSCMR1_USDHC2_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< usdhc2 mux name */ - kCLOCK_Usdhc1Mux = CCM_TUPLE(CSCMR1, + kCLOCK_Usdhc1Mux = CCM_TUPLE(CSCMR1_OFFSET, CCM_CSCMR1_USDHC1_CLK_SEL_SHIFT, CCM_CSCMR1_USDHC1_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< usdhc1 mux name */ - kCLOCK_Sai3Mux = CCM_TUPLE( - CSCMR1, CCM_CSCMR1_SAI3_CLK_SEL_SHIFT, CCM_CSCMR1_SAI3_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< sai3 mux name */ - kCLOCK_Sai2Mux = CCM_TUPLE( - CSCMR1, CCM_CSCMR1_SAI2_CLK_SEL_SHIFT, CCM_CSCMR1_SAI2_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< sai2 mux name */ - kCLOCK_Sai1Mux = CCM_TUPLE( - CSCMR1, CCM_CSCMR1_SAI1_CLK_SEL_SHIFT, CCM_CSCMR1_SAI1_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< sai1 mux name */ - kCLOCK_PerclkMux = CCM_TUPLE(CSCMR1, + kCLOCK_Sai3Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_SAI3_CLK_SEL_SHIFT, + CCM_CSCMR1_SAI3_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< sai3 mux name */ + kCLOCK_Sai2Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_SAI2_CLK_SEL_SHIFT, + CCM_CSCMR1_SAI2_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< sai2 mux name */ + kCLOCK_Sai1Mux = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_SAI1_CLK_SEL_SHIFT, + CCM_CSCMR1_SAI1_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< sai1 mux name */ + kCLOCK_PerclkMux = CCM_TUPLE(CSCMR1_OFFSET, CCM_CSCMR1_PERCLK_CLK_SEL_SHIFT, CCM_CSCMR1_PERCLK_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< perclk mux name */ - kCLOCK_Flexio2Mux = CCM_TUPLE(CSCMR2, + kCLOCK_Flexio2Mux = CCM_TUPLE(CSCMR2_OFFSET, CCM_CSCMR2_FLEXIO2_CLK_SEL_SHIFT, CCM_CSCMR2_FLEXIO2_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< flexio2 mux name */ - kCLOCK_CanMux = CCM_TUPLE( - CSCMR2, CCM_CSCMR2_CAN_CLK_SEL_SHIFT, CCM_CSCMR2_CAN_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< can mux name */ + kCLOCK_CanMux = CCM_TUPLE(CSCMR2_OFFSET, + CCM_CSCMR2_CAN_CLK_SEL_SHIFT, + CCM_CSCMR2_CAN_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< can mux name */ - kCLOCK_UartMux = CCM_TUPLE( - CSCDR1, CCM_CSCDR1_UART_CLK_SEL_SHIFT, CCM_CSCDR1_UART_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< uart mux name */ + kCLOCK_UartMux = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_UART_CLK_SEL_SHIFT, + CCM_CSCDR1_UART_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< uart mux name */ - kCLOCK_SpdifMux = CCM_TUPLE( - CDCDR, CCM_CDCDR_SPDIF0_CLK_SEL_SHIFT, CCM_CDCDR_SPDIF0_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< spdif mux name */ - kCLOCK_Flexio1Mux = CCM_TUPLE(CDCDR, + kCLOCK_SpdifMux = CCM_TUPLE(CDCDR_OFFSET, + CCM_CDCDR_SPDIF0_CLK_SEL_SHIFT, + CCM_CDCDR_SPDIF0_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< spdif mux name */ + kCLOCK_Flexio1Mux = CCM_TUPLE(CDCDR_OFFSET, CCM_CDCDR_FLEXIO1_CLK_SEL_SHIFT, CCM_CDCDR_FLEXIO1_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< flexio1 mux name */ - kCLOCK_Lpi2cMux = CCM_TUPLE( - CSCDR2, CCM_CSCDR2_LPI2C_CLK_SEL_SHIFT, CCM_CSCDR2_LPI2C_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< lpi2c mux name */ - kCLOCK_LcdifPreMux = CCM_TUPLE(CSCDR2, + kCLOCK_Lpi2cMux = CCM_TUPLE(CSCDR2_OFFSET, + CCM_CSCDR2_LPI2C_CLK_SEL_SHIFT, + CCM_CSCDR2_LPI2C_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< lpi2c mux name */ + kCLOCK_LcdifPreMux = CCM_TUPLE(CSCDR2_OFFSET, CCM_CSCDR2_LCDIF_PRE_CLK_SEL_SHIFT, CCM_CSCDR2_LCDIF_PRE_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< lcdif pre mux name */ - kCLOCK_CsiMux = CCM_TUPLE( - CSCDR3, CCM_CSCDR3_CSI_CLK_SEL_SHIFT, CCM_CSCDR3_CSI_CLK_SEL_MASK, CCM_NO_BUSY_WAIT), /*!< csi mux name */ + kCLOCK_CsiMux = CCM_TUPLE(CSCDR3_OFFSET, + CCM_CSCDR3_CSI_CLK_SEL_SHIFT, + CCM_CSCDR3_CSI_CLK_SEL_MASK, + CCM_NO_BUSY_WAIT), /*!< csi mux name */ } clock_mux_t; /*! @@ -656,104 +729,130 @@ typedef enum _clock_mux */ typedef enum _clock_div { - kCLOCK_ArmDiv = CCM_TUPLE( - CACRR, CCM_CACRR_ARM_PODF_SHIFT, CCM_CACRR_ARM_PODF_MASK, CCM_CDHIPR_ARM_PODF_BUSY_SHIFT), /*!< core div name */ + kCLOCK_ArmDiv = CCM_TUPLE(CACRR_OFFSET, + CCM_CACRR_ARM_PODF_SHIFT, + CCM_CACRR_ARM_PODF_MASK, + CCM_CDHIPR_ARM_PODF_BUSY_SHIFT), /*!< core div name */ - kCLOCK_PeriphClk2Div = CCM_TUPLE(CBCDR, + kCLOCK_PeriphClk2Div = CCM_TUPLE(CBCDR_OFFSET, CCM_CBCDR_PERIPH_CLK2_PODF_SHIFT, CCM_CBCDR_PERIPH_CLK2_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< periph clock2 div name */ - kCLOCK_SemcDiv = CCM_TUPLE(CBCDR, + kCLOCK_SemcDiv = CCM_TUPLE(CBCDR_OFFSET, CCM_CBCDR_SEMC_PODF_SHIFT, CCM_CBCDR_SEMC_PODF_MASK, CCM_CDHIPR_SEMC_PODF_BUSY_SHIFT), /*!< semc div name */ - kCLOCK_AhbDiv = CCM_TUPLE( - CBCDR, CCM_CBCDR_AHB_PODF_SHIFT, CCM_CBCDR_AHB_PODF_MASK, CCM_CDHIPR_AHB_PODF_BUSY_SHIFT), /*!< ahb div name */ - kCLOCK_IpgDiv = - CCM_TUPLE(CBCDR, CCM_CBCDR_IPG_PODF_SHIFT, CCM_CBCDR_IPG_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< ipg div name */ + kCLOCK_AhbDiv = CCM_TUPLE(CBCDR_OFFSET, + CCM_CBCDR_AHB_PODF_SHIFT, + CCM_CBCDR_AHB_PODF_MASK, + CCM_CDHIPR_AHB_PODF_BUSY_SHIFT), /*!< ahb div name */ + kCLOCK_IpgDiv = CCM_TUPLE( + CBCDR_OFFSET, CCM_CBCDR_IPG_PODF_SHIFT, CCM_CBCDR_IPG_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< ipg div name */ kCLOCK_LpspiDiv = CCM_TUPLE( - CBCMR, CCM_CBCMR_LPSPI_PODF_SHIFT, CCM_CBCMR_LPSPI_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< lpspi div name */ + CBCMR_OFFSET, CCM_CBCMR_LPSPI_PODF_SHIFT, CCM_CBCMR_LPSPI_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< lpspi div name */ kCLOCK_LcdifDiv = CCM_TUPLE( - CBCMR, CCM_CBCMR_LCDIF_PODF_SHIFT, CCM_CBCMR_LCDIF_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< lcdif div name */ + CBCMR_OFFSET, CCM_CBCMR_LCDIF_PODF_SHIFT, CCM_CBCMR_LCDIF_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< lcdif div name */ - kCLOCK_FlexspiDiv = CCM_TUPLE( - CSCMR1, CCM_CSCMR1_FLEXSPI_PODF_SHIFT, CCM_CSCMR1_FLEXSPI_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< flexspi div name */ - kCLOCK_PerclkDiv = CCM_TUPLE( - CSCMR1, CCM_CSCMR1_PERCLK_PODF_SHIFT, CCM_CSCMR1_PERCLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< perclk div name */ + kCLOCK_FlexspiDiv = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_FLEXSPI_PODF_SHIFT, + CCM_CSCMR1_FLEXSPI_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< flexspi div name */ + kCLOCK_PerclkDiv = CCM_TUPLE(CSCMR1_OFFSET, + CCM_CSCMR1_PERCLK_PODF_SHIFT, + CCM_CSCMR1_PERCLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< perclk div name */ - kCLOCK_CanDiv = CCM_TUPLE( - CSCMR2, CCM_CSCMR2_CAN_CLK_PODF_SHIFT, CCM_CSCMR2_CAN_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< can div name */ + kCLOCK_CanDiv = CCM_TUPLE(CSCMR2_OFFSET, + CCM_CSCMR2_CAN_CLK_PODF_SHIFT, + CCM_CSCMR2_CAN_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< can div name */ - kCLOCK_TraceDiv = CCM_TUPLE( - CSCDR1, CCM_CSCDR1_TRACE_PODF_SHIFT, CCM_CSCDR1_TRACE_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< trace div name */ - kCLOCK_Usdhc2Div = CCM_TUPLE( - CSCDR1, CCM_CSCDR1_USDHC2_PODF_SHIFT, CCM_CSCDR1_USDHC2_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< usdhc2 div name */ - kCLOCK_Usdhc1Div = CCM_TUPLE( - CSCDR1, CCM_CSCDR1_USDHC1_PODF_SHIFT, CCM_CSCDR1_USDHC1_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< usdhc1 div name */ - kCLOCK_UartDiv = CCM_TUPLE( - CSCDR1, CCM_CSCDR1_UART_CLK_PODF_SHIFT, CCM_CSCDR1_UART_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< uart div name */ + kCLOCK_TraceDiv = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_TRACE_PODF_SHIFT, + CCM_CSCDR1_TRACE_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< trace div name */ + kCLOCK_Usdhc2Div = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_USDHC2_PODF_SHIFT, + CCM_CSCDR1_USDHC2_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< usdhc2 div name */ + kCLOCK_Usdhc1Div = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_USDHC1_PODF_SHIFT, + CCM_CSCDR1_USDHC1_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< usdhc1 div name */ + kCLOCK_UartDiv = CCM_TUPLE(CSCDR1_OFFSET, + CCM_CSCDR1_UART_CLK_PODF_SHIFT, + CCM_CSCDR1_UART_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< uart div name */ - kCLOCK_Flexio2Div = CCM_TUPLE(CS1CDR, + kCLOCK_Flexio2Div = CCM_TUPLE(CS1CDR_OFFSET, CCM_CS1CDR_FLEXIO2_CLK_PODF_SHIFT, CCM_CS1CDR_FLEXIO2_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< flexio2 pre div name */ - kCLOCK_Sai3PreDiv = CCM_TUPLE(CS1CDR, + kCLOCK_Sai3PreDiv = CCM_TUPLE(CS1CDR_OFFSET, CCM_CS1CDR_SAI3_CLK_PRED_SHIFT, CCM_CS1CDR_SAI3_CLK_PRED_MASK, CCM_NO_BUSY_WAIT), /*!< sai3 pre div name */ - kCLOCK_Sai3Div = CCM_TUPLE( - CS1CDR, CCM_CS1CDR_SAI3_CLK_PODF_SHIFT, CCM_CS1CDR_SAI3_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< sai3 div name */ - kCLOCK_Flexio2PreDiv = CCM_TUPLE(CS1CDR, + kCLOCK_Sai3Div = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_SAI3_CLK_PODF_SHIFT, + CCM_CS1CDR_SAI3_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< sai3 div name */ + kCLOCK_Flexio2PreDiv = CCM_TUPLE(CS1CDR_OFFSET, CCM_CS1CDR_FLEXIO2_CLK_PRED_SHIFT, CCM_CS1CDR_FLEXIO2_CLK_PRED_MASK, CCM_NO_BUSY_WAIT), /*!< sai3 pre div name */ - kCLOCK_Sai1PreDiv = CCM_TUPLE(CS1CDR, + kCLOCK_Sai1PreDiv = CCM_TUPLE(CS1CDR_OFFSET, CCM_CS1CDR_SAI1_CLK_PRED_SHIFT, CCM_CS1CDR_SAI1_CLK_PRED_MASK, CCM_NO_BUSY_WAIT), /*!< sai1 pre div name */ - kCLOCK_Sai1Div = CCM_TUPLE( - CS1CDR, CCM_CS1CDR_SAI1_CLK_PODF_SHIFT, CCM_CS1CDR_SAI1_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< sai1 div name */ + kCLOCK_Sai1Div = CCM_TUPLE(CS1CDR_OFFSET, + CCM_CS1CDR_SAI1_CLK_PODF_SHIFT, + CCM_CS1CDR_SAI1_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< sai1 div name */ - kCLOCK_Sai2PreDiv = CCM_TUPLE(CS2CDR, + kCLOCK_Sai2PreDiv = CCM_TUPLE(CS2CDR_OFFSET, CCM_CS2CDR_SAI2_CLK_PRED_SHIFT, CCM_CS2CDR_SAI2_CLK_PRED_MASK, CCM_NO_BUSY_WAIT), /*!< sai2 pre div name */ - kCLOCK_Sai2Div = CCM_TUPLE( - CS2CDR, CCM_CS2CDR_SAI2_CLK_PODF_SHIFT, CCM_CS2CDR_SAI2_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< sai2 div name */ + kCLOCK_Sai2Div = CCM_TUPLE(CS2CDR_OFFSET, + CCM_CS2CDR_SAI2_CLK_PODF_SHIFT, + CCM_CS2CDR_SAI2_CLK_PODF_MASK, + CCM_NO_BUSY_WAIT), /*!< sai2 div name */ - kCLOCK_Spdif0PreDiv = CCM_TUPLE(CDCDR, + kCLOCK_Spdif0PreDiv = CCM_TUPLE(CDCDR_OFFSET, CCM_CDCDR_SPDIF0_CLK_PRED_SHIFT, CCM_CDCDR_SPDIF0_CLK_PRED_MASK, CCM_NO_BUSY_WAIT), /*!< spdif pre div name */ - kCLOCK_Spdif0Div = CCM_TUPLE(CDCDR, + kCLOCK_Spdif0Div = CCM_TUPLE(CDCDR_OFFSET, CCM_CDCDR_SPDIF0_CLK_PODF_SHIFT, CCM_CDCDR_SPDIF0_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< spdif div name */ - kCLOCK_Flexio1PreDiv = CCM_TUPLE(CDCDR, + kCLOCK_Flexio1PreDiv = CCM_TUPLE(CDCDR_OFFSET, CCM_CDCDR_FLEXIO1_CLK_PRED_SHIFT, CCM_CDCDR_FLEXIO1_CLK_PRED_MASK, CCM_NO_BUSY_WAIT), /*!< flexio1 pre div name */ - kCLOCK_Flexio1Div = CCM_TUPLE(CDCDR, + kCLOCK_Flexio1Div = CCM_TUPLE(CDCDR_OFFSET, CCM_CDCDR_FLEXIO1_CLK_PODF_SHIFT, CCM_CDCDR_FLEXIO1_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< flexio1 div name */ - kCLOCK_Lpi2cDiv = CCM_TUPLE(CSCDR2, + kCLOCK_Lpi2cDiv = CCM_TUPLE(CSCDR2_OFFSET, CCM_CSCDR2_LPI2C_CLK_PODF_SHIFT, CCM_CSCDR2_LPI2C_CLK_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< lpi2c div name */ - kCLOCK_LcdifPreDiv = CCM_TUPLE( - CSCDR2, CCM_CSCDR2_LCDIF_PRED_SHIFT, CCM_CSCDR2_LCDIF_PRED_MASK, CCM_NO_BUSY_WAIT), /*!< lcdif pre div name */ + kCLOCK_LcdifPreDiv = CCM_TUPLE(CSCDR2_OFFSET, + CCM_CSCDR2_LCDIF_PRED_SHIFT, + CCM_CSCDR2_LCDIF_PRED_MASK, + CCM_NO_BUSY_WAIT), /*!< lcdif pre div name */ - kCLOCK_CsiDiv = - CCM_TUPLE(CSCDR3, CCM_CSCDR3_CSI_PODF_SHIFT, CCM_CSCDR3_CSI_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< csi div name */ + kCLOCK_CsiDiv = CCM_TUPLE( + CSCDR3_OFFSET, CCM_CSCDR3_CSI_PODF_SHIFT, CCM_CSCDR3_CSI_PODF_MASK, CCM_NO_BUSY_WAIT), /*!< csi div name */ } clock_div_t; /*! @brief USB clock source definition. */ typedef enum _clock_usb_src { - kCLOCK_Usb480M = 0, /*!< Use 480M. */ + kCLOCK_Usb480M = 0, /*!< Use 480M. */ kCLOCK_UsbSrcUnused = (int)0xFFFFFFFFU, /*!< Used when the function does not care the clock source. */ } clock_usb_src_t; @@ -768,7 +867,7 @@ typedef enum _clock_usb_phy_src enum _clock_pll_clk_src { kCLOCK_PllClkSrc24M = 0U, /*!< Pll clock source 24M */ - kCLOCK_PllSrcClkPN = 1U, /*!< Pll clock source CLK1_P and CLK1_N */ + kCLOCK_PllSrcClkPN = 1U, /*!< Pll clock source CLK1_P and CLK1_N */ }; /*! @brief PLL configuration for ARM */ @@ -842,17 +941,17 @@ typedef struct _clock_enet_pll_config /*! @brief PLL name */ typedef enum _clock_pll { - kCLOCK_PllArm = CCM_ANALOG_TUPLE(PLL_ARM, CCM_ANALOG_PLL_ARM_ENABLE_SHIFT), /*!< PLL ARM */ - kCLOCK_PllSys = CCM_ANALOG_TUPLE(PLL_SYS, CCM_ANALOG_PLL_SYS_ENABLE_SHIFT), /*!< PLL SYS */ - kCLOCK_PllUsb1 = CCM_ANALOG_TUPLE(PLL_USB1, CCM_ANALOG_PLL_USB1_ENABLE_SHIFT), /*!< PLL USB1 */ - kCLOCK_PllAudio = CCM_ANALOG_TUPLE(PLL_AUDIO, CCM_ANALOG_PLL_AUDIO_ENABLE_SHIFT), /*!< PLL Audio */ - kCLOCK_PllVideo = CCM_ANALOG_TUPLE(PLL_VIDEO, CCM_ANALOG_PLL_VIDEO_ENABLE_SHIFT), /*!< PLL Video */ + kCLOCK_PllArm = CCM_ANALOG_TUPLE(PLL_ARM_OFFSET, CCM_ANALOG_PLL_ARM_ENABLE_SHIFT), /*!< PLL ARM */ + kCLOCK_PllSys = CCM_ANALOG_TUPLE(PLL_SYS_OFFSET, CCM_ANALOG_PLL_SYS_ENABLE_SHIFT), /*!< PLL SYS */ + kCLOCK_PllUsb1 = CCM_ANALOG_TUPLE(PLL_USB1_OFFSET, CCM_ANALOG_PLL_USB1_ENABLE_SHIFT), /*!< PLL USB1 */ + kCLOCK_PllAudio = CCM_ANALOG_TUPLE(PLL_AUDIO_OFFSET, CCM_ANALOG_PLL_AUDIO_ENABLE_SHIFT), /*!< PLL Audio */ + kCLOCK_PllVideo = CCM_ANALOG_TUPLE(PLL_VIDEO_OFFSET, CCM_ANALOG_PLL_VIDEO_ENABLE_SHIFT), /*!< PLL Video */ - kCLOCK_PllEnet = CCM_ANALOG_TUPLE(PLL_ENET, CCM_ANALOG_PLL_ENET_ENABLE_SHIFT), /*!< PLL Enet0 */ + kCLOCK_PllEnet = CCM_ANALOG_TUPLE(PLL_ENET_OFFSET, CCM_ANALOG_PLL_ENET_ENABLE_SHIFT), /*!< PLL Enet0 */ - kCLOCK_PllEnet25M = CCM_ANALOG_TUPLE(PLL_ENET, CCM_ANALOG_PLL_ENET_ENET_25M_REF_EN_SHIFT), /*!< PLL Enet1 */ + kCLOCK_PllEnet25M = CCM_ANALOG_TUPLE(PLL_ENET_OFFSET, CCM_ANALOG_PLL_ENET_ENET_25M_REF_EN_SHIFT), /*!< PLL Enet1 */ - kCLOCK_PllUsb2 = CCM_ANALOG_TUPLE(PLL_USB2, CCM_ANALOG_PLL_USB2_ENABLE_SHIFT), /*!< PLL USB2 */ + kCLOCK_PllUsb2 = CCM_ANALOG_TUPLE(PLL_USB2_OFFSET, CCM_ANALOG_PLL_USB2_ENABLE_SHIFT), /*!< PLL USB2 */ } clock_pll_t; @@ -883,7 +982,7 @@ static inline void CLOCK_SetMux(clock_mux_t mux, uint32_t value) { uint32_t busyShift; - busyShift = CCM_TUPLE_BUSY_SHIFT(mux); + busyShift = CCM_TUPLE_BUSY_SHIFT(mux); CCM_TUPLE_REG(CCM, mux) = (CCM_TUPLE_REG(CCM, mux) & (~CCM_TUPLE_MASK(mux))) | (((uint32_t)((value) << CCM_TUPLE_SHIFT(mux))) & CCM_TUPLE_MASK(mux)); @@ -920,7 +1019,7 @@ static inline void CLOCK_SetDiv(clock_div_t divider, uint32_t value) { uint32_t busyShift; - busyShift = CCM_TUPLE_BUSY_SHIFT(divider); + busyShift = CCM_TUPLE_BUSY_SHIFT(divider); CCM_TUPLE_REG(CCM, divider) = (CCM_TUPLE_REG(CCM, divider) & (~CCM_TUPLE_MASK(divider))) | (((uint32_t)((value) << CCM_TUPLE_SHIFT(divider))) & CCM_TUPLE_MASK(divider)); @@ -960,7 +1059,7 @@ static inline void CLOCK_ControlGate(clock_ip_name_t name, clock_gate_value_t va assert(index <= 6); - reg = ((volatile uint32_t *)&CCM->CCGR0) + index; + reg = ((volatile uint32_t *)&CCM->CCGR0) + index; *reg = ((*reg) & ~(3U << shift)) | (((uint32_t)value) << shift); } @@ -1460,6 +1559,16 @@ bool CLOCK_EnableUsbhs1PhyPllClock(clock_usb_phy_src_t src, uint32_t freq); */ void CLOCK_DisableUsbhs1PhyPllClock(void); +/*! + * @brief Use DWT to delay at least for some time. + * Please note that, this API will calculate the microsecond period with the maximum + * supported CPU frequency, so this API will only delay for at least the given microseconds, if precise + * delay count was needed, please implement a new timer count to achieve this function. + * + * @param delay_us Delay time in unit of microsecond. + */ +void SDK_DelayAtLeastUs(uint32_t delay_us); + /* @} */ #if defined(__cplusplus) diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_common.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_common.h old mode 100644 new mode 100755 similarity index 97% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_common.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_common.h index d8a74ce4..0b0eca9e --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_common.h +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_common.h @@ -2,10 +2,30 @@ * Copyright (c) 2015-2016, Freescale Semiconductor, Inc. * Copyright 2016-2018 NXP * All rights reserved. - * + * * SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_common.h + * @brief common drivers header + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + #ifndef _FSL_COMMON_H_ #define _FSL_COMMON_H_ @@ -126,7 +146,7 @@ enum _status_groups kStatusGroup_LPC_I2C_1 = 97, /*!< Group number for LPC_I2C_1 status codes. */ kStatusGroup_NOTIFIER = 98, /*!< Group number for NOTIFIER status codes. */ kStatusGroup_DebugConsole = 99, /*!< Group number for debug console status codes. */ - kStatusGroup_SEMC = 100, /*!< Group number for SEMC status codes. */ + kStatusGroup_SEMC = 100, /*!< Group number for SEMC status codes. */ kStatusGroup_ApplicationRangeStart = 101, /*!< Starting number for application groups. */ kStatusGroup_IAP = 102, /*!< Group number for IAP status codes */ @@ -371,7 +391,7 @@ _Pragma("diag_suppress=Pm120") #define AT_QUICKACCESS_SECTION_DATA(func) func #else #error Toolchain not supported. -#endif +#endif #endif /* __FSL_SDK_DRIVER_QUICK_ACCESS_ENABLE */ /* @} */ @@ -525,7 +545,7 @@ _Pragma("diag_suppress=Pm120") */ uint32_t InstallIRQHandler(IRQn_Type irq, uint32_t irqHandler); #endif /* ENABLE_RAM_VECTOR_TABLE. */ - + #if (defined(FSL_FEATURE_SOC_SYSCON_COUNT) && (FSL_FEATURE_SOC_SYSCON_COUNT > 0)) /*! * @brief Enable specific interrupt for wake-up from deep-sleep mode. @@ -566,15 +586,15 @@ _Pragma("diag_suppress=Pm120") * @param size The length required to malloc. * @param alignbytes The alignment size. * @retval The allocated memory. - */ + */ void *SDK_Malloc(size_t size, size_t alignbytes); - + /*! * @brief Free memory. * * @param ptr The memory to be release. - */ - void SDK_Free(void *ptr); + */ + void SDK_Free(void *ptr); #if defined(__cplusplus) } diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_debug_console.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_debug_console.h new file mode 100755 index 00000000..c40971bf --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_debug_console.h @@ -0,0 +1,213 @@ +/* + * Copyright (c) 2013 - 2015, Freescale Semiconductor, Inc. + * Copyright 2016-2018 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + * + * Debug console shall provide input and output functions to scan and print formatted data. + * o Support a format specifier for PRINTF follows this prototype "%[flags][width][.precision][length]specifier" + * - [flags] :'-', '+', '#', ' ', '0' + * - [width]: number (0,1...) + * - [.precision]: number (0,1...) + * - [length]: do not support + * - [specifier]: 'd', 'i', 'f', 'F', 'x', 'X', 'o', 'p', 'u', 'c', 's', 'n' + * o Support a format specifier for SCANF follows this prototype " %[*][width][length]specifier" + * - [*]: is supported. + * - [width]: number (0,1...) + * - [length]: 'h', 'hh', 'l','ll','L'. ignore ('j','z','t') + * - [specifier]: 'd', 'i', 'u', 'f', 'F', 'e', 'E', 'g', 'G', 'a', 'A', 'o', 'c', 's' + */ + +#ifndef _FSL_DEBUGCONSOLE_H_ +#define _FSL_DEBUGCONSOLE_H_ + +#include "fsl_common.h" +//#include "serial_manager.h" + +/*! + * @addtogroup debugconsole + * @{ + */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +extern serial_handle_t g_serialHandle; /*!< serial manager handle */ + +/*! @brief Definition select redirect toolchain printf, scanf to uart or not. */ +#define DEBUGCONSOLE_REDIRECT_TO_TOOLCHAIN 0U /*!< Select toolchain printf and scanf. */ +#define DEBUGCONSOLE_REDIRECT_TO_SDK 1U /*!< Select SDK version printf, scanf. */ +#define DEBUGCONSOLE_DISABLE 2U /*!< Disable debugconsole function. */ + +/*! @brief Definition to select sdk or toolchain printf, scanf. The macro only support + * to be redefined in project setting. + */ +#ifndef SDK_DEBUGCONSOLE +#define SDK_DEBUGCONSOLE 1U +#endif + +/*! @brief Definition to select redirect toolchain printf, scanf to uart or not. */ +#ifndef SDK_DEBUGCONSOLE_UART +/* mcux will handle this macro, not define it here */ +#if (!defined(__MCUXPRESSO)) +#define SDK_DEBUGCONSOLE_UART +#endif +#endif + +#if defined(SDK_DEBUGCONSOLE) && !(SDK_DEBUGCONSOLE) +#include +#endif + +/*! @brief Definition to select redirect toolchain printf, scanf to uart or not. + * + * if SDK_DEBUGCONSOLE defined to 0,it represents select toolchain printf, scanf. + * if SDK_DEBUGCONSOLE defined to 1,it represents select SDK version printf, scanf. + * if SDK_DEBUGCONSOLE defined to 2,it represents disable debugconsole function. + */ +#if SDK_DEBUGCONSOLE == DEBUGCONSOLE_DISABLE /* Disable debug console */ +#define PRINTF +#define SCANF +#define PUTCHAR +#define GETCHAR +#elif SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_SDK /* Select printf, scanf, putchar, getchar of SDK version. */ +#define PRINTF DbgConsole_Printf +#define SCANF DbgConsole_Scanf +#define PUTCHAR DbgConsole_Putchar +#define GETCHAR DbgConsole_Getchar +#elif SDK_DEBUGCONSOLE == DEBUGCONSOLE_REDIRECT_TO_TOOLCHAIN /* Select printf, scanf, putchar, getchar of toolchain. \ \ + */ +#define PRINTF printf +#define SCANF scanf +#define PUTCHAR putchar +#define GETCHAR getchar +#endif /* SDK_DEBUGCONSOLE */ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif /* __cplusplus */ + +/*! @name Initialization*/ +/* @{ */ + +/*! + * @brief Initializes the peripheral used for debug messages. + * + * Call this function to enable debug log messages to be output via the specified peripheral + * initialized by the serial manager module. + * After this function has returned, stdout and stdin are connected to the selected peripheral. + * + * @param instance The instance of the module. + * @param baudRate The desired baud rate in bits per second. + * @param device Low level device type for the debug console, can be one of the following. + * @arg kSerialPort_Uart, + * @arg kSerialPort_UsbCdc + * @arg kSerialPort_UsbCdcVirtual. + * @param clkSrcFreq Frequency of peripheral source clock. + * + * @return Indicates whether initialization was successful or not. + * @retval kStatus_Success Execution successfully + */ +status_t DbgConsole_Init(uint8_t instance, uint32_t baudRate, serial_port_type_t device, uint32_t clkSrcFreq); + +/*! + * @brief De-initializes the peripheral used for debug messages. + * + * Call this function to disable debug log messages to be output via the specified peripheral + * initialized by the serial manager module. + * + * @return Indicates whether de-initialization was successful or not. + */ +status_t DbgConsole_Deinit(void); + +#if SDK_DEBUGCONSOLE +/*! + * @brief Writes formatted output to the standard output stream. + * + * Call this function to write a formatted output to the standard output stream. + * + * @param formatString Format control string. + * @return Returns the number of characters printed or a negative value if an error occurs. + */ +int DbgConsole_Printf(const char *formatString, ...); + +/*! + * @brief Writes a character to stdout. + * + * Call this function to write a character to stdout. + * + * @param ch Character to be written. + * @return Returns the character written. + */ +int DbgConsole_Putchar(int ch); + +/*! + * @brief Reads formatted data from the standard input stream. + * + * Call this function to read formatted data from the standard input stream. + * + * @note Due the limitation in the BM OSA environment (CPU is blocked in the function, + * other tasks will not be scheduled), the function cannot be used when the + * DEBUG_CONSOLE_TRANSFER_NON_BLOCKING is set in the BM OSA environment. + * And an error is returned when the function called in this case. The suggestion + * is that polling the non-blocking function DbgConsole_TryGetchar to get the input char. + * + * @param formatString Format control string. + * @return Returns the number of fields successfully converted and assigned. + */ +int DbgConsole_Scanf(char *formatString, ...); + +/*! + * @brief Reads a character from standard input. + * + * Call this function to read a character from standard input. + * + * @note Due the limitation in the BM OSA environment (CPU is blocked in the function, + * other tasks will not be scheduled), the function cannot be used when the + * DEBUG_CONSOLE_TRANSFER_NON_BLOCKING is set in the BM OSA environment. + * And an error is returned when the function called in this case. The suggestion + * is that polling the non-blocking function DbgConsole_TryGetchar to get the input char. + * + * @return Returns the character read. + */ +int DbgConsole_Getchar(void); + +/*! + * @brief Debug console flush. + * + * Call this function to wait the tx buffer empty. + * If interrupt transfer is using, make sure the global IRQ is enable before call this function + * This function should be called when + * 1, before enter power down mode + * 2, log is required to print to terminal immediately + * @return Indicates whether wait idle was successful or not. + */ +status_t DbgConsole_Flush(void); + +#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING +/*! + * @brief Debug console try to get char + * This function provides a API which will not block current task, if character is + * available return it, otherwise return fail. + * @param ch the address of char to receive + * @return Indicates get char was successful or not. + */ +status_t DbgConsole_TryGetchar(char *ch); +#endif + +#endif /* SDK_DEBUGCONSOLE */ + +/*! @} */ + +#if defined(__cplusplus) +} +#endif /* __cplusplus */ + +/*! @} */ + +#endif /* _FSL_DEBUGCONSOLE_H_ */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_debug_console_conf.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_debug_console_conf.h new file mode 100755 index 00000000..4c36a7dd --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_debug_console_conf.h @@ -0,0 +1,158 @@ +/* + * Copyright 2017 - 2019 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ +#ifndef _FSL_DEBUG_CONSOLE_CONF_H_ +#define _FSL_DEBUG_CONSOLE_CONF_H_ + +/****************Debug console configuration********************/ + +/*! @brief If Non-blocking mode is needed, please define it at project setting, + * otherwise blocking mode is the default transfer mode. + * Warning: If you want to use non-blocking transfer,please make sure the corresponding + * IO interrupt is enable, otherwise there is no output. + * And non-blocking is combine with buffer, no matter bare-metal or rtos. + * Below shows how to configure in your project if you want to use non-blocking mode. + * For IAR, right click project and select "Options", define it in "C/C++ Compiler->Preprocessor->Defined symbols". + * For KEIL, click "Options for Target…", define it in "C/C++->Preprocessor Symbols->Define". + * For ARMGCC, open CmakeLists.txt and add the following lines, + * "SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG_CONSOLE_TRANSFER_NON_BLOCKING")" for debug target. + * "SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -DDEBUG_CONSOLE_TRANSFER_NON_BLOCKING")" for release target. + * For MCUxpresso, right click project and select "Properties", define it in "C/C++ Build->Settings->MCU C + * Complier->Preprocessor". + * + */ +#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING +/*! @brief define the transmit buffer length which is used to store the multi task log, buffer is enabled automatically + * when + * non-blocking transfer is using, + * This value will affect the RAM's ultilization, should be set per paltform's capability and software requirement. + * If it is configured too small, log maybe missed , because the log will not be + * buffered if the buffer is full, and the print will return immediately with -1. + * And this value should be multiple of 4 to meet memory alignment. + * + */ +#ifndef DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN +#define DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN (512U) +#endif /* DEBUG_CONSOLE_TRANSMIT_BUFFER_LEN */ + +/*! @brief define the receive buffer length which is used to store the user input, buffer is enabled automatically when + * non-blocking transfer is using, + * This value will affect the RAM's ultilization, should be set per paltform's capability and software requirement. + * If it is configured too small, log maybe missed, because buffer will be overwrited if buffer is too small. + * And this value should be multiple of 4 to meet memory alignment. + * + */ +#ifndef DEBUG_CONSOLE_RECEIVE_BUFFER_LEN +#define DEBUG_CONSOLE_RECEIVE_BUFFER_LEN (1024U) +#endif /* DEBUG_CONSOLE_RECEIVE_BUFFER_LEN */ + +/*!@ brief Whether enable the reliable TX function + * If the macro is zero, the reliable TX function of the debug console is disabled. + * When the macro is zero, the string of PRINTF will be thrown away after the transmit buffer is full. + */ +#ifndef DEBUG_CONSOLE_TX_RELIABLE_ENABLE +#define DEBUG_CONSOLE_TX_RELIABLE_ENABLE (1U) +#endif /* DEBUG_CONSOLE_RX_ENABLE */ + +#else +#define DEBUG_CONSOLE_TRANSFER_BLOCKING +#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */ + +/*!@ brief Whether enable the RX function + * If the macro is zero, the receive function of the debug console is disabled. + */ +#ifndef DEBUG_CONSOLE_RX_ENABLE +#define DEBUG_CONSOLE_RX_ENABLE (1U) +#endif /* DEBUG_CONSOLE_RX_ENABLE */ + +/*!@ brief define the MAX log length debug console support , that is when you call printf("log", x);, the log + * length can not bigger than this value. + * This macro decide the local log buffer length, the buffer locate at stack, the stack maybe overflow if + * the buffer is too big and current task stack size not big enough. + */ +#ifndef DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN +#define DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN (128U) +#endif /* DEBUG_CONSOLE_PRINTF_MAX_LOG_LEN */ + +/*!@ brief define the buffer support buffer scanf log length, that is when you call scanf("log", &x);, the log + * length can not bigger than this value. + * As same as the DEBUG_CONSOLE_BUFFER_PRINTF_MAX_LOG_LEN. + */ +#ifndef DEBUG_CONSOLE_SCANF_MAX_LOG_LEN +#define DEBUG_CONSOLE_SCANF_MAX_LOG_LEN (20U) +#endif /* DEBUG_CONSOLE_SCANF_MAX_LOG_LEN */ + +/*! @brief Debug console synchronization + * User should not change these macro for synchronization mode, but add the + * corresponding synchronization mechanism per different software environment. + * Such as, if another RTOS is used, + * add: + * #define DEBUG_CONSOLE_SYNCHRONIZATION_XXXX 3 + * in this configuration file and implement the synchronization in fsl.log.c. + */ +/*! @brief synchronization for baremetal software */ +#define DEBUG_CONSOLE_SYNCHRONIZATION_BM 0 +/*! @brief synchronization for freertos software */ +#define DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS 1 + +/*! @brief RTOS synchronization mechanism disable + * If not defined, default is enable, to avoid multitask log print mess. + * If other RTOS is used, you can implement the RTOS's specific synchronization mechanism in fsl.log.c + * If synchronization is disabled, log maybe messed on terminal. + */ +#ifndef DEBUG_CONSOLE_DISABLE_RTOS_SYNCHRONIZATION +#ifdef DEBUG_CONSOLE_TRANSFER_NON_BLOCKING +#ifdef FSL_RTOS_FREE_RTOS +#define DEBUG_CONSOLE_SYNCHRONIZATION_MODE DEBUG_CONSOLE_SYNCHRONIZATION_FREERTOS +#else +#define DEBUG_CONSOLE_SYNCHRONIZATION_MODE DEBUG_CONSOLE_SYNCHRONIZATION_BM +#endif /* FSL_RTOS_FREE_RTOS */ +#else +#define DEBUG_CONSOLE_SYNCHRONIZATION_MODE DEBUG_CONSOLE_SYNCHRONIZATION_BM +#endif /* DEBUG_CONSOLE_TRANSFER_NON_BLOCKING */ +#endif /* DEBUG_CONSOLE_DISABLE_RTOS_SYNCHRONIZATION */ + +/*! @brief echo function support + * If you want to use the echo function,please define DEBUG_CONSOLE_ENABLE_ECHO + * at your project setting. + */ +#ifndef DEBUG_CONSOLE_ENABLE_ECHO +#define DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION 0 +#else +#define DEBUG_CONSOLE_ENABLE_ECHO_FUNCTION 1 +#endif /* DEBUG_CONSOLE_ENABLE_ECHO */ + +/*********************************************************************/ + +/***************Debug console other configuration*********************/ +/*! @brief Definition to printf the float number. */ +#ifndef PRINTF_FLOAT_ENABLE +#define PRINTF_FLOAT_ENABLE 0U +#endif /* PRINTF_FLOAT_ENABLE */ + +/*! @brief Definition to scanf the float number. */ +#ifndef SCANF_FLOAT_ENABLE +#define SCANF_FLOAT_ENABLE 0U +#endif /* SCANF_FLOAT_ENABLE */ + +/*! @brief Definition to support advanced format specifier for printf. */ +#ifndef PRINTF_ADVANCED_ENABLE +#define PRINTF_ADVANCED_ENABLE 0U +#endif /* PRINTF_ADVANCED_ENABLE */ + +/*! @brief Definition to support advanced format specifier for scanf. */ +#ifndef SCANF_ADVANCED_ENABLE +#define SCANF_ADVANCED_ENABLE 0U +#endif /* SCANF_ADVANCED_ENABLE */ + +/*! @brief Definition to select virtual com(USB CDC) as the debug console. */ +#ifndef BOARD_USE_VIRTUALCOM +#define BOARD_USE_VIRTUALCOM 0U +#endif +/*******************************************************************/ + +#endif /* _FSL_DEBUG_CONSOLE_CONF_H_ */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/fsl_device_registers.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_device_registers.h old mode 100644 new mode 100755 similarity index 100% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/fsl_device_registers.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_device_registers.h diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_enet.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_enet.h new file mode 100755 index 00000000..88de1196 --- /dev/null +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_enet.h @@ -0,0 +1,1629 @@ +/* + * Copyright (c) 2015 - 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_enet.h + * @brief ethernet drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + +#ifndef _FSL_ENET_H_ +#define _FSL_ENET_H_ + +#include "fsl_common.h" +#if defined(FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET) && FSL_FEATURE_MEMORY_HAS_ADDRESS_OFFSET +#include "fsl_memory.h" +#endif +/*! + * @addtogroup enet + * @{ + */ + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/*! @name Driver version */ +/*@{*/ +/*! @brief Defines the driver version. */ +#define FSL_ENET_DRIVER_VERSION (MAKE_VERSION(2, 2, 4)) /*!< Version 2.2.4. */ +/*@}*/ + +/*! @name ENET DESCRIPTOR QUEUE */ +/*@{*/ +/*! @brief Defines the queue number. */ +#ifndef FSL_FEATURE_ENET_QUEUE +#define FSL_FEATURE_ENET_QUEUE 1 /* Singal queue for previous IP. */ +#endif +/*@}*/ + +/*! @name Control and status region bit masks of the receive buffer descriptor. */ +/*@{*/ +#define ENET_BUFFDESCRIPTOR_RX_EMPTY_MASK 0x8000U /*!< Empty bit mask. */ +#define ENET_BUFFDESCRIPTOR_RX_SOFTOWNER1_MASK 0x4000U /*!< Software owner one mask. */ +#define ENET_BUFFDESCRIPTOR_RX_WRAP_MASK 0x2000U /*!< Next buffer descriptor is the start address. */ +#define ENET_BUFFDESCRIPTOR_RX_SOFTOWNER2_Mask 0x1000U /*!< Software owner two mask. */ +#define ENET_BUFFDESCRIPTOR_RX_LAST_MASK 0x0800U /*!< Last BD of the frame mask. */ +#define ENET_BUFFDESCRIPTOR_RX_MISS_MASK 0x0100U /*!< Received because of the promiscuous mode. */ +#define ENET_BUFFDESCRIPTOR_RX_BROADCAST_MASK 0x0080U /*!< Broadcast packet mask. */ +#define ENET_BUFFDESCRIPTOR_RX_MULTICAST_MASK 0x0040U /*!< Multicast packet mask. */ +#define ENET_BUFFDESCRIPTOR_RX_LENVLIOLATE_MASK 0x0020U /*!< Length violation mask. */ +#define ENET_BUFFDESCRIPTOR_RX_NOOCTET_MASK 0x0010U /*!< Non-octet aligned frame mask. */ +#define ENET_BUFFDESCRIPTOR_RX_CRC_MASK 0x0004U /*!< CRC error mask. */ +#define ENET_BUFFDESCRIPTOR_RX_OVERRUN_MASK 0x0002U /*!< FIFO overrun mask. */ +#define ENET_BUFFDESCRIPTOR_RX_TRUNC_MASK 0x0001U /*!< Frame is truncated mask. */ +/*@}*/ + +/*! @name Control and status bit masks of the transmit buffer descriptor. */ +/*@{*/ +#define ENET_BUFFDESCRIPTOR_TX_READY_MASK 0x8000U /*!< Ready bit mask. */ +#define ENET_BUFFDESCRIPTOR_TX_SOFTOWENER1_MASK 0x4000U /*!< Software owner one mask. */ +#define ENET_BUFFDESCRIPTOR_TX_WRAP_MASK 0x2000U /*!< Wrap buffer descriptor mask. */ +#define ENET_BUFFDESCRIPTOR_TX_SOFTOWENER2_MASK 0x1000U /*!< Software owner two mask. */ +#define ENET_BUFFDESCRIPTOR_TX_LAST_MASK 0x0800U /*!< Last BD of the frame mask. */ +#define ENET_BUFFDESCRIPTOR_TX_TRANMITCRC_MASK 0x0400U /*!< Transmit CRC mask. */ +/*@}*/ + +/* Extended control regions for enhanced buffer descriptors. */ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! @name First extended control region bit masks of the receive buffer descriptor. */ +/*@{*/ +#define ENET_BUFFDESCRIPTOR_RX_IPV4_MASK 0x0001U /*!< Ipv4 frame mask. */ +#define ENET_BUFFDESCRIPTOR_RX_IPV6_MASK 0x0002U /*!< Ipv6 frame mask. */ +#define ENET_BUFFDESCRIPTOR_RX_VLAN_MASK 0x0004U /*!< VLAN frame mask. */ +#define ENET_BUFFDESCRIPTOR_RX_PROTOCOLCHECKSUM_MASK 0x0010U /*!< Protocol checksum error mask. */ +#define ENET_BUFFDESCRIPTOR_RX_IPHEADCHECKSUM_MASK 0x0020U /*!< IP header checksum error mask. */ +/*@}*/ + +/*! @name Second extended control region bit masks of the receive buffer descriptor. */ +/*@{*/ +#define ENET_BUFFDESCRIPTOR_RX_INTERRUPT_MASK 0x0080U /*!< BD interrupt mask. */ +#define ENET_BUFFDESCRIPTOR_RX_UNICAST_MASK 0x0100U /*!< Unicast frame mask. */ +#define ENET_BUFFDESCRIPTOR_RX_COLLISION_MASK 0x0200U /*!< BD collision mask. */ +#define ENET_BUFFDESCRIPTOR_RX_PHYERR_MASK 0x0400U /*!< PHY error mask. */ +#define ENET_BUFFDESCRIPTOR_RX_MACERR_MASK 0x8000U /*!< Mac error mask. */ +/*@}*/ + +/*! @name First extended control region bit masks of the transmit buffer descriptor. */ +/*@{*/ +#define ENET_BUFFDESCRIPTOR_TX_ERR_MASK 0x8000U /*!< Transmit error mask. */ +#define ENET_BUFFDESCRIPTOR_TX_UNDERFLOWERR_MASK 0x2000U /*!< Underflow error mask. */ +#define ENET_BUFFDESCRIPTOR_TX_EXCCOLLISIONERR_MASK 0x1000U /*!< Excess collision error mask. */ +#define ENET_BUFFDESCRIPTOR_TX_FRAMEERR_MASK 0x0800U /*!< Frame error mask. */ +#define ENET_BUFFDESCRIPTOR_TX_LATECOLLISIONERR_MASK 0x0400U /*!< Late collision error mask. */ +#define ENET_BUFFDESCRIPTOR_TX_OVERFLOWERR_MASK 0x0200U /*!< Overflow error mask. */ +#define ENET_BUFFDESCRIPTOR_TX_TIMESTAMPERR_MASK 0x0100U /*!< Timestamp error mask. */ +/*@}*/ + +/*! @name Second extended control region bit masks of the transmit buffer descriptor. */ +/*@{*/ +#define ENET_BUFFDESCRIPTOR_TX_INTERRUPT_MASK 0x4000U /*!< Interrupt mask. */ +#define ENET_BUFFDESCRIPTOR_TX_TIMESTAMP_MASK 0x2000U /*!< Timestamp flag mask. */ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB +#define ENET_BUFFDESCRIPTOR_TX_USETXLAUNCHTIME_MASK 0x0100U /*!< Use the transmit launch time. */ +#define ENET_BUFFDESCRIPTOR_TX_FRAMETYPE_MASK 0x00F0U /*!< Frame type mask. */ +#define ENET_BUFFDESCRIPTOR_TX_FRAMETYPE_SHIFT 4U /*!< Frame type shift. */ +#define ENET_BD_FTYPE(n) ((n << ENET_BUFFDESCRIPTOR_TX_FRAMETYPE_SHIFT) & ENET_BUFFDESCRIPTOR_TX_FRAMETYPE_MASK) +#endif /* FSL_FEATURE_ENET_HAS_AVB */ +/*@}*/ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +/*! @brief Defines the receive error status flag mask. */ +#define ENET_BUFFDESCRIPTOR_RX_ERR_MASK \ + (ENET_BUFFDESCRIPTOR_RX_TRUNC_MASK | ENET_BUFFDESCRIPTOR_RX_OVERRUN_MASK | \ + ENET_BUFFDESCRIPTOR_RX_LENVLIOLATE_MASK | ENET_BUFFDESCRIPTOR_RX_NOOCTET_MASK | ENET_BUFFDESCRIPTOR_RX_CRC_MASK) +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +#define ENET_BUFFDESCRIPTOR_RX_EXT_ERR_MASK \ + (ENET_BUFFDESCRIPTOR_RX_MACERR_MASK | ENET_BUFFDESCRIPTOR_RX_PHYERR_MASK | ENET_BUFFDESCRIPTOR_RX_COLLISION_MASK) +#endif + +/*! @name Defines some Ethernet parameters. */ +/*@{*/ +#define ENET_FRAME_MAX_FRAMELEN 1518U /*!< Default maximum Ethernet frame size. */ + +#define ENET_FIFO_MIN_RX_FULL 5U /*!< ENET minimum receive FIFO full. */ +#define ENET_RX_MIN_BUFFERSIZE 256U /*!< ENET minimum buffer size. */ +#define ENET_PHY_MAXADDRESS (ENET_MMFR_PA_MASK >> ENET_MMFR_PA_SHIFT) +#if FSL_FEATURE_ENET_QUEUE > 1 +#define ENET_TX_INTERRUPT \ + (kENET_TxFrameInterrupt | kENET_TxBufferInterrupt | kENET_TxFrame1Interrupt | kENET_TxBuffer1Interrupt | \ + kENET_TxFrame2Interrupt | kENET_TxBuffer2Interrupt) +#define ENET_RX_INTERRUPT \ + (kENET_RxFrameInterrupt | kENET_RxBufferInterrupt | kENET_RxFrame1Interrupt | kENET_RxBuffer1Interrupt | \ + kENET_RxFrame2Interrupt | kENET_RxBuffer2Interrupt) +#else +#define ENET_TX_INTERRUPT (kENET_TxFrameInterrupt | kENET_TxBufferInterrupt) +#define ENET_RX_INTERRUPT (kENET_RxFrameInterrupt | kENET_RxBufferInterrupt) +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ +#define ENET_TS_INTERRUPT (kENET_TsTimerInterrupt | kENET_TsAvailInterrupt) +#define ENET_ERR_INTERRUPT \ + (kENET_BabrInterrupt | kENET_BabtInterrupt | kENET_EBusERInterrupt | kENET_LateCollisionInterrupt | \ + kENET_RetryLimitInterrupt | kENET_UnderrunInterrupt | kENET_PayloadRxInterrupt) +#define ENET_ERR_INTERRUPT \ + (kENET_BabrInterrupt | kENET_BabtInterrupt | kENET_EBusERInterrupt | kENET_LateCollisionInterrupt | \ + kENET_RetryLimitInterrupt | kENET_UnderrunInterrupt | kENET_PayloadRxInterrupt) +/*@}*/ + +/*! @brief Defines the status return codes for transaction. */ +enum _enet_status +{ + kStatus_ENET_RxFrameError = MAKE_STATUS(kStatusGroup_ENET, 0U), /*!< A frame received but data error happen. */ + kStatus_ENET_RxFrameFail = MAKE_STATUS(kStatusGroup_ENET, 1U), /*!< Failed to receive a frame. */ + kStatus_ENET_RxFrameEmpty = MAKE_STATUS(kStatusGroup_ENET, 2U), /*!< No frame arrive. */ + kStatus_ENET_TxFrameOverLen = MAKE_STATUS(kStatusGroup_ENET, 3U), /*!< Tx frame over length. */ + kStatus_ENET_TxFrameBusy = MAKE_STATUS(kStatusGroup_ENET, 4U), /*!< Tx buffer descriptors are under process. */ + kStatus_ENET_TxFrameFail = MAKE_STATUS(kStatusGroup_ENET, 5U) /*!< Transmit frame fail. */ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + , + kStatus_ENET_PtpTsRingFull = MAKE_STATUS(kStatusGroup_ENET, 6U), /*!< Timestamp ring full. */ + kStatus_ENET_PtpTsRingEmpty = MAKE_STATUS(kStatusGroup_ENET, 7U) /*!< Timestamp ring empty. */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +}; + +/*! @brief Defines the MII/RMII/RGMII mode for data interface between the MAC and the PHY. */ +typedef enum _enet_mii_mode +{ + kENET_MiiMode = 0U, /*!< MII mode for data interface. */ + kENET_RmiiMode = 1U, /*!< RMII mode for data interface. */ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + kENET_RgmiiMode = 2U /*!< RGMII mode for data interface. */ +#endif /* FSL_FEATURE_ENET_HAS_AVB */ +} enet_mii_mode_t; + +/*! @brief Defines the 10/100/1000 Mbps speed for the MII data interface. + * + * Notice: "kENET_MiiSpeed1000M" only supported when mii mode is "kENET_RgmiiMode". + */ +typedef enum _enet_mii_speed +{ + kENET_MiiSpeed10M = 0U, /*!< Speed 10 Mbps. */ + kENET_MiiSpeed100M = 1U, /*!< Speed 100 Mbps. */ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + kENET_MiiSpeed1000M = 2U /*!< Speed 1000M bps. */ +#endif /* FSL_FEATURE_ENET_HAS_AVB */ +} enet_mii_speed_t; + +/*! @brief Defines the half or full duplex for the MII data interface. */ +typedef enum _enet_mii_duplex +{ + kENET_MiiHalfDuplex = 0U, /*!< Half duplex mode. */ + kENET_MiiFullDuplex /*!< Full duplex mode. */ +} enet_mii_duplex_t; + +/*! @brief Define the MII opcode for normal MDIO_CLAUSES_22 Frame. */ +typedef enum _enet_mii_write +{ + kENET_MiiWriteNoCompliant = 0U, /*!< Write frame operation, but not MII-compliant. */ + kENET_MiiWriteValidFrame /*!< Write frame operation for a valid MII management frame. */ +} enet_mii_write_t; + +/*! @brief Defines the read operation for the MII management frame. */ +typedef enum _enet_mii_read +{ + kENET_MiiReadValidFrame = 2U, /*!< Read frame operation for a valid MII management frame. */ + kENET_MiiReadNoCompliant = 3U /*!< Read frame operation, but not MII-compliant. */ +} enet_mii_read_t; + +#if defined(FSL_FEATURE_ENET_HAS_EXTEND_MDIO) && FSL_FEATURE_ENET_HAS_EXTEND_MDIO +/*! @brief Define the MII opcode for extended MDIO_CLAUSES_45 Frame. */ +typedef enum _enet_mii_extend_opcode +{ + kENET_MiiAddrWrite_C45 = 0U, /*!< Address Write operation. */ + kENET_MiiWriteFrame_C45 = 1U, /*!< Write frame operation for a valid MII management frame. */ + kENET_MiiReadFrame_C45 = 3U /*!< Read frame operation for a valid MII management frame. */ +} enet_mii_extend_opcode; +#endif /* FSL_FEATURE_ENET_HAS_EXTEND_MDIO */ + +/*! @brief Defines a special configuration for ENET MAC controller. + * + * These control flags are provided for special user requirements. + * Normally, these control flags are unused for ENET initialization. + * For special requirements, set the flags to + * macSpecialConfig in the enet_config_t. + * The kENET_ControlStoreAndFwdDisable is used to disable the FIFO store + * and forward. FIFO store and forward means that the FIFO read/send is started + * when a complete frame is stored in TX/RX FIFO. If this flag is set, + * configure rxFifoFullThreshold and txFifoWatermark + * in the enet_config_t. + */ +typedef enum _enet_special_control_flag +{ + kENET_ControlFlowControlEnable = 0x0001U, /*!< Enable ENET flow control: pause frame. */ + kENET_ControlRxPayloadCheckEnable = 0x0002U, /*!< Enable ENET receive payload length check. */ + kENET_ControlRxPadRemoveEnable = 0x0004U, /*!< Padding is removed from received frames. */ + kENET_ControlRxBroadCastRejectEnable = 0x0008U, /*!< Enable broadcast frame reject. */ + kENET_ControlMacAddrInsert = 0x0010U, /*!< Enable MAC address insert. */ + kENET_ControlStoreAndFwdDisable = 0x0020U, /*!< Enable FIFO store and forward. */ + kENET_ControlSMIPreambleDisable = 0x0040U, /*!< Enable SMI preamble. */ + kENET_ControlPromiscuousEnable = 0x0080U, /*!< Enable promiscuous mode. */ + kENET_ControlMIILoopEnable = 0x0100U, /*!< Enable ENET MII loop back. */ + kENET_ControlVLANTagEnable = 0x0200U, /*!< Enable normal VLAN (single vlan tag). */ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + kENET_ControlSVLANEnable = 0x0400U, /*!< Enable S-VLAN. */ + kENET_ControlVLANUseSecondTag = 0x0800U /*!< Enable extracting the second vlan tag for further processing. */ +#endif /* FSL_FEATURE_ENET_HAS_AVB */ +} enet_special_control_flag_t; + +/*! @brief List of interrupts supported by the peripheral. This + * enumeration uses one-bot encoding to allow a logical OR of multiple + * members. Members usually map to interrupt enable bits in one or more + * peripheral registers. + */ +typedef enum _enet_interrupt_enable +{ + kENET_BabrInterrupt = ENET_EIR_BABR_MASK, /*!< Babbling receive error interrupt source */ + kENET_BabtInterrupt = ENET_EIR_BABT_MASK, /*!< Babbling transmit error interrupt source */ + kENET_GraceStopInterrupt = ENET_EIR_GRA_MASK, /*!< Graceful stop complete interrupt source */ + kENET_TxFrameInterrupt = ENET_EIR_TXF_MASK, /*!< TX FRAME interrupt source */ + kENET_TxBufferInterrupt = ENET_EIR_TXB_MASK, /*!< TX BUFFER interrupt source */ + kENET_RxFrameInterrupt = ENET_EIR_RXF_MASK, /*!< RX FRAME interrupt source */ + kENET_RxBufferInterrupt = ENET_EIR_RXB_MASK, /*!< RX BUFFER interrupt source */ + kENET_MiiInterrupt = ENET_EIR_MII_MASK, /*!< MII interrupt source */ + kENET_EBusERInterrupt = ENET_EIR_EBERR_MASK, /*!< Ethernet bus error interrupt source */ + kENET_LateCollisionInterrupt = ENET_EIR_LC_MASK, /*!< Late collision interrupt source */ + kENET_RetryLimitInterrupt = ENET_EIR_RL_MASK, /*!< Collision Retry Limit interrupt source */ + kENET_UnderrunInterrupt = ENET_EIR_UN_MASK, /*!< Transmit FIFO underrun interrupt source */ + kENET_PayloadRxInterrupt = ENET_EIR_PLR_MASK, /*!< Payload Receive error interrupt source */ + kENET_WakeupInterrupt = ENET_EIR_WAKEUP_MASK, /*!< WAKEUP interrupt source */ +#if FSL_FEATURE_ENET_QUEUE > 1 + kENET_RxFlush2Interrupt = ENET_EIR_RXFLUSH_2_MASK, /*!< Rx DMA ring2 flush indication. */ + kENET_RxFlush1Interrupt = ENET_EIR_RXFLUSH_1_MASK, /*!< Rx DMA ring1 flush indication. */ + kENET_RxFlush0Interrupt = ENET_EIR_RXFLUSH_0_MASK, /*!< RX DMA ring0 flush indication. */ + kENET_TxFrame2Interrupt = ENET_EIR_TXF2_MASK, /*!< Tx frame interrupt for Tx ring/class 2. */ + kENET_TxBuffer2Interrupt = ENET_EIR_TXB2_MASK, /*!< Tx buffer interrupt for Tx ring/class 2. */ + kENET_RxFrame2Interrupt = ENET_EIR_RXF2_MASK, /*!< Rx frame interrupt for Rx ring/class 2. */ + kENET_RxBuffer2Interrupt = ENET_EIR_RXB2_MASK, /*!< Rx buffer interrupt for Rx ring/class 2. */ + kENET_TxFrame1Interrupt = ENET_EIR_TXF1_MASK, /*!< Tx frame interrupt for Tx ring/class 1. */ + kENET_TxBuffer1Interrupt = ENET_EIR_TXB1_MASK, /*!< Tx buffer interrupt for Tx ring/class 1. */ + kENET_RxFrame1Interrupt = ENET_EIR_RXF1_MASK, /*!< Rx frame interrupt for Rx ring/class 1. */ + kENET_RxBuffer1Interrupt = ENET_EIR_RXB1_MASK, /*!< Rx buffer interrupt for Rx ring/class 1. */ +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + kENET_TsAvailInterrupt = ENET_EIR_TS_AVAIL_MASK, /*!< TS AVAIL interrupt source for PTP */ + kENET_TsTimerInterrupt = ENET_EIR_TS_TIMER_MASK /*!< TS WRAP interrupt source for PTP */ +} enet_interrupt_enable_t; + +/*! @brief Defines the common interrupt event for callback use. */ +typedef enum _enet_event +{ + kENET_RxEvent, /*!< Receive event. */ + kENET_TxEvent, /*!< Transmit event. */ + kENET_ErrEvent, /*!< Error event: BABR/BABT/EBERR/LC/RL/UN/PLR . */ + kENET_WakeUpEvent, /*!< Wake up from sleep mode event. */ + kENET_TimeStampEvent, /*!< Time stamp event. */ + kENET_TimeStampAvailEvent /*!< Time stamp available event.*/ +} enet_event_t; + +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB +/*! @brief Defines certain idle slope for bandwidth fraction. */ +typedef enum _enet_idle_slope +{ + kENET_IdleSlope1 = 1U, /*!< The bandwidth fraction is about 0.002. */ + kENET_IdleSlope2 = 2U, /*!< The bandwidth fraction is about 0.003. */ + kENET_IdleSlope4 = 4U, /*!< The bandwidth fraction is about 0.008. */ + kENET_IdleSlope8 = 8U, /*!< The bandwidth fraction is about 0.02. */ + kENET_IdleSlope16 = 16U, /*!< The bandwidth fraction is about 0.03. */ + kENET_IdleSlope32 = 32U, /*!< The bandwidth fraction is about 0.06. */ + kENET_IdleSlope64 = 64U, /*!< The bandwidth fraction is about 0.11. */ + kENET_IdleSlope128 = 128U, /*!< The bandwidth fraction is about 0.20. */ + kENET_IdleSlope256 = 256U, /*!< The bandwidth fraction is about 0.33. */ + kENET_IdleSlope384 = 384U, /*!< The bandwidth fraction is about 0.43. */ + kENET_IdleSlope512 = 512U, /*!< The bandwidth fraction is about 0.50. */ + kENET_IdleSlope640 = 640U, /*!< The bandwidth fraction is about 0.56. */ + kENET_IdleSlope768 = 768U, /*!< The bandwidth fraction is about 0.60. */ + kENET_IdleSlope896 = 896U, /*!< The bandwidth fraction is about 0.64. */ + kENET_IdleSlope1024 = 1024U, /*!< The bandwidth fraction is about 0.67. */ + kENET_IdleSlope1152 = 1152U, /*!< The bandwidth fraction is about 0.69. */ + kENET_IdleSlope1280 = 1280U, /*!< The bandwidth fraction is about 0.71. */ + kENET_IdleSlope1408 = 1408U, /*!< The bandwidth fraction is about 0.73. */ + kENET_IdleSlope1536 = 1536U /*!< The bandwidth fraction is about 0.75. */ +} enet_idle_slope_t; +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + +/*! @brief Defines the transmit accelerator configuration. */ +typedef enum _enet_tx_accelerator +{ + kENET_TxAccelIsShift16Enabled = ENET_TACC_SHIFT16_MASK, /*!< Transmit FIFO shift-16. */ + kENET_TxAccelIpCheckEnabled = ENET_TACC_IPCHK_MASK, /*!< Insert IP header checksum. */ + kENET_TxAccelProtoCheckEnabled = ENET_TACC_PROCHK_MASK /*!< Insert protocol checksum. */ +} enet_tx_accelerator_t; + +/*! @brief Defines the receive accelerator configuration. */ +typedef enum _enet_rx_accelerator +{ + kENET_RxAccelPadRemoveEnabled = ENET_RACC_PADREM_MASK, /*!< Padding removal for short IP frames. */ + kENET_RxAccelIpCheckEnabled = ENET_RACC_IPDIS_MASK, /*!< Discard with wrong IP header checksum. */ + kENET_RxAccelProtoCheckEnabled = ENET_RACC_PRODIS_MASK, /*!< Discard with wrong protocol checksum. */ + kENET_RxAccelMacCheckEnabled = ENET_RACC_LINEDIS_MASK, /*!< Discard with Mac layer errors. */ + kENET_RxAccelisShift16Enabled = ENET_RACC_SHIFT16_MASK /*!< Receive FIFO shift-16. */ +} enet_rx_accelerator_t; + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! @brief Defines the ENET PTP message related constant. */ +typedef enum _enet_ptp_event_type +{ + kENET_PtpEventMsgType = 3U, /*!< PTP event message type. */ + kENET_PtpSrcPortIdLen = 10U, /*!< PTP message sequence id length. */ + kENET_PtpEventPort = 319U, /*!< PTP event port number. */ + kENET_PtpGnrlPort = 320U /*!< PTP general port number. */ +} enet_ptp_event_type_t; + +/*! @brief Defines the IEEE 1588 PTP timer channel numbers. */ +typedef enum _enet_ptp_timer_channel +{ + kENET_PtpTimerChannel1 = 0U, /*!< IEEE 1588 PTP timer Channel 1. */ + kENET_PtpTimerChannel2, /*!< IEEE 1588 PTP timer Channel 2. */ + kENET_PtpTimerChannel3, /*!< IEEE 1588 PTP timer Channel 3. */ + kENET_PtpTimerChannel4 /*!< IEEE 1588 PTP timer Channel 4. */ +} enet_ptp_timer_channel_t; + +/*! @brief Defines the capture or compare mode for IEEE 1588 PTP timer channels. */ +typedef enum _enet_ptp_timer_channel_mode +{ + kENET_PtpChannelDisable = 0U, /*!< Disable timer channel. */ + kENET_PtpChannelRisingCapture = 1U, /*!< Input capture on rising edge. */ + kENET_PtpChannelFallingCapture = 2U, /*!< Input capture on falling edge. */ + kENET_PtpChannelBothCapture = 3U, /*!< Input capture on both edges. */ + kENET_PtpChannelSoftCompare = 4U, /*!< Output compare software only. */ + kENET_PtpChannelToggleCompare = 5U, /*!< Toggle output on compare. */ + kENET_PtpChannelClearCompare = 6U, /*!< Clear output on compare. */ + kENET_PtpChannelSetCompare = 7U, /*!< Set output on compare. */ + kENET_PtpChannelClearCompareSetOverflow = 10U, /*!< Clear output on compare, set output on overflow. */ + kENET_PtpChannelSetCompareClearOverflow = 11U, /*!< Set output on compare, clear output on overflow. */ + kENET_PtpChannelPulseLowonCompare = 14U, /*!< Pulse output low on compare for one IEEE 1588 clock cycle. */ + kENET_PtpChannelPulseHighonCompare = 15U /*!< Pulse output high on compare for one IEEE 1588 clock cycle. */ +} enet_ptp_timer_channel_mode_t; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +/*! @brief Defines the receive buffer descriptor structure for the little endian system.*/ +typedef struct _enet_rx_bd_struct +{ + uint16_t length; /*!< Buffer descriptor data length. */ + uint16_t control; /*!< Buffer descriptor control and status. */ + uint8_t *buffer; /*!< Data buffer pointer. */ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + uint16_t controlExtend0; /*!< Extend buffer descriptor control0. */ + uint16_t controlExtend1; /*!< Extend buffer descriptor control1. */ + uint16_t payloadCheckSum; /*!< Internal payload checksum. */ + uint8_t headerLength; /*!< Header length. */ + uint8_t protocolTyte; /*!< Protocol type. */ + uint16_t reserved0; + uint16_t controlExtend2; /*!< Extend buffer descriptor control2. */ + uint32_t timestamp; /*!< Timestamp. */ + uint16_t reserved1; + uint16_t reserved2; + uint16_t reserved3; + uint16_t reserved4; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +} enet_rx_bd_struct_t; + +/*! @brief Defines the enhanced transmit buffer descriptor structure for the little endian system. */ +typedef struct _enet_tx_bd_struct +{ + uint16_t length; /*!< Buffer descriptor data length. */ + uint16_t control; /*!< Buffer descriptor control and status. */ + uint8_t *buffer; /*!< Data buffer pointer. */ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + uint16_t controlExtend0; /*!< Extend buffer descriptor control0. */ + uint16_t controlExtend1; /*!< Extend buffer descriptor control1. */ +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB + int8_t *txLaunchTime; /*!< Transmit launch time. */ +#else + uint16_t reserved0; + uint16_t reserved1; +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + uint16_t reserved2; + uint16_t controlExtend2; /*!< Extend buffer descriptor control2. */ + uint32_t timestamp; /*!< Timestamp. */ + uint16_t reserved3; + uint16_t reserved4; + uint16_t reserved5; + uint16_t reserved6; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +} enet_tx_bd_struct_t; + +/*! @brief Defines the ENET data error statistics structure. */ +typedef struct _enet_data_error_stats +{ + uint32_t statsRxLenGreaterErr; /*!< Receive length greater than RCR[MAX_FL]. */ + uint32_t statsRxAlignErr; /*!< Receive non-octet alignment/ */ + uint32_t statsRxFcsErr; /*!< Receive CRC error. */ + uint32_t statsRxOverRunErr; /*!< Receive over run. */ + uint32_t statsRxTruncateErr; /*!< Receive truncate. */ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + uint32_t statsRxProtocolChecksumErr; /*!< Receive protocol checksum error. */ + uint32_t statsRxIpHeadChecksumErr; /*!< Receive IP header checksum error. */ + uint32_t statsRxMacErr; /*!< Receive Mac error. */ + uint32_t statsRxPhyErr; /*!< Receive PHY error. */ + uint32_t statsRxCollisionErr; /*!< Receive collision. */ + uint32_t statsTxErr; /*!< The error happen when transmit the frame. */ + uint32_t statsTxFrameErr; /*!< The transmit frame is error. */ + uint32_t statsTxOverFlowErr; /*!< Transmit overflow. */ + uint32_t statsTxLateCollisionErr; /*!< Transmit late collision. */ + uint32_t statsTxExcessCollisionErr; /*!< Transmit excess collision.*/ + uint32_t statsTxUnderFlowErr; /*!< Transmit under flow error. */ + uint32_t statsTxTsErr; /*!< Transmit time stamp error. */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +} enet_data_error_stats_t; + +/*! @brief Defines the receive buffer descriptor configuration structure. + * + * Note that for the internal DMA requirements, the buffers have a corresponding alignment requirements. + * 1. The aligned receive and transmit buffer size must be evenly divisible by ENET_BUFF_ALIGNMENT. + * when the data buffers are in cacheable region when cache is enabled, all those size should be + * aligned to the maximum value of "ENET_BUFF_ALIGNMENT" and the cache line size. + * 2. The aligned transmit and receive buffer descriptor start address must be at + * least 64 bit aligned. However, it's recommended to be evenly divisible by ENET_BUFF_ALIGNMENT. + * buffer descriptors should be put in non-cacheable region when cache is enabled. + * 3. The aligned transmit and receive data buffer start address must be evenly divisible by ENET_BUFF_ALIGNMENT. + * Receive buffers should be continuous with the total size equal to "rxBdNumber * rxBuffSizeAlign". + * Transmit buffers should be continuous with the total size equal to "txBdNumber * txBuffSizeAlign". + * when the data buffers are in cacheable region when cache is enabled, all those size should be + * aligned to the maximum value of "ENET_BUFF_ALIGNMENT" and the cache line size. + */ +typedef struct _enet_buffer_config +{ + uint16_t rxBdNumber; /*!< Receive buffer descriptor number. */ + uint16_t txBdNumber; /*!< Transmit buffer descriptor number. */ + uint32_t rxBuffSizeAlign; /*!< Aligned receive data buffer size. */ + uint32_t txBuffSizeAlign; /*!< Aligned transmit data buffer size. */ + volatile enet_rx_bd_struct_t + *rxBdStartAddrAlign; /*!< Aligned receive buffer descriptor start address: should be non-cacheable. */ + volatile enet_tx_bd_struct_t + *txBdStartAddrAlign; /*!< Aligned transmit buffer descriptor start address: should be non-cacheable. */ + uint8_t *rxBufferAlign; /*!< Receive data buffer start address. */ + uint8_t *txBufferAlign; /*!< Transmit data buffer start address. */ +} enet_buffer_config_t; + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! @brief Defines the ENET PTP time stamp structure. */ +typedef struct _enet_ptp_time +{ + uint64_t second; /*!< Second. */ + uint32_t nanosecond; /*!< Nanosecond. */ +} enet_ptp_time_t; + +/*! @brief Defines the structure for the ENET PTP message data and timestamp data.*/ +typedef struct _enet_ptp_time_data +{ + uint8_t version; /*!< PTP version. */ + uint8_t sourcePortId[kENET_PtpSrcPortIdLen]; /*!< PTP source port ID. */ + uint16_t sequenceId; /*!< PTP sequence ID. */ + uint8_t messageType; /*!< PTP message type. */ + enet_ptp_time_t timeStamp; /*!< PTP timestamp. */ +} enet_ptp_time_data_t; + +/*! @brief Defines the ENET PTP ring buffer structure for the PTP message timestamp store.*/ +typedef struct _enet_ptp_time_data_ring +{ + uint32_t front; /*!< The first index of the ring. */ + uint32_t end; /*!< The end index of the ring. */ + uint32_t size; /*!< The size of the ring. */ + enet_ptp_time_data_t *ptpTsData; /*!< PTP message data structure. */ +} enet_ptp_time_data_ring_t; + +/*! @brief Defines the ENET PTP configuration structure. */ +typedef struct _enet_ptp_config +{ + uint8_t ptpTsRxBuffNum; /*!< Receive 1588 timestamp buffer number*/ + uint8_t ptpTsTxBuffNum; /*!< Transmit 1588 timestamp buffer number*/ + enet_ptp_time_data_t *rxPtpTsData; /*!< The start address of 1588 receive timestamp buffers */ + enet_ptp_time_data_t *txPtpTsData; /*!< The start address of 1588 transmit timestamp buffers */ + enet_ptp_timer_channel_t channel; /*!< Used for ERRATA_2579: the PTP 1588 timer channel for time interrupt. */ + uint32_t ptp1588ClockSrc_Hz; /*!< The clock source of the PTP 1588 timer. */ +} enet_ptp_config_t; +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +#if defined(FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE) && FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE +/*! @brief Defines the interrupt coalescing configure structure. */ +typedef struct _enet_intcoalesce_config +{ + uint8_t txCoalesceFrameCount[FSL_FEATURE_ENET_QUEUE]; /*!< Transmit interrupt coalescing frame count threshold. */ + uint16_t txCoalesceTimeCount[FSL_FEATURE_ENET_QUEUE]; /*!< Transmit interrupt coalescing timer count threshold. */ + uint8_t rxCoalesceFrameCount[FSL_FEATURE_ENET_QUEUE]; /*!< Receive interrupt coalescing frame count threshold. */ + uint16_t rxCoalesceTimeCount[FSL_FEATURE_ENET_QUEUE]; /*!< Receive interrupt coalescing timer count threshold. */ +} enet_intcoalesce_config_t; +#endif /* FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE */ + +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB +/*! @brief Defines the ENET AVB Configure structure. + * + * This is used for to configure the extended ring 1 and ring 2. + * 1. The classification match format is (CMP3 << 12) | (CMP2 << 8) | (CMP1 << 4) | CMP0. + * composed of four 3-bit compared VLAN priority field cmp0~cmp3, cm0 ~ cmp3 are used in parallel. + * + * If CMP1,2,3 are not unused, please set them to the same value as CMP0. + * 2. The idleSlope is used to calculate the Band Width fraction, BW fraction = 1 / (1 + 512/idleSlope). + * For avb configuration, the BW fraction of Class 1 and Class 2 combined must not exceed 0.75. + */ +typedef struct _enet_avb_config +{ + uint16_t rxClassifyMatch[FSL_FEATURE_ENET_QUEUE - 1]; /*!< The classification match value for the ring. */ + enet_idle_slope_t idleSlope[FSL_FEATURE_ENET_QUEUE - 1]; /*!< The idle slope for certian bandwidth fraction. */ +} enet_avb_config_t; +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + +/*! @brief Defines the basic configuration structure for the ENET device. + * + * Note: + * 1. macSpecialConfig is used for a special control configuration, A logical OR of + * "enet_special_control_flag_t". For a special configuration for MAC, + * set this parameter to 0. + * 2. txWatermark is used for a cut-through operation. It is in steps of 64 bytes: + * 0/1 - 64 bytes written to TX FIFO before transmission of a frame begins. + * 2 - 128 bytes written to TX FIFO .... + * 3 - 192 bytes written to TX FIFO .... + * The maximum of txWatermark is 0x2F - 4032 bytes written to TX FIFO .... + * txWatermark allows minimizing the transmit latency to set the txWatermark to 0 or 1 + * or for larger bus access latency 3 or larger due to contention for the system bus. + * 3. rxFifoFullThreshold is similar to the txWatermark for cut-through operation in RX. + * It is in 64-bit words. The minimum is ENET_FIFO_MIN_RX_FULL and the maximum is 0xFF. + * If the end of the frame is stored in FIFO and the frame size if smaller than the + * txWatermark, the frame is still transmitted. The rule is the + * same for rxFifoFullThreshold in the receive direction. + * 4. When "kENET_ControlFlowControlEnable" is set in the macSpecialConfig, ensure + * that the pauseDuration, rxFifoEmptyThreshold, and rxFifoStatEmptyThreshold + * are set for flow control enabled case. + * 5. When "kENET_ControlStoreAndFwdDisabled" is set in the macSpecialConfig, ensure + * that the rxFifoFullThreshold and txFifoWatermark are set for store and forward disable. + * 6. The rxAccelerConfig and txAccelerConfig default setting with 0 - accelerator + * are disabled. The "enet_tx_accelerator_t" and "enet_rx_accelerator_t" are + * recommended to be used to enable the transmit and receive accelerator. + * After the accelerators are enabled, the store and forward feature should be enabled. + * As a result, kENET_ControlStoreAndFwdDisabled should not be set. + * 7. The intCoalesceCfg can be used in the rx or tx enabled cases to decrese the CPU loading. + */ +typedef struct _enet_config +{ + uint32_t macSpecialConfig; /*!< Mac special configuration. A logical OR of "enet_special_control_flag_t". */ + uint32_t interrupt; /*!< Mac interrupt source. A logical OR of "enet_interrupt_enable_t". */ + uint16_t rxMaxFrameLen; /*!< Receive maximum frame length. */ + enet_mii_mode_t miiMode; /*!< MII mode. */ + enet_mii_speed_t miiSpeed; /*!< MII Speed. */ + enet_mii_duplex_t miiDuplex; /*!< MII duplex. */ + uint8_t rxAccelerConfig; /*!< Receive accelerator, A logical OR of "enet_rx_accelerator_t". */ + uint8_t txAccelerConfig; /*!< Transmit accelerator, A logical OR of "enet_rx_accelerator_t". */ + uint16_t pauseDuration; /*!< For flow control enabled case: Pause duration. */ + uint8_t rxFifoEmptyThreshold; /*!< For flow control enabled case: when RX FIFO level reaches this value, + it makes MAC generate XOFF pause frame. */ +#if defined(FSL_FEATURE_ENET_HAS_RECEIVE_STATUS_THRESHOLD) && FSL_FEATURE_ENET_HAS_RECEIVE_STATUS_THRESHOLD + uint8_t rxFifoStatEmptyThreshold; /*!< For flow control enabled case: number of frames in the receive FIFO, + independent of size, that can be accept. If the limit is reached, reception + continues and a pause frame is triggered. */ +#endif /* FSL_FEATURE_ENET_HAS_RECEIVE_STATUS_THRESHOLD */ + uint8_t rxFifoFullThreshold; /*!< For store and forward disable case, the data required in RX FIFO to notify + the MAC receive ready status. */ + uint8_t txFifoWatermark; /*!< For store and forward disable case, the data required in TX FIFO + before a frame transmit start. */ +#if defined(FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE) && FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE + enet_intcoalesce_config_t *intCoalesceCfg; /* If the interrupt coalsecence is not required in the ring n(0,1,2), + please set to NULL. */ +#endif /* FSL_FEATURE_ENET_HAS_INTERRUPT_COALESCE */ + uint8_t ringNum; /*!< Number of used rings. default with 1 -- single ring. */ +} enet_config_t; + +/* Forward declaration of the handle typedef. */ +typedef struct _enet_handle enet_handle_t; + +/*! @brief ENET callback function. */ +#if FSL_FEATURE_ENET_QUEUE > 1 +typedef void (*enet_callback_t)( + ENET_Type *base, enet_handle_t *handle, uint32_t ringId, enet_event_t event, void *userData); +#else +typedef void (*enet_callback_t)(ENET_Type *base, enet_handle_t *handle, enet_event_t event, void *userData); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + +/*! @brief Defines the ENET handler structure. */ +struct _enet_handle +{ + volatile enet_rx_bd_struct_t + *rxBdBase[FSL_FEATURE_ENET_QUEUE]; /*!< Receive buffer descriptor base address pointer. */ + volatile enet_rx_bd_struct_t + *rxBdCurrent[FSL_FEATURE_ENET_QUEUE]; /*!< The current available receive buffer descriptor pointer. */ + volatile enet_tx_bd_struct_t + *txBdBase[FSL_FEATURE_ENET_QUEUE]; /*!< Transmit buffer descriptor base address pointer. */ + volatile enet_tx_bd_struct_t + *txBdCurrent[FSL_FEATURE_ENET_QUEUE]; /*!< The current available transmit buffer descriptor pointer. */ + uint32_t rxBuffSizeAlign[FSL_FEATURE_ENET_QUEUE]; /*!< Receive buffer size alignment. */ + uint32_t txBuffSizeAlign[FSL_FEATURE_ENET_QUEUE]; /*!< Transmit buffer size alignment. */ + uint8_t ringNum; /*!< Number of used rings. */ + enet_callback_t callback; /*!< Callback function. */ + void *userData; /*!< Callback function parameter.*/ +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE + volatile enet_tx_bd_struct_t + *txBdDirtyStatic[FSL_FEATURE_ENET_QUEUE]; /*!< The dirty transmit buffer descriptor for error static update. */ + volatile enet_tx_bd_struct_t + *txBdDirtyTime[FSL_FEATURE_ENET_QUEUE]; /*!< The dirty transmit buffer descriptor for time stamp update. */ + uint64_t msTimerSecond; /*!< The second for Master PTP timer .*/ + enet_ptp_time_data_ring_t rxPtpTsDataRing; /*!< Receive PTP 1588 time stamp data ring buffer. */ + enet_ptp_time_data_ring_t txPtpTsDataRing; /*!< Transmit PTP 1588 time stamp data ring buffer. */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +}; + +/******************************************************************************* + * API + ******************************************************************************/ + +#if defined(__cplusplus) +extern "C" { +#endif + +/*! + * @name Initialization and De-initialization + * @{ + */ + +/*! + * @brief Gets the ENET default configuration structure. + * + * The purpose of this API is to get the default ENET MAC controller + * configure structure for ENET_Init(). User may use the initialized + * structure unchanged in ENET_Init(), or modify some fields of the + * structure before calling ENET_Init(). + * Example: + @code + enet_config_t config; + ENET_GetDefaultConfig(&config); + @endcode + * @param config The ENET mac controller configuration structure pointer. + */ +void ENET_GetDefaultConfig(enet_config_t *config); + +/*! + * @brief Initializes the ENET module. + * + * This function ungates the module clock and initializes it with the ENET configuration. + * + * @param base ENET peripheral base address. + * @param handle ENET handler pointer. + * @param config ENET mac configuration structure pointer. + * The "enet_config_t" type mac configuration return from ENET_GetDefaultConfig + * can be used directly. It is also possible to verify the Mac configuration using other methods. + * @param bufferConfig ENET buffer configuration structure pointer. + * The buffer configuration should be prepared for ENET Initialization. + * It is the start address of "ringNum" enet_buffer_config structures. + * To support added multi-ring features in some soc and compatible with the previous + * enet driver version. For single ring supported, this bufferConfig is a buffer + * configure structure pointer, for multi-ring supported and used case, this bufferConfig + * pointer should be a buffer configure structure array pointer. + * @param macAddr ENET mac address of Ethernet device. This MAC address should be + * provided. + * @param srcClock_Hz The internal module clock source for MII clock. + * + * @note ENET has two buffer descriptors legacy buffer descriptors and + * enhanced IEEE 1588 buffer descriptors. The legacy descriptor is used by default. To + * use the IEEE 1588 feature, use the enhanced IEEE 1588 buffer descriptor + * by defining "ENET_ENHANCEDBUFFERDESCRIPTOR_MODE" and calling ENET_Ptp1588Configure() + * to configure the 1588 feature and related buffers after calling ENET_Init(). + */ +void ENET_Init(ENET_Type *base, + enet_handle_t *handle, + const enet_config_t *config, + const enet_buffer_config_t *bufferConfig, + uint8_t *macAddr, + uint32_t srcClock_Hz); +/*! + * @brief Deinitializes the ENET module. + + * This function gates the module clock, clears ENET interrupts, and disables the ENET module. + * + * @param base ENET peripheral base address. + */ +void ENET_Deinit(ENET_Type *base); + +/*! + * @brief Resets the ENET module. + * + * This function restores the ENET module to reset state. + * Note that this function sets all registers to + * reset state. As a result, the ENET module can't work after calling this function. + * + * @param base ENET peripheral base address. + */ +static inline void ENET_Reset(ENET_Type *base) +{ + base->ECR |= ENET_ECR_RESET_MASK; +} + +/* @} */ + +/*! + * @name MII interface operation + * @{ + */ + +/*! + * @brief Sets the ENET MII speed and duplex. + * + * This API is provided to dynamically change the speed and dulpex for MAC. + * + * @param base ENET peripheral base address. + * @param speed The speed of the RMII mode. + * @param duplex The duplex of the RMII mode. + */ +void ENET_SetMII(ENET_Type *base, enet_mii_speed_t speed, enet_mii_duplex_t duplex); + +/*! + * @brief Sets the ENET SMI(serial management interface)- MII management interface. + * + * @param base ENET peripheral base address. + * @param srcClock_Hz This is the ENET module clock frequency. Normally it's the system clock. See clock distribution. + * @param isPreambleDisabled The preamble disable flag. + * - true Enables the preamble. + * - false Disables the preamble. + */ +void ENET_SetSMI(ENET_Type *base, uint32_t srcClock_Hz, bool isPreambleDisabled); + +/*! + * @brief Gets the ENET SMI- MII management interface configuration. + * + * This API is used to get the SMI configuration to check whether the MII management + * interface has been set. + * + * @param base ENET peripheral base address. + * @return The SMI setup status true or false. + */ +static inline bool ENET_GetSMI(ENET_Type *base) +{ + return (0 != (base->MSCR & 0x7E)); +} + +/*! + * @brief Reads data from the PHY register through an SMI interface. + * + * @param base ENET peripheral base address. + * @return The data read from PHY + */ +static inline uint32_t ENET_ReadSMIData(ENET_Type *base) +{ + return (uint32_t)((base->MMFR & ENET_MMFR_DATA_MASK) >> ENET_MMFR_DATA_SHIFT); +} + +/*! + * @brief Starts an SMI (Serial Management Interface) read command. + * + * Used for standard IEEE802.3 MDIO Clause 22 format. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param phyReg The PHY register. Range from 0 ~ 31. + * @param operation The read operation. + */ +void ENET_StartSMIRead(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, enet_mii_read_t operation); + +/*! + * @brief Starts an SMI write command. + * + * Used for standard IEEE802.3 MDIO Clause 22 format. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param phyReg The PHY register. Range from 0 ~ 31. + * @param operation The write operation. + * @param data The data written to PHY. + */ +void ENET_StartSMIWrite(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, enet_mii_write_t operation, uint32_t data); + +#if defined(FSL_FEATURE_ENET_HAS_EXTEND_MDIO) && FSL_FEATURE_ENET_HAS_EXTEND_MDIO +/*! + * @brief Starts the extended IEEE802.3 Clause 45 MDIO format SMI read command. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param phyReg The PHY register. For MDIO IEEE802.3 Clause 45, + * the phyReg is a 21-bits combination of the devaddr (5 bits device address) + * and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr. + */ +void ENET_StartExtC45SMIRead(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg); + +/*! + * @brief Starts the extended IEEE802.3 Clause 45 MDIO format SMI write command. + * + * @param base ENET peripheral base address. + * @param phyAddr The PHY address. + * @param phyReg The PHY register. For MDIO IEEE802.3 Clause 45, + * the phyReg is a 21-bits combination of the devaddr (5 bits device address) + * and the regAddr (16 bits phy register): phyReg = (devaddr << 16) | regAddr. + * @param data The data written to PHY. + */ +void ENET_StartExtC45SMIWrite(ENET_Type *base, uint32_t phyAddr, uint32_t phyReg, uint32_t data); +#endif /* FSL_FEATURE_ENET_HAS_EXTEND_MDIO */ + +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB +/*! + * @brief Control the usage of the delayed tx/rx RGMII clock. + * + * @param base ENET peripheral base address. + * @param txEnabled Enable or disable to generate the delayed version of RGMII_TXC. + * @param rxEnabled Enable or disable to use the delayed version of RGMII_RXC. + */ + +static inline void ENET_SetRGMIIClockDelay(ENET_Type *base, bool txEnabled, bool rxEnabled) +{ + uint32_t ecrReg = base->ECR; + + /* Set for transmit clock delay. */ + if (txEnabled) + { + ecrReg |= ENET_ECR_TXC_DLY_MASK; + } + else + { + ecrReg &= ~ENET_ECR_TXC_DLY_MASK; + } + + /* Set for receive clock delay. */ + if (rxEnabled) + { + ecrReg |= ENET_ECR_RXC_DLY_MASK; + } + else + { + ecrReg &= ~ENET_ECR_RXC_DLY_MASK; + } +} +#endif /* FSL_FEATURE_ENET_HAS_AVB */ + /* @} */ + +/*! + * @name MAC Address Filter + * @{ + */ + +/*! + * @brief Sets the ENET module Mac address. + * + * @param base ENET peripheral base address. + * @param macAddr The six-byte Mac address pointer. + * The pointer is allocated by application and input into the API. + */ +void ENET_SetMacAddr(ENET_Type *base, uint8_t *macAddr); + +/*! + * @brief Gets the ENET module Mac address. + * + * @param base ENET peripheral base address. + * @param macAddr The six-byte Mac address pointer. + * The pointer is allocated by application and input into the API. + */ +void ENET_GetMacAddr(ENET_Type *base, uint8_t *macAddr); + +/*! + * @brief Adds the ENET device to a multicast group. + * + * @param base ENET peripheral base address. + * @param address The six-byte multicast group address which is provided by application. + */ +void ENET_AddMulticastGroup(ENET_Type *base, uint8_t *address); + +/*! + * @brief Moves the ENET device from a multicast group. + * + * @param base ENET peripheral base address. + * @param address The six-byte multicast group address which is provided by application. + */ +void ENET_LeaveMulticastGroup(ENET_Type *base, uint8_t *address); + +/* @} */ + +/*! + * @name Other basic operation + * @{ + */ + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +#if defined(FSL_FEATURE_ENET_HAS_AVB) && FSL_FEATURE_ENET_HAS_AVB +/*! + * @brief Sets the ENET AVB feature. + * + * ENET AVB feature configuration, set the Receive classification match and transmit + * bandwidth. This API is called when the AVB feature is required. + * + * Note: The AVB frames transmission scheme is credit-based tx scheme and it's only supported + * with the Enhanced buffer descriptors. so the AVB configuration should only done with + * Enhanced buffer descriptor. so when the AVB feature is required, please make sure the + * the "ENET_ENHANCEDBUFFERDESCRIPTOR_MODE" is defined. + * + * @param base ENET peripheral base address. + * @param handle ENET handler pointer. + * @param config The ENET AVB feature configuration structure. + */ +void ENET_AVBConfigure(ENET_Type *base, enet_handle_t *handle, const enet_avb_config_t *config); +#endif /* FSL_FEATURE_ENET_HAS_AVB */ +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +/*! + * @brief Activates ENET read or receive. + * + * This function is to active the enet read process. It is + * used for single descriptor ring/queue. + * + * @param base ENET peripheral base address. + * + * @note This must be called after the MAC configuration and + * state are ready. It must be called after the ENET_Init() and + * ENET_Ptp1588Configure(). This should be called when the ENET receive required. + */ +static inline void ENET_ActiveRead(ENET_Type *base) +{ + base->RDAR = ENET_RDAR_RDAR_MASK; +} + +#if FSL_FEATURE_ENET_QUEUE > 1 +/*! + * @brief Activates ENET read or receive for multiple-queue/ring. + * + * This function is to active the enet read process. It is + * used for extended multiple descriptor rings/queues. + * + * @param base ENET peripheral base address. + * + * @note This must be called after the MAC configuration and + * state are ready. It must be called after the ENET_Init() and + * ENET_Ptp1588Configure(). This should be called when the ENET receive required. + */ +static inline void ENET_ActiveReadMultiRing(ENET_Type *base) +{ + base->RDAR = ENET_RDAR_RDAR_MASK; + base->RDAR1 = ENET_RDAR1_RDAR_MASK; + base->RDAR2 = ENET_RDAR2_RDAR_MASK; +} +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + +/*! + * @brief Enables/disables the MAC to enter sleep mode. + * This function is used to set the MAC enter sleep mode. + * When entering sleep mode, the magic frame wakeup interrupt should be enabled + * to wake up MAC from the sleep mode and reset it to normal mode. + * + * @param base ENET peripheral base address. + * @param enable True enable sleep mode, false disable sleep mode. + */ +static inline void ENET_EnableSleepMode(ENET_Type *base, bool enable) +{ + if (enable) + { + /* When this field is set, MAC enters sleep mode. */ + base->ECR |= ENET_ECR_SLEEP_MASK | ENET_ECR_MAGICEN_MASK; + } + else + { /* MAC exits sleep mode. */ + base->ECR &= ~(ENET_ECR_SLEEP_MASK | ENET_ECR_MAGICEN_MASK); + } +} + +/*! + * @brief Gets ENET transmit and receive accelerator functions from MAC controller. + * + * @param base ENET peripheral base address. + * @param txAccelOption The transmit accelerator option. The "enet_tx_accelerator_t" is + * recommended to be used to as the mask to get the exact the accelerator option. + * @param rxAccelOption The receive accelerator option. The "enet_rx_accelerator_t" is + * recommended to be used to as the mask to get the exact the accelerator option. + */ +static inline void ENET_GetAccelFunction(ENET_Type *base, uint32_t *txAccelOption, uint32_t *rxAccelOption) +{ + assert(txAccelOption); + assert(txAccelOption); + + *txAccelOption = base->TACC; + *rxAccelOption = base->RACC; +} + +/* @} */ + +/*! + * @name Interrupts. + * @{ + */ + +/*! + * @brief Enables the ENET interrupt. + * + * This function enables the ENET interrupt according to the provided mask. The mask + * is a logical OR of enumeration members. See @ref enet_interrupt_enable_t. + * For example, to enable the TX frame interrupt and RX frame interrupt, do the following. + * @code + * ENET_EnableInterrupts(ENET, kENET_TxFrameInterrupt | kENET_RxFrameInterrupt); + * @endcode + * + * @param base ENET peripheral base address. + * @param mask ENET interrupts to enable. This is a logical OR of the + * enumeration :: enet_interrupt_enable_t. + */ +static inline void ENET_EnableInterrupts(ENET_Type *base, uint32_t mask) +{ + base->EIMR |= mask; +} + +/*! + * @brief Disables the ENET interrupt. + * + * This function disables the ENET interrupts according to the provided mask. The mask + * is a logical OR of enumeration members. See @ref enet_interrupt_enable_t. + * For example, to disable the TX frame interrupt and RX frame interrupt, do the following. + * @code + * ENET_DisableInterrupts(ENET, kENET_TxFrameInterrupt | kENET_RxFrameInterrupt); + * @endcode + * + * @param base ENET peripheral base address. + * @param mask ENET interrupts to disable. This is a logical OR of the + * enumeration :: enet_interrupt_enable_t. + */ +static inline void ENET_DisableInterrupts(ENET_Type *base, uint32_t mask) +{ + base->EIMR &= ~mask; +} + +/*! + * @brief Gets the ENET interrupt status flag. + * + * @param base ENET peripheral base address. + * @return The event status of the interrupt source. This is the logical OR of members + * of the enumeration :: enet_interrupt_enable_t. + */ +static inline uint32_t ENET_GetInterruptStatus(ENET_Type *base) +{ + return base->EIR; +} + +/*! + * @brief Clears the ENET interrupt events status flag. + * + * This function clears enabled ENET interrupts according to the provided mask. The mask + * is a logical OR of enumeration members. See the @ref enet_interrupt_enable_t. + * For example, to clear the TX frame interrupt and RX frame interrupt, do the following. + * @code + * ENET_ClearInterruptStatus(ENET, kENET_TxFrameInterrupt | kENET_RxFrameInterrupt); + * @endcode + * + * @param base ENET peripheral base address. + * @param mask ENET interrupt source to be cleared. + * This is the logical OR of members of the enumeration :: enet_interrupt_enable_t. + */ +static inline void ENET_ClearInterruptStatus(ENET_Type *base, uint32_t mask) +{ + base->EIR = mask; +} +/* @} */ + +/*! + * @name Transactional operation + * @{ + */ + +/*! + * @brief Sets the callback function. + * This API is provided for the application callback required case when ENET + * interrupt is enabled. This API should be called after calling ENET_Init. + * + * @param handle ENET handler pointer. Should be provided by application. + * @param callback The ENET callback function. + * @param userData The callback function parameter. + */ +void ENET_SetCallback(enet_handle_t *handle, enet_callback_t callback, void *userData); + +/*! + * @brief Gets the error statistics of a received frame for ENET single ring. + * + * This API must be called after the ENET_GetRxFrameSize and before the ENET_ReadFrame(). + * If the ENET_GetRxFrameSize returns kStatus_ENET_RxFrameError, + * the ENET_GetRxErrBeforeReadFrame can be used to get the exact error statistics. + * This is an example. + * @code + * status = ENET_GetRxFrameSize(&g_handle, &length); + * if (status == kStatus_ENET_RxFrameError) + * { + * // Get the error information of the received frame. + * ENET_GetRxErrBeforeReadFrame(&g_handle, &eErrStatic); + * // update the receive buffer. + * ENET_ReadFrame(EXAMPLE_ENET, &g_handle, NULL, 0); + * } + * @endcode + * @param handle The ENET handler structure pointer. This is the same handler pointer used in the ENET_Init. + * @param eErrorStatic The error statistics structure pointer. + */ +void ENET_GetRxErrBeforeReadFrame(enet_handle_t *handle, enet_data_error_stats_t *eErrorStatic); + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! + * @brief Gets the ENET transmit frame statistics after the data send for single ring. + * + * This interface gets the error statistics of the transmit frame. + * Because the error information is reported by the uDMA after the data delivery, this interface + * should be called after the data transmit API. It is recommended to call this function on + * transmit interrupt handler. After calling the ENET_SendFrame, the + * transmit interrupt notifies the transmit completion. + * + * @param handle The PTP handler pointer. This is the same handler pointer used in the ENET_Init. + * @param eErrorStatic The error statistics structure pointer. + * @return The execute status. + */ +status_t ENET_GetTxErrAfterSendFrame(enet_handle_t *handle, enet_data_error_stats_t *eErrorStatic); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +/*! + * @brief Gets the size of the read frame for single ring. + * + * This function gets a received frame size from the ENET buffer descriptors. + * @note The FCS of the frame is automatically removed by MAC and the size is the length without the FCS. + * After calling ENET_GetRxFrameSize, ENET_ReadFrame() should be called to update the + * receive buffers If the result is not "kStatus_ENET_RxFrameEmpty". + * + * @param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * @param length The length of the valid frame received. + * @retval kStatus_ENET_RxFrameEmpty No frame received. Should not call ENET_ReadFrame to read frame. + * @retval kStatus_ENET_RxFrameError Data error happens. ENET_ReadFrame should be called with NULL data + * and NULL length to update the receive buffers. + * @retval kStatus_Success Receive a frame Successfully then the ENET_ReadFrame + * should be called with the right data buffer and the captured data length input. + */ +status_t ENET_GetRxFrameSize(enet_handle_t *handle, uint32_t *length); + +/*! + * @brief Reads a frame from the ENET device for single ring. + * This function reads a frame (both the data and the length) from the ENET buffer descriptors. + * The ENET_GetRxFrameSize should be used to get the size of the prepared data buffer. + * This is an example: + * @code + * uint32_t length; + * enet_handle_t g_handle; + * //Get the received frame size firstly. + * status = ENET_GetRxFrameSize(&g_handle, &length); + * if (length != 0) + * { + * //Allocate memory here with the size of "length" + * uint8_t *data = memory allocate interface; + * if (!data) + * { + * ENET_ReadFrame(ENET, &g_handle, NULL, 0); + * //Add the console warning log. + * } + * else + * { + * status = ENET_ReadFrame(ENET, &g_handle, data, length); + * //Call stack input API to deliver the data to stack + * } + * } + * else if (status == kStatus_ENET_RxFrameError) + * { + * //Update the received buffer when a error frame is received. + * ENET_ReadFrame(ENET, &g_handle, NULL, 0); + * } + * @endcode + * @param base ENET peripheral base address. + * @param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * @param data The data buffer provided by user to store the frame which memory size should be at least "length". + * @param length The size of the data buffer which is still the length of the received frame. + * @return The execute status, successful or failure. + */ +status_t ENET_ReadFrame(ENET_Type *base, enet_handle_t *handle, uint8_t *data, uint32_t length); + +/*! + * @brief Transmits an ENET frame for single ring. + * @note The CRC is automatically appended to the data. Input the data + * to send without the CRC. + * + * + * @param base ENET peripheral base address. + * @param handle The ENET handler pointer. This is the same handler pointer used in the ENET_Init. + * @param data The data buffer provided by user to be send. + * @param length The length of the data to be send. + * @retval kStatus_Success Send frame succeed. + * @retval kStatus_ENET_TxFrameBusy Transmit buffer descriptor is busy under transmission. + * The transmit busy happens when the data send rate is over the MAC capacity. + * The waiting mechanism is recommended to be added after each call return with + * kStatus_ENET_TxFrameBusy. + */ +status_t ENET_SendFrame(ENET_Type *base, enet_handle_t *handle, const uint8_t *data, uint32_t length); + +#if FSL_FEATURE_ENET_QUEUE > 1 +/*! + * @brief Gets the error statistics of received frame for extended multi-ring. + * + * This API must be called after the ENET_GetRxFrameSizeMultiRing and before the ENET_ReadFrameMultiRing(). + * If the ENET_GetRxFrameSizeMultiRing returns kStatus_ENET_RxFrameError, + * the ENET_GetRxErrBeforeReadFrameMultiRing can be used to get the exact error statistics. + * + * @param handle The ENET handler structure pointer. This is the same handler pointer used in the ENET_Init. + * @param eErrorStatic The error statistics structure pointer. + * @param ringId The ring index, range from 0 ~ FSL_FEATURE_ENET_QUEUE - 1. + */ +void ENET_GetRxErrBeforeReadFrameMultiRing(enet_handle_t *handle, + enet_data_error_stats_t *eErrorStatic, + uint32_t ringId); + +/*! + * @brief Transmits an ENET frame for extended multi-ring. + * @note The CRC is automatically appended to the data. Input the data + * to send without the CRC. + * + * In this API, multiple-ring are mainly used for extended avb frames are supported. + * The transmit scheme for avb frames is the credit-based scheme, the AVB class A, AVB class B + * and the non-AVB frame are transmitted in ring 1, ring 2 and ring 0 independently. + * So application should care about the transmit ring index when use multiple-ring transmission. + * + * @param base ENET peripheral base address. + * @param handle The ENET handler pointer. This is the same handler pointer used in the ENET_Init. + * @param data The data buffer provided by user to be send. + * @param length The length of the data to be send. + * @param ringId The ring index for transmission. + * @retval kStatus_Success Send frame succeed. + * @retval kStatus_ENET_TxFrameBusy Transmit buffer descriptor is busy under transmission. + * The transmit busy happens when the data send rate is over the MAC capacity. + * The waiting mechanism is recommended to be added after each call return with + * kStatus_ENET_TxFrameBusy. + */ +status_t ENET_SendFrameMultiRing( + ENET_Type *base, enet_handle_t *handle, uint8_t *data, uint32_t length, uint32_t ringId); + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! + * @brief Gets the ENET transmit frame statistics after the data send for extended multi-ring. + * + * This interface gets the error statistics of the transmit frame. + * Because the error information is reported by the uDMA after the data delivery, this interface + * should be called after the data transmit API and shall be called by transmit interrupt handler. + * After calling the ENET_SendFrame, the transmit interrupt notifies the transmit completion. + * + * @param handle The PTP handler pointer. This is the same handler pointer used in the ENET_Init. + * @param eErrorStatic The error statistics structure pointer. + * @param ringId The ring index. + * @return The execute status. + */ +status_t ENET_GetTxErrAfterSendFrameMultiRing(enet_handle_t *handle, + enet_data_error_stats_t *eErrorStatic, + uint32_t ringId); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ + +/*! + * @brief Gets the size of the read frame for extended mutli-ring. + * + * This function gets a received frame size from the ENET buffer descriptors. + * @note The FCS of the frame is automatically removed by MAC and the size is the length without the FCS. + * After calling ENET_GetRxFrameSizeMultiRing, ENET_ReadFrameMultiRing() should be called to update the + * receive buffers If the result is not "kStatus_ENET_RxFrameEmpty". The usage is + * the same to the single ring, refer to ENET_GetRxFrameSize. + * + * @param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * @param length The length of the valid frame received. + * @param ringId The ring index or ring number; + * @retval kStatus_ENET_RxFrameEmpty No frame received. Should not call ENET_ReadFrameMultiRing to read frame. + * @retval kStatus_ENET_RxFrameError Data error happens. ENET_ReadFrameMultiRing should be called with NULL data + * and NULL length to update the receive buffers. + * @retval kStatus_Success Receive a frame Successfully then the ENET_ReadFrame + * should be called with the right data buffer and the captured data length input. + */ +status_t ENET_GetRxFrameSizeMultiRing(enet_handle_t *handle, uint32_t *length, uint32_t ringId); + +/*! + * @brief Reads a frame from the ENET device for multi-ring. + * + * This function reads a frame (both the data and the length) from the ENET buffer descriptors. + * The ENET_GetRxFrameSizeMultiRing should be used to get the size of the prepared data buffer. + * This usage is the same as the single ring, refer to ENET_ReadFrame. + + * @param base ENET peripheral base address. + * @param handle The ENET handler structure. This is the same handler pointer used in the ENET_Init. + * @param data The data buffer provided by user to store the frame which memory size should be at least "length". + * @param length The size of the data buffer which is still the length of the received frame. + * @param ringId The ring index or ring number; + * @return The execute status, successful or failure. + */ +status_t ENET_ReadFrameMultiRing( + ENET_Type *base, enet_handle_t *handle, uint8_t *data, uint32_t length, uint32_t ringId); + +/*! + * @brief The transmit IRQ handler. + * + * @param base ENET peripheral base address. + * @param handle The ENET handler pointer. + * @param ringId The ring id or ring number. + */ +void ENET_TransmitIRQHandler(ENET_Type *base, enet_handle_t *handle, uint32_t ringId); + +/*! + * @brief The receive IRQ handler. + * + * @param base ENET peripheral base address. + * @param handle The ENET handler pointer. + * @param ringId The ring id or ring number. + */ +void ENET_ReceiveIRQHandler(ENET_Type *base, enet_handle_t *handle, uint32_t ringId); + +/*! + * @brief the common IRQ handler for the tx/rx irq handler. + * + * This is used for the combined tx/rx interrupt for multi-ring (frame 1). + * + * @param base ENET peripheral base address. + */ +void ENET_CommonFrame1IRQHandler(ENET_Type *base); + +/*! + * @brief the common IRQ handler for the tx/rx irq handler. + * + * This is used for the combined tx/rx interrupt for multi-ring (frame 2). + * + * @param base ENET peripheral base address. + */ +void ENET_CommonFrame2IRQHandler(ENET_Type *base); +#else +/*! + * @brief The transmit IRQ handler. + * + * @param base ENET peripheral base address. + * @param handle The ENET handler pointer. + */ +void ENET_TransmitIRQHandler(ENET_Type *base, enet_handle_t *handle); + +/*! + * @brief The receive IRQ handler. + * + * @param base ENET peripheral base address. + * @param handle The ENET handler pointer. + */ +void ENET_ReceiveIRQHandler(ENET_Type *base, enet_handle_t *handle); +#endif /* FSL_FEATURE_ENET_QUEUE > 1 */ + +/*! + * @brief Some special IRQ handler including the error, mii, wakeup irq handler. + * + * @param base ENET peripheral base address. + * @param handle The ENET handler pointer. + */ +void ENET_ErrorIRQHandler(ENET_Type *base, enet_handle_t *handle); + +/*! + * @brief the common IRQ handler for the tx/rx/error etc irq handler. + * + * This is used for the combined tx/rx/error interrupt for single/mutli-ring (frame 0). + * + * @param base ENET peripheral base address. + */ +void ENET_CommonFrame0IRQHandler(ENET_Type *base); +/* @} */ + +#ifdef ENET_ENHANCEDBUFFERDESCRIPTOR_MODE +/*! + * @name ENET PTP 1588 function operation + * @{ + */ + +/*! + * @brief Configures the ENET PTP IEEE 1588 feature with the basic configuration. + * The function sets the clock for PTP 1588 timer and enables + * time stamp interrupts and transmit interrupts for PTP 1588 features. + * This API should be called when the 1588 feature is enabled + * or the ENET_ENHANCEDBUFFERDESCRIPTOR_MODE is defined. + * ENET_Init should be called before calling this API. + * + * @note The PTP 1588 time-stamp second increase though time-stamp interrupt handler + * and the transmit time-stamp store is done through transmit interrupt handler. + * As a result, the TS interrupt and TX interrupt are enabled when you call this API. + * + * @param base ENET peripheral base address. + * @param handle ENET handler pointer. + * @param ptpConfig The ENET PTP1588 configuration. + */ +void ENET_Ptp1588Configure(ENET_Type *base, enet_handle_t *handle, enet_ptp_config_t *ptpConfig); + +/*! + * @brief Starts the ENET PTP 1588 Timer. + * This function is used to initialize the PTP timer. After the PTP starts, + * the PTP timer starts running. + * + * @param base ENET peripheral base address. + * @param ptpClkSrc The clock source of the PTP timer. + */ +void ENET_Ptp1588StartTimer(ENET_Type *base, uint32_t ptpClkSrc); + +/*! + * @brief Stops the ENET PTP 1588 Timer. + * This function is used to stops the ENET PTP timer. + * + * @param base ENET peripheral base address. + */ +static inline void ENET_Ptp1588StopTimer(ENET_Type *base) +{ + /* Disable PTP timer and reset the timer. */ + base->ATCR &= ~ENET_ATCR_EN_MASK; + base->ATCR |= ENET_ATCR_RESTART_MASK; +} + +/*! + * @brief Adjusts the ENET PTP 1588 timer. + * + * @param base ENET peripheral base address. + * @param corrIncrease The correction increment value. This value is added every time the correction + * timer expires. A value less than the PTP timer frequency(1/ptpClkSrc) slows down the timer, + * a value greater than the 1/ptpClkSrc speeds up the timer. + * @param corrPeriod The PTP timer correction counter wrap-around value. This defines after how + * many timer clock the correction counter should be reset and trigger a correction + * increment on the timer. A value of 0 disables the correction counter and no correction occurs. + */ +void ENET_Ptp1588AdjustTimer(ENET_Type *base, uint32_t corrIncrease, uint32_t corrPeriod); + +/*! + * @brief Sets the ENET PTP 1588 timer channel mode. + * + * @param base ENET peripheral base address. + * @param channel The ENET PTP timer channel number. + * @param mode The PTP timer channel mode, see "enet_ptp_timer_channel_mode_t". + * @param intEnable Enables or disables the interrupt. + */ +static inline void ENET_Ptp1588SetChannelMode(ENET_Type *base, + enet_ptp_timer_channel_t channel, + enet_ptp_timer_channel_mode_t mode, + bool intEnable) +{ + uint32_t tcrReg = 0; + + tcrReg = ENET_TCSR_TMODE(mode) | (intEnable ? ENET_TCSR_TIE_MASK : 0); + + /* Disable channel mode first. */ + base->CHANNEL[channel].TCSR = 0; + base->CHANNEL[channel].TCSR = tcrReg; +} + +#if defined(FSL_FEATURE_ENET_HAS_TIMER_PWCONTROL) && FSL_FEATURE_ENET_HAS_TIMER_PWCONTROL +/*! + * @brief Sets ENET PTP 1588 timer channel mode pulse width. + * + * For the input "mode" in ENET_Ptp1588SetChannelMode, the kENET_PtpChannelPulseLowonCompare + * kENET_PtpChannelPulseHighonCompare only support the pulse width for one 1588 clock. + * this function is extended for control the pulse width from 1 to 32 1588 clock cycles. + * so call this function if you need to set the timer channel mode for + * kENET_PtpChannelPulseLowonCompare or kENET_PtpChannelPulseHighonCompare + * with pulse width more than one 1588 clock, + * + * @param base ENET peripheral base address. + * @param channel The ENET PTP timer channel number. + * @param isOutputLow True --- timer channel is configured for output compare + * pulse output low. + * false --- timer channel is configured for output compare + * pulse output high. + * @param pulseWidth The pulse width control value, range from 0 ~ 31. + * 0 --- pulse width is one 1588 clock cycle. + * 31 --- pulse width is thirty two 1588 clock cycles. + * @param intEnable Enables or disables the interrupt. + */ +static inline void ENET_Ptp1588SetChannelOutputPulseWidth( + ENET_Type *base, enet_ptp_timer_channel_t channel, bool isOutputLow, uint8_t pulseWidth, bool intEnable) +{ + uint32_t tcrReg; + + tcrReg = ENET_TCSR_TIE(intEnable) | ENET_TCSR_TPWC(pulseWidth); + + if (isOutputLow) + { + tcrReg |= ENET_TCSR_TMODE(kENET_PtpChannelPulseLowonCompare); + } + else + { + tcrReg |= ENET_TCSR_TMODE(kENET_PtpChannelPulseHighonCompare); + } + + /* Disable channel mode first. */ + base->CHANNEL[channel].TCSR = 0; + base->CHANNEL[channel].TCSR = tcrReg; +} +#endif /* FSL_FEATURE_ENET_HAS_TIMER_PWCONTROL */ + +/*! + * @brief Sets the ENET PTP 1588 timer channel comparison value. + * + * @param base ENET peripheral base address. + * @param channel The PTP timer channel, see "enet_ptp_timer_channel_t". + * @param cmpValue The compare value for the compare setting. + */ +static inline void ENET_Ptp1588SetChannelCmpValue(ENET_Type *base, enet_ptp_timer_channel_t channel, uint32_t cmpValue) +{ + base->CHANNEL[channel].TCCR = cmpValue; +} + +/*! + * @brief Gets the ENET PTP 1588 timer channel status. + * + * @param base ENET peripheral base address. + * @param channel The IEEE 1588 timer channel number. + * @return True or false, Compare or capture operation status + */ +static inline bool ENET_Ptp1588GetChannelStatus(ENET_Type *base, enet_ptp_timer_channel_t channel) +{ + return (0 != (base->CHANNEL[channel].TCSR & ENET_TCSR_TF_MASK)); +} + +/*! + * @brief Clears the ENET PTP 1588 timer channel status. + * + * @param base ENET peripheral base address. + * @param channel The IEEE 1588 timer channel number. + */ +static inline void ENET_Ptp1588ClearChannelStatus(ENET_Type *base, enet_ptp_timer_channel_t channel) +{ + base->CHANNEL[channel].TCSR |= ENET_TCSR_TF_MASK; + base->TGSR = (1U << channel); +} + +/*! + * @brief Gets the current ENET time from the PTP 1588 timer. + * + * @param base ENET peripheral base address. + * @param handle The ENET state pointer. This is the same state pointer used in the ENET_Init. + * @param ptpTime The PTP timer structure. + */ +void ENET_Ptp1588GetTimer(ENET_Type *base, enet_handle_t *handle, enet_ptp_time_t *ptpTime); + +/*! + * @brief Sets the ENET PTP 1588 timer to the assigned time. + * + * @param base ENET peripheral base address. + * @param handle The ENET state pointer. This is the same state pointer used in the ENET_Init. + * @param ptpTime The timer to be set to the PTP timer. + */ +void ENET_Ptp1588SetTimer(ENET_Type *base, enet_handle_t *handle, enet_ptp_time_t *ptpTime); + +/*! + * @brief The IEEE 1588 PTP time stamp interrupt handler. + * + * @param base ENET peripheral base address. + * @param handle The ENET state pointer. This is the same state pointer used in the ENET_Init. + */ +void ENET_Ptp1588TimerIRQHandler(ENET_Type *base, enet_handle_t *handle); + +/*! + * @brief Gets the time stamp of the received frame. + * + * This function is used for PTP stack to get the timestamp captured by the ENET driver. + * + * @param handle The ENET handler pointer.This is the same state pointer used in + * ENET_Init. + * @param ptpTimeData The special PTP timestamp data for search the receive timestamp. + * @retval kStatus_Success Get 1588 timestamp success. + * @retval kStatus_ENET_PtpTsRingEmpty 1588 timestamp ring empty. + * @retval kStatus_ENET_PtpTsRingFull 1588 timestamp ring full. + */ +status_t ENET_GetRxFrameTime(enet_handle_t *handle, enet_ptp_time_data_t *ptpTimeData); + +/*! + * @brief Gets the time stamp of the transmit frame. + * + * This function is used for PTP stack to get the timestamp captured by the ENET driver. + * + * @param handle The ENET handler pointer.This is the same state pointer used in + * ENET_Init. + * @param ptpTimeData The special PTP timestamp data for search the receive timestamp. + * @retval kStatus_Success Get 1588 timestamp success. + * @retval kStatus_ENET_PtpTsRingEmpty 1588 timestamp ring empty. + * @retval kStatus_ENET_PtpTsRingFull 1588 timestamp ring full. + */ +status_t ENET_GetTxFrameTime(enet_handle_t *handle, enet_ptp_time_data_t *ptpTimeData); +#endif /* ENET_ENHANCEDBUFFERDESCRIPTOR_MODE */ +/* @} */ + +#if defined(__cplusplus) +} +#endif + +/*! @}*/ + +#endif /* _FSL_ENET_H_ */ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_gpio.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_gpio.h old mode 100644 new mode 100755 similarity index 100% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_gpio.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_gpio.h diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_iomuxc.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_iomuxc.h old mode 100644 new mode 100755 similarity index 99% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_iomuxc.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_iomuxc.h index d6f33559..d7e9f268 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_iomuxc.h +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_iomuxc.h @@ -6,6 +6,26 @@ * SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_iomuxc.h + * @brief io mux drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + #ifndef _FSL_IOMUXC_H_ #define _FSL_IOMUXC_H_ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_lpuart.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_lpuart.h old mode 100644 new mode 100755 similarity index 98% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_lpuart.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_lpuart.h index 419951fc..71df1ae8 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_lpuart.h +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/fsl_lpuart.h @@ -5,6 +5,27 @@ * * SPDX-License-Identifier: BSD-3-Clause */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_lpuart.h + * @brief fsl uart drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + #ifndef _FSL_LPUART_H_ #define _FSL_LPUART_H_ diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/system_MIMXRT1052.h b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/system_MIMXRT1052.h old mode 100644 new mode 100755 similarity index 100% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/system_MIMXRT1052.h rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/include/system_MIMXRT1052.h diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/uart/Makefile b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/uart/Makefile index 7696ffaa..16316437 100644 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/uart/Makefile +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/uart/Makefile @@ -1,3 +1,3 @@ -SRC_FILES := connect_uart.c +SRC_FILES := connect_uart.c fsl_lpuart.c include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_lpuart.c b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/uart/fsl_lpuart.c old mode 100644 new mode 100755 similarity index 99% rename from Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_lpuart.c rename to Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/uart/fsl_lpuart.c index 76c71ea4..14c97f51 --- a/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/MIMXRT1052/drivers/fsl_lpuart.c +++ b/Ubiquitous/XiUOS/board/ok1052-c/third_party_driver/uart/fsl_lpuart.c @@ -6,6 +6,26 @@ * SPDX-License-Identifier: BSD-3-Clause */ +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file fsl_lpuart.c + * @brief fsl uart drivers + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.11.11 + */ + #include "fsl_lpuart.h" /******************************************************************************* diff --git a/Ubiquitous/XiUOS/kernel/thread/zombierecycle.c b/Ubiquitous/XiUOS/kernel/thread/zombierecycle.c index 0f7e84de..bf51ee84 100644 --- a/Ubiquitous/XiUOS/kernel/thread/zombierecycle.c +++ b/Ubiquitous/XiUOS/kernel/thread/zombierecycle.c @@ -76,19 +76,19 @@ static void ZombieKTaskEntry(void *parameter) SuspendKTask(zombie_recycle); CriticalAreaUnLock(lock); DO_KTASK_ASSIGN; - } + } } } void ZombieTaskRecycleInit(void) { InitDoubleLinkList(&KTaskZombie); - + zombie_recycle = KTaskCreate("ZombieRecycleKTask", ZombieKTaskEntry, NONE, ZOMBIE_KTASK_STACKSIZE, - KTASK_LOWEST_PRIORITY + 1); + KTASK_PRIORITY_MAX - 1); StartupKTask(zombie_recycle); } \ No newline at end of file diff --git a/Ubiquitous/XiUOS/path_app.mk b/Ubiquitous/XiUOS/path_app.mk index c82f8549..38f5f080 100644 --- a/Ubiquitous/XiUOS/path_app.mk +++ b/Ubiquitous/XiUOS/path_app.mk @@ -23,6 +23,11 @@ APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/knowing/tensorflow-li APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/knowing/tensorflow-lite/tensorflow-lite-for-mcu/source/third_party/ruy # endif +ifeq ($(CONFIG_SUPPORT_CONTROL_FRAMEWORK), y) +APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control # +APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control/plc/interoperability/opcua # +endif + ifeq ($(CONFIG_CRYPTO), y) APPPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/security/crypto/include # endif diff --git a/Ubiquitous/XiUOS/path_kernel.mk b/Ubiquitous/XiUOS/path_kernel.mk index b8ab6d15..e62ef3ef 100755 --- a/Ubiquitous/XiUOS/path_kernel.mk +++ b/Ubiquitous/XiUOS/path_kernel.mk @@ -174,10 +174,21 @@ KERNELPATHS :=-I$(BSP_ROOT) \ -I$(KERNEL_ROOT)/arch/arm/cortex-m7 \ -I$(BSP_ROOT)/third_party_driver \ -I$(BSP_ROOT)/third_party_driver/include \ + -I$(BSP_ROOT)/third_party_driver/ethernet \ + -I$(BSP_ROOT)/third_party_driver/ethernet/ksz8081 \ -I$(BSP_ROOT)/third_party_driver/MIMXRT1052 \ -I$(BSP_ROOT)/third_party_driver/MIMXRT1052/drivers \ -I$(BSP_ROOT)/third_party_driver/CMSIS/Include \ -I$(KERNEL_ROOT)/include \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/compat \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/netif \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/apps \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/priv \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/include/lwip/prot \ + -I$(KERNEL_ROOT)/resources/ethernet/LwIP/arch \ -I$(BSP_ROOT)/include # endif @@ -239,6 +250,11 @@ KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/knowing/tensorflow KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/knowing/tensorflow-lite/tensorflow-lite-for-mcu/source/third_party/ruy # endif +ifeq ($(CONFIG_SUPPORT_CONTROL_FRAMEWORK), y) +KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control # +KERNELPATHS += -I$(KERNEL_ROOT)/../../APP_Framework/Framework/control/plc/interoperability/opcua # +endif + ifeq ($(CONFIG_CRYPTO), y) KERNELPATHS += -I$(KERNEL_ROOT)/framework/security/crypto/include # endif @@ -246,10 +262,10 @@ endif KERNELPATHS += -I$(KERNEL_ROOT)/resources/include # ifeq ($(CONFIG_RESOURCES_SPI), y) -KERNELPATHS +=-I$(KERNEL_ROOT)/resources/spi # +KERNELPATHS +=-I$(KERNEL_ROOT)/resources/spi # ifeq ($(CONFIG_RESOURCES_SPI_SFUD),y) -KERNELPATHS += -I$(KERNEL_ROOT)/resources/spi/third_party_spi/SFUD/sfud/inc # +KERNELPATHS += -I$(KERNEL_ROOT)/resources/spi/third_party_spi/SFUD/sfud/inc # endif endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/FILES b/Ubiquitous/XiUOS/resources/ethernet/LwIP/FILES index 300448fb..0be0741d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/FILES +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/FILES @@ -1,15 +1,15 @@ -api/ - The code for the high-level wrapper API. Not needed if - you use the lowel-level call-back/raw API. - -apps/ - Higher layer applications that are specifically programmed - with the lwIP low-level raw API. - -core/ - The core of the TPC/IP stack; protocol implementations, - memory and buffer management, and the low-level raw API. - -include/ - lwIP include files. - -netif/ - Generic network interface device drivers are kept here. - -For more information on the various subdirectories, check the FILES -file in each directory. +api/ - The code for the high-level wrapper API. Not needed if + you use the lowel-level call-back/raw API. + +apps/ - Higher layer applications that are specifically programmed + with the lwIP low-level raw API. + +core/ - The core of the TPC/IP stack; protocol implementations, + memory and buffer management, and the low-level raw API. + +include/ - lwIP include files. + +netif/ - Generic network interface device drivers are kept here. + +For more information on the various subdirectories, check the FILES +file in each directory. diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.cmake b/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.cmake index 9448619a..c7656287 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.cmake +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.cmake @@ -1,279 +1,279 @@ -# This file is indended to be included in end-user CMakeLists.txt -# include(/path/to/Filelists.cmake) -# It assumes the variable LWIP_DIR is defined pointing to the -# root path of lwIP sources. -# -# This file is NOT designed (on purpose) to be used as cmake -# subdir via add_subdirectory() -# The intention is to provide greater flexibility to users to -# create their own targets using the *_SRCS variables. - -set(LWIP_VERSION_MAJOR "2") -set(LWIP_VERSION_MINOR "1") -set(LWIP_VERSION_REVISION "2") -# LWIP_VERSION_RC is set to LWIP_RC_RELEASE for official releases -# LWIP_VERSION_RC is set to LWIP_RC_DEVELOPMENT for Git versions -# Numbers 1..31 are reserved for release candidates -set(LWIP_VERSION_RC "LWIP_RC_RELEASE") - -if ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_RELEASE") - set(LWIP_VERSION_STRING - "${LWIP_VERSION_MAJOR}.${LWIP_VERSION_MINOR}.${LWIP_VERSION_REVISION}" - ) -elseif ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_DEVELOPMENT") - set(LWIP_VERSION_STRING - "${LWIP_VERSION_MAJOR}.${LWIP_VERSION_MINOR}.${LWIP_VERSION_REVISION}.dev" - ) -else ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_RELEASE") - set(LWIP_VERSION_STRING - "${LWIP_VERSION_MAJOR}.${LWIP_VERSION_MINOR}.${LWIP_VERSION_REVISION}.rc${LWIP_VERSION_RC}" - ) -endif ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_RELEASE") - -# The minimum set of files needed for lwIP. -set(lwipcore_SRCS - ${LWIP_DIR}/src/core/init.c - ${LWIP_DIR}/src/core/def.c - ${LWIP_DIR}/src/core/dns.c - ${LWIP_DIR}/src/core/inet_chksum.c - ${LWIP_DIR}/src/core/ip.c - ${LWIP_DIR}/src/core/mem.c - ${LWIP_DIR}/src/core/memp.c - ${LWIP_DIR}/src/core/netif.c - ${LWIP_DIR}/src/core/pbuf.c - ${LWIP_DIR}/src/core/raw.c - ${LWIP_DIR}/src/core/stats.c - ${LWIP_DIR}/src/core/sys.c - ${LWIP_DIR}/src/core/altcp.c - ${LWIP_DIR}/src/core/altcp_alloc.c - ${LWIP_DIR}/src/core/altcp_tcp.c - ${LWIP_DIR}/src/core/tcp.c - ${LWIP_DIR}/src/core/tcp_in.c - ${LWIP_DIR}/src/core/tcp_out.c - ${LWIP_DIR}/src/core/timeouts.c - ${LWIP_DIR}/src/core/udp.c -) -set(lwipcore4_SRCS - ${LWIP_DIR}/src/core/ipv4/autoip.c - ${LWIP_DIR}/src/core/ipv4/dhcp.c - ${LWIP_DIR}/src/core/ipv4/etharp.c - ${LWIP_DIR}/src/core/ipv4/icmp.c - ${LWIP_DIR}/src/core/ipv4/igmp.c - ${LWIP_DIR}/src/core/ipv4/ip4_frag.c - ${LWIP_DIR}/src/core/ipv4/ip4.c - ${LWIP_DIR}/src/core/ipv4/ip4_addr.c -) -set(lwipcore6_SRCS - ${LWIP_DIR}/src/core/ipv6/dhcp6.c - ${LWIP_DIR}/src/core/ipv6/ethip6.c - ${LWIP_DIR}/src/core/ipv6/icmp6.c - ${LWIP_DIR}/src/core/ipv6/inet6.c - ${LWIP_DIR}/src/core/ipv6/ip6.c - ${LWIP_DIR}/src/core/ipv6/ip6_addr.c - ${LWIP_DIR}/src/core/ipv6/ip6_frag.c - ${LWIP_DIR}/src/core/ipv6/mld6.c - ${LWIP_DIR}/src/core/ipv6/nd6.c -) - -# APIFILES: The files which implement the sequential and socket APIs. -set(lwipapi_SRCS - ${LWIP_DIR}/src/api/api_lib.c - ${LWIP_DIR}/src/api/api_msg.c - ${LWIP_DIR}/src/api/err.c - ${LWIP_DIR}/src/api/if_api.c - ${LWIP_DIR}/src/api/netbuf.c - ${LWIP_DIR}/src/api/netdb.c - ${LWIP_DIR}/src/api/netifapi.c - ${LWIP_DIR}/src/api/sockets.c - ${LWIP_DIR}/src/api/tcpip.c -) - -# Files implementing various generic network interface functions -set(lwipnetif_SRCS - ${LWIP_DIR}/src/netif/ethernet.c - ${LWIP_DIR}/src/netif/bridgeif.c - ${LWIP_DIR}/src/netif/bridgeif_fdb.c - ${LWIP_DIR}/src/netif/slipif.c -) - -# 6LoWPAN -set(lwipsixlowpan_SRCS - ${LWIP_DIR}/src/netif/lowpan6_common.c - ${LWIP_DIR}/src/netif/lowpan6.c - ${LWIP_DIR}/src/netif/lowpan6_ble.c - ${LWIP_DIR}/src/netif/zepif.c -) - -# PPP -set(lwipppp_SRCS - ${LWIP_DIR}/src/netif/ppp/auth.c - ${LWIP_DIR}/src/netif/ppp/ccp.c - ${LWIP_DIR}/src/netif/ppp/chap-md5.c - ${LWIP_DIR}/src/netif/ppp/chap_ms.c - ${LWIP_DIR}/src/netif/ppp/chap-new.c - ${LWIP_DIR}/src/netif/ppp/demand.c - ${LWIP_DIR}/src/netif/ppp/eap.c - ${LWIP_DIR}/src/netif/ppp/ecp.c - ${LWIP_DIR}/src/netif/ppp/eui64.c - ${LWIP_DIR}/src/netif/ppp/fsm.c - ${LWIP_DIR}/src/netif/ppp/ipcp.c - ${LWIP_DIR}/src/netif/ppp/ipv6cp.c - ${LWIP_DIR}/src/netif/ppp/lcp.c - ${LWIP_DIR}/src/netif/ppp/magic.c - ${LWIP_DIR}/src/netif/ppp/mppe.c - ${LWIP_DIR}/src/netif/ppp/multilink.c - ${LWIP_DIR}/src/netif/ppp/ppp.c - ${LWIP_DIR}/src/netif/ppp/pppapi.c - ${LWIP_DIR}/src/netif/ppp/pppcrypt.c - ${LWIP_DIR}/src/netif/ppp/pppoe.c - ${LWIP_DIR}/src/netif/ppp/pppol2tp.c - ${LWIP_DIR}/src/netif/ppp/pppos.c - ${LWIP_DIR}/src/netif/ppp/upap.c - ${LWIP_DIR}/src/netif/ppp/utils.c - ${LWIP_DIR}/src/netif/ppp/vj.c - ${LWIP_DIR}/src/netif/ppp/polarssl/arc4.c - ${LWIP_DIR}/src/netif/ppp/polarssl/des.c - ${LWIP_DIR}/src/netif/ppp/polarssl/md4.c - ${LWIP_DIR}/src/netif/ppp/polarssl/md5.c - ${LWIP_DIR}/src/netif/ppp/polarssl/sha1.c -) - -# SNMPv3 agent -set(lwipsnmp_SRCS - ${LWIP_DIR}/src/apps/snmp/snmp_asn1.c - ${LWIP_DIR}/src/apps/snmp/snmp_core.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2_icmp.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2_interfaces.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2_ip.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2_snmp.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2_system.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2_tcp.c - ${LWIP_DIR}/src/apps/snmp/snmp_mib2_udp.c - ${LWIP_DIR}/src/apps/snmp/snmp_snmpv2_framework.c - ${LWIP_DIR}/src/apps/snmp/snmp_snmpv2_usm.c - ${LWIP_DIR}/src/apps/snmp/snmp_msg.c - ${LWIP_DIR}/src/apps/snmp/snmpv3.c - ${LWIP_DIR}/src/apps/snmp/snmp_netconn.c - ${LWIP_DIR}/src/apps/snmp/snmp_pbuf_stream.c - ${LWIP_DIR}/src/apps/snmp/snmp_raw.c - ${LWIP_DIR}/src/apps/snmp/snmp_scalar.c - ${LWIP_DIR}/src/apps/snmp/snmp_table.c - ${LWIP_DIR}/src/apps/snmp/snmp_threadsync.c - ${LWIP_DIR}/src/apps/snmp/snmp_traps.c -) - -# HTTP server + client -set(lwiphttp_SRCS - ${LWIP_DIR}/src/apps/http/altcp_proxyconnect.c - ${LWIP_DIR}/src/apps/http/fs.c - ${LWIP_DIR}/src/apps/http/http_client.c - ${LWIP_DIR}/src/apps/http/httpd.c -) - -# MAKEFSDATA HTTP server host utility -set(lwipmakefsdata_SRCS - ${LWIP_DIR}/src/apps/http/makefsdata/makefsdata.c -) - -# IPERF server -set(lwipiperf_SRCS - ${LWIP_DIR}/src/apps/lwiperf/lwiperf.c -) - -# SMTP client -set(lwipsmtp_SRCS - ${LWIP_DIR}/src/apps/smtp/smtp.c -) - -# SNTP client -set(lwipsntp_SRCS - ${LWIP_DIR}/src/apps/sntp/sntp.c -) - -# MDNS responder -set(lwipmdns_SRCS - ${LWIP_DIR}/src/apps/mdns/mdns.c -) - -# NetBIOS name server -set(lwipnetbios_SRCS - ${LWIP_DIR}/src/apps/netbiosns/netbiosns.c -) - -# TFTP server files -set(lwiptftp_SRCS - ${LWIP_DIR}/src/apps/tftp/tftp_server.c -) - -# MQTT client files -set(lwipmqtt_SRCS - ${LWIP_DIR}/src/apps/mqtt/mqtt.c -) - -# ARM MBEDTLS related files of lwIP rep -set(lwipmbedtls_SRCS - ${LWIP_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls.c - ${LWIP_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls_mem.c - ${LWIP_DIR}/src/apps/snmp/snmpv3_mbedtls.c -) - -# All LWIP files without apps -set(lwipnoapps_SRCS - ${lwipcore_SRCS} - ${lwipcore4_SRCS} - ${lwipcore6_SRCS} - ${lwipapi_SRCS} - ${lwipnetif_SRCS} - ${lwipsixlowpan_SRCS} - ${lwipppp_SRCS} -) - -# LWIPAPPFILES: All LWIP APPs -set(lwipallapps_SRCS - ${lwipsnmp_SRCS} - ${lwiphttp_SRCS} - ${lwipiperf_SRCS} - ${lwipsmtp_SRCS} - ${lwipsntp_SRCS} - ${lwipmdns_SRCS} - ${lwipnetbios_SRCS} - ${lwiptftp_SRCS} - ${lwipmqtt_SRCS} - ${lwipmbedtls_SRCS} -) - -# Generate lwip/init.h (version info) -configure_file(${LWIP_DIR}/src/include/lwip/init.h.cmake.in ${LWIP_DIR}/src/include/lwip/init.h) - -# Documentation -set(DOXYGEN_DIR ${LWIP_DIR}/doc/doxygen) -set(DOXYGEN_OUTPUT_DIR output) -set(DOXYGEN_IN ${LWIP_DIR}/doc/doxygen/lwip.Doxyfile.cmake.in) -set(DOXYGEN_OUT ${LWIP_DIR}/doc/doxygen/lwip.Doxyfile) -configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT}) - -find_package(Doxygen) -if (DOXYGEN_FOUND) - message("Doxygen build started") - - add_custom_target(lwipdocs - COMMAND ${CMAKE_COMMAND} -E remove_directory ${DOXYGEN_DIR}/${DOXYGEN_OUTPUT_DIR}/html - COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT} - WORKING_DIRECTORY ${DOXYGEN_DIR} - COMMENT "Generating API documentation with Doxygen" - VERBATIM) -else (DOXYGEN_FOUND) - message("Doxygen needs to be installed to generate the doxygen documentation") -endif (DOXYGEN_FOUND) - -# lwIP libraries -add_library(lwipcore EXCLUDE_FROM_ALL ${lwipnoapps_SRCS}) -target_compile_options(lwipcore PRIVATE ${LWIP_COMPILER_FLAGS}) -target_compile_definitions(lwipcore PRIVATE ${LWIP_DEFINITIONS} ${LWIP_MBEDTLS_DEFINITIONS}) -target_include_directories(lwipcore PRIVATE ${LWIP_INCLUDE_DIRS} ${LWIP_MBEDTLS_INCLUDE_DIRS}) - -add_library(lwipallapps EXCLUDE_FROM_ALL ${lwipallapps_SRCS}) -target_compile_options(lwipallapps PRIVATE ${LWIP_COMPILER_FLAGS}) -target_compile_definitions(lwipallapps PRIVATE ${LWIP_DEFINITIONS} ${LWIP_MBEDTLS_DEFINITIONS}) -target_include_directories(lwipallapps PRIVATE ${LWIP_INCLUDE_DIRS} ${LWIP_MBEDTLS_INCLUDE_DIRS}) +# This file is indended to be included in end-user CMakeLists.txt +# include(/path/to/Filelists.cmake) +# It assumes the variable LWIP_DIR is defined pointing to the +# root path of lwIP sources. +# +# This file is NOT designed (on purpose) to be used as cmake +# subdir via add_subdirectory() +# The intention is to provide greater flexibility to users to +# create their own targets using the *_SRCS variables. + +set(LWIP_VERSION_MAJOR "2") +set(LWIP_VERSION_MINOR "1") +set(LWIP_VERSION_REVISION "2") +# LWIP_VERSION_RC is set to LWIP_RC_RELEASE for official releases +# LWIP_VERSION_RC is set to LWIP_RC_DEVELOPMENT for Git versions +# Numbers 1..31 are reserved for release candidates +set(LWIP_VERSION_RC "LWIP_RC_RELEASE") + +if ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_RELEASE") + set(LWIP_VERSION_STRING + "${LWIP_VERSION_MAJOR}.${LWIP_VERSION_MINOR}.${LWIP_VERSION_REVISION}" + ) +elseif ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_DEVELOPMENT") + set(LWIP_VERSION_STRING + "${LWIP_VERSION_MAJOR}.${LWIP_VERSION_MINOR}.${LWIP_VERSION_REVISION}.dev" + ) +else ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_RELEASE") + set(LWIP_VERSION_STRING + "${LWIP_VERSION_MAJOR}.${LWIP_VERSION_MINOR}.${LWIP_VERSION_REVISION}.rc${LWIP_VERSION_RC}" + ) +endif ("${LWIP_VERSION_RC}" STREQUAL "LWIP_RC_RELEASE") + +# The minimum set of files needed for lwIP. +set(lwipcore_SRCS + ${LWIP_DIR}/src/core/init.c + ${LWIP_DIR}/src/core/def.c + ${LWIP_DIR}/src/core/dns.c + ${LWIP_DIR}/src/core/inet_chksum.c + ${LWIP_DIR}/src/core/ip.c + ${LWIP_DIR}/src/core/mem.c + ${LWIP_DIR}/src/core/memp.c + ${LWIP_DIR}/src/core/netif.c + ${LWIP_DIR}/src/core/pbuf.c + ${LWIP_DIR}/src/core/raw.c + ${LWIP_DIR}/src/core/stats.c + ${LWIP_DIR}/src/core/sys.c + ${LWIP_DIR}/src/core/altcp.c + ${LWIP_DIR}/src/core/altcp_alloc.c + ${LWIP_DIR}/src/core/altcp_tcp.c + ${LWIP_DIR}/src/core/tcp.c + ${LWIP_DIR}/src/core/tcp_in.c + ${LWIP_DIR}/src/core/tcp_out.c + ${LWIP_DIR}/src/core/timeouts.c + ${LWIP_DIR}/src/core/udp.c +) +set(lwipcore4_SRCS + ${LWIP_DIR}/src/core/ipv4/autoip.c + ${LWIP_DIR}/src/core/ipv4/dhcp.c + ${LWIP_DIR}/src/core/ipv4/etharp.c + ${LWIP_DIR}/src/core/ipv4/icmp.c + ${LWIP_DIR}/src/core/ipv4/igmp.c + ${LWIP_DIR}/src/core/ipv4/ip4_frag.c + ${LWIP_DIR}/src/core/ipv4/ip4.c + ${LWIP_DIR}/src/core/ipv4/ip4_addr.c +) +set(lwipcore6_SRCS + ${LWIP_DIR}/src/core/ipv6/dhcp6.c + ${LWIP_DIR}/src/core/ipv6/ethip6.c + ${LWIP_DIR}/src/core/ipv6/icmp6.c + ${LWIP_DIR}/src/core/ipv6/inet6.c + ${LWIP_DIR}/src/core/ipv6/ip6.c + ${LWIP_DIR}/src/core/ipv6/ip6_addr.c + ${LWIP_DIR}/src/core/ipv6/ip6_frag.c + ${LWIP_DIR}/src/core/ipv6/mld6.c + ${LWIP_DIR}/src/core/ipv6/nd6.c +) + +# APIFILES: The files which implement the sequential and socket APIs. +set(lwipapi_SRCS + ${LWIP_DIR}/src/api/api_lib.c + ${LWIP_DIR}/src/api/api_msg.c + ${LWIP_DIR}/src/api/err.c + ${LWIP_DIR}/src/api/if_api.c + ${LWIP_DIR}/src/api/netbuf.c + ${LWIP_DIR}/src/api/netdb.c + ${LWIP_DIR}/src/api/netifapi.c + ${LWIP_DIR}/src/api/sockets.c + ${LWIP_DIR}/src/api/tcpip.c +) + +# Files implementing various generic network interface functions +set(lwipnetif_SRCS + ${LWIP_DIR}/src/netif/ethernet.c + ${LWIP_DIR}/src/netif/bridgeif.c + ${LWIP_DIR}/src/netif/bridgeif_fdb.c + ${LWIP_DIR}/src/netif/slipif.c +) + +# 6LoWPAN +set(lwipsixlowpan_SRCS + ${LWIP_DIR}/src/netif/lowpan6_common.c + ${LWIP_DIR}/src/netif/lowpan6.c + ${LWIP_DIR}/src/netif/lowpan6_ble.c + ${LWIP_DIR}/src/netif/zepif.c +) + +# PPP +set(lwipppp_SRCS + ${LWIP_DIR}/src/netif/ppp/auth.c + ${LWIP_DIR}/src/netif/ppp/ccp.c + ${LWIP_DIR}/src/netif/ppp/chap-md5.c + ${LWIP_DIR}/src/netif/ppp/chap_ms.c + ${LWIP_DIR}/src/netif/ppp/chap-new.c + ${LWIP_DIR}/src/netif/ppp/demand.c + ${LWIP_DIR}/src/netif/ppp/eap.c + ${LWIP_DIR}/src/netif/ppp/ecp.c + ${LWIP_DIR}/src/netif/ppp/eui64.c + ${LWIP_DIR}/src/netif/ppp/fsm.c + ${LWIP_DIR}/src/netif/ppp/ipcp.c + ${LWIP_DIR}/src/netif/ppp/ipv6cp.c + ${LWIP_DIR}/src/netif/ppp/lcp.c + ${LWIP_DIR}/src/netif/ppp/magic.c + ${LWIP_DIR}/src/netif/ppp/mppe.c + ${LWIP_DIR}/src/netif/ppp/multilink.c + ${LWIP_DIR}/src/netif/ppp/ppp.c + ${LWIP_DIR}/src/netif/ppp/pppapi.c + ${LWIP_DIR}/src/netif/ppp/pppcrypt.c + ${LWIP_DIR}/src/netif/ppp/pppoe.c + ${LWIP_DIR}/src/netif/ppp/pppol2tp.c + ${LWIP_DIR}/src/netif/ppp/pppos.c + ${LWIP_DIR}/src/netif/ppp/upap.c + ${LWIP_DIR}/src/netif/ppp/utils.c + ${LWIP_DIR}/src/netif/ppp/vj.c + ${LWIP_DIR}/src/netif/ppp/polarssl/arc4.c + ${LWIP_DIR}/src/netif/ppp/polarssl/des.c + ${LWIP_DIR}/src/netif/ppp/polarssl/md4.c + ${LWIP_DIR}/src/netif/ppp/polarssl/md5.c + ${LWIP_DIR}/src/netif/ppp/polarssl/sha1.c +) + +# SNMPv3 agent +set(lwipsnmp_SRCS + ${LWIP_DIR}/src/apps/snmp/snmp_asn1.c + ${LWIP_DIR}/src/apps/snmp/snmp_core.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2_icmp.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2_interfaces.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2_ip.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2_snmp.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2_system.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2_tcp.c + ${LWIP_DIR}/src/apps/snmp/snmp_mib2_udp.c + ${LWIP_DIR}/src/apps/snmp/snmp_snmpv2_framework.c + ${LWIP_DIR}/src/apps/snmp/snmp_snmpv2_usm.c + ${LWIP_DIR}/src/apps/snmp/snmp_msg.c + ${LWIP_DIR}/src/apps/snmp/snmpv3.c + ${LWIP_DIR}/src/apps/snmp/snmp_netconn.c + ${LWIP_DIR}/src/apps/snmp/snmp_pbuf_stream.c + ${LWIP_DIR}/src/apps/snmp/snmp_raw.c + ${LWIP_DIR}/src/apps/snmp/snmp_scalar.c + ${LWIP_DIR}/src/apps/snmp/snmp_table.c + ${LWIP_DIR}/src/apps/snmp/snmp_threadsync.c + ${LWIP_DIR}/src/apps/snmp/snmp_traps.c +) + +# HTTP server + client +set(lwiphttp_SRCS + ${LWIP_DIR}/src/apps/http/altcp_proxyconnect.c + ${LWIP_DIR}/src/apps/http/fs.c + ${LWIP_DIR}/src/apps/http/http_client.c + ${LWIP_DIR}/src/apps/http/httpd.c +) + +# MAKEFSDATA HTTP server host utility +set(lwipmakefsdata_SRCS + ${LWIP_DIR}/src/apps/http/makefsdata/makefsdata.c +) + +# IPERF server +set(lwipiperf_SRCS + ${LWIP_DIR}/src/apps/lwiperf/lwiperf.c +) + +# SMTP client +set(lwipsmtp_SRCS + ${LWIP_DIR}/src/apps/smtp/smtp.c +) + +# SNTP client +set(lwipsntp_SRCS + ${LWIP_DIR}/src/apps/sntp/sntp.c +) + +# MDNS responder +set(lwipmdns_SRCS + ${LWIP_DIR}/src/apps/mdns/mdns.c +) + +# NetBIOS name server +set(lwipnetbios_SRCS + ${LWIP_DIR}/src/apps/netbiosns/netbiosns.c +) + +# TFTP server files +set(lwiptftp_SRCS + ${LWIP_DIR}/src/apps/tftp/tftp_server.c +) + +# MQTT client files +set(lwipmqtt_SRCS + ${LWIP_DIR}/src/apps/mqtt/mqtt.c +) + +# ARM MBEDTLS related files of lwIP rep +set(lwipmbedtls_SRCS + ${LWIP_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls.c + ${LWIP_DIR}/src/apps/altcp_tls/altcp_tls_mbedtls_mem.c + ${LWIP_DIR}/src/apps/snmp/snmpv3_mbedtls.c +) + +# All LWIP files without apps +set(lwipnoapps_SRCS + ${lwipcore_SRCS} + ${lwipcore4_SRCS} + ${lwipcore6_SRCS} + ${lwipapi_SRCS} + ${lwipnetif_SRCS} + ${lwipsixlowpan_SRCS} + ${lwipppp_SRCS} +) + +# LWIPAPPFILES: All LWIP APPs +set(lwipallapps_SRCS + ${lwipsnmp_SRCS} + ${lwiphttp_SRCS} + ${lwipiperf_SRCS} + ${lwipsmtp_SRCS} + ${lwipsntp_SRCS} + ${lwipmdns_SRCS} + ${lwipnetbios_SRCS} + ${lwiptftp_SRCS} + ${lwipmqtt_SRCS} + ${lwipmbedtls_SRCS} +) + +# Generate lwip/init.h (version info) +configure_file(${LWIP_DIR}/src/include/lwip/init.h.cmake.in ${LWIP_DIR}/src/include/lwip/init.h) + +# Documentation +set(DOXYGEN_DIR ${LWIP_DIR}/doc/doxygen) +set(DOXYGEN_OUTPUT_DIR output) +set(DOXYGEN_IN ${LWIP_DIR}/doc/doxygen/lwip.Doxyfile.cmake.in) +set(DOXYGEN_OUT ${LWIP_DIR}/doc/doxygen/lwip.Doxyfile) +configure_file(${DOXYGEN_IN} ${DOXYGEN_OUT}) + +find_package(Doxygen) +if (DOXYGEN_FOUND) + message("Doxygen build started") + + add_custom_target(lwipdocs + COMMAND ${CMAKE_COMMAND} -E remove_directory ${DOXYGEN_DIR}/${DOXYGEN_OUTPUT_DIR}/html + COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_OUT} + WORKING_DIRECTORY ${DOXYGEN_DIR} + COMMENT "Generating API documentation with Doxygen" + VERBATIM) +else (DOXYGEN_FOUND) + message("Doxygen needs to be installed to generate the doxygen documentation") +endif (DOXYGEN_FOUND) + +# lwIP libraries +add_library(lwipcore EXCLUDE_FROM_ALL ${lwipnoapps_SRCS}) +target_compile_options(lwipcore PRIVATE ${LWIP_COMPILER_FLAGS}) +target_compile_definitions(lwipcore PRIVATE ${LWIP_DEFINITIONS} ${LWIP_MBEDTLS_DEFINITIONS}) +target_include_directories(lwipcore PRIVATE ${LWIP_INCLUDE_DIRS} ${LWIP_MBEDTLS_INCLUDE_DIRS}) + +add_library(lwipallapps EXCLUDE_FROM_ALL ${lwipallapps_SRCS}) +target_compile_options(lwipallapps PRIVATE ${LWIP_COMPILER_FLAGS}) +target_compile_definitions(lwipallapps PRIVATE ${LWIP_DEFINITIONS} ${LWIP_MBEDTLS_DEFINITIONS}) +target_include_directories(lwipallapps PRIVATE ${LWIP_INCLUDE_DIRS} ${LWIP_MBEDTLS_INCLUDE_DIRS}) diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.mk b/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.mk index 12e1b40c..828b9f2a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.mk +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/Filelists.mk @@ -1,205 +1,205 @@ -# -# Copyright (c) 2001, 2002 Swedish Institute of Computer Science. -# 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. The name of the author may not be used to endorse or promote products -# derived from this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. -# -# This file is part of the lwIP TCP/IP stack. -# -# Author: Adam Dunkels -# - -# COREFILES, CORE4FILES: The minimum set of files needed for lwIP. -COREFILES=$(LWIPDIR)/core/init.c \ - $(LWIPDIR)/core/def.c \ - $(LWIPDIR)/core/dns.c \ - $(LWIPDIR)/core/inet_chksum.c \ - $(LWIPDIR)/core/ip.c \ - $(LWIPDIR)/core/mem.c \ - $(LWIPDIR)/core/memp.c \ - $(LWIPDIR)/core/netif.c \ - $(LWIPDIR)/core/pbuf.c \ - $(LWIPDIR)/core/raw.c \ - $(LWIPDIR)/core/stats.c \ - $(LWIPDIR)/core/sys.c \ - $(LWIPDIR)/core/altcp.c \ - $(LWIPDIR)/core/altcp_alloc.c \ - $(LWIPDIR)/core/altcp_tcp.c \ - $(LWIPDIR)/core/tcp.c \ - $(LWIPDIR)/core/tcp_in.c \ - $(LWIPDIR)/core/tcp_out.c \ - $(LWIPDIR)/core/timeouts.c \ - $(LWIPDIR)/core/udp.c - -CORE4FILES=$(LWIPDIR)/core/ipv4/autoip.c \ - $(LWIPDIR)/core/ipv4/dhcp.c \ - $(LWIPDIR)/core/ipv4/etharp.c \ - $(LWIPDIR)/core/ipv4/icmp.c \ - $(LWIPDIR)/core/ipv4/igmp.c \ - $(LWIPDIR)/core/ipv4/ip4_frag.c \ - $(LWIPDIR)/core/ipv4/ip4.c \ - $(LWIPDIR)/core/ipv4/ip4_addr.c - -CORE6FILES=$(LWIPDIR)/core/ipv6/dhcp6.c \ - $(LWIPDIR)/core/ipv6/ethip6.c \ - $(LWIPDIR)/core/ipv6/icmp6.c \ - $(LWIPDIR)/core/ipv6/inet6.c \ - $(LWIPDIR)/core/ipv6/ip6.c \ - $(LWIPDIR)/core/ipv6/ip6_addr.c \ - $(LWIPDIR)/core/ipv6/ip6_frag.c \ - $(LWIPDIR)/core/ipv6/mld6.c \ - $(LWIPDIR)/core/ipv6/nd6.c - -# APIFILES: The files which implement the sequential and socket APIs. -APIFILES=$(LWIPDIR)/api/api_lib.c \ - $(LWIPDIR)/api/api_msg.c \ - $(LWIPDIR)/api/err.c \ - $(LWIPDIR)/api/if_api.c \ - $(LWIPDIR)/api/netbuf.c \ - $(LWIPDIR)/api/netdb.c \ - $(LWIPDIR)/api/netifapi.c \ - $(LWIPDIR)/api/sockets.c \ - $(LWIPDIR)/api/tcpip.c - -# NETIFFILES: Files implementing various generic network interface functions -NETIFFILES=$(LWIPDIR)/netif/ethernet.c \ - $(LWIPDIR)/netif/bridgeif.c \ - $(LWIPDIR)/netif/bridgeif_fdb.c \ - $(LWIPDIR)/netif/slipif.c - -# SIXLOWPAN: 6LoWPAN -SIXLOWPAN=$(LWIPDIR)/netif/lowpan6_common.c \ - $(LWIPDIR)/netif/lowpan6.c \ - $(LWIPDIR)/netif/lowpan6_ble.c \ - $(LWIPDIR)/netif/zepif.c - -# PPPFILES: PPP -PPPFILES=$(LWIPDIR)/netif/ppp/auth.c \ - $(LWIPDIR)/netif/ppp/ccp.c \ - $(LWIPDIR)/netif/ppp/chap-md5.c \ - $(LWIPDIR)/netif/ppp/chap_ms.c \ - $(LWIPDIR)/netif/ppp/chap-new.c \ - $(LWIPDIR)/netif/ppp/demand.c \ - $(LWIPDIR)/netif/ppp/eap.c \ - $(LWIPDIR)/netif/ppp/ecp.c \ - $(LWIPDIR)/netif/ppp/eui64.c \ - $(LWIPDIR)/netif/ppp/fsm.c \ - $(LWIPDIR)/netif/ppp/ipcp.c \ - $(LWIPDIR)/netif/ppp/ipv6cp.c \ - $(LWIPDIR)/netif/ppp/lcp.c \ - $(LWIPDIR)/netif/ppp/magic.c \ - $(LWIPDIR)/netif/ppp/mppe.c \ - $(LWIPDIR)/netif/ppp/multilink.c \ - $(LWIPDIR)/netif/ppp/ppp.c \ - $(LWIPDIR)/netif/ppp/pppapi.c \ - $(LWIPDIR)/netif/ppp/pppcrypt.c \ - $(LWIPDIR)/netif/ppp/pppoe.c \ - $(LWIPDIR)/netif/ppp/pppol2tp.c \ - $(LWIPDIR)/netif/ppp/pppos.c \ - $(LWIPDIR)/netif/ppp/upap.c \ - $(LWIPDIR)/netif/ppp/utils.c \ - $(LWIPDIR)/netif/ppp/vj.c \ - $(LWIPDIR)/netif/ppp/polarssl/arc4.c \ - $(LWIPDIR)/netif/ppp/polarssl/des.c \ - $(LWIPDIR)/netif/ppp/polarssl/md4.c \ - $(LWIPDIR)/netif/ppp/polarssl/md5.c \ - $(LWIPDIR)/netif/ppp/polarssl/sha1.c - -# LWIPNOAPPSFILES: All LWIP files without apps -LWIPNOAPPSFILES=$(COREFILES) \ - $(CORE4FILES) \ - $(CORE6FILES) \ - $(APIFILES) \ - $(NETIFFILES) \ - $(PPPFILES) \ - $(SIXLOWPAN) - -# SNMPFILES: SNMPv2c agent -SNMPFILES=$(LWIPDIR)/apps/snmp/snmp_asn1.c \ - $(LWIPDIR)/apps/snmp/snmp_core.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2_icmp.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2_interfaces.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2_ip.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2_snmp.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2_system.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2_tcp.c \ - $(LWIPDIR)/apps/snmp/snmp_mib2_udp.c \ - $(LWIPDIR)/apps/snmp/snmp_snmpv2_framework.c \ - $(LWIPDIR)/apps/snmp/snmp_snmpv2_usm.c \ - $(LWIPDIR)/apps/snmp/snmp_msg.c \ - $(LWIPDIR)/apps/snmp/snmpv3.c \ - $(LWIPDIR)/apps/snmp/snmp_netconn.c \ - $(LWIPDIR)/apps/snmp/snmp_pbuf_stream.c \ - $(LWIPDIR)/apps/snmp/snmp_raw.c \ - $(LWIPDIR)/apps/snmp/snmp_scalar.c \ - $(LWIPDIR)/apps/snmp/snmp_table.c \ - $(LWIPDIR)/apps/snmp/snmp_threadsync.c \ - $(LWIPDIR)/apps/snmp/snmp_traps.c - -# HTTPFILES: HTTP server + client -HTTPFILES=$(LWIPDIR)/apps/http/altcp_proxyconnect.c \ - $(LWIPDIR)/apps/http/fs.c \ - $(LWIPDIR)/apps/http/http_client.c \ - $(LWIPDIR)/apps/http/httpd.c - -# MAKEFSDATA: MAKEFSDATA HTTP server host utility -MAKEFSDATAFILES=$(LWIPDIR)/apps/http/makefsdata/makefsdata.c - -# LWIPERFFILES: IPERF server -LWIPERFFILES=$(LWIPDIR)/apps/lwiperf/lwiperf.c - -# SMTPFILES: SMTP client -SMTPFILES=$(LWIPDIR)/apps/smtp/smtp.c - -# SNTPFILES: SNTP client -SNTPFILES=$(LWIPDIR)/apps/sntp/sntp.c - -# MDNSFILES: MDNS responder -MDNSFILES=$(LWIPDIR)/apps/mdns/mdns.c - -# NETBIOSNSFILES: NetBIOS name server -NETBIOSNSFILES=$(LWIPDIR)/apps/netbiosns/netbiosns.c - -# TFTPFILES: TFTP server files -TFTPFILES=$(LWIPDIR)/apps/tftp/tftp_server.c - -# MQTTFILES: MQTT client files -MQTTFILES=$(LWIPDIR)/apps/mqtt/mqtt.c - -# MBEDTLS_FILES: MBEDTLS related files of lwIP rep -MBEDTLS_FILES=$(LWIPDIR)/apps/altcp_tls/altcp_tls_mbedtls.c \ - $(LWIPDIR)/apps/altcp_tls/altcp_tls_mbedtls_mem.c \ - $(LWIPDIR)/apps/snmp/snmpv3_mbedtls.c - -# LWIPAPPFILES: All LWIP APPs -LWIPAPPFILES=$(SNMPFILES) \ - $(HTTPFILES) \ - $(LWIPERFFILES) \ - $(SMTPFILES) \ - $(SNTPFILES) \ - $(MDNSFILES) \ - $(NETBIOSNSFILES) \ - $(TFTPFILES) \ - $(MQTTFILES) \ - $(MBEDTLS_FILES) +# +# Copyright (c) 2001, 2002 Swedish Institute of Computer Science. +# 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. The name of the author may not be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. +# +# This file is part of the lwIP TCP/IP stack. +# +# Author: Adam Dunkels +# + +# COREFILES, CORE4FILES: The minimum set of files needed for lwIP. +COREFILES=$(LWIPDIR)/core/init.c \ + $(LWIPDIR)/core/def.c \ + $(LWIPDIR)/core/dns.c \ + $(LWIPDIR)/core/inet_chksum.c \ + $(LWIPDIR)/core/ip.c \ + $(LWIPDIR)/core/mem.c \ + $(LWIPDIR)/core/memp.c \ + $(LWIPDIR)/core/netif.c \ + $(LWIPDIR)/core/pbuf.c \ + $(LWIPDIR)/core/raw.c \ + $(LWIPDIR)/core/stats.c \ + $(LWIPDIR)/core/sys.c \ + $(LWIPDIR)/core/altcp.c \ + $(LWIPDIR)/core/altcp_alloc.c \ + $(LWIPDIR)/core/altcp_tcp.c \ + $(LWIPDIR)/core/tcp.c \ + $(LWIPDIR)/core/tcp_in.c \ + $(LWIPDIR)/core/tcp_out.c \ + $(LWIPDIR)/core/timeouts.c \ + $(LWIPDIR)/core/udp.c + +CORE4FILES=$(LWIPDIR)/core/ipv4/autoip.c \ + $(LWIPDIR)/core/ipv4/dhcp.c \ + $(LWIPDIR)/core/ipv4/etharp.c \ + $(LWIPDIR)/core/ipv4/icmp.c \ + $(LWIPDIR)/core/ipv4/igmp.c \ + $(LWIPDIR)/core/ipv4/ip4_frag.c \ + $(LWIPDIR)/core/ipv4/ip4.c \ + $(LWIPDIR)/core/ipv4/ip4_addr.c + +CORE6FILES=$(LWIPDIR)/core/ipv6/dhcp6.c \ + $(LWIPDIR)/core/ipv6/ethip6.c \ + $(LWIPDIR)/core/ipv6/icmp6.c \ + $(LWIPDIR)/core/ipv6/inet6.c \ + $(LWIPDIR)/core/ipv6/ip6.c \ + $(LWIPDIR)/core/ipv6/ip6_addr.c \ + $(LWIPDIR)/core/ipv6/ip6_frag.c \ + $(LWIPDIR)/core/ipv6/mld6.c \ + $(LWIPDIR)/core/ipv6/nd6.c + +# APIFILES: The files which implement the sequential and socket APIs. +APIFILES=$(LWIPDIR)/api/api_lib.c \ + $(LWIPDIR)/api/api_msg.c \ + $(LWIPDIR)/api/err.c \ + $(LWIPDIR)/api/if_api.c \ + $(LWIPDIR)/api/netbuf.c \ + $(LWIPDIR)/api/netdb.c \ + $(LWIPDIR)/api/netifapi.c \ + $(LWIPDIR)/api/sockets.c \ + $(LWIPDIR)/api/tcpip.c + +# NETIFFILES: Files implementing various generic network interface functions +NETIFFILES=$(LWIPDIR)/netif/ethernet.c \ + $(LWIPDIR)/netif/bridgeif.c \ + $(LWIPDIR)/netif/bridgeif_fdb.c \ + $(LWIPDIR)/netif/slipif.c + +# SIXLOWPAN: 6LoWPAN +SIXLOWPAN=$(LWIPDIR)/netif/lowpan6_common.c \ + $(LWIPDIR)/netif/lowpan6.c \ + $(LWIPDIR)/netif/lowpan6_ble.c \ + $(LWIPDIR)/netif/zepif.c + +# PPPFILES: PPP +PPPFILES=$(LWIPDIR)/netif/ppp/auth.c \ + $(LWIPDIR)/netif/ppp/ccp.c \ + $(LWIPDIR)/netif/ppp/chap-md5.c \ + $(LWIPDIR)/netif/ppp/chap_ms.c \ + $(LWIPDIR)/netif/ppp/chap-new.c \ + $(LWIPDIR)/netif/ppp/demand.c \ + $(LWIPDIR)/netif/ppp/eap.c \ + $(LWIPDIR)/netif/ppp/ecp.c \ + $(LWIPDIR)/netif/ppp/eui64.c \ + $(LWIPDIR)/netif/ppp/fsm.c \ + $(LWIPDIR)/netif/ppp/ipcp.c \ + $(LWIPDIR)/netif/ppp/ipv6cp.c \ + $(LWIPDIR)/netif/ppp/lcp.c \ + $(LWIPDIR)/netif/ppp/magic.c \ + $(LWIPDIR)/netif/ppp/mppe.c \ + $(LWIPDIR)/netif/ppp/multilink.c \ + $(LWIPDIR)/netif/ppp/ppp.c \ + $(LWIPDIR)/netif/ppp/pppapi.c \ + $(LWIPDIR)/netif/ppp/pppcrypt.c \ + $(LWIPDIR)/netif/ppp/pppoe.c \ + $(LWIPDIR)/netif/ppp/pppol2tp.c \ + $(LWIPDIR)/netif/ppp/pppos.c \ + $(LWIPDIR)/netif/ppp/upap.c \ + $(LWIPDIR)/netif/ppp/utils.c \ + $(LWIPDIR)/netif/ppp/vj.c \ + $(LWIPDIR)/netif/ppp/polarssl/arc4.c \ + $(LWIPDIR)/netif/ppp/polarssl/des.c \ + $(LWIPDIR)/netif/ppp/polarssl/md4.c \ + $(LWIPDIR)/netif/ppp/polarssl/md5.c \ + $(LWIPDIR)/netif/ppp/polarssl/sha1.c + +# LWIPNOAPPSFILES: All LWIP files without apps +LWIPNOAPPSFILES=$(COREFILES) \ + $(CORE4FILES) \ + $(CORE6FILES) \ + $(APIFILES) \ + $(NETIFFILES) \ + $(PPPFILES) \ + $(SIXLOWPAN) + +# SNMPFILES: SNMPv2c agent +SNMPFILES=$(LWIPDIR)/apps/snmp/snmp_asn1.c \ + $(LWIPDIR)/apps/snmp/snmp_core.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2_icmp.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2_interfaces.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2_ip.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2_snmp.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2_system.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2_tcp.c \ + $(LWIPDIR)/apps/snmp/snmp_mib2_udp.c \ + $(LWIPDIR)/apps/snmp/snmp_snmpv2_framework.c \ + $(LWIPDIR)/apps/snmp/snmp_snmpv2_usm.c \ + $(LWIPDIR)/apps/snmp/snmp_msg.c \ + $(LWIPDIR)/apps/snmp/snmpv3.c \ + $(LWIPDIR)/apps/snmp/snmp_netconn.c \ + $(LWIPDIR)/apps/snmp/snmp_pbuf_stream.c \ + $(LWIPDIR)/apps/snmp/snmp_raw.c \ + $(LWIPDIR)/apps/snmp/snmp_scalar.c \ + $(LWIPDIR)/apps/snmp/snmp_table.c \ + $(LWIPDIR)/apps/snmp/snmp_threadsync.c \ + $(LWIPDIR)/apps/snmp/snmp_traps.c + +# HTTPFILES: HTTP server + client +HTTPFILES=$(LWIPDIR)/apps/http/altcp_proxyconnect.c \ + $(LWIPDIR)/apps/http/fs.c \ + $(LWIPDIR)/apps/http/http_client.c \ + $(LWIPDIR)/apps/http/httpd.c + +# MAKEFSDATA: MAKEFSDATA HTTP server host utility +MAKEFSDATAFILES=$(LWIPDIR)/apps/http/makefsdata/makefsdata.c + +# LWIPERFFILES: IPERF server +LWIPERFFILES=$(LWIPDIR)/apps/lwiperf/lwiperf.c + +# SMTPFILES: SMTP client +SMTPFILES=$(LWIPDIR)/apps/smtp/smtp.c + +# SNTPFILES: SNTP client +SNTPFILES=$(LWIPDIR)/apps/sntp/sntp.c + +# MDNSFILES: MDNS responder +MDNSFILES=$(LWIPDIR)/apps/mdns/mdns.c + +# NETBIOSNSFILES: NetBIOS name server +NETBIOSNSFILES=$(LWIPDIR)/apps/netbiosns/netbiosns.c + +# TFTPFILES: TFTP server files +TFTPFILES=$(LWIPDIR)/apps/tftp/tftp_server.c + +# MQTTFILES: MQTT client files +MQTTFILES=$(LWIPDIR)/apps/mqtt/mqtt.c + +# MBEDTLS_FILES: MBEDTLS related files of lwIP rep +MBEDTLS_FILES=$(LWIPDIR)/apps/altcp_tls/altcp_tls_mbedtls.c \ + $(LWIPDIR)/apps/altcp_tls/altcp_tls_mbedtls_mem.c \ + $(LWIPDIR)/apps/snmp/snmpv3_mbedtls.c + +# LWIPAPPFILES: All LWIP APPs +LWIPAPPFILES=$(SNMPFILES) \ + $(HTTPFILES) \ + $(LWIPERFFILES) \ + $(SMTPFILES) \ + $(SNTPFILES) \ + $(MDNSFILES) \ + $(NETBIOSNSFILES) \ + $(TFTPFILES) \ + $(MQTTFILES) \ + $(MBEDTLS_FILES) diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_lib.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_lib.c index 9a30ec04..a2c136f0 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_lib.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_lib.c @@ -1,1367 +1,1367 @@ -/** - * @file - * Sequential API External module - * - * @defgroup netconn Netconn API - * @ingroup sequential_api - * Thread-safe, to be called from non-TCPIP threads only. - * TX/RX handling based on @ref netbuf (containing @ref pbuf) - * to avoid copying data around. - * - * @defgroup netconn_common Common functions - * @ingroup netconn - * For use with TCP and UDP - * - * @defgroup netconn_tcp TCP only - * @ingroup netconn - * TCP only functions - * - * @defgroup netconn_udp UDP only - * @ingroup netconn - * UDP only functions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - */ - -/* This is the part of the API that is linked with - the application */ - -#include "lwip/opt.h" - -#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/api.h" -#include "lwip/memp.h" - -#include "lwip/ip.h" -#include "lwip/raw.h" -#include "lwip/udp.h" -#include "lwip/priv/api_msg.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/priv/tcpip_priv.h" - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -#include - -#define API_MSG_VAR_REF(name) API_VAR_REF(name) -#define API_MSG_VAR_DECLARE(name) API_VAR_DECLARE(struct api_msg, name) -#define API_MSG_VAR_ALLOC(name) API_VAR_ALLOC(struct api_msg, MEMP_API_MSG, name, ERR_MEM) -#define API_MSG_VAR_ALLOC_RETURN_NULL(name) API_VAR_ALLOC(struct api_msg, MEMP_API_MSG, name, NULL) -#define API_MSG_VAR_FREE(name) API_VAR_FREE(MEMP_API_MSG, name) - -#if TCP_LISTEN_BACKLOG -/* need to allocate API message for accept so empty message pool does not result in event loss - * see bug #47512: MPU_COMPATIBLE may fail on empty pool */ -#define API_MSG_VAR_ALLOC_ACCEPT(msg) API_MSG_VAR_ALLOC(msg) -#define API_MSG_VAR_FREE_ACCEPT(msg) API_MSG_VAR_FREE(msg) -#else /* TCP_LISTEN_BACKLOG */ -#define API_MSG_VAR_ALLOC_ACCEPT(msg) -#define API_MSG_VAR_FREE_ACCEPT(msg) -#endif /* TCP_LISTEN_BACKLOG */ - -#if LWIP_NETCONN_FULLDUPLEX -#define NETCONN_RECVMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->recvmbox) && (((conn)->flags & NETCONN_FLAG_MBOXINVALID) == 0)) -#define NETCONN_ACCEPTMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->acceptmbox) && (((conn)->flags & (NETCONN_FLAG_MBOXCLOSED|NETCONN_FLAG_MBOXINVALID)) == 0)) -#define NETCONN_MBOX_WAITING_INC(conn) SYS_ARCH_INC(conn->mbox_threads_waiting, 1) -#define NETCONN_MBOX_WAITING_DEC(conn) SYS_ARCH_DEC(conn->mbox_threads_waiting, 1) -#else /* LWIP_NETCONN_FULLDUPLEX */ -#define NETCONN_RECVMBOX_WAITABLE(conn) sys_mbox_valid(&(conn)->recvmbox) -#define NETCONN_ACCEPTMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->acceptmbox) && (((conn)->flags & NETCONN_FLAG_MBOXCLOSED) == 0)) -#define NETCONN_MBOX_WAITING_INC(conn) -#define NETCONN_MBOX_WAITING_DEC(conn) -#endif /* LWIP_NETCONN_FULLDUPLEX */ - -static err_t netconn_close_shutdown(struct netconn *conn, u8_t how); - -/** - * Call the lower part of a netconn_* function - * This function is then running in the thread context - * of tcpip_thread and has exclusive access to lwIP core code. - * - * @param fn function to call - * @param apimsg a struct containing the function to call and its parameters - * @return ERR_OK if the function was called, another err_t if not - */ -static err_t -netconn_apimsg(tcpip_callback_fn fn, struct api_msg *apimsg) -{ - err_t err; - -#ifdef LWIP_DEBUG - /* catch functions that don't set err */ - apimsg->err = ERR_VAL; -#endif /* LWIP_DEBUG */ - -#if LWIP_NETCONN_SEM_PER_THREAD - apimsg->op_completed_sem = LWIP_NETCONN_THREAD_SEM_GET(); -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - - err = tcpip_send_msg_wait_sem(fn, apimsg, LWIP_API_MSG_SEM(apimsg)); - if (err == ERR_OK) { - return apimsg->err; - } - return err; -} - -/** - * Create a new netconn (of a specific type) that has a callback function. - * The corresponding pcb is also created. - * - * @param t the type of 'connection' to create (@see enum netconn_type) - * @param proto the IP protocol for RAW IP pcbs - * @param callback a function to call on status changes (RX available, TX'ed) - * @return a newly allocated struct netconn or - * NULL on memory error - */ -struct netconn * -netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback) -{ - struct netconn *conn; - API_MSG_VAR_DECLARE(msg); - API_MSG_VAR_ALLOC_RETURN_NULL(msg); - - conn = netconn_alloc(t, callback); - if (conn != NULL) { - err_t err; - - API_MSG_VAR_REF(msg).msg.n.proto = proto; - API_MSG_VAR_REF(msg).conn = conn; - err = netconn_apimsg(lwip_netconn_do_newconn, &API_MSG_VAR_REF(msg)); - if (err != ERR_OK) { - LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL); - LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox)); -#if LWIP_TCP - LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox)); -#endif /* LWIP_TCP */ -#if !LWIP_NETCONN_SEM_PER_THREAD - LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed)); - sys_sem_free(&conn->op_completed); -#endif /* !LWIP_NETCONN_SEM_PER_THREAD */ - sys_mbox_free(&conn->recvmbox); - memp_free(MEMP_NETCONN, conn); - API_MSG_VAR_FREE(msg); - return NULL; - } - } - API_MSG_VAR_FREE(msg); - return conn; -} - -/** - * @ingroup netconn_common - * Close a netconn 'connection' and free all its resources but not the netconn itself. - * UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate - * after this returns. - * - * @param conn the netconn to delete - * @return ERR_OK if the connection was deleted - */ -err_t -netconn_prepare_delete(struct netconn *conn) -{ - err_t err; - API_MSG_VAR_DECLARE(msg); - - /* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */ - if (conn == NULL) { - return ERR_OK; - } - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; -#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER - /* get the time we started, which is later compared to - sys_now() + conn->send_timeout */ - API_MSG_VAR_REF(msg).msg.sd.time_started = sys_now(); -#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ -#if LWIP_TCP - API_MSG_VAR_REF(msg).msg.sd.polls_left = - ((LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT + TCP_SLOW_INTERVAL - 1) / TCP_SLOW_INTERVAL) + 1; -#endif /* LWIP_TCP */ -#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ - err = netconn_apimsg(lwip_netconn_do_delconn, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - if (err != ERR_OK) { - return err; - } - return ERR_OK; -} - -/** - * @ingroup netconn_common - * Close a netconn 'connection' and free its resources. - * UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate - * after this returns. - * - * @param conn the netconn to delete - * @return ERR_OK if the connection was deleted - */ -err_t -netconn_delete(struct netconn *conn) -{ - err_t err; - - /* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */ - if (conn == NULL) { - return ERR_OK; - } - -#if LWIP_NETCONN_FULLDUPLEX - if (conn->flags & NETCONN_FLAG_MBOXINVALID) { - /* Already called netconn_prepare_delete() before */ - err = ERR_OK; - } else -#endif /* LWIP_NETCONN_FULLDUPLEX */ - { - err = netconn_prepare_delete(conn); - } - if (err == ERR_OK) { - netconn_free(conn); - } - return err; -} - -/** - * Get the local or remote IP address and port of a netconn. - * For RAW netconns, this returns the protocol instead of a port! - * - * @param conn the netconn to query - * @param addr a pointer to which to save the IP address - * @param port a pointer to which to save the port (or protocol for RAW) - * @param local 1 to get the local IP address, 0 to get the remote one - * @return ERR_CONN for invalid connections - * ERR_OK if the information was retrieved - */ -err_t -netconn_getaddr(struct netconn *conn, ip_addr_t *addr, u16_t *port, u8_t local) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_getaddr: invalid conn", (conn != NULL), return ERR_ARG;); - LWIP_ERROR("netconn_getaddr: invalid addr", (addr != NULL), return ERR_ARG;); - LWIP_ERROR("netconn_getaddr: invalid port", (port != NULL), return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.ad.local = local; -#if LWIP_MPU_COMPATIBLE - err = netconn_apimsg(lwip_netconn_do_getaddr, &API_MSG_VAR_REF(msg)); - *addr = msg->msg.ad.ipaddr; - *port = msg->msg.ad.port; -#else /* LWIP_MPU_COMPATIBLE */ - msg.msg.ad.ipaddr = addr; - msg.msg.ad.port = port; - err = netconn_apimsg(lwip_netconn_do_getaddr, &msg); -#endif /* LWIP_MPU_COMPATIBLE */ - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_common - * Bind a netconn to a specific local IP address and port. - * Binding one netconn twice might not always be checked correctly! - * - * @param conn the netconn to bind - * @param addr the local IP address to bind the netconn to - * (use IP4_ADDR_ANY/IP6_ADDR_ANY to bind to all addresses) - * @param port the local port to bind the netconn to (not used for RAW) - * @return ERR_OK if bound, any other err_t on failure - */ -err_t -netconn_bind(struct netconn *conn, const ip_addr_t *addr, u16_t port) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_bind: invalid conn", (conn != NULL), return ERR_ARG;); - -#if LWIP_IPV4 - /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ - if (addr == NULL) { - addr = IP4_ADDR_ANY; - } -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV4 && LWIP_IPV6 - /* "Socket API like" dual-stack support: If IP to bind to is IP6_ADDR_ANY, - * and NETCONN_FLAG_IPV6_V6ONLY is 0, use IP_ANY_TYPE to bind - */ - if ((netconn_get_ipv6only(conn) == 0) && - ip_addr_cmp(addr, IP6_ADDR_ANY)) { - addr = IP_ANY_TYPE; - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.bc.ipaddr = API_MSG_VAR_REF(addr); - API_MSG_VAR_REF(msg).msg.bc.port = port; - err = netconn_apimsg(lwip_netconn_do_bind, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_common - * Bind a netconn to a specific interface and port. - * Binding one netconn twice might not always be checked correctly! - * - * @param conn the netconn to bind - * @param if_idx the local interface index to bind the netconn to - * @return ERR_OK if bound, any other err_t on failure - */ -err_t -netconn_bind_if(struct netconn *conn, u8_t if_idx) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_bind_if: invalid conn", (conn != NULL), return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.bc.if_idx = if_idx; - err = netconn_apimsg(lwip_netconn_do_bind_if, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_common - * Connect a netconn to a specific remote IP address and port. - * - * @param conn the netconn to connect - * @param addr the remote IP address to connect to - * @param port the remote port to connect to (no used for RAW) - * @return ERR_OK if connected, return value of tcp_/udp_/raw_connect otherwise - */ -err_t -netconn_connect(struct netconn *conn, const ip_addr_t *addr, u16_t port) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_connect: invalid conn", (conn != NULL), return ERR_ARG;); - -#if LWIP_IPV4 - /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ - if (addr == NULL) { - addr = IP4_ADDR_ANY; - } -#endif /* LWIP_IPV4 */ - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.bc.ipaddr = API_MSG_VAR_REF(addr); - API_MSG_VAR_REF(msg).msg.bc.port = port; - err = netconn_apimsg(lwip_netconn_do_connect, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_udp - * Disconnect a netconn from its current peer (only valid for UDP netconns). - * - * @param conn the netconn to disconnect - * @return See @ref err_t - */ -err_t -netconn_disconnect(struct netconn *conn) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_disconnect: invalid conn", (conn != NULL), return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; - err = netconn_apimsg(lwip_netconn_do_disconnect, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_tcp - * Set a TCP netconn into listen mode - * - * @param conn the tcp netconn to set to listen mode - * @param backlog the listen backlog, only used if TCP_LISTEN_BACKLOG==1 - * @return ERR_OK if the netconn was set to listen (UDP and RAW netconns - * don't return any error (yet?)) - */ -err_t -netconn_listen_with_backlog(struct netconn *conn, u8_t backlog) -{ -#if LWIP_TCP - API_MSG_VAR_DECLARE(msg); - err_t err; - - /* This does no harm. If TCP_LISTEN_BACKLOG is off, backlog is unused. */ - LWIP_UNUSED_ARG(backlog); - - LWIP_ERROR("netconn_listen: invalid conn", (conn != NULL), return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; -#if TCP_LISTEN_BACKLOG - API_MSG_VAR_REF(msg).msg.lb.backlog = backlog; -#endif /* TCP_LISTEN_BACKLOG */ - err = netconn_apimsg(lwip_netconn_do_listen, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -#else /* LWIP_TCP */ - LWIP_UNUSED_ARG(conn); - LWIP_UNUSED_ARG(backlog); - return ERR_ARG; -#endif /* LWIP_TCP */ -} - -/** - * @ingroup netconn_tcp - * Accept a new connection on a TCP listening netconn. - * - * @param conn the TCP listen netconn - * @param new_conn pointer where the new connection is stored - * @return ERR_OK if a new connection has been received or an error - * code otherwise - */ -err_t -netconn_accept(struct netconn *conn, struct netconn **new_conn) -{ -#if LWIP_TCP - err_t err; - void *accept_ptr; - struct netconn *newconn; -#if TCP_LISTEN_BACKLOG - API_MSG_VAR_DECLARE(msg); -#endif /* TCP_LISTEN_BACKLOG */ - - LWIP_ERROR("netconn_accept: invalid pointer", (new_conn != NULL), return ERR_ARG;); - *new_conn = NULL; - LWIP_ERROR("netconn_accept: invalid conn", (conn != NULL), return ERR_ARG;); - - /* NOTE: Although the opengroup spec says a pending error shall be returned to - send/recv/getsockopt(SO_ERROR) only, we return it for listening - connections also, to handle embedded-system errors */ - err = netconn_err(conn); - if (err != ERR_OK) { - /* return pending error */ - return err; - } - if (!NETCONN_ACCEPTMBOX_WAITABLE(conn)) { - /* don't accept if closed: this might block the application task - waiting on acceptmbox forever! */ - return ERR_CLSD; - } - - API_MSG_VAR_ALLOC_ACCEPT(msg); - - NETCONN_MBOX_WAITING_INC(conn); - if (netconn_is_nonblocking(conn)) { - if (sys_arch_mbox_tryfetch(&conn->acceptmbox, &accept_ptr) == SYS_ARCH_TIMEOUT) { - API_MSG_VAR_FREE_ACCEPT(msg); - NETCONN_MBOX_WAITING_DEC(conn); - return ERR_WOULDBLOCK; - } - } else { -#if LWIP_SO_RCVTIMEO - if (sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, conn->recv_timeout) == SYS_ARCH_TIMEOUT) { - API_MSG_VAR_FREE_ACCEPT(msg); - NETCONN_MBOX_WAITING_DEC(conn); - return ERR_TIMEOUT; - } -#else - sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, 0); -#endif /* LWIP_SO_RCVTIMEO*/ - } - NETCONN_MBOX_WAITING_DEC(conn); -#if LWIP_NETCONN_FULLDUPLEX - if (conn->flags & NETCONN_FLAG_MBOXINVALID) { - if (lwip_netconn_is_deallocated_msg(accept_ptr)) { - /* the netconn has been closed from another thread */ - API_MSG_VAR_FREE_ACCEPT(msg); - return ERR_CONN; - } - } -#endif - - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0); - - if (lwip_netconn_is_err_msg(accept_ptr, &err)) { - /* a connection has been aborted: e.g. out of pcbs or out of netconns during accept */ - API_MSG_VAR_FREE_ACCEPT(msg); - return err; - } - if (accept_ptr == NULL) { - /* connection has been aborted */ - API_MSG_VAR_FREE_ACCEPT(msg); - return ERR_CLSD; - } - newconn = (struct netconn *)accept_ptr; -#if TCP_LISTEN_BACKLOG - /* Let the stack know that we have accepted the connection. */ - API_MSG_VAR_REF(msg).conn = newconn; - /* don't care for the return value of lwip_netconn_do_recv */ - netconn_apimsg(lwip_netconn_do_accepted, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); -#endif /* TCP_LISTEN_BACKLOG */ - - *new_conn = newconn; - /* don't set conn->last_err: it's only ERR_OK, anyway */ - return ERR_OK; -#else /* LWIP_TCP */ - LWIP_UNUSED_ARG(conn); - LWIP_UNUSED_ARG(new_conn); - return ERR_ARG; -#endif /* LWIP_TCP */ -} - -/** - * @ingroup netconn_common - * Receive data: actual implementation that doesn't care whether pbuf or netbuf - * is received (this is internal, it's just here for describing common errors) - * - * @param conn the netconn from which to receive data - * @param new_buf pointer where a new pbuf/netbuf is stored when received data - * @param apiflags flags that control function behaviour. For now only: - * - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data - * @return ERR_OK if data has been received, an error code otherwise (timeout, - * memory error or another error) - * ERR_CONN if not connected - * ERR_CLSD if TCP connection has been closed - * ERR_WOULDBLOCK if the netconn is nonblocking but would block to wait for data - * ERR_TIMEOUT if the netconn has a receive timeout and no data was received - */ -static err_t -netconn_recv_data(struct netconn *conn, void **new_buf, u8_t apiflags) -{ - void *buf = NULL; - u16_t len; - - LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;); - *new_buf = NULL; - LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;); - - if (!NETCONN_RECVMBOX_WAITABLE(conn)) { - err_t err = netconn_err(conn); - if (err != ERR_OK) { - /* return pending error */ - return err; - } - return ERR_CONN; - } - - NETCONN_MBOX_WAITING_INC(conn); - if (netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK) || - (conn->flags & NETCONN_FLAG_MBOXCLOSED) || (conn->pending_err != ERR_OK)) { - if (sys_arch_mbox_tryfetch(&conn->recvmbox, &buf) == SYS_ARCH_TIMEOUT) { - err_t err; - NETCONN_MBOX_WAITING_DEC(conn); - err = netconn_err(conn); - if (err != ERR_OK) { - /* return pending error */ - return err; - } - if (conn->flags & NETCONN_FLAG_MBOXCLOSED) { - return ERR_CONN; - } - return ERR_WOULDBLOCK; - } - } else { -#if LWIP_SO_RCVTIMEO - if (sys_arch_mbox_fetch(&conn->recvmbox, &buf, conn->recv_timeout) == SYS_ARCH_TIMEOUT) { - NETCONN_MBOX_WAITING_DEC(conn); - return ERR_TIMEOUT; - } -#else - sys_arch_mbox_fetch(&conn->recvmbox, &buf, 0); -#endif /* LWIP_SO_RCVTIMEO*/ - } - NETCONN_MBOX_WAITING_DEC(conn); -#if LWIP_NETCONN_FULLDUPLEX - if (conn->flags & NETCONN_FLAG_MBOXINVALID) { - if (lwip_netconn_is_deallocated_msg(buf)) { - /* the netconn has been closed from another thread */ - API_MSG_VAR_FREE_ACCEPT(msg); - return ERR_CONN; - } - } -#endif - -#if LWIP_TCP -#if (LWIP_UDP || LWIP_RAW) - if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) -#endif /* (LWIP_UDP || LWIP_RAW) */ - { - err_t err; - /* Check if this is an error message or a pbuf */ - if (lwip_netconn_is_err_msg(buf, &err)) { - /* new_buf has been zeroed above already */ - if (err == ERR_CLSD) { - /* connection closed translates to ERR_OK with *new_buf == NULL */ - return ERR_OK; - } - return err; - } - len = ((struct pbuf *)buf)->tot_len; - } -#endif /* LWIP_TCP */ -#if LWIP_TCP && (LWIP_UDP || LWIP_RAW) - else -#endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */ -#if (LWIP_UDP || LWIP_RAW) - { - LWIP_ASSERT("buf != NULL", buf != NULL); - len = netbuf_len((struct netbuf *)buf); - } -#endif /* (LWIP_UDP || LWIP_RAW) */ - -#if LWIP_SO_RCVBUF - SYS_ARCH_DEC(conn->recv_avail, len); -#endif /* LWIP_SO_RCVBUF */ - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVMINUS, len); - - LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv_data: received %p, len=%"U16_F"\n", buf, len)); - - *new_buf = buf; - /* don't set conn->last_err: it's only ERR_OK, anyway */ - return ERR_OK; -} - -#if LWIP_TCP -static err_t -netconn_tcp_recvd_msg(struct netconn *conn, size_t len, struct api_msg *msg) -{ - LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && - NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); - - msg->conn = conn; - msg->msg.r.len = len; - - return netconn_apimsg(lwip_netconn_do_recv, msg); -} - -err_t -netconn_tcp_recvd(struct netconn *conn, size_t len) -{ - err_t err; - API_MSG_VAR_DECLARE(msg); - LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && - NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - err = netconn_tcp_recvd_msg(conn, len, &API_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - return err; -} - -static err_t -netconn_recv_data_tcp(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags) -{ - err_t err; - struct pbuf *buf; - API_MSG_VAR_DECLARE(msg); -#if LWIP_MPU_COMPATIBLE - msg = NULL; -#endif - - if (!NETCONN_RECVMBOX_WAITABLE(conn)) { - /* This only happens when calling this function more than once *after* receiving FIN */ - return ERR_CONN; - } - if (netconn_is_flag_set(conn, NETCONN_FIN_RX_PENDING)) { - netconn_clear_flags(conn, NETCONN_FIN_RX_PENDING); - goto handle_fin; - } - - if (!(apiflags & NETCONN_NOAUTORCVD)) { - /* need to allocate API message here so empty message pool does not result in event loss - * see bug #47512: MPU_COMPATIBLE may fail on empty pool */ - API_MSG_VAR_ALLOC(msg); - } - - err = netconn_recv_data(conn, (void **)new_buf, apiflags); - if (err != ERR_OK) { - if (!(apiflags & NETCONN_NOAUTORCVD)) { - API_MSG_VAR_FREE(msg); - } - return err; - } - buf = *new_buf; - if (!(apiflags & NETCONN_NOAUTORCVD)) { - /* Let the stack know that we have taken the data. */ - u16_t len = buf ? buf->tot_len : 1; - /* don't care for the return value of lwip_netconn_do_recv */ - /* @todo: this should really be fixed, e.g. by retrying in poll on error */ - netconn_tcp_recvd_msg(conn, len, &API_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - } - - /* If we are closed, we indicate that we no longer wish to use the socket */ - if (buf == NULL) { - if (apiflags & NETCONN_NOFIN) { - /* received a FIN but the caller cannot handle it right now: - re-enqueue it and return "no data" */ - netconn_set_flags(conn, NETCONN_FIN_RX_PENDING); - return ERR_WOULDBLOCK; - } else { -handle_fin: - API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0); - if (conn->pcb.ip == NULL) { - /* race condition: RST during recv */ - err = netconn_err(conn); - if (err != ERR_OK) { - return err; - } - return ERR_RST; - } - /* RX side is closed, so deallocate the recvmbox */ - netconn_close_shutdown(conn, NETCONN_SHUT_RD); - /* Don' store ERR_CLSD as conn->err since we are only half-closed */ - return ERR_CLSD; - } - } - return err; -} - -/** - * @ingroup netconn_tcp - * Receive data (in form of a pbuf) from a TCP netconn - * - * @param conn the netconn from which to receive data - * @param new_buf pointer where a new pbuf is stored when received data - * @return ERR_OK if data has been received, an error code otherwise (timeout, - * memory error or another error, @see netconn_recv_data) - * ERR_ARG if conn is not a TCP netconn - */ -err_t -netconn_recv_tcp_pbuf(struct netconn *conn, struct pbuf **new_buf) -{ - LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && - NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); - - return netconn_recv_data_tcp(conn, new_buf, 0); -} - -/** - * @ingroup netconn_tcp - * Receive data (in form of a pbuf) from a TCP netconn - * - * @param conn the netconn from which to receive data - * @param new_buf pointer where a new pbuf is stored when received data - * @param apiflags flags that control function behaviour. For now only: - * - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data - * @return ERR_OK if data has been received, an error code otherwise (timeout, - * memory error or another error, @see netconn_recv_data) - * ERR_ARG if conn is not a TCP netconn - */ -err_t -netconn_recv_tcp_pbuf_flags(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags) -{ - LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && - NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); - - return netconn_recv_data_tcp(conn, new_buf, apiflags); -} -#endif /* LWIP_TCP */ - -/** - * Receive data (in form of a netbuf) from a UDP or RAW netconn - * - * @param conn the netconn from which to receive data - * @param new_buf pointer where a new netbuf is stored when received data - * @return ERR_OK if data has been received, an error code otherwise (timeout, - * memory error or another error) - * ERR_ARG if conn is not a UDP/RAW netconn - */ -err_t -netconn_recv_udp_raw_netbuf(struct netconn *conn, struct netbuf **new_buf) -{ - LWIP_ERROR("netconn_recv_udp_raw_netbuf: invalid conn", (conn != NULL) && - NETCONNTYPE_GROUP(netconn_type(conn)) != NETCONN_TCP, return ERR_ARG;); - - return netconn_recv_data(conn, (void **)new_buf, 0); -} - -/** - * Receive data (in form of a netbuf) from a UDP or RAW netconn - * - * @param conn the netconn from which to receive data - * @param new_buf pointer where a new netbuf is stored when received data - * @param apiflags flags that control function behaviour. For now only: - * - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data - * @return ERR_OK if data has been received, an error code otherwise (timeout, - * memory error or another error) - * ERR_ARG if conn is not a UDP/RAW netconn - */ -err_t -netconn_recv_udp_raw_netbuf_flags(struct netconn *conn, struct netbuf **new_buf, u8_t apiflags) -{ - LWIP_ERROR("netconn_recv_udp_raw_netbuf: invalid conn", (conn != NULL) && - NETCONNTYPE_GROUP(netconn_type(conn)) != NETCONN_TCP, return ERR_ARG;); - - return netconn_recv_data(conn, (void **)new_buf, apiflags); -} - -/** - * @ingroup netconn_common - * Receive data (in form of a netbuf containing a packet buffer) from a netconn - * - * @param conn the netconn from which to receive data - * @param new_buf pointer where a new netbuf is stored when received data - * @return ERR_OK if data has been received, an error code otherwise (timeout, - * memory error or another error) - */ -err_t -netconn_recv(struct netconn *conn, struct netbuf **new_buf) -{ -#if LWIP_TCP - struct netbuf *buf = NULL; - err_t err; -#endif /* LWIP_TCP */ - - LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;); - *new_buf = NULL; - LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;); - -#if LWIP_TCP -#if (LWIP_UDP || LWIP_RAW) - if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) -#endif /* (LWIP_UDP || LWIP_RAW) */ - { - struct pbuf *p = NULL; - /* This is not a listening netconn, since recvmbox is set */ - - buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); - if (buf == NULL) { - return ERR_MEM; - } - - err = netconn_recv_data_tcp(conn, &p, 0); - if (err != ERR_OK) { - memp_free(MEMP_NETBUF, buf); - return err; - } - LWIP_ASSERT("p != NULL", p != NULL); - - buf->p = p; - buf->ptr = p; - buf->port = 0; - ip_addr_set_zero(&buf->addr); - *new_buf = buf; - /* don't set conn->last_err: it's only ERR_OK, anyway */ - return ERR_OK; - } -#endif /* LWIP_TCP */ -#if LWIP_TCP && (LWIP_UDP || LWIP_RAW) - else -#endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */ - { -#if (LWIP_UDP || LWIP_RAW) - return netconn_recv_data(conn, (void **)new_buf, 0); -#endif /* (LWIP_UDP || LWIP_RAW) */ - } -} - -/** - * @ingroup netconn_udp - * Send data (in form of a netbuf) to a specific remote IP address and port. - * Only to be used for UDP and RAW netconns (not TCP). - * - * @param conn the netconn over which to send data - * @param buf a netbuf containing the data to send - * @param addr the remote IP address to which to send the data - * @param port the remote port to which to send the data - * @return ERR_OK if data was sent, any other err_t on error - */ -err_t -netconn_sendto(struct netconn *conn, struct netbuf *buf, const ip_addr_t *addr, u16_t port) -{ - if (buf != NULL) { - ip_addr_set(&buf->addr, addr); - buf->port = port; - return netconn_send(conn, buf); - } - return ERR_VAL; -} - -/** - * @ingroup netconn_udp - * Send data over a UDP or RAW netconn (that is already connected). - * - * @param conn the UDP or RAW netconn over which to send data - * @param buf a netbuf containing the data to send - * @return ERR_OK if data was sent, any other err_t on error - */ -err_t -netconn_send(struct netconn *conn, struct netbuf *buf) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_send: invalid conn", (conn != NULL), return ERR_ARG;); - - LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %"U16_F" bytes\n", buf->p->tot_len)); - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.b = buf; - err = netconn_apimsg(lwip_netconn_do_send, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_tcp - * Send data over a TCP netconn. - * - * @param conn the TCP netconn over which to send data - * @param dataptr pointer to the application buffer that contains the data to send - * @param size size of the application data to send - * @param apiflags combination of following flags : - * - NETCONN_COPY: data will be copied into memory belonging to the stack - * - NETCONN_MORE: for TCP connection, PSH flag will be set on last segment sent - * - NETCONN_DONTBLOCK: only write the data if all data can be written at once - * @param bytes_written pointer to a location that receives the number of written bytes - * @return ERR_OK if data was sent, any other err_t on error - */ -err_t -netconn_write_partly(struct netconn *conn, const void *dataptr, size_t size, - u8_t apiflags, size_t *bytes_written) -{ - struct netvector vector; - vector.ptr = dataptr; - vector.len = size; - return netconn_write_vectors_partly(conn, &vector, 1, apiflags, bytes_written); -} - -/** - * Send vectorized data atomically over a TCP netconn. - * - * @param conn the TCP netconn over which to send data - * @param vectors array of vectors containing data to send - * @param vectorcnt number of vectors in the array - * @param apiflags combination of following flags : - * - NETCONN_COPY: data will be copied into memory belonging to the stack - * - NETCONN_MORE: for TCP connection, PSH flag will be set on last segment sent - * - NETCONN_DONTBLOCK: only write the data if all data can be written at once - * @param bytes_written pointer to a location that receives the number of written bytes - * @return ERR_OK if data was sent, any other err_t on error - */ -err_t -netconn_write_vectors_partly(struct netconn *conn, struct netvector *vectors, u16_t vectorcnt, - u8_t apiflags, size_t *bytes_written) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - u8_t dontblock; - size_t size; - int i; - - LWIP_ERROR("netconn_write: invalid conn", (conn != NULL), return ERR_ARG;); - LWIP_ERROR("netconn_write: invalid conn->type", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP), return ERR_VAL;); - dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK); -#if LWIP_SO_SNDTIMEO - if (conn->send_timeout != 0) { - dontblock = 1; - } -#endif /* LWIP_SO_SNDTIMEO */ - if (dontblock && !bytes_written) { - /* This implies netconn_write() cannot be used for non-blocking send, since - it has no way to return the number of bytes written. */ - return ERR_VAL; - } - - /* sum up the total size */ - size = 0; - for (i = 0; i < vectorcnt; i++) { - size += vectors[i].len; - if (size < vectors[i].len) { - /* overflow */ - return ERR_VAL; - } - } - if (size == 0) { - return ERR_OK; - } else if (size > SSIZE_MAX) { - ssize_t limited; - /* this is required by the socket layer (cannot send full size_t range) */ - if (!bytes_written) { - return ERR_VAL; - } - /* limit the amount of data to send */ - limited = SSIZE_MAX; - size = (size_t)limited; - } - - API_MSG_VAR_ALLOC(msg); - /* non-blocking write sends as much */ - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.w.vector = vectors; - API_MSG_VAR_REF(msg).msg.w.vector_cnt = vectorcnt; - API_MSG_VAR_REF(msg).msg.w.vector_off = 0; - API_MSG_VAR_REF(msg).msg.w.apiflags = apiflags; - API_MSG_VAR_REF(msg).msg.w.len = size; - API_MSG_VAR_REF(msg).msg.w.offset = 0; -#if LWIP_SO_SNDTIMEO - if (conn->send_timeout != 0) { - /* get the time we started, which is later compared to - sys_now() + conn->send_timeout */ - API_MSG_VAR_REF(msg).msg.w.time_started = sys_now(); - } else { - API_MSG_VAR_REF(msg).msg.w.time_started = 0; - } -#endif /* LWIP_SO_SNDTIMEO */ - - /* For locking the core: this _can_ be delayed on low memory/low send buffer, - but if it is, this is done inside api_msg.c:do_write(), so we can use the - non-blocking version here. */ - err = netconn_apimsg(lwip_netconn_do_write, &API_MSG_VAR_REF(msg)); - if (err == ERR_OK) { - if (bytes_written != NULL) { - *bytes_written = API_MSG_VAR_REF(msg).msg.w.offset; - } - /* for blocking, check all requested bytes were written, NOTE: send_timeout is - treated as dontblock (see dontblock assignment above) */ - if (!dontblock) { - LWIP_ASSERT("do_write failed to write all bytes", API_MSG_VAR_REF(msg).msg.w.offset == size); - } - } - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_tcp - * Close or shutdown a TCP netconn (doesn't delete it). - * - * @param conn the TCP netconn to close or shutdown - * @param how fully close or only shutdown one side? - * @return ERR_OK if the netconn was closed, any other err_t on error - */ -static err_t -netconn_close_shutdown(struct netconn *conn, u8_t how) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - LWIP_UNUSED_ARG(how); - - LWIP_ERROR("netconn_close: invalid conn", (conn != NULL), return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - API_MSG_VAR_REF(msg).conn = conn; -#if LWIP_TCP - /* shutting down both ends is the same as closing */ - API_MSG_VAR_REF(msg).msg.sd.shut = how; -#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER - /* get the time we started, which is later compared to - sys_now() + conn->send_timeout */ - API_MSG_VAR_REF(msg).msg.sd.time_started = sys_now(); -#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ - API_MSG_VAR_REF(msg).msg.sd.polls_left = - ((LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT + TCP_SLOW_INTERVAL - 1) / TCP_SLOW_INTERVAL) + 1; -#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ -#endif /* LWIP_TCP */ - err = netconn_apimsg(lwip_netconn_do_close, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} - -/** - * @ingroup netconn_tcp - * Close a TCP netconn (doesn't delete it). - * - * @param conn the TCP netconn to close - * @return ERR_OK if the netconn was closed, any other err_t on error - */ -err_t -netconn_close(struct netconn *conn) -{ - /* shutting down both ends is the same as closing */ - return netconn_close_shutdown(conn, NETCONN_SHUT_RDWR); -} - -/** - * @ingroup netconn_common - * Get and reset pending error on a netconn - * - * @param conn the netconn to get the error from - * @return and pending error or ERR_OK if no error was pending - */ -err_t -netconn_err(struct netconn *conn) -{ - err_t err; - SYS_ARCH_DECL_PROTECT(lev); - if (conn == NULL) { - return ERR_OK; - } - SYS_ARCH_PROTECT(lev); - err = conn->pending_err; - conn->pending_err = ERR_OK; - SYS_ARCH_UNPROTECT(lev); - return err; -} - -/** - * @ingroup netconn_tcp - * Shut down one or both sides of a TCP netconn (doesn't delete it). - * - * @param conn the TCP netconn to shut down - * @param shut_rx shut down the RX side (no more read possible after this) - * @param shut_tx shut down the TX side (no more write possible after this) - * @return ERR_OK if the netconn was closed, any other err_t on error - */ -err_t -netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx) -{ - return netconn_close_shutdown(conn, (u8_t)((shut_rx ? NETCONN_SHUT_RD : 0) | (shut_tx ? NETCONN_SHUT_WR : 0))); -} - -#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) -/** - * @ingroup netconn_udp - * Join multicast groups for UDP netconns. - * - * @param conn the UDP netconn for which to change multicast addresses - * @param multiaddr IP address of the multicast group to join or leave - * @param netif_addr the IP address of the network interface on which to send - * the igmp message - * @param join_or_leave flag whether to send a join- or leave-message - * @return ERR_OK if the action was taken, any err_t on error - */ -err_t -netconn_join_leave_group(struct netconn *conn, - const ip_addr_t *multiaddr, - const ip_addr_t *netif_addr, - enum netconn_igmp join_or_leave) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - -#if LWIP_IPV4 - /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ - if (multiaddr == NULL) { - multiaddr = IP4_ADDR_ANY; - } - if (netif_addr == NULL) { - netif_addr = IP4_ADDR_ANY; - } -#endif /* LWIP_IPV4 */ - - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.jl.multiaddr = API_MSG_VAR_REF(multiaddr); - API_MSG_VAR_REF(msg).msg.jl.netif_addr = API_MSG_VAR_REF(netif_addr); - API_MSG_VAR_REF(msg).msg.jl.join_or_leave = join_or_leave; - err = netconn_apimsg(lwip_netconn_do_join_leave_group, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} -/** - * @ingroup netconn_udp - * Join multicast groups for UDP netconns. - * - * @param conn the UDP netconn for which to change multicast addresses - * @param multiaddr IP address of the multicast group to join or leave - * @param if_idx the index of the netif - * @param join_or_leave flag whether to send a join- or leave-message - * @return ERR_OK if the action was taken, any err_t on error - */ -err_t -netconn_join_leave_group_netif(struct netconn *conn, - const ip_addr_t *multiaddr, - u8_t if_idx, - enum netconn_igmp join_or_leave) -{ - API_MSG_VAR_DECLARE(msg); - err_t err; - - LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;); - - API_MSG_VAR_ALLOC(msg); - -#if LWIP_IPV4 - /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ - if (multiaddr == NULL) { - multiaddr = IP4_ADDR_ANY; - } - if (if_idx == NETIF_NO_INDEX) { - return ERR_IF; - } -#endif /* LWIP_IPV4 */ - - API_MSG_VAR_REF(msg).conn = conn; - API_MSG_VAR_REF(msg).msg.jl.multiaddr = API_MSG_VAR_REF(multiaddr); - API_MSG_VAR_REF(msg).msg.jl.if_idx = if_idx; - API_MSG_VAR_REF(msg).msg.jl.join_or_leave = join_or_leave; - err = netconn_apimsg(lwip_netconn_do_join_leave_group_netif, &API_MSG_VAR_REF(msg)); - API_MSG_VAR_FREE(msg); - - return err; -} -#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ - -#if LWIP_DNS -/** - * @ingroup netconn_common - * Execute a DNS query, only one IP address is returned - * - * @param name a string representation of the DNS host name to query - * @param addr a preallocated ip_addr_t where to store the resolved IP address - * @param dns_addrtype IP address type (IPv4 / IPv6) - * @return ERR_OK: resolving succeeded - * ERR_MEM: memory error, try again later - * ERR_ARG: dns client not initialized or invalid hostname - * ERR_VAL: dns server response was invalid - */ -#if LWIP_IPV4 && LWIP_IPV6 -err_t -netconn_gethostbyname_addrtype(const char *name, ip_addr_t *addr, u8_t dns_addrtype) -#else -err_t -netconn_gethostbyname(const char *name, ip_addr_t *addr) -#endif -{ - API_VAR_DECLARE(struct dns_api_msg, msg); -#if !LWIP_MPU_COMPATIBLE - sys_sem_t sem; -#endif /* LWIP_MPU_COMPATIBLE */ - err_t err; - err_t cberr; - - LWIP_ERROR("netconn_gethostbyname: invalid name", (name != NULL), return ERR_ARG;); - LWIP_ERROR("netconn_gethostbyname: invalid addr", (addr != NULL), return ERR_ARG;); -#if LWIP_MPU_COMPATIBLE - if (strlen(name) >= DNS_MAX_NAME_LENGTH) { - return ERR_ARG; - } -#endif - -#ifdef LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE -#if LWIP_IPV4 && LWIP_IPV6 - if (LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, dns_addrtype, &err)) { -#else - if (LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, NETCONN_DNS_DEFAULT, &err)) { -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - return err; - } -#endif /* LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE */ - - API_VAR_ALLOC(struct dns_api_msg, MEMP_DNS_API_MSG, msg, ERR_MEM); -#if LWIP_MPU_COMPATIBLE - strncpy(API_VAR_REF(msg).name, name, DNS_MAX_NAME_LENGTH - 1); - API_VAR_REF(msg).name[DNS_MAX_NAME_LENGTH - 1] = 0; -#else /* LWIP_MPU_COMPATIBLE */ - msg.err = &err; - msg.sem = &sem; - API_VAR_REF(msg).addr = API_VAR_REF(addr); - API_VAR_REF(msg).name = name; -#endif /* LWIP_MPU_COMPATIBLE */ -#if LWIP_IPV4 && LWIP_IPV6 - API_VAR_REF(msg).dns_addrtype = dns_addrtype; -#endif /* LWIP_IPV4 && LWIP_IPV6 */ -#if LWIP_NETCONN_SEM_PER_THREAD - API_VAR_REF(msg).sem = LWIP_NETCONN_THREAD_SEM_GET(); -#else /* LWIP_NETCONN_SEM_PER_THREAD*/ - err = sys_sem_new(API_EXPR_REF(API_VAR_REF(msg).sem), 0); - if (err != ERR_OK) { - API_VAR_FREE(MEMP_DNS_API_MSG, msg); - return err; - } -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - - cberr = tcpip_send_msg_wait_sem(lwip_netconn_do_gethostbyname, &API_VAR_REF(msg), API_EXPR_REF(API_VAR_REF(msg).sem)); -#if !LWIP_NETCONN_SEM_PER_THREAD - sys_sem_free(API_EXPR_REF(API_VAR_REF(msg).sem)); -#endif /* !LWIP_NETCONN_SEM_PER_THREAD */ - if (cberr != ERR_OK) { - API_VAR_FREE(MEMP_DNS_API_MSG, msg); - return cberr; - } - -#if LWIP_MPU_COMPATIBLE - *addr = msg->addr; - err = msg->err; -#endif /* LWIP_MPU_COMPATIBLE */ - - API_VAR_FREE(MEMP_DNS_API_MSG, msg); - return err; -} -#endif /* LWIP_DNS*/ - -#if LWIP_NETCONN_SEM_PER_THREAD -void -netconn_thread_init(void) -{ - sys_sem_t *sem = LWIP_NETCONN_THREAD_SEM_GET(); - if ((sem == NULL) || !sys_sem_valid(sem)) { - /* call alloc only once */ - LWIP_NETCONN_THREAD_SEM_ALLOC(); - LWIP_ASSERT("LWIP_NETCONN_THREAD_SEM_ALLOC() failed", sys_sem_valid(LWIP_NETCONN_THREAD_SEM_GET())); - } -} - -void -netconn_thread_cleanup(void) -{ - sys_sem_t *sem = LWIP_NETCONN_THREAD_SEM_GET(); - if ((sem != NULL) && sys_sem_valid(sem)) { - /* call free only once */ - LWIP_NETCONN_THREAD_SEM_FREE(); - } -} -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - -#endif /* LWIP_NETCONN */ +/** + * @file + * Sequential API External module + * + * @defgroup netconn Netconn API + * @ingroup sequential_api + * Thread-safe, to be called from non-TCPIP threads only. + * TX/RX handling based on @ref netbuf (containing @ref pbuf) + * to avoid copying data around. + * + * @defgroup netconn_common Common functions + * @ingroup netconn + * For use with TCP and UDP + * + * @defgroup netconn_tcp TCP only + * @ingroup netconn + * TCP only functions + * + * @defgroup netconn_udp UDP only + * @ingroup netconn + * UDP only functions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + */ + +/* This is the part of the API that is linked with + the application */ + +#include "lwip/opt.h" + +#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/api.h" +#include "lwip/memp.h" + +#include "lwip/ip.h" +#include "lwip/raw.h" +#include "lwip/udp.h" +#include "lwip/priv/api_msg.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/priv/tcpip_priv.h" + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +#include + +#define API_MSG_VAR_REF(name) API_VAR_REF(name) +#define API_MSG_VAR_DECLARE(name) API_VAR_DECLARE(struct api_msg, name) +#define API_MSG_VAR_ALLOC(name) API_VAR_ALLOC(struct api_msg, MEMP_API_MSG, name, ERR_MEM) +#define API_MSG_VAR_ALLOC_RETURN_NULL(name) API_VAR_ALLOC(struct api_msg, MEMP_API_MSG, name, NULL) +#define API_MSG_VAR_FREE(name) API_VAR_FREE(MEMP_API_MSG, name) + +#if TCP_LISTEN_BACKLOG +/* need to allocate API message for accept so empty message pool does not result in event loss + * see bug #47512: MPU_COMPATIBLE may fail on empty pool */ +#define API_MSG_VAR_ALLOC_ACCEPT(msg) API_MSG_VAR_ALLOC(msg) +#define API_MSG_VAR_FREE_ACCEPT(msg) API_MSG_VAR_FREE(msg) +#else /* TCP_LISTEN_BACKLOG */ +#define API_MSG_VAR_ALLOC_ACCEPT(msg) +#define API_MSG_VAR_FREE_ACCEPT(msg) +#endif /* TCP_LISTEN_BACKLOG */ + +#if LWIP_NETCONN_FULLDUPLEX +#define NETCONN_RECVMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->recvmbox) && (((conn)->flags & NETCONN_FLAG_MBOXINVALID) == 0)) +#define NETCONN_ACCEPTMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->acceptmbox) && (((conn)->flags & (NETCONN_FLAG_MBOXCLOSED|NETCONN_FLAG_MBOXINVALID)) == 0)) +#define NETCONN_MBOX_WAITING_INC(conn) SYS_ARCH_INC(conn->mbox_threads_waiting, 1) +#define NETCONN_MBOX_WAITING_DEC(conn) SYS_ARCH_DEC(conn->mbox_threads_waiting, 1) +#else /* LWIP_NETCONN_FULLDUPLEX */ +#define NETCONN_RECVMBOX_WAITABLE(conn) sys_mbox_valid(&(conn)->recvmbox) +#define NETCONN_ACCEPTMBOX_WAITABLE(conn) (sys_mbox_valid(&(conn)->acceptmbox) && (((conn)->flags & NETCONN_FLAG_MBOXCLOSED) == 0)) +#define NETCONN_MBOX_WAITING_INC(conn) +#define NETCONN_MBOX_WAITING_DEC(conn) +#endif /* LWIP_NETCONN_FULLDUPLEX */ + +static err_t netconn_close_shutdown(struct netconn *conn, u8_t how); + +/** + * Call the lower part of a netconn_* function + * This function is then running in the thread context + * of tcpip_thread and has exclusive access to lwIP core code. + * + * @param fn function to call + * @param apimsg a struct containing the function to call and its parameters + * @return ERR_OK if the function was called, another err_t if not + */ +static err_t +netconn_apimsg(tcpip_callback_fn fn, struct api_msg *apimsg) +{ + err_t err; + +#ifdef LWIP_DEBUG + /* catch functions that don't set err */ + apimsg->err = ERR_VAL; +#endif /* LWIP_DEBUG */ + +#if LWIP_NETCONN_SEM_PER_THREAD + apimsg->op_completed_sem = LWIP_NETCONN_THREAD_SEM_GET(); +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + + err = tcpip_send_msg_wait_sem(fn, apimsg, LWIP_API_MSG_SEM(apimsg)); + if (err == ERR_OK) { + return apimsg->err; + } + return err; +} + +/** + * Create a new netconn (of a specific type) that has a callback function. + * The corresponding pcb is also created. + * + * @param t the type of 'connection' to create (@see enum netconn_type) + * @param proto the IP protocol for RAW IP pcbs + * @param callback a function to call on status changes (RX available, TX'ed) + * @return a newly allocated struct netconn or + * NULL on memory error + */ +struct netconn * +netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, netconn_callback callback) +{ + struct netconn *conn; + API_MSG_VAR_DECLARE(msg); + API_MSG_VAR_ALLOC_RETURN_NULL(msg); + + conn = netconn_alloc(t, callback); + if (conn != NULL) { + err_t err; + + API_MSG_VAR_REF(msg).msg.n.proto = proto; + API_MSG_VAR_REF(msg).conn = conn; + err = netconn_apimsg(lwip_netconn_do_newconn, &API_MSG_VAR_REF(msg)); + if (err != ERR_OK) { + LWIP_ASSERT("freeing conn without freeing pcb", conn->pcb.tcp == NULL); + LWIP_ASSERT("conn has no recvmbox", sys_mbox_valid(&conn->recvmbox)); +#if LWIP_TCP + LWIP_ASSERT("conn->acceptmbox shouldn't exist", !sys_mbox_valid(&conn->acceptmbox)); +#endif /* LWIP_TCP */ +#if !LWIP_NETCONN_SEM_PER_THREAD + LWIP_ASSERT("conn has no op_completed", sys_sem_valid(&conn->op_completed)); + sys_sem_free(&conn->op_completed); +#endif /* !LWIP_NETCONN_SEM_PER_THREAD */ + sys_mbox_free(&conn->recvmbox); + memp_free(MEMP_NETCONN, conn); + API_MSG_VAR_FREE(msg); + return NULL; + } + } + API_MSG_VAR_FREE(msg); + return conn; +} + +/** + * @ingroup netconn_common + * Close a netconn 'connection' and free all its resources but not the netconn itself. + * UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate + * after this returns. + * + * @param conn the netconn to delete + * @return ERR_OK if the connection was deleted + */ +err_t +netconn_prepare_delete(struct netconn *conn) +{ + err_t err; + API_MSG_VAR_DECLARE(msg); + + /* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */ + if (conn == NULL) { + return ERR_OK; + } + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; +#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER + /* get the time we started, which is later compared to + sys_now() + conn->send_timeout */ + API_MSG_VAR_REF(msg).msg.sd.time_started = sys_now(); +#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ +#if LWIP_TCP + API_MSG_VAR_REF(msg).msg.sd.polls_left = + ((LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT + TCP_SLOW_INTERVAL - 1) / TCP_SLOW_INTERVAL) + 1; +#endif /* LWIP_TCP */ +#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ + err = netconn_apimsg(lwip_netconn_do_delconn, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + if (err != ERR_OK) { + return err; + } + return ERR_OK; +} + +/** + * @ingroup netconn_common + * Close a netconn 'connection' and free its resources. + * UDP and RAW connection are completely closed, TCP pcbs might still be in a waitstate + * after this returns. + * + * @param conn the netconn to delete + * @return ERR_OK if the connection was deleted + */ +err_t +netconn_delete(struct netconn *conn) +{ + err_t err; + + /* No ASSERT here because possible to get a (conn == NULL) if we got an accept error */ + if (conn == NULL) { + return ERR_OK; + } + +#if LWIP_NETCONN_FULLDUPLEX + if (conn->flags & NETCONN_FLAG_MBOXINVALID) { + /* Already called netconn_prepare_delete() before */ + err = ERR_OK; + } else +#endif /* LWIP_NETCONN_FULLDUPLEX */ + { +// err = netconn_prepare_delete(conn); + } + if (err == ERR_OK) { + netconn_free(conn); + } + return err; +} + +/** + * Get the local or remote IP address and port of a netconn. + * For RAW netconns, this returns the protocol instead of a port! + * + * @param conn the netconn to query + * @param addr a pointer to which to save the IP address + * @param port a pointer to which to save the port (or protocol for RAW) + * @param local 1 to get the local IP address, 0 to get the remote one + * @return ERR_CONN for invalid connections + * ERR_OK if the information was retrieved + */ +err_t +netconn_getaddr(struct netconn *conn, ip_addr_t *addr, u16_t *port, u8_t local) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_getaddr: invalid conn", (conn != NULL), return ERR_ARG;); + LWIP_ERROR("netconn_getaddr: invalid addr", (addr != NULL), return ERR_ARG;); + LWIP_ERROR("netconn_getaddr: invalid port", (port != NULL), return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.ad.local = local; +#if LWIP_MPU_COMPATIBLE + err = netconn_apimsg(lwip_netconn_do_getaddr, &API_MSG_VAR_REF(msg)); + *addr = msg->msg.ad.ipaddr; + *port = msg->msg.ad.port; +#else /* LWIP_MPU_COMPATIBLE */ + msg.msg.ad.ipaddr = addr; + msg.msg.ad.port = port; + err = netconn_apimsg(lwip_netconn_do_getaddr, &msg); +#endif /* LWIP_MPU_COMPATIBLE */ + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_common + * Bind a netconn to a specific local IP address and port. + * Binding one netconn twice might not always be checked correctly! + * + * @param conn the netconn to bind + * @param addr the local IP address to bind the netconn to + * (use IP4_ADDR_ANY/IP6_ADDR_ANY to bind to all addresses) + * @param port the local port to bind the netconn to (not used for RAW) + * @return ERR_OK if bound, any other err_t on failure + */ +err_t +netconn_bind(struct netconn *conn, const ip_addr_t *addr, u16_t port) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_bind: invalid conn", (conn != NULL), return ERR_ARG;); + +#if LWIP_IPV4 + /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ + if (addr == NULL) { + addr = IP4_ADDR_ANY; + } +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV4 && LWIP_IPV6 + /* "Socket API like" dual-stack support: If IP to bind to is IP6_ADDR_ANY, + * and NETCONN_FLAG_IPV6_V6ONLY is 0, use IP_ANY_TYPE to bind + */ + if ((netconn_get_ipv6only(conn) == 0) && + ip_addr_cmp(addr, IP6_ADDR_ANY)) { + addr = IP_ANY_TYPE; + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.bc.ipaddr = API_MSG_VAR_REF(addr); + API_MSG_VAR_REF(msg).msg.bc.port = port; + err = netconn_apimsg(lwip_netconn_do_bind, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_common + * Bind a netconn to a specific interface and port. + * Binding one netconn twice might not always be checked correctly! + * + * @param conn the netconn to bind + * @param if_idx the local interface index to bind the netconn to + * @return ERR_OK if bound, any other err_t on failure + */ +err_t +netconn_bind_if(struct netconn *conn, u8_t if_idx) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_bind_if: invalid conn", (conn != NULL), return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.bc.if_idx = if_idx; + err = netconn_apimsg(lwip_netconn_do_bind_if, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_common + * Connect a netconn to a specific remote IP address and port. + * + * @param conn the netconn to connect + * @param addr the remote IP address to connect to + * @param port the remote port to connect to (no used for RAW) + * @return ERR_OK if connected, return value of tcp_/udp_/raw_connect otherwise + */ +err_t +netconn_connect(struct netconn *conn, const ip_addr_t *addr, u16_t port) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_connect: invalid conn", (conn != NULL), return ERR_ARG;); + +#if LWIP_IPV4 + /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ + if (addr == NULL) { + addr = IP4_ADDR_ANY; + } +#endif /* LWIP_IPV4 */ + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.bc.ipaddr = API_MSG_VAR_REF(addr); + API_MSG_VAR_REF(msg).msg.bc.port = port; + err = netconn_apimsg(lwip_netconn_do_connect, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_udp + * Disconnect a netconn from its current peer (only valid for UDP netconns). + * + * @param conn the netconn to disconnect + * @return See @ref err_t + */ +err_t +netconn_disconnect(struct netconn *conn) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_disconnect: invalid conn", (conn != NULL), return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; + err = netconn_apimsg(lwip_netconn_do_disconnect, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_tcp + * Set a TCP netconn into listen mode + * + * @param conn the tcp netconn to set to listen mode + * @param backlog the listen backlog, only used if TCP_LISTEN_BACKLOG==1 + * @return ERR_OK if the netconn was set to listen (UDP and RAW netconns + * don't return any error (yet?)) + */ +err_t +netconn_listen_with_backlog(struct netconn *conn, u8_t backlog) +{ +#if LWIP_TCP + API_MSG_VAR_DECLARE(msg); + err_t err; + + /* This does no harm. If TCP_LISTEN_BACKLOG is off, backlog is unused. */ + LWIP_UNUSED_ARG(backlog); + + LWIP_ERROR("netconn_listen: invalid conn", (conn != NULL), return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; +#if TCP_LISTEN_BACKLOG + API_MSG_VAR_REF(msg).msg.lb.backlog = backlog; +#endif /* TCP_LISTEN_BACKLOG */ + err = netconn_apimsg(lwip_netconn_do_listen, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +#else /* LWIP_TCP */ + LWIP_UNUSED_ARG(conn); + LWIP_UNUSED_ARG(backlog); + return ERR_ARG; +#endif /* LWIP_TCP */ +} + +/** + * @ingroup netconn_tcp + * Accept a new connection on a TCP listening netconn. + * + * @param conn the TCP listen netconn + * @param new_conn pointer where the new connection is stored + * @return ERR_OK if a new connection has been received or an error + * code otherwise + */ +err_t +netconn_accept(struct netconn *conn, struct netconn **new_conn) +{ +#if LWIP_TCP + err_t err; + void *accept_ptr; + struct netconn *newconn; +#if TCP_LISTEN_BACKLOG + API_MSG_VAR_DECLARE(msg); +#endif /* TCP_LISTEN_BACKLOG */ + + LWIP_ERROR("netconn_accept: invalid pointer", (new_conn != NULL), return ERR_ARG;); + *new_conn = NULL; + LWIP_ERROR("netconn_accept: invalid conn", (conn != NULL), return ERR_ARG;); + + /* NOTE: Although the opengroup spec says a pending error shall be returned to + send/recv/getsockopt(SO_ERROR) only, we return it for listening + connections also, to handle embedded-system errors */ + err = netconn_err(conn); + if (err != ERR_OK) { + /* return pending error */ + return err; + } + if (!NETCONN_ACCEPTMBOX_WAITABLE(conn)) { + /* don't accept if closed: this might block the application task + waiting on acceptmbox forever! */ + return ERR_CLSD; + } + + API_MSG_VAR_ALLOC_ACCEPT(msg); + + NETCONN_MBOX_WAITING_INC(conn); + if (netconn_is_nonblocking(conn)) { + if (sys_arch_mbox_tryfetch(&conn->acceptmbox, &accept_ptr) == SYS_ARCH_TIMEOUT) { + API_MSG_VAR_FREE_ACCEPT(msg); + NETCONN_MBOX_WAITING_DEC(conn); + return ERR_WOULDBLOCK; + } + } else { +#if LWIP_SO_RCVTIMEO + if (sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, conn->recv_timeout) == SYS_ARCH_TIMEOUT) { + API_MSG_VAR_FREE_ACCEPT(msg); + NETCONN_MBOX_WAITING_DEC(conn); + return ERR_TIMEOUT; + } +#else + sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, 0); +#endif /* LWIP_SO_RCVTIMEO*/ + } + NETCONN_MBOX_WAITING_DEC(conn); +#if LWIP_NETCONN_FULLDUPLEX + if (conn->flags & NETCONN_FLAG_MBOXINVALID) { + if (lwip_netconn_is_deallocated_msg(accept_ptr)) { + /* the netconn has been closed from another thread */ + API_MSG_VAR_FREE_ACCEPT(msg); + return ERR_CONN; + } + } +#endif + + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0); + + if (lwip_netconn_is_err_msg(accept_ptr, &err)) { + /* a connection has been aborted: e.g. out of pcbs or out of netconns during accept */ + API_MSG_VAR_FREE_ACCEPT(msg); + return err; + } + if (accept_ptr == NULL) { + /* connection has been aborted */ + API_MSG_VAR_FREE_ACCEPT(msg); + return ERR_CLSD; + } + newconn = (struct netconn *)accept_ptr; +#if TCP_LISTEN_BACKLOG + /* Let the stack know that we have accepted the connection. */ + API_MSG_VAR_REF(msg).conn = newconn; + /* don't care for the return value of lwip_netconn_do_recv */ + netconn_apimsg(lwip_netconn_do_accepted, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); +#endif /* TCP_LISTEN_BACKLOG */ + + *new_conn = newconn; + /* don't set conn->last_err: it's only ERR_OK, anyway */ + return ERR_OK; +#else /* LWIP_TCP */ + LWIP_UNUSED_ARG(conn); + LWIP_UNUSED_ARG(new_conn); + return ERR_ARG; +#endif /* LWIP_TCP */ +} + +/** + * @ingroup netconn_common + * Receive data: actual implementation that doesn't care whether pbuf or netbuf + * is received (this is internal, it's just here for describing common errors) + * + * @param conn the netconn from which to receive data + * @param new_buf pointer where a new pbuf/netbuf is stored when received data + * @param apiflags flags that control function behaviour. For now only: + * - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data + * @return ERR_OK if data has been received, an error code otherwise (timeout, + * memory error or another error) + * ERR_CONN if not connected + * ERR_CLSD if TCP connection has been closed + * ERR_WOULDBLOCK if the netconn is nonblocking but would block to wait for data + * ERR_TIMEOUT if the netconn has a receive timeout and no data was received + */ +static err_t +netconn_recv_data(struct netconn *conn, void **new_buf, u8_t apiflags) +{ + void *buf = NULL; + u16_t len; + + LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;); + *new_buf = NULL; + LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;); + + if (!NETCONN_RECVMBOX_WAITABLE(conn)) { + err_t err = netconn_err(conn); + if (err != ERR_OK) { + /* return pending error */ + return err; + } + return ERR_CONN; + } + + NETCONN_MBOX_WAITING_INC(conn); + if (netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK) || + (conn->flags & NETCONN_FLAG_MBOXCLOSED) || (conn->pending_err != ERR_OK)) { + if (sys_arch_mbox_tryfetch(&conn->recvmbox, &buf) == SYS_ARCH_TIMEOUT) { + err_t err; + NETCONN_MBOX_WAITING_DEC(conn); + err = netconn_err(conn); + if (err != ERR_OK) { + /* return pending error */ + return err; + } + if (conn->flags & NETCONN_FLAG_MBOXCLOSED) { + return ERR_CONN; + } + return ERR_WOULDBLOCK; + } + } else { +#if LWIP_SO_RCVTIMEO + if (sys_arch_mbox_fetch(&conn->recvmbox, &buf, conn->recv_timeout) == SYS_ARCH_TIMEOUT) { + NETCONN_MBOX_WAITING_DEC(conn); + return ERR_TIMEOUT; + } +#else + sys_arch_mbox_fetch(&conn->recvmbox, &buf, 0); +#endif /* LWIP_SO_RCVTIMEO*/ + } + NETCONN_MBOX_WAITING_DEC(conn); +#if LWIP_NETCONN_FULLDUPLEX + if (conn->flags & NETCONN_FLAG_MBOXINVALID) { + if (lwip_netconn_is_deallocated_msg(buf)) { + /* the netconn has been closed from another thread */ + API_MSG_VAR_FREE_ACCEPT(msg); + return ERR_CONN; + } + } +#endif + +#if LWIP_TCP +#if (LWIP_UDP || LWIP_RAW) + if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) +#endif /* (LWIP_UDP || LWIP_RAW) */ + { + err_t err; + /* Check if this is an error message or a pbuf */ + if (lwip_netconn_is_err_msg(buf, &err)) { + /* new_buf has been zeroed above already */ + if (err == ERR_CLSD) { + /* connection closed translates to ERR_OK with *new_buf == NULL */ + return ERR_OK; + } + return err; + } + len = ((struct pbuf *)buf)->tot_len; + } +#endif /* LWIP_TCP */ +#if LWIP_TCP && (LWIP_UDP || LWIP_RAW) + else +#endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */ +#if (LWIP_UDP || LWIP_RAW) + { + LWIP_ASSERT("buf != NULL", buf != NULL); + len = netbuf_len((struct netbuf *)buf); + } +#endif /* (LWIP_UDP || LWIP_RAW) */ + +#if LWIP_SO_RCVBUF + SYS_ARCH_DEC(conn->recv_avail, len); +#endif /* LWIP_SO_RCVBUF */ + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVMINUS, len); + + LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_recv_data: received %p, len=%"U16_F"\n", buf, len)); + + *new_buf = buf; + /* don't set conn->last_err: it's only ERR_OK, anyway */ + return ERR_OK; +} + +#if LWIP_TCP +static err_t +netconn_tcp_recvd_msg(struct netconn *conn, size_t len, struct api_msg *msg) +{ + LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && + NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); + + msg->conn = conn; + msg->msg.r.len = len; + + return netconn_apimsg(lwip_netconn_do_recv, msg); +} + +err_t +netconn_tcp_recvd(struct netconn *conn, size_t len) +{ + err_t err; + API_MSG_VAR_DECLARE(msg); + LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && + NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + err = netconn_tcp_recvd_msg(conn, len, &API_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + return err; +} + +static err_t +netconn_recv_data_tcp(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags) +{ + err_t err; + struct pbuf *buf; + API_MSG_VAR_DECLARE(msg); +#if LWIP_MPU_COMPATIBLE + msg = NULL; +#endif + + if (!NETCONN_RECVMBOX_WAITABLE(conn)) { + /* This only happens when calling this function more than once *after* receiving FIN */ + return ERR_CONN; + } + if (netconn_is_flag_set(conn, NETCONN_FIN_RX_PENDING)) { + netconn_clear_flags(conn, NETCONN_FIN_RX_PENDING); + goto handle_fin; + } + + if (!(apiflags & NETCONN_NOAUTORCVD)) { + /* need to allocate API message here so empty message pool does not result in event loss + * see bug #47512: MPU_COMPATIBLE may fail on empty pool */ + API_MSG_VAR_ALLOC(msg); + } + + err = netconn_recv_data(conn, (void **)new_buf, apiflags); + if (err != ERR_OK) { + if (!(apiflags & NETCONN_NOAUTORCVD)) { + API_MSG_VAR_FREE(msg); + } + return err; + } + buf = *new_buf; + if (!(apiflags & NETCONN_NOAUTORCVD)) { + /* Let the stack know that we have taken the data. */ + u16_t len = buf ? buf->tot_len : 1; + /* don't care for the return value of lwip_netconn_do_recv */ + /* @todo: this should really be fixed, e.g. by retrying in poll on error */ + netconn_tcp_recvd_msg(conn, len, &API_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + } + + /* If we are closed, we indicate that we no longer wish to use the socket */ + if (buf == NULL) { + if (apiflags & NETCONN_NOFIN) { + /* received a FIN but the caller cannot handle it right now: + re-enqueue it and return "no data" */ + netconn_set_flags(conn, NETCONN_FIN_RX_PENDING); + return ERR_WOULDBLOCK; + } else { +handle_fin: + API_EVENT(conn, NETCONN_EVT_RCVMINUS, 0); + if (conn->pcb.ip == NULL) { + /* race condition: RST during recv */ + err = netconn_err(conn); + if (err != ERR_OK) { + return err; + } + return ERR_RST; + } + /* RX side is closed, so deallocate the recvmbox */ + netconn_close_shutdown(conn, NETCONN_SHUT_RD); + /* Don' store ERR_CLSD as conn->err since we are only half-closed */ + return ERR_CLSD; + } + } + return err; +} + +/** + * @ingroup netconn_tcp + * Receive data (in form of a pbuf) from a TCP netconn + * + * @param conn the netconn from which to receive data + * @param new_buf pointer where a new pbuf is stored when received data + * @return ERR_OK if data has been received, an error code otherwise (timeout, + * memory error or another error, @see netconn_recv_data) + * ERR_ARG if conn is not a TCP netconn + */ +err_t +netconn_recv_tcp_pbuf(struct netconn *conn, struct pbuf **new_buf) +{ + LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && + NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); + + return netconn_recv_data_tcp(conn, new_buf, 0); +} + +/** + * @ingroup netconn_tcp + * Receive data (in form of a pbuf) from a TCP netconn + * + * @param conn the netconn from which to receive data + * @param new_buf pointer where a new pbuf is stored when received data + * @param apiflags flags that control function behaviour. For now only: + * - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data + * @return ERR_OK if data has been received, an error code otherwise (timeout, + * memory error or another error, @see netconn_recv_data) + * ERR_ARG if conn is not a TCP netconn + */ +err_t +netconn_recv_tcp_pbuf_flags(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags) +{ + LWIP_ERROR("netconn_recv_tcp_pbuf: invalid conn", (conn != NULL) && + NETCONNTYPE_GROUP(netconn_type(conn)) == NETCONN_TCP, return ERR_ARG;); + + return netconn_recv_data_tcp(conn, new_buf, apiflags); +} +#endif /* LWIP_TCP */ + +/** + * Receive data (in form of a netbuf) from a UDP or RAW netconn + * + * @param conn the netconn from which to receive data + * @param new_buf pointer where a new netbuf is stored when received data + * @return ERR_OK if data has been received, an error code otherwise (timeout, + * memory error or another error) + * ERR_ARG if conn is not a UDP/RAW netconn + */ +err_t +netconn_recv_udp_raw_netbuf(struct netconn *conn, struct netbuf **new_buf) +{ + LWIP_ERROR("netconn_recv_udp_raw_netbuf: invalid conn", (conn != NULL) && + NETCONNTYPE_GROUP(netconn_type(conn)) != NETCONN_TCP, return ERR_ARG;); + + return netconn_recv_data(conn, (void **)new_buf, 0); +} + +/** + * Receive data (in form of a netbuf) from a UDP or RAW netconn + * + * @param conn the netconn from which to receive data + * @param new_buf pointer where a new netbuf is stored when received data + * @param apiflags flags that control function behaviour. For now only: + * - NETCONN_DONTBLOCK: only read data that is available now, don't wait for more data + * @return ERR_OK if data has been received, an error code otherwise (timeout, + * memory error or another error) + * ERR_ARG if conn is not a UDP/RAW netconn + */ +err_t +netconn_recv_udp_raw_netbuf_flags(struct netconn *conn, struct netbuf **new_buf, u8_t apiflags) +{ + LWIP_ERROR("netconn_recv_udp_raw_netbuf: invalid conn", (conn != NULL) && + NETCONNTYPE_GROUP(netconn_type(conn)) != NETCONN_TCP, return ERR_ARG;); + + return netconn_recv_data(conn, (void **)new_buf, apiflags); +} + +/** + * @ingroup netconn_common + * Receive data (in form of a netbuf containing a packet buffer) from a netconn + * + * @param conn the netconn from which to receive data + * @param new_buf pointer where a new netbuf is stored when received data + * @return ERR_OK if data has been received, an error code otherwise (timeout, + * memory error or another error) + */ +err_t +netconn_recv(struct netconn *conn, struct netbuf **new_buf) +{ +#if LWIP_TCP + struct netbuf *buf = NULL; + err_t err; +#endif /* LWIP_TCP */ + + LWIP_ERROR("netconn_recv: invalid pointer", (new_buf != NULL), return ERR_ARG;); + *new_buf = NULL; + LWIP_ERROR("netconn_recv: invalid conn", (conn != NULL), return ERR_ARG;); + +#if LWIP_TCP +#if (LWIP_UDP || LWIP_RAW) + if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) +#endif /* (LWIP_UDP || LWIP_RAW) */ + { + struct pbuf *p = NULL; + /* This is not a listening netconn, since recvmbox is set */ + + buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); + if (buf == NULL) { + return ERR_MEM; + } + + err = netconn_recv_data_tcp(conn, &p, 0); + if (err != ERR_OK) { + memp_free(MEMP_NETBUF, buf); + return err; + } + LWIP_ASSERT("p != NULL", p != NULL); + + buf->p = p; + buf->ptr = p; + buf->port = 0; + ip_addr_set_zero(&buf->addr); + *new_buf = buf; + /* don't set conn->last_err: it's only ERR_OK, anyway */ + return ERR_OK; + } +#endif /* LWIP_TCP */ +#if LWIP_TCP && (LWIP_UDP || LWIP_RAW) + else +#endif /* LWIP_TCP && (LWIP_UDP || LWIP_RAW) */ + { +#if (LWIP_UDP || LWIP_RAW) + return netconn_recv_data(conn, (void **)new_buf, 0); +#endif /* (LWIP_UDP || LWIP_RAW) */ + } +} + +/** + * @ingroup netconn_udp + * Send data (in form of a netbuf) to a specific remote IP address and port. + * Only to be used for UDP and RAW netconns (not TCP). + * + * @param conn the netconn over which to send data + * @param buf a netbuf containing the data to send + * @param addr the remote IP address to which to send the data + * @param port the remote port to which to send the data + * @return ERR_OK if data was sent, any other err_t on error + */ +err_t +netconn_sendto(struct netconn *conn, struct netbuf *buf, const ip_addr_t *addr, u16_t port) +{ + if (buf != NULL) { + ip_addr_set(&buf->addr, addr); + buf->port = port; + return netconn_send(conn, buf); + } + return ERR_VAL; +} + +/** + * @ingroup netconn_udp + * Send data over a UDP or RAW netconn (that is already connected). + * + * @param conn the UDP or RAW netconn over which to send data + * @param buf a netbuf containing the data to send + * @return ERR_OK if data was sent, any other err_t on error + */ +err_t +netconn_send(struct netconn *conn, struct netbuf *buf) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_send: invalid conn", (conn != NULL), return ERR_ARG;); + + LWIP_DEBUGF(API_LIB_DEBUG, ("netconn_send: sending %"U16_F" bytes\n", buf->p->tot_len)); + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.b = buf; + err = netconn_apimsg(lwip_netconn_do_send, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_tcp + * Send data over a TCP netconn. + * + * @param conn the TCP netconn over which to send data + * @param dataptr pointer to the application buffer that contains the data to send + * @param size size of the application data to send + * @param apiflags combination of following flags : + * - NETCONN_COPY: data will be copied into memory belonging to the stack + * - NETCONN_MORE: for TCP connection, PSH flag will be set on last segment sent + * - NETCONN_DONTBLOCK: only write the data if all data can be written at once + * @param bytes_written pointer to a location that receives the number of written bytes + * @return ERR_OK if data was sent, any other err_t on error + */ +err_t +netconn_write_partly(struct netconn *conn, const void *dataptr, size_t size, + u8_t apiflags, size_t *bytes_written) +{ + struct netvector vector; + vector.ptr = dataptr; + vector.len = size; + return netconn_write_vectors_partly(conn, &vector, 1, apiflags, bytes_written); +} + +/** + * Send vectorized data atomically over a TCP netconn. + * + * @param conn the TCP netconn over which to send data + * @param vectors array of vectors containing data to send + * @param vectorcnt number of vectors in the array + * @param apiflags combination of following flags : + * - NETCONN_COPY: data will be copied into memory belonging to the stack + * - NETCONN_MORE: for TCP connection, PSH flag will be set on last segment sent + * - NETCONN_DONTBLOCK: only write the data if all data can be written at once + * @param bytes_written pointer to a location that receives the number of written bytes + * @return ERR_OK if data was sent, any other err_t on error + */ +err_t +netconn_write_vectors_partly(struct netconn *conn, struct netvector *vectors, u16_t vectorcnt, + u8_t apiflags, size_t *bytes_written) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + u8_t dontblock; + size_t size; + int i; + + LWIP_ERROR("netconn_write: invalid conn", (conn != NULL), return ERR_ARG;); + LWIP_ERROR("netconn_write: invalid conn->type", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP), return ERR_VAL;); + dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK); +#if LWIP_SO_SNDTIMEO + if (conn->send_timeout != 0) { + dontblock = 1; + } +#endif /* LWIP_SO_SNDTIMEO */ + if (dontblock && !bytes_written) { + /* This implies netconn_write() cannot be used for non-blocking send, since + it has no way to return the number of bytes written. */ + return ERR_VAL; + } + + /* sum up the total size */ + size = 0; + for (i = 0; i < vectorcnt; i++) { + size += vectors[i].len; + if (size < vectors[i].len) { + /* overflow */ + return ERR_VAL; + } + } + if (size == 0) { + return ERR_OK; + } else if (size > SSIZE_MAX) { + ssize_t limited; + /* this is required by the socket layer (cannot send full size_t range) */ + if (!bytes_written) { + return ERR_VAL; + } + /* limit the amount of data to send */ + limited = SSIZE_MAX; + size = (size_t)limited; + } + + API_MSG_VAR_ALLOC(msg); + /* non-blocking write sends as much */ + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.w.vector = vectors; + API_MSG_VAR_REF(msg).msg.w.vector_cnt = vectorcnt; + API_MSG_VAR_REF(msg).msg.w.vector_off = 0; + API_MSG_VAR_REF(msg).msg.w.apiflags = apiflags; + API_MSG_VAR_REF(msg).msg.w.len = size; + API_MSG_VAR_REF(msg).msg.w.offset = 0; +#if LWIP_SO_SNDTIMEO + if (conn->send_timeout != 0) { + /* get the time we started, which is later compared to + sys_now() + conn->send_timeout */ + API_MSG_VAR_REF(msg).msg.w.time_started = sys_now(); + } else { + API_MSG_VAR_REF(msg).msg.w.time_started = 0; + } +#endif /* LWIP_SO_SNDTIMEO */ + + /* For locking the core: this _can_ be delayed on low memory/low send buffer, + but if it is, this is done inside api_msg.c:do_write(), so we can use the + non-blocking version here. */ + err = netconn_apimsg(lwip_netconn_do_write, &API_MSG_VAR_REF(msg)); + if (err == ERR_OK) { + if (bytes_written != NULL) { + *bytes_written = API_MSG_VAR_REF(msg).msg.w.offset; + } + /* for blocking, check all requested bytes were written, NOTE: send_timeout is + treated as dontblock (see dontblock assignment above) */ + if (!dontblock) { + LWIP_ASSERT("do_write failed to write all bytes", API_MSG_VAR_REF(msg).msg.w.offset == size); + } + } + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_tcp + * Close or shutdown a TCP netconn (doesn't delete it). + * + * @param conn the TCP netconn to close or shutdown + * @param how fully close or only shutdown one side? + * @return ERR_OK if the netconn was closed, any other err_t on error + */ +static err_t +netconn_close_shutdown(struct netconn *conn, u8_t how) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + LWIP_UNUSED_ARG(how); + + LWIP_ERROR("netconn_close: invalid conn", (conn != NULL), return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + API_MSG_VAR_REF(msg).conn = conn; +#if LWIP_TCP + /* shutting down both ends is the same as closing */ + API_MSG_VAR_REF(msg).msg.sd.shut = how; +#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER + /* get the time we started, which is later compared to + sys_now() + conn->send_timeout */ + API_MSG_VAR_REF(msg).msg.sd.time_started = sys_now(); +#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ + API_MSG_VAR_REF(msg).msg.sd.polls_left = + ((LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT + TCP_SLOW_INTERVAL - 1) / TCP_SLOW_INTERVAL) + 1; +#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ +#endif /* LWIP_TCP */ + err = netconn_apimsg(lwip_netconn_do_close, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} + +/** + * @ingroup netconn_tcp + * Close a TCP netconn (doesn't delete it). + * + * @param conn the TCP netconn to close + * @return ERR_OK if the netconn was closed, any other err_t on error + */ +err_t +netconn_close(struct netconn *conn) +{ + /* shutting down both ends is the same as closing */ + return netconn_close_shutdown(conn, NETCONN_SHUT_RDWR); +} + +/** + * @ingroup netconn_common + * Get and reset pending error on a netconn + * + * @param conn the netconn to get the error from + * @return and pending error or ERR_OK if no error was pending + */ +err_t +netconn_err(struct netconn *conn) +{ + err_t err; + SYS_ARCH_DECL_PROTECT(lev); + if (conn == NULL) { + return ERR_OK; + } + SYS_ARCH_PROTECT(lev); + err = conn->pending_err; + conn->pending_err = ERR_OK; + SYS_ARCH_UNPROTECT(lev); + return err; +} + +/** + * @ingroup netconn_tcp + * Shut down one or both sides of a TCP netconn (doesn't delete it). + * + * @param conn the TCP netconn to shut down + * @param shut_rx shut down the RX side (no more read possible after this) + * @param shut_tx shut down the TX side (no more write possible after this) + * @return ERR_OK if the netconn was closed, any other err_t on error + */ +err_t +netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx) +{ + return netconn_close_shutdown(conn, (u8_t)((shut_rx ? NETCONN_SHUT_RD : 0) | (shut_tx ? NETCONN_SHUT_WR : 0))); +} + +#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) +/** + * @ingroup netconn_udp + * Join multicast groups for UDP netconns. + * + * @param conn the UDP netconn for which to change multicast addresses + * @param multiaddr IP address of the multicast group to join or leave + * @param netif_addr the IP address of the network interface on which to send + * the igmp message + * @param join_or_leave flag whether to send a join- or leave-message + * @return ERR_OK if the action was taken, any err_t on error + */ +err_t +netconn_join_leave_group(struct netconn *conn, + const ip_addr_t *multiaddr, + const ip_addr_t *netif_addr, + enum netconn_igmp join_or_leave) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + +#if LWIP_IPV4 + /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ + if (multiaddr == NULL) { + multiaddr = IP4_ADDR_ANY; + } + if (netif_addr == NULL) { + netif_addr = IP4_ADDR_ANY; + } +#endif /* LWIP_IPV4 */ + + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.jl.multiaddr = API_MSG_VAR_REF(multiaddr); + API_MSG_VAR_REF(msg).msg.jl.netif_addr = API_MSG_VAR_REF(netif_addr); + API_MSG_VAR_REF(msg).msg.jl.join_or_leave = join_or_leave; + err = netconn_apimsg(lwip_netconn_do_join_leave_group, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} +/** + * @ingroup netconn_udp + * Join multicast groups for UDP netconns. + * + * @param conn the UDP netconn for which to change multicast addresses + * @param multiaddr IP address of the multicast group to join or leave + * @param if_idx the index of the netif + * @param join_or_leave flag whether to send a join- or leave-message + * @return ERR_OK if the action was taken, any err_t on error + */ +err_t +netconn_join_leave_group_netif(struct netconn *conn, + const ip_addr_t *multiaddr, + u8_t if_idx, + enum netconn_igmp join_or_leave) +{ + API_MSG_VAR_DECLARE(msg); + err_t err; + + LWIP_ERROR("netconn_join_leave_group: invalid conn", (conn != NULL), return ERR_ARG;); + + API_MSG_VAR_ALLOC(msg); + +#if LWIP_IPV4 + /* Don't propagate NULL pointer (IP_ADDR_ANY alias) to subsequent functions */ + if (multiaddr == NULL) { + multiaddr = IP4_ADDR_ANY; + } + if (if_idx == NETIF_NO_INDEX) { + return ERR_IF; + } +#endif /* LWIP_IPV4 */ + + API_MSG_VAR_REF(msg).conn = conn; + API_MSG_VAR_REF(msg).msg.jl.multiaddr = API_MSG_VAR_REF(multiaddr); + API_MSG_VAR_REF(msg).msg.jl.if_idx = if_idx; + API_MSG_VAR_REF(msg).msg.jl.join_or_leave = join_or_leave; + err = netconn_apimsg(lwip_netconn_do_join_leave_group_netif, &API_MSG_VAR_REF(msg)); + API_MSG_VAR_FREE(msg); + + return err; +} +#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ + +#if LWIP_DNS +/** + * @ingroup netconn_common + * Execute a DNS query, only one IP address is returned + * + * @param name a string representation of the DNS host name to query + * @param addr a preallocated ip_addr_t where to store the resolved IP address + * @param dns_addrtype IP address type (IPv4 / IPv6) + * @return ERR_OK: resolving succeeded + * ERR_MEM: memory error, try again later + * ERR_ARG: dns client not initialized or invalid hostname + * ERR_VAL: dns server response was invalid + */ +#if LWIP_IPV4 && LWIP_IPV6 +err_t +netconn_gethostbyname_addrtype(const char *name, ip_addr_t *addr, u8_t dns_addrtype) +#else +err_t +netconn_gethostbyname(const char *name, ip_addr_t *addr) +#endif +{ + API_VAR_DECLARE(struct dns_api_msg, msg); +#if !LWIP_MPU_COMPATIBLE + sys_sem_t sem; +#endif /* LWIP_MPU_COMPATIBLE */ + err_t err; + err_t cberr; + + LWIP_ERROR("netconn_gethostbyname: invalid name", (name != NULL), return ERR_ARG;); + LWIP_ERROR("netconn_gethostbyname: invalid addr", (addr != NULL), return ERR_ARG;); +#if LWIP_MPU_COMPATIBLE + if (strlen(name) >= DNS_MAX_NAME_LENGTH) { + return ERR_ARG; + } +#endif + +#ifdef LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE +#if LWIP_IPV4 && LWIP_IPV6 + if (LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, dns_addrtype, &err)) { +#else + if (LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, NETCONN_DNS_DEFAULT, &err)) { +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + return err; + } +#endif /* LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE */ + + API_VAR_ALLOC(struct dns_api_msg, MEMP_DNS_API_MSG, msg, ERR_MEM); +#if LWIP_MPU_COMPATIBLE + strncpy(API_VAR_REF(msg).name, name, DNS_MAX_NAME_LENGTH - 1); + API_VAR_REF(msg).name[DNS_MAX_NAME_LENGTH - 1] = 0; +#else /* LWIP_MPU_COMPATIBLE */ + msg.err = &err; + msg.sem = &sem; + API_VAR_REF(msg).addr = API_VAR_REF(addr); + API_VAR_REF(msg).name = name; +#endif /* LWIP_MPU_COMPATIBLE */ +#if LWIP_IPV4 && LWIP_IPV6 + API_VAR_REF(msg).dns_addrtype = dns_addrtype; +#endif /* LWIP_IPV4 && LWIP_IPV6 */ +#if LWIP_NETCONN_SEM_PER_THREAD + API_VAR_REF(msg).sem = LWIP_NETCONN_THREAD_SEM_GET(); +#else /* LWIP_NETCONN_SEM_PER_THREAD*/ + err = sys_sem_new(API_EXPR_REF(API_VAR_REF(msg).sem), 0); + if (err != ERR_OK) { + API_VAR_FREE(MEMP_DNS_API_MSG, msg); + return err; + } +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + + cberr = tcpip_send_msg_wait_sem(lwip_netconn_do_gethostbyname, &API_VAR_REF(msg), API_EXPR_REF(API_VAR_REF(msg).sem)); +#if !LWIP_NETCONN_SEM_PER_THREAD + sys_sem_free(API_EXPR_REF(API_VAR_REF(msg).sem)); +#endif /* !LWIP_NETCONN_SEM_PER_THREAD */ + if (cberr != ERR_OK) { + API_VAR_FREE(MEMP_DNS_API_MSG, msg); + return cberr; + } + +#if LWIP_MPU_COMPATIBLE + *addr = msg->addr; + err = msg->err; +#endif /* LWIP_MPU_COMPATIBLE */ + + API_VAR_FREE(MEMP_DNS_API_MSG, msg); + return err; +} +#endif /* LWIP_DNS*/ + +#if LWIP_NETCONN_SEM_PER_THREAD +void +netconn_thread_init(void) +{ + sys_sem_t *sem = LWIP_NETCONN_THREAD_SEM_GET(); + if ((sem == NULL) || !sys_sem_valid(sem)) { + /* call alloc only once */ + LWIP_NETCONN_THREAD_SEM_ALLOC(); + LWIP_ASSERT("LWIP_NETCONN_THREAD_SEM_ALLOC() failed", sys_sem_valid(LWIP_NETCONN_THREAD_SEM_GET())); + } +} + +void +netconn_thread_cleanup(void) +{ + sys_sem_t *sem = LWIP_NETCONN_THREAD_SEM_GET(); + if ((sem != NULL) && sys_sem_valid(sem)) { + /* call free only once */ + LWIP_NETCONN_THREAD_SEM_FREE(); + } +} +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + +#endif /* LWIP_NETCONN */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_msg.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_msg.c index 8952baaf..39531024 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_msg.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/api_msg.c @@ -1,2173 +1,2173 @@ -/** - * @file - * Sequential API Internal module - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/priv/api_msg.h" - -#include "lwip/ip.h" -#include "lwip/ip_addr.h" -#include "lwip/udp.h" -#include "lwip/tcp.h" -#include "lwip/raw.h" - -#include "lwip/memp.h" -#include "lwip/igmp.h" -#include "lwip/dns.h" -#include "lwip/mld6.h" -#include "lwip/priv/tcpip_priv.h" - -#include - -/* netconns are polled once per second (e.g. continue write on memory error) */ -#define NETCONN_TCP_POLL_INTERVAL 2 - -#define SET_NONBLOCKING_CONNECT(conn, val) do { if (val) { \ - netconn_set_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); \ -} else { \ - netconn_clear_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); }} while(0) -#define IN_NONBLOCKING_CONNECT(conn) netconn_is_flag_set(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT) - -#if LWIP_NETCONN_FULLDUPLEX -#define NETCONN_MBOX_VALID(conn, mbox) (sys_mbox_valid(mbox) && ((conn->flags & NETCONN_FLAG_MBOXINVALID) == 0)) -#else -#define NETCONN_MBOX_VALID(conn, mbox) sys_mbox_valid(mbox) -#endif - -/* forward declarations */ -#if LWIP_TCP -#if LWIP_TCPIP_CORE_LOCKING -#define WRITE_DELAYED , 1 -#define WRITE_DELAYED_PARAM , u8_t delayed -#else /* LWIP_TCPIP_CORE_LOCKING */ -#define WRITE_DELAYED -#define WRITE_DELAYED_PARAM -#endif /* LWIP_TCPIP_CORE_LOCKING */ -static err_t lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM); -static err_t lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM); -#endif - -static void netconn_drain(struct netconn *conn); - -#if LWIP_TCPIP_CORE_LOCKING -#define TCPIP_APIMSG_ACK(m) -#else /* LWIP_TCPIP_CORE_LOCKING */ -#define TCPIP_APIMSG_ACK(m) do { sys_sem_signal(LWIP_API_MSG_SEM(m)); } while(0) -#endif /* LWIP_TCPIP_CORE_LOCKING */ - -#if LWIP_NETCONN_FULLDUPLEX -const u8_t netconn_deleted = 0; - -int -lwip_netconn_is_deallocated_msg(void *msg) -{ - if (msg == &netconn_deleted) { - return 1; - } - return 0; -} -#endif /* LWIP_NETCONN_FULLDUPLEX */ - -#if LWIP_TCP -const u8_t netconn_aborted = 0; -const u8_t netconn_reset = 0; -const u8_t netconn_closed = 0; - -/** Translate an error to a unique void* passed via an mbox */ -static void * -lwip_netconn_err_to_msg(err_t err) -{ - switch (err) { - case ERR_ABRT: - return LWIP_CONST_CAST(void *, &netconn_aborted); - case ERR_RST: - return LWIP_CONST_CAST(void *, &netconn_reset); - case ERR_CLSD: - return LWIP_CONST_CAST(void *, &netconn_closed); - default: - LWIP_ASSERT("unhandled error", err == ERR_OK); - return NULL; - } -} - -int -lwip_netconn_is_err_msg(void *msg, err_t *err) -{ - LWIP_ASSERT("err != NULL", err != NULL); - - if (msg == &netconn_aborted) { - *err = ERR_ABRT; - return 1; - } else if (msg == &netconn_reset) { - *err = ERR_RST; - return 1; - } else if (msg == &netconn_closed) { - *err = ERR_CLSD; - return 1; - } - return 0; -} -#endif /* LWIP_TCP */ - - -#if LWIP_RAW -/** - * Receive callback function for RAW netconns. - * Doesn't 'eat' the packet, only copies it and sends it to - * conn->recvmbox - * - * @see raw.h (struct raw_pcb.recv) for parameters and return value - */ -static u8_t -recv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p, - const ip_addr_t *addr) -{ - struct pbuf *q; - struct netbuf *buf; - struct netconn *conn; - - LWIP_UNUSED_ARG(addr); - conn = (struct netconn *)arg; - - if ((conn != NULL) && NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { -#if LWIP_SO_RCVBUF - int recv_avail; - SYS_ARCH_GET(conn->recv_avail, recv_avail); - if ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize) { - return 0; - } -#endif /* LWIP_SO_RCVBUF */ - /* copy the whole packet into new pbufs */ - q = pbuf_clone(PBUF_RAW, PBUF_RAM, p); - if (q != NULL) { - u16_t len; - buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); - if (buf == NULL) { - pbuf_free(q); - return 0; - } - - buf->p = q; - buf->ptr = q; - ip_addr_copy(buf->addr, *ip_current_src_addr()); - buf->port = pcb->protocol; - - len = q->tot_len; - if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) { - netbuf_delete(buf); - return 0; - } else { -#if LWIP_SO_RCVBUF - SYS_ARCH_INC(conn->recv_avail, len); -#endif /* LWIP_SO_RCVBUF */ - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); - } - } - } - - return 0; /* do not eat the packet */ -} -#endif /* LWIP_RAW*/ - -#if LWIP_UDP -/** - * Receive callback function for UDP netconns. - * Posts the packet to conn->recvmbox or deletes it on memory error. - * - * @see udp.h (struct udp_pcb.recv) for parameters - */ -static void -recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *addr, u16_t port) -{ - struct netbuf *buf; - struct netconn *conn; - u16_t len; -#if LWIP_SO_RCVBUF - int recv_avail; -#endif /* LWIP_SO_RCVBUF */ - - LWIP_UNUSED_ARG(pcb); /* only used for asserts... */ - LWIP_ASSERT("recv_udp must have a pcb argument", pcb != NULL); - LWIP_ASSERT("recv_udp must have an argument", arg != NULL); - conn = (struct netconn *)arg; - - if (conn == NULL) { - pbuf_free(p); - return; - } - - LWIP_ASSERT("recv_udp: recv for wrong pcb!", conn->pcb.udp == pcb); - -#if LWIP_SO_RCVBUF - SYS_ARCH_GET(conn->recv_avail, recv_avail); - if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox) || - ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize)) { -#else /* LWIP_SO_RCVBUF */ - if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { -#endif /* LWIP_SO_RCVBUF */ - pbuf_free(p); - return; - } - - buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); - if (buf == NULL) { - pbuf_free(p); - return; - } else { - buf->p = p; - buf->ptr = p; - ip_addr_set(&buf->addr, addr); - buf->port = port; -#if LWIP_NETBUF_RECVINFO - if (conn->flags & NETCONN_FLAG_PKTINFO) { - /* get the UDP header - always in the first pbuf, ensured by udp_input */ - const struct udp_hdr *udphdr = (const struct udp_hdr *)ip_next_header_ptr(); - buf->flags = NETBUF_FLAG_DESTADDR; - ip_addr_set(&buf->toaddr, ip_current_dest_addr()); - buf->toport_chksum = udphdr->dest; - } -#endif /* LWIP_NETBUF_RECVINFO */ - } - - len = p->tot_len; - if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) { - netbuf_delete(buf); - return; - } else { -#if LWIP_SO_RCVBUF - SYS_ARCH_INC(conn->recv_avail, len); -#endif /* LWIP_SO_RCVBUF */ - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); - } -} -#endif /* LWIP_UDP */ - -#if LWIP_TCP -/** - * Receive callback function for TCP netconns. - * Posts the packet to conn->recvmbox, but doesn't delete it on errors. - * - * @see tcp.h (struct tcp_pcb.recv) for parameters and return value - */ -static err_t -recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) -{ - struct netconn *conn; - u16_t len; - void *msg; - - LWIP_UNUSED_ARG(pcb); - LWIP_ASSERT("recv_tcp must have a pcb argument", pcb != NULL); - LWIP_ASSERT("recv_tcp must have an argument", arg != NULL); - LWIP_ASSERT("err != ERR_OK unhandled", err == ERR_OK); - LWIP_UNUSED_ARG(err); /* for LWIP_NOASSERT */ - conn = (struct netconn *)arg; - - if (conn == NULL) { - return ERR_VAL; - } - LWIP_ASSERT("recv_tcp: recv for wrong pcb!", conn->pcb.tcp == pcb); - - if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { - /* recvmbox already deleted */ - if (p != NULL) { - tcp_recved(pcb, p->tot_len); - pbuf_free(p); - } - return ERR_OK; - } - /* Unlike for UDP or RAW pcbs, don't check for available space - using recv_avail since that could break the connection - (data is already ACKed) */ - - if (p != NULL) { - msg = p; - len = p->tot_len; - } else { - msg = LWIP_CONST_CAST(void *, &netconn_closed); - len = 0; - } - - if (sys_mbox_trypost(&conn->recvmbox, msg) != ERR_OK) { - /* don't deallocate p: it is presented to us later again from tcp_fasttmr! */ - return ERR_MEM; - } else { -#if LWIP_SO_RCVBUF - SYS_ARCH_INC(conn->recv_avail, len); -#endif /* LWIP_SO_RCVBUF */ - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); - } - - return ERR_OK; -} - -/** - * Poll callback function for TCP netconns. - * Wakes up an application thread that waits for a connection to close - * or data to be sent. The application thread then takes the - * appropriate action to go on. - * - * Signals the conn->sem. - * netconn_close waits for conn->sem if closing failed. - * - * @see tcp.h (struct tcp_pcb.poll) for parameters and return value - */ -static err_t -poll_tcp(void *arg, struct tcp_pcb *pcb) -{ - struct netconn *conn = (struct netconn *)arg; - - LWIP_UNUSED_ARG(pcb); - LWIP_ASSERT("conn != NULL", (conn != NULL)); - - if (conn->state == NETCONN_WRITE) { - lwip_netconn_do_writemore(conn WRITE_DELAYED); - } else if (conn->state == NETCONN_CLOSE) { -#if !LWIP_SO_SNDTIMEO && !LWIP_SO_LINGER - if (conn->current_msg && conn->current_msg->msg.sd.polls_left) { - conn->current_msg->msg.sd.polls_left--; - } -#endif /* !LWIP_SO_SNDTIMEO && !LWIP_SO_LINGER */ - lwip_netconn_do_close_internal(conn WRITE_DELAYED); - } - /* @todo: implement connect timeout here? */ - - /* Did a nonblocking write fail before? Then check available write-space. */ - if (conn->flags & NETCONN_FLAG_CHECK_WRITESPACE) { - /* If the queued byte- or pbuf-count drops below the configured low-water limit, - let select mark this pcb as writable again. */ - if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) && - (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) { - netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE); - API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); - } - } - - return ERR_OK; -} - -/** - * Sent callback function for TCP netconns. - * Signals the conn->sem and calls API_EVENT. - * netconn_write waits for conn->sem if send buffer is low. - * - * @see tcp.h (struct tcp_pcb.sent) for parameters and return value - */ -static err_t -sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len) -{ - struct netconn *conn = (struct netconn *)arg; - - LWIP_UNUSED_ARG(pcb); - LWIP_ASSERT("conn != NULL", (conn != NULL)); - - if (conn) { - if (conn->state == NETCONN_WRITE) { - lwip_netconn_do_writemore(conn WRITE_DELAYED); - } else if (conn->state == NETCONN_CLOSE) { - lwip_netconn_do_close_internal(conn WRITE_DELAYED); - } - - /* If the queued byte- or pbuf-count drops below the configured low-water limit, - let select mark this pcb as writable again. */ - if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) && - (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) { - netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE); - API_EVENT(conn, NETCONN_EVT_SENDPLUS, len); - } - } - - return ERR_OK; -} - -/** - * Error callback function for TCP netconns. - * Signals conn->sem, posts to all conn mboxes and calls API_EVENT. - * The application thread has then to decide what to do. - * - * @see tcp.h (struct tcp_pcb.err) for parameters - */ -static void -err_tcp(void *arg, err_t err) -{ - struct netconn *conn; - enum netconn_state old_state; - void *mbox_msg; - SYS_ARCH_DECL_PROTECT(lev); - - conn = (struct netconn *)arg; - LWIP_ASSERT("conn != NULL", (conn != NULL)); - - SYS_ARCH_PROTECT(lev); - - /* when err is called, the pcb is deallocated, so delete the reference */ - conn->pcb.tcp = NULL; - /* store pending error */ - conn->pending_err = err; - /* prevent application threads from blocking on 'recvmbox'/'acceptmbox' */ - conn->flags |= NETCONN_FLAG_MBOXCLOSED; - - /* reset conn->state now before waking up other threads */ - old_state = conn->state; - conn->state = NETCONN_NONE; - - SYS_ARCH_UNPROTECT(lev); - - /* Notify the user layer about a connection error. Used to signal select. */ - API_EVENT(conn, NETCONN_EVT_ERROR, 0); - /* Try to release selects pending on 'read' or 'write', too. - They will get an error if they actually try to read or write. */ - API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); - API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); - - mbox_msg = lwip_netconn_err_to_msg(err); - /* pass error message to recvmbox to wake up pending recv */ - if (NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { - /* use trypost to prevent deadlock */ - sys_mbox_trypost(&conn->recvmbox, mbox_msg); - } - /* pass error message to acceptmbox to wake up pending accept */ - if (NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) { - /* use trypost to preven deadlock */ - sys_mbox_trypost(&conn->acceptmbox, mbox_msg); - } - - if ((old_state == NETCONN_WRITE) || (old_state == NETCONN_CLOSE) || - (old_state == NETCONN_CONNECT)) { - /* calling lwip_netconn_do_writemore/lwip_netconn_do_close_internal is not necessary - since the pcb has already been deleted! */ - int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn); - SET_NONBLOCKING_CONNECT(conn, 0); - - if (!was_nonblocking_connect) { - sys_sem_t *op_completed_sem; - /* set error return code */ - LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL); - if (old_state == NETCONN_CLOSE) { - /* let close succeed: the connection is closed after all... */ - conn->current_msg->err = ERR_OK; - } else { - /* Write and connect fail */ - conn->current_msg->err = err; - } - op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); - LWIP_ASSERT("inavlid op_completed_sem", sys_sem_valid(op_completed_sem)); - conn->current_msg = NULL; - /* wake up the waiting task */ - sys_sem_signal(op_completed_sem); - } else { - /* @todo: test what happens for error on nonblocking connect */ - } - } else { - LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL); - } -} - -/** - * Setup a tcp_pcb with the correct callback function pointers - * and their arguments. - * - * @param conn the TCP netconn to setup - */ -static void -setup_tcp(struct netconn *conn) -{ - struct tcp_pcb *pcb; - - pcb = conn->pcb.tcp; - tcp_arg(pcb, conn); - tcp_recv(pcb, recv_tcp); - tcp_sent(pcb, sent_tcp); - tcp_poll(pcb, poll_tcp, NETCONN_TCP_POLL_INTERVAL); - tcp_err(pcb, err_tcp); -} - -/** - * Accept callback function for TCP netconns. - * Allocates a new netconn and posts that to conn->acceptmbox. - * - * @see tcp.h (struct tcp_pcb_listen.accept) for parameters and return value - */ -static err_t -accept_function(void *arg, struct tcp_pcb *newpcb, err_t err) -{ - struct netconn *newconn; - struct netconn *conn = (struct netconn *)arg; - - if (conn == NULL) { - return ERR_VAL; - } - if (!NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) { - LWIP_DEBUGF(API_MSG_DEBUG, ("accept_function: acceptmbox already deleted\n")); - return ERR_VAL; - } - - if (newpcb == NULL) { - /* out-of-pcbs during connect: pass on this error to the application */ - if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) { - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); - } - return ERR_VAL; - } - LWIP_ASSERT("expect newpcb == NULL or err == ERR_OK", err == ERR_OK); - LWIP_UNUSED_ARG(err); /* for LWIP_NOASSERT */ - - LWIP_DEBUGF(API_MSG_DEBUG, ("accept_function: newpcb->state: %s\n", tcp_debug_state_str(newpcb->state))); - - /* We have to set the callback here even though - * the new socket is unknown. newconn->socket is marked as -1. */ - newconn = netconn_alloc(conn->type, conn->callback); - if (newconn == NULL) { - /* outof netconns: pass on this error to the application */ - if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) { - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); - } - return ERR_MEM; - } - newconn->pcb.tcp = newpcb; - setup_tcp(newconn); - - /* handle backlog counter */ - tcp_backlog_delayed(newpcb); - - if (sys_mbox_trypost(&conn->acceptmbox, newconn) != ERR_OK) { - /* When returning != ERR_OK, the pcb is aborted in tcp_process(), - so do nothing here! */ - /* remove all references to this netconn from the pcb */ - struct tcp_pcb *pcb = newconn->pcb.tcp; - tcp_arg(pcb, NULL); - tcp_recv(pcb, NULL); - tcp_sent(pcb, NULL); - tcp_poll(pcb, NULL, 0); - tcp_err(pcb, NULL); - /* remove reference from to the pcb from this netconn */ - newconn->pcb.tcp = NULL; - /* no need to drain since we know the recvmbox is empty. */ - sys_mbox_free(&newconn->recvmbox); - sys_mbox_set_invalid(&newconn->recvmbox); - netconn_free(newconn); - return ERR_MEM; - } else { - /* Register event with callback */ - API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); - } - - return ERR_OK; -} -#endif /* LWIP_TCP */ - -/** - * Create a new pcb of a specific type. - * Called from lwip_netconn_do_newconn(). - * - * @param msg the api_msg describing the connection type - */ -static void -pcb_new(struct api_msg *msg) -{ - enum lwip_ip_addr_type iptype = IPADDR_TYPE_V4; - - LWIP_ASSERT("pcb_new: pcb already allocated", msg->conn->pcb.tcp == NULL); - -#if LWIP_IPV6 && LWIP_IPV4 - /* IPv6: Dual-stack by default, unless netconn_set_ipv6only() is called */ - if (NETCONNTYPE_ISIPV6(netconn_type(msg->conn))) { - iptype = IPADDR_TYPE_ANY; - } -#endif - - /* Allocate a PCB for this connection */ - switch (NETCONNTYPE_GROUP(msg->conn->type)) { -#if LWIP_RAW - case NETCONN_RAW: - msg->conn->pcb.raw = raw_new_ip_type(iptype, msg->msg.n.proto); - if (msg->conn->pcb.raw != NULL) { -#if LWIP_IPV6 - /* ICMPv6 packets should always have checksum calculated by the stack as per RFC 3542 chapter 3.1 */ - if (NETCONNTYPE_ISIPV6(msg->conn->type) && msg->conn->pcb.raw->protocol == IP6_NEXTH_ICMP6) { - msg->conn->pcb.raw->chksum_reqd = 1; - msg->conn->pcb.raw->chksum_offset = 2; - } -#endif /* LWIP_IPV6 */ - raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn); - } - break; -#endif /* LWIP_RAW */ -#if LWIP_UDP - case NETCONN_UDP: - msg->conn->pcb.udp = udp_new_ip_type(iptype); - if (msg->conn->pcb.udp != NULL) { -#if LWIP_UDPLITE - if (NETCONNTYPE_ISUDPLITE(msg->conn->type)) { - udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE); - } -#endif /* LWIP_UDPLITE */ - if (NETCONNTYPE_ISUDPNOCHKSUM(msg->conn->type)) { - udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); - } - udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); - } - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case NETCONN_TCP: - msg->conn->pcb.tcp = tcp_new_ip_type(iptype); - if (msg->conn->pcb.tcp != NULL) { - setup_tcp(msg->conn); - } - break; -#endif /* LWIP_TCP */ - default: - /* Unsupported netconn type, e.g. protocol disabled */ - msg->err = ERR_VAL; - return; - } - if (msg->conn->pcb.ip == NULL) { - msg->err = ERR_MEM; - } -} - -/** - * Create a new pcb of a specific type inside a netconn. - * Called from netconn_new_with_proto_and_callback. - * - * @param m the api_msg describing the connection type - */ -void -lwip_netconn_do_newconn(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - msg->err = ERR_OK; - if (msg->conn->pcb.tcp == NULL) { - pcb_new(msg); - } - /* Else? This "new" connection already has a PCB allocated. */ - /* Is this an error condition? Should it be deleted? */ - /* We currently just are happy and return. */ - - TCPIP_APIMSG_ACK(msg); -} - -/** - * Create a new netconn (of a specific type) that has a callback function. - * The corresponding pcb is NOT created! - * - * @param t the type of 'connection' to create (@see enum netconn_type) - * @param callback a function to call on status changes (RX available, TX'ed) - * @return a newly allocated struct netconn or - * NULL on memory error - */ -struct netconn * -netconn_alloc(enum netconn_type t, netconn_callback callback) -{ - struct netconn *conn; - int size; - u8_t init_flags = 0; - - conn = (struct netconn *)memp_malloc(MEMP_NETCONN); - if (conn == NULL) { - return NULL; - } - - conn->pending_err = ERR_OK; - conn->type = t; - conn->pcb.tcp = NULL; - - /* If all sizes are the same, every compiler should optimize this switch to nothing */ - switch (NETCONNTYPE_GROUP(t)) { -#if LWIP_RAW - case NETCONN_RAW: - size = DEFAULT_RAW_RECVMBOX_SIZE; - break; -#endif /* LWIP_RAW */ -#if LWIP_UDP - case NETCONN_UDP: - size = DEFAULT_UDP_RECVMBOX_SIZE; -#if LWIP_NETBUF_RECVINFO - init_flags |= NETCONN_FLAG_PKTINFO; -#endif /* LWIP_NETBUF_RECVINFO */ - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case NETCONN_TCP: - size = DEFAULT_TCP_RECVMBOX_SIZE; - break; -#endif /* LWIP_TCP */ - default: - LWIP_ASSERT("netconn_alloc: undefined netconn_type", 0); - goto free_and_return; - } - - if (sys_mbox_new(&conn->recvmbox, size) != ERR_OK) { - goto free_and_return; - } -#if !LWIP_NETCONN_SEM_PER_THREAD - if (sys_sem_new(&conn->op_completed, 0) != ERR_OK) { - sys_mbox_free(&conn->recvmbox); - goto free_and_return; - } -#endif - -#if LWIP_TCP - sys_mbox_set_invalid(&conn->acceptmbox); -#endif - conn->state = NETCONN_NONE; -#if LWIP_SOCKET - /* initialize socket to -1 since 0 is a valid socket */ - conn->socket = -1; -#endif /* LWIP_SOCKET */ - conn->callback = callback; -#if LWIP_TCP - conn->current_msg = NULL; -#endif /* LWIP_TCP */ -#if LWIP_SO_SNDTIMEO - conn->send_timeout = 0; -#endif /* LWIP_SO_SNDTIMEO */ -#if LWIP_SO_RCVTIMEO - conn->recv_timeout = 0; -#endif /* LWIP_SO_RCVTIMEO */ -#if LWIP_SO_RCVBUF - conn->recv_bufsize = RECV_BUFSIZE_DEFAULT; - conn->recv_avail = 0; -#endif /* LWIP_SO_RCVBUF */ -#if LWIP_SO_LINGER - conn->linger = -1; -#endif /* LWIP_SO_LINGER */ - conn->flags = init_flags; - return conn; -free_and_return: - memp_free(MEMP_NETCONN, conn); - return NULL; -} - -/** - * Delete a netconn and all its resources. - * The pcb is NOT freed (since we might not be in the right thread context do this). - * - * @param conn the netconn to free - */ -void -netconn_free(struct netconn *conn) -{ - LWIP_ASSERT("PCB must be deallocated outside this function", conn->pcb.tcp == NULL); - -#if LWIP_NETCONN_FULLDUPLEX - /* in fullduplex, netconn is drained here */ - netconn_drain(conn); -#endif /* LWIP_NETCONN_FULLDUPLEX */ - - LWIP_ASSERT("recvmbox must be deallocated before calling this function", - !sys_mbox_valid(&conn->recvmbox)); -#if LWIP_TCP - LWIP_ASSERT("acceptmbox must be deallocated before calling this function", - !sys_mbox_valid(&conn->acceptmbox)); -#endif /* LWIP_TCP */ - -#if !LWIP_NETCONN_SEM_PER_THREAD - sys_sem_free(&conn->op_completed); - sys_sem_set_invalid(&conn->op_completed); -#endif - - memp_free(MEMP_NETCONN, conn); -} - -/** - * Delete rcvmbox and acceptmbox of a netconn and free the left-over data in - * these mboxes - * - * @param conn the netconn to free - * @bytes_drained bytes drained from recvmbox - * @accepts_drained pending connections drained from acceptmbox - */ -static void -netconn_drain(struct netconn *conn) -{ - void *mem; - - /* This runs when mbox and netconn are marked as closed, - so we don't need to lock against rx packets */ -#if LWIP_NETCONN_FULLDUPLEX - LWIP_ASSERT("netconn marked closed", conn->flags & NETCONN_FLAG_MBOXINVALID); -#endif /* LWIP_NETCONN_FULLDUPLEX */ - - /* Delete and drain the recvmbox. */ - if (sys_mbox_valid(&conn->recvmbox)) { - while (sys_mbox_tryfetch(&conn->recvmbox, &mem) != SYS_MBOX_EMPTY) { -#if LWIP_NETCONN_FULLDUPLEX - if (!lwip_netconn_is_deallocated_msg(mem)) -#endif /* LWIP_NETCONN_FULLDUPLEX */ - { -#if LWIP_TCP - if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) { - err_t err; - if (!lwip_netconn_is_err_msg(mem, &err)) { - pbuf_free((struct pbuf *)mem); - } - } else -#endif /* LWIP_TCP */ - { - netbuf_delete((struct netbuf *)mem); - } - } - } - sys_mbox_free(&conn->recvmbox); - sys_mbox_set_invalid(&conn->recvmbox); - } - - /* Delete and drain the acceptmbox. */ -#if LWIP_TCP - if (sys_mbox_valid(&conn->acceptmbox)) { - while (sys_mbox_tryfetch(&conn->acceptmbox, &mem) != SYS_MBOX_EMPTY) { -#if LWIP_NETCONN_FULLDUPLEX - if (!lwip_netconn_is_deallocated_msg(mem)) -#endif /* LWIP_NETCONN_FULLDUPLEX */ - { - err_t err; - if (!lwip_netconn_is_err_msg(mem, &err)) { - struct netconn *newconn = (struct netconn *)mem; - /* Only tcp pcbs have an acceptmbox, so no need to check conn->type */ - /* pcb might be set to NULL already by err_tcp() */ - /* drain recvmbox */ - netconn_drain(newconn); - if (newconn->pcb.tcp != NULL) { - tcp_abort(newconn->pcb.tcp); - newconn->pcb.tcp = NULL; - } - netconn_free(newconn); - } - } - } - sys_mbox_free(&conn->acceptmbox); - sys_mbox_set_invalid(&conn->acceptmbox); - } -#endif /* LWIP_TCP */ -} - -#if LWIP_NETCONN_FULLDUPLEX -static void -netconn_mark_mbox_invalid(struct netconn *conn) -{ - int i, num_waiting; - void *msg = LWIP_CONST_CAST(void *, &netconn_deleted); - - /* Prevent new calls/threads from reading from the mbox */ - conn->flags |= NETCONN_FLAG_MBOXINVALID; - - SYS_ARCH_LOCKED(num_waiting = conn->mbox_threads_waiting); - for (i = 0; i < num_waiting; i++) { - if (sys_mbox_valid_val(conn->recvmbox)) { - sys_mbox_trypost(&conn->recvmbox, msg); - } else { - sys_mbox_trypost(&conn->acceptmbox, msg); - } - } -} -#endif /* LWIP_NETCONN_FULLDUPLEX */ - -#if LWIP_TCP -/** - * Internal helper function to close a TCP netconn: since this sometimes - * doesn't work at the first attempt, this function is called from multiple - * places. - * - * @param conn the TCP netconn to close - */ -static err_t -lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM) -{ - err_t err; - u8_t shut, shut_rx, shut_tx, shut_close; - u8_t close_finished = 0; - struct tcp_pcb *tpcb; -#if LWIP_SO_LINGER - u8_t linger_wait_required = 0; -#endif /* LWIP_SO_LINGER */ - - LWIP_ASSERT("invalid conn", (conn != NULL)); - LWIP_ASSERT("this is for tcp netconns only", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP)); - LWIP_ASSERT("conn must be in state NETCONN_CLOSE", (conn->state == NETCONN_CLOSE)); - LWIP_ASSERT("pcb already closed", (conn->pcb.tcp != NULL)); - LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL); - - tpcb = conn->pcb.tcp; - shut = conn->current_msg->msg.sd.shut; - shut_rx = shut & NETCONN_SHUT_RD; - shut_tx = shut & NETCONN_SHUT_WR; - /* shutting down both ends is the same as closing - (also if RD or WR side was shut down before already) */ - if (shut == NETCONN_SHUT_RDWR) { - shut_close = 1; - } else if (shut_rx && - ((tpcb->state == FIN_WAIT_1) || - (tpcb->state == FIN_WAIT_2) || - (tpcb->state == CLOSING))) { - shut_close = 1; - } else if (shut_tx && ((tpcb->flags & TF_RXCLOSED) != 0)) { - shut_close = 1; - } else { - shut_close = 0; - } - - /* Set back some callback pointers */ - if (shut_close) { - tcp_arg(tpcb, NULL); - } - if (tpcb->state == LISTEN) { - tcp_accept(tpcb, NULL); - } else { - /* some callbacks have to be reset if tcp_close is not successful */ - if (shut_rx) { - tcp_recv(tpcb, NULL); - tcp_accept(tpcb, NULL); - } - if (shut_tx) { - tcp_sent(tpcb, NULL); - } - if (shut_close) { - tcp_poll(tpcb, NULL, 0); - tcp_err(tpcb, NULL); - } - } - /* Try to close the connection */ - if (shut_close) { -#if LWIP_SO_LINGER - /* check linger possibilites before calling tcp_close */ - err = ERR_OK; - /* linger enabled/required at all? (i.e. is there untransmitted data left?) */ - if ((conn->linger >= 0) && (conn->pcb.tcp->unsent || conn->pcb.tcp->unacked)) { - if ((conn->linger == 0)) { - /* data left but linger prevents waiting */ - tcp_abort(tpcb); - tpcb = NULL; - } else if (conn->linger > 0) { - /* data left and linger says we should wait */ - if (netconn_is_nonblocking(conn)) { - /* data left on a nonblocking netconn -> cannot linger */ - err = ERR_WOULDBLOCK; - } else if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >= - (conn->linger * 1000)) { - /* data left but linger timeout has expired (this happens on further - calls to this function through poll_tcp */ - tcp_abort(tpcb); - tpcb = NULL; - } else { - /* data left -> need to wait for ACK after successful close */ - linger_wait_required = 1; - } - } - } - if ((err == ERR_OK) && (tpcb != NULL)) -#endif /* LWIP_SO_LINGER */ - { - err = tcp_close(tpcb); - } - } else { - err = tcp_shutdown(tpcb, shut_rx, shut_tx); - } - if (err == ERR_OK) { - close_finished = 1; -#if LWIP_SO_LINGER - if (linger_wait_required) { - /* wait for ACK of all unsent/unacked data by just getting called again */ - close_finished = 0; - err = ERR_INPROGRESS; - } -#endif /* LWIP_SO_LINGER */ - } else { - if (err == ERR_MEM) { - /* Closing failed because of memory shortage, try again later. Even for - nonblocking netconns, we have to wait since no standard socket application - is prepared for close failing because of resource shortage. - Check the timeout: this is kind of an lwip addition to the standard sockets: - we wait for some time when failing to allocate a segment for the FIN */ -#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER - s32_t close_timeout = LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT; -#if LWIP_SO_SNDTIMEO - if (conn->send_timeout > 0) { - close_timeout = conn->send_timeout; - } -#endif /* LWIP_SO_SNDTIMEO */ -#if LWIP_SO_LINGER - if (conn->linger >= 0) { - /* use linger timeout (seconds) */ - close_timeout = conn->linger * 1000U; - } -#endif - if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >= close_timeout) { -#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ - if (conn->current_msg->msg.sd.polls_left == 0) { -#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ - close_finished = 1; - if (shut_close) { - /* in this case, we want to RST the connection */ - tcp_abort(tpcb); - err = ERR_OK; - } - } - } else { - /* Closing failed for a non-memory error: give up */ - close_finished = 1; - } - } - if (close_finished) { - /* Closing done (succeeded, non-memory error, nonblocking error or timeout) */ - sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); - conn->current_msg->err = err; - conn->current_msg = NULL; - conn->state = NETCONN_NONE; - if (err == ERR_OK) { - if (shut_close) { - /* Set back some callback pointers as conn is going away */ - conn->pcb.tcp = NULL; - /* Trigger select() in socket layer. Make sure everybody notices activity - on the connection, error first! */ - API_EVENT(conn, NETCONN_EVT_ERROR, 0); - } - if (shut_rx) { - API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); - } - if (shut_tx) { - API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); - } - } -#if LWIP_TCPIP_CORE_LOCKING - if (delayed) -#endif - { - /* wake up the application task */ - sys_sem_signal(op_completed_sem); - } - return ERR_OK; - } - if (!close_finished) { - /* Closing failed and we want to wait: restore some of the callbacks */ - /* Closing of listen pcb will never fail! */ - LWIP_ASSERT("Closing a listen pcb may not fail!", (tpcb->state != LISTEN)); - if (shut_tx) { - tcp_sent(tpcb, sent_tcp); - } - /* when waiting for close, set up poll interval to 500ms */ - tcp_poll(tpcb, poll_tcp, 1); - tcp_err(tpcb, err_tcp); - tcp_arg(tpcb, conn); - /* don't restore recv callback: we don't want to receive any more data */ - } - /* If closing didn't succeed, we get called again either - from poll_tcp or from sent_tcp */ - LWIP_ASSERT("err != ERR_OK", err != ERR_OK); - return err; -} -#endif /* LWIP_TCP */ - -/** - * Delete the pcb inside a netconn. - * Called from netconn_delete. - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_delconn(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - enum netconn_state state = msg->conn->state; - LWIP_ASSERT("netconn state error", /* this only happens for TCP netconns */ - (state == NETCONN_NONE) || (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP)); -#if LWIP_NETCONN_FULLDUPLEX - /* In full duplex mode, blocking write/connect is aborted with ERR_CLSD */ - if (state != NETCONN_NONE) { - if ((state == NETCONN_WRITE) || - ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) { - /* close requested, abort running write/connect */ - sys_sem_t *op_completed_sem; - LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL); - op_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg); - msg->conn->current_msg->err = ERR_CLSD; - msg->conn->current_msg = NULL; - msg->conn->state = NETCONN_NONE; - sys_sem_signal(op_completed_sem); - } - } -#else /* LWIP_NETCONN_FULLDUPLEX */ - if (((state != NETCONN_NONE) && - (state != NETCONN_LISTEN) && - (state != NETCONN_CONNECT)) || - ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) { - /* This means either a blocking write or blocking connect is running - (nonblocking write returns and sets state to NONE) */ - msg->err = ERR_INPROGRESS; - } else -#endif /* LWIP_NETCONN_FULLDUPLEX */ - { - LWIP_ASSERT("blocking connect in progress", - (state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn)); - msg->err = ERR_OK; -#if LWIP_NETCONN_FULLDUPLEX - /* Mark mboxes invalid */ - netconn_mark_mbox_invalid(msg->conn); -#else /* LWIP_NETCONN_FULLDUPLEX */ - netconn_drain(msg->conn); -#endif /* LWIP_NETCONN_FULLDUPLEX */ - - if (msg->conn->pcb.tcp != NULL) { - - switch (NETCONNTYPE_GROUP(msg->conn->type)) { -#if LWIP_RAW - case NETCONN_RAW: - raw_remove(msg->conn->pcb.raw); - break; -#endif /* LWIP_RAW */ -#if LWIP_UDP - case NETCONN_UDP: - msg->conn->pcb.udp->recv_arg = NULL; - udp_remove(msg->conn->pcb.udp); - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case NETCONN_TCP: - LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL); - msg->conn->state = NETCONN_CLOSE; - msg->msg.sd.shut = NETCONN_SHUT_RDWR; - msg->conn->current_msg = msg; -#if LWIP_TCPIP_CORE_LOCKING - if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) { - LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE); - UNLOCK_TCPIP_CORE(); - sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); - LOCK_TCPIP_CORE(); - LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE); - } -#else /* LWIP_TCPIP_CORE_LOCKING */ - lwip_netconn_do_close_internal(msg->conn); -#endif /* LWIP_TCPIP_CORE_LOCKING */ - /* API_EVENT is called inside lwip_netconn_do_close_internal, before releasing - the application thread, so we can return at this point! */ - return; -#endif /* LWIP_TCP */ - default: - break; - } - msg->conn->pcb.tcp = NULL; - } - /* tcp netconns don't come here! */ - - /* @todo: this lets select make the socket readable and writable, - which is wrong! errfd instead? */ - API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0); - API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0); - } - if (sys_sem_valid(LWIP_API_MSG_SEM(msg))) { - TCPIP_APIMSG_ACK(msg); - } -} - -/** - * Bind a pcb contained in a netconn - * Called from netconn_bind. - * - * @param m the api_msg pointing to the connection and containing - * the IP address and port to bind to - */ -void -lwip_netconn_do_bind(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - err_t err; - - if (msg->conn->pcb.tcp != NULL) { - switch (NETCONNTYPE_GROUP(msg->conn->type)) { -#if LWIP_RAW - case NETCONN_RAW: - err = raw_bind(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr)); - break; -#endif /* LWIP_RAW */ -#if LWIP_UDP - case NETCONN_UDP: - err = udp_bind(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port); - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case NETCONN_TCP: - err = tcp_bind(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port); - break; -#endif /* LWIP_TCP */ - default: - err = ERR_VAL; - break; - } - } else { - err = ERR_VAL; - } - msg->err = err; - TCPIP_APIMSG_ACK(msg); -} -/** - * Bind a pcb contained in a netconn to an interface - * Called from netconn_bind_if. - * - * @param m the api_msg pointing to the connection and containing - * the IP address and port to bind to - */ -void -lwip_netconn_do_bind_if(void *m) -{ - struct netif *netif; - struct api_msg *msg = (struct api_msg *)m; - err_t err; - - netif = netif_get_by_index(msg->msg.bc.if_idx); - - if ((netif != NULL) && (msg->conn->pcb.tcp != NULL)) { - err = ERR_OK; - switch (NETCONNTYPE_GROUP(msg->conn->type)) { -#if LWIP_RAW - case NETCONN_RAW: - raw_bind_netif(msg->conn->pcb.raw, netif); - break; -#endif /* LWIP_RAW */ -#if LWIP_UDP - case NETCONN_UDP: - udp_bind_netif(msg->conn->pcb.udp, netif); - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case NETCONN_TCP: - tcp_bind_netif(msg->conn->pcb.tcp, netif); - break; -#endif /* LWIP_TCP */ - default: - err = ERR_VAL; - break; - } - } else { - err = ERR_VAL; - } - msg->err = err; - TCPIP_APIMSG_ACK(msg); -} - -#if LWIP_TCP -/** - * TCP callback function if a connection (opened by tcp_connect/lwip_netconn_do_connect) has - * been established (or reset by the remote host). - * - * @see tcp.h (struct tcp_pcb.connected) for parameters and return values - */ -static err_t -lwip_netconn_do_connected(void *arg, struct tcp_pcb *pcb, err_t err) -{ - struct netconn *conn; - int was_blocking; - sys_sem_t *op_completed_sem = NULL; - - LWIP_UNUSED_ARG(pcb); - - conn = (struct netconn *)arg; - - if (conn == NULL) { - return ERR_VAL; - } - - LWIP_ASSERT("conn->state == NETCONN_CONNECT", conn->state == NETCONN_CONNECT); - LWIP_ASSERT("(conn->current_msg != NULL) || conn->in_non_blocking_connect", - (conn->current_msg != NULL) || IN_NONBLOCKING_CONNECT(conn)); - - if (conn->current_msg != NULL) { - conn->current_msg->err = err; - op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); - } - if ((NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) && (err == ERR_OK)) { - setup_tcp(conn); - } - was_blocking = !IN_NONBLOCKING_CONNECT(conn); - SET_NONBLOCKING_CONNECT(conn, 0); - LWIP_ASSERT("blocking connect state error", - (was_blocking && op_completed_sem != NULL) || - (!was_blocking && op_completed_sem == NULL)); - conn->current_msg = NULL; - conn->state = NETCONN_NONE; - API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); - - if (was_blocking) { - sys_sem_signal(op_completed_sem); - } - return ERR_OK; -} -#endif /* LWIP_TCP */ - -/** - * Connect a pcb contained inside a netconn - * Called from netconn_connect. - * - * @param m the api_msg pointing to the connection and containing - * the IP address and port to connect to - */ -void -lwip_netconn_do_connect(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - err_t err; - - if (msg->conn->pcb.tcp == NULL) { - /* This may happen when calling netconn_connect() a second time */ - err = ERR_CLSD; - } else { - switch (NETCONNTYPE_GROUP(msg->conn->type)) { -#if LWIP_RAW - case NETCONN_RAW: - err = raw_connect(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr)); - break; -#endif /* LWIP_RAW */ -#if LWIP_UDP - case NETCONN_UDP: - err = udp_connect(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port); - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case NETCONN_TCP: - /* Prevent connect while doing any other action. */ - if (msg->conn->state == NETCONN_CONNECT) { - err = ERR_ALREADY; - } else if (msg->conn->state != NETCONN_NONE) { - err = ERR_ISCONN; - } else { - setup_tcp(msg->conn); - err = tcp_connect(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr), - msg->msg.bc.port, lwip_netconn_do_connected); - if (err == ERR_OK) { - u8_t non_blocking = netconn_is_nonblocking(msg->conn); - msg->conn->state = NETCONN_CONNECT; - SET_NONBLOCKING_CONNECT(msg->conn, non_blocking); - if (non_blocking) { - err = ERR_INPROGRESS; - } else { - msg->conn->current_msg = msg; - /* sys_sem_signal() is called from lwip_netconn_do_connected (or err_tcp()), - when the connection is established! */ -#if LWIP_TCPIP_CORE_LOCKING - LWIP_ASSERT("state!", msg->conn->state == NETCONN_CONNECT); - UNLOCK_TCPIP_CORE(); - sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); - LOCK_TCPIP_CORE(); - LWIP_ASSERT("state!", msg->conn->state != NETCONN_CONNECT); -#endif /* LWIP_TCPIP_CORE_LOCKING */ - return; - } - } - } - break; -#endif /* LWIP_TCP */ - default: - LWIP_ERROR("Invalid netconn type", 0, do { - err = ERR_VAL; - } while (0)); - break; - } - } - msg->err = err; - /* For all other protocols, netconn_connect() calls netconn_apimsg(), - so use TCPIP_APIMSG_ACK() here. */ - TCPIP_APIMSG_ACK(msg); -} - -/** - * Disconnect a pcb contained inside a netconn - * Only used for UDP netconns. - * Called from netconn_disconnect. - * - * @param m the api_msg pointing to the connection to disconnect - */ -void -lwip_netconn_do_disconnect(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - -#if LWIP_UDP - if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) { - udp_disconnect(msg->conn->pcb.udp); - msg->err = ERR_OK; - } else -#endif /* LWIP_UDP */ - { - msg->err = ERR_VAL; - } - TCPIP_APIMSG_ACK(msg); -} - -#if LWIP_TCP -/** - * Set a TCP pcb contained in a netconn into listen mode - * Called from netconn_listen. - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_listen(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - err_t err; - - if (msg->conn->pcb.tcp != NULL) { - if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { - if (msg->conn->state == NETCONN_NONE) { - struct tcp_pcb *lpcb; - if (msg->conn->pcb.tcp->state != CLOSED) { - /* connection is not closed, cannot listen */ - err = ERR_VAL; - } else { - u8_t backlog; -#if TCP_LISTEN_BACKLOG - backlog = msg->msg.lb.backlog; -#else /* TCP_LISTEN_BACKLOG */ - backlog = TCP_DEFAULT_LISTEN_BACKLOG; -#endif /* TCP_LISTEN_BACKLOG */ -#if LWIP_IPV4 && LWIP_IPV6 - /* "Socket API like" dual-stack support: If IP to listen to is IP6_ADDR_ANY, - * and NETCONN_FLAG_IPV6_V6ONLY is NOT set, use IP_ANY_TYPE to listen - */ - if (ip_addr_cmp(&msg->conn->pcb.ip->local_ip, IP6_ADDR_ANY) && - (netconn_get_ipv6only(msg->conn) == 0)) { - /* change PCB type to IPADDR_TYPE_ANY */ - IP_SET_TYPE_VAL(msg->conn->pcb.tcp->local_ip, IPADDR_TYPE_ANY); - IP_SET_TYPE_VAL(msg->conn->pcb.tcp->remote_ip, IPADDR_TYPE_ANY); - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - lpcb = tcp_listen_with_backlog_and_err(msg->conn->pcb.tcp, backlog, &err); - - if (lpcb == NULL) { - /* in this case, the old pcb is still allocated */ - } else { - /* delete the recvmbox and allocate the acceptmbox */ - if (sys_mbox_valid(&msg->conn->recvmbox)) { - /** @todo: should we drain the recvmbox here? */ - sys_mbox_free(&msg->conn->recvmbox); - sys_mbox_set_invalid(&msg->conn->recvmbox); - } - err = ERR_OK; - if (!sys_mbox_valid(&msg->conn->acceptmbox)) { - err = sys_mbox_new(&msg->conn->acceptmbox, DEFAULT_ACCEPTMBOX_SIZE); - } - if (err == ERR_OK) { - msg->conn->state = NETCONN_LISTEN; - msg->conn->pcb.tcp = lpcb; - tcp_arg(msg->conn->pcb.tcp, msg->conn); - tcp_accept(msg->conn->pcb.tcp, accept_function); - } else { - /* since the old pcb is already deallocated, free lpcb now */ - tcp_close(lpcb); - msg->conn->pcb.tcp = NULL; - } - } - } - } else if (msg->conn->state == NETCONN_LISTEN) { - /* already listening, allow updating of the backlog */ - err = ERR_OK; - tcp_backlog_set(msg->conn->pcb.tcp, msg->msg.lb.backlog); - } else { - err = ERR_CONN; - } - } else { - err = ERR_ARG; - } - } else { - err = ERR_CONN; - } - msg->err = err; - TCPIP_APIMSG_ACK(msg); -} -#endif /* LWIP_TCP */ - -/** - * Send some data on a RAW or UDP pcb contained in a netconn - * Called from netconn_send - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_send(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - err_t err = netconn_err(msg->conn); - if (err == ERR_OK) { - if (msg->conn->pcb.tcp != NULL) { - switch (NETCONNTYPE_GROUP(msg->conn->type)) { -#if LWIP_RAW - case NETCONN_RAW: - if (ip_addr_isany(&msg->msg.b->addr) || IP_IS_ANY_TYPE_VAL(msg->msg.b->addr)) { - err = raw_send(msg->conn->pcb.raw, msg->msg.b->p); - } else { - err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, &msg->msg.b->addr); - } - break; -#endif -#if LWIP_UDP - case NETCONN_UDP: -#if LWIP_CHECKSUM_ON_COPY - if (ip_addr_isany(&msg->msg.b->addr) || IP_IS_ANY_TYPE_VAL(msg->msg.b->addr)) { - err = udp_send_chksum(msg->conn->pcb.udp, msg->msg.b->p, - msg->msg.b->flags & NETBUF_FLAG_CHKSUM, msg->msg.b->toport_chksum); - } else { - err = udp_sendto_chksum(msg->conn->pcb.udp, msg->msg.b->p, - &msg->msg.b->addr, msg->msg.b->port, - msg->msg.b->flags & NETBUF_FLAG_CHKSUM, msg->msg.b->toport_chksum); - } -#else /* LWIP_CHECKSUM_ON_COPY */ - if (ip_addr_isany_val(msg->msg.b->addr) || IP_IS_ANY_TYPE_VAL(msg->msg.b->addr)) { - err = udp_send(msg->conn->pcb.udp, msg->msg.b->p); - } else { - err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port); - } -#endif /* LWIP_CHECKSUM_ON_COPY */ - break; -#endif /* LWIP_UDP */ - default: - err = ERR_CONN; - break; - } - } else { - err = ERR_CONN; - } - } - msg->err = err; - TCPIP_APIMSG_ACK(msg); -} - -#if LWIP_TCP -/** - * Indicate data has been received from a TCP pcb contained in a netconn - * Called from netconn_recv - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_recv(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - msg->err = ERR_OK; - if (msg->conn->pcb.tcp != NULL) { - if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { - size_t remaining = msg->msg.r.len; - do { - u16_t recved = (u16_t)((remaining > 0xffff) ? 0xffff : remaining); - tcp_recved(msg->conn->pcb.tcp, recved); - remaining -= recved; - } while (remaining != 0); - } - } - TCPIP_APIMSG_ACK(msg); -} - -#if TCP_LISTEN_BACKLOG -/** Indicate that a TCP pcb has been accepted - * Called from netconn_accept - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_accepted(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - msg->err = ERR_OK; - if (msg->conn->pcb.tcp != NULL) { - if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { - tcp_backlog_accepted(msg->conn->pcb.tcp); - } - } - TCPIP_APIMSG_ACK(msg); -} -#endif /* TCP_LISTEN_BACKLOG */ - -/** - * See if more data needs to be written from a previous call to netconn_write. - * Called initially from lwip_netconn_do_write. If the first call can't send all data - * (because of low memory or empty send-buffer), this function is called again - * from sent_tcp() or poll_tcp() to send more data. If all data is sent, the - * blocking application thread (waiting in netconn_write) is released. - * - * @param conn netconn (that is currently in state NETCONN_WRITE) to process - * @return ERR_OK - * ERR_MEM if LWIP_TCPIP_CORE_LOCKING=1 and sending hasn't yet finished - */ -static err_t -lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM) -{ - err_t err; - const void *dataptr; - u16_t len, available; - u8_t write_finished = 0; - size_t diff; - u8_t dontblock; - u8_t apiflags; - u8_t write_more; - - LWIP_ASSERT("conn != NULL", conn != NULL); - LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE)); - LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL); - LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL); - LWIP_ASSERT("conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len", - conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len); - LWIP_ASSERT("conn->current_msg->msg.w.vector_cnt > 0", conn->current_msg->msg.w.vector_cnt > 0); - - apiflags = conn->current_msg->msg.w.apiflags; - dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK); - -#if LWIP_SO_SNDTIMEO - if ((conn->send_timeout != 0) && - ((s32_t)(sys_now() - conn->current_msg->msg.w.time_started) >= conn->send_timeout)) { - write_finished = 1; - if (conn->current_msg->msg.w.offset == 0) { - /* nothing has been written */ - err = ERR_WOULDBLOCK; - } else { - /* partial write */ - err = ERR_OK; - } - } else -#endif /* LWIP_SO_SNDTIMEO */ - { - do { - dataptr = (const u8_t *)conn->current_msg->msg.w.vector->ptr + conn->current_msg->msg.w.vector_off; - diff = conn->current_msg->msg.w.vector->len - conn->current_msg->msg.w.vector_off; - if (diff > 0xffffUL) { /* max_u16_t */ - len = 0xffff; - apiflags |= TCP_WRITE_FLAG_MORE; - } else { - len = (u16_t)diff; - } - available = tcp_sndbuf(conn->pcb.tcp); - if (available < len) { - /* don't try to write more than sendbuf */ - len = available; - if (dontblock) { - if (!len) { - /* set error according to partial write or not */ - err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK; - goto err_mem; - } - } else { - apiflags |= TCP_WRITE_FLAG_MORE; - } - } - LWIP_ASSERT("lwip_netconn_do_writemore: invalid length!", - ((conn->current_msg->msg.w.vector_off + len) <= conn->current_msg->msg.w.vector->len)); - /* we should loop around for more sending in the following cases: - 1) We couldn't finish the current vector because of 16-bit size limitations. - tcp_write() and tcp_sndbuf() both are limited to 16-bit sizes - 2) We are sending the remainder of the current vector and have more */ - if ((len == 0xffff && diff > 0xffffUL) || - (len == (u16_t)diff && conn->current_msg->msg.w.vector_cnt > 1)) { - write_more = 1; - apiflags |= TCP_WRITE_FLAG_MORE; - } else { - write_more = 0; - } - err = tcp_write(conn->pcb.tcp, dataptr, len, apiflags); - if (err == ERR_OK) { - conn->current_msg->msg.w.offset += len; - conn->current_msg->msg.w.vector_off += len; - /* check if current vector is finished */ - if (conn->current_msg->msg.w.vector_off == conn->current_msg->msg.w.vector->len) { - conn->current_msg->msg.w.vector_cnt--; - /* if we have additional vectors, move on to them */ - if (conn->current_msg->msg.w.vector_cnt > 0) { - conn->current_msg->msg.w.vector++; - conn->current_msg->msg.w.vector_off = 0; - } - } - } - } while (write_more && err == ERR_OK); - /* if OK or memory error, check available space */ - if ((err == ERR_OK) || (err == ERR_MEM)) { -err_mem: - if (dontblock && (conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len)) { - /* non-blocking write did not write everything: mark the pcb non-writable - and let poll_tcp check writable space to mark the pcb writable again */ - API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0); - conn->flags |= NETCONN_FLAG_CHECK_WRITESPACE; - } else if ((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) || - (tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) { - /* The queued byte- or pbuf-count exceeds the configured low-water limit, - let select mark this pcb as non-writable. */ - API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0); - } - } - - if (err == ERR_OK) { - err_t out_err; - if ((conn->current_msg->msg.w.offset == conn->current_msg->msg.w.len) || dontblock) { - /* return sent length (caller reads length from msg.w.offset) */ - write_finished = 1; - } - out_err = tcp_output(conn->pcb.tcp); - if (out_err == ERR_RTE) { - /* If tcp_output fails because no route is found, - don't try writing any more but return the error - to the application thread. */ - err = out_err; - write_finished = 1; - } - } else if (err == ERR_MEM) { - /* If ERR_MEM, we wait for sent_tcp or poll_tcp to be called. - For blocking sockets, we do NOT return to the application - thread, since ERR_MEM is only a temporary error! Non-blocking - will remain non-writable until sent_tcp/poll_tcp is called */ - - /* tcp_write returned ERR_MEM, try tcp_output anyway */ - err_t out_err = tcp_output(conn->pcb.tcp); - if (out_err == ERR_RTE) { - /* If tcp_output fails because no route is found, - don't try writing any more but return the error - to the application thread. */ - err = out_err; - write_finished = 1; - } else if (dontblock) { - /* non-blocking write is done on ERR_MEM, set error according - to partial write or not */ - err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK; - write_finished = 1; - } - } else { - /* On errors != ERR_MEM, we don't try writing any more but return - the error to the application thread. */ - write_finished = 1; - } - } - if (write_finished) { - /* everything was written: set back connection state - and back to application task */ - sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); - conn->current_msg->err = err; - conn->current_msg = NULL; - conn->state = NETCONN_NONE; -#if LWIP_TCPIP_CORE_LOCKING - if (delayed) -#endif - { - sys_sem_signal(op_completed_sem); - } - } -#if LWIP_TCPIP_CORE_LOCKING - else { - return ERR_MEM; - } -#endif - return ERR_OK; -} -#endif /* LWIP_TCP */ - -/** - * Send some data on a TCP pcb contained in a netconn - * Called from netconn_write - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_write(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - err_t err = netconn_err(msg->conn); - if (err == ERR_OK) { - if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { -#if LWIP_TCP - if (msg->conn->state != NETCONN_NONE) { - /* netconn is connecting, closing or in blocking write */ - err = ERR_INPROGRESS; - } else if (msg->conn->pcb.tcp != NULL) { - msg->conn->state = NETCONN_WRITE; - /* set all the variables used by lwip_netconn_do_writemore */ - LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL); - LWIP_ASSERT("msg->msg.w.len != 0", msg->msg.w.len != 0); - msg->conn->current_msg = msg; -#if LWIP_TCPIP_CORE_LOCKING - if (lwip_netconn_do_writemore(msg->conn, 0) != ERR_OK) { - LWIP_ASSERT("state!", msg->conn->state == NETCONN_WRITE); - UNLOCK_TCPIP_CORE(); - sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); - LOCK_TCPIP_CORE(); - LWIP_ASSERT("state!", msg->conn->state != NETCONN_WRITE); - } -#else /* LWIP_TCPIP_CORE_LOCKING */ - lwip_netconn_do_writemore(msg->conn); -#endif /* LWIP_TCPIP_CORE_LOCKING */ - /* for both cases: if lwip_netconn_do_writemore was called, don't ACK the APIMSG - since lwip_netconn_do_writemore ACKs it! */ - return; - } else { - err = ERR_CONN; - } -#else /* LWIP_TCP */ - err = ERR_VAL; -#endif /* LWIP_TCP */ -#if (LWIP_UDP || LWIP_RAW) - } else { - err = ERR_VAL; -#endif /* (LWIP_UDP || LWIP_RAW) */ - } - } - msg->err = err; - TCPIP_APIMSG_ACK(msg); -} - -/** - * Return a connection's local or remote address - * Called from netconn_getaddr - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_getaddr(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - if (msg->conn->pcb.ip != NULL) { - if (msg->msg.ad.local) { - ip_addr_copy(API_EXPR_DEREF(msg->msg.ad.ipaddr), - msg->conn->pcb.ip->local_ip); - } else { - ip_addr_copy(API_EXPR_DEREF(msg->msg.ad.ipaddr), - msg->conn->pcb.ip->remote_ip); - } - - msg->err = ERR_OK; - switch (NETCONNTYPE_GROUP(msg->conn->type)) { -#if LWIP_RAW - case NETCONN_RAW: - if (msg->msg.ad.local) { - API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.raw->protocol; - } else { - /* return an error as connecting is only a helper for upper layers */ - msg->err = ERR_CONN; - } - break; -#endif /* LWIP_RAW */ -#if LWIP_UDP - case NETCONN_UDP: - if (msg->msg.ad.local) { - API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->local_port; - } else { - if ((msg->conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0) { - msg->err = ERR_CONN; - } else { - API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->remote_port; - } - } - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case NETCONN_TCP: - if ((msg->msg.ad.local == 0) && - ((msg->conn->pcb.tcp->state == CLOSED) || (msg->conn->pcb.tcp->state == LISTEN))) { - /* pcb is not connected and remote name is requested */ - msg->err = ERR_CONN; - } else { - API_EXPR_DEREF(msg->msg.ad.port) = (msg->msg.ad.local ? msg->conn->pcb.tcp->local_port : msg->conn->pcb.tcp->remote_port); - } - break; -#endif /* LWIP_TCP */ - default: - LWIP_ASSERT("invalid netconn_type", 0); - break; - } - } else { - msg->err = ERR_CONN; - } - TCPIP_APIMSG_ACK(msg); -} - -/** - * Close or half-shutdown a TCP pcb contained in a netconn - * Called from netconn_close - * In contrast to closing sockets, the netconn is not deallocated. - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_close(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - -#if LWIP_TCP - enum netconn_state state = msg->conn->state; - /* First check if this is a TCP netconn and if it is in a correct state - (LISTEN doesn't support half shutdown) */ - if ((msg->conn->pcb.tcp != NULL) && - (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) && - ((msg->msg.sd.shut == NETCONN_SHUT_RDWR) || (state != NETCONN_LISTEN))) { - /* Check if we are in a connected state */ - if (state == NETCONN_CONNECT) { - /* TCP connect in progress: cannot shutdown */ - msg->err = ERR_CONN; - } else if (state == NETCONN_WRITE) { -#if LWIP_NETCONN_FULLDUPLEX - if (msg->msg.sd.shut & NETCONN_SHUT_WR) { - /* close requested, abort running write */ - sys_sem_t *write_completed_sem; - LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL); - write_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg); - msg->conn->current_msg->err = ERR_CLSD; - msg->conn->current_msg = NULL; - msg->conn->state = NETCONN_NONE; - state = NETCONN_NONE; - sys_sem_signal(write_completed_sem); - } else { - LWIP_ASSERT("msg->msg.sd.shut == NETCONN_SHUT_RD", msg->msg.sd.shut == NETCONN_SHUT_RD); - /* In this case, let the write continue and do not interfere with - conn->current_msg or conn->state! */ - msg->err = tcp_shutdown(msg->conn->pcb.tcp, 1, 0); - } - } - if (state == NETCONN_NONE) { -#else /* LWIP_NETCONN_FULLDUPLEX */ - msg->err = ERR_INPROGRESS; - } else { -#endif /* LWIP_NETCONN_FULLDUPLEX */ - if (msg->msg.sd.shut & NETCONN_SHUT_RD) { -#if LWIP_NETCONN_FULLDUPLEX - /* Mark mboxes invalid */ - netconn_mark_mbox_invalid(msg->conn); -#else /* LWIP_NETCONN_FULLDUPLEX */ - netconn_drain(msg->conn); -#endif /* LWIP_NETCONN_FULLDUPLEX */ - } - LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL); - msg->conn->state = NETCONN_CLOSE; - msg->conn->current_msg = msg; -#if LWIP_TCPIP_CORE_LOCKING - if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) { - LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE); - UNLOCK_TCPIP_CORE(); - sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); - LOCK_TCPIP_CORE(); - LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE); - } -#else /* LWIP_TCPIP_CORE_LOCKING */ - lwip_netconn_do_close_internal(msg->conn); -#endif /* LWIP_TCPIP_CORE_LOCKING */ - /* for tcp netconns, lwip_netconn_do_close_internal ACKs the message */ - return; - } - } else -#endif /* LWIP_TCP */ - { - msg->err = ERR_CONN; - } - TCPIP_APIMSG_ACK(msg); -} - -#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) -/** - * Join multicast groups for UDP netconns. - * Called from netconn_join_leave_group - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_join_leave_group(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - - msg->err = ERR_CONN; - if (msg->conn->pcb.tcp != NULL) { - if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) { -#if LWIP_UDP -#if LWIP_IPV6 && LWIP_IPV6_MLD - if (NETCONNTYPE_ISIPV6(msg->conn->type)) { - if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { - msg->err = mld6_joingroup(ip_2_ip6(API_EXPR_REF(msg->msg.jl.netif_addr)), - ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); - } else { - msg->err = mld6_leavegroup(ip_2_ip6(API_EXPR_REF(msg->msg.jl.netif_addr)), - ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); - } - } else -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ - { -#if LWIP_IGMP - if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { - msg->err = igmp_joingroup(ip_2_ip4(API_EXPR_REF(msg->msg.jl.netif_addr)), - ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); - } else { - msg->err = igmp_leavegroup(ip_2_ip4(API_EXPR_REF(msg->msg.jl.netif_addr)), - ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); - } -#endif /* LWIP_IGMP */ - } -#endif /* LWIP_UDP */ -#if (LWIP_TCP || LWIP_RAW) - } else { - msg->err = ERR_VAL; -#endif /* (LWIP_TCP || LWIP_RAW) */ - } - } - TCPIP_APIMSG_ACK(msg); -} -/** - * Join multicast groups for UDP netconns. - * Called from netconn_join_leave_group_netif - * - * @param m the api_msg pointing to the connection - */ -void -lwip_netconn_do_join_leave_group_netif(void *m) -{ - struct api_msg *msg = (struct api_msg *)m; - struct netif *netif; - - netif = netif_get_by_index(msg->msg.jl.if_idx); - if (netif == NULL) { - msg->err = ERR_IF; - goto done; - } - - msg->err = ERR_CONN; - if (msg->conn->pcb.tcp != NULL) { - if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) { -#if LWIP_UDP -#if LWIP_IPV6 && LWIP_IPV6_MLD - if (NETCONNTYPE_ISIPV6(msg->conn->type)) { - if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { - msg->err = mld6_joingroup_netif(netif, - ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); - } else { - msg->err = mld6_leavegroup_netif(netif, - ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); - } - } else -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ - { -#if LWIP_IGMP - if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { - msg->err = igmp_joingroup_netif(netif, - ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); - } else { - msg->err = igmp_leavegroup_netif(netif, - ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); - } -#endif /* LWIP_IGMP */ - } -#endif /* LWIP_UDP */ -#if (LWIP_TCP || LWIP_RAW) - } else { - msg->err = ERR_VAL; -#endif /* (LWIP_TCP || LWIP_RAW) */ - } - } - -done: - TCPIP_APIMSG_ACK(msg); -} -#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ - -#if LWIP_DNS -/** - * Callback function that is called when DNS name is resolved - * (or on timeout). A waiting application thread is waked up by - * signaling the semaphore. - */ -static void -lwip_netconn_do_dns_found(const char *name, const ip_addr_t *ipaddr, void *arg) -{ - struct dns_api_msg *msg = (struct dns_api_msg *)arg; - - /* we trust the internal implementation to be correct :-) */ - LWIP_UNUSED_ARG(name); - - if (ipaddr == NULL) { - /* timeout or memory error */ - API_EXPR_DEREF(msg->err) = ERR_VAL; - } else { - /* address was resolved */ - API_EXPR_DEREF(msg->err) = ERR_OK; - API_EXPR_DEREF(msg->addr) = *ipaddr; - } - /* wake up the application task waiting in netconn_gethostbyname */ - sys_sem_signal(API_EXPR_REF_SEM(msg->sem)); -} - -/** - * Execute a DNS query - * Called from netconn_gethostbyname - * - * @param arg the dns_api_msg pointing to the query - */ -void -lwip_netconn_do_gethostbyname(void *arg) -{ - struct dns_api_msg *msg = (struct dns_api_msg *)arg; - u8_t addrtype = -#if LWIP_IPV4 && LWIP_IPV6 - msg->dns_addrtype; -#else - LWIP_DNS_ADDRTYPE_DEFAULT; -#endif - - API_EXPR_DEREF(msg->err) = dns_gethostbyname_addrtype(msg->name, - API_EXPR_REF(msg->addr), lwip_netconn_do_dns_found, msg, addrtype); -#if LWIP_TCPIP_CORE_LOCKING - /* For core locking, only block if we need to wait for answer/timeout */ - if (API_EXPR_DEREF(msg->err) == ERR_INPROGRESS) { - UNLOCK_TCPIP_CORE(); - sys_sem_wait(API_EXPR_REF_SEM(msg->sem)); - LOCK_TCPIP_CORE(); - LWIP_ASSERT("do_gethostbyname still in progress!!", API_EXPR_DEREF(msg->err) != ERR_INPROGRESS); - } -#else /* LWIP_TCPIP_CORE_LOCKING */ - if (API_EXPR_DEREF(msg->err) != ERR_INPROGRESS) { - /* on error or immediate success, wake up the application - * task waiting in netconn_gethostbyname */ - sys_sem_signal(API_EXPR_REF_SEM(msg->sem)); - } -#endif /* LWIP_TCPIP_CORE_LOCKING */ -} -#endif /* LWIP_DNS */ - -#endif /* LWIP_NETCONN */ +/** + * @file + * Sequential API Internal module + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/priv/api_msg.h" + +#include "lwip/ip.h" +#include "lwip/ip_addr.h" +#include "lwip/udp.h" +#include "lwip/tcp.h" +#include "lwip/raw.h" + +#include "lwip/memp.h" +#include "lwip/igmp.h" +#include "lwip/dns.h" +#include "lwip/mld6.h" +#include "lwip/priv/tcpip_priv.h" + +#include + +/* netconns are polled once per second (e.g. continue write on memory error) */ +#define NETCONN_TCP_POLL_INTERVAL 2 + +#define SET_NONBLOCKING_CONNECT(conn, val) do { if (val) { \ + netconn_set_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); \ +} else { \ + netconn_clear_flags(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT); }} while(0) +#define IN_NONBLOCKING_CONNECT(conn) netconn_is_flag_set(conn, NETCONN_FLAG_IN_NONBLOCKING_CONNECT) + +#if LWIP_NETCONN_FULLDUPLEX +#define NETCONN_MBOX_VALID(conn, mbox) (sys_mbox_valid(mbox) && ((conn->flags & NETCONN_FLAG_MBOXINVALID) == 0)) +#else +#define NETCONN_MBOX_VALID(conn, mbox) sys_mbox_valid(mbox) +#endif + +/* forward declarations */ +#if LWIP_TCP +#if LWIP_TCPIP_CORE_LOCKING +#define WRITE_DELAYED , 1 +#define WRITE_DELAYED_PARAM , u8_t delayed +#else /* LWIP_TCPIP_CORE_LOCKING */ +#define WRITE_DELAYED +#define WRITE_DELAYED_PARAM +#endif /* LWIP_TCPIP_CORE_LOCKING */ +static err_t lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM); +static err_t lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM); +#endif + +static void netconn_drain(struct netconn *conn); + +#if LWIP_TCPIP_CORE_LOCKING +#define TCPIP_APIMSG_ACK(m) +#else /* LWIP_TCPIP_CORE_LOCKING */ +#define TCPIP_APIMSG_ACK(m) do { sys_sem_signal(LWIP_API_MSG_SEM(m)); } while(0) +#endif /* LWIP_TCPIP_CORE_LOCKING */ + +#if LWIP_NETCONN_FULLDUPLEX +const u8_t netconn_deleted = 0; + +int +lwip_netconn_is_deallocated_msg(void *msg) +{ + if (msg == &netconn_deleted) { + return 1; + } + return 0; +} +#endif /* LWIP_NETCONN_FULLDUPLEX */ + +#if LWIP_TCP +const u8_t netconn_aborted = 0; +const u8_t netconn_reset = 0; +const u8_t netconn_closed = 0; + +/** Translate an error to a unique void* passed via an mbox */ +static void * +lwip_netconn_err_to_msg(err_t err) +{ + switch (err) { + case ERR_ABRT: + return LWIP_CONST_CAST(void *, &netconn_aborted); + case ERR_RST: + return LWIP_CONST_CAST(void *, &netconn_reset); + case ERR_CLSD: + return LWIP_CONST_CAST(void *, &netconn_closed); + default: + LWIP_ASSERT("unhandled error", err == ERR_OK); + return NULL; + } +} + +int +lwip_netconn_is_err_msg(void *msg, err_t *err) +{ + LWIP_ASSERT("err != NULL", err != NULL); + + if (msg == &netconn_aborted) { + *err = ERR_ABRT; + return 1; + } else if (msg == &netconn_reset) { + *err = ERR_RST; + return 1; + } else if (msg == &netconn_closed) { + *err = ERR_CLSD; + return 1; + } + return 0; +} +#endif /* LWIP_TCP */ + + +#if LWIP_RAW +/** + * Receive callback function for RAW netconns. + * Doesn't 'eat' the packet, only copies it and sends it to + * conn->recvmbox + * + * @see raw.h (struct raw_pcb.recv) for parameters and return value + */ +static u8_t +recv_raw(void *arg, struct raw_pcb *pcb, struct pbuf *p, + const ip_addr_t *addr) +{ + struct pbuf *q; + struct netbuf *buf; + struct netconn *conn; + + LWIP_UNUSED_ARG(addr); + conn = (struct netconn *)arg; + + if ((conn != NULL) && NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { +#if LWIP_SO_RCVBUF + int recv_avail; + SYS_ARCH_GET(conn->recv_avail, recv_avail); + if ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize) { + return 0; + } +#endif /* LWIP_SO_RCVBUF */ + /* copy the whole packet into new pbufs */ + q = pbuf_clone(PBUF_RAW, PBUF_RAM, p); + if (q != NULL) { + u16_t len; + buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); + if (buf == NULL) { + pbuf_free(q); + return 0; + } + + buf->p = q; + buf->ptr = q; + ip_addr_copy(buf->addr, *ip_current_src_addr()); + buf->port = pcb->protocol; + + len = q->tot_len; + if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) { + netbuf_delete(buf); + return 0; + } else { +#if LWIP_SO_RCVBUF + SYS_ARCH_INC(conn->recv_avail, len); +#endif /* LWIP_SO_RCVBUF */ + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); + } + } + } + + return 0; /* do not eat the packet */ +} +#endif /* LWIP_RAW*/ + +#if LWIP_UDP +/** + * Receive callback function for UDP netconns. + * Posts the packet to conn->recvmbox or deletes it on memory error. + * + * @see udp.h (struct udp_pcb.recv) for parameters + */ +static void +recv_udp(void *arg, struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *addr, u16_t port) +{ + struct netbuf *buf; + struct netconn *conn; + u16_t len; +#if LWIP_SO_RCVBUF + int recv_avail; +#endif /* LWIP_SO_RCVBUF */ + + LWIP_UNUSED_ARG(pcb); /* only used for asserts... */ + LWIP_ASSERT("recv_udp must have a pcb argument", pcb != NULL); + LWIP_ASSERT("recv_udp must have an argument", arg != NULL); + conn = (struct netconn *)arg; + + if (conn == NULL) { + pbuf_free(p); + return; + } + + LWIP_ASSERT("recv_udp: recv for wrong pcb!", conn->pcb.udp == pcb); + +#if LWIP_SO_RCVBUF + SYS_ARCH_GET(conn->recv_avail, recv_avail); + if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox) || + ((recv_avail + (int)(p->tot_len)) > conn->recv_bufsize)) { +#else /* LWIP_SO_RCVBUF */ + if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { +#endif /* LWIP_SO_RCVBUF */ + pbuf_free(p); + return; + } + + buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); + if (buf == NULL) { + pbuf_free(p); + return; + } else { + buf->p = p; + buf->ptr = p; + ip_addr_set(&buf->addr, addr); + buf->port = port; +#if LWIP_NETBUF_RECVINFO + if (conn->flags & NETCONN_FLAG_PKTINFO) { + /* get the UDP header - always in the first pbuf, ensured by udp_input */ + const struct udp_hdr *udphdr = (const struct udp_hdr *)ip_next_header_ptr(); + buf->flags = NETBUF_FLAG_DESTADDR; + ip_addr_set(&buf->toaddr, ip_current_dest_addr()); + buf->toport_chksum = udphdr->dest; + } +#endif /* LWIP_NETBUF_RECVINFO */ + } + + len = p->tot_len; + if (sys_mbox_trypost(&conn->recvmbox, buf) != ERR_OK) { + netbuf_delete(buf); + return; + } else { +#if LWIP_SO_RCVBUF + SYS_ARCH_INC(conn->recv_avail, len); +#endif /* LWIP_SO_RCVBUF */ + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); + } +} +#endif /* LWIP_UDP */ + +#if LWIP_TCP +/** + * Receive callback function for TCP netconns. + * Posts the packet to conn->recvmbox, but doesn't delete it on errors. + * + * @see tcp.h (struct tcp_pcb.recv) for parameters and return value + */ +static err_t +recv_tcp(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) +{ + struct netconn *conn; + u16_t len; + void *msg; + + LWIP_UNUSED_ARG(pcb); + LWIP_ASSERT("recv_tcp must have a pcb argument", pcb != NULL); + LWIP_ASSERT("recv_tcp must have an argument", arg != NULL); + LWIP_ASSERT("err != ERR_OK unhandled", err == ERR_OK); + LWIP_UNUSED_ARG(err); /* for LWIP_NOASSERT */ + conn = (struct netconn *)arg; + + if (conn == NULL) { + return ERR_VAL; + } + LWIP_ASSERT("recv_tcp: recv for wrong pcb!", conn->pcb.tcp == pcb); + + if (!NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { + /* recvmbox already deleted */ + if (p != NULL) { + tcp_recved(pcb, p->tot_len); + pbuf_free(p); + } + return ERR_OK; + } + /* Unlike for UDP or RAW pcbs, don't check for available space + using recv_avail since that could break the connection + (data is already ACKed) */ + + if (p != NULL) { + msg = p; + len = p->tot_len; + } else { + msg = LWIP_CONST_CAST(void *, &netconn_closed); + len = 0; + } + + if (sys_mbox_trypost(&conn->recvmbox, msg) != ERR_OK) { + /* don't deallocate p: it is presented to us later again from tcp_fasttmr! */ + return ERR_MEM; + } else { +#if LWIP_SO_RCVBUF + SYS_ARCH_INC(conn->recv_avail, len); +#endif /* LWIP_SO_RCVBUF */ + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVPLUS, len); + } + + return ERR_OK; +} + +/** + * Poll callback function for TCP netconns. + * Wakes up an application thread that waits for a connection to close + * or data to be sent. The application thread then takes the + * appropriate action to go on. + * + * Signals the conn->sem. + * netconn_close waits for conn->sem if closing failed. + * + * @see tcp.h (struct tcp_pcb.poll) for parameters and return value + */ +static err_t +poll_tcp(void *arg, struct tcp_pcb *pcb) +{ + struct netconn *conn = (struct netconn *)arg; + + LWIP_UNUSED_ARG(pcb); + LWIP_ASSERT("conn != NULL", (conn != NULL)); + + if (conn->state == NETCONN_WRITE) { + lwip_netconn_do_writemore(conn WRITE_DELAYED); + } else if (conn->state == NETCONN_CLOSE) { +#if !LWIP_SO_SNDTIMEO && !LWIP_SO_LINGER + if (conn->current_msg && conn->current_msg->msg.sd.polls_left) { + conn->current_msg->msg.sd.polls_left--; + } +#endif /* !LWIP_SO_SNDTIMEO && !LWIP_SO_LINGER */ + lwip_netconn_do_close_internal(conn WRITE_DELAYED); + } + /* @todo: implement connect timeout here? */ + + /* Did a nonblocking write fail before? Then check available write-space. */ + if (conn->flags & NETCONN_FLAG_CHECK_WRITESPACE) { + /* If the queued byte- or pbuf-count drops below the configured low-water limit, + let select mark this pcb as writable again. */ + if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) && + (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) { + netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE); + API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); + } + } + + return ERR_OK; +} + +/** + * Sent callback function for TCP netconns. + * Signals the conn->sem and calls API_EVENT. + * netconn_write waits for conn->sem if send buffer is low. + * + * @see tcp.h (struct tcp_pcb.sent) for parameters and return value + */ +static err_t +sent_tcp(void *arg, struct tcp_pcb *pcb, u16_t len) +{ + struct netconn *conn = (struct netconn *)arg; + + LWIP_UNUSED_ARG(pcb); + LWIP_ASSERT("conn != NULL", (conn != NULL)); + + if (conn) { + if (conn->state == NETCONN_WRITE) { + lwip_netconn_do_writemore(conn WRITE_DELAYED); + } else if (conn->state == NETCONN_CLOSE) { + lwip_netconn_do_close_internal(conn WRITE_DELAYED); + } + + /* If the queued byte- or pbuf-count drops below the configured low-water limit, + let select mark this pcb as writable again. */ + if ((conn->pcb.tcp != NULL) && (tcp_sndbuf(conn->pcb.tcp) > TCP_SNDLOWAT) && + (tcp_sndqueuelen(conn->pcb.tcp) < TCP_SNDQUEUELOWAT)) { + netconn_clear_flags(conn, NETCONN_FLAG_CHECK_WRITESPACE); + API_EVENT(conn, NETCONN_EVT_SENDPLUS, len); + } + } + + return ERR_OK; +} + +/** + * Error callback function for TCP netconns. + * Signals conn->sem, posts to all conn mboxes and calls API_EVENT. + * The application thread has then to decide what to do. + * + * @see tcp.h (struct tcp_pcb.err) for parameters + */ +static void +err_tcp(void *arg, err_t err) +{ + struct netconn *conn; + enum netconn_state old_state; + void *mbox_msg; + SYS_ARCH_DECL_PROTECT(lev); + + conn = (struct netconn *)arg; + LWIP_ASSERT("conn != NULL", (conn != NULL)); + + SYS_ARCH_PROTECT(lev); + + /* when err is called, the pcb is deallocated, so delete the reference */ + conn->pcb.tcp = NULL; + /* store pending error */ + conn->pending_err = err; + /* prevent application threads from blocking on 'recvmbox'/'acceptmbox' */ + conn->flags |= NETCONN_FLAG_MBOXCLOSED; + + /* reset conn->state now before waking up other threads */ + old_state = conn->state; + conn->state = NETCONN_NONE; + + SYS_ARCH_UNPROTECT(lev); + + /* Notify the user layer about a connection error. Used to signal select. */ + API_EVENT(conn, NETCONN_EVT_ERROR, 0); + /* Try to release selects pending on 'read' or 'write', too. + They will get an error if they actually try to read or write. */ + API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); + API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); + + mbox_msg = lwip_netconn_err_to_msg(err); + /* pass error message to recvmbox to wake up pending recv */ + if (NETCONN_MBOX_VALID(conn, &conn->recvmbox)) { + /* use trypost to prevent deadlock */ + sys_mbox_trypost(&conn->recvmbox, mbox_msg); + } + /* pass error message to acceptmbox to wake up pending accept */ + if (NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) { + /* use trypost to preven deadlock */ + sys_mbox_trypost(&conn->acceptmbox, mbox_msg); + } + + if ((old_state == NETCONN_WRITE) || (old_state == NETCONN_CLOSE) || + (old_state == NETCONN_CONNECT)) { + /* calling lwip_netconn_do_writemore/lwip_netconn_do_close_internal is not necessary + since the pcb has already been deleted! */ + int was_nonblocking_connect = IN_NONBLOCKING_CONNECT(conn); + SET_NONBLOCKING_CONNECT(conn, 0); + + if (!was_nonblocking_connect) { + sys_sem_t *op_completed_sem; + /* set error return code */ + LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL); + if (old_state == NETCONN_CLOSE) { + /* let close succeed: the connection is closed after all... */ + conn->current_msg->err = ERR_OK; + } else { + /* Write and connect fail */ + conn->current_msg->err = err; + } + op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); + LWIP_ASSERT("inavlid op_completed_sem", sys_sem_valid(op_completed_sem)); + conn->current_msg = NULL; + /* wake up the waiting task */ + sys_sem_signal(op_completed_sem); + } else { + /* @todo: test what happens for error on nonblocking connect */ + } + } else { + LWIP_ASSERT("conn->current_msg == NULL", conn->current_msg == NULL); + } +} + +/** + * Setup a tcp_pcb with the correct callback function pointers + * and their arguments. + * + * @param conn the TCP netconn to setup + */ +static void +setup_tcp(struct netconn *conn) +{ + struct tcp_pcb *pcb; + + pcb = conn->pcb.tcp; + tcp_arg(pcb, conn); + tcp_recv(pcb, recv_tcp); + tcp_sent(pcb, sent_tcp); + tcp_poll(pcb, poll_tcp, NETCONN_TCP_POLL_INTERVAL); + tcp_err(pcb, err_tcp); +} + +/** + * Accept callback function for TCP netconns. + * Allocates a new netconn and posts that to conn->acceptmbox. + * + * @see tcp.h (struct tcp_pcb_listen.accept) for parameters and return value + */ +static err_t +accept_function(void *arg, struct tcp_pcb *newpcb, err_t err) +{ + struct netconn *newconn; + struct netconn *conn = (struct netconn *)arg; + + if (conn == NULL) { + return ERR_VAL; + } + if (!NETCONN_MBOX_VALID(conn, &conn->acceptmbox)) { + LWIP_DEBUGF(API_MSG_DEBUG, ("accept_function: acceptmbox already deleted\n")); + return ERR_VAL; + } + + if (newpcb == NULL) { + /* out-of-pcbs during connect: pass on this error to the application */ + if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) { + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); + } + return ERR_VAL; + } + LWIP_ASSERT("expect newpcb == NULL or err == ERR_OK", err == ERR_OK); + LWIP_UNUSED_ARG(err); /* for LWIP_NOASSERT */ + + LWIP_DEBUGF(API_MSG_DEBUG, ("accept_function: newpcb->state: %s\n", tcp_debug_state_str(newpcb->state))); + + /* We have to set the callback here even though + * the new socket is unknown. newconn->socket is marked as -1. */ + newconn = netconn_alloc(conn->type, conn->callback); + if (newconn == NULL) { + /* outof netconns: pass on this error to the application */ + if (sys_mbox_trypost(&conn->acceptmbox, lwip_netconn_err_to_msg(ERR_ABRT)) == ERR_OK) { + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); + } + return ERR_MEM; + } + newconn->pcb.tcp = newpcb; + setup_tcp(newconn); + + /* handle backlog counter */ + tcp_backlog_delayed(newpcb); + + if (sys_mbox_trypost(&conn->acceptmbox, newconn) != ERR_OK) { + /* When returning != ERR_OK, the pcb is aborted in tcp_process(), + so do nothing here! */ + /* remove all references to this netconn from the pcb */ + struct tcp_pcb *pcb = newconn->pcb.tcp; + tcp_arg(pcb, NULL); + tcp_recv(pcb, NULL); + tcp_sent(pcb, NULL); + tcp_poll(pcb, NULL, 0); + tcp_err(pcb, NULL); + /* remove reference from to the pcb from this netconn */ + newconn->pcb.tcp = NULL; + /* no need to drain since we know the recvmbox is empty. */ + sys_mbox_free(&newconn->recvmbox); + sys_mbox_set_invalid(&newconn->recvmbox); + netconn_free(newconn); + return ERR_MEM; + } else { + /* Register event with callback */ + API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); + } + + return ERR_OK; +} +#endif /* LWIP_TCP */ + +/** + * Create a new pcb of a specific type. + * Called from lwip_netconn_do_newconn(). + * + * @param msg the api_msg describing the connection type + */ +static void +pcb_new(struct api_msg *msg) +{ + enum lwip_ip_addr_type iptype = IPADDR_TYPE_V4; + + LWIP_ASSERT("pcb_new: pcb already allocated", msg->conn->pcb.tcp == NULL); + +#if LWIP_IPV6 && LWIP_IPV4 + /* IPv6: Dual-stack by default, unless netconn_set_ipv6only() is called */ + if (NETCONNTYPE_ISIPV6(netconn_type(msg->conn))) { + iptype = IPADDR_TYPE_ANY; + } +#endif + + /* Allocate a PCB for this connection */ + switch (NETCONNTYPE_GROUP(msg->conn->type)) { +#if LWIP_RAW + case NETCONN_RAW: + msg->conn->pcb.raw = raw_new_ip_type(iptype, msg->msg.n.proto); + if (msg->conn->pcb.raw != NULL) { +#if LWIP_IPV6 + /* ICMPv6 packets should always have checksum calculated by the stack as per RFC 3542 chapter 3.1 */ + if (NETCONNTYPE_ISIPV6(msg->conn->type) && msg->conn->pcb.raw->protocol == IP6_NEXTH_ICMP6) { + msg->conn->pcb.raw->chksum_reqd = 1; + msg->conn->pcb.raw->chksum_offset = 2; + } +#endif /* LWIP_IPV6 */ + raw_recv(msg->conn->pcb.raw, recv_raw, msg->conn); + } + break; +#endif /* LWIP_RAW */ +#if LWIP_UDP + case NETCONN_UDP: + msg->conn->pcb.udp = udp_new_ip_type(iptype); + if (msg->conn->pcb.udp != NULL) { +#if LWIP_UDPLITE + if (NETCONNTYPE_ISUDPLITE(msg->conn->type)) { + udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_UDPLITE); + } +#endif /* LWIP_UDPLITE */ + if (NETCONNTYPE_ISUDPNOCHKSUM(msg->conn->type)) { + udp_setflags(msg->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); + } + udp_recv(msg->conn->pcb.udp, recv_udp, msg->conn); + } + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case NETCONN_TCP: + msg->conn->pcb.tcp = tcp_new_ip_type(iptype); + if (msg->conn->pcb.tcp != NULL) { + setup_tcp(msg->conn); + } + break; +#endif /* LWIP_TCP */ + default: + /* Unsupported netconn type, e.g. protocol disabled */ + msg->err = ERR_VAL; + return; + } + if (msg->conn->pcb.ip == NULL) { + msg->err = ERR_MEM; + } +} + +/** + * Create a new pcb of a specific type inside a netconn. + * Called from netconn_new_with_proto_and_callback. + * + * @param m the api_msg describing the connection type + */ +void +lwip_netconn_do_newconn(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + msg->err = ERR_OK; + if (msg->conn->pcb.tcp == NULL) { + pcb_new(msg); + } + /* Else? This "new" connection already has a PCB allocated. */ + /* Is this an error condition? Should it be deleted? */ + /* We currently just are happy and return. */ + + TCPIP_APIMSG_ACK(msg); +} + +/** + * Create a new netconn (of a specific type) that has a callback function. + * The corresponding pcb is NOT created! + * + * @param t the type of 'connection' to create (@see enum netconn_type) + * @param callback a function to call on status changes (RX available, TX'ed) + * @return a newly allocated struct netconn or + * NULL on memory error + */ +struct netconn * +netconn_alloc(enum netconn_type t, netconn_callback callback) +{ + struct netconn *conn; + int size; + u8_t init_flags = 0; + + conn = (struct netconn *)memp_malloc(MEMP_NETCONN); + if (conn == NULL) { + return NULL; + } + + conn->pending_err = ERR_OK; + conn->type = t; + conn->pcb.tcp = NULL; + + /* If all sizes are the same, every compiler should optimize this switch to nothing */ + switch (NETCONNTYPE_GROUP(t)) { +#if LWIP_RAW + case NETCONN_RAW: + size = DEFAULT_RAW_RECVMBOX_SIZE; + break; +#endif /* LWIP_RAW */ +#if LWIP_UDP + case NETCONN_UDP: + size = DEFAULT_UDP_RECVMBOX_SIZE; +#if LWIP_NETBUF_RECVINFO + init_flags |= NETCONN_FLAG_PKTINFO; +#endif /* LWIP_NETBUF_RECVINFO */ + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case NETCONN_TCP: + size = DEFAULT_TCP_RECVMBOX_SIZE; + break; +#endif /* LWIP_TCP */ + default: + LWIP_ASSERT("netconn_alloc: undefined netconn_type", 0); + goto free_and_return; + } + + if (sys_mbox_new(&conn->recvmbox, size) != ERR_OK) { + goto free_and_return; + } +#if !LWIP_NETCONN_SEM_PER_THREAD + if (sys_sem_new(&conn->op_completed, 0) != ERR_OK) { + sys_mbox_free(&conn->recvmbox); + goto free_and_return; + } +#endif + +#if LWIP_TCP + sys_mbox_set_invalid(&conn->acceptmbox); +#endif + conn->state = NETCONN_NONE; +#if LWIP_SOCKET + /* initialize socket to -1 since 0 is a valid socket */ + conn->socket = -1; +#endif /* LWIP_SOCKET */ + conn->callback = callback; +#if LWIP_TCP + conn->current_msg = NULL; +#endif /* LWIP_TCP */ +#if LWIP_SO_SNDTIMEO + conn->send_timeout = 0; +#endif /* LWIP_SO_SNDTIMEO */ +#if LWIP_SO_RCVTIMEO + conn->recv_timeout = 0; +#endif /* LWIP_SO_RCVTIMEO */ +#if LWIP_SO_RCVBUF + conn->recv_bufsize = RECV_BUFSIZE_DEFAULT; + conn->recv_avail = 0; +#endif /* LWIP_SO_RCVBUF */ +#if LWIP_SO_LINGER + conn->linger = -1; +#endif /* LWIP_SO_LINGER */ + conn->flags = init_flags; + return conn; +free_and_return: + memp_free(MEMP_NETCONN, conn); + return NULL; +} + +/** + * Delete a netconn and all its resources. + * The pcb is NOT freed (since we might not be in the right thread context do this). + * + * @param conn the netconn to free + */ +void +netconn_free(struct netconn *conn) +{ + LWIP_ASSERT("PCB must be deallocated outside this function", conn->pcb.tcp == NULL); + +#if LWIP_NETCONN_FULLDUPLEX + /* in fullduplex, netconn is drained here */ + netconn_drain(conn); +#endif /* LWIP_NETCONN_FULLDUPLEX */ + + LWIP_ASSERT("recvmbox must be deallocated before calling this function", + !sys_mbox_valid(&conn->recvmbox)); +#if LWIP_TCP + LWIP_ASSERT("acceptmbox must be deallocated before calling this function", + !sys_mbox_valid(&conn->acceptmbox)); +#endif /* LWIP_TCP */ + +#if !LWIP_NETCONN_SEM_PER_THREAD + sys_sem_free(&conn->op_completed); + sys_sem_set_invalid(&conn->op_completed); +#endif + + memp_free(MEMP_NETCONN, conn); +} + +/** + * Delete rcvmbox and acceptmbox of a netconn and free the left-over data in + * these mboxes + * + * @param conn the netconn to free + * @bytes_drained bytes drained from recvmbox + * @accepts_drained pending connections drained from acceptmbox + */ +static void +netconn_drain(struct netconn *conn) +{ + void *mem; + + /* This runs when mbox and netconn are marked as closed, + so we don't need to lock against rx packets */ +#if LWIP_NETCONN_FULLDUPLEX + LWIP_ASSERT("netconn marked closed", conn->flags & NETCONN_FLAG_MBOXINVALID); +#endif /* LWIP_NETCONN_FULLDUPLEX */ + + /* Delete and drain the recvmbox. */ + if (sys_mbox_valid(&conn->recvmbox)) { + while (sys_mbox_tryfetch(&conn->recvmbox, &mem) != SYS_MBOX_EMPTY) { +#if LWIP_NETCONN_FULLDUPLEX + if (!lwip_netconn_is_deallocated_msg(mem)) +#endif /* LWIP_NETCONN_FULLDUPLEX */ + { +#if LWIP_TCP + if (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) { + err_t err; + if (!lwip_netconn_is_err_msg(mem, &err)) { + pbuf_free((struct pbuf *)mem); + } + } else +#endif /* LWIP_TCP */ + { + netbuf_delete((struct netbuf *)mem); + } + } + } + sys_mbox_free(&conn->recvmbox); + sys_mbox_set_invalid(&conn->recvmbox); + } + + /* Delete and drain the acceptmbox. */ +#if LWIP_TCP + if (sys_mbox_valid(&conn->acceptmbox)) { + while (sys_mbox_tryfetch(&conn->acceptmbox, &mem) != SYS_MBOX_EMPTY) { +#if LWIP_NETCONN_FULLDUPLEX + if (!lwip_netconn_is_deallocated_msg(mem)) +#endif /* LWIP_NETCONN_FULLDUPLEX */ + { + err_t err; + if (!lwip_netconn_is_err_msg(mem, &err)) { + struct netconn *newconn = (struct netconn *)mem; + /* Only tcp pcbs have an acceptmbox, so no need to check conn->type */ + /* pcb might be set to NULL already by err_tcp() */ + /* drain recvmbox */ + netconn_drain(newconn); + if (newconn->pcb.tcp != NULL) { + tcp_abort(newconn->pcb.tcp); + newconn->pcb.tcp = NULL; + } + netconn_free(newconn); + } + } + } + sys_mbox_free(&conn->acceptmbox); + sys_mbox_set_invalid(&conn->acceptmbox); + } +#endif /* LWIP_TCP */ +} + +#if LWIP_NETCONN_FULLDUPLEX +static void +netconn_mark_mbox_invalid(struct netconn *conn) +{ + int i, num_waiting; + void *msg = LWIP_CONST_CAST(void *, &netconn_deleted); + + /* Prevent new calls/threads from reading from the mbox */ + conn->flags |= NETCONN_FLAG_MBOXINVALID; + + SYS_ARCH_LOCKED(num_waiting = conn->mbox_threads_waiting); + for (i = 0; i < num_waiting; i++) { + if (sys_mbox_valid_val(conn->recvmbox)) { + sys_mbox_trypost(&conn->recvmbox, msg); + } else { + sys_mbox_trypost(&conn->acceptmbox, msg); + } + } +} +#endif /* LWIP_NETCONN_FULLDUPLEX */ + +#if LWIP_TCP +/** + * Internal helper function to close a TCP netconn: since this sometimes + * doesn't work at the first attempt, this function is called from multiple + * places. + * + * @param conn the TCP netconn to close + */ +static err_t +lwip_netconn_do_close_internal(struct netconn *conn WRITE_DELAYED_PARAM) +{ + err_t err; + u8_t shut, shut_rx, shut_tx, shut_close; + u8_t close_finished = 0; + struct tcp_pcb *tpcb; +#if LWIP_SO_LINGER + u8_t linger_wait_required = 0; +#endif /* LWIP_SO_LINGER */ + + LWIP_ASSERT("invalid conn", (conn != NULL)); + LWIP_ASSERT("this is for tcp netconns only", (NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP)); + LWIP_ASSERT("conn must be in state NETCONN_CLOSE", (conn->state == NETCONN_CLOSE)); + LWIP_ASSERT("pcb already closed", (conn->pcb.tcp != NULL)); + LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL); + + tpcb = conn->pcb.tcp; + shut = conn->current_msg->msg.sd.shut; + shut_rx = shut & NETCONN_SHUT_RD; + shut_tx = shut & NETCONN_SHUT_WR; + /* shutting down both ends is the same as closing + (also if RD or WR side was shut down before already) */ + if (shut == NETCONN_SHUT_RDWR) { + shut_close = 1; + } else if (shut_rx && + ((tpcb->state == FIN_WAIT_1) || + (tpcb->state == FIN_WAIT_2) || + (tpcb->state == CLOSING))) { + shut_close = 1; + } else if (shut_tx && ((tpcb->flags & TF_RXCLOSED) != 0)) { + shut_close = 1; + } else { + shut_close = 0; + } + + /* Set back some callback pointers */ + if (shut_close) { + tcp_arg(tpcb, NULL); + } + if (tpcb->state == LISTEN) { + tcp_accept(tpcb, NULL); + } else { + /* some callbacks have to be reset if tcp_close is not successful */ + if (shut_rx) { + tcp_recv(tpcb, NULL); + tcp_accept(tpcb, NULL); + } + if (shut_tx) { + tcp_sent(tpcb, NULL); + } + if (shut_close) { + tcp_poll(tpcb, NULL, 0); + tcp_err(tpcb, NULL); + } + } + /* Try to close the connection */ + if (shut_close) { +#if LWIP_SO_LINGER + /* check linger possibilites before calling tcp_close */ + err = ERR_OK; + /* linger enabled/required at all? (i.e. is there untransmitted data left?) */ + if ((conn->linger >= 0) && (conn->pcb.tcp->unsent || conn->pcb.tcp->unacked)) { + if ((conn->linger == 0)) { + /* data left but linger prevents waiting */ + tcp_abort(tpcb); + tpcb = NULL; + } else if (conn->linger > 0) { + /* data left and linger says we should wait */ + if (netconn_is_nonblocking(conn)) { + /* data left on a nonblocking netconn -> cannot linger */ + err = ERR_WOULDBLOCK; + } else if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >= + (conn->linger * 1000)) { + /* data left but linger timeout has expired (this happens on further + calls to this function through poll_tcp */ + tcp_abort(tpcb); + tpcb = NULL; + } else { + /* data left -> need to wait for ACK after successful close */ + linger_wait_required = 1; + } + } + } + if ((err == ERR_OK) && (tpcb != NULL)) +#endif /* LWIP_SO_LINGER */ + { + err = tcp_close(tpcb); + } + } else { + err = tcp_shutdown(tpcb, shut_rx, shut_tx); + } + if (err == ERR_OK) { + close_finished = 1; +#if LWIP_SO_LINGER + if (linger_wait_required) { + /* wait for ACK of all unsent/unacked data by just getting called again */ + close_finished = 0; + err = ERR_INPROGRESS; + } +#endif /* LWIP_SO_LINGER */ + } else { + if (err == ERR_MEM) { + /* Closing failed because of memory shortage, try again later. Even for + nonblocking netconns, we have to wait since no standard socket application + is prepared for close failing because of resource shortage. + Check the timeout: this is kind of an lwip addition to the standard sockets: + we wait for some time when failing to allocate a segment for the FIN */ +#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER + s32_t close_timeout = LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT; +#if LWIP_SO_SNDTIMEO + if (conn->send_timeout > 0) { + close_timeout = conn->send_timeout; + } +#endif /* LWIP_SO_SNDTIMEO */ +#if LWIP_SO_LINGER + if (conn->linger >= 0) { + /* use linger timeout (seconds) */ + close_timeout = conn->linger * 1000U; + } +#endif + if ((s32_t)(sys_now() - conn->current_msg->msg.sd.time_started) >= close_timeout) { +#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ + if (conn->current_msg->msg.sd.polls_left == 0) { +#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ + close_finished = 1; + if (shut_close) { + /* in this case, we want to RST the connection */ + tcp_abort(tpcb); + err = ERR_OK; + } + } + } else { + /* Closing failed for a non-memory error: give up */ + close_finished = 1; + } + } + if (close_finished) { + /* Closing done (succeeded, non-memory error, nonblocking error or timeout) */ + sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); + conn->current_msg->err = err; + conn->current_msg = NULL; + conn->state = NETCONN_NONE; + if (err == ERR_OK) { + if (shut_close) { + /* Set back some callback pointers as conn is going away */ + conn->pcb.tcp = NULL; + /* Trigger select() in socket layer. Make sure everybody notices activity + on the connection, error first! */ + API_EVENT(conn, NETCONN_EVT_ERROR, 0); + } + if (shut_rx) { + API_EVENT(conn, NETCONN_EVT_RCVPLUS, 0); + } + if (shut_tx) { + API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); + } + } +#if LWIP_TCPIP_CORE_LOCKING + if (delayed) +#endif + { + /* wake up the application task */ + sys_sem_signal(op_completed_sem); + } + return ERR_OK; + } + if (!close_finished) { + /* Closing failed and we want to wait: restore some of the callbacks */ + /* Closing of listen pcb will never fail! */ + LWIP_ASSERT("Closing a listen pcb may not fail!", (tpcb->state != LISTEN)); + if (shut_tx) { + tcp_sent(tpcb, sent_tcp); + } + /* when waiting for close, set up poll interval to 500ms */ + tcp_poll(tpcb, poll_tcp, 1); + tcp_err(tpcb, err_tcp); + tcp_arg(tpcb, conn); + /* don't restore recv callback: we don't want to receive any more data */ + } + /* If closing didn't succeed, we get called again either + from poll_tcp or from sent_tcp */ + LWIP_ASSERT("err != ERR_OK", err != ERR_OK); + return err; +} +#endif /* LWIP_TCP */ + +/** + * Delete the pcb inside a netconn. + * Called from netconn_delete. + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_delconn(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + enum netconn_state state = msg->conn->state; + LWIP_ASSERT("netconn state error", /* this only happens for TCP netconns */ + (state == NETCONN_NONE) || (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP)); +#if LWIP_NETCONN_FULLDUPLEX + /* In full duplex mode, blocking write/connect is aborted with ERR_CLSD */ + if (state != NETCONN_NONE) { + if ((state == NETCONN_WRITE) || + ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) { + /* close requested, abort running write/connect */ + sys_sem_t *op_completed_sem; + LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL); + op_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg); + msg->conn->current_msg->err = ERR_CLSD; + msg->conn->current_msg = NULL; + msg->conn->state = NETCONN_NONE; + sys_sem_signal(op_completed_sem); + } + } +#else /* LWIP_NETCONN_FULLDUPLEX */ + if (((state != NETCONN_NONE) && + (state != NETCONN_LISTEN) && + (state != NETCONN_CONNECT)) || + ((state == NETCONN_CONNECT) && !IN_NONBLOCKING_CONNECT(msg->conn))) { + /* This means either a blocking write or blocking connect is running + (nonblocking write returns and sets state to NONE) */ + msg->err = ERR_INPROGRESS; + } else +#endif /* LWIP_NETCONN_FULLDUPLEX */ + { + LWIP_ASSERT("blocking connect in progress", + (state != NETCONN_CONNECT) || IN_NONBLOCKING_CONNECT(msg->conn)); + msg->err = ERR_OK; +#if LWIP_NETCONN_FULLDUPLEX + /* Mark mboxes invalid */ + netconn_mark_mbox_invalid(msg->conn); +#else /* LWIP_NETCONN_FULLDUPLEX */ + netconn_drain(msg->conn); +#endif /* LWIP_NETCONN_FULLDUPLEX */ + + if (msg->conn->pcb.tcp != NULL) { + + switch (NETCONNTYPE_GROUP(msg->conn->type)) { +#if LWIP_RAW + case NETCONN_RAW: + raw_remove(msg->conn->pcb.raw); + break; +#endif /* LWIP_RAW */ +#if LWIP_UDP + case NETCONN_UDP: + msg->conn->pcb.udp->recv_arg = NULL; + udp_remove(msg->conn->pcb.udp); + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case NETCONN_TCP: + LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL); + msg->conn->state = NETCONN_CLOSE; + msg->msg.sd.shut = NETCONN_SHUT_RDWR; + msg->conn->current_msg = msg; +#if LWIP_TCPIP_CORE_LOCKING + if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) { + LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE); + UNLOCK_TCPIP_CORE(); + sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); + LOCK_TCPIP_CORE(); + LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE); + } +#else /* LWIP_TCPIP_CORE_LOCKING */ + lwip_netconn_do_close_internal(msg->conn); +#endif /* LWIP_TCPIP_CORE_LOCKING */ + /* API_EVENT is called inside lwip_netconn_do_close_internal, before releasing + the application thread, so we can return at this point! */ + return; +#endif /* LWIP_TCP */ + default: + break; + } + msg->conn->pcb.tcp = NULL; + } + /* tcp netconns don't come here! */ + + /* @todo: this lets select make the socket readable and writable, + which is wrong! errfd instead? */ + API_EVENT(msg->conn, NETCONN_EVT_RCVPLUS, 0); + API_EVENT(msg->conn, NETCONN_EVT_SENDPLUS, 0); + } + if (sys_sem_valid(LWIP_API_MSG_SEM(msg))) { + TCPIP_APIMSG_ACK(msg); + } +} + +/** + * Bind a pcb contained in a netconn + * Called from netconn_bind. + * + * @param m the api_msg pointing to the connection and containing + * the IP address and port to bind to + */ +void +lwip_netconn_do_bind(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + err_t err; + + if (msg->conn->pcb.tcp != NULL) { + switch (NETCONNTYPE_GROUP(msg->conn->type)) { +#if LWIP_RAW + case NETCONN_RAW: + err = raw_bind(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr)); + break; +#endif /* LWIP_RAW */ +#if LWIP_UDP + case NETCONN_UDP: + err = udp_bind(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port); + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case NETCONN_TCP: + err = tcp_bind(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port); + break; +#endif /* LWIP_TCP */ + default: + err = ERR_VAL; + break; + } + } else { + err = ERR_VAL; + } + msg->err = err; + TCPIP_APIMSG_ACK(msg); +} +/** + * Bind a pcb contained in a netconn to an interface + * Called from netconn_bind_if. + * + * @param m the api_msg pointing to the connection and containing + * the IP address and port to bind to + */ +void +lwip_netconn_do_bind_if(void *m) +{ + struct netif *netif; + struct api_msg *msg = (struct api_msg *)m; + err_t err; + + netif = netif_get_by_index(msg->msg.bc.if_idx); + + if ((netif != NULL) && (msg->conn->pcb.tcp != NULL)) { + err = ERR_OK; + switch (NETCONNTYPE_GROUP(msg->conn->type)) { +#if LWIP_RAW + case NETCONN_RAW: + raw_bind_netif(msg->conn->pcb.raw, netif); + break; +#endif /* LWIP_RAW */ +#if LWIP_UDP + case NETCONN_UDP: + udp_bind_netif(msg->conn->pcb.udp, netif); + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case NETCONN_TCP: + tcp_bind_netif(msg->conn->pcb.tcp, netif); + break; +#endif /* LWIP_TCP */ + default: + err = ERR_VAL; + break; + } + } else { + err = ERR_VAL; + } + msg->err = err; + TCPIP_APIMSG_ACK(msg); +} + +#if LWIP_TCP +/** + * TCP callback function if a connection (opened by tcp_connect/lwip_netconn_do_connect) has + * been established (or reset by the remote host). + * + * @see tcp.h (struct tcp_pcb.connected) for parameters and return values + */ +static err_t +lwip_netconn_do_connected(void *arg, struct tcp_pcb *pcb, err_t err) +{ + struct netconn *conn; + int was_blocking; + sys_sem_t *op_completed_sem = NULL; + + LWIP_UNUSED_ARG(pcb); + + conn = (struct netconn *)arg; + + if (conn == NULL) { + return ERR_VAL; + } + + LWIP_ASSERT("conn->state == NETCONN_CONNECT", conn->state == NETCONN_CONNECT); + LWIP_ASSERT("(conn->current_msg != NULL) || conn->in_non_blocking_connect", + (conn->current_msg != NULL) || IN_NONBLOCKING_CONNECT(conn)); + + if (conn->current_msg != NULL) { + conn->current_msg->err = err; + op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); + } + if ((NETCONNTYPE_GROUP(conn->type) == NETCONN_TCP) && (err == ERR_OK)) { + setup_tcp(conn); + } + was_blocking = !IN_NONBLOCKING_CONNECT(conn); + SET_NONBLOCKING_CONNECT(conn, 0); + LWIP_ASSERT("blocking connect state error", + (was_blocking && op_completed_sem != NULL) || + (!was_blocking && op_completed_sem == NULL)); + conn->current_msg = NULL; + conn->state = NETCONN_NONE; + API_EVENT(conn, NETCONN_EVT_SENDPLUS, 0); + + if (was_blocking) { + sys_sem_signal(op_completed_sem); + } + return ERR_OK; +} +#endif /* LWIP_TCP */ + +/** + * Connect a pcb contained inside a netconn + * Called from netconn_connect. + * + * @param m the api_msg pointing to the connection and containing + * the IP address and port to connect to + */ +void +lwip_netconn_do_connect(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + err_t err; + + if (msg->conn->pcb.tcp == NULL) { + /* This may happen when calling netconn_connect() a second time */ + err = ERR_CLSD; + } else { + switch (NETCONNTYPE_GROUP(msg->conn->type)) { +#if LWIP_RAW + case NETCONN_RAW: + err = raw_connect(msg->conn->pcb.raw, API_EXPR_REF(msg->msg.bc.ipaddr)); + break; +#endif /* LWIP_RAW */ +#if LWIP_UDP + case NETCONN_UDP: + err = udp_connect(msg->conn->pcb.udp, API_EXPR_REF(msg->msg.bc.ipaddr), msg->msg.bc.port); + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case NETCONN_TCP: + /* Prevent connect while doing any other action. */ + if (msg->conn->state == NETCONN_CONNECT) { + err = ERR_ALREADY; + } else if (msg->conn->state != NETCONN_NONE) { + err = ERR_ISCONN; + } else { + setup_tcp(msg->conn); + err = tcp_connect(msg->conn->pcb.tcp, API_EXPR_REF(msg->msg.bc.ipaddr), + msg->msg.bc.port, lwip_netconn_do_connected); + if (err == ERR_OK) { + u8_t non_blocking = netconn_is_nonblocking(msg->conn); + msg->conn->state = NETCONN_CONNECT; + SET_NONBLOCKING_CONNECT(msg->conn, non_blocking); + if (non_blocking) { + err = ERR_INPROGRESS; + } else { + msg->conn->current_msg = msg; + /* sys_sem_signal() is called from lwip_netconn_do_connected (or err_tcp()), + when the connection is established! */ +#if LWIP_TCPIP_CORE_LOCKING + LWIP_ASSERT("state!", msg->conn->state == NETCONN_CONNECT); + UNLOCK_TCPIP_CORE(); + sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); + LOCK_TCPIP_CORE(); + LWIP_ASSERT("state!", msg->conn->state != NETCONN_CONNECT); +#endif /* LWIP_TCPIP_CORE_LOCKING */ + return; + } + } + } + break; +#endif /* LWIP_TCP */ + default: + LWIP_ERROR("Invalid netconn type", 0, do { + err = ERR_VAL; + } while (0)); + break; + } + } + msg->err = err; + /* For all other protocols, netconn_connect() calls netconn_apimsg(), + so use TCPIP_APIMSG_ACK() here. */ + TCPIP_APIMSG_ACK(msg); +} + +/** + * Disconnect a pcb contained inside a netconn + * Only used for UDP netconns. + * Called from netconn_disconnect. + * + * @param m the api_msg pointing to the connection to disconnect + */ +void +lwip_netconn_do_disconnect(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + +#if LWIP_UDP + if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) { + udp_disconnect(msg->conn->pcb.udp); + msg->err = ERR_OK; + } else +#endif /* LWIP_UDP */ + { + msg->err = ERR_VAL; + } + TCPIP_APIMSG_ACK(msg); +} + +#if LWIP_TCP +/** + * Set a TCP pcb contained in a netconn into listen mode + * Called from netconn_listen. + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_listen(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + err_t err; + + if (msg->conn->pcb.tcp != NULL) { + if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { + if (msg->conn->state == NETCONN_NONE) { + struct tcp_pcb *lpcb; + if (msg->conn->pcb.tcp->state != CLOSED) { + /* connection is not closed, cannot listen */ + err = ERR_VAL; + } else { + u8_t backlog; +#if TCP_LISTEN_BACKLOG + backlog = msg->msg.lb.backlog; +#else /* TCP_LISTEN_BACKLOG */ + backlog = TCP_DEFAULT_LISTEN_BACKLOG; +#endif /* TCP_LISTEN_BACKLOG */ +#if LWIP_IPV4 && LWIP_IPV6 + /* "Socket API like" dual-stack support: If IP to listen to is IP6_ADDR_ANY, + * and NETCONN_FLAG_IPV6_V6ONLY is NOT set, use IP_ANY_TYPE to listen + */ + if (ip_addr_cmp(&msg->conn->pcb.ip->local_ip, IP6_ADDR_ANY) && + (netconn_get_ipv6only(msg->conn) == 0)) { + /* change PCB type to IPADDR_TYPE_ANY */ + IP_SET_TYPE_VAL(msg->conn->pcb.tcp->local_ip, IPADDR_TYPE_ANY); + IP_SET_TYPE_VAL(msg->conn->pcb.tcp->remote_ip, IPADDR_TYPE_ANY); + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + lpcb = tcp_listen_with_backlog_and_err(msg->conn->pcb.tcp, backlog, &err); + + if (lpcb == NULL) { + /* in this case, the old pcb is still allocated */ + } else { + /* delete the recvmbox and allocate the acceptmbox */ + if (sys_mbox_valid(&msg->conn->recvmbox)) { + /** @todo: should we drain the recvmbox here? */ + sys_mbox_free(&msg->conn->recvmbox); + sys_mbox_set_invalid(&msg->conn->recvmbox); + } + err = ERR_OK; + if (!sys_mbox_valid(&msg->conn->acceptmbox)) { + err = sys_mbox_new(&msg->conn->acceptmbox, DEFAULT_ACCEPTMBOX_SIZE); + } + if (err == ERR_OK) { + msg->conn->state = NETCONN_LISTEN; + msg->conn->pcb.tcp = lpcb; + tcp_arg(msg->conn->pcb.tcp, msg->conn); + tcp_accept(msg->conn->pcb.tcp, accept_function); + } else { + /* since the old pcb is already deallocated, free lpcb now */ + tcp_close(lpcb); + msg->conn->pcb.tcp = NULL; + } + } + } + } else if (msg->conn->state == NETCONN_LISTEN) { + /* already listening, allow updating of the backlog */ + err = ERR_OK; + tcp_backlog_set(msg->conn->pcb.tcp, msg->msg.lb.backlog); + } else { + err = ERR_CONN; + } + } else { + err = ERR_ARG; + } + } else { + err = ERR_CONN; + } + msg->err = err; + TCPIP_APIMSG_ACK(msg); +} +#endif /* LWIP_TCP */ + +/** + * Send some data on a RAW or UDP pcb contained in a netconn + * Called from netconn_send + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_send(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + err_t err = netconn_err(msg->conn); + if (err == ERR_OK) { + if (msg->conn->pcb.tcp != NULL) { + switch (NETCONNTYPE_GROUP(msg->conn->type)) { +#if LWIP_RAW + case NETCONN_RAW: + if (ip_addr_isany(&msg->msg.b->addr) || IP_IS_ANY_TYPE_VAL(msg->msg.b->addr)) { + err = raw_send(msg->conn->pcb.raw, msg->msg.b->p); + } else { + err = raw_sendto(msg->conn->pcb.raw, msg->msg.b->p, &msg->msg.b->addr); + } + break; +#endif +#if LWIP_UDP + case NETCONN_UDP: +#if LWIP_CHECKSUM_ON_COPY + if (ip_addr_isany(&msg->msg.b->addr) || IP_IS_ANY_TYPE_VAL(msg->msg.b->addr)) { + err = udp_send_chksum(msg->conn->pcb.udp, msg->msg.b->p, + msg->msg.b->flags & NETBUF_FLAG_CHKSUM, msg->msg.b->toport_chksum); + } else { + err = udp_sendto_chksum(msg->conn->pcb.udp, msg->msg.b->p, + &msg->msg.b->addr, msg->msg.b->port, + msg->msg.b->flags & NETBUF_FLAG_CHKSUM, msg->msg.b->toport_chksum); + } +#else /* LWIP_CHECKSUM_ON_COPY */ + if (ip_addr_isany_val(msg->msg.b->addr) || IP_IS_ANY_TYPE_VAL(msg->msg.b->addr)) { + err = udp_send(msg->conn->pcb.udp, msg->msg.b->p); + } else { + err = udp_sendto(msg->conn->pcb.udp, msg->msg.b->p, &msg->msg.b->addr, msg->msg.b->port); + } +#endif /* LWIP_CHECKSUM_ON_COPY */ + break; +#endif /* LWIP_UDP */ + default: + err = ERR_CONN; + break; + } + } else { + err = ERR_CONN; + } + } + msg->err = err; + TCPIP_APIMSG_ACK(msg); +} + +#if LWIP_TCP +/** + * Indicate data has been received from a TCP pcb contained in a netconn + * Called from netconn_recv + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_recv(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + msg->err = ERR_OK; + if (msg->conn->pcb.tcp != NULL) { + if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { + size_t remaining = msg->msg.r.len; + do { + u16_t recved = (u16_t)((remaining > 0xffff) ? 0xffff : remaining); + tcp_recved(msg->conn->pcb.tcp, recved); + remaining -= recved; + } while (remaining != 0); + } + } + TCPIP_APIMSG_ACK(msg); +} + +#if TCP_LISTEN_BACKLOG +/** Indicate that a TCP pcb has been accepted + * Called from netconn_accept + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_accepted(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + msg->err = ERR_OK; + if (msg->conn->pcb.tcp != NULL) { + if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { + tcp_backlog_accepted(msg->conn->pcb.tcp); + } + } + TCPIP_APIMSG_ACK(msg); +} +#endif /* TCP_LISTEN_BACKLOG */ + +/** + * See if more data needs to be written from a previous call to netconn_write. + * Called initially from lwip_netconn_do_write. If the first call can't send all data + * (because of low memory or empty send-buffer), this function is called again + * from sent_tcp() or poll_tcp() to send more data. If all data is sent, the + * blocking application thread (waiting in netconn_write) is released. + * + * @param conn netconn (that is currently in state NETCONN_WRITE) to process + * @return ERR_OK + * ERR_MEM if LWIP_TCPIP_CORE_LOCKING=1 and sending hasn't yet finished + */ +static err_t +lwip_netconn_do_writemore(struct netconn *conn WRITE_DELAYED_PARAM) +{ + err_t err; + const void *dataptr; + u16_t len, available; + u8_t write_finished = 0; + size_t diff; + u8_t dontblock; + u8_t apiflags; + u8_t write_more; + + LWIP_ASSERT("conn != NULL", conn != NULL); + LWIP_ASSERT("conn->state == NETCONN_WRITE", (conn->state == NETCONN_WRITE)); + LWIP_ASSERT("conn->current_msg != NULL", conn->current_msg != NULL); + LWIP_ASSERT("conn->pcb.tcp != NULL", conn->pcb.tcp != NULL); + LWIP_ASSERT("conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len", + conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len); + LWIP_ASSERT("conn->current_msg->msg.w.vector_cnt > 0", conn->current_msg->msg.w.vector_cnt > 0); + + apiflags = conn->current_msg->msg.w.apiflags; + dontblock = netconn_is_nonblocking(conn) || (apiflags & NETCONN_DONTBLOCK); + +#if LWIP_SO_SNDTIMEO + if ((conn->send_timeout != 0) && + ((s32_t)(sys_now() - conn->current_msg->msg.w.time_started) >= conn->send_timeout)) { + write_finished = 1; + if (conn->current_msg->msg.w.offset == 0) { + /* nothing has been written */ + err = ERR_WOULDBLOCK; + } else { + /* partial write */ + err = ERR_OK; + } + } else +#endif /* LWIP_SO_SNDTIMEO */ + { + do { + dataptr = (const u8_t *)conn->current_msg->msg.w.vector->ptr + conn->current_msg->msg.w.vector_off; + diff = conn->current_msg->msg.w.vector->len - conn->current_msg->msg.w.vector_off; + if (diff > 0xffffUL) { /* max_u16_t */ + len = 0xffff; + apiflags |= TCP_WRITE_FLAG_MORE; + } else { + len = (u16_t)diff; + } + available = tcp_sndbuf(conn->pcb.tcp); + if (available < len) { + /* don't try to write more than sendbuf */ + len = available; + if (dontblock) { + if (!len) { + /* set error according to partial write or not */ + err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK; + goto err_mem; + } + } else { + apiflags |= TCP_WRITE_FLAG_MORE; + } + } + LWIP_ASSERT("lwip_netconn_do_writemore: invalid length!", + ((conn->current_msg->msg.w.vector_off + len) <= conn->current_msg->msg.w.vector->len)); + /* we should loop around for more sending in the following cases: + 1) We couldn't finish the current vector because of 16-bit size limitations. + tcp_write() and tcp_sndbuf() both are limited to 16-bit sizes + 2) We are sending the remainder of the current vector and have more */ + if ((len == 0xffff && diff > 0xffffUL) || + (len == (u16_t)diff && conn->current_msg->msg.w.vector_cnt > 1)) { + write_more = 1; + apiflags |= TCP_WRITE_FLAG_MORE; + } else { + write_more = 0; + } + err = tcp_write(conn->pcb.tcp, dataptr, len, apiflags); + if (err == ERR_OK) { + conn->current_msg->msg.w.offset += len; + conn->current_msg->msg.w.vector_off += len; + /* check if current vector is finished */ + if (conn->current_msg->msg.w.vector_off == conn->current_msg->msg.w.vector->len) { + conn->current_msg->msg.w.vector_cnt--; + /* if we have additional vectors, move on to them */ + if (conn->current_msg->msg.w.vector_cnt > 0) { + conn->current_msg->msg.w.vector++; + conn->current_msg->msg.w.vector_off = 0; + } + } + } + } while (write_more && err == ERR_OK); + /* if OK or memory error, check available space */ + if ((err == ERR_OK) || (err == ERR_MEM)) { +err_mem: + if (dontblock && (conn->current_msg->msg.w.offset < conn->current_msg->msg.w.len)) { + /* non-blocking write did not write everything: mark the pcb non-writable + and let poll_tcp check writable space to mark the pcb writable again */ + API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0); + conn->flags |= NETCONN_FLAG_CHECK_WRITESPACE; + } else if ((tcp_sndbuf(conn->pcb.tcp) <= TCP_SNDLOWAT) || + (tcp_sndqueuelen(conn->pcb.tcp) >= TCP_SNDQUEUELOWAT)) { + /* The queued byte- or pbuf-count exceeds the configured low-water limit, + let select mark this pcb as non-writable. */ + API_EVENT(conn, NETCONN_EVT_SENDMINUS, 0); + } + } + + if (err == ERR_OK) { + err_t out_err; + if ((conn->current_msg->msg.w.offset == conn->current_msg->msg.w.len) || dontblock) { + /* return sent length (caller reads length from msg.w.offset) */ + write_finished = 1; + } + out_err = tcp_output(conn->pcb.tcp); + if (out_err == ERR_RTE) { + /* If tcp_output fails because no route is found, + don't try writing any more but return the error + to the application thread. */ + err = out_err; + write_finished = 1; + } + } else if (err == ERR_MEM) { + /* If ERR_MEM, we wait for sent_tcp or poll_tcp to be called. + For blocking sockets, we do NOT return to the application + thread, since ERR_MEM is only a temporary error! Non-blocking + will remain non-writable until sent_tcp/poll_tcp is called */ + + /* tcp_write returned ERR_MEM, try tcp_output anyway */ + err_t out_err = tcp_output(conn->pcb.tcp); + if (out_err == ERR_RTE) { + /* If tcp_output fails because no route is found, + don't try writing any more but return the error + to the application thread. */ + err = out_err; + write_finished = 1; + } else if (dontblock) { + /* non-blocking write is done on ERR_MEM, set error according + to partial write or not */ + err = (conn->current_msg->msg.w.offset == 0) ? ERR_WOULDBLOCK : ERR_OK; + write_finished = 1; + } + } else { + /* On errors != ERR_MEM, we don't try writing any more but return + the error to the application thread. */ + write_finished = 1; + } + } + if (write_finished) { + /* everything was written: set back connection state + and back to application task */ + sys_sem_t *op_completed_sem = LWIP_API_MSG_SEM(conn->current_msg); + conn->current_msg->err = err; + conn->current_msg = NULL; + conn->state = NETCONN_NONE; +#if LWIP_TCPIP_CORE_LOCKING + if (delayed) +#endif + { + sys_sem_signal(op_completed_sem); + } + } +#if LWIP_TCPIP_CORE_LOCKING + else { + return ERR_MEM; + } +#endif + return ERR_OK; +} +#endif /* LWIP_TCP */ + +/** + * Send some data on a TCP pcb contained in a netconn + * Called from netconn_write + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_write(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + err_t err = netconn_err(msg->conn); + if (err == ERR_OK) { + if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) { +#if LWIP_TCP + if (msg->conn->state != NETCONN_NONE) { + /* netconn is connecting, closing or in blocking write */ + err = ERR_INPROGRESS; + } else if (msg->conn->pcb.tcp != NULL) { + msg->conn->state = NETCONN_WRITE; + /* set all the variables used by lwip_netconn_do_writemore */ + LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL); + LWIP_ASSERT("msg->msg.w.len != 0", msg->msg.w.len != 0); + msg->conn->current_msg = msg; +#if LWIP_TCPIP_CORE_LOCKING + if (lwip_netconn_do_writemore(msg->conn, 0) != ERR_OK) { + LWIP_ASSERT("state!", msg->conn->state == NETCONN_WRITE); + UNLOCK_TCPIP_CORE(); + sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); + LOCK_TCPIP_CORE(); + LWIP_ASSERT("state!", msg->conn->state != NETCONN_WRITE); + } +#else /* LWIP_TCPIP_CORE_LOCKING */ + lwip_netconn_do_writemore(msg->conn); +#endif /* LWIP_TCPIP_CORE_LOCKING */ + /* for both cases: if lwip_netconn_do_writemore was called, don't ACK the APIMSG + since lwip_netconn_do_writemore ACKs it! */ + return; + } else { + err = ERR_CONN; + } +#else /* LWIP_TCP */ + err = ERR_VAL; +#endif /* LWIP_TCP */ +#if (LWIP_UDP || LWIP_RAW) + } else { + err = ERR_VAL; +#endif /* (LWIP_UDP || LWIP_RAW) */ + } + } + msg->err = err; + TCPIP_APIMSG_ACK(msg); +} + +/** + * Return a connection's local or remote address + * Called from netconn_getaddr + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_getaddr(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + if (msg->conn->pcb.ip != NULL) { + if (msg->msg.ad.local) { + ip_addr_copy(API_EXPR_DEREF(msg->msg.ad.ipaddr), + msg->conn->pcb.ip->local_ip); + } else { + ip_addr_copy(API_EXPR_DEREF(msg->msg.ad.ipaddr), + msg->conn->pcb.ip->remote_ip); + } + + msg->err = ERR_OK; + switch (NETCONNTYPE_GROUP(msg->conn->type)) { +#if LWIP_RAW + case NETCONN_RAW: + if (msg->msg.ad.local) { + API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.raw->protocol; + } else { + /* return an error as connecting is only a helper for upper layers */ + msg->err = ERR_CONN; + } + break; +#endif /* LWIP_RAW */ +#if LWIP_UDP + case NETCONN_UDP: + if (msg->msg.ad.local) { + API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->local_port; + } else { + if ((msg->conn->pcb.udp->flags & UDP_FLAGS_CONNECTED) == 0) { + msg->err = ERR_CONN; + } else { + API_EXPR_DEREF(msg->msg.ad.port) = msg->conn->pcb.udp->remote_port; + } + } + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case NETCONN_TCP: + if ((msg->msg.ad.local == 0) && + ((msg->conn->pcb.tcp->state == CLOSED) || (msg->conn->pcb.tcp->state == LISTEN))) { + /* pcb is not connected and remote name is requested */ + msg->err = ERR_CONN; + } else { + API_EXPR_DEREF(msg->msg.ad.port) = (msg->msg.ad.local ? msg->conn->pcb.tcp->local_port : msg->conn->pcb.tcp->remote_port); + } + break; +#endif /* LWIP_TCP */ + default: + LWIP_ASSERT("invalid netconn_type", 0); + break; + } + } else { + msg->err = ERR_CONN; + } + TCPIP_APIMSG_ACK(msg); +} + +/** + * Close or half-shutdown a TCP pcb contained in a netconn + * Called from netconn_close + * In contrast to closing sockets, the netconn is not deallocated. + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_close(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + +#if LWIP_TCP + enum netconn_state state = msg->conn->state; + /* First check if this is a TCP netconn and if it is in a correct state + (LISTEN doesn't support half shutdown) */ + if ((msg->conn->pcb.tcp != NULL) && + (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_TCP) && + ((msg->msg.sd.shut == NETCONN_SHUT_RDWR) || (state != NETCONN_LISTEN))) { + /* Check if we are in a connected state */ + if (state == NETCONN_CONNECT) { + /* TCP connect in progress: cannot shutdown */ + msg->err = ERR_CONN; + } else if (state == NETCONN_WRITE) { +#if LWIP_NETCONN_FULLDUPLEX + if (msg->msg.sd.shut & NETCONN_SHUT_WR) { + /* close requested, abort running write */ + sys_sem_t *write_completed_sem; + LWIP_ASSERT("msg->conn->current_msg != NULL", msg->conn->current_msg != NULL); + write_completed_sem = LWIP_API_MSG_SEM(msg->conn->current_msg); + msg->conn->current_msg->err = ERR_CLSD; + msg->conn->current_msg = NULL; + msg->conn->state = NETCONN_NONE; + state = NETCONN_NONE; + sys_sem_signal(write_completed_sem); + } else { + LWIP_ASSERT("msg->msg.sd.shut == NETCONN_SHUT_RD", msg->msg.sd.shut == NETCONN_SHUT_RD); + /* In this case, let the write continue and do not interfere with + conn->current_msg or conn->state! */ + msg->err = tcp_shutdown(msg->conn->pcb.tcp, 1, 0); + } + } + if (state == NETCONN_NONE) { +#else /* LWIP_NETCONN_FULLDUPLEX */ + msg->err = ERR_INPROGRESS; + } else { +#endif /* LWIP_NETCONN_FULLDUPLEX */ + if (msg->msg.sd.shut & NETCONN_SHUT_RD) { +#if LWIP_NETCONN_FULLDUPLEX + /* Mark mboxes invalid */ + netconn_mark_mbox_invalid(msg->conn); +#else /* LWIP_NETCONN_FULLDUPLEX */ + netconn_drain(msg->conn); +#endif /* LWIP_NETCONN_FULLDUPLEX */ + } + LWIP_ASSERT("already writing or closing", msg->conn->current_msg == NULL); + msg->conn->state = NETCONN_CLOSE; + msg->conn->current_msg = msg; +#if LWIP_TCPIP_CORE_LOCKING + if (lwip_netconn_do_close_internal(msg->conn, 0) != ERR_OK) { + LWIP_ASSERT("state!", msg->conn->state == NETCONN_CLOSE); + UNLOCK_TCPIP_CORE(); + sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); + LOCK_TCPIP_CORE(); + LWIP_ASSERT("state!", msg->conn->state == NETCONN_NONE); + } +#else /* LWIP_TCPIP_CORE_LOCKING */ + lwip_netconn_do_close_internal(msg->conn); +#endif /* LWIP_TCPIP_CORE_LOCKING */ + /* for tcp netconns, lwip_netconn_do_close_internal ACKs the message */ + return; + } + } else +#endif /* LWIP_TCP */ + { + msg->err = ERR_CONN; + } + TCPIP_APIMSG_ACK(msg); +} + +#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) +/** + * Join multicast groups for UDP netconns. + * Called from netconn_join_leave_group + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_join_leave_group(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + + msg->err = ERR_CONN; + if (msg->conn->pcb.tcp != NULL) { + if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) { +#if LWIP_UDP +#if LWIP_IPV6 && LWIP_IPV6_MLD + if (NETCONNTYPE_ISIPV6(msg->conn->type)) { + if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { + msg->err = mld6_joingroup(ip_2_ip6(API_EXPR_REF(msg->msg.jl.netif_addr)), + ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); + } else { + msg->err = mld6_leavegroup(ip_2_ip6(API_EXPR_REF(msg->msg.jl.netif_addr)), + ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); + } + } else +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ + { +#if LWIP_IGMP + if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { + msg->err = igmp_joingroup(ip_2_ip4(API_EXPR_REF(msg->msg.jl.netif_addr)), + ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); + } else { + msg->err = igmp_leavegroup(ip_2_ip4(API_EXPR_REF(msg->msg.jl.netif_addr)), + ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); + } +#endif /* LWIP_IGMP */ + } +#endif /* LWIP_UDP */ +#if (LWIP_TCP || LWIP_RAW) + } else { + msg->err = ERR_VAL; +#endif /* (LWIP_TCP || LWIP_RAW) */ + } + } + TCPIP_APIMSG_ACK(msg); +} +/** + * Join multicast groups for UDP netconns. + * Called from netconn_join_leave_group_netif + * + * @param m the api_msg pointing to the connection + */ +void +lwip_netconn_do_join_leave_group_netif(void *m) +{ + struct api_msg *msg = (struct api_msg *)m; + struct netif *netif; + + netif = netif_get_by_index(msg->msg.jl.if_idx); + if (netif == NULL) { + msg->err = ERR_IF; + goto done; + } + + msg->err = ERR_CONN; + if (msg->conn->pcb.tcp != NULL) { + if (NETCONNTYPE_GROUP(msg->conn->type) == NETCONN_UDP) { +#if LWIP_UDP +#if LWIP_IPV6 && LWIP_IPV6_MLD + if (NETCONNTYPE_ISIPV6(msg->conn->type)) { + if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { + msg->err = mld6_joingroup_netif(netif, + ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); + } else { + msg->err = mld6_leavegroup_netif(netif, + ip_2_ip6(API_EXPR_REF(msg->msg.jl.multiaddr))); + } + } else +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ + { +#if LWIP_IGMP + if (msg->msg.jl.join_or_leave == NETCONN_JOIN) { + msg->err = igmp_joingroup_netif(netif, + ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); + } else { + msg->err = igmp_leavegroup_netif(netif, + ip_2_ip4(API_EXPR_REF(msg->msg.jl.multiaddr))); + } +#endif /* LWIP_IGMP */ + } +#endif /* LWIP_UDP */ +#if (LWIP_TCP || LWIP_RAW) + } else { + msg->err = ERR_VAL; +#endif /* (LWIP_TCP || LWIP_RAW) */ + } + } + +done: + TCPIP_APIMSG_ACK(msg); +} +#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ + +#if LWIP_DNS +/** + * Callback function that is called when DNS name is resolved + * (or on timeout). A waiting application thread is waked up by + * signaling the semaphore. + */ +static void +lwip_netconn_do_dns_found(const char *name, const ip_addr_t *ipaddr, void *arg) +{ + struct dns_api_msg *msg = (struct dns_api_msg *)arg; + + /* we trust the internal implementation to be correct :-) */ + LWIP_UNUSED_ARG(name); + + if (ipaddr == NULL) { + /* timeout or memory error */ + API_EXPR_DEREF(msg->err) = ERR_VAL; + } else { + /* address was resolved */ + API_EXPR_DEREF(msg->err) = ERR_OK; + API_EXPR_DEREF(msg->addr) = *ipaddr; + } + /* wake up the application task waiting in netconn_gethostbyname */ + sys_sem_signal(API_EXPR_REF_SEM(msg->sem)); +} + +/** + * Execute a DNS query + * Called from netconn_gethostbyname + * + * @param arg the dns_api_msg pointing to the query + */ +void +lwip_netconn_do_gethostbyname(void *arg) +{ + struct dns_api_msg *msg = (struct dns_api_msg *)arg; + u8_t addrtype = +#if LWIP_IPV4 && LWIP_IPV6 + msg->dns_addrtype; +#else + LWIP_DNS_ADDRTYPE_DEFAULT; +#endif + + API_EXPR_DEREF(msg->err) = dns_gethostbyname_addrtype(msg->name, + API_EXPR_REF(msg->addr), lwip_netconn_do_dns_found, msg, addrtype); +#if LWIP_TCPIP_CORE_LOCKING + /* For core locking, only block if we need to wait for answer/timeout */ + if (API_EXPR_DEREF(msg->err) == ERR_INPROGRESS) { + UNLOCK_TCPIP_CORE(); + sys_sem_wait(API_EXPR_REF_SEM(msg->sem)); + LOCK_TCPIP_CORE(); + LWIP_ASSERT("do_gethostbyname still in progress!!", API_EXPR_DEREF(msg->err) != ERR_INPROGRESS); + } +#else /* LWIP_TCPIP_CORE_LOCKING */ + if (API_EXPR_DEREF(msg->err) != ERR_INPROGRESS) { + /* on error or immediate success, wake up the application + * task waiting in netconn_gethostbyname */ + sys_sem_signal(API_EXPR_REF_SEM(msg->sem)); + } +#endif /* LWIP_TCPIP_CORE_LOCKING */ +} +#endif /* LWIP_DNS */ + +#endif /* LWIP_NETCONN */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/err.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/err.c index 17e28646..7643836f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/err.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/err.c @@ -1,127 +1,127 @@ -/** - * @file - * Error Management module - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/err.h" -#include "lwip/def.h" -#include "lwip/sys.h" - -#include "lwip/errno.h" - - -#if !NO_SYS - -//tmp -#define EHOSTUNREACH 113 /* No route to host */ -#define EINPROGRESS 115 /* Operation now in progress */ -#define EADDRINUSE 98 /* Address already in use */ -#define EALREADY 114 /* Operation already in progress */ -#define EISCONN 106 /* Transport endpoint is already connected */ -#define ENOTCONN 107 /* Transport endpoint is not connected */ -#define ECONNABORTED 103 /* Software caused connection abort */ - - -/** Table to quickly map an lwIP error (err_t) to a socket error - * by using -err as an index */ -static const int err_to_errno_table[] = { - 0, /* ERR_OK 0 No error, everything OK. */ - ENOMEM, /* ERR_MEM -1 Out of memory error. */ - ENOBUFS, /* ERR_BUF -2 Buffer error. */ - EWOULDBLOCK, /* ERR_TIMEOUT -3 Timeout */ - EHOSTUNREACH, /* ERR_RTE -4 Routing problem. */ - EINPROGRESS, /* ERR_INPROGRESS -5 Operation in progress */ - EINVAL, /* ERR_VAL -6 Illegal value. */ - EWOULDBLOCK, /* ERR_WOULDBLOCK -7 Operation would block. */ - EADDRINUSE, /* ERR_USE -8 Address in use. */ - EALREADY, /* ERR_ALREADY -9 Already connecting. */ - EISCONN, /* ERR_ISCONN -10 Conn already established.*/ - ENOTCONN, /* ERR_CONN -11 Not connected. */ - -1, /* ERR_IF -12 Low-level netif error */ - ECONNABORTED, /* ERR_ABRT -13 Connection aborted. */ - ECONNRESET, /* ERR_RST -14 Connection reset. */ - ENOTCONN, /* ERR_CLSD -15 Connection closed. */ - EIO /* ERR_ARG -16 Illegal argument. */ -}; - -int -err_to_errno(err_t err) -{ - if ((err > 0) || (-err >= (err_t)LWIP_ARRAYSIZE(err_to_errno_table))) { - return EIO; - } - return err_to_errno_table[-err]; -} -#endif /* !NO_SYS */ - -#ifdef LWIP_DEBUG - -static const char *err_strerr[] = { - "Ok.", /* ERR_OK 0 */ - "Out of memory error.", /* ERR_MEM -1 */ - "Buffer error.", /* ERR_BUF -2 */ - "Timeout.", /* ERR_TIMEOUT -3 */ - "Routing problem.", /* ERR_RTE -4 */ - "Operation in progress.", /* ERR_INPROGRESS -5 */ - "Illegal value.", /* ERR_VAL -6 */ - "Operation would block.", /* ERR_WOULDBLOCK -7 */ - "Address in use.", /* ERR_USE -8 */ - "Already connecting.", /* ERR_ALREADY -9 */ - "Already connected.", /* ERR_ISCONN -10 */ - "Not connected.", /* ERR_CONN -11 */ - "Low-level netif error.", /* ERR_IF -12 */ - "Connection aborted.", /* ERR_ABRT -13 */ - "Connection reset.", /* ERR_RST -14 */ - "Connection closed.", /* ERR_CLSD -15 */ - "Illegal argument." /* ERR_ARG -16 */ -}; - -/** - * Convert an lwip internal error to a string representation. - * - * @param err an lwip internal err_t - * @return a string representation for err - */ -const char * -lwip_strerr(err_t err) -{ - if ((err > 0) || (-err >= (err_t)LWIP_ARRAYSIZE(err_strerr))) { - return "Unknown error."; - } - return err_strerr[-err]; -} - -#endif /* LWIP_DEBUG */ +/** + * @file + * Error Management module + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/err.h" +#include "lwip/def.h" +#include "lwip/sys.h" + +#include "lwip/errno.h" + + +#if !NO_SYS + +//tmp +#define EHOSTUNREACH 113 /* No route to host */ +#define EINPROGRESS 115 /* Operation now in progress */ +#define EADDRINUSE 98 /* Address already in use */ +#define EALREADY 114 /* Operation already in progress */ +#define EISCONN 106 /* Transport endpoint is already connected */ +#define ENOTCONN 107 /* Transport endpoint is not connected */ +#define ECONNABORTED 103 /* Software caused connection abort */ + + +/** Table to quickly map an lwIP error (err_t) to a socket error + * by using -err as an index */ +static const int err_to_errno_table[] = { + 0, /* ERR_OK 0 No error, everything OK. */ + ENOMEM, /* ERR_MEM -1 Out of memory error. */ + ENOBUFS, /* ERR_BUF -2 Buffer error. */ + EWOULDBLOCK, /* ERR_TIMEOUT -3 Timeout */ + EHOSTUNREACH, /* ERR_RTE -4 Routing problem. */ + EINPROGRESS, /* ERR_INPROGRESS -5 Operation in progress */ + EINVAL, /* ERR_VAL -6 Illegal value. */ + EWOULDBLOCK, /* ERR_WOULDBLOCK -7 Operation would block. */ + EADDRINUSE, /* ERR_USE -8 Address in use. */ + EALREADY, /* ERR_ALREADY -9 Already connecting. */ + EISCONN, /* ERR_ISCONN -10 Conn already established.*/ + ENOTCONN, /* ERR_CONN -11 Not connected. */ + -1, /* ERR_IF -12 Low-level netif error */ + ECONNABORTED, /* ERR_ABRT -13 Connection aborted. */ + ECONNRESET, /* ERR_RST -14 Connection reset. */ + ENOTCONN, /* ERR_CLSD -15 Connection closed. */ + EIO /* ERR_ARG -16 Illegal argument. */ +}; + +int +err_to_errno(err_t err) +{ + if ((err > 0) || (-err >= (err_t)LWIP_ARRAYSIZE(err_to_errno_table))) { + return EIO; + } + return err_to_errno_table[-err]; +} +#endif /* !NO_SYS */ + +#ifdef LWIP_DEBUG + +static const char *err_strerr[] = { + "Ok.", /* ERR_OK 0 */ + "Out of memory error.", /* ERR_MEM -1 */ + "Buffer error.", /* ERR_BUF -2 */ + "Timeout.", /* ERR_TIMEOUT -3 */ + "Routing problem.", /* ERR_RTE -4 */ + "Operation in progress.", /* ERR_INPROGRESS -5 */ + "Illegal value.", /* ERR_VAL -6 */ + "Operation would block.", /* ERR_WOULDBLOCK -7 */ + "Address in use.", /* ERR_USE -8 */ + "Already connecting.", /* ERR_ALREADY -9 */ + "Already connected.", /* ERR_ISCONN -10 */ + "Not connected.", /* ERR_CONN -11 */ + "Low-level netif error.", /* ERR_IF -12 */ + "Connection aborted.", /* ERR_ABRT -13 */ + "Connection reset.", /* ERR_RST -14 */ + "Connection closed.", /* ERR_CLSD -15 */ + "Illegal argument." /* ERR_ARG -16 */ +}; + +/** + * Convert an lwip internal error to a string representation. + * + * @param err an lwip internal err_t + * @return a string representation for err + */ +const char * +lwip_strerr(err_t err) +{ + if ((err > 0) || (-err >= (err_t)LWIP_ARRAYSIZE(err_strerr))) { + return "Unknown error."; + } + return err_strerr[-err]; +} + +#endif /* LWIP_DEBUG */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/if_api.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/if_api.c index 2eda9f0b..8e094d09 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/if_api.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/if_api.c @@ -1,102 +1,102 @@ -/** - * @file - * Interface Identification APIs from: - * RFC 3493: Basic Socket Interface Extensions for IPv6 - * Section 4: Interface Identification - * - * @defgroup if_api Interface Identification API - * @ingroup socket - */ - -/* - * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Joel Cunningham - * - */ -#include "lwip/opt.h" - -#if LWIP_SOCKET - -#include "lwip/errno.h" -#include "lwip/if_api.h" -#include "lwip/netifapi.h" -#include "lwip/priv/sockets_priv.h" - -/** - * @ingroup if_api - * Maps an interface index to its corresponding name. - * @param ifindex interface index - * @param ifname shall point to a buffer of at least {IF_NAMESIZE} bytes - * @return If ifindex is an interface index, then the function shall return the - * value supplied in ifname, which points to a buffer now containing the interface name. - * Otherwise, the function shall return a NULL pointer. - */ -char * -lwip_if_indextoname(unsigned int ifindex, char *ifname) -{ -#if LWIP_NETIF_API - if (ifindex <= 0xff) { - err_t err = netifapi_netif_index_to_name((u8_t)ifindex, ifname); - if (!err && ifname[0] != '\0') { - return ifname; - } - } -#else /* LWIP_NETIF_API */ - LWIP_UNUSED_ARG(ifindex); - LWIP_UNUSED_ARG(ifname); -#endif /* LWIP_NETIF_API */ - set_errno(ENXIO); - return NULL; -} - -/** - * @ingroup if_api - * Returs the interface index corresponding to name ifname. - * @param ifname Interface name - * @return The corresponding index if ifname is the name of an interface; - * otherwise, zero. - */ -unsigned int -lwip_if_nametoindex(const char *ifname) -{ -#if LWIP_NETIF_API - err_t err; - u8_t idx; - - err = netifapi_netif_name_to_index(ifname, &idx); - if (!err) { - return idx; - } -#else /* LWIP_NETIF_API */ - LWIP_UNUSED_ARG(ifname); -#endif /* LWIP_NETIF_API */ - return 0; /* invalid index */ -} - -#endif /* LWIP_SOCKET */ +/** + * @file + * Interface Identification APIs from: + * RFC 3493: Basic Socket Interface Extensions for IPv6 + * Section 4: Interface Identification + * + * @defgroup if_api Interface Identification API + * @ingroup socket + */ + +/* + * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Joel Cunningham + * + */ +#include "lwip/opt.h" + +#if LWIP_SOCKET + +#include "lwip/errno.h" +#include "lwip/if_api.h" +#include "lwip/netifapi.h" +#include "lwip/priv/sockets_priv.h" + +/** + * @ingroup if_api + * Maps an interface index to its corresponding name. + * @param ifindex interface index + * @param ifname shall point to a buffer of at least {IF_NAMESIZE} bytes + * @return If ifindex is an interface index, then the function shall return the + * value supplied in ifname, which points to a buffer now containing the interface name. + * Otherwise, the function shall return a NULL pointer. + */ +char * +lwip_if_indextoname(unsigned int ifindex, char *ifname) +{ +#if LWIP_NETIF_API + if (ifindex <= 0xff) { + err_t err = netifapi_netif_index_to_name((u8_t)ifindex, ifname); + if (!err && ifname[0] != '\0') { + return ifname; + } + } +#else /* LWIP_NETIF_API */ + LWIP_UNUSED_ARG(ifindex); + LWIP_UNUSED_ARG(ifname); +#endif /* LWIP_NETIF_API */ + set_errno(ENXIO); + return NULL; +} + +/** + * @ingroup if_api + * Returs the interface index corresponding to name ifname. + * @param ifname Interface name + * @return The corresponding index if ifname is the name of an interface; + * otherwise, zero. + */ +unsigned int +lwip_if_nametoindex(const char *ifname) +{ +#if LWIP_NETIF_API + err_t err; + u8_t idx; + + err = netifapi_netif_name_to_index(ifname, &idx); + if (!err) { + return idx; + } +#else /* LWIP_NETIF_API */ + LWIP_UNUSED_ARG(ifname); +#endif /* LWIP_NETIF_API */ + return 0; /* invalid index */ +} + +#endif /* LWIP_SOCKET */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netbuf.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netbuf.c index b4644404..3b910de1 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netbuf.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netbuf.c @@ -1,250 +1,250 @@ -/** - * @file - * Network buffer management - * - * @defgroup netbuf Network buffers - * @ingroup netconn - * Network buffer descriptor for @ref netconn. Based on @ref pbuf internally - * to avoid copying data around.\n - * Buffers must not be shared accross multiple threads, all functions except - * netbuf_new() and netbuf_delete() are not thread-safe. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/netbuf.h" -#include "lwip/memp.h" - -#include - -/** - * @ingroup netbuf - * Create (allocate) and initialize a new netbuf. - * The netbuf doesn't yet contain a packet buffer! - * - * @return a pointer to a new netbuf - * NULL on lack of memory - */ -struct -netbuf *netbuf_new(void) -{ - struct netbuf *buf; - - buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); - if (buf != NULL) { - memset(buf, 0, sizeof(struct netbuf)); - } - return buf; -} - -/** - * @ingroup netbuf - * Deallocate a netbuf allocated by netbuf_new(). - * - * @param buf pointer to a netbuf allocated by netbuf_new() - */ -void -netbuf_delete(struct netbuf *buf) -{ - if (buf != NULL) { - if (buf->p != NULL) { - pbuf_free(buf->p); - buf->p = buf->ptr = NULL; - } - memp_free(MEMP_NETBUF, buf); - } -} - -/** - * @ingroup netbuf - * Allocate memory for a packet buffer for a given netbuf. - * - * @param buf the netbuf for which to allocate a packet buffer - * @param size the size of the packet buffer to allocate - * @return pointer to the allocated memory - * NULL if no memory could be allocated - */ -void * -netbuf_alloc(struct netbuf *buf, u16_t size) -{ - LWIP_ERROR("netbuf_alloc: invalid buf", (buf != NULL), return NULL;); - - /* Deallocate any previously allocated memory. */ - if (buf->p != NULL) { - pbuf_free(buf->p); - } - buf->p = pbuf_alloc(PBUF_TRANSPORT, size, PBUF_RAM); - if (buf->p == NULL) { - return NULL; - } - LWIP_ASSERT("check that first pbuf can hold size", - (buf->p->len >= size)); - buf->ptr = buf->p; - return buf->p->payload; -} - -/** - * @ingroup netbuf - * Free the packet buffer included in a netbuf - * - * @param buf pointer to the netbuf which contains the packet buffer to free - */ -void -netbuf_free(struct netbuf *buf) -{ - LWIP_ERROR("netbuf_free: invalid buf", (buf != NULL), return;); - if (buf->p != NULL) { - pbuf_free(buf->p); - } - buf->p = buf->ptr = NULL; -#if LWIP_CHECKSUM_ON_COPY - buf->flags = 0; - buf->toport_chksum = 0; -#endif /* LWIP_CHECKSUM_ON_COPY */ -} - -/** - * @ingroup netbuf - * Let a netbuf reference existing (non-volatile) data. - * - * @param buf netbuf which should reference the data - * @param dataptr pointer to the data to reference - * @param size size of the data - * @return ERR_OK if data is referenced - * ERR_MEM if data couldn't be referenced due to lack of memory - */ -err_t -netbuf_ref(struct netbuf *buf, const void *dataptr, u16_t size) -{ - LWIP_ERROR("netbuf_ref: invalid buf", (buf != NULL), return ERR_ARG;); - if (buf->p != NULL) { - pbuf_free(buf->p); - } - buf->p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF); - if (buf->p == NULL) { - buf->ptr = NULL; - return ERR_MEM; - } - ((struct pbuf_rom *)buf->p)->payload = dataptr; - buf->p->len = buf->p->tot_len = size; - buf->ptr = buf->p; - return ERR_OK; -} - -/** - * @ingroup netbuf - * Chain one netbuf to another (@see pbuf_chain) - * - * @param head the first netbuf - * @param tail netbuf to chain after head, freed by this function, may not be reference after returning - */ -void -netbuf_chain(struct netbuf *head, struct netbuf *tail) -{ - LWIP_ERROR("netbuf_chain: invalid head", (head != NULL), return;); - LWIP_ERROR("netbuf_chain: invalid tail", (tail != NULL), return;); - pbuf_cat(head->p, tail->p); - head->ptr = head->p; - memp_free(MEMP_NETBUF, tail); -} - -/** - * @ingroup netbuf - * Get the data pointer and length of the data inside a netbuf. - * - * @param buf netbuf to get the data from - * @param dataptr pointer to a void pointer where to store the data pointer - * @param len pointer to an u16_t where the length of the data is stored - * @return ERR_OK if the information was retrieved, - * ERR_BUF on error. - */ -err_t -netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len) -{ - LWIP_ERROR("netbuf_data: invalid buf", (buf != NULL), return ERR_ARG;); - LWIP_ERROR("netbuf_data: invalid dataptr", (dataptr != NULL), return ERR_ARG;); - LWIP_ERROR("netbuf_data: invalid len", (len != NULL), return ERR_ARG;); - - if (buf->ptr == NULL) { - return ERR_BUF; - } - *dataptr = buf->ptr->payload; - *len = buf->ptr->len; - return ERR_OK; -} - -/** - * @ingroup netbuf - * Move the current data pointer of a packet buffer contained in a netbuf - * to the next part. - * The packet buffer itself is not modified. - * - * @param buf the netbuf to modify - * @return -1 if there is no next part - * 1 if moved to the next part but now there is no next part - * 0 if moved to the next part and there are still more parts - */ -s8_t -netbuf_next(struct netbuf *buf) -{ - LWIP_ERROR("netbuf_next: invalid buf", (buf != NULL), return -1;); - if (buf->ptr->next == NULL) { - return -1; - } - buf->ptr = buf->ptr->next; - if (buf->ptr->next == NULL) { - return 1; - } - return 0; -} - -/** - * @ingroup netbuf - * Move the current data pointer of a packet buffer contained in a netbuf - * to the beginning of the packet. - * The packet buffer itself is not modified. - * - * @param buf the netbuf to modify - */ -void -netbuf_first(struct netbuf *buf) -{ - LWIP_ERROR("netbuf_first: invalid buf", (buf != NULL), return;); - buf->ptr = buf->p; -} - -#endif /* LWIP_NETCONN */ +/** + * @file + * Network buffer management + * + * @defgroup netbuf Network buffers + * @ingroup netconn + * Network buffer descriptor for @ref netconn. Based on @ref pbuf internally + * to avoid copying data around.\n + * Buffers must not be shared accross multiple threads, all functions except + * netbuf_new() and netbuf_delete() are not thread-safe. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_NETCONN /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/netbuf.h" +#include "lwip/memp.h" + +#include + +/** + * @ingroup netbuf + * Create (allocate) and initialize a new netbuf. + * The netbuf doesn't yet contain a packet buffer! + * + * @return a pointer to a new netbuf + * NULL on lack of memory + */ +struct +netbuf *netbuf_new(void) +{ + struct netbuf *buf; + + buf = (struct netbuf *)memp_malloc(MEMP_NETBUF); + if (buf != NULL) { + memset(buf, 0, sizeof(struct netbuf)); + } + return buf; +} + +/** + * @ingroup netbuf + * Deallocate a netbuf allocated by netbuf_new(). + * + * @param buf pointer to a netbuf allocated by netbuf_new() + */ +void +netbuf_delete(struct netbuf *buf) +{ + if (buf != NULL) { + if (buf->p != NULL) { + pbuf_free(buf->p); + buf->p = buf->ptr = NULL; + } + memp_free(MEMP_NETBUF, buf); + } +} + +/** + * @ingroup netbuf + * Allocate memory for a packet buffer for a given netbuf. + * + * @param buf the netbuf for which to allocate a packet buffer + * @param size the size of the packet buffer to allocate + * @return pointer to the allocated memory + * NULL if no memory could be allocated + */ +void * +netbuf_alloc(struct netbuf *buf, u16_t size) +{ + LWIP_ERROR("netbuf_alloc: invalid buf", (buf != NULL), return NULL;); + + /* Deallocate any previously allocated memory. */ + if (buf->p != NULL) { + pbuf_free(buf->p); + } + buf->p = pbuf_alloc(PBUF_TRANSPORT, size, PBUF_RAM); + if (buf->p == NULL) { + return NULL; + } + LWIP_ASSERT("check that first pbuf can hold size", + (buf->p->len >= size)); + buf->ptr = buf->p; + return buf->p->payload; +} + +/** + * @ingroup netbuf + * Free the packet buffer included in a netbuf + * + * @param buf pointer to the netbuf which contains the packet buffer to free + */ +void +netbuf_free(struct netbuf *buf) +{ + LWIP_ERROR("netbuf_free: invalid buf", (buf != NULL), return;); + if (buf->p != NULL) { + pbuf_free(buf->p); + } + buf->p = buf->ptr = NULL; +#if LWIP_CHECKSUM_ON_COPY + buf->flags = 0; + buf->toport_chksum = 0; +#endif /* LWIP_CHECKSUM_ON_COPY */ +} + +/** + * @ingroup netbuf + * Let a netbuf reference existing (non-volatile) data. + * + * @param buf netbuf which should reference the data + * @param dataptr pointer to the data to reference + * @param size size of the data + * @return ERR_OK if data is referenced + * ERR_MEM if data couldn't be referenced due to lack of memory + */ +err_t +netbuf_ref(struct netbuf *buf, const void *dataptr, u16_t size) +{ + LWIP_ERROR("netbuf_ref: invalid buf", (buf != NULL), return ERR_ARG;); + if (buf->p != NULL) { + pbuf_free(buf->p); + } + buf->p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF); + if (buf->p == NULL) { + buf->ptr = NULL; + return ERR_MEM; + } + ((struct pbuf_rom *)buf->p)->payload = dataptr; + buf->p->len = buf->p->tot_len = size; + buf->ptr = buf->p; + return ERR_OK; +} + +/** + * @ingroup netbuf + * Chain one netbuf to another (@see pbuf_chain) + * + * @param head the first netbuf + * @param tail netbuf to chain after head, freed by this function, may not be reference after returning + */ +void +netbuf_chain(struct netbuf *head, struct netbuf *tail) +{ + LWIP_ERROR("netbuf_chain: invalid head", (head != NULL), return;); + LWIP_ERROR("netbuf_chain: invalid tail", (tail != NULL), return;); + pbuf_cat(head->p, tail->p); + head->ptr = head->p; + memp_free(MEMP_NETBUF, tail); +} + +/** + * @ingroup netbuf + * Get the data pointer and length of the data inside a netbuf. + * + * @param buf netbuf to get the data from + * @param dataptr pointer to a void pointer where to store the data pointer + * @param len pointer to an u16_t where the length of the data is stored + * @return ERR_OK if the information was retrieved, + * ERR_BUF on error. + */ +err_t +netbuf_data(struct netbuf *buf, void **dataptr, u16_t *len) +{ + LWIP_ERROR("netbuf_data: invalid buf", (buf != NULL), return ERR_ARG;); + LWIP_ERROR("netbuf_data: invalid dataptr", (dataptr != NULL), return ERR_ARG;); + LWIP_ERROR("netbuf_data: invalid len", (len != NULL), return ERR_ARG;); + + if (buf->ptr == NULL) { + return ERR_BUF; + } + *dataptr = buf->ptr->payload; + *len = buf->ptr->len; + return ERR_OK; +} + +/** + * @ingroup netbuf + * Move the current data pointer of a packet buffer contained in a netbuf + * to the next part. + * The packet buffer itself is not modified. + * + * @param buf the netbuf to modify + * @return -1 if there is no next part + * 1 if moved to the next part but now there is no next part + * 0 if moved to the next part and there are still more parts + */ +s8_t +netbuf_next(struct netbuf *buf) +{ + LWIP_ERROR("netbuf_next: invalid buf", (buf != NULL), return -1;); + if (buf->ptr->next == NULL) { + return -1; + } + buf->ptr = buf->ptr->next; + if (buf->ptr->next == NULL) { + return 1; + } + return 0; +} + +/** + * @ingroup netbuf + * Move the current data pointer of a packet buffer contained in a netbuf + * to the beginning of the packet. + * The packet buffer itself is not modified. + * + * @param buf the netbuf to modify + */ +void +netbuf_first(struct netbuf *buf) +{ + LWIP_ERROR("netbuf_first: invalid buf", (buf != NULL), return;); + buf->ptr = buf->p; +} + +#endif /* LWIP_NETCONN */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netdb.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netdb.c index 9ffc75a2..87714259 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netdb.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netdb.c @@ -1,414 +1,414 @@ -/** - * @file - * API functions for name resolving - * - * @defgroup netdbapi NETDB API - * @ingroup socket - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#include "lwip/netdb.h" - -#if LWIP_DNS && LWIP_SOCKET - -#include "lwip/err.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/ip_addr.h" -#include "lwip/api.h" -#include "lwip/dns.h" - -#include /* memset */ -#include /* atoi */ - -/** helper struct for gethostbyname_r to access the char* buffer */ -struct gethostbyname_r_helper { - ip_addr_t *addr_list[2]; - ip_addr_t addr; - char *aliases; -}; - -/** h_errno is exported in netdb.h for access by applications. */ -#if LWIP_DNS_API_DECLARE_H_ERRNO -int h_errno; -#endif /* LWIP_DNS_API_DECLARE_H_ERRNO */ - -/** define "hostent" variables storage: 0 if we use a static (but unprotected) - * set of variables for lwip_gethostbyname, 1 if we use a local storage */ -#ifndef LWIP_DNS_API_HOSTENT_STORAGE -#define LWIP_DNS_API_HOSTENT_STORAGE 0 -#endif - -/** define "hostent" variables storage */ -#if LWIP_DNS_API_HOSTENT_STORAGE -#define HOSTENT_STORAGE -#else -#define HOSTENT_STORAGE static -#endif /* LWIP_DNS_API_STATIC_HOSTENT */ - -/** - * Returns an entry containing addresses of address family AF_INET - * for the host with name name. - * Due to dns_gethostbyname limitations, only one address is returned. - * - * @param name the hostname to resolve - * @return an entry containing addresses of address family AF_INET - * for the host with name name - */ -struct hostent * -lwip_gethostbyname(const char *name) -{ - err_t err; - ip_addr_t addr; - - /* buffer variables for lwip_gethostbyname() */ - HOSTENT_STORAGE struct hostent s_hostent; - HOSTENT_STORAGE char *s_aliases; - HOSTENT_STORAGE ip_addr_t s_hostent_addr; - HOSTENT_STORAGE ip_addr_t *s_phostent_addr[2]; - HOSTENT_STORAGE char s_hostname[DNS_MAX_NAME_LENGTH + 1]; - - /* query host IP address */ - err = netconn_gethostbyname(name, &addr); - if (err != ERR_OK) { - LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err)); - h_errno = HOST_NOT_FOUND; - return NULL; - } - - /* fill hostent */ - s_hostent_addr = addr; - s_phostent_addr[0] = &s_hostent_addr; - s_phostent_addr[1] = NULL; - strncpy(s_hostname, name, DNS_MAX_NAME_LENGTH); - s_hostname[DNS_MAX_NAME_LENGTH] = 0; - s_hostent.h_name = s_hostname; - s_aliases = NULL; - s_hostent.h_aliases = &s_aliases; - s_hostent.h_addrtype = AF_INET; - s_hostent.h_length = sizeof(ip_addr_t); - s_hostent.h_addr_list = (char **)&s_phostent_addr; - -#if DNS_DEBUG - /* dump hostent */ - LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_name == %s\n", s_hostent.h_name)); - LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases == %p\n", (void *)s_hostent.h_aliases)); - /* h_aliases are always empty */ - LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addrtype == %d\n", s_hostent.h_addrtype)); - LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_length == %d\n", s_hostent.h_length)); - LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list == %p\n", (void *)s_hostent.h_addr_list)); - if (s_hostent.h_addr_list != NULL) { - u8_t idx; - for (idx = 0; s_hostent.h_addr_list[idx]; idx++) { - LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i] == %p\n", idx, s_hostent.h_addr_list[idx])); - LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]-> == %s\n", idx, ipaddr_ntoa((ip_addr_t *)s_hostent.h_addr_list[idx]))); - } - } -#endif /* DNS_DEBUG */ - -#if LWIP_DNS_API_HOSTENT_STORAGE - /* this function should return the "per-thread" hostent after copy from s_hostent */ - return sys_thread_hostent(&s_hostent); -#else - return &s_hostent; -#endif /* LWIP_DNS_API_HOSTENT_STORAGE */ -} - -/** - * Thread-safe variant of lwip_gethostbyname: instead of using a static - * buffer, this function takes buffer and errno pointers as arguments - * and uses these for the result. - * - * @param name the hostname to resolve - * @param ret pre-allocated struct where to store the result - * @param buf pre-allocated buffer where to store additional data - * @param buflen the size of buf - * @param result pointer to a hostent pointer that is set to ret on success - * and set to zero on error - * @param h_errnop pointer to an int where to store errors (instead of modifying - * the global h_errno) - * @return 0 on success, non-zero on error, additional error information - * is stored in *h_errnop instead of h_errno to be thread-safe - */ -int -lwip_gethostbyname_r(const char *name, struct hostent *ret, char *buf, - size_t buflen, struct hostent **result, int *h_errnop) -{ - err_t err; - struct gethostbyname_r_helper *h; - char *hostname; - size_t namelen; - int lh_errno; - - if (h_errnop == NULL) { - /* ensure h_errnop is never NULL */ - h_errnop = &lh_errno; - } - - if (result == NULL) { - /* not all arguments given */ - *h_errnop = EINVAL; - return -1; - } - /* first thing to do: set *result to nothing */ - *result = NULL; - if ((name == NULL) || (ret == NULL) || (buf == NULL)) { - /* not all arguments given */ - *h_errnop = EINVAL; - return -1; - } - - namelen = strlen(name); - if (buflen < (sizeof(struct gethostbyname_r_helper) + LWIP_MEM_ALIGN_BUFFER(namelen + 1))) { - /* buf can't hold the data needed + a copy of name */ - *h_errnop = ERANGE; - return -1; - } - - h = (struct gethostbyname_r_helper *)LWIP_MEM_ALIGN(buf); - hostname = ((char *)h) + sizeof(struct gethostbyname_r_helper); - - /* query host IP address */ - err = netconn_gethostbyname(name, &h->addr); - if (err != ERR_OK) { - LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err)); - *h_errnop = HOST_NOT_FOUND; - return -1; - } - - /* copy the hostname into buf */ - MEMCPY(hostname, name, namelen); - hostname[namelen] = 0; - - /* fill hostent */ - h->addr_list[0] = &h->addr; - h->addr_list[1] = NULL; - h->aliases = NULL; - ret->h_name = hostname; - ret->h_aliases = &h->aliases; - ret->h_addrtype = AF_INET; - ret->h_length = sizeof(ip_addr_t); - ret->h_addr_list = (char **)&h->addr_list; - - /* set result != NULL */ - *result = ret; - - /* return success */ - return 0; -} - -/** - * Frees one or more addrinfo structures returned by getaddrinfo(), along with - * any additional storage associated with those structures. If the ai_next field - * of the structure is not null, the entire list of structures is freed. - * - * @param ai struct addrinfo to free - */ -void -lwip_freeaddrinfo(struct addrinfo *ai) -{ - struct addrinfo *next; - - while (ai != NULL) { - next = ai->ai_next; - memp_free(MEMP_NETDB, ai); - ai = next; - } -} - -/** - * Translates the name of a service location (for example, a host name) and/or - * a service name and returns a set of socket addresses and associated - * information to be used in creating a socket with which to address the - * specified service. - * Memory for the result is allocated internally and must be freed by calling - * lwip_freeaddrinfo()! - * - * Due to a limitation in dns_gethostbyname, only the first address of a - * host is returned. - * Also, service names are not supported (only port numbers)! - * - * @param nodename descriptive name or address string of the host - * (may be NULL -> local address) - * @param servname port number as string of NULL - * @param hints structure containing input values that set socktype and protocol - * @param res pointer to a pointer where to store the result (set to NULL on failure) - * @return 0 on success, non-zero on failure - * - * @todo: implement AI_V4MAPPED, AI_ADDRCONFIG - */ -int -lwip_getaddrinfo(const char *nodename, const char *servname, - const struct addrinfo *hints, struct addrinfo **res) -{ - err_t err; - ip_addr_t addr; - struct addrinfo *ai; - struct sockaddr_storage *sa = NULL; - int port_nr = 0; - size_t total_size; - size_t namelen = 0; - int ai_family; - - if (res == NULL) { - return EAI_FAIL; - } - *res = NULL; - if ((nodename == NULL) && (servname == NULL)) { - return EAI_NONAME; - } - - if (hints != NULL) { - ai_family = hints->ai_family; - if ((ai_family != AF_UNSPEC) -#if LWIP_IPV4 - && (ai_family != AF_INET) -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 - && (ai_family != AF_INET6) -#endif /* LWIP_IPV6 */ - ) { - return EAI_FAMILY; - } - } else { - ai_family = AF_UNSPEC; - } - - if (servname != NULL) { - /* service name specified: convert to port number - * @todo?: currently, only ASCII integers (port numbers) are supported (AI_NUMERICSERV)! */ - port_nr = atoi(servname); - if ((port_nr <= 0) || (port_nr > 0xffff)) { - return EAI_SERVICE; - } - } - - if (nodename != NULL) { - /* service location specified, try to resolve */ - if ((hints != NULL) && (hints->ai_flags & AI_NUMERICHOST)) { - /* no DNS lookup, just parse for an address string */ - if (!ipaddr_aton(nodename, &addr)) { - return EAI_NONAME; - } -#if LWIP_IPV4 && LWIP_IPV6 - if ((IP_IS_V6_VAL(addr) && ai_family == AF_INET) || - (IP_IS_V4_VAL(addr) && ai_family == AF_INET6)) { - return EAI_NONAME; - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - } else { -#if LWIP_IPV4 && LWIP_IPV6 - /* AF_UNSPEC: prefer IPv4 */ - u8_t type = NETCONN_DNS_IPV4_IPV6; - if (ai_family == AF_INET) { - type = NETCONN_DNS_IPV4; - } else if (ai_family == AF_INET6) { - type = NETCONN_DNS_IPV6; - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - err = netconn_gethostbyname_addrtype(nodename, &addr, type); - if (err != ERR_OK) { - return EAI_FAIL; - } - } - } else { - /* service location specified, use loopback address */ - if ((hints != NULL) && (hints->ai_flags & AI_PASSIVE)) { - ip_addr_set_any_val(ai_family == AF_INET6, addr); - } else { - ip_addr_set_loopback_val(ai_family == AF_INET6, addr); - } - } - - total_size = sizeof(struct addrinfo) + sizeof(struct sockaddr_storage); - if (nodename != NULL) { - namelen = strlen(nodename); - if (namelen > DNS_MAX_NAME_LENGTH) { - /* invalid name length */ - return EAI_FAIL; - } - LWIP_ASSERT("namelen is too long", total_size + namelen + 1 > total_size); - total_size += namelen + 1; - } - /* If this fails, please report to lwip-devel! :-) */ - LWIP_ASSERT("total_size <= NETDB_ELEM_SIZE: please report this!", - total_size <= NETDB_ELEM_SIZE); - ai = (struct addrinfo *)memp_malloc(MEMP_NETDB); - if (ai == NULL) { - return EAI_MEMORY; - } - memset(ai, 0, total_size); - /* cast through void* to get rid of alignment warnings */ - sa = (struct sockaddr_storage *)(void *)((u8_t *)ai + sizeof(struct addrinfo)); - if (IP_IS_V6_VAL(addr)) { -#if LWIP_IPV6 - struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa; - /* set up sockaddr */ - inet6_addr_from_ip6addr(&sa6->sin6_addr, ip_2_ip6(&addr)); - sa6->sin6_family = AF_INET6; - sa6->sin6_len = sizeof(struct sockaddr_in6); - sa6->sin6_port = lwip_htons((u16_t)port_nr); - sa6->sin6_scope_id = ip6_addr_zone(ip_2_ip6(&addr)); - ai->ai_family = AF_INET6; -#endif /* LWIP_IPV6 */ - } else { -#if LWIP_IPV4 - struct sockaddr_in *sa4 = (struct sockaddr_in *)sa; - /* set up sockaddr */ - inet_addr_from_ip4addr(&sa4->sin_addr, ip_2_ip4(&addr)); - sa4->sin_family = AF_INET; - sa4->sin_len = sizeof(struct sockaddr_in); - sa4->sin_port = lwip_htons((u16_t)port_nr); - ai->ai_family = AF_INET; -#endif /* LWIP_IPV4 */ - } - - /* set up addrinfo */ - if (hints != NULL) { - /* copy socktype & protocol from hints if specified */ - ai->ai_socktype = hints->ai_socktype; - ai->ai_protocol = hints->ai_protocol; - } - if (nodename != NULL) { - /* copy nodename to canonname if specified */ - ai->ai_canonname = ((char *)ai + sizeof(struct addrinfo) + sizeof(struct sockaddr_storage)); - MEMCPY(ai->ai_canonname, nodename, namelen); - ai->ai_canonname[namelen] = 0; - } - ai->ai_addrlen = sizeof(struct sockaddr_storage); - ai->ai_addr = (struct sockaddr *)sa; - - *res = ai; - - return 0; -} - -#endif /* LWIP_DNS && LWIP_SOCKET */ +/** + * @file + * API functions for name resolving + * + * @defgroup netdbapi NETDB API + * @ingroup socket + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#include "lwip/netdb.h" + +#if LWIP_DNS && LWIP_SOCKET + +#include "lwip/err.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/ip_addr.h" +#include "lwip/api.h" +#include "lwip/dns.h" + +#include /* memset */ +#include /* atoi */ + +/** helper struct for gethostbyname_r to access the char* buffer */ +struct gethostbyname_r_helper { + ip_addr_t *addr_list[2]; + ip_addr_t addr; + char *aliases; +}; + +/** h_errno is exported in netdb.h for access by applications. */ +#if LWIP_DNS_API_DECLARE_H_ERRNO +int h_errno; +#endif /* LWIP_DNS_API_DECLARE_H_ERRNO */ + +/** define "hostent" variables storage: 0 if we use a static (but unprotected) + * set of variables for lwip_gethostbyname, 1 if we use a local storage */ +#ifndef LWIP_DNS_API_HOSTENT_STORAGE +#define LWIP_DNS_API_HOSTENT_STORAGE 0 +#endif + +/** define "hostent" variables storage */ +#if LWIP_DNS_API_HOSTENT_STORAGE +#define HOSTENT_STORAGE +#else +#define HOSTENT_STORAGE static +#endif /* LWIP_DNS_API_STATIC_HOSTENT */ + +/** + * Returns an entry containing addresses of address family AF_INET + * for the host with name name. + * Due to dns_gethostbyname limitations, only one address is returned. + * + * @param name the hostname to resolve + * @return an entry containing addresses of address family AF_INET + * for the host with name name + */ +struct hostent * +lwip_gethostbyname(const char *name) +{ + err_t err; + ip_addr_t addr; + + /* buffer variables for lwip_gethostbyname() */ + HOSTENT_STORAGE struct hostent s_hostent; + HOSTENT_STORAGE char *s_aliases; + HOSTENT_STORAGE ip_addr_t s_hostent_addr; + HOSTENT_STORAGE ip_addr_t *s_phostent_addr[2]; + HOSTENT_STORAGE char s_hostname[DNS_MAX_NAME_LENGTH + 1]; + + /* query host IP address */ + err = netconn_gethostbyname(name, &addr); + if (err != ERR_OK) { + LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err)); + h_errno = HOST_NOT_FOUND; + return NULL; + } + + /* fill hostent */ + s_hostent_addr = addr; + s_phostent_addr[0] = &s_hostent_addr; + s_phostent_addr[1] = NULL; + strncpy(s_hostname, name, DNS_MAX_NAME_LENGTH); + s_hostname[DNS_MAX_NAME_LENGTH] = 0; + s_hostent.h_name = s_hostname; + s_aliases = NULL; + s_hostent.h_aliases = &s_aliases; + s_hostent.h_addrtype = AF_INET; + s_hostent.h_length = sizeof(ip_addr_t); + s_hostent.h_addr_list = (char **)&s_phostent_addr; + +#if DNS_DEBUG + /* dump hostent */ + LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_name == %s\n", s_hostent.h_name)); + LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_aliases == %p\n", (void *)s_hostent.h_aliases)); + /* h_aliases are always empty */ + LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addrtype == %d\n", s_hostent.h_addrtype)); + LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_length == %d\n", s_hostent.h_length)); + LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list == %p\n", (void *)s_hostent.h_addr_list)); + if (s_hostent.h_addr_list != NULL) { + u8_t idx; + for (idx = 0; s_hostent.h_addr_list[idx]; idx++) { + LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i] == %p\n", idx, s_hostent.h_addr_list[idx])); + LWIP_DEBUGF(DNS_DEBUG, ("hostent.h_addr_list[%i]-> == %s\n", idx, ipaddr_ntoa((ip_addr_t *)s_hostent.h_addr_list[idx]))); + } + } +#endif /* DNS_DEBUG */ + +#if LWIP_DNS_API_HOSTENT_STORAGE + /* this function should return the "per-thread" hostent after copy from s_hostent */ + return sys_thread_hostent(&s_hostent); +#else + return &s_hostent; +#endif /* LWIP_DNS_API_HOSTENT_STORAGE */ +} + +/** + * Thread-safe variant of lwip_gethostbyname: instead of using a static + * buffer, this function takes buffer and errno pointers as arguments + * and uses these for the result. + * + * @param name the hostname to resolve + * @param ret pre-allocated struct where to store the result + * @param buf pre-allocated buffer where to store additional data + * @param buflen the size of buf + * @param result pointer to a hostent pointer that is set to ret on success + * and set to zero on error + * @param h_errnop pointer to an int where to store errors (instead of modifying + * the global h_errno) + * @return 0 on success, non-zero on error, additional error information + * is stored in *h_errnop instead of h_errno to be thread-safe + */ +int +lwip_gethostbyname_r(const char *name, struct hostent *ret, char *buf, + size_t buflen, struct hostent **result, int *h_errnop) +{ + err_t err; + struct gethostbyname_r_helper *h; + char *hostname; + size_t namelen; + int lh_errno; + + if (h_errnop == NULL) { + /* ensure h_errnop is never NULL */ + h_errnop = &lh_errno; + } + + if (result == NULL) { + /* not all arguments given */ + *h_errnop = EINVAL; + return -1; + } + /* first thing to do: set *result to nothing */ + *result = NULL; + if ((name == NULL) || (ret == NULL) || (buf == NULL)) { + /* not all arguments given */ + *h_errnop = EINVAL; + return -1; + } + + namelen = strlen(name); + if (buflen < (sizeof(struct gethostbyname_r_helper) + LWIP_MEM_ALIGN_BUFFER(namelen + 1))) { + /* buf can't hold the data needed + a copy of name */ + *h_errnop = ERANGE; + return -1; + } + + h = (struct gethostbyname_r_helper *)LWIP_MEM_ALIGN(buf); + hostname = ((char *)h) + sizeof(struct gethostbyname_r_helper); + + /* query host IP address */ + err = netconn_gethostbyname(name, &h->addr); + if (err != ERR_OK) { + LWIP_DEBUGF(DNS_DEBUG, ("lwip_gethostbyname(%s) failed, err=%d\n", name, err)); + *h_errnop = HOST_NOT_FOUND; + return -1; + } + + /* copy the hostname into buf */ + MEMCPY(hostname, name, namelen); + hostname[namelen] = 0; + + /* fill hostent */ + h->addr_list[0] = &h->addr; + h->addr_list[1] = NULL; + h->aliases = NULL; + ret->h_name = hostname; + ret->h_aliases = &h->aliases; + ret->h_addrtype = AF_INET; + ret->h_length = sizeof(ip_addr_t); + ret->h_addr_list = (char **)&h->addr_list; + + /* set result != NULL */ + *result = ret; + + /* return success */ + return 0; +} + +/** + * Frees one or more addrinfo structures returned by getaddrinfo(), along with + * any additional storage associated with those structures. If the ai_next field + * of the structure is not null, the entire list of structures is freed. + * + * @param ai struct addrinfo to free + */ +void +lwip_freeaddrinfo(struct addrinfo *ai) +{ + struct addrinfo *next; + + while (ai != NULL) { + next = ai->ai_next; + memp_free(MEMP_NETDB, ai); + ai = next; + } +} + +/** + * Translates the name of a service location (for example, a host name) and/or + * a service name and returns a set of socket addresses and associated + * information to be used in creating a socket with which to address the + * specified service. + * Memory for the result is allocated internally and must be freed by calling + * lwip_freeaddrinfo()! + * + * Due to a limitation in dns_gethostbyname, only the first address of a + * host is returned. + * Also, service names are not supported (only port numbers)! + * + * @param nodename descriptive name or address string of the host + * (may be NULL -> local address) + * @param servname port number as string of NULL + * @param hints structure containing input values that set socktype and protocol + * @param res pointer to a pointer where to store the result (set to NULL on failure) + * @return 0 on success, non-zero on failure + * + * @todo: implement AI_V4MAPPED, AI_ADDRCONFIG + */ +int +lwip_getaddrinfo(const char *nodename, const char *servname, + const struct addrinfo *hints, struct addrinfo **res) +{ + err_t err; + ip_addr_t addr; + struct addrinfo *ai; + struct sockaddr_storage *sa = NULL; + int port_nr = 0; + size_t total_size; + size_t namelen = 0; + int ai_family; + + if (res == NULL) { + return EAI_FAIL; + } + *res = NULL; + if ((nodename == NULL) && (servname == NULL)) { + return EAI_NONAME; + } + + if (hints != NULL) { + ai_family = hints->ai_family; + if ((ai_family != AF_UNSPEC) +#if LWIP_IPV4 + && (ai_family != AF_INET) +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 + && (ai_family != AF_INET6) +#endif /* LWIP_IPV6 */ + ) { + return EAI_FAMILY; + } + } else { + ai_family = AF_UNSPEC; + } + + if (servname != NULL) { + /* service name specified: convert to port number + * @todo?: currently, only ASCII integers (port numbers) are supported (AI_NUMERICSERV)! */ + port_nr = atoi(servname); + if ((port_nr <= 0) || (port_nr > 0xffff)) { + return EAI_SERVICE; + } + } + + if (nodename != NULL) { + /* service location specified, try to resolve */ + if ((hints != NULL) && (hints->ai_flags & AI_NUMERICHOST)) { + /* no DNS lookup, just parse for an address string */ + if (!ipaddr_aton(nodename, &addr)) { + return EAI_NONAME; + } +#if LWIP_IPV4 && LWIP_IPV6 + if ((IP_IS_V6_VAL(addr) && ai_family == AF_INET) || + (IP_IS_V4_VAL(addr) && ai_family == AF_INET6)) { + return EAI_NONAME; + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + } else { +#if LWIP_IPV4 && LWIP_IPV6 + /* AF_UNSPEC: prefer IPv4 */ + u8_t type = NETCONN_DNS_IPV4_IPV6; + if (ai_family == AF_INET) { + type = NETCONN_DNS_IPV4; + } else if (ai_family == AF_INET6) { + type = NETCONN_DNS_IPV6; + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + err = netconn_gethostbyname_addrtype(nodename, &addr, type); + if (err != ERR_OK) { + return EAI_FAIL; + } + } + } else { + /* service location specified, use loopback address */ + if ((hints != NULL) && (hints->ai_flags & AI_PASSIVE)) { + ip_addr_set_any_val(ai_family == AF_INET6, addr); + } else { + ip_addr_set_loopback_val(ai_family == AF_INET6, addr); + } + } + + total_size = sizeof(struct addrinfo) + sizeof(struct sockaddr_storage); + if (nodename != NULL) { + namelen = strlen(nodename); + if (namelen > DNS_MAX_NAME_LENGTH) { + /* invalid name length */ + return EAI_FAIL; + } + LWIP_ASSERT("namelen is too long", total_size + namelen + 1 > total_size); + total_size += namelen + 1; + } + /* If this fails, please report to lwip-devel! :-) */ + LWIP_ASSERT("total_size <= NETDB_ELEM_SIZE: please report this!", + total_size <= NETDB_ELEM_SIZE); + ai = (struct addrinfo *)memp_malloc(MEMP_NETDB); + if (ai == NULL) { + return EAI_MEMORY; + } + memset(ai, 0, total_size); + /* cast through void* to get rid of alignment warnings */ + sa = (struct sockaddr_storage *)(void *)((u8_t *)ai + sizeof(struct addrinfo)); + if (IP_IS_V6_VAL(addr)) { +#if LWIP_IPV6 + struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa; + /* set up sockaddr */ + inet6_addr_from_ip6addr(&sa6->sin6_addr, ip_2_ip6(&addr)); + sa6->sin6_family = AF_INET6; + sa6->sin6_len = sizeof(struct sockaddr_in6); + sa6->sin6_port = lwip_htons((u16_t)port_nr); + sa6->sin6_scope_id = ip6_addr_zone(ip_2_ip6(&addr)); + ai->ai_family = AF_INET6; +#endif /* LWIP_IPV6 */ + } else { +#if LWIP_IPV4 + struct sockaddr_in *sa4 = (struct sockaddr_in *)sa; + /* set up sockaddr */ + inet_addr_from_ip4addr(&sa4->sin_addr, ip_2_ip4(&addr)); + sa4->sin_family = AF_INET; + sa4->sin_len = sizeof(struct sockaddr_in); + sa4->sin_port = lwip_htons((u16_t)port_nr); + ai->ai_family = AF_INET; +#endif /* LWIP_IPV4 */ + } + + /* set up addrinfo */ + if (hints != NULL) { + /* copy socktype & protocol from hints if specified */ + ai->ai_socktype = hints->ai_socktype; + ai->ai_protocol = hints->ai_protocol; + } + if (nodename != NULL) { + /* copy nodename to canonname if specified */ + ai->ai_canonname = ((char *)ai + sizeof(struct addrinfo) + sizeof(struct sockaddr_storage)); + MEMCPY(ai->ai_canonname, nodename, namelen); + ai->ai_canonname[namelen] = 0; + } + ai->ai_addrlen = sizeof(struct sockaddr_storage); + ai->ai_addr = (struct sockaddr *)sa; + + *res = ai; + + return 0; +} + +#endif /* LWIP_DNS && LWIP_SOCKET */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netifapi.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netifapi.c index 7c2011f7..25957cd5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netifapi.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/netifapi.c @@ -1,380 +1,380 @@ -/** - * @file - * Network Interface Sequential API module - * - * @defgroup netifapi NETIF API - * @ingroup sequential_api - * Thread-safe functions to be called from non-TCPIP threads - * - * @defgroup netifapi_netif NETIF related - * @ingroup netifapi - * To be called from non-TCPIP threads - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/opt.h" - -#if LWIP_NETIF_API /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/etharp.h" -#include "lwip/netifapi.h" -#include "lwip/memp.h" -#include "lwip/priv/tcpip_priv.h" - -#include /* strncpy */ - -#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) - -/** - * Call netif_add() inside the tcpip_thread context. - */ -static err_t -netifapi_do_netif_add(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 */ - struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; - - if (!netif_add( msg->netif, -#if LWIP_IPV4 - API_EXPR_REF(msg->msg.add.ipaddr), - API_EXPR_REF(msg->msg.add.netmask), - API_EXPR_REF(msg->msg.add.gw), -#endif /* LWIP_IPV4 */ - msg->msg.add.state, - msg->msg.add.init, - msg->msg.add.input)) { - return ERR_IF; - } else { - return ERR_OK; - } -} - -#if LWIP_IPV4 -/** - * Call netif_set_addr() inside the tcpip_thread context. - */ -static err_t -netifapi_do_netif_set_addr(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 */ - struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; - - netif_set_addr( msg->netif, - API_EXPR_REF(msg->msg.add.ipaddr), - API_EXPR_REF(msg->msg.add.netmask), - API_EXPR_REF(msg->msg.add.gw)); - return ERR_OK; -} -#endif /* LWIP_IPV4 */ - -/** -* Call netif_name_to_index() inside the tcpip_thread context. -*/ -static err_t -netifapi_do_name_to_index(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 */ - struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; - - msg->msg.ifs.index = netif_name_to_index(msg->msg.ifs.name); - return ERR_OK; -} - -/** -* Call netif_index_to_name() inside the tcpip_thread context. -*/ -static err_t -netifapi_do_index_to_name(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 */ - struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; - - if (!netif_index_to_name(msg->msg.ifs.index, msg->msg.ifs.name)) { - /* return failure via empty name */ - msg->msg.ifs.name[0] = '\0'; - } - return ERR_OK; -} - -/** - * Call the "errtfunc" (or the "voidfunc" if "errtfunc" is NULL) inside the - * tcpip_thread context. - */ -static err_t -netifapi_do_netif_common(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 */ - struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; - - if (msg->msg.common.errtfunc != NULL) { - return msg->msg.common.errtfunc(msg->netif); - } else { - msg->msg.common.voidfunc(msg->netif); - return ERR_OK; - } -} - -#if LWIP_ARP && LWIP_IPV4 -/** - * @ingroup netifapi_arp - * Add or update an entry in the ARP cache. - * For an update, ipaddr is used to find the cache entry. - * - * @param ipaddr IPv4 address of cache entry - * @param ethaddr hardware address mapped to ipaddr - * @param type type of ARP cache entry - * @return ERR_OK: entry added/updated, else error from err_t - */ -err_t -netifapi_arp_add(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, enum netifapi_arp_entry type) -{ - err_t err; - - /* We only support permanent entries currently */ - LWIP_UNUSED_ARG(type); - -#if ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING - LOCK_TCPIP_CORE(); - err = etharp_add_static_entry(ipaddr, ethaddr); - UNLOCK_TCPIP_CORE(); -#else - /* @todo add new vars to struct netifapi_msg and create a 'do' func */ - LWIP_UNUSED_ARG(ipaddr); - LWIP_UNUSED_ARG(ethaddr); - err = ERR_VAL; -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING */ - - return err; -} - -/** - * @ingroup netifapi_arp - * Remove an entry in the ARP cache identified by ipaddr - * - * @param ipaddr IPv4 address of cache entry - * @param type type of ARP cache entry - * @return ERR_OK: entry removed, else error from err_t - */ -err_t -netifapi_arp_remove(const ip4_addr_t *ipaddr, enum netifapi_arp_entry type) -{ - err_t err; - - /* We only support permanent entries currently */ - LWIP_UNUSED_ARG(type); - -#if ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING - LOCK_TCPIP_CORE(); - err = etharp_remove_static_entry(ipaddr); - UNLOCK_TCPIP_CORE(); -#else - /* @todo add new vars to struct netifapi_msg and create a 'do' func */ - LWIP_UNUSED_ARG(ipaddr); - err = ERR_VAL; -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING */ - - return err; -} -#endif /* LWIP_ARP && LWIP_IPV4 */ - -/** - * @ingroup netifapi_netif - * Call netif_add() in a thread-safe way by running that function inside the - * tcpip_thread context. - * - * @note for params @see netif_add() - */ -err_t -netifapi_netif_add(struct netif *netif, -#if LWIP_IPV4 - const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, -#endif /* LWIP_IPV4 */ - void *state, netif_init_fn init, netif_input_fn input) -{ - err_t err; - NETIFAPI_VAR_DECLARE(msg); - NETIFAPI_VAR_ALLOC(msg); - -#if LWIP_IPV4 - if (ipaddr == NULL) { - ipaddr = IP4_ADDR_ANY4; - } - if (netmask == NULL) { - netmask = IP4_ADDR_ANY4; - } - if (gw == NULL) { - gw = IP4_ADDR_ANY4; - } -#endif /* LWIP_IPV4 */ - - NETIFAPI_VAR_REF(msg).netif = netif; -#if LWIP_IPV4 - NETIFAPI_VAR_REF(msg).msg.add.ipaddr = NETIFAPI_VAR_REF(ipaddr); - NETIFAPI_VAR_REF(msg).msg.add.netmask = NETIFAPI_VAR_REF(netmask); - NETIFAPI_VAR_REF(msg).msg.add.gw = NETIFAPI_VAR_REF(gw); -#endif /* LWIP_IPV4 */ - NETIFAPI_VAR_REF(msg).msg.add.state = state; - NETIFAPI_VAR_REF(msg).msg.add.init = init; - NETIFAPI_VAR_REF(msg).msg.add.input = input; - err = tcpip_api_call(netifapi_do_netif_add, &API_VAR_REF(msg).call); - NETIFAPI_VAR_FREE(msg); - return err; -} - -#if LWIP_IPV4 -/** - * @ingroup netifapi_netif - * Call netif_set_addr() in a thread-safe way by running that function inside the - * tcpip_thread context. - * - * @note for params @see netif_set_addr() - */ -err_t -netifapi_netif_set_addr(struct netif *netif, - const ip4_addr_t *ipaddr, - const ip4_addr_t *netmask, - const ip4_addr_t *gw) -{ - err_t err; - NETIFAPI_VAR_DECLARE(msg); - NETIFAPI_VAR_ALLOC(msg); - - if (ipaddr == NULL) { - ipaddr = IP4_ADDR_ANY4; - } - if (netmask == NULL) { - netmask = IP4_ADDR_ANY4; - } - if (gw == NULL) { - gw = IP4_ADDR_ANY4; - } - - NETIFAPI_VAR_REF(msg).netif = netif; - NETIFAPI_VAR_REF(msg).msg.add.ipaddr = NETIFAPI_VAR_REF(ipaddr); - NETIFAPI_VAR_REF(msg).msg.add.netmask = NETIFAPI_VAR_REF(netmask); - NETIFAPI_VAR_REF(msg).msg.add.gw = NETIFAPI_VAR_REF(gw); - err = tcpip_api_call(netifapi_do_netif_set_addr, &API_VAR_REF(msg).call); - NETIFAPI_VAR_FREE(msg); - return err; -} -#endif /* LWIP_IPV4 */ - -/** - * call the "errtfunc" (or the "voidfunc" if "errtfunc" is NULL) in a thread-safe - * way by running that function inside the tcpip_thread context. - * - * @note use only for functions where there is only "netif" parameter. - */ -err_t -netifapi_netif_common(struct netif *netif, netifapi_void_fn voidfunc, - netifapi_errt_fn errtfunc) -{ - err_t err; - NETIFAPI_VAR_DECLARE(msg); - NETIFAPI_VAR_ALLOC(msg); - - NETIFAPI_VAR_REF(msg).netif = netif; - NETIFAPI_VAR_REF(msg).msg.common.voidfunc = voidfunc; - NETIFAPI_VAR_REF(msg).msg.common.errtfunc = errtfunc; - err = tcpip_api_call(netifapi_do_netif_common, &API_VAR_REF(msg).call); - NETIFAPI_VAR_FREE(msg); - return err; -} - -/** -* @ingroup netifapi_netif -* Call netif_name_to_index() in a thread-safe way by running that function inside the -* tcpip_thread context. -* -* @param name the interface name of the netif -* @param idx output index of the found netif -*/ -err_t -netifapi_netif_name_to_index(const char *name, u8_t *idx) -{ - err_t err; - NETIFAPI_VAR_DECLARE(msg); - NETIFAPI_VAR_ALLOC(msg); - - *idx = 0; - -#if LWIP_MPU_COMPATIBLE - strncpy(NETIFAPI_VAR_REF(msg).msg.ifs.name, name, NETIF_NAMESIZE - 1); - NETIFAPI_VAR_REF(msg).msg.ifs.name[NETIF_NAMESIZE - 1] = '\0'; -#else - NETIFAPI_VAR_REF(msg).msg.ifs.name = LWIP_CONST_CAST(char *, name); -#endif /* LWIP_MPU_COMPATIBLE */ - err = tcpip_api_call(netifapi_do_name_to_index, &API_VAR_REF(msg).call); - if (!err) { - *idx = NETIFAPI_VAR_REF(msg).msg.ifs.index; - } - NETIFAPI_VAR_FREE(msg); - return err; -} - -/** -* @ingroup netifapi_netif -* Call netif_index_to_name() in a thread-safe way by running that function inside the -* tcpip_thread context. -* -* @param idx the interface index of the netif -* @param name output name of the found netif, empty '\0' string if netif not found. -* name should be of at least NETIF_NAMESIZE bytes -*/ -err_t -netifapi_netif_index_to_name(u8_t idx, char *name) -{ - err_t err; - NETIFAPI_VAR_DECLARE(msg); - NETIFAPI_VAR_ALLOC(msg); - - NETIFAPI_VAR_REF(msg).msg.ifs.index = idx; -#if !LWIP_MPU_COMPATIBLE - NETIFAPI_VAR_REF(msg).msg.ifs.name = name; -#endif /* LWIP_MPU_COMPATIBLE */ - err = tcpip_api_call(netifapi_do_index_to_name, &API_VAR_REF(msg).call); -#if LWIP_MPU_COMPATIBLE - if (!err) { - strncpy(name, NETIFAPI_VAR_REF(msg).msg.ifs.name, NETIF_NAMESIZE - 1); - name[NETIF_NAMESIZE - 1] = '\0'; - } -#endif /* LWIP_MPU_COMPATIBLE */ - NETIFAPI_VAR_FREE(msg); - return err; -} - -#endif /* LWIP_NETIF_API */ +/** + * @file + * Network Interface Sequential API module + * + * @defgroup netifapi NETIF API + * @ingroup sequential_api + * Thread-safe functions to be called from non-TCPIP threads + * + * @defgroup netifapi_netif NETIF related + * @ingroup netifapi + * To be called from non-TCPIP threads + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/opt.h" + +#if LWIP_NETIF_API /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/etharp.h" +#include "lwip/netifapi.h" +#include "lwip/memp.h" +#include "lwip/priv/tcpip_priv.h" + +#include /* strncpy */ + +#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) + +/** + * Call netif_add() inside the tcpip_thread context. + */ +static err_t +netifapi_do_netif_add(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 */ + struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; + + if (!netif_add( msg->netif, +#if LWIP_IPV4 + API_EXPR_REF(msg->msg.add.ipaddr), + API_EXPR_REF(msg->msg.add.netmask), + API_EXPR_REF(msg->msg.add.gw), +#endif /* LWIP_IPV4 */ + msg->msg.add.state, + msg->msg.add.init, + msg->msg.add.input)) { + return ERR_IF; + } else { + return ERR_OK; + } +} + +#if LWIP_IPV4 +/** + * Call netif_set_addr() inside the tcpip_thread context. + */ +static err_t +netifapi_do_netif_set_addr(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 */ + struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; + + netif_set_addr( msg->netif, + API_EXPR_REF(msg->msg.add.ipaddr), + API_EXPR_REF(msg->msg.add.netmask), + API_EXPR_REF(msg->msg.add.gw)); + return ERR_OK; +} +#endif /* LWIP_IPV4 */ + +/** +* Call netif_name_to_index() inside the tcpip_thread context. +*/ +static err_t +netifapi_do_name_to_index(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 */ + struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; + + msg->msg.ifs.index = netif_name_to_index(msg->msg.ifs.name); + return ERR_OK; +} + +/** +* Call netif_index_to_name() inside the tcpip_thread context. +*/ +static err_t +netifapi_do_index_to_name(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 */ + struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; + + if (!netif_index_to_name(msg->msg.ifs.index, msg->msg.ifs.name)) { + /* return failure via empty name */ + msg->msg.ifs.name[0] = '\0'; + } + return ERR_OK; +} + +/** + * Call the "errtfunc" (or the "voidfunc" if "errtfunc" is NULL) inside the + * tcpip_thread context. + */ +static err_t +netifapi_do_netif_common(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 */ + struct netifapi_msg *msg = (struct netifapi_msg *)(void *)m; + + if (msg->msg.common.errtfunc != NULL) { + return msg->msg.common.errtfunc(msg->netif); + } else { + msg->msg.common.voidfunc(msg->netif); + return ERR_OK; + } +} + +#if LWIP_ARP && LWIP_IPV4 +/** + * @ingroup netifapi_arp + * Add or update an entry in the ARP cache. + * For an update, ipaddr is used to find the cache entry. + * + * @param ipaddr IPv4 address of cache entry + * @param ethaddr hardware address mapped to ipaddr + * @param type type of ARP cache entry + * @return ERR_OK: entry added/updated, else error from err_t + */ +err_t +netifapi_arp_add(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, enum netifapi_arp_entry type) +{ + err_t err; + + /* We only support permanent entries currently */ + LWIP_UNUSED_ARG(type); + +#if ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING + LOCK_TCPIP_CORE(); + err = etharp_add_static_entry(ipaddr, ethaddr); + UNLOCK_TCPIP_CORE(); +#else + /* @todo add new vars to struct netifapi_msg and create a 'do' func */ + LWIP_UNUSED_ARG(ipaddr); + LWIP_UNUSED_ARG(ethaddr); + err = ERR_VAL; +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING */ + + return err; +} + +/** + * @ingroup netifapi_arp + * Remove an entry in the ARP cache identified by ipaddr + * + * @param ipaddr IPv4 address of cache entry + * @param type type of ARP cache entry + * @return ERR_OK: entry removed, else error from err_t + */ +err_t +netifapi_arp_remove(const ip4_addr_t *ipaddr, enum netifapi_arp_entry type) +{ + err_t err; + + /* We only support permanent entries currently */ + LWIP_UNUSED_ARG(type); + +#if ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING + LOCK_TCPIP_CORE(); + err = etharp_remove_static_entry(ipaddr); + UNLOCK_TCPIP_CORE(); +#else + /* @todo add new vars to struct netifapi_msg and create a 'do' func */ + LWIP_UNUSED_ARG(ipaddr); + err = ERR_VAL; +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES && LWIP_TCPIP_CORE_LOCKING */ + + return err; +} +#endif /* LWIP_ARP && LWIP_IPV4 */ + +/** + * @ingroup netifapi_netif + * Call netif_add() in a thread-safe way by running that function inside the + * tcpip_thread context. + * + * @note for params @see netif_add() + */ +err_t +netifapi_netif_add(struct netif *netif, +#if LWIP_IPV4 + const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, +#endif /* LWIP_IPV4 */ + void *state, netif_init_fn init, netif_input_fn input) +{ + err_t err; + NETIFAPI_VAR_DECLARE(msg); + NETIFAPI_VAR_ALLOC(msg); + +#if LWIP_IPV4 + if (ipaddr == NULL) { + ipaddr = IP4_ADDR_ANY4; + } + if (netmask == NULL) { + netmask = IP4_ADDR_ANY4; + } + if (gw == NULL) { + gw = IP4_ADDR_ANY4; + } +#endif /* LWIP_IPV4 */ + + NETIFAPI_VAR_REF(msg).netif = netif; +#if LWIP_IPV4 + NETIFAPI_VAR_REF(msg).msg.add.ipaddr = NETIFAPI_VAR_REF(ipaddr); + NETIFAPI_VAR_REF(msg).msg.add.netmask = NETIFAPI_VAR_REF(netmask); + NETIFAPI_VAR_REF(msg).msg.add.gw = NETIFAPI_VAR_REF(gw); +#endif /* LWIP_IPV4 */ + NETIFAPI_VAR_REF(msg).msg.add.state = state; + NETIFAPI_VAR_REF(msg).msg.add.init = init; + NETIFAPI_VAR_REF(msg).msg.add.input = input; + err = tcpip_api_call(netifapi_do_netif_add, &API_VAR_REF(msg).call); + NETIFAPI_VAR_FREE(msg); + return err; +} + +#if LWIP_IPV4 +/** + * @ingroup netifapi_netif + * Call netif_set_addr() in a thread-safe way by running that function inside the + * tcpip_thread context. + * + * @note for params @see netif_set_addr() + */ +err_t +netifapi_netif_set_addr(struct netif *netif, + const ip4_addr_t *ipaddr, + const ip4_addr_t *netmask, + const ip4_addr_t *gw) +{ + err_t err; + NETIFAPI_VAR_DECLARE(msg); + NETIFAPI_VAR_ALLOC(msg); + + if (ipaddr == NULL) { + ipaddr = IP4_ADDR_ANY4; + } + if (netmask == NULL) { + netmask = IP4_ADDR_ANY4; + } + if (gw == NULL) { + gw = IP4_ADDR_ANY4; + } + + NETIFAPI_VAR_REF(msg).netif = netif; + NETIFAPI_VAR_REF(msg).msg.add.ipaddr = NETIFAPI_VAR_REF(ipaddr); + NETIFAPI_VAR_REF(msg).msg.add.netmask = NETIFAPI_VAR_REF(netmask); + NETIFAPI_VAR_REF(msg).msg.add.gw = NETIFAPI_VAR_REF(gw); + err = tcpip_api_call(netifapi_do_netif_set_addr, &API_VAR_REF(msg).call); + NETIFAPI_VAR_FREE(msg); + return err; +} +#endif /* LWIP_IPV4 */ + +/** + * call the "errtfunc" (or the "voidfunc" if "errtfunc" is NULL) in a thread-safe + * way by running that function inside the tcpip_thread context. + * + * @note use only for functions where there is only "netif" parameter. + */ +err_t +netifapi_netif_common(struct netif *netif, netifapi_void_fn voidfunc, + netifapi_errt_fn errtfunc) +{ + err_t err; + NETIFAPI_VAR_DECLARE(msg); + NETIFAPI_VAR_ALLOC(msg); + + NETIFAPI_VAR_REF(msg).netif = netif; + NETIFAPI_VAR_REF(msg).msg.common.voidfunc = voidfunc; + NETIFAPI_VAR_REF(msg).msg.common.errtfunc = errtfunc; + err = tcpip_api_call(netifapi_do_netif_common, &API_VAR_REF(msg).call); + NETIFAPI_VAR_FREE(msg); + return err; +} + +/** +* @ingroup netifapi_netif +* Call netif_name_to_index() in a thread-safe way by running that function inside the +* tcpip_thread context. +* +* @param name the interface name of the netif +* @param idx output index of the found netif +*/ +err_t +netifapi_netif_name_to_index(const char *name, u8_t *idx) +{ + err_t err; + NETIFAPI_VAR_DECLARE(msg); + NETIFAPI_VAR_ALLOC(msg); + + *idx = 0; + +#if LWIP_MPU_COMPATIBLE + strncpy(NETIFAPI_VAR_REF(msg).msg.ifs.name, name, NETIF_NAMESIZE - 1); + NETIFAPI_VAR_REF(msg).msg.ifs.name[NETIF_NAMESIZE - 1] = '\0'; +#else + NETIFAPI_VAR_REF(msg).msg.ifs.name = LWIP_CONST_CAST(char *, name); +#endif /* LWIP_MPU_COMPATIBLE */ + err = tcpip_api_call(netifapi_do_name_to_index, &API_VAR_REF(msg).call); + if (!err) { + *idx = NETIFAPI_VAR_REF(msg).msg.ifs.index; + } + NETIFAPI_VAR_FREE(msg); + return err; +} + +/** +* @ingroup netifapi_netif +* Call netif_index_to_name() in a thread-safe way by running that function inside the +* tcpip_thread context. +* +* @param idx the interface index of the netif +* @param name output name of the found netif, empty '\0' string if netif not found. +* name should be of at least NETIF_NAMESIZE bytes +*/ +err_t +netifapi_netif_index_to_name(u8_t idx, char *name) +{ + err_t err; + NETIFAPI_VAR_DECLARE(msg); + NETIFAPI_VAR_ALLOC(msg); + + NETIFAPI_VAR_REF(msg).msg.ifs.index = idx; +#if !LWIP_MPU_COMPATIBLE + NETIFAPI_VAR_REF(msg).msg.ifs.name = name; +#endif /* LWIP_MPU_COMPATIBLE */ + err = tcpip_api_call(netifapi_do_index_to_name, &API_VAR_REF(msg).call); +#if LWIP_MPU_COMPATIBLE + if (!err) { + strncpy(name, NETIFAPI_VAR_REF(msg).msg.ifs.name, NETIF_NAMESIZE - 1); + name[NETIF_NAMESIZE - 1] = '\0'; + } +#endif /* LWIP_MPU_COMPATIBLE */ + NETIFAPI_VAR_FREE(msg); + return err; +} + +#endif /* LWIP_NETIF_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/sockets.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/sockets.c index 21dbcbfb..2660f73e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/sockets.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/sockets.c @@ -1,4168 +1,4168 @@ -/** - * @file - * Sockets BSD-Like API module - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - * Improved by Marc Boucher and David Haas - * - */ - -#include "lwip/opt.h" - -#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/sockets.h" -#include "lwip/priv/sockets_priv.h" -#include "lwip/api.h" -#include "lwip/igmp.h" -#include "lwip/inet.h" -#include "lwip/tcp.h" -#include "lwip/raw.h" -#include "lwip/udp.h" -#include "lwip/memp.h" -#include "lwip/pbuf.h" -#include "lwip/netif.h" -#include "lwip/priv/tcpip_priv.h" -#include "lwip/mld6.h" -#if LWIP_CHECKSUM_ON_COPY -#include "lwip/inet_chksum.h" -#endif - -#if LWIP_COMPAT_SOCKETS == 2 && LWIP_POSIX_SOCKETS_IO_NAMES -#include -#endif - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -/* If the netconn API is not required publicly, then we include the necessary - files here to get the implementation */ -#if !LWIP_NETCONN -#undef LWIP_NETCONN -#define LWIP_NETCONN 1 -#include "api_msg.c" -#include "api_lib.c" -#include "netbuf.c" -#undef LWIP_NETCONN -#define LWIP_NETCONN 0 -#endif - -#define API_SELECT_CB_VAR_REF(name) API_VAR_REF(name) -#define API_SELECT_CB_VAR_DECLARE(name) API_VAR_DECLARE(struct lwip_select_cb, name) -#define API_SELECT_CB_VAR_ALLOC(name, retblock) API_VAR_ALLOC_EXT(struct lwip_select_cb, MEMP_SELECT_CB, name, retblock) -#define API_SELECT_CB_VAR_FREE(name) API_VAR_FREE(MEMP_SELECT_CB, name) - -#if LWIP_IPV4 -#define IP4ADDR_PORT_TO_SOCKADDR(sin, ipaddr, port) do { \ - (sin)->sin_len = sizeof(struct sockaddr_in); \ - (sin)->sin_family = AF_INET; \ - (sin)->sin_port = lwip_htons((port)); \ - inet_addr_from_ip4addr(&(sin)->sin_addr, ipaddr); \ - memset((sin)->sin_zero, 0, SIN_ZERO_LEN); }while(0) -#define SOCKADDR4_TO_IP4ADDR_PORT(sin, ipaddr, port) do { \ - inet_addr_to_ip4addr(ip_2_ip4(ipaddr), &((sin)->sin_addr)); \ - (port) = lwip_ntohs((sin)->sin_port); }while(0) -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -#define IP6ADDR_PORT_TO_SOCKADDR(sin6, ipaddr, port) do { \ - (sin6)->sin6_len = sizeof(struct sockaddr_in6); \ - (sin6)->sin6_family = AF_INET6; \ - (sin6)->sin6_port = lwip_htons((port)); \ - (sin6)->sin6_flowinfo = 0; \ - inet6_addr_from_ip6addr(&(sin6)->sin6_addr, ipaddr); \ - (sin6)->sin6_scope_id = ip6_addr_zone(ipaddr); }while(0) -#define SOCKADDR6_TO_IP6ADDR_PORT(sin6, ipaddr, port) do { \ - inet6_addr_to_ip6addr(ip_2_ip6(ipaddr), &((sin6)->sin6_addr)); \ - if (ip6_addr_has_scope(ip_2_ip6(ipaddr), IP6_UNKNOWN)) { \ - ip6_addr_set_zone(ip_2_ip6(ipaddr), (u8_t)((sin6)->sin6_scope_id)); \ - } \ - (port) = lwip_ntohs((sin6)->sin6_port); }while(0) -#endif /* LWIP_IPV6 */ - -#if LWIP_IPV4 && LWIP_IPV6 -static void sockaddr_to_ipaddr_port(const struct sockaddr *sockaddr, ip_addr_t *ipaddr, u16_t *port); - -#define IS_SOCK_ADDR_LEN_VALID(namelen) (((namelen) == sizeof(struct sockaddr_in)) || \ - ((namelen) == sizeof(struct sockaddr_in6))) -#define IS_SOCK_ADDR_TYPE_VALID(name) (((name)->sa_family == AF_INET) || \ - ((name)->sa_family == AF_INET6)) -#define SOCK_ADDR_TYPE_MATCH(name, sock) \ - ((((name)->sa_family == AF_INET) && !(NETCONNTYPE_ISIPV6((sock)->conn->type))) || \ - (((name)->sa_family == AF_INET6) && (NETCONNTYPE_ISIPV6((sock)->conn->type)))) -#define IPADDR_PORT_TO_SOCKADDR(sockaddr, ipaddr, port) do { \ - if (IP_IS_ANY_TYPE_VAL(*ipaddr) || IP_IS_V6_VAL(*ipaddr)) { \ - IP6ADDR_PORT_TO_SOCKADDR((struct sockaddr_in6*)(void*)(sockaddr), ip_2_ip6(ipaddr), port); \ - } else { \ - IP4ADDR_PORT_TO_SOCKADDR((struct sockaddr_in*)(void*)(sockaddr), ip_2_ip4(ipaddr), port); \ - } } while(0) -#define SOCKADDR_TO_IPADDR_PORT(sockaddr, ipaddr, port) sockaddr_to_ipaddr_port(sockaddr, ipaddr, &(port)) -#define DOMAIN_TO_NETCONN_TYPE(domain, type) (((domain) == AF_INET) ? \ - (type) : (enum netconn_type)((type) | NETCONN_TYPE_IPV6)) -#elif LWIP_IPV6 /* LWIP_IPV4 && LWIP_IPV6 */ -#define IS_SOCK_ADDR_LEN_VALID(namelen) ((namelen) == sizeof(struct sockaddr_in6)) -#define IS_SOCK_ADDR_TYPE_VALID(name) ((name)->sa_family == AF_INET6) -#define SOCK_ADDR_TYPE_MATCH(name, sock) 1 -#define IPADDR_PORT_TO_SOCKADDR(sockaddr, ipaddr, port) \ - IP6ADDR_PORT_TO_SOCKADDR((struct sockaddr_in6*)(void*)(sockaddr), ip_2_ip6(ipaddr), port) -#define SOCKADDR_TO_IPADDR_PORT(sockaddr, ipaddr, port) \ - SOCKADDR6_TO_IP6ADDR_PORT((const struct sockaddr_in6*)(const void*)(sockaddr), ipaddr, port) -#define DOMAIN_TO_NETCONN_TYPE(domain, netconn_type) (netconn_type) -#else /*-> LWIP_IPV4: LWIP_IPV4 && LWIP_IPV6 */ -#define IS_SOCK_ADDR_LEN_VALID(namelen) ((namelen) == sizeof(struct sockaddr_in)) -#define IS_SOCK_ADDR_TYPE_VALID(name) ((name)->sa_family == AF_INET) -#define SOCK_ADDR_TYPE_MATCH(name, sock) 1 -#define IPADDR_PORT_TO_SOCKADDR(sockaddr, ipaddr, port) \ - IP4ADDR_PORT_TO_SOCKADDR((struct sockaddr_in*)(void*)(sockaddr), ip_2_ip4(ipaddr), port) -#define SOCKADDR_TO_IPADDR_PORT(sockaddr, ipaddr, port) \ - SOCKADDR4_TO_IP4ADDR_PORT((const struct sockaddr_in*)(const void*)(sockaddr), ipaddr, port) -#define DOMAIN_TO_NETCONN_TYPE(domain, netconn_type) (netconn_type) -#endif /* LWIP_IPV6 */ - -#define IS_SOCK_ADDR_TYPE_VALID_OR_UNSPEC(name) (((name)->sa_family == AF_UNSPEC) || \ - IS_SOCK_ADDR_TYPE_VALID(name)) -#define SOCK_ADDR_TYPE_MATCH_OR_UNSPEC(name, sock) (((name)->sa_family == AF_UNSPEC) || \ - SOCK_ADDR_TYPE_MATCH(name, sock)) -#define IS_SOCK_ADDR_ALIGNED(name) ((((mem_ptr_t)(name)) % 4) == 0) - - -#define LWIP_SOCKOPT_CHECK_OPTLEN(sock, optlen, opttype) do { if ((optlen) < sizeof(opttype)) { done_socket(sock); return EINVAL; }}while(0) -#define LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, opttype) do { \ - LWIP_SOCKOPT_CHECK_OPTLEN(sock, optlen, opttype); \ - if ((sock)->conn == NULL) { done_socket(sock); return EINVAL; } }while(0) -#define LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, opttype) do { \ - LWIP_SOCKOPT_CHECK_OPTLEN(sock, optlen, opttype); \ - if (((sock)->conn == NULL) || ((sock)->conn->pcb.tcp == NULL)) { done_socket(sock); return EINVAL; } }while(0) -#define LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, opttype, netconntype) do { \ - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, opttype); \ - if (NETCONNTYPE_GROUP(netconn_type((sock)->conn)) != netconntype) { done_socket(sock); return ENOPROTOOPT; } }while(0) - - -#define LWIP_SETGETSOCKOPT_DATA_VAR_REF(name) API_VAR_REF(name) -#define LWIP_SETGETSOCKOPT_DATA_VAR_DECLARE(name) API_VAR_DECLARE(struct lwip_setgetsockopt_data, name) -#define LWIP_SETGETSOCKOPT_DATA_VAR_FREE(name) API_VAR_FREE(MEMP_SOCKET_SETGETSOCKOPT_DATA, name) -#if LWIP_MPU_COMPATIBLE -#define LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(name, sock) do { \ - name = (struct lwip_setgetsockopt_data *)memp_malloc(MEMP_SOCKET_SETGETSOCKOPT_DATA); \ - if (name == NULL) { \ - sock_set_errno(sock, ENOMEM); \ - done_socket(sock); \ - return -1; \ - } }while(0) -#else /* LWIP_MPU_COMPATIBLE */ -#define LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(name, sock) -#endif /* LWIP_MPU_COMPATIBLE */ - -#if LWIP_SO_SNDRCVTIMEO_NONSTANDARD -#define LWIP_SO_SNDRCVTIMEO_OPTTYPE int -#define LWIP_SO_SNDRCVTIMEO_SET(optval, val) (*(int *)(optval) = (val)) -#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval) ((long)*(const int*)(optval)) -#else -#define LWIP_SO_SNDRCVTIMEO_OPTTYPE struct timeval -#define LWIP_SO_SNDRCVTIMEO_SET(optval, val) do { \ - u32_t loc = (val); \ - ((struct timeval *)(optval))->tv_sec = (long)((loc) / 1000U); \ - ((struct timeval *)(optval))->tv_usec = (long)(((loc) % 1000U) * 1000U); }while(0) -#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval) ((((const struct timeval *)(optval))->tv_sec * 1000) + (((const struct timeval *)(optval))->tv_usec / 1000)) -#endif - - -/** A struct sockaddr replacement that has the same alignment as sockaddr_in/ - * sockaddr_in6 if instantiated. - */ -union sockaddr_aligned { - struct sockaddr sa; -#if LWIP_IPV6 - struct sockaddr_in6 sin6; -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 - struct sockaddr_in sin; -#endif /* LWIP_IPV4 */ -}; - -/* Define the number of IPv4 multicast memberships, default is one per socket */ -#ifndef LWIP_SOCKET_MAX_MEMBERSHIPS -#define LWIP_SOCKET_MAX_MEMBERSHIPS NUM_SOCKETS -#endif - -#if LWIP_IGMP -/* This is to keep track of IP_ADD_MEMBERSHIP calls to drop the membership when - a socket is closed */ -struct lwip_socket_multicast_pair { - /** the socket */ - struct lwip_sock *sock; - /** the interface address */ - ip4_addr_t if_addr; - /** the group address */ - ip4_addr_t multi_addr; -}; - -static struct lwip_socket_multicast_pair socket_ipv4_multicast_memberships[LWIP_SOCKET_MAX_MEMBERSHIPS]; - -static int lwip_socket_register_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr); -static void lwip_socket_unregister_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr); -static void lwip_socket_drop_registered_memberships(int s); -#endif /* LWIP_IGMP */ - -#if LWIP_IPV6_MLD -/* This is to keep track of IP_JOIN_GROUP calls to drop the membership when - a socket is closed */ -struct lwip_socket_multicast_mld6_pair { - /** the socket */ - struct lwip_sock *sock; - /** the interface index */ - u8_t if_idx; - /** the group address */ - ip6_addr_t multi_addr; -}; - -static struct lwip_socket_multicast_mld6_pair socket_ipv6_multicast_memberships[LWIP_SOCKET_MAX_MEMBERSHIPS]; - -static int lwip_socket_register_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr); -static void lwip_socket_unregister_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr); -static void lwip_socket_drop_registered_mld6_memberships(int s); -#endif /* LWIP_IPV6_MLD */ - -/** The global array of available sockets */ -static struct lwip_sock sockets[NUM_SOCKETS]; - -#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL -#if LWIP_TCPIP_CORE_LOCKING -/* protect the select_cb_list using core lock */ -#define LWIP_SOCKET_SELECT_DECL_PROTECT(lev) -#define LWIP_SOCKET_SELECT_PROTECT(lev) LOCK_TCPIP_CORE() -#define LWIP_SOCKET_SELECT_UNPROTECT(lev) UNLOCK_TCPIP_CORE() -#else /* LWIP_TCPIP_CORE_LOCKING */ -/* protect the select_cb_list using SYS_LIGHTWEIGHT_PROT */ -#define LWIP_SOCKET_SELECT_DECL_PROTECT(lev) SYS_ARCH_DECL_PROTECT(lev) -#define LWIP_SOCKET_SELECT_PROTECT(lev) SYS_ARCH_PROTECT(lev) -#define LWIP_SOCKET_SELECT_UNPROTECT(lev) SYS_ARCH_UNPROTECT(lev) -/** This counter is increased from lwip_select when the list is changed - and checked in select_check_waiters to see if it has changed. */ -static volatile int select_cb_ctr; -#endif /* LWIP_TCPIP_CORE_LOCKING */ -/** The global list of tasks waiting for select */ -static struct lwip_select_cb *select_cb_list; -#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ - -#define sock_set_errno(sk, e) do { \ - const int sockerr = (e); \ - set_errno(sockerr); \ -} while (0) - -/* Forward declaration of some functions */ -#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL -static void event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len); -#define DEFAULT_SOCKET_EVENTCB event_callback -static void select_check_waiters(int s, int has_recvevent, int has_sendevent, int has_errevent); -#else -#define DEFAULT_SOCKET_EVENTCB NULL -#endif -#if !LWIP_TCPIP_CORE_LOCKING -static void lwip_getsockopt_callback(void *arg); -static void lwip_setsockopt_callback(void *arg); -#endif -static int lwip_getsockopt_impl(int s, int level, int optname, void *optval, socklen_t *optlen); -static int lwip_setsockopt_impl(int s, int level, int optname, const void *optval, socklen_t optlen); -static int free_socket_locked(struct lwip_sock *sock, int is_tcp, struct netconn **conn, - union lwip_sock_lastdata *lastdata); -static void free_socket_free_elements(int is_tcp, struct netconn *conn, union lwip_sock_lastdata *lastdata); - -#if LWIP_IPV4 && LWIP_IPV6 -static void -sockaddr_to_ipaddr_port(const struct sockaddr *sockaddr, ip_addr_t *ipaddr, u16_t *port) -{ - if ((sockaddr->sa_family) == AF_INET6) { - SOCKADDR6_TO_IP6ADDR_PORT((const struct sockaddr_in6 *)(const void *)(sockaddr), ipaddr, *port); - ipaddr->type = IPADDR_TYPE_V6; - } else { - SOCKADDR4_TO_IP4ADDR_PORT((const struct sockaddr_in *)(const void *)(sockaddr), ipaddr, *port); - ipaddr->type = IPADDR_TYPE_V4; - } -} -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - -/** LWIP_NETCONN_SEM_PER_THREAD==1: initialize thread-local semaphore */ -void -lwip_socket_thread_init(void) -{ - netconn_thread_init(); -} - -/** LWIP_NETCONN_SEM_PER_THREAD==1: destroy thread-local semaphore */ -void -lwip_socket_thread_cleanup(void) -{ - netconn_thread_cleanup(); -} - -#if LWIP_NETCONN_FULLDUPLEX -/* Thread-safe increment of sock->fd_used, with overflow check */ -static int -sock_inc_used(struct lwip_sock *sock) -{ - int ret; - SYS_ARCH_DECL_PROTECT(lev); - - LWIP_ASSERT("sock != NULL", sock != NULL); - - SYS_ARCH_PROTECT(lev); - if (sock->fd_free_pending) { - /* prevent new usage of this socket if free is pending */ - ret = 0; - } else { - ++sock->fd_used; - ret = 1; - LWIP_ASSERT("sock->fd_used != 0", sock->fd_used != 0); - } - SYS_ARCH_UNPROTECT(lev); - return ret; -} - -/* Like sock_inc_used(), but called under SYS_ARCH_PROTECT lock. */ -static int -sock_inc_used_locked(struct lwip_sock *sock) -{ - LWIP_ASSERT("sock != NULL", sock != NULL); - - if (sock->fd_free_pending) { - LWIP_ASSERT("sock->fd_used != 0", sock->fd_used != 0); - return 0; - } - - ++sock->fd_used; - LWIP_ASSERT("sock->fd_used != 0", sock->fd_used != 0); - return 1; -} - -/* In full-duplex mode,sock->fd_used != 0 prevents a socket descriptor from being - * released (and possibly reused) when used from more than one thread - * (e.g. read-while-write or close-while-write, etc) - * This function is called at the end of functions using (try)get_socket*(). - */ -static void -done_socket(struct lwip_sock *sock) -{ - int freed = 0; - int is_tcp = 0; - struct netconn *conn = NULL; - union lwip_sock_lastdata lastdata; - SYS_ARCH_DECL_PROTECT(lev); - LWIP_ASSERT("sock != NULL", sock != NULL); - - SYS_ARCH_PROTECT(lev); - LWIP_ASSERT("sock->fd_used > 0", sock->fd_used > 0); - if (--sock->fd_used == 0) { - if (sock->fd_free_pending) { - /* free the socket */ - sock->fd_used = 1; - is_tcp = sock->fd_free_pending & LWIP_SOCK_FD_FREE_TCP; - freed = free_socket_locked(sock, is_tcp, &conn, &lastdata); - } - } - SYS_ARCH_UNPROTECT(lev); - - if (freed) { - free_socket_free_elements(is_tcp, conn, &lastdata); - } -} - -#else /* LWIP_NETCONN_FULLDUPLEX */ -#define sock_inc_used(sock) 1 -#define sock_inc_used_locked(sock) 1 -#define done_socket(sock) -#endif /* LWIP_NETCONN_FULLDUPLEX */ - -//tmp -#define EMSGSIZE 90 /* Message too long */ -#define ENOTCONN 107 /* Transport endpoint is not connected */ -#define ENOPROTOOPT 92 /* Protocol not available */ -#define ENOSYS 38 /* Function not implemented */ -#define EAFNOSUPPORT 97 /* Address family not supported by protocol */ - - -/* Translate a socket 'int' into a pointer (only fails if the index is invalid) */ -static struct lwip_sock * -tryget_socket_unconn_nouse(int fd) -{ - int s = fd - LWIP_SOCKET_OFFSET; - if ((s < 0) || (s >= NUM_SOCKETS)) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("tryget_socket_unconn(%d): invalid\n", fd)); - return NULL; - } - return &sockets[s]; -} - -struct lwip_sock * -lwip_socket_dbg_get_socket(int fd) -{ - return tryget_socket_unconn_nouse(fd); -} - -/* Translate a socket 'int' into a pointer (only fails if the index is invalid) */ -static struct lwip_sock * -tryget_socket_unconn(int fd) -{ - struct lwip_sock *ret = tryget_socket_unconn_nouse(fd); - if (ret != NULL) { - if (!sock_inc_used(ret)) { - return NULL; - } - } - return ret; -} - -/* Like tryget_socket_unconn(), but called under SYS_ARCH_PROTECT lock. */ -static struct lwip_sock * -tryget_socket_unconn_locked(int fd) -{ - struct lwip_sock *ret = tryget_socket_unconn_nouse(fd); - if (ret != NULL) { - if (!sock_inc_used_locked(ret)) { - return NULL; - } - } - return ret; -} - -/** - * Same as get_socket but doesn't set errno - * - * @param fd externally used socket index - * @return struct lwip_sock for the socket or NULL if not found - */ -static struct lwip_sock * -tryget_socket(int fd) -{ - struct lwip_sock *sock = tryget_socket_unconn(fd); - if (sock != NULL) { - if (sock->conn) { - return sock; - } - done_socket(sock); - } - return NULL; -} - -/** - * Map a externally used socket index to the internal socket representation. - * - * @param fd externally used socket index - * @return struct lwip_sock for the socket or NULL if not found - */ -static struct lwip_sock * -get_socket(int fd) -{ - struct lwip_sock *sock = tryget_socket(fd); - if (!sock) { - if ((fd < LWIP_SOCKET_OFFSET) || (fd >= (LWIP_SOCKET_OFFSET + NUM_SOCKETS))) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", fd)); - } - set_errno(EBADF); - return NULL; - } - return sock; -} - -/** - * Allocate a new socket for a given netconn. - * - * @param newconn the netconn for which to allocate a socket - * @param accepted 1 if socket has been created by accept(), - * 0 if socket has been created by socket() - * @return the index of the new socket; -1 on error - */ -static int -alloc_socket(struct netconn *newconn, int accepted) -{ - int i; - SYS_ARCH_DECL_PROTECT(lev); - LWIP_UNUSED_ARG(accepted); - - /* allocate a new socket identifier */ - for (i = 0; i < NUM_SOCKETS; ++i) { - /* Protect socket array */ - SYS_ARCH_PROTECT(lev); - if (!sockets[i].conn) { -#if LWIP_NETCONN_FULLDUPLEX - if (sockets[i].fd_used) { - SYS_ARCH_UNPROTECT(lev); - continue; - } - sockets[i].fd_used = 1; - sockets[i].fd_free_pending = 0; -#endif - sockets[i].conn = newconn; - /* The socket is not yet known to anyone, so no need to protect - after having marked it as used. */ - SYS_ARCH_UNPROTECT(lev); - sockets[i].lastdata.pbuf = NULL; -#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL - LWIP_ASSERT("sockets[i].select_waiting == 0", sockets[i].select_waiting == 0); - sockets[i].rcvevent = 0; - /* TCP sendbuf is empty, but the socket is not yet writable until connected - * (unless it has been created by accept()). */ - sockets[i].sendevent = (NETCONNTYPE_GROUP(newconn->type) == NETCONN_TCP ? (accepted != 0) : 1); - sockets[i].errevent = 0; -#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ - return i + LWIP_SOCKET_OFFSET; - } - SYS_ARCH_UNPROTECT(lev); - } - return -1; -} - -/** Free a socket (under lock) - * - * @param sock the socket to free - * @param is_tcp != 0 for TCP sockets, used to free lastdata - * @param conn the socekt's netconn is stored here, must be freed externally - * @param lastdata lastdata is stored here, must be freed externally - */ -static int -free_socket_locked(struct lwip_sock *sock, int is_tcp, struct netconn **conn, - union lwip_sock_lastdata *lastdata) -{ -#if LWIP_NETCONN_FULLDUPLEX - LWIP_ASSERT("sock->fd_used > 0", sock->fd_used > 0); - sock->fd_used--; - if (sock->fd_used > 0) { - sock->fd_free_pending = LWIP_SOCK_FD_FREE_FREE | (is_tcp ? LWIP_SOCK_FD_FREE_TCP : 0); - return 0; - } -#else /* LWIP_NETCONN_FULLDUPLEX */ - LWIP_UNUSED_ARG(is_tcp); -#endif /* LWIP_NETCONN_FULLDUPLEX */ - - *lastdata = sock->lastdata; - sock->lastdata.pbuf = NULL; - *conn = sock->conn; - sock->conn = NULL; - return 1; -} - -/** Free a socket's leftover members. - */ -static void -free_socket_free_elements(int is_tcp, struct netconn *conn, union lwip_sock_lastdata *lastdata) -{ - if (lastdata->pbuf != NULL) { - if (is_tcp) { - pbuf_free(lastdata->pbuf); - } else { - netbuf_delete(lastdata->netbuf); - } - } - if (conn != NULL) { - /* netconn_prepare_delete() has already been called, here we only free the conn */ - netconn_delete(conn); - } -} - -/** Free a socket. The socket's netconn must have been - * delete before! - * - * @param sock the socket to free - * @param is_tcp != 0 for TCP sockets, used to free lastdata - */ -static void -free_socket(struct lwip_sock *sock, int is_tcp) -{ - int freed; - struct netconn *conn; - union lwip_sock_lastdata lastdata; - SYS_ARCH_DECL_PROTECT(lev); - - /* Protect socket array */ - SYS_ARCH_PROTECT(lev); - - freed = free_socket_locked(sock, is_tcp, &conn, &lastdata); - SYS_ARCH_UNPROTECT(lev); - /* don't use 'sock' after this line, as another task might have allocated it */ - - if (freed) { - free_socket_free_elements(is_tcp, conn, &lastdata); - } -} - -/* Below this, the well-known socket functions are implemented. - * Use google.com or opengroup.org to get a good description :-) - * - * Exceptions are documented! - */ - -int -lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen) -{ - struct lwip_sock *sock, *nsock; - struct netconn *newconn; - ip_addr_t naddr; - u16_t port = 0; - int newsock; - err_t err; - int recvevent; - SYS_ARCH_DECL_PROTECT(lev); - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s)); - sock = get_socket(s); - if (!sock) { - return -1; - } - - /* wait for a new connection */ - err = netconn_accept(sock->conn, &newconn); - if (err != ERR_OK) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): netconn_acept failed, err=%d\n", s, err)); - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { - sock_set_errno(sock, EOPNOTSUPP); - } else if (err == ERR_CLSD) { - sock_set_errno(sock, EINVAL); - } else { - sock_set_errno(sock, err_to_errno(err)); - } - done_socket(sock); - return -1; - } - LWIP_ASSERT("newconn != NULL", newconn != NULL); - - newsock = alloc_socket(newconn, 1); - if (newsock == -1) { - netconn_delete(newconn); - sock_set_errno(sock, ENFILE); - done_socket(sock); - return -1; - } - LWIP_ASSERT("invalid socket index", (newsock >= LWIP_SOCKET_OFFSET) && (newsock < NUM_SOCKETS + LWIP_SOCKET_OFFSET)); - nsock = &sockets[newsock - LWIP_SOCKET_OFFSET]; - - /* See event_callback: If data comes in right away after an accept, even - * though the server task might not have created a new socket yet. - * In that case, newconn->socket is counted down (newconn->socket--), - * so nsock->rcvevent is >= 1 here! - */ - SYS_ARCH_PROTECT(lev); - recvevent = (s16_t)(-1 - newconn->socket); - newconn->socket = newsock; - SYS_ARCH_UNPROTECT(lev); - - if (newconn->callback) { - LOCK_TCPIP_CORE(); - while (recvevent > 0) { - recvevent--; - newconn->callback(newconn, NETCONN_EVT_RCVPLUS, 0); - } - UNLOCK_TCPIP_CORE(); - } - - /* Note that POSIX only requires us to check addr is non-NULL. addrlen must - * not be NULL if addr is valid. - */ - if ((addr != NULL) && (addrlen != NULL)) { - union sockaddr_aligned tempaddr; - /* get the IP address and port of the remote host */ - err = netconn_peer(newconn, &naddr, &port); - if (err != ERR_OK) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): netconn_peer failed, err=%d\n", s, err)); - netconn_delete(newconn); - free_socket(nsock, 1); - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return -1; - } - - IPADDR_PORT_TO_SOCKADDR(&tempaddr, &naddr, port); - if (*addrlen > tempaddr.sa.sa_len) { - *addrlen = tempaddr.sa.sa_len; - } - MEMCPY(addr, &tempaddr, *addrlen); - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock)); - ip_addr_debug_print_val(SOCKETS_DEBUG, naddr); - LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F"\n", port)); - } else { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d", s, newsock)); - } - - sock_set_errno(sock, 0); - done_socket(sock); - done_socket(nsock); - return newsock; -} - -int -lwip_bind(int s, const struct sockaddr *name, socklen_t namelen) -{ - struct lwip_sock *sock; - ip_addr_t local_addr; - u16_t local_port; - err_t err; - - sock = get_socket(s); - if (!sock) { - return -1; - } - - if (!SOCK_ADDR_TYPE_MATCH(name, sock)) { - /* sockaddr does not match socket type (IPv4/IPv6) */ - sock_set_errno(sock, err_to_errno(ERR_VAL)); - done_socket(sock); - return -1; - } - - /* check size, family and alignment of 'name' */ - LWIP_ERROR("lwip_bind: invalid address", (IS_SOCK_ADDR_LEN_VALID(namelen) && - IS_SOCK_ADDR_TYPE_VALID(name) && IS_SOCK_ADDR_ALIGNED(name)), - sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); - LWIP_UNUSED_ARG(namelen); - - SOCKADDR_TO_IPADDR_PORT(name, &local_addr, local_port); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s)); - ip_addr_debug_print_val(SOCKETS_DEBUG, local_addr); - LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", local_port)); - -#if LWIP_IPV4 && LWIP_IPV6 - /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ - if (IP_IS_V6_VAL(local_addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&local_addr))) { - unmap_ipv4_mapped_ipv6(ip_2_ip4(&local_addr), ip_2_ip6(&local_addr)); - IP_SET_TYPE_VAL(local_addr, IPADDR_TYPE_V4); - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - err = netconn_bind(sock->conn, &local_addr, local_port); - - if (err != ERR_OK) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) failed, err=%d\n", s, err)); - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return -1; - } - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) succeeded\n", s)); - sock_set_errno(sock, 0); - done_socket(sock); - return 0; -} - -int -lwip_close(int s) -{ - struct lwip_sock *sock; - int is_tcp = 0; - err_t err; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_close(%d)\n", s)); - - sock = get_socket(s); - if (!sock) { - return -1; - } - - if (sock->conn != NULL) { - is_tcp = NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP; - } else { - LWIP_ASSERT("sock->lastdata == NULL", sock->lastdata.pbuf == NULL); - } - -#if LWIP_IGMP - /* drop all possibly joined IGMP memberships */ - lwip_socket_drop_registered_memberships(s); -#endif /* LWIP_IGMP */ -#if LWIP_IPV6_MLD - /* drop all possibly joined MLD6 memberships */ - lwip_socket_drop_registered_mld6_memberships(s); -#endif /* LWIP_IPV6_MLD */ - - err = netconn_prepare_delete(sock->conn); - if (err != ERR_OK) { - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return -1; - } - - free_socket(sock, is_tcp); - set_errno(0); - return 0; -} - -int -lwip_connect(int s, const struct sockaddr *name, socklen_t namelen) -{ - struct lwip_sock *sock; - err_t err; - - sock = get_socket(s); - if (!sock) { - return -1; - } - - if (!SOCK_ADDR_TYPE_MATCH_OR_UNSPEC(name, sock)) { - /* sockaddr does not match socket type (IPv4/IPv6) */ - sock_set_errno(sock, err_to_errno(ERR_VAL)); - done_socket(sock); - return -1; - } - - LWIP_UNUSED_ARG(namelen); - if (name->sa_family == AF_UNSPEC) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, AF_UNSPEC)\n", s)); - err = netconn_disconnect(sock->conn); - } else { - ip_addr_t remote_addr; - u16_t remote_port; - - /* check size, family and alignment of 'name' */ - LWIP_ERROR("lwip_connect: invalid address", IS_SOCK_ADDR_LEN_VALID(namelen) && - IS_SOCK_ADDR_TYPE_VALID_OR_UNSPEC(name) && IS_SOCK_ADDR_ALIGNED(name), - sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); - - SOCKADDR_TO_IPADDR_PORT(name, &remote_addr, remote_port); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s)); - ip_addr_debug_print_val(SOCKETS_DEBUG, remote_addr); - LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", remote_port)); - -#if LWIP_IPV4 && LWIP_IPV6 - /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ - if (IP_IS_V6_VAL(remote_addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&remote_addr))) { - unmap_ipv4_mapped_ipv6(ip_2_ip4(&remote_addr), ip_2_ip6(&remote_addr)); - IP_SET_TYPE_VAL(remote_addr, IPADDR_TYPE_V4); - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - err = netconn_connect(sock->conn, &remote_addr, remote_port); - } - - if (err != ERR_OK) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) failed, err=%d\n", s, err)); - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return -1; - } - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) succeeded\n", s)); - sock_set_errno(sock, 0); - done_socket(sock); - return 0; -} - -/** - * Set a socket into listen mode. - * The socket may not have been used for another connection previously. - * - * @param s the socket to set to listening mode - * @param backlog (ATTENTION: needs TCP_LISTEN_BACKLOG=1) - * @return 0 on success, non-zero on failure - */ -int -lwip_listen(int s, int backlog) -{ - struct lwip_sock *sock; - err_t err; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog)); - - sock = get_socket(s); - if (!sock) { - return -1; - } - - /* limit the "backlog" parameter to fit in an u8_t */ - backlog = LWIP_MIN(LWIP_MAX(backlog, 0), 0xff); - - err = netconn_listen_with_backlog(sock->conn, (u8_t)backlog); - - if (err != ERR_OK) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d) failed, err=%d\n", s, err)); - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { - sock_set_errno(sock, EOPNOTSUPP); - } else { - sock_set_errno(sock, err_to_errno(err)); - } - done_socket(sock); - return -1; - } - - sock_set_errno(sock, 0); - done_socket(sock); - return 0; -} - -#if LWIP_TCP -/* Helper function to loop over receiving pbufs from netconn - * until "len" bytes are received or we're otherwise done. - * Keeps sock->lastdata for peeking or partly copying. - */ -static ssize_t -lwip_recv_tcp(struct lwip_sock *sock, void *mem, size_t len, int flags) -{ - u8_t apiflags = NETCONN_NOAUTORCVD; - ssize_t recvd = 0; - ssize_t recv_left = (len <= SSIZE_MAX) ? (ssize_t)len : SSIZE_MAX; - - LWIP_ASSERT("no socket given", sock != NULL); - LWIP_ASSERT("this should be checked internally", NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP); - - if (flags & MSG_DONTWAIT) { - apiflags |= NETCONN_DONTBLOCK; - } - - do { - struct pbuf *p; - err_t err; - u16_t copylen; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: top while sock->lastdata=%p\n", (void *)sock->lastdata.pbuf)); - /* Check if there is data left from the last recv operation. */ - if (sock->lastdata.pbuf) { - p = sock->lastdata.pbuf; - } else { - /* No data was left from the previous operation, so we try to get - some from the network. */ - err = netconn_recv_tcp_pbuf_flags(sock->conn, &p, apiflags); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: netconn_recv err=%d, pbuf=%p\n", - err, (void *)p)); - - if (err != ERR_OK) { - if (recvd > 0) { - /* already received data, return that (this trusts in getting the same error from - netconn layer again next time netconn_recv is called) */ - goto lwip_recv_tcp_done; - } - /* We should really do some error checking here. */ - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: p == NULL, error is \"%s\"!\n", - lwip_strerr(err))); - sock_set_errno(sock, err_to_errno(err)); - if (err == ERR_CLSD) { - return 0; - } else { - return -1; - } - } - LWIP_ASSERT("p != NULL", p != NULL); - sock->lastdata.pbuf = p; - } - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: buflen=%"U16_F" recv_left=%d off=%d\n", - p->tot_len, (int)recv_left, (int)recvd)); - - if (recv_left > p->tot_len) { - copylen = p->tot_len; - } else { - copylen = (u16_t)recv_left; - } - if (recvd + copylen < recvd) { - /* overflow */ - copylen = (u16_t)(SSIZE_MAX - recvd); - } - - /* copy the contents of the received buffer into - the supplied memory pointer mem */ - pbuf_copy_partial(p, (u8_t *)mem + recvd, copylen, 0); - - recvd += copylen; - - /* TCP combines multiple pbufs for one recv */ - LWIP_ASSERT("invalid copylen, len would underflow", recv_left >= copylen); - recv_left -= copylen; - - /* Unless we peek the incoming message... */ - if ((flags & MSG_PEEK) == 0) { - /* ... check if there is data left in the pbuf */ - LWIP_ASSERT("invalid copylen", p->tot_len >= copylen); - if (p->tot_len - copylen > 0) { - /* If so, it should be saved in the sock structure for the next recv call. - We store the pbuf but hide/free the consumed data: */ - sock->lastdata.pbuf = pbuf_free_header(p, copylen); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: lastdata now pbuf=%p\n", (void *)sock->lastdata.pbuf)); - } else { - sock->lastdata.pbuf = NULL; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: deleting pbuf=%p\n", (void *)p)); - pbuf_free(p); - } - } - /* once we have some data to return, only add more if we don't need to wait */ - apiflags |= NETCONN_DONTBLOCK | NETCONN_NOFIN; - /* @todo: do we need to support peeking more than one pbuf? */ - } while ((recv_left > 0) && !(flags & MSG_PEEK)); -lwip_recv_tcp_done: - if ((recvd > 0) && !(flags & MSG_PEEK)) { - /* ensure window update after copying all data */ - netconn_tcp_recvd(sock->conn, (size_t)recvd); - } - sock_set_errno(sock, 0); - return recvd; -} -#endif - -/* Convert a netbuf's address data to struct sockaddr */ -static int -lwip_sock_make_addr(struct netconn *conn, ip_addr_t *fromaddr, u16_t port, - struct sockaddr *from, socklen_t *fromlen) -{ - int truncated = 0; - union sockaddr_aligned saddr; - - LWIP_UNUSED_ARG(conn); - - LWIP_ASSERT("fromaddr != NULL", fromaddr != NULL); - LWIP_ASSERT("from != NULL", from != NULL); - LWIP_ASSERT("fromlen != NULL", fromlen != NULL); - -#if LWIP_IPV4 && LWIP_IPV6 - /* Dual-stack: Map IPv4 addresses to IPv4 mapped IPv6 */ - if (NETCONNTYPE_ISIPV6(netconn_type(conn)) && IP_IS_V4(fromaddr)) { - ip4_2_ipv4_mapped_ipv6(ip_2_ip6(fromaddr), ip_2_ip4(fromaddr)); - IP_SET_TYPE(fromaddr, IPADDR_TYPE_V6); - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - IPADDR_PORT_TO_SOCKADDR(&saddr, fromaddr, port); - if (*fromlen < saddr.sa.sa_len) { - truncated = 1; - } else if (*fromlen > saddr.sa.sa_len) { - *fromlen = saddr.sa.sa_len; - } - MEMCPY(from, &saddr, *fromlen); - return truncated; -} - -#if LWIP_TCP -/* Helper function to get a tcp socket's remote address info */ -static int -lwip_recv_tcp_from(struct lwip_sock *sock, struct sockaddr *from, socklen_t *fromlen, const char *dbg_fn, int dbg_s, ssize_t dbg_ret) -{ - if (sock == NULL) { - return 0; - } - LWIP_UNUSED_ARG(dbg_fn); - LWIP_UNUSED_ARG(dbg_s); - LWIP_UNUSED_ARG(dbg_ret); - -#if !SOCKETS_DEBUG - if (from && fromlen) -#endif /* !SOCKETS_DEBUG */ - { - /* get remote addr/port from tcp_pcb */ - u16_t port; - ip_addr_t tmpaddr; - netconn_getaddr(sock->conn, &tmpaddr, &port, 0); - LWIP_DEBUGF(SOCKETS_DEBUG, ("%s(%d): addr=", dbg_fn, dbg_s)); - ip_addr_debug_print_val(SOCKETS_DEBUG, tmpaddr); - LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F" len=%d\n", port, (int)dbg_ret)); - if (from && fromlen) { - return lwip_sock_make_addr(sock->conn, &tmpaddr, port, from, fromlen); - } - } - return 0; -} -#endif - -/* Helper function to receive a netbuf from a udp or raw netconn. - * Keeps sock->lastdata for peeking. - */ -static err_t -lwip_recvfrom_udp_raw(struct lwip_sock *sock, int flags, struct msghdr *msg, u16_t *datagram_len, int dbg_s) -{ - struct netbuf *buf; - u8_t apiflags; - err_t err; - u16_t buflen, copylen, copied; - int i; - - LWIP_UNUSED_ARG(dbg_s); - LWIP_ERROR("lwip_recvfrom_udp_raw: invalid arguments", (msg->msg_iov != NULL) || (msg->msg_iovlen <= 0), return ERR_ARG;); - - if (flags & MSG_DONTWAIT) { - apiflags = NETCONN_DONTBLOCK; - } else { - apiflags = 0; - } - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw[UDP/RAW]: top sock->lastdata=%p\n", (void *)sock->lastdata.netbuf)); - /* Check if there is data left from the last recv operation. */ - buf = sock->lastdata.netbuf; - if (buf == NULL) { - /* No data was left from the previous operation, so we try to get - some from the network. */ - err = netconn_recv_udp_raw_netbuf_flags(sock->conn, &buf, apiflags); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw[UDP/RAW]: netconn_recv err=%d, netbuf=%p\n", - err, (void *)buf)); - - if (err != ERR_OK) { - return err; - } - LWIP_ASSERT("buf != NULL", buf != NULL); - sock->lastdata.netbuf = buf; - } - buflen = buf->p->tot_len; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw: buflen=%"U16_F"\n", buflen)); - - copied = 0; - /* copy the pbuf payload into the iovs */ - for (i = 0; (i < msg->msg_iovlen) && (copied < buflen); i++) { - u16_t len_left = (u16_t)(buflen - copied); - if (msg->msg_iov[i].iov_len > len_left) { - copylen = len_left; - } else { - copylen = (u16_t)msg->msg_iov[i].iov_len; - } - - /* copy the contents of the received buffer into - the supplied memory buffer */ - pbuf_copy_partial(buf->p, (u8_t *)msg->msg_iov[i].iov_base, copylen, copied); - copied = (u16_t)(copied + copylen); - } - - /* Check to see from where the data was.*/ -#if !SOCKETS_DEBUG - if (msg->msg_name && msg->msg_namelen) -#endif /* !SOCKETS_DEBUG */ - { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw(%d): addr=", dbg_s)); - ip_addr_debug_print_val(SOCKETS_DEBUG, *netbuf_fromaddr(buf)); - LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F" len=%d\n", netbuf_fromport(buf), copied)); - if (msg->msg_name && msg->msg_namelen) { - lwip_sock_make_addr(sock->conn, netbuf_fromaddr(buf), netbuf_fromport(buf), - (struct sockaddr *)msg->msg_name, &msg->msg_namelen); - } - } - - /* Initialize flag output */ - msg->msg_flags = 0; - - if (msg->msg_control) { - u8_t wrote_msg = 0; -#if LWIP_NETBUF_RECVINFO - /* Check if packet info was recorded */ - if (buf->flags & NETBUF_FLAG_DESTADDR) { - if (IP_IS_V4(&buf->toaddr)) { -#if LWIP_IPV4 - if (msg->msg_controllen >= CMSG_SPACE(sizeof(struct in_pktinfo))) { - struct cmsghdr *chdr = CMSG_FIRSTHDR(msg); /* This will always return a header!! */ - struct in_pktinfo *pkti = (struct in_pktinfo *)CMSG_DATA(chdr); - chdr->cmsg_level = IPPROTO_IP; - chdr->cmsg_type = IP_PKTINFO; - chdr->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo)); - pkti->ipi_ifindex = buf->p->if_idx; - inet_addr_from_ip4addr(&pkti->ipi_addr, ip_2_ip4(netbuf_destaddr(buf))); - msg->msg_controllen = CMSG_SPACE(sizeof(struct in_pktinfo)); - wrote_msg = 1; - } else { - msg->msg_flags |= MSG_CTRUNC; - } -#endif /* LWIP_IPV4 */ - } - } -#endif /* LWIP_NETBUF_RECVINFO */ - - if (!wrote_msg) { - msg->msg_controllen = 0; - } - } - - /* If we don't peek the incoming message: zero lastdata pointer and free the netbuf */ - if ((flags & MSG_PEEK) == 0) { - sock->lastdata.netbuf = NULL; - netbuf_delete(buf); - } - if (datagram_len) { - *datagram_len = buflen; - } - return ERR_OK; -} - -ssize_t -lwip_recvfrom(int s, void *mem, size_t len, int flags, - struct sockaddr *from, socklen_t *fromlen) -{ - struct lwip_sock *sock; - ssize_t ret; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %"SZT_F", 0x%x, ..)\n", s, mem, len, flags)); - sock = get_socket(s); - if (!sock) { - return -1; - } -#if LWIP_TCP - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { - ret = lwip_recv_tcp(sock, mem, len, flags); - lwip_recv_tcp_from(sock, from, fromlen, "lwip_recvfrom", s, ret); - done_socket(sock); - return ret; - } else -#endif - { - u16_t datagram_len = 0; - struct iovec vec; - struct msghdr msg; - err_t err; - vec.iov_base = mem; - vec.iov_len = len; - msg.msg_control = NULL; - msg.msg_controllen = 0; - msg.msg_flags = 0; - msg.msg_iov = &vec; - msg.msg_iovlen = 1; - msg.msg_name = from; - msg.msg_namelen = (fromlen ? *fromlen : 0); - err = lwip_recvfrom_udp_raw(sock, flags, &msg, &datagram_len, s); - if (err != ERR_OK) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom[UDP/RAW](%d): buf == NULL, error is \"%s\"!\n", - s, lwip_strerr(err))); - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return -1; - } - ret = (ssize_t)LWIP_MIN(LWIP_MIN(len, datagram_len), SSIZE_MAX); - if (fromlen) { - *fromlen = msg.msg_namelen; - } - } - - sock_set_errno(sock, 0); - done_socket(sock); - return ret; -} - -ssize_t -lwip_read(int s, void *mem, size_t len) -{ - return lwip_recvfrom(s, mem, len, 0, NULL, NULL); -} - -ssize_t -lwip_readv(int s, const struct iovec *iov, int iovcnt) -{ - struct msghdr msg; - - msg.msg_name = NULL; - msg.msg_namelen = 0; - /* Hack: we have to cast via number to cast from 'const' pointer to non-const. - Blame the opengroup standard for this inconsistency. */ - msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); - msg.msg_iovlen = iovcnt; - msg.msg_control = NULL; - msg.msg_controllen = 0; - msg.msg_flags = 0; - return lwip_recvmsg(s, &msg, 0); -} - -ssize_t -lwip_recv(int s, void *mem, size_t len, int flags) -{ - return lwip_recvfrom(s, mem, len, flags, NULL, NULL); -} - -ssize_t -lwip_recvmsg(int s, struct msghdr *message, int flags) -{ - struct lwip_sock *sock; - int i; - ssize_t buflen; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvmsg(%d, message=%p, flags=0x%x)\n", s, (void *)message, flags)); - LWIP_ERROR("lwip_recvmsg: invalid message pointer", message != NULL, return ERR_ARG;); - LWIP_ERROR("lwip_recvmsg: unsupported flags", (flags & ~(MSG_PEEK|MSG_DONTWAIT)) == 0, - set_errno(EOPNOTSUPP); return -1;); - - if ((message->msg_iovlen <= 0) || (message->msg_iovlen > IOV_MAX)) { - set_errno(EMSGSIZE); - return -1; - } - - sock = get_socket(s); - if (!sock) { - return -1; - } - - /* check for valid vectors */ - buflen = 0; - for (i = 0; i < message->msg_iovlen; i++) { - if ((message->msg_iov[i].iov_base == NULL) || ((ssize_t)message->msg_iov[i].iov_len <= 0) || - ((size_t)(ssize_t)message->msg_iov[i].iov_len != message->msg_iov[i].iov_len) || - ((ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len) <= 0)) { - sock_set_errno(sock, err_to_errno(ERR_VAL)); - done_socket(sock); - return -1; - } - buflen = (ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len); - } - - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { -#if LWIP_TCP - int recv_flags = flags; - message->msg_flags = 0; - /* recv the data */ - buflen = 0; - for (i = 0; i < message->msg_iovlen; i++) { - /* try to receive into this vector's buffer */ - ssize_t recvd_local = lwip_recv_tcp(sock, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len, recv_flags); - if (recvd_local > 0) { - /* sum up received bytes */ - buflen += recvd_local; - } - if ((recvd_local < 0) || (recvd_local < (int)message->msg_iov[i].iov_len) || - (flags & MSG_PEEK)) { - /* returned prematurely (or peeking, which might actually be limitated to the first iov) */ - if (buflen <= 0) { - /* nothing received at all, propagate the error */ - buflen = recvd_local; - } - break; - } - /* pass MSG_DONTWAIT to lwip_recv_tcp() to prevent waiting for more data */ - recv_flags |= MSG_DONTWAIT; - } - if (buflen > 0) { - /* reset socket error since we have received something */ - sock_set_errno(sock, 0); - } - /* " If the socket is connected, the msg_name and msg_namelen members shall be ignored." */ - done_socket(sock); - return buflen; -#else /* LWIP_TCP */ - sock_set_errno(sock, err_to_errno(ERR_ARG)); - done_socket(sock); - return -1; -#endif /* LWIP_TCP */ - } - /* else, UDP and RAW NETCONNs */ -#if LWIP_UDP || LWIP_RAW - { - u16_t datagram_len = 0; - err_t err; - err = lwip_recvfrom_udp_raw(sock, flags, message, &datagram_len, s); - if (err != ERR_OK) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvmsg[UDP/RAW](%d): buf == NULL, error is \"%s\"!\n", - s, lwip_strerr(err))); - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return -1; - } - if (datagram_len > buflen) { - message->msg_flags |= MSG_TRUNC; - } - - sock_set_errno(sock, 0); - done_socket(sock); - return (int)datagram_len; - } -#else /* LWIP_UDP || LWIP_RAW */ - sock_set_errno(sock, err_to_errno(ERR_ARG)); - done_socket(sock); - return -1; -#endif /* LWIP_UDP || LWIP_RAW */ -} - -ssize_t -lwip_send(int s, const void *data, size_t size, int flags) -{ - struct lwip_sock *sock; - err_t err; - u8_t write_flags; - size_t written; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d, data=%p, size=%"SZT_F", flags=0x%x)\n", - s, data, size, flags)); - - sock = get_socket(s); - if (!sock) { - return -1; - } - - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { -#if (LWIP_UDP || LWIP_RAW) - done_socket(sock); - return lwip_sendto(s, data, size, flags, NULL, 0); -#else /* (LWIP_UDP || LWIP_RAW) */ - sock_set_errno(sock, err_to_errno(ERR_ARG)); - done_socket(sock); - return -1; -#endif /* (LWIP_UDP || LWIP_RAW) */ - } - - write_flags = (u8_t)(NETCONN_COPY | - ((flags & MSG_MORE) ? NETCONN_MORE : 0) | - ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0)); - written = 0; - err = netconn_write_partly(sock->conn, data, size, write_flags, &written); - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) err=%d written=%"SZT_F"\n", s, err, written)); - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - /* casting 'written' to ssize_t is OK here since the netconn API limits it to SSIZE_MAX */ - return (err == ERR_OK ? (ssize_t)written : -1); -} - -ssize_t -lwip_sendmsg(int s, const struct msghdr *msg, int flags) -{ - struct lwip_sock *sock; -#if LWIP_TCP - u8_t write_flags; - size_t written; -#endif - err_t err = ERR_OK; - - sock = get_socket(s); - if (!sock) { - return -1; - } - - LWIP_ERROR("lwip_sendmsg: invalid msghdr", msg != NULL, - sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); - LWIP_ERROR("lwip_sendmsg: invalid msghdr iov", msg->msg_iov != NULL, - sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); - LWIP_ERROR("lwip_sendmsg: maximum iovs exceeded", (msg->msg_iovlen > 0) && (msg->msg_iovlen <= IOV_MAX), - sock_set_errno(sock, EMSGSIZE); done_socket(sock); return -1;); - LWIP_ERROR("lwip_sendmsg: unsupported flags", (flags & ~(MSG_DONTWAIT | MSG_MORE)) == 0, - sock_set_errno(sock, EOPNOTSUPP); done_socket(sock); return -1;); - - LWIP_UNUSED_ARG(msg->msg_control); - LWIP_UNUSED_ARG(msg->msg_controllen); - LWIP_UNUSED_ARG(msg->msg_flags); - - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { -#if LWIP_TCP - write_flags = (u8_t)(NETCONN_COPY | - ((flags & MSG_MORE) ? NETCONN_MORE : 0) | - ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0)); - - written = 0; - err = netconn_write_vectors_partly(sock->conn, (struct netvector *)msg->msg_iov, (u16_t)msg->msg_iovlen, write_flags, &written); - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - /* casting 'written' to ssize_t is OK here since the netconn API limits it to SSIZE_MAX */ - return (err == ERR_OK ? (ssize_t)written : -1); -#else /* LWIP_TCP */ - sock_set_errno(sock, err_to_errno(ERR_ARG)); - done_socket(sock); - return -1; -#endif /* LWIP_TCP */ - } - /* else, UDP and RAW NETCONNs */ -#if LWIP_UDP || LWIP_RAW - { - struct netbuf chain_buf; - int i; - ssize_t size = 0; - - LWIP_UNUSED_ARG(flags); - LWIP_ERROR("lwip_sendmsg: invalid msghdr name", (((msg->msg_name == NULL) && (msg->msg_namelen == 0)) || - IS_SOCK_ADDR_LEN_VALID(msg->msg_namelen)), - sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); - - /* initialize chain buffer with destination */ - memset(&chain_buf, 0, sizeof(struct netbuf)); - if (msg->msg_name) { - u16_t remote_port; - SOCKADDR_TO_IPADDR_PORT((const struct sockaddr *)msg->msg_name, &chain_buf.addr, remote_port); - netbuf_fromport(&chain_buf) = remote_port; - } -#if LWIP_NETIF_TX_SINGLE_PBUF - for (i = 0; i < msg->msg_iovlen; i++) { - size += msg->msg_iov[i].iov_len; - if ((msg->msg_iov[i].iov_len > INT_MAX) || (size < (int)msg->msg_iov[i].iov_len)) { - /* overflow */ - goto sendmsg_emsgsize; - } - } - if (size > 0xFFFF) { - /* overflow */ - goto sendmsg_emsgsize; - } - /* Allocate a new netbuf and copy the data into it. */ - if (netbuf_alloc(&chain_buf, (u16_t)size) == NULL) { - err = ERR_MEM; - } else { - /* flatten the IO vectors */ - size_t offset = 0; - for (i = 0; i < msg->msg_iovlen; i++) { - MEMCPY(&((u8_t *)chain_buf.p->payload)[offset], msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len); - offset += msg->msg_iov[i].iov_len; - } -#if LWIP_CHECKSUM_ON_COPY - { - /* This can be improved by using LWIP_CHKSUM_COPY() and aggregating the checksum for each IO vector */ - u16_t chksum = ~inet_chksum_pbuf(chain_buf.p); - netbuf_set_chksum(&chain_buf, chksum); - } -#endif /* LWIP_CHECKSUM_ON_COPY */ - err = ERR_OK; - } -#else /* LWIP_NETIF_TX_SINGLE_PBUF */ - /* create a chained netbuf from the IO vectors. NOTE: we assemble a pbuf chain - manually to avoid having to allocate, chain, and delete a netbuf for each iov */ - for (i = 0; i < msg->msg_iovlen; i++) { - struct pbuf *p; - if (msg->msg_iov[i].iov_len > 0xFFFF) { - /* overflow */ - goto sendmsg_emsgsize; - } - p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF); - if (p == NULL) { - err = ERR_MEM; /* let netbuf_delete() cleanup chain_buf */ - break; - } - p->payload = msg->msg_iov[i].iov_base; - p->len = p->tot_len = (u16_t)msg->msg_iov[i].iov_len; - /* netbuf empty, add new pbuf */ - if (chain_buf.p == NULL) { - chain_buf.p = chain_buf.ptr = p; - /* add pbuf to existing pbuf chain */ - } else { - if (chain_buf.p->tot_len + p->len > 0xffff) { - /* overflow */ - pbuf_free(p); - goto sendmsg_emsgsize; - } - pbuf_cat(chain_buf.p, p); - } - } - /* save size of total chain */ - if (err == ERR_OK) { - size = netbuf_len(&chain_buf); - } -#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ - - if (err == ERR_OK) { -#if LWIP_IPV4 && LWIP_IPV6 - /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ - if (IP_IS_V6_VAL(chain_buf.addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&chain_buf.addr))) { - unmap_ipv4_mapped_ipv6(ip_2_ip4(&chain_buf.addr), ip_2_ip6(&chain_buf.addr)); - IP_SET_TYPE_VAL(chain_buf.addr, IPADDR_TYPE_V4); - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - /* send the data */ - err = netconn_send(sock->conn, &chain_buf); - } - - /* deallocated the buffer */ - netbuf_free(&chain_buf); - - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return (err == ERR_OK ? size : -1); -sendmsg_emsgsize: - sock_set_errno(sock, EMSGSIZE); - netbuf_free(&chain_buf); - done_socket(sock); - return -1; - } -#else /* LWIP_UDP || LWIP_RAW */ - sock_set_errno(sock, err_to_errno(ERR_ARG)); - done_socket(sock); - return -1; -#endif /* LWIP_UDP || LWIP_RAW */ -} - -ssize_t -lwip_sendto(int s, const void *data, size_t size, int flags, - const struct sockaddr *to, socklen_t tolen) -{ - struct lwip_sock *sock; - err_t err; - u16_t short_size; - u16_t remote_port; - struct netbuf buf; - - sock = get_socket(s); - if (!sock) { - return -1; - } - - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { -#if LWIP_TCP - done_socket(sock); - return lwip_send(s, data, size, flags); -#else /* LWIP_TCP */ - LWIP_UNUSED_ARG(flags); - sock_set_errno(sock, err_to_errno(ERR_ARG)); - done_socket(sock); - return -1; -#endif /* LWIP_TCP */ - } - - if (size > LWIP_MIN(0xFFFF, SSIZE_MAX)) { - /* cannot fit into one datagram (at least for us) */ - sock_set_errno(sock, EMSGSIZE); - done_socket(sock); - return -1; - } - short_size = (u16_t)size; - LWIP_ERROR("lwip_sendto: invalid address", (((to == NULL) && (tolen == 0)) || - (IS_SOCK_ADDR_LEN_VALID(tolen) && - ((to != NULL) && (IS_SOCK_ADDR_TYPE_VALID(to) && IS_SOCK_ADDR_ALIGNED(to))))), - sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); - LWIP_UNUSED_ARG(tolen); - - /* initialize a buffer */ - buf.p = buf.ptr = NULL; -#if LWIP_CHECKSUM_ON_COPY - buf.flags = 0; -#endif /* LWIP_CHECKSUM_ON_COPY */ - if (to) { - SOCKADDR_TO_IPADDR_PORT(to, &buf.addr, remote_port); - } else { - remote_port = 0; - ip_addr_set_any(NETCONNTYPE_ISIPV6(netconn_type(sock->conn)), &buf.addr); - } - netbuf_fromport(&buf) = remote_port; - - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, short_size=%"U16_F", flags=0x%x to=", - s, data, short_size, flags)); - ip_addr_debug_print_val(SOCKETS_DEBUG, buf.addr); - LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F"\n", remote_port)); - - /* make the buffer point to the data that should be sent */ -#if LWIP_NETIF_TX_SINGLE_PBUF - /* Allocate a new netbuf and copy the data into it. */ - if (netbuf_alloc(&buf, short_size) == NULL) { - err = ERR_MEM; - } else { -#if LWIP_CHECKSUM_ON_COPY - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_RAW) { - u16_t chksum = LWIP_CHKSUM_COPY(buf.p->payload, data, short_size); - netbuf_set_chksum(&buf, chksum); - } else -#endif /* LWIP_CHECKSUM_ON_COPY */ - { - MEMCPY(buf.p->payload, data, short_size); - } - err = ERR_OK; - } -#else /* LWIP_NETIF_TX_SINGLE_PBUF */ - err = netbuf_ref(&buf, data, short_size); -#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ - if (err == ERR_OK) { -#if LWIP_IPV4 && LWIP_IPV6 - /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ - if (IP_IS_V6_VAL(buf.addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&buf.addr))) { - unmap_ipv4_mapped_ipv6(ip_2_ip4(&buf.addr), ip_2_ip6(&buf.addr)); - IP_SET_TYPE_VAL(buf.addr, IPADDR_TYPE_V4); - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - /* send the data */ - err = netconn_send(sock->conn, &buf); - } - - /* deallocated the buffer */ - netbuf_free(&buf); - - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return (err == ERR_OK ? short_size : -1); -} - -int -lwip_socket(int domain, int type, int protocol) -{ - struct netconn *conn; - int i; - - LWIP_UNUSED_ARG(domain); /* @todo: check this */ - - /* create a netconn */ - switch (type) { - case SOCK_RAW: - conn = netconn_new_with_proto_and_callback(DOMAIN_TO_NETCONN_TYPE(domain, NETCONN_RAW), - (u8_t)protocol, DEFAULT_SOCKET_EVENTCB); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_RAW, %d) = ", - domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); - break; - case SOCK_DGRAM: - conn = netconn_new_with_callback(DOMAIN_TO_NETCONN_TYPE(domain, - ((protocol == IPPROTO_UDPLITE) ? NETCONN_UDPLITE : NETCONN_UDP)), - DEFAULT_SOCKET_EVENTCB); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_DGRAM, %d) = ", - domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); -#if LWIP_NETBUF_RECVINFO - if (conn) { - /* netconn layer enables pktinfo by default, sockets default to off */ - conn->flags &= ~NETCONN_FLAG_PKTINFO; - } -#endif /* LWIP_NETBUF_RECVINFO */ - break; - case SOCK_STREAM: - conn = netconn_new_with_callback(DOMAIN_TO_NETCONN_TYPE(domain, NETCONN_TCP), DEFAULT_SOCKET_EVENTCB); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_STREAM, %d) = ", - domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%d, %d/UNKNOWN, %d) = -1\n", - domain, type, protocol)); - set_errno(EINVAL); - return -1; - } - - if (!conn) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("-1 / ENOBUFS (could not create netconn)\n")); - set_errno(ENOBUFS); - return -1; - } - - i = alloc_socket(conn, 0); - - if (i == -1) { - netconn_delete(conn); - set_errno(ENFILE); - return -1; - } - conn->socket = i; - done_socket(&sockets[i - LWIP_SOCKET_OFFSET]); - LWIP_DEBUGF(SOCKETS_DEBUG, ("%d\n", i)); - set_errno(0); - return i; -} - -ssize_t -lwip_write(int s, const void *data, size_t size) -{ - return lwip_send(s, data, size, 0); -} - -ssize_t -lwip_writev(int s, const struct iovec *iov, int iovcnt) -{ - struct msghdr msg; - - msg.msg_name = NULL; - msg.msg_namelen = 0; - /* Hack: we have to cast via number to cast from 'const' pointer to non-const. - Blame the opengroup standard for this inconsistency. */ - msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); - msg.msg_iovlen = iovcnt; - msg.msg_control = NULL; - msg.msg_controllen = 0; - msg.msg_flags = 0; - return lwip_sendmsg(s, &msg, 0); -} - -#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL -/* Add select_cb to select_cb_list. */ -static void -lwip_link_select_cb(struct lwip_select_cb *select_cb) -{ - LWIP_SOCKET_SELECT_DECL_PROTECT(lev); - - /* Protect the select_cb_list */ - LWIP_SOCKET_SELECT_PROTECT(lev); - - /* Put this select_cb on top of list */ - select_cb->next = select_cb_list; - if (select_cb_list != NULL) { - select_cb_list->prev = select_cb; - } - select_cb_list = select_cb; -#if !LWIP_TCPIP_CORE_LOCKING - /* Increasing this counter tells select_check_waiters that the list has changed. */ - select_cb_ctr++; -#endif - - /* Now we can safely unprotect */ - LWIP_SOCKET_SELECT_UNPROTECT(lev); -} - -/* Remove select_cb from select_cb_list. */ -static void -lwip_unlink_select_cb(struct lwip_select_cb *select_cb) -{ - LWIP_SOCKET_SELECT_DECL_PROTECT(lev); - - /* Take us off the list */ - LWIP_SOCKET_SELECT_PROTECT(lev); - if (select_cb->next != NULL) { - select_cb->next->prev = select_cb->prev; - } - if (select_cb_list == select_cb) { - LWIP_ASSERT("select_cb->prev == NULL", select_cb->prev == NULL); - select_cb_list = select_cb->next; - } else { - LWIP_ASSERT("select_cb->prev != NULL", select_cb->prev != NULL); - select_cb->prev->next = select_cb->next; - } -#if !LWIP_TCPIP_CORE_LOCKING - /* Increasing this counter tells select_check_waiters that the list has changed. */ - select_cb_ctr++; -#endif - LWIP_SOCKET_SELECT_UNPROTECT(lev); -} -#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ - -#if LWIP_SOCKET_SELECT -/** - * Go through the readset and writeset lists and see which socket of the sockets - * set in the sets has events. On return, readset, writeset and exceptset have - * the sockets enabled that had events. - * - * @param maxfdp1 the highest socket index in the sets - * @param readset_in set of sockets to check for read events - * @param writeset_in set of sockets to check for write events - * @param exceptset_in set of sockets to check for error events - * @param readset_out set of sockets that had read events - * @param writeset_out set of sockets that had write events - * @param exceptset_out set os sockets that had error events - * @return number of sockets that had events (read/write/exception) (>= 0) - */ -static int -lwip_selscan(int maxfdp1, fd_set *readset_in, fd_set *writeset_in, fd_set *exceptset_in, - fd_set *readset_out, fd_set *writeset_out, fd_set *exceptset_out) -{ - int i, nready = 0; - fd_set lreadset, lwriteset, lexceptset; - struct lwip_sock *sock; - SYS_ARCH_DECL_PROTECT(lev); - - FD_ZERO(&lreadset); - FD_ZERO(&lwriteset); - FD_ZERO(&lexceptset); - - /* Go through each socket in each list to count number of sockets which - currently match */ - for (i = LWIP_SOCKET_OFFSET; i < maxfdp1; i++) { - /* if this FD is not in the set, continue */ - if (!(readset_in && FD_ISSET(i, readset_in)) && - !(writeset_in && FD_ISSET(i, writeset_in)) && - !(exceptset_in && FD_ISSET(i, exceptset_in))) { - continue; - } - /* First get the socket's status (protected)... */ - SYS_ARCH_PROTECT(lev); - sock = tryget_socket_unconn_locked(i); - if (sock != NULL) { - void *lastdata = sock->lastdata.pbuf; - s16_t rcvevent = sock->rcvevent; - u16_t sendevent = sock->sendevent; - u16_t errevent = sock->errevent; - SYS_ARCH_UNPROTECT(lev); - - /* ... then examine it: */ - /* See if netconn of this socket is ready for read */ - if (readset_in && FD_ISSET(i, readset_in) && ((lastdata != NULL) || (rcvevent > 0))) { - FD_SET(i, &lreadset); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for reading\n", i)); - nready++; - } - /* See if netconn of this socket is ready for write */ - if (writeset_in && FD_ISSET(i, writeset_in) && (sendevent != 0)) { - FD_SET(i, &lwriteset); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for writing\n", i)); - nready++; - } - /* See if netconn of this socket had an error */ - if (exceptset_in && FD_ISSET(i, exceptset_in) && (errevent != 0)) { - FD_SET(i, &lexceptset); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for exception\n", i)); - nready++; - } - done_socket(sock); - } else { - SYS_ARCH_UNPROTECT(lev); - /* no a valid open socket */ - return -1; - } - } - /* copy local sets to the ones provided as arguments */ - *readset_out = lreadset; - *writeset_out = lwriteset; - *exceptset_out = lexceptset; - - LWIP_ASSERT("nready >= 0", nready >= 0); - return nready; -} - -#if LWIP_NETCONN_FULLDUPLEX -/* Mark all of the set sockets in one of the three fdsets passed to select as used. - * All sockets are marked (and later unmarked), whether they are open or not. - * This is OK as lwip_selscan aborts select when non-open sockets are found. - */ -static void -lwip_select_inc_sockets_used_set(int maxfdp, fd_set *fdset, fd_set *used_sockets) -{ - SYS_ARCH_DECL_PROTECT(lev); - if (fdset) { - int i; - for (i = LWIP_SOCKET_OFFSET; i < maxfdp; i++) { - /* if this FD is in the set, lock it (unless already done) */ - if (FD_ISSET(i, fdset) && !FD_ISSET(i, used_sockets)) { - struct lwip_sock *sock; - SYS_ARCH_PROTECT(lev); - sock = tryget_socket_unconn_locked(i); - if (sock != NULL) { - /* leave the socket used until released by lwip_select_dec_sockets_used */ - FD_SET(i, used_sockets); - } - SYS_ARCH_UNPROTECT(lev); - } - } - } -} - -/* Mark all sockets passed to select as used to prevent them from being freed - * from other threads while select is running. - * Marked sockets are added to 'used_sockets' to mark them only once an be able - * to unmark them correctly. - */ -static void -lwip_select_inc_sockets_used(int maxfdp, fd_set *fdset1, fd_set *fdset2, fd_set *fdset3, fd_set *used_sockets) -{ - FD_ZERO(used_sockets); - lwip_select_inc_sockets_used_set(maxfdp, fdset1, used_sockets); - lwip_select_inc_sockets_used_set(maxfdp, fdset2, used_sockets); - lwip_select_inc_sockets_used_set(maxfdp, fdset3, used_sockets); -} - -/* Let go all sockets that were marked as used when starting select */ -static void -lwip_select_dec_sockets_used(int maxfdp, fd_set *used_sockets) -{ - int i; - for (i = LWIP_SOCKET_OFFSET; i < maxfdp; i++) { - /* if this FD is not in the set, continue */ - if (FD_ISSET(i, used_sockets)) { - struct lwip_sock *sock = tryget_socket_unconn_nouse(i); - LWIP_ASSERT("socket gone at the end of select", sock != NULL); - if (sock != NULL) { - done_socket(sock); - } - } - } -} -#else /* LWIP_NETCONN_FULLDUPLEX */ -#define lwip_select_inc_sockets_used(maxfdp1, readset, writeset, exceptset, used_sockets) -#define lwip_select_dec_sockets_used(maxfdp1, used_sockets) -#endif /* LWIP_NETCONN_FULLDUPLEX */ - -int -lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, - struct timeval *timeout) -{ - u32_t waitres = 0; - int nready; - fd_set lreadset, lwriteset, lexceptset; - u32_t msectimeout; - int i; - int maxfdp2; -#if LWIP_NETCONN_SEM_PER_THREAD - int waited = 0; -#endif -#if LWIP_NETCONN_FULLDUPLEX - fd_set used_sockets; -#endif - SYS_ARCH_DECL_PROTECT(lev); - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select(%d, %p, %p, %p, tvsec=%"S32_F" tvusec=%"S32_F")\n", - maxfdp1, (void *)readset, (void *) writeset, (void *) exceptset, - timeout ? (s32_t)timeout->tv_sec : (s32_t) - 1, - timeout ? (s32_t)timeout->tv_usec : (s32_t) - 1)); - - if ((maxfdp1 < 0) || (maxfdp1 > LWIP_SELECT_MAXNFDS)) { - set_errno(EINVAL); - return -1; - } - - lwip_select_inc_sockets_used(maxfdp1, readset, writeset, exceptset, &used_sockets); - - /* Go through each socket in each list to count number of sockets which - currently match */ - nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset); - - if (nready < 0) { - /* one of the sockets in one of the fd_sets was invalid */ - set_errno(EBADF); - lwip_select_dec_sockets_used(maxfdp1, &used_sockets); - return -1; - } else if (nready > 0) { - /* one or more sockets are set, no need to wait */ - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready)); - } else { - /* If we don't have any current events, then suspend if we are supposed to */ - if (timeout && timeout->tv_sec == 0 && timeout->tv_usec == 0) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: no timeout, returning 0\n")); - /* This is OK as the local fdsets are empty and nready is zero, - or we would have returned earlier. */ - } else { - /* None ready: add our semaphore to list: - We don't actually need any dynamic memory. Our entry on the - list is only valid while we are in this function, so it's ok - to use local variables (unless we're running in MPU compatible - mode). */ - API_SELECT_CB_VAR_DECLARE(select_cb); - API_SELECT_CB_VAR_ALLOC(select_cb, set_errno(ENOMEM); lwip_select_dec_sockets_used(maxfdp1, &used_sockets); return -1); - memset(&API_SELECT_CB_VAR_REF(select_cb), 0, sizeof(struct lwip_select_cb)); - - API_SELECT_CB_VAR_REF(select_cb).readset = readset; - API_SELECT_CB_VAR_REF(select_cb).writeset = writeset; - API_SELECT_CB_VAR_REF(select_cb).exceptset = exceptset; -#if LWIP_NETCONN_SEM_PER_THREAD - API_SELECT_CB_VAR_REF(select_cb).sem = LWIP_NETCONN_THREAD_SEM_GET(); -#else /* LWIP_NETCONN_SEM_PER_THREAD */ - if (sys_sem_new(&API_SELECT_CB_VAR_REF(select_cb).sem, 0) != ERR_OK) { - /* failed to create semaphore */ - set_errno(ENOMEM); - lwip_select_dec_sockets_used(maxfdp1, &used_sockets); - API_SELECT_CB_VAR_FREE(select_cb); - return -1; - } -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - - lwip_link_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); - - /* Increase select_waiting for each socket we are interested in */ - maxfdp2 = maxfdp1; - for (i = LWIP_SOCKET_OFFSET; i < maxfdp1; i++) { - if ((readset && FD_ISSET(i, readset)) || - (writeset && FD_ISSET(i, writeset)) || - (exceptset && FD_ISSET(i, exceptset))) { - struct lwip_sock *sock; - SYS_ARCH_PROTECT(lev); - sock = tryget_socket_unconn_locked(i); - if (sock != NULL) { - sock->select_waiting++; - if (sock->select_waiting == 0) { - /* overflow - too many threads waiting */ - sock->select_waiting--; - nready = -1; - maxfdp2 = i; - SYS_ARCH_UNPROTECT(lev); - done_socket(sock); - set_errno(EBUSY); - break; - } - SYS_ARCH_UNPROTECT(lev); - done_socket(sock); - } else { - /* Not a valid socket */ - nready = -1; - maxfdp2 = i; - SYS_ARCH_UNPROTECT(lev); - set_errno(EBADF); - break; - } - } - } - - if (nready >= 0) { - /* Call lwip_selscan again: there could have been events between - the last scan (without us on the list) and putting us on the list! */ - nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset); - if (!nready) { - /* Still none ready, just wait to be woken */ - if (timeout == 0) { - /* Wait forever */ - msectimeout = 0; - } else { - long msecs_long = ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500) / 1000)); - if (msecs_long <= 0) { - /* Wait 1ms at least (0 means wait forever) */ - msectimeout = 1; - } else { - msectimeout = (u32_t)msecs_long; - } - } - - waitres = sys_arch_sem_wait(SELECT_SEM_PTR(API_SELECT_CB_VAR_REF(select_cb).sem), msectimeout); -#if LWIP_NETCONN_SEM_PER_THREAD - waited = 1; -#endif - } - } - - /* Decrease select_waiting for each socket we are interested in */ - for (i = LWIP_SOCKET_OFFSET; i < maxfdp2; i++) { - if ((readset && FD_ISSET(i, readset)) || - (writeset && FD_ISSET(i, writeset)) || - (exceptset && FD_ISSET(i, exceptset))) { - struct lwip_sock *sock; - SYS_ARCH_PROTECT(lev); - sock = tryget_socket_unconn_locked(i); - if (sock != NULL) { - /* for now, handle select_waiting==0... */ - LWIP_ASSERT("sock->select_waiting > 0", sock->select_waiting > 0); - if (sock->select_waiting > 0) { - sock->select_waiting--; - } - SYS_ARCH_UNPROTECT(lev); - done_socket(sock); - } else { - SYS_ARCH_UNPROTECT(lev); - /* Not a valid socket */ - nready = -1; - set_errno(EBADF); - } - } - } - - lwip_unlink_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); - -#if LWIP_NETCONN_SEM_PER_THREAD - if (API_SELECT_CB_VAR_REF(select_cb).sem_signalled && (!waited || (waitres == SYS_ARCH_TIMEOUT))) { - /* don't leave the thread-local semaphore signalled */ - sys_arch_sem_wait(API_SELECT_CB_VAR_REF(select_cb).sem, 1); - } -#else /* LWIP_NETCONN_SEM_PER_THREAD */ - sys_sem_free(&API_SELECT_CB_VAR_REF(select_cb).sem); -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - API_SELECT_CB_VAR_FREE(select_cb); - - if (nready < 0) { - /* This happens when a socket got closed while waiting */ - lwip_select_dec_sockets_used(maxfdp1, &used_sockets); - return -1; - } - - if (waitres == SYS_ARCH_TIMEOUT) { - /* Timeout */ - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: timeout expired\n")); - /* This is OK as the local fdsets are empty and nready is zero, - or we would have returned earlier. */ - } else { - /* See what's set now after waiting */ - nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready)); - } - } - } - - lwip_select_dec_sockets_used(maxfdp1, &used_sockets); - set_errno(0); - if (readset) { - *readset = lreadset; - } - if (writeset) { - *writeset = lwriteset; - } - if (exceptset) { - *exceptset = lexceptset; - } - return nready; -} -#endif /* LWIP_SOCKET_SELECT */ - -#if LWIP_SOCKET_POLL -/** Options for the lwip_pollscan function. */ -enum lwip_pollscan_opts -{ - /** Clear revents in each struct pollfd. */ - LWIP_POLLSCAN_CLEAR = 1, - - /** Increment select_waiting in each struct lwip_sock. */ - LWIP_POLLSCAN_INC_WAIT = 2, - - /** Decrement select_waiting in each struct lwip_sock. */ - LWIP_POLLSCAN_DEC_WAIT = 4 -}; - -/** - * Update revents in each struct pollfd. - * Optionally update select_waiting in struct lwip_sock. - * - * @param fds array of structures to update - * @param nfds number of structures in fds - * @param opts what to update and how - * @return number of structures that have revents != 0 - */ -static int -lwip_pollscan(struct pollfd *fds, nfds_t nfds, enum lwip_pollscan_opts opts) -{ - int nready = 0; - nfds_t fdi; - struct lwip_sock *sock; - SYS_ARCH_DECL_PROTECT(lev); - - /* Go through each struct pollfd in the array. */ - for (fdi = 0; fdi < nfds; fdi++) { - if ((opts & LWIP_POLLSCAN_CLEAR) != 0) { - fds[fdi].revents = 0; - } - - /* Negative fd means the caller wants us to ignore this struct. - POLLNVAL means we already detected that the fd is invalid; - if another thread has since opened a new socket with that fd, - we must not use that socket. */ - if (fds[fdi].fd >= 0 && (fds[fdi].revents & POLLNVAL) == 0) { - /* First get the socket's status (protected)... */ - SYS_ARCH_PROTECT(lev); - sock = tryget_socket_unconn_locked(fds[fdi].fd); - if (sock != NULL) { - void* lastdata = sock->lastdata.pbuf; - s16_t rcvevent = sock->rcvevent; - u16_t sendevent = sock->sendevent; - u16_t errevent = sock->errevent; - - if ((opts & LWIP_POLLSCAN_INC_WAIT) != 0) { - sock->select_waiting++; - if (sock->select_waiting == 0) { - /* overflow - too many threads waiting */ - sock->select_waiting--; - nready = -1; - SYS_ARCH_UNPROTECT(lev); - done_socket(sock); - break; - } - } else if ((opts & LWIP_POLLSCAN_DEC_WAIT) != 0) { - /* for now, handle select_waiting==0... */ - LWIP_ASSERT("sock->select_waiting > 0", sock->select_waiting > 0); - if (sock->select_waiting > 0) { - sock->select_waiting--; - } - } - SYS_ARCH_UNPROTECT(lev); - done_socket(sock); - - /* ... then examine it: */ - /* See if netconn of this socket is ready for read */ - if ((fds[fdi].events & POLLIN) != 0 && ((lastdata != NULL) || (rcvevent > 0))) { - fds[fdi].revents |= POLLIN; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_pollscan: fd=%d ready for reading\n", fds[fdi].fd)); - } - /* See if netconn of this socket is ready for write */ - if ((fds[fdi].events & POLLOUT) != 0 && (sendevent != 0)) { - fds[fdi].revents |= POLLOUT; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_pollscan: fd=%d ready for writing\n", fds[fdi].fd)); - } - /* See if netconn of this socket had an error */ - if (errevent != 0) { - /* POLLERR is output only. */ - fds[fdi].revents |= POLLERR; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_pollscan: fd=%d ready for exception\n", fds[fdi].fd)); - } - } else { - /* Not a valid socket */ - SYS_ARCH_UNPROTECT(lev); - /* POLLNVAL is output only. */ - fds[fdi].revents |= POLLNVAL; - return -1; - } - } - - /* Will return the number of structures that have events, - not the number of events. */ - if (fds[fdi].revents != 0) { - nready++; - } - } - - LWIP_ASSERT("nready >= 0", nready >= 0); - return nready; -} - -#if LWIP_NETCONN_FULLDUPLEX -/* Mark all sockets as used. - * - * All sockets are marked (and later unmarked), whether they are open or not. - * This is OK as lwip_pollscan aborts select when non-open sockets are found. - */ -static void -lwip_poll_inc_sockets_used(struct pollfd *fds, nfds_t nfds) -{ - nfds_t fdi; - - if(fds) { - /* Go through each struct pollfd in the array. */ - for (fdi = 0; fdi < nfds; fdi++) { - /* Increase the reference counter */ - tryget_socket_unconn(fds[fdi].fd); - } - } -} - -/* Let go all sockets that were marked as used when starting poll */ -static void -lwip_poll_dec_sockets_used(struct pollfd *fds, nfds_t nfds) -{ - nfds_t fdi; - - if(fds) { - /* Go through each struct pollfd in the array. */ - for (fdi = 0; fdi < nfds; fdi++) { - struct lwip_sock *sock = tryget_socket_unconn_nouse(fds[fdi].fd); - if (sock != NULL) { - done_socket(sock); - } - } - } -} -#else /* LWIP_NETCONN_FULLDUPLEX */ -#define lwip_poll_inc_sockets_used(fds, nfds) -#define lwip_poll_dec_sockets_used(fds, nfds) -#endif /* LWIP_NETCONN_FULLDUPLEX */ - -int -lwip_poll(struct pollfd *fds, nfds_t nfds, int timeout) -{ - u32_t waitres = 0; - int nready; - u32_t msectimeout; -#if LWIP_NETCONN_SEM_PER_THREAD - int waited = 0; -#endif - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll(%p, %d, %d)\n", - (void*)fds, (int)nfds, timeout)); - LWIP_ERROR("lwip_poll: invalid fds", ((fds != NULL && nfds > 0) || (fds == NULL && nfds == 0)), - set_errno(EINVAL); return -1;); - - lwip_poll_inc_sockets_used(fds, nfds); - - /* Go through each struct pollfd to count number of structures - which currently match */ - nready = lwip_pollscan(fds, nfds, LWIP_POLLSCAN_CLEAR); - - if (nready < 0) { - lwip_poll_dec_sockets_used(fds, nfds); - return -1; - } - - /* If we don't have any current events, then suspend if we are supposed to */ - if (!nready) { - API_SELECT_CB_VAR_DECLARE(select_cb); - - if (timeout == 0) { - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll: no timeout, returning 0\n")); - goto return_success; - } - API_SELECT_CB_VAR_ALLOC(select_cb, set_errno(EAGAIN); lwip_poll_dec_sockets_used(fds, nfds); return -1); - memset(&API_SELECT_CB_VAR_REF(select_cb), 0, sizeof(struct lwip_select_cb)); - - /* None ready: add our semaphore to list: - We don't actually need any dynamic memory. Our entry on the - list is only valid while we are in this function, so it's ok - to use local variables. */ - - API_SELECT_CB_VAR_REF(select_cb).poll_fds = fds; - API_SELECT_CB_VAR_REF(select_cb).poll_nfds = nfds; -#if LWIP_NETCONN_SEM_PER_THREAD - API_SELECT_CB_VAR_REF(select_cb).sem = LWIP_NETCONN_THREAD_SEM_GET(); -#else /* LWIP_NETCONN_SEM_PER_THREAD */ - if (sys_sem_new(&API_SELECT_CB_VAR_REF(select_cb).sem, 0) != ERR_OK) { - /* failed to create semaphore */ - set_errno(EAGAIN); - lwip_poll_dec_sockets_used(fds, nfds); - API_SELECT_CB_VAR_FREE(select_cb); - return -1; - } -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - - lwip_link_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); - - /* Increase select_waiting for each socket we are interested in. - Also, check for events again: there could have been events between - the last scan (without us on the list) and putting us on the list! */ - nready = lwip_pollscan(fds, nfds, LWIP_POLLSCAN_INC_WAIT); - - if (!nready) { - /* Still none ready, just wait to be woken */ - if (timeout < 0) { - /* Wait forever */ - msectimeout = 0; - } else { - /* timeout == 0 would have been handled earlier. */ - LWIP_ASSERT("timeout > 0", timeout > 0); - msectimeout = timeout; - } - waitres = sys_arch_sem_wait(SELECT_SEM_PTR(API_SELECT_CB_VAR_REF(select_cb).sem), msectimeout); -#if LWIP_NETCONN_SEM_PER_THREAD - waited = 1; -#endif - } - - /* Decrease select_waiting for each socket we are interested in, - and check which events occurred while we waited. */ - nready = lwip_pollscan(fds, nfds, LWIP_POLLSCAN_DEC_WAIT); - - lwip_unlink_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); - -#if LWIP_NETCONN_SEM_PER_THREAD - if (select_cb.sem_signalled && (!waited || (waitres == SYS_ARCH_TIMEOUT))) { - /* don't leave the thread-local semaphore signalled */ - sys_arch_sem_wait(API_SELECT_CB_VAR_REF(select_cb).sem, 1); - } -#else /* LWIP_NETCONN_SEM_PER_THREAD */ - sys_sem_free(&API_SELECT_CB_VAR_REF(select_cb).sem); -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - API_SELECT_CB_VAR_FREE(select_cb); - - if (nready < 0) { - /* This happens when a socket got closed while waiting */ - lwip_poll_dec_sockets_used(fds, nfds); - return -1; - } - - if (waitres == SYS_ARCH_TIMEOUT) { - /* Timeout */ - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll: timeout expired\n")); - goto return_success; - } - } - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll: nready=%d\n", nready)); -return_success: - lwip_poll_dec_sockets_used(fds, nfds); - set_errno(0); - return nready; -} - -/** - * Check whether event_callback should wake up a thread waiting in - * lwip_poll. - */ -static int -lwip_poll_should_wake(const struct lwip_select_cb *scb, int fd, int has_recvevent, int has_sendevent, int has_errevent) -{ - nfds_t fdi; - for (fdi = 0; fdi < scb->poll_nfds; fdi++) { - const struct pollfd *pollfd = &scb->poll_fds[fdi]; - if (pollfd->fd == fd) { - /* Do not update pollfd->revents right here; - that would be a data race because lwip_pollscan - accesses revents without protecting. */ - if (has_recvevent && (pollfd->events & POLLIN) != 0) { - return 1; - } - if (has_sendevent && (pollfd->events & POLLOUT) != 0) { - return 1; - } - if (has_errevent) { - /* POLLERR is output only. */ - return 1; - } - } - } - return 0; -} -#endif /* LWIP_SOCKET_POLL */ - -#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL -/** - * Callback registered in the netconn layer for each socket-netconn. - * Processes recvevent (data available) and wakes up tasks waiting for select. - * - * @note for LWIP_TCPIP_CORE_LOCKING any caller of this function - * must have the core lock held when signaling the following events - * as they might cause select_list_cb to be checked: - * NETCONN_EVT_RCVPLUS - * NETCONN_EVT_SENDPLUS - * NETCONN_EVT_ERROR - * This requirement will be asserted in select_check_waiters() - */ -static void -event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len) -{ - int s, check_waiters; - struct lwip_sock *sock; - SYS_ARCH_DECL_PROTECT(lev); - - LWIP_UNUSED_ARG(len); - - /* Get socket */ - if (conn) { - s = conn->socket; - if (s < 0) { - /* Data comes in right away after an accept, even though - * the server task might not have created a new socket yet. - * Just count down (or up) if that's the case and we - * will use the data later. Note that only receive events - * can happen before the new socket is set up. */ - SYS_ARCH_PROTECT(lev); - if (conn->socket < 0) { - if (evt == NETCONN_EVT_RCVPLUS) { - /* conn->socket is -1 on initialization - lwip_accept adjusts sock->recvevent if conn->socket < -1 */ - conn->socket--; - } - SYS_ARCH_UNPROTECT(lev); - return; - } - s = conn->socket; - SYS_ARCH_UNPROTECT(lev); - } - - sock = get_socket(s); - if (!sock) { - return; - } - } else { - return; - } - - check_waiters = 1; - SYS_ARCH_PROTECT(lev); - /* Set event as required */ - switch (evt) { - case NETCONN_EVT_RCVPLUS: - sock->rcvevent++; - if (sock->rcvevent > 1) { - check_waiters = 0; - } - break; - case NETCONN_EVT_RCVMINUS: - sock->rcvevent--; - check_waiters = 0; - break; - case NETCONN_EVT_SENDPLUS: - if (sock->sendevent) { - check_waiters = 0; - } - sock->sendevent = 1; - break; - case NETCONN_EVT_SENDMINUS: - sock->sendevent = 0; - check_waiters = 0; - break; - case NETCONN_EVT_ERROR: - sock->errevent = 1; - break; - default: - LWIP_ASSERT("unknown event", 0); - break; - } - - if (sock->select_waiting && check_waiters) { - /* Save which events are active */ - int has_recvevent, has_sendevent, has_errevent; - has_recvevent = sock->rcvevent > 0; - has_sendevent = sock->sendevent != 0; - has_errevent = sock->errevent != 0; - SYS_ARCH_UNPROTECT(lev); - /* Check any select calls waiting on this socket */ - select_check_waiters(s, has_recvevent, has_sendevent, has_errevent); - } else { - SYS_ARCH_UNPROTECT(lev); - } - done_socket(sock); -} - -/** - * Check if any select waiters are waiting on this socket and its events - * - * @note on synchronization of select_cb_list: - * LWIP_TCPIP_CORE_LOCKING: the select_cb_list must only be accessed while holding - * the core lock. We do a single pass through the list and signal any waiters. - * Core lock should already be held when calling here!!!! - - * !LWIP_TCPIP_CORE_LOCKING: we use SYS_ARCH_PROTECT but unlock on each iteration - * of the loop, thus creating a possibility where a thread could modify the - * select_cb_list during our UNPROTECT/PROTECT. We use a generational counter to - * detect this change and restart the list walk. The list is expected to be small - */ -static void select_check_waiters(int s, int has_recvevent, int has_sendevent, int has_errevent) -{ - struct lwip_select_cb *scb; -#if !LWIP_TCPIP_CORE_LOCKING - int last_select_cb_ctr; - SYS_ARCH_DECL_PROTECT(lev); -#endif /* !LWIP_TCPIP_CORE_LOCKING */ - - LWIP_ASSERT_CORE_LOCKED(); - -#if !LWIP_TCPIP_CORE_LOCKING - SYS_ARCH_PROTECT(lev); -again: - /* remember the state of select_cb_list to detect changes */ - last_select_cb_ctr = select_cb_ctr; -#endif /* !LWIP_TCPIP_CORE_LOCKING */ - for (scb = select_cb_list; scb != NULL; scb = scb->next) { - if (scb->sem_signalled == 0) { - /* semaphore not signalled yet */ - int do_signal = 0; -#if LWIP_SOCKET_POLL - if (scb->poll_fds != NULL) { - do_signal = lwip_poll_should_wake(scb, s, has_recvevent, has_sendevent, has_errevent); - } -#endif /* LWIP_SOCKET_POLL */ -#if LWIP_SOCKET_SELECT && LWIP_SOCKET_POLL - else -#endif /* LWIP_SOCKET_SELECT && LWIP_SOCKET_POLL */ -#if LWIP_SOCKET_SELECT - { - /* Test this select call for our socket */ - if (has_recvevent) { - if (scb->readset && FD_ISSET(s, scb->readset)) { - do_signal = 1; - } - } - if (has_sendevent) { - if (!do_signal && scb->writeset && FD_ISSET(s, scb->writeset)) { - do_signal = 1; - } - } - if (has_errevent) { - if (!do_signal && scb->exceptset && FD_ISSET(s, scb->exceptset)) { - do_signal = 1; - } - } - } -#endif /* LWIP_SOCKET_SELECT */ - if (do_signal) { - scb->sem_signalled = 1; - /* For !LWIP_TCPIP_CORE_LOCKING, we don't call SYS_ARCH_UNPROTECT() before signaling - the semaphore, as this might lead to the select thread taking itself off the list, - invalidating the semaphore. */ - sys_sem_signal(SELECT_SEM_PTR(scb->sem)); - } - } -#if LWIP_TCPIP_CORE_LOCKING - } -#else - /* unlock interrupts with each step */ - SYS_ARCH_UNPROTECT(lev); - /* this makes sure interrupt protection time is short */ - SYS_ARCH_PROTECT(lev); - if (last_select_cb_ctr != select_cb_ctr) { - /* someone has changed select_cb_list, restart at the beginning */ - goto again; - } - /* remember the state of select_cb_list to detect changes */ - last_select_cb_ctr = select_cb_ctr; - } - SYS_ARCH_UNPROTECT(lev); -#endif -} -#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ - -/** - * Close one end of a full-duplex connection. - */ -int -lwip_shutdown(int s, int how) -{ - struct lwip_sock *sock; - err_t err; - u8_t shut_rx = 0, shut_tx = 0; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_shutdown(%d, how=%d)\n", s, how)); - - sock = get_socket(s); - if (!sock) { - return -1; - } - - if (sock->conn != NULL) { - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { - sock_set_errno(sock, EOPNOTSUPP); - done_socket(sock); - return -1; - } - } else { - sock_set_errno(sock, ENOTCONN); - done_socket(sock); - return -1; - } - - if (how == SHUT_RD) { - shut_rx = 1; - } else if (how == SHUT_WR) { - shut_tx = 1; - } else if (how == SHUT_RDWR) { - shut_rx = 1; - shut_tx = 1; - } else { - sock_set_errno(sock, EINVAL); - done_socket(sock); - return -1; - } - err = netconn_shutdown(sock->conn, shut_rx, shut_tx); - - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return (err == ERR_OK ? 0 : -1); -} - -static int -lwip_getaddrname(int s, struct sockaddr *name, socklen_t *namelen, u8_t local) -{ - struct lwip_sock *sock; - union sockaddr_aligned saddr; - ip_addr_t naddr; - u16_t port; - err_t err; - - sock = get_socket(s); - if (!sock) { - return -1; - } - - /* get the IP address and port */ - err = netconn_getaddr(sock->conn, &naddr, &port, local); - if (err != ERR_OK) { - sock_set_errno(sock, err_to_errno(err)); - done_socket(sock); - return -1; - } - -#if LWIP_IPV4 && LWIP_IPV6 - /* Dual-stack: Map IPv4 addresses to IPv4 mapped IPv6 */ - if (NETCONNTYPE_ISIPV6(netconn_type(sock->conn)) && - IP_IS_V4_VAL(naddr)) { - ip4_2_ipv4_mapped_ipv6(ip_2_ip6(&naddr), ip_2_ip4(&naddr)); - IP_SET_TYPE_VAL(naddr, IPADDR_TYPE_V6); - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - IPADDR_PORT_TO_SOCKADDR(&saddr, &naddr, port); - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getaddrname(%d, addr=", s)); - ip_addr_debug_print_val(SOCKETS_DEBUG, naddr); - LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", port)); - - if (*namelen > saddr.sa.sa_len) { - *namelen = saddr.sa.sa_len; - } - MEMCPY(name, &saddr, *namelen); - - sock_set_errno(sock, 0); - done_socket(sock); - return 0; -} - -int -lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen) -{ - return lwip_getaddrname(s, name, namelen, 0); -} - -int -lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen) -{ - return lwip_getaddrname(s, name, namelen, 1); -} - -int -lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) -{ - int err; - struct lwip_sock *sock = get_socket(s); -#if !LWIP_TCPIP_CORE_LOCKING - err_t cberr; - LWIP_SETGETSOCKOPT_DATA_VAR_DECLARE(data); -#endif /* !LWIP_TCPIP_CORE_LOCKING */ - - if (!sock) { - return -1; - } - - if ((NULL == optval) || (NULL == optlen)) { - sock_set_errno(sock, EFAULT); - done_socket(sock); - return -1; - } - -#if LWIP_TCPIP_CORE_LOCKING - /* core-locking can just call the -impl function */ - LOCK_TCPIP_CORE(); - err = lwip_getsockopt_impl(s, level, optname, optval, optlen); - UNLOCK_TCPIP_CORE(); - -#else /* LWIP_TCPIP_CORE_LOCKING */ - -#if LWIP_MPU_COMPATIBLE - /* MPU_COMPATIBLE copies the optval data, so check for max size here */ - if (*optlen > LWIP_SETGETSOCKOPT_MAXOPTLEN) { - sock_set_errno(sock, ENOBUFS); - done_socket(sock); - return -1; - } -#endif /* LWIP_MPU_COMPATIBLE */ - - LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(data, sock); - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).s = s; - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).level = level; - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optname = optname; - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen = *optlen; -#if !LWIP_MPU_COMPATIBLE - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval.p = optval; -#endif /* !LWIP_MPU_COMPATIBLE */ - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err = 0; -#if LWIP_NETCONN_SEM_PER_THREAD - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = LWIP_NETCONN_THREAD_SEM_GET(); -#else - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = &sock->conn->op_completed; -#endif - cberr = tcpip_callback(lwip_getsockopt_callback, &LWIP_SETGETSOCKOPT_DATA_VAR_REF(data)); - if (cberr != ERR_OK) { - LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); - sock_set_errno(sock, err_to_errno(cberr)); - done_socket(sock); - return -1; - } - sys_arch_sem_wait((sys_sem_t *)(LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem), 0); - - /* write back optlen and optval */ - *optlen = LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen; -#if LWIP_MPU_COMPATIBLE - MEMCPY(optval, LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval, - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen); -#endif /* LWIP_MPU_COMPATIBLE */ - - /* maybe lwip_getsockopt_internal has changed err */ - err = LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err; - LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); -#endif /* LWIP_TCPIP_CORE_LOCKING */ - - sock_set_errno(sock, err); - done_socket(sock); - return err ? -1 : 0; -} - -#if !LWIP_TCPIP_CORE_LOCKING -/** lwip_getsockopt_callback: only used without CORE_LOCKING - * to get into the tcpip_thread - */ -static void -lwip_getsockopt_callback(void *arg) -{ - struct lwip_setgetsockopt_data *data; - LWIP_ASSERT("arg != NULL", arg != NULL); - data = (struct lwip_setgetsockopt_data *)arg; - - data->err = lwip_getsockopt_impl(data->s, data->level, data->optname, -#if LWIP_MPU_COMPATIBLE - data->optval, -#else /* LWIP_MPU_COMPATIBLE */ - data->optval.p, -#endif /* LWIP_MPU_COMPATIBLE */ - &data->optlen); - - sys_sem_signal((sys_sem_t *)(data->completed_sem)); -} -#endif /* LWIP_TCPIP_CORE_LOCKING */ - -static int -lwip_sockopt_to_ipopt(int optname) -{ - /* Map SO_* values to our internal SOF_* values - * We should not rely on #defines in socket.h - * being in sync with ip.h. - */ - switch (optname) { - case SO_BROADCAST: - return SOF_BROADCAST; - case SO_KEEPALIVE: - return SOF_KEEPALIVE; - case SO_REUSEADDR: - return SOF_REUSEADDR; - default: - LWIP_ASSERT("Unknown socket option", 0); - return 0; - } -} - -/** lwip_getsockopt_impl: the actual implementation of getsockopt: - * same argument as lwip_getsockopt, either called directly or through callback - */ -static int -lwip_getsockopt_impl(int s, int level, int optname, void *optval, socklen_t *optlen) -{ - int err = 0; - struct lwip_sock *sock = tryget_socket(s); - if (!sock) { - return EBADF; - } - -#ifdef LWIP_HOOK_SOCKETS_GETSOCKOPT - if (LWIP_HOOK_SOCKETS_GETSOCKOPT(s, sock, level, optname, optval, optlen, &err)) { - return err; - } -#endif - - switch (level) { - - /* Level: SOL_SOCKET */ - case SOL_SOCKET: - switch (optname) { - -#if LWIP_TCP - case SO_ACCEPTCONN: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); - if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_TCP) { - done_socket(sock); - return ENOPROTOOPT; - } - if ((sock->conn->pcb.tcp != NULL) && (sock->conn->pcb.tcp->state == LISTEN)) { - *(int *)optval = 1; - } else { - *(int *)optval = 0; - } - break; -#endif /* LWIP_TCP */ - - /* The option flags */ - case SO_BROADCAST: - case SO_KEEPALIVE: -#if SO_REUSE - case SO_REUSEADDR: -#endif /* SO_REUSE */ - if ((optname == SO_BROADCAST) && - (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP)) { - done_socket(sock); - return ENOPROTOOPT; - } - - optname = lwip_sockopt_to_ipopt(optname); - - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); - *(int *)optval = ip_get_option(sock->conn->pcb.ip, optname); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, optname=0x%x, ..) = %s\n", - s, optname, (*(int *)optval ? "on" : "off"))); - break; - - case SO_TYPE: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, int); - switch (NETCONNTYPE_GROUP(netconn_type(sock->conn))) { - case NETCONN_RAW: - *(int *)optval = SOCK_RAW; - break; - case NETCONN_TCP: - *(int *)optval = SOCK_STREAM; - break; - case NETCONN_UDP: - *(int *)optval = SOCK_DGRAM; - break; - default: /* unrecognized socket type */ - *(int *)optval = netconn_type(sock->conn); - LWIP_DEBUGF(SOCKETS_DEBUG, - ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE): unrecognized socket type %d\n", - s, *(int *)optval)); - } /* switch (netconn_type(sock->conn)) */ - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE) = %d\n", - s, *(int *)optval)); - break; - - case SO_ERROR: - LWIP_SOCKOPT_CHECK_OPTLEN(sock, *optlen, int); - *(int *)optval = err_to_errno(netconn_err(sock->conn)); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n", - s, *(int *)optval)); - break; - -#if LWIP_SO_SNDTIMEO - case SO_SNDTIMEO: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); - LWIP_SO_SNDRCVTIMEO_SET(optval, netconn_get_sendtimeout(sock->conn)); - break; -#endif /* LWIP_SO_SNDTIMEO */ -#if LWIP_SO_RCVTIMEO - case SO_RCVTIMEO: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); - LWIP_SO_SNDRCVTIMEO_SET(optval, netconn_get_recvtimeout(sock->conn)); - break; -#endif /* LWIP_SO_RCVTIMEO */ -#if LWIP_SO_RCVBUF - case SO_RCVBUF: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, int); - *(int *)optval = netconn_get_recvbufsize(sock->conn); - break; -#endif /* LWIP_SO_RCVBUF */ -#if LWIP_SO_LINGER - case SO_LINGER: { - s16_t conn_linger; - struct linger *linger = (struct linger *)optval; - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, struct linger); - conn_linger = sock->conn->linger; - if (conn_linger >= 0) { - linger->l_onoff = 1; - linger->l_linger = (int)conn_linger; - } else { - linger->l_onoff = 0; - linger->l_linger = 0; - } - } - break; -#endif /* LWIP_SO_LINGER */ -#if LWIP_UDP - case SO_NO_CHECK: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, *optlen, int, NETCONN_UDP); -#if LWIP_UDPLITE - if (udp_is_flag_set(sock->conn->pcb.udp, UDP_FLAGS_UDPLITE)) { - /* this flag is only available for UDP, not for UDP lite */ - done_socket(sock); - return EAFNOSUPPORT; - } -#endif /* LWIP_UDPLITE */ - *(int *)optval = udp_is_flag_set(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM) ? 1 : 0; - break; -#endif /* LWIP_UDP*/ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; - - /* Level: IPPROTO_IP */ - case IPPROTO_IP: - switch (optname) { - case IP_TTL: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); - *(int *)optval = sock->conn->pcb.ip->ttl; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TTL) = %d\n", - s, *(int *)optval)); - break; - case IP_TOS: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); - *(int *)optval = sock->conn->pcb.ip->tos; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TOS) = %d\n", - s, *(int *)optval)); - break; -#if LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP - case IP_MULTICAST_TTL: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, u8_t); - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_UDP) { - done_socket(sock); - return ENOPROTOOPT; - } - *(u8_t *)optval = udp_get_multicast_ttl(sock->conn->pcb.udp); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_TTL) = %d\n", - s, *(int *)optval)); - break; - case IP_MULTICAST_IF: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, struct in_addr); - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_UDP) { - done_socket(sock); - return ENOPROTOOPT; - } - inet_addr_from_ip4addr((struct in_addr *)optval, udp_get_multicast_netif_addr(sock->conn->pcb.udp)); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_IF) = 0x%"X32_F"\n", - s, *(u32_t *)optval)); - break; - case IP_MULTICAST_LOOP: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, u8_t); - if ((sock->conn->pcb.udp->flags & UDP_FLAGS_MULTICAST_LOOP) != 0) { - *(u8_t *)optval = 1; - } else { - *(u8_t *)optval = 0; - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_LOOP) = %d\n", - s, *(int *)optval)); - break; -#endif /* LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP */ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; - -#if LWIP_TCP - /* Level: IPPROTO_TCP */ - case IPPROTO_TCP: - /* Special case: all IPPROTO_TCP option take an int */ - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, *optlen, int, NETCONN_TCP); - if (sock->conn->pcb.tcp->state == LISTEN) { - done_socket(sock); - return EINVAL; - } - switch (optname) { - case TCP_NODELAY: - *(int *)optval = tcp_nagle_disabled(sock->conn->pcb.tcp); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_NODELAY) = %s\n", - s, (*(int *)optval) ? "on" : "off") ); - break; - case TCP_KEEPALIVE: - *(int *)optval = (int)sock->conn->pcb.tcp->keep_idle; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) = %d\n", - s, *(int *)optval)); - break; - -#if LWIP_TCP_KEEPALIVE - case TCP_KEEPIDLE: - *(int *)optval = (int)(sock->conn->pcb.tcp->keep_idle / 1000); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPIDLE) = %d\n", - s, *(int *)optval)); - break; - case TCP_KEEPINTVL: - *(int *)optval = (int)(sock->conn->pcb.tcp->keep_intvl / 1000); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPINTVL) = %d\n", - s, *(int *)optval)); - break; - case TCP_KEEPCNT: - *(int *)optval = (int)sock->conn->pcb.tcp->keep_cnt; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPCNT) = %d\n", - s, *(int *)optval)); - break; -#endif /* LWIP_TCP_KEEPALIVE */ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; -#endif /* LWIP_TCP */ - -#if LWIP_IPV6 - /* Level: IPPROTO_IPV6 */ - case IPPROTO_IPV6: - switch (optname) { - case IPV6_V6ONLY: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, int); - *(int *)optval = (netconn_get_ipv6only(sock->conn) ? 1 : 0); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IPV6, IPV6_V6ONLY) = %d\n", - s, *(int *)optval)); - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IPV6, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; -#endif /* LWIP_IPV6 */ - -#if LWIP_UDP && LWIP_UDPLITE - /* Level: IPPROTO_UDPLITE */ - case IPPROTO_UDPLITE: - /* Special case: all IPPROTO_UDPLITE option take an int */ - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); - /* If this is no UDP lite socket, ignore any options. */ - if (!NETCONNTYPE_ISUDPLITE(netconn_type(sock->conn))) { - done_socket(sock); - return ENOPROTOOPT; - } - switch (optname) { - case UDPLITE_SEND_CSCOV: - *(int *)optval = sock->conn->pcb.udp->chksum_len_tx; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) = %d\n", - s, (*(int *)optval)) ); - break; - case UDPLITE_RECV_CSCOV: - *(int *)optval = sock->conn->pcb.udp->chksum_len_rx; - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) = %d\n", - s, (*(int *)optval)) ); - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; -#endif /* LWIP_UDP */ - /* Level: IPPROTO_RAW */ - case IPPROTO_RAW: - switch (optname) { -#if LWIP_IPV6 && LWIP_RAW - case IPV6_CHECKSUM: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, *optlen, int, NETCONN_RAW); - if (sock->conn->pcb.raw->chksum_reqd == 0) { - *(int *)optval = -1; - } else { - *(int *)optval = sock->conn->pcb.raw->chksum_offset; - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_RAW, IPV6_CHECKSUM) = %d\n", - s, (*(int *)optval)) ); - break; -#endif /* LWIP_IPV6 && LWIP_RAW */ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_RAW, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", - s, level, optname)); - err = ENOPROTOOPT; - break; - } /* switch (level) */ - - done_socket(sock); - return err; -} - -int -lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen) -{ - int err = 0; - struct lwip_sock *sock = get_socket(s); -#if !LWIP_TCPIP_CORE_LOCKING - err_t cberr; - LWIP_SETGETSOCKOPT_DATA_VAR_DECLARE(data); -#endif /* !LWIP_TCPIP_CORE_LOCKING */ - - if (!sock) { - return -1; - } - - if (NULL == optval) { - sock_set_errno(sock, EFAULT); - done_socket(sock); - return -1; - } - -#if LWIP_TCPIP_CORE_LOCKING - /* core-locking can just call the -impl function */ - LOCK_TCPIP_CORE(); - err = lwip_setsockopt_impl(s, level, optname, optval, optlen); - UNLOCK_TCPIP_CORE(); - -#else /* LWIP_TCPIP_CORE_LOCKING */ - -#if LWIP_MPU_COMPATIBLE - /* MPU_COMPATIBLE copies the optval data, so check for max size here */ - if (optlen > LWIP_SETGETSOCKOPT_MAXOPTLEN) { - sock_set_errno(sock, ENOBUFS); - done_socket(sock); - return -1; - } -#endif /* LWIP_MPU_COMPATIBLE */ - - LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(data, sock); - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).s = s; - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).level = level; - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optname = optname; - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen = optlen; -#if LWIP_MPU_COMPATIBLE - MEMCPY(LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval, optval, optlen); -#else /* LWIP_MPU_COMPATIBLE */ - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval.pc = (const void *)optval; -#endif /* LWIP_MPU_COMPATIBLE */ - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err = 0; -#if LWIP_NETCONN_SEM_PER_THREAD - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = LWIP_NETCONN_THREAD_SEM_GET(); -#else - LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = &sock->conn->op_completed; -#endif - cberr = tcpip_callback(lwip_setsockopt_callback, &LWIP_SETGETSOCKOPT_DATA_VAR_REF(data)); - if (cberr != ERR_OK) { - LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); - sock_set_errno(sock, err_to_errno(cberr)); - done_socket(sock); - return -1; - } - sys_arch_sem_wait((sys_sem_t *)(LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem), 0); - - /* maybe lwip_getsockopt_internal has changed err */ - err = LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err; - LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); -#endif /* LWIP_TCPIP_CORE_LOCKING */ - - sock_set_errno(sock, err); - done_socket(sock); - return err ? -1 : 0; -} - -#if !LWIP_TCPIP_CORE_LOCKING -/** lwip_setsockopt_callback: only used without CORE_LOCKING - * to get into the tcpip_thread - */ -static void -lwip_setsockopt_callback(void *arg) -{ - struct lwip_setgetsockopt_data *data; - LWIP_ASSERT("arg != NULL", arg != NULL); - data = (struct lwip_setgetsockopt_data *)arg; - - data->err = lwip_setsockopt_impl(data->s, data->level, data->optname, -#if LWIP_MPU_COMPATIBLE - data->optval, -#else /* LWIP_MPU_COMPATIBLE */ - data->optval.pc, -#endif /* LWIP_MPU_COMPATIBLE */ - data->optlen); - - sys_sem_signal((sys_sem_t *)(data->completed_sem)); -} -#endif /* LWIP_TCPIP_CORE_LOCKING */ - -/** lwip_setsockopt_impl: the actual implementation of setsockopt: - * same argument as lwip_setsockopt, either called directly or through callback - */ -static int -lwip_setsockopt_impl(int s, int level, int optname, const void *optval, socklen_t optlen) -{ - int err = 0; - struct lwip_sock *sock = tryget_socket(s); - if (!sock) { - return EBADF; - } - -#ifdef LWIP_HOOK_SOCKETS_SETSOCKOPT - if (LWIP_HOOK_SOCKETS_SETSOCKOPT(s, sock, level, optname, optval, optlen, &err)) { - return err; - } -#endif - - switch (level) { - - /* Level: SOL_SOCKET */ - case SOL_SOCKET: - switch (optname) { - - /* SO_ACCEPTCONN is get-only */ - - /* The option flags */ - case SO_BROADCAST: - case SO_KEEPALIVE: -#if SO_REUSE - case SO_REUSEADDR: -#endif /* SO_REUSE */ - if ((optname == SO_BROADCAST) && - (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP)) { - done_socket(sock); - return ENOPROTOOPT; - } - - optname = lwip_sockopt_to_ipopt(optname); - - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); - if (*(const int *)optval) { - ip_set_option(sock->conn->pcb.ip, optname); - } else { - ip_reset_option(sock->conn->pcb.ip, optname); - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, optname=0x%x, ..) -> %s\n", - s, optname, (*(const int *)optval ? "on" : "off"))); - break; - - /* SO_TYPE is get-only */ - /* SO_ERROR is get-only */ - -#if LWIP_SO_SNDTIMEO - case SO_SNDTIMEO: { - long ms_long; - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); - ms_long = LWIP_SO_SNDRCVTIMEO_GET_MS(optval); - if (ms_long < 0) { - done_socket(sock); - return EINVAL; - } - netconn_set_sendtimeout(sock->conn, ms_long); - break; - } -#endif /* LWIP_SO_SNDTIMEO */ -#if LWIP_SO_RCVTIMEO - case SO_RCVTIMEO: { - long ms_long; - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); - ms_long = LWIP_SO_SNDRCVTIMEO_GET_MS(optval); - if (ms_long < 0) { - done_socket(sock); - return EINVAL; - } - netconn_set_recvtimeout(sock->conn, (u32_t)ms_long); - break; - } -#endif /* LWIP_SO_RCVTIMEO */ -#if LWIP_SO_RCVBUF - case SO_RCVBUF: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, int); - netconn_set_recvbufsize(sock->conn, *(const int *)optval); - break; -#endif /* LWIP_SO_RCVBUF */ -#if LWIP_SO_LINGER - case SO_LINGER: { - const struct linger *linger = (const struct linger *)optval; - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, struct linger); - if (linger->l_onoff) { - int lingersec = linger->l_linger; - if (lingersec < 0) { - done_socket(sock); - return EINVAL; - } - if (lingersec > 0xFFFF) { - lingersec = 0xFFFF; - } - sock->conn->linger = (s16_t)lingersec; - } else { - sock->conn->linger = -1; - } - } - break; -#endif /* LWIP_SO_LINGER */ -#if LWIP_UDP - case SO_NO_CHECK: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_UDP); -#if LWIP_UDPLITE - if (udp_is_flag_set(sock->conn->pcb.udp, UDP_FLAGS_UDPLITE)) { - /* this flag is only available for UDP, not for UDP lite */ - done_socket(sock); - return EAFNOSUPPORT; - } -#endif /* LWIP_UDPLITE */ - if (*(const int *)optval) { - udp_set_flags(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); - } else { - udp_clear_flags(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); - } - break; -#endif /* LWIP_UDP */ - case SO_BINDTODEVICE: { - const struct ifreq *iface; - struct netif *n = NULL; - - LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, struct ifreq); - - iface = (const struct ifreq *)optval; - if (iface->ifr_name[0] != 0) { - n = netif_find(iface->ifr_name); - if (n == NULL) { - done_socket(sock); - return ENODEV; - } - } - - switch (NETCONNTYPE_GROUP(netconn_type(sock->conn))) { -#if LWIP_TCP - case NETCONN_TCP: - tcp_bind_netif(sock->conn->pcb.tcp, n); - break; -#endif -#if LWIP_UDP - case NETCONN_UDP: - udp_bind_netif(sock->conn->pcb.udp, n); - break; -#endif -#if LWIP_RAW - case NETCONN_RAW: - raw_bind_netif(sock->conn->pcb.raw, n); - break; -#endif - default: - LWIP_ASSERT("Unhandled netconn type in SO_BINDTODEVICE", 0); - break; - } - } - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; - - /* Level: IPPROTO_IP */ - case IPPROTO_IP: - switch (optname) { - case IP_TTL: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); - sock->conn->pcb.ip->ttl = (u8_t)(*(const int *)optval); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TTL, ..) -> %d\n", - s, sock->conn->pcb.ip->ttl)); - break; - case IP_TOS: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); - sock->conn->pcb.ip->tos = (u8_t)(*(const int *)optval); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TOS, ..)-> %d\n", - s, sock->conn->pcb.ip->tos)); - break; -#if LWIP_NETBUF_RECVINFO - case IP_PKTINFO: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_UDP); - if (*(const int *)optval) { - sock->conn->flags |= NETCONN_FLAG_PKTINFO; - } else { - sock->conn->flags &= ~NETCONN_FLAG_PKTINFO; - } - break; -#endif /* LWIP_NETBUF_RECVINFO */ -#if LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP - case IP_MULTICAST_TTL: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, u8_t, NETCONN_UDP); - udp_set_multicast_ttl(sock->conn->pcb.udp, (u8_t)(*(const u8_t *)optval)); - break; - case IP_MULTICAST_IF: { - ip4_addr_t if_addr; - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, struct in_addr, NETCONN_UDP); - inet_addr_to_ip4addr(&if_addr, (const struct in_addr *)optval); - udp_set_multicast_netif_addr(sock->conn->pcb.udp, &if_addr); - } - break; - case IP_MULTICAST_LOOP: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, u8_t, NETCONN_UDP); - if (*(const u8_t *)optval) { - udp_set_flags(sock->conn->pcb.udp, UDP_FLAGS_MULTICAST_LOOP); - } else { - udp_clear_flags(sock->conn->pcb.udp, UDP_FLAGS_MULTICAST_LOOP); - } - break; -#endif /* LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP */ -#if LWIP_IGMP - case IP_ADD_MEMBERSHIP: - case IP_DROP_MEMBERSHIP: { - /* If this is a TCP or a RAW socket, ignore these options. */ - err_t igmp_err; - const struct ip_mreq *imr = (const struct ip_mreq *)optval; - ip4_addr_t if_addr; - ip4_addr_t multi_addr; - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, struct ip_mreq, NETCONN_UDP); - inet_addr_to_ip4addr(&if_addr, &imr->imr_interface); - inet_addr_to_ip4addr(&multi_addr, &imr->imr_multiaddr); - if (optname == IP_ADD_MEMBERSHIP) { - if (!lwip_socket_register_membership(s, &if_addr, &multi_addr)) { - /* cannot track membership (out of memory) */ - err = ENOMEM; - igmp_err = ERR_OK; - } else { - igmp_err = igmp_joingroup(&if_addr, &multi_addr); - } - } else { - igmp_err = igmp_leavegroup(&if_addr, &multi_addr); - lwip_socket_unregister_membership(s, &if_addr, &multi_addr); - } - if (igmp_err != ERR_OK) { - err = EADDRNOTAVAIL; - } - } - break; -#endif /* LWIP_IGMP */ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; - -#if LWIP_TCP - /* Level: IPPROTO_TCP */ - case IPPROTO_TCP: - /* Special case: all IPPROTO_TCP option take an int */ - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_TCP); - if (sock->conn->pcb.tcp->state == LISTEN) { - done_socket(sock); - return EINVAL; - } - switch (optname) { - case TCP_NODELAY: - if (*(const int *)optval) { - tcp_nagle_disable(sock->conn->pcb.tcp); - } else { - tcp_nagle_enable(sock->conn->pcb.tcp); - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) -> %s\n", - s, (*(const int *)optval) ? "on" : "off") ); - break; - case TCP_KEEPALIVE: - sock->conn->pcb.tcp->keep_idle = (u32_t)(*(const int *)optval); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) -> %"U32_F"\n", - s, sock->conn->pcb.tcp->keep_idle)); - break; - -#if LWIP_TCP_KEEPALIVE - case TCP_KEEPIDLE: - sock->conn->pcb.tcp->keep_idle = 1000 * (u32_t)(*(const int *)optval); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPIDLE) -> %"U32_F"\n", - s, sock->conn->pcb.tcp->keep_idle)); - break; - case TCP_KEEPINTVL: - sock->conn->pcb.tcp->keep_intvl = 1000 * (u32_t)(*(const int *)optval); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPINTVL) -> %"U32_F"\n", - s, sock->conn->pcb.tcp->keep_intvl)); - break; - case TCP_KEEPCNT: - sock->conn->pcb.tcp->keep_cnt = (u32_t)(*(const int *)optval); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPCNT) -> %"U32_F"\n", - s, sock->conn->pcb.tcp->keep_cnt)); - break; -#endif /* LWIP_TCP_KEEPALIVE */ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; -#endif /* LWIP_TCP*/ - -#if LWIP_IPV6 - /* Level: IPPROTO_IPV6 */ - case IPPROTO_IPV6: - switch (optname) { - case IPV6_V6ONLY: - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); - if (*(const int *)optval) { - netconn_set_ipv6only(sock->conn, 1); - } else { - netconn_set_ipv6only(sock->conn, 0); - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IPV6, IPV6_V6ONLY, ..) -> %d\n", - s, (netconn_get_ipv6only(sock->conn) ? 1 : 0))); - break; -#if LWIP_IPV6_MLD - case IPV6_JOIN_GROUP: - case IPV6_LEAVE_GROUP: { - /* If this is a TCP or a RAW socket, ignore these options. */ - err_t mld6_err; - struct netif *netif; - ip6_addr_t multi_addr; - const struct ipv6_mreq *imr = (const struct ipv6_mreq *)optval; - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, struct ipv6_mreq, NETCONN_UDP); - inet6_addr_to_ip6addr(&multi_addr, &imr->ipv6mr_multiaddr); - LWIP_ASSERT("Invalid netif index", imr->ipv6mr_interface <= 0xFFu); - netif = netif_get_by_index((u8_t)imr->ipv6mr_interface); - if (netif == NULL) { - err = EADDRNOTAVAIL; - break; - } - - if (optname == IPV6_JOIN_GROUP) { - if (!lwip_socket_register_mld6_membership(s, imr->ipv6mr_interface, &multi_addr)) { - /* cannot track membership (out of memory) */ - err = ENOMEM; - mld6_err = ERR_OK; - } else { - mld6_err = mld6_joingroup_netif(netif, &multi_addr); - } - } else { - mld6_err = mld6_leavegroup_netif(netif, &multi_addr); - lwip_socket_unregister_mld6_membership(s, imr->ipv6mr_interface, &multi_addr); - } - if (mld6_err != ERR_OK) { - err = EADDRNOTAVAIL; - } - } - break; -#endif /* LWIP_IPV6_MLD */ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IPV6, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; -#endif /* LWIP_IPV6 */ - -#if LWIP_UDP && LWIP_UDPLITE - /* Level: IPPROTO_UDPLITE */ - case IPPROTO_UDPLITE: - /* Special case: all IPPROTO_UDPLITE option take an int */ - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); - /* If this is no UDP lite socket, ignore any options. */ - if (!NETCONNTYPE_ISUDPLITE(netconn_type(sock->conn))) { - done_socket(sock); - return ENOPROTOOPT; - } - switch (optname) { - case UDPLITE_SEND_CSCOV: - if ((*(const int *)optval != 0) && ((*(const int *)optval < 8) || (*(const int *)optval > 0xffff))) { - /* don't allow illegal values! */ - sock->conn->pcb.udp->chksum_len_tx = 8; - } else { - sock->conn->pcb.udp->chksum_len_tx = (u16_t) * (const int *)optval; - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) -> %d\n", - s, (*(const int *)optval)) ); - break; - case UDPLITE_RECV_CSCOV: - if ((*(const int *)optval != 0) && ((*(const int *)optval < 8) || (*(const int *)optval > 0xffff))) { - /* don't allow illegal values! */ - sock->conn->pcb.udp->chksum_len_rx = 8; - } else { - sock->conn->pcb.udp->chksum_len_rx = (u16_t) * (const int *)optval; - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) -> %d\n", - s, (*(const int *)optval)) ); - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; -#endif /* LWIP_UDP */ - /* Level: IPPROTO_RAW */ - case IPPROTO_RAW: - switch (optname) { -#if LWIP_IPV6 && LWIP_RAW - case IPV6_CHECKSUM: - /* It should not be possible to disable the checksum generation with ICMPv6 - * as per RFC 3542 chapter 3.1 */ - if (sock->conn->pcb.raw->protocol == IPPROTO_ICMPV6) { - done_socket(sock); - return EINVAL; - } - - LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_RAW); - if (*(const int *)optval < 0) { - sock->conn->pcb.raw->chksum_reqd = 0; - } else if (*(const int *)optval & 1) { - /* Per RFC3542, odd offsets are not allowed */ - done_socket(sock); - return EINVAL; - } else { - sock->conn->pcb.raw->chksum_reqd = 1; - sock->conn->pcb.raw->chksum_offset = (u16_t) * (const int *)optval; - } - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_RAW, IPV6_CHECKSUM, ..) -> %d\n", - s, sock->conn->pcb.raw->chksum_reqd)); - break; -#endif /* LWIP_IPV6 && LWIP_RAW */ - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_RAW, UNIMPL: optname=0x%x, ..)\n", - s, optname)); - err = ENOPROTOOPT; - break; - } /* switch (optname) */ - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", - s, level, optname)); - err = ENOPROTOOPT; - break; - } /* switch (level) */ - - done_socket(sock); - return err; -} - -int -lwip_ioctl(int s, long cmd, void *argp) -{ - struct lwip_sock *sock = get_socket(s); - u8_t val; -#if LWIP_SO_RCVBUF - int recv_avail; -#endif /* LWIP_SO_RCVBUF */ - - if (!sock) { - return -1; - } - - switch (cmd) { -#if LWIP_SO_RCVBUF || LWIP_FIONREAD_LINUXMODE - case FIONREAD: - if (!argp) { - sock_set_errno(sock, EINVAL); - done_socket(sock); - return -1; - } -#if LWIP_FIONREAD_LINUXMODE - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { - struct netbuf *nb; - if (sock->lastdata.netbuf) { - nb = sock->lastdata.netbuf; - *((int *)argp) = nb->p->tot_len; - } else { - struct netbuf *rxbuf; - err_t err = netconn_recv_udp_raw_netbuf_flags(sock->conn, &rxbuf, NETCONN_DONTBLOCK); - if (err != ERR_OK) { - *((int *)argp) = 0; - } else { - sock->lastdata.netbuf = rxbuf; - *((int *)argp) = rxbuf->p->tot_len; - } - } - done_socket(sock); - return 0; - } -#endif /* LWIP_FIONREAD_LINUXMODE */ - -#if LWIP_SO_RCVBUF - /* we come here if either LWIP_FIONREAD_LINUXMODE==0 or this is a TCP socket */ - SYS_ARCH_GET(sock->conn->recv_avail, recv_avail); - if (recv_avail < 0) { - recv_avail = 0; - } - - /* Check if there is data left from the last recv operation. /maq 041215 */ - if (sock->lastdata.netbuf) { - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { - recv_avail += sock->lastdata.pbuf->tot_len; - } else { - recv_avail += sock->lastdata.netbuf->p->tot_len; - } - } - *((int *)argp) = recv_avail; - - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONREAD, %p) = %"U16_F"\n", s, argp, *((u16_t *)argp))); - sock_set_errno(sock, 0); - done_socket(sock); - return 0; -#else /* LWIP_SO_RCVBUF */ - break; -#endif /* LWIP_SO_RCVBUF */ -#endif /* LWIP_SO_RCVBUF || LWIP_FIONREAD_LINUXMODE */ - - case (long)FIONBIO: - val = 0; - if (argp && *(int *)argp) { - val = 1; - } - netconn_set_nonblocking(sock->conn, val); - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, val)); - sock_set_errno(sock, 0); - done_socket(sock); - return 0; - - default: - break; - } /* switch (cmd) */ - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, UNIMPL: 0x%lx, %p)\n", s, cmd, argp)); - sock_set_errno(sock, ENOSYS); /* not yet implemented */ - done_socket(sock); - return -1; -} - -/** A minimal implementation of fcntl. - * Currently only the commands F_GETFL and F_SETFL are implemented. - * The flag O_NONBLOCK and access modes are supported for F_GETFL, only - * the flag O_NONBLOCK is implemented for F_SETFL. - */ -int -lwip_fcntl(int s, int cmd, int val) -{ - struct lwip_sock *sock = get_socket(s); - int ret = -1; - int op_mode = 0; - - if (!sock) { - return -1; - } - - switch (cmd) { - case F_GETFL: - ret = netconn_is_nonblocking(sock->conn) ? O_NONBLOCK : 0; - sock_set_errno(sock, 0); - - if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { -#if LWIP_TCPIP_CORE_LOCKING - LOCK_TCPIP_CORE(); -#else - SYS_ARCH_DECL_PROTECT(lev); - /* the proper thing to do here would be to get into the tcpip_thread, - but locking should be OK as well since we only *read* some flags */ - SYS_ARCH_PROTECT(lev); -#endif -#if LWIP_TCP - if (sock->conn->pcb.tcp) { - if (!(sock->conn->pcb.tcp->flags & TF_RXCLOSED)) { - op_mode |= O_RDONLY; - } - if (!(sock->conn->pcb.tcp->flags & TF_FIN)) { - op_mode |= O_WRONLY; - } - } -#endif -#if LWIP_TCPIP_CORE_LOCKING - UNLOCK_TCPIP_CORE(); -#else - SYS_ARCH_UNPROTECT(lev); -#endif - } else { - op_mode |= O_RDWR; - } - - /* ensure O_RDWR for (O_RDONLY|O_WRONLY) != O_RDWR cases */ - ret |= (op_mode == (O_RDONLY | O_WRONLY)) ? O_RDWR : op_mode; - - break; - case F_SETFL: - /* Bits corresponding to the file access mode and the file creation flags [..] that are set in arg shall be ignored */ - val &= ~(O_RDONLY | O_WRONLY | O_RDWR); - if ((val & ~O_NONBLOCK) == 0) { - /* only O_NONBLOCK, all other bits are zero */ - netconn_set_nonblocking(sock->conn, val & O_NONBLOCK); - ret = 0; - sock_set_errno(sock, 0); - } else { - sock_set_errno(sock, ENOSYS); /* not yet implemented */ - } - break; - default: - LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_fcntl(%d, UNIMPL: %d, %d)\n", s, cmd, val)); - sock_set_errno(sock, ENOSYS); /* not yet implemented */ - break; - } - done_socket(sock); - return ret; -} - -#if LWIP_COMPAT_SOCKETS == 2 && LWIP_POSIX_SOCKETS_IO_NAMES -int -fcntl(int s, int cmd, ...) -{ - va_list ap; - int val; - - va_start(ap, cmd); - val = va_arg(ap, int); - va_end(ap); - return lwip_fcntl(s, cmd, val); -} -#endif - -const char * -lwip_inet_ntop(int af, const void *src, char *dst, socklen_t size) -{ - const char *ret = NULL; - int size_int = (int)size; - if (size_int < 0) { - set_errno(ENOSPC); - return NULL; - } - switch (af) { -#if LWIP_IPV4 - case AF_INET: - ret = ip4addr_ntoa_r((const ip4_addr_t *)src, dst, size_int); - if (ret == NULL) { - set_errno(ENOSPC); - } - break; -#endif -#if LWIP_IPV6 - case AF_INET6: - ret = ip6addr_ntoa_r((const ip6_addr_t *)src, dst, size_int); - if (ret == NULL) { - set_errno(ENOSPC); - } - break; -#endif - default: - set_errno(EAFNOSUPPORT); - break; - } - return ret; -} - -int -lwip_inet_pton(int af, const char *src, void *dst) -{ - int err; - switch (af) { -#if LWIP_IPV4 - case AF_INET: - err = ip4addr_aton(src, (ip4_addr_t *)dst); - break; -#endif -#if LWIP_IPV6 - case AF_INET6: { - /* convert into temporary variable since ip6_addr_t might be larger - than in6_addr when scopes are enabled */ - ip6_addr_t addr; - err = ip6addr_aton(src, &addr); - if (err) { - memcpy(dst, &addr.addr, sizeof(addr.addr)); - } - break; - } -#endif - default: - err = -1; - set_errno(EAFNOSUPPORT); - break; - } - return err; -} - -#if LWIP_IGMP -/** Register a new IGMP membership. On socket close, the membership is dropped automatically. - * - * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). - * - * @return 1 on success, 0 on failure - */ -static int -lwip_socket_register_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr) -{ - struct lwip_sock *sock = get_socket(s); - int i; - - if (!sock) { - return 0; - } - - for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { - if (socket_ipv4_multicast_memberships[i].sock == NULL) { - socket_ipv4_multicast_memberships[i].sock = sock; - ip4_addr_copy(socket_ipv4_multicast_memberships[i].if_addr, *if_addr); - ip4_addr_copy(socket_ipv4_multicast_memberships[i].multi_addr, *multi_addr); - done_socket(sock); - return 1; - } - } - done_socket(sock); - return 0; -} - -/** Unregister a previously registered membership. This prevents dropping the membership - * on socket close. - * - * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). - */ -static void -lwip_socket_unregister_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr) -{ - struct lwip_sock *sock = get_socket(s); - int i; - - if (!sock) { - return; - } - - for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { - if ((socket_ipv4_multicast_memberships[i].sock == sock) && - ip4_addr_cmp(&socket_ipv4_multicast_memberships[i].if_addr, if_addr) && - ip4_addr_cmp(&socket_ipv4_multicast_memberships[i].multi_addr, multi_addr)) { - socket_ipv4_multicast_memberships[i].sock = NULL; - ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].if_addr); - ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].multi_addr); - break; - } - } - done_socket(sock); -} - -/** Drop all memberships of a socket that were not dropped explicitly via setsockopt. - * - * ATTENTION: this function is NOT called from tcpip_thread (or under CORE_LOCK). - */ -static void -lwip_socket_drop_registered_memberships(int s) -{ - struct lwip_sock *sock = get_socket(s); - int i; - - if (!sock) { - return; - } - - for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { - if (socket_ipv4_multicast_memberships[i].sock == sock) { - ip_addr_t multi_addr, if_addr; - ip_addr_copy_from_ip4(multi_addr, socket_ipv4_multicast_memberships[i].multi_addr); - ip_addr_copy_from_ip4(if_addr, socket_ipv4_multicast_memberships[i].if_addr); - socket_ipv4_multicast_memberships[i].sock = NULL; - ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].if_addr); - ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].multi_addr); - - netconn_join_leave_group(sock->conn, &multi_addr, &if_addr, NETCONN_LEAVE); - } - } - done_socket(sock); -} -#endif /* LWIP_IGMP */ - -#if LWIP_IPV6_MLD -/** Register a new MLD6 membership. On socket close, the membership is dropped automatically. - * - * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). - * - * @return 1 on success, 0 on failure - */ -static int -lwip_socket_register_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr) -{ - struct lwip_sock *sock = get_socket(s); - int i; - - if (!sock) { - return 0; - } - - for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { - if (socket_ipv6_multicast_memberships[i].sock == NULL) { - socket_ipv6_multicast_memberships[i].sock = sock; - socket_ipv6_multicast_memberships[i].if_idx = (u8_t)if_idx; - ip6_addr_copy(socket_ipv6_multicast_memberships[i].multi_addr, *multi_addr); - done_socket(sock); - return 1; - } - } - done_socket(sock); - return 0; -} - -/** Unregister a previously registered MLD6 membership. This prevents dropping the membership - * on socket close. - * - * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). - */ -static void -lwip_socket_unregister_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr) -{ - struct lwip_sock *sock = get_socket(s); - int i; - - if (!sock) { - return; - } - - for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { - if ((socket_ipv6_multicast_memberships[i].sock == sock) && - (socket_ipv6_multicast_memberships[i].if_idx == if_idx) && - ip6_addr_cmp(&socket_ipv6_multicast_memberships[i].multi_addr, multi_addr)) { - socket_ipv6_multicast_memberships[i].sock = NULL; - socket_ipv6_multicast_memberships[i].if_idx = NETIF_NO_INDEX; - ip6_addr_set_zero(&socket_ipv6_multicast_memberships[i].multi_addr); - break; - } - } - done_socket(sock); -} - -/** Drop all MLD6 memberships of a socket that were not dropped explicitly via setsockopt. - * - * ATTENTION: this function is NOT called from tcpip_thread (or under CORE_LOCK). - */ -static void -lwip_socket_drop_registered_mld6_memberships(int s) -{ - struct lwip_sock *sock = get_socket(s); - int i; - - if (!sock) { - return; - } - - for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { - if (socket_ipv6_multicast_memberships[i].sock == sock) { - ip_addr_t multi_addr; - u8_t if_idx; - - ip_addr_copy_from_ip6(multi_addr, socket_ipv6_multicast_memberships[i].multi_addr); - if_idx = socket_ipv6_multicast_memberships[i].if_idx; - - socket_ipv6_multicast_memberships[i].sock = NULL; - socket_ipv6_multicast_memberships[i].if_idx = NETIF_NO_INDEX; - ip6_addr_set_zero(&socket_ipv6_multicast_memberships[i].multi_addr); - - netconn_join_leave_group_netif(sock->conn, &multi_addr, if_idx, NETCONN_LEAVE); - } - } - done_socket(sock); -} -#endif /* LWIP_IPV6_MLD */ - -#endif /* LWIP_SOCKET */ +/** + * @file + * Sockets BSD-Like API module + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + * Improved by Marc Boucher and David Haas + * + */ + +#include "lwip/opt.h" + +#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/sockets.h" +#include "lwip/priv/sockets_priv.h" +#include "lwip/api.h" +#include "lwip/igmp.h" +#include "lwip/inet.h" +#include "lwip/tcp.h" +#include "lwip/raw.h" +#include "lwip/udp.h" +#include "lwip/memp.h" +#include "lwip/pbuf.h" +#include "lwip/netif.h" +#include "lwip/priv/tcpip_priv.h" +#include "lwip/mld6.h" +#if LWIP_CHECKSUM_ON_COPY +#include "lwip/inet_chksum.h" +#endif + +#if LWIP_COMPAT_SOCKETS == 2 && LWIP_POSIX_SOCKETS_IO_NAMES +#include +#endif + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +/* If the netconn API is not required publicly, then we include the necessary + files here to get the implementation */ +#if !LWIP_NETCONN +#undef LWIP_NETCONN +#define LWIP_NETCONN 1 +#include "api_msg.c" +#include "api_lib.c" +#include "netbuf.c" +#undef LWIP_NETCONN +#define LWIP_NETCONN 0 +#endif + +#define API_SELECT_CB_VAR_REF(name) API_VAR_REF(name) +#define API_SELECT_CB_VAR_DECLARE(name) API_VAR_DECLARE(struct lwip_select_cb, name) +#define API_SELECT_CB_VAR_ALLOC(name, retblock) API_VAR_ALLOC_EXT(struct lwip_select_cb, MEMP_SELECT_CB, name, retblock) +#define API_SELECT_CB_VAR_FREE(name) API_VAR_FREE(MEMP_SELECT_CB, name) + +#if LWIP_IPV4 +#define IP4ADDR_PORT_TO_SOCKADDR(sin, ipaddr, port) do { \ + (sin)->sin_len = sizeof(struct sockaddr_in); \ + (sin)->sin_family = AF_INET; \ + (sin)->sin_port = lwip_htons((port)); \ + inet_addr_from_ip4addr(&(sin)->sin_addr, ipaddr); \ + memset((sin)->sin_zero, 0, SIN_ZERO_LEN); }while(0) +#define SOCKADDR4_TO_IP4ADDR_PORT(sin, ipaddr, port) do { \ + inet_addr_to_ip4addr(ip_2_ip4(ipaddr), &((sin)->sin_addr)); \ + (port) = lwip_ntohs((sin)->sin_port); }while(0) +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +#define IP6ADDR_PORT_TO_SOCKADDR(sin6, ipaddr, port) do { \ + (sin6)->sin6_len = sizeof(struct sockaddr_in6); \ + (sin6)->sin6_family = AF_INET6; \ + (sin6)->sin6_port = lwip_htons((port)); \ + (sin6)->sin6_flowinfo = 0; \ + inet6_addr_from_ip6addr(&(sin6)->sin6_addr, ipaddr); \ + (sin6)->sin6_scope_id = ip6_addr_zone(ipaddr); }while(0) +#define SOCKADDR6_TO_IP6ADDR_PORT(sin6, ipaddr, port) do { \ + inet6_addr_to_ip6addr(ip_2_ip6(ipaddr), &((sin6)->sin6_addr)); \ + if (ip6_addr_has_scope(ip_2_ip6(ipaddr), IP6_UNKNOWN)) { \ + ip6_addr_set_zone(ip_2_ip6(ipaddr), (u8_t)((sin6)->sin6_scope_id)); \ + } \ + (port) = lwip_ntohs((sin6)->sin6_port); }while(0) +#endif /* LWIP_IPV6 */ + +#if LWIP_IPV4 && LWIP_IPV6 +static void sockaddr_to_ipaddr_port(const struct sockaddr *sockaddr, ip_addr_t *ipaddr, u16_t *port); + +#define IS_SOCK_ADDR_LEN_VALID(namelen) (((namelen) == sizeof(struct sockaddr_in)) || \ + ((namelen) == sizeof(struct sockaddr_in6))) +#define IS_SOCK_ADDR_TYPE_VALID(name) (((name)->sa_family == AF_INET) || \ + ((name)->sa_family == AF_INET6)) +#define SOCK_ADDR_TYPE_MATCH(name, sock) \ + ((((name)->sa_family == AF_INET) && !(NETCONNTYPE_ISIPV6((sock)->conn->type))) || \ + (((name)->sa_family == AF_INET6) && (NETCONNTYPE_ISIPV6((sock)->conn->type)))) +#define IPADDR_PORT_TO_SOCKADDR(sockaddr, ipaddr, port) do { \ + if (IP_IS_ANY_TYPE_VAL(*ipaddr) || IP_IS_V6_VAL(*ipaddr)) { \ + IP6ADDR_PORT_TO_SOCKADDR((struct sockaddr_in6*)(void*)(sockaddr), ip_2_ip6(ipaddr), port); \ + } else { \ + IP4ADDR_PORT_TO_SOCKADDR((struct sockaddr_in*)(void*)(sockaddr), ip_2_ip4(ipaddr), port); \ + } } while(0) +#define SOCKADDR_TO_IPADDR_PORT(sockaddr, ipaddr, port) sockaddr_to_ipaddr_port(sockaddr, ipaddr, &(port)) +#define DOMAIN_TO_NETCONN_TYPE(domain, type) (((domain) == AF_INET) ? \ + (type) : (enum netconn_type)((type) | NETCONN_TYPE_IPV6)) +#elif LWIP_IPV6 /* LWIP_IPV4 && LWIP_IPV6 */ +#define IS_SOCK_ADDR_LEN_VALID(namelen) ((namelen) == sizeof(struct sockaddr_in6)) +#define IS_SOCK_ADDR_TYPE_VALID(name) ((name)->sa_family == AF_INET6) +#define SOCK_ADDR_TYPE_MATCH(name, sock) 1 +#define IPADDR_PORT_TO_SOCKADDR(sockaddr, ipaddr, port) \ + IP6ADDR_PORT_TO_SOCKADDR((struct sockaddr_in6*)(void*)(sockaddr), ip_2_ip6(ipaddr), port) +#define SOCKADDR_TO_IPADDR_PORT(sockaddr, ipaddr, port) \ + SOCKADDR6_TO_IP6ADDR_PORT((const struct sockaddr_in6*)(const void*)(sockaddr), ipaddr, port) +#define DOMAIN_TO_NETCONN_TYPE(domain, netconn_type) (netconn_type) +#else /*-> LWIP_IPV4: LWIP_IPV4 && LWIP_IPV6 */ +#define IS_SOCK_ADDR_LEN_VALID(namelen) ((namelen) == sizeof(struct sockaddr_in)) +#define IS_SOCK_ADDR_TYPE_VALID(name) ((name)->sa_family == AF_INET) +#define SOCK_ADDR_TYPE_MATCH(name, sock) 1 +#define IPADDR_PORT_TO_SOCKADDR(sockaddr, ipaddr, port) \ + IP4ADDR_PORT_TO_SOCKADDR((struct sockaddr_in*)(void*)(sockaddr), ip_2_ip4(ipaddr), port) +#define SOCKADDR_TO_IPADDR_PORT(sockaddr, ipaddr, port) \ + SOCKADDR4_TO_IP4ADDR_PORT((const struct sockaddr_in*)(const void*)(sockaddr), ipaddr, port) +#define DOMAIN_TO_NETCONN_TYPE(domain, netconn_type) (netconn_type) +#endif /* LWIP_IPV6 */ + +#define IS_SOCK_ADDR_TYPE_VALID_OR_UNSPEC(name) (((name)->sa_family == AF_UNSPEC) || \ + IS_SOCK_ADDR_TYPE_VALID(name)) +#define SOCK_ADDR_TYPE_MATCH_OR_UNSPEC(name, sock) (((name)->sa_family == AF_UNSPEC) || \ + SOCK_ADDR_TYPE_MATCH(name, sock)) +#define IS_SOCK_ADDR_ALIGNED(name) ((((mem_ptr_t)(name)) % 4) == 0) + + +#define LWIP_SOCKOPT_CHECK_OPTLEN(sock, optlen, opttype) do { if ((optlen) < sizeof(opttype)) { done_socket(sock); return EINVAL; }}while(0) +#define LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, opttype) do { \ + LWIP_SOCKOPT_CHECK_OPTLEN(sock, optlen, opttype); \ + if ((sock)->conn == NULL) { done_socket(sock); return EINVAL; } }while(0) +#define LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, opttype) do { \ + LWIP_SOCKOPT_CHECK_OPTLEN(sock, optlen, opttype); \ + if (((sock)->conn == NULL) || ((sock)->conn->pcb.tcp == NULL)) { done_socket(sock); return EINVAL; } }while(0) +#define LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, opttype, netconntype) do { \ + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, opttype); \ + if (NETCONNTYPE_GROUP(netconn_type((sock)->conn)) != netconntype) { done_socket(sock); return ENOPROTOOPT; } }while(0) + + +#define LWIP_SETGETSOCKOPT_DATA_VAR_REF(name) API_VAR_REF(name) +#define LWIP_SETGETSOCKOPT_DATA_VAR_DECLARE(name) API_VAR_DECLARE(struct lwip_setgetsockopt_data, name) +#define LWIP_SETGETSOCKOPT_DATA_VAR_FREE(name) API_VAR_FREE(MEMP_SOCKET_SETGETSOCKOPT_DATA, name) +#if LWIP_MPU_COMPATIBLE +#define LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(name, sock) do { \ + name = (struct lwip_setgetsockopt_data *)memp_malloc(MEMP_SOCKET_SETGETSOCKOPT_DATA); \ + if (name == NULL) { \ + sock_set_errno(sock, ENOMEM); \ + done_socket(sock); \ + return -1; \ + } }while(0) +#else /* LWIP_MPU_COMPATIBLE */ +#define LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(name, sock) +#endif /* LWIP_MPU_COMPATIBLE */ + +#if LWIP_SO_SNDRCVTIMEO_NONSTANDARD +#define LWIP_SO_SNDRCVTIMEO_OPTTYPE int +#define LWIP_SO_SNDRCVTIMEO_SET(optval, val) (*(int *)(optval) = (val)) +#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval) ((long)*(const int*)(optval)) +#else +#define LWIP_SO_SNDRCVTIMEO_OPTTYPE struct timeval +#define LWIP_SO_SNDRCVTIMEO_SET(optval, val) do { \ + u32_t loc = (val); \ + ((struct timeval *)(optval))->tv_sec = (long)((loc) / 1000U); \ + ((struct timeval *)(optval))->tv_usec = (long)(((loc) % 1000U) * 1000U); }while(0) +#define LWIP_SO_SNDRCVTIMEO_GET_MS(optval) ((((const struct timeval *)(optval))->tv_sec * 1000) + (((const struct timeval *)(optval))->tv_usec / 1000)) +#endif + + +/** A struct sockaddr replacement that has the same alignment as sockaddr_in/ + * sockaddr_in6 if instantiated. + */ +union sockaddr_aligned { + struct sockaddr sa; +#if LWIP_IPV6 + struct sockaddr_in6 sin6; +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 + struct sockaddr_in sin; +#endif /* LWIP_IPV4 */ +}; + +/* Define the number of IPv4 multicast memberships, default is one per socket */ +#ifndef LWIP_SOCKET_MAX_MEMBERSHIPS +#define LWIP_SOCKET_MAX_MEMBERSHIPS NUM_SOCKETS +#endif + +#if LWIP_IGMP +/* This is to keep track of IP_ADD_MEMBERSHIP calls to drop the membership when + a socket is closed */ +struct lwip_socket_multicast_pair { + /** the socket */ + struct lwip_sock *sock; + /** the interface address */ + ip4_addr_t if_addr; + /** the group address */ + ip4_addr_t multi_addr; +}; + +static struct lwip_socket_multicast_pair socket_ipv4_multicast_memberships[LWIP_SOCKET_MAX_MEMBERSHIPS]; + +static int lwip_socket_register_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr); +static void lwip_socket_unregister_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr); +static void lwip_socket_drop_registered_memberships(int s); +#endif /* LWIP_IGMP */ + +#if LWIP_IPV6_MLD +/* This is to keep track of IP_JOIN_GROUP calls to drop the membership when + a socket is closed */ +struct lwip_socket_multicast_mld6_pair { + /** the socket */ + struct lwip_sock *sock; + /** the interface index */ + u8_t if_idx; + /** the group address */ + ip6_addr_t multi_addr; +}; + +static struct lwip_socket_multicast_mld6_pair socket_ipv6_multicast_memberships[LWIP_SOCKET_MAX_MEMBERSHIPS]; + +static int lwip_socket_register_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr); +static void lwip_socket_unregister_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr); +static void lwip_socket_drop_registered_mld6_memberships(int s); +#endif /* LWIP_IPV6_MLD */ + +/** The global array of available sockets */ +static struct lwip_sock sockets[NUM_SOCKETS]; + +#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL +#if LWIP_TCPIP_CORE_LOCKING +/* protect the select_cb_list using core lock */ +#define LWIP_SOCKET_SELECT_DECL_PROTECT(lev) +#define LWIP_SOCKET_SELECT_PROTECT(lev) LOCK_TCPIP_CORE() +#define LWIP_SOCKET_SELECT_UNPROTECT(lev) UNLOCK_TCPIP_CORE() +#else /* LWIP_TCPIP_CORE_LOCKING */ +/* protect the select_cb_list using SYS_LIGHTWEIGHT_PROT */ +#define LWIP_SOCKET_SELECT_DECL_PROTECT(lev) SYS_ARCH_DECL_PROTECT(lev) +#define LWIP_SOCKET_SELECT_PROTECT(lev) SYS_ARCH_PROTECT(lev) +#define LWIP_SOCKET_SELECT_UNPROTECT(lev) SYS_ARCH_UNPROTECT(lev) +/** This counter is increased from lwip_select when the list is changed + and checked in select_check_waiters to see if it has changed. */ +static volatile int select_cb_ctr; +#endif /* LWIP_TCPIP_CORE_LOCKING */ +/** The global list of tasks waiting for select */ +static struct lwip_select_cb *select_cb_list; +#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ + +#define sock_set_errno(sk, e) do { \ + const int sockerr = (e); \ + set_errno(sockerr); \ +} while (0) + +/* Forward declaration of some functions */ +#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL +static void event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len); +#define DEFAULT_SOCKET_EVENTCB event_callback +static void select_check_waiters(int s, int has_recvevent, int has_sendevent, int has_errevent); +#else +#define DEFAULT_SOCKET_EVENTCB NULL +#endif +#if !LWIP_TCPIP_CORE_LOCKING +static void lwip_getsockopt_callback(void *arg); +static void lwip_setsockopt_callback(void *arg); +#endif +static int lwip_getsockopt_impl(int s, int level, int optname, void *optval, socklen_t *optlen); +static int lwip_setsockopt_impl(int s, int level, int optname, const void *optval, socklen_t optlen); +static int free_socket_locked(struct lwip_sock *sock, int is_tcp, struct netconn **conn, + union lwip_sock_lastdata *lastdata); +static void free_socket_free_elements(int is_tcp, struct netconn *conn, union lwip_sock_lastdata *lastdata); + +#if LWIP_IPV4 && LWIP_IPV6 +static void +sockaddr_to_ipaddr_port(const struct sockaddr *sockaddr, ip_addr_t *ipaddr, u16_t *port) +{ + if ((sockaddr->sa_family) == AF_INET6) { + SOCKADDR6_TO_IP6ADDR_PORT((const struct sockaddr_in6 *)(const void *)(sockaddr), ipaddr, *port); + ipaddr->type = IPADDR_TYPE_V6; + } else { + SOCKADDR4_TO_IP4ADDR_PORT((const struct sockaddr_in *)(const void *)(sockaddr), ipaddr, *port); + ipaddr->type = IPADDR_TYPE_V4; + } +} +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + +/** LWIP_NETCONN_SEM_PER_THREAD==1: initialize thread-local semaphore */ +void +lwip_socket_thread_init(void) +{ + netconn_thread_init(); +} + +/** LWIP_NETCONN_SEM_PER_THREAD==1: destroy thread-local semaphore */ +void +lwip_socket_thread_cleanup(void) +{ + netconn_thread_cleanup(); +} + +#if LWIP_NETCONN_FULLDUPLEX +/* Thread-safe increment of sock->fd_used, with overflow check */ +static int +sock_inc_used(struct lwip_sock *sock) +{ + int ret; + SYS_ARCH_DECL_PROTECT(lev); + + LWIP_ASSERT("sock != NULL", sock != NULL); + + SYS_ARCH_PROTECT(lev); + if (sock->fd_free_pending) { + /* prevent new usage of this socket if free is pending */ + ret = 0; + } else { + ++sock->fd_used; + ret = 1; + LWIP_ASSERT("sock->fd_used != 0", sock->fd_used != 0); + } + SYS_ARCH_UNPROTECT(lev); + return ret; +} + +/* Like sock_inc_used(), but called under SYS_ARCH_PROTECT lock. */ +static int +sock_inc_used_locked(struct lwip_sock *sock) +{ + LWIP_ASSERT("sock != NULL", sock != NULL); + + if (sock->fd_free_pending) { + LWIP_ASSERT("sock->fd_used != 0", sock->fd_used != 0); + return 0; + } + + ++sock->fd_used; + LWIP_ASSERT("sock->fd_used != 0", sock->fd_used != 0); + return 1; +} + +/* In full-duplex mode,sock->fd_used != 0 prevents a socket descriptor from being + * released (and possibly reused) when used from more than one thread + * (e.g. read-while-write or close-while-write, etc) + * This function is called at the end of functions using (try)get_socket*(). + */ +static void +done_socket(struct lwip_sock *sock) +{ + int freed = 0; + int is_tcp = 0; + struct netconn *conn = NULL; + union lwip_sock_lastdata lastdata; + SYS_ARCH_DECL_PROTECT(lev); + LWIP_ASSERT("sock != NULL", sock != NULL); + + SYS_ARCH_PROTECT(lev); + LWIP_ASSERT("sock->fd_used > 0", sock->fd_used > 0); + if (--sock->fd_used == 0) { + if (sock->fd_free_pending) { + /* free the socket */ + sock->fd_used = 1; + is_tcp = sock->fd_free_pending & LWIP_SOCK_FD_FREE_TCP; + freed = free_socket_locked(sock, is_tcp, &conn, &lastdata); + } + } + SYS_ARCH_UNPROTECT(lev); + + if (freed) { + free_socket_free_elements(is_tcp, conn, &lastdata); + } +} + +#else /* LWIP_NETCONN_FULLDUPLEX */ +#define sock_inc_used(sock) 1 +#define sock_inc_used_locked(sock) 1 +#define done_socket(sock) +#endif /* LWIP_NETCONN_FULLDUPLEX */ + +//tmp +#define EMSGSIZE 90 /* Message too long */ +#define ENOTCONN 107 /* Transport endpoint is not connected */ +#define ENOPROTOOPT 92 /* Protocol not available */ +#define ENOSYS 38 /* Function not implemented */ +#define EAFNOSUPPORT 97 /* Address family not supported by protocol */ + + +/* Translate a socket 'int' into a pointer (only fails if the index is invalid) */ +static struct lwip_sock * +tryget_socket_unconn_nouse(int fd) +{ + int s = fd - LWIP_SOCKET_OFFSET; + if ((s < 0) || (s >= NUM_SOCKETS)) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("tryget_socket_unconn(%d): invalid\n", fd)); + return NULL; + } + return &sockets[s]; +} + +struct lwip_sock * +lwip_socket_dbg_get_socket(int fd) +{ + return tryget_socket_unconn_nouse(fd); +} + +/* Translate a socket 'int' into a pointer (only fails if the index is invalid) */ +static struct lwip_sock * +tryget_socket_unconn(int fd) +{ + struct lwip_sock *ret = tryget_socket_unconn_nouse(fd); + if (ret != NULL) { + if (!sock_inc_used(ret)) { + return NULL; + } + } + return ret; +} + +/* Like tryget_socket_unconn(), but called under SYS_ARCH_PROTECT lock. */ +static struct lwip_sock * +tryget_socket_unconn_locked(int fd) +{ + struct lwip_sock *ret = tryget_socket_unconn_nouse(fd); + if (ret != NULL) { + if (!sock_inc_used_locked(ret)) { + return NULL; + } + } + return ret; +} + +/** + * Same as get_socket but doesn't set errno + * + * @param fd externally used socket index + * @return struct lwip_sock for the socket or NULL if not found + */ +static struct lwip_sock * +tryget_socket(int fd) +{ + struct lwip_sock *sock = tryget_socket_unconn(fd); + if (sock != NULL) { + if (sock->conn) { + return sock; + } + done_socket(sock); + } + return NULL; +} + +/** + * Map a externally used socket index to the internal socket representation. + * + * @param fd externally used socket index + * @return struct lwip_sock for the socket or NULL if not found + */ +static struct lwip_sock * +get_socket(int fd) +{ + struct lwip_sock *sock = tryget_socket(fd); + if (!sock) { + if ((fd < LWIP_SOCKET_OFFSET) || (fd >= (LWIP_SOCKET_OFFSET + NUM_SOCKETS))) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("get_socket(%d): invalid\n", fd)); + } + set_errno(EBADF); + return NULL; + } + return sock; +} + +/** + * Allocate a new socket for a given netconn. + * + * @param newconn the netconn for which to allocate a socket + * @param accepted 1 if socket has been created by accept(), + * 0 if socket has been created by socket() + * @return the index of the new socket; -1 on error + */ +static int +alloc_socket(struct netconn *newconn, int accepted) +{ + int i; + SYS_ARCH_DECL_PROTECT(lev); + LWIP_UNUSED_ARG(accepted); + + /* allocate a new socket identifier */ + for (i = 0; i < NUM_SOCKETS; ++i) { + /* Protect socket array */ + SYS_ARCH_PROTECT(lev); + if (!sockets[i].conn) { +#if LWIP_NETCONN_FULLDUPLEX + if (sockets[i].fd_used) { + SYS_ARCH_UNPROTECT(lev); + continue; + } + sockets[i].fd_used = 1; + sockets[i].fd_free_pending = 0; +#endif + sockets[i].conn = newconn; + /* The socket is not yet known to anyone, so no need to protect + after having marked it as used. */ + SYS_ARCH_UNPROTECT(lev); + sockets[i].lastdata.pbuf = NULL; +#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL + LWIP_ASSERT("sockets[i].select_waiting == 0", sockets[i].select_waiting == 0); + sockets[i].rcvevent = 0; + /* TCP sendbuf is empty, but the socket is not yet writable until connected + * (unless it has been created by accept()). */ + sockets[i].sendevent = (NETCONNTYPE_GROUP(newconn->type) == NETCONN_TCP ? (accepted != 0) : 1); + sockets[i].errevent = 0; +#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ + return i + LWIP_SOCKET_OFFSET; + } + SYS_ARCH_UNPROTECT(lev); + } + return -1; +} + +/** Free a socket (under lock) + * + * @param sock the socket to free + * @param is_tcp != 0 for TCP sockets, used to free lastdata + * @param conn the socekt's netconn is stored here, must be freed externally + * @param lastdata lastdata is stored here, must be freed externally + */ +static int +free_socket_locked(struct lwip_sock *sock, int is_tcp, struct netconn **conn, + union lwip_sock_lastdata *lastdata) +{ +#if LWIP_NETCONN_FULLDUPLEX + LWIP_ASSERT("sock->fd_used > 0", sock->fd_used > 0); + sock->fd_used--; + if (sock->fd_used > 0) { + sock->fd_free_pending = LWIP_SOCK_FD_FREE_FREE | (is_tcp ? LWIP_SOCK_FD_FREE_TCP : 0); + return 0; + } +#else /* LWIP_NETCONN_FULLDUPLEX */ + LWIP_UNUSED_ARG(is_tcp); +#endif /* LWIP_NETCONN_FULLDUPLEX */ + + *lastdata = sock->lastdata; + sock->lastdata.pbuf = NULL; + *conn = sock->conn; + sock->conn = NULL; + return 1; +} + +/** Free a socket's leftover members. + */ +static void +free_socket_free_elements(int is_tcp, struct netconn *conn, union lwip_sock_lastdata *lastdata) +{ + if (lastdata->pbuf != NULL) { + if (is_tcp) { + pbuf_free(lastdata->pbuf); + } else { + netbuf_delete(lastdata->netbuf); + } + } + if (conn != NULL) { + /* netconn_prepare_delete() has already been called, here we only free the conn */ + netconn_delete(conn); + } +} + +/** Free a socket. The socket's netconn must have been + * delete before! + * + * @param sock the socket to free + * @param is_tcp != 0 for TCP sockets, used to free lastdata + */ +static void +free_socket(struct lwip_sock *sock, int is_tcp) +{ + int freed; + struct netconn *conn; + union lwip_sock_lastdata lastdata; + SYS_ARCH_DECL_PROTECT(lev); + + /* Protect socket array */ + SYS_ARCH_PROTECT(lev); + + freed = free_socket_locked(sock, is_tcp, &conn, &lastdata); + SYS_ARCH_UNPROTECT(lev); + /* don't use 'sock' after this line, as another task might have allocated it */ + + if (freed) { + free_socket_free_elements(is_tcp, conn, &lastdata); + } +} + +/* Below this, the well-known socket functions are implemented. + * Use google.com or opengroup.org to get a good description :-) + * + * Exceptions are documented! + */ + +int +lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen) +{ + struct lwip_sock *sock, *nsock; + struct netconn *newconn; + ip_addr_t naddr; + u16_t port = 0; + int newsock; + err_t err; + int recvevent; + SYS_ARCH_DECL_PROTECT(lev); + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d)...\n", s)); + sock = get_socket(s); + if (!sock) { + return -1; + } + + /* wait for a new connection */ + err = netconn_accept(sock->conn, &newconn); + if (err != ERR_OK) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): netconn_acept failed, err=%d\n", s, err)); + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { + sock_set_errno(sock, EOPNOTSUPP); + } else if (err == ERR_CLSD) { + sock_set_errno(sock, EINVAL); + } else { + sock_set_errno(sock, err_to_errno(err)); + } + done_socket(sock); + return -1; + } + LWIP_ASSERT("newconn != NULL", newconn != NULL); + + newsock = alloc_socket(newconn, 1); + if (newsock == -1) { + netconn_delete(newconn); + sock_set_errno(sock, ENFILE); + done_socket(sock); + return -1; + } + LWIP_ASSERT("invalid socket index", (newsock >= LWIP_SOCKET_OFFSET) && (newsock < NUM_SOCKETS + LWIP_SOCKET_OFFSET)); + nsock = &sockets[newsock - LWIP_SOCKET_OFFSET]; + + /* See event_callback: If data comes in right away after an accept, even + * though the server task might not have created a new socket yet. + * In that case, newconn->socket is counted down (newconn->socket--), + * so nsock->rcvevent is >= 1 here! + */ + SYS_ARCH_PROTECT(lev); + recvevent = (s16_t)(-1 - newconn->socket); + newconn->socket = newsock; + SYS_ARCH_UNPROTECT(lev); + + if (newconn->callback) { + LOCK_TCPIP_CORE(); + while (recvevent > 0) { + recvevent--; + newconn->callback(newconn, NETCONN_EVT_RCVPLUS, 0); + } + UNLOCK_TCPIP_CORE(); + } + + /* Note that POSIX only requires us to check addr is non-NULL. addrlen must + * not be NULL if addr is valid. + */ + if ((addr != NULL) && (addrlen != NULL)) { + union sockaddr_aligned tempaddr; + /* get the IP address and port of the remote host */ + err = netconn_peer(newconn, &naddr, &port); + if (err != ERR_OK) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d): netconn_peer failed, err=%d\n", s, err)); + netconn_delete(newconn); + free_socket(nsock, 1); + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return -1; + } + + IPADDR_PORT_TO_SOCKADDR(&tempaddr, &naddr, port); + if (*addrlen > tempaddr.sa.sa_len) { + *addrlen = tempaddr.sa.sa_len; + } + MEMCPY(addr, &tempaddr, *addrlen); + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d addr=", s, newsock)); + ip_addr_debug_print_val(SOCKETS_DEBUG, naddr); + LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F"\n", port)); + } else { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_accept(%d) returning new sock=%d", s, newsock)); + } + + sock_set_errno(sock, 0); + done_socket(sock); + done_socket(nsock); + return newsock; +} + +int +lwip_bind(int s, const struct sockaddr *name, socklen_t namelen) +{ + struct lwip_sock *sock; + ip_addr_t local_addr; + u16_t local_port; + err_t err; + + sock = get_socket(s); + if (!sock) { + return -1; + } + + if (!SOCK_ADDR_TYPE_MATCH(name, sock)) { + /* sockaddr does not match socket type (IPv4/IPv6) */ + sock_set_errno(sock, err_to_errno(ERR_VAL)); + done_socket(sock); + return -1; + } + + /* check size, family and alignment of 'name' */ + LWIP_ERROR("lwip_bind: invalid address", (IS_SOCK_ADDR_LEN_VALID(namelen) && + IS_SOCK_ADDR_TYPE_VALID(name) && IS_SOCK_ADDR_ALIGNED(name)), + sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); + LWIP_UNUSED_ARG(namelen); + + SOCKADDR_TO_IPADDR_PORT(name, &local_addr, local_port); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d, addr=", s)); + ip_addr_debug_print_val(SOCKETS_DEBUG, local_addr); + LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", local_port)); + +#if LWIP_IPV4 && LWIP_IPV6 + /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ + if (IP_IS_V6_VAL(local_addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&local_addr))) { + unmap_ipv4_mapped_ipv6(ip_2_ip4(&local_addr), ip_2_ip6(&local_addr)); + IP_SET_TYPE_VAL(local_addr, IPADDR_TYPE_V4); + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + err = netconn_bind(sock->conn, &local_addr, local_port); + + if (err != ERR_OK) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) failed, err=%d\n", s, err)); + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return -1; + } + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_bind(%d) succeeded\n", s)); + sock_set_errno(sock, 0); + done_socket(sock); + return 0; +} + +int +lwip_close(int s) +{ + struct lwip_sock *sock; + int is_tcp = 0; + err_t err; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_close(%d)\n", s)); + + sock = get_socket(s); + if (!sock) { + return -1; + } + + if (sock->conn != NULL) { + is_tcp = NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP; + } else { + LWIP_ASSERT("sock->lastdata == NULL", sock->lastdata.pbuf == NULL); + } + +#if LWIP_IGMP + /* drop all possibly joined IGMP memberships */ + lwip_socket_drop_registered_memberships(s); +#endif /* LWIP_IGMP */ +#if LWIP_IPV6_MLD + /* drop all possibly joined MLD6 memberships */ + lwip_socket_drop_registered_mld6_memberships(s); +#endif /* LWIP_IPV6_MLD */ + + err = netconn_prepare_delete(sock->conn); + if (err != ERR_OK) { + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return -1; + } + + free_socket(sock, is_tcp); + set_errno(0); + return 0; +} + +int +lwip_connect(int s, const struct sockaddr *name, socklen_t namelen) +{ + struct lwip_sock *sock; + err_t err; + + sock = get_socket(s); + if (!sock) { + return -1; + } + + if (!SOCK_ADDR_TYPE_MATCH_OR_UNSPEC(name, sock)) { + /* sockaddr does not match socket type (IPv4/IPv6) */ + sock_set_errno(sock, err_to_errno(ERR_VAL)); + done_socket(sock); + return -1; + } + + LWIP_UNUSED_ARG(namelen); + if (name->sa_family == AF_UNSPEC) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, AF_UNSPEC)\n", s)); + err = netconn_disconnect(sock->conn); + } else { + ip_addr_t remote_addr; + u16_t remote_port; + + /* check size, family and alignment of 'name' */ + LWIP_ERROR("lwip_connect: invalid address", IS_SOCK_ADDR_LEN_VALID(namelen) && + IS_SOCK_ADDR_TYPE_VALID_OR_UNSPEC(name) && IS_SOCK_ADDR_ALIGNED(name), + sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); + + SOCKADDR_TO_IPADDR_PORT(name, &remote_addr, remote_port); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d, addr=", s)); + ip_addr_debug_print_val(SOCKETS_DEBUG, remote_addr); + LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", remote_port)); + +#if LWIP_IPV4 && LWIP_IPV6 + /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ + if (IP_IS_V6_VAL(remote_addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&remote_addr))) { + unmap_ipv4_mapped_ipv6(ip_2_ip4(&remote_addr), ip_2_ip6(&remote_addr)); + IP_SET_TYPE_VAL(remote_addr, IPADDR_TYPE_V4); + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + err = netconn_connect(sock->conn, &remote_addr, remote_port); + } + + if (err != ERR_OK) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) failed, err=%d\n", s, err)); + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return -1; + } + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_connect(%d) succeeded\n", s)); + sock_set_errno(sock, 0); + done_socket(sock); + return 0; +} + +/** + * Set a socket into listen mode. + * The socket may not have been used for another connection previously. + * + * @param s the socket to set to listening mode + * @param backlog (ATTENTION: needs TCP_LISTEN_BACKLOG=1) + * @return 0 on success, non-zero on failure + */ +int +lwip_listen(int s, int backlog) +{ + struct lwip_sock *sock; + err_t err; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d, backlog=%d)\n", s, backlog)); + + sock = get_socket(s); + if (!sock) { + return -1; + } + + /* limit the "backlog" parameter to fit in an u8_t */ + backlog = LWIP_MIN(LWIP_MAX(backlog, 0), 0xff); + + err = netconn_listen_with_backlog(sock->conn, (u8_t)backlog); + + if (err != ERR_OK) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_listen(%d) failed, err=%d\n", s, err)); + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { + sock_set_errno(sock, EOPNOTSUPP); + } else { + sock_set_errno(sock, err_to_errno(err)); + } + done_socket(sock); + return -1; + } + + sock_set_errno(sock, 0); + done_socket(sock); + return 0; +} + +#if LWIP_TCP +/* Helper function to loop over receiving pbufs from netconn + * until "len" bytes are received or we're otherwise done. + * Keeps sock->lastdata for peeking or partly copying. + */ +static ssize_t +lwip_recv_tcp(struct lwip_sock *sock, void *mem, size_t len, int flags) +{ + u8_t apiflags = NETCONN_NOAUTORCVD; + ssize_t recvd = 0; + ssize_t recv_left = (len <= SSIZE_MAX) ? (ssize_t)len : SSIZE_MAX; + + LWIP_ASSERT("no socket given", sock != NULL); + LWIP_ASSERT("this should be checked internally", NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP); + + if (flags & MSG_DONTWAIT) { + apiflags |= NETCONN_DONTBLOCK; + } + + do { + struct pbuf *p; + err_t err; + u16_t copylen; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: top while sock->lastdata=%p\n", (void *)sock->lastdata.pbuf)); + /* Check if there is data left from the last recv operation. */ + if (sock->lastdata.pbuf) { + p = sock->lastdata.pbuf; + } else { + /* No data was left from the previous operation, so we try to get + some from the network. */ + err = netconn_recv_tcp_pbuf_flags(sock->conn, &p, apiflags); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: netconn_recv err=%d, pbuf=%p\n", + err, (void *)p)); + + if (err != ERR_OK) { + if (recvd > 0) { + /* already received data, return that (this trusts in getting the same error from + netconn layer again next time netconn_recv is called) */ + goto lwip_recv_tcp_done; + } + /* We should really do some error checking here. */ + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: p == NULL, error is \"%s\"!\n", + lwip_strerr(err))); + sock_set_errno(sock, err_to_errno(err)); + if (err == ERR_CLSD) { + return 0; + } else { + return -1; + } + } + LWIP_ASSERT("p != NULL", p != NULL); + sock->lastdata.pbuf = p; + } + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: buflen=%"U16_F" recv_left=%d off=%d\n", + p->tot_len, (int)recv_left, (int)recvd)); + + if (recv_left > p->tot_len) { + copylen = p->tot_len; + } else { + copylen = (u16_t)recv_left; + } + if (recvd + copylen < recvd) { + /* overflow */ + copylen = (u16_t)(SSIZE_MAX - recvd); + } + + /* copy the contents of the received buffer into + the supplied memory pointer mem */ + pbuf_copy_partial(p, (u8_t *)mem + recvd, copylen, 0); + + recvd += copylen; + + /* TCP combines multiple pbufs for one recv */ + LWIP_ASSERT("invalid copylen, len would underflow", recv_left >= copylen); + recv_left -= copylen; + + /* Unless we peek the incoming message... */ + if ((flags & MSG_PEEK) == 0) { + /* ... check if there is data left in the pbuf */ + LWIP_ASSERT("invalid copylen", p->tot_len >= copylen); + if (p->tot_len - copylen > 0) { + /* If so, it should be saved in the sock structure for the next recv call. + We store the pbuf but hide/free the consumed data: */ + sock->lastdata.pbuf = pbuf_free_header(p, copylen); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: lastdata now pbuf=%p\n", (void *)sock->lastdata.pbuf)); + } else { + sock->lastdata.pbuf = NULL; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recv_tcp: deleting pbuf=%p\n", (void *)p)); + pbuf_free(p); + } + } + /* once we have some data to return, only add more if we don't need to wait */ + apiflags |= NETCONN_DONTBLOCK | NETCONN_NOFIN; + /* @todo: do we need to support peeking more than one pbuf? */ + } while ((recv_left > 0) && !(flags & MSG_PEEK)); +lwip_recv_tcp_done: + if ((recvd > 0) && !(flags & MSG_PEEK)) { + /* ensure window update after copying all data */ + netconn_tcp_recvd(sock->conn, (size_t)recvd); + } + sock_set_errno(sock, 0); + return recvd; +} +#endif + +/* Convert a netbuf's address data to struct sockaddr */ +static int +lwip_sock_make_addr(struct netconn *conn, ip_addr_t *fromaddr, u16_t port, + struct sockaddr *from, socklen_t *fromlen) +{ + int truncated = 0; + union sockaddr_aligned saddr; + + LWIP_UNUSED_ARG(conn); + + LWIP_ASSERT("fromaddr != NULL", fromaddr != NULL); + LWIP_ASSERT("from != NULL", from != NULL); + LWIP_ASSERT("fromlen != NULL", fromlen != NULL); + +#if LWIP_IPV4 && LWIP_IPV6 + /* Dual-stack: Map IPv4 addresses to IPv4 mapped IPv6 */ + if (NETCONNTYPE_ISIPV6(netconn_type(conn)) && IP_IS_V4(fromaddr)) { + ip4_2_ipv4_mapped_ipv6(ip_2_ip6(fromaddr), ip_2_ip4(fromaddr)); + IP_SET_TYPE(fromaddr, IPADDR_TYPE_V6); + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + IPADDR_PORT_TO_SOCKADDR(&saddr, fromaddr, port); + if (*fromlen < saddr.sa.sa_len) { + truncated = 1; + } else if (*fromlen > saddr.sa.sa_len) { + *fromlen = saddr.sa.sa_len; + } + MEMCPY(from, &saddr, *fromlen); + return truncated; +} + +#if LWIP_TCP +/* Helper function to get a tcp socket's remote address info */ +static int +lwip_recv_tcp_from(struct lwip_sock *sock, struct sockaddr *from, socklen_t *fromlen, const char *dbg_fn, int dbg_s, ssize_t dbg_ret) +{ + if (sock == NULL) { + return 0; + } + LWIP_UNUSED_ARG(dbg_fn); + LWIP_UNUSED_ARG(dbg_s); + LWIP_UNUSED_ARG(dbg_ret); + +#if !SOCKETS_DEBUG + if (from && fromlen) +#endif /* !SOCKETS_DEBUG */ + { + /* get remote addr/port from tcp_pcb */ + u16_t port; + ip_addr_t tmpaddr; + netconn_getaddr(sock->conn, &tmpaddr, &port, 0); + LWIP_DEBUGF(SOCKETS_DEBUG, ("%s(%d): addr=", dbg_fn, dbg_s)); + ip_addr_debug_print_val(SOCKETS_DEBUG, tmpaddr); + LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F" len=%d\n", port, (int)dbg_ret)); + if (from && fromlen) { + return lwip_sock_make_addr(sock->conn, &tmpaddr, port, from, fromlen); + } + } + return 0; +} +#endif + +/* Helper function to receive a netbuf from a udp or raw netconn. + * Keeps sock->lastdata for peeking. + */ +static err_t +lwip_recvfrom_udp_raw(struct lwip_sock *sock, int flags, struct msghdr *msg, u16_t *datagram_len, int dbg_s) +{ + struct netbuf *buf; + u8_t apiflags; + err_t err; + u16_t buflen, copylen, copied; + int i; + + LWIP_UNUSED_ARG(dbg_s); + LWIP_ERROR("lwip_recvfrom_udp_raw: invalid arguments", (msg->msg_iov != NULL) || (msg->msg_iovlen <= 0), return ERR_ARG;); + + if (flags & MSG_DONTWAIT) { + apiflags = NETCONN_DONTBLOCK; + } else { + apiflags = 0; + } + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw[UDP/RAW]: top sock->lastdata=%p\n", (void *)sock->lastdata.netbuf)); + /* Check if there is data left from the last recv operation. */ + buf = sock->lastdata.netbuf; + if (buf == NULL) { + /* No data was left from the previous operation, so we try to get + some from the network. */ + err = netconn_recv_udp_raw_netbuf_flags(sock->conn, &buf, apiflags); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw[UDP/RAW]: netconn_recv err=%d, netbuf=%p\n", + err, (void *)buf)); + + if (err != ERR_OK) { + return err; + } + LWIP_ASSERT("buf != NULL", buf != NULL); + sock->lastdata.netbuf = buf; + } + buflen = buf->p->tot_len; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw: buflen=%"U16_F"\n", buflen)); + + copied = 0; + /* copy the pbuf payload into the iovs */ + for (i = 0; (i < msg->msg_iovlen) && (copied < buflen); i++) { + u16_t len_left = (u16_t)(buflen - copied); + if (msg->msg_iov[i].iov_len > len_left) { + copylen = len_left; + } else { + copylen = (u16_t)msg->msg_iov[i].iov_len; + } + + /* copy the contents of the received buffer into + the supplied memory buffer */ + pbuf_copy_partial(buf->p, (u8_t *)msg->msg_iov[i].iov_base, copylen, copied); + copied = (u16_t)(copied + copylen); + } + + /* Check to see from where the data was.*/ +#if !SOCKETS_DEBUG + if (msg->msg_name && msg->msg_namelen) +#endif /* !SOCKETS_DEBUG */ + { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom_udp_raw(%d): addr=", dbg_s)); + ip_addr_debug_print_val(SOCKETS_DEBUG, *netbuf_fromaddr(buf)); + LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F" len=%d\n", netbuf_fromport(buf), copied)); + if (msg->msg_name && msg->msg_namelen) { + lwip_sock_make_addr(sock->conn, netbuf_fromaddr(buf), netbuf_fromport(buf), + (struct sockaddr *)msg->msg_name, &msg->msg_namelen); + } + } + + /* Initialize flag output */ + msg->msg_flags = 0; + + if (msg->msg_control) { + u8_t wrote_msg = 0; +#if LWIP_NETBUF_RECVINFO + /* Check if packet info was recorded */ + if (buf->flags & NETBUF_FLAG_DESTADDR) { + if (IP_IS_V4(&buf->toaddr)) { +#if LWIP_IPV4 + if (msg->msg_controllen >= CMSG_SPACE(sizeof(struct in_pktinfo))) { + struct cmsghdr *chdr = CMSG_FIRSTHDR(msg); /* This will always return a header!! */ + struct in_pktinfo *pkti = (struct in_pktinfo *)CMSG_DATA(chdr); + chdr->cmsg_level = IPPROTO_IP; + chdr->cmsg_type = IP_PKTINFO; + chdr->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo)); + pkti->ipi_ifindex = buf->p->if_idx; + inet_addr_from_ip4addr(&pkti->ipi_addr, ip_2_ip4(netbuf_destaddr(buf))); + msg->msg_controllen = CMSG_SPACE(sizeof(struct in_pktinfo)); + wrote_msg = 1; + } else { + msg->msg_flags |= MSG_CTRUNC; + } +#endif /* LWIP_IPV4 */ + } + } +#endif /* LWIP_NETBUF_RECVINFO */ + + if (!wrote_msg) { + msg->msg_controllen = 0; + } + } + + /* If we don't peek the incoming message: zero lastdata pointer and free the netbuf */ + if ((flags & MSG_PEEK) == 0) { + sock->lastdata.netbuf = NULL; + netbuf_delete(buf); + } + if (datagram_len) { + *datagram_len = buflen; + } + return ERR_OK; +} + +ssize_t +lwip_recvfrom(int s, void *mem, size_t len, int flags, + struct sockaddr *from, socklen_t *fromlen) +{ + struct lwip_sock *sock; + ssize_t ret; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom(%d, %p, %"SZT_F", 0x%x, ..)\n", s, mem, len, flags)); + sock = get_socket(s); + if (!sock) { + return -1; + } +#if LWIP_TCP + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { + ret = lwip_recv_tcp(sock, mem, len, flags); + lwip_recv_tcp_from(sock, from, fromlen, "lwip_recvfrom", s, ret); + done_socket(sock); + return ret; + } else +#endif + { + u16_t datagram_len = 0; + struct iovec vec; + struct msghdr msg; + err_t err; + vec.iov_base = mem; + vec.iov_len = len; + msg.msg_control = NULL; + msg.msg_controllen = 0; + msg.msg_flags = 0; + msg.msg_iov = &vec; + msg.msg_iovlen = 1; + msg.msg_name = from; + msg.msg_namelen = (fromlen ? *fromlen : 0); + err = lwip_recvfrom_udp_raw(sock, flags, &msg, &datagram_len, s); + if (err != ERR_OK) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvfrom[UDP/RAW](%d): buf == NULL, error is \"%s\"!\n", + s, lwip_strerr(err))); + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return -1; + } + ret = (ssize_t)LWIP_MIN(LWIP_MIN(len, datagram_len), SSIZE_MAX); + if (fromlen) { + *fromlen = msg.msg_namelen; + } + } + + sock_set_errno(sock, 0); + done_socket(sock); + return ret; +} + +ssize_t +lwip_read(int s, void *mem, size_t len) +{ + return lwip_recvfrom(s, mem, len, 0, NULL, NULL); +} + +ssize_t +lwip_readv(int s, const struct iovec *iov, int iovcnt) +{ + struct msghdr msg; + + msg.msg_name = NULL; + msg.msg_namelen = 0; + /* Hack: we have to cast via number to cast from 'const' pointer to non-const. + Blame the opengroup standard for this inconsistency. */ + msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); + msg.msg_iovlen = iovcnt; + msg.msg_control = NULL; + msg.msg_controllen = 0; + msg.msg_flags = 0; + return lwip_recvmsg(s, &msg, 0); +} + +ssize_t +lwip_recv(int s, void *mem, size_t len, int flags) +{ + return lwip_recvfrom(s, mem, len, flags, NULL, NULL); +} + +ssize_t +lwip_recvmsg(int s, struct msghdr *message, int flags) +{ + struct lwip_sock *sock; + int i; + ssize_t buflen; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvmsg(%d, message=%p, flags=0x%x)\n", s, (void *)message, flags)); + LWIP_ERROR("lwip_recvmsg: invalid message pointer", message != NULL, return ERR_ARG;); + LWIP_ERROR("lwip_recvmsg: unsupported flags", (flags & ~(MSG_PEEK|MSG_DONTWAIT)) == 0, + set_errno(EOPNOTSUPP); return -1;); + + if ((message->msg_iovlen <= 0) || (message->msg_iovlen > IOV_MAX)) { + set_errno(EMSGSIZE); + return -1; + } + + sock = get_socket(s); + if (!sock) { + return -1; + } + + /* check for valid vectors */ + buflen = 0; + for (i = 0; i < message->msg_iovlen; i++) { + if ((message->msg_iov[i].iov_base == NULL) || ((ssize_t)message->msg_iov[i].iov_len <= 0) || + ((size_t)(ssize_t)message->msg_iov[i].iov_len != message->msg_iov[i].iov_len) || + ((ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len) <= 0)) { + sock_set_errno(sock, err_to_errno(ERR_VAL)); + done_socket(sock); + return -1; + } + buflen = (ssize_t)(buflen + (ssize_t)message->msg_iov[i].iov_len); + } + + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { +#if LWIP_TCP + int recv_flags = flags; + message->msg_flags = 0; + /* recv the data */ + buflen = 0; + for (i = 0; i < message->msg_iovlen; i++) { + /* try to receive into this vector's buffer */ + ssize_t recvd_local = lwip_recv_tcp(sock, message->msg_iov[i].iov_base, message->msg_iov[i].iov_len, recv_flags); + if (recvd_local > 0) { + /* sum up received bytes */ + buflen += recvd_local; + } + if ((recvd_local < 0) || (recvd_local < (int)message->msg_iov[i].iov_len) || + (flags & MSG_PEEK)) { + /* returned prematurely (or peeking, which might actually be limitated to the first iov) */ + if (buflen <= 0) { + /* nothing received at all, propagate the error */ + buflen = recvd_local; + } + break; + } + /* pass MSG_DONTWAIT to lwip_recv_tcp() to prevent waiting for more data */ + recv_flags |= MSG_DONTWAIT; + } + if (buflen > 0) { + /* reset socket error since we have received something */ + sock_set_errno(sock, 0); + } + /* " If the socket is connected, the msg_name and msg_namelen members shall be ignored." */ + done_socket(sock); + return buflen; +#else /* LWIP_TCP */ + sock_set_errno(sock, err_to_errno(ERR_ARG)); + done_socket(sock); + return -1; +#endif /* LWIP_TCP */ + } + /* else, UDP and RAW NETCONNs */ +#if LWIP_UDP || LWIP_RAW + { + u16_t datagram_len = 0; + err_t err; + err = lwip_recvfrom_udp_raw(sock, flags, message, &datagram_len, s); + if (err != ERR_OK) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_recvmsg[UDP/RAW](%d): buf == NULL, error is \"%s\"!\n", + s, lwip_strerr(err))); + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return -1; + } + if (datagram_len > buflen) { + message->msg_flags |= MSG_TRUNC; + } + + sock_set_errno(sock, 0); + done_socket(sock); + return (int)datagram_len; + } +#else /* LWIP_UDP || LWIP_RAW */ + sock_set_errno(sock, err_to_errno(ERR_ARG)); + done_socket(sock); + return -1; +#endif /* LWIP_UDP || LWIP_RAW */ +} + +ssize_t +lwip_send(int s, const void *data, size_t size, int flags) +{ + struct lwip_sock *sock; + err_t err; + u8_t write_flags; + size_t written; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d, data=%p, size=%"SZT_F", flags=0x%x)\n", + s, data, size, flags)); + + sock = get_socket(s); + if (!sock) { + return -1; + } + + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { +#if (LWIP_UDP || LWIP_RAW) + done_socket(sock); + return lwip_sendto(s, data, size, flags, NULL, 0); +#else /* (LWIP_UDP || LWIP_RAW) */ + sock_set_errno(sock, err_to_errno(ERR_ARG)); + done_socket(sock); + return -1; +#endif /* (LWIP_UDP || LWIP_RAW) */ + } + + write_flags = (u8_t)(NETCONN_COPY | + ((flags & MSG_MORE) ? NETCONN_MORE : 0) | + ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0)); + written = 0; + err = netconn_write_partly(sock->conn, data, size, write_flags, &written); + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_send(%d) err=%d written=%"SZT_F"\n", s, err, written)); + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + /* casting 'written' to ssize_t is OK here since the netconn API limits it to SSIZE_MAX */ + return (err == ERR_OK ? (ssize_t)written : -1); +} + +ssize_t +lwip_sendmsg(int s, const struct msghdr *msg, int flags) +{ + struct lwip_sock *sock; +#if LWIP_TCP + u8_t write_flags; + size_t written; +#endif + err_t err = ERR_OK; + + sock = get_socket(s); + if (!sock) { + return -1; + } + + LWIP_ERROR("lwip_sendmsg: invalid msghdr", msg != NULL, + sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); + LWIP_ERROR("lwip_sendmsg: invalid msghdr iov", msg->msg_iov != NULL, + sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); + LWIP_ERROR("lwip_sendmsg: maximum iovs exceeded", (msg->msg_iovlen > 0) && (msg->msg_iovlen <= IOV_MAX), + sock_set_errno(sock, EMSGSIZE); done_socket(sock); return -1;); + LWIP_ERROR("lwip_sendmsg: unsupported flags", (flags & ~(MSG_DONTWAIT | MSG_MORE)) == 0, + sock_set_errno(sock, EOPNOTSUPP); done_socket(sock); return -1;); + + LWIP_UNUSED_ARG(msg->msg_control); + LWIP_UNUSED_ARG(msg->msg_controllen); + LWIP_UNUSED_ARG(msg->msg_flags); + + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { +#if LWIP_TCP + write_flags = (u8_t)(NETCONN_COPY | + ((flags & MSG_MORE) ? NETCONN_MORE : 0) | + ((flags & MSG_DONTWAIT) ? NETCONN_DONTBLOCK : 0)); + + written = 0; + err = netconn_write_vectors_partly(sock->conn, (struct netvector *)msg->msg_iov, (u16_t)msg->msg_iovlen, write_flags, &written); + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + /* casting 'written' to ssize_t is OK here since the netconn API limits it to SSIZE_MAX */ + return (err == ERR_OK ? (ssize_t)written : -1); +#else /* LWIP_TCP */ + sock_set_errno(sock, err_to_errno(ERR_ARG)); + done_socket(sock); + return -1; +#endif /* LWIP_TCP */ + } + /* else, UDP and RAW NETCONNs */ +#if LWIP_UDP || LWIP_RAW + { + struct netbuf chain_buf; + int i; + ssize_t size = 0; + + LWIP_UNUSED_ARG(flags); + LWIP_ERROR("lwip_sendmsg: invalid msghdr name", (((msg->msg_name == NULL) && (msg->msg_namelen == 0)) || + IS_SOCK_ADDR_LEN_VALID(msg->msg_namelen)), + sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); + + /* initialize chain buffer with destination */ + memset(&chain_buf, 0, sizeof(struct netbuf)); + if (msg->msg_name) { + u16_t remote_port; + SOCKADDR_TO_IPADDR_PORT((const struct sockaddr *)msg->msg_name, &chain_buf.addr, remote_port); + netbuf_fromport(&chain_buf) = remote_port; + } +#if LWIP_NETIF_TX_SINGLE_PBUF + for (i = 0; i < msg->msg_iovlen; i++) { + size += msg->msg_iov[i].iov_len; + if ((msg->msg_iov[i].iov_len > INT_MAX) || (size < (int)msg->msg_iov[i].iov_len)) { + /* overflow */ + goto sendmsg_emsgsize; + } + } + if (size > 0xFFFF) { + /* overflow */ + goto sendmsg_emsgsize; + } + /* Allocate a new netbuf and copy the data into it. */ + if (netbuf_alloc(&chain_buf, (u16_t)size) == NULL) { + err = ERR_MEM; + } else { + /* flatten the IO vectors */ + size_t offset = 0; + for (i = 0; i < msg->msg_iovlen; i++) { + MEMCPY(&((u8_t *)chain_buf.p->payload)[offset], msg->msg_iov[i].iov_base, msg->msg_iov[i].iov_len); + offset += msg->msg_iov[i].iov_len; + } +#if LWIP_CHECKSUM_ON_COPY + { + /* This can be improved by using LWIP_CHKSUM_COPY() and aggregating the checksum for each IO vector */ + u16_t chksum = ~inet_chksum_pbuf(chain_buf.p); + netbuf_set_chksum(&chain_buf, chksum); + } +#endif /* LWIP_CHECKSUM_ON_COPY */ + err = ERR_OK; + } +#else /* LWIP_NETIF_TX_SINGLE_PBUF */ + /* create a chained netbuf from the IO vectors. NOTE: we assemble a pbuf chain + manually to avoid having to allocate, chain, and delete a netbuf for each iov */ + for (i = 0; i < msg->msg_iovlen; i++) { + struct pbuf *p; + if (msg->msg_iov[i].iov_len > 0xFFFF) { + /* overflow */ + goto sendmsg_emsgsize; + } + p = pbuf_alloc(PBUF_TRANSPORT, 0, PBUF_REF); + if (p == NULL) { + err = ERR_MEM; /* let netbuf_delete() cleanup chain_buf */ + break; + } + p->payload = msg->msg_iov[i].iov_base; + p->len = p->tot_len = (u16_t)msg->msg_iov[i].iov_len; + /* netbuf empty, add new pbuf */ + if (chain_buf.p == NULL) { + chain_buf.p = chain_buf.ptr = p; + /* add pbuf to existing pbuf chain */ + } else { + if (chain_buf.p->tot_len + p->len > 0xffff) { + /* overflow */ + pbuf_free(p); + goto sendmsg_emsgsize; + } + pbuf_cat(chain_buf.p, p); + } + } + /* save size of total chain */ + if (err == ERR_OK) { + size = netbuf_len(&chain_buf); + } +#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ + + if (err == ERR_OK) { +#if LWIP_IPV4 && LWIP_IPV6 + /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ + if (IP_IS_V6_VAL(chain_buf.addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&chain_buf.addr))) { + unmap_ipv4_mapped_ipv6(ip_2_ip4(&chain_buf.addr), ip_2_ip6(&chain_buf.addr)); + IP_SET_TYPE_VAL(chain_buf.addr, IPADDR_TYPE_V4); + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + /* send the data */ + err = netconn_send(sock->conn, &chain_buf); + } + + /* deallocated the buffer */ + netbuf_free(&chain_buf); + + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return (err == ERR_OK ? size : -1); +sendmsg_emsgsize: + sock_set_errno(sock, EMSGSIZE); + netbuf_free(&chain_buf); + done_socket(sock); + return -1; + } +#else /* LWIP_UDP || LWIP_RAW */ + sock_set_errno(sock, err_to_errno(ERR_ARG)); + done_socket(sock); + return -1; +#endif /* LWIP_UDP || LWIP_RAW */ +} + +ssize_t +lwip_sendto(int s, const void *data, size_t size, int flags, + const struct sockaddr *to, socklen_t tolen) +{ + struct lwip_sock *sock; + err_t err; + u16_t short_size; + u16_t remote_port; + struct netbuf buf; + + sock = get_socket(s); + if (!sock) { + return -1; + } + + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { +#if LWIP_TCP + done_socket(sock); + return lwip_send(s, data, size, flags); +#else /* LWIP_TCP */ + LWIP_UNUSED_ARG(flags); + sock_set_errno(sock, err_to_errno(ERR_ARG)); + done_socket(sock); + return -1; +#endif /* LWIP_TCP */ + } + + if (size > LWIP_MIN(0xFFFF, SSIZE_MAX)) { + /* cannot fit into one datagram (at least for us) */ + sock_set_errno(sock, EMSGSIZE); + done_socket(sock); + return -1; + } + short_size = (u16_t)size; + LWIP_ERROR("lwip_sendto: invalid address", (((to == NULL) && (tolen == 0)) || + (IS_SOCK_ADDR_LEN_VALID(tolen) && + ((to != NULL) && (IS_SOCK_ADDR_TYPE_VALID(to) && IS_SOCK_ADDR_ALIGNED(to))))), + sock_set_errno(sock, err_to_errno(ERR_ARG)); done_socket(sock); return -1;); + LWIP_UNUSED_ARG(tolen); + + /* initialize a buffer */ + buf.p = buf.ptr = NULL; +#if LWIP_CHECKSUM_ON_COPY + buf.flags = 0; +#endif /* LWIP_CHECKSUM_ON_COPY */ + if (to) { + SOCKADDR_TO_IPADDR_PORT(to, &buf.addr, remote_port); + } else { + remote_port = 0; + ip_addr_set_any(NETCONNTYPE_ISIPV6(netconn_type(sock->conn)), &buf.addr); + } + netbuf_fromport(&buf) = remote_port; + + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_sendto(%d, data=%p, short_size=%"U16_F", flags=0x%x to=", + s, data, short_size, flags)); + ip_addr_debug_print_val(SOCKETS_DEBUG, buf.addr); + LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F"\n", remote_port)); + + /* make the buffer point to the data that should be sent */ +#if LWIP_NETIF_TX_SINGLE_PBUF + /* Allocate a new netbuf and copy the data into it. */ + if (netbuf_alloc(&buf, short_size) == NULL) { + err = ERR_MEM; + } else { +#if LWIP_CHECKSUM_ON_COPY + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_RAW) { + u16_t chksum = LWIP_CHKSUM_COPY(buf.p->payload, data, short_size); + netbuf_set_chksum(&buf, chksum); + } else +#endif /* LWIP_CHECKSUM_ON_COPY */ + { + MEMCPY(buf.p->payload, data, short_size); + } + err = ERR_OK; + } +#else /* LWIP_NETIF_TX_SINGLE_PBUF */ + err = netbuf_ref(&buf, data, short_size); +#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ + if (err == ERR_OK) { +#if LWIP_IPV4 && LWIP_IPV6 + /* Dual-stack: Unmap IPv4 mapped IPv6 addresses */ + if (IP_IS_V6_VAL(buf.addr) && ip6_addr_isipv4mappedipv6(ip_2_ip6(&buf.addr))) { + unmap_ipv4_mapped_ipv6(ip_2_ip4(&buf.addr), ip_2_ip6(&buf.addr)); + IP_SET_TYPE_VAL(buf.addr, IPADDR_TYPE_V4); + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + /* send the data */ + err = netconn_send(sock->conn, &buf); + } + + /* deallocated the buffer */ + netbuf_free(&buf); + + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return (err == ERR_OK ? short_size : -1); +} + +int +lwip_socket(int domain, int type, int protocol) +{ + struct netconn *conn; + int i; + + LWIP_UNUSED_ARG(domain); /* @todo: check this */ + + /* create a netconn */ + switch (type) { + case SOCK_RAW: + conn = netconn_new_with_proto_and_callback(DOMAIN_TO_NETCONN_TYPE(domain, NETCONN_RAW), + (u8_t)protocol, DEFAULT_SOCKET_EVENTCB); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_RAW, %d) = ", + domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); + break; + case SOCK_DGRAM: + conn = netconn_new_with_callback(DOMAIN_TO_NETCONN_TYPE(domain, + ((protocol == IPPROTO_UDPLITE) ? NETCONN_UDPLITE : NETCONN_UDP)), + DEFAULT_SOCKET_EVENTCB); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_DGRAM, %d) = ", + domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); +#if LWIP_NETBUF_RECVINFO + if (conn) { + /* netconn layer enables pktinfo by default, sockets default to off */ + conn->flags &= ~NETCONN_FLAG_PKTINFO; + } +#endif /* LWIP_NETBUF_RECVINFO */ + break; + case SOCK_STREAM: + conn = netconn_new_with_callback(DOMAIN_TO_NETCONN_TYPE(domain, NETCONN_TCP), DEFAULT_SOCKET_EVENTCB); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%s, SOCK_STREAM, %d) = ", + domain == PF_INET ? "PF_INET" : "UNKNOWN", protocol)); + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_socket(%d, %d/UNKNOWN, %d) = -1\n", + domain, type, protocol)); + set_errno(EINVAL); + return -1; + } + + if (!conn) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("-1 / ENOBUFS (could not create netconn)\n")); + set_errno(ENOBUFS); + return -1; + } + + i = alloc_socket(conn, 0); + + if (i == -1) { + netconn_delete(conn); + set_errno(ENFILE); + return -1; + } + conn->socket = i; + done_socket(&sockets[i - LWIP_SOCKET_OFFSET]); + LWIP_DEBUGF(SOCKETS_DEBUG, ("%d\n", i)); + set_errno(0); + return i; +} + +ssize_t +lwip_write(int s, const void *data, size_t size) +{ + return lwip_send(s, data, size, 0); +} + +ssize_t +lwip_writev(int s, const struct iovec *iov, int iovcnt) +{ + struct msghdr msg; + + msg.msg_name = NULL; + msg.msg_namelen = 0; + /* Hack: we have to cast via number to cast from 'const' pointer to non-const. + Blame the opengroup standard for this inconsistency. */ + msg.msg_iov = LWIP_CONST_CAST(struct iovec *, iov); + msg.msg_iovlen = iovcnt; + msg.msg_control = NULL; + msg.msg_controllen = 0; + msg.msg_flags = 0; + return lwip_sendmsg(s, &msg, 0); +} + +#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL +/* Add select_cb to select_cb_list. */ +static void +lwip_link_select_cb(struct lwip_select_cb *select_cb) +{ + LWIP_SOCKET_SELECT_DECL_PROTECT(lev); + + /* Protect the select_cb_list */ + LWIP_SOCKET_SELECT_PROTECT(lev); + + /* Put this select_cb on top of list */ + select_cb->next = select_cb_list; + if (select_cb_list != NULL) { + select_cb_list->prev = select_cb; + } + select_cb_list = select_cb; +#if !LWIP_TCPIP_CORE_LOCKING + /* Increasing this counter tells select_check_waiters that the list has changed. */ + select_cb_ctr++; +#endif + + /* Now we can safely unprotect */ + LWIP_SOCKET_SELECT_UNPROTECT(lev); +} + +/* Remove select_cb from select_cb_list. */ +static void +lwip_unlink_select_cb(struct lwip_select_cb *select_cb) +{ + LWIP_SOCKET_SELECT_DECL_PROTECT(lev); + + /* Take us off the list */ + LWIP_SOCKET_SELECT_PROTECT(lev); + if (select_cb->next != NULL) { + select_cb->next->prev = select_cb->prev; + } + if (select_cb_list == select_cb) { + LWIP_ASSERT("select_cb->prev == NULL", select_cb->prev == NULL); + select_cb_list = select_cb->next; + } else { + LWIP_ASSERT("select_cb->prev != NULL", select_cb->prev != NULL); + select_cb->prev->next = select_cb->next; + } +#if !LWIP_TCPIP_CORE_LOCKING + /* Increasing this counter tells select_check_waiters that the list has changed. */ + select_cb_ctr++; +#endif + LWIP_SOCKET_SELECT_UNPROTECT(lev); +} +#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ + +#if LWIP_SOCKET_SELECT +/** + * Go through the readset and writeset lists and see which socket of the sockets + * set in the sets has events. On return, readset, writeset and exceptset have + * the sockets enabled that had events. + * + * @param maxfdp1 the highest socket index in the sets + * @param readset_in set of sockets to check for read events + * @param writeset_in set of sockets to check for write events + * @param exceptset_in set of sockets to check for error events + * @param readset_out set of sockets that had read events + * @param writeset_out set of sockets that had write events + * @param exceptset_out set os sockets that had error events + * @return number of sockets that had events (read/write/exception) (>= 0) + */ +static int +lwip_selscan(int maxfdp1, fd_set *readset_in, fd_set *writeset_in, fd_set *exceptset_in, + fd_set *readset_out, fd_set *writeset_out, fd_set *exceptset_out) +{ + int i, nready = 0; + fd_set lreadset, lwriteset, lexceptset; + struct lwip_sock *sock; + SYS_ARCH_DECL_PROTECT(lev); + + FD_ZERO(&lreadset); + FD_ZERO(&lwriteset); + FD_ZERO(&lexceptset); + + /* Go through each socket in each list to count number of sockets which + currently match */ + for (i = LWIP_SOCKET_OFFSET; i < maxfdp1; i++) { + /* if this FD is not in the set, continue */ + if (!(readset_in && FD_ISSET(i, readset_in)) && + !(writeset_in && FD_ISSET(i, writeset_in)) && + !(exceptset_in && FD_ISSET(i, exceptset_in))) { + continue; + } + /* First get the socket's status (protected)... */ + SYS_ARCH_PROTECT(lev); + sock = tryget_socket_unconn_locked(i); + if (sock != NULL) { + void *lastdata = sock->lastdata.pbuf; + s16_t rcvevent = sock->rcvevent; + u16_t sendevent = sock->sendevent; + u16_t errevent = sock->errevent; + SYS_ARCH_UNPROTECT(lev); + + /* ... then examine it: */ + /* See if netconn of this socket is ready for read */ + if (readset_in && FD_ISSET(i, readset_in) && ((lastdata != NULL) || (rcvevent > 0))) { + FD_SET(i, &lreadset); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for reading\n", i)); + nready++; + } + /* See if netconn of this socket is ready for write */ + if (writeset_in && FD_ISSET(i, writeset_in) && (sendevent != 0)) { + FD_SET(i, &lwriteset); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for writing\n", i)); + nready++; + } + /* See if netconn of this socket had an error */ + if (exceptset_in && FD_ISSET(i, exceptset_in) && (errevent != 0)) { + FD_SET(i, &lexceptset); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_selscan: fd=%d ready for exception\n", i)); + nready++; + } + done_socket(sock); + } else { + SYS_ARCH_UNPROTECT(lev); + /* no a valid open socket */ + return -1; + } + } + /* copy local sets to the ones provided as arguments */ + *readset_out = lreadset; + *writeset_out = lwriteset; + *exceptset_out = lexceptset; + + LWIP_ASSERT("nready >= 0", nready >= 0); + return nready; +} + +#if LWIP_NETCONN_FULLDUPLEX +/* Mark all of the set sockets in one of the three fdsets passed to select as used. + * All sockets are marked (and later unmarked), whether they are open or not. + * This is OK as lwip_selscan aborts select when non-open sockets are found. + */ +static void +lwip_select_inc_sockets_used_set(int maxfdp, fd_set *fdset, fd_set *used_sockets) +{ + SYS_ARCH_DECL_PROTECT(lev); + if (fdset) { + int i; + for (i = LWIP_SOCKET_OFFSET; i < maxfdp; i++) { + /* if this FD is in the set, lock it (unless already done) */ + if (FD_ISSET(i, fdset) && !FD_ISSET(i, used_sockets)) { + struct lwip_sock *sock; + SYS_ARCH_PROTECT(lev); + sock = tryget_socket_unconn_locked(i); + if (sock != NULL) { + /* leave the socket used until released by lwip_select_dec_sockets_used */ + FD_SET(i, used_sockets); + } + SYS_ARCH_UNPROTECT(lev); + } + } + } +} + +/* Mark all sockets passed to select as used to prevent them from being freed + * from other threads while select is running. + * Marked sockets are added to 'used_sockets' to mark them only once an be able + * to unmark them correctly. + */ +static void +lwip_select_inc_sockets_used(int maxfdp, fd_set *fdset1, fd_set *fdset2, fd_set *fdset3, fd_set *used_sockets) +{ + FD_ZERO(used_sockets); + lwip_select_inc_sockets_used_set(maxfdp, fdset1, used_sockets); + lwip_select_inc_sockets_used_set(maxfdp, fdset2, used_sockets); + lwip_select_inc_sockets_used_set(maxfdp, fdset3, used_sockets); +} + +/* Let go all sockets that were marked as used when starting select */ +static void +lwip_select_dec_sockets_used(int maxfdp, fd_set *used_sockets) +{ + int i; + for (i = LWIP_SOCKET_OFFSET; i < maxfdp; i++) { + /* if this FD is not in the set, continue */ + if (FD_ISSET(i, used_sockets)) { + struct lwip_sock *sock = tryget_socket_unconn_nouse(i); + LWIP_ASSERT("socket gone at the end of select", sock != NULL); + if (sock != NULL) { + done_socket(sock); + } + } + } +} +#else /* LWIP_NETCONN_FULLDUPLEX */ +#define lwip_select_inc_sockets_used(maxfdp1, readset, writeset, exceptset, used_sockets) +#define lwip_select_dec_sockets_used(maxfdp1, used_sockets) +#endif /* LWIP_NETCONN_FULLDUPLEX */ + +int +lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, + struct timeval *timeout) +{ + u32_t waitres = 0; + int nready; + fd_set lreadset, lwriteset, lexceptset; + u32_t msectimeout; + int i; + int maxfdp2; +#if LWIP_NETCONN_SEM_PER_THREAD + int waited = 0; +#endif +#if LWIP_NETCONN_FULLDUPLEX + fd_set used_sockets; +#endif + SYS_ARCH_DECL_PROTECT(lev); + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select(%d, %p, %p, %p, tvsec=%"S32_F" tvusec=%"S32_F")\n", + maxfdp1, (void *)readset, (void *) writeset, (void *) exceptset, + timeout ? (s32_t)timeout->tv_sec : (s32_t) - 1, + timeout ? (s32_t)timeout->tv_usec : (s32_t) - 1)); + + if ((maxfdp1 < 0) || (maxfdp1 > LWIP_SELECT_MAXNFDS)) { + set_errno(EINVAL); + return -1; + } + + lwip_select_inc_sockets_used(maxfdp1, readset, writeset, exceptset, &used_sockets); + + /* Go through each socket in each list to count number of sockets which + currently match */ + nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset); + + if (nready < 0) { + /* one of the sockets in one of the fd_sets was invalid */ + set_errno(EBADF); + lwip_select_dec_sockets_used(maxfdp1, &used_sockets); + return -1; + } else if (nready > 0) { + /* one or more sockets are set, no need to wait */ + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready)); + } else { + /* If we don't have any current events, then suspend if we are supposed to */ + if (timeout && timeout->tv_sec == 0 && timeout->tv_usec == 0) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: no timeout, returning 0\n")); + /* This is OK as the local fdsets are empty and nready is zero, + or we would have returned earlier. */ + } else { + /* None ready: add our semaphore to list: + We don't actually need any dynamic memory. Our entry on the + list is only valid while we are in this function, so it's ok + to use local variables (unless we're running in MPU compatible + mode). */ + API_SELECT_CB_VAR_DECLARE(select_cb); + API_SELECT_CB_VAR_ALLOC(select_cb, set_errno(ENOMEM); lwip_select_dec_sockets_used(maxfdp1, &used_sockets); return -1); + memset(&API_SELECT_CB_VAR_REF(select_cb), 0, sizeof(struct lwip_select_cb)); + + API_SELECT_CB_VAR_REF(select_cb).readset = readset; + API_SELECT_CB_VAR_REF(select_cb).writeset = writeset; + API_SELECT_CB_VAR_REF(select_cb).exceptset = exceptset; +#if LWIP_NETCONN_SEM_PER_THREAD + API_SELECT_CB_VAR_REF(select_cb).sem = LWIP_NETCONN_THREAD_SEM_GET(); +#else /* LWIP_NETCONN_SEM_PER_THREAD */ + if (sys_sem_new(&API_SELECT_CB_VAR_REF(select_cb).sem, 0) != ERR_OK) { + /* failed to create semaphore */ + set_errno(ENOMEM); + lwip_select_dec_sockets_used(maxfdp1, &used_sockets); + API_SELECT_CB_VAR_FREE(select_cb); + return -1; + } +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + + lwip_link_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); + + /* Increase select_waiting for each socket we are interested in */ + maxfdp2 = maxfdp1; + for (i = LWIP_SOCKET_OFFSET; i < maxfdp1; i++) { + if ((readset && FD_ISSET(i, readset)) || + (writeset && FD_ISSET(i, writeset)) || + (exceptset && FD_ISSET(i, exceptset))) { + struct lwip_sock *sock; + SYS_ARCH_PROTECT(lev); + sock = tryget_socket_unconn_locked(i); + if (sock != NULL) { + sock->select_waiting++; + if (sock->select_waiting == 0) { + /* overflow - too many threads waiting */ + sock->select_waiting--; + nready = -1; + maxfdp2 = i; + SYS_ARCH_UNPROTECT(lev); + done_socket(sock); + set_errno(EBUSY); + break; + } + SYS_ARCH_UNPROTECT(lev); + done_socket(sock); + } else { + /* Not a valid socket */ + nready = -1; + maxfdp2 = i; + SYS_ARCH_UNPROTECT(lev); + set_errno(EBADF); + break; + } + } + } + + if (nready >= 0) { + /* Call lwip_selscan again: there could have been events between + the last scan (without us on the list) and putting us on the list! */ + nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset); + if (!nready) { + /* Still none ready, just wait to be woken */ + if (timeout == 0) { + /* Wait forever */ + msectimeout = 0; + } else { + long msecs_long = ((timeout->tv_sec * 1000) + ((timeout->tv_usec + 500) / 1000)); + if (msecs_long <= 0) { + /* Wait 1ms at least (0 means wait forever) */ + msectimeout = 1; + } else { + msectimeout = (u32_t)msecs_long; + } + } + + waitres = sys_arch_sem_wait(SELECT_SEM_PTR(API_SELECT_CB_VAR_REF(select_cb).sem), msectimeout); +#if LWIP_NETCONN_SEM_PER_THREAD + waited = 1; +#endif + } + } + + /* Decrease select_waiting for each socket we are interested in */ + for (i = LWIP_SOCKET_OFFSET; i < maxfdp2; i++) { + if ((readset && FD_ISSET(i, readset)) || + (writeset && FD_ISSET(i, writeset)) || + (exceptset && FD_ISSET(i, exceptset))) { + struct lwip_sock *sock; + SYS_ARCH_PROTECT(lev); + sock = tryget_socket_unconn_locked(i); + if (sock != NULL) { + /* for now, handle select_waiting==0... */ + LWIP_ASSERT("sock->select_waiting > 0", sock->select_waiting > 0); + if (sock->select_waiting > 0) { + sock->select_waiting--; + } + SYS_ARCH_UNPROTECT(lev); + done_socket(sock); + } else { + SYS_ARCH_UNPROTECT(lev); + /* Not a valid socket */ + nready = -1; + set_errno(EBADF); + } + } + } + + lwip_unlink_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); + +#if LWIP_NETCONN_SEM_PER_THREAD + if (API_SELECT_CB_VAR_REF(select_cb).sem_signalled && (!waited || (waitres == SYS_ARCH_TIMEOUT))) { + /* don't leave the thread-local semaphore signalled */ + sys_arch_sem_wait(API_SELECT_CB_VAR_REF(select_cb).sem, 1); + } +#else /* LWIP_NETCONN_SEM_PER_THREAD */ + sys_sem_free(&API_SELECT_CB_VAR_REF(select_cb).sem); +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + API_SELECT_CB_VAR_FREE(select_cb); + + if (nready < 0) { + /* This happens when a socket got closed while waiting */ + lwip_select_dec_sockets_used(maxfdp1, &used_sockets); + return -1; + } + + if (waitres == SYS_ARCH_TIMEOUT) { + /* Timeout */ + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: timeout expired\n")); + /* This is OK as the local fdsets are empty and nready is zero, + or we would have returned earlier. */ + } else { + /* See what's set now after waiting */ + nready = lwip_selscan(maxfdp1, readset, writeset, exceptset, &lreadset, &lwriteset, &lexceptset); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_select: nready=%d\n", nready)); + } + } + } + + lwip_select_dec_sockets_used(maxfdp1, &used_sockets); + set_errno(0); + if (readset) { + *readset = lreadset; + } + if (writeset) { + *writeset = lwriteset; + } + if (exceptset) { + *exceptset = lexceptset; + } + return nready; +} +#endif /* LWIP_SOCKET_SELECT */ + +#if LWIP_SOCKET_POLL +/** Options for the lwip_pollscan function. */ +enum lwip_pollscan_opts +{ + /** Clear revents in each struct pollfd. */ + LWIP_POLLSCAN_CLEAR = 1, + + /** Increment select_waiting in each struct lwip_sock. */ + LWIP_POLLSCAN_INC_WAIT = 2, + + /** Decrement select_waiting in each struct lwip_sock. */ + LWIP_POLLSCAN_DEC_WAIT = 4 +}; + +/** + * Update revents in each struct pollfd. + * Optionally update select_waiting in struct lwip_sock. + * + * @param fds array of structures to update + * @param nfds number of structures in fds + * @param opts what to update and how + * @return number of structures that have revents != 0 + */ +static int +lwip_pollscan(struct pollfd *fds, nfds_t nfds, enum lwip_pollscan_opts opts) +{ + int nready = 0; + nfds_t fdi; + struct lwip_sock *sock; + SYS_ARCH_DECL_PROTECT(lev); + + /* Go through each struct pollfd in the array. */ + for (fdi = 0; fdi < nfds; fdi++) { + if ((opts & LWIP_POLLSCAN_CLEAR) != 0) { + fds[fdi].revents = 0; + } + + /* Negative fd means the caller wants us to ignore this struct. + POLLNVAL means we already detected that the fd is invalid; + if another thread has since opened a new socket with that fd, + we must not use that socket. */ + if (fds[fdi].fd >= 0 && (fds[fdi].revents & POLLNVAL) == 0) { + /* First get the socket's status (protected)... */ + SYS_ARCH_PROTECT(lev); + sock = tryget_socket_unconn_locked(fds[fdi].fd); + if (sock != NULL) { + void* lastdata = sock->lastdata.pbuf; + s16_t rcvevent = sock->rcvevent; + u16_t sendevent = sock->sendevent; + u16_t errevent = sock->errevent; + + if ((opts & LWIP_POLLSCAN_INC_WAIT) != 0) { + sock->select_waiting++; + if (sock->select_waiting == 0) { + /* overflow - too many threads waiting */ + sock->select_waiting--; + nready = -1; + SYS_ARCH_UNPROTECT(lev); + done_socket(sock); + break; + } + } else if ((opts & LWIP_POLLSCAN_DEC_WAIT) != 0) { + /* for now, handle select_waiting==0... */ + LWIP_ASSERT("sock->select_waiting > 0", sock->select_waiting > 0); + if (sock->select_waiting > 0) { + sock->select_waiting--; + } + } + SYS_ARCH_UNPROTECT(lev); + done_socket(sock); + + /* ... then examine it: */ + /* See if netconn of this socket is ready for read */ + if ((fds[fdi].events & POLLIN) != 0 && ((lastdata != NULL) || (rcvevent > 0))) { + fds[fdi].revents |= POLLIN; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_pollscan: fd=%d ready for reading\n", fds[fdi].fd)); + } + /* See if netconn of this socket is ready for write */ + if ((fds[fdi].events & POLLOUT) != 0 && (sendevent != 0)) { + fds[fdi].revents |= POLLOUT; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_pollscan: fd=%d ready for writing\n", fds[fdi].fd)); + } + /* See if netconn of this socket had an error */ + if (errevent != 0) { + /* POLLERR is output only. */ + fds[fdi].revents |= POLLERR; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_pollscan: fd=%d ready for exception\n", fds[fdi].fd)); + } + } else { + /* Not a valid socket */ + SYS_ARCH_UNPROTECT(lev); + /* POLLNVAL is output only. */ + fds[fdi].revents |= POLLNVAL; + return -1; + } + } + + /* Will return the number of structures that have events, + not the number of events. */ + if (fds[fdi].revents != 0) { + nready++; + } + } + + LWIP_ASSERT("nready >= 0", nready >= 0); + return nready; +} + +#if LWIP_NETCONN_FULLDUPLEX +/* Mark all sockets as used. + * + * All sockets are marked (and later unmarked), whether they are open or not. + * This is OK as lwip_pollscan aborts select when non-open sockets are found. + */ +static void +lwip_poll_inc_sockets_used(struct pollfd *fds, nfds_t nfds) +{ + nfds_t fdi; + + if(fds) { + /* Go through each struct pollfd in the array. */ + for (fdi = 0; fdi < nfds; fdi++) { + /* Increase the reference counter */ + tryget_socket_unconn(fds[fdi].fd); + } + } +} + +/* Let go all sockets that were marked as used when starting poll */ +static void +lwip_poll_dec_sockets_used(struct pollfd *fds, nfds_t nfds) +{ + nfds_t fdi; + + if(fds) { + /* Go through each struct pollfd in the array. */ + for (fdi = 0; fdi < nfds; fdi++) { + struct lwip_sock *sock = tryget_socket_unconn_nouse(fds[fdi].fd); + if (sock != NULL) { + done_socket(sock); + } + } + } +} +#else /* LWIP_NETCONN_FULLDUPLEX */ +#define lwip_poll_inc_sockets_used(fds, nfds) +#define lwip_poll_dec_sockets_used(fds, nfds) +#endif /* LWIP_NETCONN_FULLDUPLEX */ + +int +lwip_poll(struct pollfd *fds, nfds_t nfds, int timeout) +{ + u32_t waitres = 0; + int nready; + u32_t msectimeout; +#if LWIP_NETCONN_SEM_PER_THREAD + int waited = 0; +#endif + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll(%p, %d, %d)\n", + (void*)fds, (int)nfds, timeout)); + LWIP_ERROR("lwip_poll: invalid fds", ((fds != NULL && nfds > 0) || (fds == NULL && nfds == 0)), + set_errno(EINVAL); return -1;); + + lwip_poll_inc_sockets_used(fds, nfds); + + /* Go through each struct pollfd to count number of structures + which currently match */ + nready = lwip_pollscan(fds, nfds, LWIP_POLLSCAN_CLEAR); + + if (nready < 0) { + lwip_poll_dec_sockets_used(fds, nfds); + return -1; + } + + /* If we don't have any current events, then suspend if we are supposed to */ + if (!nready) { + API_SELECT_CB_VAR_DECLARE(select_cb); + + if (timeout == 0) { + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll: no timeout, returning 0\n")); + goto return_success; + } + API_SELECT_CB_VAR_ALLOC(select_cb, set_errno(EAGAIN); lwip_poll_dec_sockets_used(fds, nfds); return -1); + memset(&API_SELECT_CB_VAR_REF(select_cb), 0, sizeof(struct lwip_select_cb)); + + /* None ready: add our semaphore to list: + We don't actually need any dynamic memory. Our entry on the + list is only valid while we are in this function, so it's ok + to use local variables. */ + + API_SELECT_CB_VAR_REF(select_cb).poll_fds = fds; + API_SELECT_CB_VAR_REF(select_cb).poll_nfds = nfds; +#if LWIP_NETCONN_SEM_PER_THREAD + API_SELECT_CB_VAR_REF(select_cb).sem = LWIP_NETCONN_THREAD_SEM_GET(); +#else /* LWIP_NETCONN_SEM_PER_THREAD */ + if (sys_sem_new(&API_SELECT_CB_VAR_REF(select_cb).sem, 0) != ERR_OK) { + /* failed to create semaphore */ + set_errno(EAGAIN); + lwip_poll_dec_sockets_used(fds, nfds); + API_SELECT_CB_VAR_FREE(select_cb); + return -1; + } +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + + lwip_link_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); + + /* Increase select_waiting for each socket we are interested in. + Also, check for events again: there could have been events between + the last scan (without us on the list) and putting us on the list! */ + nready = lwip_pollscan(fds, nfds, LWIP_POLLSCAN_INC_WAIT); + + if (!nready) { + /* Still none ready, just wait to be woken */ + if (timeout < 0) { + /* Wait forever */ + msectimeout = 0; + } else { + /* timeout == 0 would have been handled earlier. */ + LWIP_ASSERT("timeout > 0", timeout > 0); + msectimeout = timeout; + } + waitres = sys_arch_sem_wait(SELECT_SEM_PTR(API_SELECT_CB_VAR_REF(select_cb).sem), msectimeout); +#if LWIP_NETCONN_SEM_PER_THREAD + waited = 1; +#endif + } + + /* Decrease select_waiting for each socket we are interested in, + and check which events occurred while we waited. */ + nready = lwip_pollscan(fds, nfds, LWIP_POLLSCAN_DEC_WAIT); + + lwip_unlink_select_cb(&API_SELECT_CB_VAR_REF(select_cb)); + +#if LWIP_NETCONN_SEM_PER_THREAD + if (select_cb.sem_signalled && (!waited || (waitres == SYS_ARCH_TIMEOUT))) { + /* don't leave the thread-local semaphore signalled */ + sys_arch_sem_wait(API_SELECT_CB_VAR_REF(select_cb).sem, 1); + } +#else /* LWIP_NETCONN_SEM_PER_THREAD */ + sys_sem_free(&API_SELECT_CB_VAR_REF(select_cb).sem); +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + API_SELECT_CB_VAR_FREE(select_cb); + + if (nready < 0) { + /* This happens when a socket got closed while waiting */ + lwip_poll_dec_sockets_used(fds, nfds); + return -1; + } + + if (waitres == SYS_ARCH_TIMEOUT) { + /* Timeout */ + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll: timeout expired\n")); + goto return_success; + } + } + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_poll: nready=%d\n", nready)); +return_success: + lwip_poll_dec_sockets_used(fds, nfds); + set_errno(0); + return nready; +} + +/** + * Check whether event_callback should wake up a thread waiting in + * lwip_poll. + */ +static int +lwip_poll_should_wake(const struct lwip_select_cb *scb, int fd, int has_recvevent, int has_sendevent, int has_errevent) +{ + nfds_t fdi; + for (fdi = 0; fdi < scb->poll_nfds; fdi++) { + const struct pollfd *pollfd = &scb->poll_fds[fdi]; + if (pollfd->fd == fd) { + /* Do not update pollfd->revents right here; + that would be a data race because lwip_pollscan + accesses revents without protecting. */ + if (has_recvevent && (pollfd->events & POLLIN) != 0) { + return 1; + } + if (has_sendevent && (pollfd->events & POLLOUT) != 0) { + return 1; + } + if (has_errevent) { + /* POLLERR is output only. */ + return 1; + } + } + } + return 0; +} +#endif /* LWIP_SOCKET_POLL */ + +#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL +/** + * Callback registered in the netconn layer for each socket-netconn. + * Processes recvevent (data available) and wakes up tasks waiting for select. + * + * @note for LWIP_TCPIP_CORE_LOCKING any caller of this function + * must have the core lock held when signaling the following events + * as they might cause select_list_cb to be checked: + * NETCONN_EVT_RCVPLUS + * NETCONN_EVT_SENDPLUS + * NETCONN_EVT_ERROR + * This requirement will be asserted in select_check_waiters() + */ +static void +event_callback(struct netconn *conn, enum netconn_evt evt, u16_t len) +{ + int s, check_waiters; + struct lwip_sock *sock; + SYS_ARCH_DECL_PROTECT(lev); + + LWIP_UNUSED_ARG(len); + + /* Get socket */ + if (conn) { + s = conn->socket; + if (s < 0) { + /* Data comes in right away after an accept, even though + * the server task might not have created a new socket yet. + * Just count down (or up) if that's the case and we + * will use the data later. Note that only receive events + * can happen before the new socket is set up. */ + SYS_ARCH_PROTECT(lev); + if (conn->socket < 0) { + if (evt == NETCONN_EVT_RCVPLUS) { + /* conn->socket is -1 on initialization + lwip_accept adjusts sock->recvevent if conn->socket < -1 */ + conn->socket--; + } + SYS_ARCH_UNPROTECT(lev); + return; + } + s = conn->socket; + SYS_ARCH_UNPROTECT(lev); + } + + sock = get_socket(s); + if (!sock) { + return; + } + } else { + return; + } + + check_waiters = 1; + SYS_ARCH_PROTECT(lev); + /* Set event as required */ + switch (evt) { + case NETCONN_EVT_RCVPLUS: + sock->rcvevent++; + if (sock->rcvevent > 1) { + check_waiters = 0; + } + break; + case NETCONN_EVT_RCVMINUS: + sock->rcvevent--; + check_waiters = 0; + break; + case NETCONN_EVT_SENDPLUS: + if (sock->sendevent) { + check_waiters = 0; + } + sock->sendevent = 1; + break; + case NETCONN_EVT_SENDMINUS: + sock->sendevent = 0; + check_waiters = 0; + break; + case NETCONN_EVT_ERROR: + sock->errevent = 1; + break; + default: + LWIP_ASSERT("unknown event", 0); + break; + } + + if (sock->select_waiting && check_waiters) { + /* Save which events are active */ + int has_recvevent, has_sendevent, has_errevent; + has_recvevent = sock->rcvevent > 0; + has_sendevent = sock->sendevent != 0; + has_errevent = sock->errevent != 0; + SYS_ARCH_UNPROTECT(lev); + /* Check any select calls waiting on this socket */ + select_check_waiters(s, has_recvevent, has_sendevent, has_errevent); + } else { + SYS_ARCH_UNPROTECT(lev); + } + done_socket(sock); +} + +/** + * Check if any select waiters are waiting on this socket and its events + * + * @note on synchronization of select_cb_list: + * LWIP_TCPIP_CORE_LOCKING: the select_cb_list must only be accessed while holding + * the core lock. We do a single pass through the list and signal any waiters. + * Core lock should already be held when calling here!!!! + + * !LWIP_TCPIP_CORE_LOCKING: we use SYS_ARCH_PROTECT but unlock on each iteration + * of the loop, thus creating a possibility where a thread could modify the + * select_cb_list during our UNPROTECT/PROTECT. We use a generational counter to + * detect this change and restart the list walk. The list is expected to be small + */ +static void select_check_waiters(int s, int has_recvevent, int has_sendevent, int has_errevent) +{ + struct lwip_select_cb *scb; +#if !LWIP_TCPIP_CORE_LOCKING + int last_select_cb_ctr; + SYS_ARCH_DECL_PROTECT(lev); +#endif /* !LWIP_TCPIP_CORE_LOCKING */ + + LWIP_ASSERT_CORE_LOCKED(); + +#if !LWIP_TCPIP_CORE_LOCKING + SYS_ARCH_PROTECT(lev); +again: + /* remember the state of select_cb_list to detect changes */ + last_select_cb_ctr = select_cb_ctr; +#endif /* !LWIP_TCPIP_CORE_LOCKING */ + for (scb = select_cb_list; scb != NULL; scb = scb->next) { + if (scb->sem_signalled == 0) { + /* semaphore not signalled yet */ + int do_signal = 0; +#if LWIP_SOCKET_POLL + if (scb->poll_fds != NULL) { + do_signal = lwip_poll_should_wake(scb, s, has_recvevent, has_sendevent, has_errevent); + } +#endif /* LWIP_SOCKET_POLL */ +#if LWIP_SOCKET_SELECT && LWIP_SOCKET_POLL + else +#endif /* LWIP_SOCKET_SELECT && LWIP_SOCKET_POLL */ +#if LWIP_SOCKET_SELECT + { + /* Test this select call for our socket */ + if (has_recvevent) { + if (scb->readset && FD_ISSET(s, scb->readset)) { + do_signal = 1; + } + } + if (has_sendevent) { + if (!do_signal && scb->writeset && FD_ISSET(s, scb->writeset)) { + do_signal = 1; + } + } + if (has_errevent) { + if (!do_signal && scb->exceptset && FD_ISSET(s, scb->exceptset)) { + do_signal = 1; + } + } + } +#endif /* LWIP_SOCKET_SELECT */ + if (do_signal) { + scb->sem_signalled = 1; + /* For !LWIP_TCPIP_CORE_LOCKING, we don't call SYS_ARCH_UNPROTECT() before signaling + the semaphore, as this might lead to the select thread taking itself off the list, + invalidating the semaphore. */ + sys_sem_signal(SELECT_SEM_PTR(scb->sem)); + } + } +#if LWIP_TCPIP_CORE_LOCKING + } +#else + /* unlock interrupts with each step */ + SYS_ARCH_UNPROTECT(lev); + /* this makes sure interrupt protection time is short */ + SYS_ARCH_PROTECT(lev); + if (last_select_cb_ctr != select_cb_ctr) { + /* someone has changed select_cb_list, restart at the beginning */ + goto again; + } + /* remember the state of select_cb_list to detect changes */ + last_select_cb_ctr = select_cb_ctr; + } + SYS_ARCH_UNPROTECT(lev); +#endif +} +#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ + +/** + * Close one end of a full-duplex connection. + */ +int +lwip_shutdown(int s, int how) +{ + struct lwip_sock *sock; + err_t err; + u8_t shut_rx = 0, shut_tx = 0; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_shutdown(%d, how=%d)\n", s, how)); + + sock = get_socket(s); + if (!sock) { + return -1; + } + + if (sock->conn != NULL) { + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { + sock_set_errno(sock, EOPNOTSUPP); + done_socket(sock); + return -1; + } + } else { + sock_set_errno(sock, ENOTCONN); + done_socket(sock); + return -1; + } + + if (how == SHUT_RD) { + shut_rx = 1; + } else if (how == SHUT_WR) { + shut_tx = 1; + } else if (how == SHUT_RDWR) { + shut_rx = 1; + shut_tx = 1; + } else { + sock_set_errno(sock, EINVAL); + done_socket(sock); + return -1; + } + err = netconn_shutdown(sock->conn, shut_rx, shut_tx); + + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return (err == ERR_OK ? 0 : -1); +} + +static int +lwip_getaddrname(int s, struct sockaddr *name, socklen_t *namelen, u8_t local) +{ + struct lwip_sock *sock; + union sockaddr_aligned saddr; + ip_addr_t naddr; + u16_t port; + err_t err; + + sock = get_socket(s); + if (!sock) { + return -1; + } + + /* get the IP address and port */ + err = netconn_getaddr(sock->conn, &naddr, &port, local); + if (err != ERR_OK) { + sock_set_errno(sock, err_to_errno(err)); + done_socket(sock); + return -1; + } + +#if LWIP_IPV4 && LWIP_IPV6 + /* Dual-stack: Map IPv4 addresses to IPv4 mapped IPv6 */ + if (NETCONNTYPE_ISIPV6(netconn_type(sock->conn)) && + IP_IS_V4_VAL(naddr)) { + ip4_2_ipv4_mapped_ipv6(ip_2_ip6(&naddr), ip_2_ip4(&naddr)); + IP_SET_TYPE_VAL(naddr, IPADDR_TYPE_V6); + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + IPADDR_PORT_TO_SOCKADDR(&saddr, &naddr, port); + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getaddrname(%d, addr=", s)); + ip_addr_debug_print_val(SOCKETS_DEBUG, naddr); + LWIP_DEBUGF(SOCKETS_DEBUG, (" port=%"U16_F")\n", port)); + + if (*namelen > saddr.sa.sa_len) { + *namelen = saddr.sa.sa_len; + } + MEMCPY(name, &saddr, *namelen); + + sock_set_errno(sock, 0); + done_socket(sock); + return 0; +} + +int +lwip_getpeername(int s, struct sockaddr *name, socklen_t *namelen) +{ + return lwip_getaddrname(s, name, namelen, 0); +} + +int +lwip_getsockname(int s, struct sockaddr *name, socklen_t *namelen) +{ + return lwip_getaddrname(s, name, namelen, 1); +} + +int +lwip_getsockopt(int s, int level, int optname, void *optval, socklen_t *optlen) +{ + int err; + struct lwip_sock *sock = get_socket(s); +#if !LWIP_TCPIP_CORE_LOCKING + err_t cberr; + LWIP_SETGETSOCKOPT_DATA_VAR_DECLARE(data); +#endif /* !LWIP_TCPIP_CORE_LOCKING */ + + if (!sock) { + return -1; + } + + if ((NULL == optval) || (NULL == optlen)) { + sock_set_errno(sock, EFAULT); + done_socket(sock); + return -1; + } + +#if LWIP_TCPIP_CORE_LOCKING + /* core-locking can just call the -impl function */ + LOCK_TCPIP_CORE(); + err = lwip_getsockopt_impl(s, level, optname, optval, optlen); + UNLOCK_TCPIP_CORE(); + +#else /* LWIP_TCPIP_CORE_LOCKING */ + +#if LWIP_MPU_COMPATIBLE + /* MPU_COMPATIBLE copies the optval data, so check for max size here */ + if (*optlen > LWIP_SETGETSOCKOPT_MAXOPTLEN) { + sock_set_errno(sock, ENOBUFS); + done_socket(sock); + return -1; + } +#endif /* LWIP_MPU_COMPATIBLE */ + + LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(data, sock); + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).s = s; + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).level = level; + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optname = optname; + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen = *optlen; +#if !LWIP_MPU_COMPATIBLE + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval.p = optval; +#endif /* !LWIP_MPU_COMPATIBLE */ + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err = 0; +#if LWIP_NETCONN_SEM_PER_THREAD + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = LWIP_NETCONN_THREAD_SEM_GET(); +#else + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = &sock->conn->op_completed; +#endif + cberr = tcpip_callback(lwip_getsockopt_callback, &LWIP_SETGETSOCKOPT_DATA_VAR_REF(data)); + if (cberr != ERR_OK) { + LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); + sock_set_errno(sock, err_to_errno(cberr)); + done_socket(sock); + return -1; + } + sys_arch_sem_wait((sys_sem_t *)(LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem), 0); + + /* write back optlen and optval */ + *optlen = LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen; +#if LWIP_MPU_COMPATIBLE + MEMCPY(optval, LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval, + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen); +#endif /* LWIP_MPU_COMPATIBLE */ + + /* maybe lwip_getsockopt_internal has changed err */ + err = LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err; + LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); +#endif /* LWIP_TCPIP_CORE_LOCKING */ + + sock_set_errno(sock, err); + done_socket(sock); + return err ? -1 : 0; +} + +#if !LWIP_TCPIP_CORE_LOCKING +/** lwip_getsockopt_callback: only used without CORE_LOCKING + * to get into the tcpip_thread + */ +static void +lwip_getsockopt_callback(void *arg) +{ + struct lwip_setgetsockopt_data *data; + LWIP_ASSERT("arg != NULL", arg != NULL); + data = (struct lwip_setgetsockopt_data *)arg; + + data->err = lwip_getsockopt_impl(data->s, data->level, data->optname, +#if LWIP_MPU_COMPATIBLE + data->optval, +#else /* LWIP_MPU_COMPATIBLE */ + data->optval.p, +#endif /* LWIP_MPU_COMPATIBLE */ + &data->optlen); + + sys_sem_signal((sys_sem_t *)(data->completed_sem)); +} +#endif /* LWIP_TCPIP_CORE_LOCKING */ + +static int +lwip_sockopt_to_ipopt(int optname) +{ + /* Map SO_* values to our internal SOF_* values + * We should not rely on #defines in socket.h + * being in sync with ip.h. + */ + switch (optname) { + case SO_BROADCAST: + return SOF_BROADCAST; + case SO_KEEPALIVE: + return SOF_KEEPALIVE; + case SO_REUSEADDR: + return SOF_REUSEADDR; + default: + LWIP_ASSERT("Unknown socket option", 0); + return 0; + } +} + +/** lwip_getsockopt_impl: the actual implementation of getsockopt: + * same argument as lwip_getsockopt, either called directly or through callback + */ +static int +lwip_getsockopt_impl(int s, int level, int optname, void *optval, socklen_t *optlen) +{ + int err = 0; + struct lwip_sock *sock = tryget_socket(s); + if (!sock) { + return EBADF; + } + +#ifdef LWIP_HOOK_SOCKETS_GETSOCKOPT + if (LWIP_HOOK_SOCKETS_GETSOCKOPT(s, sock, level, optname, optval, optlen, &err)) { + return err; + } +#endif + + switch (level) { + + /* Level: SOL_SOCKET */ + case SOL_SOCKET: + switch (optname) { + +#if LWIP_TCP + case SO_ACCEPTCONN: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); + if (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_TCP) { + done_socket(sock); + return ENOPROTOOPT; + } + if ((sock->conn->pcb.tcp != NULL) && (sock->conn->pcb.tcp->state == LISTEN)) { + *(int *)optval = 1; + } else { + *(int *)optval = 0; + } + break; +#endif /* LWIP_TCP */ + + /* The option flags */ + case SO_BROADCAST: + case SO_KEEPALIVE: +#if SO_REUSE + case SO_REUSEADDR: +#endif /* SO_REUSE */ + if ((optname == SO_BROADCAST) && + (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP)) { + done_socket(sock); + return ENOPROTOOPT; + } + + optname = lwip_sockopt_to_ipopt(optname); + + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); + *(int *)optval = ip_get_option(sock->conn->pcb.ip, optname); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, optname=0x%x, ..) = %s\n", + s, optname, (*(int *)optval ? "on" : "off"))); + break; + + case SO_TYPE: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, int); + switch (NETCONNTYPE_GROUP(netconn_type(sock->conn))) { + case NETCONN_RAW: + *(int *)optval = SOCK_RAW; + break; + case NETCONN_TCP: + *(int *)optval = SOCK_STREAM; + break; + case NETCONN_UDP: + *(int *)optval = SOCK_DGRAM; + break; + default: /* unrecognized socket type */ + *(int *)optval = netconn_type(sock->conn); + LWIP_DEBUGF(SOCKETS_DEBUG, + ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE): unrecognized socket type %d\n", + s, *(int *)optval)); + } /* switch (netconn_type(sock->conn)) */ + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_TYPE) = %d\n", + s, *(int *)optval)); + break; + + case SO_ERROR: + LWIP_SOCKOPT_CHECK_OPTLEN(sock, *optlen, int); + *(int *)optval = err_to_errno(netconn_err(sock->conn)); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, SO_ERROR) = %d\n", + s, *(int *)optval)); + break; + +#if LWIP_SO_SNDTIMEO + case SO_SNDTIMEO: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); + LWIP_SO_SNDRCVTIMEO_SET(optval, netconn_get_sendtimeout(sock->conn)); + break; +#endif /* LWIP_SO_SNDTIMEO */ +#if LWIP_SO_RCVTIMEO + case SO_RCVTIMEO: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); + LWIP_SO_SNDRCVTIMEO_SET(optval, netconn_get_recvtimeout(sock->conn)); + break; +#endif /* LWIP_SO_RCVTIMEO */ +#if LWIP_SO_RCVBUF + case SO_RCVBUF: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, int); + *(int *)optval = netconn_get_recvbufsize(sock->conn); + break; +#endif /* LWIP_SO_RCVBUF */ +#if LWIP_SO_LINGER + case SO_LINGER: { + s16_t conn_linger; + struct linger *linger = (struct linger *)optval; + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, struct linger); + conn_linger = sock->conn->linger; + if (conn_linger >= 0) { + linger->l_onoff = 1; + linger->l_linger = (int)conn_linger; + } else { + linger->l_onoff = 0; + linger->l_linger = 0; + } + } + break; +#endif /* LWIP_SO_LINGER */ +#if LWIP_UDP + case SO_NO_CHECK: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, *optlen, int, NETCONN_UDP); +#if LWIP_UDPLITE + if (udp_is_flag_set(sock->conn->pcb.udp, UDP_FLAGS_UDPLITE)) { + /* this flag is only available for UDP, not for UDP lite */ + done_socket(sock); + return EAFNOSUPPORT; + } +#endif /* LWIP_UDPLITE */ + *(int *)optval = udp_is_flag_set(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM) ? 1 : 0; + break; +#endif /* LWIP_UDP*/ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; + + /* Level: IPPROTO_IP */ + case IPPROTO_IP: + switch (optname) { + case IP_TTL: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); + *(int *)optval = sock->conn->pcb.ip->ttl; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TTL) = %d\n", + s, *(int *)optval)); + break; + case IP_TOS: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); + *(int *)optval = sock->conn->pcb.ip->tos; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_TOS) = %d\n", + s, *(int *)optval)); + break; +#if LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP + case IP_MULTICAST_TTL: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, u8_t); + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_UDP) { + done_socket(sock); + return ENOPROTOOPT; + } + *(u8_t *)optval = udp_get_multicast_ttl(sock->conn->pcb.udp); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_TTL) = %d\n", + s, *(int *)optval)); + break; + case IP_MULTICAST_IF: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, struct in_addr); + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_UDP) { + done_socket(sock); + return ENOPROTOOPT; + } + inet_addr_from_ip4addr((struct in_addr *)optval, udp_get_multicast_netif_addr(sock->conn->pcb.udp)); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_IF) = 0x%"X32_F"\n", + s, *(u32_t *)optval)); + break; + case IP_MULTICAST_LOOP: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, u8_t); + if ((sock->conn->pcb.udp->flags & UDP_FLAGS_MULTICAST_LOOP) != 0) { + *(u8_t *)optval = 1; + } else { + *(u8_t *)optval = 0; + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, IP_MULTICAST_LOOP) = %d\n", + s, *(int *)optval)); + break; +#endif /* LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP */ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; + +#if LWIP_TCP + /* Level: IPPROTO_TCP */ + case IPPROTO_TCP: + /* Special case: all IPPROTO_TCP option take an int */ + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, *optlen, int, NETCONN_TCP); + if (sock->conn->pcb.tcp->state == LISTEN) { + done_socket(sock); + return EINVAL; + } + switch (optname) { + case TCP_NODELAY: + *(int *)optval = tcp_nagle_disabled(sock->conn->pcb.tcp); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_NODELAY) = %s\n", + s, (*(int *)optval) ? "on" : "off") ); + break; + case TCP_KEEPALIVE: + *(int *)optval = (int)sock->conn->pcb.tcp->keep_idle; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) = %d\n", + s, *(int *)optval)); + break; + +#if LWIP_TCP_KEEPALIVE + case TCP_KEEPIDLE: + *(int *)optval = (int)(sock->conn->pcb.tcp->keep_idle / 1000); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPIDLE) = %d\n", + s, *(int *)optval)); + break; + case TCP_KEEPINTVL: + *(int *)optval = (int)(sock->conn->pcb.tcp->keep_intvl / 1000); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPINTVL) = %d\n", + s, *(int *)optval)); + break; + case TCP_KEEPCNT: + *(int *)optval = (int)sock->conn->pcb.tcp->keep_cnt; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, TCP_KEEPCNT) = %d\n", + s, *(int *)optval)); + break; +#endif /* LWIP_TCP_KEEPALIVE */ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; +#endif /* LWIP_TCP */ + +#if LWIP_IPV6 + /* Level: IPPROTO_IPV6 */ + case IPPROTO_IPV6: + switch (optname) { + case IPV6_V6ONLY: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, *optlen, int); + *(int *)optval = (netconn_get_ipv6only(sock->conn) ? 1 : 0); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IPV6, IPV6_V6ONLY) = %d\n", + s, *(int *)optval)); + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_IPV6, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; +#endif /* LWIP_IPV6 */ + +#if LWIP_UDP && LWIP_UDPLITE + /* Level: IPPROTO_UDPLITE */ + case IPPROTO_UDPLITE: + /* Special case: all IPPROTO_UDPLITE option take an int */ + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, *optlen, int); + /* If this is no UDP lite socket, ignore any options. */ + if (!NETCONNTYPE_ISUDPLITE(netconn_type(sock->conn))) { + done_socket(sock); + return ENOPROTOOPT; + } + switch (optname) { + case UDPLITE_SEND_CSCOV: + *(int *)optval = sock->conn->pcb.udp->chksum_len_tx; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) = %d\n", + s, (*(int *)optval)) ); + break; + case UDPLITE_RECV_CSCOV: + *(int *)optval = sock->conn->pcb.udp->chksum_len_rx; + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) = %d\n", + s, (*(int *)optval)) ); + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; +#endif /* LWIP_UDP */ + /* Level: IPPROTO_RAW */ + case IPPROTO_RAW: + switch (optname) { +#if LWIP_IPV6 && LWIP_RAW + case IPV6_CHECKSUM: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, *optlen, int, NETCONN_RAW); + if (sock->conn->pcb.raw->chksum_reqd == 0) { + *(int *)optval = -1; + } else { + *(int *)optval = sock->conn->pcb.raw->chksum_offset; + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_RAW, IPV6_CHECKSUM) = %d\n", + s, (*(int *)optval)) ); + break; +#endif /* LWIP_IPV6 && LWIP_RAW */ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, IPPROTO_RAW, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_getsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", + s, level, optname)); + err = ENOPROTOOPT; + break; + } /* switch (level) */ + + done_socket(sock); + return err; +} + +int +lwip_setsockopt(int s, int level, int optname, const void *optval, socklen_t optlen) +{ + int err = 0; + struct lwip_sock *sock = get_socket(s); +#if !LWIP_TCPIP_CORE_LOCKING + err_t cberr; + LWIP_SETGETSOCKOPT_DATA_VAR_DECLARE(data); +#endif /* !LWIP_TCPIP_CORE_LOCKING */ + + if (!sock) { + return -1; + } + + if (NULL == optval) { + sock_set_errno(sock, EFAULT); + done_socket(sock); + return -1; + } + +#if LWIP_TCPIP_CORE_LOCKING + /* core-locking can just call the -impl function */ + LOCK_TCPIP_CORE(); + err = lwip_setsockopt_impl(s, level, optname, optval, optlen); + UNLOCK_TCPIP_CORE(); + +#else /* LWIP_TCPIP_CORE_LOCKING */ + +#if LWIP_MPU_COMPATIBLE + /* MPU_COMPATIBLE copies the optval data, so check for max size here */ + if (optlen > LWIP_SETGETSOCKOPT_MAXOPTLEN) { + sock_set_errno(sock, ENOBUFS); + done_socket(sock); + return -1; + } +#endif /* LWIP_MPU_COMPATIBLE */ + + LWIP_SETGETSOCKOPT_DATA_VAR_ALLOC(data, sock); + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).s = s; + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).level = level; + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optname = optname; + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optlen = optlen; +#if LWIP_MPU_COMPATIBLE + MEMCPY(LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval, optval, optlen); +#else /* LWIP_MPU_COMPATIBLE */ + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).optval.pc = (const void *)optval; +#endif /* LWIP_MPU_COMPATIBLE */ + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err = 0; +#if LWIP_NETCONN_SEM_PER_THREAD + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = LWIP_NETCONN_THREAD_SEM_GET(); +#else + LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem = &sock->conn->op_completed; +#endif + cberr = tcpip_callback(lwip_setsockopt_callback, &LWIP_SETGETSOCKOPT_DATA_VAR_REF(data)); + if (cberr != ERR_OK) { + LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); + sock_set_errno(sock, err_to_errno(cberr)); + done_socket(sock); + return -1; + } + sys_arch_sem_wait((sys_sem_t *)(LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).completed_sem), 0); + + /* maybe lwip_getsockopt_internal has changed err */ + err = LWIP_SETGETSOCKOPT_DATA_VAR_REF(data).err; + LWIP_SETGETSOCKOPT_DATA_VAR_FREE(data); +#endif /* LWIP_TCPIP_CORE_LOCKING */ + + sock_set_errno(sock, err); + done_socket(sock); + return err ? -1 : 0; +} + +#if !LWIP_TCPIP_CORE_LOCKING +/** lwip_setsockopt_callback: only used without CORE_LOCKING + * to get into the tcpip_thread + */ +static void +lwip_setsockopt_callback(void *arg) +{ + struct lwip_setgetsockopt_data *data; + LWIP_ASSERT("arg != NULL", arg != NULL); + data = (struct lwip_setgetsockopt_data *)arg; + + data->err = lwip_setsockopt_impl(data->s, data->level, data->optname, +#if LWIP_MPU_COMPATIBLE + data->optval, +#else /* LWIP_MPU_COMPATIBLE */ + data->optval.pc, +#endif /* LWIP_MPU_COMPATIBLE */ + data->optlen); + + sys_sem_signal((sys_sem_t *)(data->completed_sem)); +} +#endif /* LWIP_TCPIP_CORE_LOCKING */ + +/** lwip_setsockopt_impl: the actual implementation of setsockopt: + * same argument as lwip_setsockopt, either called directly or through callback + */ +static int +lwip_setsockopt_impl(int s, int level, int optname, const void *optval, socklen_t optlen) +{ + int err = 0; + struct lwip_sock *sock = tryget_socket(s); + if (!sock) { + return EBADF; + } + +#ifdef LWIP_HOOK_SOCKETS_SETSOCKOPT + if (LWIP_HOOK_SOCKETS_SETSOCKOPT(s, sock, level, optname, optval, optlen, &err)) { + return err; + } +#endif + + switch (level) { + + /* Level: SOL_SOCKET */ + case SOL_SOCKET: + switch (optname) { + + /* SO_ACCEPTCONN is get-only */ + + /* The option flags */ + case SO_BROADCAST: + case SO_KEEPALIVE: +#if SO_REUSE + case SO_REUSEADDR: +#endif /* SO_REUSE */ + if ((optname == SO_BROADCAST) && + (NETCONNTYPE_GROUP(sock->conn->type) != NETCONN_UDP)) { + done_socket(sock); + return ENOPROTOOPT; + } + + optname = lwip_sockopt_to_ipopt(optname); + + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); + if (*(const int *)optval) { + ip_set_option(sock->conn->pcb.ip, optname); + } else { + ip_reset_option(sock->conn->pcb.ip, optname); + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, optname=0x%x, ..) -> %s\n", + s, optname, (*(const int *)optval ? "on" : "off"))); + break; + + /* SO_TYPE is get-only */ + /* SO_ERROR is get-only */ + +#if LWIP_SO_SNDTIMEO + case SO_SNDTIMEO: { + long ms_long; + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); + ms_long = LWIP_SO_SNDRCVTIMEO_GET_MS(optval); + if (ms_long < 0) { + done_socket(sock); + return EINVAL; + } + netconn_set_sendtimeout(sock->conn, ms_long); + break; + } +#endif /* LWIP_SO_SNDTIMEO */ +#if LWIP_SO_RCVTIMEO + case SO_RCVTIMEO: { + long ms_long; + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, LWIP_SO_SNDRCVTIMEO_OPTTYPE); + ms_long = LWIP_SO_SNDRCVTIMEO_GET_MS(optval); + if (ms_long < 0) { + done_socket(sock); + return EINVAL; + } + netconn_set_recvtimeout(sock->conn, (u32_t)ms_long); + break; + } +#endif /* LWIP_SO_RCVTIMEO */ +#if LWIP_SO_RCVBUF + case SO_RCVBUF: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, int); + netconn_set_recvbufsize(sock->conn, *(const int *)optval); + break; +#endif /* LWIP_SO_RCVBUF */ +#if LWIP_SO_LINGER + case SO_LINGER: { + const struct linger *linger = (const struct linger *)optval; + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, struct linger); + if (linger->l_onoff) { + int lingersec = linger->l_linger; + if (lingersec < 0) { + done_socket(sock); + return EINVAL; + } + if (lingersec > 0xFFFF) { + lingersec = 0xFFFF; + } + sock->conn->linger = (s16_t)lingersec; + } else { + sock->conn->linger = -1; + } + } + break; +#endif /* LWIP_SO_LINGER */ +#if LWIP_UDP + case SO_NO_CHECK: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_UDP); +#if LWIP_UDPLITE + if (udp_is_flag_set(sock->conn->pcb.udp, UDP_FLAGS_UDPLITE)) { + /* this flag is only available for UDP, not for UDP lite */ + done_socket(sock); + return EAFNOSUPPORT; + } +#endif /* LWIP_UDPLITE */ + if (*(const int *)optval) { + udp_set_flags(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); + } else { + udp_clear_flags(sock->conn->pcb.udp, UDP_FLAGS_NOCHKSUM); + } + break; +#endif /* LWIP_UDP */ + case SO_BINDTODEVICE: { + const struct ifreq *iface; + struct netif *n = NULL; + + LWIP_SOCKOPT_CHECK_OPTLEN_CONN(sock, optlen, struct ifreq); + + iface = (const struct ifreq *)optval; + if (iface->ifr_name[0] != 0) { + n = netif_find(iface->ifr_name); + if (n == NULL) { + done_socket(sock); + return ENODEV; + } + } + + switch (NETCONNTYPE_GROUP(netconn_type(sock->conn))) { +#if LWIP_TCP + case NETCONN_TCP: + tcp_bind_netif(sock->conn->pcb.tcp, n); + break; +#endif +#if LWIP_UDP + case NETCONN_UDP: + udp_bind_netif(sock->conn->pcb.udp, n); + break; +#endif +#if LWIP_RAW + case NETCONN_RAW: + raw_bind_netif(sock->conn->pcb.raw, n); + break; +#endif + default: + LWIP_ASSERT("Unhandled netconn type in SO_BINDTODEVICE", 0); + break; + } + } + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, SOL_SOCKET, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; + + /* Level: IPPROTO_IP */ + case IPPROTO_IP: + switch (optname) { + case IP_TTL: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); + sock->conn->pcb.ip->ttl = (u8_t)(*(const int *)optval); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TTL, ..) -> %d\n", + s, sock->conn->pcb.ip->ttl)); + break; + case IP_TOS: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); + sock->conn->pcb.ip->tos = (u8_t)(*(const int *)optval); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, IP_TOS, ..)-> %d\n", + s, sock->conn->pcb.ip->tos)); + break; +#if LWIP_NETBUF_RECVINFO + case IP_PKTINFO: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_UDP); + if (*(const int *)optval) { + sock->conn->flags |= NETCONN_FLAG_PKTINFO; + } else { + sock->conn->flags &= ~NETCONN_FLAG_PKTINFO; + } + break; +#endif /* LWIP_NETBUF_RECVINFO */ +#if LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP + case IP_MULTICAST_TTL: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, u8_t, NETCONN_UDP); + udp_set_multicast_ttl(sock->conn->pcb.udp, (u8_t)(*(const u8_t *)optval)); + break; + case IP_MULTICAST_IF: { + ip4_addr_t if_addr; + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, struct in_addr, NETCONN_UDP); + inet_addr_to_ip4addr(&if_addr, (const struct in_addr *)optval); + udp_set_multicast_netif_addr(sock->conn->pcb.udp, &if_addr); + } + break; + case IP_MULTICAST_LOOP: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, u8_t, NETCONN_UDP); + if (*(const u8_t *)optval) { + udp_set_flags(sock->conn->pcb.udp, UDP_FLAGS_MULTICAST_LOOP); + } else { + udp_clear_flags(sock->conn->pcb.udp, UDP_FLAGS_MULTICAST_LOOP); + } + break; +#endif /* LWIP_IPV4 && LWIP_MULTICAST_TX_OPTIONS && LWIP_UDP */ +#if LWIP_IGMP + case IP_ADD_MEMBERSHIP: + case IP_DROP_MEMBERSHIP: { + /* If this is a TCP or a RAW socket, ignore these options. */ + err_t igmp_err; + const struct ip_mreq *imr = (const struct ip_mreq *)optval; + ip4_addr_t if_addr; + ip4_addr_t multi_addr; + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, struct ip_mreq, NETCONN_UDP); + inet_addr_to_ip4addr(&if_addr, &imr->imr_interface); + inet_addr_to_ip4addr(&multi_addr, &imr->imr_multiaddr); + if (optname == IP_ADD_MEMBERSHIP) { + if (!lwip_socket_register_membership(s, &if_addr, &multi_addr)) { + /* cannot track membership (out of memory) */ + err = ENOMEM; + igmp_err = ERR_OK; + } else { + igmp_err = igmp_joingroup(&if_addr, &multi_addr); + } + } else { + igmp_err = igmp_leavegroup(&if_addr, &multi_addr); + lwip_socket_unregister_membership(s, &if_addr, &multi_addr); + } + if (igmp_err != ERR_OK) { + err = EADDRNOTAVAIL; + } + } + break; +#endif /* LWIP_IGMP */ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IP, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; + +#if LWIP_TCP + /* Level: IPPROTO_TCP */ + case IPPROTO_TCP: + /* Special case: all IPPROTO_TCP option take an int */ + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_TCP); + if (sock->conn->pcb.tcp->state == LISTEN) { + done_socket(sock); + return EINVAL; + } + switch (optname) { + case TCP_NODELAY: + if (*(const int *)optval) { + tcp_nagle_disable(sock->conn->pcb.tcp); + } else { + tcp_nagle_enable(sock->conn->pcb.tcp); + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_NODELAY) -> %s\n", + s, (*(const int *)optval) ? "on" : "off") ); + break; + case TCP_KEEPALIVE: + sock->conn->pcb.tcp->keep_idle = (u32_t)(*(const int *)optval); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPALIVE) -> %"U32_F"\n", + s, sock->conn->pcb.tcp->keep_idle)); + break; + +#if LWIP_TCP_KEEPALIVE + case TCP_KEEPIDLE: + sock->conn->pcb.tcp->keep_idle = 1000 * (u32_t)(*(const int *)optval); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPIDLE) -> %"U32_F"\n", + s, sock->conn->pcb.tcp->keep_idle)); + break; + case TCP_KEEPINTVL: + sock->conn->pcb.tcp->keep_intvl = 1000 * (u32_t)(*(const int *)optval); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPINTVL) -> %"U32_F"\n", + s, sock->conn->pcb.tcp->keep_intvl)); + break; + case TCP_KEEPCNT: + sock->conn->pcb.tcp->keep_cnt = (u32_t)(*(const int *)optval); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, TCP_KEEPCNT) -> %"U32_F"\n", + s, sock->conn->pcb.tcp->keep_cnt)); + break; +#endif /* LWIP_TCP_KEEPALIVE */ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_TCP, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; +#endif /* LWIP_TCP*/ + +#if LWIP_IPV6 + /* Level: IPPROTO_IPV6 */ + case IPPROTO_IPV6: + switch (optname) { + case IPV6_V6ONLY: + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); + if (*(const int *)optval) { + netconn_set_ipv6only(sock->conn, 1); + } else { + netconn_set_ipv6only(sock->conn, 0); + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IPV6, IPV6_V6ONLY, ..) -> %d\n", + s, (netconn_get_ipv6only(sock->conn) ? 1 : 0))); + break; +#if LWIP_IPV6_MLD + case IPV6_JOIN_GROUP: + case IPV6_LEAVE_GROUP: { + /* If this is a TCP or a RAW socket, ignore these options. */ + err_t mld6_err; + struct netif *netif; + ip6_addr_t multi_addr; + const struct ipv6_mreq *imr = (const struct ipv6_mreq *)optval; + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, struct ipv6_mreq, NETCONN_UDP); + inet6_addr_to_ip6addr(&multi_addr, &imr->ipv6mr_multiaddr); + LWIP_ASSERT("Invalid netif index", imr->ipv6mr_interface <= 0xFFu); + netif = netif_get_by_index((u8_t)imr->ipv6mr_interface); + if (netif == NULL) { + err = EADDRNOTAVAIL; + break; + } + + if (optname == IPV6_JOIN_GROUP) { + if (!lwip_socket_register_mld6_membership(s, imr->ipv6mr_interface, &multi_addr)) { + /* cannot track membership (out of memory) */ + err = ENOMEM; + mld6_err = ERR_OK; + } else { + mld6_err = mld6_joingroup_netif(netif, &multi_addr); + } + } else { + mld6_err = mld6_leavegroup_netif(netif, &multi_addr); + lwip_socket_unregister_mld6_membership(s, imr->ipv6mr_interface, &multi_addr); + } + if (mld6_err != ERR_OK) { + err = EADDRNOTAVAIL; + } + } + break; +#endif /* LWIP_IPV6_MLD */ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_IPV6, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; +#endif /* LWIP_IPV6 */ + +#if LWIP_UDP && LWIP_UDPLITE + /* Level: IPPROTO_UDPLITE */ + case IPPROTO_UDPLITE: + /* Special case: all IPPROTO_UDPLITE option take an int */ + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB(sock, optlen, int); + /* If this is no UDP lite socket, ignore any options. */ + if (!NETCONNTYPE_ISUDPLITE(netconn_type(sock->conn))) { + done_socket(sock); + return ENOPROTOOPT; + } + switch (optname) { + case UDPLITE_SEND_CSCOV: + if ((*(const int *)optval != 0) && ((*(const int *)optval < 8) || (*(const int *)optval > 0xffff))) { + /* don't allow illegal values! */ + sock->conn->pcb.udp->chksum_len_tx = 8; + } else { + sock->conn->pcb.udp->chksum_len_tx = (u16_t) * (const int *)optval; + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_SEND_CSCOV) -> %d\n", + s, (*(const int *)optval)) ); + break; + case UDPLITE_RECV_CSCOV: + if ((*(const int *)optval != 0) && ((*(const int *)optval < 8) || (*(const int *)optval > 0xffff))) { + /* don't allow illegal values! */ + sock->conn->pcb.udp->chksum_len_rx = 8; + } else { + sock->conn->pcb.udp->chksum_len_rx = (u16_t) * (const int *)optval; + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UDPLITE_RECV_CSCOV) -> %d\n", + s, (*(const int *)optval)) ); + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_UDPLITE, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; +#endif /* LWIP_UDP */ + /* Level: IPPROTO_RAW */ + case IPPROTO_RAW: + switch (optname) { +#if LWIP_IPV6 && LWIP_RAW + case IPV6_CHECKSUM: + /* It should not be possible to disable the checksum generation with ICMPv6 + * as per RFC 3542 chapter 3.1 */ + if (sock->conn->pcb.raw->protocol == IPPROTO_ICMPV6) { + done_socket(sock); + return EINVAL; + } + + LWIP_SOCKOPT_CHECK_OPTLEN_CONN_PCB_TYPE(sock, optlen, int, NETCONN_RAW); + if (*(const int *)optval < 0) { + sock->conn->pcb.raw->chksum_reqd = 0; + } else if (*(const int *)optval & 1) { + /* Per RFC3542, odd offsets are not allowed */ + done_socket(sock); + return EINVAL; + } else { + sock->conn->pcb.raw->chksum_reqd = 1; + sock->conn->pcb.raw->chksum_offset = (u16_t) * (const int *)optval; + } + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_RAW, IPV6_CHECKSUM, ..) -> %d\n", + s, sock->conn->pcb.raw->chksum_reqd)); + break; +#endif /* LWIP_IPV6 && LWIP_RAW */ + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, IPPROTO_RAW, UNIMPL: optname=0x%x, ..)\n", + s, optname)); + err = ENOPROTOOPT; + break; + } /* switch (optname) */ + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_setsockopt(%d, level=0x%x, UNIMPL: optname=0x%x, ..)\n", + s, level, optname)); + err = ENOPROTOOPT; + break; + } /* switch (level) */ + + done_socket(sock); + return err; +} + +int +lwip_ioctl(int s, long cmd, void *argp) +{ + struct lwip_sock *sock = get_socket(s); + u8_t val; +#if LWIP_SO_RCVBUF + int recv_avail; +#endif /* LWIP_SO_RCVBUF */ + + if (!sock) { + return -1; + } + + switch (cmd) { +#if LWIP_SO_RCVBUF || LWIP_FIONREAD_LINUXMODE + case FIONREAD: + if (!argp) { + sock_set_errno(sock, EINVAL); + done_socket(sock); + return -1; + } +#if LWIP_FIONREAD_LINUXMODE + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) != NETCONN_TCP) { + struct netbuf *nb; + if (sock->lastdata.netbuf) { + nb = sock->lastdata.netbuf; + *((int *)argp) = nb->p->tot_len; + } else { + struct netbuf *rxbuf; + err_t err = netconn_recv_udp_raw_netbuf_flags(sock->conn, &rxbuf, NETCONN_DONTBLOCK); + if (err != ERR_OK) { + *((int *)argp) = 0; + } else { + sock->lastdata.netbuf = rxbuf; + *((int *)argp) = rxbuf->p->tot_len; + } + } + done_socket(sock); + return 0; + } +#endif /* LWIP_FIONREAD_LINUXMODE */ + +#if LWIP_SO_RCVBUF + /* we come here if either LWIP_FIONREAD_LINUXMODE==0 or this is a TCP socket */ + SYS_ARCH_GET(sock->conn->recv_avail, recv_avail); + if (recv_avail < 0) { + recv_avail = 0; + } + + /* Check if there is data left from the last recv operation. /maq 041215 */ + if (sock->lastdata.netbuf) { + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { + recv_avail += sock->lastdata.pbuf->tot_len; + } else { + recv_avail += sock->lastdata.netbuf->p->tot_len; + } + } + *((int *)argp) = recv_avail; + + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONREAD, %p) = %"U16_F"\n", s, argp, *((u16_t *)argp))); + sock_set_errno(sock, 0); + done_socket(sock); + return 0; +#else /* LWIP_SO_RCVBUF */ + break; +#endif /* LWIP_SO_RCVBUF */ +#endif /* LWIP_SO_RCVBUF || LWIP_FIONREAD_LINUXMODE */ + + case (long)FIONBIO: + val = 0; + if (argp && *(int *)argp) { + val = 1; + } + netconn_set_nonblocking(sock->conn, val); + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, FIONBIO, %d)\n", s, val)); + sock_set_errno(sock, 0); + done_socket(sock); + return 0; + + default: + break; + } /* switch (cmd) */ + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_ioctl(%d, UNIMPL: 0x%lx, %p)\n", s, cmd, argp)); + sock_set_errno(sock, ENOSYS); /* not yet implemented */ + done_socket(sock); + return -1; +} + +/** A minimal implementation of fcntl. + * Currently only the commands F_GETFL and F_SETFL are implemented. + * The flag O_NONBLOCK and access modes are supported for F_GETFL, only + * the flag O_NONBLOCK is implemented for F_SETFL. + */ +int +lwip_fcntl(int s, int cmd, int val) +{ + struct lwip_sock *sock = get_socket(s); + int ret = -1; + int op_mode = 0; + + if (!sock) { + return -1; + } + + switch (cmd) { + case F_GETFL: + ret = netconn_is_nonblocking(sock->conn) ? O_NONBLOCK : 0; + sock_set_errno(sock, 0); + + if (NETCONNTYPE_GROUP(netconn_type(sock->conn)) == NETCONN_TCP) { +#if LWIP_TCPIP_CORE_LOCKING + LOCK_TCPIP_CORE(); +#else + SYS_ARCH_DECL_PROTECT(lev); + /* the proper thing to do here would be to get into the tcpip_thread, + but locking should be OK as well since we only *read* some flags */ + SYS_ARCH_PROTECT(lev); +#endif +#if LWIP_TCP + if (sock->conn->pcb.tcp) { + if (!(sock->conn->pcb.tcp->flags & TF_RXCLOSED)) { + op_mode |= O_RDONLY; + } + if (!(sock->conn->pcb.tcp->flags & TF_FIN)) { + op_mode |= O_WRONLY; + } + } +#endif +#if LWIP_TCPIP_CORE_LOCKING + UNLOCK_TCPIP_CORE(); +#else + SYS_ARCH_UNPROTECT(lev); +#endif + } else { + op_mode |= O_RDWR; + } + + /* ensure O_RDWR for (O_RDONLY|O_WRONLY) != O_RDWR cases */ + ret |= (op_mode == (O_RDONLY | O_WRONLY)) ? O_RDWR : op_mode; + + break; + case F_SETFL: + /* Bits corresponding to the file access mode and the file creation flags [..] that are set in arg shall be ignored */ + val &= ~(O_RDONLY | O_WRONLY | O_RDWR); + if ((val & ~O_NONBLOCK) == 0) { + /* only O_NONBLOCK, all other bits are zero */ + netconn_set_nonblocking(sock->conn, val & O_NONBLOCK); + ret = 0; + sock_set_errno(sock, 0); + } else { + sock_set_errno(sock, ENOSYS); /* not yet implemented */ + } + break; + default: + LWIP_DEBUGF(SOCKETS_DEBUG, ("lwip_fcntl(%d, UNIMPL: %d, %d)\n", s, cmd, val)); + sock_set_errno(sock, ENOSYS); /* not yet implemented */ + break; + } + done_socket(sock); + return ret; +} + +#if LWIP_COMPAT_SOCKETS == 2 && LWIP_POSIX_SOCKETS_IO_NAMES +int +fcntl(int s, int cmd, ...) +{ + va_list ap; + int val; + + va_start(ap, cmd); + val = va_arg(ap, int); + va_end(ap); + return lwip_fcntl(s, cmd, val); +} +#endif + +const char * +lwip_inet_ntop(int af, const void *src, char *dst, socklen_t size) +{ + const char *ret = NULL; + int size_int = (int)size; + if (size_int < 0) { + set_errno(ENOSPC); + return NULL; + } + switch (af) { +#if LWIP_IPV4 + case AF_INET: + ret = ip4addr_ntoa_r((const ip4_addr_t *)src, dst, size_int); + if (ret == NULL) { + set_errno(ENOSPC); + } + break; +#endif +#if LWIP_IPV6 + case AF_INET6: + ret = ip6addr_ntoa_r((const ip6_addr_t *)src, dst, size_int); + if (ret == NULL) { + set_errno(ENOSPC); + } + break; +#endif + default: + set_errno(EAFNOSUPPORT); + break; + } + return ret; +} + +int +lwip_inet_pton(int af, const char *src, void *dst) +{ + int err; + switch (af) { +#if LWIP_IPV4 + case AF_INET: + err = ip4addr_aton(src, (ip4_addr_t *)dst); + break; +#endif +#if LWIP_IPV6 + case AF_INET6: { + /* convert into temporary variable since ip6_addr_t might be larger + than in6_addr when scopes are enabled */ + ip6_addr_t addr; + err = ip6addr_aton(src, &addr); + if (err) { + memcpy(dst, &addr.addr, sizeof(addr.addr)); + } + break; + } +#endif + default: + err = -1; + set_errno(EAFNOSUPPORT); + break; + } + return err; +} + +#if LWIP_IGMP +/** Register a new IGMP membership. On socket close, the membership is dropped automatically. + * + * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). + * + * @return 1 on success, 0 on failure + */ +static int +lwip_socket_register_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr) +{ + struct lwip_sock *sock = get_socket(s); + int i; + + if (!sock) { + return 0; + } + + for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { + if (socket_ipv4_multicast_memberships[i].sock == NULL) { + socket_ipv4_multicast_memberships[i].sock = sock; + ip4_addr_copy(socket_ipv4_multicast_memberships[i].if_addr, *if_addr); + ip4_addr_copy(socket_ipv4_multicast_memberships[i].multi_addr, *multi_addr); + done_socket(sock); + return 1; + } + } + done_socket(sock); + return 0; +} + +/** Unregister a previously registered membership. This prevents dropping the membership + * on socket close. + * + * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). + */ +static void +lwip_socket_unregister_membership(int s, const ip4_addr_t *if_addr, const ip4_addr_t *multi_addr) +{ + struct lwip_sock *sock = get_socket(s); + int i; + + if (!sock) { + return; + } + + for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { + if ((socket_ipv4_multicast_memberships[i].sock == sock) && + ip4_addr_cmp(&socket_ipv4_multicast_memberships[i].if_addr, if_addr) && + ip4_addr_cmp(&socket_ipv4_multicast_memberships[i].multi_addr, multi_addr)) { + socket_ipv4_multicast_memberships[i].sock = NULL; + ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].if_addr); + ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].multi_addr); + break; + } + } + done_socket(sock); +} + +/** Drop all memberships of a socket that were not dropped explicitly via setsockopt. + * + * ATTENTION: this function is NOT called from tcpip_thread (or under CORE_LOCK). + */ +static void +lwip_socket_drop_registered_memberships(int s) +{ + struct lwip_sock *sock = get_socket(s); + int i; + + if (!sock) { + return; + } + + for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { + if (socket_ipv4_multicast_memberships[i].sock == sock) { + ip_addr_t multi_addr, if_addr; + ip_addr_copy_from_ip4(multi_addr, socket_ipv4_multicast_memberships[i].multi_addr); + ip_addr_copy_from_ip4(if_addr, socket_ipv4_multicast_memberships[i].if_addr); + socket_ipv4_multicast_memberships[i].sock = NULL; + ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].if_addr); + ip4_addr_set_zero(&socket_ipv4_multicast_memberships[i].multi_addr); + + netconn_join_leave_group(sock->conn, &multi_addr, &if_addr, NETCONN_LEAVE); + } + } + done_socket(sock); +} +#endif /* LWIP_IGMP */ + +#if LWIP_IPV6_MLD +/** Register a new MLD6 membership. On socket close, the membership is dropped automatically. + * + * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). + * + * @return 1 on success, 0 on failure + */ +static int +lwip_socket_register_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr) +{ + struct lwip_sock *sock = get_socket(s); + int i; + + if (!sock) { + return 0; + } + + for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { + if (socket_ipv6_multicast_memberships[i].sock == NULL) { + socket_ipv6_multicast_memberships[i].sock = sock; + socket_ipv6_multicast_memberships[i].if_idx = (u8_t)if_idx; + ip6_addr_copy(socket_ipv6_multicast_memberships[i].multi_addr, *multi_addr); + done_socket(sock); + return 1; + } + } + done_socket(sock); + return 0; +} + +/** Unregister a previously registered MLD6 membership. This prevents dropping the membership + * on socket close. + * + * ATTENTION: this function is called from tcpip_thread (or under CORE_LOCK). + */ +static void +lwip_socket_unregister_mld6_membership(int s, unsigned int if_idx, const ip6_addr_t *multi_addr) +{ + struct lwip_sock *sock = get_socket(s); + int i; + + if (!sock) { + return; + } + + for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { + if ((socket_ipv6_multicast_memberships[i].sock == sock) && + (socket_ipv6_multicast_memberships[i].if_idx == if_idx) && + ip6_addr_cmp(&socket_ipv6_multicast_memberships[i].multi_addr, multi_addr)) { + socket_ipv6_multicast_memberships[i].sock = NULL; + socket_ipv6_multicast_memberships[i].if_idx = NETIF_NO_INDEX; + ip6_addr_set_zero(&socket_ipv6_multicast_memberships[i].multi_addr); + break; + } + } + done_socket(sock); +} + +/** Drop all MLD6 memberships of a socket that were not dropped explicitly via setsockopt. + * + * ATTENTION: this function is NOT called from tcpip_thread (or under CORE_LOCK). + */ +static void +lwip_socket_drop_registered_mld6_memberships(int s) +{ + struct lwip_sock *sock = get_socket(s); + int i; + + if (!sock) { + return; + } + + for (i = 0; i < LWIP_SOCKET_MAX_MEMBERSHIPS; i++) { + if (socket_ipv6_multicast_memberships[i].sock == sock) { + ip_addr_t multi_addr; + u8_t if_idx; + + ip_addr_copy_from_ip6(multi_addr, socket_ipv6_multicast_memberships[i].multi_addr); + if_idx = socket_ipv6_multicast_memberships[i].if_idx; + + socket_ipv6_multicast_memberships[i].sock = NULL; + socket_ipv6_multicast_memberships[i].if_idx = NETIF_NO_INDEX; + ip6_addr_set_zero(&socket_ipv6_multicast_memberships[i].multi_addr); + + netconn_join_leave_group_netif(sock->conn, &multi_addr, if_idx, NETCONN_LEAVE); + } + } + done_socket(sock); +} +#endif /* LWIP_IPV6_MLD */ + +#endif /* LWIP_SOCKET */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/tcpip.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/tcpip.c index 34c9a991..2ee532a7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/tcpip.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/api/tcpip.c @@ -1,658 +1,664 @@ -/** - * @file - * Sequential API Main thread module - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if !NO_SYS /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/priv/tcpip_priv.h" -#include "lwip/sys.h" -#include "lwip/memp.h" -#include "lwip/mem.h" -#include "lwip/init.h" -#include "lwip/ip.h" -#include "lwip/pbuf.h" -#include "lwip/etharp.h" -#include "netif/ethernet.h" - -#define TCPIP_MSG_VAR_REF(name) API_VAR_REF(name) -#define TCPIP_MSG_VAR_DECLARE(name) API_VAR_DECLARE(struct tcpip_msg, name) -#define TCPIP_MSG_VAR_ALLOC(name) API_VAR_ALLOC(struct tcpip_msg, MEMP_TCPIP_MSG_API, name, ERR_MEM) -#define TCPIP_MSG_VAR_FREE(name) API_VAR_FREE(MEMP_TCPIP_MSG_API, name) - -/* global variables */ -static tcpip_init_done_fn tcpip_init_done; -static void *tcpip_init_done_arg; -static sys_mbox_t tcpip_mbox; - -#if LWIP_TCPIP_CORE_LOCKING -/** The global semaphore to lock the stack. */ -sys_mutex_t lock_tcpip_core; -#endif /* LWIP_TCPIP_CORE_LOCKING */ - -static void tcpip_thread_handle_msg(struct tcpip_msg *msg); - -#if !LWIP_TIMERS -/* wait for a message with timers disabled (e.g. pass a timer-check trigger into tcpip_thread) */ -#define TCPIP_MBOX_FETCH(mbox, msg) sys_mbox_fetch(mbox, msg) -#else /* !LWIP_TIMERS */ -/* wait for a message, timeouts are processed while waiting */ -#define TCPIP_MBOX_FETCH(mbox, msg) tcpip_timeouts_mbox_fetch(mbox, msg) -/** - * Wait (forever) for a message to arrive in an mbox. - * While waiting, timeouts are processed. - * - * @param mbox the mbox to fetch the message from - * @param msg the place to store the message - */ -static void -tcpip_timeouts_mbox_fetch(sys_mbox_t *mbox, void **msg) -{ - u32_t sleeptime, res; - -again: - LWIP_ASSERT_CORE_LOCKED(); - - sleeptime = sys_timeouts_sleeptime(); - if (sleeptime == SYS_TIMEOUTS_SLEEPTIME_INFINITE) { - UNLOCK_TCPIP_CORE(); - sys_arch_mbox_fetch(mbox, msg, 0); - LOCK_TCPIP_CORE(); - return; - } else if (sleeptime == 0) { - sys_check_timeouts(); - /* We try again to fetch a message from the mbox. */ - goto again; - } - - UNLOCK_TCPIP_CORE(); - res = sys_arch_mbox_fetch(mbox, msg, sleeptime); - LOCK_TCPIP_CORE(); - if (res == SYS_ARCH_TIMEOUT) { - /* If a SYS_ARCH_TIMEOUT value is returned, a timeout occurred - before a message could be fetched. */ - sys_check_timeouts(); - /* We try again to fetch a message from the mbox. */ - goto again; - } -} -#endif /* !LWIP_TIMERS */ - -/** - * The main lwIP thread. This thread has exclusive access to lwIP core functions - * (unless access to them is not locked). Other threads communicate with this - * thread using message boxes. - * - * It also starts all the timers to make sure they are running in the right - * thread context. - * - * @param arg unused argument - */ -static void -tcpip_thread(void *arg) -{ - struct tcpip_msg *msg; - LWIP_UNUSED_ARG(arg); - - LWIP_MARK_TCPIP_THREAD(); - - LOCK_TCPIP_CORE(); - if (tcpip_init_done != NULL) { - tcpip_init_done(tcpip_init_done_arg); - } - - while (1) { /* MAIN Loop */ - LWIP_TCPIP_THREAD_ALIVE(); - /* wait for a message, timeouts are processed while waiting */ - TCPIP_MBOX_FETCH(&tcpip_mbox, (void **)&msg); - if (msg == NULL) { - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: NULL\n")); - LWIP_ASSERT("tcpip_thread: invalid message", 0); - continue; - } - tcpip_thread_handle_msg(msg); - } -} - -/* Handle a single tcpip_msg - * This is in its own function for access by tests only. - */ -static void -tcpip_thread_handle_msg(struct tcpip_msg *msg) -{ - switch (msg->type) { -#if !LWIP_TCPIP_CORE_LOCKING - case TCPIP_MSG_API: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg)); - msg->msg.api_msg.function(msg->msg.api_msg.msg); - break; - case TCPIP_MSG_API_CALL: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API CALL message %p\n", (void *)msg)); - msg->msg.api_call.arg->err = msg->msg.api_call.function(msg->msg.api_call.arg); - sys_sem_signal(msg->msg.api_call.sem); - break; -#endif /* !LWIP_TCPIP_CORE_LOCKING */ - -#if !LWIP_TCPIP_CORE_LOCKING_INPUT - case TCPIP_MSG_INPKT: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg)); - if (msg->msg.inp.input_fn(msg->msg.inp.p, msg->msg.inp.netif) != ERR_OK) { - pbuf_free(msg->msg.inp.p); - } - memp_free(MEMP_TCPIP_MSG_INPKT, msg); - break; -#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ - -#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS - case TCPIP_MSG_TIMEOUT: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg)); - sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg); - memp_free(MEMP_TCPIP_MSG_API, msg); - break; - case TCPIP_MSG_UNTIMEOUT: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg)); - sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg); - memp_free(MEMP_TCPIP_MSG_API, msg); - break; -#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ - - case TCPIP_MSG_CALLBACK: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg)); - msg->msg.cb.function(msg->msg.cb.ctx); - memp_free(MEMP_TCPIP_MSG_API, msg); - break; - - case TCPIP_MSG_CALLBACK_STATIC: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK_STATIC %p\n", (void *)msg)); - msg->msg.cb.function(msg->msg.cb.ctx); - break; - - default: - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: %d\n", msg->type)); - LWIP_ASSERT("tcpip_thread: invalid message", 0); - break; - } -} - -#ifdef TCPIP_THREAD_TEST -/** Work on queued items in single-threaded test mode */ -int -tcpip_thread_poll_one(void) -{ - int ret = 0; - struct tcpip_msg *msg; - - if (sys_arch_mbox_tryfetch(&tcpip_mbox, (void **)&msg) != SYS_ARCH_TIMEOUT) { - LOCK_TCPIP_CORE(); - if (msg != NULL) { - tcpip_thread_handle_msg(msg); - ret = 1; - } - UNLOCK_TCPIP_CORE(); - } - return ret; -} -#endif - -/** - * Pass a received packet to tcpip_thread for input processing - * - * @param p the received packet - * @param inp the network interface on which the packet was received - * @param input_fn input function to call - */ -err_t -tcpip_inpkt(struct pbuf *p, struct netif *inp, netif_input_fn input_fn) -{ -#if LWIP_TCPIP_CORE_LOCKING_INPUT - err_t ret; - LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_inpkt: PACKET %p/%p\n", (void *)p, (void *)inp)); - LOCK_TCPIP_CORE(); - ret = input_fn(p, inp); - UNLOCK_TCPIP_CORE(); - return ret; -#else /* LWIP_TCPIP_CORE_LOCKING_INPUT */ - struct tcpip_msg *msg; - - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - - msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_INPKT); - if (msg == NULL) { - return ERR_MEM; - } - - msg->type = TCPIP_MSG_INPKT; - msg->msg.inp.p = p; - msg->msg.inp.netif = inp; - msg->msg.inp.input_fn = input_fn; - if (sys_mbox_trypost(&tcpip_mbox, msg) != ERR_OK) { - memp_free(MEMP_TCPIP_MSG_INPKT, msg); - return ERR_MEM; - } - return ERR_OK; -#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */ -} - -/** - * @ingroup lwip_os - * Pass a received packet to tcpip_thread for input processing with - * ethernet_input or ip_input. Don't call directly, pass to netif_add() - * and call netif->input(). - * - * @param p the received packet, p->payload pointing to the Ethernet header or - * to an IP header (if inp doesn't have NETIF_FLAG_ETHARP or - * NETIF_FLAG_ETHERNET flags) - * @param inp the network interface on which the packet was received - */ -err_t -tcpip_input(struct pbuf *p, struct netif *inp) -{ -#if LWIP_ETHERNET - if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) { - return tcpip_inpkt(p, inp, ethernet_input); - } else -#endif /* LWIP_ETHERNET */ - return tcpip_inpkt(p, inp, ip_input); -} - -/** - * @ingroup lwip_os - * Call a specific function in the thread context of - * tcpip_thread for easy access synchronization. - * A function called in that way may access lwIP core code - * without fearing concurrent access. - * Blocks until the request is posted. - * Must not be called from interrupt context! - * - * @param function the function to call - * @param ctx parameter passed to f - * @return ERR_OK if the function was called, another err_t if not - * - * @see tcpip_try_callback - */ -err_t -tcpip_callback(tcpip_callback_fn function, void *ctx) -{ - struct tcpip_msg *msg; - - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - - msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); - if (msg == NULL) { - return ERR_MEM; - } - - msg->type = TCPIP_MSG_CALLBACK; - msg->msg.cb.function = function; - msg->msg.cb.ctx = ctx; - - sys_mbox_post(&tcpip_mbox, msg); - return ERR_OK; -} - -/** - * @ingroup lwip_os - * Call a specific function in the thread context of - * tcpip_thread for easy access synchronization. - * A function called in that way may access lwIP core code - * without fearing concurrent access. - * Does NOT block when the request cannot be posted because the - * tcpip_mbox is full, but returns ERR_MEM instead. - * Can be called from interrupt context. - * - * @param function the function to call - * @param ctx parameter passed to f - * @return ERR_OK if the function was called, another err_t if not - * - * @see tcpip_callback - */ -err_t -tcpip_try_callback(tcpip_callback_fn function, void *ctx) -{ - struct tcpip_msg *msg; - - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - - msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); - if (msg == NULL) { - return ERR_MEM; - } - - msg->type = TCPIP_MSG_CALLBACK; - msg->msg.cb.function = function; - msg->msg.cb.ctx = ctx; - - if (sys_mbox_trypost(&tcpip_mbox, msg) != ERR_OK) { - memp_free(MEMP_TCPIP_MSG_API, msg); - return ERR_MEM; - } - return ERR_OK; -} - -#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS -/** - * call sys_timeout in tcpip_thread - * - * @param msecs time in milliseconds for timeout - * @param h function to be called on timeout - * @param arg argument to pass to timeout function h - * @return ERR_MEM on memory error, ERR_OK otherwise - */ -err_t -tcpip_timeout(u32_t msecs, sys_timeout_handler h, void *arg) -{ - struct tcpip_msg *msg; - - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - - msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); - if (msg == NULL) { - return ERR_MEM; - } - - msg->type = TCPIP_MSG_TIMEOUT; - msg->msg.tmo.msecs = msecs; - msg->msg.tmo.h = h; - msg->msg.tmo.arg = arg; - sys_mbox_post(&tcpip_mbox, msg); - return ERR_OK; -} - -/** - * call sys_untimeout in tcpip_thread - * - * @param h function to be called on timeout - * @param arg argument to pass to timeout function h - * @return ERR_MEM on memory error, ERR_OK otherwise - */ -err_t -tcpip_untimeout(sys_timeout_handler h, void *arg) -{ - struct tcpip_msg *msg; - - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - - msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); - if (msg == NULL) { - return ERR_MEM; - } - - msg->type = TCPIP_MSG_UNTIMEOUT; - msg->msg.tmo.h = h; - msg->msg.tmo.arg = arg; - sys_mbox_post(&tcpip_mbox, msg); - return ERR_OK; -} -#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ - - -/** - * Sends a message to TCPIP thread to call a function. Caller thread blocks on - * on a provided semaphore, which ist NOT automatically signalled by TCPIP thread, - * this has to be done by the user. - * It is recommended to use LWIP_TCPIP_CORE_LOCKING since this is the way - * with least runtime overhead. - * - * @param fn function to be called from TCPIP thread - * @param apimsg argument to API function - * @param sem semaphore to wait on - * @return ERR_OK if the function was called, another err_t if not - */ -err_t -tcpip_send_msg_wait_sem(tcpip_callback_fn fn, void *apimsg, sys_sem_t *sem) -{ -#if LWIP_TCPIP_CORE_LOCKING - LWIP_UNUSED_ARG(sem); - LOCK_TCPIP_CORE(); - fn(apimsg); - UNLOCK_TCPIP_CORE(); - return ERR_OK; -#else /* LWIP_TCPIP_CORE_LOCKING */ - TCPIP_MSG_VAR_DECLARE(msg); - - LWIP_ASSERT("semaphore not initialized", sys_sem_valid(sem)); - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - - TCPIP_MSG_VAR_ALLOC(msg); - TCPIP_MSG_VAR_REF(msg).type = TCPIP_MSG_API; - TCPIP_MSG_VAR_REF(msg).msg.api_msg.function = fn; - TCPIP_MSG_VAR_REF(msg).msg.api_msg.msg = apimsg; - sys_mbox_post(&tcpip_mbox, &TCPIP_MSG_VAR_REF(msg)); - sys_arch_sem_wait(sem, 0); - TCPIP_MSG_VAR_FREE(msg); - return ERR_OK; -#endif /* LWIP_TCPIP_CORE_LOCKING */ -} - -/** - * Synchronously calls function in TCPIP thread and waits for its completion. - * It is recommended to use LWIP_TCPIP_CORE_LOCKING (preferred) or - * LWIP_NETCONN_SEM_PER_THREAD. - * If not, a semaphore is created and destroyed on every call which is usually - * an expensive/slow operation. - * @param fn Function to call - * @param call Call parameters - * @return Return value from tcpip_api_call_fn - */ -err_t -tcpip_api_call(tcpip_api_call_fn fn, struct tcpip_api_call_data *call) -{ -#if LWIP_TCPIP_CORE_LOCKING - err_t err; - LOCK_TCPIP_CORE(); - err = fn(call); - UNLOCK_TCPIP_CORE(); - return err; -#else /* LWIP_TCPIP_CORE_LOCKING */ - TCPIP_MSG_VAR_DECLARE(msg); - -#if !LWIP_NETCONN_SEM_PER_THREAD - err_t err = sys_sem_new(&call->sem, 0); - if (err != ERR_OK) { - return err; - } -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - - TCPIP_MSG_VAR_ALLOC(msg); - TCPIP_MSG_VAR_REF(msg).type = TCPIP_MSG_API_CALL; - TCPIP_MSG_VAR_REF(msg).msg.api_call.arg = call; - TCPIP_MSG_VAR_REF(msg).msg.api_call.function = fn; -#if LWIP_NETCONN_SEM_PER_THREAD - TCPIP_MSG_VAR_REF(msg).msg.api_call.sem = LWIP_NETCONN_THREAD_SEM_GET(); -#else /* LWIP_NETCONN_SEM_PER_THREAD */ - TCPIP_MSG_VAR_REF(msg).msg.api_call.sem = &call->sem; -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - sys_mbox_post(&tcpip_mbox, &TCPIP_MSG_VAR_REF(msg)); - sys_arch_sem_wait(TCPIP_MSG_VAR_REF(msg).msg.api_call.sem, 0); - TCPIP_MSG_VAR_FREE(msg); - -#if !LWIP_NETCONN_SEM_PER_THREAD - sys_sem_free(&call->sem); -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - - return call->err; -#endif /* LWIP_TCPIP_CORE_LOCKING */ -} - -/** - * @ingroup lwip_os - * Allocate a structure for a static callback message and initialize it. - * The message has a special type such that lwIP never frees it. - * This is intended to be used to send "static" messages from interrupt context, - * e.g. the message is allocated once and posted several times from an IRQ - * using tcpip_callbackmsg_trycallback(). - * Example usage: Trigger execution of an ethernet IRQ DPC routine in lwIP thread context. - * - * @param function the function to call - * @param ctx parameter passed to function - * @return a struct pointer to pass to tcpip_callbackmsg_trycallback(). - * - * @see tcpip_callbackmsg_trycallback() - * @see tcpip_callbackmsg_delete() - */ -struct tcpip_callback_msg * -tcpip_callbackmsg_new(tcpip_callback_fn function, void *ctx) -{ - struct tcpip_msg *msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); - if (msg == NULL) { - return NULL; - } - msg->type = TCPIP_MSG_CALLBACK_STATIC; - msg->msg.cb.function = function; - msg->msg.cb.ctx = ctx; - return (struct tcpip_callback_msg *)msg; -} - -/** - * @ingroup lwip_os - * Free a callback message allocated by tcpip_callbackmsg_new(). - * - * @param msg the message to free - * - * @see tcpip_callbackmsg_new() - */ -void -tcpip_callbackmsg_delete(struct tcpip_callback_msg *msg) -{ - memp_free(MEMP_TCPIP_MSG_API, msg); -} - -/** - * @ingroup lwip_os - * Try to post a callback-message to the tcpip_thread tcpip_mbox. - * - * @param msg pointer to the message to post - * @return sys_mbox_trypost() return code - * - * @see tcpip_callbackmsg_new() - */ -err_t -tcpip_callbackmsg_trycallback(struct tcpip_callback_msg *msg) -{ - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - return sys_mbox_trypost(&tcpip_mbox, msg); -} - -/** - * @ingroup lwip_os - * Try to post a callback-message to the tcpip_thread mbox. - * Same as @ref tcpip_callbackmsg_trycallback but calls sys_mbox_trypost_fromisr(), - * mainly to help FreeRTOS, where calls differ between task level and ISR level. - * - * @param msg pointer to the message to post - * @return sys_mbox_trypost_fromisr() return code (without change, so this - * knowledge can be used to e.g. propagate "bool needs_scheduling") - * - * @see tcpip_callbackmsg_new() - */ -err_t -tcpip_callbackmsg_trycallback_fromisr(struct tcpip_callback_msg *msg) -{ - LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); - return sys_mbox_trypost_fromisr(&tcpip_mbox, msg); -} - -/** - * @ingroup lwip_os - * Initialize this module: - * - initialize all sub modules - * - start the tcpip_thread - * - * @param initfunc a function to call when tcpip_thread is running and finished initializing - * @param arg argument to pass to initfunc - */ -void -tcpip_init(tcpip_init_done_fn initfunc, void *arg) -{ - lwip_init(); - - tcpip_init_done = initfunc; - tcpip_init_done_arg = arg; - if (sys_mbox_new(&tcpip_mbox, TCPIP_MBOX_SIZE) != ERR_OK) { - LWIP_ASSERT("failed to create tcpip_thread mbox", 0); - } -#if LWIP_TCPIP_CORE_LOCKING - if (sys_mutex_new(&lock_tcpip_core) != ERR_OK) { - LWIP_ASSERT("failed to create lock_tcpip_core", 0); - } -#endif /* LWIP_TCPIP_CORE_LOCKING */ - - sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO); -} - -/** - * Simple callback function used with tcpip_callback to free a pbuf - * (pbuf_free has a wrong signature for tcpip_callback) - * - * @param p The pbuf (chain) to be dereferenced. - */ -static void -pbuf_free_int(void *p) -{ - struct pbuf *q = (struct pbuf *)p; - pbuf_free(q); -} - -/** - * A simple wrapper function that allows you to free a pbuf from interrupt context. - * - * @param p The pbuf (chain) to be dereferenced. - * @return ERR_OK if callback could be enqueued, an err_t if not - */ -err_t -pbuf_free_callback(struct pbuf *p) -{ - return tcpip_try_callback(pbuf_free_int, p); -} - -/** - * A simple wrapper function that allows you to free heap memory from - * interrupt context. - * - * @param m the heap memory to free - * @return ERR_OK if callback could be enqueued, an err_t if not - */ -err_t -mem_free_callback(void *m) -{ - return tcpip_try_callback(mem_free, m); -} - -#endif /* !NO_SYS */ +/** + * @file + * Sequential API Main thread module + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if !NO_SYS /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/priv/tcpip_priv.h" +#include "lwip/sys.h" +#include "lwip/memp.h" +#include "lwip/mem.h" +#include "lwip/init.h" +#include "lwip/ip.h" +#include "lwip/pbuf.h" +#include "lwip/etharp.h" +#include "netif/ethernet.h" + +#define TCPIP_MSG_VAR_REF(name) API_VAR_REF(name) +#define TCPIP_MSG_VAR_DECLARE(name) API_VAR_DECLARE(struct tcpip_msg, name) +#define TCPIP_MSG_VAR_ALLOC(name) API_VAR_ALLOC(struct tcpip_msg, MEMP_TCPIP_MSG_API, name, ERR_MEM) +#define TCPIP_MSG_VAR_FREE(name) API_VAR_FREE(MEMP_TCPIP_MSG_API, name) + +/* global variables */ +static tcpip_init_done_fn tcpip_init_done; +static void *tcpip_init_done_arg; +static sys_mbox_t tcpip_mbox; + +#if LWIP_TCPIP_CORE_LOCKING +/** The global semaphore to lock the stack. */ +sys_mutex_t lock_tcpip_core; +#endif /* LWIP_TCPIP_CORE_LOCKING */ + +static void tcpip_thread_handle_msg(struct tcpip_msg *msg); + +#if !LWIP_TIMERS +/* wait for a message with timers disabled (e.g. pass a timer-check trigger into tcpip_thread) */ +#define TCPIP_MBOX_FETCH(mbox, msg) sys_mbox_fetch(mbox, msg) +#else /* !LWIP_TIMERS */ +/* wait for a message, timeouts are processed while waiting */ +#define TCPIP_MBOX_FETCH(mbox, msg) tcpip_timeouts_mbox_fetch(mbox, msg) +/** + * Wait (forever) for a message to arrive in an mbox. + * While waiting, timeouts are processed. + * + * @param mbox the mbox to fetch the message from + * @param msg the place to store the message + */ +static void +tcpip_timeouts_mbox_fetch(sys_mbox_t *mbox, void **msg) +{ + u32_t sleeptime, res; + +again: + LWIP_ASSERT_CORE_LOCKED(); + + sleeptime = sys_timeouts_sleeptime(); + if (sleeptime == SYS_TIMEOUTS_SLEEPTIME_INFINITE) { + UNLOCK_TCPIP_CORE(); + sys_arch_mbox_fetch(mbox, msg, 0); + LOCK_TCPIP_CORE(); + return; + } else if (sleeptime == 0) { + sys_check_timeouts(); + /* We try again to fetch a message from the mbox. */ + goto again; + } + + UNLOCK_TCPIP_CORE(); + res = sys_arch_mbox_fetch(mbox, msg, sleeptime); + LOCK_TCPIP_CORE(); + if (res == SYS_ARCH_TIMEOUT) { + /* If a SYS_ARCH_TIMEOUT value is returned, a timeout occurred + before a message could be fetched. */ + sys_check_timeouts(); + /* We try again to fetch a message from the mbox. */ + goto again; + } +} +#endif /* !LWIP_TIMERS */ + +/** + * The main lwIP thread. This thread has exclusive access to lwIP core functions + * (unless access to them is not locked). Other threads communicate with this + * thread using message boxes. + * + * It also starts all the timers to make sure they are running in the right + * thread context. + * + * @param arg unused argument + */ +static void +tcpip_thread(void *arg) +{ + struct tcpip_msg *msg; + LWIP_UNUSED_ARG(arg); + + LWIP_MARK_TCPIP_THREAD(); + + LOCK_TCPIP_CORE(); + if (tcpip_init_done != NULL) { + tcpip_init_done(tcpip_init_done_arg); + } + + while (1) { /* MAIN Loop */ + LWIP_TCPIP_THREAD_ALIVE(); + /* wait for a message, timeouts are processed while waiting */ + TCPIP_MBOX_FETCH(&tcpip_mbox, (void **)&msg); + if (msg == NULL) { + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: NULL\n")); + LWIP_ASSERT("tcpip_thread: invalid message", 0); + continue; + } + tcpip_thread_handle_msg(msg); + } +} + +/* Handle a single tcpip_msg + * This is in its own function for access by tests only. + */ +static void +tcpip_thread_handle_msg(struct tcpip_msg *msg) +{ + switch (msg->type) { +#if !LWIP_TCPIP_CORE_LOCKING + case TCPIP_MSG_API: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API message %p\n", (void *)msg)); + msg->msg.api_msg.function(msg->msg.api_msg.msg); + break; + case TCPIP_MSG_API_CALL: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: API CALL message %p\n", (void *)msg)); + msg->msg.api_call.arg->err = msg->msg.api_call.function(msg->msg.api_call.arg); + sys_sem_signal(msg->msg.api_call.sem); + break; +#endif /* !LWIP_TCPIP_CORE_LOCKING */ + +#if !LWIP_TCPIP_CORE_LOCKING_INPUT + case TCPIP_MSG_INPKT: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: PACKET %p\n", (void *)msg)); + if (msg->msg.inp.input_fn(msg->msg.inp.p, msg->msg.inp.netif) != ERR_OK) { + pbuf_free(msg->msg.inp.p); + } + memp_free(MEMP_TCPIP_MSG_INPKT, msg); + break; +#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ + +#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS + case TCPIP_MSG_TIMEOUT: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: TIMEOUT %p\n", (void *)msg)); + sys_timeout(msg->msg.tmo.msecs, msg->msg.tmo.h, msg->msg.tmo.arg); + memp_free(MEMP_TCPIP_MSG_API, msg); + break; + case TCPIP_MSG_UNTIMEOUT: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: UNTIMEOUT %p\n", (void *)msg)); + sys_untimeout(msg->msg.tmo.h, msg->msg.tmo.arg); + memp_free(MEMP_TCPIP_MSG_API, msg); + break; +#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ + + case TCPIP_MSG_CALLBACK: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK %p\n", (void *)msg)); + msg->msg.cb.function(msg->msg.cb.ctx); + memp_free(MEMP_TCPIP_MSG_API, msg); + break; + + case TCPIP_MSG_CALLBACK_STATIC: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: CALLBACK_STATIC %p\n", (void *)msg)); + msg->msg.cb.function(msg->msg.cb.ctx); + break; + + default: + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_thread: invalid message: %d\n", msg->type)); + LWIP_ASSERT("tcpip_thread: invalid message", 0); + break; + } +} + +#ifdef TCPIP_THREAD_TEST +/** Work on queued items in single-threaded test mode */ +int +tcpip_thread_poll_one(void) +{ + int ret = 0; + struct tcpip_msg *msg; + + if (sys_arch_mbox_tryfetch(&tcpip_mbox, (void **)&msg) != SYS_ARCH_TIMEOUT) { + LOCK_TCPIP_CORE(); + if (msg != NULL) { + tcpip_thread_handle_msg(msg); + ret = 1; + } + UNLOCK_TCPIP_CORE(); + } + return ret; +} +#endif + +/** + * Pass a received packet to tcpip_thread for input processing + * + * @param p the received packet + * @param inp the network interface on which the packet was received + * @param input_fn input function to call + */ +err_t +tcpip_inpkt(struct pbuf *p, struct netif *inp, netif_input_fn input_fn) +{ +#if LWIP_TCPIP_CORE_LOCKING_INPUT + err_t ret; + LWIP_DEBUGF(TCPIP_DEBUG, ("tcpip_inpkt: PACKET %p/%p\n", (void *)p, (void *)inp)); + LOCK_TCPIP_CORE(); + ret = input_fn(p, inp); + UNLOCK_TCPIP_CORE(); + return ret; +#else /* LWIP_TCPIP_CORE_LOCKING_INPUT */ + struct tcpip_msg *msg; + + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + + msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_INPKT); + if (msg == NULL) { + return ERR_MEM; + } + + msg->type = TCPIP_MSG_INPKT; + msg->msg.inp.p = p; + msg->msg.inp.netif = inp; + msg->msg.inp.input_fn = input_fn; + if (sys_mbox_trypost(&tcpip_mbox, msg) != ERR_OK) { + memp_free(MEMP_TCPIP_MSG_INPKT, msg); + return ERR_MEM; + } + return ERR_OK; +#endif /* LWIP_TCPIP_CORE_LOCKING_INPUT */ +} + +/** + * @ingroup lwip_os + * Pass a received packet to tcpip_thread for input processing with + * ethernet_input or ip_input. Don't call directly, pass to netif_add() + * and call netif->input(). + * + * @param p the received packet, p->payload pointing to the Ethernet header or + * to an IP header (if inp doesn't have NETIF_FLAG_ETHARP or + * NETIF_FLAG_ETHERNET flags) + * @param inp the network interface on which the packet was received + */ +err_t +tcpip_input(struct pbuf *p, struct netif *inp) +{ +#if LWIP_ETHERNET + if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) { + return tcpip_inpkt(p, inp, ethernet_input); + } else +#endif /* LWIP_ETHERNET */ + return tcpip_inpkt(p, inp, ip_input); +} + +/** + * @ingroup lwip_os + * Call a specific function in the thread context of + * tcpip_thread for easy access synchronization. + * A function called in that way may access lwIP core code + * without fearing concurrent access. + * Blocks until the request is posted. + * Must not be called from interrupt context! + * + * @param function the function to call + * @param ctx parameter passed to f + * @return ERR_OK if the function was called, another err_t if not + * + * @see tcpip_try_callback + */ +err_t +tcpip_callback(tcpip_callback_fn function, void *ctx) +{ + struct tcpip_msg *msg; + + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + + msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); + if (msg == NULL) { + return ERR_MEM; + } + + msg->type = TCPIP_MSG_CALLBACK; + msg->msg.cb.function = function; + msg->msg.cb.ctx = ctx; + + sys_mbox_post(&tcpip_mbox, msg); + return ERR_OK; +} + +/** + * @ingroup lwip_os + * Call a specific function in the thread context of + * tcpip_thread for easy access synchronization. + * A function called in that way may access lwIP core code + * without fearing concurrent access. + * Does NOT block when the request cannot be posted because the + * tcpip_mbox is full, but returns ERR_MEM instead. + * Can be called from interrupt context. + * + * @param function the function to call + * @param ctx parameter passed to f + * @return ERR_OK if the function was called, another err_t if not + * + * @see tcpip_callback + */ +err_t +tcpip_try_callback(tcpip_callback_fn function, void *ctx) +{ + struct tcpip_msg *msg; + + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + + msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); + if (msg == NULL) { + return ERR_MEM; + } + + msg->type = TCPIP_MSG_CALLBACK; + msg->msg.cb.function = function; + msg->msg.cb.ctx = ctx; + + if (sys_mbox_trypost(&tcpip_mbox, msg) != ERR_OK) { + memp_free(MEMP_TCPIP_MSG_API, msg); + return ERR_MEM; + } + return ERR_OK; +} + +#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS +/** + * call sys_timeout in tcpip_thread + * + * @param msecs time in milliseconds for timeout + * @param h function to be called on timeout + * @param arg argument to pass to timeout function h + * @return ERR_MEM on memory error, ERR_OK otherwise + */ +err_t +tcpip_timeout(u32_t msecs, sys_timeout_handler h, void *arg) +{ + struct tcpip_msg *msg; + + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + + msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); + if (msg == NULL) { + return ERR_MEM; + } + + msg->type = TCPIP_MSG_TIMEOUT; + msg->msg.tmo.msecs = msecs; + msg->msg.tmo.h = h; + msg->msg.tmo.arg = arg; + sys_mbox_post(&tcpip_mbox, msg); + return ERR_OK; +} + +/** + * call sys_untimeout in tcpip_thread + * + * @param h function to be called on timeout + * @param arg argument to pass to timeout function h + * @return ERR_MEM on memory error, ERR_OK otherwise + */ +err_t +tcpip_untimeout(sys_timeout_handler h, void *arg) +{ + struct tcpip_msg *msg; + + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + + msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); + if (msg == NULL) { + return ERR_MEM; + } + + msg->type = TCPIP_MSG_UNTIMEOUT; + msg->msg.tmo.h = h; + msg->msg.tmo.arg = arg; + sys_mbox_post(&tcpip_mbox, msg); + return ERR_OK; +} +#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ + + +/** + * Sends a message to TCPIP thread to call a function. Caller thread blocks on + * on a provided semaphore, which ist NOT automatically signalled by TCPIP thread, + * this has to be done by the user. + * It is recommended to use LWIP_TCPIP_CORE_LOCKING since this is the way + * with least runtime overhead. + * + * @param fn function to be called from TCPIP thread + * @param apimsg argument to API function + * @param sem semaphore to wait on + * @return ERR_OK if the function was called, another err_t if not + */ +err_t +tcpip_send_msg_wait_sem(tcpip_callback_fn fn, void *apimsg, sys_sem_t *sem) +{ +#if LWIP_TCPIP_CORE_LOCKING + LWIP_UNUSED_ARG(sem); + LOCK_TCPIP_CORE(); + fn(apimsg); + UNLOCK_TCPIP_CORE(); + return ERR_OK; +#else /* LWIP_TCPIP_CORE_LOCKING */ + TCPIP_MSG_VAR_DECLARE(msg); + + LWIP_ASSERT("semaphore not initialized", sys_sem_valid(sem)); + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + + TCPIP_MSG_VAR_ALLOC(msg); + TCPIP_MSG_VAR_REF(msg).type = TCPIP_MSG_API; + TCPIP_MSG_VAR_REF(msg).msg.api_msg.function = fn; + TCPIP_MSG_VAR_REF(msg).msg.api_msg.msg = apimsg; + sys_mbox_post(&tcpip_mbox, &TCPIP_MSG_VAR_REF(msg)); + sys_arch_sem_wait(sem, 0); + TCPIP_MSG_VAR_FREE(msg); + return ERR_OK; +#endif /* LWIP_TCPIP_CORE_LOCKING */ +} + +/** + * Synchronously calls function in TCPIP thread and waits for its completion. + * It is recommended to use LWIP_TCPIP_CORE_LOCKING (preferred) or + * LWIP_NETCONN_SEM_PER_THREAD. + * If not, a semaphore is created and destroyed on every call which is usually + * an expensive/slow operation. + * @param fn Function to call + * @param call Call parameters + * @return Return value from tcpip_api_call_fn + */ +err_t +tcpip_api_call(tcpip_api_call_fn fn, struct tcpip_api_call_data *call) +{ +#if LWIP_TCPIP_CORE_LOCKING + err_t err; + LOCK_TCPIP_CORE(); + err = fn(call); + UNLOCK_TCPIP_CORE(); + return err; +#else /* LWIP_TCPIP_CORE_LOCKING */ + TCPIP_MSG_VAR_DECLARE(msg); + +#if !LWIP_NETCONN_SEM_PER_THREAD + err_t err = sys_sem_new(&call->sem, 0); + if (err != ERR_OK) { + return err; + } +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + + TCPIP_MSG_VAR_ALLOC(msg); + TCPIP_MSG_VAR_REF(msg).type = TCPIP_MSG_API_CALL; + TCPIP_MSG_VAR_REF(msg).msg.api_call.arg = call; + TCPIP_MSG_VAR_REF(msg).msg.api_call.function = fn; +#if LWIP_NETCONN_SEM_PER_THREAD + TCPIP_MSG_VAR_REF(msg).msg.api_call.sem = LWIP_NETCONN_THREAD_SEM_GET(); +#else /* LWIP_NETCONN_SEM_PER_THREAD */ + TCPIP_MSG_VAR_REF(msg).msg.api_call.sem = &call->sem; +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + sys_mbox_post(&tcpip_mbox, &TCPIP_MSG_VAR_REF(msg)); + sys_arch_sem_wait(TCPIP_MSG_VAR_REF(msg).msg.api_call.sem, 0); + TCPIP_MSG_VAR_FREE(msg); + +#if !LWIP_NETCONN_SEM_PER_THREAD + sys_sem_free(&call->sem); +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + + return call->err; +#endif /* LWIP_TCPIP_CORE_LOCKING */ +} + +/** + * @ingroup lwip_os + * Allocate a structure for a static callback message and initialize it. + * The message has a special type such that lwIP never frees it. + * This is intended to be used to send "static" messages from interrupt context, + * e.g. the message is allocated once and posted several times from an IRQ + * using tcpip_callbackmsg_trycallback(). + * Example usage: Trigger execution of an ethernet IRQ DPC routine in lwIP thread context. + * + * @param function the function to call + * @param ctx parameter passed to function + * @return a struct pointer to pass to tcpip_callbackmsg_trycallback(). + * + * @see tcpip_callbackmsg_trycallback() + * @see tcpip_callbackmsg_delete() + */ +struct tcpip_callback_msg * +tcpip_callbackmsg_new(tcpip_callback_fn function, void *ctx) +{ + struct tcpip_msg *msg = (struct tcpip_msg *)memp_malloc(MEMP_TCPIP_MSG_API); + if (msg == NULL) { + return NULL; + } + msg->type = TCPIP_MSG_CALLBACK_STATIC; + msg->msg.cb.function = function; + msg->msg.cb.ctx = ctx; + return (struct tcpip_callback_msg *)msg; +} + +/** + * @ingroup lwip_os + * Free a callback message allocated by tcpip_callbackmsg_new(). + * + * @param msg the message to free + * + * @see tcpip_callbackmsg_new() + */ +void +tcpip_callbackmsg_delete(struct tcpip_callback_msg *msg) +{ + memp_free(MEMP_TCPIP_MSG_API, msg); +} + +/** + * @ingroup lwip_os + * Try to post a callback-message to the tcpip_thread tcpip_mbox. + * + * @param msg pointer to the message to post + * @return sys_mbox_trypost() return code + * + * @see tcpip_callbackmsg_new() + */ +err_t +tcpip_callbackmsg_trycallback(struct tcpip_callback_msg *msg) +{ + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + return sys_mbox_trypost(&tcpip_mbox, msg); +} + +/** + * @ingroup lwip_os + * Try to post a callback-message to the tcpip_thread mbox. + * Same as @ref tcpip_callbackmsg_trycallback but calls sys_mbox_trypost_fromisr(), + * mainly to help FreeRTOS, where calls differ between task level and ISR level. + * + * @param msg pointer to the message to post + * @return sys_mbox_trypost_fromisr() return code (without change, so this + * knowledge can be used to e.g. propagate "bool needs_scheduling") + * + * @see tcpip_callbackmsg_new() + */ +err_t +tcpip_callbackmsg_trycallback_fromisr(struct tcpip_callback_msg *msg) +{ + LWIP_ASSERT("Invalid mbox", sys_mbox_valid_val(tcpip_mbox)); + return sys_mbox_trypost_fromisr(&tcpip_mbox, msg); +} + +/** + * @ingroup lwip_os + * Initialize this module: + * - initialize all sub modules + * - start the tcpip_thread + * + * @param initfunc a function to call when tcpip_thread is running and finished initializing + * @param arg argument to pass to initfunc + */ +void +tcpip_init(tcpip_init_done_fn initfunc, void *arg) +{ + static int tcpip_flag = 0; + lwip_init(); + + if(tcpip_flag) + return; + + tcpip_flag = 1; + + tcpip_init_done = initfunc; + tcpip_init_done_arg = arg; + if (sys_mbox_new(&tcpip_mbox, TCPIP_MBOX_SIZE) != ERR_OK) { + LWIP_ASSERT("failed to create tcpip_thread mbox", 0); + } +#if LWIP_TCPIP_CORE_LOCKING + if (sys_mutex_new(&lock_tcpip_core) != ERR_OK) { + LWIP_ASSERT("failed to create lock_tcpip_core", 0); + } +#endif /* LWIP_TCPIP_CORE_LOCKING */ + + sys_thread_new(TCPIP_THREAD_NAME, tcpip_thread, NULL, TCPIP_THREAD_STACKSIZE, TCPIP_THREAD_PRIO); +} + +/** + * Simple callback function used with tcpip_callback to free a pbuf + * (pbuf_free has a wrong signature for tcpip_callback) + * + * @param p The pbuf (chain) to be dereferenced. + */ +static void +pbuf_free_int(void *p) +{ + struct pbuf *q = (struct pbuf *)p; + pbuf_free(q); +} + +/** + * A simple wrapper function that allows you to free a pbuf from interrupt context. + * + * @param p The pbuf (chain) to be dereferenced. + * @return ERR_OK if callback could be enqueued, an err_t if not + */ +err_t +pbuf_free_callback(struct pbuf *p) +{ + return tcpip_try_callback(pbuf_free_int, p); +} + +/** + * A simple wrapper function that allows you to free heap memory from + * interrupt context. + * + * @param m the heap memory to free + * @return ERR_OK if callback could be enqueued, an err_t if not + */ +err_t +mem_free_callback(void *m) +{ + return tcpip_try_callback(mem_free, m); +} + +#endif /* !NO_SYS */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls.c index e629695a..d642decb 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls.c @@ -1,1178 +1,1178 @@ -/** - * @file - * Application layered TCP/TLS connection API (to be used from TCPIP thread) - * - * This file provides a TLS layer using mbedTLS - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - * Watch out: - * - 'sent' is always called with len==0 to the upper layer. This is because keeping - * track of the ratio of application data and TLS overhead would be too much. - * - * Mandatory security-related configuration: - * - define ALTCP_MBEDTLS_RNG_FN to mbedtls_entropy_func to use the standard mbedTLS - * entropy and ensure to add at least one strong entropy source to your mbedtls port - * (implement mbedtls_platform_entropy_poll or mbedtls_hardware_poll providing strong - * entropy) - * - define ALTCP_MBEDTLS_ENTROPY_PTR and ALTCP_MBEDTLS_ENTROPY_LEN to something providing - * GOOD custom entropy - * - * Missing things / @todo: - * - some unhandled/untested things migh be caught by LWIP_ASSERTs... - */ - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/altcp_tls_mbedtls_opts.h" - -#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS - -#include "lwip/altcp.h" -#include "lwip/altcp_tls.h" -#include "lwip/priv/altcp_priv.h" - -#include "altcp_tls_mbedtls_structs.h" -#include "altcp_tls_mbedtls_mem.h" - -/* @todo: which includes are really needed? */ -#include "mbedtls/entropy.h" -#include "mbedtls/ctr_drbg.h" -#include "mbedtls/certs.h" -#include "mbedtls/x509.h" -#include "mbedtls/ssl.h" -#include "mbedtls/net.h" -#include "mbedtls/error.h" -#include "mbedtls/debug.h" -#include "mbedtls/platform.h" -#include "mbedtls/memory_buffer_alloc.h" -#include "mbedtls/ssl_cache.h" - -#include "mbedtls/ssl_internal.h" /* to call mbedtls_flush_output after ERR_MEM */ - -#include - -#ifndef ALTCP_MBEDTLS_ENTROPY_PTR -#define ALTCP_MBEDTLS_ENTROPY_PTR NULL -#endif -#ifndef ALTCP_MBEDTLS_ENTROPY_LEN -#define ALTCP_MBEDTLS_ENTROPY_LEN 0 -#endif - -/* Variable prototype, the actual declaration is at the end of this file - since it contains pointers to static functions declared here */ -extern const struct altcp_functions altcp_mbedtls_functions; - -/** Our global mbedTLS configuration (server-specific, not connection-specific) */ -struct altcp_tls_config { - mbedtls_ssl_config conf; - mbedtls_entropy_context entropy; - mbedtls_ctr_drbg_context ctr_drbg; - mbedtls_x509_crt *cert; - mbedtls_pk_context *pkey; - mbedtls_x509_crt *ca; -#if defined(MBEDTLS_SSL_CACHE_C) && ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS - /** Inter-connection cache for fast connection startup */ - struct mbedtls_ssl_cache_context cache; -#endif -}; - -static err_t altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p, err_t err); -static err_t altcp_mbedtls_setup(void *conf, struct altcp_pcb *conn, struct altcp_pcb *inner_conn); -static err_t altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t *state); -static err_t altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *state); -static int altcp_mbedtls_bio_send(void *ctx, const unsigned char *dataptr, size_t size); - - -/* callback functions from inner/lower connection: */ - -/** Accept callback from lower connection (i.e. TCP) - * Allocate one of our structures, assign it to the new connection's 'state' and - * call the new connection's 'accepted' callback. If that succeeds, we wait - * to receive connection setup handshake bytes from the client. - */ -static err_t -altcp_mbedtls_lower_accept(void *arg, struct altcp_pcb *accepted_conn, err_t err) -{ - struct altcp_pcb *listen_conn = (struct altcp_pcb *)arg; - if (listen_conn && listen_conn->state && listen_conn->accept) { - err_t setup_err; - altcp_mbedtls_state_t *listen_state = (altcp_mbedtls_state_t *)listen_conn->state; - /* create a new altcp_conn to pass to the next 'accept' callback */ - struct altcp_pcb *new_conn = altcp_alloc(); - if (new_conn == NULL) { - return ERR_MEM; - } - setup_err = altcp_mbedtls_setup(listen_state->conf, new_conn, accepted_conn); - if (setup_err != ERR_OK) { - altcp_free(new_conn); - return setup_err; - } - return listen_conn->accept(listen_conn->arg, new_conn, err); - } - return ERR_ARG; -} - -/** Connected callback from lower connection (i.e. TCP). - * Not really implemented/tested yet... - */ -static err_t -altcp_mbedtls_lower_connected(void *arg, struct altcp_pcb *inner_conn, err_t err) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ - if (conn && conn->state) { - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - /* upper connected is called when handshake is done */ - if (err != ERR_OK) { - if (conn->connected) { - return conn->connected(conn->arg, conn, err); - } - } - return altcp_mbedtls_lower_recv_process(conn, (altcp_mbedtls_state_t *)conn->state); - } - return ERR_VAL; -} - -/* Call recved for possibly more than an u16_t */ -static void -altcp_mbedtls_lower_recved(struct altcp_pcb *inner_conn, int recvd_cnt) -{ - while (recvd_cnt > 0) { - u16_t recvd_part = (u16_t)LWIP_MIN(recvd_cnt, 0xFFFF); - altcp_recved(inner_conn, recvd_part); - recvd_cnt -= recvd_part; - } -} - -/** Recv callback from lower connection (i.e. TCP) - * This one mainly differs between connection setup/handshake (data is fed into mbedTLS only) - * and application phase (data is decoded by mbedTLS and passed on to the application). - */ -static err_t -altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p, err_t err) -{ - altcp_mbedtls_state_t *state; - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - - LWIP_ASSERT("no err expected", err == ERR_OK); - LWIP_UNUSED_ARG(err); - - if (!conn) { - /* no connection given as arg? should not happen, but prevent pbuf/conn leaks */ - if (p != NULL) { - pbuf_free(p); - } - altcp_close(inner_conn); - return ERR_CLSD; - } - state = (altcp_mbedtls_state_t *)conn->state; - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - if (!state) { - /* already closed */ - if (p != NULL) { - pbuf_free(p); - } - altcp_close(inner_conn); - return ERR_CLSD; - } - - /* handle NULL pbuf (inner connection closed) */ - if (p == NULL) { - /* remote host sent FIN, remember this (SSL state is destroyed - when both sides are closed only!) */ - if ((state->flags & (ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE | ALTCP_MBEDTLS_FLAGS_UPPER_CALLED)) == - (ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE | ALTCP_MBEDTLS_FLAGS_UPPER_CALLED)) { - /* need to notify upper layer (e.g. 'accept' called or 'connect' succeeded) */ - if ((state->rx != NULL) || (state->rx_app != NULL)) { - state->flags |= ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED; - /* this is a normal close (FIN) but we have unprocessed data, so delay the FIN */ - altcp_mbedtls_handle_rx_appldata(conn, state); - return ERR_OK; - } - state->flags |= ALTCP_MBEDTLS_FLAGS_RX_CLOSED; - if (conn->recv) { - return conn->recv(conn->arg, conn, NULL, ERR_OK); - } - } else { - /* before connection setup is done: call 'err' */ - if (conn->err) { - conn->err(conn->arg, ERR_CLSD); - } - altcp_close(conn); - } - return ERR_OK; - } - - /* If we come here, the connection is in good state (handshake phase or application data phase). - Queue up the pbuf for processing as handshake data or application data. */ - if (state->rx == NULL) { - state->rx = p; - } else { - LWIP_ASSERT("rx pbuf overflow", (int)p->tot_len + (int)p->len <= 0xFFFF); - pbuf_cat(state->rx, p); - } - return altcp_mbedtls_lower_recv_process(conn, state); -} - -static err_t -altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t *state) -{ - if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { - /* handle connection setup (handshake not done) */ - int ret = mbedtls_ssl_handshake(&state->ssl_context); - /* try to send data... */ - altcp_output(conn->inner_conn); - if (state->bio_bytes_read) { - /* acknowledge all bytes read */ - altcp_mbedtls_lower_recved(conn->inner_conn, state->bio_bytes_read); - state->bio_bytes_read = 0; - } - - if (ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE) { - /* handshake not done, wait for more recv calls */ - LWIP_ASSERT("in this state, the rx chain should be empty", state->rx == NULL); - return ERR_OK; - } - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_handshake failed: %d\n", ret)); - /* handshake failed, connection has to be closed */ - if (conn->err) { - conn->err(conn->arg, ERR_CLSD); - } - - if (altcp_close(conn) != ERR_OK) { - altcp_abort(conn); - } - return ERR_OK; - } - /* If we come here, handshake succeeded. */ - LWIP_ASSERT("state", state->bio_bytes_read == 0); - LWIP_ASSERT("state", state->bio_bytes_appl == 0); - state->flags |= ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE; - /* issue "connect" callback" to upper connection (this can only happen for active open) */ - if (conn->connected) { - err_t err; - err = conn->connected(conn->arg, conn, ERR_OK); - if (err != ERR_OK) { - return err; - } - } - if (state->rx == NULL) { - return ERR_OK; - } - } - /* handle application data */ - return altcp_mbedtls_handle_rx_appldata(conn, state); -} - -/* Pass queued decoded rx data to application */ -static err_t -altcp_mbedtls_pass_rx_data(struct altcp_pcb *conn, altcp_mbedtls_state_t *state) -{ - err_t err; - struct pbuf *buf; - LWIP_ASSERT("conn != NULL", conn != NULL); - LWIP_ASSERT("state != NULL", state != NULL); - buf = state->rx_app; - if (buf) { - state->rx_app = NULL; - if (conn->recv) { - u16_t tot_len = buf->tot_len; - /* this needs to be increased first because the 'recved' call may come nested */ - state->rx_passed_unrecved += tot_len; - state->flags |= ALTCP_MBEDTLS_FLAGS_UPPER_CALLED; - err = conn->recv(conn->arg, conn, buf, ERR_OK); - if (err != ERR_OK) { - if (err == ERR_ABRT) { - return ERR_ABRT; - } - /* not received, leave the pbuf(s) queued (and decrease 'unrecved' again) */ - LWIP_ASSERT("state == conn->state", state == conn->state); - state->rx_app = buf; - state->rx_passed_unrecved -= tot_len; - LWIP_ASSERT("state->rx_passed_unrecved >= 0", state->rx_passed_unrecved >= 0); - if (state->rx_passed_unrecved < 0) { - state->rx_passed_unrecved = 0; - } - return err; - } - } else { - pbuf_free(buf); - } - } else if ((state->flags & (ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED | ALTCP_MBEDTLS_FLAGS_RX_CLOSED)) == - ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED) { - state->flags |= ALTCP_MBEDTLS_FLAGS_RX_CLOSED; - if (conn->recv) { - return conn->recv(conn->arg, conn, NULL, ERR_OK); - } - } - - /* application may have close the connection */ - if (conn->state != state) { - /* return error code to ensure altcp_mbedtls_handle_rx_appldata() exits the loop */ - return ERR_CLSD; - } - return ERR_OK; -} - -/* Helper function that processes rx application data stored in rx pbuf chain */ -static err_t -altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *state) -{ - int ret; - LWIP_ASSERT("state != NULL", state != NULL); - if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { - /* handshake not done yet */ - return ERR_VAL; - } - do { - /* allocate a full-sized unchained PBUF_POOL: this is for RX! */ - struct pbuf *buf = pbuf_alloc(PBUF_RAW, PBUF_POOL_BUFSIZE, PBUF_POOL); - if (buf == NULL) { - /* We're short on pbufs, try again later from 'poll' or 'recv' callbacks. - @todo: close on excessive allocation failures or leave this up to upper conn? */ - return ERR_OK; - } - - /* decrypt application data, this pulls encrypted RX data off state->rx pbuf chain */ - ret = mbedtls_ssl_read(&state->ssl_context, (unsigned char *)buf->payload, PBUF_POOL_BUFSIZE); - if (ret < 0) { - if (ret == MBEDTLS_ERR_SSL_CLIENT_RECONNECT) { - /* client is initiating a new connection using the same source port -> close connection or make handshake */ - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("new connection on same source port\n")); - LWIP_ASSERT("TODO: new connection on same source port, close this connection", 0); - } else if ((ret != MBEDTLS_ERR_SSL_WANT_READ) && (ret != MBEDTLS_ERR_SSL_WANT_WRITE)) { - if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was closed gracefully\n")); - } else if (ret == MBEDTLS_ERR_NET_CONN_RESET) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was reset by peer\n")); - } - pbuf_free(buf); - return ERR_OK; - } else { - pbuf_free(buf); - return ERR_OK; - } - pbuf_free(buf); - altcp_abort(conn); - return ERR_ABRT; - } else { - err_t err; - if (ret) { - LWIP_ASSERT("bogus receive length", ret <= PBUF_POOL_BUFSIZE); - /* trim pool pbuf to actually decoded length */ - pbuf_realloc(buf, (u16_t)ret); - - state->bio_bytes_appl += ret; - if (mbedtls_ssl_get_bytes_avail(&state->ssl_context) == 0) { - /* Record is done, now we know the share between application and protocol bytes - and can adjust the RX window by the protocol bytes. - The rest is 'recved' by the application calling our 'recved' fn. */ - int overhead_bytes; - LWIP_ASSERT("bogus byte counts", state->bio_bytes_read > state->bio_bytes_appl); - overhead_bytes = state->bio_bytes_read - state->bio_bytes_appl; - altcp_mbedtls_lower_recved(conn->inner_conn, overhead_bytes); - state->bio_bytes_read = 0; - state->bio_bytes_appl = 0; - } - - if (state->rx_app == NULL) { - state->rx_app = buf; - } else { - pbuf_cat(state->rx_app, buf); - } - } else { - pbuf_free(buf); - buf = NULL; - } - err = altcp_mbedtls_pass_rx_data(conn, state); - if (err != ERR_OK) { - if (err == ERR_ABRT) { - /* recv callback needs to return this as the pcb is deallocated */ - return ERR_ABRT; - } - /* we hide all other errors as we retry feeding the pbuf to the app later */ - return ERR_OK; - } - } - } while (ret > 0); - return ERR_OK; -} - -/** Receive callback function called from mbedtls (set via mbedtls_ssl_set_bio) - * This function mainly copies data from pbufs and frees the pbufs after copying. - */ -static int -altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)ctx; - altcp_mbedtls_state_t *state; - struct pbuf *p; - u16_t ret; - u16_t copy_len; - err_t err; - - LWIP_UNUSED_ARG(err); /* for LWIP_NOASSERT */ - if ((conn == NULL) || (conn->state == NULL)) { - return MBEDTLS_ERR_NET_INVALID_CONTEXT; - } - state = (altcp_mbedtls_state_t *)conn->state; - p = state->rx; - - /* @todo: return MBEDTLS_ERR_NET_CONN_RESET/MBEDTLS_ERR_NET_RECV_FAILED? */ - - if ((p == NULL) || ((p->len == 0) && (p->next == NULL))) { - if (p) { - pbuf_free(p); - } - state->rx = NULL; - if ((state->flags & (ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED | ALTCP_MBEDTLS_FLAGS_RX_CLOSED)) == - ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED) { - /* close queued but not passed up yet */ - return 0; - } - return MBEDTLS_ERR_SSL_WANT_READ; - } - /* limit number of bytes again to copy from first pbuf in a chain only */ - copy_len = (u16_t)LWIP_MIN(len, p->len); - /* copy the data */ - ret = pbuf_copy_partial(p, buf, copy_len, 0); - LWIP_ASSERT("ret == copy_len", ret == copy_len); - /* hide the copied bytes from the pbuf */ - err = pbuf_remove_header(p, ret); - LWIP_ASSERT("error", err == ERR_OK); - if (p->len == 0) { - /* the first pbuf has been fully read, free it */ - state->rx = p->next; - p->next = NULL; - pbuf_free(p); - } - - state->bio_bytes_read += (int)ret; - return ret; -} - -/** Sent callback from lower connection (i.e. TCP) - * This only informs the upper layer to try to send more, not about - * the number of ACKed bytes. - */ -static err_t -altcp_mbedtls_lower_sent(void *arg, struct altcp_pcb *inner_conn, u16_t len) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ - LWIP_UNUSED_ARG(len); - if (conn) { - altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - if (!state || !(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { - /* @todo: do something here? */ - return ERR_OK; - } - /* try to send more if we failed before */ - mbedtls_ssl_flush_output(&state->ssl_context); - /* call upper sent with len==0 if the application already sent data */ - if ((state->flags & ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT) && conn->sent) { - return conn->sent(conn->arg, conn, 0); - } - } - return ERR_OK; -} - -/** Poll callback from lower connection (i.e. TCP) - * Just pass this on to the application. - * @todo: retry sending? - */ -static err_t -altcp_mbedtls_lower_poll(void *arg, struct altcp_pcb *inner_conn) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ - if (conn) { - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - /* check if there's unreceived rx data */ - if (conn->state) { - altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; - /* try to send more if we failed before */ - mbedtls_ssl_flush_output(&state->ssl_context); - if (altcp_mbedtls_handle_rx_appldata(conn, state) == ERR_ABRT) { - return ERR_ABRT; - } - } - if (conn->poll) { - return conn->poll(conn->arg, conn); - } - } - return ERR_OK; -} - -static void -altcp_mbedtls_lower_err(void *arg, err_t err) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - conn->inner_conn = NULL; /* already freed */ - if (conn->err) { - conn->err(conn->arg, err); - } - altcp_free(conn); - } -} - -/* setup functions */ - -static void -altcp_mbedtls_remove_callbacks(struct altcp_pcb *inner_conn) -{ - altcp_arg(inner_conn, NULL); - altcp_recv(inner_conn, NULL); - altcp_sent(inner_conn, NULL); - altcp_err(inner_conn, NULL); - altcp_poll(inner_conn, NULL, inner_conn->pollinterval); -} - -static void -altcp_mbedtls_setup_callbacks(struct altcp_pcb *conn, struct altcp_pcb *inner_conn) -{ - altcp_arg(inner_conn, conn); - altcp_recv(inner_conn, altcp_mbedtls_lower_recv); - altcp_sent(inner_conn, altcp_mbedtls_lower_sent); - altcp_err(inner_conn, altcp_mbedtls_lower_err); - /* tcp_poll is set when interval is set by application */ - /* listen is set totally different :-) */ -} - -static err_t -altcp_mbedtls_setup(void *conf, struct altcp_pcb *conn, struct altcp_pcb *inner_conn) -{ - int ret; - struct altcp_tls_config *config = (struct altcp_tls_config *)conf; - altcp_mbedtls_state_t *state; - if (!conf) { - return ERR_ARG; - } - LWIP_ASSERT("invalid inner_conn", conn != inner_conn); - - /* allocate mbedtls context */ - state = altcp_mbedtls_alloc(conf); - if (state == NULL) { - return ERR_MEM; - } - /* initialize mbedtls context: */ - mbedtls_ssl_init(&state->ssl_context); - ret = mbedtls_ssl_setup(&state->ssl_context, &config->conf); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_setup failed\n")); - /* @todo: convert 'ret' to err_t */ - altcp_mbedtls_free(conf, state); - return ERR_MEM; - } - /* tell mbedtls about our I/O functions */ - mbedtls_ssl_set_bio(&state->ssl_context, conn, altcp_mbedtls_bio_send, altcp_mbedtls_bio_recv, NULL); - - altcp_mbedtls_setup_callbacks(conn, inner_conn); - conn->inner_conn = inner_conn; - conn->fns = &altcp_mbedtls_functions; - conn->state = state; - return ERR_OK; -} - -struct altcp_pcb * -altcp_tls_wrap(struct altcp_tls_config *config, struct altcp_pcb *inner_pcb) -{ - struct altcp_pcb *ret; - if (inner_pcb == NULL) { - return NULL; - } - ret = altcp_alloc(); - if (ret != NULL) { - if (altcp_mbedtls_setup(config, ret, inner_pcb) != ERR_OK) { - altcp_free(ret); - return NULL; - } - } - return ret; -} - -void * -altcp_tls_context(struct altcp_pcb *conn) -{ - if (conn && conn->state) { - altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; - return &state->ssl_context; - } - return NULL; -} - -#if ALTCP_MBEDTLS_DEBUG != LWIP_DBG_OFF -static void -altcp_mbedtls_debug(void *ctx, int level, const char *file, int line, const char *str) -{ - LWIP_UNUSED_ARG(ctx); - LWIP_UNUSED_ARG(level); - LWIP_UNUSED_ARG(file); - LWIP_UNUSED_ARG(line); - LWIP_UNUSED_ARG(str); - - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("%s:%04d: %s", file, line, str)); -} -#endif - -#ifndef ALTCP_MBEDTLS_RNG_FN -/** ATTENTION: It is *really* important to *NOT* use this dummy RNG in production code!!!! */ -static int -dummy_rng(void *ctx, unsigned char *buffer, size_t len) -{ - static size_t ctr; - size_t i; - LWIP_UNUSED_ARG(ctx); - for (i = 0; i < len; i++) { - buffer[i] = (unsigned char)++ctr; - } - return 0; -} -#define ALTCP_MBEDTLS_RNG_FN dummy_rng -#endif /* ALTCP_MBEDTLS_RNG_FN */ - -/** Create new TLS configuration - * ATTENTION: Server certificate and private key have to be added outside this function! - */ -static struct altcp_tls_config * -altcp_tls_create_config(int is_server, int have_cert, int have_pkey, int have_ca) -{ - size_t sz; - int ret; - struct altcp_tls_config *conf; - mbedtls_x509_crt *mem; - - if (TCP_WND < MBEDTLS_SSL_MAX_CONTENT_LEN) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG|LWIP_DBG_LEVEL_SERIOUS, - ("altcp_tls: TCP_WND is smaller than the RX decryption buffer, connection RX might stall!\n")); - } - - altcp_mbedtls_mem_init(); - - sz = sizeof(struct altcp_tls_config); - if (have_cert) { - sz += sizeof(mbedtls_x509_crt); - } - if (have_ca) { - sz += sizeof(mbedtls_x509_crt); - } - if (have_pkey) { - sz += sizeof(mbedtls_pk_context); - } - - conf = (struct altcp_tls_config *)altcp_mbedtls_alloc_config(sz); - if (conf == NULL) { - return NULL; - } - mem = (mbedtls_x509_crt *)(conf + 1); - if (have_cert) { - conf->cert = mem; - mem++; - } - if (have_ca) { - conf->ca = mem; - mem++; - } - if (have_pkey) { - conf->pkey = (mbedtls_pk_context *)mem; - } - - mbedtls_ssl_config_init(&conf->conf); - mbedtls_entropy_init(&conf->entropy); - mbedtls_ctr_drbg_init(&conf->ctr_drbg); - - /* Seed the RNG */ - ret = mbedtls_ctr_drbg_seed(&conf->ctr_drbg, ALTCP_MBEDTLS_RNG_FN, &conf->entropy, ALTCP_MBEDTLS_ENTROPY_PTR, ALTCP_MBEDTLS_ENTROPY_LEN); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ctr_drbg_seed failed: %d\n", ret)); - altcp_mbedtls_free_config(conf); - return NULL; - } - - /* Setup ssl context (@todo: what's different for a client here? -> might better be done on listen/connect) */ - ret = mbedtls_ssl_config_defaults(&conf->conf, is_server ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT, - MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_config_defaults failed: %d\n", ret)); - altcp_mbedtls_free_config(conf); - return NULL; - } - mbedtls_ssl_conf_authmode(&conf->conf, MBEDTLS_SSL_VERIFY_OPTIONAL); - - mbedtls_ssl_conf_rng(&conf->conf, mbedtls_ctr_drbg_random, &conf->ctr_drbg); -#if ALTCP_MBEDTLS_DEBUG != LWIP_DBG_OFF - mbedtls_ssl_conf_dbg(&conf->conf, altcp_mbedtls_debug, stdout); -#endif -#if defined(MBEDTLS_SSL_CACHE_C) && ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS - mbedtls_ssl_conf_session_cache(&conf->conf, &conf->cache, mbedtls_ssl_cache_get, mbedtls_ssl_cache_set); - mbedtls_ssl_cache_set_timeout(&conf->cache, 30); - mbedtls_ssl_cache_set_max_entries(&conf->cache, 30); -#endif - - return conf; -} - -/** Create new TLS configuration - * This is a suboptimal version that gets the encrypted private key and its password, - * as well as the server certificate. - */ -struct altcp_tls_config * -altcp_tls_create_config_server_privkey_cert(const u8_t *privkey, size_t privkey_len, - const u8_t *privkey_pass, size_t privkey_pass_len, - const u8_t *cert, size_t cert_len) -{ - int ret; - mbedtls_x509_crt *srvcert; - mbedtls_pk_context *pkey; - struct altcp_tls_config *conf = altcp_tls_create_config(1, 1, 1, 0); - if (conf == NULL) { - return NULL; - } - - srvcert = conf->cert; - mbedtls_x509_crt_init(srvcert); - - pkey = conf->pkey; - mbedtls_pk_init(pkey); - - /* Load the certificates and private key */ - ret = mbedtls_x509_crt_parse(srvcert, cert, cert_len); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_x509_crt_parse failed: %d\n", ret)); - altcp_mbedtls_free_config(conf); - return NULL; - } - - ret = mbedtls_pk_parse_key(pkey, (const unsigned char *) privkey, privkey_len, privkey_pass, privkey_pass_len); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_pk_parse_public_key failed: %d\n", ret)); - mbedtls_x509_crt_free(srvcert); - altcp_mbedtls_free_config(conf); - return NULL; - } - - mbedtls_ssl_conf_ca_chain(&conf->conf, srvcert->next, NULL); - ret = mbedtls_ssl_conf_own_cert(&conf->conf, srvcert, pkey); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_conf_own_cert failed: %d\n", ret)); - mbedtls_x509_crt_free(srvcert); - mbedtls_pk_free(pkey); - altcp_mbedtls_free_config(conf); - return NULL; - } - return conf; -} - -static struct altcp_tls_config * -altcp_tls_create_config_client_common(const u8_t *ca, size_t ca_len, int is_2wayauth) -{ - int ret; - struct altcp_tls_config *conf = altcp_tls_create_config(0, is_2wayauth, is_2wayauth, ca != NULL); - if (conf == NULL) { - return NULL; - } - - /* Initialize the CA certificate if provided - * CA certificate is optional (to save memory) but recommended for production environment - * Without CA certificate, connection will be prone to man-in-the-middle attacks */ - if (ca) { - mbedtls_x509_crt_init(conf->ca); - ret = mbedtls_x509_crt_parse(conf->ca, ca, ca_len); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_x509_crt_parse ca failed: %d 0x%x", ret, -1*ret)); - altcp_mbedtls_free_config(conf); - return NULL; - } - - mbedtls_ssl_conf_ca_chain(&conf->conf, conf->ca, NULL); - } - return conf; -} - -struct altcp_tls_config * -altcp_tls_create_config_client(const u8_t *ca, size_t ca_len) -{ - return altcp_tls_create_config_client_common(ca, ca_len, 0); -} - -struct altcp_tls_config * -altcp_tls_create_config_client_2wayauth(const u8_t *ca, size_t ca_len, const u8_t *privkey, size_t privkey_len, - const u8_t *privkey_pass, size_t privkey_pass_len, - const u8_t *cert, size_t cert_len) -{ - int ret; - struct altcp_tls_config *conf; - - if (!cert || !privkey) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("altcp_tls_create_config_client_2wayauth: certificate and priv key required")); - return NULL; - } - - conf = altcp_tls_create_config_client_common(ca, ca_len, 1); - if (conf == NULL) { - return NULL; - } - - /* Initialize the client certificate and corresponding private key */ - mbedtls_x509_crt_init(conf->cert); - ret = mbedtls_x509_crt_parse(conf->cert, cert, cert_len); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_x509_crt_parse cert failed: %d 0x%x", ret, -1*ret)); - altcp_mbedtls_free_config(conf->cert); - return NULL; - } - - mbedtls_pk_init(conf->pkey); - ret = mbedtls_pk_parse_key(conf->pkey, privkey, privkey_len, privkey_pass, privkey_pass_len); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_pk_parse_key failed: %d 0x%x", ret, -1*ret)); - altcp_mbedtls_free_config(conf); - return NULL; - } - - ret = mbedtls_ssl_conf_own_cert(&conf->conf, conf->cert, conf->pkey); - if (ret != 0) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_conf_own_cert failed: %d 0x%x", ret, -1*ret)); - altcp_mbedtls_free_config(conf); - return NULL; - } - - return conf; -} - -void -altcp_tls_free_config(struct altcp_tls_config *conf) -{ - if (conf->pkey) { - mbedtls_pk_free(conf->pkey); - } - if (conf->cert) { - mbedtls_x509_crt_free(conf->cert); - } - if (conf->ca) { - mbedtls_x509_crt_free(conf->ca); - } - altcp_mbedtls_free_config(conf); -} - -/* "virtual" functions */ -static void -altcp_mbedtls_set_poll(struct altcp_pcb *conn, u8_t interval) -{ - if (conn != NULL) { - altcp_poll(conn->inner_conn, altcp_mbedtls_lower_poll, interval); - } -} - -static void -altcp_mbedtls_recved(struct altcp_pcb *conn, u16_t len) -{ - u16_t lower_recved; - altcp_mbedtls_state_t *state; - if (conn == NULL) { - return; - } - state = (altcp_mbedtls_state_t *)conn->state; - if (state == NULL) { - return; - } - if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { - return; - } - lower_recved = len; - if (lower_recved > state->rx_passed_unrecved) { - LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("bogus recved count (len > state->rx_passed_unrecved / %d / %d)", - len, state->rx_passed_unrecved)); - lower_recved = (u16_t)state->rx_passed_unrecved; - } - state->rx_passed_unrecved -= lower_recved; - - altcp_recved(conn->inner_conn, lower_recved); -} - -static err_t -altcp_mbedtls_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) -{ - if (conn == NULL) { - return ERR_VAL; - } - conn->connected = connected; - return altcp_connect(conn->inner_conn, ipaddr, port, altcp_mbedtls_lower_connected); -} - -static struct altcp_pcb * -altcp_mbedtls_listen(struct altcp_pcb *conn, u8_t backlog, err_t *err) -{ - struct altcp_pcb *lpcb; - if (conn == NULL) { - return NULL; - } - lpcb = altcp_listen_with_backlog_and_err(conn->inner_conn, backlog, err); - if (lpcb != NULL) { - conn->inner_conn = lpcb; - altcp_accept(lpcb, altcp_mbedtls_lower_accept); - return conn; - } - return NULL; -} - -static void -altcp_mbedtls_abort(struct altcp_pcb *conn) -{ - if (conn != NULL) { - altcp_abort(conn->inner_conn); - } -} - -static err_t -altcp_mbedtls_close(struct altcp_pcb *conn) -{ - struct altcp_pcb *inner_conn; - if (conn == NULL) { - return ERR_VAL; - } - inner_conn = conn->inner_conn; - if (inner_conn) { - err_t err; - altcp_poll_fn oldpoll = inner_conn->poll; - altcp_mbedtls_remove_callbacks(conn->inner_conn); - err = altcp_close(conn->inner_conn); - if (err != ERR_OK) { - /* not closed, set up all callbacks again */ - altcp_mbedtls_setup_callbacks(conn, inner_conn); - /* poll callback is not included in the above */ - altcp_poll(inner_conn, oldpoll, inner_conn->pollinterval); - return err; - } - conn->inner_conn = NULL; - } - altcp_free(conn); - return ERR_OK; -} - -/** Allow caller of altcp_write() to limit to negotiated chunk size - * or remaining sndbuf space of inner_conn. - */ -static u16_t -altcp_mbedtls_sndbuf(struct altcp_pcb *conn) -{ - if (conn) { - altcp_mbedtls_state_t *state; - state = (altcp_mbedtls_state_t*)conn->state; - if (!state || !(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { - return 0; - } - if (conn->inner_conn) { - u16_t sndbuf = altcp_sndbuf(conn->inner_conn); - /* Take care of record header, IV, AuthTag */ - int ssl_expan = mbedtls_ssl_get_record_expansion(&state->ssl_context); - if (ssl_expan > 0) { - size_t ssl_added = (u16_t)LWIP_MIN(ssl_expan, 0xFFFF); - /* internal sndbuf smaller than our offset */ - if (ssl_added < sndbuf) { - size_t max_len = 0xFFFF; - size_t ret; -#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) - /* @todo: adjust ssl_added to real value related to negociated cipher */ - size_t max_frag_len = mbedtls_ssl_get_max_frag_len(&state->ssl_context); - max_len = LWIP_MIN(max_frag_len, max_len); -#endif - /* Adjust sndbuf of inner_conn with what added by SSL */ - ret = LWIP_MIN(sndbuf - ssl_added, max_len); - LWIP_ASSERT("sndbuf overflow", ret <= 0xFFFF); - return (u16_t)ret; - } - } - } - } - /* fallback: use sendbuf of the inner connection */ - return altcp_default_sndbuf(conn); -} - -/** Write data to a TLS connection. Calls into mbedTLS, which in turn calls into - * @ref altcp_mbedtls_bio_send() to send the encrypted data - */ -static err_t -altcp_mbedtls_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) -{ - int ret; - altcp_mbedtls_state_t *state; - - LWIP_UNUSED_ARG(apiflags); - - if (conn == NULL) { - return ERR_VAL; - } - - state = (altcp_mbedtls_state_t *)conn->state; - if (state == NULL) { - /* @todo: which error? */ - return ERR_CLSD; - } - if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { - /* @todo: which error? */ - return ERR_VAL; - } - - /* HACK: if thre is something left to send, try to flush it and only - allow sending more if this succeeded (this is a hack because neither - returning 0 nor MBEDTLS_ERR_SSL_WANT_WRITE worked for me) */ - if (state->ssl_context.out_left) { - mbedtls_ssl_flush_output(&state->ssl_context); - if (state->ssl_context.out_left) { - return ERR_MEM; - } - } - ret = mbedtls_ssl_write(&state->ssl_context, (const unsigned char *)dataptr, len); - /* try to send data... */ - altcp_output(conn->inner_conn); - if (ret >= 0) { - if (ret == len) { - state->flags |= ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT; - return ERR_OK; - } else { - /* @todo/@fixme: assumption: either everything sent or error */ - LWIP_ASSERT("ret <= 0", 0); - return ERR_MEM; - } - } else { - if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) { - /* @todo: convert error to err_t */ - return ERR_MEM; - } - LWIP_ASSERT("unhandled error", 0); - return ERR_VAL; - } -} - -/** Send callback function called from mbedtls (set via mbedtls_ssl_set_bio) - * This function is either called during handshake or when sending application - * data via @ref altcp_mbedtls_write (or altcp_write) - */ -static int -altcp_mbedtls_bio_send(void *ctx, const unsigned char *dataptr, size_t size) -{ - struct altcp_pcb *conn = (struct altcp_pcb *) ctx; - int written = 0; - size_t size_left = size; - u8_t apiflags = TCP_WRITE_FLAG_COPY; - - LWIP_ASSERT("conn != NULL", conn != NULL); - if ((conn == NULL) || (conn->inner_conn == NULL)) { - return MBEDTLS_ERR_NET_INVALID_CONTEXT; - } - - while (size_left) { - u16_t write_len = (u16_t)LWIP_MIN(size_left, 0xFFFF); - err_t err = altcp_write(conn->inner_conn, (const void *)dataptr, write_len, apiflags); - if (err == ERR_OK) { - written += write_len; - size_left -= write_len; - } else if (err == ERR_MEM) { - if (written) { - return written; - } - return 0; /* MBEDTLS_ERR_SSL_WANT_WRITE; */ - } else { - LWIP_ASSERT("tls_write, tcp_write: err != ERR MEM", 0); - /* @todo: return MBEDTLS_ERR_NET_CONN_RESET or MBEDTLS_ERR_NET_SEND_FAILED */ - return MBEDTLS_ERR_NET_SEND_FAILED; - } - } - return written; -} - -static u16_t -altcp_mbedtls_mss(struct altcp_pcb *conn) -{ - if (conn == NULL) { - return 0; - } - /* @todo: LWIP_MIN(mss, mbedtls_ssl_get_max_frag_len()) ? */ - return altcp_mss(conn->inner_conn); -} - -static void -altcp_mbedtls_dealloc(struct altcp_pcb *conn) -{ - /* clean up and free tls state */ - if (conn) { - altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; - if (state) { - mbedtls_ssl_free(&state->ssl_context); - state->flags = 0; - if (state->rx) { - /* free leftover (unhandled) rx pbufs */ - pbuf_free(state->rx); - state->rx = NULL; - } - altcp_mbedtls_free(state->conf, state); - conn->state = NULL; - } - } -} - -const struct altcp_functions altcp_mbedtls_functions = { - altcp_mbedtls_set_poll, - altcp_mbedtls_recved, - altcp_default_bind, - altcp_mbedtls_connect, - altcp_mbedtls_listen, - altcp_mbedtls_abort, - altcp_mbedtls_close, - altcp_default_shutdown, - altcp_mbedtls_write, - altcp_default_output, - altcp_mbedtls_mss, - altcp_mbedtls_sndbuf, - altcp_default_sndqueuelen, - altcp_default_nagle_disable, - altcp_default_nagle_enable, - altcp_default_nagle_disabled, - altcp_default_setprio, - altcp_mbedtls_dealloc, - altcp_default_get_tcp_addrinfo, - altcp_default_get_ip, - altcp_default_get_port -#ifdef LWIP_DEBUG - , altcp_default_dbg_get_tcp_state -#endif -}; - -#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ -#endif /* LWIP_ALTCP */ +/** + * @file + * Application layered TCP/TLS connection API (to be used from TCPIP thread) + * + * This file provides a TLS layer using mbedTLS + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + * Watch out: + * - 'sent' is always called with len==0 to the upper layer. This is because keeping + * track of the ratio of application data and TLS overhead would be too much. + * + * Mandatory security-related configuration: + * - define ALTCP_MBEDTLS_RNG_FN to mbedtls_entropy_func to use the standard mbedTLS + * entropy and ensure to add at least one strong entropy source to your mbedtls port + * (implement mbedtls_platform_entropy_poll or mbedtls_hardware_poll providing strong + * entropy) + * - define ALTCP_MBEDTLS_ENTROPY_PTR and ALTCP_MBEDTLS_ENTROPY_LEN to something providing + * GOOD custom entropy + * + * Missing things / @todo: + * - some unhandled/untested things migh be caught by LWIP_ASSERTs... + */ + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/altcp_tls_mbedtls_opts.h" + +#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + +#include "lwip/altcp.h" +#include "lwip/altcp_tls.h" +#include "lwip/priv/altcp_priv.h" + +#include "altcp_tls_mbedtls_structs.h" +#include "altcp_tls_mbedtls_mem.h" + +/* @todo: which includes are really needed? */ +#include "mbedtls/entropy.h" +#include "mbedtls/ctr_drbg.h" +#include "mbedtls/certs.h" +#include "mbedtls/x509.h" +#include "mbedtls/ssl.h" +#include "mbedtls/net.h" +#include "mbedtls/error.h" +#include "mbedtls/debug.h" +#include "mbedtls/platform.h" +#include "mbedtls/memory_buffer_alloc.h" +#include "mbedtls/ssl_cache.h" + +#include "mbedtls/ssl_internal.h" /* to call mbedtls_flush_output after ERR_MEM */ + +#include + +#ifndef ALTCP_MBEDTLS_ENTROPY_PTR +#define ALTCP_MBEDTLS_ENTROPY_PTR NULL +#endif +#ifndef ALTCP_MBEDTLS_ENTROPY_LEN +#define ALTCP_MBEDTLS_ENTROPY_LEN 0 +#endif + +/* Variable prototype, the actual declaration is at the end of this file + since it contains pointers to static functions declared here */ +extern const struct altcp_functions altcp_mbedtls_functions; + +/** Our global mbedTLS configuration (server-specific, not connection-specific) */ +struct altcp_tls_config { + mbedtls_ssl_config conf; + mbedtls_entropy_context entropy; + mbedtls_ctr_drbg_context ctr_drbg; + mbedtls_x509_crt *cert; + mbedtls_pk_context *pkey; + mbedtls_x509_crt *ca; +#if defined(MBEDTLS_SSL_CACHE_C) && ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS + /** Inter-connection cache for fast connection startup */ + struct mbedtls_ssl_cache_context cache; +#endif +}; + +static err_t altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p, err_t err); +static err_t altcp_mbedtls_setup(void *conf, struct altcp_pcb *conn, struct altcp_pcb *inner_conn); +static err_t altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t *state); +static err_t altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *state); +static int altcp_mbedtls_bio_send(void *ctx, const unsigned char *dataptr, size_t size); + + +/* callback functions from inner/lower connection: */ + +/** Accept callback from lower connection (i.e. TCP) + * Allocate one of our structures, assign it to the new connection's 'state' and + * call the new connection's 'accepted' callback. If that succeeds, we wait + * to receive connection setup handshake bytes from the client. + */ +static err_t +altcp_mbedtls_lower_accept(void *arg, struct altcp_pcb *accepted_conn, err_t err) +{ + struct altcp_pcb *listen_conn = (struct altcp_pcb *)arg; + if (listen_conn && listen_conn->state && listen_conn->accept) { + err_t setup_err; + altcp_mbedtls_state_t *listen_state = (altcp_mbedtls_state_t *)listen_conn->state; + /* create a new altcp_conn to pass to the next 'accept' callback */ + struct altcp_pcb *new_conn = altcp_alloc(); + if (new_conn == NULL) { + return ERR_MEM; + } + setup_err = altcp_mbedtls_setup(listen_state->conf, new_conn, accepted_conn); + if (setup_err != ERR_OK) { + altcp_free(new_conn); + return setup_err; + } + return listen_conn->accept(listen_conn->arg, new_conn, err); + } + return ERR_ARG; +} + +/** Connected callback from lower connection (i.e. TCP). + * Not really implemented/tested yet... + */ +static err_t +altcp_mbedtls_lower_connected(void *arg, struct altcp_pcb *inner_conn, err_t err) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ + if (conn && conn->state) { + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + /* upper connected is called when handshake is done */ + if (err != ERR_OK) { + if (conn->connected) { + return conn->connected(conn->arg, conn, err); + } + } + return altcp_mbedtls_lower_recv_process(conn, (altcp_mbedtls_state_t *)conn->state); + } + return ERR_VAL; +} + +/* Call recved for possibly more than an u16_t */ +static void +altcp_mbedtls_lower_recved(struct altcp_pcb *inner_conn, int recvd_cnt) +{ + while (recvd_cnt > 0) { + u16_t recvd_part = (u16_t)LWIP_MIN(recvd_cnt, 0xFFFF); + altcp_recved(inner_conn, recvd_part); + recvd_cnt -= recvd_part; + } +} + +/** Recv callback from lower connection (i.e. TCP) + * This one mainly differs between connection setup/handshake (data is fed into mbedTLS only) + * and application phase (data is decoded by mbedTLS and passed on to the application). + */ +static err_t +altcp_mbedtls_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p, err_t err) +{ + altcp_mbedtls_state_t *state; + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + + LWIP_ASSERT("no err expected", err == ERR_OK); + LWIP_UNUSED_ARG(err); + + if (!conn) { + /* no connection given as arg? should not happen, but prevent pbuf/conn leaks */ + if (p != NULL) { + pbuf_free(p); + } + altcp_close(inner_conn); + return ERR_CLSD; + } + state = (altcp_mbedtls_state_t *)conn->state; + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + if (!state) { + /* already closed */ + if (p != NULL) { + pbuf_free(p); + } + altcp_close(inner_conn); + return ERR_CLSD; + } + + /* handle NULL pbuf (inner connection closed) */ + if (p == NULL) { + /* remote host sent FIN, remember this (SSL state is destroyed + when both sides are closed only!) */ + if ((state->flags & (ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE | ALTCP_MBEDTLS_FLAGS_UPPER_CALLED)) == + (ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE | ALTCP_MBEDTLS_FLAGS_UPPER_CALLED)) { + /* need to notify upper layer (e.g. 'accept' called or 'connect' succeeded) */ + if ((state->rx != NULL) || (state->rx_app != NULL)) { + state->flags |= ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED; + /* this is a normal close (FIN) but we have unprocessed data, so delay the FIN */ + altcp_mbedtls_handle_rx_appldata(conn, state); + return ERR_OK; + } + state->flags |= ALTCP_MBEDTLS_FLAGS_RX_CLOSED; + if (conn->recv) { + return conn->recv(conn->arg, conn, NULL, ERR_OK); + } + } else { + /* before connection setup is done: call 'err' */ + if (conn->err) { + conn->err(conn->arg, ERR_CLSD); + } + altcp_close(conn); + } + return ERR_OK; + } + + /* If we come here, the connection is in good state (handshake phase or application data phase). + Queue up the pbuf for processing as handshake data or application data. */ + if (state->rx == NULL) { + state->rx = p; + } else { + LWIP_ASSERT("rx pbuf overflow", (int)p->tot_len + (int)p->len <= 0xFFFF); + pbuf_cat(state->rx, p); + } + return altcp_mbedtls_lower_recv_process(conn, state); +} + +static err_t +altcp_mbedtls_lower_recv_process(struct altcp_pcb *conn, altcp_mbedtls_state_t *state) +{ + if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { + /* handle connection setup (handshake not done) */ + int ret = mbedtls_ssl_handshake(&state->ssl_context); + /* try to send data... */ + altcp_output(conn->inner_conn); + if (state->bio_bytes_read) { + /* acknowledge all bytes read */ + altcp_mbedtls_lower_recved(conn->inner_conn, state->bio_bytes_read); + state->bio_bytes_read = 0; + } + + if (ret == MBEDTLS_ERR_SSL_WANT_READ || ret == MBEDTLS_ERR_SSL_WANT_WRITE) { + /* handshake not done, wait for more recv calls */ + LWIP_ASSERT("in this state, the rx chain should be empty", state->rx == NULL); + return ERR_OK; + } + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_handshake failed: %d\n", ret)); + /* handshake failed, connection has to be closed */ + if (conn->err) { + conn->err(conn->arg, ERR_CLSD); + } + + if (altcp_close(conn) != ERR_OK) { + altcp_abort(conn); + } + return ERR_OK; + } + /* If we come here, handshake succeeded. */ + LWIP_ASSERT("state", state->bio_bytes_read == 0); + LWIP_ASSERT("state", state->bio_bytes_appl == 0); + state->flags |= ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE; + /* issue "connect" callback" to upper connection (this can only happen for active open) */ + if (conn->connected) { + err_t err; + err = conn->connected(conn->arg, conn, ERR_OK); + if (err != ERR_OK) { + return err; + } + } + if (state->rx == NULL) { + return ERR_OK; + } + } + /* handle application data */ + return altcp_mbedtls_handle_rx_appldata(conn, state); +} + +/* Pass queued decoded rx data to application */ +static err_t +altcp_mbedtls_pass_rx_data(struct altcp_pcb *conn, altcp_mbedtls_state_t *state) +{ + err_t err; + struct pbuf *buf; + LWIP_ASSERT("conn != NULL", conn != NULL); + LWIP_ASSERT("state != NULL", state != NULL); + buf = state->rx_app; + if (buf) { + state->rx_app = NULL; + if (conn->recv) { + u16_t tot_len = buf->tot_len; + /* this needs to be increased first because the 'recved' call may come nested */ + state->rx_passed_unrecved += tot_len; + state->flags |= ALTCP_MBEDTLS_FLAGS_UPPER_CALLED; + err = conn->recv(conn->arg, conn, buf, ERR_OK); + if (err != ERR_OK) { + if (err == ERR_ABRT) { + return ERR_ABRT; + } + /* not received, leave the pbuf(s) queued (and decrease 'unrecved' again) */ + LWIP_ASSERT("state == conn->state", state == conn->state); + state->rx_app = buf; + state->rx_passed_unrecved -= tot_len; + LWIP_ASSERT("state->rx_passed_unrecved >= 0", state->rx_passed_unrecved >= 0); + if (state->rx_passed_unrecved < 0) { + state->rx_passed_unrecved = 0; + } + return err; + } + } else { + pbuf_free(buf); + } + } else if ((state->flags & (ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED | ALTCP_MBEDTLS_FLAGS_RX_CLOSED)) == + ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED) { + state->flags |= ALTCP_MBEDTLS_FLAGS_RX_CLOSED; + if (conn->recv) { + return conn->recv(conn->arg, conn, NULL, ERR_OK); + } + } + + /* application may have close the connection */ + if (conn->state != state) { + /* return error code to ensure altcp_mbedtls_handle_rx_appldata() exits the loop */ + return ERR_CLSD; + } + return ERR_OK; +} + +/* Helper function that processes rx application data stored in rx pbuf chain */ +static err_t +altcp_mbedtls_handle_rx_appldata(struct altcp_pcb *conn, altcp_mbedtls_state_t *state) +{ + int ret; + LWIP_ASSERT("state != NULL", state != NULL); + if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { + /* handshake not done yet */ + return ERR_VAL; + } + do { + /* allocate a full-sized unchained PBUF_POOL: this is for RX! */ + struct pbuf *buf = pbuf_alloc(PBUF_RAW, PBUF_POOL_BUFSIZE, PBUF_POOL); + if (buf == NULL) { + /* We're short on pbufs, try again later from 'poll' or 'recv' callbacks. + @todo: close on excessive allocation failures or leave this up to upper conn? */ + return ERR_OK; + } + + /* decrypt application data, this pulls encrypted RX data off state->rx pbuf chain */ + ret = mbedtls_ssl_read(&state->ssl_context, (unsigned char *)buf->payload, PBUF_POOL_BUFSIZE); + if (ret < 0) { + if (ret == MBEDTLS_ERR_SSL_CLIENT_RECONNECT) { + /* client is initiating a new connection using the same source port -> close connection or make handshake */ + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("new connection on same source port\n")); + LWIP_ASSERT("TODO: new connection on same source port, close this connection", 0); + } else if ((ret != MBEDTLS_ERR_SSL_WANT_READ) && (ret != MBEDTLS_ERR_SSL_WANT_WRITE)) { + if (ret == MBEDTLS_ERR_SSL_PEER_CLOSE_NOTIFY) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was closed gracefully\n")); + } else if (ret == MBEDTLS_ERR_NET_CONN_RESET) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("connection was reset by peer\n")); + } + pbuf_free(buf); + return ERR_OK; + } else { + pbuf_free(buf); + return ERR_OK; + } + pbuf_free(buf); + altcp_abort(conn); + return ERR_ABRT; + } else { + err_t err; + if (ret) { + LWIP_ASSERT("bogus receive length", ret <= PBUF_POOL_BUFSIZE); + /* trim pool pbuf to actually decoded length */ + pbuf_realloc(buf, (u16_t)ret); + + state->bio_bytes_appl += ret; + if (mbedtls_ssl_get_bytes_avail(&state->ssl_context) == 0) { + /* Record is done, now we know the share between application and protocol bytes + and can adjust the RX window by the protocol bytes. + The rest is 'recved' by the application calling our 'recved' fn. */ + int overhead_bytes; + LWIP_ASSERT("bogus byte counts", state->bio_bytes_read > state->bio_bytes_appl); + overhead_bytes = state->bio_bytes_read - state->bio_bytes_appl; + altcp_mbedtls_lower_recved(conn->inner_conn, overhead_bytes); + state->bio_bytes_read = 0; + state->bio_bytes_appl = 0; + } + + if (state->rx_app == NULL) { + state->rx_app = buf; + } else { + pbuf_cat(state->rx_app, buf); + } + } else { + pbuf_free(buf); + buf = NULL; + } + err = altcp_mbedtls_pass_rx_data(conn, state); + if (err != ERR_OK) { + if (err == ERR_ABRT) { + /* recv callback needs to return this as the pcb is deallocated */ + return ERR_ABRT; + } + /* we hide all other errors as we retry feeding the pbuf to the app later */ + return ERR_OK; + } + } + } while (ret > 0); + return ERR_OK; +} + +/** Receive callback function called from mbedtls (set via mbedtls_ssl_set_bio) + * This function mainly copies data from pbufs and frees the pbufs after copying. + */ +static int +altcp_mbedtls_bio_recv(void *ctx, unsigned char *buf, size_t len) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)ctx; + altcp_mbedtls_state_t *state; + struct pbuf *p; + u16_t ret; + u16_t copy_len; + err_t err; + + LWIP_UNUSED_ARG(err); /* for LWIP_NOASSERT */ + if ((conn == NULL) || (conn->state == NULL)) { + return MBEDTLS_ERR_NET_INVALID_CONTEXT; + } + state = (altcp_mbedtls_state_t *)conn->state; + p = state->rx; + + /* @todo: return MBEDTLS_ERR_NET_CONN_RESET/MBEDTLS_ERR_NET_RECV_FAILED? */ + + if ((p == NULL) || ((p->len == 0) && (p->next == NULL))) { + if (p) { + pbuf_free(p); + } + state->rx = NULL; + if ((state->flags & (ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED | ALTCP_MBEDTLS_FLAGS_RX_CLOSED)) == + ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED) { + /* close queued but not passed up yet */ + return 0; + } + return MBEDTLS_ERR_SSL_WANT_READ; + } + /* limit number of bytes again to copy from first pbuf in a chain only */ + copy_len = (u16_t)LWIP_MIN(len, p->len); + /* copy the data */ + ret = pbuf_copy_partial(p, buf, copy_len, 0); + LWIP_ASSERT("ret == copy_len", ret == copy_len); + /* hide the copied bytes from the pbuf */ + err = pbuf_remove_header(p, ret); + LWIP_ASSERT("error", err == ERR_OK); + if (p->len == 0) { + /* the first pbuf has been fully read, free it */ + state->rx = p->next; + p->next = NULL; + pbuf_free(p); + } + + state->bio_bytes_read += (int)ret; + return ret; +} + +/** Sent callback from lower connection (i.e. TCP) + * This only informs the upper layer to try to send more, not about + * the number of ACKed bytes. + */ +static err_t +altcp_mbedtls_lower_sent(void *arg, struct altcp_pcb *inner_conn, u16_t len) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ + LWIP_UNUSED_ARG(len); + if (conn) { + altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + if (!state || !(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { + /* @todo: do something here? */ + return ERR_OK; + } + /* try to send more if we failed before */ + mbedtls_ssl_flush_output(&state->ssl_context); + /* call upper sent with len==0 if the application already sent data */ + if ((state->flags & ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT) && conn->sent) { + return conn->sent(conn->arg, conn, 0); + } + } + return ERR_OK; +} + +/** Poll callback from lower connection (i.e. TCP) + * Just pass this on to the application. + * @todo: retry sending? + */ +static err_t +altcp_mbedtls_lower_poll(void *arg, struct altcp_pcb *inner_conn) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ + if (conn) { + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + /* check if there's unreceived rx data */ + if (conn->state) { + altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; + /* try to send more if we failed before */ + mbedtls_ssl_flush_output(&state->ssl_context); + if (altcp_mbedtls_handle_rx_appldata(conn, state) == ERR_ABRT) { + return ERR_ABRT; + } + } + if (conn->poll) { + return conn->poll(conn->arg, conn); + } + } + return ERR_OK; +} + +static void +altcp_mbedtls_lower_err(void *arg, err_t err) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + conn->inner_conn = NULL; /* already freed */ + if (conn->err) { + conn->err(conn->arg, err); + } + altcp_free(conn); + } +} + +/* setup functions */ + +static void +altcp_mbedtls_remove_callbacks(struct altcp_pcb *inner_conn) +{ + altcp_arg(inner_conn, NULL); + altcp_recv(inner_conn, NULL); + altcp_sent(inner_conn, NULL); + altcp_err(inner_conn, NULL); + altcp_poll(inner_conn, NULL, inner_conn->pollinterval); +} + +static void +altcp_mbedtls_setup_callbacks(struct altcp_pcb *conn, struct altcp_pcb *inner_conn) +{ + altcp_arg(inner_conn, conn); + altcp_recv(inner_conn, altcp_mbedtls_lower_recv); + altcp_sent(inner_conn, altcp_mbedtls_lower_sent); + altcp_err(inner_conn, altcp_mbedtls_lower_err); + /* tcp_poll is set when interval is set by application */ + /* listen is set totally different :-) */ +} + +static err_t +altcp_mbedtls_setup(void *conf, struct altcp_pcb *conn, struct altcp_pcb *inner_conn) +{ + int ret; + struct altcp_tls_config *config = (struct altcp_tls_config *)conf; + altcp_mbedtls_state_t *state; + if (!conf) { + return ERR_ARG; + } + LWIP_ASSERT("invalid inner_conn", conn != inner_conn); + + /* allocate mbedtls context */ + state = altcp_mbedtls_alloc(conf); + if (state == NULL) { + return ERR_MEM; + } + /* initialize mbedtls context: */ + mbedtls_ssl_init(&state->ssl_context); + ret = mbedtls_ssl_setup(&state->ssl_context, &config->conf); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_setup failed\n")); + /* @todo: convert 'ret' to err_t */ + altcp_mbedtls_free(conf, state); + return ERR_MEM; + } + /* tell mbedtls about our I/O functions */ + mbedtls_ssl_set_bio(&state->ssl_context, conn, altcp_mbedtls_bio_send, altcp_mbedtls_bio_recv, NULL); + + altcp_mbedtls_setup_callbacks(conn, inner_conn); + conn->inner_conn = inner_conn; + conn->fns = &altcp_mbedtls_functions; + conn->state = state; + return ERR_OK; +} + +struct altcp_pcb * +altcp_tls_wrap(struct altcp_tls_config *config, struct altcp_pcb *inner_pcb) +{ + struct altcp_pcb *ret; + if (inner_pcb == NULL) { + return NULL; + } + ret = altcp_alloc(); + if (ret != NULL) { + if (altcp_mbedtls_setup(config, ret, inner_pcb) != ERR_OK) { + altcp_free(ret); + return NULL; + } + } + return ret; +} + +void * +altcp_tls_context(struct altcp_pcb *conn) +{ + if (conn && conn->state) { + altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; + return &state->ssl_context; + } + return NULL; +} + +#if ALTCP_MBEDTLS_DEBUG != LWIP_DBG_OFF +static void +altcp_mbedtls_debug(void *ctx, int level, const char *file, int line, const char *str) +{ + LWIP_UNUSED_ARG(ctx); + LWIP_UNUSED_ARG(level); + LWIP_UNUSED_ARG(file); + LWIP_UNUSED_ARG(line); + LWIP_UNUSED_ARG(str); + + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("%s:%04d: %s", file, line, str)); +} +#endif + +#ifndef ALTCP_MBEDTLS_RNG_FN +/** ATTENTION: It is *really* important to *NOT* use this dummy RNG in production code!!!! */ +static int +dummy_rng(void *ctx, unsigned char *buffer, size_t len) +{ + static size_t ctr; + size_t i; + LWIP_UNUSED_ARG(ctx); + for (i = 0; i < len; i++) { + buffer[i] = (unsigned char)++ctr; + } + return 0; +} +#define ALTCP_MBEDTLS_RNG_FN dummy_rng +#endif /* ALTCP_MBEDTLS_RNG_FN */ + +/** Create new TLS configuration + * ATTENTION: Server certificate and private key have to be added outside this function! + */ +static struct altcp_tls_config * +altcp_tls_create_config(int is_server, int have_cert, int have_pkey, int have_ca) +{ + size_t sz; + int ret; + struct altcp_tls_config *conf; + mbedtls_x509_crt *mem; + + if (TCP_WND < MBEDTLS_SSL_MAX_CONTENT_LEN) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG|LWIP_DBG_LEVEL_SERIOUS, + ("altcp_tls: TCP_WND is smaller than the RX decryption buffer, connection RX might stall!\n")); + } + + altcp_mbedtls_mem_init(); + + sz = sizeof(struct altcp_tls_config); + if (have_cert) { + sz += sizeof(mbedtls_x509_crt); + } + if (have_ca) { + sz += sizeof(mbedtls_x509_crt); + } + if (have_pkey) { + sz += sizeof(mbedtls_pk_context); + } + + conf = (struct altcp_tls_config *)altcp_mbedtls_alloc_config(sz); + if (conf == NULL) { + return NULL; + } + mem = (mbedtls_x509_crt *)(conf + 1); + if (have_cert) { + conf->cert = mem; + mem++; + } + if (have_ca) { + conf->ca = mem; + mem++; + } + if (have_pkey) { + conf->pkey = (mbedtls_pk_context *)mem; + } + + mbedtls_ssl_config_init(&conf->conf); + mbedtls_entropy_init(&conf->entropy); + mbedtls_ctr_drbg_init(&conf->ctr_drbg); + + /* Seed the RNG */ + ret = mbedtls_ctr_drbg_seed(&conf->ctr_drbg, ALTCP_MBEDTLS_RNG_FN, &conf->entropy, ALTCP_MBEDTLS_ENTROPY_PTR, ALTCP_MBEDTLS_ENTROPY_LEN); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ctr_drbg_seed failed: %d\n", ret)); + altcp_mbedtls_free_config(conf); + return NULL; + } + + /* Setup ssl context (@todo: what's different for a client here? -> might better be done on listen/connect) */ + ret = mbedtls_ssl_config_defaults(&conf->conf, is_server ? MBEDTLS_SSL_IS_SERVER : MBEDTLS_SSL_IS_CLIENT, + MBEDTLS_SSL_TRANSPORT_STREAM, MBEDTLS_SSL_PRESET_DEFAULT); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_config_defaults failed: %d\n", ret)); + altcp_mbedtls_free_config(conf); + return NULL; + } + mbedtls_ssl_conf_authmode(&conf->conf, MBEDTLS_SSL_VERIFY_OPTIONAL); + + mbedtls_ssl_conf_rng(&conf->conf, mbedtls_ctr_drbg_random, &conf->ctr_drbg); +#if ALTCP_MBEDTLS_DEBUG != LWIP_DBG_OFF + mbedtls_ssl_conf_dbg(&conf->conf, altcp_mbedtls_debug, stdout); +#endif +#if defined(MBEDTLS_SSL_CACHE_C) && ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS + mbedtls_ssl_conf_session_cache(&conf->conf, &conf->cache, mbedtls_ssl_cache_get, mbedtls_ssl_cache_set); + mbedtls_ssl_cache_set_timeout(&conf->cache, 30); + mbedtls_ssl_cache_set_max_entries(&conf->cache, 30); +#endif + + return conf; +} + +/** Create new TLS configuration + * This is a suboptimal version that gets the encrypted private key and its password, + * as well as the server certificate. + */ +struct altcp_tls_config * +altcp_tls_create_config_server_privkey_cert(const u8_t *privkey, size_t privkey_len, + const u8_t *privkey_pass, size_t privkey_pass_len, + const u8_t *cert, size_t cert_len) +{ + int ret; + mbedtls_x509_crt *srvcert; + mbedtls_pk_context *pkey; + struct altcp_tls_config *conf = altcp_tls_create_config(1, 1, 1, 0); + if (conf == NULL) { + return NULL; + } + + srvcert = conf->cert; + mbedtls_x509_crt_init(srvcert); + + pkey = conf->pkey; + mbedtls_pk_init(pkey); + + /* Load the certificates and private key */ + ret = mbedtls_x509_crt_parse(srvcert, cert, cert_len); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_x509_crt_parse failed: %d\n", ret)); + altcp_mbedtls_free_config(conf); + return NULL; + } + + ret = mbedtls_pk_parse_key(pkey, (const unsigned char *) privkey, privkey_len, privkey_pass, privkey_pass_len); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_pk_parse_public_key failed: %d\n", ret)); + mbedtls_x509_crt_free(srvcert); + altcp_mbedtls_free_config(conf); + return NULL; + } + + mbedtls_ssl_conf_ca_chain(&conf->conf, srvcert->next, NULL); + ret = mbedtls_ssl_conf_own_cert(&conf->conf, srvcert, pkey); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_conf_own_cert failed: %d\n", ret)); + mbedtls_x509_crt_free(srvcert); + mbedtls_pk_free(pkey); + altcp_mbedtls_free_config(conf); + return NULL; + } + return conf; +} + +static struct altcp_tls_config * +altcp_tls_create_config_client_common(const u8_t *ca, size_t ca_len, int is_2wayauth) +{ + int ret; + struct altcp_tls_config *conf = altcp_tls_create_config(0, is_2wayauth, is_2wayauth, ca != NULL); + if (conf == NULL) { + return NULL; + } + + /* Initialize the CA certificate if provided + * CA certificate is optional (to save memory) but recommended for production environment + * Without CA certificate, connection will be prone to man-in-the-middle attacks */ + if (ca) { + mbedtls_x509_crt_init(conf->ca); + ret = mbedtls_x509_crt_parse(conf->ca, ca, ca_len); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_x509_crt_parse ca failed: %d 0x%x", ret, -1*ret)); + altcp_mbedtls_free_config(conf); + return NULL; + } + + mbedtls_ssl_conf_ca_chain(&conf->conf, conf->ca, NULL); + } + return conf; +} + +struct altcp_tls_config * +altcp_tls_create_config_client(const u8_t *ca, size_t ca_len) +{ + return altcp_tls_create_config_client_common(ca, ca_len, 0); +} + +struct altcp_tls_config * +altcp_tls_create_config_client_2wayauth(const u8_t *ca, size_t ca_len, const u8_t *privkey, size_t privkey_len, + const u8_t *privkey_pass, size_t privkey_pass_len, + const u8_t *cert, size_t cert_len) +{ + int ret; + struct altcp_tls_config *conf; + + if (!cert || !privkey) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("altcp_tls_create_config_client_2wayauth: certificate and priv key required")); + return NULL; + } + + conf = altcp_tls_create_config_client_common(ca, ca_len, 1); + if (conf == NULL) { + return NULL; + } + + /* Initialize the client certificate and corresponding private key */ + mbedtls_x509_crt_init(conf->cert); + ret = mbedtls_x509_crt_parse(conf->cert, cert, cert_len); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_x509_crt_parse cert failed: %d 0x%x", ret, -1*ret)); + altcp_mbedtls_free_config(conf->cert); + return NULL; + } + + mbedtls_pk_init(conf->pkey); + ret = mbedtls_pk_parse_key(conf->pkey, privkey, privkey_len, privkey_pass, privkey_pass_len); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_pk_parse_key failed: %d 0x%x", ret, -1*ret)); + altcp_mbedtls_free_config(conf); + return NULL; + } + + ret = mbedtls_ssl_conf_own_cert(&conf->conf, conf->cert, conf->pkey); + if (ret != 0) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("mbedtls_ssl_conf_own_cert failed: %d 0x%x", ret, -1*ret)); + altcp_mbedtls_free_config(conf); + return NULL; + } + + return conf; +} + +void +altcp_tls_free_config(struct altcp_tls_config *conf) +{ + if (conf->pkey) { + mbedtls_pk_free(conf->pkey); + } + if (conf->cert) { + mbedtls_x509_crt_free(conf->cert); + } + if (conf->ca) { + mbedtls_x509_crt_free(conf->ca); + } + altcp_mbedtls_free_config(conf); +} + +/* "virtual" functions */ +static void +altcp_mbedtls_set_poll(struct altcp_pcb *conn, u8_t interval) +{ + if (conn != NULL) { + altcp_poll(conn->inner_conn, altcp_mbedtls_lower_poll, interval); + } +} + +static void +altcp_mbedtls_recved(struct altcp_pcb *conn, u16_t len) +{ + u16_t lower_recved; + altcp_mbedtls_state_t *state; + if (conn == NULL) { + return; + } + state = (altcp_mbedtls_state_t *)conn->state; + if (state == NULL) { + return; + } + if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { + return; + } + lower_recved = len; + if (lower_recved > state->rx_passed_unrecved) { + LWIP_DEBUGF(ALTCP_MBEDTLS_DEBUG, ("bogus recved count (len > state->rx_passed_unrecved / %d / %d)", + len, state->rx_passed_unrecved)); + lower_recved = (u16_t)state->rx_passed_unrecved; + } + state->rx_passed_unrecved -= lower_recved; + + altcp_recved(conn->inner_conn, lower_recved); +} + +static err_t +altcp_mbedtls_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) +{ + if (conn == NULL) { + return ERR_VAL; + } + conn->connected = connected; + return altcp_connect(conn->inner_conn, ipaddr, port, altcp_mbedtls_lower_connected); +} + +static struct altcp_pcb * +altcp_mbedtls_listen(struct altcp_pcb *conn, u8_t backlog, err_t *err) +{ + struct altcp_pcb *lpcb; + if (conn == NULL) { + return NULL; + } + lpcb = altcp_listen_with_backlog_and_err(conn->inner_conn, backlog, err); + if (lpcb != NULL) { + conn->inner_conn = lpcb; + altcp_accept(lpcb, altcp_mbedtls_lower_accept); + return conn; + } + return NULL; +} + +static void +altcp_mbedtls_abort(struct altcp_pcb *conn) +{ + if (conn != NULL) { + altcp_abort(conn->inner_conn); + } +} + +static err_t +altcp_mbedtls_close(struct altcp_pcb *conn) +{ + struct altcp_pcb *inner_conn; + if (conn == NULL) { + return ERR_VAL; + } + inner_conn = conn->inner_conn; + if (inner_conn) { + err_t err; + altcp_poll_fn oldpoll = inner_conn->poll; + altcp_mbedtls_remove_callbacks(conn->inner_conn); + err = altcp_close(conn->inner_conn); + if (err != ERR_OK) { + /* not closed, set up all callbacks again */ + altcp_mbedtls_setup_callbacks(conn, inner_conn); + /* poll callback is not included in the above */ + altcp_poll(inner_conn, oldpoll, inner_conn->pollinterval); + return err; + } + conn->inner_conn = NULL; + } + altcp_free(conn); + return ERR_OK; +} + +/** Allow caller of altcp_write() to limit to negotiated chunk size + * or remaining sndbuf space of inner_conn. + */ +static u16_t +altcp_mbedtls_sndbuf(struct altcp_pcb *conn) +{ + if (conn) { + altcp_mbedtls_state_t *state; + state = (altcp_mbedtls_state_t*)conn->state; + if (!state || !(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { + return 0; + } + if (conn->inner_conn) { + u16_t sndbuf = altcp_sndbuf(conn->inner_conn); + /* Take care of record header, IV, AuthTag */ + int ssl_expan = mbedtls_ssl_get_record_expansion(&state->ssl_context); + if (ssl_expan > 0) { + size_t ssl_added = (u16_t)LWIP_MIN(ssl_expan, 0xFFFF); + /* internal sndbuf smaller than our offset */ + if (ssl_added < sndbuf) { + size_t max_len = 0xFFFF; + size_t ret; +#if defined(MBEDTLS_SSL_MAX_FRAGMENT_LENGTH) + /* @todo: adjust ssl_added to real value related to negociated cipher */ + size_t max_frag_len = mbedtls_ssl_get_max_frag_len(&state->ssl_context); + max_len = LWIP_MIN(max_frag_len, max_len); +#endif + /* Adjust sndbuf of inner_conn with what added by SSL */ + ret = LWIP_MIN(sndbuf - ssl_added, max_len); + LWIP_ASSERT("sndbuf overflow", ret <= 0xFFFF); + return (u16_t)ret; + } + } + } + } + /* fallback: use sendbuf of the inner connection */ + return altcp_default_sndbuf(conn); +} + +/** Write data to a TLS connection. Calls into mbedTLS, which in turn calls into + * @ref altcp_mbedtls_bio_send() to send the encrypted data + */ +static err_t +altcp_mbedtls_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) +{ + int ret; + altcp_mbedtls_state_t *state; + + LWIP_UNUSED_ARG(apiflags); + + if (conn == NULL) { + return ERR_VAL; + } + + state = (altcp_mbedtls_state_t *)conn->state; + if (state == NULL) { + /* @todo: which error? */ + return ERR_CLSD; + } + if (!(state->flags & ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE)) { + /* @todo: which error? */ + return ERR_VAL; + } + + /* HACK: if thre is something left to send, try to flush it and only + allow sending more if this succeeded (this is a hack because neither + returning 0 nor MBEDTLS_ERR_SSL_WANT_WRITE worked for me) */ + if (state->ssl_context.out_left) { + mbedtls_ssl_flush_output(&state->ssl_context); + if (state->ssl_context.out_left) { + return ERR_MEM; + } + } + ret = mbedtls_ssl_write(&state->ssl_context, (const unsigned char *)dataptr, len); + /* try to send data... */ + altcp_output(conn->inner_conn); + if (ret >= 0) { + if (ret == len) { + state->flags |= ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT; + return ERR_OK; + } else { + /* @todo/@fixme: assumption: either everything sent or error */ + LWIP_ASSERT("ret <= 0", 0); + return ERR_MEM; + } + } else { + if (ret == MBEDTLS_ERR_SSL_WANT_WRITE) { + /* @todo: convert error to err_t */ + return ERR_MEM; + } + LWIP_ASSERT("unhandled error", 0); + return ERR_VAL; + } +} + +/** Send callback function called from mbedtls (set via mbedtls_ssl_set_bio) + * This function is either called during handshake or when sending application + * data via @ref altcp_mbedtls_write (or altcp_write) + */ +static int +altcp_mbedtls_bio_send(void *ctx, const unsigned char *dataptr, size_t size) +{ + struct altcp_pcb *conn = (struct altcp_pcb *) ctx; + int written = 0; + size_t size_left = size; + u8_t apiflags = TCP_WRITE_FLAG_COPY; + + LWIP_ASSERT("conn != NULL", conn != NULL); + if ((conn == NULL) || (conn->inner_conn == NULL)) { + return MBEDTLS_ERR_NET_INVALID_CONTEXT; + } + + while (size_left) { + u16_t write_len = (u16_t)LWIP_MIN(size_left, 0xFFFF); + err_t err = altcp_write(conn->inner_conn, (const void *)dataptr, write_len, apiflags); + if (err == ERR_OK) { + written += write_len; + size_left -= write_len; + } else if (err == ERR_MEM) { + if (written) { + return written; + } + return 0; /* MBEDTLS_ERR_SSL_WANT_WRITE; */ + } else { + LWIP_ASSERT("tls_write, tcp_write: err != ERR MEM", 0); + /* @todo: return MBEDTLS_ERR_NET_CONN_RESET or MBEDTLS_ERR_NET_SEND_FAILED */ + return MBEDTLS_ERR_NET_SEND_FAILED; + } + } + return written; +} + +static u16_t +altcp_mbedtls_mss(struct altcp_pcb *conn) +{ + if (conn == NULL) { + return 0; + } + /* @todo: LWIP_MIN(mss, mbedtls_ssl_get_max_frag_len()) ? */ + return altcp_mss(conn->inner_conn); +} + +static void +altcp_mbedtls_dealloc(struct altcp_pcb *conn) +{ + /* clean up and free tls state */ + if (conn) { + altcp_mbedtls_state_t *state = (altcp_mbedtls_state_t *)conn->state; + if (state) { + mbedtls_ssl_free(&state->ssl_context); + state->flags = 0; + if (state->rx) { + /* free leftover (unhandled) rx pbufs */ + pbuf_free(state->rx); + state->rx = NULL; + } + altcp_mbedtls_free(state->conf, state); + conn->state = NULL; + } + } +} + +const struct altcp_functions altcp_mbedtls_functions = { + altcp_mbedtls_set_poll, + altcp_mbedtls_recved, + altcp_default_bind, + altcp_mbedtls_connect, + altcp_mbedtls_listen, + altcp_mbedtls_abort, + altcp_mbedtls_close, + altcp_default_shutdown, + altcp_mbedtls_write, + altcp_default_output, + altcp_mbedtls_mss, + altcp_mbedtls_sndbuf, + altcp_default_sndqueuelen, + altcp_default_nagle_disable, + altcp_default_nagle_enable, + altcp_default_nagle_disabled, + altcp_default_setprio, + altcp_mbedtls_dealloc, + altcp_default_get_tcp_addrinfo, + altcp_default_get_ip, + altcp_default_get_port +#ifdef LWIP_DEBUG + , altcp_default_dbg_get_tcp_state +#endif +}; + +#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ +#endif /* LWIP_ALTCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.c index 664347f2..04d47ae5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.c @@ -1,210 +1,210 @@ -/** - * @file - * Application layered TCP connection API (to be used from TCPIP thread) - * - * This file contains memory management functions for a TLS layer using mbedTLS. - * - * ATTENTION: For production usage, you might want to override this file with - * your own implementation since this implementation simply uses the - * lwIP heap without caring for fragmentation or leaving heap for - * other parts of lwIP! - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - * Missing things / @todo: - * - RX data is acknowledged after receiving (tcp_recved is called when enqueueing - * the pbuf for mbedTLS receive, not when processed by mbedTLS or the inner - * connection; altcp_recved() from inner connection does nothing) - * - TX data is marked as 'sent' (i.e. acknowledged; sent callback is called) right - * after enqueueing for transmission, not when actually ACKed be the remote host. - */ - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/altcp_tls_mbedtls_opts.h" - -#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS - -#include "altcp_tls_mbedtls_mem.h" -#include "altcp_tls_mbedtls_structs.h" -#include "lwip/mem.h" - -#include "mbedtls/platform.h" - -#include - -#ifndef ALTCP_MBEDTLS_MEM_DEBUG -#define ALTCP_MBEDTLS_MEM_DEBUG LWIP_DBG_OFF -#endif - -#if defined(MBEDTLS_PLATFORM_MEMORY) && \ - (!defined(MBEDTLS_PLATFORM_FREE_MACRO) || \ - defined(MBEDTLS_PLATFORM_CALLOC_MACRO)) -#define ALTCP_MBEDTLS_PLATFORM_ALLOC 1 -#else -#define ALTCP_MBEDTLS_PLATFORM_ALLOC 0 -#endif - -#if ALTCP_MBEDTLS_PLATFORM_ALLOC - -#ifndef ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS -#define ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS 0 -#endif - -/* This is an example/debug implementation of alloc/free functions only */ -typedef struct altcp_mbedtls_malloc_helper_s { - size_t c; - size_t len; -} altcp_mbedtls_malloc_helper_t; - -#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS -typedef struct altcp_mbedtls_malloc_stats_s { - size_t allocedBytes; - size_t allocCnt; - size_t maxBytes; - size_t totalBytes; -} altcp_mbedtls_malloc_stats_t; -altcp_mbedtls_malloc_stats_t altcp_mbedtls_malloc_stats; -volatile int altcp_mbedtls_malloc_clear_stats; -#endif - -static void * -tls_malloc(size_t c, size_t len) -{ - altcp_mbedtls_malloc_helper_t *hlpr; - void *ret; - size_t alloc_size; -#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS - if (altcp_mbedtls_malloc_clear_stats) { - altcp_mbedtls_malloc_clear_stats = 0; - memset(&altcp_mbedtls_malloc_stats, 0, sizeof(altcp_mbedtls_malloc_stats)); - } -#endif - alloc_size = sizeof(altcp_mbedtls_malloc_helper_t) + (c * len); - /* check for maximum allocation size, mainly to prevent mem_size_t overflow */ - if (alloc_size > MEM_SIZE) { - LWIP_DEBUGF(ALTCP_MBEDTLS_MEM_DEBUG, ("mbedtls allocation too big: %c * %d bytes vs MEM_SIZE=%d", - (int)c, (int)len, (int)MEM_SIZE)); - return NULL; - } - hlpr = (altcp_mbedtls_malloc_helper_t *)mem_malloc((mem_size_t)alloc_size); - if (hlpr == NULL) { - LWIP_DEBUGF(ALTCP_MBEDTLS_MEM_DEBUG, ("mbedtls alloc callback failed for %c * %d bytes", (int)c, (int)len)); - return NULL; - } -#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS - altcp_mbedtls_malloc_stats.allocCnt++; - altcp_mbedtls_malloc_stats.allocedBytes += c * len; - if (altcp_mbedtls_malloc_stats.allocedBytes > altcp_mbedtls_malloc_stats.maxBytes) { - altcp_mbedtls_malloc_stats.maxBytes = altcp_mbedtls_malloc_stats.allocedBytes; - } - altcp_mbedtls_malloc_stats.totalBytes += c * len; -#endif - hlpr->c = c; - hlpr->len = len; - ret = hlpr + 1; - /* zeroing the allocated chunk is required by mbedTLS! */ - memset(ret, 0, c * len); - return ret; -} - -static void -tls_free(void *ptr) -{ - altcp_mbedtls_malloc_helper_t *hlpr; - if (ptr == NULL) { - /* this obviously happened in mbedtls... */ - return; - } - hlpr = ((altcp_mbedtls_malloc_helper_t *)ptr) - 1; -#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS - if (!altcp_mbedtls_malloc_clear_stats) { - altcp_mbedtls_malloc_stats.allocedBytes -= hlpr->c * hlpr->len; - } -#endif - mem_free(hlpr); -} -#endif /* ALTCP_MBEDTLS_PLATFORM_ALLOC*/ - -void -altcp_mbedtls_mem_init(void) -{ - /* not much to do here when using the heap */ - -#if ALTCP_MBEDTLS_PLATFORM_ALLOC - /* set mbedtls allocation methods */ - mbedtls_platform_set_calloc_free(&tls_malloc, &tls_free); -#endif -} - -altcp_mbedtls_state_t * -altcp_mbedtls_alloc(void *conf) -{ - altcp_mbedtls_state_t *ret = (altcp_mbedtls_state_t *)mem_calloc(1, sizeof(altcp_mbedtls_state_t)); - if (ret != NULL) { - ret->conf = conf; - } - return ret; -} - -void -altcp_mbedtls_free(void *conf, altcp_mbedtls_state_t *state) -{ - LWIP_UNUSED_ARG(conf); - LWIP_ASSERT("state != NULL", state != NULL); - mem_free(state); -} - -void * -altcp_mbedtls_alloc_config(size_t size) -{ - void *ret; - size_t checked_size = (mem_size_t)size; - if (size != checked_size) { - /* allocation too big (mem_size_t overflow) */ - return NULL; - } - ret = (altcp_mbedtls_state_t *)mem_calloc(1, (mem_size_t)size); - return ret; -} - -void -altcp_mbedtls_free_config(void *item) -{ - LWIP_ASSERT("item != NULL", item != NULL); - mem_free(item); -} - -#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ -#endif /* LWIP_ALTCP */ +/** + * @file + * Application layered TCP connection API (to be used from TCPIP thread) + * + * This file contains memory management functions for a TLS layer using mbedTLS. + * + * ATTENTION: For production usage, you might want to override this file with + * your own implementation since this implementation simply uses the + * lwIP heap without caring for fragmentation or leaving heap for + * other parts of lwIP! + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + * Missing things / @todo: + * - RX data is acknowledged after receiving (tcp_recved is called when enqueueing + * the pbuf for mbedTLS receive, not when processed by mbedTLS or the inner + * connection; altcp_recved() from inner connection does nothing) + * - TX data is marked as 'sent' (i.e. acknowledged; sent callback is called) right + * after enqueueing for transmission, not when actually ACKed be the remote host. + */ + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/altcp_tls_mbedtls_opts.h" + +#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + +#include "altcp_tls_mbedtls_mem.h" +#include "altcp_tls_mbedtls_structs.h" +#include "lwip/mem.h" + +#include "mbedtls/platform.h" + +#include + +#ifndef ALTCP_MBEDTLS_MEM_DEBUG +#define ALTCP_MBEDTLS_MEM_DEBUG LWIP_DBG_OFF +#endif + +#if defined(MBEDTLS_PLATFORM_MEMORY) && \ + (!defined(MBEDTLS_PLATFORM_FREE_MACRO) || \ + defined(MBEDTLS_PLATFORM_CALLOC_MACRO)) +#define ALTCP_MBEDTLS_PLATFORM_ALLOC 1 +#else +#define ALTCP_MBEDTLS_PLATFORM_ALLOC 0 +#endif + +#if ALTCP_MBEDTLS_PLATFORM_ALLOC + +#ifndef ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS +#define ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS 0 +#endif + +/* This is an example/debug implementation of alloc/free functions only */ +typedef struct altcp_mbedtls_malloc_helper_s { + size_t c; + size_t len; +} altcp_mbedtls_malloc_helper_t; + +#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS +typedef struct altcp_mbedtls_malloc_stats_s { + size_t allocedBytes; + size_t allocCnt; + size_t maxBytes; + size_t totalBytes; +} altcp_mbedtls_malloc_stats_t; +altcp_mbedtls_malloc_stats_t altcp_mbedtls_malloc_stats; +volatile int altcp_mbedtls_malloc_clear_stats; +#endif + +static void * +tls_malloc(size_t c, size_t len) +{ + altcp_mbedtls_malloc_helper_t *hlpr; + void *ret; + size_t alloc_size; +#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS + if (altcp_mbedtls_malloc_clear_stats) { + altcp_mbedtls_malloc_clear_stats = 0; + memset(&altcp_mbedtls_malloc_stats, 0, sizeof(altcp_mbedtls_malloc_stats)); + } +#endif + alloc_size = sizeof(altcp_mbedtls_malloc_helper_t) + (c * len); + /* check for maximum allocation size, mainly to prevent mem_size_t overflow */ + if (alloc_size > MEM_SIZE) { + LWIP_DEBUGF(ALTCP_MBEDTLS_MEM_DEBUG, ("mbedtls allocation too big: %c * %d bytes vs MEM_SIZE=%d", + (int)c, (int)len, (int)MEM_SIZE)); + return NULL; + } + hlpr = (altcp_mbedtls_malloc_helper_t *)mem_malloc((mem_size_t)alloc_size); + if (hlpr == NULL) { + LWIP_DEBUGF(ALTCP_MBEDTLS_MEM_DEBUG, ("mbedtls alloc callback failed for %c * %d bytes", (int)c, (int)len)); + return NULL; + } +#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS + altcp_mbedtls_malloc_stats.allocCnt++; + altcp_mbedtls_malloc_stats.allocedBytes += c * len; + if (altcp_mbedtls_malloc_stats.allocedBytes > altcp_mbedtls_malloc_stats.maxBytes) { + altcp_mbedtls_malloc_stats.maxBytes = altcp_mbedtls_malloc_stats.allocedBytes; + } + altcp_mbedtls_malloc_stats.totalBytes += c * len; +#endif + hlpr->c = c; + hlpr->len = len; + ret = hlpr + 1; + /* zeroing the allocated chunk is required by mbedTLS! */ + memset(ret, 0, c * len); + return ret; +} + +static void +tls_free(void *ptr) +{ + altcp_mbedtls_malloc_helper_t *hlpr; + if (ptr == NULL) { + /* this obviously happened in mbedtls... */ + return; + } + hlpr = ((altcp_mbedtls_malloc_helper_t *)ptr) - 1; +#if ALTCP_MBEDTLS_PLATFORM_ALLOC_STATS + if (!altcp_mbedtls_malloc_clear_stats) { + altcp_mbedtls_malloc_stats.allocedBytes -= hlpr->c * hlpr->len; + } +#endif + mem_free(hlpr); +} +#endif /* ALTCP_MBEDTLS_PLATFORM_ALLOC*/ + +void +altcp_mbedtls_mem_init(void) +{ + /* not much to do here when using the heap */ + +#if ALTCP_MBEDTLS_PLATFORM_ALLOC + /* set mbedtls allocation methods */ + mbedtls_platform_set_calloc_free(&tls_malloc, &tls_free); +#endif +} + +altcp_mbedtls_state_t * +altcp_mbedtls_alloc(void *conf) +{ + altcp_mbedtls_state_t *ret = (altcp_mbedtls_state_t *)mem_calloc(1, sizeof(altcp_mbedtls_state_t)); + if (ret != NULL) { + ret->conf = conf; + } + return ret; +} + +void +altcp_mbedtls_free(void *conf, altcp_mbedtls_state_t *state) +{ + LWIP_UNUSED_ARG(conf); + LWIP_ASSERT("state != NULL", state != NULL); + mem_free(state); +} + +void * +altcp_mbedtls_alloc_config(size_t size) +{ + void *ret; + size_t checked_size = (mem_size_t)size; + if (size != checked_size) { + /* allocation too big (mem_size_t overflow) */ + return NULL; + } + ret = (altcp_mbedtls_state_t *)mem_calloc(1, (mem_size_t)size); + return ret; +} + +void +altcp_mbedtls_free_config(void *item) +{ + LWIP_ASSERT("item != NULL", item != NULL); + mem_free(item); +} + +#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ +#endif /* LWIP_ALTCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.h index 8458193a..b391bf87 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_mem.h @@ -1,72 +1,72 @@ -/** - * @file - * Application layered TCP/TLS connection API (to be used from TCPIP thread) - * - * This file contains memory management function prototypes for a TLS layer using mbedTLS. - * - * Memory management contains: - * - allocating/freeing altcp_mbedtls_state_t - * - allocating/freeing memory used in the mbedTLS library - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_ALTCP_MBEDTLS_MEM_H -#define LWIP_HDR_ALTCP_MBEDTLS_MEM_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/altcp_tls_mbedtls_opts.h" - -#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS - -#include "altcp_tls_mbedtls_structs.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void altcp_mbedtls_mem_init(void); -altcp_mbedtls_state_t *altcp_mbedtls_alloc(void *conf); -void altcp_mbedtls_free(void *conf, altcp_mbedtls_state_t *state); -void *altcp_mbedtls_alloc_config(size_t size); -void altcp_mbedtls_free_config(void *item); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ -#endif /* LWIP_ALTCP */ -#endif /* LWIP_HDR_ALTCP_MBEDTLS_MEM_H */ +/** + * @file + * Application layered TCP/TLS connection API (to be used from TCPIP thread) + * + * This file contains memory management function prototypes for a TLS layer using mbedTLS. + * + * Memory management contains: + * - allocating/freeing altcp_mbedtls_state_t + * - allocating/freeing memory used in the mbedTLS library + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_ALTCP_MBEDTLS_MEM_H +#define LWIP_HDR_ALTCP_MBEDTLS_MEM_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/altcp_tls_mbedtls_opts.h" + +#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + +#include "altcp_tls_mbedtls_structs.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void altcp_mbedtls_mem_init(void); +altcp_mbedtls_state_t *altcp_mbedtls_alloc(void *conf); +void altcp_mbedtls_free(void *conf, altcp_mbedtls_state_t *state); +void *altcp_mbedtls_alloc_config(size_t size); +void altcp_mbedtls_free_config(void *item); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ +#endif /* LWIP_ALTCP */ +#endif /* LWIP_HDR_ALTCP_MBEDTLS_MEM_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_structs.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_structs.h index 02a756d9..17efaaf6 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_structs.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/altcp_tls/altcp_tls_mbedtls_structs.h @@ -1,83 +1,83 @@ -/** - * @file - * Application layered TCP/TLS connection API (to be used from TCPIP thread) - * - * This file contains structure definitions for a TLS layer using mbedTLS. - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_ALTCP_MBEDTLS_STRUCTS_H -#define LWIP_HDR_ALTCP_MBEDTLS_STRUCTS_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/altcp_tls_mbedtls_opts.h" - -#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS - -#include "lwip/altcp.h" -#include "lwip/pbuf.h" - -#include "mbedtls/ssl.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE 0x01 -#define ALTCP_MBEDTLS_FLAGS_UPPER_CALLED 0x02 -#define ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED 0x04 -#define ALTCP_MBEDTLS_FLAGS_RX_CLOSED 0x08 -#define ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT 0x10 - -typedef struct altcp_mbedtls_state_s { - void *conf; - mbedtls_ssl_context ssl_context; - /* chain of rx pbufs (before decryption) */ - struct pbuf *rx; - struct pbuf *rx_app; - u8_t flags; - int rx_passed_unrecved; - int bio_bytes_read; - int bio_bytes_appl; -} altcp_mbedtls_state_t; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ -#endif /* LWIP_ALTCP */ -#endif /* LWIP_HDR_ALTCP_MBEDTLS_STRUCTS_H */ +/** + * @file + * Application layered TCP/TLS connection API (to be used from TCPIP thread) + * + * This file contains structure definitions for a TLS layer using mbedTLS. + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_ALTCP_MBEDTLS_STRUCTS_H +#define LWIP_HDR_ALTCP_MBEDTLS_STRUCTS_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/altcp_tls_mbedtls_opts.h" + +#if LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS + +#include "lwip/altcp.h" +#include "lwip/pbuf.h" + +#include "mbedtls/ssl.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ALTCP_MBEDTLS_FLAGS_HANDSHAKE_DONE 0x01 +#define ALTCP_MBEDTLS_FLAGS_UPPER_CALLED 0x02 +#define ALTCP_MBEDTLS_FLAGS_RX_CLOSE_QUEUED 0x04 +#define ALTCP_MBEDTLS_FLAGS_RX_CLOSED 0x08 +#define ALTCP_MBEDTLS_FLAGS_APPLDATA_SENT 0x10 + +typedef struct altcp_mbedtls_state_s { + void *conf; + mbedtls_ssl_context ssl_context; + /* chain of rx pbufs (before decryption) */ + struct pbuf *rx; + struct pbuf *rx_app; + u8_t flags; + int rx_passed_unrecved; + int bio_bytes_read; + int bio_bytes_appl; +} altcp_mbedtls_state_t; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_ALTCP_TLS && LWIP_ALTCP_TLS_MBEDTLS */ +#endif /* LWIP_ALTCP */ +#endif /* LWIP_HDR_ALTCP_MBEDTLS_STRUCTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/altcp_proxyconnect.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/altcp_proxyconnect.c index 55d99c49..9a0b2ba1 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/altcp_proxyconnect.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/altcp_proxyconnect.c @@ -1,584 +1,584 @@ -/** - * @file - * Application layered TCP connection API that executes a proxy-connect. - * - * This file provides a starting layer that executes a proxy-connect e.g. to - * set up TLS connections through a http proxy. - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#include "lwip/apps/altcp_proxyconnect.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/altcp.h" -#include "lwip/priv/altcp_priv.h" - -#include "lwip/altcp_tcp.h" -#include "lwip/altcp_tls.h" - -#include "lwip/mem.h" -#include "lwip/init.h" - -#include - -/** This string is passed in the HTTP header as "User-Agent: " */ -#ifndef ALTCP_PROXYCONNECT_CLIENT_AGENT -#define ALTCP_PROXYCONNECT_CLIENT_AGENT "lwIP/" LWIP_VERSION_STRING " (http://savannah.nongnu.org/projects/lwip)" -#endif - -#define ALTCP_PROXYCONNECT_FLAGS_CONNECT_STARTED 0x01 -#define ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE 0x02 - -typedef struct altcp_proxyconnect_state_s -{ - ip_addr_t outer_addr; - u16_t outer_port; - struct altcp_proxyconnect_config *conf; - u8_t flags; -} altcp_proxyconnect_state_t; - -/* Variable prototype, the actual declaration is at the end of this file - since it contains pointers to static functions declared here */ -extern const struct altcp_functions altcp_proxyconnect_functions; - -/* memory management functions: */ - -static altcp_proxyconnect_state_t * -altcp_proxyconnect_state_alloc(void) -{ - altcp_proxyconnect_state_t *ret = (altcp_proxyconnect_state_t *)mem_calloc(1, sizeof(altcp_proxyconnect_state_t)); - return ret; -} - -static void -altcp_proxyconnect_state_free(altcp_proxyconnect_state_t *state) -{ - LWIP_ASSERT("state != NULL", state != NULL); - mem_free(state); -} - -/* helper functions */ - -#define PROXY_CONNECT "CONNECT %s:%d HTTP/1.1\r\n" /* HOST, PORT */ \ - "User-Agent: %s\r\n" /* User-Agent */\ - "Proxy-Connection: keep-alive\r\n" \ - "Connection: keep-alive\r\n" \ - "\r\n" -#define PROXY_CONNECT_FORMAT(host, port) PROXY_CONNECT, host, port, ALTCP_PROXYCONNECT_CLIENT_AGENT - -/* Format the http proxy connect request via snprintf */ -static int -altcp_proxyconnect_format_request(char *buffer, size_t bufsize, const char *host, int port) -{ - return snprintf(buffer, bufsize, PROXY_CONNECT_FORMAT(host, port)); -} - -/* Create and send the http proxy connect request */ -static err_t -altcp_proxyconnect_send_request(struct altcp_pcb *conn) -{ - int len, len2; - mem_size_t alloc_len; - char *buffer, *host; - altcp_proxyconnect_state_t *state = (altcp_proxyconnect_state_t *)conn->state; - - if (!state) { - return ERR_VAL; - } - /* Use printf with zero length to get the required allocation size */ - len = altcp_proxyconnect_format_request(NULL, 0, "", state->outer_port); - if (len < 0) { - return ERR_VAL; - } - /* add allocation size for IP address strings */ -#if LWIP_IPV6 - len += 40; /* worst-case IPv6 address length */ -#else - len += 16; /* worst-case IPv4 address length */ -#endif - alloc_len = (mem_size_t)len; - if ((len < 0) || (int)alloc_len != len) { - /* overflow */ - return ERR_MEM; - } - /* Allocate a bufer for the request string */ - buffer = (char *)mem_malloc(alloc_len); - if (buffer == NULL) { - return ERR_MEM; - } - host = ipaddr_ntoa(&state->outer_addr); - len2 = altcp_proxyconnect_format_request(buffer, alloc_len, host, state->outer_port); - if ((len2 > 0) && (len2 <= len) && (len2 <= 0xFFFF)) { - err_t err = altcp_write(conn->inner_conn, buffer, (u16_t)len2, TCP_WRITE_FLAG_COPY); - if (err != ERR_OK) { - /* @todo: abort? */ - mem_free(buffer); - return err; - } - } - mem_free(buffer); - return ERR_OK; -} - -/* callback functions from inner/lower connection: */ - -/** Connected callback from lower connection (i.e. TCP). - * Not really implemented/tested yet... - */ -static err_t -altcp_proxyconnect_lower_connected(void *arg, struct altcp_pcb *inner_conn, err_t err) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn && conn->state) { - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ - /* upper connected is called when handshake is done */ - if (err != ERR_OK) { - if (conn->connected) { - if (conn->connected(conn->arg, conn, err) == ERR_ABRT) { - return ERR_ABRT; - } - return ERR_OK; - } - } - /* send proxy connect request here */ - return altcp_proxyconnect_send_request(conn); - } - return ERR_VAL; -} - -/** Recv callback from lower connection (i.e. TCP) - * This one mainly differs between connection setup (wait for proxy OK string) - * and application phase (data is passed on to the application). - */ -static err_t -altcp_proxyconnect_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p, err_t err) -{ - altcp_proxyconnect_state_t *state; - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - - LWIP_ASSERT("no err expected", err == ERR_OK); - LWIP_UNUSED_ARG(err); - - if (!conn) { - /* no connection given as arg? should not happen, but prevent pbuf/conn leaks */ - if (p != NULL) { - pbuf_free(p); - } - altcp_close(inner_conn); - return ERR_CLSD; - } - state = (altcp_proxyconnect_state_t *)conn->state; - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - if (!state) { - /* already closed */ - if (p != NULL) { - pbuf_free(p); - } - altcp_close(inner_conn); - return ERR_CLSD; - } - if (state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE) { - /* application phase, just pass this through */ - if (conn->recv) { - return conn->recv(conn->arg, conn, p, err); - } - pbuf_free(p); - return ERR_OK; - } else { - /* setup phase */ - /* handle NULL pbuf (inner connection closed) */ - if (p == NULL) { - if (altcp_close(conn) != ERR_OK) { - altcp_abort(conn); - return ERR_ABRT; - } - return ERR_OK; - } else { - /* @todo: parse setup phase rx data - for now, we just wait for the end of the header... */ - u16_t idx = pbuf_memfind(p, "\r\n\r\n", 4, 0); - altcp_recved(inner_conn, p->tot_len); - pbuf_free(p); - if (idx != 0xFFFF) { - state->flags |= ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE; - if (conn->connected) { - return conn->connected(conn->arg, conn, ERR_OK); - } - } - return ERR_OK; - } - } -} - -/** Sent callback from lower connection (i.e. TCP) - * This only informs the upper layer to try to send more, not about - * the number of ACKed bytes. - */ -static err_t -altcp_proxyconnect_lower_sent(void *arg, struct altcp_pcb *inner_conn, u16_t len) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - LWIP_UNUSED_ARG(len); - if (conn) { - altcp_proxyconnect_state_t *state = (altcp_proxyconnect_state_t *)conn->state; - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ - if (!state || !(state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE)) { - /* @todo: do something here? */ - return ERR_OK; - } - /* pass this on to upper sent */ - if (conn->sent) { - return conn->sent(conn->arg, conn, len); - } - } - return ERR_OK; -} - -/** Poll callback from lower connection (i.e. TCP) - * Just pass this on to the application. - * @todo: retry sending? - */ -static err_t -altcp_proxyconnect_lower_poll(void *arg, struct altcp_pcb *inner_conn) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); - LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ - if (conn->poll) { - return conn->poll(conn->arg, conn); - } - } - return ERR_OK; -} - -static void -altcp_proxyconnect_lower_err(void *arg, err_t err) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - conn->inner_conn = NULL; /* already freed */ - if (conn->err) { - conn->err(conn->arg, err); - } - altcp_free(conn); - } -} - - -/* setup functions */ - -static void -altcp_proxyconnect_setup_callbacks(struct altcp_pcb *conn, struct altcp_pcb *inner_conn) -{ - altcp_arg(inner_conn, conn); - altcp_recv(inner_conn, altcp_proxyconnect_lower_recv); - altcp_sent(inner_conn, altcp_proxyconnect_lower_sent); - altcp_err(inner_conn, altcp_proxyconnect_lower_err); - /* tcp_poll is set when interval is set by application */ - /* listen is set totally different :-) */ -} - -static err_t -altcp_proxyconnect_setup(struct altcp_proxyconnect_config *config, struct altcp_pcb *conn, struct altcp_pcb *inner_conn) -{ - altcp_proxyconnect_state_t *state; - if (!config) { - return ERR_ARG; - } - LWIP_ASSERT("invalid inner_conn", conn != inner_conn); - - /* allocate proxyconnect context */ - state = altcp_proxyconnect_state_alloc(); - if (state == NULL) { - return ERR_MEM; - } - state->flags = 0; - state->conf = config; - altcp_proxyconnect_setup_callbacks(conn, inner_conn); - conn->inner_conn = inner_conn; - conn->fns = &altcp_proxyconnect_functions; - conn->state = state; - return ERR_OK; -} - -/** Allocate a new altcp layer connecting through a proxy. - * This function gets the inner pcb passed. - * - * @param config struct altcp_proxyconnect_config that contains the proxy settings - * @param inner_pcb pcb that makes the connection to the proxy (i.e. tcp pcb) - */ -struct altcp_pcb * -altcp_proxyconnect_new(struct altcp_proxyconnect_config *config, struct altcp_pcb *inner_pcb) -{ - struct altcp_pcb *ret; - if (inner_pcb == NULL) { - return NULL; - } - ret = altcp_alloc(); - if (ret != NULL) { - if (altcp_proxyconnect_setup(config, ret, inner_pcb) != ERR_OK) { - altcp_free(ret); - return NULL; - } - } - return ret; -} - -/** Allocate a new altcp layer connecting through a proxy. - * This function allocates the inner pcb as tcp pcb, resulting in a direct tcp - * connection to the proxy. - * - * @param config struct altcp_proxyconnect_config that contains the proxy settings - * @param ip_type IP type of the connection (@ref lwip_ip_addr_type) - */ -struct altcp_pcb * -altcp_proxyconnect_new_tcp(struct altcp_proxyconnect_config *config, u8_t ip_type) -{ - struct altcp_pcb *inner_pcb, *ret; - - /* inner pcb is tcp */ - inner_pcb = altcp_tcp_new_ip_type(ip_type); - if (inner_pcb == NULL) { - return NULL; - } - ret = altcp_proxyconnect_new(config, inner_pcb); - if (ret == NULL) { - altcp_close(inner_pcb); - } - return ret; -} - -/** Allocator function to allocate a proxy connect altcp pcb connecting directly - * via tcp to the proxy. - * - * The returned pcb is a chain: altcp_proxyconnect - altcp_tcp - tcp pcb - * - * This function is meant for use with @ref altcp_new. - * - * @param arg struct altcp_proxyconnect_config that contains the proxy settings - * @param ip_type IP type of the connection (@ref lwip_ip_addr_type) - */ -struct altcp_pcb * -altcp_proxyconnect_alloc(void *arg, u8_t ip_type) -{ - return altcp_proxyconnect_new_tcp((struct altcp_proxyconnect_config *)arg, ip_type); -} - - -#if LWIP_ALTCP_TLS - -/** Allocator function to allocate a TLS connection through a proxy. - * - * The returned pcb is a chain: altcp_tls - altcp_proxyconnect - altcp_tcp - tcp pcb - * - * This function is meant for use with @ref altcp_new. - * - * @param arg struct altcp_proxyconnect_tls_config that contains the proxy settings - * and tls settings - * @param ip_type IP type of the connection (@ref lwip_ip_addr_type) - */ -struct altcp_pcb * -altcp_proxyconnect_tls_alloc(void *arg, u8_t ip_type) -{ - struct altcp_proxyconnect_tls_config *cfg = (struct altcp_proxyconnect_tls_config *)arg; - struct altcp_pcb *proxy_pcb; - struct altcp_pcb *tls_pcb; - - proxy_pcb = altcp_proxyconnect_new_tcp(&cfg->proxy, ip_type); - tls_pcb = altcp_tls_wrap(cfg->tls_config, proxy_pcb); - - if (tls_pcb == NULL) { - altcp_close(proxy_pcb); - } - return tls_pcb; -} -#endif /* LWIP_ALTCP_TLS */ - -/* "virtual" functions */ -static void -altcp_proxyconnect_set_poll(struct altcp_pcb *conn, u8_t interval) -{ - if (conn != NULL) { - altcp_poll(conn->inner_conn, altcp_proxyconnect_lower_poll, interval); - } -} - -static void -altcp_proxyconnect_recved(struct altcp_pcb *conn, u16_t len) -{ - altcp_proxyconnect_state_t *state; - if (conn == NULL) { - return; - } - state = (altcp_proxyconnect_state_t *)conn->state; - if (state == NULL) { - return; - } - if (!(state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE)) { - return; - } - altcp_recved(conn->inner_conn, len); -} - -static err_t -altcp_proxyconnect_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) -{ - altcp_proxyconnect_state_t *state; - - if ((conn == NULL) || (ipaddr == NULL)) { - return ERR_VAL; - } - state = (altcp_proxyconnect_state_t *)conn->state; - if (state == NULL) { - return ERR_VAL; - } - if (state->flags & ALTCP_PROXYCONNECT_FLAGS_CONNECT_STARTED) { - return ERR_VAL; - } - state->flags |= ALTCP_PROXYCONNECT_FLAGS_CONNECT_STARTED; - - conn->connected = connected; - /* connect to our proxy instead, but store the requested address and port */ - ip_addr_copy(state->outer_addr, *ipaddr); - state->outer_port = port; - - return altcp_connect(conn->inner_conn, &state->conf->proxy_addr, state->conf->proxy_port, altcp_proxyconnect_lower_connected); -} - -static struct altcp_pcb * -altcp_proxyconnect_listen(struct altcp_pcb *conn, u8_t backlog, err_t *err) -{ - LWIP_UNUSED_ARG(conn); - LWIP_UNUSED_ARG(backlog); - LWIP_UNUSED_ARG(err); - /* listen not supported! */ - return NULL; -} - -static void -altcp_proxyconnect_abort(struct altcp_pcb *conn) -{ - if (conn != NULL) { - if (conn->inner_conn != NULL) { - altcp_abort(conn->inner_conn); - } - altcp_free(conn); - } -} - -static err_t -altcp_proxyconnect_close(struct altcp_pcb *conn) -{ - if (conn == NULL) { - return ERR_VAL; - } - if (conn->inner_conn != NULL) { - err_t err = altcp_close(conn->inner_conn); - if (err != ERR_OK) { - /* closing inner conn failed, return the error */ - return err; - } - } - /* no inner conn or closing it succeeded, deallocate myself */ - altcp_free(conn); - return ERR_OK; -} - -static err_t -altcp_proxyconnect_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) -{ - altcp_proxyconnect_state_t *state; - - LWIP_UNUSED_ARG(apiflags); - - if (conn == NULL) { - return ERR_VAL; - } - - state = (altcp_proxyconnect_state_t *)conn->state; - if (state == NULL) { - /* @todo: which error? */ - return ERR_CLSD; - } - if (!(state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE)) { - /* @todo: which error? */ - return ERR_VAL; - } - return altcp_write(conn->inner_conn, dataptr, len, apiflags); -} - -static void -altcp_proxyconnect_dealloc(struct altcp_pcb *conn) -{ - /* clean up and free tls state */ - if (conn) { - altcp_proxyconnect_state_t *state = (altcp_proxyconnect_state_t *)conn->state; - if (state) { - altcp_proxyconnect_state_free(state); - conn->state = NULL; - } - } -} -const struct altcp_functions altcp_proxyconnect_functions = { - altcp_proxyconnect_set_poll, - altcp_proxyconnect_recved, - altcp_default_bind, - altcp_proxyconnect_connect, - altcp_proxyconnect_listen, - altcp_proxyconnect_abort, - altcp_proxyconnect_close, - altcp_default_shutdown, - altcp_proxyconnect_write, - altcp_default_output, - altcp_default_mss, - altcp_default_sndbuf, - altcp_default_sndqueuelen, - altcp_default_nagle_disable, - altcp_default_nagle_enable, - altcp_default_nagle_disabled, - altcp_default_setprio, - altcp_proxyconnect_dealloc, - altcp_default_get_tcp_addrinfo, - altcp_default_get_ip, - altcp_default_get_port -#ifdef LWIP_DEBUG - , altcp_default_dbg_get_tcp_state -#endif -}; - -#endif /* LWIP_ALTCP */ +/** + * @file + * Application layered TCP connection API that executes a proxy-connect. + * + * This file provides a starting layer that executes a proxy-connect e.g. to + * set up TLS connections through a http proxy. + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#include "lwip/apps/altcp_proxyconnect.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/altcp.h" +#include "lwip/priv/altcp_priv.h" + +#include "lwip/altcp_tcp.h" +#include "lwip/altcp_tls.h" + +#include "lwip/mem.h" +#include "lwip/init.h" + +#include + +/** This string is passed in the HTTP header as "User-Agent: " */ +#ifndef ALTCP_PROXYCONNECT_CLIENT_AGENT +#define ALTCP_PROXYCONNECT_CLIENT_AGENT "lwIP/" LWIP_VERSION_STRING " (http://savannah.nongnu.org/projects/lwip)" +#endif + +#define ALTCP_PROXYCONNECT_FLAGS_CONNECT_STARTED 0x01 +#define ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE 0x02 + +typedef struct altcp_proxyconnect_state_s +{ + ip_addr_t outer_addr; + u16_t outer_port; + struct altcp_proxyconnect_config *conf; + u8_t flags; +} altcp_proxyconnect_state_t; + +/* Variable prototype, the actual declaration is at the end of this file + since it contains pointers to static functions declared here */ +extern const struct altcp_functions altcp_proxyconnect_functions; + +/* memory management functions: */ + +static altcp_proxyconnect_state_t * +altcp_proxyconnect_state_alloc(void) +{ + altcp_proxyconnect_state_t *ret = (altcp_proxyconnect_state_t *)mem_calloc(1, sizeof(altcp_proxyconnect_state_t)); + return ret; +} + +static void +altcp_proxyconnect_state_free(altcp_proxyconnect_state_t *state) +{ + LWIP_ASSERT("state != NULL", state != NULL); + mem_free(state); +} + +/* helper functions */ + +#define PROXY_CONNECT "CONNECT %s:%d HTTP/1.1\r\n" /* HOST, PORT */ \ + "User-Agent: %s\r\n" /* User-Agent */\ + "Proxy-Connection: keep-alive\r\n" \ + "Connection: keep-alive\r\n" \ + "\r\n" +#define PROXY_CONNECT_FORMAT(host, port) PROXY_CONNECT, host, port, ALTCP_PROXYCONNECT_CLIENT_AGENT + +/* Format the http proxy connect request via snprintf */ +static int +altcp_proxyconnect_format_request(char *buffer, size_t bufsize, const char *host, int port) +{ + return snprintf(buffer, bufsize, PROXY_CONNECT_FORMAT(host, port)); +} + +/* Create and send the http proxy connect request */ +static err_t +altcp_proxyconnect_send_request(struct altcp_pcb *conn) +{ + int len, len2; + mem_size_t alloc_len; + char *buffer, *host; + altcp_proxyconnect_state_t *state = (altcp_proxyconnect_state_t *)conn->state; + + if (!state) { + return ERR_VAL; + } + /* Use printf with zero length to get the required allocation size */ + len = altcp_proxyconnect_format_request(NULL, 0, "", state->outer_port); + if (len < 0) { + return ERR_VAL; + } + /* add allocation size for IP address strings */ +#if LWIP_IPV6 + len += 40; /* worst-case IPv6 address length */ +#else + len += 16; /* worst-case IPv4 address length */ +#endif + alloc_len = (mem_size_t)len; + if ((len < 0) || (int)alloc_len != len) { + /* overflow */ + return ERR_MEM; + } + /* Allocate a bufer for the request string */ + buffer = (char *)mem_malloc(alloc_len); + if (buffer == NULL) { + return ERR_MEM; + } + host = ipaddr_ntoa(&state->outer_addr); + len2 = altcp_proxyconnect_format_request(buffer, alloc_len, host, state->outer_port); + if ((len2 > 0) && (len2 <= len) && (len2 <= 0xFFFF)) { + err_t err = altcp_write(conn->inner_conn, buffer, (u16_t)len2, TCP_WRITE_FLAG_COPY); + if (err != ERR_OK) { + /* @todo: abort? */ + mem_free(buffer); + return err; + } + } + mem_free(buffer); + return ERR_OK; +} + +/* callback functions from inner/lower connection: */ + +/** Connected callback from lower connection (i.e. TCP). + * Not really implemented/tested yet... + */ +static err_t +altcp_proxyconnect_lower_connected(void *arg, struct altcp_pcb *inner_conn, err_t err) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn && conn->state) { + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ + /* upper connected is called when handshake is done */ + if (err != ERR_OK) { + if (conn->connected) { + if (conn->connected(conn->arg, conn, err) == ERR_ABRT) { + return ERR_ABRT; + } + return ERR_OK; + } + } + /* send proxy connect request here */ + return altcp_proxyconnect_send_request(conn); + } + return ERR_VAL; +} + +/** Recv callback from lower connection (i.e. TCP) + * This one mainly differs between connection setup (wait for proxy OK string) + * and application phase (data is passed on to the application). + */ +static err_t +altcp_proxyconnect_lower_recv(void *arg, struct altcp_pcb *inner_conn, struct pbuf *p, err_t err) +{ + altcp_proxyconnect_state_t *state; + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + + LWIP_ASSERT("no err expected", err == ERR_OK); + LWIP_UNUSED_ARG(err); + + if (!conn) { + /* no connection given as arg? should not happen, but prevent pbuf/conn leaks */ + if (p != NULL) { + pbuf_free(p); + } + altcp_close(inner_conn); + return ERR_CLSD; + } + state = (altcp_proxyconnect_state_t *)conn->state; + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + if (!state) { + /* already closed */ + if (p != NULL) { + pbuf_free(p); + } + altcp_close(inner_conn); + return ERR_CLSD; + } + if (state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE) { + /* application phase, just pass this through */ + if (conn->recv) { + return conn->recv(conn->arg, conn, p, err); + } + pbuf_free(p); + return ERR_OK; + } else { + /* setup phase */ + /* handle NULL pbuf (inner connection closed) */ + if (p == NULL) { + if (altcp_close(conn) != ERR_OK) { + altcp_abort(conn); + return ERR_ABRT; + } + return ERR_OK; + } else { + /* @todo: parse setup phase rx data + for now, we just wait for the end of the header... */ + u16_t idx = pbuf_memfind(p, "\r\n\r\n", 4, 0); + altcp_recved(inner_conn, p->tot_len); + pbuf_free(p); + if (idx != 0xFFFF) { + state->flags |= ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE; + if (conn->connected) { + return conn->connected(conn->arg, conn, ERR_OK); + } + } + return ERR_OK; + } + } +} + +/** Sent callback from lower connection (i.e. TCP) + * This only informs the upper layer to try to send more, not about + * the number of ACKed bytes. + */ +static err_t +altcp_proxyconnect_lower_sent(void *arg, struct altcp_pcb *inner_conn, u16_t len) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + LWIP_UNUSED_ARG(len); + if (conn) { + altcp_proxyconnect_state_t *state = (altcp_proxyconnect_state_t *)conn->state; + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ + if (!state || !(state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE)) { + /* @todo: do something here? */ + return ERR_OK; + } + /* pass this on to upper sent */ + if (conn->sent) { + return conn->sent(conn->arg, conn, len); + } + } + return ERR_OK; +} + +/** Poll callback from lower connection (i.e. TCP) + * Just pass this on to the application. + * @todo: retry sending? + */ +static err_t +altcp_proxyconnect_lower_poll(void *arg, struct altcp_pcb *inner_conn) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + LWIP_ASSERT("pcb mismatch", conn->inner_conn == inner_conn); + LWIP_UNUSED_ARG(inner_conn); /* for LWIP_NOASSERT */ + if (conn->poll) { + return conn->poll(conn->arg, conn); + } + } + return ERR_OK; +} + +static void +altcp_proxyconnect_lower_err(void *arg, err_t err) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + conn->inner_conn = NULL; /* already freed */ + if (conn->err) { + conn->err(conn->arg, err); + } + altcp_free(conn); + } +} + + +/* setup functions */ + +static void +altcp_proxyconnect_setup_callbacks(struct altcp_pcb *conn, struct altcp_pcb *inner_conn) +{ + altcp_arg(inner_conn, conn); + altcp_recv(inner_conn, altcp_proxyconnect_lower_recv); + altcp_sent(inner_conn, altcp_proxyconnect_lower_sent); + altcp_err(inner_conn, altcp_proxyconnect_lower_err); + /* tcp_poll is set when interval is set by application */ + /* listen is set totally different :-) */ +} + +static err_t +altcp_proxyconnect_setup(struct altcp_proxyconnect_config *config, struct altcp_pcb *conn, struct altcp_pcb *inner_conn) +{ + altcp_proxyconnect_state_t *state; + if (!config) { + return ERR_ARG; + } + LWIP_ASSERT("invalid inner_conn", conn != inner_conn); + + /* allocate proxyconnect context */ + state = altcp_proxyconnect_state_alloc(); + if (state == NULL) { + return ERR_MEM; + } + state->flags = 0; + state->conf = config; + altcp_proxyconnect_setup_callbacks(conn, inner_conn); + conn->inner_conn = inner_conn; + conn->fns = &altcp_proxyconnect_functions; + conn->state = state; + return ERR_OK; +} + +/** Allocate a new altcp layer connecting through a proxy. + * This function gets the inner pcb passed. + * + * @param config struct altcp_proxyconnect_config that contains the proxy settings + * @param inner_pcb pcb that makes the connection to the proxy (i.e. tcp pcb) + */ +struct altcp_pcb * +altcp_proxyconnect_new(struct altcp_proxyconnect_config *config, struct altcp_pcb *inner_pcb) +{ + struct altcp_pcb *ret; + if (inner_pcb == NULL) { + return NULL; + } + ret = altcp_alloc(); + if (ret != NULL) { + if (altcp_proxyconnect_setup(config, ret, inner_pcb) != ERR_OK) { + altcp_free(ret); + return NULL; + } + } + return ret; +} + +/** Allocate a new altcp layer connecting through a proxy. + * This function allocates the inner pcb as tcp pcb, resulting in a direct tcp + * connection to the proxy. + * + * @param config struct altcp_proxyconnect_config that contains the proxy settings + * @param ip_type IP type of the connection (@ref lwip_ip_addr_type) + */ +struct altcp_pcb * +altcp_proxyconnect_new_tcp(struct altcp_proxyconnect_config *config, u8_t ip_type) +{ + struct altcp_pcb *inner_pcb, *ret; + + /* inner pcb is tcp */ + inner_pcb = altcp_tcp_new_ip_type(ip_type); + if (inner_pcb == NULL) { + return NULL; + } + ret = altcp_proxyconnect_new(config, inner_pcb); + if (ret == NULL) { + altcp_close(inner_pcb); + } + return ret; +} + +/** Allocator function to allocate a proxy connect altcp pcb connecting directly + * via tcp to the proxy. + * + * The returned pcb is a chain: altcp_proxyconnect - altcp_tcp - tcp pcb + * + * This function is meant for use with @ref altcp_new. + * + * @param arg struct altcp_proxyconnect_config that contains the proxy settings + * @param ip_type IP type of the connection (@ref lwip_ip_addr_type) + */ +struct altcp_pcb * +altcp_proxyconnect_alloc(void *arg, u8_t ip_type) +{ + return altcp_proxyconnect_new_tcp((struct altcp_proxyconnect_config *)arg, ip_type); +} + + +#if LWIP_ALTCP_TLS + +/** Allocator function to allocate a TLS connection through a proxy. + * + * The returned pcb is a chain: altcp_tls - altcp_proxyconnect - altcp_tcp - tcp pcb + * + * This function is meant for use with @ref altcp_new. + * + * @param arg struct altcp_proxyconnect_tls_config that contains the proxy settings + * and tls settings + * @param ip_type IP type of the connection (@ref lwip_ip_addr_type) + */ +struct altcp_pcb * +altcp_proxyconnect_tls_alloc(void *arg, u8_t ip_type) +{ + struct altcp_proxyconnect_tls_config *cfg = (struct altcp_proxyconnect_tls_config *)arg; + struct altcp_pcb *proxy_pcb; + struct altcp_pcb *tls_pcb; + + proxy_pcb = altcp_proxyconnect_new_tcp(&cfg->proxy, ip_type); + tls_pcb = altcp_tls_wrap(cfg->tls_config, proxy_pcb); + + if (tls_pcb == NULL) { + altcp_close(proxy_pcb); + } + return tls_pcb; +} +#endif /* LWIP_ALTCP_TLS */ + +/* "virtual" functions */ +static void +altcp_proxyconnect_set_poll(struct altcp_pcb *conn, u8_t interval) +{ + if (conn != NULL) { + altcp_poll(conn->inner_conn, altcp_proxyconnect_lower_poll, interval); + } +} + +static void +altcp_proxyconnect_recved(struct altcp_pcb *conn, u16_t len) +{ + altcp_proxyconnect_state_t *state; + if (conn == NULL) { + return; + } + state = (altcp_proxyconnect_state_t *)conn->state; + if (state == NULL) { + return; + } + if (!(state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE)) { + return; + } + altcp_recved(conn->inner_conn, len); +} + +static err_t +altcp_proxyconnect_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) +{ + altcp_proxyconnect_state_t *state; + + if ((conn == NULL) || (ipaddr == NULL)) { + return ERR_VAL; + } + state = (altcp_proxyconnect_state_t *)conn->state; + if (state == NULL) { + return ERR_VAL; + } + if (state->flags & ALTCP_PROXYCONNECT_FLAGS_CONNECT_STARTED) { + return ERR_VAL; + } + state->flags |= ALTCP_PROXYCONNECT_FLAGS_CONNECT_STARTED; + + conn->connected = connected; + /* connect to our proxy instead, but store the requested address and port */ + ip_addr_copy(state->outer_addr, *ipaddr); + state->outer_port = port; + + return altcp_connect(conn->inner_conn, &state->conf->proxy_addr, state->conf->proxy_port, altcp_proxyconnect_lower_connected); +} + +static struct altcp_pcb * +altcp_proxyconnect_listen(struct altcp_pcb *conn, u8_t backlog, err_t *err) +{ + LWIP_UNUSED_ARG(conn); + LWIP_UNUSED_ARG(backlog); + LWIP_UNUSED_ARG(err); + /* listen not supported! */ + return NULL; +} + +static void +altcp_proxyconnect_abort(struct altcp_pcb *conn) +{ + if (conn != NULL) { + if (conn->inner_conn != NULL) { + altcp_abort(conn->inner_conn); + } + altcp_free(conn); + } +} + +static err_t +altcp_proxyconnect_close(struct altcp_pcb *conn) +{ + if (conn == NULL) { + return ERR_VAL; + } + if (conn->inner_conn != NULL) { + err_t err = altcp_close(conn->inner_conn); + if (err != ERR_OK) { + /* closing inner conn failed, return the error */ + return err; + } + } + /* no inner conn or closing it succeeded, deallocate myself */ + altcp_free(conn); + return ERR_OK; +} + +static err_t +altcp_proxyconnect_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) +{ + altcp_proxyconnect_state_t *state; + + LWIP_UNUSED_ARG(apiflags); + + if (conn == NULL) { + return ERR_VAL; + } + + state = (altcp_proxyconnect_state_t *)conn->state; + if (state == NULL) { + /* @todo: which error? */ + return ERR_CLSD; + } + if (!(state->flags & ALTCP_PROXYCONNECT_FLAGS_HANDSHAKE_DONE)) { + /* @todo: which error? */ + return ERR_VAL; + } + return altcp_write(conn->inner_conn, dataptr, len, apiflags); +} + +static void +altcp_proxyconnect_dealloc(struct altcp_pcb *conn) +{ + /* clean up and free tls state */ + if (conn) { + altcp_proxyconnect_state_t *state = (altcp_proxyconnect_state_t *)conn->state; + if (state) { + altcp_proxyconnect_state_free(state); + conn->state = NULL; + } + } +} +const struct altcp_functions altcp_proxyconnect_functions = { + altcp_proxyconnect_set_poll, + altcp_proxyconnect_recved, + altcp_default_bind, + altcp_proxyconnect_connect, + altcp_proxyconnect_listen, + altcp_proxyconnect_abort, + altcp_proxyconnect_close, + altcp_default_shutdown, + altcp_proxyconnect_write, + altcp_default_output, + altcp_default_mss, + altcp_default_sndbuf, + altcp_default_sndqueuelen, + altcp_default_nagle_disable, + altcp_default_nagle_enable, + altcp_default_nagle_disabled, + altcp_default_setprio, + altcp_proxyconnect_dealloc, + altcp_default_get_tcp_addrinfo, + altcp_default_get_ip, + altcp_default_get_port +#ifdef LWIP_DEBUG + , altcp_default_dbg_get_tcp_state +#endif +}; + +#endif /* LWIP_ALTCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fs.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fs.c index c89b2ff1..f15a4801 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fs.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fs.c @@ -1,174 +1,174 @@ -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/apps/httpd_opts.h" -#include "lwip/def.h" -#include "lwip/apps/fs.h" -#include - - -#include HTTPD_FSDATA_FILE - -/*-----------------------------------------------------------------------------------*/ - -#if LWIP_HTTPD_CUSTOM_FILES -int fs_open_custom(struct fs_file *file, const char *name); -void fs_close_custom(struct fs_file *file); -#if LWIP_HTTPD_FS_ASYNC_READ -u8_t fs_canread_custom(struct fs_file *file); -u8_t fs_wait_read_custom(struct fs_file *file, fs_wait_cb callback_fn, void *callback_arg); -int fs_read_async_custom(struct fs_file *file, char *buffer, int count, fs_wait_cb callback_fn, void *callback_arg); -#else /* LWIP_HTTPD_FS_ASYNC_READ */ -int fs_read_custom(struct fs_file *file, char *buffer, int count); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ -#endif /* LWIP_HTTPD_CUSTOM_FILES */ - -/*-----------------------------------------------------------------------------------*/ -err_t -fs_open(struct fs_file *file, const char *name) -{ - const struct fsdata_file *f; - - if ((file == NULL) || (name == NULL)) { - return ERR_ARG; - } - -#if LWIP_HTTPD_CUSTOM_FILES - if (fs_open_custom(file, name)) { - file->is_custom_file = 1; - return ERR_OK; - } - file->is_custom_file = 0; -#endif /* LWIP_HTTPD_CUSTOM_FILES */ - - for (f = FS_ROOT; f != NULL; f = f->next) { - if (!strcmp(name, (const char *)f->name)) { - file->data = (const char *)f->data; - file->len = f->len; - file->index = f->len; - file->pextension = NULL; - file->flags = f->flags; -#if HTTPD_PRECALCULATED_CHECKSUM - file->chksum_count = f->chksum_count; - file->chksum = f->chksum; -#endif /* HTTPD_PRECALCULATED_CHECKSUM */ -#if LWIP_HTTPD_FILE_STATE - file->state = fs_state_init(file, name); -#endif /* #if LWIP_HTTPD_FILE_STATE */ - return ERR_OK; - } - } - /* file not found */ - return ERR_VAL; -} - -/*-----------------------------------------------------------------------------------*/ -void -fs_close(struct fs_file *file) -{ -#if LWIP_HTTPD_CUSTOM_FILES - if (file->is_custom_file) { - fs_close_custom(file); - } -#endif /* LWIP_HTTPD_CUSTOM_FILES */ -#if LWIP_HTTPD_FILE_STATE - fs_state_free(file, file->state); -#endif /* #if LWIP_HTTPD_FILE_STATE */ - LWIP_UNUSED_ARG(file); -} -/*-----------------------------------------------------------------------------------*/ -#if LWIP_HTTPD_DYNAMIC_FILE_READ -#if LWIP_HTTPD_FS_ASYNC_READ -int -fs_read_async(struct fs_file *file, char *buffer, int count, fs_wait_cb callback_fn, void *callback_arg) -#else /* LWIP_HTTPD_FS_ASYNC_READ */ -int -fs_read(struct fs_file *file, char *buffer, int count) -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ -{ - int read; - if (file->index == file->len) { - return FS_READ_EOF; - } -#if LWIP_HTTPD_FS_ASYNC_READ - LWIP_UNUSED_ARG(callback_fn); - LWIP_UNUSED_ARG(callback_arg); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ -#if LWIP_HTTPD_CUSTOM_FILES - if (file->is_custom_file) { -#if LWIP_HTTPD_FS_ASYNC_READ - return fs_read_async_custom(file, buffer, count, callback_fn, callback_arg); -#else /* LWIP_HTTPD_FS_ASYNC_READ */ - return fs_read_custom(file, buffer, count); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ - } -#endif /* LWIP_HTTPD_CUSTOM_FILES */ - - read = file->len - file->index; - if (read > count) { - read = count; - } - - MEMCPY(buffer, (file->data + file->index), read); - file->index += read; - - return (read); -} -#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ -/*-----------------------------------------------------------------------------------*/ -#if LWIP_HTTPD_FS_ASYNC_READ -int -fs_is_file_ready(struct fs_file *file, fs_wait_cb callback_fn, void *callback_arg) -{ - if (file != NULL) { -#if LWIP_HTTPD_FS_ASYNC_READ -#if LWIP_HTTPD_CUSTOM_FILES - if (!fs_canread_custom(file)) { - if (fs_wait_read_custom(file, callback_fn, callback_arg)) { - return 0; - } - } -#else /* LWIP_HTTPD_CUSTOM_FILES */ - LWIP_UNUSED_ARG(callback_fn); - LWIP_UNUSED_ARG(callback_arg); -#endif /* LWIP_HTTPD_CUSTOM_FILES */ -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ - } - return 1; -} -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ -/*-----------------------------------------------------------------------------------*/ -int -fs_bytes_left(struct fs_file *file) -{ - return file->len - file->index; -} +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/apps/httpd_opts.h" +#include "lwip/def.h" +#include "lwip/apps/fs.h" +#include + + +#include HTTPD_FSDATA_FILE + +/*-----------------------------------------------------------------------------------*/ + +#if LWIP_HTTPD_CUSTOM_FILES +int fs_open_custom(struct fs_file *file, const char *name); +void fs_close_custom(struct fs_file *file); +#if LWIP_HTTPD_FS_ASYNC_READ +u8_t fs_canread_custom(struct fs_file *file); +u8_t fs_wait_read_custom(struct fs_file *file, fs_wait_cb callback_fn, void *callback_arg); +int fs_read_async_custom(struct fs_file *file, char *buffer, int count, fs_wait_cb callback_fn, void *callback_arg); +#else /* LWIP_HTTPD_FS_ASYNC_READ */ +int fs_read_custom(struct fs_file *file, char *buffer, int count); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ +#endif /* LWIP_HTTPD_CUSTOM_FILES */ + +/*-----------------------------------------------------------------------------------*/ +err_t +fs_open(struct fs_file *file, const char *name) +{ + const struct fsdata_file *f; + + if ((file == NULL) || (name == NULL)) { + return ERR_ARG; + } + +#if LWIP_HTTPD_CUSTOM_FILES + if (fs_open_custom(file, name)) { + file->is_custom_file = 1; + return ERR_OK; + } + file->is_custom_file = 0; +#endif /* LWIP_HTTPD_CUSTOM_FILES */ + + for (f = FS_ROOT; f != NULL; f = f->next) { + if (!strcmp(name, (const char *)f->name)) { + file->data = (const char *)f->data; + file->len = f->len; + file->index = f->len; + file->pextension = NULL; + file->flags = f->flags; +#if HTTPD_PRECALCULATED_CHECKSUM + file->chksum_count = f->chksum_count; + file->chksum = f->chksum; +#endif /* HTTPD_PRECALCULATED_CHECKSUM */ +#if LWIP_HTTPD_FILE_STATE + file->state = fs_state_init(file, name); +#endif /* #if LWIP_HTTPD_FILE_STATE */ + return ERR_OK; + } + } + /* file not found */ + return ERR_VAL; +} + +/*-----------------------------------------------------------------------------------*/ +void +fs_close(struct fs_file *file) +{ +#if LWIP_HTTPD_CUSTOM_FILES + if (file->is_custom_file) { + fs_close_custom(file); + } +#endif /* LWIP_HTTPD_CUSTOM_FILES */ +#if LWIP_HTTPD_FILE_STATE + fs_state_free(file, file->state); +#endif /* #if LWIP_HTTPD_FILE_STATE */ + LWIP_UNUSED_ARG(file); +} +/*-----------------------------------------------------------------------------------*/ +#if LWIP_HTTPD_DYNAMIC_FILE_READ +#if LWIP_HTTPD_FS_ASYNC_READ +int +fs_read_async(struct fs_file *file, char *buffer, int count, fs_wait_cb callback_fn, void *callback_arg) +#else /* LWIP_HTTPD_FS_ASYNC_READ */ +int +fs_read(struct fs_file *file, char *buffer, int count) +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ +{ + int read; + if (file->index == file->len) { + return FS_READ_EOF; + } +#if LWIP_HTTPD_FS_ASYNC_READ + LWIP_UNUSED_ARG(callback_fn); + LWIP_UNUSED_ARG(callback_arg); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ +#if LWIP_HTTPD_CUSTOM_FILES + if (file->is_custom_file) { +#if LWIP_HTTPD_FS_ASYNC_READ + return fs_read_async_custom(file, buffer, count, callback_fn, callback_arg); +#else /* LWIP_HTTPD_FS_ASYNC_READ */ + return fs_read_custom(file, buffer, count); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ + } +#endif /* LWIP_HTTPD_CUSTOM_FILES */ + + read = file->len - file->index; + if (read > count) { + read = count; + } + + MEMCPY(buffer, (file->data + file->index), read); + file->index += read; + + return (read); +} +#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ +/*-----------------------------------------------------------------------------------*/ +#if LWIP_HTTPD_FS_ASYNC_READ +int +fs_is_file_ready(struct fs_file *file, fs_wait_cb callback_fn, void *callback_arg) +{ + if (file != NULL) { +#if LWIP_HTTPD_FS_ASYNC_READ +#if LWIP_HTTPD_CUSTOM_FILES + if (!fs_canread_custom(file)) { + if (fs_wait_read_custom(file, callback_fn, callback_arg)) { + return 0; + } + } +#else /* LWIP_HTTPD_CUSTOM_FILES */ + LWIP_UNUSED_ARG(callback_fn); + LWIP_UNUSED_ARG(callback_arg); +#endif /* LWIP_HTTPD_CUSTOM_FILES */ +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ + } + return 1; +} +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ +/*-----------------------------------------------------------------------------------*/ +int +fs_bytes_left(struct fs_file *file) +{ + return file->len - file->index; +} diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.c index ba2a2cb9..ab9da7e1 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.c @@ -1,337 +1,337 @@ -#include "lwip/apps/fs.h" -#include "lwip/def.h" - - -#define file_NULL (struct fsdata_file *) NULL - - -#ifndef FS_FILE_FLAGS_HEADER_INCLUDED -#define FS_FILE_FLAGS_HEADER_INCLUDED 1 -#endif -#ifndef FS_FILE_FLAGS_HEADER_PERSISTENT -#define FS_FILE_FLAGS_HEADER_PERSISTENT 0 -#endif -/* FSDATA_FILE_ALIGNMENT: 0=off, 1=by variable, 2=by include */ -#ifndef FSDATA_FILE_ALIGNMENT -#define FSDATA_FILE_ALIGNMENT 0 -#endif -#ifndef FSDATA_ALIGN_PRE -#define FSDATA_ALIGN_PRE -#endif -#ifndef FSDATA_ALIGN_POST -#define FSDATA_ALIGN_POST -#endif -#if FSDATA_FILE_ALIGNMENT==2 -#include "fsdata_alignment.h" -#endif -#if FSDATA_FILE_ALIGNMENT==1 -static const unsigned int dummy_align__img_sics_gif = 0; -#endif -static const unsigned char FSDATA_ALIGN_PRE data__img_sics_gif[] FSDATA_ALIGN_POST = { -/* /img/sics.gif (14 chars) */ -0x2f,0x69,0x6d,0x67,0x2f,0x73,0x69,0x63,0x73,0x2e,0x67,0x69,0x66,0x00,0x00,0x00, - -/* HTTP header */ -/* "HTTP/1.0 200 OK -" (17 bytes) */ -0x48,0x54,0x54,0x50,0x2f,0x31,0x2e,0x30,0x20,0x32,0x30,0x30,0x20,0x4f,0x4b,0x0d, -0x0a, -/* "Server: lwIP/2.0.3d (http://savannah.nongnu.org/projects/lwip) -" (64 bytes) */ -0x53,0x65,0x72,0x76,0x65,0x72,0x3a,0x20,0x6c,0x77,0x49,0x50,0x2f,0x32,0x2e,0x30, -0x2e,0x33,0x64,0x20,0x28,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61, -0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f, -0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x29,0x0d,0x0a, - -/* "Content-Length: 724 -" (18+ bytes) */ -0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x4c,0x65,0x6e,0x67,0x74,0x68,0x3a,0x20, -0x37,0x32,0x34,0x0d,0x0a, -/* "Content-Type: image/gif - -" (27 bytes) */ -0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x54,0x79,0x70,0x65,0x3a,0x20,0x69,0x6d, -0x61,0x67,0x65,0x2f,0x67,0x69,0x66,0x0d,0x0a,0x0d,0x0a, -/* raw file data (724 bytes) */ -0x47,0x49,0x46,0x38,0x39,0x61,0x46,0x00,0x22,0x00,0xa5,0x00,0x00,0xd9,0x2b,0x39, -0x6a,0x6a,0x6a,0xbf,0xbf,0xbf,0x93,0x93,0x93,0x0f,0x0f,0x0f,0xb0,0xb0,0xb0,0xa6, -0xa6,0xa6,0x80,0x80,0x80,0x76,0x76,0x76,0x1e,0x1e,0x1e,0x9d,0x9d,0x9d,0x2e,0x2e, -0x2e,0x49,0x49,0x49,0x54,0x54,0x54,0x8a,0x8a,0x8a,0x60,0x60,0x60,0xc6,0xa6,0x99, -0xbd,0xb5,0xb2,0xc2,0xab,0xa1,0xd9,0x41,0x40,0xd5,0x67,0x55,0xc0,0xb0,0xaa,0xd5, -0x5e,0x4e,0xd6,0x50,0x45,0xcc,0x93,0x7d,0xc8,0xa1,0x90,0xce,0x8b,0x76,0xd2,0x7b, -0x65,0xd1,0x84,0x6d,0xc9,0x99,0x86,0x3a,0x3a,0x3a,0x00,0x00,0x00,0xb8,0xb8,0xb8, -0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, -0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, -0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, -0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, -0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, -0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x2c,0x00,0x00, -0x00,0x00,0x46,0x00,0x22,0x00,0x00,0x06,0xfe,0x40,0x90,0x70,0x48,0x2c,0x1a,0x8f, -0xc8,0xa4,0x72,0xc9,0x6c,0x3a,0x9f,0xd0,0xa8,0x74,0x4a,0xad,0x5a,0xaf,0xd8,0xac, -0x76,0xa9,0x40,0x04,0xbe,0x83,0xe2,0x60,0x3c,0x50,0x20,0x0d,0x8e,0x6f,0x00,0x31, -0x28,0x1c,0x0d,0x07,0xb5,0xc3,0x60,0x75,0x24,0x3e,0xf8,0xfc,0x87,0x11,0x06,0xe9, -0x3d,0x46,0x07,0x0b,0x7a,0x7a,0x7c,0x43,0x06,0x1e,0x84,0x78,0x0b,0x07,0x6e,0x51, -0x01,0x8a,0x84,0x08,0x7e,0x79,0x80,0x87,0x89,0x91,0x7a,0x93,0x0a,0x04,0x99,0x78, -0x96,0x4f,0x03,0x9e,0x79,0x01,0x94,0x9f,0x43,0x9c,0xa3,0xa4,0x05,0x77,0xa3,0xa0, -0x4e,0x98,0x79,0x0b,0x1e,0x83,0xa4,0xa6,0x1f,0x96,0x05,0x9d,0xaa,0x78,0x01,0x07, -0x84,0x04,0x1e,0x1e,0xbb,0xb8,0x51,0x84,0x0e,0x43,0x05,0x07,0x77,0xa5,0x7f,0x42, -0xb1,0xb2,0x01,0x63,0x08,0x0d,0xbb,0x01,0x0c,0x7a,0x0d,0x44,0x0e,0xd8,0xaf,0x4c, -0x05,0x7a,0x04,0x47,0x07,0x07,0xb7,0x80,0xa2,0xe1,0x7d,0x44,0x05,0x01,0x04,0x01, -0xd0,0xea,0x87,0x93,0x4f,0xe0,0x9a,0x49,0xce,0xd8,0x79,0x04,0x66,0x20,0x15,0x10, -0x10,0x11,0x92,0x29,0x80,0xb6,0xc0,0x91,0x15,0x45,0x1e,0x90,0x19,0x71,0x46,0xa8, -0x5c,0x04,0x0e,0x00,0x22,0x4e,0xe8,0x40,0x24,0x9f,0x3e,0x04,0x06,0xa7,0x58,0xd4, -0x93,0xa0,0x1c,0x91,0x3f,0xe8,0xf0,0x88,0x03,0xb1,0x21,0xa2,0x49,0x00,0x19,0x86, -0xfc,0x52,0x44,0xe0,0x01,0x9d,0x29,0x21,0x15,0x25,0x50,0xf7,0x67,0x25,0x1e,0x06, -0xfd,0x4e,0x9a,0xb4,0x90,0xac,0x15,0xfa,0xcb,0x52,0x53,0x1e,0x8c,0xf2,0xf8,0x07, -0x92,0x2d,0x08,0x3a,0x4d,0x12,0x49,0x95,0x49,0xdb,0x14,0x04,0xc4,0x14,0x85,0x29, -0xaa,0xe7,0x01,0x08,0xa4,0x49,0x01,0x14,0x51,0xe0,0x53,0x91,0xd5,0x29,0x06,0x1a, -0x64,0x02,0xf4,0xc7,0x81,0x9e,0x05,0x20,0x22,0x64,0xa5,0x30,0xae,0xab,0x9e,0x97, -0x53,0xd8,0xb9,0xfd,0x50,0xef,0x93,0x02,0x42,0x74,0x34,0xe8,0x9c,0x20,0x21,0xc9, -0x01,0x68,0x78,0xe6,0x55,0x29,0x20,0x56,0x4f,0x4c,0x40,0x51,0x71,0x82,0xc0,0x70, -0x21,0x22,0x85,0xbe,0x4b,0x1c,0x44,0x05,0xea,0xa4,0x01,0xbf,0x22,0xb5,0xf0,0x1c, -0x06,0x51,0x38,0x8f,0xe0,0x22,0xec,0x18,0xac,0x39,0x22,0xd4,0xd6,0x93,0x44,0x01, -0x32,0x82,0xc8,0xfc,0x61,0xb3,0x01,0x45,0x0c,0x2e,0x83,0x30,0xd0,0x0e,0x17,0x24, -0x0f,0x70,0x85,0x94,0xee,0x05,0x05,0x53,0x4b,0x32,0x1b,0x3f,0x98,0xd3,0x1d,0x29, -0x81,0xb0,0xae,0x1e,0x8c,0x7e,0x68,0xe0,0x60,0x5a,0x54,0x8f,0xb0,0x78,0x69,0x73, -0x06,0xa2,0x00,0x6b,0x57,0xca,0x3d,0x11,0x50,0xbd,0x04,0x30,0x4b,0x3a,0xd4,0xab, -0x5f,0x1f,0x9b,0x3d,0x13,0x74,0x27,0x88,0x3c,0x25,0xe0,0x17,0xbe,0x7a,0x79,0x45, -0x0d,0x0c,0xb0,0x8b,0xda,0x90,0xca,0x80,0x06,0x5d,0x17,0x60,0x1c,0x22,0x4c,0xd8, -0x57,0x22,0x06,0x20,0x00,0x98,0x07,0x08,0xe4,0x56,0x80,0x80,0x1c,0xc5,0xb7,0xc5, -0x82,0x0c,0x36,0xe8,0xe0,0x83,0x10,0x46,0x28,0xe1,0x84,0x14,0x56,0x68,0xa1,0x10, -0x41,0x00,0x00,0x3b,}; - -#if FSDATA_FILE_ALIGNMENT==1 -static const unsigned int dummy_align__404_html = 1; -#endif -static const unsigned char FSDATA_ALIGN_PRE data__404_html[] FSDATA_ALIGN_POST = { -/* /404.html (10 chars) */ -0x2f,0x34,0x30,0x34,0x2e,0x68,0x74,0x6d,0x6c,0x00,0x00,0x00, - -/* HTTP header */ -/* "HTTP/1.0 404 File not found -" (29 bytes) */ -0x48,0x54,0x54,0x50,0x2f,0x31,0x2e,0x30,0x20,0x34,0x30,0x34,0x20,0x46,0x69,0x6c, -0x65,0x20,0x6e,0x6f,0x74,0x20,0x66,0x6f,0x75,0x6e,0x64,0x0d,0x0a, -/* "Server: lwIP/2.0.3d (http://savannah.nongnu.org/projects/lwip) -" (64 bytes) */ -0x53,0x65,0x72,0x76,0x65,0x72,0x3a,0x20,0x6c,0x77,0x49,0x50,0x2f,0x32,0x2e,0x30, -0x2e,0x33,0x64,0x20,0x28,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61, -0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f, -0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x29,0x0d,0x0a, - -/* "Content-Length: 565 -" (18+ bytes) */ -0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x4c,0x65,0x6e,0x67,0x74,0x68,0x3a,0x20, -0x35,0x36,0x35,0x0d,0x0a, -/* "Content-Type: text/html - -" (27 bytes) */ -0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x54,0x79,0x70,0x65,0x3a,0x20,0x74,0x65, -0x78,0x74,0x2f,0x68,0x74,0x6d,0x6c,0x0d,0x0a,0x0d,0x0a, -/* raw file data (565 bytes) */ -0x3c,0x68,0x74,0x6d,0x6c,0x3e,0x0d,0x0a,0x3c,0x68,0x65,0x61,0x64,0x3e,0x3c,0x74, -0x69,0x74,0x6c,0x65,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c,0x69, -0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49,0x50, -0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x74,0x69,0x74,0x6c,0x65,0x3e,0x3c,0x2f, -0x68,0x65,0x61,0x64,0x3e,0x0d,0x0a,0x3c,0x62,0x6f,0x64,0x79,0x20,0x62,0x67,0x63, -0x6f,0x6c,0x6f,0x72,0x3d,0x22,0x77,0x68,0x69,0x74,0x65,0x22,0x20,0x74,0x65,0x78, -0x74,0x3d,0x22,0x62,0x6c,0x61,0x63,0x6b,0x22,0x3e,0x0d,0x0a,0x0d,0x0a,0x20,0x20, -0x20,0x20,0x3c,0x74,0x61,0x62,0x6c,0x65,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22, -0x31,0x30,0x30,0x25,0x22,0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x74, -0x72,0x20,0x76,0x61,0x6c,0x69,0x67,0x6e,0x3d,0x22,0x74,0x6f,0x70,0x22,0x3e,0x3c, -0x74,0x64,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22,0x38,0x30,0x22,0x3e,0x09,0x20, -0x20,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x61,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68, -0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77,0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73, -0x65,0x2f,0x22,0x3e,0x3c,0x69,0x6d,0x67,0x20,0x73,0x72,0x63,0x3d,0x22,0x2f,0x69, -0x6d,0x67,0x2f,0x73,0x69,0x63,0x73,0x2e,0x67,0x69,0x66,0x22,0x0d,0x0a,0x09,0x20, -0x20,0x62,0x6f,0x72,0x64,0x65,0x72,0x3d,0x22,0x30,0x22,0x20,0x61,0x6c,0x74,0x3d, -0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x20,0x74,0x69,0x74,0x6c, -0x65,0x3d,0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x3e,0x3c,0x2f, -0x61,0x3e,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x20,0x77,0x69, -0x64,0x74,0x68,0x3d,0x22,0x35,0x30,0x30,0x22,0x3e,0x09,0x20,0x20,0x0d,0x0a,0x09, -0x20,0x20,0x3c,0x68,0x31,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c, -0x69,0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49, -0x50,0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x68,0x31,0x3e,0x0d,0x0a,0x09,0x20, -0x20,0x3c,0x68,0x32,0x3e,0x34,0x30,0x34,0x20,0x2d,0x20,0x50,0x61,0x67,0x65,0x20, -0x6e,0x6f,0x74,0x20,0x66,0x6f,0x75,0x6e,0x64,0x3c,0x2f,0x68,0x32,0x3e,0x0d,0x0a, -0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x53,0x6f,0x72, -0x72,0x79,0x2c,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x67,0x65,0x20,0x79,0x6f,0x75, -0x20,0x61,0x72,0x65,0x20,0x72,0x65,0x71,0x75,0x65,0x73,0x74,0x69,0x6e,0x67,0x20, -0x77,0x61,0x73,0x20,0x6e,0x6f,0x74,0x20,0x66,0x6f,0x75,0x6e,0x64,0x20,0x6f,0x6e, -0x20,0x74,0x68,0x69,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x73,0x65,0x72,0x76, -0x65,0x72,0x2e,0x20,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09, -0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x26,0x6e, -0x62,0x73,0x70,0x3b,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x2f,0x74,0x72, -0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x2f,0x74,0x61,0x62,0x6c,0x65, -0x3e,0x0d,0x0a,0x3c,0x2f,0x62,0x6f,0x64,0x79,0x3e,0x0d,0x0a,0x3c,0x2f,0x68,0x74, -0x6d,0x6c,0x3e,0x0d,0x0a,}; - -#if FSDATA_FILE_ALIGNMENT==1 -static const unsigned int dummy_align__index_html = 2; -#endif -static const unsigned char FSDATA_ALIGN_PRE data__index_html[] FSDATA_ALIGN_POST = { -/* /index.html (12 chars) */ -0x2f,0x69,0x6e,0x64,0x65,0x78,0x2e,0x68,0x74,0x6d,0x6c,0x00, - -/* HTTP header */ -/* "HTTP/1.0 200 OK -" (17 bytes) */ -0x48,0x54,0x54,0x50,0x2f,0x31,0x2e,0x30,0x20,0x32,0x30,0x30,0x20,0x4f,0x4b,0x0d, -0x0a, -/* "Server: lwIP/2.0.3d (http://savannah.nongnu.org/projects/lwip) -" (64 bytes) */ -0x53,0x65,0x72,0x76,0x65,0x72,0x3a,0x20,0x6c,0x77,0x49,0x50,0x2f,0x32,0x2e,0x30, -0x2e,0x33,0x64,0x20,0x28,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61, -0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f, -0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x29,0x0d,0x0a, - -/* "Content-Length: 1751 -" (18+ bytes) */ -0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x4c,0x65,0x6e,0x67,0x74,0x68,0x3a,0x20, -0x31,0x37,0x35,0x31,0x0d,0x0a, -/* "Content-Type: text/html - -" (27 bytes) */ -0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x54,0x79,0x70,0x65,0x3a,0x20,0x74,0x65, -0x78,0x74,0x2f,0x68,0x74,0x6d,0x6c,0x0d,0x0a,0x0d,0x0a, -/* raw file data (1751 bytes) */ -0x3c,0x68,0x74,0x6d,0x6c,0x3e,0x0d,0x0a,0x3c,0x68,0x65,0x61,0x64,0x3e,0x3c,0x74, -0x69,0x74,0x6c,0x65,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c,0x69, -0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49,0x50, -0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x74,0x69,0x74,0x6c,0x65,0x3e,0x3c,0x2f, -0x68,0x65,0x61,0x64,0x3e,0x0d,0x0a,0x3c,0x62,0x6f,0x64,0x79,0x20,0x62,0x67,0x63, -0x6f,0x6c,0x6f,0x72,0x3d,0x22,0x77,0x68,0x69,0x74,0x65,0x22,0x20,0x74,0x65,0x78, -0x74,0x3d,0x22,0x62,0x6c,0x61,0x63,0x6b,0x22,0x3e,0x0d,0x0a,0x0d,0x0a,0x20,0x20, -0x20,0x20,0x3c,0x74,0x61,0x62,0x6c,0x65,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22, -0x31,0x30,0x30,0x25,0x22,0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x74, -0x72,0x20,0x76,0x61,0x6c,0x69,0x67,0x6e,0x3d,0x22,0x74,0x6f,0x70,0x22,0x3e,0x3c, -0x74,0x64,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22,0x38,0x30,0x22,0x3e,0x09,0x20, -0x20,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x61,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68, -0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77,0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73, -0x65,0x2f,0x22,0x3e,0x3c,0x69,0x6d,0x67,0x20,0x73,0x72,0x63,0x3d,0x22,0x2f,0x69, -0x6d,0x67,0x2f,0x73,0x69,0x63,0x73,0x2e,0x67,0x69,0x66,0x22,0x0d,0x0a,0x09,0x20, -0x20,0x62,0x6f,0x72,0x64,0x65,0x72,0x3d,0x22,0x30,0x22,0x20,0x61,0x6c,0x74,0x3d, -0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x20,0x74,0x69,0x74,0x6c, -0x65,0x3d,0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x3e,0x3c,0x2f, -0x61,0x3e,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x20,0x77,0x69, -0x64,0x74,0x68,0x3d,0x22,0x35,0x30,0x30,0x22,0x3e,0x09,0x20,0x20,0x0d,0x0a,0x09, -0x20,0x20,0x3c,0x68,0x31,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c, -0x69,0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49, -0x50,0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x68,0x31,0x3e,0x0d,0x0a,0x09,0x20, -0x20,0x3c,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x54,0x68,0x65,0x20,0x77, -0x65,0x62,0x20,0x70,0x61,0x67,0x65,0x20,0x79,0x6f,0x75,0x20,0x61,0x72,0x65,0x20, -0x77,0x61,0x74,0x63,0x68,0x69,0x6e,0x67,0x20,0x77,0x61,0x73,0x20,0x73,0x65,0x72, -0x76,0x65,0x64,0x20,0x62,0x79,0x20,0x61,0x20,0x73,0x69,0x6d,0x70,0x6c,0x65,0x20, -0x77,0x65,0x62,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x73,0x65,0x72,0x76,0x65,0x72, -0x20,0x72,0x75,0x6e,0x6e,0x69,0x6e,0x67,0x20,0x6f,0x6e,0x20,0x74,0x6f,0x70,0x20, -0x6f,0x66,0x20,0x74,0x68,0x65,0x20,0x6c,0x69,0x67,0x68,0x74,0x77,0x65,0x69,0x67, -0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49,0x50,0x20,0x73,0x74,0x61,0x63,0x6b,0x20, -0x3c,0x61,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68, -0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77,0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73, -0x65,0x2f,0x7e,0x61,0x64,0x61,0x6d,0x2f,0x6c,0x77,0x69,0x70,0x2f,0x22,0x3e,0x6c, -0x77,0x49,0x50,0x3c,0x2f,0x61,0x3e,0x2e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x2f,0x70, -0x3e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20, -0x6c,0x77,0x49,0x50,0x20,0x69,0x73,0x20,0x61,0x6e,0x20,0x6f,0x70,0x65,0x6e,0x20, -0x73,0x6f,0x75,0x72,0x63,0x65,0x20,0x69,0x6d,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74, -0x61,0x74,0x69,0x6f,0x6e,0x20,0x6f,0x66,0x20,0x74,0x68,0x65,0x20,0x54,0x43,0x50, -0x2f,0x49,0x50,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x70,0x72,0x6f,0x74,0x6f,0x63, -0x6f,0x6c,0x20,0x73,0x75,0x69,0x74,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x77,0x61, -0x73,0x20,0x6f,0x72,0x69,0x67,0x69,0x6e,0x61,0x6c,0x6c,0x79,0x20,0x77,0x72,0x69, -0x74,0x74,0x65,0x6e,0x20,0x62,0x79,0x20,0x3c,0x61,0x0d,0x0a,0x09,0x20,0x20,0x20, -0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77, -0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73,0x65,0x2f,0x7e,0x61,0x64,0x61,0x6d,0x2f, -0x6c,0x77,0x69,0x70,0x2f,0x22,0x3e,0x41,0x64,0x61,0x6d,0x20,0x44,0x75,0x6e,0x6b, -0x65,0x6c,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x6f,0x66,0x20,0x74,0x68,0x65, -0x20,0x53,0x77,0x65,0x64,0x69,0x73,0x68,0x20,0x49,0x6e,0x73,0x74,0x69,0x74,0x75, -0x74,0x65,0x20,0x6f,0x66,0x20,0x43,0x6f,0x6d,0x70,0x75,0x74,0x65,0x72,0x20,0x53, -0x63,0x69,0x65,0x6e,0x63,0x65,0x3c,0x2f,0x61,0x3e,0x20,0x62,0x75,0x74,0x20,0x6e, -0x6f,0x77,0x20,0x69,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x62,0x65,0x69,0x6e, -0x67,0x20,0x61,0x63,0x74,0x69,0x76,0x65,0x6c,0x79,0x20,0x64,0x65,0x76,0x65,0x6c, -0x6f,0x70,0x65,0x64,0x20,0x62,0x79,0x20,0x61,0x20,0x74,0x65,0x61,0x6d,0x20,0x6f, -0x66,0x20,0x64,0x65,0x76,0x65,0x6c,0x6f,0x70,0x65,0x72,0x73,0x0d,0x0a,0x09,0x20, -0x20,0x20,0x20,0x64,0x69,0x73,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x64,0x20,0x77, -0x6f,0x72,0x6c,0x64,0x2d,0x77,0x69,0x64,0x65,0x2e,0x20,0x53,0x69,0x6e,0x63,0x65, -0x20,0x69,0x74,0x27,0x73,0x20,0x72,0x65,0x6c,0x65,0x61,0x73,0x65,0x2c,0x20,0x6c, -0x77,0x49,0x50,0x20,0x68,0x61,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x73,0x70, -0x75,0x72,0x72,0x65,0x64,0x20,0x61,0x20,0x6c,0x6f,0x74,0x20,0x6f,0x66,0x20,0x69, -0x6e,0x74,0x65,0x72,0x65,0x73,0x74,0x20,0x61,0x6e,0x64,0x20,0x68,0x61,0x73,0x20, -0x62,0x65,0x65,0x6e,0x20,0x70,0x6f,0x72,0x74,0x65,0x64,0x20,0x74,0x6f,0x20,0x73, -0x65,0x76,0x65,0x72,0x61,0x6c,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x70,0x6c,0x61, -0x74,0x66,0x6f,0x72,0x6d,0x73,0x20,0x61,0x6e,0x64,0x20,0x6f,0x70,0x65,0x72,0x61, -0x74,0x69,0x6e,0x67,0x20,0x73,0x79,0x73,0x74,0x65,0x6d,0x73,0x2e,0x20,0x6c,0x77, -0x49,0x50,0x20,0x63,0x61,0x6e,0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x20,0x65, -0x69,0x74,0x68,0x65,0x72,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x77,0x69,0x74,0x68, -0x20,0x6f,0x72,0x20,0x77,0x69,0x74,0x68,0x6f,0x75,0x74,0x20,0x61,0x6e,0x20,0x75, -0x6e,0x64,0x65,0x72,0x6c,0x79,0x69,0x6e,0x67,0x20,0x4f,0x53,0x2e,0x0d,0x0a,0x09, -0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d,0x0a, -0x09,0x20,0x20,0x20,0x20,0x54,0x68,0x65,0x20,0x66,0x6f,0x63,0x75,0x73,0x20,0x6f, -0x66,0x20,0x74,0x68,0x65,0x20,0x6c,0x77,0x49,0x50,0x20,0x54,0x43,0x50,0x2f,0x49, -0x50,0x20,0x69,0x6d,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0x61,0x74,0x69,0x6f,0x6e, -0x20,0x69,0x73,0x20,0x74,0x6f,0x20,0x72,0x65,0x64,0x75,0x63,0x65,0x0d,0x0a,0x09, -0x20,0x20,0x20,0x20,0x74,0x68,0x65,0x20,0x52,0x41,0x4d,0x20,0x75,0x73,0x61,0x67, -0x65,0x20,0x77,0x68,0x69,0x6c,0x65,0x20,0x73,0x74,0x69,0x6c,0x6c,0x20,0x68,0x61, -0x76,0x69,0x6e,0x67,0x20,0x61,0x20,0x66,0x75,0x6c,0x6c,0x20,0x73,0x63,0x61,0x6c, -0x65,0x20,0x54,0x43,0x50,0x2e,0x20,0x54,0x68,0x69,0x73,0x0d,0x0a,0x09,0x20,0x20, -0x20,0x20,0x6d,0x61,0x6b,0x65,0x73,0x20,0x6c,0x77,0x49,0x50,0x20,0x73,0x75,0x69, -0x74,0x61,0x62,0x6c,0x65,0x20,0x66,0x6f,0x72,0x20,0x75,0x73,0x65,0x20,0x69,0x6e, -0x20,0x65,0x6d,0x62,0x65,0x64,0x64,0x65,0x64,0x20,0x73,0x79,0x73,0x74,0x65,0x6d, -0x73,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x65,0x6e,0x73,0x0d,0x0a,0x09,0x20,0x20, -0x20,0x20,0x6f,0x66,0x20,0x6b,0x69,0x6c,0x6f,0x62,0x79,0x74,0x65,0x73,0x20,0x6f, -0x66,0x20,0x66,0x72,0x65,0x65,0x20,0x52,0x41,0x4d,0x20,0x61,0x6e,0x64,0x20,0x72, -0x6f,0x6f,0x6d,0x20,0x66,0x6f,0x72,0x20,0x61,0x72,0x6f,0x75,0x6e,0x64,0x20,0x34, -0x30,0x20,0x6b,0x69,0x6c,0x6f,0x62,0x79,0x74,0x65,0x73,0x0d,0x0a,0x09,0x20,0x20, -0x20,0x20,0x6f,0x66,0x20,0x63,0x6f,0x64,0x65,0x20,0x52,0x4f,0x4d,0x2e,0x0d,0x0a, -0x09,0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d, -0x0a,0x09,0x20,0x20,0x20,0x20,0x4d,0x6f,0x72,0x65,0x20,0x69,0x6e,0x66,0x6f,0x72, -0x6d,0x61,0x74,0x69,0x6f,0x6e,0x20,0x61,0x62,0x6f,0x75,0x74,0x20,0x6c,0x77,0x49, -0x50,0x20,0x63,0x61,0x6e,0x20,0x62,0x65,0x20,0x66,0x6f,0x75,0x6e,0x64,0x20,0x61, -0x74,0x20,0x74,0x68,0x65,0x20,0x6c,0x77,0x49,0x50,0x0d,0x0a,0x09,0x20,0x20,0x20, -0x20,0x68,0x6f,0x6d,0x65,0x70,0x61,0x67,0x65,0x20,0x61,0x74,0x20,0x3c,0x61,0x0d, -0x0a,0x09,0x20,0x20,0x20,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68,0x74,0x74,0x70, -0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61,0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67, -0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f,0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f, -0x6c,0x77,0x69,0x70,0x2f,0x22,0x3e,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61, -0x76,0x61,0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72, -0x67,0x2f,0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x2f, -0x3c,0x2f,0x61,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x6f,0x72,0x20,0x61,0x74, -0x20,0x74,0x68,0x65,0x20,0x6c,0x77,0x49,0x50,0x20,0x77,0x69,0x6b,0x69,0x20,0x61, -0x74,0x20,0x3c,0x61,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x68,0x72,0x65,0x66,0x3d, -0x22,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x6c,0x77,0x69,0x70,0x2e,0x77,0x69,0x6b, -0x69,0x61,0x2e,0x63,0x6f,0x6d,0x2f,0x22,0x3e,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f, -0x6c,0x77,0x69,0x70,0x2e,0x77,0x69,0x6b,0x69,0x61,0x2e,0x63,0x6f,0x6d,0x2f,0x3c, -0x2f,0x61,0x3e,0x2e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09, -0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x26,0x6e, -0x62,0x73,0x70,0x3b,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x2f,0x74,0x72, -0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x2f,0x74,0x61,0x62,0x6c,0x65, -0x3e,0x0d,0x0a,0x3c,0x2f,0x62,0x6f,0x64,0x79,0x3e,0x0d,0x0a,0x3c,0x2f,0x68,0x74, -0x6d,0x6c,0x3e,0x0d,0x0a,0x0d,0x0a,}; - - - -const struct fsdata_file file__img_sics_gif[] = { { -file_NULL, -data__img_sics_gif, -data__img_sics_gif + 16, -sizeof(data__img_sics_gif) - 16, -FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT, -}}; - -const struct fsdata_file file__404_html[] = { { -file__img_sics_gif, -data__404_html, -data__404_html + 12, -sizeof(data__404_html) - 12, -FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT, -}}; - -const struct fsdata_file file__index_html[] = { { -file__404_html, -data__index_html, -data__index_html + 12, -sizeof(data__index_html) - 12, -FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT, -}}; - -#define FS_ROOT file__index_html -#define FS_NUMFILES 3 - +#include "lwip/apps/fs.h" +#include "lwip/def.h" + + +#define file_NULL (struct fsdata_file *) NULL + + +#ifndef FS_FILE_FLAGS_HEADER_INCLUDED +#define FS_FILE_FLAGS_HEADER_INCLUDED 1 +#endif +#ifndef FS_FILE_FLAGS_HEADER_PERSISTENT +#define FS_FILE_FLAGS_HEADER_PERSISTENT 0 +#endif +/* FSDATA_FILE_ALIGNMENT: 0=off, 1=by variable, 2=by include */ +#ifndef FSDATA_FILE_ALIGNMENT +#define FSDATA_FILE_ALIGNMENT 0 +#endif +#ifndef FSDATA_ALIGN_PRE +#define FSDATA_ALIGN_PRE +#endif +#ifndef FSDATA_ALIGN_POST +#define FSDATA_ALIGN_POST +#endif +#if FSDATA_FILE_ALIGNMENT==2 +#include "fsdata_alignment.h" +#endif +#if FSDATA_FILE_ALIGNMENT==1 +static const unsigned int dummy_align__img_sics_gif = 0; +#endif +static const unsigned char FSDATA_ALIGN_PRE data__img_sics_gif[] FSDATA_ALIGN_POST = { +/* /img/sics.gif (14 chars) */ +0x2f,0x69,0x6d,0x67,0x2f,0x73,0x69,0x63,0x73,0x2e,0x67,0x69,0x66,0x00,0x00,0x00, + +/* HTTP header */ +/* "HTTP/1.0 200 OK +" (17 bytes) */ +0x48,0x54,0x54,0x50,0x2f,0x31,0x2e,0x30,0x20,0x32,0x30,0x30,0x20,0x4f,0x4b,0x0d, +0x0a, +/* "Server: lwIP/2.0.3d (http://savannah.nongnu.org/projects/lwip) +" (64 bytes) */ +0x53,0x65,0x72,0x76,0x65,0x72,0x3a,0x20,0x6c,0x77,0x49,0x50,0x2f,0x32,0x2e,0x30, +0x2e,0x33,0x64,0x20,0x28,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61, +0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f, +0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x29,0x0d,0x0a, + +/* "Content-Length: 724 +" (18+ bytes) */ +0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x4c,0x65,0x6e,0x67,0x74,0x68,0x3a,0x20, +0x37,0x32,0x34,0x0d,0x0a, +/* "Content-Type: image/gif + +" (27 bytes) */ +0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x54,0x79,0x70,0x65,0x3a,0x20,0x69,0x6d, +0x61,0x67,0x65,0x2f,0x67,0x69,0x66,0x0d,0x0a,0x0d,0x0a, +/* raw file data (724 bytes) */ +0x47,0x49,0x46,0x38,0x39,0x61,0x46,0x00,0x22,0x00,0xa5,0x00,0x00,0xd9,0x2b,0x39, +0x6a,0x6a,0x6a,0xbf,0xbf,0xbf,0x93,0x93,0x93,0x0f,0x0f,0x0f,0xb0,0xb0,0xb0,0xa6, +0xa6,0xa6,0x80,0x80,0x80,0x76,0x76,0x76,0x1e,0x1e,0x1e,0x9d,0x9d,0x9d,0x2e,0x2e, +0x2e,0x49,0x49,0x49,0x54,0x54,0x54,0x8a,0x8a,0x8a,0x60,0x60,0x60,0xc6,0xa6,0x99, +0xbd,0xb5,0xb2,0xc2,0xab,0xa1,0xd9,0x41,0x40,0xd5,0x67,0x55,0xc0,0xb0,0xaa,0xd5, +0x5e,0x4e,0xd6,0x50,0x45,0xcc,0x93,0x7d,0xc8,0xa1,0x90,0xce,0x8b,0x76,0xd2,0x7b, +0x65,0xd1,0x84,0x6d,0xc9,0x99,0x86,0x3a,0x3a,0x3a,0x00,0x00,0x00,0xb8,0xb8,0xb8, +0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, +0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, +0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, +0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, +0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, +0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x2c,0x00,0x00, +0x00,0x00,0x46,0x00,0x22,0x00,0x00,0x06,0xfe,0x40,0x90,0x70,0x48,0x2c,0x1a,0x8f, +0xc8,0xa4,0x72,0xc9,0x6c,0x3a,0x9f,0xd0,0xa8,0x74,0x4a,0xad,0x5a,0xaf,0xd8,0xac, +0x76,0xa9,0x40,0x04,0xbe,0x83,0xe2,0x60,0x3c,0x50,0x20,0x0d,0x8e,0x6f,0x00,0x31, +0x28,0x1c,0x0d,0x07,0xb5,0xc3,0x60,0x75,0x24,0x3e,0xf8,0xfc,0x87,0x11,0x06,0xe9, +0x3d,0x46,0x07,0x0b,0x7a,0x7a,0x7c,0x43,0x06,0x1e,0x84,0x78,0x0b,0x07,0x6e,0x51, +0x01,0x8a,0x84,0x08,0x7e,0x79,0x80,0x87,0x89,0x91,0x7a,0x93,0x0a,0x04,0x99,0x78, +0x96,0x4f,0x03,0x9e,0x79,0x01,0x94,0x9f,0x43,0x9c,0xa3,0xa4,0x05,0x77,0xa3,0xa0, +0x4e,0x98,0x79,0x0b,0x1e,0x83,0xa4,0xa6,0x1f,0x96,0x05,0x9d,0xaa,0x78,0x01,0x07, +0x84,0x04,0x1e,0x1e,0xbb,0xb8,0x51,0x84,0x0e,0x43,0x05,0x07,0x77,0xa5,0x7f,0x42, +0xb1,0xb2,0x01,0x63,0x08,0x0d,0xbb,0x01,0x0c,0x7a,0x0d,0x44,0x0e,0xd8,0xaf,0x4c, +0x05,0x7a,0x04,0x47,0x07,0x07,0xb7,0x80,0xa2,0xe1,0x7d,0x44,0x05,0x01,0x04,0x01, +0xd0,0xea,0x87,0x93,0x4f,0xe0,0x9a,0x49,0xce,0xd8,0x79,0x04,0x66,0x20,0x15,0x10, +0x10,0x11,0x92,0x29,0x80,0xb6,0xc0,0x91,0x15,0x45,0x1e,0x90,0x19,0x71,0x46,0xa8, +0x5c,0x04,0x0e,0x00,0x22,0x4e,0xe8,0x40,0x24,0x9f,0x3e,0x04,0x06,0xa7,0x58,0xd4, +0x93,0xa0,0x1c,0x91,0x3f,0xe8,0xf0,0x88,0x03,0xb1,0x21,0xa2,0x49,0x00,0x19,0x86, +0xfc,0x52,0x44,0xe0,0x01,0x9d,0x29,0x21,0x15,0x25,0x50,0xf7,0x67,0x25,0x1e,0x06, +0xfd,0x4e,0x9a,0xb4,0x90,0xac,0x15,0xfa,0xcb,0x52,0x53,0x1e,0x8c,0xf2,0xf8,0x07, +0x92,0x2d,0x08,0x3a,0x4d,0x12,0x49,0x95,0x49,0xdb,0x14,0x04,0xc4,0x14,0x85,0x29, +0xaa,0xe7,0x01,0x08,0xa4,0x49,0x01,0x14,0x51,0xe0,0x53,0x91,0xd5,0x29,0x06,0x1a, +0x64,0x02,0xf4,0xc7,0x81,0x9e,0x05,0x20,0x22,0x64,0xa5,0x30,0xae,0xab,0x9e,0x97, +0x53,0xd8,0xb9,0xfd,0x50,0xef,0x93,0x02,0x42,0x74,0x34,0xe8,0x9c,0x20,0x21,0xc9, +0x01,0x68,0x78,0xe6,0x55,0x29,0x20,0x56,0x4f,0x4c,0x40,0x51,0x71,0x82,0xc0,0x70, +0x21,0x22,0x85,0xbe,0x4b,0x1c,0x44,0x05,0xea,0xa4,0x01,0xbf,0x22,0xb5,0xf0,0x1c, +0x06,0x51,0x38,0x8f,0xe0,0x22,0xec,0x18,0xac,0x39,0x22,0xd4,0xd6,0x93,0x44,0x01, +0x32,0x82,0xc8,0xfc,0x61,0xb3,0x01,0x45,0x0c,0x2e,0x83,0x30,0xd0,0x0e,0x17,0x24, +0x0f,0x70,0x85,0x94,0xee,0x05,0x05,0x53,0x4b,0x32,0x1b,0x3f,0x98,0xd3,0x1d,0x29, +0x81,0xb0,0xae,0x1e,0x8c,0x7e,0x68,0xe0,0x60,0x5a,0x54,0x8f,0xb0,0x78,0x69,0x73, +0x06,0xa2,0x00,0x6b,0x57,0xca,0x3d,0x11,0x50,0xbd,0x04,0x30,0x4b,0x3a,0xd4,0xab, +0x5f,0x1f,0x9b,0x3d,0x13,0x74,0x27,0x88,0x3c,0x25,0xe0,0x17,0xbe,0x7a,0x79,0x45, +0x0d,0x0c,0xb0,0x8b,0xda,0x90,0xca,0x80,0x06,0x5d,0x17,0x60,0x1c,0x22,0x4c,0xd8, +0x57,0x22,0x06,0x20,0x00,0x98,0x07,0x08,0xe4,0x56,0x80,0x80,0x1c,0xc5,0xb7,0xc5, +0x82,0x0c,0x36,0xe8,0xe0,0x83,0x10,0x46,0x28,0xe1,0x84,0x14,0x56,0x68,0xa1,0x10, +0x41,0x00,0x00,0x3b,}; + +#if FSDATA_FILE_ALIGNMENT==1 +static const unsigned int dummy_align__404_html = 1; +#endif +static const unsigned char FSDATA_ALIGN_PRE data__404_html[] FSDATA_ALIGN_POST = { +/* /404.html (10 chars) */ +0x2f,0x34,0x30,0x34,0x2e,0x68,0x74,0x6d,0x6c,0x00,0x00,0x00, + +/* HTTP header */ +/* "HTTP/1.0 404 File not found +" (29 bytes) */ +0x48,0x54,0x54,0x50,0x2f,0x31,0x2e,0x30,0x20,0x34,0x30,0x34,0x20,0x46,0x69,0x6c, +0x65,0x20,0x6e,0x6f,0x74,0x20,0x66,0x6f,0x75,0x6e,0x64,0x0d,0x0a, +/* "Server: lwIP/2.0.3d (http://savannah.nongnu.org/projects/lwip) +" (64 bytes) */ +0x53,0x65,0x72,0x76,0x65,0x72,0x3a,0x20,0x6c,0x77,0x49,0x50,0x2f,0x32,0x2e,0x30, +0x2e,0x33,0x64,0x20,0x28,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61, +0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f, +0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x29,0x0d,0x0a, + +/* "Content-Length: 565 +" (18+ bytes) */ +0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x4c,0x65,0x6e,0x67,0x74,0x68,0x3a,0x20, +0x35,0x36,0x35,0x0d,0x0a, +/* "Content-Type: text/html + +" (27 bytes) */ +0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x54,0x79,0x70,0x65,0x3a,0x20,0x74,0x65, +0x78,0x74,0x2f,0x68,0x74,0x6d,0x6c,0x0d,0x0a,0x0d,0x0a, +/* raw file data (565 bytes) */ +0x3c,0x68,0x74,0x6d,0x6c,0x3e,0x0d,0x0a,0x3c,0x68,0x65,0x61,0x64,0x3e,0x3c,0x74, +0x69,0x74,0x6c,0x65,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c,0x69, +0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49,0x50, +0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x74,0x69,0x74,0x6c,0x65,0x3e,0x3c,0x2f, +0x68,0x65,0x61,0x64,0x3e,0x0d,0x0a,0x3c,0x62,0x6f,0x64,0x79,0x20,0x62,0x67,0x63, +0x6f,0x6c,0x6f,0x72,0x3d,0x22,0x77,0x68,0x69,0x74,0x65,0x22,0x20,0x74,0x65,0x78, +0x74,0x3d,0x22,0x62,0x6c,0x61,0x63,0x6b,0x22,0x3e,0x0d,0x0a,0x0d,0x0a,0x20,0x20, +0x20,0x20,0x3c,0x74,0x61,0x62,0x6c,0x65,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22, +0x31,0x30,0x30,0x25,0x22,0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x74, +0x72,0x20,0x76,0x61,0x6c,0x69,0x67,0x6e,0x3d,0x22,0x74,0x6f,0x70,0x22,0x3e,0x3c, +0x74,0x64,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22,0x38,0x30,0x22,0x3e,0x09,0x20, +0x20,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x61,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68, +0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77,0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73, +0x65,0x2f,0x22,0x3e,0x3c,0x69,0x6d,0x67,0x20,0x73,0x72,0x63,0x3d,0x22,0x2f,0x69, +0x6d,0x67,0x2f,0x73,0x69,0x63,0x73,0x2e,0x67,0x69,0x66,0x22,0x0d,0x0a,0x09,0x20, +0x20,0x62,0x6f,0x72,0x64,0x65,0x72,0x3d,0x22,0x30,0x22,0x20,0x61,0x6c,0x74,0x3d, +0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x20,0x74,0x69,0x74,0x6c, +0x65,0x3d,0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x3e,0x3c,0x2f, +0x61,0x3e,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x20,0x77,0x69, +0x64,0x74,0x68,0x3d,0x22,0x35,0x30,0x30,0x22,0x3e,0x09,0x20,0x20,0x0d,0x0a,0x09, +0x20,0x20,0x3c,0x68,0x31,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c, +0x69,0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49, +0x50,0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x68,0x31,0x3e,0x0d,0x0a,0x09,0x20, +0x20,0x3c,0x68,0x32,0x3e,0x34,0x30,0x34,0x20,0x2d,0x20,0x50,0x61,0x67,0x65,0x20, +0x6e,0x6f,0x74,0x20,0x66,0x6f,0x75,0x6e,0x64,0x3c,0x2f,0x68,0x32,0x3e,0x0d,0x0a, +0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x53,0x6f,0x72, +0x72,0x79,0x2c,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x67,0x65,0x20,0x79,0x6f,0x75, +0x20,0x61,0x72,0x65,0x20,0x72,0x65,0x71,0x75,0x65,0x73,0x74,0x69,0x6e,0x67,0x20, +0x77,0x61,0x73,0x20,0x6e,0x6f,0x74,0x20,0x66,0x6f,0x75,0x6e,0x64,0x20,0x6f,0x6e, +0x20,0x74,0x68,0x69,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x73,0x65,0x72,0x76, +0x65,0x72,0x2e,0x20,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09, +0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x26,0x6e, +0x62,0x73,0x70,0x3b,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x2f,0x74,0x72, +0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x2f,0x74,0x61,0x62,0x6c,0x65, +0x3e,0x0d,0x0a,0x3c,0x2f,0x62,0x6f,0x64,0x79,0x3e,0x0d,0x0a,0x3c,0x2f,0x68,0x74, +0x6d,0x6c,0x3e,0x0d,0x0a,}; + +#if FSDATA_FILE_ALIGNMENT==1 +static const unsigned int dummy_align__index_html = 2; +#endif +static const unsigned char FSDATA_ALIGN_PRE data__index_html[] FSDATA_ALIGN_POST = { +/* /index.html (12 chars) */ +0x2f,0x69,0x6e,0x64,0x65,0x78,0x2e,0x68,0x74,0x6d,0x6c,0x00, + +/* HTTP header */ +/* "HTTP/1.0 200 OK +" (17 bytes) */ +0x48,0x54,0x54,0x50,0x2f,0x31,0x2e,0x30,0x20,0x32,0x30,0x30,0x20,0x4f,0x4b,0x0d, +0x0a, +/* "Server: lwIP/2.0.3d (http://savannah.nongnu.org/projects/lwip) +" (64 bytes) */ +0x53,0x65,0x72,0x76,0x65,0x72,0x3a,0x20,0x6c,0x77,0x49,0x50,0x2f,0x32,0x2e,0x30, +0x2e,0x33,0x64,0x20,0x28,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61, +0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f, +0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x29,0x0d,0x0a, + +/* "Content-Length: 1751 +" (18+ bytes) */ +0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x4c,0x65,0x6e,0x67,0x74,0x68,0x3a,0x20, +0x31,0x37,0x35,0x31,0x0d,0x0a, +/* "Content-Type: text/html + +" (27 bytes) */ +0x43,0x6f,0x6e,0x74,0x65,0x6e,0x74,0x2d,0x54,0x79,0x70,0x65,0x3a,0x20,0x74,0x65, +0x78,0x74,0x2f,0x68,0x74,0x6d,0x6c,0x0d,0x0a,0x0d,0x0a, +/* raw file data (1751 bytes) */ +0x3c,0x68,0x74,0x6d,0x6c,0x3e,0x0d,0x0a,0x3c,0x68,0x65,0x61,0x64,0x3e,0x3c,0x74, +0x69,0x74,0x6c,0x65,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c,0x69, +0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49,0x50, +0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x74,0x69,0x74,0x6c,0x65,0x3e,0x3c,0x2f, +0x68,0x65,0x61,0x64,0x3e,0x0d,0x0a,0x3c,0x62,0x6f,0x64,0x79,0x20,0x62,0x67,0x63, +0x6f,0x6c,0x6f,0x72,0x3d,0x22,0x77,0x68,0x69,0x74,0x65,0x22,0x20,0x74,0x65,0x78, +0x74,0x3d,0x22,0x62,0x6c,0x61,0x63,0x6b,0x22,0x3e,0x0d,0x0a,0x0d,0x0a,0x20,0x20, +0x20,0x20,0x3c,0x74,0x61,0x62,0x6c,0x65,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22, +0x31,0x30,0x30,0x25,0x22,0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x74, +0x72,0x20,0x76,0x61,0x6c,0x69,0x67,0x6e,0x3d,0x22,0x74,0x6f,0x70,0x22,0x3e,0x3c, +0x74,0x64,0x20,0x77,0x69,0x64,0x74,0x68,0x3d,0x22,0x38,0x30,0x22,0x3e,0x09,0x20, +0x20,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x61,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68, +0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77,0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73, +0x65,0x2f,0x22,0x3e,0x3c,0x69,0x6d,0x67,0x20,0x73,0x72,0x63,0x3d,0x22,0x2f,0x69, +0x6d,0x67,0x2f,0x73,0x69,0x63,0x73,0x2e,0x67,0x69,0x66,0x22,0x0d,0x0a,0x09,0x20, +0x20,0x62,0x6f,0x72,0x64,0x65,0x72,0x3d,0x22,0x30,0x22,0x20,0x61,0x6c,0x74,0x3d, +0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x20,0x74,0x69,0x74,0x6c, +0x65,0x3d,0x22,0x53,0x49,0x43,0x53,0x20,0x6c,0x6f,0x67,0x6f,0x22,0x3e,0x3c,0x2f, +0x61,0x3e,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x20,0x77,0x69, +0x64,0x74,0x68,0x3d,0x22,0x35,0x30,0x30,0x22,0x3e,0x09,0x20,0x20,0x0d,0x0a,0x09, +0x20,0x20,0x3c,0x68,0x31,0x3e,0x6c,0x77,0x49,0x50,0x20,0x2d,0x20,0x41,0x20,0x4c, +0x69,0x67,0x68,0x74,0x77,0x65,0x69,0x67,0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49, +0x50,0x20,0x53,0x74,0x61,0x63,0x6b,0x3c,0x2f,0x68,0x31,0x3e,0x0d,0x0a,0x09,0x20, +0x20,0x3c,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x54,0x68,0x65,0x20,0x77, +0x65,0x62,0x20,0x70,0x61,0x67,0x65,0x20,0x79,0x6f,0x75,0x20,0x61,0x72,0x65,0x20, +0x77,0x61,0x74,0x63,0x68,0x69,0x6e,0x67,0x20,0x77,0x61,0x73,0x20,0x73,0x65,0x72, +0x76,0x65,0x64,0x20,0x62,0x79,0x20,0x61,0x20,0x73,0x69,0x6d,0x70,0x6c,0x65,0x20, +0x77,0x65,0x62,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x73,0x65,0x72,0x76,0x65,0x72, +0x20,0x72,0x75,0x6e,0x6e,0x69,0x6e,0x67,0x20,0x6f,0x6e,0x20,0x74,0x6f,0x70,0x20, +0x6f,0x66,0x20,0x74,0x68,0x65,0x20,0x6c,0x69,0x67,0x68,0x74,0x77,0x65,0x69,0x67, +0x68,0x74,0x20,0x54,0x43,0x50,0x2f,0x49,0x50,0x20,0x73,0x74,0x61,0x63,0x6b,0x20, +0x3c,0x61,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68, +0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77,0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73, +0x65,0x2f,0x7e,0x61,0x64,0x61,0x6d,0x2f,0x6c,0x77,0x69,0x70,0x2f,0x22,0x3e,0x6c, +0x77,0x49,0x50,0x3c,0x2f,0x61,0x3e,0x2e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x2f,0x70, +0x3e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20, +0x6c,0x77,0x49,0x50,0x20,0x69,0x73,0x20,0x61,0x6e,0x20,0x6f,0x70,0x65,0x6e,0x20, +0x73,0x6f,0x75,0x72,0x63,0x65,0x20,0x69,0x6d,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74, +0x61,0x74,0x69,0x6f,0x6e,0x20,0x6f,0x66,0x20,0x74,0x68,0x65,0x20,0x54,0x43,0x50, +0x2f,0x49,0x50,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x70,0x72,0x6f,0x74,0x6f,0x63, +0x6f,0x6c,0x20,0x73,0x75,0x69,0x74,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x77,0x61, +0x73,0x20,0x6f,0x72,0x69,0x67,0x69,0x6e,0x61,0x6c,0x6c,0x79,0x20,0x77,0x72,0x69, +0x74,0x74,0x65,0x6e,0x20,0x62,0x79,0x20,0x3c,0x61,0x0d,0x0a,0x09,0x20,0x20,0x20, +0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x77,0x77, +0x77,0x2e,0x73,0x69,0x63,0x73,0x2e,0x73,0x65,0x2f,0x7e,0x61,0x64,0x61,0x6d,0x2f, +0x6c,0x77,0x69,0x70,0x2f,0x22,0x3e,0x41,0x64,0x61,0x6d,0x20,0x44,0x75,0x6e,0x6b, +0x65,0x6c,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x6f,0x66,0x20,0x74,0x68,0x65, +0x20,0x53,0x77,0x65,0x64,0x69,0x73,0x68,0x20,0x49,0x6e,0x73,0x74,0x69,0x74,0x75, +0x74,0x65,0x20,0x6f,0x66,0x20,0x43,0x6f,0x6d,0x70,0x75,0x74,0x65,0x72,0x20,0x53, +0x63,0x69,0x65,0x6e,0x63,0x65,0x3c,0x2f,0x61,0x3e,0x20,0x62,0x75,0x74,0x20,0x6e, +0x6f,0x77,0x20,0x69,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x62,0x65,0x69,0x6e, +0x67,0x20,0x61,0x63,0x74,0x69,0x76,0x65,0x6c,0x79,0x20,0x64,0x65,0x76,0x65,0x6c, +0x6f,0x70,0x65,0x64,0x20,0x62,0x79,0x20,0x61,0x20,0x74,0x65,0x61,0x6d,0x20,0x6f, +0x66,0x20,0x64,0x65,0x76,0x65,0x6c,0x6f,0x70,0x65,0x72,0x73,0x0d,0x0a,0x09,0x20, +0x20,0x20,0x20,0x64,0x69,0x73,0x74,0x72,0x69,0x62,0x75,0x74,0x65,0x64,0x20,0x77, +0x6f,0x72,0x6c,0x64,0x2d,0x77,0x69,0x64,0x65,0x2e,0x20,0x53,0x69,0x6e,0x63,0x65, +0x20,0x69,0x74,0x27,0x73,0x20,0x72,0x65,0x6c,0x65,0x61,0x73,0x65,0x2c,0x20,0x6c, +0x77,0x49,0x50,0x20,0x68,0x61,0x73,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x73,0x70, +0x75,0x72,0x72,0x65,0x64,0x20,0x61,0x20,0x6c,0x6f,0x74,0x20,0x6f,0x66,0x20,0x69, +0x6e,0x74,0x65,0x72,0x65,0x73,0x74,0x20,0x61,0x6e,0x64,0x20,0x68,0x61,0x73,0x20, +0x62,0x65,0x65,0x6e,0x20,0x70,0x6f,0x72,0x74,0x65,0x64,0x20,0x74,0x6f,0x20,0x73, +0x65,0x76,0x65,0x72,0x61,0x6c,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x70,0x6c,0x61, +0x74,0x66,0x6f,0x72,0x6d,0x73,0x20,0x61,0x6e,0x64,0x20,0x6f,0x70,0x65,0x72,0x61, +0x74,0x69,0x6e,0x67,0x20,0x73,0x79,0x73,0x74,0x65,0x6d,0x73,0x2e,0x20,0x6c,0x77, +0x49,0x50,0x20,0x63,0x61,0x6e,0x20,0x62,0x65,0x20,0x75,0x73,0x65,0x64,0x20,0x65, +0x69,0x74,0x68,0x65,0x72,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x77,0x69,0x74,0x68, +0x20,0x6f,0x72,0x20,0x77,0x69,0x74,0x68,0x6f,0x75,0x74,0x20,0x61,0x6e,0x20,0x75, +0x6e,0x64,0x65,0x72,0x6c,0x79,0x69,0x6e,0x67,0x20,0x4f,0x53,0x2e,0x0d,0x0a,0x09, +0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d,0x0a, +0x09,0x20,0x20,0x20,0x20,0x54,0x68,0x65,0x20,0x66,0x6f,0x63,0x75,0x73,0x20,0x6f, +0x66,0x20,0x74,0x68,0x65,0x20,0x6c,0x77,0x49,0x50,0x20,0x54,0x43,0x50,0x2f,0x49, +0x50,0x20,0x69,0x6d,0x70,0x6c,0x65,0x6d,0x65,0x6e,0x74,0x61,0x74,0x69,0x6f,0x6e, +0x20,0x69,0x73,0x20,0x74,0x6f,0x20,0x72,0x65,0x64,0x75,0x63,0x65,0x0d,0x0a,0x09, +0x20,0x20,0x20,0x20,0x74,0x68,0x65,0x20,0x52,0x41,0x4d,0x20,0x75,0x73,0x61,0x67, +0x65,0x20,0x77,0x68,0x69,0x6c,0x65,0x20,0x73,0x74,0x69,0x6c,0x6c,0x20,0x68,0x61, +0x76,0x69,0x6e,0x67,0x20,0x61,0x20,0x66,0x75,0x6c,0x6c,0x20,0x73,0x63,0x61,0x6c, +0x65,0x20,0x54,0x43,0x50,0x2e,0x20,0x54,0x68,0x69,0x73,0x0d,0x0a,0x09,0x20,0x20, +0x20,0x20,0x6d,0x61,0x6b,0x65,0x73,0x20,0x6c,0x77,0x49,0x50,0x20,0x73,0x75,0x69, +0x74,0x61,0x62,0x6c,0x65,0x20,0x66,0x6f,0x72,0x20,0x75,0x73,0x65,0x20,0x69,0x6e, +0x20,0x65,0x6d,0x62,0x65,0x64,0x64,0x65,0x64,0x20,0x73,0x79,0x73,0x74,0x65,0x6d, +0x73,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x65,0x6e,0x73,0x0d,0x0a,0x09,0x20,0x20, +0x20,0x20,0x6f,0x66,0x20,0x6b,0x69,0x6c,0x6f,0x62,0x79,0x74,0x65,0x73,0x20,0x6f, +0x66,0x20,0x66,0x72,0x65,0x65,0x20,0x52,0x41,0x4d,0x20,0x61,0x6e,0x64,0x20,0x72, +0x6f,0x6f,0x6d,0x20,0x66,0x6f,0x72,0x20,0x61,0x72,0x6f,0x75,0x6e,0x64,0x20,0x34, +0x30,0x20,0x6b,0x69,0x6c,0x6f,0x62,0x79,0x74,0x65,0x73,0x0d,0x0a,0x09,0x20,0x20, +0x20,0x20,0x6f,0x66,0x20,0x63,0x6f,0x64,0x65,0x20,0x52,0x4f,0x4d,0x2e,0x0d,0x0a, +0x09,0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x70,0x3e,0x0d, +0x0a,0x09,0x20,0x20,0x20,0x20,0x4d,0x6f,0x72,0x65,0x20,0x69,0x6e,0x66,0x6f,0x72, +0x6d,0x61,0x74,0x69,0x6f,0x6e,0x20,0x61,0x62,0x6f,0x75,0x74,0x20,0x6c,0x77,0x49, +0x50,0x20,0x63,0x61,0x6e,0x20,0x62,0x65,0x20,0x66,0x6f,0x75,0x6e,0x64,0x20,0x61, +0x74,0x20,0x74,0x68,0x65,0x20,0x6c,0x77,0x49,0x50,0x0d,0x0a,0x09,0x20,0x20,0x20, +0x20,0x68,0x6f,0x6d,0x65,0x70,0x61,0x67,0x65,0x20,0x61,0x74,0x20,0x3c,0x61,0x0d, +0x0a,0x09,0x20,0x20,0x20,0x20,0x68,0x72,0x65,0x66,0x3d,0x22,0x68,0x74,0x74,0x70, +0x3a,0x2f,0x2f,0x73,0x61,0x76,0x61,0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67, +0x6e,0x75,0x2e,0x6f,0x72,0x67,0x2f,0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f, +0x6c,0x77,0x69,0x70,0x2f,0x22,0x3e,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x73,0x61, +0x76,0x61,0x6e,0x6e,0x61,0x68,0x2e,0x6e,0x6f,0x6e,0x67,0x6e,0x75,0x2e,0x6f,0x72, +0x67,0x2f,0x70,0x72,0x6f,0x6a,0x65,0x63,0x74,0x73,0x2f,0x6c,0x77,0x69,0x70,0x2f, +0x3c,0x2f,0x61,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x6f,0x72,0x20,0x61,0x74, +0x20,0x74,0x68,0x65,0x20,0x6c,0x77,0x49,0x50,0x20,0x77,0x69,0x6b,0x69,0x20,0x61, +0x74,0x20,0x3c,0x61,0x0d,0x0a,0x09,0x20,0x20,0x20,0x20,0x68,0x72,0x65,0x66,0x3d, +0x22,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f,0x6c,0x77,0x69,0x70,0x2e,0x77,0x69,0x6b, +0x69,0x61,0x2e,0x63,0x6f,0x6d,0x2f,0x22,0x3e,0x68,0x74,0x74,0x70,0x3a,0x2f,0x2f, +0x6c,0x77,0x69,0x70,0x2e,0x77,0x69,0x6b,0x69,0x61,0x2e,0x63,0x6f,0x6d,0x2f,0x3c, +0x2f,0x61,0x3e,0x2e,0x0d,0x0a,0x09,0x20,0x20,0x3c,0x2f,0x70,0x3e,0x0d,0x0a,0x09, +0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x74,0x64,0x3e,0x0d,0x0a,0x09,0x20,0x20,0x26,0x6e, +0x62,0x73,0x70,0x3b,0x0d,0x0a,0x09,0x3c,0x2f,0x74,0x64,0x3e,0x3c,0x2f,0x74,0x72, +0x3e,0x0d,0x0a,0x20,0x20,0x20,0x20,0x20,0x20,0x3c,0x2f,0x74,0x61,0x62,0x6c,0x65, +0x3e,0x0d,0x0a,0x3c,0x2f,0x62,0x6f,0x64,0x79,0x3e,0x0d,0x0a,0x3c,0x2f,0x68,0x74, +0x6d,0x6c,0x3e,0x0d,0x0a,0x0d,0x0a,}; + + + +const struct fsdata_file file__img_sics_gif[] = { { +file_NULL, +data__img_sics_gif, +data__img_sics_gif + 16, +sizeof(data__img_sics_gif) - 16, +FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT, +}}; + +const struct fsdata_file file__404_html[] = { { +file__img_sics_gif, +data__404_html, +data__404_html + 12, +sizeof(data__404_html) - 12, +FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT, +}}; + +const struct fsdata_file file__index_html[] = { { +file__404_html, +data__index_html, +data__index_html + 12, +sizeof(data__index_html) - 12, +FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT, +}}; + +#define FS_ROOT file__index_html +#define FS_NUMFILES 3 + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.h index bd73419d..d31550d7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/fsdata.h @@ -1,41 +1,41 @@ -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_FSDATA_H -#define LWIP_FSDATA_H - -#include "lwip/apps/httpd_opts.h" -#include "lwip/apps/fs.h" - -/* THIS FILE IS DEPRECATED AND WILL BE REMOVED IN THE FUTURE */ -/* content was moved to fs.h to simplify #include structure */ - -#endif /* LWIP_FSDATA_H */ +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_FSDATA_H +#define LWIP_FSDATA_H + +#include "lwip/apps/httpd_opts.h" +#include "lwip/apps/fs.h" + +/* THIS FILE IS DEPRECATED AND WILL BE REMOVED IN THE FUTURE */ +/* content was moved to fs.h to simplify #include structure */ + +#endif /* LWIP_FSDATA_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/http_client.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/http_client.c index 6129cd5c..82da60d7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/http_client.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/http_client.c @@ -1,909 +1,909 @@ -/** - * @file - * HTTP client - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - */ - -/** - * @defgroup httpc HTTP client - * @ingroup apps - * @todo: - * - persistent connections - * - select outgoing http version - * - optionally follow redirect - * - check request uri for invalid characters? (e.g. encode spaces) - * - IPv6 support - */ - -#include "lwip/apps/http_client.h" - -#include "lwip/altcp_tcp.h" -#include "lwip/dns.h" -#include "lwip/debug.h" -#include "lwip/mem.h" -#include "lwip/altcp_tls.h" -#include "lwip/init.h" - -#include -#include -#include - -#if LWIP_TCP && LWIP_CALLBACK_API - -/** - * HTTPC_DEBUG: Enable debugging for HTTP client. - */ -#ifndef HTTPC_DEBUG -#define HTTPC_DEBUG LWIP_DBG_OFF -#endif - -/** Set this to 1 to keep server name and uri in request state */ -#ifndef HTTPC_DEBUG_REQUEST -#define HTTPC_DEBUG_REQUEST 0 -#endif - -/** This string is passed in the HTTP header as "User-Agent: " */ -#ifndef HTTPC_CLIENT_AGENT -#define HTTPC_CLIENT_AGENT "lwIP/" LWIP_VERSION_STRING " (http://savannah.nongnu.org/projects/lwip)" -#endif - -/* the various debug levels for this file */ -#define HTTPC_DEBUG_TRACE (HTTPC_DEBUG | LWIP_DBG_TRACE) -#define HTTPC_DEBUG_STATE (HTTPC_DEBUG | LWIP_DBG_STATE) -#define HTTPC_DEBUG_WARN (HTTPC_DEBUG | LWIP_DBG_LEVEL_WARNING) -#define HTTPC_DEBUG_WARN_STATE (HTTPC_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) -#define HTTPC_DEBUG_SERIOUS (HTTPC_DEBUG | LWIP_DBG_LEVEL_SERIOUS) - -#define HTTPC_POLL_INTERVAL 1 -#define HTTPC_POLL_TIMEOUT 30 /* 15 seconds */ - -#define HTTPC_CONTENT_LEN_INVALID 0xFFFFFFFF - -/* GET request basic */ -#define HTTPC_REQ_11 "GET %s HTTP/1.1\r\n" /* URI */\ - "User-Agent: %s\r\n" /* User-Agent */ \ - "Accept: */*\r\n" \ - "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ - "\r\n" -#define HTTPC_REQ_11_FORMAT(uri) HTTPC_REQ_11, uri, HTTPC_CLIENT_AGENT - -/* GET request with host */ -#define HTTPC_REQ_11_HOST "GET %s HTTP/1.1\r\n" /* URI */\ - "User-Agent: %s\r\n" /* User-Agent */ \ - "Accept: */*\r\n" \ - "Host: %s\r\n" /* server name */ \ - "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ - "\r\n" -#define HTTPC_REQ_11_HOST_FORMAT(uri, srv_name) HTTPC_REQ_11_HOST, uri, HTTPC_CLIENT_AGENT, srv_name - -/* GET request with proxy */ -#define HTTPC_REQ_11_PROXY "GET http://%s%s HTTP/1.1\r\n" /* HOST, URI */\ - "User-Agent: %s\r\n" /* User-Agent */ \ - "Accept: */*\r\n" \ - "Host: %s\r\n" /* server name */ \ - "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ - "\r\n" -#define HTTPC_REQ_11_PROXY_FORMAT(host, uri, srv_name) HTTPC_REQ_11_PROXY, host, uri, HTTPC_CLIENT_AGENT, srv_name - -/* GET request with proxy (non-default server port) */ -#define HTTPC_REQ_11_PROXY_PORT "GET http://%s:%d%s HTTP/1.1\r\n" /* HOST, host-port, URI */\ - "User-Agent: %s\r\n" /* User-Agent */ \ - "Accept: */*\r\n" \ - "Host: %s\r\n" /* server name */ \ - "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ - "\r\n" -#define HTTPC_REQ_11_PROXY_PORT_FORMAT(host, host_port, uri, srv_name) HTTPC_REQ_11_PROXY_PORT, host, host_port, uri, HTTPC_CLIENT_AGENT, srv_name - -typedef enum ehttpc_parse_state { - HTTPC_PARSE_WAIT_FIRST_LINE = 0, - HTTPC_PARSE_WAIT_HEADERS, - HTTPC_PARSE_RX_DATA -} httpc_parse_state_t; - -typedef struct _httpc_state -{ - struct altcp_pcb* pcb; - ip_addr_t remote_addr; - u16_t remote_port; - int timeout_ticks; - struct pbuf *request; - struct pbuf *rx_hdrs; - u16_t rx_http_version; - u16_t rx_status; - altcp_recv_fn recv_fn; - const httpc_connection_t *conn_settings; - void* callback_arg; - u32_t rx_content_len; - u32_t hdr_content_len; - httpc_parse_state_t parse_state; -#if HTTPC_DEBUG_REQUEST - char* server_name; - char* uri; -#endif -} httpc_state_t; - -/** Free http client state and deallocate all resources within */ -static err_t -httpc_free_state(httpc_state_t* req) -{ - struct altcp_pcb* tpcb; - - if (req->request != NULL) { - pbuf_free(req->request); - req->request = NULL; - } - if (req->rx_hdrs != NULL) { - pbuf_free(req->rx_hdrs); - req->rx_hdrs = NULL; - } - - tpcb = req->pcb; - mem_free(req); - req = NULL; - - if (tpcb != NULL) { - err_t r; - altcp_arg(tpcb, NULL); - altcp_recv(tpcb, NULL); - altcp_err(tpcb, NULL); - altcp_poll(tpcb, NULL, 0); - altcp_sent(tpcb, NULL); - r = altcp_close(tpcb); - if (r != ERR_OK) { - altcp_abort(tpcb); - return ERR_ABRT; - } - } - return ERR_OK; -} - -/** Close the connection: call finished callback and free the state */ -static err_t -httpc_close(httpc_state_t* req, httpc_result_t result, u32_t server_response, err_t err) -{ - if (req != NULL) { - if (req->conn_settings != NULL) { - if (req->conn_settings->result_fn != NULL) { - req->conn_settings->result_fn(req->callback_arg, result, req->rx_content_len, server_response, err); - } - } - return httpc_free_state(req); - } - return ERR_OK; -} - -/** Parse http header response line 1 */ -static err_t -http_parse_response_status(struct pbuf *p, u16_t *http_version, u16_t *http_status, u16_t *http_status_str_offset) -{ - u16_t end1 = pbuf_memfind(p, "\r\n", 2, 0); - if (end1 != 0xFFFF) { - /* get parts of first line */ - u16_t space1, space2; - space1 = pbuf_memfind(p, " ", 1, 0); - if (space1 != 0xFFFF) { - if ((pbuf_memcmp(p, 0, "HTTP/", 5) == 0) && (pbuf_get_at(p, 6) == '.')) { - char status_num[10]; - size_t status_num_len; - /* parse http version */ - u16_t version = pbuf_get_at(p, 5) - '0'; - version <<= 8; - version |= pbuf_get_at(p, 7) - '0'; - *http_version = version; - - /* parse http status number */ - space2 = pbuf_memfind(p, " ", 1, space1 + 1); - if (space2 != 0xFFFF) { - *http_status_str_offset = space2 + 1; - status_num_len = space2 - space1 - 1; - } else { - status_num_len = end1 - space1 - 1; - } - memset(status_num, 0, sizeof(status_num)); - if (pbuf_copy_partial(p, status_num, (u16_t)status_num_len, space1 + 1) == status_num_len) { - int status = atoi(status_num); - if ((status > 0) && (status <= 0xFFFF)) { - *http_status = (u16_t)status; - return ERR_OK; - } - } - } - } - } - return ERR_VAL; -} - -/** Wait for all headers to be received, return its length and content-length (if available) */ -static err_t -http_wait_headers(struct pbuf *p, u32_t *content_length, u16_t *total_header_len) -{ - u16_t end1 = pbuf_memfind(p, "\r\n\r\n", 4, 0); - if (end1 < (0xFFFF - 2)) { - /* all headers received */ - /* check if we have a content length (@todo: case insensitive?) */ - u16_t content_len_hdr; - *content_length = HTTPC_CONTENT_LEN_INVALID; - *total_header_len = end1 + 4; - - content_len_hdr = pbuf_memfind(p, "Content-Length: ", 16, 0); - if (content_len_hdr != 0xFFFF) { - u16_t content_len_line_end = pbuf_memfind(p, "\r\n", 2, content_len_hdr); - if (content_len_line_end != 0xFFFF) { - char content_len_num[16]; - u16_t content_len_num_len = (u16_t)(content_len_line_end - content_len_hdr - 16); - memset(content_len_num, 0, sizeof(content_len_num)); - if (pbuf_copy_partial(p, content_len_num, content_len_num_len, content_len_hdr + 16) == content_len_num_len) { - int len = atoi(content_len_num); - if ((len >= 0) && ((u32_t)len < HTTPC_CONTENT_LEN_INVALID)) { - *content_length = (u32_t)len; - } - } - } - } - return ERR_OK; - } - return ERR_VAL; -} - -/** http client tcp recv callback */ -static err_t -httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r) -{ - httpc_state_t* req = (httpc_state_t*)arg; - LWIP_UNUSED_ARG(r); - - if (p == NULL) { - httpc_result_t result; - if (req->parse_state != HTTPC_PARSE_RX_DATA) { - /* did not get RX data yet */ - result = HTTPC_RESULT_ERR_CLOSED; - } else if ((req->hdr_content_len != HTTPC_CONTENT_LEN_INVALID) && - (req->hdr_content_len != req->rx_content_len)) { - /* header has been received with content length but not all data received */ - result = HTTPC_RESULT_ERR_CONTENT_LEN; - } else { - /* receiving data and either all data received or no content length header */ - result = HTTPC_RESULT_OK; - } - return httpc_close(req, result, req->rx_status, ERR_OK); - } - if (req->parse_state != HTTPC_PARSE_RX_DATA) { - if (req->rx_hdrs == NULL) { - req->rx_hdrs = p; - } else { - pbuf_cat(req->rx_hdrs, p); - } - if (req->parse_state == HTTPC_PARSE_WAIT_FIRST_LINE) { - u16_t status_str_off; - err_t err = http_parse_response_status(req->rx_hdrs, &req->rx_http_version, &req->rx_status, &status_str_off); - if (err == ERR_OK) { - /* don't care status string */ - req->parse_state = HTTPC_PARSE_WAIT_HEADERS; - } - } - if (req->parse_state == HTTPC_PARSE_WAIT_HEADERS) { - u16_t total_header_len; - err_t err = http_wait_headers(req->rx_hdrs, &req->hdr_content_len, &total_header_len); - if (err == ERR_OK) { - struct pbuf *q; - /* full header received, send window update for header bytes and call into client callback */ - altcp_recved(pcb, total_header_len); - if (req->conn_settings) { - if (req->conn_settings->headers_done_fn) { - err = req->conn_settings->headers_done_fn(req, req->callback_arg, req->rx_hdrs, total_header_len, req->hdr_content_len); - if (err != ERR_OK) { - return httpc_close(req, HTTPC_RESULT_LOCAL_ABORT, req->rx_status, err); - } - } - } - /* hide header bytes in pbuf */ - q = pbuf_free_header(req->rx_hdrs, total_header_len); - p = q; - req->rx_hdrs = NULL; - /* go on with data */ - req->parse_state = HTTPC_PARSE_RX_DATA; - } - } - } - if ((p != NULL) && (req->parse_state == HTTPC_PARSE_RX_DATA)) { - req->rx_content_len += p->tot_len; - if (req->recv_fn != NULL) { - /* directly return here: the connection migth already be aborted from the callback! */ - return req->recv_fn(req->callback_arg, pcb, p, r); - } else { - altcp_recved(pcb, p->tot_len); - pbuf_free(p); - } - } - return ERR_OK; -} - -/** http client tcp err callback */ -static void -httpc_tcp_err(void *arg, err_t err) -{ - httpc_state_t* req = (httpc_state_t*)arg; - if (req != NULL) { - /* pcb has already been deallocated */ - req->pcb = NULL; - httpc_close(req, HTTPC_RESULT_ERR_CLOSED, 0, err); - } -} - -/** http client tcp poll callback */ -static err_t -httpc_tcp_poll(void *arg, struct altcp_pcb *pcb) -{ - /* implement timeout */ - httpc_state_t* req = (httpc_state_t*)arg; - LWIP_UNUSED_ARG(pcb); - if (req != NULL) { - if (req->timeout_ticks) { - req->timeout_ticks--; - } - if (!req->timeout_ticks) { - return httpc_close(req, HTTPC_RESULT_ERR_TIMEOUT, 0, ERR_OK); - } - } - return ERR_OK; -} - -/** http client tcp sent callback */ -static err_t -httpc_tcp_sent(void *arg, struct altcp_pcb *pcb, u16_t len) -{ - /* nothing to do here for now */ - LWIP_UNUSED_ARG(arg); - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(len); - return ERR_OK; -} - -/** http client tcp connected callback */ -static err_t -httpc_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err) -{ - err_t r; - httpc_state_t* req = (httpc_state_t*)arg; - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(err); - - /* send request; last char is zero termination */ - r = altcp_write(req->pcb, req->request->payload, req->request->len - 1, TCP_WRITE_FLAG_COPY); - if (r != ERR_OK) { - /* could not write the single small request -> fail, don't retry */ - return httpc_close(req, HTTPC_RESULT_ERR_MEM, 0, r); - } - /* everything written, we can free the request */ - pbuf_free(req->request); - req->request = NULL; - - altcp_output(req->pcb); - return ERR_OK; -} - -/** Start the http request when the server IP addr is known */ -static err_t -httpc_get_internal_addr(httpc_state_t* req, const ip_addr_t *ipaddr) -{ - err_t err; - LWIP_ASSERT("req != NULL", req != NULL); - - if (&req->remote_addr != ipaddr) { - /* fill in remote addr if called externally */ - req->remote_addr = *ipaddr; - } - - err = altcp_connect(req->pcb, &req->remote_addr, req->remote_port, httpc_tcp_connected); - if (err == ERR_OK) { - return ERR_OK; - } - LWIP_DEBUGF(HTTPC_DEBUG_WARN_STATE, ("tcp_connect failed: %d\n", (int)err)); - return err; -} - -#if LWIP_DNS -/** DNS callback - * If ipaddr is non-NULL, resolving succeeded and the request can be sent, otherwise it failed. - */ -static void -httpc_dns_found(const char* hostname, const ip_addr_t *ipaddr, void *arg) -{ - httpc_state_t* req = (httpc_state_t*)arg; - err_t err; - httpc_result_t result; - - LWIP_UNUSED_ARG(hostname); - - if (ipaddr != NULL) { - err = httpc_get_internal_addr(req, ipaddr); - if (err == ERR_OK) { - return; - } - result = HTTPC_RESULT_ERR_CONNECT; - } else { - LWIP_DEBUGF(HTTPC_DEBUG_WARN_STATE, ("httpc_dns_found: failed to resolve hostname: %s\n", - hostname)); - result = HTTPC_RESULT_ERR_HOSTNAME; - err = ERR_ARG; - } - httpc_close(req, result, 0, err); -} -#endif /* LWIP_DNS */ - -/** Start the http request after converting 'server_name' to ip address (DNS or address string) */ -static err_t -httpc_get_internal_dns(httpc_state_t* req, const char* server_name) -{ - err_t err; - LWIP_ASSERT("req != NULL", req != NULL); - -#if LWIP_DNS - err = dns_gethostbyname(server_name, &req->remote_addr, httpc_dns_found, req); -#else - err = ipaddr_aton(server_name, &req->remote_addr) ? ERR_OK : ERR_ARG; -#endif - - if (err == ERR_OK) { - /* cached or IP-string */ - err = httpc_get_internal_addr(req, &req->remote_addr); - } else if (err == ERR_INPROGRESS) { - return ERR_OK; - } - return err; -} - -static int -httpc_create_request_string(const httpc_connection_t *settings, const char* server_name, int server_port, const char* uri, - int use_host, char *buffer, size_t buffer_size) -{ - if (settings->use_proxy) { - LWIP_ASSERT("server_name != NULL", server_name != NULL); - if (server_port != HTTP_DEFAULT_PORT) { - return snprintf(buffer, buffer_size, HTTPC_REQ_11_PROXY_PORT_FORMAT(server_name, server_port, uri, server_name)); - } else { - return snprintf(buffer, buffer_size, HTTPC_REQ_11_PROXY_FORMAT(server_name, uri, server_name)); - } - } else if (use_host) { - LWIP_ASSERT("server_name != NULL", server_name != NULL); - return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT(uri, server_name)); - } else { - return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT(uri)); - } -} - -/** Initialize the connection struct */ -static err_t -httpc_init_connection_common(httpc_state_t **connection, const httpc_connection_t *settings, const char* server_name, - u16_t server_port, const char* uri, altcp_recv_fn recv_fn, void* callback_arg, int use_host) -{ - size_t alloc_len; - mem_size_t mem_alloc_len; - int req_len, req_len2; - httpc_state_t *req; -#if HTTPC_DEBUG_REQUEST - size_t server_name_len, uri_len; -#endif - - LWIP_ASSERT("uri != NULL", uri != NULL); - - /* get request len */ - req_len = httpc_create_request_string(settings, server_name, server_port, uri, use_host, NULL, 0); - if ((req_len < 0) || (req_len > 0xFFFF)) { - return ERR_VAL; - } - /* alloc state and request in one block */ - alloc_len = sizeof(httpc_state_t); -#if HTTPC_DEBUG_REQUEST - server_name_len = server_name ? strlen(server_name) : 0; - uri_len = strlen(uri); - alloc_len += server_name_len + 1 + uri_len + 1; -#endif - mem_alloc_len = (mem_size_t)alloc_len; - if ((mem_alloc_len < alloc_len) || (req_len + 1 > 0xFFFF)) { - return ERR_VAL; - } - - req = (httpc_state_t*)mem_malloc((mem_size_t)alloc_len); - if(req == NULL) { - return ERR_MEM; - } - memset(req, 0, sizeof(httpc_state_t)); - req->timeout_ticks = HTTPC_POLL_TIMEOUT; - req->request = pbuf_alloc(PBUF_RAW, (u16_t)(req_len + 1), PBUF_RAM); - if (req->request == NULL) { - httpc_free_state(req); - return ERR_MEM; - } - if (req->request->next != NULL) { - /* need a pbuf in one piece */ - httpc_free_state(req); - return ERR_MEM; - } - req->hdr_content_len = HTTPC_CONTENT_LEN_INVALID; -#if HTTPC_DEBUG_REQUEST - req->server_name = (char*)(req + 1); - if (server_name) { - memcpy(req->server_name, server_name, server_name_len + 1); - } - req->uri = req->server_name + server_name_len + 1; - memcpy(req->uri, uri, uri_len + 1); -#endif - req->pcb = altcp_new(settings->altcp_allocator); - if(req->pcb == NULL) { - httpc_free_state(req); - return ERR_MEM; - } - req->remote_port = settings->use_proxy ? settings->proxy_port : server_port; - altcp_arg(req->pcb, req); - altcp_recv(req->pcb, httpc_tcp_recv); - altcp_err(req->pcb, httpc_tcp_err); - altcp_poll(req->pcb, httpc_tcp_poll, HTTPC_POLL_INTERVAL); - altcp_sent(req->pcb, httpc_tcp_sent); - - /* set up request buffer */ - req_len2 = httpc_create_request_string(settings, server_name, server_port, uri, use_host, - (char *)req->request->payload, req_len + 1); - if (req_len2 != req_len) { - httpc_free_state(req); - return ERR_VAL; - } - - req->recv_fn = recv_fn; - req->conn_settings = settings; - req->callback_arg = callback_arg; - - *connection = req; - return ERR_OK; -} - -/** - * Initialize the connection struct - */ -static err_t -httpc_init_connection(httpc_state_t **connection, const httpc_connection_t *settings, const char* server_name, - u16_t server_port, const char* uri, altcp_recv_fn recv_fn, void* callback_arg) -{ - return httpc_init_connection_common(connection, settings, server_name, server_port, uri, recv_fn, callback_arg, 1); -} - - -/** - * Initialize the connection struct (from IP address) - */ -static err_t -httpc_init_connection_addr(httpc_state_t **connection, const httpc_connection_t *settings, - const ip_addr_t* server_addr, u16_t server_port, const char* uri, - altcp_recv_fn recv_fn, void* callback_arg) -{ - char *server_addr_str = ipaddr_ntoa(server_addr); - if (server_addr_str == NULL) { - return ERR_VAL; - } - return httpc_init_connection_common(connection, settings, server_addr_str, server_port, uri, - recv_fn, callback_arg, 1); -} - -/** - * @ingroup httpc - * HTTP client API: get a file by passing server IP address - * - * @param server_addr IP address of the server to connect - * @param port tcp port of the server - * @param uri uri to get from the server, remember leading "/"! - * @param settings connection settings (callbacks, proxy, etc.) - * @param recv_fn the http body (not the headers) are passed to this callback - * @param callback_arg argument passed to all the callbacks - * @param connection retreives the connection handle (to match in callbacks) - * @return ERR_OK if starting the request succeeds (callback_fn will be called later) - * or an error code - */ -err_t -httpc_get_file(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, - altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection) -{ - err_t err; - httpc_state_t* req; - - LWIP_ERROR("invalid parameters", (server_addr != NULL) && (uri != NULL) && (recv_fn != NULL), return ERR_ARG;); - - err = httpc_init_connection_addr(&req, settings, server_addr, port, - uri, recv_fn, callback_arg); - if (err != ERR_OK) { - return err; - } - - if (settings->use_proxy) { - err = httpc_get_internal_addr(req, &settings->proxy_addr); - } else { - err = httpc_get_internal_addr(req, server_addr); - } - if(err != ERR_OK) { - httpc_free_state(req); - return err; - } - - if (connection != NULL) { - *connection = req; - } - return ERR_OK; -} - -/** - * @ingroup httpc - * HTTP client API: get a file by passing server name as string (DNS name or IP address string) - * - * @param server_name server name as string (DNS name or IP address string) - * @param port tcp port of the server - * @param uri uri to get from the server, remember leading "/"! - * @param settings connection settings (callbacks, proxy, etc.) - * @param recv_fn the http body (not the headers) are passed to this callback - * @param callback_arg argument passed to all the callbacks - * @param connection retreives the connection handle (to match in callbacks) - * @return ERR_OK if starting the request succeeds (callback_fn will be called later) - * or an error code - */ -err_t -httpc_get_file_dns(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, - altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection) -{ - err_t err; - httpc_state_t* req; - - LWIP_ERROR("invalid parameters", (server_name != NULL) && (uri != NULL) && (recv_fn != NULL), return ERR_ARG;); - - err = httpc_init_connection(&req, settings, server_name, port, uri, recv_fn, callback_arg); - if (err != ERR_OK) { - return err; - } - - if (settings->use_proxy) { - err = httpc_get_internal_addr(req, &settings->proxy_addr); - } else { - err = httpc_get_internal_dns(req, server_name); - } - if(err != ERR_OK) { - httpc_free_state(req); - return err; - } - - if (connection != NULL) { - *connection = req; - } - return ERR_OK; -} - -#if LWIP_HTTPC_HAVE_FILE_IO -/* Implementation to disk via fopen/fwrite/fclose follows */ - -typedef struct _httpc_filestate -{ - const char* local_file_name; - FILE *file; - httpc_connection_t settings; - const httpc_connection_t *client_settings; - void *callback_arg; -} httpc_filestate_t; - -static void httpc_fs_result(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, - u32_t srv_res, err_t err); - -/** Initalize http client state for download to file system */ -static err_t -httpc_fs_init(httpc_filestate_t **filestate_out, const char* local_file_name, - const httpc_connection_t *settings, void* callback_arg) -{ - httpc_filestate_t *filestate; - size_t file_len, alloc_len; - FILE *f; - - file_len = strlen(local_file_name); - alloc_len = sizeof(httpc_filestate_t) + file_len + 1; - - filestate = (httpc_filestate_t *)mem_malloc((mem_size_t)alloc_len); - if (filestate == NULL) { - return ERR_MEM; - } - memset(filestate, 0, sizeof(httpc_filestate_t)); - filestate->local_file_name = (const char *)(filestate + 1); - memcpy((char *)(filestate + 1), local_file_name, file_len + 1); - filestate->file = NULL; - filestate->client_settings = settings; - filestate->callback_arg = callback_arg; - /* copy client settings but override result callback */ - memcpy(&filestate->settings, settings, sizeof(httpc_connection_t)); - filestate->settings.result_fn = httpc_fs_result; - - f = fopen(local_file_name, "wb"); - if(f == NULL) { - /* could not open file */ - mem_free(filestate); - return ERR_VAL; - } - filestate->file = f; - *filestate_out = filestate; - return ERR_OK; -} - -/** Free http client state for download to file system */ -static void -httpc_fs_free(httpc_filestate_t *filestate) -{ - if (filestate != NULL) { - if (filestate->file != NULL) { - fclose(filestate->file); - filestate->file = NULL; - } - mem_free(filestate); - } -} - -/** Connection closed (success or error) */ -static void -httpc_fs_result(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, - u32_t srv_res, err_t err) -{ - httpc_filestate_t *filestate = (httpc_filestate_t *)arg; - if (filestate != NULL) { - if (filestate->client_settings->result_fn != NULL) { - filestate->client_settings->result_fn(filestate->callback_arg, httpc_result, rx_content_len, - srv_res, err); - } - httpc_fs_free(filestate); - } -} - -/** tcp recv callback */ -static err_t -httpc_fs_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) -{ - httpc_filestate_t *filestate = (httpc_filestate_t*)arg; - struct pbuf* q; - LWIP_UNUSED_ARG(err); - - LWIP_ASSERT("p != NULL", p != NULL); - - for (q = p; q != NULL; q = q->next) { - fwrite(q->payload, 1, q->len, filestate->file); - } - altcp_recved(pcb, p->tot_len); - pbuf_free(p); - return ERR_OK; -} - -/** - * @ingroup httpc - * HTTP client API: get a file to disk by passing server IP address - * - * @param server_addr IP address of the server to connect - * @param port tcp port of the server - * @param uri uri to get from the server, remember leading "/"! - * @param settings connection settings (callbacks, proxy, etc.) - * @param callback_arg argument passed to all the callbacks - * @param connection retreives the connection handle (to match in callbacks) - * @return ERR_OK if starting the request succeeds (callback_fn will be called later) - * or an error code - */ -err_t -httpc_get_file_to_disk(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, - void* callback_arg, const char* local_file_name, httpc_state_t **connection) -{ - err_t err; - httpc_state_t* req; - httpc_filestate_t *filestate; - - LWIP_ERROR("invalid parameters", (server_addr != NULL) && (uri != NULL) && (local_file_name != NULL), return ERR_ARG;); - - err = httpc_fs_init(&filestate, local_file_name, settings, callback_arg); - if (err != ERR_OK) { - return err; - } - - err = httpc_init_connection_addr(&req, &filestate->settings, server_addr, port, - uri, httpc_fs_tcp_recv, filestate); - if (err != ERR_OK) { - httpc_fs_free(filestate); - return err; - } - - if (settings->use_proxy) { - err = httpc_get_internal_addr(req, &settings->proxy_addr); - } else { - err = httpc_get_internal_addr(req, server_addr); - } - if(err != ERR_OK) { - httpc_fs_free(filestate); - httpc_free_state(req); - return err; - } - - if (connection != NULL) { - *connection = req; - } - return ERR_OK; -} - -/** - * @ingroup httpc - * HTTP client API: get a file to disk by passing server name as string (DNS name or IP address string) - * - * @param server_name server name as string (DNS name or IP address string) - * @param port tcp port of the server - * @param uri uri to get from the server, remember leading "/"! - * @param settings connection settings (callbacks, proxy, etc.) - * @param callback_arg argument passed to all the callbacks - * @param connection retreives the connection handle (to match in callbacks) - * @return ERR_OK if starting the request succeeds (callback_fn will be called later) - * or an error code - */ -err_t -httpc_get_file_dns_to_disk(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, - void* callback_arg, const char* local_file_name, httpc_state_t **connection) -{ - err_t err; - httpc_state_t* req; - httpc_filestate_t *filestate; - - LWIP_ERROR("invalid parameters", (server_name != NULL) && (uri != NULL) && (local_file_name != NULL), return ERR_ARG;); - - err = httpc_fs_init(&filestate, local_file_name, settings, callback_arg); - if (err != ERR_OK) { - return err; - } - - err = httpc_init_connection(&req, &filestate->settings, server_name, port, - uri, httpc_fs_tcp_recv, filestate); - if (err != ERR_OK) { - httpc_fs_free(filestate); - return err; - } - - if (settings->use_proxy) { - err = httpc_get_internal_addr(req, &settings->proxy_addr); - } else { - err = httpc_get_internal_dns(req, server_name); - } - if(err != ERR_OK) { - httpc_fs_free(filestate); - httpc_free_state(req); - return err; - } - - if (connection != NULL) { - *connection = req; - } - return ERR_OK; -} -#endif /* LWIP_HTTPC_HAVE_FILE_IO */ - -#endif /* LWIP_TCP && LWIP_CALLBACK_API */ +/** + * @file + * HTTP client + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + */ + +/** + * @defgroup httpc HTTP client + * @ingroup apps + * @todo: + * - persistent connections + * - select outgoing http version + * - optionally follow redirect + * - check request uri for invalid characters? (e.g. encode spaces) + * - IPv6 support + */ + +#include "lwip/apps/http_client.h" + +#include "lwip/altcp_tcp.h" +#include "lwip/dns.h" +#include "lwip/debug.h" +#include "lwip/mem.h" +#include "lwip/altcp_tls.h" +#include "lwip/init.h" + +#include +#include +#include + +#if LWIP_TCP && LWIP_CALLBACK_API + +/** + * HTTPC_DEBUG: Enable debugging for HTTP client. + */ +#ifndef HTTPC_DEBUG +#define HTTPC_DEBUG LWIP_DBG_OFF +#endif + +/** Set this to 1 to keep server name and uri in request state */ +#ifndef HTTPC_DEBUG_REQUEST +#define HTTPC_DEBUG_REQUEST 0 +#endif + +/** This string is passed in the HTTP header as "User-Agent: " */ +#ifndef HTTPC_CLIENT_AGENT +#define HTTPC_CLIENT_AGENT "lwIP/" LWIP_VERSION_STRING " (http://savannah.nongnu.org/projects/lwip)" +#endif + +/* the various debug levels for this file */ +#define HTTPC_DEBUG_TRACE (HTTPC_DEBUG | LWIP_DBG_TRACE) +#define HTTPC_DEBUG_STATE (HTTPC_DEBUG | LWIP_DBG_STATE) +#define HTTPC_DEBUG_WARN (HTTPC_DEBUG | LWIP_DBG_LEVEL_WARNING) +#define HTTPC_DEBUG_WARN_STATE (HTTPC_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) +#define HTTPC_DEBUG_SERIOUS (HTTPC_DEBUG | LWIP_DBG_LEVEL_SERIOUS) + +#define HTTPC_POLL_INTERVAL 1 +#define HTTPC_POLL_TIMEOUT 30 /* 15 seconds */ + +#define HTTPC_CONTENT_LEN_INVALID 0xFFFFFFFF + +/* GET request basic */ +#define HTTPC_REQ_11 "GET %s HTTP/1.1\r\n" /* URI */\ + "User-Agent: %s\r\n" /* User-Agent */ \ + "Accept: */*\r\n" \ + "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ + "\r\n" +#define HTTPC_REQ_11_FORMAT(uri) HTTPC_REQ_11, uri, HTTPC_CLIENT_AGENT + +/* GET request with host */ +#define HTTPC_REQ_11_HOST "GET %s HTTP/1.1\r\n" /* URI */\ + "User-Agent: %s\r\n" /* User-Agent */ \ + "Accept: */*\r\n" \ + "Host: %s\r\n" /* server name */ \ + "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ + "\r\n" +#define HTTPC_REQ_11_HOST_FORMAT(uri, srv_name) HTTPC_REQ_11_HOST, uri, HTTPC_CLIENT_AGENT, srv_name + +/* GET request with proxy */ +#define HTTPC_REQ_11_PROXY "GET http://%s%s HTTP/1.1\r\n" /* HOST, URI */\ + "User-Agent: %s\r\n" /* User-Agent */ \ + "Accept: */*\r\n" \ + "Host: %s\r\n" /* server name */ \ + "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ + "\r\n" +#define HTTPC_REQ_11_PROXY_FORMAT(host, uri, srv_name) HTTPC_REQ_11_PROXY, host, uri, HTTPC_CLIENT_AGENT, srv_name + +/* GET request with proxy (non-default server port) */ +#define HTTPC_REQ_11_PROXY_PORT "GET http://%s:%d%s HTTP/1.1\r\n" /* HOST, host-port, URI */\ + "User-Agent: %s\r\n" /* User-Agent */ \ + "Accept: */*\r\n" \ + "Host: %s\r\n" /* server name */ \ + "Connection: Close\r\n" /* we don't support persistent connections, yet */ \ + "\r\n" +#define HTTPC_REQ_11_PROXY_PORT_FORMAT(host, host_port, uri, srv_name) HTTPC_REQ_11_PROXY_PORT, host, host_port, uri, HTTPC_CLIENT_AGENT, srv_name + +typedef enum ehttpc_parse_state { + HTTPC_PARSE_WAIT_FIRST_LINE = 0, + HTTPC_PARSE_WAIT_HEADERS, + HTTPC_PARSE_RX_DATA +} httpc_parse_state_t; + +typedef struct _httpc_state +{ + struct altcp_pcb* pcb; + ip_addr_t remote_addr; + u16_t remote_port; + int timeout_ticks; + struct pbuf *request; + struct pbuf *rx_hdrs; + u16_t rx_http_version; + u16_t rx_status; + altcp_recv_fn recv_fn; + const httpc_connection_t *conn_settings; + void* callback_arg; + u32_t rx_content_len; + u32_t hdr_content_len; + httpc_parse_state_t parse_state; +#if HTTPC_DEBUG_REQUEST + char* server_name; + char* uri; +#endif +} httpc_state_t; + +/** Free http client state and deallocate all resources within */ +static err_t +httpc_free_state(httpc_state_t* req) +{ + struct altcp_pcb* tpcb; + + if (req->request != NULL) { + pbuf_free(req->request); + req->request = NULL; + } + if (req->rx_hdrs != NULL) { + pbuf_free(req->rx_hdrs); + req->rx_hdrs = NULL; + } + + tpcb = req->pcb; + mem_free(req); + req = NULL; + + if (tpcb != NULL) { + err_t r; + altcp_arg(tpcb, NULL); + altcp_recv(tpcb, NULL); + altcp_err(tpcb, NULL); + altcp_poll(tpcb, NULL, 0); + altcp_sent(tpcb, NULL); + r = altcp_close(tpcb); + if (r != ERR_OK) { + altcp_abort(tpcb); + return ERR_ABRT; + } + } + return ERR_OK; +} + +/** Close the connection: call finished callback and free the state */ +static err_t +httpc_close(httpc_state_t* req, httpc_result_t result, u32_t server_response, err_t err) +{ + if (req != NULL) { + if (req->conn_settings != NULL) { + if (req->conn_settings->result_fn != NULL) { + req->conn_settings->result_fn(req->callback_arg, result, req->rx_content_len, server_response, err); + } + } + return httpc_free_state(req); + } + return ERR_OK; +} + +/** Parse http header response line 1 */ +static err_t +http_parse_response_status(struct pbuf *p, u16_t *http_version, u16_t *http_status, u16_t *http_status_str_offset) +{ + u16_t end1 = pbuf_memfind(p, "\r\n", 2, 0); + if (end1 != 0xFFFF) { + /* get parts of first line */ + u16_t space1, space2; + space1 = pbuf_memfind(p, " ", 1, 0); + if (space1 != 0xFFFF) { + if ((pbuf_memcmp(p, 0, "HTTP/", 5) == 0) && (pbuf_get_at(p, 6) == '.')) { + char status_num[10]; + size_t status_num_len; + /* parse http version */ + u16_t version = pbuf_get_at(p, 5) - '0'; + version <<= 8; + version |= pbuf_get_at(p, 7) - '0'; + *http_version = version; + + /* parse http status number */ + space2 = pbuf_memfind(p, " ", 1, space1 + 1); + if (space2 != 0xFFFF) { + *http_status_str_offset = space2 + 1; + status_num_len = space2 - space1 - 1; + } else { + status_num_len = end1 - space1 - 1; + } + memset(status_num, 0, sizeof(status_num)); + if (pbuf_copy_partial(p, status_num, (u16_t)status_num_len, space1 + 1) == status_num_len) { + int status = atoi(status_num); + if ((status > 0) && (status <= 0xFFFF)) { + *http_status = (u16_t)status; + return ERR_OK; + } + } + } + } + } + return ERR_VAL; +} + +/** Wait for all headers to be received, return its length and content-length (if available) */ +static err_t +http_wait_headers(struct pbuf *p, u32_t *content_length, u16_t *total_header_len) +{ + u16_t end1 = pbuf_memfind(p, "\r\n\r\n", 4, 0); + if (end1 < (0xFFFF - 2)) { + /* all headers received */ + /* check if we have a content length (@todo: case insensitive?) */ + u16_t content_len_hdr; + *content_length = HTTPC_CONTENT_LEN_INVALID; + *total_header_len = end1 + 4; + + content_len_hdr = pbuf_memfind(p, "Content-Length: ", 16, 0); + if (content_len_hdr != 0xFFFF) { + u16_t content_len_line_end = pbuf_memfind(p, "\r\n", 2, content_len_hdr); + if (content_len_line_end != 0xFFFF) { + char content_len_num[16]; + u16_t content_len_num_len = (u16_t)(content_len_line_end - content_len_hdr - 16); + memset(content_len_num, 0, sizeof(content_len_num)); + if (pbuf_copy_partial(p, content_len_num, content_len_num_len, content_len_hdr + 16) == content_len_num_len) { + int len = atoi(content_len_num); + if ((len >= 0) && ((u32_t)len < HTTPC_CONTENT_LEN_INVALID)) { + *content_length = (u32_t)len; + } + } + } + } + return ERR_OK; + } + return ERR_VAL; +} + +/** http client tcp recv callback */ +static err_t +httpc_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t r) +{ + httpc_state_t* req = (httpc_state_t*)arg; + LWIP_UNUSED_ARG(r); + + if (p == NULL) { + httpc_result_t result; + if (req->parse_state != HTTPC_PARSE_RX_DATA) { + /* did not get RX data yet */ + result = HTTPC_RESULT_ERR_CLOSED; + } else if ((req->hdr_content_len != HTTPC_CONTENT_LEN_INVALID) && + (req->hdr_content_len != req->rx_content_len)) { + /* header has been received with content length but not all data received */ + result = HTTPC_RESULT_ERR_CONTENT_LEN; + } else { + /* receiving data and either all data received or no content length header */ + result = HTTPC_RESULT_OK; + } + return httpc_close(req, result, req->rx_status, ERR_OK); + } + if (req->parse_state != HTTPC_PARSE_RX_DATA) { + if (req->rx_hdrs == NULL) { + req->rx_hdrs = p; + } else { + pbuf_cat(req->rx_hdrs, p); + } + if (req->parse_state == HTTPC_PARSE_WAIT_FIRST_LINE) { + u16_t status_str_off; + err_t err = http_parse_response_status(req->rx_hdrs, &req->rx_http_version, &req->rx_status, &status_str_off); + if (err == ERR_OK) { + /* don't care status string */ + req->parse_state = HTTPC_PARSE_WAIT_HEADERS; + } + } + if (req->parse_state == HTTPC_PARSE_WAIT_HEADERS) { + u16_t total_header_len; + err_t err = http_wait_headers(req->rx_hdrs, &req->hdr_content_len, &total_header_len); + if (err == ERR_OK) { + struct pbuf *q; + /* full header received, send window update for header bytes and call into client callback */ + altcp_recved(pcb, total_header_len); + if (req->conn_settings) { + if (req->conn_settings->headers_done_fn) { + err = req->conn_settings->headers_done_fn(req, req->callback_arg, req->rx_hdrs, total_header_len, req->hdr_content_len); + if (err != ERR_OK) { + return httpc_close(req, HTTPC_RESULT_LOCAL_ABORT, req->rx_status, err); + } + } + } + /* hide header bytes in pbuf */ + q = pbuf_free_header(req->rx_hdrs, total_header_len); + p = q; + req->rx_hdrs = NULL; + /* go on with data */ + req->parse_state = HTTPC_PARSE_RX_DATA; + } + } + } + if ((p != NULL) && (req->parse_state == HTTPC_PARSE_RX_DATA)) { + req->rx_content_len += p->tot_len; + if (req->recv_fn != NULL) { + /* directly return here: the connection migth already be aborted from the callback! */ + return req->recv_fn(req->callback_arg, pcb, p, r); + } else { + altcp_recved(pcb, p->tot_len); + pbuf_free(p); + } + } + return ERR_OK; +} + +/** http client tcp err callback */ +static void +httpc_tcp_err(void *arg, err_t err) +{ + httpc_state_t* req = (httpc_state_t*)arg; + if (req != NULL) { + /* pcb has already been deallocated */ + req->pcb = NULL; + httpc_close(req, HTTPC_RESULT_ERR_CLOSED, 0, err); + } +} + +/** http client tcp poll callback */ +static err_t +httpc_tcp_poll(void *arg, struct altcp_pcb *pcb) +{ + /* implement timeout */ + httpc_state_t* req = (httpc_state_t*)arg; + LWIP_UNUSED_ARG(pcb); + if (req != NULL) { + if (req->timeout_ticks) { + req->timeout_ticks--; + } + if (!req->timeout_ticks) { + return httpc_close(req, HTTPC_RESULT_ERR_TIMEOUT, 0, ERR_OK); + } + } + return ERR_OK; +} + +/** http client tcp sent callback */ +static err_t +httpc_tcp_sent(void *arg, struct altcp_pcb *pcb, u16_t len) +{ + /* nothing to do here for now */ + LWIP_UNUSED_ARG(arg); + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(len); + return ERR_OK; +} + +/** http client tcp connected callback */ +static err_t +httpc_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err) +{ + err_t r; + httpc_state_t* req = (httpc_state_t*)arg; + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(err); + + /* send request; last char is zero termination */ + r = altcp_write(req->pcb, req->request->payload, req->request->len - 1, TCP_WRITE_FLAG_COPY); + if (r != ERR_OK) { + /* could not write the single small request -> fail, don't retry */ + return httpc_close(req, HTTPC_RESULT_ERR_MEM, 0, r); + } + /* everything written, we can free the request */ + pbuf_free(req->request); + req->request = NULL; + + altcp_output(req->pcb); + return ERR_OK; +} + +/** Start the http request when the server IP addr is known */ +static err_t +httpc_get_internal_addr(httpc_state_t* req, const ip_addr_t *ipaddr) +{ + err_t err; + LWIP_ASSERT("req != NULL", req != NULL); + + if (&req->remote_addr != ipaddr) { + /* fill in remote addr if called externally */ + req->remote_addr = *ipaddr; + } + + err = altcp_connect(req->pcb, &req->remote_addr, req->remote_port, httpc_tcp_connected); + if (err == ERR_OK) { + return ERR_OK; + } + LWIP_DEBUGF(HTTPC_DEBUG_WARN_STATE, ("tcp_connect failed: %d\n", (int)err)); + return err; +} + +#if LWIP_DNS +/** DNS callback + * If ipaddr is non-NULL, resolving succeeded and the request can be sent, otherwise it failed. + */ +static void +httpc_dns_found(const char* hostname, const ip_addr_t *ipaddr, void *arg) +{ + httpc_state_t* req = (httpc_state_t*)arg; + err_t err; + httpc_result_t result; + + LWIP_UNUSED_ARG(hostname); + + if (ipaddr != NULL) { + err = httpc_get_internal_addr(req, ipaddr); + if (err == ERR_OK) { + return; + } + result = HTTPC_RESULT_ERR_CONNECT; + } else { + LWIP_DEBUGF(HTTPC_DEBUG_WARN_STATE, ("httpc_dns_found: failed to resolve hostname: %s\n", + hostname)); + result = HTTPC_RESULT_ERR_HOSTNAME; + err = ERR_ARG; + } + httpc_close(req, result, 0, err); +} +#endif /* LWIP_DNS */ + +/** Start the http request after converting 'server_name' to ip address (DNS or address string) */ +static err_t +httpc_get_internal_dns(httpc_state_t* req, const char* server_name) +{ + err_t err; + LWIP_ASSERT("req != NULL", req != NULL); + +#if LWIP_DNS + err = dns_gethostbyname(server_name, &req->remote_addr, httpc_dns_found, req); +#else + err = ipaddr_aton(server_name, &req->remote_addr) ? ERR_OK : ERR_ARG; +#endif + + if (err == ERR_OK) { + /* cached or IP-string */ + err = httpc_get_internal_addr(req, &req->remote_addr); + } else if (err == ERR_INPROGRESS) { + return ERR_OK; + } + return err; +} + +static int +httpc_create_request_string(const httpc_connection_t *settings, const char* server_name, int server_port, const char* uri, + int use_host, char *buffer, size_t buffer_size) +{ + if (settings->use_proxy) { + LWIP_ASSERT("server_name != NULL", server_name != NULL); + if (server_port != HTTP_DEFAULT_PORT) { + return snprintf(buffer, buffer_size, HTTPC_REQ_11_PROXY_PORT_FORMAT(server_name, server_port, uri, server_name)); + } else { + return snprintf(buffer, buffer_size, HTTPC_REQ_11_PROXY_FORMAT(server_name, uri, server_name)); + } + } else if (use_host) { + LWIP_ASSERT("server_name != NULL", server_name != NULL); + return snprintf(buffer, buffer_size, HTTPC_REQ_11_HOST_FORMAT(uri, server_name)); + } else { + return snprintf(buffer, buffer_size, HTTPC_REQ_11_FORMAT(uri)); + } +} + +/** Initialize the connection struct */ +static err_t +httpc_init_connection_common(httpc_state_t **connection, const httpc_connection_t *settings, const char* server_name, + u16_t server_port, const char* uri, altcp_recv_fn recv_fn, void* callback_arg, int use_host) +{ + size_t alloc_len; + mem_size_t mem_alloc_len; + int req_len, req_len2; + httpc_state_t *req; +#if HTTPC_DEBUG_REQUEST + size_t server_name_len, uri_len; +#endif + + LWIP_ASSERT("uri != NULL", uri != NULL); + + /* get request len */ + req_len = httpc_create_request_string(settings, server_name, server_port, uri, use_host, NULL, 0); + if ((req_len < 0) || (req_len > 0xFFFF)) { + return ERR_VAL; + } + /* alloc state and request in one block */ + alloc_len = sizeof(httpc_state_t); +#if HTTPC_DEBUG_REQUEST + server_name_len = server_name ? strlen(server_name) : 0; + uri_len = strlen(uri); + alloc_len += server_name_len + 1 + uri_len + 1; +#endif + mem_alloc_len = (mem_size_t)alloc_len; + if ((mem_alloc_len < alloc_len) || (req_len + 1 > 0xFFFF)) { + return ERR_VAL; + } + + req = (httpc_state_t*)mem_malloc((mem_size_t)alloc_len); + if(req == NULL) { + return ERR_MEM; + } + memset(req, 0, sizeof(httpc_state_t)); + req->timeout_ticks = HTTPC_POLL_TIMEOUT; + req->request = pbuf_alloc(PBUF_RAW, (u16_t)(req_len + 1), PBUF_RAM); + if (req->request == NULL) { + httpc_free_state(req); + return ERR_MEM; + } + if (req->request->next != NULL) { + /* need a pbuf in one piece */ + httpc_free_state(req); + return ERR_MEM; + } + req->hdr_content_len = HTTPC_CONTENT_LEN_INVALID; +#if HTTPC_DEBUG_REQUEST + req->server_name = (char*)(req + 1); + if (server_name) { + memcpy(req->server_name, server_name, server_name_len + 1); + } + req->uri = req->server_name + server_name_len + 1; + memcpy(req->uri, uri, uri_len + 1); +#endif + req->pcb = altcp_new(settings->altcp_allocator); + if(req->pcb == NULL) { + httpc_free_state(req); + return ERR_MEM; + } + req->remote_port = settings->use_proxy ? settings->proxy_port : server_port; + altcp_arg(req->pcb, req); + altcp_recv(req->pcb, httpc_tcp_recv); + altcp_err(req->pcb, httpc_tcp_err); + altcp_poll(req->pcb, httpc_tcp_poll, HTTPC_POLL_INTERVAL); + altcp_sent(req->pcb, httpc_tcp_sent); + + /* set up request buffer */ + req_len2 = httpc_create_request_string(settings, server_name, server_port, uri, use_host, + (char *)req->request->payload, req_len + 1); + if (req_len2 != req_len) { + httpc_free_state(req); + return ERR_VAL; + } + + req->recv_fn = recv_fn; + req->conn_settings = settings; + req->callback_arg = callback_arg; + + *connection = req; + return ERR_OK; +} + +/** + * Initialize the connection struct + */ +static err_t +httpc_init_connection(httpc_state_t **connection, const httpc_connection_t *settings, const char* server_name, + u16_t server_port, const char* uri, altcp_recv_fn recv_fn, void* callback_arg) +{ + return httpc_init_connection_common(connection, settings, server_name, server_port, uri, recv_fn, callback_arg, 1); +} + + +/** + * Initialize the connection struct (from IP address) + */ +static err_t +httpc_init_connection_addr(httpc_state_t **connection, const httpc_connection_t *settings, + const ip_addr_t* server_addr, u16_t server_port, const char* uri, + altcp_recv_fn recv_fn, void* callback_arg) +{ + char *server_addr_str = ipaddr_ntoa(server_addr); + if (server_addr_str == NULL) { + return ERR_VAL; + } + return httpc_init_connection_common(connection, settings, server_addr_str, server_port, uri, + recv_fn, callback_arg, 1); +} + +/** + * @ingroup httpc + * HTTP client API: get a file by passing server IP address + * + * @param server_addr IP address of the server to connect + * @param port tcp port of the server + * @param uri uri to get from the server, remember leading "/"! + * @param settings connection settings (callbacks, proxy, etc.) + * @param recv_fn the http body (not the headers) are passed to this callback + * @param callback_arg argument passed to all the callbacks + * @param connection retreives the connection handle (to match in callbacks) + * @return ERR_OK if starting the request succeeds (callback_fn will be called later) + * or an error code + */ +err_t +httpc_get_file(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, + altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection) +{ + err_t err; + httpc_state_t* req; + + LWIP_ERROR("invalid parameters", (server_addr != NULL) && (uri != NULL) && (recv_fn != NULL), return ERR_ARG;); + + err = httpc_init_connection_addr(&req, settings, server_addr, port, + uri, recv_fn, callback_arg); + if (err != ERR_OK) { + return err; + } + + if (settings->use_proxy) { + err = httpc_get_internal_addr(req, &settings->proxy_addr); + } else { + err = httpc_get_internal_addr(req, server_addr); + } + if(err != ERR_OK) { + httpc_free_state(req); + return err; + } + + if (connection != NULL) { + *connection = req; + } + return ERR_OK; +} + +/** + * @ingroup httpc + * HTTP client API: get a file by passing server name as string (DNS name or IP address string) + * + * @param server_name server name as string (DNS name or IP address string) + * @param port tcp port of the server + * @param uri uri to get from the server, remember leading "/"! + * @param settings connection settings (callbacks, proxy, etc.) + * @param recv_fn the http body (not the headers) are passed to this callback + * @param callback_arg argument passed to all the callbacks + * @param connection retreives the connection handle (to match in callbacks) + * @return ERR_OK if starting the request succeeds (callback_fn will be called later) + * or an error code + */ +err_t +httpc_get_file_dns(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, + altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection) +{ + err_t err; + httpc_state_t* req; + + LWIP_ERROR("invalid parameters", (server_name != NULL) && (uri != NULL) && (recv_fn != NULL), return ERR_ARG;); + + err = httpc_init_connection(&req, settings, server_name, port, uri, recv_fn, callback_arg); + if (err != ERR_OK) { + return err; + } + + if (settings->use_proxy) { + err = httpc_get_internal_addr(req, &settings->proxy_addr); + } else { + err = httpc_get_internal_dns(req, server_name); + } + if(err != ERR_OK) { + httpc_free_state(req); + return err; + } + + if (connection != NULL) { + *connection = req; + } + return ERR_OK; +} + +#if LWIP_HTTPC_HAVE_FILE_IO +/* Implementation to disk via fopen/fwrite/fclose follows */ + +typedef struct _httpc_filestate +{ + const char* local_file_name; + FILE *file; + httpc_connection_t settings; + const httpc_connection_t *client_settings; + void *callback_arg; +} httpc_filestate_t; + +static void httpc_fs_result(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, + u32_t srv_res, err_t err); + +/** Initalize http client state for download to file system */ +static err_t +httpc_fs_init(httpc_filestate_t **filestate_out, const char* local_file_name, + const httpc_connection_t *settings, void* callback_arg) +{ + httpc_filestate_t *filestate; + size_t file_len, alloc_len; + FILE *f; + + file_len = strlen(local_file_name); + alloc_len = sizeof(httpc_filestate_t) + file_len + 1; + + filestate = (httpc_filestate_t *)mem_malloc((mem_size_t)alloc_len); + if (filestate == NULL) { + return ERR_MEM; + } + memset(filestate, 0, sizeof(httpc_filestate_t)); + filestate->local_file_name = (const char *)(filestate + 1); + memcpy((char *)(filestate + 1), local_file_name, file_len + 1); + filestate->file = NULL; + filestate->client_settings = settings; + filestate->callback_arg = callback_arg; + /* copy client settings but override result callback */ + memcpy(&filestate->settings, settings, sizeof(httpc_connection_t)); + filestate->settings.result_fn = httpc_fs_result; + + f = fopen(local_file_name, "wb"); + if(f == NULL) { + /* could not open file */ + mem_free(filestate); + return ERR_VAL; + } + filestate->file = f; + *filestate_out = filestate; + return ERR_OK; +} + +/** Free http client state for download to file system */ +static void +httpc_fs_free(httpc_filestate_t *filestate) +{ + if (filestate != NULL) { + if (filestate->file != NULL) { + fclose(filestate->file); + filestate->file = NULL; + } + mem_free(filestate); + } +} + +/** Connection closed (success or error) */ +static void +httpc_fs_result(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, + u32_t srv_res, err_t err) +{ + httpc_filestate_t *filestate = (httpc_filestate_t *)arg; + if (filestate != NULL) { + if (filestate->client_settings->result_fn != NULL) { + filestate->client_settings->result_fn(filestate->callback_arg, httpc_result, rx_content_len, + srv_res, err); + } + httpc_fs_free(filestate); + } +} + +/** tcp recv callback */ +static err_t +httpc_fs_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) +{ + httpc_filestate_t *filestate = (httpc_filestate_t*)arg; + struct pbuf* q; + LWIP_UNUSED_ARG(err); + + LWIP_ASSERT("p != NULL", p != NULL); + + for (q = p; q != NULL; q = q->next) { + fwrite(q->payload, 1, q->len, filestate->file); + } + altcp_recved(pcb, p->tot_len); + pbuf_free(p); + return ERR_OK; +} + +/** + * @ingroup httpc + * HTTP client API: get a file to disk by passing server IP address + * + * @param server_addr IP address of the server to connect + * @param port tcp port of the server + * @param uri uri to get from the server, remember leading "/"! + * @param settings connection settings (callbacks, proxy, etc.) + * @param callback_arg argument passed to all the callbacks + * @param connection retreives the connection handle (to match in callbacks) + * @return ERR_OK if starting the request succeeds (callback_fn will be called later) + * or an error code + */ +err_t +httpc_get_file_to_disk(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, + void* callback_arg, const char* local_file_name, httpc_state_t **connection) +{ + err_t err; + httpc_state_t* req; + httpc_filestate_t *filestate; + + LWIP_ERROR("invalid parameters", (server_addr != NULL) && (uri != NULL) && (local_file_name != NULL), return ERR_ARG;); + + err = httpc_fs_init(&filestate, local_file_name, settings, callback_arg); + if (err != ERR_OK) { + return err; + } + + err = httpc_init_connection_addr(&req, &filestate->settings, server_addr, port, + uri, httpc_fs_tcp_recv, filestate); + if (err != ERR_OK) { + httpc_fs_free(filestate); + return err; + } + + if (settings->use_proxy) { + err = httpc_get_internal_addr(req, &settings->proxy_addr); + } else { + err = httpc_get_internal_addr(req, server_addr); + } + if(err != ERR_OK) { + httpc_fs_free(filestate); + httpc_free_state(req); + return err; + } + + if (connection != NULL) { + *connection = req; + } + return ERR_OK; +} + +/** + * @ingroup httpc + * HTTP client API: get a file to disk by passing server name as string (DNS name or IP address string) + * + * @param server_name server name as string (DNS name or IP address string) + * @param port tcp port of the server + * @param uri uri to get from the server, remember leading "/"! + * @param settings connection settings (callbacks, proxy, etc.) + * @param callback_arg argument passed to all the callbacks + * @param connection retreives the connection handle (to match in callbacks) + * @return ERR_OK if starting the request succeeds (callback_fn will be called later) + * or an error code + */ +err_t +httpc_get_file_dns_to_disk(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, + void* callback_arg, const char* local_file_name, httpc_state_t **connection) +{ + err_t err; + httpc_state_t* req; + httpc_filestate_t *filestate; + + LWIP_ERROR("invalid parameters", (server_name != NULL) && (uri != NULL) && (local_file_name != NULL), return ERR_ARG;); + + err = httpc_fs_init(&filestate, local_file_name, settings, callback_arg); + if (err != ERR_OK) { + return err; + } + + err = httpc_init_connection(&req, &filestate->settings, server_name, port, + uri, httpc_fs_tcp_recv, filestate); + if (err != ERR_OK) { + httpc_fs_free(filestate); + return err; + } + + if (settings->use_proxy) { + err = httpc_get_internal_addr(req, &settings->proxy_addr); + } else { + err = httpc_get_internal_dns(req, server_name); + } + if(err != ERR_OK) { + httpc_fs_free(filestate); + httpc_free_state(req); + return err; + } + + if (connection != NULL) { + *connection = req; + } + return ERR_OK; +} +#endif /* LWIP_HTTPC_HAVE_FILE_IO */ + +#endif /* LWIP_TCP && LWIP_CALLBACK_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd.c index cbb0387d..ccc9ba72 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd.c @@ -1,2746 +1,2746 @@ -/** - * @file - * LWIP HTTP server implementation - */ - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * Simon Goldschmidt - * - */ - -/** - * @defgroup httpd HTTP server - * @ingroup apps - * - * This httpd supports for a - * rudimentary server-side-include facility which will replace tags of the form - * in any file whose extension is .shtml, .shtm or .ssi with - * strings provided by an include handler whose pointer is provided to the - * module via function http_set_ssi_handler(). - * Additionally, a simple common - * gateway interface (CGI) handling mechanism has been added to allow clients - * to hook functions to particular request URIs. - * - * To enable SSI support, define label LWIP_HTTPD_SSI in lwipopts.h. - * To enable CGI support, define label LWIP_HTTPD_CGI in lwipopts.h. - * - * By default, the server assumes that HTTP headers are already present in - * each file stored in the file system. By defining LWIP_HTTPD_DYNAMIC_HEADERS in - * lwipopts.h, this behavior can be changed such that the server inserts the - * headers automatically based on the extension of the file being served. If - * this mode is used, be careful to ensure that the file system image used - * does not already contain the header information. - * - * File system images without headers can be created using the makefsfile - * tool with the -h command line option. - * - * - * Notes about valid SSI tags - * -------------------------- - * - * The following assumptions are made about tags used in SSI markers: - * - * 1. No tag may contain '-' or whitespace characters within the tag name. - * 2. Whitespace is allowed between the tag leadin "". - * 3. The maximum tag name length is LWIP_HTTPD_MAX_TAG_NAME_LEN, currently 8 characters. - * - * Notes on CGI usage - * ------------------ - * - * The simple CGI support offered here works with GET method requests only - * and can handle up to 16 parameters encoded into the URI. The handler - * function may not write directly to the HTTP output but must return a - * filename that the HTTP server will send to the browser as a response to - * the incoming CGI request. - * - * - * - * The list of supported file types is quite short, so if makefsdata complains - * about an unknown extension, make sure to add it (and its doctype) to - * the 'g_psHTTPHeaders' list. - */ -#include "lwip/init.h" -#include "lwip/apps/httpd.h" -#include "lwip/debug.h" -#include "lwip/stats.h" -#include "lwip/apps/fs.h" -#include "httpd_structs.h" -#include "lwip/def.h" - -#include "lwip/altcp.h" -#include "lwip/altcp_tcp.h" -#if HTTPD_ENABLE_HTTPS -#include "lwip/altcp_tls.h" -#endif -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif -#if LWIP_HTTPD_TIMING -#include "lwip/sys.h" -#endif /* LWIP_HTTPD_TIMING */ - -#include /* memset */ -#include /* atoi */ -#include - -#if LWIP_TCP && LWIP_CALLBACK_API - -/** Minimum length for a valid HTTP/0.9 request: "GET /\r\n" -> 7 bytes */ -#define MIN_REQ_LEN 7 - -#define CRLF "\r\n" -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE -#define HTTP11_CONNECTIONKEEPALIVE "Connection: keep-alive" -#define HTTP11_CONNECTIONKEEPALIVE2 "Connection: Keep-Alive" -#endif - -#if LWIP_HTTPD_DYNAMIC_FILE_READ -#define HTTP_IS_DYNAMIC_FILE(hs) ((hs)->buf != NULL) -#else -#define HTTP_IS_DYNAMIC_FILE(hs) 0 -#endif - -/* This defines checks whether tcp_write has to copy data or not */ - -#ifndef HTTP_IS_DATA_VOLATILE -/** tcp_write does not have to copy data when sent from rom-file-system directly */ -#define HTTP_IS_DATA_VOLATILE(hs) (HTTP_IS_DYNAMIC_FILE(hs) ? TCP_WRITE_FLAG_COPY : 0) -#endif -/** Default: dynamic headers are sent from ROM (non-dynamic headers are handled like file data) */ -#ifndef HTTP_IS_HDR_VOLATILE -#define HTTP_IS_HDR_VOLATILE(hs, ptr) 0 -#endif - -/* Return values for http_send_*() */ -#define HTTP_DATA_TO_SEND_FREED 3 -#define HTTP_DATA_TO_SEND_BREAK 2 -#define HTTP_DATA_TO_SEND_CONTINUE 1 -#define HTTP_NO_DATA_TO_SEND 0 - -typedef struct { - const char *name; - u8_t shtml; -} default_filename; - -static const default_filename httpd_default_filenames[] = { - {"/index.shtml", 1 }, - {"/index.ssi", 1 }, - {"/index.shtm", 1 }, - {"/index.html", 0 }, - {"/index.htm", 0 } -}; - -#define NUM_DEFAULT_FILENAMES LWIP_ARRAYSIZE(httpd_default_filenames) - -#if LWIP_HTTPD_SUPPORT_REQUESTLIST -/** HTTP request is copied here from pbufs for simple parsing */ -static char httpd_req_buf[LWIP_HTTPD_MAX_REQ_LENGTH + 1]; -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - -#if LWIP_HTTPD_SUPPORT_POST -#if LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN > LWIP_HTTPD_MAX_REQUEST_URI_LEN -#define LWIP_HTTPD_URI_BUF_LEN LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN -#endif -#endif -#ifndef LWIP_HTTPD_URI_BUF_LEN -#define LWIP_HTTPD_URI_BUF_LEN LWIP_HTTPD_MAX_REQUEST_URI_LEN -#endif -#if LWIP_HTTPD_URI_BUF_LEN -/* Filename for response file to send when POST is finished or - * search for default files when a directory is requested. */ -static char http_uri_buf[LWIP_HTTPD_URI_BUF_LEN + 1]; -#endif - -#if LWIP_HTTPD_DYNAMIC_HEADERS -/* The number of individual strings that comprise the headers sent before each - * requested file. - */ -#define NUM_FILE_HDR_STRINGS 5 -#define HDR_STRINGS_IDX_HTTP_STATUS 0 /* e.g. "HTTP/1.0 200 OK\r\n" */ -#define HDR_STRINGS_IDX_SERVER_NAME 1 /* e.g. "Server: "HTTPD_SERVER_AGENT"\r\n" */ -#define HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE 2 /* e.g. "Content-Length: xy\r\n" and/or "Connection: keep-alive\r\n" */ -#define HDR_STRINGS_IDX_CONTENT_LEN_NR 3 /* the byte count, when content-length is used */ -#define HDR_STRINGS_IDX_CONTENT_TYPE 4 /* the content type (or default answer content type including default document) */ - -/* The dynamically generated Content-Length buffer needs space for CRLF + NULL */ -#define LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET 3 -#ifndef LWIP_HTTPD_MAX_CONTENT_LEN_SIZE -/* The dynamically generated Content-Length buffer shall be able to work with - ~953 MB (9 digits) */ -#define LWIP_HTTPD_MAX_CONTENT_LEN_SIZE (9 + LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET) -#endif -#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ - -#if LWIP_HTTPD_SSI - -#define HTTPD_LAST_TAG_PART 0xFFFF - -enum tag_check_state { - TAG_NONE, /* Not processing an SSI tag */ - TAG_LEADIN, /* Tag lead in "" being processed */ - TAG_SENDING /* Sending tag replacement string */ -}; - -struct http_ssi_state { - const char *parsed; /* Pointer to the first unparsed byte in buf. */ -#if !LWIP_HTTPD_SSI_INCLUDE_TAG - const char *tag_started;/* Pointer to the first opening '<' of the tag. */ -#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG */ - const char *tag_end; /* Pointer to char after the closing '>' of the tag. */ - u32_t parse_left; /* Number of unparsed bytes in buf. */ - u16_t tag_index; /* Counter used by tag parsing state machine */ - u16_t tag_insert_len; /* Length of insert in string tag_insert */ -#if LWIP_HTTPD_SSI_MULTIPART - u16_t tag_part; /* Counter passed to and changed by tag insertion function to insert multiple times */ -#endif /* LWIP_HTTPD_SSI_MULTIPART */ - u8_t tag_type; /* index into http_ssi_tag_desc array */ - u8_t tag_name_len; /* Length of the tag name in string tag_name */ - char tag_name[LWIP_HTTPD_MAX_TAG_NAME_LEN + 1]; /* Last tag name extracted */ - char tag_insert[LWIP_HTTPD_MAX_TAG_INSERT_LEN + 1]; /* Insert string for tag_name */ - enum tag_check_state tag_state; /* State of the tag processor */ -}; - -struct http_ssi_tag_description { - const char *lead_in; - const char *lead_out; -}; - -#endif /* LWIP_HTTPD_SSI */ - -struct http_state { -#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED - struct http_state *next; -#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ - struct fs_file file_handle; - struct fs_file *handle; - const char *file; /* Pointer to first unsent byte in buf. */ - - struct altcp_pcb *pcb; -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - struct pbuf *req; -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - -#if LWIP_HTTPD_DYNAMIC_FILE_READ - char *buf; /* File read buffer. */ - int buf_len; /* Size of file read buffer, buf. */ -#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ - u32_t left; /* Number of unsent bytes in buf. */ - u8_t retries; -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - u8_t keepalive; -#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ -#if LWIP_HTTPD_SSI - struct http_ssi_state *ssi; -#endif /* LWIP_HTTPD_SSI */ -#if LWIP_HTTPD_CGI - char *params[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Params extracted from the request URI */ - char *param_vals[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Values for each extracted param */ -#endif /* LWIP_HTTPD_CGI */ -#if LWIP_HTTPD_DYNAMIC_HEADERS - const char *hdrs[NUM_FILE_HDR_STRINGS]; /* HTTP headers to be sent. */ - char hdr_content_len[LWIP_HTTPD_MAX_CONTENT_LEN_SIZE]; - u16_t hdr_pos; /* The position of the first unsent header byte in the - current string */ - u16_t hdr_index; /* The index of the hdr string currently being sent. */ -#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ -#if LWIP_HTTPD_TIMING - u32_t time_started; -#endif /* LWIP_HTTPD_TIMING */ -#if LWIP_HTTPD_SUPPORT_POST - u32_t post_content_len_left; -#if LWIP_HTTPD_POST_MANUAL_WND - u32_t unrecved_bytes; - u8_t no_auto_wnd; - u8_t post_finished; -#endif /* LWIP_HTTPD_POST_MANUAL_WND */ -#endif /* LWIP_HTTPD_SUPPORT_POST*/ -}; - -#if HTTPD_USE_MEM_POOL -LWIP_MEMPOOL_DECLARE(HTTPD_STATE, MEMP_NUM_PARALLEL_HTTPD_CONNS, sizeof(struct http_state), "HTTPD_STATE") -#if LWIP_HTTPD_SSI -LWIP_MEMPOOL_DECLARE(HTTPD_SSI_STATE, MEMP_NUM_PARALLEL_HTTPD_SSI_CONNS, sizeof(struct http_ssi_state), "HTTPD_SSI_STATE") -#define HTTP_FREE_SSI_STATE(x) LWIP_MEMPOOL_FREE(HTTPD_SSI_STATE, (x)) -#define HTTP_ALLOC_SSI_STATE() (struct http_ssi_state *)LWIP_MEMPOOL_ALLOC(HTTPD_SSI_STATE) -#endif /* LWIP_HTTPD_SSI */ -#define HTTP_ALLOC_HTTP_STATE() (struct http_state *)LWIP_MEMPOOL_ALLOC(HTTPD_STATE) -#define HTTP_FREE_HTTP_STATE(x) LWIP_MEMPOOL_FREE(HTTPD_STATE, (x)) -#else /* HTTPD_USE_MEM_POOL */ -#define HTTP_ALLOC_HTTP_STATE() (struct http_state *)mem_malloc(sizeof(struct http_state)) -#define HTTP_FREE_HTTP_STATE(x) mem_free(x) -#if LWIP_HTTPD_SSI -#define HTTP_ALLOC_SSI_STATE() (struct http_ssi_state *)mem_malloc(sizeof(struct http_ssi_state)) -#define HTTP_FREE_SSI_STATE(x) mem_free(x) -#endif /* LWIP_HTTPD_SSI */ -#endif /* HTTPD_USE_MEM_POOL */ - -static err_t http_close_conn(struct altcp_pcb *pcb, struct http_state *hs); -static err_t http_close_or_abort_conn(struct altcp_pcb *pcb, struct http_state *hs, u8_t abort_conn); -static err_t http_find_file(struct http_state *hs, const char *uri, int is_09); -static err_t http_init_file(struct http_state *hs, struct fs_file *file, int is_09, const char *uri, u8_t tag_check, char *params); -static err_t http_poll(void *arg, struct altcp_pcb *pcb); -static u8_t http_check_eof(struct altcp_pcb *pcb, struct http_state *hs); -#if LWIP_HTTPD_FS_ASYNC_READ -static void http_continue(void *connection); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ - -#if LWIP_HTTPD_SSI -/* SSI insert handler function pointer. */ -static tSSIHandler httpd_ssi_handler; -#if !LWIP_HTTPD_SSI_RAW -static int httpd_num_tags; -static const char **httpd_tags; -#endif /* !LWIP_HTTPD_SSI_RAW */ - -/* Define the available tag lead-ins and corresponding lead-outs. - * ATTENTION: for the algorithm below using this array, it is essential - * that the lead in differs in the first character! */ -const struct http_ssi_tag_description http_ssi_tag_desc[] = { - {""}, - {"/*#", "*/"} -}; - -#endif /* LWIP_HTTPD_SSI */ - -#if LWIP_HTTPD_CGI -/* CGI handler information */ -static const tCGI *httpd_cgis; -static int httpd_num_cgis; -static int http_cgi_paramcount; -#define http_cgi_params hs->params -#define http_cgi_param_vals hs->param_vals -#elif LWIP_HTTPD_CGI_SSI -static char *http_cgi_params[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Params extracted from the request URI */ -static char *http_cgi_param_vals[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Values for each extracted param */ -#endif /* LWIP_HTTPD_CGI */ - -#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED -/** global list of active HTTP connections, use to kill the oldest when - running out of memory */ -static struct http_state *http_connections; - -static void -http_add_connection(struct http_state *hs) -{ - /* add the connection to the list */ - hs->next = http_connections; - http_connections = hs; -} - -static void -http_remove_connection(struct http_state *hs) -{ - /* take the connection off the list */ - if (http_connections) { - if (http_connections == hs) { - http_connections = hs->next; - } else { - struct http_state *last; - for (last = http_connections; last->next != NULL; last = last->next) { - if (last->next == hs) { - last->next = hs->next; - break; - } - } - } - } -} - -static void -http_kill_oldest_connection(u8_t ssi_required) -{ - struct http_state *hs = http_connections; - struct http_state *hs_free_next = NULL; - while (hs && hs->next) { -#if LWIP_HTTPD_SSI - if (ssi_required) { - if (hs->next->ssi != NULL) { - hs_free_next = hs; - } - } else -#else /* LWIP_HTTPD_SSI */ - LWIP_UNUSED_ARG(ssi_required); -#endif /* LWIP_HTTPD_SSI */ - { - hs_free_next = hs; - } - LWIP_ASSERT("broken list", hs != hs->next); - hs = hs->next; - } - if (hs_free_next != NULL) { - LWIP_ASSERT("hs_free_next->next != NULL", hs_free_next->next != NULL); - LWIP_ASSERT("hs_free_next->next->pcb != NULL", hs_free_next->next->pcb != NULL); - /* send RST when killing a connection because of memory shortage */ - http_close_or_abort_conn(hs_free_next->next->pcb, hs_free_next->next, 1); /* this also unlinks the http_state from the list */ - } -} -#else /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ - -#define http_add_connection(hs) -#define http_remove_connection(hs) - -#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ - -#if LWIP_HTTPD_SSI -/** Allocate as struct http_ssi_state. */ -static struct http_ssi_state * -http_ssi_state_alloc(void) -{ - struct http_ssi_state *ret = HTTP_ALLOC_SSI_STATE(); -#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED - if (ret == NULL) { - http_kill_oldest_connection(1); - ret = HTTP_ALLOC_SSI_STATE(); - } -#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ - if (ret != NULL) { - memset(ret, 0, sizeof(struct http_ssi_state)); - } - return ret; -} - -/** Free a struct http_ssi_state. */ -static void -http_ssi_state_free(struct http_ssi_state *ssi) -{ - if (ssi != NULL) { - HTTP_FREE_SSI_STATE(ssi); - } -} -#endif /* LWIP_HTTPD_SSI */ - -/** Initialize a struct http_state. - */ -static void -http_state_init(struct http_state *hs) -{ - /* Initialize the structure. */ - memset(hs, 0, sizeof(struct http_state)); -#if LWIP_HTTPD_DYNAMIC_HEADERS - /* Indicate that the headers are not yet valid */ - hs->hdr_index = NUM_FILE_HDR_STRINGS; -#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ -} - -/** Allocate a struct http_state. */ -static struct http_state * -http_state_alloc(void) -{ - struct http_state *ret = HTTP_ALLOC_HTTP_STATE(); -#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED - if (ret == NULL) { - http_kill_oldest_connection(0); - ret = HTTP_ALLOC_HTTP_STATE(); - } -#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ - if (ret != NULL) { - http_state_init(ret); - http_add_connection(ret); - } - return ret; -} - -/** Free a struct http_state. - * Also frees the file data if dynamic. - */ -static void -http_state_eof(struct http_state *hs) -{ - if (hs->handle) { -#if LWIP_HTTPD_TIMING - u32_t ms_needed = sys_now() - hs->time_started; - u32_t needed = LWIP_MAX(1, (ms_needed / 100)); - LWIP_DEBUGF(HTTPD_DEBUG_TIMING, ("httpd: needed %"U32_F" ms to send file of %d bytes -> %"U32_F" bytes/sec\n", - ms_needed, hs->handle->len, ((((u32_t)hs->handle->len) * 10) / needed))); -#endif /* LWIP_HTTPD_TIMING */ - fs_close(hs->handle); - hs->handle = NULL; - } -#if LWIP_HTTPD_DYNAMIC_FILE_READ - if (hs->buf != NULL) { - mem_free(hs->buf); - hs->buf = NULL; - } -#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ -#if LWIP_HTTPD_SSI - if (hs->ssi) { - http_ssi_state_free(hs->ssi); - hs->ssi = NULL; - } -#endif /* LWIP_HTTPD_SSI */ -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - if (hs->req) { - pbuf_free(hs->req); - hs->req = NULL; - } -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ -} - -/** Free a struct http_state. - * Also frees the file data if dynamic. - */ -static void -http_state_free(struct http_state *hs) -{ - if (hs != NULL) { - http_state_eof(hs); - http_remove_connection(hs); - HTTP_FREE_HTTP_STATE(hs); - } -} - -/** Call tcp_write() in a loop trying smaller and smaller length - * - * @param pcb altcp_pcb to send - * @param ptr Data to send - * @param length Length of data to send (in/out: on return, contains the - * amount of data sent) - * @param apiflags directly passed to tcp_write - * @return the return value of tcp_write - */ -static err_t -http_write(struct altcp_pcb *pcb, const void *ptr, u16_t *length, u8_t apiflags) -{ - u16_t len, max_len; - err_t err; - LWIP_ASSERT("length != NULL", length != NULL); - len = *length; - if (len == 0) { - return ERR_OK; - } - /* We cannot send more data than space available in the send buffer. */ - max_len = altcp_sndbuf(pcb); - if (max_len < len) { - len = max_len; - } -#ifdef HTTPD_MAX_WRITE_LEN - /* Additional limitation: e.g. don't enqueue more than 2*mss at once */ - max_len = HTTPD_MAX_WRITE_LEN(pcb); - if (len > max_len) { - len = max_len; - } -#endif /* HTTPD_MAX_WRITE_LEN */ - do { - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Trying to send %d bytes\n", len)); - err = altcp_write(pcb, ptr, len, apiflags); - if (err == ERR_MEM) { - if ((altcp_sndbuf(pcb) == 0) || - (altcp_sndqueuelen(pcb) >= TCP_SND_QUEUELEN)) { - /* no need to try smaller sizes */ - len = 1; - } else { - len /= 2; - } - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, - ("Send failed, trying less (%d bytes)\n", len)); - } - } while ((err == ERR_MEM) && (len > 1)); - - if (err == ERR_OK) { - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Sent %d bytes\n", len)); - *length = len; - } else { - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Send failed with err %d (\"%s\")\n", err, lwip_strerr(err))); - *length = 0; - } - -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - /* ensure nagle is normally enabled (only disabled for persistent connections - when all data has been enqueued but the connection stays open for the next - request */ - altcp_nagle_enable(pcb); -#endif - - return err; -} - -/** - * The connection shall be actively closed (using RST to close from fault states). - * Reset the sent- and recv-callbacks. - * - * @param pcb the tcp pcb to reset callbacks - * @param hs connection state to free - */ -static err_t -http_close_or_abort_conn(struct altcp_pcb *pcb, struct http_state *hs, u8_t abort_conn) -{ - err_t err; - LWIP_DEBUGF(HTTPD_DEBUG, ("Closing connection %p\n", (void *)pcb)); - -#if LWIP_HTTPD_SUPPORT_POST - if (hs != NULL) { - if ((hs->post_content_len_left != 0) -#if LWIP_HTTPD_POST_MANUAL_WND - || ((hs->no_auto_wnd != 0) && (hs->unrecved_bytes != 0)) -#endif /* LWIP_HTTPD_POST_MANUAL_WND */ - ) { - /* make sure the post code knows that the connection is closed */ - http_uri_buf[0] = 0; - httpd_post_finished(hs, http_uri_buf, LWIP_HTTPD_URI_BUF_LEN); - } - } -#endif /* LWIP_HTTPD_SUPPORT_POST*/ - - - altcp_arg(pcb, NULL); - altcp_recv(pcb, NULL); - altcp_err(pcb, NULL); - altcp_poll(pcb, NULL, 0); - altcp_sent(pcb, NULL); - if (hs != NULL) { - http_state_free(hs); - } - - if (abort_conn) { - altcp_abort(pcb); - return ERR_OK; - } - err = altcp_close(pcb); - if (err != ERR_OK) { - LWIP_DEBUGF(HTTPD_DEBUG, ("Error %d closing %p\n", err, (void *)pcb)); - /* error closing, try again later in poll */ - altcp_poll(pcb, http_poll, HTTPD_POLL_INTERVAL); - } - return err; -} - -/** - * The connection shall be actively closed. - * Reset the sent- and recv-callbacks. - * - * @param pcb the tcp pcb to reset callbacks - * @param hs connection state to free - */ -static err_t -http_close_conn(struct altcp_pcb *pcb, struct http_state *hs) -{ - return http_close_or_abort_conn(pcb, hs, 0); -} - -/** End of file: either close the connection (Connection: close) or - * close the file (Connection: keep-alive) - */ -static void -http_eof(struct altcp_pcb *pcb, struct http_state *hs) -{ - /* HTTP/1.1 persistent connection? (Not supported for SSI) */ -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - if (hs->keepalive) { - http_remove_connection(hs); - - http_state_eof(hs); - http_state_init(hs); - /* restore state: */ - hs->pcb = pcb; - hs->keepalive = 1; - http_add_connection(hs); - /* ensure nagle doesn't interfere with sending all data as fast as possible: */ - altcp_nagle_disable(pcb); - } else -#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ - { - http_close_conn(pcb, hs); - } -} - -#if LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI -/** - * Extract URI parameters from the parameter-part of an URI in the form - * "test.cgi?x=y" @todo: better explanation! - * Pointers to the parameters are stored in hs->param_vals. - * - * @param hs http connection state - * @param params pointer to the NULL-terminated parameter string from the URI - * @return number of parameters extracted - */ -static int -extract_uri_parameters(struct http_state *hs, char *params) -{ - char *pair; - char *equals; - int loop; - - LWIP_UNUSED_ARG(hs); - - /* If we have no parameters at all, return immediately. */ - if (!params || (params[0] == '\0')) { - return (0); - } - - /* Get a pointer to our first parameter */ - pair = params; - - /* Parse up to LWIP_HTTPD_MAX_CGI_PARAMETERS from the passed string and ignore the - * remainder (if any) */ - for (loop = 0; (loop < LWIP_HTTPD_MAX_CGI_PARAMETERS) && pair; loop++) { - - /* Save the name of the parameter */ - http_cgi_params[loop] = pair; - - /* Remember the start of this name=value pair */ - equals = pair; - - /* Find the start of the next name=value pair and replace the delimiter - * with a 0 to terminate the previous pair string. */ - pair = strchr(pair, '&'); - if (pair) { - *pair = '\0'; - pair++; - } else { - /* We didn't find a new parameter so find the end of the URI and - * replace the space with a '\0' */ - pair = strchr(equals, ' '); - if (pair) { - *pair = '\0'; - } - - /* Revert to NULL so that we exit the loop as expected. */ - pair = NULL; - } - - /* Now find the '=' in the previous pair, replace it with '\0' and save - * the parameter value string. */ - equals = strchr(equals, '='); - if (equals) { - *equals = '\0'; - http_cgi_param_vals[loop] = equals + 1; - } else { - http_cgi_param_vals[loop] = NULL; - } - } - - return loop; -} -#endif /* LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI */ - -#if LWIP_HTTPD_SSI -/** - * Insert a tag (found in an shtml in the form of "" into the file. - * The tag's name is stored in ssi->tag_name (NULL-terminated), the replacement - * should be written to hs->tag_insert (up to a length of LWIP_HTTPD_MAX_TAG_INSERT_LEN). - * The amount of data written is stored to ssi->tag_insert_len. - * - * @todo: return tag_insert_len - maybe it can be removed from struct http_state? - * - * @param hs http connection state - */ -static void -get_tag_insert(struct http_state *hs) -{ -#if LWIP_HTTPD_SSI_RAW - const char *tag; -#else /* LWIP_HTTPD_SSI_RAW */ - int tag; -#endif /* LWIP_HTTPD_SSI_RAW */ - size_t len; - struct http_ssi_state *ssi; -#if LWIP_HTTPD_SSI_MULTIPART - u16_t current_tag_part; -#endif /* LWIP_HTTPD_SSI_MULTIPART */ - - LWIP_ASSERT("hs != NULL", hs != NULL); - ssi = hs->ssi; - LWIP_ASSERT("ssi != NULL", ssi != NULL); -#if LWIP_HTTPD_SSI_MULTIPART - current_tag_part = ssi->tag_part; - ssi->tag_part = HTTPD_LAST_TAG_PART; -#endif /* LWIP_HTTPD_SSI_MULTIPART */ -#if LWIP_HTTPD_SSI_RAW - tag = ssi->tag_name; -#endif - - if (httpd_ssi_handler -#if !LWIP_HTTPD_SSI_RAW - && httpd_tags && httpd_num_tags -#endif /* !LWIP_HTTPD_SSI_RAW */ - ) { - - /* Find this tag in the list we have been provided. */ -#if LWIP_HTTPD_SSI_RAW - { -#else /* LWIP_HTTPD_SSI_RAW */ - for (tag = 0; tag < httpd_num_tags; tag++) { - if (strcmp(ssi->tag_name, httpd_tags[tag]) == 0) -#endif /* LWIP_HTTPD_SSI_RAW */ - { - ssi->tag_insert_len = httpd_ssi_handler(tag, ssi->tag_insert, - LWIP_HTTPD_MAX_TAG_INSERT_LEN -#if LWIP_HTTPD_SSI_MULTIPART - , current_tag_part, &ssi->tag_part -#endif /* LWIP_HTTPD_SSI_MULTIPART */ -#if LWIP_HTTPD_FILE_STATE - , (hs->handle ? hs->handle->state : NULL) -#endif /* LWIP_HTTPD_FILE_STATE */ - ); -#if LWIP_HTTPD_SSI_RAW - if (ssi->tag_insert_len != HTTPD_SSI_TAG_UNKNOWN) -#endif /* LWIP_HTTPD_SSI_RAW */ - { - return; - } - } - } - } - - /* If we drop out, we were asked to serve a page which contains tags that - * we don't have a handler for. Merely echo back the tags with an error - * marker. */ -#define UNKNOWN_TAG1_TEXT "***UNKNOWN TAG " -#define UNKNOWN_TAG1_LEN 18 -#define UNKNOWN_TAG2_TEXT "***" -#define UNKNOWN_TAG2_LEN 7 - len = LWIP_MIN(sizeof(ssi->tag_name), LWIP_MIN(strlen(ssi->tag_name), - LWIP_HTTPD_MAX_TAG_INSERT_LEN - (UNKNOWN_TAG1_LEN + UNKNOWN_TAG2_LEN))); - MEMCPY(ssi->tag_insert, UNKNOWN_TAG1_TEXT, UNKNOWN_TAG1_LEN); - MEMCPY(&ssi->tag_insert[UNKNOWN_TAG1_LEN], ssi->tag_name, len); - MEMCPY(&ssi->tag_insert[UNKNOWN_TAG1_LEN + len], UNKNOWN_TAG2_TEXT, UNKNOWN_TAG2_LEN); - ssi->tag_insert[UNKNOWN_TAG1_LEN + len + UNKNOWN_TAG2_LEN] = 0; - - len = strlen(ssi->tag_insert); - LWIP_ASSERT("len <= 0xffff", len <= 0xffff); - ssi->tag_insert_len = (u16_t)len; -} -#endif /* LWIP_HTTPD_SSI */ - -#if LWIP_HTTPD_DYNAMIC_HEADERS -/** - * Generate the relevant HTTP headers for the given filename and write - * them into the supplied buffer. - */ -static void -get_http_headers(struct http_state *hs, const char *uri) -{ - size_t content_type; - char *tmp; - char *ext; - char *vars; - - /* In all cases, the second header we send is the server identification - so set it here. */ - hs->hdrs[HDR_STRINGS_IDX_SERVER_NAME] = g_psHTTPHeaderStrings[HTTP_HDR_SERVER]; - hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = NULL; - hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_NR] = NULL; - - /* Is this a normal file or the special case we use to send back the - default "404: Page not found" response? */ - if (uri == NULL) { - hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_FOUND]; -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - if (hs->keepalive) { - hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaderStrings[DEFAULT_404_HTML_PERSISTENT]; - } else -#endif - { - hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaderStrings[DEFAULT_404_HTML]; - } - - /* Set up to send the first header string. */ - hs->hdr_index = 0; - hs->hdr_pos = 0; - return; - } - /* We are dealing with a particular filename. Look for one other - special case. We assume that any filename with "404" in it must be - indicative of a 404 server error whereas all other files require - the 200 OK header. */ - if (strstr(uri, "404")) { - hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_FOUND]; - } else if (strstr(uri, "400")) { - hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_BAD_REQUEST]; - } else if (strstr(uri, "501")) { - hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_IMPL]; - } else { - hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_OK]; - } - - /* Determine if the URI has any variables and, if so, temporarily remove - them. */ - vars = strchr(uri, '?'); - if (vars) { - *vars = '\0'; - } - - /* Get a pointer to the file extension. We find this by looking for the - last occurrence of "." in the filename passed. */ - ext = NULL; - tmp = strchr(uri, '.'); - while (tmp) { - ext = tmp + 1; - tmp = strchr(ext, '.'); - } - if (ext != NULL) { - /* Now determine the content type and add the relevant header for that. */ - for (content_type = 0; content_type < NUM_HTTP_HEADERS; content_type++) { - /* Have we found a matching extension? */ - if (!lwip_stricmp(g_psHTTPHeaders[content_type].extension, ext)) { - break; - } - } - } else { - content_type = NUM_HTTP_HEADERS; - } - - /* Reinstate the parameter marker if there was one in the original URI. */ - if (vars) { - *vars = '?'; - } - -#if LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI - /* Does the URL passed have any file extension? If not, we assume it - is a special-case URL used for control state notification and we do - not send any HTTP headers with the response. */ - if (!ext) { - /* Force the header index to a value indicating that all headers - have already been sent. */ - hs->hdr_index = NUM_FILE_HDR_STRINGS; - return; - } -#endif /* LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI */ - /* Did we find a matching extension? */ - if (content_type < NUM_HTTP_HEADERS) { - /* yes, store it */ - hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaders[content_type].content_type; - } else if (!ext) { - /* no, no extension found -> use binary transfer to prevent the browser adding '.txt' on save */ - hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = HTTP_HDR_APP; - } else { - /* No - use the default, plain text file type. */ - hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = HTTP_HDR_DEFAULT_TYPE; - } - /* Set up to send the first header string. */ - hs->hdr_index = 0; - hs->hdr_pos = 0; -} - -/* Add content-length header? */ -static void -get_http_content_length(struct http_state *hs) -{ - u8_t add_content_len = 0; - - LWIP_ASSERT("already been here?", hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] == NULL); - - add_content_len = 0; -#if LWIP_HTTPD_SSI - if (hs->ssi == NULL) /* @todo: get maximum file length from SSI */ -#endif /* LWIP_HTTPD_SSI */ - { - if ((hs->handle != NULL) && (hs->handle->flags & FS_FILE_FLAGS_HEADER_PERSISTENT)) { - add_content_len = 1; - } - } - if (add_content_len) { - size_t len; - lwip_itoa(hs->hdr_content_len, (size_t)LWIP_HTTPD_MAX_CONTENT_LEN_SIZE, - hs->handle->len); - len = strlen(hs->hdr_content_len); - if (len <= LWIP_HTTPD_MAX_CONTENT_LEN_SIZE - LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET) { - SMEMCPY(&hs->hdr_content_len[len], CRLF, 3); - hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_NR] = hs->hdr_content_len; - } else { - add_content_len = 0; - } - } -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - if (add_content_len) { - hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_KEEPALIVE_LEN]; - } else { - hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_CONN_CLOSE]; - hs->keepalive = 0; - } -#else /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ - if (add_content_len) { - hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_CONTENT_LENGTH]; - } -#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ -} - -/** Sub-function of http_send(): send dynamic headers - * - * @returns: - HTTP_NO_DATA_TO_SEND: no new data has been enqueued - * - HTTP_DATA_TO_SEND_CONTINUE: continue with sending HTTP body - * - HTTP_DATA_TO_SEND_BREAK: data has been enqueued, headers pending, - * so don't send HTTP body yet - * - HTTP_DATA_TO_SEND_FREED: http_state and pcb are already freed - */ -static u8_t -http_send_headers(struct altcp_pcb *pcb, struct http_state *hs) -{ - err_t err; - u16_t len; - u8_t data_to_send = HTTP_NO_DATA_TO_SEND; - u16_t hdrlen, sendlen; - - if (hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] == NULL) { - /* set up "content-length" and "connection:" headers */ - get_http_content_length(hs); - } - - /* How much data can we send? */ - len = altcp_sndbuf(pcb); - sendlen = len; - - while (len && (hs->hdr_index < NUM_FILE_HDR_STRINGS) && sendlen) { - const void *ptr; - u16_t old_sendlen; - u8_t apiflags; - /* How much do we have to send from the current header? */ - hdrlen = (u16_t)strlen(hs->hdrs[hs->hdr_index]); - - /* How much of this can we send? */ - sendlen = (len < (hdrlen - hs->hdr_pos)) ? len : (hdrlen - hs->hdr_pos); - - /* Send this amount of data or as much as we can given memory - * constraints. */ - ptr = (const void *)(hs->hdrs[hs->hdr_index] + hs->hdr_pos); - old_sendlen = sendlen; - apiflags = HTTP_IS_HDR_VOLATILE(hs, ptr); - if (hs->hdr_index == HDR_STRINGS_IDX_CONTENT_LEN_NR) { - /* content-length is always volatile */ - apiflags |= TCP_WRITE_FLAG_COPY; - } - if (hs->hdr_index < NUM_FILE_HDR_STRINGS - 1) { - apiflags |= TCP_WRITE_FLAG_MORE; - } - err = http_write(pcb, ptr, &sendlen, apiflags); - if ((err == ERR_OK) && (old_sendlen != sendlen)) { - /* Remember that we added some more data to be transmitted. */ - data_to_send = HTTP_DATA_TO_SEND_CONTINUE; - } else if (err != ERR_OK) { - /* special case: http_write does not try to send 1 byte */ - sendlen = 0; - } - - /* Fix up the header position for the next time round. */ - hs->hdr_pos += sendlen; - len -= sendlen; - - /* Have we finished sending this string? */ - if (hs->hdr_pos == hdrlen) { - /* Yes - move on to the next one */ - hs->hdr_index++; - /* skip headers that are NULL (not all headers are required) */ - while ((hs->hdr_index < NUM_FILE_HDR_STRINGS) && - (hs->hdrs[hs->hdr_index] == NULL)) { - hs->hdr_index++; - } - hs->hdr_pos = 0; - } - } - - if ((hs->hdr_index >= NUM_FILE_HDR_STRINGS) && (hs->file == NULL)) { - /* When we are at the end of the headers, check for data to send - * instead of waiting for ACK from remote side to continue - * (which would happen when sending files from async read). */ - if (http_check_eof(pcb, hs)) { - data_to_send = HTTP_DATA_TO_SEND_BREAK; - } else { - /* At this point, for non-keepalive connections, hs is deallocated an - pcb is closed. */ - return HTTP_DATA_TO_SEND_FREED; - } - } - /* If we get here and there are still header bytes to send, we send - * the header information we just wrote immediately. If there are no - * more headers to send, but we do have file data to send, drop through - * to try to send some file data too. */ - if ((hs->hdr_index < NUM_FILE_HDR_STRINGS) || !hs->file) { - LWIP_DEBUGF(HTTPD_DEBUG, ("tcp_output\n")); - return HTTP_DATA_TO_SEND_BREAK; - } - return data_to_send; -} -#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ - -/** Sub-function of http_send(): end-of-file (or block) is reached, - * either close the file or read the next block (if supported). - * - * @returns: 0 if the file is finished or no data has been read - * 1 if the file is not finished and data has been read - */ -static u8_t -http_check_eof(struct altcp_pcb *pcb, struct http_state *hs) -{ - int bytes_left; -#if LWIP_HTTPD_DYNAMIC_FILE_READ - int count; -#ifdef HTTPD_MAX_WRITE_LEN - int max_write_len; -#endif /* HTTPD_MAX_WRITE_LEN */ -#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ - - /* Do we have a valid file handle? */ - if (hs->handle == NULL) { - /* No - close the connection. */ - http_eof(pcb, hs); - return 0; - } - bytes_left = fs_bytes_left(hs->handle); - if (bytes_left <= 0) { - /* We reached the end of the file so this request is done. */ - LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n")); - http_eof(pcb, hs); - return 0; - } -#if LWIP_HTTPD_DYNAMIC_FILE_READ - /* Do we already have a send buffer allocated? */ - if (hs->buf) { - /* Yes - get the length of the buffer */ - count = LWIP_MIN(hs->buf_len, bytes_left); - } else { - /* We don't have a send buffer so allocate one now */ - count = altcp_sndbuf(pcb); - if (bytes_left < count) { - count = bytes_left; - } -#ifdef HTTPD_MAX_WRITE_LEN - /* Additional limitation: e.g. don't enqueue more than 2*mss at once */ - max_write_len = HTTPD_MAX_WRITE_LEN(pcb); - if (count > max_write_len) { - count = max_write_len; - } -#endif /* HTTPD_MAX_WRITE_LEN */ - do { - hs->buf = (char *)mem_malloc((mem_size_t)count); - if (hs->buf != NULL) { - hs->buf_len = count; - break; - } - count = count / 2; - } while (count > 100); - - /* Did we get a send buffer? If not, return immediately. */ - if (hs->buf == NULL) { - LWIP_DEBUGF(HTTPD_DEBUG, ("No buff\n")); - return 0; - } - } - - /* Read a block of data from the file. */ - LWIP_DEBUGF(HTTPD_DEBUG, ("Trying to read %d bytes.\n", count)); - -#if LWIP_HTTPD_FS_ASYNC_READ - count = fs_read_async(hs->handle, hs->buf, count, http_continue, hs); -#else /* LWIP_HTTPD_FS_ASYNC_READ */ - count = fs_read(hs->handle, hs->buf, count); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ - if (count < 0) { - if (count == FS_READ_DELAYED) { - /* Delayed read, wait for FS to unblock us */ - return 0; - } - /* We reached the end of the file so this request is done. - * @todo: close here for HTTP/1.1 when reading file fails */ - LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n")); - http_eof(pcb, hs); - return 0; - } - - /* Set up to send the block of data we just read */ - LWIP_DEBUGF(HTTPD_DEBUG, ("Read %d bytes.\n", count)); - hs->left = count; - hs->file = hs->buf; -#if LWIP_HTTPD_SSI - if (hs->ssi) { - hs->ssi->parse_left = count; - hs->ssi->parsed = hs->buf; - } -#endif /* LWIP_HTTPD_SSI */ -#else /* LWIP_HTTPD_DYNAMIC_FILE_READ */ - LWIP_ASSERT("SSI and DYNAMIC_HEADERS turned off but eof not reached", 0); -#endif /* LWIP_HTTPD_SSI || LWIP_HTTPD_DYNAMIC_HEADERS */ - return 1; -} - -/** Sub-function of http_send(): This is the normal send-routine for non-ssi files - * - * @returns: - 1: data has been written (so call tcp_ouput) - * - 0: no data has been written (no need to call tcp_output) - */ -static u8_t -http_send_data_nonssi(struct altcp_pcb *pcb, struct http_state *hs) -{ - err_t err; - u16_t len; - u8_t data_to_send = 0; - - /* We are not processing an SHTML file so no tag checking is necessary. - * Just send the data as we received it from the file. */ - len = (u16_t)LWIP_MIN(hs->left, 0xffff); - - err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); - if (err == ERR_OK) { - data_to_send = 1; - hs->file += len; - hs->left -= len; - } - - return data_to_send; -} - -#if LWIP_HTTPD_SSI -/** Sub-function of http_send(): This is the send-routine for ssi files - * - * @returns: - 1: data has been written (so call tcp_ouput) - * - 0: no data has been written (no need to call tcp_output) - */ -static u8_t -http_send_data_ssi(struct altcp_pcb *pcb, struct http_state *hs) -{ - err_t err = ERR_OK; - u16_t len; - u8_t data_to_send = 0; - u8_t tag_type; - - struct http_ssi_state *ssi = hs->ssi; - LWIP_ASSERT("ssi != NULL", ssi != NULL); - /* We are processing an SHTML file so need to scan for tags and replace - * them with insert strings. We need to be careful here since a tag may - * straddle the boundary of two blocks read from the file and we may also - * have to split the insert string between two tcp_write operations. */ - - /* How much data could we send? */ - len = altcp_sndbuf(pcb); - - /* Do we have remaining data to send before parsing more? */ - if (ssi->parsed > hs->file) { - len = (u16_t)LWIP_MIN(ssi->parsed - hs->file, 0xffff); - - err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); - if (err == ERR_OK) { - data_to_send = 1; - hs->file += len; - hs->left -= len; - } - - /* If the send buffer is full, return now. */ - if (altcp_sndbuf(pcb) == 0) { - return data_to_send; - } - } - - LWIP_DEBUGF(HTTPD_DEBUG, ("State %d, %d left\n", ssi->tag_state, (int)ssi->parse_left)); - - /* We have sent all the data that was already parsed so continue parsing - * the buffer contents looking for SSI tags. */ - while (((ssi->tag_state == TAG_SENDING) || ssi->parse_left) && (err == ERR_OK)) { - if (len == 0) { - return data_to_send; - } - switch (ssi->tag_state) { - case TAG_NONE: - /* We are not currently processing an SSI tag so scan for the - * start of the lead-in marker. */ - for (tag_type = 0; tag_type < LWIP_ARRAYSIZE(http_ssi_tag_desc); tag_type++) { - if (*ssi->parsed == http_ssi_tag_desc[tag_type].lead_in[0]) { - /* We found what could be the lead-in for a new tag so change - * state appropriately. */ - ssi->tag_type = tag_type; - ssi->tag_state = TAG_LEADIN; - ssi->tag_index = 1; - #if !LWIP_HTTPD_SSI_INCLUDE_TAG - ssi->tag_started = ssi->parsed; - #endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG */ - break; - } - } - - /* Move on to the next character in the buffer */ - ssi->parse_left--; - ssi->parsed++; - break; - - case TAG_LEADIN: - /* We are processing the lead-in marker, looking for the start of - * the tag name. */ - - /* Have we reached the end of the leadin? */ - if (http_ssi_tag_desc[ssi->tag_type].lead_in[ssi->tag_index] == 0) { - ssi->tag_index = 0; - ssi->tag_state = TAG_FOUND; - } else { - /* Have we found the next character we expect for the tag leadin? */ - if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_in[ssi->tag_index]) { - /* Yes - move to the next one unless we have found the complete - * leadin, in which case we start looking for the tag itself */ - ssi->tag_index++; - } else { - /* We found an unexpected character so this is not a tag. Move - * back to idle state. */ - ssi->tag_state = TAG_NONE; - } - - /* Move on to the next character in the buffer */ - ssi->parse_left--; - ssi->parsed++; - } - break; - - case TAG_FOUND: - /* We are reading the tag name, looking for the start of the - * lead-out marker and removing any whitespace found. */ - - /* Remove leading whitespace between the tag leading and the first - * tag name character. */ - if ((ssi->tag_index == 0) && ((*ssi->parsed == ' ') || - (*ssi->parsed == '\t') || (*ssi->parsed == '\n') || - (*ssi->parsed == '\r'))) { - /* Move on to the next character in the buffer */ - ssi->parse_left--; - ssi->parsed++; - break; - } - - /* Have we found the end of the tag name? This is signalled by - * us finding the first leadout character or whitespace */ - if ((*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[0]) || - (*ssi->parsed == ' ') || (*ssi->parsed == '\t') || - (*ssi->parsed == '\n') || (*ssi->parsed == '\r')) { - - if (ssi->tag_index == 0) { - /* We read a zero length tag so ignore it. */ - ssi->tag_state = TAG_NONE; - } else { - /* We read a non-empty tag so go ahead and look for the - * leadout string. */ - ssi->tag_state = TAG_LEADOUT; - LWIP_ASSERT("ssi->tag_index <= 0xff", ssi->tag_index <= 0xff); - ssi->tag_name_len = (u8_t)ssi->tag_index; - ssi->tag_name[ssi->tag_index] = '\0'; - if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[0]) { - ssi->tag_index = 1; - } else { - ssi->tag_index = 0; - } - } - } else { - /* This character is part of the tag name so save it */ - if (ssi->tag_index < LWIP_HTTPD_MAX_TAG_NAME_LEN) { - ssi->tag_name[ssi->tag_index++] = *ssi->parsed; - } else { - /* The tag was too long so ignore it. */ - ssi->tag_state = TAG_NONE; - } - } - - /* Move on to the next character in the buffer */ - ssi->parse_left--; - ssi->parsed++; - - break; - - /* We are looking for the end of the lead-out marker. */ - case TAG_LEADOUT: - /* Remove leading whitespace between the tag leading and the first - * tag leadout character. */ - if ((ssi->tag_index == 0) && ((*ssi->parsed == ' ') || - (*ssi->parsed == '\t') || (*ssi->parsed == '\n') || - (*ssi->parsed == '\r'))) { - /* Move on to the next character in the buffer */ - ssi->parse_left--; - ssi->parsed++; - break; - } - - /* Have we found the next character we expect for the tag leadout? */ - if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[ssi->tag_index]) { - /* Yes - move to the next one unless we have found the complete - * leadout, in which case we need to call the client to process - * the tag. */ - - /* Move on to the next character in the buffer */ - ssi->parse_left--; - ssi->parsed++; - ssi->tag_index++; - - if (http_ssi_tag_desc[ssi->tag_type].lead_out[ssi->tag_index] == 0) { - /* Call the client to ask for the insert string for the - * tag we just found. */ -#if LWIP_HTTPD_SSI_MULTIPART - ssi->tag_part = 0; /* start with tag part 0 */ -#endif /* LWIP_HTTPD_SSI_MULTIPART */ - get_tag_insert(hs); - - /* Next time through, we are going to be sending data - * immediately, either the end of the block we start - * sending here or the insert string. */ - ssi->tag_index = 0; - ssi->tag_state = TAG_SENDING; - ssi->tag_end = ssi->parsed; -#if !LWIP_HTTPD_SSI_INCLUDE_TAG - ssi->parsed = ssi->tag_started; -#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ - - /* If there is any unsent data in the buffer prior to the - * tag, we need to send it now. */ - if (ssi->tag_end > hs->file) { - /* How much of the data can we send? */ -#if LWIP_HTTPD_SSI_INCLUDE_TAG - len = (u16_t)LWIP_MIN(ssi->tag_end - hs->file, 0xffff); -#else /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ - /* we would include the tag in sending */ - len = (u16_t)LWIP_MIN(ssi->tag_started - hs->file, 0xffff); -#endif /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ - - err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); - if (err == ERR_OK) { - data_to_send = 1; -#if !LWIP_HTTPD_SSI_INCLUDE_TAG - if (ssi->tag_started <= hs->file) { - /* pretend to have sent the tag, too */ - len += (u16_t)(ssi->tag_end - ssi->tag_started); - } -#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ - hs->file += len; - hs->left -= len; - } - } - } - } else { - /* We found an unexpected character so this is not a tag. Move - * back to idle state. */ - ssi->parse_left--; - ssi->parsed++; - ssi->tag_state = TAG_NONE; - } - break; - - /* - * We have found a valid tag and are in the process of sending - * data as a result of that discovery. We send either remaining data - * from the file prior to the insert point or the insert string itself. - */ - case TAG_SENDING: - /* Do we have any remaining file data to send from the buffer prior - * to the tag? */ - if (ssi->tag_end > hs->file) { - /* How much of the data can we send? */ -#if LWIP_HTTPD_SSI_INCLUDE_TAG - len = (u16_t)LWIP_MIN(ssi->tag_end - hs->file, 0xffff); -#else /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ - LWIP_ASSERT("hs->started >= hs->file", ssi->tag_started >= hs->file); - /* we would include the tag in sending */ - len = (u16_t)LWIP_MIN(ssi->tag_started - hs->file, 0xffff); -#endif /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ - if (len != 0) { - err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); - } else { - err = ERR_OK; - } - if (err == ERR_OK) { - data_to_send = 1; -#if !LWIP_HTTPD_SSI_INCLUDE_TAG - if (ssi->tag_started <= hs->file) { - /* pretend to have sent the tag, too */ - len += (u16_t)(ssi->tag_end - ssi->tag_started); - } -#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ - hs->file += len; - hs->left -= len; - } - } else { -#if LWIP_HTTPD_SSI_MULTIPART - if (ssi->tag_index >= ssi->tag_insert_len) { - /* Did the last SSIHandler have more to send? */ - if (ssi->tag_part != HTTPD_LAST_TAG_PART) { - /* If so, call it again */ - ssi->tag_index = 0; - get_tag_insert(hs); - } - } -#endif /* LWIP_HTTPD_SSI_MULTIPART */ - - /* Do we still have insert data left to send? */ - if (ssi->tag_index < ssi->tag_insert_len) { - /* We are sending the insert string itself. How much of the - * insert can we send? */ - len = (ssi->tag_insert_len - ssi->tag_index); - - /* Note that we set the copy flag here since we only have a - * single tag insert buffer per connection. If we don't do - * this, insert corruption can occur if more than one insert - * is processed before we call tcp_output. */ - err = http_write(pcb, &(ssi->tag_insert[ssi->tag_index]), &len, - HTTP_IS_TAG_VOLATILE(hs)); - if (err == ERR_OK) { - data_to_send = 1; - ssi->tag_index += len; - /* Don't return here: keep on sending data */ - } - } else { -#if LWIP_HTTPD_SSI_MULTIPART - if (ssi->tag_part == HTTPD_LAST_TAG_PART) -#endif /* LWIP_HTTPD_SSI_MULTIPART */ - { - /* We have sent all the insert data so go back to looking for - * a new tag. */ - LWIP_DEBUGF(HTTPD_DEBUG, ("Everything sent.\n")); - ssi->tag_index = 0; - ssi->tag_state = TAG_NONE; -#if !LWIP_HTTPD_SSI_INCLUDE_TAG - ssi->parsed = ssi->tag_end; -#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ - } - } - break; - default: - break; - } - } - } - - /* If we drop out of the end of the for loop, this implies we must have - * file data to send so send it now. In TAG_SENDING state, we've already - * handled this so skip the send if that's the case. */ - if ((ssi->tag_state != TAG_SENDING) && (ssi->parsed > hs->file)) { -#if LWIP_HTTPD_DYNAMIC_FILE_READ && !LWIP_HTTPD_SSI_INCLUDE_TAG - if ((ssi->tag_state != TAG_NONE) && (ssi->tag_started > ssi->tag_end)) { - /* If we found tag on the edge of the read buffer: just throw away the first part - (we have copied/saved everything required for parsing on later). */ - len = (u16_t)(ssi->tag_started - hs->file); - hs->left -= (ssi->parsed - ssi->tag_started); - ssi->parsed = ssi->tag_started; - ssi->tag_started = hs->buf; - } else -#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ && !LWIP_HTTPD_SSI_INCLUDE_TAG */ - { - len = (u16_t)LWIP_MIN(ssi->parsed - hs->file, 0xffff); - } - - err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); - if (err == ERR_OK) { - data_to_send = 1; - hs->file += len; - hs->left -= len; - } - } - return data_to_send; -} -#endif /* LWIP_HTTPD_SSI */ - -/** - * Try to send more data on this pcb. - * - * @param pcb the pcb to send data - * @param hs connection state - */ -static u8_t -http_send(struct altcp_pcb *pcb, struct http_state *hs) -{ - u8_t data_to_send = HTTP_NO_DATA_TO_SEND; - - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_send: pcb=%p hs=%p left=%d\n", (void *)pcb, - (void *)hs, hs != NULL ? (int)hs->left : 0)); - -#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND - if (hs->unrecved_bytes != 0) { - return 0; - } -#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */ - - /* If we were passed a NULL state structure pointer, ignore the call. */ - if (hs == NULL) { - return 0; - } - -#if LWIP_HTTPD_FS_ASYNC_READ - /* Check if we are allowed to read from this file. - (e.g. SSI might want to delay sending until data is available) */ - if (!fs_is_file_ready(hs->handle, http_continue, hs)) { - return 0; - } -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ - -#if LWIP_HTTPD_DYNAMIC_HEADERS - /* Do we have any more header data to send for this file? */ - if (hs->hdr_index < NUM_FILE_HDR_STRINGS) { - data_to_send = http_send_headers(pcb, hs); - if ((data_to_send == HTTP_DATA_TO_SEND_FREED) || - ((data_to_send != HTTP_DATA_TO_SEND_CONTINUE) && - (hs->hdr_index < NUM_FILE_HDR_STRINGS))) { - return data_to_send; - } - } -#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ - - /* Have we run out of file data to send? If so, we need to read the next - * block from the file. */ - if (hs->left == 0) { - if (!http_check_eof(pcb, hs)) { - return 0; - } - } - -#if LWIP_HTTPD_SSI - if (hs->ssi) { - data_to_send = http_send_data_ssi(pcb, hs); - } else -#endif /* LWIP_HTTPD_SSI */ - { - data_to_send = http_send_data_nonssi(pcb, hs); - } - - if ((hs->left == 0) && (fs_bytes_left(hs->handle) <= 0)) { - /* We reached the end of the file so this request is done. - * This adds the FIN flag right into the last data segment. */ - LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n")); - http_eof(pcb, hs); - return 0; - } - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("send_data end.\n")); - return data_to_send; -} - -#if LWIP_HTTPD_SUPPORT_EXTSTATUS -/** Initialize a http connection with a file to send for an error message - * - * @param hs http connection state - * @param error_nr HTTP error number - * @return ERR_OK if file was found and hs has been initialized correctly - * another err_t otherwise - */ -static err_t -http_find_error_file(struct http_state *hs, u16_t error_nr) -{ - const char *uri, *uri1, *uri2, *uri3; - - if (error_nr == 501) { - uri1 = "/501.html"; - uri2 = "/501.htm"; - uri3 = "/501.shtml"; - } else { - /* 400 (bad request is the default) */ - uri1 = "/400.html"; - uri2 = "/400.htm"; - uri3 = "/400.shtml"; - } - if (fs_open(&hs->file_handle, uri1) == ERR_OK) { - uri = uri1; - } else if (fs_open(&hs->file_handle, uri2) == ERR_OK) { - uri = uri2; - } else if (fs_open(&hs->file_handle, uri3) == ERR_OK) { - uri = uri3; - } else { - LWIP_DEBUGF(HTTPD_DEBUG, ("Error page for error %"U16_F" not found\n", - error_nr)); - return ERR_ARG; - } - return http_init_file(hs, &hs->file_handle, 0, uri, 0, NULL); -} -#else /* LWIP_HTTPD_SUPPORT_EXTSTATUS */ -#define http_find_error_file(hs, error_nr) ERR_ARG -#endif /* LWIP_HTTPD_SUPPORT_EXTSTATUS */ - -/** - * Get the file struct for a 404 error page. - * Tries some file names and returns NULL if none found. - * - * @param uri pointer that receives the actual file name URI - * @return file struct for the error page or NULL no matching file was found - */ -static struct fs_file * -http_get_404_file(struct http_state *hs, const char **uri) -{ - err_t err; - - *uri = "/404.html"; - err = fs_open(&hs->file_handle, *uri); - if (err != ERR_OK) { - /* 404.html doesn't exist. Try 404.htm instead. */ - *uri = "/404.htm"; - err = fs_open(&hs->file_handle, *uri); - if (err != ERR_OK) { - /* 404.htm doesn't exist either. Try 404.shtml instead. */ - *uri = "/404.shtml"; - err = fs_open(&hs->file_handle, *uri); - if (err != ERR_OK) { - /* 404.htm doesn't exist either. Indicate to the caller that it should - * send back a default 404 page. - */ - *uri = NULL; - return NULL; - } - } - } - - return &hs->file_handle; -} - -#if LWIP_HTTPD_SUPPORT_POST -static err_t -http_handle_post_finished(struct http_state *hs) -{ -#if LWIP_HTTPD_POST_MANUAL_WND - /* Prevent multiple calls to httpd_post_finished, since it might have already - been called before from httpd_post_data_recved(). */ - if (hs->post_finished) { - return ERR_OK; - } - hs->post_finished = 1; -#endif /* LWIP_HTTPD_POST_MANUAL_WND */ - /* application error or POST finished */ - /* NULL-terminate the buffer */ - http_uri_buf[0] = 0; - httpd_post_finished(hs, http_uri_buf, LWIP_HTTPD_URI_BUF_LEN); - return http_find_file(hs, http_uri_buf, 0); -} - -/** Pass received POST body data to the application and correctly handle - * returning a response document or closing the connection. - * ATTENTION: The application is responsible for the pbuf now, so don't free it! - * - * @param hs http connection state - * @param p pbuf to pass to the application - * @return ERR_OK if passed successfully, another err_t if the response file - * hasn't been found (after POST finished) - */ -static err_t -http_post_rxpbuf(struct http_state *hs, struct pbuf *p) -{ - err_t err; - - if (p != NULL) { - /* adjust remaining Content-Length */ - if (hs->post_content_len_left < p->tot_len) { - hs->post_content_len_left = 0; - } else { - hs->post_content_len_left -= p->tot_len; - } - } -#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND - /* prevent connection being closed if httpd_post_data_recved() is called nested */ - hs->unrecved_bytes++; -#endif - if (p != NULL) { - err = httpd_post_receive_data(hs, p); - } else { - err = ERR_OK; - } -#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND - hs->unrecved_bytes--; -#endif - if (err != ERR_OK) { - /* Ignore remaining content in case of application error */ - hs->post_content_len_left = 0; - } - if (hs->post_content_len_left == 0) { -#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND - if (hs->unrecved_bytes != 0) { - return ERR_OK; - } -#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */ - /* application error or POST finished */ - return http_handle_post_finished(hs); - } - - return ERR_OK; -} - -/** Handle a post request. Called from http_parse_request when method 'POST' - * is found. - * - * @param p The input pbuf (containing the POST header and body). - * @param hs The http connection state. - * @param data HTTP request (header and part of body) from input pbuf(s). - * @param data_len Size of 'data'. - * @param uri The HTTP URI parsed from input pbuf(s). - * @param uri_end Pointer to the end of 'uri' (here, the rest of the HTTP - * header starts). - * @return ERR_OK: POST correctly parsed and accepted by the application. - * ERR_INPROGRESS: POST not completely parsed (no error yet) - * another err_t: Error parsing POST or denied by the application - */ -static err_t -http_post_request(struct pbuf *inp, struct http_state *hs, - char *data, u16_t data_len, char *uri, char *uri_end) -{ - err_t err; - /* search for end-of-header (first double-CRLF) */ - char *crlfcrlf = lwip_strnstr(uri_end + 1, CRLF CRLF, data_len - (uri_end + 1 - data)); - - if (crlfcrlf != NULL) { - /* search for "Content-Length: " */ -#define HTTP_HDR_CONTENT_LEN "Content-Length: " -#define HTTP_HDR_CONTENT_LEN_LEN 16 -#define HTTP_HDR_CONTENT_LEN_DIGIT_MAX_LEN 10 - char *scontent_len = lwip_strnstr(uri_end + 1, HTTP_HDR_CONTENT_LEN, crlfcrlf - (uri_end + 1)); - if (scontent_len != NULL) { - char *scontent_len_end = lwip_strnstr(scontent_len + HTTP_HDR_CONTENT_LEN_LEN, CRLF, HTTP_HDR_CONTENT_LEN_DIGIT_MAX_LEN); - if (scontent_len_end != NULL) { - int content_len; - char *content_len_num = scontent_len + HTTP_HDR_CONTENT_LEN_LEN; - content_len = atoi(content_len_num); - if (content_len == 0) { - /* if atoi returns 0 on error, fix this */ - if ((content_len_num[0] != '0') || (content_len_num[1] != '\r')) { - content_len = -1; - } - } - if (content_len >= 0) { - /* adjust length of HTTP header passed to application */ - const char *hdr_start_after_uri = uri_end + 1; - u16_t hdr_len = (u16_t)LWIP_MIN(data_len, crlfcrlf + 4 - data); - u16_t hdr_data_len = (u16_t)LWIP_MIN(data_len, crlfcrlf + 4 - hdr_start_after_uri); - u8_t post_auto_wnd = 1; - http_uri_buf[0] = 0; - /* trim http header */ - *crlfcrlf = 0; - err = httpd_post_begin(hs, uri, hdr_start_after_uri, hdr_data_len, content_len, - http_uri_buf, LWIP_HTTPD_URI_BUF_LEN, &post_auto_wnd); - if (err == ERR_OK) { - /* try to pass in data of the first pbuf(s) */ - struct pbuf *q = inp; - u16_t start_offset = hdr_len; -#if LWIP_HTTPD_POST_MANUAL_WND - hs->no_auto_wnd = !post_auto_wnd; -#endif /* LWIP_HTTPD_POST_MANUAL_WND */ - /* set the Content-Length to be received for this POST */ - hs->post_content_len_left = (u32_t)content_len; - - /* get to the pbuf where the body starts */ - while ((q != NULL) && (q->len <= start_offset)) { - start_offset -= q->len; - q = q->next; - } - if (q != NULL) { - /* hide the remaining HTTP header */ - pbuf_remove_header(q, start_offset); -#if LWIP_HTTPD_POST_MANUAL_WND - if (!post_auto_wnd) { - /* already tcp_recved() this data... */ - hs->unrecved_bytes = q->tot_len; - } -#endif /* LWIP_HTTPD_POST_MANUAL_WND */ - pbuf_ref(q); - return http_post_rxpbuf(hs, q); - } else if (hs->post_content_len_left == 0) { - q = pbuf_alloc(PBUF_RAW, 0, PBUF_REF); - return http_post_rxpbuf(hs, q); - } else { - return ERR_OK; - } - } else { - /* return file passed from application */ - return http_find_file(hs, http_uri_buf, 0); - } - } else { - LWIP_DEBUGF(HTTPD_DEBUG, ("POST received invalid Content-Length: %s\n", - content_len_num)); - return ERR_ARG; - } - } - } - /* If we come here, headers are fully received (double-crlf), but Content-Length - was not included. Since this is currently the only supported method, we have - to fail in this case! */ - LWIP_DEBUGF(HTTPD_DEBUG, ("Error when parsing Content-Length\n")); - return ERR_ARG; - } - /* if we come here, the POST is incomplete */ -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - return ERR_INPROGRESS; -#else /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - return ERR_ARG; -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ -} - -#if LWIP_HTTPD_POST_MANUAL_WND -/** - * @ingroup httpd - * A POST implementation can call this function to update the TCP window. - * This can be used to throttle data reception (e.g. when received data is - * programmed to flash and data is received faster than programmed). - * - * @param connection A connection handle passed to httpd_post_begin for which - * httpd_post_finished has *NOT* been called yet! - * @param recved_len Length of data received (for window update) - */ -void httpd_post_data_recved(void *connection, u16_t recved_len) -{ - struct http_state *hs = (struct http_state *)connection; - if (hs != NULL) { - if (hs->no_auto_wnd) { - u16_t len = recved_len; - if (hs->unrecved_bytes >= recved_len) { - hs->unrecved_bytes -= recved_len; - } else { - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_LEVEL_WARNING, ("httpd_post_data_recved: recved_len too big\n")); - len = (u16_t)hs->unrecved_bytes; - hs->unrecved_bytes = 0; - } - if (hs->pcb != NULL) { - if (len != 0) { - altcp_recved(hs->pcb, len); - } - if ((hs->post_content_len_left == 0) && (hs->unrecved_bytes == 0)) { - /* finished handling POST */ - http_handle_post_finished(hs); - http_send(hs->pcb, hs); - } - } - } - } -} -#endif /* LWIP_HTTPD_POST_MANUAL_WND */ - -#endif /* LWIP_HTTPD_SUPPORT_POST */ - -#if LWIP_HTTPD_FS_ASYNC_READ -/** Try to send more data if file has been blocked before - * This is a callback function passed to fs_read_async(). - */ -static void -http_continue(void *connection) -{ - struct http_state *hs = (struct http_state *)connection; - LWIP_ASSERT_CORE_LOCKED(); - if (hs && (hs->pcb) && (hs->handle)) { - LWIP_ASSERT("hs->pcb != NULL", hs->pcb != NULL); - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("httpd_continue: try to send more data\n")); - if (http_send(hs->pcb, hs)) { - /* If we wrote anything to be sent, go ahead and send it now. */ - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("tcp_output\n")); - altcp_output(hs->pcb); - } - } -} -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ - -/** - * When data has been received in the correct state, try to parse it - * as a HTTP request. - * - * @param inp the received pbuf - * @param hs the connection state - * @param pcb the altcp_pcb which received this packet - * @return ERR_OK if request was OK and hs has been initialized correctly - * ERR_INPROGRESS if request was OK so far but not fully received - * another err_t otherwise - */ -static err_t -http_parse_request(struct pbuf *inp, struct http_state *hs, struct altcp_pcb *pcb) -{ - char *data; - char *crlf; - u16_t data_len; - struct pbuf *p = inp; -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - u16_t clen; -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ -#if LWIP_HTTPD_SUPPORT_POST - err_t err; -#endif /* LWIP_HTTPD_SUPPORT_POST */ - - LWIP_UNUSED_ARG(pcb); /* only used for post */ - LWIP_ASSERT("p != NULL", p != NULL); - LWIP_ASSERT("hs != NULL", hs != NULL); - - if ((hs->handle != NULL) || (hs->file != NULL)) { - LWIP_DEBUGF(HTTPD_DEBUG, ("Received data while sending a file\n")); - /* already sending a file */ - /* @todo: abort? */ - return ERR_USE; - } - -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - - LWIP_DEBUGF(HTTPD_DEBUG, ("Received %"U16_F" bytes\n", p->tot_len)); - - /* first check allowed characters in this pbuf? */ - - /* enqueue the pbuf */ - if (hs->req == NULL) { - LWIP_DEBUGF(HTTPD_DEBUG, ("First pbuf\n")); - hs->req = p; - } else { - LWIP_DEBUGF(HTTPD_DEBUG, ("pbuf enqueued\n")); - pbuf_cat(hs->req, p); - } - /* increase pbuf ref counter as it is freed when we return but we want to - keep it on the req list */ - pbuf_ref(p); - - if (hs->req->next != NULL) { - data_len = LWIP_MIN(hs->req->tot_len, LWIP_HTTPD_MAX_REQ_LENGTH); - pbuf_copy_partial(hs->req, httpd_req_buf, data_len, 0); - data = httpd_req_buf; - } else -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - { - data = (char *)p->payload; - data_len = p->len; - if (p->len != p->tot_len) { - LWIP_DEBUGF(HTTPD_DEBUG, ("Warning: incomplete header due to chained pbufs\n")); - } - } - - /* received enough data for minimal request? */ - if (data_len >= MIN_REQ_LEN) { - /* wait for CRLF before parsing anything */ - crlf = lwip_strnstr(data, CRLF, data_len); - if (crlf != NULL) { -#if LWIP_HTTPD_SUPPORT_POST - int is_post = 0; -#endif /* LWIP_HTTPD_SUPPORT_POST */ - int is_09 = 0; - char *sp1, *sp2; - u16_t left_len, uri_len; - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("CRLF received, parsing request\n")); - /* parse method */ - if (!strncmp(data, "GET ", 4)) { - sp1 = data + 3; - /* received GET request */ - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Received GET request\"\n")); -#if LWIP_HTTPD_SUPPORT_POST - } else if (!strncmp(data, "POST ", 5)) { - /* store request type */ - is_post = 1; - sp1 = data + 4; - /* received GET request */ - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Received POST request\n")); -#endif /* LWIP_HTTPD_SUPPORT_POST */ - } else { - /* null-terminate the METHOD (pbuf is freed anyway wen returning) */ - data[4] = 0; - /* unsupported method! */ - LWIP_DEBUGF(HTTPD_DEBUG, ("Unsupported request method (not implemented): \"%s\"\n", - data)); - return http_find_error_file(hs, 501); - } - /* if we come here, method is OK, parse URI */ - left_len = (u16_t)(data_len - ((sp1 + 1) - data)); - sp2 = lwip_strnstr(sp1 + 1, " ", left_len); -#if LWIP_HTTPD_SUPPORT_V09 - if (sp2 == NULL) { - /* HTTP 0.9: respond with correct protocol version */ - sp2 = lwip_strnstr(sp1 + 1, CRLF, left_len); - is_09 = 1; -#if LWIP_HTTPD_SUPPORT_POST - if (is_post) { - /* HTTP/0.9 does not support POST */ - goto badrequest; - } -#endif /* LWIP_HTTPD_SUPPORT_POST */ - } -#endif /* LWIP_HTTPD_SUPPORT_V09 */ - uri_len = (u16_t)(sp2 - (sp1 + 1)); - if ((sp2 != 0) && (sp2 > sp1)) { - /* wait for CRLFCRLF (indicating end of HTTP headers) before parsing anything */ - if (lwip_strnstr(data, CRLF CRLF, data_len) != NULL) { - char *uri = sp1 + 1; -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - /* This is HTTP/1.0 compatible: for strict 1.1, a connection - would always be persistent unless "close" was specified. */ - if (!is_09 && (lwip_strnstr(data, HTTP11_CONNECTIONKEEPALIVE, data_len) || - lwip_strnstr(data, HTTP11_CONNECTIONKEEPALIVE2, data_len))) { - hs->keepalive = 1; - } else { - hs->keepalive = 0; - } -#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ - /* null-terminate the METHOD (pbuf is freed anyway wen returning) */ - *sp1 = 0; - uri[uri_len] = 0; - LWIP_DEBUGF(HTTPD_DEBUG, ("Received \"%s\" request for URI: \"%s\"\n", - data, uri)); -#if LWIP_HTTPD_SUPPORT_POST - if (is_post) { -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - struct pbuf *q = hs->req; -#else /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - struct pbuf *q = inp; -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - err = http_post_request(q, hs, data, data_len, uri, sp2); - if (err != ERR_OK) { - /* restore header for next try */ - *sp1 = ' '; - *sp2 = ' '; - uri[uri_len] = ' '; - } - if (err == ERR_ARG) { - goto badrequest; - } - return err; - } else -#endif /* LWIP_HTTPD_SUPPORT_POST */ - { - return http_find_file(hs, uri, is_09); - } - } - } else { - LWIP_DEBUGF(HTTPD_DEBUG, ("invalid URI\n")); - } - } - } - -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - clen = pbuf_clen(hs->req); - if ((hs->req->tot_len <= LWIP_HTTPD_REQ_BUFSIZE) && - (clen <= LWIP_HTTPD_REQ_QUEUELEN)) { - /* request not fully received (too short or CRLF is missing) */ - return ERR_INPROGRESS; - } else -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - { -#if LWIP_HTTPD_SUPPORT_POST -badrequest: -#endif /* LWIP_HTTPD_SUPPORT_POST */ - LWIP_DEBUGF(HTTPD_DEBUG, ("bad request\n")); - /* could not parse request */ - return http_find_error_file(hs, 400); - } -} - -#if LWIP_HTTPD_SSI && (LWIP_HTTPD_SSI_BY_FILE_EXTENSION == 1) -/* Check if SSI should be parsed for this file/URL - * (With LWIP_HTTPD_SSI_BY_FILE_EXTENSION == 2, this function can be - * overridden by an external implementation.) - * - * @return 1 for SSI, 0 for standard files - */ -static u8_t -http_uri_is_ssi(struct fs_file *file, const char *uri) -{ - size_t loop; - u8_t tag_check = 0; - if (file != NULL) { - /* See if we have been asked for an shtml file and, if so, - enable tag checking. */ - const char *ext = NULL, *sub; - char *param = (char *)strstr(uri, "?"); - if (param != NULL) { - /* separate uri from parameters for now, set back later */ - *param = 0; - } - sub = uri; - ext = uri; - for (sub = strstr(sub, "."); sub != NULL; sub = strstr(sub, ".")) { - ext = sub; - sub++; - } - for (loop = 0; loop < NUM_SHTML_EXTENSIONS; loop++) { - if (!lwip_stricmp(ext, g_pcSSIExtensions[loop])) { - tag_check = 1; - break; - } - } - if (param != NULL) { - *param = '?'; - } - } - return tag_check; -} -#endif /* LWIP_HTTPD_SSI */ - -/** Try to find the file specified by uri and, if found, initialize hs - * accordingly. - * - * @param hs the connection state - * @param uri the HTTP header URI - * @param is_09 1 if the request is HTTP/0.9 (no HTTP headers in response) - * @return ERR_OK if file was found and hs has been initialized correctly - * another err_t otherwise - */ -static err_t -http_find_file(struct http_state *hs, const char *uri, int is_09) -{ - size_t loop; - struct fs_file *file = NULL; - char *params = NULL; - err_t err; -#if LWIP_HTTPD_CGI - int i; -#endif /* LWIP_HTTPD_CGI */ -#if !LWIP_HTTPD_SSI - const -#endif /* !LWIP_HTTPD_SSI */ - /* By default, assume we will not be processing server-side-includes tags */ - u8_t tag_check = 0; - - /* Have we been asked for the default file (in root or a directory) ? */ -#if LWIP_HTTPD_MAX_REQUEST_URI_LEN - size_t uri_len = strlen(uri); - if ((uri_len > 0) && (uri[uri_len - 1] == '/') && - ((uri != http_uri_buf) || (uri_len == 1))) { - size_t copy_len = LWIP_MIN(sizeof(http_uri_buf) - 1, uri_len - 1); - if (copy_len > 0) { - MEMCPY(http_uri_buf, uri, copy_len); - http_uri_buf[copy_len] = 0; - } -#else /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */ - if ((uri[0] == '/') && (uri[1] == 0)) { -#endif /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */ - /* Try each of the configured default filenames until we find one - that exists. */ - for (loop = 0; loop < NUM_DEFAULT_FILENAMES; loop++) { - const char *file_name; -#if LWIP_HTTPD_MAX_REQUEST_URI_LEN - if (copy_len > 0) { - size_t len_left = sizeof(http_uri_buf) - copy_len - 1; - if (len_left > 0) { - size_t name_len = strlen(httpd_default_filenames[loop].name); - size_t name_copy_len = LWIP_MIN(len_left, name_len); - MEMCPY(&http_uri_buf[copy_len], httpd_default_filenames[loop].name, name_copy_len); - http_uri_buf[copy_len + name_copy_len] = 0; - } - file_name = http_uri_buf; - } else -#endif /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */ - { - file_name = httpd_default_filenames[loop].name; - } - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Looking for %s...\n", file_name)); - err = fs_open(&hs->file_handle, file_name); - if (err == ERR_OK) { - uri = file_name; - file = &hs->file_handle; - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Opened.\n")); -#if LWIP_HTTPD_SSI - tag_check = httpd_default_filenames[loop].shtml; -#endif /* LWIP_HTTPD_SSI */ - break; - } - } - } - if (file == NULL) { - /* No - we've been asked for a specific file. */ - /* First, isolate the base URI (without any parameters) */ - params = (char *)strchr(uri, '?'); - if (params != NULL) { - /* URI contains parameters. NULL-terminate the base URI */ - *params = '\0'; - params++; - } - -#if LWIP_HTTPD_CGI - http_cgi_paramcount = -1; - /* Does the base URI we have isolated correspond to a CGI handler? */ - if (httpd_num_cgis && httpd_cgis) { - for (i = 0; i < httpd_num_cgis; i++) { - if (strcmp(uri, httpd_cgis[i].pcCGIName) == 0) { - /* - * We found a CGI that handles this URI so extract the - * parameters and call the handler. - */ - http_cgi_paramcount = extract_uri_parameters(hs, params); - uri = httpd_cgis[i].pfnCGIHandler(i, http_cgi_paramcount, hs->params, - hs->param_vals); - break; - } - } - } -#endif /* LWIP_HTTPD_CGI */ - - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Opening %s\n", uri)); - - err = fs_open(&hs->file_handle, uri); - if (err == ERR_OK) { - file = &hs->file_handle; - } else { - file = http_get_404_file(hs, &uri); - } -#if LWIP_HTTPD_SSI - if (file != NULL) { - if (file->flags & FS_FILE_FLAGS_SSI) { - tag_check = 1; - } else { -#if LWIP_HTTPD_SSI_BY_FILE_EXTENSION - tag_check = http_uri_is_ssi(file, uri); -#endif /* LWIP_HTTPD_SSI_BY_FILE_EXTENSION */ - } - } -#endif /* LWIP_HTTPD_SSI */ - } - if (file == NULL) { - /* None of the default filenames exist so send back a 404 page */ - file = http_get_404_file(hs, &uri); - } - return http_init_file(hs, file, is_09, uri, tag_check, params); -} - -/** Initialize a http connection with a file to send (if found). - * Called by http_find_file and http_find_error_file. - * - * @param hs http connection state - * @param file file structure to send (or NULL if not found) - * @param is_09 1 if the request is HTTP/0.9 (no HTTP headers in response) - * @param uri the HTTP header URI - * @param tag_check enable SSI tag checking - * @param params != NULL if URI has parameters (separated by '?') - * @return ERR_OK if file was found and hs has been initialized correctly - * another err_t otherwise - */ -static err_t -http_init_file(struct http_state *hs, struct fs_file *file, int is_09, const char *uri, - u8_t tag_check, char *params) -{ -#if !LWIP_HTTPD_SUPPORT_V09 - LWIP_UNUSED_ARG(is_09); -#endif - if (file != NULL) { - /* file opened, initialise struct http_state */ -#if !LWIP_HTTPD_DYNAMIC_FILE_READ - /* If dynamic read is disabled, file data must be in one piece and available now */ - LWIP_ASSERT("file->data != NULL", file->data != NULL); -#endif - -#if LWIP_HTTPD_SSI - if (tag_check) { - struct http_ssi_state *ssi = http_ssi_state_alloc(); - if (ssi != NULL) { - ssi->tag_index = 0; - ssi->tag_state = TAG_NONE; - ssi->parsed = file->data; - ssi->parse_left = file->len; - ssi->tag_end = file->data; - hs->ssi = ssi; - } - } -#else /* LWIP_HTTPD_SSI */ - LWIP_UNUSED_ARG(tag_check); -#endif /* LWIP_HTTPD_SSI */ - hs->handle = file; -#if LWIP_HTTPD_CGI_SSI - if (params != NULL) { - /* URI contains parameters, call generic CGI handler */ - int count; -#if LWIP_HTTPD_CGI - if (http_cgi_paramcount >= 0) { - count = http_cgi_paramcount; - } else -#endif - { - count = extract_uri_parameters(hs, params); - } - httpd_cgi_handler(file, uri, count, http_cgi_params, http_cgi_param_vals -#if defined(LWIP_HTTPD_FILE_STATE) && LWIP_HTTPD_FILE_STATE - , file->state -#endif /* LWIP_HTTPD_FILE_STATE */ - ); - } -#else /* LWIP_HTTPD_CGI_SSI */ - LWIP_UNUSED_ARG(params); -#endif /* LWIP_HTTPD_CGI_SSI */ - hs->file = file->data; - LWIP_ASSERT("File length must be positive!", (file->len >= 0)); -#if LWIP_HTTPD_CUSTOM_FILES - if (file->is_custom_file && (file->data == NULL)) { - /* custom file, need to read data first (via fs_read_custom) */ - hs->left = 0; - } else -#endif /* LWIP_HTTPD_CUSTOM_FILES */ - { - hs->left = (u32_t)file->len; - } - hs->retries = 0; -#if LWIP_HTTPD_TIMING - hs->time_started = sys_now(); -#endif /* LWIP_HTTPD_TIMING */ -#if !LWIP_HTTPD_DYNAMIC_HEADERS - LWIP_ASSERT("HTTP headers not included in file system", - (hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) != 0); -#endif /* !LWIP_HTTPD_DYNAMIC_HEADERS */ -#if LWIP_HTTPD_SUPPORT_V09 - if (is_09 && ((hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) != 0)) { - /* HTTP/0.9 responses are sent without HTTP header, - search for the end of the header. */ - char *file_start = lwip_strnstr(hs->file, CRLF CRLF, hs->left); - if (file_start != NULL) { - int diff = file_start + 4 - hs->file; - hs->file += diff; - hs->left -= (u32_t)diff; - } - } -#endif /* LWIP_HTTPD_SUPPORT_V09*/ - } else { - hs->handle = NULL; - hs->file = NULL; - hs->left = 0; - hs->retries = 0; - } -#if LWIP_HTTPD_DYNAMIC_HEADERS - /* Determine the HTTP headers to send based on the file extension of - * the requested URI. */ - if ((hs->handle == NULL) || ((hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) == 0)) { - get_http_headers(hs, uri); - } -#else /* LWIP_HTTPD_DYNAMIC_HEADERS */ - LWIP_UNUSED_ARG(uri); -#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - if (hs->keepalive) { -#if LWIP_HTTPD_SSI - if (hs->ssi != NULL) { - hs->keepalive = 0; - } else -#endif /* LWIP_HTTPD_SSI */ - { - if ((hs->handle != NULL) && - ((hs->handle->flags & (FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT)) == FS_FILE_FLAGS_HEADER_INCLUDED)) { - hs->keepalive = 0; - } - } - } -#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ - return ERR_OK; -} - -/** - * The pcb had an error and is already deallocated. - * The argument might still be valid (if != NULL). - */ -static void -http_err(void *arg, err_t err) -{ - struct http_state *hs = (struct http_state *)arg; - LWIP_UNUSED_ARG(err); - - LWIP_DEBUGF(HTTPD_DEBUG, ("http_err: %s", lwip_strerr(err))); - - if (hs != NULL) { - http_state_free(hs); - } -} - -/** - * Data has been sent and acknowledged by the remote host. - * This means that more data can be sent. - */ -static err_t -http_sent(void *arg, struct altcp_pcb *pcb, u16_t len) -{ - struct http_state *hs = (struct http_state *)arg; - - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_sent %p\n", (void *)pcb)); - - LWIP_UNUSED_ARG(len); - - if (hs == NULL) { - return ERR_OK; - } - - hs->retries = 0; - - http_send(pcb, hs); - - return ERR_OK; -} - -/** - * The poll function is called every 2nd second. - * If there has been no data sent (which resets the retries) in 8 seconds, close. - * If the last portion of a file has not been sent in 2 seconds, close. - * - * This could be increased, but we don't want to waste resources for bad connections. - */ -static err_t -http_poll(void *arg, struct altcp_pcb *pcb) -{ - struct http_state *hs = (struct http_state *)arg; - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_poll: pcb=%p hs=%p pcb_state=%s\n", - (void *)pcb, (void *)hs, tcp_debug_state_str(altcp_dbg_get_tcp_state(pcb)))); - - if (hs == NULL) { - err_t closed; - /* arg is null, close. */ - LWIP_DEBUGF(HTTPD_DEBUG, ("http_poll: arg is NULL, close\n")); - closed = http_close_conn(pcb, NULL); - LWIP_UNUSED_ARG(closed); -#if LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR - if (closed == ERR_MEM) { - altcp_abort(pcb); - return ERR_ABRT; - } -#endif /* LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR */ - return ERR_OK; - } else { - hs->retries++; - if (hs->retries == HTTPD_MAX_RETRIES) { - LWIP_DEBUGF(HTTPD_DEBUG, ("http_poll: too many retries, close\n")); - http_close_conn(pcb, hs); - return ERR_OK; - } - - /* If this connection has a file open, try to send some more data. If - * it has not yet received a GET request, don't do this since it will - * cause the connection to close immediately. */ - if (hs->handle) { - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_poll: try to send more data\n")); - if (http_send(pcb, hs)) { - /* If we wrote anything to be sent, go ahead and send it now. */ - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("tcp_output\n")); - altcp_output(pcb); - } - } - } - - return ERR_OK; -} - -/** - * Data has been received on this pcb. - * For HTTP 1.0, this should normally only happen once (if the request fits in one packet). - */ -static err_t -http_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) -{ - struct http_state *hs = (struct http_state *)arg; - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_recv: pcb=%p pbuf=%p err=%s\n", (void *)pcb, - (void *)p, lwip_strerr(err))); - - if ((err != ERR_OK) || (p == NULL) || (hs == NULL)) { - /* error or closed by other side? */ - if (p != NULL) { - /* Inform TCP that we have taken the data. */ - altcp_recved(pcb, p->tot_len); - pbuf_free(p); - } - if (hs == NULL) { - /* this should not happen, only to be robust */ - LWIP_DEBUGF(HTTPD_DEBUG, ("Error, http_recv: hs is NULL, close\n")); - } - http_close_conn(pcb, hs); - return ERR_OK; - } - -#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND - if (hs->no_auto_wnd) { - hs->unrecved_bytes += p->tot_len; - } else -#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */ - { - /* Inform TCP that we have taken the data. */ - altcp_recved(pcb, p->tot_len); - } - -#if LWIP_HTTPD_SUPPORT_POST - if (hs->post_content_len_left > 0) { - /* reset idle counter when POST data is received */ - hs->retries = 0; - /* this is data for a POST, pass the complete pbuf to the application */ - http_post_rxpbuf(hs, p); - /* pbuf is passed to the application, don't free it! */ - if (hs->post_content_len_left == 0) { - /* all data received, send response or close connection */ - http_send(pcb, hs); - } - return ERR_OK; - } else -#endif /* LWIP_HTTPD_SUPPORT_POST */ - { - if (hs->handle == NULL) { - err_t parsed = http_parse_request(p, hs, pcb); - LWIP_ASSERT("http_parse_request: unexpected return value", parsed == ERR_OK - || parsed == ERR_INPROGRESS || parsed == ERR_ARG || parsed == ERR_USE); -#if LWIP_HTTPD_SUPPORT_REQUESTLIST - if (parsed != ERR_INPROGRESS) { - /* request fully parsed or error */ - if (hs->req != NULL) { - pbuf_free(hs->req); - hs->req = NULL; - } - } -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - pbuf_free(p); - if (parsed == ERR_OK) { -#if LWIP_HTTPD_SUPPORT_POST - if (hs->post_content_len_left == 0) -#endif /* LWIP_HTTPD_SUPPORT_POST */ - { - LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_recv: data %p len %"S32_F"\n", (const void *)hs->file, hs->left)); - http_send(pcb, hs); - } - } else if (parsed == ERR_ARG) { - /* @todo: close on ERR_USE? */ - http_close_conn(pcb, hs); - } - } else { - LWIP_DEBUGF(HTTPD_DEBUG, ("http_recv: already sending data\n")); - /* already sending but still receiving data, we might want to RST here? */ - pbuf_free(p); - } - } - return ERR_OK; -} - -/** - * A new incoming connection has been accepted. - */ -static err_t -http_accept(void *arg, struct altcp_pcb *pcb, err_t err) -{ - struct http_state *hs; - LWIP_UNUSED_ARG(err); - LWIP_UNUSED_ARG(arg); - LWIP_DEBUGF(HTTPD_DEBUG, ("http_accept %p / %p\n", (void *)pcb, arg)); - - if ((err != ERR_OK) || (pcb == NULL)) { - return ERR_VAL; - } - - /* Set priority */ - altcp_setprio(pcb, HTTPD_TCP_PRIO); - - /* Allocate memory for the structure that holds the state of the - connection - initialized by that function. */ - hs = http_state_alloc(); - if (hs == NULL) { - LWIP_DEBUGF(HTTPD_DEBUG, ("http_accept: Out of memory, RST\n")); - return ERR_MEM; - } - hs->pcb = pcb; - - /* Tell TCP that this is the structure we wish to be passed for our - callbacks. */ - altcp_arg(pcb, hs); - - /* Set up the various callback functions */ - altcp_recv(pcb, http_recv); - altcp_err(pcb, http_err); - altcp_poll(pcb, http_poll, HTTPD_POLL_INTERVAL); - altcp_sent(pcb, http_sent); - - return ERR_OK; -} - -static void -httpd_init_pcb(struct altcp_pcb *pcb, u16_t port) -{ - err_t err; - - if (pcb) { - altcp_setprio(pcb, HTTPD_TCP_PRIO); - /* set SOF_REUSEADDR here to explicitly bind httpd to multiple interfaces */ - err = altcp_bind(pcb, IP_ANY_TYPE, port); - LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */ - LWIP_ASSERT("httpd_init: tcp_bind failed", err == ERR_OK); - pcb = altcp_listen(pcb); - LWIP_ASSERT("httpd_init: tcp_listen failed", pcb != NULL); - altcp_accept(pcb, http_accept); - } -} - -/** - * @ingroup httpd - * Initialize the httpd: set up a listening PCB and bind it to the defined port - */ -void -httpd_init(void) -{ - struct altcp_pcb *pcb; - -#if HTTPD_USE_MEM_POOL - LWIP_MEMPOOL_INIT(HTTPD_STATE); -#if LWIP_HTTPD_SSI - LWIP_MEMPOOL_INIT(HTTPD_SSI_STATE); -#endif -#endif - LWIP_DEBUGF(HTTPD_DEBUG, ("httpd_init\n")); - - /* LWIP_ASSERT_CORE_LOCKED(); is checked by tcp_new() */ - - pcb = altcp_tcp_new_ip_type(IPADDR_TYPE_ANY); - LWIP_ASSERT("httpd_init: tcp_new failed", pcb != NULL); - httpd_init_pcb(pcb, HTTPD_SERVER_PORT); -} - -#if HTTPD_ENABLE_HTTPS -/** - * @ingroup httpd - * Initialize the httpd: set up a listening PCB and bind it to the defined port. - * Also set up TLS connection handling (HTTPS). - */ -void -httpd_inits(struct altcp_tls_config *conf) -{ -#if LWIP_ALTCP_TLS - struct altcp_pcb *pcb_tls = altcp_tls_new(conf, IPADDR_TYPE_ANY); - LWIP_ASSERT("httpd_init: altcp_tls_new failed", pcb_tls != NULL); - httpd_init_pcb(pcb_tls, HTTPD_SERVER_PORT_HTTPS); -#else /* LWIP_ALTCP_TLS */ - LWIP_UNUSED_ARG(conf); -#endif /* LWIP_ALTCP_TLS */ -} -#endif /* HTTPD_ENABLE_HTTPS */ - -#if LWIP_HTTPD_SSI -/** - * @ingroup httpd - * Set the SSI handler function. - * - * @param ssi_handler the SSI handler function - * @param tags an array of SSI tag strings to search for in SSI-enabled files - * @param num_tags number of tags in the 'tags' array - */ -void -http_set_ssi_handler(tSSIHandler ssi_handler, const char **tags, int num_tags) -{ - LWIP_DEBUGF(HTTPD_DEBUG, ("http_set_ssi_handler\n")); - - LWIP_ASSERT("no ssi_handler given", ssi_handler != NULL); - httpd_ssi_handler = ssi_handler; - -#if LWIP_HTTPD_SSI_RAW - LWIP_UNUSED_ARG(tags); - LWIP_UNUSED_ARG(num_tags); -#else /* LWIP_HTTPD_SSI_RAW */ - LWIP_ASSERT("no tags given", tags != NULL); - LWIP_ASSERT("invalid number of tags", num_tags > 0); - - httpd_tags = tags; - httpd_num_tags = num_tags; -#endif /* !LWIP_HTTPD_SSI_RAW */ -} -#endif /* LWIP_HTTPD_SSI */ - -#if LWIP_HTTPD_CGI -/** - * @ingroup httpd - * Set an array of CGI filenames/handler functions - * - * @param cgis an array of CGI filenames/handler functions - * @param num_handlers number of elements in the 'cgis' array - */ -void -http_set_cgi_handlers(const tCGI *cgis, int num_handlers) -{ - LWIP_ASSERT("no cgis given", cgis != NULL); - LWIP_ASSERT("invalid number of handlers", num_handlers > 0); - - httpd_cgis = cgis; - httpd_num_cgis = num_handlers; -} -#endif /* LWIP_HTTPD_CGI */ - -#endif /* LWIP_TCP && LWIP_CALLBACK_API */ +/** + * @file + * LWIP HTTP server implementation + */ + +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * Simon Goldschmidt + * + */ + +/** + * @defgroup httpd HTTP server + * @ingroup apps + * + * This httpd supports for a + * rudimentary server-side-include facility which will replace tags of the form + * in any file whose extension is .shtml, .shtm or .ssi with + * strings provided by an include handler whose pointer is provided to the + * module via function http_set_ssi_handler(). + * Additionally, a simple common + * gateway interface (CGI) handling mechanism has been added to allow clients + * to hook functions to particular request URIs. + * + * To enable SSI support, define label LWIP_HTTPD_SSI in lwipopts.h. + * To enable CGI support, define label LWIP_HTTPD_CGI in lwipopts.h. + * + * By default, the server assumes that HTTP headers are already present in + * each file stored in the file system. By defining LWIP_HTTPD_DYNAMIC_HEADERS in + * lwipopts.h, this behavior can be changed such that the server inserts the + * headers automatically based on the extension of the file being served. If + * this mode is used, be careful to ensure that the file system image used + * does not already contain the header information. + * + * File system images without headers can be created using the makefsfile + * tool with the -h command line option. + * + * + * Notes about valid SSI tags + * -------------------------- + * + * The following assumptions are made about tags used in SSI markers: + * + * 1. No tag may contain '-' or whitespace characters within the tag name. + * 2. Whitespace is allowed between the tag leadin "". + * 3. The maximum tag name length is LWIP_HTTPD_MAX_TAG_NAME_LEN, currently 8 characters. + * + * Notes on CGI usage + * ------------------ + * + * The simple CGI support offered here works with GET method requests only + * and can handle up to 16 parameters encoded into the URI. The handler + * function may not write directly to the HTTP output but must return a + * filename that the HTTP server will send to the browser as a response to + * the incoming CGI request. + * + * + * + * The list of supported file types is quite short, so if makefsdata complains + * about an unknown extension, make sure to add it (and its doctype) to + * the 'g_psHTTPHeaders' list. + */ +#include "lwip/init.h" +#include "lwip/apps/httpd.h" +#include "lwip/debug.h" +#include "lwip/stats.h" +#include "lwip/apps/fs.h" +#include "httpd_structs.h" +#include "lwip/def.h" + +#include "lwip/altcp.h" +#include "lwip/altcp_tcp.h" +#if HTTPD_ENABLE_HTTPS +#include "lwip/altcp_tls.h" +#endif +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif +#if LWIP_HTTPD_TIMING +#include "lwip/sys.h" +#endif /* LWIP_HTTPD_TIMING */ + +#include /* memset */ +#include /* atoi */ +#include + +#if LWIP_TCP && LWIP_CALLBACK_API + +/** Minimum length for a valid HTTP/0.9 request: "GET /\r\n" -> 7 bytes */ +#define MIN_REQ_LEN 7 + +#define CRLF "\r\n" +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE +#define HTTP11_CONNECTIONKEEPALIVE "Connection: keep-alive" +#define HTTP11_CONNECTIONKEEPALIVE2 "Connection: Keep-Alive" +#endif + +#if LWIP_HTTPD_DYNAMIC_FILE_READ +#define HTTP_IS_DYNAMIC_FILE(hs) ((hs)->buf != NULL) +#else +#define HTTP_IS_DYNAMIC_FILE(hs) 0 +#endif + +/* This defines checks whether tcp_write has to copy data or not */ + +#ifndef HTTP_IS_DATA_VOLATILE +/** tcp_write does not have to copy data when sent from rom-file-system directly */ +#define HTTP_IS_DATA_VOLATILE(hs) (HTTP_IS_DYNAMIC_FILE(hs) ? TCP_WRITE_FLAG_COPY : 0) +#endif +/** Default: dynamic headers are sent from ROM (non-dynamic headers are handled like file data) */ +#ifndef HTTP_IS_HDR_VOLATILE +#define HTTP_IS_HDR_VOLATILE(hs, ptr) 0 +#endif + +/* Return values for http_send_*() */ +#define HTTP_DATA_TO_SEND_FREED 3 +#define HTTP_DATA_TO_SEND_BREAK 2 +#define HTTP_DATA_TO_SEND_CONTINUE 1 +#define HTTP_NO_DATA_TO_SEND 0 + +typedef struct { + const char *name; + u8_t shtml; +} default_filename; + +static const default_filename httpd_default_filenames[] = { + {"/index.shtml", 1 }, + {"/index.ssi", 1 }, + {"/index.shtm", 1 }, + {"/index.html", 0 }, + {"/index.htm", 0 } +}; + +#define NUM_DEFAULT_FILENAMES LWIP_ARRAYSIZE(httpd_default_filenames) + +#if LWIP_HTTPD_SUPPORT_REQUESTLIST +/** HTTP request is copied here from pbufs for simple parsing */ +static char httpd_req_buf[LWIP_HTTPD_MAX_REQ_LENGTH + 1]; +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + +#if LWIP_HTTPD_SUPPORT_POST +#if LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN > LWIP_HTTPD_MAX_REQUEST_URI_LEN +#define LWIP_HTTPD_URI_BUF_LEN LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN +#endif +#endif +#ifndef LWIP_HTTPD_URI_BUF_LEN +#define LWIP_HTTPD_URI_BUF_LEN LWIP_HTTPD_MAX_REQUEST_URI_LEN +#endif +#if LWIP_HTTPD_URI_BUF_LEN +/* Filename for response file to send when POST is finished or + * search for default files when a directory is requested. */ +static char http_uri_buf[LWIP_HTTPD_URI_BUF_LEN + 1]; +#endif + +#if LWIP_HTTPD_DYNAMIC_HEADERS +/* The number of individual strings that comprise the headers sent before each + * requested file. + */ +#define NUM_FILE_HDR_STRINGS 5 +#define HDR_STRINGS_IDX_HTTP_STATUS 0 /* e.g. "HTTP/1.0 200 OK\r\n" */ +#define HDR_STRINGS_IDX_SERVER_NAME 1 /* e.g. "Server: "HTTPD_SERVER_AGENT"\r\n" */ +#define HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE 2 /* e.g. "Content-Length: xy\r\n" and/or "Connection: keep-alive\r\n" */ +#define HDR_STRINGS_IDX_CONTENT_LEN_NR 3 /* the byte count, when content-length is used */ +#define HDR_STRINGS_IDX_CONTENT_TYPE 4 /* the content type (or default answer content type including default document) */ + +/* The dynamically generated Content-Length buffer needs space for CRLF + NULL */ +#define LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET 3 +#ifndef LWIP_HTTPD_MAX_CONTENT_LEN_SIZE +/* The dynamically generated Content-Length buffer shall be able to work with + ~953 MB (9 digits) */ +#define LWIP_HTTPD_MAX_CONTENT_LEN_SIZE (9 + LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET) +#endif +#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ + +#if LWIP_HTTPD_SSI + +#define HTTPD_LAST_TAG_PART 0xFFFF + +enum tag_check_state { + TAG_NONE, /* Not processing an SSI tag */ + TAG_LEADIN, /* Tag lead in "" being processed */ + TAG_SENDING /* Sending tag replacement string */ +}; + +struct http_ssi_state { + const char *parsed; /* Pointer to the first unparsed byte in buf. */ +#if !LWIP_HTTPD_SSI_INCLUDE_TAG + const char *tag_started;/* Pointer to the first opening '<' of the tag. */ +#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG */ + const char *tag_end; /* Pointer to char after the closing '>' of the tag. */ + u32_t parse_left; /* Number of unparsed bytes in buf. */ + u16_t tag_index; /* Counter used by tag parsing state machine */ + u16_t tag_insert_len; /* Length of insert in string tag_insert */ +#if LWIP_HTTPD_SSI_MULTIPART + u16_t tag_part; /* Counter passed to and changed by tag insertion function to insert multiple times */ +#endif /* LWIP_HTTPD_SSI_MULTIPART */ + u8_t tag_type; /* index into http_ssi_tag_desc array */ + u8_t tag_name_len; /* Length of the tag name in string tag_name */ + char tag_name[LWIP_HTTPD_MAX_TAG_NAME_LEN + 1]; /* Last tag name extracted */ + char tag_insert[LWIP_HTTPD_MAX_TAG_INSERT_LEN + 1]; /* Insert string for tag_name */ + enum tag_check_state tag_state; /* State of the tag processor */ +}; + +struct http_ssi_tag_description { + const char *lead_in; + const char *lead_out; +}; + +#endif /* LWIP_HTTPD_SSI */ + +struct http_state { +#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED + struct http_state *next; +#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ + struct fs_file file_handle; + struct fs_file *handle; + const char *file; /* Pointer to first unsent byte in buf. */ + + struct altcp_pcb *pcb; +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + struct pbuf *req; +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + +#if LWIP_HTTPD_DYNAMIC_FILE_READ + char *buf; /* File read buffer. */ + int buf_len; /* Size of file read buffer, buf. */ +#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ + u32_t left; /* Number of unsent bytes in buf. */ + u8_t retries; +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + u8_t keepalive; +#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ +#if LWIP_HTTPD_SSI + struct http_ssi_state *ssi; +#endif /* LWIP_HTTPD_SSI */ +#if LWIP_HTTPD_CGI + char *params[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Params extracted from the request URI */ + char *param_vals[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Values for each extracted param */ +#endif /* LWIP_HTTPD_CGI */ +#if LWIP_HTTPD_DYNAMIC_HEADERS + const char *hdrs[NUM_FILE_HDR_STRINGS]; /* HTTP headers to be sent. */ + char hdr_content_len[LWIP_HTTPD_MAX_CONTENT_LEN_SIZE]; + u16_t hdr_pos; /* The position of the first unsent header byte in the + current string */ + u16_t hdr_index; /* The index of the hdr string currently being sent. */ +#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ +#if LWIP_HTTPD_TIMING + u32_t time_started; +#endif /* LWIP_HTTPD_TIMING */ +#if LWIP_HTTPD_SUPPORT_POST + u32_t post_content_len_left; +#if LWIP_HTTPD_POST_MANUAL_WND + u32_t unrecved_bytes; + u8_t no_auto_wnd; + u8_t post_finished; +#endif /* LWIP_HTTPD_POST_MANUAL_WND */ +#endif /* LWIP_HTTPD_SUPPORT_POST*/ +}; + +#if HTTPD_USE_MEM_POOL +LWIP_MEMPOOL_DECLARE(HTTPD_STATE, MEMP_NUM_PARALLEL_HTTPD_CONNS, sizeof(struct http_state), "HTTPD_STATE") +#if LWIP_HTTPD_SSI +LWIP_MEMPOOL_DECLARE(HTTPD_SSI_STATE, MEMP_NUM_PARALLEL_HTTPD_SSI_CONNS, sizeof(struct http_ssi_state), "HTTPD_SSI_STATE") +#define HTTP_FREE_SSI_STATE(x) LWIP_MEMPOOL_FREE(HTTPD_SSI_STATE, (x)) +#define HTTP_ALLOC_SSI_STATE() (struct http_ssi_state *)LWIP_MEMPOOL_ALLOC(HTTPD_SSI_STATE) +#endif /* LWIP_HTTPD_SSI */ +#define HTTP_ALLOC_HTTP_STATE() (struct http_state *)LWIP_MEMPOOL_ALLOC(HTTPD_STATE) +#define HTTP_FREE_HTTP_STATE(x) LWIP_MEMPOOL_FREE(HTTPD_STATE, (x)) +#else /* HTTPD_USE_MEM_POOL */ +#define HTTP_ALLOC_HTTP_STATE() (struct http_state *)mem_malloc(sizeof(struct http_state)) +#define HTTP_FREE_HTTP_STATE(x) mem_free(x) +#if LWIP_HTTPD_SSI +#define HTTP_ALLOC_SSI_STATE() (struct http_ssi_state *)mem_malloc(sizeof(struct http_ssi_state)) +#define HTTP_FREE_SSI_STATE(x) mem_free(x) +#endif /* LWIP_HTTPD_SSI */ +#endif /* HTTPD_USE_MEM_POOL */ + +static err_t http_close_conn(struct altcp_pcb *pcb, struct http_state *hs); +static err_t http_close_or_abort_conn(struct altcp_pcb *pcb, struct http_state *hs, u8_t abort_conn); +static err_t http_find_file(struct http_state *hs, const char *uri, int is_09); +static err_t http_init_file(struct http_state *hs, struct fs_file *file, int is_09, const char *uri, u8_t tag_check, char *params); +static err_t http_poll(void *arg, struct altcp_pcb *pcb); +static u8_t http_check_eof(struct altcp_pcb *pcb, struct http_state *hs); +#if LWIP_HTTPD_FS_ASYNC_READ +static void http_continue(void *connection); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ + +#if LWIP_HTTPD_SSI +/* SSI insert handler function pointer. */ +static tSSIHandler httpd_ssi_handler; +#if !LWIP_HTTPD_SSI_RAW +static int httpd_num_tags; +static const char **httpd_tags; +#endif /* !LWIP_HTTPD_SSI_RAW */ + +/* Define the available tag lead-ins and corresponding lead-outs. + * ATTENTION: for the algorithm below using this array, it is essential + * that the lead in differs in the first character! */ +const struct http_ssi_tag_description http_ssi_tag_desc[] = { + {""}, + {"/*#", "*/"} +}; + +#endif /* LWIP_HTTPD_SSI */ + +#if LWIP_HTTPD_CGI +/* CGI handler information */ +static const tCGI *httpd_cgis; +static int httpd_num_cgis; +static int http_cgi_paramcount; +#define http_cgi_params hs->params +#define http_cgi_param_vals hs->param_vals +#elif LWIP_HTTPD_CGI_SSI +static char *http_cgi_params[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Params extracted from the request URI */ +static char *http_cgi_param_vals[LWIP_HTTPD_MAX_CGI_PARAMETERS]; /* Values for each extracted param */ +#endif /* LWIP_HTTPD_CGI */ + +#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED +/** global list of active HTTP connections, use to kill the oldest when + running out of memory */ +static struct http_state *http_connections; + +static void +http_add_connection(struct http_state *hs) +{ + /* add the connection to the list */ + hs->next = http_connections; + http_connections = hs; +} + +static void +http_remove_connection(struct http_state *hs) +{ + /* take the connection off the list */ + if (http_connections) { + if (http_connections == hs) { + http_connections = hs->next; + } else { + struct http_state *last; + for (last = http_connections; last->next != NULL; last = last->next) { + if (last->next == hs) { + last->next = hs->next; + break; + } + } + } + } +} + +static void +http_kill_oldest_connection(u8_t ssi_required) +{ + struct http_state *hs = http_connections; + struct http_state *hs_free_next = NULL; + while (hs && hs->next) { +#if LWIP_HTTPD_SSI + if (ssi_required) { + if (hs->next->ssi != NULL) { + hs_free_next = hs; + } + } else +#else /* LWIP_HTTPD_SSI */ + LWIP_UNUSED_ARG(ssi_required); +#endif /* LWIP_HTTPD_SSI */ + { + hs_free_next = hs; + } + LWIP_ASSERT("broken list", hs != hs->next); + hs = hs->next; + } + if (hs_free_next != NULL) { + LWIP_ASSERT("hs_free_next->next != NULL", hs_free_next->next != NULL); + LWIP_ASSERT("hs_free_next->next->pcb != NULL", hs_free_next->next->pcb != NULL); + /* send RST when killing a connection because of memory shortage */ + http_close_or_abort_conn(hs_free_next->next->pcb, hs_free_next->next, 1); /* this also unlinks the http_state from the list */ + } +} +#else /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ + +#define http_add_connection(hs) +#define http_remove_connection(hs) + +#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ + +#if LWIP_HTTPD_SSI +/** Allocate as struct http_ssi_state. */ +static struct http_ssi_state * +http_ssi_state_alloc(void) +{ + struct http_ssi_state *ret = HTTP_ALLOC_SSI_STATE(); +#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED + if (ret == NULL) { + http_kill_oldest_connection(1); + ret = HTTP_ALLOC_SSI_STATE(); + } +#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ + if (ret != NULL) { + memset(ret, 0, sizeof(struct http_ssi_state)); + } + return ret; +} + +/** Free a struct http_ssi_state. */ +static void +http_ssi_state_free(struct http_ssi_state *ssi) +{ + if (ssi != NULL) { + HTTP_FREE_SSI_STATE(ssi); + } +} +#endif /* LWIP_HTTPD_SSI */ + +/** Initialize a struct http_state. + */ +static void +http_state_init(struct http_state *hs) +{ + /* Initialize the structure. */ + memset(hs, 0, sizeof(struct http_state)); +#if LWIP_HTTPD_DYNAMIC_HEADERS + /* Indicate that the headers are not yet valid */ + hs->hdr_index = NUM_FILE_HDR_STRINGS; +#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ +} + +/** Allocate a struct http_state. */ +static struct http_state * +http_state_alloc(void) +{ + struct http_state *ret = HTTP_ALLOC_HTTP_STATE(); +#if LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED + if (ret == NULL) { + http_kill_oldest_connection(0); + ret = HTTP_ALLOC_HTTP_STATE(); + } +#endif /* LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED */ + if (ret != NULL) { + http_state_init(ret); + http_add_connection(ret); + } + return ret; +} + +/** Free a struct http_state. + * Also frees the file data if dynamic. + */ +static void +http_state_eof(struct http_state *hs) +{ + if (hs->handle) { +#if LWIP_HTTPD_TIMING + u32_t ms_needed = sys_now() - hs->time_started; + u32_t needed = LWIP_MAX(1, (ms_needed / 100)); + LWIP_DEBUGF(HTTPD_DEBUG_TIMING, ("httpd: needed %"U32_F" ms to send file of %d bytes -> %"U32_F" bytes/sec\n", + ms_needed, hs->handle->len, ((((u32_t)hs->handle->len) * 10) / needed))); +#endif /* LWIP_HTTPD_TIMING */ + fs_close(hs->handle); + hs->handle = NULL; + } +#if LWIP_HTTPD_DYNAMIC_FILE_READ + if (hs->buf != NULL) { + mem_free(hs->buf); + hs->buf = NULL; + } +#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ +#if LWIP_HTTPD_SSI + if (hs->ssi) { + http_ssi_state_free(hs->ssi); + hs->ssi = NULL; + } +#endif /* LWIP_HTTPD_SSI */ +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + if (hs->req) { + pbuf_free(hs->req); + hs->req = NULL; + } +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ +} + +/** Free a struct http_state. + * Also frees the file data if dynamic. + */ +static void +http_state_free(struct http_state *hs) +{ + if (hs != NULL) { + http_state_eof(hs); + http_remove_connection(hs); + HTTP_FREE_HTTP_STATE(hs); + } +} + +/** Call tcp_write() in a loop trying smaller and smaller length + * + * @param pcb altcp_pcb to send + * @param ptr Data to send + * @param length Length of data to send (in/out: on return, contains the + * amount of data sent) + * @param apiflags directly passed to tcp_write + * @return the return value of tcp_write + */ +static err_t +http_write(struct altcp_pcb *pcb, const void *ptr, u16_t *length, u8_t apiflags) +{ + u16_t len, max_len; + err_t err; + LWIP_ASSERT("length != NULL", length != NULL); + len = *length; + if (len == 0) { + return ERR_OK; + } + /* We cannot send more data than space available in the send buffer. */ + max_len = altcp_sndbuf(pcb); + if (max_len < len) { + len = max_len; + } +#ifdef HTTPD_MAX_WRITE_LEN + /* Additional limitation: e.g. don't enqueue more than 2*mss at once */ + max_len = HTTPD_MAX_WRITE_LEN(pcb); + if (len > max_len) { + len = max_len; + } +#endif /* HTTPD_MAX_WRITE_LEN */ + do { + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Trying to send %d bytes\n", len)); + err = altcp_write(pcb, ptr, len, apiflags); + if (err == ERR_MEM) { + if ((altcp_sndbuf(pcb) == 0) || + (altcp_sndqueuelen(pcb) >= TCP_SND_QUEUELEN)) { + /* no need to try smaller sizes */ + len = 1; + } else { + len /= 2; + } + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, + ("Send failed, trying less (%d bytes)\n", len)); + } + } while ((err == ERR_MEM) && (len > 1)); + + if (err == ERR_OK) { + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Sent %d bytes\n", len)); + *length = len; + } else { + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Send failed with err %d (\"%s\")\n", err, lwip_strerr(err))); + *length = 0; + } + +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + /* ensure nagle is normally enabled (only disabled for persistent connections + when all data has been enqueued but the connection stays open for the next + request */ + altcp_nagle_enable(pcb); +#endif + + return err; +} + +/** + * The connection shall be actively closed (using RST to close from fault states). + * Reset the sent- and recv-callbacks. + * + * @param pcb the tcp pcb to reset callbacks + * @param hs connection state to free + */ +static err_t +http_close_or_abort_conn(struct altcp_pcb *pcb, struct http_state *hs, u8_t abort_conn) +{ + err_t err; + LWIP_DEBUGF(HTTPD_DEBUG, ("Closing connection %p\n", (void *)pcb)); + +#if LWIP_HTTPD_SUPPORT_POST + if (hs != NULL) { + if ((hs->post_content_len_left != 0) +#if LWIP_HTTPD_POST_MANUAL_WND + || ((hs->no_auto_wnd != 0) && (hs->unrecved_bytes != 0)) +#endif /* LWIP_HTTPD_POST_MANUAL_WND */ + ) { + /* make sure the post code knows that the connection is closed */ + http_uri_buf[0] = 0; + httpd_post_finished(hs, http_uri_buf, LWIP_HTTPD_URI_BUF_LEN); + } + } +#endif /* LWIP_HTTPD_SUPPORT_POST*/ + + + altcp_arg(pcb, NULL); + altcp_recv(pcb, NULL); + altcp_err(pcb, NULL); + altcp_poll(pcb, NULL, 0); + altcp_sent(pcb, NULL); + if (hs != NULL) { + http_state_free(hs); + } + + if (abort_conn) { + altcp_abort(pcb); + return ERR_OK; + } + err = altcp_close(pcb); + if (err != ERR_OK) { + LWIP_DEBUGF(HTTPD_DEBUG, ("Error %d closing %p\n", err, (void *)pcb)); + /* error closing, try again later in poll */ + altcp_poll(pcb, http_poll, HTTPD_POLL_INTERVAL); + } + return err; +} + +/** + * The connection shall be actively closed. + * Reset the sent- and recv-callbacks. + * + * @param pcb the tcp pcb to reset callbacks + * @param hs connection state to free + */ +static err_t +http_close_conn(struct altcp_pcb *pcb, struct http_state *hs) +{ + return http_close_or_abort_conn(pcb, hs, 0); +} + +/** End of file: either close the connection (Connection: close) or + * close the file (Connection: keep-alive) + */ +static void +http_eof(struct altcp_pcb *pcb, struct http_state *hs) +{ + /* HTTP/1.1 persistent connection? (Not supported for SSI) */ +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + if (hs->keepalive) { + http_remove_connection(hs); + + http_state_eof(hs); + http_state_init(hs); + /* restore state: */ + hs->pcb = pcb; + hs->keepalive = 1; + http_add_connection(hs); + /* ensure nagle doesn't interfere with sending all data as fast as possible: */ + altcp_nagle_disable(pcb); + } else +#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ + { + http_close_conn(pcb, hs); + } +} + +#if LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI +/** + * Extract URI parameters from the parameter-part of an URI in the form + * "test.cgi?x=y" @todo: better explanation! + * Pointers to the parameters are stored in hs->param_vals. + * + * @param hs http connection state + * @param params pointer to the NULL-terminated parameter string from the URI + * @return number of parameters extracted + */ +static int +extract_uri_parameters(struct http_state *hs, char *params) +{ + char *pair; + char *equals; + int loop; + + LWIP_UNUSED_ARG(hs); + + /* If we have no parameters at all, return immediately. */ + if (!params || (params[0] == '\0')) { + return (0); + } + + /* Get a pointer to our first parameter */ + pair = params; + + /* Parse up to LWIP_HTTPD_MAX_CGI_PARAMETERS from the passed string and ignore the + * remainder (if any) */ + for (loop = 0; (loop < LWIP_HTTPD_MAX_CGI_PARAMETERS) && pair; loop++) { + + /* Save the name of the parameter */ + http_cgi_params[loop] = pair; + + /* Remember the start of this name=value pair */ + equals = pair; + + /* Find the start of the next name=value pair and replace the delimiter + * with a 0 to terminate the previous pair string. */ + pair = strchr(pair, '&'); + if (pair) { + *pair = '\0'; + pair++; + } else { + /* We didn't find a new parameter so find the end of the URI and + * replace the space with a '\0' */ + pair = strchr(equals, ' '); + if (pair) { + *pair = '\0'; + } + + /* Revert to NULL so that we exit the loop as expected. */ + pair = NULL; + } + + /* Now find the '=' in the previous pair, replace it with '\0' and save + * the parameter value string. */ + equals = strchr(equals, '='); + if (equals) { + *equals = '\0'; + http_cgi_param_vals[loop] = equals + 1; + } else { + http_cgi_param_vals[loop] = NULL; + } + } + + return loop; +} +#endif /* LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI */ + +#if LWIP_HTTPD_SSI +/** + * Insert a tag (found in an shtml in the form of "" into the file. + * The tag's name is stored in ssi->tag_name (NULL-terminated), the replacement + * should be written to hs->tag_insert (up to a length of LWIP_HTTPD_MAX_TAG_INSERT_LEN). + * The amount of data written is stored to ssi->tag_insert_len. + * + * @todo: return tag_insert_len - maybe it can be removed from struct http_state? + * + * @param hs http connection state + */ +static void +get_tag_insert(struct http_state *hs) +{ +#if LWIP_HTTPD_SSI_RAW + const char *tag; +#else /* LWIP_HTTPD_SSI_RAW */ + int tag; +#endif /* LWIP_HTTPD_SSI_RAW */ + size_t len; + struct http_ssi_state *ssi; +#if LWIP_HTTPD_SSI_MULTIPART + u16_t current_tag_part; +#endif /* LWIP_HTTPD_SSI_MULTIPART */ + + LWIP_ASSERT("hs != NULL", hs != NULL); + ssi = hs->ssi; + LWIP_ASSERT("ssi != NULL", ssi != NULL); +#if LWIP_HTTPD_SSI_MULTIPART + current_tag_part = ssi->tag_part; + ssi->tag_part = HTTPD_LAST_TAG_PART; +#endif /* LWIP_HTTPD_SSI_MULTIPART */ +#if LWIP_HTTPD_SSI_RAW + tag = ssi->tag_name; +#endif + + if (httpd_ssi_handler +#if !LWIP_HTTPD_SSI_RAW + && httpd_tags && httpd_num_tags +#endif /* !LWIP_HTTPD_SSI_RAW */ + ) { + + /* Find this tag in the list we have been provided. */ +#if LWIP_HTTPD_SSI_RAW + { +#else /* LWIP_HTTPD_SSI_RAW */ + for (tag = 0; tag < httpd_num_tags; tag++) { + if (strcmp(ssi->tag_name, httpd_tags[tag]) == 0) +#endif /* LWIP_HTTPD_SSI_RAW */ + { + ssi->tag_insert_len = httpd_ssi_handler(tag, ssi->tag_insert, + LWIP_HTTPD_MAX_TAG_INSERT_LEN +#if LWIP_HTTPD_SSI_MULTIPART + , current_tag_part, &ssi->tag_part +#endif /* LWIP_HTTPD_SSI_MULTIPART */ +#if LWIP_HTTPD_FILE_STATE + , (hs->handle ? hs->handle->state : NULL) +#endif /* LWIP_HTTPD_FILE_STATE */ + ); +#if LWIP_HTTPD_SSI_RAW + if (ssi->tag_insert_len != HTTPD_SSI_TAG_UNKNOWN) +#endif /* LWIP_HTTPD_SSI_RAW */ + { + return; + } + } + } + } + + /* If we drop out, we were asked to serve a page which contains tags that + * we don't have a handler for. Merely echo back the tags with an error + * marker. */ +#define UNKNOWN_TAG1_TEXT "***UNKNOWN TAG " +#define UNKNOWN_TAG1_LEN 18 +#define UNKNOWN_TAG2_TEXT "***" +#define UNKNOWN_TAG2_LEN 7 + len = LWIP_MIN(sizeof(ssi->tag_name), LWIP_MIN(strlen(ssi->tag_name), + LWIP_HTTPD_MAX_TAG_INSERT_LEN - (UNKNOWN_TAG1_LEN + UNKNOWN_TAG2_LEN))); + MEMCPY(ssi->tag_insert, UNKNOWN_TAG1_TEXT, UNKNOWN_TAG1_LEN); + MEMCPY(&ssi->tag_insert[UNKNOWN_TAG1_LEN], ssi->tag_name, len); + MEMCPY(&ssi->tag_insert[UNKNOWN_TAG1_LEN + len], UNKNOWN_TAG2_TEXT, UNKNOWN_TAG2_LEN); + ssi->tag_insert[UNKNOWN_TAG1_LEN + len + UNKNOWN_TAG2_LEN] = 0; + + len = strlen(ssi->tag_insert); + LWIP_ASSERT("len <= 0xffff", len <= 0xffff); + ssi->tag_insert_len = (u16_t)len; +} +#endif /* LWIP_HTTPD_SSI */ + +#if LWIP_HTTPD_DYNAMIC_HEADERS +/** + * Generate the relevant HTTP headers for the given filename and write + * them into the supplied buffer. + */ +static void +get_http_headers(struct http_state *hs, const char *uri) +{ + size_t content_type; + char *tmp; + char *ext; + char *vars; + + /* In all cases, the second header we send is the server identification + so set it here. */ + hs->hdrs[HDR_STRINGS_IDX_SERVER_NAME] = g_psHTTPHeaderStrings[HTTP_HDR_SERVER]; + hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = NULL; + hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_NR] = NULL; + + /* Is this a normal file or the special case we use to send back the + default "404: Page not found" response? */ + if (uri == NULL) { + hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_FOUND]; +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + if (hs->keepalive) { + hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaderStrings[DEFAULT_404_HTML_PERSISTENT]; + } else +#endif + { + hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaderStrings[DEFAULT_404_HTML]; + } + + /* Set up to send the first header string. */ + hs->hdr_index = 0; + hs->hdr_pos = 0; + return; + } + /* We are dealing with a particular filename. Look for one other + special case. We assume that any filename with "404" in it must be + indicative of a 404 server error whereas all other files require + the 200 OK header. */ + if (strstr(uri, "404")) { + hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_FOUND]; + } else if (strstr(uri, "400")) { + hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_BAD_REQUEST]; + } else if (strstr(uri, "501")) { + hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_NOT_IMPL]; + } else { + hs->hdrs[HDR_STRINGS_IDX_HTTP_STATUS] = g_psHTTPHeaderStrings[HTTP_HDR_OK]; + } + + /* Determine if the URI has any variables and, if so, temporarily remove + them. */ + vars = strchr(uri, '?'); + if (vars) { + *vars = '\0'; + } + + /* Get a pointer to the file extension. We find this by looking for the + last occurrence of "." in the filename passed. */ + ext = NULL; + tmp = strchr(uri, '.'); + while (tmp) { + ext = tmp + 1; + tmp = strchr(ext, '.'); + } + if (ext != NULL) { + /* Now determine the content type and add the relevant header for that. */ + for (content_type = 0; content_type < NUM_HTTP_HEADERS; content_type++) { + /* Have we found a matching extension? */ + if (!lwip_stricmp(g_psHTTPHeaders[content_type].extension, ext)) { + break; + } + } + } else { + content_type = NUM_HTTP_HEADERS; + } + + /* Reinstate the parameter marker if there was one in the original URI. */ + if (vars) { + *vars = '?'; + } + +#if LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI + /* Does the URL passed have any file extension? If not, we assume it + is a special-case URL used for control state notification and we do + not send any HTTP headers with the response. */ + if (!ext) { + /* Force the header index to a value indicating that all headers + have already been sent. */ + hs->hdr_index = NUM_FILE_HDR_STRINGS; + return; + } +#endif /* LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI */ + /* Did we find a matching extension? */ + if (content_type < NUM_HTTP_HEADERS) { + /* yes, store it */ + hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = g_psHTTPHeaders[content_type].content_type; + } else if (!ext) { + /* no, no extension found -> use binary transfer to prevent the browser adding '.txt' on save */ + hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = HTTP_HDR_APP; + } else { + /* No - use the default, plain text file type. */ + hs->hdrs[HDR_STRINGS_IDX_CONTENT_TYPE] = HTTP_HDR_DEFAULT_TYPE; + } + /* Set up to send the first header string. */ + hs->hdr_index = 0; + hs->hdr_pos = 0; +} + +/* Add content-length header? */ +static void +get_http_content_length(struct http_state *hs) +{ + u8_t add_content_len = 0; + + LWIP_ASSERT("already been here?", hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] == NULL); + + add_content_len = 0; +#if LWIP_HTTPD_SSI + if (hs->ssi == NULL) /* @todo: get maximum file length from SSI */ +#endif /* LWIP_HTTPD_SSI */ + { + if ((hs->handle != NULL) && (hs->handle->flags & FS_FILE_FLAGS_HEADER_PERSISTENT)) { + add_content_len = 1; + } + } + if (add_content_len) { + size_t len; + lwip_itoa(hs->hdr_content_len, (size_t)LWIP_HTTPD_MAX_CONTENT_LEN_SIZE, + hs->handle->len); + len = strlen(hs->hdr_content_len); + if (len <= LWIP_HTTPD_MAX_CONTENT_LEN_SIZE - LWIP_HTTPD_MAX_CONTENT_LEN_OFFSET) { + SMEMCPY(&hs->hdr_content_len[len], CRLF, 3); + hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_NR] = hs->hdr_content_len; + } else { + add_content_len = 0; + } + } +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + if (add_content_len) { + hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_KEEPALIVE_LEN]; + } else { + hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_CONN_CLOSE]; + hs->keepalive = 0; + } +#else /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ + if (add_content_len) { + hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] = g_psHTTPHeaderStrings[HTTP_HDR_CONTENT_LENGTH]; + } +#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ +} + +/** Sub-function of http_send(): send dynamic headers + * + * @returns: - HTTP_NO_DATA_TO_SEND: no new data has been enqueued + * - HTTP_DATA_TO_SEND_CONTINUE: continue with sending HTTP body + * - HTTP_DATA_TO_SEND_BREAK: data has been enqueued, headers pending, + * so don't send HTTP body yet + * - HTTP_DATA_TO_SEND_FREED: http_state and pcb are already freed + */ +static u8_t +http_send_headers(struct altcp_pcb *pcb, struct http_state *hs) +{ + err_t err; + u16_t len; + u8_t data_to_send = HTTP_NO_DATA_TO_SEND; + u16_t hdrlen, sendlen; + + if (hs->hdrs[HDR_STRINGS_IDX_CONTENT_LEN_KEEPALIVE] == NULL) { + /* set up "content-length" and "connection:" headers */ + get_http_content_length(hs); + } + + /* How much data can we send? */ + len = altcp_sndbuf(pcb); + sendlen = len; + + while (len && (hs->hdr_index < NUM_FILE_HDR_STRINGS) && sendlen) { + const void *ptr; + u16_t old_sendlen; + u8_t apiflags; + /* How much do we have to send from the current header? */ + hdrlen = (u16_t)strlen(hs->hdrs[hs->hdr_index]); + + /* How much of this can we send? */ + sendlen = (len < (hdrlen - hs->hdr_pos)) ? len : (hdrlen - hs->hdr_pos); + + /* Send this amount of data or as much as we can given memory + * constraints. */ + ptr = (const void *)(hs->hdrs[hs->hdr_index] + hs->hdr_pos); + old_sendlen = sendlen; + apiflags = HTTP_IS_HDR_VOLATILE(hs, ptr); + if (hs->hdr_index == HDR_STRINGS_IDX_CONTENT_LEN_NR) { + /* content-length is always volatile */ + apiflags |= TCP_WRITE_FLAG_COPY; + } + if (hs->hdr_index < NUM_FILE_HDR_STRINGS - 1) { + apiflags |= TCP_WRITE_FLAG_MORE; + } + err = http_write(pcb, ptr, &sendlen, apiflags); + if ((err == ERR_OK) && (old_sendlen != sendlen)) { + /* Remember that we added some more data to be transmitted. */ + data_to_send = HTTP_DATA_TO_SEND_CONTINUE; + } else if (err != ERR_OK) { + /* special case: http_write does not try to send 1 byte */ + sendlen = 0; + } + + /* Fix up the header position for the next time round. */ + hs->hdr_pos += sendlen; + len -= sendlen; + + /* Have we finished sending this string? */ + if (hs->hdr_pos == hdrlen) { + /* Yes - move on to the next one */ + hs->hdr_index++; + /* skip headers that are NULL (not all headers are required) */ + while ((hs->hdr_index < NUM_FILE_HDR_STRINGS) && + (hs->hdrs[hs->hdr_index] == NULL)) { + hs->hdr_index++; + } + hs->hdr_pos = 0; + } + } + + if ((hs->hdr_index >= NUM_FILE_HDR_STRINGS) && (hs->file == NULL)) { + /* When we are at the end of the headers, check for data to send + * instead of waiting for ACK from remote side to continue + * (which would happen when sending files from async read). */ + if (http_check_eof(pcb, hs)) { + data_to_send = HTTP_DATA_TO_SEND_BREAK; + } else { + /* At this point, for non-keepalive connections, hs is deallocated an + pcb is closed. */ + return HTTP_DATA_TO_SEND_FREED; + } + } + /* If we get here and there are still header bytes to send, we send + * the header information we just wrote immediately. If there are no + * more headers to send, but we do have file data to send, drop through + * to try to send some file data too. */ + if ((hs->hdr_index < NUM_FILE_HDR_STRINGS) || !hs->file) { + LWIP_DEBUGF(HTTPD_DEBUG, ("tcp_output\n")); + return HTTP_DATA_TO_SEND_BREAK; + } + return data_to_send; +} +#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ + +/** Sub-function of http_send(): end-of-file (or block) is reached, + * either close the file or read the next block (if supported). + * + * @returns: 0 if the file is finished or no data has been read + * 1 if the file is not finished and data has been read + */ +static u8_t +http_check_eof(struct altcp_pcb *pcb, struct http_state *hs) +{ + int bytes_left; +#if LWIP_HTTPD_DYNAMIC_FILE_READ + int count; +#ifdef HTTPD_MAX_WRITE_LEN + int max_write_len; +#endif /* HTTPD_MAX_WRITE_LEN */ +#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ + + /* Do we have a valid file handle? */ + if (hs->handle == NULL) { + /* No - close the connection. */ + http_eof(pcb, hs); + return 0; + } + bytes_left = fs_bytes_left(hs->handle); + if (bytes_left <= 0) { + /* We reached the end of the file so this request is done. */ + LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n")); + http_eof(pcb, hs); + return 0; + } +#if LWIP_HTTPD_DYNAMIC_FILE_READ + /* Do we already have a send buffer allocated? */ + if (hs->buf) { + /* Yes - get the length of the buffer */ + count = LWIP_MIN(hs->buf_len, bytes_left); + } else { + /* We don't have a send buffer so allocate one now */ + count = altcp_sndbuf(pcb); + if (bytes_left < count) { + count = bytes_left; + } +#ifdef HTTPD_MAX_WRITE_LEN + /* Additional limitation: e.g. don't enqueue more than 2*mss at once */ + max_write_len = HTTPD_MAX_WRITE_LEN(pcb); + if (count > max_write_len) { + count = max_write_len; + } +#endif /* HTTPD_MAX_WRITE_LEN */ + do { + hs->buf = (char *)mem_malloc((mem_size_t)count); + if (hs->buf != NULL) { + hs->buf_len = count; + break; + } + count = count / 2; + } while (count > 100); + + /* Did we get a send buffer? If not, return immediately. */ + if (hs->buf == NULL) { + LWIP_DEBUGF(HTTPD_DEBUG, ("No buff\n")); + return 0; + } + } + + /* Read a block of data from the file. */ + LWIP_DEBUGF(HTTPD_DEBUG, ("Trying to read %d bytes.\n", count)); + +#if LWIP_HTTPD_FS_ASYNC_READ + count = fs_read_async(hs->handle, hs->buf, count, http_continue, hs); +#else /* LWIP_HTTPD_FS_ASYNC_READ */ + count = fs_read(hs->handle, hs->buf, count); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ + if (count < 0) { + if (count == FS_READ_DELAYED) { + /* Delayed read, wait for FS to unblock us */ + return 0; + } + /* We reached the end of the file so this request is done. + * @todo: close here for HTTP/1.1 when reading file fails */ + LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n")); + http_eof(pcb, hs); + return 0; + } + + /* Set up to send the block of data we just read */ + LWIP_DEBUGF(HTTPD_DEBUG, ("Read %d bytes.\n", count)); + hs->left = count; + hs->file = hs->buf; +#if LWIP_HTTPD_SSI + if (hs->ssi) { + hs->ssi->parse_left = count; + hs->ssi->parsed = hs->buf; + } +#endif /* LWIP_HTTPD_SSI */ +#else /* LWIP_HTTPD_DYNAMIC_FILE_READ */ + LWIP_ASSERT("SSI and DYNAMIC_HEADERS turned off but eof not reached", 0); +#endif /* LWIP_HTTPD_SSI || LWIP_HTTPD_DYNAMIC_HEADERS */ + return 1; +} + +/** Sub-function of http_send(): This is the normal send-routine for non-ssi files + * + * @returns: - 1: data has been written (so call tcp_ouput) + * - 0: no data has been written (no need to call tcp_output) + */ +static u8_t +http_send_data_nonssi(struct altcp_pcb *pcb, struct http_state *hs) +{ + err_t err; + u16_t len; + u8_t data_to_send = 0; + + /* We are not processing an SHTML file so no tag checking is necessary. + * Just send the data as we received it from the file. */ + len = (u16_t)LWIP_MIN(hs->left, 0xffff); + + err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); + if (err == ERR_OK) { + data_to_send = 1; + hs->file += len; + hs->left -= len; + } + + return data_to_send; +} + +#if LWIP_HTTPD_SSI +/** Sub-function of http_send(): This is the send-routine for ssi files + * + * @returns: - 1: data has been written (so call tcp_ouput) + * - 0: no data has been written (no need to call tcp_output) + */ +static u8_t +http_send_data_ssi(struct altcp_pcb *pcb, struct http_state *hs) +{ + err_t err = ERR_OK; + u16_t len; + u8_t data_to_send = 0; + u8_t tag_type; + + struct http_ssi_state *ssi = hs->ssi; + LWIP_ASSERT("ssi != NULL", ssi != NULL); + /* We are processing an SHTML file so need to scan for tags and replace + * them with insert strings. We need to be careful here since a tag may + * straddle the boundary of two blocks read from the file and we may also + * have to split the insert string between two tcp_write operations. */ + + /* How much data could we send? */ + len = altcp_sndbuf(pcb); + + /* Do we have remaining data to send before parsing more? */ + if (ssi->parsed > hs->file) { + len = (u16_t)LWIP_MIN(ssi->parsed - hs->file, 0xffff); + + err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); + if (err == ERR_OK) { + data_to_send = 1; + hs->file += len; + hs->left -= len; + } + + /* If the send buffer is full, return now. */ + if (altcp_sndbuf(pcb) == 0) { + return data_to_send; + } + } + + LWIP_DEBUGF(HTTPD_DEBUG, ("State %d, %d left\n", ssi->tag_state, (int)ssi->parse_left)); + + /* We have sent all the data that was already parsed so continue parsing + * the buffer contents looking for SSI tags. */ + while (((ssi->tag_state == TAG_SENDING) || ssi->parse_left) && (err == ERR_OK)) { + if (len == 0) { + return data_to_send; + } + switch (ssi->tag_state) { + case TAG_NONE: + /* We are not currently processing an SSI tag so scan for the + * start of the lead-in marker. */ + for (tag_type = 0; tag_type < LWIP_ARRAYSIZE(http_ssi_tag_desc); tag_type++) { + if (*ssi->parsed == http_ssi_tag_desc[tag_type].lead_in[0]) { + /* We found what could be the lead-in for a new tag so change + * state appropriately. */ + ssi->tag_type = tag_type; + ssi->tag_state = TAG_LEADIN; + ssi->tag_index = 1; + #if !LWIP_HTTPD_SSI_INCLUDE_TAG + ssi->tag_started = ssi->parsed; + #endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG */ + break; + } + } + + /* Move on to the next character in the buffer */ + ssi->parse_left--; + ssi->parsed++; + break; + + case TAG_LEADIN: + /* We are processing the lead-in marker, looking for the start of + * the tag name. */ + + /* Have we reached the end of the leadin? */ + if (http_ssi_tag_desc[ssi->tag_type].lead_in[ssi->tag_index] == 0) { + ssi->tag_index = 0; + ssi->tag_state = TAG_FOUND; + } else { + /* Have we found the next character we expect for the tag leadin? */ + if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_in[ssi->tag_index]) { + /* Yes - move to the next one unless we have found the complete + * leadin, in which case we start looking for the tag itself */ + ssi->tag_index++; + } else { + /* We found an unexpected character so this is not a tag. Move + * back to idle state. */ + ssi->tag_state = TAG_NONE; + } + + /* Move on to the next character in the buffer */ + ssi->parse_left--; + ssi->parsed++; + } + break; + + case TAG_FOUND: + /* We are reading the tag name, looking for the start of the + * lead-out marker and removing any whitespace found. */ + + /* Remove leading whitespace between the tag leading and the first + * tag name character. */ + if ((ssi->tag_index == 0) && ((*ssi->parsed == ' ') || + (*ssi->parsed == '\t') || (*ssi->parsed == '\n') || + (*ssi->parsed == '\r'))) { + /* Move on to the next character in the buffer */ + ssi->parse_left--; + ssi->parsed++; + break; + } + + /* Have we found the end of the tag name? This is signalled by + * us finding the first leadout character or whitespace */ + if ((*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[0]) || + (*ssi->parsed == ' ') || (*ssi->parsed == '\t') || + (*ssi->parsed == '\n') || (*ssi->parsed == '\r')) { + + if (ssi->tag_index == 0) { + /* We read a zero length tag so ignore it. */ + ssi->tag_state = TAG_NONE; + } else { + /* We read a non-empty tag so go ahead and look for the + * leadout string. */ + ssi->tag_state = TAG_LEADOUT; + LWIP_ASSERT("ssi->tag_index <= 0xff", ssi->tag_index <= 0xff); + ssi->tag_name_len = (u8_t)ssi->tag_index; + ssi->tag_name[ssi->tag_index] = '\0'; + if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[0]) { + ssi->tag_index = 1; + } else { + ssi->tag_index = 0; + } + } + } else { + /* This character is part of the tag name so save it */ + if (ssi->tag_index < LWIP_HTTPD_MAX_TAG_NAME_LEN) { + ssi->tag_name[ssi->tag_index++] = *ssi->parsed; + } else { + /* The tag was too long so ignore it. */ + ssi->tag_state = TAG_NONE; + } + } + + /* Move on to the next character in the buffer */ + ssi->parse_left--; + ssi->parsed++; + + break; + + /* We are looking for the end of the lead-out marker. */ + case TAG_LEADOUT: + /* Remove leading whitespace between the tag leading and the first + * tag leadout character. */ + if ((ssi->tag_index == 0) && ((*ssi->parsed == ' ') || + (*ssi->parsed == '\t') || (*ssi->parsed == '\n') || + (*ssi->parsed == '\r'))) { + /* Move on to the next character in the buffer */ + ssi->parse_left--; + ssi->parsed++; + break; + } + + /* Have we found the next character we expect for the tag leadout? */ + if (*ssi->parsed == http_ssi_tag_desc[ssi->tag_type].lead_out[ssi->tag_index]) { + /* Yes - move to the next one unless we have found the complete + * leadout, in which case we need to call the client to process + * the tag. */ + + /* Move on to the next character in the buffer */ + ssi->parse_left--; + ssi->parsed++; + ssi->tag_index++; + + if (http_ssi_tag_desc[ssi->tag_type].lead_out[ssi->tag_index] == 0) { + /* Call the client to ask for the insert string for the + * tag we just found. */ +#if LWIP_HTTPD_SSI_MULTIPART + ssi->tag_part = 0; /* start with tag part 0 */ +#endif /* LWIP_HTTPD_SSI_MULTIPART */ + get_tag_insert(hs); + + /* Next time through, we are going to be sending data + * immediately, either the end of the block we start + * sending here or the insert string. */ + ssi->tag_index = 0; + ssi->tag_state = TAG_SENDING; + ssi->tag_end = ssi->parsed; +#if !LWIP_HTTPD_SSI_INCLUDE_TAG + ssi->parsed = ssi->tag_started; +#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ + + /* If there is any unsent data in the buffer prior to the + * tag, we need to send it now. */ + if (ssi->tag_end > hs->file) { + /* How much of the data can we send? */ +#if LWIP_HTTPD_SSI_INCLUDE_TAG + len = (u16_t)LWIP_MIN(ssi->tag_end - hs->file, 0xffff); +#else /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ + /* we would include the tag in sending */ + len = (u16_t)LWIP_MIN(ssi->tag_started - hs->file, 0xffff); +#endif /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ + + err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); + if (err == ERR_OK) { + data_to_send = 1; +#if !LWIP_HTTPD_SSI_INCLUDE_TAG + if (ssi->tag_started <= hs->file) { + /* pretend to have sent the tag, too */ + len += (u16_t)(ssi->tag_end - ssi->tag_started); + } +#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ + hs->file += len; + hs->left -= len; + } + } + } + } else { + /* We found an unexpected character so this is not a tag. Move + * back to idle state. */ + ssi->parse_left--; + ssi->parsed++; + ssi->tag_state = TAG_NONE; + } + break; + + /* + * We have found a valid tag and are in the process of sending + * data as a result of that discovery. We send either remaining data + * from the file prior to the insert point or the insert string itself. + */ + case TAG_SENDING: + /* Do we have any remaining file data to send from the buffer prior + * to the tag? */ + if (ssi->tag_end > hs->file) { + /* How much of the data can we send? */ +#if LWIP_HTTPD_SSI_INCLUDE_TAG + len = (u16_t)LWIP_MIN(ssi->tag_end - hs->file, 0xffff); +#else /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ + LWIP_ASSERT("hs->started >= hs->file", ssi->tag_started >= hs->file); + /* we would include the tag in sending */ + len = (u16_t)LWIP_MIN(ssi->tag_started - hs->file, 0xffff); +#endif /* LWIP_HTTPD_SSI_INCLUDE_TAG*/ + if (len != 0) { + err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); + } else { + err = ERR_OK; + } + if (err == ERR_OK) { + data_to_send = 1; +#if !LWIP_HTTPD_SSI_INCLUDE_TAG + if (ssi->tag_started <= hs->file) { + /* pretend to have sent the tag, too */ + len += (u16_t)(ssi->tag_end - ssi->tag_started); + } +#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ + hs->file += len; + hs->left -= len; + } + } else { +#if LWIP_HTTPD_SSI_MULTIPART + if (ssi->tag_index >= ssi->tag_insert_len) { + /* Did the last SSIHandler have more to send? */ + if (ssi->tag_part != HTTPD_LAST_TAG_PART) { + /* If so, call it again */ + ssi->tag_index = 0; + get_tag_insert(hs); + } + } +#endif /* LWIP_HTTPD_SSI_MULTIPART */ + + /* Do we still have insert data left to send? */ + if (ssi->tag_index < ssi->tag_insert_len) { + /* We are sending the insert string itself. How much of the + * insert can we send? */ + len = (ssi->tag_insert_len - ssi->tag_index); + + /* Note that we set the copy flag here since we only have a + * single tag insert buffer per connection. If we don't do + * this, insert corruption can occur if more than one insert + * is processed before we call tcp_output. */ + err = http_write(pcb, &(ssi->tag_insert[ssi->tag_index]), &len, + HTTP_IS_TAG_VOLATILE(hs)); + if (err == ERR_OK) { + data_to_send = 1; + ssi->tag_index += len; + /* Don't return here: keep on sending data */ + } + } else { +#if LWIP_HTTPD_SSI_MULTIPART + if (ssi->tag_part == HTTPD_LAST_TAG_PART) +#endif /* LWIP_HTTPD_SSI_MULTIPART */ + { + /* We have sent all the insert data so go back to looking for + * a new tag. */ + LWIP_DEBUGF(HTTPD_DEBUG, ("Everything sent.\n")); + ssi->tag_index = 0; + ssi->tag_state = TAG_NONE; +#if !LWIP_HTTPD_SSI_INCLUDE_TAG + ssi->parsed = ssi->tag_end; +#endif /* !LWIP_HTTPD_SSI_INCLUDE_TAG*/ + } + } + break; + default: + break; + } + } + } + + /* If we drop out of the end of the for loop, this implies we must have + * file data to send so send it now. In TAG_SENDING state, we've already + * handled this so skip the send if that's the case. */ + if ((ssi->tag_state != TAG_SENDING) && (ssi->parsed > hs->file)) { +#if LWIP_HTTPD_DYNAMIC_FILE_READ && !LWIP_HTTPD_SSI_INCLUDE_TAG + if ((ssi->tag_state != TAG_NONE) && (ssi->tag_started > ssi->tag_end)) { + /* If we found tag on the edge of the read buffer: just throw away the first part + (we have copied/saved everything required for parsing on later). */ + len = (u16_t)(ssi->tag_started - hs->file); + hs->left -= (ssi->parsed - ssi->tag_started); + ssi->parsed = ssi->tag_started; + ssi->tag_started = hs->buf; + } else +#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ && !LWIP_HTTPD_SSI_INCLUDE_TAG */ + { + len = (u16_t)LWIP_MIN(ssi->parsed - hs->file, 0xffff); + } + + err = http_write(pcb, hs->file, &len, HTTP_IS_DATA_VOLATILE(hs)); + if (err == ERR_OK) { + data_to_send = 1; + hs->file += len; + hs->left -= len; + } + } + return data_to_send; +} +#endif /* LWIP_HTTPD_SSI */ + +/** + * Try to send more data on this pcb. + * + * @param pcb the pcb to send data + * @param hs connection state + */ +static u8_t +http_send(struct altcp_pcb *pcb, struct http_state *hs) +{ + u8_t data_to_send = HTTP_NO_DATA_TO_SEND; + + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_send: pcb=%p hs=%p left=%d\n", (void *)pcb, + (void *)hs, hs != NULL ? (int)hs->left : 0)); + +#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND + if (hs->unrecved_bytes != 0) { + return 0; + } +#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */ + + /* If we were passed a NULL state structure pointer, ignore the call. */ + if (hs == NULL) { + return 0; + } + +#if LWIP_HTTPD_FS_ASYNC_READ + /* Check if we are allowed to read from this file. + (e.g. SSI might want to delay sending until data is available) */ + if (!fs_is_file_ready(hs->handle, http_continue, hs)) { + return 0; + } +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ + +#if LWIP_HTTPD_DYNAMIC_HEADERS + /* Do we have any more header data to send for this file? */ + if (hs->hdr_index < NUM_FILE_HDR_STRINGS) { + data_to_send = http_send_headers(pcb, hs); + if ((data_to_send == HTTP_DATA_TO_SEND_FREED) || + ((data_to_send != HTTP_DATA_TO_SEND_CONTINUE) && + (hs->hdr_index < NUM_FILE_HDR_STRINGS))) { + return data_to_send; + } + } +#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ + + /* Have we run out of file data to send? If so, we need to read the next + * block from the file. */ + if (hs->left == 0) { + if (!http_check_eof(pcb, hs)) { + return 0; + } + } + +#if LWIP_HTTPD_SSI + if (hs->ssi) { + data_to_send = http_send_data_ssi(pcb, hs); + } else +#endif /* LWIP_HTTPD_SSI */ + { + data_to_send = http_send_data_nonssi(pcb, hs); + } + + if ((hs->left == 0) && (fs_bytes_left(hs->handle) <= 0)) { + /* We reached the end of the file so this request is done. + * This adds the FIN flag right into the last data segment. */ + LWIP_DEBUGF(HTTPD_DEBUG, ("End of file.\n")); + http_eof(pcb, hs); + return 0; + } + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("send_data end.\n")); + return data_to_send; +} + +#if LWIP_HTTPD_SUPPORT_EXTSTATUS +/** Initialize a http connection with a file to send for an error message + * + * @param hs http connection state + * @param error_nr HTTP error number + * @return ERR_OK if file was found and hs has been initialized correctly + * another err_t otherwise + */ +static err_t +http_find_error_file(struct http_state *hs, u16_t error_nr) +{ + const char *uri, *uri1, *uri2, *uri3; + + if (error_nr == 501) { + uri1 = "/501.html"; + uri2 = "/501.htm"; + uri3 = "/501.shtml"; + } else { + /* 400 (bad request is the default) */ + uri1 = "/400.html"; + uri2 = "/400.htm"; + uri3 = "/400.shtml"; + } + if (fs_open(&hs->file_handle, uri1) == ERR_OK) { + uri = uri1; + } else if (fs_open(&hs->file_handle, uri2) == ERR_OK) { + uri = uri2; + } else if (fs_open(&hs->file_handle, uri3) == ERR_OK) { + uri = uri3; + } else { + LWIP_DEBUGF(HTTPD_DEBUG, ("Error page for error %"U16_F" not found\n", + error_nr)); + return ERR_ARG; + } + return http_init_file(hs, &hs->file_handle, 0, uri, 0, NULL); +} +#else /* LWIP_HTTPD_SUPPORT_EXTSTATUS */ +#define http_find_error_file(hs, error_nr) ERR_ARG +#endif /* LWIP_HTTPD_SUPPORT_EXTSTATUS */ + +/** + * Get the file struct for a 404 error page. + * Tries some file names and returns NULL if none found. + * + * @param uri pointer that receives the actual file name URI + * @return file struct for the error page or NULL no matching file was found + */ +static struct fs_file * +http_get_404_file(struct http_state *hs, const char **uri) +{ + err_t err; + + *uri = "/404.html"; + err = fs_open(&hs->file_handle, *uri); + if (err != ERR_OK) { + /* 404.html doesn't exist. Try 404.htm instead. */ + *uri = "/404.htm"; + err = fs_open(&hs->file_handle, *uri); + if (err != ERR_OK) { + /* 404.htm doesn't exist either. Try 404.shtml instead. */ + *uri = "/404.shtml"; + err = fs_open(&hs->file_handle, *uri); + if (err != ERR_OK) { + /* 404.htm doesn't exist either. Indicate to the caller that it should + * send back a default 404 page. + */ + *uri = NULL; + return NULL; + } + } + } + + return &hs->file_handle; +} + +#if LWIP_HTTPD_SUPPORT_POST +static err_t +http_handle_post_finished(struct http_state *hs) +{ +#if LWIP_HTTPD_POST_MANUAL_WND + /* Prevent multiple calls to httpd_post_finished, since it might have already + been called before from httpd_post_data_recved(). */ + if (hs->post_finished) { + return ERR_OK; + } + hs->post_finished = 1; +#endif /* LWIP_HTTPD_POST_MANUAL_WND */ + /* application error or POST finished */ + /* NULL-terminate the buffer */ + http_uri_buf[0] = 0; + httpd_post_finished(hs, http_uri_buf, LWIP_HTTPD_URI_BUF_LEN); + return http_find_file(hs, http_uri_buf, 0); +} + +/** Pass received POST body data to the application and correctly handle + * returning a response document or closing the connection. + * ATTENTION: The application is responsible for the pbuf now, so don't free it! + * + * @param hs http connection state + * @param p pbuf to pass to the application + * @return ERR_OK if passed successfully, another err_t if the response file + * hasn't been found (after POST finished) + */ +static err_t +http_post_rxpbuf(struct http_state *hs, struct pbuf *p) +{ + err_t err; + + if (p != NULL) { + /* adjust remaining Content-Length */ + if (hs->post_content_len_left < p->tot_len) { + hs->post_content_len_left = 0; + } else { + hs->post_content_len_left -= p->tot_len; + } + } +#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND + /* prevent connection being closed if httpd_post_data_recved() is called nested */ + hs->unrecved_bytes++; +#endif + if (p != NULL) { + err = httpd_post_receive_data(hs, p); + } else { + err = ERR_OK; + } +#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND + hs->unrecved_bytes--; +#endif + if (err != ERR_OK) { + /* Ignore remaining content in case of application error */ + hs->post_content_len_left = 0; + } + if (hs->post_content_len_left == 0) { +#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND + if (hs->unrecved_bytes != 0) { + return ERR_OK; + } +#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */ + /* application error or POST finished */ + return http_handle_post_finished(hs); + } + + return ERR_OK; +} + +/** Handle a post request. Called from http_parse_request when method 'POST' + * is found. + * + * @param p The input pbuf (containing the POST header and body). + * @param hs The http connection state. + * @param data HTTP request (header and part of body) from input pbuf(s). + * @param data_len Size of 'data'. + * @param uri The HTTP URI parsed from input pbuf(s). + * @param uri_end Pointer to the end of 'uri' (here, the rest of the HTTP + * header starts). + * @return ERR_OK: POST correctly parsed and accepted by the application. + * ERR_INPROGRESS: POST not completely parsed (no error yet) + * another err_t: Error parsing POST or denied by the application + */ +static err_t +http_post_request(struct pbuf *inp, struct http_state *hs, + char *data, u16_t data_len, char *uri, char *uri_end) +{ + err_t err; + /* search for end-of-header (first double-CRLF) */ + char *crlfcrlf = lwip_strnstr(uri_end + 1, CRLF CRLF, data_len - (uri_end + 1 - data)); + + if (crlfcrlf != NULL) { + /* search for "Content-Length: " */ +#define HTTP_HDR_CONTENT_LEN "Content-Length: " +#define HTTP_HDR_CONTENT_LEN_LEN 16 +#define HTTP_HDR_CONTENT_LEN_DIGIT_MAX_LEN 10 + char *scontent_len = lwip_strnstr(uri_end + 1, HTTP_HDR_CONTENT_LEN, crlfcrlf - (uri_end + 1)); + if (scontent_len != NULL) { + char *scontent_len_end = lwip_strnstr(scontent_len + HTTP_HDR_CONTENT_LEN_LEN, CRLF, HTTP_HDR_CONTENT_LEN_DIGIT_MAX_LEN); + if (scontent_len_end != NULL) { + int content_len; + char *content_len_num = scontent_len + HTTP_HDR_CONTENT_LEN_LEN; + content_len = atoi(content_len_num); + if (content_len == 0) { + /* if atoi returns 0 on error, fix this */ + if ((content_len_num[0] != '0') || (content_len_num[1] != '\r')) { + content_len = -1; + } + } + if (content_len >= 0) { + /* adjust length of HTTP header passed to application */ + const char *hdr_start_after_uri = uri_end + 1; + u16_t hdr_len = (u16_t)LWIP_MIN(data_len, crlfcrlf + 4 - data); + u16_t hdr_data_len = (u16_t)LWIP_MIN(data_len, crlfcrlf + 4 - hdr_start_after_uri); + u8_t post_auto_wnd = 1; + http_uri_buf[0] = 0; + /* trim http header */ + *crlfcrlf = 0; + err = httpd_post_begin(hs, uri, hdr_start_after_uri, hdr_data_len, content_len, + http_uri_buf, LWIP_HTTPD_URI_BUF_LEN, &post_auto_wnd); + if (err == ERR_OK) { + /* try to pass in data of the first pbuf(s) */ + struct pbuf *q = inp; + u16_t start_offset = hdr_len; +#if LWIP_HTTPD_POST_MANUAL_WND + hs->no_auto_wnd = !post_auto_wnd; +#endif /* LWIP_HTTPD_POST_MANUAL_WND */ + /* set the Content-Length to be received for this POST */ + hs->post_content_len_left = (u32_t)content_len; + + /* get to the pbuf where the body starts */ + while ((q != NULL) && (q->len <= start_offset)) { + start_offset -= q->len; + q = q->next; + } + if (q != NULL) { + /* hide the remaining HTTP header */ + pbuf_remove_header(q, start_offset); +#if LWIP_HTTPD_POST_MANUAL_WND + if (!post_auto_wnd) { + /* already tcp_recved() this data... */ + hs->unrecved_bytes = q->tot_len; + } +#endif /* LWIP_HTTPD_POST_MANUAL_WND */ + pbuf_ref(q); + return http_post_rxpbuf(hs, q); + } else if (hs->post_content_len_left == 0) { + q = pbuf_alloc(PBUF_RAW, 0, PBUF_REF); + return http_post_rxpbuf(hs, q); + } else { + return ERR_OK; + } + } else { + /* return file passed from application */ + return http_find_file(hs, http_uri_buf, 0); + } + } else { + LWIP_DEBUGF(HTTPD_DEBUG, ("POST received invalid Content-Length: %s\n", + content_len_num)); + return ERR_ARG; + } + } + } + /* If we come here, headers are fully received (double-crlf), but Content-Length + was not included. Since this is currently the only supported method, we have + to fail in this case! */ + LWIP_DEBUGF(HTTPD_DEBUG, ("Error when parsing Content-Length\n")); + return ERR_ARG; + } + /* if we come here, the POST is incomplete */ +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + return ERR_INPROGRESS; +#else /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + return ERR_ARG; +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ +} + +#if LWIP_HTTPD_POST_MANUAL_WND +/** + * @ingroup httpd + * A POST implementation can call this function to update the TCP window. + * This can be used to throttle data reception (e.g. when received data is + * programmed to flash and data is received faster than programmed). + * + * @param connection A connection handle passed to httpd_post_begin for which + * httpd_post_finished has *NOT* been called yet! + * @param recved_len Length of data received (for window update) + */ +void httpd_post_data_recved(void *connection, u16_t recved_len) +{ + struct http_state *hs = (struct http_state *)connection; + if (hs != NULL) { + if (hs->no_auto_wnd) { + u16_t len = recved_len; + if (hs->unrecved_bytes >= recved_len) { + hs->unrecved_bytes -= recved_len; + } else { + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_LEVEL_WARNING, ("httpd_post_data_recved: recved_len too big\n")); + len = (u16_t)hs->unrecved_bytes; + hs->unrecved_bytes = 0; + } + if (hs->pcb != NULL) { + if (len != 0) { + altcp_recved(hs->pcb, len); + } + if ((hs->post_content_len_left == 0) && (hs->unrecved_bytes == 0)) { + /* finished handling POST */ + http_handle_post_finished(hs); + http_send(hs->pcb, hs); + } + } + } + } +} +#endif /* LWIP_HTTPD_POST_MANUAL_WND */ + +#endif /* LWIP_HTTPD_SUPPORT_POST */ + +#if LWIP_HTTPD_FS_ASYNC_READ +/** Try to send more data if file has been blocked before + * This is a callback function passed to fs_read_async(). + */ +static void +http_continue(void *connection) +{ + struct http_state *hs = (struct http_state *)connection; + LWIP_ASSERT_CORE_LOCKED(); + if (hs && (hs->pcb) && (hs->handle)) { + LWIP_ASSERT("hs->pcb != NULL", hs->pcb != NULL); + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("httpd_continue: try to send more data\n")); + if (http_send(hs->pcb, hs)) { + /* If we wrote anything to be sent, go ahead and send it now. */ + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("tcp_output\n")); + altcp_output(hs->pcb); + } + } +} +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ + +/** + * When data has been received in the correct state, try to parse it + * as a HTTP request. + * + * @param inp the received pbuf + * @param hs the connection state + * @param pcb the altcp_pcb which received this packet + * @return ERR_OK if request was OK and hs has been initialized correctly + * ERR_INPROGRESS if request was OK so far but not fully received + * another err_t otherwise + */ +static err_t +http_parse_request(struct pbuf *inp, struct http_state *hs, struct altcp_pcb *pcb) +{ + char *data; + char *crlf; + u16_t data_len; + struct pbuf *p = inp; +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + u16_t clen; +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ +#if LWIP_HTTPD_SUPPORT_POST + err_t err; +#endif /* LWIP_HTTPD_SUPPORT_POST */ + + LWIP_UNUSED_ARG(pcb); /* only used for post */ + LWIP_ASSERT("p != NULL", p != NULL); + LWIP_ASSERT("hs != NULL", hs != NULL); + + if ((hs->handle != NULL) || (hs->file != NULL)) { + LWIP_DEBUGF(HTTPD_DEBUG, ("Received data while sending a file\n")); + /* already sending a file */ + /* @todo: abort? */ + return ERR_USE; + } + +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + + LWIP_DEBUGF(HTTPD_DEBUG, ("Received %"U16_F" bytes\n", p->tot_len)); + + /* first check allowed characters in this pbuf? */ + + /* enqueue the pbuf */ + if (hs->req == NULL) { + LWIP_DEBUGF(HTTPD_DEBUG, ("First pbuf\n")); + hs->req = p; + } else { + LWIP_DEBUGF(HTTPD_DEBUG, ("pbuf enqueued\n")); + pbuf_cat(hs->req, p); + } + /* increase pbuf ref counter as it is freed when we return but we want to + keep it on the req list */ + pbuf_ref(p); + + if (hs->req->next != NULL) { + data_len = LWIP_MIN(hs->req->tot_len, LWIP_HTTPD_MAX_REQ_LENGTH); + pbuf_copy_partial(hs->req, httpd_req_buf, data_len, 0); + data = httpd_req_buf; + } else +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + { + data = (char *)p->payload; + data_len = p->len; + if (p->len != p->tot_len) { + LWIP_DEBUGF(HTTPD_DEBUG, ("Warning: incomplete header due to chained pbufs\n")); + } + } + + /* received enough data for minimal request? */ + if (data_len >= MIN_REQ_LEN) { + /* wait for CRLF before parsing anything */ + crlf = lwip_strnstr(data, CRLF, data_len); + if (crlf != NULL) { +#if LWIP_HTTPD_SUPPORT_POST + int is_post = 0; +#endif /* LWIP_HTTPD_SUPPORT_POST */ + int is_09 = 0; + char *sp1, *sp2; + u16_t left_len, uri_len; + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("CRLF received, parsing request\n")); + /* parse method */ + if (!strncmp(data, "GET ", 4)) { + sp1 = data + 3; + /* received GET request */ + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Received GET request\"\n")); +#if LWIP_HTTPD_SUPPORT_POST + } else if (!strncmp(data, "POST ", 5)) { + /* store request type */ + is_post = 1; + sp1 = data + 4; + /* received GET request */ + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Received POST request\n")); +#endif /* LWIP_HTTPD_SUPPORT_POST */ + } else { + /* null-terminate the METHOD (pbuf is freed anyway wen returning) */ + data[4] = 0; + /* unsupported method! */ + LWIP_DEBUGF(HTTPD_DEBUG, ("Unsupported request method (not implemented): \"%s\"\n", + data)); + return http_find_error_file(hs, 501); + } + /* if we come here, method is OK, parse URI */ + left_len = (u16_t)(data_len - ((sp1 + 1) - data)); + sp2 = lwip_strnstr(sp1 + 1, " ", left_len); +#if LWIP_HTTPD_SUPPORT_V09 + if (sp2 == NULL) { + /* HTTP 0.9: respond with correct protocol version */ + sp2 = lwip_strnstr(sp1 + 1, CRLF, left_len); + is_09 = 1; +#if LWIP_HTTPD_SUPPORT_POST + if (is_post) { + /* HTTP/0.9 does not support POST */ + goto badrequest; + } +#endif /* LWIP_HTTPD_SUPPORT_POST */ + } +#endif /* LWIP_HTTPD_SUPPORT_V09 */ + uri_len = (u16_t)(sp2 - (sp1 + 1)); + if ((sp2 != 0) && (sp2 > sp1)) { + /* wait for CRLFCRLF (indicating end of HTTP headers) before parsing anything */ + if (lwip_strnstr(data, CRLF CRLF, data_len) != NULL) { + char *uri = sp1 + 1; +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + /* This is HTTP/1.0 compatible: for strict 1.1, a connection + would always be persistent unless "close" was specified. */ + if (!is_09 && (lwip_strnstr(data, HTTP11_CONNECTIONKEEPALIVE, data_len) || + lwip_strnstr(data, HTTP11_CONNECTIONKEEPALIVE2, data_len))) { + hs->keepalive = 1; + } else { + hs->keepalive = 0; + } +#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ + /* null-terminate the METHOD (pbuf is freed anyway wen returning) */ + *sp1 = 0; + uri[uri_len] = 0; + LWIP_DEBUGF(HTTPD_DEBUG, ("Received \"%s\" request for URI: \"%s\"\n", + data, uri)); +#if LWIP_HTTPD_SUPPORT_POST + if (is_post) { +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + struct pbuf *q = hs->req; +#else /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + struct pbuf *q = inp; +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + err = http_post_request(q, hs, data, data_len, uri, sp2); + if (err != ERR_OK) { + /* restore header for next try */ + *sp1 = ' '; + *sp2 = ' '; + uri[uri_len] = ' '; + } + if (err == ERR_ARG) { + goto badrequest; + } + return err; + } else +#endif /* LWIP_HTTPD_SUPPORT_POST */ + { + return http_find_file(hs, uri, is_09); + } + } + } else { + LWIP_DEBUGF(HTTPD_DEBUG, ("invalid URI\n")); + } + } + } + +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + clen = pbuf_clen(hs->req); + if ((hs->req->tot_len <= LWIP_HTTPD_REQ_BUFSIZE) && + (clen <= LWIP_HTTPD_REQ_QUEUELEN)) { + /* request not fully received (too short or CRLF is missing) */ + return ERR_INPROGRESS; + } else +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + { +#if LWIP_HTTPD_SUPPORT_POST +badrequest: +#endif /* LWIP_HTTPD_SUPPORT_POST */ + LWIP_DEBUGF(HTTPD_DEBUG, ("bad request\n")); + /* could not parse request */ + return http_find_error_file(hs, 400); + } +} + +#if LWIP_HTTPD_SSI && (LWIP_HTTPD_SSI_BY_FILE_EXTENSION == 1) +/* Check if SSI should be parsed for this file/URL + * (With LWIP_HTTPD_SSI_BY_FILE_EXTENSION == 2, this function can be + * overridden by an external implementation.) + * + * @return 1 for SSI, 0 for standard files + */ +static u8_t +http_uri_is_ssi(struct fs_file *file, const char *uri) +{ + size_t loop; + u8_t tag_check = 0; + if (file != NULL) { + /* See if we have been asked for an shtml file and, if so, + enable tag checking. */ + const char *ext = NULL, *sub; + char *param = (char *)strstr(uri, "?"); + if (param != NULL) { + /* separate uri from parameters for now, set back later */ + *param = 0; + } + sub = uri; + ext = uri; + for (sub = strstr(sub, "."); sub != NULL; sub = strstr(sub, ".")) { + ext = sub; + sub++; + } + for (loop = 0; loop < NUM_SHTML_EXTENSIONS; loop++) { + if (!lwip_stricmp(ext, g_pcSSIExtensions[loop])) { + tag_check = 1; + break; + } + } + if (param != NULL) { + *param = '?'; + } + } + return tag_check; +} +#endif /* LWIP_HTTPD_SSI */ + +/** Try to find the file specified by uri and, if found, initialize hs + * accordingly. + * + * @param hs the connection state + * @param uri the HTTP header URI + * @param is_09 1 if the request is HTTP/0.9 (no HTTP headers in response) + * @return ERR_OK if file was found and hs has been initialized correctly + * another err_t otherwise + */ +static err_t +http_find_file(struct http_state *hs, const char *uri, int is_09) +{ + size_t loop; + struct fs_file *file = NULL; + char *params = NULL; + err_t err; +#if LWIP_HTTPD_CGI + int i; +#endif /* LWIP_HTTPD_CGI */ +#if !LWIP_HTTPD_SSI + const +#endif /* !LWIP_HTTPD_SSI */ + /* By default, assume we will not be processing server-side-includes tags */ + u8_t tag_check = 0; + + /* Have we been asked for the default file (in root or a directory) ? */ +#if LWIP_HTTPD_MAX_REQUEST_URI_LEN + size_t uri_len = strlen(uri); + if ((uri_len > 0) && (uri[uri_len - 1] == '/') && + ((uri != http_uri_buf) || (uri_len == 1))) { + size_t copy_len = LWIP_MIN(sizeof(http_uri_buf) - 1, uri_len - 1); + if (copy_len > 0) { + MEMCPY(http_uri_buf, uri, copy_len); + http_uri_buf[copy_len] = 0; + } +#else /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */ + if ((uri[0] == '/') && (uri[1] == 0)) { +#endif /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */ + /* Try each of the configured default filenames until we find one + that exists. */ + for (loop = 0; loop < NUM_DEFAULT_FILENAMES; loop++) { + const char *file_name; +#if LWIP_HTTPD_MAX_REQUEST_URI_LEN + if (copy_len > 0) { + size_t len_left = sizeof(http_uri_buf) - copy_len - 1; + if (len_left > 0) { + size_t name_len = strlen(httpd_default_filenames[loop].name); + size_t name_copy_len = LWIP_MIN(len_left, name_len); + MEMCPY(&http_uri_buf[copy_len], httpd_default_filenames[loop].name, name_copy_len); + http_uri_buf[copy_len + name_copy_len] = 0; + } + file_name = http_uri_buf; + } else +#endif /* LWIP_HTTPD_MAX_REQUEST_URI_LEN */ + { + file_name = httpd_default_filenames[loop].name; + } + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Looking for %s...\n", file_name)); + err = fs_open(&hs->file_handle, file_name); + if (err == ERR_OK) { + uri = file_name; + file = &hs->file_handle; + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Opened.\n")); +#if LWIP_HTTPD_SSI + tag_check = httpd_default_filenames[loop].shtml; +#endif /* LWIP_HTTPD_SSI */ + break; + } + } + } + if (file == NULL) { + /* No - we've been asked for a specific file. */ + /* First, isolate the base URI (without any parameters) */ + params = (char *)strchr(uri, '?'); + if (params != NULL) { + /* URI contains parameters. NULL-terminate the base URI */ + *params = '\0'; + params++; + } + +#if LWIP_HTTPD_CGI + http_cgi_paramcount = -1; + /* Does the base URI we have isolated correspond to a CGI handler? */ + if (httpd_num_cgis && httpd_cgis) { + for (i = 0; i < httpd_num_cgis; i++) { + if (strcmp(uri, httpd_cgis[i].pcCGIName) == 0) { + /* + * We found a CGI that handles this URI so extract the + * parameters and call the handler. + */ + http_cgi_paramcount = extract_uri_parameters(hs, params); + uri = httpd_cgis[i].pfnCGIHandler(i, http_cgi_paramcount, hs->params, + hs->param_vals); + break; + } + } + } +#endif /* LWIP_HTTPD_CGI */ + + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("Opening %s\n", uri)); + + err = fs_open(&hs->file_handle, uri); + if (err == ERR_OK) { + file = &hs->file_handle; + } else { + file = http_get_404_file(hs, &uri); + } +#if LWIP_HTTPD_SSI + if (file != NULL) { + if (file->flags & FS_FILE_FLAGS_SSI) { + tag_check = 1; + } else { +#if LWIP_HTTPD_SSI_BY_FILE_EXTENSION + tag_check = http_uri_is_ssi(file, uri); +#endif /* LWIP_HTTPD_SSI_BY_FILE_EXTENSION */ + } + } +#endif /* LWIP_HTTPD_SSI */ + } + if (file == NULL) { + /* None of the default filenames exist so send back a 404 page */ + file = http_get_404_file(hs, &uri); + } + return http_init_file(hs, file, is_09, uri, tag_check, params); +} + +/** Initialize a http connection with a file to send (if found). + * Called by http_find_file and http_find_error_file. + * + * @param hs http connection state + * @param file file structure to send (or NULL if not found) + * @param is_09 1 if the request is HTTP/0.9 (no HTTP headers in response) + * @param uri the HTTP header URI + * @param tag_check enable SSI tag checking + * @param params != NULL if URI has parameters (separated by '?') + * @return ERR_OK if file was found and hs has been initialized correctly + * another err_t otherwise + */ +static err_t +http_init_file(struct http_state *hs, struct fs_file *file, int is_09, const char *uri, + u8_t tag_check, char *params) +{ +#if !LWIP_HTTPD_SUPPORT_V09 + LWIP_UNUSED_ARG(is_09); +#endif + if (file != NULL) { + /* file opened, initialise struct http_state */ +#if !LWIP_HTTPD_DYNAMIC_FILE_READ + /* If dynamic read is disabled, file data must be in one piece and available now */ + LWIP_ASSERT("file->data != NULL", file->data != NULL); +#endif + +#if LWIP_HTTPD_SSI + if (tag_check) { + struct http_ssi_state *ssi = http_ssi_state_alloc(); + if (ssi != NULL) { + ssi->tag_index = 0; + ssi->tag_state = TAG_NONE; + ssi->parsed = file->data; + ssi->parse_left = file->len; + ssi->tag_end = file->data; + hs->ssi = ssi; + } + } +#else /* LWIP_HTTPD_SSI */ + LWIP_UNUSED_ARG(tag_check); +#endif /* LWIP_HTTPD_SSI */ + hs->handle = file; +#if LWIP_HTTPD_CGI_SSI + if (params != NULL) { + /* URI contains parameters, call generic CGI handler */ + int count; +#if LWIP_HTTPD_CGI + if (http_cgi_paramcount >= 0) { + count = http_cgi_paramcount; + } else +#endif + { + count = extract_uri_parameters(hs, params); + } + httpd_cgi_handler(file, uri, count, http_cgi_params, http_cgi_param_vals +#if defined(LWIP_HTTPD_FILE_STATE) && LWIP_HTTPD_FILE_STATE + , file->state +#endif /* LWIP_HTTPD_FILE_STATE */ + ); + } +#else /* LWIP_HTTPD_CGI_SSI */ + LWIP_UNUSED_ARG(params); +#endif /* LWIP_HTTPD_CGI_SSI */ + hs->file = file->data; + LWIP_ASSERT("File length must be positive!", (file->len >= 0)); +#if LWIP_HTTPD_CUSTOM_FILES + if (file->is_custom_file && (file->data == NULL)) { + /* custom file, need to read data first (via fs_read_custom) */ + hs->left = 0; + } else +#endif /* LWIP_HTTPD_CUSTOM_FILES */ + { + hs->left = (u32_t)file->len; + } + hs->retries = 0; +#if LWIP_HTTPD_TIMING + hs->time_started = sys_now(); +#endif /* LWIP_HTTPD_TIMING */ +#if !LWIP_HTTPD_DYNAMIC_HEADERS + LWIP_ASSERT("HTTP headers not included in file system", + (hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) != 0); +#endif /* !LWIP_HTTPD_DYNAMIC_HEADERS */ +#if LWIP_HTTPD_SUPPORT_V09 + if (is_09 && ((hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) != 0)) { + /* HTTP/0.9 responses are sent without HTTP header, + search for the end of the header. */ + char *file_start = lwip_strnstr(hs->file, CRLF CRLF, hs->left); + if (file_start != NULL) { + int diff = file_start + 4 - hs->file; + hs->file += diff; + hs->left -= (u32_t)diff; + } + } +#endif /* LWIP_HTTPD_SUPPORT_V09*/ + } else { + hs->handle = NULL; + hs->file = NULL; + hs->left = 0; + hs->retries = 0; + } +#if LWIP_HTTPD_DYNAMIC_HEADERS + /* Determine the HTTP headers to send based on the file extension of + * the requested URI. */ + if ((hs->handle == NULL) || ((hs->handle->flags & FS_FILE_FLAGS_HEADER_INCLUDED) == 0)) { + get_http_headers(hs, uri); + } +#else /* LWIP_HTTPD_DYNAMIC_HEADERS */ + LWIP_UNUSED_ARG(uri); +#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + if (hs->keepalive) { +#if LWIP_HTTPD_SSI + if (hs->ssi != NULL) { + hs->keepalive = 0; + } else +#endif /* LWIP_HTTPD_SSI */ + { + if ((hs->handle != NULL) && + ((hs->handle->flags & (FS_FILE_FLAGS_HEADER_INCLUDED | FS_FILE_FLAGS_HEADER_PERSISTENT)) == FS_FILE_FLAGS_HEADER_INCLUDED)) { + hs->keepalive = 0; + } + } + } +#endif /* LWIP_HTTPD_SUPPORT_11_KEEPALIVE */ + return ERR_OK; +} + +/** + * The pcb had an error and is already deallocated. + * The argument might still be valid (if != NULL). + */ +static void +http_err(void *arg, err_t err) +{ + struct http_state *hs = (struct http_state *)arg; + LWIP_UNUSED_ARG(err); + + LWIP_DEBUGF(HTTPD_DEBUG, ("http_err: %s", lwip_strerr(err))); + + if (hs != NULL) { + http_state_free(hs); + } +} + +/** + * Data has been sent and acknowledged by the remote host. + * This means that more data can be sent. + */ +static err_t +http_sent(void *arg, struct altcp_pcb *pcb, u16_t len) +{ + struct http_state *hs = (struct http_state *)arg; + + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_sent %p\n", (void *)pcb)); + + LWIP_UNUSED_ARG(len); + + if (hs == NULL) { + return ERR_OK; + } + + hs->retries = 0; + + http_send(pcb, hs); + + return ERR_OK; +} + +/** + * The poll function is called every 2nd second. + * If there has been no data sent (which resets the retries) in 8 seconds, close. + * If the last portion of a file has not been sent in 2 seconds, close. + * + * This could be increased, but we don't want to waste resources for bad connections. + */ +static err_t +http_poll(void *arg, struct altcp_pcb *pcb) +{ + struct http_state *hs = (struct http_state *)arg; + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_poll: pcb=%p hs=%p pcb_state=%s\n", + (void *)pcb, (void *)hs, tcp_debug_state_str(altcp_dbg_get_tcp_state(pcb)))); + + if (hs == NULL) { + err_t closed; + /* arg is null, close. */ + LWIP_DEBUGF(HTTPD_DEBUG, ("http_poll: arg is NULL, close\n")); + closed = http_close_conn(pcb, NULL); + LWIP_UNUSED_ARG(closed); +#if LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR + if (closed == ERR_MEM) { + altcp_abort(pcb); + return ERR_ABRT; + } +#endif /* LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR */ + return ERR_OK; + } else { + hs->retries++; + if (hs->retries == HTTPD_MAX_RETRIES) { + LWIP_DEBUGF(HTTPD_DEBUG, ("http_poll: too many retries, close\n")); + http_close_conn(pcb, hs); + return ERR_OK; + } + + /* If this connection has a file open, try to send some more data. If + * it has not yet received a GET request, don't do this since it will + * cause the connection to close immediately. */ + if (hs->handle) { + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_poll: try to send more data\n")); + if (http_send(pcb, hs)) { + /* If we wrote anything to be sent, go ahead and send it now. */ + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("tcp_output\n")); + altcp_output(pcb); + } + } + } + + return ERR_OK; +} + +/** + * Data has been received on this pcb. + * For HTTP 1.0, this should normally only happen once (if the request fits in one packet). + */ +static err_t +http_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) +{ + struct http_state *hs = (struct http_state *)arg; + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_recv: pcb=%p pbuf=%p err=%s\n", (void *)pcb, + (void *)p, lwip_strerr(err))); + + if ((err != ERR_OK) || (p == NULL) || (hs == NULL)) { + /* error or closed by other side? */ + if (p != NULL) { + /* Inform TCP that we have taken the data. */ + altcp_recved(pcb, p->tot_len); + pbuf_free(p); + } + if (hs == NULL) { + /* this should not happen, only to be robust */ + LWIP_DEBUGF(HTTPD_DEBUG, ("Error, http_recv: hs is NULL, close\n")); + } + http_close_conn(pcb, hs); + return ERR_OK; + } + +#if LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND + if (hs->no_auto_wnd) { + hs->unrecved_bytes += p->tot_len; + } else +#endif /* LWIP_HTTPD_SUPPORT_POST && LWIP_HTTPD_POST_MANUAL_WND */ + { + /* Inform TCP that we have taken the data. */ + altcp_recved(pcb, p->tot_len); + } + +#if LWIP_HTTPD_SUPPORT_POST + if (hs->post_content_len_left > 0) { + /* reset idle counter when POST data is received */ + hs->retries = 0; + /* this is data for a POST, pass the complete pbuf to the application */ + http_post_rxpbuf(hs, p); + /* pbuf is passed to the application, don't free it! */ + if (hs->post_content_len_left == 0) { + /* all data received, send response or close connection */ + http_send(pcb, hs); + } + return ERR_OK; + } else +#endif /* LWIP_HTTPD_SUPPORT_POST */ + { + if (hs->handle == NULL) { + err_t parsed = http_parse_request(p, hs, pcb); + LWIP_ASSERT("http_parse_request: unexpected return value", parsed == ERR_OK + || parsed == ERR_INPROGRESS || parsed == ERR_ARG || parsed == ERR_USE); +#if LWIP_HTTPD_SUPPORT_REQUESTLIST + if (parsed != ERR_INPROGRESS) { + /* request fully parsed or error */ + if (hs->req != NULL) { + pbuf_free(hs->req); + hs->req = NULL; + } + } +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + pbuf_free(p); + if (parsed == ERR_OK) { +#if LWIP_HTTPD_SUPPORT_POST + if (hs->post_content_len_left == 0) +#endif /* LWIP_HTTPD_SUPPORT_POST */ + { + LWIP_DEBUGF(HTTPD_DEBUG | LWIP_DBG_TRACE, ("http_recv: data %p len %"S32_F"\n", (const void *)hs->file, hs->left)); + http_send(pcb, hs); + } + } else if (parsed == ERR_ARG) { + /* @todo: close on ERR_USE? */ + http_close_conn(pcb, hs); + } + } else { + LWIP_DEBUGF(HTTPD_DEBUG, ("http_recv: already sending data\n")); + /* already sending but still receiving data, we might want to RST here? */ + pbuf_free(p); + } + } + return ERR_OK; +} + +/** + * A new incoming connection has been accepted. + */ +static err_t +http_accept(void *arg, struct altcp_pcb *pcb, err_t err) +{ + struct http_state *hs; + LWIP_UNUSED_ARG(err); + LWIP_UNUSED_ARG(arg); + LWIP_DEBUGF(HTTPD_DEBUG, ("http_accept %p / %p\n", (void *)pcb, arg)); + + if ((err != ERR_OK) || (pcb == NULL)) { + return ERR_VAL; + } + + /* Set priority */ + altcp_setprio(pcb, HTTPD_TCP_PRIO); + + /* Allocate memory for the structure that holds the state of the + connection - initialized by that function. */ + hs = http_state_alloc(); + if (hs == NULL) { + LWIP_DEBUGF(HTTPD_DEBUG, ("http_accept: Out of memory, RST\n")); + return ERR_MEM; + } + hs->pcb = pcb; + + /* Tell TCP that this is the structure we wish to be passed for our + callbacks. */ + altcp_arg(pcb, hs); + + /* Set up the various callback functions */ + altcp_recv(pcb, http_recv); + altcp_err(pcb, http_err); + altcp_poll(pcb, http_poll, HTTPD_POLL_INTERVAL); + altcp_sent(pcb, http_sent); + + return ERR_OK; +} + +static void +httpd_init_pcb(struct altcp_pcb *pcb, u16_t port) +{ + err_t err; + + if (pcb) { + altcp_setprio(pcb, HTTPD_TCP_PRIO); + /* set SOF_REUSEADDR here to explicitly bind httpd to multiple interfaces */ + err = altcp_bind(pcb, IP_ANY_TYPE, port); + LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */ + LWIP_ASSERT("httpd_init: tcp_bind failed", err == ERR_OK); + pcb = altcp_listen(pcb); + LWIP_ASSERT("httpd_init: tcp_listen failed", pcb != NULL); + altcp_accept(pcb, http_accept); + } +} + +/** + * @ingroup httpd + * Initialize the httpd: set up a listening PCB and bind it to the defined port + */ +void +httpd_init(void) +{ + struct altcp_pcb *pcb; + +#if HTTPD_USE_MEM_POOL + LWIP_MEMPOOL_INIT(HTTPD_STATE); +#if LWIP_HTTPD_SSI + LWIP_MEMPOOL_INIT(HTTPD_SSI_STATE); +#endif +#endif + LWIP_DEBUGF(HTTPD_DEBUG, ("httpd_init\n")); + + /* LWIP_ASSERT_CORE_LOCKED(); is checked by tcp_new() */ + + pcb = altcp_tcp_new_ip_type(IPADDR_TYPE_ANY); + LWIP_ASSERT("httpd_init: tcp_new failed", pcb != NULL); + httpd_init_pcb(pcb, HTTPD_SERVER_PORT); +} + +#if HTTPD_ENABLE_HTTPS +/** + * @ingroup httpd + * Initialize the httpd: set up a listening PCB and bind it to the defined port. + * Also set up TLS connection handling (HTTPS). + */ +void +httpd_inits(struct altcp_tls_config *conf) +{ +#if LWIP_ALTCP_TLS + struct altcp_pcb *pcb_tls = altcp_tls_new(conf, IPADDR_TYPE_ANY); + LWIP_ASSERT("httpd_init: altcp_tls_new failed", pcb_tls != NULL); + httpd_init_pcb(pcb_tls, HTTPD_SERVER_PORT_HTTPS); +#else /* LWIP_ALTCP_TLS */ + LWIP_UNUSED_ARG(conf); +#endif /* LWIP_ALTCP_TLS */ +} +#endif /* HTTPD_ENABLE_HTTPS */ + +#if LWIP_HTTPD_SSI +/** + * @ingroup httpd + * Set the SSI handler function. + * + * @param ssi_handler the SSI handler function + * @param tags an array of SSI tag strings to search for in SSI-enabled files + * @param num_tags number of tags in the 'tags' array + */ +void +http_set_ssi_handler(tSSIHandler ssi_handler, const char **tags, int num_tags) +{ + LWIP_DEBUGF(HTTPD_DEBUG, ("http_set_ssi_handler\n")); + + LWIP_ASSERT("no ssi_handler given", ssi_handler != NULL); + httpd_ssi_handler = ssi_handler; + +#if LWIP_HTTPD_SSI_RAW + LWIP_UNUSED_ARG(tags); + LWIP_UNUSED_ARG(num_tags); +#else /* LWIP_HTTPD_SSI_RAW */ + LWIP_ASSERT("no tags given", tags != NULL); + LWIP_ASSERT("invalid number of tags", num_tags > 0); + + httpd_tags = tags; + httpd_num_tags = num_tags; +#endif /* !LWIP_HTTPD_SSI_RAW */ +} +#endif /* LWIP_HTTPD_SSI */ + +#if LWIP_HTTPD_CGI +/** + * @ingroup httpd + * Set an array of CGI filenames/handler functions + * + * @param cgis an array of CGI filenames/handler functions + * @param num_handlers number of elements in the 'cgis' array + */ +void +http_set_cgi_handlers(const tCGI *cgis, int num_handlers) +{ + LWIP_ASSERT("no cgis given", cgis != NULL); + LWIP_ASSERT("invalid number of handlers", num_handlers > 0); + + httpd_cgis = cgis; + httpd_num_cgis = num_handlers; +} +#endif /* LWIP_HTTPD_CGI */ + +#endif /* LWIP_TCP && LWIP_CALLBACK_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd_structs.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd_structs.h index 519533af..56b97a32 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd_structs.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/httpd_structs.h @@ -1,123 +1,123 @@ -#ifndef LWIP_HTTPD_STRUCTS_H -#define LWIP_HTTPD_STRUCTS_H - -#include "lwip/apps/httpd.h" - -#if LWIP_HTTPD_DYNAMIC_HEADERS -/** This struct is used for a list of HTTP header strings for various - * filename extensions. */ -typedef struct { - const char *extension; - const char *content_type; -} tHTTPHeader; - -/** A list of strings used in HTTP headers (see RFC 1945 HTTP/1.0 and - * RFC 2616 HTTP/1.1 for header field definitions) */ -static const char *const g_psHTTPHeaderStrings[] = { - "HTTP/1.0 200 OK\r\n", - "HTTP/1.0 404 File not found\r\n", - "HTTP/1.0 400 Bad Request\r\n", - "HTTP/1.0 501 Not Implemented\r\n", - "HTTP/1.1 200 OK\r\n", - "HTTP/1.1 404 File not found\r\n", - "HTTP/1.1 400 Bad Request\r\n", - "HTTP/1.1 501 Not Implemented\r\n", - "Content-Length: ", - "Connection: Close\r\n", - "Connection: keep-alive\r\n", - "Connection: keep-alive\r\nContent-Length: ", - "Server: "HTTPD_SERVER_AGENT"\r\n", - "\r\n

404: The requested file cannot be found.

\r\n" -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE - , "Connection: keep-alive\r\nContent-Length: 77\r\n\r\n

404: The requested file cannot be found.

\r\n" -#endif -}; - -/* Indexes into the g_psHTTPHeaderStrings array */ -#define HTTP_HDR_OK 0 /* 200 OK */ -#define HTTP_HDR_NOT_FOUND 1 /* 404 File not found */ -#define HTTP_HDR_BAD_REQUEST 2 /* 400 Bad request */ -#define HTTP_HDR_NOT_IMPL 3 /* 501 Not Implemented */ -#define HTTP_HDR_OK_11 4 /* 200 OK */ -#define HTTP_HDR_NOT_FOUND_11 5 /* 404 File not found */ -#define HTTP_HDR_BAD_REQUEST_11 6 /* 400 Bad request */ -#define HTTP_HDR_NOT_IMPL_11 7 /* 501 Not Implemented */ -#define HTTP_HDR_CONTENT_LENGTH 8 /* Content-Length: (HTTP 1.0)*/ -#define HTTP_HDR_CONN_CLOSE 9 /* Connection: Close (HTTP 1.1) */ -#define HTTP_HDR_CONN_KEEPALIVE 10 /* Connection: keep-alive (HTTP 1.1) */ -#define HTTP_HDR_KEEPALIVE_LEN 11 /* Connection: keep-alive + Content-Length: (HTTP 1.1)*/ -#define HTTP_HDR_SERVER 12 /* Server: HTTPD_SERVER_AGENT */ -#define DEFAULT_404_HTML 13 /* default 404 body */ -#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE -#define DEFAULT_404_HTML_PERSISTENT 14 /* default 404 body, but including Connection: keep-alive */ -#endif - -#define HTTP_CONTENT_TYPE(contenttype) "Content-Type: "contenttype"\r\n\r\n" -#define HTTP_CONTENT_TYPE_ENCODING(contenttype, encoding) "Content-Type: "contenttype"\r\nContent-Encoding: "encoding"\r\n\r\n" - -#define HTTP_HDR_HTML HTTP_CONTENT_TYPE("text/html") -#define HTTP_HDR_SSI HTTP_CONTENT_TYPE("text/html\r\nExpires: Fri, 10 Apr 2008 14:00:00 GMT\r\nPragma: no-cache") -#define HTTP_HDR_GIF HTTP_CONTENT_TYPE("image/gif") -#define HTTP_HDR_PNG HTTP_CONTENT_TYPE("image/png") -#define HTTP_HDR_JPG HTTP_CONTENT_TYPE("image/jpeg") -#define HTTP_HDR_BMP HTTP_CONTENT_TYPE("image/bmp") -#define HTTP_HDR_ICO HTTP_CONTENT_TYPE("image/x-icon") -#define HTTP_HDR_APP HTTP_CONTENT_TYPE("application/octet-stream") -#define HTTP_HDR_JS HTTP_CONTENT_TYPE("application/javascript") -#define HTTP_HDR_RA HTTP_CONTENT_TYPE("application/javascript") -#define HTTP_HDR_CSS HTTP_CONTENT_TYPE("text/css") -#define HTTP_HDR_SWF HTTP_CONTENT_TYPE("application/x-shockwave-flash") -#define HTTP_HDR_XML HTTP_CONTENT_TYPE("text/xml") -#define HTTP_HDR_PDF HTTP_CONTENT_TYPE("application/pdf") -#define HTTP_HDR_JSON HTTP_CONTENT_TYPE("application/json") -#define HTTP_HDR_CSV HTTP_CONTENT_TYPE("text/csv") -#define HTTP_HDR_TSV HTTP_CONTENT_TYPE("text/tsv") -#define HTTP_HDR_SVG HTTP_CONTENT_TYPE("image/svg+xml") -#define HTTP_HDR_SVGZ HTTP_CONTENT_TYPE_ENCODING("image/svg+xml", "gzip") - -#define HTTP_HDR_DEFAULT_TYPE HTTP_CONTENT_TYPE("text/plain") - -/** A list of extension-to-HTTP header strings (see outdated RFC 1700 MEDIA TYPES - * and http://www.iana.org/assignments/media-types for registered content types - * and subtypes) */ -static const tHTTPHeader g_psHTTPHeaders[] = { - { "html", HTTP_HDR_HTML}, - { "htm", HTTP_HDR_HTML}, - { "shtml", HTTP_HDR_SSI}, - { "shtm", HTTP_HDR_SSI}, - { "ssi", HTTP_HDR_SSI}, - { "gif", HTTP_HDR_GIF}, - { "png", HTTP_HDR_PNG}, - { "jpg", HTTP_HDR_JPG}, - { "bmp", HTTP_HDR_BMP}, - { "ico", HTTP_HDR_ICO}, - { "class", HTTP_HDR_APP}, - { "cls", HTTP_HDR_APP}, - { "js", HTTP_HDR_JS}, - { "ram", HTTP_HDR_RA}, - { "css", HTTP_HDR_CSS}, - { "swf", HTTP_HDR_SWF}, - { "xml", HTTP_HDR_XML}, - { "xsl", HTTP_HDR_XML}, - { "pdf", HTTP_HDR_PDF}, - { "json", HTTP_HDR_JSON} -#ifdef HTTPD_ADDITIONAL_CONTENT_TYPES - /* If you need to add content types not listed here: - * #define HTTPD_ADDITIONAL_CONTENT_TYPES {"ct1", HTTP_CONTENT_TYPE("text/ct1")}, {"exe", HTTP_CONTENT_TYPE("application/exe")} - */ - , HTTPD_ADDITIONAL_CONTENT_TYPES -#endif -}; - -#define NUM_HTTP_HEADERS LWIP_ARRAYSIZE(g_psHTTPHeaders) - -#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ - -#if LWIP_HTTPD_SSI -static const char *const g_pcSSIExtensions[] = { - ".shtml", ".shtm", ".ssi", ".xml", ".json" -}; -#define NUM_SHTML_EXTENSIONS LWIP_ARRAYSIZE(g_pcSSIExtensions) -#endif /* LWIP_HTTPD_SSI */ - -#endif /* LWIP_HTTPD_STRUCTS_H */ +#ifndef LWIP_HTTPD_STRUCTS_H +#define LWIP_HTTPD_STRUCTS_H + +#include "lwip/apps/httpd.h" + +#if LWIP_HTTPD_DYNAMIC_HEADERS +/** This struct is used for a list of HTTP header strings for various + * filename extensions. */ +typedef struct { + const char *extension; + const char *content_type; +} tHTTPHeader; + +/** A list of strings used in HTTP headers (see RFC 1945 HTTP/1.0 and + * RFC 2616 HTTP/1.1 for header field definitions) */ +static const char *const g_psHTTPHeaderStrings[] = { + "HTTP/1.0 200 OK\r\n", + "HTTP/1.0 404 File not found\r\n", + "HTTP/1.0 400 Bad Request\r\n", + "HTTP/1.0 501 Not Implemented\r\n", + "HTTP/1.1 200 OK\r\n", + "HTTP/1.1 404 File not found\r\n", + "HTTP/1.1 400 Bad Request\r\n", + "HTTP/1.1 501 Not Implemented\r\n", + "Content-Length: ", + "Connection: Close\r\n", + "Connection: keep-alive\r\n", + "Connection: keep-alive\r\nContent-Length: ", + "Server: "HTTPD_SERVER_AGENT"\r\n", + "\r\n

404: The requested file cannot be found.

\r\n" +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE + , "Connection: keep-alive\r\nContent-Length: 77\r\n\r\n

404: The requested file cannot be found.

\r\n" +#endif +}; + +/* Indexes into the g_psHTTPHeaderStrings array */ +#define HTTP_HDR_OK 0 /* 200 OK */ +#define HTTP_HDR_NOT_FOUND 1 /* 404 File not found */ +#define HTTP_HDR_BAD_REQUEST 2 /* 400 Bad request */ +#define HTTP_HDR_NOT_IMPL 3 /* 501 Not Implemented */ +#define HTTP_HDR_OK_11 4 /* 200 OK */ +#define HTTP_HDR_NOT_FOUND_11 5 /* 404 File not found */ +#define HTTP_HDR_BAD_REQUEST_11 6 /* 400 Bad request */ +#define HTTP_HDR_NOT_IMPL_11 7 /* 501 Not Implemented */ +#define HTTP_HDR_CONTENT_LENGTH 8 /* Content-Length: (HTTP 1.0)*/ +#define HTTP_HDR_CONN_CLOSE 9 /* Connection: Close (HTTP 1.1) */ +#define HTTP_HDR_CONN_KEEPALIVE 10 /* Connection: keep-alive (HTTP 1.1) */ +#define HTTP_HDR_KEEPALIVE_LEN 11 /* Connection: keep-alive + Content-Length: (HTTP 1.1)*/ +#define HTTP_HDR_SERVER 12 /* Server: HTTPD_SERVER_AGENT */ +#define DEFAULT_404_HTML 13 /* default 404 body */ +#if LWIP_HTTPD_SUPPORT_11_KEEPALIVE +#define DEFAULT_404_HTML_PERSISTENT 14 /* default 404 body, but including Connection: keep-alive */ +#endif + +#define HTTP_CONTENT_TYPE(contenttype) "Content-Type: "contenttype"\r\n\r\n" +#define HTTP_CONTENT_TYPE_ENCODING(contenttype, encoding) "Content-Type: "contenttype"\r\nContent-Encoding: "encoding"\r\n\r\n" + +#define HTTP_HDR_HTML HTTP_CONTENT_TYPE("text/html") +#define HTTP_HDR_SSI HTTP_CONTENT_TYPE("text/html\r\nExpires: Fri, 10 Apr 2008 14:00:00 GMT\r\nPragma: no-cache") +#define HTTP_HDR_GIF HTTP_CONTENT_TYPE("image/gif") +#define HTTP_HDR_PNG HTTP_CONTENT_TYPE("image/png") +#define HTTP_HDR_JPG HTTP_CONTENT_TYPE("image/jpeg") +#define HTTP_HDR_BMP HTTP_CONTENT_TYPE("image/bmp") +#define HTTP_HDR_ICO HTTP_CONTENT_TYPE("image/x-icon") +#define HTTP_HDR_APP HTTP_CONTENT_TYPE("application/octet-stream") +#define HTTP_HDR_JS HTTP_CONTENT_TYPE("application/javascript") +#define HTTP_HDR_RA HTTP_CONTENT_TYPE("application/javascript") +#define HTTP_HDR_CSS HTTP_CONTENT_TYPE("text/css") +#define HTTP_HDR_SWF HTTP_CONTENT_TYPE("application/x-shockwave-flash") +#define HTTP_HDR_XML HTTP_CONTENT_TYPE("text/xml") +#define HTTP_HDR_PDF HTTP_CONTENT_TYPE("application/pdf") +#define HTTP_HDR_JSON HTTP_CONTENT_TYPE("application/json") +#define HTTP_HDR_CSV HTTP_CONTENT_TYPE("text/csv") +#define HTTP_HDR_TSV HTTP_CONTENT_TYPE("text/tsv") +#define HTTP_HDR_SVG HTTP_CONTENT_TYPE("image/svg+xml") +#define HTTP_HDR_SVGZ HTTP_CONTENT_TYPE_ENCODING("image/svg+xml", "gzip") + +#define HTTP_HDR_DEFAULT_TYPE HTTP_CONTENT_TYPE("text/plain") + +/** A list of extension-to-HTTP header strings (see outdated RFC 1700 MEDIA TYPES + * and http://www.iana.org/assignments/media-types for registered content types + * and subtypes) */ +static const tHTTPHeader g_psHTTPHeaders[] = { + { "html", HTTP_HDR_HTML}, + { "htm", HTTP_HDR_HTML}, + { "shtml", HTTP_HDR_SSI}, + { "shtm", HTTP_HDR_SSI}, + { "ssi", HTTP_HDR_SSI}, + { "gif", HTTP_HDR_GIF}, + { "png", HTTP_HDR_PNG}, + { "jpg", HTTP_HDR_JPG}, + { "bmp", HTTP_HDR_BMP}, + { "ico", HTTP_HDR_ICO}, + { "class", HTTP_HDR_APP}, + { "cls", HTTP_HDR_APP}, + { "js", HTTP_HDR_JS}, + { "ram", HTTP_HDR_RA}, + { "css", HTTP_HDR_CSS}, + { "swf", HTTP_HDR_SWF}, + { "xml", HTTP_HDR_XML}, + { "xsl", HTTP_HDR_XML}, + { "pdf", HTTP_HDR_PDF}, + { "json", HTTP_HDR_JSON} +#ifdef HTTPD_ADDITIONAL_CONTENT_TYPES + /* If you need to add content types not listed here: + * #define HTTPD_ADDITIONAL_CONTENT_TYPES {"ct1", HTTP_CONTENT_TYPE("text/ct1")}, {"exe", HTTP_CONTENT_TYPE("application/exe")} + */ + , HTTPD_ADDITIONAL_CONTENT_TYPES +#endif +}; + +#define NUM_HTTP_HEADERS LWIP_ARRAYSIZE(g_psHTTPHeaders) + +#endif /* LWIP_HTTPD_DYNAMIC_HEADERS */ + +#if LWIP_HTTPD_SSI +static const char *const g_pcSSIExtensions[] = { + ".shtml", ".shtm", ".ssi", ".xml", ".json" +}; +#define NUM_SHTML_EXTENSIONS LWIP_ARRAYSIZE(g_pcSSIExtensions) +#endif /* LWIP_HTTPD_SSI */ + +#endif /* LWIP_HTTPD_STRUCTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata index 981c3d18..37b4203e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata @@ -1,97 +1,97 @@ -#!/usr/bin/perl - -open(OUTPUT, "> fsdata.c"); - -chdir("fs"); -open(FILES, "find . -type f |"); - -while($file = ) { - - # Do not include files in CVS directories nor backup files. - if($file =~ /(CVS|~)/) { - next; - } - - chop($file); - - open(HEADER, "> /tmp/header") || die $!; - if($file =~ /404/) { - print(HEADER "HTTP/1.0 404 File not found\r\n"); - } else { - print(HEADER "HTTP/1.0 200 OK\r\n"); - } - print(HEADER "Server: lwIP/pre-0.6 (http://www.sics.se/~adam/lwip/)\r\n"); - if($file =~ /\.html$/) { - print(HEADER "Content-type: text/html\r\n"); - } elsif($file =~ /\.gif$/) { - print(HEADER "Content-type: image/gif\r\n"); - } elsif($file =~ /\.png$/) { - print(HEADER "Content-type: image/png\r\n"); - } elsif($file =~ /\.jpg$/) { - print(HEADER "Content-type: image/jpeg\r\n"); - } elsif($file =~ /\.class$/) { - print(HEADER "Content-type: application/octet-stream\r\n"); - } elsif($file =~ /\.ram$/) { - print(HEADER "Content-type: audio/x-pn-realaudio\r\n"); - } else { - print(HEADER "Content-type: text/plain\r\n"); - } - print(HEADER "\r\n"); - close(HEADER); - - unless($file =~ /\.plain$/ || $file =~ /cgi/) { - system("cat /tmp/header $file > /tmp/file"); - } else { - system("cp $file /tmp/file"); - } - - open(FILE, "/tmp/file"); - unlink("/tmp/file"); - unlink("/tmp/header"); - - $file =~ s/\.//; - $fvar = $file; - $fvar =~ s-/-_-g; - $fvar =~ s-\.-_-g; - print(OUTPUT "static const unsigned char data".$fvar."[] = {\n"); - print(OUTPUT "\t/* $file */\n\t"); - for($j = 0; $j < length($file); $j++) { - printf(OUTPUT "%#02x, ", unpack("C", substr($file, $j, 1))); - } - printf(OUTPUT "0,\n"); - - - $i = 0; - while(read(FILE, $data, 1)) { - if($i == 0) { - print(OUTPUT "\t"); - } - printf(OUTPUT "%#02x, ", unpack("C", $data)); - $i++; - if($i == 10) { - print(OUTPUT "\n"); - $i = 0; - } - } - print(OUTPUT "};\n\n"); - close(FILE); - push(@fvars, $fvar); - push(@files, $file); -} - -for($i = 0; $i < @fvars; $i++) { - $file = $files[$i]; - $fvar = $fvars[$i]; - - if($i == 0) { - $prevfile = "NULL"; - } else { - $prevfile = "file" . $fvars[$i - 1]; - } - print(OUTPUT "const struct fsdata_file file".$fvar."[] = {{$prevfile, data$fvar, "); - print(OUTPUT "data$fvar + ". (length($file) + 1) .", "); - print(OUTPUT "sizeof(data$fvar) - ". (length($file) + 1) ."}};\n\n"); -} - -print(OUTPUT "#define FS_ROOT file$fvars[$i - 1]\n\n"); -print(OUTPUT "#define FS_NUMFILES $i\n"); +#!/usr/bin/perl + +open(OUTPUT, "> fsdata.c"); + +chdir("fs"); +open(FILES, "find . -type f |"); + +while($file = ) { + + # Do not include files in CVS directories nor backup files. + if($file =~ /(CVS|~)/) { + next; + } + + chop($file); + + open(HEADER, "> /tmp/header") || die $!; + if($file =~ /404/) { + print(HEADER "HTTP/1.0 404 File not found\r\n"); + } else { + print(HEADER "HTTP/1.0 200 OK\r\n"); + } + print(HEADER "Server: lwIP/pre-0.6 (http://www.sics.se/~adam/lwip/)\r\n"); + if($file =~ /\.html$/) { + print(HEADER "Content-type: text/html\r\n"); + } elsif($file =~ /\.gif$/) { + print(HEADER "Content-type: image/gif\r\n"); + } elsif($file =~ /\.png$/) { + print(HEADER "Content-type: image/png\r\n"); + } elsif($file =~ /\.jpg$/) { + print(HEADER "Content-type: image/jpeg\r\n"); + } elsif($file =~ /\.class$/) { + print(HEADER "Content-type: application/octet-stream\r\n"); + } elsif($file =~ /\.ram$/) { + print(HEADER "Content-type: audio/x-pn-realaudio\r\n"); + } else { + print(HEADER "Content-type: text/plain\r\n"); + } + print(HEADER "\r\n"); + close(HEADER); + + unless($file =~ /\.plain$/ || $file =~ /cgi/) { + system("cat /tmp/header $file > /tmp/file"); + } else { + system("cp $file /tmp/file"); + } + + open(FILE, "/tmp/file"); + unlink("/tmp/file"); + unlink("/tmp/header"); + + $file =~ s/\.//; + $fvar = $file; + $fvar =~ s-/-_-g; + $fvar =~ s-\.-_-g; + print(OUTPUT "static const unsigned char data".$fvar."[] = {\n"); + print(OUTPUT "\t/* $file */\n\t"); + for($j = 0; $j < length($file); $j++) { + printf(OUTPUT "%#02x, ", unpack("C", substr($file, $j, 1))); + } + printf(OUTPUT "0,\n"); + + + $i = 0; + while(read(FILE, $data, 1)) { + if($i == 0) { + print(OUTPUT "\t"); + } + printf(OUTPUT "%#02x, ", unpack("C", $data)); + $i++; + if($i == 10) { + print(OUTPUT "\n"); + $i = 0; + } + } + print(OUTPUT "};\n\n"); + close(FILE); + push(@fvars, $fvar); + push(@files, $file); +} + +for($i = 0; $i < @fvars; $i++) { + $file = $files[$i]; + $fvar = $fvars[$i]; + + if($i == 0) { + $prevfile = "NULL"; + } else { + $prevfile = "file" . $fvars[$i - 1]; + } + print(OUTPUT "const struct fsdata_file file".$fvar."[] = {{$prevfile, data$fvar, "); + print(OUTPUT "data$fvar + ". (length($file) + 1) .", "); + print(OUTPUT "sizeof(data$fvar) - ". (length($file) + 1) ."}};\n\n"); +} + +print(OUTPUT "#define FS_ROOT file$fvars[$i - 1]\n\n"); +print(OUTPUT "#define FS_NUMFILES $i\n"); diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata.c index 1906ce22..695e94f5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/makefsdata.c @@ -1,1251 +1,1251 @@ -/** - * makefsdata: Converts a directory structure for use with the lwIP httpd. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Jim Pettinato - * Simon Goldschmidt - * - * @todo: - * - take TCP_MSS, LWIP_TCP_TIMESTAMPS and - * PAYLOAD_ALIGN_TYPE/PAYLOAD_ALIGNMENT as arguments - */ - -#include -#include -#include -#include -#include - -#include "tinydir.h" - -/** Makefsdata can generate *all* files deflate-compressed (where file size shrinks). - * Since nearly all browsers support this, this is a good way to reduce ROM size. - * To compress the files, "miniz.c" must be downloaded seperately. - */ -#ifndef MAKEFS_SUPPORT_DEFLATE -#define MAKEFS_SUPPORT_DEFLATE 0 -#endif - -#define COPY_BUFSIZE (1024*1024) /* 1 MByte */ - -#if MAKEFS_SUPPORT_DEFLATE -#include "../miniz.c" - -typedef unsigned char uint8; -typedef unsigned short uint16; -typedef unsigned int uint; - -#define my_max(a,b) (((a) > (b)) ? (a) : (b)) -#define my_min(a,b) (((a) < (b)) ? (a) : (b)) - -/* COMP_OUT_BUF_SIZE is the size of the output buffer used during compression. - COMP_OUT_BUF_SIZE must be >= 1 and <= OUT_BUF_SIZE */ -#define COMP_OUT_BUF_SIZE COPY_BUFSIZE - -/* OUT_BUF_SIZE is the size of the output buffer used during decompression. - OUT_BUF_SIZE must be a power of 2 >= TINFL_LZ_DICT_SIZE (because the low-level decompressor not only writes, but reads from the output buffer as it decompresses) */ -#define OUT_BUF_SIZE COPY_BUFSIZE -static uint8 s_outbuf[OUT_BUF_SIZE]; -static uint8 s_checkbuf[OUT_BUF_SIZE]; - -/* tdefl_compressor contains all the state needed by the low-level compressor so it's a pretty big struct (~300k). - This example makes it a global vs. putting it on the stack, of course in real-world usage you'll probably malloc() or new it. */ -tdefl_compressor g_deflator; -tinfl_decompressor g_inflator; - -int deflate_level = 10; /* default compression level, can be changed via command line */ -#define USAGE_ARG_DEFLATE " [-defl<:compr_level>]" -#else /* MAKEFS_SUPPORT_DEFLATE */ -#define USAGE_ARG_DEFLATE "" -#endif /* MAKEFS_SUPPORT_DEFLATE */ - -#ifdef WIN32 - -#define GETCWD(path, len) GetCurrentDirectoryA(len, path) -#define CHDIR(path) SetCurrentDirectoryA(path) -#define CHDIR_SUCCEEDED(ret) (ret == TRUE) - -#elif __linux__ - -#define GETCWD(path, len) getcwd(path, len) -#define CHDIR(path) chdir(path) -#define CHDIR_SUCCEEDED(ret) (ret == 0) - -#else - -#error makefsdata not supported on this platform - -#endif - -#define NEWLINE "\r\n" -#define NEWLINE_LEN 2 - -/* define this to get the header variables we use to build HTTP headers */ -#define LWIP_HTTPD_DYNAMIC_HEADERS 1 -#define LWIP_HTTPD_SSI 1 -#include "lwip/init.h" -#include "../httpd_structs.h" -#include "lwip/apps/fs.h" - -#include "../core/inet_chksum.c" -#include "../core/def.c" - -/** (Your server name here) */ -const char *serverID = "Server: "HTTPD_SERVER_AGENT"\r\n"; -char serverIDBuffer[1024]; - -/* change this to suit your MEM_ALIGNMENT */ -#define PAYLOAD_ALIGNMENT 4 -/* set this to 0 to prevent aligning payload */ -#define ALIGN_PAYLOAD 1 -/* define this to a type that has the required alignment */ -#define PAYLOAD_ALIGN_TYPE "unsigned int" -static int payload_alingment_dummy_counter = 0; - -#define HEX_BYTES_PER_LINE 16 - -#define MAX_PATH_LEN 256 - -struct file_entry { - struct file_entry *next; - const char *filename_c; -}; - -int process_sub(FILE *data_file, FILE *struct_file); -int process_file(FILE *data_file, FILE *struct_file, const char *filename); -int file_write_http_header(FILE *data_file, const char *filename, int file_size, u16_t *http_hdr_len, - u16_t *http_hdr_chksum, u8_t provide_content_len, int is_compressed); -int file_put_ascii(FILE *file, const char *ascii_string, int len, int *i); -int s_put_ascii(char *buf, const char *ascii_string, int len, int *i); -void concat_files(const char *file1, const char *file2, const char *targetfile); -int check_path(char *path, size_t size); -static int checkSsiByFilelist(const char* filename_listfile); -static int ext_in_list(const char* filename, const char *ext_list); -static int file_to_exclude(const char* filename); -static int file_can_be_compressed(const char* filename); - -/* 5 bytes per char + 3 bytes per line */ -static char file_buffer_c[COPY_BUFSIZE * 5 + ((COPY_BUFSIZE / HEX_BYTES_PER_LINE) * 3)]; - -char curSubdir[MAX_PATH_LEN]; -char lastFileVar[MAX_PATH_LEN]; -char hdr_buf[4096]; - -unsigned char processSubs = 1; -unsigned char includeHttpHeader = 1; -unsigned char useHttp11 = 0; -unsigned char supportSsi = 1; -unsigned char precalcChksum = 0; -unsigned char includeLastModified = 0; -#if MAKEFS_SUPPORT_DEFLATE -unsigned char deflateNonSsiFiles = 0; -size_t deflatedBytesReduced = 0; -size_t overallDataBytes = 0; -#endif -const char *exclude_list = NULL; -const char *ncompress_list = NULL; - -struct file_entry *first_file = NULL; -struct file_entry *last_file = NULL; - -static char *ssi_file_buffer; -static char **ssi_file_lines; -static size_t ssi_file_num_lines; - -static void print_usage(void) -{ - printf(" Usage: htmlgen [targetdir] [-s] [-e] [-11] [-nossi] [-ssi:] [-c] [-f:] [-m] [-svr:] [-x:] [-xc:" USAGE_ARG_DEFLATE NEWLINE NEWLINE); - printf(" targetdir: relative or absolute path to files to convert" NEWLINE); - printf(" switch -s: toggle processing of subdirectories (default is on)" NEWLINE); - printf(" switch -e: exclude HTTP header from file (header is created at runtime, default is off)" NEWLINE); - printf(" switch -11: include HTTP 1.1 header (1.0 is default)" NEWLINE); - printf(" switch -nossi: no support for SSI (cannot calculate Content-Length for SSI)" NEWLINE); - printf(" switch -ssi: ssi filename (ssi support controlled by file list, not by extension)" NEWLINE); - printf(" switch -c: precalculate checksums for all pages (default is off)" NEWLINE); - printf(" switch -f: target filename (default is \"fsdata.c\")" NEWLINE); - printf(" switch -m: include \"Last-Modified\" header based on file time" NEWLINE); - printf(" switch -svr: server identifier sent in HTTP response header ('Server' field)" NEWLINE); - printf(" switch -x: comma separated list of extensions of files to exclude (e.g., -x:json,txt)" NEWLINE); - printf(" switch -xc: comma separated list of extensions of files to not compress (e.g., -xc:mp3,jpg)" NEWLINE); -#if MAKEFS_SUPPORT_DEFLATE - printf(" switch -defl: deflate-compress all non-SSI files (with opt. compr.-level, default=10)" NEWLINE); - printf(" ATTENTION: browser has to support \"Content-Encoding: deflate\"!" NEWLINE); -#endif - printf(" if targetdir not specified, htmlgen will attempt to" NEWLINE); - printf(" process files in subdirectory 'fs'" NEWLINE); -} - -int main(int argc, char *argv[]) -{ - char path[MAX_PATH_LEN]; - char appPath[MAX_PATH_LEN]; - FILE *data_file; - FILE *struct_file; - int filesProcessed; - int i; - char targetfile[MAX_PATH_LEN]; - strcpy(targetfile, "fsdata.c"); - - memset(path, 0, sizeof(path)); - memset(appPath, 0, sizeof(appPath)); - - printf(NEWLINE " makefsdata - HTML to C source converter" NEWLINE); - printf(" by Jim Pettinato - circa 2003 " NEWLINE); - printf(" extended by Simon Goldschmidt - 2009 " NEWLINE NEWLINE); - - LWIP_ASSERT("sizeof(hdr_buf) must fit into an u16_t", sizeof(hdr_buf) <= 0xffff); - - strcpy(path, "fs"); - for (i = 1; i < argc; i++) { - if (argv[i] == NULL) { - continue; - } - if (argv[i][0] == '-') { - if (strstr(argv[i], "-svr:") == argv[i]) { - snprintf(serverIDBuffer, sizeof(serverIDBuffer), "Server: %s\r\n", &argv[i][5]); - serverID = serverIDBuffer; - printf("Using Server-ID: \"%s\"\n", serverID); - } else if (!strcmp(argv[i], "-s")) { - processSubs = 0; - } else if (!strcmp(argv[i], "-e")) { - includeHttpHeader = 0; - } else if (!strcmp(argv[i], "-11")) { - useHttp11 = 1; - } else if (!strcmp(argv[i], "-nossi")) { - supportSsi = 0; - } else if (strstr(argv[i], "-ssi:") == argv[i]) { - const char* ssi_list_filename = &argv[i][5]; - if (checkSsiByFilelist(ssi_list_filename)) { - printf("Reading list of SSI files from \"%s\"\n", ssi_list_filename); - } else { - printf("Failed to load list of SSI files from \"%s\"\n", ssi_list_filename); - } - } else if (!strcmp(argv[i], "-c")) { - precalcChksum = 1; - } else if (strstr(argv[i], "-f:") == argv[i]) { - strncpy(targetfile, &argv[i][3], sizeof(targetfile) - 1); - targetfile[sizeof(targetfile) - 1] = 0; - printf("Writing to file \"%s\"\n", targetfile); - } else if (!strcmp(argv[i], "-m")) { - includeLastModified = 1; - } else if (!strcmp(argv[i], "-defl")) { -#if MAKEFS_SUPPORT_DEFLATE - char *colon = strstr(argv[i], ":"); - if (colon) { - if (colon[1] != 0) { - int defl_level = atoi(&colon[1]); - if ((defl_level >= 0) && (defl_level <= 10)) { - deflate_level = defl_level; - } else { - printf("ERROR: deflate level must be [0..10]" NEWLINE); - exit(0); - } - } - } - deflateNonSsiFiles = 1; - printf("Deflating all non-SSI files with level %d (but only if size is reduced)" NEWLINE, deflate_level); -#else - printf("WARNING: Deflate support is disabled\n"); -#endif - } else if (strstr(argv[i], "-x:") == argv[i]) { - exclude_list = &argv[i][3]; - printf("Excluding files with extensions %s" NEWLINE, exclude_list); - } else if (strstr(argv[i], "-xc:") == argv[i]) { - ncompress_list = &argv[i][4]; - printf("Skipping compresion for files with extensions %s" NEWLINE, ncompress_list); - } else if ((strstr(argv[i], "-?")) || (strstr(argv[i], "-h"))) { - print_usage(); - exit(0); - } - } else if ((argv[i][0] == '/') && (argv[i][1] == '?') && (argv[i][2] == 0)) { - print_usage(); - exit(0); - } else { - strncpy(path, argv[i], sizeof(path) - 1); - path[sizeof(path) - 1] = 0; - } - } - - if (!check_path(path, sizeof(path))) { - printf("Invalid path: \"%s\"." NEWLINE, path); - exit(-1); - } - - GETCWD(appPath, MAX_PATH_LEN); - /* if command line param or subdir named 'fs' not found spout usage verbiage */ - if (!CHDIR_SUCCEEDED(CHDIR(path))) { - /* if no subdir named 'fs' (or the one which was given) exists, spout usage verbiage */ - printf(" Failed to open directory \"%s\"." NEWLINE NEWLINE, path); - print_usage(); - exit(-1); - } - CHDIR(appPath); - - printf("HTTP %sheader will %s statically included." NEWLINE, - (includeHttpHeader ? (useHttp11 ? "1.1 " : "1.0 ") : ""), - (includeHttpHeader ? "be" : "not be")); - - curSubdir[0] = '\0'; /* start off in web page's root directory - relative paths */ - printf(" Processing all files in directory %s", path); - if (processSubs) { - printf(" and subdirectories..." NEWLINE NEWLINE); - } else { - printf("..." NEWLINE NEWLINE); - } - - data_file = fopen("fsdata.tmp", "wb"); - if (data_file == NULL) { - printf("Failed to create file \"fsdata.tmp\"\n"); - exit(-1); - } - struct_file = fopen("fshdr.tmp", "wb"); - if (struct_file == NULL) { - printf("Failed to create file \"fshdr.tmp\"\n"); - fclose(data_file); - exit(-1); - } - - CHDIR(path); - - fprintf(data_file, "#include \"lwip/apps/fs.h\"" NEWLINE); - fprintf(data_file, "#include \"lwip/def.h\"" NEWLINE NEWLINE NEWLINE); - - fprintf(data_file, "#define file_NULL (struct fsdata_file *) NULL" NEWLINE NEWLINE NEWLINE); - /* define FS_FILE_FLAGS_HEADER_INCLUDED to 1 if not defined (compatibility with older httpd/fs) */ - fprintf(data_file, "#ifndef FS_FILE_FLAGS_HEADER_INCLUDED" NEWLINE "#define FS_FILE_FLAGS_HEADER_INCLUDED 1" NEWLINE "#endif" NEWLINE); - /* define FS_FILE_FLAGS_HEADER_PERSISTENT to 0 if not defined (compatibility with older httpd/fs: wasn't supported back then) */ - fprintf(data_file, "#ifndef FS_FILE_FLAGS_HEADER_PERSISTENT" NEWLINE "#define FS_FILE_FLAGS_HEADER_PERSISTENT 0" NEWLINE "#endif" NEWLINE); - - /* define alignment defines */ -#if ALIGN_PAYLOAD - fprintf(data_file, "/* FSDATA_FILE_ALIGNMENT: 0=off, 1=by variable, 2=by include */" NEWLINE "#ifndef FSDATA_FILE_ALIGNMENT" NEWLINE "#define FSDATA_FILE_ALIGNMENT 0" NEWLINE "#endif" NEWLINE); -#endif - fprintf(data_file, "#ifndef FSDATA_ALIGN_PRE" NEWLINE "#define FSDATA_ALIGN_PRE" NEWLINE "#endif" NEWLINE); - fprintf(data_file, "#ifndef FSDATA_ALIGN_POST" NEWLINE "#define FSDATA_ALIGN_POST" NEWLINE "#endif" NEWLINE); -#if ALIGN_PAYLOAD - fprintf(data_file, "#if FSDATA_FILE_ALIGNMENT==2" NEWLINE "#include \"fsdata_alignment.h\"" NEWLINE "#endif" NEWLINE); -#endif - - sprintf(lastFileVar, "NULL"); - - filesProcessed = process_sub(data_file, struct_file); - - /* data_file now contains all of the raw data.. now append linked list of - * file header structs to allow embedded app to search for a file name */ - fprintf(data_file, NEWLINE NEWLINE); - fprintf(struct_file, "#define FS_ROOT file_%s" NEWLINE, lastFileVar); - fprintf(struct_file, "#define FS_NUMFILES %d" NEWLINE NEWLINE, filesProcessed); - - fclose(data_file); - fclose(struct_file); - - CHDIR(appPath); - /* append struct_file to data_file */ - printf(NEWLINE "Creating target file..." NEWLINE NEWLINE); - concat_files("fsdata.tmp", "fshdr.tmp", targetfile); - - /* if succeeded, delete the temporary files */ - if (remove("fsdata.tmp") != 0) { - printf("Warning: failed to delete fsdata.tmp\n"); - } - if (remove("fshdr.tmp") != 0) { - printf("Warning: failed to delete fshdr.tmp\n"); - } - - printf(NEWLINE "Processed %d files - done." NEWLINE, filesProcessed); -#if MAKEFS_SUPPORT_DEFLATE - if (deflateNonSsiFiles) { - printf("(Deflated total byte reduction: %d bytes -> %d bytes (%.02f%%)" NEWLINE, - (int)overallDataBytes, (int)deflatedBytesReduced, (float)((deflatedBytesReduced * 100.0) / overallDataBytes)); - } -#endif - printf(NEWLINE); - - while (first_file != NULL) { - struct file_entry *fe = first_file; - first_file = fe->next; - free(fe); - } - - if (ssi_file_buffer) { - free(ssi_file_buffer); - } - if (ssi_file_lines) { - free(ssi_file_lines); - } - - return 0; -} - -int check_path(char *path, size_t size) -{ - size_t slen; - if (path[0] == 0) { - /* empty */ - return 0; - } - slen = strlen(path); - if (slen >= size) { - /* not NULL-terminated */ - return 0; - } - while ((slen > 0) && ((path[slen] == '\\') || (path[slen] == '/'))) { - /* path should not end with trailing backslash */ - path[slen] = 0; - slen--; - } - if (slen == 0) { - return 0; - } - return 1; -} - -static void copy_file(const char *filename_in, FILE *fout) -{ - FILE *fin; - size_t len; - void *buf; - fin = fopen(filename_in, "rb"); - if (fin == NULL) { - printf("Failed to open file \"%s\"\n", filename_in); - exit(-1); - } - buf = malloc(COPY_BUFSIZE); - while ((len = fread(buf, 1, COPY_BUFSIZE, fin)) > 0) { - fwrite(buf, 1, len, fout); - } - free(buf); - fclose(fin); -} - -void concat_files(const char *file1, const char *file2, const char *targetfile) -{ - FILE *fout; - fout = fopen(targetfile, "wb"); - if (fout == NULL) { - printf("Failed to open file \"%s\"\n", targetfile); - exit(-1); - } - copy_file(file1, fout); - copy_file(file2, fout); - fclose(fout); -} - -int process_sub(FILE *data_file, FILE *struct_file) -{ - tinydir_dir dir; - int filesProcessed = 0; - - if (processSubs) { - /* process subs recursively */ - size_t sublen = strlen(curSubdir); - size_t freelen = sizeof(curSubdir) - sublen - 1; - int ret; - LWIP_ASSERT("sublen < sizeof(curSubdir)", sublen < sizeof(curSubdir)); - - ret = tinydir_open_sorted(&dir, TINYDIR_STRING(".")); - - if (ret == 0) { - unsigned int i; - for (i = 0; i < dir.n_files; i++) { - tinydir_file file; - - ret = tinydir_readfile_n(&dir, &file, i); - - if (ret == 0) { -#if (defined _MSC_VER || defined __MINGW32__) && (defined _UNICODE) - size_t num_char_converted; - char currName[256]; - wcstombs_s(&num_char_converted, currName, sizeof(currName), file.name, sizeof(currName)); -#else - const char *currName = file.name; -#endif - - if (currName[0] == '.') { - continue; - } - if (!file.is_dir) { - continue; - } - if (freelen > 0) { - CHDIR(currName); - strncat(curSubdir, "/", freelen); - strncat(curSubdir, currName, freelen - 1); - curSubdir[sizeof(curSubdir) - 1] = 0; - printf("processing subdirectory %s/..." NEWLINE, curSubdir); - filesProcessed += process_sub(data_file, struct_file); - CHDIR(".."); - curSubdir[sublen] = 0; - } else { - printf("WARNING: cannot process sub due to path length restrictions: \"%s/%s\"\n", curSubdir, currName); - } - } - } - } - - ret = tinydir_open_sorted(&dir, TINYDIR_STRING(".")); - if (ret == 0) { - unsigned int i; - for (i = 0; i < dir.n_files; i++) { - tinydir_file file; - - ret = tinydir_readfile_n(&dir, &file, i); - - if (ret == 0) { - if (!file.is_dir) { -#if (defined _MSC_VER || defined __MINGW32__) && (defined _UNICODE) - size_t num_char_converted; - char curName[256]; - wcstombs_s(&num_char_converted, curName, sizeof(curName), file.name, sizeof(curName)); -#else - const char *curName = file.name; -#endif - - if (strcmp(curName, "fsdata.tmp") == 0) { - continue; - } - if (strcmp(curName, "fshdr.tmp") == 0) { - continue; - } - if (file_to_exclude(curName)) { - printf("skipping %s/%s by exclude list (-x option)..." NEWLINE, curSubdir, curName); - continue; - } - - printf("processing %s/%s..." NEWLINE, curSubdir, curName); - - if (process_file(data_file, struct_file, curName) < 0) { - printf(NEWLINE "Error... aborting" NEWLINE); - return -1; - } - filesProcessed++; - } - } - } - } - } - - return filesProcessed; -} - -static u8_t *get_file_data(const char *filename, int *file_size, int can_be_compressed, int *is_compressed) -{ - FILE *inFile; - size_t fsize = 0; - u8_t *buf; - size_t r; - int rs; - LWIP_UNUSED_ARG(r); /* for LWIP_NOASSERT */ - inFile = fopen(filename, "rb"); - if (inFile == NULL) { - printf("Failed to open file \"%s\"\n", filename); - exit(-1); - } - fseek(inFile, 0, SEEK_END); - rs = ftell(inFile); - if (rs < 0) { - printf("ftell failed with %d\n", errno); - exit(-1); - } - fsize = (size_t)rs; - fseek(inFile, 0, SEEK_SET); - buf = (u8_t *)malloc(fsize); - LWIP_ASSERT("buf != NULL", buf != NULL); - r = fread(buf, 1, fsize, inFile); - LWIP_ASSERT("r == fsize", r == fsize); - *file_size = fsize; - *is_compressed = 0; -#if MAKEFS_SUPPORT_DEFLATE - overallDataBytes += fsize; - if (deflateNonSsiFiles) { - if (can_be_compressed) { - if (fsize < OUT_BUF_SIZE) { - u8_t *ret_buf; - tdefl_status status; - size_t in_bytes = fsize; - size_t out_bytes = OUT_BUF_SIZE; - const void *next_in = buf; - void *next_out = s_outbuf; - /* create tdefl() compatible flags (we have to compose the low-level flags ourselves, or use tdefl_create_comp_flags_from_zip_params() but that means MINIZ_NO_ZLIB_APIS can't be defined). */ - mz_uint comp_flags = s_tdefl_num_probes[MZ_MIN(10, deflate_level)] | ((deflate_level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); - if (!deflate_level) { - comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; - } - status = tdefl_init(&g_deflator, NULL, NULL, comp_flags); - if (status != TDEFL_STATUS_OKAY) { - printf("tdefl_init() failed!\n"); - exit(-1); - } - memset(s_outbuf, 0, sizeof(s_outbuf)); - status = tdefl_compress(&g_deflator, next_in, &in_bytes, next_out, &out_bytes, TDEFL_FINISH); - if (status != TDEFL_STATUS_DONE) { - printf("deflate failed: %d\n", status); - exit(-1); - } - LWIP_ASSERT("out_bytes <= COPY_BUFSIZE", out_bytes <= OUT_BUF_SIZE); - if (out_bytes < fsize) { - ret_buf = (u8_t *)malloc(out_bytes); - LWIP_ASSERT("ret_buf != NULL", ret_buf != NULL); - memcpy(ret_buf, s_outbuf, out_bytes); - { - /* sanity-check compression be inflating and comparing to the original */ - tinfl_status dec_status; - tinfl_decompressor inflator; - size_t dec_in_bytes = out_bytes; - size_t dec_out_bytes = OUT_BUF_SIZE; - next_out = s_checkbuf; - - tinfl_init(&inflator); - memset(s_checkbuf, 0, sizeof(s_checkbuf)); - dec_status = tinfl_decompress(&inflator, (const mz_uint8 *)ret_buf, &dec_in_bytes, s_checkbuf, (mz_uint8 *)next_out, &dec_out_bytes, 0); - LWIP_ASSERT("tinfl_decompress failed", dec_status == TINFL_STATUS_DONE); - LWIP_ASSERT("tinfl_decompress size mismatch", fsize == dec_out_bytes); - LWIP_ASSERT("decompressed memcmp failed", !memcmp(s_checkbuf, buf, fsize)); - } - /* free original buffer, use compressed data + size */ - free(buf); - buf = ret_buf; - *file_size = out_bytes; - printf(" - deflate: %d bytes -> %d bytes (%.02f%%)" NEWLINE, (int)fsize, (int)out_bytes, (float)((out_bytes * 100.0) / fsize)); - deflatedBytesReduced += (size_t)(fsize - out_bytes); - *is_compressed = 1; - } else { - printf(" - uncompressed: (would be %d bytes larger using deflate)" NEWLINE, (int)(out_bytes - fsize)); - } - } else { - printf(" - uncompressed: (file is larger than deflate bufer)" NEWLINE); - } - } else { - printf(" - cannot be compressed" NEWLINE); - } - } -#else - LWIP_UNUSED_ARG(can_be_compressed); -#endif - fclose(inFile); - return buf; -} - -static void process_file_data(FILE *data_file, u8_t *file_data, size_t file_size) -{ - size_t written, i, src_off = 0; - size_t off = 0; - LWIP_UNUSED_ARG(written); /* for LWIP_NOASSERT */ - for (i = 0; i < file_size; i++) { - LWIP_ASSERT("file_buffer_c overflow", off < sizeof(file_buffer_c) - 5); - sprintf(&file_buffer_c[off], "0x%02x,", file_data[i]); - off += 5; - if ((++src_off % HEX_BYTES_PER_LINE) == 0) { - LWIP_ASSERT("file_buffer_c overflow", off < sizeof(file_buffer_c) - NEWLINE_LEN); - memcpy(&file_buffer_c[off], NEWLINE, NEWLINE_LEN); - off += NEWLINE_LEN; - } - if (off + 20 >= sizeof(file_buffer_c)) { - written = fwrite(file_buffer_c, 1, off, data_file); - LWIP_ASSERT("written == off", written == off); - off = 0; - } - } - written = fwrite(file_buffer_c, 1, off, data_file); - LWIP_ASSERT("written == off", written == off); -} - -static int write_checksums(FILE *struct_file, const char *varname, - u16_t hdr_len, u16_t hdr_chksum, const u8_t *file_data, size_t file_size) -{ - int chunk_size = TCP_MSS; - int offset, src_offset; - size_t len; - int i = 0; -#if LWIP_TCP_TIMESTAMPS - /* when timestamps are used, usable space is 12 bytes less per segment */ - chunk_size -= 12; -#endif - - fprintf(struct_file, "#if HTTPD_PRECALCULATED_CHECKSUM" NEWLINE); - fprintf(struct_file, "const struct fsdata_chksum chksums_%s[] = {" NEWLINE, varname); - - if (hdr_len > 0) { - /* add checksum for HTTP header */ - fprintf(struct_file, "{%d, 0x%04x, %d}," NEWLINE, 0, hdr_chksum, hdr_len); - i++; - } - src_offset = 0; - for (offset = hdr_len; ; offset += len) { - unsigned short chksum; - const void *data = (const void *)&file_data[src_offset]; - len = LWIP_MIN(chunk_size, (int)file_size - src_offset); - if (len == 0) { - break; - } - chksum = ~inet_chksum(data, (u16_t)len); - /* add checksum for data */ - fprintf(struct_file, "{%d, 0x%04x, %"SZT_F"}," NEWLINE, offset, chksum, len); - i++; - } - fprintf(struct_file, "};" NEWLINE); - fprintf(struct_file, "#endif /* HTTPD_PRECALCULATED_CHECKSUM */" NEWLINE); - return i; -} - -static int is_valid_char_for_c_var(char x) -{ - if (((x >= 'A') && (x <= 'Z')) || - ((x >= 'a') && (x <= 'z')) || - ((x >= '0') && (x <= '9')) || - (x == '_')) { - return 1; - } - return 0; -} - -static void fix_filename_for_c(char *qualifiedName, size_t max_len) -{ - struct file_entry *f; - size_t len = strlen(qualifiedName); - char *new_name = (char *)malloc(len + 2); - int filename_ok; - int cnt = 0; - size_t i; - if (len + 3 == max_len) { - printf("File name too long: \"%s\"\n", qualifiedName); - exit(-1); - } - strcpy(new_name, qualifiedName); - for (i = 0; i < len; i++) { - if (!is_valid_char_for_c_var(new_name[i])) { - new_name[i] = '_'; - } - } - do { - filename_ok = 1; - for (f = first_file; f != NULL; f = f->next) { - if (!strcmp(f->filename_c, new_name)) { - filename_ok = 0; - cnt++; - /* try next unique file name */ - sprintf(&new_name[len], "%d", cnt); - break; - } - } - } while (!filename_ok && (cnt < 999)); - if (!filename_ok) { - printf("Failed to get unique file name: \"%s\"\n", qualifiedName); - exit(-1); - } - strcpy(qualifiedName, new_name); - free(new_name); -} - -static void register_filename(const char *qualifiedName) -{ - struct file_entry *fe = (struct file_entry *)malloc(sizeof(struct file_entry)); - fe->filename_c = strdup(qualifiedName); - fe->next = NULL; - if (first_file == NULL) { - first_file = last_file = fe; - } else { - last_file->next = fe; - last_file = fe; - } -} - -static int checkSsiByFilelist(const char* filename_listfile) -{ - FILE *f = fopen(filename_listfile, "r"); - if (f != NULL) { - char *buf; - long rs; - size_t fsize, readcount; - size_t i, l, num_lines; - char **lines; - int state; - - fseek(f, 0, SEEK_END); - rs = ftell(f); - if (rs < 0) { - printf("ftell failed with %d\n", errno); - fclose(f); - return 0; - } - fsize = (size_t)rs; - fseek(f, 0, SEEK_SET); - buf = (char*)malloc(fsize); - if (!buf) { - printf("failed to allocate ssi file buffer\n"); - fclose(f); - return 0; - } - memset(buf, 0, fsize); - readcount = fread(buf, 1, fsize, f); - fclose(f); - if ((readcount > fsize) || !readcount) { - printf("failed to read data from ssi file\n"); - free(buf); - return 0; - } - - /* first pass: get the number of lines (and convert newlines to '0') */ - num_lines = 1; - for (i = 0; i < readcount; i++) { - if (buf[i] == '\n') { - num_lines++; - buf[i] = 0; - } else if (buf[i] == '\r') { - buf[i] = 0; - } - } - /* allocate the line pointer array */ - lines = (char**)malloc(sizeof(char*) * num_lines); - if (!lines) { - printf("failed to allocate ssi line buffer\n"); - free(buf); - return 0; - } - memset(lines, 0, sizeof(char*) * num_lines); - l = 0; - state = 0; - for (i = 0; i < readcount; i++) { - if (state) { - /* waiting for null */ - if (buf[i] == 0) { - state = 0; - } - } else { - /* waiting for beginning of new string */ - if (buf[i] != 0) { - LWIP_ASSERT("lines array overflow", l < num_lines); - lines[l] = &buf[i]; - state = 1; - l++; - } - } - } - LWIP_ASSERT("lines array overflow", l < num_lines); - - ssi_file_buffer = buf; - ssi_file_lines = lines; - ssi_file_num_lines = l; - } - return 0; -} - -static int is_ssi_file(const char *filename) -{ - if (supportSsi) { - if (ssi_file_buffer) { - /* compare by list */ - size_t i; - int ret = 0; - /* build up the relative path to this file */ - size_t sublen = strlen(curSubdir); - size_t freelen = sizeof(curSubdir) - sublen - 1; - strncat(curSubdir, "/", freelen); - strncat(curSubdir, filename, freelen - 1); - curSubdir[sizeof(curSubdir) - 1] = 0; - for (i = 0; i < ssi_file_num_lines; i++) { - const char *listed_file = ssi_file_lines[i]; - /* compare without the leading '/' */ - if (!strcmp(&curSubdir[1], listed_file)) { - ret = 1; - } - } - curSubdir[sublen] = 0; - return ret; - } else { - /* check file extension */ - size_t loop; - for (loop = 0; loop < NUM_SHTML_EXTENSIONS; loop++) { - if (strstr(filename, g_pcSSIExtensions[loop])) { - return 1; - } - } - } - } - return 0; -} - -static int ext_in_list(const char* filename, const char *ext_list) -{ - int found = 0; - const char *ext = ext_list; - if (ext_list == NULL) { - return 0; - } - while(*ext != '\0') { - const char *comma = strchr(ext, ','); - size_t ext_size; - size_t filename_size = strlen(filename); - if (comma == NULL) { - comma = strchr(ext, '\0'); - } - ext_size = comma - ext; - if ((filename[filename_size - ext_size - 1] == '.') && - !strncmp(&filename[filename_size - ext_size], ext, ext_size)) { - found = 1; - break; - } - ext = comma + 1; - } - - return found; -} - -static int file_to_exclude(const char *filename) -{ - return (exclude_list != NULL) && ext_in_list(filename, exclude_list); -} - -static int file_can_be_compressed(const char *filename) -{ - return (ncompress_list == NULL) || !ext_in_list(filename, ncompress_list); -} - -int process_file(FILE *data_file, FILE *struct_file, const char *filename) -{ - char varname[MAX_PATH_LEN]; - int i = 0; - char qualifiedName[MAX_PATH_LEN]; - int file_size; - u16_t http_hdr_chksum = 0; - u16_t http_hdr_len = 0; - int chksum_count = 0; - u8_t flags = 0; - u8_t has_content_len; - u8_t *file_data; - int is_ssi; - int can_be_compressed; - int is_compressed = 0; - int flags_printed; - - /* create qualified name (@todo: prepend slash or not?) */ - sprintf(qualifiedName, "%s/%s", curSubdir, filename); - /* create C variable name */ - strcpy(varname, qualifiedName); - /* convert slashes & dots to underscores */ - fix_filename_for_c(varname, MAX_PATH_LEN); - register_filename(varname); -#if ALIGN_PAYLOAD - /* to force even alignment of array, type 1 */ - fprintf(data_file, "#if FSDATA_FILE_ALIGNMENT==1" NEWLINE); - fprintf(data_file, "static const " PAYLOAD_ALIGN_TYPE " dummy_align_%s = %d;" NEWLINE, varname, payload_alingment_dummy_counter++); - fprintf(data_file, "#endif" NEWLINE); -#endif /* ALIGN_PAYLOAD */ - fprintf(data_file, "static const unsigned char FSDATA_ALIGN_PRE data_%s[] FSDATA_ALIGN_POST = {" NEWLINE, varname); - /* encode source file name (used by file system, not returned to browser) */ - fprintf(data_file, "/* %s (%"SZT_F" chars) */" NEWLINE, qualifiedName, strlen(qualifiedName) + 1); - file_put_ascii(data_file, qualifiedName, strlen(qualifiedName) + 1, &i); -#if ALIGN_PAYLOAD - /* pad to even number of bytes to assure payload is on aligned boundary */ - while (i % PAYLOAD_ALIGNMENT != 0) { - fprintf(data_file, "0x%02x,", 0); - i++; - } -#endif /* ALIGN_PAYLOAD */ - fprintf(data_file, NEWLINE); - - is_ssi = is_ssi_file(filename); - if (is_ssi) { - flags |= FS_FILE_FLAGS_SSI; - } - has_content_len = !is_ssi; - can_be_compressed = includeHttpHeader && !is_ssi && file_can_be_compressed(filename); - file_data = get_file_data(filename, &file_size, can_be_compressed, &is_compressed); - if (includeHttpHeader) { - file_write_http_header(data_file, filename, file_size, &http_hdr_len, &http_hdr_chksum, has_content_len, is_compressed); - flags |= FS_FILE_FLAGS_HEADER_INCLUDED; - if (has_content_len) { - flags |= FS_FILE_FLAGS_HEADER_PERSISTENT; - if (useHttp11) { - flags |= FS_FILE_FLAGS_HEADER_HTTPVER_1_1; - } - } - } - if (precalcChksum) { - chksum_count = write_checksums(struct_file, varname, http_hdr_len, http_hdr_chksum, file_data, file_size); - } - - /* build declaration of struct fsdata_file in temp file */ - fprintf(struct_file, "const struct fsdata_file file_%s[] = { {" NEWLINE, varname); - fprintf(struct_file, "file_%s," NEWLINE, lastFileVar); - fprintf(struct_file, "data_%s," NEWLINE, varname); - fprintf(struct_file, "data_%s + %d," NEWLINE, varname, i); - fprintf(struct_file, "sizeof(data_%s) - %d," NEWLINE, varname, i); - - flags_printed = 0; - if (flags & FS_FILE_FLAGS_HEADER_INCLUDED) { - fputs("FS_FILE_FLAGS_HEADER_INCLUDED", struct_file); - flags_printed = 1; - } - if (flags & FS_FILE_FLAGS_HEADER_PERSISTENT) { - if (flags_printed) { - fputs(" | ", struct_file); - } - fputs("FS_FILE_FLAGS_HEADER_PERSISTENT", struct_file); - flags_printed = 1; - } - if (flags & FS_FILE_FLAGS_HEADER_HTTPVER_1_1) { - if (flags_printed) { - fputs(" | ", struct_file); - } - fputs("FS_FILE_FLAGS_HEADER_HTTPVER_1_1", struct_file); - flags_printed = 1; - } - if (flags & FS_FILE_FLAGS_SSI) { - if (flags_printed) { - fputs(" | ", struct_file); - } - fputs("FS_FILE_FLAGS_SSI", struct_file); - flags_printed = 1; - } - if (!flags_printed) { - fputs("0", struct_file); - } - fputs("," NEWLINE, struct_file); - if (precalcChksum) { - fprintf(struct_file, "#if HTTPD_PRECALCULATED_CHECKSUM" NEWLINE); - fprintf(struct_file, "%d, chksums_%s," NEWLINE, chksum_count, varname); - fprintf(struct_file, "#endif /* HTTPD_PRECALCULATED_CHECKSUM */" NEWLINE); - } - fprintf(struct_file, "}};" NEWLINE NEWLINE); - strcpy(lastFileVar, varname); - - /* write actual file contents */ - i = 0; - fprintf(data_file, NEWLINE "/* raw file data (%d bytes) */" NEWLINE, file_size); - process_file_data(data_file, file_data, file_size); - fprintf(data_file, "};" NEWLINE NEWLINE); - free(file_data); - return 0; -} - -int file_write_http_header(FILE *data_file, const char *filename, int file_size, u16_t *http_hdr_len, - u16_t *http_hdr_chksum, u8_t provide_content_len, int is_compressed) -{ - int i = 0; - int response_type = HTTP_HDR_OK; - const char *file_type; - const char *cur_string; - size_t cur_len; - int written = 0; - size_t hdr_len = 0; - u16_t acc; - const char *file_ext; - size_t j; - u8_t provide_last_modified = includeLastModified; - - memset(hdr_buf, 0, sizeof(hdr_buf)); - - if (useHttp11) { - response_type = HTTP_HDR_OK_11; - } - - fprintf(data_file, NEWLINE "/* HTTP header */"); - if (strstr(filename, "404") == filename) { - response_type = HTTP_HDR_NOT_FOUND; - if (useHttp11) { - response_type = HTTP_HDR_NOT_FOUND_11; - } - } else if (strstr(filename, "400") == filename) { - response_type = HTTP_HDR_BAD_REQUEST; - if (useHttp11) { - response_type = HTTP_HDR_BAD_REQUEST_11; - } - } else if (strstr(filename, "501") == filename) { - response_type = HTTP_HDR_NOT_IMPL; - if (useHttp11) { - response_type = HTTP_HDR_NOT_IMPL_11; - } - } - cur_string = g_psHTTPHeaderStrings[response_type]; - cur_len = strlen(cur_string); - fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); - written += file_put_ascii(data_file, cur_string, cur_len, &i); - i = 0; - if (precalcChksum) { - memcpy(&hdr_buf[hdr_len], cur_string, cur_len); - hdr_len += cur_len; - } - - cur_string = serverID; - cur_len = strlen(cur_string); - fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); - written += file_put_ascii(data_file, cur_string, cur_len, &i); - i = 0; - if (precalcChksum) { - memcpy(&hdr_buf[hdr_len], cur_string, cur_len); - hdr_len += cur_len; - } - - file_ext = filename; - if (file_ext != NULL) { - while (strstr(file_ext, ".") != NULL) { - file_ext = strstr(file_ext, "."); - file_ext++; - } - } - if ((file_ext == NULL) || (*file_ext == 0)) { - printf("failed to get extension for file \"%s\", using default.\n", filename); - file_type = HTTP_HDR_DEFAULT_TYPE; - } else { - file_type = NULL; - for (j = 0; j < NUM_HTTP_HEADERS; j++) { - if (!strcmp(file_ext, g_psHTTPHeaders[j].extension)) { - file_type = g_psHTTPHeaders[j].content_type; - break; - } - } - if (file_type == NULL) { - printf("failed to get file type for extension \"%s\", using default.\n", file_ext); - file_type = HTTP_HDR_DEFAULT_TYPE; - } - } - - /* Content-Length is used for persistent connections in HTTP/1.1 but also for - download progress in older versions - @todo: just use a big-enough buffer and let the HTTPD send spaces? */ - if (provide_content_len) { - char intbuf[MAX_PATH_LEN]; - int content_len = file_size; - memset(intbuf, 0, sizeof(intbuf)); - cur_string = g_psHTTPHeaderStrings[HTTP_HDR_CONTENT_LENGTH]; - cur_len = strlen(cur_string); - fprintf(data_file, NEWLINE "/* \"%s%d\r\n\" (%"SZT_F"+ bytes) */" NEWLINE, cur_string, content_len, cur_len + 2); - written += file_put_ascii(data_file, cur_string, cur_len, &i); - if (precalcChksum) { - memcpy(&hdr_buf[hdr_len], cur_string, cur_len); - hdr_len += cur_len; - } - - lwip_itoa(intbuf, sizeof(intbuf), content_len); - strcat(intbuf, "\r\n"); - cur_len = strlen(intbuf); - written += file_put_ascii(data_file, intbuf, cur_len, &i); - i = 0; - if (precalcChksum) { - memcpy(&hdr_buf[hdr_len], intbuf, cur_len); - hdr_len += cur_len; - } - } - if (provide_last_modified) { - char modbuf[256]; - struct stat stat_data; - struct tm *t; - memset(modbuf, 0, sizeof(modbuf)); - memset(&stat_data, 0, sizeof(stat_data)); - cur_string = modbuf; - strcpy(modbuf, "Last-Modified: "); - if (stat(filename, &stat_data) != 0) { - printf("stat(%s) failed with error %d\n", filename, errno); - exit(-1); - } - t = gmtime(&stat_data.st_mtime); - if (t == NULL) { - printf("gmtime() failed with error %d\n", errno); - exit(-1); - } - strftime(&modbuf[15], sizeof(modbuf) - 15, "%a, %d %b %Y %H:%M:%S GMT", t); - cur_len = strlen(cur_string); - fprintf(data_file, NEWLINE "/* \"%s\"\r\n\" (%"SZT_F"+ bytes) */" NEWLINE, cur_string, cur_len + 2); - written += file_put_ascii(data_file, cur_string, cur_len, &i); - if (precalcChksum) { - memcpy(&hdr_buf[hdr_len], cur_string, cur_len); - hdr_len += cur_len; - } - - modbuf[0] = 0; - strcat(modbuf, "\r\n"); - cur_len = strlen(modbuf); - written += file_put_ascii(data_file, modbuf, cur_len, &i); - i = 0; - if (precalcChksum) { - memcpy(&hdr_buf[hdr_len], modbuf, cur_len); - hdr_len += cur_len; - } - } - - /* HTTP/1.1 implements persistent connections */ - if (useHttp11) { - if (provide_content_len) { - cur_string = g_psHTTPHeaderStrings[HTTP_HDR_CONN_KEEPALIVE]; - } else { - /* no Content-Length available, so a persistent connection is no possible - because the client does not know the data length */ - cur_string = g_psHTTPHeaderStrings[HTTP_HDR_CONN_CLOSE]; - } - cur_len = strlen(cur_string); - fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); - written += file_put_ascii(data_file, cur_string, cur_len, &i); - i = 0; - if (precalcChksum) { - memcpy(&hdr_buf[hdr_len], cur_string, cur_len); - hdr_len += cur_len; - } - } - -#if MAKEFS_SUPPORT_DEFLATE - if (is_compressed) { - /* tell the client about the deflate encoding */ - LWIP_ASSERT("error", deflateNonSsiFiles); - cur_string = "Content-Encoding: deflate\r\n"; - cur_len = strlen(cur_string); - fprintf(data_file, NEWLINE "/* \"%s\" (%d bytes) */" NEWLINE, cur_string, cur_len); - written += file_put_ascii(data_file, cur_string, cur_len, &i); - i = 0; - } -#else - LWIP_UNUSED_ARG(is_compressed); -#endif - - /* write content-type, ATTENTION: this includes the double-CRLF! */ - cur_string = file_type; - cur_len = strlen(cur_string); - fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); - written += file_put_ascii(data_file, cur_string, cur_len, &i); - i = 0; - - /* ATTENTION: headers are done now (double-CRLF has been written!) */ - - if (precalcChksum) { - LWIP_ASSERT("hdr_len + cur_len <= sizeof(hdr_buf)", hdr_len + cur_len <= sizeof(hdr_buf)); - memcpy(&hdr_buf[hdr_len], cur_string, cur_len); - hdr_len += cur_len; - - LWIP_ASSERT("strlen(hdr_buf) == hdr_len", strlen(hdr_buf) == hdr_len); - acc = ~inet_chksum(hdr_buf, (u16_t)hdr_len); - *http_hdr_len = (u16_t)hdr_len; - *http_hdr_chksum = acc; - } - - return written; -} - -int file_put_ascii(FILE *file, const char *ascii_string, int len, int *i) -{ - int x; - for (x = 0; x < len; x++) { - unsigned char cur = ascii_string[x]; - fprintf(file, "0x%02x,", cur); - if ((++(*i) % HEX_BYTES_PER_LINE) == 0) { - fprintf(file, NEWLINE); - } - } - return len; -} - -int s_put_ascii(char *buf, const char *ascii_string, int len, int *i) -{ - int x; - int idx = 0; - for (x = 0; x < len; x++) { - unsigned char cur = ascii_string[x]; - sprintf(&buf[idx], "0x%02x,", cur); - idx += 5; - if ((++(*i) % HEX_BYTES_PER_LINE) == 0) { - sprintf(&buf[idx], NEWLINE); - idx += NEWLINE_LEN; - } - } - return len; -} +/** + * makefsdata: Converts a directory structure for use with the lwIP httpd. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Jim Pettinato + * Simon Goldschmidt + * + * @todo: + * - take TCP_MSS, LWIP_TCP_TIMESTAMPS and + * PAYLOAD_ALIGN_TYPE/PAYLOAD_ALIGNMENT as arguments + */ + +#include +#include +#include +#include +#include + +#include "tinydir.h" + +/** Makefsdata can generate *all* files deflate-compressed (where file size shrinks). + * Since nearly all browsers support this, this is a good way to reduce ROM size. + * To compress the files, "miniz.c" must be downloaded seperately. + */ +#ifndef MAKEFS_SUPPORT_DEFLATE +#define MAKEFS_SUPPORT_DEFLATE 0 +#endif + +#define COPY_BUFSIZE (1024*1024) /* 1 MByte */ + +#if MAKEFS_SUPPORT_DEFLATE +#include "../miniz.c" + +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef unsigned int uint; + +#define my_max(a,b) (((a) > (b)) ? (a) : (b)) +#define my_min(a,b) (((a) < (b)) ? (a) : (b)) + +/* COMP_OUT_BUF_SIZE is the size of the output buffer used during compression. + COMP_OUT_BUF_SIZE must be >= 1 and <= OUT_BUF_SIZE */ +#define COMP_OUT_BUF_SIZE COPY_BUFSIZE + +/* OUT_BUF_SIZE is the size of the output buffer used during decompression. + OUT_BUF_SIZE must be a power of 2 >= TINFL_LZ_DICT_SIZE (because the low-level decompressor not only writes, but reads from the output buffer as it decompresses) */ +#define OUT_BUF_SIZE COPY_BUFSIZE +static uint8 s_outbuf[OUT_BUF_SIZE]; +static uint8 s_checkbuf[OUT_BUF_SIZE]; + +/* tdefl_compressor contains all the state needed by the low-level compressor so it's a pretty big struct (~300k). + This example makes it a global vs. putting it on the stack, of course in real-world usage you'll probably malloc() or new it. */ +tdefl_compressor g_deflator; +tinfl_decompressor g_inflator; + +int deflate_level = 10; /* default compression level, can be changed via command line */ +#define USAGE_ARG_DEFLATE " [-defl<:compr_level>]" +#else /* MAKEFS_SUPPORT_DEFLATE */ +#define USAGE_ARG_DEFLATE "" +#endif /* MAKEFS_SUPPORT_DEFLATE */ + +#ifdef WIN32 + +#define GETCWD(path, len) GetCurrentDirectoryA(len, path) +#define CHDIR(path) SetCurrentDirectoryA(path) +#define CHDIR_SUCCEEDED(ret) (ret == TRUE) + +#elif __linux__ + +#define GETCWD(path, len) getcwd(path, len) +#define CHDIR(path) chdir(path) +#define CHDIR_SUCCEEDED(ret) (ret == 0) + +#else + +#error makefsdata not supported on this platform + +#endif + +#define NEWLINE "\r\n" +#define NEWLINE_LEN 2 + +/* define this to get the header variables we use to build HTTP headers */ +#define LWIP_HTTPD_DYNAMIC_HEADERS 1 +#define LWIP_HTTPD_SSI 1 +#include "lwip/init.h" +#include "../httpd_structs.h" +#include "lwip/apps/fs.h" + +#include "../core/inet_chksum.c" +#include "../core/def.c" + +/** (Your server name here) */ +const char *serverID = "Server: "HTTPD_SERVER_AGENT"\r\n"; +char serverIDBuffer[1024]; + +/* change this to suit your MEM_ALIGNMENT */ +#define PAYLOAD_ALIGNMENT 4 +/* set this to 0 to prevent aligning payload */ +#define ALIGN_PAYLOAD 1 +/* define this to a type that has the required alignment */ +#define PAYLOAD_ALIGN_TYPE "unsigned int" +static int payload_alingment_dummy_counter = 0; + +#define HEX_BYTES_PER_LINE 16 + +#define MAX_PATH_LEN 256 + +struct file_entry { + struct file_entry *next; + const char *filename_c; +}; + +int process_sub(FILE *data_file, FILE *struct_file); +int process_file(FILE *data_file, FILE *struct_file, const char *filename); +int file_write_http_header(FILE *data_file, const char *filename, int file_size, u16_t *http_hdr_len, + u16_t *http_hdr_chksum, u8_t provide_content_len, int is_compressed); +int file_put_ascii(FILE *file, const char *ascii_string, int len, int *i); +int s_put_ascii(char *buf, const char *ascii_string, int len, int *i); +void concat_files(const char *file1, const char *file2, const char *targetfile); +int check_path(char *path, size_t size); +static int checkSsiByFilelist(const char* filename_listfile); +static int ext_in_list(const char* filename, const char *ext_list); +static int file_to_exclude(const char* filename); +static int file_can_be_compressed(const char* filename); + +/* 5 bytes per char + 3 bytes per line */ +static char file_buffer_c[COPY_BUFSIZE * 5 + ((COPY_BUFSIZE / HEX_BYTES_PER_LINE) * 3)]; + +char curSubdir[MAX_PATH_LEN]; +char lastFileVar[MAX_PATH_LEN]; +char hdr_buf[4096]; + +unsigned char processSubs = 1; +unsigned char includeHttpHeader = 1; +unsigned char useHttp11 = 0; +unsigned char supportSsi = 1; +unsigned char precalcChksum = 0; +unsigned char includeLastModified = 0; +#if MAKEFS_SUPPORT_DEFLATE +unsigned char deflateNonSsiFiles = 0; +size_t deflatedBytesReduced = 0; +size_t overallDataBytes = 0; +#endif +const char *exclude_list = NULL; +const char *ncompress_list = NULL; + +struct file_entry *first_file = NULL; +struct file_entry *last_file = NULL; + +static char *ssi_file_buffer; +static char **ssi_file_lines; +static size_t ssi_file_num_lines; + +static void print_usage(void) +{ + printf(" Usage: htmlgen [targetdir] [-s] [-e] [-11] [-nossi] [-ssi:] [-c] [-f:] [-m] [-svr:] [-x:] [-xc:" USAGE_ARG_DEFLATE NEWLINE NEWLINE); + printf(" targetdir: relative or absolute path to files to convert" NEWLINE); + printf(" switch -s: toggle processing of subdirectories (default is on)" NEWLINE); + printf(" switch -e: exclude HTTP header from file (header is created at runtime, default is off)" NEWLINE); + printf(" switch -11: include HTTP 1.1 header (1.0 is default)" NEWLINE); + printf(" switch -nossi: no support for SSI (cannot calculate Content-Length for SSI)" NEWLINE); + printf(" switch -ssi: ssi filename (ssi support controlled by file list, not by extension)" NEWLINE); + printf(" switch -c: precalculate checksums for all pages (default is off)" NEWLINE); + printf(" switch -f: target filename (default is \"fsdata.c\")" NEWLINE); + printf(" switch -m: include \"Last-Modified\" header based on file time" NEWLINE); + printf(" switch -svr: server identifier sent in HTTP response header ('Server' field)" NEWLINE); + printf(" switch -x: comma separated list of extensions of files to exclude (e.g., -x:json,txt)" NEWLINE); + printf(" switch -xc: comma separated list of extensions of files to not compress (e.g., -xc:mp3,jpg)" NEWLINE); +#if MAKEFS_SUPPORT_DEFLATE + printf(" switch -defl: deflate-compress all non-SSI files (with opt. compr.-level, default=10)" NEWLINE); + printf(" ATTENTION: browser has to support \"Content-Encoding: deflate\"!" NEWLINE); +#endif + printf(" if targetdir not specified, htmlgen will attempt to" NEWLINE); + printf(" process files in subdirectory 'fs'" NEWLINE); +} + +int main(int argc, char *argv[]) +{ + char path[MAX_PATH_LEN]; + char appPath[MAX_PATH_LEN]; + FILE *data_file; + FILE *struct_file; + int filesProcessed; + int i; + char targetfile[MAX_PATH_LEN]; + strcpy(targetfile, "fsdata.c"); + + memset(path, 0, sizeof(path)); + memset(appPath, 0, sizeof(appPath)); + + printf(NEWLINE " makefsdata - HTML to C source converter" NEWLINE); + printf(" by Jim Pettinato - circa 2003 " NEWLINE); + printf(" extended by Simon Goldschmidt - 2009 " NEWLINE NEWLINE); + + LWIP_ASSERT("sizeof(hdr_buf) must fit into an u16_t", sizeof(hdr_buf) <= 0xffff); + + strcpy(path, "fs"); + for (i = 1; i < argc; i++) { + if (argv[i] == NULL) { + continue; + } + if (argv[i][0] == '-') { + if (strstr(argv[i], "-svr:") == argv[i]) { + snprintf(serverIDBuffer, sizeof(serverIDBuffer), "Server: %s\r\n", &argv[i][5]); + serverID = serverIDBuffer; + printf("Using Server-ID: \"%s\"\n", serverID); + } else if (!strcmp(argv[i], "-s")) { + processSubs = 0; + } else if (!strcmp(argv[i], "-e")) { + includeHttpHeader = 0; + } else if (!strcmp(argv[i], "-11")) { + useHttp11 = 1; + } else if (!strcmp(argv[i], "-nossi")) { + supportSsi = 0; + } else if (strstr(argv[i], "-ssi:") == argv[i]) { + const char* ssi_list_filename = &argv[i][5]; + if (checkSsiByFilelist(ssi_list_filename)) { + printf("Reading list of SSI files from \"%s\"\n", ssi_list_filename); + } else { + printf("Failed to load list of SSI files from \"%s\"\n", ssi_list_filename); + } + } else if (!strcmp(argv[i], "-c")) { + precalcChksum = 1; + } else if (strstr(argv[i], "-f:") == argv[i]) { + strncpy(targetfile, &argv[i][3], sizeof(targetfile) - 1); + targetfile[sizeof(targetfile) - 1] = 0; + printf("Writing to file \"%s\"\n", targetfile); + } else if (!strcmp(argv[i], "-m")) { + includeLastModified = 1; + } else if (!strcmp(argv[i], "-defl")) { +#if MAKEFS_SUPPORT_DEFLATE + char *colon = strstr(argv[i], ":"); + if (colon) { + if (colon[1] != 0) { + int defl_level = atoi(&colon[1]); + if ((defl_level >= 0) && (defl_level <= 10)) { + deflate_level = defl_level; + } else { + printf("ERROR: deflate level must be [0..10]" NEWLINE); + exit(0); + } + } + } + deflateNonSsiFiles = 1; + printf("Deflating all non-SSI files with level %d (but only if size is reduced)" NEWLINE, deflate_level); +#else + printf("WARNING: Deflate support is disabled\n"); +#endif + } else if (strstr(argv[i], "-x:") == argv[i]) { + exclude_list = &argv[i][3]; + printf("Excluding files with extensions %s" NEWLINE, exclude_list); + } else if (strstr(argv[i], "-xc:") == argv[i]) { + ncompress_list = &argv[i][4]; + printf("Skipping compresion for files with extensions %s" NEWLINE, ncompress_list); + } else if ((strstr(argv[i], "-?")) || (strstr(argv[i], "-h"))) { + print_usage(); + exit(0); + } + } else if ((argv[i][0] == '/') && (argv[i][1] == '?') && (argv[i][2] == 0)) { + print_usage(); + exit(0); + } else { + strncpy(path, argv[i], sizeof(path) - 1); + path[sizeof(path) - 1] = 0; + } + } + + if (!check_path(path, sizeof(path))) { + printf("Invalid path: \"%s\"." NEWLINE, path); + exit(-1); + } + + GETCWD(appPath, MAX_PATH_LEN); + /* if command line param or subdir named 'fs' not found spout usage verbiage */ + if (!CHDIR_SUCCEEDED(CHDIR(path))) { + /* if no subdir named 'fs' (or the one which was given) exists, spout usage verbiage */ + printf(" Failed to open directory \"%s\"." NEWLINE NEWLINE, path); + print_usage(); + exit(-1); + } + CHDIR(appPath); + + printf("HTTP %sheader will %s statically included." NEWLINE, + (includeHttpHeader ? (useHttp11 ? "1.1 " : "1.0 ") : ""), + (includeHttpHeader ? "be" : "not be")); + + curSubdir[0] = '\0'; /* start off in web page's root directory - relative paths */ + printf(" Processing all files in directory %s", path); + if (processSubs) { + printf(" and subdirectories..." NEWLINE NEWLINE); + } else { + printf("..." NEWLINE NEWLINE); + } + + data_file = fopen("fsdata.tmp", "wb"); + if (data_file == NULL) { + printf("Failed to create file \"fsdata.tmp\"\n"); + exit(-1); + } + struct_file = fopen("fshdr.tmp", "wb"); + if (struct_file == NULL) { + printf("Failed to create file \"fshdr.tmp\"\n"); + fclose(data_file); + exit(-1); + } + + CHDIR(path); + + fprintf(data_file, "#include \"lwip/apps/fs.h\"" NEWLINE); + fprintf(data_file, "#include \"lwip/def.h\"" NEWLINE NEWLINE NEWLINE); + + fprintf(data_file, "#define file_NULL (struct fsdata_file *) NULL" NEWLINE NEWLINE NEWLINE); + /* define FS_FILE_FLAGS_HEADER_INCLUDED to 1 if not defined (compatibility with older httpd/fs) */ + fprintf(data_file, "#ifndef FS_FILE_FLAGS_HEADER_INCLUDED" NEWLINE "#define FS_FILE_FLAGS_HEADER_INCLUDED 1" NEWLINE "#endif" NEWLINE); + /* define FS_FILE_FLAGS_HEADER_PERSISTENT to 0 if not defined (compatibility with older httpd/fs: wasn't supported back then) */ + fprintf(data_file, "#ifndef FS_FILE_FLAGS_HEADER_PERSISTENT" NEWLINE "#define FS_FILE_FLAGS_HEADER_PERSISTENT 0" NEWLINE "#endif" NEWLINE); + + /* define alignment defines */ +#if ALIGN_PAYLOAD + fprintf(data_file, "/* FSDATA_FILE_ALIGNMENT: 0=off, 1=by variable, 2=by include */" NEWLINE "#ifndef FSDATA_FILE_ALIGNMENT" NEWLINE "#define FSDATA_FILE_ALIGNMENT 0" NEWLINE "#endif" NEWLINE); +#endif + fprintf(data_file, "#ifndef FSDATA_ALIGN_PRE" NEWLINE "#define FSDATA_ALIGN_PRE" NEWLINE "#endif" NEWLINE); + fprintf(data_file, "#ifndef FSDATA_ALIGN_POST" NEWLINE "#define FSDATA_ALIGN_POST" NEWLINE "#endif" NEWLINE); +#if ALIGN_PAYLOAD + fprintf(data_file, "#if FSDATA_FILE_ALIGNMENT==2" NEWLINE "#include \"fsdata_alignment.h\"" NEWLINE "#endif" NEWLINE); +#endif + + sprintf(lastFileVar, "NULL"); + + filesProcessed = process_sub(data_file, struct_file); + + /* data_file now contains all of the raw data.. now append linked list of + * file header structs to allow embedded app to search for a file name */ + fprintf(data_file, NEWLINE NEWLINE); + fprintf(struct_file, "#define FS_ROOT file_%s" NEWLINE, lastFileVar); + fprintf(struct_file, "#define FS_NUMFILES %d" NEWLINE NEWLINE, filesProcessed); + + fclose(data_file); + fclose(struct_file); + + CHDIR(appPath); + /* append struct_file to data_file */ + printf(NEWLINE "Creating target file..." NEWLINE NEWLINE); + concat_files("fsdata.tmp", "fshdr.tmp", targetfile); + + /* if succeeded, delete the temporary files */ + if (remove("fsdata.tmp") != 0) { + printf("Warning: failed to delete fsdata.tmp\n"); + } + if (remove("fshdr.tmp") != 0) { + printf("Warning: failed to delete fshdr.tmp\n"); + } + + printf(NEWLINE "Processed %d files - done." NEWLINE, filesProcessed); +#if MAKEFS_SUPPORT_DEFLATE + if (deflateNonSsiFiles) { + printf("(Deflated total byte reduction: %d bytes -> %d bytes (%.02f%%)" NEWLINE, + (int)overallDataBytes, (int)deflatedBytesReduced, (float)((deflatedBytesReduced * 100.0) / overallDataBytes)); + } +#endif + printf(NEWLINE); + + while (first_file != NULL) { + struct file_entry *fe = first_file; + first_file = fe->next; + free(fe); + } + + if (ssi_file_buffer) { + free(ssi_file_buffer); + } + if (ssi_file_lines) { + free(ssi_file_lines); + } + + return 0; +} + +int check_path(char *path, size_t size) +{ + size_t slen; + if (path[0] == 0) { + /* empty */ + return 0; + } + slen = strlen(path); + if (slen >= size) { + /* not NULL-terminated */ + return 0; + } + while ((slen > 0) && ((path[slen] == '\\') || (path[slen] == '/'))) { + /* path should not end with trailing backslash */ + path[slen] = 0; + slen--; + } + if (slen == 0) { + return 0; + } + return 1; +} + +static void copy_file(const char *filename_in, FILE *fout) +{ + FILE *fin; + size_t len; + void *buf; + fin = fopen(filename_in, "rb"); + if (fin == NULL) { + printf("Failed to open file \"%s\"\n", filename_in); + exit(-1); + } + buf = malloc(COPY_BUFSIZE); + while ((len = fread(buf, 1, COPY_BUFSIZE, fin)) > 0) { + fwrite(buf, 1, len, fout); + } + free(buf); + fclose(fin); +} + +void concat_files(const char *file1, const char *file2, const char *targetfile) +{ + FILE *fout; + fout = fopen(targetfile, "wb"); + if (fout == NULL) { + printf("Failed to open file \"%s\"\n", targetfile); + exit(-1); + } + copy_file(file1, fout); + copy_file(file2, fout); + fclose(fout); +} + +int process_sub(FILE *data_file, FILE *struct_file) +{ + tinydir_dir dir; + int filesProcessed = 0; + + if (processSubs) { + /* process subs recursively */ + size_t sublen = strlen(curSubdir); + size_t freelen = sizeof(curSubdir) - sublen - 1; + int ret; + LWIP_ASSERT("sublen < sizeof(curSubdir)", sublen < sizeof(curSubdir)); + + ret = tinydir_open_sorted(&dir, TINYDIR_STRING(".")); + + if (ret == 0) { + unsigned int i; + for (i = 0; i < dir.n_files; i++) { + tinydir_file file; + + ret = tinydir_readfile_n(&dir, &file, i); + + if (ret == 0) { +#if (defined _MSC_VER || defined __MINGW32__) && (defined _UNICODE) + size_t num_char_converted; + char currName[256]; + wcstombs_s(&num_char_converted, currName, sizeof(currName), file.name, sizeof(currName)); +#else + const char *currName = file.name; +#endif + + if (currName[0] == '.') { + continue; + } + if (!file.is_dir) { + continue; + } + if (freelen > 0) { + CHDIR(currName); + strncat(curSubdir, "/", freelen); + strncat(curSubdir, currName, freelen - 1); + curSubdir[sizeof(curSubdir) - 1] = 0; + printf("processing subdirectory %s/..." NEWLINE, curSubdir); + filesProcessed += process_sub(data_file, struct_file); + CHDIR(".."); + curSubdir[sublen] = 0; + } else { + printf("WARNING: cannot process sub due to path length restrictions: \"%s/%s\"\n", curSubdir, currName); + } + } + } + } + + ret = tinydir_open_sorted(&dir, TINYDIR_STRING(".")); + if (ret == 0) { + unsigned int i; + for (i = 0; i < dir.n_files; i++) { + tinydir_file file; + + ret = tinydir_readfile_n(&dir, &file, i); + + if (ret == 0) { + if (!file.is_dir) { +#if (defined _MSC_VER || defined __MINGW32__) && (defined _UNICODE) + size_t num_char_converted; + char curName[256]; + wcstombs_s(&num_char_converted, curName, sizeof(curName), file.name, sizeof(curName)); +#else + const char *curName = file.name; +#endif + + if (strcmp(curName, "fsdata.tmp") == 0) { + continue; + } + if (strcmp(curName, "fshdr.tmp") == 0) { + continue; + } + if (file_to_exclude(curName)) { + printf("skipping %s/%s by exclude list (-x option)..." NEWLINE, curSubdir, curName); + continue; + } + + printf("processing %s/%s..." NEWLINE, curSubdir, curName); + + if (process_file(data_file, struct_file, curName) < 0) { + printf(NEWLINE "Error... aborting" NEWLINE); + return -1; + } + filesProcessed++; + } + } + } + } + } + + return filesProcessed; +} + +static u8_t *get_file_data(const char *filename, int *file_size, int can_be_compressed, int *is_compressed) +{ + FILE *inFile; + size_t fsize = 0; + u8_t *buf; + size_t r; + int rs; + LWIP_UNUSED_ARG(r); /* for LWIP_NOASSERT */ + inFile = fopen(filename, "rb"); + if (inFile == NULL) { + printf("Failed to open file \"%s\"\n", filename); + exit(-1); + } + fseek(inFile, 0, SEEK_END); + rs = ftell(inFile); + if (rs < 0) { + printf("ftell failed with %d\n", errno); + exit(-1); + } + fsize = (size_t)rs; + fseek(inFile, 0, SEEK_SET); + buf = (u8_t *)malloc(fsize); + LWIP_ASSERT("buf != NULL", buf != NULL); + r = fread(buf, 1, fsize, inFile); + LWIP_ASSERT("r == fsize", r == fsize); + *file_size = fsize; + *is_compressed = 0; +#if MAKEFS_SUPPORT_DEFLATE + overallDataBytes += fsize; + if (deflateNonSsiFiles) { + if (can_be_compressed) { + if (fsize < OUT_BUF_SIZE) { + u8_t *ret_buf; + tdefl_status status; + size_t in_bytes = fsize; + size_t out_bytes = OUT_BUF_SIZE; + const void *next_in = buf; + void *next_out = s_outbuf; + /* create tdefl() compatible flags (we have to compose the low-level flags ourselves, or use tdefl_create_comp_flags_from_zip_params() but that means MINIZ_NO_ZLIB_APIS can't be defined). */ + mz_uint comp_flags = s_tdefl_num_probes[MZ_MIN(10, deflate_level)] | ((deflate_level <= 3) ? TDEFL_GREEDY_PARSING_FLAG : 0); + if (!deflate_level) { + comp_flags |= TDEFL_FORCE_ALL_RAW_BLOCKS; + } + status = tdefl_init(&g_deflator, NULL, NULL, comp_flags); + if (status != TDEFL_STATUS_OKAY) { + printf("tdefl_init() failed!\n"); + exit(-1); + } + memset(s_outbuf, 0, sizeof(s_outbuf)); + status = tdefl_compress(&g_deflator, next_in, &in_bytes, next_out, &out_bytes, TDEFL_FINISH); + if (status != TDEFL_STATUS_DONE) { + printf("deflate failed: %d\n", status); + exit(-1); + } + LWIP_ASSERT("out_bytes <= COPY_BUFSIZE", out_bytes <= OUT_BUF_SIZE); + if (out_bytes < fsize) { + ret_buf = (u8_t *)malloc(out_bytes); + LWIP_ASSERT("ret_buf != NULL", ret_buf != NULL); + memcpy(ret_buf, s_outbuf, out_bytes); + { + /* sanity-check compression be inflating and comparing to the original */ + tinfl_status dec_status; + tinfl_decompressor inflator; + size_t dec_in_bytes = out_bytes; + size_t dec_out_bytes = OUT_BUF_SIZE; + next_out = s_checkbuf; + + tinfl_init(&inflator); + memset(s_checkbuf, 0, sizeof(s_checkbuf)); + dec_status = tinfl_decompress(&inflator, (const mz_uint8 *)ret_buf, &dec_in_bytes, s_checkbuf, (mz_uint8 *)next_out, &dec_out_bytes, 0); + LWIP_ASSERT("tinfl_decompress failed", dec_status == TINFL_STATUS_DONE); + LWIP_ASSERT("tinfl_decompress size mismatch", fsize == dec_out_bytes); + LWIP_ASSERT("decompressed memcmp failed", !memcmp(s_checkbuf, buf, fsize)); + } + /* free original buffer, use compressed data + size */ + free(buf); + buf = ret_buf; + *file_size = out_bytes; + printf(" - deflate: %d bytes -> %d bytes (%.02f%%)" NEWLINE, (int)fsize, (int)out_bytes, (float)((out_bytes * 100.0) / fsize)); + deflatedBytesReduced += (size_t)(fsize - out_bytes); + *is_compressed = 1; + } else { + printf(" - uncompressed: (would be %d bytes larger using deflate)" NEWLINE, (int)(out_bytes - fsize)); + } + } else { + printf(" - uncompressed: (file is larger than deflate bufer)" NEWLINE); + } + } else { + printf(" - cannot be compressed" NEWLINE); + } + } +#else + LWIP_UNUSED_ARG(can_be_compressed); +#endif + fclose(inFile); + return buf; +} + +static void process_file_data(FILE *data_file, u8_t *file_data, size_t file_size) +{ + size_t written, i, src_off = 0; + size_t off = 0; + LWIP_UNUSED_ARG(written); /* for LWIP_NOASSERT */ + for (i = 0; i < file_size; i++) { + LWIP_ASSERT("file_buffer_c overflow", off < sizeof(file_buffer_c) - 5); + sprintf(&file_buffer_c[off], "0x%02x,", file_data[i]); + off += 5; + if ((++src_off % HEX_BYTES_PER_LINE) == 0) { + LWIP_ASSERT("file_buffer_c overflow", off < sizeof(file_buffer_c) - NEWLINE_LEN); + memcpy(&file_buffer_c[off], NEWLINE, NEWLINE_LEN); + off += NEWLINE_LEN; + } + if (off + 20 >= sizeof(file_buffer_c)) { + written = fwrite(file_buffer_c, 1, off, data_file); + LWIP_ASSERT("written == off", written == off); + off = 0; + } + } + written = fwrite(file_buffer_c, 1, off, data_file); + LWIP_ASSERT("written == off", written == off); +} + +static int write_checksums(FILE *struct_file, const char *varname, + u16_t hdr_len, u16_t hdr_chksum, const u8_t *file_data, size_t file_size) +{ + int chunk_size = TCP_MSS; + int offset, src_offset; + size_t len; + int i = 0; +#if LWIP_TCP_TIMESTAMPS + /* when timestamps are used, usable space is 12 bytes less per segment */ + chunk_size -= 12; +#endif + + fprintf(struct_file, "#if HTTPD_PRECALCULATED_CHECKSUM" NEWLINE); + fprintf(struct_file, "const struct fsdata_chksum chksums_%s[] = {" NEWLINE, varname); + + if (hdr_len > 0) { + /* add checksum for HTTP header */ + fprintf(struct_file, "{%d, 0x%04x, %d}," NEWLINE, 0, hdr_chksum, hdr_len); + i++; + } + src_offset = 0; + for (offset = hdr_len; ; offset += len) { + unsigned short chksum; + const void *data = (const void *)&file_data[src_offset]; + len = LWIP_MIN(chunk_size, (int)file_size - src_offset); + if (len == 0) { + break; + } + chksum = ~inet_chksum(data, (u16_t)len); + /* add checksum for data */ + fprintf(struct_file, "{%d, 0x%04x, %"SZT_F"}," NEWLINE, offset, chksum, len); + i++; + } + fprintf(struct_file, "};" NEWLINE); + fprintf(struct_file, "#endif /* HTTPD_PRECALCULATED_CHECKSUM */" NEWLINE); + return i; +} + +static int is_valid_char_for_c_var(char x) +{ + if (((x >= 'A') && (x <= 'Z')) || + ((x >= 'a') && (x <= 'z')) || + ((x >= '0') && (x <= '9')) || + (x == '_')) { + return 1; + } + return 0; +} + +static void fix_filename_for_c(char *qualifiedName, size_t max_len) +{ + struct file_entry *f; + size_t len = strlen(qualifiedName); + char *new_name = (char *)malloc(len + 2); + int filename_ok; + int cnt = 0; + size_t i; + if (len + 3 == max_len) { + printf("File name too long: \"%s\"\n", qualifiedName); + exit(-1); + } + strcpy(new_name, qualifiedName); + for (i = 0; i < len; i++) { + if (!is_valid_char_for_c_var(new_name[i])) { + new_name[i] = '_'; + } + } + do { + filename_ok = 1; + for (f = first_file; f != NULL; f = f->next) { + if (!strcmp(f->filename_c, new_name)) { + filename_ok = 0; + cnt++; + /* try next unique file name */ + sprintf(&new_name[len], "%d", cnt); + break; + } + } + } while (!filename_ok && (cnt < 999)); + if (!filename_ok) { + printf("Failed to get unique file name: \"%s\"\n", qualifiedName); + exit(-1); + } + strcpy(qualifiedName, new_name); + free(new_name); +} + +static void register_filename(const char *qualifiedName) +{ + struct file_entry *fe = (struct file_entry *)malloc(sizeof(struct file_entry)); + fe->filename_c = strdup(qualifiedName); + fe->next = NULL; + if (first_file == NULL) { + first_file = last_file = fe; + } else { + last_file->next = fe; + last_file = fe; + } +} + +static int checkSsiByFilelist(const char* filename_listfile) +{ + FILE *f = fopen(filename_listfile, "r"); + if (f != NULL) { + char *buf; + long rs; + size_t fsize, readcount; + size_t i, l, num_lines; + char **lines; + int state; + + fseek(f, 0, SEEK_END); + rs = ftell(f); + if (rs < 0) { + printf("ftell failed with %d\n", errno); + fclose(f); + return 0; + } + fsize = (size_t)rs; + fseek(f, 0, SEEK_SET); + buf = (char*)malloc(fsize); + if (!buf) { + printf("failed to allocate ssi file buffer\n"); + fclose(f); + return 0; + } + memset(buf, 0, fsize); + readcount = fread(buf, 1, fsize, f); + fclose(f); + if ((readcount > fsize) || !readcount) { + printf("failed to read data from ssi file\n"); + free(buf); + return 0; + } + + /* first pass: get the number of lines (and convert newlines to '0') */ + num_lines = 1; + for (i = 0; i < readcount; i++) { + if (buf[i] == '\n') { + num_lines++; + buf[i] = 0; + } else if (buf[i] == '\r') { + buf[i] = 0; + } + } + /* allocate the line pointer array */ + lines = (char**)malloc(sizeof(char*) * num_lines); + if (!lines) { + printf("failed to allocate ssi line buffer\n"); + free(buf); + return 0; + } + memset(lines, 0, sizeof(char*) * num_lines); + l = 0; + state = 0; + for (i = 0; i < readcount; i++) { + if (state) { + /* waiting for null */ + if (buf[i] == 0) { + state = 0; + } + } else { + /* waiting for beginning of new string */ + if (buf[i] != 0) { + LWIP_ASSERT("lines array overflow", l < num_lines); + lines[l] = &buf[i]; + state = 1; + l++; + } + } + } + LWIP_ASSERT("lines array overflow", l < num_lines); + + ssi_file_buffer = buf; + ssi_file_lines = lines; + ssi_file_num_lines = l; + } + return 0; +} + +static int is_ssi_file(const char *filename) +{ + if (supportSsi) { + if (ssi_file_buffer) { + /* compare by list */ + size_t i; + int ret = 0; + /* build up the relative path to this file */ + size_t sublen = strlen(curSubdir); + size_t freelen = sizeof(curSubdir) - sublen - 1; + strncat(curSubdir, "/", freelen); + strncat(curSubdir, filename, freelen - 1); + curSubdir[sizeof(curSubdir) - 1] = 0; + for (i = 0; i < ssi_file_num_lines; i++) { + const char *listed_file = ssi_file_lines[i]; + /* compare without the leading '/' */ + if (!strcmp(&curSubdir[1], listed_file)) { + ret = 1; + } + } + curSubdir[sublen] = 0; + return ret; + } else { + /* check file extension */ + size_t loop; + for (loop = 0; loop < NUM_SHTML_EXTENSIONS; loop++) { + if (strstr(filename, g_pcSSIExtensions[loop])) { + return 1; + } + } + } + } + return 0; +} + +static int ext_in_list(const char* filename, const char *ext_list) +{ + int found = 0; + const char *ext = ext_list; + if (ext_list == NULL) { + return 0; + } + while(*ext != '\0') { + const char *comma = strchr(ext, ','); + size_t ext_size; + size_t filename_size = strlen(filename); + if (comma == NULL) { + comma = strchr(ext, '\0'); + } + ext_size = comma - ext; + if ((filename[filename_size - ext_size - 1] == '.') && + !strncmp(&filename[filename_size - ext_size], ext, ext_size)) { + found = 1; + break; + } + ext = comma + 1; + } + + return found; +} + +static int file_to_exclude(const char *filename) +{ + return (exclude_list != NULL) && ext_in_list(filename, exclude_list); +} + +static int file_can_be_compressed(const char *filename) +{ + return (ncompress_list == NULL) || !ext_in_list(filename, ncompress_list); +} + +int process_file(FILE *data_file, FILE *struct_file, const char *filename) +{ + char varname[MAX_PATH_LEN]; + int i = 0; + char qualifiedName[MAX_PATH_LEN]; + int file_size; + u16_t http_hdr_chksum = 0; + u16_t http_hdr_len = 0; + int chksum_count = 0; + u8_t flags = 0; + u8_t has_content_len; + u8_t *file_data; + int is_ssi; + int can_be_compressed; + int is_compressed = 0; + int flags_printed; + + /* create qualified name (@todo: prepend slash or not?) */ + sprintf(qualifiedName, "%s/%s", curSubdir, filename); + /* create C variable name */ + strcpy(varname, qualifiedName); + /* convert slashes & dots to underscores */ + fix_filename_for_c(varname, MAX_PATH_LEN); + register_filename(varname); +#if ALIGN_PAYLOAD + /* to force even alignment of array, type 1 */ + fprintf(data_file, "#if FSDATA_FILE_ALIGNMENT==1" NEWLINE); + fprintf(data_file, "static const " PAYLOAD_ALIGN_TYPE " dummy_align_%s = %d;" NEWLINE, varname, payload_alingment_dummy_counter++); + fprintf(data_file, "#endif" NEWLINE); +#endif /* ALIGN_PAYLOAD */ + fprintf(data_file, "static const unsigned char FSDATA_ALIGN_PRE data_%s[] FSDATA_ALIGN_POST = {" NEWLINE, varname); + /* encode source file name (used by file system, not returned to browser) */ + fprintf(data_file, "/* %s (%"SZT_F" chars) */" NEWLINE, qualifiedName, strlen(qualifiedName) + 1); + file_put_ascii(data_file, qualifiedName, strlen(qualifiedName) + 1, &i); +#if ALIGN_PAYLOAD + /* pad to even number of bytes to assure payload is on aligned boundary */ + while (i % PAYLOAD_ALIGNMENT != 0) { + fprintf(data_file, "0x%02x,", 0); + i++; + } +#endif /* ALIGN_PAYLOAD */ + fprintf(data_file, NEWLINE); + + is_ssi = is_ssi_file(filename); + if (is_ssi) { + flags |= FS_FILE_FLAGS_SSI; + } + has_content_len = !is_ssi; + can_be_compressed = includeHttpHeader && !is_ssi && file_can_be_compressed(filename); + file_data = get_file_data(filename, &file_size, can_be_compressed, &is_compressed); + if (includeHttpHeader) { + file_write_http_header(data_file, filename, file_size, &http_hdr_len, &http_hdr_chksum, has_content_len, is_compressed); + flags |= FS_FILE_FLAGS_HEADER_INCLUDED; + if (has_content_len) { + flags |= FS_FILE_FLAGS_HEADER_PERSISTENT; + if (useHttp11) { + flags |= FS_FILE_FLAGS_HEADER_HTTPVER_1_1; + } + } + } + if (precalcChksum) { + chksum_count = write_checksums(struct_file, varname, http_hdr_len, http_hdr_chksum, file_data, file_size); + } + + /* build declaration of struct fsdata_file in temp file */ + fprintf(struct_file, "const struct fsdata_file file_%s[] = { {" NEWLINE, varname); + fprintf(struct_file, "file_%s," NEWLINE, lastFileVar); + fprintf(struct_file, "data_%s," NEWLINE, varname); + fprintf(struct_file, "data_%s + %d," NEWLINE, varname, i); + fprintf(struct_file, "sizeof(data_%s) - %d," NEWLINE, varname, i); + + flags_printed = 0; + if (flags & FS_FILE_FLAGS_HEADER_INCLUDED) { + fputs("FS_FILE_FLAGS_HEADER_INCLUDED", struct_file); + flags_printed = 1; + } + if (flags & FS_FILE_FLAGS_HEADER_PERSISTENT) { + if (flags_printed) { + fputs(" | ", struct_file); + } + fputs("FS_FILE_FLAGS_HEADER_PERSISTENT", struct_file); + flags_printed = 1; + } + if (flags & FS_FILE_FLAGS_HEADER_HTTPVER_1_1) { + if (flags_printed) { + fputs(" | ", struct_file); + } + fputs("FS_FILE_FLAGS_HEADER_HTTPVER_1_1", struct_file); + flags_printed = 1; + } + if (flags & FS_FILE_FLAGS_SSI) { + if (flags_printed) { + fputs(" | ", struct_file); + } + fputs("FS_FILE_FLAGS_SSI", struct_file); + flags_printed = 1; + } + if (!flags_printed) { + fputs("0", struct_file); + } + fputs("," NEWLINE, struct_file); + if (precalcChksum) { + fprintf(struct_file, "#if HTTPD_PRECALCULATED_CHECKSUM" NEWLINE); + fprintf(struct_file, "%d, chksums_%s," NEWLINE, chksum_count, varname); + fprintf(struct_file, "#endif /* HTTPD_PRECALCULATED_CHECKSUM */" NEWLINE); + } + fprintf(struct_file, "}};" NEWLINE NEWLINE); + strcpy(lastFileVar, varname); + + /* write actual file contents */ + i = 0; + fprintf(data_file, NEWLINE "/* raw file data (%d bytes) */" NEWLINE, file_size); + process_file_data(data_file, file_data, file_size); + fprintf(data_file, "};" NEWLINE NEWLINE); + free(file_data); + return 0; +} + +int file_write_http_header(FILE *data_file, const char *filename, int file_size, u16_t *http_hdr_len, + u16_t *http_hdr_chksum, u8_t provide_content_len, int is_compressed) +{ + int i = 0; + int response_type = HTTP_HDR_OK; + const char *file_type; + const char *cur_string; + size_t cur_len; + int written = 0; + size_t hdr_len = 0; + u16_t acc; + const char *file_ext; + size_t j; + u8_t provide_last_modified = includeLastModified; + + memset(hdr_buf, 0, sizeof(hdr_buf)); + + if (useHttp11) { + response_type = HTTP_HDR_OK_11; + } + + fprintf(data_file, NEWLINE "/* HTTP header */"); + if (strstr(filename, "404") == filename) { + response_type = HTTP_HDR_NOT_FOUND; + if (useHttp11) { + response_type = HTTP_HDR_NOT_FOUND_11; + } + } else if (strstr(filename, "400") == filename) { + response_type = HTTP_HDR_BAD_REQUEST; + if (useHttp11) { + response_type = HTTP_HDR_BAD_REQUEST_11; + } + } else if (strstr(filename, "501") == filename) { + response_type = HTTP_HDR_NOT_IMPL; + if (useHttp11) { + response_type = HTTP_HDR_NOT_IMPL_11; + } + } + cur_string = g_psHTTPHeaderStrings[response_type]; + cur_len = strlen(cur_string); + fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); + written += file_put_ascii(data_file, cur_string, cur_len, &i); + i = 0; + if (precalcChksum) { + memcpy(&hdr_buf[hdr_len], cur_string, cur_len); + hdr_len += cur_len; + } + + cur_string = serverID; + cur_len = strlen(cur_string); + fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); + written += file_put_ascii(data_file, cur_string, cur_len, &i); + i = 0; + if (precalcChksum) { + memcpy(&hdr_buf[hdr_len], cur_string, cur_len); + hdr_len += cur_len; + } + + file_ext = filename; + if (file_ext != NULL) { + while (strstr(file_ext, ".") != NULL) { + file_ext = strstr(file_ext, "."); + file_ext++; + } + } + if ((file_ext == NULL) || (*file_ext == 0)) { + printf("failed to get extension for file \"%s\", using default.\n", filename); + file_type = HTTP_HDR_DEFAULT_TYPE; + } else { + file_type = NULL; + for (j = 0; j < NUM_HTTP_HEADERS; j++) { + if (!strcmp(file_ext, g_psHTTPHeaders[j].extension)) { + file_type = g_psHTTPHeaders[j].content_type; + break; + } + } + if (file_type == NULL) { + printf("failed to get file type for extension \"%s\", using default.\n", file_ext); + file_type = HTTP_HDR_DEFAULT_TYPE; + } + } + + /* Content-Length is used for persistent connections in HTTP/1.1 but also for + download progress in older versions + @todo: just use a big-enough buffer and let the HTTPD send spaces? */ + if (provide_content_len) { + char intbuf[MAX_PATH_LEN]; + int content_len = file_size; + memset(intbuf, 0, sizeof(intbuf)); + cur_string = g_psHTTPHeaderStrings[HTTP_HDR_CONTENT_LENGTH]; + cur_len = strlen(cur_string); + fprintf(data_file, NEWLINE "/* \"%s%d\r\n\" (%"SZT_F"+ bytes) */" NEWLINE, cur_string, content_len, cur_len + 2); + written += file_put_ascii(data_file, cur_string, cur_len, &i); + if (precalcChksum) { + memcpy(&hdr_buf[hdr_len], cur_string, cur_len); + hdr_len += cur_len; + } + + lwip_itoa(intbuf, sizeof(intbuf), content_len); + strcat(intbuf, "\r\n"); + cur_len = strlen(intbuf); + written += file_put_ascii(data_file, intbuf, cur_len, &i); + i = 0; + if (precalcChksum) { + memcpy(&hdr_buf[hdr_len], intbuf, cur_len); + hdr_len += cur_len; + } + } + if (provide_last_modified) { + char modbuf[256]; + struct stat stat_data; + struct tm *t; + memset(modbuf, 0, sizeof(modbuf)); + memset(&stat_data, 0, sizeof(stat_data)); + cur_string = modbuf; + strcpy(modbuf, "Last-Modified: "); + if (stat(filename, &stat_data) != 0) { + printf("stat(%s) failed with error %d\n", filename, errno); + exit(-1); + } + t = gmtime(&stat_data.st_mtime); + if (t == NULL) { + printf("gmtime() failed with error %d\n", errno); + exit(-1); + } + strftime(&modbuf[15], sizeof(modbuf) - 15, "%a, %d %b %Y %H:%M:%S GMT", t); + cur_len = strlen(cur_string); + fprintf(data_file, NEWLINE "/* \"%s\"\r\n\" (%"SZT_F"+ bytes) */" NEWLINE, cur_string, cur_len + 2); + written += file_put_ascii(data_file, cur_string, cur_len, &i); + if (precalcChksum) { + memcpy(&hdr_buf[hdr_len], cur_string, cur_len); + hdr_len += cur_len; + } + + modbuf[0] = 0; + strcat(modbuf, "\r\n"); + cur_len = strlen(modbuf); + written += file_put_ascii(data_file, modbuf, cur_len, &i); + i = 0; + if (precalcChksum) { + memcpy(&hdr_buf[hdr_len], modbuf, cur_len); + hdr_len += cur_len; + } + } + + /* HTTP/1.1 implements persistent connections */ + if (useHttp11) { + if (provide_content_len) { + cur_string = g_psHTTPHeaderStrings[HTTP_HDR_CONN_KEEPALIVE]; + } else { + /* no Content-Length available, so a persistent connection is no possible + because the client does not know the data length */ + cur_string = g_psHTTPHeaderStrings[HTTP_HDR_CONN_CLOSE]; + } + cur_len = strlen(cur_string); + fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); + written += file_put_ascii(data_file, cur_string, cur_len, &i); + i = 0; + if (precalcChksum) { + memcpy(&hdr_buf[hdr_len], cur_string, cur_len); + hdr_len += cur_len; + } + } + +#if MAKEFS_SUPPORT_DEFLATE + if (is_compressed) { + /* tell the client about the deflate encoding */ + LWIP_ASSERT("error", deflateNonSsiFiles); + cur_string = "Content-Encoding: deflate\r\n"; + cur_len = strlen(cur_string); + fprintf(data_file, NEWLINE "/* \"%s\" (%d bytes) */" NEWLINE, cur_string, cur_len); + written += file_put_ascii(data_file, cur_string, cur_len, &i); + i = 0; + } +#else + LWIP_UNUSED_ARG(is_compressed); +#endif + + /* write content-type, ATTENTION: this includes the double-CRLF! */ + cur_string = file_type; + cur_len = strlen(cur_string); + fprintf(data_file, NEWLINE "/* \"%s\" (%"SZT_F" bytes) */" NEWLINE, cur_string, cur_len); + written += file_put_ascii(data_file, cur_string, cur_len, &i); + i = 0; + + /* ATTENTION: headers are done now (double-CRLF has been written!) */ + + if (precalcChksum) { + LWIP_ASSERT("hdr_len + cur_len <= sizeof(hdr_buf)", hdr_len + cur_len <= sizeof(hdr_buf)); + memcpy(&hdr_buf[hdr_len], cur_string, cur_len); + hdr_len += cur_len; + + LWIP_ASSERT("strlen(hdr_buf) == hdr_len", strlen(hdr_buf) == hdr_len); + acc = ~inet_chksum(hdr_buf, (u16_t)hdr_len); + *http_hdr_len = (u16_t)hdr_len; + *http_hdr_chksum = acc; + } + + return written; +} + +int file_put_ascii(FILE *file, const char *ascii_string, int len, int *i) +{ + int x; + for (x = 0; x < len; x++) { + unsigned char cur = ascii_string[x]; + fprintf(file, "0x%02x,", cur); + if ((++(*i) % HEX_BYTES_PER_LINE) == 0) { + fprintf(file, NEWLINE); + } + } + return len; +} + +int s_put_ascii(char *buf, const char *ascii_string, int len, int *i) +{ + int x; + int idx = 0; + for (x = 0; x < len; x++) { + unsigned char cur = ascii_string[x]; + sprintf(&buf[idx], "0x%02x,", cur); + idx += 5; + if ((++(*i) % HEX_BYTES_PER_LINE) == 0) { + sprintf(&buf[idx], NEWLINE); + idx += NEWLINE_LEN; + } + } + return len; +} diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/readme.txt b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/readme.txt index 41c7d800..3768585e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/readme.txt +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/readme.txt @@ -1,13 +1,13 @@ -This directory contains a script ('makefsdata') to create C code suitable for -httpd for given html pages (or other files) in a directory. - -There is also a plain C console application doing the same and extended a bit. - -Usage: htmlgen [targetdir] [-s] [-i]s - targetdir: relative or absolute path to files to convert - switch -s: toggle processing of subdirectories (default is on) - switch -e: exclude HTTP header from file (header is created at runtime, default is on) - switch -11: include HTTP 1.1 header (1.0 is default) - - if targetdir not specified, makefsdata will attempt to - process files in subdirectory 'fs'. +This directory contains a script ('makefsdata') to create C code suitable for +httpd for given html pages (or other files) in a directory. + +There is also a plain C console application doing the same and extended a bit. + +Usage: htmlgen [targetdir] [-s] [-i]s + targetdir: relative or absolute path to files to convert + switch -s: toggle processing of subdirectories (default is on) + switch -e: exclude HTTP header from file (header is created at runtime, default is on) + switch -11: include HTTP 1.1 header (1.0 is default) + + if targetdir not specified, makefsdata will attempt to + process files in subdirectory 'fs'. diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/tinydir.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/tinydir.h index 69dac0a5..32ae5e84 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/tinydir.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/http/makefsdata/tinydir.h @@ -1,808 +1,808 @@ -/* -Copyright (c) 2013-2017, tinydir authors: -- Cong Xu -- Lautis Sun -- Baudouin Feildel -- Andargor -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. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR -ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES -(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; -LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -*/ -#ifndef TINYDIR_H -#define TINYDIR_H - -#ifdef __cplusplus -extern "C" { -#endif - -#if ((defined _UNICODE) && !(defined UNICODE)) -#define UNICODE -#endif - -#if ((defined UNICODE) && !(defined _UNICODE)) -#define _UNICODE -#endif - -#include -#include -#include -#ifdef _MSC_VER -# define WIN32_LEAN_AND_MEAN -# include -# include -# pragma warning(push) -# pragma warning (disable : 4996) -#else -# include -# include -# include -# include -#endif -#ifdef __MINGW32__ -# include -#endif - - -/* types */ - -/* Windows UNICODE wide character support */ -#if defined _MSC_VER || defined __MINGW32__ -#define _tinydir_char_t TCHAR -#define TINYDIR_STRING(s) _TEXT(s) -#define _tinydir_strlen _tcslen -#define _tinydir_strcpy _tcscpy -#define _tinydir_strcat _tcscat -#define _tinydir_strcmp _tcscmp -#define _tinydir_strrchr _tcsrchr -#define _tinydir_strncmp _tcsncmp -#else -#define _tinydir_char_t char -#define TINYDIR_STRING(s) s -#define _tinydir_strlen strlen -#define _tinydir_strcpy strcpy -#define _tinydir_strcat strcat -#define _tinydir_strcmp strcmp -#define _tinydir_strrchr strrchr -#define _tinydir_strncmp strncmp -#endif - -#if (defined _MSC_VER || defined __MINGW32__) -#include -#define _TINYDIR_PATH_MAX MAX_PATH -#elif defined __linux__ -#include -#define _TINYDIR_PATH_MAX PATH_MAX -#else -#define _TINYDIR_PATH_MAX 4096 -#endif - -#ifdef _MSC_VER -/* extra chars for the "\\*" mask */ -# define _TINYDIR_PATH_EXTRA 2 -#else -# define _TINYDIR_PATH_EXTRA 0 -#endif - -#define _TINYDIR_FILENAME_MAX 256 - -#if (defined _MSC_VER || defined __MINGW32__) -#define _TINYDIR_DRIVE_MAX 3 -#endif - -#ifdef _MSC_VER -# define _TINYDIR_FUNC static __inline -#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L -# define _TINYDIR_FUNC static __inline__ -#else -# define _TINYDIR_FUNC static inline -#endif - -/* readdir_r usage; define TINYDIR_USE_READDIR_R to use it (if supported) */ -#ifdef TINYDIR_USE_READDIR_R - -/* readdir_r is a POSIX-only function, and may not be available under various - * environments/settings, e.g. MinGW. Use readdir fallback */ -#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE ||\ - _POSIX_SOURCE -# define _TINYDIR_HAS_READDIR_R -#endif -#if _POSIX_C_SOURCE >= 200112L -# define _TINYDIR_HAS_FPATHCONF -# include -#endif -#if _BSD_SOURCE || _SVID_SOURCE || \ - (_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700) -# define _TINYDIR_HAS_DIRFD -# include -#endif -#if defined _TINYDIR_HAS_FPATHCONF && defined _TINYDIR_HAS_DIRFD &&\ - defined _PC_NAME_MAX -# define _TINYDIR_USE_FPATHCONF -#endif -#if defined __MINGW32__ || !defined _TINYDIR_HAS_READDIR_R ||\ - !(defined _TINYDIR_USE_FPATHCONF || defined NAME_MAX) -# define _TINYDIR_USE_READDIR -#endif - -/* Use readdir by default */ -#else -# define _TINYDIR_USE_READDIR -#endif - -/* MINGW32 has two versions of dirent, ASCII and UNICODE*/ -#ifndef _MSC_VER -#if (defined __MINGW32__) && (defined _UNICODE) -#define _TINYDIR_DIR _WDIR -#define _tinydir_dirent _wdirent -#define _tinydir_opendir _wopendir -#define _tinydir_readdir _wreaddir -#define _tinydir_closedir _wclosedir -#else -#define _TINYDIR_DIR DIR -#define _tinydir_dirent dirent -#define _tinydir_opendir opendir -#define _tinydir_readdir readdir -#define _tinydir_closedir closedir -#endif -#endif - -/* Allow user to use a custom allocator by defining _TINYDIR_MALLOC and _TINYDIR_FREE. */ -#if defined(_TINYDIR_MALLOC) && defined(_TINYDIR_FREE) -#elif !defined(_TINYDIR_MALLOC) && !defined(_TINYDIR_FREE) -#else -#error "Either define both alloc and free or none of them!" -#endif - -#if !defined(_TINYDIR_MALLOC) - #define _TINYDIR_MALLOC(_size) malloc(_size) - #define _TINYDIR_FREE(_ptr) free(_ptr) -#endif /* !defined(_TINYDIR_MALLOC) */ - -typedef struct tinydir_file -{ - _tinydir_char_t path[_TINYDIR_PATH_MAX]; - _tinydir_char_t name[_TINYDIR_FILENAME_MAX]; - _tinydir_char_t *extension; - int is_dir; - int is_reg; - -#ifndef _MSC_VER -#ifdef __MINGW32__ - struct _stat _s; -#else - struct stat _s; -#endif -#endif -} tinydir_file; - -typedef struct tinydir_dir -{ - _tinydir_char_t path[_TINYDIR_PATH_MAX]; - int has_next; - size_t n_files; - - tinydir_file *_files; -#ifdef _MSC_VER - HANDLE _h; - WIN32_FIND_DATA _f; -#else - _TINYDIR_DIR *_d; - struct _tinydir_dirent *_e; -#ifndef _TINYDIR_USE_READDIR - struct _tinydir_dirent *_ep; -#endif -#endif -} tinydir_dir; - - -/* declarations */ - -_TINYDIR_FUNC -int tinydir_open(tinydir_dir *dir, const _tinydir_char_t *path); -_TINYDIR_FUNC -int tinydir_open_sorted(tinydir_dir *dir, const _tinydir_char_t *path); -_TINYDIR_FUNC -void tinydir_close(tinydir_dir *dir); - -_TINYDIR_FUNC -int tinydir_next(tinydir_dir *dir); -_TINYDIR_FUNC -int tinydir_readfile(const tinydir_dir *dir, tinydir_file *file); -_TINYDIR_FUNC -int tinydir_readfile_n(const tinydir_dir *dir, tinydir_file *file, size_t i); -_TINYDIR_FUNC -int tinydir_open_subdir_n(tinydir_dir *dir, size_t i); - -_TINYDIR_FUNC -int tinydir_file_open(tinydir_file *file, const _tinydir_char_t *path); -_TINYDIR_FUNC -void _tinydir_get_ext(tinydir_file *file); -_TINYDIR_FUNC -int _tinydir_file_cmp(const void *a, const void *b); -#ifndef _MSC_VER -#ifndef _TINYDIR_USE_READDIR -_TINYDIR_FUNC -size_t _tinydir_dirent_buf_size(_TINYDIR_DIR *dirp); -#endif -#endif - - -/* definitions*/ - -_TINYDIR_FUNC -int tinydir_open(tinydir_dir *dir, const _tinydir_char_t *path) -{ -#ifndef _MSC_VER -#ifndef _TINYDIR_USE_READDIR - int error; - int size; /* using int size */ -#endif -#else - _tinydir_char_t path_buf[_TINYDIR_PATH_MAX]; -#endif - _tinydir_char_t *pathp; - - if (dir == NULL || path == NULL || _tinydir_strlen(path) == 0) - { - errno = EINVAL; - return -1; - } - if (_tinydir_strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX) - { - errno = ENAMETOOLONG; - return -1; - } - - /* initialise dir */ - dir->_files = NULL; -#ifdef _MSC_VER - dir->_h = INVALID_HANDLE_VALUE; -#else - dir->_d = NULL; -#ifndef _TINYDIR_USE_READDIR - dir->_ep = NULL; -#endif -#endif - tinydir_close(dir); - - _tinydir_strcpy(dir->path, path); - /* Remove trailing slashes */ - pathp = &dir->path[_tinydir_strlen(dir->path) - 1]; - while (pathp != dir->path && (*pathp == TINYDIR_STRING('\\') || *pathp == TINYDIR_STRING('/'))) - { - *pathp = TINYDIR_STRING('\0'); - pathp++; - } -#ifdef _MSC_VER - _tinydir_strcpy(path_buf, dir->path); - _tinydir_strcat(path_buf, TINYDIR_STRING("\\*")); -#if (defined WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP) - dir->_h = FindFirstFileEx(path_buf, FindExInfoStandard, &dir->_f, FindExSearchNameMatch, NULL, 0); -#else - dir->_h = FindFirstFile(path_buf, &dir->_f); -#endif - if (dir->_h == INVALID_HANDLE_VALUE) - { - errno = ENOENT; -#else - dir->_d = _tinydir_opendir(path); - if (dir->_d == NULL) - { -#endif - goto bail; - } - - /* read first file */ - dir->has_next = 1; -#ifndef _MSC_VER -#ifdef _TINYDIR_USE_READDIR - dir->_e = _tinydir_readdir(dir->_d); -#else - /* allocate dirent buffer for readdir_r */ - size = _tinydir_dirent_buf_size(dir->_d); /* conversion to int */ - if (size == -1) return -1; - dir->_ep = (struct _tinydir_dirent*)_TINYDIR_MALLOC(size); - if (dir->_ep == NULL) return -1; - - error = readdir_r(dir->_d, dir->_ep, &dir->_e); - if (error != 0) return -1; -#endif - if (dir->_e == NULL) - { - dir->has_next = 0; - } -#endif - - return 0; - -bail: - tinydir_close(dir); - return -1; -} - -_TINYDIR_FUNC -int tinydir_open_sorted(tinydir_dir *dir, const _tinydir_char_t *path) -{ - /* Count the number of files first, to pre-allocate the files array */ - size_t n_files = 0; - if (tinydir_open(dir, path) == -1) - { - return -1; - } - while (dir->has_next) - { - n_files++; - if (tinydir_next(dir) == -1) - { - goto bail; - } - } - tinydir_close(dir); - - if (tinydir_open(dir, path) == -1) - { - return -1; - } - - dir->n_files = 0; - dir->_files = (tinydir_file *)_TINYDIR_MALLOC(sizeof *dir->_files * n_files); - if (dir->_files == NULL) - { - goto bail; - } - while (dir->has_next) - { - tinydir_file *p_file; - dir->n_files++; - - p_file = &dir->_files[dir->n_files - 1]; - if (tinydir_readfile(dir, p_file) == -1) - { - goto bail; - } - - if (tinydir_next(dir) == -1) - { - goto bail; - } - - /* Just in case the number of files has changed between the first and - second reads, terminate without writing into unallocated memory */ - if (dir->n_files == n_files) - { - break; - } - } - - qsort(dir->_files, dir->n_files, sizeof(tinydir_file), _tinydir_file_cmp); - - return 0; - -bail: - tinydir_close(dir); - return -1; -} - -_TINYDIR_FUNC -void tinydir_close(tinydir_dir *dir) -{ - if (dir == NULL) - { - return; - } - - memset(dir->path, 0, sizeof(dir->path)); - dir->has_next = 0; - dir->n_files = 0; - _TINYDIR_FREE(dir->_files); - dir->_files = NULL; -#ifdef _MSC_VER - if (dir->_h != INVALID_HANDLE_VALUE) - { - FindClose(dir->_h); - } - dir->_h = INVALID_HANDLE_VALUE; -#else - if (dir->_d) - { - _tinydir_closedir(dir->_d); - } - dir->_d = NULL; - dir->_e = NULL; -#ifndef _TINYDIR_USE_READDIR - _TINYDIR_FREE(dir->_ep); - dir->_ep = NULL; -#endif -#endif -} - -_TINYDIR_FUNC -int tinydir_next(tinydir_dir *dir) -{ - if (dir == NULL) - { - errno = EINVAL; - return -1; - } - if (!dir->has_next) - { - errno = ENOENT; - return -1; - } - -#ifdef _MSC_VER - if (FindNextFile(dir->_h, &dir->_f) == 0) -#else -#ifdef _TINYDIR_USE_READDIR - dir->_e = _tinydir_readdir(dir->_d); -#else - if (dir->_ep == NULL) - { - return -1; - } - if (readdir_r(dir->_d, dir->_ep, &dir->_e) != 0) - { - return -1; - } -#endif - if (dir->_e == NULL) -#endif - { - dir->has_next = 0; -#ifdef _MSC_VER - if (GetLastError() != ERROR_SUCCESS && - GetLastError() != ERROR_NO_MORE_FILES) - { - tinydir_close(dir); - errno = EIO; - return -1; - } -#endif - } - - return 0; -} - -_TINYDIR_FUNC -int tinydir_readfile(const tinydir_dir *dir, tinydir_file *file) -{ - if (dir == NULL || file == NULL) - { - errno = EINVAL; - return -1; - } -#ifdef _MSC_VER - if (dir->_h == INVALID_HANDLE_VALUE) -#else - if (dir->_e == NULL) -#endif - { - errno = ENOENT; - return -1; - } - if (_tinydir_strlen(dir->path) + - _tinydir_strlen( -#ifdef _MSC_VER - dir->_f.cFileName -#else - dir->_e->d_name -#endif - ) + 1 + _TINYDIR_PATH_EXTRA >= - _TINYDIR_PATH_MAX) - { - /* the path for the file will be too long */ - errno = ENAMETOOLONG; - return -1; - } - if (_tinydir_strlen( -#ifdef _MSC_VER - dir->_f.cFileName -#else - dir->_e->d_name -#endif - ) >= _TINYDIR_FILENAME_MAX) - { - errno = ENAMETOOLONG; - return -1; - } - - _tinydir_strcpy(file->path, dir->path); - _tinydir_strcat(file->path, TINYDIR_STRING("/")); - _tinydir_strcpy(file->name, -#ifdef _MSC_VER - dir->_f.cFileName -#else - dir->_e->d_name -#endif - ); - _tinydir_strcat(file->path, file->name); -#ifndef _MSC_VER -#ifdef __MINGW32__ - if (_tstat( -#else - if (stat( -#endif - file->path, &file->_s) == -1) - { - return -1; - } -#endif - _tinydir_get_ext(file); - - file->is_dir = -#ifdef _MSC_VER - !!(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); -#else - S_ISDIR(file->_s.st_mode); -#endif - file->is_reg = -#ifdef _MSC_VER - !!(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) || - ( - !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DEVICE) && - !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && - !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) && -#ifdef FILE_ATTRIBUTE_INTEGRITY_STREAM - !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_INTEGRITY_STREAM) && -#endif -#ifdef FILE_ATTRIBUTE_NO_SCRUB_DATA - !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_NO_SCRUB_DATA) && -#endif - !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) && - !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY)); -#else - S_ISREG(file->_s.st_mode); -#endif - - return 0; -} - -_TINYDIR_FUNC -int tinydir_readfile_n(const tinydir_dir *dir, tinydir_file *file, size_t i) -{ - if (dir == NULL || file == NULL) - { - errno = EINVAL; - return -1; - } - if (i >= dir->n_files) - { - errno = ENOENT; - return -1; - } - - memcpy(file, &dir->_files[i], sizeof(tinydir_file)); - _tinydir_get_ext(file); - - return 0; -} - -_TINYDIR_FUNC -int tinydir_open_subdir_n(tinydir_dir *dir, size_t i) -{ - _tinydir_char_t path[_TINYDIR_PATH_MAX]; - if (dir == NULL) - { - errno = EINVAL; - return -1; - } - if (i >= dir->n_files || !dir->_files[i].is_dir) - { - errno = ENOENT; - return -1; - } - - _tinydir_strcpy(path, dir->_files[i].path); - tinydir_close(dir); - if (tinydir_open_sorted(dir, path) == -1) - { - return -1; - } - - return 0; -} - -/* Open a single file given its path */ -_TINYDIR_FUNC -int tinydir_file_open(tinydir_file *file, const _tinydir_char_t *path) -{ - tinydir_dir dir; - int result = 0; - int found = 0; - _tinydir_char_t dir_name_buf[_TINYDIR_PATH_MAX]; - _tinydir_char_t file_name_buf[_TINYDIR_FILENAME_MAX]; - _tinydir_char_t *dir_name; - _tinydir_char_t *base_name; -#if (defined _MSC_VER || defined __MINGW32__) - _tinydir_char_t drive_buf[_TINYDIR_PATH_MAX]; - _tinydir_char_t ext_buf[_TINYDIR_FILENAME_MAX]; -#endif - - if (file == NULL || path == NULL || _tinydir_strlen(path) == 0) - { - errno = EINVAL; - return -1; - } - if (_tinydir_strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX) - { - errno = ENAMETOOLONG; - return -1; - } - - /* Get the parent path */ -#if (defined _MSC_VER || defined __MINGW32__) -#if ((defined _MSC_VER) && (_MSC_VER >= 1400)) - _tsplitpath_s( - path, - drive_buf, _TINYDIR_DRIVE_MAX, - dir_name_buf, _TINYDIR_FILENAME_MAX, - file_name_buf, _TINYDIR_FILENAME_MAX, - ext_buf, _TINYDIR_FILENAME_MAX); -#else - _tsplitpath( - path, - drive_buf, - dir_name_buf, - file_name_buf, - ext_buf); -#endif - -/* _splitpath_s not work fine with only filename and widechar support */ -#ifdef _UNICODE - if (drive_buf[0] == L'\xFEFE') - drive_buf[0] = '\0'; - if (dir_name_buf[0] == L'\xFEFE') - dir_name_buf[0] = '\0'; -#endif - - if (errno) - { - errno = EINVAL; - return -1; - } - /* Emulate the behavior of dirname by returning "." for dir name if it's - empty */ - if (drive_buf[0] == '\0' && dir_name_buf[0] == '\0') - { - _tinydir_strcpy(dir_name_buf, TINYDIR_STRING(".")); - } - /* Concatenate the drive letter and dir name to form full dir name */ - _tinydir_strcat(drive_buf, dir_name_buf); - dir_name = drive_buf; - /* Concatenate the file name and extension to form base name */ - _tinydir_strcat(file_name_buf, ext_buf); - base_name = file_name_buf; -#else - _tinydir_strcpy(dir_name_buf, path); - dir_name = dirname(dir_name_buf); - _tinydir_strcpy(file_name_buf, path); - base_name =basename(file_name_buf); -#endif - - /* Open the parent directory */ - if (tinydir_open(&dir, dir_name) == -1) - { - return -1; - } - - /* Read through the parent directory and look for the file */ - while (dir.has_next) - { - if (tinydir_readfile(&dir, file) == -1) - { - result = -1; - goto bail; - } - if (_tinydir_strcmp(file->name, base_name) == 0) - { - /* File found */ - found = 1; - break; - } - tinydir_next(&dir); - } - if (!found) - { - result = -1; - errno = ENOENT; - } - -bail: - tinydir_close(&dir); - return result; -} - -_TINYDIR_FUNC -void _tinydir_get_ext(tinydir_file *file) -{ - _tinydir_char_t *period = _tinydir_strrchr(file->name, TINYDIR_STRING('.')); - if (period == NULL) - { - file->extension = &(file->name[_tinydir_strlen(file->name)]); - } - else - { - file->extension = period + 1; - } -} - -_TINYDIR_FUNC -int _tinydir_file_cmp(const void *a, const void *b) -{ - const tinydir_file *fa = (const tinydir_file *)a; - const tinydir_file *fb = (const tinydir_file *)b; - if (fa->is_dir != fb->is_dir) - { - return -(fa->is_dir - fb->is_dir); - } - return _tinydir_strncmp(fa->name, fb->name, _TINYDIR_FILENAME_MAX); -} - -#ifndef _MSC_VER -#ifndef _TINYDIR_USE_READDIR -/* -The following authored by Ben Hutchings -from https://womble.decadent.org.uk/readdir_r-advisory.html -*/ -/* Calculate the required buffer size (in bytes) for directory * -* entries read from the given directory handle. Return -1 if this * -* this cannot be done. * -* * -* This code does not trust values of NAME_MAX that are less than * -* 255, since some systems (including at least HP-UX) incorrectly * -* define it to be a smaller value. */ -_TINYDIR_FUNC -size_t _tinydir_dirent_buf_size(_TINYDIR_DIR *dirp) -{ - long name_max; - size_t name_end; - /* parameter may be unused */ - (void)dirp; - -#if defined _TINYDIR_USE_FPATHCONF - name_max = fpathconf(dirfd(dirp), _PC_NAME_MAX); - if (name_max == -1) -#if defined(NAME_MAX) - name_max = (NAME_MAX > 255) ? NAME_MAX : 255; -#else - return (size_t)(-1); -#endif -#elif defined(NAME_MAX) - name_max = (NAME_MAX > 255) ? NAME_MAX : 255; -#else -#error "buffer size for readdir_r cannot be determined" -#endif - name_end = (size_t)offsetof(struct _tinydir_dirent, d_name) + name_max + 1; - return (name_end > sizeof(struct _tinydir_dirent) ? - name_end : sizeof(struct _tinydir_dirent)); -} -#endif -#endif - -#ifdef __cplusplus -} -#endif - -# if defined (_MSC_VER) -# pragma warning(pop) -# endif - -#endif +/* +Copyright (c) 2013-2017, tinydir authors: +- Cong Xu +- Lautis Sun +- Baudouin Feildel +- Andargor +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. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +*/ +#ifndef TINYDIR_H +#define TINYDIR_H + +#ifdef __cplusplus +extern "C" { +#endif + +#if ((defined _UNICODE) && !(defined UNICODE)) +#define UNICODE +#endif + +#if ((defined UNICODE) && !(defined _UNICODE)) +#define _UNICODE +#endif + +#include +#include +#include +#ifdef _MSC_VER +# define WIN32_LEAN_AND_MEAN +# include +# include +# pragma warning(push) +# pragma warning (disable : 4996) +#else +# include +# include +# include +# include +#endif +#ifdef __MINGW32__ +# include +#endif + + +/* types */ + +/* Windows UNICODE wide character support */ +#if defined _MSC_VER || defined __MINGW32__ +#define _tinydir_char_t TCHAR +#define TINYDIR_STRING(s) _TEXT(s) +#define _tinydir_strlen _tcslen +#define _tinydir_strcpy _tcscpy +#define _tinydir_strcat _tcscat +#define _tinydir_strcmp _tcscmp +#define _tinydir_strrchr _tcsrchr +#define _tinydir_strncmp _tcsncmp +#else +#define _tinydir_char_t char +#define TINYDIR_STRING(s) s +#define _tinydir_strlen strlen +#define _tinydir_strcpy strcpy +#define _tinydir_strcat strcat +#define _tinydir_strcmp strcmp +#define _tinydir_strrchr strrchr +#define _tinydir_strncmp strncmp +#endif + +#if (defined _MSC_VER || defined __MINGW32__) +#include +#define _TINYDIR_PATH_MAX MAX_PATH +#elif defined __linux__ +#include +#define _TINYDIR_PATH_MAX PATH_MAX +#else +#define _TINYDIR_PATH_MAX 4096 +#endif + +#ifdef _MSC_VER +/* extra chars for the "\\*" mask */ +# define _TINYDIR_PATH_EXTRA 2 +#else +# define _TINYDIR_PATH_EXTRA 0 +#endif + +#define _TINYDIR_FILENAME_MAX 256 + +#if (defined _MSC_VER || defined __MINGW32__) +#define _TINYDIR_DRIVE_MAX 3 +#endif + +#ifdef _MSC_VER +# define _TINYDIR_FUNC static __inline +#elif !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L +# define _TINYDIR_FUNC static __inline__ +#else +# define _TINYDIR_FUNC static inline +#endif + +/* readdir_r usage; define TINYDIR_USE_READDIR_R to use it (if supported) */ +#ifdef TINYDIR_USE_READDIR_R + +/* readdir_r is a POSIX-only function, and may not be available under various + * environments/settings, e.g. MinGW. Use readdir fallback */ +#if _POSIX_C_SOURCE >= 1 || _XOPEN_SOURCE || _BSD_SOURCE || _SVID_SOURCE ||\ + _POSIX_SOURCE +# define _TINYDIR_HAS_READDIR_R +#endif +#if _POSIX_C_SOURCE >= 200112L +# define _TINYDIR_HAS_FPATHCONF +# include +#endif +#if _BSD_SOURCE || _SVID_SOURCE || \ + (_POSIX_C_SOURCE >= 200809L || _XOPEN_SOURCE >= 700) +# define _TINYDIR_HAS_DIRFD +# include +#endif +#if defined _TINYDIR_HAS_FPATHCONF && defined _TINYDIR_HAS_DIRFD &&\ + defined _PC_NAME_MAX +# define _TINYDIR_USE_FPATHCONF +#endif +#if defined __MINGW32__ || !defined _TINYDIR_HAS_READDIR_R ||\ + !(defined _TINYDIR_USE_FPATHCONF || defined NAME_MAX) +# define _TINYDIR_USE_READDIR +#endif + +/* Use readdir by default */ +#else +# define _TINYDIR_USE_READDIR +#endif + +/* MINGW32 has two versions of dirent, ASCII and UNICODE*/ +#ifndef _MSC_VER +#if (defined __MINGW32__) && (defined _UNICODE) +#define _TINYDIR_DIR _WDIR +#define _tinydir_dirent _wdirent +#define _tinydir_opendir _wopendir +#define _tinydir_readdir _wreaddir +#define _tinydir_closedir _wclosedir +#else +#define _TINYDIR_DIR DIR +#define _tinydir_dirent dirent +#define _tinydir_opendir opendir +#define _tinydir_readdir readdir +#define _tinydir_closedir closedir +#endif +#endif + +/* Allow user to use a custom allocator by defining _TINYDIR_MALLOC and _TINYDIR_FREE. */ +#if defined(_TINYDIR_MALLOC) && defined(_TINYDIR_FREE) +#elif !defined(_TINYDIR_MALLOC) && !defined(_TINYDIR_FREE) +#else +#error "Either define both alloc and free or none of them!" +#endif + +#if !defined(_TINYDIR_MALLOC) + #define _TINYDIR_MALLOC(_size) malloc(_size) + #define _TINYDIR_FREE(_ptr) free(_ptr) +#endif /* !defined(_TINYDIR_MALLOC) */ + +typedef struct tinydir_file +{ + _tinydir_char_t path[_TINYDIR_PATH_MAX]; + _tinydir_char_t name[_TINYDIR_FILENAME_MAX]; + _tinydir_char_t *extension; + int is_dir; + int is_reg; + +#ifndef _MSC_VER +#ifdef __MINGW32__ + struct _stat _s; +#else + struct stat _s; +#endif +#endif +} tinydir_file; + +typedef struct tinydir_dir +{ + _tinydir_char_t path[_TINYDIR_PATH_MAX]; + int has_next; + size_t n_files; + + tinydir_file *_files; +#ifdef _MSC_VER + HANDLE _h; + WIN32_FIND_DATA _f; +#else + _TINYDIR_DIR *_d; + struct _tinydir_dirent *_e; +#ifndef _TINYDIR_USE_READDIR + struct _tinydir_dirent *_ep; +#endif +#endif +} tinydir_dir; + + +/* declarations */ + +_TINYDIR_FUNC +int tinydir_open(tinydir_dir *dir, const _tinydir_char_t *path); +_TINYDIR_FUNC +int tinydir_open_sorted(tinydir_dir *dir, const _tinydir_char_t *path); +_TINYDIR_FUNC +void tinydir_close(tinydir_dir *dir); + +_TINYDIR_FUNC +int tinydir_next(tinydir_dir *dir); +_TINYDIR_FUNC +int tinydir_readfile(const tinydir_dir *dir, tinydir_file *file); +_TINYDIR_FUNC +int tinydir_readfile_n(const tinydir_dir *dir, tinydir_file *file, size_t i); +_TINYDIR_FUNC +int tinydir_open_subdir_n(tinydir_dir *dir, size_t i); + +_TINYDIR_FUNC +int tinydir_file_open(tinydir_file *file, const _tinydir_char_t *path); +_TINYDIR_FUNC +void _tinydir_get_ext(tinydir_file *file); +_TINYDIR_FUNC +int _tinydir_file_cmp(const void *a, const void *b); +#ifndef _MSC_VER +#ifndef _TINYDIR_USE_READDIR +_TINYDIR_FUNC +size_t _tinydir_dirent_buf_size(_TINYDIR_DIR *dirp); +#endif +#endif + + +/* definitions*/ + +_TINYDIR_FUNC +int tinydir_open(tinydir_dir *dir, const _tinydir_char_t *path) +{ +#ifndef _MSC_VER +#ifndef _TINYDIR_USE_READDIR + int error; + int size; /* using int size */ +#endif +#else + _tinydir_char_t path_buf[_TINYDIR_PATH_MAX]; +#endif + _tinydir_char_t *pathp; + + if (dir == NULL || path == NULL || _tinydir_strlen(path) == 0) + { + errno = EINVAL; + return -1; + } + if (_tinydir_strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX) + { + errno = ENAMETOOLONG; + return -1; + } + + /* initialise dir */ + dir->_files = NULL; +#ifdef _MSC_VER + dir->_h = INVALID_HANDLE_VALUE; +#else + dir->_d = NULL; +#ifndef _TINYDIR_USE_READDIR + dir->_ep = NULL; +#endif +#endif + tinydir_close(dir); + + _tinydir_strcpy(dir->path, path); + /* Remove trailing slashes */ + pathp = &dir->path[_tinydir_strlen(dir->path) - 1]; + while (pathp != dir->path && (*pathp == TINYDIR_STRING('\\') || *pathp == TINYDIR_STRING('/'))) + { + *pathp = TINYDIR_STRING('\0'); + pathp++; + } +#ifdef _MSC_VER + _tinydir_strcpy(path_buf, dir->path); + _tinydir_strcat(path_buf, TINYDIR_STRING("\\*")); +#if (defined WINAPI_FAMILY) && (WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP) + dir->_h = FindFirstFileEx(path_buf, FindExInfoStandard, &dir->_f, FindExSearchNameMatch, NULL, 0); +#else + dir->_h = FindFirstFile(path_buf, &dir->_f); +#endif + if (dir->_h == INVALID_HANDLE_VALUE) + { + errno = ENOENT; +#else + dir->_d = _tinydir_opendir(path); + if (dir->_d == NULL) + { +#endif + goto bail; + } + + /* read first file */ + dir->has_next = 1; +#ifndef _MSC_VER +#ifdef _TINYDIR_USE_READDIR + dir->_e = _tinydir_readdir(dir->_d); +#else + /* allocate dirent buffer for readdir_r */ + size = _tinydir_dirent_buf_size(dir->_d); /* conversion to int */ + if (size == -1) return -1; + dir->_ep = (struct _tinydir_dirent*)_TINYDIR_MALLOC(size); + if (dir->_ep == NULL) return -1; + + error = readdir_r(dir->_d, dir->_ep, &dir->_e); + if (error != 0) return -1; +#endif + if (dir->_e == NULL) + { + dir->has_next = 0; + } +#endif + + return 0; + +bail: + tinydir_close(dir); + return -1; +} + +_TINYDIR_FUNC +int tinydir_open_sorted(tinydir_dir *dir, const _tinydir_char_t *path) +{ + /* Count the number of files first, to pre-allocate the files array */ + size_t n_files = 0; + if (tinydir_open(dir, path) == -1) + { + return -1; + } + while (dir->has_next) + { + n_files++; + if (tinydir_next(dir) == -1) + { + goto bail; + } + } + tinydir_close(dir); + + if (tinydir_open(dir, path) == -1) + { + return -1; + } + + dir->n_files = 0; + dir->_files = (tinydir_file *)_TINYDIR_MALLOC(sizeof *dir->_files * n_files); + if (dir->_files == NULL) + { + goto bail; + } + while (dir->has_next) + { + tinydir_file *p_file; + dir->n_files++; + + p_file = &dir->_files[dir->n_files - 1]; + if (tinydir_readfile(dir, p_file) == -1) + { + goto bail; + } + + if (tinydir_next(dir) == -1) + { + goto bail; + } + + /* Just in case the number of files has changed between the first and + second reads, terminate without writing into unallocated memory */ + if (dir->n_files == n_files) + { + break; + } + } + + qsort(dir->_files, dir->n_files, sizeof(tinydir_file), _tinydir_file_cmp); + + return 0; + +bail: + tinydir_close(dir); + return -1; +} + +_TINYDIR_FUNC +void tinydir_close(tinydir_dir *dir) +{ + if (dir == NULL) + { + return; + } + + memset(dir->path, 0, sizeof(dir->path)); + dir->has_next = 0; + dir->n_files = 0; + _TINYDIR_FREE(dir->_files); + dir->_files = NULL; +#ifdef _MSC_VER + if (dir->_h != INVALID_HANDLE_VALUE) + { + FindClose(dir->_h); + } + dir->_h = INVALID_HANDLE_VALUE; +#else + if (dir->_d) + { + _tinydir_closedir(dir->_d); + } + dir->_d = NULL; + dir->_e = NULL; +#ifndef _TINYDIR_USE_READDIR + _TINYDIR_FREE(dir->_ep); + dir->_ep = NULL; +#endif +#endif +} + +_TINYDIR_FUNC +int tinydir_next(tinydir_dir *dir) +{ + if (dir == NULL) + { + errno = EINVAL; + return -1; + } + if (!dir->has_next) + { + errno = ENOENT; + return -1; + } + +#ifdef _MSC_VER + if (FindNextFile(dir->_h, &dir->_f) == 0) +#else +#ifdef _TINYDIR_USE_READDIR + dir->_e = _tinydir_readdir(dir->_d); +#else + if (dir->_ep == NULL) + { + return -1; + } + if (readdir_r(dir->_d, dir->_ep, &dir->_e) != 0) + { + return -1; + } +#endif + if (dir->_e == NULL) +#endif + { + dir->has_next = 0; +#ifdef _MSC_VER + if (GetLastError() != ERROR_SUCCESS && + GetLastError() != ERROR_NO_MORE_FILES) + { + tinydir_close(dir); + errno = EIO; + return -1; + } +#endif + } + + return 0; +} + +_TINYDIR_FUNC +int tinydir_readfile(const tinydir_dir *dir, tinydir_file *file) +{ + if (dir == NULL || file == NULL) + { + errno = EINVAL; + return -1; + } +#ifdef _MSC_VER + if (dir->_h == INVALID_HANDLE_VALUE) +#else + if (dir->_e == NULL) +#endif + { + errno = ENOENT; + return -1; + } + if (_tinydir_strlen(dir->path) + + _tinydir_strlen( +#ifdef _MSC_VER + dir->_f.cFileName +#else + dir->_e->d_name +#endif + ) + 1 + _TINYDIR_PATH_EXTRA >= + _TINYDIR_PATH_MAX) + { + /* the path for the file will be too long */ + errno = ENAMETOOLONG; + return -1; + } + if (_tinydir_strlen( +#ifdef _MSC_VER + dir->_f.cFileName +#else + dir->_e->d_name +#endif + ) >= _TINYDIR_FILENAME_MAX) + { + errno = ENAMETOOLONG; + return -1; + } + + _tinydir_strcpy(file->path, dir->path); + _tinydir_strcat(file->path, TINYDIR_STRING("/")); + _tinydir_strcpy(file->name, +#ifdef _MSC_VER + dir->_f.cFileName +#else + dir->_e->d_name +#endif + ); + _tinydir_strcat(file->path, file->name); +#ifndef _MSC_VER +#ifdef __MINGW32__ + if (_tstat( +#else + if (stat( +#endif + file->path, &file->_s) == -1) + { + return -1; + } +#endif + _tinydir_get_ext(file); + + file->is_dir = +#ifdef _MSC_VER + !!(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); +#else + S_ISDIR(file->_s.st_mode); +#endif + file->is_reg = +#ifdef _MSC_VER + !!(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_NORMAL) || + ( + !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DEVICE) && + !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && + !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED) && +#ifdef FILE_ATTRIBUTE_INTEGRITY_STREAM + !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_INTEGRITY_STREAM) && +#endif +#ifdef FILE_ATTRIBUTE_NO_SCRUB_DATA + !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_NO_SCRUB_DATA) && +#endif + !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_OFFLINE) && + !(dir->_f.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY)); +#else + S_ISREG(file->_s.st_mode); +#endif + + return 0; +} + +_TINYDIR_FUNC +int tinydir_readfile_n(const tinydir_dir *dir, tinydir_file *file, size_t i) +{ + if (dir == NULL || file == NULL) + { + errno = EINVAL; + return -1; + } + if (i >= dir->n_files) + { + errno = ENOENT; + return -1; + } + + memcpy(file, &dir->_files[i], sizeof(tinydir_file)); + _tinydir_get_ext(file); + + return 0; +} + +_TINYDIR_FUNC +int tinydir_open_subdir_n(tinydir_dir *dir, size_t i) +{ + _tinydir_char_t path[_TINYDIR_PATH_MAX]; + if (dir == NULL) + { + errno = EINVAL; + return -1; + } + if (i >= dir->n_files || !dir->_files[i].is_dir) + { + errno = ENOENT; + return -1; + } + + _tinydir_strcpy(path, dir->_files[i].path); + tinydir_close(dir); + if (tinydir_open_sorted(dir, path) == -1) + { + return -1; + } + + return 0; +} + +/* Open a single file given its path */ +_TINYDIR_FUNC +int tinydir_file_open(tinydir_file *file, const _tinydir_char_t *path) +{ + tinydir_dir dir; + int result = 0; + int found = 0; + _tinydir_char_t dir_name_buf[_TINYDIR_PATH_MAX]; + _tinydir_char_t file_name_buf[_TINYDIR_FILENAME_MAX]; + _tinydir_char_t *dir_name; + _tinydir_char_t *base_name; +#if (defined _MSC_VER || defined __MINGW32__) + _tinydir_char_t drive_buf[_TINYDIR_PATH_MAX]; + _tinydir_char_t ext_buf[_TINYDIR_FILENAME_MAX]; +#endif + + if (file == NULL || path == NULL || _tinydir_strlen(path) == 0) + { + errno = EINVAL; + return -1; + } + if (_tinydir_strlen(path) + _TINYDIR_PATH_EXTRA >= _TINYDIR_PATH_MAX) + { + errno = ENAMETOOLONG; + return -1; + } + + /* Get the parent path */ +#if (defined _MSC_VER || defined __MINGW32__) +#if ((defined _MSC_VER) && (_MSC_VER >= 1400)) + _tsplitpath_s( + path, + drive_buf, _TINYDIR_DRIVE_MAX, + dir_name_buf, _TINYDIR_FILENAME_MAX, + file_name_buf, _TINYDIR_FILENAME_MAX, + ext_buf, _TINYDIR_FILENAME_MAX); +#else + _tsplitpath( + path, + drive_buf, + dir_name_buf, + file_name_buf, + ext_buf); +#endif + +/* _splitpath_s not work fine with only filename and widechar support */ +#ifdef _UNICODE + if (drive_buf[0] == L'\xFEFE') + drive_buf[0] = '\0'; + if (dir_name_buf[0] == L'\xFEFE') + dir_name_buf[0] = '\0'; +#endif + + if (errno) + { + errno = EINVAL; + return -1; + } + /* Emulate the behavior of dirname by returning "." for dir name if it's + empty */ + if (drive_buf[0] == '\0' && dir_name_buf[0] == '\0') + { + _tinydir_strcpy(dir_name_buf, TINYDIR_STRING(".")); + } + /* Concatenate the drive letter and dir name to form full dir name */ + _tinydir_strcat(drive_buf, dir_name_buf); + dir_name = drive_buf; + /* Concatenate the file name and extension to form base name */ + _tinydir_strcat(file_name_buf, ext_buf); + base_name = file_name_buf; +#else + _tinydir_strcpy(dir_name_buf, path); + dir_name = dirname(dir_name_buf); + _tinydir_strcpy(file_name_buf, path); + base_name =basename(file_name_buf); +#endif + + /* Open the parent directory */ + if (tinydir_open(&dir, dir_name) == -1) + { + return -1; + } + + /* Read through the parent directory and look for the file */ + while (dir.has_next) + { + if (tinydir_readfile(&dir, file) == -1) + { + result = -1; + goto bail; + } + if (_tinydir_strcmp(file->name, base_name) == 0) + { + /* File found */ + found = 1; + break; + } + tinydir_next(&dir); + } + if (!found) + { + result = -1; + errno = ENOENT; + } + +bail: + tinydir_close(&dir); + return result; +} + +_TINYDIR_FUNC +void _tinydir_get_ext(tinydir_file *file) +{ + _tinydir_char_t *period = _tinydir_strrchr(file->name, TINYDIR_STRING('.')); + if (period == NULL) + { + file->extension = &(file->name[_tinydir_strlen(file->name)]); + } + else + { + file->extension = period + 1; + } +} + +_TINYDIR_FUNC +int _tinydir_file_cmp(const void *a, const void *b) +{ + const tinydir_file *fa = (const tinydir_file *)a; + const tinydir_file *fb = (const tinydir_file *)b; + if (fa->is_dir != fb->is_dir) + { + return -(fa->is_dir - fb->is_dir); + } + return _tinydir_strncmp(fa->name, fb->name, _TINYDIR_FILENAME_MAX); +} + +#ifndef _MSC_VER +#ifndef _TINYDIR_USE_READDIR +/* +The following authored by Ben Hutchings +from https://womble.decadent.org.uk/readdir_r-advisory.html +*/ +/* Calculate the required buffer size (in bytes) for directory * +* entries read from the given directory handle. Return -1 if this * +* this cannot be done. * +* * +* This code does not trust values of NAME_MAX that are less than * +* 255, since some systems (including at least HP-UX) incorrectly * +* define it to be a smaller value. */ +_TINYDIR_FUNC +size_t _tinydir_dirent_buf_size(_TINYDIR_DIR *dirp) +{ + long name_max; + size_t name_end; + /* parameter may be unused */ + (void)dirp; + +#if defined _TINYDIR_USE_FPATHCONF + name_max = fpathconf(dirfd(dirp), _PC_NAME_MAX); + if (name_max == -1) +#if defined(NAME_MAX) + name_max = (NAME_MAX > 255) ? NAME_MAX : 255; +#else + return (size_t)(-1); +#endif +#elif defined(NAME_MAX) + name_max = (NAME_MAX > 255) ? NAME_MAX : 255; +#else +#error "buffer size for readdir_r cannot be determined" +#endif + name_end = (size_t)offsetof(struct _tinydir_dirent, d_name) + name_max + 1; + return (name_end > sizeof(struct _tinydir_dirent) ? + name_end : sizeof(struct _tinydir_dirent)); +} +#endif +#endif + +#ifdef __cplusplus +} +#endif + +# if defined (_MSC_VER) +# pragma warning(pop) +# endif + +#endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/lwiperf/lwiperf.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/lwiperf/lwiperf.c index ec2c9bb9..dbec4dae 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/lwiperf/lwiperf.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/lwiperf/lwiperf.c @@ -1,841 +1,841 @@ -/** - * @file - * lwIP iPerf server implementation - */ - -/** - * @defgroup iperf Iperf server - * @ingroup apps - * - * This is a simple performance measuring client/server to check your bandwith using - * iPerf2 on a PC as server/client. - * It is currently a minimal implementation providing a TCP client/server only. - * - * @todo: - * - implement UDP mode - * - protect combined sessions handling (via 'related_master_state') against reallocation - * (this is a pointer address, currently, so if the same memory is allocated again, - * session pairs (tx/rx) can be confused on reallocation) - */ - -/* - * Copyright (c) 2014 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - */ - -#include "lwip/apps/lwiperf.h" - -#include "lwip/tcp.h" -#include "lwip/sys.h" - -#include - -/* Currently, only TCP is implemented */ -#if LWIP_TCP && LWIP_CALLBACK_API - -/** Specify the idle timeout (in seconds) after that the test fails */ -#ifndef LWIPERF_TCP_MAX_IDLE_SEC -#define LWIPERF_TCP_MAX_IDLE_SEC 10U -#endif -#if LWIPERF_TCP_MAX_IDLE_SEC > 255 -#error LWIPERF_TCP_MAX_IDLE_SEC must fit into an u8_t -#endif - -/** Change this if you don't want to lwiperf to listen to any IP version */ -#ifndef LWIPERF_SERVER_IP_TYPE -#define LWIPERF_SERVER_IP_TYPE IPADDR_TYPE_ANY -#endif - -/* File internal memory allocation (struct lwiperf_*): this defaults to - the heap */ -#ifndef LWIPERF_ALLOC -#define LWIPERF_ALLOC(type) mem_malloc(sizeof(type)) -#define LWIPERF_FREE(type, item) mem_free(item) -#endif - -/** If this is 1, check that received data has the correct format */ -#ifndef LWIPERF_CHECK_RX_DATA -#define LWIPERF_CHECK_RX_DATA 0 -#endif - -/** This is the Iperf settings struct sent from the client */ -typedef struct _lwiperf_settings { -#define LWIPERF_FLAGS_ANSWER_TEST 0x80000000 -#define LWIPERF_FLAGS_ANSWER_NOW 0x00000001 - u32_t flags; - u32_t num_threads; /* unused for now */ - u32_t remote_port; - u32_t buffer_len; /* unused for now */ - u32_t win_band; /* TCP window / UDP rate: unused for now */ - u32_t amount; /* pos. value: bytes?; neg. values: time (unit is 10ms: 1/100 second) */ -} lwiperf_settings_t; - -/** Basic connection handle */ -struct _lwiperf_state_base; -typedef struct _lwiperf_state_base lwiperf_state_base_t; -struct _lwiperf_state_base { - /* linked list */ - lwiperf_state_base_t *next; - /* 1=tcp, 0=udp */ - u8_t tcp; - /* 1=server, 0=client */ - u8_t server; - /* master state used to abort sessions (e.g. listener, main client) */ - lwiperf_state_base_t *related_master_state; -}; - -/** Connection handle for a TCP iperf session */ -typedef struct _lwiperf_state_tcp { - lwiperf_state_base_t base; - struct tcp_pcb *server_pcb; - struct tcp_pcb *conn_pcb; - u32_t time_started; - lwiperf_report_fn report_fn; - void *report_arg; - u8_t poll_count; - u8_t next_num; - /* 1=start server when client is closed */ - u8_t client_tradeoff_mode; - u32_t bytes_transferred; - lwiperf_settings_t settings; - u8_t have_settings_buf; - u8_t specific_remote; - ip_addr_t remote_addr; -} lwiperf_state_tcp_t; - -/** List of active iperf sessions */ -static lwiperf_state_base_t *lwiperf_all_connections; -/** A const buffer to send from: we want to measure sending, not copying! */ -static const u8_t lwiperf_txbuf_const[1600] = { - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', -}; - -static err_t lwiperf_tcp_poll(void *arg, struct tcp_pcb *tpcb); -static void lwiperf_tcp_err(void *arg, err_t err); -static err_t lwiperf_start_tcp_server_impl(const ip_addr_t *local_addr, u16_t local_port, - lwiperf_report_fn report_fn, void *report_arg, - lwiperf_state_base_t *related_master_state, lwiperf_state_tcp_t **state); - - -/** Add an iperf session to the 'active' list */ -static void -lwiperf_list_add(lwiperf_state_base_t *item) -{ - item->next = lwiperf_all_connections; - lwiperf_all_connections = item; -} - -/** Remove an iperf session from the 'active' list */ -static void -lwiperf_list_remove(lwiperf_state_base_t *item) -{ - lwiperf_state_base_t *prev = NULL; - lwiperf_state_base_t *iter; - for (iter = lwiperf_all_connections; iter != NULL; prev = iter, iter = iter->next) { - if (iter == item) { - if (prev == NULL) { - lwiperf_all_connections = iter->next; - } else { - prev->next = iter->next; - } - /* @debug: ensure this item is listed only once */ - for (iter = iter->next; iter != NULL; iter = iter->next) { - LWIP_ASSERT("duplicate entry", iter != item); - } - break; - } - } -} - -static lwiperf_state_base_t * -lwiperf_list_find(lwiperf_state_base_t *item) -{ - lwiperf_state_base_t *iter; - for (iter = lwiperf_all_connections; iter != NULL; iter = iter->next) { - if (iter == item) { - return item; - } - } - return NULL; -} - -/** Call the report function of an iperf tcp session */ -static void -lwip_tcp_conn_report(lwiperf_state_tcp_t *conn, enum lwiperf_report_type report_type) -{ - if ((conn != NULL) && (conn->report_fn != NULL)) { - u32_t now, duration_ms, bandwidth_kbitpsec; - now = sys_now(); - duration_ms = now - conn->time_started; - if (duration_ms == 0) { - bandwidth_kbitpsec = 0; - } else { - bandwidth_kbitpsec = (conn->bytes_transferred / duration_ms) * 8U; - } - conn->report_fn(conn->report_arg, report_type, - &conn->conn_pcb->local_ip, conn->conn_pcb->local_port, - &conn->conn_pcb->remote_ip, conn->conn_pcb->remote_port, - conn->bytes_transferred, duration_ms, bandwidth_kbitpsec); - } -} - -/** Close an iperf tcp session */ -static void -lwiperf_tcp_close(lwiperf_state_tcp_t *conn, enum lwiperf_report_type report_type) -{ - err_t err; - - lwiperf_list_remove(&conn->base); - lwip_tcp_conn_report(conn, report_type); - if (conn->conn_pcb != NULL) { - tcp_arg(conn->conn_pcb, NULL); - tcp_poll(conn->conn_pcb, NULL, 0); - tcp_sent(conn->conn_pcb, NULL); - tcp_recv(conn->conn_pcb, NULL); - tcp_err(conn->conn_pcb, NULL); - err = tcp_close(conn->conn_pcb); - if (err != ERR_OK) { - /* don't want to wait for free memory here... */ - tcp_abort(conn->conn_pcb); - } - } else { - /* no conn pcb, this is the listener pcb */ - err = tcp_close(conn->server_pcb); - LWIP_ASSERT("error", err == ERR_OK); - } - LWIPERF_FREE(lwiperf_state_tcp_t, conn); -} - -/** Try to send more data on an iperf tcp session */ -static err_t -lwiperf_tcp_client_send_more(lwiperf_state_tcp_t *conn) -{ - int send_more; - err_t err; - u16_t txlen; - u16_t txlen_max; - void *txptr; - u8_t apiflags; - - LWIP_ASSERT("conn invalid", (conn != NULL) && conn->base.tcp && (conn->base.server == 0)); - - do { - send_more = 0; - if (conn->settings.amount & PP_HTONL(0x80000000)) { - /* this session is time-limited */ - u32_t now = sys_now(); - u32_t diff_ms = now - conn->time_started; - u32_t time = (u32_t) - (s32_t)lwip_htonl(conn->settings.amount); - u32_t time_ms = time * 10; - if (diff_ms >= time_ms) { - /* time specified by the client is over -> close the connection */ - lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_CLIENT); - return ERR_OK; - } - } else { - /* this session is byte-limited */ - u32_t amount_bytes = lwip_htonl(conn->settings.amount); - /* @todo: this can send up to 1*MSS more than requested... */ - if (amount_bytes >= conn->bytes_transferred) { - /* all requested bytes transferred -> close the connection */ - lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_CLIENT); - return ERR_OK; - } - } - - if (conn->bytes_transferred < 24) { - /* transmit the settings a first time */ - txptr = &((u8_t *)&conn->settings)[conn->bytes_transferred]; - txlen_max = (u16_t)(24 - conn->bytes_transferred); - apiflags = TCP_WRITE_FLAG_COPY; - } else if (conn->bytes_transferred < 48) { - /* transmit the settings a second time */ - txptr = &((u8_t *)&conn->settings)[conn->bytes_transferred - 24]; - txlen_max = (u16_t)(48 - conn->bytes_transferred); - apiflags = TCP_WRITE_FLAG_COPY | TCP_WRITE_FLAG_MORE; - send_more = 1; - } else { - /* transmit data */ - /* @todo: every x bytes, transmit the settings again */ - txptr = LWIP_CONST_CAST(void *, &lwiperf_txbuf_const[conn->bytes_transferred % 10]); - txlen_max = TCP_MSS; - if (conn->bytes_transferred == 48) { /* @todo: fix this for intermediate settings, too */ - txlen_max = TCP_MSS - 24; - } - apiflags = 0; /* no copying needed */ - send_more = 1; - } - txlen = txlen_max; - do { - err = tcp_write(conn->conn_pcb, txptr, txlen, apiflags); - if (err == ERR_MEM) { - txlen /= 2; - } - } while ((err == ERR_MEM) && (txlen >= (TCP_MSS / 2))); - - if (err == ERR_OK) { - conn->bytes_transferred += txlen; - } else { - send_more = 0; - } - } while (send_more); - - tcp_output(conn->conn_pcb); - return ERR_OK; -} - -/** TCP sent callback, try to send more data */ -static err_t -lwiperf_tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) -{ - lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; - /* @todo: check 'len' (e.g. to time ACK of all data)? for now, we just send more... */ - LWIP_ASSERT("invalid conn", conn->conn_pcb == tpcb); - LWIP_UNUSED_ARG(tpcb); - LWIP_UNUSED_ARG(len); - - conn->poll_count = 0; - - return lwiperf_tcp_client_send_more(conn); -} - -/** TCP connected callback (active connection), send data now */ -static err_t -lwiperf_tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err) -{ - lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; - LWIP_ASSERT("invalid conn", conn->conn_pcb == tpcb); - LWIP_UNUSED_ARG(tpcb); - if (err != ERR_OK) { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE); - return ERR_OK; - } - conn->poll_count = 0; - conn->time_started = sys_now(); - return lwiperf_tcp_client_send_more(conn); -} - -/** Start TCP connection back to the client (either parallel or after the - * receive test has finished. - */ -static err_t -lwiperf_tx_start_impl(const ip_addr_t *remote_ip, u16_t remote_port, lwiperf_settings_t *settings, lwiperf_report_fn report_fn, - void *report_arg, lwiperf_state_base_t *related_master_state, lwiperf_state_tcp_t **new_conn) -{ - err_t err; - lwiperf_state_tcp_t *client_conn; - struct tcp_pcb *newpcb; - ip_addr_t remote_addr; - - LWIP_ASSERT("remote_ip != NULL", remote_ip != NULL); - LWIP_ASSERT("remote_ip != NULL", settings != NULL); - LWIP_ASSERT("new_conn != NULL", new_conn != NULL); - *new_conn = NULL; - - client_conn = (lwiperf_state_tcp_t *)LWIPERF_ALLOC(lwiperf_state_tcp_t); - if (client_conn == NULL) { - return ERR_MEM; - } - newpcb = tcp_new_ip_type(IP_GET_TYPE(remote_ip)); - if (newpcb == NULL) { - LWIPERF_FREE(lwiperf_state_tcp_t, client_conn); - return ERR_MEM; - } - memset(client_conn, 0, sizeof(lwiperf_state_tcp_t)); - client_conn->base.tcp = 1; - client_conn->base.related_master_state = related_master_state; - client_conn->conn_pcb = newpcb; - client_conn->time_started = sys_now(); /* @todo: set this again on 'connected' */ - client_conn->report_fn = report_fn; - client_conn->report_arg = report_arg; - client_conn->next_num = 4; /* initial nr is '4' since the header has 24 byte */ - client_conn->bytes_transferred = 0; - memcpy(&client_conn->settings, settings, sizeof(*settings)); - client_conn->have_settings_buf = 1; - - tcp_arg(newpcb, client_conn); - tcp_sent(newpcb, lwiperf_tcp_client_sent); - tcp_poll(newpcb, lwiperf_tcp_poll, 2U); - tcp_err(newpcb, lwiperf_tcp_err); - - ip_addr_copy(remote_addr, *remote_ip); - - err = tcp_connect(newpcb, &remote_addr, remote_port, lwiperf_tcp_client_connected); - if (err != ERR_OK) { - lwiperf_tcp_close(client_conn, LWIPERF_TCP_ABORTED_LOCAL); - return err; - } - lwiperf_list_add(&client_conn->base); - *new_conn = client_conn; - return ERR_OK; -} - -static err_t -lwiperf_tx_start_passive(lwiperf_state_tcp_t *conn) -{ - err_t ret; - lwiperf_state_tcp_t *new_conn = NULL; - u16_t remote_port = (u16_t)lwip_htonl(conn->settings.remote_port); - - ret = lwiperf_tx_start_impl(&conn->conn_pcb->remote_ip, remote_port, &conn->settings, conn->report_fn, conn->report_arg, - conn->base.related_master_state, &new_conn); - if (ret == ERR_OK) { - LWIP_ASSERT("new_conn != NULL", new_conn != NULL); - new_conn->settings.flags = 0; /* prevent the remote side starting back as client again */ - } - return ret; -} - -/** Receive data on an iperf tcp session */ -static err_t -lwiperf_tcp_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) -{ - u8_t tmp; - u16_t tot_len; - u32_t packet_idx; - struct pbuf *q; - lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; - - LWIP_ASSERT("pcb mismatch", conn->conn_pcb == tpcb); - LWIP_UNUSED_ARG(tpcb); - - if (err != ERR_OK) { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE); - return ERR_OK; - } - if (p == NULL) { - /* connection closed -> test done */ - if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST)) { - if ((conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_NOW)) == 0) { - /* client requested transmission after end of test */ - lwiperf_tx_start_passive(conn); - } - } - lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_SERVER); - return ERR_OK; - } - tot_len = p->tot_len; - - conn->poll_count = 0; - - if ((!conn->have_settings_buf) || ((conn->bytes_transferred - 24) % (1024 * 128) == 0)) { - /* wait for 24-byte header */ - if (p->tot_len < sizeof(lwiperf_settings_t)) { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR); - pbuf_free(p); - return ERR_OK; - } - if (!conn->have_settings_buf) { - if (pbuf_copy_partial(p, &conn->settings, sizeof(lwiperf_settings_t), 0) != sizeof(lwiperf_settings_t)) { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL); - pbuf_free(p); - return ERR_OK; - } - conn->have_settings_buf = 1; - if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST)) { - if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_NOW)) { - /* client requested parallel transmission test */ - err_t err2 = lwiperf_tx_start_passive(conn); - if (err2 != ERR_OK) { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_TXERROR); - pbuf_free(p); - return ERR_OK; - } - } - } - } else { - if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST)) { - if (pbuf_memcmp(p, 0, &conn->settings, sizeof(lwiperf_settings_t)) != 0) { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR); - pbuf_free(p); - return ERR_OK; - } - } - } - conn->bytes_transferred += sizeof(lwiperf_settings_t); - if (conn->bytes_transferred <= 24) { - conn->time_started = sys_now(); - tcp_recved(tpcb, p->tot_len); - pbuf_free(p); - return ERR_OK; - } - conn->next_num = 4; /* 24 bytes received... */ - tmp = pbuf_remove_header(p, 24); - LWIP_ASSERT("pbuf_remove_header failed", tmp == 0); - LWIP_UNUSED_ARG(tmp); /* for LWIP_NOASSERT */ - } - - packet_idx = 0; - for (q = p; q != NULL; q = q->next) { -#if LWIPERF_CHECK_RX_DATA - const u8_t *payload = (const u8_t *)q->payload; - u16_t i; - for (i = 0; i < q->len; i++) { - u8_t val = payload[i]; - u8_t num = val - '0'; - if (num == conn->next_num) { - conn->next_num++; - if (conn->next_num == 10) { - conn->next_num = 0; - } - } else { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR); - pbuf_free(p); - return ERR_OK; - } - } -#endif - packet_idx += q->len; - } - LWIP_ASSERT("count mismatch", packet_idx == p->tot_len); - conn->bytes_transferred += packet_idx; - tcp_recved(tpcb, tot_len); - pbuf_free(p); - return ERR_OK; -} - -/** Error callback, iperf tcp session aborted */ -static void -lwiperf_tcp_err(void *arg, err_t err) -{ - lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; - LWIP_UNUSED_ARG(err); - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE); -} - -/** TCP poll callback, try to send more data */ -static err_t -lwiperf_tcp_poll(void *arg, struct tcp_pcb *tpcb) -{ - lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; - LWIP_ASSERT("pcb mismatch", conn->conn_pcb == tpcb); - LWIP_UNUSED_ARG(tpcb); - if (++conn->poll_count >= LWIPERF_TCP_MAX_IDLE_SEC) { - lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL); - return ERR_OK; /* lwiperf_tcp_close frees conn */ - } - - if (!conn->base.server) { - lwiperf_tcp_client_send_more(conn); - } - - return ERR_OK; -} - -/** This is called when a new client connects for an iperf tcp session */ -static err_t -lwiperf_tcp_accept(void *arg, struct tcp_pcb *newpcb, err_t err) -{ - lwiperf_state_tcp_t *s, *conn; - if ((err != ERR_OK) || (newpcb == NULL) || (arg == NULL)) { - return ERR_VAL; - } - - s = (lwiperf_state_tcp_t *)arg; - LWIP_ASSERT("invalid session", s->base.server); - LWIP_ASSERT("invalid listen pcb", s->server_pcb != NULL); - LWIP_ASSERT("invalid conn pcb", s->conn_pcb == NULL); - if (s->specific_remote) { - LWIP_ASSERT("s->base.related_master_state != NULL", s->base.related_master_state != NULL); - if (!ip_addr_cmp(&newpcb->remote_ip, &s->remote_addr)) { - /* this listener belongs to a client session, and this is not the correct remote */ - return ERR_VAL; - } - } else { - LWIP_ASSERT("s->base.related_master_state == NULL", s->base.related_master_state == NULL); - } - - conn = (lwiperf_state_tcp_t *)LWIPERF_ALLOC(lwiperf_state_tcp_t); - if (conn == NULL) { - return ERR_MEM; - } - memset(conn, 0, sizeof(lwiperf_state_tcp_t)); - conn->base.tcp = 1; - conn->base.server = 1; - conn->base.related_master_state = &s->base; - conn->conn_pcb = newpcb; - conn->time_started = sys_now(); - conn->report_fn = s->report_fn; - conn->report_arg = s->report_arg; - - /* setup the tcp rx connection */ - tcp_arg(newpcb, conn); - tcp_recv(newpcb, lwiperf_tcp_recv); - tcp_poll(newpcb, lwiperf_tcp_poll, 2U); - tcp_err(conn->conn_pcb, lwiperf_tcp_err); - - if (s->specific_remote) { - /* this listener belongs to a client, so make the client the master of the newly created connection */ - conn->base.related_master_state = s->base.related_master_state; - /* if dual mode or (tradeoff mode AND client is done): close the listener */ - if (!s->client_tradeoff_mode || !lwiperf_list_find(s->base.related_master_state)) { - /* prevent report when closing: this is expected */ - s->report_fn = NULL; - lwiperf_tcp_close(s, LWIPERF_TCP_ABORTED_LOCAL); - } - } - lwiperf_list_add(&conn->base); - return ERR_OK; -} - -/** - * @ingroup iperf - * Start a TCP iperf server on the default TCP port (5001) and listen for - * incoming connections from iperf clients. - * - * @returns a connection handle that can be used to abort the server - * by calling @ref lwiperf_abort() - */ -void * -lwiperf_start_tcp_server_default(lwiperf_report_fn report_fn, void *report_arg) -{ - return lwiperf_start_tcp_server(IP_ADDR_ANY, LWIPERF_TCP_PORT_DEFAULT, - report_fn, report_arg); -} - -/** - * @ingroup iperf - * Start a TCP iperf server on a specific IP address and port and listen for - * incoming connections from iperf clients. - * - * @returns a connection handle that can be used to abort the server - * by calling @ref lwiperf_abort() - */ -void * -lwiperf_start_tcp_server(const ip_addr_t *local_addr, u16_t local_port, - lwiperf_report_fn report_fn, void *report_arg) -{ - err_t err; - lwiperf_state_tcp_t *state = NULL; - - err = lwiperf_start_tcp_server_impl(local_addr, local_port, report_fn, report_arg, - NULL, &state); - if (err == ERR_OK) { - return state; - } - return NULL; -} - -static err_t lwiperf_start_tcp_server_impl(const ip_addr_t *local_addr, u16_t local_port, - lwiperf_report_fn report_fn, void *report_arg, - lwiperf_state_base_t *related_master_state, lwiperf_state_tcp_t **state) -{ - err_t err; - struct tcp_pcb *pcb; - lwiperf_state_tcp_t *s; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("state != NULL", state != NULL); - - if (local_addr == NULL) { - return ERR_ARG; - } - - s = (lwiperf_state_tcp_t *)LWIPERF_ALLOC(lwiperf_state_tcp_t); - if (s == NULL) { - return ERR_MEM; - } - memset(s, 0, sizeof(lwiperf_state_tcp_t)); - s->base.tcp = 1; - s->base.server = 1; - s->base.related_master_state = related_master_state; - s->report_fn = report_fn; - s->report_arg = report_arg; - - pcb = tcp_new_ip_type(LWIPERF_SERVER_IP_TYPE); - if (pcb == NULL) { - return ERR_MEM; - } - err = tcp_bind(pcb, local_addr, local_port); - if (err != ERR_OK) { - return err; - } - s->server_pcb = tcp_listen_with_backlog(pcb, 1); - if (s->server_pcb == NULL) { - if (pcb != NULL) { - tcp_close(pcb); - } - LWIPERF_FREE(lwiperf_state_tcp_t, s); - return ERR_MEM; - } - pcb = NULL; - - tcp_arg(s->server_pcb, s); - tcp_accept(s->server_pcb, lwiperf_tcp_accept); - - lwiperf_list_add(&s->base); - *state = s; - return ERR_OK; -} - -/** - * @ingroup iperf - * Start a TCP iperf client to the default TCP port (5001). - * - * @returns a connection handle that can be used to abort the client - * by calling @ref lwiperf_abort() - */ -void* lwiperf_start_tcp_client_default(const ip_addr_t* remote_addr, - lwiperf_report_fn report_fn, void* report_arg) -{ - return lwiperf_start_tcp_client(remote_addr, LWIPERF_TCP_PORT_DEFAULT, LWIPERF_CLIENT, - report_fn, report_arg); -} - -/** - * @ingroup iperf - * Start a TCP iperf client to a specific IP address and port. - * - * @returns a connection handle that can be used to abort the client - * by calling @ref lwiperf_abort() - */ -void* lwiperf_start_tcp_client(const ip_addr_t* remote_addr, u16_t remote_port, - enum lwiperf_client_type type, lwiperf_report_fn report_fn, void* report_arg) -{ - err_t ret; - lwiperf_settings_t settings; - lwiperf_state_tcp_t *state = NULL; - - memset(&settings, 0, sizeof(settings)); - switch (type) { - case LWIPERF_CLIENT: - /* Unidirectional tx only test */ - settings.flags = 0; - break; - case LWIPERF_DUAL: - /* Do a bidirectional test simultaneously */ - settings.flags = htonl(LWIPERF_FLAGS_ANSWER_TEST | LWIPERF_FLAGS_ANSWER_NOW); - break; - case LWIPERF_TRADEOFF: - /* Do a bidirectional test individually */ - settings.flags = htonl(LWIPERF_FLAGS_ANSWER_TEST); - break; - default: - /* invalid argument */ - return NULL; - } - settings.num_threads = htonl(1); - settings.remote_port = htonl(LWIPERF_TCP_PORT_DEFAULT); - /* TODO: implement passing duration/amount of bytes to transfer */ - settings.amount = htonl((u32_t)-1000); - - ret = lwiperf_tx_start_impl(remote_addr, remote_port, &settings, report_fn, report_arg, NULL, &state); - if (ret == ERR_OK) { - LWIP_ASSERT("state != NULL", state != NULL); - if (type != LWIPERF_CLIENT) { - /* start corresponding server now */ - lwiperf_state_tcp_t *server = NULL; - ret = lwiperf_start_tcp_server_impl(&state->conn_pcb->local_ip, LWIPERF_TCP_PORT_DEFAULT, - report_fn, report_arg, (lwiperf_state_base_t *)state, &server); - if (ret != ERR_OK) { - /* starting server failed, abort client */ - lwiperf_abort(state); - return NULL; - } - /* make this server accept one connection only */ - server->specific_remote = 1; - server->remote_addr = state->conn_pcb->remote_ip; - if (type == LWIPERF_TRADEOFF) { - /* tradeoff means that the remote host connects only after the client is done, - so keep the listen pcb open until the client is done */ - server->client_tradeoff_mode = 1; - } - } - return state; - } - return NULL; -} - -/** - * @ingroup iperf - * Abort an iperf session (handle returned by lwiperf_start_tcp_server*()) - */ -void -lwiperf_abort(void *lwiperf_session) -{ - lwiperf_state_base_t *i, *dealloc, *last = NULL; - - LWIP_ASSERT_CORE_LOCKED(); - - for (i = lwiperf_all_connections; i != NULL; ) { - if ((i == lwiperf_session) || (i->related_master_state == lwiperf_session)) { - dealloc = i; - i = i->next; - if (last != NULL) { - last->next = i; - } - LWIPERF_FREE(lwiperf_state_tcp_t, dealloc); /* @todo: type? */ - } else { - last = i; - i = i->next; - } - } -} - -#endif /* LWIP_TCP && LWIP_CALLBACK_API */ +/** + * @file + * lwIP iPerf server implementation + */ + +/** + * @defgroup iperf Iperf server + * @ingroup apps + * + * This is a simple performance measuring client/server to check your bandwith using + * iPerf2 on a PC as server/client. + * It is currently a minimal implementation providing a TCP client/server only. + * + * @todo: + * - implement UDP mode + * - protect combined sessions handling (via 'related_master_state') against reallocation + * (this is a pointer address, currently, so if the same memory is allocated again, + * session pairs (tx/rx) can be confused on reallocation) + */ + +/* + * Copyright (c) 2014 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + */ + +#include "lwip/apps/lwiperf.h" + +#include "lwip/tcp.h" +#include "lwip/sys.h" + +#include + +/* Currently, only TCP is implemented */ +#if LWIP_TCP && LWIP_CALLBACK_API + +/** Specify the idle timeout (in seconds) after that the test fails */ +#ifndef LWIPERF_TCP_MAX_IDLE_SEC +#define LWIPERF_TCP_MAX_IDLE_SEC 10U +#endif +#if LWIPERF_TCP_MAX_IDLE_SEC > 255 +#error LWIPERF_TCP_MAX_IDLE_SEC must fit into an u8_t +#endif + +/** Change this if you don't want to lwiperf to listen to any IP version */ +#ifndef LWIPERF_SERVER_IP_TYPE +#define LWIPERF_SERVER_IP_TYPE IPADDR_TYPE_ANY +#endif + +/* File internal memory allocation (struct lwiperf_*): this defaults to + the heap */ +#ifndef LWIPERF_ALLOC +#define LWIPERF_ALLOC(type) mem_malloc(sizeof(type)) +#define LWIPERF_FREE(type, item) mem_free(item) +#endif + +/** If this is 1, check that received data has the correct format */ +#ifndef LWIPERF_CHECK_RX_DATA +#define LWIPERF_CHECK_RX_DATA 0 +#endif + +/** This is the Iperf settings struct sent from the client */ +typedef struct _lwiperf_settings { +#define LWIPERF_FLAGS_ANSWER_TEST 0x80000000 +#define LWIPERF_FLAGS_ANSWER_NOW 0x00000001 + u32_t flags; + u32_t num_threads; /* unused for now */ + u32_t remote_port; + u32_t buffer_len; /* unused for now */ + u32_t win_band; /* TCP window / UDP rate: unused for now */ + u32_t amount; /* pos. value: bytes?; neg. values: time (unit is 10ms: 1/100 second) */ +} lwiperf_settings_t; + +/** Basic connection handle */ +struct _lwiperf_state_base; +typedef struct _lwiperf_state_base lwiperf_state_base_t; +struct _lwiperf_state_base { + /* linked list */ + lwiperf_state_base_t *next; + /* 1=tcp, 0=udp */ + u8_t tcp; + /* 1=server, 0=client */ + u8_t server; + /* master state used to abort sessions (e.g. listener, main client) */ + lwiperf_state_base_t *related_master_state; +}; + +/** Connection handle for a TCP iperf session */ +typedef struct _lwiperf_state_tcp { + lwiperf_state_base_t base; + struct tcp_pcb *server_pcb; + struct tcp_pcb *conn_pcb; + u32_t time_started; + lwiperf_report_fn report_fn; + void *report_arg; + u8_t poll_count; + u8_t next_num; + /* 1=start server when client is closed */ + u8_t client_tradeoff_mode; + u32_t bytes_transferred; + lwiperf_settings_t settings; + u8_t have_settings_buf; + u8_t specific_remote; + ip_addr_t remote_addr; +} lwiperf_state_tcp_t; + +/** List of active iperf sessions */ +static lwiperf_state_base_t *lwiperf_all_connections; +/** A const buffer to send from: we want to measure sending, not copying! */ +static const u8_t lwiperf_txbuf_const[1600] = { + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', +}; + +static err_t lwiperf_tcp_poll(void *arg, struct tcp_pcb *tpcb); +static void lwiperf_tcp_err(void *arg, err_t err); +static err_t lwiperf_start_tcp_server_impl(const ip_addr_t *local_addr, u16_t local_port, + lwiperf_report_fn report_fn, void *report_arg, + lwiperf_state_base_t *related_master_state, lwiperf_state_tcp_t **state); + + +/** Add an iperf session to the 'active' list */ +static void +lwiperf_list_add(lwiperf_state_base_t *item) +{ + item->next = lwiperf_all_connections; + lwiperf_all_connections = item; +} + +/** Remove an iperf session from the 'active' list */ +static void +lwiperf_list_remove(lwiperf_state_base_t *item) +{ + lwiperf_state_base_t *prev = NULL; + lwiperf_state_base_t *iter; + for (iter = lwiperf_all_connections; iter != NULL; prev = iter, iter = iter->next) { + if (iter == item) { + if (prev == NULL) { + lwiperf_all_connections = iter->next; + } else { + prev->next = iter->next; + } + /* @debug: ensure this item is listed only once */ + for (iter = iter->next; iter != NULL; iter = iter->next) { + LWIP_ASSERT("duplicate entry", iter != item); + } + break; + } + } +} + +static lwiperf_state_base_t * +lwiperf_list_find(lwiperf_state_base_t *item) +{ + lwiperf_state_base_t *iter; + for (iter = lwiperf_all_connections; iter != NULL; iter = iter->next) { + if (iter == item) { + return item; + } + } + return NULL; +} + +/** Call the report function of an iperf tcp session */ +static void +lwip_tcp_conn_report(lwiperf_state_tcp_t *conn, enum lwiperf_report_type report_type) +{ + if ((conn != NULL) && (conn->report_fn != NULL)) { + u32_t now, duration_ms, bandwidth_kbitpsec; + now = sys_now(); + duration_ms = now - conn->time_started; + if (duration_ms == 0) { + bandwidth_kbitpsec = 0; + } else { + bandwidth_kbitpsec = (conn->bytes_transferred / duration_ms) * 8U; + } + conn->report_fn(conn->report_arg, report_type, + &conn->conn_pcb->local_ip, conn->conn_pcb->local_port, + &conn->conn_pcb->remote_ip, conn->conn_pcb->remote_port, + conn->bytes_transferred, duration_ms, bandwidth_kbitpsec); + } +} + +/** Close an iperf tcp session */ +static void +lwiperf_tcp_close(lwiperf_state_tcp_t *conn, enum lwiperf_report_type report_type) +{ + err_t err; + + lwiperf_list_remove(&conn->base); + lwip_tcp_conn_report(conn, report_type); + if (conn->conn_pcb != NULL) { + tcp_arg(conn->conn_pcb, NULL); + tcp_poll(conn->conn_pcb, NULL, 0); + tcp_sent(conn->conn_pcb, NULL); + tcp_recv(conn->conn_pcb, NULL); + tcp_err(conn->conn_pcb, NULL); + err = tcp_close(conn->conn_pcb); + if (err != ERR_OK) { + /* don't want to wait for free memory here... */ + tcp_abort(conn->conn_pcb); + } + } else { + /* no conn pcb, this is the listener pcb */ + err = tcp_close(conn->server_pcb); + LWIP_ASSERT("error", err == ERR_OK); + } + LWIPERF_FREE(lwiperf_state_tcp_t, conn); +} + +/** Try to send more data on an iperf tcp session */ +static err_t +lwiperf_tcp_client_send_more(lwiperf_state_tcp_t *conn) +{ + int send_more; + err_t err; + u16_t txlen; + u16_t txlen_max; + void *txptr; + u8_t apiflags; + + LWIP_ASSERT("conn invalid", (conn != NULL) && conn->base.tcp && (conn->base.server == 0)); + + do { + send_more = 0; + if (conn->settings.amount & PP_HTONL(0x80000000)) { + /* this session is time-limited */ + u32_t now = sys_now(); + u32_t diff_ms = now - conn->time_started; + u32_t time = (u32_t) - (s32_t)lwip_htonl(conn->settings.amount); + u32_t time_ms = time * 10; + if (diff_ms >= time_ms) { + /* time specified by the client is over -> close the connection */ + lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_CLIENT); + return ERR_OK; + } + } else { + /* this session is byte-limited */ + u32_t amount_bytes = lwip_htonl(conn->settings.amount); + /* @todo: this can send up to 1*MSS more than requested... */ + if (amount_bytes >= conn->bytes_transferred) { + /* all requested bytes transferred -> close the connection */ + lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_CLIENT); + return ERR_OK; + } + } + + if (conn->bytes_transferred < 24) { + /* transmit the settings a first time */ + txptr = &((u8_t *)&conn->settings)[conn->bytes_transferred]; + txlen_max = (u16_t)(24 - conn->bytes_transferred); + apiflags = TCP_WRITE_FLAG_COPY; + } else if (conn->bytes_transferred < 48) { + /* transmit the settings a second time */ + txptr = &((u8_t *)&conn->settings)[conn->bytes_transferred - 24]; + txlen_max = (u16_t)(48 - conn->bytes_transferred); + apiflags = TCP_WRITE_FLAG_COPY | TCP_WRITE_FLAG_MORE; + send_more = 1; + } else { + /* transmit data */ + /* @todo: every x bytes, transmit the settings again */ + txptr = LWIP_CONST_CAST(void *, &lwiperf_txbuf_const[conn->bytes_transferred % 10]); + txlen_max = TCP_MSS; + if (conn->bytes_transferred == 48) { /* @todo: fix this for intermediate settings, too */ + txlen_max = TCP_MSS - 24; + } + apiflags = 0; /* no copying needed */ + send_more = 1; + } + txlen = txlen_max; + do { + err = tcp_write(conn->conn_pcb, txptr, txlen, apiflags); + if (err == ERR_MEM) { + txlen /= 2; + } + } while ((err == ERR_MEM) && (txlen >= (TCP_MSS / 2))); + + if (err == ERR_OK) { + conn->bytes_transferred += txlen; + } else { + send_more = 0; + } + } while (send_more); + + tcp_output(conn->conn_pcb); + return ERR_OK; +} + +/** TCP sent callback, try to send more data */ +static err_t +lwiperf_tcp_client_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) +{ + lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; + /* @todo: check 'len' (e.g. to time ACK of all data)? for now, we just send more... */ + LWIP_ASSERT("invalid conn", conn->conn_pcb == tpcb); + LWIP_UNUSED_ARG(tpcb); + LWIP_UNUSED_ARG(len); + + conn->poll_count = 0; + + return lwiperf_tcp_client_send_more(conn); +} + +/** TCP connected callback (active connection), send data now */ +static err_t +lwiperf_tcp_client_connected(void *arg, struct tcp_pcb *tpcb, err_t err) +{ + lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; + LWIP_ASSERT("invalid conn", conn->conn_pcb == tpcb); + LWIP_UNUSED_ARG(tpcb); + if (err != ERR_OK) { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE); + return ERR_OK; + } + conn->poll_count = 0; + conn->time_started = sys_now(); + return lwiperf_tcp_client_send_more(conn); +} + +/** Start TCP connection back to the client (either parallel or after the + * receive test has finished. + */ +static err_t +lwiperf_tx_start_impl(const ip_addr_t *remote_ip, u16_t remote_port, lwiperf_settings_t *settings, lwiperf_report_fn report_fn, + void *report_arg, lwiperf_state_base_t *related_master_state, lwiperf_state_tcp_t **new_conn) +{ + err_t err; + lwiperf_state_tcp_t *client_conn; + struct tcp_pcb *newpcb; + ip_addr_t remote_addr; + + LWIP_ASSERT("remote_ip != NULL", remote_ip != NULL); + LWIP_ASSERT("remote_ip != NULL", settings != NULL); + LWIP_ASSERT("new_conn != NULL", new_conn != NULL); + *new_conn = NULL; + + client_conn = (lwiperf_state_tcp_t *)LWIPERF_ALLOC(lwiperf_state_tcp_t); + if (client_conn == NULL) { + return ERR_MEM; + } + newpcb = tcp_new_ip_type(IP_GET_TYPE(remote_ip)); + if (newpcb == NULL) { + LWIPERF_FREE(lwiperf_state_tcp_t, client_conn); + return ERR_MEM; + } + memset(client_conn, 0, sizeof(lwiperf_state_tcp_t)); + client_conn->base.tcp = 1; + client_conn->base.related_master_state = related_master_state; + client_conn->conn_pcb = newpcb; + client_conn->time_started = sys_now(); /* @todo: set this again on 'connected' */ + client_conn->report_fn = report_fn; + client_conn->report_arg = report_arg; + client_conn->next_num = 4; /* initial nr is '4' since the header has 24 byte */ + client_conn->bytes_transferred = 0; + memcpy(&client_conn->settings, settings, sizeof(*settings)); + client_conn->have_settings_buf = 1; + + tcp_arg(newpcb, client_conn); + tcp_sent(newpcb, lwiperf_tcp_client_sent); + tcp_poll(newpcb, lwiperf_tcp_poll, 2U); + tcp_err(newpcb, lwiperf_tcp_err); + + ip_addr_copy(remote_addr, *remote_ip); + + err = tcp_connect(newpcb, &remote_addr, remote_port, lwiperf_tcp_client_connected); + if (err != ERR_OK) { + lwiperf_tcp_close(client_conn, LWIPERF_TCP_ABORTED_LOCAL); + return err; + } + lwiperf_list_add(&client_conn->base); + *new_conn = client_conn; + return ERR_OK; +} + +static err_t +lwiperf_tx_start_passive(lwiperf_state_tcp_t *conn) +{ + err_t ret; + lwiperf_state_tcp_t *new_conn = NULL; + u16_t remote_port = (u16_t)lwip_htonl(conn->settings.remote_port); + + ret = lwiperf_tx_start_impl(&conn->conn_pcb->remote_ip, remote_port, &conn->settings, conn->report_fn, conn->report_arg, + conn->base.related_master_state, &new_conn); + if (ret == ERR_OK) { + LWIP_ASSERT("new_conn != NULL", new_conn != NULL); + new_conn->settings.flags = 0; /* prevent the remote side starting back as client again */ + } + return ret; +} + +/** Receive data on an iperf tcp session */ +static err_t +lwiperf_tcp_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) +{ + u8_t tmp; + u16_t tot_len; + u32_t packet_idx; + struct pbuf *q; + lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; + + LWIP_ASSERT("pcb mismatch", conn->conn_pcb == tpcb); + LWIP_UNUSED_ARG(tpcb); + + if (err != ERR_OK) { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE); + return ERR_OK; + } + if (p == NULL) { + /* connection closed -> test done */ + if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST)) { + if ((conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_NOW)) == 0) { + /* client requested transmission after end of test */ + lwiperf_tx_start_passive(conn); + } + } + lwiperf_tcp_close(conn, LWIPERF_TCP_DONE_SERVER); + return ERR_OK; + } + tot_len = p->tot_len; + + conn->poll_count = 0; + + if ((!conn->have_settings_buf) || ((conn->bytes_transferred - 24) % (1024 * 128) == 0)) { + /* wait for 24-byte header */ + if (p->tot_len < sizeof(lwiperf_settings_t)) { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR); + pbuf_free(p); + return ERR_OK; + } + if (!conn->have_settings_buf) { + if (pbuf_copy_partial(p, &conn->settings, sizeof(lwiperf_settings_t), 0) != sizeof(lwiperf_settings_t)) { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL); + pbuf_free(p); + return ERR_OK; + } + conn->have_settings_buf = 1; + if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST)) { + if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_NOW)) { + /* client requested parallel transmission test */ + err_t err2 = lwiperf_tx_start_passive(conn); + if (err2 != ERR_OK) { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_TXERROR); + pbuf_free(p); + return ERR_OK; + } + } + } + } else { + if (conn->settings.flags & PP_HTONL(LWIPERF_FLAGS_ANSWER_TEST)) { + if (pbuf_memcmp(p, 0, &conn->settings, sizeof(lwiperf_settings_t)) != 0) { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR); + pbuf_free(p); + return ERR_OK; + } + } + } + conn->bytes_transferred += sizeof(lwiperf_settings_t); + if (conn->bytes_transferred <= 24) { + conn->time_started = sys_now(); + tcp_recved(tpcb, p->tot_len); + pbuf_free(p); + return ERR_OK; + } + conn->next_num = 4; /* 24 bytes received... */ + tmp = pbuf_remove_header(p, 24); + LWIP_ASSERT("pbuf_remove_header failed", tmp == 0); + LWIP_UNUSED_ARG(tmp); /* for LWIP_NOASSERT */ + } + + packet_idx = 0; + for (q = p; q != NULL; q = q->next) { +#if LWIPERF_CHECK_RX_DATA + const u8_t *payload = (const u8_t *)q->payload; + u16_t i; + for (i = 0; i < q->len; i++) { + u8_t val = payload[i]; + u8_t num = val - '0'; + if (num == conn->next_num) { + conn->next_num++; + if (conn->next_num == 10) { + conn->next_num = 0; + } + } else { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL_DATAERROR); + pbuf_free(p); + return ERR_OK; + } + } +#endif + packet_idx += q->len; + } + LWIP_ASSERT("count mismatch", packet_idx == p->tot_len); + conn->bytes_transferred += packet_idx; + tcp_recved(tpcb, tot_len); + pbuf_free(p); + return ERR_OK; +} + +/** Error callback, iperf tcp session aborted */ +static void +lwiperf_tcp_err(void *arg, err_t err) +{ + lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; + LWIP_UNUSED_ARG(err); + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_REMOTE); +} + +/** TCP poll callback, try to send more data */ +static err_t +lwiperf_tcp_poll(void *arg, struct tcp_pcb *tpcb) +{ + lwiperf_state_tcp_t *conn = (lwiperf_state_tcp_t *)arg; + LWIP_ASSERT("pcb mismatch", conn->conn_pcb == tpcb); + LWIP_UNUSED_ARG(tpcb); + if (++conn->poll_count >= LWIPERF_TCP_MAX_IDLE_SEC) { + lwiperf_tcp_close(conn, LWIPERF_TCP_ABORTED_LOCAL); + return ERR_OK; /* lwiperf_tcp_close frees conn */ + } + + if (!conn->base.server) { + lwiperf_tcp_client_send_more(conn); + } + + return ERR_OK; +} + +/** This is called when a new client connects for an iperf tcp session */ +static err_t +lwiperf_tcp_accept(void *arg, struct tcp_pcb *newpcb, err_t err) +{ + lwiperf_state_tcp_t *s, *conn; + if ((err != ERR_OK) || (newpcb == NULL) || (arg == NULL)) { + return ERR_VAL; + } + + s = (lwiperf_state_tcp_t *)arg; + LWIP_ASSERT("invalid session", s->base.server); + LWIP_ASSERT("invalid listen pcb", s->server_pcb != NULL); + LWIP_ASSERT("invalid conn pcb", s->conn_pcb == NULL); + if (s->specific_remote) { + LWIP_ASSERT("s->base.related_master_state != NULL", s->base.related_master_state != NULL); + if (!ip_addr_cmp(&newpcb->remote_ip, &s->remote_addr)) { + /* this listener belongs to a client session, and this is not the correct remote */ + return ERR_VAL; + } + } else { + LWIP_ASSERT("s->base.related_master_state == NULL", s->base.related_master_state == NULL); + } + + conn = (lwiperf_state_tcp_t *)LWIPERF_ALLOC(lwiperf_state_tcp_t); + if (conn == NULL) { + return ERR_MEM; + } + memset(conn, 0, sizeof(lwiperf_state_tcp_t)); + conn->base.tcp = 1; + conn->base.server = 1; + conn->base.related_master_state = &s->base; + conn->conn_pcb = newpcb; + conn->time_started = sys_now(); + conn->report_fn = s->report_fn; + conn->report_arg = s->report_arg; + + /* setup the tcp rx connection */ + tcp_arg(newpcb, conn); + tcp_recv(newpcb, lwiperf_tcp_recv); + tcp_poll(newpcb, lwiperf_tcp_poll, 2U); + tcp_err(conn->conn_pcb, lwiperf_tcp_err); + + if (s->specific_remote) { + /* this listener belongs to a client, so make the client the master of the newly created connection */ + conn->base.related_master_state = s->base.related_master_state; + /* if dual mode or (tradeoff mode AND client is done): close the listener */ + if (!s->client_tradeoff_mode || !lwiperf_list_find(s->base.related_master_state)) { + /* prevent report when closing: this is expected */ + s->report_fn = NULL; + lwiperf_tcp_close(s, LWIPERF_TCP_ABORTED_LOCAL); + } + } + lwiperf_list_add(&conn->base); + return ERR_OK; +} + +/** + * @ingroup iperf + * Start a TCP iperf server on the default TCP port (5001) and listen for + * incoming connections from iperf clients. + * + * @returns a connection handle that can be used to abort the server + * by calling @ref lwiperf_abort() + */ +void * +lwiperf_start_tcp_server_default(lwiperf_report_fn report_fn, void *report_arg) +{ + return lwiperf_start_tcp_server(IP_ADDR_ANY, LWIPERF_TCP_PORT_DEFAULT, + report_fn, report_arg); +} + +/** + * @ingroup iperf + * Start a TCP iperf server on a specific IP address and port and listen for + * incoming connections from iperf clients. + * + * @returns a connection handle that can be used to abort the server + * by calling @ref lwiperf_abort() + */ +void * +lwiperf_start_tcp_server(const ip_addr_t *local_addr, u16_t local_port, + lwiperf_report_fn report_fn, void *report_arg) +{ + err_t err; + lwiperf_state_tcp_t *state = NULL; + + err = lwiperf_start_tcp_server_impl(local_addr, local_port, report_fn, report_arg, + NULL, &state); + if (err == ERR_OK) { + return state; + } + return NULL; +} + +static err_t lwiperf_start_tcp_server_impl(const ip_addr_t *local_addr, u16_t local_port, + lwiperf_report_fn report_fn, void *report_arg, + lwiperf_state_base_t *related_master_state, lwiperf_state_tcp_t **state) +{ + err_t err; + struct tcp_pcb *pcb; + lwiperf_state_tcp_t *s; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("state != NULL", state != NULL); + + if (local_addr == NULL) { + return ERR_ARG; + } + + s = (lwiperf_state_tcp_t *)LWIPERF_ALLOC(lwiperf_state_tcp_t); + if (s == NULL) { + return ERR_MEM; + } + memset(s, 0, sizeof(lwiperf_state_tcp_t)); + s->base.tcp = 1; + s->base.server = 1; + s->base.related_master_state = related_master_state; + s->report_fn = report_fn; + s->report_arg = report_arg; + + pcb = tcp_new_ip_type(LWIPERF_SERVER_IP_TYPE); + if (pcb == NULL) { + return ERR_MEM; + } + err = tcp_bind(pcb, local_addr, local_port); + if (err != ERR_OK) { + return err; + } + s->server_pcb = tcp_listen_with_backlog(pcb, 1); + if (s->server_pcb == NULL) { + if (pcb != NULL) { + tcp_close(pcb); + } + LWIPERF_FREE(lwiperf_state_tcp_t, s); + return ERR_MEM; + } + pcb = NULL; + + tcp_arg(s->server_pcb, s); + tcp_accept(s->server_pcb, lwiperf_tcp_accept); + + lwiperf_list_add(&s->base); + *state = s; + return ERR_OK; +} + +/** + * @ingroup iperf + * Start a TCP iperf client to the default TCP port (5001). + * + * @returns a connection handle that can be used to abort the client + * by calling @ref lwiperf_abort() + */ +void* lwiperf_start_tcp_client_default(const ip_addr_t* remote_addr, + lwiperf_report_fn report_fn, void* report_arg) +{ + return lwiperf_start_tcp_client(remote_addr, LWIPERF_TCP_PORT_DEFAULT, LWIPERF_CLIENT, + report_fn, report_arg); +} + +/** + * @ingroup iperf + * Start a TCP iperf client to a specific IP address and port. + * + * @returns a connection handle that can be used to abort the client + * by calling @ref lwiperf_abort() + */ +void* lwiperf_start_tcp_client(const ip_addr_t* remote_addr, u16_t remote_port, + enum lwiperf_client_type type, lwiperf_report_fn report_fn, void* report_arg) +{ + err_t ret; + lwiperf_settings_t settings; + lwiperf_state_tcp_t *state = NULL; + + memset(&settings, 0, sizeof(settings)); + switch (type) { + case LWIPERF_CLIENT: + /* Unidirectional tx only test */ + settings.flags = 0; + break; + case LWIPERF_DUAL: + /* Do a bidirectional test simultaneously */ + settings.flags = htonl(LWIPERF_FLAGS_ANSWER_TEST | LWIPERF_FLAGS_ANSWER_NOW); + break; + case LWIPERF_TRADEOFF: + /* Do a bidirectional test individually */ + settings.flags = htonl(LWIPERF_FLAGS_ANSWER_TEST); + break; + default: + /* invalid argument */ + return NULL; + } + settings.num_threads = htonl(1); + settings.remote_port = htonl(LWIPERF_TCP_PORT_DEFAULT); + /* TODO: implement passing duration/amount of bytes to transfer */ + settings.amount = htonl((u32_t)-1000); + + ret = lwiperf_tx_start_impl(remote_addr, remote_port, &settings, report_fn, report_arg, NULL, &state); + if (ret == ERR_OK) { + LWIP_ASSERT("state != NULL", state != NULL); + if (type != LWIPERF_CLIENT) { + /* start corresponding server now */ + lwiperf_state_tcp_t *server = NULL; + ret = lwiperf_start_tcp_server_impl(&state->conn_pcb->local_ip, LWIPERF_TCP_PORT_DEFAULT, + report_fn, report_arg, (lwiperf_state_base_t *)state, &server); + if (ret != ERR_OK) { + /* starting server failed, abort client */ + lwiperf_abort(state); + return NULL; + } + /* make this server accept one connection only */ + server->specific_remote = 1; + server->remote_addr = state->conn_pcb->remote_ip; + if (type == LWIPERF_TRADEOFF) { + /* tradeoff means that the remote host connects only after the client is done, + so keep the listen pcb open until the client is done */ + server->client_tradeoff_mode = 1; + } + } + return state; + } + return NULL; +} + +/** + * @ingroup iperf + * Abort an iperf session (handle returned by lwiperf_start_tcp_server*()) + */ +void +lwiperf_abort(void *lwiperf_session) +{ + lwiperf_state_base_t *i, *dealloc, *last = NULL; + + LWIP_ASSERT_CORE_LOCKED(); + + for (i = lwiperf_all_connections; i != NULL; ) { + if ((i == lwiperf_session) || (i->related_master_state == lwiperf_session)) { + dealloc = i; + i = i->next; + if (last != NULL) { + last->next = i; + } + LWIPERF_FREE(lwiperf_state_tcp_t, dealloc); /* @todo: type? */ + } else { + last = i; + i = i->next; + } + } +} + +#endif /* LWIP_TCP && LWIP_CALLBACK_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mdns/mdns.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mdns/mdns.c index 46314d25..aad27288 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mdns/mdns.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mdns/mdns.c @@ -1,2407 +1,2407 @@ -/** - * @file - * MDNS responder implementation - * - * @defgroup mdns MDNS - * @ingroup apps - * - * RFC 6762 - Multicast DNS\n - * RFC 6763 - DNS-Based Service Discovery\n - * - * @verbinclude mdns.txt - * - * Things left to implement: - * ------------------------- - * - * - Tiebreaking for simultaneous probing - * - Sending goodbye messages (zero ttl) - shutdown, DHCP lease about to expire, DHCP turned off... - * - Checking that source address of unicast requests are on the same network - * - Limiting multicast responses to 1 per second per resource record - * - Fragmenting replies if required - * - Handling multi-packet known answers - * - Individual known answer detection for all local IPv6 addresses - * - Dynamic size of outgoing packet - */ - -/* - * Copyright (c) 2015 Verisure Innovation AB - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Erik Ekman - * - */ - -#include "lwip/apps/mdns.h" -#include "lwip/apps/mdns_priv.h" -#include "lwip/netif.h" -#include "lwip/udp.h" -#include "lwip/ip_addr.h" -#include "lwip/mem.h" -#include "lwip/prot/dns.h" -#include "lwip/prot/iana.h" -#include "lwip/timeouts.h" - -#include - -#if LWIP_MDNS_RESPONDER - -#if (LWIP_IPV4 && !LWIP_IGMP) -#error "If you want to use MDNS with IPv4, you have to define LWIP_IGMP=1 in your lwipopts.h" -#endif -#if (LWIP_IPV6 && !LWIP_IPV6_MLD) -#error "If you want to use MDNS with IPv6, you have to define LWIP_IPV6_MLD=1 in your lwipopts.h" -#endif -#if (!LWIP_UDP) -#error "If you want to use MDNS, you have to define LWIP_UDP=1 in your lwipopts.h" -#endif - -#if LWIP_IPV4 -#include "lwip/igmp.h" -/* IPv4 multicast group 224.0.0.251 */ -static const ip_addr_t v4group = DNS_MQUERY_IPV4_GROUP_INIT; -#endif - -#if LWIP_IPV6 -#include "lwip/mld6.h" -/* IPv6 multicast group FF02::FB */ -static const ip_addr_t v6group = DNS_MQUERY_IPV6_GROUP_INIT; -#endif - -#define MDNS_TTL 255 - -/* Stored offsets to beginning of domain names - * Used for compression. - */ -#define NUM_DOMAIN_OFFSETS 10 -#define DOMAIN_JUMP_SIZE 2 -#define DOMAIN_JUMP 0xc000 - -static u8_t mdns_netif_client_id; -static struct udp_pcb *mdns_pcb; -#if MDNS_RESP_USENETIF_EXTCALLBACK -NETIF_DECLARE_EXT_CALLBACK(netif_callback) -#endif -static mdns_name_result_cb_t mdns_name_result_cb; - -#define NETIF_TO_HOST(netif) (struct mdns_host*)(netif_get_client_data(netif, mdns_netif_client_id)) - -#define TOPDOMAIN_LOCAL "local" - -#define REVERSE_PTR_TOPDOMAIN "arpa" -#define REVERSE_PTR_V4_DOMAIN "in-addr" -#define REVERSE_PTR_V6_DOMAIN "ip6" - -#define SRV_PRIORITY 0 -#define SRV_WEIGHT 0 - -/* Payload size allocated for each outgoing UDP packet */ -#define OUTPACKET_SIZE 500 - -/* Lookup from hostname -> IPv4 */ -#define REPLY_HOST_A 0x01 -/* Lookup from IPv4/v6 -> hostname */ -#define REPLY_HOST_PTR_V4 0x02 -/* Lookup from hostname -> IPv6 */ -#define REPLY_HOST_AAAA 0x04 -/* Lookup from hostname -> IPv6 */ -#define REPLY_HOST_PTR_V6 0x08 - -/* Lookup for service types */ -#define REPLY_SERVICE_TYPE_PTR 0x10 -/* Lookup for instances of service */ -#define REPLY_SERVICE_NAME_PTR 0x20 -/* Lookup for location of service instance */ -#define REPLY_SERVICE_SRV 0x40 -/* Lookup for text info on service instance */ -#define REPLY_SERVICE_TXT 0x80 - -#define MDNS_PROBE_DELAY_MS 250 -#define MDNS_PROBE_COUNT 3 -#ifdef LWIP_RAND -/* first probe timeout SHOULD be random 0-250 ms*/ -#define MDNS_INITIAL_PROBE_DELAY_MS (LWIP_RAND() % MDNS_PROBE_DELAY_MS) -#else -#define MDNS_INITIAL_PROBE_DELAY_MS MDNS_PROBE_DELAY_MS -#endif - -#define MDNS_PROBING_NOT_STARTED 0 -#define MDNS_PROBING_ONGOING 1 -#define MDNS_PROBING_COMPLETE 2 - -static const char *dnssd_protos[] = { - "_udp", /* DNSSD_PROTO_UDP */ - "_tcp", /* DNSSD_PROTO_TCP */ -}; - -/** Description of a service */ -struct mdns_service { - /** TXT record to answer with */ - struct mdns_domain txtdata; - /** Name of service, like 'myweb' */ - char name[MDNS_LABEL_MAXLEN + 1]; - /** Type of service, like '_http' */ - char service[MDNS_LABEL_MAXLEN + 1]; - /** Callback function and userdata - * to update txtdata buffer */ - service_get_txt_fn_t txt_fn; - void *txt_userdata; - /** TTL in seconds of SRV/TXT replies */ - u32_t dns_ttl; - /** Protocol, TCP or UDP */ - u16_t proto; - /** Port of the service */ - u16_t port; -}; - -/** Description of a host/netif */ -struct mdns_host { - /** Hostname */ - char name[MDNS_LABEL_MAXLEN + 1]; - /** Pointer to services */ - struct mdns_service *services[MDNS_MAX_SERVICES]; - /** TTL in seconds of A/AAAA/PTR replies */ - u32_t dns_ttl; - /** Number of probes sent for the current name */ - u8_t probes_sent; - /** State in probing sequence */ - u8_t probing_state; -}; - -/** Information about received packet */ -struct mdns_packet { - /** Sender IP/port */ - ip_addr_t source_addr; - u16_t source_port; - /** If packet was received unicast */ - u16_t recv_unicast; - /** Netif that received the packet */ - struct netif *netif; - /** Packet data */ - struct pbuf *pbuf; - /** Current parsing offset in packet */ - u16_t parse_offset; - /** Identifier. Used in legacy queries */ - u16_t tx_id; - /** Number of questions in packet, - * read from packet header */ - u16_t questions; - /** Number of unparsed questions */ - u16_t questions_left; - /** Number of answers in packet, - * (sum of normal, authoritative and additional answers) - * read from packet header */ - u16_t answers; - /** Number of unparsed answers */ - u16_t answers_left; -}; - -/** Information about outgoing packet */ -struct mdns_outpacket { - /** Netif to send the packet on */ - struct netif *netif; - /** Packet data */ - struct pbuf *pbuf; - /** Current write offset in packet */ - u16_t write_offset; - /** Identifier. Used in legacy queries */ - u16_t tx_id; - /** Destination IP/port if sent unicast */ - ip_addr_t dest_addr; - u16_t dest_port; - /** Number of questions written */ - u16_t questions; - /** Number of normal answers written */ - u16_t answers; - /** Number of authoritative answers written */ - u16_t authoritative; - /** Number of additional answers written */ - u16_t additional; - /** Offsets for written domain names in packet. - * Used for compression */ - u16_t domain_offsets[NUM_DOMAIN_OFFSETS]; - /** If all answers in packet should set cache_flush bit */ - u8_t cache_flush; - /** If reply should be sent unicast */ - u8_t unicast_reply; - /** If legacy query. (tx_id needed, and write - * question again in reply before answer) */ - u8_t legacy_query; - /* Reply bitmask for host information */ - u8_t host_replies; - /* Bitmask for which reverse IPv6 hosts to answer */ - u8_t host_reverse_v6_replies; - /* Reply bitmask per service */ - u8_t serv_replies[MDNS_MAX_SERVICES]; -}; - -/** Domain, type and class. - * Shared between questions and answers */ -struct mdns_rr_info { - struct mdns_domain domain; - u16_t type; - u16_t klass; -}; - -struct mdns_question { - struct mdns_rr_info info; - /** unicast reply requested */ - u16_t unicast; -}; - -struct mdns_answer { - struct mdns_rr_info info; - /** cache flush command bit */ - u16_t cache_flush; - /* Validity time in seconds */ - u32_t ttl; - /** Length of variable answer */ - u16_t rd_length; - /** Offset of start of variable answer in packet */ - u16_t rd_offset; -}; - -static err_t mdns_send_outpacket(struct mdns_outpacket *outpkt, u8_t flags); -static void mdns_probe(void* arg); - -static err_t -mdns_domain_add_label_base(struct mdns_domain *domain, u8_t len) -{ - if (len > MDNS_LABEL_MAXLEN) { - return ERR_VAL; - } - if (len > 0 && (1 + len + domain->length >= MDNS_DOMAIN_MAXLEN)) { - return ERR_VAL; - } - /* Allow only zero marker on last byte */ - if (len == 0 && (1 + domain->length > MDNS_DOMAIN_MAXLEN)) { - return ERR_VAL; - } - domain->name[domain->length] = len; - domain->length++; - return ERR_OK; -} - -/** - * Add a label part to a domain - * @param domain The domain to add a label to - * @param label The label to add, like <hostname>, 'local', 'com' or '' - * @param len The length of the label - * @return ERR_OK on success, an err_t otherwise if label too long - */ -err_t -mdns_domain_add_label(struct mdns_domain *domain, const char *label, u8_t len) -{ - err_t err = mdns_domain_add_label_base(domain, len); - if (err != ERR_OK) { - return err; - } - if (len) { - MEMCPY(&domain->name[domain->length], label, len); - domain->length += len; - } - return ERR_OK; -} - -/** - * Add a label part to a domain (@see mdns_domain_add_label but copy directly from pbuf) - */ -static err_t -mdns_domain_add_label_pbuf(struct mdns_domain *domain, const struct pbuf *p, u16_t offset, u8_t len) -{ - err_t err = mdns_domain_add_label_base(domain, len); - if (err != ERR_OK) { - return err; - } - if (len) { - if (pbuf_copy_partial(p, &domain->name[domain->length], len, offset) != len) { - /* take back the ++ done before */ - domain->length--; - return ERR_ARG; - } - domain->length += len; - } - return ERR_OK; -} - -/** - * Internal readname function with max 6 levels of recursion following jumps - * while decompressing name - */ -static u16_t -mdns_readname_loop(struct pbuf *p, u16_t offset, struct mdns_domain *domain, unsigned depth) -{ - u8_t c; - - do { - if (depth > 5) { - /* Too many jumps */ - return MDNS_READNAME_ERROR; - } - - c = pbuf_get_at(p, offset); - offset++; - - /* is this a compressed label? */ - if ((c & 0xc0) == 0xc0) { - u16_t jumpaddr; - if (offset >= p->tot_len) { - /* Make sure both jump bytes fit in the packet */ - return MDNS_READNAME_ERROR; - } - jumpaddr = (((c & 0x3f) << 8) | (pbuf_get_at(p, offset) & 0xff)); - offset++; - if (jumpaddr >= SIZEOF_DNS_HDR && jumpaddr < p->tot_len) { - u16_t res; - /* Recursive call, maximum depth will be checked */ - res = mdns_readname_loop(p, jumpaddr, domain, depth + 1); - /* Dont return offset since new bytes were not read (jumped to somewhere in packet) */ - if (res == MDNS_READNAME_ERROR) { - return res; - } - } else { - return MDNS_READNAME_ERROR; - } - break; - } - - /* normal label */ - if (c <= MDNS_LABEL_MAXLEN) { - err_t res; - - if (c + domain->length >= MDNS_DOMAIN_MAXLEN) { - return MDNS_READNAME_ERROR; - } - res = mdns_domain_add_label_pbuf(domain, p, offset, c); - if (res != ERR_OK) { - return MDNS_READNAME_ERROR; - } - offset += c; - } else { - /* bad length byte */ - return MDNS_READNAME_ERROR; - } - } while (c != 0); - - return offset; -} - -/** - * Read possibly compressed domain name from packet buffer - * @param p The packet - * @param offset start position of domain name in packet - * @param domain The domain name destination - * @return The new offset after the domain, or MDNS_READNAME_ERROR - * if reading failed - */ -u16_t -mdns_readname(struct pbuf *p, u16_t offset, struct mdns_domain *domain) -{ - memset(domain, 0, sizeof(struct mdns_domain)); - return mdns_readname_loop(p, offset, domain, 0); -} - -/** - * Print domain name to debug output - * @param domain The domain name - */ -static void -mdns_domain_debug_print(struct mdns_domain *domain) -{ - u8_t *src = domain->name; - u8_t i; - - while (*src) { - u8_t label_len = *src; - src++; - for (i = 0; i < label_len; i++) { - LWIP_DEBUGF(MDNS_DEBUG, ("%c", src[i])); - } - src += label_len; - LWIP_DEBUGF(MDNS_DEBUG, (".")); - } -} - -/** - * Return 1 if contents of domains match (case-insensitive) - * @param a Domain name to compare 1 - * @param b Domain name to compare 2 - * @return 1 if domains are equal ignoring case, 0 otherwise - */ -int -mdns_domain_eq(struct mdns_domain *a, struct mdns_domain *b) -{ - u8_t *ptra, *ptrb; - u8_t len; - int res; - - if (a->length != b->length) { - return 0; - } - - ptra = a->name; - ptrb = b->name; - while (*ptra && *ptrb && ptra < &a->name[a->length]) { - if (*ptra != *ptrb) { - return 0; - } - len = *ptra; - ptra++; - ptrb++; - res = lwip_strnicmp((char *) ptra, (char *) ptrb, len); - if (res != 0) { - return 0; - } - ptra += len; - ptrb += len; - } - if (*ptra != *ptrb && ptra < &a->name[a->length]) { - return 0; - } - return 1; -} - -/** - * Call user supplied function to setup TXT data - * @param service The service to build TXT record for - */ -static void -mdns_prepare_txtdata(struct mdns_service *service) -{ - memset(&service->txtdata, 0, sizeof(struct mdns_domain)); - if (service->txt_fn) { - service->txt_fn(service, service->txt_userdata); - } -} - -#if LWIP_IPV4 -/** - * Build domain for reverse lookup of IPv4 address - * like 12.0.168.192.in-addr.arpa. for 192.168.0.12 - * @param domain Where to write the domain name - * @param addr Pointer to an IPv4 address to encode - * @return ERR_OK if domain was written, an err_t otherwise - */ -static err_t -mdns_build_reverse_v4_domain(struct mdns_domain *domain, const ip4_addr_t *addr) -{ - int i; - err_t res; - const u8_t *ptr; - - LWIP_UNUSED_ARG(res); - if (!domain || !addr) { - return ERR_ARG; - } - memset(domain, 0, sizeof(struct mdns_domain)); - ptr = (const u8_t *) addr; - for (i = sizeof(ip4_addr_t) - 1; i >= 0; i--) { - char buf[4]; - u8_t val = ptr[i]; - - lwip_itoa(buf, sizeof(buf), val); - res = mdns_domain_add_label(domain, buf, (u8_t)strlen(buf)); - LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); - } - res = mdns_domain_add_label(domain, REVERSE_PTR_V4_DOMAIN, (u8_t)(sizeof(REVERSE_PTR_V4_DOMAIN) - 1)); - LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); - res = mdns_domain_add_label(domain, REVERSE_PTR_TOPDOMAIN, (u8_t)(sizeof(REVERSE_PTR_TOPDOMAIN) - 1)); - LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); - res = mdns_domain_add_label(domain, NULL, 0); - LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); - - return ERR_OK; -} -#endif - -#if LWIP_IPV6 -/** - * Build domain for reverse lookup of IP address - * like b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa. for 2001:db8::567:89ab - * @param domain Where to write the domain name - * @param addr Pointer to an IPv6 address to encode - * @return ERR_OK if domain was written, an err_t otherwise - */ -static err_t -mdns_build_reverse_v6_domain(struct mdns_domain *domain, const ip6_addr_t *addr) -{ - int i; - err_t res; - const u8_t *ptr; - LWIP_UNUSED_ARG(res); - if (!domain || !addr) { - return ERR_ARG; - } - memset(domain, 0, sizeof(struct mdns_domain)); - ptr = (const u8_t *) addr; - for (i = sizeof(ip6_addr_p_t) - 1; i >= 0; i--) { - char buf; - u8_t byte = ptr[i]; - int j; - for (j = 0; j < 2; j++) { - if ((byte & 0x0F) < 0xA) { - buf = '0' + (byte & 0x0F); - } else { - buf = 'a' + (byte & 0x0F) - 0xA; - } - res = mdns_domain_add_label(domain, &buf, sizeof(buf)); - LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); - byte >>= 4; - } - } - res = mdns_domain_add_label(domain, REVERSE_PTR_V6_DOMAIN, (u8_t)(sizeof(REVERSE_PTR_V6_DOMAIN) - 1)); - LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); - res = mdns_domain_add_label(domain, REVERSE_PTR_TOPDOMAIN, (u8_t)(sizeof(REVERSE_PTR_TOPDOMAIN) - 1)); - LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); - res = mdns_domain_add_label(domain, NULL, 0); - LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); - - return ERR_OK; -} -#endif - -/* Add .local. to domain */ -static err_t -mdns_add_dotlocal(struct mdns_domain *domain) -{ - err_t res = mdns_domain_add_label(domain, TOPDOMAIN_LOCAL, (u8_t)(sizeof(TOPDOMAIN_LOCAL) - 1)); - LWIP_UNUSED_ARG(res); - LWIP_ERROR("mdns_add_dotlocal: Failed to add label", (res == ERR_OK), return res); - return mdns_domain_add_label(domain, NULL, 0); -} - -/** - * Build the .local. domain name - * @param domain Where to write the domain name - * @param mdns TMDNS netif descriptor. - * @return ERR_OK if domain .local. was written, an err_t otherwise - */ -static err_t -mdns_build_host_domain(struct mdns_domain *domain, struct mdns_host *mdns) -{ - err_t res; - LWIP_UNUSED_ARG(res); - memset(domain, 0, sizeof(struct mdns_domain)); - LWIP_ERROR("mdns_build_host_domain: mdns != NULL", (mdns != NULL), return ERR_VAL); - res = mdns_domain_add_label(domain, mdns->name, (u8_t)strlen(mdns->name)); - LWIP_ERROR("mdns_build_host_domain: Failed to add label", (res == ERR_OK), return res); - return mdns_add_dotlocal(domain); -} - -/** - * Build the lookup-all-services special DNS-SD domain name - * @param domain Where to write the domain name - * @return ERR_OK if domain _services._dns-sd._udp.local. was written, an err_t otherwise - */ -static err_t -mdns_build_dnssd_domain(struct mdns_domain *domain) -{ - err_t res; - LWIP_UNUSED_ARG(res); - memset(domain, 0, sizeof(struct mdns_domain)); - res = mdns_domain_add_label(domain, "_services", (u8_t)(sizeof("_services") - 1)); - LWIP_ERROR("mdns_build_dnssd_domain: Failed to add label", (res == ERR_OK), return res); - res = mdns_domain_add_label(domain, "_dns-sd", (u8_t)(sizeof("_dns-sd") - 1)); - LWIP_ERROR("mdns_build_dnssd_domain: Failed to add label", (res == ERR_OK), return res); - res = mdns_domain_add_label(domain, dnssd_protos[DNSSD_PROTO_UDP], (u8_t)strlen(dnssd_protos[DNSSD_PROTO_UDP])); - LWIP_ERROR("mdns_build_dnssd_domain: Failed to add label", (res == ERR_OK), return res); - return mdns_add_dotlocal(domain); -} - -/** - * Build domain name for a service - * @param domain Where to write the domain name - * @param service The service struct, containing service name, type and protocol - * @param include_name Whether to include the service name in the domain - * @return ERR_OK if domain was written. If service name is included, - * ...local. will be written, otherwise ..local. - * An err_t is returned on error. - */ -static err_t -mdns_build_service_domain(struct mdns_domain *domain, struct mdns_service *service, int include_name) -{ - err_t res; - LWIP_UNUSED_ARG(res); - memset(domain, 0, sizeof(struct mdns_domain)); - if (include_name) { - res = mdns_domain_add_label(domain, service->name, (u8_t)strlen(service->name)); - LWIP_ERROR("mdns_build_service_domain: Failed to add label", (res == ERR_OK), return res); - } - res = mdns_domain_add_label(domain, service->service, (u8_t)strlen(service->service)); - LWIP_ERROR("mdns_build_service_domain: Failed to add label", (res == ERR_OK), return res); - res = mdns_domain_add_label(domain, dnssd_protos[service->proto], (u8_t)strlen(dnssd_protos[service->proto])); - LWIP_ERROR("mdns_build_service_domain: Failed to add label", (res == ERR_OK), return res); - return mdns_add_dotlocal(domain); -} - -/** - * Check which replies we should send for a host/netif based on question - * @param netif The network interface that received the question - * @param rr Domain/type/class from a question - * @param reverse_v6_reply Bitmask of which IPv6 addresses to send reverse PTRs for - * if reply bit has REPLY_HOST_PTR_V6 set - * @return Bitmask of which replies to send - */ -static int -check_host(struct netif *netif, struct mdns_rr_info *rr, u8_t *reverse_v6_reply) -{ - err_t res; - int replies = 0; - struct mdns_domain mydomain; - - LWIP_UNUSED_ARG(reverse_v6_reply); /* if ipv6 is disabled */ - - if (rr->klass != DNS_RRCLASS_IN && rr->klass != DNS_RRCLASS_ANY) { - /* Invalid class */ - return replies; - } - - /* Handle PTR for our addresses */ - if (rr->type == DNS_RRTYPE_PTR || rr->type == DNS_RRTYPE_ANY) { -#if LWIP_IPV6 - int i; - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { - res = mdns_build_reverse_v6_domain(&mydomain, netif_ip6_addr(netif, i)); - if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { - replies |= REPLY_HOST_PTR_V6; - /* Mark which addresses where requested */ - if (reverse_v6_reply) { - *reverse_v6_reply |= (1 << i); - } - } - } - } -#endif -#if LWIP_IPV4 - if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { - res = mdns_build_reverse_v4_domain(&mydomain, netif_ip4_addr(netif)); - if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { - replies |= REPLY_HOST_PTR_V4; - } - } -#endif - } - - res = mdns_build_host_domain(&mydomain, NETIF_TO_HOST(netif)); - /* Handle requests for our hostname */ - if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { - /* TODO return NSEC if unsupported protocol requested */ -#if LWIP_IPV4 - if (!ip4_addr_isany_val(*netif_ip4_addr(netif)) - && (rr->type == DNS_RRTYPE_A || rr->type == DNS_RRTYPE_ANY)) { - replies |= REPLY_HOST_A; - } -#endif -#if LWIP_IPV6 - if (rr->type == DNS_RRTYPE_AAAA || rr->type == DNS_RRTYPE_ANY) { - replies |= REPLY_HOST_AAAA; - } -#endif - } - - return replies; -} - -/** - * Check which replies we should send for a service based on question - * @param service A registered MDNS service - * @param rr Domain/type/class from a question - * @return Bitmask of which replies to send - */ -static int -check_service(struct mdns_service *service, struct mdns_rr_info *rr) -{ - err_t res; - int replies = 0; - struct mdns_domain mydomain; - - if (rr->klass != DNS_RRCLASS_IN && rr->klass != DNS_RRCLASS_ANY) { - /* Invalid class */ - return 0; - } - - res = mdns_build_dnssd_domain(&mydomain); - if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain) && - (rr->type == DNS_RRTYPE_PTR || rr->type == DNS_RRTYPE_ANY)) { - /* Request for all service types */ - replies |= REPLY_SERVICE_TYPE_PTR; - } - - res = mdns_build_service_domain(&mydomain, service, 0); - if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain) && - (rr->type == DNS_RRTYPE_PTR || rr->type == DNS_RRTYPE_ANY)) { - /* Request for the instance of my service */ - replies |= REPLY_SERVICE_NAME_PTR; - } - - res = mdns_build_service_domain(&mydomain, service, 1); - if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { - /* Request for info about my service */ - if (rr->type == DNS_RRTYPE_SRV || rr->type == DNS_RRTYPE_ANY) { - replies |= REPLY_SERVICE_SRV; - } - if (rr->type == DNS_RRTYPE_TXT || rr->type == DNS_RRTYPE_ANY) { - replies |= REPLY_SERVICE_TXT; - } - } - - return replies; -} - -/** - * Return bytes needed to write before jump for best result of compressing supplied domain - * against domain in outpacket starting at specified offset. - * If a match is found, offset is updated to where to jump to - * @param pbuf Pointer to pbuf with the partially constructed DNS packet - * @param offset Start position of a domain written earlier. If this location is suitable - * for compression, the pointer is updated to where in the domain to jump to. - * @param domain The domain to write - * @return Number of bytes to write of the new domain before writing a jump to the offset. - * If compression can not be done against this previous domain name, the full new - * domain length is returned. - */ -u16_t -mdns_compress_domain(struct pbuf *pbuf, u16_t *offset, struct mdns_domain *domain) -{ - struct mdns_domain target; - u16_t target_end; - u8_t target_len; - u8_t writelen = 0; - u8_t *ptr; - if (pbuf == NULL) { - return domain->length; - } - target_end = mdns_readname(pbuf, *offset, &target); - if (target_end == MDNS_READNAME_ERROR) { - return domain->length; - } - target_len = (u8_t)(target_end - *offset); - ptr = domain->name; - while (writelen < domain->length) { - u8_t domainlen = (u8_t)(domain->length - writelen); - u8_t labellen; - if (domainlen <= target.length && domainlen > DOMAIN_JUMP_SIZE) { - /* Compare domains if target is long enough, and we have enough left of the domain */ - u8_t targetpos = (u8_t)(target.length - domainlen); - if ((targetpos + DOMAIN_JUMP_SIZE) >= target_len) { - /* We are checking at or beyond a jump in the original, stop looking */ - break; - } - if (target.length >= domainlen && - memcmp(&domain->name[writelen], &target.name[targetpos], domainlen) == 0) { - *offset += targetpos; - return writelen; - } - } - /* Skip to next label in domain */ - labellen = *ptr; - writelen += 1 + labellen; - ptr += 1 + labellen; - } - /* Nothing found */ - return domain->length; -} - -/** - * Write domain to outpacket. Compression will be attempted, - * unless domain->skip_compression is set. - * @param outpkt The outpacket to write to - * @param domain The domain name to write - * @return ERR_OK on success, an err_t otherwise - */ -static err_t -mdns_write_domain(struct mdns_outpacket *outpkt, struct mdns_domain *domain) -{ - int i; - err_t res; - u16_t writelen = domain->length; - u16_t jump_offset = 0; - u16_t jump; - - if (!domain->skip_compression) { - for (i = 0; i < NUM_DOMAIN_OFFSETS; i++) { - u16_t offset = outpkt->domain_offsets[i]; - if (offset) { - u16_t len = mdns_compress_domain(outpkt->pbuf, &offset, domain); - if (len < writelen) { - writelen = len; - jump_offset = offset; - } - } - } - } - - if (writelen) { - /* Write uncompressed part of name */ - res = pbuf_take_at(outpkt->pbuf, domain->name, writelen, outpkt->write_offset); - if (res != ERR_OK) { - return res; - } - - /* Store offset of this new domain */ - for (i = 0; i < NUM_DOMAIN_OFFSETS; i++) { - if (outpkt->domain_offsets[i] == 0) { - outpkt->domain_offsets[i] = outpkt->write_offset; - break; - } - } - - outpkt->write_offset += writelen; - } - if (jump_offset) { - /* Write jump */ - jump = lwip_htons(DOMAIN_JUMP | jump_offset); - res = pbuf_take_at(outpkt->pbuf, &jump, DOMAIN_JUMP_SIZE, outpkt->write_offset); - if (res != ERR_OK) { - return res; - } - outpkt->write_offset += DOMAIN_JUMP_SIZE; - } - return ERR_OK; -} - -/** - * Write a question to an outpacket - * A question contains domain, type and class. Since an answer also starts with these fields this function is also - * called from mdns_add_answer(). - * @param outpkt The outpacket to write to - * @param domain The domain name the answer is for - * @param type The DNS type of the answer (like 'AAAA', 'SRV') - * @param klass The DNS type of the answer (like 'IN') - * @param unicast If highest bit in class should be set, to instruct the responder to - * reply with a unicast packet - * @return ERR_OK on success, an err_t otherwise - */ -static err_t -mdns_add_question(struct mdns_outpacket *outpkt, struct mdns_domain *domain, u16_t type, u16_t klass, u16_t unicast) -{ - u16_t question_len; - u16_t field16; - err_t res; - - if (!outpkt->pbuf) { - /* If no pbuf is active, allocate one */ - outpkt->pbuf = pbuf_alloc(PBUF_TRANSPORT, OUTPACKET_SIZE, PBUF_RAM); - if (!outpkt->pbuf) { - return ERR_MEM; - } - outpkt->write_offset = SIZEOF_DNS_HDR; - } - - /* Worst case calculation. Domain string might be compressed */ - question_len = domain->length + sizeof(type) + sizeof(klass); - if (outpkt->write_offset + question_len > outpkt->pbuf->tot_len) { - /* No space */ - return ERR_MEM; - } - - /* Write name */ - res = mdns_write_domain(outpkt, domain); - if (res != ERR_OK) { - return res; - } - - /* Write type */ - field16 = lwip_htons(type); - res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset); - if (res != ERR_OK) { - return res; - } - outpkt->write_offset += sizeof(field16); - - /* Write class */ - if (unicast) { - klass |= 0x8000; - } - field16 = lwip_htons(klass); - res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset); - if (res != ERR_OK) { - return res; - } - outpkt->write_offset += sizeof(field16); - - return ERR_OK; -} - -/** - * Write answer to reply packet. - * buf or answer_domain can be null. The rd_length written will be buf_length + - * size of (compressed) domain. Most uses will need either buf or answer_domain, - * special case is SRV that starts with 3 u16 and then a domain name. - * @param reply The outpacket to write to - * @param domain The domain name the answer is for - * @param type The DNS type of the answer (like 'AAAA', 'SRV') - * @param klass The DNS type of the answer (like 'IN') - * @param cache_flush If highest bit in class should be set, to instruct receiver that - * this reply replaces any earlier answer for this domain/type/class - * @param ttl Validity time in seconds to send out for IP address data in DNS replies - * @param buf Pointer to buffer of answer data - * @param buf_length Length of variable data - * @param answer_domain A domain to write after any buffer data as answer - * @return ERR_OK on success, an err_t otherwise - */ -static err_t -mdns_add_answer(struct mdns_outpacket *reply, struct mdns_domain *domain, u16_t type, u16_t klass, u16_t cache_flush, - u32_t ttl, const u8_t *buf, size_t buf_length, struct mdns_domain *answer_domain) -{ - u16_t answer_len; - u16_t field16; - u16_t rdlen_offset; - u16_t answer_offset; - u32_t field32; - err_t res; - - if (!reply->pbuf) { - /* If no pbuf is active, allocate one */ - reply->pbuf = pbuf_alloc(PBUF_TRANSPORT, OUTPACKET_SIZE, PBUF_RAM); - if (!reply->pbuf) { - return ERR_MEM; - } - reply->write_offset = SIZEOF_DNS_HDR; - } - - /* Worst case calculation. Domain strings might be compressed */ - answer_len = domain->length + sizeof(type) + sizeof(klass) + sizeof(ttl) + sizeof(field16)/*rd_length*/; - if (buf) { - answer_len += (u16_t)buf_length; - } - if (answer_domain) { - answer_len += answer_domain->length; - } - if (reply->write_offset + answer_len > reply->pbuf->tot_len) { - /* No space */ - return ERR_MEM; - } - - /* Answer starts with same data as question, then more fields */ - mdns_add_question(reply, domain, type, klass, cache_flush); - - /* Write TTL */ - field32 = lwip_htonl(ttl); - res = pbuf_take_at(reply->pbuf, &field32, sizeof(field32), reply->write_offset); - if (res != ERR_OK) { - return res; - } - reply->write_offset += sizeof(field32); - - /* Store offsets and skip forward to the data */ - rdlen_offset = reply->write_offset; - reply->write_offset += sizeof(field16); - answer_offset = reply->write_offset; - - if (buf) { - /* Write static data */ - res = pbuf_take_at(reply->pbuf, buf, (u16_t)buf_length, reply->write_offset); - if (res != ERR_OK) { - return res; - } - reply->write_offset += (u16_t)buf_length; - } - - if (answer_domain) { - /* Write name answer (compressed if possible) */ - res = mdns_write_domain(reply, answer_domain); - if (res != ERR_OK) { - return res; - } - } - - /* Write rd_length after when we know the answer size */ - field16 = lwip_htons(reply->write_offset - answer_offset); - res = pbuf_take_at(reply->pbuf, &field16, sizeof(field16), rdlen_offset); - - return res; -} - -/** - * Helper function for mdns_read_question/mdns_read_answer - * Reads a domain, type and class from the packet - * @param pkt The MDNS packet to read from. The parse_offset field will be - * incremented to point to the next unparsed byte. - * @param info The struct to fill with domain, type and class - * @return ERR_OK on success, an err_t otherwise - */ -static err_t -mdns_read_rr_info(struct mdns_packet *pkt, struct mdns_rr_info *info) -{ - u16_t field16, copied; - pkt->parse_offset = mdns_readname(pkt->pbuf, pkt->parse_offset, &info->domain); - if (pkt->parse_offset == MDNS_READNAME_ERROR) { - return ERR_VAL; - } - - copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); - if (copied != sizeof(field16)) { - return ERR_VAL; - } - pkt->parse_offset += copied; - info->type = lwip_ntohs(field16); - - copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); - if (copied != sizeof(field16)) { - return ERR_VAL; - } - pkt->parse_offset += copied; - info->klass = lwip_ntohs(field16); - - return ERR_OK; -} - -/** - * Read a question from the packet. - * All questions have to be read before the answers. - * @param pkt The MDNS packet to read from. The questions_left field will be decremented - * and the parse_offset will be updated. - * @param question The struct to fill with question data - * @return ERR_OK on success, an err_t otherwise - */ -static err_t -mdns_read_question(struct mdns_packet *pkt, struct mdns_question *question) -{ - /* Safety check */ - if (pkt->pbuf->tot_len < pkt->parse_offset) { - return ERR_VAL; - } - - if (pkt->questions_left) { - err_t res; - pkt->questions_left--; - - memset(question, 0, sizeof(struct mdns_question)); - res = mdns_read_rr_info(pkt, &question->info); - if (res != ERR_OK) { - return res; - } - - /* Extract unicast flag from class field */ - question->unicast = question->info.klass & 0x8000; - question->info.klass &= 0x7FFF; - - return ERR_OK; - } - return ERR_VAL; -} - -/** - * Read an answer from the packet - * The variable length reply is not copied, its pbuf offset and length is stored instead. - * @param pkt The MDNS packet to read. The answers_left field will be decremented and - * the parse_offset will be updated. - * @param answer The struct to fill with answer data - * @return ERR_OK on success, an err_t otherwise - */ -static err_t -mdns_read_answer(struct mdns_packet *pkt, struct mdns_answer *answer) -{ - /* Read questions first */ - if (pkt->questions_left) { - return ERR_VAL; - } - - /* Safety check */ - if (pkt->pbuf->tot_len < pkt->parse_offset) { - return ERR_VAL; - } - - if (pkt->answers_left) { - u16_t copied, field16; - u32_t ttl; - err_t res; - pkt->answers_left--; - - memset(answer, 0, sizeof(struct mdns_answer)); - res = mdns_read_rr_info(pkt, &answer->info); - if (res != ERR_OK) { - return res; - } - - /* Extract cache_flush flag from class field */ - answer->cache_flush = answer->info.klass & 0x8000; - answer->info.klass &= 0x7FFF; - - copied = pbuf_copy_partial(pkt->pbuf, &ttl, sizeof(ttl), pkt->parse_offset); - if (copied != sizeof(ttl)) { - return ERR_VAL; - } - pkt->parse_offset += copied; - answer->ttl = lwip_ntohl(ttl); - - copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); - if (copied != sizeof(field16)) { - return ERR_VAL; - } - pkt->parse_offset += copied; - answer->rd_length = lwip_ntohs(field16); - - answer->rd_offset = pkt->parse_offset; - pkt->parse_offset += answer->rd_length; - - return ERR_OK; - } - return ERR_VAL; -} - -#if LWIP_IPV4 -/** Write an IPv4 address (A) RR to outpacket */ -static err_t -mdns_add_a_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif) -{ - struct mdns_domain host; - mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with A record\n")); - return mdns_add_answer(reply, &host, DNS_RRTYPE_A, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, (const u8_t *) netif_ip4_addr(netif), sizeof(ip4_addr_t), NULL); -} - -/** Write a 4.3.2.1.in-addr.arpa -> hostname.local PTR RR to outpacket */ -static err_t -mdns_add_hostv4_ptr_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif) -{ - struct mdns_domain host, revhost; - mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); - mdns_build_reverse_v4_domain(&revhost, netif_ip4_addr(netif)); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with v4 PTR record\n")); - return mdns_add_answer(reply, &revhost, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, NULL, 0, &host); -} -#endif - -#if LWIP_IPV6 -/** Write an IPv6 address (AAAA) RR to outpacket */ -static err_t -mdns_add_aaaa_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif, int addrindex) -{ - struct mdns_domain host; - mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with AAAA record\n")); - return mdns_add_answer(reply, &host, DNS_RRTYPE_AAAA, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, (const u8_t *) netif_ip6_addr(netif, addrindex), sizeof(ip6_addr_p_t), NULL); -} - -/** Write a x.y.z.ip6.arpa -> hostname.local PTR RR to outpacket */ -static err_t -mdns_add_hostv6_ptr_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif, int addrindex) -{ - struct mdns_domain host, revhost; - mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); - mdns_build_reverse_v6_domain(&revhost, netif_ip6_addr(netif, addrindex)); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with v6 PTR record\n")); - return mdns_add_answer(reply, &revhost, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, NULL, 0, &host); -} -#endif - -/** Write an all-services -> servicetype PTR RR to outpacket */ -static err_t -mdns_add_servicetype_ptr_answer(struct mdns_outpacket *reply, struct mdns_service *service) -{ - struct mdns_domain service_type, service_dnssd; - mdns_build_service_domain(&service_type, service, 0); - mdns_build_dnssd_domain(&service_dnssd); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with service type PTR record\n")); - return mdns_add_answer(reply, &service_dnssd, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, 0, service->dns_ttl, NULL, 0, &service_type); -} - -/** Write a servicetype -> servicename PTR RR to outpacket */ -static err_t -mdns_add_servicename_ptr_answer(struct mdns_outpacket *reply, struct mdns_service *service) -{ - struct mdns_domain service_type, service_instance; - mdns_build_service_domain(&service_type, service, 0); - mdns_build_service_domain(&service_instance, service, 1); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with service name PTR record\n")); - return mdns_add_answer(reply, &service_type, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, 0, service->dns_ttl, NULL, 0, &service_instance); -} - -/** Write a SRV RR to outpacket */ -static err_t -mdns_add_srv_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct mdns_host *mdns, struct mdns_service *service) -{ - struct mdns_domain service_instance, srvhost; - u16_t srvdata[3]; - mdns_build_service_domain(&service_instance, service, 1); - mdns_build_host_domain(&srvhost, mdns); - if (reply->legacy_query) { - /* RFC 6762 section 18.14: - * In legacy unicast responses generated to answer legacy queries, - * name compression MUST NOT be performed on SRV records. - */ - srvhost.skip_compression = 1; - } - srvdata[0] = lwip_htons(SRV_PRIORITY); - srvdata[1] = lwip_htons(SRV_WEIGHT); - srvdata[2] = lwip_htons(service->port); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with SRV record\n")); - return mdns_add_answer(reply, &service_instance, DNS_RRTYPE_SRV, DNS_RRCLASS_IN, cache_flush, service->dns_ttl, - (const u8_t *) &srvdata, sizeof(srvdata), &srvhost); -} - -/** Write a TXT RR to outpacket */ -static err_t -mdns_add_txt_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct mdns_service *service) -{ - struct mdns_domain service_instance; - mdns_build_service_domain(&service_instance, service, 1); - mdns_prepare_txtdata(service); - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with TXT record\n")); - return mdns_add_answer(reply, &service_instance, DNS_RRTYPE_TXT, DNS_RRCLASS_IN, cache_flush, service->dns_ttl, - (u8_t *) &service->txtdata.name, service->txtdata.length, NULL); -} - -/** - * Setup outpacket as a reply to the incoming packet - */ -static void -mdns_init_outpacket(struct mdns_outpacket *out, struct mdns_packet *in) -{ - memset(out, 0, sizeof(struct mdns_outpacket)); - out->cache_flush = 1; - out->netif = in->netif; - - /* Copy source IP/port to use when responding unicast, or to choose - * which pcb to use for multicast (IPv4/IPv6) - */ - SMEMCPY(&out->dest_addr, &in->source_addr, sizeof(ip_addr_t)); - out->dest_port = in->source_port; - - if (in->source_port != LWIP_IANA_PORT_MDNS) { - out->unicast_reply = 1; - out->cache_flush = 0; - if (in->questions == 1) { - out->legacy_query = 1; - out->tx_id = in->tx_id; - } - } - - if (in->recv_unicast) { - out->unicast_reply = 1; - } -} - -/** - * Send chosen answers as a reply - * - * Add all selected answers (first write will allocate pbuf) - * Add additional answers based on the selected answers - * Send the packet - */ -static err_t -mdns_send_outpacket(struct mdns_outpacket *outpkt, u8_t flags) -{ - struct mdns_service *service; - err_t res = ERR_ARG; - int i; - struct mdns_host *mdns = NETIF_TO_HOST(outpkt->netif); - u16_t answers = 0; - - /* Write answers to host questions */ -#if LWIP_IPV4 - if (outpkt->host_replies & REPLY_HOST_A) { - res = mdns_add_a_answer(outpkt, outpkt->cache_flush, outpkt->netif); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } - if (outpkt->host_replies & REPLY_HOST_PTR_V4) { - res = mdns_add_hostv4_ptr_answer(outpkt, outpkt->cache_flush, outpkt->netif); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } -#endif -#if LWIP_IPV6 - if (outpkt->host_replies & REPLY_HOST_AAAA) { - int addrindex; - for (addrindex = 0; addrindex < LWIP_IPV6_NUM_ADDRESSES; addrindex++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(outpkt->netif, addrindex))) { - res = mdns_add_aaaa_answer(outpkt, outpkt->cache_flush, outpkt->netif, addrindex); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } - } - } - if (outpkt->host_replies & REPLY_HOST_PTR_V6) { - u8_t rev_addrs = outpkt->host_reverse_v6_replies; - int addrindex = 0; - while (rev_addrs) { - if (rev_addrs & 1) { - res = mdns_add_hostv6_ptr_answer(outpkt, outpkt->cache_flush, outpkt->netif, addrindex); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } - addrindex++; - rev_addrs >>= 1; - } - } -#endif - - /* Write answers to service questions */ - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - service = mdns->services[i]; - if (!service) { - continue; - } - - if (outpkt->serv_replies[i] & REPLY_SERVICE_TYPE_PTR) { - res = mdns_add_servicetype_ptr_answer(outpkt, service); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } - - if (outpkt->serv_replies[i] & REPLY_SERVICE_NAME_PTR) { - res = mdns_add_servicename_ptr_answer(outpkt, service); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } - - if (outpkt->serv_replies[i] & REPLY_SERVICE_SRV) { - res = mdns_add_srv_answer(outpkt, outpkt->cache_flush, mdns, service); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } - - if (outpkt->serv_replies[i] & REPLY_SERVICE_TXT) { - res = mdns_add_txt_answer(outpkt, outpkt->cache_flush, service); - if (res != ERR_OK) { - goto cleanup; - } - answers++; - } - } - - /* if this is a response, the data above is anwers, else this is a probe and the answers above goes into auth section */ - if (flags & DNS_FLAG1_RESPONSE) { - outpkt->answers += answers; - } else { - outpkt->authoritative += answers; - } - - /* All answers written, add additional RRs */ - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - service = mdns->services[i]; - if (!service) { - continue; - } - - if (outpkt->serv_replies[i] & REPLY_SERVICE_NAME_PTR) { - /* Our service instance requested, include SRV & TXT - * if they are already not requested. */ - if (!(outpkt->serv_replies[i] & REPLY_SERVICE_SRV)) { - res = mdns_add_srv_answer(outpkt, outpkt->cache_flush, mdns, service); - if (res != ERR_OK) { - goto cleanup; - } - outpkt->additional++; - } - - if (!(outpkt->serv_replies[i] & REPLY_SERVICE_TXT)) { - res = mdns_add_txt_answer(outpkt, outpkt->cache_flush, service); - if (res != ERR_OK) { - goto cleanup; - } - outpkt->additional++; - } - } - - /* If service instance, SRV, record or an IP address is requested, - * supply all addresses for the host - */ - if ((outpkt->serv_replies[i] & (REPLY_SERVICE_NAME_PTR | REPLY_SERVICE_SRV)) || - (outpkt->host_replies & (REPLY_HOST_A | REPLY_HOST_AAAA))) { -#if LWIP_IPV6 - if (!(outpkt->host_replies & REPLY_HOST_AAAA)) { - int addrindex; - for (addrindex = 0; addrindex < LWIP_IPV6_NUM_ADDRESSES; addrindex++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(outpkt->netif, addrindex))) { - res = mdns_add_aaaa_answer(outpkt, outpkt->cache_flush, outpkt->netif, addrindex); - if (res != ERR_OK) { - goto cleanup; - } - outpkt->additional++; - } - } - } -#endif -#if LWIP_IPV4 - if (!(outpkt->host_replies & REPLY_HOST_A) && - !ip4_addr_isany_val(*netif_ip4_addr(outpkt->netif))) { - res = mdns_add_a_answer(outpkt, outpkt->cache_flush, outpkt->netif); - if (res != ERR_OK) { - goto cleanup; - } - outpkt->additional++; - } -#endif - } - } - - if (outpkt->pbuf) { - const ip_addr_t *mcast_destaddr; - struct dns_hdr hdr; - - /* Write header */ - memset(&hdr, 0, sizeof(hdr)); - hdr.flags1 = flags; - hdr.numquestions = lwip_htons(outpkt->questions); - hdr.numanswers = lwip_htons(outpkt->answers); - hdr.numauthrr = lwip_htons(outpkt->authoritative); - hdr.numextrarr = lwip_htons(outpkt->additional); - hdr.id = lwip_htons(outpkt->tx_id); - pbuf_take(outpkt->pbuf, &hdr, sizeof(hdr)); - - /* Shrink packet */ - pbuf_realloc(outpkt->pbuf, outpkt->write_offset); - - if (IP_IS_V6_VAL(outpkt->dest_addr)) { -#if LWIP_IPV6 - mcast_destaddr = &v6group; -#endif - } else { -#if LWIP_IPV4 - mcast_destaddr = &v4group; -#endif - } - /* Send created packet */ - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Sending packet, len=%d, unicast=%d\n", outpkt->write_offset, outpkt->unicast_reply)); - if (outpkt->unicast_reply) { - res = udp_sendto_if(mdns_pcb, outpkt->pbuf, &outpkt->dest_addr, outpkt->dest_port, outpkt->netif); - } else { - res = udp_sendto_if(mdns_pcb, outpkt->pbuf, mcast_destaddr, LWIP_IANA_PORT_MDNS, outpkt->netif); - } - } - -cleanup: - if (outpkt->pbuf) { - pbuf_free(outpkt->pbuf); - outpkt->pbuf = NULL; - } - return res; -} - -/** - * Send unsolicited answer containing all our known data - * @param netif The network interface to send on - * @param destination The target address to send to (usually multicast address) - */ -static void -mdns_announce(struct netif *netif, const ip_addr_t *destination) -{ - struct mdns_outpacket announce; - int i; - struct mdns_host *mdns = NETIF_TO_HOST(netif); - - memset(&announce, 0, sizeof(announce)); - announce.netif = netif; - announce.cache_flush = 1; -#if LWIP_IPV4 - if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { - announce.host_replies = REPLY_HOST_A | REPLY_HOST_PTR_V4; - } -#endif -#if LWIP_IPV6 - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { - announce.host_replies |= REPLY_HOST_AAAA | REPLY_HOST_PTR_V6; - announce.host_reverse_v6_replies |= (1 << i); - } - } -#endif - - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - struct mdns_service *serv = mdns->services[i]; - if (serv) { - announce.serv_replies[i] = REPLY_SERVICE_TYPE_PTR | REPLY_SERVICE_NAME_PTR | - REPLY_SERVICE_SRV | REPLY_SERVICE_TXT; - } - } - - announce.dest_port = LWIP_IANA_PORT_MDNS; - SMEMCPY(&announce.dest_addr, destination, sizeof(announce.dest_addr)); - mdns_send_outpacket(&announce, DNS_FLAG1_RESPONSE | DNS_FLAG1_AUTHORATIVE); -} - -/** - * Handle question MDNS packet - * 1. Parse all questions and set bits what answers to send - * 2. Clear pending answers if known answers are supplied - * 3. Put chosen answers in new packet and send as reply - */ -static void -mdns_handle_question(struct mdns_packet *pkt) -{ - struct mdns_service *service; - struct mdns_outpacket reply; - int replies = 0; - int i; - err_t res; - struct mdns_host *mdns = NETIF_TO_HOST(pkt->netif); - - if (mdns->probing_state != MDNS_PROBING_COMPLETE) { - /* Don't answer questions until we've verified our domains via probing */ - /* @todo we should check incoming questions during probing for tiebreaking */ - return; - } - - mdns_init_outpacket(&reply, pkt); - - while (pkt->questions_left) { - struct mdns_question q; - - res = mdns_read_question(pkt, &q); - if (res != ERR_OK) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse question, skipping query packet\n")); - return; - } - - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Query for domain ")); - mdns_domain_debug_print(&q.info.domain); - LWIP_DEBUGF(MDNS_DEBUG, (" type %d class %d\n", q.info.type, q.info.klass)); - - if (q.unicast) { - /* Reply unicast if any question is unicast */ - reply.unicast_reply = 1; - } - - reply.host_replies |= check_host(pkt->netif, &q.info, &reply.host_reverse_v6_replies); - replies |= reply.host_replies; - - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - service = mdns->services[i]; - if (!service) { - continue; - } - reply.serv_replies[i] |= check_service(service, &q.info); - replies |= reply.serv_replies[i]; - } - - if (replies && reply.legacy_query) { - /* Add question to reply packet (legacy packet only has 1 question) */ - res = mdns_add_question(&reply, &q.info.domain, q.info.type, q.info.klass, 0); - reply.questions = 1; - if (res != ERR_OK) { - goto cleanup; - } - } - } - - /* Handle known answers */ - while (pkt->answers_left) { - struct mdns_answer ans; - u8_t rev_v6; - int match; - - res = mdns_read_answer(pkt, &ans); - if (res != ERR_OK) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse answer, skipping query packet\n")); - goto cleanup; - } - - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Known answer for domain ")); - mdns_domain_debug_print(&ans.info.domain); - LWIP_DEBUGF(MDNS_DEBUG, (" type %d class %d\n", ans.info.type, ans.info.klass)); - - - if (ans.info.type == DNS_RRTYPE_ANY || ans.info.klass == DNS_RRCLASS_ANY) { - /* Skip known answers for ANY type & class */ - continue; - } - - rev_v6 = 0; - match = reply.host_replies & check_host(pkt->netif, &ans.info, &rev_v6); - if (match && (ans.ttl > (mdns->dns_ttl / 2))) { - /* The RR in the known answer matches an RR we are planning to send, - * and the TTL is less than half gone. - * If the payload matches we should not send that answer. - */ - if (ans.info.type == DNS_RRTYPE_PTR) { - /* Read domain and compare */ - struct mdns_domain known_ans, my_ans; - u16_t len; - len = mdns_readname(pkt->pbuf, ans.rd_offset, &known_ans); - res = mdns_build_host_domain(&my_ans, mdns); - if (len != MDNS_READNAME_ERROR && res == ERR_OK && mdns_domain_eq(&known_ans, &my_ans)) { -#if LWIP_IPV4 - if (match & REPLY_HOST_PTR_V4) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: v4 PTR\n")); - reply.host_replies &= ~REPLY_HOST_PTR_V4; - } -#endif -#if LWIP_IPV6 - if (match & REPLY_HOST_PTR_V6) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: v6 PTR\n")); - reply.host_reverse_v6_replies &= ~rev_v6; - if (reply.host_reverse_v6_replies == 0) { - reply.host_replies &= ~REPLY_HOST_PTR_V6; - } - } -#endif - } - } else if (match & REPLY_HOST_A) { -#if LWIP_IPV4 - if (ans.rd_length == sizeof(ip4_addr_t) && - pbuf_memcmp(pkt->pbuf, ans.rd_offset, netif_ip4_addr(pkt->netif), ans.rd_length) == 0) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: A\n")); - reply.host_replies &= ~REPLY_HOST_A; - } -#endif - } else if (match & REPLY_HOST_AAAA) { -#if LWIP_IPV6 - if (ans.rd_length == sizeof(ip6_addr_p_t) && - /* TODO this clears all AAAA responses if first addr is set as known */ - pbuf_memcmp(pkt->pbuf, ans.rd_offset, netif_ip6_addr(pkt->netif, 0), ans.rd_length) == 0) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: AAAA\n")); - reply.host_replies &= ~REPLY_HOST_AAAA; - } -#endif - } - } - - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - service = mdns->services[i]; - if (!service) { - continue; - } - match = reply.serv_replies[i] & check_service(service, &ans.info); - if (match && (ans.ttl > (service->dns_ttl / 2))) { - /* The RR in the known answer matches an RR we are planning to send, - * and the TTL is less than half gone. - * If the payload matches we should not send that answer. - */ - if (ans.info.type == DNS_RRTYPE_PTR) { - /* Read domain and compare */ - struct mdns_domain known_ans, my_ans; - u16_t len; - len = mdns_readname(pkt->pbuf, ans.rd_offset, &known_ans); - if (len != MDNS_READNAME_ERROR) { - if (match & REPLY_SERVICE_TYPE_PTR) { - res = mdns_build_service_domain(&my_ans, service, 0); - if (res == ERR_OK && mdns_domain_eq(&known_ans, &my_ans)) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: service type PTR\n")); - reply.serv_replies[i] &= ~REPLY_SERVICE_TYPE_PTR; - } - } - if (match & REPLY_SERVICE_NAME_PTR) { - res = mdns_build_service_domain(&my_ans, service, 1); - if (res == ERR_OK && mdns_domain_eq(&known_ans, &my_ans)) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: service name PTR\n")); - reply.serv_replies[i] &= ~REPLY_SERVICE_NAME_PTR; - } - } - } - } else if (match & REPLY_SERVICE_SRV) { - /* Read and compare to my SRV record */ - u16_t field16, len, read_pos; - struct mdns_domain known_ans, my_ans; - read_pos = ans.rd_offset; - do { - /* Check priority field */ - len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); - if (len != sizeof(field16) || lwip_ntohs(field16) != SRV_PRIORITY) { - break; - } - read_pos += len; - /* Check weight field */ - len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); - if (len != sizeof(field16) || lwip_ntohs(field16) != SRV_WEIGHT) { - break; - } - read_pos += len; - /* Check port field */ - len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); - if (len != sizeof(field16) || lwip_ntohs(field16) != service->port) { - break; - } - read_pos += len; - /* Check host field */ - len = mdns_readname(pkt->pbuf, read_pos, &known_ans); - mdns_build_host_domain(&my_ans, mdns); - if (len == MDNS_READNAME_ERROR || !mdns_domain_eq(&known_ans, &my_ans)) { - break; - } - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: SRV\n")); - reply.serv_replies[i] &= ~REPLY_SERVICE_SRV; - } while (0); - } else if (match & REPLY_SERVICE_TXT) { - mdns_prepare_txtdata(service); - if (service->txtdata.length == ans.rd_length && - pbuf_memcmp(pkt->pbuf, ans.rd_offset, service->txtdata.name, ans.rd_length) == 0) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: TXT\n")); - reply.serv_replies[i] &= ~REPLY_SERVICE_TXT; - } - } - } - } - } - - mdns_send_outpacket(&reply, DNS_FLAG1_RESPONSE | DNS_FLAG1_AUTHORATIVE); - -cleanup: - if (reply.pbuf) { - /* This should only happen if we fail to alloc/write question for legacy query */ - pbuf_free(reply.pbuf); - reply.pbuf = NULL; - } -} - -/** - * Handle response MDNS packet - * Only prints debug for now. Will need more code to do conflict resolution. - */ -static void -mdns_handle_response(struct mdns_packet *pkt) -{ - struct mdns_host* mdns = NETIF_TO_HOST(pkt->netif); - - /* Ignore all questions */ - while (pkt->questions_left) { - struct mdns_question q; - err_t res; - - res = mdns_read_question(pkt, &q); - if (res != ERR_OK) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse question, skipping response packet\n")); - return; - } - } - - while (pkt->answers_left) { - struct mdns_answer ans; - err_t res; - - res = mdns_read_answer(pkt, &ans); - if (res != ERR_OK) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse answer, skipping response packet\n")); - return; - } - - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Answer for domain ")); - mdns_domain_debug_print(&ans.info.domain); - LWIP_DEBUGF(MDNS_DEBUG, (" type %d class %d\n", ans.info.type, ans.info.klass)); - - /*"Apparently conflicting Multicast DNS responses received *before* the first probe packet is sent MUST - be silently ignored" so drop answer if we haven't started probing yet*/ - if ((mdns->probing_state == MDNS_PROBING_ONGOING) && (mdns->probes_sent > 0)) { - struct mdns_domain domain; - u8_t i; - u8_t conflict = 0; - - res = mdns_build_host_domain(&domain, mdns); - if (res == ERR_OK && mdns_domain_eq(&ans.info.domain, &domain)) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Probe response matches host domain!")); - conflict = 1; - } - - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - struct mdns_service* service = mdns->services[i]; - if (!service) { - continue; - } - res = mdns_build_service_domain(&domain, service, 1); - if ((res == ERR_OK) && mdns_domain_eq(&ans.info.domain, &domain)) { - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Probe response matches service domain!")); - conflict = 1; - } - } - - if (conflict != 0) { - sys_untimeout(mdns_probe, pkt->netif); - if (mdns_name_result_cb != NULL) { - mdns_name_result_cb(pkt->netif, MDNS_PROBING_CONFLICT); - } - } - } - } -} - -/** - * Receive input function for MDNS packets. - * Handles both IPv4 and IPv6 UDP pcbs. - */ -static void -mdns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - struct dns_hdr hdr; - struct mdns_packet packet; - struct netif *recv_netif = ip_current_input_netif(); - u16_t offset = 0; - - LWIP_UNUSED_ARG(arg); - LWIP_UNUSED_ARG(pcb); - - LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Received IPv%d MDNS packet, len %d\n", IP_IS_V6(addr) ? 6 : 4, p->tot_len)); - - if (NETIF_TO_HOST(recv_netif) == NULL) { - /* From netif not configured for MDNS */ - goto dealloc; - } - - if (pbuf_copy_partial(p, &hdr, SIZEOF_DNS_HDR, offset) < SIZEOF_DNS_HDR) { - /* Too small */ - goto dealloc; - } - offset += SIZEOF_DNS_HDR; - - if (DNS_HDR_GET_OPCODE(&hdr)) { - /* Ignore non-standard queries in multicast packets (RFC 6762, section 18.3) */ - goto dealloc; - } - - memset(&packet, 0, sizeof(packet)); - SMEMCPY(&packet.source_addr, addr, sizeof(packet.source_addr)); - packet.source_port = port; - packet.netif = recv_netif; - packet.pbuf = p; - packet.parse_offset = offset; - packet.tx_id = lwip_ntohs(hdr.id); - packet.questions = packet.questions_left = lwip_ntohs(hdr.numquestions); - packet.answers = packet.answers_left = lwip_ntohs(hdr.numanswers) + lwip_ntohs(hdr.numauthrr) + lwip_ntohs(hdr.numextrarr); - -#if LWIP_IPV6 - if (IP_IS_V6(ip_current_dest_addr())) { - /* instead of having one 'v6group' per netif, just compare zoneless here */ - if (!ip_addr_cmp_zoneless(ip_current_dest_addr(), &v6group)) { - packet.recv_unicast = 1; - } - } -#endif -#if LWIP_IPV4 - if (!IP_IS_V6(ip_current_dest_addr())) { - if (!ip_addr_cmp(ip_current_dest_addr(), &v4group)) { - packet.recv_unicast = 1; - } - } -#endif - - if (hdr.flags1 & DNS_FLAG1_RESPONSE) { - mdns_handle_response(&packet); - } else { - mdns_handle_question(&packet); - } - -dealloc: - pbuf_free(p); -} - -#if LWIP_NETIF_EXT_STATUS_CALLBACK && MDNS_RESP_USENETIF_EXTCALLBACK -static void -mdns_netif_ext_status_callback(struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args) -{ - LWIP_UNUSED_ARG(args); - - /* MDNS enabled on netif? */ - if (NETIF_TO_HOST(netif) == NULL) { - return; - } - - if (reason & LWIP_NSC_STATUS_CHANGED) { - if (args->status_changed.state != 0) { - mdns_resp_restart(netif); - } - /* TODO: send goodbye message */ - } - if (reason & LWIP_NSC_LINK_CHANGED) { - if (args->link_changed.state != 0) { - mdns_resp_restart(netif); - } - } - if (reason & (LWIP_NSC_IPV4_ADDRESS_CHANGED | LWIP_NSC_IPV4_GATEWAY_CHANGED | - LWIP_NSC_IPV4_NETMASK_CHANGED | LWIP_NSC_IPV4_SETTINGS_CHANGED | - LWIP_NSC_IPV6_SET | LWIP_NSC_IPV6_ADDR_STATE_CHANGED)) { - mdns_resp_announce(netif); - } -} -#endif /* LWIP_NETIF_EXT_STATUS_CALLBACK && MDNS_RESP_USENETIF_EXTCALLBACK */ - -static err_t -mdns_send_probe(struct netif* netif, const ip_addr_t *destination) -{ - struct mdns_host* mdns; - struct mdns_outpacket pkt; - struct mdns_domain domain; - u8_t i; - err_t res; - - mdns = NETIF_TO_HOST(netif); - - memset(&pkt, 0, sizeof(pkt)); - pkt.netif = netif; - - /* Add unicast questions with rtype ANY for all our desired records */ - mdns_build_host_domain(&domain, mdns); - res = mdns_add_question(&pkt, &domain, DNS_RRTYPE_ANY, DNS_RRCLASS_IN, 1); - if (res != ERR_OK) { - goto cleanup; - } - pkt.questions++; - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - struct mdns_service* service = mdns->services[i]; - if (!service) { - continue; - } - mdns_build_service_domain(&domain, service, 1); - res = mdns_add_question(&pkt, &domain, DNS_RRTYPE_ANY, DNS_RRCLASS_IN, 1); - if (res != ERR_OK) { - goto cleanup; - } - pkt.questions++; - } - - /* Add answers to the questions above into the authority section for tiebreaking */ -#if LWIP_IPV4 - if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { - pkt.host_replies = REPLY_HOST_A; - } -#endif -#if LWIP_IPV6 - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { - pkt.host_replies |= REPLY_HOST_AAAA; - } - } -#endif - - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - struct mdns_service *serv = mdns->services[i]; - if (serv) { - pkt.serv_replies[i] = REPLY_SERVICE_SRV | REPLY_SERVICE_TXT; - } - } - - pkt.tx_id = 0; - pkt.dest_port = LWIP_IANA_PORT_MDNS; - SMEMCPY(&pkt.dest_addr, destination, sizeof(pkt.dest_addr)); - res = mdns_send_outpacket(&pkt, 0); - -cleanup: - if (pkt.pbuf) { - pbuf_free(pkt.pbuf); - pkt.pbuf = NULL; - } - return res; -} - -/** - * Timer callback for probing network. - */ -static void -mdns_probe(void* arg) -{ - struct netif *netif = (struct netif *)arg; - struct mdns_host* mdns = NETIF_TO_HOST(netif); - - if(mdns->probes_sent >= MDNS_PROBE_COUNT) { - /* probing successful, announce the new name */ - mdns->probing_state = MDNS_PROBING_COMPLETE; - mdns_resp_announce(netif); - if (mdns_name_result_cb != NULL) { - mdns_name_result_cb(netif, MDNS_PROBING_SUCCESSFUL); - } - } else { -#if LWIP_IPV4 - /*if ipv4 wait with probing until address is set*/ - if (!ip4_addr_isany_val(*netif_ip4_addr(netif)) && - mdns_send_probe(netif, IP4_ADDR_ANY) == ERR_OK) -#endif - { -#if LWIP_IPV6 - if (mdns_send_probe(netif, IP6_ADDR_ANY) == ERR_OK) -#endif - { - mdns->probes_sent++; - } - } - sys_timeout(MDNS_PROBE_DELAY_MS, mdns_probe, netif); - } -} - -/** - * @ingroup mdns - * Activate MDNS responder for a network interface. - * @param netif The network interface to activate. - * @param hostname Name to use. Queries for <hostname>.local will be answered - * with the IP addresses of the netif. The hostname will be copied, the - * given pointer can be on the stack. - * @param dns_ttl Validity time in seconds to send out for IP address data in DNS replies - * @return ERR_OK if netif was added, an err_t otherwise - */ -err_t -mdns_resp_add_netif(struct netif *netif, const char *hostname, u32_t dns_ttl) -{ - err_t res; - struct mdns_host *mdns; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ERROR("mdns_resp_add_netif: netif != NULL", (netif != NULL), return ERR_VAL); - LWIP_ERROR("mdns_resp_add_netif: Hostname too long", (strlen(hostname) <= MDNS_LABEL_MAXLEN), return ERR_VAL); - - LWIP_ASSERT("mdns_resp_add_netif: Double add", NETIF_TO_HOST(netif) == NULL); - mdns = (struct mdns_host *) mem_calloc(1, sizeof(struct mdns_host)); - LWIP_ERROR("mdns_resp_add_netif: Alloc failed", (mdns != NULL), return ERR_MEM); - - netif_set_client_data(netif, mdns_netif_client_id, mdns); - - MEMCPY(&mdns->name, hostname, LWIP_MIN(MDNS_LABEL_MAXLEN, strlen(hostname))); - mdns->dns_ttl = dns_ttl; - mdns->probes_sent = 0; - mdns->probing_state = MDNS_PROBING_NOT_STARTED; - - /* Join multicast groups */ -#if LWIP_IPV4 - res = igmp_joingroup_netif(netif, ip_2_ip4(&v4group)); - if (res != ERR_OK) { - goto cleanup; - } -#endif -#if LWIP_IPV6 - res = mld6_joingroup_netif(netif, ip_2_ip6(&v6group)); - if (res != ERR_OK) { - goto cleanup; - } -#endif - - mdns_resp_restart(netif); - - return ERR_OK; - -cleanup: - mem_free(mdns); - netif_set_client_data(netif, mdns_netif_client_id, NULL); - return res; -} - -/** - * @ingroup mdns - * Stop responding to MDNS queries on this interface, leave multicast groups, - * and free the helper structure and any of its services. - * @param netif The network interface to remove. - * @return ERR_OK if netif was removed, an err_t otherwise - */ -err_t -mdns_resp_remove_netif(struct netif *netif) -{ - int i; - struct mdns_host *mdns; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mdns_resp_remove_netif: Null pointer", netif); - mdns = NETIF_TO_HOST(netif); - LWIP_ERROR("mdns_resp_remove_netif: Not an active netif", (mdns != NULL), return ERR_VAL); - - if (mdns->probing_state == MDNS_PROBING_ONGOING) { - sys_untimeout(mdns_probe, netif); - } - - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - struct mdns_service *service = mdns->services[i]; - if (service) { - mem_free(service); - } - } - - /* Leave multicast groups */ -#if LWIP_IPV4 - igmp_leavegroup_netif(netif, ip_2_ip4(&v4group)); -#endif -#if LWIP_IPV6 - mld6_leavegroup_netif(netif, ip_2_ip6(&v6group)); -#endif - - mem_free(mdns); - netif_set_client_data(netif, mdns_netif_client_id, NULL); - return ERR_OK; -} - -/** - * @ingroup mdns - * Update MDNS hostname for a network interface. - * @param netif The network interface to activate. - * @param hostname Name to use. Queries for <hostname>.local will be answered - * with the IP addresses of the netif. The hostname will be copied, the - * given pointer can be on the stack. - * @return ERR_OK if name could be set on netif, an err_t otherwise - */ -err_t -mdns_resp_rename_netif(struct netif *netif, const char *hostname) -{ - struct mdns_host *mdns; - size_t len; - - LWIP_ASSERT_CORE_LOCKED(); - len = strlen(hostname); - LWIP_ERROR("mdns_resp_rename_netif: netif != NULL", (netif != NULL), return ERR_VAL); - LWIP_ERROR("mdns_resp_rename_netif: Hostname too long", (len <= MDNS_LABEL_MAXLEN), return ERR_VAL); - mdns = NETIF_TO_HOST(netif); - LWIP_ERROR("mdns_resp_rename_netif: Not an mdns netif", (mdns != NULL), return ERR_VAL); - - MEMCPY(&mdns->name, hostname, LWIP_MIN(MDNS_LABEL_MAXLEN, len)); - mdns->name[len] = '\0'; /* null termination in case new name is shorter than previous */ - - mdns_resp_restart(netif); - - return ERR_OK; -} - -/** - * @ingroup mdns - * Add a service to the selected network interface. - * @param netif The network interface to publish this service on - * @param name The name of the service - * @param service The service type, like "_http" - * @param proto The service protocol, DNSSD_PROTO_TCP for TCP ("_tcp") and DNSSD_PROTO_UDP - * for others ("_udp") - * @param port The port the service listens to - * @param dns_ttl Validity time in seconds to send out for service data in DNS replies - * @param txt_fn Callback to get TXT data. Will be called each time a TXT reply is created to - * allow dynamic replies. - * @param txt_data Userdata pointer for txt_fn - * @return service_id if the service was added to the netif, an err_t otherwise - */ -s8_t -mdns_resp_add_service(struct netif *netif, const char *name, const char *service, enum mdns_sd_proto proto, u16_t port, u32_t dns_ttl, service_get_txt_fn_t txt_fn, void *txt_data) -{ - s8_t i; - s8_t slot = -1; - struct mdns_service *srv; - struct mdns_host *mdns; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mdns_resp_add_service: netif != NULL", netif); - mdns = NETIF_TO_HOST(netif); - LWIP_ERROR("mdns_resp_add_service: Not an mdns netif", (mdns != NULL), return ERR_VAL); - - LWIP_ERROR("mdns_resp_add_service: Name too long", (strlen(name) <= MDNS_LABEL_MAXLEN), return ERR_VAL); - LWIP_ERROR("mdns_resp_add_service: Service too long", (strlen(service) <= MDNS_LABEL_MAXLEN), return ERR_VAL); - LWIP_ERROR("mdns_resp_add_service: Bad proto (need TCP or UDP)", (proto == DNSSD_PROTO_TCP || proto == DNSSD_PROTO_UDP), return ERR_VAL); - - for (i = 0; i < MDNS_MAX_SERVICES; i++) { - if (mdns->services[i] == NULL) { - slot = i; - break; - } - } - LWIP_ERROR("mdns_resp_add_service: Service list full (increase MDNS_MAX_SERVICES)", (slot >= 0), return ERR_MEM); - - srv = (struct mdns_service *)mem_calloc(1, sizeof(struct mdns_service)); - LWIP_ERROR("mdns_resp_add_service: Alloc failed", (srv != NULL), return ERR_MEM); - - MEMCPY(&srv->name, name, LWIP_MIN(MDNS_LABEL_MAXLEN, strlen(name))); - MEMCPY(&srv->service, service, LWIP_MIN(MDNS_LABEL_MAXLEN, strlen(service))); - srv->txt_fn = txt_fn; - srv->txt_userdata = txt_data; - srv->proto = (u16_t)proto; - srv->port = port; - srv->dns_ttl = dns_ttl; - - mdns->services[slot] = srv; - - mdns_resp_restart(netif); - - return slot; -} - -/** - * @ingroup mdns - * Delete a service on the selected network interface. - * @param netif The network interface on which service should be removed - * @param slot The service slot number returned by mdns_resp_add_service - * @return ERR_OK if the service was removed from the netif, an err_t otherwise - */ -err_t -mdns_resp_del_service(struct netif *netif, s8_t slot) -{ - struct mdns_host *mdns; - struct mdns_service *srv; - LWIP_ASSERT("mdns_resp_del_service: netif != NULL", netif); - mdns = NETIF_TO_HOST(netif); - LWIP_ERROR("mdns_resp_del_service: Not an mdns netif", (mdns != NULL), return ERR_VAL); - LWIP_ERROR("mdns_resp_del_service: Invalid Service ID", (slot >= 0) && (slot < MDNS_MAX_SERVICES), return ERR_VAL); - LWIP_ERROR("mdns_resp_del_service: Invalid Service ID", (mdns->services[slot] != NULL), return ERR_VAL); - - srv = mdns->services[slot]; - mdns->services[slot] = NULL; - mem_free(srv); - return ERR_OK; -} - -/** - * @ingroup mdns - * Update name for an MDNS service. - * @param netif The network interface to activate. - * @param slot The service slot number returned by mdns_resp_add_service - * @param name The new name for the service - * @return ERR_OK if name could be set on service, an err_t otherwise - */ -err_t -mdns_resp_rename_service(struct netif *netif, s8_t slot, const char *name) -{ - struct mdns_service *srv; - struct mdns_host *mdns; - size_t len; - - LWIP_ASSERT_CORE_LOCKED(); - len = strlen(name); - LWIP_ASSERT("mdns_resp_rename_service: netif != NULL", netif); - mdns = NETIF_TO_HOST(netif); - LWIP_ERROR("mdns_resp_rename_service: Not an mdns netif", (mdns != NULL), return ERR_VAL); - LWIP_ERROR("mdns_resp_rename_service: Name too long", (len <= MDNS_LABEL_MAXLEN), return ERR_VAL); - LWIP_ERROR("mdns_resp_rename_service: Invalid Service ID", (slot >= 0) && (slot < MDNS_MAX_SERVICES), return ERR_VAL); - LWIP_ERROR("mdns_resp_rename_service: Invalid Service ID", (mdns->services[slot] != NULL), return ERR_VAL); - - srv = mdns->services[slot]; - - MEMCPY(&srv->name, name, LWIP_MIN(MDNS_LABEL_MAXLEN, len)); - srv->name[len] = '\0'; /* null termination in case new name is shorter than previous */ - - mdns_resp_restart(netif); - - return ERR_OK; -} - -/** - * @ingroup mdns - * Call this function from inside the service_get_txt_fn_t callback to add text data. - * Buffer for TXT data is 256 bytes, and each field is prefixed with a length byte. - * @param service The service provided to the get_txt callback - * @param txt String to add to the TXT field. - * @param txt_len Length of string - * @return ERR_OK if the string was added to the reply, an err_t otherwise - */ -err_t -mdns_resp_add_service_txtitem(struct mdns_service *service, const char *txt, u8_t txt_len) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mdns_resp_add_service_txtitem: service != NULL", service); - - /* Use a mdns_domain struct to store txt chunks since it is the same encoding */ - return mdns_domain_add_label(&service->txtdata, txt, txt_len); -} - -/** - * @ingroup mdns - * Send unsolicited answer containing all our known data - * @param netif The network interface to send on - */ -void -mdns_resp_announce(struct netif *netif) -{ - struct mdns_host* mdns; - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ERROR("mdns_resp_announce: netif != NULL", (netif != NULL), return); - - mdns = NETIF_TO_HOST(netif); - if (mdns == NULL) { - return; - } - - if (mdns->probing_state == MDNS_PROBING_COMPLETE) { - /* Announce on IPv6 and IPv4 */ -#if LWIP_IPV6 - mdns_announce(netif, IP6_ADDR_ANY); -#endif -#if LWIP_IPV4 - if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { - mdns_announce(netif, IP4_ADDR_ANY); - } -#endif - } /* else: ip address changed while probing was ongoing? @todo reset counter to restart? */ -} - -/** Register a callback function that is called if probing is completed successfully - * or with a conflict. */ -void -mdns_resp_register_name_result_cb(mdns_name_result_cb_t cb) -{ - mdns_name_result_cb = cb; -} - -/** - * @ingroup mdns - * Restart mdns responder. Call this when cable is connected after being disconnected or - * administrative interface is set up after being down - * @param netif The network interface to send on - */ -void -mdns_resp_restart(struct netif *netif) -{ - struct mdns_host* mdns; - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ERROR("mdns_resp_restart: netif != NULL", (netif != NULL), return); - - mdns = NETIF_TO_HOST(netif); - if (mdns == NULL) { - return; - } - - if (mdns->probing_state == MDNS_PROBING_ONGOING) { - sys_untimeout(mdns_probe, netif); - } - /* @todo if we've failed 15 times within a 10 second period we MUST wait 5 seconds (or wait 5 seconds every time except first)*/ - mdns->probes_sent = 0; - mdns->probing_state = MDNS_PROBING_ONGOING; - sys_timeout(MDNS_INITIAL_PROBE_DELAY_MS, mdns_probe, netif); -} - -/** - * @ingroup mdns - * Initiate MDNS responder. Will open UDP sockets on port 5353 - */ -void -mdns_resp_init(void) -{ - err_t res; - - /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ - - mdns_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); - LWIP_ASSERT("Failed to allocate pcb", mdns_pcb != NULL); -#if LWIP_MULTICAST_TX_OPTIONS - udp_set_multicast_ttl(mdns_pcb, MDNS_TTL); -#else - mdns_pcb->ttl = MDNS_TTL; -#endif - res = udp_bind(mdns_pcb, IP_ANY_TYPE, LWIP_IANA_PORT_MDNS); - LWIP_UNUSED_ARG(res); /* in case of LWIP_NOASSERT */ - LWIP_ASSERT("Failed to bind pcb", res == ERR_OK); - udp_recv(mdns_pcb, mdns_recv, NULL); - - mdns_netif_client_id = netif_alloc_client_data_id(); - -#if MDNS_RESP_USENETIF_EXTCALLBACK - /* register for netif events when started on first netif */ - netif_add_ext_callback(&netif_callback, mdns_netif_ext_status_callback); -#endif -} - -#endif /* LWIP_MDNS_RESPONDER */ +/** + * @file + * MDNS responder implementation + * + * @defgroup mdns MDNS + * @ingroup apps + * + * RFC 6762 - Multicast DNS\n + * RFC 6763 - DNS-Based Service Discovery\n + * + * @verbinclude mdns.txt + * + * Things left to implement: + * ------------------------- + * + * - Tiebreaking for simultaneous probing + * - Sending goodbye messages (zero ttl) - shutdown, DHCP lease about to expire, DHCP turned off... + * - Checking that source address of unicast requests are on the same network + * - Limiting multicast responses to 1 per second per resource record + * - Fragmenting replies if required + * - Handling multi-packet known answers + * - Individual known answer detection for all local IPv6 addresses + * - Dynamic size of outgoing packet + */ + +/* + * Copyright (c) 2015 Verisure Innovation AB + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Erik Ekman + * + */ + +#include "lwip/apps/mdns.h" +#include "lwip/apps/mdns_priv.h" +#include "lwip/netif.h" +#include "lwip/udp.h" +#include "lwip/ip_addr.h" +#include "lwip/mem.h" +#include "lwip/prot/dns.h" +#include "lwip/prot/iana.h" +#include "lwip/timeouts.h" + +#include + +#if LWIP_MDNS_RESPONDER + +#if (LWIP_IPV4 && !LWIP_IGMP) +#error "If you want to use MDNS with IPv4, you have to define LWIP_IGMP=1 in your lwipopts.h" +#endif +#if (LWIP_IPV6 && !LWIP_IPV6_MLD) +#error "If you want to use MDNS with IPv6, you have to define LWIP_IPV6_MLD=1 in your lwipopts.h" +#endif +#if (!LWIP_UDP) +#error "If you want to use MDNS, you have to define LWIP_UDP=1 in your lwipopts.h" +#endif + +#if LWIP_IPV4 +#include "lwip/igmp.h" +/* IPv4 multicast group 224.0.0.251 */ +static const ip_addr_t v4group = DNS_MQUERY_IPV4_GROUP_INIT; +#endif + +#if LWIP_IPV6 +#include "lwip/mld6.h" +/* IPv6 multicast group FF02::FB */ +static const ip_addr_t v6group = DNS_MQUERY_IPV6_GROUP_INIT; +#endif + +#define MDNS_TTL 255 + +/* Stored offsets to beginning of domain names + * Used for compression. + */ +#define NUM_DOMAIN_OFFSETS 10 +#define DOMAIN_JUMP_SIZE 2 +#define DOMAIN_JUMP 0xc000 + +static u8_t mdns_netif_client_id; +static struct udp_pcb *mdns_pcb; +#if MDNS_RESP_USENETIF_EXTCALLBACK +NETIF_DECLARE_EXT_CALLBACK(netif_callback) +#endif +static mdns_name_result_cb_t mdns_name_result_cb; + +#define NETIF_TO_HOST(netif) (struct mdns_host*)(netif_get_client_data(netif, mdns_netif_client_id)) + +#define TOPDOMAIN_LOCAL "local" + +#define REVERSE_PTR_TOPDOMAIN "arpa" +#define REVERSE_PTR_V4_DOMAIN "in-addr" +#define REVERSE_PTR_V6_DOMAIN "ip6" + +#define SRV_PRIORITY 0 +#define SRV_WEIGHT 0 + +/* Payload size allocated for each outgoing UDP packet */ +#define OUTPACKET_SIZE 500 + +/* Lookup from hostname -> IPv4 */ +#define REPLY_HOST_A 0x01 +/* Lookup from IPv4/v6 -> hostname */ +#define REPLY_HOST_PTR_V4 0x02 +/* Lookup from hostname -> IPv6 */ +#define REPLY_HOST_AAAA 0x04 +/* Lookup from hostname -> IPv6 */ +#define REPLY_HOST_PTR_V6 0x08 + +/* Lookup for service types */ +#define REPLY_SERVICE_TYPE_PTR 0x10 +/* Lookup for instances of service */ +#define REPLY_SERVICE_NAME_PTR 0x20 +/* Lookup for location of service instance */ +#define REPLY_SERVICE_SRV 0x40 +/* Lookup for text info on service instance */ +#define REPLY_SERVICE_TXT 0x80 + +#define MDNS_PROBE_DELAY_MS 250 +#define MDNS_PROBE_COUNT 3 +#ifdef LWIP_RAND +/* first probe timeout SHOULD be random 0-250 ms*/ +#define MDNS_INITIAL_PROBE_DELAY_MS (LWIP_RAND() % MDNS_PROBE_DELAY_MS) +#else +#define MDNS_INITIAL_PROBE_DELAY_MS MDNS_PROBE_DELAY_MS +#endif + +#define MDNS_PROBING_NOT_STARTED 0 +#define MDNS_PROBING_ONGOING 1 +#define MDNS_PROBING_COMPLETE 2 + +static const char *dnssd_protos[] = { + "_udp", /* DNSSD_PROTO_UDP */ + "_tcp", /* DNSSD_PROTO_TCP */ +}; + +/** Description of a service */ +struct mdns_service { + /** TXT record to answer with */ + struct mdns_domain txtdata; + /** Name of service, like 'myweb' */ + char name[MDNS_LABEL_MAXLEN + 1]; + /** Type of service, like '_http' */ + char service[MDNS_LABEL_MAXLEN + 1]; + /** Callback function and userdata + * to update txtdata buffer */ + service_get_txt_fn_t txt_fn; + void *txt_userdata; + /** TTL in seconds of SRV/TXT replies */ + u32_t dns_ttl; + /** Protocol, TCP or UDP */ + u16_t proto; + /** Port of the service */ + u16_t port; +}; + +/** Description of a host/netif */ +struct mdns_host { + /** Hostname */ + char name[MDNS_LABEL_MAXLEN + 1]; + /** Pointer to services */ + struct mdns_service *services[MDNS_MAX_SERVICES]; + /** TTL in seconds of A/AAAA/PTR replies */ + u32_t dns_ttl; + /** Number of probes sent for the current name */ + u8_t probes_sent; + /** State in probing sequence */ + u8_t probing_state; +}; + +/** Information about received packet */ +struct mdns_packet { + /** Sender IP/port */ + ip_addr_t source_addr; + u16_t source_port; + /** If packet was received unicast */ + u16_t recv_unicast; + /** Netif that received the packet */ + struct netif *netif; + /** Packet data */ + struct pbuf *pbuf; + /** Current parsing offset in packet */ + u16_t parse_offset; + /** Identifier. Used in legacy queries */ + u16_t tx_id; + /** Number of questions in packet, + * read from packet header */ + u16_t questions; + /** Number of unparsed questions */ + u16_t questions_left; + /** Number of answers in packet, + * (sum of normal, authoritative and additional answers) + * read from packet header */ + u16_t answers; + /** Number of unparsed answers */ + u16_t answers_left; +}; + +/** Information about outgoing packet */ +struct mdns_outpacket { + /** Netif to send the packet on */ + struct netif *netif; + /** Packet data */ + struct pbuf *pbuf; + /** Current write offset in packet */ + u16_t write_offset; + /** Identifier. Used in legacy queries */ + u16_t tx_id; + /** Destination IP/port if sent unicast */ + ip_addr_t dest_addr; + u16_t dest_port; + /** Number of questions written */ + u16_t questions; + /** Number of normal answers written */ + u16_t answers; + /** Number of authoritative answers written */ + u16_t authoritative; + /** Number of additional answers written */ + u16_t additional; + /** Offsets for written domain names in packet. + * Used for compression */ + u16_t domain_offsets[NUM_DOMAIN_OFFSETS]; + /** If all answers in packet should set cache_flush bit */ + u8_t cache_flush; + /** If reply should be sent unicast */ + u8_t unicast_reply; + /** If legacy query. (tx_id needed, and write + * question again in reply before answer) */ + u8_t legacy_query; + /* Reply bitmask for host information */ + u8_t host_replies; + /* Bitmask for which reverse IPv6 hosts to answer */ + u8_t host_reverse_v6_replies; + /* Reply bitmask per service */ + u8_t serv_replies[MDNS_MAX_SERVICES]; +}; + +/** Domain, type and class. + * Shared between questions and answers */ +struct mdns_rr_info { + struct mdns_domain domain; + u16_t type; + u16_t klass; +}; + +struct mdns_question { + struct mdns_rr_info info; + /** unicast reply requested */ + u16_t unicast; +}; + +struct mdns_answer { + struct mdns_rr_info info; + /** cache flush command bit */ + u16_t cache_flush; + /* Validity time in seconds */ + u32_t ttl; + /** Length of variable answer */ + u16_t rd_length; + /** Offset of start of variable answer in packet */ + u16_t rd_offset; +}; + +static err_t mdns_send_outpacket(struct mdns_outpacket *outpkt, u8_t flags); +static void mdns_probe(void* arg); + +static err_t +mdns_domain_add_label_base(struct mdns_domain *domain, u8_t len) +{ + if (len > MDNS_LABEL_MAXLEN) { + return ERR_VAL; + } + if (len > 0 && (1 + len + domain->length >= MDNS_DOMAIN_MAXLEN)) { + return ERR_VAL; + } + /* Allow only zero marker on last byte */ + if (len == 0 && (1 + domain->length > MDNS_DOMAIN_MAXLEN)) { + return ERR_VAL; + } + domain->name[domain->length] = len; + domain->length++; + return ERR_OK; +} + +/** + * Add a label part to a domain + * @param domain The domain to add a label to + * @param label The label to add, like <hostname>, 'local', 'com' or '' + * @param len The length of the label + * @return ERR_OK on success, an err_t otherwise if label too long + */ +err_t +mdns_domain_add_label(struct mdns_domain *domain, const char *label, u8_t len) +{ + err_t err = mdns_domain_add_label_base(domain, len); + if (err != ERR_OK) { + return err; + } + if (len) { + MEMCPY(&domain->name[domain->length], label, len); + domain->length += len; + } + return ERR_OK; +} + +/** + * Add a label part to a domain (@see mdns_domain_add_label but copy directly from pbuf) + */ +static err_t +mdns_domain_add_label_pbuf(struct mdns_domain *domain, const struct pbuf *p, u16_t offset, u8_t len) +{ + err_t err = mdns_domain_add_label_base(domain, len); + if (err != ERR_OK) { + return err; + } + if (len) { + if (pbuf_copy_partial(p, &domain->name[domain->length], len, offset) != len) { + /* take back the ++ done before */ + domain->length--; + return ERR_ARG; + } + domain->length += len; + } + return ERR_OK; +} + +/** + * Internal readname function with max 6 levels of recursion following jumps + * while decompressing name + */ +static u16_t +mdns_readname_loop(struct pbuf *p, u16_t offset, struct mdns_domain *domain, unsigned depth) +{ + u8_t c; + + do { + if (depth > 5) { + /* Too many jumps */ + return MDNS_READNAME_ERROR; + } + + c = pbuf_get_at(p, offset); + offset++; + + /* is this a compressed label? */ + if ((c & 0xc0) == 0xc0) { + u16_t jumpaddr; + if (offset >= p->tot_len) { + /* Make sure both jump bytes fit in the packet */ + return MDNS_READNAME_ERROR; + } + jumpaddr = (((c & 0x3f) << 8) | (pbuf_get_at(p, offset) & 0xff)); + offset++; + if (jumpaddr >= SIZEOF_DNS_HDR && jumpaddr < p->tot_len) { + u16_t res; + /* Recursive call, maximum depth will be checked */ + res = mdns_readname_loop(p, jumpaddr, domain, depth + 1); + /* Dont return offset since new bytes were not read (jumped to somewhere in packet) */ + if (res == MDNS_READNAME_ERROR) { + return res; + } + } else { + return MDNS_READNAME_ERROR; + } + break; + } + + /* normal label */ + if (c <= MDNS_LABEL_MAXLEN) { + err_t res; + + if (c + domain->length >= MDNS_DOMAIN_MAXLEN) { + return MDNS_READNAME_ERROR; + } + res = mdns_domain_add_label_pbuf(domain, p, offset, c); + if (res != ERR_OK) { + return MDNS_READNAME_ERROR; + } + offset += c; + } else { + /* bad length byte */ + return MDNS_READNAME_ERROR; + } + } while (c != 0); + + return offset; +} + +/** + * Read possibly compressed domain name from packet buffer + * @param p The packet + * @param offset start position of domain name in packet + * @param domain The domain name destination + * @return The new offset after the domain, or MDNS_READNAME_ERROR + * if reading failed + */ +u16_t +mdns_readname(struct pbuf *p, u16_t offset, struct mdns_domain *domain) +{ + memset(domain, 0, sizeof(struct mdns_domain)); + return mdns_readname_loop(p, offset, domain, 0); +} + +/** + * Print domain name to debug output + * @param domain The domain name + */ +static void +mdns_domain_debug_print(struct mdns_domain *domain) +{ + u8_t *src = domain->name; + u8_t i; + + while (*src) { + u8_t label_len = *src; + src++; + for (i = 0; i < label_len; i++) { + LWIP_DEBUGF(MDNS_DEBUG, ("%c", src[i])); + } + src += label_len; + LWIP_DEBUGF(MDNS_DEBUG, (".")); + } +} + +/** + * Return 1 if contents of domains match (case-insensitive) + * @param a Domain name to compare 1 + * @param b Domain name to compare 2 + * @return 1 if domains are equal ignoring case, 0 otherwise + */ +int +mdns_domain_eq(struct mdns_domain *a, struct mdns_domain *b) +{ + u8_t *ptra, *ptrb; + u8_t len; + int res; + + if (a->length != b->length) { + return 0; + } + + ptra = a->name; + ptrb = b->name; + while (*ptra && *ptrb && ptra < &a->name[a->length]) { + if (*ptra != *ptrb) { + return 0; + } + len = *ptra; + ptra++; + ptrb++; + res = lwip_strnicmp((char *) ptra, (char *) ptrb, len); + if (res != 0) { + return 0; + } + ptra += len; + ptrb += len; + } + if (*ptra != *ptrb && ptra < &a->name[a->length]) { + return 0; + } + return 1; +} + +/** + * Call user supplied function to setup TXT data + * @param service The service to build TXT record for + */ +static void +mdns_prepare_txtdata(struct mdns_service *service) +{ + memset(&service->txtdata, 0, sizeof(struct mdns_domain)); + if (service->txt_fn) { + service->txt_fn(service, service->txt_userdata); + } +} + +#if LWIP_IPV4 +/** + * Build domain for reverse lookup of IPv4 address + * like 12.0.168.192.in-addr.arpa. for 192.168.0.12 + * @param domain Where to write the domain name + * @param addr Pointer to an IPv4 address to encode + * @return ERR_OK if domain was written, an err_t otherwise + */ +static err_t +mdns_build_reverse_v4_domain(struct mdns_domain *domain, const ip4_addr_t *addr) +{ + int i; + err_t res; + const u8_t *ptr; + + LWIP_UNUSED_ARG(res); + if (!domain || !addr) { + return ERR_ARG; + } + memset(domain, 0, sizeof(struct mdns_domain)); + ptr = (const u8_t *) addr; + for (i = sizeof(ip4_addr_t) - 1; i >= 0; i--) { + char buf[4]; + u8_t val = ptr[i]; + + lwip_itoa(buf, sizeof(buf), val); + res = mdns_domain_add_label(domain, buf, (u8_t)strlen(buf)); + LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); + } + res = mdns_domain_add_label(domain, REVERSE_PTR_V4_DOMAIN, (u8_t)(sizeof(REVERSE_PTR_V4_DOMAIN) - 1)); + LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); + res = mdns_domain_add_label(domain, REVERSE_PTR_TOPDOMAIN, (u8_t)(sizeof(REVERSE_PTR_TOPDOMAIN) - 1)); + LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); + res = mdns_domain_add_label(domain, NULL, 0); + LWIP_ERROR("mdns_build_reverse_v4_domain: Failed to add label", (res == ERR_OK), return res); + + return ERR_OK; +} +#endif + +#if LWIP_IPV6 +/** + * Build domain for reverse lookup of IP address + * like b.a.9.8.7.6.5.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa. for 2001:db8::567:89ab + * @param domain Where to write the domain name + * @param addr Pointer to an IPv6 address to encode + * @return ERR_OK if domain was written, an err_t otherwise + */ +static err_t +mdns_build_reverse_v6_domain(struct mdns_domain *domain, const ip6_addr_t *addr) +{ + int i; + err_t res; + const u8_t *ptr; + LWIP_UNUSED_ARG(res); + if (!domain || !addr) { + return ERR_ARG; + } + memset(domain, 0, sizeof(struct mdns_domain)); + ptr = (const u8_t *) addr; + for (i = sizeof(ip6_addr_p_t) - 1; i >= 0; i--) { + char buf; + u8_t byte = ptr[i]; + int j; + for (j = 0; j < 2; j++) { + if ((byte & 0x0F) < 0xA) { + buf = '0' + (byte & 0x0F); + } else { + buf = 'a' + (byte & 0x0F) - 0xA; + } + res = mdns_domain_add_label(domain, &buf, sizeof(buf)); + LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); + byte >>= 4; + } + } + res = mdns_domain_add_label(domain, REVERSE_PTR_V6_DOMAIN, (u8_t)(sizeof(REVERSE_PTR_V6_DOMAIN) - 1)); + LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); + res = mdns_domain_add_label(domain, REVERSE_PTR_TOPDOMAIN, (u8_t)(sizeof(REVERSE_PTR_TOPDOMAIN) - 1)); + LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); + res = mdns_domain_add_label(domain, NULL, 0); + LWIP_ERROR("mdns_build_reverse_v6_domain: Failed to add label", (res == ERR_OK), return res); + + return ERR_OK; +} +#endif + +/* Add .local. to domain */ +static err_t +mdns_add_dotlocal(struct mdns_domain *domain) +{ + err_t res = mdns_domain_add_label(domain, TOPDOMAIN_LOCAL, (u8_t)(sizeof(TOPDOMAIN_LOCAL) - 1)); + LWIP_UNUSED_ARG(res); + LWIP_ERROR("mdns_add_dotlocal: Failed to add label", (res == ERR_OK), return res); + return mdns_domain_add_label(domain, NULL, 0); +} + +/** + * Build the .local. domain name + * @param domain Where to write the domain name + * @param mdns TMDNS netif descriptor. + * @return ERR_OK if domain .local. was written, an err_t otherwise + */ +static err_t +mdns_build_host_domain(struct mdns_domain *domain, struct mdns_host *mdns) +{ + err_t res; + LWIP_UNUSED_ARG(res); + memset(domain, 0, sizeof(struct mdns_domain)); + LWIP_ERROR("mdns_build_host_domain: mdns != NULL", (mdns != NULL), return ERR_VAL); + res = mdns_domain_add_label(domain, mdns->name, (u8_t)strlen(mdns->name)); + LWIP_ERROR("mdns_build_host_domain: Failed to add label", (res == ERR_OK), return res); + return mdns_add_dotlocal(domain); +} + +/** + * Build the lookup-all-services special DNS-SD domain name + * @param domain Where to write the domain name + * @return ERR_OK if domain _services._dns-sd._udp.local. was written, an err_t otherwise + */ +static err_t +mdns_build_dnssd_domain(struct mdns_domain *domain) +{ + err_t res; + LWIP_UNUSED_ARG(res); + memset(domain, 0, sizeof(struct mdns_domain)); + res = mdns_domain_add_label(domain, "_services", (u8_t)(sizeof("_services") - 1)); + LWIP_ERROR("mdns_build_dnssd_domain: Failed to add label", (res == ERR_OK), return res); + res = mdns_domain_add_label(domain, "_dns-sd", (u8_t)(sizeof("_dns-sd") - 1)); + LWIP_ERROR("mdns_build_dnssd_domain: Failed to add label", (res == ERR_OK), return res); + res = mdns_domain_add_label(domain, dnssd_protos[DNSSD_PROTO_UDP], (u8_t)strlen(dnssd_protos[DNSSD_PROTO_UDP])); + LWIP_ERROR("mdns_build_dnssd_domain: Failed to add label", (res == ERR_OK), return res); + return mdns_add_dotlocal(domain); +} + +/** + * Build domain name for a service + * @param domain Where to write the domain name + * @param service The service struct, containing service name, type and protocol + * @param include_name Whether to include the service name in the domain + * @return ERR_OK if domain was written. If service name is included, + * ...local. will be written, otherwise ..local. + * An err_t is returned on error. + */ +static err_t +mdns_build_service_domain(struct mdns_domain *domain, struct mdns_service *service, int include_name) +{ + err_t res; + LWIP_UNUSED_ARG(res); + memset(domain, 0, sizeof(struct mdns_domain)); + if (include_name) { + res = mdns_domain_add_label(domain, service->name, (u8_t)strlen(service->name)); + LWIP_ERROR("mdns_build_service_domain: Failed to add label", (res == ERR_OK), return res); + } + res = mdns_domain_add_label(domain, service->service, (u8_t)strlen(service->service)); + LWIP_ERROR("mdns_build_service_domain: Failed to add label", (res == ERR_OK), return res); + res = mdns_domain_add_label(domain, dnssd_protos[service->proto], (u8_t)strlen(dnssd_protos[service->proto])); + LWIP_ERROR("mdns_build_service_domain: Failed to add label", (res == ERR_OK), return res); + return mdns_add_dotlocal(domain); +} + +/** + * Check which replies we should send for a host/netif based on question + * @param netif The network interface that received the question + * @param rr Domain/type/class from a question + * @param reverse_v6_reply Bitmask of which IPv6 addresses to send reverse PTRs for + * if reply bit has REPLY_HOST_PTR_V6 set + * @return Bitmask of which replies to send + */ +static int +check_host(struct netif *netif, struct mdns_rr_info *rr, u8_t *reverse_v6_reply) +{ + err_t res; + int replies = 0; + struct mdns_domain mydomain; + + LWIP_UNUSED_ARG(reverse_v6_reply); /* if ipv6 is disabled */ + + if (rr->klass != DNS_RRCLASS_IN && rr->klass != DNS_RRCLASS_ANY) { + /* Invalid class */ + return replies; + } + + /* Handle PTR for our addresses */ + if (rr->type == DNS_RRTYPE_PTR || rr->type == DNS_RRTYPE_ANY) { +#if LWIP_IPV6 + int i; + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { + res = mdns_build_reverse_v6_domain(&mydomain, netif_ip6_addr(netif, i)); + if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { + replies |= REPLY_HOST_PTR_V6; + /* Mark which addresses where requested */ + if (reverse_v6_reply) { + *reverse_v6_reply |= (1 << i); + } + } + } + } +#endif +#if LWIP_IPV4 + if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { + res = mdns_build_reverse_v4_domain(&mydomain, netif_ip4_addr(netif)); + if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { + replies |= REPLY_HOST_PTR_V4; + } + } +#endif + } + + res = mdns_build_host_domain(&mydomain, NETIF_TO_HOST(netif)); + /* Handle requests for our hostname */ + if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { + /* TODO return NSEC if unsupported protocol requested */ +#if LWIP_IPV4 + if (!ip4_addr_isany_val(*netif_ip4_addr(netif)) + && (rr->type == DNS_RRTYPE_A || rr->type == DNS_RRTYPE_ANY)) { + replies |= REPLY_HOST_A; + } +#endif +#if LWIP_IPV6 + if (rr->type == DNS_RRTYPE_AAAA || rr->type == DNS_RRTYPE_ANY) { + replies |= REPLY_HOST_AAAA; + } +#endif + } + + return replies; +} + +/** + * Check which replies we should send for a service based on question + * @param service A registered MDNS service + * @param rr Domain/type/class from a question + * @return Bitmask of which replies to send + */ +static int +check_service(struct mdns_service *service, struct mdns_rr_info *rr) +{ + err_t res; + int replies = 0; + struct mdns_domain mydomain; + + if (rr->klass != DNS_RRCLASS_IN && rr->klass != DNS_RRCLASS_ANY) { + /* Invalid class */ + return 0; + } + + res = mdns_build_dnssd_domain(&mydomain); + if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain) && + (rr->type == DNS_RRTYPE_PTR || rr->type == DNS_RRTYPE_ANY)) { + /* Request for all service types */ + replies |= REPLY_SERVICE_TYPE_PTR; + } + + res = mdns_build_service_domain(&mydomain, service, 0); + if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain) && + (rr->type == DNS_RRTYPE_PTR || rr->type == DNS_RRTYPE_ANY)) { + /* Request for the instance of my service */ + replies |= REPLY_SERVICE_NAME_PTR; + } + + res = mdns_build_service_domain(&mydomain, service, 1); + if (res == ERR_OK && mdns_domain_eq(&rr->domain, &mydomain)) { + /* Request for info about my service */ + if (rr->type == DNS_RRTYPE_SRV || rr->type == DNS_RRTYPE_ANY) { + replies |= REPLY_SERVICE_SRV; + } + if (rr->type == DNS_RRTYPE_TXT || rr->type == DNS_RRTYPE_ANY) { + replies |= REPLY_SERVICE_TXT; + } + } + + return replies; +} + +/** + * Return bytes needed to write before jump for best result of compressing supplied domain + * against domain in outpacket starting at specified offset. + * If a match is found, offset is updated to where to jump to + * @param pbuf Pointer to pbuf with the partially constructed DNS packet + * @param offset Start position of a domain written earlier. If this location is suitable + * for compression, the pointer is updated to where in the domain to jump to. + * @param domain The domain to write + * @return Number of bytes to write of the new domain before writing a jump to the offset. + * If compression can not be done against this previous domain name, the full new + * domain length is returned. + */ +u16_t +mdns_compress_domain(struct pbuf *pbuf, u16_t *offset, struct mdns_domain *domain) +{ + struct mdns_domain target; + u16_t target_end; + u8_t target_len; + u8_t writelen = 0; + u8_t *ptr; + if (pbuf == NULL) { + return domain->length; + } + target_end = mdns_readname(pbuf, *offset, &target); + if (target_end == MDNS_READNAME_ERROR) { + return domain->length; + } + target_len = (u8_t)(target_end - *offset); + ptr = domain->name; + while (writelen < domain->length) { + u8_t domainlen = (u8_t)(domain->length - writelen); + u8_t labellen; + if (domainlen <= target.length && domainlen > DOMAIN_JUMP_SIZE) { + /* Compare domains if target is long enough, and we have enough left of the domain */ + u8_t targetpos = (u8_t)(target.length - domainlen); + if ((targetpos + DOMAIN_JUMP_SIZE) >= target_len) { + /* We are checking at or beyond a jump in the original, stop looking */ + break; + } + if (target.length >= domainlen && + memcmp(&domain->name[writelen], &target.name[targetpos], domainlen) == 0) { + *offset += targetpos; + return writelen; + } + } + /* Skip to next label in domain */ + labellen = *ptr; + writelen += 1 + labellen; + ptr += 1 + labellen; + } + /* Nothing found */ + return domain->length; +} + +/** + * Write domain to outpacket. Compression will be attempted, + * unless domain->skip_compression is set. + * @param outpkt The outpacket to write to + * @param domain The domain name to write + * @return ERR_OK on success, an err_t otherwise + */ +static err_t +mdns_write_domain(struct mdns_outpacket *outpkt, struct mdns_domain *domain) +{ + int i; + err_t res; + u16_t writelen = domain->length; + u16_t jump_offset = 0; + u16_t jump; + + if (!domain->skip_compression) { + for (i = 0; i < NUM_DOMAIN_OFFSETS; i++) { + u16_t offset = outpkt->domain_offsets[i]; + if (offset) { + u16_t len = mdns_compress_domain(outpkt->pbuf, &offset, domain); + if (len < writelen) { + writelen = len; + jump_offset = offset; + } + } + } + } + + if (writelen) { + /* Write uncompressed part of name */ + res = pbuf_take_at(outpkt->pbuf, domain->name, writelen, outpkt->write_offset); + if (res != ERR_OK) { + return res; + } + + /* Store offset of this new domain */ + for (i = 0; i < NUM_DOMAIN_OFFSETS; i++) { + if (outpkt->domain_offsets[i] == 0) { + outpkt->domain_offsets[i] = outpkt->write_offset; + break; + } + } + + outpkt->write_offset += writelen; + } + if (jump_offset) { + /* Write jump */ + jump = lwip_htons(DOMAIN_JUMP | jump_offset); + res = pbuf_take_at(outpkt->pbuf, &jump, DOMAIN_JUMP_SIZE, outpkt->write_offset); + if (res != ERR_OK) { + return res; + } + outpkt->write_offset += DOMAIN_JUMP_SIZE; + } + return ERR_OK; +} + +/** + * Write a question to an outpacket + * A question contains domain, type and class. Since an answer also starts with these fields this function is also + * called from mdns_add_answer(). + * @param outpkt The outpacket to write to + * @param domain The domain name the answer is for + * @param type The DNS type of the answer (like 'AAAA', 'SRV') + * @param klass The DNS type of the answer (like 'IN') + * @param unicast If highest bit in class should be set, to instruct the responder to + * reply with a unicast packet + * @return ERR_OK on success, an err_t otherwise + */ +static err_t +mdns_add_question(struct mdns_outpacket *outpkt, struct mdns_domain *domain, u16_t type, u16_t klass, u16_t unicast) +{ + u16_t question_len; + u16_t field16; + err_t res; + + if (!outpkt->pbuf) { + /* If no pbuf is active, allocate one */ + outpkt->pbuf = pbuf_alloc(PBUF_TRANSPORT, OUTPACKET_SIZE, PBUF_RAM); + if (!outpkt->pbuf) { + return ERR_MEM; + } + outpkt->write_offset = SIZEOF_DNS_HDR; + } + + /* Worst case calculation. Domain string might be compressed */ + question_len = domain->length + sizeof(type) + sizeof(klass); + if (outpkt->write_offset + question_len > outpkt->pbuf->tot_len) { + /* No space */ + return ERR_MEM; + } + + /* Write name */ + res = mdns_write_domain(outpkt, domain); + if (res != ERR_OK) { + return res; + } + + /* Write type */ + field16 = lwip_htons(type); + res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset); + if (res != ERR_OK) { + return res; + } + outpkt->write_offset += sizeof(field16); + + /* Write class */ + if (unicast) { + klass |= 0x8000; + } + field16 = lwip_htons(klass); + res = pbuf_take_at(outpkt->pbuf, &field16, sizeof(field16), outpkt->write_offset); + if (res != ERR_OK) { + return res; + } + outpkt->write_offset += sizeof(field16); + + return ERR_OK; +} + +/** + * Write answer to reply packet. + * buf or answer_domain can be null. The rd_length written will be buf_length + + * size of (compressed) domain. Most uses will need either buf or answer_domain, + * special case is SRV that starts with 3 u16 and then a domain name. + * @param reply The outpacket to write to + * @param domain The domain name the answer is for + * @param type The DNS type of the answer (like 'AAAA', 'SRV') + * @param klass The DNS type of the answer (like 'IN') + * @param cache_flush If highest bit in class should be set, to instruct receiver that + * this reply replaces any earlier answer for this domain/type/class + * @param ttl Validity time in seconds to send out for IP address data in DNS replies + * @param buf Pointer to buffer of answer data + * @param buf_length Length of variable data + * @param answer_domain A domain to write after any buffer data as answer + * @return ERR_OK on success, an err_t otherwise + */ +static err_t +mdns_add_answer(struct mdns_outpacket *reply, struct mdns_domain *domain, u16_t type, u16_t klass, u16_t cache_flush, + u32_t ttl, const u8_t *buf, size_t buf_length, struct mdns_domain *answer_domain) +{ + u16_t answer_len; + u16_t field16; + u16_t rdlen_offset; + u16_t answer_offset; + u32_t field32; + err_t res; + + if (!reply->pbuf) { + /* If no pbuf is active, allocate one */ + reply->pbuf = pbuf_alloc(PBUF_TRANSPORT, OUTPACKET_SIZE, PBUF_RAM); + if (!reply->pbuf) { + return ERR_MEM; + } + reply->write_offset = SIZEOF_DNS_HDR; + } + + /* Worst case calculation. Domain strings might be compressed */ + answer_len = domain->length + sizeof(type) + sizeof(klass) + sizeof(ttl) + sizeof(field16)/*rd_length*/; + if (buf) { + answer_len += (u16_t)buf_length; + } + if (answer_domain) { + answer_len += answer_domain->length; + } + if (reply->write_offset + answer_len > reply->pbuf->tot_len) { + /* No space */ + return ERR_MEM; + } + + /* Answer starts with same data as question, then more fields */ + mdns_add_question(reply, domain, type, klass, cache_flush); + + /* Write TTL */ + field32 = lwip_htonl(ttl); + res = pbuf_take_at(reply->pbuf, &field32, sizeof(field32), reply->write_offset); + if (res != ERR_OK) { + return res; + } + reply->write_offset += sizeof(field32); + + /* Store offsets and skip forward to the data */ + rdlen_offset = reply->write_offset; + reply->write_offset += sizeof(field16); + answer_offset = reply->write_offset; + + if (buf) { + /* Write static data */ + res = pbuf_take_at(reply->pbuf, buf, (u16_t)buf_length, reply->write_offset); + if (res != ERR_OK) { + return res; + } + reply->write_offset += (u16_t)buf_length; + } + + if (answer_domain) { + /* Write name answer (compressed if possible) */ + res = mdns_write_domain(reply, answer_domain); + if (res != ERR_OK) { + return res; + } + } + + /* Write rd_length after when we know the answer size */ + field16 = lwip_htons(reply->write_offset - answer_offset); + res = pbuf_take_at(reply->pbuf, &field16, sizeof(field16), rdlen_offset); + + return res; +} + +/** + * Helper function for mdns_read_question/mdns_read_answer + * Reads a domain, type and class from the packet + * @param pkt The MDNS packet to read from. The parse_offset field will be + * incremented to point to the next unparsed byte. + * @param info The struct to fill with domain, type and class + * @return ERR_OK on success, an err_t otherwise + */ +static err_t +mdns_read_rr_info(struct mdns_packet *pkt, struct mdns_rr_info *info) +{ + u16_t field16, copied; + pkt->parse_offset = mdns_readname(pkt->pbuf, pkt->parse_offset, &info->domain); + if (pkt->parse_offset == MDNS_READNAME_ERROR) { + return ERR_VAL; + } + + copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); + if (copied != sizeof(field16)) { + return ERR_VAL; + } + pkt->parse_offset += copied; + info->type = lwip_ntohs(field16); + + copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); + if (copied != sizeof(field16)) { + return ERR_VAL; + } + pkt->parse_offset += copied; + info->klass = lwip_ntohs(field16); + + return ERR_OK; +} + +/** + * Read a question from the packet. + * All questions have to be read before the answers. + * @param pkt The MDNS packet to read from. The questions_left field will be decremented + * and the parse_offset will be updated. + * @param question The struct to fill with question data + * @return ERR_OK on success, an err_t otherwise + */ +static err_t +mdns_read_question(struct mdns_packet *pkt, struct mdns_question *question) +{ + /* Safety check */ + if (pkt->pbuf->tot_len < pkt->parse_offset) { + return ERR_VAL; + } + + if (pkt->questions_left) { + err_t res; + pkt->questions_left--; + + memset(question, 0, sizeof(struct mdns_question)); + res = mdns_read_rr_info(pkt, &question->info); + if (res != ERR_OK) { + return res; + } + + /* Extract unicast flag from class field */ + question->unicast = question->info.klass & 0x8000; + question->info.klass &= 0x7FFF; + + return ERR_OK; + } + return ERR_VAL; +} + +/** + * Read an answer from the packet + * The variable length reply is not copied, its pbuf offset and length is stored instead. + * @param pkt The MDNS packet to read. The answers_left field will be decremented and + * the parse_offset will be updated. + * @param answer The struct to fill with answer data + * @return ERR_OK on success, an err_t otherwise + */ +static err_t +mdns_read_answer(struct mdns_packet *pkt, struct mdns_answer *answer) +{ + /* Read questions first */ + if (pkt->questions_left) { + return ERR_VAL; + } + + /* Safety check */ + if (pkt->pbuf->tot_len < pkt->parse_offset) { + return ERR_VAL; + } + + if (pkt->answers_left) { + u16_t copied, field16; + u32_t ttl; + err_t res; + pkt->answers_left--; + + memset(answer, 0, sizeof(struct mdns_answer)); + res = mdns_read_rr_info(pkt, &answer->info); + if (res != ERR_OK) { + return res; + } + + /* Extract cache_flush flag from class field */ + answer->cache_flush = answer->info.klass & 0x8000; + answer->info.klass &= 0x7FFF; + + copied = pbuf_copy_partial(pkt->pbuf, &ttl, sizeof(ttl), pkt->parse_offset); + if (copied != sizeof(ttl)) { + return ERR_VAL; + } + pkt->parse_offset += copied; + answer->ttl = lwip_ntohl(ttl); + + copied = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), pkt->parse_offset); + if (copied != sizeof(field16)) { + return ERR_VAL; + } + pkt->parse_offset += copied; + answer->rd_length = lwip_ntohs(field16); + + answer->rd_offset = pkt->parse_offset; + pkt->parse_offset += answer->rd_length; + + return ERR_OK; + } + return ERR_VAL; +} + +#if LWIP_IPV4 +/** Write an IPv4 address (A) RR to outpacket */ +static err_t +mdns_add_a_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif) +{ + struct mdns_domain host; + mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with A record\n")); + return mdns_add_answer(reply, &host, DNS_RRTYPE_A, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, (const u8_t *) netif_ip4_addr(netif), sizeof(ip4_addr_t), NULL); +} + +/** Write a 4.3.2.1.in-addr.arpa -> hostname.local PTR RR to outpacket */ +static err_t +mdns_add_hostv4_ptr_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif) +{ + struct mdns_domain host, revhost; + mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); + mdns_build_reverse_v4_domain(&revhost, netif_ip4_addr(netif)); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with v4 PTR record\n")); + return mdns_add_answer(reply, &revhost, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, NULL, 0, &host); +} +#endif + +#if LWIP_IPV6 +/** Write an IPv6 address (AAAA) RR to outpacket */ +static err_t +mdns_add_aaaa_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif, int addrindex) +{ + struct mdns_domain host; + mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with AAAA record\n")); + return mdns_add_answer(reply, &host, DNS_RRTYPE_AAAA, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, (const u8_t *) netif_ip6_addr(netif, addrindex), sizeof(ip6_addr_p_t), NULL); +} + +/** Write a x.y.z.ip6.arpa -> hostname.local PTR RR to outpacket */ +static err_t +mdns_add_hostv6_ptr_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct netif *netif, int addrindex) +{ + struct mdns_domain host, revhost; + mdns_build_host_domain(&host, NETIF_TO_HOST(netif)); + mdns_build_reverse_v6_domain(&revhost, netif_ip6_addr(netif, addrindex)); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with v6 PTR record\n")); + return mdns_add_answer(reply, &revhost, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, cache_flush, (NETIF_TO_HOST(netif))->dns_ttl, NULL, 0, &host); +} +#endif + +/** Write an all-services -> servicetype PTR RR to outpacket */ +static err_t +mdns_add_servicetype_ptr_answer(struct mdns_outpacket *reply, struct mdns_service *service) +{ + struct mdns_domain service_type, service_dnssd; + mdns_build_service_domain(&service_type, service, 0); + mdns_build_dnssd_domain(&service_dnssd); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with service type PTR record\n")); + return mdns_add_answer(reply, &service_dnssd, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, 0, service->dns_ttl, NULL, 0, &service_type); +} + +/** Write a servicetype -> servicename PTR RR to outpacket */ +static err_t +mdns_add_servicename_ptr_answer(struct mdns_outpacket *reply, struct mdns_service *service) +{ + struct mdns_domain service_type, service_instance; + mdns_build_service_domain(&service_type, service, 0); + mdns_build_service_domain(&service_instance, service, 1); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with service name PTR record\n")); + return mdns_add_answer(reply, &service_type, DNS_RRTYPE_PTR, DNS_RRCLASS_IN, 0, service->dns_ttl, NULL, 0, &service_instance); +} + +/** Write a SRV RR to outpacket */ +static err_t +mdns_add_srv_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct mdns_host *mdns, struct mdns_service *service) +{ + struct mdns_domain service_instance, srvhost; + u16_t srvdata[3]; + mdns_build_service_domain(&service_instance, service, 1); + mdns_build_host_domain(&srvhost, mdns); + if (reply->legacy_query) { + /* RFC 6762 section 18.14: + * In legacy unicast responses generated to answer legacy queries, + * name compression MUST NOT be performed on SRV records. + */ + srvhost.skip_compression = 1; + } + srvdata[0] = lwip_htons(SRV_PRIORITY); + srvdata[1] = lwip_htons(SRV_WEIGHT); + srvdata[2] = lwip_htons(service->port); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with SRV record\n")); + return mdns_add_answer(reply, &service_instance, DNS_RRTYPE_SRV, DNS_RRCLASS_IN, cache_flush, service->dns_ttl, + (const u8_t *) &srvdata, sizeof(srvdata), &srvhost); +} + +/** Write a TXT RR to outpacket */ +static err_t +mdns_add_txt_answer(struct mdns_outpacket *reply, u16_t cache_flush, struct mdns_service *service) +{ + struct mdns_domain service_instance; + mdns_build_service_domain(&service_instance, service, 1); + mdns_prepare_txtdata(service); + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Responding with TXT record\n")); + return mdns_add_answer(reply, &service_instance, DNS_RRTYPE_TXT, DNS_RRCLASS_IN, cache_flush, service->dns_ttl, + (u8_t *) &service->txtdata.name, service->txtdata.length, NULL); +} + +/** + * Setup outpacket as a reply to the incoming packet + */ +static void +mdns_init_outpacket(struct mdns_outpacket *out, struct mdns_packet *in) +{ + memset(out, 0, sizeof(struct mdns_outpacket)); + out->cache_flush = 1; + out->netif = in->netif; + + /* Copy source IP/port to use when responding unicast, or to choose + * which pcb to use for multicast (IPv4/IPv6) + */ + SMEMCPY(&out->dest_addr, &in->source_addr, sizeof(ip_addr_t)); + out->dest_port = in->source_port; + + if (in->source_port != LWIP_IANA_PORT_MDNS) { + out->unicast_reply = 1; + out->cache_flush = 0; + if (in->questions == 1) { + out->legacy_query = 1; + out->tx_id = in->tx_id; + } + } + + if (in->recv_unicast) { + out->unicast_reply = 1; + } +} + +/** + * Send chosen answers as a reply + * + * Add all selected answers (first write will allocate pbuf) + * Add additional answers based on the selected answers + * Send the packet + */ +static err_t +mdns_send_outpacket(struct mdns_outpacket *outpkt, u8_t flags) +{ + struct mdns_service *service; + err_t res = ERR_ARG; + int i; + struct mdns_host *mdns = NETIF_TO_HOST(outpkt->netif); + u16_t answers = 0; + + /* Write answers to host questions */ +#if LWIP_IPV4 + if (outpkt->host_replies & REPLY_HOST_A) { + res = mdns_add_a_answer(outpkt, outpkt->cache_flush, outpkt->netif); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } + if (outpkt->host_replies & REPLY_HOST_PTR_V4) { + res = mdns_add_hostv4_ptr_answer(outpkt, outpkt->cache_flush, outpkt->netif); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } +#endif +#if LWIP_IPV6 + if (outpkt->host_replies & REPLY_HOST_AAAA) { + int addrindex; + for (addrindex = 0; addrindex < LWIP_IPV6_NUM_ADDRESSES; addrindex++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(outpkt->netif, addrindex))) { + res = mdns_add_aaaa_answer(outpkt, outpkt->cache_flush, outpkt->netif, addrindex); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } + } + } + if (outpkt->host_replies & REPLY_HOST_PTR_V6) { + u8_t rev_addrs = outpkt->host_reverse_v6_replies; + int addrindex = 0; + while (rev_addrs) { + if (rev_addrs & 1) { + res = mdns_add_hostv6_ptr_answer(outpkt, outpkt->cache_flush, outpkt->netif, addrindex); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } + addrindex++; + rev_addrs >>= 1; + } + } +#endif + + /* Write answers to service questions */ + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + service = mdns->services[i]; + if (!service) { + continue; + } + + if (outpkt->serv_replies[i] & REPLY_SERVICE_TYPE_PTR) { + res = mdns_add_servicetype_ptr_answer(outpkt, service); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } + + if (outpkt->serv_replies[i] & REPLY_SERVICE_NAME_PTR) { + res = mdns_add_servicename_ptr_answer(outpkt, service); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } + + if (outpkt->serv_replies[i] & REPLY_SERVICE_SRV) { + res = mdns_add_srv_answer(outpkt, outpkt->cache_flush, mdns, service); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } + + if (outpkt->serv_replies[i] & REPLY_SERVICE_TXT) { + res = mdns_add_txt_answer(outpkt, outpkt->cache_flush, service); + if (res != ERR_OK) { + goto cleanup; + } + answers++; + } + } + + /* if this is a response, the data above is anwers, else this is a probe and the answers above goes into auth section */ + if (flags & DNS_FLAG1_RESPONSE) { + outpkt->answers += answers; + } else { + outpkt->authoritative += answers; + } + + /* All answers written, add additional RRs */ + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + service = mdns->services[i]; + if (!service) { + continue; + } + + if (outpkt->serv_replies[i] & REPLY_SERVICE_NAME_PTR) { + /* Our service instance requested, include SRV & TXT + * if they are already not requested. */ + if (!(outpkt->serv_replies[i] & REPLY_SERVICE_SRV)) { + res = mdns_add_srv_answer(outpkt, outpkt->cache_flush, mdns, service); + if (res != ERR_OK) { + goto cleanup; + } + outpkt->additional++; + } + + if (!(outpkt->serv_replies[i] & REPLY_SERVICE_TXT)) { + res = mdns_add_txt_answer(outpkt, outpkt->cache_flush, service); + if (res != ERR_OK) { + goto cleanup; + } + outpkt->additional++; + } + } + + /* If service instance, SRV, record or an IP address is requested, + * supply all addresses for the host + */ + if ((outpkt->serv_replies[i] & (REPLY_SERVICE_NAME_PTR | REPLY_SERVICE_SRV)) || + (outpkt->host_replies & (REPLY_HOST_A | REPLY_HOST_AAAA))) { +#if LWIP_IPV6 + if (!(outpkt->host_replies & REPLY_HOST_AAAA)) { + int addrindex; + for (addrindex = 0; addrindex < LWIP_IPV6_NUM_ADDRESSES; addrindex++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(outpkt->netif, addrindex))) { + res = mdns_add_aaaa_answer(outpkt, outpkt->cache_flush, outpkt->netif, addrindex); + if (res != ERR_OK) { + goto cleanup; + } + outpkt->additional++; + } + } + } +#endif +#if LWIP_IPV4 + if (!(outpkt->host_replies & REPLY_HOST_A) && + !ip4_addr_isany_val(*netif_ip4_addr(outpkt->netif))) { + res = mdns_add_a_answer(outpkt, outpkt->cache_flush, outpkt->netif); + if (res != ERR_OK) { + goto cleanup; + } + outpkt->additional++; + } +#endif + } + } + + if (outpkt->pbuf) { + const ip_addr_t *mcast_destaddr; + struct dns_hdr hdr; + + /* Write header */ + memset(&hdr, 0, sizeof(hdr)); + hdr.flags1 = flags; + hdr.numquestions = lwip_htons(outpkt->questions); + hdr.numanswers = lwip_htons(outpkt->answers); + hdr.numauthrr = lwip_htons(outpkt->authoritative); + hdr.numextrarr = lwip_htons(outpkt->additional); + hdr.id = lwip_htons(outpkt->tx_id); + pbuf_take(outpkt->pbuf, &hdr, sizeof(hdr)); + + /* Shrink packet */ + pbuf_realloc(outpkt->pbuf, outpkt->write_offset); + + if (IP_IS_V6_VAL(outpkt->dest_addr)) { +#if LWIP_IPV6 + mcast_destaddr = &v6group; +#endif + } else { +#if LWIP_IPV4 + mcast_destaddr = &v4group; +#endif + } + /* Send created packet */ + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Sending packet, len=%d, unicast=%d\n", outpkt->write_offset, outpkt->unicast_reply)); + if (outpkt->unicast_reply) { + res = udp_sendto_if(mdns_pcb, outpkt->pbuf, &outpkt->dest_addr, outpkt->dest_port, outpkt->netif); + } else { + res = udp_sendto_if(mdns_pcb, outpkt->pbuf, mcast_destaddr, LWIP_IANA_PORT_MDNS, outpkt->netif); + } + } + +cleanup: + if (outpkt->pbuf) { + pbuf_free(outpkt->pbuf); + outpkt->pbuf = NULL; + } + return res; +} + +/** + * Send unsolicited answer containing all our known data + * @param netif The network interface to send on + * @param destination The target address to send to (usually multicast address) + */ +static void +mdns_announce(struct netif *netif, const ip_addr_t *destination) +{ + struct mdns_outpacket announce; + int i; + struct mdns_host *mdns = NETIF_TO_HOST(netif); + + memset(&announce, 0, sizeof(announce)); + announce.netif = netif; + announce.cache_flush = 1; +#if LWIP_IPV4 + if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { + announce.host_replies = REPLY_HOST_A | REPLY_HOST_PTR_V4; + } +#endif +#if LWIP_IPV6 + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { + announce.host_replies |= REPLY_HOST_AAAA | REPLY_HOST_PTR_V6; + announce.host_reverse_v6_replies |= (1 << i); + } + } +#endif + + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + struct mdns_service *serv = mdns->services[i]; + if (serv) { + announce.serv_replies[i] = REPLY_SERVICE_TYPE_PTR | REPLY_SERVICE_NAME_PTR | + REPLY_SERVICE_SRV | REPLY_SERVICE_TXT; + } + } + + announce.dest_port = LWIP_IANA_PORT_MDNS; + SMEMCPY(&announce.dest_addr, destination, sizeof(announce.dest_addr)); + mdns_send_outpacket(&announce, DNS_FLAG1_RESPONSE | DNS_FLAG1_AUTHORATIVE); +} + +/** + * Handle question MDNS packet + * 1. Parse all questions and set bits what answers to send + * 2. Clear pending answers if known answers are supplied + * 3. Put chosen answers in new packet and send as reply + */ +static void +mdns_handle_question(struct mdns_packet *pkt) +{ + struct mdns_service *service; + struct mdns_outpacket reply; + int replies = 0; + int i; + err_t res; + struct mdns_host *mdns = NETIF_TO_HOST(pkt->netif); + + if (mdns->probing_state != MDNS_PROBING_COMPLETE) { + /* Don't answer questions until we've verified our domains via probing */ + /* @todo we should check incoming questions during probing for tiebreaking */ + return; + } + + mdns_init_outpacket(&reply, pkt); + + while (pkt->questions_left) { + struct mdns_question q; + + res = mdns_read_question(pkt, &q); + if (res != ERR_OK) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse question, skipping query packet\n")); + return; + } + + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Query for domain ")); + mdns_domain_debug_print(&q.info.domain); + LWIP_DEBUGF(MDNS_DEBUG, (" type %d class %d\n", q.info.type, q.info.klass)); + + if (q.unicast) { + /* Reply unicast if any question is unicast */ + reply.unicast_reply = 1; + } + + reply.host_replies |= check_host(pkt->netif, &q.info, &reply.host_reverse_v6_replies); + replies |= reply.host_replies; + + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + service = mdns->services[i]; + if (!service) { + continue; + } + reply.serv_replies[i] |= check_service(service, &q.info); + replies |= reply.serv_replies[i]; + } + + if (replies && reply.legacy_query) { + /* Add question to reply packet (legacy packet only has 1 question) */ + res = mdns_add_question(&reply, &q.info.domain, q.info.type, q.info.klass, 0); + reply.questions = 1; + if (res != ERR_OK) { + goto cleanup; + } + } + } + + /* Handle known answers */ + while (pkt->answers_left) { + struct mdns_answer ans; + u8_t rev_v6; + int match; + + res = mdns_read_answer(pkt, &ans); + if (res != ERR_OK) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse answer, skipping query packet\n")); + goto cleanup; + } + + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Known answer for domain ")); + mdns_domain_debug_print(&ans.info.domain); + LWIP_DEBUGF(MDNS_DEBUG, (" type %d class %d\n", ans.info.type, ans.info.klass)); + + + if (ans.info.type == DNS_RRTYPE_ANY || ans.info.klass == DNS_RRCLASS_ANY) { + /* Skip known answers for ANY type & class */ + continue; + } + + rev_v6 = 0; + match = reply.host_replies & check_host(pkt->netif, &ans.info, &rev_v6); + if (match && (ans.ttl > (mdns->dns_ttl / 2))) { + /* The RR in the known answer matches an RR we are planning to send, + * and the TTL is less than half gone. + * If the payload matches we should not send that answer. + */ + if (ans.info.type == DNS_RRTYPE_PTR) { + /* Read domain and compare */ + struct mdns_domain known_ans, my_ans; + u16_t len; + len = mdns_readname(pkt->pbuf, ans.rd_offset, &known_ans); + res = mdns_build_host_domain(&my_ans, mdns); + if (len != MDNS_READNAME_ERROR && res == ERR_OK && mdns_domain_eq(&known_ans, &my_ans)) { +#if LWIP_IPV4 + if (match & REPLY_HOST_PTR_V4) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: v4 PTR\n")); + reply.host_replies &= ~REPLY_HOST_PTR_V4; + } +#endif +#if LWIP_IPV6 + if (match & REPLY_HOST_PTR_V6) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: v6 PTR\n")); + reply.host_reverse_v6_replies &= ~rev_v6; + if (reply.host_reverse_v6_replies == 0) { + reply.host_replies &= ~REPLY_HOST_PTR_V6; + } + } +#endif + } + } else if (match & REPLY_HOST_A) { +#if LWIP_IPV4 + if (ans.rd_length == sizeof(ip4_addr_t) && + pbuf_memcmp(pkt->pbuf, ans.rd_offset, netif_ip4_addr(pkt->netif), ans.rd_length) == 0) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: A\n")); + reply.host_replies &= ~REPLY_HOST_A; + } +#endif + } else if (match & REPLY_HOST_AAAA) { +#if LWIP_IPV6 + if (ans.rd_length == sizeof(ip6_addr_p_t) && + /* TODO this clears all AAAA responses if first addr is set as known */ + pbuf_memcmp(pkt->pbuf, ans.rd_offset, netif_ip6_addr(pkt->netif, 0), ans.rd_length) == 0) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: AAAA\n")); + reply.host_replies &= ~REPLY_HOST_AAAA; + } +#endif + } + } + + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + service = mdns->services[i]; + if (!service) { + continue; + } + match = reply.serv_replies[i] & check_service(service, &ans.info); + if (match && (ans.ttl > (service->dns_ttl / 2))) { + /* The RR in the known answer matches an RR we are planning to send, + * and the TTL is less than half gone. + * If the payload matches we should not send that answer. + */ + if (ans.info.type == DNS_RRTYPE_PTR) { + /* Read domain and compare */ + struct mdns_domain known_ans, my_ans; + u16_t len; + len = mdns_readname(pkt->pbuf, ans.rd_offset, &known_ans); + if (len != MDNS_READNAME_ERROR) { + if (match & REPLY_SERVICE_TYPE_PTR) { + res = mdns_build_service_domain(&my_ans, service, 0); + if (res == ERR_OK && mdns_domain_eq(&known_ans, &my_ans)) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: service type PTR\n")); + reply.serv_replies[i] &= ~REPLY_SERVICE_TYPE_PTR; + } + } + if (match & REPLY_SERVICE_NAME_PTR) { + res = mdns_build_service_domain(&my_ans, service, 1); + if (res == ERR_OK && mdns_domain_eq(&known_ans, &my_ans)) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: service name PTR\n")); + reply.serv_replies[i] &= ~REPLY_SERVICE_NAME_PTR; + } + } + } + } else if (match & REPLY_SERVICE_SRV) { + /* Read and compare to my SRV record */ + u16_t field16, len, read_pos; + struct mdns_domain known_ans, my_ans; + read_pos = ans.rd_offset; + do { + /* Check priority field */ + len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); + if (len != sizeof(field16) || lwip_ntohs(field16) != SRV_PRIORITY) { + break; + } + read_pos += len; + /* Check weight field */ + len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); + if (len != sizeof(field16) || lwip_ntohs(field16) != SRV_WEIGHT) { + break; + } + read_pos += len; + /* Check port field */ + len = pbuf_copy_partial(pkt->pbuf, &field16, sizeof(field16), read_pos); + if (len != sizeof(field16) || lwip_ntohs(field16) != service->port) { + break; + } + read_pos += len; + /* Check host field */ + len = mdns_readname(pkt->pbuf, read_pos, &known_ans); + mdns_build_host_domain(&my_ans, mdns); + if (len == MDNS_READNAME_ERROR || !mdns_domain_eq(&known_ans, &my_ans)) { + break; + } + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: SRV\n")); + reply.serv_replies[i] &= ~REPLY_SERVICE_SRV; + } while (0); + } else if (match & REPLY_SERVICE_TXT) { + mdns_prepare_txtdata(service); + if (service->txtdata.length == ans.rd_length && + pbuf_memcmp(pkt->pbuf, ans.rd_offset, service->txtdata.name, ans.rd_length) == 0) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Skipping known answer: TXT\n")); + reply.serv_replies[i] &= ~REPLY_SERVICE_TXT; + } + } + } + } + } + + mdns_send_outpacket(&reply, DNS_FLAG1_RESPONSE | DNS_FLAG1_AUTHORATIVE); + +cleanup: + if (reply.pbuf) { + /* This should only happen if we fail to alloc/write question for legacy query */ + pbuf_free(reply.pbuf); + reply.pbuf = NULL; + } +} + +/** + * Handle response MDNS packet + * Only prints debug for now. Will need more code to do conflict resolution. + */ +static void +mdns_handle_response(struct mdns_packet *pkt) +{ + struct mdns_host* mdns = NETIF_TO_HOST(pkt->netif); + + /* Ignore all questions */ + while (pkt->questions_left) { + struct mdns_question q; + err_t res; + + res = mdns_read_question(pkt, &q); + if (res != ERR_OK) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse question, skipping response packet\n")); + return; + } + } + + while (pkt->answers_left) { + struct mdns_answer ans; + err_t res; + + res = mdns_read_answer(pkt, &ans); + if (res != ERR_OK) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Failed to parse answer, skipping response packet\n")); + return; + } + + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Answer for domain ")); + mdns_domain_debug_print(&ans.info.domain); + LWIP_DEBUGF(MDNS_DEBUG, (" type %d class %d\n", ans.info.type, ans.info.klass)); + + /*"Apparently conflicting Multicast DNS responses received *before* the first probe packet is sent MUST + be silently ignored" so drop answer if we haven't started probing yet*/ + if ((mdns->probing_state == MDNS_PROBING_ONGOING) && (mdns->probes_sent > 0)) { + struct mdns_domain domain; + u8_t i; + u8_t conflict = 0; + + res = mdns_build_host_domain(&domain, mdns); + if (res == ERR_OK && mdns_domain_eq(&ans.info.domain, &domain)) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Probe response matches host domain!")); + conflict = 1; + } + + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + struct mdns_service* service = mdns->services[i]; + if (!service) { + continue; + } + res = mdns_build_service_domain(&domain, service, 1); + if ((res == ERR_OK) && mdns_domain_eq(&ans.info.domain, &domain)) { + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Probe response matches service domain!")); + conflict = 1; + } + } + + if (conflict != 0) { + sys_untimeout(mdns_probe, pkt->netif); + if (mdns_name_result_cb != NULL) { + mdns_name_result_cb(pkt->netif, MDNS_PROBING_CONFLICT); + } + } + } + } +} + +/** + * Receive input function for MDNS packets. + * Handles both IPv4 and IPv6 UDP pcbs. + */ +static void +mdns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + struct dns_hdr hdr; + struct mdns_packet packet; + struct netif *recv_netif = ip_current_input_netif(); + u16_t offset = 0; + + LWIP_UNUSED_ARG(arg); + LWIP_UNUSED_ARG(pcb); + + LWIP_DEBUGF(MDNS_DEBUG, ("MDNS: Received IPv%d MDNS packet, len %d\n", IP_IS_V6(addr) ? 6 : 4, p->tot_len)); + + if (NETIF_TO_HOST(recv_netif) == NULL) { + /* From netif not configured for MDNS */ + goto dealloc; + } + + if (pbuf_copy_partial(p, &hdr, SIZEOF_DNS_HDR, offset) < SIZEOF_DNS_HDR) { + /* Too small */ + goto dealloc; + } + offset += SIZEOF_DNS_HDR; + + if (DNS_HDR_GET_OPCODE(&hdr)) { + /* Ignore non-standard queries in multicast packets (RFC 6762, section 18.3) */ + goto dealloc; + } + + memset(&packet, 0, sizeof(packet)); + SMEMCPY(&packet.source_addr, addr, sizeof(packet.source_addr)); + packet.source_port = port; + packet.netif = recv_netif; + packet.pbuf = p; + packet.parse_offset = offset; + packet.tx_id = lwip_ntohs(hdr.id); + packet.questions = packet.questions_left = lwip_ntohs(hdr.numquestions); + packet.answers = packet.answers_left = lwip_ntohs(hdr.numanswers) + lwip_ntohs(hdr.numauthrr) + lwip_ntohs(hdr.numextrarr); + +#if LWIP_IPV6 + if (IP_IS_V6(ip_current_dest_addr())) { + /* instead of having one 'v6group' per netif, just compare zoneless here */ + if (!ip_addr_cmp_zoneless(ip_current_dest_addr(), &v6group)) { + packet.recv_unicast = 1; + } + } +#endif +#if LWIP_IPV4 + if (!IP_IS_V6(ip_current_dest_addr())) { + if (!ip_addr_cmp(ip_current_dest_addr(), &v4group)) { + packet.recv_unicast = 1; + } + } +#endif + + if (hdr.flags1 & DNS_FLAG1_RESPONSE) { + mdns_handle_response(&packet); + } else { + mdns_handle_question(&packet); + } + +dealloc: + pbuf_free(p); +} + +#if LWIP_NETIF_EXT_STATUS_CALLBACK && MDNS_RESP_USENETIF_EXTCALLBACK +static void +mdns_netif_ext_status_callback(struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args) +{ + LWIP_UNUSED_ARG(args); + + /* MDNS enabled on netif? */ + if (NETIF_TO_HOST(netif) == NULL) { + return; + } + + if (reason & LWIP_NSC_STATUS_CHANGED) { + if (args->status_changed.state != 0) { + mdns_resp_restart(netif); + } + /* TODO: send goodbye message */ + } + if (reason & LWIP_NSC_LINK_CHANGED) { + if (args->link_changed.state != 0) { + mdns_resp_restart(netif); + } + } + if (reason & (LWIP_NSC_IPV4_ADDRESS_CHANGED | LWIP_NSC_IPV4_GATEWAY_CHANGED | + LWIP_NSC_IPV4_NETMASK_CHANGED | LWIP_NSC_IPV4_SETTINGS_CHANGED | + LWIP_NSC_IPV6_SET | LWIP_NSC_IPV6_ADDR_STATE_CHANGED)) { + mdns_resp_announce(netif); + } +} +#endif /* LWIP_NETIF_EXT_STATUS_CALLBACK && MDNS_RESP_USENETIF_EXTCALLBACK */ + +static err_t +mdns_send_probe(struct netif* netif, const ip_addr_t *destination) +{ + struct mdns_host* mdns; + struct mdns_outpacket pkt; + struct mdns_domain domain; + u8_t i; + err_t res; + + mdns = NETIF_TO_HOST(netif); + + memset(&pkt, 0, sizeof(pkt)); + pkt.netif = netif; + + /* Add unicast questions with rtype ANY for all our desired records */ + mdns_build_host_domain(&domain, mdns); + res = mdns_add_question(&pkt, &domain, DNS_RRTYPE_ANY, DNS_RRCLASS_IN, 1); + if (res != ERR_OK) { + goto cleanup; + } + pkt.questions++; + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + struct mdns_service* service = mdns->services[i]; + if (!service) { + continue; + } + mdns_build_service_domain(&domain, service, 1); + res = mdns_add_question(&pkt, &domain, DNS_RRTYPE_ANY, DNS_RRCLASS_IN, 1); + if (res != ERR_OK) { + goto cleanup; + } + pkt.questions++; + } + + /* Add answers to the questions above into the authority section for tiebreaking */ +#if LWIP_IPV4 + if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { + pkt.host_replies = REPLY_HOST_A; + } +#endif +#if LWIP_IPV6 + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { + pkt.host_replies |= REPLY_HOST_AAAA; + } + } +#endif + + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + struct mdns_service *serv = mdns->services[i]; + if (serv) { + pkt.serv_replies[i] = REPLY_SERVICE_SRV | REPLY_SERVICE_TXT; + } + } + + pkt.tx_id = 0; + pkt.dest_port = LWIP_IANA_PORT_MDNS; + SMEMCPY(&pkt.dest_addr, destination, sizeof(pkt.dest_addr)); + res = mdns_send_outpacket(&pkt, 0); + +cleanup: + if (pkt.pbuf) { + pbuf_free(pkt.pbuf); + pkt.pbuf = NULL; + } + return res; +} + +/** + * Timer callback for probing network. + */ +static void +mdns_probe(void* arg) +{ + struct netif *netif = (struct netif *)arg; + struct mdns_host* mdns = NETIF_TO_HOST(netif); + + if(mdns->probes_sent >= MDNS_PROBE_COUNT) { + /* probing successful, announce the new name */ + mdns->probing_state = MDNS_PROBING_COMPLETE; + mdns_resp_announce(netif); + if (mdns_name_result_cb != NULL) { + mdns_name_result_cb(netif, MDNS_PROBING_SUCCESSFUL); + } + } else { +#if LWIP_IPV4 + /*if ipv4 wait with probing until address is set*/ + if (!ip4_addr_isany_val(*netif_ip4_addr(netif)) && + mdns_send_probe(netif, IP4_ADDR_ANY) == ERR_OK) +#endif + { +#if LWIP_IPV6 + if (mdns_send_probe(netif, IP6_ADDR_ANY) == ERR_OK) +#endif + { + mdns->probes_sent++; + } + } + sys_timeout(MDNS_PROBE_DELAY_MS, mdns_probe, netif); + } +} + +/** + * @ingroup mdns + * Activate MDNS responder for a network interface. + * @param netif The network interface to activate. + * @param hostname Name to use. Queries for <hostname>.local will be answered + * with the IP addresses of the netif. The hostname will be copied, the + * given pointer can be on the stack. + * @param dns_ttl Validity time in seconds to send out for IP address data in DNS replies + * @return ERR_OK if netif was added, an err_t otherwise + */ +err_t +mdns_resp_add_netif(struct netif *netif, const char *hostname, u32_t dns_ttl) +{ + err_t res; + struct mdns_host *mdns; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ERROR("mdns_resp_add_netif: netif != NULL", (netif != NULL), return ERR_VAL); + LWIP_ERROR("mdns_resp_add_netif: Hostname too long", (strlen(hostname) <= MDNS_LABEL_MAXLEN), return ERR_VAL); + + LWIP_ASSERT("mdns_resp_add_netif: Double add", NETIF_TO_HOST(netif) == NULL); + mdns = (struct mdns_host *) mem_calloc(1, sizeof(struct mdns_host)); + LWIP_ERROR("mdns_resp_add_netif: Alloc failed", (mdns != NULL), return ERR_MEM); + + netif_set_client_data(netif, mdns_netif_client_id, mdns); + + MEMCPY(&mdns->name, hostname, LWIP_MIN(MDNS_LABEL_MAXLEN, strlen(hostname))); + mdns->dns_ttl = dns_ttl; + mdns->probes_sent = 0; + mdns->probing_state = MDNS_PROBING_NOT_STARTED; + + /* Join multicast groups */ +#if LWIP_IPV4 + res = igmp_joingroup_netif(netif, ip_2_ip4(&v4group)); + if (res != ERR_OK) { + goto cleanup; + } +#endif +#if LWIP_IPV6 + res = mld6_joingroup_netif(netif, ip_2_ip6(&v6group)); + if (res != ERR_OK) { + goto cleanup; + } +#endif + + mdns_resp_restart(netif); + + return ERR_OK; + +cleanup: + mem_free(mdns); + netif_set_client_data(netif, mdns_netif_client_id, NULL); + return res; +} + +/** + * @ingroup mdns + * Stop responding to MDNS queries on this interface, leave multicast groups, + * and free the helper structure and any of its services. + * @param netif The network interface to remove. + * @return ERR_OK if netif was removed, an err_t otherwise + */ +err_t +mdns_resp_remove_netif(struct netif *netif) +{ + int i; + struct mdns_host *mdns; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mdns_resp_remove_netif: Null pointer", netif); + mdns = NETIF_TO_HOST(netif); + LWIP_ERROR("mdns_resp_remove_netif: Not an active netif", (mdns != NULL), return ERR_VAL); + + if (mdns->probing_state == MDNS_PROBING_ONGOING) { + sys_untimeout(mdns_probe, netif); + } + + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + struct mdns_service *service = mdns->services[i]; + if (service) { + mem_free(service); + } + } + + /* Leave multicast groups */ +#if LWIP_IPV4 + igmp_leavegroup_netif(netif, ip_2_ip4(&v4group)); +#endif +#if LWIP_IPV6 + mld6_leavegroup_netif(netif, ip_2_ip6(&v6group)); +#endif + + mem_free(mdns); + netif_set_client_data(netif, mdns_netif_client_id, NULL); + return ERR_OK; +} + +/** + * @ingroup mdns + * Update MDNS hostname for a network interface. + * @param netif The network interface to activate. + * @param hostname Name to use. Queries for <hostname>.local will be answered + * with the IP addresses of the netif. The hostname will be copied, the + * given pointer can be on the stack. + * @return ERR_OK if name could be set on netif, an err_t otherwise + */ +err_t +mdns_resp_rename_netif(struct netif *netif, const char *hostname) +{ + struct mdns_host *mdns; + size_t len; + + LWIP_ASSERT_CORE_LOCKED(); + len = strlen(hostname); + LWIP_ERROR("mdns_resp_rename_netif: netif != NULL", (netif != NULL), return ERR_VAL); + LWIP_ERROR("mdns_resp_rename_netif: Hostname too long", (len <= MDNS_LABEL_MAXLEN), return ERR_VAL); + mdns = NETIF_TO_HOST(netif); + LWIP_ERROR("mdns_resp_rename_netif: Not an mdns netif", (mdns != NULL), return ERR_VAL); + + MEMCPY(&mdns->name, hostname, LWIP_MIN(MDNS_LABEL_MAXLEN, len)); + mdns->name[len] = '\0'; /* null termination in case new name is shorter than previous */ + + mdns_resp_restart(netif); + + return ERR_OK; +} + +/** + * @ingroup mdns + * Add a service to the selected network interface. + * @param netif The network interface to publish this service on + * @param name The name of the service + * @param service The service type, like "_http" + * @param proto The service protocol, DNSSD_PROTO_TCP for TCP ("_tcp") and DNSSD_PROTO_UDP + * for others ("_udp") + * @param port The port the service listens to + * @param dns_ttl Validity time in seconds to send out for service data in DNS replies + * @param txt_fn Callback to get TXT data. Will be called each time a TXT reply is created to + * allow dynamic replies. + * @param txt_data Userdata pointer for txt_fn + * @return service_id if the service was added to the netif, an err_t otherwise + */ +s8_t +mdns_resp_add_service(struct netif *netif, const char *name, const char *service, enum mdns_sd_proto proto, u16_t port, u32_t dns_ttl, service_get_txt_fn_t txt_fn, void *txt_data) +{ + s8_t i; + s8_t slot = -1; + struct mdns_service *srv; + struct mdns_host *mdns; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mdns_resp_add_service: netif != NULL", netif); + mdns = NETIF_TO_HOST(netif); + LWIP_ERROR("mdns_resp_add_service: Not an mdns netif", (mdns != NULL), return ERR_VAL); + + LWIP_ERROR("mdns_resp_add_service: Name too long", (strlen(name) <= MDNS_LABEL_MAXLEN), return ERR_VAL); + LWIP_ERROR("mdns_resp_add_service: Service too long", (strlen(service) <= MDNS_LABEL_MAXLEN), return ERR_VAL); + LWIP_ERROR("mdns_resp_add_service: Bad proto (need TCP or UDP)", (proto == DNSSD_PROTO_TCP || proto == DNSSD_PROTO_UDP), return ERR_VAL); + + for (i = 0; i < MDNS_MAX_SERVICES; i++) { + if (mdns->services[i] == NULL) { + slot = i; + break; + } + } + LWIP_ERROR("mdns_resp_add_service: Service list full (increase MDNS_MAX_SERVICES)", (slot >= 0), return ERR_MEM); + + srv = (struct mdns_service *)mem_calloc(1, sizeof(struct mdns_service)); + LWIP_ERROR("mdns_resp_add_service: Alloc failed", (srv != NULL), return ERR_MEM); + + MEMCPY(&srv->name, name, LWIP_MIN(MDNS_LABEL_MAXLEN, strlen(name))); + MEMCPY(&srv->service, service, LWIP_MIN(MDNS_LABEL_MAXLEN, strlen(service))); + srv->txt_fn = txt_fn; + srv->txt_userdata = txt_data; + srv->proto = (u16_t)proto; + srv->port = port; + srv->dns_ttl = dns_ttl; + + mdns->services[slot] = srv; + + mdns_resp_restart(netif); + + return slot; +} + +/** + * @ingroup mdns + * Delete a service on the selected network interface. + * @param netif The network interface on which service should be removed + * @param slot The service slot number returned by mdns_resp_add_service + * @return ERR_OK if the service was removed from the netif, an err_t otherwise + */ +err_t +mdns_resp_del_service(struct netif *netif, s8_t slot) +{ + struct mdns_host *mdns; + struct mdns_service *srv; + LWIP_ASSERT("mdns_resp_del_service: netif != NULL", netif); + mdns = NETIF_TO_HOST(netif); + LWIP_ERROR("mdns_resp_del_service: Not an mdns netif", (mdns != NULL), return ERR_VAL); + LWIP_ERROR("mdns_resp_del_service: Invalid Service ID", (slot >= 0) && (slot < MDNS_MAX_SERVICES), return ERR_VAL); + LWIP_ERROR("mdns_resp_del_service: Invalid Service ID", (mdns->services[slot] != NULL), return ERR_VAL); + + srv = mdns->services[slot]; + mdns->services[slot] = NULL; + mem_free(srv); + return ERR_OK; +} + +/** + * @ingroup mdns + * Update name for an MDNS service. + * @param netif The network interface to activate. + * @param slot The service slot number returned by mdns_resp_add_service + * @param name The new name for the service + * @return ERR_OK if name could be set on service, an err_t otherwise + */ +err_t +mdns_resp_rename_service(struct netif *netif, s8_t slot, const char *name) +{ + struct mdns_service *srv; + struct mdns_host *mdns; + size_t len; + + LWIP_ASSERT_CORE_LOCKED(); + len = strlen(name); + LWIP_ASSERT("mdns_resp_rename_service: netif != NULL", netif); + mdns = NETIF_TO_HOST(netif); + LWIP_ERROR("mdns_resp_rename_service: Not an mdns netif", (mdns != NULL), return ERR_VAL); + LWIP_ERROR("mdns_resp_rename_service: Name too long", (len <= MDNS_LABEL_MAXLEN), return ERR_VAL); + LWIP_ERROR("mdns_resp_rename_service: Invalid Service ID", (slot >= 0) && (slot < MDNS_MAX_SERVICES), return ERR_VAL); + LWIP_ERROR("mdns_resp_rename_service: Invalid Service ID", (mdns->services[slot] != NULL), return ERR_VAL); + + srv = mdns->services[slot]; + + MEMCPY(&srv->name, name, LWIP_MIN(MDNS_LABEL_MAXLEN, len)); + srv->name[len] = '\0'; /* null termination in case new name is shorter than previous */ + + mdns_resp_restart(netif); + + return ERR_OK; +} + +/** + * @ingroup mdns + * Call this function from inside the service_get_txt_fn_t callback to add text data. + * Buffer for TXT data is 256 bytes, and each field is prefixed with a length byte. + * @param service The service provided to the get_txt callback + * @param txt String to add to the TXT field. + * @param txt_len Length of string + * @return ERR_OK if the string was added to the reply, an err_t otherwise + */ +err_t +mdns_resp_add_service_txtitem(struct mdns_service *service, const char *txt, u8_t txt_len) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mdns_resp_add_service_txtitem: service != NULL", service); + + /* Use a mdns_domain struct to store txt chunks since it is the same encoding */ + return mdns_domain_add_label(&service->txtdata, txt, txt_len); +} + +/** + * @ingroup mdns + * Send unsolicited answer containing all our known data + * @param netif The network interface to send on + */ +void +mdns_resp_announce(struct netif *netif) +{ + struct mdns_host* mdns; + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ERROR("mdns_resp_announce: netif != NULL", (netif != NULL), return); + + mdns = NETIF_TO_HOST(netif); + if (mdns == NULL) { + return; + } + + if (mdns->probing_state == MDNS_PROBING_COMPLETE) { + /* Announce on IPv6 and IPv4 */ +#if LWIP_IPV6 + mdns_announce(netif, IP6_ADDR_ANY); +#endif +#if LWIP_IPV4 + if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { + mdns_announce(netif, IP4_ADDR_ANY); + } +#endif + } /* else: ip address changed while probing was ongoing? @todo reset counter to restart? */ +} + +/** Register a callback function that is called if probing is completed successfully + * or with a conflict. */ +void +mdns_resp_register_name_result_cb(mdns_name_result_cb_t cb) +{ + mdns_name_result_cb = cb; +} + +/** + * @ingroup mdns + * Restart mdns responder. Call this when cable is connected after being disconnected or + * administrative interface is set up after being down + * @param netif The network interface to send on + */ +void +mdns_resp_restart(struct netif *netif) +{ + struct mdns_host* mdns; + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ERROR("mdns_resp_restart: netif != NULL", (netif != NULL), return); + + mdns = NETIF_TO_HOST(netif); + if (mdns == NULL) { + return; + } + + if (mdns->probing_state == MDNS_PROBING_ONGOING) { + sys_untimeout(mdns_probe, netif); + } + /* @todo if we've failed 15 times within a 10 second period we MUST wait 5 seconds (or wait 5 seconds every time except first)*/ + mdns->probes_sent = 0; + mdns->probing_state = MDNS_PROBING_ONGOING; + sys_timeout(MDNS_INITIAL_PROBE_DELAY_MS, mdns_probe, netif); +} + +/** + * @ingroup mdns + * Initiate MDNS responder. Will open UDP sockets on port 5353 + */ +void +mdns_resp_init(void) +{ + err_t res; + + /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ + + mdns_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + LWIP_ASSERT("Failed to allocate pcb", mdns_pcb != NULL); +#if LWIP_MULTICAST_TX_OPTIONS + udp_set_multicast_ttl(mdns_pcb, MDNS_TTL); +#else + mdns_pcb->ttl = MDNS_TTL; +#endif + res = udp_bind(mdns_pcb, IP_ANY_TYPE, LWIP_IANA_PORT_MDNS); + LWIP_UNUSED_ARG(res); /* in case of LWIP_NOASSERT */ + LWIP_ASSERT("Failed to bind pcb", res == ERR_OK); + udp_recv(mdns_pcb, mdns_recv, NULL); + + mdns_netif_client_id = netif_alloc_client_data_id(); + +#if MDNS_RESP_USENETIF_EXTCALLBACK + /* register for netif events when started on first netif */ + netif_add_ext_callback(&netif_callback, mdns_netif_ext_status_callback); +#endif +} + +#endif /* LWIP_MDNS_RESPONDER */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mqtt/mqtt.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mqtt/mqtt.c index f785ebe9..269f4a49 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mqtt/mqtt.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/mqtt/mqtt.c @@ -1,1463 +1,1463 @@ -/** - * @file - * MQTT client - * - * @defgroup mqtt MQTT client - * @ingroup apps - * @verbinclude mqtt_client.txt - */ - -/* - * Copyright (c) 2016 Erik Andersson - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack - * - * Author: Erik Andersson - * - * - * @todo: - * - Handle large outgoing payloads for PUBLISH messages - * - Fix restriction of a single topic in each (UN)SUBSCRIBE message (protocol has support for multiple topics) - * - Add support for legacy MQTT protocol version - * - * Please coordinate changes and requests with Erik Andersson - * Erik Andersson - * - */ -#include "lwip/apps/mqtt.h" -#include "lwip/apps/mqtt_priv.h" -#include "lwip/timeouts.h" -#include "lwip/ip_addr.h" -#include "lwip/mem.h" -#include "lwip/err.h" -#include "lwip/pbuf.h" -#include "lwip/altcp.h" -#include "lwip/altcp_tcp.h" -#include "lwip/altcp_tls.h" -#include - -#if LWIP_TCP && LWIP_CALLBACK_API - -/** - * MQTT_DEBUG: Default is off. - */ -#if !defined MQTT_DEBUG || defined __DOXYGEN__ -#define MQTT_DEBUG LWIP_DBG_OFF -#endif - -#define MQTT_DEBUG_TRACE (MQTT_DEBUG | LWIP_DBG_TRACE) -#define MQTT_DEBUG_STATE (MQTT_DEBUG | LWIP_DBG_STATE) -#define MQTT_DEBUG_WARN (MQTT_DEBUG | LWIP_DBG_LEVEL_WARNING) -#define MQTT_DEBUG_WARN_STATE (MQTT_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) -#define MQTT_DEBUG_SERIOUS (MQTT_DEBUG | LWIP_DBG_LEVEL_SERIOUS) - - - -/** - * MQTT client connection states - */ -enum { - TCP_DISCONNECTED, - TCP_CONNECTING, - MQTT_CONNECTING, - MQTT_CONNECTED -}; - -/** - * MQTT control message types - */ -enum mqtt_message_type { - MQTT_MSG_TYPE_CONNECT = 1, - MQTT_MSG_TYPE_CONNACK = 2, - MQTT_MSG_TYPE_PUBLISH = 3, - MQTT_MSG_TYPE_PUBACK = 4, - MQTT_MSG_TYPE_PUBREC = 5, - MQTT_MSG_TYPE_PUBREL = 6, - MQTT_MSG_TYPE_PUBCOMP = 7, - MQTT_MSG_TYPE_SUBSCRIBE = 8, - MQTT_MSG_TYPE_SUBACK = 9, - MQTT_MSG_TYPE_UNSUBSCRIBE = 10, - MQTT_MSG_TYPE_UNSUBACK = 11, - MQTT_MSG_TYPE_PINGREQ = 12, - MQTT_MSG_TYPE_PINGRESP = 13, - MQTT_MSG_TYPE_DISCONNECT = 14 -}; - -/** Helpers to extract control packet type and qos from first byte in fixed header */ -#define MQTT_CTL_PACKET_TYPE(fixed_hdr_byte0) ((fixed_hdr_byte0 & 0xf0) >> 4) -#define MQTT_CTL_PACKET_QOS(fixed_hdr_byte0) ((fixed_hdr_byte0 & 0x6) >> 1) - -/** - * MQTT connect flags, only used in CONNECT message - */ -enum mqtt_connect_flag { - MQTT_CONNECT_FLAG_USERNAME = 1 << 7, - MQTT_CONNECT_FLAG_PASSWORD = 1 << 6, - MQTT_CONNECT_FLAG_WILL_RETAIN = 1 << 5, - MQTT_CONNECT_FLAG_WILL = 1 << 2, - MQTT_CONNECT_FLAG_CLEAN_SESSION = 1 << 1 -}; - - -static void mqtt_cyclic_timer(void *arg); - -#if defined(LWIP_DEBUG) -static const char *const mqtt_message_type_str[15] = { - "UNDEFINED", - "CONNECT", - "CONNACK", - "PUBLISH", - "PUBACK", - "PUBREC", - "PUBREL", - "PUBCOMP", - "SUBSCRIBE", - "SUBACK", - "UNSUBSCRIBE", - "UNSUBACK", - "PINGREQ", - "PINGRESP", - "DISCONNECT" -}; - -/** - * Message type value to string - * @param msg_type see enum mqtt_message_type - * - * @return Control message type text string - */ -static const char * -mqtt_msg_type_to_str(u8_t msg_type) -{ - if (msg_type >= LWIP_ARRAYSIZE(mqtt_message_type_str)) { - msg_type = 0; - } - return mqtt_message_type_str[msg_type]; -} - -#endif - - -/** - * Generate MQTT packet identifier - * @param client MQTT client - * @return New packet identifier, range 1 to 65535 - */ -static u16_t -msg_generate_packet_id(mqtt_client_t *client) -{ - client->pkt_id_seq++; - if (client->pkt_id_seq == 0) { - client->pkt_id_seq++; - } - return client->pkt_id_seq; -} - -/*--------------------------------------------------------------------------------------------------------------------- */ -/* Output ring buffer */ - -/** Add single item to ring buffer */ -static void -mqtt_ringbuf_put(struct mqtt_ringbuf_t *rb, u8_t item) -{ - rb->buf[rb->put] = item; - rb->put++; - if (rb->put >= MQTT_OUTPUT_RINGBUF_SIZE) { - rb->put = 0; - } -} - -/** Return pointer to ring buffer get position */ -static u8_t * -mqtt_ringbuf_get_ptr(struct mqtt_ringbuf_t *rb) -{ - return &rb->buf[rb->get]; -} - -static void -mqtt_ringbuf_advance_get_idx(struct mqtt_ringbuf_t *rb, u16_t len) -{ - LWIP_ASSERT("mqtt_ringbuf_advance_get_idx: len < MQTT_OUTPUT_RINGBUF_SIZE", len < MQTT_OUTPUT_RINGBUF_SIZE); - - rb->get += len; - if (rb->get >= MQTT_OUTPUT_RINGBUF_SIZE) { - rb->get = rb->get - MQTT_OUTPUT_RINGBUF_SIZE; - } -} - -/** Return number of bytes in ring buffer */ -static u16_t -mqtt_ringbuf_len(struct mqtt_ringbuf_t *rb) -{ - u32_t len = rb->put - rb->get; - if (len > 0xFFFF) { - len += MQTT_OUTPUT_RINGBUF_SIZE; - } - return (u16_t)len; -} - -/** Return number of bytes free in ring buffer */ -#define mqtt_ringbuf_free(rb) (MQTT_OUTPUT_RINGBUF_SIZE - mqtt_ringbuf_len(rb)) - -/** Return number of bytes possible to read without wrapping around */ -#define mqtt_ringbuf_linear_read_length(rb) LWIP_MIN(mqtt_ringbuf_len(rb), (MQTT_OUTPUT_RINGBUF_SIZE - (rb)->get)) - -/** - * Try send as many bytes as possible from output ring buffer - * @param rb Output ring buffer - * @param tpcb TCP connection handle - */ -static void -mqtt_output_send(struct mqtt_ringbuf_t *rb, struct altcp_pcb *tpcb) -{ - err_t err; - u8_t wrap = 0; - u16_t ringbuf_lin_len = mqtt_ringbuf_linear_read_length(rb); - u16_t send_len = altcp_sndbuf(tpcb); - LWIP_ASSERT("mqtt_output_send: tpcb != NULL", tpcb != NULL); - - if (send_len == 0 || ringbuf_lin_len == 0) { - return; - } - - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_output_send: tcp_sndbuf: %d bytes, ringbuf_linear_available: %d, get %d, put %d\n", - send_len, ringbuf_lin_len, rb->get, rb->put)); - - if (send_len > ringbuf_lin_len) { - /* Space in TCP output buffer is larger than available in ring buffer linear portion */ - send_len = ringbuf_lin_len; - /* Wrap around if more data in ring buffer after linear portion */ - wrap = (mqtt_ringbuf_len(rb) > ringbuf_lin_len); - } - err = altcp_write(tpcb, mqtt_ringbuf_get_ptr(rb), send_len, TCP_WRITE_FLAG_COPY | (wrap ? TCP_WRITE_FLAG_MORE : 0)); - if ((err == ERR_OK) && wrap) { - mqtt_ringbuf_advance_get_idx(rb, send_len); - /* Use the lesser one of ring buffer linear length and TCP send buffer size */ - send_len = LWIP_MIN(altcp_sndbuf(tpcb), mqtt_ringbuf_linear_read_length(rb)); - err = altcp_write(tpcb, mqtt_ringbuf_get_ptr(rb), send_len, TCP_WRITE_FLAG_COPY); - } - - if (err == ERR_OK) { - mqtt_ringbuf_advance_get_idx(rb, send_len); - /* Flush */ - altcp_output(tpcb); - } else { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_output_send: Send failed with err %d (\"%s\")\n", err, lwip_strerr(err))); - } -} - - - -/*--------------------------------------------------------------------------------------------------------------------- */ -/* Request queue */ - -/** - * Create request item - * @param r_objs Pointer to request objects - * @param r_objs_len Number of array entries - * @param pkt_id Packet identifier of request - * @param cb Packet callback to call when requests lifetime ends - * @param arg Parameter following callback - * @return Request or NULL if failed to create - */ -static struct mqtt_request_t * -mqtt_create_request(struct mqtt_request_t *r_objs, size_t r_objs_len, u16_t pkt_id, mqtt_request_cb_t cb, void *arg) -{ - struct mqtt_request_t *r = NULL; - u8_t n; - LWIP_ASSERT("mqtt_create_request: r_objs != NULL", r_objs != NULL); - for (n = 0; n < r_objs_len; n++) { - /* Item point to itself if not in use */ - if (r_objs[n].next == &r_objs[n]) { - r = &r_objs[n]; - r->next = NULL; - r->cb = cb; - r->arg = arg; - r->pkt_id = pkt_id; - break; - } - } - return r; -} - - -/** - * Append request to pending request queue - * @param tail Pointer to request queue tail pointer - * @param r Request to append - */ -static void -mqtt_append_request(struct mqtt_request_t **tail, struct mqtt_request_t *r) -{ - struct mqtt_request_t *head = NULL; - s16_t time_before = 0; - struct mqtt_request_t *iter; - - LWIP_ASSERT("mqtt_append_request: tail != NULL", tail != NULL); - - /* Iterate trough queue to find head, and count total timeout time */ - for (iter = *tail; iter != NULL; iter = iter->next) { - time_before += iter->timeout_diff; - head = iter; - } - - LWIP_ASSERT("mqtt_append_request: time_before <= MQTT_REQ_TIMEOUT", time_before <= MQTT_REQ_TIMEOUT); - r->timeout_diff = MQTT_REQ_TIMEOUT - time_before; - if (head == NULL) { - *tail = r; - } else { - head->next = r; - } -} - - -/** - * Delete request item - * @param r Request item to delete - */ -static void -mqtt_delete_request(struct mqtt_request_t *r) -{ - if (r != NULL) { - r->next = r; - } -} - -/** - * Remove a request item with a specific packet identifier from request queue - * @param tail Pointer to request queue tail pointer - * @param pkt_id Packet identifier of request to take - * @return Request item if found, NULL if not - */ -static struct mqtt_request_t * -mqtt_take_request(struct mqtt_request_t **tail, u16_t pkt_id) -{ - struct mqtt_request_t *iter = NULL, *prev = NULL; - LWIP_ASSERT("mqtt_take_request: tail != NULL", tail != NULL); - /* Search all request for pkt_id */ - for (iter = *tail; iter != NULL; iter = iter->next) { - if (iter->pkt_id == pkt_id) { - break; - } - prev = iter; - } - - /* If request was found */ - if (iter != NULL) { - /* unchain */ - if (prev == NULL) { - *tail = iter->next; - } else { - prev->next = iter->next; - } - /* If exists, add remaining timeout time for the request to next */ - if (iter->next != NULL) { - iter->next->timeout_diff += iter->timeout_diff; - } - iter->next = NULL; - } - return iter; -} - -/** - * Handle requests timeout - * @param tail Pointer to request queue tail pointer - * @param t Time since last call in seconds - */ -static void -mqtt_request_time_elapsed(struct mqtt_request_t **tail, u8_t t) -{ - struct mqtt_request_t *r; - LWIP_ASSERT("mqtt_request_time_elapsed: tail != NULL", tail != NULL); - r = *tail; - while (t > 0 && r != NULL) { - if (t >= r->timeout_diff) { - t -= (u8_t)r->timeout_diff; - /* Unchain */ - *tail = r->next; - /* Notify upper layer about timeout */ - if (r->cb != NULL) { - r->cb(r->arg, ERR_TIMEOUT); - } - mqtt_delete_request(r); - /* Tail might be be modified in callback, so re-read it in every iteration */ - r = *(struct mqtt_request_t *const volatile *)tail; - } else { - r->timeout_diff -= t; - t = 0; - } - } -} - -/** - * Free all request items - * @param tail Pointer to request queue tail pointer - */ -static void -mqtt_clear_requests(struct mqtt_request_t **tail) -{ - struct mqtt_request_t *iter, *next; - LWIP_ASSERT("mqtt_clear_requests: tail != NULL", tail != NULL); - for (iter = *tail; iter != NULL; iter = next) { - next = iter->next; - mqtt_delete_request(iter); - } - *tail = NULL; -} -/** - * Initialize all request items - * @param r_objs Pointer to request objects - * @param r_objs_len Number of array entries - */ -static void -mqtt_init_requests(struct mqtt_request_t *r_objs, size_t r_objs_len) -{ - u8_t n; - LWIP_ASSERT("mqtt_init_requests: r_objs != NULL", r_objs != NULL); - for (n = 0; n < r_objs_len; n++) { - /* Item pointing to itself indicates unused */ - r_objs[n].next = &r_objs[n]; - } -} - -/*--------------------------------------------------------------------------------------------------------------------- */ -/* Output message build helpers */ - - -static void -mqtt_output_append_u8(struct mqtt_ringbuf_t *rb, u8_t value) -{ - mqtt_ringbuf_put(rb, value); -} - -static -void mqtt_output_append_u16(struct mqtt_ringbuf_t *rb, u16_t value) -{ - mqtt_ringbuf_put(rb, value >> 8); - mqtt_ringbuf_put(rb, value & 0xff); -} - -static void -mqtt_output_append_buf(struct mqtt_ringbuf_t *rb, const void *data, u16_t length) -{ - u16_t n; - for (n = 0; n < length; n++) { - mqtt_ringbuf_put(rb, ((const u8_t *)data)[n]); - } -} - -static void -mqtt_output_append_string(struct mqtt_ringbuf_t *rb, const char *str, u16_t length) -{ - u16_t n; - mqtt_ringbuf_put(rb, length >> 8); - mqtt_ringbuf_put(rb, length & 0xff); - for (n = 0; n < length; n++) { - mqtt_ringbuf_put(rb, str[n]); - } -} - -/** - * Append fixed header - * @param rb Output ring buffer - * @param msg_type see enum mqtt_message_type - * @param fdup MQTT DUP flag - * @param fqos MQTT QoS field - * @param fretain MQTT retain flag - * @param r_length Remaining length after fixed header - */ - -static void -mqtt_output_append_fixed_header(struct mqtt_ringbuf_t *rb, u8_t msg_type, u8_t fdup, - u8_t fqos, u8_t fretain, u16_t r_length) -{ - /* Start with control byte */ - mqtt_output_append_u8(rb, (((msg_type & 0x0f) << 4) | ((fdup & 1) << 3) | ((fqos & 3) << 1) | (fretain & 1))); - /* Encode remaining length field */ - do { - mqtt_output_append_u8(rb, (r_length & 0x7f) | (r_length >= 128 ? 0x80 : 0)); - r_length >>= 7; - } while (r_length > 0); -} - - -/** - * Check output buffer space - * @param rb Output ring buffer - * @param r_length Remaining length after fixed header - * @return 1 if message will fit, 0 if not enough buffer space - */ -static u8_t -mqtt_output_check_space(struct mqtt_ringbuf_t *rb, u16_t r_length) -{ - /* Start with length of type byte + remaining length */ - u16_t total_len = 1 + r_length; - - LWIP_ASSERT("mqtt_output_check_space: rb != NULL", rb != NULL); - - /* Calculate number of required bytes to contain the remaining bytes field and add to total*/ - do { - total_len++; - r_length >>= 7; - } while (r_length > 0); - - return (total_len <= mqtt_ringbuf_free(rb)); -} - - -/** - * Close connection to server - * @param client MQTT client - * @param reason Reason for disconnection - */ -static void -mqtt_close(mqtt_client_t *client, mqtt_connection_status_t reason) -{ - LWIP_ASSERT("mqtt_close: client != NULL", client != NULL); - - /* Bring down TCP connection if not already done */ - if (client->conn != NULL) { - err_t res; - altcp_recv(client->conn, NULL); - altcp_err(client->conn, NULL); - altcp_sent(client->conn, NULL); - res = altcp_close(client->conn); - if (res != ERR_OK) { - altcp_abort(client->conn); - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_close: Close err=%s\n", lwip_strerr(res))); - } - client->conn = NULL; - } - - /* Remove all pending requests */ - mqtt_clear_requests(&client->pend_req_queue); - /* Stop cyclic timer */ - sys_untimeout(mqtt_cyclic_timer, client); - - /* Notify upper layer of disconnection if changed state */ - if (client->conn_state != TCP_DISCONNECTED) { - - client->conn_state = TCP_DISCONNECTED; - if (client->connect_cb != NULL) { - client->connect_cb(client, client->connect_arg, reason); - } - } -} - - -/** - * Interval timer, called every MQTT_CYCLIC_TIMER_INTERVAL seconds in MQTT_CONNECTING and MQTT_CONNECTED states - * @param arg MQTT client - */ -static void -mqtt_cyclic_timer(void *arg) -{ - u8_t restart_timer = 1; - mqtt_client_t *client = (mqtt_client_t *)arg; - LWIP_ASSERT("mqtt_cyclic_timer: client != NULL", client != NULL); - - if (client->conn_state == MQTT_CONNECTING) { - client->cyclic_tick++; - if ((client->cyclic_tick * MQTT_CYCLIC_TIMER_INTERVAL) >= MQTT_CONNECT_TIMOUT) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_cyclic_timer: CONNECT attempt to server timed out\n")); - /* Disconnect TCP */ - mqtt_close(client, MQTT_CONNECT_TIMEOUT); - restart_timer = 0; - } - } else if (client->conn_state == MQTT_CONNECTED) { - /* Handle timeout for pending requests */ - mqtt_request_time_elapsed(&client->pend_req_queue, MQTT_CYCLIC_TIMER_INTERVAL); - - /* keep_alive > 0 means keep alive functionality shall be used */ - if (client->keep_alive > 0) { - - client->server_watchdog++; - /* If reception from server has been idle for 1.5*keep_alive time, server is considered unresponsive */ - if ((client->server_watchdog * MQTT_CYCLIC_TIMER_INTERVAL) > (client->keep_alive + client->keep_alive / 2)) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_cyclic_timer: Server incoming keep-alive timeout\n")); - mqtt_close(client, MQTT_CONNECT_TIMEOUT); - restart_timer = 0; - } - - /* If time for a keep alive message to be sent, transmission has been idle for keep_alive time */ - if ((client->cyclic_tick * MQTT_CYCLIC_TIMER_INTERVAL) >= client->keep_alive) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_cyclic_timer: Sending keep-alive message to server\n")); - if (mqtt_output_check_space(&client->output, 0) != 0) { - mqtt_output_append_fixed_header(&client->output, MQTT_MSG_TYPE_PINGREQ, 0, 0, 0, 0); - client->cyclic_tick = 0; - } - } else { - client->cyclic_tick++; - } - } - } else { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_cyclic_timer: Timer should not be running in state %d\n", client->conn_state)); - restart_timer = 0; - } - if (restart_timer) { - sys_timeout(MQTT_CYCLIC_TIMER_INTERVAL * 1000, mqtt_cyclic_timer, arg); - } -} - - -/** - * Send PUBACK, PUBREC or PUBREL response message - * @param client MQTT client - * @param msg PUBACK, PUBREC or PUBREL - * @param pkt_id Packet identifier - * @param qos QoS value - * @return ERR_OK if successful, ERR_MEM if out of memory - */ -static err_t -pub_ack_rec_rel_response(mqtt_client_t *client, u8_t msg, u16_t pkt_id, u8_t qos) -{ - err_t err = ERR_OK; - if (mqtt_output_check_space(&client->output, 2)) { - mqtt_output_append_fixed_header(&client->output, msg, 0, qos, 0, 2); - mqtt_output_append_u16(&client->output, pkt_id); - mqtt_output_send(&client->output, client->conn); - } else { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("pub_ack_rec_rel_response: OOM creating response: %s with pkt_id: %d\n", - mqtt_msg_type_to_str(msg), pkt_id)); - err = ERR_MEM; - } - return err; -} - -/** - * Subscribe response from server - * @param r Matching request - * @param result Result code from server - */ -static void -mqtt_incomming_suback(struct mqtt_request_t *r, u8_t result) -{ - if (r->cb != NULL) { - r->cb(r->arg, result < 3 ? ERR_OK : ERR_ABRT); - } -} - - -/** - * Complete MQTT message received or buffer full - * @param client MQTT client - * @param fixed_hdr_idx header index - * @param length length received part - * @param remaining_length Remaining length of complete message - */ -static mqtt_connection_status_t -mqtt_message_received(mqtt_client_t *client, u8_t fixed_hdr_idx, u16_t length, u32_t remaining_length) -{ - mqtt_connection_status_t res = MQTT_CONNECT_ACCEPTED; - - u8_t *var_hdr_payload = client->rx_buffer + fixed_hdr_idx; - size_t var_hdr_payload_bufsize = sizeof(client->rx_buffer) - fixed_hdr_idx; - - /* Control packet type */ - u8_t pkt_type = MQTT_CTL_PACKET_TYPE(client->rx_buffer[0]); - u16_t pkt_id = 0; - - LWIP_ASSERT("client->msg_idx < MQTT_VAR_HEADER_BUFFER_LEN", client->msg_idx < MQTT_VAR_HEADER_BUFFER_LEN); - LWIP_ASSERT("fixed_hdr_idx <= client->msg_idx", fixed_hdr_idx <= client->msg_idx); - LWIP_ERROR("buffer length mismatch", fixed_hdr_idx + length <= MQTT_VAR_HEADER_BUFFER_LEN, - return MQTT_CONNECT_DISCONNECTED); - - if (pkt_type == MQTT_MSG_TYPE_CONNACK) { - if (client->conn_state == MQTT_CONNECTING) { - if (length < 2) { - LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short CONNACK message\n")); - goto out_disconnect; - } - /* Get result code from CONNACK */ - res = (mqtt_connection_status_t)var_hdr_payload[1]; - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: Connect response code %d\n", res)); - if (res == MQTT_CONNECT_ACCEPTED) { - /* Reset cyclic_tick when changing to connected state */ - client->cyclic_tick = 0; - client->conn_state = MQTT_CONNECTED; - /* Notify upper layer */ - if (client->connect_cb != 0) { - client->connect_cb(client, client->connect_arg, res); - } - } - } else { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: Received CONNACK in connected state\n")); - } - } else if (pkt_type == MQTT_MSG_TYPE_PINGRESP) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ( "mqtt_message_received: Received PINGRESP from server\n")); - - } else if (pkt_type == MQTT_MSG_TYPE_PUBLISH) { - u16_t payload_offset = 0; - u16_t payload_length = length; - u8_t qos = MQTT_CTL_PACKET_QOS(client->rx_buffer[0]); - - if (client->msg_idx <= MQTT_VAR_HEADER_BUFFER_LEN) { - /* Should have topic and pkt id*/ - u8_t *topic; - u16_t after_topic; - u8_t bkp; - u16_t topic_len; - u16_t qos_len = (qos ? 2U : 0U); - if (length < 2 + qos_len) { - LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short PUBLISH packet\n")); - goto out_disconnect; - } - topic_len = var_hdr_payload[0]; - topic_len = (topic_len << 8) + (u16_t)(var_hdr_payload[1]); - if ((topic_len > length - (2 + qos_len)) || - (topic_len > var_hdr_payload_bufsize - (2 + qos_len))) { - LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short PUBLISH packet (topic)\n")); - goto out_disconnect; - } - - topic = var_hdr_payload + 2; - after_topic = 2 + topic_len; - /* Check buffer length, add one byte even for QoS 0 so that zero termination will fit */ - if ((after_topic + (qos ? 2U : 1U)) > var_hdr_payload_bufsize) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: Receive buffer can not fit topic + pkt_id\n")); - goto out_disconnect; - } - - /* id for QoS 1 and 2 */ - if (qos > 0) { - if (length < after_topic + 2U) { - LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short PUBLISH packet (after_topic)\n")); - goto out_disconnect; - } - client->inpub_pkt_id = ((u16_t)var_hdr_payload[after_topic] << 8) + (u16_t)var_hdr_payload[after_topic + 1]; - after_topic += 2; - } else { - client->inpub_pkt_id = 0; - } - /* Take backup of byte after topic */ - bkp = topic[topic_len]; - /* Zero terminate string */ - topic[topic_len] = 0; - /* Payload data remaining in receive buffer */ - payload_length = length - after_topic; - payload_offset = after_topic; - - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_incomming_publish: Received message with QoS %d at topic: %s, payload length %"U32_F"\n", - qos, topic, remaining_length + payload_length)); - if (client->pub_cb != NULL) { - client->pub_cb(client->inpub_arg, (const char *)topic, remaining_length + payload_length); - } - /* Restore byte after topic */ - topic[topic_len] = bkp; - } - if (payload_length > 0 || remaining_length == 0) { - if (length < (size_t)(payload_offset + payload_length)) { - LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short packet (payload)\n")); - goto out_disconnect; - } - client->data_cb(client->inpub_arg, var_hdr_payload + payload_offset, payload_length, remaining_length == 0 ? MQTT_DATA_FLAG_LAST : 0); - /* Reply if QoS > 0 */ - if (remaining_length == 0 && qos > 0) { - /* Send PUBACK for QoS 1 or PUBREC for QoS 2 */ - u8_t resp_msg = (qos == 1) ? MQTT_MSG_TYPE_PUBACK : MQTT_MSG_TYPE_PUBREC; - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_incomming_publish: Sending publish response: %s with pkt_id: %d\n", - mqtt_msg_type_to_str(resp_msg), client->inpub_pkt_id)); - pub_ack_rec_rel_response(client, resp_msg, client->inpub_pkt_id, 0); - } - } - } else { - /* Get packet identifier */ - pkt_id = (u16_t)var_hdr_payload[0] << 8; - pkt_id |= (u16_t)var_hdr_payload[1]; - if (pkt_id == 0) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: Got message with illegal packet identifier: 0\n")); - goto out_disconnect; - } - if (pkt_type == MQTT_MSG_TYPE_PUBREC) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: PUBREC, sending PUBREL with pkt_id: %d\n", pkt_id)); - pub_ack_rec_rel_response(client, MQTT_MSG_TYPE_PUBREL, pkt_id, 1); - - } else if (pkt_type == MQTT_MSG_TYPE_PUBREL) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: PUBREL, sending PUBCOMP response with pkt_id: %d\n", pkt_id)); - pub_ack_rec_rel_response(client, MQTT_MSG_TYPE_PUBCOMP, pkt_id, 0); - - } else if (pkt_type == MQTT_MSG_TYPE_SUBACK || pkt_type == MQTT_MSG_TYPE_UNSUBACK || - pkt_type == MQTT_MSG_TYPE_PUBCOMP || pkt_type == MQTT_MSG_TYPE_PUBACK) { - struct mqtt_request_t *r = mqtt_take_request(&client->pend_req_queue, pkt_id); - if (r != NULL) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: %s response with id %d\n", mqtt_msg_type_to_str(pkt_type), pkt_id)); - if (pkt_type == MQTT_MSG_TYPE_SUBACK) { - if (length < 3) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: To small SUBACK packet\n")); - goto out_disconnect; - } else { - mqtt_incomming_suback(r, var_hdr_payload[2]); - } - } else if (r->cb != NULL) { - r->cb(r->arg, ERR_OK); - } - mqtt_delete_request(r); - } else { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ( "mqtt_message_received: Received %s reply, with wrong pkt_id: %d\n", mqtt_msg_type_to_str(pkt_type), pkt_id)); - } - } else { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ( "mqtt_message_received: Received unknown message type: %d\n", pkt_type)); - goto out_disconnect; - } - } - return res; -out_disconnect: - return MQTT_CONNECT_DISCONNECTED; -} - - -/** - * MQTT incoming message parser - * @param client MQTT client - * @param p PBUF chain of received data - * @return Connection status - */ -static mqtt_connection_status_t -mqtt_parse_incoming(mqtt_client_t *client, struct pbuf *p) -{ - u16_t in_offset = 0; - u32_t msg_rem_len = 0; - u8_t fixed_hdr_idx = 0; - u8_t b = 0; - - while (p->tot_len > in_offset) { - /* We ALWAYS parse the header here first. Even if the header was not - included in this segment, we re-parse it here by buffering it in - client->rx_buffer. client->msg_idx keeps track of this. */ - if ((fixed_hdr_idx < 2) || ((b & 0x80) != 0)) { - - if (fixed_hdr_idx < client->msg_idx) { - /* parse header from old pbuf (buffered in client->rx_buffer) */ - b = client->rx_buffer[fixed_hdr_idx]; - } else { - /* parse header from this pbuf and save it in client->rx_buffer in case - it comes in segmented */ - b = pbuf_get_at(p, in_offset++); - client->rx_buffer[client->msg_idx++] = b; - } - fixed_hdr_idx++; - - if (fixed_hdr_idx >= 2) { - /* fixed header contains at least 2 bytes but can contain more, depending on - 'remaining length'. All bytes but the last of this have 0x80 set to - indicate more bytes are coming. */ - msg_rem_len |= (u32_t)(b & 0x7f) << ((fixed_hdr_idx - 2) * 7); - if ((b & 0x80) == 0) { - /* fixed header is done */ - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_parse_incoming: Remaining length after fixed header: %"U32_F"\n", msg_rem_len)); - if (msg_rem_len == 0) { - /* Complete message with no extra headers of payload received */ - mqtt_message_received(client, fixed_hdr_idx, 0, 0); - client->msg_idx = 0; - fixed_hdr_idx = 0; - } else { - /* Bytes remaining in message (changes remaining length if this is - not the first segment of this message) */ - msg_rem_len = (msg_rem_len + fixed_hdr_idx) - client->msg_idx; - } - } - } - } else { - /* Fixed header has been parsed, parse variable header */ - u16_t cpy_len, cpy_start, buffer_space; - - cpy_start = (client->msg_idx - fixed_hdr_idx) % (MQTT_VAR_HEADER_BUFFER_LEN - fixed_hdr_idx) + fixed_hdr_idx; - - /* Allow to copy the lesser one of available length in input data or bytes remaining in message */ - cpy_len = (u16_t)LWIP_MIN((u16_t)(p->tot_len - in_offset), msg_rem_len); - - /* Limit to available space in buffer */ - buffer_space = MQTT_VAR_HEADER_BUFFER_LEN - cpy_start; - if (cpy_len > buffer_space) { - cpy_len = buffer_space; - } - pbuf_copy_partial(p, client->rx_buffer + cpy_start, cpy_len, in_offset); - - /* Advance get and put indexes */ - client->msg_idx += cpy_len; - in_offset += cpy_len; - msg_rem_len -= cpy_len; - - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_parse_incoming: msg_idx: %"U32_F", cpy_len: %"U16_F", remaining %"U32_F"\n", client->msg_idx, cpy_len, msg_rem_len)); - if ((msg_rem_len == 0) || (cpy_len == buffer_space)) { - /* Whole message received or buffer is full */ - mqtt_connection_status_t res = mqtt_message_received(client, fixed_hdr_idx, (cpy_start + cpy_len) - fixed_hdr_idx, msg_rem_len); - if (res != MQTT_CONNECT_ACCEPTED) { - return res; - } - if (msg_rem_len == 0) { - /* Reset parser state */ - client->msg_idx = 0; - /* msg_tot_len = 0; */ - fixed_hdr_idx = 0; - } - } - } - } - return MQTT_CONNECT_ACCEPTED; -} - - -/** - * TCP received callback function. @see tcp_recv_fn - * @param arg MQTT client - * @param p PBUF chain of received data - * @param err Passed as return value if not ERR_OK - * @return ERR_OK or err passed into callback - */ -static err_t -mqtt_tcp_recv_cb(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) -{ - mqtt_client_t *client = (mqtt_client_t *)arg; - LWIP_ASSERT("mqtt_tcp_recv_cb: client != NULL", client != NULL); - LWIP_ASSERT("mqtt_tcp_recv_cb: client->conn == pcb", client->conn == pcb); - - if (p == NULL) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_recv_cb: Recv pbuf=NULL, remote has closed connection\n")); - mqtt_close(client, MQTT_CONNECT_DISCONNECTED); - } else { - mqtt_connection_status_t res; - if (err != ERR_OK) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_tcp_recv_cb: Recv err=%d\n", err)); - pbuf_free(p); - return err; - } - - /* Tell remote that data has been received */ - altcp_recved(pcb, p->tot_len); - res = mqtt_parse_incoming(client, p); - pbuf_free(p); - - if (res != MQTT_CONNECT_ACCEPTED) { - mqtt_close(client, res); - } - /* If keep alive functionality is used */ - if (client->keep_alive != 0) { - /* Reset server alive watchdog */ - client->server_watchdog = 0; - } - - } - return ERR_OK; -} - - -/** - * TCP data sent callback function. @see tcp_sent_fn - * @param arg MQTT client - * @param tpcb TCP connection handle - * @param len Number of bytes sent - * @return ERR_OK - */ -static err_t -mqtt_tcp_sent_cb(void *arg, struct altcp_pcb *tpcb, u16_t len) -{ - mqtt_client_t *client = (mqtt_client_t *)arg; - - LWIP_UNUSED_ARG(tpcb); - LWIP_UNUSED_ARG(len); - - if (client->conn_state == MQTT_CONNECTED) { - struct mqtt_request_t *r; - - /* Reset keep-alive send timer and server watchdog */ - client->cyclic_tick = 0; - client->server_watchdog = 0; - /* QoS 0 publish has no response from server, so call its callbacks here */ - while ((r = mqtt_take_request(&client->pend_req_queue, 0)) != NULL) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_sent_cb: Calling QoS 0 publish complete callback\n")); - if (r->cb != NULL) { - r->cb(r->arg, ERR_OK); - } - mqtt_delete_request(r); - } - /* Try send any remaining buffers from output queue */ - mqtt_output_send(&client->output, client->conn); - } - return ERR_OK; -} - -/** - * TCP error callback function. @see tcp_err_fn - * @param arg MQTT client - * @param err Error encountered - */ -static void -mqtt_tcp_err_cb(void *arg, err_t err) -{ - mqtt_client_t *client = (mqtt_client_t *)arg; - LWIP_UNUSED_ARG(err); /* only used for debug output */ - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_err_cb: TCP error callback: error %d, arg: %p\n", err, arg)); - LWIP_ASSERT("mqtt_tcp_err_cb: client != NULL", client != NULL); - /* Set conn to null before calling close as pcb is already deallocated*/ - client->conn = 0; - mqtt_close(client, MQTT_CONNECT_DISCONNECTED); -} - -/** - * TCP poll callback function. @see tcp_poll_fn - * @param arg MQTT client - * @param tpcb TCP connection handle - * @return err ERR_OK - */ -static err_t -mqtt_tcp_poll_cb(void *arg, struct altcp_pcb *tpcb) -{ - mqtt_client_t *client = (mqtt_client_t *)arg; - if (client->conn_state == MQTT_CONNECTED) { - /* Try send any remaining buffers from output queue */ - mqtt_output_send(&client->output, tpcb); - } - return ERR_OK; -} - -/** - * TCP connect callback function. @see tcp_connected_fn - * @param arg MQTT client - * @param err Always ERR_OK, mqtt_tcp_err_cb is called in case of error - * @return ERR_OK - */ -static err_t -mqtt_tcp_connect_cb(void *arg, struct altcp_pcb *tpcb, err_t err) -{ - mqtt_client_t *client = (mqtt_client_t *)arg; - - if (err != ERR_OK) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_tcp_connect_cb: TCP connect error %d\n", err)); - return err; - } - - /* Initiate receiver state */ - client->msg_idx = 0; - - /* Setup TCP callbacks */ - altcp_recv(tpcb, mqtt_tcp_recv_cb); - altcp_sent(tpcb, mqtt_tcp_sent_cb); - altcp_poll(tpcb, mqtt_tcp_poll_cb, 2); - - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_connect_cb: TCP connection established to server\n")); - /* Enter MQTT connect state */ - client->conn_state = MQTT_CONNECTING; - - /* Start cyclic timer */ - sys_timeout(MQTT_CYCLIC_TIMER_INTERVAL * 1000, mqtt_cyclic_timer, client); - client->cyclic_tick = 0; - - /* Start transmission from output queue, connect message is the first one out*/ - mqtt_output_send(&client->output, client->conn); - - return ERR_OK; -} - - - -/*---------------------------------------------------------------------------------------------------- */ -/* Public API */ - - -/** - * @ingroup mqtt - * MQTT publish function. - * @param client MQTT client - * @param topic Publish topic string - * @param payload Data to publish (NULL is allowed) - * @param payload_length Length of payload (0 is allowed) - * @param qos Quality of service, 0 1 or 2 - * @param retain MQTT retain flag - * @param cb Callback to call when publish is complete or has timed out - * @param arg User supplied argument to publish callback - * @return ERR_OK if successful - * ERR_CONN if client is disconnected - * ERR_MEM if short on memory - */ -err_t -mqtt_publish(mqtt_client_t *client, const char *topic, const void *payload, u16_t payload_length, u8_t qos, u8_t retain, - mqtt_request_cb_t cb, void *arg) -{ - struct mqtt_request_t *r; - u16_t pkt_id; - size_t topic_strlen; - size_t total_len; - u16_t topic_len; - u16_t remaining_length; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mqtt_publish: client != NULL", client); - LWIP_ASSERT("mqtt_publish: topic != NULL", topic); - LWIP_ERROR("mqtt_publish: TCP disconnected", (client->conn_state != TCP_DISCONNECTED), return ERR_CONN); - - topic_strlen = strlen(topic); - LWIP_ERROR("mqtt_publish: topic length overflow", (topic_strlen <= (0xFFFF - 2)), return ERR_ARG); - topic_len = (u16_t)topic_strlen; - total_len = 2 + topic_len + payload_length; - - if (qos > 0) { - total_len += 2; - /* Generate pkt_id id for QoS1 and 2 */ - pkt_id = msg_generate_packet_id(client); - } else { - /* Use reserved value pkt_id 0 for QoS 0 in request handle */ - pkt_id = 0; - } - LWIP_ERROR("mqtt_publish: total length overflow", (total_len <= 0xFFFF), return ERR_ARG); - remaining_length = (u16_t)total_len; - - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_publish: Publish with payload length %d to topic \"%s\"\n", payload_length, topic)); - - r = mqtt_create_request(client->req_list, LWIP_ARRAYSIZE(client->req_list), pkt_id, cb, arg); - if (r == NULL) { - return ERR_MEM; - } - - if (mqtt_output_check_space(&client->output, remaining_length) == 0) { - mqtt_delete_request(r); - return ERR_MEM; - } - /* Append fixed header */ - mqtt_output_append_fixed_header(&client->output, MQTT_MSG_TYPE_PUBLISH, 0, qos, retain, remaining_length); - - /* Append Topic */ - mqtt_output_append_string(&client->output, topic, topic_len); - - /* Append packet if for QoS 1 and 2*/ - if (qos > 0) { - mqtt_output_append_u16(&client->output, pkt_id); - } - - /* Append optional publish payload */ - if ((payload != NULL) && (payload_length > 0)) { - mqtt_output_append_buf(&client->output, payload, payload_length); - } - - mqtt_append_request(&client->pend_req_queue, r); - mqtt_output_send(&client->output, client->conn); - return ERR_OK; -} - - -/** - * @ingroup mqtt - * MQTT subscribe/unsubscribe function. - * @param client MQTT client - * @param topic topic to subscribe to - * @param qos Quality of service, 0 1 or 2 (only used for subscribe) - * @param cb Callback to call when subscribe/unsubscribe reponse is received - * @param arg User supplied argument to publish callback - * @param sub 1 for subscribe, 0 for unsubscribe - * @return ERR_OK if successful, @see err_t enum for other results - */ -err_t -mqtt_sub_unsub(mqtt_client_t *client, const char *topic, u8_t qos, mqtt_request_cb_t cb, void *arg, u8_t sub) -{ - size_t topic_strlen; - size_t total_len; - u16_t topic_len; - u16_t remaining_length; - u16_t pkt_id; - struct mqtt_request_t *r; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mqtt_sub_unsub: client != NULL", client); - LWIP_ASSERT("mqtt_sub_unsub: topic != NULL", topic); - - topic_strlen = strlen(topic); - LWIP_ERROR("mqtt_sub_unsub: topic length overflow", (topic_strlen <= (0xFFFF - 2)), return ERR_ARG); - topic_len = (u16_t)topic_strlen; - /* Topic string, pkt_id, qos for subscribe */ - total_len = topic_len + 2 + 2 + (sub != 0); - LWIP_ERROR("mqtt_sub_unsub: total length overflow", (total_len <= 0xFFFF), return ERR_ARG); - remaining_length = (u16_t)total_len; - - LWIP_ASSERT("mqtt_sub_unsub: qos < 3", qos < 3); - if (client->conn_state == TCP_DISCONNECTED) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_sub_unsub: Can not (un)subscribe in disconnected state\n")); - return ERR_CONN; - } - - pkt_id = msg_generate_packet_id(client); - r = mqtt_create_request(client->req_list, LWIP_ARRAYSIZE(client->req_list), pkt_id, cb, arg); - if (r == NULL) { - return ERR_MEM; - } - - if (mqtt_output_check_space(&client->output, remaining_length) == 0) { - mqtt_delete_request(r); - return ERR_MEM; - } - - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_sub_unsub: Client (un)subscribe to topic \"%s\", id: %d\n", topic, pkt_id)); - - mqtt_output_append_fixed_header(&client->output, sub ? MQTT_MSG_TYPE_SUBSCRIBE : MQTT_MSG_TYPE_UNSUBSCRIBE, 0, 1, 0, remaining_length); - /* Packet id */ - mqtt_output_append_u16(&client->output, pkt_id); - /* Topic */ - mqtt_output_append_string(&client->output, topic, topic_len); - /* QoS */ - if (sub != 0) { - mqtt_output_append_u8(&client->output, LWIP_MIN(qos, 2)); - } - - mqtt_append_request(&client->pend_req_queue, r); - mqtt_output_send(&client->output, client->conn); - return ERR_OK; -} - - -/** - * @ingroup mqtt - * Set callback to handle incoming publish requests from server - * @param client MQTT client - * @param pub_cb Callback invoked when publish starts, contain topic and total length of payload - * @param data_cb Callback for each fragment of payload that arrives - * @param arg User supplied argument to both callbacks - */ -void -mqtt_set_inpub_callback(mqtt_client_t *client, mqtt_incoming_publish_cb_t pub_cb, - mqtt_incoming_data_cb_t data_cb, void *arg) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mqtt_set_inpub_callback: client != NULL", client != NULL); - client->data_cb = data_cb; - client->pub_cb = pub_cb; - client->inpub_arg = arg; -} - -/** - * @ingroup mqtt - * Create a new MQTT client instance - * @return Pointer to instance on success, NULL otherwise - */ -mqtt_client_t * -mqtt_client_new(void) -{ - LWIP_ASSERT_CORE_LOCKED(); - return (mqtt_client_t *)mem_calloc(1, sizeof(mqtt_client_t)); -} - -/** - * @ingroup mqtt - * Free MQTT client instance - * @param client Pointer to instance to be freed - */ -void -mqtt_client_free(mqtt_client_t *client) -{ - mem_free(client); -} - -/** - * @ingroup mqtt - * Connect to MQTT server - * @param client MQTT client - * @param ip_addr Server IP - * @param port Server port - * @param cb Connection state change callback - * @param arg User supplied argument to connection callback - * @param client_info Client identification and connection options - * @return ERR_OK if successful, @see err_t enum for other results - */ -err_t -mqtt_client_connect(mqtt_client_t *client, const ip_addr_t *ip_addr, u16_t port, mqtt_connection_cb_t cb, void *arg, - const struct mqtt_connect_client_info_t *client_info) -{ - err_t err; - size_t len; - u16_t client_id_length; - /* Length is the sum of 2+"MQTT", protocol level, flags and keep alive */ - u16_t remaining_length = 2 + 4 + 1 + 1 + 2; - u8_t flags = 0, will_topic_len = 0, will_msg_len = 0; - u16_t client_user_len = 0, client_pass_len = 0; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mqtt_client_connect: client != NULL", client != NULL); - LWIP_ASSERT("mqtt_client_connect: ip_addr != NULL", ip_addr != NULL); - LWIP_ASSERT("mqtt_client_connect: client_info != NULL", client_info != NULL); - LWIP_ASSERT("mqtt_client_connect: client_info->client_id != NULL", client_info->client_id != NULL); - - if (client->conn_state != TCP_DISCONNECTED) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_client_connect: Already connected\n")); - return ERR_ISCONN; - } - - /* Wipe clean */ - memset(client, 0, sizeof(mqtt_client_t)); - client->connect_arg = arg; - client->connect_cb = cb; - client->keep_alive = client_info->keep_alive; - mqtt_init_requests(client->req_list, LWIP_ARRAYSIZE(client->req_list)); - - /* Build connect message */ - if (client_info->will_topic != NULL && client_info->will_msg != NULL) { - flags |= MQTT_CONNECT_FLAG_WILL; - flags |= (client_info->will_qos & 3) << 3; - if (client_info->will_retain) { - flags |= MQTT_CONNECT_FLAG_WILL_RETAIN; - } - len = strlen(client_info->will_topic); - LWIP_ERROR("mqtt_client_connect: client_info->will_topic length overflow", len <= 0xFF, return ERR_VAL); - LWIP_ERROR("mqtt_client_connect: client_info->will_topic length must be > 0", len > 0, return ERR_VAL); - will_topic_len = (u8_t)len; - len = strlen(client_info->will_msg); - LWIP_ERROR("mqtt_client_connect: client_info->will_msg length overflow", len <= 0xFF, return ERR_VAL); - will_msg_len = (u8_t)len; - len = remaining_length + 2 + will_topic_len + 2 + will_msg_len; - LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); - remaining_length = (u16_t)len; - } - if (client_info->client_user != NULL) { - flags |= MQTT_CONNECT_FLAG_USERNAME; - len = strlen(client_info->client_user); - LWIP_ERROR("mqtt_client_connect: client_info->client_user length overflow", len <= 0xFFFF, return ERR_VAL); - LWIP_ERROR("mqtt_client_connect: client_info->client_user length must be > 0", len > 0, return ERR_VAL); - client_user_len = (u16_t)len; - len = remaining_length + 2 + client_user_len; - LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); - remaining_length = (u16_t)len; - } - if (client_info->client_pass != NULL) { - flags |= MQTT_CONNECT_FLAG_PASSWORD; - len = strlen(client_info->client_pass); - LWIP_ERROR("mqtt_client_connect: client_info->client_pass length overflow", len <= 0xFFFF, return ERR_VAL); - LWIP_ERROR("mqtt_client_connect: client_info->client_pass length must be > 0", len > 0, return ERR_VAL); - client_pass_len = (u16_t)len; - len = remaining_length + 2 + client_pass_len; - LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); - remaining_length = (u16_t)len; - } - - /* Don't complicate things, always connect using clean session */ - flags |= MQTT_CONNECT_FLAG_CLEAN_SESSION; - - len = strlen(client_info->client_id); - LWIP_ERROR("mqtt_client_connect: client_info->client_id length overflow", len <= 0xFFFF, return ERR_VAL); - client_id_length = (u16_t)len; - len = remaining_length + 2 + client_id_length; - LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); - remaining_length = (u16_t)len; - - if (mqtt_output_check_space(&client->output, remaining_length) == 0) { - return ERR_MEM; - } - -#if LWIP_ALTCP && LWIP_ALTCP_TLS - if (client_info->tls_config) { - client->conn = altcp_tls_new(client_info->tls_config, IP_GET_TYPE(ip_addr)); - } else -#endif - { - client->conn = altcp_tcp_new_ip_type(IP_GET_TYPE(ip_addr)); - } - if (client->conn == NULL) { - return ERR_MEM; - } - - /* Set arg pointer for callbacks */ - altcp_arg(client->conn, client); - /* Any local address, pick random local port number */ - err = altcp_bind(client->conn, IP_ADDR_ANY, 0); - if (err != ERR_OK) { - LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_client_connect: Error binding to local ip/port, %d\n", err)); - goto tcp_fail; - } - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_client_connect: Connecting to host: %s at port:%"U16_F"\n", ipaddr_ntoa(ip_addr), port)); - - /* Connect to server */ - err = altcp_connect(client->conn, ip_addr, port, mqtt_tcp_connect_cb); - if (err != ERR_OK) { - LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_client_connect: Error connecting to remote ip/port, %d\n", err)); - goto tcp_fail; - } - /* Set error callback */ - altcp_err(client->conn, mqtt_tcp_err_cb); - client->conn_state = TCP_CONNECTING; - - /* Append fixed header */ - mqtt_output_append_fixed_header(&client->output, MQTT_MSG_TYPE_CONNECT, 0, 0, 0, remaining_length); - /* Append Protocol string */ - mqtt_output_append_string(&client->output, "MQTT", 4); - /* Append Protocol level */ - mqtt_output_append_u8(&client->output, 4); - /* Append connect flags */ - mqtt_output_append_u8(&client->output, flags); - /* Append keep-alive */ - mqtt_output_append_u16(&client->output, client_info->keep_alive); - /* Append client id */ - mqtt_output_append_string(&client->output, client_info->client_id, client_id_length); - /* Append will message if used */ - if ((flags & MQTT_CONNECT_FLAG_WILL) != 0) { - mqtt_output_append_string(&client->output, client_info->will_topic, will_topic_len); - mqtt_output_append_string(&client->output, client_info->will_msg, will_msg_len); - } - /* Append user name if given */ - if ((flags & MQTT_CONNECT_FLAG_USERNAME) != 0) { - mqtt_output_append_string(&client->output, client_info->client_user, client_user_len); - } - /* Append password if given */ - if ((flags & MQTT_CONNECT_FLAG_PASSWORD) != 0) { - mqtt_output_append_string(&client->output, client_info->client_pass, client_pass_len); - } - return ERR_OK; - -tcp_fail: - altcp_abort(client->conn); - client->conn = NULL; - return err; -} - - -/** - * @ingroup mqtt - * Disconnect from MQTT server - * @param client MQTT client - */ -void -mqtt_disconnect(mqtt_client_t *client) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mqtt_disconnect: client != NULL", client); - /* If connection in not already closed */ - if (client->conn_state != TCP_DISCONNECTED) { - /* Set conn_state before calling mqtt_close to prevent callback from being called */ - client->conn_state = TCP_DISCONNECTED; - mqtt_close(client, (mqtt_connection_status_t)0); - } -} - -/** - * @ingroup mqtt - * Check connection with server - * @param client MQTT client - * @return 1 if connected to server, 0 otherwise - */ -u8_t -mqtt_client_is_connected(mqtt_client_t *client) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mqtt_client_is_connected: client != NULL", client); - return client->conn_state == MQTT_CONNECTED; -} - -#endif /* LWIP_TCP && LWIP_CALLBACK_API */ +/** + * @file + * MQTT client + * + * @defgroup mqtt MQTT client + * @ingroup apps + * @verbinclude mqtt_client.txt + */ + +/* + * Copyright (c) 2016 Erik Andersson + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack + * + * Author: Erik Andersson + * + * + * @todo: + * - Handle large outgoing payloads for PUBLISH messages + * - Fix restriction of a single topic in each (UN)SUBSCRIBE message (protocol has support for multiple topics) + * - Add support for legacy MQTT protocol version + * + * Please coordinate changes and requests with Erik Andersson + * Erik Andersson + * + */ +#include "lwip/apps/mqtt.h" +#include "lwip/apps/mqtt_priv.h" +#include "lwip/timeouts.h" +#include "lwip/ip_addr.h" +#include "lwip/mem.h" +#include "lwip/err.h" +#include "lwip/pbuf.h" +#include "lwip/altcp.h" +#include "lwip/altcp_tcp.h" +#include "lwip/altcp_tls.h" +#include + +#if LWIP_TCP && LWIP_CALLBACK_API + +/** + * MQTT_DEBUG: Default is off. + */ +#if !defined MQTT_DEBUG || defined __DOXYGEN__ +#define MQTT_DEBUG LWIP_DBG_OFF +#endif + +#define MQTT_DEBUG_TRACE (MQTT_DEBUG | LWIP_DBG_TRACE) +#define MQTT_DEBUG_STATE (MQTT_DEBUG | LWIP_DBG_STATE) +#define MQTT_DEBUG_WARN (MQTT_DEBUG | LWIP_DBG_LEVEL_WARNING) +#define MQTT_DEBUG_WARN_STATE (MQTT_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) +#define MQTT_DEBUG_SERIOUS (MQTT_DEBUG | LWIP_DBG_LEVEL_SERIOUS) + + + +/** + * MQTT client connection states + */ +enum { + TCP_DISCONNECTED, + TCP_CONNECTING, + MQTT_CONNECTING, + MQTT_CONNECTED +}; + +/** + * MQTT control message types + */ +enum mqtt_message_type { + MQTT_MSG_TYPE_CONNECT = 1, + MQTT_MSG_TYPE_CONNACK = 2, + MQTT_MSG_TYPE_PUBLISH = 3, + MQTT_MSG_TYPE_PUBACK = 4, + MQTT_MSG_TYPE_PUBREC = 5, + MQTT_MSG_TYPE_PUBREL = 6, + MQTT_MSG_TYPE_PUBCOMP = 7, + MQTT_MSG_TYPE_SUBSCRIBE = 8, + MQTT_MSG_TYPE_SUBACK = 9, + MQTT_MSG_TYPE_UNSUBSCRIBE = 10, + MQTT_MSG_TYPE_UNSUBACK = 11, + MQTT_MSG_TYPE_PINGREQ = 12, + MQTT_MSG_TYPE_PINGRESP = 13, + MQTT_MSG_TYPE_DISCONNECT = 14 +}; + +/** Helpers to extract control packet type and qos from first byte in fixed header */ +#define MQTT_CTL_PACKET_TYPE(fixed_hdr_byte0) ((fixed_hdr_byte0 & 0xf0) >> 4) +#define MQTT_CTL_PACKET_QOS(fixed_hdr_byte0) ((fixed_hdr_byte0 & 0x6) >> 1) + +/** + * MQTT connect flags, only used in CONNECT message + */ +enum mqtt_connect_flag { + MQTT_CONNECT_FLAG_USERNAME = 1 << 7, + MQTT_CONNECT_FLAG_PASSWORD = 1 << 6, + MQTT_CONNECT_FLAG_WILL_RETAIN = 1 << 5, + MQTT_CONNECT_FLAG_WILL = 1 << 2, + MQTT_CONNECT_FLAG_CLEAN_SESSION = 1 << 1 +}; + + +static void mqtt_cyclic_timer(void *arg); + +#if defined(LWIP_DEBUG) +static const char *const mqtt_message_type_str[15] = { + "UNDEFINED", + "CONNECT", + "CONNACK", + "PUBLISH", + "PUBACK", + "PUBREC", + "PUBREL", + "PUBCOMP", + "SUBSCRIBE", + "SUBACK", + "UNSUBSCRIBE", + "UNSUBACK", + "PINGREQ", + "PINGRESP", + "DISCONNECT" +}; + +/** + * Message type value to string + * @param msg_type see enum mqtt_message_type + * + * @return Control message type text string + */ +static const char * +mqtt_msg_type_to_str(u8_t msg_type) +{ + if (msg_type >= LWIP_ARRAYSIZE(mqtt_message_type_str)) { + msg_type = 0; + } + return mqtt_message_type_str[msg_type]; +} + +#endif + + +/** + * Generate MQTT packet identifier + * @param client MQTT client + * @return New packet identifier, range 1 to 65535 + */ +static u16_t +msg_generate_packet_id(mqtt_client_t *client) +{ + client->pkt_id_seq++; + if (client->pkt_id_seq == 0) { + client->pkt_id_seq++; + } + return client->pkt_id_seq; +} + +/*--------------------------------------------------------------------------------------------------------------------- */ +/* Output ring buffer */ + +/** Add single item to ring buffer */ +static void +mqtt_ringbuf_put(struct mqtt_ringbuf_t *rb, u8_t item) +{ + rb->buf[rb->put] = item; + rb->put++; + if (rb->put >= MQTT_OUTPUT_RINGBUF_SIZE) { + rb->put = 0; + } +} + +/** Return pointer to ring buffer get position */ +static u8_t * +mqtt_ringbuf_get_ptr(struct mqtt_ringbuf_t *rb) +{ + return &rb->buf[rb->get]; +} + +static void +mqtt_ringbuf_advance_get_idx(struct mqtt_ringbuf_t *rb, u16_t len) +{ + LWIP_ASSERT("mqtt_ringbuf_advance_get_idx: len < MQTT_OUTPUT_RINGBUF_SIZE", len < MQTT_OUTPUT_RINGBUF_SIZE); + + rb->get += len; + if (rb->get >= MQTT_OUTPUT_RINGBUF_SIZE) { + rb->get = rb->get - MQTT_OUTPUT_RINGBUF_SIZE; + } +} + +/** Return number of bytes in ring buffer */ +static u16_t +mqtt_ringbuf_len(struct mqtt_ringbuf_t *rb) +{ + u32_t len = rb->put - rb->get; + if (len > 0xFFFF) { + len += MQTT_OUTPUT_RINGBUF_SIZE; + } + return (u16_t)len; +} + +/** Return number of bytes free in ring buffer */ +#define mqtt_ringbuf_free(rb) (MQTT_OUTPUT_RINGBUF_SIZE - mqtt_ringbuf_len(rb)) + +/** Return number of bytes possible to read without wrapping around */ +#define mqtt_ringbuf_linear_read_length(rb) LWIP_MIN(mqtt_ringbuf_len(rb), (MQTT_OUTPUT_RINGBUF_SIZE - (rb)->get)) + +/** + * Try send as many bytes as possible from output ring buffer + * @param rb Output ring buffer + * @param tpcb TCP connection handle + */ +static void +mqtt_output_send(struct mqtt_ringbuf_t *rb, struct altcp_pcb *tpcb) +{ + err_t err; + u8_t wrap = 0; + u16_t ringbuf_lin_len = mqtt_ringbuf_linear_read_length(rb); + u16_t send_len = altcp_sndbuf(tpcb); + LWIP_ASSERT("mqtt_output_send: tpcb != NULL", tpcb != NULL); + + if (send_len == 0 || ringbuf_lin_len == 0) { + return; + } + + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_output_send: tcp_sndbuf: %d bytes, ringbuf_linear_available: %d, get %d, put %d\n", + send_len, ringbuf_lin_len, rb->get, rb->put)); + + if (send_len > ringbuf_lin_len) { + /* Space in TCP output buffer is larger than available in ring buffer linear portion */ + send_len = ringbuf_lin_len; + /* Wrap around if more data in ring buffer after linear portion */ + wrap = (mqtt_ringbuf_len(rb) > ringbuf_lin_len); + } + err = altcp_write(tpcb, mqtt_ringbuf_get_ptr(rb), send_len, TCP_WRITE_FLAG_COPY | (wrap ? TCP_WRITE_FLAG_MORE : 0)); + if ((err == ERR_OK) && wrap) { + mqtt_ringbuf_advance_get_idx(rb, send_len); + /* Use the lesser one of ring buffer linear length and TCP send buffer size */ + send_len = LWIP_MIN(altcp_sndbuf(tpcb), mqtt_ringbuf_linear_read_length(rb)); + err = altcp_write(tpcb, mqtt_ringbuf_get_ptr(rb), send_len, TCP_WRITE_FLAG_COPY); + } + + if (err == ERR_OK) { + mqtt_ringbuf_advance_get_idx(rb, send_len); + /* Flush */ + altcp_output(tpcb); + } else { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_output_send: Send failed with err %d (\"%s\")\n", err, lwip_strerr(err))); + } +} + + + +/*--------------------------------------------------------------------------------------------------------------------- */ +/* Request queue */ + +/** + * Create request item + * @param r_objs Pointer to request objects + * @param r_objs_len Number of array entries + * @param pkt_id Packet identifier of request + * @param cb Packet callback to call when requests lifetime ends + * @param arg Parameter following callback + * @return Request or NULL if failed to create + */ +static struct mqtt_request_t * +mqtt_create_request(struct mqtt_request_t *r_objs, size_t r_objs_len, u16_t pkt_id, mqtt_request_cb_t cb, void *arg) +{ + struct mqtt_request_t *r = NULL; + u8_t n; + LWIP_ASSERT("mqtt_create_request: r_objs != NULL", r_objs != NULL); + for (n = 0; n < r_objs_len; n++) { + /* Item point to itself if not in use */ + if (r_objs[n].next == &r_objs[n]) { + r = &r_objs[n]; + r->next = NULL; + r->cb = cb; + r->arg = arg; + r->pkt_id = pkt_id; + break; + } + } + return r; +} + + +/** + * Append request to pending request queue + * @param tail Pointer to request queue tail pointer + * @param r Request to append + */ +static void +mqtt_append_request(struct mqtt_request_t **tail, struct mqtt_request_t *r) +{ + struct mqtt_request_t *head = NULL; + s16_t time_before = 0; + struct mqtt_request_t *iter; + + LWIP_ASSERT("mqtt_append_request: tail != NULL", tail != NULL); + + /* Iterate trough queue to find head, and count total timeout time */ + for (iter = *tail; iter != NULL; iter = iter->next) { + time_before += iter->timeout_diff; + head = iter; + } + + LWIP_ASSERT("mqtt_append_request: time_before <= MQTT_REQ_TIMEOUT", time_before <= MQTT_REQ_TIMEOUT); + r->timeout_diff = MQTT_REQ_TIMEOUT - time_before; + if (head == NULL) { + *tail = r; + } else { + head->next = r; + } +} + + +/** + * Delete request item + * @param r Request item to delete + */ +static void +mqtt_delete_request(struct mqtt_request_t *r) +{ + if (r != NULL) { + r->next = r; + } +} + +/** + * Remove a request item with a specific packet identifier from request queue + * @param tail Pointer to request queue tail pointer + * @param pkt_id Packet identifier of request to take + * @return Request item if found, NULL if not + */ +static struct mqtt_request_t * +mqtt_take_request(struct mqtt_request_t **tail, u16_t pkt_id) +{ + struct mqtt_request_t *iter = NULL, *prev = NULL; + LWIP_ASSERT("mqtt_take_request: tail != NULL", tail != NULL); + /* Search all request for pkt_id */ + for (iter = *tail; iter != NULL; iter = iter->next) { + if (iter->pkt_id == pkt_id) { + break; + } + prev = iter; + } + + /* If request was found */ + if (iter != NULL) { + /* unchain */ + if (prev == NULL) { + *tail = iter->next; + } else { + prev->next = iter->next; + } + /* If exists, add remaining timeout time for the request to next */ + if (iter->next != NULL) { + iter->next->timeout_diff += iter->timeout_diff; + } + iter->next = NULL; + } + return iter; +} + +/** + * Handle requests timeout + * @param tail Pointer to request queue tail pointer + * @param t Time since last call in seconds + */ +static void +mqtt_request_time_elapsed(struct mqtt_request_t **tail, u8_t t) +{ + struct mqtt_request_t *r; + LWIP_ASSERT("mqtt_request_time_elapsed: tail != NULL", tail != NULL); + r = *tail; + while (t > 0 && r != NULL) { + if (t >= r->timeout_diff) { + t -= (u8_t)r->timeout_diff; + /* Unchain */ + *tail = r->next; + /* Notify upper layer about timeout */ + if (r->cb != NULL) { + r->cb(r->arg, ERR_TIMEOUT); + } + mqtt_delete_request(r); + /* Tail might be be modified in callback, so re-read it in every iteration */ + r = *(struct mqtt_request_t *const volatile *)tail; + } else { + r->timeout_diff -= t; + t = 0; + } + } +} + +/** + * Free all request items + * @param tail Pointer to request queue tail pointer + */ +static void +mqtt_clear_requests(struct mqtt_request_t **tail) +{ + struct mqtt_request_t *iter, *next; + LWIP_ASSERT("mqtt_clear_requests: tail != NULL", tail != NULL); + for (iter = *tail; iter != NULL; iter = next) { + next = iter->next; + mqtt_delete_request(iter); + } + *tail = NULL; +} +/** + * Initialize all request items + * @param r_objs Pointer to request objects + * @param r_objs_len Number of array entries + */ +static void +mqtt_init_requests(struct mqtt_request_t *r_objs, size_t r_objs_len) +{ + u8_t n; + LWIP_ASSERT("mqtt_init_requests: r_objs != NULL", r_objs != NULL); + for (n = 0; n < r_objs_len; n++) { + /* Item pointing to itself indicates unused */ + r_objs[n].next = &r_objs[n]; + } +} + +/*--------------------------------------------------------------------------------------------------------------------- */ +/* Output message build helpers */ + + +static void +mqtt_output_append_u8(struct mqtt_ringbuf_t *rb, u8_t value) +{ + mqtt_ringbuf_put(rb, value); +} + +static +void mqtt_output_append_u16(struct mqtt_ringbuf_t *rb, u16_t value) +{ + mqtt_ringbuf_put(rb, value >> 8); + mqtt_ringbuf_put(rb, value & 0xff); +} + +static void +mqtt_output_append_buf(struct mqtt_ringbuf_t *rb, const void *data, u16_t length) +{ + u16_t n; + for (n = 0; n < length; n++) { + mqtt_ringbuf_put(rb, ((const u8_t *)data)[n]); + } +} + +static void +mqtt_output_append_string(struct mqtt_ringbuf_t *rb, const char *str, u16_t length) +{ + u16_t n; + mqtt_ringbuf_put(rb, length >> 8); + mqtt_ringbuf_put(rb, length & 0xff); + for (n = 0; n < length; n++) { + mqtt_ringbuf_put(rb, str[n]); + } +} + +/** + * Append fixed header + * @param rb Output ring buffer + * @param msg_type see enum mqtt_message_type + * @param fdup MQTT DUP flag + * @param fqos MQTT QoS field + * @param fretain MQTT retain flag + * @param r_length Remaining length after fixed header + */ + +static void +mqtt_output_append_fixed_header(struct mqtt_ringbuf_t *rb, u8_t msg_type, u8_t fdup, + u8_t fqos, u8_t fretain, u16_t r_length) +{ + /* Start with control byte */ + mqtt_output_append_u8(rb, (((msg_type & 0x0f) << 4) | ((fdup & 1) << 3) | ((fqos & 3) << 1) | (fretain & 1))); + /* Encode remaining length field */ + do { + mqtt_output_append_u8(rb, (r_length & 0x7f) | (r_length >= 128 ? 0x80 : 0)); + r_length >>= 7; + } while (r_length > 0); +} + + +/** + * Check output buffer space + * @param rb Output ring buffer + * @param r_length Remaining length after fixed header + * @return 1 if message will fit, 0 if not enough buffer space + */ +static u8_t +mqtt_output_check_space(struct mqtt_ringbuf_t *rb, u16_t r_length) +{ + /* Start with length of type byte + remaining length */ + u16_t total_len = 1 + r_length; + + LWIP_ASSERT("mqtt_output_check_space: rb != NULL", rb != NULL); + + /* Calculate number of required bytes to contain the remaining bytes field and add to total*/ + do { + total_len++; + r_length >>= 7; + } while (r_length > 0); + + return (total_len <= mqtt_ringbuf_free(rb)); +} + + +/** + * Close connection to server + * @param client MQTT client + * @param reason Reason for disconnection + */ +static void +mqtt_close(mqtt_client_t *client, mqtt_connection_status_t reason) +{ + LWIP_ASSERT("mqtt_close: client != NULL", client != NULL); + + /* Bring down TCP connection if not already done */ + if (client->conn != NULL) { + err_t res; + altcp_recv(client->conn, NULL); + altcp_err(client->conn, NULL); + altcp_sent(client->conn, NULL); + res = altcp_close(client->conn); + if (res != ERR_OK) { + altcp_abort(client->conn); + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_close: Close err=%s\n", lwip_strerr(res))); + } + client->conn = NULL; + } + + /* Remove all pending requests */ + mqtt_clear_requests(&client->pend_req_queue); + /* Stop cyclic timer */ + sys_untimeout(mqtt_cyclic_timer, client); + + /* Notify upper layer of disconnection if changed state */ + if (client->conn_state != TCP_DISCONNECTED) { + + client->conn_state = TCP_DISCONNECTED; + if (client->connect_cb != NULL) { + client->connect_cb(client, client->connect_arg, reason); + } + } +} + + +/** + * Interval timer, called every MQTT_CYCLIC_TIMER_INTERVAL seconds in MQTT_CONNECTING and MQTT_CONNECTED states + * @param arg MQTT client + */ +static void +mqtt_cyclic_timer(void *arg) +{ + u8_t restart_timer = 1; + mqtt_client_t *client = (mqtt_client_t *)arg; + LWIP_ASSERT("mqtt_cyclic_timer: client != NULL", client != NULL); + + if (client->conn_state == MQTT_CONNECTING) { + client->cyclic_tick++; + if ((client->cyclic_tick * MQTT_CYCLIC_TIMER_INTERVAL) >= MQTT_CONNECT_TIMOUT) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_cyclic_timer: CONNECT attempt to server timed out\n")); + /* Disconnect TCP */ + mqtt_close(client, MQTT_CONNECT_TIMEOUT); + restart_timer = 0; + } + } else if (client->conn_state == MQTT_CONNECTED) { + /* Handle timeout for pending requests */ + mqtt_request_time_elapsed(&client->pend_req_queue, MQTT_CYCLIC_TIMER_INTERVAL); + + /* keep_alive > 0 means keep alive functionality shall be used */ + if (client->keep_alive > 0) { + + client->server_watchdog++; + /* If reception from server has been idle for 1.5*keep_alive time, server is considered unresponsive */ + if ((client->server_watchdog * MQTT_CYCLIC_TIMER_INTERVAL) > (client->keep_alive + client->keep_alive / 2)) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_cyclic_timer: Server incoming keep-alive timeout\n")); + mqtt_close(client, MQTT_CONNECT_TIMEOUT); + restart_timer = 0; + } + + /* If time for a keep alive message to be sent, transmission has been idle for keep_alive time */ + if ((client->cyclic_tick * MQTT_CYCLIC_TIMER_INTERVAL) >= client->keep_alive) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_cyclic_timer: Sending keep-alive message to server\n")); + if (mqtt_output_check_space(&client->output, 0) != 0) { + mqtt_output_append_fixed_header(&client->output, MQTT_MSG_TYPE_PINGREQ, 0, 0, 0, 0); + client->cyclic_tick = 0; + } + } else { + client->cyclic_tick++; + } + } + } else { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_cyclic_timer: Timer should not be running in state %d\n", client->conn_state)); + restart_timer = 0; + } + if (restart_timer) { + sys_timeout(MQTT_CYCLIC_TIMER_INTERVAL * 1000, mqtt_cyclic_timer, arg); + } +} + + +/** + * Send PUBACK, PUBREC or PUBREL response message + * @param client MQTT client + * @param msg PUBACK, PUBREC or PUBREL + * @param pkt_id Packet identifier + * @param qos QoS value + * @return ERR_OK if successful, ERR_MEM if out of memory + */ +static err_t +pub_ack_rec_rel_response(mqtt_client_t *client, u8_t msg, u16_t pkt_id, u8_t qos) +{ + err_t err = ERR_OK; + if (mqtt_output_check_space(&client->output, 2)) { + mqtt_output_append_fixed_header(&client->output, msg, 0, qos, 0, 2); + mqtt_output_append_u16(&client->output, pkt_id); + mqtt_output_send(&client->output, client->conn); + } else { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("pub_ack_rec_rel_response: OOM creating response: %s with pkt_id: %d\n", + mqtt_msg_type_to_str(msg), pkt_id)); + err = ERR_MEM; + } + return err; +} + +/** + * Subscribe response from server + * @param r Matching request + * @param result Result code from server + */ +static void +mqtt_incomming_suback(struct mqtt_request_t *r, u8_t result) +{ + if (r->cb != NULL) { + r->cb(r->arg, result < 3 ? ERR_OK : ERR_ABRT); + } +} + + +/** + * Complete MQTT message received or buffer full + * @param client MQTT client + * @param fixed_hdr_idx header index + * @param length length received part + * @param remaining_length Remaining length of complete message + */ +static mqtt_connection_status_t +mqtt_message_received(mqtt_client_t *client, u8_t fixed_hdr_idx, u16_t length, u32_t remaining_length) +{ + mqtt_connection_status_t res = MQTT_CONNECT_ACCEPTED; + + u8_t *var_hdr_payload = client->rx_buffer + fixed_hdr_idx; + size_t var_hdr_payload_bufsize = sizeof(client->rx_buffer) - fixed_hdr_idx; + + /* Control packet type */ + u8_t pkt_type = MQTT_CTL_PACKET_TYPE(client->rx_buffer[0]); + u16_t pkt_id = 0; + + LWIP_ASSERT("client->msg_idx < MQTT_VAR_HEADER_BUFFER_LEN", client->msg_idx < MQTT_VAR_HEADER_BUFFER_LEN); + LWIP_ASSERT("fixed_hdr_idx <= client->msg_idx", fixed_hdr_idx <= client->msg_idx); + LWIP_ERROR("buffer length mismatch", fixed_hdr_idx + length <= MQTT_VAR_HEADER_BUFFER_LEN, + return MQTT_CONNECT_DISCONNECTED); + + if (pkt_type == MQTT_MSG_TYPE_CONNACK) { + if (client->conn_state == MQTT_CONNECTING) { + if (length < 2) { + LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short CONNACK message\n")); + goto out_disconnect; + } + /* Get result code from CONNACK */ + res = (mqtt_connection_status_t)var_hdr_payload[1]; + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: Connect response code %d\n", res)); + if (res == MQTT_CONNECT_ACCEPTED) { + /* Reset cyclic_tick when changing to connected state */ + client->cyclic_tick = 0; + client->conn_state = MQTT_CONNECTED; + /* Notify upper layer */ + if (client->connect_cb != 0) { + client->connect_cb(client, client->connect_arg, res); + } + } + } else { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: Received CONNACK in connected state\n")); + } + } else if (pkt_type == MQTT_MSG_TYPE_PINGRESP) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ( "mqtt_message_received: Received PINGRESP from server\n")); + + } else if (pkt_type == MQTT_MSG_TYPE_PUBLISH) { + u16_t payload_offset = 0; + u16_t payload_length = length; + u8_t qos = MQTT_CTL_PACKET_QOS(client->rx_buffer[0]); + + if (client->msg_idx <= MQTT_VAR_HEADER_BUFFER_LEN) { + /* Should have topic and pkt id*/ + u8_t *topic; + u16_t after_topic; + u8_t bkp; + u16_t topic_len; + u16_t qos_len = (qos ? 2U : 0U); + if (length < 2 + qos_len) { + LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short PUBLISH packet\n")); + goto out_disconnect; + } + topic_len = var_hdr_payload[0]; + topic_len = (topic_len << 8) + (u16_t)(var_hdr_payload[1]); + if ((topic_len > length - (2 + qos_len)) || + (topic_len > var_hdr_payload_bufsize - (2 + qos_len))) { + LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short PUBLISH packet (topic)\n")); + goto out_disconnect; + } + + topic = var_hdr_payload + 2; + after_topic = 2 + topic_len; + /* Check buffer length, add one byte even for QoS 0 so that zero termination will fit */ + if ((after_topic + (qos ? 2U : 1U)) > var_hdr_payload_bufsize) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: Receive buffer can not fit topic + pkt_id\n")); + goto out_disconnect; + } + + /* id for QoS 1 and 2 */ + if (qos > 0) { + if (length < after_topic + 2U) { + LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short PUBLISH packet (after_topic)\n")); + goto out_disconnect; + } + client->inpub_pkt_id = ((u16_t)var_hdr_payload[after_topic] << 8) + (u16_t)var_hdr_payload[after_topic + 1]; + after_topic += 2; + } else { + client->inpub_pkt_id = 0; + } + /* Take backup of byte after topic */ + bkp = topic[topic_len]; + /* Zero terminate string */ + topic[topic_len] = 0; + /* Payload data remaining in receive buffer */ + payload_length = length - after_topic; + payload_offset = after_topic; + + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_incomming_publish: Received message with QoS %d at topic: %s, payload length %"U32_F"\n", + qos, topic, remaining_length + payload_length)); + if (client->pub_cb != NULL) { + client->pub_cb(client->inpub_arg, (const char *)topic, remaining_length + payload_length); + } + /* Restore byte after topic */ + topic[topic_len] = bkp; + } + if (payload_length > 0 || remaining_length == 0) { + if (length < (size_t)(payload_offset + payload_length)) { + LWIP_DEBUGF(MQTT_DEBUG_WARN,( "mqtt_message_received: Received short packet (payload)\n")); + goto out_disconnect; + } + client->data_cb(client->inpub_arg, var_hdr_payload + payload_offset, payload_length, remaining_length == 0 ? MQTT_DATA_FLAG_LAST : 0); + /* Reply if QoS > 0 */ + if (remaining_length == 0 && qos > 0) { + /* Send PUBACK for QoS 1 or PUBREC for QoS 2 */ + u8_t resp_msg = (qos == 1) ? MQTT_MSG_TYPE_PUBACK : MQTT_MSG_TYPE_PUBREC; + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_incomming_publish: Sending publish response: %s with pkt_id: %d\n", + mqtt_msg_type_to_str(resp_msg), client->inpub_pkt_id)); + pub_ack_rec_rel_response(client, resp_msg, client->inpub_pkt_id, 0); + } + } + } else { + /* Get packet identifier */ + pkt_id = (u16_t)var_hdr_payload[0] << 8; + pkt_id |= (u16_t)var_hdr_payload[1]; + if (pkt_id == 0) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: Got message with illegal packet identifier: 0\n")); + goto out_disconnect; + } + if (pkt_type == MQTT_MSG_TYPE_PUBREC) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: PUBREC, sending PUBREL with pkt_id: %d\n", pkt_id)); + pub_ack_rec_rel_response(client, MQTT_MSG_TYPE_PUBREL, pkt_id, 1); + + } else if (pkt_type == MQTT_MSG_TYPE_PUBREL) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: PUBREL, sending PUBCOMP response with pkt_id: %d\n", pkt_id)); + pub_ack_rec_rel_response(client, MQTT_MSG_TYPE_PUBCOMP, pkt_id, 0); + + } else if (pkt_type == MQTT_MSG_TYPE_SUBACK || pkt_type == MQTT_MSG_TYPE_UNSUBACK || + pkt_type == MQTT_MSG_TYPE_PUBCOMP || pkt_type == MQTT_MSG_TYPE_PUBACK) { + struct mqtt_request_t *r = mqtt_take_request(&client->pend_req_queue, pkt_id); + if (r != NULL) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_message_received: %s response with id %d\n", mqtt_msg_type_to_str(pkt_type), pkt_id)); + if (pkt_type == MQTT_MSG_TYPE_SUBACK) { + if (length < 3) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_message_received: To small SUBACK packet\n")); + goto out_disconnect; + } else { + mqtt_incomming_suback(r, var_hdr_payload[2]); + } + } else if (r->cb != NULL) { + r->cb(r->arg, ERR_OK); + } + mqtt_delete_request(r); + } else { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ( "mqtt_message_received: Received %s reply, with wrong pkt_id: %d\n", mqtt_msg_type_to_str(pkt_type), pkt_id)); + } + } else { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ( "mqtt_message_received: Received unknown message type: %d\n", pkt_type)); + goto out_disconnect; + } + } + return res; +out_disconnect: + return MQTT_CONNECT_DISCONNECTED; +} + + +/** + * MQTT incoming message parser + * @param client MQTT client + * @param p PBUF chain of received data + * @return Connection status + */ +static mqtt_connection_status_t +mqtt_parse_incoming(mqtt_client_t *client, struct pbuf *p) +{ + u16_t in_offset = 0; + u32_t msg_rem_len = 0; + u8_t fixed_hdr_idx = 0; + u8_t b = 0; + + while (p->tot_len > in_offset) { + /* We ALWAYS parse the header here first. Even if the header was not + included in this segment, we re-parse it here by buffering it in + client->rx_buffer. client->msg_idx keeps track of this. */ + if ((fixed_hdr_idx < 2) || ((b & 0x80) != 0)) { + + if (fixed_hdr_idx < client->msg_idx) { + /* parse header from old pbuf (buffered in client->rx_buffer) */ + b = client->rx_buffer[fixed_hdr_idx]; + } else { + /* parse header from this pbuf and save it in client->rx_buffer in case + it comes in segmented */ + b = pbuf_get_at(p, in_offset++); + client->rx_buffer[client->msg_idx++] = b; + } + fixed_hdr_idx++; + + if (fixed_hdr_idx >= 2) { + /* fixed header contains at least 2 bytes but can contain more, depending on + 'remaining length'. All bytes but the last of this have 0x80 set to + indicate more bytes are coming. */ + msg_rem_len |= (u32_t)(b & 0x7f) << ((fixed_hdr_idx - 2) * 7); + if ((b & 0x80) == 0) { + /* fixed header is done */ + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_parse_incoming: Remaining length after fixed header: %"U32_F"\n", msg_rem_len)); + if (msg_rem_len == 0) { + /* Complete message with no extra headers of payload received */ + mqtt_message_received(client, fixed_hdr_idx, 0, 0); + client->msg_idx = 0; + fixed_hdr_idx = 0; + } else { + /* Bytes remaining in message (changes remaining length if this is + not the first segment of this message) */ + msg_rem_len = (msg_rem_len + fixed_hdr_idx) - client->msg_idx; + } + } + } + } else { + /* Fixed header has been parsed, parse variable header */ + u16_t cpy_len, cpy_start, buffer_space; + + cpy_start = (client->msg_idx - fixed_hdr_idx) % (MQTT_VAR_HEADER_BUFFER_LEN - fixed_hdr_idx) + fixed_hdr_idx; + + /* Allow to copy the lesser one of available length in input data or bytes remaining in message */ + cpy_len = (u16_t)LWIP_MIN((u16_t)(p->tot_len - in_offset), msg_rem_len); + + /* Limit to available space in buffer */ + buffer_space = MQTT_VAR_HEADER_BUFFER_LEN - cpy_start; + if (cpy_len > buffer_space) { + cpy_len = buffer_space; + } + pbuf_copy_partial(p, client->rx_buffer + cpy_start, cpy_len, in_offset); + + /* Advance get and put indexes */ + client->msg_idx += cpy_len; + in_offset += cpy_len; + msg_rem_len -= cpy_len; + + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_parse_incoming: msg_idx: %"U32_F", cpy_len: %"U16_F", remaining %"U32_F"\n", client->msg_idx, cpy_len, msg_rem_len)); + if ((msg_rem_len == 0) || (cpy_len == buffer_space)) { + /* Whole message received or buffer is full */ + mqtt_connection_status_t res = mqtt_message_received(client, fixed_hdr_idx, (cpy_start + cpy_len) - fixed_hdr_idx, msg_rem_len); + if (res != MQTT_CONNECT_ACCEPTED) { + return res; + } + if (msg_rem_len == 0) { + /* Reset parser state */ + client->msg_idx = 0; + /* msg_tot_len = 0; */ + fixed_hdr_idx = 0; + } + } + } + } + return MQTT_CONNECT_ACCEPTED; +} + + +/** + * TCP received callback function. @see tcp_recv_fn + * @param arg MQTT client + * @param p PBUF chain of received data + * @param err Passed as return value if not ERR_OK + * @return ERR_OK or err passed into callback + */ +static err_t +mqtt_tcp_recv_cb(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) +{ + mqtt_client_t *client = (mqtt_client_t *)arg; + LWIP_ASSERT("mqtt_tcp_recv_cb: client != NULL", client != NULL); + LWIP_ASSERT("mqtt_tcp_recv_cb: client->conn == pcb", client->conn == pcb); + + if (p == NULL) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_recv_cb: Recv pbuf=NULL, remote has closed connection\n")); + mqtt_close(client, MQTT_CONNECT_DISCONNECTED); + } else { + mqtt_connection_status_t res; + if (err != ERR_OK) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_tcp_recv_cb: Recv err=%d\n", err)); + pbuf_free(p); + return err; + } + + /* Tell remote that data has been received */ + altcp_recved(pcb, p->tot_len); + res = mqtt_parse_incoming(client, p); + pbuf_free(p); + + if (res != MQTT_CONNECT_ACCEPTED) { + mqtt_close(client, res); + } + /* If keep alive functionality is used */ + if (client->keep_alive != 0) { + /* Reset server alive watchdog */ + client->server_watchdog = 0; + } + + } + return ERR_OK; +} + + +/** + * TCP data sent callback function. @see tcp_sent_fn + * @param arg MQTT client + * @param tpcb TCP connection handle + * @param len Number of bytes sent + * @return ERR_OK + */ +static err_t +mqtt_tcp_sent_cb(void *arg, struct altcp_pcb *tpcb, u16_t len) +{ + mqtt_client_t *client = (mqtt_client_t *)arg; + + LWIP_UNUSED_ARG(tpcb); + LWIP_UNUSED_ARG(len); + + if (client->conn_state == MQTT_CONNECTED) { + struct mqtt_request_t *r; + + /* Reset keep-alive send timer and server watchdog */ + client->cyclic_tick = 0; + client->server_watchdog = 0; + /* QoS 0 publish has no response from server, so call its callbacks here */ + while ((r = mqtt_take_request(&client->pend_req_queue, 0)) != NULL) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_sent_cb: Calling QoS 0 publish complete callback\n")); + if (r->cb != NULL) { + r->cb(r->arg, ERR_OK); + } + mqtt_delete_request(r); + } + /* Try send any remaining buffers from output queue */ + mqtt_output_send(&client->output, client->conn); + } + return ERR_OK; +} + +/** + * TCP error callback function. @see tcp_err_fn + * @param arg MQTT client + * @param err Error encountered + */ +static void +mqtt_tcp_err_cb(void *arg, err_t err) +{ + mqtt_client_t *client = (mqtt_client_t *)arg; + LWIP_UNUSED_ARG(err); /* only used for debug output */ + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_err_cb: TCP error callback: error %d, arg: %p\n", err, arg)); + LWIP_ASSERT("mqtt_tcp_err_cb: client != NULL", client != NULL); + /* Set conn to null before calling close as pcb is already deallocated*/ + client->conn = 0; + mqtt_close(client, MQTT_CONNECT_DISCONNECTED); +} + +/** + * TCP poll callback function. @see tcp_poll_fn + * @param arg MQTT client + * @param tpcb TCP connection handle + * @return err ERR_OK + */ +static err_t +mqtt_tcp_poll_cb(void *arg, struct altcp_pcb *tpcb) +{ + mqtt_client_t *client = (mqtt_client_t *)arg; + if (client->conn_state == MQTT_CONNECTED) { + /* Try send any remaining buffers from output queue */ + mqtt_output_send(&client->output, tpcb); + } + return ERR_OK; +} + +/** + * TCP connect callback function. @see tcp_connected_fn + * @param arg MQTT client + * @param err Always ERR_OK, mqtt_tcp_err_cb is called in case of error + * @return ERR_OK + */ +static err_t +mqtt_tcp_connect_cb(void *arg, struct altcp_pcb *tpcb, err_t err) +{ + mqtt_client_t *client = (mqtt_client_t *)arg; + + if (err != ERR_OK) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_tcp_connect_cb: TCP connect error %d\n", err)); + return err; + } + + /* Initiate receiver state */ + client->msg_idx = 0; + + /* Setup TCP callbacks */ + altcp_recv(tpcb, mqtt_tcp_recv_cb); + altcp_sent(tpcb, mqtt_tcp_sent_cb); + altcp_poll(tpcb, mqtt_tcp_poll_cb, 2); + + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_tcp_connect_cb: TCP connection established to server\n")); + /* Enter MQTT connect state */ + client->conn_state = MQTT_CONNECTING; + + /* Start cyclic timer */ + sys_timeout(MQTT_CYCLIC_TIMER_INTERVAL * 1000, mqtt_cyclic_timer, client); + client->cyclic_tick = 0; + + /* Start transmission from output queue, connect message is the first one out*/ + mqtt_output_send(&client->output, client->conn); + + return ERR_OK; +} + + + +/*---------------------------------------------------------------------------------------------------- */ +/* Public API */ + + +/** + * @ingroup mqtt + * MQTT publish function. + * @param client MQTT client + * @param topic Publish topic string + * @param payload Data to publish (NULL is allowed) + * @param payload_length Length of payload (0 is allowed) + * @param qos Quality of service, 0 1 or 2 + * @param retain MQTT retain flag + * @param cb Callback to call when publish is complete or has timed out + * @param arg User supplied argument to publish callback + * @return ERR_OK if successful + * ERR_CONN if client is disconnected + * ERR_MEM if short on memory + */ +err_t +mqtt_publish(mqtt_client_t *client, const char *topic, const void *payload, u16_t payload_length, u8_t qos, u8_t retain, + mqtt_request_cb_t cb, void *arg) +{ + struct mqtt_request_t *r; + u16_t pkt_id; + size_t topic_strlen; + size_t total_len; + u16_t topic_len; + u16_t remaining_length; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mqtt_publish: client != NULL", client); + LWIP_ASSERT("mqtt_publish: topic != NULL", topic); + LWIP_ERROR("mqtt_publish: TCP disconnected", (client->conn_state != TCP_DISCONNECTED), return ERR_CONN); + + topic_strlen = strlen(topic); + LWIP_ERROR("mqtt_publish: topic length overflow", (topic_strlen <= (0xFFFF - 2)), return ERR_ARG); + topic_len = (u16_t)topic_strlen; + total_len = 2 + topic_len + payload_length; + + if (qos > 0) { + total_len += 2; + /* Generate pkt_id id for QoS1 and 2 */ + pkt_id = msg_generate_packet_id(client); + } else { + /* Use reserved value pkt_id 0 for QoS 0 in request handle */ + pkt_id = 0; + } + LWIP_ERROR("mqtt_publish: total length overflow", (total_len <= 0xFFFF), return ERR_ARG); + remaining_length = (u16_t)total_len; + + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_publish: Publish with payload length %d to topic \"%s\"\n", payload_length, topic)); + + r = mqtt_create_request(client->req_list, LWIP_ARRAYSIZE(client->req_list), pkt_id, cb, arg); + if (r == NULL) { + return ERR_MEM; + } + + if (mqtt_output_check_space(&client->output, remaining_length) == 0) { + mqtt_delete_request(r); + return ERR_MEM; + } + /* Append fixed header */ + mqtt_output_append_fixed_header(&client->output, MQTT_MSG_TYPE_PUBLISH, 0, qos, retain, remaining_length); + + /* Append Topic */ + mqtt_output_append_string(&client->output, topic, topic_len); + + /* Append packet if for QoS 1 and 2*/ + if (qos > 0) { + mqtt_output_append_u16(&client->output, pkt_id); + } + + /* Append optional publish payload */ + if ((payload != NULL) && (payload_length > 0)) { + mqtt_output_append_buf(&client->output, payload, payload_length); + } + + mqtt_append_request(&client->pend_req_queue, r); + mqtt_output_send(&client->output, client->conn); + return ERR_OK; +} + + +/** + * @ingroup mqtt + * MQTT subscribe/unsubscribe function. + * @param client MQTT client + * @param topic topic to subscribe to + * @param qos Quality of service, 0 1 or 2 (only used for subscribe) + * @param cb Callback to call when subscribe/unsubscribe reponse is received + * @param arg User supplied argument to publish callback + * @param sub 1 for subscribe, 0 for unsubscribe + * @return ERR_OK if successful, @see err_t enum for other results + */ +err_t +mqtt_sub_unsub(mqtt_client_t *client, const char *topic, u8_t qos, mqtt_request_cb_t cb, void *arg, u8_t sub) +{ + size_t topic_strlen; + size_t total_len; + u16_t topic_len; + u16_t remaining_length; + u16_t pkt_id; + struct mqtt_request_t *r; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mqtt_sub_unsub: client != NULL", client); + LWIP_ASSERT("mqtt_sub_unsub: topic != NULL", topic); + + topic_strlen = strlen(topic); + LWIP_ERROR("mqtt_sub_unsub: topic length overflow", (topic_strlen <= (0xFFFF - 2)), return ERR_ARG); + topic_len = (u16_t)topic_strlen; + /* Topic string, pkt_id, qos for subscribe */ + total_len = topic_len + 2 + 2 + (sub != 0); + LWIP_ERROR("mqtt_sub_unsub: total length overflow", (total_len <= 0xFFFF), return ERR_ARG); + remaining_length = (u16_t)total_len; + + LWIP_ASSERT("mqtt_sub_unsub: qos < 3", qos < 3); + if (client->conn_state == TCP_DISCONNECTED) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_sub_unsub: Can not (un)subscribe in disconnected state\n")); + return ERR_CONN; + } + + pkt_id = msg_generate_packet_id(client); + r = mqtt_create_request(client->req_list, LWIP_ARRAYSIZE(client->req_list), pkt_id, cb, arg); + if (r == NULL) { + return ERR_MEM; + } + + if (mqtt_output_check_space(&client->output, remaining_length) == 0) { + mqtt_delete_request(r); + return ERR_MEM; + } + + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_sub_unsub: Client (un)subscribe to topic \"%s\", id: %d\n", topic, pkt_id)); + + mqtt_output_append_fixed_header(&client->output, sub ? MQTT_MSG_TYPE_SUBSCRIBE : MQTT_MSG_TYPE_UNSUBSCRIBE, 0, 1, 0, remaining_length); + /* Packet id */ + mqtt_output_append_u16(&client->output, pkt_id); + /* Topic */ + mqtt_output_append_string(&client->output, topic, topic_len); + /* QoS */ + if (sub != 0) { + mqtt_output_append_u8(&client->output, LWIP_MIN(qos, 2)); + } + + mqtt_append_request(&client->pend_req_queue, r); + mqtt_output_send(&client->output, client->conn); + return ERR_OK; +} + + +/** + * @ingroup mqtt + * Set callback to handle incoming publish requests from server + * @param client MQTT client + * @param pub_cb Callback invoked when publish starts, contain topic and total length of payload + * @param data_cb Callback for each fragment of payload that arrives + * @param arg User supplied argument to both callbacks + */ +void +mqtt_set_inpub_callback(mqtt_client_t *client, mqtt_incoming_publish_cb_t pub_cb, + mqtt_incoming_data_cb_t data_cb, void *arg) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mqtt_set_inpub_callback: client != NULL", client != NULL); + client->data_cb = data_cb; + client->pub_cb = pub_cb; + client->inpub_arg = arg; +} + +/** + * @ingroup mqtt + * Create a new MQTT client instance + * @return Pointer to instance on success, NULL otherwise + */ +mqtt_client_t * +mqtt_client_new(void) +{ + LWIP_ASSERT_CORE_LOCKED(); + return (mqtt_client_t *)mem_calloc(1, sizeof(mqtt_client_t)); +} + +/** + * @ingroup mqtt + * Free MQTT client instance + * @param client Pointer to instance to be freed + */ +void +mqtt_client_free(mqtt_client_t *client) +{ + mem_free(client); +} + +/** + * @ingroup mqtt + * Connect to MQTT server + * @param client MQTT client + * @param ip_addr Server IP + * @param port Server port + * @param cb Connection state change callback + * @param arg User supplied argument to connection callback + * @param client_info Client identification and connection options + * @return ERR_OK if successful, @see err_t enum for other results + */ +err_t +mqtt_client_connect(mqtt_client_t *client, const ip_addr_t *ip_addr, u16_t port, mqtt_connection_cb_t cb, void *arg, + const struct mqtt_connect_client_info_t *client_info) +{ + err_t err; + size_t len; + u16_t client_id_length; + /* Length is the sum of 2+"MQTT", protocol level, flags and keep alive */ + u16_t remaining_length = 2 + 4 + 1 + 1 + 2; + u8_t flags = 0, will_topic_len = 0, will_msg_len = 0; + u16_t client_user_len = 0, client_pass_len = 0; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mqtt_client_connect: client != NULL", client != NULL); + LWIP_ASSERT("mqtt_client_connect: ip_addr != NULL", ip_addr != NULL); + LWIP_ASSERT("mqtt_client_connect: client_info != NULL", client_info != NULL); + LWIP_ASSERT("mqtt_client_connect: client_info->client_id != NULL", client_info->client_id != NULL); + + if (client->conn_state != TCP_DISCONNECTED) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_client_connect: Already connected\n")); + return ERR_ISCONN; + } + + /* Wipe clean */ + memset(client, 0, sizeof(mqtt_client_t)); + client->connect_arg = arg; + client->connect_cb = cb; + client->keep_alive = client_info->keep_alive; + mqtt_init_requests(client->req_list, LWIP_ARRAYSIZE(client->req_list)); + + /* Build connect message */ + if (client_info->will_topic != NULL && client_info->will_msg != NULL) { + flags |= MQTT_CONNECT_FLAG_WILL; + flags |= (client_info->will_qos & 3) << 3; + if (client_info->will_retain) { + flags |= MQTT_CONNECT_FLAG_WILL_RETAIN; + } + len = strlen(client_info->will_topic); + LWIP_ERROR("mqtt_client_connect: client_info->will_topic length overflow", len <= 0xFF, return ERR_VAL); + LWIP_ERROR("mqtt_client_connect: client_info->will_topic length must be > 0", len > 0, return ERR_VAL); + will_topic_len = (u8_t)len; + len = strlen(client_info->will_msg); + LWIP_ERROR("mqtt_client_connect: client_info->will_msg length overflow", len <= 0xFF, return ERR_VAL); + will_msg_len = (u8_t)len; + len = remaining_length + 2 + will_topic_len + 2 + will_msg_len; + LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); + remaining_length = (u16_t)len; + } + if (client_info->client_user != NULL) { + flags |= MQTT_CONNECT_FLAG_USERNAME; + len = strlen(client_info->client_user); + LWIP_ERROR("mqtt_client_connect: client_info->client_user length overflow", len <= 0xFFFF, return ERR_VAL); + LWIP_ERROR("mqtt_client_connect: client_info->client_user length must be > 0", len > 0, return ERR_VAL); + client_user_len = (u16_t)len; + len = remaining_length + 2 + client_user_len; + LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); + remaining_length = (u16_t)len; + } + if (client_info->client_pass != NULL) { + flags |= MQTT_CONNECT_FLAG_PASSWORD; + len = strlen(client_info->client_pass); + LWIP_ERROR("mqtt_client_connect: client_info->client_pass length overflow", len <= 0xFFFF, return ERR_VAL); + LWIP_ERROR("mqtt_client_connect: client_info->client_pass length must be > 0", len > 0, return ERR_VAL); + client_pass_len = (u16_t)len; + len = remaining_length + 2 + client_pass_len; + LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); + remaining_length = (u16_t)len; + } + + /* Don't complicate things, always connect using clean session */ + flags |= MQTT_CONNECT_FLAG_CLEAN_SESSION; + + len = strlen(client_info->client_id); + LWIP_ERROR("mqtt_client_connect: client_info->client_id length overflow", len <= 0xFFFF, return ERR_VAL); + client_id_length = (u16_t)len; + len = remaining_length + 2 + client_id_length; + LWIP_ERROR("mqtt_client_connect: remaining_length overflow", len <= 0xFFFF, return ERR_VAL); + remaining_length = (u16_t)len; + + if (mqtt_output_check_space(&client->output, remaining_length) == 0) { + return ERR_MEM; + } + +#if LWIP_ALTCP && LWIP_ALTCP_TLS + if (client_info->tls_config) { + client->conn = altcp_tls_new(client_info->tls_config, IP_GET_TYPE(ip_addr)); + } else +#endif + { + client->conn = altcp_tcp_new_ip_type(IP_GET_TYPE(ip_addr)); + } + if (client->conn == NULL) { + return ERR_MEM; + } + + /* Set arg pointer for callbacks */ + altcp_arg(client->conn, client); + /* Any local address, pick random local port number */ + err = altcp_bind(client->conn, IP_ADDR_ANY, 0); + if (err != ERR_OK) { + LWIP_DEBUGF(MQTT_DEBUG_WARN, ("mqtt_client_connect: Error binding to local ip/port, %d\n", err)); + goto tcp_fail; + } + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_client_connect: Connecting to host: %s at port:%"U16_F"\n", ipaddr_ntoa(ip_addr), port)); + + /* Connect to server */ + err = altcp_connect(client->conn, ip_addr, port, mqtt_tcp_connect_cb); + if (err != ERR_OK) { + LWIP_DEBUGF(MQTT_DEBUG_TRACE, ("mqtt_client_connect: Error connecting to remote ip/port, %d\n", err)); + goto tcp_fail; + } + /* Set error callback */ + altcp_err(client->conn, mqtt_tcp_err_cb); + client->conn_state = TCP_CONNECTING; + + /* Append fixed header */ + mqtt_output_append_fixed_header(&client->output, MQTT_MSG_TYPE_CONNECT, 0, 0, 0, remaining_length); + /* Append Protocol string */ + mqtt_output_append_string(&client->output, "MQTT", 4); + /* Append Protocol level */ + mqtt_output_append_u8(&client->output, 4); + /* Append connect flags */ + mqtt_output_append_u8(&client->output, flags); + /* Append keep-alive */ + mqtt_output_append_u16(&client->output, client_info->keep_alive); + /* Append client id */ + mqtt_output_append_string(&client->output, client_info->client_id, client_id_length); + /* Append will message if used */ + if ((flags & MQTT_CONNECT_FLAG_WILL) != 0) { + mqtt_output_append_string(&client->output, client_info->will_topic, will_topic_len); + mqtt_output_append_string(&client->output, client_info->will_msg, will_msg_len); + } + /* Append user name if given */ + if ((flags & MQTT_CONNECT_FLAG_USERNAME) != 0) { + mqtt_output_append_string(&client->output, client_info->client_user, client_user_len); + } + /* Append password if given */ + if ((flags & MQTT_CONNECT_FLAG_PASSWORD) != 0) { + mqtt_output_append_string(&client->output, client_info->client_pass, client_pass_len); + } + return ERR_OK; + +tcp_fail: + altcp_abort(client->conn); + client->conn = NULL; + return err; +} + + +/** + * @ingroup mqtt + * Disconnect from MQTT server + * @param client MQTT client + */ +void +mqtt_disconnect(mqtt_client_t *client) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mqtt_disconnect: client != NULL", client); + /* If connection in not already closed */ + if (client->conn_state != TCP_DISCONNECTED) { + /* Set conn_state before calling mqtt_close to prevent callback from being called */ + client->conn_state = TCP_DISCONNECTED; + mqtt_close(client, (mqtt_connection_status_t)0); + } +} + +/** + * @ingroup mqtt + * Check connection with server + * @param client MQTT client + * @return 1 if connected to server, 0 otherwise + */ +u8_t +mqtt_client_is_connected(mqtt_client_t *client) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mqtt_client_is_connected: client != NULL", client); + return client->conn_state == MQTT_CONNECTED; +} + +#endif /* LWIP_TCP && LWIP_CALLBACK_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/netbiosns/netbiosns.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/netbiosns/netbiosns.c index 6a605c82..c94a7791 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/netbiosns/netbiosns.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/netbiosns/netbiosns.c @@ -1,533 +1,533 @@ - /** - * @file - * NetBIOS name service responder - */ - -/** - * @defgroup netbiosns NETBIOS responder - * @ingroup apps - * - * This is an example implementation of a NetBIOS name server. - * It responds to name queries for a configurable name. - * Name resolving is not supported. - * - * Note that the device doesn't broadcast it's own name so can't - * detect duplicate names! - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Modifications by Ray Abram to respond to NetBIOS name requests when Incoming name = * - * - based on code from "https://github.com/esp8266/Arduino/commit/1f7989b31d26d7df9776a08f36d685eae7ac8f99" - * - with permission to relicense to BSD from original author: - * http://www.xpablo.cz/?p=751#more-751 - */ - -#include "lwip/apps/netbiosns.h" - -#if LWIP_IPV4 && LWIP_UDP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/def.h" -#include "lwip/udp.h" -#include "lwip/ip.h" -#include "lwip/netif.h" -#include "lwip/prot/iana.h" - -#include - -/** size of a NetBIOS name */ -#define NETBIOS_NAME_LEN 16 - -/** The Time-To-Live for NetBIOS name responds (in seconds) - * Default is 300000 seconds (3 days, 11 hours, 20 minutes) */ -#define NETBIOS_NAME_TTL 300000u - -/** NetBIOS header flags */ -#define NETB_HFLAG_RESPONSE 0x8000U -#define NETB_HFLAG_OPCODE 0x7800U -#define NETB_HFLAG_OPCODE_NAME_QUERY 0x0000U -#define NETB_HFLAG_AUTHORATIVE 0x0400U -#define NETB_HFLAG_TRUNCATED 0x0200U -#define NETB_HFLAG_RECURS_DESIRED 0x0100U -#define NETB_HFLAG_RECURS_AVAILABLE 0x0080U -#define NETB_HFLAG_BROADCAST 0x0010U -#define NETB_HFLAG_REPLYCODE 0x0008U -#define NETB_HFLAG_REPLYCODE_NOERROR 0x0000U - -/* NetBIOS question types */ -#define NETB_QTYPE_NB 0x0020U -#define NETB_QTYPE_NBSTAT 0x0021U - -/** NetBIOS name flags */ -#define NETB_NFLAG_UNIQUE 0x8000U -#define NETB_NFLAG_NODETYPE 0x6000U -#define NETB_NFLAG_NODETYPE_HNODE 0x6000U -#define NETB_NFLAG_NODETYPE_MNODE 0x4000U -#define NETB_NFLAG_NODETYPE_PNODE 0x2000U -#define NETB_NFLAG_NODETYPE_BNODE 0x0000U - -#define NETB_NFLAG_NAME_IN_CONFLICT 0x0800U /* 1=Yes, 0=No */ -#define NETB_NFLAG_NAME_IS_ACTIVE 0x0400U /* 1=Yes, 0=No */ -#define NETB_NFLAG_NAME_IS_PERMANENT 0x0200U /* 1=Yes (Name is Permanent Node Name), 0=No */ - -/** NetBIOS message header */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct netbios_hdr { - PACK_STRUCT_FIELD(u16_t trans_id); - PACK_STRUCT_FIELD(u16_t flags); - PACK_STRUCT_FIELD(u16_t questions); - PACK_STRUCT_FIELD(u16_t answerRRs); - PACK_STRUCT_FIELD(u16_t authorityRRs); - PACK_STRUCT_FIELD(u16_t additionalRRs); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** NetBIOS message question part */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct netbios_question_hdr { - PACK_STRUCT_FLD_8(u8_t nametype); - PACK_STRUCT_FLD_8(u8_t encname[(NETBIOS_NAME_LEN * 2) + 1]); - PACK_STRUCT_FIELD(u16_t type); - PACK_STRUCT_FIELD(u16_t cls); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** NetBIOS message name part */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct netbios_name_hdr { - PACK_STRUCT_FLD_8(u8_t nametype); - PACK_STRUCT_FLD_8(u8_t encname[(NETBIOS_NAME_LEN * 2) + 1]); - PACK_STRUCT_FIELD(u16_t type); - PACK_STRUCT_FIELD(u16_t cls); - PACK_STRUCT_FIELD(u32_t ttl); - PACK_STRUCT_FIELD(u16_t datalen); - PACK_STRUCT_FIELD(u16_t flags); - PACK_STRUCT_FLD_S(ip4_addr_p_t addr); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** NetBIOS message */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct netbios_resp { - struct netbios_hdr resp_hdr; - struct netbios_name_hdr resp_name; -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** The NBNS Structure Responds to a Name Query */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct netbios_answer { - struct netbios_hdr answer_hdr; - /** the length of the next string */ - PACK_STRUCT_FIELD(u8_t name_size); - /** WARNING!!! this item may be of a different length (we use this struct for transmission) */ - PACK_STRUCT_FLD_8(u8_t query_name[(NETBIOS_NAME_LEN * 2) + 1]); - PACK_STRUCT_FIELD(u16_t packet_type); - PACK_STRUCT_FIELD(u16_t cls); - PACK_STRUCT_FIELD(u32_t ttl); - PACK_STRUCT_FIELD(u16_t data_length); -#define OFFSETOF_STRUCT_NETBIOS_ANSWER_NUMBER_OF_NAMES 56 - /** number of names */ - PACK_STRUCT_FLD_8(u8_t number_of_names); - /** node name */ - PACK_STRUCT_FLD_8(u8_t answer_name[NETBIOS_NAME_LEN]); - /** node flags */ - PACK_STRUCT_FIELD(u16_t answer_name_flags); - /** Unit ID */ - PACK_STRUCT_FLD_8(u8_t unit_id[6]); - /** Jumpers */ - PACK_STRUCT_FLD_8(u8_t jumpers); - /** Test result */ - PACK_STRUCT_FLD_8(u8_t test_result); - /** Version number */ - PACK_STRUCT_FIELD(u16_t version_number); - /** Period of statistics */ - PACK_STRUCT_FIELD(u16_t period_of_statistics); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_crcs); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_alignment_errors); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_collisions); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_send_aborts); - /** Statistics */ - PACK_STRUCT_FIELD(u32_t number_of_good_sends); - /** Statistics */ - PACK_STRUCT_FIELD(u32_t number_of_good_receives); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_retransmits); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_no_resource_condition); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_free_command_blocks); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t total_number_of_command_blocks); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t max_total_number_of_command_blocks); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t number_of_pending_sessions); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t max_number_of_pending_sessions); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t max_total_sessions_possible); - /** Statistics */ - PACK_STRUCT_FIELD(u16_t session_data_packet_size); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#ifdef NETBIOS_LWIP_NAME -#define NETBIOS_LOCAL_NAME NETBIOS_LWIP_NAME -#else -static char netbiosns_local_name[NETBIOS_NAME_LEN]; -#define NETBIOS_LOCAL_NAME netbiosns_local_name -#endif - -static struct udp_pcb *netbiosns_pcb; - -/** Decode a NetBIOS name (from packet to string) */ -static int -netbiosns_name_decode(char *name_enc, char *name_dec, int name_dec_len) -{ - char *pname; - char cname; - char cnbname; - int idx = 0; - - LWIP_UNUSED_ARG(name_dec_len); - - /* Start decoding netbios name. */ - pname = name_enc; - for (;;) { - /* Every two characters of the first level-encoded name - * turn into one character in the decoded name. */ - cname = *pname; - if (cname == '\0') { - break; /* no more characters */ - } - if (cname == '.') { - break; /* scope ID follows */ - } - if (!lwip_isupper(cname)) { - /* Not legal. */ - return -1; - } - cname -= 'A'; - cnbname = cname << 4; - pname++; - - cname = *pname; - if (!lwip_isupper(cname)) { - /* Not legal. */ - return -1; - } - cname -= 'A'; - cnbname |= cname; - pname++; - - /* Do we have room to store the character? */ - if (idx < NETBIOS_NAME_LEN) { - /* Yes - store the character. */ - name_dec[idx++] = (cnbname != ' ' ? cnbname : '\0'); - } - } - - return 0; -} - -#if 0 /* function currently unused */ -/** Encode a NetBIOS name (from string to packet) - currently unused because - we don't ask for names. */ -static int -netbiosns_name_encode(char *name_enc, char *name_dec, int name_dec_len) -{ - char *pname; - char cname; - unsigned char ucname; - int idx = 0; - - /* Start encoding netbios name. */ - pname = name_enc; - - for (;;) { - /* Every two characters of the first level-encoded name - * turn into one character in the decoded name. */ - cname = *pname; - if (cname == '\0') { - break; /* no more characters */ - } - if (cname == '.') { - break; /* scope ID follows */ - } - if ((cname < 'A' || cname > 'Z') && (cname < '0' || cname > '9')) { - /* Not legal. */ - return -1; - } - - /* Do we have room to store the character? */ - if (idx >= name_dec_len) { - return -1; - } - - /* Yes - store the character. */ - ucname = cname; - name_dec[idx++] = ('A' + ((ucname >> 4) & 0x0F)); - name_dec[idx++] = ('A' + ( ucname & 0x0F)); - pname++; - } - - /* Fill with "space" coding */ - for (; idx < name_dec_len - 1;) { - name_dec[idx++] = 'C'; - name_dec[idx++] = 'A'; - } - - /* Terminate string */ - name_dec[idx] = '\0'; - - return 0; -} -#endif /* 0 */ - -/** NetBIOS Name service recv callback */ -static void -netbiosns_recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - LWIP_UNUSED_ARG(arg); - - /* if packet is valid */ - if (p != NULL) { - char netbios_name[NETBIOS_NAME_LEN + 1]; - struct netbios_hdr *netbios_hdr = (struct netbios_hdr *)p->payload; - struct netbios_question_hdr *netbios_question_hdr = (struct netbios_question_hdr *)(netbios_hdr + 1); - - /* is the packet long enough (we need the header in one piece) */ - if (p->len < (sizeof(struct netbios_hdr) + sizeof(struct netbios_question_hdr))) { - /* packet too short */ - pbuf_free(p); - return; - } - /* we only answer if we got a default interface */ - if (netif_default != NULL) { - /* @todo: do we need to check answerRRs/authorityRRs/additionalRRs? */ - /* if the packet is a NetBIOS name query question */ - if (((netbios_hdr->flags & PP_NTOHS(NETB_HFLAG_OPCODE)) == PP_NTOHS(NETB_HFLAG_OPCODE_NAME_QUERY)) && - ((netbios_hdr->flags & PP_NTOHS(NETB_HFLAG_RESPONSE)) == 0) && - (netbios_hdr->questions == PP_NTOHS(1))) { - /* decode the NetBIOS name */ - netbiosns_name_decode((char *)(netbios_question_hdr->encname), netbios_name, sizeof(netbios_name)); - /* check the request type */ - if (netbios_question_hdr->type == PP_HTONS(NETB_QTYPE_NB)) { - /* if the packet is for us */ - if (lwip_strnicmp(netbios_name, NETBIOS_LOCAL_NAME, sizeof(NETBIOS_LOCAL_NAME)) == 0) { - struct pbuf *q; - struct netbios_resp *resp; - - q = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct netbios_resp), PBUF_RAM); - if (q != NULL) { - resp = (struct netbios_resp *)q->payload; - - /* prepare NetBIOS header response */ - resp->resp_hdr.trans_id = netbios_hdr->trans_id; - resp->resp_hdr.flags = PP_HTONS(NETB_HFLAG_RESPONSE | - NETB_HFLAG_OPCODE_NAME_QUERY | - NETB_HFLAG_AUTHORATIVE | - NETB_HFLAG_RECURS_DESIRED); - resp->resp_hdr.questions = 0; - resp->resp_hdr.answerRRs = PP_HTONS(1); - resp->resp_hdr.authorityRRs = 0; - resp->resp_hdr.additionalRRs = 0; - - /* prepare NetBIOS header datas */ - MEMCPY( resp->resp_name.encname, netbios_question_hdr->encname, sizeof(netbios_question_hdr->encname)); - resp->resp_name.nametype = netbios_question_hdr->nametype; - resp->resp_name.type = netbios_question_hdr->type; - resp->resp_name.cls = netbios_question_hdr->cls; - resp->resp_name.ttl = PP_HTONL(NETBIOS_NAME_TTL); - resp->resp_name.datalen = PP_HTONS(sizeof(resp->resp_name.flags) + sizeof(resp->resp_name.addr)); - resp->resp_name.flags = PP_HTONS(NETB_NFLAG_NODETYPE_BNODE); - ip4_addr_copy(resp->resp_name.addr, *netif_ip4_addr(netif_default)); - - /* send the NetBIOS response */ - udp_sendto(upcb, q, addr, port); - - /* free the "reference" pbuf */ - pbuf_free(q); - } - } -#if LWIP_NETBIOS_RESPOND_NAME_QUERY - } else if (netbios_question_hdr->type == PP_HTONS(NETB_QTYPE_NBSTAT)) { - /* if the packet is for us or general query */ - if (!lwip_strnicmp(netbios_name, NETBIOS_LOCAL_NAME, sizeof(NETBIOS_LOCAL_NAME)) || - !lwip_strnicmp(netbios_name, "*", sizeof(NETBIOS_LOCAL_NAME))) { - /* general query - ask for our IP address */ - struct pbuf *q; - struct netbios_answer *resp; - - q = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct netbios_answer), PBUF_RAM); - if (q != NULL) { - /* buffer to which a response is compiled */ - resp = (struct netbios_answer *) q->payload; - - /* Init response to zero, especially the statistics fields */ - memset(resp, 0, sizeof(*resp)); - - /* copy the query to the response ID */ - resp->answer_hdr.trans_id = netbios_hdr->trans_id; - /* acknowledgment of termination */ - resp->answer_hdr.flags = PP_HTONS(NETB_HFLAG_RESPONSE | NETB_HFLAG_OPCODE_NAME_QUERY | NETB_HFLAG_AUTHORATIVE); - /* resp->answer_hdr.questions = PP_HTONS(0); done by memset() */ - /* serial number of the answer */ - resp->answer_hdr.answerRRs = PP_HTONS(1); - /* resp->answer_hdr.authorityRRs = PP_HTONS(0); done by memset() */ - /* resp->answer_hdr.additionalRRs = PP_HTONS(0); done by memset() */ - /* we will copy the length of the station name */ - resp->name_size = netbios_question_hdr->nametype; - /* we will copy the queried name */ - MEMCPY(resp->query_name, netbios_question_hdr->encname, (NETBIOS_NAME_LEN * 2) + 1); - /* NBSTAT */ - resp->packet_type = PP_HTONS(0x21); - /* Internet name */ - resp->cls = PP_HTONS(1); - /* resp->ttl = PP_HTONL(0); done by memset() */ - resp->data_length = PP_HTONS(sizeof(struct netbios_answer) - offsetof(struct netbios_answer, number_of_names)); - resp->number_of_names = 1; - - /* make windows see us as workstation, not as a server */ - memset(resp->answer_name, 0x20, NETBIOS_NAME_LEN - 1); - /* strlen is checked to be < NETBIOS_NAME_LEN during initialization */ - MEMCPY(resp->answer_name, NETBIOS_LOCAL_NAME, strlen(NETBIOS_LOCAL_NAME)); - - /* b-node, unique, active */ - resp->answer_name_flags = PP_HTONS(NETB_NFLAG_NAME_IS_ACTIVE); - - /* Set responder netif MAC address */ - SMEMCPY(resp->unit_id, ip_current_input_netif()->hwaddr, sizeof(resp->unit_id)); - - udp_sendto(upcb, q, addr, port); - pbuf_free(q); - } - } -#endif /* LWIP_NETBIOS_RESPOND_NAME_QUERY */ - } - } - } - /* free the pbuf */ - pbuf_free(p); - } -} - -/** - * @ingroup netbiosns - * Init netbios responder - */ -void -netbiosns_init(void) -{ - /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ -#ifdef NETBIOS_LWIP_NAME - LWIP_ASSERT("NetBIOS name is too long!", strlen(NETBIOS_LWIP_NAME) < NETBIOS_NAME_LEN); -#endif - - netbiosns_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); - if (netbiosns_pcb != NULL) { - /* we have to be allowed to send broadcast packets! */ - ip_set_option(netbiosns_pcb, SOF_BROADCAST); - udp_bind(netbiosns_pcb, IP_ANY_TYPE, LWIP_IANA_PORT_NETBIOS); - udp_recv(netbiosns_pcb, netbiosns_recv, netbiosns_pcb); - } -} - -#ifndef NETBIOS_LWIP_NAME -/** - * @ingroup netbiosns - * Set netbios name. ATTENTION: the hostname must be less than 15 characters! - * the NetBIOS name spec says the name MUST be upper case, so incoming name is forced into uppercase :-) - */ -void -netbiosns_set_name(const char *hostname) -{ - size_t i; - size_t copy_len = strlen(hostname); - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("NetBIOS name is too long!", copy_len < NETBIOS_NAME_LEN); - if (copy_len >= NETBIOS_NAME_LEN) { - copy_len = NETBIOS_NAME_LEN - 1; - } - - /* make name into upper case */ - for (i = 0; i < copy_len; i++ ) { - netbiosns_local_name[i] = (char)lwip_toupper(hostname[i]); - } - netbiosns_local_name[copy_len] = '\0'; -} -#endif /* NETBIOS_LWIP_NAME */ - -/** - * @ingroup netbiosns - * Stop netbios responder - */ -void -netbiosns_stop(void) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (netbiosns_pcb != NULL) { - udp_remove(netbiosns_pcb); - netbiosns_pcb = NULL; - } -} - -#endif /* LWIP_IPV4 && LWIP_UDP */ + /** + * @file + * NetBIOS name service responder + */ + +/** + * @defgroup netbiosns NETBIOS responder + * @ingroup apps + * + * This is an example implementation of a NetBIOS name server. + * It responds to name queries for a configurable name. + * Name resolving is not supported. + * + * Note that the device doesn't broadcast it's own name so can't + * detect duplicate names! + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Modifications by Ray Abram to respond to NetBIOS name requests when Incoming name = * + * - based on code from "https://github.com/esp8266/Arduino/commit/1f7989b31d26d7df9776a08f36d685eae7ac8f99" + * - with permission to relicense to BSD from original author: + * http://www.xpablo.cz/?p=751#more-751 + */ + +#include "lwip/apps/netbiosns.h" + +#if LWIP_IPV4 && LWIP_UDP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/def.h" +#include "lwip/udp.h" +#include "lwip/ip.h" +#include "lwip/netif.h" +#include "lwip/prot/iana.h" + +#include + +/** size of a NetBIOS name */ +#define NETBIOS_NAME_LEN 16 + +/** The Time-To-Live for NetBIOS name responds (in seconds) + * Default is 300000 seconds (3 days, 11 hours, 20 minutes) */ +#define NETBIOS_NAME_TTL 300000u + +/** NetBIOS header flags */ +#define NETB_HFLAG_RESPONSE 0x8000U +#define NETB_HFLAG_OPCODE 0x7800U +#define NETB_HFLAG_OPCODE_NAME_QUERY 0x0000U +#define NETB_HFLAG_AUTHORATIVE 0x0400U +#define NETB_HFLAG_TRUNCATED 0x0200U +#define NETB_HFLAG_RECURS_DESIRED 0x0100U +#define NETB_HFLAG_RECURS_AVAILABLE 0x0080U +#define NETB_HFLAG_BROADCAST 0x0010U +#define NETB_HFLAG_REPLYCODE 0x0008U +#define NETB_HFLAG_REPLYCODE_NOERROR 0x0000U + +/* NetBIOS question types */ +#define NETB_QTYPE_NB 0x0020U +#define NETB_QTYPE_NBSTAT 0x0021U + +/** NetBIOS name flags */ +#define NETB_NFLAG_UNIQUE 0x8000U +#define NETB_NFLAG_NODETYPE 0x6000U +#define NETB_NFLAG_NODETYPE_HNODE 0x6000U +#define NETB_NFLAG_NODETYPE_MNODE 0x4000U +#define NETB_NFLAG_NODETYPE_PNODE 0x2000U +#define NETB_NFLAG_NODETYPE_BNODE 0x0000U + +#define NETB_NFLAG_NAME_IN_CONFLICT 0x0800U /* 1=Yes, 0=No */ +#define NETB_NFLAG_NAME_IS_ACTIVE 0x0400U /* 1=Yes, 0=No */ +#define NETB_NFLAG_NAME_IS_PERMANENT 0x0200U /* 1=Yes (Name is Permanent Node Name), 0=No */ + +/** NetBIOS message header */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_hdr { + PACK_STRUCT_FIELD(u16_t trans_id); + PACK_STRUCT_FIELD(u16_t flags); + PACK_STRUCT_FIELD(u16_t questions); + PACK_STRUCT_FIELD(u16_t answerRRs); + PACK_STRUCT_FIELD(u16_t authorityRRs); + PACK_STRUCT_FIELD(u16_t additionalRRs); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** NetBIOS message question part */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_question_hdr { + PACK_STRUCT_FLD_8(u8_t nametype); + PACK_STRUCT_FLD_8(u8_t encname[(NETBIOS_NAME_LEN * 2) + 1]); + PACK_STRUCT_FIELD(u16_t type); + PACK_STRUCT_FIELD(u16_t cls); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** NetBIOS message name part */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_name_hdr { + PACK_STRUCT_FLD_8(u8_t nametype); + PACK_STRUCT_FLD_8(u8_t encname[(NETBIOS_NAME_LEN * 2) + 1]); + PACK_STRUCT_FIELD(u16_t type); + PACK_STRUCT_FIELD(u16_t cls); + PACK_STRUCT_FIELD(u32_t ttl); + PACK_STRUCT_FIELD(u16_t datalen); + PACK_STRUCT_FIELD(u16_t flags); + PACK_STRUCT_FLD_S(ip4_addr_p_t addr); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** NetBIOS message */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_resp { + struct netbios_hdr resp_hdr; + struct netbios_name_hdr resp_name; +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** The NBNS Structure Responds to a Name Query */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct netbios_answer { + struct netbios_hdr answer_hdr; + /** the length of the next string */ + PACK_STRUCT_FIELD(u8_t name_size); + /** WARNING!!! this item may be of a different length (we use this struct for transmission) */ + PACK_STRUCT_FLD_8(u8_t query_name[(NETBIOS_NAME_LEN * 2) + 1]); + PACK_STRUCT_FIELD(u16_t packet_type); + PACK_STRUCT_FIELD(u16_t cls); + PACK_STRUCT_FIELD(u32_t ttl); + PACK_STRUCT_FIELD(u16_t data_length); +#define OFFSETOF_STRUCT_NETBIOS_ANSWER_NUMBER_OF_NAMES 56 + /** number of names */ + PACK_STRUCT_FLD_8(u8_t number_of_names); + /** node name */ + PACK_STRUCT_FLD_8(u8_t answer_name[NETBIOS_NAME_LEN]); + /** node flags */ + PACK_STRUCT_FIELD(u16_t answer_name_flags); + /** Unit ID */ + PACK_STRUCT_FLD_8(u8_t unit_id[6]); + /** Jumpers */ + PACK_STRUCT_FLD_8(u8_t jumpers); + /** Test result */ + PACK_STRUCT_FLD_8(u8_t test_result); + /** Version number */ + PACK_STRUCT_FIELD(u16_t version_number); + /** Period of statistics */ + PACK_STRUCT_FIELD(u16_t period_of_statistics); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_crcs); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_alignment_errors); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_collisions); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_send_aborts); + /** Statistics */ + PACK_STRUCT_FIELD(u32_t number_of_good_sends); + /** Statistics */ + PACK_STRUCT_FIELD(u32_t number_of_good_receives); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_retransmits); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_no_resource_condition); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_free_command_blocks); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t total_number_of_command_blocks); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t max_total_number_of_command_blocks); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t number_of_pending_sessions); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t max_number_of_pending_sessions); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t max_total_sessions_possible); + /** Statistics */ + PACK_STRUCT_FIELD(u16_t session_data_packet_size); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#ifdef NETBIOS_LWIP_NAME +#define NETBIOS_LOCAL_NAME NETBIOS_LWIP_NAME +#else +static char netbiosns_local_name[NETBIOS_NAME_LEN]; +#define NETBIOS_LOCAL_NAME netbiosns_local_name +#endif + +static struct udp_pcb *netbiosns_pcb; + +/** Decode a NetBIOS name (from packet to string) */ +static int +netbiosns_name_decode(char *name_enc, char *name_dec, int name_dec_len) +{ + char *pname; + char cname; + char cnbname; + int idx = 0; + + LWIP_UNUSED_ARG(name_dec_len); + + /* Start decoding netbios name. */ + pname = name_enc; + for (;;) { + /* Every two characters of the first level-encoded name + * turn into one character in the decoded name. */ + cname = *pname; + if (cname == '\0') { + break; /* no more characters */ + } + if (cname == '.') { + break; /* scope ID follows */ + } + if (!lwip_isupper(cname)) { + /* Not legal. */ + return -1; + } + cname -= 'A'; + cnbname = cname << 4; + pname++; + + cname = *pname; + if (!lwip_isupper(cname)) { + /* Not legal. */ + return -1; + } + cname -= 'A'; + cnbname |= cname; + pname++; + + /* Do we have room to store the character? */ + if (idx < NETBIOS_NAME_LEN) { + /* Yes - store the character. */ + name_dec[idx++] = (cnbname != ' ' ? cnbname : '\0'); + } + } + + return 0; +} + +#if 0 /* function currently unused */ +/** Encode a NetBIOS name (from string to packet) - currently unused because + we don't ask for names. */ +static int +netbiosns_name_encode(char *name_enc, char *name_dec, int name_dec_len) +{ + char *pname; + char cname; + unsigned char ucname; + int idx = 0; + + /* Start encoding netbios name. */ + pname = name_enc; + + for (;;) { + /* Every two characters of the first level-encoded name + * turn into one character in the decoded name. */ + cname = *pname; + if (cname == '\0') { + break; /* no more characters */ + } + if (cname == '.') { + break; /* scope ID follows */ + } + if ((cname < 'A' || cname > 'Z') && (cname < '0' || cname > '9')) { + /* Not legal. */ + return -1; + } + + /* Do we have room to store the character? */ + if (idx >= name_dec_len) { + return -1; + } + + /* Yes - store the character. */ + ucname = cname; + name_dec[idx++] = ('A' + ((ucname >> 4) & 0x0F)); + name_dec[idx++] = ('A' + ( ucname & 0x0F)); + pname++; + } + + /* Fill with "space" coding */ + for (; idx < name_dec_len - 1;) { + name_dec[idx++] = 'C'; + name_dec[idx++] = 'A'; + } + + /* Terminate string */ + name_dec[idx] = '\0'; + + return 0; +} +#endif /* 0 */ + +/** NetBIOS Name service recv callback */ +static void +netbiosns_recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + LWIP_UNUSED_ARG(arg); + + /* if packet is valid */ + if (p != NULL) { + char netbios_name[NETBIOS_NAME_LEN + 1]; + struct netbios_hdr *netbios_hdr = (struct netbios_hdr *)p->payload; + struct netbios_question_hdr *netbios_question_hdr = (struct netbios_question_hdr *)(netbios_hdr + 1); + + /* is the packet long enough (we need the header in one piece) */ + if (p->len < (sizeof(struct netbios_hdr) + sizeof(struct netbios_question_hdr))) { + /* packet too short */ + pbuf_free(p); + return; + } + /* we only answer if we got a default interface */ + if (netif_default != NULL) { + /* @todo: do we need to check answerRRs/authorityRRs/additionalRRs? */ + /* if the packet is a NetBIOS name query question */ + if (((netbios_hdr->flags & PP_NTOHS(NETB_HFLAG_OPCODE)) == PP_NTOHS(NETB_HFLAG_OPCODE_NAME_QUERY)) && + ((netbios_hdr->flags & PP_NTOHS(NETB_HFLAG_RESPONSE)) == 0) && + (netbios_hdr->questions == PP_NTOHS(1))) { + /* decode the NetBIOS name */ + netbiosns_name_decode((char *)(netbios_question_hdr->encname), netbios_name, sizeof(netbios_name)); + /* check the request type */ + if (netbios_question_hdr->type == PP_HTONS(NETB_QTYPE_NB)) { + /* if the packet is for us */ + if (lwip_strnicmp(netbios_name, NETBIOS_LOCAL_NAME, sizeof(NETBIOS_LOCAL_NAME)) == 0) { + struct pbuf *q; + struct netbios_resp *resp; + + q = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct netbios_resp), PBUF_RAM); + if (q != NULL) { + resp = (struct netbios_resp *)q->payload; + + /* prepare NetBIOS header response */ + resp->resp_hdr.trans_id = netbios_hdr->trans_id; + resp->resp_hdr.flags = PP_HTONS(NETB_HFLAG_RESPONSE | + NETB_HFLAG_OPCODE_NAME_QUERY | + NETB_HFLAG_AUTHORATIVE | + NETB_HFLAG_RECURS_DESIRED); + resp->resp_hdr.questions = 0; + resp->resp_hdr.answerRRs = PP_HTONS(1); + resp->resp_hdr.authorityRRs = 0; + resp->resp_hdr.additionalRRs = 0; + + /* prepare NetBIOS header datas */ + MEMCPY( resp->resp_name.encname, netbios_question_hdr->encname, sizeof(netbios_question_hdr->encname)); + resp->resp_name.nametype = netbios_question_hdr->nametype; + resp->resp_name.type = netbios_question_hdr->type; + resp->resp_name.cls = netbios_question_hdr->cls; + resp->resp_name.ttl = PP_HTONL(NETBIOS_NAME_TTL); + resp->resp_name.datalen = PP_HTONS(sizeof(resp->resp_name.flags) + sizeof(resp->resp_name.addr)); + resp->resp_name.flags = PP_HTONS(NETB_NFLAG_NODETYPE_BNODE); + ip4_addr_copy(resp->resp_name.addr, *netif_ip4_addr(netif_default)); + + /* send the NetBIOS response */ + udp_sendto(upcb, q, addr, port); + + /* free the "reference" pbuf */ + pbuf_free(q); + } + } +#if LWIP_NETBIOS_RESPOND_NAME_QUERY + } else if (netbios_question_hdr->type == PP_HTONS(NETB_QTYPE_NBSTAT)) { + /* if the packet is for us or general query */ + if (!lwip_strnicmp(netbios_name, NETBIOS_LOCAL_NAME, sizeof(NETBIOS_LOCAL_NAME)) || + !lwip_strnicmp(netbios_name, "*", sizeof(NETBIOS_LOCAL_NAME))) { + /* general query - ask for our IP address */ + struct pbuf *q; + struct netbios_answer *resp; + + q = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct netbios_answer), PBUF_RAM); + if (q != NULL) { + /* buffer to which a response is compiled */ + resp = (struct netbios_answer *) q->payload; + + /* Init response to zero, especially the statistics fields */ + memset(resp, 0, sizeof(*resp)); + + /* copy the query to the response ID */ + resp->answer_hdr.trans_id = netbios_hdr->trans_id; + /* acknowledgment of termination */ + resp->answer_hdr.flags = PP_HTONS(NETB_HFLAG_RESPONSE | NETB_HFLAG_OPCODE_NAME_QUERY | NETB_HFLAG_AUTHORATIVE); + /* resp->answer_hdr.questions = PP_HTONS(0); done by memset() */ + /* serial number of the answer */ + resp->answer_hdr.answerRRs = PP_HTONS(1); + /* resp->answer_hdr.authorityRRs = PP_HTONS(0); done by memset() */ + /* resp->answer_hdr.additionalRRs = PP_HTONS(0); done by memset() */ + /* we will copy the length of the station name */ + resp->name_size = netbios_question_hdr->nametype; + /* we will copy the queried name */ + MEMCPY(resp->query_name, netbios_question_hdr->encname, (NETBIOS_NAME_LEN * 2) + 1); + /* NBSTAT */ + resp->packet_type = PP_HTONS(0x21); + /* Internet name */ + resp->cls = PP_HTONS(1); + /* resp->ttl = PP_HTONL(0); done by memset() */ + resp->data_length = PP_HTONS(sizeof(struct netbios_answer) - offsetof(struct netbios_answer, number_of_names)); + resp->number_of_names = 1; + + /* make windows see us as workstation, not as a server */ + memset(resp->answer_name, 0x20, NETBIOS_NAME_LEN - 1); + /* strlen is checked to be < NETBIOS_NAME_LEN during initialization */ + MEMCPY(resp->answer_name, NETBIOS_LOCAL_NAME, strlen(NETBIOS_LOCAL_NAME)); + + /* b-node, unique, active */ + resp->answer_name_flags = PP_HTONS(NETB_NFLAG_NAME_IS_ACTIVE); + + /* Set responder netif MAC address */ + SMEMCPY(resp->unit_id, ip_current_input_netif()->hwaddr, sizeof(resp->unit_id)); + + udp_sendto(upcb, q, addr, port); + pbuf_free(q); + } + } +#endif /* LWIP_NETBIOS_RESPOND_NAME_QUERY */ + } + } + } + /* free the pbuf */ + pbuf_free(p); + } +} + +/** + * @ingroup netbiosns + * Init netbios responder + */ +void +netbiosns_init(void) +{ + /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ +#ifdef NETBIOS_LWIP_NAME + LWIP_ASSERT("NetBIOS name is too long!", strlen(NETBIOS_LWIP_NAME) < NETBIOS_NAME_LEN); +#endif + + netbiosns_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + if (netbiosns_pcb != NULL) { + /* we have to be allowed to send broadcast packets! */ + ip_set_option(netbiosns_pcb, SOF_BROADCAST); + udp_bind(netbiosns_pcb, IP_ANY_TYPE, LWIP_IANA_PORT_NETBIOS); + udp_recv(netbiosns_pcb, netbiosns_recv, netbiosns_pcb); + } +} + +#ifndef NETBIOS_LWIP_NAME +/** + * @ingroup netbiosns + * Set netbios name. ATTENTION: the hostname must be less than 15 characters! + * the NetBIOS name spec says the name MUST be upper case, so incoming name is forced into uppercase :-) + */ +void +netbiosns_set_name(const char *hostname) +{ + size_t i; + size_t copy_len = strlen(hostname); + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("NetBIOS name is too long!", copy_len < NETBIOS_NAME_LEN); + if (copy_len >= NETBIOS_NAME_LEN) { + copy_len = NETBIOS_NAME_LEN - 1; + } + + /* make name into upper case */ + for (i = 0; i < copy_len; i++ ) { + netbiosns_local_name[i] = (char)lwip_toupper(hostname[i]); + } + netbiosns_local_name[copy_len] = '\0'; +} +#endif /* NETBIOS_LWIP_NAME */ + +/** + * @ingroup netbiosns + * Stop netbios responder + */ +void +netbiosns_stop(void) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (netbiosns_pcb != NULL) { + udp_remove(netbiosns_pcb); + netbiosns_pcb = NULL; + } +} + +#endif /* LWIP_IPV4 && LWIP_UDP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/smtp/smtp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/smtp/smtp.c index af2f053a..55303c35 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/smtp/smtp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/smtp/smtp.c @@ -1,1555 +1,1555 @@ -/** - * @file - * SMTP client module - * - * Author: Simon Goldschmidt - * - * @defgroup smtp SMTP client - * @ingroup apps - * - * This is simple SMTP client for raw API. - * It is a minimal implementation of SMTP as specified in RFC 5321. - * - * Example usage: -@code{.c} - void my_smtp_result_fn(void *arg, u8_t smtp_result, u16_t srv_err, err_t err) - { - printf("mail (%p) sent with results: 0x%02x, 0x%04x, 0x%08x\n", arg, - smtp_result, srv_err, err); - } - static void my_smtp_test(void) - { - smtp_set_server_addr("mymailserver.org"); - -> set both username and password as NULL if no auth needed - smtp_set_auth("username", "password"); - smtp_send_mail("sender", "recipient", "subject", "body", my_smtp_result_fn, - some_argument); - } -@endcode - - * When using from any other thread than the tcpip_thread (for NO_SYS==0), use - * smtp_send_mail_int()! - * - * SMTP_BODYDH usage: -@code{.c} - int my_smtp_bodydh_fn(void *arg, struct smtp_bodydh *bdh) - { - if(bdh->state >= 10) { - return BDH_DONE; - } - sprintf(bdh->buffer,"Line #%2d\r\n",bdh->state); - bdh->length = strlen(bdh->buffer); - ++bdh->state; - return BDH_WORKING; - } - - smtp_send_mail_bodycback("sender", "recipient", "subject", - my_smtp_bodydh_fn, my_smtp_result_fn, some_argument); -@endcode - * - * @todo: - * - attachments (the main difficulty here is streaming base64-encoding to - * prevent having to allocate a buffer for the whole encoded file at once) - * - test with more mail servers... - * - */ - -#include "lwip/apps/smtp.h" - -#if LWIP_TCP && LWIP_CALLBACK_API -#include "lwip/sys.h" -#include "lwip/sockets.h" -#include "lwip/altcp.h" -#include "lwip/dns.h" -#include "lwip/mem.h" -#include "lwip/altcp_tcp.h" -#include "lwip/altcp_tls.h" - -#include /* strlen, memcpy */ -#include - -/** TCP poll interval. Unit is 0.5 sec. */ -#define SMTP_POLL_INTERVAL 4 -/** TCP poll timeout while sending message body, reset after every - * successful write. 3 minutes */ -#define SMTP_TIMEOUT_DATABLOCK ( 3 * 60 * SMTP_POLL_INTERVAL / 2) -/** TCP poll timeout while waiting for confirmation after sending the body. - * 10 minutes */ -#define SMTP_TIMEOUT_DATATERM (10 * 60 * SMTP_POLL_INTERVAL / 2) -/** TCP poll timeout while not sending the body. - * This is somewhat lower than the RFC states (5 minutes for initial, MAIL - * and RCPT) but still OK for us here. - * 2 minutes */ -#define SMTP_TIMEOUT ( 2 * 60 * SMTP_POLL_INTERVAL / 2) - -/* the various debug levels for this file */ -#define SMTP_DEBUG_TRACE (SMTP_DEBUG | LWIP_DBG_TRACE) -#define SMTP_DEBUG_STATE (SMTP_DEBUG | LWIP_DBG_STATE) -#define SMTP_DEBUG_WARN (SMTP_DEBUG | LWIP_DBG_LEVEL_WARNING) -#define SMTP_DEBUG_WARN_STATE (SMTP_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) -#define SMTP_DEBUG_SERIOUS (SMTP_DEBUG | LWIP_DBG_LEVEL_SERIOUS) - - -#define SMTP_RX_BUF_LEN 255 -#define SMTP_TX_BUF_LEN 255 -#define SMTP_CRLF "\r\n" -#define SMTP_CRLF_LEN 2 - -#define SMTP_RESP_220 "220" -#define SMTP_RESP_235 "235" -#define SMTP_RESP_250 "250" -#define SMTP_RESP_334 "334" -#define SMTP_RESP_354 "354" -#define SMTP_RESP_LOGIN_UNAME "VXNlcm5hbWU6" -#define SMTP_RESP_LOGIN_PASS "UGFzc3dvcmQ6" - -#define SMTP_KEYWORD_AUTH_SP "AUTH " -#define SMTP_KEYWORD_AUTH_EQ "AUTH=" -#define SMTP_KEYWORD_AUTH_LEN 5 -#define SMTP_AUTH_PARAM_PLAIN "PLAIN" -#define SMTP_AUTH_PARAM_LOGIN "LOGIN" - -#define SMTP_CMD_EHLO_1 "EHLO [" -#define SMTP_CMD_EHLO_1_LEN 6 -#define SMTP_CMD_EHLO_2 "]\r\n" -#define SMTP_CMD_EHLO_2_LEN 3 -#define SMTP_CMD_AUTHPLAIN_1 "AUTH PLAIN " -#define SMTP_CMD_AUTHPLAIN_1_LEN 11 -#define SMTP_CMD_AUTHPLAIN_2 "\r\n" -#define SMTP_CMD_AUTHPLAIN_2_LEN 2 -#define SMTP_CMD_AUTHLOGIN "AUTH LOGIN\r\n" -#define SMTP_CMD_AUTHLOGIN_LEN 12 -#define SMTP_CMD_MAIL_1 "MAIL FROM: <" -#define SMTP_CMD_MAIL_1_LEN 12 -#define SMTP_CMD_MAIL_2 ">\r\n" -#define SMTP_CMD_MAIL_2_LEN 3 -#define SMTP_CMD_RCPT_1 "RCPT TO: <" -#define SMTP_CMD_RCPT_1_LEN 10 -#define SMTP_CMD_RCPT_2 ">\r\n" -#define SMTP_CMD_RCPT_2_LEN 3 -#define SMTP_CMD_DATA "DATA\r\n" -#define SMTP_CMD_DATA_LEN 6 -#define SMTP_CMD_HEADER_1 "From: <" -#define SMTP_CMD_HEADER_1_LEN 7 -#define SMTP_CMD_HEADER_2 ">\r\nTo: <" -#define SMTP_CMD_HEADER_2_LEN 8 -#define SMTP_CMD_HEADER_3 ">\r\nSubject: " -#define SMTP_CMD_HEADER_3_LEN 12 -#define SMTP_CMD_HEADER_4 "\r\n\r\n" -#define SMTP_CMD_HEADER_4_LEN 4 -#define SMTP_CMD_BODY_FINISHED "\r\n.\r\n" -#define SMTP_CMD_BODY_FINISHED_LEN 5 -#define SMTP_CMD_QUIT "QUIT\r\n" -#define SMTP_CMD_QUIT_LEN 6 - -#if defined(SMTP_STAT_TX_BUF_MAX) && SMTP_STAT_TX_BUF_MAX -#define SMTP_TX_BUF_MAX(len) LWIP_MACRO(if((len) > smtp_tx_buf_len_max) smtp_tx_buf_len_max = (len);) -#else /* SMTP_STAT_TX_BUF_MAX */ -#define SMTP_TX_BUF_MAX(len) -#endif /* SMTP_STAT_TX_BUF_MAX */ - -#if SMTP_COPY_AUTHDATA -#define SMTP_USERNAME(session) (session)->username -#define SMTP_PASS(session) (session)->pass -#define SMTP_AUTH_PLAIN_DATA(session) (session)->auth_plain -#define SMTP_AUTH_PLAIN_LEN(session) (session)->auth_plain_len -#else /* SMTP_COPY_AUTHDATA */ -#define SMTP_USERNAME(session) smtp_username -#define SMTP_PASS(session) smtp_pass -#define SMTP_AUTH_PLAIN_DATA(session) smtp_auth_plain -#define SMTP_AUTH_PLAIN_LEN(session) smtp_auth_plain_len -#endif /* SMTP_COPY_AUTHDATA */ - -#if SMTP_BODYDH -#ifndef SMTP_BODYDH_MALLOC -#define SMTP_BODYDH_MALLOC(size) mem_malloc(size) -#define SMTP_BODYDH_FREE(ptr) mem_free(ptr) -#endif - -/* Some internal state return values */ -#define BDHALLDATASENT 2 -#define BDHSOMEDATASENT 1 - -enum bdh_handler_state { - BDH_SENDING, /* Serving the user function generating body content */ - BDH_STOP /* User function stopped, closing */ -}; -#endif - -/** State for SMTP client state machine */ -enum smtp_session_state { - SMTP_NULL, - SMTP_HELO, - SMTP_AUTH_PLAIN, - SMTP_AUTH_LOGIN_UNAME, - SMTP_AUTH_LOGIN_PASS, - SMTP_AUTH_LOGIN, - SMTP_MAIL, - SMTP_RCPT, - SMTP_DATA, - SMTP_BODY, - SMTP_QUIT, - SMTP_CLOSED -}; - -#ifdef LWIP_DEBUG -/** State-to-string table for debugging */ -static const char *smtp_state_str[] = { - "SMTP_NULL", - "SMTP_HELO", - "SMTP_AUTH_PLAIN", - "SMTP_AUTH_LOGIN_UNAME", - "SMTP_AUTH_LOGIN_PASS", - "SMTP_AUTH_LOGIN", - "SMTP_MAIL", - "SMTP_RCPT", - "SMTP_DATA", - "SMTP_BODY", - "SMTP_QUIT", - "SMTP_CLOSED", -}; - -static const char *smtp_result_strs[] = { - "SMTP_RESULT_OK", - "SMTP_RESULT_ERR_UNKNOWN", - "SMTP_RESULT_ERR_CONNECT", - "SMTP_RESULT_ERR_HOSTNAME", - "SMTP_RESULT_ERR_CLOSED", - "SMTP_RESULT_ERR_TIMEOUT", - "SMTP_RESULT_ERR_SVR_RESP", - "SMTP_RESULT_ERR_MEM" -}; -#endif /* LWIP_DEBUG */ - -#if SMTP_BODYDH -struct smtp_bodydh_state { - smtp_bodycback_fn callback_fn; /* The function to call (again) */ - u16_t state; - struct smtp_bodydh exposed; /* the user function structure */ -}; -#endif /* SMTP_BODYDH */ - -/** struct keeping the body and state of an smtp session */ -struct smtp_session { - /** keeping the state of the smtp session */ - enum smtp_session_state state; - /** timeout handling, if this reaches 0, the connection is closed */ - u16_t timer; - /** helper buffer for transmit, not used for sending body */ - char tx_buf[SMTP_TX_BUF_LEN + 1]; - struct pbuf* p; - /** source email address */ - const char* from; - /** size of the sourceemail address */ - u16_t from_len; - /** target email address */ - const char* to; - /** size of the target email address */ - u16_t to_len; - /** subject of the email */ - const char *subject; - /** length of the subject string */ - u16_t subject_len; - /** this is the body of the mail to be sent */ - const char* body; - /** this is the length of the body to be sent */ - u16_t body_len; - /** amount of data from body already sent */ - u16_t body_sent; - /** callback function to call when closed */ - smtp_result_fn callback_fn; - /** argument for callback function */ - void *callback_arg; -#if SMTP_COPY_AUTHDATA - /** Username to use for this request */ - char *username; - /** Password to use for this request */ - char *pass; - /** Username and password combined as necessary for PLAIN authentication */ - char auth_plain[SMTP_MAX_USERNAME_LEN + SMTP_MAX_PASS_LEN + 3]; - /** Length of smtp_auth_plain string (cannot use strlen since it includes \0) */ - size_t auth_plain_len; -#endif /* SMTP_COPY_AUTHDATA */ -#if SMTP_BODYDH - struct smtp_bodydh_state *bodydh; -#endif /* SMTP_BODYDH */ -}; - -/** IP address or DNS name of the server to use for next SMTP request */ -static char smtp_server[SMTP_MAX_SERVERNAME_LEN + 1]; -/** TCP port of the server to use for next SMTP request */ -static u16_t smtp_server_port = SMTP_DEFAULT_PORT; -#if LWIP_ALTCP && LWIP_ALTCP_TLS -/** If this is set, mail is sent using SMTPS */ -static struct altcp_tls_config *smtp_server_tls_config; -#endif -/** Username to use for the next SMTP request */ -static char *smtp_username; -/** Password to use for the next SMTP request */ -static char *smtp_pass; -/** Username and password combined as necessary for PLAIN authentication */ -static char smtp_auth_plain[SMTP_MAX_USERNAME_LEN + SMTP_MAX_PASS_LEN + 3]; -/** Length of smtp_auth_plain string (cannot use strlen since it includes \0) */ -static size_t smtp_auth_plain_len; - -#if SMTP_CHECK_DATA -static err_t smtp_verify(const char *data, size_t data_len, u8_t linebreaks_allowed); -#endif /* SMTP_CHECK_DATA */ -static err_t smtp_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err); -static void smtp_tcp_err(void *arg, err_t err); -static err_t smtp_tcp_poll(void *arg, struct altcp_pcb *pcb); -static err_t smtp_tcp_sent(void *arg, struct altcp_pcb *pcb, u16_t len); -static err_t smtp_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err); -#if LWIP_DNS -static void smtp_dns_found(const char* hostname, const ip_addr_t *ipaddr, void *arg); -#endif /* LWIP_DNS */ -#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN -static size_t smtp_base64_encode(char* target, size_t target_len, const char* source, size_t source_len); -#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ -static enum smtp_session_state smtp_prepare_mail(struct smtp_session *s, u16_t *tx_buf_len); -static void smtp_send_body(struct smtp_session *s, struct altcp_pcb *pcb); -static void smtp_process(void *arg, struct altcp_pcb *pcb, struct pbuf *p); -#if SMTP_BODYDH -static void smtp_send_body_data_handler(struct smtp_session *s, struct altcp_pcb *pcb); -#endif /* SMTP_BODYDH */ - - -#ifdef LWIP_DEBUG -/** Convert an smtp result to a string */ -const char* -smtp_result_str(u8_t smtp_result) -{ - if (smtp_result >= LWIP_ARRAYSIZE(smtp_result_strs)) { - return "UNKNOWN"; - } - return smtp_result_strs[smtp_result]; -} - -/** Null-terminates the payload of p for printing out messages. - * WARNING: use this only if p is not needed any more as the last byte of - * payload is deleted! - */ -static const char* -smtp_pbuf_str(struct pbuf* p) -{ - if ((p == NULL) || (p->len == 0)) { - return ""; - } - ((char*)p->payload)[p->len] = 0; - return (const char*)p->payload; -} -#endif /* LWIP_DEBUG */ - -/** @ingroup smtp - * Set IP address or DNS name for next SMTP connection - * - * @param server IP address (in ASCII representation) or DNS name of the server - */ -err_t -smtp_set_server_addr(const char* server) -{ - size_t len = 0; - - LWIP_ASSERT_CORE_LOCKED(); - - if (server != NULL) { - /* strlen: returns length WITHOUT terminating 0 byte */ - len = strlen(server); - } - if (len > SMTP_MAX_SERVERNAME_LEN) { - return ERR_MEM; - } - if (len != 0) { - MEMCPY(smtp_server, server, len); - } - smtp_server[len] = 0; /* always OK because of smtp_server[SMTP_MAX_SERVERNAME_LEN + 1] */ - return ERR_OK; -} - -/** @ingroup smtp - * Set TCP port for next SMTP connection - * - * @param port TCP port - */ -void -smtp_set_server_port(u16_t port) -{ - LWIP_ASSERT_CORE_LOCKED(); - smtp_server_port = port; -} - -#if LWIP_ALTCP && LWIP_ALTCP_TLS -/** @ingroup smtp - * Set TLS configuration for next SMTP connection - * - * @param tls_config TLS configuration - */ -void -smtp_set_tls_config(struct altcp_tls_config *tls_config) -{ - LWIP_ASSERT_CORE_LOCKED(); - smtp_server_tls_config = tls_config; -} -#endif - -/** @ingroup smtp - * Set authentication parameters for next SMTP connection - * - * @param username login name as passed to the server - * @param pass password passed to the server together with username - */ -err_t -smtp_set_auth(const char* username, const char* pass) -{ - size_t uname_len = 0; - size_t pass_len = 0; - - LWIP_ASSERT_CORE_LOCKED(); - - memset(smtp_auth_plain, 0xfa, 64); - if (username != NULL) { - uname_len = strlen(username); - if (uname_len > SMTP_MAX_USERNAME_LEN) { - LWIP_DEBUGF(SMTP_DEBUG_SERIOUS, ("Username is too long, %d instead of %d\n", - (int)uname_len, SMTP_MAX_USERNAME_LEN)); - return ERR_ARG; - } - } - if (pass != NULL) { -#if SMTP_SUPPORT_AUTH_LOGIN || SMTP_SUPPORT_AUTH_PLAIN - pass_len = strlen(pass); - if (pass_len > SMTP_MAX_PASS_LEN) { - LWIP_DEBUGF(SMTP_DEBUG_SERIOUS, ("Password is too long, %d instead of %d\n", - (int)uname_len, SMTP_MAX_USERNAME_LEN)); - return ERR_ARG; - } -#else /* SMTP_SUPPORT_AUTH_LOGIN || SMTP_SUPPORT_AUTH_PLAIN */ - LWIP_DEBUGF(SMTP_DEBUG_WARN, ("Password not supported as no authentication methods are activated\n")); -#endif /* SMTP_SUPPORT_AUTH_LOGIN || SMTP_SUPPORT_AUTH_PLAIN */ - } - *smtp_auth_plain = 0; - if (username != NULL) { - smtp_username = smtp_auth_plain + 1; - strcpy(smtp_username, username); - } - if (pass != NULL) { - smtp_pass = smtp_auth_plain + uname_len + 2; - strcpy(smtp_pass, pass); - } - smtp_auth_plain_len = uname_len + pass_len + 2; - - return ERR_OK; -} - -#if SMTP_BODYDH -static void smtp_free_struct(struct smtp_session *s) -{ - if (s->bodydh != NULL) { - SMTP_BODYDH_FREE(s->bodydh); - } - SMTP_STATE_FREE(s); -} -#else /* SMTP_BODYDH */ -#define smtp_free_struct(x) SMTP_STATE_FREE(x) -#endif /* SMTP_BODYDH */ - -static struct altcp_pcb* -smtp_setup_pcb(struct smtp_session *s, const ip_addr_t* remote_ip) -{ - struct altcp_pcb* pcb; - LWIP_UNUSED_ARG(remote_ip); - -#if LWIP_ALTCP && LWIP_ALTCP_TLS - if (smtp_server_tls_config) { - pcb = altcp_tls_new(smtp_server_tls_config, IP_GET_TYPE(remote_ip)); - } else -#endif - { - pcb = altcp_tcp_new_ip_type(IP_GET_TYPE(remote_ip)); - } - if (pcb != NULL) { - altcp_arg(pcb, s); - altcp_recv(pcb, smtp_tcp_recv); - altcp_err(pcb, smtp_tcp_err); - altcp_poll(pcb, smtp_tcp_poll, SMTP_POLL_INTERVAL); - altcp_sent(pcb, smtp_tcp_sent); - } - return pcb; -} - -/** The actual mail-sending function, called by smtp_send_mail and - * smtp_send_mail_static after setting up the struct smtp_session. - */ -static err_t -smtp_send_mail_alloced(struct smtp_session *s) -{ - err_t err; - struct altcp_pcb* pcb = NULL; - ip_addr_t addr; - - LWIP_ASSERT("no smtp_session supplied", s != NULL); - -#if SMTP_CHECK_DATA - /* check that body conforms to RFC: - * - convert all single-CR or -LF in body to CRLF - * - only 7-bit ASCII is allowed - */ - if (smtp_verify(s->to, s->to_len, 0) != ERR_OK) { - err = ERR_ARG; - goto leave; - } - if (smtp_verify(s->from, s->from_len, 0) != ERR_OK) { - err = ERR_ARG; - goto leave; - } - if (smtp_verify(s->subject, s->subject_len, 0) != ERR_OK) { - err = ERR_ARG; - goto leave; - } -#if SMTP_BODYDH - if (s->bodydh == NULL) -#endif /* SMTP_BODYDH */ - { - if (smtp_verify(s->body, s->body_len, 0) != ERR_OK) { - err = ERR_ARG; - goto leave; - } - } -#endif /* SMTP_CHECK_DATA */ - -#if SMTP_COPY_AUTHDATA - /* copy auth data, ensuring the first byte is always zero */ - MEMCPY(s->auth_plain + 1, smtp_auth_plain + 1, smtp_auth_plain_len - 1); - s->auth_plain_len = smtp_auth_plain_len; - /* default username and pass is empty string */ - s->username = s->auth_plain; - s->pass = s->auth_plain; - if (smtp_username != NULL) { - s->username += smtp_username - smtp_auth_plain; - } - if (smtp_pass != NULL) { - s->pass += smtp_pass - smtp_auth_plain; - } -#endif /* SMTP_COPY_AUTHDATA */ - - s->state = SMTP_NULL; - s->timer = SMTP_TIMEOUT; - -#if LWIP_DNS - err = dns_gethostbyname(smtp_server, &addr, smtp_dns_found, s); -#else /* LWIP_DNS */ - err = ipaddr_aton(smtp_server, &addr) ? ERR_OK : ERR_ARG; -#endif /* LWIP_DNS */ - if (err == ERR_OK) { - pcb = smtp_setup_pcb(s, &addr); - if (pcb == NULL) { - err = ERR_MEM; - goto leave; - } - err = altcp_connect(pcb, &addr, smtp_server_port, smtp_tcp_connected); - if (err != ERR_OK) { - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("tcp_connect failed: %d\n", (int)err)); - goto deallocate_and_leave; - } - } else if (err != ERR_INPROGRESS) { - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("dns_gethostbyname failed: %d\n", (int)err)); - goto deallocate_and_leave; - } - return ERR_OK; - -deallocate_and_leave: - if (pcb != NULL) { - altcp_arg(pcb, NULL); - altcp_close(pcb); - } -leave: - smtp_free_struct(s); - /* no need to call the callback here since we return != ERR_OK */ - return err; -} - -/** @ingroup smtp - * Send an email via the currently selected server, username and password. - * - * @param from source email address (must be NULL-terminated) - * @param to target email address (must be NULL-terminated) - * @param subject email subject (must be NULL-terminated) - * @param body email body (must be NULL-terminated) - * @param callback_fn callback function - * @param callback_arg user argument to callback_fn - * @returns - ERR_OK if structures were allocated and no error occured starting the connection - * (this does not mean the email has been successfully sent!) - * - another err_t on error. - */ -err_t -smtp_send_mail(const char* from, const char* to, const char* subject, const char* body, - smtp_result_fn callback_fn, void* callback_arg) -{ - struct smtp_session* s; - size_t from_len = strlen(from); - size_t to_len = strlen(to); - size_t subject_len = strlen(subject); - size_t body_len = strlen(body); - size_t mem_len = sizeof(struct smtp_session); - char *sfrom, *sto, *ssubject, *sbody; - - LWIP_ASSERT_CORE_LOCKED(); - - mem_len += from_len + to_len + subject_len + body_len + 4; - if (mem_len > 0xffff) { - /* too long! */ - return ERR_MEM; - } - - /* Allocate memory to keep this email's session state */ - s = (struct smtp_session *)SMTP_STATE_MALLOC((mem_size_t)mem_len); - if (s == NULL) { - return ERR_MEM; - } - /* initialize the structure */ - memset(s, 0, mem_len); - s->from = sfrom = (char*)s + sizeof(struct smtp_session); - s->from_len = (u16_t)from_len; - s->to = sto = sfrom + from_len + 1; - s->to_len = (u16_t)to_len; - s->subject = ssubject = sto + to_len + 1; - s->subject_len = (u16_t)subject_len; - s->body = sbody = ssubject + subject_len + 1; - s->body_len = (u16_t)body_len; - /* copy source and target email address */ - /* cast to size_t is a hack to cast away constness */ - MEMCPY(sfrom, from, from_len + 1); - MEMCPY(sto, to, to_len + 1); - MEMCPY(ssubject, subject, subject_len + 1); - MEMCPY(sbody, body, body_len + 1); - - s->callback_fn = callback_fn; - s->callback_arg = callback_arg; - - /* call the actual implementation of this function */ - return smtp_send_mail_alloced(s); -} - -/** @ingroup smtp - * Same as smtp_send_mail, but doesn't copy from, to, subject and body into - * an internal buffer to save memory. - * WARNING: the above data must stay untouched until the callback function is - * called (unless the function returns != ERR_OK) - */ -err_t -smtp_send_mail_static(const char *from, const char* to, const char* subject, - const char* body, smtp_result_fn callback_fn, void* callback_arg) -{ - struct smtp_session* s; - size_t len; - - LWIP_ASSERT_CORE_LOCKED(); - - s = (struct smtp_session*)SMTP_STATE_MALLOC(sizeof(struct smtp_session)); - if (s == NULL) { - return ERR_MEM; - } - memset(s, 0, sizeof(struct smtp_session)); - /* initialize the structure */ - s->from = from; - len = strlen(from); - LWIP_ASSERT("string is too long", len <= 0xffff); - s->from_len = (u16_t)len; - s->to = to; - len = strlen(to); - LWIP_ASSERT("string is too long", len <= 0xffff); - s->to_len = (u16_t)len; - s->subject = subject; - len = strlen(subject); - LWIP_ASSERT("string is too long", len <= 0xffff); - s->subject_len = (u16_t)len; - s->body = body; - len = strlen(body); - LWIP_ASSERT("string is too long", len <= 0xffff); - s->body_len = (u16_t)len; - s->callback_fn = callback_fn; - s->callback_arg = callback_arg; - /* call the actual implementation of this function */ - return smtp_send_mail_alloced(s); -} - - -/** @ingroup smtp - * Same as smtp_send_mail but takes a struct smtp_send_request as single - * parameter which contains all the other parameters. - * To be used with tcpip_callback to send mail from interrupt context or from - * another thread. - * - * WARNING: server and authentication must stay untouched until this function has run! - * - * Usage example: - * - allocate a struct smtp_send_request (in a way that is allowed in interrupt context) - * - fill the members of the struct as if calling smtp_send_mail - * - specify a callback_function - * - set callback_arg to the structure itself - * - call this function - * - wait for the callback function to be called - * - in the callback function, deallocate the structure (passed as arg) - */ -void -smtp_send_mail_int(void *arg) -{ - struct smtp_send_request *req = (struct smtp_send_request*)arg; - err_t err; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("smtp_send_mail_int: no argument given", arg != NULL); - - if (req->static_data) { - err = smtp_send_mail_static(req->from, req->to, req->subject, req->body, - req->callback_fn, req->callback_arg); - } else { - err = smtp_send_mail(req->from, req->to, req->subject, req->body, - req->callback_fn, req->callback_arg); - } - if ((err != ERR_OK) && (req->callback_fn != NULL)) { - req->callback_fn(req->callback_arg, SMTP_RESULT_ERR_UNKNOWN, 0, err); - } -} - -#if SMTP_CHECK_DATA -/** Verify that a given string conforms to the SMTP rules - * (7-bit only, no single CR or LF, - * @todo: no line consisting of a single dot only) - */ -static err_t -smtp_verify(const char *data, size_t data_len, u8_t linebreaks_allowed) -{ - size_t i; - u8_t last_was_cr = 0; - for (i = 0; i < data_len; i++) { - char current = data[i]; - if ((current & 0x80) != 0) { - LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: no 8-bit data supported: %s\n", data)); - return ERR_ARG; - } - if (current == '\r') { - if (!linebreaks_allowed) { - LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: found CR where no linebreaks allowed: %s\n", data)); - return ERR_ARG; - } - if (last_was_cr) { - LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: found double CR: %s\n", data)); - return ERR_ARG; - } - last_was_cr = 1; - } else { - if (current == '\n') { - if (!last_was_cr) { - LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: found LF without CR before: %s\n", data)); - return ERR_ARG; - } - } - last_was_cr = 0; - } - } - return ERR_OK; -} -#endif /* SMTP_CHECK_DATA */ - -/** Frees the smtp_session and calls the callback function */ -static void -smtp_free(struct smtp_session *s, u8_t result, u16_t srv_err, err_t err) -{ - smtp_result_fn fn = s->callback_fn; - void *arg = s->callback_arg; - if (s->p != NULL) { - pbuf_free(s->p); - } - smtp_free_struct(s); - if (fn != NULL) { - fn(arg, result, srv_err, err); - } -} - -/** Try to close a pcb and free the arg if successful */ -static void -smtp_close(struct smtp_session *s, struct altcp_pcb *pcb, u8_t result, - u16_t srv_err, err_t err) -{ - if (pcb != NULL) { - altcp_arg(pcb, NULL); - if (altcp_close(pcb) == ERR_OK) { - if (s != NULL) { - smtp_free(s, result, srv_err, err); - } - } else { - /* close failed, set back arg */ - altcp_arg(pcb, s); - } - } else { - if (s != NULL) { - smtp_free(s, result, srv_err, err); - } - } -} - -/** Raw API TCP err callback: pcb is already deallocated */ -static void -smtp_tcp_err(void *arg, err_t err) -{ - LWIP_UNUSED_ARG(err); - if (arg != NULL) { - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_tcp_err: connection reset by remote host\n")); - smtp_free((struct smtp_session*)arg, SMTP_RESULT_ERR_CLOSED, 0, err); - } -} - -/** Raw API TCP poll callback */ -static err_t -smtp_tcp_poll(void *arg, struct altcp_pcb *pcb) -{ - if (arg != NULL) { - struct smtp_session *s = (struct smtp_session*)arg; - if (s->timer != 0) { - s->timer--; - } - } - smtp_process(arg, pcb, NULL); - return ERR_OK; -} - -/** Raw API TCP sent callback */ -static err_t -smtp_tcp_sent(void *arg, struct altcp_pcb *pcb, u16_t len) -{ - LWIP_UNUSED_ARG(len); - - smtp_process(arg, pcb, NULL); - - return ERR_OK; -} - -/** Raw API TCP recv callback */ -static err_t -smtp_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) -{ - LWIP_UNUSED_ARG(err); - if (p != NULL) { - altcp_recved(pcb, p->tot_len); - smtp_process(arg, pcb, p); - } else { - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_tcp_recv: connection closed by remote host\n")); - smtp_close((struct smtp_session*)arg, pcb, SMTP_RESULT_ERR_CLOSED, 0, err); - } - return ERR_OK; -} - -static err_t -smtp_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err) -{ - LWIP_UNUSED_ARG(arg); - - if (err == ERR_OK) { - LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_connected: Waiting for 220\n")); - } else { - /* shouldn't happen, but we still check 'err', only to be sure */ - LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_connected: %d\n", (int)err)); - smtp_close((struct smtp_session*)arg, pcb, SMTP_RESULT_ERR_CONNECT, 0, err); - } - return ERR_OK; -} - -#if LWIP_DNS -/** DNS callback - * If ipaddr is non-NULL, resolving succeeded, otherwise it failed. - */ -static void -smtp_dns_found(const char* hostname, const ip_addr_t *ipaddr, void *arg) -{ - struct smtp_session *s = (struct smtp_session*)arg; - struct altcp_pcb *pcb; - err_t err; - u8_t result; - - LWIP_UNUSED_ARG(hostname); - - if (ipaddr != NULL) { - pcb = smtp_setup_pcb(s, ipaddr); - if (pcb != NULL) { - LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_dns_found: hostname resolved, connecting\n")); - err = altcp_connect(pcb, ipaddr, smtp_server_port, smtp_tcp_connected); - if (err == ERR_OK) { - return; - } - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("tcp_connect failed: %d\n", (int)err)); - result = SMTP_RESULT_ERR_CONNECT; - } else { - LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_dns_found: failed to allocate tcp pcb\n")); - result = SMTP_RESULT_ERR_MEM; - err = ERR_MEM; - } - } else { - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_dns_found: failed to resolve hostname: %s\n", - hostname)); - pcb = NULL; - result = SMTP_RESULT_ERR_HOSTNAME; - err = ERR_ARG; - } - smtp_close(s, pcb, result, 0, err); -} -#endif /* LWIP_DNS */ - -#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN - -/** Table 6-bit-index-to-ASCII used for base64-encoding */ -static const char base64_table[] = { - 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', - 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', - 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', - 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', - 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', - 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', - '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', - '+', '/' -}; - -/** Base64 encoding */ -static size_t -smtp_base64_encode(char* target, size_t target_len, const char* source, size_t source_len) -{ - size_t i; - s8_t j; - size_t target_idx = 0; - size_t longer = (source_len % 3) ? (3 - (source_len % 3)) : 0; - size_t source_len_b64 = source_len + longer; - size_t len = (((source_len_b64) * 4) / 3); - u8_t x = 5; - u8_t current = 0; - LWIP_UNUSED_ARG(target_len); - - LWIP_ASSERT("target_len is too short", target_len >= len); - - for (i = 0; i < source_len_b64; i++) { - u8_t b = (i < source_len ? (u8_t)source[i] : 0); - for (j = 7; j >= 0; j--, x--) { - if ((b & (1 << j)) != 0) { - current = (u8_t)(current | (1U << x)); - } - if (x == 0) { - target[target_idx++] = base64_table[current]; - x = 6; - current = 0; - } - } - } - for (i = len - longer; i < len; i++) { - target[i] = '='; - } - return len; -} -#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ - -/** Parse pbuf to see if it contains the beginning of an answer. - * If so, it returns the contained response code as number between 1 and 999. - * If not, zero is returned. - * - * @param s smtp session struct - */ -static u16_t -smtp_is_response(struct smtp_session *s) -{ - char digits[4]; - long num; - - if (s->p == NULL) { - return 0; - } - /* copy three digits and convert them to int */ - if (pbuf_copy_partial(s->p, digits, 3, 0) != 3) { - /* pbuf was too short */ - return 0; - } - digits[3] = 0; - num = strtol(digits, NULL, 10); - if ((num <= 0) || (num >= 1000)) { - /* failed to find response code at start of line */ - return 0; - } - return (u16_t)num; -} - -/** Parse pbuf to see if it contains a fully received answer. - * If one is found, ERR_OK is returned. - * If none is found, ERR_VAL is returned. - * - * A fully received answer is a 3-digit number followed by a space, - * some string and a CRLF as line ending. - * - * @param s smtp session struct - */ -static err_t -smtp_is_response_finished(struct smtp_session *s) -{ - u8_t sp; - u16_t crlf; - u16_t offset; - - if (s->p == NULL) { - return ERR_VAL; - } - offset = 0; -again: - /* We could check the response number here, but we trust the - * protocol definition which says the client can rely on it being - * the same on every line. */ - - /* find CRLF */ - if (offset > 0xFFFF - 4) { - /* would overflow */ - return ERR_VAL; - } - crlf = pbuf_memfind(s->p, SMTP_CRLF, SMTP_CRLF_LEN, (u16_t)(offset + 4)); - if (crlf == 0xFFFF) { - /* no CRLF found */ - return ERR_VAL; - } - sp = pbuf_get_at(s->p, (u16_t)(offset + 3)); - if (sp == '-') { - /* no space after response code -> try next line */ - offset = (u16_t)(crlf + 2); - if (offset < crlf) { - /* overflow */ - return ERR_VAL; - } - goto again; - } else if (sp == ' ') { - /* CRLF found after response code + space -> valid response */ - return ERR_OK; - } - /* sp contains invalid character */ - return ERR_VAL; -} - -/** Prepare HELO/EHLO message */ -static enum smtp_session_state -smtp_prepare_helo(struct smtp_session *s, u16_t *tx_buf_len, struct altcp_pcb *pcb) -{ - size_t ipa_len; - const char *ipa = ipaddr_ntoa(altcp_get_ip(pcb, 1)); - LWIP_ASSERT("ipaddr_ntoa returned NULL", ipa != NULL); - ipa_len = strlen(ipa); - LWIP_ASSERT("string too long", ipa_len <= (SMTP_TX_BUF_LEN-SMTP_CMD_EHLO_1_LEN-SMTP_CMD_EHLO_2_LEN)); - - *tx_buf_len = (u16_t)(SMTP_CMD_EHLO_1_LEN + (u16_t)ipa_len + SMTP_CMD_EHLO_2_LEN); - LWIP_ASSERT("tx_buf overflow detected", *tx_buf_len <= SMTP_TX_BUF_LEN); - - SMEMCPY(s->tx_buf, SMTP_CMD_EHLO_1, SMTP_CMD_EHLO_1_LEN); - MEMCPY(&s->tx_buf[SMTP_CMD_EHLO_1_LEN], ipa, ipa_len); - SMEMCPY(&s->tx_buf[SMTP_CMD_EHLO_1_LEN + ipa_len], SMTP_CMD_EHLO_2, SMTP_CMD_EHLO_2_LEN); - return SMTP_HELO; -} - -#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN -/** Parse last server response (in rx_buf) for supported authentication method, - * create data to send out (to tx_buf), set tx_data_len correctly - * and return the next state. - */ -static enum smtp_session_state -smtp_prepare_auth_or_mail(struct smtp_session *s, u16_t *tx_buf_len) -{ - /* check response for supported authentication method */ - u16_t auth = pbuf_strstr(s->p, SMTP_KEYWORD_AUTH_SP); - if (auth == 0xFFFF) { - auth = pbuf_strstr(s->p, SMTP_KEYWORD_AUTH_EQ); - } - if (auth != 0xFFFF) { - u16_t crlf = pbuf_memfind(s->p, SMTP_CRLF, SMTP_CRLF_LEN, auth); - if ((crlf != 0xFFFF) && (crlf > auth)) { - /* use tx_buf temporarily */ - u16_t copied = pbuf_copy_partial(s->p, s->tx_buf, (u16_t)(crlf - auth), auth); - if (copied != 0) { - char *sep = s->tx_buf + SMTP_KEYWORD_AUTH_LEN; - s->tx_buf[copied] = 0; -#if SMTP_SUPPORT_AUTH_PLAIN - /* favour PLAIN over LOGIN since it involves less requests */ - if (strstr(sep, SMTP_AUTH_PARAM_PLAIN) != NULL) { - size_t auth_len; - /* server supports AUTH PLAIN */ - SMEMCPY(s->tx_buf, SMTP_CMD_AUTHPLAIN_1, SMTP_CMD_AUTHPLAIN_1_LEN); - - /* add base64-encoded string "\0username\0password" */ - auth_len = smtp_base64_encode(&s->tx_buf[SMTP_CMD_AUTHPLAIN_1_LEN], - SMTP_TX_BUF_LEN - SMTP_CMD_AUTHPLAIN_1_LEN, SMTP_AUTH_PLAIN_DATA(s), - SMTP_AUTH_PLAIN_LEN(s)); - LWIP_ASSERT("string too long", auth_len <= (SMTP_TX_BUF_LEN-SMTP_CMD_AUTHPLAIN_1_LEN-SMTP_CMD_AUTHPLAIN_2_LEN)); - *tx_buf_len = (u16_t)(SMTP_CMD_AUTHPLAIN_1_LEN + SMTP_CMD_AUTHPLAIN_2_LEN + (u16_t)auth_len); - SMEMCPY(&s->tx_buf[SMTP_CMD_AUTHPLAIN_1_LEN + auth_len], SMTP_CMD_AUTHPLAIN_2, - SMTP_CMD_AUTHPLAIN_2_LEN); - return SMTP_AUTH_PLAIN; - } else -#endif /* SMTP_SUPPORT_AUTH_PLAIN */ - { -#if SMTP_SUPPORT_AUTH_LOGIN - if (strstr(sep, SMTP_AUTH_PARAM_LOGIN) != NULL) { - /* server supports AUTH LOGIN */ - *tx_buf_len = SMTP_CMD_AUTHLOGIN_LEN; - SMEMCPY(s->tx_buf, SMTP_CMD_AUTHLOGIN, SMTP_CMD_AUTHLOGIN_LEN); - return SMTP_AUTH_LOGIN_UNAME; - } -#endif /* SMTP_SUPPORT_AUTH_LOGIN */ - } - } - } - } - /* server didnt's send correct keywords for AUTH, try sending directly */ - return smtp_prepare_mail(s, tx_buf_len); -} -#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ - -#if SMTP_SUPPORT_AUTH_LOGIN -/** Send base64-encoded username */ -static enum smtp_session_state -smtp_prepare_auth_login_uname(struct smtp_session *s, u16_t *tx_buf_len) -{ - size_t base64_len = smtp_base64_encode(s->tx_buf, SMTP_TX_BUF_LEN, - SMTP_USERNAME(s), strlen(SMTP_USERNAME(s))); - /* @todo: support base64-encoded longer than 64k */ - LWIP_ASSERT("string too long", base64_len <= 0xffff); - LWIP_ASSERT("tx_buf overflow detected", base64_len <= SMTP_TX_BUF_LEN - SMTP_CRLF_LEN); - *tx_buf_len = (u16_t)(base64_len + SMTP_CRLF_LEN); - - SMEMCPY(&s->tx_buf[base64_len], SMTP_CRLF, SMTP_CRLF_LEN); - s->tx_buf[*tx_buf_len] = 0; - return SMTP_AUTH_LOGIN_PASS; -} - -/** Send base64-encoded password */ -static enum smtp_session_state -smtp_prepare_auth_login_pass(struct smtp_session *s, u16_t *tx_buf_len) -{ - size_t base64_len = smtp_base64_encode(s->tx_buf, SMTP_TX_BUF_LEN, - SMTP_PASS(s), strlen(SMTP_PASS(s))); - /* @todo: support base64-encoded longer than 64k */ - LWIP_ASSERT("string too long", base64_len <= 0xffff); - LWIP_ASSERT("tx_buf overflow detected", base64_len <= SMTP_TX_BUF_LEN - SMTP_CRLF_LEN); - *tx_buf_len = (u16_t)(base64_len + SMTP_CRLF_LEN); - - SMEMCPY(&s->tx_buf[base64_len], SMTP_CRLF, SMTP_CRLF_LEN); - s->tx_buf[*tx_buf_len] = 0; - return SMTP_AUTH_LOGIN; -} -#endif /* SMTP_SUPPORT_AUTH_LOGIN */ - -/** Prepare MAIL message */ -static enum smtp_session_state -smtp_prepare_mail(struct smtp_session *s, u16_t *tx_buf_len) -{ - char *target = s->tx_buf; - LWIP_ASSERT("tx_buf overflow detected", s->from_len <= (SMTP_TX_BUF_LEN - SMTP_CMD_MAIL_1_LEN - SMTP_CMD_MAIL_2_LEN)); - *tx_buf_len = (u16_t)(SMTP_CMD_MAIL_1_LEN + SMTP_CMD_MAIL_2_LEN + s->from_len); - target[*tx_buf_len] = 0; - - SMEMCPY(target, SMTP_CMD_MAIL_1, SMTP_CMD_MAIL_1_LEN); - target += SMTP_CMD_MAIL_1_LEN; - MEMCPY(target, s->from, s->from_len); - target += s->from_len; - SMEMCPY(target, SMTP_CMD_MAIL_2, SMTP_CMD_MAIL_2_LEN); - return SMTP_MAIL; -} - -/** Prepare RCPT message */ -static enum smtp_session_state -smtp_prepare_rcpt(struct smtp_session *s, u16_t *tx_buf_len) -{ - char *target = s->tx_buf; - LWIP_ASSERT("tx_buf overflow detected", s->to_len <= (SMTP_TX_BUF_LEN - SMTP_CMD_RCPT_1_LEN - SMTP_CMD_RCPT_2_LEN)); - *tx_buf_len = (u16_t)(SMTP_CMD_RCPT_1_LEN + SMTP_CMD_RCPT_2_LEN + s->to_len); - target[*tx_buf_len] = 0; - - SMEMCPY(target, SMTP_CMD_RCPT_1, SMTP_CMD_RCPT_1_LEN); - target += SMTP_CMD_RCPT_1_LEN; - MEMCPY(target, s->to, s->to_len); - target += s->to_len; - SMEMCPY(target, SMTP_CMD_RCPT_2, SMTP_CMD_RCPT_2_LEN); - return SMTP_RCPT; -} - -/** Prepare header of body */ -static enum smtp_session_state -smtp_prepare_header(struct smtp_session *s, u16_t *tx_buf_len) -{ - char *target = s->tx_buf; - int len = SMTP_CMD_HEADER_1_LEN + SMTP_CMD_HEADER_2_LEN + - SMTP_CMD_HEADER_3_LEN + SMTP_CMD_HEADER_4_LEN + s->from_len + s->to_len + - s->subject_len; - LWIP_ASSERT("tx_buf overflow detected", len > 0 && len <= SMTP_TX_BUF_LEN); - *tx_buf_len = (u16_t)len; - target[*tx_buf_len] = 0; - - SMEMCPY(target, SMTP_CMD_HEADER_1, SMTP_CMD_HEADER_1_LEN); - target += SMTP_CMD_HEADER_1_LEN; - MEMCPY(target, s->from, s->from_len); - target += s->from_len; - SMEMCPY(target, SMTP_CMD_HEADER_2, SMTP_CMD_HEADER_2_LEN); - target += SMTP_CMD_HEADER_2_LEN; - MEMCPY(target, s->to, s->to_len); - target += s->to_len; - SMEMCPY(target, SMTP_CMD_HEADER_3, SMTP_CMD_HEADER_3_LEN); - target += SMTP_CMD_HEADER_3_LEN; - MEMCPY(target, s->subject, s->subject_len); - target += s->subject_len; - SMEMCPY(target, SMTP_CMD_HEADER_4, SMTP_CMD_HEADER_4_LEN); - - return SMTP_BODY; -} - -/** Prepare QUIT message */ -static enum smtp_session_state -smtp_prepare_quit(struct smtp_session *s, u16_t *tx_buf_len) -{ - *tx_buf_len = SMTP_CMD_QUIT_LEN; - s->tx_buf[*tx_buf_len] = 0; - SMEMCPY(s->tx_buf, SMTP_CMD_QUIT, SMTP_CMD_QUIT_LEN); - LWIP_ASSERT("tx_buf overflow detected", *tx_buf_len <= SMTP_TX_BUF_LEN); - return SMTP_CLOSED; -} - -/** If in state SMTP_BODY, try to send more body data */ -static void -smtp_send_body(struct smtp_session *s, struct altcp_pcb *pcb) -{ - err_t err; - - if (s->state == SMTP_BODY) { -#if SMTP_BODYDH - if (s->bodydh) { - smtp_send_body_data_handler(s, pcb); - } else -#endif /* SMTP_BODYDH */ - { - u16_t send_len = (u16_t)(s->body_len - s->body_sent); - if (send_len > 0) { - u16_t snd_buf = altcp_sndbuf(pcb); - if (send_len > snd_buf) { - send_len = snd_buf; - } - if (send_len > 0) { - /* try to send something out */ - err = altcp_write(pcb, &s->body[s->body_sent], (u16_t)send_len, TCP_WRITE_FLAG_COPY); - if (err == ERR_OK) { - s->timer = SMTP_TIMEOUT_DATABLOCK; - s->body_sent = (u16_t)(s->body_sent + send_len); - if (s->body_sent < s->body_len) { - LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_send_body: %d of %d bytes written\n", - s->body_sent, s->body_len)); - } - } - } - } - } - if (s->body_sent == s->body_len) { - /* the whole body has been written, write last line */ - LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_send_body: body completely written (%d bytes), appending end-of-body\n", - s->body_len)); - err = altcp_write(pcb, SMTP_CMD_BODY_FINISHED, SMTP_CMD_BODY_FINISHED_LEN, 0); - if (err == ERR_OK) { - s->timer = SMTP_TIMEOUT_DATATERM; - LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_send_body: end-of-body written, changing state to %s\n", - smtp_state_str[SMTP_QUIT])); - /* last line written, change state, wait for confirmation */ - s->state = SMTP_QUIT; - } - } - } -} - -/** State machine-like implementation of an SMTP client. - */ -static void -smtp_process(void *arg, struct altcp_pcb *pcb, struct pbuf *p) -{ - struct smtp_session* s = (struct smtp_session*)arg; - u16_t response_code = 0; - u16_t tx_buf_len = 0; - enum smtp_session_state next_state; - - if (arg == NULL) { - /* already closed SMTP connection */ - if (p != NULL) { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("Received %d bytes after closing: %s\n", - p->tot_len, smtp_pbuf_str(p))); - pbuf_free(p); - } - return; - } - - next_state = s->state; - - if (p != NULL) { - /* received data */ - if (s->p == NULL) { - s->p = p; - } else { - pbuf_cat(s->p, p); - } - } else { - /* idle timer, close connection if timed out */ - if (s->timer == 0) { - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_process: connection timed out, closing\n")); - smtp_close(s, pcb, SMTP_RESULT_ERR_TIMEOUT, 0, ERR_TIMEOUT); - return; - } - if (s->state == SMTP_BODY) { - smtp_send_body(s, pcb); - return; - } - } - response_code = smtp_is_response(s); - if (response_code) { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process: received response code: %d\n", response_code)); - if (smtp_is_response_finished(s) != ERR_OK) { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process: partly received response code: %d\n", response_code)); - /* wait for next packet to complete the respone */ - return; - } - } else { - if (s->p != NULL) { - LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_process: unknown data received (%s)\n", - smtp_pbuf_str(s->p))); - pbuf_free(s->p); - s->p = NULL; - } - return; - } - - switch(s->state) - { - case(SMTP_NULL): - /* wait for 220 */ - if (response_code == 220) { - /* then send EHLO */ - next_state = smtp_prepare_helo(s, &tx_buf_len, pcb); - } - break; - case(SMTP_HELO): - /* wait for 250 */ - if (response_code == 250) { -#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN - /* then send AUTH or MAIL */ - next_state = smtp_prepare_auth_or_mail(s, &tx_buf_len); - } - break; - case(SMTP_AUTH_LOGIN): - case(SMTP_AUTH_PLAIN): - /* wait for 235 */ - if (response_code == 235) { -#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ - /* send MAIL */ - next_state = smtp_prepare_mail(s, &tx_buf_len); - } - break; -#if SMTP_SUPPORT_AUTH_LOGIN - case(SMTP_AUTH_LOGIN_UNAME): - /* wait for 334 Username */ - if (response_code == 334) { - if (pbuf_strstr(s->p, SMTP_RESP_LOGIN_UNAME) != 0xFFFF) { - /* send username */ - next_state = smtp_prepare_auth_login_uname(s, &tx_buf_len); - } - } - break; - case(SMTP_AUTH_LOGIN_PASS): - /* wait for 334 Password */ - if (response_code == 334) { - if (pbuf_strstr(s->p, SMTP_RESP_LOGIN_PASS) != 0xFFFF) { - /* send username */ - next_state = smtp_prepare_auth_login_pass(s, &tx_buf_len); - } - } - break; -#endif /* SMTP_SUPPORT_AUTH_LOGIN */ - case(SMTP_MAIL): - /* wait for 250 */ - if (response_code == 250) { - /* send RCPT */ - next_state = smtp_prepare_rcpt(s, &tx_buf_len); - } - break; - case(SMTP_RCPT): - /* wait for 250 */ - if (response_code == 250) { - /* send DATA */ - SMEMCPY(s->tx_buf, SMTP_CMD_DATA, SMTP_CMD_DATA_LEN); - tx_buf_len = SMTP_CMD_DATA_LEN; - next_state = SMTP_DATA; - } - break; - case(SMTP_DATA): - /* wait for 354 */ - if (response_code == 354) { - /* send email header */ - next_state = smtp_prepare_header(s, &tx_buf_len); - } - break; - case(SMTP_BODY): - /* nothing to be done here, handled somewhere else */ - break; - case(SMTP_QUIT): - /* wait for 250 */ - if (response_code == 250) { - /* send QUIT */ - next_state = smtp_prepare_quit(s, &tx_buf_len); - } - break; - case(SMTP_CLOSED): - /* nothing to do, wait for connection closed from server */ - return; - default: - LWIP_DEBUGF(SMTP_DEBUG_SERIOUS, ("Invalid state: %d/%s\n", (int)s->state, - smtp_state_str[s->state])); - break; - } - if (s->state == next_state) { - LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_process[%s]: unexpected response_code, closing: %d (%s)\n", - smtp_state_str[s->state], response_code, smtp_pbuf_str(s->p))); - /* close connection */ - smtp_close(s, pcb, SMTP_RESULT_ERR_SVR_RESP, response_code, ERR_OK); - return; - } - if (tx_buf_len > 0) { - SMTP_TX_BUF_MAX(tx_buf_len); - if (altcp_write(pcb, s->tx_buf, tx_buf_len, TCP_WRITE_FLAG_COPY) == ERR_OK) { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process[%s]: received command %d (%s)\n", - smtp_state_str[s->state], response_code, smtp_pbuf_str(s->p))); - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process[%s]: sent %"U16_F" bytes: \"%s\"\n", - smtp_state_str[s->state], tx_buf_len, s->tx_buf)); - s->timer = SMTP_TIMEOUT; - pbuf_free(s->p); - s->p = NULL; - LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_process: changing state from %s to %s\n", - smtp_state_str[s->state], smtp_state_str[next_state])); - s->state = next_state; - if (next_state == SMTP_BODY) { - /* try to stream-send body data right now */ - smtp_send_body(s, pcb); - } else if (next_state == SMTP_CLOSED) { - /* sent out all data, delete structure */ - altcp_arg(pcb, NULL); - smtp_free(s, SMTP_RESULT_OK, 0, ERR_OK); - } - } - } -} - -#if SMTP_BODYDH -/** Elementary sub-function to send data - * - * @returns: BDHALLDATASENT all data has been written - * BDHSOMEDATASENT some data has been written - * 0 no data has been written - */ -static int -smtp_send_bodyh_data(struct altcp_pcb *pcb, const char **from, u16_t *howmany) -{ - err_t err; - u16_t len = *howmany; - - len = (u16_t)LWIP_MIN(len, altcp_sndbuf(pcb)); - err = altcp_write(pcb, *from, len, TCP_WRITE_FLAG_COPY); - if (err == ERR_OK) { - *from += len; - if ((*howmany -= len) > 0) { - return BDHSOMEDATASENT; - } - return BDHALLDATASENT; - } - return 0; -} - -/** Same as smtp_send_mail_static, but uses a callback function to send body data - */ -err_t -smtp_send_mail_bodycback(const char *from, const char* to, const char* subject, - smtp_bodycback_fn bodycback_fn, smtp_result_fn callback_fn, void* callback_arg) -{ - struct smtp_session* s; - size_t len; - - LWIP_ASSERT_CORE_LOCKED(); - - s = (struct smtp_session*)SMTP_STATE_MALLOC(sizeof(struct smtp_session)); - if (s == NULL) { - return ERR_MEM; - } - memset(s, 0, sizeof(struct smtp_session)); - s->bodydh = (struct smtp_bodydh_state*)SMTP_BODYDH_MALLOC(sizeof(struct smtp_bodydh_state)); - if (s->bodydh == NULL) { - SMTP_STATE_FREE(s); - return ERR_MEM; - } - memset(s->bodydh, 0, sizeof(struct smtp_bodydh_state)); - /* initialize the structure */ - s->from = from; - len = strlen(from); - LWIP_ASSERT("string is too long", len <= 0xffff); - s->from_len = (u16_t)len; - s->to = to; - len = strlen(to); - LWIP_ASSERT("string is too long", len <= 0xffff); - s->to_len = (u16_t)len; - s->subject = subject; - len = strlen(subject); - LWIP_ASSERT("string is too long", len <= 0xffff); - s->subject_len = (u16_t)len; - s->body = NULL; - LWIP_ASSERT("string is too long", len <= 0xffff); - s->callback_fn = callback_fn; - s->callback_arg = callback_arg; - s->bodydh->callback_fn = bodycback_fn; - s->bodydh->state = BDH_SENDING; - /* call the actual implementation of this function */ - return smtp_send_mail_alloced(s); -} - -static void -smtp_send_body_data_handler(struct smtp_session *s, struct altcp_pcb *pcb) -{ - struct smtp_bodydh_state *bdh; - int res = 0, ret; - LWIP_ASSERT("s != NULL", s != NULL); - bdh = s->bodydh; - LWIP_ASSERT("bodydh != NULL", bdh != NULL); - - /* resume any leftovers from prior memory constraints */ - if (s->body_len) { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: resume\n")); - if((res = smtp_send_bodyh_data(pcb, (const char **)&s->body, &s->body_len)) - != BDHALLDATASENT) { - s->body_sent = s->body_len - 1; - return; - } - } - ret = res; - /* all data on buffer has been queued, resume execution */ - if (bdh->state == BDH_SENDING) { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: run\n")); - do { - ret |= res; /* remember if we once queued something to send */ - bdh->exposed.length = 0; - if (bdh->callback_fn(s->callback_arg, &bdh->exposed) == BDH_DONE) { - bdh->state = BDH_STOP; - } - s->body = bdh->exposed.buffer; - s->body_len = bdh->exposed.length; - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: trying to send %u bytes\n", (unsigned int)s->body_len)); - } while (s->body_len && - ((res = smtp_send_bodyh_data(pcb, (const char **)&s->body, &s->body_len)) == BDHALLDATASENT) - && (bdh->state != BDH_STOP)); - } - if ((bdh->state != BDH_SENDING) && (ret != BDHSOMEDATASENT)) { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: stop\n")); - s->body_sent = s->body_len; - } else { - LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: pause\n")); - s->body_sent = s->body_len - 1; - } -} -#endif /* SMTP_BODYDH */ - -#endif /* LWIP_TCP && LWIP_CALLBACK_API */ +/** + * @file + * SMTP client module + * + * Author: Simon Goldschmidt + * + * @defgroup smtp SMTP client + * @ingroup apps + * + * This is simple SMTP client for raw API. + * It is a minimal implementation of SMTP as specified in RFC 5321. + * + * Example usage: +@code{.c} + void my_smtp_result_fn(void *arg, u8_t smtp_result, u16_t srv_err, err_t err) + { + printf("mail (%p) sent with results: 0x%02x, 0x%04x, 0x%08x\n", arg, + smtp_result, srv_err, err); + } + static void my_smtp_test(void) + { + smtp_set_server_addr("mymailserver.org"); + -> set both username and password as NULL if no auth needed + smtp_set_auth("username", "password"); + smtp_send_mail("sender", "recipient", "subject", "body", my_smtp_result_fn, + some_argument); + } +@endcode + + * When using from any other thread than the tcpip_thread (for NO_SYS==0), use + * smtp_send_mail_int()! + * + * SMTP_BODYDH usage: +@code{.c} + int my_smtp_bodydh_fn(void *arg, struct smtp_bodydh *bdh) + { + if(bdh->state >= 10) { + return BDH_DONE; + } + sprintf(bdh->buffer,"Line #%2d\r\n",bdh->state); + bdh->length = strlen(bdh->buffer); + ++bdh->state; + return BDH_WORKING; + } + + smtp_send_mail_bodycback("sender", "recipient", "subject", + my_smtp_bodydh_fn, my_smtp_result_fn, some_argument); +@endcode + * + * @todo: + * - attachments (the main difficulty here is streaming base64-encoding to + * prevent having to allocate a buffer for the whole encoded file at once) + * - test with more mail servers... + * + */ + +#include "lwip/apps/smtp.h" + +#if LWIP_TCP && LWIP_CALLBACK_API +#include "lwip/sys.h" +#include "lwip/sockets.h" +#include "lwip/altcp.h" +#include "lwip/dns.h" +#include "lwip/mem.h" +#include "lwip/altcp_tcp.h" +#include "lwip/altcp_tls.h" + +#include /* strlen, memcpy */ +#include + +/** TCP poll interval. Unit is 0.5 sec. */ +#define SMTP_POLL_INTERVAL 4 +/** TCP poll timeout while sending message body, reset after every + * successful write. 3 minutes */ +#define SMTP_TIMEOUT_DATABLOCK ( 3 * 60 * SMTP_POLL_INTERVAL / 2) +/** TCP poll timeout while waiting for confirmation after sending the body. + * 10 minutes */ +#define SMTP_TIMEOUT_DATATERM (10 * 60 * SMTP_POLL_INTERVAL / 2) +/** TCP poll timeout while not sending the body. + * This is somewhat lower than the RFC states (5 minutes for initial, MAIL + * and RCPT) but still OK for us here. + * 2 minutes */ +#define SMTP_TIMEOUT ( 2 * 60 * SMTP_POLL_INTERVAL / 2) + +/* the various debug levels for this file */ +#define SMTP_DEBUG_TRACE (SMTP_DEBUG | LWIP_DBG_TRACE) +#define SMTP_DEBUG_STATE (SMTP_DEBUG | LWIP_DBG_STATE) +#define SMTP_DEBUG_WARN (SMTP_DEBUG | LWIP_DBG_LEVEL_WARNING) +#define SMTP_DEBUG_WARN_STATE (SMTP_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) +#define SMTP_DEBUG_SERIOUS (SMTP_DEBUG | LWIP_DBG_LEVEL_SERIOUS) + + +#define SMTP_RX_BUF_LEN 255 +#define SMTP_TX_BUF_LEN 255 +#define SMTP_CRLF "\r\n" +#define SMTP_CRLF_LEN 2 + +#define SMTP_RESP_220 "220" +#define SMTP_RESP_235 "235" +#define SMTP_RESP_250 "250" +#define SMTP_RESP_334 "334" +#define SMTP_RESP_354 "354" +#define SMTP_RESP_LOGIN_UNAME "VXNlcm5hbWU6" +#define SMTP_RESP_LOGIN_PASS "UGFzc3dvcmQ6" + +#define SMTP_KEYWORD_AUTH_SP "AUTH " +#define SMTP_KEYWORD_AUTH_EQ "AUTH=" +#define SMTP_KEYWORD_AUTH_LEN 5 +#define SMTP_AUTH_PARAM_PLAIN "PLAIN" +#define SMTP_AUTH_PARAM_LOGIN "LOGIN" + +#define SMTP_CMD_EHLO_1 "EHLO [" +#define SMTP_CMD_EHLO_1_LEN 6 +#define SMTP_CMD_EHLO_2 "]\r\n" +#define SMTP_CMD_EHLO_2_LEN 3 +#define SMTP_CMD_AUTHPLAIN_1 "AUTH PLAIN " +#define SMTP_CMD_AUTHPLAIN_1_LEN 11 +#define SMTP_CMD_AUTHPLAIN_2 "\r\n" +#define SMTP_CMD_AUTHPLAIN_2_LEN 2 +#define SMTP_CMD_AUTHLOGIN "AUTH LOGIN\r\n" +#define SMTP_CMD_AUTHLOGIN_LEN 12 +#define SMTP_CMD_MAIL_1 "MAIL FROM: <" +#define SMTP_CMD_MAIL_1_LEN 12 +#define SMTP_CMD_MAIL_2 ">\r\n" +#define SMTP_CMD_MAIL_2_LEN 3 +#define SMTP_CMD_RCPT_1 "RCPT TO: <" +#define SMTP_CMD_RCPT_1_LEN 10 +#define SMTP_CMD_RCPT_2 ">\r\n" +#define SMTP_CMD_RCPT_2_LEN 3 +#define SMTP_CMD_DATA "DATA\r\n" +#define SMTP_CMD_DATA_LEN 6 +#define SMTP_CMD_HEADER_1 "From: <" +#define SMTP_CMD_HEADER_1_LEN 7 +#define SMTP_CMD_HEADER_2 ">\r\nTo: <" +#define SMTP_CMD_HEADER_2_LEN 8 +#define SMTP_CMD_HEADER_3 ">\r\nSubject: " +#define SMTP_CMD_HEADER_3_LEN 12 +#define SMTP_CMD_HEADER_4 "\r\n\r\n" +#define SMTP_CMD_HEADER_4_LEN 4 +#define SMTP_CMD_BODY_FINISHED "\r\n.\r\n" +#define SMTP_CMD_BODY_FINISHED_LEN 5 +#define SMTP_CMD_QUIT "QUIT\r\n" +#define SMTP_CMD_QUIT_LEN 6 + +#if defined(SMTP_STAT_TX_BUF_MAX) && SMTP_STAT_TX_BUF_MAX +#define SMTP_TX_BUF_MAX(len) LWIP_MACRO(if((len) > smtp_tx_buf_len_max) smtp_tx_buf_len_max = (len);) +#else /* SMTP_STAT_TX_BUF_MAX */ +#define SMTP_TX_BUF_MAX(len) +#endif /* SMTP_STAT_TX_BUF_MAX */ + +#if SMTP_COPY_AUTHDATA +#define SMTP_USERNAME(session) (session)->username +#define SMTP_PASS(session) (session)->pass +#define SMTP_AUTH_PLAIN_DATA(session) (session)->auth_plain +#define SMTP_AUTH_PLAIN_LEN(session) (session)->auth_plain_len +#else /* SMTP_COPY_AUTHDATA */ +#define SMTP_USERNAME(session) smtp_username +#define SMTP_PASS(session) smtp_pass +#define SMTP_AUTH_PLAIN_DATA(session) smtp_auth_plain +#define SMTP_AUTH_PLAIN_LEN(session) smtp_auth_plain_len +#endif /* SMTP_COPY_AUTHDATA */ + +#if SMTP_BODYDH +#ifndef SMTP_BODYDH_MALLOC +#define SMTP_BODYDH_MALLOC(size) mem_malloc(size) +#define SMTP_BODYDH_FREE(ptr) mem_free(ptr) +#endif + +/* Some internal state return values */ +#define BDHALLDATASENT 2 +#define BDHSOMEDATASENT 1 + +enum bdh_handler_state { + BDH_SENDING, /* Serving the user function generating body content */ + BDH_STOP /* User function stopped, closing */ +}; +#endif + +/** State for SMTP client state machine */ +enum smtp_session_state { + SMTP_NULL, + SMTP_HELO, + SMTP_AUTH_PLAIN, + SMTP_AUTH_LOGIN_UNAME, + SMTP_AUTH_LOGIN_PASS, + SMTP_AUTH_LOGIN, + SMTP_MAIL, + SMTP_RCPT, + SMTP_DATA, + SMTP_BODY, + SMTP_QUIT, + SMTP_CLOSED +}; + +#ifdef LWIP_DEBUG +/** State-to-string table for debugging */ +static const char *smtp_state_str[] = { + "SMTP_NULL", + "SMTP_HELO", + "SMTP_AUTH_PLAIN", + "SMTP_AUTH_LOGIN_UNAME", + "SMTP_AUTH_LOGIN_PASS", + "SMTP_AUTH_LOGIN", + "SMTP_MAIL", + "SMTP_RCPT", + "SMTP_DATA", + "SMTP_BODY", + "SMTP_QUIT", + "SMTP_CLOSED", +}; + +static const char *smtp_result_strs[] = { + "SMTP_RESULT_OK", + "SMTP_RESULT_ERR_UNKNOWN", + "SMTP_RESULT_ERR_CONNECT", + "SMTP_RESULT_ERR_HOSTNAME", + "SMTP_RESULT_ERR_CLOSED", + "SMTP_RESULT_ERR_TIMEOUT", + "SMTP_RESULT_ERR_SVR_RESP", + "SMTP_RESULT_ERR_MEM" +}; +#endif /* LWIP_DEBUG */ + +#if SMTP_BODYDH +struct smtp_bodydh_state { + smtp_bodycback_fn callback_fn; /* The function to call (again) */ + u16_t state; + struct smtp_bodydh exposed; /* the user function structure */ +}; +#endif /* SMTP_BODYDH */ + +/** struct keeping the body and state of an smtp session */ +struct smtp_session { + /** keeping the state of the smtp session */ + enum smtp_session_state state; + /** timeout handling, if this reaches 0, the connection is closed */ + u16_t timer; + /** helper buffer for transmit, not used for sending body */ + char tx_buf[SMTP_TX_BUF_LEN + 1]; + struct pbuf* p; + /** source email address */ + const char* from; + /** size of the sourceemail address */ + u16_t from_len; + /** target email address */ + const char* to; + /** size of the target email address */ + u16_t to_len; + /** subject of the email */ + const char *subject; + /** length of the subject string */ + u16_t subject_len; + /** this is the body of the mail to be sent */ + const char* body; + /** this is the length of the body to be sent */ + u16_t body_len; + /** amount of data from body already sent */ + u16_t body_sent; + /** callback function to call when closed */ + smtp_result_fn callback_fn; + /** argument for callback function */ + void *callback_arg; +#if SMTP_COPY_AUTHDATA + /** Username to use for this request */ + char *username; + /** Password to use for this request */ + char *pass; + /** Username and password combined as necessary for PLAIN authentication */ + char auth_plain[SMTP_MAX_USERNAME_LEN + SMTP_MAX_PASS_LEN + 3]; + /** Length of smtp_auth_plain string (cannot use strlen since it includes \0) */ + size_t auth_plain_len; +#endif /* SMTP_COPY_AUTHDATA */ +#if SMTP_BODYDH + struct smtp_bodydh_state *bodydh; +#endif /* SMTP_BODYDH */ +}; + +/** IP address or DNS name of the server to use for next SMTP request */ +static char smtp_server[SMTP_MAX_SERVERNAME_LEN + 1]; +/** TCP port of the server to use for next SMTP request */ +static u16_t smtp_server_port = SMTP_DEFAULT_PORT; +#if LWIP_ALTCP && LWIP_ALTCP_TLS +/** If this is set, mail is sent using SMTPS */ +static struct altcp_tls_config *smtp_server_tls_config; +#endif +/** Username to use for the next SMTP request */ +static char *smtp_username; +/** Password to use for the next SMTP request */ +static char *smtp_pass; +/** Username and password combined as necessary for PLAIN authentication */ +static char smtp_auth_plain[SMTP_MAX_USERNAME_LEN + SMTP_MAX_PASS_LEN + 3]; +/** Length of smtp_auth_plain string (cannot use strlen since it includes \0) */ +static size_t smtp_auth_plain_len; + +#if SMTP_CHECK_DATA +static err_t smtp_verify(const char *data, size_t data_len, u8_t linebreaks_allowed); +#endif /* SMTP_CHECK_DATA */ +static err_t smtp_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err); +static void smtp_tcp_err(void *arg, err_t err); +static err_t smtp_tcp_poll(void *arg, struct altcp_pcb *pcb); +static err_t smtp_tcp_sent(void *arg, struct altcp_pcb *pcb, u16_t len); +static err_t smtp_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err); +#if LWIP_DNS +static void smtp_dns_found(const char* hostname, const ip_addr_t *ipaddr, void *arg); +#endif /* LWIP_DNS */ +#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN +static size_t smtp_base64_encode(char* target, size_t target_len, const char* source, size_t source_len); +#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ +static enum smtp_session_state smtp_prepare_mail(struct smtp_session *s, u16_t *tx_buf_len); +static void smtp_send_body(struct smtp_session *s, struct altcp_pcb *pcb); +static void smtp_process(void *arg, struct altcp_pcb *pcb, struct pbuf *p); +#if SMTP_BODYDH +static void smtp_send_body_data_handler(struct smtp_session *s, struct altcp_pcb *pcb); +#endif /* SMTP_BODYDH */ + + +#ifdef LWIP_DEBUG +/** Convert an smtp result to a string */ +const char* +smtp_result_str(u8_t smtp_result) +{ + if (smtp_result >= LWIP_ARRAYSIZE(smtp_result_strs)) { + return "UNKNOWN"; + } + return smtp_result_strs[smtp_result]; +} + +/** Null-terminates the payload of p for printing out messages. + * WARNING: use this only if p is not needed any more as the last byte of + * payload is deleted! + */ +static const char* +smtp_pbuf_str(struct pbuf* p) +{ + if ((p == NULL) || (p->len == 0)) { + return ""; + } + ((char*)p->payload)[p->len] = 0; + return (const char*)p->payload; +} +#endif /* LWIP_DEBUG */ + +/** @ingroup smtp + * Set IP address or DNS name for next SMTP connection + * + * @param server IP address (in ASCII representation) or DNS name of the server + */ +err_t +smtp_set_server_addr(const char* server) +{ + size_t len = 0; + + LWIP_ASSERT_CORE_LOCKED(); + + if (server != NULL) { + /* strlen: returns length WITHOUT terminating 0 byte */ + len = strlen(server); + } + if (len > SMTP_MAX_SERVERNAME_LEN) { + return ERR_MEM; + } + if (len != 0) { + MEMCPY(smtp_server, server, len); + } + smtp_server[len] = 0; /* always OK because of smtp_server[SMTP_MAX_SERVERNAME_LEN + 1] */ + return ERR_OK; +} + +/** @ingroup smtp + * Set TCP port for next SMTP connection + * + * @param port TCP port + */ +void +smtp_set_server_port(u16_t port) +{ + LWIP_ASSERT_CORE_LOCKED(); + smtp_server_port = port; +} + +#if LWIP_ALTCP && LWIP_ALTCP_TLS +/** @ingroup smtp + * Set TLS configuration for next SMTP connection + * + * @param tls_config TLS configuration + */ +void +smtp_set_tls_config(struct altcp_tls_config *tls_config) +{ + LWIP_ASSERT_CORE_LOCKED(); + smtp_server_tls_config = tls_config; +} +#endif + +/** @ingroup smtp + * Set authentication parameters for next SMTP connection + * + * @param username login name as passed to the server + * @param pass password passed to the server together with username + */ +err_t +smtp_set_auth(const char* username, const char* pass) +{ + size_t uname_len = 0; + size_t pass_len = 0; + + LWIP_ASSERT_CORE_LOCKED(); + + memset(smtp_auth_plain, 0xfa, 64); + if (username != NULL) { + uname_len = strlen(username); + if (uname_len > SMTP_MAX_USERNAME_LEN) { + LWIP_DEBUGF(SMTP_DEBUG_SERIOUS, ("Username is too long, %d instead of %d\n", + (int)uname_len, SMTP_MAX_USERNAME_LEN)); + return ERR_ARG; + } + } + if (pass != NULL) { +#if SMTP_SUPPORT_AUTH_LOGIN || SMTP_SUPPORT_AUTH_PLAIN + pass_len = strlen(pass); + if (pass_len > SMTP_MAX_PASS_LEN) { + LWIP_DEBUGF(SMTP_DEBUG_SERIOUS, ("Password is too long, %d instead of %d\n", + (int)uname_len, SMTP_MAX_USERNAME_LEN)); + return ERR_ARG; + } +#else /* SMTP_SUPPORT_AUTH_LOGIN || SMTP_SUPPORT_AUTH_PLAIN */ + LWIP_DEBUGF(SMTP_DEBUG_WARN, ("Password not supported as no authentication methods are activated\n")); +#endif /* SMTP_SUPPORT_AUTH_LOGIN || SMTP_SUPPORT_AUTH_PLAIN */ + } + *smtp_auth_plain = 0; + if (username != NULL) { + smtp_username = smtp_auth_plain + 1; + strcpy(smtp_username, username); + } + if (pass != NULL) { + smtp_pass = smtp_auth_plain + uname_len + 2; + strcpy(smtp_pass, pass); + } + smtp_auth_plain_len = uname_len + pass_len + 2; + + return ERR_OK; +} + +#if SMTP_BODYDH +static void smtp_free_struct(struct smtp_session *s) +{ + if (s->bodydh != NULL) { + SMTP_BODYDH_FREE(s->bodydh); + } + SMTP_STATE_FREE(s); +} +#else /* SMTP_BODYDH */ +#define smtp_free_struct(x) SMTP_STATE_FREE(x) +#endif /* SMTP_BODYDH */ + +static struct altcp_pcb* +smtp_setup_pcb(struct smtp_session *s, const ip_addr_t* remote_ip) +{ + struct altcp_pcb* pcb; + LWIP_UNUSED_ARG(remote_ip); + +#if LWIP_ALTCP && LWIP_ALTCP_TLS + if (smtp_server_tls_config) { + pcb = altcp_tls_new(smtp_server_tls_config, IP_GET_TYPE(remote_ip)); + } else +#endif + { + pcb = altcp_tcp_new_ip_type(IP_GET_TYPE(remote_ip)); + } + if (pcb != NULL) { + altcp_arg(pcb, s); + altcp_recv(pcb, smtp_tcp_recv); + altcp_err(pcb, smtp_tcp_err); + altcp_poll(pcb, smtp_tcp_poll, SMTP_POLL_INTERVAL); + altcp_sent(pcb, smtp_tcp_sent); + } + return pcb; +} + +/** The actual mail-sending function, called by smtp_send_mail and + * smtp_send_mail_static after setting up the struct smtp_session. + */ +static err_t +smtp_send_mail_alloced(struct smtp_session *s) +{ + err_t err; + struct altcp_pcb* pcb = NULL; + ip_addr_t addr; + + LWIP_ASSERT("no smtp_session supplied", s != NULL); + +#if SMTP_CHECK_DATA + /* check that body conforms to RFC: + * - convert all single-CR or -LF in body to CRLF + * - only 7-bit ASCII is allowed + */ + if (smtp_verify(s->to, s->to_len, 0) != ERR_OK) { + err = ERR_ARG; + goto leave; + } + if (smtp_verify(s->from, s->from_len, 0) != ERR_OK) { + err = ERR_ARG; + goto leave; + } + if (smtp_verify(s->subject, s->subject_len, 0) != ERR_OK) { + err = ERR_ARG; + goto leave; + } +#if SMTP_BODYDH + if (s->bodydh == NULL) +#endif /* SMTP_BODYDH */ + { + if (smtp_verify(s->body, s->body_len, 0) != ERR_OK) { + err = ERR_ARG; + goto leave; + } + } +#endif /* SMTP_CHECK_DATA */ + +#if SMTP_COPY_AUTHDATA + /* copy auth data, ensuring the first byte is always zero */ + MEMCPY(s->auth_plain + 1, smtp_auth_plain + 1, smtp_auth_plain_len - 1); + s->auth_plain_len = smtp_auth_plain_len; + /* default username and pass is empty string */ + s->username = s->auth_plain; + s->pass = s->auth_plain; + if (smtp_username != NULL) { + s->username += smtp_username - smtp_auth_plain; + } + if (smtp_pass != NULL) { + s->pass += smtp_pass - smtp_auth_plain; + } +#endif /* SMTP_COPY_AUTHDATA */ + + s->state = SMTP_NULL; + s->timer = SMTP_TIMEOUT; + +#if LWIP_DNS + err = dns_gethostbyname(smtp_server, &addr, smtp_dns_found, s); +#else /* LWIP_DNS */ + err = ipaddr_aton(smtp_server, &addr) ? ERR_OK : ERR_ARG; +#endif /* LWIP_DNS */ + if (err == ERR_OK) { + pcb = smtp_setup_pcb(s, &addr); + if (pcb == NULL) { + err = ERR_MEM; + goto leave; + } + err = altcp_connect(pcb, &addr, smtp_server_port, smtp_tcp_connected); + if (err != ERR_OK) { + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("tcp_connect failed: %d\n", (int)err)); + goto deallocate_and_leave; + } + } else if (err != ERR_INPROGRESS) { + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("dns_gethostbyname failed: %d\n", (int)err)); + goto deallocate_and_leave; + } + return ERR_OK; + +deallocate_and_leave: + if (pcb != NULL) { + altcp_arg(pcb, NULL); + altcp_close(pcb); + } +leave: + smtp_free_struct(s); + /* no need to call the callback here since we return != ERR_OK */ + return err; +} + +/** @ingroup smtp + * Send an email via the currently selected server, username and password. + * + * @param from source email address (must be NULL-terminated) + * @param to target email address (must be NULL-terminated) + * @param subject email subject (must be NULL-terminated) + * @param body email body (must be NULL-terminated) + * @param callback_fn callback function + * @param callback_arg user argument to callback_fn + * @returns - ERR_OK if structures were allocated and no error occured starting the connection + * (this does not mean the email has been successfully sent!) + * - another err_t on error. + */ +err_t +smtp_send_mail(const char* from, const char* to, const char* subject, const char* body, + smtp_result_fn callback_fn, void* callback_arg) +{ + struct smtp_session* s; + size_t from_len = strlen(from); + size_t to_len = strlen(to); + size_t subject_len = strlen(subject); + size_t body_len = strlen(body); + size_t mem_len = sizeof(struct smtp_session); + char *sfrom, *sto, *ssubject, *sbody; + + LWIP_ASSERT_CORE_LOCKED(); + + mem_len += from_len + to_len + subject_len + body_len + 4; + if (mem_len > 0xffff) { + /* too long! */ + return ERR_MEM; + } + + /* Allocate memory to keep this email's session state */ + s = (struct smtp_session *)SMTP_STATE_MALLOC((mem_size_t)mem_len); + if (s == NULL) { + return ERR_MEM; + } + /* initialize the structure */ + memset(s, 0, mem_len); + s->from = sfrom = (char*)s + sizeof(struct smtp_session); + s->from_len = (u16_t)from_len; + s->to = sto = sfrom + from_len + 1; + s->to_len = (u16_t)to_len; + s->subject = ssubject = sto + to_len + 1; + s->subject_len = (u16_t)subject_len; + s->body = sbody = ssubject + subject_len + 1; + s->body_len = (u16_t)body_len; + /* copy source and target email address */ + /* cast to size_t is a hack to cast away constness */ + MEMCPY(sfrom, from, from_len + 1); + MEMCPY(sto, to, to_len + 1); + MEMCPY(ssubject, subject, subject_len + 1); + MEMCPY(sbody, body, body_len + 1); + + s->callback_fn = callback_fn; + s->callback_arg = callback_arg; + + /* call the actual implementation of this function */ + return smtp_send_mail_alloced(s); +} + +/** @ingroup smtp + * Same as smtp_send_mail, but doesn't copy from, to, subject and body into + * an internal buffer to save memory. + * WARNING: the above data must stay untouched until the callback function is + * called (unless the function returns != ERR_OK) + */ +err_t +smtp_send_mail_static(const char *from, const char* to, const char* subject, + const char* body, smtp_result_fn callback_fn, void* callback_arg) +{ + struct smtp_session* s; + size_t len; + + LWIP_ASSERT_CORE_LOCKED(); + + s = (struct smtp_session*)SMTP_STATE_MALLOC(sizeof(struct smtp_session)); + if (s == NULL) { + return ERR_MEM; + } + memset(s, 0, sizeof(struct smtp_session)); + /* initialize the structure */ + s->from = from; + len = strlen(from); + LWIP_ASSERT("string is too long", len <= 0xffff); + s->from_len = (u16_t)len; + s->to = to; + len = strlen(to); + LWIP_ASSERT("string is too long", len <= 0xffff); + s->to_len = (u16_t)len; + s->subject = subject; + len = strlen(subject); + LWIP_ASSERT("string is too long", len <= 0xffff); + s->subject_len = (u16_t)len; + s->body = body; + len = strlen(body); + LWIP_ASSERT("string is too long", len <= 0xffff); + s->body_len = (u16_t)len; + s->callback_fn = callback_fn; + s->callback_arg = callback_arg; + /* call the actual implementation of this function */ + return smtp_send_mail_alloced(s); +} + + +/** @ingroup smtp + * Same as smtp_send_mail but takes a struct smtp_send_request as single + * parameter which contains all the other parameters. + * To be used with tcpip_callback to send mail from interrupt context or from + * another thread. + * + * WARNING: server and authentication must stay untouched until this function has run! + * + * Usage example: + * - allocate a struct smtp_send_request (in a way that is allowed in interrupt context) + * - fill the members of the struct as if calling smtp_send_mail + * - specify a callback_function + * - set callback_arg to the structure itself + * - call this function + * - wait for the callback function to be called + * - in the callback function, deallocate the structure (passed as arg) + */ +void +smtp_send_mail_int(void *arg) +{ + struct smtp_send_request *req = (struct smtp_send_request*)arg; + err_t err; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("smtp_send_mail_int: no argument given", arg != NULL); + + if (req->static_data) { + err = smtp_send_mail_static(req->from, req->to, req->subject, req->body, + req->callback_fn, req->callback_arg); + } else { + err = smtp_send_mail(req->from, req->to, req->subject, req->body, + req->callback_fn, req->callback_arg); + } + if ((err != ERR_OK) && (req->callback_fn != NULL)) { + req->callback_fn(req->callback_arg, SMTP_RESULT_ERR_UNKNOWN, 0, err); + } +} + +#if SMTP_CHECK_DATA +/** Verify that a given string conforms to the SMTP rules + * (7-bit only, no single CR or LF, + * @todo: no line consisting of a single dot only) + */ +static err_t +smtp_verify(const char *data, size_t data_len, u8_t linebreaks_allowed) +{ + size_t i; + u8_t last_was_cr = 0; + for (i = 0; i < data_len; i++) { + char current = data[i]; + if ((current & 0x80) != 0) { + LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: no 8-bit data supported: %s\n", data)); + return ERR_ARG; + } + if (current == '\r') { + if (!linebreaks_allowed) { + LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: found CR where no linebreaks allowed: %s\n", data)); + return ERR_ARG; + } + if (last_was_cr) { + LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: found double CR: %s\n", data)); + return ERR_ARG; + } + last_was_cr = 1; + } else { + if (current == '\n') { + if (!last_was_cr) { + LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_verify: found LF without CR before: %s\n", data)); + return ERR_ARG; + } + } + last_was_cr = 0; + } + } + return ERR_OK; +} +#endif /* SMTP_CHECK_DATA */ + +/** Frees the smtp_session and calls the callback function */ +static void +smtp_free(struct smtp_session *s, u8_t result, u16_t srv_err, err_t err) +{ + smtp_result_fn fn = s->callback_fn; + void *arg = s->callback_arg; + if (s->p != NULL) { + pbuf_free(s->p); + } + smtp_free_struct(s); + if (fn != NULL) { + fn(arg, result, srv_err, err); + } +} + +/** Try to close a pcb and free the arg if successful */ +static void +smtp_close(struct smtp_session *s, struct altcp_pcb *pcb, u8_t result, + u16_t srv_err, err_t err) +{ + if (pcb != NULL) { + altcp_arg(pcb, NULL); + if (altcp_close(pcb) == ERR_OK) { + if (s != NULL) { + smtp_free(s, result, srv_err, err); + } + } else { + /* close failed, set back arg */ + altcp_arg(pcb, s); + } + } else { + if (s != NULL) { + smtp_free(s, result, srv_err, err); + } + } +} + +/** Raw API TCP err callback: pcb is already deallocated */ +static void +smtp_tcp_err(void *arg, err_t err) +{ + LWIP_UNUSED_ARG(err); + if (arg != NULL) { + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_tcp_err: connection reset by remote host\n")); + smtp_free((struct smtp_session*)arg, SMTP_RESULT_ERR_CLOSED, 0, err); + } +} + +/** Raw API TCP poll callback */ +static err_t +smtp_tcp_poll(void *arg, struct altcp_pcb *pcb) +{ + if (arg != NULL) { + struct smtp_session *s = (struct smtp_session*)arg; + if (s->timer != 0) { + s->timer--; + } + } + smtp_process(arg, pcb, NULL); + return ERR_OK; +} + +/** Raw API TCP sent callback */ +static err_t +smtp_tcp_sent(void *arg, struct altcp_pcb *pcb, u16_t len) +{ + LWIP_UNUSED_ARG(len); + + smtp_process(arg, pcb, NULL); + + return ERR_OK; +} + +/** Raw API TCP recv callback */ +static err_t +smtp_tcp_recv(void *arg, struct altcp_pcb *pcb, struct pbuf *p, err_t err) +{ + LWIP_UNUSED_ARG(err); + if (p != NULL) { + altcp_recved(pcb, p->tot_len); + smtp_process(arg, pcb, p); + } else { + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_tcp_recv: connection closed by remote host\n")); + smtp_close((struct smtp_session*)arg, pcb, SMTP_RESULT_ERR_CLOSED, 0, err); + } + return ERR_OK; +} + +static err_t +smtp_tcp_connected(void *arg, struct altcp_pcb *pcb, err_t err) +{ + LWIP_UNUSED_ARG(arg); + + if (err == ERR_OK) { + LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_connected: Waiting for 220\n")); + } else { + /* shouldn't happen, but we still check 'err', only to be sure */ + LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_connected: %d\n", (int)err)); + smtp_close((struct smtp_session*)arg, pcb, SMTP_RESULT_ERR_CONNECT, 0, err); + } + return ERR_OK; +} + +#if LWIP_DNS +/** DNS callback + * If ipaddr is non-NULL, resolving succeeded, otherwise it failed. + */ +static void +smtp_dns_found(const char* hostname, const ip_addr_t *ipaddr, void *arg) +{ + struct smtp_session *s = (struct smtp_session*)arg; + struct altcp_pcb *pcb; + err_t err; + u8_t result; + + LWIP_UNUSED_ARG(hostname); + + if (ipaddr != NULL) { + pcb = smtp_setup_pcb(s, ipaddr); + if (pcb != NULL) { + LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_dns_found: hostname resolved, connecting\n")); + err = altcp_connect(pcb, ipaddr, smtp_server_port, smtp_tcp_connected); + if (err == ERR_OK) { + return; + } + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("tcp_connect failed: %d\n", (int)err)); + result = SMTP_RESULT_ERR_CONNECT; + } else { + LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_dns_found: failed to allocate tcp pcb\n")); + result = SMTP_RESULT_ERR_MEM; + err = ERR_MEM; + } + } else { + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_dns_found: failed to resolve hostname: %s\n", + hostname)); + pcb = NULL; + result = SMTP_RESULT_ERR_HOSTNAME; + err = ERR_ARG; + } + smtp_close(s, pcb, result, 0, err); +} +#endif /* LWIP_DNS */ + +#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN + +/** Table 6-bit-index-to-ASCII used for base64-encoding */ +static const char base64_table[] = { + 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', + 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', + 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', + 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', + 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', + 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', + '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', + '+', '/' +}; + +/** Base64 encoding */ +static size_t +smtp_base64_encode(char* target, size_t target_len, const char* source, size_t source_len) +{ + size_t i; + s8_t j; + size_t target_idx = 0; + size_t longer = (source_len % 3) ? (3 - (source_len % 3)) : 0; + size_t source_len_b64 = source_len + longer; + size_t len = (((source_len_b64) * 4) / 3); + u8_t x = 5; + u8_t current = 0; + LWIP_UNUSED_ARG(target_len); + + LWIP_ASSERT("target_len is too short", target_len >= len); + + for (i = 0; i < source_len_b64; i++) { + u8_t b = (i < source_len ? (u8_t)source[i] : 0); + for (j = 7; j >= 0; j--, x--) { + if ((b & (1 << j)) != 0) { + current = (u8_t)(current | (1U << x)); + } + if (x == 0) { + target[target_idx++] = base64_table[current]; + x = 6; + current = 0; + } + } + } + for (i = len - longer; i < len; i++) { + target[i] = '='; + } + return len; +} +#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ + +/** Parse pbuf to see if it contains the beginning of an answer. + * If so, it returns the contained response code as number between 1 and 999. + * If not, zero is returned. + * + * @param s smtp session struct + */ +static u16_t +smtp_is_response(struct smtp_session *s) +{ + char digits[4]; + long num; + + if (s->p == NULL) { + return 0; + } + /* copy three digits and convert them to int */ + if (pbuf_copy_partial(s->p, digits, 3, 0) != 3) { + /* pbuf was too short */ + return 0; + } + digits[3] = 0; + num = strtol(digits, NULL, 10); + if ((num <= 0) || (num >= 1000)) { + /* failed to find response code at start of line */ + return 0; + } + return (u16_t)num; +} + +/** Parse pbuf to see if it contains a fully received answer. + * If one is found, ERR_OK is returned. + * If none is found, ERR_VAL is returned. + * + * A fully received answer is a 3-digit number followed by a space, + * some string and a CRLF as line ending. + * + * @param s smtp session struct + */ +static err_t +smtp_is_response_finished(struct smtp_session *s) +{ + u8_t sp; + u16_t crlf; + u16_t offset; + + if (s->p == NULL) { + return ERR_VAL; + } + offset = 0; +again: + /* We could check the response number here, but we trust the + * protocol definition which says the client can rely on it being + * the same on every line. */ + + /* find CRLF */ + if (offset > 0xFFFF - 4) { + /* would overflow */ + return ERR_VAL; + } + crlf = pbuf_memfind(s->p, SMTP_CRLF, SMTP_CRLF_LEN, (u16_t)(offset + 4)); + if (crlf == 0xFFFF) { + /* no CRLF found */ + return ERR_VAL; + } + sp = pbuf_get_at(s->p, (u16_t)(offset + 3)); + if (sp == '-') { + /* no space after response code -> try next line */ + offset = (u16_t)(crlf + 2); + if (offset < crlf) { + /* overflow */ + return ERR_VAL; + } + goto again; + } else if (sp == ' ') { + /* CRLF found after response code + space -> valid response */ + return ERR_OK; + } + /* sp contains invalid character */ + return ERR_VAL; +} + +/** Prepare HELO/EHLO message */ +static enum smtp_session_state +smtp_prepare_helo(struct smtp_session *s, u16_t *tx_buf_len, struct altcp_pcb *pcb) +{ + size_t ipa_len; + const char *ipa = ipaddr_ntoa(altcp_get_ip(pcb, 1)); + LWIP_ASSERT("ipaddr_ntoa returned NULL", ipa != NULL); + ipa_len = strlen(ipa); + LWIP_ASSERT("string too long", ipa_len <= (SMTP_TX_BUF_LEN-SMTP_CMD_EHLO_1_LEN-SMTP_CMD_EHLO_2_LEN)); + + *tx_buf_len = (u16_t)(SMTP_CMD_EHLO_1_LEN + (u16_t)ipa_len + SMTP_CMD_EHLO_2_LEN); + LWIP_ASSERT("tx_buf overflow detected", *tx_buf_len <= SMTP_TX_BUF_LEN); + + SMEMCPY(s->tx_buf, SMTP_CMD_EHLO_1, SMTP_CMD_EHLO_1_LEN); + MEMCPY(&s->tx_buf[SMTP_CMD_EHLO_1_LEN], ipa, ipa_len); + SMEMCPY(&s->tx_buf[SMTP_CMD_EHLO_1_LEN + ipa_len], SMTP_CMD_EHLO_2, SMTP_CMD_EHLO_2_LEN); + return SMTP_HELO; +} + +#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN +/** Parse last server response (in rx_buf) for supported authentication method, + * create data to send out (to tx_buf), set tx_data_len correctly + * and return the next state. + */ +static enum smtp_session_state +smtp_prepare_auth_or_mail(struct smtp_session *s, u16_t *tx_buf_len) +{ + /* check response for supported authentication method */ + u16_t auth = pbuf_strstr(s->p, SMTP_KEYWORD_AUTH_SP); + if (auth == 0xFFFF) { + auth = pbuf_strstr(s->p, SMTP_KEYWORD_AUTH_EQ); + } + if (auth != 0xFFFF) { + u16_t crlf = pbuf_memfind(s->p, SMTP_CRLF, SMTP_CRLF_LEN, auth); + if ((crlf != 0xFFFF) && (crlf > auth)) { + /* use tx_buf temporarily */ + u16_t copied = pbuf_copy_partial(s->p, s->tx_buf, (u16_t)(crlf - auth), auth); + if (copied != 0) { + char *sep = s->tx_buf + SMTP_KEYWORD_AUTH_LEN; + s->tx_buf[copied] = 0; +#if SMTP_SUPPORT_AUTH_PLAIN + /* favour PLAIN over LOGIN since it involves less requests */ + if (strstr(sep, SMTP_AUTH_PARAM_PLAIN) != NULL) { + size_t auth_len; + /* server supports AUTH PLAIN */ + SMEMCPY(s->tx_buf, SMTP_CMD_AUTHPLAIN_1, SMTP_CMD_AUTHPLAIN_1_LEN); + + /* add base64-encoded string "\0username\0password" */ + auth_len = smtp_base64_encode(&s->tx_buf[SMTP_CMD_AUTHPLAIN_1_LEN], + SMTP_TX_BUF_LEN - SMTP_CMD_AUTHPLAIN_1_LEN, SMTP_AUTH_PLAIN_DATA(s), + SMTP_AUTH_PLAIN_LEN(s)); + LWIP_ASSERT("string too long", auth_len <= (SMTP_TX_BUF_LEN-SMTP_CMD_AUTHPLAIN_1_LEN-SMTP_CMD_AUTHPLAIN_2_LEN)); + *tx_buf_len = (u16_t)(SMTP_CMD_AUTHPLAIN_1_LEN + SMTP_CMD_AUTHPLAIN_2_LEN + (u16_t)auth_len); + SMEMCPY(&s->tx_buf[SMTP_CMD_AUTHPLAIN_1_LEN + auth_len], SMTP_CMD_AUTHPLAIN_2, + SMTP_CMD_AUTHPLAIN_2_LEN); + return SMTP_AUTH_PLAIN; + } else +#endif /* SMTP_SUPPORT_AUTH_PLAIN */ + { +#if SMTP_SUPPORT_AUTH_LOGIN + if (strstr(sep, SMTP_AUTH_PARAM_LOGIN) != NULL) { + /* server supports AUTH LOGIN */ + *tx_buf_len = SMTP_CMD_AUTHLOGIN_LEN; + SMEMCPY(s->tx_buf, SMTP_CMD_AUTHLOGIN, SMTP_CMD_AUTHLOGIN_LEN); + return SMTP_AUTH_LOGIN_UNAME; + } +#endif /* SMTP_SUPPORT_AUTH_LOGIN */ + } + } + } + } + /* server didnt's send correct keywords for AUTH, try sending directly */ + return smtp_prepare_mail(s, tx_buf_len); +} +#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ + +#if SMTP_SUPPORT_AUTH_LOGIN +/** Send base64-encoded username */ +static enum smtp_session_state +smtp_prepare_auth_login_uname(struct smtp_session *s, u16_t *tx_buf_len) +{ + size_t base64_len = smtp_base64_encode(s->tx_buf, SMTP_TX_BUF_LEN, + SMTP_USERNAME(s), strlen(SMTP_USERNAME(s))); + /* @todo: support base64-encoded longer than 64k */ + LWIP_ASSERT("string too long", base64_len <= 0xffff); + LWIP_ASSERT("tx_buf overflow detected", base64_len <= SMTP_TX_BUF_LEN - SMTP_CRLF_LEN); + *tx_buf_len = (u16_t)(base64_len + SMTP_CRLF_LEN); + + SMEMCPY(&s->tx_buf[base64_len], SMTP_CRLF, SMTP_CRLF_LEN); + s->tx_buf[*tx_buf_len] = 0; + return SMTP_AUTH_LOGIN_PASS; +} + +/** Send base64-encoded password */ +static enum smtp_session_state +smtp_prepare_auth_login_pass(struct smtp_session *s, u16_t *tx_buf_len) +{ + size_t base64_len = smtp_base64_encode(s->tx_buf, SMTP_TX_BUF_LEN, + SMTP_PASS(s), strlen(SMTP_PASS(s))); + /* @todo: support base64-encoded longer than 64k */ + LWIP_ASSERT("string too long", base64_len <= 0xffff); + LWIP_ASSERT("tx_buf overflow detected", base64_len <= SMTP_TX_BUF_LEN - SMTP_CRLF_LEN); + *tx_buf_len = (u16_t)(base64_len + SMTP_CRLF_LEN); + + SMEMCPY(&s->tx_buf[base64_len], SMTP_CRLF, SMTP_CRLF_LEN); + s->tx_buf[*tx_buf_len] = 0; + return SMTP_AUTH_LOGIN; +} +#endif /* SMTP_SUPPORT_AUTH_LOGIN */ + +/** Prepare MAIL message */ +static enum smtp_session_state +smtp_prepare_mail(struct smtp_session *s, u16_t *tx_buf_len) +{ + char *target = s->tx_buf; + LWIP_ASSERT("tx_buf overflow detected", s->from_len <= (SMTP_TX_BUF_LEN - SMTP_CMD_MAIL_1_LEN - SMTP_CMD_MAIL_2_LEN)); + *tx_buf_len = (u16_t)(SMTP_CMD_MAIL_1_LEN + SMTP_CMD_MAIL_2_LEN + s->from_len); + target[*tx_buf_len] = 0; + + SMEMCPY(target, SMTP_CMD_MAIL_1, SMTP_CMD_MAIL_1_LEN); + target += SMTP_CMD_MAIL_1_LEN; + MEMCPY(target, s->from, s->from_len); + target += s->from_len; + SMEMCPY(target, SMTP_CMD_MAIL_2, SMTP_CMD_MAIL_2_LEN); + return SMTP_MAIL; +} + +/** Prepare RCPT message */ +static enum smtp_session_state +smtp_prepare_rcpt(struct smtp_session *s, u16_t *tx_buf_len) +{ + char *target = s->tx_buf; + LWIP_ASSERT("tx_buf overflow detected", s->to_len <= (SMTP_TX_BUF_LEN - SMTP_CMD_RCPT_1_LEN - SMTP_CMD_RCPT_2_LEN)); + *tx_buf_len = (u16_t)(SMTP_CMD_RCPT_1_LEN + SMTP_CMD_RCPT_2_LEN + s->to_len); + target[*tx_buf_len] = 0; + + SMEMCPY(target, SMTP_CMD_RCPT_1, SMTP_CMD_RCPT_1_LEN); + target += SMTP_CMD_RCPT_1_LEN; + MEMCPY(target, s->to, s->to_len); + target += s->to_len; + SMEMCPY(target, SMTP_CMD_RCPT_2, SMTP_CMD_RCPT_2_LEN); + return SMTP_RCPT; +} + +/** Prepare header of body */ +static enum smtp_session_state +smtp_prepare_header(struct smtp_session *s, u16_t *tx_buf_len) +{ + char *target = s->tx_buf; + int len = SMTP_CMD_HEADER_1_LEN + SMTP_CMD_HEADER_2_LEN + + SMTP_CMD_HEADER_3_LEN + SMTP_CMD_HEADER_4_LEN + s->from_len + s->to_len + + s->subject_len; + LWIP_ASSERT("tx_buf overflow detected", len > 0 && len <= SMTP_TX_BUF_LEN); + *tx_buf_len = (u16_t)len; + target[*tx_buf_len] = 0; + + SMEMCPY(target, SMTP_CMD_HEADER_1, SMTP_CMD_HEADER_1_LEN); + target += SMTP_CMD_HEADER_1_LEN; + MEMCPY(target, s->from, s->from_len); + target += s->from_len; + SMEMCPY(target, SMTP_CMD_HEADER_2, SMTP_CMD_HEADER_2_LEN); + target += SMTP_CMD_HEADER_2_LEN; + MEMCPY(target, s->to, s->to_len); + target += s->to_len; + SMEMCPY(target, SMTP_CMD_HEADER_3, SMTP_CMD_HEADER_3_LEN); + target += SMTP_CMD_HEADER_3_LEN; + MEMCPY(target, s->subject, s->subject_len); + target += s->subject_len; + SMEMCPY(target, SMTP_CMD_HEADER_4, SMTP_CMD_HEADER_4_LEN); + + return SMTP_BODY; +} + +/** Prepare QUIT message */ +static enum smtp_session_state +smtp_prepare_quit(struct smtp_session *s, u16_t *tx_buf_len) +{ + *tx_buf_len = SMTP_CMD_QUIT_LEN; + s->tx_buf[*tx_buf_len] = 0; + SMEMCPY(s->tx_buf, SMTP_CMD_QUIT, SMTP_CMD_QUIT_LEN); + LWIP_ASSERT("tx_buf overflow detected", *tx_buf_len <= SMTP_TX_BUF_LEN); + return SMTP_CLOSED; +} + +/** If in state SMTP_BODY, try to send more body data */ +static void +smtp_send_body(struct smtp_session *s, struct altcp_pcb *pcb) +{ + err_t err; + + if (s->state == SMTP_BODY) { +#if SMTP_BODYDH + if (s->bodydh) { + smtp_send_body_data_handler(s, pcb); + } else +#endif /* SMTP_BODYDH */ + { + u16_t send_len = (u16_t)(s->body_len - s->body_sent); + if (send_len > 0) { + u16_t snd_buf = altcp_sndbuf(pcb); + if (send_len > snd_buf) { + send_len = snd_buf; + } + if (send_len > 0) { + /* try to send something out */ + err = altcp_write(pcb, &s->body[s->body_sent], (u16_t)send_len, TCP_WRITE_FLAG_COPY); + if (err == ERR_OK) { + s->timer = SMTP_TIMEOUT_DATABLOCK; + s->body_sent = (u16_t)(s->body_sent + send_len); + if (s->body_sent < s->body_len) { + LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_send_body: %d of %d bytes written\n", + s->body_sent, s->body_len)); + } + } + } + } + } + if (s->body_sent == s->body_len) { + /* the whole body has been written, write last line */ + LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_send_body: body completely written (%d bytes), appending end-of-body\n", + s->body_len)); + err = altcp_write(pcb, SMTP_CMD_BODY_FINISHED, SMTP_CMD_BODY_FINISHED_LEN, 0); + if (err == ERR_OK) { + s->timer = SMTP_TIMEOUT_DATATERM; + LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_send_body: end-of-body written, changing state to %s\n", + smtp_state_str[SMTP_QUIT])); + /* last line written, change state, wait for confirmation */ + s->state = SMTP_QUIT; + } + } + } +} + +/** State machine-like implementation of an SMTP client. + */ +static void +smtp_process(void *arg, struct altcp_pcb *pcb, struct pbuf *p) +{ + struct smtp_session* s = (struct smtp_session*)arg; + u16_t response_code = 0; + u16_t tx_buf_len = 0; + enum smtp_session_state next_state; + + if (arg == NULL) { + /* already closed SMTP connection */ + if (p != NULL) { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("Received %d bytes after closing: %s\n", + p->tot_len, smtp_pbuf_str(p))); + pbuf_free(p); + } + return; + } + + next_state = s->state; + + if (p != NULL) { + /* received data */ + if (s->p == NULL) { + s->p = p; + } else { + pbuf_cat(s->p, p); + } + } else { + /* idle timer, close connection if timed out */ + if (s->timer == 0) { + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_process: connection timed out, closing\n")); + smtp_close(s, pcb, SMTP_RESULT_ERR_TIMEOUT, 0, ERR_TIMEOUT); + return; + } + if (s->state == SMTP_BODY) { + smtp_send_body(s, pcb); + return; + } + } + response_code = smtp_is_response(s); + if (response_code) { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process: received response code: %d\n", response_code)); + if (smtp_is_response_finished(s) != ERR_OK) { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process: partly received response code: %d\n", response_code)); + /* wait for next packet to complete the respone */ + return; + } + } else { + if (s->p != NULL) { + LWIP_DEBUGF(SMTP_DEBUG_WARN, ("smtp_process: unknown data received (%s)\n", + smtp_pbuf_str(s->p))); + pbuf_free(s->p); + s->p = NULL; + } + return; + } + + switch(s->state) + { + case(SMTP_NULL): + /* wait for 220 */ + if (response_code == 220) { + /* then send EHLO */ + next_state = smtp_prepare_helo(s, &tx_buf_len, pcb); + } + break; + case(SMTP_HELO): + /* wait for 250 */ + if (response_code == 250) { +#if SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN + /* then send AUTH or MAIL */ + next_state = smtp_prepare_auth_or_mail(s, &tx_buf_len); + } + break; + case(SMTP_AUTH_LOGIN): + case(SMTP_AUTH_PLAIN): + /* wait for 235 */ + if (response_code == 235) { +#endif /* SMTP_SUPPORT_AUTH_PLAIN || SMTP_SUPPORT_AUTH_LOGIN */ + /* send MAIL */ + next_state = smtp_prepare_mail(s, &tx_buf_len); + } + break; +#if SMTP_SUPPORT_AUTH_LOGIN + case(SMTP_AUTH_LOGIN_UNAME): + /* wait for 334 Username */ + if (response_code == 334) { + if (pbuf_strstr(s->p, SMTP_RESP_LOGIN_UNAME) != 0xFFFF) { + /* send username */ + next_state = smtp_prepare_auth_login_uname(s, &tx_buf_len); + } + } + break; + case(SMTP_AUTH_LOGIN_PASS): + /* wait for 334 Password */ + if (response_code == 334) { + if (pbuf_strstr(s->p, SMTP_RESP_LOGIN_PASS) != 0xFFFF) { + /* send username */ + next_state = smtp_prepare_auth_login_pass(s, &tx_buf_len); + } + } + break; +#endif /* SMTP_SUPPORT_AUTH_LOGIN */ + case(SMTP_MAIL): + /* wait for 250 */ + if (response_code == 250) { + /* send RCPT */ + next_state = smtp_prepare_rcpt(s, &tx_buf_len); + } + break; + case(SMTP_RCPT): + /* wait for 250 */ + if (response_code == 250) { + /* send DATA */ + SMEMCPY(s->tx_buf, SMTP_CMD_DATA, SMTP_CMD_DATA_LEN); + tx_buf_len = SMTP_CMD_DATA_LEN; + next_state = SMTP_DATA; + } + break; + case(SMTP_DATA): + /* wait for 354 */ + if (response_code == 354) { + /* send email header */ + next_state = smtp_prepare_header(s, &tx_buf_len); + } + break; + case(SMTP_BODY): + /* nothing to be done here, handled somewhere else */ + break; + case(SMTP_QUIT): + /* wait for 250 */ + if (response_code == 250) { + /* send QUIT */ + next_state = smtp_prepare_quit(s, &tx_buf_len); + } + break; + case(SMTP_CLOSED): + /* nothing to do, wait for connection closed from server */ + return; + default: + LWIP_DEBUGF(SMTP_DEBUG_SERIOUS, ("Invalid state: %d/%s\n", (int)s->state, + smtp_state_str[s->state])); + break; + } + if (s->state == next_state) { + LWIP_DEBUGF(SMTP_DEBUG_WARN_STATE, ("smtp_process[%s]: unexpected response_code, closing: %d (%s)\n", + smtp_state_str[s->state], response_code, smtp_pbuf_str(s->p))); + /* close connection */ + smtp_close(s, pcb, SMTP_RESULT_ERR_SVR_RESP, response_code, ERR_OK); + return; + } + if (tx_buf_len > 0) { + SMTP_TX_BUF_MAX(tx_buf_len); + if (altcp_write(pcb, s->tx_buf, tx_buf_len, TCP_WRITE_FLAG_COPY) == ERR_OK) { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process[%s]: received command %d (%s)\n", + smtp_state_str[s->state], response_code, smtp_pbuf_str(s->p))); + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_process[%s]: sent %"U16_F" bytes: \"%s\"\n", + smtp_state_str[s->state], tx_buf_len, s->tx_buf)); + s->timer = SMTP_TIMEOUT; + pbuf_free(s->p); + s->p = NULL; + LWIP_DEBUGF(SMTP_DEBUG_STATE, ("smtp_process: changing state from %s to %s\n", + smtp_state_str[s->state], smtp_state_str[next_state])); + s->state = next_state; + if (next_state == SMTP_BODY) { + /* try to stream-send body data right now */ + smtp_send_body(s, pcb); + } else if (next_state == SMTP_CLOSED) { + /* sent out all data, delete structure */ + altcp_arg(pcb, NULL); + smtp_free(s, SMTP_RESULT_OK, 0, ERR_OK); + } + } + } +} + +#if SMTP_BODYDH +/** Elementary sub-function to send data + * + * @returns: BDHALLDATASENT all data has been written + * BDHSOMEDATASENT some data has been written + * 0 no data has been written + */ +static int +smtp_send_bodyh_data(struct altcp_pcb *pcb, const char **from, u16_t *howmany) +{ + err_t err; + u16_t len = *howmany; + + len = (u16_t)LWIP_MIN(len, altcp_sndbuf(pcb)); + err = altcp_write(pcb, *from, len, TCP_WRITE_FLAG_COPY); + if (err == ERR_OK) { + *from += len; + if ((*howmany -= len) > 0) { + return BDHSOMEDATASENT; + } + return BDHALLDATASENT; + } + return 0; +} + +/** Same as smtp_send_mail_static, but uses a callback function to send body data + */ +err_t +smtp_send_mail_bodycback(const char *from, const char* to, const char* subject, + smtp_bodycback_fn bodycback_fn, smtp_result_fn callback_fn, void* callback_arg) +{ + struct smtp_session* s; + size_t len; + + LWIP_ASSERT_CORE_LOCKED(); + + s = (struct smtp_session*)SMTP_STATE_MALLOC(sizeof(struct smtp_session)); + if (s == NULL) { + return ERR_MEM; + } + memset(s, 0, sizeof(struct smtp_session)); + s->bodydh = (struct smtp_bodydh_state*)SMTP_BODYDH_MALLOC(sizeof(struct smtp_bodydh_state)); + if (s->bodydh == NULL) { + SMTP_STATE_FREE(s); + return ERR_MEM; + } + memset(s->bodydh, 0, sizeof(struct smtp_bodydh_state)); + /* initialize the structure */ + s->from = from; + len = strlen(from); + LWIP_ASSERT("string is too long", len <= 0xffff); + s->from_len = (u16_t)len; + s->to = to; + len = strlen(to); + LWIP_ASSERT("string is too long", len <= 0xffff); + s->to_len = (u16_t)len; + s->subject = subject; + len = strlen(subject); + LWIP_ASSERT("string is too long", len <= 0xffff); + s->subject_len = (u16_t)len; + s->body = NULL; + LWIP_ASSERT("string is too long", len <= 0xffff); + s->callback_fn = callback_fn; + s->callback_arg = callback_arg; + s->bodydh->callback_fn = bodycback_fn; + s->bodydh->state = BDH_SENDING; + /* call the actual implementation of this function */ + return smtp_send_mail_alloced(s); +} + +static void +smtp_send_body_data_handler(struct smtp_session *s, struct altcp_pcb *pcb) +{ + struct smtp_bodydh_state *bdh; + int res = 0, ret; + LWIP_ASSERT("s != NULL", s != NULL); + bdh = s->bodydh; + LWIP_ASSERT("bodydh != NULL", bdh != NULL); + + /* resume any leftovers from prior memory constraints */ + if (s->body_len) { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: resume\n")); + if((res = smtp_send_bodyh_data(pcb, (const char **)&s->body, &s->body_len)) + != BDHALLDATASENT) { + s->body_sent = s->body_len - 1; + return; + } + } + ret = res; + /* all data on buffer has been queued, resume execution */ + if (bdh->state == BDH_SENDING) { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: run\n")); + do { + ret |= res; /* remember if we once queued something to send */ + bdh->exposed.length = 0; + if (bdh->callback_fn(s->callback_arg, &bdh->exposed) == BDH_DONE) { + bdh->state = BDH_STOP; + } + s->body = bdh->exposed.buffer; + s->body_len = bdh->exposed.length; + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: trying to send %u bytes\n", (unsigned int)s->body_len)); + } while (s->body_len && + ((res = smtp_send_bodyh_data(pcb, (const char **)&s->body, &s->body_len)) == BDHALLDATASENT) + && (bdh->state != BDH_STOP)); + } + if ((bdh->state != BDH_SENDING) && (ret != BDHSOMEDATASENT)) { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: stop\n")); + s->body_sent = s->body_len; + } else { + LWIP_DEBUGF(SMTP_DEBUG_TRACE, ("smtp_send_body_data_handler: pause\n")); + s->body_sent = s->body_len - 1; + } +} +#endif /* SMTP_BODYDH */ + +#endif /* LWIP_TCP && LWIP_CALLBACK_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.c index 8e91e758..6df34dbd 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.c @@ -1,704 +1,704 @@ -/** - * @file - * Abstract Syntax Notation One (ISO 8824, 8825) encoding - * - * @todo not optimised (yet), favor correctness over speed, favor speed over size - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Christiaan Simons - * Martin Hentschel - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "snmp_asn1.h" - -#define PBUF_OP_EXEC(code) \ - if ((code) != ERR_OK) { \ - return ERR_BUF; \ - } - -/** - * Encodes a TLV into a pbuf stream. - * - * @param pbuf_stream points to a pbuf stream - * @param tlv TLV to encode - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode - */ -err_t -snmp_ans1_enc_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv) -{ - u8_t data; - u8_t length_bytes_required; - - /* write type */ - if ((tlv->type & SNMP_ASN1_DATATYPE_MASK) == SNMP_ASN1_DATATYPE_EXTENDED) { - /* extended format is not used by SNMP so we do not accept those values */ - return ERR_ARG; - } - if (tlv->type_len != 0) { - /* any other value as auto is not accepted for type (we always use one byte because extended syntax is prohibited) */ - return ERR_ARG; - } - - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, tlv->type)); - tlv->type_len = 1; - - /* write length */ - if (tlv->value_len <= 127) { - length_bytes_required = 1; - } else if (tlv->value_len <= 255) { - length_bytes_required = 2; - } else { - length_bytes_required = 3; - } - - /* check for forced min length */ - if (tlv->length_len > 0) { - if (tlv->length_len < length_bytes_required) { - /* unable to code requested length in requested number of bytes */ - return ERR_ARG; - } - - length_bytes_required = tlv->length_len; - } else { - tlv->length_len = length_bytes_required; - } - - if (length_bytes_required > 1) { - /* multi byte representation required */ - length_bytes_required--; - data = 0x80 | length_bytes_required; /* extended length definition, 1 length byte follows */ - - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, data)); - - while (length_bytes_required > 1) { - if (length_bytes_required == 2) { - /* append high byte */ - data = (u8_t)(tlv->value_len >> 8); - } else { - /* append leading 0x00 */ - data = 0x00; - } - - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, data)); - length_bytes_required--; - } - } - - /* append low byte */ - data = (u8_t)(tlv->value_len & 0xFF); - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, data)); - - return ERR_OK; -} - -/** - * Encodes raw data (octet string, opaque) into a pbuf chained ASN1 msg. - * - * @param pbuf_stream points to a pbuf stream - * @param raw_len raw data length - * @param raw points raw data - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode - */ -err_t -snmp_asn1_enc_raw(struct snmp_pbuf_stream *pbuf_stream, const u8_t *raw, u16_t raw_len) -{ - PBUF_OP_EXEC(snmp_pbuf_stream_writebuf(pbuf_stream, raw, raw_len)); - - return ERR_OK; -} - -/** - * Encodes u32_t (counter, gauge, timeticks) into a pbuf chained ASN1 msg. - * - * @param pbuf_stream points to a pbuf stream - * @param octets_needed encoding length (from snmp_asn1_enc_u32t_cnt()) - * @param value is the host order u32_t value to be encoded - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode - * - * @see snmp_asn1_enc_u32t_cnt() - */ -err_t -snmp_asn1_enc_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u32_t value) -{ - if (octets_needed > 5) { - return ERR_ARG; - } - if (octets_needed == 5) { - /* not enough bits in 'value' add leading 0x00 */ - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, 0x00)); - octets_needed--; - } - - while (octets_needed > 1) { - octets_needed--; - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value >> (octets_needed << 3)))); - } - - /* (only) one least significant octet */ - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)value)); - - return ERR_OK; -} -/** - * Encodes s32_t integer into a pbuf chained ASN1 msg. - * - * @param pbuf_stream points to a pbuf stream - * @param octets_needed encoding length (from snmp_asn1_enc_s32t_cnt()) - * @param value is the host order s32_t value to be encoded - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode - * - * @see snmp_asn1_enc_s32t_cnt() - */ -err_t -snmp_asn1_enc_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, s32_t value) -{ - while (octets_needed > 1) { - octets_needed--; - - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value >> (octets_needed << 3)))); - } - - /* (only) one least significant octet */ - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)value)); - - return ERR_OK; -} - -/** - * Encodes object identifier into a pbuf chained ASN1 msg. - * - * @param pbuf_stream points to a pbuf stream - * @param oid points to object identifier array - * @param oid_len object identifier array length - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode - */ -err_t -snmp_asn1_enc_oid(struct snmp_pbuf_stream *pbuf_stream, const u32_t *oid, u16_t oid_len) -{ - if (oid_len > 1) { - /* write compressed first two sub id's */ - u32_t compressed_byte = ((oid[0] * 40) + oid[1]); - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)compressed_byte)); - oid_len -= 2; - oid += 2; - } else { - /* @bug: allow empty varbinds for symmetry (we must decode them for getnext), allow partial compression?? */ - /* ident_len <= 1, at least we need zeroDotZero (0.0) (ident_len == 2) */ - return ERR_ARG; - } - - while (oid_len > 0) { - u32_t sub_id; - u8_t shift, tail; - - oid_len--; - sub_id = *oid; - tail = 0; - shift = 28; - while (shift > 0) { - u8_t code; - - code = (u8_t)(sub_id >> shift); - if ((code != 0) || (tail != 0)) { - tail = 1; - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, code | 0x80)); - } - shift -= 7; - } - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)sub_id & 0x7F)); - - /* proceed to next sub-identifier */ - oid++; - } - return ERR_OK; -} - -/** - * Returns octet count for length. - * - * @param length parameter length - * @param octets_needed points to the return value - */ -void -snmp_asn1_enc_length_cnt(u16_t length, u8_t *octets_needed) -{ - if (length < 0x80U) { - *octets_needed = 1; - } else if (length < 0x100U) { - *octets_needed = 2; - } else { - *octets_needed = 3; - } -} - -/** - * Returns octet count for an u32_t. - * - * @param value value to be encoded - * @param octets_needed points to the return value - * - * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded - * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value - * of 0xFFFFFFFF is preceded with 0x00 and the length is 5 octets!! - */ -void -snmp_asn1_enc_u32t_cnt(u32_t value, u16_t *octets_needed) -{ - if (value < 0x80UL) { - *octets_needed = 1; - } else if (value < 0x8000UL) { - *octets_needed = 2; - } else if (value < 0x800000UL) { - *octets_needed = 3; - } else if (value < 0x80000000UL) { - *octets_needed = 4; - } else { - *octets_needed = 5; - } -} - -/** - * Returns octet count for an s32_t. - * - * @param value value to be encoded - * @param octets_needed points to the return value - * - * @note ASN coded integers are _always_ signed. - */ -void -snmp_asn1_enc_s32t_cnt(s32_t value, u16_t *octets_needed) -{ - if (value < 0) { - value = ~value; - } - if (value < 0x80L) { - *octets_needed = 1; - } else if (value < 0x8000L) { - *octets_needed = 2; - } else if (value < 0x800000L) { - *octets_needed = 3; - } else { - *octets_needed = 4; - } -} - -/** - * Returns octet count for an object identifier. - * - * @param oid points to object identifier array - * @param oid_len object identifier array length - * @param octets_needed points to the return value - */ -void -snmp_asn1_enc_oid_cnt(const u32_t *oid, u16_t oid_len, u16_t *octets_needed) -{ - u32_t sub_id; - - *octets_needed = 0; - if (oid_len > 1) { - /* compressed prefix in one octet */ - (*octets_needed)++; - oid_len -= 2; - oid += 2; - } - while (oid_len > 0) { - oid_len--; - sub_id = *oid; - - sub_id >>= 7; - (*octets_needed)++; - while (sub_id > 0) { - sub_id >>= 7; - (*octets_needed)++; - } - oid++; - } -} - -/** - * Decodes a TLV from a pbuf stream. - * - * @param pbuf_stream points to a pbuf stream - * @param tlv returns decoded TLV - * @return ERR_OK if successful, ERR_VAL if we can't decode - */ -err_t -snmp_asn1_dec_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv) -{ - u8_t data; - - /* decode type first */ - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - tlv->type = data; - - if ((tlv->type & SNMP_ASN1_DATATYPE_MASK) == SNMP_ASN1_DATATYPE_EXTENDED) { - /* extended format is not used by SNMP so we do not accept those values */ - return ERR_VAL; - } - tlv->type_len = 1; - - /* now, decode length */ - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - - if (data < 0x80) { /* short form */ - tlv->length_len = 1; - tlv->value_len = data; - } else if (data > 0x80) { /* long form */ - u8_t length_bytes = data - 0x80; - if (length_bytes > pbuf_stream->length) { - return ERR_VAL; - } - tlv->length_len = length_bytes + 1; /* this byte + defined number of length bytes following */ - tlv->value_len = 0; - - while (length_bytes > 0) { - /* we only support up to u16.maxvalue-1 (2 bytes) but have to accept leading zero bytes */ - if (tlv->value_len > 0xFF) { - return ERR_VAL; - } - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - tlv->value_len <<= 8; - tlv->value_len |= data; - - /* take care for special value used for indefinite length */ - if (tlv->value_len == 0xFFFF) { - return ERR_VAL; - } - - length_bytes--; - } - } else { /* data == 0x80 indefinite length form */ - /* (not allowed for SNMP; RFC 1157, 3.2.2) */ - return ERR_VAL; - } - - return ERR_OK; -} - -/** - * Decodes positive integer (counter, gauge, timeticks) into u32_t. - * - * @param pbuf_stream points to a pbuf stream - * @param len length of the coded integer field - * @param value return host order integer - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode - * - * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded - * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value - * of 0xFFFFFFFF is preceded with 0x00 and the length is 5 octets!! - */ -err_t -snmp_asn1_dec_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *value) -{ - u8_t data; - - if ((len > 0) && (len <= 5)) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - - /* expecting sign bit to be zero, only unsigned please! */ - if (((len == 5) && (data == 0x00)) || ((len < 5) && ((data & 0x80) == 0))) { - *value = data; - len--; - - while (len > 0) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - len--; - - *value <<= 8; - *value |= data; - } - - return ERR_OK; - } - } - - return ERR_VAL; -} - -/** - * Decodes integer into s32_t. - * - * @param pbuf_stream points to a pbuf stream - * @param len length of the coded integer field - * @param value return host order integer - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode - * - * @note ASN coded integers are _always_ signed! - */ -err_t -snmp_asn1_dec_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, s32_t *value) -{ - u8_t data; - - if ((len > 0) && (len < 5)) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - - if (data & 0x80) { - /* negative, start from -1 */ - *value = -1; - *value = (*value << 8) | data; - } else { - /* positive, start from 0 */ - *value = data; - } - len--; - /* shift in the remaining value */ - while (len > 0) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - *value = (*value << 8) | data; - len--; - } - return ERR_OK; - } - - return ERR_VAL; -} - -/** - * Decodes object identifier from incoming message into array of u32_t. - * - * @param pbuf_stream points to a pbuf stream - * @param len length of the coded object identifier - * @param oid return decoded object identifier - * @param oid_len return decoded object identifier length - * @param oid_max_len size of oid buffer - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode - */ -err_t -snmp_asn1_dec_oid(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *oid, u8_t *oid_len, u8_t oid_max_len) -{ - u32_t *oid_ptr; - u8_t data; - - *oid_len = 0; - oid_ptr = oid; - if (len > 0) { - if (oid_max_len < 2) { - return ERR_MEM; - } - - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - len--; - - /* first compressed octet */ - if (data == 0x2B) { - /* (most) common case 1.3 (iso.org) */ - *oid_ptr = 1; - oid_ptr++; - *oid_ptr = 3; - oid_ptr++; - } else if (data < 40) { - *oid_ptr = 0; - oid_ptr++; - *oid_ptr = data; - oid_ptr++; - } else if (data < 80) { - *oid_ptr = 1; - oid_ptr++; - *oid_ptr = data - 40; - oid_ptr++; - } else { - *oid_ptr = 2; - oid_ptr++; - *oid_ptr = data - 80; - oid_ptr++; - } - *oid_len = 2; - } else { - /* accepting zero length identifiers e.g. for getnext operation. uncommon but valid */ - return ERR_OK; - } - - while ((len > 0) && (*oid_len < oid_max_len)) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - len--; - - if ((data & 0x80) == 0x00) { - /* sub-identifier uses single octet */ - *oid_ptr = data; - } else { - /* sub-identifier uses multiple octets */ - u32_t sub_id = (data & ~0x80); - while ((len > 0) && ((data & 0x80) != 0)) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - len--; - - sub_id = (sub_id << 7) + (data & ~0x80); - } - - if ((data & 0x80) != 0) { - /* "more bytes following" bit still set at end of len */ - return ERR_VAL; - } - *oid_ptr = sub_id; - } - oid_ptr++; - (*oid_len)++; - } - - if (len > 0) { - /* OID to long to fit in our buffer */ - return ERR_MEM; - } - - return ERR_OK; -} - -/** - * Decodes (copies) raw data (ip-addresses, octet strings, opaque encoding) - * from incoming message into array. - * - * @param pbuf_stream points to a pbuf stream - * @param len length of the coded raw data (zero is valid, e.g. empty string!) - * @param buf return raw bytes - * @param buf_len returns length of the raw return value - * @param buf_max_len buffer size - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode - */ -err_t -snmp_asn1_dec_raw(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u8_t *buf, u16_t *buf_len, u16_t buf_max_len) -{ - if (len > buf_max_len) { - /* not enough dst space */ - return ERR_MEM; - } - *buf_len = len; - - while (len > 0) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, buf)); - buf++; - len--; - } - - return ERR_OK; -} - -#if LWIP_HAVE_INT64 -/** - * Returns octet count for an u64_t. - * - * @param value value to be encoded - * @param octets_needed points to the return value - * - * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded - * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value - * of 0xFFFFFFFFFFFFFFFF is preceded with 0x00 and the length is 9 octets!! - */ -void -snmp_asn1_enc_u64t_cnt(u64_t value, u16_t *octets_needed) -{ - /* check if high u32 is 0 */ - if ((value >> 32) == 0) { - /* only low u32 is important */ - snmp_asn1_enc_u32t_cnt((u32_t)value, octets_needed); - } else { - /* low u32 does not matter for length determination */ - snmp_asn1_enc_u32t_cnt((u32_t)(value >> 32), octets_needed); - *octets_needed = *octets_needed + 4; /* add the 4 bytes of low u32 */ - } -} - -/** - * Decodes large positive integer (counter64) into 2x u32_t. - * - * @param pbuf_stream points to a pbuf stream - * @param len length of the coded integer field - * @param value return 64 bit integer - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode - * - * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded - * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value - * of 0xFFFFFFFFFFFFFFFF is preceded with 0x00 and the length is 9 octets!! - */ -err_t -snmp_asn1_dec_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u64_t *value) -{ - u8_t data; - - if ((len > 0) && (len <= 9)) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - - /* expecting sign bit to be zero, only unsigned please! */ - if (((len == 9) && (data == 0x00)) || ((len < 9) && ((data & 0x80) == 0))) { - *value = data; - len--; - - while (len > 0) { - PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); - *value <<= 8; - *value |= data; - len--; - } - - return ERR_OK; - } - } - - return ERR_VAL; -} - -/** - * Encodes u64_t (counter64) into a pbuf chained ASN1 msg. - * - * @param pbuf_stream points to a pbuf stream - * @param octets_needed encoding length (from snmp_asn1_enc_u32t_cnt()) - * @param value is the value to be encoded - * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode - * - * @see snmp_asn1_enc_u64t_cnt() - */ -err_t -snmp_asn1_enc_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u64_t value) -{ - if (octets_needed > 9) { - return ERR_ARG; - } - if (octets_needed == 9) { - /* not enough bits in 'value' add leading 0x00 */ - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, 0x00)); - octets_needed--; - } - - while (octets_needed > 1) { - octets_needed--; - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value >> (octets_needed << 3)))); - } - - /* always write at least one octet (also in case of value == 0) */ - PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value))); - - return ERR_OK; -} -#endif - -#endif /* LWIP_SNMP */ +/** + * @file + * Abstract Syntax Notation One (ISO 8824, 8825) encoding + * + * @todo not optimised (yet), favor correctness over speed, favor speed over size + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Christiaan Simons + * Martin Hentschel + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "snmp_asn1.h" + +#define PBUF_OP_EXEC(code) \ + if ((code) != ERR_OK) { \ + return ERR_BUF; \ + } + +/** + * Encodes a TLV into a pbuf stream. + * + * @param pbuf_stream points to a pbuf stream + * @param tlv TLV to encode + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode + */ +err_t +snmp_ans1_enc_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv) +{ + u8_t data; + u8_t length_bytes_required; + + /* write type */ + if ((tlv->type & SNMP_ASN1_DATATYPE_MASK) == SNMP_ASN1_DATATYPE_EXTENDED) { + /* extended format is not used by SNMP so we do not accept those values */ + return ERR_ARG; + } + if (tlv->type_len != 0) { + /* any other value as auto is not accepted for type (we always use one byte because extended syntax is prohibited) */ + return ERR_ARG; + } + + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, tlv->type)); + tlv->type_len = 1; + + /* write length */ + if (tlv->value_len <= 127) { + length_bytes_required = 1; + } else if (tlv->value_len <= 255) { + length_bytes_required = 2; + } else { + length_bytes_required = 3; + } + + /* check for forced min length */ + if (tlv->length_len > 0) { + if (tlv->length_len < length_bytes_required) { + /* unable to code requested length in requested number of bytes */ + return ERR_ARG; + } + + length_bytes_required = tlv->length_len; + } else { + tlv->length_len = length_bytes_required; + } + + if (length_bytes_required > 1) { + /* multi byte representation required */ + length_bytes_required--; + data = 0x80 | length_bytes_required; /* extended length definition, 1 length byte follows */ + + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, data)); + + while (length_bytes_required > 1) { + if (length_bytes_required == 2) { + /* append high byte */ + data = (u8_t)(tlv->value_len >> 8); + } else { + /* append leading 0x00 */ + data = 0x00; + } + + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, data)); + length_bytes_required--; + } + } + + /* append low byte */ + data = (u8_t)(tlv->value_len & 0xFF); + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, data)); + + return ERR_OK; +} + +/** + * Encodes raw data (octet string, opaque) into a pbuf chained ASN1 msg. + * + * @param pbuf_stream points to a pbuf stream + * @param raw_len raw data length + * @param raw points raw data + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode + */ +err_t +snmp_asn1_enc_raw(struct snmp_pbuf_stream *pbuf_stream, const u8_t *raw, u16_t raw_len) +{ + PBUF_OP_EXEC(snmp_pbuf_stream_writebuf(pbuf_stream, raw, raw_len)); + + return ERR_OK; +} + +/** + * Encodes u32_t (counter, gauge, timeticks) into a pbuf chained ASN1 msg. + * + * @param pbuf_stream points to a pbuf stream + * @param octets_needed encoding length (from snmp_asn1_enc_u32t_cnt()) + * @param value is the host order u32_t value to be encoded + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode + * + * @see snmp_asn1_enc_u32t_cnt() + */ +err_t +snmp_asn1_enc_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u32_t value) +{ + if (octets_needed > 5) { + return ERR_ARG; + } + if (octets_needed == 5) { + /* not enough bits in 'value' add leading 0x00 */ + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, 0x00)); + octets_needed--; + } + + while (octets_needed > 1) { + octets_needed--; + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value >> (octets_needed << 3)))); + } + + /* (only) one least significant octet */ + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)value)); + + return ERR_OK; +} +/** + * Encodes s32_t integer into a pbuf chained ASN1 msg. + * + * @param pbuf_stream points to a pbuf stream + * @param octets_needed encoding length (from snmp_asn1_enc_s32t_cnt()) + * @param value is the host order s32_t value to be encoded + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode + * + * @see snmp_asn1_enc_s32t_cnt() + */ +err_t +snmp_asn1_enc_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, s32_t value) +{ + while (octets_needed > 1) { + octets_needed--; + + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value >> (octets_needed << 3)))); + } + + /* (only) one least significant octet */ + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)value)); + + return ERR_OK; +} + +/** + * Encodes object identifier into a pbuf chained ASN1 msg. + * + * @param pbuf_stream points to a pbuf stream + * @param oid points to object identifier array + * @param oid_len object identifier array length + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode + */ +err_t +snmp_asn1_enc_oid(struct snmp_pbuf_stream *pbuf_stream, const u32_t *oid, u16_t oid_len) +{ + if (oid_len > 1) { + /* write compressed first two sub id's */ + u32_t compressed_byte = ((oid[0] * 40) + oid[1]); + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)compressed_byte)); + oid_len -= 2; + oid += 2; + } else { + /* @bug: allow empty varbinds for symmetry (we must decode them for getnext), allow partial compression?? */ + /* ident_len <= 1, at least we need zeroDotZero (0.0) (ident_len == 2) */ + return ERR_ARG; + } + + while (oid_len > 0) { + u32_t sub_id; + u8_t shift, tail; + + oid_len--; + sub_id = *oid; + tail = 0; + shift = 28; + while (shift > 0) { + u8_t code; + + code = (u8_t)(sub_id >> shift); + if ((code != 0) || (tail != 0)) { + tail = 1; + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, code | 0x80)); + } + shift -= 7; + } + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)sub_id & 0x7F)); + + /* proceed to next sub-identifier */ + oid++; + } + return ERR_OK; +} + +/** + * Returns octet count for length. + * + * @param length parameter length + * @param octets_needed points to the return value + */ +void +snmp_asn1_enc_length_cnt(u16_t length, u8_t *octets_needed) +{ + if (length < 0x80U) { + *octets_needed = 1; + } else if (length < 0x100U) { + *octets_needed = 2; + } else { + *octets_needed = 3; + } +} + +/** + * Returns octet count for an u32_t. + * + * @param value value to be encoded + * @param octets_needed points to the return value + * + * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded + * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value + * of 0xFFFFFFFF is preceded with 0x00 and the length is 5 octets!! + */ +void +snmp_asn1_enc_u32t_cnt(u32_t value, u16_t *octets_needed) +{ + if (value < 0x80UL) { + *octets_needed = 1; + } else if (value < 0x8000UL) { + *octets_needed = 2; + } else if (value < 0x800000UL) { + *octets_needed = 3; + } else if (value < 0x80000000UL) { + *octets_needed = 4; + } else { + *octets_needed = 5; + } +} + +/** + * Returns octet count for an s32_t. + * + * @param value value to be encoded + * @param octets_needed points to the return value + * + * @note ASN coded integers are _always_ signed. + */ +void +snmp_asn1_enc_s32t_cnt(s32_t value, u16_t *octets_needed) +{ + if (value < 0) { + value = ~value; + } + if (value < 0x80L) { + *octets_needed = 1; + } else if (value < 0x8000L) { + *octets_needed = 2; + } else if (value < 0x800000L) { + *octets_needed = 3; + } else { + *octets_needed = 4; + } +} + +/** + * Returns octet count for an object identifier. + * + * @param oid points to object identifier array + * @param oid_len object identifier array length + * @param octets_needed points to the return value + */ +void +snmp_asn1_enc_oid_cnt(const u32_t *oid, u16_t oid_len, u16_t *octets_needed) +{ + u32_t sub_id; + + *octets_needed = 0; + if (oid_len > 1) { + /* compressed prefix in one octet */ + (*octets_needed)++; + oid_len -= 2; + oid += 2; + } + while (oid_len > 0) { + oid_len--; + sub_id = *oid; + + sub_id >>= 7; + (*octets_needed)++; + while (sub_id > 0) { + sub_id >>= 7; + (*octets_needed)++; + } + oid++; + } +} + +/** + * Decodes a TLV from a pbuf stream. + * + * @param pbuf_stream points to a pbuf stream + * @param tlv returns decoded TLV + * @return ERR_OK if successful, ERR_VAL if we can't decode + */ +err_t +snmp_asn1_dec_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv) +{ + u8_t data; + + /* decode type first */ + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + tlv->type = data; + + if ((tlv->type & SNMP_ASN1_DATATYPE_MASK) == SNMP_ASN1_DATATYPE_EXTENDED) { + /* extended format is not used by SNMP so we do not accept those values */ + return ERR_VAL; + } + tlv->type_len = 1; + + /* now, decode length */ + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + + if (data < 0x80) { /* short form */ + tlv->length_len = 1; + tlv->value_len = data; + } else if (data > 0x80) { /* long form */ + u8_t length_bytes = data - 0x80; + if (length_bytes > pbuf_stream->length) { + return ERR_VAL; + } + tlv->length_len = length_bytes + 1; /* this byte + defined number of length bytes following */ + tlv->value_len = 0; + + while (length_bytes > 0) { + /* we only support up to u16.maxvalue-1 (2 bytes) but have to accept leading zero bytes */ + if (tlv->value_len > 0xFF) { + return ERR_VAL; + } + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + tlv->value_len <<= 8; + tlv->value_len |= data; + + /* take care for special value used for indefinite length */ + if (tlv->value_len == 0xFFFF) { + return ERR_VAL; + } + + length_bytes--; + } + } else { /* data == 0x80 indefinite length form */ + /* (not allowed for SNMP; RFC 1157, 3.2.2) */ + return ERR_VAL; + } + + return ERR_OK; +} + +/** + * Decodes positive integer (counter, gauge, timeticks) into u32_t. + * + * @param pbuf_stream points to a pbuf stream + * @param len length of the coded integer field + * @param value return host order integer + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode + * + * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded + * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value + * of 0xFFFFFFFF is preceded with 0x00 and the length is 5 octets!! + */ +err_t +snmp_asn1_dec_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *value) +{ + u8_t data; + + if ((len > 0) && (len <= 5)) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + + /* expecting sign bit to be zero, only unsigned please! */ + if (((len == 5) && (data == 0x00)) || ((len < 5) && ((data & 0x80) == 0))) { + *value = data; + len--; + + while (len > 0) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + len--; + + *value <<= 8; + *value |= data; + } + + return ERR_OK; + } + } + + return ERR_VAL; +} + +/** + * Decodes integer into s32_t. + * + * @param pbuf_stream points to a pbuf stream + * @param len length of the coded integer field + * @param value return host order integer + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode + * + * @note ASN coded integers are _always_ signed! + */ +err_t +snmp_asn1_dec_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, s32_t *value) +{ + u8_t data; + + if ((len > 0) && (len < 5)) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + + if (data & 0x80) { + /* negative, start from -1 */ + *value = -1; + *value = (*value << 8) | data; + } else { + /* positive, start from 0 */ + *value = data; + } + len--; + /* shift in the remaining value */ + while (len > 0) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + *value = (*value << 8) | data; + len--; + } + return ERR_OK; + } + + return ERR_VAL; +} + +/** + * Decodes object identifier from incoming message into array of u32_t. + * + * @param pbuf_stream points to a pbuf stream + * @param len length of the coded object identifier + * @param oid return decoded object identifier + * @param oid_len return decoded object identifier length + * @param oid_max_len size of oid buffer + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode + */ +err_t +snmp_asn1_dec_oid(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *oid, u8_t *oid_len, u8_t oid_max_len) +{ + u32_t *oid_ptr; + u8_t data; + + *oid_len = 0; + oid_ptr = oid; + if (len > 0) { + if (oid_max_len < 2) { + return ERR_MEM; + } + + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + len--; + + /* first compressed octet */ + if (data == 0x2B) { + /* (most) common case 1.3 (iso.org) */ + *oid_ptr = 1; + oid_ptr++; + *oid_ptr = 3; + oid_ptr++; + } else if (data < 40) { + *oid_ptr = 0; + oid_ptr++; + *oid_ptr = data; + oid_ptr++; + } else if (data < 80) { + *oid_ptr = 1; + oid_ptr++; + *oid_ptr = data - 40; + oid_ptr++; + } else { + *oid_ptr = 2; + oid_ptr++; + *oid_ptr = data - 80; + oid_ptr++; + } + *oid_len = 2; + } else { + /* accepting zero length identifiers e.g. for getnext operation. uncommon but valid */ + return ERR_OK; + } + + while ((len > 0) && (*oid_len < oid_max_len)) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + len--; + + if ((data & 0x80) == 0x00) { + /* sub-identifier uses single octet */ + *oid_ptr = data; + } else { + /* sub-identifier uses multiple octets */ + u32_t sub_id = (data & ~0x80); + while ((len > 0) && ((data & 0x80) != 0)) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + len--; + + sub_id = (sub_id << 7) + (data & ~0x80); + } + + if ((data & 0x80) != 0) { + /* "more bytes following" bit still set at end of len */ + return ERR_VAL; + } + *oid_ptr = sub_id; + } + oid_ptr++; + (*oid_len)++; + } + + if (len > 0) { + /* OID to long to fit in our buffer */ + return ERR_MEM; + } + + return ERR_OK; +} + +/** + * Decodes (copies) raw data (ip-addresses, octet strings, opaque encoding) + * from incoming message into array. + * + * @param pbuf_stream points to a pbuf stream + * @param len length of the coded raw data (zero is valid, e.g. empty string!) + * @param buf return raw bytes + * @param buf_len returns length of the raw return value + * @param buf_max_len buffer size + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode + */ +err_t +snmp_asn1_dec_raw(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u8_t *buf, u16_t *buf_len, u16_t buf_max_len) +{ + if (len > buf_max_len) { + /* not enough dst space */ + return ERR_MEM; + } + *buf_len = len; + + while (len > 0) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, buf)); + buf++; + len--; + } + + return ERR_OK; +} + +#if LWIP_HAVE_INT64 +/** + * Returns octet count for an u64_t. + * + * @param value value to be encoded + * @param octets_needed points to the return value + * + * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded + * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value + * of 0xFFFFFFFFFFFFFFFF is preceded with 0x00 and the length is 9 octets!! + */ +void +snmp_asn1_enc_u64t_cnt(u64_t value, u16_t *octets_needed) +{ + /* check if high u32 is 0 */ + if ((value >> 32) == 0) { + /* only low u32 is important */ + snmp_asn1_enc_u32t_cnt((u32_t)value, octets_needed); + } else { + /* low u32 does not matter for length determination */ + snmp_asn1_enc_u32t_cnt((u32_t)(value >> 32), octets_needed); + *octets_needed = *octets_needed + 4; /* add the 4 bytes of low u32 */ + } +} + +/** + * Decodes large positive integer (counter64) into 2x u32_t. + * + * @param pbuf_stream points to a pbuf stream + * @param len length of the coded integer field + * @param value return 64 bit integer + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) decode + * + * @note ASN coded integers are _always_ signed. E.g. +0xFFFF is coded + * as 0x00,0xFF,0xFF. Note the leading sign octet. A positive value + * of 0xFFFFFFFFFFFFFFFF is preceded with 0x00 and the length is 9 octets!! + */ +err_t +snmp_asn1_dec_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u64_t *value) +{ + u8_t data; + + if ((len > 0) && (len <= 9)) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + + /* expecting sign bit to be zero, only unsigned please! */ + if (((len == 9) && (data == 0x00)) || ((len < 9) && ((data & 0x80) == 0))) { + *value = data; + len--; + + while (len > 0) { + PBUF_OP_EXEC(snmp_pbuf_stream_read(pbuf_stream, &data)); + *value <<= 8; + *value |= data; + len--; + } + + return ERR_OK; + } + } + + return ERR_VAL; +} + +/** + * Encodes u64_t (counter64) into a pbuf chained ASN1 msg. + * + * @param pbuf_stream points to a pbuf stream + * @param octets_needed encoding length (from snmp_asn1_enc_u32t_cnt()) + * @param value is the value to be encoded + * @return ERR_OK if successful, ERR_ARG if we can't (or won't) encode + * + * @see snmp_asn1_enc_u64t_cnt() + */ +err_t +snmp_asn1_enc_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u64_t value) +{ + if (octets_needed > 9) { + return ERR_ARG; + } + if (octets_needed == 9) { + /* not enough bits in 'value' add leading 0x00 */ + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, 0x00)); + octets_needed--; + } + + while (octets_needed > 1) { + octets_needed--; + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value >> (octets_needed << 3)))); + } + + /* always write at least one octet (also in case of value == 0) */ + PBUF_OP_EXEC(snmp_pbuf_stream_write(pbuf_stream, (u8_t)(value))); + + return ERR_OK; +} +#endif + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.h index c9daf066..87c0973f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_asn1.h @@ -1,113 +1,113 @@ -/** - * @file - * Abstract Syntax Notation One (ISO 8824, 8825) codec. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * Copyright (c) 2016 Elias Oenal. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Christiaan Simons - * Martin Hentschel - * Elias Oenal - */ - -#ifndef LWIP_HDR_APPS_SNMP_ASN1_H -#define LWIP_HDR_APPS_SNMP_ASN1_H - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP - -#include "lwip/err.h" -#include "lwip/apps/snmp_core.h" -#include "snmp_pbuf_stream.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define SNMP_ASN1_TLV_INDEFINITE_LENGTH 0x80 - -#define SNMP_ASN1_CLASS_MASK 0xC0 -#define SNMP_ASN1_CONTENTTYPE_MASK 0x20 -#define SNMP_ASN1_DATATYPE_MASK 0x1F -#define SNMP_ASN1_DATATYPE_EXTENDED 0x1F /* DataType indicating that datatype is encoded in following bytes */ - -/* context specific (SNMP) tags (from SNMP spec. RFC1157 and RFC1905) */ -#define SNMP_ASN1_CONTEXT_PDU_GET_REQ 0 -#define SNMP_ASN1_CONTEXT_PDU_GET_NEXT_REQ 1 -#define SNMP_ASN1_CONTEXT_PDU_GET_RESP 2 -#define SNMP_ASN1_CONTEXT_PDU_SET_REQ 3 -#define SNMP_ASN1_CONTEXT_PDU_TRAP 4 -#define SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ 5 -#define SNMP_ASN1_CONTEXT_PDU_INFORM_REQ 6 -#define SNMP_ASN1_CONTEXT_PDU_V2_TRAP 7 -#define SNMP_ASN1_CONTEXT_PDU_REPORT 8 - -#define SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_OBJECT 0 -#define SNMP_ASN1_CONTEXT_VARBIND_END_OF_MIB_VIEW 2 - -struct snmp_asn1_tlv { - u8_t type; /* only U8 because extended types are not specified by SNMP */ - u8_t type_len; /* encoded length of 'type' field (normally 1) */ - u8_t length_len; /* indicates how many bytes are required to encode the 'value_len' field */ - u16_t value_len; /* encoded length of the value */ -}; -#define SNMP_ASN1_TLV_HDR_LENGTH(tlv) ((tlv).type_len + (tlv).length_len) -#define SNMP_ASN1_TLV_LENGTH(tlv) ((tlv).type_len + (tlv).length_len + (tlv).value_len) -#define SNMP_ASN1_SET_TLV_PARAMS(tlv, type_, length_len_, value_len_) do { (tlv).type = (type_); (tlv).type_len = 0; (tlv).length_len = (length_len_); (tlv).value_len = (value_len_); } while (0); - -err_t snmp_asn1_dec_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv); -err_t snmp_asn1_dec_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *value); -err_t snmp_asn1_dec_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, s32_t *value); -err_t snmp_asn1_dec_oid(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *oid, u8_t *oid_len, u8_t oid_max_len); -err_t snmp_asn1_dec_raw(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u8_t *buf, u16_t *buf_len, u16_t buf_max_len); - -err_t snmp_ans1_enc_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv); - -void snmp_asn1_enc_length_cnt(u16_t length, u8_t *octets_needed); -void snmp_asn1_enc_u32t_cnt(u32_t value, u16_t *octets_needed); -void snmp_asn1_enc_s32t_cnt(s32_t value, u16_t *octets_needed); -void snmp_asn1_enc_oid_cnt(const u32_t *oid, u16_t oid_len, u16_t *octets_needed); -err_t snmp_asn1_enc_oid(struct snmp_pbuf_stream *pbuf_stream, const u32_t *oid, u16_t oid_len); -err_t snmp_asn1_enc_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, s32_t value); -err_t snmp_asn1_enc_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u32_t value); -err_t snmp_asn1_enc_raw(struct snmp_pbuf_stream *pbuf_stream, const u8_t *raw, u16_t raw_len); - -#if LWIP_HAVE_INT64 -err_t snmp_asn1_dec_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u64_t *value); -void snmp_asn1_enc_u64t_cnt(u64_t value, u16_t *octets_needed); -err_t snmp_asn1_enc_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u64_t value); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_SNMP */ - -#endif /* LWIP_HDR_APPS_SNMP_ASN1_H */ +/** + * @file + * Abstract Syntax Notation One (ISO 8824, 8825) codec. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * Copyright (c) 2016 Elias Oenal. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Christiaan Simons + * Martin Hentschel + * Elias Oenal + */ + +#ifndef LWIP_HDR_APPS_SNMP_ASN1_H +#define LWIP_HDR_APPS_SNMP_ASN1_H + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP + +#include "lwip/err.h" +#include "lwip/apps/snmp_core.h" +#include "snmp_pbuf_stream.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define SNMP_ASN1_TLV_INDEFINITE_LENGTH 0x80 + +#define SNMP_ASN1_CLASS_MASK 0xC0 +#define SNMP_ASN1_CONTENTTYPE_MASK 0x20 +#define SNMP_ASN1_DATATYPE_MASK 0x1F +#define SNMP_ASN1_DATATYPE_EXTENDED 0x1F /* DataType indicating that datatype is encoded in following bytes */ + +/* context specific (SNMP) tags (from SNMP spec. RFC1157 and RFC1905) */ +#define SNMP_ASN1_CONTEXT_PDU_GET_REQ 0 +#define SNMP_ASN1_CONTEXT_PDU_GET_NEXT_REQ 1 +#define SNMP_ASN1_CONTEXT_PDU_GET_RESP 2 +#define SNMP_ASN1_CONTEXT_PDU_SET_REQ 3 +#define SNMP_ASN1_CONTEXT_PDU_TRAP 4 +#define SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ 5 +#define SNMP_ASN1_CONTEXT_PDU_INFORM_REQ 6 +#define SNMP_ASN1_CONTEXT_PDU_V2_TRAP 7 +#define SNMP_ASN1_CONTEXT_PDU_REPORT 8 + +#define SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_OBJECT 0 +#define SNMP_ASN1_CONTEXT_VARBIND_END_OF_MIB_VIEW 2 + +struct snmp_asn1_tlv { + u8_t type; /* only U8 because extended types are not specified by SNMP */ + u8_t type_len; /* encoded length of 'type' field (normally 1) */ + u8_t length_len; /* indicates how many bytes are required to encode the 'value_len' field */ + u16_t value_len; /* encoded length of the value */ +}; +#define SNMP_ASN1_TLV_HDR_LENGTH(tlv) ((tlv).type_len + (tlv).length_len) +#define SNMP_ASN1_TLV_LENGTH(tlv) ((tlv).type_len + (tlv).length_len + (tlv).value_len) +#define SNMP_ASN1_SET_TLV_PARAMS(tlv, type_, length_len_, value_len_) do { (tlv).type = (type_); (tlv).type_len = 0; (tlv).length_len = (length_len_); (tlv).value_len = (value_len_); } while (0); + +err_t snmp_asn1_dec_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv); +err_t snmp_asn1_dec_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *value); +err_t snmp_asn1_dec_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, s32_t *value); +err_t snmp_asn1_dec_oid(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u32_t *oid, u8_t *oid_len, u8_t oid_max_len); +err_t snmp_asn1_dec_raw(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u8_t *buf, u16_t *buf_len, u16_t buf_max_len); + +err_t snmp_ans1_enc_tlv(struct snmp_pbuf_stream *pbuf_stream, struct snmp_asn1_tlv *tlv); + +void snmp_asn1_enc_length_cnt(u16_t length, u8_t *octets_needed); +void snmp_asn1_enc_u32t_cnt(u32_t value, u16_t *octets_needed); +void snmp_asn1_enc_s32t_cnt(s32_t value, u16_t *octets_needed); +void snmp_asn1_enc_oid_cnt(const u32_t *oid, u16_t oid_len, u16_t *octets_needed); +err_t snmp_asn1_enc_oid(struct snmp_pbuf_stream *pbuf_stream, const u32_t *oid, u16_t oid_len); +err_t snmp_asn1_enc_s32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, s32_t value); +err_t snmp_asn1_enc_u32t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u32_t value); +err_t snmp_asn1_enc_raw(struct snmp_pbuf_stream *pbuf_stream, const u8_t *raw, u16_t raw_len); + +#if LWIP_HAVE_INT64 +err_t snmp_asn1_dec_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t len, u64_t *value); +void snmp_asn1_enc_u64t_cnt(u64_t value, u16_t *octets_needed); +err_t snmp_asn1_enc_u64t(struct snmp_pbuf_stream *pbuf_stream, u16_t octets_needed, u64_t value); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_SNMP */ + +#endif /* LWIP_HDR_APPS_SNMP_ASN1_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core.c index 2b507168..987f1066 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core.c @@ -1,1353 +1,1353 @@ -/** - * @file - * MIB tree access/construction functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Christiaan Simons - * Martin Hentschel -*/ - -/** - * @defgroup snmp SNMPv2c/v3 agent - * @ingroup apps - * SNMPv2c and SNMPv3 compatible agent\n - * There is also a MIB compiler and a MIB viewer in lwIP contrib repository - * (lwip-contrib/apps/LwipMibCompiler).\n - * The agent implements the most important MIB2 MIBs including IPv6 support - * (interfaces, UDP, TCP, SNMP, ICMP, SYSTEM). IP MIB is an older version - * without IPv6 statistics (TODO).\n - * Rewritten by Martin Hentschel and - * Dirk Ziegelmeier \n - * - * 0 Agent Capabilities - * ==================== - * - * Features: - * --------- - * - SNMPv2c support. - * - SNMPv3 support (a port to ARM mbedtls is provided, LWIP_SNMP_V3_MBEDTLS option). - * - Low RAM usage - no memory pools, stack only. - * - MIB2 implementation is separated from SNMP stack. - * - Support for multiple MIBs (snmp_set_mibs() call) - e.g. for private MIB. - * - Simple and generic API for MIB implementation. - * - Comfortable node types and helper functions for scalar arrays and tables. - * - Counter64, bit and truthvalue datatype support. - * - Callbacks for SNMP writes e.g. to implement persistency. - * - Runs on two APIs: RAW and netconn. - * - Async API is gone - the stack now supports netconn API instead, - * so blocking operations can be done in MIB calls. - * SNMP runs in a worker thread when netconn API is used. - * - Simplified thread sync support for MIBs - useful when MIBs - * need to access variables shared with other threads where no locking is - * possible. Used in MIB2 to access lwIP stats from lwIP thread. - * - * MIB compiler (code generator): - * ------------------------------ - * - Provided in lwIP contrib repository. - * - Written in C#. MIB viewer used Windows Forms. - * - Developed on Windows with Visual Studio 2010. - * - Can be compiled and used on all platforms with http://www.monodevelop.com/. - * - Based on a heavily modified version of of SharpSnmpLib (a4bd05c6afb4) - * (https://sharpsnmplib.codeplex.com/SourceControl/network/forks/Nemo157/MIBParserUpdate). - * - MIB parser, C file generation framework and LWIP code generation are cleanly - * separated, which means the code may be useful as a base for code generation - * of other SNMP agents. - * - * Notes: - * ------ - * - Stack and MIB compiler were used to implement a Profinet device. - * Compiled/implemented MIBs: LLDP-MIB, LLDP-EXT-DOT3-MIB, LLDP-EXT-PNO-MIB. - * - * SNMPv1 per RFC1157 and SNMPv2c per RFC 3416 - * ------------------------------------------- - * Note the S in SNMP stands for "Simple". Note that "Simple" is - * relative. SNMP is simple compared to the complex ISO network - * management protocols CMIP (Common Management Information Protocol) - * and CMOT (CMip Over Tcp). - * - * SNMPv3 - * ------ - * When SNMPv3 is used, several functions from snmpv3.h must be implemented - * by the user. This is mainly user management and persistence handling. - * The sample provided in lwip-contrib is insecure, don't use it in production - * systems, especially the missing persistence for engine boots variable - * simplifies replay attacks. - * - * MIB II - * ------ - * The standard lwIP stack management information base. - * This is a required MIB, so this is always enabled. - * The groups EGP, CMOT and transmission are disabled by default. - * - * Most mib-2 objects are not writable except: - * sysName, sysLocation, sysContact, snmpEnableAuthenTraps. - * Writing to or changing the ARP and IP address and route - * tables is not possible. - * - * Note lwIP has a very limited notion of IP routing. It currently - * doen't have a route table and doesn't have a notion of the U,G,H flags. - * Instead lwIP uses the interface list with only one default interface - * acting as a single gateway interface (G) for the default route. - * - * The agent returns a "virtual table" with the default route 0.0.0.0 - * for the default interface and network routes (no H) for each - * network interface in the netif_list. - * All routes are considered to be up (U). - * - * Loading additional MIBs - * ----------------------- - * MIBs can only be added in compile-time, not in run-time. - * - * - * 1 Building the Agent - * ==================== - * First of all you'll need to add the following define - * to your local lwipopts.h: - * \#define LWIP_SNMP 1 - * - * and add the source files your makefile. - * - * Note you'll might need to adapt you network driver to update - * the mib2 variables for your interface. - * - * 2 Running the Agent - * =================== - * The following function calls must be made in your program to - * actually get the SNMP agent running. - * - * Before starting the agent you should supply pointers - * for sysContact, sysLocation, and snmpEnableAuthenTraps. - * You can do this by calling - * - * - snmp_mib2_set_syscontact() - * - snmp_mib2_set_syslocation() - * - snmp_set_auth_traps_enabled() - * - * You can register a callback which is called on successful write access: - * snmp_set_write_callback(). - * - * Additionally you may want to set - * - * - snmp_mib2_set_sysdescr() - * - snmp_set_device_enterprise_oid() - * - snmp_mib2_set_sysname() - * - * Also before starting the agent you need to setup - * one or more trap destinations using these calls: - * - * - snmp_trap_dst_enable() - * - snmp_trap_dst_ip_set() - * - * If you need more than MIB2, set the MIBs you want to use - * by snmp_set_mibs(). - * - * Finally, enable the agent by calling snmp_init() - * - * @defgroup snmp_core Core - * @ingroup snmp - * - * @defgroup snmp_traps Traps - * @ingroup snmp - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "snmp_core_priv.h" -#include "lwip/netif.h" -#include - - -#if (LWIP_SNMP && (SNMP_TRAP_DESTINATIONS<=0)) -#error "If you want to use SNMP, you have to define SNMP_TRAP_DESTINATIONS>=1 in your lwipopts.h" -#endif -#if (!LWIP_UDP && LWIP_SNMP) -#error "If you want to use SNMP, you have to define LWIP_UDP=1 in your lwipopts.h" -#endif -#if SNMP_MAX_OBJ_ID_LEN > 255 -#error "SNMP_MAX_OBJ_ID_LEN must fit into an u8_t" -#endif - -struct snmp_statistics snmp_stats; -static const struct snmp_obj_id snmp_device_enterprise_oid_default = {SNMP_DEVICE_ENTERPRISE_OID_LEN, SNMP_DEVICE_ENTERPRISE_OID}; -static const struct snmp_obj_id *snmp_device_enterprise_oid = &snmp_device_enterprise_oid_default; - -const u32_t snmp_zero_dot_zero_values[] = { 0, 0 }; -const struct snmp_obj_id_const_ref snmp_zero_dot_zero = { LWIP_ARRAYSIZE(snmp_zero_dot_zero_values), snmp_zero_dot_zero_values }; - -#if SNMP_LWIP_MIB2 && LWIP_SNMP_V3 -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_snmpv2_framework.h" -#include "lwip/apps/snmp_snmpv2_usm.h" -static const struct snmp_mib *const default_mibs[] = { &mib2, &snmpframeworkmib, &snmpusmmib }; -static u8_t snmp_num_mibs = LWIP_ARRAYSIZE(default_mibs); -#elif SNMP_LWIP_MIB2 -#include "lwip/apps/snmp_mib2.h" -static const struct snmp_mib *const default_mibs[] = { &mib2 }; -static u8_t snmp_num_mibs = LWIP_ARRAYSIZE(default_mibs); -#else -static const struct snmp_mib *const default_mibs[] = { NULL }; -static u8_t snmp_num_mibs = 0; -#endif - -/* List of known mibs */ -static struct snmp_mib const *const *snmp_mibs = default_mibs; - -/** - * @ingroup snmp_core - * Sets the MIBs to use. - * Example: call snmp_set_mibs() as follows: - * static const struct snmp_mib *my_snmp_mibs[] = { - * &mib2, - * &private_mib - * }; - * snmp_set_mibs(my_snmp_mibs, LWIP_ARRAYSIZE(my_snmp_mibs)); - */ -void -snmp_set_mibs(const struct snmp_mib **mibs, u8_t num_mibs) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("mibs pointer must be != NULL", (mibs != NULL)); - LWIP_ASSERT("num_mibs pointer must be != 0", (num_mibs != 0)); - snmp_mibs = mibs; - snmp_num_mibs = num_mibs; -} - -/** - * @ingroup snmp_core - * 'device enterprise oid' is used for 'device OID' field in trap PDU's (for identification of generating device) - * as well as for value returned by MIB-2 'sysObjectID' field (if internal MIB2 implementation is used). - * The 'device enterprise oid' shall point to an OID located under 'private-enterprises' branch (1.3.6.1.4.1.XXX). If a vendor - * wants to provide a custom object there, he has to get its own enterprise oid from IANA (http://www.iana.org). It - * is not allowed to use LWIP enterprise ID! - * In order to identify a specific device it is recommended to create a dedicated OID for each device type under its own - * enterprise oid. - * e.g. - * device a > 1.3.6.1.4.1.XXX(ent-oid).1(devices).1(device a) - * device b > 1.3.6.1.4.1.XXX(ent-oid).1(devices).2(device b) - * for more details see description of 'sysObjectID' field in RFC1213-MIB - */ -void snmp_set_device_enterprise_oid(const struct snmp_obj_id *device_enterprise_oid) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (device_enterprise_oid == NULL) { - snmp_device_enterprise_oid = &snmp_device_enterprise_oid_default; - } else { - snmp_device_enterprise_oid = device_enterprise_oid; - } -} - -/** - * @ingroup snmp_core - * Get 'device enterprise oid' - */ -const struct snmp_obj_id *snmp_get_device_enterprise_oid(void) -{ - LWIP_ASSERT_CORE_LOCKED(); - return snmp_device_enterprise_oid; -} - -#if LWIP_IPV4 -/** - * Conversion from InetAddressIPv4 oid to lwIP ip4_addr - * @param oid points to u32_t ident[4] input - * @param ip points to output struct - */ -u8_t -snmp_oid_to_ip4(const u32_t *oid, ip4_addr_t *ip) -{ - if ((oid[0] > 0xFF) || - (oid[1] > 0xFF) || - (oid[2] > 0xFF) || - (oid[3] > 0xFF)) { - ip4_addr_copy(*ip, *IP4_ADDR_ANY4); - return 0; - } - - IP4_ADDR(ip, oid[0], oid[1], oid[2], oid[3]); - return 1; -} - -/** - * Convert ip4_addr to InetAddressIPv4 (no InetAddressType) - * @param ip points to input struct - * @param oid points to u32_t ident[4] output - */ -void -snmp_ip4_to_oid(const ip4_addr_t *ip, u32_t *oid) -{ - oid[0] = ip4_addr1(ip); - oid[1] = ip4_addr2(ip); - oid[2] = ip4_addr3(ip); - oid[3] = ip4_addr4(ip); -} -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -/** - * Conversion from InetAddressIPv6 oid to lwIP ip6_addr - * @param oid points to u32_t oid[16] input - * @param ip points to output struct - */ -u8_t -snmp_oid_to_ip6(const u32_t *oid, ip6_addr_t *ip) -{ - if ((oid[0] > 0xFF) || - (oid[1] > 0xFF) || - (oid[2] > 0xFF) || - (oid[3] > 0xFF) || - (oid[4] > 0xFF) || - (oid[5] > 0xFF) || - (oid[6] > 0xFF) || - (oid[7] > 0xFF) || - (oid[8] > 0xFF) || - (oid[9] > 0xFF) || - (oid[10] > 0xFF) || - (oid[11] > 0xFF) || - (oid[12] > 0xFF) || - (oid[13] > 0xFF) || - (oid[14] > 0xFF) || - (oid[15] > 0xFF)) { - ip6_addr_set_any(ip); - return 0; - } - - ip->addr[0] = (oid[0] << 24) | (oid[1] << 16) | (oid[2] << 8) | (oid[3] << 0); - ip->addr[1] = (oid[4] << 24) | (oid[5] << 16) | (oid[6] << 8) | (oid[7] << 0); - ip->addr[2] = (oid[8] << 24) | (oid[9] << 16) | (oid[10] << 8) | (oid[11] << 0); - ip->addr[3] = (oid[12] << 24) | (oid[13] << 16) | (oid[14] << 8) | (oid[15] << 0); - return 1; -} - -/** - * Convert ip6_addr to InetAddressIPv6 (no InetAddressType) - * @param ip points to input struct - * @param oid points to u32_t ident[16] output - */ -void -snmp_ip6_to_oid(const ip6_addr_t *ip, u32_t *oid) -{ - oid[0] = (ip->addr[0] & 0xFF000000) >> 24; - oid[1] = (ip->addr[0] & 0x00FF0000) >> 16; - oid[2] = (ip->addr[0] & 0x0000FF00) >> 8; - oid[3] = (ip->addr[0] & 0x000000FF) >> 0; - oid[4] = (ip->addr[1] & 0xFF000000) >> 24; - oid[5] = (ip->addr[1] & 0x00FF0000) >> 16; - oid[6] = (ip->addr[1] & 0x0000FF00) >> 8; - oid[7] = (ip->addr[1] & 0x000000FF) >> 0; - oid[8] = (ip->addr[2] & 0xFF000000) >> 24; - oid[9] = (ip->addr[2] & 0x00FF0000) >> 16; - oid[10] = (ip->addr[2] & 0x0000FF00) >> 8; - oid[11] = (ip->addr[2] & 0x000000FF) >> 0; - oid[12] = (ip->addr[3] & 0xFF000000) >> 24; - oid[13] = (ip->addr[3] & 0x00FF0000) >> 16; - oid[14] = (ip->addr[3] & 0x0000FF00) >> 8; - oid[15] = (ip->addr[3] & 0x000000FF) >> 0; -} -#endif /* LWIP_IPV6 */ - -#if LWIP_IPV4 || LWIP_IPV6 -/** - * Convert to InetAddressType+InetAddress+InetPortNumber - * @param ip IP address - * @param port Port - * @param oid OID - * @return OID length - */ -u8_t -snmp_ip_port_to_oid(const ip_addr_t *ip, u16_t port, u32_t *oid) -{ - u8_t idx; - - idx = snmp_ip_to_oid(ip, oid); - oid[idx] = port; - idx++; - - return idx; -} - -/** - * Convert to InetAddressType+InetAddress - * @param ip IP address - * @param oid OID - * @return OID length - */ -u8_t -snmp_ip_to_oid(const ip_addr_t *ip, u32_t *oid) -{ - if (IP_IS_ANY_TYPE_VAL(*ip)) { - oid[0] = 0; /* any */ - oid[1] = 0; /* no IP OIDs follow */ - return 2; - } else if (IP_IS_V6(ip)) { -#if LWIP_IPV6 - oid[0] = 2; /* ipv6 */ - oid[1] = 16; /* 16 InetAddressIPv6 OIDs follow */ - snmp_ip6_to_oid(ip_2_ip6(ip), &oid[2]); - return 18; -#else /* LWIP_IPV6 */ - return 0; -#endif /* LWIP_IPV6 */ - } else { -#if LWIP_IPV4 - oid[0] = 1; /* ipv4 */ - oid[1] = 4; /* 4 InetAddressIPv4 OIDs follow */ - snmp_ip4_to_oid(ip_2_ip4(ip), &oid[2]); - return 6; -#else /* LWIP_IPV4 */ - return 0; -#endif /* LWIP_IPV4 */ - } -} - -/** - * Convert from InetAddressType+InetAddress to ip_addr_t - * @param oid OID - * @param oid_len OID length - * @param ip IP address - * @return Parsed OID length - */ -u8_t -snmp_oid_to_ip(const u32_t *oid, u8_t oid_len, ip_addr_t *ip) -{ - /* InetAddressType */ - if (oid_len < 1) { - return 0; - } - - if (oid[0] == 0) { /* any */ - /* 1x InetAddressType, 1x OID len */ - if (oid_len < 2) { - return 0; - } - if (oid[1] != 0) { - return 0; - } - - memset(ip, 0, sizeof(*ip)); - IP_SET_TYPE(ip, IPADDR_TYPE_ANY); - - return 2; - } else if (oid[0] == 1) { /* ipv4 */ -#if LWIP_IPV4 - /* 1x InetAddressType, 1x OID len, 4x InetAddressIPv4 */ - if (oid_len < 6) { - return 0; - } - - /* 4x ipv4 OID */ - if (oid[1] != 4) { - return 0; - } - - IP_SET_TYPE(ip, IPADDR_TYPE_V4); - if (!snmp_oid_to_ip4(&oid[2], ip_2_ip4(ip))) { - return 0; - } - - return 6; -#else /* LWIP_IPV4 */ - return 0; -#endif /* LWIP_IPV4 */ - } else if (oid[0] == 2) { /* ipv6 */ -#if LWIP_IPV6 - /* 1x InetAddressType, 1x OID len, 16x InetAddressIPv6 */ - if (oid_len < 18) { - return 0; - } - - /* 16x ipv6 OID */ - if (oid[1] != 16) { - return 0; - } - - IP_SET_TYPE(ip, IPADDR_TYPE_V6); - if (!snmp_oid_to_ip6(&oid[2], ip_2_ip6(ip))) { - return 0; - } - - return 18; -#else /* LWIP_IPV6 */ - return 0; -#endif /* LWIP_IPV6 */ - } else { /* unsupported InetAddressType */ - return 0; - } -} - -/** - * Convert from InetAddressType+InetAddress+InetPortNumber to ip_addr_t and u16_t - * @param oid OID - * @param oid_len OID length - * @param ip IP address - * @param port Port - * @return Parsed OID length - */ -u8_t -snmp_oid_to_ip_port(const u32_t *oid, u8_t oid_len, ip_addr_t *ip, u16_t *port) -{ - u8_t idx; - - /* InetAddressType + InetAddress */ - idx = snmp_oid_to_ip(&oid[0], oid_len, ip); - if (idx == 0) { - return 0; - } - - /* InetPortNumber */ - if (oid_len < (idx + 1)) { - return 0; - } - if (oid[idx] > 0xffff) { - return 0; - } - *port = (u16_t)oid[idx]; - idx++; - - return idx; -} - -#endif /* LWIP_IPV4 || LWIP_IPV6 */ - -/** - * Assign an OID to struct snmp_obj_id - * @param target Assignment target - * @param oid OID - * @param oid_len OID length - */ -void -snmp_oid_assign(struct snmp_obj_id *target, const u32_t *oid, u8_t oid_len) -{ - LWIP_ASSERT("oid_len <= SNMP_MAX_OBJ_ID_LEN", oid_len <= SNMP_MAX_OBJ_ID_LEN); - - target->len = oid_len; - - if (oid_len > 0) { - MEMCPY(target->id, oid, oid_len * sizeof(u32_t)); - } -} - -/** - * Prefix an OID to OID in struct snmp_obj_id - * @param target Assignment target to prefix - * @param oid OID - * @param oid_len OID length - */ -void -snmp_oid_prefix(struct snmp_obj_id *target, const u32_t *oid, u8_t oid_len) -{ - LWIP_ASSERT("target->len + oid_len <= SNMP_MAX_OBJ_ID_LEN", (target->len + oid_len) <= SNMP_MAX_OBJ_ID_LEN); - - if (oid_len > 0) { - /* move existing OID to make room at the beginning for OID to insert */ - int i; - for (i = target->len - 1; i >= 0; i--) { - target->id[i + oid_len] = target->id[i]; - } - - /* paste oid at the beginning */ - MEMCPY(target->id, oid, oid_len * sizeof(u32_t)); - } -} - -/** - * Combine two OIDs into struct snmp_obj_id - * @param target Assignmet target - * @param oid1 OID 1 - * @param oid1_len OID 1 length - * @param oid2 OID 2 - * @param oid2_len OID 2 length - */ -void -snmp_oid_combine(struct snmp_obj_id *target, const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) -{ - snmp_oid_assign(target, oid1, oid1_len); - snmp_oid_append(target, oid2, oid2_len); -} - -/** - * Append OIDs to struct snmp_obj_id - * @param target Assignment target to append to - * @param oid OID - * @param oid_len OID length - */ -void -snmp_oid_append(struct snmp_obj_id *target, const u32_t *oid, u8_t oid_len) -{ - LWIP_ASSERT("offset + oid_len <= SNMP_MAX_OBJ_ID_LEN", (target->len + oid_len) <= SNMP_MAX_OBJ_ID_LEN); - - if (oid_len > 0) { - MEMCPY(&target->id[target->len], oid, oid_len * sizeof(u32_t)); - target->len = (u8_t)(target->len + oid_len); - } -} - -/** - * Compare two OIDs - * @param oid1 OID 1 - * @param oid1_len OID 1 length - * @param oid2 OID 2 - * @param oid2_len OID 2 length - * @return -1: OID1<OID2 1: OID1 >OID2 0: equal - */ -s8_t -snmp_oid_compare(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) -{ - u8_t level = 0; - LWIP_ASSERT("'oid1' param must not be NULL or 'oid1_len' param be 0!", (oid1 != NULL) || (oid1_len == 0)); - LWIP_ASSERT("'oid2' param must not be NULL or 'oid2_len' param be 0!", (oid2 != NULL) || (oid2_len == 0)); - - while ((level < oid1_len) && (level < oid2_len)) { - if (*oid1 < *oid2) { - return -1; - } - if (*oid1 > *oid2) { - return 1; - } - - level++; - oid1++; - oid2++; - } - - /* common part of both OID's is equal, compare length */ - if (oid1_len < oid2_len) { - return -1; - } - if (oid1_len > oid2_len) { - return 1; - } - - /* they are equal */ - return 0; -} - - -/** - * Check of two OIDs are equal - * @param oid1 OID 1 - * @param oid1_len OID 1 length - * @param oid2 OID 2 - * @param oid2_len OID 2 length - * @return 1: equal 0: non-equal - */ -u8_t -snmp_oid_equal(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) -{ - return (snmp_oid_compare(oid1, oid1_len, oid2, oid2_len) == 0) ? 1 : 0; -} - -/** - * Convert netif to interface index - * @param netif netif - * @return index - */ -u8_t -netif_to_num(const struct netif *netif) -{ - return netif_get_index(netif); -} - -static const struct snmp_mib * -snmp_get_mib_from_oid(const u32_t *oid, u8_t oid_len) -{ - const u32_t *list_oid; - const u32_t *searched_oid; - u8_t i, l; - - u8_t max_match_len = 0; - const struct snmp_mib *matched_mib = NULL; - - LWIP_ASSERT("'oid' param must not be NULL!", (oid != NULL)); - - if (oid_len == 0) { - return NULL; - } - - for (i = 0; i < snmp_num_mibs; i++) { - LWIP_ASSERT("MIB array not initialized correctly", (snmp_mibs[i] != NULL)); - LWIP_ASSERT("MIB array not initialized correctly - base OID is NULL", (snmp_mibs[i]->base_oid != NULL)); - - if (oid_len >= snmp_mibs[i]->base_oid_len) { - l = snmp_mibs[i]->base_oid_len; - list_oid = snmp_mibs[i]->base_oid; - searched_oid = oid; - - while (l > 0) { - if (*list_oid != *searched_oid) { - break; - } - - l--; - list_oid++; - searched_oid++; - } - - if ((l == 0) && (snmp_mibs[i]->base_oid_len > max_match_len)) { - max_match_len = snmp_mibs[i]->base_oid_len; - matched_mib = snmp_mibs[i]; - } - } - } - - return matched_mib; -} - -static const struct snmp_mib * -snmp_get_next_mib(const u32_t *oid, u8_t oid_len) -{ - u8_t i; - const struct snmp_mib *next_mib = NULL; - - LWIP_ASSERT("'oid' param must not be NULL!", (oid != NULL)); - - if (oid_len == 0) { - return NULL; - } - - for (i = 0; i < snmp_num_mibs; i++) { - if (snmp_mibs[i]->base_oid != NULL) { - /* check if mib is located behind starting point */ - if (snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len, oid, oid_len) > 0) { - if ((next_mib == NULL) || - (snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len, - next_mib->base_oid, next_mib->base_oid_len) < 0)) { - next_mib = snmp_mibs[i]; - } - } - } - } - - return next_mib; -} - -static const struct snmp_mib * -snmp_get_mib_between(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) -{ - const struct snmp_mib *next_mib = snmp_get_next_mib(oid1, oid1_len); - - LWIP_ASSERT("'oid2' param must not be NULL!", (oid2 != NULL)); - LWIP_ASSERT("'oid2_len' param must be greater than 0!", (oid2_len > 0)); - - if (next_mib != NULL) { - if (snmp_oid_compare(next_mib->base_oid, next_mib->base_oid_len, oid2, oid2_len) < 0) { - return next_mib; - } - } - - return NULL; -} - -u8_t -snmp_get_node_instance_from_oid(const u32_t *oid, u8_t oid_len, struct snmp_node_instance *node_instance) -{ - u8_t result = SNMP_ERR_NOSUCHOBJECT; - const struct snmp_mib *mib; - const struct snmp_node *mn = NULL; - - mib = snmp_get_mib_from_oid(oid, oid_len); - if (mib != NULL) { - u8_t oid_instance_len; - - mn = snmp_mib_tree_resolve_exact(mib, oid, oid_len, &oid_instance_len); - if ((mn != NULL) && (mn->node_type != SNMP_NODE_TREE)) { - /* get instance */ - const struct snmp_leaf_node *leaf_node = (const struct snmp_leaf_node *)(const void *)mn; - - node_instance->node = mn; - snmp_oid_assign(&node_instance->instance_oid, oid + (oid_len - oid_instance_len), oid_instance_len); - - result = leaf_node->get_instance( - oid, - oid_len - oid_instance_len, - node_instance); - -#ifdef LWIP_DEBUG - if (result == SNMP_ERR_NOERROR) { - if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_READ) != 0) && (node_instance->get_value == NULL)) { - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is readable but no get_value function is specified\n")); - } - if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_WRITE) != 0) && (node_instance->set_value == NULL)) { - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is writable but no set_value and/or set_test function is specified\n")); - } - } -#endif - } - } - - return result; -} - -u8_t -snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_validate_node_instance_method validate_node_instance_method, void *validate_node_instance_arg, struct snmp_obj_id *node_oid, struct snmp_node_instance *node_instance) -{ - const struct snmp_mib *mib; - const struct snmp_node *mn = NULL; - const u32_t *start_oid = NULL; - u8_t start_oid_len = 0; - - /* resolve target MIB from passed OID */ - mib = snmp_get_mib_from_oid(oid, oid_len); - if (mib == NULL) { - /* passed OID does not reference any known MIB, start at the next closest MIB */ - mib = snmp_get_next_mib(oid, oid_len); - - if (mib != NULL) { - start_oid = mib->base_oid; - start_oid_len = mib->base_oid_len; - } - } else { - start_oid = oid; - start_oid_len = oid_len; - } - - /* resolve target node from MIB, skip to next MIB if no suitable node is found in current MIB */ - while ((mib != NULL) && (mn == NULL)) { - u8_t oid_instance_len; - - /* check if OID directly references a node inside current MIB, in this case we have to ask this node for the next instance */ - mn = snmp_mib_tree_resolve_exact(mib, start_oid, start_oid_len, &oid_instance_len); - if (mn != NULL) { - snmp_oid_assign(node_oid, start_oid, start_oid_len - oid_instance_len); /* set oid to node */ - snmp_oid_assign(&node_instance->instance_oid, start_oid + (start_oid_len - oid_instance_len), oid_instance_len); /* set (relative) instance oid */ - } else { - /* OID does not reference a node, search for the next closest node inside MIB; set instance_oid.len to zero because we want the first instance of this node */ - mn = snmp_mib_tree_resolve_next(mib, start_oid, start_oid_len, node_oid); - node_instance->instance_oid.len = 0; - } - - /* validate the node; if the node has no further instance or the returned instance is invalid, search for the next in MIB and validate again */ - node_instance->node = mn; - while (mn != NULL) { - u8_t result; - - /* clear fields which may have values from previous loops */ - node_instance->asn1_type = 0; - node_instance->access = SNMP_NODE_INSTANCE_NOT_ACCESSIBLE; - node_instance->get_value = NULL; - node_instance->set_test = NULL; - node_instance->set_value = NULL; - node_instance->release_instance = NULL; - node_instance->reference.ptr = NULL; - node_instance->reference_len = 0; - - result = ((const struct snmp_leaf_node *)(const void *)mn)->get_next_instance( - node_oid->id, - node_oid->len, - node_instance); - - if (result == SNMP_ERR_NOERROR) { -#ifdef LWIP_DEBUG - if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_READ) != 0) && (node_instance->get_value == NULL)) { - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is readable but no get_value function is specified\n")); - } - if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_WRITE) != 0) && (node_instance->set_value == NULL)) { - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is writable but no set_value function is specified\n")); - } -#endif - - /* validate node because the node may be not accessible for example (but let the caller decide what is valid */ - if ((validate_node_instance_method == NULL) || - (validate_node_instance_method(node_instance, validate_node_instance_arg) == SNMP_ERR_NOERROR)) { - /* node_oid "returns" the full result OID (including the instance part) */ - snmp_oid_append(node_oid, node_instance->instance_oid.id, node_instance->instance_oid.len); - break; - } - - if (node_instance->release_instance != NULL) { - node_instance->release_instance(node_instance); - } - /* - the instance itself is not valid, ask for next instance from same node. - we don't have to change any variables because node_instance->instance_oid is used as input (starting point) - as well as output (resulting next OID), so we have to simply call get_next_instance method again - */ - } else { - if (node_instance->release_instance != NULL) { - node_instance->release_instance(node_instance); - } - - /* the node has no further instance, skip to next node */ - mn = snmp_mib_tree_resolve_next(mib, node_oid->id, node_oid->len, &node_instance->instance_oid); /* misuse node_instance->instance_oid as tmp buffer */ - if (mn != NULL) { - /* prepare for next loop */ - snmp_oid_assign(node_oid, node_instance->instance_oid.id, node_instance->instance_oid.len); - node_instance->instance_oid.len = 0; - node_instance->node = mn; - } - } - } - - if (mn != NULL) { - /* - we found a suitable next node, - now we have to check if a inner MIB is located between the searched OID and the resulting OID. - this is possible because MIB's may be located anywhere in the global tree, that means also in - the subtree of another MIB (e.g. if searched OID is .2 and resulting OID is .4, then another - MIB having .3 as root node may exist) - */ - const struct snmp_mib *intermediate_mib; - intermediate_mib = snmp_get_mib_between(start_oid, start_oid_len, node_oid->id, node_oid->len); - - if (intermediate_mib != NULL) { - /* search for first node inside intermediate mib in next loop */ - if (node_instance->release_instance != NULL) { - node_instance->release_instance(node_instance); - } - - mn = NULL; - mib = intermediate_mib; - start_oid = mib->base_oid; - start_oid_len = mib->base_oid_len; - } - /* else { we found out target node } */ - } else { - /* - there is no further (suitable) node inside this MIB, search for the next MIB with following priority - 1. search for inner MIB's (whose root is located inside tree of current MIB) - 2. search for surrouding MIB's (where the current MIB is the inner MIB) and continue there if any - 3. take the next closest MIB (not being related to the current MIB) - */ - const struct snmp_mib *next_mib; - next_mib = snmp_get_next_mib(start_oid, start_oid_len); /* returns MIB's related to point 1 and 3 */ - - /* is the found MIB an inner MIB? (point 1) */ - if ((next_mib != NULL) && (next_mib->base_oid_len > mib->base_oid_len) && - (snmp_oid_compare(next_mib->base_oid, mib->base_oid_len, mib->base_oid, mib->base_oid_len) == 0)) { - /* yes it is -> continue at inner MIB */ - mib = next_mib; - start_oid = mib->base_oid; - start_oid_len = mib->base_oid_len; - } else { - /* check if there is a surrounding mib where to continue (point 2) (only possible if OID length > 1) */ - if (mib->base_oid_len > 1) { - mib = snmp_get_mib_from_oid(mib->base_oid, mib->base_oid_len - 1); - - if (mib == NULL) { - /* no surrounding mib, use next mib encountered above (point 3) */ - mib = next_mib; - - if (mib != NULL) { - start_oid = mib->base_oid; - start_oid_len = mib->base_oid_len; - } - } - /* else { start_oid stays the same because we want to continue from current offset in surrounding mib (point 2) } */ - } - } - } - } - - if (mib == NULL) { - /* loop is only left when mib == null (error) or mib_node != NULL (success) */ - return SNMP_ERR_ENDOFMIBVIEW; - } - - return SNMP_ERR_NOERROR; -} - -/** - * Searches tree for the supplied object identifier. - * - */ -const struct snmp_node * -snmp_mib_tree_resolve_exact(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, u8_t *oid_instance_len) -{ - const struct snmp_node *const *node = &mib->root_node; - u8_t oid_offset = mib->base_oid_len; - - while ((oid_offset < oid_len) && ((*node)->node_type == SNMP_NODE_TREE)) { - /* search for matching sub node */ - u32_t subnode_oid = *(oid + oid_offset); - - u32_t i = (*(const struct snmp_tree_node * const *)node)->subnode_count; - node = (*(const struct snmp_tree_node * const *)node)->subnodes; - while ((i > 0) && ((*node)->oid != subnode_oid)) { - node++; - i--; - } - - if (i == 0) { - /* no matching subnode found */ - return NULL; - } - - oid_offset++; - } - - if ((*node)->node_type != SNMP_NODE_TREE) { - /* we found a leaf node */ - *oid_instance_len = oid_len - oid_offset; - return (*node); - } - - return NULL; -} - -const struct snmp_node * -snmp_mib_tree_resolve_next(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, struct snmp_obj_id *oidret) -{ - u8_t oid_offset = mib->base_oid_len; - const struct snmp_node *const *node; - const struct snmp_tree_node *node_stack[SNMP_MAX_OBJ_ID_LEN]; - s32_t nsi = 0; /* NodeStackIndex */ - u32_t subnode_oid; - - if (mib->root_node->node_type != SNMP_NODE_TREE) { - /* a next operation on a mib with only a leaf node will always return NULL because there is no other node */ - return NULL; - } - - /* first build node stack related to passed oid (as far as possible), then go backwards to determine the next node */ - node_stack[nsi] = (const struct snmp_tree_node *)(const void *)mib->root_node; - while (oid_offset < oid_len) { - /* search for matching sub node */ - u32_t i = node_stack[nsi]->subnode_count; - node = node_stack[nsi]->subnodes; - - subnode_oid = *(oid + oid_offset); - - while ((i > 0) && ((*node)->oid != subnode_oid)) { - node++; - i--; - } - - if ((i == 0) || ((*node)->node_type != SNMP_NODE_TREE)) { - /* no (matching) tree-subnode found */ - break; - } - nsi++; - node_stack[nsi] = (const struct snmp_tree_node *)(const void *)(*node); - - oid_offset++; - } - - - if (oid_offset >= oid_len) { - /* passed oid references a tree node -> return first useable sub node of it */ - subnode_oid = 0; - } else { - subnode_oid = *(oid + oid_offset) + 1; - } - - while (nsi >= 0) { - const struct snmp_node *subnode = NULL; - - /* find next node on current level */ - s32_t i = node_stack[nsi]->subnode_count; - node = node_stack[nsi]->subnodes; - while (i > 0) { - if ((*node)->oid == subnode_oid) { - subnode = *node; - break; - } else if (((*node)->oid > subnode_oid) && ((subnode == NULL) || ((*node)->oid < subnode->oid))) { - subnode = *node; - } - - node++; - i--; - } - - if (subnode == NULL) { - /* no further node found on this level, go one level up and start searching with index of current node*/ - subnode_oid = node_stack[nsi]->node.oid + 1; - nsi--; - } else { - if (subnode->node_type == SNMP_NODE_TREE) { - /* next is a tree node, go into it and start searching */ - nsi++; - node_stack[nsi] = (const struct snmp_tree_node *)(const void *)subnode; - subnode_oid = 0; - } else { - /* we found a leaf node -> fill oidret and return it */ - snmp_oid_assign(oidret, mib->base_oid, mib->base_oid_len); - i = 1; - while (i <= nsi) { - oidret->id[oidret->len] = node_stack[i]->node.oid; - oidret->len++; - i++; - } - - oidret->id[oidret->len] = subnode->oid; - oidret->len++; - - return subnode; - } - } - } - - return NULL; -} - -/** initialize struct next_oid_state using this function before passing it to next_oid_check */ -void -snmp_next_oid_init(struct snmp_next_oid_state *state, - const u32_t *start_oid, u8_t start_oid_len, - u32_t *next_oid_buf, u8_t next_oid_max_len) -{ - state->start_oid = start_oid; - state->start_oid_len = start_oid_len; - state->next_oid = next_oid_buf; - state->next_oid_len = 0; - state->next_oid_max_len = next_oid_max_len; - state->status = SNMP_NEXT_OID_STATUS_NO_MATCH; -} - -/** checks if the passed incomplete OID may be a possible candidate for snmp_next_oid_check(); -this methid is intended if the complete OID is not yet known but it is very expensive to build it up, -so it is possible to test the starting part before building up the complete oid and pass it to snmp_next_oid_check()*/ -u8_t -snmp_next_oid_precheck(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len) -{ - if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL) { - u8_t start_oid_len = (oid_len < state->start_oid_len) ? oid_len : state->start_oid_len; - - /* check passed OID is located behind start offset */ - if (snmp_oid_compare(oid, oid_len, state->start_oid, start_oid_len) >= 0) { - /* check if new oid is located closer to start oid than current closest oid */ - if ((state->status == SNMP_NEXT_OID_STATUS_NO_MATCH) || - (snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0)) { - return 1; - } - } - } - - return 0; -} - -/** checks the passed OID if it is a candidate to be the next one (get_next); returns !=0 if passed oid is currently closest, otherwise 0 */ -u8_t -snmp_next_oid_check(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len, void *reference) -{ - /* do not overwrite a fail result */ - if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL) { - /* check passed OID is located behind start offset */ - if (snmp_oid_compare(oid, oid_len, state->start_oid, state->start_oid_len) > 0) { - /* check if new oid is located closer to start oid than current closest oid */ - if ((state->status == SNMP_NEXT_OID_STATUS_NO_MATCH) || - (snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0)) { - if (oid_len <= state->next_oid_max_len) { - MEMCPY(state->next_oid, oid, oid_len * sizeof(u32_t)); - state->next_oid_len = oid_len; - state->status = SNMP_NEXT_OID_STATUS_SUCCESS; - state->reference = reference; - return 1; - } else { - state->status = SNMP_NEXT_OID_STATUS_BUF_TO_SMALL; - } - } - } - } - - return 0; -} - -u8_t -snmp_oid_in_range(const u32_t *oid_in, u8_t oid_len, const struct snmp_oid_range *oid_ranges, u8_t oid_ranges_len) -{ - u8_t i; - - if (oid_len != oid_ranges_len) { - return 0; - } - - for (i = 0; i < oid_ranges_len; i++) { - if ((oid_in[i] < oid_ranges[i].min) || (oid_in[i] > oid_ranges[i].max)) { - return 0; - } - } - - return 1; -} - -snmp_err_t -snmp_set_test_ok(struct snmp_node_instance *instance, u16_t value_len, void *value) -{ - LWIP_UNUSED_ARG(instance); - LWIP_UNUSED_ARG(value_len); - LWIP_UNUSED_ARG(value); - - return SNMP_ERR_NOERROR; -} - -/** - * Decodes BITS pseudotype value from ASN.1 OctetString. - * - * @note Because BITS pseudo type is encoded as OCTET STRING, it cannot directly - * be encoded/decoded by the agent. Instead call this function as required from - * get/test/set methods. - * - * @param buf points to a buffer holding the ASN1 octet string - * @param buf_len length of octet string - * @param bit_value decoded Bit value with Bit0 == LSB - * @return ERR_OK if successful, ERR_ARG if bit value contains more than 32 bit - */ -err_t -snmp_decode_bits(const u8_t *buf, u32_t buf_len, u32_t *bit_value) -{ - u8_t b; - u8_t bits_processed = 0; - *bit_value = 0; - - while (buf_len > 0) { - /* any bit set in this byte? */ - if (*buf != 0x00) { - if (bits_processed >= 32) { - /* accept more than 4 bytes, but only when no bits are set */ - return ERR_VAL; - } - - b = *buf; - do { - if (b & 0x80) { - *bit_value |= (1 << bits_processed); - } - bits_processed++; - b <<= 1; - } while ((bits_processed & 0x07) != 0); /* &0x07 -> % 8 */ - } else { - bits_processed += 8; - } - - buf_len--; - buf++; - } - - return ERR_OK; -} - -err_t -snmp_decode_truthvalue(const s32_t *asn1_value, u8_t *bool_value) -{ - /* defined by RFC1443: - TruthValue ::= TEXTUAL-CONVENTION - STATUS current - DESCRIPTION - "Represents a boolean value." - SYNTAX INTEGER { true(1), false(2) } - */ - - if ((asn1_value == NULL) || (bool_value == NULL)) { - return ERR_ARG; - } - - if (*asn1_value == 1) { - *bool_value = 1; - } else if (*asn1_value == 2) { - *bool_value = 0; - } else { - return ERR_VAL; - } - - return ERR_OK; -} - -/** - * Encodes BITS pseudotype value into ASN.1 OctetString. - * - * @note Because BITS pseudo type is encoded as OCTET STRING, it cannot directly - * be encoded/decoded by the agent. Instead call this function as required from - * get/test/set methods. - * - * @param buf points to a buffer where the resulting ASN1 octet string is stored to - * @param buf_len max length of the bufffer - * @param bit_value Bit value to encode with Bit0 == LSB - * @param bit_count Number of possible bits for the bit value (according to rfc we have to send all bits independant from their truth value) - * @return number of bytes used from buffer to store the resulting OctetString - */ -u8_t -snmp_encode_bits(u8_t *buf, u32_t buf_len, u32_t bit_value, u8_t bit_count) -{ - u8_t len = 0; - u8_t min_bytes = (bit_count + 7) >> 3; /* >>3 -> / 8 */ - - while ((buf_len > 0) && (bit_value != 0x00)) { - s8_t i = 7; - *buf = 0x00; - while (i >= 0) { - if (bit_value & 0x01) { - *buf |= 0x01; - } - - if (i > 0) { - *buf <<= 1; - } - - bit_value >>= 1; - i--; - } - - buf++; - buf_len--; - len++; - } - - if (len < min_bytes) { - buf += len; - buf_len -= len; - - while ((len < min_bytes) && (buf_len > 0)) { - *buf = 0x00; - buf++; - buf_len--; - len++; - } - } - - return len; -} - -u8_t -snmp_encode_truthvalue(s32_t *asn1_value, u32_t bool_value) -{ - /* defined by RFC1443: - TruthValue ::= TEXTUAL-CONVENTION - STATUS current - DESCRIPTION - "Represents a boolean value." - SYNTAX INTEGER { true(1), false(2) } - */ - - if (asn1_value == NULL) { - return 0; - } - - if (bool_value) { - *asn1_value = 1; /* defined by RFC1443 */ - } else { - *asn1_value = 2; /* defined by RFC1443 */ - } - - return sizeof(s32_t); -} - -#endif /* LWIP_SNMP */ +/** + * @file + * MIB tree access/construction functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Christiaan Simons + * Martin Hentschel +*/ + +/** + * @defgroup snmp SNMPv2c/v3 agent + * @ingroup apps + * SNMPv2c and SNMPv3 compatible agent\n + * There is also a MIB compiler and a MIB viewer in lwIP contrib repository + * (lwip-contrib/apps/LwipMibCompiler).\n + * The agent implements the most important MIB2 MIBs including IPv6 support + * (interfaces, UDP, TCP, SNMP, ICMP, SYSTEM). IP MIB is an older version + * without IPv6 statistics (TODO).\n + * Rewritten by Martin Hentschel and + * Dirk Ziegelmeier \n + * + * 0 Agent Capabilities + * ==================== + * + * Features: + * --------- + * - SNMPv2c support. + * - SNMPv3 support (a port to ARM mbedtls is provided, LWIP_SNMP_V3_MBEDTLS option). + * - Low RAM usage - no memory pools, stack only. + * - MIB2 implementation is separated from SNMP stack. + * - Support for multiple MIBs (snmp_set_mibs() call) - e.g. for private MIB. + * - Simple and generic API for MIB implementation. + * - Comfortable node types and helper functions for scalar arrays and tables. + * - Counter64, bit and truthvalue datatype support. + * - Callbacks for SNMP writes e.g. to implement persistency. + * - Runs on two APIs: RAW and netconn. + * - Async API is gone - the stack now supports netconn API instead, + * so blocking operations can be done in MIB calls. + * SNMP runs in a worker thread when netconn API is used. + * - Simplified thread sync support for MIBs - useful when MIBs + * need to access variables shared with other threads where no locking is + * possible. Used in MIB2 to access lwIP stats from lwIP thread. + * + * MIB compiler (code generator): + * ------------------------------ + * - Provided in lwIP contrib repository. + * - Written in C#. MIB viewer used Windows Forms. + * - Developed on Windows with Visual Studio 2010. + * - Can be compiled and used on all platforms with http://www.monodevelop.com/. + * - Based on a heavily modified version of of SharpSnmpLib (a4bd05c6afb4) + * (https://sharpsnmplib.codeplex.com/SourceControl/network/forks/Nemo157/MIBParserUpdate). + * - MIB parser, C file generation framework and LWIP code generation are cleanly + * separated, which means the code may be useful as a base for code generation + * of other SNMP agents. + * + * Notes: + * ------ + * - Stack and MIB compiler were used to implement a Profinet device. + * Compiled/implemented MIBs: LLDP-MIB, LLDP-EXT-DOT3-MIB, LLDP-EXT-PNO-MIB. + * + * SNMPv1 per RFC1157 and SNMPv2c per RFC 3416 + * ------------------------------------------- + * Note the S in SNMP stands for "Simple". Note that "Simple" is + * relative. SNMP is simple compared to the complex ISO network + * management protocols CMIP (Common Management Information Protocol) + * and CMOT (CMip Over Tcp). + * + * SNMPv3 + * ------ + * When SNMPv3 is used, several functions from snmpv3.h must be implemented + * by the user. This is mainly user management and persistence handling. + * The sample provided in lwip-contrib is insecure, don't use it in production + * systems, especially the missing persistence for engine boots variable + * simplifies replay attacks. + * + * MIB II + * ------ + * The standard lwIP stack management information base. + * This is a required MIB, so this is always enabled. + * The groups EGP, CMOT and transmission are disabled by default. + * + * Most mib-2 objects are not writable except: + * sysName, sysLocation, sysContact, snmpEnableAuthenTraps. + * Writing to or changing the ARP and IP address and route + * tables is not possible. + * + * Note lwIP has a very limited notion of IP routing. It currently + * doen't have a route table and doesn't have a notion of the U,G,H flags. + * Instead lwIP uses the interface list with only one default interface + * acting as a single gateway interface (G) for the default route. + * + * The agent returns a "virtual table" with the default route 0.0.0.0 + * for the default interface and network routes (no H) for each + * network interface in the netif_list. + * All routes are considered to be up (U). + * + * Loading additional MIBs + * ----------------------- + * MIBs can only be added in compile-time, not in run-time. + * + * + * 1 Building the Agent + * ==================== + * First of all you'll need to add the following define + * to your local lwipopts.h: + * \#define LWIP_SNMP 1 + * + * and add the source files your makefile. + * + * Note you'll might need to adapt you network driver to update + * the mib2 variables for your interface. + * + * 2 Running the Agent + * =================== + * The following function calls must be made in your program to + * actually get the SNMP agent running. + * + * Before starting the agent you should supply pointers + * for sysContact, sysLocation, and snmpEnableAuthenTraps. + * You can do this by calling + * + * - snmp_mib2_set_syscontact() + * - snmp_mib2_set_syslocation() + * - snmp_set_auth_traps_enabled() + * + * You can register a callback which is called on successful write access: + * snmp_set_write_callback(). + * + * Additionally you may want to set + * + * - snmp_mib2_set_sysdescr() + * - snmp_set_device_enterprise_oid() + * - snmp_mib2_set_sysname() + * + * Also before starting the agent you need to setup + * one or more trap destinations using these calls: + * + * - snmp_trap_dst_enable() + * - snmp_trap_dst_ip_set() + * + * If you need more than MIB2, set the MIBs you want to use + * by snmp_set_mibs(). + * + * Finally, enable the agent by calling snmp_init() + * + * @defgroup snmp_core Core + * @ingroup snmp + * + * @defgroup snmp_traps Traps + * @ingroup snmp + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "snmp_core_priv.h" +#include "lwip/netif.h" +#include + + +#if (LWIP_SNMP && (SNMP_TRAP_DESTINATIONS<=0)) +#error "If you want to use SNMP, you have to define SNMP_TRAP_DESTINATIONS>=1 in your lwipopts.h" +#endif +#if (!LWIP_UDP && LWIP_SNMP) +#error "If you want to use SNMP, you have to define LWIP_UDP=1 in your lwipopts.h" +#endif +#if SNMP_MAX_OBJ_ID_LEN > 255 +#error "SNMP_MAX_OBJ_ID_LEN must fit into an u8_t" +#endif + +struct snmp_statistics snmp_stats; +static const struct snmp_obj_id snmp_device_enterprise_oid_default = {SNMP_DEVICE_ENTERPRISE_OID_LEN, SNMP_DEVICE_ENTERPRISE_OID}; +static const struct snmp_obj_id *snmp_device_enterprise_oid = &snmp_device_enterprise_oid_default; + +const u32_t snmp_zero_dot_zero_values[] = { 0, 0 }; +const struct snmp_obj_id_const_ref snmp_zero_dot_zero = { LWIP_ARRAYSIZE(snmp_zero_dot_zero_values), snmp_zero_dot_zero_values }; + +#if SNMP_LWIP_MIB2 && LWIP_SNMP_V3 +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_snmpv2_framework.h" +#include "lwip/apps/snmp_snmpv2_usm.h" +static const struct snmp_mib *const default_mibs[] = { &mib2, &snmpframeworkmib, &snmpusmmib }; +static u8_t snmp_num_mibs = LWIP_ARRAYSIZE(default_mibs); +#elif SNMP_LWIP_MIB2 +#include "lwip/apps/snmp_mib2.h" +static const struct snmp_mib *const default_mibs[] = { &mib2 }; +static u8_t snmp_num_mibs = LWIP_ARRAYSIZE(default_mibs); +#else +static const struct snmp_mib *const default_mibs[] = { NULL }; +static u8_t snmp_num_mibs = 0; +#endif + +/* List of known mibs */ +static struct snmp_mib const *const *snmp_mibs = default_mibs; + +/** + * @ingroup snmp_core + * Sets the MIBs to use. + * Example: call snmp_set_mibs() as follows: + * static const struct snmp_mib *my_snmp_mibs[] = { + * &mib2, + * &private_mib + * }; + * snmp_set_mibs(my_snmp_mibs, LWIP_ARRAYSIZE(my_snmp_mibs)); + */ +void +snmp_set_mibs(const struct snmp_mib **mibs, u8_t num_mibs) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("mibs pointer must be != NULL", (mibs != NULL)); + LWIP_ASSERT("num_mibs pointer must be != 0", (num_mibs != 0)); + snmp_mibs = mibs; + snmp_num_mibs = num_mibs; +} + +/** + * @ingroup snmp_core + * 'device enterprise oid' is used for 'device OID' field in trap PDU's (for identification of generating device) + * as well as for value returned by MIB-2 'sysObjectID' field (if internal MIB2 implementation is used). + * The 'device enterprise oid' shall point to an OID located under 'private-enterprises' branch (1.3.6.1.4.1.XXX). If a vendor + * wants to provide a custom object there, he has to get its own enterprise oid from IANA (http://www.iana.org). It + * is not allowed to use LWIP enterprise ID! + * In order to identify a specific device it is recommended to create a dedicated OID for each device type under its own + * enterprise oid. + * e.g. + * device a > 1.3.6.1.4.1.XXX(ent-oid).1(devices).1(device a) + * device b > 1.3.6.1.4.1.XXX(ent-oid).1(devices).2(device b) + * for more details see description of 'sysObjectID' field in RFC1213-MIB + */ +void snmp_set_device_enterprise_oid(const struct snmp_obj_id *device_enterprise_oid) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (device_enterprise_oid == NULL) { + snmp_device_enterprise_oid = &snmp_device_enterprise_oid_default; + } else { + snmp_device_enterprise_oid = device_enterprise_oid; + } +} + +/** + * @ingroup snmp_core + * Get 'device enterprise oid' + */ +const struct snmp_obj_id *snmp_get_device_enterprise_oid(void) +{ + LWIP_ASSERT_CORE_LOCKED(); + return snmp_device_enterprise_oid; +} + +#if LWIP_IPV4 +/** + * Conversion from InetAddressIPv4 oid to lwIP ip4_addr + * @param oid points to u32_t ident[4] input + * @param ip points to output struct + */ +u8_t +snmp_oid_to_ip4(const u32_t *oid, ip4_addr_t *ip) +{ + if ((oid[0] > 0xFF) || + (oid[1] > 0xFF) || + (oid[2] > 0xFF) || + (oid[3] > 0xFF)) { + ip4_addr_copy(*ip, *IP4_ADDR_ANY4); + return 0; + } + + IP4_ADDR(ip, oid[0], oid[1], oid[2], oid[3]); + return 1; +} + +/** + * Convert ip4_addr to InetAddressIPv4 (no InetAddressType) + * @param ip points to input struct + * @param oid points to u32_t ident[4] output + */ +void +snmp_ip4_to_oid(const ip4_addr_t *ip, u32_t *oid) +{ + oid[0] = ip4_addr1(ip); + oid[1] = ip4_addr2(ip); + oid[2] = ip4_addr3(ip); + oid[3] = ip4_addr4(ip); +} +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +/** + * Conversion from InetAddressIPv6 oid to lwIP ip6_addr + * @param oid points to u32_t oid[16] input + * @param ip points to output struct + */ +u8_t +snmp_oid_to_ip6(const u32_t *oid, ip6_addr_t *ip) +{ + if ((oid[0] > 0xFF) || + (oid[1] > 0xFF) || + (oid[2] > 0xFF) || + (oid[3] > 0xFF) || + (oid[4] > 0xFF) || + (oid[5] > 0xFF) || + (oid[6] > 0xFF) || + (oid[7] > 0xFF) || + (oid[8] > 0xFF) || + (oid[9] > 0xFF) || + (oid[10] > 0xFF) || + (oid[11] > 0xFF) || + (oid[12] > 0xFF) || + (oid[13] > 0xFF) || + (oid[14] > 0xFF) || + (oid[15] > 0xFF)) { + ip6_addr_set_any(ip); + return 0; + } + + ip->addr[0] = (oid[0] << 24) | (oid[1] << 16) | (oid[2] << 8) | (oid[3] << 0); + ip->addr[1] = (oid[4] << 24) | (oid[5] << 16) | (oid[6] << 8) | (oid[7] << 0); + ip->addr[2] = (oid[8] << 24) | (oid[9] << 16) | (oid[10] << 8) | (oid[11] << 0); + ip->addr[3] = (oid[12] << 24) | (oid[13] << 16) | (oid[14] << 8) | (oid[15] << 0); + return 1; +} + +/** + * Convert ip6_addr to InetAddressIPv6 (no InetAddressType) + * @param ip points to input struct + * @param oid points to u32_t ident[16] output + */ +void +snmp_ip6_to_oid(const ip6_addr_t *ip, u32_t *oid) +{ + oid[0] = (ip->addr[0] & 0xFF000000) >> 24; + oid[1] = (ip->addr[0] & 0x00FF0000) >> 16; + oid[2] = (ip->addr[0] & 0x0000FF00) >> 8; + oid[3] = (ip->addr[0] & 0x000000FF) >> 0; + oid[4] = (ip->addr[1] & 0xFF000000) >> 24; + oid[5] = (ip->addr[1] & 0x00FF0000) >> 16; + oid[6] = (ip->addr[1] & 0x0000FF00) >> 8; + oid[7] = (ip->addr[1] & 0x000000FF) >> 0; + oid[8] = (ip->addr[2] & 0xFF000000) >> 24; + oid[9] = (ip->addr[2] & 0x00FF0000) >> 16; + oid[10] = (ip->addr[2] & 0x0000FF00) >> 8; + oid[11] = (ip->addr[2] & 0x000000FF) >> 0; + oid[12] = (ip->addr[3] & 0xFF000000) >> 24; + oid[13] = (ip->addr[3] & 0x00FF0000) >> 16; + oid[14] = (ip->addr[3] & 0x0000FF00) >> 8; + oid[15] = (ip->addr[3] & 0x000000FF) >> 0; +} +#endif /* LWIP_IPV6 */ + +#if LWIP_IPV4 || LWIP_IPV6 +/** + * Convert to InetAddressType+InetAddress+InetPortNumber + * @param ip IP address + * @param port Port + * @param oid OID + * @return OID length + */ +u8_t +snmp_ip_port_to_oid(const ip_addr_t *ip, u16_t port, u32_t *oid) +{ + u8_t idx; + + idx = snmp_ip_to_oid(ip, oid); + oid[idx] = port; + idx++; + + return idx; +} + +/** + * Convert to InetAddressType+InetAddress + * @param ip IP address + * @param oid OID + * @return OID length + */ +u8_t +snmp_ip_to_oid(const ip_addr_t *ip, u32_t *oid) +{ + if (IP_IS_ANY_TYPE_VAL(*ip)) { + oid[0] = 0; /* any */ + oid[1] = 0; /* no IP OIDs follow */ + return 2; + } else if (IP_IS_V6(ip)) { +#if LWIP_IPV6 + oid[0] = 2; /* ipv6 */ + oid[1] = 16; /* 16 InetAddressIPv6 OIDs follow */ + snmp_ip6_to_oid(ip_2_ip6(ip), &oid[2]); + return 18; +#else /* LWIP_IPV6 */ + return 0; +#endif /* LWIP_IPV6 */ + } else { +#if LWIP_IPV4 + oid[0] = 1; /* ipv4 */ + oid[1] = 4; /* 4 InetAddressIPv4 OIDs follow */ + snmp_ip4_to_oid(ip_2_ip4(ip), &oid[2]); + return 6; +#else /* LWIP_IPV4 */ + return 0; +#endif /* LWIP_IPV4 */ + } +} + +/** + * Convert from InetAddressType+InetAddress to ip_addr_t + * @param oid OID + * @param oid_len OID length + * @param ip IP address + * @return Parsed OID length + */ +u8_t +snmp_oid_to_ip(const u32_t *oid, u8_t oid_len, ip_addr_t *ip) +{ + /* InetAddressType */ + if (oid_len < 1) { + return 0; + } + + if (oid[0] == 0) { /* any */ + /* 1x InetAddressType, 1x OID len */ + if (oid_len < 2) { + return 0; + } + if (oid[1] != 0) { + return 0; + } + + memset(ip, 0, sizeof(*ip)); + IP_SET_TYPE(ip, IPADDR_TYPE_ANY); + + return 2; + } else if (oid[0] == 1) { /* ipv4 */ +#if LWIP_IPV4 + /* 1x InetAddressType, 1x OID len, 4x InetAddressIPv4 */ + if (oid_len < 6) { + return 0; + } + + /* 4x ipv4 OID */ + if (oid[1] != 4) { + return 0; + } + + IP_SET_TYPE(ip, IPADDR_TYPE_V4); + if (!snmp_oid_to_ip4(&oid[2], ip_2_ip4(ip))) { + return 0; + } + + return 6; +#else /* LWIP_IPV4 */ + return 0; +#endif /* LWIP_IPV4 */ + } else if (oid[0] == 2) { /* ipv6 */ +#if LWIP_IPV6 + /* 1x InetAddressType, 1x OID len, 16x InetAddressIPv6 */ + if (oid_len < 18) { + return 0; + } + + /* 16x ipv6 OID */ + if (oid[1] != 16) { + return 0; + } + + IP_SET_TYPE(ip, IPADDR_TYPE_V6); + if (!snmp_oid_to_ip6(&oid[2], ip_2_ip6(ip))) { + return 0; + } + + return 18; +#else /* LWIP_IPV6 */ + return 0; +#endif /* LWIP_IPV6 */ + } else { /* unsupported InetAddressType */ + return 0; + } +} + +/** + * Convert from InetAddressType+InetAddress+InetPortNumber to ip_addr_t and u16_t + * @param oid OID + * @param oid_len OID length + * @param ip IP address + * @param port Port + * @return Parsed OID length + */ +u8_t +snmp_oid_to_ip_port(const u32_t *oid, u8_t oid_len, ip_addr_t *ip, u16_t *port) +{ + u8_t idx; + + /* InetAddressType + InetAddress */ + idx = snmp_oid_to_ip(&oid[0], oid_len, ip); + if (idx == 0) { + return 0; + } + + /* InetPortNumber */ + if (oid_len < (idx + 1)) { + return 0; + } + if (oid[idx] > 0xffff) { + return 0; + } + *port = (u16_t)oid[idx]; + idx++; + + return idx; +} + +#endif /* LWIP_IPV4 || LWIP_IPV6 */ + +/** + * Assign an OID to struct snmp_obj_id + * @param target Assignment target + * @param oid OID + * @param oid_len OID length + */ +void +snmp_oid_assign(struct snmp_obj_id *target, const u32_t *oid, u8_t oid_len) +{ + LWIP_ASSERT("oid_len <= SNMP_MAX_OBJ_ID_LEN", oid_len <= SNMP_MAX_OBJ_ID_LEN); + + target->len = oid_len; + + if (oid_len > 0) { + MEMCPY(target->id, oid, oid_len * sizeof(u32_t)); + } +} + +/** + * Prefix an OID to OID in struct snmp_obj_id + * @param target Assignment target to prefix + * @param oid OID + * @param oid_len OID length + */ +void +snmp_oid_prefix(struct snmp_obj_id *target, const u32_t *oid, u8_t oid_len) +{ + LWIP_ASSERT("target->len + oid_len <= SNMP_MAX_OBJ_ID_LEN", (target->len + oid_len) <= SNMP_MAX_OBJ_ID_LEN); + + if (oid_len > 0) { + /* move existing OID to make room at the beginning for OID to insert */ + int i; + for (i = target->len - 1; i >= 0; i--) { + target->id[i + oid_len] = target->id[i]; + } + + /* paste oid at the beginning */ + MEMCPY(target->id, oid, oid_len * sizeof(u32_t)); + } +} + +/** + * Combine two OIDs into struct snmp_obj_id + * @param target Assignmet target + * @param oid1 OID 1 + * @param oid1_len OID 1 length + * @param oid2 OID 2 + * @param oid2_len OID 2 length + */ +void +snmp_oid_combine(struct snmp_obj_id *target, const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) +{ + snmp_oid_assign(target, oid1, oid1_len); + snmp_oid_append(target, oid2, oid2_len); +} + +/** + * Append OIDs to struct snmp_obj_id + * @param target Assignment target to append to + * @param oid OID + * @param oid_len OID length + */ +void +snmp_oid_append(struct snmp_obj_id *target, const u32_t *oid, u8_t oid_len) +{ + LWIP_ASSERT("offset + oid_len <= SNMP_MAX_OBJ_ID_LEN", (target->len + oid_len) <= SNMP_MAX_OBJ_ID_LEN); + + if (oid_len > 0) { + MEMCPY(&target->id[target->len], oid, oid_len * sizeof(u32_t)); + target->len = (u8_t)(target->len + oid_len); + } +} + +/** + * Compare two OIDs + * @param oid1 OID 1 + * @param oid1_len OID 1 length + * @param oid2 OID 2 + * @param oid2_len OID 2 length + * @return -1: OID1<OID2 1: OID1 >OID2 0: equal + */ +s8_t +snmp_oid_compare(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) +{ + u8_t level = 0; + LWIP_ASSERT("'oid1' param must not be NULL or 'oid1_len' param be 0!", (oid1 != NULL) || (oid1_len == 0)); + LWIP_ASSERT("'oid2' param must not be NULL or 'oid2_len' param be 0!", (oid2 != NULL) || (oid2_len == 0)); + + while ((level < oid1_len) && (level < oid2_len)) { + if (*oid1 < *oid2) { + return -1; + } + if (*oid1 > *oid2) { + return 1; + } + + level++; + oid1++; + oid2++; + } + + /* common part of both OID's is equal, compare length */ + if (oid1_len < oid2_len) { + return -1; + } + if (oid1_len > oid2_len) { + return 1; + } + + /* they are equal */ + return 0; +} + + +/** + * Check of two OIDs are equal + * @param oid1 OID 1 + * @param oid1_len OID 1 length + * @param oid2 OID 2 + * @param oid2_len OID 2 length + * @return 1: equal 0: non-equal + */ +u8_t +snmp_oid_equal(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) +{ + return (snmp_oid_compare(oid1, oid1_len, oid2, oid2_len) == 0) ? 1 : 0; +} + +/** + * Convert netif to interface index + * @param netif netif + * @return index + */ +u8_t +netif_to_num(const struct netif *netif) +{ + return netif_get_index(netif); +} + +static const struct snmp_mib * +snmp_get_mib_from_oid(const u32_t *oid, u8_t oid_len) +{ + const u32_t *list_oid; + const u32_t *searched_oid; + u8_t i, l; + + u8_t max_match_len = 0; + const struct snmp_mib *matched_mib = NULL; + + LWIP_ASSERT("'oid' param must not be NULL!", (oid != NULL)); + + if (oid_len == 0) { + return NULL; + } + + for (i = 0; i < snmp_num_mibs; i++) { + LWIP_ASSERT("MIB array not initialized correctly", (snmp_mibs[i] != NULL)); + LWIP_ASSERT("MIB array not initialized correctly - base OID is NULL", (snmp_mibs[i]->base_oid != NULL)); + + if (oid_len >= snmp_mibs[i]->base_oid_len) { + l = snmp_mibs[i]->base_oid_len; + list_oid = snmp_mibs[i]->base_oid; + searched_oid = oid; + + while (l > 0) { + if (*list_oid != *searched_oid) { + break; + } + + l--; + list_oid++; + searched_oid++; + } + + if ((l == 0) && (snmp_mibs[i]->base_oid_len > max_match_len)) { + max_match_len = snmp_mibs[i]->base_oid_len; + matched_mib = snmp_mibs[i]; + } + } + } + + return matched_mib; +} + +static const struct snmp_mib * +snmp_get_next_mib(const u32_t *oid, u8_t oid_len) +{ + u8_t i; + const struct snmp_mib *next_mib = NULL; + + LWIP_ASSERT("'oid' param must not be NULL!", (oid != NULL)); + + if (oid_len == 0) { + return NULL; + } + + for (i = 0; i < snmp_num_mibs; i++) { + if (snmp_mibs[i]->base_oid != NULL) { + /* check if mib is located behind starting point */ + if (snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len, oid, oid_len) > 0) { + if ((next_mib == NULL) || + (snmp_oid_compare(snmp_mibs[i]->base_oid, snmp_mibs[i]->base_oid_len, + next_mib->base_oid, next_mib->base_oid_len) < 0)) { + next_mib = snmp_mibs[i]; + } + } + } + } + + return next_mib; +} + +static const struct snmp_mib * +snmp_get_mib_between(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len) +{ + const struct snmp_mib *next_mib = snmp_get_next_mib(oid1, oid1_len); + + LWIP_ASSERT("'oid2' param must not be NULL!", (oid2 != NULL)); + LWIP_ASSERT("'oid2_len' param must be greater than 0!", (oid2_len > 0)); + + if (next_mib != NULL) { + if (snmp_oid_compare(next_mib->base_oid, next_mib->base_oid_len, oid2, oid2_len) < 0) { + return next_mib; + } + } + + return NULL; +} + +u8_t +snmp_get_node_instance_from_oid(const u32_t *oid, u8_t oid_len, struct snmp_node_instance *node_instance) +{ + u8_t result = SNMP_ERR_NOSUCHOBJECT; + const struct snmp_mib *mib; + const struct snmp_node *mn = NULL; + + mib = snmp_get_mib_from_oid(oid, oid_len); + if (mib != NULL) { + u8_t oid_instance_len; + + mn = snmp_mib_tree_resolve_exact(mib, oid, oid_len, &oid_instance_len); + if ((mn != NULL) && (mn->node_type != SNMP_NODE_TREE)) { + /* get instance */ + const struct snmp_leaf_node *leaf_node = (const struct snmp_leaf_node *)(const void *)mn; + + node_instance->node = mn; + snmp_oid_assign(&node_instance->instance_oid, oid + (oid_len - oid_instance_len), oid_instance_len); + + result = leaf_node->get_instance( + oid, + oid_len - oid_instance_len, + node_instance); + +#ifdef LWIP_DEBUG + if (result == SNMP_ERR_NOERROR) { + if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_READ) != 0) && (node_instance->get_value == NULL)) { + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is readable but no get_value function is specified\n")); + } + if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_WRITE) != 0) && (node_instance->set_value == NULL)) { + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is writable but no set_value and/or set_test function is specified\n")); + } + } +#endif + } + } + + return result; +} + +u8_t +snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_validate_node_instance_method validate_node_instance_method, void *validate_node_instance_arg, struct snmp_obj_id *node_oid, struct snmp_node_instance *node_instance) +{ + const struct snmp_mib *mib; + const struct snmp_node *mn = NULL; + const u32_t *start_oid = NULL; + u8_t start_oid_len = 0; + + /* resolve target MIB from passed OID */ + mib = snmp_get_mib_from_oid(oid, oid_len); + if (mib == NULL) { + /* passed OID does not reference any known MIB, start at the next closest MIB */ + mib = snmp_get_next_mib(oid, oid_len); + + if (mib != NULL) { + start_oid = mib->base_oid; + start_oid_len = mib->base_oid_len; + } + } else { + start_oid = oid; + start_oid_len = oid_len; + } + + /* resolve target node from MIB, skip to next MIB if no suitable node is found in current MIB */ + while ((mib != NULL) && (mn == NULL)) { + u8_t oid_instance_len; + + /* check if OID directly references a node inside current MIB, in this case we have to ask this node for the next instance */ + mn = snmp_mib_tree_resolve_exact(mib, start_oid, start_oid_len, &oid_instance_len); + if (mn != NULL) { + snmp_oid_assign(node_oid, start_oid, start_oid_len - oid_instance_len); /* set oid to node */ + snmp_oid_assign(&node_instance->instance_oid, start_oid + (start_oid_len - oid_instance_len), oid_instance_len); /* set (relative) instance oid */ + } else { + /* OID does not reference a node, search for the next closest node inside MIB; set instance_oid.len to zero because we want the first instance of this node */ + mn = snmp_mib_tree_resolve_next(mib, start_oid, start_oid_len, node_oid); + node_instance->instance_oid.len = 0; + } + + /* validate the node; if the node has no further instance or the returned instance is invalid, search for the next in MIB and validate again */ + node_instance->node = mn; + while (mn != NULL) { + u8_t result; + + /* clear fields which may have values from previous loops */ + node_instance->asn1_type = 0; + node_instance->access = SNMP_NODE_INSTANCE_NOT_ACCESSIBLE; + node_instance->get_value = NULL; + node_instance->set_test = NULL; + node_instance->set_value = NULL; + node_instance->release_instance = NULL; + node_instance->reference.ptr = NULL; + node_instance->reference_len = 0; + + result = ((const struct snmp_leaf_node *)(const void *)mn)->get_next_instance( + node_oid->id, + node_oid->len, + node_instance); + + if (result == SNMP_ERR_NOERROR) { +#ifdef LWIP_DEBUG + if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_READ) != 0) && (node_instance->get_value == NULL)) { + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is readable but no get_value function is specified\n")); + } + if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_WRITE) != 0) && (node_instance->set_value == NULL)) { + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP inconsistent access: node is writable but no set_value function is specified\n")); + } +#endif + + /* validate node because the node may be not accessible for example (but let the caller decide what is valid */ + if ((validate_node_instance_method == NULL) || + (validate_node_instance_method(node_instance, validate_node_instance_arg) == SNMP_ERR_NOERROR)) { + /* node_oid "returns" the full result OID (including the instance part) */ + snmp_oid_append(node_oid, node_instance->instance_oid.id, node_instance->instance_oid.len); + break; + } + + if (node_instance->release_instance != NULL) { + node_instance->release_instance(node_instance); + } + /* + the instance itself is not valid, ask for next instance from same node. + we don't have to change any variables because node_instance->instance_oid is used as input (starting point) + as well as output (resulting next OID), so we have to simply call get_next_instance method again + */ + } else { + if (node_instance->release_instance != NULL) { + node_instance->release_instance(node_instance); + } + + /* the node has no further instance, skip to next node */ + mn = snmp_mib_tree_resolve_next(mib, node_oid->id, node_oid->len, &node_instance->instance_oid); /* misuse node_instance->instance_oid as tmp buffer */ + if (mn != NULL) { + /* prepare for next loop */ + snmp_oid_assign(node_oid, node_instance->instance_oid.id, node_instance->instance_oid.len); + node_instance->instance_oid.len = 0; + node_instance->node = mn; + } + } + } + + if (mn != NULL) { + /* + we found a suitable next node, + now we have to check if a inner MIB is located between the searched OID and the resulting OID. + this is possible because MIB's may be located anywhere in the global tree, that means also in + the subtree of another MIB (e.g. if searched OID is .2 and resulting OID is .4, then another + MIB having .3 as root node may exist) + */ + const struct snmp_mib *intermediate_mib; + intermediate_mib = snmp_get_mib_between(start_oid, start_oid_len, node_oid->id, node_oid->len); + + if (intermediate_mib != NULL) { + /* search for first node inside intermediate mib in next loop */ + if (node_instance->release_instance != NULL) { + node_instance->release_instance(node_instance); + } + + mn = NULL; + mib = intermediate_mib; + start_oid = mib->base_oid; + start_oid_len = mib->base_oid_len; + } + /* else { we found out target node } */ + } else { + /* + there is no further (suitable) node inside this MIB, search for the next MIB with following priority + 1. search for inner MIB's (whose root is located inside tree of current MIB) + 2. search for surrouding MIB's (where the current MIB is the inner MIB) and continue there if any + 3. take the next closest MIB (not being related to the current MIB) + */ + const struct snmp_mib *next_mib; + next_mib = snmp_get_next_mib(start_oid, start_oid_len); /* returns MIB's related to point 1 and 3 */ + + /* is the found MIB an inner MIB? (point 1) */ + if ((next_mib != NULL) && (next_mib->base_oid_len > mib->base_oid_len) && + (snmp_oid_compare(next_mib->base_oid, mib->base_oid_len, mib->base_oid, mib->base_oid_len) == 0)) { + /* yes it is -> continue at inner MIB */ + mib = next_mib; + start_oid = mib->base_oid; + start_oid_len = mib->base_oid_len; + } else { + /* check if there is a surrounding mib where to continue (point 2) (only possible if OID length > 1) */ + if (mib->base_oid_len > 1) { + mib = snmp_get_mib_from_oid(mib->base_oid, mib->base_oid_len - 1); + + if (mib == NULL) { + /* no surrounding mib, use next mib encountered above (point 3) */ + mib = next_mib; + + if (mib != NULL) { + start_oid = mib->base_oid; + start_oid_len = mib->base_oid_len; + } + } + /* else { start_oid stays the same because we want to continue from current offset in surrounding mib (point 2) } */ + } + } + } + } + + if (mib == NULL) { + /* loop is only left when mib == null (error) or mib_node != NULL (success) */ + return SNMP_ERR_ENDOFMIBVIEW; + } + + return SNMP_ERR_NOERROR; +} + +/** + * Searches tree for the supplied object identifier. + * + */ +const struct snmp_node * +snmp_mib_tree_resolve_exact(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, u8_t *oid_instance_len) +{ + const struct snmp_node *const *node = &mib->root_node; + u8_t oid_offset = mib->base_oid_len; + + while ((oid_offset < oid_len) && ((*node)->node_type == SNMP_NODE_TREE)) { + /* search for matching sub node */ + u32_t subnode_oid = *(oid + oid_offset); + + u32_t i = (*(const struct snmp_tree_node * const *)node)->subnode_count; + node = (*(const struct snmp_tree_node * const *)node)->subnodes; + while ((i > 0) && ((*node)->oid != subnode_oid)) { + node++; + i--; + } + + if (i == 0) { + /* no matching subnode found */ + return NULL; + } + + oid_offset++; + } + + if ((*node)->node_type != SNMP_NODE_TREE) { + /* we found a leaf node */ + *oid_instance_len = oid_len - oid_offset; + return (*node); + } + + return NULL; +} + +const struct snmp_node * +snmp_mib_tree_resolve_next(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, struct snmp_obj_id *oidret) +{ + u8_t oid_offset = mib->base_oid_len; + const struct snmp_node *const *node; + const struct snmp_tree_node *node_stack[SNMP_MAX_OBJ_ID_LEN]; + s32_t nsi = 0; /* NodeStackIndex */ + u32_t subnode_oid; + + if (mib->root_node->node_type != SNMP_NODE_TREE) { + /* a next operation on a mib with only a leaf node will always return NULL because there is no other node */ + return NULL; + } + + /* first build node stack related to passed oid (as far as possible), then go backwards to determine the next node */ + node_stack[nsi] = (const struct snmp_tree_node *)(const void *)mib->root_node; + while (oid_offset < oid_len) { + /* search for matching sub node */ + u32_t i = node_stack[nsi]->subnode_count; + node = node_stack[nsi]->subnodes; + + subnode_oid = *(oid + oid_offset); + + while ((i > 0) && ((*node)->oid != subnode_oid)) { + node++; + i--; + } + + if ((i == 0) || ((*node)->node_type != SNMP_NODE_TREE)) { + /* no (matching) tree-subnode found */ + break; + } + nsi++; + node_stack[nsi] = (const struct snmp_tree_node *)(const void *)(*node); + + oid_offset++; + } + + + if (oid_offset >= oid_len) { + /* passed oid references a tree node -> return first useable sub node of it */ + subnode_oid = 0; + } else { + subnode_oid = *(oid + oid_offset) + 1; + } + + while (nsi >= 0) { + const struct snmp_node *subnode = NULL; + + /* find next node on current level */ + s32_t i = node_stack[nsi]->subnode_count; + node = node_stack[nsi]->subnodes; + while (i > 0) { + if ((*node)->oid == subnode_oid) { + subnode = *node; + break; + } else if (((*node)->oid > subnode_oid) && ((subnode == NULL) || ((*node)->oid < subnode->oid))) { + subnode = *node; + } + + node++; + i--; + } + + if (subnode == NULL) { + /* no further node found on this level, go one level up and start searching with index of current node*/ + subnode_oid = node_stack[nsi]->node.oid + 1; + nsi--; + } else { + if (subnode->node_type == SNMP_NODE_TREE) { + /* next is a tree node, go into it and start searching */ + nsi++; + node_stack[nsi] = (const struct snmp_tree_node *)(const void *)subnode; + subnode_oid = 0; + } else { + /* we found a leaf node -> fill oidret and return it */ + snmp_oid_assign(oidret, mib->base_oid, mib->base_oid_len); + i = 1; + while (i <= nsi) { + oidret->id[oidret->len] = node_stack[i]->node.oid; + oidret->len++; + i++; + } + + oidret->id[oidret->len] = subnode->oid; + oidret->len++; + + return subnode; + } + } + } + + return NULL; +} + +/** initialize struct next_oid_state using this function before passing it to next_oid_check */ +void +snmp_next_oid_init(struct snmp_next_oid_state *state, + const u32_t *start_oid, u8_t start_oid_len, + u32_t *next_oid_buf, u8_t next_oid_max_len) +{ + state->start_oid = start_oid; + state->start_oid_len = start_oid_len; + state->next_oid = next_oid_buf; + state->next_oid_len = 0; + state->next_oid_max_len = next_oid_max_len; + state->status = SNMP_NEXT_OID_STATUS_NO_MATCH; +} + +/** checks if the passed incomplete OID may be a possible candidate for snmp_next_oid_check(); +this methid is intended if the complete OID is not yet known but it is very expensive to build it up, +so it is possible to test the starting part before building up the complete oid and pass it to snmp_next_oid_check()*/ +u8_t +snmp_next_oid_precheck(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len) +{ + if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL) { + u8_t start_oid_len = (oid_len < state->start_oid_len) ? oid_len : state->start_oid_len; + + /* check passed OID is located behind start offset */ + if (snmp_oid_compare(oid, oid_len, state->start_oid, start_oid_len) >= 0) { + /* check if new oid is located closer to start oid than current closest oid */ + if ((state->status == SNMP_NEXT_OID_STATUS_NO_MATCH) || + (snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0)) { + return 1; + } + } + } + + return 0; +} + +/** checks the passed OID if it is a candidate to be the next one (get_next); returns !=0 if passed oid is currently closest, otherwise 0 */ +u8_t +snmp_next_oid_check(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len, void *reference) +{ + /* do not overwrite a fail result */ + if (state->status != SNMP_NEXT_OID_STATUS_BUF_TO_SMALL) { + /* check passed OID is located behind start offset */ + if (snmp_oid_compare(oid, oid_len, state->start_oid, state->start_oid_len) > 0) { + /* check if new oid is located closer to start oid than current closest oid */ + if ((state->status == SNMP_NEXT_OID_STATUS_NO_MATCH) || + (snmp_oid_compare(oid, oid_len, state->next_oid, state->next_oid_len) < 0)) { + if (oid_len <= state->next_oid_max_len) { + MEMCPY(state->next_oid, oid, oid_len * sizeof(u32_t)); + state->next_oid_len = oid_len; + state->status = SNMP_NEXT_OID_STATUS_SUCCESS; + state->reference = reference; + return 1; + } else { + state->status = SNMP_NEXT_OID_STATUS_BUF_TO_SMALL; + } + } + } + } + + return 0; +} + +u8_t +snmp_oid_in_range(const u32_t *oid_in, u8_t oid_len, const struct snmp_oid_range *oid_ranges, u8_t oid_ranges_len) +{ + u8_t i; + + if (oid_len != oid_ranges_len) { + return 0; + } + + for (i = 0; i < oid_ranges_len; i++) { + if ((oid_in[i] < oid_ranges[i].min) || (oid_in[i] > oid_ranges[i].max)) { + return 0; + } + } + + return 1; +} + +snmp_err_t +snmp_set_test_ok(struct snmp_node_instance *instance, u16_t value_len, void *value) +{ + LWIP_UNUSED_ARG(instance); + LWIP_UNUSED_ARG(value_len); + LWIP_UNUSED_ARG(value); + + return SNMP_ERR_NOERROR; +} + +/** + * Decodes BITS pseudotype value from ASN.1 OctetString. + * + * @note Because BITS pseudo type is encoded as OCTET STRING, it cannot directly + * be encoded/decoded by the agent. Instead call this function as required from + * get/test/set methods. + * + * @param buf points to a buffer holding the ASN1 octet string + * @param buf_len length of octet string + * @param bit_value decoded Bit value with Bit0 == LSB + * @return ERR_OK if successful, ERR_ARG if bit value contains more than 32 bit + */ +err_t +snmp_decode_bits(const u8_t *buf, u32_t buf_len, u32_t *bit_value) +{ + u8_t b; + u8_t bits_processed = 0; + *bit_value = 0; + + while (buf_len > 0) { + /* any bit set in this byte? */ + if (*buf != 0x00) { + if (bits_processed >= 32) { + /* accept more than 4 bytes, but only when no bits are set */ + return ERR_VAL; + } + + b = *buf; + do { + if (b & 0x80) { + *bit_value |= (1 << bits_processed); + } + bits_processed++; + b <<= 1; + } while ((bits_processed & 0x07) != 0); /* &0x07 -> % 8 */ + } else { + bits_processed += 8; + } + + buf_len--; + buf++; + } + + return ERR_OK; +} + +err_t +snmp_decode_truthvalue(const s32_t *asn1_value, u8_t *bool_value) +{ + /* defined by RFC1443: + TruthValue ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Represents a boolean value." + SYNTAX INTEGER { true(1), false(2) } + */ + + if ((asn1_value == NULL) || (bool_value == NULL)) { + return ERR_ARG; + } + + if (*asn1_value == 1) { + *bool_value = 1; + } else if (*asn1_value == 2) { + *bool_value = 0; + } else { + return ERR_VAL; + } + + return ERR_OK; +} + +/** + * Encodes BITS pseudotype value into ASN.1 OctetString. + * + * @note Because BITS pseudo type is encoded as OCTET STRING, it cannot directly + * be encoded/decoded by the agent. Instead call this function as required from + * get/test/set methods. + * + * @param buf points to a buffer where the resulting ASN1 octet string is stored to + * @param buf_len max length of the bufffer + * @param bit_value Bit value to encode with Bit0 == LSB + * @param bit_count Number of possible bits for the bit value (according to rfc we have to send all bits independant from their truth value) + * @return number of bytes used from buffer to store the resulting OctetString + */ +u8_t +snmp_encode_bits(u8_t *buf, u32_t buf_len, u32_t bit_value, u8_t bit_count) +{ + u8_t len = 0; + u8_t min_bytes = (bit_count + 7) >> 3; /* >>3 -> / 8 */ + + while ((buf_len > 0) && (bit_value != 0x00)) { + s8_t i = 7; + *buf = 0x00; + while (i >= 0) { + if (bit_value & 0x01) { + *buf |= 0x01; + } + + if (i > 0) { + *buf <<= 1; + } + + bit_value >>= 1; + i--; + } + + buf++; + buf_len--; + len++; + } + + if (len < min_bytes) { + buf += len; + buf_len -= len; + + while ((len < min_bytes) && (buf_len > 0)) { + *buf = 0x00; + buf++; + buf_len--; + len++; + } + } + + return len; +} + +u8_t +snmp_encode_truthvalue(s32_t *asn1_value, u32_t bool_value) +{ + /* defined by RFC1443: + TruthValue ::= TEXTUAL-CONVENTION + STATUS current + DESCRIPTION + "Represents a boolean value." + SYNTAX INTEGER { true(1), false(2) } + */ + + if (asn1_value == NULL) { + return 0; + } + + if (bool_value) { + *asn1_value = 1; /* defined by RFC1443 */ + } else { + *asn1_value = 2; /* defined by RFC1443 */ + } + + return sizeof(s32_t); +} + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core_priv.h index 5e548643..9532c05e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_core_priv.h @@ -1,83 +1,83 @@ -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * - */ - -#ifndef LWIP_HDR_APPS_SNMP_CORE_PRIV_H -#define LWIP_HDR_APPS_SNMP_CORE_PRIV_H - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/snmp_core.h" -#include "snmp_asn1.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* (outdated) SNMPv1 error codes - * shall not be used by MIBS anymore, nevertheless required from core for properly answering a v1 request - */ -#define SNMP_ERR_NOSUCHNAME 2 -#define SNMP_ERR_BADVALUE 3 -#define SNMP_ERR_READONLY 4 -/* error codes which are internal and shall not be used by MIBS - * shall not be used by MIBS anymore, nevertheless required from core for properly answering a v1 request - */ -#define SNMP_ERR_TOOBIG 1 -#define SNMP_ERR_AUTHORIZATIONERROR 16 - -#define SNMP_ERR_UNKNOWN_ENGINEID 30 -#define SNMP_ERR_UNKNOWN_SECURITYNAME 31 -#define SNMP_ERR_UNSUPPORTED_SECLEVEL 32 -#define SNMP_ERR_NOTINTIMEWINDOW 33 -#define SNMP_ERR_DECRYIPTION_ERROR 34 - -#define SNMP_ERR_NOSUCHOBJECT SNMP_VARBIND_EXCEPTION_OFFSET + SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_OBJECT -#define SNMP_ERR_ENDOFMIBVIEW SNMP_VARBIND_EXCEPTION_OFFSET + SNMP_ASN1_CONTEXT_VARBIND_END_OF_MIB_VIEW - - -const struct snmp_node *snmp_mib_tree_resolve_exact(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, u8_t *oid_instance_len); -const struct snmp_node *snmp_mib_tree_resolve_next(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, struct snmp_obj_id *oidret); - -typedef u8_t (*snmp_validate_node_instance_method)(struct snmp_node_instance *, void *); - -u8_t snmp_get_node_instance_from_oid(const u32_t *oid, u8_t oid_len, struct snmp_node_instance *node_instance); -u8_t snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_validate_node_instance_method validate_node_instance_method, void *validate_node_instance_arg, struct snmp_obj_id *node_oid, struct snmp_node_instance *node_instance); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_SNMP */ - -#endif /* LWIP_HDR_APPS_SNMP_CORE_PRIV_H */ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * + */ + +#ifndef LWIP_HDR_APPS_SNMP_CORE_PRIV_H +#define LWIP_HDR_APPS_SNMP_CORE_PRIV_H + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/snmp_core.h" +#include "snmp_asn1.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* (outdated) SNMPv1 error codes + * shall not be used by MIBS anymore, nevertheless required from core for properly answering a v1 request + */ +#define SNMP_ERR_NOSUCHNAME 2 +#define SNMP_ERR_BADVALUE 3 +#define SNMP_ERR_READONLY 4 +/* error codes which are internal and shall not be used by MIBS + * shall not be used by MIBS anymore, nevertheless required from core for properly answering a v1 request + */ +#define SNMP_ERR_TOOBIG 1 +#define SNMP_ERR_AUTHORIZATIONERROR 16 + +#define SNMP_ERR_UNKNOWN_ENGINEID 30 +#define SNMP_ERR_UNKNOWN_SECURITYNAME 31 +#define SNMP_ERR_UNSUPPORTED_SECLEVEL 32 +#define SNMP_ERR_NOTINTIMEWINDOW 33 +#define SNMP_ERR_DECRYIPTION_ERROR 34 + +#define SNMP_ERR_NOSUCHOBJECT SNMP_VARBIND_EXCEPTION_OFFSET + SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_OBJECT +#define SNMP_ERR_ENDOFMIBVIEW SNMP_VARBIND_EXCEPTION_OFFSET + SNMP_ASN1_CONTEXT_VARBIND_END_OF_MIB_VIEW + + +const struct snmp_node *snmp_mib_tree_resolve_exact(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, u8_t *oid_instance_len); +const struct snmp_node *snmp_mib_tree_resolve_next(const struct snmp_mib *mib, const u32_t *oid, u8_t oid_len, struct snmp_obj_id *oidret); + +typedef u8_t (*snmp_validate_node_instance_method)(struct snmp_node_instance *, void *); + +u8_t snmp_get_node_instance_from_oid(const u32_t *oid, u8_t oid_len, struct snmp_node_instance *node_instance); +u8_t snmp_get_next_node_instance_from_oid(const u32_t *oid, u8_t oid_len, snmp_validate_node_instance_method validate_node_instance_method, void *validate_node_instance_arg, struct snmp_obj_id *node_oid, struct snmp_node_instance *node_instance); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_SNMP */ + +#endif /* LWIP_HDR_APPS_SNMP_CORE_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2.c index dc49ae6d..3383e44e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2.c @@ -1,116 +1,116 @@ -/** - * @file - * Management Information Base II (RFC1213) objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -/** - * @defgroup snmp_mib2 MIB2 - * @ingroup snmp - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP && SNMP_LWIP_MIB2 /* don't build if not configured for use in lwipopts.h */ - -#if !LWIP_STATS -#error LWIP_SNMP MIB2 needs LWIP_STATS (for MIB2) -#endif -#if !MIB2_STATS -#error LWIP_SNMP MIB2 needs MIB2_STATS (for MIB2) -#endif - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_scalar.h" - -#if SNMP_USE_NETCONN -#include "lwip/tcpip.h" -#include "lwip/priv/tcpip_priv.h" -void -snmp_mib2_lwip_synchronizer(snmp_threadsync_called_fn fn, void *arg) -{ -#if LWIP_TCPIP_CORE_LOCKING - LOCK_TCPIP_CORE(); - fn(arg); - UNLOCK_TCPIP_CORE(); -#else - tcpip_callback(fn, arg); -#endif -} - -struct snmp_threadsync_instance snmp_mib2_lwip_locks; -#endif - -/* dot3 and EtherLike MIB not planned. (transmission .1.3.6.1.2.1.10) */ -/* historical (some say hysterical). (cmot .1.3.6.1.2.1.9) */ -/* lwIP has no EGP, thus may not implement it. (egp .1.3.6.1.2.1.8) */ - -/* --- mib-2 .1.3.6.1.2.1 ----------------------------------------------------- */ -extern const struct snmp_scalar_array_node snmp_mib2_snmp_root; -extern const struct snmp_tree_node snmp_mib2_udp_root; -extern const struct snmp_tree_node snmp_mib2_tcp_root; -extern const struct snmp_scalar_array_node snmp_mib2_icmp_root; -extern const struct snmp_tree_node snmp_mib2_interface_root; -extern const struct snmp_scalar_array_node snmp_mib2_system_node; -extern const struct snmp_tree_node snmp_mib2_at_root; -extern const struct snmp_tree_node snmp_mib2_ip_root; - -static const struct snmp_node *const mib2_nodes[] = { - &snmp_mib2_system_node.node.node, - &snmp_mib2_interface_root.node, -#if LWIP_ARP && LWIP_IPV4 - &snmp_mib2_at_root.node, -#endif /* LWIP_ARP && LWIP_IPV4 */ -#if LWIP_IPV4 - &snmp_mib2_ip_root.node, -#endif /* LWIP_IPV4 */ -#if LWIP_ICMP - &snmp_mib2_icmp_root.node.node, -#endif /* LWIP_ICMP */ -#if LWIP_TCP - &snmp_mib2_tcp_root.node, -#endif /* LWIP_TCP */ -#if LWIP_UDP - &snmp_mib2_udp_root.node, -#endif /* LWIP_UDP */ - &snmp_mib2_snmp_root.node.node -}; - -static const struct snmp_tree_node mib2_root = SNMP_CREATE_TREE_NODE(1, mib2_nodes); - -static const u32_t mib2_base_oid_arr[] = { 1, 3, 6, 1, 2, 1 }; -const struct snmp_mib mib2 = SNMP_MIB_CREATE(mib2_base_oid_arr, &mib2_root.node); - -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ +/** + * @file + * Management Information Base II (RFC1213) objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +/** + * @defgroup snmp_mib2 MIB2 + * @ingroup snmp + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP && SNMP_LWIP_MIB2 /* don't build if not configured for use in lwipopts.h */ + +#if !LWIP_STATS +#error LWIP_SNMP MIB2 needs LWIP_STATS (for MIB2) +#endif +#if !MIB2_STATS +#error LWIP_SNMP MIB2 needs MIB2_STATS (for MIB2) +#endif + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_scalar.h" + +#if SNMP_USE_NETCONN +#include "lwip/tcpip.h" +#include "lwip/priv/tcpip_priv.h" +void +snmp_mib2_lwip_synchronizer(snmp_threadsync_called_fn fn, void *arg) +{ +#if LWIP_TCPIP_CORE_LOCKING + LOCK_TCPIP_CORE(); + fn(arg); + UNLOCK_TCPIP_CORE(); +#else + tcpip_callback(fn, arg); +#endif +} + +struct snmp_threadsync_instance snmp_mib2_lwip_locks; +#endif + +/* dot3 and EtherLike MIB not planned. (transmission .1.3.6.1.2.1.10) */ +/* historical (some say hysterical). (cmot .1.3.6.1.2.1.9) */ +/* lwIP has no EGP, thus may not implement it. (egp .1.3.6.1.2.1.8) */ + +/* --- mib-2 .1.3.6.1.2.1 ----------------------------------------------------- */ +extern const struct snmp_scalar_array_node snmp_mib2_snmp_root; +extern const struct snmp_tree_node snmp_mib2_udp_root; +extern const struct snmp_tree_node snmp_mib2_tcp_root; +extern const struct snmp_scalar_array_node snmp_mib2_icmp_root; +extern const struct snmp_tree_node snmp_mib2_interface_root; +extern const struct snmp_scalar_array_node snmp_mib2_system_node; +extern const struct snmp_tree_node snmp_mib2_at_root; +extern const struct snmp_tree_node snmp_mib2_ip_root; + +static const struct snmp_node *const mib2_nodes[] = { + &snmp_mib2_system_node.node.node, + &snmp_mib2_interface_root.node, +#if LWIP_ARP && LWIP_IPV4 + &snmp_mib2_at_root.node, +#endif /* LWIP_ARP && LWIP_IPV4 */ +#if LWIP_IPV4 + &snmp_mib2_ip_root.node, +#endif /* LWIP_IPV4 */ +#if LWIP_ICMP + &snmp_mib2_icmp_root.node.node, +#endif /* LWIP_ICMP */ +#if LWIP_TCP + &snmp_mib2_tcp_root.node, +#endif /* LWIP_TCP */ +#if LWIP_UDP + &snmp_mib2_udp_root.node, +#endif /* LWIP_UDP */ + &snmp_mib2_snmp_root.node.node +}; + +static const struct snmp_tree_node mib2_root = SNMP_CREATE_TREE_NODE(1, mib2_nodes); + +static const u32_t mib2_base_oid_arr[] = { 1, 3, 6, 1, 2, 1 }; +const struct snmp_mib mib2 = SNMP_MIB_CREATE(mib2_base_oid_arr, &mib2_root.node); + +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_icmp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_icmp.c index 0a82375e..033d229e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_icmp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_icmp.c @@ -1,182 +1,182 @@ -/** - * @file - * Management Information Base II (RFC1213) ICMP objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/icmp.h" -#include "lwip/stats.h" - -#if LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_ICMP - -#if SNMP_USE_NETCONN -#define SYNC_NODE_NAME(node_name) node_name ## _synced -#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ - static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); -#else -#define SYNC_NODE_NAME(node_name) node_name -#define CREATE_LWIP_SYNC_NODE(oid, node_name) -#endif - -/* --- icmp .1.3.6.1.2.1.5 ----------------------------------------------------- */ - -static s16_t -icmp_get_value(const struct snmp_scalar_array_node_def *node, void *value) -{ - u32_t *uint_ptr = (u32_t *)value; - - switch (node->oid) { - case 1: /* icmpInMsgs */ - *uint_ptr = STATS_GET(mib2.icmpinmsgs); - return sizeof(*uint_ptr); - case 2: /* icmpInErrors */ - *uint_ptr = STATS_GET(mib2.icmpinerrors); - return sizeof(*uint_ptr); - case 3: /* icmpInDestUnreachs */ - *uint_ptr = STATS_GET(mib2.icmpindestunreachs); - return sizeof(*uint_ptr); - case 4: /* icmpInTimeExcds */ - *uint_ptr = STATS_GET(mib2.icmpintimeexcds); - return sizeof(*uint_ptr); - case 5: /* icmpInParmProbs */ - *uint_ptr = STATS_GET(mib2.icmpinparmprobs); - return sizeof(*uint_ptr); - case 6: /* icmpInSrcQuenchs */ - *uint_ptr = STATS_GET(mib2.icmpinsrcquenchs); - return sizeof(*uint_ptr); - case 7: /* icmpInRedirects */ - *uint_ptr = STATS_GET(mib2.icmpinredirects); - return sizeof(*uint_ptr); - case 8: /* icmpInEchos */ - *uint_ptr = STATS_GET(mib2.icmpinechos); - return sizeof(*uint_ptr); - case 9: /* icmpInEchoReps */ - *uint_ptr = STATS_GET(mib2.icmpinechoreps); - return sizeof(*uint_ptr); - case 10: /* icmpInTimestamps */ - *uint_ptr = STATS_GET(mib2.icmpintimestamps); - return sizeof(*uint_ptr); - case 11: /* icmpInTimestampReps */ - *uint_ptr = STATS_GET(mib2.icmpintimestampreps); - return sizeof(*uint_ptr); - case 12: /* icmpInAddrMasks */ - *uint_ptr = STATS_GET(mib2.icmpinaddrmasks); - return sizeof(*uint_ptr); - case 13: /* icmpInAddrMaskReps */ - *uint_ptr = STATS_GET(mib2.icmpinaddrmaskreps); - return sizeof(*uint_ptr); - case 14: /* icmpOutMsgs */ - *uint_ptr = STATS_GET(mib2.icmpoutmsgs); - return sizeof(*uint_ptr); - case 15: /* icmpOutErrors */ - *uint_ptr = STATS_GET(mib2.icmpouterrors); - return sizeof(*uint_ptr); - case 16: /* icmpOutDestUnreachs */ - *uint_ptr = STATS_GET(mib2.icmpoutdestunreachs); - return sizeof(*uint_ptr); - case 17: /* icmpOutTimeExcds */ - *uint_ptr = STATS_GET(mib2.icmpouttimeexcds); - return sizeof(*uint_ptr); - case 18: /* icmpOutParmProbs: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - case 19: /* icmpOutSrcQuenchs: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - case 20: /* icmpOutRedirects: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - case 21: /* icmpOutEchos */ - *uint_ptr = STATS_GET(mib2.icmpoutechos); - return sizeof(*uint_ptr); - case 22: /* icmpOutEchoReps */ - *uint_ptr = STATS_GET(mib2.icmpoutechoreps); - return sizeof(*uint_ptr); - case 23: /* icmpOutTimestamps: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - case 24: /* icmpOutTimestampReps: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - case 25: /* icmpOutAddrMasks: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - case 26: /* icmpOutAddrMaskReps: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("icmp_get_value(): unknown id: %"S32_F"\n", node->oid)); - break; - } - - return 0; -} - - -static const struct snmp_scalar_array_node_def icmp_nodes[] = { - { 1, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 2, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 3, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 4, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 5, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 6, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 7, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 8, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - { 9, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {10, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {11, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {12, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {13, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {14, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {15, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {16, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {17, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {18, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {19, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {20, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {21, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {22, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {23, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {24, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {25, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, - {26, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY} -}; - -const struct snmp_scalar_array_node snmp_mib2_icmp_root = SNMP_SCALAR_CREATE_ARRAY_NODE(5, icmp_nodes, icmp_get_value, NULL, NULL); - -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_ICMP */ +/** + * @file + * Management Information Base II (RFC1213) ICMP objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/icmp.h" +#include "lwip/stats.h" + +#if LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_ICMP + +#if SNMP_USE_NETCONN +#define SYNC_NODE_NAME(node_name) node_name ## _synced +#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ + static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); +#else +#define SYNC_NODE_NAME(node_name) node_name +#define CREATE_LWIP_SYNC_NODE(oid, node_name) +#endif + +/* --- icmp .1.3.6.1.2.1.5 ----------------------------------------------------- */ + +static s16_t +icmp_get_value(const struct snmp_scalar_array_node_def *node, void *value) +{ + u32_t *uint_ptr = (u32_t *)value; + + switch (node->oid) { + case 1: /* icmpInMsgs */ + *uint_ptr = STATS_GET(mib2.icmpinmsgs); + return sizeof(*uint_ptr); + case 2: /* icmpInErrors */ + *uint_ptr = STATS_GET(mib2.icmpinerrors); + return sizeof(*uint_ptr); + case 3: /* icmpInDestUnreachs */ + *uint_ptr = STATS_GET(mib2.icmpindestunreachs); + return sizeof(*uint_ptr); + case 4: /* icmpInTimeExcds */ + *uint_ptr = STATS_GET(mib2.icmpintimeexcds); + return sizeof(*uint_ptr); + case 5: /* icmpInParmProbs */ + *uint_ptr = STATS_GET(mib2.icmpinparmprobs); + return sizeof(*uint_ptr); + case 6: /* icmpInSrcQuenchs */ + *uint_ptr = STATS_GET(mib2.icmpinsrcquenchs); + return sizeof(*uint_ptr); + case 7: /* icmpInRedirects */ + *uint_ptr = STATS_GET(mib2.icmpinredirects); + return sizeof(*uint_ptr); + case 8: /* icmpInEchos */ + *uint_ptr = STATS_GET(mib2.icmpinechos); + return sizeof(*uint_ptr); + case 9: /* icmpInEchoReps */ + *uint_ptr = STATS_GET(mib2.icmpinechoreps); + return sizeof(*uint_ptr); + case 10: /* icmpInTimestamps */ + *uint_ptr = STATS_GET(mib2.icmpintimestamps); + return sizeof(*uint_ptr); + case 11: /* icmpInTimestampReps */ + *uint_ptr = STATS_GET(mib2.icmpintimestampreps); + return sizeof(*uint_ptr); + case 12: /* icmpInAddrMasks */ + *uint_ptr = STATS_GET(mib2.icmpinaddrmasks); + return sizeof(*uint_ptr); + case 13: /* icmpInAddrMaskReps */ + *uint_ptr = STATS_GET(mib2.icmpinaddrmaskreps); + return sizeof(*uint_ptr); + case 14: /* icmpOutMsgs */ + *uint_ptr = STATS_GET(mib2.icmpoutmsgs); + return sizeof(*uint_ptr); + case 15: /* icmpOutErrors */ + *uint_ptr = STATS_GET(mib2.icmpouterrors); + return sizeof(*uint_ptr); + case 16: /* icmpOutDestUnreachs */ + *uint_ptr = STATS_GET(mib2.icmpoutdestunreachs); + return sizeof(*uint_ptr); + case 17: /* icmpOutTimeExcds */ + *uint_ptr = STATS_GET(mib2.icmpouttimeexcds); + return sizeof(*uint_ptr); + case 18: /* icmpOutParmProbs: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + case 19: /* icmpOutSrcQuenchs: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + case 20: /* icmpOutRedirects: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + case 21: /* icmpOutEchos */ + *uint_ptr = STATS_GET(mib2.icmpoutechos); + return sizeof(*uint_ptr); + case 22: /* icmpOutEchoReps */ + *uint_ptr = STATS_GET(mib2.icmpoutechoreps); + return sizeof(*uint_ptr); + case 23: /* icmpOutTimestamps: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + case 24: /* icmpOutTimestampReps: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + case 25: /* icmpOutAddrMasks: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + case 26: /* icmpOutAddrMaskReps: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("icmp_get_value(): unknown id: %"S32_F"\n", node->oid)); + break; + } + + return 0; +} + + +static const struct snmp_scalar_array_node_def icmp_nodes[] = { + { 1, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 2, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 3, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 4, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 5, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 6, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 7, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 8, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + { 9, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {10, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {11, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {12, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {13, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {14, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {15, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {16, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {17, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {18, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {19, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {20, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {21, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {22, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {23, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {24, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {25, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, + {26, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY} +}; + +const struct snmp_scalar_array_node snmp_mib2_icmp_root = SNMP_SCALAR_CREATE_ARRAY_NODE(5, icmp_nodes, icmp_get_value, NULL, NULL); + +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_ICMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_interfaces.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_interfaces.c index c53ce9e8..5f12dd55 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_interfaces.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_interfaces.c @@ -1,368 +1,368 @@ -/** - * @file - * Management Information Base II (RFC1213) INTERFACES objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/netif.h" -#include "lwip/stats.h" - -#include - -#if LWIP_SNMP && SNMP_LWIP_MIB2 - -#if SNMP_USE_NETCONN -#define SYNC_NODE_NAME(node_name) node_name ## _synced -#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ - static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); -#else -#define SYNC_NODE_NAME(node_name) node_name -#define CREATE_LWIP_SYNC_NODE(oid, node_name) -#endif - - -/* --- interfaces .1.3.6.1.2.1.2 ----------------------------------------------------- */ - -static s16_t -interfaces_get_value(struct snmp_node_instance *instance, void *value) -{ - if (instance->node->oid == 1) { - s32_t *sint_ptr = (s32_t *)value; - s32_t num_netifs = 0; - - struct netif *netif; - NETIF_FOREACH(netif) { - num_netifs++; - } - - *sint_ptr = num_netifs; - return sizeof(*sint_ptr); - } - - return 0; -} - -/* list of allowed value ranges for incoming OID */ -static const struct snmp_oid_range interfaces_Table_oid_ranges[] = { - { 1, 0xff } /* netif->num is u8_t */ -}; - -static const u8_t iftable_ifOutQLen = 0; - -static const u8_t iftable_ifOperStatus_up = 1; -static const u8_t iftable_ifOperStatus_down = 2; - -static const u8_t iftable_ifAdminStatus_up = 1; -static const u8_t iftable_ifAdminStatus_lowerLayerDown = 7; -static const u8_t iftable_ifAdminStatus_down = 2; - -static snmp_err_t -interfaces_Table_get_cell_instance(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, struct snmp_node_instance *cell_instance) -{ - u32_t ifIndex; - struct netif *netif; - - LWIP_UNUSED_ARG(column); - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(row_oid, row_oid_len, interfaces_Table_oid_ranges, LWIP_ARRAYSIZE(interfaces_Table_oid_ranges))) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* get netif index from incoming OID */ - ifIndex = row_oid[0]; - - /* find netif with index */ - NETIF_FOREACH(netif) { - if (netif_to_num(netif) == ifIndex) { - /* store netif pointer for subsequent operations (get/test/set) */ - cell_instance->reference.ptr = netif; - return SNMP_ERR_NOERROR; - } - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -interfaces_Table_get_next_cell_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance) -{ - struct netif *netif; - struct snmp_next_oid_state state; - u32_t result_temp[LWIP_ARRAYSIZE(interfaces_Table_oid_ranges)]; - - LWIP_UNUSED_ARG(column); - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(interfaces_Table_oid_ranges)); - - /* iterate over all possible OIDs to find the next one */ - NETIF_FOREACH(netif) { - u32_t test_oid[LWIP_ARRAYSIZE(interfaces_Table_oid_ranges)]; - test_oid[0] = netif_to_num(netif); - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(interfaces_Table_oid_ranges), netif); - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* store netif pointer for subsequent operations (get/test/set) */ - cell_instance->reference.ptr = /* (struct netif*) */state.reference; - return SNMP_ERR_NOERROR; - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static s16_t -interfaces_Table_get_value(struct snmp_node_instance *instance, void *value) -{ - struct netif *netif = (struct netif *)instance->reference.ptr; - u32_t *value_u32 = (u32_t *)value; - s32_t *value_s32 = (s32_t *)value; - u16_t value_len; - - switch (SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id)) { - case 1: /* ifIndex */ - *value_s32 = netif_to_num(netif); - value_len = sizeof(*value_s32); - break; - case 2: /* ifDescr */ - value_len = sizeof(netif->name); - MEMCPY(value, netif->name, value_len); - break; - case 3: /* ifType */ - *value_s32 = netif->link_type; - value_len = sizeof(*value_s32); - break; - case 4: /* ifMtu */ - *value_s32 = netif->mtu; - value_len = sizeof(*value_s32); - break; - case 5: /* ifSpeed */ - *value_u32 = netif->link_speed; - value_len = sizeof(*value_u32); - break; - case 6: /* ifPhysAddress */ - value_len = sizeof(netif->hwaddr); - MEMCPY(value, &netif->hwaddr, value_len); - break; - case 7: /* ifAdminStatus */ - if (netif_is_up(netif)) { - *value_s32 = iftable_ifOperStatus_up; - } else { - *value_s32 = iftable_ifOperStatus_down; - } - value_len = sizeof(*value_s32); - break; - case 8: /* ifOperStatus */ - if (netif_is_up(netif)) { - if (netif_is_link_up(netif)) { - *value_s32 = iftable_ifAdminStatus_up; - } else { - *value_s32 = iftable_ifAdminStatus_lowerLayerDown; - } - } else { - *value_s32 = iftable_ifAdminStatus_down; - } - value_len = sizeof(*value_s32); - break; - case 9: /* ifLastChange */ - *value_u32 = netif->ts; - value_len = sizeof(*value_u32); - break; - case 10: /* ifInOctets */ - *value_u32 = netif->mib2_counters.ifinoctets; - value_len = sizeof(*value_u32); - break; - case 11: /* ifInUcastPkts */ - *value_u32 = netif->mib2_counters.ifinucastpkts; - value_len = sizeof(*value_u32); - break; - case 12: /* ifInNUcastPkts */ - *value_u32 = netif->mib2_counters.ifinnucastpkts; - value_len = sizeof(*value_u32); - break; - case 13: /* ifInDiscards */ - *value_u32 = netif->mib2_counters.ifindiscards; - value_len = sizeof(*value_u32); - break; - case 14: /* ifInErrors */ - *value_u32 = netif->mib2_counters.ifinerrors; - value_len = sizeof(*value_u32); - break; - case 15: /* ifInUnkownProtos */ - *value_u32 = netif->mib2_counters.ifinunknownprotos; - value_len = sizeof(*value_u32); - break; - case 16: /* ifOutOctets */ - *value_u32 = netif->mib2_counters.ifoutoctets; - value_len = sizeof(*value_u32); - break; - case 17: /* ifOutUcastPkts */ - *value_u32 = netif->mib2_counters.ifoutucastpkts; - value_len = sizeof(*value_u32); - break; - case 18: /* ifOutNUcastPkts */ - *value_u32 = netif->mib2_counters.ifoutnucastpkts; - value_len = sizeof(*value_u32); - break; - case 19: /* ifOutDiscarts */ - *value_u32 = netif->mib2_counters.ifoutdiscards; - value_len = sizeof(*value_u32); - break; - case 20: /* ifOutErrors */ - *value_u32 = netif->mib2_counters.ifouterrors; - value_len = sizeof(*value_u32); - break; - case 21: /* ifOutQLen */ - *value_u32 = iftable_ifOutQLen; - value_len = sizeof(*value_u32); - break; - /** @note returning zeroDotZero (0.0) no media specific MIB support */ - case 22: /* ifSpecific */ - value_len = snmp_zero_dot_zero.len * sizeof(u32_t); - MEMCPY(value, snmp_zero_dot_zero.id, value_len); - break; - default: - return 0; - } - - return value_len; -} - -#if !SNMP_SAFE_REQUESTS - -static snmp_err_t -interfaces_Table_set_test(struct snmp_node_instance *instance, u16_t len, void *value) -{ - s32_t *sint_ptr = (s32_t *)value; - - /* stack should never call this method for another column, - because all other columns are set to readonly */ - LWIP_ASSERT("Invalid column", (SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id) == 7)); - LWIP_UNUSED_ARG(len); - - if (*sint_ptr == 1 || *sint_ptr == 2) { - return SNMP_ERR_NOERROR; - } - - return SNMP_ERR_WRONGVALUE; -} - -static snmp_err_t -interfaces_Table_set_value(struct snmp_node_instance *instance, u16_t len, void *value) -{ - struct netif *netif = (struct netif *)instance->reference.ptr; - s32_t *sint_ptr = (s32_t *)value; - - /* stack should never call this method for another column, - because all other columns are set to readonly */ - LWIP_ASSERT("Invalid column", (SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id) == 7)); - LWIP_UNUSED_ARG(len); - - if (*sint_ptr == 1) { - netif_set_up(netif); - } else if (*sint_ptr == 2) { - netif_set_down(netif); - } - - return SNMP_ERR_NOERROR; -} - -#endif /* SNMP_SAFE_REQUESTS */ - -static const struct snmp_scalar_node interfaces_Number = SNMP_SCALAR_CREATE_NODE_READONLY(1, SNMP_ASN1_TYPE_INTEGER, interfaces_get_value); - -static const struct snmp_table_col_def interfaces_Table_columns[] = { - { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifIndex */ - { 2, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifDescr */ - { 3, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifType */ - { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifMtu */ - { 5, SNMP_ASN1_TYPE_GAUGE, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifSpeed */ - { 6, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifPhysAddress */ -#if !SNMP_SAFE_REQUESTS - { 7, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_WRITE }, /* ifAdminStatus */ -#else - { 7, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifAdminStatus */ -#endif - { 8, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOperStatus */ - { 9, SNMP_ASN1_TYPE_TIMETICKS, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifLastChange */ - { 10, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInOctets */ - { 11, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInUcastPkts */ - { 12, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInNUcastPkts */ - { 13, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInDiscarts */ - { 14, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInErrors */ - { 15, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInUnkownProtos */ - { 16, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutOctets */ - { 17, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutUcastPkts */ - { 18, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutNUcastPkts */ - { 19, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutDiscarts */ - { 20, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutErrors */ - { 21, SNMP_ASN1_TYPE_GAUGE, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutQLen */ - { 22, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY } /* ifSpecific */ -}; - -#if !SNMP_SAFE_REQUESTS -static const struct snmp_table_node interfaces_Table = SNMP_TABLE_CREATE( - 2, interfaces_Table_columns, - interfaces_Table_get_cell_instance, interfaces_Table_get_next_cell_instance, - interfaces_Table_get_value, interfaces_Table_set_test, interfaces_Table_set_value); -#else -static const struct snmp_table_node interfaces_Table = SNMP_TABLE_CREATE( - 2, interfaces_Table_columns, - interfaces_Table_get_cell_instance, interfaces_Table_get_next_cell_instance, - interfaces_Table_get_value, NULL, NULL); -#endif - -/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ -CREATE_LWIP_SYNC_NODE(1, interfaces_Number) -CREATE_LWIP_SYNC_NODE(2, interfaces_Table) - -static const struct snmp_node *const interface_nodes[] = { - &SYNC_NODE_NAME(interfaces_Number).node.node, - &SYNC_NODE_NAME(interfaces_Table).node.node -}; - -const struct snmp_tree_node snmp_mib2_interface_root = SNMP_CREATE_TREE_NODE(2, interface_nodes); - -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ +/** + * @file + * Management Information Base II (RFC1213) INTERFACES objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/netif.h" +#include "lwip/stats.h" + +#include + +#if LWIP_SNMP && SNMP_LWIP_MIB2 + +#if SNMP_USE_NETCONN +#define SYNC_NODE_NAME(node_name) node_name ## _synced +#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ + static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); +#else +#define SYNC_NODE_NAME(node_name) node_name +#define CREATE_LWIP_SYNC_NODE(oid, node_name) +#endif + + +/* --- interfaces .1.3.6.1.2.1.2 ----------------------------------------------------- */ + +static s16_t +interfaces_get_value(struct snmp_node_instance *instance, void *value) +{ + if (instance->node->oid == 1) { + s32_t *sint_ptr = (s32_t *)value; + s32_t num_netifs = 0; + + struct netif *netif; + NETIF_FOREACH(netif) { + num_netifs++; + } + + *sint_ptr = num_netifs; + return sizeof(*sint_ptr); + } + + return 0; +} + +/* list of allowed value ranges for incoming OID */ +static const struct snmp_oid_range interfaces_Table_oid_ranges[] = { + { 1, 0xff } /* netif->num is u8_t */ +}; + +static const u8_t iftable_ifOutQLen = 0; + +static const u8_t iftable_ifOperStatus_up = 1; +static const u8_t iftable_ifOperStatus_down = 2; + +static const u8_t iftable_ifAdminStatus_up = 1; +static const u8_t iftable_ifAdminStatus_lowerLayerDown = 7; +static const u8_t iftable_ifAdminStatus_down = 2; + +static snmp_err_t +interfaces_Table_get_cell_instance(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, struct snmp_node_instance *cell_instance) +{ + u32_t ifIndex; + struct netif *netif; + + LWIP_UNUSED_ARG(column); + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(row_oid, row_oid_len, interfaces_Table_oid_ranges, LWIP_ARRAYSIZE(interfaces_Table_oid_ranges))) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* get netif index from incoming OID */ + ifIndex = row_oid[0]; + + /* find netif with index */ + NETIF_FOREACH(netif) { + if (netif_to_num(netif) == ifIndex) { + /* store netif pointer for subsequent operations (get/test/set) */ + cell_instance->reference.ptr = netif; + return SNMP_ERR_NOERROR; + } + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +interfaces_Table_get_next_cell_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance) +{ + struct netif *netif; + struct snmp_next_oid_state state; + u32_t result_temp[LWIP_ARRAYSIZE(interfaces_Table_oid_ranges)]; + + LWIP_UNUSED_ARG(column); + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(interfaces_Table_oid_ranges)); + + /* iterate over all possible OIDs to find the next one */ + NETIF_FOREACH(netif) { + u32_t test_oid[LWIP_ARRAYSIZE(interfaces_Table_oid_ranges)]; + test_oid[0] = netif_to_num(netif); + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(interfaces_Table_oid_ranges), netif); + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* store netif pointer for subsequent operations (get/test/set) */ + cell_instance->reference.ptr = /* (struct netif*) */state.reference; + return SNMP_ERR_NOERROR; + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static s16_t +interfaces_Table_get_value(struct snmp_node_instance *instance, void *value) +{ + struct netif *netif = (struct netif *)instance->reference.ptr; + u32_t *value_u32 = (u32_t *)value; + s32_t *value_s32 = (s32_t *)value; + u16_t value_len; + + switch (SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id)) { + case 1: /* ifIndex */ + *value_s32 = netif_to_num(netif); + value_len = sizeof(*value_s32); + break; + case 2: /* ifDescr */ + value_len = sizeof(netif->name); + MEMCPY(value, netif->name, value_len); + break; + case 3: /* ifType */ + *value_s32 = netif->link_type; + value_len = sizeof(*value_s32); + break; + case 4: /* ifMtu */ + *value_s32 = netif->mtu; + value_len = sizeof(*value_s32); + break; + case 5: /* ifSpeed */ + *value_u32 = netif->link_speed; + value_len = sizeof(*value_u32); + break; + case 6: /* ifPhysAddress */ + value_len = sizeof(netif->hwaddr); + MEMCPY(value, &netif->hwaddr, value_len); + break; + case 7: /* ifAdminStatus */ + if (netif_is_up(netif)) { + *value_s32 = iftable_ifOperStatus_up; + } else { + *value_s32 = iftable_ifOperStatus_down; + } + value_len = sizeof(*value_s32); + break; + case 8: /* ifOperStatus */ + if (netif_is_up(netif)) { + if (netif_is_link_up(netif)) { + *value_s32 = iftable_ifAdminStatus_up; + } else { + *value_s32 = iftable_ifAdminStatus_lowerLayerDown; + } + } else { + *value_s32 = iftable_ifAdminStatus_down; + } + value_len = sizeof(*value_s32); + break; + case 9: /* ifLastChange */ + *value_u32 = netif->ts; + value_len = sizeof(*value_u32); + break; + case 10: /* ifInOctets */ + *value_u32 = netif->mib2_counters.ifinoctets; + value_len = sizeof(*value_u32); + break; + case 11: /* ifInUcastPkts */ + *value_u32 = netif->mib2_counters.ifinucastpkts; + value_len = sizeof(*value_u32); + break; + case 12: /* ifInNUcastPkts */ + *value_u32 = netif->mib2_counters.ifinnucastpkts; + value_len = sizeof(*value_u32); + break; + case 13: /* ifInDiscards */ + *value_u32 = netif->mib2_counters.ifindiscards; + value_len = sizeof(*value_u32); + break; + case 14: /* ifInErrors */ + *value_u32 = netif->mib2_counters.ifinerrors; + value_len = sizeof(*value_u32); + break; + case 15: /* ifInUnkownProtos */ + *value_u32 = netif->mib2_counters.ifinunknownprotos; + value_len = sizeof(*value_u32); + break; + case 16: /* ifOutOctets */ + *value_u32 = netif->mib2_counters.ifoutoctets; + value_len = sizeof(*value_u32); + break; + case 17: /* ifOutUcastPkts */ + *value_u32 = netif->mib2_counters.ifoutucastpkts; + value_len = sizeof(*value_u32); + break; + case 18: /* ifOutNUcastPkts */ + *value_u32 = netif->mib2_counters.ifoutnucastpkts; + value_len = sizeof(*value_u32); + break; + case 19: /* ifOutDiscarts */ + *value_u32 = netif->mib2_counters.ifoutdiscards; + value_len = sizeof(*value_u32); + break; + case 20: /* ifOutErrors */ + *value_u32 = netif->mib2_counters.ifouterrors; + value_len = sizeof(*value_u32); + break; + case 21: /* ifOutQLen */ + *value_u32 = iftable_ifOutQLen; + value_len = sizeof(*value_u32); + break; + /** @note returning zeroDotZero (0.0) no media specific MIB support */ + case 22: /* ifSpecific */ + value_len = snmp_zero_dot_zero.len * sizeof(u32_t); + MEMCPY(value, snmp_zero_dot_zero.id, value_len); + break; + default: + return 0; + } + + return value_len; +} + +#if !SNMP_SAFE_REQUESTS + +static snmp_err_t +interfaces_Table_set_test(struct snmp_node_instance *instance, u16_t len, void *value) +{ + s32_t *sint_ptr = (s32_t *)value; + + /* stack should never call this method for another column, + because all other columns are set to readonly */ + LWIP_ASSERT("Invalid column", (SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id) == 7)); + LWIP_UNUSED_ARG(len); + + if (*sint_ptr == 1 || *sint_ptr == 2) { + return SNMP_ERR_NOERROR; + } + + return SNMP_ERR_WRONGVALUE; +} + +static snmp_err_t +interfaces_Table_set_value(struct snmp_node_instance *instance, u16_t len, void *value) +{ + struct netif *netif = (struct netif *)instance->reference.ptr; + s32_t *sint_ptr = (s32_t *)value; + + /* stack should never call this method for another column, + because all other columns are set to readonly */ + LWIP_ASSERT("Invalid column", (SNMP_TABLE_GET_COLUMN_FROM_OID(instance->instance_oid.id) == 7)); + LWIP_UNUSED_ARG(len); + + if (*sint_ptr == 1) { + netif_set_up(netif); + } else if (*sint_ptr == 2) { + netif_set_down(netif); + } + + return SNMP_ERR_NOERROR; +} + +#endif /* SNMP_SAFE_REQUESTS */ + +static const struct snmp_scalar_node interfaces_Number = SNMP_SCALAR_CREATE_NODE_READONLY(1, SNMP_ASN1_TYPE_INTEGER, interfaces_get_value); + +static const struct snmp_table_col_def interfaces_Table_columns[] = { + { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifIndex */ + { 2, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifDescr */ + { 3, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifType */ + { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifMtu */ + { 5, SNMP_ASN1_TYPE_GAUGE, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifSpeed */ + { 6, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifPhysAddress */ +#if !SNMP_SAFE_REQUESTS + { 7, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_WRITE }, /* ifAdminStatus */ +#else + { 7, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifAdminStatus */ +#endif + { 8, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOperStatus */ + { 9, SNMP_ASN1_TYPE_TIMETICKS, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifLastChange */ + { 10, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInOctets */ + { 11, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInUcastPkts */ + { 12, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInNUcastPkts */ + { 13, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInDiscarts */ + { 14, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInErrors */ + { 15, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifInUnkownProtos */ + { 16, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutOctets */ + { 17, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutUcastPkts */ + { 18, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutNUcastPkts */ + { 19, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutDiscarts */ + { 20, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutErrors */ + { 21, SNMP_ASN1_TYPE_GAUGE, SNMP_NODE_INSTANCE_READ_ONLY }, /* ifOutQLen */ + { 22, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY } /* ifSpecific */ +}; + +#if !SNMP_SAFE_REQUESTS +static const struct snmp_table_node interfaces_Table = SNMP_TABLE_CREATE( + 2, interfaces_Table_columns, + interfaces_Table_get_cell_instance, interfaces_Table_get_next_cell_instance, + interfaces_Table_get_value, interfaces_Table_set_test, interfaces_Table_set_value); +#else +static const struct snmp_table_node interfaces_Table = SNMP_TABLE_CREATE( + 2, interfaces_Table_columns, + interfaces_Table_get_cell_instance, interfaces_Table_get_next_cell_instance, + interfaces_Table_get_value, NULL, NULL); +#endif + +/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ +CREATE_LWIP_SYNC_NODE(1, interfaces_Number) +CREATE_LWIP_SYNC_NODE(2, interfaces_Table) + +static const struct snmp_node *const interface_nodes[] = { + &SYNC_NODE_NAME(interfaces_Number).node.node, + &SYNC_NODE_NAME(interfaces_Table).node.node +}; + +const struct snmp_tree_node snmp_mib2_interface_root = SNMP_CREATE_TREE_NODE(2, interface_nodes); + +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_ip.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_ip.c index de109907..6931049e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_ip.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_ip.c @@ -1,731 +1,731 @@ -/** - * @file - * Management Information Base II (RFC1213) IP objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/stats.h" -#include "lwip/netif.h" -#include "lwip/ip.h" -#include "lwip/etharp.h" - -#if LWIP_SNMP && SNMP_LWIP_MIB2 - -#if SNMP_USE_NETCONN -#define SYNC_NODE_NAME(node_name) node_name ## _synced -#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ - static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); -#else -#define SYNC_NODE_NAME(node_name) node_name -#define CREATE_LWIP_SYNC_NODE(oid, node_name) -#endif - -#if LWIP_IPV4 -/* --- ip .1.3.6.1.2.1.4 ----------------------------------------------------- */ - -static s16_t -ip_get_value(struct snmp_node_instance *instance, void *value) -{ - s32_t *sint_ptr = (s32_t *)value; - u32_t *uint_ptr = (u32_t *)value; - - switch (instance->node->oid) { - case 1: /* ipForwarding */ -#if IP_FORWARD - /* forwarding */ - *sint_ptr = 1; -#else - /* not-forwarding */ - *sint_ptr = 2; -#endif - return sizeof(*sint_ptr); - case 2: /* ipDefaultTTL */ - *sint_ptr = IP_DEFAULT_TTL; - return sizeof(*sint_ptr); - case 3: /* ipInReceives */ - *uint_ptr = STATS_GET(mib2.ipinreceives); - return sizeof(*uint_ptr); - case 4: /* ipInHdrErrors */ - *uint_ptr = STATS_GET(mib2.ipinhdrerrors); - return sizeof(*uint_ptr); - case 5: /* ipInAddrErrors */ - *uint_ptr = STATS_GET(mib2.ipinaddrerrors); - return sizeof(*uint_ptr); - case 6: /* ipForwDatagrams */ - *uint_ptr = STATS_GET(mib2.ipforwdatagrams); - return sizeof(*uint_ptr); - case 7: /* ipInUnknownProtos */ - *uint_ptr = STATS_GET(mib2.ipinunknownprotos); - return sizeof(*uint_ptr); - case 8: /* ipInDiscards */ - *uint_ptr = STATS_GET(mib2.ipindiscards); - return sizeof(*uint_ptr); - case 9: /* ipInDelivers */ - *uint_ptr = STATS_GET(mib2.ipindelivers); - return sizeof(*uint_ptr); - case 10: /* ipOutRequests */ - *uint_ptr = STATS_GET(mib2.ipoutrequests); - return sizeof(*uint_ptr); - case 11: /* ipOutDiscards */ - *uint_ptr = STATS_GET(mib2.ipoutdiscards); - return sizeof(*uint_ptr); - case 12: /* ipOutNoRoutes */ - *uint_ptr = STATS_GET(mib2.ipoutnoroutes); - return sizeof(*uint_ptr); - case 13: /* ipReasmTimeout */ -#if IP_REASSEMBLY - *sint_ptr = IP_REASS_MAXAGE; -#else - *sint_ptr = 0; -#endif - return sizeof(*sint_ptr); - case 14: /* ipReasmReqds */ - *uint_ptr = STATS_GET(mib2.ipreasmreqds); - return sizeof(*uint_ptr); - case 15: /* ipReasmOKs */ - *uint_ptr = STATS_GET(mib2.ipreasmoks); - return sizeof(*uint_ptr); - case 16: /* ipReasmFails */ - *uint_ptr = STATS_GET(mib2.ipreasmfails); - return sizeof(*uint_ptr); - case 17: /* ipFragOKs */ - *uint_ptr = STATS_GET(mib2.ipfragoks); - return sizeof(*uint_ptr); - case 18: /* ipFragFails */ - *uint_ptr = STATS_GET(mib2.ipfragfails); - return sizeof(*uint_ptr); - case 19: /* ipFragCreates */ - *uint_ptr = STATS_GET(mib2.ipfragcreates); - return sizeof(*uint_ptr); - case 23: /* ipRoutingDiscards: not supported -> always 0 */ - *uint_ptr = 0; - return sizeof(*uint_ptr); - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("ip_get_value(): unknown id: %"S32_F"\n", instance->node->oid)); - break; - } - - return 0; -} - -/** - * Test ip object value before setting. - * - * @param instance node instance - * @param len return value space (in bytes) - * @param value points to (varbind) space to copy value from. - * - * @note we allow set if the value matches the hardwired value, - * otherwise return badvalue. - */ -static snmp_err_t -ip_set_test(struct snmp_node_instance *instance, u16_t len, void *value) -{ - snmp_err_t ret = SNMP_ERR_WRONGVALUE; - s32_t *sint_ptr = (s32_t *)value; - - LWIP_UNUSED_ARG(len); - switch (instance->node->oid) { - case 1: /* ipForwarding */ -#if IP_FORWARD - /* forwarding */ - if (*sint_ptr == 1) -#else - /* not-forwarding */ - if (*sint_ptr == 2) -#endif - { - ret = SNMP_ERR_NOERROR; - } - break; - case 2: /* ipDefaultTTL */ - if (*sint_ptr == IP_DEFAULT_TTL) { - ret = SNMP_ERR_NOERROR; - } - break; - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("ip_set_test(): unknown id: %"S32_F"\n", instance->node->oid)); - break; - } - - return ret; -} - -static snmp_err_t -ip_set_value(struct snmp_node_instance *instance, u16_t len, void *value) -{ - LWIP_UNUSED_ARG(instance); - LWIP_UNUSED_ARG(len); - LWIP_UNUSED_ARG(value); - /* nothing to do here because in set_test we only accept values being the same as our own stored value -> no need to store anything */ - return SNMP_ERR_NOERROR; -} - -/* --- ipAddrTable --- */ - -/* list of allowed value ranges for incoming OID */ -static const struct snmp_oid_range ip_AddrTable_oid_ranges[] = { - { 0, 0xff }, /* IP A */ - { 0, 0xff }, /* IP B */ - { 0, 0xff }, /* IP C */ - { 0, 0xff } /* IP D */ -}; - -static snmp_err_t -ip_AddrTable_get_cell_value_core(struct netif *netif, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) -{ - LWIP_UNUSED_ARG(value_len); - - switch (*column) { - case 1: /* ipAdEntAddr */ - value->u32 = netif_ip4_addr(netif)->addr; - break; - case 2: /* ipAdEntIfIndex */ - value->u32 = netif_to_num(netif); - break; - case 3: /* ipAdEntNetMask */ - value->u32 = netif_ip4_netmask(netif)->addr; - break; - case 4: /* ipAdEntBcastAddr */ - /* lwIP oddity, there's no broadcast - address in the netif we can rely on */ - value->u32 = IPADDR_BROADCAST & 1; - break; - case 5: /* ipAdEntReasmMaxSize */ -#if IP_REASSEMBLY - /* @todo The theoretical maximum is IP_REASS_MAX_PBUFS * size of the pbufs, - * but only if receiving one fragmented packet at a time. - * The current solution is to calculate for 2 simultaneous packets... - */ - value->u32 = (IP_HLEN + ((IP_REASS_MAX_PBUFS / 2) * - (PBUF_POOL_BUFSIZE - PBUF_LINK_ENCAPSULATION_HLEN - PBUF_LINK_HLEN - IP_HLEN))); -#else - /** @todo returning MTU would be a bad thing and - returning a wild guess like '576' isn't good either */ - value->u32 = 0; -#endif - break; - default: - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -ip_AddrTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - ip4_addr_t ip; - struct netif *netif; - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(row_oid, row_oid_len, ip_AddrTable_oid_ranges, LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges))) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* get IP from incoming OID */ - snmp_oid_to_ip4(&row_oid[0], &ip); /* we know it succeeds because of oid_in_range check above */ - - /* find netif with requested ip */ - NETIF_FOREACH(netif) { - if (ip4_addr_cmp(&ip, netif_ip4_addr(netif))) { - /* fill in object properties */ - return ip_AddrTable_get_cell_value_core(netif, column, value, value_len); - } - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -ip_AddrTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - struct netif *netif; - struct snmp_next_oid_state state; - u32_t result_temp[LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges)]; - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges)); - - /* iterate over all possible OIDs to find the next one */ - NETIF_FOREACH(netif) { - u32_t test_oid[LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges)]; - snmp_ip4_to_oid(netif_ip4_addr(netif), &test_oid[0]); - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges), netif); - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return ip_AddrTable_get_cell_value_core((struct netif *)state.reference, column, value, value_len); - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -/* --- ipRouteTable --- */ - -/* list of allowed value ranges for incoming OID */ -static const struct snmp_oid_range ip_RouteTable_oid_ranges[] = { - { 0, 0xff }, /* IP A */ - { 0, 0xff }, /* IP B */ - { 0, 0xff }, /* IP C */ - { 0, 0xff }, /* IP D */ -}; - -static snmp_err_t -ip_RouteTable_get_cell_value_core(struct netif *netif, u8_t default_route, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) -{ - switch (*column) { - case 1: /* ipRouteDest */ - if (default_route) { - /* default rte has 0.0.0.0 dest */ - value->u32 = IP4_ADDR_ANY4->addr; - } else { - /* netifs have netaddress dest */ - ip4_addr_t tmp; - ip4_addr_get_network(&tmp, netif_ip4_addr(netif), netif_ip4_netmask(netif)); - value->u32 = tmp.addr; - } - break; - case 2: /* ipRouteIfIndex */ - value->u32 = netif_to_num(netif); - break; - case 3: /* ipRouteMetric1 */ - if (default_route) { - value->s32 = 1; /* default */ - } else { - value->s32 = 0; /* normal */ - } - break; - case 4: /* ipRouteMetric2 */ - case 5: /* ipRouteMetric3 */ - case 6: /* ipRouteMetric4 */ - value->s32 = -1; /* none */ - break; - case 7: /* ipRouteNextHop */ - if (default_route) { - /* default rte: gateway */ - value->u32 = netif_ip4_gw(netif)->addr; - } else { - /* other rtes: netif ip_addr */ - value->u32 = netif_ip4_addr(netif)->addr; - } - break; - case 8: /* ipRouteType */ - if (default_route) { - /* default rte is indirect */ - value->u32 = 4; /* indirect */ - } else { - /* other rtes are direct */ - value->u32 = 3; /* direct */ - } - break; - case 9: /* ipRouteProto */ - /* locally defined routes */ - value->u32 = 2; /* local */ - break; - case 10: /* ipRouteAge */ - /* @todo (sysuptime - timestamp last change) / 100 */ - value->u32 = 0; - break; - case 11: /* ipRouteMask */ - if (default_route) { - /* default rte use 0.0.0.0 mask */ - value->u32 = IP4_ADDR_ANY4->addr; - } else { - /* other rtes use netmask */ - value->u32 = netif_ip4_netmask(netif)->addr; - } - break; - case 12: /* ipRouteMetric5 */ - value->s32 = -1; /* none */ - break; - case 13: /* ipRouteInfo */ - value->const_ptr = snmp_zero_dot_zero.id; - *value_len = snmp_zero_dot_zero.len * sizeof(u32_t); - break; - default: - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -ip_RouteTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - ip4_addr_t test_ip; - struct netif *netif; - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(row_oid, row_oid_len, ip_RouteTable_oid_ranges, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges))) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* get IP and port from incoming OID */ - snmp_oid_to_ip4(&row_oid[0], &test_ip); /* we know it succeeds because of oid_in_range check above */ - - /* default route is on default netif */ - if (ip4_addr_isany_val(test_ip) && (netif_default != NULL)) { - /* fill in object properties */ - return ip_RouteTable_get_cell_value_core(netif_default, 1, column, value, value_len); - } - - /* find netif with requested route */ - NETIF_FOREACH(netif) { - ip4_addr_t dst; - ip4_addr_get_network(&dst, netif_ip4_addr(netif), netif_ip4_netmask(netif)); - - if (ip4_addr_cmp(&dst, &test_ip)) { - /* fill in object properties */ - return ip_RouteTable_get_cell_value_core(netif, 0, column, value, value_len); - } - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -ip_RouteTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - struct netif *netif; - struct snmp_next_oid_state state; - u32_t result_temp[LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges)]; - u32_t test_oid[LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges)]; - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges)); - - /* check default route */ - if (netif_default != NULL) { - snmp_ip4_to_oid(IP4_ADDR_ANY4, &test_oid[0]); - snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges), netif_default); - } - - /* iterate over all possible OIDs to find the next one */ - NETIF_FOREACH(netif) { - ip4_addr_t dst; - ip4_addr_get_network(&dst, netif_ip4_addr(netif), netif_ip4_netmask(netif)); - - /* check generated OID: is it a candidate for the next one? */ - if (!ip4_addr_isany_val(dst)) { - snmp_ip4_to_oid(&dst, &test_oid[0]); - snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges), netif); - } - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - ip4_addr_t dst; - snmp_oid_to_ip4(&result_temp[0], &dst); - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return ip_RouteTable_get_cell_value_core((struct netif *)state.reference, ip4_addr_isany_val(dst), column, value, value_len); - } else { - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; - } -} - -#if LWIP_ARP && LWIP_IPV4 -/* --- ipNetToMediaTable --- */ - -/* list of allowed value ranges for incoming OID */ -static const struct snmp_oid_range ip_NetToMediaTable_oid_ranges[] = { - { 1, 0xff }, /* IfIndex */ - { 0, 0xff }, /* IP A */ - { 0, 0xff }, /* IP B */ - { 0, 0xff }, /* IP C */ - { 0, 0xff } /* IP D */ -}; - -static snmp_err_t -ip_NetToMediaTable_get_cell_value_core(size_t arp_table_index, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) -{ - ip4_addr_t *ip; - struct netif *netif; - struct eth_addr *ethaddr; - - etharp_get_entry(arp_table_index, &ip, &netif, ðaddr); - - /* value */ - switch (*column) { - case 1: /* atIfIndex / ipNetToMediaIfIndex */ - value->u32 = netif_to_num(netif); - break; - case 2: /* atPhysAddress / ipNetToMediaPhysAddress */ - value->ptr = ethaddr; - *value_len = sizeof(*ethaddr); - break; - case 3: /* atNetAddress / ipNetToMediaNetAddress */ - value->u32 = ip->addr; - break; - case 4: /* ipNetToMediaType */ - value->u32 = 3; /* dynamic*/ - break; - default: - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -ip_NetToMediaTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - ip4_addr_t ip_in; - u8_t netif_index; - size_t i; - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(row_oid, row_oid_len, ip_NetToMediaTable_oid_ranges, LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges))) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* get IP from incoming OID */ - netif_index = (u8_t)row_oid[0]; - snmp_oid_to_ip4(&row_oid[1], &ip_in); /* we know it succeeds because of oid_in_range check above */ - - /* find requested entry */ - for (i = 0; i < ARP_TABLE_SIZE; i++) { - ip4_addr_t *ip; - struct netif *netif; - struct eth_addr *ethaddr; - - if (etharp_get_entry(i, &ip, &netif, ðaddr)) { - if ((netif_index == netif_to_num(netif)) && ip4_addr_cmp(&ip_in, ip)) { - /* fill in object properties */ - return ip_NetToMediaTable_get_cell_value_core(i, column, value, value_len); - } - } - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -ip_NetToMediaTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - size_t i; - struct snmp_next_oid_state state; - u32_t result_temp[LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges)]; - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges)); - - /* iterate over all possible OIDs to find the next one */ - for (i = 0; i < ARP_TABLE_SIZE; i++) { - ip4_addr_t *ip; - struct netif *netif; - struct eth_addr *ethaddr; - - if (etharp_get_entry(i, &ip, &netif, ðaddr)) { - u32_t test_oid[LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges)]; - - test_oid[0] = netif_to_num(netif); - snmp_ip4_to_oid(ip, &test_oid[1]); - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges), LWIP_PTR_NUMERIC_CAST(void *, i)); - } - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return ip_NetToMediaTable_get_cell_value_core(LWIP_PTR_NUMERIC_CAST(size_t, state.reference), column, value, value_len); - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -#endif /* LWIP_ARP && LWIP_IPV4 */ - -static const struct snmp_scalar_node ip_Forwarding = SNMP_SCALAR_CREATE_NODE(1, SNMP_NODE_INSTANCE_READ_WRITE, SNMP_ASN1_TYPE_INTEGER, ip_get_value, ip_set_test, ip_set_value); -static const struct snmp_scalar_node ip_DefaultTTL = SNMP_SCALAR_CREATE_NODE(2, SNMP_NODE_INSTANCE_READ_WRITE, SNMP_ASN1_TYPE_INTEGER, ip_get_value, ip_set_test, ip_set_value); -static const struct snmp_scalar_node ip_InReceives = SNMP_SCALAR_CREATE_NODE_READONLY(3, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_InHdrErrors = SNMP_SCALAR_CREATE_NODE_READONLY(4, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_InAddrErrors = SNMP_SCALAR_CREATE_NODE_READONLY(5, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_ForwDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(6, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_InUnknownProtos = SNMP_SCALAR_CREATE_NODE_READONLY(7, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_InDiscards = SNMP_SCALAR_CREATE_NODE_READONLY(8, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_InDelivers = SNMP_SCALAR_CREATE_NODE_READONLY(9, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_OutRequests = SNMP_SCALAR_CREATE_NODE_READONLY(10, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_OutDiscards = SNMP_SCALAR_CREATE_NODE_READONLY(11, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_OutNoRoutes = SNMP_SCALAR_CREATE_NODE_READONLY(12, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_ReasmTimeout = SNMP_SCALAR_CREATE_NODE_READONLY(13, SNMP_ASN1_TYPE_INTEGER, ip_get_value); -static const struct snmp_scalar_node ip_ReasmReqds = SNMP_SCALAR_CREATE_NODE_READONLY(14, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_ReasmOKs = SNMP_SCALAR_CREATE_NODE_READONLY(15, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_ReasmFails = SNMP_SCALAR_CREATE_NODE_READONLY(16, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_FragOKs = SNMP_SCALAR_CREATE_NODE_READONLY(17, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_FragFails = SNMP_SCALAR_CREATE_NODE_READONLY(18, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_FragCreates = SNMP_SCALAR_CREATE_NODE_READONLY(19, SNMP_ASN1_TYPE_COUNTER, ip_get_value); -static const struct snmp_scalar_node ip_RoutingDiscards = SNMP_SCALAR_CREATE_NODE_READONLY(23, SNMP_ASN1_TYPE_COUNTER, ip_get_value); - -static const struct snmp_table_simple_col_def ip_AddrTable_columns[] = { - { 1, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntAddr */ - { 2, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntIfIndex */ - { 3, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntNetMask */ - { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntBcastAddr */ - { 5, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* ipAdEntReasmMaxSize */ -}; - -static const struct snmp_table_simple_node ip_AddrTable = SNMP_TABLE_CREATE_SIMPLE(20, ip_AddrTable_columns, ip_AddrTable_get_cell_value, ip_AddrTable_get_next_cell_instance_and_value); - -static const struct snmp_table_simple_col_def ip_RouteTable_columns[] = { - { 1, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteDest */ - { 2, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteIfIndex */ - { 3, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric1 */ - { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric2 */ - { 5, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric3 */ - { 6, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric4 */ - { 7, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteNextHop */ - { 8, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteType */ - { 9, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteProto */ - { 10, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteAge */ - { 11, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteMask */ - { 12, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric5 */ - { 13, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_VARIANT_VALUE_TYPE_PTR } /* ipRouteInfo */ -}; - -static const struct snmp_table_simple_node ip_RouteTable = SNMP_TABLE_CREATE_SIMPLE(21, ip_RouteTable_columns, ip_RouteTable_get_cell_value, ip_RouteTable_get_next_cell_instance_and_value); -#endif /* LWIP_IPV4 */ - -#if LWIP_ARP && LWIP_IPV4 -static const struct snmp_table_simple_col_def ip_NetToMediaTable_columns[] = { - { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipNetToMediaIfIndex */ - { 2, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_VARIANT_VALUE_TYPE_PTR }, /* ipNetToMediaPhysAddress */ - { 3, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipNetToMediaNetAddress */ - { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* ipNetToMediaType */ -}; - -static const struct snmp_table_simple_node ip_NetToMediaTable = SNMP_TABLE_CREATE_SIMPLE(22, ip_NetToMediaTable_columns, ip_NetToMediaTable_get_cell_value, ip_NetToMediaTable_get_next_cell_instance_and_value); -#endif /* LWIP_ARP && LWIP_IPV4 */ - -#if LWIP_IPV4 -/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ -CREATE_LWIP_SYNC_NODE( 1, ip_Forwarding) -CREATE_LWIP_SYNC_NODE( 2, ip_DefaultTTL) -CREATE_LWIP_SYNC_NODE( 3, ip_InReceives) -CREATE_LWIP_SYNC_NODE( 4, ip_InHdrErrors) -CREATE_LWIP_SYNC_NODE( 5, ip_InAddrErrors) -CREATE_LWIP_SYNC_NODE( 6, ip_ForwDatagrams) -CREATE_LWIP_SYNC_NODE( 7, ip_InUnknownProtos) -CREATE_LWIP_SYNC_NODE( 8, ip_InDiscards) -CREATE_LWIP_SYNC_NODE( 9, ip_InDelivers) -CREATE_LWIP_SYNC_NODE(10, ip_OutRequests) -CREATE_LWIP_SYNC_NODE(11, ip_OutDiscards) -CREATE_LWIP_SYNC_NODE(12, ip_OutNoRoutes) -CREATE_LWIP_SYNC_NODE(13, ip_ReasmTimeout) -CREATE_LWIP_SYNC_NODE(14, ip_ReasmReqds) -CREATE_LWIP_SYNC_NODE(15, ip_ReasmOKs) -CREATE_LWIP_SYNC_NODE(15, ip_ReasmFails) -CREATE_LWIP_SYNC_NODE(17, ip_FragOKs) -CREATE_LWIP_SYNC_NODE(18, ip_FragFails) -CREATE_LWIP_SYNC_NODE(19, ip_FragCreates) -CREATE_LWIP_SYNC_NODE(20, ip_AddrTable) -CREATE_LWIP_SYNC_NODE(21, ip_RouteTable) -#if LWIP_ARP -CREATE_LWIP_SYNC_NODE(22, ip_NetToMediaTable) -#endif /* LWIP_ARP */ -CREATE_LWIP_SYNC_NODE(23, ip_RoutingDiscards) - -static const struct snmp_node *const ip_nodes[] = { - &SYNC_NODE_NAME(ip_Forwarding).node.node, - &SYNC_NODE_NAME(ip_DefaultTTL).node.node, - &SYNC_NODE_NAME(ip_InReceives).node.node, - &SYNC_NODE_NAME(ip_InHdrErrors).node.node, - &SYNC_NODE_NAME(ip_InAddrErrors).node.node, - &SYNC_NODE_NAME(ip_ForwDatagrams).node.node, - &SYNC_NODE_NAME(ip_InUnknownProtos).node.node, - &SYNC_NODE_NAME(ip_InDiscards).node.node, - &SYNC_NODE_NAME(ip_InDelivers).node.node, - &SYNC_NODE_NAME(ip_OutRequests).node.node, - &SYNC_NODE_NAME(ip_OutDiscards).node.node, - &SYNC_NODE_NAME(ip_OutNoRoutes).node.node, - &SYNC_NODE_NAME(ip_ReasmTimeout).node.node, - &SYNC_NODE_NAME(ip_ReasmReqds).node.node, - &SYNC_NODE_NAME(ip_ReasmOKs).node.node, - &SYNC_NODE_NAME(ip_ReasmFails).node.node, - &SYNC_NODE_NAME(ip_FragOKs).node.node, - &SYNC_NODE_NAME(ip_FragFails).node.node, - &SYNC_NODE_NAME(ip_FragCreates).node.node, - &SYNC_NODE_NAME(ip_AddrTable).node.node, - &SYNC_NODE_NAME(ip_RouteTable).node.node, -#if LWIP_ARP - &SYNC_NODE_NAME(ip_NetToMediaTable).node.node, -#endif /* LWIP_ARP */ - &SYNC_NODE_NAME(ip_RoutingDiscards).node.node -}; - -const struct snmp_tree_node snmp_mib2_ip_root = SNMP_CREATE_TREE_NODE(4, ip_nodes); -#endif /* LWIP_IPV4 */ - -/* --- at .1.3.6.1.2.1.3 ----------------------------------------------------- */ - -#if LWIP_ARP && LWIP_IPV4 -/* at node table is a subset of ip_nettomedia table (same rows but less columns) */ -static const struct snmp_table_simple_col_def at_Table_columns[] = { - { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* atIfIndex */ - { 2, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_VARIANT_VALUE_TYPE_PTR }, /* atPhysAddress */ - { 3, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 } /* atNetAddress */ -}; - -static const struct snmp_table_simple_node at_Table = SNMP_TABLE_CREATE_SIMPLE(1, at_Table_columns, ip_NetToMediaTable_get_cell_value, ip_NetToMediaTable_get_next_cell_instance_and_value); - -/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ -CREATE_LWIP_SYNC_NODE(1, at_Table) - -static const struct snmp_node *const at_nodes[] = { - &SYNC_NODE_NAME(at_Table).node.node -}; - -const struct snmp_tree_node snmp_mib2_at_root = SNMP_CREATE_TREE_NODE(3, at_nodes); -#endif /* LWIP_ARP && LWIP_IPV4 */ - -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ +/** + * @file + * Management Information Base II (RFC1213) IP objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/stats.h" +#include "lwip/netif.h" +#include "lwip/ip.h" +#include "lwip/etharp.h" + +#if LWIP_SNMP && SNMP_LWIP_MIB2 + +#if SNMP_USE_NETCONN +#define SYNC_NODE_NAME(node_name) node_name ## _synced +#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ + static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); +#else +#define SYNC_NODE_NAME(node_name) node_name +#define CREATE_LWIP_SYNC_NODE(oid, node_name) +#endif + +#if LWIP_IPV4 +/* --- ip .1.3.6.1.2.1.4 ----------------------------------------------------- */ + +static s16_t +ip_get_value(struct snmp_node_instance *instance, void *value) +{ + s32_t *sint_ptr = (s32_t *)value; + u32_t *uint_ptr = (u32_t *)value; + + switch (instance->node->oid) { + case 1: /* ipForwarding */ +#if IP_FORWARD + /* forwarding */ + *sint_ptr = 1; +#else + /* not-forwarding */ + *sint_ptr = 2; +#endif + return sizeof(*sint_ptr); + case 2: /* ipDefaultTTL */ + *sint_ptr = IP_DEFAULT_TTL; + return sizeof(*sint_ptr); + case 3: /* ipInReceives */ + *uint_ptr = STATS_GET(mib2.ipinreceives); + return sizeof(*uint_ptr); + case 4: /* ipInHdrErrors */ + *uint_ptr = STATS_GET(mib2.ipinhdrerrors); + return sizeof(*uint_ptr); + case 5: /* ipInAddrErrors */ + *uint_ptr = STATS_GET(mib2.ipinaddrerrors); + return sizeof(*uint_ptr); + case 6: /* ipForwDatagrams */ + *uint_ptr = STATS_GET(mib2.ipforwdatagrams); + return sizeof(*uint_ptr); + case 7: /* ipInUnknownProtos */ + *uint_ptr = STATS_GET(mib2.ipinunknownprotos); + return sizeof(*uint_ptr); + case 8: /* ipInDiscards */ + *uint_ptr = STATS_GET(mib2.ipindiscards); + return sizeof(*uint_ptr); + case 9: /* ipInDelivers */ + *uint_ptr = STATS_GET(mib2.ipindelivers); + return sizeof(*uint_ptr); + case 10: /* ipOutRequests */ + *uint_ptr = STATS_GET(mib2.ipoutrequests); + return sizeof(*uint_ptr); + case 11: /* ipOutDiscards */ + *uint_ptr = STATS_GET(mib2.ipoutdiscards); + return sizeof(*uint_ptr); + case 12: /* ipOutNoRoutes */ + *uint_ptr = STATS_GET(mib2.ipoutnoroutes); + return sizeof(*uint_ptr); + case 13: /* ipReasmTimeout */ +#if IP_REASSEMBLY + *sint_ptr = IP_REASS_MAXAGE; +#else + *sint_ptr = 0; +#endif + return sizeof(*sint_ptr); + case 14: /* ipReasmReqds */ + *uint_ptr = STATS_GET(mib2.ipreasmreqds); + return sizeof(*uint_ptr); + case 15: /* ipReasmOKs */ + *uint_ptr = STATS_GET(mib2.ipreasmoks); + return sizeof(*uint_ptr); + case 16: /* ipReasmFails */ + *uint_ptr = STATS_GET(mib2.ipreasmfails); + return sizeof(*uint_ptr); + case 17: /* ipFragOKs */ + *uint_ptr = STATS_GET(mib2.ipfragoks); + return sizeof(*uint_ptr); + case 18: /* ipFragFails */ + *uint_ptr = STATS_GET(mib2.ipfragfails); + return sizeof(*uint_ptr); + case 19: /* ipFragCreates */ + *uint_ptr = STATS_GET(mib2.ipfragcreates); + return sizeof(*uint_ptr); + case 23: /* ipRoutingDiscards: not supported -> always 0 */ + *uint_ptr = 0; + return sizeof(*uint_ptr); + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("ip_get_value(): unknown id: %"S32_F"\n", instance->node->oid)); + break; + } + + return 0; +} + +/** + * Test ip object value before setting. + * + * @param instance node instance + * @param len return value space (in bytes) + * @param value points to (varbind) space to copy value from. + * + * @note we allow set if the value matches the hardwired value, + * otherwise return badvalue. + */ +static snmp_err_t +ip_set_test(struct snmp_node_instance *instance, u16_t len, void *value) +{ + snmp_err_t ret = SNMP_ERR_WRONGVALUE; + s32_t *sint_ptr = (s32_t *)value; + + LWIP_UNUSED_ARG(len); + switch (instance->node->oid) { + case 1: /* ipForwarding */ +#if IP_FORWARD + /* forwarding */ + if (*sint_ptr == 1) +#else + /* not-forwarding */ + if (*sint_ptr == 2) +#endif + { + ret = SNMP_ERR_NOERROR; + } + break; + case 2: /* ipDefaultTTL */ + if (*sint_ptr == IP_DEFAULT_TTL) { + ret = SNMP_ERR_NOERROR; + } + break; + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("ip_set_test(): unknown id: %"S32_F"\n", instance->node->oid)); + break; + } + + return ret; +} + +static snmp_err_t +ip_set_value(struct snmp_node_instance *instance, u16_t len, void *value) +{ + LWIP_UNUSED_ARG(instance); + LWIP_UNUSED_ARG(len); + LWIP_UNUSED_ARG(value); + /* nothing to do here because in set_test we only accept values being the same as our own stored value -> no need to store anything */ + return SNMP_ERR_NOERROR; +} + +/* --- ipAddrTable --- */ + +/* list of allowed value ranges for incoming OID */ +static const struct snmp_oid_range ip_AddrTable_oid_ranges[] = { + { 0, 0xff }, /* IP A */ + { 0, 0xff }, /* IP B */ + { 0, 0xff }, /* IP C */ + { 0, 0xff } /* IP D */ +}; + +static snmp_err_t +ip_AddrTable_get_cell_value_core(struct netif *netif, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) +{ + LWIP_UNUSED_ARG(value_len); + + switch (*column) { + case 1: /* ipAdEntAddr */ + value->u32 = netif_ip4_addr(netif)->addr; + break; + case 2: /* ipAdEntIfIndex */ + value->u32 = netif_to_num(netif); + break; + case 3: /* ipAdEntNetMask */ + value->u32 = netif_ip4_netmask(netif)->addr; + break; + case 4: /* ipAdEntBcastAddr */ + /* lwIP oddity, there's no broadcast + address in the netif we can rely on */ + value->u32 = IPADDR_BROADCAST & 1; + break; + case 5: /* ipAdEntReasmMaxSize */ +#if IP_REASSEMBLY + /* @todo The theoretical maximum is IP_REASS_MAX_PBUFS * size of the pbufs, + * but only if receiving one fragmented packet at a time. + * The current solution is to calculate for 2 simultaneous packets... + */ + value->u32 = (IP_HLEN + ((IP_REASS_MAX_PBUFS / 2) * + (PBUF_POOL_BUFSIZE - PBUF_LINK_ENCAPSULATION_HLEN - PBUF_LINK_HLEN - IP_HLEN))); +#else + /** @todo returning MTU would be a bad thing and + returning a wild guess like '576' isn't good either */ + value->u32 = 0; +#endif + break; + default: + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +ip_AddrTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + ip4_addr_t ip; + struct netif *netif; + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(row_oid, row_oid_len, ip_AddrTable_oid_ranges, LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges))) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* get IP from incoming OID */ + snmp_oid_to_ip4(&row_oid[0], &ip); /* we know it succeeds because of oid_in_range check above */ + + /* find netif with requested ip */ + NETIF_FOREACH(netif) { + if (ip4_addr_cmp(&ip, netif_ip4_addr(netif))) { + /* fill in object properties */ + return ip_AddrTable_get_cell_value_core(netif, column, value, value_len); + } + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +ip_AddrTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + struct netif *netif; + struct snmp_next_oid_state state; + u32_t result_temp[LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges)]; + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges)); + + /* iterate over all possible OIDs to find the next one */ + NETIF_FOREACH(netif) { + u32_t test_oid[LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges)]; + snmp_ip4_to_oid(netif_ip4_addr(netif), &test_oid[0]); + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_AddrTable_oid_ranges), netif); + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return ip_AddrTable_get_cell_value_core((struct netif *)state.reference, column, value, value_len); + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +/* --- ipRouteTable --- */ + +/* list of allowed value ranges for incoming OID */ +static const struct snmp_oid_range ip_RouteTable_oid_ranges[] = { + { 0, 0xff }, /* IP A */ + { 0, 0xff }, /* IP B */ + { 0, 0xff }, /* IP C */ + { 0, 0xff }, /* IP D */ +}; + +static snmp_err_t +ip_RouteTable_get_cell_value_core(struct netif *netif, u8_t default_route, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) +{ + switch (*column) { + case 1: /* ipRouteDest */ + if (default_route) { + /* default rte has 0.0.0.0 dest */ + value->u32 = IP4_ADDR_ANY4->addr; + } else { + /* netifs have netaddress dest */ + ip4_addr_t tmp; + ip4_addr_get_network(&tmp, netif_ip4_addr(netif), netif_ip4_netmask(netif)); + value->u32 = tmp.addr; + } + break; + case 2: /* ipRouteIfIndex */ + value->u32 = netif_to_num(netif); + break; + case 3: /* ipRouteMetric1 */ + if (default_route) { + value->s32 = 1; /* default */ + } else { + value->s32 = 0; /* normal */ + } + break; + case 4: /* ipRouteMetric2 */ + case 5: /* ipRouteMetric3 */ + case 6: /* ipRouteMetric4 */ + value->s32 = -1; /* none */ + break; + case 7: /* ipRouteNextHop */ + if (default_route) { + /* default rte: gateway */ + value->u32 = netif_ip4_gw(netif)->addr; + } else { + /* other rtes: netif ip_addr */ + value->u32 = netif_ip4_addr(netif)->addr; + } + break; + case 8: /* ipRouteType */ + if (default_route) { + /* default rte is indirect */ + value->u32 = 4; /* indirect */ + } else { + /* other rtes are direct */ + value->u32 = 3; /* direct */ + } + break; + case 9: /* ipRouteProto */ + /* locally defined routes */ + value->u32 = 2; /* local */ + break; + case 10: /* ipRouteAge */ + /* @todo (sysuptime - timestamp last change) / 100 */ + value->u32 = 0; + break; + case 11: /* ipRouteMask */ + if (default_route) { + /* default rte use 0.0.0.0 mask */ + value->u32 = IP4_ADDR_ANY4->addr; + } else { + /* other rtes use netmask */ + value->u32 = netif_ip4_netmask(netif)->addr; + } + break; + case 12: /* ipRouteMetric5 */ + value->s32 = -1; /* none */ + break; + case 13: /* ipRouteInfo */ + value->const_ptr = snmp_zero_dot_zero.id; + *value_len = snmp_zero_dot_zero.len * sizeof(u32_t); + break; + default: + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +ip_RouteTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + ip4_addr_t test_ip; + struct netif *netif; + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(row_oid, row_oid_len, ip_RouteTable_oid_ranges, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges))) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* get IP and port from incoming OID */ + snmp_oid_to_ip4(&row_oid[0], &test_ip); /* we know it succeeds because of oid_in_range check above */ + + /* default route is on default netif */ + if (ip4_addr_isany_val(test_ip) && (netif_default != NULL)) { + /* fill in object properties */ + return ip_RouteTable_get_cell_value_core(netif_default, 1, column, value, value_len); + } + + /* find netif with requested route */ + NETIF_FOREACH(netif) { + ip4_addr_t dst; + ip4_addr_get_network(&dst, netif_ip4_addr(netif), netif_ip4_netmask(netif)); + + if (ip4_addr_cmp(&dst, &test_ip)) { + /* fill in object properties */ + return ip_RouteTable_get_cell_value_core(netif, 0, column, value, value_len); + } + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +ip_RouteTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + struct netif *netif; + struct snmp_next_oid_state state; + u32_t result_temp[LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges)]; + u32_t test_oid[LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges)]; + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges)); + + /* check default route */ + if (netif_default != NULL) { + snmp_ip4_to_oid(IP4_ADDR_ANY4, &test_oid[0]); + snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges), netif_default); + } + + /* iterate over all possible OIDs to find the next one */ + NETIF_FOREACH(netif) { + ip4_addr_t dst; + ip4_addr_get_network(&dst, netif_ip4_addr(netif), netif_ip4_netmask(netif)); + + /* check generated OID: is it a candidate for the next one? */ + if (!ip4_addr_isany_val(dst)) { + snmp_ip4_to_oid(&dst, &test_oid[0]); + snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_RouteTable_oid_ranges), netif); + } + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + ip4_addr_t dst; + snmp_oid_to_ip4(&result_temp[0], &dst); + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return ip_RouteTable_get_cell_value_core((struct netif *)state.reference, ip4_addr_isany_val(dst), column, value, value_len); + } else { + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; + } +} + +#if LWIP_ARP && LWIP_IPV4 +/* --- ipNetToMediaTable --- */ + +/* list of allowed value ranges for incoming OID */ +static const struct snmp_oid_range ip_NetToMediaTable_oid_ranges[] = { + { 1, 0xff }, /* IfIndex */ + { 0, 0xff }, /* IP A */ + { 0, 0xff }, /* IP B */ + { 0, 0xff }, /* IP C */ + { 0, 0xff } /* IP D */ +}; + +static snmp_err_t +ip_NetToMediaTable_get_cell_value_core(size_t arp_table_index, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) +{ + ip4_addr_t *ip; + struct netif *netif; + struct eth_addr *ethaddr; + + etharp_get_entry(arp_table_index, &ip, &netif, ðaddr); + + /* value */ + switch (*column) { + case 1: /* atIfIndex / ipNetToMediaIfIndex */ + value->u32 = netif_to_num(netif); + break; + case 2: /* atPhysAddress / ipNetToMediaPhysAddress */ + value->ptr = ethaddr; + *value_len = sizeof(*ethaddr); + break; + case 3: /* atNetAddress / ipNetToMediaNetAddress */ + value->u32 = ip->addr; + break; + case 4: /* ipNetToMediaType */ + value->u32 = 3; /* dynamic*/ + break; + default: + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +ip_NetToMediaTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + ip4_addr_t ip_in; + u8_t netif_index; + size_t i; + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(row_oid, row_oid_len, ip_NetToMediaTable_oid_ranges, LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges))) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* get IP from incoming OID */ + netif_index = (u8_t)row_oid[0]; + snmp_oid_to_ip4(&row_oid[1], &ip_in); /* we know it succeeds because of oid_in_range check above */ + + /* find requested entry */ + for (i = 0; i < ARP_TABLE_SIZE; i++) { + ip4_addr_t *ip; + struct netif *netif; + struct eth_addr *ethaddr; + + if (etharp_get_entry(i, &ip, &netif, ðaddr)) { + if ((netif_index == netif_to_num(netif)) && ip4_addr_cmp(&ip_in, ip)) { + /* fill in object properties */ + return ip_NetToMediaTable_get_cell_value_core(i, column, value, value_len); + } + } + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +ip_NetToMediaTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + size_t i; + struct snmp_next_oid_state state; + u32_t result_temp[LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges)]; + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges)); + + /* iterate over all possible OIDs to find the next one */ + for (i = 0; i < ARP_TABLE_SIZE; i++) { + ip4_addr_t *ip; + struct netif *netif; + struct eth_addr *ethaddr; + + if (etharp_get_entry(i, &ip, &netif, ðaddr)) { + u32_t test_oid[LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges)]; + + test_oid[0] = netif_to_num(netif); + snmp_ip4_to_oid(ip, &test_oid[1]); + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(ip_NetToMediaTable_oid_ranges), LWIP_PTR_NUMERIC_CAST(void *, i)); + } + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return ip_NetToMediaTable_get_cell_value_core(LWIP_PTR_NUMERIC_CAST(size_t, state.reference), column, value, value_len); + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +#endif /* LWIP_ARP && LWIP_IPV4 */ + +static const struct snmp_scalar_node ip_Forwarding = SNMP_SCALAR_CREATE_NODE(1, SNMP_NODE_INSTANCE_READ_WRITE, SNMP_ASN1_TYPE_INTEGER, ip_get_value, ip_set_test, ip_set_value); +static const struct snmp_scalar_node ip_DefaultTTL = SNMP_SCALAR_CREATE_NODE(2, SNMP_NODE_INSTANCE_READ_WRITE, SNMP_ASN1_TYPE_INTEGER, ip_get_value, ip_set_test, ip_set_value); +static const struct snmp_scalar_node ip_InReceives = SNMP_SCALAR_CREATE_NODE_READONLY(3, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_InHdrErrors = SNMP_SCALAR_CREATE_NODE_READONLY(4, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_InAddrErrors = SNMP_SCALAR_CREATE_NODE_READONLY(5, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_ForwDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(6, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_InUnknownProtos = SNMP_SCALAR_CREATE_NODE_READONLY(7, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_InDiscards = SNMP_SCALAR_CREATE_NODE_READONLY(8, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_InDelivers = SNMP_SCALAR_CREATE_NODE_READONLY(9, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_OutRequests = SNMP_SCALAR_CREATE_NODE_READONLY(10, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_OutDiscards = SNMP_SCALAR_CREATE_NODE_READONLY(11, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_OutNoRoutes = SNMP_SCALAR_CREATE_NODE_READONLY(12, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_ReasmTimeout = SNMP_SCALAR_CREATE_NODE_READONLY(13, SNMP_ASN1_TYPE_INTEGER, ip_get_value); +static const struct snmp_scalar_node ip_ReasmReqds = SNMP_SCALAR_CREATE_NODE_READONLY(14, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_ReasmOKs = SNMP_SCALAR_CREATE_NODE_READONLY(15, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_ReasmFails = SNMP_SCALAR_CREATE_NODE_READONLY(16, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_FragOKs = SNMP_SCALAR_CREATE_NODE_READONLY(17, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_FragFails = SNMP_SCALAR_CREATE_NODE_READONLY(18, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_FragCreates = SNMP_SCALAR_CREATE_NODE_READONLY(19, SNMP_ASN1_TYPE_COUNTER, ip_get_value); +static const struct snmp_scalar_node ip_RoutingDiscards = SNMP_SCALAR_CREATE_NODE_READONLY(23, SNMP_ASN1_TYPE_COUNTER, ip_get_value); + +static const struct snmp_table_simple_col_def ip_AddrTable_columns[] = { + { 1, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntAddr */ + { 2, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntIfIndex */ + { 3, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntNetMask */ + { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipAdEntBcastAddr */ + { 5, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* ipAdEntReasmMaxSize */ +}; + +static const struct snmp_table_simple_node ip_AddrTable = SNMP_TABLE_CREATE_SIMPLE(20, ip_AddrTable_columns, ip_AddrTable_get_cell_value, ip_AddrTable_get_next_cell_instance_and_value); + +static const struct snmp_table_simple_col_def ip_RouteTable_columns[] = { + { 1, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteDest */ + { 2, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteIfIndex */ + { 3, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric1 */ + { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric2 */ + { 5, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric3 */ + { 6, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric4 */ + { 7, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteNextHop */ + { 8, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteType */ + { 9, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteProto */ + { 10, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteAge */ + { 11, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipRouteMask */ + { 12, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_S32 }, /* ipRouteMetric5 */ + { 13, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_VARIANT_VALUE_TYPE_PTR } /* ipRouteInfo */ +}; + +static const struct snmp_table_simple_node ip_RouteTable = SNMP_TABLE_CREATE_SIMPLE(21, ip_RouteTable_columns, ip_RouteTable_get_cell_value, ip_RouteTable_get_next_cell_instance_and_value); +#endif /* LWIP_IPV4 */ + +#if LWIP_ARP && LWIP_IPV4 +static const struct snmp_table_simple_col_def ip_NetToMediaTable_columns[] = { + { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipNetToMediaIfIndex */ + { 2, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_VARIANT_VALUE_TYPE_PTR }, /* ipNetToMediaPhysAddress */ + { 3, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* ipNetToMediaNetAddress */ + { 4, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* ipNetToMediaType */ +}; + +static const struct snmp_table_simple_node ip_NetToMediaTable = SNMP_TABLE_CREATE_SIMPLE(22, ip_NetToMediaTable_columns, ip_NetToMediaTable_get_cell_value, ip_NetToMediaTable_get_next_cell_instance_and_value); +#endif /* LWIP_ARP && LWIP_IPV4 */ + +#if LWIP_IPV4 +/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ +CREATE_LWIP_SYNC_NODE( 1, ip_Forwarding) +CREATE_LWIP_SYNC_NODE( 2, ip_DefaultTTL) +CREATE_LWIP_SYNC_NODE( 3, ip_InReceives) +CREATE_LWIP_SYNC_NODE( 4, ip_InHdrErrors) +CREATE_LWIP_SYNC_NODE( 5, ip_InAddrErrors) +CREATE_LWIP_SYNC_NODE( 6, ip_ForwDatagrams) +CREATE_LWIP_SYNC_NODE( 7, ip_InUnknownProtos) +CREATE_LWIP_SYNC_NODE( 8, ip_InDiscards) +CREATE_LWIP_SYNC_NODE( 9, ip_InDelivers) +CREATE_LWIP_SYNC_NODE(10, ip_OutRequests) +CREATE_LWIP_SYNC_NODE(11, ip_OutDiscards) +CREATE_LWIP_SYNC_NODE(12, ip_OutNoRoutes) +CREATE_LWIP_SYNC_NODE(13, ip_ReasmTimeout) +CREATE_LWIP_SYNC_NODE(14, ip_ReasmReqds) +CREATE_LWIP_SYNC_NODE(15, ip_ReasmOKs) +CREATE_LWIP_SYNC_NODE(15, ip_ReasmFails) +CREATE_LWIP_SYNC_NODE(17, ip_FragOKs) +CREATE_LWIP_SYNC_NODE(18, ip_FragFails) +CREATE_LWIP_SYNC_NODE(19, ip_FragCreates) +CREATE_LWIP_SYNC_NODE(20, ip_AddrTable) +CREATE_LWIP_SYNC_NODE(21, ip_RouteTable) +#if LWIP_ARP +CREATE_LWIP_SYNC_NODE(22, ip_NetToMediaTable) +#endif /* LWIP_ARP */ +CREATE_LWIP_SYNC_NODE(23, ip_RoutingDiscards) + +static const struct snmp_node *const ip_nodes[] = { + &SYNC_NODE_NAME(ip_Forwarding).node.node, + &SYNC_NODE_NAME(ip_DefaultTTL).node.node, + &SYNC_NODE_NAME(ip_InReceives).node.node, + &SYNC_NODE_NAME(ip_InHdrErrors).node.node, + &SYNC_NODE_NAME(ip_InAddrErrors).node.node, + &SYNC_NODE_NAME(ip_ForwDatagrams).node.node, + &SYNC_NODE_NAME(ip_InUnknownProtos).node.node, + &SYNC_NODE_NAME(ip_InDiscards).node.node, + &SYNC_NODE_NAME(ip_InDelivers).node.node, + &SYNC_NODE_NAME(ip_OutRequests).node.node, + &SYNC_NODE_NAME(ip_OutDiscards).node.node, + &SYNC_NODE_NAME(ip_OutNoRoutes).node.node, + &SYNC_NODE_NAME(ip_ReasmTimeout).node.node, + &SYNC_NODE_NAME(ip_ReasmReqds).node.node, + &SYNC_NODE_NAME(ip_ReasmOKs).node.node, + &SYNC_NODE_NAME(ip_ReasmFails).node.node, + &SYNC_NODE_NAME(ip_FragOKs).node.node, + &SYNC_NODE_NAME(ip_FragFails).node.node, + &SYNC_NODE_NAME(ip_FragCreates).node.node, + &SYNC_NODE_NAME(ip_AddrTable).node.node, + &SYNC_NODE_NAME(ip_RouteTable).node.node, +#if LWIP_ARP + &SYNC_NODE_NAME(ip_NetToMediaTable).node.node, +#endif /* LWIP_ARP */ + &SYNC_NODE_NAME(ip_RoutingDiscards).node.node +}; + +const struct snmp_tree_node snmp_mib2_ip_root = SNMP_CREATE_TREE_NODE(4, ip_nodes); +#endif /* LWIP_IPV4 */ + +/* --- at .1.3.6.1.2.1.3 ----------------------------------------------------- */ + +#if LWIP_ARP && LWIP_IPV4 +/* at node table is a subset of ip_nettomedia table (same rows but less columns) */ +static const struct snmp_table_simple_col_def at_Table_columns[] = { + { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* atIfIndex */ + { 2, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_VARIANT_VALUE_TYPE_PTR }, /* atPhysAddress */ + { 3, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 } /* atNetAddress */ +}; + +static const struct snmp_table_simple_node at_Table = SNMP_TABLE_CREATE_SIMPLE(1, at_Table_columns, ip_NetToMediaTable_get_cell_value, ip_NetToMediaTable_get_next_cell_instance_and_value); + +/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ +CREATE_LWIP_SYNC_NODE(1, at_Table) + +static const struct snmp_node *const at_nodes[] = { + &SYNC_NODE_NAME(at_Table).node.node +}; + +const struct snmp_tree_node snmp_mib2_at_root = SNMP_CREATE_TREE_NODE(3, at_nodes); +#endif /* LWIP_ARP && LWIP_IPV4 */ + +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_snmp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_snmp.c index 6661c83d..ca22e416 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_snmp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_snmp.c @@ -1,227 +1,227 @@ -/** - * @file - * Management Information Base II (RFC1213) SNMP objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_scalar.h" - -#if LWIP_SNMP && SNMP_LWIP_MIB2 - -#define MIB2_AUTH_TRAPS_ENABLED 1 -#define MIB2_AUTH_TRAPS_DISABLED 2 - -/* --- snmp .1.3.6.1.2.1.11 ----------------------------------------------------- */ -static s16_t -snmp_get_value(const struct snmp_scalar_array_node_def *node, void *value) -{ - u32_t *uint_ptr = (u32_t *)value; - switch (node->oid) { - case 1: /* snmpInPkts */ - *uint_ptr = snmp_stats.inpkts; - break; - case 2: /* snmpOutPkts */ - *uint_ptr = snmp_stats.outpkts; - break; - case 3: /* snmpInBadVersions */ - *uint_ptr = snmp_stats.inbadversions; - break; - case 4: /* snmpInBadCommunityNames */ - *uint_ptr = snmp_stats.inbadcommunitynames; - break; - case 5: /* snmpInBadCommunityUses */ - *uint_ptr = snmp_stats.inbadcommunityuses; - break; - case 6: /* snmpInASNParseErrs */ - *uint_ptr = snmp_stats.inasnparseerrs; - break; - case 8: /* snmpInTooBigs */ - *uint_ptr = snmp_stats.intoobigs; - break; - case 9: /* snmpInNoSuchNames */ - *uint_ptr = snmp_stats.innosuchnames; - break; - case 10: /* snmpInBadValues */ - *uint_ptr = snmp_stats.inbadvalues; - break; - case 11: /* snmpInReadOnlys */ - *uint_ptr = snmp_stats.inreadonlys; - break; - case 12: /* snmpInGenErrs */ - *uint_ptr = snmp_stats.ingenerrs; - break; - case 13: /* snmpInTotalReqVars */ - *uint_ptr = snmp_stats.intotalreqvars; - break; - case 14: /* snmpInTotalSetVars */ - *uint_ptr = snmp_stats.intotalsetvars; - break; - case 15: /* snmpInGetRequests */ - *uint_ptr = snmp_stats.ingetrequests; - break; - case 16: /* snmpInGetNexts */ - *uint_ptr = snmp_stats.ingetnexts; - break; - case 17: /* snmpInSetRequests */ - *uint_ptr = snmp_stats.insetrequests; - break; - case 18: /* snmpInGetResponses */ - *uint_ptr = snmp_stats.ingetresponses; - break; - case 19: /* snmpInTraps */ - *uint_ptr = snmp_stats.intraps; - break; - case 20: /* snmpOutTooBigs */ - *uint_ptr = snmp_stats.outtoobigs; - break; - case 21: /* snmpOutNoSuchNames */ - *uint_ptr = snmp_stats.outnosuchnames; - break; - case 22: /* snmpOutBadValues */ - *uint_ptr = snmp_stats.outbadvalues; - break; - case 24: /* snmpOutGenErrs */ - *uint_ptr = snmp_stats.outgenerrs; - break; - case 25: /* snmpOutGetRequests */ - *uint_ptr = snmp_stats.outgetrequests; - break; - case 26: /* snmpOutGetNexts */ - *uint_ptr = snmp_stats.outgetnexts; - break; - case 27: /* snmpOutSetRequests */ - *uint_ptr = snmp_stats.outsetrequests; - break; - case 28: /* snmpOutGetResponses */ - *uint_ptr = snmp_stats.outgetresponses; - break; - case 29: /* snmpOutTraps */ - *uint_ptr = snmp_stats.outtraps; - break; - case 30: /* snmpEnableAuthenTraps */ - if (snmp_get_auth_traps_enabled() == SNMP_AUTH_TRAPS_DISABLED) { - *uint_ptr = MIB2_AUTH_TRAPS_DISABLED; - } else { - *uint_ptr = MIB2_AUTH_TRAPS_ENABLED; - } - break; - case 31: /* snmpSilentDrops */ - *uint_ptr = 0; /* not supported */ - break; - case 32: /* snmpProxyDrops */ - *uint_ptr = 0; /* not supported */ - break; - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("snmp_get_value(): unknown id: %"S32_F"\n", node->oid)); - return 0; - } - - return sizeof(*uint_ptr); -} - -static snmp_err_t -snmp_set_test(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) -{ - snmp_err_t ret = SNMP_ERR_WRONGVALUE; - LWIP_UNUSED_ARG(len); - - if (node->oid == 30) { - /* snmpEnableAuthenTraps */ - s32_t *sint_ptr = (s32_t *)value; - - /* we should have writable non-volatile mem here */ - if ((*sint_ptr == MIB2_AUTH_TRAPS_DISABLED) || (*sint_ptr == MIB2_AUTH_TRAPS_ENABLED)) { - ret = SNMP_ERR_NOERROR; - } - } - return ret; -} - -static snmp_err_t -snmp_set_value(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) -{ - LWIP_UNUSED_ARG(len); - - if (node->oid == 30) { - /* snmpEnableAuthenTraps */ - s32_t *sint_ptr = (s32_t *)value; - if (*sint_ptr == MIB2_AUTH_TRAPS_DISABLED) { - snmp_set_auth_traps_enabled(SNMP_AUTH_TRAPS_DISABLED); - } else { - snmp_set_auth_traps_enabled(SNMP_AUTH_TRAPS_ENABLED); - } - } - - return SNMP_ERR_NOERROR; -} - -/* the following nodes access variables in SNMP stack (snmp_stats) from SNMP worker thread -> OK, no sync needed */ -static const struct snmp_scalar_array_node_def snmp_nodes[] = { - { 1, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInPkts */ - { 2, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutPkts */ - { 3, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadVersions */ - { 4, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadCommunityNames */ - { 5, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadCommunityUses */ - { 6, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInASNParseErrs */ - { 8, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTooBigs */ - { 9, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInNoSuchNames */ - {10, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadValues */ - {11, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInReadOnlys */ - {12, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGenErrs */ - {13, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTotalReqVars */ - {14, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTotalSetVars */ - {15, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGetRequests */ - {16, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGetNexts */ - {17, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInSetRequests */ - {18, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGetResponses */ - {19, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTraps */ - {20, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutTooBigs */ - {21, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutNoSuchNames */ - {22, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutBadValues */ - {24, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGenErrs */ - {25, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGetRequests */ - {26, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGetNexts */ - {27, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutSetRequests */ - {28, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGetResponses */ - {29, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutTraps */ - {30, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_WRITE}, /* snmpEnableAuthenTraps */ - {31, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpSilentDrops */ - {32, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY} /* snmpProxyDrops */ -}; - -const struct snmp_scalar_array_node snmp_mib2_snmp_root = SNMP_SCALAR_CREATE_ARRAY_NODE(11, snmp_nodes, snmp_get_value, snmp_set_test, snmp_set_value); - -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ +/** + * @file + * Management Information Base II (RFC1213) SNMP objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_scalar.h" + +#if LWIP_SNMP && SNMP_LWIP_MIB2 + +#define MIB2_AUTH_TRAPS_ENABLED 1 +#define MIB2_AUTH_TRAPS_DISABLED 2 + +/* --- snmp .1.3.6.1.2.1.11 ----------------------------------------------------- */ +static s16_t +snmp_get_value(const struct snmp_scalar_array_node_def *node, void *value) +{ + u32_t *uint_ptr = (u32_t *)value; + switch (node->oid) { + case 1: /* snmpInPkts */ + *uint_ptr = snmp_stats.inpkts; + break; + case 2: /* snmpOutPkts */ + *uint_ptr = snmp_stats.outpkts; + break; + case 3: /* snmpInBadVersions */ + *uint_ptr = snmp_stats.inbadversions; + break; + case 4: /* snmpInBadCommunityNames */ + *uint_ptr = snmp_stats.inbadcommunitynames; + break; + case 5: /* snmpInBadCommunityUses */ + *uint_ptr = snmp_stats.inbadcommunityuses; + break; + case 6: /* snmpInASNParseErrs */ + *uint_ptr = snmp_stats.inasnparseerrs; + break; + case 8: /* snmpInTooBigs */ + *uint_ptr = snmp_stats.intoobigs; + break; + case 9: /* snmpInNoSuchNames */ + *uint_ptr = snmp_stats.innosuchnames; + break; + case 10: /* snmpInBadValues */ + *uint_ptr = snmp_stats.inbadvalues; + break; + case 11: /* snmpInReadOnlys */ + *uint_ptr = snmp_stats.inreadonlys; + break; + case 12: /* snmpInGenErrs */ + *uint_ptr = snmp_stats.ingenerrs; + break; + case 13: /* snmpInTotalReqVars */ + *uint_ptr = snmp_stats.intotalreqvars; + break; + case 14: /* snmpInTotalSetVars */ + *uint_ptr = snmp_stats.intotalsetvars; + break; + case 15: /* snmpInGetRequests */ + *uint_ptr = snmp_stats.ingetrequests; + break; + case 16: /* snmpInGetNexts */ + *uint_ptr = snmp_stats.ingetnexts; + break; + case 17: /* snmpInSetRequests */ + *uint_ptr = snmp_stats.insetrequests; + break; + case 18: /* snmpInGetResponses */ + *uint_ptr = snmp_stats.ingetresponses; + break; + case 19: /* snmpInTraps */ + *uint_ptr = snmp_stats.intraps; + break; + case 20: /* snmpOutTooBigs */ + *uint_ptr = snmp_stats.outtoobigs; + break; + case 21: /* snmpOutNoSuchNames */ + *uint_ptr = snmp_stats.outnosuchnames; + break; + case 22: /* snmpOutBadValues */ + *uint_ptr = snmp_stats.outbadvalues; + break; + case 24: /* snmpOutGenErrs */ + *uint_ptr = snmp_stats.outgenerrs; + break; + case 25: /* snmpOutGetRequests */ + *uint_ptr = snmp_stats.outgetrequests; + break; + case 26: /* snmpOutGetNexts */ + *uint_ptr = snmp_stats.outgetnexts; + break; + case 27: /* snmpOutSetRequests */ + *uint_ptr = snmp_stats.outsetrequests; + break; + case 28: /* snmpOutGetResponses */ + *uint_ptr = snmp_stats.outgetresponses; + break; + case 29: /* snmpOutTraps */ + *uint_ptr = snmp_stats.outtraps; + break; + case 30: /* snmpEnableAuthenTraps */ + if (snmp_get_auth_traps_enabled() == SNMP_AUTH_TRAPS_DISABLED) { + *uint_ptr = MIB2_AUTH_TRAPS_DISABLED; + } else { + *uint_ptr = MIB2_AUTH_TRAPS_ENABLED; + } + break; + case 31: /* snmpSilentDrops */ + *uint_ptr = 0; /* not supported */ + break; + case 32: /* snmpProxyDrops */ + *uint_ptr = 0; /* not supported */ + break; + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("snmp_get_value(): unknown id: %"S32_F"\n", node->oid)); + return 0; + } + + return sizeof(*uint_ptr); +} + +static snmp_err_t +snmp_set_test(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) +{ + snmp_err_t ret = SNMP_ERR_WRONGVALUE; + LWIP_UNUSED_ARG(len); + + if (node->oid == 30) { + /* snmpEnableAuthenTraps */ + s32_t *sint_ptr = (s32_t *)value; + + /* we should have writable non-volatile mem here */ + if ((*sint_ptr == MIB2_AUTH_TRAPS_DISABLED) || (*sint_ptr == MIB2_AUTH_TRAPS_ENABLED)) { + ret = SNMP_ERR_NOERROR; + } + } + return ret; +} + +static snmp_err_t +snmp_set_value(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) +{ + LWIP_UNUSED_ARG(len); + + if (node->oid == 30) { + /* snmpEnableAuthenTraps */ + s32_t *sint_ptr = (s32_t *)value; + if (*sint_ptr == MIB2_AUTH_TRAPS_DISABLED) { + snmp_set_auth_traps_enabled(SNMP_AUTH_TRAPS_DISABLED); + } else { + snmp_set_auth_traps_enabled(SNMP_AUTH_TRAPS_ENABLED); + } + } + + return SNMP_ERR_NOERROR; +} + +/* the following nodes access variables in SNMP stack (snmp_stats) from SNMP worker thread -> OK, no sync needed */ +static const struct snmp_scalar_array_node_def snmp_nodes[] = { + { 1, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInPkts */ + { 2, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutPkts */ + { 3, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadVersions */ + { 4, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadCommunityNames */ + { 5, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadCommunityUses */ + { 6, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInASNParseErrs */ + { 8, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTooBigs */ + { 9, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInNoSuchNames */ + {10, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInBadValues */ + {11, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInReadOnlys */ + {12, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGenErrs */ + {13, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTotalReqVars */ + {14, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTotalSetVars */ + {15, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGetRequests */ + {16, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGetNexts */ + {17, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInSetRequests */ + {18, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInGetResponses */ + {19, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpInTraps */ + {20, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutTooBigs */ + {21, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutNoSuchNames */ + {22, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutBadValues */ + {24, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGenErrs */ + {25, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGetRequests */ + {26, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGetNexts */ + {27, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutSetRequests */ + {28, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutGetResponses */ + {29, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpOutTraps */ + {30, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_WRITE}, /* snmpEnableAuthenTraps */ + {31, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpSilentDrops */ + {32, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY} /* snmpProxyDrops */ +}; + +const struct snmp_scalar_array_node snmp_mib2_snmp_root = SNMP_SCALAR_CREATE_ARRAY_NODE(11, snmp_nodes, snmp_get_value, snmp_set_test, snmp_set_value); + +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_system.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_system.c index ce28892c..71c1c29c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_system.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_system.c @@ -1,376 +1,376 @@ -/** - * @file - * Management Information Base II (RFC1213) SYSTEM objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/sys.h" - -#include - -#if LWIP_SNMP && SNMP_LWIP_MIB2 - -#if SNMP_USE_NETCONN -#define SYNC_NODE_NAME(node_name) node_name ## _synced -#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ - static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); -#else -#define SYNC_NODE_NAME(node_name) node_name -#define CREATE_LWIP_SYNC_NODE(oid, node_name) -#endif - -/* --- system .1.3.6.1.2.1.1 ----------------------------------------------------- */ - -/** mib-2.system.sysDescr */ -static const u8_t sysdescr_default[] = SNMP_LWIP_MIB2_SYSDESC; -static const u8_t *sysdescr = sysdescr_default; -static const u16_t *sysdescr_len = NULL; /* use strlen for determining len */ - -/** mib-2.system.sysContact */ -static const u8_t syscontact_default[] = SNMP_LWIP_MIB2_SYSCONTACT; -static const u8_t *syscontact = syscontact_default; -static const u16_t *syscontact_len = NULL; /* use strlen for determining len */ -static u8_t *syscontact_wr = NULL; /* if writable, points to the same buffer as syscontact (required for correct constness) */ -static u16_t *syscontact_wr_len = NULL; /* if writable, points to the same buffer as syscontact_len (required for correct constness) */ -static u16_t syscontact_bufsize = 0; /* 0=not writable */ - -/** mib-2.system.sysName */ -static const u8_t sysname_default[] = SNMP_LWIP_MIB2_SYSNAME; -static const u8_t *sysname = sysname_default; -static const u16_t *sysname_len = NULL; /* use strlen for determining len */ -static u8_t *sysname_wr = NULL; /* if writable, points to the same buffer as sysname (required for correct constness) */ -static u16_t *sysname_wr_len = NULL; /* if writable, points to the same buffer as sysname_len (required for correct constness) */ -static u16_t sysname_bufsize = 0; /* 0=not writable */ - -/** mib-2.system.sysLocation */ -static const u8_t syslocation_default[] = SNMP_LWIP_MIB2_SYSLOCATION; -static const u8_t *syslocation = syslocation_default; -static const u16_t *syslocation_len = NULL; /* use strlen for determining len */ -static u8_t *syslocation_wr = NULL; /* if writable, points to the same buffer as syslocation (required for correct constness) */ -static u16_t *syslocation_wr_len = NULL; /* if writable, points to the same buffer as syslocation_len (required for correct constness) */ -static u16_t syslocation_bufsize = 0; /* 0=not writable */ - -/** - * @ingroup snmp_mib2 - * Initializes sysDescr pointers. - * - * @param str if non-NULL then copy str pointer - * @param len points to string length, excluding zero terminator - */ -void -snmp_mib2_set_sysdescr(const u8_t *str, const u16_t *len) -{ - if (str != NULL) { - sysdescr = str; - sysdescr_len = len; - } -} - -/** - * @ingroup snmp_mib2 - * Initializes sysContact pointers - * - * @param ocstr if non-NULL then copy str pointer - * @param ocstrlen points to string length, excluding zero terminator. - * if set to NULL it is assumed that ocstr is NULL-terminated. - * @param bufsize size of the buffer in bytes. - * (this is required because the buffer can be overwritten by snmp-set) - * if ocstrlen is NULL buffer needs space for terminating 0 byte. - * otherwise complete buffer is used for string. - * if bufsize is set to 0, the value is regarded as read-only. - */ -void -snmp_mib2_set_syscontact(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize) -{ - if (ocstr != NULL) { - syscontact = ocstr; - syscontact_wr = ocstr; - syscontact_len = ocstrlen; - syscontact_wr_len = ocstrlen; - syscontact_bufsize = bufsize; - } -} - -/** - * @ingroup snmp_mib2 - * see \ref snmp_mib2_set_syscontact but set pointer to readonly memory - */ -void -snmp_mib2_set_syscontact_readonly(const u8_t *ocstr, const u16_t *ocstrlen) -{ - if (ocstr != NULL) { - syscontact = ocstr; - syscontact_len = ocstrlen; - syscontact_wr = NULL; - syscontact_wr_len = NULL; - syscontact_bufsize = 0; - } -} - - -/** - * @ingroup snmp_mib2 - * Initializes sysName pointers - * - * @param ocstr if non-NULL then copy str pointer - * @param ocstrlen points to string length, excluding zero terminator. - * if set to NULL it is assumed that ocstr is NULL-terminated. - * @param bufsize size of the buffer in bytes. - * (this is required because the buffer can be overwritten by snmp-set) - * if ocstrlen is NULL buffer needs space for terminating 0 byte. - * otherwise complete buffer is used for string. - * if bufsize is set to 0, the value is regarded as read-only. - */ -void -snmp_mib2_set_sysname(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize) -{ - if (ocstr != NULL) { - sysname = ocstr; - sysname_wr = ocstr; - sysname_len = ocstrlen; - sysname_wr_len = ocstrlen; - sysname_bufsize = bufsize; - } -} - -/** - * @ingroup snmp_mib2 - * see \ref snmp_mib2_set_sysname but set pointer to readonly memory - */ -void -snmp_mib2_set_sysname_readonly(const u8_t *ocstr, const u16_t *ocstrlen) -{ - if (ocstr != NULL) { - sysname = ocstr; - sysname_len = ocstrlen; - sysname_wr = NULL; - sysname_wr_len = NULL; - sysname_bufsize = 0; - } -} - -/** - * @ingroup snmp_mib2 - * Initializes sysLocation pointers - * - * @param ocstr if non-NULL then copy str pointer - * @param ocstrlen points to string length, excluding zero terminator. - * if set to NULL it is assumed that ocstr is NULL-terminated. - * @param bufsize size of the buffer in bytes. - * (this is required because the buffer can be overwritten by snmp-set) - * if ocstrlen is NULL buffer needs space for terminating 0 byte. - * otherwise complete buffer is used for string. - * if bufsize is set to 0, the value is regarded as read-only. - */ -void -snmp_mib2_set_syslocation(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize) -{ - if (ocstr != NULL) { - syslocation = ocstr; - syslocation_wr = ocstr; - syslocation_len = ocstrlen; - syslocation_wr_len = ocstrlen; - syslocation_bufsize = bufsize; - } -} - -/** - * @ingroup snmp_mib2 - * see \ref snmp_mib2_set_syslocation but set pointer to readonly memory - */ -void -snmp_mib2_set_syslocation_readonly(const u8_t *ocstr, const u16_t *ocstrlen) -{ - if (ocstr != NULL) { - syslocation = ocstr; - syslocation_len = ocstrlen; - syslocation_wr = NULL; - syslocation_wr_len = NULL; - syslocation_bufsize = 0; - } -} - - -static s16_t -system_get_value(const struct snmp_scalar_array_node_def *node, void *value) -{ - const u8_t *var = NULL; - const s16_t *var_len; - u16_t result; - - switch (node->oid) { - case 1: /* sysDescr */ - var = sysdescr; - var_len = (const s16_t *)sysdescr_len; - break; - case 2: { /* sysObjectID */ - const struct snmp_obj_id *dev_enterprise_oid = snmp_get_device_enterprise_oid(); - MEMCPY(value, dev_enterprise_oid->id, dev_enterprise_oid->len * sizeof(u32_t)); - return dev_enterprise_oid->len * sizeof(u32_t); - } - case 3: /* sysUpTime */ - MIB2_COPY_SYSUPTIME_TO((u32_t *)value); - return sizeof(u32_t); - case 4: /* sysContact */ - var = syscontact; - var_len = (const s16_t *)syscontact_len; - break; - case 5: /* sysName */ - var = sysname; - var_len = (const s16_t *)sysname_len; - break; - case 6: /* sysLocation */ - var = syslocation; - var_len = (const s16_t *)syslocation_len; - break; - case 7: /* sysServices */ - *(s32_t *)value = SNMP_SYSSERVICES; - return sizeof(s32_t); - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("system_get_value(): unknown id: %"S32_F"\n", node->oid)); - return 0; - } - - /* handle string values (OID 1,4,5 and 6) */ - LWIP_ASSERT("", (value != NULL)); - if (var_len == NULL) { - result = (s16_t)strlen((const char *)var); - } else { - result = *var_len; - } - MEMCPY(value, var, result); - return result; -} - -static snmp_err_t -system_set_test(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) -{ - snmp_err_t ret = SNMP_ERR_WRONGVALUE; - const u16_t *var_bufsize = NULL; - const u16_t *var_wr_len; - - LWIP_UNUSED_ARG(value); - - switch (node->oid) { - case 4: /* sysContact */ - var_bufsize = &syscontact_bufsize; - var_wr_len = syscontact_wr_len; - break; - case 5: /* sysName */ - var_bufsize = &sysname_bufsize; - var_wr_len = sysname_wr_len; - break; - case 6: /* sysLocation */ - var_bufsize = &syslocation_bufsize; - var_wr_len = syslocation_wr_len; - break; - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("system_set_test(): unknown id: %"S32_F"\n", node->oid)); - return ret; - } - - /* check if value is writable at all */ - if (*var_bufsize > 0) { - if (var_wr_len == NULL) { - /* we have to take the terminating 0 into account */ - if (len < *var_bufsize) { - ret = SNMP_ERR_NOERROR; - } - } else { - if (len <= *var_bufsize) { - ret = SNMP_ERR_NOERROR; - } - } - } else { - ret = SNMP_ERR_NOTWRITABLE; - } - - return ret; -} - -static snmp_err_t -system_set_value(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) -{ - u8_t *var_wr = NULL; - u16_t *var_wr_len; - - switch (node->oid) { - case 4: /* sysContact */ - var_wr = syscontact_wr; - var_wr_len = syscontact_wr_len; - break; - case 5: /* sysName */ - var_wr = sysname_wr; - var_wr_len = sysname_wr_len; - break; - case 6: /* sysLocation */ - var_wr = syslocation_wr; - var_wr_len = syslocation_wr_len; - break; - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("system_set_value(): unknown id: %"S32_F"\n", node->oid)); - return SNMP_ERR_GENERROR; - } - - /* no need to check size of target buffer, this was already done in set_test method */ - LWIP_ASSERT("", var_wr != NULL); - MEMCPY(var_wr, value, len); - - if (var_wr_len == NULL) { - /* add terminating 0 */ - var_wr[len] = 0; - } else { - *var_wr_len = len; - } - - return SNMP_ERR_NOERROR; -} - -static const struct snmp_scalar_array_node_def system_nodes[] = { - {1, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* sysDescr */ - {2, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* sysObjectID */ - {3, SNMP_ASN1_TYPE_TIMETICKS, SNMP_NODE_INSTANCE_READ_ONLY}, /* sysUpTime */ - {4, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_WRITE}, /* sysContact */ - {5, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_WRITE}, /* sysName */ - {6, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_WRITE}, /* sysLocation */ - {7, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY} /* sysServices */ -}; - -const struct snmp_scalar_array_node snmp_mib2_system_node = SNMP_SCALAR_CREATE_ARRAY_NODE(1, system_nodes, system_get_value, system_set_test, system_set_value); - -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ +/** + * @file + * Management Information Base II (RFC1213) SYSTEM objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/sys.h" + +#include + +#if LWIP_SNMP && SNMP_LWIP_MIB2 + +#if SNMP_USE_NETCONN +#define SYNC_NODE_NAME(node_name) node_name ## _synced +#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ + static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); +#else +#define SYNC_NODE_NAME(node_name) node_name +#define CREATE_LWIP_SYNC_NODE(oid, node_name) +#endif + +/* --- system .1.3.6.1.2.1.1 ----------------------------------------------------- */ + +/** mib-2.system.sysDescr */ +static const u8_t sysdescr_default[] = SNMP_LWIP_MIB2_SYSDESC; +static const u8_t *sysdescr = sysdescr_default; +static const u16_t *sysdescr_len = NULL; /* use strlen for determining len */ + +/** mib-2.system.sysContact */ +static const u8_t syscontact_default[] = SNMP_LWIP_MIB2_SYSCONTACT; +static const u8_t *syscontact = syscontact_default; +static const u16_t *syscontact_len = NULL; /* use strlen for determining len */ +static u8_t *syscontact_wr = NULL; /* if writable, points to the same buffer as syscontact (required for correct constness) */ +static u16_t *syscontact_wr_len = NULL; /* if writable, points to the same buffer as syscontact_len (required for correct constness) */ +static u16_t syscontact_bufsize = 0; /* 0=not writable */ + +/** mib-2.system.sysName */ +static const u8_t sysname_default[] = SNMP_LWIP_MIB2_SYSNAME; +static const u8_t *sysname = sysname_default; +static const u16_t *sysname_len = NULL; /* use strlen for determining len */ +static u8_t *sysname_wr = NULL; /* if writable, points to the same buffer as sysname (required for correct constness) */ +static u16_t *sysname_wr_len = NULL; /* if writable, points to the same buffer as sysname_len (required for correct constness) */ +static u16_t sysname_bufsize = 0; /* 0=not writable */ + +/** mib-2.system.sysLocation */ +static const u8_t syslocation_default[] = SNMP_LWIP_MIB2_SYSLOCATION; +static const u8_t *syslocation = syslocation_default; +static const u16_t *syslocation_len = NULL; /* use strlen for determining len */ +static u8_t *syslocation_wr = NULL; /* if writable, points to the same buffer as syslocation (required for correct constness) */ +static u16_t *syslocation_wr_len = NULL; /* if writable, points to the same buffer as syslocation_len (required for correct constness) */ +static u16_t syslocation_bufsize = 0; /* 0=not writable */ + +/** + * @ingroup snmp_mib2 + * Initializes sysDescr pointers. + * + * @param str if non-NULL then copy str pointer + * @param len points to string length, excluding zero terminator + */ +void +snmp_mib2_set_sysdescr(const u8_t *str, const u16_t *len) +{ + if (str != NULL) { + sysdescr = str; + sysdescr_len = len; + } +} + +/** + * @ingroup snmp_mib2 + * Initializes sysContact pointers + * + * @param ocstr if non-NULL then copy str pointer + * @param ocstrlen points to string length, excluding zero terminator. + * if set to NULL it is assumed that ocstr is NULL-terminated. + * @param bufsize size of the buffer in bytes. + * (this is required because the buffer can be overwritten by snmp-set) + * if ocstrlen is NULL buffer needs space for terminating 0 byte. + * otherwise complete buffer is used for string. + * if bufsize is set to 0, the value is regarded as read-only. + */ +void +snmp_mib2_set_syscontact(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize) +{ + if (ocstr != NULL) { + syscontact = ocstr; + syscontact_wr = ocstr; + syscontact_len = ocstrlen; + syscontact_wr_len = ocstrlen; + syscontact_bufsize = bufsize; + } +} + +/** + * @ingroup snmp_mib2 + * see \ref snmp_mib2_set_syscontact but set pointer to readonly memory + */ +void +snmp_mib2_set_syscontact_readonly(const u8_t *ocstr, const u16_t *ocstrlen) +{ + if (ocstr != NULL) { + syscontact = ocstr; + syscontact_len = ocstrlen; + syscontact_wr = NULL; + syscontact_wr_len = NULL; + syscontact_bufsize = 0; + } +} + + +/** + * @ingroup snmp_mib2 + * Initializes sysName pointers + * + * @param ocstr if non-NULL then copy str pointer + * @param ocstrlen points to string length, excluding zero terminator. + * if set to NULL it is assumed that ocstr is NULL-terminated. + * @param bufsize size of the buffer in bytes. + * (this is required because the buffer can be overwritten by snmp-set) + * if ocstrlen is NULL buffer needs space for terminating 0 byte. + * otherwise complete buffer is used for string. + * if bufsize is set to 0, the value is regarded as read-only. + */ +void +snmp_mib2_set_sysname(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize) +{ + if (ocstr != NULL) { + sysname = ocstr; + sysname_wr = ocstr; + sysname_len = ocstrlen; + sysname_wr_len = ocstrlen; + sysname_bufsize = bufsize; + } +} + +/** + * @ingroup snmp_mib2 + * see \ref snmp_mib2_set_sysname but set pointer to readonly memory + */ +void +snmp_mib2_set_sysname_readonly(const u8_t *ocstr, const u16_t *ocstrlen) +{ + if (ocstr != NULL) { + sysname = ocstr; + sysname_len = ocstrlen; + sysname_wr = NULL; + sysname_wr_len = NULL; + sysname_bufsize = 0; + } +} + +/** + * @ingroup snmp_mib2 + * Initializes sysLocation pointers + * + * @param ocstr if non-NULL then copy str pointer + * @param ocstrlen points to string length, excluding zero terminator. + * if set to NULL it is assumed that ocstr is NULL-terminated. + * @param bufsize size of the buffer in bytes. + * (this is required because the buffer can be overwritten by snmp-set) + * if ocstrlen is NULL buffer needs space for terminating 0 byte. + * otherwise complete buffer is used for string. + * if bufsize is set to 0, the value is regarded as read-only. + */ +void +snmp_mib2_set_syslocation(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize) +{ + if (ocstr != NULL) { + syslocation = ocstr; + syslocation_wr = ocstr; + syslocation_len = ocstrlen; + syslocation_wr_len = ocstrlen; + syslocation_bufsize = bufsize; + } +} + +/** + * @ingroup snmp_mib2 + * see \ref snmp_mib2_set_syslocation but set pointer to readonly memory + */ +void +snmp_mib2_set_syslocation_readonly(const u8_t *ocstr, const u16_t *ocstrlen) +{ + if (ocstr != NULL) { + syslocation = ocstr; + syslocation_len = ocstrlen; + syslocation_wr = NULL; + syslocation_wr_len = NULL; + syslocation_bufsize = 0; + } +} + + +static s16_t +system_get_value(const struct snmp_scalar_array_node_def *node, void *value) +{ + const u8_t *var = NULL; + const s16_t *var_len; + u16_t result; + + switch (node->oid) { + case 1: /* sysDescr */ + var = sysdescr; + var_len = (const s16_t *)sysdescr_len; + break; + case 2: { /* sysObjectID */ + const struct snmp_obj_id *dev_enterprise_oid = snmp_get_device_enterprise_oid(); + MEMCPY(value, dev_enterprise_oid->id, dev_enterprise_oid->len * sizeof(u32_t)); + return dev_enterprise_oid->len * sizeof(u32_t); + } + case 3: /* sysUpTime */ + MIB2_COPY_SYSUPTIME_TO((u32_t *)value); + return sizeof(u32_t); + case 4: /* sysContact */ + var = syscontact; + var_len = (const s16_t *)syscontact_len; + break; + case 5: /* sysName */ + var = sysname; + var_len = (const s16_t *)sysname_len; + break; + case 6: /* sysLocation */ + var = syslocation; + var_len = (const s16_t *)syslocation_len; + break; + case 7: /* sysServices */ + *(s32_t *)value = SNMP_SYSSERVICES; + return sizeof(s32_t); + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("system_get_value(): unknown id: %"S32_F"\n", node->oid)); + return 0; + } + + /* handle string values (OID 1,4,5 and 6) */ + LWIP_ASSERT("", (value != NULL)); + if (var_len == NULL) { + result = (s16_t)strlen((const char *)var); + } else { + result = *var_len; + } + MEMCPY(value, var, result); + return result; +} + +static snmp_err_t +system_set_test(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) +{ + snmp_err_t ret = SNMP_ERR_WRONGVALUE; + const u16_t *var_bufsize = NULL; + const u16_t *var_wr_len; + + LWIP_UNUSED_ARG(value); + + switch (node->oid) { + case 4: /* sysContact */ + var_bufsize = &syscontact_bufsize; + var_wr_len = syscontact_wr_len; + break; + case 5: /* sysName */ + var_bufsize = &sysname_bufsize; + var_wr_len = sysname_wr_len; + break; + case 6: /* sysLocation */ + var_bufsize = &syslocation_bufsize; + var_wr_len = syslocation_wr_len; + break; + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("system_set_test(): unknown id: %"S32_F"\n", node->oid)); + return ret; + } + + /* check if value is writable at all */ + if (*var_bufsize > 0) { + if (var_wr_len == NULL) { + /* we have to take the terminating 0 into account */ + if (len < *var_bufsize) { + ret = SNMP_ERR_NOERROR; + } + } else { + if (len <= *var_bufsize) { + ret = SNMP_ERR_NOERROR; + } + } + } else { + ret = SNMP_ERR_NOTWRITABLE; + } + + return ret; +} + +static snmp_err_t +system_set_value(const struct snmp_scalar_array_node_def *node, u16_t len, void *value) +{ + u8_t *var_wr = NULL; + u16_t *var_wr_len; + + switch (node->oid) { + case 4: /* sysContact */ + var_wr = syscontact_wr; + var_wr_len = syscontact_wr_len; + break; + case 5: /* sysName */ + var_wr = sysname_wr; + var_wr_len = sysname_wr_len; + break; + case 6: /* sysLocation */ + var_wr = syslocation_wr; + var_wr_len = syslocation_wr_len; + break; + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("system_set_value(): unknown id: %"S32_F"\n", node->oid)); + return SNMP_ERR_GENERROR; + } + + /* no need to check size of target buffer, this was already done in set_test method */ + LWIP_ASSERT("", var_wr != NULL); + MEMCPY(var_wr, value, len); + + if (var_wr_len == NULL) { + /* add terminating 0 */ + var_wr[len] = 0; + } else { + *var_wr_len = len; + } + + return SNMP_ERR_NOERROR; +} + +static const struct snmp_scalar_array_node_def system_nodes[] = { + {1, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* sysDescr */ + {2, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* sysObjectID */ + {3, SNMP_ASN1_TYPE_TIMETICKS, SNMP_NODE_INSTANCE_READ_ONLY}, /* sysUpTime */ + {4, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_WRITE}, /* sysContact */ + {5, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_WRITE}, /* sysName */ + {6, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_WRITE}, /* sysLocation */ + {7, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY} /* sysServices */ +}; + +const struct snmp_scalar_array_node snmp_mib2_system_node = SNMP_SCALAR_CREATE_ARRAY_NODE(1, system_nodes, system_get_value, system_set_test, system_set_value); + +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_tcp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_tcp.c index 61cf2db0..8a321f3f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_tcp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_tcp.c @@ -1,607 +1,607 @@ -/** - * @file - * Management Information Base II (RFC1213) TCP objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/tcp.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/stats.h" - -#include - -#if LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_TCP - -#if SNMP_USE_NETCONN -#define SYNC_NODE_NAME(node_name) node_name ## _synced -#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ - static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); -#else -#define SYNC_NODE_NAME(node_name) node_name -#define CREATE_LWIP_SYNC_NODE(oid, node_name) -#endif - -/* --- tcp .1.3.6.1.2.1.6 ----------------------------------------------------- */ - -static s16_t -tcp_get_value(struct snmp_node_instance *instance, void *value) -{ - u32_t *uint_ptr = (u32_t *)value; - s32_t *sint_ptr = (s32_t *)value; - - switch (instance->node->oid) { - case 1: /* tcpRtoAlgorithm, vanj(4) */ - *sint_ptr = 4; - return sizeof(*sint_ptr); - case 2: /* tcpRtoMin */ - /* @todo not the actual value, a guess, - needs to be calculated */ - *sint_ptr = 1000; - return sizeof(*sint_ptr); - case 3: /* tcpRtoMax */ - /* @todo not the actual value, a guess, - needs to be calculated */ - *sint_ptr = 60000; - return sizeof(*sint_ptr); - case 4: /* tcpMaxConn */ - *sint_ptr = MEMP_NUM_TCP_PCB; - return sizeof(*sint_ptr); - case 5: /* tcpActiveOpens */ - *uint_ptr = STATS_GET(mib2.tcpactiveopens); - return sizeof(*uint_ptr); - case 6: /* tcpPassiveOpens */ - *uint_ptr = STATS_GET(mib2.tcppassiveopens); - return sizeof(*uint_ptr); - case 7: /* tcpAttemptFails */ - *uint_ptr = STATS_GET(mib2.tcpattemptfails); - return sizeof(*uint_ptr); - case 8: /* tcpEstabResets */ - *uint_ptr = STATS_GET(mib2.tcpestabresets); - return sizeof(*uint_ptr); - case 9: { /* tcpCurrEstab */ - u16_t tcpcurrestab = 0; - struct tcp_pcb *pcb = tcp_active_pcbs; - while (pcb != NULL) { - if ((pcb->state == ESTABLISHED) || - (pcb->state == CLOSE_WAIT)) { - tcpcurrestab++; - } - pcb = pcb->next; - } - *uint_ptr = tcpcurrestab; - } - return sizeof(*uint_ptr); - case 10: /* tcpInSegs */ - *uint_ptr = STATS_GET(mib2.tcpinsegs); - return sizeof(*uint_ptr); - case 11: /* tcpOutSegs */ - *uint_ptr = STATS_GET(mib2.tcpoutsegs); - return sizeof(*uint_ptr); - case 12: /* tcpRetransSegs */ - *uint_ptr = STATS_GET(mib2.tcpretranssegs); - return sizeof(*uint_ptr); - case 14: /* tcpInErrs */ - *uint_ptr = STATS_GET(mib2.tcpinerrs); - return sizeof(*uint_ptr); - case 15: /* tcpOutRsts */ - *uint_ptr = STATS_GET(mib2.tcpoutrsts); - return sizeof(*uint_ptr); -#if LWIP_HAVE_INT64 - case 17: { /* tcpHCInSegs */ - /* use the 32 bit counter for now... */ - u64_t val64 = STATS_GET(mib2.tcpinsegs); - *((u64_t *)value) = val64; - } - return sizeof(u64_t); - case 18: { /* tcpHCOutSegs */ - /* use the 32 bit counter for now... */ - u64_t val64 = STATS_GET(mib2.tcpoutsegs); - *((u64_t *)value) = val64; - } - return sizeof(u64_t); -#endif - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("tcp_get_value(): unknown id: %"S32_F"\n", instance->node->oid)); - break; - } - - return 0; -} - -/* --- tcpConnTable --- */ - -#if LWIP_IPV4 - -/* list of allowed value ranges for incoming OID */ -static const struct snmp_oid_range tcp_ConnTable_oid_ranges[] = { - { 0, 0xff }, /* IP A */ - { 0, 0xff }, /* IP B */ - { 0, 0xff }, /* IP C */ - { 0, 0xff }, /* IP D */ - { 0, 0xffff }, /* Port */ - { 0, 0xff }, /* IP A */ - { 0, 0xff }, /* IP B */ - { 0, 0xff }, /* IP C */ - { 0, 0xff }, /* IP D */ - { 0, 0xffff } /* Port */ -}; - -static snmp_err_t -tcp_ConnTable_get_cell_value_core(struct tcp_pcb *pcb, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) -{ - LWIP_UNUSED_ARG(value_len); - - /* value */ - switch (*column) { - case 1: /* tcpConnState */ - value->u32 = pcb->state + 1; - break; - case 2: /* tcpConnLocalAddress */ - value->u32 = ip_2_ip4(&pcb->local_ip)->addr; - break; - case 3: /* tcpConnLocalPort */ - value->u32 = pcb->local_port; - break; - case 4: /* tcpConnRemAddress */ - if (pcb->state == LISTEN) { - value->u32 = IP4_ADDR_ANY4->addr; - } else { - value->u32 = ip_2_ip4(&pcb->remote_ip)->addr; - } - break; - case 5: /* tcpConnRemPort */ - if (pcb->state == LISTEN) { - value->u32 = 0; - } else { - value->u32 = pcb->remote_port; - } - break; - default: - LWIP_ASSERT("invalid id", 0); - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -tcp_ConnTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - u8_t i; - ip4_addr_t local_ip; - ip4_addr_t remote_ip; - u16_t local_port; - u16_t remote_port; - struct tcp_pcb *pcb; - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(row_oid, row_oid_len, tcp_ConnTable_oid_ranges, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges))) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* get IPs and ports from incoming OID */ - snmp_oid_to_ip4(&row_oid[0], &local_ip); /* we know it succeeds because of oid_in_range check above */ - local_port = (u16_t)row_oid[4]; - snmp_oid_to_ip4(&row_oid[5], &remote_ip); /* we know it succeeds because of oid_in_range check above */ - remote_port = (u16_t)row_oid[9]; - - /* find tcp_pcb with requested ips and ports */ - for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) { - pcb = *tcp_pcb_lists[i]; - - while (pcb != NULL) { - /* do local IP and local port match? */ - if (IP_IS_V4_VAL(pcb->local_ip) && - ip4_addr_cmp(&local_ip, ip_2_ip4(&pcb->local_ip)) && (local_port == pcb->local_port)) { - - /* PCBs in state LISTEN are not connected and have no remote_ip or remote_port */ - if (pcb->state == LISTEN) { - if (ip4_addr_cmp(&remote_ip, IP4_ADDR_ANY4) && (remote_port == 0)) { - /* fill in object properties */ - return tcp_ConnTable_get_cell_value_core(pcb, column, value, value_len); - } - } else { - if (IP_IS_V4_VAL(pcb->remote_ip) && - ip4_addr_cmp(&remote_ip, ip_2_ip4(&pcb->remote_ip)) && (remote_port == pcb->remote_port)) { - /* fill in object properties */ - return tcp_ConnTable_get_cell_value_core(pcb, column, value, value_len); - } - } - } - - pcb = pcb->next; - } - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -tcp_ConnTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - u8_t i; - struct tcp_pcb *pcb; - struct snmp_next_oid_state state; - u32_t result_temp[LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)]; - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)); - - /* iterate over all possible OIDs to find the next one */ - for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) { - pcb = *tcp_pcb_lists[i]; - while (pcb != NULL) { - u32_t test_oid[LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)]; - - if (IP_IS_V4_VAL(pcb->local_ip)) { - snmp_ip4_to_oid(ip_2_ip4(&pcb->local_ip), &test_oid[0]); - test_oid[4] = pcb->local_port; - - /* PCBs in state LISTEN are not connected and have no remote_ip or remote_port */ - if (pcb->state == LISTEN) { - snmp_ip4_to_oid(IP4_ADDR_ANY4, &test_oid[5]); - test_oid[9] = 0; - } else { - if (IP_IS_V6_VAL(pcb->remote_ip)) { /* should never happen */ - continue; - } - snmp_ip4_to_oid(ip_2_ip4(&pcb->remote_ip), &test_oid[5]); - test_oid[9] = pcb->remote_port; - } - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges), pcb); - } - - pcb = pcb->next; - } - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return tcp_ConnTable_get_cell_value_core((struct tcp_pcb *)state.reference, column, value, value_len); - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -#endif /* LWIP_IPV4 */ - -/* --- tcpConnectionTable --- */ - -static snmp_err_t -tcp_ConnectionTable_get_cell_value_core(const u32_t *column, struct tcp_pcb *pcb, union snmp_variant_value *value) -{ - /* all items except tcpConnectionState and tcpConnectionProcess are declared as not-accessible */ - switch (*column) { - case 7: /* tcpConnectionState */ - value->u32 = pcb->state + 1; - break; - case 8: /* tcpConnectionProcess */ - value->u32 = 0; /* not supported */ - break; - default: - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -tcp_ConnectionTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - ip_addr_t local_ip, remote_ip; - u16_t local_port, remote_port; - struct tcp_pcb *pcb; - u8_t idx = 0; - u8_t i; - struct tcp_pcb **const tcp_pcb_nonlisten_lists[] = {&tcp_bound_pcbs, &tcp_active_pcbs, &tcp_tw_pcbs}; - - LWIP_UNUSED_ARG(value_len); - - /* tcpConnectionLocalAddressType + tcpConnectionLocalAddress + tcpConnectionLocalPort */ - idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port); - if (idx == 0) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* tcpConnectionRemAddressType + tcpConnectionRemAddress + tcpConnectionRemPort */ - idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &remote_ip, &remote_port); - if (idx == 0) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* find tcp_pcb with requested ip and port*/ - for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_nonlisten_lists); i++) { - pcb = *tcp_pcb_nonlisten_lists[i]; - - while (pcb != NULL) { - if (ip_addr_cmp(&local_ip, &pcb->local_ip) && - (local_port == pcb->local_port) && - ip_addr_cmp(&remote_ip, &pcb->remote_ip) && - (remote_port == pcb->remote_port)) { - /* fill in object properties */ - return tcp_ConnectionTable_get_cell_value_core(column, pcb, value); - } - pcb = pcb->next; - } - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -tcp_ConnectionTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - struct tcp_pcb *pcb; - struct snmp_next_oid_state state; - /* 1x tcpConnectionLocalAddressType + 1x OID len + 16x tcpConnectionLocalAddress + 1x tcpConnectionLocalPort - * 1x tcpConnectionRemAddressType + 1x OID len + 16x tcpConnectionRemAddress + 1x tcpConnectionRemPort */ - u32_t result_temp[38]; - u8_t i; - struct tcp_pcb **const tcp_pcb_nonlisten_lists[] = {&tcp_bound_pcbs, &tcp_active_pcbs, &tcp_tw_pcbs}; - - LWIP_UNUSED_ARG(value_len); - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp)); - - /* iterate over all possible OIDs to find the next one */ - for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_nonlisten_lists); i++) { - pcb = *tcp_pcb_nonlisten_lists[i]; - - while (pcb != NULL) { - u8_t idx = 0; - u32_t test_oid[LWIP_ARRAYSIZE(result_temp)]; - - /* tcpConnectionLocalAddressType + tcpConnectionLocalAddress + tcpConnectionLocalPort */ - idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]); - - /* tcpConnectionRemAddressType + tcpConnectionRemAddress + tcpConnectionRemPort */ - idx += snmp_ip_port_to_oid(&pcb->remote_ip, pcb->remote_port, &test_oid[idx]); - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, idx, pcb); - - pcb = pcb->next; - } - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return tcp_ConnectionTable_get_cell_value_core(column, (struct tcp_pcb *)state.reference, value); - } else { - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; - } -} - -/* --- tcpListenerTable --- */ - -static snmp_err_t -tcp_ListenerTable_get_cell_value_core(const u32_t *column, union snmp_variant_value *value) -{ - /* all items except tcpListenerProcess are declared as not-accessible */ - switch (*column) { - case 4: /* tcpListenerProcess */ - value->u32 = 0; /* not supported */ - break; - default: - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -tcp_ListenerTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - ip_addr_t local_ip; - u16_t local_port; - struct tcp_pcb_listen *pcb; - u8_t idx = 0; - - LWIP_UNUSED_ARG(value_len); - - /* tcpListenerLocalAddressType + tcpListenerLocalAddress + tcpListenerLocalPort */ - idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port); - if (idx == 0) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* find tcp_pcb with requested ip and port*/ - pcb = tcp_listen_pcbs.listen_pcbs; - while (pcb != NULL) { - if (ip_addr_cmp(&local_ip, &pcb->local_ip) && - (local_port == pcb->local_port)) { - /* fill in object properties */ - return tcp_ListenerTable_get_cell_value_core(column, value); - } - pcb = pcb->next; - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -tcp_ListenerTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - struct tcp_pcb_listen *pcb; - struct snmp_next_oid_state state; - /* 1x tcpListenerLocalAddressType + 1x OID len + 16x tcpListenerLocalAddress + 1x tcpListenerLocalPort */ - u32_t result_temp[19]; - - LWIP_UNUSED_ARG(value_len); - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp)); - - /* iterate over all possible OIDs to find the next one */ - pcb = tcp_listen_pcbs.listen_pcbs; - while (pcb != NULL) { - u8_t idx = 0; - u32_t test_oid[LWIP_ARRAYSIZE(result_temp)]; - - /* tcpListenerLocalAddressType + tcpListenerLocalAddress + tcpListenerLocalPort */ - idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]); - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, idx, NULL); - - pcb = pcb->next; - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return tcp_ListenerTable_get_cell_value_core(column, value); - } else { - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; - } -} - -static const struct snmp_scalar_node tcp_RtoAlgorithm = SNMP_SCALAR_CREATE_NODE_READONLY(1, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); -static const struct snmp_scalar_node tcp_RtoMin = SNMP_SCALAR_CREATE_NODE_READONLY(2, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); -static const struct snmp_scalar_node tcp_RtoMax = SNMP_SCALAR_CREATE_NODE_READONLY(3, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); -static const struct snmp_scalar_node tcp_MaxConn = SNMP_SCALAR_CREATE_NODE_READONLY(4, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); -static const struct snmp_scalar_node tcp_ActiveOpens = SNMP_SCALAR_CREATE_NODE_READONLY(5, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_PassiveOpens = SNMP_SCALAR_CREATE_NODE_READONLY(6, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_AttemptFails = SNMP_SCALAR_CREATE_NODE_READONLY(7, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_EstabResets = SNMP_SCALAR_CREATE_NODE_READONLY(8, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_CurrEstab = SNMP_SCALAR_CREATE_NODE_READONLY(9, SNMP_ASN1_TYPE_GAUGE, tcp_get_value); -static const struct snmp_scalar_node tcp_InSegs = SNMP_SCALAR_CREATE_NODE_READONLY(10, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_OutSegs = SNMP_SCALAR_CREATE_NODE_READONLY(11, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_RetransSegs = SNMP_SCALAR_CREATE_NODE_READONLY(12, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_InErrs = SNMP_SCALAR_CREATE_NODE_READONLY(14, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -static const struct snmp_scalar_node tcp_OutRsts = SNMP_SCALAR_CREATE_NODE_READONLY(15, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); -#if LWIP_HAVE_INT64 -static const struct snmp_scalar_node tcp_HCInSegs = SNMP_SCALAR_CREATE_NODE_READONLY(17, SNMP_ASN1_TYPE_COUNTER64, tcp_get_value); -static const struct snmp_scalar_node tcp_HCOutSegs = SNMP_SCALAR_CREATE_NODE_READONLY(18, SNMP_ASN1_TYPE_COUNTER64, tcp_get_value); -#endif - -#if LWIP_IPV4 -static const struct snmp_table_simple_col_def tcp_ConnTable_columns[] = { - { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnState */ - { 2, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnLocalAddress */ - { 3, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnLocalPort */ - { 4, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnRemAddress */ - { 5, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpConnRemPort */ -}; - -static const struct snmp_table_simple_node tcp_ConnTable = SNMP_TABLE_CREATE_SIMPLE(13, tcp_ConnTable_columns, tcp_ConnTable_get_cell_value, tcp_ConnTable_get_next_cell_instance_and_value); -#endif /* LWIP_IPV4 */ - -static const struct snmp_table_simple_col_def tcp_ConnectionTable_columns[] = { - /* all items except tcpConnectionState and tcpConnectionProcess are declared as not-accessible */ - { 7, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnectionState */ - { 8, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpConnectionProcess */ -}; - -static const struct snmp_table_simple_node tcp_ConnectionTable = SNMP_TABLE_CREATE_SIMPLE(19, tcp_ConnectionTable_columns, tcp_ConnectionTable_get_cell_value, tcp_ConnectionTable_get_next_cell_instance_and_value); - - -static const struct snmp_table_simple_col_def tcp_ListenerTable_columns[] = { - /* all items except tcpListenerProcess are declared as not-accessible */ - { 4, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpListenerProcess */ -}; - -static const struct snmp_table_simple_node tcp_ListenerTable = SNMP_TABLE_CREATE_SIMPLE(20, tcp_ListenerTable_columns, tcp_ListenerTable_get_cell_value, tcp_ListenerTable_get_next_cell_instance_and_value); - -/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ -CREATE_LWIP_SYNC_NODE( 1, tcp_RtoAlgorithm) -CREATE_LWIP_SYNC_NODE( 2, tcp_RtoMin) -CREATE_LWIP_SYNC_NODE( 3, tcp_RtoMax) -CREATE_LWIP_SYNC_NODE( 4, tcp_MaxConn) -CREATE_LWIP_SYNC_NODE( 5, tcp_ActiveOpens) -CREATE_LWIP_SYNC_NODE( 6, tcp_PassiveOpens) -CREATE_LWIP_SYNC_NODE( 7, tcp_AttemptFails) -CREATE_LWIP_SYNC_NODE( 8, tcp_EstabResets) -CREATE_LWIP_SYNC_NODE( 9, tcp_CurrEstab) -CREATE_LWIP_SYNC_NODE(10, tcp_InSegs) -CREATE_LWIP_SYNC_NODE(11, tcp_OutSegs) -CREATE_LWIP_SYNC_NODE(12, tcp_RetransSegs) -#if LWIP_IPV4 -CREATE_LWIP_SYNC_NODE(13, tcp_ConnTable) -#endif /* LWIP_IPV4 */ -CREATE_LWIP_SYNC_NODE(14, tcp_InErrs) -CREATE_LWIP_SYNC_NODE(15, tcp_OutRsts) -#if LWIP_HAVE_INT64 -CREATE_LWIP_SYNC_NODE(17, tcp_HCInSegs) -CREATE_LWIP_SYNC_NODE(18, tcp_HCOutSegs) -#endif -CREATE_LWIP_SYNC_NODE(19, tcp_ConnectionTable) -CREATE_LWIP_SYNC_NODE(20, tcp_ListenerTable) - -static const struct snmp_node *const tcp_nodes[] = { - &SYNC_NODE_NAME(tcp_RtoAlgorithm).node.node, - &SYNC_NODE_NAME(tcp_RtoMin).node.node, - &SYNC_NODE_NAME(tcp_RtoMax).node.node, - &SYNC_NODE_NAME(tcp_MaxConn).node.node, - &SYNC_NODE_NAME(tcp_ActiveOpens).node.node, - &SYNC_NODE_NAME(tcp_PassiveOpens).node.node, - &SYNC_NODE_NAME(tcp_AttemptFails).node.node, - &SYNC_NODE_NAME(tcp_EstabResets).node.node, - &SYNC_NODE_NAME(tcp_CurrEstab).node.node, - &SYNC_NODE_NAME(tcp_InSegs).node.node, - &SYNC_NODE_NAME(tcp_OutSegs).node.node, - &SYNC_NODE_NAME(tcp_RetransSegs).node.node, -#if LWIP_IPV4 - &SYNC_NODE_NAME(tcp_ConnTable).node.node, -#endif /* LWIP_IPV4 */ - &SYNC_NODE_NAME(tcp_InErrs).node.node, - &SYNC_NODE_NAME(tcp_OutRsts).node.node, - &SYNC_NODE_NAME(tcp_HCInSegs).node.node, -#if LWIP_HAVE_INT64 - &SYNC_NODE_NAME(tcp_HCOutSegs).node.node, - &SYNC_NODE_NAME(tcp_ConnectionTable).node.node, -#endif - &SYNC_NODE_NAME(tcp_ListenerTable).node.node -}; - -const struct snmp_tree_node snmp_mib2_tcp_root = SNMP_CREATE_TREE_NODE(6, tcp_nodes); -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_TCP */ +/** + * @file + * Management Information Base II (RFC1213) TCP objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/tcp.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/stats.h" + +#include + +#if LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_TCP + +#if SNMP_USE_NETCONN +#define SYNC_NODE_NAME(node_name) node_name ## _synced +#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ + static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); +#else +#define SYNC_NODE_NAME(node_name) node_name +#define CREATE_LWIP_SYNC_NODE(oid, node_name) +#endif + +/* --- tcp .1.3.6.1.2.1.6 ----------------------------------------------------- */ + +static s16_t +tcp_get_value(struct snmp_node_instance *instance, void *value) +{ + u32_t *uint_ptr = (u32_t *)value; + s32_t *sint_ptr = (s32_t *)value; + + switch (instance->node->oid) { + case 1: /* tcpRtoAlgorithm, vanj(4) */ + *sint_ptr = 4; + return sizeof(*sint_ptr); + case 2: /* tcpRtoMin */ + /* @todo not the actual value, a guess, + needs to be calculated */ + *sint_ptr = 1000; + return sizeof(*sint_ptr); + case 3: /* tcpRtoMax */ + /* @todo not the actual value, a guess, + needs to be calculated */ + *sint_ptr = 60000; + return sizeof(*sint_ptr); + case 4: /* tcpMaxConn */ + *sint_ptr = MEMP_NUM_TCP_PCB; + return sizeof(*sint_ptr); + case 5: /* tcpActiveOpens */ + *uint_ptr = STATS_GET(mib2.tcpactiveopens); + return sizeof(*uint_ptr); + case 6: /* tcpPassiveOpens */ + *uint_ptr = STATS_GET(mib2.tcppassiveopens); + return sizeof(*uint_ptr); + case 7: /* tcpAttemptFails */ + *uint_ptr = STATS_GET(mib2.tcpattemptfails); + return sizeof(*uint_ptr); + case 8: /* tcpEstabResets */ + *uint_ptr = STATS_GET(mib2.tcpestabresets); + return sizeof(*uint_ptr); + case 9: { /* tcpCurrEstab */ + u16_t tcpcurrestab = 0; + struct tcp_pcb *pcb = tcp_active_pcbs; + while (pcb != NULL) { + if ((pcb->state == ESTABLISHED) || + (pcb->state == CLOSE_WAIT)) { + tcpcurrestab++; + } + pcb = pcb->next; + } + *uint_ptr = tcpcurrestab; + } + return sizeof(*uint_ptr); + case 10: /* tcpInSegs */ + *uint_ptr = STATS_GET(mib2.tcpinsegs); + return sizeof(*uint_ptr); + case 11: /* tcpOutSegs */ + *uint_ptr = STATS_GET(mib2.tcpoutsegs); + return sizeof(*uint_ptr); + case 12: /* tcpRetransSegs */ + *uint_ptr = STATS_GET(mib2.tcpretranssegs); + return sizeof(*uint_ptr); + case 14: /* tcpInErrs */ + *uint_ptr = STATS_GET(mib2.tcpinerrs); + return sizeof(*uint_ptr); + case 15: /* tcpOutRsts */ + *uint_ptr = STATS_GET(mib2.tcpoutrsts); + return sizeof(*uint_ptr); +#if LWIP_HAVE_INT64 + case 17: { /* tcpHCInSegs */ + /* use the 32 bit counter for now... */ + u64_t val64 = STATS_GET(mib2.tcpinsegs); + *((u64_t *)value) = val64; + } + return sizeof(u64_t); + case 18: { /* tcpHCOutSegs */ + /* use the 32 bit counter for now... */ + u64_t val64 = STATS_GET(mib2.tcpoutsegs); + *((u64_t *)value) = val64; + } + return sizeof(u64_t); +#endif + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("tcp_get_value(): unknown id: %"S32_F"\n", instance->node->oid)); + break; + } + + return 0; +} + +/* --- tcpConnTable --- */ + +#if LWIP_IPV4 + +/* list of allowed value ranges for incoming OID */ +static const struct snmp_oid_range tcp_ConnTable_oid_ranges[] = { + { 0, 0xff }, /* IP A */ + { 0, 0xff }, /* IP B */ + { 0, 0xff }, /* IP C */ + { 0, 0xff }, /* IP D */ + { 0, 0xffff }, /* Port */ + { 0, 0xff }, /* IP A */ + { 0, 0xff }, /* IP B */ + { 0, 0xff }, /* IP C */ + { 0, 0xff }, /* IP D */ + { 0, 0xffff } /* Port */ +}; + +static snmp_err_t +tcp_ConnTable_get_cell_value_core(struct tcp_pcb *pcb, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) +{ + LWIP_UNUSED_ARG(value_len); + + /* value */ + switch (*column) { + case 1: /* tcpConnState */ + value->u32 = pcb->state + 1; + break; + case 2: /* tcpConnLocalAddress */ + value->u32 = ip_2_ip4(&pcb->local_ip)->addr; + break; + case 3: /* tcpConnLocalPort */ + value->u32 = pcb->local_port; + break; + case 4: /* tcpConnRemAddress */ + if (pcb->state == LISTEN) { + value->u32 = IP4_ADDR_ANY4->addr; + } else { + value->u32 = ip_2_ip4(&pcb->remote_ip)->addr; + } + break; + case 5: /* tcpConnRemPort */ + if (pcb->state == LISTEN) { + value->u32 = 0; + } else { + value->u32 = pcb->remote_port; + } + break; + default: + LWIP_ASSERT("invalid id", 0); + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +tcp_ConnTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + u8_t i; + ip4_addr_t local_ip; + ip4_addr_t remote_ip; + u16_t local_port; + u16_t remote_port; + struct tcp_pcb *pcb; + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(row_oid, row_oid_len, tcp_ConnTable_oid_ranges, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges))) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* get IPs and ports from incoming OID */ + snmp_oid_to_ip4(&row_oid[0], &local_ip); /* we know it succeeds because of oid_in_range check above */ + local_port = (u16_t)row_oid[4]; + snmp_oid_to_ip4(&row_oid[5], &remote_ip); /* we know it succeeds because of oid_in_range check above */ + remote_port = (u16_t)row_oid[9]; + + /* find tcp_pcb with requested ips and ports */ + for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) { + pcb = *tcp_pcb_lists[i]; + + while (pcb != NULL) { + /* do local IP and local port match? */ + if (IP_IS_V4_VAL(pcb->local_ip) && + ip4_addr_cmp(&local_ip, ip_2_ip4(&pcb->local_ip)) && (local_port == pcb->local_port)) { + + /* PCBs in state LISTEN are not connected and have no remote_ip or remote_port */ + if (pcb->state == LISTEN) { + if (ip4_addr_cmp(&remote_ip, IP4_ADDR_ANY4) && (remote_port == 0)) { + /* fill in object properties */ + return tcp_ConnTable_get_cell_value_core(pcb, column, value, value_len); + } + } else { + if (IP_IS_V4_VAL(pcb->remote_ip) && + ip4_addr_cmp(&remote_ip, ip_2_ip4(&pcb->remote_ip)) && (remote_port == pcb->remote_port)) { + /* fill in object properties */ + return tcp_ConnTable_get_cell_value_core(pcb, column, value, value_len); + } + } + } + + pcb = pcb->next; + } + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +tcp_ConnTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + u8_t i; + struct tcp_pcb *pcb; + struct snmp_next_oid_state state; + u32_t result_temp[LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)]; + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)); + + /* iterate over all possible OIDs to find the next one */ + for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) { + pcb = *tcp_pcb_lists[i]; + while (pcb != NULL) { + u32_t test_oid[LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges)]; + + if (IP_IS_V4_VAL(pcb->local_ip)) { + snmp_ip4_to_oid(ip_2_ip4(&pcb->local_ip), &test_oid[0]); + test_oid[4] = pcb->local_port; + + /* PCBs in state LISTEN are not connected and have no remote_ip or remote_port */ + if (pcb->state == LISTEN) { + snmp_ip4_to_oid(IP4_ADDR_ANY4, &test_oid[5]); + test_oid[9] = 0; + } else { + if (IP_IS_V6_VAL(pcb->remote_ip)) { /* should never happen */ + continue; + } + snmp_ip4_to_oid(ip_2_ip4(&pcb->remote_ip), &test_oid[5]); + test_oid[9] = pcb->remote_port; + } + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(tcp_ConnTable_oid_ranges), pcb); + } + + pcb = pcb->next; + } + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return tcp_ConnTable_get_cell_value_core((struct tcp_pcb *)state.reference, column, value, value_len); + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +#endif /* LWIP_IPV4 */ + +/* --- tcpConnectionTable --- */ + +static snmp_err_t +tcp_ConnectionTable_get_cell_value_core(const u32_t *column, struct tcp_pcb *pcb, union snmp_variant_value *value) +{ + /* all items except tcpConnectionState and tcpConnectionProcess are declared as not-accessible */ + switch (*column) { + case 7: /* tcpConnectionState */ + value->u32 = pcb->state + 1; + break; + case 8: /* tcpConnectionProcess */ + value->u32 = 0; /* not supported */ + break; + default: + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +tcp_ConnectionTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + ip_addr_t local_ip, remote_ip; + u16_t local_port, remote_port; + struct tcp_pcb *pcb; + u8_t idx = 0; + u8_t i; + struct tcp_pcb **const tcp_pcb_nonlisten_lists[] = {&tcp_bound_pcbs, &tcp_active_pcbs, &tcp_tw_pcbs}; + + LWIP_UNUSED_ARG(value_len); + + /* tcpConnectionLocalAddressType + tcpConnectionLocalAddress + tcpConnectionLocalPort */ + idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port); + if (idx == 0) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* tcpConnectionRemAddressType + tcpConnectionRemAddress + tcpConnectionRemPort */ + idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &remote_ip, &remote_port); + if (idx == 0) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* find tcp_pcb with requested ip and port*/ + for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_nonlisten_lists); i++) { + pcb = *tcp_pcb_nonlisten_lists[i]; + + while (pcb != NULL) { + if (ip_addr_cmp(&local_ip, &pcb->local_ip) && + (local_port == pcb->local_port) && + ip_addr_cmp(&remote_ip, &pcb->remote_ip) && + (remote_port == pcb->remote_port)) { + /* fill in object properties */ + return tcp_ConnectionTable_get_cell_value_core(column, pcb, value); + } + pcb = pcb->next; + } + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +tcp_ConnectionTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + struct tcp_pcb *pcb; + struct snmp_next_oid_state state; + /* 1x tcpConnectionLocalAddressType + 1x OID len + 16x tcpConnectionLocalAddress + 1x tcpConnectionLocalPort + * 1x tcpConnectionRemAddressType + 1x OID len + 16x tcpConnectionRemAddress + 1x tcpConnectionRemPort */ + u32_t result_temp[38]; + u8_t i; + struct tcp_pcb **const tcp_pcb_nonlisten_lists[] = {&tcp_bound_pcbs, &tcp_active_pcbs, &tcp_tw_pcbs}; + + LWIP_UNUSED_ARG(value_len); + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp)); + + /* iterate over all possible OIDs to find the next one */ + for (i = 0; i < LWIP_ARRAYSIZE(tcp_pcb_nonlisten_lists); i++) { + pcb = *tcp_pcb_nonlisten_lists[i]; + + while (pcb != NULL) { + u8_t idx = 0; + u32_t test_oid[LWIP_ARRAYSIZE(result_temp)]; + + /* tcpConnectionLocalAddressType + tcpConnectionLocalAddress + tcpConnectionLocalPort */ + idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]); + + /* tcpConnectionRemAddressType + tcpConnectionRemAddress + tcpConnectionRemPort */ + idx += snmp_ip_port_to_oid(&pcb->remote_ip, pcb->remote_port, &test_oid[idx]); + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, idx, pcb); + + pcb = pcb->next; + } + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return tcp_ConnectionTable_get_cell_value_core(column, (struct tcp_pcb *)state.reference, value); + } else { + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; + } +} + +/* --- tcpListenerTable --- */ + +static snmp_err_t +tcp_ListenerTable_get_cell_value_core(const u32_t *column, union snmp_variant_value *value) +{ + /* all items except tcpListenerProcess are declared as not-accessible */ + switch (*column) { + case 4: /* tcpListenerProcess */ + value->u32 = 0; /* not supported */ + break; + default: + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +tcp_ListenerTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + ip_addr_t local_ip; + u16_t local_port; + struct tcp_pcb_listen *pcb; + u8_t idx = 0; + + LWIP_UNUSED_ARG(value_len); + + /* tcpListenerLocalAddressType + tcpListenerLocalAddress + tcpListenerLocalPort */ + idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port); + if (idx == 0) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* find tcp_pcb with requested ip and port*/ + pcb = tcp_listen_pcbs.listen_pcbs; + while (pcb != NULL) { + if (ip_addr_cmp(&local_ip, &pcb->local_ip) && + (local_port == pcb->local_port)) { + /* fill in object properties */ + return tcp_ListenerTable_get_cell_value_core(column, value); + } + pcb = pcb->next; + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +tcp_ListenerTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + struct tcp_pcb_listen *pcb; + struct snmp_next_oid_state state; + /* 1x tcpListenerLocalAddressType + 1x OID len + 16x tcpListenerLocalAddress + 1x tcpListenerLocalPort */ + u32_t result_temp[19]; + + LWIP_UNUSED_ARG(value_len); + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp)); + + /* iterate over all possible OIDs to find the next one */ + pcb = tcp_listen_pcbs.listen_pcbs; + while (pcb != NULL) { + u8_t idx = 0; + u32_t test_oid[LWIP_ARRAYSIZE(result_temp)]; + + /* tcpListenerLocalAddressType + tcpListenerLocalAddress + tcpListenerLocalPort */ + idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]); + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, idx, NULL); + + pcb = pcb->next; + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return tcp_ListenerTable_get_cell_value_core(column, value); + } else { + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; + } +} + +static const struct snmp_scalar_node tcp_RtoAlgorithm = SNMP_SCALAR_CREATE_NODE_READONLY(1, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); +static const struct snmp_scalar_node tcp_RtoMin = SNMP_SCALAR_CREATE_NODE_READONLY(2, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); +static const struct snmp_scalar_node tcp_RtoMax = SNMP_SCALAR_CREATE_NODE_READONLY(3, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); +static const struct snmp_scalar_node tcp_MaxConn = SNMP_SCALAR_CREATE_NODE_READONLY(4, SNMP_ASN1_TYPE_INTEGER, tcp_get_value); +static const struct snmp_scalar_node tcp_ActiveOpens = SNMP_SCALAR_CREATE_NODE_READONLY(5, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_PassiveOpens = SNMP_SCALAR_CREATE_NODE_READONLY(6, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_AttemptFails = SNMP_SCALAR_CREATE_NODE_READONLY(7, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_EstabResets = SNMP_SCALAR_CREATE_NODE_READONLY(8, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_CurrEstab = SNMP_SCALAR_CREATE_NODE_READONLY(9, SNMP_ASN1_TYPE_GAUGE, tcp_get_value); +static const struct snmp_scalar_node tcp_InSegs = SNMP_SCALAR_CREATE_NODE_READONLY(10, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_OutSegs = SNMP_SCALAR_CREATE_NODE_READONLY(11, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_RetransSegs = SNMP_SCALAR_CREATE_NODE_READONLY(12, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_InErrs = SNMP_SCALAR_CREATE_NODE_READONLY(14, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +static const struct snmp_scalar_node tcp_OutRsts = SNMP_SCALAR_CREATE_NODE_READONLY(15, SNMP_ASN1_TYPE_COUNTER, tcp_get_value); +#if LWIP_HAVE_INT64 +static const struct snmp_scalar_node tcp_HCInSegs = SNMP_SCALAR_CREATE_NODE_READONLY(17, SNMP_ASN1_TYPE_COUNTER64, tcp_get_value); +static const struct snmp_scalar_node tcp_HCOutSegs = SNMP_SCALAR_CREATE_NODE_READONLY(18, SNMP_ASN1_TYPE_COUNTER64, tcp_get_value); +#endif + +#if LWIP_IPV4 +static const struct snmp_table_simple_col_def tcp_ConnTable_columns[] = { + { 1, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnState */ + { 2, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnLocalAddress */ + { 3, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnLocalPort */ + { 4, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnRemAddress */ + { 5, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpConnRemPort */ +}; + +static const struct snmp_table_simple_node tcp_ConnTable = SNMP_TABLE_CREATE_SIMPLE(13, tcp_ConnTable_columns, tcp_ConnTable_get_cell_value, tcp_ConnTable_get_next_cell_instance_and_value); +#endif /* LWIP_IPV4 */ + +static const struct snmp_table_simple_col_def tcp_ConnectionTable_columns[] = { + /* all items except tcpConnectionState and tcpConnectionProcess are declared as not-accessible */ + { 7, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 }, /* tcpConnectionState */ + { 8, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpConnectionProcess */ +}; + +static const struct snmp_table_simple_node tcp_ConnectionTable = SNMP_TABLE_CREATE_SIMPLE(19, tcp_ConnectionTable_columns, tcp_ConnectionTable_get_cell_value, tcp_ConnectionTable_get_next_cell_instance_and_value); + + +static const struct snmp_table_simple_col_def tcp_ListenerTable_columns[] = { + /* all items except tcpListenerProcess are declared as not-accessible */ + { 4, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* tcpListenerProcess */ +}; + +static const struct snmp_table_simple_node tcp_ListenerTable = SNMP_TABLE_CREATE_SIMPLE(20, tcp_ListenerTable_columns, tcp_ListenerTable_get_cell_value, tcp_ListenerTable_get_next_cell_instance_and_value); + +/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ +CREATE_LWIP_SYNC_NODE( 1, tcp_RtoAlgorithm) +CREATE_LWIP_SYNC_NODE( 2, tcp_RtoMin) +CREATE_LWIP_SYNC_NODE( 3, tcp_RtoMax) +CREATE_LWIP_SYNC_NODE( 4, tcp_MaxConn) +CREATE_LWIP_SYNC_NODE( 5, tcp_ActiveOpens) +CREATE_LWIP_SYNC_NODE( 6, tcp_PassiveOpens) +CREATE_LWIP_SYNC_NODE( 7, tcp_AttemptFails) +CREATE_LWIP_SYNC_NODE( 8, tcp_EstabResets) +CREATE_LWIP_SYNC_NODE( 9, tcp_CurrEstab) +CREATE_LWIP_SYNC_NODE(10, tcp_InSegs) +CREATE_LWIP_SYNC_NODE(11, tcp_OutSegs) +CREATE_LWIP_SYNC_NODE(12, tcp_RetransSegs) +#if LWIP_IPV4 +CREATE_LWIP_SYNC_NODE(13, tcp_ConnTable) +#endif /* LWIP_IPV4 */ +CREATE_LWIP_SYNC_NODE(14, tcp_InErrs) +CREATE_LWIP_SYNC_NODE(15, tcp_OutRsts) +#if LWIP_HAVE_INT64 +CREATE_LWIP_SYNC_NODE(17, tcp_HCInSegs) +CREATE_LWIP_SYNC_NODE(18, tcp_HCOutSegs) +#endif +CREATE_LWIP_SYNC_NODE(19, tcp_ConnectionTable) +CREATE_LWIP_SYNC_NODE(20, tcp_ListenerTable) + +static const struct snmp_node *const tcp_nodes[] = { + &SYNC_NODE_NAME(tcp_RtoAlgorithm).node.node, + &SYNC_NODE_NAME(tcp_RtoMin).node.node, + &SYNC_NODE_NAME(tcp_RtoMax).node.node, + &SYNC_NODE_NAME(tcp_MaxConn).node.node, + &SYNC_NODE_NAME(tcp_ActiveOpens).node.node, + &SYNC_NODE_NAME(tcp_PassiveOpens).node.node, + &SYNC_NODE_NAME(tcp_AttemptFails).node.node, + &SYNC_NODE_NAME(tcp_EstabResets).node.node, + &SYNC_NODE_NAME(tcp_CurrEstab).node.node, + &SYNC_NODE_NAME(tcp_InSegs).node.node, + &SYNC_NODE_NAME(tcp_OutSegs).node.node, + &SYNC_NODE_NAME(tcp_RetransSegs).node.node, +#if LWIP_IPV4 + &SYNC_NODE_NAME(tcp_ConnTable).node.node, +#endif /* LWIP_IPV4 */ + &SYNC_NODE_NAME(tcp_InErrs).node.node, + &SYNC_NODE_NAME(tcp_OutRsts).node.node, + &SYNC_NODE_NAME(tcp_HCInSegs).node.node, +#if LWIP_HAVE_INT64 + &SYNC_NODE_NAME(tcp_HCOutSegs).node.node, + &SYNC_NODE_NAME(tcp_ConnectionTable).node.node, +#endif + &SYNC_NODE_NAME(tcp_ListenerTable).node.node +}; + +const struct snmp_tree_node snmp_mib2_tcp_root = SNMP_CREATE_TREE_NODE(6, tcp_nodes); +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_TCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_udp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_udp.c index 3c89029e..d0bd5dec 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_udp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_mib2_udp.c @@ -1,372 +1,372 @@ -/** - * @file - * Management Information Base II (RFC1213) UDP objects and functions. - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - * Christiaan Simons - */ - -#include "lwip/snmp.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_mib2.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/udp.h" -#include "lwip/stats.h" - -#include - -#if LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_UDP - -#if SNMP_USE_NETCONN -#define SYNC_NODE_NAME(node_name) node_name ## _synced -#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ - static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); -#else -#define SYNC_NODE_NAME(node_name) node_name -#define CREATE_LWIP_SYNC_NODE(oid, node_name) -#endif - -/* --- udp .1.3.6.1.2.1.7 ----------------------------------------------------- */ - -static s16_t -udp_get_value(struct snmp_node_instance *instance, void *value) -{ - u32_t *uint_ptr = (u32_t *)value; - - switch (instance->node->oid) { - case 1: /* udpInDatagrams */ - *uint_ptr = STATS_GET(mib2.udpindatagrams); - return sizeof(*uint_ptr); - case 2: /* udpNoPorts */ - *uint_ptr = STATS_GET(mib2.udpnoports); - return sizeof(*uint_ptr); - case 3: /* udpInErrors */ - *uint_ptr = STATS_GET(mib2.udpinerrors); - return sizeof(*uint_ptr); - case 4: /* udpOutDatagrams */ - *uint_ptr = STATS_GET(mib2.udpoutdatagrams); - return sizeof(*uint_ptr); -#if LWIP_HAVE_INT64 - case 8: { /* udpHCInDatagrams */ - /* use the 32 bit counter for now... */ - u64_t val64 = STATS_GET(mib2.udpindatagrams); - *((u64_t *)value) = val64; - } - return sizeof(u64_t); - case 9: { /* udpHCOutDatagrams */ - /* use the 32 bit counter for now... */ - u64_t val64 = STATS_GET(mib2.udpoutdatagrams); - *((u64_t *)value) = val64; - } - return sizeof(u64_t); -#endif - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("udp_get_value(): unknown id: %"S32_F"\n", instance->node->oid)); - break; - } - - return 0; -} - -/* --- udpEndpointTable --- */ - -static snmp_err_t -udp_endpointTable_get_cell_value_core(const u32_t *column, union snmp_variant_value *value) -{ - /* all items except udpEndpointProcess are declared as not-accessible */ - switch (*column) { - case 8: /* udpEndpointProcess */ - value->u32 = 0; /* not supported */ - break; - default: - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -udp_endpointTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - ip_addr_t local_ip, remote_ip; - u16_t local_port, remote_port; - struct udp_pcb *pcb; - u8_t idx = 0; - - LWIP_UNUSED_ARG(value_len); - - /* udpEndpointLocalAddressType + udpEndpointLocalAddress + udpEndpointLocalPort */ - idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port); - if (idx == 0) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* udpEndpointRemoteAddressType + udpEndpointRemoteAddress + udpEndpointRemotePort */ - idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &remote_ip, &remote_port); - if (idx == 0) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* udpEndpointInstance */ - if (row_oid_len < (idx + 1)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - if (row_oid[idx] != 0) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* find udp_pcb with requested ip and port*/ - pcb = udp_pcbs; - while (pcb != NULL) { - if (ip_addr_cmp(&local_ip, &pcb->local_ip) && - (local_port == pcb->local_port) && - ip_addr_cmp(&remote_ip, &pcb->remote_ip) && - (remote_port == pcb->remote_port)) { - /* fill in object properties */ - return udp_endpointTable_get_cell_value_core(column, value); - } - pcb = pcb->next; - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -udp_endpointTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - struct udp_pcb *pcb; - struct snmp_next_oid_state state; - /* 1x udpEndpointLocalAddressType + 1x OID len + 16x udpEndpointLocalAddress + 1x udpEndpointLocalPort + - * 1x udpEndpointRemoteAddressType + 1x OID len + 16x udpEndpointRemoteAddress + 1x udpEndpointRemotePort + - * 1x udpEndpointInstance = 39 - */ - u32_t result_temp[39]; - - LWIP_UNUSED_ARG(value_len); - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp)); - - /* iterate over all possible OIDs to find the next one */ - pcb = udp_pcbs; - while (pcb != NULL) { - u32_t test_oid[LWIP_ARRAYSIZE(result_temp)]; - u8_t idx = 0; - - /* udpEndpointLocalAddressType + udpEndpointLocalAddress + udpEndpointLocalPort */ - idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]); - - /* udpEndpointRemoteAddressType + udpEndpointRemoteAddress + udpEndpointRemotePort */ - idx += snmp_ip_port_to_oid(&pcb->remote_ip, pcb->remote_port, &test_oid[idx]); - - test_oid[idx] = 0; /* udpEndpointInstance */ - idx++; - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, idx, NULL); - - pcb = pcb->next; - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return udp_endpointTable_get_cell_value_core(column, value); - } else { - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; - } -} - -/* --- udpTable --- */ - -#if LWIP_IPV4 - -/* list of allowed value ranges for incoming OID */ -static const struct snmp_oid_range udp_Table_oid_ranges[] = { - { 0, 0xff }, /* IP A */ - { 0, 0xff }, /* IP B */ - { 0, 0xff }, /* IP C */ - { 0, 0xff }, /* IP D */ - { 1, 0xffff } /* Port */ -}; - -static snmp_err_t -udp_Table_get_cell_value_core(struct udp_pcb *pcb, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) -{ - LWIP_UNUSED_ARG(value_len); - - switch (*column) { - case 1: /* udpLocalAddress */ - /* set reference to PCB local IP and return a generic node that copies IP4 addresses */ - value->u32 = ip_2_ip4(&pcb->local_ip)->addr; - break; - case 2: /* udpLocalPort */ - /* set reference to PCB local port and return a generic node that copies u16_t values */ - value->u32 = pcb->local_port; - break; - default: - return SNMP_ERR_NOSUCHINSTANCE; - } - - return SNMP_ERR_NOERROR; -} - -static snmp_err_t -udp_Table_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) -{ - ip4_addr_t ip; - u16_t port; - struct udp_pcb *pcb; - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(row_oid, row_oid_len, udp_Table_oid_ranges, LWIP_ARRAYSIZE(udp_Table_oid_ranges))) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* get IP and port from incoming OID */ - snmp_oid_to_ip4(&row_oid[0], &ip); /* we know it succeeds because of oid_in_range check above */ - port = (u16_t)row_oid[4]; - - /* find udp_pcb with requested ip and port*/ - pcb = udp_pcbs; - while (pcb != NULL) { - if (IP_IS_V4_VAL(pcb->local_ip)) { - if (ip4_addr_cmp(&ip, ip_2_ip4(&pcb->local_ip)) && (port == pcb->local_port)) { - /* fill in object properties */ - return udp_Table_get_cell_value_core(pcb, column, value, value_len); - } - } - pcb = pcb->next; - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static snmp_err_t -udp_Table_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) -{ - struct udp_pcb *pcb; - struct snmp_next_oid_state state; - u32_t result_temp[LWIP_ARRAYSIZE(udp_Table_oid_ranges)]; - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(udp_Table_oid_ranges)); - - /* iterate over all possible OIDs to find the next one */ - pcb = udp_pcbs; - while (pcb != NULL) { - u32_t test_oid[LWIP_ARRAYSIZE(udp_Table_oid_ranges)]; - - if (IP_IS_V4_VAL(pcb->local_ip)) { - snmp_ip4_to_oid(ip_2_ip4(&pcb->local_ip), &test_oid[0]); - test_oid[4] = pcb->local_port; - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(udp_Table_oid_ranges), pcb); - } - - pcb = pcb->next; - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* fill in object properties */ - return udp_Table_get_cell_value_core((struct udp_pcb *)state.reference, column, value, value_len); - } else { - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; - } -} - -#endif /* LWIP_IPV4 */ - -static const struct snmp_scalar_node udp_inDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(1, SNMP_ASN1_TYPE_COUNTER, udp_get_value); -static const struct snmp_scalar_node udp_noPorts = SNMP_SCALAR_CREATE_NODE_READONLY(2, SNMP_ASN1_TYPE_COUNTER, udp_get_value); -static const struct snmp_scalar_node udp_inErrors = SNMP_SCALAR_CREATE_NODE_READONLY(3, SNMP_ASN1_TYPE_COUNTER, udp_get_value); -static const struct snmp_scalar_node udp_outDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(4, SNMP_ASN1_TYPE_COUNTER, udp_get_value); -#if LWIP_HAVE_INT64 -static const struct snmp_scalar_node udp_HCInDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(8, SNMP_ASN1_TYPE_COUNTER64, udp_get_value); -static const struct snmp_scalar_node udp_HCOutDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(9, SNMP_ASN1_TYPE_COUNTER64, udp_get_value); -#endif - -#if LWIP_IPV4 -static const struct snmp_table_simple_col_def udp_Table_columns[] = { - { 1, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* udpLocalAddress */ - { 2, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* udpLocalPort */ -}; -static const struct snmp_table_simple_node udp_Table = SNMP_TABLE_CREATE_SIMPLE(5, udp_Table_columns, udp_Table_get_cell_value, udp_Table_get_next_cell_instance_and_value); -#endif /* LWIP_IPV4 */ - -static const struct snmp_table_simple_col_def udp_endpointTable_columns[] = { - /* all items except udpEndpointProcess are declared as not-accessible */ - { 8, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* udpEndpointProcess */ -}; - -static const struct snmp_table_simple_node udp_endpointTable = SNMP_TABLE_CREATE_SIMPLE(7, udp_endpointTable_columns, udp_endpointTable_get_cell_value, udp_endpointTable_get_next_cell_instance_and_value); - -/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ -CREATE_LWIP_SYNC_NODE(1, udp_inDatagrams) -CREATE_LWIP_SYNC_NODE(2, udp_noPorts) -CREATE_LWIP_SYNC_NODE(3, udp_inErrors) -CREATE_LWIP_SYNC_NODE(4, udp_outDatagrams) -#if LWIP_IPV4 -CREATE_LWIP_SYNC_NODE(5, udp_Table) -#endif /* LWIP_IPV4 */ -CREATE_LWIP_SYNC_NODE(7, udp_endpointTable) -#if LWIP_HAVE_INT64 -CREATE_LWIP_SYNC_NODE(8, udp_HCInDatagrams) -CREATE_LWIP_SYNC_NODE(9, udp_HCOutDatagrams) -#endif - -static const struct snmp_node *const udp_nodes[] = { - &SYNC_NODE_NAME(udp_inDatagrams).node.node, - &SYNC_NODE_NAME(udp_noPorts).node.node, - &SYNC_NODE_NAME(udp_inErrors).node.node, - &SYNC_NODE_NAME(udp_outDatagrams).node.node, -#if LWIP_IPV4 - &SYNC_NODE_NAME(udp_Table).node.node, -#endif /* LWIP_IPV4 */ - &SYNC_NODE_NAME(udp_endpointTable).node.node -#if LWIP_HAVE_INT64 - , - &SYNC_NODE_NAME(udp_HCInDatagrams).node.node, - &SYNC_NODE_NAME(udp_HCOutDatagrams).node.node -#endif -}; - -const struct snmp_tree_node snmp_mib2_udp_root = SNMP_CREATE_TREE_NODE(7, udp_nodes); -#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_UDP */ +/** + * @file + * Management Information Base II (RFC1213) UDP objects and functions. + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + * Christiaan Simons + */ + +#include "lwip/snmp.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_mib2.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/udp.h" +#include "lwip/stats.h" + +#include + +#if LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_UDP + +#if SNMP_USE_NETCONN +#define SYNC_NODE_NAME(node_name) node_name ## _synced +#define CREATE_LWIP_SYNC_NODE(oid, node_name) \ + static const struct snmp_threadsync_node node_name ## _synced = SNMP_CREATE_THREAD_SYNC_NODE(oid, &node_name.node, &snmp_mib2_lwip_locks); +#else +#define SYNC_NODE_NAME(node_name) node_name +#define CREATE_LWIP_SYNC_NODE(oid, node_name) +#endif + +/* --- udp .1.3.6.1.2.1.7 ----------------------------------------------------- */ + +static s16_t +udp_get_value(struct snmp_node_instance *instance, void *value) +{ + u32_t *uint_ptr = (u32_t *)value; + + switch (instance->node->oid) { + case 1: /* udpInDatagrams */ + *uint_ptr = STATS_GET(mib2.udpindatagrams); + return sizeof(*uint_ptr); + case 2: /* udpNoPorts */ + *uint_ptr = STATS_GET(mib2.udpnoports); + return sizeof(*uint_ptr); + case 3: /* udpInErrors */ + *uint_ptr = STATS_GET(mib2.udpinerrors); + return sizeof(*uint_ptr); + case 4: /* udpOutDatagrams */ + *uint_ptr = STATS_GET(mib2.udpoutdatagrams); + return sizeof(*uint_ptr); +#if LWIP_HAVE_INT64 + case 8: { /* udpHCInDatagrams */ + /* use the 32 bit counter for now... */ + u64_t val64 = STATS_GET(mib2.udpindatagrams); + *((u64_t *)value) = val64; + } + return sizeof(u64_t); + case 9: { /* udpHCOutDatagrams */ + /* use the 32 bit counter for now... */ + u64_t val64 = STATS_GET(mib2.udpoutdatagrams); + *((u64_t *)value) = val64; + } + return sizeof(u64_t); +#endif + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("udp_get_value(): unknown id: %"S32_F"\n", instance->node->oid)); + break; + } + + return 0; +} + +/* --- udpEndpointTable --- */ + +static snmp_err_t +udp_endpointTable_get_cell_value_core(const u32_t *column, union snmp_variant_value *value) +{ + /* all items except udpEndpointProcess are declared as not-accessible */ + switch (*column) { + case 8: /* udpEndpointProcess */ + value->u32 = 0; /* not supported */ + break; + default: + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +udp_endpointTable_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + ip_addr_t local_ip, remote_ip; + u16_t local_port, remote_port; + struct udp_pcb *pcb; + u8_t idx = 0; + + LWIP_UNUSED_ARG(value_len); + + /* udpEndpointLocalAddressType + udpEndpointLocalAddress + udpEndpointLocalPort */ + idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &local_ip, &local_port); + if (idx == 0) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* udpEndpointRemoteAddressType + udpEndpointRemoteAddress + udpEndpointRemotePort */ + idx += snmp_oid_to_ip_port(&row_oid[idx], row_oid_len - idx, &remote_ip, &remote_port); + if (idx == 0) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* udpEndpointInstance */ + if (row_oid_len < (idx + 1)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + if (row_oid[idx] != 0) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* find udp_pcb with requested ip and port*/ + pcb = udp_pcbs; + while (pcb != NULL) { + if (ip_addr_cmp(&local_ip, &pcb->local_ip) && + (local_port == pcb->local_port) && + ip_addr_cmp(&remote_ip, &pcb->remote_ip) && + (remote_port == pcb->remote_port)) { + /* fill in object properties */ + return udp_endpointTable_get_cell_value_core(column, value); + } + pcb = pcb->next; + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +udp_endpointTable_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + struct udp_pcb *pcb; + struct snmp_next_oid_state state; + /* 1x udpEndpointLocalAddressType + 1x OID len + 16x udpEndpointLocalAddress + 1x udpEndpointLocalPort + + * 1x udpEndpointRemoteAddressType + 1x OID len + 16x udpEndpointRemoteAddress + 1x udpEndpointRemotePort + + * 1x udpEndpointInstance = 39 + */ + u32_t result_temp[39]; + + LWIP_UNUSED_ARG(value_len); + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(result_temp)); + + /* iterate over all possible OIDs to find the next one */ + pcb = udp_pcbs; + while (pcb != NULL) { + u32_t test_oid[LWIP_ARRAYSIZE(result_temp)]; + u8_t idx = 0; + + /* udpEndpointLocalAddressType + udpEndpointLocalAddress + udpEndpointLocalPort */ + idx += snmp_ip_port_to_oid(&pcb->local_ip, pcb->local_port, &test_oid[idx]); + + /* udpEndpointRemoteAddressType + udpEndpointRemoteAddress + udpEndpointRemotePort */ + idx += snmp_ip_port_to_oid(&pcb->remote_ip, pcb->remote_port, &test_oid[idx]); + + test_oid[idx] = 0; /* udpEndpointInstance */ + idx++; + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, idx, NULL); + + pcb = pcb->next; + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return udp_endpointTable_get_cell_value_core(column, value); + } else { + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; + } +} + +/* --- udpTable --- */ + +#if LWIP_IPV4 + +/* list of allowed value ranges for incoming OID */ +static const struct snmp_oid_range udp_Table_oid_ranges[] = { + { 0, 0xff }, /* IP A */ + { 0, 0xff }, /* IP B */ + { 0, 0xff }, /* IP C */ + { 0, 0xff }, /* IP D */ + { 1, 0xffff } /* Port */ +}; + +static snmp_err_t +udp_Table_get_cell_value_core(struct udp_pcb *pcb, const u32_t *column, union snmp_variant_value *value, u32_t *value_len) +{ + LWIP_UNUSED_ARG(value_len); + + switch (*column) { + case 1: /* udpLocalAddress */ + /* set reference to PCB local IP and return a generic node that copies IP4 addresses */ + value->u32 = ip_2_ip4(&pcb->local_ip)->addr; + break; + case 2: /* udpLocalPort */ + /* set reference to PCB local port and return a generic node that copies u16_t values */ + value->u32 = pcb->local_port; + break; + default: + return SNMP_ERR_NOSUCHINSTANCE; + } + + return SNMP_ERR_NOERROR; +} + +static snmp_err_t +udp_Table_get_cell_value(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, union snmp_variant_value *value, u32_t *value_len) +{ + ip4_addr_t ip; + u16_t port; + struct udp_pcb *pcb; + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(row_oid, row_oid_len, udp_Table_oid_ranges, LWIP_ARRAYSIZE(udp_Table_oid_ranges))) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* get IP and port from incoming OID */ + snmp_oid_to_ip4(&row_oid[0], &ip); /* we know it succeeds because of oid_in_range check above */ + port = (u16_t)row_oid[4]; + + /* find udp_pcb with requested ip and port*/ + pcb = udp_pcbs; + while (pcb != NULL) { + if (IP_IS_V4_VAL(pcb->local_ip)) { + if (ip4_addr_cmp(&ip, ip_2_ip4(&pcb->local_ip)) && (port == pcb->local_port)) { + /* fill in object properties */ + return udp_Table_get_cell_value_core(pcb, column, value, value_len); + } + } + pcb = pcb->next; + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static snmp_err_t +udp_Table_get_next_cell_instance_and_value(const u32_t *column, struct snmp_obj_id *row_oid, union snmp_variant_value *value, u32_t *value_len) +{ + struct udp_pcb *pcb; + struct snmp_next_oid_state state; + u32_t result_temp[LWIP_ARRAYSIZE(udp_Table_oid_ranges)]; + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(udp_Table_oid_ranges)); + + /* iterate over all possible OIDs to find the next one */ + pcb = udp_pcbs; + while (pcb != NULL) { + u32_t test_oid[LWIP_ARRAYSIZE(udp_Table_oid_ranges)]; + + if (IP_IS_V4_VAL(pcb->local_ip)) { + snmp_ip4_to_oid(ip_2_ip4(&pcb->local_ip), &test_oid[0]); + test_oid[4] = pcb->local_port; + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, LWIP_ARRAYSIZE(udp_Table_oid_ranges), pcb); + } + + pcb = pcb->next; + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* fill in object properties */ + return udp_Table_get_cell_value_core((struct udp_pcb *)state.reference, column, value, value_len); + } else { + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; + } +} + +#endif /* LWIP_IPV4 */ + +static const struct snmp_scalar_node udp_inDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(1, SNMP_ASN1_TYPE_COUNTER, udp_get_value); +static const struct snmp_scalar_node udp_noPorts = SNMP_SCALAR_CREATE_NODE_READONLY(2, SNMP_ASN1_TYPE_COUNTER, udp_get_value); +static const struct snmp_scalar_node udp_inErrors = SNMP_SCALAR_CREATE_NODE_READONLY(3, SNMP_ASN1_TYPE_COUNTER, udp_get_value); +static const struct snmp_scalar_node udp_outDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(4, SNMP_ASN1_TYPE_COUNTER, udp_get_value); +#if LWIP_HAVE_INT64 +static const struct snmp_scalar_node udp_HCInDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(8, SNMP_ASN1_TYPE_COUNTER64, udp_get_value); +static const struct snmp_scalar_node udp_HCOutDatagrams = SNMP_SCALAR_CREATE_NODE_READONLY(9, SNMP_ASN1_TYPE_COUNTER64, udp_get_value); +#endif + +#if LWIP_IPV4 +static const struct snmp_table_simple_col_def udp_Table_columns[] = { + { 1, SNMP_ASN1_TYPE_IPADDR, SNMP_VARIANT_VALUE_TYPE_U32 }, /* udpLocalAddress */ + { 2, SNMP_ASN1_TYPE_INTEGER, SNMP_VARIANT_VALUE_TYPE_U32 } /* udpLocalPort */ +}; +static const struct snmp_table_simple_node udp_Table = SNMP_TABLE_CREATE_SIMPLE(5, udp_Table_columns, udp_Table_get_cell_value, udp_Table_get_next_cell_instance_and_value); +#endif /* LWIP_IPV4 */ + +static const struct snmp_table_simple_col_def udp_endpointTable_columns[] = { + /* all items except udpEndpointProcess are declared as not-accessible */ + { 8, SNMP_ASN1_TYPE_UNSIGNED32, SNMP_VARIANT_VALUE_TYPE_U32 } /* udpEndpointProcess */ +}; + +static const struct snmp_table_simple_node udp_endpointTable = SNMP_TABLE_CREATE_SIMPLE(7, udp_endpointTable_columns, udp_endpointTable_get_cell_value, udp_endpointTable_get_next_cell_instance_and_value); + +/* the following nodes access variables in LWIP stack from SNMP worker thread and must therefore be synced to LWIP (TCPIP) thread */ +CREATE_LWIP_SYNC_NODE(1, udp_inDatagrams) +CREATE_LWIP_SYNC_NODE(2, udp_noPorts) +CREATE_LWIP_SYNC_NODE(3, udp_inErrors) +CREATE_LWIP_SYNC_NODE(4, udp_outDatagrams) +#if LWIP_IPV4 +CREATE_LWIP_SYNC_NODE(5, udp_Table) +#endif /* LWIP_IPV4 */ +CREATE_LWIP_SYNC_NODE(7, udp_endpointTable) +#if LWIP_HAVE_INT64 +CREATE_LWIP_SYNC_NODE(8, udp_HCInDatagrams) +CREATE_LWIP_SYNC_NODE(9, udp_HCOutDatagrams) +#endif + +static const struct snmp_node *const udp_nodes[] = { + &SYNC_NODE_NAME(udp_inDatagrams).node.node, + &SYNC_NODE_NAME(udp_noPorts).node.node, + &SYNC_NODE_NAME(udp_inErrors).node.node, + &SYNC_NODE_NAME(udp_outDatagrams).node.node, +#if LWIP_IPV4 + &SYNC_NODE_NAME(udp_Table).node.node, +#endif /* LWIP_IPV4 */ + &SYNC_NODE_NAME(udp_endpointTable).node.node +#if LWIP_HAVE_INT64 + , + &SYNC_NODE_NAME(udp_HCInDatagrams).node.node, + &SYNC_NODE_NAME(udp_HCOutDatagrams).node.node +#endif +}; + +const struct snmp_tree_node snmp_mib2_udp_root = SNMP_CREATE_TREE_NODE(7, udp_nodes); +#endif /* LWIP_SNMP && SNMP_LWIP_MIB2 && LWIP_UDP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.c index a2e9057f..0b6693a7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.c @@ -1,1951 +1,1951 @@ -/** - * @file - * SNMP message processing (RFC1157). - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * Copyright (c) 2016 Elias Oenal. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Christiaan Simons - * Martin Hentschel - * Elias Oenal - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "snmp_msg.h" -#include "snmp_asn1.h" -#include "snmp_core_priv.h" -#include "lwip/ip_addr.h" -#include "lwip/stats.h" - -#if LWIP_SNMP_V3 -#include "lwip/apps/snmpv3.h" -#include "snmpv3_priv.h" -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif -#endif - -#include - -#define SNMP_V3_AUTH_FLAG 0x01 -#define SNMP_V3_PRIV_FLAG 0x02 - -/* Security levels */ -#define SNMP_V3_NOAUTHNOPRIV 0x00 -#define SNMP_V3_AUTHNOPRIV SNMP_V3_AUTH_FLAG -#define SNMP_V3_AUTHPRIV (SNMP_V3_AUTH_FLAG | SNMP_V3_PRIV_FLAG) - -/* public (non-static) constants */ -/** SNMP community string */ -const char *snmp_community = SNMP_COMMUNITY; -/** SNMP community string for write access */ -const char *snmp_community_write = SNMP_COMMUNITY_WRITE; -/** SNMP community string for sending traps */ -const char *snmp_community_trap = SNMP_COMMUNITY_TRAP; - -snmp_write_callback_fct snmp_write_callback = NULL; -void *snmp_write_callback_arg = NULL; - -#if LWIP_SNMP_CONFIGURE_VERSIONS - -static u8_t v1_enabled = 1; -static u8_t v2c_enabled = 1; -static u8_t v3_enabled = 1; - -static u8_t -snmp_version_enabled(u8_t version) -{ - if (version == SNMP_VERSION_1) { - return v1_enabled; - } else if (version == SNMP_VERSION_2c) { - return v2c_enabled; - } -#if LWIP_SNMP_V3 - else if (version == SNMP_VERSION_3) { - return v3_enabled; - } -#endif - else { - LWIP_ASSERT("Invalid SNMP version", 0); - return 0; - } -} - -u8_t -snmp_v1_enabled(void) -{ - return snmp_version_enabled(SNMP_VERSION_1); -} - -u8_t -snmp_v2c_enabled(void) -{ - return snmp_version_enabled(SNMP_VERSION_2c); -} - -u8_t -snmp_v3_enabled(void) -{ - return snmp_version_enabled(SNMP_VERSION_3); -} - -static void -snmp_version_enable(u8_t version, u8_t enable) -{ - if (version == SNMP_VERSION_1) { - v1_enabled = enable; - } else if (version == SNMP_VERSION_2c) { - v2c_enabled = enable; - } -#if LWIP_SNMP_V3 - else if (version == SNMP_VERSION_3) { - v3_enabled = enable; - } -#endif - else { - LWIP_ASSERT("Invalid SNMP version", 0); - } -} - -void -snmp_v1_enable(u8_t enable) -{ - snmp_version_enable(SNMP_VERSION_1, enable); -} - -void -snmp_v2c_enable(u8_t enable) -{ - snmp_version_enable(SNMP_VERSION_2c, enable); -} - -void -snmp_v3_enable(u8_t enable) -{ - snmp_version_enable(SNMP_VERSION_3, enable); -} - -#endif - -/** - * @ingroup snmp_core - * Returns current SNMP community string. - * @return current SNMP community string - */ -const char * -snmp_get_community(void) -{ - return snmp_community; -} - -/** - * @ingroup snmp_core - * Sets SNMP community string. - * The string itself (its storage) must be valid throughout the whole life of - * program (or until it is changed to sth else). - * - * @param community is a pointer to new community string - */ -void -snmp_set_community(const char *const community) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("community string is too long!", strlen(community) <= SNMP_MAX_COMMUNITY_STR_LEN); - snmp_community = community; -} - -/** - * @ingroup snmp_core - * Returns current SNMP write-access community string. - * @return current SNMP write-access community string - */ -const char * -snmp_get_community_write(void) -{ - return snmp_community_write; -} - -/** - * @ingroup snmp_traps - * Returns current SNMP community string used for sending traps. - * @return current SNMP community string used for sending traps - */ -const char * -snmp_get_community_trap(void) -{ - return snmp_community_trap; -} - -/** - * @ingroup snmp_core - * Sets SNMP community string for write-access. - * The string itself (its storage) must be valid throughout the whole life of - * program (or until it is changed to sth else). - * - * @param community is a pointer to new write-access community string - */ -void -snmp_set_community_write(const char *const community) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("community string must not be NULL", community != NULL); - LWIP_ASSERT("community string is too long!", strlen(community) <= SNMP_MAX_COMMUNITY_STR_LEN); - snmp_community_write = community; -} - -/** - * @ingroup snmp_traps - * Sets SNMP community string used for sending traps. - * The string itself (its storage) must be valid throughout the whole life of - * program (or until it is changed to sth else). - * - * @param community is a pointer to new trap community string - */ -void -snmp_set_community_trap(const char *const community) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("community string is too long!", strlen(community) <= SNMP_MAX_COMMUNITY_STR_LEN); - snmp_community_trap = community; -} - -/** - * @ingroup snmp_core - * Callback fired on every successful write access - */ -void -snmp_set_write_callback(snmp_write_callback_fct write_callback, void *callback_arg) -{ - LWIP_ASSERT_CORE_LOCKED(); - snmp_write_callback = write_callback; - snmp_write_callback_arg = callback_arg; -} - -/* ----------------------------------------------------------------------- */ -/* forward declarations */ -/* ----------------------------------------------------------------------- */ - -static err_t snmp_process_get_request(struct snmp_request *request); -static err_t snmp_process_getnext_request(struct snmp_request *request); -static err_t snmp_process_getbulk_request(struct snmp_request *request); -static err_t snmp_process_set_request(struct snmp_request *request); - -static err_t snmp_parse_inbound_frame(struct snmp_request *request); -static err_t snmp_prepare_outbound_frame(struct snmp_request *request); -static err_t snmp_complete_outbound_frame(struct snmp_request *request); -static void snmp_execute_write_callbacks(struct snmp_request *request); - - -/* ----------------------------------------------------------------------- */ -/* implementation */ -/* ----------------------------------------------------------------------- */ - -void -snmp_receive(void *handle, struct pbuf *p, const ip_addr_t *source_ip, u16_t port) -{ - err_t err; - struct snmp_request request; - - memset(&request, 0, sizeof(request)); - request.handle = handle; - request.source_ip = source_ip; - request.source_port = port; - request.inbound_pbuf = p; - - snmp_stats.inpkts++; - - err = snmp_parse_inbound_frame(&request); - if (err == ERR_OK) { - err = snmp_prepare_outbound_frame(&request); - if (err == ERR_OK) { - - if (request.error_status == SNMP_ERR_NOERROR) { - /* only process frame if we do not already have an error to return (e.g. all readonly) */ - if (request.request_type == SNMP_ASN1_CONTEXT_PDU_GET_REQ) { - err = snmp_process_get_request(&request); - } else if (request.request_type == SNMP_ASN1_CONTEXT_PDU_GET_NEXT_REQ) { - err = snmp_process_getnext_request(&request); - } else if (request.request_type == SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ) { - err = snmp_process_getbulk_request(&request); - } else if (request.request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { - err = snmp_process_set_request(&request); - } - } -#if LWIP_SNMP_V3 - else { - struct snmp_varbind vb; - - vb.next = NULL; - vb.prev = NULL; - vb.type = SNMP_ASN1_TYPE_COUNTER32; - vb.value_len = sizeof(u32_t); - - switch (request.error_status) { - case SNMP_ERR_AUTHORIZATIONERROR: { - static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 5, 0 }; - snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); - vb.value = &snmp_stats.wrongdigests; - } - break; - case SNMP_ERR_UNKNOWN_ENGINEID: { - static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 4, 0 }; - snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); - vb.value = &snmp_stats.unknownengineids; - } - break; - case SNMP_ERR_UNKNOWN_SECURITYNAME: { - static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 3, 0 }; - snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); - vb.value = &snmp_stats.unknownusernames; - } - break; - case SNMP_ERR_UNSUPPORTED_SECLEVEL: { - static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 1, 0 }; - snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); - vb.value = &snmp_stats.unsupportedseclevels; - } - break; - case SNMP_ERR_NOTINTIMEWINDOW: { - static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 2, 0 }; - snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); - vb.value = &snmp_stats.notintimewindows; - } - break; - case SNMP_ERR_DECRYIPTION_ERROR: { - static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 6, 0 }; - snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); - vb.value = &snmp_stats.decryptionerrors; - } - break; - default: - /* Unknown or unhandled error_status */ - err = ERR_ARG; - } - - if (err == ERR_OK) { - snmp_append_outbound_varbind(&(request.outbound_pbuf_stream), &vb); - request.error_status = SNMP_ERR_NOERROR; - } - - request.request_out_type = (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_REPORT); - request.request_id = request.msg_id; - } -#endif - - if (err == ERR_OK) { - err = snmp_complete_outbound_frame(&request); - - if (err == ERR_OK) { - err = snmp_sendto(request.handle, request.outbound_pbuf, request.source_ip, request.source_port); - - if ((request.request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) - && (request.error_status == SNMP_ERR_NOERROR) - && (snmp_write_callback != NULL)) { - /* raise write notification for all written objects */ - snmp_execute_write_callbacks(&request); - } - } - } - } - - if (request.outbound_pbuf != NULL) { - pbuf_free(request.outbound_pbuf); - } - } -} - -static u8_t -snmp_msg_getnext_validate_node_inst(struct snmp_node_instance *node_instance, void *validate_arg) -{ - if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_READ) != SNMP_NODE_INSTANCE_ACCESS_READ) || (node_instance->get_value == NULL)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - -#if LWIP_HAVE_INT64 - if ((node_instance->asn1_type == SNMP_ASN1_TYPE_COUNTER64) && (((struct snmp_request *)validate_arg)->version == SNMP_VERSION_1)) { - /* according to RFC 2089 skip Counter64 objects in GetNext requests from v1 clients */ - return SNMP_ERR_NOSUCHINSTANCE; - } -#endif - - return SNMP_ERR_NOERROR; -} - -static void -snmp_process_varbind(struct snmp_request *request, struct snmp_varbind *vb, u8_t get_next) -{ - err_t err; - struct snmp_node_instance node_instance; - memset(&node_instance, 0, sizeof(node_instance)); - - if (get_next) { - struct snmp_obj_id result_oid; - request->error_status = snmp_get_next_node_instance_from_oid(vb->oid.id, vb->oid.len, snmp_msg_getnext_validate_node_inst, request, &result_oid, &node_instance); - - if (request->error_status == SNMP_ERR_NOERROR) { - snmp_oid_assign(&vb->oid, result_oid.id, result_oid.len); - } - } else { - request->error_status = snmp_get_node_instance_from_oid(vb->oid.id, vb->oid.len, &node_instance); - - if (request->error_status == SNMP_ERR_NOERROR) { - /* use 'getnext_validate' method for validation to avoid code duplication (some checks have to be executed here) */ - request->error_status = snmp_msg_getnext_validate_node_inst(&node_instance, request); - - if (request->error_status != SNMP_ERR_NOERROR) { - if (node_instance.release_instance != NULL) { - node_instance.release_instance(&node_instance); - } - } - } - } - - if (request->error_status != SNMP_ERR_NOERROR) { - if (request->error_status >= SNMP_VARBIND_EXCEPTION_OFFSET) { - if ((request->version == SNMP_VERSION_2c) || request->version == SNMP_VERSION_3) { - /* in SNMP v2c a varbind related exception is stored in varbind and not in frame header */ - vb->type = (SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_CLASS_CONTEXT | (request->error_status & SNMP_VARBIND_EXCEPTION_MASK)); - vb->value_len = 0; - - err = snmp_append_outbound_varbind(&(request->outbound_pbuf_stream), vb); - if (err == ERR_OK) { - /* we stored the exception in varbind -> go on */ - request->error_status = SNMP_ERR_NOERROR; - } else if (err == ERR_BUF) { - request->error_status = SNMP_ERR_TOOBIG; - } else { - request->error_status = SNMP_ERR_GENERROR; - } - } - } else { - /* according to RFC 1157/1905, all other errors only return genError */ - request->error_status = SNMP_ERR_GENERROR; - } - } else { - s16_t len = node_instance.get_value(&node_instance, vb->value); - - if (len >= 0) { - vb->value_len = (u16_t)len; /* cast is OK because we checked >= 0 above */ - vb->type = node_instance.asn1_type; - - LWIP_ASSERT("SNMP_MAX_VALUE_SIZE is configured too low", (vb->value_len & ~SNMP_GET_VALUE_RAW_DATA) <= SNMP_MAX_VALUE_SIZE); - err = snmp_append_outbound_varbind(&request->outbound_pbuf_stream, vb); - - if (err == ERR_BUF) { - request->error_status = SNMP_ERR_TOOBIG; - } else if (err != ERR_OK) { - request->error_status = SNMP_ERR_GENERROR; - } - } else { - request->error_status = SNMP_ERR_GENERROR; - } - - if (node_instance.release_instance != NULL) { - node_instance.release_instance(&node_instance); - } - } -} - - -/** - * Service an internal or external event for SNMP GET. - * - * @param request points to the associated message process state - */ -static err_t -snmp_process_get_request(struct snmp_request *request) -{ - snmp_vb_enumerator_err_t err; - struct snmp_varbind vb; - vb.value = request->value_buffer; - - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP get request\n")); - - while (request->error_status == SNMP_ERR_NOERROR) { - err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); - if (err == SNMP_VB_ENUMERATOR_ERR_OK) { - if ((vb.type == SNMP_ASN1_TYPE_NULL) && (vb.value_len == 0)) { - snmp_process_varbind(request, &vb, 0); - } else { - request->error_status = SNMP_ERR_GENERROR; - } - } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { - /* no more varbinds in request */ - break; - } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { - /* malformed ASN.1, don't answer */ - return ERR_ARG; - } else { - request->error_status = SNMP_ERR_GENERROR; - } - } - - return ERR_OK; -} - -/** - * Service an internal or external event for SNMP GET. - * - * @param request points to the associated message process state - */ -static err_t -snmp_process_getnext_request(struct snmp_request *request) -{ - snmp_vb_enumerator_err_t err; - struct snmp_varbind vb; - vb.value = request->value_buffer; - - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP get-next request\n")); - - while (request->error_status == SNMP_ERR_NOERROR) { - err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); - if (err == SNMP_VB_ENUMERATOR_ERR_OK) { - if ((vb.type == SNMP_ASN1_TYPE_NULL) && (vb.value_len == 0)) { - snmp_process_varbind(request, &vb, 1); - } else { - request->error_status = SNMP_ERR_GENERROR; - } - } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { - /* no more varbinds in request */ - break; - } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { - /* malformed ASN.1, don't answer */ - return ERR_ARG; - } else { - request->error_status = SNMP_ERR_GENERROR; - } - } - - return ERR_OK; -} - -/** - * Service an internal or external event for SNMP GETBULKT. - * - * @param request points to the associated message process state - */ -static err_t -snmp_process_getbulk_request(struct snmp_request *request) -{ - snmp_vb_enumerator_err_t err; - s32_t non_repeaters = request->non_repeaters; - s32_t repetitions; - u16_t repetition_offset = 0; - struct snmp_varbind_enumerator repetition_varbind_enumerator; - struct snmp_varbind vb; - vb.value = request->value_buffer; - - if (SNMP_LWIP_GETBULK_MAX_REPETITIONS > 0) { - repetitions = LWIP_MIN(request->max_repetitions, SNMP_LWIP_GETBULK_MAX_REPETITIONS); - } else { - repetitions = request->max_repetitions; - } - - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP get-bulk request\n")); - - /* process non repeaters and first repetition */ - while (request->error_status == SNMP_ERR_NOERROR) { - if (non_repeaters == 0) { - repetition_offset = request->outbound_pbuf_stream.offset; - - if (repetitions == 0) { - /* do not resolve repeaters when repetitions is set to 0 */ - break; - } - repetitions--; - } - - err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); - if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { - /* no more varbinds in request */ - break; - } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { - /* malformed ASN.1, don't answer */ - return ERR_ARG; - } else if ((err != SNMP_VB_ENUMERATOR_ERR_OK) || (vb.type != SNMP_ASN1_TYPE_NULL) || (vb.value_len != 0)) { - request->error_status = SNMP_ERR_GENERROR; - } else { - snmp_process_varbind(request, &vb, 1); - non_repeaters--; - } - } - - /* process repetitions > 1 */ - while ((request->error_status == SNMP_ERR_NOERROR) && (repetitions > 0) && (request->outbound_pbuf_stream.offset != repetition_offset)) { - - u8_t all_endofmibview = 1; - - snmp_vb_enumerator_init(&repetition_varbind_enumerator, request->outbound_pbuf, repetition_offset, request->outbound_pbuf_stream.offset - repetition_offset); - repetition_offset = request->outbound_pbuf_stream.offset; /* for next loop */ - - while (request->error_status == SNMP_ERR_NOERROR) { - vb.value = NULL; /* do NOT decode value (we enumerate outbound buffer here, so all varbinds have values assigned) */ - err = snmp_vb_enumerator_get_next(&repetition_varbind_enumerator, &vb); - if (err == SNMP_VB_ENUMERATOR_ERR_OK) { - vb.value = request->value_buffer; - snmp_process_varbind(request, &vb, 1); - - if (request->error_status != SNMP_ERR_NOERROR) { - /* already set correct error-index (here it cannot be taken from inbound varbind enumerator) */ - request->error_index = request->non_repeaters + repetition_varbind_enumerator.varbind_count; - } else if (vb.type != (SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTEXT_VARBIND_END_OF_MIB_VIEW)) { - all_endofmibview = 0; - } - } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { - /* no more varbinds in request */ - break; - } else { - LWIP_DEBUGF(SNMP_DEBUG, ("Very strange, we cannot parse the varbind output that we created just before!")); - request->error_status = SNMP_ERR_GENERROR; - request->error_index = request->non_repeaters + repetition_varbind_enumerator.varbind_count; - } - } - - if ((request->error_status == SNMP_ERR_NOERROR) && all_endofmibview) { - /* stop when all varbinds in a loop return EndOfMibView */ - break; - } - - repetitions--; - } - - if (request->error_status == SNMP_ERR_TOOBIG) { - /* for GetBulk it is ok, if not all requested variables fit into the response -> just return the varbinds added so far */ - request->error_status = SNMP_ERR_NOERROR; - } - - return ERR_OK; -} - -/** - * Service an internal or external event for SNMP SET. - * - * @param request points to the associated message process state - */ -static err_t -snmp_process_set_request(struct snmp_request *request) -{ - snmp_vb_enumerator_err_t err; - struct snmp_varbind vb; - vb.value = request->value_buffer; - - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP set request\n")); - - /* perform set test on all objects */ - while (request->error_status == SNMP_ERR_NOERROR) { - err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); - if (err == SNMP_VB_ENUMERATOR_ERR_OK) { - struct snmp_node_instance node_instance; - memset(&node_instance, 0, sizeof(node_instance)); - - request->error_status = snmp_get_node_instance_from_oid(vb.oid.id, vb.oid.len, &node_instance); - if (request->error_status == SNMP_ERR_NOERROR) { - if (node_instance.asn1_type != vb.type) { - request->error_status = SNMP_ERR_WRONGTYPE; - } else if (((node_instance.access & SNMP_NODE_INSTANCE_ACCESS_WRITE) != SNMP_NODE_INSTANCE_ACCESS_WRITE) || (node_instance.set_value == NULL)) { - request->error_status = SNMP_ERR_NOTWRITABLE; - } else { - if (node_instance.set_test != NULL) { - request->error_status = node_instance.set_test(&node_instance, vb.value_len, vb.value); - } - } - - if (node_instance.release_instance != NULL) { - node_instance.release_instance(&node_instance); - } - } - } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { - /* no more varbinds in request */ - break; - } else if (err == SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH) { - request->error_status = SNMP_ERR_WRONGLENGTH; - } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { - /* malformed ASN.1, don't answer */ - return ERR_ARG; - } else { - request->error_status = SNMP_ERR_GENERROR; - } - } - - /* perform real set operation on all objects */ - if (request->error_status == SNMP_ERR_NOERROR) { - snmp_vb_enumerator_init(&request->inbound_varbind_enumerator, request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len); - while (request->error_status == SNMP_ERR_NOERROR) { - err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); - if (err == SNMP_VB_ENUMERATOR_ERR_OK) { - struct snmp_node_instance node_instance; - memset(&node_instance, 0, sizeof(node_instance)); - request->error_status = snmp_get_node_instance_from_oid(vb.oid.id, vb.oid.len, &node_instance); - if (request->error_status == SNMP_ERR_NOERROR) { - if (node_instance.set_value(&node_instance, vb.value_len, vb.value) != SNMP_ERR_NOERROR) { - if (request->inbound_varbind_enumerator.varbind_count == 1) { - request->error_status = SNMP_ERR_COMMITFAILED; - } else { - /* we cannot undo the set operations done so far */ - request->error_status = SNMP_ERR_UNDOFAILED; - } - } - - if (node_instance.release_instance != NULL) { - node_instance.release_instance(&node_instance); - } - } - } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { - /* no more varbinds in request */ - break; - } else { - /* first time enumerating varbinds work but second time not, although nothing should have changed in between ??? */ - request->error_status = SNMP_ERR_GENERROR; - } - } - } - - return ERR_OK; -} - -#define PARSE_EXEC(code, retValue) \ - if ((code) != ERR_OK) { \ - LWIP_DEBUGF(SNMP_DEBUG, ("Malformed ASN.1 detected.\n")); \ - snmp_stats.inasnparseerrs++; \ - return retValue; \ - } - -#define PARSE_ASSERT(cond, retValue) \ - if (!(cond)) { \ - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP parse assertion failed!: " # cond)); \ - snmp_stats.inasnparseerrs++; \ - return retValue; \ - } - -#define BUILD_EXEC(code, retValue) \ - if ((code) != ERR_OK) { \ - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP error during creation of outbound frame!: " # code)); \ - return retValue; \ - } - -#define IF_PARSE_EXEC(code) PARSE_EXEC(code, ERR_ARG) -#define IF_PARSE_ASSERT(code) PARSE_ASSERT(code, ERR_ARG) - -/** - * Checks and decodes incoming SNMP message header, logs header errors. - * - * @param request points to the current message request state return - * @return - * - ERR_OK SNMP header is sane and accepted - * - ERR_VAL SNMP header is either malformed or rejected - */ -static err_t -snmp_parse_inbound_frame(struct snmp_request *request) -{ - struct snmp_pbuf_stream pbuf_stream; - struct snmp_asn1_tlv tlv; - s32_t parent_tlv_value_len; - s32_t s32_value; - err_t err; -#if LWIP_SNMP_V3 - snmpv3_auth_algo_t auth; - snmpv3_priv_algo_t priv; -#endif - - IF_PARSE_EXEC(snmp_pbuf_stream_init(&pbuf_stream, request->inbound_pbuf, 0, request->inbound_pbuf->tot_len)); - - /* decode main container consisting of version, community and PDU */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_SEQUENCE) && (tlv.value_len == pbuf_stream.length)); - parent_tlv_value_len = tlv.value_len; - - /* decode version */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); - - if (((s32_value != SNMP_VERSION_1) && - (s32_value != SNMP_VERSION_2c) -#if LWIP_SNMP_V3 - && (s32_value != SNMP_VERSION_3) -#endif - ) -#if LWIP_SNMP_CONFIGURE_VERSIONS - || (!snmp_version_enabled(s32_value)) -#endif - ) { - /* unsupported SNMP version */ - snmp_stats.inbadversions++; - return ERR_ARG; - } - request->version = (u8_t)s32_value; - -#if LWIP_SNMP_V3 - if (request->version == SNMP_VERSION_3) { - u16_t u16_value; - u16_t inbound_msgAuthenticationParameters_offset; - - /* SNMPv3 doesn't use communities */ - /* @todo: Differentiate read/write access */ - strncpy((char *)request->community, snmp_community, SNMP_MAX_COMMUNITY_STR_LEN); - request->community[SNMP_MAX_COMMUNITY_STR_LEN] = 0; /* ensure NULL termination (strncpy does NOT guarantee it!) */ - request->community_strlen = (u16_t)strnlen((char *)request->community, SNMP_MAX_COMMUNITY_STR_LEN); - - /* RFC3414 globalData */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_SEQUENCE); - parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - /* decode msgID */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); - request->msg_id = s32_value; - - /* decode msgMaxSize */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); - request->msg_max_size = s32_value; - - /* decode msgFlags */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); - request->msg_flags = (u8_t)s32_value; - - /* decode msgSecurityModel */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); - request->msg_security_model = s32_value; - - /* RFC3414 msgSecurityParameters - * The User-based Security Model defines the contents of the OCTET - * STRING as a SEQUENCE. - * - * We skip the protective dummy OCTET STRING header - * to access the SEQUENCE header. - */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - /* msgSecurityParameters SEQUENCE header */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_SEQUENCE); - parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - /* decode msgAuthoritativeEngineID */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_authoritative_engine_id, - &u16_value, SNMP_V3_MAX_ENGINE_ID_LENGTH)); - request->msg_authoritative_engine_id_len = (u8_t)u16_value; - - /* msgAuthoritativeEngineBoots */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->msg_authoritative_engine_boots)); - - /* msgAuthoritativeEngineTime */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->msg_authoritative_engine_time)); - - /* msgUserName */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_user_name, - &u16_value, SNMP_V3_MAX_USER_LENGTH)); - request->msg_user_name_len = (u8_t)u16_value; - - /* msgAuthenticationParameters */ - memset(request->msg_authentication_parameters, 0, SNMP_V3_MAX_AUTH_PARAM_LENGTH); - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - /* Remember position */ - inbound_msgAuthenticationParameters_offset = pbuf_stream.offset; - LWIP_UNUSED_ARG(inbound_msgAuthenticationParameters_offset); - /* Read auth parameters */ - /* IF_PARSE_ASSERT(tlv.value_len <= SNMP_V3_MAX_AUTH_PARAM_LENGTH); */ - IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_authentication_parameters, - &u16_value, tlv.value_len)); - request->msg_authentication_parameters_len = (u8_t)u16_value; - - /* msgPrivacyParameters */ - memset(request->msg_privacy_parameters, 0, SNMP_V3_MAX_PRIV_PARAM_LENGTH); - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_privacy_parameters, - &u16_value, SNMP_V3_MAX_PRIV_PARAM_LENGTH)); - request->msg_privacy_parameters_len = (u8_t)u16_value; - - /* validate securityParameters here (do this after decoding because we don't want to increase other counters for wrong frames) - * 1) securityParameters was correctly serialized if we reach here. - * 2) securityParameters are already cached. - * 3) if msgAuthoritativeEngineID is unknown, zero-length or too long: - b) https://tools.ietf.org/html/rfc3414#section-7 - */ - { - const char *eid; - u8_t eid_len; - - snmpv3_get_engine_id(&eid, &eid_len); - - if ((request->msg_authoritative_engine_id_len == 0) || - (request->msg_authoritative_engine_id_len != eid_len) || - (memcmp(eid, request->msg_authoritative_engine_id, eid_len) != 0)) { - snmp_stats.unknownengineids++; - request->msg_flags = 0; /* noauthnopriv */ - request->error_status = SNMP_ERR_UNKNOWN_ENGINEID; - return ERR_OK; - } - } - - /* 4) verify username */ - if (snmpv3_get_user((char *)request->msg_user_name, &auth, NULL, &priv, NULL)) { - snmp_stats.unknownusernames++; - request->msg_flags = 0; /* noauthnopriv */ - request->error_status = SNMP_ERR_UNKNOWN_SECURITYNAME; - return ERR_OK; - } - - /* 5) verify security level */ - switch (request->msg_flags & (SNMP_V3_AUTH_FLAG | SNMP_V3_PRIV_FLAG)) { - case SNMP_V3_NOAUTHNOPRIV: - if ((auth != SNMP_V3_AUTH_ALGO_INVAL) || (priv != SNMP_V3_PRIV_ALGO_INVAL)) { - /* Invalid security level for user */ - snmp_stats.unsupportedseclevels++; - request->msg_flags = SNMP_V3_NOAUTHNOPRIV; - request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; - return ERR_OK; - } - break; -#if LWIP_SNMP_V3_CRYPTO - case SNMP_V3_AUTHNOPRIV: - if ((auth == SNMP_V3_AUTH_ALGO_INVAL) || (priv != SNMP_V3_PRIV_ALGO_INVAL)) { - /* Invalid security level for user */ - snmp_stats.unsupportedseclevels++; - request->msg_flags = SNMP_V3_NOAUTHNOPRIV; - request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; - return ERR_OK; - } - break; - case SNMP_V3_AUTHPRIV: - if ((auth == SNMP_V3_AUTH_ALGO_INVAL) || (priv == SNMP_V3_PRIV_ALGO_INVAL)) { - /* Invalid security level for user */ - snmp_stats.unsupportedseclevels++; - request->msg_flags = SNMP_V3_NOAUTHNOPRIV; - request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; - return ERR_OK; - } - break; -#endif - default: - snmp_stats.unsupportedseclevels++; - request->msg_flags = SNMP_V3_NOAUTHNOPRIV; - request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; - return ERR_OK; - } - - /* 6) if securitylevel specifies authentication, authenticate message. */ -#if LWIP_SNMP_V3_CRYPTO - if (request->msg_flags & SNMP_V3_AUTH_FLAG) { - const u8_t zero_arr[SNMP_V3_MAX_AUTH_PARAM_LENGTH] = { 0 }; - u8_t key[20]; - u8_t hmac[LWIP_MAX(SNMP_V3_SHA_LEN, SNMP_V3_MD5_LEN)]; - struct snmp_pbuf_stream auth_stream; - - if (request->msg_authentication_parameters_len > SNMP_V3_MAX_AUTH_PARAM_LENGTH) { - snmp_stats.wrongdigests++; - request->msg_flags = SNMP_V3_NOAUTHNOPRIV; - request->error_status = SNMP_ERR_AUTHORIZATIONERROR; - return ERR_OK; - } - - /* Rewind stream */ - IF_PARSE_EXEC(snmp_pbuf_stream_init(&auth_stream, request->inbound_pbuf, 0, request->inbound_pbuf->tot_len)); - IF_PARSE_EXEC(snmp_pbuf_stream_seek_abs(&auth_stream, inbound_msgAuthenticationParameters_offset)); - /* Set auth parameters to zero for verification */ - IF_PARSE_EXEC(snmp_asn1_enc_raw(&auth_stream, zero_arr, request->msg_authentication_parameters_len)); - - /* Verify authentication */ - IF_PARSE_EXEC(snmp_pbuf_stream_init(&auth_stream, request->inbound_pbuf, 0, request->inbound_pbuf->tot_len)); - - IF_PARSE_EXEC(snmpv3_get_user((char *)request->msg_user_name, &auth, key, NULL, NULL)); - IF_PARSE_EXEC(snmpv3_auth(&auth_stream, request->inbound_pbuf->tot_len, key, auth, hmac)); - - if (memcmp(request->msg_authentication_parameters, hmac, SNMP_V3_MAX_AUTH_PARAM_LENGTH)) { - snmp_stats.wrongdigests++; - request->msg_flags = SNMP_V3_NOAUTHNOPRIV; - request->error_status = SNMP_ERR_AUTHORIZATIONERROR; - return ERR_OK; - } - - /* 7) if securitylevel specifies authentication, verify engineboots, enginetime and lastenginetime */ - { - s32_t boots = snmpv3_get_engine_boots_internal(); - if ((request->msg_authoritative_engine_boots != boots) || (boots == 2147483647UL)) { - snmp_stats.notintimewindows++; - request->msg_flags = SNMP_V3_AUTHNOPRIV; - request->error_status = SNMP_ERR_NOTINTIMEWINDOW; - return ERR_OK; - } - } - { - s32_t time = snmpv3_get_engine_time_internal(); - if (request->msg_authoritative_engine_time > (time + 150)) { - snmp_stats.notintimewindows++; - request->msg_flags = SNMP_V3_AUTHNOPRIV; - request->error_status = SNMP_ERR_NOTINTIMEWINDOW; - return ERR_OK; - } else if (time > 150) { - if (request->msg_authoritative_engine_time < (time - 150)) { - snmp_stats.notintimewindows++; - request->msg_flags = SNMP_V3_AUTHNOPRIV; - request->error_status = SNMP_ERR_NOTINTIMEWINDOW; - return ERR_OK; - } - } - } - } -#endif - - /* 8) if securitylevel specifies privacy, decrypt message. */ -#if LWIP_SNMP_V3_CRYPTO - if (request->msg_flags & SNMP_V3_PRIV_FLAG) { - /* Decrypt message */ - - u8_t key[20]; - - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmpv3_get_user((char *)request->msg_user_name, NULL, NULL, &priv, key)); - if (snmpv3_crypt(&pbuf_stream, tlv.value_len, key, - request->msg_privacy_parameters, request->msg_authoritative_engine_boots, - request->msg_authoritative_engine_time, priv, SNMP_V3_PRIV_MODE_DECRYPT) != ERR_OK) { - snmp_stats.decryptionerrors++; - request->msg_flags = SNMP_V3_AUTHNOPRIV; - request->error_status = SNMP_ERR_DECRYIPTION_ERROR; - return ERR_OK; - } - } -#endif - /* 9) calculate max size of scoped pdu? - * 10) securityname for user is retrieved from usertable? - * 11) security data is cached? - * 12) - */ - - /* Scoped PDU - * Encryption context - */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_SEQUENCE); - parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - /* contextEngineID */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->context_engine_id, - &u16_value, SNMP_V3_MAX_ENGINE_ID_LENGTH)); - request->context_engine_id_len = (u8_t)u16_value; - /* TODO: do we need to verify this contextengineid too? */ - - /* contextName */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->context_name, - &u16_value, SNMP_V3_MAX_ENGINE_ID_LENGTH)); - request->context_name_len = (u8_t)u16_value; - /* TODO: do we need to verify this contextname too? */ - } else -#endif - { - /* decode community */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - err = snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->community, &request->community_strlen, SNMP_MAX_COMMUNITY_STR_LEN); - if (err == ERR_MEM) { - /* community string does not fit in our buffer -> its too long -> its invalid */ - request->community_strlen = 0; - snmp_pbuf_stream_seek(&pbuf_stream, tlv.value_len); - } else { - IF_PARSE_ASSERT(err == ERR_OK); - } - /* add zero terminator */ - request->community[request->community_strlen] = 0; - } - - /* decode PDU type (next container level) */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.value_len <= pbuf_stream.length); - request->inbound_padding_len = pbuf_stream.length - tlv.value_len; - parent_tlv_value_len = tlv.value_len; - - /* validate PDU type */ - switch (tlv.type) { - case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_REQ): - /* GetRequest PDU */ - snmp_stats.ingetrequests++; - break; - case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_NEXT_REQ): - /* GetNextRequest PDU */ - snmp_stats.ingetnexts++; - break; - case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ): - /* GetBulkRequest PDU */ - if (request->version < SNMP_VERSION_2c) { - /* RFC2089: invalid, drop packet */ - return ERR_ARG; - } - break; - case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_SET_REQ): - /* SetRequest PDU */ - snmp_stats.insetrequests++; - break; - default: - /* unsupported input PDU for this agent (no parse error) */ - LWIP_DEBUGF(SNMP_DEBUG, ("Unknown/Invalid SNMP PDU type received: %d", tlv.type)); \ - return ERR_ARG; - } - request->request_type = tlv.type & SNMP_ASN1_DATATYPE_MASK; - request->request_out_type = (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_RESP); - - /* validate community (do this after decoding PDU type because we don't want to increase 'inbadcommunitynames' for wrong frame types */ - if (request->community_strlen == 0) { - /* community string was too long or really empty*/ - snmp_stats.inbadcommunitynames++; - snmp_authfail_trap(); - return ERR_ARG; - } else if (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { - if (snmp_community_write[0] == 0) { - /* our write community is empty, that means all our objects are readonly */ - request->error_status = SNMP_ERR_NOTWRITABLE; - request->error_index = 1; - } else if (strncmp(snmp_community_write, (const char *)request->community, SNMP_MAX_COMMUNITY_STR_LEN) != 0) { - /* community name does not match */ - snmp_stats.inbadcommunitynames++; - snmp_authfail_trap(); - return ERR_ARG; - } - } else { - if (strncmp(snmp_community, (const char *)request->community, SNMP_MAX_COMMUNITY_STR_LEN) != 0) { - /* community name does not match */ - snmp_stats.inbadcommunitynames++; - snmp_authfail_trap(); - return ERR_ARG; - } - } - - /* decode request ID */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->request_id)); - - /* decode error status / non-repeaters */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - if (request->request_type == SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ) { - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->non_repeaters)); - if (request->non_repeaters < 0) { - /* RFC 1905, 4.2.3 */ - request->non_repeaters = 0; - } - } else { - /* only check valid value, don't touch 'request->error_status', maybe a response error status was already set to above; */ - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); - IF_PARSE_ASSERT(s32_value == SNMP_ERR_NOERROR); - } - - /* decode error index / max-repetitions */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); - parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); - IF_PARSE_ASSERT(parent_tlv_value_len > 0); - - if (request->request_type == SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ) { - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->max_repetitions)); - if (request->max_repetitions < 0) { - /* RFC 1905, 4.2.3 */ - request->max_repetitions = 0; - } - } else { - IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->error_index)); - IF_PARSE_ASSERT(s32_value == 0); - } - - /* decode varbind-list type (next container level) */ - IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); - IF_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_SEQUENCE) && (tlv.value_len <= pbuf_stream.length)); - - request->inbound_varbind_offset = pbuf_stream.offset; - request->inbound_varbind_len = pbuf_stream.length - request->inbound_padding_len; - snmp_vb_enumerator_init(&(request->inbound_varbind_enumerator), request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len); - - return ERR_OK; -} - -#define OF_BUILD_EXEC(code) BUILD_EXEC(code, ERR_ARG) - -static err_t -snmp_prepare_outbound_frame(struct snmp_request *request) -{ - struct snmp_asn1_tlv tlv; - struct snmp_pbuf_stream *pbuf_stream = &(request->outbound_pbuf_stream); - - /* try allocating pbuf(s) for maximum response size */ - request->outbound_pbuf = pbuf_alloc(PBUF_TRANSPORT, 1472, PBUF_RAM); - if (request->outbound_pbuf == NULL) { - return ERR_MEM; - } - - snmp_pbuf_stream_init(pbuf_stream, request->outbound_pbuf, 0, request->outbound_pbuf->tot_len); - - /* 'Message' sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, 0); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - - /* version */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); - snmp_asn1_enc_s32t_cnt(request->version, &tlv.value_len); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - OF_BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->version) ); - -#if LWIP_SNMP_V3 - if (request->version < SNMP_VERSION_3) { -#endif - /* community */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->community_strlen); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - OF_BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, request->community, request->community_strlen) ); -#if LWIP_SNMP_V3 - } else { - const char *id; - - /* globalData */ - request->outbound_msg_global_data_offset = pbuf_stream->offset; - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, 0); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - - /* msgID */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); - snmp_asn1_enc_s32t_cnt(request->msg_id, &tlv.value_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_id)); - - /* msgMaxSize */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); - snmp_asn1_enc_s32t_cnt(request->msg_max_size, &tlv.value_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_max_size)); - - /* msgFlags */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, 1); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, &request->msg_flags, 1)); - - /* msgSecurityModel */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); - snmp_asn1_enc_s32t_cnt(request->msg_security_model, &tlv.value_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_security_model)); - - /* end of msgGlobalData */ - request->outbound_msg_global_data_end = pbuf_stream->offset; - - /* msgSecurityParameters */ - request->outbound_msg_security_parameters_str_offset = pbuf_stream->offset; - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, 0); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - - request->outbound_msg_security_parameters_seq_offset = pbuf_stream->offset; - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, 0); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - - /* msgAuthoritativeEngineID */ - snmpv3_get_engine_id(&id, &request->msg_authoritative_engine_id_len); - MEMCPY(request->msg_authoritative_engine_id, id, request->msg_authoritative_engine_id_len); - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->msg_authoritative_engine_id_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_authoritative_engine_id, request->msg_authoritative_engine_id_len)); - - request->msg_authoritative_engine_time = snmpv3_get_engine_time(); - request->msg_authoritative_engine_boots = snmpv3_get_engine_boots(); - - /* msgAuthoritativeEngineBoots */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); - snmp_asn1_enc_s32t_cnt(request->msg_authoritative_engine_boots, &tlv.value_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_authoritative_engine_boots)); - - /* msgAuthoritativeEngineTime */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); - snmp_asn1_enc_s32t_cnt(request->msg_authoritative_engine_time, &tlv.value_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_authoritative_engine_time)); - - /* msgUserName */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->msg_user_name_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_user_name, request->msg_user_name_len)); - -#if LWIP_SNMP_V3_CRYPTO - /* msgAuthenticationParameters */ - if (request->msg_flags & SNMP_V3_AUTH_FLAG) { - memset(request->msg_authentication_parameters, 0, SNMP_V3_MAX_AUTH_PARAM_LENGTH); - request->outbound_msg_authentication_parameters_offset = pbuf_stream->offset; - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, SNMP_V3_MAX_AUTH_PARAM_LENGTH); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_authentication_parameters, SNMP_V3_MAX_AUTH_PARAM_LENGTH)); - } else -#endif - { - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, 0); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - } - -#if LWIP_SNMP_V3_CRYPTO - /* msgPrivacyParameters */ - if (request->msg_flags & SNMP_V3_PRIV_FLAG) { - snmpv3_build_priv_param(request->msg_privacy_parameters); - - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, SNMP_V3_MAX_PRIV_PARAM_LENGTH); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_privacy_parameters, SNMP_V3_MAX_PRIV_PARAM_LENGTH)); - } else -#endif - { - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, 0); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - } - - /* End of msgSecurityParameters, so we can calculate the length of this sequence later */ - request->outbound_msg_security_parameters_end = pbuf_stream->offset; - -#if LWIP_SNMP_V3_CRYPTO - /* For encryption we have to encapsulate the payload in an octet string */ - if (request->msg_flags & SNMP_V3_PRIV_FLAG) { - request->outbound_scoped_pdu_string_offset = pbuf_stream->offset; - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 3, 0); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - } -#endif - /* Scoped PDU - * Encryption context - */ - request->outbound_scoped_pdu_seq_offset = pbuf_stream->offset; - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, 0); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - - /* contextEngineID */ - snmpv3_get_engine_id(&id, &request->context_engine_id_len); - MEMCPY(request->context_engine_id, id, request->context_engine_id_len); - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->context_engine_id_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->context_engine_id, request->context_engine_id_len)); - - /* contextName */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->context_name_len); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->context_name, request->context_name_len)); - } -#endif - - /* 'PDU' sequence */ - request->outbound_pdu_offset = pbuf_stream->offset; - SNMP_ASN1_SET_TLV_PARAMS(tlv, request->request_out_type, 3, 0); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - - /* request ID */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); - snmp_asn1_enc_s32t_cnt(request->request_id, &tlv.value_len); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - OF_BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->request_id) ); - - /* error status */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - request->outbound_error_status_offset = pbuf_stream->offset; - OF_BUILD_EXEC( snmp_pbuf_stream_write(pbuf_stream, 0) ); - - /* error index */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - request->outbound_error_index_offset = pbuf_stream->offset; - OF_BUILD_EXEC( snmp_pbuf_stream_write(pbuf_stream, 0) ); - - /* 'VarBindList' sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, 0); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - - request->outbound_varbind_offset = pbuf_stream->offset; - - return ERR_OK; -} - -/** Calculate the length of a varbind list */ -err_t -snmp_varbind_length(struct snmp_varbind *varbind, struct snmp_varbind_len *len) -{ - /* calculate required lengths */ - snmp_asn1_enc_oid_cnt(varbind->oid.id, varbind->oid.len, &len->oid_value_len); - snmp_asn1_enc_length_cnt(len->oid_value_len, &len->oid_len_len); - - if (varbind->value_len == 0) { - len->value_value_len = 0; - } else if (varbind->value_len & SNMP_GET_VALUE_RAW_DATA) { - len->value_value_len = varbind->value_len & (~SNMP_GET_VALUE_RAW_DATA); - } else { - switch (varbind->type) { - case SNMP_ASN1_TYPE_INTEGER: - if (varbind->value_len != sizeof (s32_t)) { - return ERR_VAL; - } - snmp_asn1_enc_s32t_cnt(*((s32_t *) varbind->value), &len->value_value_len); - break; - case SNMP_ASN1_TYPE_COUNTER: - case SNMP_ASN1_TYPE_GAUGE: - case SNMP_ASN1_TYPE_TIMETICKS: - if (varbind->value_len != sizeof (u32_t)) { - return ERR_VAL; - } - snmp_asn1_enc_u32t_cnt(*((u32_t *) varbind->value), &len->value_value_len); - break; - case SNMP_ASN1_TYPE_OCTET_STRING: - case SNMP_ASN1_TYPE_IPADDR: - case SNMP_ASN1_TYPE_OPAQUE: - len->value_value_len = varbind->value_len; - break; - case SNMP_ASN1_TYPE_NULL: - if (varbind->value_len != 0) { - return ERR_VAL; - } - len->value_value_len = 0; - break; - case SNMP_ASN1_TYPE_OBJECT_ID: - if ((varbind->value_len & 0x03) != 0) { - return ERR_VAL; - } - snmp_asn1_enc_oid_cnt((u32_t *) varbind->value, varbind->value_len >> 2, &len->value_value_len); - break; -#if LWIP_HAVE_INT64 - case SNMP_ASN1_TYPE_COUNTER64: - if (varbind->value_len != sizeof(u64_t)) { - return ERR_VAL; - } - snmp_asn1_enc_u64t_cnt(*(u64_t *)varbind->value, &len->value_value_len); - break; -#endif - default: - /* unsupported type */ - return ERR_VAL; - } - } - snmp_asn1_enc_length_cnt(len->value_value_len, &len->value_len_len); - - len->vb_value_len = 1 + len->oid_len_len + len->oid_value_len + 1 + len->value_len_len + len->value_value_len; - snmp_asn1_enc_length_cnt(len->vb_value_len, &len->vb_len_len); - - return ERR_OK; -} - -#define OVB_BUILD_EXEC(code) BUILD_EXEC(code, ERR_ARG) - -err_t -snmp_append_outbound_varbind(struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbind) -{ - struct snmp_asn1_tlv tlv; - struct snmp_varbind_len len; - err_t err; - - err = snmp_varbind_length(varbind, &len); - - if (err != ERR_OK) { - return err; - } - - /* check length already before adding first data because in case of GetBulk, - * data added so far is returned and therefore no partial data shall be added - */ - if ((1 + len.vb_len_len + len.vb_value_len) > pbuf_stream->length) { - return ERR_BUF; - } - - /* 'VarBind' sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, len.vb_len_len, len.vb_value_len); - OVB_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - - /* VarBind OID */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OBJECT_ID, len.oid_len_len, len.oid_value_len); - OVB_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - OVB_BUILD_EXEC(snmp_asn1_enc_oid(pbuf_stream, varbind->oid.id, varbind->oid.len)); - - /* VarBind value */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, varbind->type, len.value_len_len, len.value_value_len); - OVB_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); - - if (len.value_value_len > 0) { - if (varbind->value_len & SNMP_GET_VALUE_RAW_DATA) { - OVB_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, (u8_t *) varbind->value, len.value_value_len)); - } else { - switch (varbind->type) { - case SNMP_ASN1_TYPE_INTEGER: - OVB_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, len.value_value_len, *((s32_t *) varbind->value))); - break; - case SNMP_ASN1_TYPE_COUNTER: - case SNMP_ASN1_TYPE_GAUGE: - case SNMP_ASN1_TYPE_TIMETICKS: - OVB_BUILD_EXEC(snmp_asn1_enc_u32t(pbuf_stream, len.value_value_len, *((u32_t *) varbind->value))); - break; - case SNMP_ASN1_TYPE_OCTET_STRING: - case SNMP_ASN1_TYPE_IPADDR: - case SNMP_ASN1_TYPE_OPAQUE: - OVB_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, (u8_t *) varbind->value, len.value_value_len)); - len.value_value_len = varbind->value_len; - break; - case SNMP_ASN1_TYPE_OBJECT_ID: - OVB_BUILD_EXEC(snmp_asn1_enc_oid(pbuf_stream, (u32_t *) varbind->value, varbind->value_len / sizeof (u32_t))); - break; -#if LWIP_HAVE_INT64 - case SNMP_ASN1_TYPE_COUNTER64: - OVB_BUILD_EXEC(snmp_asn1_enc_u64t(pbuf_stream, len.value_value_len, *(u64_t *) varbind->value)); - break; -#endif - default: - LWIP_ASSERT("Unknown variable type", 0); - break; - } - } - } - - return ERR_OK; -} - -static err_t -snmp_complete_outbound_frame(struct snmp_request *request) -{ - struct snmp_asn1_tlv tlv; - u16_t frame_size; - u8_t outbound_padding = 0; - - if (request->version == SNMP_VERSION_1) { - if (request->error_status != SNMP_ERR_NOERROR) { - /* map v2c error codes to v1 compliant error code (according to RFC 2089) */ - switch (request->error_status) { - /* mapping of implementation specific "virtual" error codes - * (during processing of frame we already stored them in error_status field, - * so no need to check all varbinds here for those exceptions as suggested by RFC) */ - case SNMP_ERR_NOSUCHINSTANCE: - case SNMP_ERR_NOSUCHOBJECT: - case SNMP_ERR_ENDOFMIBVIEW: - request->error_status = SNMP_ERR_NOSUCHNAME; - break; - /* mapping according to RFC */ - case SNMP_ERR_WRONGVALUE: - case SNMP_ERR_WRONGENCODING: - case SNMP_ERR_WRONGTYPE: - case SNMP_ERR_WRONGLENGTH: - case SNMP_ERR_INCONSISTENTVALUE: - request->error_status = SNMP_ERR_BADVALUE; - break; - case SNMP_ERR_NOACCESS: - case SNMP_ERR_NOTWRITABLE: - case SNMP_ERR_NOCREATION: - case SNMP_ERR_INCONSISTENTNAME: - case SNMP_ERR_AUTHORIZATIONERROR: - request->error_status = SNMP_ERR_NOSUCHNAME; - break; - case SNMP_ERR_RESOURCEUNAVAILABLE: - case SNMP_ERR_COMMITFAILED: - case SNMP_ERR_UNDOFAILED: - default: - request->error_status = SNMP_ERR_GENERROR; - break; - } - } - } else { - if (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { - /* map error codes to according to RFC 1905 (4.2.5. The SetRequest-PDU) return 'NotWritable' for unknown OIDs) */ - switch (request->error_status) { - case SNMP_ERR_NOSUCHINSTANCE: - case SNMP_ERR_NOSUCHOBJECT: - case SNMP_ERR_ENDOFMIBVIEW: - request->error_status = SNMP_ERR_NOTWRITABLE; - break; - default: - break; - } - } - - if (request->error_status >= SNMP_VARBIND_EXCEPTION_OFFSET) { - /* should never occur because v2 frames store exceptions directly inside varbinds and not as frame error_status */ - LWIP_DEBUGF(SNMP_DEBUG, ("snmp_complete_outbound_frame() > Found v2 request with varbind exception code stored as error status!\n")); - return ERR_ARG; - } - } - - if ((request->error_status != SNMP_ERR_NOERROR) || (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ)) { - /* all inbound vars are returned in response without any modification for error responses and successful set requests*/ - struct snmp_pbuf_stream inbound_stream; - OF_BUILD_EXEC( snmp_pbuf_stream_init(&inbound_stream, request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len) ); - OF_BUILD_EXEC( snmp_pbuf_stream_init(&(request->outbound_pbuf_stream), request->outbound_pbuf, request->outbound_varbind_offset, request->outbound_pbuf->tot_len - request->outbound_varbind_offset) ); - OF_BUILD_EXEC( snmp_pbuf_stream_writeto(&inbound_stream, &(request->outbound_pbuf_stream), 0) ); - } - - frame_size = request->outbound_pbuf_stream.offset; - -#if LWIP_SNMP_V3 && LWIP_SNMP_V3_CRYPTO - /* Calculate padding for encryption */ - if (request->version == SNMP_VERSION_3 && (request->msg_flags & SNMP_V3_PRIV_FLAG)) { - u8_t i; - outbound_padding = (8 - (u8_t)((frame_size - request->outbound_scoped_pdu_seq_offset) & 0x07)) & 0x07; - for (i = 0; i < outbound_padding; i++) { - OF_BUILD_EXEC( snmp_pbuf_stream_write(&request->outbound_pbuf_stream, 0) ); - } - } -#endif - - /* complete missing length in 'Message' sequence ; 'Message' tlv is located at the beginning (offset 0) */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, frame_size + outbound_padding - 1 - 3); /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ - OF_BUILD_EXEC( snmp_pbuf_stream_init(&(request->outbound_pbuf_stream), request->outbound_pbuf, 0, request->outbound_pbuf->tot_len) ); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv) ); - -#if LWIP_SNMP_V3 - if (request->version == SNMP_VERSION_3) { - /* complete missing length in 'globalData' sequence */ - /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, request->outbound_msg_global_data_end - - request->outbound_msg_global_data_offset - 1 - 1); - OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_msg_global_data_offset)); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); - - /* complete missing length in 'msgSecurityParameters' sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, request->outbound_msg_security_parameters_end - - request->outbound_msg_security_parameters_str_offset - 1 - 1); - OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_msg_security_parameters_str_offset)); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); - - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, request->outbound_msg_security_parameters_end - - request->outbound_msg_security_parameters_seq_offset - 1 - 1); - OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_msg_security_parameters_seq_offset)); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); - - /* complete missing length in scoped PDU sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, frame_size - request->outbound_scoped_pdu_seq_offset - 1 - 3); - OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_scoped_pdu_seq_offset)); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); - } -#endif - - /* complete missing length in 'PDU' sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, request->request_out_type, 3, - frame_size - request->outbound_pdu_offset - 1 - 3); /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ - OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_pdu_offset) ); - OF_BUILD_EXEC( snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv) ); - - /* process and encode final error status */ - if (request->error_status != 0) { - u16_t len; - snmp_asn1_enc_s32t_cnt(request->error_status, &len); - if (len != 1) { - /* error, we only reserved one byte for it */ - return ERR_ARG; - } - OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_error_status_offset) ); - OF_BUILD_EXEC( snmp_asn1_enc_s32t(&(request->outbound_pbuf_stream), len, request->error_status) ); - - /* for compatibility to v1, log statistics; in v2 (RFC 1907) these statistics are obsoleted */ - switch (request->error_status) { - case SNMP_ERR_TOOBIG: - snmp_stats.outtoobigs++; - break; - case SNMP_ERR_NOSUCHNAME: - snmp_stats.outnosuchnames++; - break; - case SNMP_ERR_BADVALUE: - snmp_stats.outbadvalues++; - break; - case SNMP_ERR_GENERROR: - default: - snmp_stats.outgenerrs++; - break; - } - - if (request->error_status == SNMP_ERR_TOOBIG) { - request->error_index = 0; /* defined by RFC 1157 */ - } else if (request->error_index == 0) { - /* set index to varbind where error occured (if not already set before, e.g. during GetBulk processing) */ - request->error_index = request->inbound_varbind_enumerator.varbind_count; - } - } else { - if (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { - snmp_stats.intotalsetvars += request->inbound_varbind_enumerator.varbind_count; - } else { - snmp_stats.intotalreqvars += request->inbound_varbind_enumerator.varbind_count; - } - } - - /* encode final error index*/ - if (request->error_index != 0) { - u16_t len; - snmp_asn1_enc_s32t_cnt(request->error_index, &len); - if (len != 1) { - /* error, we only reserved one byte for it */ - return ERR_VAL; - } - OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_error_index_offset) ); - OF_BUILD_EXEC( snmp_asn1_enc_s32t(&(request->outbound_pbuf_stream), len, request->error_index) ); - } - - /* complete missing length in 'VarBindList' sequence ; 'VarBindList' tlv is located directly before varbind offset */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, frame_size - request->outbound_varbind_offset); - OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_varbind_offset - 1 - 3) ); /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ - OF_BUILD_EXEC( snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv) ); - - /* Authenticate response */ -#if LWIP_SNMP_V3 && LWIP_SNMP_V3_CRYPTO - /* Encrypt response */ - if (request->version == SNMP_VERSION_3 && (request->msg_flags & SNMP_V3_PRIV_FLAG)) { - u8_t key[20]; - snmpv3_priv_algo_t algo; - - /* complete missing length in PDU sequence */ - OF_BUILD_EXEC(snmp_pbuf_stream_init(&request->outbound_pbuf_stream, request->outbound_pbuf, 0, request->outbound_pbuf->tot_len)); - OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_scoped_pdu_string_offset)); - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 3, frame_size + outbound_padding - - request->outbound_scoped_pdu_string_offset - 1 - 3); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); - - OF_BUILD_EXEC(snmpv3_get_user((char *)request->msg_user_name, NULL, NULL, &algo, key)); - - OF_BUILD_EXEC(snmpv3_crypt(&request->outbound_pbuf_stream, tlv.value_len, key, - request->msg_privacy_parameters, request->msg_authoritative_engine_boots, - request->msg_authoritative_engine_time, algo, SNMP_V3_PRIV_MODE_ENCRYPT)); - } - - if (request->version == SNMP_VERSION_3 && (request->msg_flags & SNMP_V3_AUTH_FLAG)) { - u8_t key[20]; - snmpv3_auth_algo_t algo; - u8_t hmac[20]; - - OF_BUILD_EXEC(snmpv3_get_user((char *)request->msg_user_name, &algo, key, NULL, NULL)); - OF_BUILD_EXEC(snmp_pbuf_stream_init(&(request->outbound_pbuf_stream), - request->outbound_pbuf, 0, request->outbound_pbuf->tot_len)); - OF_BUILD_EXEC(snmpv3_auth(&request->outbound_pbuf_stream, frame_size + outbound_padding, key, algo, hmac)); - - MEMCPY(request->msg_authentication_parameters, hmac, SNMP_V3_MAX_AUTH_PARAM_LENGTH); - OF_BUILD_EXEC(snmp_pbuf_stream_init(&request->outbound_pbuf_stream, - request->outbound_pbuf, 0, request->outbound_pbuf->tot_len)); - OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&request->outbound_pbuf_stream, - request->outbound_msg_authentication_parameters_offset)); - - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, SNMP_V3_MAX_AUTH_PARAM_LENGTH); - OF_BUILD_EXEC(snmp_ans1_enc_tlv(&request->outbound_pbuf_stream, &tlv)); - OF_BUILD_EXEC(snmp_asn1_enc_raw(&request->outbound_pbuf_stream, - request->msg_authentication_parameters, SNMP_V3_MAX_AUTH_PARAM_LENGTH)); - } -#endif - - pbuf_realloc(request->outbound_pbuf, frame_size + outbound_padding); - - snmp_stats.outgetresponses++; - snmp_stats.outpkts++; - - return ERR_OK; -} - -static void -snmp_execute_write_callbacks(struct snmp_request *request) -{ - struct snmp_varbind_enumerator inbound_varbind_enumerator; - struct snmp_varbind vb; - - snmp_vb_enumerator_init(&inbound_varbind_enumerator, request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len); - vb.value = NULL; /* do NOT decode value (we enumerate outbound buffer here, so all varbinds have values assigned, which we don't need here) */ - - while (snmp_vb_enumerator_get_next(&inbound_varbind_enumerator, &vb) == SNMP_VB_ENUMERATOR_ERR_OK) { - snmp_write_callback(vb.oid.id, vb.oid.len, snmp_write_callback_arg); - } -} - - -/* ----------------------------------------------------------------------- */ -/* VarBind enumerator methods */ -/* ----------------------------------------------------------------------- */ - -void -snmp_vb_enumerator_init(struct snmp_varbind_enumerator *enumerator, struct pbuf *p, u16_t offset, u16_t length) -{ - snmp_pbuf_stream_init(&(enumerator->pbuf_stream), p, offset, length); - enumerator->varbind_count = 0; -} - -#define VB_PARSE_EXEC(code) PARSE_EXEC(code, SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) -#define VB_PARSE_ASSERT(code) PARSE_ASSERT(code, SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) - -snmp_vb_enumerator_err_t -snmp_vb_enumerator_get_next(struct snmp_varbind_enumerator *enumerator, struct snmp_varbind *varbind) -{ - struct snmp_asn1_tlv tlv; - u16_t varbind_len; - err_t err; - - if (enumerator->pbuf_stream.length == 0) { - return SNMP_VB_ENUMERATOR_ERR_EOVB; - } - enumerator->varbind_count++; - - /* decode varbind itself (parent container of a varbind) */ - VB_PARSE_EXEC(snmp_asn1_dec_tlv(&(enumerator->pbuf_stream), &tlv)); - VB_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_SEQUENCE) && (tlv.value_len <= enumerator->pbuf_stream.length)); - varbind_len = tlv.value_len; - - /* decode varbind name (object id) */ - VB_PARSE_EXEC(snmp_asn1_dec_tlv(&(enumerator->pbuf_stream), &tlv)); - VB_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_OBJECT_ID) && (SNMP_ASN1_TLV_LENGTH(tlv) < varbind_len) && (tlv.value_len < enumerator->pbuf_stream.length)); - - VB_PARSE_EXEC(snmp_asn1_dec_oid(&(enumerator->pbuf_stream), tlv.value_len, varbind->oid.id, &(varbind->oid.len), SNMP_MAX_OBJ_ID_LEN)); - varbind_len -= SNMP_ASN1_TLV_LENGTH(tlv); - - /* decode varbind value (object id) */ - VB_PARSE_EXEC(snmp_asn1_dec_tlv(&(enumerator->pbuf_stream), &tlv)); - VB_PARSE_ASSERT((SNMP_ASN1_TLV_LENGTH(tlv) == varbind_len) && (tlv.value_len <= enumerator->pbuf_stream.length)); - varbind->type = tlv.type; - - /* shall the value be decoded ? */ - if (varbind->value != NULL) { - switch (varbind->type) { - case SNMP_ASN1_TYPE_INTEGER: - VB_PARSE_EXEC(snmp_asn1_dec_s32t(&(enumerator->pbuf_stream), tlv.value_len, (s32_t *)varbind->value)); - varbind->value_len = sizeof(s32_t); - break; - case SNMP_ASN1_TYPE_COUNTER: - case SNMP_ASN1_TYPE_GAUGE: - case SNMP_ASN1_TYPE_TIMETICKS: - VB_PARSE_EXEC(snmp_asn1_dec_u32t(&(enumerator->pbuf_stream), tlv.value_len, (u32_t *)varbind->value)); - varbind->value_len = sizeof(u32_t); - break; - case SNMP_ASN1_TYPE_OCTET_STRING: - case SNMP_ASN1_TYPE_OPAQUE: - err = snmp_asn1_dec_raw(&(enumerator->pbuf_stream), tlv.value_len, (u8_t *)varbind->value, &varbind->value_len, SNMP_MAX_VALUE_SIZE); - if (err == ERR_MEM) { - return SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH; - } - VB_PARSE_ASSERT(err == ERR_OK); - break; - case SNMP_ASN1_TYPE_NULL: - varbind->value_len = 0; - break; - case SNMP_ASN1_TYPE_OBJECT_ID: - /* misuse tlv.length_len as OID_length transporter */ - err = snmp_asn1_dec_oid(&(enumerator->pbuf_stream), tlv.value_len, (u32_t *)varbind->value, &tlv.length_len, SNMP_MAX_OBJ_ID_LEN); - if (err == ERR_MEM) { - return SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH; - } - VB_PARSE_ASSERT(err == ERR_OK); - varbind->value_len = tlv.length_len * sizeof(u32_t); - break; - case SNMP_ASN1_TYPE_IPADDR: - if (tlv.value_len == 4) { - /* must be exactly 4 octets! */ - VB_PARSE_EXEC(snmp_asn1_dec_raw(&(enumerator->pbuf_stream), tlv.value_len, (u8_t *)varbind->value, &varbind->value_len, SNMP_MAX_VALUE_SIZE)); - } else { - VB_PARSE_ASSERT(0); - } - break; -#if LWIP_HAVE_INT64 - case SNMP_ASN1_TYPE_COUNTER64: - VB_PARSE_EXEC(snmp_asn1_dec_u64t(&(enumerator->pbuf_stream), tlv.value_len, (u64_t *)varbind->value)); - varbind->value_len = sizeof(u64_t); - break; -#endif - default: - VB_PARSE_ASSERT(0); - break; - } - } else { - snmp_pbuf_stream_seek(&(enumerator->pbuf_stream), tlv.value_len); - varbind->value_len = tlv.value_len; - } - - return SNMP_VB_ENUMERATOR_ERR_OK; -} - -#endif /* LWIP_SNMP */ +/** + * @file + * SNMP message processing (RFC1157). + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * Copyright (c) 2016 Elias Oenal. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Christiaan Simons + * Martin Hentschel + * Elias Oenal + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "snmp_msg.h" +#include "snmp_asn1.h" +#include "snmp_core_priv.h" +#include "lwip/ip_addr.h" +#include "lwip/stats.h" + +#if LWIP_SNMP_V3 +#include "lwip/apps/snmpv3.h" +#include "snmpv3_priv.h" +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif +#endif + +#include + +#define SNMP_V3_AUTH_FLAG 0x01 +#define SNMP_V3_PRIV_FLAG 0x02 + +/* Security levels */ +#define SNMP_V3_NOAUTHNOPRIV 0x00 +#define SNMP_V3_AUTHNOPRIV SNMP_V3_AUTH_FLAG +#define SNMP_V3_AUTHPRIV (SNMP_V3_AUTH_FLAG | SNMP_V3_PRIV_FLAG) + +/* public (non-static) constants */ +/** SNMP community string */ +const char *snmp_community = SNMP_COMMUNITY; +/** SNMP community string for write access */ +const char *snmp_community_write = SNMP_COMMUNITY_WRITE; +/** SNMP community string for sending traps */ +const char *snmp_community_trap = SNMP_COMMUNITY_TRAP; + +snmp_write_callback_fct snmp_write_callback = NULL; +void *snmp_write_callback_arg = NULL; + +#if LWIP_SNMP_CONFIGURE_VERSIONS + +static u8_t v1_enabled = 1; +static u8_t v2c_enabled = 1; +static u8_t v3_enabled = 1; + +static u8_t +snmp_version_enabled(u8_t version) +{ + if (version == SNMP_VERSION_1) { + return v1_enabled; + } else if (version == SNMP_VERSION_2c) { + return v2c_enabled; + } +#if LWIP_SNMP_V3 + else if (version == SNMP_VERSION_3) { + return v3_enabled; + } +#endif + else { + LWIP_ASSERT("Invalid SNMP version", 0); + return 0; + } +} + +u8_t +snmp_v1_enabled(void) +{ + return snmp_version_enabled(SNMP_VERSION_1); +} + +u8_t +snmp_v2c_enabled(void) +{ + return snmp_version_enabled(SNMP_VERSION_2c); +} + +u8_t +snmp_v3_enabled(void) +{ + return snmp_version_enabled(SNMP_VERSION_3); +} + +static void +snmp_version_enable(u8_t version, u8_t enable) +{ + if (version == SNMP_VERSION_1) { + v1_enabled = enable; + } else if (version == SNMP_VERSION_2c) { + v2c_enabled = enable; + } +#if LWIP_SNMP_V3 + else if (version == SNMP_VERSION_3) { + v3_enabled = enable; + } +#endif + else { + LWIP_ASSERT("Invalid SNMP version", 0); + } +} + +void +snmp_v1_enable(u8_t enable) +{ + snmp_version_enable(SNMP_VERSION_1, enable); +} + +void +snmp_v2c_enable(u8_t enable) +{ + snmp_version_enable(SNMP_VERSION_2c, enable); +} + +void +snmp_v3_enable(u8_t enable) +{ + snmp_version_enable(SNMP_VERSION_3, enable); +} + +#endif + +/** + * @ingroup snmp_core + * Returns current SNMP community string. + * @return current SNMP community string + */ +const char * +snmp_get_community(void) +{ + return snmp_community; +} + +/** + * @ingroup snmp_core + * Sets SNMP community string. + * The string itself (its storage) must be valid throughout the whole life of + * program (or until it is changed to sth else). + * + * @param community is a pointer to new community string + */ +void +snmp_set_community(const char *const community) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("community string is too long!", strlen(community) <= SNMP_MAX_COMMUNITY_STR_LEN); + snmp_community = community; +} + +/** + * @ingroup snmp_core + * Returns current SNMP write-access community string. + * @return current SNMP write-access community string + */ +const char * +snmp_get_community_write(void) +{ + return snmp_community_write; +} + +/** + * @ingroup snmp_traps + * Returns current SNMP community string used for sending traps. + * @return current SNMP community string used for sending traps + */ +const char * +snmp_get_community_trap(void) +{ + return snmp_community_trap; +} + +/** + * @ingroup snmp_core + * Sets SNMP community string for write-access. + * The string itself (its storage) must be valid throughout the whole life of + * program (or until it is changed to sth else). + * + * @param community is a pointer to new write-access community string + */ +void +snmp_set_community_write(const char *const community) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("community string must not be NULL", community != NULL); + LWIP_ASSERT("community string is too long!", strlen(community) <= SNMP_MAX_COMMUNITY_STR_LEN); + snmp_community_write = community; +} + +/** + * @ingroup snmp_traps + * Sets SNMP community string used for sending traps. + * The string itself (its storage) must be valid throughout the whole life of + * program (or until it is changed to sth else). + * + * @param community is a pointer to new trap community string + */ +void +snmp_set_community_trap(const char *const community) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("community string is too long!", strlen(community) <= SNMP_MAX_COMMUNITY_STR_LEN); + snmp_community_trap = community; +} + +/** + * @ingroup snmp_core + * Callback fired on every successful write access + */ +void +snmp_set_write_callback(snmp_write_callback_fct write_callback, void *callback_arg) +{ + LWIP_ASSERT_CORE_LOCKED(); + snmp_write_callback = write_callback; + snmp_write_callback_arg = callback_arg; +} + +/* ----------------------------------------------------------------------- */ +/* forward declarations */ +/* ----------------------------------------------------------------------- */ + +static err_t snmp_process_get_request(struct snmp_request *request); +static err_t snmp_process_getnext_request(struct snmp_request *request); +static err_t snmp_process_getbulk_request(struct snmp_request *request); +static err_t snmp_process_set_request(struct snmp_request *request); + +static err_t snmp_parse_inbound_frame(struct snmp_request *request); +static err_t snmp_prepare_outbound_frame(struct snmp_request *request); +static err_t snmp_complete_outbound_frame(struct snmp_request *request); +static void snmp_execute_write_callbacks(struct snmp_request *request); + + +/* ----------------------------------------------------------------------- */ +/* implementation */ +/* ----------------------------------------------------------------------- */ + +void +snmp_receive(void *handle, struct pbuf *p, const ip_addr_t *source_ip, u16_t port) +{ + err_t err; + struct snmp_request request; + + memset(&request, 0, sizeof(request)); + request.handle = handle; + request.source_ip = source_ip; + request.source_port = port; + request.inbound_pbuf = p; + + snmp_stats.inpkts++; + + err = snmp_parse_inbound_frame(&request); + if (err == ERR_OK) { + err = snmp_prepare_outbound_frame(&request); + if (err == ERR_OK) { + + if (request.error_status == SNMP_ERR_NOERROR) { + /* only process frame if we do not already have an error to return (e.g. all readonly) */ + if (request.request_type == SNMP_ASN1_CONTEXT_PDU_GET_REQ) { + err = snmp_process_get_request(&request); + } else if (request.request_type == SNMP_ASN1_CONTEXT_PDU_GET_NEXT_REQ) { + err = snmp_process_getnext_request(&request); + } else if (request.request_type == SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ) { + err = snmp_process_getbulk_request(&request); + } else if (request.request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { + err = snmp_process_set_request(&request); + } + } +#if LWIP_SNMP_V3 + else { + struct snmp_varbind vb; + + vb.next = NULL; + vb.prev = NULL; + vb.type = SNMP_ASN1_TYPE_COUNTER32; + vb.value_len = sizeof(u32_t); + + switch (request.error_status) { + case SNMP_ERR_AUTHORIZATIONERROR: { + static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 5, 0 }; + snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); + vb.value = &snmp_stats.wrongdigests; + } + break; + case SNMP_ERR_UNKNOWN_ENGINEID: { + static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 4, 0 }; + snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); + vb.value = &snmp_stats.unknownengineids; + } + break; + case SNMP_ERR_UNKNOWN_SECURITYNAME: { + static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 3, 0 }; + snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); + vb.value = &snmp_stats.unknownusernames; + } + break; + case SNMP_ERR_UNSUPPORTED_SECLEVEL: { + static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 1, 0 }; + snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); + vb.value = &snmp_stats.unsupportedseclevels; + } + break; + case SNMP_ERR_NOTINTIMEWINDOW: { + static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 2, 0 }; + snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); + vb.value = &snmp_stats.notintimewindows; + } + break; + case SNMP_ERR_DECRYIPTION_ERROR: { + static const u32_t oid[] = { 1, 3, 6, 1, 6, 3, 15, 1, 1, 6, 0 }; + snmp_oid_assign(&vb.oid, oid, LWIP_ARRAYSIZE(oid)); + vb.value = &snmp_stats.decryptionerrors; + } + break; + default: + /* Unknown or unhandled error_status */ + err = ERR_ARG; + } + + if (err == ERR_OK) { + snmp_append_outbound_varbind(&(request.outbound_pbuf_stream), &vb); + request.error_status = SNMP_ERR_NOERROR; + } + + request.request_out_type = (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_REPORT); + request.request_id = request.msg_id; + } +#endif + + if (err == ERR_OK) { + err = snmp_complete_outbound_frame(&request); + + if (err == ERR_OK) { + err = snmp_sendto(request.handle, request.outbound_pbuf, request.source_ip, request.source_port); + + if ((request.request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) + && (request.error_status == SNMP_ERR_NOERROR) + && (snmp_write_callback != NULL)) { + /* raise write notification for all written objects */ + snmp_execute_write_callbacks(&request); + } + } + } + } + + if (request.outbound_pbuf != NULL) { + pbuf_free(request.outbound_pbuf); + } + } +} + +static u8_t +snmp_msg_getnext_validate_node_inst(struct snmp_node_instance *node_instance, void *validate_arg) +{ + if (((node_instance->access & SNMP_NODE_INSTANCE_ACCESS_READ) != SNMP_NODE_INSTANCE_ACCESS_READ) || (node_instance->get_value == NULL)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + +#if LWIP_HAVE_INT64 + if ((node_instance->asn1_type == SNMP_ASN1_TYPE_COUNTER64) && (((struct snmp_request *)validate_arg)->version == SNMP_VERSION_1)) { + /* according to RFC 2089 skip Counter64 objects in GetNext requests from v1 clients */ + return SNMP_ERR_NOSUCHINSTANCE; + } +#endif + + return SNMP_ERR_NOERROR; +} + +static void +snmp_process_varbind(struct snmp_request *request, struct snmp_varbind *vb, u8_t get_next) +{ + err_t err; + struct snmp_node_instance node_instance; + memset(&node_instance, 0, sizeof(node_instance)); + + if (get_next) { + struct snmp_obj_id result_oid; + request->error_status = snmp_get_next_node_instance_from_oid(vb->oid.id, vb->oid.len, snmp_msg_getnext_validate_node_inst, request, &result_oid, &node_instance); + + if (request->error_status == SNMP_ERR_NOERROR) { + snmp_oid_assign(&vb->oid, result_oid.id, result_oid.len); + } + } else { + request->error_status = snmp_get_node_instance_from_oid(vb->oid.id, vb->oid.len, &node_instance); + + if (request->error_status == SNMP_ERR_NOERROR) { + /* use 'getnext_validate' method for validation to avoid code duplication (some checks have to be executed here) */ + request->error_status = snmp_msg_getnext_validate_node_inst(&node_instance, request); + + if (request->error_status != SNMP_ERR_NOERROR) { + if (node_instance.release_instance != NULL) { + node_instance.release_instance(&node_instance); + } + } + } + } + + if (request->error_status != SNMP_ERR_NOERROR) { + if (request->error_status >= SNMP_VARBIND_EXCEPTION_OFFSET) { + if ((request->version == SNMP_VERSION_2c) || request->version == SNMP_VERSION_3) { + /* in SNMP v2c a varbind related exception is stored in varbind and not in frame header */ + vb->type = (SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_CLASS_CONTEXT | (request->error_status & SNMP_VARBIND_EXCEPTION_MASK)); + vb->value_len = 0; + + err = snmp_append_outbound_varbind(&(request->outbound_pbuf_stream), vb); + if (err == ERR_OK) { + /* we stored the exception in varbind -> go on */ + request->error_status = SNMP_ERR_NOERROR; + } else if (err == ERR_BUF) { + request->error_status = SNMP_ERR_TOOBIG; + } else { + request->error_status = SNMP_ERR_GENERROR; + } + } + } else { + /* according to RFC 1157/1905, all other errors only return genError */ + request->error_status = SNMP_ERR_GENERROR; + } + } else { + s16_t len = node_instance.get_value(&node_instance, vb->value); + + if (len >= 0) { + vb->value_len = (u16_t)len; /* cast is OK because we checked >= 0 above */ + vb->type = node_instance.asn1_type; + + LWIP_ASSERT("SNMP_MAX_VALUE_SIZE is configured too low", (vb->value_len & ~SNMP_GET_VALUE_RAW_DATA) <= SNMP_MAX_VALUE_SIZE); + err = snmp_append_outbound_varbind(&request->outbound_pbuf_stream, vb); + + if (err == ERR_BUF) { + request->error_status = SNMP_ERR_TOOBIG; + } else if (err != ERR_OK) { + request->error_status = SNMP_ERR_GENERROR; + } + } else { + request->error_status = SNMP_ERR_GENERROR; + } + + if (node_instance.release_instance != NULL) { + node_instance.release_instance(&node_instance); + } + } +} + + +/** + * Service an internal or external event for SNMP GET. + * + * @param request points to the associated message process state + */ +static err_t +snmp_process_get_request(struct snmp_request *request) +{ + snmp_vb_enumerator_err_t err; + struct snmp_varbind vb; + vb.value = request->value_buffer; + + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP get request\n")); + + while (request->error_status == SNMP_ERR_NOERROR) { + err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); + if (err == SNMP_VB_ENUMERATOR_ERR_OK) { + if ((vb.type == SNMP_ASN1_TYPE_NULL) && (vb.value_len == 0)) { + snmp_process_varbind(request, &vb, 0); + } else { + request->error_status = SNMP_ERR_GENERROR; + } + } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { + /* no more varbinds in request */ + break; + } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { + /* malformed ASN.1, don't answer */ + return ERR_ARG; + } else { + request->error_status = SNMP_ERR_GENERROR; + } + } + + return ERR_OK; +} + +/** + * Service an internal or external event for SNMP GET. + * + * @param request points to the associated message process state + */ +static err_t +snmp_process_getnext_request(struct snmp_request *request) +{ + snmp_vb_enumerator_err_t err; + struct snmp_varbind vb; + vb.value = request->value_buffer; + + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP get-next request\n")); + + while (request->error_status == SNMP_ERR_NOERROR) { + err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); + if (err == SNMP_VB_ENUMERATOR_ERR_OK) { + if ((vb.type == SNMP_ASN1_TYPE_NULL) && (vb.value_len == 0)) { + snmp_process_varbind(request, &vb, 1); + } else { + request->error_status = SNMP_ERR_GENERROR; + } + } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { + /* no more varbinds in request */ + break; + } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { + /* malformed ASN.1, don't answer */ + return ERR_ARG; + } else { + request->error_status = SNMP_ERR_GENERROR; + } + } + + return ERR_OK; +} + +/** + * Service an internal or external event for SNMP GETBULKT. + * + * @param request points to the associated message process state + */ +static err_t +snmp_process_getbulk_request(struct snmp_request *request) +{ + snmp_vb_enumerator_err_t err; + s32_t non_repeaters = request->non_repeaters; + s32_t repetitions; + u16_t repetition_offset = 0; + struct snmp_varbind_enumerator repetition_varbind_enumerator; + struct snmp_varbind vb; + vb.value = request->value_buffer; + + if (SNMP_LWIP_GETBULK_MAX_REPETITIONS > 0) { + repetitions = LWIP_MIN(request->max_repetitions, SNMP_LWIP_GETBULK_MAX_REPETITIONS); + } else { + repetitions = request->max_repetitions; + } + + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP get-bulk request\n")); + + /* process non repeaters and first repetition */ + while (request->error_status == SNMP_ERR_NOERROR) { + if (non_repeaters == 0) { + repetition_offset = request->outbound_pbuf_stream.offset; + + if (repetitions == 0) { + /* do not resolve repeaters when repetitions is set to 0 */ + break; + } + repetitions--; + } + + err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); + if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { + /* no more varbinds in request */ + break; + } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { + /* malformed ASN.1, don't answer */ + return ERR_ARG; + } else if ((err != SNMP_VB_ENUMERATOR_ERR_OK) || (vb.type != SNMP_ASN1_TYPE_NULL) || (vb.value_len != 0)) { + request->error_status = SNMP_ERR_GENERROR; + } else { + snmp_process_varbind(request, &vb, 1); + non_repeaters--; + } + } + + /* process repetitions > 1 */ + while ((request->error_status == SNMP_ERR_NOERROR) && (repetitions > 0) && (request->outbound_pbuf_stream.offset != repetition_offset)) { + + u8_t all_endofmibview = 1; + + snmp_vb_enumerator_init(&repetition_varbind_enumerator, request->outbound_pbuf, repetition_offset, request->outbound_pbuf_stream.offset - repetition_offset); + repetition_offset = request->outbound_pbuf_stream.offset; /* for next loop */ + + while (request->error_status == SNMP_ERR_NOERROR) { + vb.value = NULL; /* do NOT decode value (we enumerate outbound buffer here, so all varbinds have values assigned) */ + err = snmp_vb_enumerator_get_next(&repetition_varbind_enumerator, &vb); + if (err == SNMP_VB_ENUMERATOR_ERR_OK) { + vb.value = request->value_buffer; + snmp_process_varbind(request, &vb, 1); + + if (request->error_status != SNMP_ERR_NOERROR) { + /* already set correct error-index (here it cannot be taken from inbound varbind enumerator) */ + request->error_index = request->non_repeaters + repetition_varbind_enumerator.varbind_count; + } else if (vb.type != (SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTEXT_VARBIND_END_OF_MIB_VIEW)) { + all_endofmibview = 0; + } + } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { + /* no more varbinds in request */ + break; + } else { + LWIP_DEBUGF(SNMP_DEBUG, ("Very strange, we cannot parse the varbind output that we created just before!")); + request->error_status = SNMP_ERR_GENERROR; + request->error_index = request->non_repeaters + repetition_varbind_enumerator.varbind_count; + } + } + + if ((request->error_status == SNMP_ERR_NOERROR) && all_endofmibview) { + /* stop when all varbinds in a loop return EndOfMibView */ + break; + } + + repetitions--; + } + + if (request->error_status == SNMP_ERR_TOOBIG) { + /* for GetBulk it is ok, if not all requested variables fit into the response -> just return the varbinds added so far */ + request->error_status = SNMP_ERR_NOERROR; + } + + return ERR_OK; +} + +/** + * Service an internal or external event for SNMP SET. + * + * @param request points to the associated message process state + */ +static err_t +snmp_process_set_request(struct snmp_request *request) +{ + snmp_vb_enumerator_err_t err; + struct snmp_varbind vb; + vb.value = request->value_buffer; + + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP set request\n")); + + /* perform set test on all objects */ + while (request->error_status == SNMP_ERR_NOERROR) { + err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); + if (err == SNMP_VB_ENUMERATOR_ERR_OK) { + struct snmp_node_instance node_instance; + memset(&node_instance, 0, sizeof(node_instance)); + + request->error_status = snmp_get_node_instance_from_oid(vb.oid.id, vb.oid.len, &node_instance); + if (request->error_status == SNMP_ERR_NOERROR) { + if (node_instance.asn1_type != vb.type) { + request->error_status = SNMP_ERR_WRONGTYPE; + } else if (((node_instance.access & SNMP_NODE_INSTANCE_ACCESS_WRITE) != SNMP_NODE_INSTANCE_ACCESS_WRITE) || (node_instance.set_value == NULL)) { + request->error_status = SNMP_ERR_NOTWRITABLE; + } else { + if (node_instance.set_test != NULL) { + request->error_status = node_instance.set_test(&node_instance, vb.value_len, vb.value); + } + } + + if (node_instance.release_instance != NULL) { + node_instance.release_instance(&node_instance); + } + } + } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { + /* no more varbinds in request */ + break; + } else if (err == SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH) { + request->error_status = SNMP_ERR_WRONGLENGTH; + } else if (err == SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) { + /* malformed ASN.1, don't answer */ + return ERR_ARG; + } else { + request->error_status = SNMP_ERR_GENERROR; + } + } + + /* perform real set operation on all objects */ + if (request->error_status == SNMP_ERR_NOERROR) { + snmp_vb_enumerator_init(&request->inbound_varbind_enumerator, request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len); + while (request->error_status == SNMP_ERR_NOERROR) { + err = snmp_vb_enumerator_get_next(&request->inbound_varbind_enumerator, &vb); + if (err == SNMP_VB_ENUMERATOR_ERR_OK) { + struct snmp_node_instance node_instance; + memset(&node_instance, 0, sizeof(node_instance)); + request->error_status = snmp_get_node_instance_from_oid(vb.oid.id, vb.oid.len, &node_instance); + if (request->error_status == SNMP_ERR_NOERROR) { + if (node_instance.set_value(&node_instance, vb.value_len, vb.value) != SNMP_ERR_NOERROR) { + if (request->inbound_varbind_enumerator.varbind_count == 1) { + request->error_status = SNMP_ERR_COMMITFAILED; + } else { + /* we cannot undo the set operations done so far */ + request->error_status = SNMP_ERR_UNDOFAILED; + } + } + + if (node_instance.release_instance != NULL) { + node_instance.release_instance(&node_instance); + } + } + } else if (err == SNMP_VB_ENUMERATOR_ERR_EOVB) { + /* no more varbinds in request */ + break; + } else { + /* first time enumerating varbinds work but second time not, although nothing should have changed in between ??? */ + request->error_status = SNMP_ERR_GENERROR; + } + } + } + + return ERR_OK; +} + +#define PARSE_EXEC(code, retValue) \ + if ((code) != ERR_OK) { \ + LWIP_DEBUGF(SNMP_DEBUG, ("Malformed ASN.1 detected.\n")); \ + snmp_stats.inasnparseerrs++; \ + return retValue; \ + } + +#define PARSE_ASSERT(cond, retValue) \ + if (!(cond)) { \ + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP parse assertion failed!: " # cond)); \ + snmp_stats.inasnparseerrs++; \ + return retValue; \ + } + +#define BUILD_EXEC(code, retValue) \ + if ((code) != ERR_OK) { \ + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP error during creation of outbound frame!: " # code)); \ + return retValue; \ + } + +#define IF_PARSE_EXEC(code) PARSE_EXEC(code, ERR_ARG) +#define IF_PARSE_ASSERT(code) PARSE_ASSERT(code, ERR_ARG) + +/** + * Checks and decodes incoming SNMP message header, logs header errors. + * + * @param request points to the current message request state return + * @return + * - ERR_OK SNMP header is sane and accepted + * - ERR_VAL SNMP header is either malformed or rejected + */ +static err_t +snmp_parse_inbound_frame(struct snmp_request *request) +{ + struct snmp_pbuf_stream pbuf_stream; + struct snmp_asn1_tlv tlv; + s32_t parent_tlv_value_len; + s32_t s32_value; + err_t err; +#if LWIP_SNMP_V3 + snmpv3_auth_algo_t auth; + snmpv3_priv_algo_t priv; +#endif + + IF_PARSE_EXEC(snmp_pbuf_stream_init(&pbuf_stream, request->inbound_pbuf, 0, request->inbound_pbuf->tot_len)); + + /* decode main container consisting of version, community and PDU */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_SEQUENCE) && (tlv.value_len == pbuf_stream.length)); + parent_tlv_value_len = tlv.value_len; + + /* decode version */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); + + if (((s32_value != SNMP_VERSION_1) && + (s32_value != SNMP_VERSION_2c) +#if LWIP_SNMP_V3 + && (s32_value != SNMP_VERSION_3) +#endif + ) +#if LWIP_SNMP_CONFIGURE_VERSIONS + || (!snmp_version_enabled(s32_value)) +#endif + ) { + /* unsupported SNMP version */ + snmp_stats.inbadversions++; + return ERR_ARG; + } + request->version = (u8_t)s32_value; + +#if LWIP_SNMP_V3 + if (request->version == SNMP_VERSION_3) { + u16_t u16_value; + u16_t inbound_msgAuthenticationParameters_offset; + + /* SNMPv3 doesn't use communities */ + /* @todo: Differentiate read/write access */ + strncpy((char *)request->community, snmp_community, SNMP_MAX_COMMUNITY_STR_LEN); + request->community[SNMP_MAX_COMMUNITY_STR_LEN] = 0; /* ensure NULL termination (strncpy does NOT guarantee it!) */ + request->community_strlen = (u16_t)strnlen((char *)request->community, SNMP_MAX_COMMUNITY_STR_LEN); + + /* RFC3414 globalData */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_SEQUENCE); + parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + /* decode msgID */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); + request->msg_id = s32_value; + + /* decode msgMaxSize */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); + request->msg_max_size = s32_value; + + /* decode msgFlags */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); + request->msg_flags = (u8_t)s32_value; + + /* decode msgSecurityModel */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); + request->msg_security_model = s32_value; + + /* RFC3414 msgSecurityParameters + * The User-based Security Model defines the contents of the OCTET + * STRING as a SEQUENCE. + * + * We skip the protective dummy OCTET STRING header + * to access the SEQUENCE header. + */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + /* msgSecurityParameters SEQUENCE header */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_SEQUENCE); + parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + /* decode msgAuthoritativeEngineID */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_authoritative_engine_id, + &u16_value, SNMP_V3_MAX_ENGINE_ID_LENGTH)); + request->msg_authoritative_engine_id_len = (u8_t)u16_value; + + /* msgAuthoritativeEngineBoots */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->msg_authoritative_engine_boots)); + + /* msgAuthoritativeEngineTime */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->msg_authoritative_engine_time)); + + /* msgUserName */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_user_name, + &u16_value, SNMP_V3_MAX_USER_LENGTH)); + request->msg_user_name_len = (u8_t)u16_value; + + /* msgAuthenticationParameters */ + memset(request->msg_authentication_parameters, 0, SNMP_V3_MAX_AUTH_PARAM_LENGTH); + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + /* Remember position */ + inbound_msgAuthenticationParameters_offset = pbuf_stream.offset; + LWIP_UNUSED_ARG(inbound_msgAuthenticationParameters_offset); + /* Read auth parameters */ + /* IF_PARSE_ASSERT(tlv.value_len <= SNMP_V3_MAX_AUTH_PARAM_LENGTH); */ + IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_authentication_parameters, + &u16_value, tlv.value_len)); + request->msg_authentication_parameters_len = (u8_t)u16_value; + + /* msgPrivacyParameters */ + memset(request->msg_privacy_parameters, 0, SNMP_V3_MAX_PRIV_PARAM_LENGTH); + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->msg_privacy_parameters, + &u16_value, SNMP_V3_MAX_PRIV_PARAM_LENGTH)); + request->msg_privacy_parameters_len = (u8_t)u16_value; + + /* validate securityParameters here (do this after decoding because we don't want to increase other counters for wrong frames) + * 1) securityParameters was correctly serialized if we reach here. + * 2) securityParameters are already cached. + * 3) if msgAuthoritativeEngineID is unknown, zero-length or too long: + b) https://tools.ietf.org/html/rfc3414#section-7 + */ + { + const char *eid; + u8_t eid_len; + + snmpv3_get_engine_id(&eid, &eid_len); + + if ((request->msg_authoritative_engine_id_len == 0) || + (request->msg_authoritative_engine_id_len != eid_len) || + (memcmp(eid, request->msg_authoritative_engine_id, eid_len) != 0)) { + snmp_stats.unknownengineids++; + request->msg_flags = 0; /* noauthnopriv */ + request->error_status = SNMP_ERR_UNKNOWN_ENGINEID; + return ERR_OK; + } + } + + /* 4) verify username */ + if (snmpv3_get_user((char *)request->msg_user_name, &auth, NULL, &priv, NULL)) { + snmp_stats.unknownusernames++; + request->msg_flags = 0; /* noauthnopriv */ + request->error_status = SNMP_ERR_UNKNOWN_SECURITYNAME; + return ERR_OK; + } + + /* 5) verify security level */ + switch (request->msg_flags & (SNMP_V3_AUTH_FLAG | SNMP_V3_PRIV_FLAG)) { + case SNMP_V3_NOAUTHNOPRIV: + if ((auth != SNMP_V3_AUTH_ALGO_INVAL) || (priv != SNMP_V3_PRIV_ALGO_INVAL)) { + /* Invalid security level for user */ + snmp_stats.unsupportedseclevels++; + request->msg_flags = SNMP_V3_NOAUTHNOPRIV; + request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; + return ERR_OK; + } + break; +#if LWIP_SNMP_V3_CRYPTO + case SNMP_V3_AUTHNOPRIV: + if ((auth == SNMP_V3_AUTH_ALGO_INVAL) || (priv != SNMP_V3_PRIV_ALGO_INVAL)) { + /* Invalid security level for user */ + snmp_stats.unsupportedseclevels++; + request->msg_flags = SNMP_V3_NOAUTHNOPRIV; + request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; + return ERR_OK; + } + break; + case SNMP_V3_AUTHPRIV: + if ((auth == SNMP_V3_AUTH_ALGO_INVAL) || (priv == SNMP_V3_PRIV_ALGO_INVAL)) { + /* Invalid security level for user */ + snmp_stats.unsupportedseclevels++; + request->msg_flags = SNMP_V3_NOAUTHNOPRIV; + request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; + return ERR_OK; + } + break; +#endif + default: + snmp_stats.unsupportedseclevels++; + request->msg_flags = SNMP_V3_NOAUTHNOPRIV; + request->error_status = SNMP_ERR_UNSUPPORTED_SECLEVEL; + return ERR_OK; + } + + /* 6) if securitylevel specifies authentication, authenticate message. */ +#if LWIP_SNMP_V3_CRYPTO + if (request->msg_flags & SNMP_V3_AUTH_FLAG) { + const u8_t zero_arr[SNMP_V3_MAX_AUTH_PARAM_LENGTH] = { 0 }; + u8_t key[20]; + u8_t hmac[LWIP_MAX(SNMP_V3_SHA_LEN, SNMP_V3_MD5_LEN)]; + struct snmp_pbuf_stream auth_stream; + + if (request->msg_authentication_parameters_len > SNMP_V3_MAX_AUTH_PARAM_LENGTH) { + snmp_stats.wrongdigests++; + request->msg_flags = SNMP_V3_NOAUTHNOPRIV; + request->error_status = SNMP_ERR_AUTHORIZATIONERROR; + return ERR_OK; + } + + /* Rewind stream */ + IF_PARSE_EXEC(snmp_pbuf_stream_init(&auth_stream, request->inbound_pbuf, 0, request->inbound_pbuf->tot_len)); + IF_PARSE_EXEC(snmp_pbuf_stream_seek_abs(&auth_stream, inbound_msgAuthenticationParameters_offset)); + /* Set auth parameters to zero for verification */ + IF_PARSE_EXEC(snmp_asn1_enc_raw(&auth_stream, zero_arr, request->msg_authentication_parameters_len)); + + /* Verify authentication */ + IF_PARSE_EXEC(snmp_pbuf_stream_init(&auth_stream, request->inbound_pbuf, 0, request->inbound_pbuf->tot_len)); + + IF_PARSE_EXEC(snmpv3_get_user((char *)request->msg_user_name, &auth, key, NULL, NULL)); + IF_PARSE_EXEC(snmpv3_auth(&auth_stream, request->inbound_pbuf->tot_len, key, auth, hmac)); + + if (memcmp(request->msg_authentication_parameters, hmac, SNMP_V3_MAX_AUTH_PARAM_LENGTH)) { + snmp_stats.wrongdigests++; + request->msg_flags = SNMP_V3_NOAUTHNOPRIV; + request->error_status = SNMP_ERR_AUTHORIZATIONERROR; + return ERR_OK; + } + + /* 7) if securitylevel specifies authentication, verify engineboots, enginetime and lastenginetime */ + { + s32_t boots = snmpv3_get_engine_boots_internal(); + if ((request->msg_authoritative_engine_boots != boots) || (boots == 2147483647UL)) { + snmp_stats.notintimewindows++; + request->msg_flags = SNMP_V3_AUTHNOPRIV; + request->error_status = SNMP_ERR_NOTINTIMEWINDOW; + return ERR_OK; + } + } + { + s32_t time = snmpv3_get_engine_time_internal(); + if (request->msg_authoritative_engine_time > (time + 150)) { + snmp_stats.notintimewindows++; + request->msg_flags = SNMP_V3_AUTHNOPRIV; + request->error_status = SNMP_ERR_NOTINTIMEWINDOW; + return ERR_OK; + } else if (time > 150) { + if (request->msg_authoritative_engine_time < (time - 150)) { + snmp_stats.notintimewindows++; + request->msg_flags = SNMP_V3_AUTHNOPRIV; + request->error_status = SNMP_ERR_NOTINTIMEWINDOW; + return ERR_OK; + } + } + } + } +#endif + + /* 8) if securitylevel specifies privacy, decrypt message. */ +#if LWIP_SNMP_V3_CRYPTO + if (request->msg_flags & SNMP_V3_PRIV_FLAG) { + /* Decrypt message */ + + u8_t key[20]; + + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmpv3_get_user((char *)request->msg_user_name, NULL, NULL, &priv, key)); + if (snmpv3_crypt(&pbuf_stream, tlv.value_len, key, + request->msg_privacy_parameters, request->msg_authoritative_engine_boots, + request->msg_authoritative_engine_time, priv, SNMP_V3_PRIV_MODE_DECRYPT) != ERR_OK) { + snmp_stats.decryptionerrors++; + request->msg_flags = SNMP_V3_AUTHNOPRIV; + request->error_status = SNMP_ERR_DECRYIPTION_ERROR; + return ERR_OK; + } + } +#endif + /* 9) calculate max size of scoped pdu? + * 10) securityname for user is retrieved from usertable? + * 11) security data is cached? + * 12) + */ + + /* Scoped PDU + * Encryption context + */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_SEQUENCE); + parent_tlv_value_len -= SNMP_ASN1_TLV_HDR_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + /* contextEngineID */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->context_engine_id, + &u16_value, SNMP_V3_MAX_ENGINE_ID_LENGTH)); + request->context_engine_id_len = (u8_t)u16_value; + /* TODO: do we need to verify this contextengineid too? */ + + /* contextName */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->context_name, + &u16_value, SNMP_V3_MAX_ENGINE_ID_LENGTH)); + request->context_name_len = (u8_t)u16_value; + /* TODO: do we need to verify this contextname too? */ + } else +#endif + { + /* decode community */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_OCTET_STRING); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + err = snmp_asn1_dec_raw(&pbuf_stream, tlv.value_len, request->community, &request->community_strlen, SNMP_MAX_COMMUNITY_STR_LEN); + if (err == ERR_MEM) { + /* community string does not fit in our buffer -> its too long -> its invalid */ + request->community_strlen = 0; + snmp_pbuf_stream_seek(&pbuf_stream, tlv.value_len); + } else { + IF_PARSE_ASSERT(err == ERR_OK); + } + /* add zero terminator */ + request->community[request->community_strlen] = 0; + } + + /* decode PDU type (next container level) */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.value_len <= pbuf_stream.length); + request->inbound_padding_len = pbuf_stream.length - tlv.value_len; + parent_tlv_value_len = tlv.value_len; + + /* validate PDU type */ + switch (tlv.type) { + case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_REQ): + /* GetRequest PDU */ + snmp_stats.ingetrequests++; + break; + case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_NEXT_REQ): + /* GetNextRequest PDU */ + snmp_stats.ingetnexts++; + break; + case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ): + /* GetBulkRequest PDU */ + if (request->version < SNMP_VERSION_2c) { + /* RFC2089: invalid, drop packet */ + return ERR_ARG; + } + break; + case (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_SET_REQ): + /* SetRequest PDU */ + snmp_stats.insetrequests++; + break; + default: + /* unsupported input PDU for this agent (no parse error) */ + LWIP_DEBUGF(SNMP_DEBUG, ("Unknown/Invalid SNMP PDU type received: %d", tlv.type)); \ + return ERR_ARG; + } + request->request_type = tlv.type & SNMP_ASN1_DATATYPE_MASK; + request->request_out_type = (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_GET_RESP); + + /* validate community (do this after decoding PDU type because we don't want to increase 'inbadcommunitynames' for wrong frame types */ + if (request->community_strlen == 0) { + /* community string was too long or really empty*/ + snmp_stats.inbadcommunitynames++; + snmp_authfail_trap(); + return ERR_ARG; + } else if (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { + if (snmp_community_write[0] == 0) { + /* our write community is empty, that means all our objects are readonly */ + request->error_status = SNMP_ERR_NOTWRITABLE; + request->error_index = 1; + } else if (strncmp(snmp_community_write, (const char *)request->community, SNMP_MAX_COMMUNITY_STR_LEN) != 0) { + /* community name does not match */ + snmp_stats.inbadcommunitynames++; + snmp_authfail_trap(); + return ERR_ARG; + } + } else { + if (strncmp(snmp_community, (const char *)request->community, SNMP_MAX_COMMUNITY_STR_LEN) != 0) { + /* community name does not match */ + snmp_stats.inbadcommunitynames++; + snmp_authfail_trap(); + return ERR_ARG; + } + } + + /* decode request ID */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->request_id)); + + /* decode error status / non-repeaters */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + if (request->request_type == SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ) { + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->non_repeaters)); + if (request->non_repeaters < 0) { + /* RFC 1905, 4.2.3 */ + request->non_repeaters = 0; + } + } else { + /* only check valid value, don't touch 'request->error_status', maybe a response error status was already set to above; */ + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &s32_value)); + IF_PARSE_ASSERT(s32_value == SNMP_ERR_NOERROR); + } + + /* decode error index / max-repetitions */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT(tlv.type == SNMP_ASN1_TYPE_INTEGER); + parent_tlv_value_len -= SNMP_ASN1_TLV_LENGTH(tlv); + IF_PARSE_ASSERT(parent_tlv_value_len > 0); + + if (request->request_type == SNMP_ASN1_CONTEXT_PDU_GET_BULK_REQ) { + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->max_repetitions)); + if (request->max_repetitions < 0) { + /* RFC 1905, 4.2.3 */ + request->max_repetitions = 0; + } + } else { + IF_PARSE_EXEC(snmp_asn1_dec_s32t(&pbuf_stream, tlv.value_len, &request->error_index)); + IF_PARSE_ASSERT(s32_value == 0); + } + + /* decode varbind-list type (next container level) */ + IF_PARSE_EXEC(snmp_asn1_dec_tlv(&pbuf_stream, &tlv)); + IF_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_SEQUENCE) && (tlv.value_len <= pbuf_stream.length)); + + request->inbound_varbind_offset = pbuf_stream.offset; + request->inbound_varbind_len = pbuf_stream.length - request->inbound_padding_len; + snmp_vb_enumerator_init(&(request->inbound_varbind_enumerator), request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len); + + return ERR_OK; +} + +#define OF_BUILD_EXEC(code) BUILD_EXEC(code, ERR_ARG) + +static err_t +snmp_prepare_outbound_frame(struct snmp_request *request) +{ + struct snmp_asn1_tlv tlv; + struct snmp_pbuf_stream *pbuf_stream = &(request->outbound_pbuf_stream); + + /* try allocating pbuf(s) for maximum response size */ + request->outbound_pbuf = pbuf_alloc(PBUF_TRANSPORT, 1472, PBUF_RAM); + if (request->outbound_pbuf == NULL) { + return ERR_MEM; + } + + snmp_pbuf_stream_init(pbuf_stream, request->outbound_pbuf, 0, request->outbound_pbuf->tot_len); + + /* 'Message' sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, 0); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + + /* version */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); + snmp_asn1_enc_s32t_cnt(request->version, &tlv.value_len); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + OF_BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->version) ); + +#if LWIP_SNMP_V3 + if (request->version < SNMP_VERSION_3) { +#endif + /* community */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->community_strlen); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + OF_BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, request->community, request->community_strlen) ); +#if LWIP_SNMP_V3 + } else { + const char *id; + + /* globalData */ + request->outbound_msg_global_data_offset = pbuf_stream->offset; + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, 0); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + + /* msgID */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); + snmp_asn1_enc_s32t_cnt(request->msg_id, &tlv.value_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_id)); + + /* msgMaxSize */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); + snmp_asn1_enc_s32t_cnt(request->msg_max_size, &tlv.value_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_max_size)); + + /* msgFlags */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, 1); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, &request->msg_flags, 1)); + + /* msgSecurityModel */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); + snmp_asn1_enc_s32t_cnt(request->msg_security_model, &tlv.value_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_security_model)); + + /* end of msgGlobalData */ + request->outbound_msg_global_data_end = pbuf_stream->offset; + + /* msgSecurityParameters */ + request->outbound_msg_security_parameters_str_offset = pbuf_stream->offset; + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, 0); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + + request->outbound_msg_security_parameters_seq_offset = pbuf_stream->offset; + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, 0); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + + /* msgAuthoritativeEngineID */ + snmpv3_get_engine_id(&id, &request->msg_authoritative_engine_id_len); + MEMCPY(request->msg_authoritative_engine_id, id, request->msg_authoritative_engine_id_len); + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->msg_authoritative_engine_id_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_authoritative_engine_id, request->msg_authoritative_engine_id_len)); + + request->msg_authoritative_engine_time = snmpv3_get_engine_time(); + request->msg_authoritative_engine_boots = snmpv3_get_engine_boots(); + + /* msgAuthoritativeEngineBoots */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); + snmp_asn1_enc_s32t_cnt(request->msg_authoritative_engine_boots, &tlv.value_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_authoritative_engine_boots)); + + /* msgAuthoritativeEngineTime */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); + snmp_asn1_enc_s32t_cnt(request->msg_authoritative_engine_time, &tlv.value_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->msg_authoritative_engine_time)); + + /* msgUserName */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->msg_user_name_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_user_name, request->msg_user_name_len)); + +#if LWIP_SNMP_V3_CRYPTO + /* msgAuthenticationParameters */ + if (request->msg_flags & SNMP_V3_AUTH_FLAG) { + memset(request->msg_authentication_parameters, 0, SNMP_V3_MAX_AUTH_PARAM_LENGTH); + request->outbound_msg_authentication_parameters_offset = pbuf_stream->offset; + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, SNMP_V3_MAX_AUTH_PARAM_LENGTH); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_authentication_parameters, SNMP_V3_MAX_AUTH_PARAM_LENGTH)); + } else +#endif + { + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, 0); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + } + +#if LWIP_SNMP_V3_CRYPTO + /* msgPrivacyParameters */ + if (request->msg_flags & SNMP_V3_PRIV_FLAG) { + snmpv3_build_priv_param(request->msg_privacy_parameters); + + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, SNMP_V3_MAX_PRIV_PARAM_LENGTH); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->msg_privacy_parameters, SNMP_V3_MAX_PRIV_PARAM_LENGTH)); + } else +#endif + { + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, 0); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + } + + /* End of msgSecurityParameters, so we can calculate the length of this sequence later */ + request->outbound_msg_security_parameters_end = pbuf_stream->offset; + +#if LWIP_SNMP_V3_CRYPTO + /* For encryption we have to encapsulate the payload in an octet string */ + if (request->msg_flags & SNMP_V3_PRIV_FLAG) { + request->outbound_scoped_pdu_string_offset = pbuf_stream->offset; + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 3, 0); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + } +#endif + /* Scoped PDU + * Encryption context + */ + request->outbound_scoped_pdu_seq_offset = pbuf_stream->offset; + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, 0); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + + /* contextEngineID */ + snmpv3_get_engine_id(&id, &request->context_engine_id_len); + MEMCPY(request->context_engine_id, id, request->context_engine_id_len); + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->context_engine_id_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->context_engine_id, request->context_engine_id_len)); + + /* contextName */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, request->context_name_len); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, request->context_name, request->context_name_len)); + } +#endif + + /* 'PDU' sequence */ + request->outbound_pdu_offset = pbuf_stream->offset; + SNMP_ASN1_SET_TLV_PARAMS(tlv, request->request_out_type, 3, 0); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + + /* request ID */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); + snmp_asn1_enc_s32t_cnt(request->request_id, &tlv.value_len); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + OF_BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, request->request_id) ); + + /* error status */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + request->outbound_error_status_offset = pbuf_stream->offset; + OF_BUILD_EXEC( snmp_pbuf_stream_write(pbuf_stream, 0) ); + + /* error index */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 1); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + request->outbound_error_index_offset = pbuf_stream->offset; + OF_BUILD_EXEC( snmp_pbuf_stream_write(pbuf_stream, 0) ); + + /* 'VarBindList' sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, 0); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + + request->outbound_varbind_offset = pbuf_stream->offset; + + return ERR_OK; +} + +/** Calculate the length of a varbind list */ +err_t +snmp_varbind_length(struct snmp_varbind *varbind, struct snmp_varbind_len *len) +{ + /* calculate required lengths */ + snmp_asn1_enc_oid_cnt(varbind->oid.id, varbind->oid.len, &len->oid_value_len); + snmp_asn1_enc_length_cnt(len->oid_value_len, &len->oid_len_len); + + if (varbind->value_len == 0) { + len->value_value_len = 0; + } else if (varbind->value_len & SNMP_GET_VALUE_RAW_DATA) { + len->value_value_len = varbind->value_len & (~SNMP_GET_VALUE_RAW_DATA); + } else { + switch (varbind->type) { + case SNMP_ASN1_TYPE_INTEGER: + if (varbind->value_len != sizeof (s32_t)) { + return ERR_VAL; + } + snmp_asn1_enc_s32t_cnt(*((s32_t *) varbind->value), &len->value_value_len); + break; + case SNMP_ASN1_TYPE_COUNTER: + case SNMP_ASN1_TYPE_GAUGE: + case SNMP_ASN1_TYPE_TIMETICKS: + if (varbind->value_len != sizeof (u32_t)) { + return ERR_VAL; + } + snmp_asn1_enc_u32t_cnt(*((u32_t *) varbind->value), &len->value_value_len); + break; + case SNMP_ASN1_TYPE_OCTET_STRING: + case SNMP_ASN1_TYPE_IPADDR: + case SNMP_ASN1_TYPE_OPAQUE: + len->value_value_len = varbind->value_len; + break; + case SNMP_ASN1_TYPE_NULL: + if (varbind->value_len != 0) { + return ERR_VAL; + } + len->value_value_len = 0; + break; + case SNMP_ASN1_TYPE_OBJECT_ID: + if ((varbind->value_len & 0x03) != 0) { + return ERR_VAL; + } + snmp_asn1_enc_oid_cnt((u32_t *) varbind->value, varbind->value_len >> 2, &len->value_value_len); + break; +#if LWIP_HAVE_INT64 + case SNMP_ASN1_TYPE_COUNTER64: + if (varbind->value_len != sizeof(u64_t)) { + return ERR_VAL; + } + snmp_asn1_enc_u64t_cnt(*(u64_t *)varbind->value, &len->value_value_len); + break; +#endif + default: + /* unsupported type */ + return ERR_VAL; + } + } + snmp_asn1_enc_length_cnt(len->value_value_len, &len->value_len_len); + + len->vb_value_len = 1 + len->oid_len_len + len->oid_value_len + 1 + len->value_len_len + len->value_value_len; + snmp_asn1_enc_length_cnt(len->vb_value_len, &len->vb_len_len); + + return ERR_OK; +} + +#define OVB_BUILD_EXEC(code) BUILD_EXEC(code, ERR_ARG) + +err_t +snmp_append_outbound_varbind(struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbind) +{ + struct snmp_asn1_tlv tlv; + struct snmp_varbind_len len; + err_t err; + + err = snmp_varbind_length(varbind, &len); + + if (err != ERR_OK) { + return err; + } + + /* check length already before adding first data because in case of GetBulk, + * data added so far is returned and therefore no partial data shall be added + */ + if ((1 + len.vb_len_len + len.vb_value_len) > pbuf_stream->length) { + return ERR_BUF; + } + + /* 'VarBind' sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, len.vb_len_len, len.vb_value_len); + OVB_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + + /* VarBind OID */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OBJECT_ID, len.oid_len_len, len.oid_value_len); + OVB_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + OVB_BUILD_EXEC(snmp_asn1_enc_oid(pbuf_stream, varbind->oid.id, varbind->oid.len)); + + /* VarBind value */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, varbind->type, len.value_len_len, len.value_value_len); + OVB_BUILD_EXEC(snmp_ans1_enc_tlv(pbuf_stream, &tlv)); + + if (len.value_value_len > 0) { + if (varbind->value_len & SNMP_GET_VALUE_RAW_DATA) { + OVB_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, (u8_t *) varbind->value, len.value_value_len)); + } else { + switch (varbind->type) { + case SNMP_ASN1_TYPE_INTEGER: + OVB_BUILD_EXEC(snmp_asn1_enc_s32t(pbuf_stream, len.value_value_len, *((s32_t *) varbind->value))); + break; + case SNMP_ASN1_TYPE_COUNTER: + case SNMP_ASN1_TYPE_GAUGE: + case SNMP_ASN1_TYPE_TIMETICKS: + OVB_BUILD_EXEC(snmp_asn1_enc_u32t(pbuf_stream, len.value_value_len, *((u32_t *) varbind->value))); + break; + case SNMP_ASN1_TYPE_OCTET_STRING: + case SNMP_ASN1_TYPE_IPADDR: + case SNMP_ASN1_TYPE_OPAQUE: + OVB_BUILD_EXEC(snmp_asn1_enc_raw(pbuf_stream, (u8_t *) varbind->value, len.value_value_len)); + len.value_value_len = varbind->value_len; + break; + case SNMP_ASN1_TYPE_OBJECT_ID: + OVB_BUILD_EXEC(snmp_asn1_enc_oid(pbuf_stream, (u32_t *) varbind->value, varbind->value_len / sizeof (u32_t))); + break; +#if LWIP_HAVE_INT64 + case SNMP_ASN1_TYPE_COUNTER64: + OVB_BUILD_EXEC(snmp_asn1_enc_u64t(pbuf_stream, len.value_value_len, *(u64_t *) varbind->value)); + break; +#endif + default: + LWIP_ASSERT("Unknown variable type", 0); + break; + } + } + } + + return ERR_OK; +} + +static err_t +snmp_complete_outbound_frame(struct snmp_request *request) +{ + struct snmp_asn1_tlv tlv; + u16_t frame_size; + u8_t outbound_padding = 0; + + if (request->version == SNMP_VERSION_1) { + if (request->error_status != SNMP_ERR_NOERROR) { + /* map v2c error codes to v1 compliant error code (according to RFC 2089) */ + switch (request->error_status) { + /* mapping of implementation specific "virtual" error codes + * (during processing of frame we already stored them in error_status field, + * so no need to check all varbinds here for those exceptions as suggested by RFC) */ + case SNMP_ERR_NOSUCHINSTANCE: + case SNMP_ERR_NOSUCHOBJECT: + case SNMP_ERR_ENDOFMIBVIEW: + request->error_status = SNMP_ERR_NOSUCHNAME; + break; + /* mapping according to RFC */ + case SNMP_ERR_WRONGVALUE: + case SNMP_ERR_WRONGENCODING: + case SNMP_ERR_WRONGTYPE: + case SNMP_ERR_WRONGLENGTH: + case SNMP_ERR_INCONSISTENTVALUE: + request->error_status = SNMP_ERR_BADVALUE; + break; + case SNMP_ERR_NOACCESS: + case SNMP_ERR_NOTWRITABLE: + case SNMP_ERR_NOCREATION: + case SNMP_ERR_INCONSISTENTNAME: + case SNMP_ERR_AUTHORIZATIONERROR: + request->error_status = SNMP_ERR_NOSUCHNAME; + break; + case SNMP_ERR_RESOURCEUNAVAILABLE: + case SNMP_ERR_COMMITFAILED: + case SNMP_ERR_UNDOFAILED: + default: + request->error_status = SNMP_ERR_GENERROR; + break; + } + } + } else { + if (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { + /* map error codes to according to RFC 1905 (4.2.5. The SetRequest-PDU) return 'NotWritable' for unknown OIDs) */ + switch (request->error_status) { + case SNMP_ERR_NOSUCHINSTANCE: + case SNMP_ERR_NOSUCHOBJECT: + case SNMP_ERR_ENDOFMIBVIEW: + request->error_status = SNMP_ERR_NOTWRITABLE; + break; + default: + break; + } + } + + if (request->error_status >= SNMP_VARBIND_EXCEPTION_OFFSET) { + /* should never occur because v2 frames store exceptions directly inside varbinds and not as frame error_status */ + LWIP_DEBUGF(SNMP_DEBUG, ("snmp_complete_outbound_frame() > Found v2 request with varbind exception code stored as error status!\n")); + return ERR_ARG; + } + } + + if ((request->error_status != SNMP_ERR_NOERROR) || (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ)) { + /* all inbound vars are returned in response without any modification for error responses and successful set requests*/ + struct snmp_pbuf_stream inbound_stream; + OF_BUILD_EXEC( snmp_pbuf_stream_init(&inbound_stream, request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len) ); + OF_BUILD_EXEC( snmp_pbuf_stream_init(&(request->outbound_pbuf_stream), request->outbound_pbuf, request->outbound_varbind_offset, request->outbound_pbuf->tot_len - request->outbound_varbind_offset) ); + OF_BUILD_EXEC( snmp_pbuf_stream_writeto(&inbound_stream, &(request->outbound_pbuf_stream), 0) ); + } + + frame_size = request->outbound_pbuf_stream.offset; + +#if LWIP_SNMP_V3 && LWIP_SNMP_V3_CRYPTO + /* Calculate padding for encryption */ + if (request->version == SNMP_VERSION_3 && (request->msg_flags & SNMP_V3_PRIV_FLAG)) { + u8_t i; + outbound_padding = (8 - (u8_t)((frame_size - request->outbound_scoped_pdu_seq_offset) & 0x07)) & 0x07; + for (i = 0; i < outbound_padding; i++) { + OF_BUILD_EXEC( snmp_pbuf_stream_write(&request->outbound_pbuf_stream, 0) ); + } + } +#endif + + /* complete missing length in 'Message' sequence ; 'Message' tlv is located at the beginning (offset 0) */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, frame_size + outbound_padding - 1 - 3); /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ + OF_BUILD_EXEC( snmp_pbuf_stream_init(&(request->outbound_pbuf_stream), request->outbound_pbuf, 0, request->outbound_pbuf->tot_len) ); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv) ); + +#if LWIP_SNMP_V3 + if (request->version == SNMP_VERSION_3) { + /* complete missing length in 'globalData' sequence */ + /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, request->outbound_msg_global_data_end + - request->outbound_msg_global_data_offset - 1 - 1); + OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_msg_global_data_offset)); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); + + /* complete missing length in 'msgSecurityParameters' sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, request->outbound_msg_security_parameters_end + - request->outbound_msg_security_parameters_str_offset - 1 - 1); + OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_msg_security_parameters_str_offset)); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); + + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 1, request->outbound_msg_security_parameters_end + - request->outbound_msg_security_parameters_seq_offset - 1 - 1); + OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_msg_security_parameters_seq_offset)); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); + + /* complete missing length in scoped PDU sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, frame_size - request->outbound_scoped_pdu_seq_offset - 1 - 3); + OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_scoped_pdu_seq_offset)); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); + } +#endif + + /* complete missing length in 'PDU' sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, request->request_out_type, 3, + frame_size - request->outbound_pdu_offset - 1 - 3); /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ + OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_pdu_offset) ); + OF_BUILD_EXEC( snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv) ); + + /* process and encode final error status */ + if (request->error_status != 0) { + u16_t len; + snmp_asn1_enc_s32t_cnt(request->error_status, &len); + if (len != 1) { + /* error, we only reserved one byte for it */ + return ERR_ARG; + } + OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_error_status_offset) ); + OF_BUILD_EXEC( snmp_asn1_enc_s32t(&(request->outbound_pbuf_stream), len, request->error_status) ); + + /* for compatibility to v1, log statistics; in v2 (RFC 1907) these statistics are obsoleted */ + switch (request->error_status) { + case SNMP_ERR_TOOBIG: + snmp_stats.outtoobigs++; + break; + case SNMP_ERR_NOSUCHNAME: + snmp_stats.outnosuchnames++; + break; + case SNMP_ERR_BADVALUE: + snmp_stats.outbadvalues++; + break; + case SNMP_ERR_GENERROR: + default: + snmp_stats.outgenerrs++; + break; + } + + if (request->error_status == SNMP_ERR_TOOBIG) { + request->error_index = 0; /* defined by RFC 1157 */ + } else if (request->error_index == 0) { + /* set index to varbind where error occured (if not already set before, e.g. during GetBulk processing) */ + request->error_index = request->inbound_varbind_enumerator.varbind_count; + } + } else { + if (request->request_type == SNMP_ASN1_CONTEXT_PDU_SET_REQ) { + snmp_stats.intotalsetvars += request->inbound_varbind_enumerator.varbind_count; + } else { + snmp_stats.intotalreqvars += request->inbound_varbind_enumerator.varbind_count; + } + } + + /* encode final error index*/ + if (request->error_index != 0) { + u16_t len; + snmp_asn1_enc_s32t_cnt(request->error_index, &len); + if (len != 1) { + /* error, we only reserved one byte for it */ + return ERR_VAL; + } + OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_error_index_offset) ); + OF_BUILD_EXEC( snmp_asn1_enc_s32t(&(request->outbound_pbuf_stream), len, request->error_index) ); + } + + /* complete missing length in 'VarBindList' sequence ; 'VarBindList' tlv is located directly before varbind offset */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 3, frame_size - request->outbound_varbind_offset); + OF_BUILD_EXEC( snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_varbind_offset - 1 - 3) ); /* - type - length_len(fixed, see snmp_prepare_outbound_frame()) */ + OF_BUILD_EXEC( snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv) ); + + /* Authenticate response */ +#if LWIP_SNMP_V3 && LWIP_SNMP_V3_CRYPTO + /* Encrypt response */ + if (request->version == SNMP_VERSION_3 && (request->msg_flags & SNMP_V3_PRIV_FLAG)) { + u8_t key[20]; + snmpv3_priv_algo_t algo; + + /* complete missing length in PDU sequence */ + OF_BUILD_EXEC(snmp_pbuf_stream_init(&request->outbound_pbuf_stream, request->outbound_pbuf, 0, request->outbound_pbuf->tot_len)); + OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&(request->outbound_pbuf_stream), request->outbound_scoped_pdu_string_offset)); + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 3, frame_size + outbound_padding + - request->outbound_scoped_pdu_string_offset - 1 - 3); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(&(request->outbound_pbuf_stream), &tlv)); + + OF_BUILD_EXEC(snmpv3_get_user((char *)request->msg_user_name, NULL, NULL, &algo, key)); + + OF_BUILD_EXEC(snmpv3_crypt(&request->outbound_pbuf_stream, tlv.value_len, key, + request->msg_privacy_parameters, request->msg_authoritative_engine_boots, + request->msg_authoritative_engine_time, algo, SNMP_V3_PRIV_MODE_ENCRYPT)); + } + + if (request->version == SNMP_VERSION_3 && (request->msg_flags & SNMP_V3_AUTH_FLAG)) { + u8_t key[20]; + snmpv3_auth_algo_t algo; + u8_t hmac[20]; + + OF_BUILD_EXEC(snmpv3_get_user((char *)request->msg_user_name, &algo, key, NULL, NULL)); + OF_BUILD_EXEC(snmp_pbuf_stream_init(&(request->outbound_pbuf_stream), + request->outbound_pbuf, 0, request->outbound_pbuf->tot_len)); + OF_BUILD_EXEC(snmpv3_auth(&request->outbound_pbuf_stream, frame_size + outbound_padding, key, algo, hmac)); + + MEMCPY(request->msg_authentication_parameters, hmac, SNMP_V3_MAX_AUTH_PARAM_LENGTH); + OF_BUILD_EXEC(snmp_pbuf_stream_init(&request->outbound_pbuf_stream, + request->outbound_pbuf, 0, request->outbound_pbuf->tot_len)); + OF_BUILD_EXEC(snmp_pbuf_stream_seek_abs(&request->outbound_pbuf_stream, + request->outbound_msg_authentication_parameters_offset)); + + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 1, SNMP_V3_MAX_AUTH_PARAM_LENGTH); + OF_BUILD_EXEC(snmp_ans1_enc_tlv(&request->outbound_pbuf_stream, &tlv)); + OF_BUILD_EXEC(snmp_asn1_enc_raw(&request->outbound_pbuf_stream, + request->msg_authentication_parameters, SNMP_V3_MAX_AUTH_PARAM_LENGTH)); + } +#endif + + pbuf_realloc(request->outbound_pbuf, frame_size + outbound_padding); + + snmp_stats.outgetresponses++; + snmp_stats.outpkts++; + + return ERR_OK; +} + +static void +snmp_execute_write_callbacks(struct snmp_request *request) +{ + struct snmp_varbind_enumerator inbound_varbind_enumerator; + struct snmp_varbind vb; + + snmp_vb_enumerator_init(&inbound_varbind_enumerator, request->inbound_pbuf, request->inbound_varbind_offset, request->inbound_varbind_len); + vb.value = NULL; /* do NOT decode value (we enumerate outbound buffer here, so all varbinds have values assigned, which we don't need here) */ + + while (snmp_vb_enumerator_get_next(&inbound_varbind_enumerator, &vb) == SNMP_VB_ENUMERATOR_ERR_OK) { + snmp_write_callback(vb.oid.id, vb.oid.len, snmp_write_callback_arg); + } +} + + +/* ----------------------------------------------------------------------- */ +/* VarBind enumerator methods */ +/* ----------------------------------------------------------------------- */ + +void +snmp_vb_enumerator_init(struct snmp_varbind_enumerator *enumerator, struct pbuf *p, u16_t offset, u16_t length) +{ + snmp_pbuf_stream_init(&(enumerator->pbuf_stream), p, offset, length); + enumerator->varbind_count = 0; +} + +#define VB_PARSE_EXEC(code) PARSE_EXEC(code, SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) +#define VB_PARSE_ASSERT(code) PARSE_ASSERT(code, SNMP_VB_ENUMERATOR_ERR_ASN1ERROR) + +snmp_vb_enumerator_err_t +snmp_vb_enumerator_get_next(struct snmp_varbind_enumerator *enumerator, struct snmp_varbind *varbind) +{ + struct snmp_asn1_tlv tlv; + u16_t varbind_len; + err_t err; + + if (enumerator->pbuf_stream.length == 0) { + return SNMP_VB_ENUMERATOR_ERR_EOVB; + } + enumerator->varbind_count++; + + /* decode varbind itself (parent container of a varbind) */ + VB_PARSE_EXEC(snmp_asn1_dec_tlv(&(enumerator->pbuf_stream), &tlv)); + VB_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_SEQUENCE) && (tlv.value_len <= enumerator->pbuf_stream.length)); + varbind_len = tlv.value_len; + + /* decode varbind name (object id) */ + VB_PARSE_EXEC(snmp_asn1_dec_tlv(&(enumerator->pbuf_stream), &tlv)); + VB_PARSE_ASSERT((tlv.type == SNMP_ASN1_TYPE_OBJECT_ID) && (SNMP_ASN1_TLV_LENGTH(tlv) < varbind_len) && (tlv.value_len < enumerator->pbuf_stream.length)); + + VB_PARSE_EXEC(snmp_asn1_dec_oid(&(enumerator->pbuf_stream), tlv.value_len, varbind->oid.id, &(varbind->oid.len), SNMP_MAX_OBJ_ID_LEN)); + varbind_len -= SNMP_ASN1_TLV_LENGTH(tlv); + + /* decode varbind value (object id) */ + VB_PARSE_EXEC(snmp_asn1_dec_tlv(&(enumerator->pbuf_stream), &tlv)); + VB_PARSE_ASSERT((SNMP_ASN1_TLV_LENGTH(tlv) == varbind_len) && (tlv.value_len <= enumerator->pbuf_stream.length)); + varbind->type = tlv.type; + + /* shall the value be decoded ? */ + if (varbind->value != NULL) { + switch (varbind->type) { + case SNMP_ASN1_TYPE_INTEGER: + VB_PARSE_EXEC(snmp_asn1_dec_s32t(&(enumerator->pbuf_stream), tlv.value_len, (s32_t *)varbind->value)); + varbind->value_len = sizeof(s32_t); + break; + case SNMP_ASN1_TYPE_COUNTER: + case SNMP_ASN1_TYPE_GAUGE: + case SNMP_ASN1_TYPE_TIMETICKS: + VB_PARSE_EXEC(snmp_asn1_dec_u32t(&(enumerator->pbuf_stream), tlv.value_len, (u32_t *)varbind->value)); + varbind->value_len = sizeof(u32_t); + break; + case SNMP_ASN1_TYPE_OCTET_STRING: + case SNMP_ASN1_TYPE_OPAQUE: + err = snmp_asn1_dec_raw(&(enumerator->pbuf_stream), tlv.value_len, (u8_t *)varbind->value, &varbind->value_len, SNMP_MAX_VALUE_SIZE); + if (err == ERR_MEM) { + return SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH; + } + VB_PARSE_ASSERT(err == ERR_OK); + break; + case SNMP_ASN1_TYPE_NULL: + varbind->value_len = 0; + break; + case SNMP_ASN1_TYPE_OBJECT_ID: + /* misuse tlv.length_len as OID_length transporter */ + err = snmp_asn1_dec_oid(&(enumerator->pbuf_stream), tlv.value_len, (u32_t *)varbind->value, &tlv.length_len, SNMP_MAX_OBJ_ID_LEN); + if (err == ERR_MEM) { + return SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH; + } + VB_PARSE_ASSERT(err == ERR_OK); + varbind->value_len = tlv.length_len * sizeof(u32_t); + break; + case SNMP_ASN1_TYPE_IPADDR: + if (tlv.value_len == 4) { + /* must be exactly 4 octets! */ + VB_PARSE_EXEC(snmp_asn1_dec_raw(&(enumerator->pbuf_stream), tlv.value_len, (u8_t *)varbind->value, &varbind->value_len, SNMP_MAX_VALUE_SIZE)); + } else { + VB_PARSE_ASSERT(0); + } + break; +#if LWIP_HAVE_INT64 + case SNMP_ASN1_TYPE_COUNTER64: + VB_PARSE_EXEC(snmp_asn1_dec_u64t(&(enumerator->pbuf_stream), tlv.value_len, (u64_t *)varbind->value)); + varbind->value_len = sizeof(u64_t); + break; +#endif + default: + VB_PARSE_ASSERT(0); + break; + } + } else { + snmp_pbuf_stream_seek(&(enumerator->pbuf_stream), tlv.value_len); + varbind->value_len = tlv.value_len; + } + + return SNMP_VB_ENUMERATOR_ERR_OK; +} + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.h index a3b072f9..903f08a2 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_msg.h @@ -1,185 +1,185 @@ -/** - * @file - * SNMP Agent message handling structures (internal API, do not use in client code). - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * Copyright (c) 2016 Elias Oenal. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Christiaan Simons - * Martin Hentschel - * Elias Oenal - */ - -#ifndef LWIP_HDR_APPS_SNMP_MSG_H -#define LWIP_HDR_APPS_SNMP_MSG_H - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP - -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "snmp_pbuf_stream.h" -#include "lwip/ip_addr.h" -#include "lwip/err.h" - -#if LWIP_SNMP_V3 -#include "snmpv3_priv.h" -#endif - - -#ifdef __cplusplus -extern "C" { -#endif - -/* version defines used in PDU */ -#define SNMP_VERSION_1 0 -#define SNMP_VERSION_2c 1 -#define SNMP_VERSION_3 3 - -struct snmp_varbind_enumerator { - struct snmp_pbuf_stream pbuf_stream; - u16_t varbind_count; -}; - -typedef enum { - SNMP_VB_ENUMERATOR_ERR_OK = 0, - SNMP_VB_ENUMERATOR_ERR_EOVB = 1, - SNMP_VB_ENUMERATOR_ERR_ASN1ERROR = 2, - SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH = 3 -} snmp_vb_enumerator_err_t; - -void snmp_vb_enumerator_init(struct snmp_varbind_enumerator *enumerator, struct pbuf *p, u16_t offset, u16_t length); -snmp_vb_enumerator_err_t snmp_vb_enumerator_get_next(struct snmp_varbind_enumerator *enumerator, struct snmp_varbind *varbind); - -struct snmp_request { - /* Communication handle */ - void *handle; - /* source IP address */ - const ip_addr_t *source_ip; - /* source UDP port */ - u16_t source_port; - /* incoming snmp version */ - u8_t version; - /* community name (zero terminated) */ - u8_t community[SNMP_MAX_COMMUNITY_STR_LEN + 1]; - /* community string length (exclusive zero term) */ - u16_t community_strlen; - /* request type */ - u8_t request_type; - /* request ID */ - s32_t request_id; - /* error status */ - s32_t error_status; - /* error index */ - s32_t error_index; - /* non-repeaters (getBulkRequest (SNMPv2c)) */ - s32_t non_repeaters; - /* max-repetitions (getBulkRequest (SNMPv2c)) */ - s32_t max_repetitions; - - /* Usually response-pdu (2). When snmpv3 errors are detected report-pdu(8) */ - u8_t request_out_type; - -#if LWIP_SNMP_V3 - s32_t msg_id; - s32_t msg_max_size; - u8_t msg_flags; - s32_t msg_security_model; - u8_t msg_authoritative_engine_id[SNMP_V3_MAX_ENGINE_ID_LENGTH]; - u8_t msg_authoritative_engine_id_len; - s32_t msg_authoritative_engine_boots; - s32_t msg_authoritative_engine_time; - u8_t msg_user_name[SNMP_V3_MAX_USER_LENGTH]; - u8_t msg_user_name_len; - u8_t msg_authentication_parameters[SNMP_V3_MAX_AUTH_PARAM_LENGTH]; - u8_t msg_authentication_parameters_len; - u8_t msg_privacy_parameters[SNMP_V3_MAX_PRIV_PARAM_LENGTH]; - u8_t msg_privacy_parameters_len; - u8_t context_engine_id[SNMP_V3_MAX_ENGINE_ID_LENGTH]; - u8_t context_engine_id_len; - u8_t context_name[SNMP_V3_MAX_ENGINE_ID_LENGTH]; - u8_t context_name_len; -#endif - - struct pbuf *inbound_pbuf; - struct snmp_varbind_enumerator inbound_varbind_enumerator; - u16_t inbound_varbind_offset; - u16_t inbound_varbind_len; - u16_t inbound_padding_len; - - struct pbuf *outbound_pbuf; - struct snmp_pbuf_stream outbound_pbuf_stream; - u16_t outbound_pdu_offset; - u16_t outbound_error_status_offset; - u16_t outbound_error_index_offset; - u16_t outbound_varbind_offset; -#if LWIP_SNMP_V3 - u16_t outbound_msg_global_data_offset; - u16_t outbound_msg_global_data_end; - u16_t outbound_msg_security_parameters_str_offset; - u16_t outbound_msg_security_parameters_seq_offset; - u16_t outbound_msg_security_parameters_end; - u16_t outbound_msg_authentication_parameters_offset; - u16_t outbound_scoped_pdu_seq_offset; - u16_t outbound_scoped_pdu_string_offset; -#endif - - u8_t value_buffer[SNMP_MAX_VALUE_SIZE]; -}; - -/** A helper struct keeping length information about varbinds */ -struct snmp_varbind_len { - u8_t vb_len_len; - u16_t vb_value_len; - u8_t oid_len_len; - u16_t oid_value_len; - u8_t value_len_len; - u16_t value_value_len; -}; - -/** Agent community string */ -extern const char *snmp_community; -/** Agent community string for write access */ -extern const char *snmp_community_write; -/** handle for sending traps */ -extern void *snmp_traps_handle; - -void snmp_receive(void *handle, struct pbuf *p, const ip_addr_t *source_ip, u16_t port); -err_t snmp_sendto(void *handle, struct pbuf *p, const ip_addr_t *dst, u16_t port); -u8_t snmp_get_local_ip_for_dst(void *handle, const ip_addr_t *dst, ip_addr_t *result); -err_t snmp_varbind_length(struct snmp_varbind *varbind, struct snmp_varbind_len *len); -err_t snmp_append_outbound_varbind(struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbind); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_SNMP */ - -#endif /* LWIP_HDR_APPS_SNMP_MSG_H */ +/** + * @file + * SNMP Agent message handling structures (internal API, do not use in client code). + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * Copyright (c) 2016 Elias Oenal. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Christiaan Simons + * Martin Hentschel + * Elias Oenal + */ + +#ifndef LWIP_HDR_APPS_SNMP_MSG_H +#define LWIP_HDR_APPS_SNMP_MSG_H + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP + +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "snmp_pbuf_stream.h" +#include "lwip/ip_addr.h" +#include "lwip/err.h" + +#if LWIP_SNMP_V3 +#include "snmpv3_priv.h" +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +/* version defines used in PDU */ +#define SNMP_VERSION_1 0 +#define SNMP_VERSION_2c 1 +#define SNMP_VERSION_3 3 + +struct snmp_varbind_enumerator { + struct snmp_pbuf_stream pbuf_stream; + u16_t varbind_count; +}; + +typedef enum { + SNMP_VB_ENUMERATOR_ERR_OK = 0, + SNMP_VB_ENUMERATOR_ERR_EOVB = 1, + SNMP_VB_ENUMERATOR_ERR_ASN1ERROR = 2, + SNMP_VB_ENUMERATOR_ERR_INVALIDLENGTH = 3 +} snmp_vb_enumerator_err_t; + +void snmp_vb_enumerator_init(struct snmp_varbind_enumerator *enumerator, struct pbuf *p, u16_t offset, u16_t length); +snmp_vb_enumerator_err_t snmp_vb_enumerator_get_next(struct snmp_varbind_enumerator *enumerator, struct snmp_varbind *varbind); + +struct snmp_request { + /* Communication handle */ + void *handle; + /* source IP address */ + const ip_addr_t *source_ip; + /* source UDP port */ + u16_t source_port; + /* incoming snmp version */ + u8_t version; + /* community name (zero terminated) */ + u8_t community[SNMP_MAX_COMMUNITY_STR_LEN + 1]; + /* community string length (exclusive zero term) */ + u16_t community_strlen; + /* request type */ + u8_t request_type; + /* request ID */ + s32_t request_id; + /* error status */ + s32_t error_status; + /* error index */ + s32_t error_index; + /* non-repeaters (getBulkRequest (SNMPv2c)) */ + s32_t non_repeaters; + /* max-repetitions (getBulkRequest (SNMPv2c)) */ + s32_t max_repetitions; + + /* Usually response-pdu (2). When snmpv3 errors are detected report-pdu(8) */ + u8_t request_out_type; + +#if LWIP_SNMP_V3 + s32_t msg_id; + s32_t msg_max_size; + u8_t msg_flags; + s32_t msg_security_model; + u8_t msg_authoritative_engine_id[SNMP_V3_MAX_ENGINE_ID_LENGTH]; + u8_t msg_authoritative_engine_id_len; + s32_t msg_authoritative_engine_boots; + s32_t msg_authoritative_engine_time; + u8_t msg_user_name[SNMP_V3_MAX_USER_LENGTH]; + u8_t msg_user_name_len; + u8_t msg_authentication_parameters[SNMP_V3_MAX_AUTH_PARAM_LENGTH]; + u8_t msg_authentication_parameters_len; + u8_t msg_privacy_parameters[SNMP_V3_MAX_PRIV_PARAM_LENGTH]; + u8_t msg_privacy_parameters_len; + u8_t context_engine_id[SNMP_V3_MAX_ENGINE_ID_LENGTH]; + u8_t context_engine_id_len; + u8_t context_name[SNMP_V3_MAX_ENGINE_ID_LENGTH]; + u8_t context_name_len; +#endif + + struct pbuf *inbound_pbuf; + struct snmp_varbind_enumerator inbound_varbind_enumerator; + u16_t inbound_varbind_offset; + u16_t inbound_varbind_len; + u16_t inbound_padding_len; + + struct pbuf *outbound_pbuf; + struct snmp_pbuf_stream outbound_pbuf_stream; + u16_t outbound_pdu_offset; + u16_t outbound_error_status_offset; + u16_t outbound_error_index_offset; + u16_t outbound_varbind_offset; +#if LWIP_SNMP_V3 + u16_t outbound_msg_global_data_offset; + u16_t outbound_msg_global_data_end; + u16_t outbound_msg_security_parameters_str_offset; + u16_t outbound_msg_security_parameters_seq_offset; + u16_t outbound_msg_security_parameters_end; + u16_t outbound_msg_authentication_parameters_offset; + u16_t outbound_scoped_pdu_seq_offset; + u16_t outbound_scoped_pdu_string_offset; +#endif + + u8_t value_buffer[SNMP_MAX_VALUE_SIZE]; +}; + +/** A helper struct keeping length information about varbinds */ +struct snmp_varbind_len { + u8_t vb_len_len; + u16_t vb_value_len; + u8_t oid_len_len; + u16_t oid_value_len; + u8_t value_len_len; + u16_t value_value_len; +}; + +/** Agent community string */ +extern const char *snmp_community; +/** Agent community string for write access */ +extern const char *snmp_community_write; +/** handle for sending traps */ +extern void *snmp_traps_handle; + +void snmp_receive(void *handle, struct pbuf *p, const ip_addr_t *source_ip, u16_t port); +err_t snmp_sendto(void *handle, struct pbuf *p, const ip_addr_t *dst, u16_t port); +u8_t snmp_get_local_ip_for_dst(void *handle, const ip_addr_t *dst, ip_addr_t *result); +err_t snmp_varbind_length(struct snmp_varbind *varbind, struct snmp_varbind_len *len); +err_t snmp_append_outbound_varbind(struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbind); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_SNMP */ + +#endif /* LWIP_HDR_APPS_SNMP_MSG_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_netconn.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_netconn.c index 57d98f6d..8850acb5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_netconn.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_netconn.c @@ -1,123 +1,123 @@ -/** - * @file - * SNMP netconn frontend. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP && SNMP_USE_NETCONN - -#include -#include "lwip/api.h" -#include "lwip/ip.h" -#include "lwip/udp.h" -#include "snmp_msg.h" -#include "lwip/sys.h" -#include "lwip/prot/iana.h" - -/** SNMP netconn API worker thread */ -static void -snmp_netconn_thread(void *arg) -{ - struct netconn *conn; - struct netbuf *buf; - err_t err; - LWIP_UNUSED_ARG(arg); - - /* Bind to SNMP port with default IP address */ -#if LWIP_IPV6 - conn = netconn_new(NETCONN_UDP_IPV6); - netconn_bind(conn, IP6_ADDR_ANY, LWIP_IANA_PORT_SNMP); -#else /* LWIP_IPV6 */ - conn = netconn_new(NETCONN_UDP); - netconn_bind(conn, IP4_ADDR_ANY, LWIP_IANA_PORT_SNMP); -#endif /* LWIP_IPV6 */ - LWIP_ERROR("snmp_netconn: invalid conn", (conn != NULL), return;); - - snmp_traps_handle = conn; - - do { - err = netconn_recv(conn, &buf); - - if (err == ERR_OK) { - snmp_receive(conn, buf->p, &buf->addr, buf->port); - } - - if (buf != NULL) { - netbuf_delete(buf); - } - } while (1); -} - -err_t -snmp_sendto(void *handle, struct pbuf *p, const ip_addr_t *dst, u16_t port) -{ - err_t result; - struct netbuf buf; - - memset(&buf, 0, sizeof(buf)); - buf.p = p; - result = netconn_sendto((struct netconn *)handle, &buf, dst, port); - - return result; -} - -u8_t -snmp_get_local_ip_for_dst(void *handle, const ip_addr_t *dst, ip_addr_t *result) -{ - struct netconn *conn = (struct netconn *)handle; - struct netif *dst_if; - const ip_addr_t *dst_ip; - - LWIP_UNUSED_ARG(conn); /* unused in case of IPV4 only configuration */ - - ip_route_get_local_ip(&conn->pcb.udp->local_ip, dst, dst_if, dst_ip); - - if ((dst_if != NULL) && (dst_ip != NULL)) { - ip_addr_copy(*result, *dst_ip); - return 1; - } else { - return 0; - } -} - -/** - * Starts SNMP Agent. - */ -void -snmp_init(void) -{ - LWIP_ASSERT_CORE_LOCKED(); - sys_thread_new("snmp_netconn", snmp_netconn_thread, NULL, SNMP_STACK_SIZE, SNMP_THREAD_PRIO); -} - -#endif /* LWIP_SNMP && SNMP_USE_NETCONN */ +/** + * @file + * SNMP netconn frontend. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP && SNMP_USE_NETCONN + +#include +#include "lwip/api.h" +#include "lwip/ip.h" +#include "lwip/udp.h" +#include "snmp_msg.h" +#include "lwip/sys.h" +#include "lwip/prot/iana.h" + +/** SNMP netconn API worker thread */ +static void +snmp_netconn_thread(void *arg) +{ + struct netconn *conn; + struct netbuf *buf; + err_t err; + LWIP_UNUSED_ARG(arg); + + /* Bind to SNMP port with default IP address */ +#if LWIP_IPV6 + conn = netconn_new(NETCONN_UDP_IPV6); + netconn_bind(conn, IP6_ADDR_ANY, LWIP_IANA_PORT_SNMP); +#else /* LWIP_IPV6 */ + conn = netconn_new(NETCONN_UDP); + netconn_bind(conn, IP4_ADDR_ANY, LWIP_IANA_PORT_SNMP); +#endif /* LWIP_IPV6 */ + LWIP_ERROR("snmp_netconn: invalid conn", (conn != NULL), return;); + + snmp_traps_handle = conn; + + do { + err = netconn_recv(conn, &buf); + + if (err == ERR_OK) { + snmp_receive(conn, buf->p, &buf->addr, buf->port); + } + + if (buf != NULL) { + netbuf_delete(buf); + } + } while (1); +} + +err_t +snmp_sendto(void *handle, struct pbuf *p, const ip_addr_t *dst, u16_t port) +{ + err_t result; + struct netbuf buf; + + memset(&buf, 0, sizeof(buf)); + buf.p = p; + result = netconn_sendto((struct netconn *)handle, &buf, dst, port); + + return result; +} + +u8_t +snmp_get_local_ip_for_dst(void *handle, const ip_addr_t *dst, ip_addr_t *result) +{ + struct netconn *conn = (struct netconn *)handle; + struct netif *dst_if; + const ip_addr_t *dst_ip; + + LWIP_UNUSED_ARG(conn); /* unused in case of IPV4 only configuration */ + + ip_route_get_local_ip(&conn->pcb.udp->local_ip, dst, dst_if, dst_ip); + + if ((dst_if != NULL) && (dst_ip != NULL)) { + ip_addr_copy(*result, *dst_ip); + return 1; + } else { + return 0; + } +} + +/** + * Starts SNMP Agent. + */ +void +snmp_init(void) +{ + LWIP_ASSERT_CORE_LOCKED(); + sys_thread_new("snmp_netconn", snmp_netconn_thread, NULL, SNMP_STACK_SIZE, SNMP_THREAD_PRIO); +} + +#endif /* LWIP_SNMP && SNMP_USE_NETCONN */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.c index e33c6ec9..42867fbb 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.c @@ -1,156 +1,156 @@ -/** - * @file - * SNMP pbuf stream wrapper implementation (internal API, do not use in client code). - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "snmp_pbuf_stream.h" -#include "lwip/def.h" -#include - -err_t -snmp_pbuf_stream_init(struct snmp_pbuf_stream *pbuf_stream, struct pbuf *p, u16_t offset, u16_t length) -{ - pbuf_stream->offset = offset; - pbuf_stream->length = length; - pbuf_stream->pbuf = p; - - return ERR_OK; -} - -err_t -snmp_pbuf_stream_read(struct snmp_pbuf_stream *pbuf_stream, u8_t *data) -{ - if (pbuf_stream->length == 0) { - return ERR_BUF; - } - - if (pbuf_copy_partial(pbuf_stream->pbuf, data, 1, pbuf_stream->offset) == 0) { - return ERR_BUF; - } - - pbuf_stream->offset++; - pbuf_stream->length--; - - return ERR_OK; -} - -err_t -snmp_pbuf_stream_write(struct snmp_pbuf_stream *pbuf_stream, u8_t data) -{ - return snmp_pbuf_stream_writebuf(pbuf_stream, &data, 1); -} - -err_t -snmp_pbuf_stream_writebuf(struct snmp_pbuf_stream *pbuf_stream, const void *buf, u16_t buf_len) -{ - if (pbuf_stream->length < buf_len) { - return ERR_BUF; - } - - if (pbuf_take_at(pbuf_stream->pbuf, buf, buf_len, pbuf_stream->offset) != ERR_OK) { - return ERR_BUF; - } - - pbuf_stream->offset += buf_len; - pbuf_stream->length -= buf_len; - - return ERR_OK; -} - -err_t -snmp_pbuf_stream_writeto(struct snmp_pbuf_stream *pbuf_stream, struct snmp_pbuf_stream *target_pbuf_stream, u16_t len) -{ - - if ((pbuf_stream == NULL) || (target_pbuf_stream == NULL)) { - return ERR_ARG; - } - if ((len > pbuf_stream->length) || (len > target_pbuf_stream->length)) { - return ERR_ARG; - } - - if (len == 0) { - len = LWIP_MIN(pbuf_stream->length, target_pbuf_stream->length); - } - - while (len > 0) { - u16_t chunk_len; - err_t err; - u16_t target_offset; - struct pbuf *pbuf = pbuf_skip(pbuf_stream->pbuf, pbuf_stream->offset, &target_offset); - - if ((pbuf == NULL) || (pbuf->len == 0)) { - return ERR_BUF; - } - - chunk_len = LWIP_MIN(len, pbuf->len); - err = snmp_pbuf_stream_writebuf(target_pbuf_stream, &((u8_t *)pbuf->payload)[target_offset], chunk_len); - if (err != ERR_OK) { - return err; - } - - pbuf_stream->offset += chunk_len; - pbuf_stream->length -= chunk_len; - len -= chunk_len; - } - - return ERR_OK; -} - -err_t -snmp_pbuf_stream_seek(struct snmp_pbuf_stream *pbuf_stream, s32_t offset) -{ - if ((offset < 0) || (offset > pbuf_stream->length)) { - /* we cannot seek backwards or forward behind stream end */ - return ERR_ARG; - } - - pbuf_stream->offset += (u16_t)offset; - pbuf_stream->length -= (u16_t)offset; - - return ERR_OK; -} - -err_t -snmp_pbuf_stream_seek_abs(struct snmp_pbuf_stream *pbuf_stream, u32_t offset) -{ - s32_t rel_offset = offset - pbuf_stream->offset; - return snmp_pbuf_stream_seek(pbuf_stream, rel_offset); -} - -#endif /* LWIP_SNMP */ +/** + * @file + * SNMP pbuf stream wrapper implementation (internal API, do not use in client code). + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "snmp_pbuf_stream.h" +#include "lwip/def.h" +#include + +err_t +snmp_pbuf_stream_init(struct snmp_pbuf_stream *pbuf_stream, struct pbuf *p, u16_t offset, u16_t length) +{ + pbuf_stream->offset = offset; + pbuf_stream->length = length; + pbuf_stream->pbuf = p; + + return ERR_OK; +} + +err_t +snmp_pbuf_stream_read(struct snmp_pbuf_stream *pbuf_stream, u8_t *data) +{ + if (pbuf_stream->length == 0) { + return ERR_BUF; + } + + if (pbuf_copy_partial(pbuf_stream->pbuf, data, 1, pbuf_stream->offset) == 0) { + return ERR_BUF; + } + + pbuf_stream->offset++; + pbuf_stream->length--; + + return ERR_OK; +} + +err_t +snmp_pbuf_stream_write(struct snmp_pbuf_stream *pbuf_stream, u8_t data) +{ + return snmp_pbuf_stream_writebuf(pbuf_stream, &data, 1); +} + +err_t +snmp_pbuf_stream_writebuf(struct snmp_pbuf_stream *pbuf_stream, const void *buf, u16_t buf_len) +{ + if (pbuf_stream->length < buf_len) { + return ERR_BUF; + } + + if (pbuf_take_at(pbuf_stream->pbuf, buf, buf_len, pbuf_stream->offset) != ERR_OK) { + return ERR_BUF; + } + + pbuf_stream->offset += buf_len; + pbuf_stream->length -= buf_len; + + return ERR_OK; +} + +err_t +snmp_pbuf_stream_writeto(struct snmp_pbuf_stream *pbuf_stream, struct snmp_pbuf_stream *target_pbuf_stream, u16_t len) +{ + + if ((pbuf_stream == NULL) || (target_pbuf_stream == NULL)) { + return ERR_ARG; + } + if ((len > pbuf_stream->length) || (len > target_pbuf_stream->length)) { + return ERR_ARG; + } + + if (len == 0) { + len = LWIP_MIN(pbuf_stream->length, target_pbuf_stream->length); + } + + while (len > 0) { + u16_t chunk_len; + err_t err; + u16_t target_offset; + struct pbuf *pbuf = pbuf_skip(pbuf_stream->pbuf, pbuf_stream->offset, &target_offset); + + if ((pbuf == NULL) || (pbuf->len == 0)) { + return ERR_BUF; + } + + chunk_len = LWIP_MIN(len, pbuf->len); + err = snmp_pbuf_stream_writebuf(target_pbuf_stream, &((u8_t *)pbuf->payload)[target_offset], chunk_len); + if (err != ERR_OK) { + return err; + } + + pbuf_stream->offset += chunk_len; + pbuf_stream->length -= chunk_len; + len -= chunk_len; + } + + return ERR_OK; +} + +err_t +snmp_pbuf_stream_seek(struct snmp_pbuf_stream *pbuf_stream, s32_t offset) +{ + if ((offset < 0) || (offset > pbuf_stream->length)) { + /* we cannot seek backwards or forward behind stream end */ + return ERR_ARG; + } + + pbuf_stream->offset += (u16_t)offset; + pbuf_stream->length -= (u16_t)offset; + + return ERR_OK; +} + +err_t +snmp_pbuf_stream_seek_abs(struct snmp_pbuf_stream *pbuf_stream, u32_t offset) +{ + s32_t rel_offset = offset - pbuf_stream->offset; + return snmp_pbuf_stream_seek(pbuf_stream, rel_offset); +} + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.h index d094fb1c..682713f9 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_pbuf_stream.h @@ -1,72 +1,72 @@ -/** - * @file - * SNMP pbuf stream wrapper (internal API, do not use in client code). - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * - */ - -#ifndef LWIP_HDR_APPS_SNMP_PBUF_STREAM_H -#define LWIP_HDR_APPS_SNMP_PBUF_STREAM_H - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP - -#include "lwip/err.h" -#include "lwip/pbuf.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct snmp_pbuf_stream { - struct pbuf *pbuf; - u16_t offset; - u16_t length; -}; - -err_t snmp_pbuf_stream_init(struct snmp_pbuf_stream *pbuf_stream, struct pbuf *p, u16_t offset, u16_t length); -err_t snmp_pbuf_stream_read(struct snmp_pbuf_stream *pbuf_stream, u8_t *data); -err_t snmp_pbuf_stream_write(struct snmp_pbuf_stream *pbuf_stream, u8_t data); -err_t snmp_pbuf_stream_writebuf(struct snmp_pbuf_stream *pbuf_stream, const void *buf, u16_t buf_len); -err_t snmp_pbuf_stream_writeto(struct snmp_pbuf_stream *pbuf_stream, struct snmp_pbuf_stream *target_pbuf_stream, u16_t len); -err_t snmp_pbuf_stream_seek(struct snmp_pbuf_stream *pbuf_stream, s32_t offset); -err_t snmp_pbuf_stream_seek_abs(struct snmp_pbuf_stream *pbuf_stream, u32_t offset); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_SNMP */ - -#endif /* LWIP_HDR_APPS_SNMP_PBUF_STREAM_H */ +/** + * @file + * SNMP pbuf stream wrapper (internal API, do not use in client code). + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * + */ + +#ifndef LWIP_HDR_APPS_SNMP_PBUF_STREAM_H +#define LWIP_HDR_APPS_SNMP_PBUF_STREAM_H + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP + +#include "lwip/err.h" +#include "lwip/pbuf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct snmp_pbuf_stream { + struct pbuf *pbuf; + u16_t offset; + u16_t length; +}; + +err_t snmp_pbuf_stream_init(struct snmp_pbuf_stream *pbuf_stream, struct pbuf *p, u16_t offset, u16_t length); +err_t snmp_pbuf_stream_read(struct snmp_pbuf_stream *pbuf_stream, u8_t *data); +err_t snmp_pbuf_stream_write(struct snmp_pbuf_stream *pbuf_stream, u8_t data); +err_t snmp_pbuf_stream_writebuf(struct snmp_pbuf_stream *pbuf_stream, const void *buf, u16_t buf_len); +err_t snmp_pbuf_stream_writeto(struct snmp_pbuf_stream *pbuf_stream, struct snmp_pbuf_stream *target_pbuf_stream, u16_t len); +err_t snmp_pbuf_stream_seek(struct snmp_pbuf_stream *pbuf_stream, s32_t offset); +err_t snmp_pbuf_stream_seek_abs(struct snmp_pbuf_stream *pbuf_stream, u32_t offset); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_SNMP */ + +#endif /* LWIP_HDR_APPS_SNMP_PBUF_STREAM_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_raw.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_raw.c index 912606fb..e203cb69 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_raw.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_raw.c @@ -1,103 +1,103 @@ -/** - * @file - * SNMP RAW API frontend. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - */ - -#include "lwip/apps/snmp_opts.h" -#include "lwip/ip_addr.h" - -#if LWIP_SNMP && SNMP_USE_RAW - -#include "lwip/udp.h" -#include "lwip/ip.h" -#include "lwip/prot/iana.h" -#include "snmp_msg.h" - -/* lwIP UDP receive callback function */ -static void -snmp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - LWIP_UNUSED_ARG(arg); - - snmp_receive(pcb, p, addr, port); - - pbuf_free(p); -} - -err_t -snmp_sendto(void *handle, struct pbuf *p, const ip_addr_t *dst, u16_t port) -{ - return udp_sendto((struct udp_pcb *)handle, p, dst, port); -} - -u8_t -snmp_get_local_ip_for_dst(void *handle, const ip_addr_t *dst, ip_addr_t *result) -{ - struct udp_pcb *udp_pcb = (struct udp_pcb *)handle; - struct netif *dst_if; - const ip_addr_t *dst_ip; - - LWIP_UNUSED_ARG(udp_pcb); /* unused in case of IPV4 only configuration */ - - ip_route_get_local_ip(&udp_pcb->local_ip, dst, dst_if, dst_ip); - - if ((dst_if != NULL) && (dst_ip != NULL)) { - ip_addr_copy(*result, *dst_ip); - return 1; - } else { - return 0; - } -} - -/** - * @ingroup snmp_core - * Starts SNMP Agent. - * Allocates UDP pcb and binds it to IP_ANY_TYPE port 161. - */ -void -snmp_init(void) -{ - err_t err; - - struct udp_pcb *snmp_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); - LWIP_ERROR("snmp_raw: no PCB", (snmp_pcb != NULL), return;); - - LWIP_ASSERT_CORE_LOCKED(); - - snmp_traps_handle = snmp_pcb; - - udp_recv(snmp_pcb, snmp_recv, NULL); - err = udp_bind(snmp_pcb, IP_ANY_TYPE, LWIP_IANA_PORT_SNMP); - LWIP_ERROR("snmp_raw: Unable to bind PCB", (err == ERR_OK), return;); -} - -#endif /* LWIP_SNMP && SNMP_USE_RAW */ +/** + * @file + * SNMP RAW API frontend. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + */ + +#include "lwip/apps/snmp_opts.h" +#include "lwip/ip_addr.h" + +#if LWIP_SNMP && SNMP_USE_RAW + +#include "lwip/udp.h" +#include "lwip/ip.h" +#include "lwip/prot/iana.h" +#include "snmp_msg.h" + +/* lwIP UDP receive callback function */ +static void +snmp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + LWIP_UNUSED_ARG(arg); + + snmp_receive(pcb, p, addr, port); + + pbuf_free(p); +} + +err_t +snmp_sendto(void *handle, struct pbuf *p, const ip_addr_t *dst, u16_t port) +{ + return udp_sendto((struct udp_pcb *)handle, p, dst, port); +} + +u8_t +snmp_get_local_ip_for_dst(void *handle, const ip_addr_t *dst, ip_addr_t *result) +{ + struct udp_pcb *udp_pcb = (struct udp_pcb *)handle; + struct netif *dst_if; + const ip_addr_t *dst_ip; + + LWIP_UNUSED_ARG(udp_pcb); /* unused in case of IPV4 only configuration */ + + ip_route_get_local_ip(&udp_pcb->local_ip, dst, dst_if, dst_ip); + + if ((dst_if != NULL) && (dst_ip != NULL)) { + ip_addr_copy(*result, *dst_ip); + return 1; + } else { + return 0; + } +} + +/** + * @ingroup snmp_core + * Starts SNMP Agent. + * Allocates UDP pcb and binds it to IP_ANY_TYPE port 161. + */ +void +snmp_init(void) +{ + err_t err; + + struct udp_pcb *snmp_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + LWIP_ERROR("snmp_raw: no PCB", (snmp_pcb != NULL), return;); + + LWIP_ASSERT_CORE_LOCKED(); + + snmp_traps_handle = snmp_pcb; + + udp_recv(snmp_pcb, snmp_recv, NULL); + err = udp_bind(snmp_pcb, IP_ANY_TYPE, LWIP_IANA_PORT_SNMP); + LWIP_ERROR("snmp_raw: Unable to bind PCB", (err == ERR_OK), return;); +} + +#endif /* LWIP_SNMP && SNMP_USE_RAW */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_scalar.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_scalar.c index 51eaed10..094f52fe 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_scalar.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_scalar.c @@ -1,232 +1,232 @@ -/** - * @file - * SNMP scalar node support implementation. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/snmp_scalar.h" -#include "lwip/apps/snmp_core.h" - -static s16_t snmp_scalar_array_get_value(struct snmp_node_instance *instance, void *value); -static snmp_err_t snmp_scalar_array_set_test(struct snmp_node_instance *instance, u16_t value_len, void *value); -static snmp_err_t snmp_scalar_array_set_value(struct snmp_node_instance *instance, u16_t value_len, void *value); - -snmp_err_t -snmp_scalar_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - const struct snmp_scalar_node *scalar_node = (const struct snmp_scalar_node *)(const void *)instance->node; - - LWIP_UNUSED_ARG(root_oid); - LWIP_UNUSED_ARG(root_oid_len); - - /* scalar only has one dedicated instance: .0 */ - if ((instance->instance_oid.len != 1) || (instance->instance_oid.id[0] != 0)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - instance->access = scalar_node->access; - instance->asn1_type = scalar_node->asn1_type; - instance->get_value = scalar_node->get_value; - instance->set_test = scalar_node->set_test; - instance->set_value = scalar_node->set_value; - return SNMP_ERR_NOERROR; -} - -snmp_err_t -snmp_scalar_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - /* because our only instance is .0 we can only return a next instance if no instance oid is passed */ - if (instance->instance_oid.len == 0) { - instance->instance_oid.len = 1; - instance->instance_oid.id[0] = 0; - - return snmp_scalar_get_instance(root_oid, root_oid_len, instance); - } - - return SNMP_ERR_NOSUCHINSTANCE; -} - - -snmp_err_t -snmp_scalar_array_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - LWIP_UNUSED_ARG(root_oid); - LWIP_UNUSED_ARG(root_oid_len); - - if ((instance->instance_oid.len == 2) && (instance->instance_oid.id[1] == 0)) { - const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; - const struct snmp_scalar_array_node_def *array_node_def = array_node->array_nodes; - u32_t i = 0; - - while (i < array_node->array_node_count) { - if (array_node_def->oid == instance->instance_oid.id[0]) { - break; - } - - array_node_def++; - i++; - } - - if (i < array_node->array_node_count) { - instance->access = array_node_def->access; - instance->asn1_type = array_node_def->asn1_type; - instance->get_value = snmp_scalar_array_get_value; - instance->set_test = snmp_scalar_array_set_test; - instance->set_value = snmp_scalar_array_set_value; - instance->reference.const_ptr = array_node_def; - - return SNMP_ERR_NOERROR; - } - } - - return SNMP_ERR_NOSUCHINSTANCE; -} - -snmp_err_t -snmp_scalar_array_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; - const struct snmp_scalar_array_node_def *array_node_def = array_node->array_nodes; - const struct snmp_scalar_array_node_def *result = NULL; - - LWIP_UNUSED_ARG(root_oid); - LWIP_UNUSED_ARG(root_oid_len); - - if ((instance->instance_oid.len == 0) && (array_node->array_node_count > 0)) { - /* return node with lowest OID */ - u16_t i = 0; - - result = array_node_def; - array_node_def++; - - for (i = 1; i < array_node->array_node_count; i++) { - if (array_node_def->oid < result->oid) { - result = array_node_def; - } - array_node_def++; - } - } else if (instance->instance_oid.len >= 1) { - if (instance->instance_oid.len == 1) { - /* if we have the requested OID we return its instance, otherwise we search for the next available */ - u16_t i = 0; - while (i < array_node->array_node_count) { - if (array_node_def->oid == instance->instance_oid.id[0]) { - result = array_node_def; - break; - } - - array_node_def++; - i++; - } - } - if (result == NULL) { - u32_t oid_dist = 0xFFFFFFFFUL; - u16_t i = 0; - array_node_def = array_node->array_nodes; /* may be already at the end when if case before was executed without result -> reinitialize to start */ - while (i < array_node->array_node_count) { - if ((array_node_def->oid > instance->instance_oid.id[0]) && - ((u32_t)(array_node_def->oid - instance->instance_oid.id[0]) < oid_dist)) { - result = array_node_def; - oid_dist = array_node_def->oid - instance->instance_oid.id[0]; - } - - array_node_def++; - i++; - } - } - } - - if (result == NULL) { - /* nothing to return */ - return SNMP_ERR_NOSUCHINSTANCE; - } - - instance->instance_oid.len = 2; - instance->instance_oid.id[0] = result->oid; - instance->instance_oid.id[1] = 0; - - instance->access = result->access; - instance->asn1_type = result->asn1_type; - instance->get_value = snmp_scalar_array_get_value; - instance->set_test = snmp_scalar_array_set_test; - instance->set_value = snmp_scalar_array_set_value; - instance->reference.const_ptr = result; - - return SNMP_ERR_NOERROR; -} - -static s16_t -snmp_scalar_array_get_value(struct snmp_node_instance *instance, void *value) -{ - s16_t result = -1; - const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; - const struct snmp_scalar_array_node_def *array_node_def = (const struct snmp_scalar_array_node_def *)instance->reference.const_ptr; - - if (array_node->get_value != NULL) { - result = array_node->get_value(array_node_def, value); - } - return result; -} - -static snmp_err_t -snmp_scalar_array_set_test(struct snmp_node_instance *instance, u16_t value_len, void *value) -{ - snmp_err_t result = SNMP_ERR_NOTWRITABLE; - const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; - const struct snmp_scalar_array_node_def *array_node_def = (const struct snmp_scalar_array_node_def *)instance->reference.const_ptr; - - if (array_node->set_test != NULL) { - result = array_node->set_test(array_node_def, value_len, value); - } - return result; -} - -static snmp_err_t -snmp_scalar_array_set_value(struct snmp_node_instance *instance, u16_t value_len, void *value) -{ - snmp_err_t result = SNMP_ERR_NOTWRITABLE; - const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; - const struct snmp_scalar_array_node_def *array_node_def = (const struct snmp_scalar_array_node_def *)instance->reference.const_ptr; - - if (array_node->set_value != NULL) { - result = array_node->set_value(array_node_def, value_len, value); - } - return result; -} - -#endif /* LWIP_SNMP */ +/** + * @file + * SNMP scalar node support implementation. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/snmp_scalar.h" +#include "lwip/apps/snmp_core.h" + +static s16_t snmp_scalar_array_get_value(struct snmp_node_instance *instance, void *value); +static snmp_err_t snmp_scalar_array_set_test(struct snmp_node_instance *instance, u16_t value_len, void *value); +static snmp_err_t snmp_scalar_array_set_value(struct snmp_node_instance *instance, u16_t value_len, void *value); + +snmp_err_t +snmp_scalar_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + const struct snmp_scalar_node *scalar_node = (const struct snmp_scalar_node *)(const void *)instance->node; + + LWIP_UNUSED_ARG(root_oid); + LWIP_UNUSED_ARG(root_oid_len); + + /* scalar only has one dedicated instance: .0 */ + if ((instance->instance_oid.len != 1) || (instance->instance_oid.id[0] != 0)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + instance->access = scalar_node->access; + instance->asn1_type = scalar_node->asn1_type; + instance->get_value = scalar_node->get_value; + instance->set_test = scalar_node->set_test; + instance->set_value = scalar_node->set_value; + return SNMP_ERR_NOERROR; +} + +snmp_err_t +snmp_scalar_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + /* because our only instance is .0 we can only return a next instance if no instance oid is passed */ + if (instance->instance_oid.len == 0) { + instance->instance_oid.len = 1; + instance->instance_oid.id[0] = 0; + + return snmp_scalar_get_instance(root_oid, root_oid_len, instance); + } + + return SNMP_ERR_NOSUCHINSTANCE; +} + + +snmp_err_t +snmp_scalar_array_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + LWIP_UNUSED_ARG(root_oid); + LWIP_UNUSED_ARG(root_oid_len); + + if ((instance->instance_oid.len == 2) && (instance->instance_oid.id[1] == 0)) { + const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; + const struct snmp_scalar_array_node_def *array_node_def = array_node->array_nodes; + u32_t i = 0; + + while (i < array_node->array_node_count) { + if (array_node_def->oid == instance->instance_oid.id[0]) { + break; + } + + array_node_def++; + i++; + } + + if (i < array_node->array_node_count) { + instance->access = array_node_def->access; + instance->asn1_type = array_node_def->asn1_type; + instance->get_value = snmp_scalar_array_get_value; + instance->set_test = snmp_scalar_array_set_test; + instance->set_value = snmp_scalar_array_set_value; + instance->reference.const_ptr = array_node_def; + + return SNMP_ERR_NOERROR; + } + } + + return SNMP_ERR_NOSUCHINSTANCE; +} + +snmp_err_t +snmp_scalar_array_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; + const struct snmp_scalar_array_node_def *array_node_def = array_node->array_nodes; + const struct snmp_scalar_array_node_def *result = NULL; + + LWIP_UNUSED_ARG(root_oid); + LWIP_UNUSED_ARG(root_oid_len); + + if ((instance->instance_oid.len == 0) && (array_node->array_node_count > 0)) { + /* return node with lowest OID */ + u16_t i = 0; + + result = array_node_def; + array_node_def++; + + for (i = 1; i < array_node->array_node_count; i++) { + if (array_node_def->oid < result->oid) { + result = array_node_def; + } + array_node_def++; + } + } else if (instance->instance_oid.len >= 1) { + if (instance->instance_oid.len == 1) { + /* if we have the requested OID we return its instance, otherwise we search for the next available */ + u16_t i = 0; + while (i < array_node->array_node_count) { + if (array_node_def->oid == instance->instance_oid.id[0]) { + result = array_node_def; + break; + } + + array_node_def++; + i++; + } + } + if (result == NULL) { + u32_t oid_dist = 0xFFFFFFFFUL; + u16_t i = 0; + array_node_def = array_node->array_nodes; /* may be already at the end when if case before was executed without result -> reinitialize to start */ + while (i < array_node->array_node_count) { + if ((array_node_def->oid > instance->instance_oid.id[0]) && + ((u32_t)(array_node_def->oid - instance->instance_oid.id[0]) < oid_dist)) { + result = array_node_def; + oid_dist = array_node_def->oid - instance->instance_oid.id[0]; + } + + array_node_def++; + i++; + } + } + } + + if (result == NULL) { + /* nothing to return */ + return SNMP_ERR_NOSUCHINSTANCE; + } + + instance->instance_oid.len = 2; + instance->instance_oid.id[0] = result->oid; + instance->instance_oid.id[1] = 0; + + instance->access = result->access; + instance->asn1_type = result->asn1_type; + instance->get_value = snmp_scalar_array_get_value; + instance->set_test = snmp_scalar_array_set_test; + instance->set_value = snmp_scalar_array_set_value; + instance->reference.const_ptr = result; + + return SNMP_ERR_NOERROR; +} + +static s16_t +snmp_scalar_array_get_value(struct snmp_node_instance *instance, void *value) +{ + s16_t result = -1; + const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; + const struct snmp_scalar_array_node_def *array_node_def = (const struct snmp_scalar_array_node_def *)instance->reference.const_ptr; + + if (array_node->get_value != NULL) { + result = array_node->get_value(array_node_def, value); + } + return result; +} + +static snmp_err_t +snmp_scalar_array_set_test(struct snmp_node_instance *instance, u16_t value_len, void *value) +{ + snmp_err_t result = SNMP_ERR_NOTWRITABLE; + const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; + const struct snmp_scalar_array_node_def *array_node_def = (const struct snmp_scalar_array_node_def *)instance->reference.const_ptr; + + if (array_node->set_test != NULL) { + result = array_node->set_test(array_node_def, value_len, value); + } + return result; +} + +static snmp_err_t +snmp_scalar_array_set_value(struct snmp_node_instance *instance, u16_t value_len, void *value) +{ + snmp_err_t result = SNMP_ERR_NOTWRITABLE; + const struct snmp_scalar_array_node *array_node = (const struct snmp_scalar_array_node *)(const void *)instance->node; + const struct snmp_scalar_array_node_def *array_node_def = (const struct snmp_scalar_array_node_def *)instance->reference.const_ptr; + + if (array_node->set_value != NULL) { + result = array_node->set_value(array_node_def, value_len, value); + } + return result; +} + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_framework.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_framework.c index a19a26e7..a5611dbf 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_framework.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_framework.c @@ -1,90 +1,90 @@ -/* -Generated by LwipMibCompiler -*/ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP && LWIP_SNMP_V3 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/snmp_snmpv2_framework.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmpv3.h" -#include "snmpv3_priv.h" - -#include "lwip/sys.h" - -#include - -const struct snmp_obj_id usmNoAuthProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 1, 1 } }; -const struct snmp_obj_id usmHMACMD5AuthProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 1, 2 } }; -const struct snmp_obj_id usmHMACSHAAuthProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 1, 3 } }; -/* .4 sha-224 - * .5 sha-256 - * .6 sha-384 - * .7 sha-512 - */ - -const struct snmp_obj_id usmNoPrivProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 2, 1 } }; -const struct snmp_obj_id usmDESPrivProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 2, 2 } }; -/* .3 3des-ede */ -const struct snmp_obj_id usmAESPrivProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 2, 4 } }; -/* .5 unknown - * .6 unknown - * .7 unknown - */ - -/* TODO: where should this value come from? */ -#define SNMP_FRAMEWORKMIB_SNMPENGINEMAXMESSAGESIZE 1500 - -/* --- snmpFrameworkMIBObjects 1.3.6.1.6.3.10.2 ----------------------------------------------------- */ -static s16_t snmpengine_scalars_get_value(const struct snmp_scalar_array_node_def *node, void *value) -{ - const char *engineid; - u8_t engineid_len; - - switch (node->oid) { - case 1: /* snmpEngineID */ - snmpv3_get_engine_id(&engineid, &engineid_len); - MEMCPY(value, engineid, engineid_len); - return engineid_len; - case 2: /* snmpEngineBoots */ - *(s32_t *)value = snmpv3_get_engine_boots_internal(); - return sizeof(s32_t); - case 3: /* snmpEngineTime */ - *(s32_t *)value = snmpv3_get_engine_time_internal(); - return sizeof(s32_t); - case 4: /* snmpEngineMaxMessageSize */ - *(s32_t *)value = SNMP_FRAMEWORKMIB_SNMPENGINEMAXMESSAGESIZE; - return sizeof(s32_t); - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("snmpengine_scalars_get_value(): unknown id: %"S32_F"\n", node->oid)); - return 0; - } -} - -static const struct snmp_scalar_array_node_def snmpengine_scalars_nodes[] = { - {1, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineID */ - {2, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineBoots */ - {3, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineTime */ - {4, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineMaxMessageSize */ -}; -static const struct snmp_scalar_array_node snmpengine_scalars = SNMP_SCALAR_CREATE_ARRAY_NODE(1, snmpengine_scalars_nodes, snmpengine_scalars_get_value, NULL, NULL); - -static const struct snmp_node *const snmpframeworkmibobjects_subnodes[] = { - &snmpengine_scalars.node.node -}; -static const struct snmp_tree_node snmpframeworkmibobjects_treenode = SNMP_CREATE_TREE_NODE(2, snmpframeworkmibobjects_subnodes); - -/* --- snmpFrameworkMIB ----------------------------------------------------- */ -static const struct snmp_node *const snmpframeworkmib_subnodes[] = { - &snmpframeworkmibobjects_treenode.node -}; -static const struct snmp_tree_node snmpframeworkmib_root = SNMP_CREATE_TREE_NODE(10, snmpframeworkmib_subnodes); -static const u32_t snmpframeworkmib_base_oid[] = {1, 3, 6, 1, 6, 3, 10}; -const struct snmp_mib snmpframeworkmib = {snmpframeworkmib_base_oid, LWIP_ARRAYSIZE(snmpframeworkmib_base_oid), &snmpframeworkmib_root.node}; - -/* --- snmpFrameworkMIB ----------------------------------------------------- */ -#endif /* LWIP_SNMP */ +/* +Generated by LwipMibCompiler +*/ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP && LWIP_SNMP_V3 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/snmp_snmpv2_framework.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmpv3.h" +#include "snmpv3_priv.h" + +#include "lwip/sys.h" + +#include + +const struct snmp_obj_id usmNoAuthProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 1, 1 } }; +const struct snmp_obj_id usmHMACMD5AuthProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 1, 2 } }; +const struct snmp_obj_id usmHMACSHAAuthProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 1, 3 } }; +/* .4 sha-224 + * .5 sha-256 + * .6 sha-384 + * .7 sha-512 + */ + +const struct snmp_obj_id usmNoPrivProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 2, 1 } }; +const struct snmp_obj_id usmDESPrivProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 2, 2 } }; +/* .3 3des-ede */ +const struct snmp_obj_id usmAESPrivProtocol = { 10, { 1, 3, 6, 1, 6, 3, 10, 1, 2, 4 } }; +/* .5 unknown + * .6 unknown + * .7 unknown + */ + +/* TODO: where should this value come from? */ +#define SNMP_FRAMEWORKMIB_SNMPENGINEMAXMESSAGESIZE 1500 + +/* --- snmpFrameworkMIBObjects 1.3.6.1.6.3.10.2 ----------------------------------------------------- */ +static s16_t snmpengine_scalars_get_value(const struct snmp_scalar_array_node_def *node, void *value) +{ + const char *engineid; + u8_t engineid_len; + + switch (node->oid) { + case 1: /* snmpEngineID */ + snmpv3_get_engine_id(&engineid, &engineid_len); + MEMCPY(value, engineid, engineid_len); + return engineid_len; + case 2: /* snmpEngineBoots */ + *(s32_t *)value = snmpv3_get_engine_boots_internal(); + return sizeof(s32_t); + case 3: /* snmpEngineTime */ + *(s32_t *)value = snmpv3_get_engine_time_internal(); + return sizeof(s32_t); + case 4: /* snmpEngineMaxMessageSize */ + *(s32_t *)value = SNMP_FRAMEWORKMIB_SNMPENGINEMAXMESSAGESIZE; + return sizeof(s32_t); + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("snmpengine_scalars_get_value(): unknown id: %"S32_F"\n", node->oid)); + return 0; + } +} + +static const struct snmp_scalar_array_node_def snmpengine_scalars_nodes[] = { + {1, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineID */ + {2, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineBoots */ + {3, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineTime */ + {4, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* snmpEngineMaxMessageSize */ +}; +static const struct snmp_scalar_array_node snmpengine_scalars = SNMP_SCALAR_CREATE_ARRAY_NODE(1, snmpengine_scalars_nodes, snmpengine_scalars_get_value, NULL, NULL); + +static const struct snmp_node *const snmpframeworkmibobjects_subnodes[] = { + &snmpengine_scalars.node.node +}; +static const struct snmp_tree_node snmpframeworkmibobjects_treenode = SNMP_CREATE_TREE_NODE(2, snmpframeworkmibobjects_subnodes); + +/* --- snmpFrameworkMIB ----------------------------------------------------- */ +static const struct snmp_node *const snmpframeworkmib_subnodes[] = { + &snmpframeworkmibobjects_treenode.node +}; +static const struct snmp_tree_node snmpframeworkmib_root = SNMP_CREATE_TREE_NODE(10, snmpframeworkmib_subnodes); +static const u32_t snmpframeworkmib_base_oid[] = {1, 3, 6, 1, 6, 3, 10}; +const struct snmp_mib snmpframeworkmib = {snmpframeworkmib_base_oid, LWIP_ARRAYSIZE(snmpframeworkmib_base_oid), &snmpframeworkmib_root.node}; + +/* --- snmpFrameworkMIB ----------------------------------------------------- */ +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_usm.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_usm.c index 940ca754..7490c9c8 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_usm.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_snmpv2_usm.c @@ -1,410 +1,410 @@ -/* -Generated by LwipMibCompiler -*/ - -#include "lwip/apps/snmp_opts.h" -#if LWIP_SNMP && LWIP_SNMP_V3 - -#include "lwip/apps/snmp_snmpv2_usm.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_scalar.h" -#include "lwip/apps/snmp_table.h" -#include "lwip/apps/snmpv3.h" -#include "snmpv3_priv.h" - -#include "lwip/apps/snmp_snmpv2_framework.h" - -#include - -/* --- usmUser 1.3.6.1.6.3.15.1.2 ----------------------------------------------------- */ - -static const struct snmp_oid_range usmUserTable_oid_ranges[] = { - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, - { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff } -}; - -static void snmp_engineid_to_oid(const char *engineid, u32_t *oid, u32_t len) -{ - u8_t i; - - for (i = 0; i < len; i++) { - oid[i] = engineid[i]; - } -} - -static void snmp_oid_to_name(char *name, const u32_t *oid, size_t len) -{ - u8_t i; - - for (i = 0; i < len; i++) { - name[i] = (char)oid[i]; - } -} - -static void snmp_name_to_oid(const char *name, u32_t *oid, size_t len) -{ - u8_t i; - - for (i = 0; i < len; i++) { - oid[i] = name[i]; - } -} - -static const struct snmp_obj_id *snmp_auth_algo_to_oid(snmpv3_auth_algo_t algo) -{ - if (algo == SNMP_V3_AUTH_ALGO_MD5) { - return &usmHMACMD5AuthProtocol; - } else if (algo == SNMP_V3_AUTH_ALGO_SHA) { - return &usmHMACMD5AuthProtocol; - } - - return &usmNoAuthProtocol; -} - -static const struct snmp_obj_id *snmp_priv_algo_to_oid(snmpv3_priv_algo_t algo) -{ - if (algo == SNMP_V3_PRIV_ALGO_DES) { - return &usmDESPrivProtocol; - } else if (algo == SNMP_V3_PRIV_ALGO_AES) { - return &usmAESPrivProtocol; - } - - return &usmNoPrivProtocol; -} - -char username[32]; - -static snmp_err_t usmusertable_get_instance(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, struct snmp_node_instance *cell_instance) -{ - const char *engineid; - u8_t eid_len; - - u32_t engineid_oid[SNMP_V3_MAX_ENGINE_ID_LENGTH]; - - u8_t name_len; - u8_t engineid_len; - - u8_t name_start; - u8_t engineid_start; - - LWIP_UNUSED_ARG(column); - - snmpv3_get_engine_id(&engineid, &eid_len); - - engineid_len = (u8_t)row_oid[0]; - engineid_start = 1; - - if (engineid_len != eid_len) { - /* EngineID length does not match! */ - return SNMP_ERR_NOSUCHINSTANCE; - } - - if (engineid_len > row_oid_len) { - /* row OID doesn't contain enough data according to engineid_len.*/ - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(&row_oid[engineid_start], engineid_len, usmUserTable_oid_ranges, engineid_len)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - snmp_engineid_to_oid(engineid, engineid_oid, engineid_len); - - /* Verify EngineID */ - if (snmp_oid_equal(&row_oid[engineid_start], engineid_len, engineid_oid, engineid_len)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - name_len = (u8_t)row_oid[engineid_start + engineid_len]; - name_start = engineid_start + engineid_len + 1; - - if (name_len > SNMP_V3_MAX_USER_LENGTH) { - /* specified name is too long */ - return SNMP_ERR_NOSUCHINSTANCE; - } - - if (1 + engineid_len + 1 + name_len != row_oid_len) { - /* Length of EngineID and name does not match row oid length. (+2 for length fields)*/ - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* check if incoming OID length and if values are in plausible range */ - if (!snmp_oid_in_range(&row_oid[name_start], name_len, usmUserTable_oid_ranges, name_len)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* Verify if user exists */ - memset(username, 0, sizeof(username)); - snmp_oid_to_name(username, &row_oid[name_start], name_len); - if (snmpv3_get_user(username, NULL, NULL, NULL, NULL) != ERR_OK) { - return SNMP_ERR_NOSUCHINSTANCE; - } - - /* Save name in reference pointer to make it easier to handle later on */ - cell_instance->reference.ptr = username; - cell_instance->reference_len = name_len; - - /* user was found */ - return SNMP_ERR_NOERROR; -} - -/* - * valid oid options - * - * . - * .. - * .. - * ... - * .... - * .... - * - */ -static snmp_err_t usmusertable_get_next_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance) -{ - const char *engineid; - u8_t eid_len; - - u32_t engineid_oid[SNMP_V3_MAX_ENGINE_ID_LENGTH]; - - u8_t name_len; - u8_t engineid_len; - - u8_t name_start; - u8_t engineid_start = 1; - u8_t i; - - struct snmp_next_oid_state state; - - u32_t result_temp[LWIP_ARRAYSIZE(usmUserTable_oid_ranges)]; - - LWIP_UNUSED_ARG(column); - - snmpv3_get_engine_id(&engineid, &eid_len); - - /* If EngineID might be given */ - if (row_oid->len > 0) { - engineid_len = (u8_t)row_oid->id[0]; - engineid_start = 1; - - if (engineid_len != eid_len) { - /* EngineID length does not match! */ - return SNMP_ERR_NOSUCHINSTANCE; - } - - if (engineid_len > row_oid->len) { - /* Verify partial EngineID */ - snmp_engineid_to_oid(engineid, engineid_oid, row_oid->len - 1); - if (!snmp_oid_equal(&row_oid->id[engineid_start], row_oid->len - 1, engineid_oid, row_oid->len - 1)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - } else { - /* Verify complete EngineID */ - snmp_engineid_to_oid(engineid, engineid_oid, engineid_len); - if (!snmp_oid_equal(&row_oid->id[engineid_start], engineid_len, engineid_oid, engineid_len)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - } - - /* At this point, the given EngineID (partially) matches the local EngineID.*/ - - /* If name might also be given */ - if (row_oid->len > engineid_start + engineid_len) { - name_len = (u8_t)row_oid->id[engineid_start + engineid_len]; - name_start = engineid_start + engineid_len + 1; - - if (name_len > SNMP_V3_MAX_USER_LENGTH) { - /* specified name is too long, max length is 32 according to mib file.*/ - return SNMP_ERR_NOSUCHINSTANCE; - } - - if (row_oid->len < engineid_len + name_len + 2) { - /* Partial name given according to oid.*/ - u8_t tmplen = row_oid->len - engineid_len - 2; - if (!snmp_oid_in_range(&row_oid->id[name_start], tmplen, usmUserTable_oid_ranges, tmplen)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - } else { - /* Full name given according to oid. Also test for too much data.*/ - u8_t tmplen = row_oid->len - engineid_len - 2; - if (!snmp_oid_in_range(&row_oid->id[name_start], name_len, usmUserTable_oid_ranges, tmplen)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - } - - /* At this point the EngineID and (partial) UserName match the local EngineID and UserName.*/ - } - } - - /* init struct to search next oid */ - snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(usmUserTable_oid_ranges)); - - for (i = 0; i < snmpv3_get_amount_of_users(); i++) { - u32_t test_oid[LWIP_ARRAYSIZE(usmUserTable_oid_ranges)]; - - test_oid[0] = eid_len; - snmp_engineid_to_oid(engineid, &test_oid[1], eid_len); - - snmpv3_get_username(username, i); - - test_oid[1 + eid_len] = strlen(username); - snmp_name_to_oid(username, &test_oid[2 + eid_len], strlen(username)); - - /* check generated OID: is it a candidate for the next one? */ - snmp_next_oid_check(&state, test_oid, (u8_t)(1 + eid_len + 1 + strlen(username)), LWIP_PTR_NUMERIC_CAST(void *, i)); - } - - /* did we find a next one? */ - if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { - snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); - /* store username for subsequent operations (get/test/set) */ - memset(username, 0, sizeof(username)); - snmpv3_get_username(username, LWIP_PTR_NUMERIC_CAST(u8_t, state.reference)); - cell_instance->reference.ptr = username; - cell_instance->reference_len = strlen(username); - return SNMP_ERR_NOERROR; - } - - /* not found */ - return SNMP_ERR_NOSUCHINSTANCE; -} - -static s16_t usmusertable_get_value(struct snmp_node_instance *cell_instance, void *value) -{ - snmpv3_user_storagetype_t storage_type; - - switch (SNMP_TABLE_GET_COLUMN_FROM_OID(cell_instance->instance_oid.id)) { - case 3: /* usmUserSecurityName */ - MEMCPY(value, cell_instance->reference.ptr, cell_instance->reference_len); - return (s16_t)cell_instance->reference_len; - case 4: /* usmUserCloneFrom */ - MEMCPY(value, snmp_zero_dot_zero.id, snmp_zero_dot_zero.len * sizeof(u32_t)); - return snmp_zero_dot_zero.len * sizeof(u32_t); - case 5: { /* usmUserAuthProtocol */ - const struct snmp_obj_id *auth_algo; - snmpv3_auth_algo_t auth_algo_val; - snmpv3_get_user((const char *)cell_instance->reference.ptr, &auth_algo_val, NULL, NULL, NULL); - auth_algo = snmp_auth_algo_to_oid(auth_algo_val); - MEMCPY(value, auth_algo->id, auth_algo->len * sizeof(u32_t)); - return auth_algo->len * sizeof(u32_t); - } - case 6: /* usmUserAuthKeyChange */ - return 0; - case 7: /* usmUserOwnAuthKeyChange */ - return 0; - case 8: { /* usmUserPrivProtocol */ - const struct snmp_obj_id *priv_algo; - snmpv3_priv_algo_t priv_algo_val; - snmpv3_get_user((const char *)cell_instance->reference.ptr, NULL, NULL, &priv_algo_val, NULL); - priv_algo = snmp_priv_algo_to_oid(priv_algo_val); - MEMCPY(value, priv_algo->id, priv_algo->len * sizeof(u32_t)); - return priv_algo->len * sizeof(u32_t); - } - case 9: /* usmUserPrivKeyChange */ - return 0; - case 10: /* usmUserOwnPrivKeyChange */ - return 0; - case 11: /* usmUserPublic */ - /* TODO: Implement usmUserPublic */ - return 0; - case 12: /* usmUserStorageType */ - snmpv3_get_user_storagetype((const char *)cell_instance->reference.ptr, &storage_type); - *(s32_t *)value = storage_type; - return sizeof(s32_t); - case 13: /* usmUserStatus */ - *(s32_t *)value = 1; /* active */ - return sizeof(s32_t); - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("usmusertable_get_value(): unknown id: %"S32_F"\n", SNMP_TABLE_GET_COLUMN_FROM_OID(cell_instance->instance_oid.id))); - return 0; - } -} - -/* --- usmMIBObjects 1.3.6.1.6.3.15.1 ----------------------------------------------------- */ -static s16_t usmstats_scalars_get_value(const struct snmp_scalar_array_node_def *node, void *value) -{ - u32_t *uint_ptr = (u32_t *)value; - switch (node->oid) { - case 1: /* usmStatsUnsupportedSecLevels */ - *uint_ptr = snmp_stats.unsupportedseclevels; - break; - case 2: /* usmStatsNotInTimeWindows */ - *uint_ptr = snmp_stats.notintimewindows; - break; - case 3: /* usmStatsUnknownUserNames */ - *uint_ptr = snmp_stats.unknownusernames; - break; - case 4: /* usmStatsUnknownEngineIDs */ - *uint_ptr = snmp_stats.unknownengineids; - break; - case 5: /* usmStatsWrongDigests */ - *uint_ptr = snmp_stats.wrongdigests; - break; - case 6: /* usmStatsDecryptionErrors */ - *uint_ptr = snmp_stats.decryptionerrors; - break; - default: - LWIP_DEBUGF(SNMP_MIB_DEBUG, ("usmstats_scalars_get_value(): unknown id: %"S32_F"\n", node->oid)); - return 0; - } - - return sizeof(*uint_ptr); -} - -/* --- snmpUsmMIB ----------------------------------------------------- */ - -/* --- usmUser 1.3.6.1.6.3.15.1.2 ----------------------------------------------------- */ - -static const struct snmp_table_col_def usmusertable_columns[] = { - {3, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserSecurityName */ - {4, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserCloneFrom */ - {5, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserAuthProtocol */ - {6, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserAuthKeyChange */ - {7, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserOwnAuthKeyChange */ - {8, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserPrivProtocol */ - {9, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserPrivKeyChange */ - {10, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserOwnPrivKeyChange */ - {11, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserPublic */ - {12, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserStorageType */ - {13, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserStatus */ -}; -static const struct snmp_table_node usmusertable = SNMP_TABLE_CREATE(2, usmusertable_columns, usmusertable_get_instance, usmusertable_get_next_instance, usmusertable_get_value, NULL, NULL); - -static const struct snmp_node *const usmuser_subnodes[] = { - &usmusertable.node.node -}; -static const struct snmp_tree_node usmuser_treenode = SNMP_CREATE_TREE_NODE(2, usmuser_subnodes); - -/* --- usmMIBObjects 1.3.6.1.6.3.15.1 ----------------------------------------------------- */ -static const struct snmp_scalar_array_node_def usmstats_scalars_nodes[] = { - {1, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsUnsupportedSecLevels */ - {2, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsNotInTimeWindows */ - {3, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsUnknownUserNames */ - {4, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsUnknownEngineIDs */ - {5, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsWrongDigests */ - {6, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsDecryptionErrors */ -}; -static const struct snmp_scalar_array_node usmstats_scalars = SNMP_SCALAR_CREATE_ARRAY_NODE(1, usmstats_scalars_nodes, usmstats_scalars_get_value, NULL, NULL); - -static const struct snmp_node *const usmmibobjects_subnodes[] = { - &usmstats_scalars.node.node, - &usmuser_treenode.node -}; -static const struct snmp_tree_node usmmibobjects_treenode = SNMP_CREATE_TREE_NODE(1, usmmibobjects_subnodes); - -/* --- snmpUsmMIB ----------------------------------------------------- */ -static const struct snmp_node *const snmpusmmib_subnodes[] = { - &usmmibobjects_treenode.node -}; -static const struct snmp_tree_node snmpusmmib_root = SNMP_CREATE_TREE_NODE(15, snmpusmmib_subnodes); -static const u32_t snmpusmmib_base_oid[] = {1, 3, 6, 1, 6, 3, 15}; -const struct snmp_mib snmpusmmib = {snmpusmmib_base_oid, LWIP_ARRAYSIZE(snmpusmmib_base_oid), &snmpusmmib_root.node}; - -#endif /* LWIP_SNMP */ +/* +Generated by LwipMibCompiler +*/ + +#include "lwip/apps/snmp_opts.h" +#if LWIP_SNMP && LWIP_SNMP_V3 + +#include "lwip/apps/snmp_snmpv2_usm.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_scalar.h" +#include "lwip/apps/snmp_table.h" +#include "lwip/apps/snmpv3.h" +#include "snmpv3_priv.h" + +#include "lwip/apps/snmp_snmpv2_framework.h" + +#include + +/* --- usmUser 1.3.6.1.6.3.15.1.2 ----------------------------------------------------- */ + +static const struct snmp_oid_range usmUserTable_oid_ranges[] = { + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, + { 0, 0xff }, { 0, 0xff }, { 0, 0xff }, { 0, 0xff } +}; + +static void snmp_engineid_to_oid(const char *engineid, u32_t *oid, u32_t len) +{ + u8_t i; + + for (i = 0; i < len; i++) { + oid[i] = engineid[i]; + } +} + +static void snmp_oid_to_name(char *name, const u32_t *oid, size_t len) +{ + u8_t i; + + for (i = 0; i < len; i++) { + name[i] = (char)oid[i]; + } +} + +static void snmp_name_to_oid(const char *name, u32_t *oid, size_t len) +{ + u8_t i; + + for (i = 0; i < len; i++) { + oid[i] = name[i]; + } +} + +static const struct snmp_obj_id *snmp_auth_algo_to_oid(snmpv3_auth_algo_t algo) +{ + if (algo == SNMP_V3_AUTH_ALGO_MD5) { + return &usmHMACMD5AuthProtocol; + } else if (algo == SNMP_V3_AUTH_ALGO_SHA) { + return &usmHMACMD5AuthProtocol; + } + + return &usmNoAuthProtocol; +} + +static const struct snmp_obj_id *snmp_priv_algo_to_oid(snmpv3_priv_algo_t algo) +{ + if (algo == SNMP_V3_PRIV_ALGO_DES) { + return &usmDESPrivProtocol; + } else if (algo == SNMP_V3_PRIV_ALGO_AES) { + return &usmAESPrivProtocol; + } + + return &usmNoPrivProtocol; +} + +char username[32]; + +static snmp_err_t usmusertable_get_instance(const u32_t *column, const u32_t *row_oid, u8_t row_oid_len, struct snmp_node_instance *cell_instance) +{ + const char *engineid; + u8_t eid_len; + + u32_t engineid_oid[SNMP_V3_MAX_ENGINE_ID_LENGTH]; + + u8_t name_len; + u8_t engineid_len; + + u8_t name_start; + u8_t engineid_start; + + LWIP_UNUSED_ARG(column); + + snmpv3_get_engine_id(&engineid, &eid_len); + + engineid_len = (u8_t)row_oid[0]; + engineid_start = 1; + + if (engineid_len != eid_len) { + /* EngineID length does not match! */ + return SNMP_ERR_NOSUCHINSTANCE; + } + + if (engineid_len > row_oid_len) { + /* row OID doesn't contain enough data according to engineid_len.*/ + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(&row_oid[engineid_start], engineid_len, usmUserTable_oid_ranges, engineid_len)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + snmp_engineid_to_oid(engineid, engineid_oid, engineid_len); + + /* Verify EngineID */ + if (snmp_oid_equal(&row_oid[engineid_start], engineid_len, engineid_oid, engineid_len)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + name_len = (u8_t)row_oid[engineid_start + engineid_len]; + name_start = engineid_start + engineid_len + 1; + + if (name_len > SNMP_V3_MAX_USER_LENGTH) { + /* specified name is too long */ + return SNMP_ERR_NOSUCHINSTANCE; + } + + if (1 + engineid_len + 1 + name_len != row_oid_len) { + /* Length of EngineID and name does not match row oid length. (+2 for length fields)*/ + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* check if incoming OID length and if values are in plausible range */ + if (!snmp_oid_in_range(&row_oid[name_start], name_len, usmUserTable_oid_ranges, name_len)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* Verify if user exists */ + memset(username, 0, sizeof(username)); + snmp_oid_to_name(username, &row_oid[name_start], name_len); + if (snmpv3_get_user(username, NULL, NULL, NULL, NULL) != ERR_OK) { + return SNMP_ERR_NOSUCHINSTANCE; + } + + /* Save name in reference pointer to make it easier to handle later on */ + cell_instance->reference.ptr = username; + cell_instance->reference_len = name_len; + + /* user was found */ + return SNMP_ERR_NOERROR; +} + +/* + * valid oid options + * + * . + * .. + * .. + * ... + * .... + * .... + * + */ +static snmp_err_t usmusertable_get_next_instance(const u32_t *column, struct snmp_obj_id *row_oid, struct snmp_node_instance *cell_instance) +{ + const char *engineid; + u8_t eid_len; + + u32_t engineid_oid[SNMP_V3_MAX_ENGINE_ID_LENGTH]; + + u8_t name_len; + u8_t engineid_len; + + u8_t name_start; + u8_t engineid_start = 1; + u8_t i; + + struct snmp_next_oid_state state; + + u32_t result_temp[LWIP_ARRAYSIZE(usmUserTable_oid_ranges)]; + + LWIP_UNUSED_ARG(column); + + snmpv3_get_engine_id(&engineid, &eid_len); + + /* If EngineID might be given */ + if (row_oid->len > 0) { + engineid_len = (u8_t)row_oid->id[0]; + engineid_start = 1; + + if (engineid_len != eid_len) { + /* EngineID length does not match! */ + return SNMP_ERR_NOSUCHINSTANCE; + } + + if (engineid_len > row_oid->len) { + /* Verify partial EngineID */ + snmp_engineid_to_oid(engineid, engineid_oid, row_oid->len - 1); + if (!snmp_oid_equal(&row_oid->id[engineid_start], row_oid->len - 1, engineid_oid, row_oid->len - 1)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + } else { + /* Verify complete EngineID */ + snmp_engineid_to_oid(engineid, engineid_oid, engineid_len); + if (!snmp_oid_equal(&row_oid->id[engineid_start], engineid_len, engineid_oid, engineid_len)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + } + + /* At this point, the given EngineID (partially) matches the local EngineID.*/ + + /* If name might also be given */ + if (row_oid->len > engineid_start + engineid_len) { + name_len = (u8_t)row_oid->id[engineid_start + engineid_len]; + name_start = engineid_start + engineid_len + 1; + + if (name_len > SNMP_V3_MAX_USER_LENGTH) { + /* specified name is too long, max length is 32 according to mib file.*/ + return SNMP_ERR_NOSUCHINSTANCE; + } + + if (row_oid->len < engineid_len + name_len + 2) { + /* Partial name given according to oid.*/ + u8_t tmplen = row_oid->len - engineid_len - 2; + if (!snmp_oid_in_range(&row_oid->id[name_start], tmplen, usmUserTable_oid_ranges, tmplen)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + } else { + /* Full name given according to oid. Also test for too much data.*/ + u8_t tmplen = row_oid->len - engineid_len - 2; + if (!snmp_oid_in_range(&row_oid->id[name_start], name_len, usmUserTable_oid_ranges, tmplen)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + } + + /* At this point the EngineID and (partial) UserName match the local EngineID and UserName.*/ + } + } + + /* init struct to search next oid */ + snmp_next_oid_init(&state, row_oid->id, row_oid->len, result_temp, LWIP_ARRAYSIZE(usmUserTable_oid_ranges)); + + for (i = 0; i < snmpv3_get_amount_of_users(); i++) { + u32_t test_oid[LWIP_ARRAYSIZE(usmUserTable_oid_ranges)]; + + test_oid[0] = eid_len; + snmp_engineid_to_oid(engineid, &test_oid[1], eid_len); + + snmpv3_get_username(username, i); + + test_oid[1 + eid_len] = strlen(username); + snmp_name_to_oid(username, &test_oid[2 + eid_len], strlen(username)); + + /* check generated OID: is it a candidate for the next one? */ + snmp_next_oid_check(&state, test_oid, (u8_t)(1 + eid_len + 1 + strlen(username)), LWIP_PTR_NUMERIC_CAST(void *, i)); + } + + /* did we find a next one? */ + if (state.status == SNMP_NEXT_OID_STATUS_SUCCESS) { + snmp_oid_assign(row_oid, state.next_oid, state.next_oid_len); + /* store username for subsequent operations (get/test/set) */ + memset(username, 0, sizeof(username)); + snmpv3_get_username(username, LWIP_PTR_NUMERIC_CAST(u8_t, state.reference)); + cell_instance->reference.ptr = username; + cell_instance->reference_len = strlen(username); + return SNMP_ERR_NOERROR; + } + + /* not found */ + return SNMP_ERR_NOSUCHINSTANCE; +} + +static s16_t usmusertable_get_value(struct snmp_node_instance *cell_instance, void *value) +{ + snmpv3_user_storagetype_t storage_type; + + switch (SNMP_TABLE_GET_COLUMN_FROM_OID(cell_instance->instance_oid.id)) { + case 3: /* usmUserSecurityName */ + MEMCPY(value, cell_instance->reference.ptr, cell_instance->reference_len); + return (s16_t)cell_instance->reference_len; + case 4: /* usmUserCloneFrom */ + MEMCPY(value, snmp_zero_dot_zero.id, snmp_zero_dot_zero.len * sizeof(u32_t)); + return snmp_zero_dot_zero.len * sizeof(u32_t); + case 5: { /* usmUserAuthProtocol */ + const struct snmp_obj_id *auth_algo; + snmpv3_auth_algo_t auth_algo_val; + snmpv3_get_user((const char *)cell_instance->reference.ptr, &auth_algo_val, NULL, NULL, NULL); + auth_algo = snmp_auth_algo_to_oid(auth_algo_val); + MEMCPY(value, auth_algo->id, auth_algo->len * sizeof(u32_t)); + return auth_algo->len * sizeof(u32_t); + } + case 6: /* usmUserAuthKeyChange */ + return 0; + case 7: /* usmUserOwnAuthKeyChange */ + return 0; + case 8: { /* usmUserPrivProtocol */ + const struct snmp_obj_id *priv_algo; + snmpv3_priv_algo_t priv_algo_val; + snmpv3_get_user((const char *)cell_instance->reference.ptr, NULL, NULL, &priv_algo_val, NULL); + priv_algo = snmp_priv_algo_to_oid(priv_algo_val); + MEMCPY(value, priv_algo->id, priv_algo->len * sizeof(u32_t)); + return priv_algo->len * sizeof(u32_t); + } + case 9: /* usmUserPrivKeyChange */ + return 0; + case 10: /* usmUserOwnPrivKeyChange */ + return 0; + case 11: /* usmUserPublic */ + /* TODO: Implement usmUserPublic */ + return 0; + case 12: /* usmUserStorageType */ + snmpv3_get_user_storagetype((const char *)cell_instance->reference.ptr, &storage_type); + *(s32_t *)value = storage_type; + return sizeof(s32_t); + case 13: /* usmUserStatus */ + *(s32_t *)value = 1; /* active */ + return sizeof(s32_t); + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("usmusertable_get_value(): unknown id: %"S32_F"\n", SNMP_TABLE_GET_COLUMN_FROM_OID(cell_instance->instance_oid.id))); + return 0; + } +} + +/* --- usmMIBObjects 1.3.6.1.6.3.15.1 ----------------------------------------------------- */ +static s16_t usmstats_scalars_get_value(const struct snmp_scalar_array_node_def *node, void *value) +{ + u32_t *uint_ptr = (u32_t *)value; + switch (node->oid) { + case 1: /* usmStatsUnsupportedSecLevels */ + *uint_ptr = snmp_stats.unsupportedseclevels; + break; + case 2: /* usmStatsNotInTimeWindows */ + *uint_ptr = snmp_stats.notintimewindows; + break; + case 3: /* usmStatsUnknownUserNames */ + *uint_ptr = snmp_stats.unknownusernames; + break; + case 4: /* usmStatsUnknownEngineIDs */ + *uint_ptr = snmp_stats.unknownengineids; + break; + case 5: /* usmStatsWrongDigests */ + *uint_ptr = snmp_stats.wrongdigests; + break; + case 6: /* usmStatsDecryptionErrors */ + *uint_ptr = snmp_stats.decryptionerrors; + break; + default: + LWIP_DEBUGF(SNMP_MIB_DEBUG, ("usmstats_scalars_get_value(): unknown id: %"S32_F"\n", node->oid)); + return 0; + } + + return sizeof(*uint_ptr); +} + +/* --- snmpUsmMIB ----------------------------------------------------- */ + +/* --- usmUser 1.3.6.1.6.3.15.1.2 ----------------------------------------------------- */ + +static const struct snmp_table_col_def usmusertable_columns[] = { + {3, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserSecurityName */ + {4, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserCloneFrom */ + {5, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserAuthProtocol */ + {6, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserAuthKeyChange */ + {7, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserOwnAuthKeyChange */ + {8, SNMP_ASN1_TYPE_OBJECT_ID, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserPrivProtocol */ + {9, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserPrivKeyChange */ + {10, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserOwnPrivKeyChange */ + {11, SNMP_ASN1_TYPE_OCTET_STRING, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserPublic */ + {12, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserStorageType */ + {13, SNMP_ASN1_TYPE_INTEGER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmUserStatus */ +}; +static const struct snmp_table_node usmusertable = SNMP_TABLE_CREATE(2, usmusertable_columns, usmusertable_get_instance, usmusertable_get_next_instance, usmusertable_get_value, NULL, NULL); + +static const struct snmp_node *const usmuser_subnodes[] = { + &usmusertable.node.node +}; +static const struct snmp_tree_node usmuser_treenode = SNMP_CREATE_TREE_NODE(2, usmuser_subnodes); + +/* --- usmMIBObjects 1.3.6.1.6.3.15.1 ----------------------------------------------------- */ +static const struct snmp_scalar_array_node_def usmstats_scalars_nodes[] = { + {1, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsUnsupportedSecLevels */ + {2, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsNotInTimeWindows */ + {3, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsUnknownUserNames */ + {4, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsUnknownEngineIDs */ + {5, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsWrongDigests */ + {6, SNMP_ASN1_TYPE_COUNTER, SNMP_NODE_INSTANCE_READ_ONLY}, /* usmStatsDecryptionErrors */ +}; +static const struct snmp_scalar_array_node usmstats_scalars = SNMP_SCALAR_CREATE_ARRAY_NODE(1, usmstats_scalars_nodes, usmstats_scalars_get_value, NULL, NULL); + +static const struct snmp_node *const usmmibobjects_subnodes[] = { + &usmstats_scalars.node.node, + &usmuser_treenode.node +}; +static const struct snmp_tree_node usmmibobjects_treenode = SNMP_CREATE_TREE_NODE(1, usmmibobjects_subnodes); + +/* --- snmpUsmMIB ----------------------------------------------------- */ +static const struct snmp_node *const snmpusmmib_subnodes[] = { + &usmmibobjects_treenode.node +}; +static const struct snmp_tree_node snmpusmmib_root = SNMP_CREATE_TREE_NODE(15, snmpusmmib_subnodes); +static const u32_t snmpusmmib_base_oid[] = {1, 3, 6, 1, 6, 3, 15}; +const struct snmp_mib snmpusmmib = {snmpusmmib_base_oid, LWIP_ARRAYSIZE(snmpusmmib_base_oid), &snmpusmmib_root.node}; + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_table.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_table.c index 55d744b5..4b77a474 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_table.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_table.c @@ -1,342 +1,342 @@ -/** - * @file - * SNMP table support implementation. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/snmp_core.h" -#include "lwip/apps/snmp_table.h" -#include - -snmp_err_t snmp_table_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - snmp_err_t ret = SNMP_ERR_NOSUCHINSTANCE; - const struct snmp_table_node *table_node = (const struct snmp_table_node *)(const void *)instance->node; - - LWIP_UNUSED_ARG(root_oid); - LWIP_UNUSED_ARG(root_oid_len); - - /* check min. length (fixed row entry definition, column, row instance oid with at least one entry */ - /* fixed row entry always has oid 1 */ - if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) { - /* search column */ - const struct snmp_table_col_def *col_def = table_node->columns; - u16_t i = table_node->column_count; - while (i > 0) { - if (col_def->index == instance->instance_oid.id[1]) { - break; - } - - col_def++; - i--; - } - - if (i > 0) { - /* everything may be overwritten by get_cell_instance_method() in order to implement special handling for single columns/cells */ - instance->asn1_type = col_def->asn1_type; - instance->access = col_def->access; - instance->get_value = table_node->get_value; - instance->set_test = table_node->set_test; - instance->set_value = table_node->set_value; - - ret = table_node->get_cell_instance( - &(instance->instance_oid.id[1]), - &(instance->instance_oid.id[2]), - instance->instance_oid.len - 2, - instance); - } - } - - return ret; -} - -snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - const struct snmp_table_node *table_node = (const struct snmp_table_node *)(const void *)instance->node; - const struct snmp_table_col_def *col_def; - struct snmp_obj_id row_oid; - u32_t column = 0; - snmp_err_t result; - - LWIP_UNUSED_ARG(root_oid); - LWIP_UNUSED_ARG(root_oid_len); - - /* check that first part of id is 0 or 1, referencing fixed row entry */ - if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - if (instance->instance_oid.len > 1) { - column = instance->instance_oid.id[1]; - } - if (instance->instance_oid.len > 2) { - snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2); - } else { - row_oid.len = 0; - } - - instance->get_value = table_node->get_value; - instance->set_test = table_node->set_test; - instance->set_value = table_node->set_value; - - /* resolve column and value */ - do { - u16_t i; - const struct snmp_table_col_def *next_col_def = NULL; - col_def = table_node->columns; - - for (i = 0; i < table_node->column_count; i++) { - if (col_def->index == column) { - next_col_def = col_def; - break; - } else if ((col_def->index > column) && ((next_col_def == NULL) || (col_def->index < next_col_def->index))) { - next_col_def = col_def; - } - col_def++; - } - - if (next_col_def == NULL) { - /* no further column found */ - return SNMP_ERR_NOSUCHINSTANCE; - } - - instance->asn1_type = next_col_def->asn1_type; - instance->access = next_col_def->access; - - result = table_node->get_next_cell_instance( - &next_col_def->index, - &row_oid, - instance); - - if (result == SNMP_ERR_NOERROR) { - col_def = next_col_def; - break; - } - - row_oid.len = 0; /* reset row_oid because we switch to next column and start with the first entry there */ - column = next_col_def->index + 1; - } while (1); - - /* build resulting oid */ - instance->instance_oid.len = 2; - instance->instance_oid.id[0] = 1; - instance->instance_oid.id[1] = col_def->index; - snmp_oid_append(&instance->instance_oid, row_oid.id, row_oid.len); - - return SNMP_ERR_NOERROR; -} - - -snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - snmp_err_t ret = SNMP_ERR_NOSUCHINSTANCE; - const struct snmp_table_simple_node *table_node = (const struct snmp_table_simple_node *)(const void *)instance->node; - - LWIP_UNUSED_ARG(root_oid); - LWIP_UNUSED_ARG(root_oid_len); - - /* check min. length (fixed row entry definition, column, row instance oid with at least one entry */ - /* fixed row entry always has oid 1 */ - if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) { - ret = table_node->get_cell_value( - &(instance->instance_oid.id[1]), - &(instance->instance_oid.id[2]), - instance->instance_oid.len - 2, - &instance->reference, - &instance->reference_len); - - if (ret == SNMP_ERR_NOERROR) { - /* search column */ - const struct snmp_table_simple_col_def *col_def = table_node->columns; - u32_t i = table_node->column_count; - while (i > 0) { - if (col_def->index == instance->instance_oid.id[1]) { - break; - } - - col_def++; - i--; - } - - if (i > 0) { - instance->asn1_type = col_def->asn1_type; - instance->access = SNMP_NODE_INSTANCE_READ_ONLY; - instance->set_test = NULL; - instance->set_value = NULL; - - switch (col_def->data_type) { - case SNMP_VARIANT_VALUE_TYPE_U32: - instance->get_value = snmp_table_extract_value_from_u32ref; - break; - case SNMP_VARIANT_VALUE_TYPE_S32: - instance->get_value = snmp_table_extract_value_from_s32ref; - break; - case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */ - case SNMP_VARIANT_VALUE_TYPE_CONST_PTR: - instance->get_value = snmp_table_extract_value_from_refconstptr; - break; - default: - LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type)); - return SNMP_ERR_GENERROR; - } - - ret = SNMP_ERR_NOERROR; - } else { - ret = SNMP_ERR_NOSUCHINSTANCE; - } - } - } - - return ret; -} - -snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - const struct snmp_table_simple_node *table_node = (const struct snmp_table_simple_node *)(const void *)instance->node; - const struct snmp_table_simple_col_def *col_def; - struct snmp_obj_id row_oid; - u32_t column = 0; - snmp_err_t result; - - LWIP_UNUSED_ARG(root_oid); - LWIP_UNUSED_ARG(root_oid_len); - - /* check that first part of id is 0 or 1, referencing fixed row entry */ - if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) { - return SNMP_ERR_NOSUCHINSTANCE; - } - if (instance->instance_oid.len > 1) { - column = instance->instance_oid.id[1]; - } - if (instance->instance_oid.len > 2) { - snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2); - } else { - row_oid.len = 0; - } - - /* resolve column and value */ - do { - u32_t i; - const struct snmp_table_simple_col_def *next_col_def = NULL; - col_def = table_node->columns; - - for (i = 0; i < table_node->column_count; i++) { - if (col_def->index == column) { - next_col_def = col_def; - break; - } else if ((col_def->index > column) && ((next_col_def == NULL) || - (col_def->index < next_col_def->index))) { - next_col_def = col_def; - } - col_def++; - } - - if (next_col_def == NULL) { - /* no further column found */ - return SNMP_ERR_NOSUCHINSTANCE; - } - - result = table_node->get_next_cell_instance_and_value( - &next_col_def->index, - &row_oid, - &instance->reference, - &instance->reference_len); - - if (result == SNMP_ERR_NOERROR) { - col_def = next_col_def; - break; - } - - row_oid.len = 0; /* reset row_oid because we switch to next column and start with the first entry there */ - column = next_col_def->index + 1; - } while (1); - - instance->asn1_type = col_def->asn1_type; - instance->access = SNMP_NODE_INSTANCE_READ_ONLY; - instance->set_test = NULL; - instance->set_value = NULL; - - switch (col_def->data_type) { - case SNMP_VARIANT_VALUE_TYPE_U32: - instance->get_value = snmp_table_extract_value_from_u32ref; - break; - case SNMP_VARIANT_VALUE_TYPE_S32: - instance->get_value = snmp_table_extract_value_from_s32ref; - break; - case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */ - case SNMP_VARIANT_VALUE_TYPE_CONST_PTR: - instance->get_value = snmp_table_extract_value_from_refconstptr; - break; - default: - LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type)); - return SNMP_ERR_GENERROR; - } - - /* build resulting oid */ - instance->instance_oid.len = 2; - instance->instance_oid.id[0] = 1; - instance->instance_oid.id[1] = col_def->index; - snmp_oid_append(&instance->instance_oid, row_oid.id, row_oid.len); - - return SNMP_ERR_NOERROR; -} - - -s16_t -snmp_table_extract_value_from_s32ref(struct snmp_node_instance *instance, void *value) -{ - s32_t *dst = (s32_t *)value; - *dst = instance->reference.s32; - return sizeof(*dst); -} - -s16_t -snmp_table_extract_value_from_u32ref(struct snmp_node_instance *instance, void *value) -{ - u32_t *dst = (u32_t *)value; - *dst = instance->reference.u32; - return sizeof(*dst); -} - -s16_t -snmp_table_extract_value_from_refconstptr(struct snmp_node_instance *instance, void *value) -{ - MEMCPY(value, instance->reference.const_ptr, instance->reference_len); - return (u16_t)instance->reference_len; -} - -#endif /* LWIP_SNMP */ +/** + * @file + * SNMP table support implementation. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/snmp_core.h" +#include "lwip/apps/snmp_table.h" +#include + +snmp_err_t snmp_table_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + snmp_err_t ret = SNMP_ERR_NOSUCHINSTANCE; + const struct snmp_table_node *table_node = (const struct snmp_table_node *)(const void *)instance->node; + + LWIP_UNUSED_ARG(root_oid); + LWIP_UNUSED_ARG(root_oid_len); + + /* check min. length (fixed row entry definition, column, row instance oid with at least one entry */ + /* fixed row entry always has oid 1 */ + if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) { + /* search column */ + const struct snmp_table_col_def *col_def = table_node->columns; + u16_t i = table_node->column_count; + while (i > 0) { + if (col_def->index == instance->instance_oid.id[1]) { + break; + } + + col_def++; + i--; + } + + if (i > 0) { + /* everything may be overwritten by get_cell_instance_method() in order to implement special handling for single columns/cells */ + instance->asn1_type = col_def->asn1_type; + instance->access = col_def->access; + instance->get_value = table_node->get_value; + instance->set_test = table_node->set_test; + instance->set_value = table_node->set_value; + + ret = table_node->get_cell_instance( + &(instance->instance_oid.id[1]), + &(instance->instance_oid.id[2]), + instance->instance_oid.len - 2, + instance); + } + } + + return ret; +} + +snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + const struct snmp_table_node *table_node = (const struct snmp_table_node *)(const void *)instance->node; + const struct snmp_table_col_def *col_def; + struct snmp_obj_id row_oid; + u32_t column = 0; + snmp_err_t result; + + LWIP_UNUSED_ARG(root_oid); + LWIP_UNUSED_ARG(root_oid_len); + + /* check that first part of id is 0 or 1, referencing fixed row entry */ + if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + if (instance->instance_oid.len > 1) { + column = instance->instance_oid.id[1]; + } + if (instance->instance_oid.len > 2) { + snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2); + } else { + row_oid.len = 0; + } + + instance->get_value = table_node->get_value; + instance->set_test = table_node->set_test; + instance->set_value = table_node->set_value; + + /* resolve column and value */ + do { + u16_t i; + const struct snmp_table_col_def *next_col_def = NULL; + col_def = table_node->columns; + + for (i = 0; i < table_node->column_count; i++) { + if (col_def->index == column) { + next_col_def = col_def; + break; + } else if ((col_def->index > column) && ((next_col_def == NULL) || (col_def->index < next_col_def->index))) { + next_col_def = col_def; + } + col_def++; + } + + if (next_col_def == NULL) { + /* no further column found */ + return SNMP_ERR_NOSUCHINSTANCE; + } + + instance->asn1_type = next_col_def->asn1_type; + instance->access = next_col_def->access; + + result = table_node->get_next_cell_instance( + &next_col_def->index, + &row_oid, + instance); + + if (result == SNMP_ERR_NOERROR) { + col_def = next_col_def; + break; + } + + row_oid.len = 0; /* reset row_oid because we switch to next column and start with the first entry there */ + column = next_col_def->index + 1; + } while (1); + + /* build resulting oid */ + instance->instance_oid.len = 2; + instance->instance_oid.id[0] = 1; + instance->instance_oid.id[1] = col_def->index; + snmp_oid_append(&instance->instance_oid, row_oid.id, row_oid.len); + + return SNMP_ERR_NOERROR; +} + + +snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + snmp_err_t ret = SNMP_ERR_NOSUCHINSTANCE; + const struct snmp_table_simple_node *table_node = (const struct snmp_table_simple_node *)(const void *)instance->node; + + LWIP_UNUSED_ARG(root_oid); + LWIP_UNUSED_ARG(root_oid_len); + + /* check min. length (fixed row entry definition, column, row instance oid with at least one entry */ + /* fixed row entry always has oid 1 */ + if ((instance->instance_oid.len >= 3) && (instance->instance_oid.id[0] == 1)) { + ret = table_node->get_cell_value( + &(instance->instance_oid.id[1]), + &(instance->instance_oid.id[2]), + instance->instance_oid.len - 2, + &instance->reference, + &instance->reference_len); + + if (ret == SNMP_ERR_NOERROR) { + /* search column */ + const struct snmp_table_simple_col_def *col_def = table_node->columns; + u32_t i = table_node->column_count; + while (i > 0) { + if (col_def->index == instance->instance_oid.id[1]) { + break; + } + + col_def++; + i--; + } + + if (i > 0) { + instance->asn1_type = col_def->asn1_type; + instance->access = SNMP_NODE_INSTANCE_READ_ONLY; + instance->set_test = NULL; + instance->set_value = NULL; + + switch (col_def->data_type) { + case SNMP_VARIANT_VALUE_TYPE_U32: + instance->get_value = snmp_table_extract_value_from_u32ref; + break; + case SNMP_VARIANT_VALUE_TYPE_S32: + instance->get_value = snmp_table_extract_value_from_s32ref; + break; + case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */ + case SNMP_VARIANT_VALUE_TYPE_CONST_PTR: + instance->get_value = snmp_table_extract_value_from_refconstptr; + break; + default: + LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type)); + return SNMP_ERR_GENERROR; + } + + ret = SNMP_ERR_NOERROR; + } else { + ret = SNMP_ERR_NOSUCHINSTANCE; + } + } + } + + return ret; +} + +snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + const struct snmp_table_simple_node *table_node = (const struct snmp_table_simple_node *)(const void *)instance->node; + const struct snmp_table_simple_col_def *col_def; + struct snmp_obj_id row_oid; + u32_t column = 0; + snmp_err_t result; + + LWIP_UNUSED_ARG(root_oid); + LWIP_UNUSED_ARG(root_oid_len); + + /* check that first part of id is 0 or 1, referencing fixed row entry */ + if ((instance->instance_oid.len > 0) && (instance->instance_oid.id[0] > 1)) { + return SNMP_ERR_NOSUCHINSTANCE; + } + if (instance->instance_oid.len > 1) { + column = instance->instance_oid.id[1]; + } + if (instance->instance_oid.len > 2) { + snmp_oid_assign(&row_oid, &(instance->instance_oid.id[2]), instance->instance_oid.len - 2); + } else { + row_oid.len = 0; + } + + /* resolve column and value */ + do { + u32_t i; + const struct snmp_table_simple_col_def *next_col_def = NULL; + col_def = table_node->columns; + + for (i = 0; i < table_node->column_count; i++) { + if (col_def->index == column) { + next_col_def = col_def; + break; + } else if ((col_def->index > column) && ((next_col_def == NULL) || + (col_def->index < next_col_def->index))) { + next_col_def = col_def; + } + col_def++; + } + + if (next_col_def == NULL) { + /* no further column found */ + return SNMP_ERR_NOSUCHINSTANCE; + } + + result = table_node->get_next_cell_instance_and_value( + &next_col_def->index, + &row_oid, + &instance->reference, + &instance->reference_len); + + if (result == SNMP_ERR_NOERROR) { + col_def = next_col_def; + break; + } + + row_oid.len = 0; /* reset row_oid because we switch to next column and start with the first entry there */ + column = next_col_def->index + 1; + } while (1); + + instance->asn1_type = col_def->asn1_type; + instance->access = SNMP_NODE_INSTANCE_READ_ONLY; + instance->set_test = NULL; + instance->set_value = NULL; + + switch (col_def->data_type) { + case SNMP_VARIANT_VALUE_TYPE_U32: + instance->get_value = snmp_table_extract_value_from_u32ref; + break; + case SNMP_VARIANT_VALUE_TYPE_S32: + instance->get_value = snmp_table_extract_value_from_s32ref; + break; + case SNMP_VARIANT_VALUE_TYPE_PTR: /* fall through */ + case SNMP_VARIANT_VALUE_TYPE_CONST_PTR: + instance->get_value = snmp_table_extract_value_from_refconstptr; + break; + default: + LWIP_DEBUGF(SNMP_DEBUG, ("snmp_table_simple_get_instance(): unknown column data_type: %d\n", col_def->data_type)); + return SNMP_ERR_GENERROR; + } + + /* build resulting oid */ + instance->instance_oid.len = 2; + instance->instance_oid.id[0] = 1; + instance->instance_oid.id[1] = col_def->index; + snmp_oid_append(&instance->instance_oid, row_oid.id, row_oid.len); + + return SNMP_ERR_NOERROR; +} + + +s16_t +snmp_table_extract_value_from_s32ref(struct snmp_node_instance *instance, void *value) +{ + s32_t *dst = (s32_t *)value; + *dst = instance->reference.s32; + return sizeof(*dst); +} + +s16_t +snmp_table_extract_value_from_u32ref(struct snmp_node_instance *instance, void *value) +{ + u32_t *dst = (u32_t *)value; + *dst = instance->reference.u32; + return sizeof(*dst); +} + +s16_t +snmp_table_extract_value_from_refconstptr(struct snmp_node_instance *instance, void *value) +{ + MEMCPY(value, instance->reference.const_ptr, instance->reference_len); + return (u16_t)instance->reference_len; +} + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_threadsync.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_threadsync.c index 764856dd..56d98862 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_threadsync.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_threadsync.c @@ -1,231 +1,231 @@ -/** - * @file - * SNMP thread synchronization implementation. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dirk Ziegelmeier - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP && (NO_SYS == 0) /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/snmp_threadsync.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/sys.h" -#include - -static void -call_synced_function(struct threadsync_data *call_data, snmp_threadsync_called_fn fn) -{ - sys_mutex_lock(&call_data->threadsync_node->instance->sem_usage_mutex); - call_data->threadsync_node->instance->sync_fn(fn, call_data); - sys_sem_wait(&call_data->threadsync_node->instance->sem); - sys_mutex_unlock(&call_data->threadsync_node->instance->sem_usage_mutex); -} - -static void -threadsync_get_value_synced(void *ctx) -{ - struct threadsync_data *call_data = (struct threadsync_data *)ctx; - - if (call_data->proxy_instance.get_value != NULL) { - call_data->retval.s16 = call_data->proxy_instance.get_value(&call_data->proxy_instance, call_data->arg1.value); - } else { - call_data->retval.s16 = -1; - } - - sys_sem_signal(&call_data->threadsync_node->instance->sem); -} - -static s16_t -threadsync_get_value(struct snmp_node_instance *instance, void *value) -{ - struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; - - call_data->arg1.value = value; - call_synced_function(call_data, threadsync_get_value_synced); - - return call_data->retval.s16; -} - -static void -threadsync_set_test_synced(void *ctx) -{ - struct threadsync_data *call_data = (struct threadsync_data *)ctx; - - if (call_data->proxy_instance.set_test != NULL) { - call_data->retval.err = call_data->proxy_instance.set_test(&call_data->proxy_instance, call_data->arg2.len, call_data->arg1.value); - } else { - call_data->retval.err = SNMP_ERR_NOTWRITABLE; - } - - sys_sem_signal(&call_data->threadsync_node->instance->sem); -} - -static snmp_err_t -threadsync_set_test(struct snmp_node_instance *instance, u16_t len, void *value) -{ - struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; - - call_data->arg1.value = value; - call_data->arg2.len = len; - call_synced_function(call_data, threadsync_set_test_synced); - - return call_data->retval.err; -} - -static void -threadsync_set_value_synced(void *ctx) -{ - struct threadsync_data *call_data = (struct threadsync_data *)ctx; - - if (call_data->proxy_instance.set_value != NULL) { - call_data->retval.err = call_data->proxy_instance.set_value(&call_data->proxy_instance, call_data->arg2.len, call_data->arg1.value); - } else { - call_data->retval.err = SNMP_ERR_NOTWRITABLE; - } - - sys_sem_signal(&call_data->threadsync_node->instance->sem); -} - -static snmp_err_t -threadsync_set_value(struct snmp_node_instance *instance, u16_t len, void *value) -{ - struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; - - call_data->arg1.value = value; - call_data->arg2.len = len; - call_synced_function(call_data, threadsync_set_value_synced); - - return call_data->retval.err; -} - -static void -threadsync_release_instance_synced(void *ctx) -{ - struct threadsync_data *call_data = (struct threadsync_data *)ctx; - - call_data->proxy_instance.release_instance(&call_data->proxy_instance); - - sys_sem_signal(&call_data->threadsync_node->instance->sem); -} - -static void -threadsync_release_instance(struct snmp_node_instance *instance) -{ - struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; - - if (call_data->proxy_instance.release_instance != NULL) { - call_synced_function(call_data, threadsync_release_instance_synced); - } -} - -static void -get_instance_synced(void *ctx) -{ - struct threadsync_data *call_data = (struct threadsync_data *)ctx; - const struct snmp_leaf_node *leaf = (const struct snmp_leaf_node *)(const void *)call_data->proxy_instance.node; - - call_data->retval.err = leaf->get_instance(call_data->arg1.root_oid, call_data->arg2.root_oid_len, &call_data->proxy_instance); - - sys_sem_signal(&call_data->threadsync_node->instance->sem); -} - -static void -get_next_instance_synced(void *ctx) -{ - struct threadsync_data *call_data = (struct threadsync_data *)ctx; - const struct snmp_leaf_node *leaf = (const struct snmp_leaf_node *)(const void *)call_data->proxy_instance.node; - - call_data->retval.err = leaf->get_next_instance(call_data->arg1.root_oid, call_data->arg2.root_oid_len, &call_data->proxy_instance); - - sys_sem_signal(&call_data->threadsync_node->instance->sem); -} - -static snmp_err_t -do_sync(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance, snmp_threadsync_called_fn fn) -{ - const struct snmp_threadsync_node *threadsync_node = (const struct snmp_threadsync_node *)(const void *)instance->node; - struct threadsync_data *call_data = &threadsync_node->instance->data; - - if (threadsync_node->node.node.oid != threadsync_node->target->node.oid) { - LWIP_DEBUGF(SNMP_DEBUG, ("Sync node OID does not match target node OID")); - return SNMP_ERR_NOSUCHINSTANCE; - } - - memset(&call_data->proxy_instance, 0, sizeof(call_data->proxy_instance)); - - instance->reference.ptr = call_data; - snmp_oid_assign(&call_data->proxy_instance.instance_oid, instance->instance_oid.id, instance->instance_oid.len); - - call_data->proxy_instance.node = &threadsync_node->target->node; - call_data->threadsync_node = threadsync_node; - - call_data->arg1.root_oid = root_oid; - call_data->arg2.root_oid_len = root_oid_len; - call_synced_function(call_data, fn); - - if (call_data->retval.err == SNMP_ERR_NOERROR) { - instance->access = call_data->proxy_instance.access; - instance->asn1_type = call_data->proxy_instance.asn1_type; - instance->release_instance = threadsync_release_instance; - instance->get_value = (call_data->proxy_instance.get_value != NULL) ? threadsync_get_value : NULL; - instance->set_value = (call_data->proxy_instance.set_value != NULL) ? threadsync_set_value : NULL; - instance->set_test = (call_data->proxy_instance.set_test != NULL) ? threadsync_set_test : NULL; - snmp_oid_assign(&instance->instance_oid, call_data->proxy_instance.instance_oid.id, call_data->proxy_instance.instance_oid.len); - } - - return call_data->retval.err; -} - -snmp_err_t -snmp_threadsync_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - return do_sync(root_oid, root_oid_len, instance, get_instance_synced); -} - -snmp_err_t -snmp_threadsync_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) -{ - return do_sync(root_oid, root_oid_len, instance, get_next_instance_synced); -} - -/** Initializes thread synchronization instance */ -void snmp_threadsync_init(struct snmp_threadsync_instance *instance, snmp_threadsync_synchronizer_fn sync_fn) -{ - err_t err = sys_mutex_new(&instance->sem_usage_mutex); - LWIP_ASSERT("Failed to set up mutex", err == ERR_OK); - err = sys_sem_new(&instance->sem, 0); - LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */ - LWIP_ASSERT("Failed to set up semaphore", err == ERR_OK); - instance->sync_fn = sync_fn; -} - -#endif /* LWIP_SNMP */ +/** + * @file + * SNMP thread synchronization implementation. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dirk Ziegelmeier + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP && (NO_SYS == 0) /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/snmp_threadsync.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/sys.h" +#include + +static void +call_synced_function(struct threadsync_data *call_data, snmp_threadsync_called_fn fn) +{ + sys_mutex_lock(&call_data->threadsync_node->instance->sem_usage_mutex); + call_data->threadsync_node->instance->sync_fn(fn, call_data); + sys_sem_wait(&call_data->threadsync_node->instance->sem); + sys_mutex_unlock(&call_data->threadsync_node->instance->sem_usage_mutex); +} + +static void +threadsync_get_value_synced(void *ctx) +{ + struct threadsync_data *call_data = (struct threadsync_data *)ctx; + + if (call_data->proxy_instance.get_value != NULL) { + call_data->retval.s16 = call_data->proxy_instance.get_value(&call_data->proxy_instance, call_data->arg1.value); + } else { + call_data->retval.s16 = -1; + } + + sys_sem_signal(&call_data->threadsync_node->instance->sem); +} + +static s16_t +threadsync_get_value(struct snmp_node_instance *instance, void *value) +{ + struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; + + call_data->arg1.value = value; + call_synced_function(call_data, threadsync_get_value_synced); + + return call_data->retval.s16; +} + +static void +threadsync_set_test_synced(void *ctx) +{ + struct threadsync_data *call_data = (struct threadsync_data *)ctx; + + if (call_data->proxy_instance.set_test != NULL) { + call_data->retval.err = call_data->proxy_instance.set_test(&call_data->proxy_instance, call_data->arg2.len, call_data->arg1.value); + } else { + call_data->retval.err = SNMP_ERR_NOTWRITABLE; + } + + sys_sem_signal(&call_data->threadsync_node->instance->sem); +} + +static snmp_err_t +threadsync_set_test(struct snmp_node_instance *instance, u16_t len, void *value) +{ + struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; + + call_data->arg1.value = value; + call_data->arg2.len = len; + call_synced_function(call_data, threadsync_set_test_synced); + + return call_data->retval.err; +} + +static void +threadsync_set_value_synced(void *ctx) +{ + struct threadsync_data *call_data = (struct threadsync_data *)ctx; + + if (call_data->proxy_instance.set_value != NULL) { + call_data->retval.err = call_data->proxy_instance.set_value(&call_data->proxy_instance, call_data->arg2.len, call_data->arg1.value); + } else { + call_data->retval.err = SNMP_ERR_NOTWRITABLE; + } + + sys_sem_signal(&call_data->threadsync_node->instance->sem); +} + +static snmp_err_t +threadsync_set_value(struct snmp_node_instance *instance, u16_t len, void *value) +{ + struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; + + call_data->arg1.value = value; + call_data->arg2.len = len; + call_synced_function(call_data, threadsync_set_value_synced); + + return call_data->retval.err; +} + +static void +threadsync_release_instance_synced(void *ctx) +{ + struct threadsync_data *call_data = (struct threadsync_data *)ctx; + + call_data->proxy_instance.release_instance(&call_data->proxy_instance); + + sys_sem_signal(&call_data->threadsync_node->instance->sem); +} + +static void +threadsync_release_instance(struct snmp_node_instance *instance) +{ + struct threadsync_data *call_data = (struct threadsync_data *)instance->reference.ptr; + + if (call_data->proxy_instance.release_instance != NULL) { + call_synced_function(call_data, threadsync_release_instance_synced); + } +} + +static void +get_instance_synced(void *ctx) +{ + struct threadsync_data *call_data = (struct threadsync_data *)ctx; + const struct snmp_leaf_node *leaf = (const struct snmp_leaf_node *)(const void *)call_data->proxy_instance.node; + + call_data->retval.err = leaf->get_instance(call_data->arg1.root_oid, call_data->arg2.root_oid_len, &call_data->proxy_instance); + + sys_sem_signal(&call_data->threadsync_node->instance->sem); +} + +static void +get_next_instance_synced(void *ctx) +{ + struct threadsync_data *call_data = (struct threadsync_data *)ctx; + const struct snmp_leaf_node *leaf = (const struct snmp_leaf_node *)(const void *)call_data->proxy_instance.node; + + call_data->retval.err = leaf->get_next_instance(call_data->arg1.root_oid, call_data->arg2.root_oid_len, &call_data->proxy_instance); + + sys_sem_signal(&call_data->threadsync_node->instance->sem); +} + +static snmp_err_t +do_sync(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance, snmp_threadsync_called_fn fn) +{ + const struct snmp_threadsync_node *threadsync_node = (const struct snmp_threadsync_node *)(const void *)instance->node; + struct threadsync_data *call_data = &threadsync_node->instance->data; + + if (threadsync_node->node.node.oid != threadsync_node->target->node.oid) { + LWIP_DEBUGF(SNMP_DEBUG, ("Sync node OID does not match target node OID")); + return SNMP_ERR_NOSUCHINSTANCE; + } + + memset(&call_data->proxy_instance, 0, sizeof(call_data->proxy_instance)); + + instance->reference.ptr = call_data; + snmp_oid_assign(&call_data->proxy_instance.instance_oid, instance->instance_oid.id, instance->instance_oid.len); + + call_data->proxy_instance.node = &threadsync_node->target->node; + call_data->threadsync_node = threadsync_node; + + call_data->arg1.root_oid = root_oid; + call_data->arg2.root_oid_len = root_oid_len; + call_synced_function(call_data, fn); + + if (call_data->retval.err == SNMP_ERR_NOERROR) { + instance->access = call_data->proxy_instance.access; + instance->asn1_type = call_data->proxy_instance.asn1_type; + instance->release_instance = threadsync_release_instance; + instance->get_value = (call_data->proxy_instance.get_value != NULL) ? threadsync_get_value : NULL; + instance->set_value = (call_data->proxy_instance.set_value != NULL) ? threadsync_set_value : NULL; + instance->set_test = (call_data->proxy_instance.set_test != NULL) ? threadsync_set_test : NULL; + snmp_oid_assign(&instance->instance_oid, call_data->proxy_instance.instance_oid.id, call_data->proxy_instance.instance_oid.len); + } + + return call_data->retval.err; +} + +snmp_err_t +snmp_threadsync_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + return do_sync(root_oid, root_oid_len, instance, get_instance_synced); +} + +snmp_err_t +snmp_threadsync_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance *instance) +{ + return do_sync(root_oid, root_oid_len, instance, get_next_instance_synced); +} + +/** Initializes thread synchronization instance */ +void snmp_threadsync_init(struct snmp_threadsync_instance *instance, snmp_threadsync_synchronizer_fn sync_fn) +{ + err_t err = sys_mutex_new(&instance->sem_usage_mutex); + LWIP_ASSERT("Failed to set up mutex", err == ERR_OK); + err = sys_sem_new(&instance->sem, 0); + LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */ + LWIP_ASSERT("Failed to set up semaphore", err == ERR_OK); + instance->sync_fn = sync_fn; +} + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_traps.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_traps.c index 002596a1..3c9c8176 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_traps.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmp_traps.c @@ -1,458 +1,458 @@ -/** - * @file - * SNMPv1 traps implementation. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * Christiaan Simons - * - */ - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include - -#include "lwip/snmp.h" -#include "lwip/sys.h" -#include "lwip/apps/snmp.h" -#include "lwip/apps/snmp_core.h" -#include "lwip/prot/iana.h" -#include "snmp_msg.h" -#include "snmp_asn1.h" -#include "snmp_core_priv.h" - -struct snmp_msg_trap { - /* source enterprise ID (sysObjectID) */ - const struct snmp_obj_id *enterprise; - /* source IP address, raw network order format */ - ip_addr_t sip; - /* generic trap code */ - u32_t gen_trap; - /* specific trap code */ - u32_t spc_trap; - /* timestamp */ - u32_t ts; - /* snmp_version */ - u32_t snmp_version; - - /* output trap lengths used in ASN encoding */ - /* encoding pdu length */ - u16_t pdulen; - /* encoding community length */ - u16_t comlen; - /* encoding sequence length */ - u16_t seqlen; - /* encoding varbinds sequence length */ - u16_t vbseqlen; -}; - -static u16_t snmp_trap_varbind_sum(struct snmp_msg_trap *trap, struct snmp_varbind *varbinds); -static u16_t snmp_trap_header_sum(struct snmp_msg_trap *trap, u16_t vb_len); -static err_t snmp_trap_header_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream); -static err_t snmp_trap_varbind_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbinds); - -#define BUILD_EXEC(code) \ - if ((code) != ERR_OK) { \ - LWIP_DEBUGF(SNMP_DEBUG, ("SNMP error during creation of outbound trap frame!")); \ - return ERR_ARG; \ - } - -/** Agent community string for sending traps */ -extern const char *snmp_community_trap; - -void *snmp_traps_handle; - -struct snmp_trap_dst { - /* destination IP address in network order */ - ip_addr_t dip; - /* set to 0 when disabled, >0 when enabled */ - u8_t enable; -}; -static struct snmp_trap_dst trap_dst[SNMP_TRAP_DESTINATIONS]; - -static u8_t snmp_auth_traps_enabled = 0; - -/** - * @ingroup snmp_traps - * Sets enable switch for this trap destination. - * @param dst_idx index in 0 .. SNMP_TRAP_DESTINATIONS-1 - * @param enable switch if 0 destination is disabled >0 enabled. - */ -void -snmp_trap_dst_enable(u8_t dst_idx, u8_t enable) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (dst_idx < SNMP_TRAP_DESTINATIONS) { - trap_dst[dst_idx].enable = enable; - } -} - -/** - * @ingroup snmp_traps - * Sets IPv4 address for this trap destination. - * @param dst_idx index in 0 .. SNMP_TRAP_DESTINATIONS-1 - * @param dst IPv4 address in host order. - */ -void -snmp_trap_dst_ip_set(u8_t dst_idx, const ip_addr_t *dst) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (dst_idx < SNMP_TRAP_DESTINATIONS) { - ip_addr_set(&trap_dst[dst_idx].dip, dst); - } -} - -/** - * @ingroup snmp_traps - * Enable/disable authentication traps - */ -void -snmp_set_auth_traps_enabled(u8_t enable) -{ - snmp_auth_traps_enabled = enable; -} - -/** - * @ingroup snmp_traps - * Get authentication traps enabled state - */ -u8_t -snmp_get_auth_traps_enabled(void) -{ - return snmp_auth_traps_enabled; -} - - -/** - * @ingroup snmp_traps - * Sends a generic or enterprise specific trap message. - * - * @param eoid points to enterprise object identifier - * @param generic_trap is the trap code - * @param specific_trap used for enterprise traps when generic_trap == 6 - * @param varbinds linked list of varbinds to be sent - * @return ERR_OK when success, ERR_MEM if we're out of memory - * - * @note the use of the enterprise identifier field - * is per RFC1215. - * Use .iso.org.dod.internet.mgmt.mib-2.snmp for generic traps - * and .iso.org.dod.internet.private.enterprises.yourenterprise - * (sysObjectID) for specific traps. - */ -err_t -snmp_send_trap(const struct snmp_obj_id *eoid, s32_t generic_trap, s32_t specific_trap, struct snmp_varbind *varbinds) -{ - struct snmp_msg_trap trap_msg; - struct snmp_trap_dst *td; - struct pbuf *p; - u16_t i, tot_len; - err_t err = ERR_OK; - - LWIP_ASSERT_CORE_LOCKED(); - - trap_msg.snmp_version = 0; - - for (i = 0, td = &trap_dst[0]; i < SNMP_TRAP_DESTINATIONS; i++, td++) { - if ((td->enable != 0) && !ip_addr_isany(&td->dip)) { - /* lookup current source address for this dst */ - if (snmp_get_local_ip_for_dst(snmp_traps_handle, &td->dip, &trap_msg.sip)) { - if (eoid == NULL) { - trap_msg.enterprise = snmp_get_device_enterprise_oid(); - } else { - trap_msg.enterprise = eoid; - } - - trap_msg.gen_trap = generic_trap; - if (generic_trap == SNMP_GENTRAP_ENTERPRISE_SPECIFIC) { - trap_msg.spc_trap = specific_trap; - } else { - trap_msg.spc_trap = 0; - } - - MIB2_COPY_SYSUPTIME_TO(&trap_msg.ts); - - /* pass 0, calculate length fields */ - tot_len = snmp_trap_varbind_sum(&trap_msg, varbinds); - tot_len = snmp_trap_header_sum(&trap_msg, tot_len); - - /* allocate pbuf(s) */ - p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_RAM); - if (p != NULL) { - struct snmp_pbuf_stream pbuf_stream; - snmp_pbuf_stream_init(&pbuf_stream, p, 0, tot_len); - - /* pass 1, encode packet into the pbuf(s) */ - snmp_trap_header_enc(&trap_msg, &pbuf_stream); - snmp_trap_varbind_enc(&trap_msg, &pbuf_stream, varbinds); - - snmp_stats.outtraps++; - snmp_stats.outpkts++; - - /** send to the TRAP destination */ - snmp_sendto(snmp_traps_handle, p, &td->dip, LWIP_IANA_PORT_SNMP_TRAP); - pbuf_free(p); - } else { - err = ERR_MEM; - } - } else { - /* routing error */ - err = ERR_RTE; - } - } - } - return err; -} - -/** - * @ingroup snmp_traps - * Send generic SNMP trap - */ -err_t -snmp_send_trap_generic(s32_t generic_trap) -{ - static const struct snmp_obj_id oid = { 7, { 1, 3, 6, 1, 2, 1, 11 } }; - return snmp_send_trap(&oid, generic_trap, 0, NULL); -} - -/** - * @ingroup snmp_traps - * Send specific SNMP trap with variable bindings - */ -err_t -snmp_send_trap_specific(s32_t specific_trap, struct snmp_varbind *varbinds) -{ - return snmp_send_trap(NULL, SNMP_GENTRAP_ENTERPRISE_SPECIFIC, specific_trap, varbinds); -} - -/** - * @ingroup snmp_traps - * Send coldstart trap - */ -void -snmp_coldstart_trap(void) -{ - snmp_send_trap_generic(SNMP_GENTRAP_COLDSTART); -} - -/** - * @ingroup snmp_traps - * Send authentication failure trap (used internally by agent) - */ -void -snmp_authfail_trap(void) -{ - if (snmp_auth_traps_enabled != 0) { - snmp_send_trap_generic(SNMP_GENTRAP_AUTH_FAILURE); - } -} - -static u16_t -snmp_trap_varbind_sum(struct snmp_msg_trap *trap, struct snmp_varbind *varbinds) -{ - struct snmp_varbind *varbind; - u16_t tot_len; - u8_t tot_len_len; - - tot_len = 0; - varbind = varbinds; - while (varbind != NULL) { - struct snmp_varbind_len len; - - if (snmp_varbind_length(varbind, &len) == ERR_OK) { - tot_len += 1 + len.vb_len_len + len.vb_value_len; - } - - varbind = varbind->next; - } - - trap->vbseqlen = tot_len; - snmp_asn1_enc_length_cnt(trap->vbseqlen, &tot_len_len); - tot_len += 1 + tot_len_len; - - return tot_len; -} - -/** - * Sums trap header field lengths from tail to head and - * returns trap_header_lengths for second encoding pass. - * - * @param trap Trap message - * @param vb_len varbind-list length - * @return the required length for encoding the trap header - */ -static u16_t -snmp_trap_header_sum(struct snmp_msg_trap *trap, u16_t vb_len) -{ - u16_t tot_len; - u16_t len; - u8_t lenlen; - - tot_len = vb_len; - - snmp_asn1_enc_u32t_cnt(trap->ts, &len); - snmp_asn1_enc_length_cnt(len, &lenlen); - tot_len += 1 + len + lenlen; - - snmp_asn1_enc_s32t_cnt(trap->spc_trap, &len); - snmp_asn1_enc_length_cnt(len, &lenlen); - tot_len += 1 + len + lenlen; - - snmp_asn1_enc_s32t_cnt(trap->gen_trap, &len); - snmp_asn1_enc_length_cnt(len, &lenlen); - tot_len += 1 + len + lenlen; - - if (IP_IS_V6_VAL(trap->sip)) { -#if LWIP_IPV6 - len = sizeof(ip_2_ip6(&trap->sip)->addr); -#endif - } else { -#if LWIP_IPV4 - len = sizeof(ip_2_ip4(&trap->sip)->addr); -#endif - } - snmp_asn1_enc_length_cnt(len, &lenlen); - tot_len += 1 + len + lenlen; - - snmp_asn1_enc_oid_cnt(trap->enterprise->id, trap->enterprise->len, &len); - snmp_asn1_enc_length_cnt(len, &lenlen); - tot_len += 1 + len + lenlen; - - trap->pdulen = tot_len; - snmp_asn1_enc_length_cnt(trap->pdulen, &lenlen); - tot_len += 1 + lenlen; - - trap->comlen = (u16_t)LWIP_MIN(strlen(snmp_community_trap), 0xFFFF); - snmp_asn1_enc_length_cnt(trap->comlen, &lenlen); - tot_len += 1 + lenlen + trap->comlen; - - snmp_asn1_enc_s32t_cnt(trap->snmp_version, &len); - snmp_asn1_enc_length_cnt(len, &lenlen); - tot_len += 1 + len + lenlen; - - trap->seqlen = tot_len; - snmp_asn1_enc_length_cnt(trap->seqlen, &lenlen); - tot_len += 1 + lenlen; - - return tot_len; -} - -static err_t -snmp_trap_varbind_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbinds) -{ - struct snmp_asn1_tlv tlv; - struct snmp_varbind *varbind; - - varbind = varbinds; - - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 0, trap->vbseqlen); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - - while (varbind != NULL) { - BUILD_EXEC( snmp_append_outbound_varbind(pbuf_stream, varbind) ); - - varbind = varbind->next; - } - - return ERR_OK; -} - -/** - * Encodes trap header from head to tail. - */ -static err_t -snmp_trap_header_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream) -{ - struct snmp_asn1_tlv tlv; - - /* 'Message' sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 0, trap->seqlen); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - - /* version */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); - snmp_asn1_enc_s32t_cnt(trap->snmp_version, &tlv.value_len); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->snmp_version) ); - - /* community */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, trap->comlen); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, (const u8_t *)snmp_community_trap, trap->comlen) ); - - /* 'PDU' sequence */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_TRAP), 0, trap->pdulen); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - - /* object ID */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OBJECT_ID, 0, 0); - snmp_asn1_enc_oid_cnt(trap->enterprise->id, trap->enterprise->len, &tlv.value_len); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_oid(pbuf_stream, trap->enterprise->id, trap->enterprise->len) ); - - /* IP addr */ - if (IP_IS_V6_VAL(trap->sip)) { -#if LWIP_IPV6 - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_IPADDR, 0, sizeof(ip_2_ip6(&trap->sip)->addr)); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, (const u8_t *)&ip_2_ip6(&trap->sip)->addr, sizeof(ip_2_ip6(&trap->sip)->addr)) ); -#endif - } else { -#if LWIP_IPV4 - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_IPADDR, 0, sizeof(ip_2_ip4(&trap->sip)->addr)); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, (const u8_t *)&ip_2_ip4(&trap->sip)->addr, sizeof(ip_2_ip4(&trap->sip)->addr)) ); -#endif - } - - /* trap length */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); - snmp_asn1_enc_s32t_cnt(trap->gen_trap, &tlv.value_len); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->gen_trap) ); - - /* specific trap */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); - snmp_asn1_enc_s32t_cnt(trap->spc_trap, &tlv.value_len); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->spc_trap) ); - - /* timestamp */ - SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_TIMETICKS, 0, 0); - snmp_asn1_enc_s32t_cnt(trap->ts, &tlv.value_len); - BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); - BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->ts) ); - - return ERR_OK; -} - -#endif /* LWIP_SNMP */ +/** + * @file + * SNMPv1 traps implementation. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * Christiaan Simons + * + */ + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include + +#include "lwip/snmp.h" +#include "lwip/sys.h" +#include "lwip/apps/snmp.h" +#include "lwip/apps/snmp_core.h" +#include "lwip/prot/iana.h" +#include "snmp_msg.h" +#include "snmp_asn1.h" +#include "snmp_core_priv.h" + +struct snmp_msg_trap { + /* source enterprise ID (sysObjectID) */ + const struct snmp_obj_id *enterprise; + /* source IP address, raw network order format */ + ip_addr_t sip; + /* generic trap code */ + u32_t gen_trap; + /* specific trap code */ + u32_t spc_trap; + /* timestamp */ + u32_t ts; + /* snmp_version */ + u32_t snmp_version; + + /* output trap lengths used in ASN encoding */ + /* encoding pdu length */ + u16_t pdulen; + /* encoding community length */ + u16_t comlen; + /* encoding sequence length */ + u16_t seqlen; + /* encoding varbinds sequence length */ + u16_t vbseqlen; +}; + +static u16_t snmp_trap_varbind_sum(struct snmp_msg_trap *trap, struct snmp_varbind *varbinds); +static u16_t snmp_trap_header_sum(struct snmp_msg_trap *trap, u16_t vb_len); +static err_t snmp_trap_header_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream); +static err_t snmp_trap_varbind_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbinds); + +#define BUILD_EXEC(code) \ + if ((code) != ERR_OK) { \ + LWIP_DEBUGF(SNMP_DEBUG, ("SNMP error during creation of outbound trap frame!")); \ + return ERR_ARG; \ + } + +/** Agent community string for sending traps */ +extern const char *snmp_community_trap; + +void *snmp_traps_handle; + +struct snmp_trap_dst { + /* destination IP address in network order */ + ip_addr_t dip; + /* set to 0 when disabled, >0 when enabled */ + u8_t enable; +}; +static struct snmp_trap_dst trap_dst[SNMP_TRAP_DESTINATIONS]; + +static u8_t snmp_auth_traps_enabled = 0; + +/** + * @ingroup snmp_traps + * Sets enable switch for this trap destination. + * @param dst_idx index in 0 .. SNMP_TRAP_DESTINATIONS-1 + * @param enable switch if 0 destination is disabled >0 enabled. + */ +void +snmp_trap_dst_enable(u8_t dst_idx, u8_t enable) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (dst_idx < SNMP_TRAP_DESTINATIONS) { + trap_dst[dst_idx].enable = enable; + } +} + +/** + * @ingroup snmp_traps + * Sets IPv4 address for this trap destination. + * @param dst_idx index in 0 .. SNMP_TRAP_DESTINATIONS-1 + * @param dst IPv4 address in host order. + */ +void +snmp_trap_dst_ip_set(u8_t dst_idx, const ip_addr_t *dst) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (dst_idx < SNMP_TRAP_DESTINATIONS) { + ip_addr_set(&trap_dst[dst_idx].dip, dst); + } +} + +/** + * @ingroup snmp_traps + * Enable/disable authentication traps + */ +void +snmp_set_auth_traps_enabled(u8_t enable) +{ + snmp_auth_traps_enabled = enable; +} + +/** + * @ingroup snmp_traps + * Get authentication traps enabled state + */ +u8_t +snmp_get_auth_traps_enabled(void) +{ + return snmp_auth_traps_enabled; +} + + +/** + * @ingroup snmp_traps + * Sends a generic or enterprise specific trap message. + * + * @param eoid points to enterprise object identifier + * @param generic_trap is the trap code + * @param specific_trap used for enterprise traps when generic_trap == 6 + * @param varbinds linked list of varbinds to be sent + * @return ERR_OK when success, ERR_MEM if we're out of memory + * + * @note the use of the enterprise identifier field + * is per RFC1215. + * Use .iso.org.dod.internet.mgmt.mib-2.snmp for generic traps + * and .iso.org.dod.internet.private.enterprises.yourenterprise + * (sysObjectID) for specific traps. + */ +err_t +snmp_send_trap(const struct snmp_obj_id *eoid, s32_t generic_trap, s32_t specific_trap, struct snmp_varbind *varbinds) +{ + struct snmp_msg_trap trap_msg; + struct snmp_trap_dst *td; + struct pbuf *p; + u16_t i, tot_len; + err_t err = ERR_OK; + + LWIP_ASSERT_CORE_LOCKED(); + + trap_msg.snmp_version = 0; + + for (i = 0, td = &trap_dst[0]; i < SNMP_TRAP_DESTINATIONS; i++, td++) { + if ((td->enable != 0) && !ip_addr_isany(&td->dip)) { + /* lookup current source address for this dst */ + if (snmp_get_local_ip_for_dst(snmp_traps_handle, &td->dip, &trap_msg.sip)) { + if (eoid == NULL) { + trap_msg.enterprise = snmp_get_device_enterprise_oid(); + } else { + trap_msg.enterprise = eoid; + } + + trap_msg.gen_trap = generic_trap; + if (generic_trap == SNMP_GENTRAP_ENTERPRISE_SPECIFIC) { + trap_msg.spc_trap = specific_trap; + } else { + trap_msg.spc_trap = 0; + } + + MIB2_COPY_SYSUPTIME_TO(&trap_msg.ts); + + /* pass 0, calculate length fields */ + tot_len = snmp_trap_varbind_sum(&trap_msg, varbinds); + tot_len = snmp_trap_header_sum(&trap_msg, tot_len); + + /* allocate pbuf(s) */ + p = pbuf_alloc(PBUF_TRANSPORT, tot_len, PBUF_RAM); + if (p != NULL) { + struct snmp_pbuf_stream pbuf_stream; + snmp_pbuf_stream_init(&pbuf_stream, p, 0, tot_len); + + /* pass 1, encode packet into the pbuf(s) */ + snmp_trap_header_enc(&trap_msg, &pbuf_stream); + snmp_trap_varbind_enc(&trap_msg, &pbuf_stream, varbinds); + + snmp_stats.outtraps++; + snmp_stats.outpkts++; + + /** send to the TRAP destination */ + snmp_sendto(snmp_traps_handle, p, &td->dip, LWIP_IANA_PORT_SNMP_TRAP); + pbuf_free(p); + } else { + err = ERR_MEM; + } + } else { + /* routing error */ + err = ERR_RTE; + } + } + } + return err; +} + +/** + * @ingroup snmp_traps + * Send generic SNMP trap + */ +err_t +snmp_send_trap_generic(s32_t generic_trap) +{ + static const struct snmp_obj_id oid = { 7, { 1, 3, 6, 1, 2, 1, 11 } }; + return snmp_send_trap(&oid, generic_trap, 0, NULL); +} + +/** + * @ingroup snmp_traps + * Send specific SNMP trap with variable bindings + */ +err_t +snmp_send_trap_specific(s32_t specific_trap, struct snmp_varbind *varbinds) +{ + return snmp_send_trap(NULL, SNMP_GENTRAP_ENTERPRISE_SPECIFIC, specific_trap, varbinds); +} + +/** + * @ingroup snmp_traps + * Send coldstart trap + */ +void +snmp_coldstart_trap(void) +{ + snmp_send_trap_generic(SNMP_GENTRAP_COLDSTART); +} + +/** + * @ingroup snmp_traps + * Send authentication failure trap (used internally by agent) + */ +void +snmp_authfail_trap(void) +{ + if (snmp_auth_traps_enabled != 0) { + snmp_send_trap_generic(SNMP_GENTRAP_AUTH_FAILURE); + } +} + +static u16_t +snmp_trap_varbind_sum(struct snmp_msg_trap *trap, struct snmp_varbind *varbinds) +{ + struct snmp_varbind *varbind; + u16_t tot_len; + u8_t tot_len_len; + + tot_len = 0; + varbind = varbinds; + while (varbind != NULL) { + struct snmp_varbind_len len; + + if (snmp_varbind_length(varbind, &len) == ERR_OK) { + tot_len += 1 + len.vb_len_len + len.vb_value_len; + } + + varbind = varbind->next; + } + + trap->vbseqlen = tot_len; + snmp_asn1_enc_length_cnt(trap->vbseqlen, &tot_len_len); + tot_len += 1 + tot_len_len; + + return tot_len; +} + +/** + * Sums trap header field lengths from tail to head and + * returns trap_header_lengths for second encoding pass. + * + * @param trap Trap message + * @param vb_len varbind-list length + * @return the required length for encoding the trap header + */ +static u16_t +snmp_trap_header_sum(struct snmp_msg_trap *trap, u16_t vb_len) +{ + u16_t tot_len; + u16_t len; + u8_t lenlen; + + tot_len = vb_len; + + snmp_asn1_enc_u32t_cnt(trap->ts, &len); + snmp_asn1_enc_length_cnt(len, &lenlen); + tot_len += 1 + len + lenlen; + + snmp_asn1_enc_s32t_cnt(trap->spc_trap, &len); + snmp_asn1_enc_length_cnt(len, &lenlen); + tot_len += 1 + len + lenlen; + + snmp_asn1_enc_s32t_cnt(trap->gen_trap, &len); + snmp_asn1_enc_length_cnt(len, &lenlen); + tot_len += 1 + len + lenlen; + + if (IP_IS_V6_VAL(trap->sip)) { +#if LWIP_IPV6 + len = sizeof(ip_2_ip6(&trap->sip)->addr); +#endif + } else { +#if LWIP_IPV4 + len = sizeof(ip_2_ip4(&trap->sip)->addr); +#endif + } + snmp_asn1_enc_length_cnt(len, &lenlen); + tot_len += 1 + len + lenlen; + + snmp_asn1_enc_oid_cnt(trap->enterprise->id, trap->enterprise->len, &len); + snmp_asn1_enc_length_cnt(len, &lenlen); + tot_len += 1 + len + lenlen; + + trap->pdulen = tot_len; + snmp_asn1_enc_length_cnt(trap->pdulen, &lenlen); + tot_len += 1 + lenlen; + + trap->comlen = (u16_t)LWIP_MIN(strlen(snmp_community_trap), 0xFFFF); + snmp_asn1_enc_length_cnt(trap->comlen, &lenlen); + tot_len += 1 + lenlen + trap->comlen; + + snmp_asn1_enc_s32t_cnt(trap->snmp_version, &len); + snmp_asn1_enc_length_cnt(len, &lenlen); + tot_len += 1 + len + lenlen; + + trap->seqlen = tot_len; + snmp_asn1_enc_length_cnt(trap->seqlen, &lenlen); + tot_len += 1 + lenlen; + + return tot_len; +} + +static err_t +snmp_trap_varbind_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream, struct snmp_varbind *varbinds) +{ + struct snmp_asn1_tlv tlv; + struct snmp_varbind *varbind; + + varbind = varbinds; + + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 0, trap->vbseqlen); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + + while (varbind != NULL) { + BUILD_EXEC( snmp_append_outbound_varbind(pbuf_stream, varbind) ); + + varbind = varbind->next; + } + + return ERR_OK; +} + +/** + * Encodes trap header from head to tail. + */ +static err_t +snmp_trap_header_enc(struct snmp_msg_trap *trap, struct snmp_pbuf_stream *pbuf_stream) +{ + struct snmp_asn1_tlv tlv; + + /* 'Message' sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_SEQUENCE, 0, trap->seqlen); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + + /* version */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); + snmp_asn1_enc_s32t_cnt(trap->snmp_version, &tlv.value_len); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->snmp_version) ); + + /* community */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OCTET_STRING, 0, trap->comlen); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, (const u8_t *)snmp_community_trap, trap->comlen) ); + + /* 'PDU' sequence */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, (SNMP_ASN1_CLASS_CONTEXT | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_CONTEXT_PDU_TRAP), 0, trap->pdulen); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + + /* object ID */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_OBJECT_ID, 0, 0); + snmp_asn1_enc_oid_cnt(trap->enterprise->id, trap->enterprise->len, &tlv.value_len); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_oid(pbuf_stream, trap->enterprise->id, trap->enterprise->len) ); + + /* IP addr */ + if (IP_IS_V6_VAL(trap->sip)) { +#if LWIP_IPV6 + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_IPADDR, 0, sizeof(ip_2_ip6(&trap->sip)->addr)); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, (const u8_t *)&ip_2_ip6(&trap->sip)->addr, sizeof(ip_2_ip6(&trap->sip)->addr)) ); +#endif + } else { +#if LWIP_IPV4 + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_IPADDR, 0, sizeof(ip_2_ip4(&trap->sip)->addr)); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_raw(pbuf_stream, (const u8_t *)&ip_2_ip4(&trap->sip)->addr, sizeof(ip_2_ip4(&trap->sip)->addr)) ); +#endif + } + + /* trap length */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); + snmp_asn1_enc_s32t_cnt(trap->gen_trap, &tlv.value_len); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->gen_trap) ); + + /* specific trap */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_INTEGER, 0, 0); + snmp_asn1_enc_s32t_cnt(trap->spc_trap, &tlv.value_len); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->spc_trap) ); + + /* timestamp */ + SNMP_ASN1_SET_TLV_PARAMS(tlv, SNMP_ASN1_TYPE_TIMETICKS, 0, 0); + snmp_asn1_enc_s32t_cnt(trap->ts, &tlv.value_len); + BUILD_EXEC( snmp_ans1_enc_tlv(pbuf_stream, &tlv) ); + BUILD_EXEC( snmp_asn1_enc_s32t(pbuf_stream, tlv.value_len, trap->ts) ); + + return ERR_OK; +} + +#endif /* LWIP_SNMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3.c index df7bb5cf..ed5a076c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3.c @@ -1,136 +1,136 @@ -/** - * @file - * Additional SNMPv3 functionality RFC3414 and RFC3826. - */ - -/* - * Copyright (c) 2016 Elias Oenal. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Elias Oenal - */ - -#include "snmpv3_priv.h" -#include "lwip/apps/snmpv3.h" -#include "lwip/sys.h" -#include - -#if LWIP_SNMP && LWIP_SNMP_V3 - -#ifdef LWIP_SNMPV3_INCLUDE_ENGINE -#include LWIP_SNMPV3_INCLUDE_ENGINE -#endif - -#define SNMP_MAX_TIME_BOOT 2147483647UL - -/** Call this if engine has been changed. Has to reset boots, see below */ -void -snmpv3_engine_id_changed(void) -{ - snmpv3_set_engine_boots(0); -} - -/** According to RFC3414 2.2.2. - * - * The number of times that the SNMP engine has - * (re-)initialized itself since snmpEngineID - * was last configured. - */ -s32_t -snmpv3_get_engine_boots_internal(void) -{ - if (snmpv3_get_engine_boots() == 0 || - snmpv3_get_engine_boots() < SNMP_MAX_TIME_BOOT) { - return snmpv3_get_engine_boots(); - } - - snmpv3_set_engine_boots(SNMP_MAX_TIME_BOOT); - return snmpv3_get_engine_boots(); -} - -/** RFC3414 2.2.2. - * - * Once the timer reaches 2147483647 it gets reset to zero and the - * engine boot ups get incremented. - */ -s32_t -snmpv3_get_engine_time_internal(void) -{ - if (snmpv3_get_engine_time() >= SNMP_MAX_TIME_BOOT) { - snmpv3_reset_engine_time(); - - if (snmpv3_get_engine_boots() < SNMP_MAX_TIME_BOOT - 1) { - snmpv3_set_engine_boots(snmpv3_get_engine_boots() + 1); - } else { - snmpv3_set_engine_boots(SNMP_MAX_TIME_BOOT); - } - } - - return snmpv3_get_engine_time(); -} - -#if LWIP_SNMP_V3_CRYPTO - -/* This function ignores the byte order suggestion in RFC3414 - * since it simply doesn't influence the effectiveness of an IV. - * - * Implementing RFC3826 priv param algorithm if LWIP_RAND is available. - * - * @todo: This is a potential thread safety issue. - */ -err_t -snmpv3_build_priv_param(u8_t *priv_param) -{ -#ifdef LWIP_RAND /* Based on RFC3826 */ - static u8_t init; - static u32_t priv1, priv2; - - /* Lazy initialisation */ - if (init == 0) { - init = 1; - priv1 = LWIP_RAND(); - priv2 = LWIP_RAND(); - } - - SMEMCPY(&priv_param[0], &priv1, sizeof(priv1)); - SMEMCPY(&priv_param[4], &priv2, sizeof(priv2)); - - /* Emulate 64bit increment */ - priv1++; - if (!priv1) { /* Overflow */ - priv2++; - } -#else /* Based on RFC3414 */ - static u32_t ctr; - u32_t boots = snmpv3_get_engine_boots_internal(); - SMEMCPY(&priv_param[0], &boots, 4); - SMEMCPY(&priv_param[4], &ctr, 4); - ctr++; -#endif - return ERR_OK; -} -#endif /* LWIP_SNMP_V3_CRYPTO */ - -#endif +/** + * @file + * Additional SNMPv3 functionality RFC3414 and RFC3826. + */ + +/* + * Copyright (c) 2016 Elias Oenal. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Elias Oenal + */ + +#include "snmpv3_priv.h" +#include "lwip/apps/snmpv3.h" +#include "lwip/sys.h" +#include + +#if LWIP_SNMP && LWIP_SNMP_V3 + +#ifdef LWIP_SNMPV3_INCLUDE_ENGINE +#include LWIP_SNMPV3_INCLUDE_ENGINE +#endif + +#define SNMP_MAX_TIME_BOOT 2147483647UL + +/** Call this if engine has been changed. Has to reset boots, see below */ +void +snmpv3_engine_id_changed(void) +{ + snmpv3_set_engine_boots(0); +} + +/** According to RFC3414 2.2.2. + * + * The number of times that the SNMP engine has + * (re-)initialized itself since snmpEngineID + * was last configured. + */ +s32_t +snmpv3_get_engine_boots_internal(void) +{ + if (snmpv3_get_engine_boots() == 0 || + snmpv3_get_engine_boots() < SNMP_MAX_TIME_BOOT) { + return snmpv3_get_engine_boots(); + } + + snmpv3_set_engine_boots(SNMP_MAX_TIME_BOOT); + return snmpv3_get_engine_boots(); +} + +/** RFC3414 2.2.2. + * + * Once the timer reaches 2147483647 it gets reset to zero and the + * engine boot ups get incremented. + */ +s32_t +snmpv3_get_engine_time_internal(void) +{ + if (snmpv3_get_engine_time() >= SNMP_MAX_TIME_BOOT) { + snmpv3_reset_engine_time(); + + if (snmpv3_get_engine_boots() < SNMP_MAX_TIME_BOOT - 1) { + snmpv3_set_engine_boots(snmpv3_get_engine_boots() + 1); + } else { + snmpv3_set_engine_boots(SNMP_MAX_TIME_BOOT); + } + } + + return snmpv3_get_engine_time(); +} + +#if LWIP_SNMP_V3_CRYPTO + +/* This function ignores the byte order suggestion in RFC3414 + * since it simply doesn't influence the effectiveness of an IV. + * + * Implementing RFC3826 priv param algorithm if LWIP_RAND is available. + * + * @todo: This is a potential thread safety issue. + */ +err_t +snmpv3_build_priv_param(u8_t *priv_param) +{ +#ifdef LWIP_RAND /* Based on RFC3826 */ + static u8_t init; + static u32_t priv1, priv2; + + /* Lazy initialisation */ + if (init == 0) { + init = 1; + priv1 = LWIP_RAND(); + priv2 = LWIP_RAND(); + } + + SMEMCPY(&priv_param[0], &priv1, sizeof(priv1)); + SMEMCPY(&priv_param[4], &priv2, sizeof(priv2)); + + /* Emulate 64bit increment */ + priv1++; + if (!priv1) { /* Overflow */ + priv2++; + } +#else /* Based on RFC3414 */ + static u32_t ctr; + u32_t boots = snmpv3_get_engine_boots_internal(); + SMEMCPY(&priv_param[0], &boots, 4); + SMEMCPY(&priv_param[4], &ctr, 4); + ctr++; +#endif + return ERR_OK; +} +#endif /* LWIP_SNMP_V3_CRYPTO */ + +#endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_mbedtls.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_mbedtls.c index fe20f788..48c1a81f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_mbedtls.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_mbedtls.c @@ -1,342 +1,342 @@ -/** - * @file - * SNMPv3 crypto/auth functions implemented for ARM mbedtls. - */ - -/* - * Copyright (c) 2016 Elias Oenal and Dirk Ziegelmeier. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Elias Oenal - * Dirk Ziegelmeier - */ - -#include "lwip/apps/snmpv3.h" -#include "snmpv3_priv.h" -#include "lwip/arch.h" -#include "snmp_msg.h" -#include "lwip/sys.h" -#include - -#if LWIP_SNMP && LWIP_SNMP_V3 && LWIP_SNMP_V3_MBEDTLS - -#include "mbedtls/md.h" -#include "mbedtls/cipher.h" - -#include "mbedtls/md5.h" -#include "mbedtls/sha1.h" - -err_t -snmpv3_auth(struct snmp_pbuf_stream *stream, u16_t length, - const u8_t *key, snmpv3_auth_algo_t algo, u8_t *hmac_out) -{ - u32_t i; - u8_t key_len; - const mbedtls_md_info_t *md_info; - mbedtls_md_context_t ctx; - struct snmp_pbuf_stream read_stream; - snmp_pbuf_stream_init(&read_stream, stream->pbuf, stream->offset, stream->length); - - if (algo == SNMP_V3_AUTH_ALGO_MD5) { - md_info = mbedtls_md_info_from_type(MBEDTLS_MD_MD5); - key_len = SNMP_V3_MD5_LEN; - } else if (algo == SNMP_V3_AUTH_ALGO_SHA) { - md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1); - key_len = SNMP_V3_SHA_LEN; - } else { - return ERR_ARG; - } - - mbedtls_md_init(&ctx); - if (mbedtls_md_setup(&ctx, md_info, 1) != 0) { - return ERR_ARG; - } - - if (mbedtls_md_hmac_starts(&ctx, key, key_len) != 0) { - goto free_md; - } - - for (i = 0; i < length; i++) { - u8_t byte; - - if (snmp_pbuf_stream_read(&read_stream, &byte)) { - goto free_md; - } - - if (mbedtls_md_hmac_update(&ctx, &byte, 1) != 0) { - goto free_md; - } - } - - if (mbedtls_md_hmac_finish(&ctx, hmac_out) != 0) { - goto free_md; - } - - mbedtls_md_free(&ctx); - return ERR_OK; - -free_md: - mbedtls_md_free(&ctx); - return ERR_ARG; -} - -#if LWIP_SNMP_V3_CRYPTO - -err_t -snmpv3_crypt(struct snmp_pbuf_stream *stream, u16_t length, - const u8_t *key, const u8_t *priv_param, const u32_t engine_boots, - const u32_t engine_time, snmpv3_priv_algo_t algo, snmpv3_priv_mode_t mode) -{ - size_t i; - mbedtls_cipher_context_t ctx; - const mbedtls_cipher_info_t *cipher_info; - - struct snmp_pbuf_stream read_stream; - struct snmp_pbuf_stream write_stream; - snmp_pbuf_stream_init(&read_stream, stream->pbuf, stream->offset, stream->length); - snmp_pbuf_stream_init(&write_stream, stream->pbuf, stream->offset, stream->length); - mbedtls_cipher_init(&ctx); - - if (algo == SNMP_V3_PRIV_ALGO_DES) { - u8_t iv_local[8]; - u8_t out_bytes[8]; - size_t out_len; - - /* RFC 3414 mandates padding for DES */ - if ((length & 0x07) != 0) { - return ERR_ARG; - } - - cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_DES_CBC); - if (mbedtls_cipher_setup(&ctx, cipher_info) != 0) { - return ERR_ARG; - } - if (mbedtls_cipher_set_padding_mode(&ctx, MBEDTLS_PADDING_NONE) != 0) { - return ERR_ARG; - } - if (mbedtls_cipher_setkey(&ctx, key, 8 * 8, (mode == SNMP_V3_PRIV_MODE_ENCRYPT) ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT) != 0) { - goto error; - } - - /* Prepare IV */ - for (i = 0; i < LWIP_ARRAYSIZE(iv_local); i++) { - iv_local[i] = priv_param[i] ^ key[i + 8]; - } - if (mbedtls_cipher_set_iv(&ctx, iv_local, LWIP_ARRAYSIZE(iv_local)) != 0) { - goto error; - } - - for (i = 0; i < length; i += 8) { - size_t j; - u8_t in_bytes[8]; - out_len = LWIP_ARRAYSIZE(out_bytes) ; - - for (j = 0; j < LWIP_ARRAYSIZE(in_bytes); j++) { - if (snmp_pbuf_stream_read(&read_stream, &in_bytes[j]) != ERR_OK) { - goto error; - } - } - - if (mbedtls_cipher_update(&ctx, in_bytes, LWIP_ARRAYSIZE(in_bytes), out_bytes, &out_len) != 0) { - goto error; - } - - if (snmp_pbuf_stream_writebuf(&write_stream, out_bytes, (u16_t)out_len) != ERR_OK) { - goto error; - } - } - - out_len = LWIP_ARRAYSIZE(out_bytes); - if (mbedtls_cipher_finish(&ctx, out_bytes, &out_len) != 0) { - goto error; - } - - if (snmp_pbuf_stream_writebuf(&write_stream, out_bytes, (u16_t)out_len) != ERR_OK) { - goto error; - } - } else if (algo == SNMP_V3_PRIV_ALGO_AES) { - u8_t iv_local[16]; - - cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_CFB128); - if (mbedtls_cipher_setup(&ctx, cipher_info) != 0) { - return ERR_ARG; - } - if (mbedtls_cipher_setkey(&ctx, key, 16 * 8, (mode == SNMP_V3_PRIV_MODE_ENCRYPT) ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT) != 0) { - goto error; - } - - /* - * IV is the big endian concatenation of boots, - * uptime and priv param - see RFC3826. - */ - iv_local[0 + 0] = (engine_boots >> 24) & 0xFF; - iv_local[0 + 1] = (engine_boots >> 16) & 0xFF; - iv_local[0 + 2] = (engine_boots >> 8) & 0xFF; - iv_local[0 + 3] = (engine_boots >> 0) & 0xFF; - iv_local[4 + 0] = (engine_time >> 24) & 0xFF; - iv_local[4 + 1] = (engine_time >> 16) & 0xFF; - iv_local[4 + 2] = (engine_time >> 8) & 0xFF; - iv_local[4 + 3] = (engine_time >> 0) & 0xFF; - SMEMCPY(iv_local + 8, priv_param, 8); - if (mbedtls_cipher_set_iv(&ctx, iv_local, LWIP_ARRAYSIZE(iv_local)) != 0) { - goto error; - } - - for (i = 0; i < length; i++) { - u8_t in_byte; - u8_t out_byte; - size_t out_len = sizeof(out_byte); - - if (snmp_pbuf_stream_read(&read_stream, &in_byte) != ERR_OK) { - goto error; - } - if (mbedtls_cipher_update(&ctx, &in_byte, sizeof(in_byte), &out_byte, &out_len) != 0) { - goto error; - } - if (snmp_pbuf_stream_write(&write_stream, out_byte) != ERR_OK) { - goto error; - } - } - } else { - return ERR_ARG; - } - - mbedtls_cipher_free(&ctx); - return ERR_OK; - -error: - mbedtls_cipher_free(&ctx); - return ERR_OK; -} - -#endif /* LWIP_SNMP_V3_CRYPTO */ - -/* A.2.1. Password to Key Sample Code for MD5 */ -void -snmpv3_password_to_key_md5( - const u8_t *password, /* IN */ - size_t passwordlen, /* IN */ - const u8_t *engineID, /* IN - pointer to snmpEngineID */ - u8_t engineLength,/* IN - length of snmpEngineID */ - u8_t *key) /* OUT - pointer to caller 16-octet buffer */ -{ - mbedtls_md5_context MD; - u8_t *cp, password_buf[64]; - u32_t password_index = 0; - u8_t i; - u32_t count = 0; - - mbedtls_md5_init(&MD); /* initialize MD5 */ - mbedtls_md5_starts(&MD); - - /**********************************************/ - /* Use while loop until we've done 1 Megabyte */ - /**********************************************/ - while (count < 1048576) { - cp = password_buf; - for (i = 0; i < 64; i++) { - /*************************************************/ - /* Take the next octet of the password, wrapping */ - /* to the beginning of the password as necessary.*/ - /*************************************************/ - *cp++ = password[password_index++ % passwordlen]; - } - mbedtls_md5_update(&MD, password_buf, 64); - count += 64; - } - mbedtls_md5_finish(&MD, key); /* tell MD5 we're done */ - - /*****************************************************/ - /* Now localize the key with the engineID and pass */ - /* through MD5 to produce final key */ - /* May want to ensure that engineLength <= 32, */ - /* otherwise need to use a buffer larger than 64 */ - /*****************************************************/ - SMEMCPY(password_buf, key, 16); - MEMCPY(password_buf + 16, engineID, engineLength); - SMEMCPY(password_buf + 16 + engineLength, key, 16); - - mbedtls_md5_starts(&MD); - mbedtls_md5_update(&MD, password_buf, 32 + engineLength); - mbedtls_md5_finish(&MD, key); - - mbedtls_md5_free(&MD); - return; -} - -/* A.2.2. Password to Key Sample Code for SHA */ -void -snmpv3_password_to_key_sha( - const u8_t *password, /* IN */ - size_t passwordlen, /* IN */ - const u8_t *engineID, /* IN - pointer to snmpEngineID */ - u8_t engineLength,/* IN - length of snmpEngineID */ - u8_t *key) /* OUT - pointer to caller 20-octet buffer */ -{ - mbedtls_sha1_context SH; - u8_t *cp, password_buf[72]; - u32_t password_index = 0; - u8_t i; - u32_t count = 0; - - mbedtls_sha1_init(&SH); /* initialize SHA */ - mbedtls_sha1_starts(&SH); - - /**********************************************/ - /* Use while loop until we've done 1 Megabyte */ - /**********************************************/ - while (count < 1048576) { - cp = password_buf; - for (i = 0; i < 64; i++) { - /*************************************************/ - /* Take the next octet of the password, wrapping */ - /* to the beginning of the password as necessary.*/ - /*************************************************/ - *cp++ = password[password_index++ % passwordlen]; - } - mbedtls_sha1_update(&SH, password_buf, 64); - count += 64; - } - mbedtls_sha1_finish(&SH, key); /* tell SHA we're done */ - - /*****************************************************/ - /* Now localize the key with the engineID and pass */ - /* through SHA to produce final key */ - /* May want to ensure that engineLength <= 32, */ - /* otherwise need to use a buffer larger than 72 */ - /*****************************************************/ - SMEMCPY(password_buf, key, 20); - MEMCPY(password_buf + 20, engineID, engineLength); - SMEMCPY(password_buf + 20 + engineLength, key, 20); - - mbedtls_sha1_starts(&SH); - mbedtls_sha1_update(&SH, password_buf, 40 + engineLength); - mbedtls_sha1_finish(&SH, key); - - mbedtls_sha1_free(&SH); - return; -} - -#endif /* LWIP_SNMP && LWIP_SNMP_V3 && LWIP_SNMP_V3_MBEDTLS */ +/** + * @file + * SNMPv3 crypto/auth functions implemented for ARM mbedtls. + */ + +/* + * Copyright (c) 2016 Elias Oenal and Dirk Ziegelmeier. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Elias Oenal + * Dirk Ziegelmeier + */ + +#include "lwip/apps/snmpv3.h" +#include "snmpv3_priv.h" +#include "lwip/arch.h" +#include "snmp_msg.h" +#include "lwip/sys.h" +#include + +#if LWIP_SNMP && LWIP_SNMP_V3 && LWIP_SNMP_V3_MBEDTLS + +#include "mbedtls/md.h" +#include "mbedtls/cipher.h" + +#include "mbedtls/md5.h" +#include "mbedtls/sha1.h" + +err_t +snmpv3_auth(struct snmp_pbuf_stream *stream, u16_t length, + const u8_t *key, snmpv3_auth_algo_t algo, u8_t *hmac_out) +{ + u32_t i; + u8_t key_len; + const mbedtls_md_info_t *md_info; + mbedtls_md_context_t ctx; + struct snmp_pbuf_stream read_stream; + snmp_pbuf_stream_init(&read_stream, stream->pbuf, stream->offset, stream->length); + + if (algo == SNMP_V3_AUTH_ALGO_MD5) { + md_info = mbedtls_md_info_from_type(MBEDTLS_MD_MD5); + key_len = SNMP_V3_MD5_LEN; + } else if (algo == SNMP_V3_AUTH_ALGO_SHA) { + md_info = mbedtls_md_info_from_type(MBEDTLS_MD_SHA1); + key_len = SNMP_V3_SHA_LEN; + } else { + return ERR_ARG; + } + + mbedtls_md_init(&ctx); + if (mbedtls_md_setup(&ctx, md_info, 1) != 0) { + return ERR_ARG; + } + + if (mbedtls_md_hmac_starts(&ctx, key, key_len) != 0) { + goto free_md; + } + + for (i = 0; i < length; i++) { + u8_t byte; + + if (snmp_pbuf_stream_read(&read_stream, &byte)) { + goto free_md; + } + + if (mbedtls_md_hmac_update(&ctx, &byte, 1) != 0) { + goto free_md; + } + } + + if (mbedtls_md_hmac_finish(&ctx, hmac_out) != 0) { + goto free_md; + } + + mbedtls_md_free(&ctx); + return ERR_OK; + +free_md: + mbedtls_md_free(&ctx); + return ERR_ARG; +} + +#if LWIP_SNMP_V3_CRYPTO + +err_t +snmpv3_crypt(struct snmp_pbuf_stream *stream, u16_t length, + const u8_t *key, const u8_t *priv_param, const u32_t engine_boots, + const u32_t engine_time, snmpv3_priv_algo_t algo, snmpv3_priv_mode_t mode) +{ + size_t i; + mbedtls_cipher_context_t ctx; + const mbedtls_cipher_info_t *cipher_info; + + struct snmp_pbuf_stream read_stream; + struct snmp_pbuf_stream write_stream; + snmp_pbuf_stream_init(&read_stream, stream->pbuf, stream->offset, stream->length); + snmp_pbuf_stream_init(&write_stream, stream->pbuf, stream->offset, stream->length); + mbedtls_cipher_init(&ctx); + + if (algo == SNMP_V3_PRIV_ALGO_DES) { + u8_t iv_local[8]; + u8_t out_bytes[8]; + size_t out_len; + + /* RFC 3414 mandates padding for DES */ + if ((length & 0x07) != 0) { + return ERR_ARG; + } + + cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_DES_CBC); + if (mbedtls_cipher_setup(&ctx, cipher_info) != 0) { + return ERR_ARG; + } + if (mbedtls_cipher_set_padding_mode(&ctx, MBEDTLS_PADDING_NONE) != 0) { + return ERR_ARG; + } + if (mbedtls_cipher_setkey(&ctx, key, 8 * 8, (mode == SNMP_V3_PRIV_MODE_ENCRYPT) ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT) != 0) { + goto error; + } + + /* Prepare IV */ + for (i = 0; i < LWIP_ARRAYSIZE(iv_local); i++) { + iv_local[i] = priv_param[i] ^ key[i + 8]; + } + if (mbedtls_cipher_set_iv(&ctx, iv_local, LWIP_ARRAYSIZE(iv_local)) != 0) { + goto error; + } + + for (i = 0; i < length; i += 8) { + size_t j; + u8_t in_bytes[8]; + out_len = LWIP_ARRAYSIZE(out_bytes) ; + + for (j = 0; j < LWIP_ARRAYSIZE(in_bytes); j++) { + if (snmp_pbuf_stream_read(&read_stream, &in_bytes[j]) != ERR_OK) { + goto error; + } + } + + if (mbedtls_cipher_update(&ctx, in_bytes, LWIP_ARRAYSIZE(in_bytes), out_bytes, &out_len) != 0) { + goto error; + } + + if (snmp_pbuf_stream_writebuf(&write_stream, out_bytes, (u16_t)out_len) != ERR_OK) { + goto error; + } + } + + out_len = LWIP_ARRAYSIZE(out_bytes); + if (mbedtls_cipher_finish(&ctx, out_bytes, &out_len) != 0) { + goto error; + } + + if (snmp_pbuf_stream_writebuf(&write_stream, out_bytes, (u16_t)out_len) != ERR_OK) { + goto error; + } + } else if (algo == SNMP_V3_PRIV_ALGO_AES) { + u8_t iv_local[16]; + + cipher_info = mbedtls_cipher_info_from_type(MBEDTLS_CIPHER_AES_128_CFB128); + if (mbedtls_cipher_setup(&ctx, cipher_info) != 0) { + return ERR_ARG; + } + if (mbedtls_cipher_setkey(&ctx, key, 16 * 8, (mode == SNMP_V3_PRIV_MODE_ENCRYPT) ? MBEDTLS_ENCRYPT : MBEDTLS_DECRYPT) != 0) { + goto error; + } + + /* + * IV is the big endian concatenation of boots, + * uptime and priv param - see RFC3826. + */ + iv_local[0 + 0] = (engine_boots >> 24) & 0xFF; + iv_local[0 + 1] = (engine_boots >> 16) & 0xFF; + iv_local[0 + 2] = (engine_boots >> 8) & 0xFF; + iv_local[0 + 3] = (engine_boots >> 0) & 0xFF; + iv_local[4 + 0] = (engine_time >> 24) & 0xFF; + iv_local[4 + 1] = (engine_time >> 16) & 0xFF; + iv_local[4 + 2] = (engine_time >> 8) & 0xFF; + iv_local[4 + 3] = (engine_time >> 0) & 0xFF; + SMEMCPY(iv_local + 8, priv_param, 8); + if (mbedtls_cipher_set_iv(&ctx, iv_local, LWIP_ARRAYSIZE(iv_local)) != 0) { + goto error; + } + + for (i = 0; i < length; i++) { + u8_t in_byte; + u8_t out_byte; + size_t out_len = sizeof(out_byte); + + if (snmp_pbuf_stream_read(&read_stream, &in_byte) != ERR_OK) { + goto error; + } + if (mbedtls_cipher_update(&ctx, &in_byte, sizeof(in_byte), &out_byte, &out_len) != 0) { + goto error; + } + if (snmp_pbuf_stream_write(&write_stream, out_byte) != ERR_OK) { + goto error; + } + } + } else { + return ERR_ARG; + } + + mbedtls_cipher_free(&ctx); + return ERR_OK; + +error: + mbedtls_cipher_free(&ctx); + return ERR_OK; +} + +#endif /* LWIP_SNMP_V3_CRYPTO */ + +/* A.2.1. Password to Key Sample Code for MD5 */ +void +snmpv3_password_to_key_md5( + const u8_t *password, /* IN */ + size_t passwordlen, /* IN */ + const u8_t *engineID, /* IN - pointer to snmpEngineID */ + u8_t engineLength,/* IN - length of snmpEngineID */ + u8_t *key) /* OUT - pointer to caller 16-octet buffer */ +{ + mbedtls_md5_context MD; + u8_t *cp, password_buf[64]; + u32_t password_index = 0; + u8_t i; + u32_t count = 0; + + mbedtls_md5_init(&MD); /* initialize MD5 */ + mbedtls_md5_starts(&MD); + + /**********************************************/ + /* Use while loop until we've done 1 Megabyte */ + /**********************************************/ + while (count < 1048576) { + cp = password_buf; + for (i = 0; i < 64; i++) { + /*************************************************/ + /* Take the next octet of the password, wrapping */ + /* to the beginning of the password as necessary.*/ + /*************************************************/ + *cp++ = password[password_index++ % passwordlen]; + } + mbedtls_md5_update(&MD, password_buf, 64); + count += 64; + } + mbedtls_md5_finish(&MD, key); /* tell MD5 we're done */ + + /*****************************************************/ + /* Now localize the key with the engineID and pass */ + /* through MD5 to produce final key */ + /* May want to ensure that engineLength <= 32, */ + /* otherwise need to use a buffer larger than 64 */ + /*****************************************************/ + SMEMCPY(password_buf, key, 16); + MEMCPY(password_buf + 16, engineID, engineLength); + SMEMCPY(password_buf + 16 + engineLength, key, 16); + + mbedtls_md5_starts(&MD); + mbedtls_md5_update(&MD, password_buf, 32 + engineLength); + mbedtls_md5_finish(&MD, key); + + mbedtls_md5_free(&MD); + return; +} + +/* A.2.2. Password to Key Sample Code for SHA */ +void +snmpv3_password_to_key_sha( + const u8_t *password, /* IN */ + size_t passwordlen, /* IN */ + const u8_t *engineID, /* IN - pointer to snmpEngineID */ + u8_t engineLength,/* IN - length of snmpEngineID */ + u8_t *key) /* OUT - pointer to caller 20-octet buffer */ +{ + mbedtls_sha1_context SH; + u8_t *cp, password_buf[72]; + u32_t password_index = 0; + u8_t i; + u32_t count = 0; + + mbedtls_sha1_init(&SH); /* initialize SHA */ + mbedtls_sha1_starts(&SH); + + /**********************************************/ + /* Use while loop until we've done 1 Megabyte */ + /**********************************************/ + while (count < 1048576) { + cp = password_buf; + for (i = 0; i < 64; i++) { + /*************************************************/ + /* Take the next octet of the password, wrapping */ + /* to the beginning of the password as necessary.*/ + /*************************************************/ + *cp++ = password[password_index++ % passwordlen]; + } + mbedtls_sha1_update(&SH, password_buf, 64); + count += 64; + } + mbedtls_sha1_finish(&SH, key); /* tell SHA we're done */ + + /*****************************************************/ + /* Now localize the key with the engineID and pass */ + /* through SHA to produce final key */ + /* May want to ensure that engineLength <= 32, */ + /* otherwise need to use a buffer larger than 72 */ + /*****************************************************/ + SMEMCPY(password_buf, key, 20); + MEMCPY(password_buf + 20, engineID, engineLength); + SMEMCPY(password_buf + 20 + engineLength, key, 20); + + mbedtls_sha1_starts(&SH); + mbedtls_sha1_update(&SH, password_buf, 40 + engineLength); + mbedtls_sha1_finish(&SH, key); + + mbedtls_sha1_free(&SH); + return; +} + +#endif /* LWIP_SNMP && LWIP_SNMP_V3 && LWIP_SNMP_V3_MBEDTLS */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_priv.h index 8ea710ac..323364c3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/snmp/snmpv3_priv.h @@ -1,69 +1,69 @@ -/** - * @file - * Additional SNMPv3 functionality RFC3414 and RFC3826 (internal API, do not use in client code). - */ - -/* - * Copyright (c) 2016 Elias Oenal. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Elias Oenal - */ - -#ifndef LWIP_HDR_APPS_SNMP_V3_PRIV_H -#define LWIP_HDR_APPS_SNMP_V3_PRIV_H - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP && LWIP_SNMP_V3 - -#include "lwip/apps/snmpv3.h" -#include "snmp_pbuf_stream.h" - -/* According to RFC 3411 */ -#define SNMP_V3_MAX_ENGINE_ID_LENGTH 32 -#define SNMP_V3_MAX_USER_LENGTH 32 - -#define SNMP_V3_MAX_AUTH_PARAM_LENGTH 12 -#define SNMP_V3_MAX_PRIV_PARAM_LENGTH 8 - -#define SNMP_V3_MD5_LEN 16 -#define SNMP_V3_SHA_LEN 20 - -typedef enum { - SNMP_V3_PRIV_MODE_DECRYPT = 0, - SNMP_V3_PRIV_MODE_ENCRYPT = 1 -} snmpv3_priv_mode_t; - -s32_t snmpv3_get_engine_boots_internal(void); -err_t snmpv3_auth(struct snmp_pbuf_stream *stream, u16_t length, const u8_t *key, snmpv3_auth_algo_t algo, u8_t *hmac_out); -err_t snmpv3_crypt(struct snmp_pbuf_stream *stream, u16_t length, const u8_t *key, - const u8_t *priv_param, const u32_t engine_boots, const u32_t engine_time, snmpv3_priv_algo_t algo, snmpv3_priv_mode_t mode); -err_t snmpv3_build_priv_param(u8_t *priv_param); -void snmpv3_enginetime_timer(void *arg); - -#endif - -#endif /* LWIP_HDR_APPS_SNMP_V3_PRIV_H */ +/** + * @file + * Additional SNMPv3 functionality RFC3414 and RFC3826 (internal API, do not use in client code). + */ + +/* + * Copyright (c) 2016 Elias Oenal. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Elias Oenal + */ + +#ifndef LWIP_HDR_APPS_SNMP_V3_PRIV_H +#define LWIP_HDR_APPS_SNMP_V3_PRIV_H + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP && LWIP_SNMP_V3 + +#include "lwip/apps/snmpv3.h" +#include "snmp_pbuf_stream.h" + +/* According to RFC 3411 */ +#define SNMP_V3_MAX_ENGINE_ID_LENGTH 32 +#define SNMP_V3_MAX_USER_LENGTH 32 + +#define SNMP_V3_MAX_AUTH_PARAM_LENGTH 12 +#define SNMP_V3_MAX_PRIV_PARAM_LENGTH 8 + +#define SNMP_V3_MD5_LEN 16 +#define SNMP_V3_SHA_LEN 20 + +typedef enum { + SNMP_V3_PRIV_MODE_DECRYPT = 0, + SNMP_V3_PRIV_MODE_ENCRYPT = 1 +} snmpv3_priv_mode_t; + +s32_t snmpv3_get_engine_boots_internal(void); +err_t snmpv3_auth(struct snmp_pbuf_stream *stream, u16_t length, const u8_t *key, snmpv3_auth_algo_t algo, u8_t *hmac_out); +err_t snmpv3_crypt(struct snmp_pbuf_stream *stream, u16_t length, const u8_t *key, + const u8_t *priv_param, const u32_t engine_boots, const u32_t engine_time, snmpv3_priv_algo_t algo, snmpv3_priv_mode_t mode); +err_t snmpv3_build_priv_param(u8_t *priv_param); +void snmpv3_enginetime_timer(void *arg); + +#endif + +#endif /* LWIP_HDR_APPS_SNMP_V3_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/sntp/sntp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/sntp/sntp.c index 0952a633..b7ff56ad 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/sntp/sntp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/sntp/sntp.c @@ -1,869 +1,869 @@ -/** - * @file - * SNTP client module - */ - -/* - * Copyright (c) 2007-2009 Frédéric Bernon, Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Frédéric Bernon, Simon Goldschmidt - */ - - -/** - * @defgroup sntp SNTP - * @ingroup apps - * - * This is simple "SNTP" client for the lwIP raw API. - * It is a minimal implementation of SNTPv4 as specified in RFC 4330. - * - * For a list of some public NTP servers, see this link: - * http://support.ntp.org/bin/view/Servers/NTPPoolServers - * - * @todo: - * - complete SNTP_CHECK_RESPONSE checks 3 and 4 - */ - -#include "lwip/apps/sntp.h" - -#include "lwip/opt.h" -#include "lwip/timeouts.h" -#include "lwip/udp.h" -#include "lwip/dns.h" -#include "lwip/ip_addr.h" -#include "lwip/pbuf.h" -#include "lwip/dhcp.h" - -#include -#include - -#if LWIP_UDP - -/* Handle support for more than one server via SNTP_MAX_SERVERS */ -#if SNTP_MAX_SERVERS > 1 -#define SNTP_SUPPORT_MULTIPLE_SERVERS 1 -#else /* NTP_MAX_SERVERS > 1 */ -#define SNTP_SUPPORT_MULTIPLE_SERVERS 0 -#endif /* NTP_MAX_SERVERS > 1 */ - -#ifndef SNTP_SUPPRESS_DELAY_CHECK -#if SNTP_UPDATE_DELAY < 15000 -#error "SNTPv4 RFC 4330 enforces a minimum update time of 15 seconds (define SNTP_SUPPRESS_DELAY_CHECK to disable this error)!" -#endif -#endif - -/* the various debug levels for this file */ -#define SNTP_DEBUG_TRACE (SNTP_DEBUG | LWIP_DBG_TRACE) -#define SNTP_DEBUG_STATE (SNTP_DEBUG | LWIP_DBG_STATE) -#define SNTP_DEBUG_WARN (SNTP_DEBUG | LWIP_DBG_LEVEL_WARNING) -#define SNTP_DEBUG_WARN_STATE (SNTP_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) -#define SNTP_DEBUG_SERIOUS (SNTP_DEBUG | LWIP_DBG_LEVEL_SERIOUS) - -#define SNTP_ERR_KOD 1 - -/* SNTP protocol defines */ -#define SNTP_MSG_LEN 48 - -#define SNTP_OFFSET_LI_VN_MODE 0 -#define SNTP_LI_MASK 0xC0 -#define SNTP_LI_NO_WARNING (0x00 << 6) -#define SNTP_LI_LAST_MINUTE_61_SEC (0x01 << 6) -#define SNTP_LI_LAST_MINUTE_59_SEC (0x02 << 6) -#define SNTP_LI_ALARM_CONDITION (0x03 << 6) /* (clock not synchronized) */ - -#define SNTP_VERSION_MASK 0x38 -#define SNTP_VERSION (4/* NTP Version 4*/<<3) - -#define SNTP_MODE_MASK 0x07 -#define SNTP_MODE_CLIENT 0x03 -#define SNTP_MODE_SERVER 0x04 -#define SNTP_MODE_BROADCAST 0x05 - -#define SNTP_OFFSET_STRATUM 1 -#define SNTP_STRATUM_KOD 0x00 - -#define SNTP_OFFSET_ORIGINATE_TIME 24 -#define SNTP_OFFSET_RECEIVE_TIME 32 -#define SNTP_OFFSET_TRANSMIT_TIME 40 - -/* Number of seconds between 1970 and Feb 7, 2036 06:28:16 UTC (epoch 1) */ -#define DIFF_SEC_1970_2036 ((u32_t)2085978496L) - -/** Convert NTP timestamp fraction to microseconds. - */ -#ifndef SNTP_FRAC_TO_US -# if LWIP_HAVE_INT64 -# define SNTP_FRAC_TO_US(f) ((u32_t)(((u64_t)(f) * 1000000UL) >> 32)) -# else -# define SNTP_FRAC_TO_US(f) ((u32_t)(f) / 4295) -# endif -#endif /* !SNTP_FRAC_TO_US */ - -/* Configure behaviour depending on native, microsecond or second precision. - * Treat NTP timestamps as signed two's-complement integers. This way, - * timestamps that have the MSB set simply become negative offsets from - * the epoch (Feb 7, 2036 06:28:16 UTC). Representable dates range from - * 1968 to 2104. - */ -#ifndef SNTP_SET_SYSTEM_TIME_NTP -# ifdef SNTP_SET_SYSTEM_TIME_US -# define SNTP_SET_SYSTEM_TIME_NTP(s, f) \ - SNTP_SET_SYSTEM_TIME_US((u32_t)((s) + DIFF_SEC_1970_2036), SNTP_FRAC_TO_US(f)) -# else -# define SNTP_SET_SYSTEM_TIME_NTP(s, f) \ - SNTP_SET_SYSTEM_TIME((u32_t)((s) + DIFF_SEC_1970_2036)) -# endif -#endif /* !SNTP_SET_SYSTEM_TIME_NTP */ - -/* Get the system time either natively as NTP timestamp or convert from - * Unix time in seconds and microseconds. Take care to avoid overflow if the - * microsecond value is at the maximum of 999999. Also add 0.5 us fudge to - * avoid special values like 0, and to mask round-off errors that would - * otherwise break round-trip conversion identity. - */ -#ifndef SNTP_GET_SYSTEM_TIME_NTP -# define SNTP_GET_SYSTEM_TIME_NTP(s, f) do { \ - u32_t sec_, usec_; \ - SNTP_GET_SYSTEM_TIME(sec_, usec_); \ - (s) = (s32_t)(sec_ - DIFF_SEC_1970_2036); \ - (f) = usec_ * 4295 - ((usec_ * 2143) >> 16) + 2147; \ - } while (0) -#endif /* !SNTP_GET_SYSTEM_TIME_NTP */ - -/* Start offset of the timestamps to extract from the SNTP packet */ -#define SNTP_OFFSET_TIMESTAMPS \ - (SNTP_OFFSET_TRANSMIT_TIME + 8 - sizeof(struct sntp_timestamps)) - -/* Round-trip delay arithmetic helpers */ -#if SNTP_COMP_ROUNDTRIP -# if !LWIP_HAVE_INT64 -# error "SNTP round-trip delay compensation requires 64-bit arithmetic" -# endif -# define SNTP_SEC_FRAC_TO_S64(s, f) \ - ((s64_t)(((u64_t)(s) << 32) | (u32_t)(f))) -# define SNTP_TIMESTAMP_TO_S64(t) \ - SNTP_SEC_FRAC_TO_S64(lwip_ntohl((t).sec), lwip_ntohl((t).frac)) -#endif /* SNTP_COMP_ROUNDTRIP */ - -/** - * 64-bit NTP timestamp, in network byte order. - */ -struct sntp_time { - u32_t sec; - u32_t frac; -}; - -/** - * Timestamps to be extracted from the NTP header. - */ -struct sntp_timestamps { -#if SNTP_COMP_ROUNDTRIP || SNTP_CHECK_RESPONSE >= 2 - struct sntp_time orig; - struct sntp_time recv; -#endif - struct sntp_time xmit; -}; - -/** - * SNTP packet format (without optional fields) - * Timestamps are coded as 64 bits: - * - signed 32 bits seconds since Feb 07, 2036, 06:28:16 UTC (epoch 1) - * - unsigned 32 bits seconds fraction (2^32 = 1 second) - */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct sntp_msg { - PACK_STRUCT_FLD_8(u8_t li_vn_mode); - PACK_STRUCT_FLD_8(u8_t stratum); - PACK_STRUCT_FLD_8(u8_t poll); - PACK_STRUCT_FLD_8(u8_t precision); - PACK_STRUCT_FIELD(u32_t root_delay); - PACK_STRUCT_FIELD(u32_t root_dispersion); - PACK_STRUCT_FIELD(u32_t reference_identifier); - PACK_STRUCT_FIELD(u32_t reference_timestamp[2]); - PACK_STRUCT_FIELD(u32_t originate_timestamp[2]); - PACK_STRUCT_FIELD(u32_t receive_timestamp[2]); - PACK_STRUCT_FIELD(u32_t transmit_timestamp[2]); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/* function prototypes */ -static void sntp_request(void *arg); - -/** The operating mode */ -static u8_t sntp_opmode; - -/** The UDP pcb used by the SNTP client */ -static struct udp_pcb *sntp_pcb; -/** Names/Addresses of servers */ -struct sntp_server { -#if SNTP_SERVER_DNS - const char *name; -#endif /* SNTP_SERVER_DNS */ - ip_addr_t addr; -#if SNTP_MONITOR_SERVER_REACHABILITY - /** Reachability shift register as described in RFC 5905 */ - u8_t reachability; -#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ -}; -static struct sntp_server sntp_servers[SNTP_MAX_SERVERS]; - -#if SNTP_GET_SERVERS_FROM_DHCP -static u8_t sntp_set_servers_from_dhcp; -#endif /* SNTP_GET_SERVERS_FROM_DHCP */ -#if SNTP_SUPPORT_MULTIPLE_SERVERS -/** The currently used server (initialized to 0) */ -static u8_t sntp_current_server; -#else /* SNTP_SUPPORT_MULTIPLE_SERVERS */ -#define sntp_current_server 0 -#endif /* SNTP_SUPPORT_MULTIPLE_SERVERS */ - -#if SNTP_RETRY_TIMEOUT_EXP -#define SNTP_RESET_RETRY_TIMEOUT() sntp_retry_timeout = SNTP_RETRY_TIMEOUT -/** Retry time, initialized with SNTP_RETRY_TIMEOUT and doubled with each retry. */ -static u32_t sntp_retry_timeout; -#else /* SNTP_RETRY_TIMEOUT_EXP */ -#define SNTP_RESET_RETRY_TIMEOUT() -#define sntp_retry_timeout SNTP_RETRY_TIMEOUT -#endif /* SNTP_RETRY_TIMEOUT_EXP */ - -#if SNTP_CHECK_RESPONSE >= 1 -/** Saves the last server address to compare with response */ -static ip_addr_t sntp_last_server_address; -#endif /* SNTP_CHECK_RESPONSE >= 1 */ - -#if SNTP_CHECK_RESPONSE >= 2 -/** Saves the last timestamp sent (which is sent back by the server) - * to compare against in response. Stored in network byte order. */ -static struct sntp_time sntp_last_timestamp_sent; -#endif /* SNTP_CHECK_RESPONSE >= 2 */ - -#if defined(LWIP_DEBUG) && !defined(sntp_format_time) -/* Debug print helper. */ -static const char * -sntp_format_time(s32_t sec) -{ - time_t ut; - ut = (u32_t)((u32_t)sec + DIFF_SEC_1970_2036); - return ctime(&ut); -} -#endif /* LWIP_DEBUG && !sntp_format_time */ - -/** - * SNTP processing of received timestamp - */ -static void -sntp_process(const struct sntp_timestamps *timestamps) -{ - s32_t sec; - u32_t frac; - - sec = (s32_t)lwip_ntohl(timestamps->xmit.sec); - frac = lwip_ntohl(timestamps->xmit.frac); - -#if SNTP_COMP_ROUNDTRIP -# if SNTP_CHECK_RESPONSE >= 2 - if (timestamps->recv.sec != 0 || timestamps->recv.frac != 0) -# endif - { - s32_t dest_sec; - u32_t dest_frac; - u32_t step_sec; - - /* Get the destination time stamp, i.e. the current system time */ - SNTP_GET_SYSTEM_TIME_NTP(dest_sec, dest_frac); - - step_sec = (dest_sec < sec) ? ((u32_t)sec - (u32_t)dest_sec) - : ((u32_t)dest_sec - (u32_t)sec); - /* In order to avoid overflows, skip the compensation if the clock step - * is larger than about 34 years. */ - if ((step_sec >> 30) == 0) { - s64_t t1, t2, t3, t4; - - t4 = SNTP_SEC_FRAC_TO_S64(dest_sec, dest_frac); - t3 = SNTP_SEC_FRAC_TO_S64(sec, frac); - t1 = SNTP_TIMESTAMP_TO_S64(timestamps->orig); - t2 = SNTP_TIMESTAMP_TO_S64(timestamps->recv); - /* Clock offset calculation according to RFC 4330 */ - t4 += ((t2 - t1) + (t3 - t4)) / 2; - - sec = (s32_t)((u64_t)t4 >> 32); - frac = (u32_t)((u64_t)t4); - } - } -#endif /* SNTP_COMP_ROUNDTRIP */ - - SNTP_SET_SYSTEM_TIME_NTP(sec, frac); - LWIP_UNUSED_ARG(frac); /* might be unused if only seconds are set */ - LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp_process: %s, %" U32_F " us\n", - sntp_format_time(sec), SNTP_FRAC_TO_US(frac))); -} - -/** - * Initialize request struct to be sent to server. - */ -static void -sntp_initialize_request(struct sntp_msg *req) -{ - memset(req, 0, SNTP_MSG_LEN); - req->li_vn_mode = SNTP_LI_NO_WARNING | SNTP_VERSION | SNTP_MODE_CLIENT; - -#if SNTP_CHECK_RESPONSE >= 2 || SNTP_COMP_ROUNDTRIP - { - s32_t secs; - u32_t sec, frac; - /* Get the transmit timestamp */ - SNTP_GET_SYSTEM_TIME_NTP(secs, frac); - sec = lwip_htonl((u32_t)secs); - frac = lwip_htonl(frac); - -# if SNTP_CHECK_RESPONSE >= 2 - sntp_last_timestamp_sent.sec = sec; - sntp_last_timestamp_sent.frac = frac; -# endif - req->transmit_timestamp[0] = sec; - req->transmit_timestamp[1] = frac; - } -#endif /* SNTP_CHECK_RESPONSE >= 2 || SNTP_COMP_ROUNDTRIP */ -} - -/** - * Retry: send a new request (and increase retry timeout). - * - * @param arg is unused (only necessary to conform to sys_timeout) - */ -static void -sntp_retry(void *arg) -{ - LWIP_UNUSED_ARG(arg); - - LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_retry: Next request will be sent in %"U32_F" ms\n", - sntp_retry_timeout)); - - /* set up a timer to send a retry and increase the retry delay */ - sys_timeout(sntp_retry_timeout, sntp_request, NULL); - -#if SNTP_RETRY_TIMEOUT_EXP - { - u32_t new_retry_timeout; - /* increase the timeout for next retry */ - new_retry_timeout = sntp_retry_timeout << 1; - /* limit to maximum timeout and prevent overflow */ - if ((new_retry_timeout <= SNTP_RETRY_TIMEOUT_MAX) && - (new_retry_timeout > sntp_retry_timeout)) { - sntp_retry_timeout = new_retry_timeout; - } - } -#endif /* SNTP_RETRY_TIMEOUT_EXP */ -} - -#if SNTP_SUPPORT_MULTIPLE_SERVERS -/** - * If Kiss-of-Death is received (or another packet parsing error), - * try the next server or retry the current server and increase the retry - * timeout if only one server is available. - * (implicitly, SNTP_MAX_SERVERS > 1) - * - * @param arg is unused (only necessary to conform to sys_timeout) - */ -static void -sntp_try_next_server(void *arg) -{ - u8_t old_server, i; - LWIP_UNUSED_ARG(arg); - - old_server = sntp_current_server; - for (i = 0; i < SNTP_MAX_SERVERS - 1; i++) { - sntp_current_server++; - if (sntp_current_server >= SNTP_MAX_SERVERS) { - sntp_current_server = 0; - } - if (!ip_addr_isany(&sntp_servers[sntp_current_server].addr) -#if SNTP_SERVER_DNS - || (sntp_servers[sntp_current_server].name != NULL) -#endif - ) { - LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_try_next_server: Sending request to server %"U16_F"\n", - (u16_t)sntp_current_server)); - /* new server: reset retry timeout */ - SNTP_RESET_RETRY_TIMEOUT(); - /* instantly send a request to the next server */ - sntp_request(NULL); - return; - } - } - /* no other valid server found */ - sntp_current_server = old_server; - sntp_retry(NULL); -} -#else /* SNTP_SUPPORT_MULTIPLE_SERVERS */ -/* Always retry on error if only one server is supported */ -#define sntp_try_next_server sntp_retry -#endif /* SNTP_SUPPORT_MULTIPLE_SERVERS */ - -/** UDP recv callback for the sntp pcb */ -static void -sntp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - struct sntp_timestamps timestamps; - u8_t mode; - u8_t stratum; - err_t err; - - LWIP_UNUSED_ARG(arg); - LWIP_UNUSED_ARG(pcb); - - err = ERR_ARG; -#if SNTP_CHECK_RESPONSE >= 1 - /* check server address and port */ - if (((sntp_opmode != SNTP_OPMODE_POLL) || ip_addr_cmp(addr, &sntp_last_server_address)) && - (port == SNTP_PORT)) -#else /* SNTP_CHECK_RESPONSE >= 1 */ - LWIP_UNUSED_ARG(addr); - LWIP_UNUSED_ARG(port); -#endif /* SNTP_CHECK_RESPONSE >= 1 */ - { - /* process the response */ - if (p->tot_len == SNTP_MSG_LEN) { - mode = pbuf_get_at(p, SNTP_OFFSET_LI_VN_MODE) & SNTP_MODE_MASK; - /* if this is a SNTP response... */ - if (((sntp_opmode == SNTP_OPMODE_POLL) && (mode == SNTP_MODE_SERVER)) || - ((sntp_opmode == SNTP_OPMODE_LISTENONLY) && (mode == SNTP_MODE_BROADCAST))) { - stratum = pbuf_get_at(p, SNTP_OFFSET_STRATUM); - - if (stratum == SNTP_STRATUM_KOD) { - /* Kiss-of-death packet. Use another server or increase UPDATE_DELAY. */ - err = SNTP_ERR_KOD; - LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_recv: Received Kiss-of-Death\n")); - } else { - pbuf_copy_partial(p, ×tamps, sizeof(timestamps), SNTP_OFFSET_TIMESTAMPS); -#if SNTP_CHECK_RESPONSE >= 2 - /* check originate_timetamp against sntp_last_timestamp_sent */ - if (timestamps.orig.sec != sntp_last_timestamp_sent.sec || - timestamps.orig.frac != sntp_last_timestamp_sent.frac) { - LWIP_DEBUGF(SNTP_DEBUG_WARN, - ("sntp_recv: Invalid originate timestamp in response\n")); - } else -#endif /* SNTP_CHECK_RESPONSE >= 2 */ - /* @todo: add code for SNTP_CHECK_RESPONSE >= 3 and >= 4 here */ - { - /* correct answer */ - err = ERR_OK; - } - } - } else { - LWIP_DEBUGF(SNTP_DEBUG_WARN, ("sntp_recv: Invalid mode in response: %"U16_F"\n", (u16_t)mode)); - /* wait for correct response */ - err = ERR_TIMEOUT; - } - } else { - LWIP_DEBUGF(SNTP_DEBUG_WARN, ("sntp_recv: Invalid packet length: %"U16_F"\n", p->tot_len)); - } - } -#if SNTP_CHECK_RESPONSE >= 1 - else { - /* packet from wrong remote address or port, wait for correct response */ - err = ERR_TIMEOUT; - } -#endif /* SNTP_CHECK_RESPONSE >= 1 */ - - pbuf_free(p); - - if (err == ERR_OK) { - /* correct packet received: process it it */ - sntp_process(×tamps); - -#if SNTP_MONITOR_SERVER_REACHABILITY - /* indicate that server responded */ - sntp_servers[sntp_current_server].reachability |= 1; -#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ - /* Set up timeout for next request (only if poll response was received)*/ - if (sntp_opmode == SNTP_OPMODE_POLL) { - u32_t sntp_update_delay; - sys_untimeout(sntp_try_next_server, NULL); - sys_untimeout(sntp_request, NULL); - - /* Correct response, reset retry timeout */ - SNTP_RESET_RETRY_TIMEOUT(); - - sntp_update_delay = (u32_t)SNTP_UPDATE_DELAY; - sys_timeout(sntp_update_delay, sntp_request, NULL); - LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_recv: Scheduled next time request: %"U32_F" ms\n", - sntp_update_delay)); - } - } else if (err == SNTP_ERR_KOD) { - /* KOD errors are only processed in case of an explicit poll response */ - if (sntp_opmode == SNTP_OPMODE_POLL) { - /* Kiss-of-death packet. Use another server or increase UPDATE_DELAY. */ - sntp_try_next_server(NULL); - } - } else { - /* ignore any broken packet, poll mode: retry after timeout to avoid flooding */ - } -} - -/** Actually send an sntp request to a server. - * - * @param server_addr resolved IP address of the SNTP server - */ -static void -sntp_send_request(const ip_addr_t *server_addr) -{ - struct pbuf *p; - - LWIP_ASSERT("server_addr != NULL", server_addr != NULL); - - p = pbuf_alloc(PBUF_TRANSPORT, SNTP_MSG_LEN, PBUF_RAM); - if (p != NULL) { - struct sntp_msg *sntpmsg = (struct sntp_msg *)p->payload; - LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_send_request: Sending request to server\n")); - /* initialize request message */ - sntp_initialize_request(sntpmsg); - /* send request */ - udp_sendto(sntp_pcb, p, server_addr, SNTP_PORT); - /* free the pbuf after sending it */ - pbuf_free(p); -#if SNTP_MONITOR_SERVER_REACHABILITY - /* indicate new packet has been sent */ - sntp_servers[sntp_current_server].reachability <<= 1; -#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ - /* set up receive timeout: try next server or retry on timeout */ - sys_timeout((u32_t)SNTP_RECV_TIMEOUT, sntp_try_next_server, NULL); -#if SNTP_CHECK_RESPONSE >= 1 - /* save server address to verify it in sntp_recv */ - ip_addr_copy(sntp_last_server_address, *server_addr); -#endif /* SNTP_CHECK_RESPONSE >= 1 */ - } else { - LWIP_DEBUGF(SNTP_DEBUG_SERIOUS, ("sntp_send_request: Out of memory, trying again in %"U32_F" ms\n", - (u32_t)SNTP_RETRY_TIMEOUT)); - /* out of memory: set up a timer to send a retry */ - sys_timeout((u32_t)SNTP_RETRY_TIMEOUT, sntp_request, NULL); - } -} - -#if SNTP_SERVER_DNS -/** - * DNS found callback when using DNS names as server address. - */ -static void -sntp_dns_found(const char *hostname, const ip_addr_t *ipaddr, void *arg) -{ - LWIP_UNUSED_ARG(hostname); - LWIP_UNUSED_ARG(arg); - - if (ipaddr != NULL) { - /* Address resolved, send request */ - LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_dns_found: Server address resolved, sending request\n")); - sntp_servers[sntp_current_server].addr = *ipaddr; - sntp_send_request(ipaddr); - } else { - /* DNS resolving failed -> try another server */ - LWIP_DEBUGF(SNTP_DEBUG_WARN_STATE, ("sntp_dns_found: Failed to resolve server address resolved, trying next server\n")); - sntp_try_next_server(NULL); - } -} -#endif /* SNTP_SERVER_DNS */ - -/** - * Send out an sntp request. - * - * @param arg is unused (only necessary to conform to sys_timeout) - */ -static void -sntp_request(void *arg) -{ - ip_addr_t sntp_server_address; - err_t err; - - LWIP_UNUSED_ARG(arg); - - /* initialize SNTP server address */ -#if SNTP_SERVER_DNS - if (sntp_servers[sntp_current_server].name) { - /* always resolve the name and rely on dns-internal caching & timeout */ - ip_addr_set_zero(&sntp_servers[sntp_current_server].addr); - err = dns_gethostbyname(sntp_servers[sntp_current_server].name, &sntp_server_address, - sntp_dns_found, NULL); - if (err == ERR_INPROGRESS) { - /* DNS request sent, wait for sntp_dns_found being called */ - LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_request: Waiting for server address to be resolved.\n")); - return; - } else if (err == ERR_OK) { - sntp_servers[sntp_current_server].addr = sntp_server_address; - } - } else -#endif /* SNTP_SERVER_DNS */ - { - sntp_server_address = sntp_servers[sntp_current_server].addr; - err = (ip_addr_isany_val(sntp_server_address)) ? ERR_ARG : ERR_OK; - } - - if (err == ERR_OK) { - LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp_request: current server address is %s\n", - ipaddr_ntoa(&sntp_server_address))); - sntp_send_request(&sntp_server_address); - } else { - /* address conversion failed, try another server */ - LWIP_DEBUGF(SNTP_DEBUG_WARN_STATE, ("sntp_request: Invalid server address, trying next server.\n")); - sys_timeout((u32_t)SNTP_RETRY_TIMEOUT, sntp_try_next_server, NULL); - } -} - -/** - * @ingroup sntp - * Initialize this module. - * Send out request instantly or after SNTP_STARTUP_DELAY(_FUNC). - */ -void -sntp_init(void) -{ - /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ - -#ifdef SNTP_SERVER_ADDRESS -#if SNTP_SERVER_DNS - sntp_setservername(0, SNTP_SERVER_ADDRESS); -#else -#error SNTP_SERVER_ADDRESS string not supported SNTP_SERVER_DNS==0 -#endif -#endif /* SNTP_SERVER_ADDRESS */ - - if (sntp_pcb == NULL) { - sntp_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); - LWIP_ASSERT("Failed to allocate udp pcb for sntp client", sntp_pcb != NULL); - if (sntp_pcb != NULL) { - udp_recv(sntp_pcb, sntp_recv, NULL); - - if (sntp_opmode == SNTP_OPMODE_POLL) { - SNTP_RESET_RETRY_TIMEOUT(); -#if SNTP_STARTUP_DELAY - sys_timeout((u32_t)SNTP_STARTUP_DELAY_FUNC, sntp_request, NULL); -#else - sntp_request(NULL); -#endif - } else if (sntp_opmode == SNTP_OPMODE_LISTENONLY) { - ip_set_option(sntp_pcb, SOF_BROADCAST); - udp_bind(sntp_pcb, IP_ANY_TYPE, SNTP_PORT); - } - } - } -} - -/** - * @ingroup sntp - * Stop this module. - */ -void -sntp_stop(void) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (sntp_pcb != NULL) { -#if SNTP_MONITOR_SERVER_REACHABILITY - u8_t i; - for (i = 0; i < SNTP_MAX_SERVERS; i++) { - sntp_servers[i].reachability = 0; - } -#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ - sys_untimeout(sntp_request, NULL); - sys_untimeout(sntp_try_next_server, NULL); - udp_remove(sntp_pcb); - sntp_pcb = NULL; - } -} - -/** - * @ingroup sntp - * Get enabled state. - */ -u8_t sntp_enabled(void) -{ - return (sntp_pcb != NULL) ? 1 : 0; -} - -/** - * @ingroup sntp - * Sets the operating mode. - * @param operating_mode one of the available operating modes - */ -void -sntp_setoperatingmode(u8_t operating_mode) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("Invalid operating mode", operating_mode <= SNTP_OPMODE_LISTENONLY); - LWIP_ASSERT("Operating mode must not be set while SNTP client is running", sntp_pcb == NULL); - sntp_opmode = operating_mode; -} - -/** - * @ingroup sntp - * Gets the operating mode. - */ -u8_t -sntp_getoperatingmode(void) -{ - return sntp_opmode; -} - -#if SNTP_MONITOR_SERVER_REACHABILITY -/** - * @ingroup sntp - * Gets the server reachability shift register as described in RFC 5905. - * - * @param idx the index of the NTP server - */ -u8_t -sntp_getreachability(u8_t idx) -{ - if (idx < SNTP_MAX_SERVERS) { - return sntp_servers[idx].reachability; - } - return 0; -} -#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ - -#if SNTP_GET_SERVERS_FROM_DHCP -/** - * Config SNTP server handling by IP address, name, or DHCP; clear table - * @param set_servers_from_dhcp enable or disable getting server addresses from dhcp - */ -void -sntp_servermode_dhcp(int set_servers_from_dhcp) -{ - u8_t new_mode = set_servers_from_dhcp ? 1 : 0; - LWIP_ASSERT_CORE_LOCKED(); - if (sntp_set_servers_from_dhcp != new_mode) { - sntp_set_servers_from_dhcp = new_mode; - } -} -#endif /* SNTP_GET_SERVERS_FROM_DHCP */ - -/** - * @ingroup sntp - * Initialize one of the NTP servers by IP address - * - * @param idx the index of the NTP server to set must be < SNTP_MAX_SERVERS - * @param server IP address of the NTP server to set - */ -void -sntp_setserver(u8_t idx, const ip_addr_t *server) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (idx < SNTP_MAX_SERVERS) { - if (server != NULL) { - sntp_servers[idx].addr = (*server); - } else { - ip_addr_set_zero(&sntp_servers[idx].addr); - } -#if SNTP_SERVER_DNS - sntp_servers[idx].name = NULL; -#endif - } -} - -#if LWIP_DHCP && SNTP_GET_SERVERS_FROM_DHCP -/** - * Initialize one of the NTP servers by IP address, required by DHCP - * - * @param num the index of the NTP server to set must be < SNTP_MAX_SERVERS - * @param server IP address of the NTP server to set - */ -void -dhcp_set_ntp_servers(u8_t num, const ip4_addr_t *server) -{ - LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp: %s %u.%u.%u.%u as NTP server #%u via DHCP\n", - (sntp_set_servers_from_dhcp ? "Got" : "Rejected"), - ip4_addr1(server), ip4_addr2(server), ip4_addr3(server), ip4_addr4(server), num)); - if (sntp_set_servers_from_dhcp && num) { - u8_t i; - for (i = 0; (i < num) && (i < SNTP_MAX_SERVERS); i++) { - ip_addr_t addr; - ip_addr_copy_from_ip4(addr, server[i]); - sntp_setserver(i, &addr); - } - for (i = num; i < SNTP_MAX_SERVERS; i++) { - sntp_setserver(i, NULL); - } - } -} -#endif /* LWIP_DHCP && SNTP_GET_SERVERS_FROM_DHCP */ - -/** - * @ingroup sntp - * Obtain one of the currently configured by IP address (or DHCP) NTP servers - * - * @param idx the index of the NTP server - * @return IP address of the indexed NTP server or "ip_addr_any" if the NTP - * server has not been configured by address (or at all). - */ -const ip_addr_t * -sntp_getserver(u8_t idx) -{ - if (idx < SNTP_MAX_SERVERS) { - return &sntp_servers[idx].addr; - } - return IP_ADDR_ANY; -} - -#if SNTP_SERVER_DNS -/** - * Initialize one of the NTP servers by name - * - * @param idx the index of the NTP server to set must be < SNTP_MAX_SERVERS - * @param server DNS name of the NTP server to set, to be resolved at contact time - */ -void -sntp_setservername(u8_t idx, const char *server) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (idx < SNTP_MAX_SERVERS) { - sntp_servers[idx].name = server; - } -} - -/** - * Obtain one of the currently configured by name NTP servers. - * - * @param idx the index of the NTP server - * @return IP address of the indexed NTP server or NULL if the NTP - * server has not been configured by name (or at all) - */ -const char * -sntp_getservername(u8_t idx) -{ - if (idx < SNTP_MAX_SERVERS) { - return sntp_servers[idx].name; - } - return NULL; -} -#endif /* SNTP_SERVER_DNS */ - -#endif /* LWIP_UDP */ +/** + * @file + * SNTP client module + */ + +/* + * Copyright (c) 2007-2009 Frédéric Bernon, Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Frédéric Bernon, Simon Goldschmidt + */ + + +/** + * @defgroup sntp SNTP + * @ingroup apps + * + * This is simple "SNTP" client for the lwIP raw API. + * It is a minimal implementation of SNTPv4 as specified in RFC 4330. + * + * For a list of some public NTP servers, see this link: + * http://support.ntp.org/bin/view/Servers/NTPPoolServers + * + * @todo: + * - complete SNTP_CHECK_RESPONSE checks 3 and 4 + */ + +#include "lwip/apps/sntp.h" + +#include "lwip/opt.h" +#include "lwip/timeouts.h" +#include "lwip/udp.h" +#include "lwip/dns.h" +#include "lwip/ip_addr.h" +#include "lwip/pbuf.h" +#include "lwip/dhcp.h" + +#include +#include + +#if LWIP_UDP + +/* Handle support for more than one server via SNTP_MAX_SERVERS */ +#if SNTP_MAX_SERVERS > 1 +#define SNTP_SUPPORT_MULTIPLE_SERVERS 1 +#else /* NTP_MAX_SERVERS > 1 */ +#define SNTP_SUPPORT_MULTIPLE_SERVERS 0 +#endif /* NTP_MAX_SERVERS > 1 */ + +#ifndef SNTP_SUPPRESS_DELAY_CHECK +#if SNTP_UPDATE_DELAY < 15000 +#error "SNTPv4 RFC 4330 enforces a minimum update time of 15 seconds (define SNTP_SUPPRESS_DELAY_CHECK to disable this error)!" +#endif +#endif + +/* the various debug levels for this file */ +#define SNTP_DEBUG_TRACE (SNTP_DEBUG | LWIP_DBG_TRACE) +#define SNTP_DEBUG_STATE (SNTP_DEBUG | LWIP_DBG_STATE) +#define SNTP_DEBUG_WARN (SNTP_DEBUG | LWIP_DBG_LEVEL_WARNING) +#define SNTP_DEBUG_WARN_STATE (SNTP_DEBUG | LWIP_DBG_LEVEL_WARNING | LWIP_DBG_STATE) +#define SNTP_DEBUG_SERIOUS (SNTP_DEBUG | LWIP_DBG_LEVEL_SERIOUS) + +#define SNTP_ERR_KOD 1 + +/* SNTP protocol defines */ +#define SNTP_MSG_LEN 48 + +#define SNTP_OFFSET_LI_VN_MODE 0 +#define SNTP_LI_MASK 0xC0 +#define SNTP_LI_NO_WARNING (0x00 << 6) +#define SNTP_LI_LAST_MINUTE_61_SEC (0x01 << 6) +#define SNTP_LI_LAST_MINUTE_59_SEC (0x02 << 6) +#define SNTP_LI_ALARM_CONDITION (0x03 << 6) /* (clock not synchronized) */ + +#define SNTP_VERSION_MASK 0x38 +#define SNTP_VERSION (4/* NTP Version 4*/<<3) + +#define SNTP_MODE_MASK 0x07 +#define SNTP_MODE_CLIENT 0x03 +#define SNTP_MODE_SERVER 0x04 +#define SNTP_MODE_BROADCAST 0x05 + +#define SNTP_OFFSET_STRATUM 1 +#define SNTP_STRATUM_KOD 0x00 + +#define SNTP_OFFSET_ORIGINATE_TIME 24 +#define SNTP_OFFSET_RECEIVE_TIME 32 +#define SNTP_OFFSET_TRANSMIT_TIME 40 + +/* Number of seconds between 1970 and Feb 7, 2036 06:28:16 UTC (epoch 1) */ +#define DIFF_SEC_1970_2036 ((u32_t)2085978496L) + +/** Convert NTP timestamp fraction to microseconds. + */ +#ifndef SNTP_FRAC_TO_US +# if LWIP_HAVE_INT64 +# define SNTP_FRAC_TO_US(f) ((u32_t)(((u64_t)(f) * 1000000UL) >> 32)) +# else +# define SNTP_FRAC_TO_US(f) ((u32_t)(f) / 4295) +# endif +#endif /* !SNTP_FRAC_TO_US */ + +/* Configure behaviour depending on native, microsecond or second precision. + * Treat NTP timestamps as signed two's-complement integers. This way, + * timestamps that have the MSB set simply become negative offsets from + * the epoch (Feb 7, 2036 06:28:16 UTC). Representable dates range from + * 1968 to 2104. + */ +#ifndef SNTP_SET_SYSTEM_TIME_NTP +# ifdef SNTP_SET_SYSTEM_TIME_US +# define SNTP_SET_SYSTEM_TIME_NTP(s, f) \ + SNTP_SET_SYSTEM_TIME_US((u32_t)((s) + DIFF_SEC_1970_2036), SNTP_FRAC_TO_US(f)) +# else +# define SNTP_SET_SYSTEM_TIME_NTP(s, f) \ + SNTP_SET_SYSTEM_TIME((u32_t)((s) + DIFF_SEC_1970_2036)) +# endif +#endif /* !SNTP_SET_SYSTEM_TIME_NTP */ + +/* Get the system time either natively as NTP timestamp or convert from + * Unix time in seconds and microseconds. Take care to avoid overflow if the + * microsecond value is at the maximum of 999999. Also add 0.5 us fudge to + * avoid special values like 0, and to mask round-off errors that would + * otherwise break round-trip conversion identity. + */ +#ifndef SNTP_GET_SYSTEM_TIME_NTP +# define SNTP_GET_SYSTEM_TIME_NTP(s, f) do { \ + u32_t sec_, usec_; \ + SNTP_GET_SYSTEM_TIME(sec_, usec_); \ + (s) = (s32_t)(sec_ - DIFF_SEC_1970_2036); \ + (f) = usec_ * 4295 - ((usec_ * 2143) >> 16) + 2147; \ + } while (0) +#endif /* !SNTP_GET_SYSTEM_TIME_NTP */ + +/* Start offset of the timestamps to extract from the SNTP packet */ +#define SNTP_OFFSET_TIMESTAMPS \ + (SNTP_OFFSET_TRANSMIT_TIME + 8 - sizeof(struct sntp_timestamps)) + +/* Round-trip delay arithmetic helpers */ +#if SNTP_COMP_ROUNDTRIP +# if !LWIP_HAVE_INT64 +# error "SNTP round-trip delay compensation requires 64-bit arithmetic" +# endif +# define SNTP_SEC_FRAC_TO_S64(s, f) \ + ((s64_t)(((u64_t)(s) << 32) | (u32_t)(f))) +# define SNTP_TIMESTAMP_TO_S64(t) \ + SNTP_SEC_FRAC_TO_S64(lwip_ntohl((t).sec), lwip_ntohl((t).frac)) +#endif /* SNTP_COMP_ROUNDTRIP */ + +/** + * 64-bit NTP timestamp, in network byte order. + */ +struct sntp_time { + u32_t sec; + u32_t frac; +}; + +/** + * Timestamps to be extracted from the NTP header. + */ +struct sntp_timestamps { +#if SNTP_COMP_ROUNDTRIP || SNTP_CHECK_RESPONSE >= 2 + struct sntp_time orig; + struct sntp_time recv; +#endif + struct sntp_time xmit; +}; + +/** + * SNTP packet format (without optional fields) + * Timestamps are coded as 64 bits: + * - signed 32 bits seconds since Feb 07, 2036, 06:28:16 UTC (epoch 1) + * - unsigned 32 bits seconds fraction (2^32 = 1 second) + */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct sntp_msg { + PACK_STRUCT_FLD_8(u8_t li_vn_mode); + PACK_STRUCT_FLD_8(u8_t stratum); + PACK_STRUCT_FLD_8(u8_t poll); + PACK_STRUCT_FLD_8(u8_t precision); + PACK_STRUCT_FIELD(u32_t root_delay); + PACK_STRUCT_FIELD(u32_t root_dispersion); + PACK_STRUCT_FIELD(u32_t reference_identifier); + PACK_STRUCT_FIELD(u32_t reference_timestamp[2]); + PACK_STRUCT_FIELD(u32_t originate_timestamp[2]); + PACK_STRUCT_FIELD(u32_t receive_timestamp[2]); + PACK_STRUCT_FIELD(u32_t transmit_timestamp[2]); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/* function prototypes */ +static void sntp_request(void *arg); + +/** The operating mode */ +static u8_t sntp_opmode; + +/** The UDP pcb used by the SNTP client */ +static struct udp_pcb *sntp_pcb; +/** Names/Addresses of servers */ +struct sntp_server { +#if SNTP_SERVER_DNS + const char *name; +#endif /* SNTP_SERVER_DNS */ + ip_addr_t addr; +#if SNTP_MONITOR_SERVER_REACHABILITY + /** Reachability shift register as described in RFC 5905 */ + u8_t reachability; +#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ +}; +static struct sntp_server sntp_servers[SNTP_MAX_SERVERS]; + +#if SNTP_GET_SERVERS_FROM_DHCP +static u8_t sntp_set_servers_from_dhcp; +#endif /* SNTP_GET_SERVERS_FROM_DHCP */ +#if SNTP_SUPPORT_MULTIPLE_SERVERS +/** The currently used server (initialized to 0) */ +static u8_t sntp_current_server; +#else /* SNTP_SUPPORT_MULTIPLE_SERVERS */ +#define sntp_current_server 0 +#endif /* SNTP_SUPPORT_MULTIPLE_SERVERS */ + +#if SNTP_RETRY_TIMEOUT_EXP +#define SNTP_RESET_RETRY_TIMEOUT() sntp_retry_timeout = SNTP_RETRY_TIMEOUT +/** Retry time, initialized with SNTP_RETRY_TIMEOUT and doubled with each retry. */ +static u32_t sntp_retry_timeout; +#else /* SNTP_RETRY_TIMEOUT_EXP */ +#define SNTP_RESET_RETRY_TIMEOUT() +#define sntp_retry_timeout SNTP_RETRY_TIMEOUT +#endif /* SNTP_RETRY_TIMEOUT_EXP */ + +#if SNTP_CHECK_RESPONSE >= 1 +/** Saves the last server address to compare with response */ +static ip_addr_t sntp_last_server_address; +#endif /* SNTP_CHECK_RESPONSE >= 1 */ + +#if SNTP_CHECK_RESPONSE >= 2 +/** Saves the last timestamp sent (which is sent back by the server) + * to compare against in response. Stored in network byte order. */ +static struct sntp_time sntp_last_timestamp_sent; +#endif /* SNTP_CHECK_RESPONSE >= 2 */ + +#if defined(LWIP_DEBUG) && !defined(sntp_format_time) +/* Debug print helper. */ +static const char * +sntp_format_time(s32_t sec) +{ + time_t ut; + ut = (u32_t)((u32_t)sec + DIFF_SEC_1970_2036); + return ctime(&ut); +} +#endif /* LWIP_DEBUG && !sntp_format_time */ + +/** + * SNTP processing of received timestamp + */ +static void +sntp_process(const struct sntp_timestamps *timestamps) +{ + s32_t sec; + u32_t frac; + + sec = (s32_t)lwip_ntohl(timestamps->xmit.sec); + frac = lwip_ntohl(timestamps->xmit.frac); + +#if SNTP_COMP_ROUNDTRIP +# if SNTP_CHECK_RESPONSE >= 2 + if (timestamps->recv.sec != 0 || timestamps->recv.frac != 0) +# endif + { + s32_t dest_sec; + u32_t dest_frac; + u32_t step_sec; + + /* Get the destination time stamp, i.e. the current system time */ + SNTP_GET_SYSTEM_TIME_NTP(dest_sec, dest_frac); + + step_sec = (dest_sec < sec) ? ((u32_t)sec - (u32_t)dest_sec) + : ((u32_t)dest_sec - (u32_t)sec); + /* In order to avoid overflows, skip the compensation if the clock step + * is larger than about 34 years. */ + if ((step_sec >> 30) == 0) { + s64_t t1, t2, t3, t4; + + t4 = SNTP_SEC_FRAC_TO_S64(dest_sec, dest_frac); + t3 = SNTP_SEC_FRAC_TO_S64(sec, frac); + t1 = SNTP_TIMESTAMP_TO_S64(timestamps->orig); + t2 = SNTP_TIMESTAMP_TO_S64(timestamps->recv); + /* Clock offset calculation according to RFC 4330 */ + t4 += ((t2 - t1) + (t3 - t4)) / 2; + + sec = (s32_t)((u64_t)t4 >> 32); + frac = (u32_t)((u64_t)t4); + } + } +#endif /* SNTP_COMP_ROUNDTRIP */ + + SNTP_SET_SYSTEM_TIME_NTP(sec, frac); + LWIP_UNUSED_ARG(frac); /* might be unused if only seconds are set */ + LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp_process: %s, %" U32_F " us\n", + sntp_format_time(sec), SNTP_FRAC_TO_US(frac))); +} + +/** + * Initialize request struct to be sent to server. + */ +static void +sntp_initialize_request(struct sntp_msg *req) +{ + memset(req, 0, SNTP_MSG_LEN); + req->li_vn_mode = SNTP_LI_NO_WARNING | SNTP_VERSION | SNTP_MODE_CLIENT; + +#if SNTP_CHECK_RESPONSE >= 2 || SNTP_COMP_ROUNDTRIP + { + s32_t secs; + u32_t sec, frac; + /* Get the transmit timestamp */ + SNTP_GET_SYSTEM_TIME_NTP(secs, frac); + sec = lwip_htonl((u32_t)secs); + frac = lwip_htonl(frac); + +# if SNTP_CHECK_RESPONSE >= 2 + sntp_last_timestamp_sent.sec = sec; + sntp_last_timestamp_sent.frac = frac; +# endif + req->transmit_timestamp[0] = sec; + req->transmit_timestamp[1] = frac; + } +#endif /* SNTP_CHECK_RESPONSE >= 2 || SNTP_COMP_ROUNDTRIP */ +} + +/** + * Retry: send a new request (and increase retry timeout). + * + * @param arg is unused (only necessary to conform to sys_timeout) + */ +static void +sntp_retry(void *arg) +{ + LWIP_UNUSED_ARG(arg); + + LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_retry: Next request will be sent in %"U32_F" ms\n", + sntp_retry_timeout)); + + /* set up a timer to send a retry and increase the retry delay */ + sys_timeout(sntp_retry_timeout, sntp_request, NULL); + +#if SNTP_RETRY_TIMEOUT_EXP + { + u32_t new_retry_timeout; + /* increase the timeout for next retry */ + new_retry_timeout = sntp_retry_timeout << 1; + /* limit to maximum timeout and prevent overflow */ + if ((new_retry_timeout <= SNTP_RETRY_TIMEOUT_MAX) && + (new_retry_timeout > sntp_retry_timeout)) { + sntp_retry_timeout = new_retry_timeout; + } + } +#endif /* SNTP_RETRY_TIMEOUT_EXP */ +} + +#if SNTP_SUPPORT_MULTIPLE_SERVERS +/** + * If Kiss-of-Death is received (or another packet parsing error), + * try the next server or retry the current server and increase the retry + * timeout if only one server is available. + * (implicitly, SNTP_MAX_SERVERS > 1) + * + * @param arg is unused (only necessary to conform to sys_timeout) + */ +static void +sntp_try_next_server(void *arg) +{ + u8_t old_server, i; + LWIP_UNUSED_ARG(arg); + + old_server = sntp_current_server; + for (i = 0; i < SNTP_MAX_SERVERS - 1; i++) { + sntp_current_server++; + if (sntp_current_server >= SNTP_MAX_SERVERS) { + sntp_current_server = 0; + } + if (!ip_addr_isany(&sntp_servers[sntp_current_server].addr) +#if SNTP_SERVER_DNS + || (sntp_servers[sntp_current_server].name != NULL) +#endif + ) { + LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_try_next_server: Sending request to server %"U16_F"\n", + (u16_t)sntp_current_server)); + /* new server: reset retry timeout */ + SNTP_RESET_RETRY_TIMEOUT(); + /* instantly send a request to the next server */ + sntp_request(NULL); + return; + } + } + /* no other valid server found */ + sntp_current_server = old_server; + sntp_retry(NULL); +} +#else /* SNTP_SUPPORT_MULTIPLE_SERVERS */ +/* Always retry on error if only one server is supported */ +#define sntp_try_next_server sntp_retry +#endif /* SNTP_SUPPORT_MULTIPLE_SERVERS */ + +/** UDP recv callback for the sntp pcb */ +static void +sntp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + struct sntp_timestamps timestamps; + u8_t mode; + u8_t stratum; + err_t err; + + LWIP_UNUSED_ARG(arg); + LWIP_UNUSED_ARG(pcb); + + err = ERR_ARG; +#if SNTP_CHECK_RESPONSE >= 1 + /* check server address and port */ + if (((sntp_opmode != SNTP_OPMODE_POLL) || ip_addr_cmp(addr, &sntp_last_server_address)) && + (port == SNTP_PORT)) +#else /* SNTP_CHECK_RESPONSE >= 1 */ + LWIP_UNUSED_ARG(addr); + LWIP_UNUSED_ARG(port); +#endif /* SNTP_CHECK_RESPONSE >= 1 */ + { + /* process the response */ + if (p->tot_len == SNTP_MSG_LEN) { + mode = pbuf_get_at(p, SNTP_OFFSET_LI_VN_MODE) & SNTP_MODE_MASK; + /* if this is a SNTP response... */ + if (((sntp_opmode == SNTP_OPMODE_POLL) && (mode == SNTP_MODE_SERVER)) || + ((sntp_opmode == SNTP_OPMODE_LISTENONLY) && (mode == SNTP_MODE_BROADCAST))) { + stratum = pbuf_get_at(p, SNTP_OFFSET_STRATUM); + + if (stratum == SNTP_STRATUM_KOD) { + /* Kiss-of-death packet. Use another server or increase UPDATE_DELAY. */ + err = SNTP_ERR_KOD; + LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_recv: Received Kiss-of-Death\n")); + } else { + pbuf_copy_partial(p, ×tamps, sizeof(timestamps), SNTP_OFFSET_TIMESTAMPS); +#if SNTP_CHECK_RESPONSE >= 2 + /* check originate_timetamp against sntp_last_timestamp_sent */ + if (timestamps.orig.sec != sntp_last_timestamp_sent.sec || + timestamps.orig.frac != sntp_last_timestamp_sent.frac) { + LWIP_DEBUGF(SNTP_DEBUG_WARN, + ("sntp_recv: Invalid originate timestamp in response\n")); + } else +#endif /* SNTP_CHECK_RESPONSE >= 2 */ + /* @todo: add code for SNTP_CHECK_RESPONSE >= 3 and >= 4 here */ + { + /* correct answer */ + err = ERR_OK; + } + } + } else { + LWIP_DEBUGF(SNTP_DEBUG_WARN, ("sntp_recv: Invalid mode in response: %"U16_F"\n", (u16_t)mode)); + /* wait for correct response */ + err = ERR_TIMEOUT; + } + } else { + LWIP_DEBUGF(SNTP_DEBUG_WARN, ("sntp_recv: Invalid packet length: %"U16_F"\n", p->tot_len)); + } + } +#if SNTP_CHECK_RESPONSE >= 1 + else { + /* packet from wrong remote address or port, wait for correct response */ + err = ERR_TIMEOUT; + } +#endif /* SNTP_CHECK_RESPONSE >= 1 */ + + pbuf_free(p); + + if (err == ERR_OK) { + /* correct packet received: process it it */ + sntp_process(×tamps); + +#if SNTP_MONITOR_SERVER_REACHABILITY + /* indicate that server responded */ + sntp_servers[sntp_current_server].reachability |= 1; +#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ + /* Set up timeout for next request (only if poll response was received)*/ + if (sntp_opmode == SNTP_OPMODE_POLL) { + u32_t sntp_update_delay; + sys_untimeout(sntp_try_next_server, NULL); + sys_untimeout(sntp_request, NULL); + + /* Correct response, reset retry timeout */ + SNTP_RESET_RETRY_TIMEOUT(); + + sntp_update_delay = (u32_t)SNTP_UPDATE_DELAY; + sys_timeout(sntp_update_delay, sntp_request, NULL); + LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_recv: Scheduled next time request: %"U32_F" ms\n", + sntp_update_delay)); + } + } else if (err == SNTP_ERR_KOD) { + /* KOD errors are only processed in case of an explicit poll response */ + if (sntp_opmode == SNTP_OPMODE_POLL) { + /* Kiss-of-death packet. Use another server or increase UPDATE_DELAY. */ + sntp_try_next_server(NULL); + } + } else { + /* ignore any broken packet, poll mode: retry after timeout to avoid flooding */ + } +} + +/** Actually send an sntp request to a server. + * + * @param server_addr resolved IP address of the SNTP server + */ +static void +sntp_send_request(const ip_addr_t *server_addr) +{ + struct pbuf *p; + + LWIP_ASSERT("server_addr != NULL", server_addr != NULL); + + p = pbuf_alloc(PBUF_TRANSPORT, SNTP_MSG_LEN, PBUF_RAM); + if (p != NULL) { + struct sntp_msg *sntpmsg = (struct sntp_msg *)p->payload; + LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_send_request: Sending request to server\n")); + /* initialize request message */ + sntp_initialize_request(sntpmsg); + /* send request */ + udp_sendto(sntp_pcb, p, server_addr, SNTP_PORT); + /* free the pbuf after sending it */ + pbuf_free(p); +#if SNTP_MONITOR_SERVER_REACHABILITY + /* indicate new packet has been sent */ + sntp_servers[sntp_current_server].reachability <<= 1; +#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ + /* set up receive timeout: try next server or retry on timeout */ + sys_timeout((u32_t)SNTP_RECV_TIMEOUT, sntp_try_next_server, NULL); +#if SNTP_CHECK_RESPONSE >= 1 + /* save server address to verify it in sntp_recv */ + ip_addr_copy(sntp_last_server_address, *server_addr); +#endif /* SNTP_CHECK_RESPONSE >= 1 */ + } else { + LWIP_DEBUGF(SNTP_DEBUG_SERIOUS, ("sntp_send_request: Out of memory, trying again in %"U32_F" ms\n", + (u32_t)SNTP_RETRY_TIMEOUT)); + /* out of memory: set up a timer to send a retry */ + sys_timeout((u32_t)SNTP_RETRY_TIMEOUT, sntp_request, NULL); + } +} + +#if SNTP_SERVER_DNS +/** + * DNS found callback when using DNS names as server address. + */ +static void +sntp_dns_found(const char *hostname, const ip_addr_t *ipaddr, void *arg) +{ + LWIP_UNUSED_ARG(hostname); + LWIP_UNUSED_ARG(arg); + + if (ipaddr != NULL) { + /* Address resolved, send request */ + LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_dns_found: Server address resolved, sending request\n")); + sntp_servers[sntp_current_server].addr = *ipaddr; + sntp_send_request(ipaddr); + } else { + /* DNS resolving failed -> try another server */ + LWIP_DEBUGF(SNTP_DEBUG_WARN_STATE, ("sntp_dns_found: Failed to resolve server address resolved, trying next server\n")); + sntp_try_next_server(NULL); + } +} +#endif /* SNTP_SERVER_DNS */ + +/** + * Send out an sntp request. + * + * @param arg is unused (only necessary to conform to sys_timeout) + */ +static void +sntp_request(void *arg) +{ + ip_addr_t sntp_server_address; + err_t err; + + LWIP_UNUSED_ARG(arg); + + /* initialize SNTP server address */ +#if SNTP_SERVER_DNS + if (sntp_servers[sntp_current_server].name) { + /* always resolve the name and rely on dns-internal caching & timeout */ + ip_addr_set_zero(&sntp_servers[sntp_current_server].addr); + err = dns_gethostbyname(sntp_servers[sntp_current_server].name, &sntp_server_address, + sntp_dns_found, NULL); + if (err == ERR_INPROGRESS) { + /* DNS request sent, wait for sntp_dns_found being called */ + LWIP_DEBUGF(SNTP_DEBUG_STATE, ("sntp_request: Waiting for server address to be resolved.\n")); + return; + } else if (err == ERR_OK) { + sntp_servers[sntp_current_server].addr = sntp_server_address; + } + } else +#endif /* SNTP_SERVER_DNS */ + { + sntp_server_address = sntp_servers[sntp_current_server].addr; + err = (ip_addr_isany_val(sntp_server_address)) ? ERR_ARG : ERR_OK; + } + + if (err == ERR_OK) { + LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp_request: current server address is %s\n", + ipaddr_ntoa(&sntp_server_address))); + sntp_send_request(&sntp_server_address); + } else { + /* address conversion failed, try another server */ + LWIP_DEBUGF(SNTP_DEBUG_WARN_STATE, ("sntp_request: Invalid server address, trying next server.\n")); + sys_timeout((u32_t)SNTP_RETRY_TIMEOUT, sntp_try_next_server, NULL); + } +} + +/** + * @ingroup sntp + * Initialize this module. + * Send out request instantly or after SNTP_STARTUP_DELAY(_FUNC). + */ +void +sntp_init(void) +{ + /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ + +#ifdef SNTP_SERVER_ADDRESS +#if SNTP_SERVER_DNS + sntp_setservername(0, SNTP_SERVER_ADDRESS); +#else +#error SNTP_SERVER_ADDRESS string not supported SNTP_SERVER_DNS==0 +#endif +#endif /* SNTP_SERVER_ADDRESS */ + + if (sntp_pcb == NULL) { + sntp_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + LWIP_ASSERT("Failed to allocate udp pcb for sntp client", sntp_pcb != NULL); + if (sntp_pcb != NULL) { + udp_recv(sntp_pcb, sntp_recv, NULL); + + if (sntp_opmode == SNTP_OPMODE_POLL) { + SNTP_RESET_RETRY_TIMEOUT(); +#if SNTP_STARTUP_DELAY + sys_timeout((u32_t)SNTP_STARTUP_DELAY_FUNC, sntp_request, NULL); +#else + sntp_request(NULL); +#endif + } else if (sntp_opmode == SNTP_OPMODE_LISTENONLY) { + ip_set_option(sntp_pcb, SOF_BROADCAST); + udp_bind(sntp_pcb, IP_ANY_TYPE, SNTP_PORT); + } + } + } +} + +/** + * @ingroup sntp + * Stop this module. + */ +void +sntp_stop(void) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (sntp_pcb != NULL) { +#if SNTP_MONITOR_SERVER_REACHABILITY + u8_t i; + for (i = 0; i < SNTP_MAX_SERVERS; i++) { + sntp_servers[i].reachability = 0; + } +#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ + sys_untimeout(sntp_request, NULL); + sys_untimeout(sntp_try_next_server, NULL); + udp_remove(sntp_pcb); + sntp_pcb = NULL; + } +} + +/** + * @ingroup sntp + * Get enabled state. + */ +u8_t sntp_enabled(void) +{ + return (sntp_pcb != NULL) ? 1 : 0; +} + +/** + * @ingroup sntp + * Sets the operating mode. + * @param operating_mode one of the available operating modes + */ +void +sntp_setoperatingmode(u8_t operating_mode) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("Invalid operating mode", operating_mode <= SNTP_OPMODE_LISTENONLY); + LWIP_ASSERT("Operating mode must not be set while SNTP client is running", sntp_pcb == NULL); + sntp_opmode = operating_mode; +} + +/** + * @ingroup sntp + * Gets the operating mode. + */ +u8_t +sntp_getoperatingmode(void) +{ + return sntp_opmode; +} + +#if SNTP_MONITOR_SERVER_REACHABILITY +/** + * @ingroup sntp + * Gets the server reachability shift register as described in RFC 5905. + * + * @param idx the index of the NTP server + */ +u8_t +sntp_getreachability(u8_t idx) +{ + if (idx < SNTP_MAX_SERVERS) { + return sntp_servers[idx].reachability; + } + return 0; +} +#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ + +#if SNTP_GET_SERVERS_FROM_DHCP +/** + * Config SNTP server handling by IP address, name, or DHCP; clear table + * @param set_servers_from_dhcp enable or disable getting server addresses from dhcp + */ +void +sntp_servermode_dhcp(int set_servers_from_dhcp) +{ + u8_t new_mode = set_servers_from_dhcp ? 1 : 0; + LWIP_ASSERT_CORE_LOCKED(); + if (sntp_set_servers_from_dhcp != new_mode) { + sntp_set_servers_from_dhcp = new_mode; + } +} +#endif /* SNTP_GET_SERVERS_FROM_DHCP */ + +/** + * @ingroup sntp + * Initialize one of the NTP servers by IP address + * + * @param idx the index of the NTP server to set must be < SNTP_MAX_SERVERS + * @param server IP address of the NTP server to set + */ +void +sntp_setserver(u8_t idx, const ip_addr_t *server) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (idx < SNTP_MAX_SERVERS) { + if (server != NULL) { + sntp_servers[idx].addr = (*server); + } else { + ip_addr_set_zero(&sntp_servers[idx].addr); + } +#if SNTP_SERVER_DNS + sntp_servers[idx].name = NULL; +#endif + } +} + +#if LWIP_DHCP && SNTP_GET_SERVERS_FROM_DHCP +/** + * Initialize one of the NTP servers by IP address, required by DHCP + * + * @param num the index of the NTP server to set must be < SNTP_MAX_SERVERS + * @param server IP address of the NTP server to set + */ +void +dhcp_set_ntp_servers(u8_t num, const ip4_addr_t *server) +{ + LWIP_DEBUGF(SNTP_DEBUG_TRACE, ("sntp: %s %u.%u.%u.%u as NTP server #%u via DHCP\n", + (sntp_set_servers_from_dhcp ? "Got" : "Rejected"), + ip4_addr1(server), ip4_addr2(server), ip4_addr3(server), ip4_addr4(server), num)); + if (sntp_set_servers_from_dhcp && num) { + u8_t i; + for (i = 0; (i < num) && (i < SNTP_MAX_SERVERS); i++) { + ip_addr_t addr; + ip_addr_copy_from_ip4(addr, server[i]); + sntp_setserver(i, &addr); + } + for (i = num; i < SNTP_MAX_SERVERS; i++) { + sntp_setserver(i, NULL); + } + } +} +#endif /* LWIP_DHCP && SNTP_GET_SERVERS_FROM_DHCP */ + +/** + * @ingroup sntp + * Obtain one of the currently configured by IP address (or DHCP) NTP servers + * + * @param idx the index of the NTP server + * @return IP address of the indexed NTP server or "ip_addr_any" if the NTP + * server has not been configured by address (or at all). + */ +const ip_addr_t * +sntp_getserver(u8_t idx) +{ + if (idx < SNTP_MAX_SERVERS) { + return &sntp_servers[idx].addr; + } + return IP_ADDR_ANY; +} + +#if SNTP_SERVER_DNS +/** + * Initialize one of the NTP servers by name + * + * @param idx the index of the NTP server to set must be < SNTP_MAX_SERVERS + * @param server DNS name of the NTP server to set, to be resolved at contact time + */ +void +sntp_setservername(u8_t idx, const char *server) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (idx < SNTP_MAX_SERVERS) { + sntp_servers[idx].name = server; + } +} + +/** + * Obtain one of the currently configured by name NTP servers. + * + * @param idx the index of the NTP server + * @return IP address of the indexed NTP server or NULL if the NTP + * server has not been configured by name (or at all) + */ +const char * +sntp_getservername(u8_t idx) +{ + if (idx < SNTP_MAX_SERVERS) { + return sntp_servers[idx].name; + } + return NULL; +} +#endif /* SNTP_SERVER_DNS */ + +#endif /* LWIP_UDP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/tftp/tftp_server.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/tftp/tftp_server.c index d6c75b4e..e3f15124 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/tftp/tftp_server.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/apps/tftp/tftp_server.c @@ -1,435 +1,435 @@ -/** - * - * @file tftp_server.c - * - * @author Logan Gunthorpe - * Dirk Ziegelmeier - * - * @brief Trivial File Transfer Protocol (RFC 1350) - * - * Copyright (c) Deltatee Enterprises Ltd. 2013 - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Logan Gunthorpe - * Dirk Ziegelmeier - * - */ - -/** - * @defgroup tftp TFTP server - * @ingroup apps - * - * This is simple TFTP server for the lwIP raw API. - */ - -#include "lwip/apps/tftp_server.h" - -#if LWIP_UDP - -#include "lwip/udp.h" -#include "lwip/timeouts.h" -#include "lwip/debug.h" - -#define TFTP_MAX_PAYLOAD_SIZE 512 -#define TFTP_HEADER_LENGTH 4 - -#define TFTP_RRQ 1 -#define TFTP_WRQ 2 -#define TFTP_DATA 3 -#define TFTP_ACK 4 -#define TFTP_ERROR 5 - -enum tftp_error { - TFTP_ERROR_FILE_NOT_FOUND = 1, - TFTP_ERROR_ACCESS_VIOLATION = 2, - TFTP_ERROR_DISK_FULL = 3, - TFTP_ERROR_ILLEGAL_OPERATION = 4, - TFTP_ERROR_UNKNOWN_TRFR_ID = 5, - TFTP_ERROR_FILE_EXISTS = 6, - TFTP_ERROR_NO_SUCH_USER = 7 -}; - -#include - -struct tftp_state { - const struct tftp_context *ctx; - void *handle; - struct pbuf *last_data; - struct udp_pcb *upcb; - ip_addr_t addr; - u16_t port; - int timer; - int last_pkt; - u16_t blknum; - u8_t retries; - u8_t mode_write; -}; - -static struct tftp_state tftp_state; - -static void tftp_tmr(void *arg); - -static void -close_handle(void) -{ - tftp_state.port = 0; - ip_addr_set_any(0, &tftp_state.addr); - - if (tftp_state.last_data != NULL) { - pbuf_free(tftp_state.last_data); - tftp_state.last_data = NULL; - } - - sys_untimeout(tftp_tmr, NULL); - - if (tftp_state.handle) { - tftp_state.ctx->close(tftp_state.handle); - tftp_state.handle = NULL; - LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: closing\n")); - } -} - -static void -send_error(const ip_addr_t *addr, u16_t port, enum tftp_error code, const char *str) -{ - int str_length = strlen(str); - struct pbuf *p; - u16_t *payload; - - p = pbuf_alloc(PBUF_TRANSPORT, (u16_t)(TFTP_HEADER_LENGTH + str_length + 1), PBUF_RAM); - if (p == NULL) { - return; - } - - payload = (u16_t *) p->payload; - payload[0] = PP_HTONS(TFTP_ERROR); - payload[1] = lwip_htons(code); - MEMCPY(&payload[2], str, str_length + 1); - - udp_sendto(tftp_state.upcb, p, addr, port); - pbuf_free(p); -} - -static void -send_ack(u16_t blknum) -{ - struct pbuf *p; - u16_t *payload; - - p = pbuf_alloc(PBUF_TRANSPORT, TFTP_HEADER_LENGTH, PBUF_RAM); - if (p == NULL) { - return; - } - payload = (u16_t *) p->payload; - - payload[0] = PP_HTONS(TFTP_ACK); - payload[1] = lwip_htons(blknum); - udp_sendto(tftp_state.upcb, p, &tftp_state.addr, tftp_state.port); - pbuf_free(p); -} - -static void -resend_data(void) -{ - struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, tftp_state.last_data->len, PBUF_RAM); - if (p == NULL) { - return; - } - - if (pbuf_copy(p, tftp_state.last_data) != ERR_OK) { - pbuf_free(p); - return; - } - - udp_sendto(tftp_state.upcb, p, &tftp_state.addr, tftp_state.port); - pbuf_free(p); -} - -static void -send_data(void) -{ - u16_t *payload; - int ret; - - if (tftp_state.last_data != NULL) { - pbuf_free(tftp_state.last_data); - } - - tftp_state.last_data = pbuf_alloc(PBUF_TRANSPORT, TFTP_HEADER_LENGTH + TFTP_MAX_PAYLOAD_SIZE, PBUF_RAM); - if (tftp_state.last_data == NULL) { - return; - } - - payload = (u16_t *) tftp_state.last_data->payload; - payload[0] = PP_HTONS(TFTP_DATA); - payload[1] = lwip_htons(tftp_state.blknum); - - ret = tftp_state.ctx->read(tftp_state.handle, &payload[2], TFTP_MAX_PAYLOAD_SIZE); - if (ret < 0) { - send_error(&tftp_state.addr, tftp_state.port, TFTP_ERROR_ACCESS_VIOLATION, "Error occured while reading the file."); - close_handle(); - return; - } - - pbuf_realloc(tftp_state.last_data, (u16_t)(TFTP_HEADER_LENGTH + ret)); - resend_data(); -} - -static void -recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - u16_t *sbuf = (u16_t *) p->payload; - int opcode; - - LWIP_UNUSED_ARG(arg); - LWIP_UNUSED_ARG(upcb); - - if (((tftp_state.port != 0) && (port != tftp_state.port)) || - (!ip_addr_isany_val(tftp_state.addr) && !ip_addr_cmp(&tftp_state.addr, addr))) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Only one connection at a time is supported"); - pbuf_free(p); - return; - } - - opcode = sbuf[0]; - - tftp_state.last_pkt = tftp_state.timer; - tftp_state.retries = 0; - - switch (opcode) { - case PP_HTONS(TFTP_RRQ): /* fall through */ - case PP_HTONS(TFTP_WRQ): { - const char tftp_null = 0; - char filename[TFTP_MAX_FILENAME_LEN + 1]; - char mode[TFTP_MAX_MODE_LEN + 1]; - u16_t filename_end_offset; - u16_t mode_end_offset; - - if (tftp_state.handle != NULL) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Only one connection at a time is supported"); - break; - } - - sys_timeout(TFTP_TIMER_MSECS, tftp_tmr, NULL); - - /* find \0 in pbuf -> end of filename string */ - filename_end_offset = pbuf_memfind(p, &tftp_null, sizeof(tftp_null), 2); - if ((u16_t)(filename_end_offset - 1) > sizeof(filename)) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Filename too long/not NULL terminated"); - break; - } - pbuf_copy_partial(p, filename, filename_end_offset - 1, 2); - - /* find \0 in pbuf -> end of mode string */ - mode_end_offset = pbuf_memfind(p, &tftp_null, sizeof(tftp_null), filename_end_offset + 1); - if ((u16_t)(mode_end_offset - filename_end_offset) > sizeof(mode)) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Mode too long/not NULL terminated"); - break; - } - pbuf_copy_partial(p, mode, mode_end_offset - filename_end_offset, filename_end_offset + 1); - - tftp_state.handle = tftp_state.ctx->open(filename, mode, opcode == PP_HTONS(TFTP_WRQ)); - tftp_state.blknum = 1; - - if (!tftp_state.handle) { - send_error(addr, port, TFTP_ERROR_FILE_NOT_FOUND, "Unable to open requested file."); - break; - } - - LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: %s request from ", (opcode == PP_HTONS(TFTP_WRQ)) ? "write" : "read")); - ip_addr_debug_print(TFTP_DEBUG | LWIP_DBG_STATE, addr); - LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, (" for '%s' mode '%s'\n", filename, mode)); - - ip_addr_copy(tftp_state.addr, *addr); - tftp_state.port = port; - - if (opcode == PP_HTONS(TFTP_WRQ)) { - tftp_state.mode_write = 1; - send_ack(0); - } else { - tftp_state.mode_write = 0; - send_data(); - } - - break; - } - - case PP_HTONS(TFTP_DATA): { - int ret; - u16_t blknum; - - if (tftp_state.handle == NULL) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "No connection"); - break; - } - - if (tftp_state.mode_write != 1) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Not a write connection"); - break; - } - - blknum = lwip_ntohs(sbuf[1]); - if (blknum == tftp_state.blknum) { - pbuf_remove_header(p, TFTP_HEADER_LENGTH); - - ret = tftp_state.ctx->write(tftp_state.handle, p); - if (ret < 0) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "error writing file"); - close_handle(); - } else { - send_ack(blknum); - } - - if (p->tot_len < TFTP_MAX_PAYLOAD_SIZE) { - close_handle(); - } else { - tftp_state.blknum++; - } - } else if ((u16_t)(blknum + 1) == tftp_state.blknum) { - /* retransmit of previous block, ack again (casting to u16_t to care for overflow) */ - send_ack(blknum); - } else { - send_error(addr, port, TFTP_ERROR_UNKNOWN_TRFR_ID, "Wrong block number"); - } - break; - } - - case PP_HTONS(TFTP_ACK): { - u16_t blknum; - int lastpkt; - - if (tftp_state.handle == NULL) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "No connection"); - break; - } - - if (tftp_state.mode_write != 0) { - send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Not a read connection"); - break; - } - - blknum = lwip_ntohs(sbuf[1]); - if (blknum != tftp_state.blknum) { - send_error(addr, port, TFTP_ERROR_UNKNOWN_TRFR_ID, "Wrong block number"); - break; - } - - lastpkt = 0; - - if (tftp_state.last_data != NULL) { - lastpkt = tftp_state.last_data->tot_len != (TFTP_MAX_PAYLOAD_SIZE + TFTP_HEADER_LENGTH); - } - - if (!lastpkt) { - tftp_state.blknum++; - send_data(); - } else { - close_handle(); - } - - break; - } - - default: - send_error(addr, port, TFTP_ERROR_ILLEGAL_OPERATION, "Unknown operation"); - break; - } - - pbuf_free(p); -} - -static void -tftp_tmr(void *arg) -{ - LWIP_UNUSED_ARG(arg); - - tftp_state.timer++; - - if (tftp_state.handle == NULL) { - return; - } - - sys_timeout(TFTP_TIMER_MSECS, tftp_tmr, NULL); - - if ((tftp_state.timer - tftp_state.last_pkt) > (TFTP_TIMEOUT_MSECS / TFTP_TIMER_MSECS)) { - if ((tftp_state.last_data != NULL) && (tftp_state.retries < TFTP_MAX_RETRIES)) { - LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: timeout, retrying\n")); - resend_data(); - tftp_state.retries++; - } else { - LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: timeout\n")); - close_handle(); - } - } -} - -/** @ingroup tftp - * Initialize TFTP server. - * @param ctx TFTP callback struct - */ -err_t -tftp_init(const struct tftp_context *ctx) -{ - err_t ret; - - /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ - struct udp_pcb *pcb = udp_new_ip_type(IPADDR_TYPE_ANY); - if (pcb == NULL) { - return ERR_MEM; - } - - ret = udp_bind(pcb, IP_ANY_TYPE, TFTP_PORT); - if (ret != ERR_OK) { - udp_remove(pcb); - return ret; - } - - tftp_state.handle = NULL; - tftp_state.port = 0; - tftp_state.ctx = ctx; - tftp_state.timer = 0; - tftp_state.last_data = NULL; - tftp_state.upcb = pcb; - - udp_recv(pcb, recv, NULL); - - return ERR_OK; -} - -/** @ingroup tftp - * Deinitialize ("turn off") TFTP server. - */ -void tftp_cleanup(void) -{ - LWIP_ASSERT("Cleanup called on non-initialized TFTP", tftp_state.upcb != NULL); - udp_remove(tftp_state.upcb); - close_handle(); - memset(&tftp_state, 0, sizeof(tftp_state)); -} - -#endif /* LWIP_UDP */ +/** + * + * @file tftp_server.c + * + * @author Logan Gunthorpe + * Dirk Ziegelmeier + * + * @brief Trivial File Transfer Protocol (RFC 1350) + * + * Copyright (c) Deltatee Enterprises Ltd. 2013 + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Logan Gunthorpe + * Dirk Ziegelmeier + * + */ + +/** + * @defgroup tftp TFTP server + * @ingroup apps + * + * This is simple TFTP server for the lwIP raw API. + */ + +#include "lwip/apps/tftp_server.h" + +#if LWIP_UDP + +#include "lwip/udp.h" +#include "lwip/timeouts.h" +#include "lwip/debug.h" + +#define TFTP_MAX_PAYLOAD_SIZE 512 +#define TFTP_HEADER_LENGTH 4 + +#define TFTP_RRQ 1 +#define TFTP_WRQ 2 +#define TFTP_DATA 3 +#define TFTP_ACK 4 +#define TFTP_ERROR 5 + +enum tftp_error { + TFTP_ERROR_FILE_NOT_FOUND = 1, + TFTP_ERROR_ACCESS_VIOLATION = 2, + TFTP_ERROR_DISK_FULL = 3, + TFTP_ERROR_ILLEGAL_OPERATION = 4, + TFTP_ERROR_UNKNOWN_TRFR_ID = 5, + TFTP_ERROR_FILE_EXISTS = 6, + TFTP_ERROR_NO_SUCH_USER = 7 +}; + +#include + +struct tftp_state { + const struct tftp_context *ctx; + void *handle; + struct pbuf *last_data; + struct udp_pcb *upcb; + ip_addr_t addr; + u16_t port; + int timer; + int last_pkt; + u16_t blknum; + u8_t retries; + u8_t mode_write; +}; + +static struct tftp_state tftp_state; + +static void tftp_tmr(void *arg); + +static void +close_handle(void) +{ + tftp_state.port = 0; + ip_addr_set_any(0, &tftp_state.addr); + + if (tftp_state.last_data != NULL) { + pbuf_free(tftp_state.last_data); + tftp_state.last_data = NULL; + } + + sys_untimeout(tftp_tmr, NULL); + + if (tftp_state.handle) { + tftp_state.ctx->close(tftp_state.handle); + tftp_state.handle = NULL; + LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: closing\n")); + } +} + +static void +send_error(const ip_addr_t *addr, u16_t port, enum tftp_error code, const char *str) +{ + int str_length = strlen(str); + struct pbuf *p; + u16_t *payload; + + p = pbuf_alloc(PBUF_TRANSPORT, (u16_t)(TFTP_HEADER_LENGTH + str_length + 1), PBUF_RAM); + if (p == NULL) { + return; + } + + payload = (u16_t *) p->payload; + payload[0] = PP_HTONS(TFTP_ERROR); + payload[1] = lwip_htons(code); + MEMCPY(&payload[2], str, str_length + 1); + + udp_sendto(tftp_state.upcb, p, addr, port); + pbuf_free(p); +} + +static void +send_ack(u16_t blknum) +{ + struct pbuf *p; + u16_t *payload; + + p = pbuf_alloc(PBUF_TRANSPORT, TFTP_HEADER_LENGTH, PBUF_RAM); + if (p == NULL) { + return; + } + payload = (u16_t *) p->payload; + + payload[0] = PP_HTONS(TFTP_ACK); + payload[1] = lwip_htons(blknum); + udp_sendto(tftp_state.upcb, p, &tftp_state.addr, tftp_state.port); + pbuf_free(p); +} + +static void +resend_data(void) +{ + struct pbuf *p = pbuf_alloc(PBUF_TRANSPORT, tftp_state.last_data->len, PBUF_RAM); + if (p == NULL) { + return; + } + + if (pbuf_copy(p, tftp_state.last_data) != ERR_OK) { + pbuf_free(p); + return; + } + + udp_sendto(tftp_state.upcb, p, &tftp_state.addr, tftp_state.port); + pbuf_free(p); +} + +static void +send_data(void) +{ + u16_t *payload; + int ret; + + if (tftp_state.last_data != NULL) { + pbuf_free(tftp_state.last_data); + } + + tftp_state.last_data = pbuf_alloc(PBUF_TRANSPORT, TFTP_HEADER_LENGTH + TFTP_MAX_PAYLOAD_SIZE, PBUF_RAM); + if (tftp_state.last_data == NULL) { + return; + } + + payload = (u16_t *) tftp_state.last_data->payload; + payload[0] = PP_HTONS(TFTP_DATA); + payload[1] = lwip_htons(tftp_state.blknum); + + ret = tftp_state.ctx->read(tftp_state.handle, &payload[2], TFTP_MAX_PAYLOAD_SIZE); + if (ret < 0) { + send_error(&tftp_state.addr, tftp_state.port, TFTP_ERROR_ACCESS_VIOLATION, "Error occured while reading the file."); + close_handle(); + return; + } + + pbuf_realloc(tftp_state.last_data, (u16_t)(TFTP_HEADER_LENGTH + ret)); + resend_data(); +} + +static void +recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + u16_t *sbuf = (u16_t *) p->payload; + int opcode; + + LWIP_UNUSED_ARG(arg); + LWIP_UNUSED_ARG(upcb); + + if (((tftp_state.port != 0) && (port != tftp_state.port)) || + (!ip_addr_isany_val(tftp_state.addr) && !ip_addr_cmp(&tftp_state.addr, addr))) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Only one connection at a time is supported"); + pbuf_free(p); + return; + } + + opcode = sbuf[0]; + + tftp_state.last_pkt = tftp_state.timer; + tftp_state.retries = 0; + + switch (opcode) { + case PP_HTONS(TFTP_RRQ): /* fall through */ + case PP_HTONS(TFTP_WRQ): { + const char tftp_null = 0; + char filename[TFTP_MAX_FILENAME_LEN + 1]; + char mode[TFTP_MAX_MODE_LEN + 1]; + u16_t filename_end_offset; + u16_t mode_end_offset; + + if (tftp_state.handle != NULL) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Only one connection at a time is supported"); + break; + } + + sys_timeout(TFTP_TIMER_MSECS, tftp_tmr, NULL); + + /* find \0 in pbuf -> end of filename string */ + filename_end_offset = pbuf_memfind(p, &tftp_null, sizeof(tftp_null), 2); + if ((u16_t)(filename_end_offset - 1) > sizeof(filename)) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Filename too long/not NULL terminated"); + break; + } + pbuf_copy_partial(p, filename, filename_end_offset - 1, 2); + + /* find \0 in pbuf -> end of mode string */ + mode_end_offset = pbuf_memfind(p, &tftp_null, sizeof(tftp_null), filename_end_offset + 1); + if ((u16_t)(mode_end_offset - filename_end_offset) > sizeof(mode)) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Mode too long/not NULL terminated"); + break; + } + pbuf_copy_partial(p, mode, mode_end_offset - filename_end_offset, filename_end_offset + 1); + + tftp_state.handle = tftp_state.ctx->open(filename, mode, opcode == PP_HTONS(TFTP_WRQ)); + tftp_state.blknum = 1; + + if (!tftp_state.handle) { + send_error(addr, port, TFTP_ERROR_FILE_NOT_FOUND, "Unable to open requested file."); + break; + } + + LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: %s request from ", (opcode == PP_HTONS(TFTP_WRQ)) ? "write" : "read")); + ip_addr_debug_print(TFTP_DEBUG | LWIP_DBG_STATE, addr); + LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, (" for '%s' mode '%s'\n", filename, mode)); + + ip_addr_copy(tftp_state.addr, *addr); + tftp_state.port = port; + + if (opcode == PP_HTONS(TFTP_WRQ)) { + tftp_state.mode_write = 1; + send_ack(0); + } else { + tftp_state.mode_write = 0; + send_data(); + } + + break; + } + + case PP_HTONS(TFTP_DATA): { + int ret; + u16_t blknum; + + if (tftp_state.handle == NULL) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "No connection"); + break; + } + + if (tftp_state.mode_write != 1) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Not a write connection"); + break; + } + + blknum = lwip_ntohs(sbuf[1]); + if (blknum == tftp_state.blknum) { + pbuf_remove_header(p, TFTP_HEADER_LENGTH); + + ret = tftp_state.ctx->write(tftp_state.handle, p); + if (ret < 0) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "error writing file"); + close_handle(); + } else { + send_ack(blknum); + } + + if (p->tot_len < TFTP_MAX_PAYLOAD_SIZE) { + close_handle(); + } else { + tftp_state.blknum++; + } + } else if ((u16_t)(blknum + 1) == tftp_state.blknum) { + /* retransmit of previous block, ack again (casting to u16_t to care for overflow) */ + send_ack(blknum); + } else { + send_error(addr, port, TFTP_ERROR_UNKNOWN_TRFR_ID, "Wrong block number"); + } + break; + } + + case PP_HTONS(TFTP_ACK): { + u16_t blknum; + int lastpkt; + + if (tftp_state.handle == NULL) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "No connection"); + break; + } + + if (tftp_state.mode_write != 0) { + send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Not a read connection"); + break; + } + + blknum = lwip_ntohs(sbuf[1]); + if (blknum != tftp_state.blknum) { + send_error(addr, port, TFTP_ERROR_UNKNOWN_TRFR_ID, "Wrong block number"); + break; + } + + lastpkt = 0; + + if (tftp_state.last_data != NULL) { + lastpkt = tftp_state.last_data->tot_len != (TFTP_MAX_PAYLOAD_SIZE + TFTP_HEADER_LENGTH); + } + + if (!lastpkt) { + tftp_state.blknum++; + send_data(); + } else { + close_handle(); + } + + break; + } + + default: + send_error(addr, port, TFTP_ERROR_ILLEGAL_OPERATION, "Unknown operation"); + break; + } + + pbuf_free(p); +} + +static void +tftp_tmr(void *arg) +{ + LWIP_UNUSED_ARG(arg); + + tftp_state.timer++; + + if (tftp_state.handle == NULL) { + return; + } + + sys_timeout(TFTP_TIMER_MSECS, tftp_tmr, NULL); + + if ((tftp_state.timer - tftp_state.last_pkt) > (TFTP_TIMEOUT_MSECS / TFTP_TIMER_MSECS)) { + if ((tftp_state.last_data != NULL) && (tftp_state.retries < TFTP_MAX_RETRIES)) { + LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: timeout, retrying\n")); + resend_data(); + tftp_state.retries++; + } else { + LWIP_DEBUGF(TFTP_DEBUG | LWIP_DBG_STATE, ("tftp: timeout\n")); + close_handle(); + } + } +} + +/** @ingroup tftp + * Initialize TFTP server. + * @param ctx TFTP callback struct + */ +err_t +tftp_init(const struct tftp_context *ctx) +{ + err_t ret; + + /* LWIP_ASSERT_CORE_LOCKED(); is checked by udp_new() */ + struct udp_pcb *pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + if (pcb == NULL) { + return ERR_MEM; + } + + ret = udp_bind(pcb, IP_ANY_TYPE, TFTP_PORT); + if (ret != ERR_OK) { + udp_remove(pcb); + return ret; + } + + tftp_state.handle = NULL; + tftp_state.port = 0; + tftp_state.ctx = ctx; + tftp_state.timer = 0; + tftp_state.last_data = NULL; + tftp_state.upcb = pcb; + + udp_recv(pcb, recv, NULL); + + return ERR_OK; +} + +/** @ingroup tftp + * Deinitialize ("turn off") TFTP server. + */ +void tftp_cleanup(void) +{ + LWIP_ASSERT("Cleanup called on non-initialized TFTP", tftp_state.upcb != NULL); + udp_remove(tftp_state.upcb); + close_handle(); + memset(&tftp_state, 0, sizeof(tftp_state)); +} + +#endif /* LWIP_UDP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/Makefile b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/Makefile index 1bff7aae..2fdda867 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/Makefile +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/Makefile @@ -1,5 +1,3 @@ -SRC_FILES += sys_arch.c \ - tcp_echo_socket_demo.c \ - udp_echo.c +SRC_FILES += sys_arch.c include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/cc.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/cc.h index 1a241967..46640e34 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/cc.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/cc.h @@ -1,96 +1,96 @@ -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef __CC_H__ -#define __CC_H__ - -#include "stdio.h" - -#include "main.h" - -//typedef unsigned char u8_t; -//typedef signed char s8_t; -//typedef unsigned short u16_t; -//typedef signed short s16_t; -//typedef unsigned long u32_t; -//typedef signed long s32_t; -//typedef u32_t mem_ptr_t; -//typedef int sys_prot_t; - - -#define U16_F "hu" -#define S16_F "d" -#define X16_F "hx" -#define U32_F "u" -#define S32_F "d" -#define X32_F "x" -#define SZT_F "uz" - - - - - -/* define compiler specific symbols */ -#if defined (__ICCARM__) - -#define PACK_STRUCT_BEGIN -#define PACK_STRUCT_STRUCT -#define PACK_STRUCT_END -#define PACK_STRUCT_FIELD(x) x -#define PACK_STRUCT_USE_INCLUDES - -#elif defined (__CC_ARM) - -#define PACK_STRUCT_BEGIN __packed -#define PACK_STRUCT_STRUCT -#define PACK_STRUCT_END -#define PACK_STRUCT_FIELD(x) x - -#elif defined (__GNUC__) - -#define PACK_STRUCT_BEGIN -#define PACK_STRUCT_STRUCT __attribute__ ((__packed__)) -#define PACK_STRUCT_END -#define PACK_STRUCT_FIELD(x) x - -#elif defined (__TASKING__) - -#define PACK_STRUCT_BEGIN -#define PACK_STRUCT_STRUCT -#define PACK_STRUCT_END -#define PACK_STRUCT_FIELD(x) x - -#endif - - -#define LWIP_PLATFORM_ASSERT(x) do {printf(x);}while(0) - -#endif /* __CC_H__ */ +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef __CC_H__ +#define __CC_H__ + +#include "stdio.h" + +#include "main.h" + +//typedef unsigned char u8_t; +//typedef signed char s8_t; +//typedef unsigned short u16_t; +//typedef signed short s16_t; +//typedef unsigned long u32_t; +//typedef signed long s32_t; +//typedef u32_t mem_ptr_t; +//typedef int sys_prot_t; + + +#define U16_F "hu" +#define S16_F "d" +#define X16_F "hx" +#define U32_F "u" +#define S32_F "d" +#define X32_F "x" +#define SZT_F "uz" + + + + + +/* define compiler specific symbols */ +#if defined (__ICCARM__) + +#define PACK_STRUCT_BEGIN +#define PACK_STRUCT_STRUCT +#define PACK_STRUCT_END +#define PACK_STRUCT_FIELD(x) x +#define PACK_STRUCT_USE_INCLUDES + +#elif defined (__CC_ARM) + +#define PACK_STRUCT_BEGIN __packed +#define PACK_STRUCT_STRUCT +#define PACK_STRUCT_END +#define PACK_STRUCT_FIELD(x) x + +#elif defined (__GNUC__) + +#define PACK_STRUCT_BEGIN +#define PACK_STRUCT_STRUCT __attribute__ ((__packed__)) +#define PACK_STRUCT_END +#define PACK_STRUCT_FIELD(x) x + +#elif defined (__TASKING__) + +#define PACK_STRUCT_BEGIN +#define PACK_STRUCT_STRUCT +#define PACK_STRUCT_END +#define PACK_STRUCT_FIELD(x) x + +#endif + + +#define LWIP_PLATFORM_ASSERT(x) do {printf(x);}while(0) + +#endif /* __CC_H__ */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/ethernetif.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/ethernetif.h deleted file mode 100644 index e4733e3a..00000000 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/ethernetif.h +++ /dev/null @@ -1,86 +0,0 @@ -/** - ****************************************************************************** - * File Name : ethernetif.h - * Description : This file provides initialization code for LWIP - * middleWare. - ****************************************************************************** - * This notice applies to any and all portions of this file - * that are not between comment pairs USER CODE BEGIN and - * USER CODE END. Other portions of this file, whether - * inserted by the user or by software development tools - * are owned by their respective copyright owners. - * - * Copyright (c) 2018 STMicroelectronics International N.V. - * 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. Redistribution 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 STMicroelectronics nor the names of other - * contributors to this software may be used to endorse or promote products - * derived from this software without specific written permission. - * 4. This software, including modifications and/or derivative works of this - * software, must execute solely and exclusively on microcontroller or - * microprocessor devices manufactured by or for STMicroelectronics. - * 5. Redistribution and use of this software other than as permitted under - * this license is void and will automatically terminate your rights under - * this license. - * - * THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS" - * AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A - * PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY - * RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT - * SHALL STMICROELECTRONICS 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 __ETHERNETIF_H__ -#define __ETHERNETIF_H__ - -#include "lwip/err.h" -#include "lwip/netif.h" - -/* Within 'USER CODE' section, code will be kept by default at each generation */ -/* USER CODE BEGIN 0 */ -#define NETIF_MTU ( 1500 ) - -#define NETIF_IN_TASK_STACK_SIZE ( 1024 ) -#define NETIF_IN_TASK_PRIORITY ( 3 ) - -#define NETIF_OUT_TASK_STACK_SIZE ( 1024 ) -#define NETIF_OUT_TASK_PRIORITY ( 3 ) - -/* USER CODE END 0 */ - - -/* Exported functions ------------------------------------------------------- */ -err_t ethernetif_init(struct netif *netif); - -void ethernetif_input( void *argument ); -void ethernetif_output( void *argument ); -void ethernetif_update_config(struct netif *netif); -void ethernetif_notify_conn_changed(struct netif *netif); - -u32_t sys_jiffies(void); -u32_t sys_now(void); - -/* USER CODE BEGIN 1 */ - -/* USER CODE END 1 */ -#endif - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/lwipopts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/lwipopts.h index 936446c3..2b058129 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/lwipopts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/lwipopts.h @@ -1,499 +1,261 @@ -/** - ****************************************************************************** - * @file lwipopts.h - * @author MCD Application Team - * @version V1.1.0 - * @date 31-July-2013 - * @brief lwIP Options Configuration. - * This file is based on Utilities\lwip_v1.4.1\src\include\lwip\opt.h - * and contains the lwIP configuration for the STM32F4x7 demonstration. - ****************************************************************************** - * @attention - * - *

© COPYRIGHT 2013 STMicroelectronics

- * - * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); - * You may not use this file except in compliance with the License. - * You may obtain a copy of the License at: - * - * http://www.st.com/software_license_agreement_liberty_v2 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - * - ****************************************************************************** - */ - -#ifndef __LWIPOPTS_H__ -#define __LWIPOPTS_H__ - -/** - * SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain - * critical regions during buffer allocation, deallocation and memory - * allocation and deallocation. - */ -#define SYS_LIGHTWEIGHT_PROT 1 - -/** - * NO_SYS==1: Provides VERY minimal functionality. Otherwise, - * use lwIP facilities. - */ -#define NO_SYS 0 - -/** - * NO_SYS_NO_TIMERS==1: Drop support for sys_timeout when NO_SYS==1 - * Mainly for compatibility to old versions. - */ -#define NO_SYS_NO_TIMERS 0 - -/* ---------- Memory options ---------- */ -/* MEM_ALIGNMENT: should be set to the alignment of the CPU for which - lwIP is compiled. 4 byte alignment -> define MEM_ALIGNMENT to 4, 2 - byte alignment -> define MEM_ALIGNMENT to 2. */ -#define MEM_ALIGNMENT 4 - -/* MEM_SIZE: the size of the heap memory. If the application will send -a lot of data that needs to be copied, this should be set high. */ -#define MEM_SIZE (25*1024) - -/* MEMP_NUM_PBUF: the number of memp struct pbufs. If the application - sends a lot of data out of ROM (or other static memory), this - should be set high. */ -#define MEMP_NUM_PBUF 15 -/* MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One - per active UDP "connection". */ -#define MEMP_NUM_UDP_PCB 4 -/* MEMP_NUM_TCP_PCB: the number of simulatenously active TCP - connections. */ -#define MEMP_NUM_TCP_PCB 4 -/* MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP - connections. */ -#define MEMP_NUM_TCP_PCB_LISTEN 2 -/* MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP - segments. */ -#define MEMP_NUM_TCP_SEG 120 -/* MEMP_NUM_SYS_TIMEOUT: the number of simulateously active - timeouts. */ -#define MEMP_NUM_SYS_TIMEOUT 6 - - -/* ---------- Pbuf options ---------- */ -/* PBUF_POOL_SIZE: the number of buffers in the pbuf pool. */ -#define PBUF_POOL_SIZE 20 -/* PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. */ -#define PBUF_POOL_BUFSIZE LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_ENCAPSULATION_HLEN+PBUF_LINK_HLEN) - - -/* ---------- TCP options ---------- */ -#define LWIP_TCP 1 -#define TCP_TTL 255 - -/* Controls if TCP should queue segments that arrive out of - order. Define to 0 if your device is low on memory. */ -#define TCP_QUEUE_OOSEQ 0 - -/* TCP Maximum segment size. */ -#define TCP_MSS (1500 - 40) /* TCP_MSS = (Ethernet MTU - IP header size - TCP header size) */ - -/* TCP sender buffer space (bytes). */ -#define TCP_SND_BUF (11*TCP_MSS) - -/* TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least - as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. */ - -#define TCP_SND_QUEUELEN (8* TCP_SND_BUF/TCP_MSS) - -/* TCP receive window. */ -#define TCP_WND 16000//(12*TCP_MSS) - - -/* ---------- ICMP options ---------- */ -#define LWIP_ICMP 1 - - -/* ---------- DHCP options ---------- */ -/* Define LWIP_DHCP to 1 if you want DHCP configuration of - interfaces. DHCP is not implemented in lwIP 0.5.1, however, so - turning this on does currently not work. */ -#define LWIP_DHCP 0 - - -/* ---------- UDP options ---------- */ -#define LWIP_UDP 1 -#define UDP_TTL 255 - - -/* ---------- Statistics options ---------- */ -#define LWIP_STATS 0 -#define LWIP_PROVIDE_ERRNO 1 - -/* ---------- link callback options ---------- */ -/* LWIP_NETIF_LINK_CALLBACK==1: Support a callback function from an interface - * whenever the link changes (i.e., link down) - */ -#define LWIP_NETIF_LINK_CALLBACK 0 -/* - -------------------------------------- - ---------- Checksum options ---------- - -------------------------------------- -*/ - -/* -The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums by hardware: - - To use this feature let the following define uncommented. - - To disable it and process by CPU comment the the checksum. -*/ -#define CHECKSUM_BY_HARDWARE - - -#ifdef CHECKSUM_BY_HARDWARE - /* CHECKSUM_GEN_IP==0: Generate checksums by hardware for outgoing IP packets.*/ - #define CHECKSUM_GEN_IP 0 - /* CHECKSUM_GEN_UDP==0: Generate checksums by hardware for outgoing UDP packets.*/ - #define CHECKSUM_GEN_UDP 0 - /* CHECKSUM_GEN_TCP==0: Generate checksums by hardware for outgoing TCP packets.*/ - #define CHECKSUM_GEN_TCP 0 - /* CHECKSUM_CHECK_IP==0: Check checksums by hardware for incoming IP packets.*/ - #define CHECKSUM_CHECK_IP 0 - /* CHECKSUM_CHECK_UDP==0: Check checksums by hardware for incoming UDP packets.*/ - #define CHECKSUM_CHECK_UDP 0 - /* CHECKSUM_CHECK_TCP==0: Check checksums by hardware for incoming TCP packets.*/ - #define CHECKSUM_CHECK_TCP 0 - /* CHECKSUM_CHECK_ICMP==0: Check checksums by hardware for incoming ICMP packets.*/ - #define CHECKSUM_GEN_ICMP 0 -#else - /* CHECKSUM_GEN_IP==1: Generate checksums in software for outgoing IP packets.*/ - #define CHECKSUM_GEN_IP 1 - /* CHECKSUM_GEN_UDP==1: Generate checksums in software for outgoing UDP packets.*/ - #define CHECKSUM_GEN_UDP 1 - /* CHECKSUM_GEN_TCP==1: Generate checksums in software for outgoing TCP packets.*/ - #define CHECKSUM_GEN_TCP 1 - /* CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets.*/ - #define CHECKSUM_CHECK_IP 1 - /* CHECKSUM_CHECK_UDP==1: Check checksums in software for incoming UDP packets.*/ - #define CHECKSUM_CHECK_UDP 1 - /* CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets.*/ - #define CHECKSUM_CHECK_TCP 1 - /* CHECKSUM_CHECK_ICMP==1: Check checksums by hardware for incoming ICMP packets.*/ - #define CHECKSUM_GEN_ICMP 1 -#endif - - -/* - ---------------------------------------------- - ---------- Sequential layer options ---------- - ---------------------------------------------- -*/ -/** - * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c) - */ -#define LWIP_NETCONN 1 - -/* - ------------------------------------ - ---------- Socket options ---------- - ------------------------------------ -*/ -/** - * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c) - */ -#define LWIP_SOCKET 1 - -/* - --------------------------------- - ---------- OS options ---------- - --------------------------------- -*/ - - -#define DEFAULT_UDP_RECVMBOX_SIZE 10 -#define DEFAULT_TCP_RECVMBOX_SIZE 10 -#define DEFAULT_ACCEPTMBOX_SIZE 10 -#define DEFAULT_THREAD_STACKSIZE 1024 - - -#define TCPIP_THREAD_NAME "lwip" -#define TCPIP_THREAD_STACKSIZE 2048 -#define TCPIP_MBOX_SIZE 8 -#define TCPIP_THREAD_PRIO 3 - -//#define IPERF_SERVER_THREAD_NAME "iperf_server" -//#define IPERF_SERVER_THREAD_STACKSIZE 1024 -//#define IPERF_SERVER_THREAD_PRIO 0 - -//#define BLOCK_TIME 250 -//#define BLOCK_TIME_WAITING_FOR_INPUT ( ( portTickType ) 100 ) - -/* - ---------------------------------------- - ---------- Lwip Debug options ---------- - ---------------------------------------- -*/ -//#define LWIP_DEBUG 1 - -#endif /* __LWIPOPTS_H__ */ - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ - - - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -//#ifndef __LWIPOPTS_H__ -//#define __LWIPOPTS_H__ - -//#define TCPIP_MBOX_SIZE 6 - -//#define TCPIP_THREAD_NAME "tcp/ip" -//#define TCPIP_THREAD_STACKSIZE 1500 -//#define TCPIP_THREAD_PRIO 3 - -//#define DEFAULT_THREAD_STACKSIZE 1500 -//#define DEFAULT_THREAD_PRIO 3 - -//#define ETH_PAD_SIZE 2 -//#define LWIP_TCPIP_CORE_LOCKING 0 ///TODO Initialize mutex - -////#define LWIP_DEBUG -////#define DBG_TYPES_ON 0xff - -//#define ETHARP_DEBUG LWIP_DBG_OFF -//#define NETIF_DEBUG LWIP_DBG_ON -//#define PBUF_DEBUG LWIP_DBG_OFF -//#define API_LIB_DEBUG LWIP_DBG_OFF -//#define API_MSG_DEBUG LWIP_DBG_OFF -//#define SOCKETS_DEBUG LWIP_DBG_OFF -//#define ICMP_DEBUG LWIP_DBG_OFF -//#define IGMP_DEBUG LWIP_DBG_OFF -//#define INET_DEBUG LWIP_DBG_OFF -//#define IP_DEBUG LWIP_DBG_OFF -//#define IP_REASS_DEBUG LWIP_DBG_OFF -//#define RAW_DEBUG LWIP_DBG_OFF -//#define MEM_DEBUG LWIP_DBG_OFF -//#define MEMP_DEBUG LWIP_DBG_OFF -//#define SYS_DEBUG LWIP_DBG_OFF -//#define TCP_DEBUG LWIP_DBG_OFF -//#define TCP_INPUT_DEBUG LWIP_DBG_OFF -//#define TCP_FR_DEBUG LWIP_DBG_OFF -//#define TCP_RTO_DEBUG LWIP_DBG_OFF -//#define TCP_CWND_DEBUG LWIP_DBG_OFF -//#define TCP_WND_DEBUG LWIP_DBG_OFF -//#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF -//#define TCP_RST_DEBUG LWIP_DBG_OFF -//#define TCP_QLEN_DEBUG LWIP_DBG_OFF -//#define UDP_DEBUG LWIP_DBG_OFF -//#define TCPIP_DEBUG LWIP_DBG_OFF -//#define PPP_DEBUG LWIP_DBG_OFF -//#define SLIP_DEBUG LWIP_DBG_OFF -//#define DHCP_DEBUG LWIP_DBG_OFF -//#define AUTOIP_DEBUG LWIP_DBG_OFF -//#define SNMP_MSG_DEBUG LWIP_DBG_OFF -//#define SNMP_MIB_DEBUG LWIP_DBG_OFF -//#define DNS_DEBUG LWIP_DBG_OFF -//#define LWIP_NOASSERT 0 - -///** -// * SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain -// * critical regions during buffer allocation, deallocation and memory -// * allocation and deallocation. -// */ -//#define SYS_LIGHTWEIGHT_PROT 1 - -///* -// ------------------------------------ -// ---------- Memory options ---------- -// ------------------------------------ -//*/ - -///** -// * MEM_ALIGNMENT: should be set to the alignment of the CPU -// * 4 byte alignment -> #define MEM_ALIGNMENT 4 -// * 2 byte alignment -> #define MEM_ALIGNMENT 2 -// */ -//#define MEM_ALIGNMENT 4 - -///** STF (9*1024) -// * MEM_SIZE: the size of the heap memory. If the application will send -// * a lot of data that needs to be copied, this should be set high. -// */ -//#define MEM_SIZE (8*1024) - -///* -// ------------------------------------------------ -// ---------- Internal Memory Pool Sizes ---------- -// ------------------------------------------------ -//*/ -///** STF 40 -// * MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF). -// * If the application sends a lot of data out of ROM (or other static memory), -// * this should be set high. -// */ -//#define MEMP_NUM_PBUF 20 - -///** STF 8 -// * MEMP_NUM_TCP_PCB: the number of simulatenously active TCP connections. -// * (requires the LWIP_TCP option) -// */ -//#define MEMP_NUM_TCP_PCB 10 - -///** -// * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments. -// * (requires the LWIP_TCP option) -// */ -//#define MEMP_NUM_TCP_SEG 8 - -///** STF 3 -// * MEMP_NUM_SYS_TIMEOUT: the number of simulateously active timeouts. -// * (requires NO_SYS==0) -// */ -//#define MEMP_NUM_SYS_TIMEOUT 5 - -///** -// * MEMP_NUM_NETBUF: the number of struct netbufs. -// * (only needed if you use the sequential API, like api_lib.c) -// */ -//#define MEMP_NUM_NETBUF 4 - -///** STF 8 -// * PBUF_POOL_SIZE: the number of buffers in the pbuf pool. -// */ -//#define PBUF_POOL_SIZE 4 - - -///* -// ---------------------------------- -// ---------- Pbuf options ---------- -// ---------------------------------- -//*/ - -///** -// * PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. The default is -// * designed to accomodate single full size TCP frame in one pbuf, including -// * TCP_MSS, IP header, and link header. -// */ -//#define PBUF_POOL_BUFSIZE 1500 - -///* -// --------------------------------- -// ---------- TCP options ---------- -// --------------------------------- -//*/ -///** -// * LWIP_TCP==1: Turn on TCP. -// */ -//#define LWIP_TCP 1 - -///* TCP Maximum segment size. */ -//#define TCP_MSS 1500 - -///* TCP sender buffer space (bytes). */ -//#define TCP_SND_BUF 2*TCP_MSS - -///** -// * TCP_WND: The size of a TCP window. -// */ -//#define TCP_WND 2*TCP_MSS //1500 - -///** -// * TCP_SYNMAXRTX: Maximum number of retransmissions of SYN segments. -// */ -//#define TCP_SYNMAXRTX 4 - -///* -// --------------------------------- -// ---------- RAW options ---------- -// --------------------------------- -//*/ -///** -// * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. -// */ -//#define LWIP_RAW 0 - -///* -// ---------------------------------------------- -// ---------- Sequential layer options ---------- -// ---------------------------------------------- -//*/ -///** -// * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c) -// */ -//#define LWIP_NETCONN 1 -///* -// ------------------------------------ -// ---------- Socket options ---------- -// ------------------------------------ -//*/ -///** -// * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c) -// */ -//#define LWIP_SOCKET 1 - - -///* -// ---------------------------------------- -// ---------- Statistics options ---------- -// ---------------------------------------- -//*/ -///** -// * LWIP_STATS==1: Enable statistics collection in lwip_stats. -// */ -//#define LWIP_STATS 0 - -///* -// ---------------------------------- -// ---------- DHCP options ---------- -// ---------------------------------- -//*/ -///** -// * LWIP_DHCP==1: Enable DHCP module. -// */ -//#define LWIP_DHCP 0 - -///* -// ---------------------------------- -// ---------- IGMP options ---------- -// ---------------------------------- -//*/ -///** -// * LWIP_IGMP==1: Turn on IGMP module. -// */ -//#define LWIP_IGMP 0 - - -//#define LWIP_PROVIDE_ERRNO 1 - -////#define LWIP_SNMP 1 - -//#endif /* __LWIPOPTS_H__ */ +/** + ****************************************************************************** + * @file lwipopts.h + * @author MCD Application Team + * @version V1.1.0 + * @date 31-July-2013 + * @brief lwIP Options Configuration. + * This file is based on Utilities\lwip_v1.4.1\src\include\lwip\opt.h + * and contains the lwIP configuration for the STM32F4x7 demonstration. + ****************************************************************************** + * @attention + * + *

© COPYRIGHT 2013 STMicroelectronics

+ * + * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License"); + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.st.com/software_license_agreement_liberty_v2 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + ****************************************************************************** + */ + +#ifndef __LWIPOPTS_H__ +#define __LWIPOPTS_H__ + +/** + * SYS_LIGHTWEIGHT_PROT==1: if you want inter-task protection for certain + * critical regions during buffer allocation, deallocation and memory + * allocation and deallocation. + */ +#define SYS_LIGHTWEIGHT_PROT 1 + +/** + * NO_SYS==1: Provides VERY minimal functionality. Otherwise, + * use lwIP facilities. + */ +#define NO_SYS 0 + +/** + * NO_SYS_NO_TIMERS==1: Drop support for sys_timeout when NO_SYS==1 + * Mainly for compatibility to old versions. + */ +#define NO_SYS_NO_TIMERS 0 + +/* ---------- Memory options ---------- */ +/* MEM_ALIGNMENT: should be set to the alignment of the CPU for which + lwIP is compiled. 4 byte alignment -> define MEM_ALIGNMENT to 4, 2 + byte alignment -> define MEM_ALIGNMENT to 2. */ +#define MEM_ALIGNMENT 4 + +/* MEM_SIZE: the size of the heap memory. If the application will send +a lot of data that needs to be copied, this should be set high. */ +#define MEM_SIZE (25*1024) + +/* MEMP_NUM_PBUF: the number of memp struct pbufs. If the application + sends a lot of data out of ROM (or other static memory), this + should be set high. */ +#define MEMP_NUM_PBUF 15 +/* MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One + per active UDP "connection". */ +#define MEMP_NUM_UDP_PCB 4 +/* MEMP_NUM_TCP_PCB: the number of simulatenously active TCP + connections. */ +#define MEMP_NUM_TCP_PCB 4 +/* MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP + connections. */ +#define MEMP_NUM_TCP_PCB_LISTEN 2 +/* MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP + segments. */ +#define MEMP_NUM_TCP_SEG 120 +/* MEMP_NUM_SYS_TIMEOUT: the number of simulateously active + timeouts. */ +#define MEMP_NUM_SYS_TIMEOUT 6 + + +/* ---------- Pbuf options ---------- */ +/* PBUF_POOL_SIZE: the number of buffers in the pbuf pool. */ +#define PBUF_POOL_SIZE 20 +/* PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. */ +#define PBUF_POOL_BUFSIZE LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_ENCAPSULATION_HLEN+PBUF_LINK_HLEN) + + +/* ---------- TCP options ---------- */ +#define LWIP_TCP 1 +#define TCP_TTL 255 + +/* Controls if TCP should queue segments that arrive out of + order. Define to 0 if your device is low on memory. */ +#define TCP_QUEUE_OOSEQ 0 + +/* TCP Maximum segment size. */ +#define TCP_MSS (1500 - 40) /* TCP_MSS = (Ethernet MTU - IP header size - TCP header size) */ + +/* TCP sender buffer space (bytes). */ +#define TCP_SND_BUF (11*TCP_MSS) + +/* TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least + as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. */ + +#define TCP_SND_QUEUELEN (8* TCP_SND_BUF/TCP_MSS) + +/* TCP receive window. */ +#define TCP_WND (12*TCP_MSS) + + +/* ---------- ICMP options ---------- */ +#define LWIP_ICMP 1 + + +/* ---------- DHCP options ---------- */ +/* Define LWIP_DHCP to 1 if you want DHCP configuration of + interfaces. DHCP is not implemented in lwIP 0.5.1, however, so + turning this on does currently not work. */ +#define LWIP_DHCP 1 + + +/* ---------- UDP options ---------- */ +#define LWIP_UDP 1 +#define UDP_TTL 255 + + +/* ---------- Statistics options ---------- */ +#define LWIP_STATS 0 +#define LWIP_PROVIDE_ERRNO 1 + +/* ---------- link callback options ---------- */ +/* LWIP_NETIF_LINK_CALLBACK==1: Support a callback function from an interface + * whenever the link changes (i.e., link down) + */ +#define LWIP_NETIF_LINK_CALLBACK 0 +/* + -------------------------------------- + ---------- Checksum options ---------- + -------------------------------------- +*/ + +/* +The STM32F4x7 allows computing and verifying the IP, UDP, TCP and ICMP checksums by hardware: + - To use this feature let the following define uncommented. + - To disable it and process by CPU comment the the checksum. +*/ +//#define CHECKSUM_BY_HARDWARE + +#ifdef CHECKSUM_BY_HARDWARE + /* CHECKSUM_GEN_IP==0: Generate checksums by hardware for outgoing IP packets.*/ + #define CHECKSUM_GEN_IP 0 + /* CHECKSUM_GEN_UDP==0: Generate checksums by hardware for outgoing UDP packets.*/ + #define CHECKSUM_GEN_UDP 0 + /* CHECKSUM_GEN_TCP==0: Generate checksums by hardware for outgoing TCP packets.*/ + #define CHECKSUM_GEN_TCP 0 + /* CHECKSUM_CHECK_IP==0: Check checksums by hardware for incoming IP packets.*/ + #define CHECKSUM_CHECK_IP 0 + /* CHECKSUM_CHECK_UDP==0: Check checksums by hardware for incoming UDP packets.*/ + #define CHECKSUM_CHECK_UDP 0 + /* CHECKSUM_CHECK_TCP==0: Check checksums by hardware for incoming TCP packets.*/ + #define CHECKSUM_CHECK_TCP 0 + /* CHECKSUM_CHECK_ICMP==0: Check checksums by hardware for incoming ICMP packets.*/ + #define CHECKSUM_GEN_ICMP 0 +#else + /* CHECKSUM_GEN_IP==1: Generate checksums in software for outgoing IP packets.*/ + #define CHECKSUM_GEN_IP 1 + /* CHECKSUM_GEN_UDP==1: Generate checksums in software for outgoing UDP packets.*/ + #define CHECKSUM_GEN_UDP 1 + /* CHECKSUM_GEN_TCP==1: Generate checksums in software for outgoing TCP packets.*/ + #define CHECKSUM_GEN_TCP 1 + /* CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets.*/ + #define CHECKSUM_CHECK_IP 1 + /* CHECKSUM_CHECK_UDP==1: Check checksums in software for incoming UDP packets.*/ + #define CHECKSUM_CHECK_UDP 1 + /* CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets.*/ + #define CHECKSUM_CHECK_TCP 1 + /* CHECKSUM_CHECK_ICMP==1: Check checksums by hardware for incoming ICMP packets.*/ + #define CHECKSUM_GEN_ICMP 1 +#endif + + +/* + ---------------------------------------------- + ---------- Sequential layer options ---------- + ---------------------------------------------- +*/ +/** + * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c) + */ +#define LWIP_NETCONN 1 + +/* + ------------------------------------ + ---------- Socket options ---------- + ------------------------------------ +*/ +/** + * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c) + */ +#define LWIP_SOCKET 1 + +/* + --------------------------------- + ---------- OS options ---------- + --------------------------------- +*/ + +#define DEFAULT_RAW_RECVMBOX_SIZE 10 +#define DEFAULT_UDP_RECVMBOX_SIZE 10 +#define DEFAULT_TCP_RECVMBOX_SIZE 10 +#define DEFAULT_ACCEPTMBOX_SIZE 10 + +#define DEFAULT_THREAD_PRIO 20 +#define DEFAULT_THREAD_STACKSIZE 1024 + +#define TCPIP_THREAD_NAME "tcp" +#define TCPIP_THREAD_STACKSIZE 8192 +#define TCPIP_MBOX_SIZE 10 +#define TCPIP_THREAD_PRIO 15 + +//#define IPERF_SERVER_THREAD_NAME "iperf_server" +//#define IPERF_SERVER_THREAD_STACKSIZE 1024 +//#define IPERF_SERVER_THREAD_PRIO 0 + +//#define BLOCK_TIME 250 +//#define BLOCK_TIME_WAITING_FOR_INPUT ( ( portTickType ) 100 ) + +/* + ---------------------------------------- + ---------- Lwip Debug options ---------- + ---------------------------------------- +*/ +#define LWIP_DEBUG 1 + +#define LWIP_IPV4 1 +#define LWIP_RAW 1 +#define LWIP_DNS 1 + +#if LWIP_DNS +#define LWIP_RAND rand +#endif + +#ifndef nfds_t +typedef unsigned int nfds_t; +#endif + +#define FSL_FEATURE_PHYKSZ8081_USE_RMII50M_MODE + +#define MEMP_LIB_MALLOC 1 +#define MEMP_MEM_MALLOC 1 + +#define lw_print //KPrintf +#define lw_trace() //KPrintf("lw: [%s][%d] passed!\n", __func__, __LINE__) +#define lw_error() //KPrintf("lw: [%s][%d] failed!\n", __func__, __LINE__) +#define lw_pr_info KPrintf +#endif /* __LWIPOPTS_H__ */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/main.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/main.h index 1618279d..04c2a44d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/main.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/main.h @@ -1,50 +1,50 @@ -/** - ****************************************************************************** - * @file GPIO/GPIO_EXTI/Inc/main.h - * @author MCD Application Team - * @brief Header for main.c module - ****************************************************************************** - * @attention - * - *

© COPYRIGHT(c) 2017 STMicroelectronics

- * - * 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 STMicroelectronics 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. - * - ****************************************************************************** - */ - -/* Define to prevent recursive inclusion -------------------------------------*/ -#ifndef __MAIN_H -#define __MAIN_H - -/* Includes ------------------------------------------------------------------*/ - -// void BSP_Init(void); -/* Exported types ------------------------------------------------------------*/ -/* Exported constants --------------------------------------------------------*/ -/* Exported macro ------------------------------------------------------------*/ -/* Exported functions ------------------------------------------------------- */ - -#endif /* __MAIN_H */ - -/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ +/** + ****************************************************************************** + * @file GPIO/GPIO_EXTI/Inc/main.h + * @author MCD Application Team + * @brief Header for main.c module + ****************************************************************************** + * @attention + * + *

© COPYRIGHT(c) 2017 STMicroelectronics

+ * + * 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 STMicroelectronics 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. + * + ****************************************************************************** + */ + +/* Define to prevent recursive inclusion -------------------------------------*/ +#ifndef __MAIN_H +#define __MAIN_H + +/* Includes ------------------------------------------------------------------*/ + +// void BSP_Init(void); +/* Exported types ------------------------------------------------------------*/ +/* Exported constants --------------------------------------------------------*/ +/* Exported macro ------------------------------------------------------------*/ +/* Exported functions ------------------------------------------------------- */ + +#endif /* __MAIN_H */ + +/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/perf.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/perf.h index 68afdb56..334d42af 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/perf.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/perf.h @@ -1,38 +1,38 @@ -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef __PERF_H__ -#define __PERF_H__ - -#define PERF_START /* null definition */ -#define PERF_STOP(x) /* null definition */ - -#endif /* __PERF_H__ */ +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef __PERF_H__ +#define __PERF_H__ + +#define PERF_START /* null definition */ +#define PERF_STOP(x) /* null definition */ + +#endif /* __PERF_H__ */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.c index f7221daf..99845580 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.c @@ -1,450 +1,595 @@ -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -/* -* Copyright (c) 2020 AIIT XUOS Lab -* XiUOS is licensed under Mulan PSL v2. -* You can use this software according to the terms and conditions of the Mulan PSL v2. -* You may obtain a copy of Mulan PSL v2 at: -* http://license.coscl.org.cn/MulanPSL2 -* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, -* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, -* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. -* See the Mulan PSL v2 for more details. -*/ - -/** -* @file sys_arch.c -* @brief In order to adapt to XiUOS, some changes have been made to implement the LwIP interface. -* @version 1.0 -* @author AIIT XUOS Lab -* @date 2021-05-29 -*/ -#include "debug.h" - -#include -#include - -#include "tcpip.h" -#include "lwip/init.h" -#include "lwip/netif.h" -#include "lwip/sio.h" -#include "ethernetif.h" - -#if !NO_SYS -#include "sys_arch.h" -#endif -#include -#include -#include -#include "lwip/dhcp.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include - -int errno; - - -x_ticks_t lwip_sys_now; - -struct sys_timeouts { - struct sys_timeo *next; -}; - -struct timeoutlist -{ - struct sys_timeouts timeouts; - int32 pid; -}; - -#define SYS_THREAD_MAX 4 - -static struct timeoutlist s_timeoutlist[SYS_THREAD_MAX]; - -static u16_t s_nextthread = 0; - -u32_t -sys_jiffies(void) -{ - lwip_sys_now = CurrentTicksGain(); - return lwip_sys_now; -} - -u32_t -sys_now(void) -{ - lwip_sys_now = CurrentTicksGain(); - return lwip_sys_now; -} - -void -sys_init(void) -{ - int i; - for(i = 0; i < SYS_THREAD_MAX; i++) - { - s_timeoutlist[i].pid = 0; - s_timeoutlist[i].timeouts.next = NULL; - } - s_nextthread = 0; -} - -struct sys_timeouts *sys_arch_timeouts(void) -{ - int i; - int32 pid; - struct timeoutlist *tl; - pid = (int32)GetKTaskDescriptor()->id.id; - for(i = 0; i < s_nextthread; i++) - { - tl = &(s_timeoutlist[i]); - if(tl->pid == pid) - { - return &(tl->timeouts); - } - } - return NULL; -} - -sys_prot_t sys_arch_protect(void) -{ - return CriticalAreaLock(); -} - -void sys_arch_unprotect(sys_prot_t pval) -{ - CriticalAreaUnLock(pval); -} - -#if !NO_SYS - -err_t -sys_sem_new(sys_sem_t *sem, u8_t count) -{ - *sem = KSemaphoreCreate((uint16)count); - -#if SYS_STATS - ++lwip_stats.sys.sem.used; - if (lwip_stats.sys.sem.max < lwip_stats.sys.sem.used) { - lwip_stats.sys.sem.max = lwip_stats.sys.sem.used; - } -#endif /* SYS_STATS */ - - if(*sem >= 0) - return ERR_OK; - else - { -#if SYS_STATS - ++lwip_stats.sys.sem.err; -#endif /* SYS_STATS */ - KPrintf("[sys_arch]:new sem fail!\n"); - return ERR_MEM; - } -} - -void -sys_sem_free(sys_sem_t *sem) -{ -#if SYS_STATS - --lwip_stats.sys.sem.used; -#endif /* SYS_STATS */ - KSemaphoreDelete(*sem); - *sem = SYS_SEM_NULL; -} - -int sys_sem_valid(sys_sem_t *sem) -{ - return (*sem >= SYS_SEM_NULL); -} - -void -sys_sem_set_invalid(sys_sem_t *sem) -{ - *sem = SYS_SEM_NULL; -} - -u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) -{ - x_ticks_t start_tick = 0 ; - int32 wait_time = 0; - - - if(*sem == SYS_SEM_NULL) - return SYS_ARCH_TIMEOUT; - - - start_tick = CurrentTicksGain(); - - if (0 == timeout) - wait_time = WAITING_FOREVER; - else - wait_time = timeout; - - - if(KSemaphoreObtain(*sem, wait_time) == EOK) - return ((CurrentTicksGain()-start_tick)*MS_PER_SYSTICK_F407); - else - return SYS_ARCH_TIMEOUT; -} - -void sys_sem_signal(sys_sem_t *sem) -{ - if(KSemaphoreAbandon( *sem ) != EOK) - KPrintf("[sys_arch]:sem signal fail!\n"); -} - -err_t sys_mutex_new(sys_mutex_t *mutex) -{ - *mutex = KMutexCreate(); - if(*mutex >= 0) - return ERR_OK; - else - { - KPrintf("[sys_arch]:new mutex fail!\n"); - return ERR_MEM; - } -} - -void sys_mutex_free(sys_mutex_t *mutex) -{ - KMutexDelete(*mutex); -} - -void sys_mutex_set_invalid(sys_mutex_t *mutex) -{ - *mutex = SYS_MRTEX_NULL; -} - -void sys_mutex_lock(sys_mutex_t *mutex) -{ - KMutexObtain(*mutex, - WAITING_FOREVER); -} - -void sys_mutex_unlock(sys_mutex_t *mutex) -{ - KMutexAbandon( *mutex ); -} - - -sys_thread_t sys_thread_new(const char *name, lwip_thread_fn function, void *arg, int stacksize, int prio) -{ - sys_thread_t handle = -1; - handle = KTaskCreate(name, - function, - arg, - (uint32)stacksize, - (uint8)prio); - - if (handle >= 0) - { - StartupKTask(handle); - return handle; - } - return -ERROR; -} - -err_t sys_mbox_new(sys_mbox_t *mbox, int size) -{ - *mbox = KCreateMsgQueue(sizeof(void *), size); - -#if SYS_STATS - ++lwip_stats.sys.mbox.used; - if (lwip_stats.sys.mbox.max < lwip_stats.sys.mbox.used) { - lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used; - } -#endif /* SYS_STATS */ - if(*mbox < 0) - return ERR_MEM; - - return ERR_OK; -} - -void sys_mbox_free(sys_mbox_t *mbox) -{ - KDeleteMsgQueue(*mbox); -} - -int sys_mbox_valid(sys_mbox_t *mbox) -{ - if (*mbox < SYS_MBOX_NULL) - return 0; - else - return 1; -} - -void sys_mbox_set_invalid(sys_mbox_t *mbox) -{ - *mbox = SYS_MBOX_NULL; -} - -void sys_mbox_post(sys_mbox_t *q, void *msg) -{ - while(KMsgQueueSendwait( *q, &msg, sizeof(void *), WAITING_FOREVER) != EOK); -} - -err_t sys_mbox_trypost(sys_mbox_t *q, void *msg) -{ - if(KMsgQueueSend(*q, &msg, sizeof(void *)) == EOK) - return ERR_OK; - else - return ERR_MEM; -} - -err_t sys_mbox_trypost_fromisr(sys_mbox_t *q, void *msg) -{ - return sys_mbox_trypost(q, msg); -} - -u32_t sys_arch_mbox_fetch(sys_mbox_t *q, void **msg, u32_t timeout) -{ - x_ticks_t start_tick = 0 ; - int32 wait_time = 0; - - start_tick = CurrentTicksGain(); - - if (0 == timeout) - wait_time = WAITING_FOREVER; - else - wait_time = timeout; - - if(KMsgQueueRecv(*q, &(*msg), sizeof(void *), wait_time) == EOK) - return ((CurrentTicksGain()-start_tick)*MS_PER_SYSTICK_F407); - else{ - *msg = NULL; - return SYS_ARCH_TIMEOUT; - } -} - -u32_t sys_arch_mbox_tryfetch(sys_mbox_t *q, void **msg) -{ - if(KMsgQueueRecv(*q, &(*msg), sizeof(void *), 0) == EOK) - return ERR_OK; - else - return SYS_MBOX_EMPTY; -} - -#if LWIP_NETCONN_SEM_PER_THREAD -#error LWIP_NETCONN_SEM_PER_THREAD==1 not supported -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - -#endif /* !NO_SYS */ - -/* Variables Initialization */ -struct netif gnetif; -ip4_addr_t ipaddr; -ip4_addr_t netmask; -ip4_addr_t gw; -uint8_t IP_ADDRESS[4]; -uint8_t NETMASK_ADDRESS[4]; -uint8_t GATEWAY_ADDRESS[4]; - -void TcpIpInit(void) -{ - tcpip_init(NULL, NULL); - - /* IP addresses initialization */ - /* USER CODE BEGIN 0 */ -#if LWIP_DHCP - ip_addr_set_zero_ip4(&ipaddr); - ip_addr_set_zero_ip4(&netmask); - ip_addr_set_zero_ip4(&gw); -#else - #ifdef SET_AS_SERVER - IP4_ADDR(&ipaddr,IP_ADDR0_SERVER,IP_ADDR1_SERVER,IP_ADDR2_SERVER,IP_ADDR3_SERVER); - #else - IP4_ADDR(&ipaddr,IP_ADDR0_ClIENT,IP_ADDR1_ClIENT,IP_ADDR2_ClIENT,IP_ADDR3_ClIENT); - #endif - - IP4_ADDR(&netmask,NETMASK_ADDR0,NETMASK_ADDR1,NETMASK_ADDR2,NETMASK_ADDR3); - IP4_ADDR(&gw,GW_ADDR0,GW_ADDR1,GW_ADDR2,GW_ADDR3); -#endif /* USE_DHCP */ - /* USER CODE END 0 */ - /* Initilialize the LwIP stack without RTOS */ - /* add the network interface (IPv4/IPv6) without RTOS */ - netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, ðernetif_init, &tcpip_input); - - /* Registers the default network interface */ - netif_set_default(&gnetif); - - if (netif_is_link_up(&gnetif)) - { - /* When the netif is fully configured this function must be called */ - KPrintf("TcpIpInit : netif_set_up\n"); - netif_set_up(&gnetif); - } - else - { - /* When the netif link is down this function must be called */ - KPrintf("TcpIpInit : netif_set_down\n"); - netif_set_down(&gnetif); - } - -#if LWIP_DHCP - int err; - /* Creates a new DHCP client for this interface on the first call. - Note: you must call dhcp_fine_tmr() and dhcp_coarse_tmr() at - the predefined regular intervals after starting the client. - You can peek in the netif->dhcp struct for the actual DHCP status.*/ - - - err = dhcp_start(&gnetif); - if(err == ERR_OK) - KPrintf("lwip dhcp init success...\n\n"); - else - KPrintf("lwip dhcp init fail...\n\n"); - while(ip_addr_cmp(&(gnetif.ip_addr),&ipaddr)) - { - vTaskDelay(1); - } -#endif - KPrintf("\n\nIP:%d.%d.%d.%d\n\n", \ - ((gnetif.ip_addr.addr)&0x000000ff), \ - (((gnetif.ip_addr.addr)&0x0000ff00)>>8), \ - (((gnetif.ip_addr.addr)&0x00ff0000)>>16), \ - ((gnetif.ip_addr.addr)&0xff000000)>>24); -} - - - - - - - - - - +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file sys_arch.c +* @brief In order to adapt to XiUOS, some changes have been made to implement the LwIP interface. +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-29 +*/ +#include "debug.h" + +#include +#include + +#include "tcpip.h" +#include "lwip/init.h" +#include "lwip/netif.h" +#include "lwip/sio.h" +#include +#include +#include +#include "lwip/dhcp.h" +#include "tcpip_priv.h" + +#if !NO_SYS +#include "sys_arch.h" +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "board.h" +#include "ethernet.h" +#include "enet_ethernetif.h" +#include + +/* MAC address configuration. */ +#define configMAC_ADDR { 0x02, 0x12, 0x13, 0x10, 0x15, 0x11} + +char lwip_ipaddr[] = {192, 168, 250, 253}; +char lwip_netmask[] = {255, 255, 255, 0}; +char lwip_gwaddr[] = {192, 168, 250, 252}; + +int errno; +int is_lwip_test = 0; //for lwip input thread + +x_ticks_t lwip_sys_now; + +static int lwip_init_flag = 0; + +struct sys_timeouts { + struct sys_timeo *next; +}; + +struct timeoutlist +{ + struct sys_timeouts timeouts; + int32 pid; +}; + +#define SYS_THREAD_MAX 4 + +static struct timeoutlist s_timeoutlist[SYS_THREAD_MAX]; + +static u16_t s_nextthread = 0; + +u32_t +sys_jiffies(void) +{ + lwip_sys_now = CurrentTicksGain(); + return lwip_sys_now; +} + +u32_t +sys_now(void) +{ + lwip_sys_now = CurrentTicksGain(); + return lwip_sys_now; +} + +void +sys_init(void) +{ + int i; + for(i = 0; i < SYS_THREAD_MAX; i++) + { + s_timeoutlist[i].pid = 0; + s_timeoutlist[i].timeouts.next = NULL; + } + s_nextthread = 0; +} + +struct sys_timeouts *sys_arch_timeouts(void) +{ + int i; + int32 pid; + struct timeoutlist *tl; + pid = (int32)GetKTaskDescriptor()->id.id; + for(i = 0; i < s_nextthread; i++) + { + tl = &(s_timeoutlist[i]); + if(tl->pid == pid) + { + return &(tl->timeouts); + } + } + return NULL; +} + +sys_prot_t sys_arch_protect(void) +{ + return CriticalAreaLock(); +} + +void sys_arch_unprotect(sys_prot_t pval) +{ + CriticalAreaUnLock(pval); +} + +#if !NO_SYS + +err_t +sys_sem_new(sys_sem_t *sem, u8_t count) +{ + *sem = KSemaphoreCreate((uint16)count); + +#if SYS_STATS + ++lwip_stats.sys.sem.used; + if (lwip_stats.sys.sem.max < lwip_stats.sys.sem.used) { + lwip_stats.sys.sem.max = lwip_stats.sys.sem.used; + } +#endif /* SYS_STATS */ + + if(*sem >= 0) + return ERR_OK; + else + { +#if SYS_STATS + ++lwip_stats.sys.sem.err; +#endif /* SYS_STATS */ + KPrintf("[sys_arch]:new sem fail!\n"); + return ERR_MEM; + } +} + +void +sys_sem_free(sys_sem_t *sem) +{ +#if SYS_STATS + --lwip_stats.sys.sem.used; +#endif /* SYS_STATS */ + KSemaphoreDelete(*sem); + *sem = SYS_SEM_NULL; +} + +int sys_sem_valid(sys_sem_t *sem) +{ + return (*sem >= SYS_SEM_NULL); +} + +void +sys_sem_set_invalid(sys_sem_t *sem) +{ + *sem = SYS_SEM_NULL; +} + +u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout) +{ + x_ticks_t start_tick = 0 ; + int32 wait_time = 0; + + + if(*sem == SYS_SEM_NULL) + return SYS_ARCH_TIMEOUT; + + + start_tick = CurrentTicksGain(); + + if (0 == timeout) + wait_time = WAITING_FOREVER; + else + wait_time = timeout; + + + if(KSemaphoreObtain(*sem, wait_time) == EOK) + return ((CurrentTicksGain()-start_tick)*MS_PER_SYSTICK_F407); + else + return SYS_ARCH_TIMEOUT; +} + +void sys_sem_signal(sys_sem_t *sem) +{ + if(KSemaphoreAbandon( *sem ) != EOK) + KPrintf("[sys_arch]:sem signal fail!\n"); +} + +err_t sys_mutex_new(sys_mutex_t *mutex) +{ + *mutex = KMutexCreate(); + if(*mutex >= 0) + return ERR_OK; + else + { + KPrintf("[sys_arch]:new mutex fail!\n"); + return ERR_MEM; + } +} + +void sys_mutex_free(sys_mutex_t *mutex) +{ + KMutexDelete(*mutex); +} + +void sys_mutex_set_invalid(sys_mutex_t *mutex) +{ + *mutex = SYS_MRTEX_NULL; +} + +void sys_mutex_lock(sys_mutex_t *mutex) +{ + KMutexObtain(*mutex, + WAITING_FOREVER); +} + +void sys_mutex_unlock(sys_mutex_t *mutex) +{ + KMutexAbandon( *mutex ); +} + + +sys_thread_t sys_thread_new(const char *name, lwip_thread_fn function, void *arg, int stacksize, int prio) +{ + sys_thread_t handle = -1; + handle = KTaskCreate(name, + function, + arg, + (uint32)stacksize, + (uint8)prio); + if (handle >= 0) + { + StartupKTask(handle); + lw_print("lw: [%s] create %s handle %x\n", __func__, name, handle); + return handle; + } + lw_print("lw: [%s] create %s failed\n", __func__, name); + return -ERROR; +} + +err_t sys_mbox_new(sys_mbox_t *mbox, int size) +{ + *mbox = KCreateMsgQueue(sizeof(void *), size); + +#if SYS_STATS + ++lwip_stats.sys.mbox.used; + if (lwip_stats.sys.mbox.max < lwip_stats.sys.mbox.used) { + lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used; + } +#endif /* SYS_STATS */ + if(*mbox < 0) + { + lw_print("lw: [%s] alloc %d mbox %p failed\n", __func__, size, mbox); + return ERR_MEM; + } + + lw_print("lw: [%s] alloc %d mbox %p ok!\n", __func__, size, mbox); + return ERR_OK; +} + +void sys_mbox_free(sys_mbox_t *mbox) +{ + KDeleteMsgQueue(*mbox); +} + +int sys_mbox_valid(sys_mbox_t *mbox) +{ + if (*mbox <= SYS_MBOX_NULL) + return 0; + else + return 1; +} + +void sys_mbox_set_invalid(sys_mbox_t *mbox) +{ + *mbox = SYS_MBOX_NULL; +} + +void sys_mbox_post(sys_mbox_t *q, void *msg) +{ + while(KMsgQueueSendwait( *q, &msg, sizeof(void *), WAITING_FOREVER) != EOK); +} + +err_t sys_mbox_trypost(sys_mbox_t *q, void *msg) +{ + if(KMsgQueueSend(*q, &msg, sizeof(void *)) == EOK) + return ERR_OK; + else + return ERR_MEM; +} + +err_t sys_mbox_trypost_fromisr(sys_mbox_t *q, void *msg) +{ + return sys_mbox_trypost(q, msg); +} + +u32_t sys_arch_mbox_fetch(sys_mbox_t *q, void **msg, u32_t timeout) +{ + x_ticks_t start_tick = 0 ; + int32 wait_time = 0; + + start_tick = CurrentTicksGain(); + + if (0 == timeout) + wait_time = WAITING_FOREVER; + else + wait_time = timeout; + + if(KMsgQueueRecv(*q, &(*msg), sizeof(void *), wait_time) == EOK) + return ((CurrentTicksGain()-start_tick)*MS_PER_SYSTICK_F407); + else{ + *msg = NULL; + return SYS_ARCH_TIMEOUT; + } +} + +u32_t sys_arch_mbox_tryfetch(sys_mbox_t *q, void **msg) +{ + if(KMsgQueueRecv(*q, &(*msg), sizeof(void *), 0) == EOK) + return ERR_OK; + else + return SYS_MBOX_EMPTY; +} + +#if LWIP_NETCONN_SEM_PER_THREAD +#error LWIP_NETCONN_SEM_PER_THREAD==1 not supported +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + +#endif /* !NO_SYS */ + +/* Variables Initialization */ +struct netif gnetif; +ip4_addr_t ipaddr; +ip4_addr_t netmask; +ip4_addr_t gw; + +void TcpIpInit(void) +{ + tcpip_init(NULL, NULL); + + /* IP addresses initialization */ + /* USER CODE BEGIN 0 */ +#if LWIP_DHCP + ip_addr_set_zero_ip4(&ipaddr); + ip_addr_set_zero_ip4(&netmask); + ip_addr_set_zero_ip4(&gw); +#else + #ifdef SET_AS_SERVER + IP4_ADDR(&ipaddr,IP_ADDR0_SERVER,IP_ADDR1_SERVER,IP_ADDR2_SERVER,IP_ADDR3_SERVER); + #else + IP4_ADDR(&ipaddr,IP_ADDR0_ClIENT,IP_ADDR1_ClIENT,IP_ADDR2_ClIENT,IP_ADDR3_ClIENT); + #endif + + IP4_ADDR(&netmask,NETMASK_ADDR0,NETMASK_ADDR1,NETMASK_ADDR2,NETMASK_ADDR3); + IP4_ADDR(&gw,GW_ADDR0,GW_ADDR1,GW_ADDR2,GW_ADDR3); +#endif /* USE_DHCP */ + /* USER CODE END 0 */ + /* Initilialize the LwIP stack without RTOS */ + /* add the network interface (IPv4/IPv6) without RTOS */ + netif_add(&gnetif, &ipaddr, &netmask, &gw, NULL, ðernetif0_init, &tcpip_input); + + /* Registers the default network interface */ + netif_set_default(&gnetif); + + if (netif_is_link_up(&gnetif)) + { + /* When the netif is fully configured this function must be called */ + KPrintf("TcpIpInit : netif_set_up\n"); + netif_set_up(&gnetif); + } + else + { + /* When the netif link is down this function must be called */ + KPrintf("TcpIpInit : netif_set_down\n"); + netif_set_down(&gnetif); + } + +#if LWIP_DHCP + int err; + /* Creates a new DHCP client for this interface on the first call. + Note: you must call dhcp_fine_tmr() and dhcp_coarse_tmr() at + the predefined regular intervals after starting the client. + You can peek in the netif->dhcp struct for the actual DHCP status.*/ + + + err = dhcp_start(&gnetif); + if(err == ERR_OK) + KPrintf("lwip dhcp init success...\n\n"); + else + KPrintf("lwip dhcp init fail...\n\n"); + while(ip_addr_cmp(&(gnetif.ip_addr),&ipaddr)) + { + DelayKTask(1); + } +#endif + KPrintf("\n\nIP:%d.%d.%d.%d\n\n", \ + ((gnetif.ip_addr.addr)&0x000000ff), \ + (((gnetif.ip_addr.addr)&0x0000ff00)>>8), \ + (((gnetif.ip_addr.addr)&0x00ff0000)>>16), \ + ((gnetif.ip_addr.addr)&0xff000000)>>24); +} + +// lwip input thread to get network packet +void lwip_input_thread(void *param) +{ + struct netif *net = param; + + while (1) + { + /* Poll the driver, get any outstanding frames */ + ethernetif_input(net); + sys_check_timeouts(); /* Handle all system timeouts for all core protocols */ +// DelayKTask(1); + } +} + +void lwip_config_input(struct netif *net) +{ + pthread_t th_id = 0; + + th_id = sys_thread_new("eth_input", lwip_input_thread, net, 4096, 15); + + if (th_id >= 0) { + lw_print("%s %d successfully!\n", __func__, th_id); + } else { + lw_print("%s failed!\n", __func__); + } +} + +void lwip_config_net(char *ip, char *mask, char *gw) +{ +#if defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0) + mem_range_t non_dma_memory[] = NON_DMA_MEMORY_ARRAY; +#endif /* FSL_FEATURE_SOC_LPC_ENET_COUNT */ + ip4_addr_t net_ipaddr, net_netmask, net_gw; + ethernetif_config_t cfg = { + .phyAddress = BOARD_ENET0_PHY_ADDRESS, + .clockName = kCLOCK_CoreSysClk, + .macAddress = configMAC_ADDR, +#if defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0) + .non_dma_memory = non_dma_memory, +#endif /* FSL_FEATURE_SOC_LPC_ENET_COUNT */ + }; + + if(lwip_init_flag) + { + lw_print("lw: [%s] already ...\n", __func__); + + IP4_ADDR(&net_ipaddr, ip[0], ip[1], ip[2], ip[3]); + IP4_ADDR(&net_netmask, mask[0], mask[1], mask[2], mask[3]); + IP4_ADDR(&net_gw, gw[0], gw[1], gw[2], gw[3]); + + netif_set_down(&gnetif); + netif_set_gw(&gnetif, &net_gw); + netif_set_netmask(&gnetif, &net_netmask); + netif_set_ipaddr(&gnetif, &net_ipaddr); + netif_set_up(&gnetif); + return; + } + lwip_init_flag = 1; + + lw_print("lw: [%s] start ...\n", __func__); + + IP4_ADDR(&net_ipaddr, ip[0], ip[1], ip[2], ip[3]); + IP4_ADDR(&net_netmask, mask[0], mask[1], mask[2], mask[3]); + IP4_ADDR(&net_gw, gw[0], gw[1], gw[2], gw[3]); + + lwip_init(); + + netif_add(&gnetif, &net_ipaddr, &net_netmask, &net_gw, &cfg, ethernetif0_init, + ethernet_input); + netif_set_default(&gnetif); + netif_set_up(&gnetif); + + if(is_lwip_test) + { + lw_pr_info("\r\n************************************************\r\n"); + lw_pr_info(" Network Configuration\r\n"); + lw_pr_info("************************************************\r\n"); + lw_pr_info(" IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t *)&net_ipaddr)[0], ((u8_t *)&net_ipaddr)[1], + ((u8_t *)&net_ipaddr)[2], ((u8_t *)&net_ipaddr)[3]); + lw_pr_info(" IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t *)&net_netmask)[0], ((u8_t *)&net_netmask)[1], + ((u8_t *)&net_netmask)[2], ((u8_t *)&net_netmask)[3]); + lw_pr_info(" IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t *)&net_gw)[0], ((u8_t *)&net_gw)[1], + ((u8_t *)&net_gw)[2], ((u8_t *)&net_gw)[3]); + lw_pr_info("************************************************\r\n"); + } + lwip_config_input(&gnetif); +} + +void lwip_config_tcp(char *ip, char *mask, char *gw) +{ +#if defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0) + mem_range_t non_dma_memory[] = NON_DMA_MEMORY_ARRAY; +#endif /* FSL_FEATURE_SOC_LPC_ENET_COUNT */ + ip4_addr_t net_ipaddr, net_netmask, net_gw; + ethernetif_config_t cfg = { + .phyAddress = BOARD_ENET0_PHY_ADDRESS, + .clockName = kCLOCK_CoreSysClk, + .macAddress = configMAC_ADDR, +#if defined(FSL_FEATURE_SOC_LPC_ENET_COUNT) && (FSL_FEATURE_SOC_LPC_ENET_COUNT > 0) + .non_dma_memory = non_dma_memory, +#endif /* FSL_FEATURE_SOC_LPC_ENET_COUNT */ + }; + + if(lwip_init_flag) + { + lw_print("lw: [%s] already ...\n", __func__); + return; + } + lwip_init_flag = 1; + + tcpip_init(NULL, NULL); + + lw_print("lw: [%s] start ...\n", __func__); + + IP4_ADDR(&net_ipaddr, ip[0], ip[1], ip[2], ip[3]); + IP4_ADDR(&net_netmask, mask[0], mask[1], mask[2], mask[3]); + IP4_ADDR(&net_gw, gw[0], gw[1], gw[2], gw[3]); + + netif_add(&gnetif, &net_ipaddr, &net_netmask, &net_gw, &cfg, ethernetif0_init, + tcpip_input); + + netif_set_default(&gnetif); + netif_set_up(&gnetif); + + lw_print("\r\n************************************************\r\n"); + lw_print(" Network Configuration\r\n"); + lw_print("************************************************\r\n"); + lw_print(" IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t *)&net_ipaddr)[0], ((u8_t *)&net_ipaddr)[1], + ((u8_t *)&net_ipaddr)[2], ((u8_t *)&net_ipaddr)[3]); + lw_print(" IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t *)&net_netmask)[0], ((u8_t *)&net_netmask)[1], + ((u8_t *)&net_netmask)[2], ((u8_t *)&net_netmask)[3]); + lw_print(" IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t *)&net_gw)[0], ((u8_t *)&net_gw)[1], + ((u8_t *)&net_gw)[2], ((u8_t *)&net_gw)[3]); + lw_print("************************************************\r\n"); + + lwip_config_input(&gnetif); +} + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.h index d9bf38b4..dab1c544 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/sys_arch.h @@ -1,102 +1,118 @@ -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -/* -* Copyright (c) 2020 AIIT XUOS Lab -* XiUOS is licensed under Mulan PSL v2. -* You can use this software according to the terms and conditions of the Mulan PSL v2. -* You may obtain a copy of Mulan PSL v2 at: -* http://license.coscl.org.cn/MulanPSL2 -* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, -* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, -* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. -* See the Mulan PSL v2 for more details. -*/ - -/** -* @file sys_arch.h -* @brief In order to adapt to XiUOS, some changes have been made to implement the LwIP interface. -* @version 1.0 -* @author AIIT XUOS Lab -* @date 2021-05-29 -*/ - -#include -#include -#include "tcpip.h" - -#include - -/* USER CODE BEGIN 0 */ -// #define SET_AS_SERVER 1 /* define this terminal is udp server or not*/ - -#define LOCAL_PORT_SERVER 5001 -#define TARGET_PORT_CLIENT LOCAL_PORT_SERVER - -/*Static IP ADDRESS: IP_ADDR0.IP_ADDR1.IP_ADDR2.IP_ADDR3 */ -#define IP_ADDR0_SERVER 192 -#define IP_ADDR1_SERVER 168 -#define IP_ADDR2_SERVER 0 -#define IP_ADDR3_SERVER 166 - -#define IP_ADDR0_ClIENT 192 -#define IP_ADDR1_ClIENT 168 -#define IP_ADDR2_ClIENT 0 -#define IP_ADDR3_ClIENT 177 - -/*NETMASK*/ -#define NETMASK_ADDR0 255 -#define NETMASK_ADDR1 255 -#define NETMASK_ADDR2 255 -#define NETMASK_ADDR3 0 - -/*Gateway Address*/ -#define GW_ADDR0 192 -#define GW_ADDR1 168 -#define GW_ADDR2 0 -#define GW_ADDR3 1 -/* USER CODE END 0 */ - -#define SYS_MBOX_NULL 0 -#define SYS_SEM_NULL 0 -#define SYS_MRTEX_NULL SYS_SEM_NULL - -typedef int32 sys_sem_t; -typedef int32 sys_mutex_t; -typedef int32 sys_mbox_t; -typedef int32 sys_thread_t; - -typedef x_base sys_prot_t; - -#define MS_PER_SYSTICK_F407 1000/TICK_PER_SECOND - -void TcpIpInit(void); - +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file sys_arch.h +* @brief In order to adapt to XiUOS, some changes have been made to implement the LwIP interface. +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-29 +*/ + +#ifndef __SYS_ARCH__ +#define __SYS_ATCH__ + +#include +#include +#include + +#include "tcpip.h" + +#include + +/* USER CODE BEGIN 0 */ +// #define SET_AS_SERVER 1 /* define this terminal is udp server or not*/ + +#define LOCAL_PORT_SERVER 4840 +#define TARGET_PORT_CLIENT LOCAL_PORT_SERVER + +#define TEST_LWIP_TIMES 3 + +/*Static IP ADDRESS: IP_ADDR0.IP_ADDR1.IP_ADDR2.IP_ADDR3 */ +#define IP_ADDR0_SERVER 192 +#define IP_ADDR1_SERVER 168 +#define IP_ADDR2_SERVER 250 +#define IP_ADDR3_SERVER 252 + +#define IP_ADDR0_ClIENT 192 +#define IP_ADDR1_ClIENT 168 +#define IP_ADDR2_ClIENT 250 +#define IP_ADDR3_ClIENT 253 + +/*NETMASK*/ +#define NETMASK_ADDR0 255 +#define NETMASK_ADDR1 255 +#define NETMASK_ADDR2 255 +#define NETMASK_ADDR3 0 + +/*Gateway Address*/ +#define GW_ADDR0 192 +#define GW_ADDR1 168 +#define GW_ADDR2 250 +#define GW_ADDR3 5 +/* USER CODE END 0 */ + +#define SYS_MBOX_NULL -1 +#define SYS_SEM_NULL 0 +#define SYS_MRTEX_NULL SYS_SEM_NULL + +typedef int32 sys_sem_t; +typedef int32 sys_mutex_t; +typedef int32 sys_mbox_t; +typedef int32 sys_thread_t; + +typedef x_base sys_prot_t; + +#define MS_PER_SYSTICK_F407 1000/TICK_PER_SECOND + +extern char lwip_ipaddr[]; +extern char lwip_netmask[]; +extern char lwip_gwaddr[]; +extern int is_lwip_test; +extern struct netif gnetif; + +void TcpIpInit(void); +void lwip_config_net(char *ip, char *mask, char *gw); +void lwip_config_tcp(char *ip, char *mask, char *gw); + +#endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/tcp_echo_socket_demo.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/tcp_echo_socket_demo.c deleted file mode 100644 index 2e7f03da..00000000 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/tcp_echo_socket_demo.c +++ /dev/null @@ -1,68 +0,0 @@ -/* -* Copyright (c) 2020 AIIT XUOS Lab -* XiUOS is licensed under Mulan PSL v2. -* You can use this software according to the terms and conditions of the Mulan PSL v2. -* You may obtain a copy of Mulan PSL v2 at: -* http://license.coscl.org.cn/MulanPSL2 -* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, -* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, -* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. -* See the Mulan PSL v2 for more details. -*/ - -/** -* @file tcp_echo_socket_demo.c -* @brief One UDP demo based on LwIP -* @version 1.0 -* @author AIIT XUOS Lab -* @date 2021-05-29 -*/ - -#include -#include "udp_echo.h" -#include - -static void NetStackTaskCreate(void* param); - -extern void TcpIpInit(void); - -extern char* send_msg; - -int UdpEchoSocketDemo(int argc, char *argv[]) -{ - if (argc == 2) - { - send_msg = argv[1]; - } - - ETH_BSP_Config(); - - int32 thr_id = KTaskCreate( - (const char* )"NetStackTaskCreate", - NetStackTaskCreate, - (void* )NULL, - (uint16_t )512, - 15); - - if(thr_id >= 0) - StartupKTask(thr_id); - else{ - KPrintf("NetStackTaskCreate create failed !\n"); - return -1; - } -} -#ifndef SEPARATE_COMPILE -SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0)|SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN), -UdpEchoSocketDemo, UdpEchoSocketDemo, tcp_echo_socket function ); -#endif - -static void NetStackTaskCreate(void* param) -{ - TcpIpInit(); - - UdpEchoInit(); -} - - - - diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/udp_echo.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/udp_echo.c deleted file mode 100644 index 0db73277..00000000 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/udp_echo.c +++ /dev/null @@ -1,191 +0,0 @@ -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -/* -* Copyright (c) 2020 AIIT XUOS Lab -* XiUOS is licensed under Mulan PSL v2. -* You can use this software according to the terms and conditions of the Mulan PSL v2. -* You may obtain a copy of Mulan PSL v2 at: -* http://license.coscl.org.cn/MulanPSL2 -* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, -* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, -* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. -* See the Mulan PSL v2 for more details. -*/ - -/** -* @file tcpecho.c -* @brief Add UDP client function -* @version 1.0 -* @author AIIT XUOS Lab -* @date 2021-05-29 -*/ - -#include "udp_echo.h" - -#include "lwip/opt.h" - -#if LWIP_SOCKET -#include - -#include "lwip/sys.h" -#include "lwip/api.h" -#include - -#define RECV_DATA (1024) - -char* send_msg = "\n\nThis one is UDP pkg. Congratulations on you.\n\n"; - -static void UdpEchoThreadServer(void *arg) -{ - KPrintf("UdpEchoThreadServer start.\n"); - - int sock = -1; - char *recv_data; - struct sockaddr_in udp_addr,seraddr; - int recv_data_len; - socklen_t addrlen; - - while(1) - { - recv_data = (char *)malloc(RECV_DATA); - if (recv_data == NULL) - { - KPrintf("No memory\n"); - goto __exit; - } - - sock = socket(AF_INET, SOCK_DGRAM, 0); - if (sock < 0) - { - KPrintf("Socket error\n"); - goto __exit; - } - - udp_addr.sin_family = AF_INET; - udp_addr.sin_addr.s_addr = INADDR_ANY; - udp_addr.sin_port = htons(LOCAL_PORT_SERVER); - memset(&(udp_addr.sin_zero), 0, sizeof(udp_addr.sin_zero)); - - if (bind(sock, (struct sockaddr *)&udp_addr, sizeof(struct sockaddr)) == -1) - { - KPrintf("Unable to bind\n"); - goto __exit; - } - - KPrintf("UDP bind sucess, start to receive.\n"); - KPrintf("\n\nLocal Port:%d\n\n", LOCAL_PORT_SERVER); - - while(1) - { - memset(recv_data, 0, RECV_DATA); - recv_data_len=recvfrom(sock,recv_data, - RECV_DATA,0, - (struct sockaddr*)&seraddr, - &addrlen); - - KPrintf("Receive from : %s\n",inet_ntoa(seraddr.sin_addr)); - - KPrintf("Recevce data : %s\n\n",recv_data); - - sendto(sock,recv_data, - recv_data_len,0, - (struct sockaddr*)&seraddr, - addrlen); - } - -__exit: - if (sock >= 0) closesocket(sock); - if (recv_data) free(recv_data); - } -} - -static void UdpEchoThreadClient(void *arg) -{ - KPrintf("UdpEchoThreadClient start.\n"); - - int sock_udp_send_once = -1; - sock_udp_send_once = socket(AF_INET, SOCK_DGRAM, 0); - if (sock_udp_send_once < 0) - { - KPrintf("Socket error\n"); - goto __exit; - } - - struct sockaddr_in udp_sock; - udp_sock.sin_family = AF_INET; - udp_sock.sin_port = htons(TARGET_PORT_CLIENT); - udp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(IP_ADDR0_SERVER,IP_ADDR1_SERVER,IP_ADDR2_SERVER,IP_ADDR3_SERVER)); - memset(&(udp_sock.sin_zero), 0, sizeof(udp_sock.sin_zero)); - - if (connect(sock_udp_send_once, (struct sockaddr *)&udp_sock, sizeof(struct sockaddr))) - { - KPrintf("Unable to connect\n"); - goto __exit; - } - - KPrintf("UDP connect sucess, start to send.\n"); - KPrintf("\n\nTarget Port:%d\n\n", udp_sock.sin_port); - - - - while (1) - { - KPrintf("Lwip client is running.\n"); - - sendto(sock_udp_send_once,send_msg, - strlen(send_msg),0, - (struct sockaddr*)&udp_sock, - sizeof(struct sockaddr)); - - KPrintf("Send UDP msg: %s ", send_msg); - - MdelayKTask(1000); - } - -__exit: - if (sock_udp_send_once >= 0) closesocket(sock_udp_send_once); - - return; -} - -void -UdpEchoInit(void) -{ - #ifdef SET_AS_SERVER - sys_thread_new("UdpEchoThreadServer", UdpEchoThreadServer, NULL, 2048, 4); - #else - sys_thread_new("UdpEchoThreadClient", UdpEchoThreadClient, NULL, 2048, 4); - #endif -} - -#endif /* LWIP_NETCONN */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp.c index d42b727c..d46d6cdb 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp.c @@ -1,681 +1,681 @@ -/** - * @file - * @defgroup altcp Application layered TCP Functions - * @ingroup altcp_api - * - * This file contains the common functions for altcp to work. - * For more details see @ref altcp_api. - */ - -/** - * @defgroup altcp_api Application layered TCP Introduction - * @ingroup callbackstyle_api - * - * Overview - * -------- - * altcp (application layered TCP connection API; to be used from TCPIP thread) - * is an abstraction layer that prevents applications linking hard against the - * @ref tcp.h functions while providing the same functionality. It is used to - * e.g. add SSL/TLS (see LWIP_ALTCP_TLS) or proxy-connect support to an application - * written for the tcp callback API without that application knowing the - * protocol details. - * - * * This interface mimics the tcp callback API to the application while preventing - * direct linking (much like virtual functions). - * * This way, an application can make use of other application layer protocols - * on top of TCP without knowing the details (e.g. TLS, proxy connection). - * * This is achieved by simply including "lwip/altcp.h" instead of "lwip/tcp.h", - * replacing "struct tcp_pcb" with "struct altcp_pcb" and prefixing all functions - * with "altcp_" instead of "tcp_". - * - * With altcp support disabled (LWIP_ALTCP==0), applications written against the - * altcp API can still be compiled but are directly linked against the tcp.h - * callback API and then cannot use layered protocols. To minimize code changes - * in this case, the use of altcp_allocators is strongly suggested. - * - * Usage - * ----- - * To make use of this API from an existing tcp raw API application: - * * Include "lwip/altcp.h" instead of "lwip/tcp.h" - * * Replace "struct tcp_pcb" with "struct altcp_pcb" - * * Prefix all called tcp API functions with "altcp_" instead of "tcp_" to link - * against the altcp functions - * * @ref altcp_new (and @ref altcp_new_ip_type/@ref altcp_new_ip6) take - * an @ref altcp_allocator_t as an argument, whereas the original tcp API - * functions take no arguments. - * * An @ref altcp_allocator_t allocator is an object that holds a pointer to an - * allocator object and a corresponding state (e.g. for TLS, the corresponding - * state may hold certificates or keys). This way, the application does not - * even need to know if it uses TLS or pure TCP, this is handled at runtime - * by passing a specific allocator. - * * An application can alternatively bind hard to the altcp_tls API by calling - * @ref altcp_tls_new or @ref altcp_tls_wrap. - * * The TLS layer is not directly implemented by lwIP, but a port to mbedTLS is - * provided. - * * Another altcp layer is proxy-connect to use TLS behind a HTTP proxy (see - * @ref altcp_proxyconnect.h) - * - * altcp_allocator_t - * ----------------- - * An altcp allocator is created by the application by combining an allocator - * callback function and a corresponding state, e.g.:\code{.c} - * static const unsigned char cert[] = {0x2D, ... (see mbedTLS doc for how to create this)}; - * struct altcp_tls_config * conf = altcp_tls_create_config_client(cert, sizeof(cert)); - * altcp_allocator_t tls_allocator = { - * altcp_tls_alloc, conf - * }; - * \endcode - * - * - * struct altcp_tls_config - * ----------------------- - * The struct altcp_tls_config holds state that is needed to create new TLS client - * or server connections (e.g. certificates and private keys). - * - * It is not defined by lwIP itself but by the TLS port (e.g. altcp_tls to mbedTLS - * adaption). However, the parameters used to create it are defined in @ref - * altcp_tls.h (see @ref altcp_tls_create_config_server_privkey_cert for servers - * and @ref altcp_tls_create_config_client/@ref altcp_tls_create_config_client_2wayauth - * for clients). - * - * For mbedTLS, ensure that certificates can be parsed by 'mbedtls_x509_crt_parse()' and - * private keys can be parsed by 'mbedtls_pk_parse_key()'. - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/altcp.h" -#include "lwip/priv/altcp_priv.h" -#include "lwip/altcp_tcp.h" -#include "lwip/tcp.h" -#include "lwip/mem.h" - -#include - -extern const struct altcp_functions altcp_tcp_functions; - -/** - * For altcp layer implementations only: allocate a new struct altcp_pcb from the pool - * and zero the memory - */ -struct altcp_pcb * -altcp_alloc(void) -{ - struct altcp_pcb *ret = (struct altcp_pcb *)memp_malloc(MEMP_ALTCP_PCB); - if (ret != NULL) { - memset(ret, 0, sizeof(struct altcp_pcb)); - } - return ret; -} - -/** - * For altcp layer implementations only: return a struct altcp_pcb to the pool - */ -void -altcp_free(struct altcp_pcb *conn) -{ - if (conn) { - if (conn->fns && conn->fns->dealloc) { - conn->fns->dealloc(conn); - } - memp_free(MEMP_ALTCP_PCB, conn); - } -} - -/** - * @ingroup altcp - * altcp_new_ip6: @ref altcp_new for IPv6 - */ -struct altcp_pcb * -altcp_new_ip6(altcp_allocator_t *allocator) -{ - return altcp_new_ip_type(allocator, IPADDR_TYPE_V6); -} - -/** - * @ingroup altcp - * altcp_new: @ref altcp_new for IPv4 - */ -struct altcp_pcb * -altcp_new(altcp_allocator_t *allocator) -{ - return altcp_new_ip_type(allocator, IPADDR_TYPE_V4); -} - -/** - * @ingroup altcp - * altcp_new_ip_type: called by applications to allocate a new pcb with the help of an - * allocator function. - * - * @param allocator allocator function and argument - * @param ip_type IP version of the pcb (@ref lwip_ip_addr_type) - * @return a new altcp_pcb or NULL on error - */ -struct altcp_pcb * -altcp_new_ip_type(altcp_allocator_t *allocator, u8_t ip_type) -{ - struct altcp_pcb *conn; - if (allocator == NULL) { - /* no allocator given, create a simple TCP connection */ - return altcp_tcp_new_ip_type(ip_type); - } - if (allocator->alloc == NULL) { - /* illegal allocator */ - return NULL; - } - conn = allocator->alloc(allocator->arg, ip_type); - if (conn == NULL) { - /* allocation failed */ - return NULL; - } - return conn; -} - -/** - * @ingroup altcp - * @see tcp_arg() - */ -void -altcp_arg(struct altcp_pcb *conn, void *arg) -{ - if (conn) { - conn->arg = arg; - } -} - -/** - * @ingroup altcp - * @see tcp_accept() - */ -void -altcp_accept(struct altcp_pcb *conn, altcp_accept_fn accept) -{ - if (conn != NULL) { - conn->accept = accept; - } -} - -/** - * @ingroup altcp - * @see tcp_recv() - */ -void -altcp_recv(struct altcp_pcb *conn, altcp_recv_fn recv) -{ - if (conn) { - conn->recv = recv; - } -} - -/** - * @ingroup altcp - * @see tcp_sent() - */ -void -altcp_sent(struct altcp_pcb *conn, altcp_sent_fn sent) -{ - if (conn) { - conn->sent = sent; - } -} - -/** - * @ingroup altcp - * @see tcp_poll() - */ -void -altcp_poll(struct altcp_pcb *conn, altcp_poll_fn poll, u8_t interval) -{ - if (conn) { - conn->poll = poll; - conn->pollinterval = interval; - if (conn->fns && conn->fns->set_poll) { - conn->fns->set_poll(conn, interval); - } - } -} - -/** - * @ingroup altcp - * @see tcp_err() - */ -void -altcp_err(struct altcp_pcb *conn, altcp_err_fn err) -{ - if (conn) { - conn->err = err; - } -} - -/* Generic functions calling the "virtual" ones */ - -/** - * @ingroup altcp - * @see tcp_recved() - */ -void -altcp_recved(struct altcp_pcb *conn, u16_t len) -{ - if (conn && conn->fns && conn->fns->recved) { - conn->fns->recved(conn, len); - } -} - -/** - * @ingroup altcp - * @see tcp_bind() - */ -err_t -altcp_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port) -{ - if (conn && conn->fns && conn->fns->bind) { - return conn->fns->bind(conn, ipaddr, port); - } - return ERR_VAL; -} - -/** - * @ingroup altcp - * @see tcp_connect() - */ -err_t -altcp_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) -{ - if (conn && conn->fns && conn->fns->connect) { - return conn->fns->connect(conn, ipaddr, port, connected); - } - return ERR_VAL; -} - -/** - * @ingroup altcp - * @see tcp_listen_with_backlog_and_err() - */ -struct altcp_pcb * -altcp_listen_with_backlog_and_err(struct altcp_pcb *conn, u8_t backlog, err_t *err) -{ - if (conn && conn->fns && conn->fns->listen) { - return conn->fns->listen(conn, backlog, err); - } - return NULL; -} - -/** - * @ingroup altcp - * @see tcp_abort() - */ -void -altcp_abort(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->abort) { - conn->fns->abort(conn); - } -} - -/** - * @ingroup altcp - * @see tcp_close() - */ -err_t -altcp_close(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->close) { - return conn->fns->close(conn); - } - return ERR_VAL; -} - -/** - * @ingroup altcp - * @see tcp_shutdown() - */ -err_t -altcp_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx) -{ - if (conn && conn->fns && conn->fns->shutdown) { - return conn->fns->shutdown(conn, shut_rx, shut_tx); - } - return ERR_VAL; -} - -/** - * @ingroup altcp - * @see tcp_write() - */ -err_t -altcp_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) -{ - if (conn && conn->fns && conn->fns->write) { - return conn->fns->write(conn, dataptr, len, apiflags); - } - return ERR_VAL; -} - -/** - * @ingroup altcp - * @see tcp_output() - */ -err_t -altcp_output(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->output) { - return conn->fns->output(conn); - } - return ERR_VAL; -} - -/** - * @ingroup altcp - * @see tcp_mss() - */ -u16_t -altcp_mss(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->mss) { - return conn->fns->mss(conn); - } - return 0; -} - -/** - * @ingroup altcp - * @see tcp_sndbuf() - */ -u16_t -altcp_sndbuf(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->sndbuf) { - return conn->fns->sndbuf(conn); - } - return 0; -} - -/** - * @ingroup altcp - * @see tcp_sndqueuelen() - */ -u16_t -altcp_sndqueuelen(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->sndqueuelen) { - return conn->fns->sndqueuelen(conn); - } - return 0; -} - -void -altcp_nagle_disable(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->nagle_disable) { - conn->fns->nagle_disable(conn); - } -} - -void -altcp_nagle_enable(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->nagle_enable) { - conn->fns->nagle_enable(conn); - } -} - -int -altcp_nagle_disabled(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->nagle_disabled) { - return conn->fns->nagle_disabled(conn); - } - return 0; -} - -/** - * @ingroup altcp - * @see tcp_setprio() - */ -void -altcp_setprio(struct altcp_pcb *conn, u8_t prio) -{ - if (conn && conn->fns && conn->fns->setprio) { - conn->fns->setprio(conn, prio); - } -} - -err_t -altcp_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port) -{ - if (conn && conn->fns && conn->fns->addrinfo) { - return conn->fns->addrinfo(conn, local, addr, port); - } - return ERR_VAL; -} - -ip_addr_t * -altcp_get_ip(struct altcp_pcb *conn, int local) -{ - if (conn && conn->fns && conn->fns->getip) { - return conn->fns->getip(conn, local); - } - return NULL; -} - -u16_t -altcp_get_port(struct altcp_pcb *conn, int local) -{ - if (conn && conn->fns && conn->fns->getport) { - return conn->fns->getport(conn, local); - } - return 0; -} - -#ifdef LWIP_DEBUG -enum tcp_state -altcp_dbg_get_tcp_state(struct altcp_pcb *conn) -{ - if (conn && conn->fns && conn->fns->dbg_get_tcp_state) { - return conn->fns->dbg_get_tcp_state(conn); - } - return CLOSED; -} -#endif - -/* Default implementations for the "virtual" functions */ - -void -altcp_default_set_poll(struct altcp_pcb *conn, u8_t interval) -{ - if (conn && conn->inner_conn) { - altcp_poll(conn->inner_conn, conn->poll, interval); - } -} - -void -altcp_default_recved(struct altcp_pcb *conn, u16_t len) -{ - if (conn && conn->inner_conn) { - altcp_recved(conn->inner_conn, len); - } -} - -err_t -altcp_default_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port) -{ - if (conn && conn->inner_conn) { - return altcp_bind(conn->inner_conn, ipaddr, port); - } - return ERR_VAL; -} - -err_t -altcp_default_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx) -{ - if (conn) { - if (shut_rx && shut_tx && conn->fns && conn->fns->close) { - /* default shutdown for both sides is close */ - return conn->fns->close(conn); - } - if (conn->inner_conn) { - return altcp_shutdown(conn->inner_conn, shut_rx, shut_tx); - } - } - return ERR_VAL; -} - -err_t -altcp_default_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) -{ - if (conn && conn->inner_conn) { - return altcp_write(conn->inner_conn, dataptr, len, apiflags); - } - return ERR_VAL; -} - -err_t -altcp_default_output(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - return altcp_output(conn->inner_conn); - } - return ERR_VAL; -} - -u16_t -altcp_default_mss(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - return altcp_mss(conn->inner_conn); - } - return 0; -} - -u16_t -altcp_default_sndbuf(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - return altcp_sndbuf(conn->inner_conn); - } - return 0; -} - -u16_t -altcp_default_sndqueuelen(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - return altcp_sndqueuelen(conn->inner_conn); - } - return 0; -} - -void -altcp_default_nagle_disable(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - altcp_nagle_disable(conn->inner_conn); - } -} - -void -altcp_default_nagle_enable(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - altcp_nagle_enable(conn->inner_conn); - } -} - -int -altcp_default_nagle_disabled(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - return altcp_nagle_disabled(conn->inner_conn); - } - return 0; -} - -void -altcp_default_setprio(struct altcp_pcb *conn, u8_t prio) -{ - if (conn && conn->inner_conn) { - altcp_setprio(conn->inner_conn, prio); - } -} - -void -altcp_default_dealloc(struct altcp_pcb *conn) -{ - LWIP_UNUSED_ARG(conn); - /* nothing to do */ -} - -err_t -altcp_default_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port) -{ - if (conn && conn->inner_conn) { - return altcp_get_tcp_addrinfo(conn->inner_conn, local, addr, port); - } - return ERR_VAL; -} - -ip_addr_t * -altcp_default_get_ip(struct altcp_pcb *conn, int local) -{ - if (conn && conn->inner_conn) { - return altcp_get_ip(conn->inner_conn, local); - } - return NULL; -} - -u16_t -altcp_default_get_port(struct altcp_pcb *conn, int local) -{ - if (conn && conn->inner_conn) { - return altcp_get_port(conn->inner_conn, local); - } - return 0; -} - -#ifdef LWIP_DEBUG -enum tcp_state -altcp_default_dbg_get_tcp_state(struct altcp_pcb *conn) -{ - if (conn && conn->inner_conn) { - return altcp_dbg_get_tcp_state(conn->inner_conn); - } - return CLOSED; -} -#endif - - -#endif /* LWIP_ALTCP */ +/** + * @file + * @defgroup altcp Application layered TCP Functions + * @ingroup altcp_api + * + * This file contains the common functions for altcp to work. + * For more details see @ref altcp_api. + */ + +/** + * @defgroup altcp_api Application layered TCP Introduction + * @ingroup callbackstyle_api + * + * Overview + * -------- + * altcp (application layered TCP connection API; to be used from TCPIP thread) + * is an abstraction layer that prevents applications linking hard against the + * @ref tcp.h functions while providing the same functionality. It is used to + * e.g. add SSL/TLS (see LWIP_ALTCP_TLS) or proxy-connect support to an application + * written for the tcp callback API without that application knowing the + * protocol details. + * + * * This interface mimics the tcp callback API to the application while preventing + * direct linking (much like virtual functions). + * * This way, an application can make use of other application layer protocols + * on top of TCP without knowing the details (e.g. TLS, proxy connection). + * * This is achieved by simply including "lwip/altcp.h" instead of "lwip/tcp.h", + * replacing "struct tcp_pcb" with "struct altcp_pcb" and prefixing all functions + * with "altcp_" instead of "tcp_". + * + * With altcp support disabled (LWIP_ALTCP==0), applications written against the + * altcp API can still be compiled but are directly linked against the tcp.h + * callback API and then cannot use layered protocols. To minimize code changes + * in this case, the use of altcp_allocators is strongly suggested. + * + * Usage + * ----- + * To make use of this API from an existing tcp raw API application: + * * Include "lwip/altcp.h" instead of "lwip/tcp.h" + * * Replace "struct tcp_pcb" with "struct altcp_pcb" + * * Prefix all called tcp API functions with "altcp_" instead of "tcp_" to link + * against the altcp functions + * * @ref altcp_new (and @ref altcp_new_ip_type/@ref altcp_new_ip6) take + * an @ref altcp_allocator_t as an argument, whereas the original tcp API + * functions take no arguments. + * * An @ref altcp_allocator_t allocator is an object that holds a pointer to an + * allocator object and a corresponding state (e.g. for TLS, the corresponding + * state may hold certificates or keys). This way, the application does not + * even need to know if it uses TLS or pure TCP, this is handled at runtime + * by passing a specific allocator. + * * An application can alternatively bind hard to the altcp_tls API by calling + * @ref altcp_tls_new or @ref altcp_tls_wrap. + * * The TLS layer is not directly implemented by lwIP, but a port to mbedTLS is + * provided. + * * Another altcp layer is proxy-connect to use TLS behind a HTTP proxy (see + * @ref altcp_proxyconnect.h) + * + * altcp_allocator_t + * ----------------- + * An altcp allocator is created by the application by combining an allocator + * callback function and a corresponding state, e.g.:\code{.c} + * static const unsigned char cert[] = {0x2D, ... (see mbedTLS doc for how to create this)}; + * struct altcp_tls_config * conf = altcp_tls_create_config_client(cert, sizeof(cert)); + * altcp_allocator_t tls_allocator = { + * altcp_tls_alloc, conf + * }; + * \endcode + * + * + * struct altcp_tls_config + * ----------------------- + * The struct altcp_tls_config holds state that is needed to create new TLS client + * or server connections (e.g. certificates and private keys). + * + * It is not defined by lwIP itself but by the TLS port (e.g. altcp_tls to mbedTLS + * adaption). However, the parameters used to create it are defined in @ref + * altcp_tls.h (see @ref altcp_tls_create_config_server_privkey_cert for servers + * and @ref altcp_tls_create_config_client/@ref altcp_tls_create_config_client_2wayauth + * for clients). + * + * For mbedTLS, ensure that certificates can be parsed by 'mbedtls_x509_crt_parse()' and + * private keys can be parsed by 'mbedtls_pk_parse_key()'. + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/altcp.h" +#include "lwip/priv/altcp_priv.h" +#include "lwip/altcp_tcp.h" +#include "lwip/tcp.h" +#include "lwip/mem.h" + +#include + +extern const struct altcp_functions altcp_tcp_functions; + +/** + * For altcp layer implementations only: allocate a new struct altcp_pcb from the pool + * and zero the memory + */ +struct altcp_pcb * +altcp_alloc(void) +{ + struct altcp_pcb *ret = (struct altcp_pcb *)memp_malloc(MEMP_ALTCP_PCB); + if (ret != NULL) { + memset(ret, 0, sizeof(struct altcp_pcb)); + } + return ret; +} + +/** + * For altcp layer implementations only: return a struct altcp_pcb to the pool + */ +void +altcp_free(struct altcp_pcb *conn) +{ + if (conn) { + if (conn->fns && conn->fns->dealloc) { + conn->fns->dealloc(conn); + } + memp_free(MEMP_ALTCP_PCB, conn); + } +} + +/** + * @ingroup altcp + * altcp_new_ip6: @ref altcp_new for IPv6 + */ +struct altcp_pcb * +altcp_new_ip6(altcp_allocator_t *allocator) +{ + return altcp_new_ip_type(allocator, IPADDR_TYPE_V6); +} + +/** + * @ingroup altcp + * altcp_new: @ref altcp_new for IPv4 + */ +struct altcp_pcb * +altcp_new(altcp_allocator_t *allocator) +{ + return altcp_new_ip_type(allocator, IPADDR_TYPE_V4); +} + +/** + * @ingroup altcp + * altcp_new_ip_type: called by applications to allocate a new pcb with the help of an + * allocator function. + * + * @param allocator allocator function and argument + * @param ip_type IP version of the pcb (@ref lwip_ip_addr_type) + * @return a new altcp_pcb or NULL on error + */ +struct altcp_pcb * +altcp_new_ip_type(altcp_allocator_t *allocator, u8_t ip_type) +{ + struct altcp_pcb *conn; + if (allocator == NULL) { + /* no allocator given, create a simple TCP connection */ + return altcp_tcp_new_ip_type(ip_type); + } + if (allocator->alloc == NULL) { + /* illegal allocator */ + return NULL; + } + conn = allocator->alloc(allocator->arg, ip_type); + if (conn == NULL) { + /* allocation failed */ + return NULL; + } + return conn; +} + +/** + * @ingroup altcp + * @see tcp_arg() + */ +void +altcp_arg(struct altcp_pcb *conn, void *arg) +{ + if (conn) { + conn->arg = arg; + } +} + +/** + * @ingroup altcp + * @see tcp_accept() + */ +void +altcp_accept(struct altcp_pcb *conn, altcp_accept_fn accept) +{ + if (conn != NULL) { + conn->accept = accept; + } +} + +/** + * @ingroup altcp + * @see tcp_recv() + */ +void +altcp_recv(struct altcp_pcb *conn, altcp_recv_fn recv) +{ + if (conn) { + conn->recv = recv; + } +} + +/** + * @ingroup altcp + * @see tcp_sent() + */ +void +altcp_sent(struct altcp_pcb *conn, altcp_sent_fn sent) +{ + if (conn) { + conn->sent = sent; + } +} + +/** + * @ingroup altcp + * @see tcp_poll() + */ +void +altcp_poll(struct altcp_pcb *conn, altcp_poll_fn poll, u8_t interval) +{ + if (conn) { + conn->poll = poll; + conn->pollinterval = interval; + if (conn->fns && conn->fns->set_poll) { + conn->fns->set_poll(conn, interval); + } + } +} + +/** + * @ingroup altcp + * @see tcp_err() + */ +void +altcp_err(struct altcp_pcb *conn, altcp_err_fn err) +{ + if (conn) { + conn->err = err; + } +} + +/* Generic functions calling the "virtual" ones */ + +/** + * @ingroup altcp + * @see tcp_recved() + */ +void +altcp_recved(struct altcp_pcb *conn, u16_t len) +{ + if (conn && conn->fns && conn->fns->recved) { + conn->fns->recved(conn, len); + } +} + +/** + * @ingroup altcp + * @see tcp_bind() + */ +err_t +altcp_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port) +{ + if (conn && conn->fns && conn->fns->bind) { + return conn->fns->bind(conn, ipaddr, port); + } + return ERR_VAL; +} + +/** + * @ingroup altcp + * @see tcp_connect() + */ +err_t +altcp_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) +{ + if (conn && conn->fns && conn->fns->connect) { + return conn->fns->connect(conn, ipaddr, port, connected); + } + return ERR_VAL; +} + +/** + * @ingroup altcp + * @see tcp_listen_with_backlog_and_err() + */ +struct altcp_pcb * +altcp_listen_with_backlog_and_err(struct altcp_pcb *conn, u8_t backlog, err_t *err) +{ + if (conn && conn->fns && conn->fns->listen) { + return conn->fns->listen(conn, backlog, err); + } + return NULL; +} + +/** + * @ingroup altcp + * @see tcp_abort() + */ +void +altcp_abort(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->abort) { + conn->fns->abort(conn); + } +} + +/** + * @ingroup altcp + * @see tcp_close() + */ +err_t +altcp_close(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->close) { + return conn->fns->close(conn); + } + return ERR_VAL; +} + +/** + * @ingroup altcp + * @see tcp_shutdown() + */ +err_t +altcp_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx) +{ + if (conn && conn->fns && conn->fns->shutdown) { + return conn->fns->shutdown(conn, shut_rx, shut_tx); + } + return ERR_VAL; +} + +/** + * @ingroup altcp + * @see tcp_write() + */ +err_t +altcp_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) +{ + if (conn && conn->fns && conn->fns->write) { + return conn->fns->write(conn, dataptr, len, apiflags); + } + return ERR_VAL; +} + +/** + * @ingroup altcp + * @see tcp_output() + */ +err_t +altcp_output(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->output) { + return conn->fns->output(conn); + } + return ERR_VAL; +} + +/** + * @ingroup altcp + * @see tcp_mss() + */ +u16_t +altcp_mss(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->mss) { + return conn->fns->mss(conn); + } + return 0; +} + +/** + * @ingroup altcp + * @see tcp_sndbuf() + */ +u16_t +altcp_sndbuf(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->sndbuf) { + return conn->fns->sndbuf(conn); + } + return 0; +} + +/** + * @ingroup altcp + * @see tcp_sndqueuelen() + */ +u16_t +altcp_sndqueuelen(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->sndqueuelen) { + return conn->fns->sndqueuelen(conn); + } + return 0; +} + +void +altcp_nagle_disable(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->nagle_disable) { + conn->fns->nagle_disable(conn); + } +} + +void +altcp_nagle_enable(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->nagle_enable) { + conn->fns->nagle_enable(conn); + } +} + +int +altcp_nagle_disabled(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->nagle_disabled) { + return conn->fns->nagle_disabled(conn); + } + return 0; +} + +/** + * @ingroup altcp + * @see tcp_setprio() + */ +void +altcp_setprio(struct altcp_pcb *conn, u8_t prio) +{ + if (conn && conn->fns && conn->fns->setprio) { + conn->fns->setprio(conn, prio); + } +} + +err_t +altcp_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port) +{ + if (conn && conn->fns && conn->fns->addrinfo) { + return conn->fns->addrinfo(conn, local, addr, port); + } + return ERR_VAL; +} + +ip_addr_t * +altcp_get_ip(struct altcp_pcb *conn, int local) +{ + if (conn && conn->fns && conn->fns->getip) { + return conn->fns->getip(conn, local); + } + return NULL; +} + +u16_t +altcp_get_port(struct altcp_pcb *conn, int local) +{ + if (conn && conn->fns && conn->fns->getport) { + return conn->fns->getport(conn, local); + } + return 0; +} + +#ifdef LWIP_DEBUG +enum tcp_state +altcp_dbg_get_tcp_state(struct altcp_pcb *conn) +{ + if (conn && conn->fns && conn->fns->dbg_get_tcp_state) { + return conn->fns->dbg_get_tcp_state(conn); + } + return CLOSED; +} +#endif + +/* Default implementations for the "virtual" functions */ + +void +altcp_default_set_poll(struct altcp_pcb *conn, u8_t interval) +{ + if (conn && conn->inner_conn) { + altcp_poll(conn->inner_conn, conn->poll, interval); + } +} + +void +altcp_default_recved(struct altcp_pcb *conn, u16_t len) +{ + if (conn && conn->inner_conn) { + altcp_recved(conn->inner_conn, len); + } +} + +err_t +altcp_default_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port) +{ + if (conn && conn->inner_conn) { + return altcp_bind(conn->inner_conn, ipaddr, port); + } + return ERR_VAL; +} + +err_t +altcp_default_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx) +{ + if (conn) { + if (shut_rx && shut_tx && conn->fns && conn->fns->close) { + /* default shutdown for both sides is close */ + return conn->fns->close(conn); + } + if (conn->inner_conn) { + return altcp_shutdown(conn->inner_conn, shut_rx, shut_tx); + } + } + return ERR_VAL; +} + +err_t +altcp_default_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) +{ + if (conn && conn->inner_conn) { + return altcp_write(conn->inner_conn, dataptr, len, apiflags); + } + return ERR_VAL; +} + +err_t +altcp_default_output(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + return altcp_output(conn->inner_conn); + } + return ERR_VAL; +} + +u16_t +altcp_default_mss(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + return altcp_mss(conn->inner_conn); + } + return 0; +} + +u16_t +altcp_default_sndbuf(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + return altcp_sndbuf(conn->inner_conn); + } + return 0; +} + +u16_t +altcp_default_sndqueuelen(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + return altcp_sndqueuelen(conn->inner_conn); + } + return 0; +} + +void +altcp_default_nagle_disable(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + altcp_nagle_disable(conn->inner_conn); + } +} + +void +altcp_default_nagle_enable(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + altcp_nagle_enable(conn->inner_conn); + } +} + +int +altcp_default_nagle_disabled(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + return altcp_nagle_disabled(conn->inner_conn); + } + return 0; +} + +void +altcp_default_setprio(struct altcp_pcb *conn, u8_t prio) +{ + if (conn && conn->inner_conn) { + altcp_setprio(conn->inner_conn, prio); + } +} + +void +altcp_default_dealloc(struct altcp_pcb *conn) +{ + LWIP_UNUSED_ARG(conn); + /* nothing to do */ +} + +err_t +altcp_default_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port) +{ + if (conn && conn->inner_conn) { + return altcp_get_tcp_addrinfo(conn->inner_conn, local, addr, port); + } + return ERR_VAL; +} + +ip_addr_t * +altcp_default_get_ip(struct altcp_pcb *conn, int local) +{ + if (conn && conn->inner_conn) { + return altcp_get_ip(conn->inner_conn, local); + } + return NULL; +} + +u16_t +altcp_default_get_port(struct altcp_pcb *conn, int local) +{ + if (conn && conn->inner_conn) { + return altcp_get_port(conn->inner_conn, local); + } + return 0; +} + +#ifdef LWIP_DEBUG +enum tcp_state +altcp_default_dbg_get_tcp_state(struct altcp_pcb *conn) +{ + if (conn && conn->inner_conn) { + return altcp_dbg_get_tcp_state(conn->inner_conn); + } + return CLOSED; +} +#endif + + +#endif /* LWIP_ALTCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_alloc.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_alloc.c index 8c2390ee..cd619bc1 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_alloc.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_alloc.c @@ -1,87 +1,87 @@ -/** - * @file - * Application layered TCP connection API (to be used from TCPIP thread)\n - * This interface mimics the tcp callback API to the application while preventing - * direct linking (much like virtual functions). - * This way, an application can make use of other application layer protocols - * on top of TCP without knowing the details (e.g. TLS, proxy connection). - * - * This file contains allocation implementation that combine several layers. - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/altcp.h" -#include "lwip/altcp_tcp.h" -#include "lwip/altcp_tls.h" -#include "lwip/priv/altcp_priv.h" -#include "lwip/mem.h" - -#include - -#if LWIP_ALTCP_TLS - -/** This standard allocator function creates an altcp pcb for - * TLS over TCP */ -struct altcp_pcb * -altcp_tls_new(struct altcp_tls_config *config, u8_t ip_type) -{ - struct altcp_pcb *inner_conn, *ret; - LWIP_UNUSED_ARG(ip_type); - - inner_conn = altcp_tcp_new_ip_type(ip_type); - if (inner_conn == NULL) { - return NULL; - } - ret = altcp_tls_wrap(config, inner_conn); - if (ret == NULL) { - altcp_close(inner_conn); - } - return ret; -} - -/** This standard allocator function creates an altcp pcb for - * TLS over TCP */ -struct altcp_pcb * -altcp_tls_alloc(void *arg, u8_t ip_type) -{ - return altcp_tls_new((struct altcp_tls_config *)arg, ip_type); -} - -#endif /* LWIP_ALTCP_TLS */ - -#endif /* LWIP_ALTCP */ +/** + * @file + * Application layered TCP connection API (to be used from TCPIP thread)\n + * This interface mimics the tcp callback API to the application while preventing + * direct linking (much like virtual functions). + * This way, an application can make use of other application layer protocols + * on top of TCP without knowing the details (e.g. TLS, proxy connection). + * + * This file contains allocation implementation that combine several layers. + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/altcp.h" +#include "lwip/altcp_tcp.h" +#include "lwip/altcp_tls.h" +#include "lwip/priv/altcp_priv.h" +#include "lwip/mem.h" + +#include + +#if LWIP_ALTCP_TLS + +/** This standard allocator function creates an altcp pcb for + * TLS over TCP */ +struct altcp_pcb * +altcp_tls_new(struct altcp_tls_config *config, u8_t ip_type) +{ + struct altcp_pcb *inner_conn, *ret; + LWIP_UNUSED_ARG(ip_type); + + inner_conn = altcp_tcp_new_ip_type(ip_type); + if (inner_conn == NULL) { + return NULL; + } + ret = altcp_tls_wrap(config, inner_conn); + if (ret == NULL) { + altcp_close(inner_conn); + } + return ret; +} + +/** This standard allocator function creates an altcp pcb for + * TLS over TCP */ +struct altcp_pcb * +altcp_tls_alloc(void *arg, u8_t ip_type) +{ + return altcp_tls_new((struct altcp_tls_config *)arg, ip_type); +} + +#endif /* LWIP_ALTCP_TLS */ + +#endif /* LWIP_ALTCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_tcp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_tcp.c index f5b8e844..b715f045 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_tcp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/altcp_tcp.c @@ -1,543 +1,543 @@ -/** - * @file - * Application layered TCP connection API (to be used from TCPIP thread)\n - * This interface mimics the tcp callback API to the application while preventing - * direct linking (much like virtual functions). - * This way, an application can make use of other application layer protocols - * on top of TCP without knowing the details (e.g. TLS, proxy connection). - * - * This file contains the base implementation calling into tcp. - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/altcp.h" -#include "lwip/altcp_tcp.h" -#include "lwip/priv/altcp_priv.h" -#include "lwip/tcp.h" -#include "lwip/mem.h" - -#include - -#define ALTCP_TCP_ASSERT_CONN(conn) do { \ - LWIP_ASSERT("conn->inner_conn == NULL", (conn)->inner_conn == NULL); \ - LWIP_UNUSED_ARG(conn); /* for LWIP_NOASSERT */ } while(0) -#define ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb) do { \ - LWIP_ASSERT("pcb mismatch", (conn)->state == tpcb); \ - LWIP_UNUSED_ARG(tpcb); /* for LWIP_NOASSERT */ \ - ALTCP_TCP_ASSERT_CONN(conn); } while(0) - - -/* Variable prototype, the actual declaration is at the end of this file - since it contains pointers to static functions declared here */ -extern const struct altcp_functions altcp_tcp_functions; - -static void altcp_tcp_setup(struct altcp_pcb *conn, struct tcp_pcb *tpcb); - -/* callback functions for TCP */ -static err_t -altcp_tcp_accept(void *arg, struct tcp_pcb *new_tpcb, err_t err) -{ - struct altcp_pcb *listen_conn = (struct altcp_pcb *)arg; - if (listen_conn && listen_conn->accept) { - /* create a new altcp_conn to pass to the next 'accept' callback */ - struct altcp_pcb *new_conn = altcp_alloc(); - if (new_conn == NULL) { - return ERR_MEM; - } - altcp_tcp_setup(new_conn, new_tpcb); - return listen_conn->accept(listen_conn->arg, new_conn, err); - } - return ERR_ARG; -} - -static err_t -altcp_tcp_connected(void *arg, struct tcp_pcb *tpcb, err_t err) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); - if (conn->connected) { - return conn->connected(conn->arg, conn, err); - } - } - return ERR_OK; -} - -static err_t -altcp_tcp_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); - if (conn->recv) { - return conn->recv(conn->arg, conn, p, err); - } - } - if (p != NULL) { - /* prevent memory leaks */ - pbuf_free(p); - } - return ERR_OK; -} - -static err_t -altcp_tcp_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); - if (conn->sent) { - return conn->sent(conn->arg, conn, len); - } - } - return ERR_OK; -} - -static err_t -altcp_tcp_poll(void *arg, struct tcp_pcb *tpcb) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); - if (conn->poll) { - return conn->poll(conn->arg, conn); - } - } - return ERR_OK; -} - -static void -altcp_tcp_err(void *arg, err_t err) -{ - struct altcp_pcb *conn = (struct altcp_pcb *)arg; - if (conn) { - conn->state = NULL; /* already freed */ - if (conn->err) { - conn->err(conn->arg, err); - } - altcp_free(conn); - } -} - -/* setup functions */ - -static void -altcp_tcp_remove_callbacks(struct tcp_pcb *tpcb) -{ - tcp_arg(tpcb, NULL); - tcp_recv(tpcb, NULL); - tcp_sent(tpcb, NULL); - tcp_err(tpcb, NULL); - tcp_poll(tpcb, NULL, tpcb->pollinterval); -} - -static void -altcp_tcp_setup_callbacks(struct altcp_pcb *conn, struct tcp_pcb *tpcb) -{ - tcp_arg(tpcb, conn); - tcp_recv(tpcb, altcp_tcp_recv); - tcp_sent(tpcb, altcp_tcp_sent); - tcp_err(tpcb, altcp_tcp_err); - /* tcp_poll is set when interval is set by application */ - /* listen is set totally different :-) */ -} - -static void -altcp_tcp_setup(struct altcp_pcb *conn, struct tcp_pcb *tpcb) -{ - altcp_tcp_setup_callbacks(conn, tpcb); - conn->state = tpcb; - conn->fns = &altcp_tcp_functions; -} - -struct altcp_pcb * -altcp_tcp_new_ip_type(u8_t ip_type) -{ - /* Allocate the tcp pcb first to invoke the priority handling code - if we're out of pcbs */ - struct tcp_pcb *tpcb = tcp_new_ip_type(ip_type); - if (tpcb != NULL) { - struct altcp_pcb *ret = altcp_alloc(); - if (ret != NULL) { - altcp_tcp_setup(ret, tpcb); - return ret; - } else { - /* altcp_pcb allocation failed -> free the tcp_pcb too */ - tcp_close(tpcb); - } - } - return NULL; -} - -/** altcp_tcp allocator function fitting to @ref altcp_allocator_t / @ref altcp_new. -* -* arg pointer is not used for TCP. -*/ -struct altcp_pcb * -altcp_tcp_alloc(void *arg, u8_t ip_type) -{ - LWIP_UNUSED_ARG(arg); - return altcp_tcp_new_ip_type(ip_type); -} - -struct altcp_pcb * -altcp_tcp_wrap(struct tcp_pcb *tpcb) -{ - if (tpcb != NULL) { - struct altcp_pcb *ret = altcp_alloc(); - if (ret != NULL) { - altcp_tcp_setup(ret, tpcb); - return ret; - } - } - return NULL; -} - - -/* "virtual" functions calling into tcp */ -static void -altcp_tcp_set_poll(struct altcp_pcb *conn, u8_t interval) -{ - if (conn != NULL) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - tcp_poll(pcb, altcp_tcp_poll, interval); - } -} - -static void -altcp_tcp_recved(struct altcp_pcb *conn, u16_t len) -{ - if (conn != NULL) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - tcp_recved(pcb, len); - } -} - -static err_t -altcp_tcp_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return ERR_VAL; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - return tcp_bind(pcb, ipaddr, port); -} - -static err_t -altcp_tcp_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return ERR_VAL; - } - ALTCP_TCP_ASSERT_CONN(conn); - conn->connected = connected; - pcb = (struct tcp_pcb *)conn->state; - return tcp_connect(pcb, ipaddr, port, altcp_tcp_connected); -} - -static struct altcp_pcb * -altcp_tcp_listen(struct altcp_pcb *conn, u8_t backlog, err_t *err) -{ - struct tcp_pcb *pcb; - struct tcp_pcb *lpcb; - if (conn == NULL) { - return NULL; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - lpcb = tcp_listen_with_backlog_and_err(pcb, backlog, err); - if (lpcb != NULL) { - conn->state = lpcb; - tcp_accept(lpcb, altcp_tcp_accept); - return conn; - } - return NULL; -} - -static void -altcp_tcp_abort(struct altcp_pcb *conn) -{ - if (conn != NULL) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - if (pcb) { - tcp_abort(pcb); - } - } -} - -static err_t -altcp_tcp_close(struct altcp_pcb *conn) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return ERR_VAL; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - if (pcb) { - err_t err; - tcp_poll_fn oldpoll = pcb->poll; - altcp_tcp_remove_callbacks(pcb); - err = tcp_close(pcb); - if (err != ERR_OK) { - /* not closed, set up all callbacks again */ - altcp_tcp_setup_callbacks(conn, pcb); - /* poll callback is not included in the above */ - tcp_poll(pcb, oldpoll, pcb->pollinterval); - return err; - } - conn->state = NULL; /* unsafe to reference pcb after tcp_close(). */ - } - altcp_free(conn); - return ERR_OK; -} - -static err_t -altcp_tcp_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return ERR_VAL; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - return tcp_shutdown(pcb, shut_rx, shut_tx); -} - -static err_t -altcp_tcp_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return ERR_VAL; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - return tcp_write(pcb, dataptr, len, apiflags); -} - -static err_t -altcp_tcp_output(struct altcp_pcb *conn) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return ERR_VAL; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - return tcp_output(pcb); -} - -static u16_t -altcp_tcp_mss(struct altcp_pcb *conn) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return 0; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - return tcp_mss(pcb); -} - -static u16_t -altcp_tcp_sndbuf(struct altcp_pcb *conn) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return 0; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - return tcp_sndbuf(pcb); -} - -static u16_t -altcp_tcp_sndqueuelen(struct altcp_pcb *conn) -{ - struct tcp_pcb *pcb; - if (conn == NULL) { - return 0; - } - ALTCP_TCP_ASSERT_CONN(conn); - pcb = (struct tcp_pcb *)conn->state; - return tcp_sndqueuelen(pcb); -} - -static void -altcp_tcp_nagle_disable(struct altcp_pcb *conn) -{ - if (conn && conn->state) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - tcp_nagle_disable(pcb); - } -} - -static void -altcp_tcp_nagle_enable(struct altcp_pcb *conn) -{ - if (conn && conn->state) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - tcp_nagle_enable(pcb); - } -} - -static int -altcp_tcp_nagle_disabled(struct altcp_pcb *conn) -{ - if (conn && conn->state) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - return tcp_nagle_disabled(pcb); - } - return 0; -} - -static void -altcp_tcp_setprio(struct altcp_pcb *conn, u8_t prio) -{ - if (conn != NULL) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - tcp_setprio(pcb, prio); - } -} - -static void -altcp_tcp_dealloc(struct altcp_pcb *conn) -{ - LWIP_UNUSED_ARG(conn); - ALTCP_TCP_ASSERT_CONN(conn); - /* no private state to clean up */ -} - -static err_t -altcp_tcp_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port) -{ - if (conn) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - return tcp_tcp_get_tcp_addrinfo(pcb, local, addr, port); - } - return ERR_VAL; -} - -static ip_addr_t * -altcp_tcp_get_ip(struct altcp_pcb *conn, int local) -{ - if (conn) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - if (pcb) { - if (local) { - return &pcb->local_ip; - } else { - return &pcb->remote_ip; - } - } - } - return NULL; -} - -static u16_t -altcp_tcp_get_port(struct altcp_pcb *conn, int local) -{ - if (conn) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - if (pcb) { - if (local) { - return pcb->local_port; - } else { - return pcb->remote_port; - } - } - } - return 0; -} - -#ifdef LWIP_DEBUG -static enum tcp_state -altcp_tcp_dbg_get_tcp_state(struct altcp_pcb *conn) -{ - if (conn) { - struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; - ALTCP_TCP_ASSERT_CONN(conn); - if (pcb) { - return pcb->state; - } - } - return CLOSED; -} -#endif -const struct altcp_functions altcp_tcp_functions = { - altcp_tcp_set_poll, - altcp_tcp_recved, - altcp_tcp_bind, - altcp_tcp_connect, - altcp_tcp_listen, - altcp_tcp_abort, - altcp_tcp_close, - altcp_tcp_shutdown, - altcp_tcp_write, - altcp_tcp_output, - altcp_tcp_mss, - altcp_tcp_sndbuf, - altcp_tcp_sndqueuelen, - altcp_tcp_nagle_disable, - altcp_tcp_nagle_enable, - altcp_tcp_nagle_disabled, - altcp_tcp_setprio, - altcp_tcp_dealloc, - altcp_tcp_get_tcp_addrinfo, - altcp_tcp_get_ip, - altcp_tcp_get_port -#ifdef LWIP_DEBUG - , altcp_tcp_dbg_get_tcp_state -#endif -}; - -#endif /* LWIP_ALTCP */ +/** + * @file + * Application layered TCP connection API (to be used from TCPIP thread)\n + * This interface mimics the tcp callback API to the application while preventing + * direct linking (much like virtual functions). + * This way, an application can make use of other application layer protocols + * on top of TCP without knowing the details (e.g. TLS, proxy connection). + * + * This file contains the base implementation calling into tcp. + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/altcp.h" +#include "lwip/altcp_tcp.h" +#include "lwip/priv/altcp_priv.h" +#include "lwip/tcp.h" +#include "lwip/mem.h" + +#include + +#define ALTCP_TCP_ASSERT_CONN(conn) do { \ + LWIP_ASSERT("conn->inner_conn == NULL", (conn)->inner_conn == NULL); \ + LWIP_UNUSED_ARG(conn); /* for LWIP_NOASSERT */ } while(0) +#define ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb) do { \ + LWIP_ASSERT("pcb mismatch", (conn)->state == tpcb); \ + LWIP_UNUSED_ARG(tpcb); /* for LWIP_NOASSERT */ \ + ALTCP_TCP_ASSERT_CONN(conn); } while(0) + + +/* Variable prototype, the actual declaration is at the end of this file + since it contains pointers to static functions declared here */ +extern const struct altcp_functions altcp_tcp_functions; + +static void altcp_tcp_setup(struct altcp_pcb *conn, struct tcp_pcb *tpcb); + +/* callback functions for TCP */ +static err_t +altcp_tcp_accept(void *arg, struct tcp_pcb *new_tpcb, err_t err) +{ + struct altcp_pcb *listen_conn = (struct altcp_pcb *)arg; + if (listen_conn && listen_conn->accept) { + /* create a new altcp_conn to pass to the next 'accept' callback */ + struct altcp_pcb *new_conn = altcp_alloc(); + if (new_conn == NULL) { + return ERR_MEM; + } + altcp_tcp_setup(new_conn, new_tpcb); + return listen_conn->accept(listen_conn->arg, new_conn, err); + } + return ERR_ARG; +} + +static err_t +altcp_tcp_connected(void *arg, struct tcp_pcb *tpcb, err_t err) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); + if (conn->connected) { + return conn->connected(conn->arg, conn, err); + } + } + return ERR_OK; +} + +static err_t +altcp_tcp_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); + if (conn->recv) { + return conn->recv(conn->arg, conn, p, err); + } + } + if (p != NULL) { + /* prevent memory leaks */ + pbuf_free(p); + } + return ERR_OK; +} + +static err_t +altcp_tcp_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); + if (conn->sent) { + return conn->sent(conn->arg, conn, len); + } + } + return ERR_OK; +} + +static err_t +altcp_tcp_poll(void *arg, struct tcp_pcb *tpcb) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + ALTCP_TCP_ASSERT_CONN_PCB(conn, tpcb); + if (conn->poll) { + return conn->poll(conn->arg, conn); + } + } + return ERR_OK; +} + +static void +altcp_tcp_err(void *arg, err_t err) +{ + struct altcp_pcb *conn = (struct altcp_pcb *)arg; + if (conn) { + conn->state = NULL; /* already freed */ + if (conn->err) { + conn->err(conn->arg, err); + } + altcp_free(conn); + } +} + +/* setup functions */ + +static void +altcp_tcp_remove_callbacks(struct tcp_pcb *tpcb) +{ + tcp_arg(tpcb, NULL); + tcp_recv(tpcb, NULL); + tcp_sent(tpcb, NULL); + tcp_err(tpcb, NULL); + tcp_poll(tpcb, NULL, tpcb->pollinterval); +} + +static void +altcp_tcp_setup_callbacks(struct altcp_pcb *conn, struct tcp_pcb *tpcb) +{ + tcp_arg(tpcb, conn); + tcp_recv(tpcb, altcp_tcp_recv); + tcp_sent(tpcb, altcp_tcp_sent); + tcp_err(tpcb, altcp_tcp_err); + /* tcp_poll is set when interval is set by application */ + /* listen is set totally different :-) */ +} + +static void +altcp_tcp_setup(struct altcp_pcb *conn, struct tcp_pcb *tpcb) +{ + altcp_tcp_setup_callbacks(conn, tpcb); + conn->state = tpcb; + conn->fns = &altcp_tcp_functions; +} + +struct altcp_pcb * +altcp_tcp_new_ip_type(u8_t ip_type) +{ + /* Allocate the tcp pcb first to invoke the priority handling code + if we're out of pcbs */ + struct tcp_pcb *tpcb = tcp_new_ip_type(ip_type); + if (tpcb != NULL) { + struct altcp_pcb *ret = altcp_alloc(); + if (ret != NULL) { + altcp_tcp_setup(ret, tpcb); + return ret; + } else { + /* altcp_pcb allocation failed -> free the tcp_pcb too */ + tcp_close(tpcb); + } + } + return NULL; +} + +/** altcp_tcp allocator function fitting to @ref altcp_allocator_t / @ref altcp_new. +* +* arg pointer is not used for TCP. +*/ +struct altcp_pcb * +altcp_tcp_alloc(void *arg, u8_t ip_type) +{ + LWIP_UNUSED_ARG(arg); + return altcp_tcp_new_ip_type(ip_type); +} + +struct altcp_pcb * +altcp_tcp_wrap(struct tcp_pcb *tpcb) +{ + if (tpcb != NULL) { + struct altcp_pcb *ret = altcp_alloc(); + if (ret != NULL) { + altcp_tcp_setup(ret, tpcb); + return ret; + } + } + return NULL; +} + + +/* "virtual" functions calling into tcp */ +static void +altcp_tcp_set_poll(struct altcp_pcb *conn, u8_t interval) +{ + if (conn != NULL) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + tcp_poll(pcb, altcp_tcp_poll, interval); + } +} + +static void +altcp_tcp_recved(struct altcp_pcb *conn, u16_t len) +{ + if (conn != NULL) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + tcp_recved(pcb, len); + } +} + +static err_t +altcp_tcp_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return ERR_VAL; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + return tcp_bind(pcb, ipaddr, port); +} + +static err_t +altcp_tcp_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return ERR_VAL; + } + ALTCP_TCP_ASSERT_CONN(conn); + conn->connected = connected; + pcb = (struct tcp_pcb *)conn->state; + return tcp_connect(pcb, ipaddr, port, altcp_tcp_connected); +} + +static struct altcp_pcb * +altcp_tcp_listen(struct altcp_pcb *conn, u8_t backlog, err_t *err) +{ + struct tcp_pcb *pcb; + struct tcp_pcb *lpcb; + if (conn == NULL) { + return NULL; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + lpcb = tcp_listen_with_backlog_and_err(pcb, backlog, err); + if (lpcb != NULL) { + conn->state = lpcb; + tcp_accept(lpcb, altcp_tcp_accept); + return conn; + } + return NULL; +} + +static void +altcp_tcp_abort(struct altcp_pcb *conn) +{ + if (conn != NULL) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + if (pcb) { + tcp_abort(pcb); + } + } +} + +static err_t +altcp_tcp_close(struct altcp_pcb *conn) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return ERR_VAL; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + if (pcb) { + err_t err; + tcp_poll_fn oldpoll = pcb->poll; + altcp_tcp_remove_callbacks(pcb); + err = tcp_close(pcb); + if (err != ERR_OK) { + /* not closed, set up all callbacks again */ + altcp_tcp_setup_callbacks(conn, pcb); + /* poll callback is not included in the above */ + tcp_poll(pcb, oldpoll, pcb->pollinterval); + return err; + } + conn->state = NULL; /* unsafe to reference pcb after tcp_close(). */ + } + altcp_free(conn); + return ERR_OK; +} + +static err_t +altcp_tcp_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return ERR_VAL; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + return tcp_shutdown(pcb, shut_rx, shut_tx); +} + +static err_t +altcp_tcp_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return ERR_VAL; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + return tcp_write(pcb, dataptr, len, apiflags); +} + +static err_t +altcp_tcp_output(struct altcp_pcb *conn) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return ERR_VAL; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + return tcp_output(pcb); +} + +static u16_t +altcp_tcp_mss(struct altcp_pcb *conn) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return 0; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + return tcp_mss(pcb); +} + +static u16_t +altcp_tcp_sndbuf(struct altcp_pcb *conn) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return 0; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + return tcp_sndbuf(pcb); +} + +static u16_t +altcp_tcp_sndqueuelen(struct altcp_pcb *conn) +{ + struct tcp_pcb *pcb; + if (conn == NULL) { + return 0; + } + ALTCP_TCP_ASSERT_CONN(conn); + pcb = (struct tcp_pcb *)conn->state; + return tcp_sndqueuelen(pcb); +} + +static void +altcp_tcp_nagle_disable(struct altcp_pcb *conn) +{ + if (conn && conn->state) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + tcp_nagle_disable(pcb); + } +} + +static void +altcp_tcp_nagle_enable(struct altcp_pcb *conn) +{ + if (conn && conn->state) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + tcp_nagle_enable(pcb); + } +} + +static int +altcp_tcp_nagle_disabled(struct altcp_pcb *conn) +{ + if (conn && conn->state) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + return tcp_nagle_disabled(pcb); + } + return 0; +} + +static void +altcp_tcp_setprio(struct altcp_pcb *conn, u8_t prio) +{ + if (conn != NULL) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + tcp_setprio(pcb, prio); + } +} + +static void +altcp_tcp_dealloc(struct altcp_pcb *conn) +{ + LWIP_UNUSED_ARG(conn); + ALTCP_TCP_ASSERT_CONN(conn); + /* no private state to clean up */ +} + +static err_t +altcp_tcp_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port) +{ + if (conn) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + return tcp_tcp_get_tcp_addrinfo(pcb, local, addr, port); + } + return ERR_VAL; +} + +static ip_addr_t * +altcp_tcp_get_ip(struct altcp_pcb *conn, int local) +{ + if (conn) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + if (pcb) { + if (local) { + return &pcb->local_ip; + } else { + return &pcb->remote_ip; + } + } + } + return NULL; +} + +static u16_t +altcp_tcp_get_port(struct altcp_pcb *conn, int local) +{ + if (conn) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + if (pcb) { + if (local) { + return pcb->local_port; + } else { + return pcb->remote_port; + } + } + } + return 0; +} + +#ifdef LWIP_DEBUG +static enum tcp_state +altcp_tcp_dbg_get_tcp_state(struct altcp_pcb *conn) +{ + if (conn) { + struct tcp_pcb *pcb = (struct tcp_pcb *)conn->state; + ALTCP_TCP_ASSERT_CONN(conn); + if (pcb) { + return pcb->state; + } + } + return CLOSED; +} +#endif +const struct altcp_functions altcp_tcp_functions = { + altcp_tcp_set_poll, + altcp_tcp_recved, + altcp_tcp_bind, + altcp_tcp_connect, + altcp_tcp_listen, + altcp_tcp_abort, + altcp_tcp_close, + altcp_tcp_shutdown, + altcp_tcp_write, + altcp_tcp_output, + altcp_tcp_mss, + altcp_tcp_sndbuf, + altcp_tcp_sndqueuelen, + altcp_tcp_nagle_disable, + altcp_tcp_nagle_enable, + altcp_tcp_nagle_disabled, + altcp_tcp_setprio, + altcp_tcp_dealloc, + altcp_tcp_get_tcp_addrinfo, + altcp_tcp_get_ip, + altcp_tcp_get_port +#ifdef LWIP_DEBUG + , altcp_tcp_dbg_get_tcp_state +#endif +}; + +#endif /* LWIP_ALTCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/def.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/def.c index 004a5288..9da36fee 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/def.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/def.c @@ -1,240 +1,240 @@ -/** - * @file - * Common functions used throughout the stack. - * - * These are reference implementations of the byte swapping functions. - * Again with the aim of being simple, correct and fully portable. - * Byte swapping is the second thing you would want to optimize. You will - * need to port it to your architecture and in your cc.h: - * - * \#define lwip_htons(x) your_htons - * \#define lwip_htonl(x) your_htonl - * - * Note lwip_ntohs() and lwip_ntohl() are merely references to the htonx counterparts. - * - * If you \#define them to htons() and htonl(), you should - * \#define LWIP_DONT_PROVIDE_BYTEORDER_FUNCTIONS to prevent lwIP from - * defining htonx/ntohx compatibility macros. - - * @defgroup sys_nonstandard Non-standard functions - * @ingroup sys_layer - * lwIP provides default implementations for non-standard functions. - * These can be mapped to OS functions to reduce code footprint if desired. - * All defines related to this section must not be placed in lwipopts.h, - * but in arch/cc.h! - * These options cannot be \#defined in lwipopts.h since they are not options - * of lwIP itself, but options of the lwIP port to your system. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#include "lwip/opt.h" -#include "lwip/def.h" - -#include - -#if BYTE_ORDER == LITTLE_ENDIAN - -#if !defined(lwip_htons) -/** - * Convert an u16_t from host- to network byte order. - * - * @param n u16_t in host byte order - * @return n in network byte order - */ -u16_t -lwip_htons(u16_t n) -{ - return PP_HTONS(n); -} -#endif /* lwip_htons */ - -#if !defined(lwip_htonl) -/** - * Convert an u32_t from host- to network byte order. - * - * @param n u32_t in host byte order - * @return n in network byte order - */ -u32_t -lwip_htonl(u32_t n) -{ - return PP_HTONL(n); -} -#endif /* lwip_htonl */ - -#endif /* BYTE_ORDER == LITTLE_ENDIAN */ - -#ifndef lwip_strnstr -/** - * @ingroup sys_nonstandard - * lwIP default implementation for strnstr() non-standard function. - * This can be \#defined to strnstr() depending on your platform port. - */ -char * -lwip_strnstr(const char *buffer, const char *token, size_t n) -{ - const char *p; - size_t tokenlen = strlen(token); - if (tokenlen == 0) { - return LWIP_CONST_CAST(char *, buffer); - } - for (p = buffer; *p && (p + tokenlen <= buffer + n); p++) { - if ((*p == *token) && (strncmp(p, token, tokenlen) == 0)) { - return LWIP_CONST_CAST(char *, p); - } - } - return NULL; -} -#endif - -#ifndef lwip_stricmp -/** - * @ingroup sys_nonstandard - * lwIP default implementation for stricmp() non-standard function. - * This can be \#defined to stricmp() depending on your platform port. - */ -int -lwip_stricmp(const char *str1, const char *str2) -{ - char c1, c2; - - do { - c1 = *str1++; - c2 = *str2++; - if (c1 != c2) { - char c1_upc = c1 | 0x20; - if ((c1_upc >= 'a') && (c1_upc <= 'z')) { - /* characters are not equal an one is in the alphabet range: - downcase both chars and check again */ - char c2_upc = c2 | 0x20; - if (c1_upc != c2_upc) { - /* still not equal */ - /* don't care for < or > */ - return 1; - } - } else { - /* characters are not equal but none is in the alphabet range */ - return 1; - } - } - } while (c1 != 0); - return 0; -} -#endif - -#ifndef lwip_strnicmp -/** - * @ingroup sys_nonstandard - * lwIP default implementation for strnicmp() non-standard function. - * This can be \#defined to strnicmp() depending on your platform port. - */ -int -lwip_strnicmp(const char *str1, const char *str2, size_t len) -{ - char c1, c2; - - do { - c1 = *str1++; - c2 = *str2++; - if (c1 != c2) { - char c1_upc = c1 | 0x20; - if ((c1_upc >= 'a') && (c1_upc <= 'z')) { - /* characters are not equal an one is in the alphabet range: - downcase both chars and check again */ - char c2_upc = c2 | 0x20; - if (c1_upc != c2_upc) { - /* still not equal */ - /* don't care for < or > */ - return 1; - } - } else { - /* characters are not equal but none is in the alphabet range */ - return 1; - } - } - len--; - } while ((len != 0) && (c1 != 0)); - return 0; -} -#endif - -#ifndef lwip_itoa -/** - * @ingroup sys_nonstandard - * lwIP default implementation for itoa() non-standard function. - * This can be \#defined to itoa() or snprintf(result, bufsize, "%d", number) depending on your platform port. - */ -void -lwip_itoa(char *result, size_t bufsize, int number) -{ - char *res = result; - char *tmp = result + bufsize - 1; - int n = (number >= 0) ? number : -number; - - /* handle invalid bufsize */ - if (bufsize < 2) { - if (bufsize == 1) { - *result = 0; - } - return; - } - - /* First, add sign */ - if (number < 0) { - *res++ = '-'; - } - /* Then create the string from the end and stop if buffer full, - and ensure output string is zero terminated */ - *tmp = 0; - while ((n != 0) && (tmp > res)) { - char val = (char)('0' + (n % 10)); - tmp--; - *tmp = val; - n = n / 10; - } - if (n) { - /* buffer is too small */ - *result = 0; - return; - } - if (*tmp == 0) { - /* Nothing added? */ - *res++ = '0'; - *res++ = 0; - return; - } - /* move from temporary buffer to output buffer (sign is not moved) */ - memmove(res, tmp, (size_t)((result + bufsize) - tmp)); -} -#endif +/** + * @file + * Common functions used throughout the stack. + * + * These are reference implementations of the byte swapping functions. + * Again with the aim of being simple, correct and fully portable. + * Byte swapping is the second thing you would want to optimize. You will + * need to port it to your architecture and in your cc.h: + * + * \#define lwip_htons(x) your_htons + * \#define lwip_htonl(x) your_htonl + * + * Note lwip_ntohs() and lwip_ntohl() are merely references to the htonx counterparts. + * + * If you \#define them to htons() and htonl(), you should + * \#define LWIP_DONT_PROVIDE_BYTEORDER_FUNCTIONS to prevent lwIP from + * defining htonx/ntohx compatibility macros. + + * @defgroup sys_nonstandard Non-standard functions + * @ingroup sys_layer + * lwIP provides default implementations for non-standard functions. + * These can be mapped to OS functions to reduce code footprint if desired. + * All defines related to this section must not be placed in lwipopts.h, + * but in arch/cc.h! + * These options cannot be \#defined in lwipopts.h since they are not options + * of lwIP itself, but options of the lwIP port to your system. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#include "lwip/opt.h" +#include "lwip/def.h" + +#include + +#if BYTE_ORDER == LITTLE_ENDIAN + +#if !defined(lwip_htons) +/** + * Convert an u16_t from host- to network byte order. + * + * @param n u16_t in host byte order + * @return n in network byte order + */ +u16_t +lwip_htons(u16_t n) +{ + return PP_HTONS(n); +} +#endif /* lwip_htons */ + +#if !defined(lwip_htonl) +/** + * Convert an u32_t from host- to network byte order. + * + * @param n u32_t in host byte order + * @return n in network byte order + */ +u32_t +lwip_htonl(u32_t n) +{ + return PP_HTONL(n); +} +#endif /* lwip_htonl */ + +#endif /* BYTE_ORDER == LITTLE_ENDIAN */ + +#ifndef lwip_strnstr +/** + * @ingroup sys_nonstandard + * lwIP default implementation for strnstr() non-standard function. + * This can be \#defined to strnstr() depending on your platform port. + */ +char * +lwip_strnstr(const char *buffer, const char *token, size_t n) +{ + const char *p; + size_t tokenlen = strlen(token); + if (tokenlen == 0) { + return LWIP_CONST_CAST(char *, buffer); + } + for (p = buffer; *p && (p + tokenlen <= buffer + n); p++) { + if ((*p == *token) && (strncmp(p, token, tokenlen) == 0)) { + return LWIP_CONST_CAST(char *, p); + } + } + return NULL; +} +#endif + +#ifndef lwip_stricmp +/** + * @ingroup sys_nonstandard + * lwIP default implementation for stricmp() non-standard function. + * This can be \#defined to stricmp() depending on your platform port. + */ +int +lwip_stricmp(const char *str1, const char *str2) +{ + char c1, c2; + + do { + c1 = *str1++; + c2 = *str2++; + if (c1 != c2) { + char c1_upc = c1 | 0x20; + if ((c1_upc >= 'a') && (c1_upc <= 'z')) { + /* characters are not equal an one is in the alphabet range: + downcase both chars and check again */ + char c2_upc = c2 | 0x20; + if (c1_upc != c2_upc) { + /* still not equal */ + /* don't care for < or > */ + return 1; + } + } else { + /* characters are not equal but none is in the alphabet range */ + return 1; + } + } + } while (c1 != 0); + return 0; +} +#endif + +#ifndef lwip_strnicmp +/** + * @ingroup sys_nonstandard + * lwIP default implementation for strnicmp() non-standard function. + * This can be \#defined to strnicmp() depending on your platform port. + */ +int +lwip_strnicmp(const char *str1, const char *str2, size_t len) +{ + char c1, c2; + + do { + c1 = *str1++; + c2 = *str2++; + if (c1 != c2) { + char c1_upc = c1 | 0x20; + if ((c1_upc >= 'a') && (c1_upc <= 'z')) { + /* characters are not equal an one is in the alphabet range: + downcase both chars and check again */ + char c2_upc = c2 | 0x20; + if (c1_upc != c2_upc) { + /* still not equal */ + /* don't care for < or > */ + return 1; + } + } else { + /* characters are not equal but none is in the alphabet range */ + return 1; + } + } + len--; + } while ((len != 0) && (c1 != 0)); + return 0; +} +#endif + +#ifndef lwip_itoa +/** + * @ingroup sys_nonstandard + * lwIP default implementation for itoa() non-standard function. + * This can be \#defined to itoa() or snprintf(result, bufsize, "%d", number) depending on your platform port. + */ +void +lwip_itoa(char *result, size_t bufsize, int number) +{ + char *res = result; + char *tmp = result + bufsize - 1; + int n = (number >= 0) ? number : -number; + + /* handle invalid bufsize */ + if (bufsize < 2) { + if (bufsize == 1) { + *result = 0; + } + return; + } + + /* First, add sign */ + if (number < 0) { + *res++ = '-'; + } + /* Then create the string from the end and stop if buffer full, + and ensure output string is zero terminated */ + *tmp = 0; + while ((n != 0) && (tmp > res)) { + char val = (char)('0' + (n % 10)); + tmp--; + *tmp = val; + n = n / 10; + } + if (n) { + /* buffer is too small */ + *result = 0; + return; + } + if (*tmp == 0) { + /* Nothing added? */ + *res++ = '0'; + *res++ = 0; + return; + } + /* move from temporary buffer to output buffer (sign is not moved) */ + memmove(res, tmp, (size_t)((result + bufsize) - tmp)); +} +#endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/dns.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/dns.c index 737b3393..9d2f61ed 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/dns.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/dns.c @@ -1,1631 +1,1631 @@ -/** - * @file - * DNS - host name to IP address resolver. - * - * @defgroup dns DNS - * @ingroup callbackstyle_api - * - * Implements a DNS host name to IP address resolver. - * - * The lwIP DNS resolver functions are used to lookup a host name and - * map it to a numerical IP address. It maintains a list of resolved - * hostnames that can be queried with the dns_lookup() function. - * New hostnames can be resolved using the dns_query() function. - * - * The lwIP version of the resolver also adds a non-blocking version of - * gethostbyname() that will work with a raw API application. This function - * checks for an IP address string first and converts it if it is valid. - * gethostbyname() then does a dns_lookup() to see if the name is - * already in the table. If so, the IP is returned. If not, a query is - * issued and the function returns with a ERR_INPROGRESS status. The app - * using the dns client must then go into a waiting state. - * - * Once a hostname has been resolved (or found to be non-existent), - * the resolver code calls a specified callback function (which - * must be implemented by the module that uses the resolver). - * - * Multicast DNS queries are supported for names ending on ".local". - * However, only "One-Shot Multicast DNS Queries" are supported (RFC 6762 - * chapter 5.1), this is not a fully compliant implementation of continuous - * mDNS querying! - * - * All functions must be called from TCPIP thread. - * - * @see DNS_MAX_SERVERS - * @see LWIP_DHCP_MAX_DNS_SERVERS - * @see @ref netconn_common for thread-safe access. - */ - -/* - * Port to lwIP from uIP - * by Jim Pettinato April 2007 - * - * security fixes and more by Simon Goldschmidt - * - * uIP version Copyright (c) 2002-2003, Adam Dunkels. - * 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. The name of the author may not be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - */ - -/*----------------------------------------------------------------------------- - * RFC 1035 - Domain names - implementation and specification - * RFC 2181 - Clarifications to the DNS Specification - *----------------------------------------------------------------------------*/ - -/** @todo: define good default values (rfc compliance) */ -/** @todo: improve answer parsing, more checkings... */ -/** @todo: check RFC1035 - 7.3. Processing responses */ -/** @todo: one-shot mDNS: dual-stack fallback to another IP version */ - -/*----------------------------------------------------------------------------- - * Includes - *----------------------------------------------------------------------------*/ - -#include "lwip/opt.h" - -#if LWIP_DNS /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/def.h" -#include "lwip/udp.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/dns.h" -#include "lwip/prot/dns.h" - -#include - -/** Random generator function to create random TXIDs and source ports for queries */ -#ifndef DNS_RAND_TXID -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_XID) != 0) -#define DNS_RAND_TXID LWIP_RAND -#else -static u16_t dns_txid; -#define DNS_RAND_TXID() (++dns_txid) -#endif -#endif - -/** Limits the source port to be >= 1024 by default */ -#ifndef DNS_PORT_ALLOWED -#define DNS_PORT_ALLOWED(port) ((port) >= 1024) -#endif - -/** DNS resource record max. TTL (one week as default) */ -#ifndef DNS_MAX_TTL -#define DNS_MAX_TTL 604800 -#elif DNS_MAX_TTL > 0x7FFFFFFF -#error DNS_MAX_TTL must be a positive 32-bit value -#endif - -#if DNS_TABLE_SIZE > 255 -#error DNS_TABLE_SIZE must fit into an u8_t -#endif -#if DNS_MAX_SERVERS > 255 -#error DNS_MAX_SERVERS must fit into an u8_t -#endif - -/* The number of parallel requests (i.e. calls to dns_gethostbyname - * that cannot be answered from the DNS table. - * This is set to the table size by default. - */ -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) -#ifndef DNS_MAX_REQUESTS -#define DNS_MAX_REQUESTS DNS_TABLE_SIZE -#else -#if DNS_MAX_REQUESTS > 255 -#error DNS_MAX_REQUESTS must fit into an u8_t -#endif -#endif -#else -/* In this configuration, both arrays have to have the same size and are used - * like one entry (used/free) */ -#define DNS_MAX_REQUESTS DNS_TABLE_SIZE -#endif - -/* The number of UDP source ports used in parallel */ -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) -#ifndef DNS_MAX_SOURCE_PORTS -#define DNS_MAX_SOURCE_PORTS DNS_MAX_REQUESTS -#else -#if DNS_MAX_SOURCE_PORTS > 255 -#error DNS_MAX_SOURCE_PORTS must fit into an u8_t -#endif -#endif -#else -#ifdef DNS_MAX_SOURCE_PORTS -#undef DNS_MAX_SOURCE_PORTS -#endif -#define DNS_MAX_SOURCE_PORTS 1 -#endif - -#if LWIP_IPV4 && LWIP_IPV6 -#define LWIP_DNS_ADDRTYPE_IS_IPV6(t) (((t) == LWIP_DNS_ADDRTYPE_IPV6_IPV4) || ((t) == LWIP_DNS_ADDRTYPE_IPV6)) -#define LWIP_DNS_ADDRTYPE_MATCH_IP(t, ip) (IP_IS_V6_VAL(ip) ? LWIP_DNS_ADDRTYPE_IS_IPV6(t) : (!LWIP_DNS_ADDRTYPE_IS_IPV6(t))) -#define LWIP_DNS_ADDRTYPE_ARG(x) , x -#define LWIP_DNS_ADDRTYPE_ARG_OR_ZERO(x) x -#define LWIP_DNS_SET_ADDRTYPE(x, y) do { x = y; } while(0) -#else -#if LWIP_IPV6 -#define LWIP_DNS_ADDRTYPE_IS_IPV6(t) 1 -#else -#define LWIP_DNS_ADDRTYPE_IS_IPV6(t) 0 -#endif -#define LWIP_DNS_ADDRTYPE_MATCH_IP(t, ip) 1 -#define LWIP_DNS_ADDRTYPE_ARG(x) -#define LWIP_DNS_ADDRTYPE_ARG_OR_ZERO(x) 0 -#define LWIP_DNS_SET_ADDRTYPE(x, y) -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - -#if LWIP_DNS_SUPPORT_MDNS_QUERIES -#define LWIP_DNS_ISMDNS_ARG(x) , x -#else -#define LWIP_DNS_ISMDNS_ARG(x) -#endif - -/** DNS query message structure. - No packing needed: only used locally on the stack. */ -struct dns_query { - /* DNS query record starts with either a domain name or a pointer - to a name already present somewhere in the packet. */ - u16_t type; - u16_t cls; -}; -#define SIZEOF_DNS_QUERY 4 - -/** DNS answer message structure. - No packing needed: only used locally on the stack. */ -struct dns_answer { - /* DNS answer record starts with either a domain name or a pointer - to a name already present somewhere in the packet. */ - u16_t type; - u16_t cls; - u32_t ttl; - u16_t len; -}; -#define SIZEOF_DNS_ANSWER 10 -/* maximum allowed size for the struct due to non-packed */ -#define SIZEOF_DNS_ANSWER_ASSERT 12 - -/* DNS table entry states */ -typedef enum { - DNS_STATE_UNUSED = 0, - DNS_STATE_NEW = 1, - DNS_STATE_ASKING = 2, - DNS_STATE_DONE = 3 -} dns_state_enum_t; - -/** DNS table entry */ -struct dns_table_entry { - u32_t ttl; - ip_addr_t ipaddr; - u16_t txid; - u8_t state; - u8_t server_idx; - u8_t tmr; - u8_t retries; - u8_t seqno; -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) - u8_t pcb_idx; -#endif - char name[DNS_MAX_NAME_LENGTH]; -#if LWIP_IPV4 && LWIP_IPV6 - u8_t reqaddrtype; -#endif /* LWIP_IPV4 && LWIP_IPV6 */ -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - u8_t is_mdns; -#endif -}; - -/** DNS request table entry: used when dns_gehostbyname cannot answer the - * request from the DNS table */ -struct dns_req_entry { - /* pointer to callback on DNS query done */ - dns_found_callback found; - /* argument passed to the callback function */ - void *arg; -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) - u8_t dns_table_idx; -#endif -#if LWIP_IPV4 && LWIP_IPV6 - u8_t reqaddrtype; -#endif /* LWIP_IPV4 && LWIP_IPV6 */ -}; - -#if DNS_LOCAL_HOSTLIST - -#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC -/** Local host-list. For hostnames in this list, no - * external name resolution is performed */ -static struct local_hostlist_entry *local_hostlist_dynamic; -#else /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - -/** Defining this allows the local_hostlist_static to be placed in a different - * linker section (e.g. FLASH) */ -#ifndef DNS_LOCAL_HOSTLIST_STORAGE_PRE -#define DNS_LOCAL_HOSTLIST_STORAGE_PRE static -#endif /* DNS_LOCAL_HOSTLIST_STORAGE_PRE */ -/** Defining this allows the local_hostlist_static to be placed in a different - * linker section (e.g. FLASH) */ -#ifndef DNS_LOCAL_HOSTLIST_STORAGE_POST -#define DNS_LOCAL_HOSTLIST_STORAGE_POST -#endif /* DNS_LOCAL_HOSTLIST_STORAGE_POST */ -DNS_LOCAL_HOSTLIST_STORAGE_PRE struct local_hostlist_entry local_hostlist_static[] - DNS_LOCAL_HOSTLIST_STORAGE_POST = DNS_LOCAL_HOSTLIST_INIT; - -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - -static void dns_init_local(void); -static err_t dns_lookup_local(const char *hostname, ip_addr_t *addr LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype)); -#endif /* DNS_LOCAL_HOSTLIST */ - - -/* forward declarations */ -static void dns_recv(void *s, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); -static void dns_check_entries(void); -static void dns_call_found(u8_t idx, ip_addr_t *addr); - -/*----------------------------------------------------------------------------- - * Globals - *----------------------------------------------------------------------------*/ - -/* DNS variables */ -static struct udp_pcb *dns_pcbs[DNS_MAX_SOURCE_PORTS]; -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) -static u8_t dns_last_pcb_idx; -#endif -static u8_t dns_seqno; -static struct dns_table_entry dns_table[DNS_TABLE_SIZE]; -static struct dns_req_entry dns_requests[DNS_MAX_REQUESTS]; -static ip_addr_t dns_servers[DNS_MAX_SERVERS]; - -#if LWIP_IPV4 -const ip_addr_t dns_mquery_v4group = DNS_MQUERY_IPV4_GROUP_INIT; -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 -const ip_addr_t dns_mquery_v6group = DNS_MQUERY_IPV6_GROUP_INIT; -#endif /* LWIP_IPV6 */ - -/** - * Initialize the resolver: set up the UDP pcb and configure the default server - * (if DNS_SERVER_ADDRESS is set). - */ -void -dns_init(void) -{ -#ifdef DNS_SERVER_ADDRESS - /* initialize default DNS server address */ - ip_addr_t dnsserver; - DNS_SERVER_ADDRESS(&dnsserver); - dns_setserver(0, &dnsserver); -#endif /* DNS_SERVER_ADDRESS */ - - LWIP_ASSERT("sanity check SIZEOF_DNS_QUERY", - sizeof(struct dns_query) == SIZEOF_DNS_QUERY); - LWIP_ASSERT("sanity check SIZEOF_DNS_ANSWER", - sizeof(struct dns_answer) <= SIZEOF_DNS_ANSWER_ASSERT); - - LWIP_DEBUGF(DNS_DEBUG, ("dns_init: initializing\n")); - - /* if dns client not yet initialized... */ -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) == 0) - if (dns_pcbs[0] == NULL) { - dns_pcbs[0] = udp_new_ip_type(IPADDR_TYPE_ANY); - LWIP_ASSERT("dns_pcbs[0] != NULL", dns_pcbs[0] != NULL); - - /* initialize DNS table not needed (initialized to zero since it is a - * global variable) */ - LWIP_ASSERT("For implicit initialization to work, DNS_STATE_UNUSED needs to be 0", - DNS_STATE_UNUSED == 0); - - /* initialize DNS client */ - udp_bind(dns_pcbs[0], IP_ANY_TYPE, 0); - udp_recv(dns_pcbs[0], dns_recv, NULL); - } -#endif - -#if DNS_LOCAL_HOSTLIST - dns_init_local(); -#endif -} - -/** - * @ingroup dns - * Initialize one of the DNS servers. - * - * @param numdns the index of the DNS server to set must be < DNS_MAX_SERVERS - * @param dnsserver IP address of the DNS server to set - */ -void -dns_setserver(u8_t numdns, const ip_addr_t *dnsserver) -{ - if (numdns < DNS_MAX_SERVERS) { - if (dnsserver != NULL) { - dns_servers[numdns] = (*dnsserver); - } else { - dns_servers[numdns] = *IP_ADDR_ANY; - } - } -} - -/** - * @ingroup dns - * Obtain one of the currently configured DNS server. - * - * @param numdns the index of the DNS server - * @return IP address of the indexed DNS server or "ip_addr_any" if the DNS - * server has not been configured. - */ -const ip_addr_t * -dns_getserver(u8_t numdns) -{ - if (numdns < DNS_MAX_SERVERS) { - return &dns_servers[numdns]; - } else { - return IP_ADDR_ANY; - } -} - -/** - * The DNS resolver client timer - handle retries and timeouts and should - * be called every DNS_TMR_INTERVAL milliseconds (every second by default). - */ -void -dns_tmr(void) -{ - LWIP_DEBUGF(DNS_DEBUG, ("dns_tmr: dns_check_entries\n")); - dns_check_entries(); -} - -#if DNS_LOCAL_HOSTLIST -static void -dns_init_local(void) -{ -#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC && defined(DNS_LOCAL_HOSTLIST_INIT) - size_t i; - struct local_hostlist_entry *entry; - /* Dynamic: copy entries from DNS_LOCAL_HOSTLIST_INIT to list */ - struct local_hostlist_entry local_hostlist_init[] = DNS_LOCAL_HOSTLIST_INIT; - size_t namelen; - for (i = 0; i < LWIP_ARRAYSIZE(local_hostlist_init); i++) { - struct local_hostlist_entry *init_entry = &local_hostlist_init[i]; - LWIP_ASSERT("invalid host name (NULL)", init_entry->name != NULL); - namelen = strlen(init_entry->name); - LWIP_ASSERT("namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN", namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN); - entry = (struct local_hostlist_entry *)memp_malloc(MEMP_LOCALHOSTLIST); - LWIP_ASSERT("mem-error in dns_init_local", entry != NULL); - if (entry != NULL) { - char *entry_name = (char *)entry + sizeof(struct local_hostlist_entry); - MEMCPY(entry_name, init_entry->name, namelen); - entry_name[namelen] = 0; - entry->name = entry_name; - entry->addr = init_entry->addr; - entry->next = local_hostlist_dynamic; - local_hostlist_dynamic = entry; - } - } -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC && defined(DNS_LOCAL_HOSTLIST_INIT) */ -} - -/** - * @ingroup dns - * Iterate the local host-list for a hostname. - * - * @param iterator_fn a function that is called for every entry in the local host-list - * @param iterator_arg 3rd argument passed to iterator_fn - * @return the number of entries in the local host-list - */ -size_t -dns_local_iterate(dns_found_callback iterator_fn, void *iterator_arg) -{ - size_t i; -#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC - struct local_hostlist_entry *entry = local_hostlist_dynamic; - i = 0; - while (entry != NULL) { - if (iterator_fn != NULL) { - iterator_fn(entry->name, &entry->addr, iterator_arg); - } - i++; - entry = entry->next; - } -#else /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - for (i = 0; i < LWIP_ARRAYSIZE(local_hostlist_static); i++) { - if (iterator_fn != NULL) { - iterator_fn(local_hostlist_static[i].name, &local_hostlist_static[i].addr, iterator_arg); - } - } -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - return i; -} - -/** - * @ingroup dns - * Scans the local host-list for a hostname. - * - * @param hostname Hostname to look for in the local host-list - * @param addr the first IP address for the hostname in the local host-list or - * IPADDR_NONE if not found. - * @param dns_addrtype - LWIP_DNS_ADDRTYPE_IPV4_IPV6: try to resolve IPv4 (ATTENTION: no fallback here!) - * - LWIP_DNS_ADDRTYPE_IPV6_IPV4: try to resolve IPv6 (ATTENTION: no fallback here!) - * - LWIP_DNS_ADDRTYPE_IPV4: try to resolve IPv4 only - * - LWIP_DNS_ADDRTYPE_IPV6: try to resolve IPv6 only - * @return ERR_OK if found, ERR_ARG if not found - */ -err_t -dns_local_lookup(const char *hostname, ip_addr_t *addr, u8_t dns_addrtype) -{ - LWIP_UNUSED_ARG(dns_addrtype); - return dns_lookup_local(hostname, addr LWIP_DNS_ADDRTYPE_ARG(dns_addrtype)); -} - -/* Internal implementation for dns_local_lookup and dns_lookup */ -static err_t -dns_lookup_local(const char *hostname, ip_addr_t *addr LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype)) -{ -#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC - struct local_hostlist_entry *entry = local_hostlist_dynamic; - while (entry != NULL) { - if ((lwip_stricmp(entry->name, hostname) == 0) && - LWIP_DNS_ADDRTYPE_MATCH_IP(dns_addrtype, entry->addr)) { - if (addr) { - ip_addr_copy(*addr, entry->addr); - } - return ERR_OK; - } - entry = entry->next; - } -#else /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - size_t i; - for (i = 0; i < LWIP_ARRAYSIZE(local_hostlist_static); i++) { - if ((lwip_stricmp(local_hostlist_static[i].name, hostname) == 0) && - LWIP_DNS_ADDRTYPE_MATCH_IP(dns_addrtype, local_hostlist_static[i].addr)) { - if (addr) { - ip_addr_copy(*addr, local_hostlist_static[i].addr); - } - return ERR_OK; - } - } -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - return ERR_ARG; -} - -#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC -/** - * @ingroup dns - * Remove all entries from the local host-list for a specific hostname - * and/or IP address - * - * @param hostname hostname for which entries shall be removed from the local - * host-list - * @param addr address for which entries shall be removed from the local host-list - * @return the number of removed entries - */ -int -dns_local_removehost(const char *hostname, const ip_addr_t *addr) -{ - int removed = 0; - struct local_hostlist_entry *entry = local_hostlist_dynamic; - struct local_hostlist_entry *last_entry = NULL; - while (entry != NULL) { - if (((hostname == NULL) || !lwip_stricmp(entry->name, hostname)) && - ((addr == NULL) || ip_addr_cmp(&entry->addr, addr))) { - struct local_hostlist_entry *free_entry; - if (last_entry != NULL) { - last_entry->next = entry->next; - } else { - local_hostlist_dynamic = entry->next; - } - free_entry = entry; - entry = entry->next; - memp_free(MEMP_LOCALHOSTLIST, free_entry); - removed++; - } else { - last_entry = entry; - entry = entry->next; - } - } - return removed; -} - -/** - * @ingroup dns - * Add a hostname/IP address pair to the local host-list. - * Duplicates are not checked. - * - * @param hostname hostname of the new entry - * @param addr IP address of the new entry - * @return ERR_OK if succeeded or ERR_MEM on memory error - */ -err_t -dns_local_addhost(const char *hostname, const ip_addr_t *addr) -{ - struct local_hostlist_entry *entry; - size_t namelen; - char *entry_name; - LWIP_ASSERT("invalid host name (NULL)", hostname != NULL); - namelen = strlen(hostname); - LWIP_ASSERT("namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN", namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN); - entry = (struct local_hostlist_entry *)memp_malloc(MEMP_LOCALHOSTLIST); - if (entry == NULL) { - return ERR_MEM; - } - entry_name = (char *)entry + sizeof(struct local_hostlist_entry); - MEMCPY(entry_name, hostname, namelen); - entry_name[namelen] = 0; - entry->name = entry_name; - ip_addr_copy(entry->addr, *addr); - entry->next = local_hostlist_dynamic; - local_hostlist_dynamic = entry; - return ERR_OK; -} -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC*/ -#endif /* DNS_LOCAL_HOSTLIST */ - -/** - * @ingroup dns - * Look up a hostname in the array of known hostnames. - * - * @note This function only looks in the internal array of known - * hostnames, it does not send out a query for the hostname if none - * was found. The function dns_enqueue() can be used to send a query - * for a hostname. - * - * @param name the hostname to look up - * @param addr the hostname's IP address, as u32_t (instead of ip_addr_t to - * better check for failure: != IPADDR_NONE) or IPADDR_NONE if the hostname - * was not found in the cached dns_table. - * @return ERR_OK if found, ERR_ARG if not found - */ -static err_t -dns_lookup(const char *name, ip_addr_t *addr LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype)) -{ - u8_t i; -#if DNS_LOCAL_HOSTLIST - if (dns_lookup_local(name, addr LWIP_DNS_ADDRTYPE_ARG(dns_addrtype)) == ERR_OK) { - return ERR_OK; - } -#endif /* DNS_LOCAL_HOSTLIST */ -#ifdef DNS_LOOKUP_LOCAL_EXTERN - if (DNS_LOOKUP_LOCAL_EXTERN(name, addr, LWIP_DNS_ADDRTYPE_ARG_OR_ZERO(dns_addrtype)) == ERR_OK) { - return ERR_OK; - } -#endif /* DNS_LOOKUP_LOCAL_EXTERN */ - - /* Walk through name list, return entry if found. If not, return NULL. */ - for (i = 0; i < DNS_TABLE_SIZE; ++i) { - if ((dns_table[i].state == DNS_STATE_DONE) && - (lwip_strnicmp(name, dns_table[i].name, sizeof(dns_table[i].name)) == 0) && - LWIP_DNS_ADDRTYPE_MATCH_IP(dns_addrtype, dns_table[i].ipaddr)) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_lookup: \"%s\": found = ", name)); - ip_addr_debug_print_val(DNS_DEBUG, dns_table[i].ipaddr); - LWIP_DEBUGF(DNS_DEBUG, ("\n")); - if (addr) { - ip_addr_copy(*addr, dns_table[i].ipaddr); - } - return ERR_OK; - } - } - - return ERR_ARG; -} - -/** - * Compare the "dotted" name "query" with the encoded name "response" - * to make sure an answer from the DNS server matches the current dns_table - * entry (otherwise, answers might arrive late for hostname not on the list - * any more). - * - * For now, this function compares case-insensitive to cope with all kinds of - * servers. This also means that "dns 0x20 bit encoding" must be checked - * externally, if we want to implement it. - * Currently, the request is sent exactly as passed in by he user request. - * - * @param query hostname (not encoded) from the dns_table - * @param p pbuf containing the encoded hostname in the DNS response - * @param start_offset offset into p where the name starts - * @return 0xFFFF: names differ, other: names equal -> offset behind name - */ -static u16_t -dns_compare_name(const char *query, struct pbuf *p, u16_t start_offset) -{ - int n; - u16_t response_offset = start_offset; - - do { - n = pbuf_try_get_at(p, response_offset); - if ((n < 0) || (response_offset == 0xFFFF)) { - /* error or overflow */ - return 0xFFFF; - } - response_offset++; - /** @see RFC 1035 - 4.1.4. Message compression */ - if ((n & 0xc0) == 0xc0) { - /* Compressed name: cannot be equal since we don't send them */ - return 0xFFFF; - } else { - /* Not compressed name */ - while (n > 0) { - int c = pbuf_try_get_at(p, response_offset); - if (c < 0) { - return 0xFFFF; - } - if (lwip_tolower((*query)) != lwip_tolower((u8_t)c)) { - return 0xFFFF; - } - if (response_offset == 0xFFFF) { - /* would overflow */ - return 0xFFFF; - } - response_offset++; - ++query; - --n; - } - ++query; - } - n = pbuf_try_get_at(p, response_offset); - if (n < 0) { - return 0xFFFF; - } - } while (n != 0); - - if (response_offset == 0xFFFF) { - /* would overflow */ - return 0xFFFF; - } - return (u16_t)(response_offset + 1); -} - -/** - * Walk through a compact encoded DNS name and return the end of the name. - * - * @param p pbuf containing the name - * @param query_idx start index into p pointing to encoded DNS name in the DNS server response - * @return index to end of the name - */ -static u16_t -dns_skip_name(struct pbuf *p, u16_t query_idx) -{ - int n; - u16_t offset = query_idx; - - do { - n = pbuf_try_get_at(p, offset++); - if ((n < 0) || (offset == 0)) { - return 0xFFFF; - } - /** @see RFC 1035 - 4.1.4. Message compression */ - if ((n & 0xc0) == 0xc0) { - /* Compressed name: since we only want to skip it (not check it), stop here */ - break; - } else { - /* Not compressed name */ - if (offset + n >= p->tot_len) { - return 0xFFFF; - } - offset = (u16_t)(offset + n); - } - n = pbuf_try_get_at(p, offset); - if (n < 0) { - return 0xFFFF; - } - } while (n != 0); - - if (offset == 0xFFFF) { - return 0xFFFF; - } - return (u16_t)(offset + 1); -} - -/** - * Send a DNS query packet. - * - * @param idx the DNS table entry index for which to send a request - * @return ERR_OK if packet is sent; an err_t indicating the problem otherwise - */ -static err_t -dns_send(u8_t idx) -{ - err_t err; - struct dns_hdr hdr; - struct dns_query qry; - struct pbuf *p; - u16_t query_idx, copy_len; - const char *hostname, *hostname_part; - u8_t n; - u8_t pcb_idx; - struct dns_table_entry *entry = &dns_table[idx]; - - LWIP_DEBUGF(DNS_DEBUG, ("dns_send: dns_servers[%"U16_F"] \"%s\": request\n", - (u16_t)(entry->server_idx), entry->name)); - LWIP_ASSERT("dns server out of array", entry->server_idx < DNS_MAX_SERVERS); - if (ip_addr_isany_val(dns_servers[entry->server_idx]) -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - && !entry->is_mdns -#endif - ) { - /* DNS server not valid anymore, e.g. PPP netif has been shut down */ - /* call specified callback function if provided */ - dns_call_found(idx, NULL); - /* flush this entry */ - entry->state = DNS_STATE_UNUSED; - return ERR_OK; - } - - /* if here, we have either a new query or a retry on a previous query to process */ - p = pbuf_alloc(PBUF_TRANSPORT, (u16_t)(SIZEOF_DNS_HDR + strlen(entry->name) + 2 + - SIZEOF_DNS_QUERY), PBUF_RAM); - if (p != NULL) { - const ip_addr_t *dst; - u16_t dst_port; - /* fill dns header */ - memset(&hdr, 0, SIZEOF_DNS_HDR); - hdr.id = lwip_htons(entry->txid); - hdr.flags1 = DNS_FLAG1_RD; - hdr.numquestions = PP_HTONS(1); - pbuf_take(p, &hdr, SIZEOF_DNS_HDR); - hostname = entry->name; - --hostname; - - /* convert hostname into suitable query format. */ - query_idx = SIZEOF_DNS_HDR; - do { - ++hostname; - hostname_part = hostname; - for (n = 0; *hostname != '.' && *hostname != 0; ++hostname) { - ++n; - } - copy_len = (u16_t)(hostname - hostname_part); - if (query_idx + n + 1 > 0xFFFF) { - /* u16_t overflow */ - goto overflow_return; - } - pbuf_put_at(p, query_idx, n); - pbuf_take_at(p, hostname_part, copy_len, (u16_t)(query_idx + 1)); - query_idx = (u16_t)(query_idx + n + 1); - } while (*hostname != 0); - pbuf_put_at(p, query_idx, 0); - query_idx++; - - /* fill dns query */ - if (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) { - qry.type = PP_HTONS(DNS_RRTYPE_AAAA); - } else { - qry.type = PP_HTONS(DNS_RRTYPE_A); - } - qry.cls = PP_HTONS(DNS_RRCLASS_IN); - pbuf_take_at(p, &qry, SIZEOF_DNS_QUERY, query_idx); - -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) - pcb_idx = entry->pcb_idx; -#else - pcb_idx = 0; -#endif - /* send dns packet */ - LWIP_DEBUGF(DNS_DEBUG, ("sending DNS request ID %d for name \"%s\" to server %d\r\n", - entry->txid, entry->name, entry->server_idx)); -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - if (entry->is_mdns) { - dst_port = DNS_MQUERY_PORT; -#if LWIP_IPV6 - if (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) { - dst = &dns_mquery_v6group; - } -#endif -#if LWIP_IPV4 && LWIP_IPV6 - else -#endif -#if LWIP_IPV4 - { - dst = &dns_mquery_v4group; - } -#endif - } else -#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ - { - dst_port = DNS_SERVER_PORT; - dst = &dns_servers[entry->server_idx]; - } - err = udp_sendto(dns_pcbs[pcb_idx], p, dst, dst_port); - - /* free pbuf */ - pbuf_free(p); - } else { - err = ERR_MEM; - } - - return err; -overflow_return: - pbuf_free(p); - return ERR_VAL; -} - -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) -static struct udp_pcb * -dns_alloc_random_port(void) -{ - err_t err; - struct udp_pcb *pcb; - - pcb = udp_new_ip_type(IPADDR_TYPE_ANY); - if (pcb == NULL) { - /* out of memory, have to reuse an existing pcb */ - return NULL; - } - do { - u16_t port = (u16_t)DNS_RAND_TXID(); - if (DNS_PORT_ALLOWED(port)) { - err = udp_bind(pcb, IP_ANY_TYPE, port); - } else { - /* this port is not allowed, try again */ - err = ERR_USE; - } - } while (err == ERR_USE); - if (err != ERR_OK) { - udp_remove(pcb); - return NULL; - } - udp_recv(pcb, dns_recv, NULL); - return pcb; -} - -/** - * dns_alloc_pcb() - allocates a new pcb (or reuses an existing one) to be used - * for sending a request - * - * @return an index into dns_pcbs - */ -static u8_t -dns_alloc_pcb(void) -{ - u8_t i; - u8_t idx; - - for (i = 0; i < DNS_MAX_SOURCE_PORTS; i++) { - if (dns_pcbs[i] == NULL) { - break; - } - } - if (i < DNS_MAX_SOURCE_PORTS) { - dns_pcbs[i] = dns_alloc_random_port(); - if (dns_pcbs[i] != NULL) { - /* succeeded */ - dns_last_pcb_idx = i; - return i; - } - } - /* if we come here, creating a new UDP pcb failed, so we have to use - an already existing one (so overflow is no issue) */ - for (i = 0, idx = (u8_t)(dns_last_pcb_idx + 1); i < DNS_MAX_SOURCE_PORTS; i++, idx++) { - if (idx >= DNS_MAX_SOURCE_PORTS) { - idx = 0; - } - if (dns_pcbs[idx] != NULL) { - dns_last_pcb_idx = idx; - return idx; - } - } - return DNS_MAX_SOURCE_PORTS; -} -#endif /* ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) */ - -/** - * dns_call_found() - call the found callback and check if there are duplicate - * entries for the given hostname. If there are any, their found callback will - * be called and they will be removed. - * - * @param idx dns table index of the entry that is resolved or removed - * @param addr IP address for the hostname (or NULL on error or memory shortage) - */ -static void -dns_call_found(u8_t idx, ip_addr_t *addr) -{ -#if ((LWIP_DNS_SECURE & (LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING | LWIP_DNS_SECURE_RAND_SRC_PORT)) != 0) - u8_t i; -#endif - -#if LWIP_IPV4 && LWIP_IPV6 - if (addr != NULL) { - /* check that address type matches the request and adapt the table entry */ - if (IP_IS_V6_VAL(*addr)) { - LWIP_ASSERT("invalid response", LWIP_DNS_ADDRTYPE_IS_IPV6(dns_table[idx].reqaddrtype)); - dns_table[idx].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV6; - } else { - LWIP_ASSERT("invalid response", !LWIP_DNS_ADDRTYPE_IS_IPV6(dns_table[idx].reqaddrtype)); - dns_table[idx].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV4; - } - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) - for (i = 0; i < DNS_MAX_REQUESTS; i++) { - if (dns_requests[i].found && (dns_requests[i].dns_table_idx == idx)) { - (*dns_requests[i].found)(dns_table[idx].name, addr, dns_requests[i].arg); - /* flush this entry */ - dns_requests[i].found = NULL; - } - } -#else - if (dns_requests[idx].found) { - (*dns_requests[idx].found)(dns_table[idx].name, addr, dns_requests[idx].arg); - } - dns_requests[idx].found = NULL; -#endif -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) - /* close the pcb used unless other request are using it */ - for (i = 0; i < DNS_MAX_REQUESTS; i++) { - if (i == idx) { - continue; /* only check other requests */ - } - if (dns_table[i].state == DNS_STATE_ASKING) { - if (dns_table[i].pcb_idx == dns_table[idx].pcb_idx) { - /* another request is still using the same pcb */ - dns_table[idx].pcb_idx = DNS_MAX_SOURCE_PORTS; - break; - } - } - } - if (dns_table[idx].pcb_idx < DNS_MAX_SOURCE_PORTS) { - /* if we come here, the pcb is not used any more and can be removed */ - udp_remove(dns_pcbs[dns_table[idx].pcb_idx]); - dns_pcbs[dns_table[idx].pcb_idx] = NULL; - dns_table[idx].pcb_idx = DNS_MAX_SOURCE_PORTS; - } -#endif -} - -/* Create a query transmission ID that is unique for all outstanding queries */ -static u16_t -dns_create_txid(void) -{ - u16_t txid; - u8_t i; - -again: - txid = (u16_t)DNS_RAND_TXID(); - - /* check whether the ID is unique */ - for (i = 0; i < DNS_TABLE_SIZE; i++) { - if ((dns_table[i].state == DNS_STATE_ASKING) && - (dns_table[i].txid == txid)) { - /* ID already used by another pending query */ - goto again; - } - } - - return txid; -} - -/** - * Check whether there are other backup DNS servers available to try - */ -static u8_t -dns_backupserver_available(struct dns_table_entry *pentry) -{ - u8_t ret = 0; - - if (pentry) { - if ((pentry->server_idx + 1 < DNS_MAX_SERVERS) && !ip_addr_isany_val(dns_servers[pentry->server_idx + 1])) { - ret = 1; - } - } - - return ret; -} - -/** - * dns_check_entry() - see if entry has not yet been queried and, if so, sends out a query. - * Check an entry in the dns_table: - * - send out query for new entries - * - retry old pending entries on timeout (also with different servers) - * - remove completed entries from the table if their TTL has expired - * - * @param i index of the dns_table entry to check - */ -static void -dns_check_entry(u8_t i) -{ - err_t err; - struct dns_table_entry *entry = &dns_table[i]; - - LWIP_ASSERT("array index out of bounds", i < DNS_TABLE_SIZE); - - switch (entry->state) { - case DNS_STATE_NEW: - /* initialize new entry */ - entry->txid = dns_create_txid(); - entry->state = DNS_STATE_ASKING; - entry->server_idx = 0; - entry->tmr = 1; - entry->retries = 0; - - /* send DNS packet for this entry */ - err = dns_send(i); - if (err != ERR_OK) { - LWIP_DEBUGF(DNS_DEBUG | LWIP_DBG_LEVEL_WARNING, - ("dns_send returned error: %s\n", lwip_strerr(err))); - } - break; - case DNS_STATE_ASKING: - if (--entry->tmr == 0) { - if (++entry->retries == DNS_MAX_RETRIES) { - if (dns_backupserver_available(entry) -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - && !entry->is_mdns -#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ - ) { - /* change of server */ - entry->server_idx++; - entry->tmr = 1; - entry->retries = 0; - } else { - LWIP_DEBUGF(DNS_DEBUG, ("dns_check_entry: \"%s\": timeout\n", entry->name)); - /* call specified callback function if provided */ - dns_call_found(i, NULL); - /* flush this entry */ - entry->state = DNS_STATE_UNUSED; - break; - } - } else { - /* wait longer for the next retry */ - entry->tmr = entry->retries; - } - - /* send DNS packet for this entry */ - err = dns_send(i); - if (err != ERR_OK) { - LWIP_DEBUGF(DNS_DEBUG | LWIP_DBG_LEVEL_WARNING, - ("dns_send returned error: %s\n", lwip_strerr(err))); - } - } - break; - case DNS_STATE_DONE: - /* if the time to live is nul */ - if ((entry->ttl == 0) || (--entry->ttl == 0)) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_check_entry: \"%s\": flush\n", entry->name)); - /* flush this entry, there cannot be any related pending entries in this state */ - entry->state = DNS_STATE_UNUSED; - } - break; - case DNS_STATE_UNUSED: - /* nothing to do */ - break; - default: - LWIP_ASSERT("unknown dns_table entry state:", 0); - break; - } -} - -/** - * Call dns_check_entry for each entry in dns_table - check all entries. - */ -static void -dns_check_entries(void) -{ - u8_t i; - - for (i = 0; i < DNS_TABLE_SIZE; ++i) { - dns_check_entry(i); - } -} - -/** - * Save TTL and call dns_call_found for correct response. - */ -static void -dns_correct_response(u8_t idx, u32_t ttl) -{ - struct dns_table_entry *entry = &dns_table[idx]; - - entry->state = DNS_STATE_DONE; - - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response = ", entry->name)); - ip_addr_debug_print_val(DNS_DEBUG, entry->ipaddr); - LWIP_DEBUGF(DNS_DEBUG, ("\n")); - - /* read the answer resource record's TTL, and maximize it if needed */ - entry->ttl = ttl; - if (entry->ttl > DNS_MAX_TTL) { - entry->ttl = DNS_MAX_TTL; - } - dns_call_found(idx, &entry->ipaddr); - - if (entry->ttl == 0) { - /* RFC 883, page 29: "Zero values are - interpreted to mean that the RR can only be used for the - transaction in progress, and should not be cached." - -> flush this entry now */ - /* entry reused during callback? */ - if (entry->state == DNS_STATE_DONE) { - entry->state = DNS_STATE_UNUSED; - } - } -} - -/** - * Receive input function for DNS response packets arriving for the dns UDP pcb. - */ -static void -dns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - u8_t i; - u16_t txid; - u16_t res_idx; - struct dns_hdr hdr; - struct dns_answer ans; - struct dns_query qry; - u16_t nquestions, nanswers; - - LWIP_UNUSED_ARG(arg); - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(port); - - /* is the dns message big enough ? */ - if (p->tot_len < (SIZEOF_DNS_HDR + SIZEOF_DNS_QUERY)) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: pbuf too small\n")); - /* free pbuf and return */ - goto ignore_packet; - } - - /* copy dns payload inside static buffer for processing */ - if (pbuf_copy_partial(p, &hdr, SIZEOF_DNS_HDR, 0) == SIZEOF_DNS_HDR) { - /* Match the ID in the DNS header with the name table. */ - txid = lwip_htons(hdr.id); - for (i = 0; i < DNS_TABLE_SIZE; i++) { - struct dns_table_entry *entry = &dns_table[i]; - if ((entry->state == DNS_STATE_ASKING) && - (entry->txid == txid)) { - - /* We only care about the question(s) and the answers. The authrr - and the extrarr are simply discarded. */ - nquestions = lwip_htons(hdr.numquestions); - nanswers = lwip_htons(hdr.numanswers); - - /* Check for correct response. */ - if ((hdr.flags1 & DNS_FLAG1_RESPONSE) == 0) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": not a response\n", entry->name)); - goto ignore_packet; /* ignore this packet */ - } - if (nquestions != 1) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response not match to query\n", entry->name)); - goto ignore_packet; /* ignore this packet */ - } - -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - if (!entry->is_mdns) -#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ - { - /* Check whether response comes from the same network address to which the - question was sent. (RFC 5452) */ - if (!ip_addr_cmp(addr, &dns_servers[entry->server_idx])) { - goto ignore_packet; /* ignore this packet */ - } - } - - /* Check if the name in the "question" part match with the name in the entry and - skip it if equal. */ - res_idx = dns_compare_name(entry->name, p, SIZEOF_DNS_HDR); - if (res_idx == 0xFFFF) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response not match to query\n", entry->name)); - goto ignore_packet; /* ignore this packet */ - } - - /* check if "question" part matches the request */ - if (pbuf_copy_partial(p, &qry, SIZEOF_DNS_QUERY, res_idx) != SIZEOF_DNS_QUERY) { - goto ignore_packet; /* ignore this packet */ - } - if ((qry.cls != PP_HTONS(DNS_RRCLASS_IN)) || - (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype) && (qry.type != PP_HTONS(DNS_RRTYPE_AAAA))) || - (!LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype) && (qry.type != PP_HTONS(DNS_RRTYPE_A)))) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response not match to query\n", entry->name)); - goto ignore_packet; /* ignore this packet */ - } - /* skip the rest of the "question" part */ - if (res_idx + SIZEOF_DNS_QUERY > 0xFFFF) { - goto ignore_packet; - } - res_idx = (u16_t)(res_idx + SIZEOF_DNS_QUERY); - - /* Check for error. If so, call callback to inform. */ - if (hdr.flags2 & DNS_FLAG2_ERR_MASK) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": error in flags\n", entry->name)); - - /* if there is another backup DNS server to try - * then don't stop the DNS request - */ - if (dns_backupserver_available(entry)) { - /* avoid retrying the same server */ - entry->retries = DNS_MAX_RETRIES-1; - entry->tmr = 1; - - /* contact next available server for this entry */ - dns_check_entry(i); - - goto ignore_packet; - } - } else { - while ((nanswers > 0) && (res_idx < p->tot_len)) { - /* skip answer resource record's host name */ - res_idx = dns_skip_name(p, res_idx); - if (res_idx == 0xFFFF) { - goto ignore_packet; /* ignore this packet */ - } - - /* Check for IP address type and Internet class. Others are discarded. */ - if (pbuf_copy_partial(p, &ans, SIZEOF_DNS_ANSWER, res_idx) != SIZEOF_DNS_ANSWER) { - goto ignore_packet; /* ignore this packet */ - } - if (res_idx + SIZEOF_DNS_ANSWER > 0xFFFF) { - goto ignore_packet; - } - res_idx = (u16_t)(res_idx + SIZEOF_DNS_ANSWER); - - if (ans.cls == PP_HTONS(DNS_RRCLASS_IN)) { -#if LWIP_IPV4 - if ((ans.type == PP_HTONS(DNS_RRTYPE_A)) && (ans.len == PP_HTONS(sizeof(ip4_addr_t)))) { -#if LWIP_IPV4 && LWIP_IPV6 - if (!LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - { - ip4_addr_t ip4addr; - /* read the IP address after answer resource record's header */ - if (pbuf_copy_partial(p, &ip4addr, sizeof(ip4_addr_t), res_idx) != sizeof(ip4_addr_t)) { - goto ignore_packet; /* ignore this packet */ - } - ip_addr_copy_from_ip4(dns_table[i].ipaddr, ip4addr); - pbuf_free(p); - /* handle correct response */ - dns_correct_response(i, lwip_ntohl(ans.ttl)); - return; - } - } -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 - if ((ans.type == PP_HTONS(DNS_RRTYPE_AAAA)) && (ans.len == PP_HTONS(sizeof(ip6_addr_p_t)))) { -#if LWIP_IPV4 && LWIP_IPV6 - if (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - { - ip6_addr_p_t ip6addr; - /* read the IP address after answer resource record's header */ - if (pbuf_copy_partial(p, &ip6addr, sizeof(ip6_addr_p_t), res_idx) != sizeof(ip6_addr_p_t)) { - goto ignore_packet; /* ignore this packet */ - } - /* @todo: scope ip6addr? Might be required for link-local addresses at least? */ - ip_addr_copy_from_ip6_packed(dns_table[i].ipaddr, ip6addr); - pbuf_free(p); - /* handle correct response */ - dns_correct_response(i, lwip_ntohl(ans.ttl)); - return; - } - } -#endif /* LWIP_IPV6 */ - } - /* skip this answer */ - if ((int)(res_idx + lwip_htons(ans.len)) > 0xFFFF) { - goto ignore_packet; /* ignore this packet */ - } - res_idx = (u16_t)(res_idx + lwip_htons(ans.len)); - --nanswers; - } -#if LWIP_IPV4 && LWIP_IPV6 - if ((entry->reqaddrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) || - (entry->reqaddrtype == LWIP_DNS_ADDRTYPE_IPV6_IPV4)) { - if (entry->reqaddrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) { - /* IPv4 failed, try IPv6 */ - dns_table[i].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV6; - } else { - /* IPv6 failed, try IPv4 */ - dns_table[i].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV4; - } - pbuf_free(p); - dns_table[i].state = DNS_STATE_NEW; - dns_check_entry(i); - return; - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": error in response\n", entry->name)); - } - /* call callback to indicate error, clean up memory and return */ - pbuf_free(p); - dns_call_found(i, NULL); - dns_table[i].state = DNS_STATE_UNUSED; - return; - } - } - } - -ignore_packet: - /* deallocate memory and return */ - pbuf_free(p); - return; -} - -/** - * Queues a new hostname to resolve and sends out a DNS query for that hostname - * - * @param name the hostname that is to be queried - * @param hostnamelen length of the hostname - * @param found a callback function to be called on success, failure or timeout - * @param callback_arg argument to pass to the callback function - * @return err_t return code. - */ -static err_t -dns_enqueue(const char *name, size_t hostnamelen, dns_found_callback found, - void *callback_arg LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype) LWIP_DNS_ISMDNS_ARG(u8_t is_mdns)) -{ - u8_t i; - u8_t lseq, lseqi; - struct dns_table_entry *entry = NULL; - size_t namelen; - struct dns_req_entry *req; - -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) - u8_t r; - /* check for duplicate entries */ - for (i = 0; i < DNS_TABLE_SIZE; i++) { - if ((dns_table[i].state == DNS_STATE_ASKING) && - (lwip_strnicmp(name, dns_table[i].name, sizeof(dns_table[i].name)) == 0)) { -#if LWIP_IPV4 && LWIP_IPV6 - if (dns_table[i].reqaddrtype != dns_addrtype) { - /* requested address types don't match - this can lead to 2 concurrent requests, but mixing the address types - for the same host should not be that common */ - continue; - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - /* this is a duplicate entry, find a free request entry */ - for (r = 0; r < DNS_MAX_REQUESTS; r++) { - if (dns_requests[r].found == 0) { - dns_requests[r].found = found; - dns_requests[r].arg = callback_arg; - dns_requests[r].dns_table_idx = i; - LWIP_DNS_SET_ADDRTYPE(dns_requests[r].reqaddrtype, dns_addrtype); - LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": duplicate request\n", name)); - return ERR_INPROGRESS; - } - } - } - } - /* no duplicate entries found */ -#endif - - /* search an unused entry, or the oldest one */ - lseq = 0; - lseqi = DNS_TABLE_SIZE; - for (i = 0; i < DNS_TABLE_SIZE; ++i) { - entry = &dns_table[i]; - /* is it an unused entry ? */ - if (entry->state == DNS_STATE_UNUSED) { - break; - } - /* check if this is the oldest completed entry */ - if (entry->state == DNS_STATE_DONE) { - u8_t age = (u8_t)(dns_seqno - entry->seqno); - if (age > lseq) { - lseq = age; - lseqi = i; - } - } - } - - /* if we don't have found an unused entry, use the oldest completed one */ - if (i == DNS_TABLE_SIZE) { - if ((lseqi >= DNS_TABLE_SIZE) || (dns_table[lseqi].state != DNS_STATE_DONE)) { - /* no entry can be used now, table is full */ - LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": DNS entries table is full\n", name)); - return ERR_MEM; - } else { - /* use the oldest completed one */ - i = lseqi; - entry = &dns_table[i]; - } - } - -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) - /* find a free request entry */ - req = NULL; - for (r = 0; r < DNS_MAX_REQUESTS; r++) { - if (dns_requests[r].found == NULL) { - req = &dns_requests[r]; - break; - } - } - if (req == NULL) { - /* no request entry can be used now, table is full */ - LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": DNS request entries table is full\n", name)); - return ERR_MEM; - } - req->dns_table_idx = i; -#else - /* in this configuration, the entry index is the same as the request index */ - req = &dns_requests[i]; -#endif - - /* use this entry */ - LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": use DNS entry %"U16_F"\n", name, (u16_t)(i))); - - /* fill the entry */ - entry->state = DNS_STATE_NEW; - entry->seqno = dns_seqno; - LWIP_DNS_SET_ADDRTYPE(entry->reqaddrtype, dns_addrtype); - LWIP_DNS_SET_ADDRTYPE(req->reqaddrtype, dns_addrtype); - req->found = found; - req->arg = callback_arg; - namelen = LWIP_MIN(hostnamelen, DNS_MAX_NAME_LENGTH - 1); - MEMCPY(entry->name, name, namelen); - entry->name[namelen] = 0; - -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) - entry->pcb_idx = dns_alloc_pcb(); - if (entry->pcb_idx >= DNS_MAX_SOURCE_PORTS) { - /* failed to get a UDP pcb */ - LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": failed to allocate a pcb\n", name)); - entry->state = DNS_STATE_UNUSED; - req->found = NULL; - return ERR_MEM; - } - LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": use DNS pcb %"U16_F"\n", name, (u16_t)(entry->pcb_idx))); -#endif - -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - entry->is_mdns = is_mdns; -#endif - - dns_seqno++; - - /* force to send query without waiting timer */ - dns_check_entry(i); - - /* dns query is enqueued */ - return ERR_INPROGRESS; -} - -/** - * @ingroup dns - * Resolve a hostname (string) into an IP address. - * NON-BLOCKING callback version for use with raw API!!! - * - * Returns immediately with one of err_t return codes: - * - ERR_OK if hostname is a valid IP address string or the host - * name is already in the local names table. - * - ERR_INPROGRESS enqueue a request to be sent to the DNS server - * for resolution if no errors are present. - * - ERR_ARG: dns client not initialized or invalid hostname - * - * @param hostname the hostname that is to be queried - * @param addr pointer to a ip_addr_t where to store the address if it is already - * cached in the dns_table (only valid if ERR_OK is returned!) - * @param found a callback function to be called on success, failure or timeout (only if - * ERR_INPROGRESS is returned!) - * @param callback_arg argument to pass to the callback function - * @return a err_t return code. - */ -err_t -dns_gethostbyname(const char *hostname, ip_addr_t *addr, dns_found_callback found, - void *callback_arg) -{ - return dns_gethostbyname_addrtype(hostname, addr, found, callback_arg, LWIP_DNS_ADDRTYPE_DEFAULT); -} - -/** - * @ingroup dns - * Like dns_gethostbyname, but returned address type can be controlled: - * @param hostname the hostname that is to be queried - * @param addr pointer to a ip_addr_t where to store the address if it is already - * cached in the dns_table (only valid if ERR_OK is returned!) - * @param found a callback function to be called on success, failure or timeout (only if - * ERR_INPROGRESS is returned!) - * @param callback_arg argument to pass to the callback function - * @param dns_addrtype - LWIP_DNS_ADDRTYPE_IPV4_IPV6: try to resolve IPv4 first, try IPv6 if IPv4 fails only - * - LWIP_DNS_ADDRTYPE_IPV6_IPV4: try to resolve IPv6 first, try IPv4 if IPv6 fails only - * - LWIP_DNS_ADDRTYPE_IPV4: try to resolve IPv4 only - * - LWIP_DNS_ADDRTYPE_IPV6: try to resolve IPv6 only - */ -err_t -dns_gethostbyname_addrtype(const char *hostname, ip_addr_t *addr, dns_found_callback found, - void *callback_arg, u8_t dns_addrtype) -{ - size_t hostnamelen; -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - u8_t is_mdns; -#endif - /* not initialized or no valid server yet, or invalid addr pointer - * or invalid hostname or invalid hostname length */ - if ((addr == NULL) || - (!hostname) || (!hostname[0])) { - return ERR_ARG; - } -#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) == 0) - if (dns_pcbs[0] == NULL) { - return ERR_ARG; - } -#endif - hostnamelen = strlen(hostname); - if (hostnamelen >= DNS_MAX_NAME_LENGTH) { - LWIP_DEBUGF(DNS_DEBUG, ("dns_gethostbyname: name too long to resolve")); - return ERR_ARG; - } - - -#if LWIP_HAVE_LOOPIF - if (strcmp(hostname, "localhost") == 0) { - ip_addr_set_loopback(LWIP_DNS_ADDRTYPE_IS_IPV6(dns_addrtype), addr); - return ERR_OK; - } -#endif /* LWIP_HAVE_LOOPIF */ - - /* host name already in octet notation? set ip addr and return ERR_OK */ - if (ipaddr_aton(hostname, addr)) { -#if LWIP_IPV4 && LWIP_IPV6 - if ((IP_IS_V6(addr) && (dns_addrtype != LWIP_DNS_ADDRTYPE_IPV4)) || - (IP_IS_V4(addr) && (dns_addrtype != LWIP_DNS_ADDRTYPE_IPV6))) -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - { - return ERR_OK; - } - } - /* already have this address cached? */ - if (dns_lookup(hostname, addr LWIP_DNS_ADDRTYPE_ARG(dns_addrtype)) == ERR_OK) { - return ERR_OK; - } -#if LWIP_IPV4 && LWIP_IPV6 - if ((dns_addrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) || (dns_addrtype == LWIP_DNS_ADDRTYPE_IPV6_IPV4)) { - /* fallback to 2nd IP type and try again to lookup */ - u8_t fallback; - if (dns_addrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) { - fallback = LWIP_DNS_ADDRTYPE_IPV6; - } else { - fallback = LWIP_DNS_ADDRTYPE_IPV4; - } - if (dns_lookup(hostname, addr LWIP_DNS_ADDRTYPE_ARG(fallback)) == ERR_OK) { - return ERR_OK; - } - } -#else /* LWIP_IPV4 && LWIP_IPV6 */ - LWIP_UNUSED_ARG(dns_addrtype); -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - -#if LWIP_DNS_SUPPORT_MDNS_QUERIES - if (strstr(hostname, ".local") == &hostname[hostnamelen] - 6) { - is_mdns = 1; - } else { - is_mdns = 0; - } - - if (!is_mdns) -#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ - { - /* prevent calling found callback if no server is set, return error instead */ - if (ip_addr_isany_val(dns_servers[0])) { - return ERR_VAL; - } - } - - /* queue query with specified callback */ - return dns_enqueue(hostname, hostnamelen, found, callback_arg LWIP_DNS_ADDRTYPE_ARG(dns_addrtype) - LWIP_DNS_ISMDNS_ARG(is_mdns)); -} - -#endif /* LWIP_DNS */ +/** + * @file + * DNS - host name to IP address resolver. + * + * @defgroup dns DNS + * @ingroup callbackstyle_api + * + * Implements a DNS host name to IP address resolver. + * + * The lwIP DNS resolver functions are used to lookup a host name and + * map it to a numerical IP address. It maintains a list of resolved + * hostnames that can be queried with the dns_lookup() function. + * New hostnames can be resolved using the dns_query() function. + * + * The lwIP version of the resolver also adds a non-blocking version of + * gethostbyname() that will work with a raw API application. This function + * checks for an IP address string first and converts it if it is valid. + * gethostbyname() then does a dns_lookup() to see if the name is + * already in the table. If so, the IP is returned. If not, a query is + * issued and the function returns with a ERR_INPROGRESS status. The app + * using the dns client must then go into a waiting state. + * + * Once a hostname has been resolved (or found to be non-existent), + * the resolver code calls a specified callback function (which + * must be implemented by the module that uses the resolver). + * + * Multicast DNS queries are supported for names ending on ".local". + * However, only "One-Shot Multicast DNS Queries" are supported (RFC 6762 + * chapter 5.1), this is not a fully compliant implementation of continuous + * mDNS querying! + * + * All functions must be called from TCPIP thread. + * + * @see DNS_MAX_SERVERS + * @see LWIP_DHCP_MAX_DNS_SERVERS + * @see @ref netconn_common for thread-safe access. + */ + +/* + * Port to lwIP from uIP + * by Jim Pettinato April 2007 + * + * security fixes and more by Simon Goldschmidt + * + * uIP version Copyright (c) 2002-2003, Adam Dunkels. + * 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. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + */ + +/*----------------------------------------------------------------------------- + * RFC 1035 - Domain names - implementation and specification + * RFC 2181 - Clarifications to the DNS Specification + *----------------------------------------------------------------------------*/ + +/** @todo: define good default values (rfc compliance) */ +/** @todo: improve answer parsing, more checkings... */ +/** @todo: check RFC1035 - 7.3. Processing responses */ +/** @todo: one-shot mDNS: dual-stack fallback to another IP version */ + +/*----------------------------------------------------------------------------- + * Includes + *----------------------------------------------------------------------------*/ + +#include "lwip/opt.h" + +#if LWIP_DNS /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/def.h" +#include "lwip/udp.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/dns.h" +#include "lwip/prot/dns.h" + +#include + +/** Random generator function to create random TXIDs and source ports for queries */ +#ifndef DNS_RAND_TXID +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_XID) != 0) +#define DNS_RAND_TXID LWIP_RAND +#else +static u16_t dns_txid; +#define DNS_RAND_TXID() (++dns_txid) +#endif +#endif + +/** Limits the source port to be >= 1024 by default */ +#ifndef DNS_PORT_ALLOWED +#define DNS_PORT_ALLOWED(port) ((port) >= 1024) +#endif + +/** DNS resource record max. TTL (one week as default) */ +#ifndef DNS_MAX_TTL +#define DNS_MAX_TTL 604800 +#elif DNS_MAX_TTL > 0x7FFFFFFF +#error DNS_MAX_TTL must be a positive 32-bit value +#endif + +#if DNS_TABLE_SIZE > 255 +#error DNS_TABLE_SIZE must fit into an u8_t +#endif +#if DNS_MAX_SERVERS > 255 +#error DNS_MAX_SERVERS must fit into an u8_t +#endif + +/* The number of parallel requests (i.e. calls to dns_gethostbyname + * that cannot be answered from the DNS table. + * This is set to the table size by default. + */ +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) +#ifndef DNS_MAX_REQUESTS +#define DNS_MAX_REQUESTS DNS_TABLE_SIZE +#else +#if DNS_MAX_REQUESTS > 255 +#error DNS_MAX_REQUESTS must fit into an u8_t +#endif +#endif +#else +/* In this configuration, both arrays have to have the same size and are used + * like one entry (used/free) */ +#define DNS_MAX_REQUESTS DNS_TABLE_SIZE +#endif + +/* The number of UDP source ports used in parallel */ +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) +#ifndef DNS_MAX_SOURCE_PORTS +#define DNS_MAX_SOURCE_PORTS DNS_MAX_REQUESTS +#else +#if DNS_MAX_SOURCE_PORTS > 255 +#error DNS_MAX_SOURCE_PORTS must fit into an u8_t +#endif +#endif +#else +#ifdef DNS_MAX_SOURCE_PORTS +#undef DNS_MAX_SOURCE_PORTS +#endif +#define DNS_MAX_SOURCE_PORTS 1 +#endif + +#if LWIP_IPV4 && LWIP_IPV6 +#define LWIP_DNS_ADDRTYPE_IS_IPV6(t) (((t) == LWIP_DNS_ADDRTYPE_IPV6_IPV4) || ((t) == LWIP_DNS_ADDRTYPE_IPV6)) +#define LWIP_DNS_ADDRTYPE_MATCH_IP(t, ip) (IP_IS_V6_VAL(ip) ? LWIP_DNS_ADDRTYPE_IS_IPV6(t) : (!LWIP_DNS_ADDRTYPE_IS_IPV6(t))) +#define LWIP_DNS_ADDRTYPE_ARG(x) , x +#define LWIP_DNS_ADDRTYPE_ARG_OR_ZERO(x) x +#define LWIP_DNS_SET_ADDRTYPE(x, y) do { x = y; } while(0) +#else +#if LWIP_IPV6 +#define LWIP_DNS_ADDRTYPE_IS_IPV6(t) 1 +#else +#define LWIP_DNS_ADDRTYPE_IS_IPV6(t) 0 +#endif +#define LWIP_DNS_ADDRTYPE_MATCH_IP(t, ip) 1 +#define LWIP_DNS_ADDRTYPE_ARG(x) +#define LWIP_DNS_ADDRTYPE_ARG_OR_ZERO(x) 0 +#define LWIP_DNS_SET_ADDRTYPE(x, y) +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + +#if LWIP_DNS_SUPPORT_MDNS_QUERIES +#define LWIP_DNS_ISMDNS_ARG(x) , x +#else +#define LWIP_DNS_ISMDNS_ARG(x) +#endif + +/** DNS query message structure. + No packing needed: only used locally on the stack. */ +struct dns_query { + /* DNS query record starts with either a domain name or a pointer + to a name already present somewhere in the packet. */ + u16_t type; + u16_t cls; +}; +#define SIZEOF_DNS_QUERY 4 + +/** DNS answer message structure. + No packing needed: only used locally on the stack. */ +struct dns_answer { + /* DNS answer record starts with either a domain name or a pointer + to a name already present somewhere in the packet. */ + u16_t type; + u16_t cls; + u32_t ttl; + u16_t len; +}; +#define SIZEOF_DNS_ANSWER 10 +/* maximum allowed size for the struct due to non-packed */ +#define SIZEOF_DNS_ANSWER_ASSERT 12 + +/* DNS table entry states */ +typedef enum { + DNS_STATE_UNUSED = 0, + DNS_STATE_NEW = 1, + DNS_STATE_ASKING = 2, + DNS_STATE_DONE = 3 +} dns_state_enum_t; + +/** DNS table entry */ +struct dns_table_entry { + u32_t ttl; + ip_addr_t ipaddr; + u16_t txid; + u8_t state; + u8_t server_idx; + u8_t tmr; + u8_t retries; + u8_t seqno; +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) + u8_t pcb_idx; +#endif + char name[DNS_MAX_NAME_LENGTH]; +#if LWIP_IPV4 && LWIP_IPV6 + u8_t reqaddrtype; +#endif /* LWIP_IPV4 && LWIP_IPV6 */ +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + u8_t is_mdns; +#endif +}; + +/** DNS request table entry: used when dns_gehostbyname cannot answer the + * request from the DNS table */ +struct dns_req_entry { + /* pointer to callback on DNS query done */ + dns_found_callback found; + /* argument passed to the callback function */ + void *arg; +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) + u8_t dns_table_idx; +#endif +#if LWIP_IPV4 && LWIP_IPV6 + u8_t reqaddrtype; +#endif /* LWIP_IPV4 && LWIP_IPV6 */ +}; + +#if DNS_LOCAL_HOSTLIST + +#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC +/** Local host-list. For hostnames in this list, no + * external name resolution is performed */ +static struct local_hostlist_entry *local_hostlist_dynamic; +#else /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + +/** Defining this allows the local_hostlist_static to be placed in a different + * linker section (e.g. FLASH) */ +#ifndef DNS_LOCAL_HOSTLIST_STORAGE_PRE +#define DNS_LOCAL_HOSTLIST_STORAGE_PRE static +#endif /* DNS_LOCAL_HOSTLIST_STORAGE_PRE */ +/** Defining this allows the local_hostlist_static to be placed in a different + * linker section (e.g. FLASH) */ +#ifndef DNS_LOCAL_HOSTLIST_STORAGE_POST +#define DNS_LOCAL_HOSTLIST_STORAGE_POST +#endif /* DNS_LOCAL_HOSTLIST_STORAGE_POST */ +DNS_LOCAL_HOSTLIST_STORAGE_PRE struct local_hostlist_entry local_hostlist_static[] + DNS_LOCAL_HOSTLIST_STORAGE_POST = DNS_LOCAL_HOSTLIST_INIT; + +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + +static void dns_init_local(void); +static err_t dns_lookup_local(const char *hostname, ip_addr_t *addr LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype)); +#endif /* DNS_LOCAL_HOSTLIST */ + + +/* forward declarations */ +static void dns_recv(void *s, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); +static void dns_check_entries(void); +static void dns_call_found(u8_t idx, ip_addr_t *addr); + +/*----------------------------------------------------------------------------- + * Globals + *----------------------------------------------------------------------------*/ + +/* DNS variables */ +static struct udp_pcb *dns_pcbs[DNS_MAX_SOURCE_PORTS]; +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) +static u8_t dns_last_pcb_idx; +#endif +static u8_t dns_seqno; +static struct dns_table_entry dns_table[DNS_TABLE_SIZE]; +static struct dns_req_entry dns_requests[DNS_MAX_REQUESTS]; +static ip_addr_t dns_servers[DNS_MAX_SERVERS]; + +#if LWIP_IPV4 +const ip_addr_t dns_mquery_v4group = DNS_MQUERY_IPV4_GROUP_INIT; +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 +const ip_addr_t dns_mquery_v6group = DNS_MQUERY_IPV6_GROUP_INIT; +#endif /* LWIP_IPV6 */ + +/** + * Initialize the resolver: set up the UDP pcb and configure the default server + * (if DNS_SERVER_ADDRESS is set). + */ +void +dns_init(void) +{ +#ifdef DNS_SERVER_ADDRESS + /* initialize default DNS server address */ + ip_addr_t dnsserver; + DNS_SERVER_ADDRESS(&dnsserver); + dns_setserver(0, &dnsserver); +#endif /* DNS_SERVER_ADDRESS */ + + LWIP_ASSERT("sanity check SIZEOF_DNS_QUERY", + sizeof(struct dns_query) == SIZEOF_DNS_QUERY); + LWIP_ASSERT("sanity check SIZEOF_DNS_ANSWER", + sizeof(struct dns_answer) <= SIZEOF_DNS_ANSWER_ASSERT); + + LWIP_DEBUGF(DNS_DEBUG, ("dns_init: initializing\n")); + + /* if dns client not yet initialized... */ +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) == 0) + if (dns_pcbs[0] == NULL) { + dns_pcbs[0] = udp_new_ip_type(IPADDR_TYPE_ANY); + LWIP_ASSERT("dns_pcbs[0] != NULL", dns_pcbs[0] != NULL); + + /* initialize DNS table not needed (initialized to zero since it is a + * global variable) */ + LWIP_ASSERT("For implicit initialization to work, DNS_STATE_UNUSED needs to be 0", + DNS_STATE_UNUSED == 0); + + /* initialize DNS client */ + udp_bind(dns_pcbs[0], IP_ANY_TYPE, 0); + udp_recv(dns_pcbs[0], dns_recv, NULL); + } +#endif + +#if DNS_LOCAL_HOSTLIST + dns_init_local(); +#endif +} + +/** + * @ingroup dns + * Initialize one of the DNS servers. + * + * @param numdns the index of the DNS server to set must be < DNS_MAX_SERVERS + * @param dnsserver IP address of the DNS server to set + */ +void +dns_setserver(u8_t numdns, const ip_addr_t *dnsserver) +{ + if (numdns < DNS_MAX_SERVERS) { + if (dnsserver != NULL) { + dns_servers[numdns] = (*dnsserver); + } else { + dns_servers[numdns] = *IP_ADDR_ANY; + } + } +} + +/** + * @ingroup dns + * Obtain one of the currently configured DNS server. + * + * @param numdns the index of the DNS server + * @return IP address of the indexed DNS server or "ip_addr_any" if the DNS + * server has not been configured. + */ +const ip_addr_t * +dns_getserver(u8_t numdns) +{ + if (numdns < DNS_MAX_SERVERS) { + return &dns_servers[numdns]; + } else { + return IP_ADDR_ANY; + } +} + +/** + * The DNS resolver client timer - handle retries and timeouts and should + * be called every DNS_TMR_INTERVAL milliseconds (every second by default). + */ +void +dns_tmr(void) +{ + LWIP_DEBUGF(DNS_DEBUG, ("dns_tmr: dns_check_entries\n")); + dns_check_entries(); +} + +#if DNS_LOCAL_HOSTLIST +static void +dns_init_local(void) +{ +#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC && defined(DNS_LOCAL_HOSTLIST_INIT) + size_t i; + struct local_hostlist_entry *entry; + /* Dynamic: copy entries from DNS_LOCAL_HOSTLIST_INIT to list */ + struct local_hostlist_entry local_hostlist_init[] = DNS_LOCAL_HOSTLIST_INIT; + size_t namelen; + for (i = 0; i < LWIP_ARRAYSIZE(local_hostlist_init); i++) { + struct local_hostlist_entry *init_entry = &local_hostlist_init[i]; + LWIP_ASSERT("invalid host name (NULL)", init_entry->name != NULL); + namelen = strlen(init_entry->name); + LWIP_ASSERT("namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN", namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN); + entry = (struct local_hostlist_entry *)memp_malloc(MEMP_LOCALHOSTLIST); + LWIP_ASSERT("mem-error in dns_init_local", entry != NULL); + if (entry != NULL) { + char *entry_name = (char *)entry + sizeof(struct local_hostlist_entry); + MEMCPY(entry_name, init_entry->name, namelen); + entry_name[namelen] = 0; + entry->name = entry_name; + entry->addr = init_entry->addr; + entry->next = local_hostlist_dynamic; + local_hostlist_dynamic = entry; + } + } +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC && defined(DNS_LOCAL_HOSTLIST_INIT) */ +} + +/** + * @ingroup dns + * Iterate the local host-list for a hostname. + * + * @param iterator_fn a function that is called for every entry in the local host-list + * @param iterator_arg 3rd argument passed to iterator_fn + * @return the number of entries in the local host-list + */ +size_t +dns_local_iterate(dns_found_callback iterator_fn, void *iterator_arg) +{ + size_t i; +#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC + struct local_hostlist_entry *entry = local_hostlist_dynamic; + i = 0; + while (entry != NULL) { + if (iterator_fn != NULL) { + iterator_fn(entry->name, &entry->addr, iterator_arg); + } + i++; + entry = entry->next; + } +#else /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + for (i = 0; i < LWIP_ARRAYSIZE(local_hostlist_static); i++) { + if (iterator_fn != NULL) { + iterator_fn(local_hostlist_static[i].name, &local_hostlist_static[i].addr, iterator_arg); + } + } +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + return i; +} + +/** + * @ingroup dns + * Scans the local host-list for a hostname. + * + * @param hostname Hostname to look for in the local host-list + * @param addr the first IP address for the hostname in the local host-list or + * IPADDR_NONE if not found. + * @param dns_addrtype - LWIP_DNS_ADDRTYPE_IPV4_IPV6: try to resolve IPv4 (ATTENTION: no fallback here!) + * - LWIP_DNS_ADDRTYPE_IPV6_IPV4: try to resolve IPv6 (ATTENTION: no fallback here!) + * - LWIP_DNS_ADDRTYPE_IPV4: try to resolve IPv4 only + * - LWIP_DNS_ADDRTYPE_IPV6: try to resolve IPv6 only + * @return ERR_OK if found, ERR_ARG if not found + */ +err_t +dns_local_lookup(const char *hostname, ip_addr_t *addr, u8_t dns_addrtype) +{ + LWIP_UNUSED_ARG(dns_addrtype); + return dns_lookup_local(hostname, addr LWIP_DNS_ADDRTYPE_ARG(dns_addrtype)); +} + +/* Internal implementation for dns_local_lookup and dns_lookup */ +static err_t +dns_lookup_local(const char *hostname, ip_addr_t *addr LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype)) +{ +#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC + struct local_hostlist_entry *entry = local_hostlist_dynamic; + while (entry != NULL) { + if ((lwip_stricmp(entry->name, hostname) == 0) && + LWIP_DNS_ADDRTYPE_MATCH_IP(dns_addrtype, entry->addr)) { + if (addr) { + ip_addr_copy(*addr, entry->addr); + } + return ERR_OK; + } + entry = entry->next; + } +#else /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + size_t i; + for (i = 0; i < LWIP_ARRAYSIZE(local_hostlist_static); i++) { + if ((lwip_stricmp(local_hostlist_static[i].name, hostname) == 0) && + LWIP_DNS_ADDRTYPE_MATCH_IP(dns_addrtype, local_hostlist_static[i].addr)) { + if (addr) { + ip_addr_copy(*addr, local_hostlist_static[i].addr); + } + return ERR_OK; + } + } +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + return ERR_ARG; +} + +#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC +/** + * @ingroup dns + * Remove all entries from the local host-list for a specific hostname + * and/or IP address + * + * @param hostname hostname for which entries shall be removed from the local + * host-list + * @param addr address for which entries shall be removed from the local host-list + * @return the number of removed entries + */ +int +dns_local_removehost(const char *hostname, const ip_addr_t *addr) +{ + int removed = 0; + struct local_hostlist_entry *entry = local_hostlist_dynamic; + struct local_hostlist_entry *last_entry = NULL; + while (entry != NULL) { + if (((hostname == NULL) || !lwip_stricmp(entry->name, hostname)) && + ((addr == NULL) || ip_addr_cmp(&entry->addr, addr))) { + struct local_hostlist_entry *free_entry; + if (last_entry != NULL) { + last_entry->next = entry->next; + } else { + local_hostlist_dynamic = entry->next; + } + free_entry = entry; + entry = entry->next; + memp_free(MEMP_LOCALHOSTLIST, free_entry); + removed++; + } else { + last_entry = entry; + entry = entry->next; + } + } + return removed; +} + +/** + * @ingroup dns + * Add a hostname/IP address pair to the local host-list. + * Duplicates are not checked. + * + * @param hostname hostname of the new entry + * @param addr IP address of the new entry + * @return ERR_OK if succeeded or ERR_MEM on memory error + */ +err_t +dns_local_addhost(const char *hostname, const ip_addr_t *addr) +{ + struct local_hostlist_entry *entry; + size_t namelen; + char *entry_name; + LWIP_ASSERT("invalid host name (NULL)", hostname != NULL); + namelen = strlen(hostname); + LWIP_ASSERT("namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN", namelen <= DNS_LOCAL_HOSTLIST_MAX_NAMELEN); + entry = (struct local_hostlist_entry *)memp_malloc(MEMP_LOCALHOSTLIST); + if (entry == NULL) { + return ERR_MEM; + } + entry_name = (char *)entry + sizeof(struct local_hostlist_entry); + MEMCPY(entry_name, hostname, namelen); + entry_name[namelen] = 0; + entry->name = entry_name; + ip_addr_copy(entry->addr, *addr); + entry->next = local_hostlist_dynamic; + local_hostlist_dynamic = entry; + return ERR_OK; +} +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC*/ +#endif /* DNS_LOCAL_HOSTLIST */ + +/** + * @ingroup dns + * Look up a hostname in the array of known hostnames. + * + * @note This function only looks in the internal array of known + * hostnames, it does not send out a query for the hostname if none + * was found. The function dns_enqueue() can be used to send a query + * for a hostname. + * + * @param name the hostname to look up + * @param addr the hostname's IP address, as u32_t (instead of ip_addr_t to + * better check for failure: != IPADDR_NONE) or IPADDR_NONE if the hostname + * was not found in the cached dns_table. + * @return ERR_OK if found, ERR_ARG if not found + */ +static err_t +dns_lookup(const char *name, ip_addr_t *addr LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype)) +{ + u8_t i; +#if DNS_LOCAL_HOSTLIST + if (dns_lookup_local(name, addr LWIP_DNS_ADDRTYPE_ARG(dns_addrtype)) == ERR_OK) { + return ERR_OK; + } +#endif /* DNS_LOCAL_HOSTLIST */ +#ifdef DNS_LOOKUP_LOCAL_EXTERN + if (DNS_LOOKUP_LOCAL_EXTERN(name, addr, LWIP_DNS_ADDRTYPE_ARG_OR_ZERO(dns_addrtype)) == ERR_OK) { + return ERR_OK; + } +#endif /* DNS_LOOKUP_LOCAL_EXTERN */ + + /* Walk through name list, return entry if found. If not, return NULL. */ + for (i = 0; i < DNS_TABLE_SIZE; ++i) { + if ((dns_table[i].state == DNS_STATE_DONE) && + (lwip_strnicmp(name, dns_table[i].name, sizeof(dns_table[i].name)) == 0) && + LWIP_DNS_ADDRTYPE_MATCH_IP(dns_addrtype, dns_table[i].ipaddr)) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_lookup: \"%s\": found = ", name)); + ip_addr_debug_print_val(DNS_DEBUG, dns_table[i].ipaddr); + LWIP_DEBUGF(DNS_DEBUG, ("\n")); + if (addr) { + ip_addr_copy(*addr, dns_table[i].ipaddr); + } + return ERR_OK; + } + } + + return ERR_ARG; +} + +/** + * Compare the "dotted" name "query" with the encoded name "response" + * to make sure an answer from the DNS server matches the current dns_table + * entry (otherwise, answers might arrive late for hostname not on the list + * any more). + * + * For now, this function compares case-insensitive to cope with all kinds of + * servers. This also means that "dns 0x20 bit encoding" must be checked + * externally, if we want to implement it. + * Currently, the request is sent exactly as passed in by he user request. + * + * @param query hostname (not encoded) from the dns_table + * @param p pbuf containing the encoded hostname in the DNS response + * @param start_offset offset into p where the name starts + * @return 0xFFFF: names differ, other: names equal -> offset behind name + */ +static u16_t +dns_compare_name(const char *query, struct pbuf *p, u16_t start_offset) +{ + int n; + u16_t response_offset = start_offset; + + do { + n = pbuf_try_get_at(p, response_offset); + if ((n < 0) || (response_offset == 0xFFFF)) { + /* error or overflow */ + return 0xFFFF; + } + response_offset++; + /** @see RFC 1035 - 4.1.4. Message compression */ + if ((n & 0xc0) == 0xc0) { + /* Compressed name: cannot be equal since we don't send them */ + return 0xFFFF; + } else { + /* Not compressed name */ + while (n > 0) { + int c = pbuf_try_get_at(p, response_offset); + if (c < 0) { + return 0xFFFF; + } + if (lwip_tolower((*query)) != lwip_tolower((u8_t)c)) { + return 0xFFFF; + } + if (response_offset == 0xFFFF) { + /* would overflow */ + return 0xFFFF; + } + response_offset++; + ++query; + --n; + } + ++query; + } + n = pbuf_try_get_at(p, response_offset); + if (n < 0) { + return 0xFFFF; + } + } while (n != 0); + + if (response_offset == 0xFFFF) { + /* would overflow */ + return 0xFFFF; + } + return (u16_t)(response_offset + 1); +} + +/** + * Walk through a compact encoded DNS name and return the end of the name. + * + * @param p pbuf containing the name + * @param query_idx start index into p pointing to encoded DNS name in the DNS server response + * @return index to end of the name + */ +static u16_t +dns_skip_name(struct pbuf *p, u16_t query_idx) +{ + int n; + u16_t offset = query_idx; + + do { + n = pbuf_try_get_at(p, offset++); + if ((n < 0) || (offset == 0)) { + return 0xFFFF; + } + /** @see RFC 1035 - 4.1.4. Message compression */ + if ((n & 0xc0) == 0xc0) { + /* Compressed name: since we only want to skip it (not check it), stop here */ + break; + } else { + /* Not compressed name */ + if (offset + n >= p->tot_len) { + return 0xFFFF; + } + offset = (u16_t)(offset + n); + } + n = pbuf_try_get_at(p, offset); + if (n < 0) { + return 0xFFFF; + } + } while (n != 0); + + if (offset == 0xFFFF) { + return 0xFFFF; + } + return (u16_t)(offset + 1); +} + +/** + * Send a DNS query packet. + * + * @param idx the DNS table entry index for which to send a request + * @return ERR_OK if packet is sent; an err_t indicating the problem otherwise + */ +static err_t +dns_send(u8_t idx) +{ + err_t err; + struct dns_hdr hdr; + struct dns_query qry; + struct pbuf *p; + u16_t query_idx, copy_len; + const char *hostname, *hostname_part; + u8_t n; + u8_t pcb_idx; + struct dns_table_entry *entry = &dns_table[idx]; + + LWIP_DEBUGF(DNS_DEBUG, ("dns_send: dns_servers[%"U16_F"] \"%s\": request\n", + (u16_t)(entry->server_idx), entry->name)); + LWIP_ASSERT("dns server out of array", entry->server_idx < DNS_MAX_SERVERS); + if (ip_addr_isany_val(dns_servers[entry->server_idx]) +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + && !entry->is_mdns +#endif + ) { + /* DNS server not valid anymore, e.g. PPP netif has been shut down */ + /* call specified callback function if provided */ + dns_call_found(idx, NULL); + /* flush this entry */ + entry->state = DNS_STATE_UNUSED; + return ERR_OK; + } + + /* if here, we have either a new query or a retry on a previous query to process */ + p = pbuf_alloc(PBUF_TRANSPORT, (u16_t)(SIZEOF_DNS_HDR + strlen(entry->name) + 2 + + SIZEOF_DNS_QUERY), PBUF_RAM); + if (p != NULL) { + const ip_addr_t *dst; + u16_t dst_port; + /* fill dns header */ + memset(&hdr, 0, SIZEOF_DNS_HDR); + hdr.id = lwip_htons(entry->txid); + hdr.flags1 = DNS_FLAG1_RD; + hdr.numquestions = PP_HTONS(1); + pbuf_take(p, &hdr, SIZEOF_DNS_HDR); + hostname = entry->name; + --hostname; + + /* convert hostname into suitable query format. */ + query_idx = SIZEOF_DNS_HDR; + do { + ++hostname; + hostname_part = hostname; + for (n = 0; *hostname != '.' && *hostname != 0; ++hostname) { + ++n; + } + copy_len = (u16_t)(hostname - hostname_part); + if (query_idx + n + 1 > 0xFFFF) { + /* u16_t overflow */ + goto overflow_return; + } + pbuf_put_at(p, query_idx, n); + pbuf_take_at(p, hostname_part, copy_len, (u16_t)(query_idx + 1)); + query_idx = (u16_t)(query_idx + n + 1); + } while (*hostname != 0); + pbuf_put_at(p, query_idx, 0); + query_idx++; + + /* fill dns query */ + if (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) { + qry.type = PP_HTONS(DNS_RRTYPE_AAAA); + } else { + qry.type = PP_HTONS(DNS_RRTYPE_A); + } + qry.cls = PP_HTONS(DNS_RRCLASS_IN); + pbuf_take_at(p, &qry, SIZEOF_DNS_QUERY, query_idx); + +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) + pcb_idx = entry->pcb_idx; +#else + pcb_idx = 0; +#endif + /* send dns packet */ + LWIP_DEBUGF(DNS_DEBUG, ("sending DNS request ID %d for name \"%s\" to server %d\r\n", + entry->txid, entry->name, entry->server_idx)); +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + if (entry->is_mdns) { + dst_port = DNS_MQUERY_PORT; +#if LWIP_IPV6 + if (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) { + dst = &dns_mquery_v6group; + } +#endif +#if LWIP_IPV4 && LWIP_IPV6 + else +#endif +#if LWIP_IPV4 + { + dst = &dns_mquery_v4group; + } +#endif + } else +#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ + { + dst_port = DNS_SERVER_PORT; + dst = &dns_servers[entry->server_idx]; + } + err = udp_sendto(dns_pcbs[pcb_idx], p, dst, dst_port); + + /* free pbuf */ + pbuf_free(p); + } else { + err = ERR_MEM; + } + + return err; +overflow_return: + pbuf_free(p); + return ERR_VAL; +} + +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) +static struct udp_pcb * +dns_alloc_random_port(void) +{ + err_t err; + struct udp_pcb *pcb; + + pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + if (pcb == NULL) { + /* out of memory, have to reuse an existing pcb */ + return NULL; + } + do { + u16_t port = (u16_t)DNS_RAND_TXID(); + if (DNS_PORT_ALLOWED(port)) { + err = udp_bind(pcb, IP_ANY_TYPE, port); + } else { + /* this port is not allowed, try again */ + err = ERR_USE; + } + } while (err == ERR_USE); + if (err != ERR_OK) { + udp_remove(pcb); + return NULL; + } + udp_recv(pcb, dns_recv, NULL); + return pcb; +} + +/** + * dns_alloc_pcb() - allocates a new pcb (or reuses an existing one) to be used + * for sending a request + * + * @return an index into dns_pcbs + */ +static u8_t +dns_alloc_pcb(void) +{ + u8_t i; + u8_t idx; + + for (i = 0; i < DNS_MAX_SOURCE_PORTS; i++) { + if (dns_pcbs[i] == NULL) { + break; + } + } + if (i < DNS_MAX_SOURCE_PORTS) { + dns_pcbs[i] = dns_alloc_random_port(); + if (dns_pcbs[i] != NULL) { + /* succeeded */ + dns_last_pcb_idx = i; + return i; + } + } + /* if we come here, creating a new UDP pcb failed, so we have to use + an already existing one (so overflow is no issue) */ + for (i = 0, idx = (u8_t)(dns_last_pcb_idx + 1); i < DNS_MAX_SOURCE_PORTS; i++, idx++) { + if (idx >= DNS_MAX_SOURCE_PORTS) { + idx = 0; + } + if (dns_pcbs[idx] != NULL) { + dns_last_pcb_idx = idx; + return idx; + } + } + return DNS_MAX_SOURCE_PORTS; +} +#endif /* ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) */ + +/** + * dns_call_found() - call the found callback and check if there are duplicate + * entries for the given hostname. If there are any, their found callback will + * be called and they will be removed. + * + * @param idx dns table index of the entry that is resolved or removed + * @param addr IP address for the hostname (or NULL on error or memory shortage) + */ +static void +dns_call_found(u8_t idx, ip_addr_t *addr) +{ +#if ((LWIP_DNS_SECURE & (LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING | LWIP_DNS_SECURE_RAND_SRC_PORT)) != 0) + u8_t i; +#endif + +#if LWIP_IPV4 && LWIP_IPV6 + if (addr != NULL) { + /* check that address type matches the request and adapt the table entry */ + if (IP_IS_V6_VAL(*addr)) { + LWIP_ASSERT("invalid response", LWIP_DNS_ADDRTYPE_IS_IPV6(dns_table[idx].reqaddrtype)); + dns_table[idx].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV6; + } else { + LWIP_ASSERT("invalid response", !LWIP_DNS_ADDRTYPE_IS_IPV6(dns_table[idx].reqaddrtype)); + dns_table[idx].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV4; + } + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) + for (i = 0; i < DNS_MAX_REQUESTS; i++) { + if (dns_requests[i].found && (dns_requests[i].dns_table_idx == idx)) { + (*dns_requests[i].found)(dns_table[idx].name, addr, dns_requests[i].arg); + /* flush this entry */ + dns_requests[i].found = NULL; + } + } +#else + if (dns_requests[idx].found) { + (*dns_requests[idx].found)(dns_table[idx].name, addr, dns_requests[idx].arg); + } + dns_requests[idx].found = NULL; +#endif +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) + /* close the pcb used unless other request are using it */ + for (i = 0; i < DNS_MAX_REQUESTS; i++) { + if (i == idx) { + continue; /* only check other requests */ + } + if (dns_table[i].state == DNS_STATE_ASKING) { + if (dns_table[i].pcb_idx == dns_table[idx].pcb_idx) { + /* another request is still using the same pcb */ + dns_table[idx].pcb_idx = DNS_MAX_SOURCE_PORTS; + break; + } + } + } + if (dns_table[idx].pcb_idx < DNS_MAX_SOURCE_PORTS) { + /* if we come here, the pcb is not used any more and can be removed */ + udp_remove(dns_pcbs[dns_table[idx].pcb_idx]); + dns_pcbs[dns_table[idx].pcb_idx] = NULL; + dns_table[idx].pcb_idx = DNS_MAX_SOURCE_PORTS; + } +#endif +} + +/* Create a query transmission ID that is unique for all outstanding queries */ +static u16_t +dns_create_txid(void) +{ + u16_t txid; + u8_t i; + +again: + txid = (u16_t)DNS_RAND_TXID(); + + /* check whether the ID is unique */ + for (i = 0; i < DNS_TABLE_SIZE; i++) { + if ((dns_table[i].state == DNS_STATE_ASKING) && + (dns_table[i].txid == txid)) { + /* ID already used by another pending query */ + goto again; + } + } + + return txid; +} + +/** + * Check whether there are other backup DNS servers available to try + */ +static u8_t +dns_backupserver_available(struct dns_table_entry *pentry) +{ + u8_t ret = 0; + + if (pentry) { + if ((pentry->server_idx + 1 < DNS_MAX_SERVERS) && !ip_addr_isany_val(dns_servers[pentry->server_idx + 1])) { + ret = 1; + } + } + + return ret; +} + +/** + * dns_check_entry() - see if entry has not yet been queried and, if so, sends out a query. + * Check an entry in the dns_table: + * - send out query for new entries + * - retry old pending entries on timeout (also with different servers) + * - remove completed entries from the table if their TTL has expired + * + * @param i index of the dns_table entry to check + */ +static void +dns_check_entry(u8_t i) +{ + err_t err; + struct dns_table_entry *entry = &dns_table[i]; + + LWIP_ASSERT("array index out of bounds", i < DNS_TABLE_SIZE); + + switch (entry->state) { + case DNS_STATE_NEW: + /* initialize new entry */ + entry->txid = dns_create_txid(); + entry->state = DNS_STATE_ASKING; + entry->server_idx = 0; + entry->tmr = 1; + entry->retries = 0; + + /* send DNS packet for this entry */ + err = dns_send(i); + if (err != ERR_OK) { + LWIP_DEBUGF(DNS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("dns_send returned error: %s\n", lwip_strerr(err))); + } + break; + case DNS_STATE_ASKING: + if (--entry->tmr == 0) { + if (++entry->retries == DNS_MAX_RETRIES) { + if (dns_backupserver_available(entry) +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + && !entry->is_mdns +#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ + ) { + /* change of server */ + entry->server_idx++; + entry->tmr = 1; + entry->retries = 0; + } else { + LWIP_DEBUGF(DNS_DEBUG, ("dns_check_entry: \"%s\": timeout\n", entry->name)); + /* call specified callback function if provided */ + dns_call_found(i, NULL); + /* flush this entry */ + entry->state = DNS_STATE_UNUSED; + break; + } + } else { + /* wait longer for the next retry */ + entry->tmr = entry->retries; + } + + /* send DNS packet for this entry */ + err = dns_send(i); + if (err != ERR_OK) { + LWIP_DEBUGF(DNS_DEBUG | LWIP_DBG_LEVEL_WARNING, + ("dns_send returned error: %s\n", lwip_strerr(err))); + } + } + break; + case DNS_STATE_DONE: + /* if the time to live is nul */ + if ((entry->ttl == 0) || (--entry->ttl == 0)) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_check_entry: \"%s\": flush\n", entry->name)); + /* flush this entry, there cannot be any related pending entries in this state */ + entry->state = DNS_STATE_UNUSED; + } + break; + case DNS_STATE_UNUSED: + /* nothing to do */ + break; + default: + LWIP_ASSERT("unknown dns_table entry state:", 0); + break; + } +} + +/** + * Call dns_check_entry for each entry in dns_table - check all entries. + */ +static void +dns_check_entries(void) +{ + u8_t i; + + for (i = 0; i < DNS_TABLE_SIZE; ++i) { + dns_check_entry(i); + } +} + +/** + * Save TTL and call dns_call_found for correct response. + */ +static void +dns_correct_response(u8_t idx, u32_t ttl) +{ + struct dns_table_entry *entry = &dns_table[idx]; + + entry->state = DNS_STATE_DONE; + + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response = ", entry->name)); + ip_addr_debug_print_val(DNS_DEBUG, entry->ipaddr); + LWIP_DEBUGF(DNS_DEBUG, ("\n")); + + /* read the answer resource record's TTL, and maximize it if needed */ + entry->ttl = ttl; + if (entry->ttl > DNS_MAX_TTL) { + entry->ttl = DNS_MAX_TTL; + } + dns_call_found(idx, &entry->ipaddr); + + if (entry->ttl == 0) { + /* RFC 883, page 29: "Zero values are + interpreted to mean that the RR can only be used for the + transaction in progress, and should not be cached." + -> flush this entry now */ + /* entry reused during callback? */ + if (entry->state == DNS_STATE_DONE) { + entry->state = DNS_STATE_UNUSED; + } + } +} + +/** + * Receive input function for DNS response packets arriving for the dns UDP pcb. + */ +static void +dns_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + u8_t i; + u16_t txid; + u16_t res_idx; + struct dns_hdr hdr; + struct dns_answer ans; + struct dns_query qry; + u16_t nquestions, nanswers; + + LWIP_UNUSED_ARG(arg); + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(port); + + /* is the dns message big enough ? */ + if (p->tot_len < (SIZEOF_DNS_HDR + SIZEOF_DNS_QUERY)) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: pbuf too small\n")); + /* free pbuf and return */ + goto ignore_packet; + } + + /* copy dns payload inside static buffer for processing */ + if (pbuf_copy_partial(p, &hdr, SIZEOF_DNS_HDR, 0) == SIZEOF_DNS_HDR) { + /* Match the ID in the DNS header with the name table. */ + txid = lwip_htons(hdr.id); + for (i = 0; i < DNS_TABLE_SIZE; i++) { + struct dns_table_entry *entry = &dns_table[i]; + if ((entry->state == DNS_STATE_ASKING) && + (entry->txid == txid)) { + + /* We only care about the question(s) and the answers. The authrr + and the extrarr are simply discarded. */ + nquestions = lwip_htons(hdr.numquestions); + nanswers = lwip_htons(hdr.numanswers); + + /* Check for correct response. */ + if ((hdr.flags1 & DNS_FLAG1_RESPONSE) == 0) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": not a response\n", entry->name)); + goto ignore_packet; /* ignore this packet */ + } + if (nquestions != 1) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response not match to query\n", entry->name)); + goto ignore_packet; /* ignore this packet */ + } + +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + if (!entry->is_mdns) +#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ + { + /* Check whether response comes from the same network address to which the + question was sent. (RFC 5452) */ + if (!ip_addr_cmp(addr, &dns_servers[entry->server_idx])) { + goto ignore_packet; /* ignore this packet */ + } + } + + /* Check if the name in the "question" part match with the name in the entry and + skip it if equal. */ + res_idx = dns_compare_name(entry->name, p, SIZEOF_DNS_HDR); + if (res_idx == 0xFFFF) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response not match to query\n", entry->name)); + goto ignore_packet; /* ignore this packet */ + } + + /* check if "question" part matches the request */ + if (pbuf_copy_partial(p, &qry, SIZEOF_DNS_QUERY, res_idx) != SIZEOF_DNS_QUERY) { + goto ignore_packet; /* ignore this packet */ + } + if ((qry.cls != PP_HTONS(DNS_RRCLASS_IN)) || + (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype) && (qry.type != PP_HTONS(DNS_RRTYPE_AAAA))) || + (!LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype) && (qry.type != PP_HTONS(DNS_RRTYPE_A)))) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": response not match to query\n", entry->name)); + goto ignore_packet; /* ignore this packet */ + } + /* skip the rest of the "question" part */ + if (res_idx + SIZEOF_DNS_QUERY > 0xFFFF) { + goto ignore_packet; + } + res_idx = (u16_t)(res_idx + SIZEOF_DNS_QUERY); + + /* Check for error. If so, call callback to inform. */ + if (hdr.flags2 & DNS_FLAG2_ERR_MASK) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": error in flags\n", entry->name)); + + /* if there is another backup DNS server to try + * then don't stop the DNS request + */ + if (dns_backupserver_available(entry)) { + /* avoid retrying the same server */ + entry->retries = DNS_MAX_RETRIES-1; + entry->tmr = 1; + + /* contact next available server for this entry */ + dns_check_entry(i); + + goto ignore_packet; + } + } else { + while ((nanswers > 0) && (res_idx < p->tot_len)) { + /* skip answer resource record's host name */ + res_idx = dns_skip_name(p, res_idx); + if (res_idx == 0xFFFF) { + goto ignore_packet; /* ignore this packet */ + } + + /* Check for IP address type and Internet class. Others are discarded. */ + if (pbuf_copy_partial(p, &ans, SIZEOF_DNS_ANSWER, res_idx) != SIZEOF_DNS_ANSWER) { + goto ignore_packet; /* ignore this packet */ + } + if (res_idx + SIZEOF_DNS_ANSWER > 0xFFFF) { + goto ignore_packet; + } + res_idx = (u16_t)(res_idx + SIZEOF_DNS_ANSWER); + + if (ans.cls == PP_HTONS(DNS_RRCLASS_IN)) { +#if LWIP_IPV4 + if ((ans.type == PP_HTONS(DNS_RRTYPE_A)) && (ans.len == PP_HTONS(sizeof(ip4_addr_t)))) { +#if LWIP_IPV4 && LWIP_IPV6 + if (!LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + { + ip4_addr_t ip4addr; + /* read the IP address after answer resource record's header */ + if (pbuf_copy_partial(p, &ip4addr, sizeof(ip4_addr_t), res_idx) != sizeof(ip4_addr_t)) { + goto ignore_packet; /* ignore this packet */ + } + ip_addr_copy_from_ip4(dns_table[i].ipaddr, ip4addr); + pbuf_free(p); + /* handle correct response */ + dns_correct_response(i, lwip_ntohl(ans.ttl)); + return; + } + } +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 + if ((ans.type == PP_HTONS(DNS_RRTYPE_AAAA)) && (ans.len == PP_HTONS(sizeof(ip6_addr_p_t)))) { +#if LWIP_IPV4 && LWIP_IPV6 + if (LWIP_DNS_ADDRTYPE_IS_IPV6(entry->reqaddrtype)) +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + { + ip6_addr_p_t ip6addr; + /* read the IP address after answer resource record's header */ + if (pbuf_copy_partial(p, &ip6addr, sizeof(ip6_addr_p_t), res_idx) != sizeof(ip6_addr_p_t)) { + goto ignore_packet; /* ignore this packet */ + } + /* @todo: scope ip6addr? Might be required for link-local addresses at least? */ + ip_addr_copy_from_ip6_packed(dns_table[i].ipaddr, ip6addr); + pbuf_free(p); + /* handle correct response */ + dns_correct_response(i, lwip_ntohl(ans.ttl)); + return; + } + } +#endif /* LWIP_IPV6 */ + } + /* skip this answer */ + if ((int)(res_idx + lwip_htons(ans.len)) > 0xFFFF) { + goto ignore_packet; /* ignore this packet */ + } + res_idx = (u16_t)(res_idx + lwip_htons(ans.len)); + --nanswers; + } +#if LWIP_IPV4 && LWIP_IPV6 + if ((entry->reqaddrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) || + (entry->reqaddrtype == LWIP_DNS_ADDRTYPE_IPV6_IPV4)) { + if (entry->reqaddrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) { + /* IPv4 failed, try IPv6 */ + dns_table[i].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV6; + } else { + /* IPv6 failed, try IPv4 */ + dns_table[i].reqaddrtype = LWIP_DNS_ADDRTYPE_IPV4; + } + pbuf_free(p); + dns_table[i].state = DNS_STATE_NEW; + dns_check_entry(i); + return; + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + LWIP_DEBUGF(DNS_DEBUG, ("dns_recv: \"%s\": error in response\n", entry->name)); + } + /* call callback to indicate error, clean up memory and return */ + pbuf_free(p); + dns_call_found(i, NULL); + dns_table[i].state = DNS_STATE_UNUSED; + return; + } + } + } + +ignore_packet: + /* deallocate memory and return */ + pbuf_free(p); + return; +} + +/** + * Queues a new hostname to resolve and sends out a DNS query for that hostname + * + * @param name the hostname that is to be queried + * @param hostnamelen length of the hostname + * @param found a callback function to be called on success, failure or timeout + * @param callback_arg argument to pass to the callback function + * @return err_t return code. + */ +static err_t +dns_enqueue(const char *name, size_t hostnamelen, dns_found_callback found, + void *callback_arg LWIP_DNS_ADDRTYPE_ARG(u8_t dns_addrtype) LWIP_DNS_ISMDNS_ARG(u8_t is_mdns)) +{ + u8_t i; + u8_t lseq, lseqi; + struct dns_table_entry *entry = NULL; + size_t namelen; + struct dns_req_entry *req; + +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) + u8_t r; + /* check for duplicate entries */ + for (i = 0; i < DNS_TABLE_SIZE; i++) { + if ((dns_table[i].state == DNS_STATE_ASKING) && + (lwip_strnicmp(name, dns_table[i].name, sizeof(dns_table[i].name)) == 0)) { +#if LWIP_IPV4 && LWIP_IPV6 + if (dns_table[i].reqaddrtype != dns_addrtype) { + /* requested address types don't match + this can lead to 2 concurrent requests, but mixing the address types + for the same host should not be that common */ + continue; + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + /* this is a duplicate entry, find a free request entry */ + for (r = 0; r < DNS_MAX_REQUESTS; r++) { + if (dns_requests[r].found == 0) { + dns_requests[r].found = found; + dns_requests[r].arg = callback_arg; + dns_requests[r].dns_table_idx = i; + LWIP_DNS_SET_ADDRTYPE(dns_requests[r].reqaddrtype, dns_addrtype); + LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": duplicate request\n", name)); + return ERR_INPROGRESS; + } + } + } + } + /* no duplicate entries found */ +#endif + + /* search an unused entry, or the oldest one */ + lseq = 0; + lseqi = DNS_TABLE_SIZE; + for (i = 0; i < DNS_TABLE_SIZE; ++i) { + entry = &dns_table[i]; + /* is it an unused entry ? */ + if (entry->state == DNS_STATE_UNUSED) { + break; + } + /* check if this is the oldest completed entry */ + if (entry->state == DNS_STATE_DONE) { + u8_t age = (u8_t)(dns_seqno - entry->seqno); + if (age > lseq) { + lseq = age; + lseqi = i; + } + } + } + + /* if we don't have found an unused entry, use the oldest completed one */ + if (i == DNS_TABLE_SIZE) { + if ((lseqi >= DNS_TABLE_SIZE) || (dns_table[lseqi].state != DNS_STATE_DONE)) { + /* no entry can be used now, table is full */ + LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": DNS entries table is full\n", name)); + return ERR_MEM; + } else { + /* use the oldest completed one */ + i = lseqi; + entry = &dns_table[i]; + } + } + +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING) != 0) + /* find a free request entry */ + req = NULL; + for (r = 0; r < DNS_MAX_REQUESTS; r++) { + if (dns_requests[r].found == NULL) { + req = &dns_requests[r]; + break; + } + } + if (req == NULL) { + /* no request entry can be used now, table is full */ + LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": DNS request entries table is full\n", name)); + return ERR_MEM; + } + req->dns_table_idx = i; +#else + /* in this configuration, the entry index is the same as the request index */ + req = &dns_requests[i]; +#endif + + /* use this entry */ + LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": use DNS entry %"U16_F"\n", name, (u16_t)(i))); + + /* fill the entry */ + entry->state = DNS_STATE_NEW; + entry->seqno = dns_seqno; + LWIP_DNS_SET_ADDRTYPE(entry->reqaddrtype, dns_addrtype); + LWIP_DNS_SET_ADDRTYPE(req->reqaddrtype, dns_addrtype); + req->found = found; + req->arg = callback_arg; + namelen = LWIP_MIN(hostnamelen, DNS_MAX_NAME_LENGTH - 1); + MEMCPY(entry->name, name, namelen); + entry->name[namelen] = 0; + +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) != 0) + entry->pcb_idx = dns_alloc_pcb(); + if (entry->pcb_idx >= DNS_MAX_SOURCE_PORTS) { + /* failed to get a UDP pcb */ + LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": failed to allocate a pcb\n", name)); + entry->state = DNS_STATE_UNUSED; + req->found = NULL; + return ERR_MEM; + } + LWIP_DEBUGF(DNS_DEBUG, ("dns_enqueue: \"%s\": use DNS pcb %"U16_F"\n", name, (u16_t)(entry->pcb_idx))); +#endif + +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + entry->is_mdns = is_mdns; +#endif + + dns_seqno++; + + /* force to send query without waiting timer */ + dns_check_entry(i); + + /* dns query is enqueued */ + return ERR_INPROGRESS; +} + +/** + * @ingroup dns + * Resolve a hostname (string) into an IP address. + * NON-BLOCKING callback version for use with raw API!!! + * + * Returns immediately with one of err_t return codes: + * - ERR_OK if hostname is a valid IP address string or the host + * name is already in the local names table. + * - ERR_INPROGRESS enqueue a request to be sent to the DNS server + * for resolution if no errors are present. + * - ERR_ARG: dns client not initialized or invalid hostname + * + * @param hostname the hostname that is to be queried + * @param addr pointer to a ip_addr_t where to store the address if it is already + * cached in the dns_table (only valid if ERR_OK is returned!) + * @param found a callback function to be called on success, failure or timeout (only if + * ERR_INPROGRESS is returned!) + * @param callback_arg argument to pass to the callback function + * @return a err_t return code. + */ +err_t +dns_gethostbyname(const char *hostname, ip_addr_t *addr, dns_found_callback found, + void *callback_arg) +{ + return dns_gethostbyname_addrtype(hostname, addr, found, callback_arg, LWIP_DNS_ADDRTYPE_DEFAULT); +} + +/** + * @ingroup dns + * Like dns_gethostbyname, but returned address type can be controlled: + * @param hostname the hostname that is to be queried + * @param addr pointer to a ip_addr_t where to store the address if it is already + * cached in the dns_table (only valid if ERR_OK is returned!) + * @param found a callback function to be called on success, failure or timeout (only if + * ERR_INPROGRESS is returned!) + * @param callback_arg argument to pass to the callback function + * @param dns_addrtype - LWIP_DNS_ADDRTYPE_IPV4_IPV6: try to resolve IPv4 first, try IPv6 if IPv4 fails only + * - LWIP_DNS_ADDRTYPE_IPV6_IPV4: try to resolve IPv6 first, try IPv4 if IPv6 fails only + * - LWIP_DNS_ADDRTYPE_IPV4: try to resolve IPv4 only + * - LWIP_DNS_ADDRTYPE_IPV6: try to resolve IPv6 only + */ +err_t +dns_gethostbyname_addrtype(const char *hostname, ip_addr_t *addr, dns_found_callback found, + void *callback_arg, u8_t dns_addrtype) +{ + size_t hostnamelen; +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + u8_t is_mdns; +#endif + /* not initialized or no valid server yet, or invalid addr pointer + * or invalid hostname or invalid hostname length */ + if ((addr == NULL) || + (!hostname) || (!hostname[0])) { + return ERR_ARG; + } +#if ((LWIP_DNS_SECURE & LWIP_DNS_SECURE_RAND_SRC_PORT) == 0) + if (dns_pcbs[0] == NULL) { + return ERR_ARG; + } +#endif + hostnamelen = strlen(hostname); + if (hostnamelen >= DNS_MAX_NAME_LENGTH) { + LWIP_DEBUGF(DNS_DEBUG, ("dns_gethostbyname: name too long to resolve")); + return ERR_ARG; + } + + +#if LWIP_HAVE_LOOPIF + if (strcmp(hostname, "localhost") == 0) { + ip_addr_set_loopback(LWIP_DNS_ADDRTYPE_IS_IPV6(dns_addrtype), addr); + return ERR_OK; + } +#endif /* LWIP_HAVE_LOOPIF */ + + /* host name already in octet notation? set ip addr and return ERR_OK */ + if (ipaddr_aton(hostname, addr)) { +#if LWIP_IPV4 && LWIP_IPV6 + if ((IP_IS_V6(addr) && (dns_addrtype != LWIP_DNS_ADDRTYPE_IPV4)) || + (IP_IS_V4(addr) && (dns_addrtype != LWIP_DNS_ADDRTYPE_IPV6))) +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + { + return ERR_OK; + } + } + /* already have this address cached? */ + if (dns_lookup(hostname, addr LWIP_DNS_ADDRTYPE_ARG(dns_addrtype)) == ERR_OK) { + return ERR_OK; + } +#if LWIP_IPV4 && LWIP_IPV6 + if ((dns_addrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) || (dns_addrtype == LWIP_DNS_ADDRTYPE_IPV6_IPV4)) { + /* fallback to 2nd IP type and try again to lookup */ + u8_t fallback; + if (dns_addrtype == LWIP_DNS_ADDRTYPE_IPV4_IPV6) { + fallback = LWIP_DNS_ADDRTYPE_IPV6; + } else { + fallback = LWIP_DNS_ADDRTYPE_IPV4; + } + if (dns_lookup(hostname, addr LWIP_DNS_ADDRTYPE_ARG(fallback)) == ERR_OK) { + return ERR_OK; + } + } +#else /* LWIP_IPV4 && LWIP_IPV6 */ + LWIP_UNUSED_ARG(dns_addrtype); +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + +#if LWIP_DNS_SUPPORT_MDNS_QUERIES + if (strstr(hostname, ".local") == &hostname[hostnamelen] - 6) { + is_mdns = 1; + } else { + is_mdns = 0; + } + + if (!is_mdns) +#endif /* LWIP_DNS_SUPPORT_MDNS_QUERIES */ + { + /* prevent calling found callback if no server is set, return error instead */ + if (ip_addr_isany_val(dns_servers[0])) { + return ERR_VAL; + } + } + + /* queue query with specified callback */ + return dns_enqueue(hostname, hostnamelen, found, callback_arg LWIP_DNS_ADDRTYPE_ARG(dns_addrtype) + LWIP_DNS_ISMDNS_ARG(is_mdns)); +} + +#endif /* LWIP_DNS */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/inet_chksum.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/inet_chksum.c index 25255b90..818c68f4 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/inet_chksum.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/inet_chksum.c @@ -1,608 +1,608 @@ -/** - * @file - * Internet checksum functions.\n - * - * These are some reference implementations of the checksum algorithm, with the - * aim of being simple, correct and fully portable. Checksumming is the - * first thing you would want to optimize for your platform. If you create - * your own version, link it in and in your cc.h put: - * - * \#define LWIP_CHKSUM your_checksum_routine - * - * Or you can select from the implementations below by defining - * LWIP_CHKSUM_ALGORITHM to 1, 2 or 3. - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#include "lwip/inet_chksum.h" -#include "lwip/def.h" -#include "lwip/ip_addr.h" - -#include - -#ifndef LWIP_CHKSUM -# define LWIP_CHKSUM lwip_standard_chksum -# ifndef LWIP_CHKSUM_ALGORITHM -# define LWIP_CHKSUM_ALGORITHM 2 -# endif -u16_t lwip_standard_chksum(const void *dataptr, int len); -#endif -/* If none set: */ -#ifndef LWIP_CHKSUM_ALGORITHM -# define LWIP_CHKSUM_ALGORITHM 0 -#endif - -#if (LWIP_CHKSUM_ALGORITHM == 1) /* Version #1 */ -/** - * lwip checksum - * - * @param dataptr points to start of data to be summed at any boundary - * @param len length of data to be summed - * @return host order (!) lwip checksum (non-inverted Internet sum) - * - * @note accumulator size limits summable length to 64k - * @note host endianess is irrelevant (p3 RFC1071) - */ -u16_t -lwip_standard_chksum(const void *dataptr, int len) -{ - u32_t acc; - u16_t src; - const u8_t *octetptr; - - acc = 0; - /* dataptr may be at odd or even addresses */ - octetptr = (const u8_t *)dataptr; - while (len > 1) { - /* declare first octet as most significant - thus assume network order, ignoring host order */ - src = (*octetptr) << 8; - octetptr++; - /* declare second octet as least significant */ - src |= (*octetptr); - octetptr++; - acc += src; - len -= 2; - } - if (len > 0) { - /* accumulate remaining octet */ - src = (*octetptr) << 8; - acc += src; - } - /* add deferred carry bits */ - acc = (acc >> 16) + (acc & 0x0000ffffUL); - if ((acc & 0xffff0000UL) != 0) { - acc = (acc >> 16) + (acc & 0x0000ffffUL); - } - /* This maybe a little confusing: reorder sum using lwip_htons() - instead of lwip_ntohs() since it has a little less call overhead. - The caller must invert bits for Internet sum ! */ - return lwip_htons((u16_t)acc); -} -#endif - -#if (LWIP_CHKSUM_ALGORITHM == 2) /* Alternative version #2 */ -/* - * Curt McDowell - * Broadcom Corp. - * csm@broadcom.com - * - * IP checksum two bytes at a time with support for - * unaligned buffer. - * Works for len up to and including 0x20000. - * by Curt McDowell, Broadcom Corp. 12/08/2005 - * - * @param dataptr points to start of data to be summed at any boundary - * @param len length of data to be summed - * @return host order (!) lwip checksum (non-inverted Internet sum) - */ -u16_t -lwip_standard_chksum(const void *dataptr, int len) -{ - const u8_t *pb = (const u8_t *)dataptr; - const u16_t *ps; - u16_t t = 0; - u32_t sum = 0; - int odd = ((mem_ptr_t)pb & 1); - - /* Get aligned to u16_t */ - if (odd && len > 0) { - ((u8_t *)&t)[1] = *pb++; - len--; - } - - /* Add the bulk of the data */ - ps = (const u16_t *)(const void *)pb; - while (len > 1) { - sum += *ps++; - len -= 2; - } - - /* Consume left-over byte, if any */ - if (len > 0) { - ((u8_t *)&t)[0] = *(const u8_t *)ps; - } - - /* Add end bytes */ - sum += t; - - /* Fold 32-bit sum to 16 bits - calling this twice is probably faster than if statements... */ - sum = FOLD_U32T(sum); - sum = FOLD_U32T(sum); - - /* Swap if alignment was odd */ - if (odd) { - sum = SWAP_BYTES_IN_WORD(sum); - } - - return (u16_t)sum; -} -#endif - -#if (LWIP_CHKSUM_ALGORITHM == 3) /* Alternative version #3 */ -/** - * An optimized checksum routine. Basically, it uses loop-unrolling on - * the checksum loop, treating the head and tail bytes specially, whereas - * the inner loop acts on 8 bytes at a time. - * - * @arg start of buffer to be checksummed. May be an odd byte address. - * @len number of bytes in the buffer to be checksummed. - * @return host order (!) lwip checksum (non-inverted Internet sum) - * - * by Curt McDowell, Broadcom Corp. December 8th, 2005 - */ -u16_t -lwip_standard_chksum(const void *dataptr, int len) -{ - const u8_t *pb = (const u8_t *)dataptr; - const u16_t *ps; - u16_t t = 0; - const u32_t *pl; - u32_t sum = 0, tmp; - /* starts at odd byte address? */ - int odd = ((mem_ptr_t)pb & 1); - - if (odd && len > 0) { - ((u8_t *)&t)[1] = *pb++; - len--; - } - - ps = (const u16_t *)(const void *)pb; - - if (((mem_ptr_t)ps & 3) && len > 1) { - sum += *ps++; - len -= 2; - } - - pl = (const u32_t *)(const void *)ps; - - while (len > 7) { - tmp = sum + *pl++; /* ping */ - if (tmp < sum) { - tmp++; /* add back carry */ - } - - sum = tmp + *pl++; /* pong */ - if (sum < tmp) { - sum++; /* add back carry */ - } - - len -= 8; - } - - /* make room in upper bits */ - sum = FOLD_U32T(sum); - - ps = (const u16_t *)pl; - - /* 16-bit aligned word remaining? */ - while (len > 1) { - sum += *ps++; - len -= 2; - } - - /* dangling tail byte remaining? */ - if (len > 0) { /* include odd byte */ - ((u8_t *)&t)[0] = *(const u8_t *)ps; - } - - sum += t; /* add end bytes */ - - /* Fold 32-bit sum to 16 bits - calling this twice is probably faster than if statements... */ - sum = FOLD_U32T(sum); - sum = FOLD_U32T(sum); - - if (odd) { - sum = SWAP_BYTES_IN_WORD(sum); - } - - return (u16_t)sum; -} -#endif - -/** Parts of the pseudo checksum which are common to IPv4 and IPv6 */ -static u16_t -inet_cksum_pseudo_base(struct pbuf *p, u8_t proto, u16_t proto_len, u32_t acc) -{ - struct pbuf *q; - int swapped = 0; - - /* iterate through all pbuf in chain */ - for (q = p; q != NULL; q = q->next) { - LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n", - (void *)q, (void *)q->next)); - acc += LWIP_CHKSUM(q->payload, q->len); - /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/ - /* just executing this next line is probably faster that the if statement needed - to check whether we really need to execute it, and does no harm */ - acc = FOLD_U32T(acc); - if (q->len % 2 != 0) { - swapped = !swapped; - acc = SWAP_BYTES_IN_WORD(acc); - } - /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/ - } - - if (swapped) { - acc = SWAP_BYTES_IN_WORD(acc); - } - - acc += (u32_t)lwip_htons((u16_t)proto); - acc += (u32_t)lwip_htons(proto_len); - - /* Fold 32-bit sum to 16 bits - calling this twice is probably faster than if statements... */ - acc = FOLD_U32T(acc); - acc = FOLD_U32T(acc); - LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc)); - return (u16_t)~(acc & 0xffffUL); -} - -#if LWIP_IPV4 -/* inet_chksum_pseudo: - * - * Calculates the IPv4 pseudo Internet checksum used by TCP and UDP for a pbuf chain. - * IP addresses are expected to be in network byte order. - * - * @param p chain of pbufs over that a checksum should be calculated (ip data part) - * @param src source ip address (used for checksum of pseudo header) - * @param dst destination ip address (used for checksum of pseudo header) - * @param proto ip protocol (used for checksum of pseudo header) - * @param proto_len length of the ip data part (used for checksum of pseudo header) - * @return checksum (as u16_t) to be saved directly in the protocol header - */ -u16_t -inet_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, - const ip4_addr_t *src, const ip4_addr_t *dest) -{ - u32_t acc; - u32_t addr; - - addr = ip4_addr_get_u32(src); - acc = (addr & 0xffffUL); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - addr = ip4_addr_get_u32(dest); - acc = (u32_t)(acc + (addr & 0xffffUL)); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - /* fold down to 16 bits */ - acc = FOLD_U32T(acc); - acc = FOLD_U32T(acc); - - return inet_cksum_pseudo_base(p, proto, proto_len, acc); -} -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -/** - * Calculates the checksum with IPv6 pseudo header used by TCP and UDP for a pbuf chain. - * IPv6 addresses are expected to be in network byte order. - * - * @param p chain of pbufs over that a checksum should be calculated (ip data part) - * @param proto ipv6 protocol/next header (used for checksum of pseudo header) - * @param proto_len length of the ipv6 payload (used for checksum of pseudo header) - * @param src source ipv6 address (used for checksum of pseudo header) - * @param dest destination ipv6 address (used for checksum of pseudo header) - * @return checksum (as u16_t) to be saved directly in the protocol header - */ -u16_t -ip6_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, - const ip6_addr_t *src, const ip6_addr_t *dest) -{ - u32_t acc = 0; - u32_t addr; - u8_t addr_part; - - for (addr_part = 0; addr_part < 4; addr_part++) { - addr = src->addr[addr_part]; - acc = (u32_t)(acc + (addr & 0xffffUL)); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - addr = dest->addr[addr_part]; - acc = (u32_t)(acc + (addr & 0xffffUL)); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - } - /* fold down to 16 bits */ - acc = FOLD_U32T(acc); - acc = FOLD_U32T(acc); - - return inet_cksum_pseudo_base(p, proto, proto_len, acc); -} -#endif /* LWIP_IPV6 */ - -/* ip_chksum_pseudo: - * - * Calculates the IPv4 or IPv6 pseudo Internet checksum used by TCP and UDP for a pbuf chain. - * IP addresses are expected to be in network byte order. - * - * @param p chain of pbufs over that a checksum should be calculated (ip data part) - * @param src source ip address (used for checksum of pseudo header) - * @param dst destination ip address (used for checksum of pseudo header) - * @param proto ip protocol (used for checksum of pseudo header) - * @param proto_len length of the ip data part (used for checksum of pseudo header) - * @return checksum (as u16_t) to be saved directly in the protocol header - */ -u16_t -ip_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, - const ip_addr_t *src, const ip_addr_t *dest) -{ -#if LWIP_IPV6 - if (IP_IS_V6(dest)) { - return ip6_chksum_pseudo(p, proto, proto_len, ip_2_ip6(src), ip_2_ip6(dest)); - } -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 && LWIP_IPV6 - else -#endif /* LWIP_IPV4 && LWIP_IPV6 */ -#if LWIP_IPV4 - { - return inet_chksum_pseudo(p, proto, proto_len, ip_2_ip4(src), ip_2_ip4(dest)); - } -#endif /* LWIP_IPV4 */ -} - -/** Parts of the pseudo checksum which are common to IPv4 and IPv6 */ -static u16_t -inet_cksum_pseudo_partial_base(struct pbuf *p, u8_t proto, u16_t proto_len, - u16_t chksum_len, u32_t acc) -{ - struct pbuf *q; - int swapped = 0; - u16_t chklen; - - /* iterate through all pbuf in chain */ - for (q = p; (q != NULL) && (chksum_len > 0); q = q->next) { - LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n", - (void *)q, (void *)q->next)); - chklen = q->len; - if (chklen > chksum_len) { - chklen = chksum_len; - } - acc += LWIP_CHKSUM(q->payload, chklen); - chksum_len = (u16_t)(chksum_len - chklen); - LWIP_ASSERT("delete me", chksum_len < 0x7fff); - /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/ - /* fold the upper bit down */ - acc = FOLD_U32T(acc); - if (q->len % 2 != 0) { - swapped = !swapped; - acc = SWAP_BYTES_IN_WORD(acc); - } - /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/ - } - - if (swapped) { - acc = SWAP_BYTES_IN_WORD(acc); - } - - acc += (u32_t)lwip_htons((u16_t)proto); - acc += (u32_t)lwip_htons(proto_len); - - /* Fold 32-bit sum to 16 bits - calling this twice is probably faster than if statements... */ - acc = FOLD_U32T(acc); - acc = FOLD_U32T(acc); - LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc)); - return (u16_t)~(acc & 0xffffUL); -} - -#if LWIP_IPV4 -/* inet_chksum_pseudo_partial: - * - * Calculates the IPv4 pseudo Internet checksum used by TCP and UDP for a pbuf chain. - * IP addresses are expected to be in network byte order. - * - * @param p chain of pbufs over that a checksum should be calculated (ip data part) - * @param src source ip address (used for checksum of pseudo header) - * @param dst destination ip address (used for checksum of pseudo header) - * @param proto ip protocol (used for checksum of pseudo header) - * @param proto_len length of the ip data part (used for checksum of pseudo header) - * @return checksum (as u16_t) to be saved directly in the protocol header - */ -u16_t -inet_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, - u16_t chksum_len, const ip4_addr_t *src, const ip4_addr_t *dest) -{ - u32_t acc; - u32_t addr; - - addr = ip4_addr_get_u32(src); - acc = (addr & 0xffffUL); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - addr = ip4_addr_get_u32(dest); - acc = (u32_t)(acc + (addr & 0xffffUL)); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - /* fold down to 16 bits */ - acc = FOLD_U32T(acc); - acc = FOLD_U32T(acc); - - return inet_cksum_pseudo_partial_base(p, proto, proto_len, chksum_len, acc); -} -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -/** - * Calculates the checksum with IPv6 pseudo header used by TCP and UDP for a pbuf chain. - * IPv6 addresses are expected to be in network byte order. Will only compute for a - * portion of the payload. - * - * @param p chain of pbufs over that a checksum should be calculated (ip data part) - * @param proto ipv6 protocol/next header (used for checksum of pseudo header) - * @param proto_len length of the ipv6 payload (used for checksum of pseudo header) - * @param chksum_len number of payload bytes used to compute chksum - * @param src source ipv6 address (used for checksum of pseudo header) - * @param dest destination ipv6 address (used for checksum of pseudo header) - * @return checksum (as u16_t) to be saved directly in the protocol header - */ -u16_t -ip6_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, - u16_t chksum_len, const ip6_addr_t *src, const ip6_addr_t *dest) -{ - u32_t acc = 0; - u32_t addr; - u8_t addr_part; - - for (addr_part = 0; addr_part < 4; addr_part++) { - addr = src->addr[addr_part]; - acc = (u32_t)(acc + (addr & 0xffffUL)); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - addr = dest->addr[addr_part]; - acc = (u32_t)(acc + (addr & 0xffffUL)); - acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); - } - /* fold down to 16 bits */ - acc = FOLD_U32T(acc); - acc = FOLD_U32T(acc); - - return inet_cksum_pseudo_partial_base(p, proto, proto_len, chksum_len, acc); -} -#endif /* LWIP_IPV6 */ - -/* ip_chksum_pseudo_partial: - * - * Calculates the IPv4 or IPv6 pseudo Internet checksum used by TCP and UDP for a pbuf chain. - * - * @param p chain of pbufs over that a checksum should be calculated (ip data part) - * @param src source ip address (used for checksum of pseudo header) - * @param dst destination ip address (used for checksum of pseudo header) - * @param proto ip protocol (used for checksum of pseudo header) - * @param proto_len length of the ip data part (used for checksum of pseudo header) - * @return checksum (as u16_t) to be saved directly in the protocol header - */ -u16_t -ip_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, - u16_t chksum_len, const ip_addr_t *src, const ip_addr_t *dest) -{ -#if LWIP_IPV6 - if (IP_IS_V6(dest)) { - return ip6_chksum_pseudo_partial(p, proto, proto_len, chksum_len, ip_2_ip6(src), ip_2_ip6(dest)); - } -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 && LWIP_IPV6 - else -#endif /* LWIP_IPV4 && LWIP_IPV6 */ -#if LWIP_IPV4 - { - return inet_chksum_pseudo_partial(p, proto, proto_len, chksum_len, ip_2_ip4(src), ip_2_ip4(dest)); - } -#endif /* LWIP_IPV4 */ -} - -/* inet_chksum: - * - * Calculates the Internet checksum over a portion of memory. Used primarily for IP - * and ICMP. - * - * @param dataptr start of the buffer to calculate the checksum (no alignment needed) - * @param len length of the buffer to calculate the checksum - * @return checksum (as u16_t) to be saved directly in the protocol header - */ - -u16_t -inet_chksum(const void *dataptr, u16_t len) -{ - return (u16_t)~(unsigned int)LWIP_CHKSUM(dataptr, len); -} - -/** - * Calculate a checksum over a chain of pbufs (without pseudo-header, much like - * inet_chksum only pbufs are used). - * - * @param p pbuf chain over that the checksum should be calculated - * @return checksum (as u16_t) to be saved directly in the protocol header - */ -u16_t -inet_chksum_pbuf(struct pbuf *p) -{ - u32_t acc; - struct pbuf *q; - int swapped = 0; - - acc = 0; - for (q = p; q != NULL; q = q->next) { - acc += LWIP_CHKSUM(q->payload, q->len); - acc = FOLD_U32T(acc); - if (q->len % 2 != 0) { - swapped = !swapped; - acc = SWAP_BYTES_IN_WORD(acc); - } - } - - if (swapped) { - acc = SWAP_BYTES_IN_WORD(acc); - } - return (u16_t)~(acc & 0xffffUL); -} - -/* These are some implementations for LWIP_CHKSUM_COPY, which copies data - * like MEMCPY but generates a checksum at the same time. Since this is a - * performance-sensitive function, you might want to create your own version - * in assembly targeted at your hardware by defining it in lwipopts.h: - * #define LWIP_CHKSUM_COPY(dst, src, len) your_chksum_copy(dst, src, len) - */ - -#if (LWIP_CHKSUM_COPY_ALGORITHM == 1) /* Version #1 */ -/** Safe but slow: first call MEMCPY, then call LWIP_CHKSUM. - * For architectures with big caches, data might still be in cache when - * generating the checksum after copying. - */ -u16_t -lwip_chksum_copy(void *dst, const void *src, u16_t len) -{ - MEMCPY(dst, src, len); - return LWIP_CHKSUM(dst, len); -} -#endif /* (LWIP_CHKSUM_COPY_ALGORITHM == 1) */ +/** + * @file + * Internet checksum functions.\n + * + * These are some reference implementations of the checksum algorithm, with the + * aim of being simple, correct and fully portable. Checksumming is the + * first thing you would want to optimize for your platform. If you create + * your own version, link it in and in your cc.h put: + * + * \#define LWIP_CHKSUM your_checksum_routine + * + * Or you can select from the implementations below by defining + * LWIP_CHKSUM_ALGORITHM to 1, 2 or 3. + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#include "lwip/inet_chksum.h" +#include "lwip/def.h" +#include "lwip/ip_addr.h" + +#include + +#ifndef LWIP_CHKSUM +# define LWIP_CHKSUM lwip_standard_chksum +# ifndef LWIP_CHKSUM_ALGORITHM +# define LWIP_CHKSUM_ALGORITHM 2 +# endif +u16_t lwip_standard_chksum(const void *dataptr, int len); +#endif +/* If none set: */ +#ifndef LWIP_CHKSUM_ALGORITHM +# define LWIP_CHKSUM_ALGORITHM 0 +#endif + +#if (LWIP_CHKSUM_ALGORITHM == 1) /* Version #1 */ +/** + * lwip checksum + * + * @param dataptr points to start of data to be summed at any boundary + * @param len length of data to be summed + * @return host order (!) lwip checksum (non-inverted Internet sum) + * + * @note accumulator size limits summable length to 64k + * @note host endianess is irrelevant (p3 RFC1071) + */ +u16_t +lwip_standard_chksum(const void *dataptr, int len) +{ + u32_t acc; + u16_t src; + const u8_t *octetptr; + + acc = 0; + /* dataptr may be at odd or even addresses */ + octetptr = (const u8_t *)dataptr; + while (len > 1) { + /* declare first octet as most significant + thus assume network order, ignoring host order */ + src = (*octetptr) << 8; + octetptr++; + /* declare second octet as least significant */ + src |= (*octetptr); + octetptr++; + acc += src; + len -= 2; + } + if (len > 0) { + /* accumulate remaining octet */ + src = (*octetptr) << 8; + acc += src; + } + /* add deferred carry bits */ + acc = (acc >> 16) + (acc & 0x0000ffffUL); + if ((acc & 0xffff0000UL) != 0) { + acc = (acc >> 16) + (acc & 0x0000ffffUL); + } + /* This maybe a little confusing: reorder sum using lwip_htons() + instead of lwip_ntohs() since it has a little less call overhead. + The caller must invert bits for Internet sum ! */ + return lwip_htons((u16_t)acc); +} +#endif + +#if (LWIP_CHKSUM_ALGORITHM == 2) /* Alternative version #2 */ +/* + * Curt McDowell + * Broadcom Corp. + * csm@broadcom.com + * + * IP checksum two bytes at a time with support for + * unaligned buffer. + * Works for len up to and including 0x20000. + * by Curt McDowell, Broadcom Corp. 12/08/2005 + * + * @param dataptr points to start of data to be summed at any boundary + * @param len length of data to be summed + * @return host order (!) lwip checksum (non-inverted Internet sum) + */ +u16_t +lwip_standard_chksum(const void *dataptr, int len) +{ + const u8_t *pb = (const u8_t *)dataptr; + const u16_t *ps; + u16_t t = 0; + u32_t sum = 0; + int odd = ((mem_ptr_t)pb & 1); + + /* Get aligned to u16_t */ + if (odd && len > 0) { + ((u8_t *)&t)[1] = *pb++; + len--; + } + + /* Add the bulk of the data */ + ps = (const u16_t *)(const void *)pb; + while (len > 1) { + sum += *ps++; + len -= 2; + } + + /* Consume left-over byte, if any */ + if (len > 0) { + ((u8_t *)&t)[0] = *(const u8_t *)ps; + } + + /* Add end bytes */ + sum += t; + + /* Fold 32-bit sum to 16 bits + calling this twice is probably faster than if statements... */ + sum = FOLD_U32T(sum); + sum = FOLD_U32T(sum); + + /* Swap if alignment was odd */ + if (odd) { + sum = SWAP_BYTES_IN_WORD(sum); + } + + return (u16_t)sum; +} +#endif + +#if (LWIP_CHKSUM_ALGORITHM == 3) /* Alternative version #3 */ +/** + * An optimized checksum routine. Basically, it uses loop-unrolling on + * the checksum loop, treating the head and tail bytes specially, whereas + * the inner loop acts on 8 bytes at a time. + * + * @arg start of buffer to be checksummed. May be an odd byte address. + * @len number of bytes in the buffer to be checksummed. + * @return host order (!) lwip checksum (non-inverted Internet sum) + * + * by Curt McDowell, Broadcom Corp. December 8th, 2005 + */ +u16_t +lwip_standard_chksum(const void *dataptr, int len) +{ + const u8_t *pb = (const u8_t *)dataptr; + const u16_t *ps; + u16_t t = 0; + const u32_t *pl; + u32_t sum = 0, tmp; + /* starts at odd byte address? */ + int odd = ((mem_ptr_t)pb & 1); + + if (odd && len > 0) { + ((u8_t *)&t)[1] = *pb++; + len--; + } + + ps = (const u16_t *)(const void *)pb; + + if (((mem_ptr_t)ps & 3) && len > 1) { + sum += *ps++; + len -= 2; + } + + pl = (const u32_t *)(const void *)ps; + + while (len > 7) { + tmp = sum + *pl++; /* ping */ + if (tmp < sum) { + tmp++; /* add back carry */ + } + + sum = tmp + *pl++; /* pong */ + if (sum < tmp) { + sum++; /* add back carry */ + } + + len -= 8; + } + + /* make room in upper bits */ + sum = FOLD_U32T(sum); + + ps = (const u16_t *)pl; + + /* 16-bit aligned word remaining? */ + while (len > 1) { + sum += *ps++; + len -= 2; + } + + /* dangling tail byte remaining? */ + if (len > 0) { /* include odd byte */ + ((u8_t *)&t)[0] = *(const u8_t *)ps; + } + + sum += t; /* add end bytes */ + + /* Fold 32-bit sum to 16 bits + calling this twice is probably faster than if statements... */ + sum = FOLD_U32T(sum); + sum = FOLD_U32T(sum); + + if (odd) { + sum = SWAP_BYTES_IN_WORD(sum); + } + + return (u16_t)sum; +} +#endif + +/** Parts of the pseudo checksum which are common to IPv4 and IPv6 */ +static u16_t +inet_cksum_pseudo_base(struct pbuf *p, u8_t proto, u16_t proto_len, u32_t acc) +{ + struct pbuf *q; + int swapped = 0; + + /* iterate through all pbuf in chain */ + for (q = p; q != NULL; q = q->next) { + LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n", + (void *)q, (void *)q->next)); + acc += LWIP_CHKSUM(q->payload, q->len); + /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/ + /* just executing this next line is probably faster that the if statement needed + to check whether we really need to execute it, and does no harm */ + acc = FOLD_U32T(acc); + if (q->len % 2 != 0) { + swapped = !swapped; + acc = SWAP_BYTES_IN_WORD(acc); + } + /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/ + } + + if (swapped) { + acc = SWAP_BYTES_IN_WORD(acc); + } + + acc += (u32_t)lwip_htons((u16_t)proto); + acc += (u32_t)lwip_htons(proto_len); + + /* Fold 32-bit sum to 16 bits + calling this twice is probably faster than if statements... */ + acc = FOLD_U32T(acc); + acc = FOLD_U32T(acc); + LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc)); + return (u16_t)~(acc & 0xffffUL); +} + +#if LWIP_IPV4 +/* inet_chksum_pseudo: + * + * Calculates the IPv4 pseudo Internet checksum used by TCP and UDP for a pbuf chain. + * IP addresses are expected to be in network byte order. + * + * @param p chain of pbufs over that a checksum should be calculated (ip data part) + * @param src source ip address (used for checksum of pseudo header) + * @param dst destination ip address (used for checksum of pseudo header) + * @param proto ip protocol (used for checksum of pseudo header) + * @param proto_len length of the ip data part (used for checksum of pseudo header) + * @return checksum (as u16_t) to be saved directly in the protocol header + */ +u16_t +inet_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, + const ip4_addr_t *src, const ip4_addr_t *dest) +{ + u32_t acc; + u32_t addr; + + addr = ip4_addr_get_u32(src); + acc = (addr & 0xffffUL); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + addr = ip4_addr_get_u32(dest); + acc = (u32_t)(acc + (addr & 0xffffUL)); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + /* fold down to 16 bits */ + acc = FOLD_U32T(acc); + acc = FOLD_U32T(acc); + + return inet_cksum_pseudo_base(p, proto, proto_len, acc); +} +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +/** + * Calculates the checksum with IPv6 pseudo header used by TCP and UDP for a pbuf chain. + * IPv6 addresses are expected to be in network byte order. + * + * @param p chain of pbufs over that a checksum should be calculated (ip data part) + * @param proto ipv6 protocol/next header (used for checksum of pseudo header) + * @param proto_len length of the ipv6 payload (used for checksum of pseudo header) + * @param src source ipv6 address (used for checksum of pseudo header) + * @param dest destination ipv6 address (used for checksum of pseudo header) + * @return checksum (as u16_t) to be saved directly in the protocol header + */ +u16_t +ip6_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, + const ip6_addr_t *src, const ip6_addr_t *dest) +{ + u32_t acc = 0; + u32_t addr; + u8_t addr_part; + + for (addr_part = 0; addr_part < 4; addr_part++) { + addr = src->addr[addr_part]; + acc = (u32_t)(acc + (addr & 0xffffUL)); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + addr = dest->addr[addr_part]; + acc = (u32_t)(acc + (addr & 0xffffUL)); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + } + /* fold down to 16 bits */ + acc = FOLD_U32T(acc); + acc = FOLD_U32T(acc); + + return inet_cksum_pseudo_base(p, proto, proto_len, acc); +} +#endif /* LWIP_IPV6 */ + +/* ip_chksum_pseudo: + * + * Calculates the IPv4 or IPv6 pseudo Internet checksum used by TCP and UDP for a pbuf chain. + * IP addresses are expected to be in network byte order. + * + * @param p chain of pbufs over that a checksum should be calculated (ip data part) + * @param src source ip address (used for checksum of pseudo header) + * @param dst destination ip address (used for checksum of pseudo header) + * @param proto ip protocol (used for checksum of pseudo header) + * @param proto_len length of the ip data part (used for checksum of pseudo header) + * @return checksum (as u16_t) to be saved directly in the protocol header + */ +u16_t +ip_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, + const ip_addr_t *src, const ip_addr_t *dest) +{ +#if LWIP_IPV6 + if (IP_IS_V6(dest)) { + return ip6_chksum_pseudo(p, proto, proto_len, ip_2_ip6(src), ip_2_ip6(dest)); + } +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 && LWIP_IPV6 + else +#endif /* LWIP_IPV4 && LWIP_IPV6 */ +#if LWIP_IPV4 + { + return inet_chksum_pseudo(p, proto, proto_len, ip_2_ip4(src), ip_2_ip4(dest)); + } +#endif /* LWIP_IPV4 */ +} + +/** Parts of the pseudo checksum which are common to IPv4 and IPv6 */ +static u16_t +inet_cksum_pseudo_partial_base(struct pbuf *p, u8_t proto, u16_t proto_len, + u16_t chksum_len, u32_t acc) +{ + struct pbuf *q; + int swapped = 0; + u16_t chklen; + + /* iterate through all pbuf in chain */ + for (q = p; (q != NULL) && (chksum_len > 0); q = q->next) { + LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): checksumming pbuf %p (has next %p) \n", + (void *)q, (void *)q->next)); + chklen = q->len; + if (chklen > chksum_len) { + chklen = chksum_len; + } + acc += LWIP_CHKSUM(q->payload, chklen); + chksum_len = (u16_t)(chksum_len - chklen); + LWIP_ASSERT("delete me", chksum_len < 0x7fff); + /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): unwrapped lwip_chksum()=%"X32_F" \n", acc));*/ + /* fold the upper bit down */ + acc = FOLD_U32T(acc); + if (q->len % 2 != 0) { + swapped = !swapped; + acc = SWAP_BYTES_IN_WORD(acc); + } + /*LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): wrapped lwip_chksum()=%"X32_F" \n", acc));*/ + } + + if (swapped) { + acc = SWAP_BYTES_IN_WORD(acc); + } + + acc += (u32_t)lwip_htons((u16_t)proto); + acc += (u32_t)lwip_htons(proto_len); + + /* Fold 32-bit sum to 16 bits + calling this twice is probably faster than if statements... */ + acc = FOLD_U32T(acc); + acc = FOLD_U32T(acc); + LWIP_DEBUGF(INET_DEBUG, ("inet_chksum_pseudo(): pbuf chain lwip_chksum()=%"X32_F"\n", acc)); + return (u16_t)~(acc & 0xffffUL); +} + +#if LWIP_IPV4 +/* inet_chksum_pseudo_partial: + * + * Calculates the IPv4 pseudo Internet checksum used by TCP and UDP for a pbuf chain. + * IP addresses are expected to be in network byte order. + * + * @param p chain of pbufs over that a checksum should be calculated (ip data part) + * @param src source ip address (used for checksum of pseudo header) + * @param dst destination ip address (used for checksum of pseudo header) + * @param proto ip protocol (used for checksum of pseudo header) + * @param proto_len length of the ip data part (used for checksum of pseudo header) + * @return checksum (as u16_t) to be saved directly in the protocol header + */ +u16_t +inet_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, + u16_t chksum_len, const ip4_addr_t *src, const ip4_addr_t *dest) +{ + u32_t acc; + u32_t addr; + + addr = ip4_addr_get_u32(src); + acc = (addr & 0xffffUL); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + addr = ip4_addr_get_u32(dest); + acc = (u32_t)(acc + (addr & 0xffffUL)); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + /* fold down to 16 bits */ + acc = FOLD_U32T(acc); + acc = FOLD_U32T(acc); + + return inet_cksum_pseudo_partial_base(p, proto, proto_len, chksum_len, acc); +} +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +/** + * Calculates the checksum with IPv6 pseudo header used by TCP and UDP for a pbuf chain. + * IPv6 addresses are expected to be in network byte order. Will only compute for a + * portion of the payload. + * + * @param p chain of pbufs over that a checksum should be calculated (ip data part) + * @param proto ipv6 protocol/next header (used for checksum of pseudo header) + * @param proto_len length of the ipv6 payload (used for checksum of pseudo header) + * @param chksum_len number of payload bytes used to compute chksum + * @param src source ipv6 address (used for checksum of pseudo header) + * @param dest destination ipv6 address (used for checksum of pseudo header) + * @return checksum (as u16_t) to be saved directly in the protocol header + */ +u16_t +ip6_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, + u16_t chksum_len, const ip6_addr_t *src, const ip6_addr_t *dest) +{ + u32_t acc = 0; + u32_t addr; + u8_t addr_part; + + for (addr_part = 0; addr_part < 4; addr_part++) { + addr = src->addr[addr_part]; + acc = (u32_t)(acc + (addr & 0xffffUL)); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + addr = dest->addr[addr_part]; + acc = (u32_t)(acc + (addr & 0xffffUL)); + acc = (u32_t)(acc + ((addr >> 16) & 0xffffUL)); + } + /* fold down to 16 bits */ + acc = FOLD_U32T(acc); + acc = FOLD_U32T(acc); + + return inet_cksum_pseudo_partial_base(p, proto, proto_len, chksum_len, acc); +} +#endif /* LWIP_IPV6 */ + +/* ip_chksum_pseudo_partial: + * + * Calculates the IPv4 or IPv6 pseudo Internet checksum used by TCP and UDP for a pbuf chain. + * + * @param p chain of pbufs over that a checksum should be calculated (ip data part) + * @param src source ip address (used for checksum of pseudo header) + * @param dst destination ip address (used for checksum of pseudo header) + * @param proto ip protocol (used for checksum of pseudo header) + * @param proto_len length of the ip data part (used for checksum of pseudo header) + * @return checksum (as u16_t) to be saved directly in the protocol header + */ +u16_t +ip_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, + u16_t chksum_len, const ip_addr_t *src, const ip_addr_t *dest) +{ +#if LWIP_IPV6 + if (IP_IS_V6(dest)) { + return ip6_chksum_pseudo_partial(p, proto, proto_len, chksum_len, ip_2_ip6(src), ip_2_ip6(dest)); + } +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 && LWIP_IPV6 + else +#endif /* LWIP_IPV4 && LWIP_IPV6 */ +#if LWIP_IPV4 + { + return inet_chksum_pseudo_partial(p, proto, proto_len, chksum_len, ip_2_ip4(src), ip_2_ip4(dest)); + } +#endif /* LWIP_IPV4 */ +} + +/* inet_chksum: + * + * Calculates the Internet checksum over a portion of memory. Used primarily for IP + * and ICMP. + * + * @param dataptr start of the buffer to calculate the checksum (no alignment needed) + * @param len length of the buffer to calculate the checksum + * @return checksum (as u16_t) to be saved directly in the protocol header + */ + +u16_t +inet_chksum(const void *dataptr, u16_t len) +{ + return (u16_t)~(unsigned int)LWIP_CHKSUM(dataptr, len); +} + +/** + * Calculate a checksum over a chain of pbufs (without pseudo-header, much like + * inet_chksum only pbufs are used). + * + * @param p pbuf chain over that the checksum should be calculated + * @return checksum (as u16_t) to be saved directly in the protocol header + */ +u16_t +inet_chksum_pbuf(struct pbuf *p) +{ + u32_t acc; + struct pbuf *q; + int swapped = 0; + + acc = 0; + for (q = p; q != NULL; q = q->next) { + acc += LWIP_CHKSUM(q->payload, q->len); + acc = FOLD_U32T(acc); + if (q->len % 2 != 0) { + swapped = !swapped; + acc = SWAP_BYTES_IN_WORD(acc); + } + } + + if (swapped) { + acc = SWAP_BYTES_IN_WORD(acc); + } + return (u16_t)~(acc & 0xffffUL); +} + +/* These are some implementations for LWIP_CHKSUM_COPY, which copies data + * like MEMCPY but generates a checksum at the same time. Since this is a + * performance-sensitive function, you might want to create your own version + * in assembly targeted at your hardware by defining it in lwipopts.h: + * #define LWIP_CHKSUM_COPY(dst, src, len) your_chksum_copy(dst, src, len) + */ + +#if (LWIP_CHKSUM_COPY_ALGORITHM == 1) /* Version #1 */ +/** Safe but slow: first call MEMCPY, then call LWIP_CHKSUM. + * For architectures with big caches, data might still be in cache when + * generating the checksum after copying. + */ +u16_t +lwip_chksum_copy(void *dst, const void *src, u16_t len) +{ + MEMCPY(dst, src, len); + return LWIP_CHKSUM(dst, len); +} +#endif /* (LWIP_CHKSUM_COPY_ALGORITHM == 1) */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/init.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/init.c index b6885364..b3737a35 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/init.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/init.c @@ -1,380 +1,380 @@ -/** - * @file - * Modules initialization - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - */ - -#include "lwip/opt.h" - -#include "lwip/init.h" -#include "lwip/stats.h" -#include "lwip/sys.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/pbuf.h" -#include "lwip/netif.h" -#include "lwip/sockets.h" -#include "lwip/ip.h" -#include "lwip/raw.h" -#include "lwip/udp.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/igmp.h" -#include "lwip/dns.h" -#include "lwip/timeouts.h" -#include "lwip/etharp.h" -#include "lwip/ip6.h" -#include "lwip/nd6.h" -#include "lwip/mld6.h" -#include "lwip/api.h" - -#include "netif/ppp/ppp_opts.h" -#include "netif/ppp/ppp_impl.h" - -#ifndef LWIP_SKIP_PACKING_CHECK - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct packed_struct_test { - PACK_STRUCT_FLD_8(u8_t dummy1); - PACK_STRUCT_FIELD(u32_t dummy2); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define PACKED_STRUCT_TEST_EXPECTED_SIZE 5 - -#endif - -/* Compile-time sanity checks for configuration errors. - * These can be done independently of LWIP_DEBUG, without penalty. - */ -#ifndef BYTE_ORDER -#error "BYTE_ORDER is not defined, you have to define it in your cc.h" -#endif -#if (!IP_SOF_BROADCAST && IP_SOF_BROADCAST_RECV) -#error "If you want to use broadcast filter per pcb on recv operations, you have to define IP_SOF_BROADCAST=1 in your lwipopts.h" -#endif -#if (!LWIP_UDP && LWIP_UDPLITE) -#error "If you want to use UDP Lite, you have to define LWIP_UDP=1 in your lwipopts.h" -#endif -#if (!LWIP_UDP && LWIP_DHCP) -#error "If you want to use DHCP, you have to define LWIP_UDP=1 in your lwipopts.h" -#endif -#if (!LWIP_UDP && !LWIP_RAW && LWIP_MULTICAST_TX_OPTIONS) -#error "If you want to use LWIP_MULTICAST_TX_OPTIONS, you have to define LWIP_UDP=1 and/or LWIP_RAW=1 in your lwipopts.h" -#endif -#if (!LWIP_UDP && LWIP_DNS) -#error "If you want to use DNS, you have to define LWIP_UDP=1 in your lwipopts.h" -#endif -#if !MEMP_MEM_MALLOC /* MEMP_NUM_* checks are disabled when not using the pool allocator */ -#if (LWIP_ARP && ARP_QUEUEING && (MEMP_NUM_ARP_QUEUE<=0)) -#error "If you want to use ARP Queueing, you have to define MEMP_NUM_ARP_QUEUE>=1 in your lwipopts.h" -#endif -#if (LWIP_RAW && (MEMP_NUM_RAW_PCB<=0)) -#error "If you want to use RAW, you have to define MEMP_NUM_RAW_PCB>=1 in your lwipopts.h" -#endif -#if (LWIP_UDP && (MEMP_NUM_UDP_PCB<=0)) -#error "If you want to use UDP, you have to define MEMP_NUM_UDP_PCB>=1 in your lwipopts.h" -#endif -#if (LWIP_TCP && (MEMP_NUM_TCP_PCB<=0)) -#error "If you want to use TCP, you have to define MEMP_NUM_TCP_PCB>=1 in your lwipopts.h" -#endif -#if (LWIP_IGMP && (MEMP_NUM_IGMP_GROUP<=1)) -#error "If you want to use IGMP, you have to define MEMP_NUM_IGMP_GROUP>1 in your lwipopts.h" -#endif -#if (LWIP_IGMP && !LWIP_MULTICAST_TX_OPTIONS) -#error "If you want to use IGMP, you have to define LWIP_MULTICAST_TX_OPTIONS==1 in your lwipopts.h" -#endif -#if (LWIP_IGMP && !LWIP_IPV4) -#error "IGMP needs LWIP_IPV4 enabled in your lwipopts.h" -#endif -#if ((LWIP_NETCONN || LWIP_SOCKET) && (MEMP_NUM_TCPIP_MSG_API<=0)) -#error "If you want to use Sequential API, you have to define MEMP_NUM_TCPIP_MSG_API>=1 in your lwipopts.h" -#endif -/* There must be sufficient timeouts, taking into account requirements of the subsystems. */ -#if LWIP_TIMERS && (MEMP_NUM_SYS_TIMEOUT < LWIP_NUM_SYS_TIMEOUT_INTERNAL) -#error "MEMP_NUM_SYS_TIMEOUT is too low to accomodate all required timeouts" -#endif -#if (IP_REASSEMBLY && (MEMP_NUM_REASSDATA > IP_REASS_MAX_PBUFS)) -#error "MEMP_NUM_REASSDATA > IP_REASS_MAX_PBUFS doesn't make sense since each struct ip_reassdata must hold 2 pbufs at least!" -#endif -#endif /* !MEMP_MEM_MALLOC */ -#if LWIP_WND_SCALE -#if (LWIP_TCP && (TCP_WND > 0xffffffff)) -#error "If you want to use TCP, TCP_WND must fit in an u32_t, so, you have to reduce it in your lwipopts.h" -#endif -#if (LWIP_TCP && (TCP_RCV_SCALE > 14)) -#error "The maximum valid window scale value is 14!" -#endif -#if (LWIP_TCP && (TCP_WND > (0xFFFFU << TCP_RCV_SCALE))) -#error "TCP_WND is bigger than the configured LWIP_WND_SCALE allows!" -#endif -#if (LWIP_TCP && ((TCP_WND >> TCP_RCV_SCALE) == 0)) -#error "TCP_WND is too small for the configured LWIP_WND_SCALE (results in zero window)!" -#endif -#else /* LWIP_WND_SCALE */ -#if (LWIP_TCP && (TCP_WND > 0xffff)) -#error "If you want to use TCP, TCP_WND must fit in an u16_t, so, you have to reduce it in your lwipopts.h (or enable window scaling)" -#endif -#endif /* LWIP_WND_SCALE */ -#if (LWIP_TCP && (TCP_SND_QUEUELEN > 0xffff)) -#error "If you want to use TCP, TCP_SND_QUEUELEN must fit in an u16_t, so, you have to reduce it in your lwipopts.h" -#endif -#if (LWIP_TCP && (TCP_SND_QUEUELEN < 2)) -#error "TCP_SND_QUEUELEN must be at least 2 for no-copy TCP writes to work" -#endif -#if (LWIP_TCP && ((TCP_MAXRTX > 12) || (TCP_SYNMAXRTX > 12))) -#error "If you want to use TCP, TCP_MAXRTX and TCP_SYNMAXRTX must less or equal to 12 (due to tcp_backoff table), so, you have to reduce them in your lwipopts.h" -#endif -#if (LWIP_TCP && TCP_LISTEN_BACKLOG && ((TCP_DEFAULT_LISTEN_BACKLOG < 0) || (TCP_DEFAULT_LISTEN_BACKLOG > 0xff))) -#error "If you want to use TCP backlog, TCP_DEFAULT_LISTEN_BACKLOG must fit into an u8_t" -#endif -#if (LWIP_TCP && LWIP_TCP_SACK_OUT && !TCP_QUEUE_OOSEQ) -#error "To use LWIP_TCP_SACK_OUT, TCP_QUEUE_OOSEQ needs to be enabled" -#endif -#if (LWIP_TCP && LWIP_TCP_SACK_OUT && (LWIP_TCP_MAX_SACK_NUM < 1)) -#error "LWIP_TCP_MAX_SACK_NUM must be greater than 0" -#endif -#if (LWIP_NETIF_API && (NO_SYS==1)) -#error "If you want to use NETIF API, you have to define NO_SYS=0 in your lwipopts.h" -#endif -#if ((LWIP_SOCKET || LWIP_NETCONN) && (NO_SYS==1)) -#error "If you want to use Sequential API, you have to define NO_SYS=0 in your lwipopts.h" -#endif -#if (LWIP_PPP_API && (NO_SYS==1)) -#error "If you want to use PPP API, you have to define NO_SYS=0 in your lwipopts.h" -#endif -#if (LWIP_PPP_API && (PPP_SUPPORT==0)) -#error "If you want to use PPP API, you have to enable PPP_SUPPORT in your lwipopts.h" -#endif -#if (((!LWIP_DHCP) || (!LWIP_AUTOIP)) && LWIP_DHCP_AUTOIP_COOP) -#error "If you want to use DHCP/AUTOIP cooperation mode, you have to define LWIP_DHCP=1 and LWIP_AUTOIP=1 in your lwipopts.h" -#endif -#if (((!LWIP_DHCP) || (!LWIP_ARP)) && DHCP_DOES_ARP_CHECK) -#error "If you want to use DHCP ARP checking, you have to define LWIP_DHCP=1 and LWIP_ARP=1 in your lwipopts.h" -#endif -#if (!LWIP_ARP && LWIP_AUTOIP) -#error "If you want to use AUTOIP, you have to define LWIP_ARP=1 in your lwipopts.h" -#endif -#if (LWIP_TCP && ((LWIP_EVENT_API && LWIP_CALLBACK_API) || (!LWIP_EVENT_API && !LWIP_CALLBACK_API))) -#error "One and exactly one of LWIP_EVENT_API and LWIP_CALLBACK_API has to be enabled in your lwipopts.h" -#endif -#if (LWIP_ALTCP && LWIP_EVENT_API) -#error "The application layered tcp API does not work with LWIP_EVENT_API" -#endif -#if (MEM_LIBC_MALLOC && MEM_USE_POOLS) -#error "MEM_LIBC_MALLOC and MEM_USE_POOLS may not both be simultaneously enabled in your lwipopts.h" -#endif -#if (MEM_USE_POOLS && !MEMP_USE_CUSTOM_POOLS) -#error "MEM_USE_POOLS requires custom pools (MEMP_USE_CUSTOM_POOLS) to be enabled in your lwipopts.h" -#endif -#if (PBUF_POOL_BUFSIZE <= MEM_ALIGNMENT) -#error "PBUF_POOL_BUFSIZE must be greater than MEM_ALIGNMENT or the offset may take the full first pbuf" -#endif -#if (DNS_LOCAL_HOSTLIST && !DNS_LOCAL_HOSTLIST_IS_DYNAMIC && !(defined(DNS_LOCAL_HOSTLIST_INIT))) -#error "you have to define define DNS_LOCAL_HOSTLIST_INIT {{'host1', 0x123}, {'host2', 0x234}} to initialize DNS_LOCAL_HOSTLIST" -#endif -#if PPP_SUPPORT && !PPPOS_SUPPORT && !PPPOE_SUPPORT && !PPPOL2TP_SUPPORT -#error "PPP_SUPPORT needs at least one of PPPOS_SUPPORT, PPPOE_SUPPORT or PPPOL2TP_SUPPORT turned on" -#endif -#if PPP_SUPPORT && !PPP_IPV4_SUPPORT && !PPP_IPV6_SUPPORT -#error "PPP_SUPPORT needs PPP_IPV4_SUPPORT and/or PPP_IPV6_SUPPORT turned on" -#endif -#if PPP_SUPPORT && PPP_IPV4_SUPPORT && !LWIP_IPV4 -#error "PPP_IPV4_SUPPORT needs LWIP_IPV4 turned on" -#endif -#if PPP_SUPPORT && PPP_IPV6_SUPPORT && !LWIP_IPV6 -#error "PPP_IPV6_SUPPORT needs LWIP_IPV6 turned on" -#endif -#if !LWIP_ETHERNET && (LWIP_ARP || PPPOE_SUPPORT) -#error "LWIP_ETHERNET needs to be turned on for LWIP_ARP or PPPOE_SUPPORT" -#endif -#if LWIP_TCPIP_CORE_LOCKING_INPUT && !LWIP_TCPIP_CORE_LOCKING -#error "When using LWIP_TCPIP_CORE_LOCKING_INPUT, LWIP_TCPIP_CORE_LOCKING must be enabled, too" -#endif -#if LWIP_TCP && LWIP_NETIF_TX_SINGLE_PBUF && !TCP_OVERSIZE -#error "LWIP_NETIF_TX_SINGLE_PBUF needs TCP_OVERSIZE enabled to create single-pbuf TCP packets" -#endif -#if LWIP_NETCONN && LWIP_TCP -#if NETCONN_COPY != TCP_WRITE_FLAG_COPY -#error "NETCONN_COPY != TCP_WRITE_FLAG_COPY" -#endif -#if NETCONN_MORE != TCP_WRITE_FLAG_MORE -#error "NETCONN_MORE != TCP_WRITE_FLAG_MORE" -#endif -#endif /* LWIP_NETCONN && LWIP_TCP */ -#if LWIP_SOCKET -#endif /* LWIP_SOCKET */ - - -/* Compile-time checks for deprecated options. - */ -#ifdef MEMP_NUM_TCPIP_MSG -#error "MEMP_NUM_TCPIP_MSG option is deprecated. Remove it from your lwipopts.h." -#endif -#ifdef TCP_REXMIT_DEBUG -#error "TCP_REXMIT_DEBUG option is deprecated. Remove it from your lwipopts.h." -#endif -#ifdef RAW_STATS -#error "RAW_STATS option is deprecated. Remove it from your lwipopts.h." -#endif -#ifdef ETHARP_QUEUE_FIRST -#error "ETHARP_QUEUE_FIRST option is deprecated. Remove it from your lwipopts.h." -#endif -#ifdef ETHARP_ALWAYS_INSERT -#error "ETHARP_ALWAYS_INSERT option is deprecated. Remove it from your lwipopts.h." -#endif -#if !NO_SYS && LWIP_TCPIP_CORE_LOCKING && LWIP_COMPAT_MUTEX && !defined(LWIP_COMPAT_MUTEX_ALLOWED) -#error "LWIP_COMPAT_MUTEX cannot prevent priority inversion. It is recommended to implement priority-aware mutexes. (Define LWIP_COMPAT_MUTEX_ALLOWED to disable this error.)" -#endif - -#ifndef LWIP_DISABLE_TCP_SANITY_CHECKS -#define LWIP_DISABLE_TCP_SANITY_CHECKS 0 -#endif -#ifndef LWIP_DISABLE_MEMP_SANITY_CHECKS -#define LWIP_DISABLE_MEMP_SANITY_CHECKS 0 -#endif - -/* MEMP sanity checks */ -#if MEMP_MEM_MALLOC -#if !LWIP_DISABLE_MEMP_SANITY_CHECKS -#if LWIP_NETCONN || LWIP_SOCKET -#if !MEMP_NUM_NETCONN && LWIP_SOCKET -#error "lwip_sanity_check: WARNING: MEMP_NUM_NETCONN cannot be 0 when using sockets!" -#endif -#else /* MEMP_MEM_MALLOC */ -#if MEMP_NUM_NETCONN > (MEMP_NUM_TCP_PCB+MEMP_NUM_TCP_PCB_LISTEN+MEMP_NUM_UDP_PCB+MEMP_NUM_RAW_PCB) -#error "lwip_sanity_check: WARNING: MEMP_NUM_NETCONN should be less than the sum of MEMP_NUM_{TCP,RAW,UDP}_PCB+MEMP_NUM_TCP_PCB_LISTEN. If you know what you are doing, define LWIP_DISABLE_MEMP_SANITY_CHECKS to 1 to disable this error." -#endif -#endif /* LWIP_NETCONN || LWIP_SOCKET */ -#endif /* !LWIP_DISABLE_MEMP_SANITY_CHECKS */ -#if MEM_USE_POOLS -#error "MEMP_MEM_MALLOC and MEM_USE_POOLS cannot be enabled at the same time" -#endif -#ifdef LWIP_HOOK_MEMP_AVAILABLE -#error "LWIP_HOOK_MEMP_AVAILABLE doesn't make sense with MEMP_MEM_MALLOC" -#endif -#endif /* MEMP_MEM_MALLOC */ - -/* TCP sanity checks */ -#if !LWIP_DISABLE_TCP_SANITY_CHECKS -#if LWIP_TCP -#if !MEMP_MEM_MALLOC && (MEMP_NUM_TCP_SEG < TCP_SND_QUEUELEN) -#error "lwip_sanity_check: WARNING: MEMP_NUM_TCP_SEG should be at least as big as TCP_SND_QUEUELEN. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#if TCP_SND_BUF < (2 * TCP_MSS) -#error "lwip_sanity_check: WARNING: TCP_SND_BUF must be at least as much as (2 * TCP_MSS) for things to work smoothly. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#if TCP_SND_QUEUELEN < (2 * (TCP_SND_BUF / TCP_MSS)) -#error "lwip_sanity_check: WARNING: TCP_SND_QUEUELEN must be at least as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#if TCP_SNDLOWAT >= TCP_SND_BUF -#error "lwip_sanity_check: WARNING: TCP_SNDLOWAT must be less than TCP_SND_BUF. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#if TCP_SNDLOWAT >= (0xFFFF - (4 * TCP_MSS)) -#error "lwip_sanity_check: WARNING: TCP_SNDLOWAT must at least be 4*MSS below u16_t overflow!" -#endif -#if TCP_SNDQUEUELOWAT >= TCP_SND_QUEUELEN -#error "lwip_sanity_check: WARNING: TCP_SNDQUEUELOWAT must be less than TCP_SND_QUEUELEN. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#if !MEMP_MEM_MALLOC && PBUF_POOL_SIZE && (PBUF_POOL_BUFSIZE <= (PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN)) -#error "lwip_sanity_check: WARNING: PBUF_POOL_BUFSIZE does not provide enough space for protocol headers. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#if !MEMP_MEM_MALLOC && PBUF_POOL_SIZE && (TCP_WND > (PBUF_POOL_SIZE * (PBUF_POOL_BUFSIZE - (PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN)))) -#error "lwip_sanity_check: WARNING: TCP_WND is larger than space provided by PBUF_POOL_SIZE * (PBUF_POOL_BUFSIZE - protocol headers). If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#if TCP_WND < TCP_MSS -#error "lwip_sanity_check: WARNING: TCP_WND is smaller than MSS. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." -#endif -#endif /* LWIP_TCP */ -#endif /* !LWIP_DISABLE_TCP_SANITY_CHECKS */ - -/** - * @ingroup lwip_nosys - * Initialize all modules. - * Use this in NO_SYS mode. Use tcpip_init() otherwise. - */ -void -lwip_init(void) -{ -#ifndef LWIP_SKIP_CONST_CHECK - int a = 0; - LWIP_UNUSED_ARG(a); - LWIP_ASSERT("LWIP_CONST_CAST not implemented correctly. Check your lwIP port.", LWIP_CONST_CAST(void *, &a) == &a); -#endif -#ifndef LWIP_SKIP_PACKING_CHECK - LWIP_ASSERT("Struct packing not implemented correctly. Check your lwIP port.", sizeof(struct packed_struct_test) == PACKED_STRUCT_TEST_EXPECTED_SIZE); -#endif - - /* Modules initialization */ - stats_init(); -#if !NO_SYS - sys_init(); -#endif /* !NO_SYS */ - mem_init(); - memp_init(); - pbuf_init(); - netif_init(); -#if LWIP_IPV4 - ip_init(); -#if LWIP_ARP - etharp_init(); -#endif /* LWIP_ARP */ -#endif /* LWIP_IPV4 */ -#if LWIP_RAW - raw_init(); -#endif /* LWIP_RAW */ -#if LWIP_UDP - udp_init(); -#endif /* LWIP_UDP */ -#if LWIP_TCP - tcp_init(); -#endif /* LWIP_TCP */ -#if LWIP_IGMP - igmp_init(); -#endif /* LWIP_IGMP */ -#if LWIP_DNS - dns_init(); -#endif /* LWIP_DNS */ -#if PPP_SUPPORT - ppp_init(); -#endif - -#if LWIP_TIMERS - sys_timeouts_init(); -#endif /* LWIP_TIMERS */ -} +/** + * @file + * Modules initialization + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + */ + +#include "lwip/opt.h" + +#include "lwip/init.h" +#include "lwip/stats.h" +#include "lwip/sys.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/pbuf.h" +#include "lwip/netif.h" +#include "lwip/sockets.h" +#include "lwip/ip.h" +#include "lwip/raw.h" +#include "lwip/udp.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/igmp.h" +#include "lwip/dns.h" +#include "lwip/timeouts.h" +#include "lwip/etharp.h" +#include "lwip/ip6.h" +#include "lwip/nd6.h" +#include "lwip/mld6.h" +#include "lwip/api.h" + +#include "netif/ppp/ppp_opts.h" +#include "netif/ppp/ppp_impl.h" + +#ifndef LWIP_SKIP_PACKING_CHECK + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct packed_struct_test { + PACK_STRUCT_FLD_8(u8_t dummy1); + PACK_STRUCT_FIELD(u32_t dummy2); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define PACKED_STRUCT_TEST_EXPECTED_SIZE 5 + +#endif + +/* Compile-time sanity checks for configuration errors. + * These can be done independently of LWIP_DEBUG, without penalty. + */ +#ifndef BYTE_ORDER +#error "BYTE_ORDER is not defined, you have to define it in your cc.h" +#endif +#if (!IP_SOF_BROADCAST && IP_SOF_BROADCAST_RECV) +#error "If you want to use broadcast filter per pcb on recv operations, you have to define IP_SOF_BROADCAST=1 in your lwipopts.h" +#endif +#if (!LWIP_UDP && LWIP_UDPLITE) +#error "If you want to use UDP Lite, you have to define LWIP_UDP=1 in your lwipopts.h" +#endif +#if (!LWIP_UDP && LWIP_DHCP) +#error "If you want to use DHCP, you have to define LWIP_UDP=1 in your lwipopts.h" +#endif +#if (!LWIP_UDP && !LWIP_RAW && LWIP_MULTICAST_TX_OPTIONS) +#error "If you want to use LWIP_MULTICAST_TX_OPTIONS, you have to define LWIP_UDP=1 and/or LWIP_RAW=1 in your lwipopts.h" +#endif +#if (!LWIP_UDP && LWIP_DNS) +#error "If you want to use DNS, you have to define LWIP_UDP=1 in your lwipopts.h" +#endif +#if !MEMP_MEM_MALLOC /* MEMP_NUM_* checks are disabled when not using the pool allocator */ +#if (LWIP_ARP && ARP_QUEUEING && (MEMP_NUM_ARP_QUEUE<=0)) +#error "If you want to use ARP Queueing, you have to define MEMP_NUM_ARP_QUEUE>=1 in your lwipopts.h" +#endif +#if (LWIP_RAW && (MEMP_NUM_RAW_PCB<=0)) +#error "If you want to use RAW, you have to define MEMP_NUM_RAW_PCB>=1 in your lwipopts.h" +#endif +#if (LWIP_UDP && (MEMP_NUM_UDP_PCB<=0)) +#error "If you want to use UDP, you have to define MEMP_NUM_UDP_PCB>=1 in your lwipopts.h" +#endif +#if (LWIP_TCP && (MEMP_NUM_TCP_PCB<=0)) +#error "If you want to use TCP, you have to define MEMP_NUM_TCP_PCB>=1 in your lwipopts.h" +#endif +#if (LWIP_IGMP && (MEMP_NUM_IGMP_GROUP<=1)) +#error "If you want to use IGMP, you have to define MEMP_NUM_IGMP_GROUP>1 in your lwipopts.h" +#endif +#if (LWIP_IGMP && !LWIP_MULTICAST_TX_OPTIONS) +#error "If you want to use IGMP, you have to define LWIP_MULTICAST_TX_OPTIONS==1 in your lwipopts.h" +#endif +#if (LWIP_IGMP && !LWIP_IPV4) +#error "IGMP needs LWIP_IPV4 enabled in your lwipopts.h" +#endif +#if ((LWIP_NETCONN || LWIP_SOCKET) && (MEMP_NUM_TCPIP_MSG_API<=0)) +#error "If you want to use Sequential API, you have to define MEMP_NUM_TCPIP_MSG_API>=1 in your lwipopts.h" +#endif +/* There must be sufficient timeouts, taking into account requirements of the subsystems. */ +#if LWIP_TIMERS && (MEMP_NUM_SYS_TIMEOUT < LWIP_NUM_SYS_TIMEOUT_INTERNAL) +#error "MEMP_NUM_SYS_TIMEOUT is too low to accomodate all required timeouts" +#endif +#if (IP_REASSEMBLY && (MEMP_NUM_REASSDATA > IP_REASS_MAX_PBUFS)) +#error "MEMP_NUM_REASSDATA > IP_REASS_MAX_PBUFS doesn't make sense since each struct ip_reassdata must hold 2 pbufs at least!" +#endif +#endif /* !MEMP_MEM_MALLOC */ +#if LWIP_WND_SCALE +#if (LWIP_TCP && (TCP_WND > 0xffffffff)) +#error "If you want to use TCP, TCP_WND must fit in an u32_t, so, you have to reduce it in your lwipopts.h" +#endif +#if (LWIP_TCP && (TCP_RCV_SCALE > 14)) +#error "The maximum valid window scale value is 14!" +#endif +#if (LWIP_TCP && (TCP_WND > (0xFFFFU << TCP_RCV_SCALE))) +#error "TCP_WND is bigger than the configured LWIP_WND_SCALE allows!" +#endif +#if (LWIP_TCP && ((TCP_WND >> TCP_RCV_SCALE) == 0)) +#error "TCP_WND is too small for the configured LWIP_WND_SCALE (results in zero window)!" +#endif +#else /* LWIP_WND_SCALE */ +#if (LWIP_TCP && (TCP_WND > 0xffff)) +#error "If you want to use TCP, TCP_WND must fit in an u16_t, so, you have to reduce it in your lwipopts.h (or enable window scaling)" +#endif +#endif /* LWIP_WND_SCALE */ +#if (LWIP_TCP && (TCP_SND_QUEUELEN > 0xffff)) +#error "If you want to use TCP, TCP_SND_QUEUELEN must fit in an u16_t, so, you have to reduce it in your lwipopts.h" +#endif +#if (LWIP_TCP && (TCP_SND_QUEUELEN < 2)) +#error "TCP_SND_QUEUELEN must be at least 2 for no-copy TCP writes to work" +#endif +#if (LWIP_TCP && ((TCP_MAXRTX > 12) || (TCP_SYNMAXRTX > 12))) +#error "If you want to use TCP, TCP_MAXRTX and TCP_SYNMAXRTX must less or equal to 12 (due to tcp_backoff table), so, you have to reduce them in your lwipopts.h" +#endif +#if (LWIP_TCP && TCP_LISTEN_BACKLOG && ((TCP_DEFAULT_LISTEN_BACKLOG < 0) || (TCP_DEFAULT_LISTEN_BACKLOG > 0xff))) +#error "If you want to use TCP backlog, TCP_DEFAULT_LISTEN_BACKLOG must fit into an u8_t" +#endif +#if (LWIP_TCP && LWIP_TCP_SACK_OUT && !TCP_QUEUE_OOSEQ) +#error "To use LWIP_TCP_SACK_OUT, TCP_QUEUE_OOSEQ needs to be enabled" +#endif +#if (LWIP_TCP && LWIP_TCP_SACK_OUT && (LWIP_TCP_MAX_SACK_NUM < 1)) +#error "LWIP_TCP_MAX_SACK_NUM must be greater than 0" +#endif +#if (LWIP_NETIF_API && (NO_SYS==1)) +#error "If you want to use NETIF API, you have to define NO_SYS=0 in your lwipopts.h" +#endif +#if ((LWIP_SOCKET || LWIP_NETCONN) && (NO_SYS==1)) +#error "If you want to use Sequential API, you have to define NO_SYS=0 in your lwipopts.h" +#endif +#if (LWIP_PPP_API && (NO_SYS==1)) +#error "If you want to use PPP API, you have to define NO_SYS=0 in your lwipopts.h" +#endif +#if (LWIP_PPP_API && (PPP_SUPPORT==0)) +#error "If you want to use PPP API, you have to enable PPP_SUPPORT in your lwipopts.h" +#endif +#if (((!LWIP_DHCP) || (!LWIP_AUTOIP)) && LWIP_DHCP_AUTOIP_COOP) +#error "If you want to use DHCP/AUTOIP cooperation mode, you have to define LWIP_DHCP=1 and LWIP_AUTOIP=1 in your lwipopts.h" +#endif +#if (((!LWIP_DHCP) || (!LWIP_ARP)) && DHCP_DOES_ARP_CHECK) +#error "If you want to use DHCP ARP checking, you have to define LWIP_DHCP=1 and LWIP_ARP=1 in your lwipopts.h" +#endif +#if (!LWIP_ARP && LWIP_AUTOIP) +#error "If you want to use AUTOIP, you have to define LWIP_ARP=1 in your lwipopts.h" +#endif +#if (LWIP_TCP && ((LWIP_EVENT_API && LWIP_CALLBACK_API) || (!LWIP_EVENT_API && !LWIP_CALLBACK_API))) +#error "One and exactly one of LWIP_EVENT_API and LWIP_CALLBACK_API has to be enabled in your lwipopts.h" +#endif +#if (LWIP_ALTCP && LWIP_EVENT_API) +#error "The application layered tcp API does not work with LWIP_EVENT_API" +#endif +#if (MEM_LIBC_MALLOC && MEM_USE_POOLS) +#error "MEM_LIBC_MALLOC and MEM_USE_POOLS may not both be simultaneously enabled in your lwipopts.h" +#endif +#if (MEM_USE_POOLS && !MEMP_USE_CUSTOM_POOLS) +#error "MEM_USE_POOLS requires custom pools (MEMP_USE_CUSTOM_POOLS) to be enabled in your lwipopts.h" +#endif +#if (PBUF_POOL_BUFSIZE <= MEM_ALIGNMENT) +#error "PBUF_POOL_BUFSIZE must be greater than MEM_ALIGNMENT or the offset may take the full first pbuf" +#endif +#if (DNS_LOCAL_HOSTLIST && !DNS_LOCAL_HOSTLIST_IS_DYNAMIC && !(defined(DNS_LOCAL_HOSTLIST_INIT))) +#error "you have to define define DNS_LOCAL_HOSTLIST_INIT {{'host1', 0x123}, {'host2', 0x234}} to initialize DNS_LOCAL_HOSTLIST" +#endif +#if PPP_SUPPORT && !PPPOS_SUPPORT && !PPPOE_SUPPORT && !PPPOL2TP_SUPPORT +#error "PPP_SUPPORT needs at least one of PPPOS_SUPPORT, PPPOE_SUPPORT or PPPOL2TP_SUPPORT turned on" +#endif +#if PPP_SUPPORT && !PPP_IPV4_SUPPORT && !PPP_IPV6_SUPPORT +#error "PPP_SUPPORT needs PPP_IPV4_SUPPORT and/or PPP_IPV6_SUPPORT turned on" +#endif +#if PPP_SUPPORT && PPP_IPV4_SUPPORT && !LWIP_IPV4 +#error "PPP_IPV4_SUPPORT needs LWIP_IPV4 turned on" +#endif +#if PPP_SUPPORT && PPP_IPV6_SUPPORT && !LWIP_IPV6 +#error "PPP_IPV6_SUPPORT needs LWIP_IPV6 turned on" +#endif +#if !LWIP_ETHERNET && (LWIP_ARP || PPPOE_SUPPORT) +#error "LWIP_ETHERNET needs to be turned on for LWIP_ARP or PPPOE_SUPPORT" +#endif +#if LWIP_TCPIP_CORE_LOCKING_INPUT && !LWIP_TCPIP_CORE_LOCKING +#error "When using LWIP_TCPIP_CORE_LOCKING_INPUT, LWIP_TCPIP_CORE_LOCKING must be enabled, too" +#endif +#if LWIP_TCP && LWIP_NETIF_TX_SINGLE_PBUF && !TCP_OVERSIZE +#error "LWIP_NETIF_TX_SINGLE_PBUF needs TCP_OVERSIZE enabled to create single-pbuf TCP packets" +#endif +#if LWIP_NETCONN && LWIP_TCP +#if NETCONN_COPY != TCP_WRITE_FLAG_COPY +#error "NETCONN_COPY != TCP_WRITE_FLAG_COPY" +#endif +#if NETCONN_MORE != TCP_WRITE_FLAG_MORE +#error "NETCONN_MORE != TCP_WRITE_FLAG_MORE" +#endif +#endif /* LWIP_NETCONN && LWIP_TCP */ +#if LWIP_SOCKET +#endif /* LWIP_SOCKET */ + + +/* Compile-time checks for deprecated options. + */ +#ifdef MEMP_NUM_TCPIP_MSG +#error "MEMP_NUM_TCPIP_MSG option is deprecated. Remove it from your lwipopts.h." +#endif +#ifdef TCP_REXMIT_DEBUG +#error "TCP_REXMIT_DEBUG option is deprecated. Remove it from your lwipopts.h." +#endif +#ifdef RAW_STATS +#error "RAW_STATS option is deprecated. Remove it from your lwipopts.h." +#endif +#ifdef ETHARP_QUEUE_FIRST +#error "ETHARP_QUEUE_FIRST option is deprecated. Remove it from your lwipopts.h." +#endif +#ifdef ETHARP_ALWAYS_INSERT +#error "ETHARP_ALWAYS_INSERT option is deprecated. Remove it from your lwipopts.h." +#endif +#if !NO_SYS && LWIP_TCPIP_CORE_LOCKING && LWIP_COMPAT_MUTEX && !defined(LWIP_COMPAT_MUTEX_ALLOWED) +#error "LWIP_COMPAT_MUTEX cannot prevent priority inversion. It is recommended to implement priority-aware mutexes. (Define LWIP_COMPAT_MUTEX_ALLOWED to disable this error.)" +#endif + +#ifndef LWIP_DISABLE_TCP_SANITY_CHECKS +#define LWIP_DISABLE_TCP_SANITY_CHECKS 0 +#endif +#ifndef LWIP_DISABLE_MEMP_SANITY_CHECKS +#define LWIP_DISABLE_MEMP_SANITY_CHECKS 0 +#endif + +/* MEMP sanity checks */ +#if MEMP_MEM_MALLOC +#if !LWIP_DISABLE_MEMP_SANITY_CHECKS +#if LWIP_NETCONN || LWIP_SOCKET +#if !MEMP_NUM_NETCONN && LWIP_SOCKET +#error "lwip_sanity_check: WARNING: MEMP_NUM_NETCONN cannot be 0 when using sockets!" +#endif +#else /* MEMP_MEM_MALLOC */ +#if MEMP_NUM_NETCONN > (MEMP_NUM_TCP_PCB+MEMP_NUM_TCP_PCB_LISTEN+MEMP_NUM_UDP_PCB+MEMP_NUM_RAW_PCB) +#error "lwip_sanity_check: WARNING: MEMP_NUM_NETCONN should be less than the sum of MEMP_NUM_{TCP,RAW,UDP}_PCB+MEMP_NUM_TCP_PCB_LISTEN. If you know what you are doing, define LWIP_DISABLE_MEMP_SANITY_CHECKS to 1 to disable this error." +#endif +#endif /* LWIP_NETCONN || LWIP_SOCKET */ +#endif /* !LWIP_DISABLE_MEMP_SANITY_CHECKS */ +#if MEM_USE_POOLS +#error "MEMP_MEM_MALLOC and MEM_USE_POOLS cannot be enabled at the same time" +#endif +#ifdef LWIP_HOOK_MEMP_AVAILABLE +#error "LWIP_HOOK_MEMP_AVAILABLE doesn't make sense with MEMP_MEM_MALLOC" +#endif +#endif /* MEMP_MEM_MALLOC */ + +/* TCP sanity checks */ +#if !LWIP_DISABLE_TCP_SANITY_CHECKS +#if LWIP_TCP +#if !MEMP_MEM_MALLOC && (MEMP_NUM_TCP_SEG < TCP_SND_QUEUELEN) +#error "lwip_sanity_check: WARNING: MEMP_NUM_TCP_SEG should be at least as big as TCP_SND_QUEUELEN. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#if TCP_SND_BUF < (2 * TCP_MSS) +#error "lwip_sanity_check: WARNING: TCP_SND_BUF must be at least as much as (2 * TCP_MSS) for things to work smoothly. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#if TCP_SND_QUEUELEN < (2 * (TCP_SND_BUF / TCP_MSS)) +#error "lwip_sanity_check: WARNING: TCP_SND_QUEUELEN must be at least as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#if TCP_SNDLOWAT >= TCP_SND_BUF +#error "lwip_sanity_check: WARNING: TCP_SNDLOWAT must be less than TCP_SND_BUF. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#if TCP_SNDLOWAT >= (0xFFFF - (4 * TCP_MSS)) +#error "lwip_sanity_check: WARNING: TCP_SNDLOWAT must at least be 4*MSS below u16_t overflow!" +#endif +#if TCP_SNDQUEUELOWAT >= TCP_SND_QUEUELEN +#error "lwip_sanity_check: WARNING: TCP_SNDQUEUELOWAT must be less than TCP_SND_QUEUELEN. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#if !MEMP_MEM_MALLOC && PBUF_POOL_SIZE && (PBUF_POOL_BUFSIZE <= (PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN)) +#error "lwip_sanity_check: WARNING: PBUF_POOL_BUFSIZE does not provide enough space for protocol headers. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#if !MEMP_MEM_MALLOC && PBUF_POOL_SIZE && (TCP_WND > (PBUF_POOL_SIZE * (PBUF_POOL_BUFSIZE - (PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN)))) +#error "lwip_sanity_check: WARNING: TCP_WND is larger than space provided by PBUF_POOL_SIZE * (PBUF_POOL_BUFSIZE - protocol headers). If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#if TCP_WND < TCP_MSS +#error "lwip_sanity_check: WARNING: TCP_WND is smaller than MSS. If you know what you are doing, define LWIP_DISABLE_TCP_SANITY_CHECKS to 1 to disable this error." +#endif +#endif /* LWIP_TCP */ +#endif /* !LWIP_DISABLE_TCP_SANITY_CHECKS */ + +/** + * @ingroup lwip_nosys + * Initialize all modules. + * Use this in NO_SYS mode. Use tcpip_init() otherwise. + */ +void +lwip_init(void) +{ +#ifndef LWIP_SKIP_CONST_CHECK + int a = 0; + LWIP_UNUSED_ARG(a); + LWIP_ASSERT("LWIP_CONST_CAST not implemented correctly. Check your lwIP port.", LWIP_CONST_CAST(void *, &a) == &a); +#endif +#ifndef LWIP_SKIP_PACKING_CHECK + LWIP_ASSERT("Struct packing not implemented correctly. Check your lwIP port.", sizeof(struct packed_struct_test) == PACKED_STRUCT_TEST_EXPECTED_SIZE); +#endif + + /* Modules initialization */ + stats_init(); +#if !NO_SYS + sys_init(); +#endif /* !NO_SYS */ + mem_init(); + memp_init(); + pbuf_init(); + netif_init(); +#if LWIP_IPV4 + ip_init(); +#if LWIP_ARP + etharp_init(); +#endif /* LWIP_ARP */ +#endif /* LWIP_IPV4 */ +#if LWIP_RAW + raw_init(); +#endif /* LWIP_RAW */ +#if LWIP_UDP + udp_init(); +#endif /* LWIP_UDP */ +#if LWIP_TCP + tcp_init(); +#endif /* LWIP_TCP */ +#if LWIP_IGMP + igmp_init(); +#endif /* LWIP_IGMP */ +#if LWIP_DNS + dns_init(); +#endif /* LWIP_DNS */ +#if PPP_SUPPORT + ppp_init(); +#endif + +#if LWIP_TIMERS + sys_timeouts_init(); +#endif /* LWIP_TIMERS */ +} diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ip.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ip.c index d611315b..18514cf3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ip.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ip.c @@ -1,167 +1,167 @@ -/** - * @file - * Common IPv4 and IPv6 code - * - * @defgroup ip IP - * @ingroup callbackstyle_api - * - * @defgroup ip4 IPv4 - * @ingroup ip - * - * @defgroup ip6 IPv6 - * @ingroup ip - * - * @defgroup ipaddr IP address handling - * @ingroup infrastructure - * - * @defgroup ip4addr IPv4 only - * @ingroup ipaddr - * - * @defgroup ip6addr IPv6 only - * @ingroup ipaddr - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 || LWIP_IPV6 - -#include "lwip/ip_addr.h" -#include "lwip/ip.h" - -/** Global data for both IPv4 and IPv6 */ -struct ip_globals ip_data; - -#if LWIP_IPV4 && LWIP_IPV6 - -const ip_addr_t ip_addr_any_type = IPADDR_ANY_TYPE_INIT; - -/** - * @ingroup ipaddr - * Convert numeric IP address (both versions) into ASCII representation. - * returns ptr to static buffer; not reentrant! - * - * @param addr ip address in network order to convert - * @return pointer to a global static (!) buffer that holds the ASCII - * representation of addr - */ -char *ipaddr_ntoa(const ip_addr_t *addr) -{ - if (addr == NULL) { - return NULL; - } - if (IP_IS_V6(addr)) { - return ip6addr_ntoa(ip_2_ip6(addr)); - } else { - return ip4addr_ntoa(ip_2_ip4(addr)); - } -} - -/** - * @ingroup ipaddr - * Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used. - * - * @param addr ip address in network order to convert - * @param buf target buffer where the string is stored - * @param buflen length of buf - * @return either pointer to buf which now holds the ASCII - * representation of addr or NULL if buf was too small - */ -char *ipaddr_ntoa_r(const ip_addr_t *addr, char *buf, int buflen) -{ - if (addr == NULL) { - return NULL; - } - if (IP_IS_V6(addr)) { - return ip6addr_ntoa_r(ip_2_ip6(addr), buf, buflen); - } else { - return ip4addr_ntoa_r(ip_2_ip4(addr), buf, buflen); - } -} - -/** - * @ingroup ipaddr - * Convert IP address string (both versions) to numeric. - * The version is auto-detected from the string. - * - * @param cp IP address string to convert - * @param addr conversion result is stored here - * @return 1 on success, 0 on error - */ -int -ipaddr_aton(const char *cp, ip_addr_t *addr) -{ - if (cp != NULL) { - const char *c; - for (c = cp; *c != 0; c++) { - if (*c == ':') { - /* contains a colon: IPv6 address */ - if (addr) { - IP_SET_TYPE_VAL(*addr, IPADDR_TYPE_V6); - } - return ip6addr_aton(cp, ip_2_ip6(addr)); - } else if (*c == '.') { - /* contains a dot: IPv4 address */ - break; - } - } - /* call ip4addr_aton as fallback or if IPv4 was found */ - if (addr) { - IP_SET_TYPE_VAL(*addr, IPADDR_TYPE_V4); - } - return ip4addr_aton(cp, ip_2_ip4(addr)); - } - return 0; -} - -/** - * @ingroup lwip_nosys - * If both IP versions are enabled, this function can dispatch packets to the correct one. - * Don't call directly, pass to netif_add() and call netif->input(). - */ -err_t -ip_input(struct pbuf *p, struct netif *inp) -{ - if (p != NULL) { - if (IP_HDR_GET_VERSION(p->payload) == 6) { - return ip6_input(p, inp); - } - return ip4_input(p, inp); - } - return ERR_VAL; -} - -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - -#endif /* LWIP_IPV4 || LWIP_IPV6 */ +/** + * @file + * Common IPv4 and IPv6 code + * + * @defgroup ip IP + * @ingroup callbackstyle_api + * + * @defgroup ip4 IPv4 + * @ingroup ip + * + * @defgroup ip6 IPv6 + * @ingroup ip + * + * @defgroup ipaddr IP address handling + * @ingroup infrastructure + * + * @defgroup ip4addr IPv4 only + * @ingroup ipaddr + * + * @defgroup ip6addr IPv6 only + * @ingroup ipaddr + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 || LWIP_IPV6 + +#include "lwip/ip_addr.h" +#include "lwip/ip.h" + +/** Global data for both IPv4 and IPv6 */ +struct ip_globals ip_data; + +#if LWIP_IPV4 && LWIP_IPV6 + +const ip_addr_t ip_addr_any_type = IPADDR_ANY_TYPE_INIT; + +/** + * @ingroup ipaddr + * Convert numeric IP address (both versions) into ASCII representation. + * returns ptr to static buffer; not reentrant! + * + * @param addr ip address in network order to convert + * @return pointer to a global static (!) buffer that holds the ASCII + * representation of addr + */ +char *ipaddr_ntoa(const ip_addr_t *addr) +{ + if (addr == NULL) { + return NULL; + } + if (IP_IS_V6(addr)) { + return ip6addr_ntoa(ip_2_ip6(addr)); + } else { + return ip4addr_ntoa(ip_2_ip4(addr)); + } +} + +/** + * @ingroup ipaddr + * Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used. + * + * @param addr ip address in network order to convert + * @param buf target buffer where the string is stored + * @param buflen length of buf + * @return either pointer to buf which now holds the ASCII + * representation of addr or NULL if buf was too small + */ +char *ipaddr_ntoa_r(const ip_addr_t *addr, char *buf, int buflen) +{ + if (addr == NULL) { + return NULL; + } + if (IP_IS_V6(addr)) { + return ip6addr_ntoa_r(ip_2_ip6(addr), buf, buflen); + } else { + return ip4addr_ntoa_r(ip_2_ip4(addr), buf, buflen); + } +} + +/** + * @ingroup ipaddr + * Convert IP address string (both versions) to numeric. + * The version is auto-detected from the string. + * + * @param cp IP address string to convert + * @param addr conversion result is stored here + * @return 1 on success, 0 on error + */ +int +ipaddr_aton(const char *cp, ip_addr_t *addr) +{ + if (cp != NULL) { + const char *c; + for (c = cp; *c != 0; c++) { + if (*c == ':') { + /* contains a colon: IPv6 address */ + if (addr) { + IP_SET_TYPE_VAL(*addr, IPADDR_TYPE_V6); + } + return ip6addr_aton(cp, ip_2_ip6(addr)); + } else if (*c == '.') { + /* contains a dot: IPv4 address */ + break; + } + } + /* call ip4addr_aton as fallback or if IPv4 was found */ + if (addr) { + IP_SET_TYPE_VAL(*addr, IPADDR_TYPE_V4); + } + return ip4addr_aton(cp, ip_2_ip4(addr)); + } + return 0; +} + +/** + * @ingroup lwip_nosys + * If both IP versions are enabled, this function can dispatch packets to the correct one. + * Don't call directly, pass to netif_add() and call netif->input(). + */ +err_t +ip_input(struct pbuf *p, struct netif *inp) +{ + if (p != NULL) { + if (IP_HDR_GET_VERSION(p->payload) == 6) { + return ip6_input(p, inp); + } + return ip4_input(p, inp); + } + return ERR_VAL; +} + +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + +#endif /* LWIP_IPV4 || LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/autoip.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/autoip.c index a4545049..9f7139bc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/autoip.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/autoip.c @@ -1,527 +1,527 @@ -/** - * @file - * AutoIP Automatic LinkLocal IP Configuration - * - * This is a AutoIP implementation for the lwIP TCP/IP stack. It aims to conform - * with RFC 3927. - * - * @defgroup autoip AUTOIP - * @ingroup ip4 - * AUTOIP related functions - * USAGE: - * - * define @ref LWIP_AUTOIP 1 in your lwipopts.h - * Options: - * AUTOIP_TMR_INTERVAL msecs, - * I recommend a value of 100. The value must divide 1000 with a remainder almost 0. - * Possible values are 1000, 500, 333, 250, 200, 166, 142, 125, 111, 100 .... - * - * Without DHCP: - * - Call autoip_start() after netif_add(). - * - * With DHCP: - * - define @ref LWIP_DHCP_AUTOIP_COOP 1 in your lwipopts.h. - * - Configure your DHCP Client. - * - * @see netifapi_autoip - */ - -/* - * - * Copyright (c) 2007 Dominik Spies - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dominik Spies - */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 && LWIP_AUTOIP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/mem.h" -/* #include "lwip/udp.h" */ -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/autoip.h" -#include "lwip/etharp.h" -#include "lwip/prot/autoip.h" - -#include - -/** Pseudo random macro based on netif informations. - * You could use "rand()" from the C Library if you define LWIP_AUTOIP_RAND in lwipopts.h */ -#ifndef LWIP_AUTOIP_RAND -#define LWIP_AUTOIP_RAND(netif) ( (((u32_t)((netif->hwaddr[5]) & 0xff) << 24) | \ - ((u32_t)((netif->hwaddr[3]) & 0xff) << 16) | \ - ((u32_t)((netif->hwaddr[2]) & 0xff) << 8) | \ - ((u32_t)((netif->hwaddr[4]) & 0xff))) + \ - (netif_autoip_data(netif)? netif_autoip_data(netif)->tried_llipaddr : 0)) -#endif /* LWIP_AUTOIP_RAND */ - -/** - * Macro that generates the initial IP address to be tried by AUTOIP. - * If you want to override this, define it to something else in lwipopts.h. - */ -#ifndef LWIP_AUTOIP_CREATE_SEED_ADDR -#define LWIP_AUTOIP_CREATE_SEED_ADDR(netif) \ - lwip_htonl(AUTOIP_RANGE_START + ((u32_t)(((u8_t)(netif->hwaddr[4])) | \ - ((u32_t)((u8_t)(netif->hwaddr[5]))) << 8))) -#endif /* LWIP_AUTOIP_CREATE_SEED_ADDR */ - -/* static functions */ -static err_t autoip_arp_announce(struct netif *netif); -static void autoip_start_probing(struct netif *netif); - -/** - * @ingroup autoip - * Set a statically allocated struct autoip to work with. - * Using this prevents autoip_start to allocate it using mem_malloc. - * - * @param netif the netif for which to set the struct autoip - * @param autoip (uninitialised) autoip struct allocated by the application - */ -void -autoip_set_struct(struct netif *netif, struct autoip *autoip) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("autoip != NULL", autoip != NULL); - LWIP_ASSERT("netif already has a struct autoip set", - netif_autoip_data(netif) == NULL); - - /* clear data structure */ - memset(autoip, 0, sizeof(struct autoip)); - /* autoip->state = AUTOIP_STATE_OFF; */ - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip); -} - -/** Restart AutoIP client and check the next address (conflict detected) - * - * @param netif The netif under AutoIP control - */ -static void -autoip_restart(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - autoip->tried_llipaddr++; - autoip_start(netif); -} - -/** - * Handle a IP address conflict after an ARP conflict detection - */ -static void -autoip_handle_arp_conflict(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - - /* RFC3927, 2.5 "Conflict Detection and Defense" allows two options where - a) means retreat on the first conflict and - b) allows to keep an already configured address when having only one - conflict in 10 seconds - We use option b) since it helps to improve the chance that one of the two - conflicting hosts may be able to retain its address. */ - - if (autoip->lastconflict > 0) { - /* retreat, there was a conflicting ARP in the last DEFEND_INTERVAL seconds */ - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n")); - - /* Active TCP sessions are aborted when removing the ip addresss */ - autoip_restart(netif); - } else { - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n")); - autoip_arp_announce(netif); - autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND; - } -} - -/** - * Create an IP-Address out of range 169.254.1.0 to 169.254.254.255 - * - * @param netif network interface on which create the IP-Address - * @param ipaddr ip address to initialize - */ -static void -autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr) -{ - struct autoip *autoip = netif_autoip_data(netif); - - /* Here we create an IP-Address out of range 169.254.1.0 to 169.254.254.255 - * compliant to RFC 3927 Section 2.1 - * We have 254 * 256 possibilities */ - - u32_t addr = lwip_ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif)); - addr += autoip->tried_llipaddr; - addr = AUTOIP_NET | (addr & 0xffff); - /* Now, 169.254.0.0 <= addr <= 169.254.255.255 */ - - if (addr < AUTOIP_RANGE_START) { - addr += AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1; - } - if (addr > AUTOIP_RANGE_END) { - addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1; - } - LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) && - (addr <= AUTOIP_RANGE_END)); - ip4_addr_set_u32(ipaddr, lwip_htonl(addr)); - - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - (u16_t)(autoip->tried_llipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), - ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr))); -} - -/** - * Sends an ARP probe from a network interface - * - * @param netif network interface used to send the probe - */ -static err_t -autoip_arp_probe(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - /* this works because netif->ip_addr is ANY */ - return etharp_request(netif, &autoip->llipaddr); -} - -/** - * Sends an ARP announce from a network interface - * - * @param netif network interface used to send the announce - */ -static err_t -autoip_arp_announce(struct netif *netif) -{ - return etharp_gratuitous(netif); -} - -/** - * Configure interface for use with current LL IP-Address - * - * @param netif network interface to configure with current LL IP-Address - */ -static err_t -autoip_bind(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - ip4_addr_t sn_mask, gw_addr; - - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, - ("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num, - ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), - ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); - - IP4_ADDR(&sn_mask, 255, 255, 0, 0); - IP4_ADDR(&gw_addr, 0, 0, 0, 0); - - netif_set_addr(netif, &autoip->llipaddr, &sn_mask, &gw_addr); - /* interface is used by routing now that an address is set */ - - return ERR_OK; -} - -/** - * @ingroup autoip - * Start AutoIP client - * - * @param netif network interface on which start the AutoIP client - */ -err_t -autoip_start(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - err_t result = ERR_OK; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;); - - /* Set IP-Address, Netmask and Gateway to 0 to make sure that - * ARP Packets are formed correctly - */ - netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); - - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("autoip_start(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], - netif->name[1], (u16_t)netif->num)); - if (autoip == NULL) { - /* no AutoIP client attached yet? */ - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, - ("autoip_start(): starting new AUTOIP client\n")); - autoip = (struct autoip *)mem_calloc(1, sizeof(struct autoip)); - if (autoip == NULL) { - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, - ("autoip_start(): could not allocate autoip\n")); - return ERR_MEM; - } - /* store this AutoIP client in the netif */ - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip); - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_start(): allocated autoip")); - } else { - autoip->state = AUTOIP_STATE_OFF; - autoip->ttw = 0; - autoip->sent_num = 0; - ip4_addr_set_zero(&autoip->llipaddr); - autoip->lastconflict = 0; - } - - autoip_create_addr(netif, &(autoip->llipaddr)); - autoip_start_probing(netif); - - return result; -} - -static void -autoip_start_probing(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - - autoip->state = AUTOIP_STATE_PROBING; - autoip->sent_num = 0; - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("autoip_start_probing(): changing state to PROBING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), - ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); - - /* time to wait to first probe, this is randomly - * chosen out of 0 to PROBE_WAIT seconds. - * compliant to RFC 3927 Section 2.2.1 - */ - autoip->ttw = (u16_t)(LWIP_AUTOIP_RAND(netif) % (PROBE_WAIT * AUTOIP_TICKS_PER_SECOND)); - - /* - * if we tried more then MAX_CONFLICTS we must limit our rate for - * acquiring and probing address - * compliant to RFC 3927 Section 2.2.1 - */ - if (autoip->tried_llipaddr > MAX_CONFLICTS) { - autoip->ttw = RATE_LIMIT_INTERVAL * AUTOIP_TICKS_PER_SECOND; - } -} - -/** - * Handle a possible change in the network configuration. - * - * If there is an AutoIP address configured, take the interface down - * and begin probing with the same address. - */ -void -autoip_network_changed(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - - if (autoip && (autoip->state != AUTOIP_STATE_OFF)) { - autoip_start_probing(netif); - } -} - -/** - * @ingroup autoip - * Stop AutoIP client - * - * @param netif network interface on which stop the AutoIP client - */ -err_t -autoip_stop(struct netif *netif) -{ - struct autoip *autoip = netif_autoip_data(netif); - - LWIP_ASSERT_CORE_LOCKED(); - if (autoip != NULL) { - autoip->state = AUTOIP_STATE_OFF; - if (ip4_addr_islinklocal(netif_ip4_addr(netif))) { - netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); - } - } - return ERR_OK; -} - -/** - * Has to be called in loop every AUTOIP_TMR_INTERVAL milliseconds - */ -void -autoip_tmr(void) -{ - struct netif *netif; - /* loop through netif's */ - NETIF_FOREACH(netif) { - struct autoip *autoip = netif_autoip_data(netif); - /* only act on AutoIP configured interfaces */ - if (autoip != NULL) { - if (autoip->lastconflict > 0) { - autoip->lastconflict--; - } - - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, - ("autoip_tmr() AutoIP-State: %"U16_F", ttw=%"U16_F"\n", - (u16_t)(autoip->state), autoip->ttw)); - - if (autoip->ttw > 0) { - autoip->ttw--; - } - - switch (autoip->state) { - case AUTOIP_STATE_PROBING: - if (autoip->ttw == 0) { - if (autoip->sent_num >= PROBE_NUM) { - /* Switch to ANNOUNCING: now we can bind to an IP address and use it */ - autoip->state = AUTOIP_STATE_ANNOUNCING; - autoip_bind(netif); - /* autoip_bind() calls netif_set_addr(): this triggers a gratuitous ARP - which counts as an announcement */ - autoip->sent_num = 1; - autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND; - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("autoip_tmr(): changing state to ANNOUNCING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), - ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); - } else { - autoip_arp_probe(netif); - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() PROBING Sent Probe\n")); - autoip->sent_num++; - if (autoip->sent_num == PROBE_NUM) { - /* calculate time to wait to for announce */ - autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND; - } else { - /* calculate time to wait to next probe */ - autoip->ttw = (u16_t)((LWIP_AUTOIP_RAND(netif) % - ((PROBE_MAX - PROBE_MIN) * AUTOIP_TICKS_PER_SECOND) ) + - PROBE_MIN * AUTOIP_TICKS_PER_SECOND); - } - } - } - break; - - case AUTOIP_STATE_ANNOUNCING: - if (autoip->ttw == 0) { - autoip_arp_announce(netif); - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() ANNOUNCING Sent Announce\n")); - autoip->ttw = ANNOUNCE_INTERVAL * AUTOIP_TICKS_PER_SECOND; - autoip->sent_num++; - - if (autoip->sent_num >= ANNOUNCE_NUM) { - autoip->state = AUTOIP_STATE_BOUND; - autoip->sent_num = 0; - autoip->ttw = 0; - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("autoip_tmr(): changing state to BOUND: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), - ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); - } - } - break; - - default: - /* nothing to do in other states */ - break; - } - } - } -} - -/** - * Handles every incoming ARP Packet, called by etharp_input(). - * - * @param netif network interface to use for autoip processing - * @param hdr Incoming ARP packet - */ -void -autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr) -{ - struct autoip *autoip = netif_autoip_data(netif); - - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n")); - if ((autoip != NULL) && (autoip->state != AUTOIP_STATE_OFF)) { - /* when ip.src == llipaddr && hw.src != netif->hwaddr - * - * when probing ip.dst == llipaddr && hw.src != netif->hwaddr - * we have a conflict and must solve it - */ - ip4_addr_t sipaddr, dipaddr; - struct eth_addr netifaddr; - SMEMCPY(netifaddr.addr, netif->hwaddr, ETH_HWADDR_LEN); - - /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without - * structure packing (not using structure copy which breaks strict-aliasing rules). - */ - IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&sipaddr, &hdr->sipaddr); - IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&dipaddr, &hdr->dipaddr); - - if (autoip->state == AUTOIP_STATE_PROBING) { - /* RFC 3927 Section 2.2.1: - * from beginning to after ANNOUNCE_WAIT - * seconds we have a conflict if - * ip.src == llipaddr OR - * ip.dst == llipaddr && hw.src != own hwaddr - */ - if ((ip4_addr_cmp(&sipaddr, &autoip->llipaddr)) || - (ip4_addr_isany_val(sipaddr) && - ip4_addr_cmp(&dipaddr, &autoip->llipaddr) && - !eth_addr_cmp(&netifaddr, &hdr->shwaddr))) { - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, - ("autoip_arp_reply(): Probe Conflict detected\n")); - autoip_restart(netif); - } - } else { - /* RFC 3927 Section 2.5: - * in any state we have a conflict if - * ip.src == llipaddr && hw.src != own hwaddr - */ - if (ip4_addr_cmp(&sipaddr, &autoip->llipaddr) && - !eth_addr_cmp(&netifaddr, &hdr->shwaddr)) { - LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, - ("autoip_arp_reply(): Conflicting ARP-Packet detected\n")); - autoip_handle_arp_conflict(netif); - } - } - } -} - -/** check if AutoIP supplied netif->ip_addr - * - * @param netif the netif to check - * @return 1 if AutoIP supplied netif->ip_addr (state BOUND or ANNOUNCING), - * 0 otherwise - */ -u8_t -autoip_supplied_address(const struct netif *netif) -{ - if ((netif != NULL) && (netif_autoip_data(netif) != NULL)) { - struct autoip *autoip = netif_autoip_data(netif); - return (autoip->state == AUTOIP_STATE_BOUND) || (autoip->state == AUTOIP_STATE_ANNOUNCING); - } - return 0; -} - -u8_t -autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr) -{ - struct autoip *autoip = netif_autoip_data(netif); - return (autoip != NULL) && ip4_addr_cmp(addr, &(autoip->llipaddr)); -} - -#endif /* LWIP_IPV4 && LWIP_AUTOIP */ +/** + * @file + * AutoIP Automatic LinkLocal IP Configuration + * + * This is a AutoIP implementation for the lwIP TCP/IP stack. It aims to conform + * with RFC 3927. + * + * @defgroup autoip AUTOIP + * @ingroup ip4 + * AUTOIP related functions + * USAGE: + * + * define @ref LWIP_AUTOIP 1 in your lwipopts.h + * Options: + * AUTOIP_TMR_INTERVAL msecs, + * I recommend a value of 100. The value must divide 1000 with a remainder almost 0. + * Possible values are 1000, 500, 333, 250, 200, 166, 142, 125, 111, 100 .... + * + * Without DHCP: + * - Call autoip_start() after netif_add(). + * + * With DHCP: + * - define @ref LWIP_DHCP_AUTOIP_COOP 1 in your lwipopts.h. + * - Configure your DHCP Client. + * + * @see netifapi_autoip + */ + +/* + * + * Copyright (c) 2007 Dominik Spies + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dominik Spies + */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_AUTOIP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/mem.h" +/* #include "lwip/udp.h" */ +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/autoip.h" +#include "lwip/etharp.h" +#include "lwip/prot/autoip.h" + +#include + +/** Pseudo random macro based on netif informations. + * You could use "rand()" from the C Library if you define LWIP_AUTOIP_RAND in lwipopts.h */ +#ifndef LWIP_AUTOIP_RAND +#define LWIP_AUTOIP_RAND(netif) ( (((u32_t)((netif->hwaddr[5]) & 0xff) << 24) | \ + ((u32_t)((netif->hwaddr[3]) & 0xff) << 16) | \ + ((u32_t)((netif->hwaddr[2]) & 0xff) << 8) | \ + ((u32_t)((netif->hwaddr[4]) & 0xff))) + \ + (netif_autoip_data(netif)? netif_autoip_data(netif)->tried_llipaddr : 0)) +#endif /* LWIP_AUTOIP_RAND */ + +/** + * Macro that generates the initial IP address to be tried by AUTOIP. + * If you want to override this, define it to something else in lwipopts.h. + */ +#ifndef LWIP_AUTOIP_CREATE_SEED_ADDR +#define LWIP_AUTOIP_CREATE_SEED_ADDR(netif) \ + lwip_htonl(AUTOIP_RANGE_START + ((u32_t)(((u8_t)(netif->hwaddr[4])) | \ + ((u32_t)((u8_t)(netif->hwaddr[5]))) << 8))) +#endif /* LWIP_AUTOIP_CREATE_SEED_ADDR */ + +/* static functions */ +static err_t autoip_arp_announce(struct netif *netif); +static void autoip_start_probing(struct netif *netif); + +/** + * @ingroup autoip + * Set a statically allocated struct autoip to work with. + * Using this prevents autoip_start to allocate it using mem_malloc. + * + * @param netif the netif for which to set the struct autoip + * @param autoip (uninitialised) autoip struct allocated by the application + */ +void +autoip_set_struct(struct netif *netif, struct autoip *autoip) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("autoip != NULL", autoip != NULL); + LWIP_ASSERT("netif already has a struct autoip set", + netif_autoip_data(netif) == NULL); + + /* clear data structure */ + memset(autoip, 0, sizeof(struct autoip)); + /* autoip->state = AUTOIP_STATE_OFF; */ + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip); +} + +/** Restart AutoIP client and check the next address (conflict detected) + * + * @param netif The netif under AutoIP control + */ +static void +autoip_restart(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + autoip->tried_llipaddr++; + autoip_start(netif); +} + +/** + * Handle a IP address conflict after an ARP conflict detection + */ +static void +autoip_handle_arp_conflict(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + + /* RFC3927, 2.5 "Conflict Detection and Defense" allows two options where + a) means retreat on the first conflict and + b) allows to keep an already configured address when having only one + conflict in 10 seconds + We use option b) since it helps to improve the chance that one of the two + conflicting hosts may be able to retain its address. */ + + if (autoip->lastconflict > 0) { + /* retreat, there was a conflicting ARP in the last DEFEND_INTERVAL seconds */ + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("autoip_handle_arp_conflict(): we are defending, but in DEFEND_INTERVAL, retreating\n")); + + /* Active TCP sessions are aborted when removing the ip addresss */ + autoip_restart(netif); + } else { + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("autoip_handle_arp_conflict(): we are defend, send ARP Announce\n")); + autoip_arp_announce(netif); + autoip->lastconflict = DEFEND_INTERVAL * AUTOIP_TICKS_PER_SECOND; + } +} + +/** + * Create an IP-Address out of range 169.254.1.0 to 169.254.254.255 + * + * @param netif network interface on which create the IP-Address + * @param ipaddr ip address to initialize + */ +static void +autoip_create_addr(struct netif *netif, ip4_addr_t *ipaddr) +{ + struct autoip *autoip = netif_autoip_data(netif); + + /* Here we create an IP-Address out of range 169.254.1.0 to 169.254.254.255 + * compliant to RFC 3927 Section 2.1 + * We have 254 * 256 possibilities */ + + u32_t addr = lwip_ntohl(LWIP_AUTOIP_CREATE_SEED_ADDR(netif)); + addr += autoip->tried_llipaddr; + addr = AUTOIP_NET | (addr & 0xffff); + /* Now, 169.254.0.0 <= addr <= 169.254.255.255 */ + + if (addr < AUTOIP_RANGE_START) { + addr += AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1; + } + if (addr > AUTOIP_RANGE_END) { + addr -= AUTOIP_RANGE_END - AUTOIP_RANGE_START + 1; + } + LWIP_ASSERT("AUTOIP address not in range", (addr >= AUTOIP_RANGE_START) && + (addr <= AUTOIP_RANGE_END)); + ip4_addr_set_u32(ipaddr, lwip_htonl(addr)); + + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("autoip_create_addr(): tried_llipaddr=%"U16_F", %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + (u16_t)(autoip->tried_llipaddr), ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), + ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr))); +} + +/** + * Sends an ARP probe from a network interface + * + * @param netif network interface used to send the probe + */ +static err_t +autoip_arp_probe(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + /* this works because netif->ip_addr is ANY */ + return etharp_request(netif, &autoip->llipaddr); +} + +/** + * Sends an ARP announce from a network interface + * + * @param netif network interface used to send the announce + */ +static err_t +autoip_arp_announce(struct netif *netif) +{ + return etharp_gratuitous(netif); +} + +/** + * Configure interface for use with current LL IP-Address + * + * @param netif network interface to configure with current LL IP-Address + */ +static err_t +autoip_bind(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + ip4_addr_t sn_mask, gw_addr; + + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, + ("autoip_bind(netif=%p) %c%c%"U16_F" %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num, + ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), + ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); + + IP4_ADDR(&sn_mask, 255, 255, 0, 0); + IP4_ADDR(&gw_addr, 0, 0, 0, 0); + + netif_set_addr(netif, &autoip->llipaddr, &sn_mask, &gw_addr); + /* interface is used by routing now that an address is set */ + + return ERR_OK; +} + +/** + * @ingroup autoip + * Start AutoIP client + * + * @param netif network interface on which start the AutoIP client + */ +err_t +autoip_start(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + err_t result = ERR_OK; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;); + + /* Set IP-Address, Netmask and Gateway to 0 to make sure that + * ARP Packets are formed correctly + */ + netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); + + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("autoip_start(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], + netif->name[1], (u16_t)netif->num)); + if (autoip == NULL) { + /* no AutoIP client attached yet? */ + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, + ("autoip_start(): starting new AUTOIP client\n")); + autoip = (struct autoip *)mem_calloc(1, sizeof(struct autoip)); + if (autoip == NULL) { + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, + ("autoip_start(): could not allocate autoip\n")); + return ERR_MEM; + } + /* store this AutoIP client in the netif */ + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, autoip); + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_start(): allocated autoip")); + } else { + autoip->state = AUTOIP_STATE_OFF; + autoip->ttw = 0; + autoip->sent_num = 0; + ip4_addr_set_zero(&autoip->llipaddr); + autoip->lastconflict = 0; + } + + autoip_create_addr(netif, &(autoip->llipaddr)); + autoip_start_probing(netif); + + return result; +} + +static void +autoip_start_probing(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + + autoip->state = AUTOIP_STATE_PROBING; + autoip->sent_num = 0; + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("autoip_start_probing(): changing state to PROBING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), + ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); + + /* time to wait to first probe, this is randomly + * chosen out of 0 to PROBE_WAIT seconds. + * compliant to RFC 3927 Section 2.2.1 + */ + autoip->ttw = (u16_t)(LWIP_AUTOIP_RAND(netif) % (PROBE_WAIT * AUTOIP_TICKS_PER_SECOND)); + + /* + * if we tried more then MAX_CONFLICTS we must limit our rate for + * acquiring and probing address + * compliant to RFC 3927 Section 2.2.1 + */ + if (autoip->tried_llipaddr > MAX_CONFLICTS) { + autoip->ttw = RATE_LIMIT_INTERVAL * AUTOIP_TICKS_PER_SECOND; + } +} + +/** + * Handle a possible change in the network configuration. + * + * If there is an AutoIP address configured, take the interface down + * and begin probing with the same address. + */ +void +autoip_network_changed(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + + if (autoip && (autoip->state != AUTOIP_STATE_OFF)) { + autoip_start_probing(netif); + } +} + +/** + * @ingroup autoip + * Stop AutoIP client + * + * @param netif network interface on which stop the AutoIP client + */ +err_t +autoip_stop(struct netif *netif) +{ + struct autoip *autoip = netif_autoip_data(netif); + + LWIP_ASSERT_CORE_LOCKED(); + if (autoip != NULL) { + autoip->state = AUTOIP_STATE_OFF; + if (ip4_addr_islinklocal(netif_ip4_addr(netif))) { + netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); + } + } + return ERR_OK; +} + +/** + * Has to be called in loop every AUTOIP_TMR_INTERVAL milliseconds + */ +void +autoip_tmr(void) +{ + struct netif *netif; + /* loop through netif's */ + NETIF_FOREACH(netif) { + struct autoip *autoip = netif_autoip_data(netif); + /* only act on AutoIP configured interfaces */ + if (autoip != NULL) { + if (autoip->lastconflict > 0) { + autoip->lastconflict--; + } + + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, + ("autoip_tmr() AutoIP-State: %"U16_F", ttw=%"U16_F"\n", + (u16_t)(autoip->state), autoip->ttw)); + + if (autoip->ttw > 0) { + autoip->ttw--; + } + + switch (autoip->state) { + case AUTOIP_STATE_PROBING: + if (autoip->ttw == 0) { + if (autoip->sent_num >= PROBE_NUM) { + /* Switch to ANNOUNCING: now we can bind to an IP address and use it */ + autoip->state = AUTOIP_STATE_ANNOUNCING; + autoip_bind(netif); + /* autoip_bind() calls netif_set_addr(): this triggers a gratuitous ARP + which counts as an announcement */ + autoip->sent_num = 1; + autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND; + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("autoip_tmr(): changing state to ANNOUNCING: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), + ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); + } else { + autoip_arp_probe(netif); + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() PROBING Sent Probe\n")); + autoip->sent_num++; + if (autoip->sent_num == PROBE_NUM) { + /* calculate time to wait to for announce */ + autoip->ttw = ANNOUNCE_WAIT * AUTOIP_TICKS_PER_SECOND; + } else { + /* calculate time to wait to next probe */ + autoip->ttw = (u16_t)((LWIP_AUTOIP_RAND(netif) % + ((PROBE_MAX - PROBE_MIN) * AUTOIP_TICKS_PER_SECOND) ) + + PROBE_MIN * AUTOIP_TICKS_PER_SECOND); + } + } + } + break; + + case AUTOIP_STATE_ANNOUNCING: + if (autoip->ttw == 0) { + autoip_arp_announce(netif); + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_tmr() ANNOUNCING Sent Announce\n")); + autoip->ttw = ANNOUNCE_INTERVAL * AUTOIP_TICKS_PER_SECOND; + autoip->sent_num++; + + if (autoip->sent_num >= ANNOUNCE_NUM) { + autoip->state = AUTOIP_STATE_BOUND; + autoip->sent_num = 0; + autoip->ttw = 0; + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("autoip_tmr(): changing state to BOUND: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(&autoip->llipaddr), ip4_addr2_16(&autoip->llipaddr), + ip4_addr3_16(&autoip->llipaddr), ip4_addr4_16(&autoip->llipaddr))); + } + } + break; + + default: + /* nothing to do in other states */ + break; + } + } + } +} + +/** + * Handles every incoming ARP Packet, called by etharp_input(). + * + * @param netif network interface to use for autoip processing + * @param hdr Incoming ARP packet + */ +void +autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr) +{ + struct autoip *autoip = netif_autoip_data(netif); + + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE, ("autoip_arp_reply()\n")); + if ((autoip != NULL) && (autoip->state != AUTOIP_STATE_OFF)) { + /* when ip.src == llipaddr && hw.src != netif->hwaddr + * + * when probing ip.dst == llipaddr && hw.src != netif->hwaddr + * we have a conflict and must solve it + */ + ip4_addr_t sipaddr, dipaddr; + struct eth_addr netifaddr; + SMEMCPY(netifaddr.addr, netif->hwaddr, ETH_HWADDR_LEN); + + /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without + * structure packing (not using structure copy which breaks strict-aliasing rules). + */ + IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&sipaddr, &hdr->sipaddr); + IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&dipaddr, &hdr->dipaddr); + + if (autoip->state == AUTOIP_STATE_PROBING) { + /* RFC 3927 Section 2.2.1: + * from beginning to after ANNOUNCE_WAIT + * seconds we have a conflict if + * ip.src == llipaddr OR + * ip.dst == llipaddr && hw.src != own hwaddr + */ + if ((ip4_addr_cmp(&sipaddr, &autoip->llipaddr)) || + (ip4_addr_isany_val(sipaddr) && + ip4_addr_cmp(&dipaddr, &autoip->llipaddr) && + !eth_addr_cmp(&netifaddr, &hdr->shwaddr))) { + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, + ("autoip_arp_reply(): Probe Conflict detected\n")); + autoip_restart(netif); + } + } else { + /* RFC 3927 Section 2.5: + * in any state we have a conflict if + * ip.src == llipaddr && hw.src != own hwaddr + */ + if (ip4_addr_cmp(&sipaddr, &autoip->llipaddr) && + !eth_addr_cmp(&netifaddr, &hdr->shwaddr)) { + LWIP_DEBUGF(AUTOIP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, + ("autoip_arp_reply(): Conflicting ARP-Packet detected\n")); + autoip_handle_arp_conflict(netif); + } + } + } +} + +/** check if AutoIP supplied netif->ip_addr + * + * @param netif the netif to check + * @return 1 if AutoIP supplied netif->ip_addr (state BOUND or ANNOUNCING), + * 0 otherwise + */ +u8_t +autoip_supplied_address(const struct netif *netif) +{ + if ((netif != NULL) && (netif_autoip_data(netif) != NULL)) { + struct autoip *autoip = netif_autoip_data(netif); + return (autoip->state == AUTOIP_STATE_BOUND) || (autoip->state == AUTOIP_STATE_ANNOUNCING); + } + return 0; +} + +u8_t +autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr) +{ + struct autoip *autoip = netif_autoip_data(netif); + return (autoip != NULL) && ip4_addr_cmp(addr, &(autoip->llipaddr)); +} + +#endif /* LWIP_IPV4 && LWIP_AUTOIP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/dhcp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/dhcp.c index 89f9c416..534574fe 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/dhcp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/dhcp.c @@ -1,1990 +1,1990 @@ -/** - * @file - * Dynamic Host Configuration Protocol client - * - * @defgroup dhcp4 DHCPv4 - * @ingroup ip4 - * DHCP (IPv4) related functions - * This is a DHCP client for the lwIP TCP/IP stack. It aims to conform - * with RFC 2131 and RFC 2132. - * - * @todo: - * - Support for interfaces other than Ethernet (SLIP, PPP, ...) - * - * Options: - * @ref DHCP_COARSE_TIMER_SECS (recommended 60 which is a minute) - * @ref DHCP_FINE_TIMER_MSECS (recommended 500 which equals TCP coarse timer) - * - * dhcp_start() starts a DHCP client instance which - * configures the interface by obtaining an IP address lease and maintaining it. - * - * Use dhcp_release() to end the lease and use dhcp_stop() - * to remove the DHCP client. - * - * @see LWIP_HOOK_DHCP_APPEND_OPTIONS - * @see LWIP_HOOK_DHCP_PARSE_OPTION - * - * @see netifapi_dhcp4 - */ - -/* - * Copyright (c) 2001-2004 Leon Woestenberg - * Copyright (c) 2001-2004 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * The Swedish Institute of Computer Science and Adam Dunkels - * are specifically granted permission to redistribute this - * source code. - * - * Author: Leon Woestenberg - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 && LWIP_DHCP /* don't build if not configured for use in lwipopts.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/dhcp.h" -#include "lwip/autoip.h" -#include "lwip/dns.h" -#include "lwip/etharp.h" -#include "lwip/prot/dhcp.h" -#include "lwip/prot/iana.h" - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif -#ifndef LWIP_HOOK_DHCP_APPEND_OPTIONS -#define LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, state, msg, msg_type, options_len_ptr) -#endif -#ifndef LWIP_HOOK_DHCP_PARSE_OPTION -#define LWIP_HOOK_DHCP_PARSE_OPTION(netif, dhcp, state, msg, msg_type, option, len, pbuf, offset) do { LWIP_UNUSED_ARG(msg); } while(0) -#endif - -/** DHCP_CREATE_RAND_XID: if this is set to 1, the xid is created using - * LWIP_RAND() (this overrides DHCP_GLOBAL_XID) - */ -#ifndef DHCP_CREATE_RAND_XID -#define DHCP_CREATE_RAND_XID 1 -#endif - -/** Default for DHCP_GLOBAL_XID is 0xABCD0000 - * This can be changed by defining DHCP_GLOBAL_XID and DHCP_GLOBAL_XID_HEADER, e.g. - * \#define DHCP_GLOBAL_XID_HEADER "stdlib.h" - * \#define DHCP_GLOBAL_XID rand() - */ -#ifdef DHCP_GLOBAL_XID_HEADER -#include DHCP_GLOBAL_XID_HEADER /* include optional starting XID generation prototypes */ -#endif - -/** DHCP_OPTION_MAX_MSG_SIZE is set to the MTU - * MTU is checked to be big enough in dhcp_start */ -#define DHCP_MAX_MSG_LEN(netif) (netif->mtu) -#define DHCP_MAX_MSG_LEN_MIN_REQUIRED 576 -/** Minimum length for reply before packet is parsed */ -#define DHCP_MIN_REPLY_LEN 44 - -#define REBOOT_TRIES 2 - -#if LWIP_DNS && LWIP_DHCP_MAX_DNS_SERVERS -#if DNS_MAX_SERVERS > LWIP_DHCP_MAX_DNS_SERVERS -#define LWIP_DHCP_PROVIDE_DNS_SERVERS LWIP_DHCP_MAX_DNS_SERVERS -#else -#define LWIP_DHCP_PROVIDE_DNS_SERVERS DNS_MAX_SERVERS -#endif -#else -#define LWIP_DHCP_PROVIDE_DNS_SERVERS 0 -#endif - -/** 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_MAX -}; - -/** Holds the decoded option values, only valid while in dhcp_recv. - @todo: move this into struct dhcp? */ -u32_t dhcp_rx_options_val[DHCP_OPTION_IDX_MAX]; -/** Holds a flag which option was received and is contained in dhcp_rx_options_val, - only valid while in dhcp_recv. - @todo: move this into struct dhcp? */ -u8_t dhcp_rx_options_given[DHCP_OPTION_IDX_MAX]; - -static u8_t dhcp_discover_request_options[] = { - DHCP_OPTION_SUBNET_MASK, - DHCP_OPTION_ROUTER, - DHCP_OPTION_BROADCAST -#if LWIP_DHCP_PROVIDE_DNS_SERVERS - , DHCP_OPTION_DNS_SERVER -#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ -#if LWIP_DHCP_GET_NTP_SRV - , DHCP_OPTION_NTP -#endif /* LWIP_DHCP_GET_NTP_SRV */ -}; - -#ifdef DHCP_GLOBAL_XID -static u32_t xid; -static u8_t xid_initialised; -#endif /* DHCP_GLOBAL_XID */ - -#define dhcp_option_given(dhcp, idx) (dhcp_rx_options_given[idx] != 0) -#define dhcp_got_option(dhcp, idx) (dhcp_rx_options_given[idx] = 1) -#define dhcp_clear_option(dhcp, idx) (dhcp_rx_options_given[idx] = 0) -#define dhcp_clear_all_options(dhcp) (memset(dhcp_rx_options_given, 0, sizeof(dhcp_rx_options_given))) -#define dhcp_get_option_value(dhcp, idx) (dhcp_rx_options_val[idx]) -#define dhcp_set_option_value(dhcp, idx, val) (dhcp_rx_options_val[idx] = (val)) - -static struct udp_pcb *dhcp_pcb; -static u8_t dhcp_pcb_refcount; - -/* DHCP client state machine functions */ -static err_t dhcp_discover(struct netif *netif); -static err_t dhcp_select(struct netif *netif); -static void dhcp_bind(struct netif *netif); -#if DHCP_DOES_ARP_CHECK -static err_t dhcp_decline(struct netif *netif); -#endif /* DHCP_DOES_ARP_CHECK */ -static err_t dhcp_rebind(struct netif *netif); -static err_t dhcp_reboot(struct netif *netif); -static void dhcp_set_state(struct dhcp *dhcp, u8_t new_state); - -/* receive, unfold, parse and free incoming messages */ -static void dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); - -/* set the DHCP timers */ -static void dhcp_timeout(struct netif *netif); -static void dhcp_t1_timeout(struct netif *netif); -static void dhcp_t2_timeout(struct netif *netif); - -/* build outgoing messages */ -/* create a DHCP message, fill in common headers */ -static struct pbuf *dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type, u16_t *options_out_len); -/* add a DHCP option (type, then length in bytes) */ -static u16_t dhcp_option(u16_t options_out_len, u8_t *options, u8_t option_type, u8_t option_len); -/* add option values */ -static u16_t dhcp_option_byte(u16_t options_out_len, u8_t *options, u8_t value); -static u16_t dhcp_option_short(u16_t options_out_len, u8_t *options, u16_t value); -static u16_t dhcp_option_long(u16_t options_out_len, u8_t *options, u32_t value); -#if LWIP_NETIF_HOSTNAME -static u16_t dhcp_option_hostname(u16_t options_out_len, u8_t *options, struct netif *netif); -#endif /* LWIP_NETIF_HOSTNAME */ -/* always add the DHCP options trailer to end and pad */ -static void dhcp_option_trailer(u16_t options_out_len, u8_t *options, struct pbuf *p_out); - -/** Ensure DHCP PCB is allocated and bound */ -static err_t -dhcp_inc_pcb_refcount(void) -{ - if (dhcp_pcb_refcount == 0) { - LWIP_ASSERT("dhcp_inc_pcb_refcount(): memory leak", dhcp_pcb == NULL); - - /* allocate UDP PCB */ - dhcp_pcb = udp_new(); - - if (dhcp_pcb == NULL) { - return ERR_MEM; - } - - ip_set_option(dhcp_pcb, SOF_BROADCAST); - - /* set up local and remote port for the pcb -> listen on all interfaces on all src/dest IPs */ - udp_bind(dhcp_pcb, IP4_ADDR_ANY, LWIP_IANA_PORT_DHCP_CLIENT); - udp_connect(dhcp_pcb, IP4_ADDR_ANY, LWIP_IANA_PORT_DHCP_SERVER); - udp_recv(dhcp_pcb, dhcp_recv, NULL); - } - - dhcp_pcb_refcount++; - - return ERR_OK; -} - -/** Free DHCP PCB if the last netif stops using it */ -static void -dhcp_dec_pcb_refcount(void) -{ - LWIP_ASSERT("dhcp_pcb_refcount(): refcount error", (dhcp_pcb_refcount > 0)); - dhcp_pcb_refcount--; - - if (dhcp_pcb_refcount == 0) { - udp_remove(dhcp_pcb); - dhcp_pcb = NULL; - } -} - -/** - * Back-off the DHCP client (because of a received NAK response). - * - * Back-off the DHCP client because of a received NAK. Receiving a - * NAK means the client asked for something non-sensible, for - * example when it tries to renew a lease obtained on another network. - * - * We clear any existing set IP address and restart DHCP negotiation - * afresh (as per RFC2131 3.2.3). - * - * @param netif the netif under DHCP control - */ -static void -dhcp_handle_nak(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_nak(netif=%p) %c%c%"U16_F"\n", - (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); - /* Change to a defined state - set this before assigning the address - to ensure the callback can use dhcp_supplied_address() */ - dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF); - /* remove IP address from interface (must no longer be used, as per RFC2131) */ - netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); - /* We can immediately restart discovery */ - dhcp_discover(netif); -} - -#if DHCP_DOES_ARP_CHECK -/** - * Checks if the offered IP address is already in use. - * - * It does so by sending an ARP request for the offered address and - * entering CHECKING state. If no ARP reply is received within a small - * interval, the address is assumed to be free for use by us. - * - * @param netif the netif under DHCP control - */ -static void -dhcp_check(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - err_t result; - u16_t msecs; - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_check(netif=%p) %c%c\n", (void *)netif, (s16_t)netif->name[0], - (s16_t)netif->name[1])); - dhcp_set_state(dhcp, DHCP_STATE_CHECKING); - /* create an ARP query for the offered IP address, expecting that no host - responds, as the IP address should not be in use. */ - result = etharp_query(netif, &dhcp->offered_ip_addr, NULL); - if (result != ERR_OK) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("dhcp_check: could not perform ARP query\n")); - } - if (dhcp->tries < 255) { - dhcp->tries++; - } - msecs = 500; - dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_check(): set request timeout %"U16_F" msecs\n", msecs)); -} -#endif /* DHCP_DOES_ARP_CHECK */ - -/** - * Remember the configuration offered by a DHCP server. - * - * @param netif the netif under DHCP control - */ -static void -dhcp_handle_offer(struct netif *netif, struct dhcp_msg *msg_in) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_offer(netif=%p) %c%c%"U16_F"\n", - (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); - /* obtain the server address */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) { - dhcp->request_timeout = 0; /* stop timer */ - - ip_addr_set_ip4_u32(&dhcp->server_ip_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID))); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): server 0x%08"X32_F"\n", - ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr)))); - /* remember offered address */ - ip4_addr_copy(dhcp->offered_ip_addr, msg_in->yiaddr); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): offer for 0x%08"X32_F"\n", - ip4_addr_get_u32(&dhcp->offered_ip_addr))); - - dhcp_select(netif); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("dhcp_handle_offer(netif=%p) did not get server ID!\n", (void *)netif)); - } -} - -/** - * Select a DHCP server offer out of all offers. - * - * Simply select the first offer received. - * - * @param netif the netif under DHCP control - * @return lwIP specific error (see error.h) - */ -static err_t -dhcp_select(struct netif *netif) -{ - struct dhcp *dhcp; - err_t result; - u16_t msecs; - u8_t i; - struct pbuf *p_out; - u16_t options_out_len; - - LWIP_ERROR("dhcp_select: netif != NULL", (netif != NULL), return ERR_ARG;); - dhcp = netif_dhcp_data(netif); - LWIP_ERROR("dhcp_select: dhcp != NULL", (dhcp != NULL), return ERR_VAL;); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_select(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); - dhcp_set_state(dhcp, DHCP_STATE_REQUESTING); - - /* create and initialize the DHCP message header */ - p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); - options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); - - /* MUST request the offered IP address */ - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_REQUESTED_IP, 4); - options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_SERVER_ID, 4); - options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr)))); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); - for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { - options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); - } - -#if LWIP_NETIF_HOSTNAME - options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); -#endif /* LWIP_NETIF_HOSTNAME */ - - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_REQUESTING, msg_out, DHCP_REQUEST, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - /* send broadcast to any DHCP server */ - result = udp_sendto_if_src(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif, IP4_ADDR_ANY); - pbuf_free(p_out); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_select: REQUESTING\n")); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("dhcp_select: could not allocate DHCP request\n")); - result = ERR_MEM; - } - if (dhcp->tries < 255) { - dhcp->tries++; - } - msecs = (u16_t)((dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000); - dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_select(): set request timeout %"U16_F" msecs\n", msecs)); - return result; -} - -/** - * The DHCP timer that checks for lease renewal/rebind timeouts. - * Must be called once a minute (see @ref DHCP_COARSE_TIMER_SECS). - */ -void -dhcp_coarse_tmr(void) -{ - struct netif *netif; - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_coarse_tmr()\n")); - /* iterate through all network interfaces */ - NETIF_FOREACH(netif) { - /* only act on DHCP configured interfaces */ - struct dhcp *dhcp = netif_dhcp_data(netif); - if ((dhcp != NULL) && (dhcp->state != DHCP_STATE_OFF)) { - /* compare lease time to expire timeout */ - if (dhcp->t0_timeout && (++dhcp->lease_used == dhcp->t0_timeout)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t0 timeout\n")); - /* this clients' lease time has expired */ - dhcp_release_and_stop(netif); - dhcp_start(netif); - /* timer is active (non zero), and triggers (zeroes) now? */ - } else if (dhcp->t2_rebind_time && (dhcp->t2_rebind_time-- == 1)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t2 timeout\n")); - /* this clients' rebind timeout triggered */ - dhcp_t2_timeout(netif); - /* timer is active (non zero), and triggers (zeroes) now */ - } else if (dhcp->t1_renew_time && (dhcp->t1_renew_time-- == 1)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t1 timeout\n")); - /* this clients' renewal timeout triggered */ - dhcp_t1_timeout(netif); - } - } - } -} - -/** - * DHCP transaction timeout handling (this function must be called every 500ms, - * see @ref DHCP_FINE_TIMER_MSECS). - * - * A DHCP server is expected to respond within a short period of time. - * This timer checks whether an outstanding DHCP request is timed out. - */ -void -dhcp_fine_tmr(void) -{ - struct netif *netif; - /* loop through netif's */ - NETIF_FOREACH(netif) { - struct dhcp *dhcp = netif_dhcp_data(netif); - /* only act on DHCP configured interfaces */ - if (dhcp != NULL) { - /* timer is active (non zero), and is about to trigger now */ - if (dhcp->request_timeout > 1) { - dhcp->request_timeout--; - } else if (dhcp->request_timeout == 1) { - dhcp->request_timeout--; - /* { dhcp->request_timeout == 0 } */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_fine_tmr(): request timeout\n")); - /* this client's request timeout triggered */ - dhcp_timeout(netif); - } - } - } -} - -/** - * A DHCP negotiation transaction, or ARP request, has timed out. - * - * The timer that was started with the DHCP or ARP request has - * timed out, indicating no response was received in time. - * - * @param netif the netif under DHCP control - */ -static void -dhcp_timeout(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout()\n")); - /* back-off period has passed, or server selection timed out */ - if ((dhcp->state == DHCP_STATE_BACKING_OFF) || (dhcp->state == DHCP_STATE_SELECTING)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout(): restarting discovery\n")); - dhcp_discover(netif); - /* receiving the requested lease timed out */ - } else if (dhcp->state == DHCP_STATE_REQUESTING) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, DHCP request timed out\n")); - if (dhcp->tries <= 5) { - dhcp_select(netif); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, releasing, restarting\n")); - dhcp_release_and_stop(netif); - dhcp_start(netif); - } -#if DHCP_DOES_ARP_CHECK - /* received no ARP reply for the offered address (which is good) */ - } else if (dhcp->state == DHCP_STATE_CHECKING) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): CHECKING, ARP request timed out\n")); - if (dhcp->tries <= 1) { - dhcp_check(netif); - /* no ARP replies on the offered address, - looks like the IP address is indeed free */ - } else { - /* bind the interface to the offered address */ - dhcp_bind(netif); - } -#endif /* DHCP_DOES_ARP_CHECK */ - } else if (dhcp->state == DHCP_STATE_REBOOTING) { - if (dhcp->tries < REBOOT_TRIES) { - dhcp_reboot(netif); - } else { - dhcp_discover(netif); - } - } -} - -/** - * The renewal period has timed out. - * - * @param netif the netif under DHCP control - */ -static void -dhcp_t1_timeout(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_t1_timeout()\n")); - if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) || - (dhcp->state == DHCP_STATE_RENEWING)) { - /* just retry to renew - note that the rebind timer (t2) will - * eventually time-out if renew tries fail. */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("dhcp_t1_timeout(): must renew\n")); - /* This slightly different to RFC2131: DHCPREQUEST will be sent from state - DHCP_STATE_RENEWING, not DHCP_STATE_BOUND */ - dhcp_renew(netif); - /* Calculate next timeout */ - if (((dhcp->t2_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) { - dhcp->t1_renew_time = (u16_t)((dhcp->t2_timeout - dhcp->lease_used) / 2); - } - } -} - -/** - * The rebind period has timed out. - * - * @param netif the netif under DHCP control - */ -static void -dhcp_t2_timeout(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t2_timeout()\n")); - if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) || - (dhcp->state == DHCP_STATE_RENEWING) || (dhcp->state == DHCP_STATE_REBINDING)) { - /* just retry to rebind */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - ("dhcp_t2_timeout(): must rebind\n")); - /* This slightly different to RFC2131: DHCPREQUEST will be sent from state - DHCP_STATE_REBINDING, not DHCP_STATE_BOUND */ - dhcp_rebind(netif); - /* Calculate next timeout */ - if (((dhcp->t0_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) { - dhcp->t2_rebind_time = (u16_t)((dhcp->t0_timeout - dhcp->lease_used) / 2); - } - } -} - -/** - * Handle a DHCP ACK packet - * - * @param netif the netif under DHCP control - */ -static void -dhcp_handle_ack(struct netif *netif, struct dhcp_msg *msg_in) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - -#if LWIP_DHCP_PROVIDE_DNS_SERVERS || LWIP_DHCP_GET_NTP_SRV - u8_t n; -#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS || LWIP_DHCP_GET_NTP_SRV */ -#if LWIP_DHCP_GET_NTP_SRV - ip4_addr_t ntp_server_addrs[LWIP_DHCP_MAX_NTP_SERVERS]; -#endif - - /* clear options we might not get from the ACK */ - ip4_addr_set_zero(&dhcp->offered_sn_mask); - ip4_addr_set_zero(&dhcp->offered_gw_addr); -#if LWIP_DHCP_BOOTP_FILE - ip4_addr_set_zero(&dhcp->offered_si_addr); -#endif /* LWIP_DHCP_BOOTP_FILE */ - - /* lease time given? */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_LEASE_TIME)) { - /* remember offered lease time */ - dhcp->offered_t0_lease = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_LEASE_TIME); - } - /* renewal period given? */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T1)) { - /* remember given renewal period */ - dhcp->offered_t1_renew = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T1); - } else { - /* calculate safe periods for renewal */ - dhcp->offered_t1_renew = dhcp->offered_t0_lease / 2; - } - - /* renewal period given? */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T2)) { - /* remember given rebind period */ - dhcp->offered_t2_rebind = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T2); - } else { - /* calculate safe periods for rebinding (offered_t0_lease * 0.875 -> 87.5%)*/ - dhcp->offered_t2_rebind = (dhcp->offered_t0_lease * 7U) / 8U; - } - - /* (y)our internet address */ - ip4_addr_copy(dhcp->offered_ip_addr, msg_in->yiaddr); - -#if LWIP_DHCP_BOOTP_FILE - /* copy boot server address, - boot file name copied in dhcp_parse_reply if not overloaded */ - ip4_addr_copy(dhcp->offered_si_addr, msg_in->siaddr); -#endif /* LWIP_DHCP_BOOTP_FILE */ - - /* subnet mask given? */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)) { - /* remember given subnet mask */ - ip4_addr_set_u32(&dhcp->offered_sn_mask, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SUBNET_MASK))); - dhcp->subnet_mask_given = 1; - } else { - dhcp->subnet_mask_given = 0; - } - - /* gateway router */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_ROUTER)) { - ip4_addr_set_u32(&dhcp->offered_gw_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_ROUTER))); - } - -#if LWIP_DHCP_GET_NTP_SRV - /* NTP servers */ - for (n = 0; (n < LWIP_DHCP_MAX_NTP_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n); n++) { - ip4_addr_set_u32(&ntp_server_addrs[n], lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n))); - } - dhcp_set_ntp_servers(n, ntp_server_addrs); -#endif /* LWIP_DHCP_GET_NTP_SRV */ - -#if LWIP_DHCP_PROVIDE_DNS_SERVERS - /* DNS servers */ - for (n = 0; (n < LWIP_DHCP_PROVIDE_DNS_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n); n++) { - ip_addr_t dns_addr; - ip_addr_set_ip4_u32_val(dns_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n))); - dns_setserver(n, &dns_addr); - } -#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ -} - -/** - * @ingroup dhcp4 - * Set a statically allocated struct dhcp to work with. - * Using this prevents dhcp_start to allocate it using mem_malloc. - * - * @param netif the netif for which to set the struct dhcp - * @param dhcp (uninitialised) dhcp struct allocated by the application - */ -void -dhcp_set_struct(struct netif *netif, struct dhcp *dhcp) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("dhcp != NULL", dhcp != NULL); - LWIP_ASSERT("netif already has a struct dhcp set", netif_dhcp_data(netif) == NULL); - - /* clear data structure */ - memset(dhcp, 0, sizeof(struct dhcp)); - /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */ - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp); -} - -/** - * @ingroup dhcp4 - * Removes a struct dhcp from a netif. - * - * ATTENTION: Only use this when not using dhcp_set_struct() to allocate the - * struct dhcp since the memory is passed back to the heap. - * - * @param netif the netif from which to remove the struct dhcp - */ -void dhcp_cleanup(struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("netif != NULL", netif != NULL); - - if (netif_dhcp_data(netif) != NULL) { - mem_free(netif_dhcp_data(netif)); - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, NULL); - } -} - -/** - * @ingroup dhcp4 - * Start DHCP negotiation for a network interface. - * - * If no DHCP client instance was attached to this interface, - * a new client is created first. If a DHCP client instance - * was already present, it restarts negotiation. - * - * @param netif The lwIP network interface - * @return lwIP error code - * - ERR_OK - No error - * - ERR_MEM - Out of memory - */ -err_t -dhcp_start(struct netif *netif) -{ - struct dhcp *dhcp; - err_t result; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG;); - LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;); - dhcp = netif_dhcp_data(netif); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); - - /* check MTU of the netif */ - if (netif->mtu < DHCP_MAX_MSG_LEN_MIN_REQUIRED) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): Cannot use this netif with DHCP: MTU is too small\n")); - return ERR_MEM; - } - - /* no DHCP client attached yet? */ - if (dhcp == NULL) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): mallocing new DHCP client\n")); - dhcp = (struct dhcp *)mem_malloc(sizeof(struct dhcp)); - if (dhcp == NULL) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): could not allocate dhcp\n")); - return ERR_MEM; - } - - /* store this dhcp client in the netif */ - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): allocated dhcp")); - /* already has DHCP client attached */ - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(): restarting DHCP configuration\n")); - - if (dhcp->pcb_allocated != 0) { - dhcp_dec_pcb_refcount(); /* free DHCP PCB if not needed any more */ - } - /* dhcp is cleared below, no need to reset flag*/ - } - - /* clear data structure */ - memset(dhcp, 0, sizeof(struct dhcp)); - /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */ - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): starting DHCP configuration\n")); - - if (dhcp_inc_pcb_refcount() != ERR_OK) { /* ensure DHCP PCB is allocated */ - return ERR_MEM; - } - dhcp->pcb_allocated = 1; - - if (!netif_is_link_up(netif)) { - /* set state INIT and wait for dhcp_network_changed() to call dhcp_discover() */ - dhcp_set_state(dhcp, DHCP_STATE_INIT); - return ERR_OK; - } - - /* (re)start the DHCP negotiation */ - result = dhcp_discover(netif); - if (result != ERR_OK) { - /* free resources allocated above */ - dhcp_release_and_stop(netif); - return ERR_MEM; - } - return result; -} - -/** - * @ingroup dhcp4 - * Inform a DHCP server of our manual configuration. - * - * This informs DHCP servers of our fixed IP address configuration - * by sending an INFORM message. It does not involve DHCP address - * configuration, it is just here to be nice to the network. - * - * @param netif The lwIP network interface - */ -void -dhcp_inform(struct netif *netif) -{ - struct dhcp dhcp; - struct pbuf *p_out; - u16_t options_out_len; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ERROR("netif != NULL", (netif != NULL), return;); - - if (dhcp_inc_pcb_refcount() != ERR_OK) { /* ensure DHCP PCB is allocated */ - return; - } - - memset(&dhcp, 0, sizeof(struct dhcp)); - dhcp_set_state(&dhcp, DHCP_STATE_INFORMING); - - /* create and initialize the DHCP message header */ - p_out = dhcp_create_msg(netif, &dhcp, DHCP_INFORM, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); - options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); - - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, &dhcp, DHCP_STATE_INFORMING, msg_out, DHCP_INFORM, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_inform: INFORMING\n")); - - udp_sendto_if(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif); - - pbuf_free(p_out); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_inform: could not allocate DHCP request\n")); - } - - dhcp_dec_pcb_refcount(); /* delete DHCP PCB if not needed any more */ -} - -/** Handle a possible change in the network configuration. - * - * This enters the REBOOTING state to verify that the currently bound - * address is still valid. - */ -void -dhcp_network_changed(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - - if (!dhcp) { - return; - } - switch (dhcp->state) { - case DHCP_STATE_REBINDING: - case DHCP_STATE_RENEWING: - case DHCP_STATE_BOUND: - case DHCP_STATE_REBOOTING: - dhcp->tries = 0; - dhcp_reboot(netif); - break; - case DHCP_STATE_OFF: - /* stay off */ - break; - default: - LWIP_ASSERT("invalid dhcp->state", dhcp->state <= DHCP_STATE_BACKING_OFF); - /* INIT/REQUESTING/CHECKING/BACKING_OFF restart with new 'rid' because the - state changes, SELECTING: continue with current 'rid' as we stay in the - same state */ -#if LWIP_DHCP_AUTOIP_COOP - if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) { - autoip_stop(netif); - dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF; - } -#endif /* LWIP_DHCP_AUTOIP_COOP */ - /* ensure we start with short timeouts, even if already discovering */ - dhcp->tries = 0; - dhcp_discover(netif); - break; - } -} - -#if DHCP_DOES_ARP_CHECK -/** - * Match an ARP reply with the offered IP address: - * check whether the offered IP address is not in use using ARP - * - * @param netif the network interface on which the reply was received - * @param addr The IP address we received a reply from - */ -void -dhcp_arp_reply(struct netif *netif, const ip4_addr_t *addr) -{ - struct dhcp *dhcp; - - LWIP_ERROR("netif != NULL", (netif != NULL), return;); - dhcp = netif_dhcp_data(netif); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_arp_reply()\n")); - /* is a DHCP client doing an ARP check? */ - if ((dhcp != NULL) && (dhcp->state == DHCP_STATE_CHECKING)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_arp_reply(): CHECKING, arp reply for 0x%08"X32_F"\n", - ip4_addr_get_u32(addr))); - /* did a host respond with the address we - were offered by the DHCP server? */ - if (ip4_addr_cmp(addr, &dhcp->offered_ip_addr)) { - /* we will not accept the offered address */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, - ("dhcp_arp_reply(): arp reply matched with offered address, declining\n")); - dhcp_decline(netif); - } - } -} - -/** - * Decline an offered lease. - * - * Tell the DHCP server we do not accept the offered address. - * One reason to decline the lease is when we find out the address - * is already in use by another host (through ARP). - * - * @param netif the netif under DHCP control - */ -static err_t -dhcp_decline(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - err_t result; - u16_t msecs; - struct pbuf *p_out; - u16_t options_out_len; - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline()\n")); - dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF); - /* create and initialize the DHCP message header */ - p_out = dhcp_create_msg(netif, dhcp, DHCP_DECLINE, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_REQUESTED_IP, 4); - options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); - - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_BACKING_OFF, msg_out, DHCP_DECLINE, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - /* per section 4.4.4, broadcast DECLINE messages */ - result = udp_sendto_if_src(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif, IP4_ADDR_ANY); - pbuf_free(p_out); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_decline: BACKING OFF\n")); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("dhcp_decline: could not allocate DHCP request\n")); - result = ERR_MEM; - } - if (dhcp->tries < 255) { - dhcp->tries++; - } - msecs = 10 * 1000; - dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline(): set request timeout %"U16_F" msecs\n", msecs)); - return result; -} -#endif /* DHCP_DOES_ARP_CHECK */ - - -/** - * Start the DHCP process, discover a DHCP server. - * - * @param netif the netif under DHCP control - */ -static err_t -dhcp_discover(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - err_t result = ERR_OK; - u16_t msecs; - u8_t i; - struct pbuf *p_out; - u16_t options_out_len; - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover()\n")); - - ip4_addr_set_any(&dhcp->offered_ip_addr); - dhcp_set_state(dhcp, DHCP_STATE_SELECTING); - /* create and initialize the DHCP message header */ - p_out = dhcp_create_msg(netif, dhcp, DHCP_DISCOVER, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: making request\n")); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); - options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); - for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { - options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); - } - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_SELECTING, msg_out, DHCP_DISCOVER, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: sendto(DISCOVER, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER)\n")); - udp_sendto_if_src(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif, IP4_ADDR_ANY); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: deleting()ing\n")); - pbuf_free(p_out); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_discover: SELECTING\n")); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_discover: could not allocate DHCP request\n")); - } - if (dhcp->tries < 255) { - dhcp->tries++; - } -#if LWIP_DHCP_AUTOIP_COOP - if (dhcp->tries >= LWIP_DHCP_AUTOIP_COOP_TRIES && dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_OFF) { - dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_ON; - autoip_start(netif); - } -#endif /* LWIP_DHCP_AUTOIP_COOP */ - msecs = (u16_t)((dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000); - dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_discover(): set request timeout %"U16_F" msecs\n", msecs)); - return result; -} - - -/** - * Bind the interface to the offered IP address. - * - * @param netif network interface to bind to the offered address - */ -static void -dhcp_bind(struct netif *netif) -{ - u32_t timeout; - struct dhcp *dhcp; - ip4_addr_t sn_mask, gw_addr; - LWIP_ERROR("dhcp_bind: netif != NULL", (netif != NULL), return;); - dhcp = netif_dhcp_data(netif); - LWIP_ERROR("dhcp_bind: dhcp != NULL", (dhcp != NULL), return;); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); - - /* reset time used of lease */ - dhcp->lease_used = 0; - - if (dhcp->offered_t0_lease != 0xffffffffUL) { - /* set renewal period timer */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t0 renewal timer %"U32_F" secs\n", dhcp->offered_t0_lease)); - timeout = (dhcp->offered_t0_lease + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; - if (timeout > 0xffff) { - timeout = 0xffff; - } - dhcp->t0_timeout = (u16_t)timeout; - if (dhcp->t0_timeout == 0) { - dhcp->t0_timeout = 1; - } - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t0_lease * 1000)); - } - - /* temporary DHCP lease? */ - if (dhcp->offered_t1_renew != 0xffffffffUL) { - /* set renewal period timer */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t1 renewal timer %"U32_F" secs\n", dhcp->offered_t1_renew)); - timeout = (dhcp->offered_t1_renew + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; - if (timeout > 0xffff) { - timeout = 0xffff; - } - dhcp->t1_timeout = (u16_t)timeout; - if (dhcp->t1_timeout == 0) { - dhcp->t1_timeout = 1; - } - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t1_renew * 1000)); - dhcp->t1_renew_time = dhcp->t1_timeout; - } - /* set renewal period timer */ - if (dhcp->offered_t2_rebind != 0xffffffffUL) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t2 rebind timer %"U32_F" secs\n", dhcp->offered_t2_rebind)); - timeout = (dhcp->offered_t2_rebind + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; - if (timeout > 0xffff) { - timeout = 0xffff; - } - dhcp->t2_timeout = (u16_t)timeout; - if (dhcp->t2_timeout == 0) { - dhcp->t2_timeout = 1; - } - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t2_rebind * 1000)); - dhcp->t2_rebind_time = dhcp->t2_timeout; - } - - /* If we have sub 1 minute lease, t2 and t1 will kick in at the same time. */ - if ((dhcp->t1_timeout >= dhcp->t2_timeout) && (dhcp->t2_timeout > 0)) { - dhcp->t1_timeout = 0; - } - - if (dhcp->subnet_mask_given) { - /* copy offered network mask */ - ip4_addr_copy(sn_mask, dhcp->offered_sn_mask); - } else { - /* subnet mask not given, choose a safe subnet mask given the network class */ - u8_t first_octet = ip4_addr1(&dhcp->offered_ip_addr); - if (first_octet <= 127) { - ip4_addr_set_u32(&sn_mask, PP_HTONL(0xff000000UL)); - } else if (first_octet >= 192) { - ip4_addr_set_u32(&sn_mask, PP_HTONL(0xffffff00UL)); - } else { - ip4_addr_set_u32(&sn_mask, PP_HTONL(0xffff0000UL)); - } - } - - ip4_addr_copy(gw_addr, dhcp->offered_gw_addr); - /* gateway address not given? */ - if (ip4_addr_isany_val(gw_addr)) { - /* copy network address */ - ip4_addr_get_network(&gw_addr, &dhcp->offered_ip_addr, &sn_mask); - /* use first host address on network as gateway */ - ip4_addr_set_u32(&gw_addr, ip4_addr_get_u32(&gw_addr) | PP_HTONL(0x00000001UL)); - } - -#if LWIP_DHCP_AUTOIP_COOP - if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) { - autoip_stop(netif); - dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF; - } -#endif /* LWIP_DHCP_AUTOIP_COOP */ - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_bind(): IP: 0x%08"X32_F" SN: 0x%08"X32_F" GW: 0x%08"X32_F"\n", - ip4_addr_get_u32(&dhcp->offered_ip_addr), ip4_addr_get_u32(&sn_mask), ip4_addr_get_u32(&gw_addr))); - /* netif is now bound to DHCP leased address - set this before assigning the address - to ensure the callback can use dhcp_supplied_address() */ - dhcp_set_state(dhcp, DHCP_STATE_BOUND); - - netif_set_addr(netif, &dhcp->offered_ip_addr, &sn_mask, &gw_addr); - /* interface is used by routing now that an address is set */ -} - -/** - * @ingroup dhcp4 - * Renew an existing DHCP lease at the involved DHCP server. - * - * @param netif network interface which must renew its lease - */ -err_t -dhcp_renew(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - err_t result; - u16_t msecs; - u8_t i; - struct pbuf *p_out; - u16_t options_out_len; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_renew()\n")); - dhcp_set_state(dhcp, DHCP_STATE_RENEWING); - - /* create and initialize the DHCP message header */ - p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); - options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); - for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { - options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); - } - -#if LWIP_NETIF_HOSTNAME - options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); -#endif /* LWIP_NETIF_HOSTNAME */ - - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_RENEWING, msg_out, DHCP_REQUEST, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - result = udp_sendto_if(dhcp_pcb, p_out, &dhcp->server_ip_addr, LWIP_IANA_PORT_DHCP_SERVER, netif); - pbuf_free(p_out); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_renew: RENEWING\n")); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_renew: could not allocate DHCP request\n")); - result = ERR_MEM; - } - if (dhcp->tries < 255) { - dhcp->tries++; - } - /* back-off on retries, but to a maximum of 20 seconds */ - msecs = (u16_t)(dhcp->tries < 10 ? dhcp->tries * 2000 : 20 * 1000); - dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_renew(): set request timeout %"U16_F" msecs\n", msecs)); - return result; -} - -/** - * Rebind with a DHCP server for an existing DHCP lease. - * - * @param netif network interface which must rebind with a DHCP server - */ -static err_t -dhcp_rebind(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - err_t result; - u16_t msecs; - u8_t i; - struct pbuf *p_out; - u16_t options_out_len; - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind()\n")); - dhcp_set_state(dhcp, DHCP_STATE_REBINDING); - - /* create and initialize the DHCP message header */ - p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); - options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); - for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { - options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); - } - -#if LWIP_NETIF_HOSTNAME - options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); -#endif /* LWIP_NETIF_HOSTNAME */ - - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_REBINDING, msg_out, DHCP_DISCOVER, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - /* broadcast to server */ - result = udp_sendto_if(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif); - pbuf_free(p_out); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind: REBINDING\n")); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_rebind: could not allocate DHCP request\n")); - result = ERR_MEM; - } - if (dhcp->tries < 255) { - dhcp->tries++; - } - msecs = (u16_t)(dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000); - dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind(): set request timeout %"U16_F" msecs\n", msecs)); - return result; -} - -/** - * Enter REBOOTING state to verify an existing lease - * - * @param netif network interface which must reboot - */ -static err_t -dhcp_reboot(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - err_t result; - u16_t msecs; - u8_t i; - struct pbuf *p_out; - u16_t options_out_len; - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_reboot()\n")); - dhcp_set_state(dhcp, DHCP_STATE_REBOOTING); - - /* create and initialize the DHCP message header */ - p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); - options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN_MIN_REQUIRED); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_REQUESTED_IP, 4); - options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); - - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); - for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { - options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); - } - -#if LWIP_NETIF_HOSTNAME - options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); -#endif /* LWIP_NETIF_HOSTNAME */ - - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_REBOOTING, msg_out, DHCP_REQUEST, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - /* broadcast to server */ - result = udp_sendto_if(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif); - pbuf_free(p_out); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_reboot: REBOOTING\n")); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_reboot: could not allocate DHCP request\n")); - result = ERR_MEM; - } - if (dhcp->tries < 255) { - dhcp->tries++; - } - msecs = (u16_t)(dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000); - dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_reboot(): set request timeout %"U16_F" msecs\n", msecs)); - return result; -} - -/** - * @ingroup dhcp4 - * Release a DHCP lease and stop DHCP statemachine (and AUTOIP if LWIP_DHCP_AUTOIP_COOP). - * - * @param netif network interface - */ -void -dhcp_release_and_stop(struct netif *netif) -{ - struct dhcp *dhcp = netif_dhcp_data(netif); - ip_addr_t server_ip_addr; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_release_and_stop()\n")); - if (dhcp == NULL) { - return; - } - - /* already off? -> nothing to do */ - if (dhcp->state == DHCP_STATE_OFF) { - return; - } - - ip_addr_copy(server_ip_addr, dhcp->server_ip_addr); - - /* clean old DHCP offer */ - ip_addr_set_zero_ip4(&dhcp->server_ip_addr); - ip4_addr_set_zero(&dhcp->offered_ip_addr); - ip4_addr_set_zero(&dhcp->offered_sn_mask); - ip4_addr_set_zero(&dhcp->offered_gw_addr); -#if LWIP_DHCP_BOOTP_FILE - ip4_addr_set_zero(&dhcp->offered_si_addr); -#endif /* LWIP_DHCP_BOOTP_FILE */ - dhcp->offered_t0_lease = dhcp->offered_t1_renew = dhcp->offered_t2_rebind = 0; - dhcp->t1_renew_time = dhcp->t2_rebind_time = dhcp->lease_used = dhcp->t0_timeout = 0; - - /* send release message when current IP was assigned via DHCP */ - if (dhcp_supplied_address(netif)) { - /* create and initialize the DHCP message header */ - struct pbuf *p_out; - u16_t options_out_len; - p_out = dhcp_create_msg(netif, dhcp, DHCP_RELEASE, &options_out_len); - if (p_out != NULL) { - struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; - options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_SERVER_ID, 4); - options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&server_ip_addr)))); - - LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, dhcp->state, msg_out, DHCP_RELEASE, &options_out_len); - dhcp_option_trailer(options_out_len, msg_out->options, p_out); - - udp_sendto_if(dhcp_pcb, p_out, &server_ip_addr, LWIP_IANA_PORT_DHCP_SERVER, netif); - pbuf_free(p_out); - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release: RELEASED, DHCP_STATE_OFF\n")); - } else { - /* sending release failed, but that's not a problem since the correct behaviour of dhcp does not rely on release */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_release: could not allocate DHCP request\n")); - } - } - - /* remove IP address from interface (prevents routing from selecting this interface) */ - netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); - -#if LWIP_DHCP_AUTOIP_COOP - if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) { - autoip_stop(netif); - dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF; - } -#endif /* LWIP_DHCP_AUTOIP_COOP */ - - dhcp_set_state(dhcp, DHCP_STATE_OFF); - - if (dhcp->pcb_allocated != 0) { - dhcp_dec_pcb_refcount(); /* free DHCP PCB if not needed any more */ - dhcp->pcb_allocated = 0; - } -} - -/** - * @ingroup dhcp4 - * This function calls dhcp_release_and_stop() internally. - * @deprecated Use dhcp_release_and_stop() instead. - */ -err_t -dhcp_release(struct netif *netif) -{ - dhcp_release_and_stop(netif); - return ERR_OK; -} - -/** - * @ingroup dhcp4 - * This function calls dhcp_release_and_stop() internally. - * @deprecated Use dhcp_release_and_stop() instead. - */ -void -dhcp_stop(struct netif *netif) -{ - dhcp_release_and_stop(netif); -} - -/* - * Set the DHCP state of a DHCP client. - * - * If the state changed, reset the number of tries. - */ -static void -dhcp_set_state(struct dhcp *dhcp, u8_t new_state) -{ - if (new_state != dhcp->state) { - dhcp->state = new_state; - dhcp->tries = 0; - dhcp->request_timeout = 0; - } -} - -/* - * Concatenate an option type and length field to the outgoing - * DHCP message. - * - */ -static u16_t -dhcp_option(u16_t options_out_len, u8_t *options, u8_t option_type, u8_t option_len) -{ - LWIP_ASSERT("dhcp_option: options_out_len + 2 + option_len <= DHCP_OPTIONS_LEN", options_out_len + 2U + option_len <= DHCP_OPTIONS_LEN); - options[options_out_len++] = option_type; - options[options_out_len++] = option_len; - return options_out_len; -} -/* - * Concatenate a single byte to the outgoing DHCP message. - * - */ -static u16_t -dhcp_option_byte(u16_t options_out_len, u8_t *options, u8_t value) -{ - LWIP_ASSERT("dhcp_option_byte: options_out_len < DHCP_OPTIONS_LEN", options_out_len < DHCP_OPTIONS_LEN); - options[options_out_len++] = value; - return options_out_len; -} - -static u16_t -dhcp_option_short(u16_t options_out_len, u8_t *options, u16_t value) -{ - LWIP_ASSERT("dhcp_option_short: options_out_len + 2 <= DHCP_OPTIONS_LEN", options_out_len + 2U <= DHCP_OPTIONS_LEN); - options[options_out_len++] = (u8_t)((value & 0xff00U) >> 8); - options[options_out_len++] = (u8_t) (value & 0x00ffU); - return options_out_len; -} - -static u16_t -dhcp_option_long(u16_t options_out_len, u8_t *options, u32_t value) -{ - LWIP_ASSERT("dhcp_option_long: options_out_len + 4 <= DHCP_OPTIONS_LEN", options_out_len + 4U <= DHCP_OPTIONS_LEN); - options[options_out_len++] = (u8_t)((value & 0xff000000UL) >> 24); - options[options_out_len++] = (u8_t)((value & 0x00ff0000UL) >> 16); - options[options_out_len++] = (u8_t)((value & 0x0000ff00UL) >> 8); - options[options_out_len++] = (u8_t)((value & 0x000000ffUL)); - return options_out_len; -} - -#if LWIP_NETIF_HOSTNAME -static u16_t -dhcp_option_hostname(u16_t options_out_len, u8_t *options, struct netif *netif) -{ - if (netif->hostname != NULL) { - size_t namelen = strlen(netif->hostname); - if (namelen > 0) { - size_t len; - const char *p = netif->hostname; - /* Shrink len to available bytes (need 2 bytes for OPTION_HOSTNAME - and 1 byte for trailer) */ - size_t available = DHCP_OPTIONS_LEN - options_out_len - 3; - LWIP_ASSERT("DHCP: hostname is too long!", namelen <= available); - len = LWIP_MIN(namelen, available); - LWIP_ASSERT("DHCP: hostname is too long!", len <= 0xFF); - options_out_len = dhcp_option(options_out_len, options, DHCP_OPTION_HOSTNAME, (u8_t)len); - while (len--) { - options_out_len = dhcp_option_byte(options_out_len, options, *p++); - } - } - } - return options_out_len; -} -#endif /* LWIP_NETIF_HOSTNAME */ - -/** - * Extract the DHCP message and the DHCP options. - * - * Extract the DHCP message and the DHCP options, each into a contiguous - * piece of memory. As a DHCP message is variable sized by its options, - * and also allows overriding some fields for options, the easy approach - * is to first unfold the options into a contiguous piece of memory, and - * use that further on. - * - */ -static err_t -dhcp_parse_reply(struct pbuf *p, struct dhcp *dhcp) -{ - u8_t *options; - u16_t offset; - u16_t offset_max; - u16_t options_idx; - u16_t options_idx_max; - struct pbuf *q; - int parse_file_as_options = 0; - int parse_sname_as_options = 0; - struct dhcp_msg *msg_in; -#if LWIP_DHCP_BOOTP_FILE - int file_overloaded = 0; -#endif - - LWIP_UNUSED_ARG(dhcp); - - /* clear received options */ - dhcp_clear_all_options(dhcp); - /* check that beginning of dhcp_msg (up to and including chaddr) is in first pbuf */ - if (p->len < DHCP_SNAME_OFS) { - return ERR_BUF; - } - msg_in = (struct dhcp_msg *)p->payload; -#if LWIP_DHCP_BOOTP_FILE - /* clear boot file name */ - dhcp->boot_file_name[0] = 0; -#endif /* LWIP_DHCP_BOOTP_FILE */ - - /* parse options */ - - /* start with options field */ - options_idx = DHCP_OPTIONS_OFS; - /* parse options to the end of the received packet */ - options_idx_max = p->tot_len; -again: - q = p; - while ((q != NULL) && (options_idx >= q->len)) { - options_idx = (u16_t)(options_idx - q->len); - options_idx_max = (u16_t)(options_idx_max - q->len); - q = q->next; - } - if (q == NULL) { - return ERR_BUF; - } - offset = options_idx; - offset_max = options_idx_max; - options = (u8_t *)q->payload; - /* at least 1 byte to read and no end marker, then at least 3 bytes to read? */ - while ((q != NULL) && (offset < offset_max) && (options[offset] != DHCP_OPTION_END)) { - u8_t op = options[offset]; - u8_t len; - u8_t decode_len = 0; - int decode_idx = -1; - u16_t val_offset = (u16_t)(offset + 2); - if (val_offset < offset) { - /* overflow */ - return ERR_BUF; - } - /* len byte might be in the next pbuf */ - if ((offset + 1) < q->len) { - len = options[offset + 1]; - } else { - len = (q->next != NULL ? ((u8_t *)q->next->payload)[0] : 0); - } - /* LWIP_DEBUGF(DHCP_DEBUG, ("msg_offset=%"U16_F", q->len=%"U16_F, msg_offset, q->len)); */ - decode_len = len; - switch (op) { - /* case(DHCP_OPTION_END): handled above */ - case (DHCP_OPTION_PAD): - /* special option: no len encoded */ - decode_len = len = 0; - /* will be increased below */ - break; - case (DHCP_OPTION_SUBNET_MASK): - LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_SUBNET_MASK; - break; - case (DHCP_OPTION_ROUTER): - decode_len = 4; /* only copy the first given router */ - LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_ROUTER; - break; -#if LWIP_DHCP_PROVIDE_DNS_SERVERS - case (DHCP_OPTION_DNS_SERVER): - /* special case: there might be more than one server */ - LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;); - /* limit number of DNS servers */ - decode_len = LWIP_MIN(len, 4 * DNS_MAX_SERVERS); - LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_DNS_SERVER; - break; -#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ - case (DHCP_OPTION_LEASE_TIME): - LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_LEASE_TIME; - break; -#if LWIP_DHCP_GET_NTP_SRV - case (DHCP_OPTION_NTP): - /* special case: there might be more than one server */ - LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;); - /* limit number of NTP servers */ - decode_len = LWIP_MIN(len, 4 * LWIP_DHCP_MAX_NTP_SERVERS); - LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_NTP_SERVER; - break; -#endif /* LWIP_DHCP_GET_NTP_SRV*/ - case (DHCP_OPTION_OVERLOAD): - LWIP_ERROR("len == 1", len == 1, return ERR_VAL;); - /* decode overload only in options, not in file/sname: invalid packet */ - LWIP_ERROR("overload in file/sname", options_idx == DHCP_OPTIONS_OFS, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_OVERLOAD; - break; - case (DHCP_OPTION_MESSAGE_TYPE): - LWIP_ERROR("len == 1", len == 1, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_MSG_TYPE; - break; - case (DHCP_OPTION_SERVER_ID): - LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_SERVER_ID; - break; - case (DHCP_OPTION_T1): - LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_T1; - break; - case (DHCP_OPTION_T2): - LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); - decode_idx = DHCP_OPTION_IDX_T2; - break; - default: - decode_len = 0; - LWIP_DEBUGF(DHCP_DEBUG, ("skipping option %"U16_F" in options\n", (u16_t)op)); - LWIP_HOOK_DHCP_PARSE_OPTION(ip_current_netif(), dhcp, dhcp->state, msg_in, - dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) ? (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) : 0, - op, len, q, val_offset); - break; - } - if (op == DHCP_OPTION_PAD) { - offset++; - } else { - if (offset + len + 2 > 0xFFFF) { - /* overflow */ - return ERR_BUF; - } - offset = (u16_t)(offset + len + 2); - if (decode_len > 0) { - u32_t value = 0; - u16_t copy_len; -decode_next: - LWIP_ASSERT("check decode_idx", decode_idx >= 0 && decode_idx < DHCP_OPTION_IDX_MAX); - if (!dhcp_option_given(dhcp, decode_idx)) { - copy_len = LWIP_MIN(decode_len, 4); - if (pbuf_copy_partial(q, &value, copy_len, val_offset) != copy_len) { - return ERR_BUF; - } - if (decode_len > 4) { - /* decode more than one u32_t */ - u16_t next_val_offset; - LWIP_ERROR("decode_len %% 4 == 0", decode_len % 4 == 0, return ERR_VAL;); - dhcp_got_option(dhcp, decode_idx); - dhcp_set_option_value(dhcp, decode_idx, lwip_htonl(value)); - decode_len = (u8_t)(decode_len - 4); - next_val_offset = (u16_t)(val_offset + 4); - if (next_val_offset < val_offset) { - /* overflow */ - return ERR_BUF; - } - val_offset = next_val_offset; - decode_idx++; - goto decode_next; - } else if (decode_len == 4) { - value = lwip_ntohl(value); - } else { - LWIP_ERROR("invalid decode_len", decode_len == 1, return ERR_VAL;); - value = ((u8_t *)&value)[0]; - } - dhcp_got_option(dhcp, decode_idx); - dhcp_set_option_value(dhcp, decode_idx, value); - } - } - } - if (offset >= q->len) { - offset = (u16_t)(offset - q->len); - offset_max = (u16_t)(offset_max - q->len); - if (offset < offset_max) { - q = q->next; - LWIP_ERROR("next pbuf was null", q != NULL, return ERR_VAL;); - options = (u8_t *)q->payload; - } else { - /* We've run out of bytes, probably no end marker. Don't proceed. */ - return ERR_BUF; - } - } - } - /* is this an overloaded message? */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_OVERLOAD)) { - u32_t overload = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_OVERLOAD); - dhcp_clear_option(dhcp, DHCP_OPTION_IDX_OVERLOAD); - if (overload == DHCP_OVERLOAD_FILE) { - parse_file_as_options = 1; - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("overloaded file field\n")); - } else if (overload == DHCP_OVERLOAD_SNAME) { - parse_sname_as_options = 1; - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("overloaded sname field\n")); - } else if (overload == DHCP_OVERLOAD_SNAME_FILE) { - parse_sname_as_options = 1; - parse_file_as_options = 1; - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("overloaded sname and file field\n")); - } else { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("invalid overload option: %d\n", (int)overload)); - } - } - if (parse_file_as_options) { - /* if both are overloaded, parse file first and then sname (RFC 2131 ch. 4.1) */ - parse_file_as_options = 0; - options_idx = DHCP_FILE_OFS; - options_idx_max = DHCP_FILE_OFS + DHCP_FILE_LEN; -#if LWIP_DHCP_BOOTP_FILE - file_overloaded = 1; -#endif - goto again; - } else if (parse_sname_as_options) { - parse_sname_as_options = 0; - options_idx = DHCP_SNAME_OFS; - options_idx_max = DHCP_SNAME_OFS + DHCP_SNAME_LEN; - goto again; - } -#if LWIP_DHCP_BOOTP_FILE - if (!file_overloaded) { - /* only do this for ACK messages */ - if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) && - (dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) == DHCP_ACK)) - /* copy bootp file name, don't care for sname (server hostname) */ - if (pbuf_copy_partial(p, dhcp->boot_file_name, DHCP_FILE_LEN-1, DHCP_FILE_OFS) != (DHCP_FILE_LEN-1)) { - return ERR_BUF; - } - /* make sure the string is really NULL-terminated */ - dhcp->boot_file_name[DHCP_FILE_LEN-1] = 0; - } -#endif /* LWIP_DHCP_BOOTP_FILE */ - return ERR_OK; -} - -/** - * If an incoming DHCP message is in response to us, then trigger the state machine - */ -static void -dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - struct netif *netif = ip_current_input_netif(); - struct dhcp *dhcp = netif_dhcp_data(netif); - struct dhcp_msg *reply_msg = (struct dhcp_msg *)p->payload; - u8_t msg_type; - u8_t i; - struct dhcp_msg *msg_in; - - LWIP_UNUSED_ARG(arg); - - /* Caught DHCP message from netif that does not have DHCP enabled? -> not interested */ - if ((dhcp == NULL) || (dhcp->pcb_allocated == 0)) { - goto free_pbuf_and_return; - } - - LWIP_ASSERT("invalid server address type", IP_IS_V4(addr)); - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_recv(pbuf = %p) from DHCP server %"U16_F".%"U16_F".%"U16_F".%"U16_F" port %"U16_F"\n", (void *)p, - ip4_addr1_16(ip_2_ip4(addr)), ip4_addr2_16(ip_2_ip4(addr)), ip4_addr3_16(ip_2_ip4(addr)), ip4_addr4_16(ip_2_ip4(addr)), port)); - 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); - - if (p->len < DHCP_MIN_REPLY_LEN) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("DHCP reply message or pbuf too short\n")); - goto free_pbuf_and_return; - } - - if (reply_msg->op != DHCP_BOOTREPLY) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("not a DHCP reply message, but type %"U16_F"\n", (u16_t)reply_msg->op)); - goto free_pbuf_and_return; - } - /* iterate through hardware address and match against DHCP message */ - for (i = 0; i < netif->hwaddr_len && i < LWIP_MIN(DHCP_CHADDR_LEN, NETIF_MAX_HWADDR_LEN); i++) { - if (netif->hwaddr[i] != reply_msg->chaddr[i]) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, - ("netif->hwaddr[%"U16_F"]==%02"X16_F" != reply_msg->chaddr[%"U16_F"]==%02"X16_F"\n", - (u16_t)i, (u16_t)netif->hwaddr[i], (u16_t)i, (u16_t)reply_msg->chaddr[i])); - goto free_pbuf_and_return; - } - } - /* match transaction ID against what we expected */ - if (lwip_ntohl(reply_msg->xid) != dhcp->xid) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, - ("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n", lwip_ntohl(reply_msg->xid), dhcp->xid)); - goto free_pbuf_and_return; - } - /* option fields could be unfold? */ - if (dhcp_parse_reply(p, dhcp) != ERR_OK) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("problem unfolding DHCP message - too short on memory?\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 (!dhcp_option_given(dhcp, 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; - } - - msg_in = (struct dhcp_msg *)p->payload; - /* read DHCP message type */ - msg_type = (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE); - /* message type is DHCP ACK? */ - if (msg_type == DHCP_ACK) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_ACK received\n")); - /* in requesting state? */ - if (dhcp->state == DHCP_STATE_REQUESTING) { - dhcp_handle_ack(netif, msg_in); -#if DHCP_DOES_ARP_CHECK - if ((netif->flags & NETIF_FLAG_ETHARP) != 0) { - /* check if the acknowledged lease address is already in use */ - dhcp_check(netif); - } else { - /* bind interface to the acknowledged lease address */ - dhcp_bind(netif); - } -#else - /* bind interface to the acknowledged lease address */ - dhcp_bind(netif); -#endif - } - /* already bound to the given lease address? */ - else if ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REBINDING) || - (dhcp->state == DHCP_STATE_RENEWING)) { - dhcp_handle_ack(netif, msg_in); - dhcp_bind(netif); - } - } - /* received a DHCP_NAK in appropriate state? */ - else if ((msg_type == DHCP_NAK) && - ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REQUESTING) || - (dhcp->state == DHCP_STATE_REBINDING) || (dhcp->state == DHCP_STATE_RENEWING ))) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_NAK received\n")); - dhcp_handle_nak(netif); - } - /* received a DHCP_OFFER in DHCP_STATE_SELECTING state? */ - else if ((msg_type == DHCP_OFFER) && (dhcp->state == DHCP_STATE_SELECTING)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_OFFER received in DHCP_STATE_SELECTING state\n")); - /* remember offered lease */ - dhcp_handle_offer(netif, msg_in); - } - -free_pbuf_and_return: - pbuf_free(p); -} - -/** - * Create a DHCP request, fill in common headers - * - * @param netif the netif under DHCP control - * @param dhcp dhcp control struct - * @param message_type message type of the request - */ -static struct pbuf * -dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type, u16_t *options_out_len) -{ - u16_t i; - struct pbuf *p_out; - struct dhcp_msg *msg_out; - u16_t options_out_len_loc; - -#ifndef DHCP_GLOBAL_XID - /** default global transaction identifier starting value (easy to match - * with a packet analyser). We simply increment for each new request. - * Predefine DHCP_GLOBAL_XID to a better value or a function call to generate one - * at runtime, any supporting function prototypes can be defined in DHCP_GLOBAL_XID_HEADER */ -#if DHCP_CREATE_RAND_XID && defined(LWIP_RAND) - static u32_t xid; -#else /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ - static u32_t xid = 0xABCD0000; -#endif /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ -#else - if (!xid_initialised) { - xid = DHCP_GLOBAL_XID; - xid_initialised = !xid_initialised; - } -#endif - LWIP_ERROR("dhcp_create_msg: netif != NULL", (netif != NULL), return NULL;); - LWIP_ERROR("dhcp_create_msg: dhcp != NULL", (dhcp != NULL), return NULL;); - p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM); - if (p_out == NULL) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("dhcp_create_msg(): could not allocate pbuf\n")); - return NULL; - } - LWIP_ASSERT("dhcp_create_msg: check that first pbuf can hold struct dhcp_msg", - (p_out->len >= sizeof(struct dhcp_msg))); - - /* DHCP_REQUEST should reuse 'xid' from DHCPOFFER */ - if ((message_type != DHCP_REQUEST) || (dhcp->state == DHCP_STATE_REBOOTING)) { - /* reuse transaction identifier in retransmissions */ - if (dhcp->tries == 0) { -#if DHCP_CREATE_RAND_XID && defined(LWIP_RAND) - xid = LWIP_RAND(); -#else /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ - xid++; -#endif /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ - } - dhcp->xid = xid; - } - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, - ("transaction id xid(%"X32_F")\n", xid)); - - msg_out = (struct dhcp_msg *)p_out->payload; - memset(msg_out, 0, sizeof(struct dhcp_msg)); - - msg_out->op = DHCP_BOOTREQUEST; - /* @todo: make link layer independent */ - msg_out->htype = LWIP_IANA_HWTYPE_ETHERNET; - msg_out->hlen = netif->hwaddr_len; - msg_out->xid = lwip_htonl(dhcp->xid); - /* we don't need the broadcast flag since we can receive unicast traffic - before being fully configured! */ - /* set ciaddr to netif->ip_addr based on message_type and state */ - if ((message_type == DHCP_INFORM) || (message_type == DHCP_DECLINE) || (message_type == DHCP_RELEASE) || - ((message_type == DHCP_REQUEST) && /* DHCP_STATE_BOUND not used for sending! */ - ((dhcp->state == DHCP_STATE_RENEWING) || dhcp->state == DHCP_STATE_REBINDING))) { - ip4_addr_copy(msg_out->ciaddr, *netif_ip4_addr(netif)); - } - for (i = 0; i < LWIP_MIN(DHCP_CHADDR_LEN, NETIF_MAX_HWADDR_LEN); i++) { - /* copy netif hardware address (padded with zeroes through memset already) */ - msg_out->chaddr[i] = netif->hwaddr[i]; - } - msg_out->cookie = PP_HTONL(DHCP_MAGIC_COOKIE); - /* Add option MESSAGE_TYPE */ - options_out_len_loc = dhcp_option(0, msg_out->options, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); - options_out_len_loc = dhcp_option_byte(options_out_len_loc, msg_out->options, message_type); - if (options_out_len) { - *options_out_len = options_out_len_loc; - } - return p_out; -} - -/** - * Add a DHCP message trailer - * - * Adds the END option to the DHCP message, and if - * necessary, up to three padding bytes. - */ -static void -dhcp_option_trailer(u16_t options_out_len, u8_t *options, struct pbuf *p_out) -{ - options[options_out_len++] = DHCP_OPTION_END; - /* packet is too small, or not 4 byte aligned? */ - while (((options_out_len < DHCP_MIN_OPTIONS_LEN) || (options_out_len & 3)) && - (options_out_len < DHCP_OPTIONS_LEN)) { - /* add a fill/padding byte */ - options[options_out_len++] = 0; - } - /* shrink the pbuf to the actual content length */ - pbuf_realloc(p_out, (u16_t)(sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + options_out_len)); -} - -/** check if DHCP supplied netif->ip_addr - * - * @param netif the netif to check - * @return 1 if DHCP supplied netif->ip_addr (states BOUND or RENEWING), - * 0 otherwise - */ -u8_t -dhcp_supplied_address(const struct netif *netif) -{ - if ((netif != NULL) && (netif_dhcp_data(netif) != NULL)) { - struct dhcp *dhcp = netif_dhcp_data(netif); - return (dhcp->state == DHCP_STATE_BOUND) || (dhcp->state == DHCP_STATE_RENEWING) || - (dhcp->state == DHCP_STATE_REBINDING); - } - return 0; -} - -#endif /* LWIP_IPV4 && LWIP_DHCP */ +/** + * @file + * Dynamic Host Configuration Protocol client + * + * @defgroup dhcp4 DHCPv4 + * @ingroup ip4 + * DHCP (IPv4) related functions + * This is a DHCP client for the lwIP TCP/IP stack. It aims to conform + * with RFC 2131 and RFC 2132. + * + * @todo: + * - Support for interfaces other than Ethernet (SLIP, PPP, ...) + * + * Options: + * @ref DHCP_COARSE_TIMER_SECS (recommended 60 which is a minute) + * @ref DHCP_FINE_TIMER_MSECS (recommended 500 which equals TCP coarse timer) + * + * dhcp_start() starts a DHCP client instance which + * configures the interface by obtaining an IP address lease and maintaining it. + * + * Use dhcp_release() to end the lease and use dhcp_stop() + * to remove the DHCP client. + * + * @see LWIP_HOOK_DHCP_APPEND_OPTIONS + * @see LWIP_HOOK_DHCP_PARSE_OPTION + * + * @see netifapi_dhcp4 + */ + +/* + * Copyright (c) 2001-2004 Leon Woestenberg + * Copyright (c) 2001-2004 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * The Swedish Institute of Computer Science and Adam Dunkels + * are specifically granted permission to redistribute this + * source code. + * + * Author: Leon Woestenberg + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_DHCP /* don't build if not configured for use in lwipopts.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/dhcp.h" +#include "lwip/autoip.h" +#include "lwip/dns.h" +#include "lwip/etharp.h" +#include "lwip/prot/dhcp.h" +#include "lwip/prot/iana.h" + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif +#ifndef LWIP_HOOK_DHCP_APPEND_OPTIONS +#define LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, state, msg, msg_type, options_len_ptr) +#endif +#ifndef LWIP_HOOK_DHCP_PARSE_OPTION +#define LWIP_HOOK_DHCP_PARSE_OPTION(netif, dhcp, state, msg, msg_type, option, len, pbuf, offset) do { LWIP_UNUSED_ARG(msg); } while(0) +#endif + +/** DHCP_CREATE_RAND_XID: if this is set to 1, the xid is created using + * LWIP_RAND() (this overrides DHCP_GLOBAL_XID) + */ +#ifndef DHCP_CREATE_RAND_XID +#define DHCP_CREATE_RAND_XID 1 +#endif + +/** Default for DHCP_GLOBAL_XID is 0xABCD0000 + * This can be changed by defining DHCP_GLOBAL_XID and DHCP_GLOBAL_XID_HEADER, e.g. + * \#define DHCP_GLOBAL_XID_HEADER "stdlib.h" + * \#define DHCP_GLOBAL_XID rand() + */ +#ifdef DHCP_GLOBAL_XID_HEADER +#include DHCP_GLOBAL_XID_HEADER /* include optional starting XID generation prototypes */ +#endif + +/** DHCP_OPTION_MAX_MSG_SIZE is set to the MTU + * MTU is checked to be big enough in dhcp_start */ +#define DHCP_MAX_MSG_LEN(netif) (netif->mtu) +#define DHCP_MAX_MSG_LEN_MIN_REQUIRED 576 +/** Minimum length for reply before packet is parsed */ +#define DHCP_MIN_REPLY_LEN 44 + +#define REBOOT_TRIES 2 + +#if LWIP_DNS && LWIP_DHCP_MAX_DNS_SERVERS +#if DNS_MAX_SERVERS > LWIP_DHCP_MAX_DNS_SERVERS +#define LWIP_DHCP_PROVIDE_DNS_SERVERS LWIP_DHCP_MAX_DNS_SERVERS +#else +#define LWIP_DHCP_PROVIDE_DNS_SERVERS DNS_MAX_SERVERS +#endif +#else +#define LWIP_DHCP_PROVIDE_DNS_SERVERS 0 +#endif + +/** 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_MAX +}; + +/** Holds the decoded option values, only valid while in dhcp_recv. + @todo: move this into struct dhcp? */ +u32_t dhcp_rx_options_val[DHCP_OPTION_IDX_MAX]; +/** Holds a flag which option was received and is contained in dhcp_rx_options_val, + only valid while in dhcp_recv. + @todo: move this into struct dhcp? */ +u8_t dhcp_rx_options_given[DHCP_OPTION_IDX_MAX]; + +static u8_t dhcp_discover_request_options[] = { + DHCP_OPTION_SUBNET_MASK, + DHCP_OPTION_ROUTER, + DHCP_OPTION_BROADCAST +#if LWIP_DHCP_PROVIDE_DNS_SERVERS + , DHCP_OPTION_DNS_SERVER +#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ +#if LWIP_DHCP_GET_NTP_SRV + , DHCP_OPTION_NTP +#endif /* LWIP_DHCP_GET_NTP_SRV */ +}; + +#ifdef DHCP_GLOBAL_XID +static u32_t xid; +static u8_t xid_initialised; +#endif /* DHCP_GLOBAL_XID */ + +#define dhcp_option_given(dhcp, idx) (dhcp_rx_options_given[idx] != 0) +#define dhcp_got_option(dhcp, idx) (dhcp_rx_options_given[idx] = 1) +#define dhcp_clear_option(dhcp, idx) (dhcp_rx_options_given[idx] = 0) +#define dhcp_clear_all_options(dhcp) (memset(dhcp_rx_options_given, 0, sizeof(dhcp_rx_options_given))) +#define dhcp_get_option_value(dhcp, idx) (dhcp_rx_options_val[idx]) +#define dhcp_set_option_value(dhcp, idx, val) (dhcp_rx_options_val[idx] = (val)) + +static struct udp_pcb *dhcp_pcb; +static u8_t dhcp_pcb_refcount; + +/* DHCP client state machine functions */ +static err_t dhcp_discover(struct netif *netif); +static err_t dhcp_select(struct netif *netif); +static void dhcp_bind(struct netif *netif); +#if DHCP_DOES_ARP_CHECK +static err_t dhcp_decline(struct netif *netif); +#endif /* DHCP_DOES_ARP_CHECK */ +static err_t dhcp_rebind(struct netif *netif); +static err_t dhcp_reboot(struct netif *netif); +static void dhcp_set_state(struct dhcp *dhcp, u8_t new_state); + +/* receive, unfold, parse and free incoming messages */ +static void dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); + +/* set the DHCP timers */ +static void dhcp_timeout(struct netif *netif); +static void dhcp_t1_timeout(struct netif *netif); +static void dhcp_t2_timeout(struct netif *netif); + +/* build outgoing messages */ +/* create a DHCP message, fill in common headers */ +static struct pbuf *dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type, u16_t *options_out_len); +/* add a DHCP option (type, then length in bytes) */ +static u16_t dhcp_option(u16_t options_out_len, u8_t *options, u8_t option_type, u8_t option_len); +/* add option values */ +static u16_t dhcp_option_byte(u16_t options_out_len, u8_t *options, u8_t value); +static u16_t dhcp_option_short(u16_t options_out_len, u8_t *options, u16_t value); +static u16_t dhcp_option_long(u16_t options_out_len, u8_t *options, u32_t value); +#if LWIP_NETIF_HOSTNAME +static u16_t dhcp_option_hostname(u16_t options_out_len, u8_t *options, struct netif *netif); +#endif /* LWIP_NETIF_HOSTNAME */ +/* always add the DHCP options trailer to end and pad */ +static void dhcp_option_trailer(u16_t options_out_len, u8_t *options, struct pbuf *p_out); + +/** Ensure DHCP PCB is allocated and bound */ +static err_t +dhcp_inc_pcb_refcount(void) +{ + if (dhcp_pcb_refcount == 0) { + LWIP_ASSERT("dhcp_inc_pcb_refcount(): memory leak", dhcp_pcb == NULL); + + /* allocate UDP PCB */ + dhcp_pcb = udp_new(); + + if (dhcp_pcb == NULL) { + return ERR_MEM; + } + + ip_set_option(dhcp_pcb, SOF_BROADCAST); + + /* set up local and remote port for the pcb -> listen on all interfaces on all src/dest IPs */ + udp_bind(dhcp_pcb, IP4_ADDR_ANY, LWIP_IANA_PORT_DHCP_CLIENT); + udp_connect(dhcp_pcb, IP4_ADDR_ANY, LWIP_IANA_PORT_DHCP_SERVER); + udp_recv(dhcp_pcb, dhcp_recv, NULL); + } + + dhcp_pcb_refcount++; + + return ERR_OK; +} + +/** Free DHCP PCB if the last netif stops using it */ +static void +dhcp_dec_pcb_refcount(void) +{ + LWIP_ASSERT("dhcp_pcb_refcount(): refcount error", (dhcp_pcb_refcount > 0)); + dhcp_pcb_refcount--; + + if (dhcp_pcb_refcount == 0) { + udp_remove(dhcp_pcb); + dhcp_pcb = NULL; + } +} + +/** + * Back-off the DHCP client (because of a received NAK response). + * + * Back-off the DHCP client because of a received NAK. Receiving a + * NAK means the client asked for something non-sensible, for + * example when it tries to renew a lease obtained on another network. + * + * We clear any existing set IP address and restart DHCP negotiation + * afresh (as per RFC2131 3.2.3). + * + * @param netif the netif under DHCP control + */ +static void +dhcp_handle_nak(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_nak(netif=%p) %c%c%"U16_F"\n", + (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); + /* Change to a defined state - set this before assigning the address + to ensure the callback can use dhcp_supplied_address() */ + dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF); + /* remove IP address from interface (must no longer be used, as per RFC2131) */ + netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); + /* We can immediately restart discovery */ + dhcp_discover(netif); +} + +#if DHCP_DOES_ARP_CHECK +/** + * Checks if the offered IP address is already in use. + * + * It does so by sending an ARP request for the offered address and + * entering CHECKING state. If no ARP reply is received within a small + * interval, the address is assumed to be free for use by us. + * + * @param netif the netif under DHCP control + */ +static void +dhcp_check(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + err_t result; + u16_t msecs; + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_check(netif=%p) %c%c\n", (void *)netif, (s16_t)netif->name[0], + (s16_t)netif->name[1])); + dhcp_set_state(dhcp, DHCP_STATE_CHECKING); + /* create an ARP query for the offered IP address, expecting that no host + responds, as the IP address should not be in use. */ + result = etharp_query(netif, &dhcp->offered_ip_addr, NULL); + if (result != ERR_OK) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("dhcp_check: could not perform ARP query\n")); + } + if (dhcp->tries < 255) { + dhcp->tries++; + } + msecs = 500; + dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_check(): set request timeout %"U16_F" msecs\n", msecs)); +} +#endif /* DHCP_DOES_ARP_CHECK */ + +/** + * Remember the configuration offered by a DHCP server. + * + * @param netif the netif under DHCP control + */ +static void +dhcp_handle_offer(struct netif *netif, struct dhcp_msg *msg_in) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_handle_offer(netif=%p) %c%c%"U16_F"\n", + (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); + /* obtain the server address */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SERVER_ID)) { + dhcp->request_timeout = 0; /* stop timer */ + + ip_addr_set_ip4_u32(&dhcp->server_ip_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SERVER_ID))); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): server 0x%08"X32_F"\n", + ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr)))); + /* remember offered address */ + ip4_addr_copy(dhcp->offered_ip_addr, msg_in->yiaddr); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_handle_offer(): offer for 0x%08"X32_F"\n", + ip4_addr_get_u32(&dhcp->offered_ip_addr))); + + dhcp_select(netif); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("dhcp_handle_offer(netif=%p) did not get server ID!\n", (void *)netif)); + } +} + +/** + * Select a DHCP server offer out of all offers. + * + * Simply select the first offer received. + * + * @param netif the netif under DHCP control + * @return lwIP specific error (see error.h) + */ +static err_t +dhcp_select(struct netif *netif) +{ + struct dhcp *dhcp; + err_t result; + u16_t msecs; + u8_t i; + struct pbuf *p_out; + u16_t options_out_len; + + LWIP_ERROR("dhcp_select: netif != NULL", (netif != NULL), return ERR_ARG;); + dhcp = netif_dhcp_data(netif); + LWIP_ERROR("dhcp_select: dhcp != NULL", (dhcp != NULL), return ERR_VAL;); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_select(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); + dhcp_set_state(dhcp, DHCP_STATE_REQUESTING); + + /* create and initialize the DHCP message header */ + p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); + options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); + + /* MUST request the offered IP address */ + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_REQUESTED_IP, 4); + options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_SERVER_ID, 4); + options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&dhcp->server_ip_addr)))); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); + for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { + options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); + } + +#if LWIP_NETIF_HOSTNAME + options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); +#endif /* LWIP_NETIF_HOSTNAME */ + + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_REQUESTING, msg_out, DHCP_REQUEST, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + /* send broadcast to any DHCP server */ + result = udp_sendto_if_src(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif, IP4_ADDR_ANY); + pbuf_free(p_out); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_select: REQUESTING\n")); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("dhcp_select: could not allocate DHCP request\n")); + result = ERR_MEM; + } + if (dhcp->tries < 255) { + dhcp->tries++; + } + msecs = (u16_t)((dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000); + dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_select(): set request timeout %"U16_F" msecs\n", msecs)); + return result; +} + +/** + * The DHCP timer that checks for lease renewal/rebind timeouts. + * Must be called once a minute (see @ref DHCP_COARSE_TIMER_SECS). + */ +void +dhcp_coarse_tmr(void) +{ + struct netif *netif; + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_coarse_tmr()\n")); + /* iterate through all network interfaces */ + NETIF_FOREACH(netif) { + /* only act on DHCP configured interfaces */ + struct dhcp *dhcp = netif_dhcp_data(netif); + if ((dhcp != NULL) && (dhcp->state != DHCP_STATE_OFF)) { + /* compare lease time to expire timeout */ + if (dhcp->t0_timeout && (++dhcp->lease_used == dhcp->t0_timeout)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t0 timeout\n")); + /* this clients' lease time has expired */ + dhcp_release_and_stop(netif); + dhcp_start(netif); + /* timer is active (non zero), and triggers (zeroes) now? */ + } else if (dhcp->t2_rebind_time && (dhcp->t2_rebind_time-- == 1)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t2 timeout\n")); + /* this clients' rebind timeout triggered */ + dhcp_t2_timeout(netif); + /* timer is active (non zero), and triggers (zeroes) now */ + } else if (dhcp->t1_renew_time && (dhcp->t1_renew_time-- == 1)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_coarse_tmr(): t1 timeout\n")); + /* this clients' renewal timeout triggered */ + dhcp_t1_timeout(netif); + } + } + } +} + +/** + * DHCP transaction timeout handling (this function must be called every 500ms, + * see @ref DHCP_FINE_TIMER_MSECS). + * + * A DHCP server is expected to respond within a short period of time. + * This timer checks whether an outstanding DHCP request is timed out. + */ +void +dhcp_fine_tmr(void) +{ + struct netif *netif; + /* loop through netif's */ + NETIF_FOREACH(netif) { + struct dhcp *dhcp = netif_dhcp_data(netif); + /* only act on DHCP configured interfaces */ + if (dhcp != NULL) { + /* timer is active (non zero), and is about to trigger now */ + if (dhcp->request_timeout > 1) { + dhcp->request_timeout--; + } else if (dhcp->request_timeout == 1) { + dhcp->request_timeout--; + /* { dhcp->request_timeout == 0 } */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_fine_tmr(): request timeout\n")); + /* this client's request timeout triggered */ + dhcp_timeout(netif); + } + } + } +} + +/** + * A DHCP negotiation transaction, or ARP request, has timed out. + * + * The timer that was started with the DHCP or ARP request has + * timed out, indicating no response was received in time. + * + * @param netif the netif under DHCP control + */ +static void +dhcp_timeout(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout()\n")); + /* back-off period has passed, or server selection timed out */ + if ((dhcp->state == DHCP_STATE_BACKING_OFF) || (dhcp->state == DHCP_STATE_SELECTING)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_timeout(): restarting discovery\n")); + dhcp_discover(netif); + /* receiving the requested lease timed out */ + } else if (dhcp->state == DHCP_STATE_REQUESTING) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, DHCP request timed out\n")); + if (dhcp->tries <= 5) { + dhcp_select(netif); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): REQUESTING, releasing, restarting\n")); + dhcp_release_and_stop(netif); + dhcp_start(netif); + } +#if DHCP_DOES_ARP_CHECK + /* received no ARP reply for the offered address (which is good) */ + } else if (dhcp->state == DHCP_STATE_CHECKING) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_timeout(): CHECKING, ARP request timed out\n")); + if (dhcp->tries <= 1) { + dhcp_check(netif); + /* no ARP replies on the offered address, + looks like the IP address is indeed free */ + } else { + /* bind the interface to the offered address */ + dhcp_bind(netif); + } +#endif /* DHCP_DOES_ARP_CHECK */ + } else if (dhcp->state == DHCP_STATE_REBOOTING) { + if (dhcp->tries < REBOOT_TRIES) { + dhcp_reboot(netif); + } else { + dhcp_discover(netif); + } + } +} + +/** + * The renewal period has timed out. + * + * @param netif the netif under DHCP control + */ +static void +dhcp_t1_timeout(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_t1_timeout()\n")); + if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) || + (dhcp->state == DHCP_STATE_RENEWING)) { + /* just retry to renew - note that the rebind timer (t2) will + * eventually time-out if renew tries fail. */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("dhcp_t1_timeout(): must renew\n")); + /* This slightly different to RFC2131: DHCPREQUEST will be sent from state + DHCP_STATE_RENEWING, not DHCP_STATE_BOUND */ + dhcp_renew(netif); + /* Calculate next timeout */ + if (((dhcp->t2_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) { + dhcp->t1_renew_time = (u16_t)((dhcp->t2_timeout - dhcp->lease_used) / 2); + } + } +} + +/** + * The rebind period has timed out. + * + * @param netif the netif under DHCP control + */ +static void +dhcp_t2_timeout(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_t2_timeout()\n")); + if ((dhcp->state == DHCP_STATE_REQUESTING) || (dhcp->state == DHCP_STATE_BOUND) || + (dhcp->state == DHCP_STATE_RENEWING) || (dhcp->state == DHCP_STATE_REBINDING)) { + /* just retry to rebind */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + ("dhcp_t2_timeout(): must rebind\n")); + /* This slightly different to RFC2131: DHCPREQUEST will be sent from state + DHCP_STATE_REBINDING, not DHCP_STATE_BOUND */ + dhcp_rebind(netif); + /* Calculate next timeout */ + if (((dhcp->t0_timeout - dhcp->lease_used) / 2) >= ((60 + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS)) { + dhcp->t2_rebind_time = (u16_t)((dhcp->t0_timeout - dhcp->lease_used) / 2); + } + } +} + +/** + * Handle a DHCP ACK packet + * + * @param netif the netif under DHCP control + */ +static void +dhcp_handle_ack(struct netif *netif, struct dhcp_msg *msg_in) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + +#if LWIP_DHCP_PROVIDE_DNS_SERVERS || LWIP_DHCP_GET_NTP_SRV + u8_t n; +#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS || LWIP_DHCP_GET_NTP_SRV */ +#if LWIP_DHCP_GET_NTP_SRV + ip4_addr_t ntp_server_addrs[LWIP_DHCP_MAX_NTP_SERVERS]; +#endif + + /* clear options we might not get from the ACK */ + ip4_addr_set_zero(&dhcp->offered_sn_mask); + ip4_addr_set_zero(&dhcp->offered_gw_addr); +#if LWIP_DHCP_BOOTP_FILE + ip4_addr_set_zero(&dhcp->offered_si_addr); +#endif /* LWIP_DHCP_BOOTP_FILE */ + + /* lease time given? */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_LEASE_TIME)) { + /* remember offered lease time */ + dhcp->offered_t0_lease = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_LEASE_TIME); + } + /* renewal period given? */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T1)) { + /* remember given renewal period */ + dhcp->offered_t1_renew = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T1); + } else { + /* calculate safe periods for renewal */ + dhcp->offered_t1_renew = dhcp->offered_t0_lease / 2; + } + + /* renewal period given? */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_T2)) { + /* remember given rebind period */ + dhcp->offered_t2_rebind = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_T2); + } else { + /* calculate safe periods for rebinding (offered_t0_lease * 0.875 -> 87.5%)*/ + dhcp->offered_t2_rebind = (dhcp->offered_t0_lease * 7U) / 8U; + } + + /* (y)our internet address */ + ip4_addr_copy(dhcp->offered_ip_addr, msg_in->yiaddr); + +#if LWIP_DHCP_BOOTP_FILE + /* copy boot server address, + boot file name copied in dhcp_parse_reply if not overloaded */ + ip4_addr_copy(dhcp->offered_si_addr, msg_in->siaddr); +#endif /* LWIP_DHCP_BOOTP_FILE */ + + /* subnet mask given? */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_SUBNET_MASK)) { + /* remember given subnet mask */ + ip4_addr_set_u32(&dhcp->offered_sn_mask, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_SUBNET_MASK))); + dhcp->subnet_mask_given = 1; + } else { + dhcp->subnet_mask_given = 0; + } + + /* gateway router */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_ROUTER)) { + ip4_addr_set_u32(&dhcp->offered_gw_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_ROUTER))); + } + +#if LWIP_DHCP_GET_NTP_SRV + /* NTP servers */ + for (n = 0; (n < LWIP_DHCP_MAX_NTP_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n); n++) { + ip4_addr_set_u32(&ntp_server_addrs[n], lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_NTP_SERVER + n))); + } + dhcp_set_ntp_servers(n, ntp_server_addrs); +#endif /* LWIP_DHCP_GET_NTP_SRV */ + +#if LWIP_DHCP_PROVIDE_DNS_SERVERS + /* DNS servers */ + for (n = 0; (n < LWIP_DHCP_PROVIDE_DNS_SERVERS) && dhcp_option_given(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n); n++) { + ip_addr_t dns_addr; + ip_addr_set_ip4_u32_val(dns_addr, lwip_htonl(dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_DNS_SERVER + n))); + dns_setserver(n, &dns_addr); + } +#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ +} + +/** + * @ingroup dhcp4 + * Set a statically allocated struct dhcp to work with. + * Using this prevents dhcp_start to allocate it using mem_malloc. + * + * @param netif the netif for which to set the struct dhcp + * @param dhcp (uninitialised) dhcp struct allocated by the application + */ +void +dhcp_set_struct(struct netif *netif, struct dhcp *dhcp) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("dhcp != NULL", dhcp != NULL); + LWIP_ASSERT("netif already has a struct dhcp set", netif_dhcp_data(netif) == NULL); + + /* clear data structure */ + memset(dhcp, 0, sizeof(struct dhcp)); + /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */ + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp); +} + +/** + * @ingroup dhcp4 + * Removes a struct dhcp from a netif. + * + * ATTENTION: Only use this when not using dhcp_set_struct() to allocate the + * struct dhcp since the memory is passed back to the heap. + * + * @param netif the netif from which to remove the struct dhcp + */ +void dhcp_cleanup(struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("netif != NULL", netif != NULL); + + if (netif_dhcp_data(netif) != NULL) { + mem_free(netif_dhcp_data(netif)); + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, NULL); + } +} + +/** + * @ingroup dhcp4 + * Start DHCP negotiation for a network interface. + * + * If no DHCP client instance was attached to this interface, + * a new client is created first. If a DHCP client instance + * was already present, it restarts negotiation. + * + * @param netif The lwIP network interface + * @return lwIP error code + * - ERR_OK - No error + * - ERR_MEM - Out of memory + */ +err_t +dhcp_start(struct netif *netif) +{ + struct dhcp *dhcp; + err_t result; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ERROR("netif != NULL", (netif != NULL), return ERR_ARG;); + LWIP_ERROR("netif is not up, old style port?", netif_is_up(netif), return ERR_ARG;); + dhcp = netif_dhcp_data(netif); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); + + /* check MTU of the netif */ + if (netif->mtu < DHCP_MAX_MSG_LEN_MIN_REQUIRED) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): Cannot use this netif with DHCP: MTU is too small\n")); + return ERR_MEM; + } + + /* no DHCP client attached yet? */ + if (dhcp == NULL) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): mallocing new DHCP client\n")); + dhcp = (struct dhcp *)mem_malloc(sizeof(struct dhcp)); + if (dhcp == NULL) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): could not allocate dhcp\n")); + return ERR_MEM; + } + + /* store this dhcp client in the netif */ + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, dhcp); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): allocated dhcp")); + /* already has DHCP client attached */ + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_start(): restarting DHCP configuration\n")); + + if (dhcp->pcb_allocated != 0) { + dhcp_dec_pcb_refcount(); /* free DHCP PCB if not needed any more */ + } + /* dhcp is cleared below, no need to reset flag*/ + } + + /* clear data structure */ + memset(dhcp, 0, sizeof(struct dhcp)); + /* dhcp_set_state(&dhcp, DHCP_STATE_OFF); */ + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_start(): starting DHCP configuration\n")); + + if (dhcp_inc_pcb_refcount() != ERR_OK) { /* ensure DHCP PCB is allocated */ + return ERR_MEM; + } + dhcp->pcb_allocated = 1; + + if (!netif_is_link_up(netif)) { + /* set state INIT and wait for dhcp_network_changed() to call dhcp_discover() */ + dhcp_set_state(dhcp, DHCP_STATE_INIT); + return ERR_OK; + } + + /* (re)start the DHCP negotiation */ + result = dhcp_discover(netif); + if (result != ERR_OK) { + /* free resources allocated above */ + dhcp_release_and_stop(netif); + return ERR_MEM; + } + return result; +} + +/** + * @ingroup dhcp4 + * Inform a DHCP server of our manual configuration. + * + * This informs DHCP servers of our fixed IP address configuration + * by sending an INFORM message. It does not involve DHCP address + * configuration, it is just here to be nice to the network. + * + * @param netif The lwIP network interface + */ +void +dhcp_inform(struct netif *netif) +{ + struct dhcp dhcp; + struct pbuf *p_out; + u16_t options_out_len; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ERROR("netif != NULL", (netif != NULL), return;); + + if (dhcp_inc_pcb_refcount() != ERR_OK) { /* ensure DHCP PCB is allocated */ + return; + } + + memset(&dhcp, 0, sizeof(struct dhcp)); + dhcp_set_state(&dhcp, DHCP_STATE_INFORMING); + + /* create and initialize the DHCP message header */ + p_out = dhcp_create_msg(netif, &dhcp, DHCP_INFORM, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); + options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); + + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, &dhcp, DHCP_STATE_INFORMING, msg_out, DHCP_INFORM, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_inform: INFORMING\n")); + + udp_sendto_if(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif); + + pbuf_free(p_out); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_inform: could not allocate DHCP request\n")); + } + + dhcp_dec_pcb_refcount(); /* delete DHCP PCB if not needed any more */ +} + +/** Handle a possible change in the network configuration. + * + * This enters the REBOOTING state to verify that the currently bound + * address is still valid. + */ +void +dhcp_network_changed(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + + if (!dhcp) { + return; + } + switch (dhcp->state) { + case DHCP_STATE_REBINDING: + case DHCP_STATE_RENEWING: + case DHCP_STATE_BOUND: + case DHCP_STATE_REBOOTING: + dhcp->tries = 0; + dhcp_reboot(netif); + break; + case DHCP_STATE_OFF: + /* stay off */ + break; + default: + LWIP_ASSERT("invalid dhcp->state", dhcp->state <= DHCP_STATE_BACKING_OFF); + /* INIT/REQUESTING/CHECKING/BACKING_OFF restart with new 'rid' because the + state changes, SELECTING: continue with current 'rid' as we stay in the + same state */ +#if LWIP_DHCP_AUTOIP_COOP + if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) { + autoip_stop(netif); + dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF; + } +#endif /* LWIP_DHCP_AUTOIP_COOP */ + /* ensure we start with short timeouts, even if already discovering */ + dhcp->tries = 0; + dhcp_discover(netif); + break; + } +} + +#if DHCP_DOES_ARP_CHECK +/** + * Match an ARP reply with the offered IP address: + * check whether the offered IP address is not in use using ARP + * + * @param netif the network interface on which the reply was received + * @param addr The IP address we received a reply from + */ +void +dhcp_arp_reply(struct netif *netif, const ip4_addr_t *addr) +{ + struct dhcp *dhcp; + + LWIP_ERROR("netif != NULL", (netif != NULL), return;); + dhcp = netif_dhcp_data(netif); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_arp_reply()\n")); + /* is a DHCP client doing an ARP check? */ + if ((dhcp != NULL) && (dhcp->state == DHCP_STATE_CHECKING)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_arp_reply(): CHECKING, arp reply for 0x%08"X32_F"\n", + ip4_addr_get_u32(addr))); + /* did a host respond with the address we + were offered by the DHCP server? */ + if (ip4_addr_cmp(addr, &dhcp->offered_ip_addr)) { + /* we will not accept the offered address */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE | LWIP_DBG_LEVEL_WARNING, + ("dhcp_arp_reply(): arp reply matched with offered address, declining\n")); + dhcp_decline(netif); + } + } +} + +/** + * Decline an offered lease. + * + * Tell the DHCP server we do not accept the offered address. + * One reason to decline the lease is when we find out the address + * is already in use by another host (through ARP). + * + * @param netif the netif under DHCP control + */ +static err_t +dhcp_decline(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + err_t result; + u16_t msecs; + struct pbuf *p_out; + u16_t options_out_len; + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline()\n")); + dhcp_set_state(dhcp, DHCP_STATE_BACKING_OFF); + /* create and initialize the DHCP message header */ + p_out = dhcp_create_msg(netif, dhcp, DHCP_DECLINE, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_REQUESTED_IP, 4); + options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); + + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_BACKING_OFF, msg_out, DHCP_DECLINE, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + /* per section 4.4.4, broadcast DECLINE messages */ + result = udp_sendto_if_src(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif, IP4_ADDR_ANY); + pbuf_free(p_out); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_decline: BACKING OFF\n")); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("dhcp_decline: could not allocate DHCP request\n")); + result = ERR_MEM; + } + if (dhcp->tries < 255) { + dhcp->tries++; + } + msecs = 10 * 1000; + dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_decline(): set request timeout %"U16_F" msecs\n", msecs)); + return result; +} +#endif /* DHCP_DOES_ARP_CHECK */ + + +/** + * Start the DHCP process, discover a DHCP server. + * + * @param netif the netif under DHCP control + */ +static err_t +dhcp_discover(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + err_t result = ERR_OK; + u16_t msecs; + u8_t i; + struct pbuf *p_out; + u16_t options_out_len; + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover()\n")); + + ip4_addr_set_any(&dhcp->offered_ip_addr); + dhcp_set_state(dhcp, DHCP_STATE_SELECTING); + /* create and initialize the DHCP message header */ + p_out = dhcp_create_msg(netif, dhcp, DHCP_DISCOVER, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: making request\n")); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); + options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); + for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { + options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); + } + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_SELECTING, msg_out, DHCP_DISCOVER, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: sendto(DISCOVER, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER)\n")); + udp_sendto_if_src(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif, IP4_ADDR_ANY); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_discover: deleting()ing\n")); + pbuf_free(p_out); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_discover: SELECTING\n")); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_discover: could not allocate DHCP request\n")); + } + if (dhcp->tries < 255) { + dhcp->tries++; + } +#if LWIP_DHCP_AUTOIP_COOP + if (dhcp->tries >= LWIP_DHCP_AUTOIP_COOP_TRIES && dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_OFF) { + dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_ON; + autoip_start(netif); + } +#endif /* LWIP_DHCP_AUTOIP_COOP */ + msecs = (u16_t)((dhcp->tries < 6 ? 1 << dhcp->tries : 60) * 1000); + dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_discover(): set request timeout %"U16_F" msecs\n", msecs)); + return result; +} + + +/** + * Bind the interface to the offered IP address. + * + * @param netif network interface to bind to the offered address + */ +static void +dhcp_bind(struct netif *netif) +{ + u32_t timeout; + struct dhcp *dhcp; + ip4_addr_t sn_mask, gw_addr; + LWIP_ERROR("dhcp_bind: netif != NULL", (netif != NULL), return;); + dhcp = netif_dhcp_data(netif); + LWIP_ERROR("dhcp_bind: dhcp != NULL", (dhcp != NULL), return;); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); + + /* reset time used of lease */ + dhcp->lease_used = 0; + + if (dhcp->offered_t0_lease != 0xffffffffUL) { + /* set renewal period timer */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t0 renewal timer %"U32_F" secs\n", dhcp->offered_t0_lease)); + timeout = (dhcp->offered_t0_lease + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; + if (timeout > 0xffff) { + timeout = 0xffff; + } + dhcp->t0_timeout = (u16_t)timeout; + if (dhcp->t0_timeout == 0) { + dhcp->t0_timeout = 1; + } + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t0_lease * 1000)); + } + + /* temporary DHCP lease? */ + if (dhcp->offered_t1_renew != 0xffffffffUL) { + /* set renewal period timer */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t1 renewal timer %"U32_F" secs\n", dhcp->offered_t1_renew)); + timeout = (dhcp->offered_t1_renew + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; + if (timeout > 0xffff) { + timeout = 0xffff; + } + dhcp->t1_timeout = (u16_t)timeout; + if (dhcp->t1_timeout == 0) { + dhcp->t1_timeout = 1; + } + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t1_renew * 1000)); + dhcp->t1_renew_time = dhcp->t1_timeout; + } + /* set renewal period timer */ + if (dhcp->offered_t2_rebind != 0xffffffffUL) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_bind(): t2 rebind timer %"U32_F" secs\n", dhcp->offered_t2_rebind)); + timeout = (dhcp->offered_t2_rebind + DHCP_COARSE_TIMER_SECS / 2) / DHCP_COARSE_TIMER_SECS; + if (timeout > 0xffff) { + timeout = 0xffff; + } + dhcp->t2_timeout = (u16_t)timeout; + if (dhcp->t2_timeout == 0) { + dhcp->t2_timeout = 1; + } + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_bind(): set request timeout %"U32_F" msecs\n", dhcp->offered_t2_rebind * 1000)); + dhcp->t2_rebind_time = dhcp->t2_timeout; + } + + /* If we have sub 1 minute lease, t2 and t1 will kick in at the same time. */ + if ((dhcp->t1_timeout >= dhcp->t2_timeout) && (dhcp->t2_timeout > 0)) { + dhcp->t1_timeout = 0; + } + + if (dhcp->subnet_mask_given) { + /* copy offered network mask */ + ip4_addr_copy(sn_mask, dhcp->offered_sn_mask); + } else { + /* subnet mask not given, choose a safe subnet mask given the network class */ + u8_t first_octet = ip4_addr1(&dhcp->offered_ip_addr); + if (first_octet <= 127) { + ip4_addr_set_u32(&sn_mask, PP_HTONL(0xff000000UL)); + } else if (first_octet >= 192) { + ip4_addr_set_u32(&sn_mask, PP_HTONL(0xffffff00UL)); + } else { + ip4_addr_set_u32(&sn_mask, PP_HTONL(0xffff0000UL)); + } + } + + ip4_addr_copy(gw_addr, dhcp->offered_gw_addr); + /* gateway address not given? */ + if (ip4_addr_isany_val(gw_addr)) { + /* copy network address */ + ip4_addr_get_network(&gw_addr, &dhcp->offered_ip_addr, &sn_mask); + /* use first host address on network as gateway */ + ip4_addr_set_u32(&gw_addr, ip4_addr_get_u32(&gw_addr) | PP_HTONL(0x00000001UL)); + } + +#if LWIP_DHCP_AUTOIP_COOP + if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) { + autoip_stop(netif); + dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF; + } +#endif /* LWIP_DHCP_AUTOIP_COOP */ + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_STATE, ("dhcp_bind(): IP: 0x%08"X32_F" SN: 0x%08"X32_F" GW: 0x%08"X32_F"\n", + ip4_addr_get_u32(&dhcp->offered_ip_addr), ip4_addr_get_u32(&sn_mask), ip4_addr_get_u32(&gw_addr))); + /* netif is now bound to DHCP leased address - set this before assigning the address + to ensure the callback can use dhcp_supplied_address() */ + dhcp_set_state(dhcp, DHCP_STATE_BOUND); + + netif_set_addr(netif, &dhcp->offered_ip_addr, &sn_mask, &gw_addr); + /* interface is used by routing now that an address is set */ +} + +/** + * @ingroup dhcp4 + * Renew an existing DHCP lease at the involved DHCP server. + * + * @param netif network interface which must renew its lease + */ +err_t +dhcp_renew(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + err_t result; + u16_t msecs; + u8_t i; + struct pbuf *p_out; + u16_t options_out_len; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_renew()\n")); + dhcp_set_state(dhcp, DHCP_STATE_RENEWING); + + /* create and initialize the DHCP message header */ + p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); + options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); + for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { + options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); + } + +#if LWIP_NETIF_HOSTNAME + options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); +#endif /* LWIP_NETIF_HOSTNAME */ + + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_RENEWING, msg_out, DHCP_REQUEST, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + result = udp_sendto_if(dhcp_pcb, p_out, &dhcp->server_ip_addr, LWIP_IANA_PORT_DHCP_SERVER, netif); + pbuf_free(p_out); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_renew: RENEWING\n")); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_renew: could not allocate DHCP request\n")); + result = ERR_MEM; + } + if (dhcp->tries < 255) { + dhcp->tries++; + } + /* back-off on retries, but to a maximum of 20 seconds */ + msecs = (u16_t)(dhcp->tries < 10 ? dhcp->tries * 2000 : 20 * 1000); + dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_renew(): set request timeout %"U16_F" msecs\n", msecs)); + return result; +} + +/** + * Rebind with a DHCP server for an existing DHCP lease. + * + * @param netif network interface which must rebind with a DHCP server + */ +static err_t +dhcp_rebind(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + err_t result; + u16_t msecs; + u8_t i; + struct pbuf *p_out; + u16_t options_out_len; + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind()\n")); + dhcp_set_state(dhcp, DHCP_STATE_REBINDING); + + /* create and initialize the DHCP message header */ + p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); + options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN(netif)); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); + for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { + options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); + } + +#if LWIP_NETIF_HOSTNAME + options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); +#endif /* LWIP_NETIF_HOSTNAME */ + + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_REBINDING, msg_out, DHCP_DISCOVER, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + /* broadcast to server */ + result = udp_sendto_if(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif); + pbuf_free(p_out); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind: REBINDING\n")); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_rebind: could not allocate DHCP request\n")); + result = ERR_MEM; + } + if (dhcp->tries < 255) { + dhcp->tries++; + } + msecs = (u16_t)(dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000); + dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_rebind(): set request timeout %"U16_F" msecs\n", msecs)); + return result; +} + +/** + * Enter REBOOTING state to verify an existing lease + * + * @param netif network interface which must reboot + */ +static err_t +dhcp_reboot(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + err_t result; + u16_t msecs; + u8_t i; + struct pbuf *p_out; + u16_t options_out_len; + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_reboot()\n")); + dhcp_set_state(dhcp, DHCP_STATE_REBOOTING); + + /* create and initialize the DHCP message header */ + p_out = dhcp_create_msg(netif, dhcp, DHCP_REQUEST, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_MAX_MSG_SIZE, DHCP_OPTION_MAX_MSG_SIZE_LEN); + options_out_len = dhcp_option_short(options_out_len, msg_out->options, DHCP_MAX_MSG_LEN_MIN_REQUIRED); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_REQUESTED_IP, 4); + options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(&dhcp->offered_ip_addr))); + + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_PARAMETER_REQUEST_LIST, LWIP_ARRAYSIZE(dhcp_discover_request_options)); + for (i = 0; i < LWIP_ARRAYSIZE(dhcp_discover_request_options); i++) { + options_out_len = dhcp_option_byte(options_out_len, msg_out->options, dhcp_discover_request_options[i]); + } + +#if LWIP_NETIF_HOSTNAME + options_out_len = dhcp_option_hostname(options_out_len, msg_out->options, netif); +#endif /* LWIP_NETIF_HOSTNAME */ + + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, DHCP_STATE_REBOOTING, msg_out, DHCP_REQUEST, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + /* broadcast to server */ + result = udp_sendto_if(dhcp_pcb, p_out, IP_ADDR_BROADCAST, LWIP_IANA_PORT_DHCP_SERVER, netif); + pbuf_free(p_out); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_reboot: REBOOTING\n")); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_reboot: could not allocate DHCP request\n")); + result = ERR_MEM; + } + if (dhcp->tries < 255) { + dhcp->tries++; + } + msecs = (u16_t)(dhcp->tries < 10 ? dhcp->tries * 1000 : 10 * 1000); + dhcp->request_timeout = (u16_t)((msecs + DHCP_FINE_TIMER_MSECS - 1) / DHCP_FINE_TIMER_MSECS); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_reboot(): set request timeout %"U16_F" msecs\n", msecs)); + return result; +} + +/** + * @ingroup dhcp4 + * Release a DHCP lease and stop DHCP statemachine (and AUTOIP if LWIP_DHCP_AUTOIP_COOP). + * + * @param netif network interface + */ +void +dhcp_release_and_stop(struct netif *netif) +{ + struct dhcp *dhcp = netif_dhcp_data(netif); + ip_addr_t server_ip_addr; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_release_and_stop()\n")); + if (dhcp == NULL) { + return; + } + + /* already off? -> nothing to do */ + if (dhcp->state == DHCP_STATE_OFF) { + return; + } + + ip_addr_copy(server_ip_addr, dhcp->server_ip_addr); + + /* clean old DHCP offer */ + ip_addr_set_zero_ip4(&dhcp->server_ip_addr); + ip4_addr_set_zero(&dhcp->offered_ip_addr); + ip4_addr_set_zero(&dhcp->offered_sn_mask); + ip4_addr_set_zero(&dhcp->offered_gw_addr); +#if LWIP_DHCP_BOOTP_FILE + ip4_addr_set_zero(&dhcp->offered_si_addr); +#endif /* LWIP_DHCP_BOOTP_FILE */ + dhcp->offered_t0_lease = dhcp->offered_t1_renew = dhcp->offered_t2_rebind = 0; + dhcp->t1_renew_time = dhcp->t2_rebind_time = dhcp->lease_used = dhcp->t0_timeout = 0; + + /* send release message when current IP was assigned via DHCP */ + if (dhcp_supplied_address(netif)) { + /* create and initialize the DHCP message header */ + struct pbuf *p_out; + u16_t options_out_len; + p_out = dhcp_create_msg(netif, dhcp, DHCP_RELEASE, &options_out_len); + if (p_out != NULL) { + struct dhcp_msg *msg_out = (struct dhcp_msg *)p_out->payload; + options_out_len = dhcp_option(options_out_len, msg_out->options, DHCP_OPTION_SERVER_ID, 4); + options_out_len = dhcp_option_long(options_out_len, msg_out->options, lwip_ntohl(ip4_addr_get_u32(ip_2_ip4(&server_ip_addr)))); + + LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, dhcp->state, msg_out, DHCP_RELEASE, &options_out_len); + dhcp_option_trailer(options_out_len, msg_out->options, p_out); + + udp_sendto_if(dhcp_pcb, p_out, &server_ip_addr, LWIP_IANA_PORT_DHCP_SERVER, netif); + pbuf_free(p_out); + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp_release: RELEASED, DHCP_STATE_OFF\n")); + } else { + /* sending release failed, but that's not a problem since the correct behaviour of dhcp does not rely on release */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp_release: could not allocate DHCP request\n")); + } + } + + /* remove IP address from interface (prevents routing from selecting this interface) */ + netif_set_addr(netif, IP4_ADDR_ANY4, IP4_ADDR_ANY4, IP4_ADDR_ANY4); + +#if LWIP_DHCP_AUTOIP_COOP + if (dhcp->autoip_coop_state == DHCP_AUTOIP_COOP_STATE_ON) { + autoip_stop(netif); + dhcp->autoip_coop_state = DHCP_AUTOIP_COOP_STATE_OFF; + } +#endif /* LWIP_DHCP_AUTOIP_COOP */ + + dhcp_set_state(dhcp, DHCP_STATE_OFF); + + if (dhcp->pcb_allocated != 0) { + dhcp_dec_pcb_refcount(); /* free DHCP PCB if not needed any more */ + dhcp->pcb_allocated = 0; + } +} + +/** + * @ingroup dhcp4 + * This function calls dhcp_release_and_stop() internally. + * @deprecated Use dhcp_release_and_stop() instead. + */ +err_t +dhcp_release(struct netif *netif) +{ + dhcp_release_and_stop(netif); + return ERR_OK; +} + +/** + * @ingroup dhcp4 + * This function calls dhcp_release_and_stop() internally. + * @deprecated Use dhcp_release_and_stop() instead. + */ +void +dhcp_stop(struct netif *netif) +{ + dhcp_release_and_stop(netif); +} + +/* + * Set the DHCP state of a DHCP client. + * + * If the state changed, reset the number of tries. + */ +static void +dhcp_set_state(struct dhcp *dhcp, u8_t new_state) +{ + if (new_state != dhcp->state) { + dhcp->state = new_state; + dhcp->tries = 0; + dhcp->request_timeout = 0; + } +} + +/* + * Concatenate an option type and length field to the outgoing + * DHCP message. + * + */ +static u16_t +dhcp_option(u16_t options_out_len, u8_t *options, u8_t option_type, u8_t option_len) +{ + LWIP_ASSERT("dhcp_option: options_out_len + 2 + option_len <= DHCP_OPTIONS_LEN", options_out_len + 2U + option_len <= DHCP_OPTIONS_LEN); + options[options_out_len++] = option_type; + options[options_out_len++] = option_len; + return options_out_len; +} +/* + * Concatenate a single byte to the outgoing DHCP message. + * + */ +static u16_t +dhcp_option_byte(u16_t options_out_len, u8_t *options, u8_t value) +{ + LWIP_ASSERT("dhcp_option_byte: options_out_len < DHCP_OPTIONS_LEN", options_out_len < DHCP_OPTIONS_LEN); + options[options_out_len++] = value; + return options_out_len; +} + +static u16_t +dhcp_option_short(u16_t options_out_len, u8_t *options, u16_t value) +{ + LWIP_ASSERT("dhcp_option_short: options_out_len + 2 <= DHCP_OPTIONS_LEN", options_out_len + 2U <= DHCP_OPTIONS_LEN); + options[options_out_len++] = (u8_t)((value & 0xff00U) >> 8); + options[options_out_len++] = (u8_t) (value & 0x00ffU); + return options_out_len; +} + +static u16_t +dhcp_option_long(u16_t options_out_len, u8_t *options, u32_t value) +{ + LWIP_ASSERT("dhcp_option_long: options_out_len + 4 <= DHCP_OPTIONS_LEN", options_out_len + 4U <= DHCP_OPTIONS_LEN); + options[options_out_len++] = (u8_t)((value & 0xff000000UL) >> 24); + options[options_out_len++] = (u8_t)((value & 0x00ff0000UL) >> 16); + options[options_out_len++] = (u8_t)((value & 0x0000ff00UL) >> 8); + options[options_out_len++] = (u8_t)((value & 0x000000ffUL)); + return options_out_len; +} + +#if LWIP_NETIF_HOSTNAME +static u16_t +dhcp_option_hostname(u16_t options_out_len, u8_t *options, struct netif *netif) +{ + if (netif->hostname != NULL) { + size_t namelen = strlen(netif->hostname); + if (namelen > 0) { + size_t len; + const char *p = netif->hostname; + /* Shrink len to available bytes (need 2 bytes for OPTION_HOSTNAME + and 1 byte for trailer) */ + size_t available = DHCP_OPTIONS_LEN - options_out_len - 3; + LWIP_ASSERT("DHCP: hostname is too long!", namelen <= available); + len = LWIP_MIN(namelen, available); + LWIP_ASSERT("DHCP: hostname is too long!", len <= 0xFF); + options_out_len = dhcp_option(options_out_len, options, DHCP_OPTION_HOSTNAME, (u8_t)len); + while (len--) { + options_out_len = dhcp_option_byte(options_out_len, options, *p++); + } + } + } + return options_out_len; +} +#endif /* LWIP_NETIF_HOSTNAME */ + +/** + * Extract the DHCP message and the DHCP options. + * + * Extract the DHCP message and the DHCP options, each into a contiguous + * piece of memory. As a DHCP message is variable sized by its options, + * and also allows overriding some fields for options, the easy approach + * is to first unfold the options into a contiguous piece of memory, and + * use that further on. + * + */ +static err_t +dhcp_parse_reply(struct pbuf *p, struct dhcp *dhcp) +{ + u8_t *options; + u16_t offset; + u16_t offset_max; + u16_t options_idx; + u16_t options_idx_max; + struct pbuf *q; + int parse_file_as_options = 0; + int parse_sname_as_options = 0; + struct dhcp_msg *msg_in; +#if LWIP_DHCP_BOOTP_FILE + int file_overloaded = 0; +#endif + + LWIP_UNUSED_ARG(dhcp); + + /* clear received options */ + dhcp_clear_all_options(dhcp); + /* check that beginning of dhcp_msg (up to and including chaddr) is in first pbuf */ + if (p->len < DHCP_SNAME_OFS) { + return ERR_BUF; + } + msg_in = (struct dhcp_msg *)p->payload; +#if LWIP_DHCP_BOOTP_FILE + /* clear boot file name */ + dhcp->boot_file_name[0] = 0; +#endif /* LWIP_DHCP_BOOTP_FILE */ + + /* parse options */ + + /* start with options field */ + options_idx = DHCP_OPTIONS_OFS; + /* parse options to the end of the received packet */ + options_idx_max = p->tot_len; +again: + q = p; + while ((q != NULL) && (options_idx >= q->len)) { + options_idx = (u16_t)(options_idx - q->len); + options_idx_max = (u16_t)(options_idx_max - q->len); + q = q->next; + } + if (q == NULL) { + return ERR_BUF; + } + offset = options_idx; + offset_max = options_idx_max; + options = (u8_t *)q->payload; + /* at least 1 byte to read and no end marker, then at least 3 bytes to read? */ + while ((q != NULL) && (offset < offset_max) && (options[offset] != DHCP_OPTION_END)) { + u8_t op = options[offset]; + u8_t len; + u8_t decode_len = 0; + int decode_idx = -1; + u16_t val_offset = (u16_t)(offset + 2); + if (val_offset < offset) { + /* overflow */ + return ERR_BUF; + } + /* len byte might be in the next pbuf */ + if ((offset + 1) < q->len) { + len = options[offset + 1]; + } else { + len = (q->next != NULL ? ((u8_t *)q->next->payload)[0] : 0); + } + /* LWIP_DEBUGF(DHCP_DEBUG, ("msg_offset=%"U16_F", q->len=%"U16_F, msg_offset, q->len)); */ + decode_len = len; + switch (op) { + /* case(DHCP_OPTION_END): handled above */ + case (DHCP_OPTION_PAD): + /* special option: no len encoded */ + decode_len = len = 0; + /* will be increased below */ + break; + case (DHCP_OPTION_SUBNET_MASK): + LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_SUBNET_MASK; + break; + case (DHCP_OPTION_ROUTER): + decode_len = 4; /* only copy the first given router */ + LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_ROUTER; + break; +#if LWIP_DHCP_PROVIDE_DNS_SERVERS + case (DHCP_OPTION_DNS_SERVER): + /* special case: there might be more than one server */ + LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;); + /* limit number of DNS servers */ + decode_len = LWIP_MIN(len, 4 * DNS_MAX_SERVERS); + LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_DNS_SERVER; + break; +#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ + case (DHCP_OPTION_LEASE_TIME): + LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_LEASE_TIME; + break; +#if LWIP_DHCP_GET_NTP_SRV + case (DHCP_OPTION_NTP): + /* special case: there might be more than one server */ + LWIP_ERROR("len %% 4 == 0", len % 4 == 0, return ERR_VAL;); + /* limit number of NTP servers */ + decode_len = LWIP_MIN(len, 4 * LWIP_DHCP_MAX_NTP_SERVERS); + LWIP_ERROR("len >= decode_len", len >= decode_len, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_NTP_SERVER; + break; +#endif /* LWIP_DHCP_GET_NTP_SRV*/ + case (DHCP_OPTION_OVERLOAD): + LWIP_ERROR("len == 1", len == 1, return ERR_VAL;); + /* decode overload only in options, not in file/sname: invalid packet */ + LWIP_ERROR("overload in file/sname", options_idx == DHCP_OPTIONS_OFS, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_OVERLOAD; + break; + case (DHCP_OPTION_MESSAGE_TYPE): + LWIP_ERROR("len == 1", len == 1, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_MSG_TYPE; + break; + case (DHCP_OPTION_SERVER_ID): + LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_SERVER_ID; + break; + case (DHCP_OPTION_T1): + LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_T1; + break; + case (DHCP_OPTION_T2): + LWIP_ERROR("len == 4", len == 4, return ERR_VAL;); + decode_idx = DHCP_OPTION_IDX_T2; + break; + default: + decode_len = 0; + LWIP_DEBUGF(DHCP_DEBUG, ("skipping option %"U16_F" in options\n", (u16_t)op)); + LWIP_HOOK_DHCP_PARSE_OPTION(ip_current_netif(), dhcp, dhcp->state, msg_in, + dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) ? (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) : 0, + op, len, q, val_offset); + break; + } + if (op == DHCP_OPTION_PAD) { + offset++; + } else { + if (offset + len + 2 > 0xFFFF) { + /* overflow */ + return ERR_BUF; + } + offset = (u16_t)(offset + len + 2); + if (decode_len > 0) { + u32_t value = 0; + u16_t copy_len; +decode_next: + LWIP_ASSERT("check decode_idx", decode_idx >= 0 && decode_idx < DHCP_OPTION_IDX_MAX); + if (!dhcp_option_given(dhcp, decode_idx)) { + copy_len = LWIP_MIN(decode_len, 4); + if (pbuf_copy_partial(q, &value, copy_len, val_offset) != copy_len) { + return ERR_BUF; + } + if (decode_len > 4) { + /* decode more than one u32_t */ + u16_t next_val_offset; + LWIP_ERROR("decode_len %% 4 == 0", decode_len % 4 == 0, return ERR_VAL;); + dhcp_got_option(dhcp, decode_idx); + dhcp_set_option_value(dhcp, decode_idx, lwip_htonl(value)); + decode_len = (u8_t)(decode_len - 4); + next_val_offset = (u16_t)(val_offset + 4); + if (next_val_offset < val_offset) { + /* overflow */ + return ERR_BUF; + } + val_offset = next_val_offset; + decode_idx++; + goto decode_next; + } else if (decode_len == 4) { + value = lwip_ntohl(value); + } else { + LWIP_ERROR("invalid decode_len", decode_len == 1, return ERR_VAL;); + value = ((u8_t *)&value)[0]; + } + dhcp_got_option(dhcp, decode_idx); + dhcp_set_option_value(dhcp, decode_idx, value); + } + } + } + if (offset >= q->len) { + offset = (u16_t)(offset - q->len); + offset_max = (u16_t)(offset_max - q->len); + if (offset < offset_max) { + q = q->next; + LWIP_ERROR("next pbuf was null", q != NULL, return ERR_VAL;); + options = (u8_t *)q->payload; + } else { + /* We've run out of bytes, probably no end marker. Don't proceed. */ + return ERR_BUF; + } + } + } + /* is this an overloaded message? */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_OVERLOAD)) { + u32_t overload = dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_OVERLOAD); + dhcp_clear_option(dhcp, DHCP_OPTION_IDX_OVERLOAD); + if (overload == DHCP_OVERLOAD_FILE) { + parse_file_as_options = 1; + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("overloaded file field\n")); + } else if (overload == DHCP_OVERLOAD_SNAME) { + parse_sname_as_options = 1; + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("overloaded sname field\n")); + } else if (overload == DHCP_OVERLOAD_SNAME_FILE) { + parse_sname_as_options = 1; + parse_file_as_options = 1; + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("overloaded sname and file field\n")); + } else { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("invalid overload option: %d\n", (int)overload)); + } + } + if (parse_file_as_options) { + /* if both are overloaded, parse file first and then sname (RFC 2131 ch. 4.1) */ + parse_file_as_options = 0; + options_idx = DHCP_FILE_OFS; + options_idx_max = DHCP_FILE_OFS + DHCP_FILE_LEN; +#if LWIP_DHCP_BOOTP_FILE + file_overloaded = 1; +#endif + goto again; + } else if (parse_sname_as_options) { + parse_sname_as_options = 0; + options_idx = DHCP_SNAME_OFS; + options_idx_max = DHCP_SNAME_OFS + DHCP_SNAME_LEN; + goto again; + } +#if LWIP_DHCP_BOOTP_FILE + if (!file_overloaded) { + /* only do this for ACK messages */ + if (dhcp_option_given(dhcp, DHCP_OPTION_IDX_MSG_TYPE) && + (dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE) == DHCP_ACK)) + /* copy bootp file name, don't care for sname (server hostname) */ + if (pbuf_copy_partial(p, dhcp->boot_file_name, DHCP_FILE_LEN-1, DHCP_FILE_OFS) != (DHCP_FILE_LEN-1)) { + return ERR_BUF; + } + /* make sure the string is really NULL-terminated */ + dhcp->boot_file_name[DHCP_FILE_LEN-1] = 0; + } +#endif /* LWIP_DHCP_BOOTP_FILE */ + return ERR_OK; +} + +/** + * If an incoming DHCP message is in response to us, then trigger the state machine + */ +static void +dhcp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + struct netif *netif = ip_current_input_netif(); + struct dhcp *dhcp = netif_dhcp_data(netif); + struct dhcp_msg *reply_msg = (struct dhcp_msg *)p->payload; + u8_t msg_type; + u8_t i; + struct dhcp_msg *msg_in; + + LWIP_UNUSED_ARG(arg); + + /* Caught DHCP message from netif that does not have DHCP enabled? -> not interested */ + if ((dhcp == NULL) || (dhcp->pcb_allocated == 0)) { + goto free_pbuf_and_return; + } + + LWIP_ASSERT("invalid server address type", IP_IS_V4(addr)); + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp_recv(pbuf = %p) from DHCP server %"U16_F".%"U16_F".%"U16_F".%"U16_F" port %"U16_F"\n", (void *)p, + ip4_addr1_16(ip_2_ip4(addr)), ip4_addr2_16(ip_2_ip4(addr)), ip4_addr3_16(ip_2_ip4(addr)), ip4_addr4_16(ip_2_ip4(addr)), port)); + 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); + + if (p->len < DHCP_MIN_REPLY_LEN) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("DHCP reply message or pbuf too short\n")); + goto free_pbuf_and_return; + } + + if (reply_msg->op != DHCP_BOOTREPLY) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("not a DHCP reply message, but type %"U16_F"\n", (u16_t)reply_msg->op)); + goto free_pbuf_and_return; + } + /* iterate through hardware address and match against DHCP message */ + for (i = 0; i < netif->hwaddr_len && i < LWIP_MIN(DHCP_CHADDR_LEN, NETIF_MAX_HWADDR_LEN); i++) { + if (netif->hwaddr[i] != reply_msg->chaddr[i]) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, + ("netif->hwaddr[%"U16_F"]==%02"X16_F" != reply_msg->chaddr[%"U16_F"]==%02"X16_F"\n", + (u16_t)i, (u16_t)netif->hwaddr[i], (u16_t)i, (u16_t)reply_msg->chaddr[i])); + goto free_pbuf_and_return; + } + } + /* match transaction ID against what we expected */ + if (lwip_ntohl(reply_msg->xid) != dhcp->xid) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, + ("transaction id mismatch reply_msg->xid(%"X32_F")!=dhcp->xid(%"X32_F")\n", lwip_ntohl(reply_msg->xid), dhcp->xid)); + goto free_pbuf_and_return; + } + /* option fields could be unfold? */ + if (dhcp_parse_reply(p, dhcp) != ERR_OK) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("problem unfolding DHCP message - too short on memory?\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 (!dhcp_option_given(dhcp, 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; + } + + msg_in = (struct dhcp_msg *)p->payload; + /* read DHCP message type */ + msg_type = (u8_t)dhcp_get_option_value(dhcp, DHCP_OPTION_IDX_MSG_TYPE); + /* message type is DHCP ACK? */ + if (msg_type == DHCP_ACK) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_ACK received\n")); + /* in requesting state? */ + if (dhcp->state == DHCP_STATE_REQUESTING) { + dhcp_handle_ack(netif, msg_in); +#if DHCP_DOES_ARP_CHECK + if ((netif->flags & NETIF_FLAG_ETHARP) != 0) { + /* check if the acknowledged lease address is already in use */ + dhcp_check(netif); + } else { + /* bind interface to the acknowledged lease address */ + dhcp_bind(netif); + } +#else + /* bind interface to the acknowledged lease address */ + dhcp_bind(netif); +#endif + } + /* already bound to the given lease address? */ + else if ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REBINDING) || + (dhcp->state == DHCP_STATE_RENEWING)) { + dhcp_handle_ack(netif, msg_in); + dhcp_bind(netif); + } + } + /* received a DHCP_NAK in appropriate state? */ + else if ((msg_type == DHCP_NAK) && + ((dhcp->state == DHCP_STATE_REBOOTING) || (dhcp->state == DHCP_STATE_REQUESTING) || + (dhcp->state == DHCP_STATE_REBINDING) || (dhcp->state == DHCP_STATE_RENEWING ))) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_NAK received\n")); + dhcp_handle_nak(netif); + } + /* received a DHCP_OFFER in DHCP_STATE_SELECTING state? */ + else if ((msg_type == DHCP_OFFER) && (dhcp->state == DHCP_STATE_SELECTING)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("DHCP_OFFER received in DHCP_STATE_SELECTING state\n")); + /* remember offered lease */ + dhcp_handle_offer(netif, msg_in); + } + +free_pbuf_and_return: + pbuf_free(p); +} + +/** + * Create a DHCP request, fill in common headers + * + * @param netif the netif under DHCP control + * @param dhcp dhcp control struct + * @param message_type message type of the request + */ +static struct pbuf * +dhcp_create_msg(struct netif *netif, struct dhcp *dhcp, u8_t message_type, u16_t *options_out_len) +{ + u16_t i; + struct pbuf *p_out; + struct dhcp_msg *msg_out; + u16_t options_out_len_loc; + +#ifndef DHCP_GLOBAL_XID + /** default global transaction identifier starting value (easy to match + * with a packet analyser). We simply increment for each new request. + * Predefine DHCP_GLOBAL_XID to a better value or a function call to generate one + * at runtime, any supporting function prototypes can be defined in DHCP_GLOBAL_XID_HEADER */ +#if DHCP_CREATE_RAND_XID && defined(LWIP_RAND) + static u32_t xid; +#else /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ + static u32_t xid = 0xABCD0000; +#endif /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ +#else + if (!xid_initialised) { + xid = DHCP_GLOBAL_XID; + xid_initialised = !xid_initialised; + } +#endif + LWIP_ERROR("dhcp_create_msg: netif != NULL", (netif != NULL), return NULL;); + LWIP_ERROR("dhcp_create_msg: dhcp != NULL", (dhcp != NULL), return NULL;); + p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp_msg), PBUF_RAM); + if (p_out == NULL) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("dhcp_create_msg(): could not allocate pbuf\n")); + return NULL; + } + LWIP_ASSERT("dhcp_create_msg: check that first pbuf can hold struct dhcp_msg", + (p_out->len >= sizeof(struct dhcp_msg))); + + /* DHCP_REQUEST should reuse 'xid' from DHCPOFFER */ + if ((message_type != DHCP_REQUEST) || (dhcp->state == DHCP_STATE_REBOOTING)) { + /* reuse transaction identifier in retransmissions */ + if (dhcp->tries == 0) { +#if DHCP_CREATE_RAND_XID && defined(LWIP_RAND) + xid = LWIP_RAND(); +#else /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ + xid++; +#endif /* DHCP_CREATE_RAND_XID && defined(LWIP_RAND) */ + } + dhcp->xid = xid; + } + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, + ("transaction id xid(%"X32_F")\n", xid)); + + msg_out = (struct dhcp_msg *)p_out->payload; + memset(msg_out, 0, sizeof(struct dhcp_msg)); + + msg_out->op = DHCP_BOOTREQUEST; + /* @todo: make link layer independent */ + msg_out->htype = LWIP_IANA_HWTYPE_ETHERNET; + msg_out->hlen = netif->hwaddr_len; + msg_out->xid = lwip_htonl(dhcp->xid); + /* we don't need the broadcast flag since we can receive unicast traffic + before being fully configured! */ + /* set ciaddr to netif->ip_addr based on message_type and state */ + if ((message_type == DHCP_INFORM) || (message_type == DHCP_DECLINE) || (message_type == DHCP_RELEASE) || + ((message_type == DHCP_REQUEST) && /* DHCP_STATE_BOUND not used for sending! */ + ((dhcp->state == DHCP_STATE_RENEWING) || dhcp->state == DHCP_STATE_REBINDING))) { + ip4_addr_copy(msg_out->ciaddr, *netif_ip4_addr(netif)); + } + for (i = 0; i < LWIP_MIN(DHCP_CHADDR_LEN, NETIF_MAX_HWADDR_LEN); i++) { + /* copy netif hardware address (padded with zeroes through memset already) */ + msg_out->chaddr[i] = netif->hwaddr[i]; + } + msg_out->cookie = PP_HTONL(DHCP_MAGIC_COOKIE); + /* Add option MESSAGE_TYPE */ + options_out_len_loc = dhcp_option(0, msg_out->options, DHCP_OPTION_MESSAGE_TYPE, DHCP_OPTION_MESSAGE_TYPE_LEN); + options_out_len_loc = dhcp_option_byte(options_out_len_loc, msg_out->options, message_type); + if (options_out_len) { + *options_out_len = options_out_len_loc; + } + return p_out; +} + +/** + * Add a DHCP message trailer + * + * Adds the END option to the DHCP message, and if + * necessary, up to three padding bytes. + */ +static void +dhcp_option_trailer(u16_t options_out_len, u8_t *options, struct pbuf *p_out) +{ + options[options_out_len++] = DHCP_OPTION_END; + /* packet is too small, or not 4 byte aligned? */ + while (((options_out_len < DHCP_MIN_OPTIONS_LEN) || (options_out_len & 3)) && + (options_out_len < DHCP_OPTIONS_LEN)) { + /* add a fill/padding byte */ + options[options_out_len++] = 0; + } + /* shrink the pbuf to the actual content length */ + pbuf_realloc(p_out, (u16_t)(sizeof(struct dhcp_msg) - DHCP_OPTIONS_LEN + options_out_len)); +} + +/** check if DHCP supplied netif->ip_addr + * + * @param netif the netif to check + * @return 1 if DHCP supplied netif->ip_addr (states BOUND or RENEWING), + * 0 otherwise + */ +u8_t +dhcp_supplied_address(const struct netif *netif) +{ + if ((netif != NULL) && (netif_dhcp_data(netif) != NULL)) { + struct dhcp *dhcp = netif_dhcp_data(netif); + return (dhcp->state == DHCP_STATE_BOUND) || (dhcp->state == DHCP_STATE_RENEWING) || + (dhcp->state == DHCP_STATE_REBINDING); + } + return 0; +} + +#endif /* LWIP_IPV4 && LWIP_DHCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/etharp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/etharp.c index 94ef3449..2e358eff 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/etharp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/etharp.c @@ -1,1204 +1,1204 @@ -/** - * @file - * Address Resolution Protocol module for IP over Ethernet - * - * Functionally, ARP is divided into two parts. The first maps an IP address - * to a physical address when sending a packet, and the second part answers - * requests from other machines for our physical address. - * - * This implementation complies with RFC 826 (Ethernet ARP). It supports - * Gratuitious ARP from RFC3220 (IP Mobility Support for IPv4) section 4.6 - * if an interface calls etharp_gratuitous(our_netif) upon address change. - */ - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * Copyright (c) 2003-2004 Leon Woestenberg - * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 && LWIP_ARP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/etharp.h" -#include "lwip/stats.h" -#include "lwip/snmp.h" -#include "lwip/dhcp.h" -#include "lwip/autoip.h" -#include "lwip/prot/iana.h" -#include "netif/ethernet.h" - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -/** Re-request a used ARP entry 1 minute before it would expire to prevent - * breaking a steadily used connection because the ARP entry timed out. */ -#define ARP_AGE_REREQUEST_USED_UNICAST (ARP_MAXAGE - 30) -#define ARP_AGE_REREQUEST_USED_BROADCAST (ARP_MAXAGE - 15) - -/** the time an ARP entry stays pending after first request, - * for ARP_TMR_INTERVAL = 1000, this is - * 10 seconds. - * - * @internal Keep this number at least 2, otherwise it might - * run out instantly if the timeout occurs directly after a request. - */ -#define ARP_MAXPENDING 5 - -/** ARP states */ -enum etharp_state { - ETHARP_STATE_EMPTY = 0, - ETHARP_STATE_PENDING, - ETHARP_STATE_STABLE, - ETHARP_STATE_STABLE_REREQUESTING_1, - ETHARP_STATE_STABLE_REREQUESTING_2 -#if ETHARP_SUPPORT_STATIC_ENTRIES - , ETHARP_STATE_STATIC -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ -}; - -struct etharp_entry { -#if ARP_QUEUEING - /** Pointer to queue of pending outgoing packets on this ARP entry. */ - struct etharp_q_entry *q; -#else /* ARP_QUEUEING */ - /** Pointer to a single pending outgoing packet on this ARP entry. */ - struct pbuf *q; -#endif /* ARP_QUEUEING */ - ip4_addr_t ipaddr; - struct netif *netif; - struct eth_addr ethaddr; - u16_t ctime; - u8_t state; -}; - -static struct etharp_entry arp_table[ARP_TABLE_SIZE]; - -#if !LWIP_NETIF_HWADDRHINT -static netif_addr_idx_t etharp_cached_entry; -#endif /* !LWIP_NETIF_HWADDRHINT */ - -/** Try hard to create a new entry - we want the IP address to appear in - the cache (even if this means removing an active entry or so). */ -#define ETHARP_FLAG_TRY_HARD 1 -#define ETHARP_FLAG_FIND_ONLY 2 -#if ETHARP_SUPPORT_STATIC_ENTRIES -#define ETHARP_FLAG_STATIC_ENTRY 4 -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ - -#if LWIP_NETIF_HWADDRHINT -#define ETHARP_SET_ADDRHINT(netif, addrhint) do { if (((netif) != NULL) && ((netif)->hints != NULL)) { \ - (netif)->hints->addr_hint = (addrhint); }} while(0) -#else /* LWIP_NETIF_HWADDRHINT */ -#define ETHARP_SET_ADDRHINT(netif, addrhint) (etharp_cached_entry = (addrhint)) -#endif /* LWIP_NETIF_HWADDRHINT */ - - -/* Check for maximum ARP_TABLE_SIZE */ -#if (ARP_TABLE_SIZE > NETIF_ADDR_IDX_MAX) -#error "ARP_TABLE_SIZE must fit in an s16_t, you have to reduce it in your lwipopts.h" -#endif - - -static err_t etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr *hw_dst_addr); -static err_t etharp_raw(struct netif *netif, - const struct eth_addr *ethsrc_addr, const struct eth_addr *ethdst_addr, - const struct eth_addr *hwsrc_addr, const ip4_addr_t *ipsrc_addr, - const struct eth_addr *hwdst_addr, const ip4_addr_t *ipdst_addr, - const u16_t opcode); - -#if ARP_QUEUEING -/** - * Free a complete queue of etharp entries - * - * @param q a qeueue of etharp_q_entry's to free - */ -static void -free_etharp_q(struct etharp_q_entry *q) -{ - struct etharp_q_entry *r; - LWIP_ASSERT("q != NULL", q != NULL); - while (q) { - r = q; - q = q->next; - LWIP_ASSERT("r->p != NULL", (r->p != NULL)); - pbuf_free(r->p); - memp_free(MEMP_ARP_QUEUE, r); - } -} -#else /* ARP_QUEUEING */ - -/** Compatibility define: free the queued pbuf */ -#define free_etharp_q(q) pbuf_free(q) - -#endif /* ARP_QUEUEING */ - -/** Clean up ARP table entries */ -static void -etharp_free_entry(int i) -{ - /* remove from SNMP ARP index tree */ - mib2_remove_arp_entry(arp_table[i].netif, &arp_table[i].ipaddr); - /* and empty packet queue */ - if (arp_table[i].q != NULL) { - /* remove all queued packets */ - LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_free_entry: freeing entry %"U16_F", packet queue %p.\n", (u16_t)i, (void *)(arp_table[i].q))); - free_etharp_q(arp_table[i].q); - arp_table[i].q = NULL; - } - /* recycle entry for re-use */ - arp_table[i].state = ETHARP_STATE_EMPTY; -#ifdef LWIP_DEBUG - /* for debugging, clean out the complete entry */ - arp_table[i].ctime = 0; - arp_table[i].netif = NULL; - ip4_addr_set_zero(&arp_table[i].ipaddr); - arp_table[i].ethaddr = ethzero; -#endif /* LWIP_DEBUG */ -} - -/** - * Clears expired entries in the ARP table. - * - * This function should be called every ARP_TMR_INTERVAL milliseconds (1 second), - * in order to expire entries in the ARP table. - */ -void -etharp_tmr(void) -{ - int i; - - LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer\n")); - /* remove expired entries from the ARP table */ - for (i = 0; i < ARP_TABLE_SIZE; ++i) { - u8_t state = arp_table[i].state; - if (state != ETHARP_STATE_EMPTY -#if ETHARP_SUPPORT_STATIC_ENTRIES - && (state != ETHARP_STATE_STATIC) -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ - ) { - arp_table[i].ctime++; - if ((arp_table[i].ctime >= ARP_MAXAGE) || - ((arp_table[i].state == ETHARP_STATE_PENDING) && - (arp_table[i].ctime >= ARP_MAXPENDING))) { - /* pending or stable entry has become old! */ - LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired %s entry %d.\n", - arp_table[i].state >= ETHARP_STATE_STABLE ? "stable" : "pending", i)); - /* clean up entries that have just been expired */ - etharp_free_entry(i); - } else if (arp_table[i].state == ETHARP_STATE_STABLE_REREQUESTING_1) { - /* Don't send more than one request every 2 seconds. */ - arp_table[i].state = ETHARP_STATE_STABLE_REREQUESTING_2; - } else if (arp_table[i].state == ETHARP_STATE_STABLE_REREQUESTING_2) { - /* Reset state to stable, so that the next transmitted packet will - re-send an ARP request. */ - arp_table[i].state = ETHARP_STATE_STABLE; - } else if (arp_table[i].state == ETHARP_STATE_PENDING) { - /* still pending, resend an ARP query */ - etharp_request(arp_table[i].netif, &arp_table[i].ipaddr); - } - } - } -} - -/** - * Search the ARP table for a matching or new entry. - * - * If an IP address is given, return a pending or stable ARP entry that matches - * the address. If no match is found, create a new entry with this address set, - * but in state ETHARP_EMPTY. The caller must check and possibly change the - * state of the returned entry. - * - * If ipaddr is NULL, return a initialized new entry in state ETHARP_EMPTY. - * - * In all cases, attempt to create new entries from an empty entry. If no - * empty entries are available and ETHARP_FLAG_TRY_HARD flag is set, recycle - * old entries. Heuristic choose the least important entry for recycling. - * - * @param ipaddr IP address to find in ARP cache, or to add if not found. - * @param flags See @ref etharp_state - * @param netif netif related to this address (used for NETIF_HWADDRHINT) - * - * @return The ARP entry index that matched or is created, ERR_MEM if no - * entry is found or could be recycled. - */ -static s16_t -etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif *netif) -{ - s16_t old_pending = ARP_TABLE_SIZE, old_stable = ARP_TABLE_SIZE; - s16_t empty = ARP_TABLE_SIZE; - s16_t i = 0; - /* oldest entry with packets on queue */ - s16_t old_queue = ARP_TABLE_SIZE; - /* its age */ - u16_t age_queue = 0, age_pending = 0, age_stable = 0; - - LWIP_UNUSED_ARG(netif); - - /** - * a) do a search through the cache, remember candidates - * b) select candidate entry - * c) create new entry - */ - - /* a) in a single search sweep, do all of this - * 1) remember the first empty entry (if any) - * 2) remember the oldest stable entry (if any) - * 3) remember the oldest pending entry without queued packets (if any) - * 4) remember the oldest pending entry with queued packets (if any) - * 5) search for a matching IP entry, either pending or stable - * until 5 matches, or all entries are searched for. - */ - - for (i = 0; i < ARP_TABLE_SIZE; ++i) { - u8_t state = arp_table[i].state; - /* no empty entry found yet and now we do find one? */ - if ((empty == ARP_TABLE_SIZE) && (state == ETHARP_STATE_EMPTY)) { - LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_find_entry: found empty entry %d\n", (int)i)); - /* remember first empty entry */ - empty = i; - } else if (state != ETHARP_STATE_EMPTY) { - LWIP_ASSERT("state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE", - state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE); - /* if given, does IP address match IP address in ARP entry? */ - if (ipaddr && ip4_addr_cmp(ipaddr, &arp_table[i].ipaddr) -#if ETHARP_TABLE_MATCH_NETIF - && ((netif == NULL) || (netif == arp_table[i].netif)) -#endif /* ETHARP_TABLE_MATCH_NETIF */ - ) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: found matching entry %d\n", (int)i)); - /* found exact IP address match, simply bail out */ - return i; - } - /* pending entry? */ - if (state == ETHARP_STATE_PENDING) { - /* pending with queued packets? */ - if (arp_table[i].q != NULL) { - if (arp_table[i].ctime >= age_queue) { - old_queue = i; - age_queue = arp_table[i].ctime; - } - } else - /* pending without queued packets? */ - { - if (arp_table[i].ctime >= age_pending) { - old_pending = i; - age_pending = arp_table[i].ctime; - } - } - /* stable entry? */ - } else if (state >= ETHARP_STATE_STABLE) { -#if ETHARP_SUPPORT_STATIC_ENTRIES - /* don't record old_stable for static entries since they never expire */ - if (state < ETHARP_STATE_STATIC) -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ - { - /* remember entry with oldest stable entry in oldest, its age in maxtime */ - if (arp_table[i].ctime >= age_stable) { - old_stable = i; - age_stable = arp_table[i].ctime; - } - } - } - } - } - /* { we have no match } => try to create a new entry */ - - /* don't create new entry, only search? */ - if (((flags & ETHARP_FLAG_FIND_ONLY) != 0) || - /* or no empty entry found and not allowed to recycle? */ - ((empty == ARP_TABLE_SIZE) && ((flags & ETHARP_FLAG_TRY_HARD) == 0))) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: no empty entry found and not allowed to recycle\n")); - return (s16_t)ERR_MEM; - } - - /* b) choose the least destructive entry to recycle: - * 1) empty entry - * 2) oldest stable entry - * 3) oldest pending entry without queued packets - * 4) oldest pending entry with queued packets - * - * { ETHARP_FLAG_TRY_HARD is set at this point } - */ - - /* 1) empty entry available? */ - if (empty < ARP_TABLE_SIZE) { - i = empty; - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting empty entry %d\n", (int)i)); - } else { - /* 2) found recyclable stable entry? */ - if (old_stable < ARP_TABLE_SIZE) { - /* recycle oldest stable*/ - i = old_stable; - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest stable entry %d\n", (int)i)); - /* no queued packets should exist on stable entries */ - LWIP_ASSERT("arp_table[i].q == NULL", arp_table[i].q == NULL); - /* 3) found recyclable pending entry without queued packets? */ - } else if (old_pending < ARP_TABLE_SIZE) { - /* recycle oldest pending */ - i = old_pending; - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %d (without queue)\n", (int)i)); - /* 4) found recyclable pending entry with queued packets? */ - } else if (old_queue < ARP_TABLE_SIZE) { - /* recycle oldest pending (queued packets are free in etharp_free_entry) */ - i = old_queue; - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %d, freeing packet queue %p\n", (int)i, (void *)(arp_table[i].q))); - /* no empty or recyclable entries found */ - } else { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: no empty or recyclable entries found\n")); - return (s16_t)ERR_MEM; - } - - /* { empty or recyclable entry found } */ - LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE); - etharp_free_entry(i); - } - - LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE); - LWIP_ASSERT("arp_table[i].state == ETHARP_STATE_EMPTY", - arp_table[i].state == ETHARP_STATE_EMPTY); - - /* IP address given? */ - if (ipaddr != NULL) { - /* set IP address */ - ip4_addr_copy(arp_table[i].ipaddr, *ipaddr); - } - arp_table[i].ctime = 0; -#if ETHARP_TABLE_MATCH_NETIF - arp_table[i].netif = netif; -#endif /* ETHARP_TABLE_MATCH_NETIF */ - return (s16_t)i; -} - -/** - * Update (or insert) a IP/MAC address pair in the ARP cache. - * - * If a pending entry is resolved, any queued packets will be sent - * at this point. - * - * @param netif netif related to this entry (used for NETIF_ADDRHINT) - * @param ipaddr IP address of the inserted ARP entry. - * @param ethaddr Ethernet address of the inserted ARP entry. - * @param flags See @ref etharp_state - * - * @return - * - ERR_OK Successfully updated ARP cache. - * - ERR_MEM If we could not add a new ARP entry when ETHARP_FLAG_TRY_HARD was set. - * - ERR_ARG Non-unicast address given, those will not appear in ARP cache. - * - * @see pbuf_free() - */ -static err_t -etharp_update_arp_entry(struct netif *netif, const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, u8_t flags) -{ - s16_t i; - LWIP_ASSERT("netif->hwaddr_len == ETH_HWADDR_LEN", netif->hwaddr_len == ETH_HWADDR_LEN); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_update_arp_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n", - ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr), - (u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2], - (u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5])); - /* non-unicast address? */ - if (ip4_addr_isany(ipaddr) || - ip4_addr_isbroadcast(ipaddr, netif) || - ip4_addr_ismulticast(ipaddr)) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_update_arp_entry: will not add non-unicast IP address to ARP cache\n")); - return ERR_ARG; - } - /* find or create ARP entry */ - i = etharp_find_entry(ipaddr, flags, netif); - /* bail out if no entry could be found */ - if (i < 0) { - return (err_t)i; - } - -#if ETHARP_SUPPORT_STATIC_ENTRIES - if (flags & ETHARP_FLAG_STATIC_ENTRY) { - /* record static type */ - arp_table[i].state = ETHARP_STATE_STATIC; - } else if (arp_table[i].state == ETHARP_STATE_STATIC) { - /* found entry is a static type, don't overwrite it */ - return ERR_VAL; - } else -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ - { - /* mark it stable */ - arp_table[i].state = ETHARP_STATE_STABLE; - } - - /* record network interface */ - arp_table[i].netif = netif; - /* insert in SNMP ARP index tree */ - mib2_add_arp_entry(netif, &arp_table[i].ipaddr); - - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_update_arp_entry: updating stable entry %"S16_F"\n", i)); - /* update address */ - SMEMCPY(&arp_table[i].ethaddr, ethaddr, ETH_HWADDR_LEN); - /* reset time stamp */ - arp_table[i].ctime = 0; - /* this is where we will send out queued packets! */ -#if ARP_QUEUEING - while (arp_table[i].q != NULL) { - struct pbuf *p; - /* remember remainder of queue */ - struct etharp_q_entry *q = arp_table[i].q; - /* pop first item off the queue */ - arp_table[i].q = q->next; - /* get the packet pointer */ - p = q->p; - /* now queue entry can be freed */ - memp_free(MEMP_ARP_QUEUE, q); -#else /* ARP_QUEUEING */ - if (arp_table[i].q != NULL) { - struct pbuf *p = arp_table[i].q; - arp_table[i].q = NULL; -#endif /* ARP_QUEUEING */ - /* send the queued IP packet */ - ethernet_output(netif, p, (struct eth_addr *)(netif->hwaddr), ethaddr, ETHTYPE_IP); - /* free the queued IP packet */ - pbuf_free(p); - } - return ERR_OK; -} - -#if ETHARP_SUPPORT_STATIC_ENTRIES -/** Add a new static entry to the ARP table. If an entry exists for the - * specified IP address, this entry is overwritten. - * If packets are queued for the specified IP address, they are sent out. - * - * @param ipaddr IP address for the new static entry - * @param ethaddr ethernet address for the new static entry - * @return See return values of etharp_add_static_entry - */ -err_t -etharp_add_static_entry(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr) -{ - struct netif *netif; - LWIP_ASSERT_CORE_LOCKED(); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_add_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n", - ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr), - (u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2], - (u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5])); - - netif = ip4_route(ipaddr); - if (netif == NULL) { - return ERR_RTE; - } - - return etharp_update_arp_entry(netif, ipaddr, ethaddr, ETHARP_FLAG_TRY_HARD | ETHARP_FLAG_STATIC_ENTRY); -} - -/** Remove a static entry from the ARP table previously added with a call to - * etharp_add_static_entry. - * - * @param ipaddr IP address of the static entry to remove - * @return ERR_OK: entry removed - * ERR_MEM: entry wasn't found - * ERR_ARG: entry wasn't a static entry but a dynamic one - */ -err_t -etharp_remove_static_entry(const ip4_addr_t *ipaddr) -{ - s16_t i; - LWIP_ASSERT_CORE_LOCKED(); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_remove_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr))); - - /* find or create ARP entry */ - i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, NULL); - /* bail out if no entry could be found */ - if (i < 0) { - return (err_t)i; - } - - if (arp_table[i].state != ETHARP_STATE_STATIC) { - /* entry wasn't a static entry, cannot remove it */ - return ERR_ARG; - } - /* entry found, free it */ - etharp_free_entry(i); - return ERR_OK; -} -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ - -/** - * Remove all ARP table entries of the specified netif. - * - * @param netif points to a network interface - */ -void -etharp_cleanup_netif(struct netif *netif) -{ - int i; - - for (i = 0; i < ARP_TABLE_SIZE; ++i) { - u8_t state = arp_table[i].state; - if ((state != ETHARP_STATE_EMPTY) && (arp_table[i].netif == netif)) { - etharp_free_entry(i); - } - } -} - -/** - * Finds (stable) ethernet/IP address pair from ARP table - * using interface and IP address index. - * @note the addresses in the ARP table are in network order! - * - * @param netif points to interface index - * @param ipaddr points to the (network order) IP address index - * @param eth_ret points to return pointer - * @param ip_ret points to return pointer - * @return table index if found, -1 otherwise - */ -ssize_t -etharp_find_addr(struct netif *netif, const ip4_addr_t *ipaddr, - struct eth_addr **eth_ret, const ip4_addr_t **ip_ret) -{ - s16_t i; - - LWIP_ASSERT("eth_ret != NULL && ip_ret != NULL", - eth_ret != NULL && ip_ret != NULL); - - LWIP_UNUSED_ARG(netif); - - i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, netif); - if ((i >= 0) && (arp_table[i].state >= ETHARP_STATE_STABLE)) { - *eth_ret = &arp_table[i].ethaddr; - *ip_ret = &arp_table[i].ipaddr; - return i; - } - return -1; -} - -/** - * Possibility to iterate over stable ARP table entries - * - * @param i entry number, 0 to ARP_TABLE_SIZE - * @param ipaddr return value: IP address - * @param netif return value: points to interface - * @param eth_ret return value: ETH address - * @return 1 on valid index, 0 otherwise - */ -int -etharp_get_entry(size_t i, ip4_addr_t **ipaddr, struct netif **netif, struct eth_addr **eth_ret) -{ - LWIP_ASSERT("ipaddr != NULL", ipaddr != NULL); - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("eth_ret != NULL", eth_ret != NULL); - - if ((i < ARP_TABLE_SIZE) && (arp_table[i].state >= ETHARP_STATE_STABLE)) { - *ipaddr = &arp_table[i].ipaddr; - *netif = arp_table[i].netif; - *eth_ret = &arp_table[i].ethaddr; - return 1; - } else { - return 0; - } -} - -/** - * Responds to ARP requests to us. Upon ARP replies to us, add entry to cache - * send out queued IP packets. Updates cache with snooped address pairs. - * - * Should be called for incoming ARP packets. The pbuf in the argument - * is freed by this function. - * - * @param p The ARP packet that arrived on netif. Is freed by this function. - * @param netif The lwIP network interface on which the ARP packet pbuf arrived. - * - * @see pbuf_free() - */ -void -etharp_input(struct pbuf *p, struct netif *netif) -{ - struct etharp_hdr *hdr; - /* these are aligned properly, whereas the ARP header fields might not be */ - ip4_addr_t sipaddr, dipaddr; - u8_t for_us; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("netif != NULL", (netif != NULL), return;); - - hdr = (struct etharp_hdr *)p->payload; - - /* RFC 826 "Packet Reception": */ - if ((hdr->hwtype != PP_HTONS(LWIP_IANA_HWTYPE_ETHERNET)) || - (hdr->hwlen != ETH_HWADDR_LEN) || - (hdr->protolen != sizeof(ip4_addr_t)) || - (hdr->proto != PP_HTONS(ETHTYPE_IP))) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, - ("etharp_input: packet dropped, wrong hw type, hwlen, proto, protolen or ethernet type (%"U16_F"/%"U16_F"/%"U16_F"/%"U16_F")\n", - hdr->hwtype, (u16_t)hdr->hwlen, hdr->proto, (u16_t)hdr->protolen)); - ETHARP_STATS_INC(etharp.proterr); - ETHARP_STATS_INC(etharp.drop); - pbuf_free(p); - return; - } - ETHARP_STATS_INC(etharp.recv); - -#if LWIP_AUTOIP - /* We have to check if a host already has configured our random - * created link local address and continuously check if there is - * a host with this IP-address so we can detect collisions */ - autoip_arp_reply(netif, hdr); -#endif /* LWIP_AUTOIP */ - - /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without - * structure packing (not using structure copy which breaks strict-aliasing rules). */ - IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&sipaddr, &hdr->sipaddr); - IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&dipaddr, &hdr->dipaddr); - - /* this interface is not configured? */ - if (ip4_addr_isany_val(*netif_ip4_addr(netif))) { - for_us = 0; - } else { - /* ARP packet directed to us? */ - for_us = (u8_t)ip4_addr_cmp(&dipaddr, netif_ip4_addr(netif)); - } - - /* ARP message directed to us? - -> add IP address in ARP cache; assume requester wants to talk to us, - can result in directly sending the queued packets for this host. - ARP message not directed to us? - -> update the source IP address in the cache, if present */ - etharp_update_arp_entry(netif, &sipaddr, &(hdr->shwaddr), - for_us ? ETHARP_FLAG_TRY_HARD : ETHARP_FLAG_FIND_ONLY); - - /* now act on the message itself */ - switch (hdr->opcode) { - /* ARP request? */ - case PP_HTONS(ARP_REQUEST): - /* ARP request. If it asked for our address, we send out a - * reply. In any case, we time-stamp any existing ARP entry, - * and possibly send out an IP packet that was queued on it. */ - LWIP_DEBUGF (ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP request\n")); - /* ARP request for our address? */ - if (for_us) { - /* send ARP response */ - etharp_raw(netif, - (struct eth_addr *)netif->hwaddr, &hdr->shwaddr, - (struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), - &hdr->shwaddr, &sipaddr, - ARP_REPLY); - - /* we are not configured? */ - } else if (ip4_addr_isany_val(*netif_ip4_addr(netif))) { - /* { for_us == 0 and netif->ip_addr.addr == 0 } */ - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: we are unconfigured, ARP request ignored.\n")); - /* request was not directed to us */ - } else { - /* { for_us == 0 and netif->ip_addr.addr != 0 } */ - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP request was not for us.\n")); - } - break; - case PP_HTONS(ARP_REPLY): - /* ARP reply. We already updated the ARP cache earlier. */ - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP reply\n")); -#if (LWIP_DHCP && DHCP_DOES_ARP_CHECK) - /* DHCP wants to know about ARP replies from any host with an - * IP address also offered to us by the DHCP server. We do not - * want to take a duplicate IP address on a single network. - * @todo How should we handle redundant (fail-over) interfaces? */ - dhcp_arp_reply(netif, &sipaddr); -#endif /* (LWIP_DHCP && DHCP_DOES_ARP_CHECK) */ - break; - default: - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP unknown opcode type %"S16_F"\n", lwip_htons(hdr->opcode))); - ETHARP_STATS_INC(etharp.err); - break; - } - /* free ARP packet */ - pbuf_free(p); -} - -/** Just a small helper function that sends a pbuf to an ethernet address - * in the arp_table specified by the index 'arp_idx'. - */ -static err_t -etharp_output_to_arp_index(struct netif *netif, struct pbuf *q, netif_addr_idx_t arp_idx) -{ - LWIP_ASSERT("arp_table[arp_idx].state >= ETHARP_STATE_STABLE", - arp_table[arp_idx].state >= ETHARP_STATE_STABLE); - /* if arp table entry is about to expire: re-request it, - but only if its state is ETHARP_STATE_STABLE to prevent flooding the - network with ARP requests if this address is used frequently. */ - if (arp_table[arp_idx].state == ETHARP_STATE_STABLE) { - if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_BROADCAST) { - /* issue a standard request using broadcast */ - if (etharp_request(netif, &arp_table[arp_idx].ipaddr) == ERR_OK) { - arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING_1; - } - } else if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_UNICAST) { - /* issue a unicast request (for 15 seconds) to prevent unnecessary broadcast */ - if (etharp_request_dst(netif, &arp_table[arp_idx].ipaddr, &arp_table[arp_idx].ethaddr) == ERR_OK) { - arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING_1; - } - } - } - - return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), &arp_table[arp_idx].ethaddr, ETHTYPE_IP); -} - -/** - * Resolve and fill-in Ethernet address header for outgoing IP packet. - * - * For IP multicast and broadcast, corresponding Ethernet addresses - * are selected and the packet is transmitted on the link. - * - * For unicast addresses, the packet is submitted to etharp_query(). In - * case the IP address is outside the local network, the IP address of - * the gateway is used. - * - * @param netif The lwIP network interface which the IP packet will be sent on. - * @param q The pbuf(s) containing the IP packet to be sent. - * @param ipaddr The IP address of the packet destination. - * - * @return - * - ERR_RTE No route to destination (no gateway to external networks), - * or the return type of either etharp_query() or ethernet_output(). - */ -err_t -etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr) -{ - const struct eth_addr *dest; - struct eth_addr mcastaddr; - const ip4_addr_t *dst_addr = ipaddr; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("q != NULL", q != NULL); - LWIP_ASSERT("ipaddr != NULL", ipaddr != NULL); - - /* Determine on destination hardware address. Broadcasts and multicasts - * are special, other IP addresses are looked up in the ARP table. */ - - /* broadcast destination IP address? */ - if (ip4_addr_isbroadcast(ipaddr, netif)) { - /* broadcast on Ethernet also */ - dest = (const struct eth_addr *)ðbroadcast; - /* multicast destination IP address? */ - } else if (ip4_addr_ismulticast(ipaddr)) { - /* Hash IP multicast address to MAC address.*/ - mcastaddr.addr[0] = LL_IP4_MULTICAST_ADDR_0; - mcastaddr.addr[1] = LL_IP4_MULTICAST_ADDR_1; - mcastaddr.addr[2] = LL_IP4_MULTICAST_ADDR_2; - mcastaddr.addr[3] = ip4_addr2(ipaddr) & 0x7f; - mcastaddr.addr[4] = ip4_addr3(ipaddr); - mcastaddr.addr[5] = ip4_addr4(ipaddr); - /* destination Ethernet address is multicast */ - dest = &mcastaddr; - /* unicast destination IP address? */ - } else { - netif_addr_idx_t i; - /* outside local network? if so, this can neither be a global broadcast nor - a subnet broadcast. */ - if (!ip4_addr_netcmp(ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) && - !ip4_addr_islinklocal(ipaddr)) { -#if LWIP_AUTOIP - struct ip_hdr *iphdr = LWIP_ALIGNMENT_CAST(struct ip_hdr *, q->payload); - /* According to RFC 3297, chapter 2.6.2 (Forwarding Rules), a packet with - a link-local source address must always be "directly to its destination - on the same physical link. The host MUST NOT send the packet to any - router for forwarding". */ - if (!ip4_addr_islinklocal(&iphdr->src)) -#endif /* LWIP_AUTOIP */ - { -#ifdef LWIP_HOOK_ETHARP_GET_GW - /* For advanced routing, a single default gateway might not be enough, so get - the IP address of the gateway to handle the current destination address. */ - dst_addr = LWIP_HOOK_ETHARP_GET_GW(netif, ipaddr); - if (dst_addr == NULL) -#endif /* LWIP_HOOK_ETHARP_GET_GW */ - { - /* interface has default gateway? */ - if (!ip4_addr_isany_val(*netif_ip4_gw(netif))) { - /* send to hardware address of default gateway IP address */ - dst_addr = netif_ip4_gw(netif); - /* no default gateway available */ - } else { - /* no route to destination error (default gateway missing) */ - return ERR_RTE; - } - } - } - } -#if LWIP_NETIF_HWADDRHINT - if (netif->hints != NULL) { - /* per-pcb cached entry was given */ - netif_addr_idx_t etharp_cached_entry = netif->hints->addr_hint; - if (etharp_cached_entry < ARP_TABLE_SIZE) { -#endif /* LWIP_NETIF_HWADDRHINT */ - if ((arp_table[etharp_cached_entry].state >= ETHARP_STATE_STABLE) && -#if ETHARP_TABLE_MATCH_NETIF - (arp_table[etharp_cached_entry].netif == netif) && -#endif - (ip4_addr_cmp(dst_addr, &arp_table[etharp_cached_entry].ipaddr))) { - /* the per-pcb-cached entry is stable and the right one! */ - ETHARP_STATS_INC(etharp.cachehit); - return etharp_output_to_arp_index(netif, q, etharp_cached_entry); - } -#if LWIP_NETIF_HWADDRHINT - } - } -#endif /* LWIP_NETIF_HWADDRHINT */ - - /* find stable entry: do this here since this is a critical path for - throughput and etharp_find_entry() is kind of slow */ - for (i = 0; i < ARP_TABLE_SIZE; i++) { - if ((arp_table[i].state >= ETHARP_STATE_STABLE) && -#if ETHARP_TABLE_MATCH_NETIF - (arp_table[i].netif == netif) && -#endif - (ip4_addr_cmp(dst_addr, &arp_table[i].ipaddr))) { - /* found an existing, stable entry */ - ETHARP_SET_ADDRHINT(netif, i); - return etharp_output_to_arp_index(netif, q, i); - } - } - /* no stable entry found, use the (slower) query function: - queue on destination Ethernet address belonging to ipaddr */ - return etharp_query(netif, dst_addr, q); - } - - /* continuation for multicast/broadcast destinations */ - /* obtain source Ethernet address of the given interface */ - /* send packet directly on the link */ - return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), dest, ETHTYPE_IP); -} - -/** - * Send an ARP request for the given IP address and/or queue a packet. - * - * If the IP address was not yet in the cache, a pending ARP cache entry - * is added and an ARP request is sent for the given address. The packet - * is queued on this entry. - * - * If the IP address was already pending in the cache, a new ARP request - * is sent for the given address. The packet is queued on this entry. - * - * If the IP address was already stable in the cache, and a packet is - * given, it is directly sent and no ARP request is sent out. - * - * If the IP address was already stable in the cache, and no packet is - * given, an ARP request is sent out. - * - * @param netif The lwIP network interface on which ipaddr - * must be queried for. - * @param ipaddr The IP address to be resolved. - * @param q If non-NULL, a pbuf that must be delivered to the IP address. - * q is not freed by this function. - * - * @note q must only be ONE packet, not a packet queue! - * - * @return - * - ERR_BUF Could not make room for Ethernet header. - * - ERR_MEM Hardware address unknown, and no more ARP entries available - * to query for address or queue the packet. - * - ERR_MEM Could not queue packet due to memory shortage. - * - ERR_RTE No route to destination (no gateway to external networks). - * - ERR_ARG Non-unicast address given, those will not appear in ARP cache. - * - */ -err_t -etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q) -{ - struct eth_addr *srcaddr = (struct eth_addr *)netif->hwaddr; - err_t result = ERR_MEM; - int is_new_entry = 0; - s16_t i_err; - netif_addr_idx_t i; - - /* non-unicast address? */ - if (ip4_addr_isbroadcast(ipaddr, netif) || - ip4_addr_ismulticast(ipaddr) || - ip4_addr_isany(ipaddr)) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: will not add non-unicast IP address to ARP cache\n")); - return ERR_ARG; - } - - /* find entry in ARP cache, ask to create entry if queueing packet */ - i_err = etharp_find_entry(ipaddr, ETHARP_FLAG_TRY_HARD, netif); - - /* could not find or create entry? */ - if (i_err < 0) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not create ARP entry\n")); - if (q) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: packet dropped\n")); - ETHARP_STATS_INC(etharp.memerr); - } - return (err_t)i_err; - } - LWIP_ASSERT("type overflow", (size_t)i_err < NETIF_ADDR_IDX_MAX); - i = (netif_addr_idx_t)i_err; - - /* mark a fresh entry as pending (we just sent a request) */ - if (arp_table[i].state == ETHARP_STATE_EMPTY) { - is_new_entry = 1; - arp_table[i].state = ETHARP_STATE_PENDING; - /* record network interface for re-sending arp request in etharp_tmr */ - arp_table[i].netif = netif; - } - - /* { i is either a STABLE or (new or existing) PENDING entry } */ - LWIP_ASSERT("arp_table[i].state == PENDING or STABLE", - ((arp_table[i].state == ETHARP_STATE_PENDING) || - (arp_table[i].state >= ETHARP_STATE_STABLE))); - - /* do we have a new entry? or an implicit query request? */ - if (is_new_entry || (q == NULL)) { - /* try to resolve it; send out ARP request */ - result = etharp_request(netif, ipaddr); - if (result != ERR_OK) { - /* ARP request couldn't be sent */ - /* We don't re-send arp request in etharp_tmr, but we still queue packets, - since this failure could be temporary, and the next packet calling - etharp_query again could lead to sending the queued packets. */ - } - if (q == NULL) { - return result; - } - } - - /* packet given? */ - LWIP_ASSERT("q != NULL", q != NULL); - /* stable entry? */ - if (arp_table[i].state >= ETHARP_STATE_STABLE) { - /* we have a valid IP->Ethernet address mapping */ - ETHARP_SET_ADDRHINT(netif, i); - /* send the packet */ - result = ethernet_output(netif, q, srcaddr, &(arp_table[i].ethaddr), ETHTYPE_IP); - /* pending entry? (either just created or already pending */ - } else if (arp_table[i].state == ETHARP_STATE_PENDING) { - /* entry is still pending, queue the given packet 'q' */ - struct pbuf *p; - int copy_needed = 0; - /* IF q includes a pbuf that must be copied, copy the whole chain into a - * new PBUF_RAM. See the definition of PBUF_NEEDS_COPY for details. */ - p = q; - while (p) { - LWIP_ASSERT("no packet queues allowed!", (p->len != p->tot_len) || (p->next == 0)); - if (PBUF_NEEDS_COPY(p)) { - copy_needed = 1; - break; - } - p = p->next; - } - if (copy_needed) { - /* copy the whole packet into new pbufs */ - p = pbuf_clone(PBUF_LINK, PBUF_RAM, q); - } else { - /* referencing the old pbuf is enough */ - p = q; - pbuf_ref(p); - } - /* packet could be taken over? */ - if (p != NULL) { - /* queue packet ... */ -#if ARP_QUEUEING - struct etharp_q_entry *new_entry; - /* allocate a new arp queue entry */ - new_entry = (struct etharp_q_entry *)memp_malloc(MEMP_ARP_QUEUE); - if (new_entry != NULL) { - unsigned int qlen = 0; - new_entry->next = 0; - new_entry->p = p; - if (arp_table[i].q != NULL) { - /* queue was already existent, append the new entry to the end */ - struct etharp_q_entry *r; - r = arp_table[i].q; - qlen++; - while (r->next != NULL) { - r = r->next; - qlen++; - } - r->next = new_entry; - } else { - /* queue did not exist, first item in queue */ - arp_table[i].q = new_entry; - } -#if ARP_QUEUE_LEN - if (qlen >= ARP_QUEUE_LEN) { - struct etharp_q_entry *old; - old = arp_table[i].q; - arp_table[i].q = arp_table[i].q->next; - pbuf_free(old->p); - memp_free(MEMP_ARP_QUEUE, old); - } -#endif - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"U16_F"\n", (void *)q, i)); - result = ERR_OK; - } else { - /* the pool MEMP_ARP_QUEUE is empty */ - pbuf_free(p); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q)); - result = ERR_MEM; - } -#else /* ARP_QUEUEING */ - /* always queue one packet per ARP request only, freeing a previously queued packet */ - if (arp_table[i].q != NULL) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: dropped previously queued packet %p for ARP entry %"U16_F"\n", (void *)q, (u16_t)i)); - pbuf_free(arp_table[i].q); - } - arp_table[i].q = p; - result = ERR_OK; - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"U16_F"\n", (void *)q, (u16_t)i)); -#endif /* ARP_QUEUEING */ - } else { - ETHARP_STATS_INC(etharp.memerr); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q)); - result = ERR_MEM; - } - } - return result; -} - -/** - * Send a raw ARP packet (opcode and all addresses can be modified) - * - * @param netif the lwip network interface on which to send the ARP packet - * @param ethsrc_addr the source MAC address for the ethernet header - * @param ethdst_addr the destination MAC address for the ethernet header - * @param hwsrc_addr the source MAC address for the ARP protocol header - * @param ipsrc_addr the source IP address for the ARP protocol header - * @param hwdst_addr the destination MAC address for the ARP protocol header - * @param ipdst_addr the destination IP address for the ARP protocol header - * @param opcode the type of the ARP packet - * @return ERR_OK if the ARP packet has been sent - * ERR_MEM if the ARP packet couldn't be allocated - * any other err_t on failure - */ -static err_t -etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr, - const struct eth_addr *ethdst_addr, - const struct eth_addr *hwsrc_addr, const ip4_addr_t *ipsrc_addr, - const struct eth_addr *hwdst_addr, const ip4_addr_t *ipdst_addr, - const u16_t opcode) -{ - struct pbuf *p; - err_t result = ERR_OK; - struct etharp_hdr *hdr; - - LWIP_ASSERT("netif != NULL", netif != NULL); - - /* allocate a pbuf for the outgoing ARP request packet */ - p = pbuf_alloc(PBUF_LINK, SIZEOF_ETHARP_HDR, PBUF_RAM); - /* could allocate a pbuf for an ARP request? */ - if (p == NULL) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("etharp_raw: could not allocate pbuf for ARP request.\n")); - ETHARP_STATS_INC(etharp.memerr); - return ERR_MEM; - } - LWIP_ASSERT("check that first pbuf can hold struct etharp_hdr", - (p->len >= SIZEOF_ETHARP_HDR)); - - hdr = (struct etharp_hdr *)p->payload; - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_raw: sending raw ARP packet.\n")); - hdr->opcode = lwip_htons(opcode); - - LWIP_ASSERT("netif->hwaddr_len must be the same as ETH_HWADDR_LEN for etharp!", - (netif->hwaddr_len == ETH_HWADDR_LEN)); - - /* Write the ARP MAC-Addresses */ - SMEMCPY(&hdr->shwaddr, hwsrc_addr, ETH_HWADDR_LEN); - SMEMCPY(&hdr->dhwaddr, hwdst_addr, ETH_HWADDR_LEN); - /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without - * structure packing. */ - IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->sipaddr, ipsrc_addr); - IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->dipaddr, ipdst_addr); - - hdr->hwtype = PP_HTONS(LWIP_IANA_HWTYPE_ETHERNET); - hdr->proto = PP_HTONS(ETHTYPE_IP); - /* set hwlen and protolen */ - hdr->hwlen = ETH_HWADDR_LEN; - hdr->protolen = sizeof(ip4_addr_t); - - /* send ARP query */ -#if LWIP_AUTOIP - /* If we are using Link-Local, all ARP packets that contain a Link-Local - * 'sender IP address' MUST be sent using link-layer broadcast instead of - * link-layer unicast. (See RFC3927 Section 2.5, last paragraph) */ - if (ip4_addr_islinklocal(ipsrc_addr)) { - ethernet_output(netif, p, ethsrc_addr, ðbroadcast, ETHTYPE_ARP); - } else -#endif /* LWIP_AUTOIP */ - { - ethernet_output(netif, p, ethsrc_addr, ethdst_addr, ETHTYPE_ARP); - } - - ETHARP_STATS_INC(etharp.xmit); - /* free ARP query packet */ - pbuf_free(p); - p = NULL; - /* could not allocate pbuf for ARP request */ - - return result; -} - -/** - * Send an ARP request packet asking for ipaddr to a specific eth address. - * Used to send unicast request to refresh the ARP table just before an entry - * times out - * - * @param netif the lwip network interface on which to send the request - * @param ipaddr the IP address for which to ask - * @param hw_dst_addr the ethernet address to send this packet to - * @return ERR_OK if the request has been sent - * ERR_MEM if the ARP packet couldn't be allocated - * any other err_t on failure - */ -static err_t -etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr *hw_dst_addr) -{ - return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, hw_dst_addr, - (struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), ðzero, - ipaddr, ARP_REQUEST); -} - -/** - * Send an ARP request packet asking for ipaddr. - * - * @param netif the lwip network interface on which to send the request - * @param ipaddr the IP address for which to ask - * @return ERR_OK if the request has been sent - * ERR_MEM if the ARP packet couldn't be allocated - * any other err_t on failure - */ -err_t -etharp_request(struct netif *netif, const ip4_addr_t *ipaddr) -{ - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_request: sending ARP request.\n")); - return etharp_request_dst(netif, ipaddr, ðbroadcast); -} - -#endif /* LWIP_IPV4 && LWIP_ARP */ +/** + * @file + * Address Resolution Protocol module for IP over Ethernet + * + * Functionally, ARP is divided into two parts. The first maps an IP address + * to a physical address when sending a packet, and the second part answers + * requests from other machines for our physical address. + * + * This implementation complies with RFC 826 (Ethernet ARP). It supports + * Gratuitious ARP from RFC3220 (IP Mobility Support for IPv4) section 4.6 + * if an interface calls etharp_gratuitous(our_netif) upon address change. + */ + +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * Copyright (c) 2003-2004 Leon Woestenberg + * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_ARP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/etharp.h" +#include "lwip/stats.h" +#include "lwip/snmp.h" +#include "lwip/dhcp.h" +#include "lwip/autoip.h" +#include "lwip/prot/iana.h" +#include "netif/ethernet.h" + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +/** Re-request a used ARP entry 1 minute before it would expire to prevent + * breaking a steadily used connection because the ARP entry timed out. */ +#define ARP_AGE_REREQUEST_USED_UNICAST (ARP_MAXAGE - 30) +#define ARP_AGE_REREQUEST_USED_BROADCAST (ARP_MAXAGE - 15) + +/** the time an ARP entry stays pending after first request, + * for ARP_TMR_INTERVAL = 1000, this is + * 10 seconds. + * + * @internal Keep this number at least 2, otherwise it might + * run out instantly if the timeout occurs directly after a request. + */ +#define ARP_MAXPENDING 5 + +/** ARP states */ +enum etharp_state { + ETHARP_STATE_EMPTY = 0, + ETHARP_STATE_PENDING, + ETHARP_STATE_STABLE, + ETHARP_STATE_STABLE_REREQUESTING_1, + ETHARP_STATE_STABLE_REREQUESTING_2 +#if ETHARP_SUPPORT_STATIC_ENTRIES + , ETHARP_STATE_STATIC +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ +}; + +struct etharp_entry { +#if ARP_QUEUEING + /** Pointer to queue of pending outgoing packets on this ARP entry. */ + struct etharp_q_entry *q; +#else /* ARP_QUEUEING */ + /** Pointer to a single pending outgoing packet on this ARP entry. */ + struct pbuf *q; +#endif /* ARP_QUEUEING */ + ip4_addr_t ipaddr; + struct netif *netif; + struct eth_addr ethaddr; + u16_t ctime; + u8_t state; +}; + +static struct etharp_entry arp_table[ARP_TABLE_SIZE]; + +#if !LWIP_NETIF_HWADDRHINT +static netif_addr_idx_t etharp_cached_entry; +#endif /* !LWIP_NETIF_HWADDRHINT */ + +/** Try hard to create a new entry - we want the IP address to appear in + the cache (even if this means removing an active entry or so). */ +#define ETHARP_FLAG_TRY_HARD 1 +#define ETHARP_FLAG_FIND_ONLY 2 +#if ETHARP_SUPPORT_STATIC_ENTRIES +#define ETHARP_FLAG_STATIC_ENTRY 4 +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ + +#if LWIP_NETIF_HWADDRHINT +#define ETHARP_SET_ADDRHINT(netif, addrhint) do { if (((netif) != NULL) && ((netif)->hints != NULL)) { \ + (netif)->hints->addr_hint = (addrhint); }} while(0) +#else /* LWIP_NETIF_HWADDRHINT */ +#define ETHARP_SET_ADDRHINT(netif, addrhint) (etharp_cached_entry = (addrhint)) +#endif /* LWIP_NETIF_HWADDRHINT */ + + +/* Check for maximum ARP_TABLE_SIZE */ +#if (ARP_TABLE_SIZE > NETIF_ADDR_IDX_MAX) +#error "ARP_TABLE_SIZE must fit in an s16_t, you have to reduce it in your lwipopts.h" +#endif + + +static err_t etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr *hw_dst_addr); +static err_t etharp_raw(struct netif *netif, + const struct eth_addr *ethsrc_addr, const struct eth_addr *ethdst_addr, + const struct eth_addr *hwsrc_addr, const ip4_addr_t *ipsrc_addr, + const struct eth_addr *hwdst_addr, const ip4_addr_t *ipdst_addr, + const u16_t opcode); + +#if ARP_QUEUEING +/** + * Free a complete queue of etharp entries + * + * @param q a qeueue of etharp_q_entry's to free + */ +static void +free_etharp_q(struct etharp_q_entry *q) +{ + struct etharp_q_entry *r; + LWIP_ASSERT("q != NULL", q != NULL); + while (q) { + r = q; + q = q->next; + LWIP_ASSERT("r->p != NULL", (r->p != NULL)); + pbuf_free(r->p); + memp_free(MEMP_ARP_QUEUE, r); + } +} +#else /* ARP_QUEUEING */ + +/** Compatibility define: free the queued pbuf */ +#define free_etharp_q(q) pbuf_free(q) + +#endif /* ARP_QUEUEING */ + +/** Clean up ARP table entries */ +static void +etharp_free_entry(int i) +{ + /* remove from SNMP ARP index tree */ + mib2_remove_arp_entry(arp_table[i].netif, &arp_table[i].ipaddr); + /* and empty packet queue */ + if (arp_table[i].q != NULL) { + /* remove all queued packets */ + LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_free_entry: freeing entry %"U16_F", packet queue %p.\n", (u16_t)i, (void *)(arp_table[i].q))); + free_etharp_q(arp_table[i].q); + arp_table[i].q = NULL; + } + /* recycle entry for re-use */ + arp_table[i].state = ETHARP_STATE_EMPTY; +#ifdef LWIP_DEBUG + /* for debugging, clean out the complete entry */ + arp_table[i].ctime = 0; + arp_table[i].netif = NULL; + ip4_addr_set_zero(&arp_table[i].ipaddr); + arp_table[i].ethaddr = ethzero; +#endif /* LWIP_DEBUG */ +} + +/** + * Clears expired entries in the ARP table. + * + * This function should be called every ARP_TMR_INTERVAL milliseconds (1 second), + * in order to expire entries in the ARP table. + */ +void +etharp_tmr(void) +{ + int i; + + LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer\n")); + /* remove expired entries from the ARP table */ + for (i = 0; i < ARP_TABLE_SIZE; ++i) { + u8_t state = arp_table[i].state; + if (state != ETHARP_STATE_EMPTY +#if ETHARP_SUPPORT_STATIC_ENTRIES + && (state != ETHARP_STATE_STATIC) +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ + ) { + arp_table[i].ctime++; + if ((arp_table[i].ctime >= ARP_MAXAGE) || + ((arp_table[i].state == ETHARP_STATE_PENDING) && + (arp_table[i].ctime >= ARP_MAXPENDING))) { + /* pending or stable entry has become old! */ + LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_timer: expired %s entry %d.\n", + arp_table[i].state >= ETHARP_STATE_STABLE ? "stable" : "pending", i)); + /* clean up entries that have just been expired */ + etharp_free_entry(i); + } else if (arp_table[i].state == ETHARP_STATE_STABLE_REREQUESTING_1) { + /* Don't send more than one request every 2 seconds. */ + arp_table[i].state = ETHARP_STATE_STABLE_REREQUESTING_2; + } else if (arp_table[i].state == ETHARP_STATE_STABLE_REREQUESTING_2) { + /* Reset state to stable, so that the next transmitted packet will + re-send an ARP request. */ + arp_table[i].state = ETHARP_STATE_STABLE; + } else if (arp_table[i].state == ETHARP_STATE_PENDING) { + /* still pending, resend an ARP query */ + etharp_request(arp_table[i].netif, &arp_table[i].ipaddr); + } + } + } +} + +/** + * Search the ARP table for a matching or new entry. + * + * If an IP address is given, return a pending or stable ARP entry that matches + * the address. If no match is found, create a new entry with this address set, + * but in state ETHARP_EMPTY. The caller must check and possibly change the + * state of the returned entry. + * + * If ipaddr is NULL, return a initialized new entry in state ETHARP_EMPTY. + * + * In all cases, attempt to create new entries from an empty entry. If no + * empty entries are available and ETHARP_FLAG_TRY_HARD flag is set, recycle + * old entries. Heuristic choose the least important entry for recycling. + * + * @param ipaddr IP address to find in ARP cache, or to add if not found. + * @param flags See @ref etharp_state + * @param netif netif related to this address (used for NETIF_HWADDRHINT) + * + * @return The ARP entry index that matched or is created, ERR_MEM if no + * entry is found or could be recycled. + */ +static s16_t +etharp_find_entry(const ip4_addr_t *ipaddr, u8_t flags, struct netif *netif) +{ + s16_t old_pending = ARP_TABLE_SIZE, old_stable = ARP_TABLE_SIZE; + s16_t empty = ARP_TABLE_SIZE; + s16_t i = 0; + /* oldest entry with packets on queue */ + s16_t old_queue = ARP_TABLE_SIZE; + /* its age */ + u16_t age_queue = 0, age_pending = 0, age_stable = 0; + + LWIP_UNUSED_ARG(netif); + + /** + * a) do a search through the cache, remember candidates + * b) select candidate entry + * c) create new entry + */ + + /* a) in a single search sweep, do all of this + * 1) remember the first empty entry (if any) + * 2) remember the oldest stable entry (if any) + * 3) remember the oldest pending entry without queued packets (if any) + * 4) remember the oldest pending entry with queued packets (if any) + * 5) search for a matching IP entry, either pending or stable + * until 5 matches, or all entries are searched for. + */ + + for (i = 0; i < ARP_TABLE_SIZE; ++i) { + u8_t state = arp_table[i].state; + /* no empty entry found yet and now we do find one? */ + if ((empty == ARP_TABLE_SIZE) && (state == ETHARP_STATE_EMPTY)) { + LWIP_DEBUGF(ETHARP_DEBUG, ("etharp_find_entry: found empty entry %d\n", (int)i)); + /* remember first empty entry */ + empty = i; + } else if (state != ETHARP_STATE_EMPTY) { + LWIP_ASSERT("state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE", + state == ETHARP_STATE_PENDING || state >= ETHARP_STATE_STABLE); + /* if given, does IP address match IP address in ARP entry? */ + if (ipaddr && ip4_addr_cmp(ipaddr, &arp_table[i].ipaddr) +#if ETHARP_TABLE_MATCH_NETIF + && ((netif == NULL) || (netif == arp_table[i].netif)) +#endif /* ETHARP_TABLE_MATCH_NETIF */ + ) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: found matching entry %d\n", (int)i)); + /* found exact IP address match, simply bail out */ + return i; + } + /* pending entry? */ + if (state == ETHARP_STATE_PENDING) { + /* pending with queued packets? */ + if (arp_table[i].q != NULL) { + if (arp_table[i].ctime >= age_queue) { + old_queue = i; + age_queue = arp_table[i].ctime; + } + } else + /* pending without queued packets? */ + { + if (arp_table[i].ctime >= age_pending) { + old_pending = i; + age_pending = arp_table[i].ctime; + } + } + /* stable entry? */ + } else if (state >= ETHARP_STATE_STABLE) { +#if ETHARP_SUPPORT_STATIC_ENTRIES + /* don't record old_stable for static entries since they never expire */ + if (state < ETHARP_STATE_STATIC) +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ + { + /* remember entry with oldest stable entry in oldest, its age in maxtime */ + if (arp_table[i].ctime >= age_stable) { + old_stable = i; + age_stable = arp_table[i].ctime; + } + } + } + } + } + /* { we have no match } => try to create a new entry */ + + /* don't create new entry, only search? */ + if (((flags & ETHARP_FLAG_FIND_ONLY) != 0) || + /* or no empty entry found and not allowed to recycle? */ + ((empty == ARP_TABLE_SIZE) && ((flags & ETHARP_FLAG_TRY_HARD) == 0))) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: no empty entry found and not allowed to recycle\n")); + return (s16_t)ERR_MEM; + } + + /* b) choose the least destructive entry to recycle: + * 1) empty entry + * 2) oldest stable entry + * 3) oldest pending entry without queued packets + * 4) oldest pending entry with queued packets + * + * { ETHARP_FLAG_TRY_HARD is set at this point } + */ + + /* 1) empty entry available? */ + if (empty < ARP_TABLE_SIZE) { + i = empty; + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting empty entry %d\n", (int)i)); + } else { + /* 2) found recyclable stable entry? */ + if (old_stable < ARP_TABLE_SIZE) { + /* recycle oldest stable*/ + i = old_stable; + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest stable entry %d\n", (int)i)); + /* no queued packets should exist on stable entries */ + LWIP_ASSERT("arp_table[i].q == NULL", arp_table[i].q == NULL); + /* 3) found recyclable pending entry without queued packets? */ + } else if (old_pending < ARP_TABLE_SIZE) { + /* recycle oldest pending */ + i = old_pending; + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %d (without queue)\n", (int)i)); + /* 4) found recyclable pending entry with queued packets? */ + } else if (old_queue < ARP_TABLE_SIZE) { + /* recycle oldest pending (queued packets are free in etharp_free_entry) */ + i = old_queue; + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: selecting oldest pending entry %d, freeing packet queue %p\n", (int)i, (void *)(arp_table[i].q))); + /* no empty or recyclable entries found */ + } else { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_find_entry: no empty or recyclable entries found\n")); + return (s16_t)ERR_MEM; + } + + /* { empty or recyclable entry found } */ + LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE); + etharp_free_entry(i); + } + + LWIP_ASSERT("i < ARP_TABLE_SIZE", i < ARP_TABLE_SIZE); + LWIP_ASSERT("arp_table[i].state == ETHARP_STATE_EMPTY", + arp_table[i].state == ETHARP_STATE_EMPTY); + + /* IP address given? */ + if (ipaddr != NULL) { + /* set IP address */ + ip4_addr_copy(arp_table[i].ipaddr, *ipaddr); + } + arp_table[i].ctime = 0; +#if ETHARP_TABLE_MATCH_NETIF + arp_table[i].netif = netif; +#endif /* ETHARP_TABLE_MATCH_NETIF */ + return (s16_t)i; +} + +/** + * Update (or insert) a IP/MAC address pair in the ARP cache. + * + * If a pending entry is resolved, any queued packets will be sent + * at this point. + * + * @param netif netif related to this entry (used for NETIF_ADDRHINT) + * @param ipaddr IP address of the inserted ARP entry. + * @param ethaddr Ethernet address of the inserted ARP entry. + * @param flags See @ref etharp_state + * + * @return + * - ERR_OK Successfully updated ARP cache. + * - ERR_MEM If we could not add a new ARP entry when ETHARP_FLAG_TRY_HARD was set. + * - ERR_ARG Non-unicast address given, those will not appear in ARP cache. + * + * @see pbuf_free() + */ +static err_t +etharp_update_arp_entry(struct netif *netif, const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, u8_t flags) +{ + s16_t i; + LWIP_ASSERT("netif->hwaddr_len == ETH_HWADDR_LEN", netif->hwaddr_len == ETH_HWADDR_LEN); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_update_arp_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n", + ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr), + (u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2], + (u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5])); + /* non-unicast address? */ + if (ip4_addr_isany(ipaddr) || + ip4_addr_isbroadcast(ipaddr, netif) || + ip4_addr_ismulticast(ipaddr)) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_update_arp_entry: will not add non-unicast IP address to ARP cache\n")); + return ERR_ARG; + } + /* find or create ARP entry */ + i = etharp_find_entry(ipaddr, flags, netif); + /* bail out if no entry could be found */ + if (i < 0) { + return (err_t)i; + } + +#if ETHARP_SUPPORT_STATIC_ENTRIES + if (flags & ETHARP_FLAG_STATIC_ENTRY) { + /* record static type */ + arp_table[i].state = ETHARP_STATE_STATIC; + } else if (arp_table[i].state == ETHARP_STATE_STATIC) { + /* found entry is a static type, don't overwrite it */ + return ERR_VAL; + } else +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ + { + /* mark it stable */ + arp_table[i].state = ETHARP_STATE_STABLE; + } + + /* record network interface */ + arp_table[i].netif = netif; + /* insert in SNMP ARP index tree */ + mib2_add_arp_entry(netif, &arp_table[i].ipaddr); + + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_update_arp_entry: updating stable entry %"S16_F"\n", i)); + /* update address */ + SMEMCPY(&arp_table[i].ethaddr, ethaddr, ETH_HWADDR_LEN); + /* reset time stamp */ + arp_table[i].ctime = 0; + /* this is where we will send out queued packets! */ +#if ARP_QUEUEING + while (arp_table[i].q != NULL) { + struct pbuf *p; + /* remember remainder of queue */ + struct etharp_q_entry *q = arp_table[i].q; + /* pop first item off the queue */ + arp_table[i].q = q->next; + /* get the packet pointer */ + p = q->p; + /* now queue entry can be freed */ + memp_free(MEMP_ARP_QUEUE, q); +#else /* ARP_QUEUEING */ + if (arp_table[i].q != NULL) { + struct pbuf *p = arp_table[i].q; + arp_table[i].q = NULL; +#endif /* ARP_QUEUEING */ + /* send the queued IP packet */ + ethernet_output(netif, p, (struct eth_addr *)(netif->hwaddr), ethaddr, ETHTYPE_IP); + /* free the queued IP packet */ + pbuf_free(p); + } + return ERR_OK; +} + +#if ETHARP_SUPPORT_STATIC_ENTRIES +/** Add a new static entry to the ARP table. If an entry exists for the + * specified IP address, this entry is overwritten. + * If packets are queued for the specified IP address, they are sent out. + * + * @param ipaddr IP address for the new static entry + * @param ethaddr ethernet address for the new static entry + * @return See return values of etharp_add_static_entry + */ +err_t +etharp_add_static_entry(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr) +{ + struct netif *netif; + LWIP_ASSERT_CORE_LOCKED(); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_add_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F" - %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F"\n", + ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr), + (u16_t)ethaddr->addr[0], (u16_t)ethaddr->addr[1], (u16_t)ethaddr->addr[2], + (u16_t)ethaddr->addr[3], (u16_t)ethaddr->addr[4], (u16_t)ethaddr->addr[5])); + + netif = ip4_route(ipaddr); + if (netif == NULL) { + return ERR_RTE; + } + + return etharp_update_arp_entry(netif, ipaddr, ethaddr, ETHARP_FLAG_TRY_HARD | ETHARP_FLAG_STATIC_ENTRY); +} + +/** Remove a static entry from the ARP table previously added with a call to + * etharp_add_static_entry. + * + * @param ipaddr IP address of the static entry to remove + * @return ERR_OK: entry removed + * ERR_MEM: entry wasn't found + * ERR_ARG: entry wasn't a static entry but a dynamic one + */ +err_t +etharp_remove_static_entry(const ip4_addr_t *ipaddr) +{ + s16_t i; + LWIP_ASSERT_CORE_LOCKED(); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_remove_static_entry: %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(ipaddr), ip4_addr2_16(ipaddr), ip4_addr3_16(ipaddr), ip4_addr4_16(ipaddr))); + + /* find or create ARP entry */ + i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, NULL); + /* bail out if no entry could be found */ + if (i < 0) { + return (err_t)i; + } + + if (arp_table[i].state != ETHARP_STATE_STATIC) { + /* entry wasn't a static entry, cannot remove it */ + return ERR_ARG; + } + /* entry found, free it */ + etharp_free_entry(i); + return ERR_OK; +} +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ + +/** + * Remove all ARP table entries of the specified netif. + * + * @param netif points to a network interface + */ +void +etharp_cleanup_netif(struct netif *netif) +{ + int i; + + for (i = 0; i < ARP_TABLE_SIZE; ++i) { + u8_t state = arp_table[i].state; + if ((state != ETHARP_STATE_EMPTY) && (arp_table[i].netif == netif)) { + etharp_free_entry(i); + } + } +} + +/** + * Finds (stable) ethernet/IP address pair from ARP table + * using interface and IP address index. + * @note the addresses in the ARP table are in network order! + * + * @param netif points to interface index + * @param ipaddr points to the (network order) IP address index + * @param eth_ret points to return pointer + * @param ip_ret points to return pointer + * @return table index if found, -1 otherwise + */ +ssize_t +etharp_find_addr(struct netif *netif, const ip4_addr_t *ipaddr, + struct eth_addr **eth_ret, const ip4_addr_t **ip_ret) +{ + s16_t i; + + LWIP_ASSERT("eth_ret != NULL && ip_ret != NULL", + eth_ret != NULL && ip_ret != NULL); + + LWIP_UNUSED_ARG(netif); + + i = etharp_find_entry(ipaddr, ETHARP_FLAG_FIND_ONLY, netif); + if ((i >= 0) && (arp_table[i].state >= ETHARP_STATE_STABLE)) { + *eth_ret = &arp_table[i].ethaddr; + *ip_ret = &arp_table[i].ipaddr; + return i; + } + return -1; +} + +/** + * Possibility to iterate over stable ARP table entries + * + * @param i entry number, 0 to ARP_TABLE_SIZE + * @param ipaddr return value: IP address + * @param netif return value: points to interface + * @param eth_ret return value: ETH address + * @return 1 on valid index, 0 otherwise + */ +int +etharp_get_entry(size_t i, ip4_addr_t **ipaddr, struct netif **netif, struct eth_addr **eth_ret) +{ + LWIP_ASSERT("ipaddr != NULL", ipaddr != NULL); + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("eth_ret != NULL", eth_ret != NULL); + + if ((i < ARP_TABLE_SIZE) && (arp_table[i].state >= ETHARP_STATE_STABLE)) { + *ipaddr = &arp_table[i].ipaddr; + *netif = arp_table[i].netif; + *eth_ret = &arp_table[i].ethaddr; + return 1; + } else { + return 0; + } +} + +/** + * Responds to ARP requests to us. Upon ARP replies to us, add entry to cache + * send out queued IP packets. Updates cache with snooped address pairs. + * + * Should be called for incoming ARP packets. The pbuf in the argument + * is freed by this function. + * + * @param p The ARP packet that arrived on netif. Is freed by this function. + * @param netif The lwIP network interface on which the ARP packet pbuf arrived. + * + * @see pbuf_free() + */ +void +etharp_input(struct pbuf *p, struct netif *netif) +{ + struct etharp_hdr *hdr; + /* these are aligned properly, whereas the ARP header fields might not be */ + ip4_addr_t sipaddr, dipaddr; + u8_t for_us; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("netif != NULL", (netif != NULL), return;); + + hdr = (struct etharp_hdr *)p->payload; + + /* RFC 826 "Packet Reception": */ + if ((hdr->hwtype != PP_HTONS(LWIP_IANA_HWTYPE_ETHERNET)) || + (hdr->hwlen != ETH_HWADDR_LEN) || + (hdr->protolen != sizeof(ip4_addr_t)) || + (hdr->proto != PP_HTONS(ETHTYPE_IP))) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, + ("etharp_input: packet dropped, wrong hw type, hwlen, proto, protolen or ethernet type (%"U16_F"/%"U16_F"/%"U16_F"/%"U16_F")\n", + hdr->hwtype, (u16_t)hdr->hwlen, hdr->proto, (u16_t)hdr->protolen)); + ETHARP_STATS_INC(etharp.proterr); + ETHARP_STATS_INC(etharp.drop); + pbuf_free(p); + return; + } + ETHARP_STATS_INC(etharp.recv); + +#if LWIP_AUTOIP + /* We have to check if a host already has configured our random + * created link local address and continuously check if there is + * a host with this IP-address so we can detect collisions */ + autoip_arp_reply(netif, hdr); +#endif /* LWIP_AUTOIP */ + + /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without + * structure packing (not using structure copy which breaks strict-aliasing rules). */ + IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&sipaddr, &hdr->sipaddr); + IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(&dipaddr, &hdr->dipaddr); + + /* this interface is not configured? */ + if (ip4_addr_isany_val(*netif_ip4_addr(netif))) { + for_us = 0; + } else { + /* ARP packet directed to us? */ + for_us = (u8_t)ip4_addr_cmp(&dipaddr, netif_ip4_addr(netif)); + } + + /* ARP message directed to us? + -> add IP address in ARP cache; assume requester wants to talk to us, + can result in directly sending the queued packets for this host. + ARP message not directed to us? + -> update the source IP address in the cache, if present */ + etharp_update_arp_entry(netif, &sipaddr, &(hdr->shwaddr), + for_us ? ETHARP_FLAG_TRY_HARD : ETHARP_FLAG_FIND_ONLY); + + /* now act on the message itself */ + switch (hdr->opcode) { + /* ARP request? */ + case PP_HTONS(ARP_REQUEST): + /* ARP request. If it asked for our address, we send out a + * reply. In any case, we time-stamp any existing ARP entry, + * and possibly send out an IP packet that was queued on it. */ + LWIP_DEBUGF (ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP request\n")); + /* ARP request for our address? */ + if (for_us) { + /* send ARP response */ + etharp_raw(netif, + (struct eth_addr *)netif->hwaddr, &hdr->shwaddr, + (struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), + &hdr->shwaddr, &sipaddr, + ARP_REPLY); + + /* we are not configured? */ + } else if (ip4_addr_isany_val(*netif_ip4_addr(netif))) { + /* { for_us == 0 and netif->ip_addr.addr == 0 } */ + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: we are unconfigured, ARP request ignored.\n")); + /* request was not directed to us */ + } else { + /* { for_us == 0 and netif->ip_addr.addr != 0 } */ + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP request was not for us.\n")); + } + break; + case PP_HTONS(ARP_REPLY): + /* ARP reply. We already updated the ARP cache earlier. */ + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: incoming ARP reply\n")); +#if (LWIP_DHCP && DHCP_DOES_ARP_CHECK) + /* DHCP wants to know about ARP replies from any host with an + * IP address also offered to us by the DHCP server. We do not + * want to take a duplicate IP address on a single network. + * @todo How should we handle redundant (fail-over) interfaces? */ + dhcp_arp_reply(netif, &sipaddr); +#endif /* (LWIP_DHCP && DHCP_DOES_ARP_CHECK) */ + break; + default: + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_input: ARP unknown opcode type %"S16_F"\n", lwip_htons(hdr->opcode))); + ETHARP_STATS_INC(etharp.err); + break; + } + /* free ARP packet */ + pbuf_free(p); +} + +/** Just a small helper function that sends a pbuf to an ethernet address + * in the arp_table specified by the index 'arp_idx'. + */ +static err_t +etharp_output_to_arp_index(struct netif *netif, struct pbuf *q, netif_addr_idx_t arp_idx) +{ + LWIP_ASSERT("arp_table[arp_idx].state >= ETHARP_STATE_STABLE", + arp_table[arp_idx].state >= ETHARP_STATE_STABLE); + /* if arp table entry is about to expire: re-request it, + but only if its state is ETHARP_STATE_STABLE to prevent flooding the + network with ARP requests if this address is used frequently. */ + if (arp_table[arp_idx].state == ETHARP_STATE_STABLE) { + if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_BROADCAST) { + /* issue a standard request using broadcast */ + if (etharp_request(netif, &arp_table[arp_idx].ipaddr) == ERR_OK) { + arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING_1; + } + } else if (arp_table[arp_idx].ctime >= ARP_AGE_REREQUEST_USED_UNICAST) { + /* issue a unicast request (for 15 seconds) to prevent unnecessary broadcast */ + if (etharp_request_dst(netif, &arp_table[arp_idx].ipaddr, &arp_table[arp_idx].ethaddr) == ERR_OK) { + arp_table[arp_idx].state = ETHARP_STATE_STABLE_REREQUESTING_1; + } + } + } + + return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), &arp_table[arp_idx].ethaddr, ETHTYPE_IP); +} + +/** + * Resolve and fill-in Ethernet address header for outgoing IP packet. + * + * For IP multicast and broadcast, corresponding Ethernet addresses + * are selected and the packet is transmitted on the link. + * + * For unicast addresses, the packet is submitted to etharp_query(). In + * case the IP address is outside the local network, the IP address of + * the gateway is used. + * + * @param netif The lwIP network interface which the IP packet will be sent on. + * @param q The pbuf(s) containing the IP packet to be sent. + * @param ipaddr The IP address of the packet destination. + * + * @return + * - ERR_RTE No route to destination (no gateway to external networks), + * or the return type of either etharp_query() or ethernet_output(). + */ +err_t +etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr) +{ + const struct eth_addr *dest; + struct eth_addr mcastaddr; + const ip4_addr_t *dst_addr = ipaddr; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("q != NULL", q != NULL); + LWIP_ASSERT("ipaddr != NULL", ipaddr != NULL); + + /* Determine on destination hardware address. Broadcasts and multicasts + * are special, other IP addresses are looked up in the ARP table. */ + + /* broadcast destination IP address? */ + if (ip4_addr_isbroadcast(ipaddr, netif)) { + /* broadcast on Ethernet also */ + dest = (const struct eth_addr *)ðbroadcast; + /* multicast destination IP address? */ + } else if (ip4_addr_ismulticast(ipaddr)) { + /* Hash IP multicast address to MAC address.*/ + mcastaddr.addr[0] = LL_IP4_MULTICAST_ADDR_0; + mcastaddr.addr[1] = LL_IP4_MULTICAST_ADDR_1; + mcastaddr.addr[2] = LL_IP4_MULTICAST_ADDR_2; + mcastaddr.addr[3] = ip4_addr2(ipaddr) & 0x7f; + mcastaddr.addr[4] = ip4_addr3(ipaddr); + mcastaddr.addr[5] = ip4_addr4(ipaddr); + /* destination Ethernet address is multicast */ + dest = &mcastaddr; + /* unicast destination IP address? */ + } else { + netif_addr_idx_t i; + /* outside local network? if so, this can neither be a global broadcast nor + a subnet broadcast. */ + if (!ip4_addr_netcmp(ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) && + !ip4_addr_islinklocal(ipaddr)) { +#if LWIP_AUTOIP + struct ip_hdr *iphdr = LWIP_ALIGNMENT_CAST(struct ip_hdr *, q->payload); + /* According to RFC 3297, chapter 2.6.2 (Forwarding Rules), a packet with + a link-local source address must always be "directly to its destination + on the same physical link. The host MUST NOT send the packet to any + router for forwarding". */ + if (!ip4_addr_islinklocal(&iphdr->src)) +#endif /* LWIP_AUTOIP */ + { +#ifdef LWIP_HOOK_ETHARP_GET_GW + /* For advanced routing, a single default gateway might not be enough, so get + the IP address of the gateway to handle the current destination address. */ + dst_addr = LWIP_HOOK_ETHARP_GET_GW(netif, ipaddr); + if (dst_addr == NULL) +#endif /* LWIP_HOOK_ETHARP_GET_GW */ + { + /* interface has default gateway? */ + if (!ip4_addr_isany_val(*netif_ip4_gw(netif))) { + /* send to hardware address of default gateway IP address */ + dst_addr = netif_ip4_gw(netif); + /* no default gateway available */ + } else { + /* no route to destination error (default gateway missing) */ + return ERR_RTE; + } + } + } + } +#if LWIP_NETIF_HWADDRHINT + if (netif->hints != NULL) { + /* per-pcb cached entry was given */ + netif_addr_idx_t etharp_cached_entry = netif->hints->addr_hint; + if (etharp_cached_entry < ARP_TABLE_SIZE) { +#endif /* LWIP_NETIF_HWADDRHINT */ + if ((arp_table[etharp_cached_entry].state >= ETHARP_STATE_STABLE) && +#if ETHARP_TABLE_MATCH_NETIF + (arp_table[etharp_cached_entry].netif == netif) && +#endif + (ip4_addr_cmp(dst_addr, &arp_table[etharp_cached_entry].ipaddr))) { + /* the per-pcb-cached entry is stable and the right one! */ + ETHARP_STATS_INC(etharp.cachehit); + return etharp_output_to_arp_index(netif, q, etharp_cached_entry); + } +#if LWIP_NETIF_HWADDRHINT + } + } +#endif /* LWIP_NETIF_HWADDRHINT */ + + /* find stable entry: do this here since this is a critical path for + throughput and etharp_find_entry() is kind of slow */ + for (i = 0; i < ARP_TABLE_SIZE; i++) { + if ((arp_table[i].state >= ETHARP_STATE_STABLE) && +#if ETHARP_TABLE_MATCH_NETIF + (arp_table[i].netif == netif) && +#endif + (ip4_addr_cmp(dst_addr, &arp_table[i].ipaddr))) { + /* found an existing, stable entry */ + ETHARP_SET_ADDRHINT(netif, i); + return etharp_output_to_arp_index(netif, q, i); + } + } + /* no stable entry found, use the (slower) query function: + queue on destination Ethernet address belonging to ipaddr */ + return etharp_query(netif, dst_addr, q); + } + + /* continuation for multicast/broadcast destinations */ + /* obtain source Ethernet address of the given interface */ + /* send packet directly on the link */ + return ethernet_output(netif, q, (struct eth_addr *)(netif->hwaddr), dest, ETHTYPE_IP); +} + +/** + * Send an ARP request for the given IP address and/or queue a packet. + * + * If the IP address was not yet in the cache, a pending ARP cache entry + * is added and an ARP request is sent for the given address. The packet + * is queued on this entry. + * + * If the IP address was already pending in the cache, a new ARP request + * is sent for the given address. The packet is queued on this entry. + * + * If the IP address was already stable in the cache, and a packet is + * given, it is directly sent and no ARP request is sent out. + * + * If the IP address was already stable in the cache, and no packet is + * given, an ARP request is sent out. + * + * @param netif The lwIP network interface on which ipaddr + * must be queried for. + * @param ipaddr The IP address to be resolved. + * @param q If non-NULL, a pbuf that must be delivered to the IP address. + * q is not freed by this function. + * + * @note q must only be ONE packet, not a packet queue! + * + * @return + * - ERR_BUF Could not make room for Ethernet header. + * - ERR_MEM Hardware address unknown, and no more ARP entries available + * to query for address or queue the packet. + * - ERR_MEM Could not queue packet due to memory shortage. + * - ERR_RTE No route to destination (no gateway to external networks). + * - ERR_ARG Non-unicast address given, those will not appear in ARP cache. + * + */ +err_t +etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q) +{ + struct eth_addr *srcaddr = (struct eth_addr *)netif->hwaddr; + err_t result = ERR_MEM; + int is_new_entry = 0; + s16_t i_err; + netif_addr_idx_t i; + + /* non-unicast address? */ + if (ip4_addr_isbroadcast(ipaddr, netif) || + ip4_addr_ismulticast(ipaddr) || + ip4_addr_isany(ipaddr)) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: will not add non-unicast IP address to ARP cache\n")); + return ERR_ARG; + } + + /* find entry in ARP cache, ask to create entry if queueing packet */ + i_err = etharp_find_entry(ipaddr, ETHARP_FLAG_TRY_HARD, netif); + + /* could not find or create entry? */ + if (i_err < 0) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not create ARP entry\n")); + if (q) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: packet dropped\n")); + ETHARP_STATS_INC(etharp.memerr); + } + return (err_t)i_err; + } + LWIP_ASSERT("type overflow", (size_t)i_err < NETIF_ADDR_IDX_MAX); + i = (netif_addr_idx_t)i_err; + + /* mark a fresh entry as pending (we just sent a request) */ + if (arp_table[i].state == ETHARP_STATE_EMPTY) { + is_new_entry = 1; + arp_table[i].state = ETHARP_STATE_PENDING; + /* record network interface for re-sending arp request in etharp_tmr */ + arp_table[i].netif = netif; + } + + /* { i is either a STABLE or (new or existing) PENDING entry } */ + LWIP_ASSERT("arp_table[i].state == PENDING or STABLE", + ((arp_table[i].state == ETHARP_STATE_PENDING) || + (arp_table[i].state >= ETHARP_STATE_STABLE))); + + /* do we have a new entry? or an implicit query request? */ + if (is_new_entry || (q == NULL)) { + /* try to resolve it; send out ARP request */ + result = etharp_request(netif, ipaddr); + if (result != ERR_OK) { + /* ARP request couldn't be sent */ + /* We don't re-send arp request in etharp_tmr, but we still queue packets, + since this failure could be temporary, and the next packet calling + etharp_query again could lead to sending the queued packets. */ + } + if (q == NULL) { + return result; + } + } + + /* packet given? */ + LWIP_ASSERT("q != NULL", q != NULL); + /* stable entry? */ + if (arp_table[i].state >= ETHARP_STATE_STABLE) { + /* we have a valid IP->Ethernet address mapping */ + ETHARP_SET_ADDRHINT(netif, i); + /* send the packet */ + result = ethernet_output(netif, q, srcaddr, &(arp_table[i].ethaddr), ETHTYPE_IP); + /* pending entry? (either just created or already pending */ + } else if (arp_table[i].state == ETHARP_STATE_PENDING) { + /* entry is still pending, queue the given packet 'q' */ + struct pbuf *p; + int copy_needed = 0; + /* IF q includes a pbuf that must be copied, copy the whole chain into a + * new PBUF_RAM. See the definition of PBUF_NEEDS_COPY for details. */ + p = q; + while (p) { + LWIP_ASSERT("no packet queues allowed!", (p->len != p->tot_len) || (p->next == 0)); + if (PBUF_NEEDS_COPY(p)) { + copy_needed = 1; + break; + } + p = p->next; + } + if (copy_needed) { + /* copy the whole packet into new pbufs */ + p = pbuf_clone(PBUF_LINK, PBUF_RAM, q); + } else { + /* referencing the old pbuf is enough */ + p = q; + pbuf_ref(p); + } + /* packet could be taken over? */ + if (p != NULL) { + /* queue packet ... */ +#if ARP_QUEUEING + struct etharp_q_entry *new_entry; + /* allocate a new arp queue entry */ + new_entry = (struct etharp_q_entry *)memp_malloc(MEMP_ARP_QUEUE); + if (new_entry != NULL) { + unsigned int qlen = 0; + new_entry->next = 0; + new_entry->p = p; + if (arp_table[i].q != NULL) { + /* queue was already existent, append the new entry to the end */ + struct etharp_q_entry *r; + r = arp_table[i].q; + qlen++; + while (r->next != NULL) { + r = r->next; + qlen++; + } + r->next = new_entry; + } else { + /* queue did not exist, first item in queue */ + arp_table[i].q = new_entry; + } +#if ARP_QUEUE_LEN + if (qlen >= ARP_QUEUE_LEN) { + struct etharp_q_entry *old; + old = arp_table[i].q; + arp_table[i].q = arp_table[i].q->next; + pbuf_free(old->p); + memp_free(MEMP_ARP_QUEUE, old); + } +#endif + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"U16_F"\n", (void *)q, i)); + result = ERR_OK; + } else { + /* the pool MEMP_ARP_QUEUE is empty */ + pbuf_free(p); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q)); + result = ERR_MEM; + } +#else /* ARP_QUEUEING */ + /* always queue one packet per ARP request only, freeing a previously queued packet */ + if (arp_table[i].q != NULL) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: dropped previously queued packet %p for ARP entry %"U16_F"\n", (void *)q, (u16_t)i)); + pbuf_free(arp_table[i].q); + } + arp_table[i].q = p; + result = ERR_OK; + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: queued packet %p on ARP entry %"U16_F"\n", (void *)q, (u16_t)i)); +#endif /* ARP_QUEUEING */ + } else { + ETHARP_STATS_INC(etharp.memerr); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_query: could not queue a copy of PBUF_REF packet %p (out of memory)\n", (void *)q)); + result = ERR_MEM; + } + } + return result; +} + +/** + * Send a raw ARP packet (opcode and all addresses can be modified) + * + * @param netif the lwip network interface on which to send the ARP packet + * @param ethsrc_addr the source MAC address for the ethernet header + * @param ethdst_addr the destination MAC address for the ethernet header + * @param hwsrc_addr the source MAC address for the ARP protocol header + * @param ipsrc_addr the source IP address for the ARP protocol header + * @param hwdst_addr the destination MAC address for the ARP protocol header + * @param ipdst_addr the destination IP address for the ARP protocol header + * @param opcode the type of the ARP packet + * @return ERR_OK if the ARP packet has been sent + * ERR_MEM if the ARP packet couldn't be allocated + * any other err_t on failure + */ +static err_t +etharp_raw(struct netif *netif, const struct eth_addr *ethsrc_addr, + const struct eth_addr *ethdst_addr, + const struct eth_addr *hwsrc_addr, const ip4_addr_t *ipsrc_addr, + const struct eth_addr *hwdst_addr, const ip4_addr_t *ipdst_addr, + const u16_t opcode) +{ + struct pbuf *p; + err_t result = ERR_OK; + struct etharp_hdr *hdr; + + LWIP_ASSERT("netif != NULL", netif != NULL); + + /* allocate a pbuf for the outgoing ARP request packet */ + p = pbuf_alloc(PBUF_LINK, SIZEOF_ETHARP_HDR, PBUF_RAM); + /* could allocate a pbuf for an ARP request? */ + if (p == NULL) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("etharp_raw: could not allocate pbuf for ARP request.\n")); + ETHARP_STATS_INC(etharp.memerr); + return ERR_MEM; + } + LWIP_ASSERT("check that first pbuf can hold struct etharp_hdr", + (p->len >= SIZEOF_ETHARP_HDR)); + + hdr = (struct etharp_hdr *)p->payload; + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_raw: sending raw ARP packet.\n")); + hdr->opcode = lwip_htons(opcode); + + LWIP_ASSERT("netif->hwaddr_len must be the same as ETH_HWADDR_LEN for etharp!", + (netif->hwaddr_len == ETH_HWADDR_LEN)); + + /* Write the ARP MAC-Addresses */ + SMEMCPY(&hdr->shwaddr, hwsrc_addr, ETH_HWADDR_LEN); + SMEMCPY(&hdr->dhwaddr, hwdst_addr, ETH_HWADDR_LEN); + /* Copy struct ip4_addr_wordaligned to aligned ip4_addr, to support compilers without + * structure packing. */ + IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->sipaddr, ipsrc_addr); + IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(&hdr->dipaddr, ipdst_addr); + + hdr->hwtype = PP_HTONS(LWIP_IANA_HWTYPE_ETHERNET); + hdr->proto = PP_HTONS(ETHTYPE_IP); + /* set hwlen and protolen */ + hdr->hwlen = ETH_HWADDR_LEN; + hdr->protolen = sizeof(ip4_addr_t); + + /* send ARP query */ +#if LWIP_AUTOIP + /* If we are using Link-Local, all ARP packets that contain a Link-Local + * 'sender IP address' MUST be sent using link-layer broadcast instead of + * link-layer unicast. (See RFC3927 Section 2.5, last paragraph) */ + if (ip4_addr_islinklocal(ipsrc_addr)) { + ethernet_output(netif, p, ethsrc_addr, ðbroadcast, ETHTYPE_ARP); + } else +#endif /* LWIP_AUTOIP */ + { + ethernet_output(netif, p, ethsrc_addr, ethdst_addr, ETHTYPE_ARP); + } + + ETHARP_STATS_INC(etharp.xmit); + /* free ARP query packet */ + pbuf_free(p); + p = NULL; + /* could not allocate pbuf for ARP request */ + + return result; +} + +/** + * Send an ARP request packet asking for ipaddr to a specific eth address. + * Used to send unicast request to refresh the ARP table just before an entry + * times out + * + * @param netif the lwip network interface on which to send the request + * @param ipaddr the IP address for which to ask + * @param hw_dst_addr the ethernet address to send this packet to + * @return ERR_OK if the request has been sent + * ERR_MEM if the ARP packet couldn't be allocated + * any other err_t on failure + */ +static err_t +etharp_request_dst(struct netif *netif, const ip4_addr_t *ipaddr, const struct eth_addr *hw_dst_addr) +{ + return etharp_raw(netif, (struct eth_addr *)netif->hwaddr, hw_dst_addr, + (struct eth_addr *)netif->hwaddr, netif_ip4_addr(netif), ðzero, + ipaddr, ARP_REQUEST); +} + +/** + * Send an ARP request packet asking for ipaddr. + * + * @param netif the lwip network interface on which to send the request + * @param ipaddr the IP address for which to ask + * @return ERR_OK if the request has been sent + * ERR_MEM if the ARP packet couldn't be allocated + * any other err_t on failure + */ +err_t +etharp_request(struct netif *netif, const ip4_addr_t *ipaddr) +{ + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("etharp_request: sending ARP request.\n")); + return etharp_request_dst(netif, ipaddr, ðbroadcast); +} + +#endif /* LWIP_IPV4 && LWIP_ARP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/icmp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/icmp.c index fd9054b6..a462ccd3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/icmp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/icmp.c @@ -1,404 +1,404 @@ -/** - * @file - * ICMP - Internet Control Message Protocol - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -/* Some ICMP messages should be passed to the transport protocols. This - is not implemented. */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 && LWIP_ICMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/icmp.h" -#include "lwip/inet_chksum.h" -#include "lwip/ip.h" -#include "lwip/def.h" -#include "lwip/stats.h" - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -/** Small optimization: set to 0 if incoming PBUF_POOL pbuf always can be - * used to modify and send a response packet (and to 1 if this is not the case, - * e.g. when link header is stripped off when receiving) */ -#ifndef LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN -#define LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN 1 -#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN */ - -/* The amount of data from the original packet to return in a dest-unreachable */ -#define ICMP_DEST_UNREACH_DATASIZE 8 - -static void icmp_send_response(struct pbuf *p, u8_t type, u8_t code); - -/** - * Processes ICMP input packets, called from ip_input(). - * - * Currently only processes icmp echo requests and sends - * out the echo response. - * - * @param p the icmp echo request packet, p->payload pointing to the icmp header - * @param inp the netif on which this packet was received - */ -void -icmp_input(struct pbuf *p, struct netif *inp) -{ - u8_t type; -#ifdef LWIP_DEBUG - u8_t code; -#endif /* LWIP_DEBUG */ - struct icmp_echo_hdr *iecho; - const struct ip_hdr *iphdr_in; - u16_t hlen; - const ip4_addr_t *src; - - ICMP_STATS_INC(icmp.recv); - MIB2_STATS_INC(mib2.icmpinmsgs); - - iphdr_in = ip4_current_header(); - hlen = IPH_HL_BYTES(iphdr_in); - if (hlen < IP_HLEN) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short IP header (%"S16_F" bytes) received\n", hlen)); - goto lenerr; - } - if (p->len < sizeof(u16_t) * 2) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short ICMP (%"U16_F" bytes) received\n", p->tot_len)); - goto lenerr; - } - - type = *((u8_t *)p->payload); -#ifdef LWIP_DEBUG - code = *(((u8_t *)p->payload) + 1); - /* if debug is enabled but debug statement below is somehow disabled: */ - LWIP_UNUSED_ARG(code); -#endif /* LWIP_DEBUG */ - switch (type) { - case ICMP_ER: - /* This is OK, echo reply might have been parsed by a raw PCB - (as obviously, an echo request has been sent, too). */ - MIB2_STATS_INC(mib2.icmpinechoreps); - break; - case ICMP_ECHO: - MIB2_STATS_INC(mib2.icmpinechos); - src = ip4_current_dest_addr(); - /* multicast destination address? */ - if (ip4_addr_ismulticast(ip4_current_dest_addr())) { -#if LWIP_MULTICAST_PING - /* For multicast, use address of receiving interface as source address */ - src = netif_ip4_addr(inp); -#else /* LWIP_MULTICAST_PING */ - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to multicast pings\n")); - goto icmperr; -#endif /* LWIP_MULTICAST_PING */ - } - /* broadcast destination address? */ - if (ip4_addr_isbroadcast(ip4_current_dest_addr(), ip_current_netif())) { -#if LWIP_BROADCAST_PING - /* For broadcast, use address of receiving interface as source address */ - src = netif_ip4_addr(inp); -#else /* LWIP_BROADCAST_PING */ - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to broadcast pings\n")); - goto icmperr; -#endif /* LWIP_BROADCAST_PING */ - } - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ping\n")); - if (p->tot_len < sizeof(struct icmp_echo_hdr)) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: bad ICMP echo received\n")); - goto lenerr; - } -#if CHECKSUM_CHECK_ICMP - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_ICMP) { - if (inet_chksum_pbuf(p) != 0) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: checksum failed for received ICMP echo\n")); - pbuf_free(p); - ICMP_STATS_INC(icmp.chkerr); - MIB2_STATS_INC(mib2.icmpinerrors); - return; - } - } -#endif -#if LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN - if (pbuf_add_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) { - /* p is not big enough to contain link headers - * allocate a new one and copy p into it - */ - struct pbuf *r; - u16_t alloc_len = (u16_t)(p->tot_len + hlen); - if (alloc_len < p->tot_len) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed (tot_len overflow)\n")); - goto icmperr; - } - /* allocate new packet buffer with space for link headers */ - r = pbuf_alloc(PBUF_LINK, alloc_len, PBUF_RAM); - if (r == NULL) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed\n")); - goto icmperr; - } - if (r->len < hlen + sizeof(struct icmp_echo_hdr)) { - LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("first pbuf cannot hold the ICMP header")); - pbuf_free(r); - goto icmperr; - } - /* copy the ip header */ - MEMCPY(r->payload, iphdr_in, hlen); - /* switch r->payload back to icmp header (cannot fail) */ - if (pbuf_remove_header(r, hlen)) { - LWIP_ASSERT("icmp_input: moving r->payload to icmp header failed\n", 0); - pbuf_free(r); - goto icmperr; - } - /* copy the rest of the packet without ip header */ - if (pbuf_copy(r, p) != ERR_OK) { - LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("icmp_input: copying to new pbuf failed")); - pbuf_free(r); - goto icmperr; - } - /* free the original p */ - pbuf_free(p); - /* we now have an identical copy of p that has room for link headers */ - p = r; - } else { - /* restore p->payload to point to icmp header (cannot fail) */ - if (pbuf_remove_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) { - LWIP_ASSERT("icmp_input: restoring original p->payload failed\n", 0); - goto icmperr; - } - } -#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN */ - /* At this point, all checks are OK. */ - /* We generate an answer by switching the dest and src ip addresses, - * setting the icmp type to ECHO_RESPONSE and updating the checksum. */ - iecho = (struct icmp_echo_hdr *)p->payload; - if (pbuf_add_header(p, hlen)) { - LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Can't move over header in packet")); - } else { - err_t ret; - struct ip_hdr *iphdr = (struct ip_hdr *)p->payload; - ip4_addr_copy(iphdr->src, *src); - ip4_addr_copy(iphdr->dest, *ip4_current_src_addr()); - ICMPH_TYPE_SET(iecho, ICMP_ER); -#if CHECKSUM_GEN_ICMP - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_ICMP) { - /* adjust the checksum */ - if (iecho->chksum > PP_HTONS(0xffffU - (ICMP_ECHO << 8))) { - iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS((u16_t)(ICMP_ECHO << 8)) + 1); - } else { - iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS(ICMP_ECHO << 8)); - } - } -#if LWIP_CHECKSUM_CTRL_PER_NETIF - else { - iecho->chksum = 0; - } -#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ -#else /* CHECKSUM_GEN_ICMP */ - iecho->chksum = 0; -#endif /* CHECKSUM_GEN_ICMP */ - - /* Set the correct TTL and recalculate the header checksum. */ - IPH_TTL_SET(iphdr, ICMP_TTL); - IPH_CHKSUM_SET(iphdr, 0); -#if CHECKSUM_GEN_IP - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_IP) { - IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, hlen)); - } -#endif /* CHECKSUM_GEN_IP */ - - ICMP_STATS_INC(icmp.xmit); - /* increase number of messages attempted to send */ - MIB2_STATS_INC(mib2.icmpoutmsgs); - /* increase number of echo replies attempted to send */ - MIB2_STATS_INC(mib2.icmpoutechoreps); - - /* send an ICMP packet */ - ret = ip4_output_if(p, src, LWIP_IP_HDRINCL, - ICMP_TTL, 0, IP_PROTO_ICMP, inp); - if (ret != ERR_OK) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ip_output_if returned an error: %s\n", lwip_strerr(ret))); - } - } - break; - default: - if (type == ICMP_DUR) { - MIB2_STATS_INC(mib2.icmpindestunreachs); - } else if (type == ICMP_TE) { - MIB2_STATS_INC(mib2.icmpintimeexcds); - } else if (type == ICMP_PP) { - MIB2_STATS_INC(mib2.icmpinparmprobs); - } else if (type == ICMP_SQ) { - MIB2_STATS_INC(mib2.icmpinsrcquenchs); - } else if (type == ICMP_RD) { - MIB2_STATS_INC(mib2.icmpinredirects); - } else if (type == ICMP_TS) { - MIB2_STATS_INC(mib2.icmpintimestamps); - } else if (type == ICMP_TSR) { - MIB2_STATS_INC(mib2.icmpintimestampreps); - } else if (type == ICMP_AM) { - MIB2_STATS_INC(mib2.icmpinaddrmasks); - } else if (type == ICMP_AMR) { - MIB2_STATS_INC(mib2.icmpinaddrmaskreps); - } - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ICMP type %"S16_F" code %"S16_F" not supported.\n", - (s16_t)type, (s16_t)code)); - ICMP_STATS_INC(icmp.proterr); - ICMP_STATS_INC(icmp.drop); - } - pbuf_free(p); - return; -lenerr: - pbuf_free(p); - ICMP_STATS_INC(icmp.lenerr); - MIB2_STATS_INC(mib2.icmpinerrors); - return; -#if LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN || !LWIP_MULTICAST_PING || !LWIP_BROADCAST_PING -icmperr: - pbuf_free(p); - ICMP_STATS_INC(icmp.err); - MIB2_STATS_INC(mib2.icmpinerrors); - return; -#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN || !LWIP_MULTICAST_PING || !LWIP_BROADCAST_PING */ -} - -/** - * Send an icmp 'destination unreachable' packet, called from ip_input() if - * the transport layer protocol is unknown and from udp_input() if the local - * port is not bound. - * - * @param p the input packet for which the 'unreachable' should be sent, - * p->payload pointing to the IP header - * @param t type of the 'unreachable' packet - */ -void -icmp_dest_unreach(struct pbuf *p, enum icmp_dur_type t) -{ - MIB2_STATS_INC(mib2.icmpoutdestunreachs); - icmp_send_response(p, ICMP_DUR, t); -} - -#if IP_FORWARD || IP_REASSEMBLY -/** - * Send a 'time exceeded' packet, called from ip_forward() if TTL is 0. - * - * @param p the input packet for which the 'time exceeded' should be sent, - * p->payload pointing to the IP header - * @param t type of the 'time exceeded' packet - */ -void -icmp_time_exceeded(struct pbuf *p, enum icmp_te_type t) -{ - MIB2_STATS_INC(mib2.icmpouttimeexcds); - icmp_send_response(p, ICMP_TE, t); -} - -#endif /* IP_FORWARD || IP_REASSEMBLY */ - -/** - * Send an icmp packet in response to an incoming packet. - * - * @param p the input packet for which the 'unreachable' should be sent, - * p->payload pointing to the IP header - * @param type Type of the ICMP header - * @param code Code of the ICMP header - */ -static void -icmp_send_response(struct pbuf *p, u8_t type, u8_t code) -{ - struct pbuf *q; - struct ip_hdr *iphdr; - /* we can use the echo header here */ - struct icmp_echo_hdr *icmphdr; - ip4_addr_t iphdr_src; - struct netif *netif; - - /* increase number of messages attempted to send */ - MIB2_STATS_INC(mib2.icmpoutmsgs); - - /* ICMP header + IP header + 8 bytes of data */ - q = pbuf_alloc(PBUF_IP, sizeof(struct icmp_echo_hdr) + IP_HLEN + ICMP_DEST_UNREACH_DATASIZE, - PBUF_RAM); - if (q == NULL) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded: failed to allocate pbuf for ICMP packet.\n")); - MIB2_STATS_INC(mib2.icmpouterrors); - return; - } - LWIP_ASSERT("check that first pbuf can hold icmp message", - (q->len >= (sizeof(struct icmp_echo_hdr) + IP_HLEN + ICMP_DEST_UNREACH_DATASIZE))); - - iphdr = (struct ip_hdr *)p->payload; - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded from ")); - ip4_addr_debug_print_val(ICMP_DEBUG, iphdr->src); - LWIP_DEBUGF(ICMP_DEBUG, (" to ")); - ip4_addr_debug_print_val(ICMP_DEBUG, iphdr->dest); - LWIP_DEBUGF(ICMP_DEBUG, ("\n")); - - icmphdr = (struct icmp_echo_hdr *)q->payload; - icmphdr->type = type; - icmphdr->code = code; - icmphdr->id = 0; - icmphdr->seqno = 0; - - /* copy fields from original packet */ - SMEMCPY((u8_t *)q->payload + sizeof(struct icmp_echo_hdr), (u8_t *)p->payload, - IP_HLEN + ICMP_DEST_UNREACH_DATASIZE); - - ip4_addr_copy(iphdr_src, iphdr->src); -#ifdef LWIP_HOOK_IP4_ROUTE_SRC - { - ip4_addr_t iphdr_dst; - ip4_addr_copy(iphdr_dst, iphdr->dest); - netif = ip4_route_src(&iphdr_dst, &iphdr_src); - } -#else - netif = ip4_route(&iphdr_src); -#endif - if (netif != NULL) { - /* calculate checksum */ - icmphdr->chksum = 0; -#if CHECKSUM_GEN_ICMP - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP) { - icmphdr->chksum = inet_chksum(icmphdr, q->len); - } -#endif - ICMP_STATS_INC(icmp.xmit); - ip4_output_if(q, NULL, &iphdr_src, ICMP_TTL, 0, IP_PROTO_ICMP, netif); - } - pbuf_free(q); -} - -#endif /* LWIP_IPV4 && LWIP_ICMP */ +/** + * @file + * ICMP - Internet Control Message Protocol + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/* Some ICMP messages should be passed to the transport protocols. This + is not implemented. */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_ICMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/icmp.h" +#include "lwip/inet_chksum.h" +#include "lwip/ip.h" +#include "lwip/def.h" +#include "lwip/stats.h" + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +/** Small optimization: set to 0 if incoming PBUF_POOL pbuf always can be + * used to modify and send a response packet (and to 1 if this is not the case, + * e.g. when link header is stripped off when receiving) */ +#ifndef LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN +#define LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN 1 +#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN */ + +/* The amount of data from the original packet to return in a dest-unreachable */ +#define ICMP_DEST_UNREACH_DATASIZE 8 + +static void icmp_send_response(struct pbuf *p, u8_t type, u8_t code); + +/** + * Processes ICMP input packets, called from ip_input(). + * + * Currently only processes icmp echo requests and sends + * out the echo response. + * + * @param p the icmp echo request packet, p->payload pointing to the icmp header + * @param inp the netif on which this packet was received + */ +void +icmp_input(struct pbuf *p, struct netif *inp) +{ + u8_t type; +#ifdef LWIP_DEBUG + u8_t code; +#endif /* LWIP_DEBUG */ + struct icmp_echo_hdr *iecho; + const struct ip_hdr *iphdr_in; + u16_t hlen; + const ip4_addr_t *src; + + ICMP_STATS_INC(icmp.recv); + MIB2_STATS_INC(mib2.icmpinmsgs); + + iphdr_in = ip4_current_header(); + hlen = IPH_HL_BYTES(iphdr_in); + if (hlen < IP_HLEN) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short IP header (%"S16_F" bytes) received\n", hlen)); + goto lenerr; + } + if (p->len < sizeof(u16_t) * 2) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: short ICMP (%"U16_F" bytes) received\n", p->tot_len)); + goto lenerr; + } + + type = *((u8_t *)p->payload); +#ifdef LWIP_DEBUG + code = *(((u8_t *)p->payload) + 1); + /* if debug is enabled but debug statement below is somehow disabled: */ + LWIP_UNUSED_ARG(code); +#endif /* LWIP_DEBUG */ + switch (type) { + case ICMP_ER: + /* This is OK, echo reply might have been parsed by a raw PCB + (as obviously, an echo request has been sent, too). */ + MIB2_STATS_INC(mib2.icmpinechoreps); + break; + case ICMP_ECHO: + MIB2_STATS_INC(mib2.icmpinechos); + src = ip4_current_dest_addr(); + /* multicast destination address? */ + if (ip4_addr_ismulticast(ip4_current_dest_addr())) { +#if LWIP_MULTICAST_PING + /* For multicast, use address of receiving interface as source address */ + src = netif_ip4_addr(inp); +#else /* LWIP_MULTICAST_PING */ + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to multicast pings\n")); + goto icmperr; +#endif /* LWIP_MULTICAST_PING */ + } + /* broadcast destination address? */ + if (ip4_addr_isbroadcast(ip4_current_dest_addr(), ip_current_netif())) { +#if LWIP_BROADCAST_PING + /* For broadcast, use address of receiving interface as source address */ + src = netif_ip4_addr(inp); +#else /* LWIP_BROADCAST_PING */ + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: Not echoing to broadcast pings\n")); + goto icmperr; +#endif /* LWIP_BROADCAST_PING */ + } + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ping\n")); + if (p->tot_len < sizeof(struct icmp_echo_hdr)) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: bad ICMP echo received\n")); + goto lenerr; + } +#if CHECKSUM_CHECK_ICMP + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_ICMP) { + if (inet_chksum_pbuf(p) != 0) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: checksum failed for received ICMP echo\n")); + pbuf_free(p); + ICMP_STATS_INC(icmp.chkerr); + MIB2_STATS_INC(mib2.icmpinerrors); + return; + } + } +#endif +#if LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN + if (pbuf_add_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) { + /* p is not big enough to contain link headers + * allocate a new one and copy p into it + */ + struct pbuf *r; + u16_t alloc_len = (u16_t)(p->tot_len + hlen); + if (alloc_len < p->tot_len) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed (tot_len overflow)\n")); + goto icmperr; + } + /* allocate new packet buffer with space for link headers */ + r = pbuf_alloc(PBUF_LINK, alloc_len, PBUF_RAM); + if (r == NULL) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: allocating new pbuf failed\n")); + goto icmperr; + } + if (r->len < hlen + sizeof(struct icmp_echo_hdr)) { + LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("first pbuf cannot hold the ICMP header")); + pbuf_free(r); + goto icmperr; + } + /* copy the ip header */ + MEMCPY(r->payload, iphdr_in, hlen); + /* switch r->payload back to icmp header (cannot fail) */ + if (pbuf_remove_header(r, hlen)) { + LWIP_ASSERT("icmp_input: moving r->payload to icmp header failed\n", 0); + pbuf_free(r); + goto icmperr; + } + /* copy the rest of the packet without ip header */ + if (pbuf_copy(r, p) != ERR_OK) { + LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("icmp_input: copying to new pbuf failed")); + pbuf_free(r); + goto icmperr; + } + /* free the original p */ + pbuf_free(p); + /* we now have an identical copy of p that has room for link headers */ + p = r; + } else { + /* restore p->payload to point to icmp header (cannot fail) */ + if (pbuf_remove_header(p, hlen + PBUF_LINK_HLEN + PBUF_LINK_ENCAPSULATION_HLEN)) { + LWIP_ASSERT("icmp_input: restoring original p->payload failed\n", 0); + goto icmperr; + } + } +#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN */ + /* At this point, all checks are OK. */ + /* We generate an answer by switching the dest and src ip addresses, + * setting the icmp type to ECHO_RESPONSE and updating the checksum. */ + iecho = (struct icmp_echo_hdr *)p->payload; + if (pbuf_add_header(p, hlen)) { + LWIP_DEBUGF(ICMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Can't move over header in packet")); + } else { + err_t ret; + struct ip_hdr *iphdr = (struct ip_hdr *)p->payload; + ip4_addr_copy(iphdr->src, *src); + ip4_addr_copy(iphdr->dest, *ip4_current_src_addr()); + ICMPH_TYPE_SET(iecho, ICMP_ER); +#if CHECKSUM_GEN_ICMP + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_ICMP) { + /* adjust the checksum */ + if (iecho->chksum > PP_HTONS(0xffffU - (ICMP_ECHO << 8))) { + iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS((u16_t)(ICMP_ECHO << 8)) + 1); + } else { + iecho->chksum = (u16_t)(iecho->chksum + PP_HTONS(ICMP_ECHO << 8)); + } + } +#if LWIP_CHECKSUM_CTRL_PER_NETIF + else { + iecho->chksum = 0; + } +#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ +#else /* CHECKSUM_GEN_ICMP */ + iecho->chksum = 0; +#endif /* CHECKSUM_GEN_ICMP */ + + /* Set the correct TTL and recalculate the header checksum. */ + IPH_TTL_SET(iphdr, ICMP_TTL); + IPH_CHKSUM_SET(iphdr, 0); +#if CHECKSUM_GEN_IP + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_IP) { + IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, hlen)); + } +#endif /* CHECKSUM_GEN_IP */ + + ICMP_STATS_INC(icmp.xmit); + /* increase number of messages attempted to send */ + MIB2_STATS_INC(mib2.icmpoutmsgs); + /* increase number of echo replies attempted to send */ + MIB2_STATS_INC(mib2.icmpoutechoreps); + + /* send an ICMP packet */ + ret = ip4_output_if(p, src, LWIP_IP_HDRINCL, + ICMP_TTL, 0, IP_PROTO_ICMP, inp); + if (ret != ERR_OK) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ip_output_if returned an error: %s\n", lwip_strerr(ret))); + } + } + break; + default: + if (type == ICMP_DUR) { + MIB2_STATS_INC(mib2.icmpindestunreachs); + } else if (type == ICMP_TE) { + MIB2_STATS_INC(mib2.icmpintimeexcds); + } else if (type == ICMP_PP) { + MIB2_STATS_INC(mib2.icmpinparmprobs); + } else if (type == ICMP_SQ) { + MIB2_STATS_INC(mib2.icmpinsrcquenchs); + } else if (type == ICMP_RD) { + MIB2_STATS_INC(mib2.icmpinredirects); + } else if (type == ICMP_TS) { + MIB2_STATS_INC(mib2.icmpintimestamps); + } else if (type == ICMP_TSR) { + MIB2_STATS_INC(mib2.icmpintimestampreps); + } else if (type == ICMP_AM) { + MIB2_STATS_INC(mib2.icmpinaddrmasks); + } else if (type == ICMP_AMR) { + MIB2_STATS_INC(mib2.icmpinaddrmaskreps); + } + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_input: ICMP type %"S16_F" code %"S16_F" not supported.\n", + (s16_t)type, (s16_t)code)); + ICMP_STATS_INC(icmp.proterr); + ICMP_STATS_INC(icmp.drop); + } + pbuf_free(p); + return; +lenerr: + pbuf_free(p); + ICMP_STATS_INC(icmp.lenerr); + MIB2_STATS_INC(mib2.icmpinerrors); + return; +#if LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN || !LWIP_MULTICAST_PING || !LWIP_BROADCAST_PING +icmperr: + pbuf_free(p); + ICMP_STATS_INC(icmp.err); + MIB2_STATS_INC(mib2.icmpinerrors); + return; +#endif /* LWIP_ICMP_ECHO_CHECK_INPUT_PBUF_LEN || !LWIP_MULTICAST_PING || !LWIP_BROADCAST_PING */ +} + +/** + * Send an icmp 'destination unreachable' packet, called from ip_input() if + * the transport layer protocol is unknown and from udp_input() if the local + * port is not bound. + * + * @param p the input packet for which the 'unreachable' should be sent, + * p->payload pointing to the IP header + * @param t type of the 'unreachable' packet + */ +void +icmp_dest_unreach(struct pbuf *p, enum icmp_dur_type t) +{ + MIB2_STATS_INC(mib2.icmpoutdestunreachs); + icmp_send_response(p, ICMP_DUR, t); +} + +#if IP_FORWARD || IP_REASSEMBLY +/** + * Send a 'time exceeded' packet, called from ip_forward() if TTL is 0. + * + * @param p the input packet for which the 'time exceeded' should be sent, + * p->payload pointing to the IP header + * @param t type of the 'time exceeded' packet + */ +void +icmp_time_exceeded(struct pbuf *p, enum icmp_te_type t) +{ + MIB2_STATS_INC(mib2.icmpouttimeexcds); + icmp_send_response(p, ICMP_TE, t); +} + +#endif /* IP_FORWARD || IP_REASSEMBLY */ + +/** + * Send an icmp packet in response to an incoming packet. + * + * @param p the input packet for which the 'unreachable' should be sent, + * p->payload pointing to the IP header + * @param type Type of the ICMP header + * @param code Code of the ICMP header + */ +static void +icmp_send_response(struct pbuf *p, u8_t type, u8_t code) +{ + struct pbuf *q; + struct ip_hdr *iphdr; + /* we can use the echo header here */ + struct icmp_echo_hdr *icmphdr; + ip4_addr_t iphdr_src; + struct netif *netif; + + /* increase number of messages attempted to send */ + MIB2_STATS_INC(mib2.icmpoutmsgs); + + /* ICMP header + IP header + 8 bytes of data */ + q = pbuf_alloc(PBUF_IP, sizeof(struct icmp_echo_hdr) + IP_HLEN + ICMP_DEST_UNREACH_DATASIZE, + PBUF_RAM); + if (q == NULL) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded: failed to allocate pbuf for ICMP packet.\n")); + MIB2_STATS_INC(mib2.icmpouterrors); + return; + } + LWIP_ASSERT("check that first pbuf can hold icmp message", + (q->len >= (sizeof(struct icmp_echo_hdr) + IP_HLEN + ICMP_DEST_UNREACH_DATASIZE))); + + iphdr = (struct ip_hdr *)p->payload; + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded from ")); + ip4_addr_debug_print_val(ICMP_DEBUG, iphdr->src); + LWIP_DEBUGF(ICMP_DEBUG, (" to ")); + ip4_addr_debug_print_val(ICMP_DEBUG, iphdr->dest); + LWIP_DEBUGF(ICMP_DEBUG, ("\n")); + + icmphdr = (struct icmp_echo_hdr *)q->payload; + icmphdr->type = type; + icmphdr->code = code; + icmphdr->id = 0; + icmphdr->seqno = 0; + + /* copy fields from original packet */ + SMEMCPY((u8_t *)q->payload + sizeof(struct icmp_echo_hdr), (u8_t *)p->payload, + IP_HLEN + ICMP_DEST_UNREACH_DATASIZE); + + ip4_addr_copy(iphdr_src, iphdr->src); +#ifdef LWIP_HOOK_IP4_ROUTE_SRC + { + ip4_addr_t iphdr_dst; + ip4_addr_copy(iphdr_dst, iphdr->dest); + netif = ip4_route_src(&iphdr_dst, &iphdr_src); + } +#else + netif = ip4_route(&iphdr_src); +#endif + if (netif != NULL) { + /* calculate checksum */ + icmphdr->chksum = 0; +#if CHECKSUM_GEN_ICMP + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP) { + icmphdr->chksum = inet_chksum(icmphdr, q->len); + } +#endif + ICMP_STATS_INC(icmp.xmit); + ip4_output_if(q, NULL, &iphdr_src, ICMP_TTL, 0, IP_PROTO_ICMP, netif); + } + pbuf_free(q); +} + +#endif /* LWIP_IPV4 && LWIP_ICMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/igmp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/igmp.c index 61f45d95..b655aa3a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/igmp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/igmp.c @@ -1,801 +1,801 @@ -/** - * @file - * IGMP - Internet Group Management Protocol - * - * @defgroup igmp IGMP - * @ingroup ip4 - * To be called from TCPIP thread - */ - -/* - * Copyright (c) 2002 CITEL Technologies 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 CITEL Technologies Ltd 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 CITEL TECHNOLOGIES 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 CITEL TECHNOLOGIES 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. - * - * This file is a contribution to the lwIP TCP/IP stack. - * The Swedish Institute of Computer Science and Adam Dunkels - * are specifically granted permission to redistribute this - * source code. -*/ - -/*------------------------------------------------------------- -Note 1) -Although the rfc requires V1 AND V2 capability -we will only support v2 since now V1 is very old (August 1989) -V1 can be added if required - -a debug print and statistic have been implemented to -show this up. -------------------------------------------------------------- -------------------------------------------------------------- -Note 2) -A query for a specific group address (as opposed to ALLHOSTS) -has now been implemented as I am unsure if it is required - -a debug print and statistic have been implemented to -show this up. -------------------------------------------------------------- -------------------------------------------------------------- -Note 3) -The router alert rfc 2113 is implemented in outgoing packets -but not checked rigorously incoming -------------------------------------------------------------- -Steve Reynolds -------------------------------------------------------------*/ - -/*----------------------------------------------------------------------------- - * RFC 988 - Host extensions for IP multicasting - V0 - * RFC 1054 - Host extensions for IP multicasting - - * RFC 1112 - Host extensions for IP multicasting - V1 - * RFC 2236 - Internet Group Management Protocol, Version 2 - V2 <- this code is based on this RFC (it's the "de facto" standard) - * RFC 3376 - Internet Group Management Protocol, Version 3 - V3 - * RFC 4604 - Using Internet Group Management Protocol Version 3... - V3+ - * RFC 2113 - IP Router Alert Option - - *----------------------------------------------------------------------------*/ - -/*----------------------------------------------------------------------------- - * Includes - *----------------------------------------------------------------------------*/ - -#include "lwip/opt.h" - -#if LWIP_IPV4 && LWIP_IGMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/igmp.h" -#include "lwip/debug.h" -#include "lwip/def.h" -#include "lwip/mem.h" -#include "lwip/ip.h" -#include "lwip/inet_chksum.h" -#include "lwip/netif.h" -#include "lwip/stats.h" -#include "lwip/prot/igmp.h" - -#include - -static struct igmp_group *igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr); -static err_t igmp_remove_group(struct netif *netif, struct igmp_group *group); -static void igmp_timeout(struct netif *netif, struct igmp_group *group); -static void igmp_start_timer(struct igmp_group *group, u8_t max_time); -static void igmp_delaying_member(struct igmp_group *group, u8_t maxresp); -static err_t igmp_ip_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, struct netif *netif); -static void igmp_send(struct netif *netif, struct igmp_group *group, u8_t type); - -static ip4_addr_t allsystems; -static ip4_addr_t allrouters; - -/** - * Initialize the IGMP module - */ -void -igmp_init(void) -{ - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_init: initializing\n")); - - IP4_ADDR(&allsystems, 224, 0, 0, 1); - IP4_ADDR(&allrouters, 224, 0, 0, 2); -} - -/** - * Start IGMP processing on interface - * - * @param netif network interface on which start IGMP processing - */ -err_t -igmp_start(struct netif *netif) -{ - struct igmp_group *group; - - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: starting IGMP processing on if %p\n", (void *)netif)); - - group = igmp_lookup_group(netif, &allsystems); - - if (group != NULL) { - group->group_state = IGMP_GROUP_IDLE_MEMBER; - group->use++; - - /* Allow the igmp messages at the MAC level */ - if (netif->igmp_mac_filter != NULL) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: igmp_mac_filter(ADD ")); - ip4_addr_debug_print_val(IGMP_DEBUG, allsystems); - LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); - netif->igmp_mac_filter(netif, &allsystems, NETIF_ADD_MAC_FILTER); - } - - return ERR_OK; - } - - return ERR_MEM; -} - -/** - * Stop IGMP processing on interface - * - * @param netif network interface on which stop IGMP processing - */ -err_t -igmp_stop(struct netif *netif) -{ - struct igmp_group *group = netif_igmp_data(netif); - - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, NULL); - - while (group != NULL) { - struct igmp_group *next = group->next; /* avoid use-after-free below */ - - /* disable the group at the MAC level */ - if (netif->igmp_mac_filter != NULL) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_stop: igmp_mac_filter(DEL ")); - ip4_addr_debug_print_val(IGMP_DEBUG, group->group_address); - LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); - netif->igmp_mac_filter(netif, &(group->group_address), NETIF_DEL_MAC_FILTER); - } - - /* free group */ - memp_free(MEMP_IGMP_GROUP, group); - - /* move to "next" */ - group = next; - } - return ERR_OK; -} - -/** - * Report IGMP memberships for this interface - * - * @param netif network interface on which report IGMP memberships - */ -void -igmp_report_groups(struct netif *netif) -{ - struct igmp_group *group = netif_igmp_data(netif); - - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_report_groups: sending IGMP reports on if %p\n", (void *)netif)); - - /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */ - if (group != NULL) { - group = group->next; - } - - while (group != NULL) { - igmp_delaying_member(group, IGMP_JOIN_DELAYING_MEMBER_TMR); - group = group->next; - } -} - -/** - * Search for a group in the netif's igmp group list - * - * @param ifp the network interface for which to look - * @param addr the group ip address to search for - * @return a struct igmp_group* if the group has been found, - * NULL if the group wasn't found. - */ -struct igmp_group * -igmp_lookfor_group(struct netif *ifp, const ip4_addr_t *addr) -{ - struct igmp_group *group = netif_igmp_data(ifp); - - while (group != NULL) { - if (ip4_addr_cmp(&(group->group_address), addr)) { - return group; - } - group = group->next; - } - - /* to be clearer, we return NULL here instead of - * 'group' (which is also NULL at this point). - */ - return NULL; -} - -/** - * Search for a specific igmp group and create a new one if not found- - * - * @param ifp the network interface for which to look - * @param addr the group ip address to search - * @return a struct igmp_group*, - * NULL on memory error. - */ -static struct igmp_group * -igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr) -{ - struct igmp_group *group; - struct igmp_group *list_head = netif_igmp_data(ifp); - - /* Search if the group already exists */ - group = igmp_lookfor_group(ifp, addr); - if (group != NULL) { - /* Group already exists. */ - return group; - } - - /* Group doesn't exist yet, create a new one */ - group = (struct igmp_group *)memp_malloc(MEMP_IGMP_GROUP); - if (group != NULL) { - ip4_addr_set(&(group->group_address), addr); - group->timer = 0; /* Not running */ - group->group_state = IGMP_GROUP_NON_MEMBER; - group->last_reporter_flag = 0; - group->use = 0; - - /* Ensure allsystems group is always first in list */ - if (list_head == NULL) { - /* this is the first entry in linked list */ - LWIP_ASSERT("igmp_lookup_group: first group must be allsystems", - (ip4_addr_cmp(addr, &allsystems) != 0)); - group->next = NULL; - netif_set_client_data(ifp, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, group); - } else { - /* append _after_ first entry */ - LWIP_ASSERT("igmp_lookup_group: all except first group must not be allsystems", - (ip4_addr_cmp(addr, &allsystems) == 0)); - group->next = list_head->next; - list_head->next = group; - } - } - - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_lookup_group: %sallocated a new group with address ", (group ? "" : "impossible to "))); - ip4_addr_debug_print(IGMP_DEBUG, addr); - LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)ifp)); - - return group; -} - -/** - * Remove a group from netif's igmp group list, but don't free it yet - * - * @param group the group to remove from the netif's igmp group list - * @return ERR_OK if group was removed from the list, an err_t otherwise - */ -static err_t -igmp_remove_group(struct netif *netif, struct igmp_group *group) -{ - err_t err = ERR_OK; - struct igmp_group *tmp_group; - - /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */ - for (tmp_group = netif_igmp_data(netif); tmp_group != NULL; tmp_group = tmp_group->next) { - if (tmp_group->next == group) { - tmp_group->next = group->next; - break; - } - } - /* Group not found in netif's igmp group list */ - if (tmp_group == NULL) { - err = ERR_ARG; - } - - return err; -} - -/** - * Called from ip_input() if a new IGMP packet is received. - * - * @param p received igmp packet, p->payload pointing to the igmp header - * @param inp network interface on which the packet was received - * @param dest destination ip address of the igmp packet - */ -void -igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest) -{ - struct igmp_msg *igmp; - struct igmp_group *group; - struct igmp_group *groupref; - - IGMP_STATS_INC(igmp.recv); - - /* Note that the length CAN be greater than 8 but only 8 are used - All are included in the checksum */ - if (p->len < IGMP_MINLEN) { - pbuf_free(p); - IGMP_STATS_INC(igmp.lenerr); - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: length error\n")); - return; - } - - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: message from ")); - ip4_addr_debug_print_val(IGMP_DEBUG, ip4_current_header()->src); - LWIP_DEBUGF(IGMP_DEBUG, (" to address ")); - ip4_addr_debug_print_val(IGMP_DEBUG, ip4_current_header()->dest); - LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)inp)); - - /* Now calculate and check the checksum */ - igmp = (struct igmp_msg *)p->payload; - if (inet_chksum(igmp, p->len)) { - pbuf_free(p); - IGMP_STATS_INC(igmp.chkerr); - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: checksum error\n")); - return; - } - - /* Packet is ok so find an existing group */ - group = igmp_lookfor_group(inp, dest); /* use the destination IP address of incoming packet */ - - /* If group can be found or create... */ - if (!group) { - pbuf_free(p); - IGMP_STATS_INC(igmp.drop); - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP frame not for us\n")); - return; - } - - /* NOW ACT ON THE INCOMING MESSAGE TYPE... */ - switch (igmp->igmp_msgtype) { - case IGMP_MEMB_QUERY: - /* IGMP_MEMB_QUERY to the "all systems" address ? */ - if ((ip4_addr_cmp(dest, &allsystems)) && ip4_addr_isany(&igmp->igmp_group_address)) { - /* THIS IS THE GENERAL QUERY */ - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: General IGMP_MEMB_QUERY on \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); - - if (igmp->igmp_maxresp == 0) { - IGMP_STATS_INC(igmp.rx_v1); - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: got an all hosts query with time== 0 - this is V1 and not implemented - treat as v2\n")); - igmp->igmp_maxresp = IGMP_V1_DELAYING_MEMBER_TMR; - } else { - IGMP_STATS_INC(igmp.rx_general); - } - - groupref = netif_igmp_data(inp); - - /* Do not send messages on the all systems group address! */ - /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */ - if (groupref != NULL) { - groupref = groupref->next; - } - - while (groupref) { - igmp_delaying_member(groupref, igmp->igmp_maxresp); - groupref = groupref->next; - } - } else { - /* IGMP_MEMB_QUERY to a specific group ? */ - if (!ip4_addr_isany(&igmp->igmp_group_address)) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_MEMB_QUERY to a specific group ")); - ip4_addr_debug_print_val(IGMP_DEBUG, igmp->igmp_group_address); - if (ip4_addr_cmp(dest, &allsystems)) { - ip4_addr_t groupaddr; - LWIP_DEBUGF(IGMP_DEBUG, (" using \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); - /* we first need to re-look for the group since we used dest last time */ - ip4_addr_copy(groupaddr, igmp->igmp_group_address); - group = igmp_lookfor_group(inp, &groupaddr); - } else { - LWIP_DEBUGF(IGMP_DEBUG, (" with the group address as destination [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); - } - - if (group != NULL) { - IGMP_STATS_INC(igmp.rx_group); - igmp_delaying_member(group, igmp->igmp_maxresp); - } else { - IGMP_STATS_INC(igmp.drop); - } - } else { - IGMP_STATS_INC(igmp.proterr); - } - } - break; - case IGMP_V2_MEMB_REPORT: - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_V2_MEMB_REPORT\n")); - IGMP_STATS_INC(igmp.rx_report); - if (group->group_state == IGMP_GROUP_DELAYING_MEMBER) { - /* This is on a specific group we have already looked up */ - group->timer = 0; /* stopped */ - group->group_state = IGMP_GROUP_IDLE_MEMBER; - group->last_reporter_flag = 0; - } - break; - default: - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: unexpected msg %d in state %d on group %p on if %p\n", - igmp->igmp_msgtype, group->group_state, (void *)&group, (void *)inp)); - IGMP_STATS_INC(igmp.proterr); - break; - } - - pbuf_free(p); - return; -} - -/** - * @ingroup igmp - * Join a group on one network interface. - * - * @param ifaddr ip address of the network interface which should join a new group - * @param groupaddr the ip address of the group which to join - * @return ERR_OK if group was joined on the netif(s), an err_t otherwise - */ -err_t -igmp_joingroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr) -{ - err_t err = ERR_VAL; /* no matching interface */ - struct netif *netif; - - LWIP_ASSERT_CORE_LOCKED(); - - /* make sure it is multicast address */ - LWIP_ERROR("igmp_joingroup: attempt to join non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); - LWIP_ERROR("igmp_joingroup: attempt to join allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); - - /* loop through netif's */ - NETIF_FOREACH(netif) { - /* Should we join this interface ? */ - if ((netif->flags & NETIF_FLAG_IGMP) && ((ip4_addr_isany(ifaddr) || ip4_addr_cmp(netif_ip4_addr(netif), ifaddr)))) { - err = igmp_joingroup_netif(netif, groupaddr); - if (err != ERR_OK) { - /* Return an error even if some network interfaces are joined */ - /** @todo undo any other netif already joined */ - return err; - } - } - } - - return err; -} - -/** - * @ingroup igmp - * Join a group on one network interface. - * - * @param netif the network interface which should join a new group - * @param groupaddr the ip address of the group which to join - * @return ERR_OK if group was joined on the netif, an err_t otherwise - */ -err_t -igmp_joingroup_netif(struct netif *netif, const ip4_addr_t *groupaddr) -{ - struct igmp_group *group; - - LWIP_ASSERT_CORE_LOCKED(); - - /* make sure it is multicast address */ - LWIP_ERROR("igmp_joingroup_netif: attempt to join non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); - LWIP_ERROR("igmp_joingroup_netif: attempt to join allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); - - /* make sure it is an igmp-enabled netif */ - LWIP_ERROR("igmp_joingroup_netif: attempt to join on non-IGMP netif", netif->flags & NETIF_FLAG_IGMP, return ERR_VAL;); - - /* find group or create a new one if not found */ - group = igmp_lookup_group(netif, groupaddr); - - if (group != NULL) { - /* This should create a new group, check the state to make sure */ - if (group->group_state != IGMP_GROUP_NON_MEMBER) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: join to group not in state IGMP_GROUP_NON_MEMBER\n")); - } else { - /* OK - it was new group */ - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: join to new group: ")); - ip4_addr_debug_print(IGMP_DEBUG, groupaddr); - LWIP_DEBUGF(IGMP_DEBUG, ("\n")); - - /* If first use of the group, allow the group at the MAC level */ - if ((group->use == 0) && (netif->igmp_mac_filter != NULL)) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: igmp_mac_filter(ADD ")); - ip4_addr_debug_print(IGMP_DEBUG, groupaddr); - LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); - netif->igmp_mac_filter(netif, groupaddr, NETIF_ADD_MAC_FILTER); - } - - IGMP_STATS_INC(igmp.tx_join); - igmp_send(netif, group, IGMP_V2_MEMB_REPORT); - - igmp_start_timer(group, IGMP_JOIN_DELAYING_MEMBER_TMR); - - /* Need to work out where this timer comes from */ - group->group_state = IGMP_GROUP_DELAYING_MEMBER; - } - /* Increment group use */ - group->use++; - /* Join on this interface */ - return ERR_OK; - } else { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: Not enough memory to join to group\n")); - return ERR_MEM; - } -} - -/** - * @ingroup igmp - * Leave a group on one network interface. - * - * @param ifaddr ip address of the network interface which should leave a group - * @param groupaddr the ip address of the group which to leave - * @return ERR_OK if group was left on the netif(s), an err_t otherwise - */ -err_t -igmp_leavegroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr) -{ - err_t err = ERR_VAL; /* no matching interface */ - struct netif *netif; - - LWIP_ASSERT_CORE_LOCKED(); - - /* make sure it is multicast address */ - LWIP_ERROR("igmp_leavegroup: attempt to leave non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); - LWIP_ERROR("igmp_leavegroup: attempt to leave allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); - - /* loop through netif's */ - NETIF_FOREACH(netif) { - /* Should we leave this interface ? */ - if ((netif->flags & NETIF_FLAG_IGMP) && ((ip4_addr_isany(ifaddr) || ip4_addr_cmp(netif_ip4_addr(netif), ifaddr)))) { - err_t res = igmp_leavegroup_netif(netif, groupaddr); - if (err != ERR_OK) { - /* Store this result if we have not yet gotten a success */ - err = res; - } - } - } - - return err; -} - -/** - * @ingroup igmp - * Leave a group on one network interface. - * - * @param netif the network interface which should leave a group - * @param groupaddr the ip address of the group which to leave - * @return ERR_OK if group was left on the netif, an err_t otherwise - */ -err_t -igmp_leavegroup_netif(struct netif *netif, const ip4_addr_t *groupaddr) -{ - struct igmp_group *group; - - LWIP_ASSERT_CORE_LOCKED(); - - /* make sure it is multicast address */ - LWIP_ERROR("igmp_leavegroup_netif: attempt to leave non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); - LWIP_ERROR("igmp_leavegroup_netif: attempt to leave allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); - - /* make sure it is an igmp-enabled netif */ - LWIP_ERROR("igmp_leavegroup_netif: attempt to leave on non-IGMP netif", netif->flags & NETIF_FLAG_IGMP, return ERR_VAL;); - - /* find group */ - group = igmp_lookfor_group(netif, groupaddr); - - if (group != NULL) { - /* Only send a leave if the flag is set according to the state diagram */ - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: Leaving group: ")); - ip4_addr_debug_print(IGMP_DEBUG, groupaddr); - LWIP_DEBUGF(IGMP_DEBUG, ("\n")); - - /* If there is no other use of the group */ - if (group->use <= 1) { - /* Remove the group from the list */ - igmp_remove_group(netif, group); - - /* If we are the last reporter for this group */ - if (group->last_reporter_flag) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: sending leaving group\n")); - IGMP_STATS_INC(igmp.tx_leave); - igmp_send(netif, group, IGMP_LEAVE_GROUP); - } - - /* Disable the group at the MAC level */ - if (netif->igmp_mac_filter != NULL) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: igmp_mac_filter(DEL ")); - ip4_addr_debug_print(IGMP_DEBUG, groupaddr); - LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); - netif->igmp_mac_filter(netif, groupaddr, NETIF_DEL_MAC_FILTER); - } - - /* Free group struct */ - memp_free(MEMP_IGMP_GROUP, group); - } else { - /* Decrement group use */ - group->use--; - } - return ERR_OK; - } else { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: not member of group\n")); - return ERR_VAL; - } -} - -/** - * The igmp timer function (both for NO_SYS=1 and =0) - * Should be called every IGMP_TMR_INTERVAL milliseconds (100 ms is default). - */ -void -igmp_tmr(void) -{ - struct netif *netif; - - NETIF_FOREACH(netif) { - struct igmp_group *group = netif_igmp_data(netif); - - while (group != NULL) { - if (group->timer > 0) { - group->timer--; - if (group->timer == 0) { - igmp_timeout(netif, group); - } - } - group = group->next; - } - } -} - -/** - * Called if a timeout for one group is reached. - * Sends a report for this group. - * - * @param group an igmp_group for which a timeout is reached - */ -static void -igmp_timeout(struct netif *netif, struct igmp_group *group) -{ - /* If the state is IGMP_GROUP_DELAYING_MEMBER then we send a report for this group - (unless it is the allsystems group) */ - if ((group->group_state == IGMP_GROUP_DELAYING_MEMBER) && - (!(ip4_addr_cmp(&(group->group_address), &allsystems)))) { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_timeout: report membership for group with address ")); - ip4_addr_debug_print_val(IGMP_DEBUG, group->group_address); - LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)netif)); - - group->group_state = IGMP_GROUP_IDLE_MEMBER; - - IGMP_STATS_INC(igmp.tx_report); - igmp_send(netif, group, IGMP_V2_MEMB_REPORT); - } -} - -/** - * Start a timer for an igmp group - * - * @param group the igmp_group for which to start a timer - * @param max_time the time in multiples of IGMP_TMR_INTERVAL (decrease with - * every call to igmp_tmr()) - */ -static void -igmp_start_timer(struct igmp_group *group, u8_t max_time) -{ -#ifdef LWIP_RAND - group->timer = (u16_t)(max_time > 2 ? (LWIP_RAND() % max_time) : 1); -#else /* LWIP_RAND */ - /* ATTENTION: use this only if absolutely necessary! */ - group->timer = max_time / 2; -#endif /* LWIP_RAND */ - - if (group->timer == 0) { - group->timer = 1; - } -} - -/** - * Delaying membership report for a group if necessary - * - * @param group the igmp_group for which "delaying" membership report - * @param maxresp query delay - */ -static void -igmp_delaying_member(struct igmp_group *group, u8_t maxresp) -{ - if ((group->group_state == IGMP_GROUP_IDLE_MEMBER) || - ((group->group_state == IGMP_GROUP_DELAYING_MEMBER) && - ((group->timer == 0) || (maxresp < group->timer)))) { - igmp_start_timer(group, maxresp); - group->group_state = IGMP_GROUP_DELAYING_MEMBER; - } -} - - -/** - * Sends an IP packet on a network interface. This function constructs the IP header - * and calculates the IP header checksum. If the source IP address is NULL, - * the IP address of the outgoing network interface is filled in as source address. - * - * @param p the packet to send (p->payload points to the data, e.g. next - protocol header; if dest == LWIP_IP_HDRINCL, p already includes an - IP header and p->payload points to that IP header) - * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the - * IP address of the netif used to send is used as source address) - * @param dest the destination IP address to send the packet to - * @param netif the netif on which to send this packet - * @return ERR_OK if the packet was sent OK - * ERR_BUF if p doesn't have enough space for IP/LINK headers - * returns errors returned by netif->output - */ -static err_t -igmp_ip_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, struct netif *netif) -{ - /* This is the "router alert" option */ - u16_t ra[2]; - ra[0] = PP_HTONS(ROUTER_ALERT); - ra[1] = 0x0000; /* Router shall examine packet */ - IGMP_STATS_INC(igmp.xmit); - return ip4_output_if_opt(p, src, dest, IGMP_TTL, 0, IP_PROTO_IGMP, netif, ra, ROUTER_ALERTLEN); -} - -/** - * Send an igmp packet to a specific group. - * - * @param group the group to which to send the packet - * @param type the type of igmp packet to send - */ -static void -igmp_send(struct netif *netif, struct igmp_group *group, u8_t type) -{ - struct pbuf *p = NULL; - struct igmp_msg *igmp = NULL; - ip4_addr_t src = *IP4_ADDR_ANY4; - ip4_addr_t *dest = NULL; - - /* IP header + "router alert" option + IGMP header */ - p = pbuf_alloc(PBUF_TRANSPORT, IGMP_MINLEN, PBUF_RAM); - - if (p) { - igmp = (struct igmp_msg *)p->payload; - LWIP_ASSERT("igmp_send: check that first pbuf can hold struct igmp_msg", - (p->len >= sizeof(struct igmp_msg))); - ip4_addr_copy(src, *netif_ip4_addr(netif)); - - if (type == IGMP_V2_MEMB_REPORT) { - dest = &(group->group_address); - ip4_addr_copy(igmp->igmp_group_address, group->group_address); - group->last_reporter_flag = 1; /* Remember we were the last to report */ - } else { - if (type == IGMP_LEAVE_GROUP) { - dest = &allrouters; - ip4_addr_copy(igmp->igmp_group_address, group->group_address); - } - } - - if ((type == IGMP_V2_MEMB_REPORT) || (type == IGMP_LEAVE_GROUP)) { - igmp->igmp_msgtype = type; - igmp->igmp_maxresp = 0; - igmp->igmp_checksum = 0; - igmp->igmp_checksum = inet_chksum(igmp, IGMP_MINLEN); - - igmp_ip_output_if(p, &src, dest, netif); - } - - pbuf_free(p); - } else { - LWIP_DEBUGF(IGMP_DEBUG, ("igmp_send: not enough memory for igmp_send\n")); - IGMP_STATS_INC(igmp.memerr); - } -} - -#endif /* LWIP_IPV4 && LWIP_IGMP */ +/** + * @file + * IGMP - Internet Group Management Protocol + * + * @defgroup igmp IGMP + * @ingroup ip4 + * To be called from TCPIP thread + */ + +/* + * Copyright (c) 2002 CITEL Technologies 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 CITEL Technologies Ltd 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 CITEL TECHNOLOGIES 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 CITEL TECHNOLOGIES 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. + * + * This file is a contribution to the lwIP TCP/IP stack. + * The Swedish Institute of Computer Science and Adam Dunkels + * are specifically granted permission to redistribute this + * source code. +*/ + +/*------------------------------------------------------------- +Note 1) +Although the rfc requires V1 AND V2 capability +we will only support v2 since now V1 is very old (August 1989) +V1 can be added if required + +a debug print and statistic have been implemented to +show this up. +------------------------------------------------------------- +------------------------------------------------------------- +Note 2) +A query for a specific group address (as opposed to ALLHOSTS) +has now been implemented as I am unsure if it is required + +a debug print and statistic have been implemented to +show this up. +------------------------------------------------------------- +------------------------------------------------------------- +Note 3) +The router alert rfc 2113 is implemented in outgoing packets +but not checked rigorously incoming +------------------------------------------------------------- +Steve Reynolds +------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------- + * RFC 988 - Host extensions for IP multicasting - V0 + * RFC 1054 - Host extensions for IP multicasting - + * RFC 1112 - Host extensions for IP multicasting - V1 + * RFC 2236 - Internet Group Management Protocol, Version 2 - V2 <- this code is based on this RFC (it's the "de facto" standard) + * RFC 3376 - Internet Group Management Protocol, Version 3 - V3 + * RFC 4604 - Using Internet Group Management Protocol Version 3... - V3+ + * RFC 2113 - IP Router Alert Option - + *----------------------------------------------------------------------------*/ + +/*----------------------------------------------------------------------------- + * Includes + *----------------------------------------------------------------------------*/ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_IGMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/igmp.h" +#include "lwip/debug.h" +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/ip.h" +#include "lwip/inet_chksum.h" +#include "lwip/netif.h" +#include "lwip/stats.h" +#include "lwip/prot/igmp.h" + +#include + +static struct igmp_group *igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr); +static err_t igmp_remove_group(struct netif *netif, struct igmp_group *group); +static void igmp_timeout(struct netif *netif, struct igmp_group *group); +static void igmp_start_timer(struct igmp_group *group, u8_t max_time); +static void igmp_delaying_member(struct igmp_group *group, u8_t maxresp); +static err_t igmp_ip_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, struct netif *netif); +static void igmp_send(struct netif *netif, struct igmp_group *group, u8_t type); + +static ip4_addr_t allsystems; +static ip4_addr_t allrouters; + +/** + * Initialize the IGMP module + */ +void +igmp_init(void) +{ + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_init: initializing\n")); + + IP4_ADDR(&allsystems, 224, 0, 0, 1); + IP4_ADDR(&allrouters, 224, 0, 0, 2); +} + +/** + * Start IGMP processing on interface + * + * @param netif network interface on which start IGMP processing + */ +err_t +igmp_start(struct netif *netif) +{ + struct igmp_group *group; + + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: starting IGMP processing on if %p\n", (void *)netif)); + + group = igmp_lookup_group(netif, &allsystems); + + if (group != NULL) { + group->group_state = IGMP_GROUP_IDLE_MEMBER; + group->use++; + + /* Allow the igmp messages at the MAC level */ + if (netif->igmp_mac_filter != NULL) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_start: igmp_mac_filter(ADD ")); + ip4_addr_debug_print_val(IGMP_DEBUG, allsystems); + LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); + netif->igmp_mac_filter(netif, &allsystems, NETIF_ADD_MAC_FILTER); + } + + return ERR_OK; + } + + return ERR_MEM; +} + +/** + * Stop IGMP processing on interface + * + * @param netif network interface on which stop IGMP processing + */ +err_t +igmp_stop(struct netif *netif) +{ + struct igmp_group *group = netif_igmp_data(netif); + + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, NULL); + + while (group != NULL) { + struct igmp_group *next = group->next; /* avoid use-after-free below */ + + /* disable the group at the MAC level */ + if (netif->igmp_mac_filter != NULL) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_stop: igmp_mac_filter(DEL ")); + ip4_addr_debug_print_val(IGMP_DEBUG, group->group_address); + LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); + netif->igmp_mac_filter(netif, &(group->group_address), NETIF_DEL_MAC_FILTER); + } + + /* free group */ + memp_free(MEMP_IGMP_GROUP, group); + + /* move to "next" */ + group = next; + } + return ERR_OK; +} + +/** + * Report IGMP memberships for this interface + * + * @param netif network interface on which report IGMP memberships + */ +void +igmp_report_groups(struct netif *netif) +{ + struct igmp_group *group = netif_igmp_data(netif); + + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_report_groups: sending IGMP reports on if %p\n", (void *)netif)); + + /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */ + if (group != NULL) { + group = group->next; + } + + while (group != NULL) { + igmp_delaying_member(group, IGMP_JOIN_DELAYING_MEMBER_TMR); + group = group->next; + } +} + +/** + * Search for a group in the netif's igmp group list + * + * @param ifp the network interface for which to look + * @param addr the group ip address to search for + * @return a struct igmp_group* if the group has been found, + * NULL if the group wasn't found. + */ +struct igmp_group * +igmp_lookfor_group(struct netif *ifp, const ip4_addr_t *addr) +{ + struct igmp_group *group = netif_igmp_data(ifp); + + while (group != NULL) { + if (ip4_addr_cmp(&(group->group_address), addr)) { + return group; + } + group = group->next; + } + + /* to be clearer, we return NULL here instead of + * 'group' (which is also NULL at this point). + */ + return NULL; +} + +/** + * Search for a specific igmp group and create a new one if not found- + * + * @param ifp the network interface for which to look + * @param addr the group ip address to search + * @return a struct igmp_group*, + * NULL on memory error. + */ +static struct igmp_group * +igmp_lookup_group(struct netif *ifp, const ip4_addr_t *addr) +{ + struct igmp_group *group; + struct igmp_group *list_head = netif_igmp_data(ifp); + + /* Search if the group already exists */ + group = igmp_lookfor_group(ifp, addr); + if (group != NULL) { + /* Group already exists. */ + return group; + } + + /* Group doesn't exist yet, create a new one */ + group = (struct igmp_group *)memp_malloc(MEMP_IGMP_GROUP); + if (group != NULL) { + ip4_addr_set(&(group->group_address), addr); + group->timer = 0; /* Not running */ + group->group_state = IGMP_GROUP_NON_MEMBER; + group->last_reporter_flag = 0; + group->use = 0; + + /* Ensure allsystems group is always first in list */ + if (list_head == NULL) { + /* this is the first entry in linked list */ + LWIP_ASSERT("igmp_lookup_group: first group must be allsystems", + (ip4_addr_cmp(addr, &allsystems) != 0)); + group->next = NULL; + netif_set_client_data(ifp, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, group); + } else { + /* append _after_ first entry */ + LWIP_ASSERT("igmp_lookup_group: all except first group must not be allsystems", + (ip4_addr_cmp(addr, &allsystems) == 0)); + group->next = list_head->next; + list_head->next = group; + } + } + + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_lookup_group: %sallocated a new group with address ", (group ? "" : "impossible to "))); + ip4_addr_debug_print(IGMP_DEBUG, addr); + LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)ifp)); + + return group; +} + +/** + * Remove a group from netif's igmp group list, but don't free it yet + * + * @param group the group to remove from the netif's igmp group list + * @return ERR_OK if group was removed from the list, an err_t otherwise + */ +static err_t +igmp_remove_group(struct netif *netif, struct igmp_group *group) +{ + err_t err = ERR_OK; + struct igmp_group *tmp_group; + + /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */ + for (tmp_group = netif_igmp_data(netif); tmp_group != NULL; tmp_group = tmp_group->next) { + if (tmp_group->next == group) { + tmp_group->next = group->next; + break; + } + } + /* Group not found in netif's igmp group list */ + if (tmp_group == NULL) { + err = ERR_ARG; + } + + return err; +} + +/** + * Called from ip_input() if a new IGMP packet is received. + * + * @param p received igmp packet, p->payload pointing to the igmp header + * @param inp network interface on which the packet was received + * @param dest destination ip address of the igmp packet + */ +void +igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest) +{ + struct igmp_msg *igmp; + struct igmp_group *group; + struct igmp_group *groupref; + + IGMP_STATS_INC(igmp.recv); + + /* Note that the length CAN be greater than 8 but only 8 are used - All are included in the checksum */ + if (p->len < IGMP_MINLEN) { + pbuf_free(p); + IGMP_STATS_INC(igmp.lenerr); + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: length error\n")); + return; + } + + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: message from ")); + ip4_addr_debug_print_val(IGMP_DEBUG, ip4_current_header()->src); + LWIP_DEBUGF(IGMP_DEBUG, (" to address ")); + ip4_addr_debug_print_val(IGMP_DEBUG, ip4_current_header()->dest); + LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)inp)); + + /* Now calculate and check the checksum */ + igmp = (struct igmp_msg *)p->payload; + if (inet_chksum(igmp, p->len)) { + pbuf_free(p); + IGMP_STATS_INC(igmp.chkerr); + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: checksum error\n")); + return; + } + + /* Packet is ok so find an existing group */ + group = igmp_lookfor_group(inp, dest); /* use the destination IP address of incoming packet */ + + /* If group can be found or create... */ + if (!group) { + pbuf_free(p); + IGMP_STATS_INC(igmp.drop); + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP frame not for us\n")); + return; + } + + /* NOW ACT ON THE INCOMING MESSAGE TYPE... */ + switch (igmp->igmp_msgtype) { + case IGMP_MEMB_QUERY: + /* IGMP_MEMB_QUERY to the "all systems" address ? */ + if ((ip4_addr_cmp(dest, &allsystems)) && ip4_addr_isany(&igmp->igmp_group_address)) { + /* THIS IS THE GENERAL QUERY */ + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: General IGMP_MEMB_QUERY on \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); + + if (igmp->igmp_maxresp == 0) { + IGMP_STATS_INC(igmp.rx_v1); + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: got an all hosts query with time== 0 - this is V1 and not implemented - treat as v2\n")); + igmp->igmp_maxresp = IGMP_V1_DELAYING_MEMBER_TMR; + } else { + IGMP_STATS_INC(igmp.rx_general); + } + + groupref = netif_igmp_data(inp); + + /* Do not send messages on the all systems group address! */ + /* Skip the first group in the list, it is always the allsystems group added in igmp_start() */ + if (groupref != NULL) { + groupref = groupref->next; + } + + while (groupref) { + igmp_delaying_member(groupref, igmp->igmp_maxresp); + groupref = groupref->next; + } + } else { + /* IGMP_MEMB_QUERY to a specific group ? */ + if (!ip4_addr_isany(&igmp->igmp_group_address)) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_MEMB_QUERY to a specific group ")); + ip4_addr_debug_print_val(IGMP_DEBUG, igmp->igmp_group_address); + if (ip4_addr_cmp(dest, &allsystems)) { + ip4_addr_t groupaddr; + LWIP_DEBUGF(IGMP_DEBUG, (" using \"ALL SYSTEMS\" address (224.0.0.1) [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); + /* we first need to re-look for the group since we used dest last time */ + ip4_addr_copy(groupaddr, igmp->igmp_group_address); + group = igmp_lookfor_group(inp, &groupaddr); + } else { + LWIP_DEBUGF(IGMP_DEBUG, (" with the group address as destination [igmp_maxresp=%i]\n", (int)(igmp->igmp_maxresp))); + } + + if (group != NULL) { + IGMP_STATS_INC(igmp.rx_group); + igmp_delaying_member(group, igmp->igmp_maxresp); + } else { + IGMP_STATS_INC(igmp.drop); + } + } else { + IGMP_STATS_INC(igmp.proterr); + } + } + break; + case IGMP_V2_MEMB_REPORT: + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: IGMP_V2_MEMB_REPORT\n")); + IGMP_STATS_INC(igmp.rx_report); + if (group->group_state == IGMP_GROUP_DELAYING_MEMBER) { + /* This is on a specific group we have already looked up */ + group->timer = 0; /* stopped */ + group->group_state = IGMP_GROUP_IDLE_MEMBER; + group->last_reporter_flag = 0; + } + break; + default: + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_input: unexpected msg %d in state %d on group %p on if %p\n", + igmp->igmp_msgtype, group->group_state, (void *)&group, (void *)inp)); + IGMP_STATS_INC(igmp.proterr); + break; + } + + pbuf_free(p); + return; +} + +/** + * @ingroup igmp + * Join a group on one network interface. + * + * @param ifaddr ip address of the network interface which should join a new group + * @param groupaddr the ip address of the group which to join + * @return ERR_OK if group was joined on the netif(s), an err_t otherwise + */ +err_t +igmp_joingroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr) +{ + err_t err = ERR_VAL; /* no matching interface */ + struct netif *netif; + + LWIP_ASSERT_CORE_LOCKED(); + + /* make sure it is multicast address */ + LWIP_ERROR("igmp_joingroup: attempt to join non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); + LWIP_ERROR("igmp_joingroup: attempt to join allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); + + /* loop through netif's */ + NETIF_FOREACH(netif) { + /* Should we join this interface ? */ + if ((netif->flags & NETIF_FLAG_IGMP) && ((ip4_addr_isany(ifaddr) || ip4_addr_cmp(netif_ip4_addr(netif), ifaddr)))) { + err = igmp_joingroup_netif(netif, groupaddr); + if (err != ERR_OK) { + /* Return an error even if some network interfaces are joined */ + /** @todo undo any other netif already joined */ + return err; + } + } + } + + return err; +} + +/** + * @ingroup igmp + * Join a group on one network interface. + * + * @param netif the network interface which should join a new group + * @param groupaddr the ip address of the group which to join + * @return ERR_OK if group was joined on the netif, an err_t otherwise + */ +err_t +igmp_joingroup_netif(struct netif *netif, const ip4_addr_t *groupaddr) +{ + struct igmp_group *group; + + LWIP_ASSERT_CORE_LOCKED(); + + /* make sure it is multicast address */ + LWIP_ERROR("igmp_joingroup_netif: attempt to join non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); + LWIP_ERROR("igmp_joingroup_netif: attempt to join allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); + + /* make sure it is an igmp-enabled netif */ + LWIP_ERROR("igmp_joingroup_netif: attempt to join on non-IGMP netif", netif->flags & NETIF_FLAG_IGMP, return ERR_VAL;); + + /* find group or create a new one if not found */ + group = igmp_lookup_group(netif, groupaddr); + + if (group != NULL) { + /* This should create a new group, check the state to make sure */ + if (group->group_state != IGMP_GROUP_NON_MEMBER) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: join to group not in state IGMP_GROUP_NON_MEMBER\n")); + } else { + /* OK - it was new group */ + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: join to new group: ")); + ip4_addr_debug_print(IGMP_DEBUG, groupaddr); + LWIP_DEBUGF(IGMP_DEBUG, ("\n")); + + /* If first use of the group, allow the group at the MAC level */ + if ((group->use == 0) && (netif->igmp_mac_filter != NULL)) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: igmp_mac_filter(ADD ")); + ip4_addr_debug_print(IGMP_DEBUG, groupaddr); + LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); + netif->igmp_mac_filter(netif, groupaddr, NETIF_ADD_MAC_FILTER); + } + + IGMP_STATS_INC(igmp.tx_join); + igmp_send(netif, group, IGMP_V2_MEMB_REPORT); + + igmp_start_timer(group, IGMP_JOIN_DELAYING_MEMBER_TMR); + + /* Need to work out where this timer comes from */ + group->group_state = IGMP_GROUP_DELAYING_MEMBER; + } + /* Increment group use */ + group->use++; + /* Join on this interface */ + return ERR_OK; + } else { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_joingroup_netif: Not enough memory to join to group\n")); + return ERR_MEM; + } +} + +/** + * @ingroup igmp + * Leave a group on one network interface. + * + * @param ifaddr ip address of the network interface which should leave a group + * @param groupaddr the ip address of the group which to leave + * @return ERR_OK if group was left on the netif(s), an err_t otherwise + */ +err_t +igmp_leavegroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr) +{ + err_t err = ERR_VAL; /* no matching interface */ + struct netif *netif; + + LWIP_ASSERT_CORE_LOCKED(); + + /* make sure it is multicast address */ + LWIP_ERROR("igmp_leavegroup: attempt to leave non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); + LWIP_ERROR("igmp_leavegroup: attempt to leave allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); + + /* loop through netif's */ + NETIF_FOREACH(netif) { + /* Should we leave this interface ? */ + if ((netif->flags & NETIF_FLAG_IGMP) && ((ip4_addr_isany(ifaddr) || ip4_addr_cmp(netif_ip4_addr(netif), ifaddr)))) { + err_t res = igmp_leavegroup_netif(netif, groupaddr); + if (err != ERR_OK) { + /* Store this result if we have not yet gotten a success */ + err = res; + } + } + } + + return err; +} + +/** + * @ingroup igmp + * Leave a group on one network interface. + * + * @param netif the network interface which should leave a group + * @param groupaddr the ip address of the group which to leave + * @return ERR_OK if group was left on the netif, an err_t otherwise + */ +err_t +igmp_leavegroup_netif(struct netif *netif, const ip4_addr_t *groupaddr) +{ + struct igmp_group *group; + + LWIP_ASSERT_CORE_LOCKED(); + + /* make sure it is multicast address */ + LWIP_ERROR("igmp_leavegroup_netif: attempt to leave non-multicast address", ip4_addr_ismulticast(groupaddr), return ERR_VAL;); + LWIP_ERROR("igmp_leavegroup_netif: attempt to leave allsystems address", (!ip4_addr_cmp(groupaddr, &allsystems)), return ERR_VAL;); + + /* make sure it is an igmp-enabled netif */ + LWIP_ERROR("igmp_leavegroup_netif: attempt to leave on non-IGMP netif", netif->flags & NETIF_FLAG_IGMP, return ERR_VAL;); + + /* find group */ + group = igmp_lookfor_group(netif, groupaddr); + + if (group != NULL) { + /* Only send a leave if the flag is set according to the state diagram */ + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: Leaving group: ")); + ip4_addr_debug_print(IGMP_DEBUG, groupaddr); + LWIP_DEBUGF(IGMP_DEBUG, ("\n")); + + /* If there is no other use of the group */ + if (group->use <= 1) { + /* Remove the group from the list */ + igmp_remove_group(netif, group); + + /* If we are the last reporter for this group */ + if (group->last_reporter_flag) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: sending leaving group\n")); + IGMP_STATS_INC(igmp.tx_leave); + igmp_send(netif, group, IGMP_LEAVE_GROUP); + } + + /* Disable the group at the MAC level */ + if (netif->igmp_mac_filter != NULL) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: igmp_mac_filter(DEL ")); + ip4_addr_debug_print(IGMP_DEBUG, groupaddr); + LWIP_DEBUGF(IGMP_DEBUG, (") on if %p\n", (void *)netif)); + netif->igmp_mac_filter(netif, groupaddr, NETIF_DEL_MAC_FILTER); + } + + /* Free group struct */ + memp_free(MEMP_IGMP_GROUP, group); + } else { + /* Decrement group use */ + group->use--; + } + return ERR_OK; + } else { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_leavegroup_netif: not member of group\n")); + return ERR_VAL; + } +} + +/** + * The igmp timer function (both for NO_SYS=1 and =0) + * Should be called every IGMP_TMR_INTERVAL milliseconds (100 ms is default). + */ +void +igmp_tmr(void) +{ + struct netif *netif; + + NETIF_FOREACH(netif) { + struct igmp_group *group = netif_igmp_data(netif); + + while (group != NULL) { + if (group->timer > 0) { + group->timer--; + if (group->timer == 0) { + igmp_timeout(netif, group); + } + } + group = group->next; + } + } +} + +/** + * Called if a timeout for one group is reached. + * Sends a report for this group. + * + * @param group an igmp_group for which a timeout is reached + */ +static void +igmp_timeout(struct netif *netif, struct igmp_group *group) +{ + /* If the state is IGMP_GROUP_DELAYING_MEMBER then we send a report for this group + (unless it is the allsystems group) */ + if ((group->group_state == IGMP_GROUP_DELAYING_MEMBER) && + (!(ip4_addr_cmp(&(group->group_address), &allsystems)))) { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_timeout: report membership for group with address ")); + ip4_addr_debug_print_val(IGMP_DEBUG, group->group_address); + LWIP_DEBUGF(IGMP_DEBUG, (" on if %p\n", (void *)netif)); + + group->group_state = IGMP_GROUP_IDLE_MEMBER; + + IGMP_STATS_INC(igmp.tx_report); + igmp_send(netif, group, IGMP_V2_MEMB_REPORT); + } +} + +/** + * Start a timer for an igmp group + * + * @param group the igmp_group for which to start a timer + * @param max_time the time in multiples of IGMP_TMR_INTERVAL (decrease with + * every call to igmp_tmr()) + */ +static void +igmp_start_timer(struct igmp_group *group, u8_t max_time) +{ +#ifdef LWIP_RAND + group->timer = (u16_t)(max_time > 2 ? (LWIP_RAND() % max_time) : 1); +#else /* LWIP_RAND */ + /* ATTENTION: use this only if absolutely necessary! */ + group->timer = max_time / 2; +#endif /* LWIP_RAND */ + + if (group->timer == 0) { + group->timer = 1; + } +} + +/** + * Delaying membership report for a group if necessary + * + * @param group the igmp_group for which "delaying" membership report + * @param maxresp query delay + */ +static void +igmp_delaying_member(struct igmp_group *group, u8_t maxresp) +{ + if ((group->group_state == IGMP_GROUP_IDLE_MEMBER) || + ((group->group_state == IGMP_GROUP_DELAYING_MEMBER) && + ((group->timer == 0) || (maxresp < group->timer)))) { + igmp_start_timer(group, maxresp); + group->group_state = IGMP_GROUP_DELAYING_MEMBER; + } +} + + +/** + * Sends an IP packet on a network interface. This function constructs the IP header + * and calculates the IP header checksum. If the source IP address is NULL, + * the IP address of the outgoing network interface is filled in as source address. + * + * @param p the packet to send (p->payload points to the data, e.g. next + protocol header; if dest == LWIP_IP_HDRINCL, p already includes an + IP header and p->payload points to that IP header) + * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the + * IP address of the netif used to send is used as source address) + * @param dest the destination IP address to send the packet to + * @param netif the netif on which to send this packet + * @return ERR_OK if the packet was sent OK + * ERR_BUF if p doesn't have enough space for IP/LINK headers + * returns errors returned by netif->output + */ +static err_t +igmp_ip_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, struct netif *netif) +{ + /* This is the "router alert" option */ + u16_t ra[2]; + ra[0] = PP_HTONS(ROUTER_ALERT); + ra[1] = 0x0000; /* Router shall examine packet */ + IGMP_STATS_INC(igmp.xmit); + return ip4_output_if_opt(p, src, dest, IGMP_TTL, 0, IP_PROTO_IGMP, netif, ra, ROUTER_ALERTLEN); +} + +/** + * Send an igmp packet to a specific group. + * + * @param group the group to which to send the packet + * @param type the type of igmp packet to send + */ +static void +igmp_send(struct netif *netif, struct igmp_group *group, u8_t type) +{ + struct pbuf *p = NULL; + struct igmp_msg *igmp = NULL; + ip4_addr_t src = *IP4_ADDR_ANY4; + ip4_addr_t *dest = NULL; + + /* IP header + "router alert" option + IGMP header */ + p = pbuf_alloc(PBUF_TRANSPORT, IGMP_MINLEN, PBUF_RAM); + + if (p) { + igmp = (struct igmp_msg *)p->payload; + LWIP_ASSERT("igmp_send: check that first pbuf can hold struct igmp_msg", + (p->len >= sizeof(struct igmp_msg))); + ip4_addr_copy(src, *netif_ip4_addr(netif)); + + if (type == IGMP_V2_MEMB_REPORT) { + dest = &(group->group_address); + ip4_addr_copy(igmp->igmp_group_address, group->group_address); + group->last_reporter_flag = 1; /* Remember we were the last to report */ + } else { + if (type == IGMP_LEAVE_GROUP) { + dest = &allrouters; + ip4_addr_copy(igmp->igmp_group_address, group->group_address); + } + } + + if ((type == IGMP_V2_MEMB_REPORT) || (type == IGMP_LEAVE_GROUP)) { + igmp->igmp_msgtype = type; + igmp->igmp_maxresp = 0; + igmp->igmp_checksum = 0; + igmp->igmp_checksum = inet_chksum(igmp, IGMP_MINLEN); + + igmp_ip_output_if(p, &src, dest, netif); + } + + pbuf_free(p); + } else { + LWIP_DEBUGF(IGMP_DEBUG, ("igmp_send: not enough memory for igmp_send\n")); + IGMP_STATS_INC(igmp.memerr); + } +} + +#endif /* LWIP_IPV4 && LWIP_IGMP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4.c index 7350186c..036457af 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4.c @@ -1,1133 +1,1133 @@ -/** - * @file - * This is the IPv4 layer implementation for incoming and outgoing IP traffic. - * - * @see ip_frag.c - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 - -#include "lwip/ip.h" -#include "lwip/def.h" -#include "lwip/mem.h" -#include "lwip/ip4_frag.h" -#include "lwip/inet_chksum.h" -#include "lwip/netif.h" -#include "lwip/icmp.h" -#include "lwip/igmp.h" -#include "lwip/priv/raw_priv.h" -#include "lwip/udp.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/autoip.h" -#include "lwip/stats.h" -#include "lwip/prot/iana.h" - -#include -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -/** Set this to 0 in the rare case of wanting to call an extra function to - * generate the IP checksum (in contrast to calculating it on-the-fly). */ -#ifndef LWIP_INLINE_IP_CHKSUM -#if LWIP_CHECKSUM_CTRL_PER_NETIF -#define LWIP_INLINE_IP_CHKSUM 0 -#else /* LWIP_CHECKSUM_CTRL_PER_NETIF */ -#define LWIP_INLINE_IP_CHKSUM 1 -#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ -#endif - -#if LWIP_INLINE_IP_CHKSUM && CHECKSUM_GEN_IP -#define CHECKSUM_GEN_IP_INLINE 1 -#else -#define CHECKSUM_GEN_IP_INLINE 0 -#endif - -#if LWIP_DHCP || defined(LWIP_IP_ACCEPT_UDP_PORT) -#define IP_ACCEPT_LINK_LAYER_ADDRESSING 1 - -/** Some defines for DHCP to let link-layer-addressed packets through while the - * netif is down. - * To use this in your own application/protocol, define LWIP_IP_ACCEPT_UDP_PORT(port) - * to return 1 if the port is accepted and 0 if the port is not accepted. - */ -#if LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) -/* accept DHCP client port and custom port */ -#define IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(port) (((port) == PP_NTOHS(LWIP_IANA_PORT_DHCP_CLIENT)) \ - || (LWIP_IP_ACCEPT_UDP_PORT(port))) -#elif defined(LWIP_IP_ACCEPT_UDP_PORT) /* LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) */ -/* accept custom port only */ -#define IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(port) (LWIP_IP_ACCEPT_UDP_PORT(port)) -#else /* LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) */ -/* accept DHCP client port only */ -#define IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(port) ((port) == PP_NTOHS(LWIP_IANA_PORT_DHCP_CLIENT)) -#endif /* LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) */ - -#else /* LWIP_DHCP */ -#define IP_ACCEPT_LINK_LAYER_ADDRESSING 0 -#endif /* LWIP_DHCP */ - -/** The IP header ID of the next outgoing IP packet */ -static u16_t ip_id; - -#if LWIP_MULTICAST_TX_OPTIONS -/** The default netif used for multicast */ -static struct netif *ip4_default_multicast_netif; - -/** - * @ingroup ip4 - * Set a default netif for IPv4 multicast. */ -void -ip4_set_default_multicast_netif(struct netif *default_multicast_netif) -{ - ip4_default_multicast_netif = default_multicast_netif; -} -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - -#ifdef LWIP_HOOK_IP4_ROUTE_SRC -/** - * Source based IPv4 routing must be fully implemented in - * LWIP_HOOK_IP4_ROUTE_SRC(). This function only provides the parameters. - */ -struct netif * -ip4_route_src(const ip4_addr_t *src, const ip4_addr_t *dest) -{ - if (src != NULL) { - /* when src==NULL, the hook is called from ip4_route(dest) */ - struct netif *netif = LWIP_HOOK_IP4_ROUTE_SRC(src, dest); - if (netif != NULL) { - return netif; - } - } - return ip4_route(dest); -} -#endif /* LWIP_HOOK_IP4_ROUTE_SRC */ - -/** - * Finds the appropriate network interface for a given IP address. It - * searches the list of network interfaces linearly. A match is found - * if the masked IP address of the network interface equals the masked - * IP address given to the function. - * - * @param dest the destination IP address for which to find the route - * @return the netif on which to send to reach dest - */ -struct netif * -ip4_route(const ip4_addr_t *dest) -{ -#if !LWIP_SINGLE_NETIF - struct netif *netif; - - LWIP_ASSERT_CORE_LOCKED(); - -#if LWIP_MULTICAST_TX_OPTIONS - /* Use administratively selected interface for multicast by default */ - if (ip4_addr_ismulticast(dest) && ip4_default_multicast_netif) { - return ip4_default_multicast_netif; - } -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - - /* bug #54569: in case LWIP_SINGLE_NETIF=1 and LWIP_DEBUGF() disabled, the following loop is optimized away */ - LWIP_UNUSED_ARG(dest); - - /* iterate through netifs */ - NETIF_FOREACH(netif) { - /* is the netif up, does it have a link and a valid address? */ - if (netif_is_up(netif) && netif_is_link_up(netif) && !ip4_addr_isany_val(*netif_ip4_addr(netif))) { - /* network mask matches? */ - if (ip4_addr_netcmp(dest, netif_ip4_addr(netif), netif_ip4_netmask(netif))) { - /* return netif on which to forward IP packet */ - return netif; - } - /* gateway matches on a non broadcast interface? (i.e. peer in a point to point interface) */ - if (((netif->flags & NETIF_FLAG_BROADCAST) == 0) && ip4_addr_cmp(dest, netif_ip4_gw(netif))) { - /* return netif on which to forward IP packet */ - return netif; - } - } - } - -#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF - /* loopif is disabled, looopback traffic is passed through any netif */ - if (ip4_addr_isloopback(dest)) { - /* don't check for link on loopback traffic */ - if (netif_default != NULL && netif_is_up(netif_default)) { - return netif_default; - } - /* default netif is not up, just use any netif for loopback traffic */ - NETIF_FOREACH(netif) { - if (netif_is_up(netif)) { - return netif; - } - } - return NULL; - } -#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */ - -#ifdef LWIP_HOOK_IP4_ROUTE_SRC - netif = LWIP_HOOK_IP4_ROUTE_SRC(NULL, dest); - if (netif != NULL) { - return netif; - } -#elif defined(LWIP_HOOK_IP4_ROUTE) - netif = LWIP_HOOK_IP4_ROUTE(dest); - if (netif != NULL) { - return netif; - } -#endif -#endif /* !LWIP_SINGLE_NETIF */ - - if ((netif_default == NULL) || !netif_is_up(netif_default) || !netif_is_link_up(netif_default) || - ip4_addr_isany_val(*netif_ip4_addr(netif_default)) || ip4_addr_isloopback(dest)) { - /* No matching netif found and default netif is not usable. - If this is not good enough for you, use LWIP_HOOK_IP4_ROUTE() */ - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_route: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); - IP_STATS_INC(ip.rterr); - MIB2_STATS_INC(mib2.ipoutnoroutes); - return NULL; - } - - return netif_default; -} - -#if IP_FORWARD -/** - * Determine whether an IP address is in a reserved set of addresses - * that may not be forwarded, or whether datagrams to that destination - * may be forwarded. - * @param p the packet to forward - * @return 1: can forward 0: discard - */ -static int -ip4_canforward(struct pbuf *p) -{ - u32_t addr = lwip_htonl(ip4_addr_get_u32(ip4_current_dest_addr())); - -#ifdef LWIP_HOOK_IP4_CANFORWARD - int ret = LWIP_HOOK_IP4_CANFORWARD(p, addr); - if (ret >= 0) { - return ret; - } -#endif /* LWIP_HOOK_IP4_CANFORWARD */ - - if (p->flags & PBUF_FLAG_LLBCAST) { - /* don't route link-layer broadcasts */ - return 0; - } - if ((p->flags & PBUF_FLAG_LLMCAST) || IP_MULTICAST(addr)) { - /* don't route link-layer multicasts (use LWIP_HOOK_IP4_CANFORWARD instead) */ - return 0; - } - if (IP_EXPERIMENTAL(addr)) { - return 0; - } - if (IP_CLASSA(addr)) { - u32_t net = addr & IP_CLASSA_NET; - if ((net == 0) || (net == ((u32_t)IP_LOOPBACKNET << IP_CLASSA_NSHIFT))) { - /* don't route loopback packets */ - return 0; - } - } - return 1; -} - -/** - * Forwards an IP packet. It finds an appropriate route for the - * packet, decrements the TTL value of the packet, adjusts the - * checksum and outputs the packet on the appropriate interface. - * - * @param p the packet to forward (p->payload points to IP header) - * @param iphdr the IP header of the input packet - * @param inp the netif on which this packet was received - */ -static void -ip4_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp) -{ - struct netif *netif; - - PERF_START; - LWIP_UNUSED_ARG(inp); - - if (!ip4_canforward(p)) { - goto return_noroute; - } - - /* RFC3927 2.7: do not forward link-local addresses */ - if (ip4_addr_islinklocal(ip4_current_dest_addr())) { - LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not forwarding LLA %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), - ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); - goto return_noroute; - } - - /* Find network interface where to forward this IP packet to. */ - netif = ip4_route_src(ip4_current_src_addr(), ip4_current_dest_addr()); - if (netif == NULL) { - LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: no forwarding route for %"U16_F".%"U16_F".%"U16_F".%"U16_F" found\n", - ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), - ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); - /* @todo: send ICMP_DUR_NET? */ - goto return_noroute; - } -#if !IP_FORWARD_ALLOW_TX_ON_RX_NETIF - /* Do not forward packets onto the same network interface on which - * they arrived. */ - if (netif == inp) { - LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not bouncing packets back on incoming interface.\n")); - goto return_noroute; - } -#endif /* IP_FORWARD_ALLOW_TX_ON_RX_NETIF */ - - /* decrement TTL */ - IPH_TTL_SET(iphdr, IPH_TTL(iphdr) - 1); - /* send ICMP if TTL == 0 */ - if (IPH_TTL(iphdr) == 0) { - MIB2_STATS_INC(mib2.ipinhdrerrors); -#if LWIP_ICMP - /* Don't send ICMP messages in response to ICMP messages */ - if (IPH_PROTO(iphdr) != IP_PROTO_ICMP) { - icmp_time_exceeded(p, ICMP_TE_TTL); - } -#endif /* LWIP_ICMP */ - return; - } - - /* Incrementally update the IP checksum. */ - if (IPH_CHKSUM(iphdr) >= PP_HTONS(0xffffU - 0x100)) { - IPH_CHKSUM_SET(iphdr, (u16_t)(IPH_CHKSUM(iphdr) + PP_HTONS(0x100) + 1)); - } else { - IPH_CHKSUM_SET(iphdr, (u16_t)(IPH_CHKSUM(iphdr) + PP_HTONS(0x100))); - } - - LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: forwarding packet to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), - ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); - - IP_STATS_INC(ip.fw); - MIB2_STATS_INC(mib2.ipforwdatagrams); - IP_STATS_INC(ip.xmit); - - PERF_STOP("ip4_forward"); - /* don't fragment if interface has mtu set to 0 [loopif] */ - if (netif->mtu && (p->tot_len > netif->mtu)) { - if ((IPH_OFFSET(iphdr) & PP_NTOHS(IP_DF)) == 0) { -#if IP_FRAG - ip4_frag(p, netif, ip4_current_dest_addr()); -#else /* IP_FRAG */ - /* @todo: send ICMP Destination Unreachable code 13 "Communication administratively prohibited"? */ -#endif /* IP_FRAG */ - } else { -#if LWIP_ICMP - /* send ICMP Destination Unreachable code 4: "Fragmentation Needed and DF Set" */ - icmp_dest_unreach(p, ICMP_DUR_FRAG); -#endif /* LWIP_ICMP */ - } - return; - } - /* transmit pbuf on chosen interface */ - netif->output(netif, p, ip4_current_dest_addr()); - return; -return_noroute: - MIB2_STATS_INC(mib2.ipoutnoroutes); -} -#endif /* IP_FORWARD */ - -/** Return true if the current input packet should be accepted on this netif */ -static int -ip4_input_accept(struct netif *netif) -{ - LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest 0x%"X32_F" netif->ip_addr 0x%"X32_F" (0x%"X32_F", 0x%"X32_F", 0x%"X32_F")\n", - ip4_addr_get_u32(ip4_current_dest_addr()), ip4_addr_get_u32(netif_ip4_addr(netif)), - ip4_addr_get_u32(ip4_current_dest_addr()) & ip4_addr_get_u32(netif_ip4_netmask(netif)), - ip4_addr_get_u32(netif_ip4_addr(netif)) & ip4_addr_get_u32(netif_ip4_netmask(netif)), - ip4_addr_get_u32(ip4_current_dest_addr()) & ~ip4_addr_get_u32(netif_ip4_netmask(netif)))); - - /* interface is up and configured? */ - if ((netif_is_up(netif)) && (!ip4_addr_isany_val(*netif_ip4_addr(netif)))) { - /* unicast to this interface address? */ - if (ip4_addr_cmp(ip4_current_dest_addr(), netif_ip4_addr(netif)) || - /* or broadcast on this interface network address? */ - ip4_addr_isbroadcast(ip4_current_dest_addr(), netif) -#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF - || (ip4_addr_get_u32(ip4_current_dest_addr()) == PP_HTONL(IPADDR_LOOPBACK)) -#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */ - ) { - LWIP_DEBUGF(IP_DEBUG, ("ip4_input: packet accepted on interface %c%c\n", - netif->name[0], netif->name[1])); - /* accept on this netif */ - return 1; - } -#if LWIP_AUTOIP - /* connections to link-local addresses must persist after changing - the netif's address (RFC3927 ch. 1.9) */ - if (autoip_accept_packet(netif, ip4_current_dest_addr())) { - LWIP_DEBUGF(IP_DEBUG, ("ip4_input: LLA packet accepted on interface %c%c\n", - netif->name[0], netif->name[1])); - /* accept on this netif */ - return 1; - } -#endif /* LWIP_AUTOIP */ - } - return 0; -} - -/** - * This function is called by the network interface device driver when - * an IP packet is received. The function does the basic checks of the - * IP header such as packet size being at least larger than the header - * size etc. If the packet was not destined for us, the packet is - * forwarded (using ip_forward). The IP checksum is always checked. - * - * Finally, the packet is sent to the upper layer protocol input function. - * - * @param p the received IP packet (p->payload points to IP header) - * @param inp the netif on which this packet was received - * @return ERR_OK if the packet was processed (could return ERR_* if it wasn't - * processed, but currently always returns ERR_OK) - */ -err_t -ip4_input(struct pbuf *p, struct netif *inp) -{ - const struct ip_hdr *iphdr; - struct netif *netif; - u16_t iphdr_hlen; - u16_t iphdr_len; -#if IP_ACCEPT_LINK_LAYER_ADDRESSING || LWIP_IGMP - int check_ip_src = 1; -#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING || LWIP_IGMP */ -#if LWIP_RAW - raw_input_state_t raw_status; -#endif /* LWIP_RAW */ - - LWIP_ASSERT_CORE_LOCKED(); - - IP_STATS_INC(ip.recv); - MIB2_STATS_INC(mib2.ipinreceives); - - /* identify the IP header */ - iphdr = (struct ip_hdr *)p->payload; - if (IPH_V(iphdr) != 4) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IP packet dropped due to bad version number %"U16_F"\n", (u16_t)IPH_V(iphdr))); - ip4_debug_print(p); - pbuf_free(p); - IP_STATS_INC(ip.err); - IP_STATS_INC(ip.drop); - MIB2_STATS_INC(mib2.ipinhdrerrors); - return ERR_OK; - } - -#ifdef LWIP_HOOK_IP4_INPUT - if (LWIP_HOOK_IP4_INPUT(p, inp)) { - /* the packet has been eaten */ - return ERR_OK; - } -#endif - - /* obtain IP header length in bytes */ - iphdr_hlen = IPH_HL_BYTES(iphdr); - /* obtain ip length in bytes */ - iphdr_len = lwip_ntohs(IPH_LEN(iphdr)); - - /* Trim pbuf. This is especially required for packets < 60 bytes. */ - if (iphdr_len < p->tot_len) { - pbuf_realloc(p, iphdr_len); - } - - /* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */ - if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len) || (iphdr_hlen < IP_HLEN)) { - if (iphdr_hlen < IP_HLEN) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("ip4_input: short IP header (%"U16_F" bytes) received, IP packet dropped\n", iphdr_hlen)); - } - if (iphdr_hlen > p->len) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IP header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n", - iphdr_hlen, p->len)); - } - if (iphdr_len > p->tot_len) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IP (len %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n", - iphdr_len, p->tot_len)); - } - /* free (drop) packet pbufs */ - pbuf_free(p); - IP_STATS_INC(ip.lenerr); - IP_STATS_INC(ip.drop); - MIB2_STATS_INC(mib2.ipindiscards); - return ERR_OK; - } - - /* verify checksum */ -#if CHECKSUM_CHECK_IP - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_IP) { - if (inet_chksum(iphdr, iphdr_hlen) != 0) { - - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("Checksum (0x%"X16_F") failed, IP packet dropped.\n", inet_chksum(iphdr, iphdr_hlen))); - ip4_debug_print(p); - pbuf_free(p); - IP_STATS_INC(ip.chkerr); - IP_STATS_INC(ip.drop); - MIB2_STATS_INC(mib2.ipinhdrerrors); - return ERR_OK; - } - } -#endif - /* copy IP addresses to aligned ip_addr_t */ - ip_addr_copy_from_ip4(ip_data.current_iphdr_dest, iphdr->dest); - ip_addr_copy_from_ip4(ip_data.current_iphdr_src, iphdr->src); - - /* match packet against an interface, i.e. is this packet for us? */ - if (ip4_addr_ismulticast(ip4_current_dest_addr())) { -#if LWIP_IGMP - if ((inp->flags & NETIF_FLAG_IGMP) && (igmp_lookfor_group(inp, ip4_current_dest_addr()))) { - /* IGMP snooping switches need 0.0.0.0 to be allowed as source address (RFC 4541) */ - ip4_addr_t allsystems; - IP4_ADDR(&allsystems, 224, 0, 0, 1); - if (ip4_addr_cmp(ip4_current_dest_addr(), &allsystems) && - ip4_addr_isany(ip4_current_src_addr())) { - check_ip_src = 0; - } - netif = inp; - } else { - netif = NULL; - } -#else /* LWIP_IGMP */ - if ((netif_is_up(inp)) && (!ip4_addr_isany_val(*netif_ip4_addr(inp)))) { - netif = inp; - } else { - netif = NULL; - } -#endif /* LWIP_IGMP */ - } else { - /* start trying with inp. if that's not acceptable, start walking the - list of configured netifs. */ - if (ip4_input_accept(inp)) { - netif = inp; - } else { - netif = NULL; -#if !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF - /* Packets sent to the loopback address must not be accepted on an - * interface that does not have the loopback address assigned to it, - * unless a non-loopback interface is used for loopback traffic. */ - if (!ip4_addr_isloopback(ip4_current_dest_addr())) -#endif /* !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF */ - { -#if !LWIP_SINGLE_NETIF - NETIF_FOREACH(netif) { - if (netif == inp) { - /* we checked that before already */ - continue; - } - if (ip4_input_accept(netif)) { - break; - } - } -#endif /* !LWIP_SINGLE_NETIF */ - } - } - } - -#if IP_ACCEPT_LINK_LAYER_ADDRESSING - /* Pass DHCP messages regardless of destination address. DHCP traffic is addressed - * using link layer addressing (such as Ethernet MAC) so we must not filter on IP. - * According to RFC 1542 section 3.1.1, referred by RFC 2131). - * - * If you want to accept private broadcast communication while a netif is down, - * define LWIP_IP_ACCEPT_UDP_PORT(dst_port), e.g.: - * - * #define LWIP_IP_ACCEPT_UDP_PORT(dst_port) ((dst_port) == PP_NTOHS(12345)) - */ - if (netif == NULL) { - /* remote port is DHCP server? */ - if (IPH_PROTO(iphdr) == IP_PROTO_UDP) { - const struct udp_hdr *udphdr = (const struct udp_hdr *)((const u8_t *)iphdr + iphdr_hlen); - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: UDP packet to DHCP client port %"U16_F"\n", - lwip_ntohs(udphdr->dest))); - if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: DHCP packet accepted.\n")); - netif = inp; - check_ip_src = 0; - } - } - } -#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */ - - /* broadcast or multicast packet source address? Compliant with RFC 1122: 3.2.1.3 */ -#if LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING - if (check_ip_src -#if IP_ACCEPT_LINK_LAYER_ADDRESSING - /* DHCP servers need 0.0.0.0 to be allowed as source address (RFC 1.1.2.2: 3.2.1.3/a) */ - && !ip4_addr_isany_val(*ip4_current_src_addr()) -#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */ - ) -#endif /* LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING */ - { - if ((ip4_addr_isbroadcast(ip4_current_src_addr(), inp)) || - (ip4_addr_ismulticast(ip4_current_src_addr()))) { - /* packet source is not valid */ - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("ip4_input: packet source is not valid.\n")); - /* free (drop) packet pbufs */ - pbuf_free(p); - IP_STATS_INC(ip.drop); - MIB2_STATS_INC(mib2.ipinaddrerrors); - MIB2_STATS_INC(mib2.ipindiscards); - return ERR_OK; - } - } - - /* packet not for us? */ - if (netif == NULL) { - /* packet not for us, route or discard */ - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: packet not for us.\n")); -#if IP_FORWARD - /* non-broadcast packet? */ - if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), inp)) { - /* try to forward IP packet on (other) interfaces */ - ip4_forward(p, (struct ip_hdr *)p->payload, inp); - } else -#endif /* IP_FORWARD */ - { - IP_STATS_INC(ip.drop); - MIB2_STATS_INC(mib2.ipinaddrerrors); - MIB2_STATS_INC(mib2.ipindiscards); - } - pbuf_free(p); - return ERR_OK; - } - - /* packet consists of multiple fragments? */ - if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) { -#if IP_REASSEMBLY /* packet fragment reassembly code present? */ - LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip4_reass()\n", - lwip_ntohs(IPH_ID(iphdr)), p->tot_len, lwip_ntohs(IPH_LEN(iphdr)), (u16_t)!!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (u16_t)((lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK) * 8))); - /* reassemble the packet*/ - p = ip4_reass(p); - /* packet not fully reassembled yet? */ - if (p == NULL) { - return ERR_OK; - } - iphdr = (const struct ip_hdr *)p->payload; -#else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */ - pbuf_free(p); - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n", - lwip_ntohs(IPH_OFFSET(iphdr)))); - IP_STATS_INC(ip.opterr); - IP_STATS_INC(ip.drop); - /* unsupported protocol feature */ - MIB2_STATS_INC(mib2.ipinunknownprotos); - return ERR_OK; -#endif /* IP_REASSEMBLY */ - } - -#if IP_OPTIONS_ALLOWED == 0 /* no support for IP options in the IP header? */ - -#if LWIP_IGMP - /* there is an extra "router alert" option in IGMP messages which we allow for but do not police */ - if ((iphdr_hlen > IP_HLEN) && (IPH_PROTO(iphdr) != IP_PROTO_IGMP)) { -#else - if (iphdr_hlen > IP_HLEN) { -#endif /* LWIP_IGMP */ - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since there were IP options (while IP_OPTIONS_ALLOWED == 0).\n")); - pbuf_free(p); - IP_STATS_INC(ip.opterr); - IP_STATS_INC(ip.drop); - /* unsupported protocol feature */ - MIB2_STATS_INC(mib2.ipinunknownprotos); - return ERR_OK; - } -#endif /* IP_OPTIONS_ALLOWED == 0 */ - - /* send to upper layers */ - LWIP_DEBUGF(IP_DEBUG, ("ip4_input: \n")); - ip4_debug_print(p); - LWIP_DEBUGF(IP_DEBUG, ("ip4_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len)); - - ip_data.current_netif = netif; - ip_data.current_input_netif = inp; - ip_data.current_ip4_header = iphdr; - ip_data.current_ip_header_tot_len = IPH_HL_BYTES(iphdr); - -#if LWIP_RAW - /* raw input did not eat the packet? */ - raw_status = raw_input(p, inp); - if (raw_status != RAW_INPUT_EATEN) -#endif /* LWIP_RAW */ - { - pbuf_remove_header(p, iphdr_hlen); /* Move to payload, no check necessary. */ - - switch (IPH_PROTO(iphdr)) { -#if LWIP_UDP - case IP_PROTO_UDP: -#if LWIP_UDPLITE - case IP_PROTO_UDPLITE: -#endif /* LWIP_UDPLITE */ - MIB2_STATS_INC(mib2.ipindelivers); - udp_input(p, inp); - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case IP_PROTO_TCP: - MIB2_STATS_INC(mib2.ipindelivers); - tcp_input(p, inp); - break; -#endif /* LWIP_TCP */ -#if LWIP_ICMP - case IP_PROTO_ICMP: - MIB2_STATS_INC(mib2.ipindelivers); - icmp_input(p, inp); - break; -#endif /* LWIP_ICMP */ -#if LWIP_IGMP - case IP_PROTO_IGMP: - igmp_input(p, inp, ip4_current_dest_addr()); - break; -#endif /* LWIP_IGMP */ - default: -#if LWIP_RAW - if (raw_status == RAW_INPUT_DELIVERED) { - MIB2_STATS_INC(mib2.ipindelivers); - } else -#endif /* LWIP_RAW */ - { -#if LWIP_ICMP - /* send ICMP destination protocol unreachable unless is was a broadcast */ - if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), netif) && - !ip4_addr_ismulticast(ip4_current_dest_addr())) { - pbuf_header_force(p, (s16_t)iphdr_hlen); /* Move to ip header, no check necessary. */ - icmp_dest_unreach(p, ICMP_DUR_PROTO); - } -#endif /* LWIP_ICMP */ - - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Unsupported transport protocol %"U16_F"\n", (u16_t)IPH_PROTO(iphdr))); - - IP_STATS_INC(ip.proterr); - IP_STATS_INC(ip.drop); - MIB2_STATS_INC(mib2.ipinunknownprotos); - } - pbuf_free(p); - break; - } - } - - /* @todo: this is not really necessary... */ - ip_data.current_netif = NULL; - ip_data.current_input_netif = NULL; - ip_data.current_ip4_header = NULL; - ip_data.current_ip_header_tot_len = 0; - ip4_addr_set_any(ip4_current_src_addr()); - ip4_addr_set_any(ip4_current_dest_addr()); - - return ERR_OK; -} - -/** - * Sends an IP packet on a network interface. This function constructs - * the IP header and calculates the IP header checksum. If the source - * IP address is NULL, the IP address of the outgoing network - * interface is filled in as source address. - * If the destination IP address is LWIP_IP_HDRINCL, p is assumed to already - * include an IP header and p->payload points to it instead of the data. - * - * @param p the packet to send (p->payload points to the data, e.g. next - protocol header; if dest == LWIP_IP_HDRINCL, p already includes an - IP header and p->payload points to that IP header) - * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the - * IP address of the netif used to send is used as source address) - * @param dest the destination IP address to send the packet to - * @param ttl the TTL value to be set in the IP header - * @param tos the TOS value to be set in the IP header - * @param proto the PROTOCOL to be set in the IP header - * @param netif the netif on which to send this packet - * @return ERR_OK if the packet was sent OK - * ERR_BUF if p doesn't have enough space for IP/LINK headers - * returns errors returned by netif->output - * - * @note ip_id: RFC791 "some host may be able to simply use - * unique identifiers independent of destination" - */ -err_t -ip4_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, - u8_t proto, struct netif *netif) -{ -#if IP_OPTIONS_SEND - return ip4_output_if_opt(p, src, dest, ttl, tos, proto, netif, NULL, 0); -} - -/** - * Same as ip_output_if() but with the possibility to include IP options: - * - * @ param ip_options pointer to the IP options, copied into the IP header - * @ param optlen length of ip_options - */ -err_t -ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, - u16_t optlen) -{ -#endif /* IP_OPTIONS_SEND */ - const ip4_addr_t *src_used = src; - if (dest != LWIP_IP_HDRINCL) { - if (ip4_addr_isany(src)) { - src_used = netif_ip4_addr(netif); - } - } - -#if IP_OPTIONS_SEND - return ip4_output_if_opt_src(p, src_used, dest, ttl, tos, proto, netif, - ip_options, optlen); -#else /* IP_OPTIONS_SEND */ - return ip4_output_if_src(p, src_used, dest, ttl, tos, proto, netif); -#endif /* IP_OPTIONS_SEND */ -} - -/** - * Same as ip_output_if() but 'src' address is not replaced by netif address - * when it is 'any'. - */ -err_t -ip4_output_if_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, - u8_t proto, struct netif *netif) -{ -#if IP_OPTIONS_SEND - return ip4_output_if_opt_src(p, src, dest, ttl, tos, proto, netif, NULL, 0); -} - -/** - * Same as ip_output_if_opt() but 'src' address is not replaced by netif address - * when it is 'any'. - */ -err_t -ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, - u16_t optlen) -{ -#endif /* IP_OPTIONS_SEND */ - struct ip_hdr *iphdr; - ip4_addr_t dest_addr; -#if CHECKSUM_GEN_IP_INLINE - u32_t chk_sum = 0; -#endif /* CHECKSUM_GEN_IP_INLINE */ - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); - - MIB2_STATS_INC(mib2.ipoutrequests); - - /* Should the IP header be generated or is it already included in p? */ - if (dest != LWIP_IP_HDRINCL) { - u16_t ip_hlen = IP_HLEN; -#if IP_OPTIONS_SEND - u16_t optlen_aligned = 0; - if (optlen != 0) { -#if CHECKSUM_GEN_IP_INLINE - int i; -#endif /* CHECKSUM_GEN_IP_INLINE */ - if (optlen > (IP_HLEN_MAX - IP_HLEN)) { - /* optlen too long */ - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output_if_opt: optlen too long\n")); - IP_STATS_INC(ip.err); - MIB2_STATS_INC(mib2.ipoutdiscards); - return ERR_VAL; - } - /* round up to a multiple of 4 */ - optlen_aligned = (u16_t)((optlen + 3) & ~3); - ip_hlen = (u16_t)(ip_hlen + optlen_aligned); - /* First write in the IP options */ - if (pbuf_add_header(p, optlen_aligned)) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output_if_opt: not enough room for IP options in pbuf\n")); - IP_STATS_INC(ip.err); - MIB2_STATS_INC(mib2.ipoutdiscards); - return ERR_BUF; - } - MEMCPY(p->payload, ip_options, optlen); - if (optlen < optlen_aligned) { - /* zero the remaining bytes */ - memset(((char *)p->payload) + optlen, 0, (size_t)(optlen_aligned - optlen)); - } -#if CHECKSUM_GEN_IP_INLINE - for (i = 0; i < optlen_aligned / 2; i++) { - chk_sum += ((u16_t *)p->payload)[i]; - } -#endif /* CHECKSUM_GEN_IP_INLINE */ - } -#endif /* IP_OPTIONS_SEND */ - /* generate IP header */ - if (pbuf_add_header(p, IP_HLEN)) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output: not enough room for IP header in pbuf\n")); - - IP_STATS_INC(ip.err); - MIB2_STATS_INC(mib2.ipoutdiscards); - return ERR_BUF; - } - - iphdr = (struct ip_hdr *)p->payload; - LWIP_ASSERT("check that first pbuf can hold struct ip_hdr", - (p->len >= sizeof(struct ip_hdr))); - - IPH_TTL_SET(iphdr, ttl); - IPH_PROTO_SET(iphdr, proto); -#if CHECKSUM_GEN_IP_INLINE - chk_sum += PP_NTOHS(proto | (ttl << 8)); -#endif /* CHECKSUM_GEN_IP_INLINE */ - - /* dest cannot be NULL here */ - ip4_addr_copy(iphdr->dest, *dest); -#if CHECKSUM_GEN_IP_INLINE - chk_sum += ip4_addr_get_u32(&iphdr->dest) & 0xFFFF; - chk_sum += ip4_addr_get_u32(&iphdr->dest) >> 16; -#endif /* CHECKSUM_GEN_IP_INLINE */ - - IPH_VHL_SET(iphdr, 4, ip_hlen / 4); - IPH_TOS_SET(iphdr, tos); -#if CHECKSUM_GEN_IP_INLINE - chk_sum += PP_NTOHS(tos | (iphdr->_v_hl << 8)); -#endif /* CHECKSUM_GEN_IP_INLINE */ - IPH_LEN_SET(iphdr, lwip_htons(p->tot_len)); -#if CHECKSUM_GEN_IP_INLINE - chk_sum += iphdr->_len; -#endif /* CHECKSUM_GEN_IP_INLINE */ - IPH_OFFSET_SET(iphdr, 0); - IPH_ID_SET(iphdr, lwip_htons(ip_id)); -#if CHECKSUM_GEN_IP_INLINE - chk_sum += iphdr->_id; -#endif /* CHECKSUM_GEN_IP_INLINE */ - ++ip_id; - - if (src == NULL) { - ip4_addr_copy(iphdr->src, *IP4_ADDR_ANY4); - } else { - /* src cannot be NULL here */ - ip4_addr_copy(iphdr->src, *src); - } - -#if CHECKSUM_GEN_IP_INLINE - chk_sum += ip4_addr_get_u32(&iphdr->src) & 0xFFFF; - chk_sum += ip4_addr_get_u32(&iphdr->src) >> 16; - chk_sum = (chk_sum >> 16) + (chk_sum & 0xFFFF); - chk_sum = (chk_sum >> 16) + chk_sum; - chk_sum = ~chk_sum; - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) { - iphdr->_chksum = (u16_t)chk_sum; /* network order */ - } -#if LWIP_CHECKSUM_CTRL_PER_NETIF - else { - IPH_CHKSUM_SET(iphdr, 0); - } -#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF*/ -#else /* CHECKSUM_GEN_IP_INLINE */ - IPH_CHKSUM_SET(iphdr, 0); -#if CHECKSUM_GEN_IP - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) { - IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, ip_hlen)); - } -#endif /* CHECKSUM_GEN_IP */ -#endif /* CHECKSUM_GEN_IP_INLINE */ - } else { - /* IP header already included in p */ - if (p->len < IP_HLEN) { - LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output: LWIP_IP_HDRINCL but pbuf is too short\n")); - IP_STATS_INC(ip.err); - MIB2_STATS_INC(mib2.ipoutdiscards); - return ERR_BUF; - } - iphdr = (struct ip_hdr *)p->payload; - ip4_addr_copy(dest_addr, iphdr->dest); - dest = &dest_addr; - } - - IP_STATS_INC(ip.xmit); - - LWIP_DEBUGF(IP_DEBUG, ("ip4_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], (u16_t)netif->num)); - ip4_debug_print(p); - -#if ENABLE_LOOPBACK - if (ip4_addr_cmp(dest, netif_ip4_addr(netif)) -#if !LWIP_HAVE_LOOPIF - || ip4_addr_isloopback(dest) -#endif /* !LWIP_HAVE_LOOPIF */ - ) { - /* Packet to self, enqueue it for loopback */ - LWIP_DEBUGF(IP_DEBUG, ("netif_loop_output()")); - return netif_loop_output(netif, p); - } -#if LWIP_MULTICAST_TX_OPTIONS - if ((p->flags & PBUF_FLAG_MCASTLOOP) != 0) { - netif_loop_output(netif, p); - } -#endif /* LWIP_MULTICAST_TX_OPTIONS */ -#endif /* ENABLE_LOOPBACK */ -#if IP_FRAG - /* don't fragment if interface has mtu set to 0 [loopif] */ - if (netif->mtu && (p->tot_len > netif->mtu)) { - return ip4_frag(p, netif, dest); - } -#endif /* IP_FRAG */ - - LWIP_DEBUGF(IP_DEBUG, ("ip4_output_if: call netif->output()\n")); - return netif->output(netif, p, dest); -} - -/** - * Simple interface to ip_output_if. It finds the outgoing network - * interface and calls upon ip_output_if to do the actual work. - * - * @param p the packet to send (p->payload points to the data, e.g. next - protocol header; if dest == LWIP_IP_HDRINCL, p already includes an - IP header and p->payload points to that IP header) - * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the - * IP address of the netif used to send is used as source address) - * @param dest the destination IP address to send the packet to - * @param ttl the TTL value to be set in the IP header - * @param tos the TOS value to be set in the IP header - * @param proto the PROTOCOL to be set in the IP header - * - * @return ERR_RTE if no route is found - * see ip_output_if() for more return values - */ -err_t -ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto) -{ - struct netif *netif; - - LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); - - if ((netif = ip4_route_src(src, dest)) == NULL) { - LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); - IP_STATS_INC(ip.rterr); - return ERR_RTE; - } - - return ip4_output_if(p, src, dest, ttl, tos, proto, netif); -} - -#if LWIP_NETIF_USE_HINTS -/** Like ip_output, but takes and addr_hint pointer that is passed on to netif->addr_hint - * before calling ip_output_if. - * - * @param p the packet to send (p->payload points to the data, e.g. next - protocol header; if dest == LWIP_IP_HDRINCL, p already includes an - IP header and p->payload points to that IP header) - * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the - * IP address of the netif used to send is used as source address) - * @param dest the destination IP address to send the packet to - * @param ttl the TTL value to be set in the IP header - * @param tos the TOS value to be set in the IP header - * @param proto the PROTOCOL to be set in the IP header - * @param netif_hint netif output hint pointer set to netif->hint before - * calling ip_output_if() - * - * @return ERR_RTE if no route is found - * see ip_output_if() for more return values - */ -err_t -ip4_output_hinted(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif_hint *netif_hint) -{ - struct netif *netif; - err_t err; - - LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); - - if ((netif = ip4_route_src(src, dest)) == NULL) { - LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); - IP_STATS_INC(ip.rterr); - return ERR_RTE; - } - - NETIF_SET_HINTS(netif, netif_hint); - err = ip4_output_if(p, src, dest, ttl, tos, proto, netif); - NETIF_RESET_HINTS(netif); - - return err; -} -#endif /* LWIP_NETIF_USE_HINTS*/ - -#if IP_DEBUG -/* Print an IP header by using LWIP_DEBUGF - * @param p an IP packet, p->payload pointing to the IP header - */ -void -ip4_debug_print(struct pbuf *p) -{ - struct ip_hdr *iphdr = (struct ip_hdr *)p->payload; - - LWIP_DEBUGF(IP_DEBUG, ("IP header:\n")); - LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP_DEBUG, ("|%2"S16_F" |%2"S16_F" | 0x%02"X16_F" | %5"U16_F" | (v, hl, tos, len)\n", - (u16_t)IPH_V(iphdr), - (u16_t)IPH_HL(iphdr), - (u16_t)IPH_TOS(iphdr), - lwip_ntohs(IPH_LEN(iphdr)))); - LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP_DEBUG, ("| %5"U16_F" |%"U16_F"%"U16_F"%"U16_F"| %4"U16_F" | (id, flags, offset)\n", - lwip_ntohs(IPH_ID(iphdr)), - (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 15 & 1), - (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 14 & 1), - (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 13 & 1), - (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK))); - LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | 0x%04"X16_F" | (ttl, proto, chksum)\n", - (u16_t)IPH_TTL(iphdr), - (u16_t)IPH_PROTO(iphdr), - lwip_ntohs(IPH_CHKSUM(iphdr)))); - LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (src)\n", - ip4_addr1_16_val(iphdr->src), - ip4_addr2_16_val(iphdr->src), - ip4_addr3_16_val(iphdr->src), - ip4_addr4_16_val(iphdr->src))); - LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (dest)\n", - ip4_addr1_16_val(iphdr->dest), - ip4_addr2_16_val(iphdr->dest), - ip4_addr3_16_val(iphdr->dest), - ip4_addr4_16_val(iphdr->dest))); - LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); -} -#endif /* IP_DEBUG */ - -#endif /* LWIP_IPV4 */ +/** + * @file + * This is the IPv4 layer implementation for incoming and outgoing IP traffic. + * + * @see ip_frag.c + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 + +#include "lwip/ip.h" +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/ip4_frag.h" +#include "lwip/inet_chksum.h" +#include "lwip/netif.h" +#include "lwip/icmp.h" +#include "lwip/igmp.h" +#include "lwip/priv/raw_priv.h" +#include "lwip/udp.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/autoip.h" +#include "lwip/stats.h" +#include "lwip/prot/iana.h" + +#include +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +/** Set this to 0 in the rare case of wanting to call an extra function to + * generate the IP checksum (in contrast to calculating it on-the-fly). */ +#ifndef LWIP_INLINE_IP_CHKSUM +#if LWIP_CHECKSUM_CTRL_PER_NETIF +#define LWIP_INLINE_IP_CHKSUM 0 +#else /* LWIP_CHECKSUM_CTRL_PER_NETIF */ +#define LWIP_INLINE_IP_CHKSUM 1 +#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ +#endif + +#if LWIP_INLINE_IP_CHKSUM && CHECKSUM_GEN_IP +#define CHECKSUM_GEN_IP_INLINE 1 +#else +#define CHECKSUM_GEN_IP_INLINE 0 +#endif + +#if LWIP_DHCP || defined(LWIP_IP_ACCEPT_UDP_PORT) +#define IP_ACCEPT_LINK_LAYER_ADDRESSING 1 + +/** Some defines for DHCP to let link-layer-addressed packets through while the + * netif is down. + * To use this in your own application/protocol, define LWIP_IP_ACCEPT_UDP_PORT(port) + * to return 1 if the port is accepted and 0 if the port is not accepted. + */ +#if LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) +/* accept DHCP client port and custom port */ +#define IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(port) (((port) == PP_NTOHS(LWIP_IANA_PORT_DHCP_CLIENT)) \ + || (LWIP_IP_ACCEPT_UDP_PORT(port))) +#elif defined(LWIP_IP_ACCEPT_UDP_PORT) /* LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) */ +/* accept custom port only */ +#define IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(port) (LWIP_IP_ACCEPT_UDP_PORT(port)) +#else /* LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) */ +/* accept DHCP client port only */ +#define IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(port) ((port) == PP_NTOHS(LWIP_IANA_PORT_DHCP_CLIENT)) +#endif /* LWIP_DHCP && defined(LWIP_IP_ACCEPT_UDP_PORT) */ + +#else /* LWIP_DHCP */ +#define IP_ACCEPT_LINK_LAYER_ADDRESSING 0 +#endif /* LWIP_DHCP */ + +/** The IP header ID of the next outgoing IP packet */ +static u16_t ip_id; + +#if LWIP_MULTICAST_TX_OPTIONS +/** The default netif used for multicast */ +static struct netif *ip4_default_multicast_netif; + +/** + * @ingroup ip4 + * Set a default netif for IPv4 multicast. */ +void +ip4_set_default_multicast_netif(struct netif *default_multicast_netif) +{ + ip4_default_multicast_netif = default_multicast_netif; +} +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + +#ifdef LWIP_HOOK_IP4_ROUTE_SRC +/** + * Source based IPv4 routing must be fully implemented in + * LWIP_HOOK_IP4_ROUTE_SRC(). This function only provides the parameters. + */ +struct netif * +ip4_route_src(const ip4_addr_t *src, const ip4_addr_t *dest) +{ + if (src != NULL) { + /* when src==NULL, the hook is called from ip4_route(dest) */ + struct netif *netif = LWIP_HOOK_IP4_ROUTE_SRC(src, dest); + if (netif != NULL) { + return netif; + } + } + return ip4_route(dest); +} +#endif /* LWIP_HOOK_IP4_ROUTE_SRC */ + +/** + * Finds the appropriate network interface for a given IP address. It + * searches the list of network interfaces linearly. A match is found + * if the masked IP address of the network interface equals the masked + * IP address given to the function. + * + * @param dest the destination IP address for which to find the route + * @return the netif on which to send to reach dest + */ +struct netif * +ip4_route(const ip4_addr_t *dest) +{ +#if !LWIP_SINGLE_NETIF + struct netif *netif; + + LWIP_ASSERT_CORE_LOCKED(); + +#if LWIP_MULTICAST_TX_OPTIONS + /* Use administratively selected interface for multicast by default */ + if (ip4_addr_ismulticast(dest) && ip4_default_multicast_netif) { + return ip4_default_multicast_netif; + } +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + + /* bug #54569: in case LWIP_SINGLE_NETIF=1 and LWIP_DEBUGF() disabled, the following loop is optimized away */ + LWIP_UNUSED_ARG(dest); + + /* iterate through netifs */ + NETIF_FOREACH(netif) { + /* is the netif up, does it have a link and a valid address? */ + if (netif_is_up(netif) && netif_is_link_up(netif) && !ip4_addr_isany_val(*netif_ip4_addr(netif))) { + /* network mask matches? */ + if (ip4_addr_netcmp(dest, netif_ip4_addr(netif), netif_ip4_netmask(netif))) { + /* return netif on which to forward IP packet */ + return netif; + } + /* gateway matches on a non broadcast interface? (i.e. peer in a point to point interface) */ + if (((netif->flags & NETIF_FLAG_BROADCAST) == 0) && ip4_addr_cmp(dest, netif_ip4_gw(netif))) { + /* return netif on which to forward IP packet */ + return netif; + } + } + } + +#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF + /* loopif is disabled, looopback traffic is passed through any netif */ + if (ip4_addr_isloopback(dest)) { + /* don't check for link on loopback traffic */ + if (netif_default != NULL && netif_is_up(netif_default)) { + return netif_default; + } + /* default netif is not up, just use any netif for loopback traffic */ + NETIF_FOREACH(netif) { + if (netif_is_up(netif)) { + return netif; + } + } + return NULL; + } +#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */ + +#ifdef LWIP_HOOK_IP4_ROUTE_SRC + netif = LWIP_HOOK_IP4_ROUTE_SRC(NULL, dest); + if (netif != NULL) { + return netif; + } +#elif defined(LWIP_HOOK_IP4_ROUTE) + netif = LWIP_HOOK_IP4_ROUTE(dest); + if (netif != NULL) { + return netif; + } +#endif +#endif /* !LWIP_SINGLE_NETIF */ + + if ((netif_default == NULL) || !netif_is_up(netif_default) || !netif_is_link_up(netif_default) || + ip4_addr_isany_val(*netif_ip4_addr(netif_default)) || ip4_addr_isloopback(dest)) { + /* No matching netif found and default netif is not usable. + If this is not good enough for you, use LWIP_HOOK_IP4_ROUTE() */ + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_route: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); + IP_STATS_INC(ip.rterr); + MIB2_STATS_INC(mib2.ipoutnoroutes); + return NULL; + } + + return netif_default; +} + +#if IP_FORWARD +/** + * Determine whether an IP address is in a reserved set of addresses + * that may not be forwarded, or whether datagrams to that destination + * may be forwarded. + * @param p the packet to forward + * @return 1: can forward 0: discard + */ +static int +ip4_canforward(struct pbuf *p) +{ + u32_t addr = lwip_htonl(ip4_addr_get_u32(ip4_current_dest_addr())); + +#ifdef LWIP_HOOK_IP4_CANFORWARD + int ret = LWIP_HOOK_IP4_CANFORWARD(p, addr); + if (ret >= 0) { + return ret; + } +#endif /* LWIP_HOOK_IP4_CANFORWARD */ + + if (p->flags & PBUF_FLAG_LLBCAST) { + /* don't route link-layer broadcasts */ + return 0; + } + if ((p->flags & PBUF_FLAG_LLMCAST) || IP_MULTICAST(addr)) { + /* don't route link-layer multicasts (use LWIP_HOOK_IP4_CANFORWARD instead) */ + return 0; + } + if (IP_EXPERIMENTAL(addr)) { + return 0; + } + if (IP_CLASSA(addr)) { + u32_t net = addr & IP_CLASSA_NET; + if ((net == 0) || (net == ((u32_t)IP_LOOPBACKNET << IP_CLASSA_NSHIFT))) { + /* don't route loopback packets */ + return 0; + } + } + return 1; +} + +/** + * Forwards an IP packet. It finds an appropriate route for the + * packet, decrements the TTL value of the packet, adjusts the + * checksum and outputs the packet on the appropriate interface. + * + * @param p the packet to forward (p->payload points to IP header) + * @param iphdr the IP header of the input packet + * @param inp the netif on which this packet was received + */ +static void +ip4_forward(struct pbuf *p, struct ip_hdr *iphdr, struct netif *inp) +{ + struct netif *netif; + + PERF_START; + LWIP_UNUSED_ARG(inp); + + if (!ip4_canforward(p)) { + goto return_noroute; + } + + /* RFC3927 2.7: do not forward link-local addresses */ + if (ip4_addr_islinklocal(ip4_current_dest_addr())) { + LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not forwarding LLA %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), + ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); + goto return_noroute; + } + + /* Find network interface where to forward this IP packet to. */ + netif = ip4_route_src(ip4_current_src_addr(), ip4_current_dest_addr()); + if (netif == NULL) { + LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: no forwarding route for %"U16_F".%"U16_F".%"U16_F".%"U16_F" found\n", + ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), + ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); + /* @todo: send ICMP_DUR_NET? */ + goto return_noroute; + } +#if !IP_FORWARD_ALLOW_TX_ON_RX_NETIF + /* Do not forward packets onto the same network interface on which + * they arrived. */ + if (netif == inp) { + LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: not bouncing packets back on incoming interface.\n")); + goto return_noroute; + } +#endif /* IP_FORWARD_ALLOW_TX_ON_RX_NETIF */ + + /* decrement TTL */ + IPH_TTL_SET(iphdr, IPH_TTL(iphdr) - 1); + /* send ICMP if TTL == 0 */ + if (IPH_TTL(iphdr) == 0) { + MIB2_STATS_INC(mib2.ipinhdrerrors); +#if LWIP_ICMP + /* Don't send ICMP messages in response to ICMP messages */ + if (IPH_PROTO(iphdr) != IP_PROTO_ICMP) { + icmp_time_exceeded(p, ICMP_TE_TTL); + } +#endif /* LWIP_ICMP */ + return; + } + + /* Incrementally update the IP checksum. */ + if (IPH_CHKSUM(iphdr) >= PP_HTONS(0xffffU - 0x100)) { + IPH_CHKSUM_SET(iphdr, (u16_t)(IPH_CHKSUM(iphdr) + PP_HTONS(0x100) + 1)); + } else { + IPH_CHKSUM_SET(iphdr, (u16_t)(IPH_CHKSUM(iphdr) + PP_HTONS(0x100))); + } + + LWIP_DEBUGF(IP_DEBUG, ("ip4_forward: forwarding packet to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(ip4_current_dest_addr()), ip4_addr2_16(ip4_current_dest_addr()), + ip4_addr3_16(ip4_current_dest_addr()), ip4_addr4_16(ip4_current_dest_addr()))); + + IP_STATS_INC(ip.fw); + MIB2_STATS_INC(mib2.ipforwdatagrams); + IP_STATS_INC(ip.xmit); + + PERF_STOP("ip4_forward"); + /* don't fragment if interface has mtu set to 0 [loopif] */ + if (netif->mtu && (p->tot_len > netif->mtu)) { + if ((IPH_OFFSET(iphdr) & PP_NTOHS(IP_DF)) == 0) { +#if IP_FRAG + ip4_frag(p, netif, ip4_current_dest_addr()); +#else /* IP_FRAG */ + /* @todo: send ICMP Destination Unreachable code 13 "Communication administratively prohibited"? */ +#endif /* IP_FRAG */ + } else { +#if LWIP_ICMP + /* send ICMP Destination Unreachable code 4: "Fragmentation Needed and DF Set" */ + icmp_dest_unreach(p, ICMP_DUR_FRAG); +#endif /* LWIP_ICMP */ + } + return; + } + /* transmit pbuf on chosen interface */ + netif->output(netif, p, ip4_current_dest_addr()); + return; +return_noroute: + MIB2_STATS_INC(mib2.ipoutnoroutes); +} +#endif /* IP_FORWARD */ + +/** Return true if the current input packet should be accepted on this netif */ +static int +ip4_input_accept(struct netif *netif) +{ + LWIP_DEBUGF(IP_DEBUG, ("ip_input: iphdr->dest 0x%"X32_F" netif->ip_addr 0x%"X32_F" (0x%"X32_F", 0x%"X32_F", 0x%"X32_F")\n", + ip4_addr_get_u32(ip4_current_dest_addr()), ip4_addr_get_u32(netif_ip4_addr(netif)), + ip4_addr_get_u32(ip4_current_dest_addr()) & ip4_addr_get_u32(netif_ip4_netmask(netif)), + ip4_addr_get_u32(netif_ip4_addr(netif)) & ip4_addr_get_u32(netif_ip4_netmask(netif)), + ip4_addr_get_u32(ip4_current_dest_addr()) & ~ip4_addr_get_u32(netif_ip4_netmask(netif)))); + + /* interface is up and configured? */ + if ((netif_is_up(netif)) && (!ip4_addr_isany_val(*netif_ip4_addr(netif)))) { + /* unicast to this interface address? */ + if (ip4_addr_cmp(ip4_current_dest_addr(), netif_ip4_addr(netif)) || + /* or broadcast on this interface network address? */ + ip4_addr_isbroadcast(ip4_current_dest_addr(), netif) +#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF + || (ip4_addr_get_u32(ip4_current_dest_addr()) == PP_HTONL(IPADDR_LOOPBACK)) +#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */ + ) { + LWIP_DEBUGF(IP_DEBUG, ("ip4_input: packet accepted on interface %c%c\n", + netif->name[0], netif->name[1])); + /* accept on this netif */ + return 1; + } +#if LWIP_AUTOIP + /* connections to link-local addresses must persist after changing + the netif's address (RFC3927 ch. 1.9) */ + if (autoip_accept_packet(netif, ip4_current_dest_addr())) { + LWIP_DEBUGF(IP_DEBUG, ("ip4_input: LLA packet accepted on interface %c%c\n", + netif->name[0], netif->name[1])); + /* accept on this netif */ + return 1; + } +#endif /* LWIP_AUTOIP */ + } + return 0; +} + +/** + * This function is called by the network interface device driver when + * an IP packet is received. The function does the basic checks of the + * IP header such as packet size being at least larger than the header + * size etc. If the packet was not destined for us, the packet is + * forwarded (using ip_forward). The IP checksum is always checked. + * + * Finally, the packet is sent to the upper layer protocol input function. + * + * @param p the received IP packet (p->payload points to IP header) + * @param inp the netif on which this packet was received + * @return ERR_OK if the packet was processed (could return ERR_* if it wasn't + * processed, but currently always returns ERR_OK) + */ +err_t +ip4_input(struct pbuf *p, struct netif *inp) +{ + const struct ip_hdr *iphdr; + struct netif *netif; + u16_t iphdr_hlen; + u16_t iphdr_len; +#if IP_ACCEPT_LINK_LAYER_ADDRESSING || LWIP_IGMP + int check_ip_src = 1; +#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING || LWIP_IGMP */ +#if LWIP_RAW + raw_input_state_t raw_status; +#endif /* LWIP_RAW */ + + LWIP_ASSERT_CORE_LOCKED(); + + IP_STATS_INC(ip.recv); + MIB2_STATS_INC(mib2.ipinreceives); + + /* identify the IP header */ + iphdr = (struct ip_hdr *)p->payload; + if (IPH_V(iphdr) != 4) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IP packet dropped due to bad version number %"U16_F"\n", (u16_t)IPH_V(iphdr))); + ip4_debug_print(p); + pbuf_free(p); + IP_STATS_INC(ip.err); + IP_STATS_INC(ip.drop); + MIB2_STATS_INC(mib2.ipinhdrerrors); + return ERR_OK; + } + +#ifdef LWIP_HOOK_IP4_INPUT + if (LWIP_HOOK_IP4_INPUT(p, inp)) { + /* the packet has been eaten */ + return ERR_OK; + } +#endif + + /* obtain IP header length in bytes */ + iphdr_hlen = IPH_HL_BYTES(iphdr); + /* obtain ip length in bytes */ + iphdr_len = lwip_ntohs(IPH_LEN(iphdr)); + + /* Trim pbuf. This is especially required for packets < 60 bytes. */ + if (iphdr_len < p->tot_len) { + pbuf_realloc(p, iphdr_len); + } + + /* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */ + if ((iphdr_hlen > p->len) || (iphdr_len > p->tot_len) || (iphdr_hlen < IP_HLEN)) { + if (iphdr_hlen < IP_HLEN) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("ip4_input: short IP header (%"U16_F" bytes) received, IP packet dropped\n", iphdr_hlen)); + } + if (iphdr_hlen > p->len) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IP header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n", + iphdr_hlen, p->len)); + } + if (iphdr_len > p->tot_len) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IP (len %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n", + iphdr_len, p->tot_len)); + } + /* free (drop) packet pbufs */ + pbuf_free(p); + IP_STATS_INC(ip.lenerr); + IP_STATS_INC(ip.drop); + MIB2_STATS_INC(mib2.ipindiscards); + return ERR_OK; + } + + /* verify checksum */ +#if CHECKSUM_CHECK_IP + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_IP) { + if (inet_chksum(iphdr, iphdr_hlen) != 0) { + + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("Checksum (0x%"X16_F") failed, IP packet dropped.\n", inet_chksum(iphdr, iphdr_hlen))); + ip4_debug_print(p); + pbuf_free(p); + IP_STATS_INC(ip.chkerr); + IP_STATS_INC(ip.drop); + MIB2_STATS_INC(mib2.ipinhdrerrors); + return ERR_OK; + } + } +#endif + /* copy IP addresses to aligned ip_addr_t */ + ip_addr_copy_from_ip4(ip_data.current_iphdr_dest, iphdr->dest); + ip_addr_copy_from_ip4(ip_data.current_iphdr_src, iphdr->src); + + /* match packet against an interface, i.e. is this packet for us? */ + if (ip4_addr_ismulticast(ip4_current_dest_addr())) { +#if LWIP_IGMP + if ((inp->flags & NETIF_FLAG_IGMP) && (igmp_lookfor_group(inp, ip4_current_dest_addr()))) { + /* IGMP snooping switches need 0.0.0.0 to be allowed as source address (RFC 4541) */ + ip4_addr_t allsystems; + IP4_ADDR(&allsystems, 224, 0, 0, 1); + if (ip4_addr_cmp(ip4_current_dest_addr(), &allsystems) && + ip4_addr_isany(ip4_current_src_addr())) { + check_ip_src = 0; + } + netif = inp; + } else { + netif = NULL; + } +#else /* LWIP_IGMP */ + if ((netif_is_up(inp)) && (!ip4_addr_isany_val(*netif_ip4_addr(inp)))) { + netif = inp; + } else { + netif = NULL; + } +#endif /* LWIP_IGMP */ + } else { + /* start trying with inp. if that's not acceptable, start walking the + list of configured netifs. */ + if (ip4_input_accept(inp)) { + netif = inp; + } else { + netif = NULL; +#if !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF + /* Packets sent to the loopback address must not be accepted on an + * interface that does not have the loopback address assigned to it, + * unless a non-loopback interface is used for loopback traffic. */ + if (!ip4_addr_isloopback(ip4_current_dest_addr())) +#endif /* !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF */ + { +#if !LWIP_SINGLE_NETIF + NETIF_FOREACH(netif) { + if (netif == inp) { + /* we checked that before already */ + continue; + } + if (ip4_input_accept(netif)) { + break; + } + } +#endif /* !LWIP_SINGLE_NETIF */ + } + } + } + +#if IP_ACCEPT_LINK_LAYER_ADDRESSING + /* Pass DHCP messages regardless of destination address. DHCP traffic is addressed + * using link layer addressing (such as Ethernet MAC) so we must not filter on IP. + * According to RFC 1542 section 3.1.1, referred by RFC 2131). + * + * If you want to accept private broadcast communication while a netif is down, + * define LWIP_IP_ACCEPT_UDP_PORT(dst_port), e.g.: + * + * #define LWIP_IP_ACCEPT_UDP_PORT(dst_port) ((dst_port) == PP_NTOHS(12345)) + */ + if (netif == NULL) { + /* remote port is DHCP server? */ + if (IPH_PROTO(iphdr) == IP_PROTO_UDP) { + const struct udp_hdr *udphdr = (const struct udp_hdr *)((const u8_t *)iphdr + iphdr_hlen); + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: UDP packet to DHCP client port %"U16_F"\n", + lwip_ntohs(udphdr->dest))); + if (IP_ACCEPT_LINK_LAYER_ADDRESSED_PORT(udphdr->dest)) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: DHCP packet accepted.\n")); + netif = inp; + check_ip_src = 0; + } + } + } +#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */ + + /* broadcast or multicast packet source address? Compliant with RFC 1122: 3.2.1.3 */ +#if LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING + if (check_ip_src +#if IP_ACCEPT_LINK_LAYER_ADDRESSING + /* DHCP servers need 0.0.0.0 to be allowed as source address (RFC 1.1.2.2: 3.2.1.3/a) */ + && !ip4_addr_isany_val(*ip4_current_src_addr()) +#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */ + ) +#endif /* LWIP_IGMP || IP_ACCEPT_LINK_LAYER_ADDRESSING */ + { + if ((ip4_addr_isbroadcast(ip4_current_src_addr(), inp)) || + (ip4_addr_ismulticast(ip4_current_src_addr()))) { + /* packet source is not valid */ + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("ip4_input: packet source is not valid.\n")); + /* free (drop) packet pbufs */ + pbuf_free(p); + IP_STATS_INC(ip.drop); + MIB2_STATS_INC(mib2.ipinaddrerrors); + MIB2_STATS_INC(mib2.ipindiscards); + return ERR_OK; + } + } + + /* packet not for us? */ + if (netif == NULL) { + /* packet not for us, route or discard */ + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_TRACE, ("ip4_input: packet not for us.\n")); +#if IP_FORWARD + /* non-broadcast packet? */ + if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), inp)) { + /* try to forward IP packet on (other) interfaces */ + ip4_forward(p, (struct ip_hdr *)p->payload, inp); + } else +#endif /* IP_FORWARD */ + { + IP_STATS_INC(ip.drop); + MIB2_STATS_INC(mib2.ipinaddrerrors); + MIB2_STATS_INC(mib2.ipindiscards); + } + pbuf_free(p); + return ERR_OK; + } + + /* packet consists of multiple fragments? */ + if ((IPH_OFFSET(iphdr) & PP_HTONS(IP_OFFMASK | IP_MF)) != 0) { +#if IP_REASSEMBLY /* packet fragment reassembly code present? */ + LWIP_DEBUGF(IP_DEBUG, ("IP packet is a fragment (id=0x%04"X16_F" tot_len=%"U16_F" len=%"U16_F" MF=%"U16_F" offset=%"U16_F"), calling ip4_reass()\n", + lwip_ntohs(IPH_ID(iphdr)), p->tot_len, lwip_ntohs(IPH_LEN(iphdr)), (u16_t)!!(IPH_OFFSET(iphdr) & PP_HTONS(IP_MF)), (u16_t)((lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK) * 8))); + /* reassemble the packet*/ + p = ip4_reass(p); + /* packet not fully reassembled yet? */ + if (p == NULL) { + return ERR_OK; + } + iphdr = (const struct ip_hdr *)p->payload; +#else /* IP_REASSEMBLY == 0, no packet fragment reassembly code present */ + pbuf_free(p); + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since it was fragmented (0x%"X16_F") (while IP_REASSEMBLY == 0).\n", + lwip_ntohs(IPH_OFFSET(iphdr)))); + IP_STATS_INC(ip.opterr); + IP_STATS_INC(ip.drop); + /* unsupported protocol feature */ + MIB2_STATS_INC(mib2.ipinunknownprotos); + return ERR_OK; +#endif /* IP_REASSEMBLY */ + } + +#if IP_OPTIONS_ALLOWED == 0 /* no support for IP options in the IP header? */ + +#if LWIP_IGMP + /* there is an extra "router alert" option in IGMP messages which we allow for but do not police */ + if ((iphdr_hlen > IP_HLEN) && (IPH_PROTO(iphdr) != IP_PROTO_IGMP)) { +#else + if (iphdr_hlen > IP_HLEN) { +#endif /* LWIP_IGMP */ + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("IP packet dropped since there were IP options (while IP_OPTIONS_ALLOWED == 0).\n")); + pbuf_free(p); + IP_STATS_INC(ip.opterr); + IP_STATS_INC(ip.drop); + /* unsupported protocol feature */ + MIB2_STATS_INC(mib2.ipinunknownprotos); + return ERR_OK; + } +#endif /* IP_OPTIONS_ALLOWED == 0 */ + + /* send to upper layers */ + LWIP_DEBUGF(IP_DEBUG, ("ip4_input: \n")); + ip4_debug_print(p); + LWIP_DEBUGF(IP_DEBUG, ("ip4_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len)); + + ip_data.current_netif = netif; + ip_data.current_input_netif = inp; + ip_data.current_ip4_header = iphdr; + ip_data.current_ip_header_tot_len = IPH_HL_BYTES(iphdr); + +#if LWIP_RAW + /* raw input did not eat the packet? */ + raw_status = raw_input(p, inp); + if (raw_status != RAW_INPUT_EATEN) +#endif /* LWIP_RAW */ + { + pbuf_remove_header(p, iphdr_hlen); /* Move to payload, no check necessary. */ + + switch (IPH_PROTO(iphdr)) { +#if LWIP_UDP + case IP_PROTO_UDP: +#if LWIP_UDPLITE + case IP_PROTO_UDPLITE: +#endif /* LWIP_UDPLITE */ + MIB2_STATS_INC(mib2.ipindelivers); + udp_input(p, inp); + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case IP_PROTO_TCP: + MIB2_STATS_INC(mib2.ipindelivers); + tcp_input(p, inp); + break; +#endif /* LWIP_TCP */ +#if LWIP_ICMP + case IP_PROTO_ICMP: + MIB2_STATS_INC(mib2.ipindelivers); + icmp_input(p, inp); + break; +#endif /* LWIP_ICMP */ +#if LWIP_IGMP + case IP_PROTO_IGMP: + igmp_input(p, inp, ip4_current_dest_addr()); + break; +#endif /* LWIP_IGMP */ + default: +#if LWIP_RAW + if (raw_status == RAW_INPUT_DELIVERED) { + MIB2_STATS_INC(mib2.ipindelivers); + } else +#endif /* LWIP_RAW */ + { +#if LWIP_ICMP + /* send ICMP destination protocol unreachable unless is was a broadcast */ + if (!ip4_addr_isbroadcast(ip4_current_dest_addr(), netif) && + !ip4_addr_ismulticast(ip4_current_dest_addr())) { + pbuf_header_force(p, (s16_t)iphdr_hlen); /* Move to ip header, no check necessary. */ + icmp_dest_unreach(p, ICMP_DUR_PROTO); + } +#endif /* LWIP_ICMP */ + + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("Unsupported transport protocol %"U16_F"\n", (u16_t)IPH_PROTO(iphdr))); + + IP_STATS_INC(ip.proterr); + IP_STATS_INC(ip.drop); + MIB2_STATS_INC(mib2.ipinunknownprotos); + } + pbuf_free(p); + break; + } + } + + /* @todo: this is not really necessary... */ + ip_data.current_netif = NULL; + ip_data.current_input_netif = NULL; + ip_data.current_ip4_header = NULL; + ip_data.current_ip_header_tot_len = 0; + ip4_addr_set_any(ip4_current_src_addr()); + ip4_addr_set_any(ip4_current_dest_addr()); + + return ERR_OK; +} + +/** + * Sends an IP packet on a network interface. This function constructs + * the IP header and calculates the IP header checksum. If the source + * IP address is NULL, the IP address of the outgoing network + * interface is filled in as source address. + * If the destination IP address is LWIP_IP_HDRINCL, p is assumed to already + * include an IP header and p->payload points to it instead of the data. + * + * @param p the packet to send (p->payload points to the data, e.g. next + protocol header; if dest == LWIP_IP_HDRINCL, p already includes an + IP header and p->payload points to that IP header) + * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the + * IP address of the netif used to send is used as source address) + * @param dest the destination IP address to send the packet to + * @param ttl the TTL value to be set in the IP header + * @param tos the TOS value to be set in the IP header + * @param proto the PROTOCOL to be set in the IP header + * @param netif the netif on which to send this packet + * @return ERR_OK if the packet was sent OK + * ERR_BUF if p doesn't have enough space for IP/LINK headers + * returns errors returned by netif->output + * + * @note ip_id: RFC791 "some host may be able to simply use + * unique identifiers independent of destination" + */ +err_t +ip4_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, + u8_t proto, struct netif *netif) +{ +#if IP_OPTIONS_SEND + return ip4_output_if_opt(p, src, dest, ttl, tos, proto, netif, NULL, 0); +} + +/** + * Same as ip_output_if() but with the possibility to include IP options: + * + * @ param ip_options pointer to the IP options, copied into the IP header + * @ param optlen length of ip_options + */ +err_t +ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, + u16_t optlen) +{ +#endif /* IP_OPTIONS_SEND */ + const ip4_addr_t *src_used = src; + if (dest != LWIP_IP_HDRINCL) { + if (ip4_addr_isany(src)) { + src_used = netif_ip4_addr(netif); + } + } + +#if IP_OPTIONS_SEND + return ip4_output_if_opt_src(p, src_used, dest, ttl, tos, proto, netif, + ip_options, optlen); +#else /* IP_OPTIONS_SEND */ + return ip4_output_if_src(p, src_used, dest, ttl, tos, proto, netif); +#endif /* IP_OPTIONS_SEND */ +} + +/** + * Same as ip_output_if() but 'src' address is not replaced by netif address + * when it is 'any'. + */ +err_t +ip4_output_if_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, + u8_t proto, struct netif *netif) +{ +#if IP_OPTIONS_SEND + return ip4_output_if_opt_src(p, src, dest, ttl, tos, proto, netif, NULL, 0); +} + +/** + * Same as ip_output_if_opt() but 'src' address is not replaced by netif address + * when it is 'any'. + */ +err_t +ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, + u16_t optlen) +{ +#endif /* IP_OPTIONS_SEND */ + struct ip_hdr *iphdr; + ip4_addr_t dest_addr; +#if CHECKSUM_GEN_IP_INLINE + u32_t chk_sum = 0; +#endif /* CHECKSUM_GEN_IP_INLINE */ + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); + + MIB2_STATS_INC(mib2.ipoutrequests); + + /* Should the IP header be generated or is it already included in p? */ + if (dest != LWIP_IP_HDRINCL) { + u16_t ip_hlen = IP_HLEN; +#if IP_OPTIONS_SEND + u16_t optlen_aligned = 0; + if (optlen != 0) { +#if CHECKSUM_GEN_IP_INLINE + int i; +#endif /* CHECKSUM_GEN_IP_INLINE */ + if (optlen > (IP_HLEN_MAX - IP_HLEN)) { + /* optlen too long */ + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output_if_opt: optlen too long\n")); + IP_STATS_INC(ip.err); + MIB2_STATS_INC(mib2.ipoutdiscards); + return ERR_VAL; + } + /* round up to a multiple of 4 */ + optlen_aligned = (u16_t)((optlen + 3) & ~3); + ip_hlen = (u16_t)(ip_hlen + optlen_aligned); + /* First write in the IP options */ + if (pbuf_add_header(p, optlen_aligned)) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output_if_opt: not enough room for IP options in pbuf\n")); + IP_STATS_INC(ip.err); + MIB2_STATS_INC(mib2.ipoutdiscards); + return ERR_BUF; + } + MEMCPY(p->payload, ip_options, optlen); + if (optlen < optlen_aligned) { + /* zero the remaining bytes */ + memset(((char *)p->payload) + optlen, 0, (size_t)(optlen_aligned - optlen)); + } +#if CHECKSUM_GEN_IP_INLINE + for (i = 0; i < optlen_aligned / 2; i++) { + chk_sum += ((u16_t *)p->payload)[i]; + } +#endif /* CHECKSUM_GEN_IP_INLINE */ + } +#endif /* IP_OPTIONS_SEND */ + /* generate IP header */ + if (pbuf_add_header(p, IP_HLEN)) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output: not enough room for IP header in pbuf\n")); + + IP_STATS_INC(ip.err); + MIB2_STATS_INC(mib2.ipoutdiscards); + return ERR_BUF; + } + + iphdr = (struct ip_hdr *)p->payload; + LWIP_ASSERT("check that first pbuf can hold struct ip_hdr", + (p->len >= sizeof(struct ip_hdr))); + + IPH_TTL_SET(iphdr, ttl); + IPH_PROTO_SET(iphdr, proto); +#if CHECKSUM_GEN_IP_INLINE + chk_sum += PP_NTOHS(proto | (ttl << 8)); +#endif /* CHECKSUM_GEN_IP_INLINE */ + + /* dest cannot be NULL here */ + ip4_addr_copy(iphdr->dest, *dest); +#if CHECKSUM_GEN_IP_INLINE + chk_sum += ip4_addr_get_u32(&iphdr->dest) & 0xFFFF; + chk_sum += ip4_addr_get_u32(&iphdr->dest) >> 16; +#endif /* CHECKSUM_GEN_IP_INLINE */ + + IPH_VHL_SET(iphdr, 4, ip_hlen / 4); + IPH_TOS_SET(iphdr, tos); +#if CHECKSUM_GEN_IP_INLINE + chk_sum += PP_NTOHS(tos | (iphdr->_v_hl << 8)); +#endif /* CHECKSUM_GEN_IP_INLINE */ + IPH_LEN_SET(iphdr, lwip_htons(p->tot_len)); +#if CHECKSUM_GEN_IP_INLINE + chk_sum += iphdr->_len; +#endif /* CHECKSUM_GEN_IP_INLINE */ + IPH_OFFSET_SET(iphdr, 0); + IPH_ID_SET(iphdr, lwip_htons(ip_id)); +#if CHECKSUM_GEN_IP_INLINE + chk_sum += iphdr->_id; +#endif /* CHECKSUM_GEN_IP_INLINE */ + ++ip_id; + + if (src == NULL) { + ip4_addr_copy(iphdr->src, *IP4_ADDR_ANY4); + } else { + /* src cannot be NULL here */ + ip4_addr_copy(iphdr->src, *src); + } + +#if CHECKSUM_GEN_IP_INLINE + chk_sum += ip4_addr_get_u32(&iphdr->src) & 0xFFFF; + chk_sum += ip4_addr_get_u32(&iphdr->src) >> 16; + chk_sum = (chk_sum >> 16) + (chk_sum & 0xFFFF); + chk_sum = (chk_sum >> 16) + chk_sum; + chk_sum = ~chk_sum; + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) { + iphdr->_chksum = (u16_t)chk_sum; /* network order */ + } +#if LWIP_CHECKSUM_CTRL_PER_NETIF + else { + IPH_CHKSUM_SET(iphdr, 0); + } +#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF*/ +#else /* CHECKSUM_GEN_IP_INLINE */ + IPH_CHKSUM_SET(iphdr, 0); +#if CHECKSUM_GEN_IP + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) { + IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, ip_hlen)); + } +#endif /* CHECKSUM_GEN_IP */ +#endif /* CHECKSUM_GEN_IP_INLINE */ + } else { + /* IP header already included in p */ + if (p->len < IP_HLEN) { + LWIP_DEBUGF(IP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip4_output: LWIP_IP_HDRINCL but pbuf is too short\n")); + IP_STATS_INC(ip.err); + MIB2_STATS_INC(mib2.ipoutdiscards); + return ERR_BUF; + } + iphdr = (struct ip_hdr *)p->payload; + ip4_addr_copy(dest_addr, iphdr->dest); + dest = &dest_addr; + } + + IP_STATS_INC(ip.xmit); + + LWIP_DEBUGF(IP_DEBUG, ("ip4_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], (u16_t)netif->num)); + ip4_debug_print(p); + +#if ENABLE_LOOPBACK + if (ip4_addr_cmp(dest, netif_ip4_addr(netif)) +#if !LWIP_HAVE_LOOPIF + || ip4_addr_isloopback(dest) +#endif /* !LWIP_HAVE_LOOPIF */ + ) { + /* Packet to self, enqueue it for loopback */ + LWIP_DEBUGF(IP_DEBUG, ("netif_loop_output()")); + return netif_loop_output(netif, p); + } +#if LWIP_MULTICAST_TX_OPTIONS + if ((p->flags & PBUF_FLAG_MCASTLOOP) != 0) { + netif_loop_output(netif, p); + } +#endif /* LWIP_MULTICAST_TX_OPTIONS */ +#endif /* ENABLE_LOOPBACK */ +#if IP_FRAG + /* don't fragment if interface has mtu set to 0 [loopif] */ + if (netif->mtu && (p->tot_len > netif->mtu)) { + return ip4_frag(p, netif, dest); + } +#endif /* IP_FRAG */ + + LWIP_DEBUGF(IP_DEBUG, ("ip4_output_if: call netif->output()\n")); + return netif->output(netif, p, dest); +} + +/** + * Simple interface to ip_output_if. It finds the outgoing network + * interface and calls upon ip_output_if to do the actual work. + * + * @param p the packet to send (p->payload points to the data, e.g. next + protocol header; if dest == LWIP_IP_HDRINCL, p already includes an + IP header and p->payload points to that IP header) + * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the + * IP address of the netif used to send is used as source address) + * @param dest the destination IP address to send the packet to + * @param ttl the TTL value to be set in the IP header + * @param tos the TOS value to be set in the IP header + * @param proto the PROTOCOL to be set in the IP header + * + * @return ERR_RTE if no route is found + * see ip_output_if() for more return values + */ +err_t +ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto) +{ + struct netif *netif; + + LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); + + if ((netif = ip4_route_src(src, dest)) == NULL) { + LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); + IP_STATS_INC(ip.rterr); + return ERR_RTE; + } + + return ip4_output_if(p, src, dest, ttl, tos, proto, netif); +} + +#if LWIP_NETIF_USE_HINTS +/** Like ip_output, but takes and addr_hint pointer that is passed on to netif->addr_hint + * before calling ip_output_if. + * + * @param p the packet to send (p->payload points to the data, e.g. next + protocol header; if dest == LWIP_IP_HDRINCL, p already includes an + IP header and p->payload points to that IP header) + * @param src the source IP address to send from (if src == IP4_ADDR_ANY, the + * IP address of the netif used to send is used as source address) + * @param dest the destination IP address to send the packet to + * @param ttl the TTL value to be set in the IP header + * @param tos the TOS value to be set in the IP header + * @param proto the PROTOCOL to be set in the IP header + * @param netif_hint netif output hint pointer set to netif->hint before + * calling ip_output_if() + * + * @return ERR_RTE if no route is found + * see ip_output_if() for more return values + */ +err_t +ip4_output_hinted(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif_hint *netif_hint) +{ + struct netif *netif; + err_t err; + + LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); + + if ((netif = ip4_route_src(src, dest)) == NULL) { + LWIP_DEBUGF(IP_DEBUG, ("ip4_output: No route to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + ip4_addr1_16(dest), ip4_addr2_16(dest), ip4_addr3_16(dest), ip4_addr4_16(dest))); + IP_STATS_INC(ip.rterr); + return ERR_RTE; + } + + NETIF_SET_HINTS(netif, netif_hint); + err = ip4_output_if(p, src, dest, ttl, tos, proto, netif); + NETIF_RESET_HINTS(netif); + + return err; +} +#endif /* LWIP_NETIF_USE_HINTS*/ + +#if IP_DEBUG +/* Print an IP header by using LWIP_DEBUGF + * @param p an IP packet, p->payload pointing to the IP header + */ +void +ip4_debug_print(struct pbuf *p) +{ + struct ip_hdr *iphdr = (struct ip_hdr *)p->payload; + + LWIP_DEBUGF(IP_DEBUG, ("IP header:\n")); + LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP_DEBUG, ("|%2"S16_F" |%2"S16_F" | 0x%02"X16_F" | %5"U16_F" | (v, hl, tos, len)\n", + (u16_t)IPH_V(iphdr), + (u16_t)IPH_HL(iphdr), + (u16_t)IPH_TOS(iphdr), + lwip_ntohs(IPH_LEN(iphdr)))); + LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP_DEBUG, ("| %5"U16_F" |%"U16_F"%"U16_F"%"U16_F"| %4"U16_F" | (id, flags, offset)\n", + lwip_ntohs(IPH_ID(iphdr)), + (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 15 & 1), + (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 14 & 1), + (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) >> 13 & 1), + (u16_t)(lwip_ntohs(IPH_OFFSET(iphdr)) & IP_OFFMASK))); + LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | 0x%04"X16_F" | (ttl, proto, chksum)\n", + (u16_t)IPH_TTL(iphdr), + (u16_t)IPH_PROTO(iphdr), + lwip_ntohs(IPH_CHKSUM(iphdr)))); + LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (src)\n", + ip4_addr1_16_val(iphdr->src), + ip4_addr2_16_val(iphdr->src), + ip4_addr3_16_val(iphdr->src), + ip4_addr4_16_val(iphdr->src))); + LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP_DEBUG, ("| %3"U16_F" | %3"U16_F" | %3"U16_F" | %3"U16_F" | (dest)\n", + ip4_addr1_16_val(iphdr->dest), + ip4_addr2_16_val(iphdr->dest), + ip4_addr3_16_val(iphdr->dest), + ip4_addr4_16_val(iphdr->dest))); + LWIP_DEBUGF(IP_DEBUG, ("+-------------------------------+\n")); +} +#endif /* IP_DEBUG */ + +#endif /* LWIP_IPV4 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_addr.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_addr.c index 92077c20..33204d11 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_addr.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_addr.c @@ -1,321 +1,321 @@ -/** - * @file - * This is the IPv4 address tools implementation. - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 - -#include "lwip/ip_addr.h" -#include "lwip/netif.h" - -/* used by IP4_ADDR_ANY and IP_ADDR_BROADCAST in ip_addr.h */ -const ip_addr_t ip_addr_any = IPADDR4_INIT(IPADDR_ANY); -const ip_addr_t ip_addr_broadcast = IPADDR4_INIT(IPADDR_BROADCAST); - -/** - * Determine if an address is a broadcast address on a network interface - * - * @param addr address to be checked - * @param netif the network interface against which the address is checked - * @return returns non-zero if the address is a broadcast address - */ -u8_t -ip4_addr_isbroadcast_u32(u32_t addr, const struct netif *netif) -{ - ip4_addr_t ipaddr; - ip4_addr_set_u32(&ipaddr, addr); - - /* all ones (broadcast) or all zeroes (old skool broadcast) */ - if ((~addr == IPADDR_ANY) || - (addr == IPADDR_ANY)) { - return 1; - /* no broadcast support on this network interface? */ - } else if ((netif->flags & NETIF_FLAG_BROADCAST) == 0) { - /* the given address cannot be a broadcast address - * nor can we check against any broadcast addresses */ - return 0; - /* address matches network interface address exactly? => no broadcast */ - } else if (addr == ip4_addr_get_u32(netif_ip4_addr(netif))) { - return 0; - /* on the same (sub) network... */ - } else if (ip4_addr_netcmp(&ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) - /* ...and host identifier bits are all ones? =>... */ - && ((addr & ~ip4_addr_get_u32(netif_ip4_netmask(netif))) == - (IPADDR_BROADCAST & ~ip4_addr_get_u32(netif_ip4_netmask(netif))))) { - /* => network broadcast address */ - return 1; - } else { - return 0; - } -} - -/** Checks if a netmask is valid (starting with ones, then only zeros) - * - * @param netmask the IPv4 netmask to check (in network byte order!) - * @return 1 if the netmask is valid, 0 if it is not - */ -u8_t -ip4_addr_netmask_valid(u32_t netmask) -{ - u32_t mask; - u32_t nm_hostorder = lwip_htonl(netmask); - - /* first, check for the first zero */ - for (mask = 1UL << 31 ; mask != 0; mask >>= 1) { - if ((nm_hostorder & mask) == 0) { - break; - } - } - /* then check that there is no one */ - for (; mask != 0; mask >>= 1) { - if ((nm_hostorder & mask) != 0) { - /* there is a one after the first zero -> invalid */ - return 0; - } - } - /* no one after the first zero -> valid */ - return 1; -} - -/** - * Ascii internet address interpretation routine. - * The value returned is in network order. - * - * @param cp IP address in ascii representation (e.g. "127.0.0.1") - * @return ip address in network order - */ -u32_t -ipaddr_addr(const char *cp) -{ - ip4_addr_t val; - - if (ip4addr_aton(cp, &val)) { - return ip4_addr_get_u32(&val); - } - return (IPADDR_NONE); -} - -/** - * Check whether "cp" is a valid ascii representation - * of an Internet address and convert to a binary address. - * Returns 1 if the address is valid, 0 if not. - * This replaces inet_addr, the return value from which - * cannot distinguish between failure and a local broadcast address. - * - * @param cp IP address in ascii representation (e.g. "127.0.0.1") - * @param addr pointer to which to save the ip address in network order - * @return 1 if cp could be converted to addr, 0 on failure - */ -int -ip4addr_aton(const char *cp, ip4_addr_t *addr) -{ - u32_t val; - u8_t base; - char c; - u32_t parts[4]; - u32_t *pp = parts; - - c = *cp; - for (;;) { - /* - * Collect number up to ``.''. - * Values are specified as for C: - * 0x=hex, 0=octal, 1-9=decimal. - */ - if (!lwip_isdigit(c)) { - return 0; - } - val = 0; - base = 10; - if (c == '0') { - c = *++cp; - if (c == 'x' || c == 'X') { - base = 16; - c = *++cp; - } else { - base = 8; - } - } - for (;;) { - if (lwip_isdigit(c)) { - val = (val * base) + (u32_t)(c - '0'); - c = *++cp; - } else if (base == 16 && lwip_isxdigit(c)) { - val = (val << 4) | (u32_t)(c + 10 - (lwip_islower(c) ? 'a' : 'A')); - c = *++cp; - } else { - break; - } - } - if (c == '.') { - /* - * Internet format: - * a.b.c.d - * a.b.c (with c treated as 16 bits) - * a.b (with b treated as 24 bits) - */ - if (pp >= parts + 3) { - return 0; - } - *pp++ = val; - c = *++cp; - } else { - break; - } - } - /* - * Check for trailing characters. - */ - if (c != '\0' && !lwip_isspace(c)) { - return 0; - } - /* - * Concoct the address according to - * the number of parts specified. - */ - switch (pp - parts + 1) { - - case 0: - return 0; /* initial nondigit */ - - case 1: /* a -- 32 bits */ - break; - - case 2: /* a.b -- 8.24 bits */ - if (val > 0xffffffUL) { - return 0; - } - if (parts[0] > 0xff) { - return 0; - } - val |= parts[0] << 24; - break; - - case 3: /* a.b.c -- 8.8.16 bits */ - if (val > 0xffff) { - return 0; - } - if ((parts[0] > 0xff) || (parts[1] > 0xff)) { - return 0; - } - val |= (parts[0] << 24) | (parts[1] << 16); - break; - - case 4: /* a.b.c.d -- 8.8.8.8 bits */ - if (val > 0xff) { - return 0; - } - if ((parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff)) { - return 0; - } - val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8); - break; - default: - LWIP_ASSERT("unhandled", 0); - break; - } - if (addr) { - ip4_addr_set_u32(addr, lwip_htonl(val)); - } - return 1; -} - -/** - * Convert numeric IP address into decimal dotted ASCII representation. - * returns ptr to static buffer; not reentrant! - * - * @param addr ip address in network order to convert - * @return pointer to a global static (!) buffer that holds the ASCII - * representation of addr - */ -char * -ip4addr_ntoa(const ip4_addr_t *addr) -{ - static char str[IP4ADDR_STRLEN_MAX]; - return ip4addr_ntoa_r(addr, str, IP4ADDR_STRLEN_MAX); -} - -/** - * Same as ip4addr_ntoa, but reentrant since a user-supplied buffer is used. - * - * @param addr ip address in network order to convert - * @param buf target buffer where the string is stored - * @param buflen length of buf - * @return either pointer to buf which now holds the ASCII - * representation of addr or NULL if buf was too small - */ -char * -ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen) -{ - u32_t s_addr; - char inv[3]; - char *rp; - u8_t *ap; - u8_t rem; - u8_t n; - u8_t i; - int len = 0; - - s_addr = ip4_addr_get_u32(addr); - - rp = buf; - ap = (u8_t *)&s_addr; - for (n = 0; n < 4; n++) { - i = 0; - do { - rem = *ap % (u8_t)10; - *ap /= (u8_t)10; - inv[i++] = (char)('0' + rem); - } while (*ap); - while (i--) { - if (len++ >= buflen) { - return NULL; - } - *rp++ = inv[i]; - } - if (len++ >= buflen) { - return NULL; - } - *rp++ = '.'; - ap++; - } - *--rp = 0; - return buf; -} - -#endif /* LWIP_IPV4 */ +/** + * @file + * This is the IPv4 address tools implementation. + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 + +#include "lwip/ip_addr.h" +#include "lwip/netif.h" + +/* used by IP4_ADDR_ANY and IP_ADDR_BROADCAST in ip_addr.h */ +const ip_addr_t ip_addr_any = IPADDR4_INIT(IPADDR_ANY); +const ip_addr_t ip_addr_broadcast = IPADDR4_INIT(IPADDR_BROADCAST); + +/** + * Determine if an address is a broadcast address on a network interface + * + * @param addr address to be checked + * @param netif the network interface against which the address is checked + * @return returns non-zero if the address is a broadcast address + */ +u8_t +ip4_addr_isbroadcast_u32(u32_t addr, const struct netif *netif) +{ + ip4_addr_t ipaddr; + ip4_addr_set_u32(&ipaddr, addr); + + /* all ones (broadcast) or all zeroes (old skool broadcast) */ + if ((~addr == IPADDR_ANY) || + (addr == IPADDR_ANY)) { + return 1; + /* no broadcast support on this network interface? */ + } else if ((netif->flags & NETIF_FLAG_BROADCAST) == 0) { + /* the given address cannot be a broadcast address + * nor can we check against any broadcast addresses */ + return 0; + /* address matches network interface address exactly? => no broadcast */ + } else if (addr == ip4_addr_get_u32(netif_ip4_addr(netif))) { + return 0; + /* on the same (sub) network... */ + } else if (ip4_addr_netcmp(&ipaddr, netif_ip4_addr(netif), netif_ip4_netmask(netif)) + /* ...and host identifier bits are all ones? =>... */ + && ((addr & ~ip4_addr_get_u32(netif_ip4_netmask(netif))) == + (IPADDR_BROADCAST & ~ip4_addr_get_u32(netif_ip4_netmask(netif))))) { + /* => network broadcast address */ + return 1; + } else { + return 0; + } +} + +/** Checks if a netmask is valid (starting with ones, then only zeros) + * + * @param netmask the IPv4 netmask to check (in network byte order!) + * @return 1 if the netmask is valid, 0 if it is not + */ +u8_t +ip4_addr_netmask_valid(u32_t netmask) +{ + u32_t mask; + u32_t nm_hostorder = lwip_htonl(netmask); + + /* first, check for the first zero */ + for (mask = 1UL << 31 ; mask != 0; mask >>= 1) { + if ((nm_hostorder & mask) == 0) { + break; + } + } + /* then check that there is no one */ + for (; mask != 0; mask >>= 1) { + if ((nm_hostorder & mask) != 0) { + /* there is a one after the first zero -> invalid */ + return 0; + } + } + /* no one after the first zero -> valid */ + return 1; +} + +/** + * Ascii internet address interpretation routine. + * The value returned is in network order. + * + * @param cp IP address in ascii representation (e.g. "127.0.0.1") + * @return ip address in network order + */ +u32_t +ipaddr_addr(const char *cp) +{ + ip4_addr_t val; + + if (ip4addr_aton(cp, &val)) { + return ip4_addr_get_u32(&val); + } + return (IPADDR_NONE); +} + +/** + * Check whether "cp" is a valid ascii representation + * of an Internet address and convert to a binary address. + * Returns 1 if the address is valid, 0 if not. + * This replaces inet_addr, the return value from which + * cannot distinguish between failure and a local broadcast address. + * + * @param cp IP address in ascii representation (e.g. "127.0.0.1") + * @param addr pointer to which to save the ip address in network order + * @return 1 if cp could be converted to addr, 0 on failure + */ +int +ip4addr_aton(const char *cp, ip4_addr_t *addr) +{ + u32_t val; + u8_t base; + char c; + u32_t parts[4]; + u32_t *pp = parts; + + c = *cp; + for (;;) { + /* + * Collect number up to ``.''. + * Values are specified as for C: + * 0x=hex, 0=octal, 1-9=decimal. + */ + if (!lwip_isdigit(c)) { + return 0; + } + val = 0; + base = 10; + if (c == '0') { + c = *++cp; + if (c == 'x' || c == 'X') { + base = 16; + c = *++cp; + } else { + base = 8; + } + } + for (;;) { + if (lwip_isdigit(c)) { + val = (val * base) + (u32_t)(c - '0'); + c = *++cp; + } else if (base == 16 && lwip_isxdigit(c)) { + val = (val << 4) | (u32_t)(c + 10 - (lwip_islower(c) ? 'a' : 'A')); + c = *++cp; + } else { + break; + } + } + if (c == '.') { + /* + * Internet format: + * a.b.c.d + * a.b.c (with c treated as 16 bits) + * a.b (with b treated as 24 bits) + */ + if (pp >= parts + 3) { + return 0; + } + *pp++ = val; + c = *++cp; + } else { + break; + } + } + /* + * Check for trailing characters. + */ + if (c != '\0' && !lwip_isspace(c)) { + return 0; + } + /* + * Concoct the address according to + * the number of parts specified. + */ + switch (pp - parts + 1) { + + case 0: + return 0; /* initial nondigit */ + + case 1: /* a -- 32 bits */ + break; + + case 2: /* a.b -- 8.24 bits */ + if (val > 0xffffffUL) { + return 0; + } + if (parts[0] > 0xff) { + return 0; + } + val |= parts[0] << 24; + break; + + case 3: /* a.b.c -- 8.8.16 bits */ + if (val > 0xffff) { + return 0; + } + if ((parts[0] > 0xff) || (parts[1] > 0xff)) { + return 0; + } + val |= (parts[0] << 24) | (parts[1] << 16); + break; + + case 4: /* a.b.c.d -- 8.8.8.8 bits */ + if (val > 0xff) { + return 0; + } + if ((parts[0] > 0xff) || (parts[1] > 0xff) || (parts[2] > 0xff)) { + return 0; + } + val |= (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8); + break; + default: + LWIP_ASSERT("unhandled", 0); + break; + } + if (addr) { + ip4_addr_set_u32(addr, lwip_htonl(val)); + } + return 1; +} + +/** + * Convert numeric IP address into decimal dotted ASCII representation. + * returns ptr to static buffer; not reentrant! + * + * @param addr ip address in network order to convert + * @return pointer to a global static (!) buffer that holds the ASCII + * representation of addr + */ +char * +ip4addr_ntoa(const ip4_addr_t *addr) +{ + static char str[IP4ADDR_STRLEN_MAX]; + return ip4addr_ntoa_r(addr, str, IP4ADDR_STRLEN_MAX); +} + +/** + * Same as ip4addr_ntoa, but reentrant since a user-supplied buffer is used. + * + * @param addr ip address in network order to convert + * @param buf target buffer where the string is stored + * @param buflen length of buf + * @return either pointer to buf which now holds the ASCII + * representation of addr or NULL if buf was too small + */ +char * +ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen) +{ + u32_t s_addr; + char inv[3]; + char *rp; + u8_t *ap; + u8_t rem; + u8_t n; + u8_t i; + int len = 0; + + s_addr = ip4_addr_get_u32(addr); + + rp = buf; + ap = (u8_t *)&s_addr; + for (n = 0; n < 4; n++) { + i = 0; + do { + rem = *ap % (u8_t)10; + *ap /= (u8_t)10; + inv[i++] = (char)('0' + rem); + } while (*ap); + while (i--) { + if (len++ >= buflen) { + return NULL; + } + *rp++ = inv[i]; + } + if (len++ >= buflen) { + return NULL; + } + *rp++ = '.'; + ap++; + } + *--rp = 0; + return buf; +} + +#endif /* LWIP_IPV4 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_frag.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_frag.c index b2fd14c5..a445530e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_frag.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv4/ip4_frag.c @@ -1,894 +1,894 @@ -/** - * @file - * This is the IPv4 packet segmentation and reassembly implementation. - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Jani Monoses - * Simon Goldschmidt - * original reassembly code by Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV4 - -#include "lwip/ip4_frag.h" -#include "lwip/def.h" -#include "lwip/inet_chksum.h" -#include "lwip/netif.h" -#include "lwip/stats.h" -#include "lwip/icmp.h" - -#include - -#if IP_REASSEMBLY -/** - * The IP reassembly code currently has the following limitations: - * - IP header options are not supported - * - fragments must not overlap (e.g. due to different routes), - * currently, overlapping or duplicate fragments are thrown away - * if IP_REASS_CHECK_OVERLAP=1 (the default)! - * - * @todo: work with IP header options - */ - -/** Setting this to 0, you can turn off checking the fragments for overlapping - * regions. The code gets a little smaller. Only use this if you know that - * overlapping won't occur on your network! */ -#ifndef IP_REASS_CHECK_OVERLAP -#define IP_REASS_CHECK_OVERLAP 1 -#endif /* IP_REASS_CHECK_OVERLAP */ - -/** Set to 0 to prevent freeing the oldest datagram when the reassembly buffer is - * full (IP_REASS_MAX_PBUFS pbufs are enqueued). The code gets a little smaller. - * Datagrams will be freed by timeout only. Especially useful when MEMP_NUM_REASSDATA - * is set to 1, so one datagram can be reassembled at a time, only. */ -#ifndef IP_REASS_FREE_OLDEST -#define IP_REASS_FREE_OLDEST 1 -#endif /* IP_REASS_FREE_OLDEST */ - -#define IP_REASS_FLAG_LASTFRAG 0x01 - -#define IP_REASS_VALIDATE_TELEGRAM_FINISHED 1 -#define IP_REASS_VALIDATE_PBUF_QUEUED 0 -#define IP_REASS_VALIDATE_PBUF_DROPPED -1 - -/** This is a helper struct which holds the starting - * offset and the ending offset of this fragment to - * easily chain the fragments. - * It has the same packing requirements as the IP header, since it replaces - * the IP header in memory in incoming fragments (after copying it) to keep - * track of the various fragments. (-> If the IP header doesn't need packing, - * this struct doesn't need packing, too.) - */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip_reass_helper { - PACK_STRUCT_FIELD(struct pbuf *next_pbuf); - PACK_STRUCT_FIELD(u16_t start); - PACK_STRUCT_FIELD(u16_t end); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#define IP_ADDRESSES_AND_ID_MATCH(iphdrA, iphdrB) \ - (ip4_addr_cmp(&(iphdrA)->src, &(iphdrB)->src) && \ - ip4_addr_cmp(&(iphdrA)->dest, &(iphdrB)->dest) && \ - IPH_ID(iphdrA) == IPH_ID(iphdrB)) ? 1 : 0 - -/* global variables */ -static struct ip_reassdata *reassdatagrams; -static u16_t ip_reass_pbufcount; - -/* function prototypes */ -static void ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev); -static int ip_reass_free_complete_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev); - -/** - * Reassembly timer base function - * for both NO_SYS == 0 and 1 (!). - * - * Should be called every 1000 msec (defined by IP_TMR_INTERVAL). - */ -void -ip_reass_tmr(void) -{ - struct ip_reassdata *r, *prev = NULL; - - r = reassdatagrams; - while (r != NULL) { - /* Decrement the timer. Once it reaches 0, - * clean up the incomplete fragment assembly */ - if (r->timer > 0) { - r->timer--; - LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer dec %"U16_F"\n", (u16_t)r->timer)); - prev = r; - r = r->next; - } else { - /* reassembly timed out */ - struct ip_reassdata *tmp; - LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer timed out\n")); - tmp = r; - /* get the next pointer before freeing */ - r = r->next; - /* free the helper struct and all enqueued pbufs */ - ip_reass_free_complete_datagram(tmp, prev); - } - } -} - -/** - * Free a datagram (struct ip_reassdata) and all its pbufs. - * Updates the total count of enqueued pbufs (ip_reass_pbufcount), - * SNMP counters and sends an ICMP time exceeded packet. - * - * @param ipr datagram to free - * @param prev the previous datagram in the linked list - * @return the number of pbufs freed - */ -static int -ip_reass_free_complete_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev) -{ - u16_t pbufs_freed = 0; - u16_t clen; - struct pbuf *p; - struct ip_reass_helper *iprh; - - LWIP_ASSERT("prev != ipr", prev != ipr); - if (prev != NULL) { - LWIP_ASSERT("prev->next == ipr", prev->next == ipr); - } - - MIB2_STATS_INC(mib2.ipreasmfails); -#if LWIP_ICMP - iprh = (struct ip_reass_helper *)ipr->p->payload; - if (iprh->start == 0) { - /* The first fragment was received, send ICMP time exceeded. */ - /* First, de-queue the first pbuf from r->p. */ - p = ipr->p; - ipr->p = iprh->next_pbuf; - /* Then, copy the original header into it. */ - SMEMCPY(p->payload, &ipr->iphdr, IP_HLEN); - icmp_time_exceeded(p, ICMP_TE_FRAG); - clen = pbuf_clen(p); - LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); - pbufs_freed = (u16_t)(pbufs_freed + clen); - pbuf_free(p); - } -#endif /* LWIP_ICMP */ - - /* First, free all received pbufs. The individual pbufs need to be released - separately as they have not yet been chained */ - p = ipr->p; - while (p != NULL) { - struct pbuf *pcur; - iprh = (struct ip_reass_helper *)p->payload; - pcur = p; - /* get the next pointer before freeing */ - p = iprh->next_pbuf; - clen = pbuf_clen(pcur); - LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); - pbufs_freed = (u16_t)(pbufs_freed + clen); - pbuf_free(pcur); - } - /* Then, unchain the struct ip_reassdata from the list and free it. */ - ip_reass_dequeue_datagram(ipr, prev); - LWIP_ASSERT("ip_reass_pbufcount >= pbufs_freed", ip_reass_pbufcount >= pbufs_freed); - ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount - pbufs_freed); - - return pbufs_freed; -} - -#if IP_REASS_FREE_OLDEST -/** - * Free the oldest datagram to make room for enqueueing new fragments. - * The datagram 'fraghdr' belongs to is not freed! - * - * @param fraghdr IP header of the current fragment - * @param pbufs_needed number of pbufs needed to enqueue - * (used for freeing other datagrams if not enough space) - * @return the number of pbufs freed - */ -static int -ip_reass_remove_oldest_datagram(struct ip_hdr *fraghdr, int pbufs_needed) -{ - /* @todo Can't we simply remove the last datagram in the - * linked list behind reassdatagrams? - */ - struct ip_reassdata *r, *oldest, *prev, *oldest_prev; - int pbufs_freed = 0, pbufs_freed_current; - int other_datagrams; - - /* Free datagrams until being allowed to enqueue 'pbufs_needed' pbufs, - * but don't free the datagram that 'fraghdr' belongs to! */ - do { - oldest = NULL; - prev = NULL; - oldest_prev = NULL; - other_datagrams = 0; - r = reassdatagrams; - while (r != NULL) { - if (!IP_ADDRESSES_AND_ID_MATCH(&r->iphdr, fraghdr)) { - /* Not the same datagram as fraghdr */ - other_datagrams++; - if (oldest == NULL) { - oldest = r; - oldest_prev = prev; - } else if (r->timer <= oldest->timer) { - /* older than the previous oldest */ - oldest = r; - oldest_prev = prev; - } - } - if (r->next != NULL) { - prev = r; - } - r = r->next; - } - if (oldest != NULL) { - pbufs_freed_current = ip_reass_free_complete_datagram(oldest, oldest_prev); - pbufs_freed += pbufs_freed_current; - } - } while ((pbufs_freed < pbufs_needed) && (other_datagrams > 1)); - return pbufs_freed; -} -#endif /* IP_REASS_FREE_OLDEST */ - -/** - * Enqueues a new fragment into the fragment queue - * @param fraghdr points to the new fragments IP hdr - * @param clen number of pbufs needed to enqueue (used for freeing other datagrams if not enough space) - * @return A pointer to the queue location into which the fragment was enqueued - */ -static struct ip_reassdata * -ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen) -{ - struct ip_reassdata *ipr; -#if ! IP_REASS_FREE_OLDEST - LWIP_UNUSED_ARG(clen); -#endif - - /* No matching previous fragment found, allocate a new reassdata struct */ - ipr = (struct ip_reassdata *)memp_malloc(MEMP_REASSDATA); - if (ipr == NULL) { -#if IP_REASS_FREE_OLDEST - if (ip_reass_remove_oldest_datagram(fraghdr, clen) >= clen) { - ipr = (struct ip_reassdata *)memp_malloc(MEMP_REASSDATA); - } - if (ipr == NULL) -#endif /* IP_REASS_FREE_OLDEST */ - { - IPFRAG_STATS_INC(ip_frag.memerr); - LWIP_DEBUGF(IP_REASS_DEBUG, ("Failed to alloc reassdata struct\n")); - return NULL; - } - } - memset(ipr, 0, sizeof(struct ip_reassdata)); - ipr->timer = IP_REASS_MAXAGE; - - /* enqueue the new structure to the front of the list */ - ipr->next = reassdatagrams; - reassdatagrams = ipr; - /* copy the ip header for later tests and input */ - /* @todo: no ip options supported? */ - SMEMCPY(&(ipr->iphdr), fraghdr, IP_HLEN); - return ipr; -} - -/** - * Dequeues a datagram from the datagram queue. Doesn't deallocate the pbufs. - * @param ipr points to the queue entry to dequeue - */ -static void -ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev) -{ - /* dequeue the reass struct */ - if (reassdatagrams == ipr) { - /* it was the first in the list */ - reassdatagrams = ipr->next; - } else { - /* it wasn't the first, so it must have a valid 'prev' */ - LWIP_ASSERT("sanity check linked list", prev != NULL); - prev->next = ipr->next; - } - - /* now we can free the ip_reassdata struct */ - memp_free(MEMP_REASSDATA, ipr); -} - -/** - * Chain a new pbuf into the pbuf list that composes the datagram. The pbuf list - * will grow over time as new pbufs are rx. - * Also checks that the datagram passes basic continuity checks (if the last - * fragment was received at least once). - * @param ipr points to the reassembly state - * @param new_p points to the pbuf for the current fragment - * @param is_last is 1 if this pbuf has MF==0 (ipr->flags not updated yet) - * @return see IP_REASS_VALIDATE_* defines - */ -static int -ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p, int is_last) -{ - struct ip_reass_helper *iprh, *iprh_tmp, *iprh_prev = NULL; - struct pbuf *q; - u16_t offset, len; - u8_t hlen; - struct ip_hdr *fraghdr; - int valid = 1; - - /* Extract length and fragment offset from current fragment */ - fraghdr = (struct ip_hdr *)new_p->payload; - len = lwip_ntohs(IPH_LEN(fraghdr)); - hlen = IPH_HL_BYTES(fraghdr); - if (hlen > len) { - /* invalid datagram */ - return IP_REASS_VALIDATE_PBUF_DROPPED; - } - len = (u16_t)(len - hlen); - offset = IPH_OFFSET_BYTES(fraghdr); - - /* overwrite the fragment's ip header from the pbuf with our helper struct, - * and setup the embedded helper structure. */ - /* make sure the struct ip_reass_helper fits into the IP header */ - LWIP_ASSERT("sizeof(struct ip_reass_helper) <= IP_HLEN", - sizeof(struct ip_reass_helper) <= IP_HLEN); - iprh = (struct ip_reass_helper *)new_p->payload; - iprh->next_pbuf = NULL; - iprh->start = offset; - iprh->end = (u16_t)(offset + len); - if (iprh->end < offset) { - /* u16_t overflow, cannot handle this */ - return IP_REASS_VALIDATE_PBUF_DROPPED; - } - - /* Iterate through until we either get to the end of the list (append), - * or we find one with a larger offset (insert). */ - for (q = ipr->p; q != NULL;) { - iprh_tmp = (struct ip_reass_helper *)q->payload; - if (iprh->start < iprh_tmp->start) { - /* the new pbuf should be inserted before this */ - iprh->next_pbuf = q; - if (iprh_prev != NULL) { - /* not the fragment with the lowest offset */ -#if IP_REASS_CHECK_OVERLAP - if ((iprh->start < iprh_prev->end) || (iprh->end > iprh_tmp->start)) { - /* fragment overlaps with previous or following, throw away */ - return IP_REASS_VALIDATE_PBUF_DROPPED; - } -#endif /* IP_REASS_CHECK_OVERLAP */ - iprh_prev->next_pbuf = new_p; - if (iprh_prev->end != iprh->start) { - /* There is a fragment missing between the current - * and the previous fragment */ - valid = 0; - } - } else { -#if IP_REASS_CHECK_OVERLAP - if (iprh->end > iprh_tmp->start) { - /* fragment overlaps with following, throw away */ - return IP_REASS_VALIDATE_PBUF_DROPPED; - } -#endif /* IP_REASS_CHECK_OVERLAP */ - /* fragment with the lowest offset */ - ipr->p = new_p; - } - break; - } else if (iprh->start == iprh_tmp->start) { - /* received the same datagram twice: no need to keep the datagram */ - return IP_REASS_VALIDATE_PBUF_DROPPED; -#if IP_REASS_CHECK_OVERLAP - } else if (iprh->start < iprh_tmp->end) { - /* overlap: no need to keep the new datagram */ - return IP_REASS_VALIDATE_PBUF_DROPPED; -#endif /* IP_REASS_CHECK_OVERLAP */ - } else { - /* Check if the fragments received so far have no holes. */ - if (iprh_prev != NULL) { - if (iprh_prev->end != iprh_tmp->start) { - /* There is a fragment missing between the current - * and the previous fragment */ - valid = 0; - } - } - } - q = iprh_tmp->next_pbuf; - iprh_prev = iprh_tmp; - } - - /* If q is NULL, then we made it to the end of the list. Determine what to do now */ - if (q == NULL) { - if (iprh_prev != NULL) { - /* this is (for now), the fragment with the highest offset: - * chain it to the last fragment */ -#if IP_REASS_CHECK_OVERLAP - LWIP_ASSERT("check fragments don't overlap", iprh_prev->end <= iprh->start); -#endif /* IP_REASS_CHECK_OVERLAP */ - iprh_prev->next_pbuf = new_p; - if (iprh_prev->end != iprh->start) { - valid = 0; - } - } else { -#if IP_REASS_CHECK_OVERLAP - LWIP_ASSERT("no previous fragment, this must be the first fragment!", - ipr->p == NULL); -#endif /* IP_REASS_CHECK_OVERLAP */ - /* this is the first fragment we ever received for this ip datagram */ - ipr->p = new_p; - } - } - - /* At this point, the validation part begins: */ - /* If we already received the last fragment */ - if (is_last || ((ipr->flags & IP_REASS_FLAG_LASTFRAG) != 0)) { - /* and had no holes so far */ - if (valid) { - /* then check if the rest of the fragments is here */ - /* Check if the queue starts with the first datagram */ - if ((ipr->p == NULL) || (((struct ip_reass_helper *)ipr->p->payload)->start != 0)) { - valid = 0; - } else { - /* and check that there are no holes after this datagram */ - iprh_prev = iprh; - q = iprh->next_pbuf; - while (q != NULL) { - iprh = (struct ip_reass_helper *)q->payload; - if (iprh_prev->end != iprh->start) { - valid = 0; - break; - } - iprh_prev = iprh; - q = iprh->next_pbuf; - } - /* if still valid, all fragments are received - * (because to the MF==0 already arrived */ - if (valid) { - LWIP_ASSERT("sanity check", ipr->p != NULL); - LWIP_ASSERT("sanity check", - ((struct ip_reass_helper *)ipr->p->payload) != iprh); - LWIP_ASSERT("validate_datagram:next_pbuf!=NULL", - iprh->next_pbuf == NULL); - } - } - } - /* If valid is 0 here, there are some fragments missing in the middle - * (since MF == 0 has already arrived). Such datagrams simply time out if - * no more fragments are received... */ - return valid ? IP_REASS_VALIDATE_TELEGRAM_FINISHED : IP_REASS_VALIDATE_PBUF_QUEUED; - } - /* If we come here, not all fragments were received, yet! */ - return IP_REASS_VALIDATE_PBUF_QUEUED; /* not yet valid! */ -} - -/** - * Reassembles incoming IP fragments into an IP datagram. - * - * @param p points to a pbuf chain of the fragment - * @return NULL if reassembly is incomplete, ? otherwise - */ -struct pbuf * -ip4_reass(struct pbuf *p) -{ - struct pbuf *r; - struct ip_hdr *fraghdr; - struct ip_reassdata *ipr; - struct ip_reass_helper *iprh; - u16_t offset, len, clen; - u8_t hlen; - int valid; - int is_last; - - IPFRAG_STATS_INC(ip_frag.recv); - MIB2_STATS_INC(mib2.ipreasmreqds); - - fraghdr = (struct ip_hdr *)p->payload; - - if (IPH_HL_BYTES(fraghdr) != IP_HLEN) { - LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: IP options currently not supported!\n")); - IPFRAG_STATS_INC(ip_frag.err); - goto nullreturn; - } - - offset = IPH_OFFSET_BYTES(fraghdr); - len = lwip_ntohs(IPH_LEN(fraghdr)); - hlen = IPH_HL_BYTES(fraghdr); - if (hlen > len) { - /* invalid datagram */ - goto nullreturn; - } - len = (u16_t)(len - hlen); - - /* Check if we are allowed to enqueue more datagrams. */ - clen = pbuf_clen(p); - if ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) { -#if IP_REASS_FREE_OLDEST - if (!ip_reass_remove_oldest_datagram(fraghdr, clen) || - ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS)) -#endif /* IP_REASS_FREE_OLDEST */ - { - /* No datagram could be freed and still too many pbufs enqueued */ - LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: Overflow condition: pbufct=%d, clen=%d, MAX=%d\n", - ip_reass_pbufcount, clen, IP_REASS_MAX_PBUFS)); - IPFRAG_STATS_INC(ip_frag.memerr); - /* @todo: send ICMP time exceeded here? */ - /* drop this pbuf */ - goto nullreturn; - } - } - - /* Look for the datagram the fragment belongs to in the current datagram queue, - * remembering the previous in the queue for later dequeueing. */ - for (ipr = reassdatagrams; ipr != NULL; ipr = ipr->next) { - /* Check if the incoming fragment matches the one currently present - in the reassembly buffer. If so, we proceed with copying the - fragment into the buffer. */ - if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) { - LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: matching previous fragment ID=%"X16_F"\n", - lwip_ntohs(IPH_ID(fraghdr)))); - IPFRAG_STATS_INC(ip_frag.cachehit); - break; - } - } - - if (ipr == NULL) { - /* Enqueue a new datagram into the datagram queue */ - ipr = ip_reass_enqueue_new_datagram(fraghdr, clen); - /* Bail if unable to enqueue */ - if (ipr == NULL) { - goto nullreturn; - } - } else { - if (((lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) && - ((lwip_ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) { - /* ipr->iphdr is not the header from the first fragment, but fraghdr is - * -> copy fraghdr into ipr->iphdr since we want to have the header - * of the first fragment (for ICMP time exceeded and later, for copying - * all options, if supported)*/ - SMEMCPY(&ipr->iphdr, fraghdr, IP_HLEN); - } - } - - /* At this point, we have either created a new entry or pointing - * to an existing one */ - - /* check for 'no more fragments', and update queue entry*/ - is_last = (IPH_OFFSET(fraghdr) & PP_NTOHS(IP_MF)) == 0; - if (is_last) { - u16_t datagram_len = (u16_t)(offset + len); - if ((datagram_len < offset) || (datagram_len > (0xFFFF - IP_HLEN))) { - /* u16_t overflow, cannot handle this */ - goto nullreturn_ipr; - } - } - /* find the right place to insert this pbuf */ - /* @todo: trim pbufs if fragments are overlapping */ - valid = ip_reass_chain_frag_into_datagram_and_validate(ipr, p, is_last); - if (valid == IP_REASS_VALIDATE_PBUF_DROPPED) { - goto nullreturn_ipr; - } - /* if we come here, the pbuf has been enqueued */ - - /* Track the current number of pbufs current 'in-flight', in order to limit - the number of fragments that may be enqueued at any one time - (overflow checked by testing against IP_REASS_MAX_PBUFS) */ - ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount + clen); - if (is_last) { - u16_t datagram_len = (u16_t)(offset + len); - ipr->datagram_len = datagram_len; - ipr->flags |= IP_REASS_FLAG_LASTFRAG; - LWIP_DEBUGF(IP_REASS_DEBUG, - ("ip4_reass: last fragment seen, total len %"S16_F"\n", - ipr->datagram_len)); - } - - if (valid == IP_REASS_VALIDATE_TELEGRAM_FINISHED) { - struct ip_reassdata *ipr_prev; - /* the totally last fragment (flag more fragments = 0) was received at least - * once AND all fragments are received */ - u16_t datagram_len = (u16_t)(ipr->datagram_len + IP_HLEN); - - /* save the second pbuf before copying the header over the pointer */ - r = ((struct ip_reass_helper *)ipr->p->payload)->next_pbuf; - - /* copy the original ip header back to the first pbuf */ - fraghdr = (struct ip_hdr *)(ipr->p->payload); - SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN); - IPH_LEN_SET(fraghdr, lwip_htons(datagram_len)); - IPH_OFFSET_SET(fraghdr, 0); - IPH_CHKSUM_SET(fraghdr, 0); - /* @todo: do we need to set/calculate the correct checksum? */ -#if CHECKSUM_GEN_IP - IF__NETIF_CHECKSUM_ENABLED(ip_current_input_netif(), NETIF_CHECKSUM_GEN_IP) { - IPH_CHKSUM_SET(fraghdr, inet_chksum(fraghdr, IP_HLEN)); - } -#endif /* CHECKSUM_GEN_IP */ - - p = ipr->p; - - /* chain together the pbufs contained within the reass_data list. */ - while (r != NULL) { - iprh = (struct ip_reass_helper *)r->payload; - - /* hide the ip header for every succeeding fragment */ - pbuf_remove_header(r, IP_HLEN); - pbuf_cat(p, r); - r = iprh->next_pbuf; - } - - /* find the previous entry in the linked list */ - if (ipr == reassdatagrams) { - ipr_prev = NULL; - } else { - for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) { - if (ipr_prev->next == ipr) { - break; - } - } - } - - /* release the sources allocate for the fragment queue entry */ - ip_reass_dequeue_datagram(ipr, ipr_prev); - - /* and adjust the number of pbufs currently queued for reassembly. */ - clen = pbuf_clen(p); - LWIP_ASSERT("ip_reass_pbufcount >= clen", ip_reass_pbufcount >= clen); - ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount - clen); - - MIB2_STATS_INC(mib2.ipreasmoks); - - /* Return the pbuf chain */ - return p; - } - /* the datagram is not (yet?) reassembled completely */ - LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_pbufcount: %d out\n", ip_reass_pbufcount)); - return NULL; - -nullreturn_ipr: - LWIP_ASSERT("ipr != NULL", ipr != NULL); - if (ipr->p == NULL) { - /* dropped pbuf after creating a new datagram entry: remove the entry, too */ - LWIP_ASSERT("not firstalthough just enqueued", ipr == reassdatagrams); - ip_reass_dequeue_datagram(ipr, NULL); - } - -nullreturn: - LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: nullreturn\n")); - IPFRAG_STATS_INC(ip_frag.drop); - pbuf_free(p); - return NULL; -} -#endif /* IP_REASSEMBLY */ - -#if IP_FRAG -#if !LWIP_NETIF_TX_SINGLE_PBUF -/** Allocate a new struct pbuf_custom_ref */ -static struct pbuf_custom_ref * -ip_frag_alloc_pbuf_custom_ref(void) -{ - return (struct pbuf_custom_ref *)memp_malloc(MEMP_FRAG_PBUF); -} - -/** Free a struct pbuf_custom_ref */ -static void -ip_frag_free_pbuf_custom_ref(struct pbuf_custom_ref *p) -{ - LWIP_ASSERT("p != NULL", p != NULL); - memp_free(MEMP_FRAG_PBUF, p); -} - -/** Free-callback function to free a 'struct pbuf_custom_ref', called by - * pbuf_free. */ -static void -ipfrag_free_pbuf_custom(struct pbuf *p) -{ - struct pbuf_custom_ref *pcr = (struct pbuf_custom_ref *)p; - LWIP_ASSERT("pcr != NULL", pcr != NULL); - LWIP_ASSERT("pcr == p", (void *)pcr == (void *)p); - if (pcr->original != NULL) { - pbuf_free(pcr->original); - } - ip_frag_free_pbuf_custom_ref(pcr); -} -#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ - -/** - * Fragment an IP datagram if too large for the netif. - * - * Chop the datagram in MTU sized chunks and send them in order - * by pointing PBUF_REFs into p. - * - * @param p ip packet to send - * @param netif the netif on which to send - * @param dest destination ip address to which to send - * - * @return ERR_OK if sent successfully, err_t otherwise - */ -err_t -ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest) -{ - struct pbuf *rambuf; -#if !LWIP_NETIF_TX_SINGLE_PBUF - struct pbuf *newpbuf; - u16_t newpbuflen = 0; - u16_t left_to_copy; -#endif - struct ip_hdr *original_iphdr; - struct ip_hdr *iphdr; - const u16_t nfb = (u16_t)((netif->mtu - IP_HLEN) / 8); - u16_t left, fragsize; - u16_t ofo; - int last; - u16_t poff = IP_HLEN; - u16_t tmp; - int mf_set; - - original_iphdr = (struct ip_hdr *)p->payload; - iphdr = original_iphdr; - if (IPH_HL_BYTES(iphdr) != IP_HLEN) { - /* ip4_frag() does not support IP options */ - return ERR_VAL; - } - LWIP_ERROR("ip4_frag(): pbuf too short", p->len >= IP_HLEN, return ERR_VAL); - - /* Save original offset */ - tmp = lwip_ntohs(IPH_OFFSET(iphdr)); - ofo = tmp & IP_OFFMASK; - /* already fragmented? if so, the last fragment we create must have MF, too */ - mf_set = tmp & IP_MF; - - left = (u16_t)(p->tot_len - IP_HLEN); - - while (left) { - /* Fill this fragment */ - fragsize = LWIP_MIN(left, (u16_t)(nfb * 8)); - -#if LWIP_NETIF_TX_SINGLE_PBUF - rambuf = pbuf_alloc(PBUF_IP, fragsize, PBUF_RAM); - if (rambuf == NULL) { - goto memerr; - } - LWIP_ASSERT("this needs a pbuf in one piece!", - (rambuf->len == rambuf->tot_len) && (rambuf->next == NULL)); - poff += pbuf_copy_partial(p, rambuf->payload, fragsize, poff); - /* make room for the IP header */ - if (pbuf_add_header(rambuf, IP_HLEN)) { - pbuf_free(rambuf); - goto memerr; - } - /* fill in the IP header */ - SMEMCPY(rambuf->payload, original_iphdr, IP_HLEN); - iphdr = (struct ip_hdr *)rambuf->payload; -#else /* LWIP_NETIF_TX_SINGLE_PBUF */ - /* When not using a static buffer, create a chain of pbufs. - * The first will be a PBUF_RAM holding the link and IP header. - * The rest will be PBUF_REFs mirroring the pbuf chain to be fragged, - * but limited to the size of an mtu. - */ - rambuf = pbuf_alloc(PBUF_LINK, IP_HLEN, PBUF_RAM); - if (rambuf == NULL) { - goto memerr; - } - LWIP_ASSERT("this needs a pbuf in one piece!", - (rambuf->len >= (IP_HLEN))); - SMEMCPY(rambuf->payload, original_iphdr, IP_HLEN); - iphdr = (struct ip_hdr *)rambuf->payload; - - left_to_copy = fragsize; - while (left_to_copy) { - struct pbuf_custom_ref *pcr; - u16_t plen = (u16_t)(p->len - poff); - LWIP_ASSERT("p->len >= poff", p->len >= poff); - newpbuflen = LWIP_MIN(left_to_copy, plen); - /* Is this pbuf already empty? */ - if (!newpbuflen) { - poff = 0; - p = p->next; - continue; - } - pcr = ip_frag_alloc_pbuf_custom_ref(); - if (pcr == NULL) { - pbuf_free(rambuf); - goto memerr; - } - /* Mirror this pbuf, although we might not need all of it. */ - newpbuf = pbuf_alloced_custom(PBUF_RAW, newpbuflen, PBUF_REF, &pcr->pc, - (u8_t *)p->payload + poff, newpbuflen); - if (newpbuf == NULL) { - ip_frag_free_pbuf_custom_ref(pcr); - pbuf_free(rambuf); - goto memerr; - } - pbuf_ref(p); - pcr->original = p; - pcr->pc.custom_free_function = ipfrag_free_pbuf_custom; - - /* Add it to end of rambuf's chain, but using pbuf_cat, not pbuf_chain - * so that it is removed when pbuf_dechain is later called on rambuf. - */ - pbuf_cat(rambuf, newpbuf); - left_to_copy = (u16_t)(left_to_copy - newpbuflen); - if (left_to_copy) { - poff = 0; - p = p->next; - } - } - poff = (u16_t)(poff + newpbuflen); -#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ - - /* Correct header */ - last = (left <= netif->mtu - IP_HLEN); - - /* Set new offset and MF flag */ - tmp = (IP_OFFMASK & (ofo)); - if (!last || mf_set) { - /* the last fragment has MF set if the input frame had it */ - tmp = tmp | IP_MF; - } - IPH_OFFSET_SET(iphdr, lwip_htons(tmp)); - IPH_LEN_SET(iphdr, lwip_htons((u16_t)(fragsize + IP_HLEN))); - IPH_CHKSUM_SET(iphdr, 0); -#if CHECKSUM_GEN_IP - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) { - IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN)); - } -#endif /* CHECKSUM_GEN_IP */ - - /* No need for separate header pbuf - we allowed room for it in rambuf - * when allocated. - */ - netif->output(netif, rambuf, dest); - IPFRAG_STATS_INC(ip_frag.xmit); - - /* Unfortunately we can't reuse rambuf - the hardware may still be - * using the buffer. Instead we free it (and the ensuing chain) and - * recreate it next time round the loop. If we're lucky the hardware - * will have already sent the packet, the free will really free, and - * there will be zero memory penalty. - */ - - pbuf_free(rambuf); - left = (u16_t)(left - fragsize); - ofo = (u16_t)(ofo + nfb); - } - MIB2_STATS_INC(mib2.ipfragoks); - return ERR_OK; -memerr: - MIB2_STATS_INC(mib2.ipfragfails); - return ERR_MEM; -} -#endif /* IP_FRAG */ - -#endif /* LWIP_IPV4 */ +/** + * @file + * This is the IPv4 packet segmentation and reassembly implementation. + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Jani Monoses + * Simon Goldschmidt + * original reassembly code by Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV4 + +#include "lwip/ip4_frag.h" +#include "lwip/def.h" +#include "lwip/inet_chksum.h" +#include "lwip/netif.h" +#include "lwip/stats.h" +#include "lwip/icmp.h" + +#include + +#if IP_REASSEMBLY +/** + * The IP reassembly code currently has the following limitations: + * - IP header options are not supported + * - fragments must not overlap (e.g. due to different routes), + * currently, overlapping or duplicate fragments are thrown away + * if IP_REASS_CHECK_OVERLAP=1 (the default)! + * + * @todo: work with IP header options + */ + +/** Setting this to 0, you can turn off checking the fragments for overlapping + * regions. The code gets a little smaller. Only use this if you know that + * overlapping won't occur on your network! */ +#ifndef IP_REASS_CHECK_OVERLAP +#define IP_REASS_CHECK_OVERLAP 1 +#endif /* IP_REASS_CHECK_OVERLAP */ + +/** Set to 0 to prevent freeing the oldest datagram when the reassembly buffer is + * full (IP_REASS_MAX_PBUFS pbufs are enqueued). The code gets a little smaller. + * Datagrams will be freed by timeout only. Especially useful when MEMP_NUM_REASSDATA + * is set to 1, so one datagram can be reassembled at a time, only. */ +#ifndef IP_REASS_FREE_OLDEST +#define IP_REASS_FREE_OLDEST 1 +#endif /* IP_REASS_FREE_OLDEST */ + +#define IP_REASS_FLAG_LASTFRAG 0x01 + +#define IP_REASS_VALIDATE_TELEGRAM_FINISHED 1 +#define IP_REASS_VALIDATE_PBUF_QUEUED 0 +#define IP_REASS_VALIDATE_PBUF_DROPPED -1 + +/** This is a helper struct which holds the starting + * offset and the ending offset of this fragment to + * easily chain the fragments. + * It has the same packing requirements as the IP header, since it replaces + * the IP header in memory in incoming fragments (after copying it) to keep + * track of the various fragments. (-> If the IP header doesn't need packing, + * this struct doesn't need packing, too.) + */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip_reass_helper { + PACK_STRUCT_FIELD(struct pbuf *next_pbuf); + PACK_STRUCT_FIELD(u16_t start); + PACK_STRUCT_FIELD(u16_t end); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#define IP_ADDRESSES_AND_ID_MATCH(iphdrA, iphdrB) \ + (ip4_addr_cmp(&(iphdrA)->src, &(iphdrB)->src) && \ + ip4_addr_cmp(&(iphdrA)->dest, &(iphdrB)->dest) && \ + IPH_ID(iphdrA) == IPH_ID(iphdrB)) ? 1 : 0 + +/* global variables */ +static struct ip_reassdata *reassdatagrams; +static u16_t ip_reass_pbufcount; + +/* function prototypes */ +static void ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev); +static int ip_reass_free_complete_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev); + +/** + * Reassembly timer base function + * for both NO_SYS == 0 and 1 (!). + * + * Should be called every 1000 msec (defined by IP_TMR_INTERVAL). + */ +void +ip_reass_tmr(void) +{ + struct ip_reassdata *r, *prev = NULL; + + r = reassdatagrams; + while (r != NULL) { + /* Decrement the timer. Once it reaches 0, + * clean up the incomplete fragment assembly */ + if (r->timer > 0) { + r->timer--; + LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer dec %"U16_F"\n", (u16_t)r->timer)); + prev = r; + r = r->next; + } else { + /* reassembly timed out */ + struct ip_reassdata *tmp; + LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_tmr: timer timed out\n")); + tmp = r; + /* get the next pointer before freeing */ + r = r->next; + /* free the helper struct and all enqueued pbufs */ + ip_reass_free_complete_datagram(tmp, prev); + } + } +} + +/** + * Free a datagram (struct ip_reassdata) and all its pbufs. + * Updates the total count of enqueued pbufs (ip_reass_pbufcount), + * SNMP counters and sends an ICMP time exceeded packet. + * + * @param ipr datagram to free + * @param prev the previous datagram in the linked list + * @return the number of pbufs freed + */ +static int +ip_reass_free_complete_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev) +{ + u16_t pbufs_freed = 0; + u16_t clen; + struct pbuf *p; + struct ip_reass_helper *iprh; + + LWIP_ASSERT("prev != ipr", prev != ipr); + if (prev != NULL) { + LWIP_ASSERT("prev->next == ipr", prev->next == ipr); + } + + MIB2_STATS_INC(mib2.ipreasmfails); +#if LWIP_ICMP + iprh = (struct ip_reass_helper *)ipr->p->payload; + if (iprh->start == 0) { + /* The first fragment was received, send ICMP time exceeded. */ + /* First, de-queue the first pbuf from r->p. */ + p = ipr->p; + ipr->p = iprh->next_pbuf; + /* Then, copy the original header into it. */ + SMEMCPY(p->payload, &ipr->iphdr, IP_HLEN); + icmp_time_exceeded(p, ICMP_TE_FRAG); + clen = pbuf_clen(p); + LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); + pbufs_freed = (u16_t)(pbufs_freed + clen); + pbuf_free(p); + } +#endif /* LWIP_ICMP */ + + /* First, free all received pbufs. The individual pbufs need to be released + separately as they have not yet been chained */ + p = ipr->p; + while (p != NULL) { + struct pbuf *pcur; + iprh = (struct ip_reass_helper *)p->payload; + pcur = p; + /* get the next pointer before freeing */ + p = iprh->next_pbuf; + clen = pbuf_clen(pcur); + LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); + pbufs_freed = (u16_t)(pbufs_freed + clen); + pbuf_free(pcur); + } + /* Then, unchain the struct ip_reassdata from the list and free it. */ + ip_reass_dequeue_datagram(ipr, prev); + LWIP_ASSERT("ip_reass_pbufcount >= pbufs_freed", ip_reass_pbufcount >= pbufs_freed); + ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount - pbufs_freed); + + return pbufs_freed; +} + +#if IP_REASS_FREE_OLDEST +/** + * Free the oldest datagram to make room for enqueueing new fragments. + * The datagram 'fraghdr' belongs to is not freed! + * + * @param fraghdr IP header of the current fragment + * @param pbufs_needed number of pbufs needed to enqueue + * (used for freeing other datagrams if not enough space) + * @return the number of pbufs freed + */ +static int +ip_reass_remove_oldest_datagram(struct ip_hdr *fraghdr, int pbufs_needed) +{ + /* @todo Can't we simply remove the last datagram in the + * linked list behind reassdatagrams? + */ + struct ip_reassdata *r, *oldest, *prev, *oldest_prev; + int pbufs_freed = 0, pbufs_freed_current; + int other_datagrams; + + /* Free datagrams until being allowed to enqueue 'pbufs_needed' pbufs, + * but don't free the datagram that 'fraghdr' belongs to! */ + do { + oldest = NULL; + prev = NULL; + oldest_prev = NULL; + other_datagrams = 0; + r = reassdatagrams; + while (r != NULL) { + if (!IP_ADDRESSES_AND_ID_MATCH(&r->iphdr, fraghdr)) { + /* Not the same datagram as fraghdr */ + other_datagrams++; + if (oldest == NULL) { + oldest = r; + oldest_prev = prev; + } else if (r->timer <= oldest->timer) { + /* older than the previous oldest */ + oldest = r; + oldest_prev = prev; + } + } + if (r->next != NULL) { + prev = r; + } + r = r->next; + } + if (oldest != NULL) { + pbufs_freed_current = ip_reass_free_complete_datagram(oldest, oldest_prev); + pbufs_freed += pbufs_freed_current; + } + } while ((pbufs_freed < pbufs_needed) && (other_datagrams > 1)); + return pbufs_freed; +} +#endif /* IP_REASS_FREE_OLDEST */ + +/** + * Enqueues a new fragment into the fragment queue + * @param fraghdr points to the new fragments IP hdr + * @param clen number of pbufs needed to enqueue (used for freeing other datagrams if not enough space) + * @return A pointer to the queue location into which the fragment was enqueued + */ +static struct ip_reassdata * +ip_reass_enqueue_new_datagram(struct ip_hdr *fraghdr, int clen) +{ + struct ip_reassdata *ipr; +#if ! IP_REASS_FREE_OLDEST + LWIP_UNUSED_ARG(clen); +#endif + + /* No matching previous fragment found, allocate a new reassdata struct */ + ipr = (struct ip_reassdata *)memp_malloc(MEMP_REASSDATA); + if (ipr == NULL) { +#if IP_REASS_FREE_OLDEST + if (ip_reass_remove_oldest_datagram(fraghdr, clen) >= clen) { + ipr = (struct ip_reassdata *)memp_malloc(MEMP_REASSDATA); + } + if (ipr == NULL) +#endif /* IP_REASS_FREE_OLDEST */ + { + IPFRAG_STATS_INC(ip_frag.memerr); + LWIP_DEBUGF(IP_REASS_DEBUG, ("Failed to alloc reassdata struct\n")); + return NULL; + } + } + memset(ipr, 0, sizeof(struct ip_reassdata)); + ipr->timer = IP_REASS_MAXAGE; + + /* enqueue the new structure to the front of the list */ + ipr->next = reassdatagrams; + reassdatagrams = ipr; + /* copy the ip header for later tests and input */ + /* @todo: no ip options supported? */ + SMEMCPY(&(ipr->iphdr), fraghdr, IP_HLEN); + return ipr; +} + +/** + * Dequeues a datagram from the datagram queue. Doesn't deallocate the pbufs. + * @param ipr points to the queue entry to dequeue + */ +static void +ip_reass_dequeue_datagram(struct ip_reassdata *ipr, struct ip_reassdata *prev) +{ + /* dequeue the reass struct */ + if (reassdatagrams == ipr) { + /* it was the first in the list */ + reassdatagrams = ipr->next; + } else { + /* it wasn't the first, so it must have a valid 'prev' */ + LWIP_ASSERT("sanity check linked list", prev != NULL); + prev->next = ipr->next; + } + + /* now we can free the ip_reassdata struct */ + memp_free(MEMP_REASSDATA, ipr); +} + +/** + * Chain a new pbuf into the pbuf list that composes the datagram. The pbuf list + * will grow over time as new pbufs are rx. + * Also checks that the datagram passes basic continuity checks (if the last + * fragment was received at least once). + * @param ipr points to the reassembly state + * @param new_p points to the pbuf for the current fragment + * @param is_last is 1 if this pbuf has MF==0 (ipr->flags not updated yet) + * @return see IP_REASS_VALIDATE_* defines + */ +static int +ip_reass_chain_frag_into_datagram_and_validate(struct ip_reassdata *ipr, struct pbuf *new_p, int is_last) +{ + struct ip_reass_helper *iprh, *iprh_tmp, *iprh_prev = NULL; + struct pbuf *q; + u16_t offset, len; + u8_t hlen; + struct ip_hdr *fraghdr; + int valid = 1; + + /* Extract length and fragment offset from current fragment */ + fraghdr = (struct ip_hdr *)new_p->payload; + len = lwip_ntohs(IPH_LEN(fraghdr)); + hlen = IPH_HL_BYTES(fraghdr); + if (hlen > len) { + /* invalid datagram */ + return IP_REASS_VALIDATE_PBUF_DROPPED; + } + len = (u16_t)(len - hlen); + offset = IPH_OFFSET_BYTES(fraghdr); + + /* overwrite the fragment's ip header from the pbuf with our helper struct, + * and setup the embedded helper structure. */ + /* make sure the struct ip_reass_helper fits into the IP header */ + LWIP_ASSERT("sizeof(struct ip_reass_helper) <= IP_HLEN", + sizeof(struct ip_reass_helper) <= IP_HLEN); + iprh = (struct ip_reass_helper *)new_p->payload; + iprh->next_pbuf = NULL; + iprh->start = offset; + iprh->end = (u16_t)(offset + len); + if (iprh->end < offset) { + /* u16_t overflow, cannot handle this */ + return IP_REASS_VALIDATE_PBUF_DROPPED; + } + + /* Iterate through until we either get to the end of the list (append), + * or we find one with a larger offset (insert). */ + for (q = ipr->p; q != NULL;) { + iprh_tmp = (struct ip_reass_helper *)q->payload; + if (iprh->start < iprh_tmp->start) { + /* the new pbuf should be inserted before this */ + iprh->next_pbuf = q; + if (iprh_prev != NULL) { + /* not the fragment with the lowest offset */ +#if IP_REASS_CHECK_OVERLAP + if ((iprh->start < iprh_prev->end) || (iprh->end > iprh_tmp->start)) { + /* fragment overlaps with previous or following, throw away */ + return IP_REASS_VALIDATE_PBUF_DROPPED; + } +#endif /* IP_REASS_CHECK_OVERLAP */ + iprh_prev->next_pbuf = new_p; + if (iprh_prev->end != iprh->start) { + /* There is a fragment missing between the current + * and the previous fragment */ + valid = 0; + } + } else { +#if IP_REASS_CHECK_OVERLAP + if (iprh->end > iprh_tmp->start) { + /* fragment overlaps with following, throw away */ + return IP_REASS_VALIDATE_PBUF_DROPPED; + } +#endif /* IP_REASS_CHECK_OVERLAP */ + /* fragment with the lowest offset */ + ipr->p = new_p; + } + break; + } else if (iprh->start == iprh_tmp->start) { + /* received the same datagram twice: no need to keep the datagram */ + return IP_REASS_VALIDATE_PBUF_DROPPED; +#if IP_REASS_CHECK_OVERLAP + } else if (iprh->start < iprh_tmp->end) { + /* overlap: no need to keep the new datagram */ + return IP_REASS_VALIDATE_PBUF_DROPPED; +#endif /* IP_REASS_CHECK_OVERLAP */ + } else { + /* Check if the fragments received so far have no holes. */ + if (iprh_prev != NULL) { + if (iprh_prev->end != iprh_tmp->start) { + /* There is a fragment missing between the current + * and the previous fragment */ + valid = 0; + } + } + } + q = iprh_tmp->next_pbuf; + iprh_prev = iprh_tmp; + } + + /* If q is NULL, then we made it to the end of the list. Determine what to do now */ + if (q == NULL) { + if (iprh_prev != NULL) { + /* this is (for now), the fragment with the highest offset: + * chain it to the last fragment */ +#if IP_REASS_CHECK_OVERLAP + LWIP_ASSERT("check fragments don't overlap", iprh_prev->end <= iprh->start); +#endif /* IP_REASS_CHECK_OVERLAP */ + iprh_prev->next_pbuf = new_p; + if (iprh_prev->end != iprh->start) { + valid = 0; + } + } else { +#if IP_REASS_CHECK_OVERLAP + LWIP_ASSERT("no previous fragment, this must be the first fragment!", + ipr->p == NULL); +#endif /* IP_REASS_CHECK_OVERLAP */ + /* this is the first fragment we ever received for this ip datagram */ + ipr->p = new_p; + } + } + + /* At this point, the validation part begins: */ + /* If we already received the last fragment */ + if (is_last || ((ipr->flags & IP_REASS_FLAG_LASTFRAG) != 0)) { + /* and had no holes so far */ + if (valid) { + /* then check if the rest of the fragments is here */ + /* Check if the queue starts with the first datagram */ + if ((ipr->p == NULL) || (((struct ip_reass_helper *)ipr->p->payload)->start != 0)) { + valid = 0; + } else { + /* and check that there are no holes after this datagram */ + iprh_prev = iprh; + q = iprh->next_pbuf; + while (q != NULL) { + iprh = (struct ip_reass_helper *)q->payload; + if (iprh_prev->end != iprh->start) { + valid = 0; + break; + } + iprh_prev = iprh; + q = iprh->next_pbuf; + } + /* if still valid, all fragments are received + * (because to the MF==0 already arrived */ + if (valid) { + LWIP_ASSERT("sanity check", ipr->p != NULL); + LWIP_ASSERT("sanity check", + ((struct ip_reass_helper *)ipr->p->payload) != iprh); + LWIP_ASSERT("validate_datagram:next_pbuf!=NULL", + iprh->next_pbuf == NULL); + } + } + } + /* If valid is 0 here, there are some fragments missing in the middle + * (since MF == 0 has already arrived). Such datagrams simply time out if + * no more fragments are received... */ + return valid ? IP_REASS_VALIDATE_TELEGRAM_FINISHED : IP_REASS_VALIDATE_PBUF_QUEUED; + } + /* If we come here, not all fragments were received, yet! */ + return IP_REASS_VALIDATE_PBUF_QUEUED; /* not yet valid! */ +} + +/** + * Reassembles incoming IP fragments into an IP datagram. + * + * @param p points to a pbuf chain of the fragment + * @return NULL if reassembly is incomplete, ? otherwise + */ +struct pbuf * +ip4_reass(struct pbuf *p) +{ + struct pbuf *r; + struct ip_hdr *fraghdr; + struct ip_reassdata *ipr; + struct ip_reass_helper *iprh; + u16_t offset, len, clen; + u8_t hlen; + int valid; + int is_last; + + IPFRAG_STATS_INC(ip_frag.recv); + MIB2_STATS_INC(mib2.ipreasmreqds); + + fraghdr = (struct ip_hdr *)p->payload; + + if (IPH_HL_BYTES(fraghdr) != IP_HLEN) { + LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: IP options currently not supported!\n")); + IPFRAG_STATS_INC(ip_frag.err); + goto nullreturn; + } + + offset = IPH_OFFSET_BYTES(fraghdr); + len = lwip_ntohs(IPH_LEN(fraghdr)); + hlen = IPH_HL_BYTES(fraghdr); + if (hlen > len) { + /* invalid datagram */ + goto nullreturn; + } + len = (u16_t)(len - hlen); + + /* Check if we are allowed to enqueue more datagrams. */ + clen = pbuf_clen(p); + if ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) { +#if IP_REASS_FREE_OLDEST + if (!ip_reass_remove_oldest_datagram(fraghdr, clen) || + ((ip_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS)) +#endif /* IP_REASS_FREE_OLDEST */ + { + /* No datagram could be freed and still too many pbufs enqueued */ + LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: Overflow condition: pbufct=%d, clen=%d, MAX=%d\n", + ip_reass_pbufcount, clen, IP_REASS_MAX_PBUFS)); + IPFRAG_STATS_INC(ip_frag.memerr); + /* @todo: send ICMP time exceeded here? */ + /* drop this pbuf */ + goto nullreturn; + } + } + + /* Look for the datagram the fragment belongs to in the current datagram queue, + * remembering the previous in the queue for later dequeueing. */ + for (ipr = reassdatagrams; ipr != NULL; ipr = ipr->next) { + /* Check if the incoming fragment matches the one currently present + in the reassembly buffer. If so, we proceed with copying the + fragment into the buffer. */ + if (IP_ADDRESSES_AND_ID_MATCH(&ipr->iphdr, fraghdr)) { + LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: matching previous fragment ID=%"X16_F"\n", + lwip_ntohs(IPH_ID(fraghdr)))); + IPFRAG_STATS_INC(ip_frag.cachehit); + break; + } + } + + if (ipr == NULL) { + /* Enqueue a new datagram into the datagram queue */ + ipr = ip_reass_enqueue_new_datagram(fraghdr, clen); + /* Bail if unable to enqueue */ + if (ipr == NULL) { + goto nullreturn; + } + } else { + if (((lwip_ntohs(IPH_OFFSET(fraghdr)) & IP_OFFMASK) == 0) && + ((lwip_ntohs(IPH_OFFSET(&ipr->iphdr)) & IP_OFFMASK) != 0)) { + /* ipr->iphdr is not the header from the first fragment, but fraghdr is + * -> copy fraghdr into ipr->iphdr since we want to have the header + * of the first fragment (for ICMP time exceeded and later, for copying + * all options, if supported)*/ + SMEMCPY(&ipr->iphdr, fraghdr, IP_HLEN); + } + } + + /* At this point, we have either created a new entry or pointing + * to an existing one */ + + /* check for 'no more fragments', and update queue entry*/ + is_last = (IPH_OFFSET(fraghdr) & PP_NTOHS(IP_MF)) == 0; + if (is_last) { + u16_t datagram_len = (u16_t)(offset + len); + if ((datagram_len < offset) || (datagram_len > (0xFFFF - IP_HLEN))) { + /* u16_t overflow, cannot handle this */ + goto nullreturn_ipr; + } + } + /* find the right place to insert this pbuf */ + /* @todo: trim pbufs if fragments are overlapping */ + valid = ip_reass_chain_frag_into_datagram_and_validate(ipr, p, is_last); + if (valid == IP_REASS_VALIDATE_PBUF_DROPPED) { + goto nullreturn_ipr; + } + /* if we come here, the pbuf has been enqueued */ + + /* Track the current number of pbufs current 'in-flight', in order to limit + the number of fragments that may be enqueued at any one time + (overflow checked by testing against IP_REASS_MAX_PBUFS) */ + ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount + clen); + if (is_last) { + u16_t datagram_len = (u16_t)(offset + len); + ipr->datagram_len = datagram_len; + ipr->flags |= IP_REASS_FLAG_LASTFRAG; + LWIP_DEBUGF(IP_REASS_DEBUG, + ("ip4_reass: last fragment seen, total len %"S16_F"\n", + ipr->datagram_len)); + } + + if (valid == IP_REASS_VALIDATE_TELEGRAM_FINISHED) { + struct ip_reassdata *ipr_prev; + /* the totally last fragment (flag more fragments = 0) was received at least + * once AND all fragments are received */ + u16_t datagram_len = (u16_t)(ipr->datagram_len + IP_HLEN); + + /* save the second pbuf before copying the header over the pointer */ + r = ((struct ip_reass_helper *)ipr->p->payload)->next_pbuf; + + /* copy the original ip header back to the first pbuf */ + fraghdr = (struct ip_hdr *)(ipr->p->payload); + SMEMCPY(fraghdr, &ipr->iphdr, IP_HLEN); + IPH_LEN_SET(fraghdr, lwip_htons(datagram_len)); + IPH_OFFSET_SET(fraghdr, 0); + IPH_CHKSUM_SET(fraghdr, 0); + /* @todo: do we need to set/calculate the correct checksum? */ +#if CHECKSUM_GEN_IP + IF__NETIF_CHECKSUM_ENABLED(ip_current_input_netif(), NETIF_CHECKSUM_GEN_IP) { + IPH_CHKSUM_SET(fraghdr, inet_chksum(fraghdr, IP_HLEN)); + } +#endif /* CHECKSUM_GEN_IP */ + + p = ipr->p; + + /* chain together the pbufs contained within the reass_data list. */ + while (r != NULL) { + iprh = (struct ip_reass_helper *)r->payload; + + /* hide the ip header for every succeeding fragment */ + pbuf_remove_header(r, IP_HLEN); + pbuf_cat(p, r); + r = iprh->next_pbuf; + } + + /* find the previous entry in the linked list */ + if (ipr == reassdatagrams) { + ipr_prev = NULL; + } else { + for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) { + if (ipr_prev->next == ipr) { + break; + } + } + } + + /* release the sources allocate for the fragment queue entry */ + ip_reass_dequeue_datagram(ipr, ipr_prev); + + /* and adjust the number of pbufs currently queued for reassembly. */ + clen = pbuf_clen(p); + LWIP_ASSERT("ip_reass_pbufcount >= clen", ip_reass_pbufcount >= clen); + ip_reass_pbufcount = (u16_t)(ip_reass_pbufcount - clen); + + MIB2_STATS_INC(mib2.ipreasmoks); + + /* Return the pbuf chain */ + return p; + } + /* the datagram is not (yet?) reassembled completely */ + LWIP_DEBUGF(IP_REASS_DEBUG, ("ip_reass_pbufcount: %d out\n", ip_reass_pbufcount)); + return NULL; + +nullreturn_ipr: + LWIP_ASSERT("ipr != NULL", ipr != NULL); + if (ipr->p == NULL) { + /* dropped pbuf after creating a new datagram entry: remove the entry, too */ + LWIP_ASSERT("not firstalthough just enqueued", ipr == reassdatagrams); + ip_reass_dequeue_datagram(ipr, NULL); + } + +nullreturn: + LWIP_DEBUGF(IP_REASS_DEBUG, ("ip4_reass: nullreturn\n")); + IPFRAG_STATS_INC(ip_frag.drop); + pbuf_free(p); + return NULL; +} +#endif /* IP_REASSEMBLY */ + +#if IP_FRAG +#if !LWIP_NETIF_TX_SINGLE_PBUF +/** Allocate a new struct pbuf_custom_ref */ +static struct pbuf_custom_ref * +ip_frag_alloc_pbuf_custom_ref(void) +{ + return (struct pbuf_custom_ref *)memp_malloc(MEMP_FRAG_PBUF); +} + +/** Free a struct pbuf_custom_ref */ +static void +ip_frag_free_pbuf_custom_ref(struct pbuf_custom_ref *p) +{ + LWIP_ASSERT("p != NULL", p != NULL); + memp_free(MEMP_FRAG_PBUF, p); +} + +/** Free-callback function to free a 'struct pbuf_custom_ref', called by + * pbuf_free. */ +static void +ipfrag_free_pbuf_custom(struct pbuf *p) +{ + struct pbuf_custom_ref *pcr = (struct pbuf_custom_ref *)p; + LWIP_ASSERT("pcr != NULL", pcr != NULL); + LWIP_ASSERT("pcr == p", (void *)pcr == (void *)p); + if (pcr->original != NULL) { + pbuf_free(pcr->original); + } + ip_frag_free_pbuf_custom_ref(pcr); +} +#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ + +/** + * Fragment an IP datagram if too large for the netif. + * + * Chop the datagram in MTU sized chunks and send them in order + * by pointing PBUF_REFs into p. + * + * @param p ip packet to send + * @param netif the netif on which to send + * @param dest destination ip address to which to send + * + * @return ERR_OK if sent successfully, err_t otherwise + */ +err_t +ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest) +{ + struct pbuf *rambuf; +#if !LWIP_NETIF_TX_SINGLE_PBUF + struct pbuf *newpbuf; + u16_t newpbuflen = 0; + u16_t left_to_copy; +#endif + struct ip_hdr *original_iphdr; + struct ip_hdr *iphdr; + const u16_t nfb = (u16_t)((netif->mtu - IP_HLEN) / 8); + u16_t left, fragsize; + u16_t ofo; + int last; + u16_t poff = IP_HLEN; + u16_t tmp; + int mf_set; + + original_iphdr = (struct ip_hdr *)p->payload; + iphdr = original_iphdr; + if (IPH_HL_BYTES(iphdr) != IP_HLEN) { + /* ip4_frag() does not support IP options */ + return ERR_VAL; + } + LWIP_ERROR("ip4_frag(): pbuf too short", p->len >= IP_HLEN, return ERR_VAL); + + /* Save original offset */ + tmp = lwip_ntohs(IPH_OFFSET(iphdr)); + ofo = tmp & IP_OFFMASK; + /* already fragmented? if so, the last fragment we create must have MF, too */ + mf_set = tmp & IP_MF; + + left = (u16_t)(p->tot_len - IP_HLEN); + + while (left) { + /* Fill this fragment */ + fragsize = LWIP_MIN(left, (u16_t)(nfb * 8)); + +#if LWIP_NETIF_TX_SINGLE_PBUF + rambuf = pbuf_alloc(PBUF_IP, fragsize, PBUF_RAM); + if (rambuf == NULL) { + goto memerr; + } + LWIP_ASSERT("this needs a pbuf in one piece!", + (rambuf->len == rambuf->tot_len) && (rambuf->next == NULL)); + poff += pbuf_copy_partial(p, rambuf->payload, fragsize, poff); + /* make room for the IP header */ + if (pbuf_add_header(rambuf, IP_HLEN)) { + pbuf_free(rambuf); + goto memerr; + } + /* fill in the IP header */ + SMEMCPY(rambuf->payload, original_iphdr, IP_HLEN); + iphdr = (struct ip_hdr *)rambuf->payload; +#else /* LWIP_NETIF_TX_SINGLE_PBUF */ + /* When not using a static buffer, create a chain of pbufs. + * The first will be a PBUF_RAM holding the link and IP header. + * The rest will be PBUF_REFs mirroring the pbuf chain to be fragged, + * but limited to the size of an mtu. + */ + rambuf = pbuf_alloc(PBUF_LINK, IP_HLEN, PBUF_RAM); + if (rambuf == NULL) { + goto memerr; + } + LWIP_ASSERT("this needs a pbuf in one piece!", + (rambuf->len >= (IP_HLEN))); + SMEMCPY(rambuf->payload, original_iphdr, IP_HLEN); + iphdr = (struct ip_hdr *)rambuf->payload; + + left_to_copy = fragsize; + while (left_to_copy) { + struct pbuf_custom_ref *pcr; + u16_t plen = (u16_t)(p->len - poff); + LWIP_ASSERT("p->len >= poff", p->len >= poff); + newpbuflen = LWIP_MIN(left_to_copy, plen); + /* Is this pbuf already empty? */ + if (!newpbuflen) { + poff = 0; + p = p->next; + continue; + } + pcr = ip_frag_alloc_pbuf_custom_ref(); + if (pcr == NULL) { + pbuf_free(rambuf); + goto memerr; + } + /* Mirror this pbuf, although we might not need all of it. */ + newpbuf = pbuf_alloced_custom(PBUF_RAW, newpbuflen, PBUF_REF, &pcr->pc, + (u8_t *)p->payload + poff, newpbuflen); + if (newpbuf == NULL) { + ip_frag_free_pbuf_custom_ref(pcr); + pbuf_free(rambuf); + goto memerr; + } + pbuf_ref(p); + pcr->original = p; + pcr->pc.custom_free_function = ipfrag_free_pbuf_custom; + + /* Add it to end of rambuf's chain, but using pbuf_cat, not pbuf_chain + * so that it is removed when pbuf_dechain is later called on rambuf. + */ + pbuf_cat(rambuf, newpbuf); + left_to_copy = (u16_t)(left_to_copy - newpbuflen); + if (left_to_copy) { + poff = 0; + p = p->next; + } + } + poff = (u16_t)(poff + newpbuflen); +#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ + + /* Correct header */ + last = (left <= netif->mtu - IP_HLEN); + + /* Set new offset and MF flag */ + tmp = (IP_OFFMASK & (ofo)); + if (!last || mf_set) { + /* the last fragment has MF set if the input frame had it */ + tmp = tmp | IP_MF; + } + IPH_OFFSET_SET(iphdr, lwip_htons(tmp)); + IPH_LEN_SET(iphdr, lwip_htons((u16_t)(fragsize + IP_HLEN))); + IPH_CHKSUM_SET(iphdr, 0); +#if CHECKSUM_GEN_IP + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_IP) { + IPH_CHKSUM_SET(iphdr, inet_chksum(iphdr, IP_HLEN)); + } +#endif /* CHECKSUM_GEN_IP */ + + /* No need for separate header pbuf - we allowed room for it in rambuf + * when allocated. + */ + netif->output(netif, rambuf, dest); + IPFRAG_STATS_INC(ip_frag.xmit); + + /* Unfortunately we can't reuse rambuf - the hardware may still be + * using the buffer. Instead we free it (and the ensuing chain) and + * recreate it next time round the loop. If we're lucky the hardware + * will have already sent the packet, the free will really free, and + * there will be zero memory penalty. + */ + + pbuf_free(rambuf); + left = (u16_t)(left - fragsize); + ofo = (u16_t)(ofo + nfb); + } + MIB2_STATS_INC(mib2.ipfragoks); + return ERR_OK; +memerr: + MIB2_STATS_INC(mib2.ipfragfails); + return ERR_MEM; +} +#endif /* IP_FRAG */ + +#endif /* LWIP_IPV4 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/dhcp6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/dhcp6.c index 1ae8742f..7cf98a52 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/dhcp6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/dhcp6.c @@ -1,812 +1,812 @@ -/** - * @file - * - * @defgroup dhcp6 DHCPv6 - * @ingroup ip6 - * DHCPv6 client: IPv6 address autoconfiguration as per - * RFC 3315 (stateful DHCPv6) and - * RFC 3736 (stateless DHCPv6). - * - * For now, only stateless DHCPv6 is implemented! - * - * TODO: - * - enable/disable API to not always start when RA is received - * - stateful DHCPv6 (for now, only stateless DHCPv6 for DNS and NTP servers works) - * - create Client Identifier? - * - only start requests if a valid local address is available on the netif - * - only start information requests if required (not for every RA) - * - * dhcp6_enable_stateful() enables stateful DHCPv6 for a netif (stateless disabled)\n - * dhcp6_enable_stateless() enables stateless DHCPv6 for a netif (stateful disabled)\n - * dhcp6_disable() disable DHCPv6 for a netif - * - * When enabled, requests are only issued after receipt of RA with the - * corresponding bits set. - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - */ - -#include "lwip/opt.h" - -#if LWIP_IPV6 && LWIP_IPV6_DHCP6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/dhcp6.h" -#include "lwip/prot/dhcp6.h" -#include "lwip/def.h" -#include "lwip/udp.h" -#include "lwip/dns.h" - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif -#ifndef LWIP_HOOK_DHCP6_APPEND_OPTIONS -#define LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, state, msg, msg_type, options_len_ptr, max_len) -#endif -#ifndef LWIP_HOOK_DHCP6_PARSE_OPTION -#define LWIP_HOOK_DHCP6_PARSE_OPTION(netif, dhcp6, state, msg, msg_type, option, len, pbuf, offset) do { LWIP_UNUSED_ARG(msg); } while(0) -#endif - -#if LWIP_DNS && LWIP_DHCP6_MAX_DNS_SERVERS -#if DNS_MAX_SERVERS > LWIP_DHCP6_MAX_DNS_SERVERS -#define LWIP_DHCP6_PROVIDE_DNS_SERVERS LWIP_DHCP6_MAX_DNS_SERVERS -#else -#define LWIP_DHCP6_PROVIDE_DNS_SERVERS DNS_MAX_SERVERS -#endif -#else -#define LWIP_DHCP6_PROVIDE_DNS_SERVERS 0 -#endif - - -/** Option handling: options are parsed in dhcp6_parse_reply - * and saved in an array where other functions can load them from. - * This might be moved into the struct dhcp6 (not necessarily since - * lwIP is single-threaded and the array is only used while in recv - * callback). */ -enum dhcp6_option_idx { - DHCP6_OPTION_IDX_CLI_ID = 0, - DHCP6_OPTION_IDX_SERVER_ID, -#if LWIP_DHCP6_PROVIDE_DNS_SERVERS - DHCP6_OPTION_IDX_DNS_SERVER, - DHCP6_OPTION_IDX_DOMAIN_LIST, -#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ -#if LWIP_DHCP6_GET_NTP_SRV - DHCP6_OPTION_IDX_NTP_SERVER, -#endif /* LWIP_DHCP_GET_NTP_SRV */ - DHCP6_OPTION_IDX_MAX -}; - -struct dhcp6_option_info { - u8_t option_given; - u16_t val_start; - u16_t val_length; -}; - -/** Holds the decoded option info, only valid while in dhcp6_recv. */ -struct dhcp6_option_info dhcp6_rx_options[DHCP6_OPTION_IDX_MAX]; - -#define dhcp6_option_given(dhcp6, idx) (dhcp6_rx_options[idx].option_given != 0) -#define dhcp6_got_option(dhcp6, idx) (dhcp6_rx_options[idx].option_given = 1) -#define dhcp6_clear_option(dhcp6, idx) (dhcp6_rx_options[idx].option_given = 0) -#define dhcp6_clear_all_options(dhcp6) (memset(dhcp6_rx_options, 0, sizeof(dhcp6_rx_options))) -#define dhcp6_get_option_start(dhcp6, idx) (dhcp6_rx_options[idx].val_start) -#define dhcp6_get_option_length(dhcp6, idx) (dhcp6_rx_options[idx].val_length) -#define dhcp6_set_option(dhcp6, idx, start, len) do { dhcp6_rx_options[idx].val_start = (start); dhcp6_rx_options[idx].val_length = (len); }while(0) - - -const ip_addr_t dhcp6_All_DHCP6_Relay_Agents_and_Servers = IPADDR6_INIT_HOST(0xFF020000, 0, 0, 0x00010002); -const ip_addr_t dhcp6_All_DHCP6_Servers = IPADDR6_INIT_HOST(0xFF020000, 0, 0, 0x00010003); - -static struct udp_pcb *dhcp6_pcb; -static u8_t dhcp6_pcb_refcount; - - -/* receive, unfold, parse and free incoming messages */ -static void dhcp6_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); - -/** Ensure DHCP PCB is allocated and bound */ -static err_t -dhcp6_inc_pcb_refcount(void) -{ - if (dhcp6_pcb_refcount == 0) { - LWIP_ASSERT("dhcp6_inc_pcb_refcount(): memory leak", dhcp6_pcb == NULL); - - /* allocate UDP PCB */ - dhcp6_pcb = udp_new_ip6(); - - if (dhcp6_pcb == NULL) { - return ERR_MEM; - } - - ip_set_option(dhcp6_pcb, SOF_BROADCAST); - - /* set up local and remote port for the pcb -> listen on all interfaces on all src/dest IPs */ - udp_bind(dhcp6_pcb, IP6_ADDR_ANY, DHCP6_CLIENT_PORT); - udp_recv(dhcp6_pcb, dhcp6_recv, NULL); - } - - dhcp6_pcb_refcount++; - - return ERR_OK; -} - -/** Free DHCP PCB if the last netif stops using it */ -static void -dhcp6_dec_pcb_refcount(void) -{ - LWIP_ASSERT("dhcp6_pcb_refcount(): refcount error", (dhcp6_pcb_refcount > 0)); - dhcp6_pcb_refcount--; - - if (dhcp6_pcb_refcount == 0) { - udp_remove(dhcp6_pcb); - dhcp6_pcb = NULL; - } -} - -/** - * @ingroup dhcp6 - * Set a statically allocated struct dhcp6 to work with. - * Using this prevents dhcp6_start to allocate it using mem_malloc. - * - * @param netif the netif for which to set the struct dhcp - * @param dhcp6 (uninitialised) dhcp6 struct allocated by the application - */ -void -dhcp6_set_struct(struct netif *netif, struct dhcp6 *dhcp6) -{ - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("dhcp6 != NULL", dhcp6 != NULL); - LWIP_ASSERT("netif already has a struct dhcp6 set", netif_dhcp6_data(netif) == NULL); - - /* clear data structure */ - memset(dhcp6, 0, sizeof(struct dhcp6)); - /* dhcp6_set_state(&dhcp, DHCP6_STATE_OFF); */ - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, dhcp6); -} - -/** - * @ingroup dhcp6 - * Removes a struct dhcp6 from a netif. - * - * ATTENTION: Only use this when not using dhcp6_set_struct() to allocate the - * struct dhcp6 since the memory is passed back to the heap. - * - * @param netif the netif from which to remove the struct dhcp - */ -void dhcp6_cleanup(struct netif *netif) -{ - LWIP_ASSERT("netif != NULL", netif != NULL); - - if (netif_dhcp6_data(netif) != NULL) { - mem_free(netif_dhcp6_data(netif)); - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, NULL); - } -} - -static struct dhcp6* -dhcp6_get_struct(struct netif *netif, const char *dbg_requester) -{ - struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); - if (dhcp6 == NULL) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("%s: mallocing new DHCPv6 client\n", dbg_requester)); - dhcp6 = (struct dhcp6 *)mem_malloc(sizeof(struct dhcp6)); - if (dhcp6 == NULL) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("%s: could not allocate dhcp6\n", dbg_requester)); - return NULL; - } - - /* clear data structure, this implies DHCP6_STATE_OFF */ - memset(dhcp6, 0, sizeof(struct dhcp6)); - /* store this dhcp6 client in the netif */ - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, dhcp6); - } else { - /* already has DHCP6 client attached */ - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("%s: using existing DHCPv6 client\n", dbg_requester)); - } - - if (!dhcp6->pcb_allocated) { - if (dhcp6_inc_pcb_refcount() != ERR_OK) { /* ensure DHCP6 PCB is allocated */ - mem_free(dhcp6); - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, NULL); - return NULL; - } - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("%s: allocated dhcp6", dbg_requester)); - dhcp6->pcb_allocated = 1; - } - return dhcp6; -} - -/* - * Set the DHCPv6 state - * If the state changed, reset the number of tries. - */ -static void -dhcp6_set_state(struct dhcp6 *dhcp6, u8_t new_state, const char *dbg_caller) -{ - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("DHCPv6 state: %d -> %d (%s)\n", - dhcp6->state, new_state, dbg_caller)); - if (new_state != dhcp6->state) { - dhcp6->state = new_state; - dhcp6->tries = 0; - dhcp6->request_timeout = 0; - } -} - -static int -dhcp6_stateless_enabled(struct dhcp6 *dhcp6) -{ - if ((dhcp6->state == DHCP6_STATE_STATELESS_IDLE) || - (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG)) { - return 1; - } - return 0; -} - -/*static int -dhcp6_stateful_enabled(struct dhcp6 *dhcp6) -{ - if (dhcp6->state == DHCP6_STATE_OFF) { - return 0; - } - if (dhcp6_stateless_enabled(dhcp6)) { - return 0; - } - return 1; -}*/ - -/** - * @ingroup dhcp6 - * Enable stateful DHCPv6 on this netif - * Requests are sent on receipt of an RA message with the - * ND6_RA_FLAG_MANAGED_ADDR_CONFIG flag set. - * - * A struct dhcp6 will be allocated for this netif if not - * set via @ref dhcp6_set_struct before. - * - * @todo: stateful DHCPv6 not supported, yet - */ -err_t -dhcp6_enable_stateful(struct netif *netif) -{ - LWIP_UNUSED_ARG(netif); - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("stateful dhcp6 not implemented yet")); - return ERR_VAL; -} - -/** - * @ingroup dhcp6 - * Enable stateless DHCPv6 on this netif - * Requests are sent on receipt of an RA message with the - * ND6_RA_FLAG_OTHER_CONFIG flag set. - * - * A struct dhcp6 will be allocated for this netif if not - * set via @ref dhcp6_set_struct before. - */ -err_t -dhcp6_enable_stateless(struct netif *netif) -{ - struct dhcp6 *dhcp6; - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_enable_stateless(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); - - dhcp6 = dhcp6_get_struct(netif, "dhcp6_enable_stateless()"); - if (dhcp6 == NULL) { - return ERR_MEM; - } - if (dhcp6_stateless_enabled(dhcp6)) { - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_enable_stateless(): stateless DHCPv6 already enabled")); - return ERR_OK; - } else if (dhcp6->state != DHCP6_STATE_OFF) { - /* stateful running */ - /* @todo: stop stateful once it is implemented */ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_enable_stateless(): switching from stateful to stateless DHCPv6")); - } - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_enable_stateless(): stateless DHCPv6 enabled\n")); - dhcp6_set_state(dhcp6, DHCP6_STATE_STATELESS_IDLE, "dhcp6_enable_stateless"); - return ERR_OK; -} - -/** - * @ingroup dhcp6 - * Disable stateful or stateless DHCPv6 on this netif - * Requests are sent on receipt of an RA message with the - * ND6_RA_FLAG_OTHER_CONFIG flag set. - */ -void -dhcp6_disable(struct netif *netif) -{ - struct dhcp6 *dhcp6; - - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_disable(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); - - dhcp6 = netif_dhcp6_data(netif); - if (dhcp6 != NULL) { - if (dhcp6->state != DHCP6_STATE_OFF) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_disable(): DHCPv6 disabled (old state: %s)\n", - (dhcp6_stateless_enabled(dhcp6) ? "stateless" : "stateful"))); - dhcp6_set_state(dhcp6, DHCP6_STATE_OFF, "dhcp6_disable"); - if (dhcp6->pcb_allocated != 0) { - dhcp6_dec_pcb_refcount(); /* free DHCPv6 PCB if not needed any more */ - dhcp6->pcb_allocated = 0; - } - } - } -} - -/** - * Create a DHCPv6 request, fill in common headers - * - * @param netif the netif under DHCPv6 control - * @param dhcp6 dhcp6 control struct - * @param message_type message type of the request - * @param opt_len_alloc option length to allocate - * @param options_out_len option length on exit - * @return a pbuf for the message - */ -static struct pbuf * -dhcp6_create_msg(struct netif *netif, struct dhcp6 *dhcp6, u8_t message_type, - u16_t opt_len_alloc, u16_t *options_out_len) -{ - struct pbuf *p_out; - struct dhcp6_msg *msg_out; - - LWIP_ERROR("dhcp6_create_msg: netif != NULL", (netif != NULL), return NULL;); - LWIP_ERROR("dhcp6_create_msg: dhcp6 != NULL", (dhcp6 != NULL), return NULL;); - p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp6_msg) + opt_len_alloc, PBUF_RAM); - if (p_out == NULL) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("dhcp6_create_msg(): could not allocate pbuf\n")); - return NULL; - } - LWIP_ASSERT("dhcp6_create_msg: check that first pbuf can hold struct dhcp6_msg", - (p_out->len >= sizeof(struct dhcp6_msg) + opt_len_alloc)); - - /* @todo: limit new xid for certain message types? */ - /* reuse transaction identifier in retransmissions */ - if (dhcp6->tries == 0) { - dhcp6->xid = LWIP_RAND() & 0xFFFFFF; - } - - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, - ("transaction id xid(%"X32_F")\n", dhcp6->xid)); - - msg_out = (struct dhcp6_msg *)p_out->payload; - memset(msg_out, 0, sizeof(struct dhcp6_msg) + opt_len_alloc); - - msg_out->msgtype = message_type; - msg_out->transaction_id[0] = (u8_t)(dhcp6->xid >> 16); - msg_out->transaction_id[1] = (u8_t)(dhcp6->xid >> 8); - msg_out->transaction_id[2] = (u8_t)dhcp6->xid; - *options_out_len = 0; - return p_out; -} - -static u16_t -dhcp6_option_short(u16_t options_out_len, u8_t *options, u16_t value) -{ - options[options_out_len++] = (u8_t)((value & 0xff00U) >> 8); - options[options_out_len++] = (u8_t) (value & 0x00ffU); - return options_out_len; -} - -static u16_t -dhcp6_option_optionrequest(u16_t options_out_len, u8_t *options, const u16_t *req_options, - u16_t num_req_options, u16_t max_len) -{ - size_t i; - u16_t ret; - - LWIP_ASSERT("dhcp6_option_optionrequest: options_out_len + sizeof(struct dhcp6_msg) + addlen <= max_len", - sizeof(struct dhcp6_msg) + options_out_len + 4U + (2U * num_req_options) <= max_len); - LWIP_UNUSED_ARG(max_len); - - ret = dhcp6_option_short(options_out_len, options, DHCP6_OPTION_ORO); - ret = dhcp6_option_short(ret, options, 2 * num_req_options); - for (i = 0; i < num_req_options; i++) { - ret = dhcp6_option_short(ret, options, req_options[i]); - } - return ret; -} - -/* All options are added, shrink the pbuf to the required size */ -static void -dhcp6_msg_finalize(u16_t options_out_len, struct pbuf *p_out) -{ - /* shrink the pbuf to the actual content length */ - pbuf_realloc(p_out, (u16_t)(sizeof(struct dhcp6_msg) + options_out_len)); -} - - -#if LWIP_IPV6_DHCP6_STATELESS -static void -dhcp6_information_request(struct netif *netif, struct dhcp6 *dhcp6) -{ - const u16_t requested_options[] = {DHCP6_OPTION_DNS_SERVERS, DHCP6_OPTION_DOMAIN_LIST, DHCP6_OPTION_SNTP_SERVERS}; - u16_t msecs; - struct pbuf *p_out; - u16_t options_out_len; - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_information_request()\n")); - /* create and initialize the DHCP message header */ - p_out = dhcp6_create_msg(netif, dhcp6, DHCP6_INFOREQUEST, 4 + sizeof(requested_options), &options_out_len); - if (p_out != NULL) { - err_t err; - struct dhcp6_msg *msg_out = (struct dhcp6_msg *)p_out->payload; - u8_t *options = (u8_t *)(msg_out + 1); - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_information_request: making request\n")); - - options_out_len = dhcp6_option_optionrequest(options_out_len, options, requested_options, - LWIP_ARRAYSIZE(requested_options), p_out->len); - LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, DHCP6_STATE_REQUESTING_CONFIG, msg_out, - DHCP6_INFOREQUEST, options_out_len, p_out->len); - dhcp6_msg_finalize(options_out_len, p_out); - - err = udp_sendto_if(dhcp6_pcb, p_out, &dhcp6_All_DHCP6_Relay_Agents_and_Servers, DHCP6_SERVER_PORT, netif); - pbuf_free(p_out); - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_information_request: INFOREQUESTING -> %d\n", (int)err)); - LWIP_UNUSED_ARG(err); - } else { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp6_information_request: could not allocate DHCP6 request\n")); - } - dhcp6_set_state(dhcp6, DHCP6_STATE_REQUESTING_CONFIG, "dhcp6_information_request"); - if (dhcp6->tries < 255) { - dhcp6->tries++; - } - msecs = (u16_t)((dhcp6->tries < 6 ? 1 << dhcp6->tries : 60) * 1000); - dhcp6->request_timeout = (u16_t)((msecs + DHCP6_TIMER_MSECS - 1) / DHCP6_TIMER_MSECS); - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_information_request(): set request timeout %"U16_F" msecs\n", msecs)); -} - -static err_t -dhcp6_request_config(struct netif *netif, struct dhcp6 *dhcp6) -{ - /* stateless mode enabled and no request running? */ - if (dhcp6->state == DHCP6_STATE_STATELESS_IDLE) { - /* send Information-request and wait for answer; setup receive timeout */ - dhcp6_information_request(netif, dhcp6); - } - - return ERR_OK; -} - -static void -dhcp6_abort_config_request(struct dhcp6 *dhcp6) -{ - if (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG) { - /* abort running request */ - dhcp6_set_state(dhcp6, DHCP6_STATE_STATELESS_IDLE, "dhcp6_abort_config_request"); - } -} - -/* Handle a REPLY to INFOREQUEST - * This parses DNS and NTP server addresses from the reply. - */ -static void -dhcp6_handle_config_reply(struct netif *netif, struct pbuf *p_msg_in) -{ - struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); - - LWIP_UNUSED_ARG(dhcp6); - LWIP_UNUSED_ARG(p_msg_in); - -#if LWIP_DHCP6_PROVIDE_DNS_SERVERS - if (dhcp6_option_given(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER)) { - ip_addr_t dns_addr; - ip6_addr_t *dns_addr6; - u16_t op_start = dhcp6_get_option_start(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER); - u16_t op_len = dhcp6_get_option_length(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER); - u16_t idx; - u8_t n; - - memset(&dns_addr, 0, sizeof(dns_addr)); - dns_addr6 = ip_2_ip6(&dns_addr); - for (n = 0, idx = op_start; (idx < op_start + op_len) && (n < LWIP_DHCP6_PROVIDE_DNS_SERVERS); - n++, idx += sizeof(struct ip6_addr_packed)) { - u16_t copied = pbuf_copy_partial(p_msg_in, dns_addr6, sizeof(struct ip6_addr_packed), idx); - if (copied != sizeof(struct ip6_addr_packed)) { - /* pbuf length mismatch */ - return; - } - ip6_addr_assign_zone(dns_addr6, IP6_UNKNOWN, netif); - /* @todo: do we need a different offset than DHCP(v4)? */ - dns_setserver(n, &dns_addr); - } - } - /* @ todo: parse and set Domain Search List */ -#endif /* LWIP_DHCP6_PROVIDE_DNS_SERVERS */ - -#if LWIP_DHCP6_GET_NTP_SRV - if (dhcp6_option_given(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER)) { - ip_addr_t ntp_server_addrs[LWIP_DHCP6_MAX_NTP_SERVERS]; - u16_t op_start = dhcp6_get_option_start(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER); - u16_t op_len = dhcp6_get_option_length(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER); - u16_t idx; - u8_t n; - - for (n = 0, idx = op_start; (idx < op_start + op_len) && (n < LWIP_DHCP6_MAX_NTP_SERVERS); - n++, idx += sizeof(struct ip6_addr_packed)) { - u16_t copied; - ip6_addr_t *ntp_addr6 = ip_2_ip6(&ntp_server_addrs[n]); - ip_addr_set_zero_ip6(&ntp_server_addrs[n]); - copied = pbuf_copy_partial(p_msg_in, ntp_addr6, sizeof(struct ip6_addr_packed), idx); - if (copied != sizeof(struct ip6_addr_packed)) { - /* pbuf length mismatch */ - return; - } - ip6_addr_assign_zone(ntp_addr6, IP6_UNKNOWN, netif); - } - dhcp6_set_ntp_servers(n, ntp_server_addrs); - } -#endif /* LWIP_DHCP6_GET_NTP_SRV */ -} -#endif /* LWIP_IPV6_DHCP6_STATELESS */ - -/** This function is called from nd6 module when an RA messsage is received - * It triggers DHCPv6 requests (if enabled). - */ -void -dhcp6_nd6_ra_trigger(struct netif *netif, u8_t managed_addr_config, u8_t other_config) -{ - struct dhcp6 *dhcp6; - - LWIP_ASSERT("netif != NULL", netif != NULL); - dhcp6 = netif_dhcp6_data(netif); - - LWIP_UNUSED_ARG(managed_addr_config); - LWIP_UNUSED_ARG(other_config); - LWIP_UNUSED_ARG(dhcp6); - -#if LWIP_IPV6_DHCP6_STATELESS - if (dhcp6 != NULL) { - if (dhcp6_stateless_enabled(dhcp6)) { - if (other_config) { - dhcp6_request_config(netif, dhcp6); - } else { - dhcp6_abort_config_request(dhcp6); - } - } - } -#endif /* LWIP_IPV6_DHCP6_STATELESS */ -} - -/** - * Parse the DHCPv6 message and extract the DHCPv6 options. - * - * Extract the DHCPv6 options (offset + length) so that we can later easily - * check for them or extract the contents. - */ -static err_t -dhcp6_parse_reply(struct pbuf *p, struct dhcp6 *dhcp6) -{ - u16_t offset; - u16_t offset_max; - u16_t options_idx; - struct dhcp6_msg *msg_in; - - LWIP_UNUSED_ARG(dhcp6); - - /* clear received options */ - dhcp6_clear_all_options(dhcp6); - msg_in = (struct dhcp6_msg *)p->payload; - - /* parse options */ - - options_idx = sizeof(struct dhcp6_msg); - /* parse options to the end of the received packet */ - offset_max = p->tot_len; - - offset = options_idx; - /* at least 4 byte to read? */ - while ((offset + 4 <= offset_max)) { - u8_t op_len_buf[4]; - u8_t *op_len; - u16_t op; - u16_t len; - u16_t val_offset = (u16_t)(offset + 4); - if (val_offset < offset) { - /* overflow */ - return ERR_BUF; - } - /* copy option + length, might be split accross pbufs */ - op_len = (u8_t *)pbuf_get_contiguous(p, op_len_buf, 4, 4, offset); - if (op_len == NULL) { - /* failed to get option and length */ - return ERR_VAL; - } - op = (op_len[0] << 8) | op_len[1]; - len = (op_len[2] << 8) | op_len[3]; - offset = val_offset + len; - if (offset < val_offset) { - /* overflow */ - return ERR_BUF; - } - - switch (op) { - case (DHCP6_OPTION_CLIENTID): - dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_CLI_ID); - dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_CLI_ID, val_offset, len); - break; - case (DHCP6_OPTION_SERVERID): - dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_SERVER_ID); - dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_SERVER_ID, val_offset, len); - break; -#if LWIP_DHCP6_PROVIDE_DNS_SERVERS - case (DHCP6_OPTION_DNS_SERVERS): - dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER); - dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER, val_offset, len); - break; - case (DHCP6_OPTION_DOMAIN_LIST): - dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_DOMAIN_LIST); - dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_DOMAIN_LIST, val_offset, len); - break; -#endif /* LWIP_DHCP6_PROVIDE_DNS_SERVERS */ -#if LWIP_DHCP6_GET_NTP_SRV - case (DHCP6_OPTION_SNTP_SERVERS): - dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER); - dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER, val_offset, len); - break; -#endif /* LWIP_DHCP6_GET_NTP_SRV*/ - default: - LWIP_DEBUGF(DHCP6_DEBUG, ("skipping option %"U16_F" in options\n", op)); - LWIP_HOOK_DHCP6_PARSE_OPTION(ip_current_netif(), dhcp6, dhcp6->state, msg_in, - msg_in->msgtype, op, len, q, val_offset); - break; - } - } - return ERR_OK; -} - -static void -dhcp6_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) -{ - struct netif *netif = ip_current_input_netif(); - struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); - struct dhcp6_msg *reply_msg = (struct dhcp6_msg *)p->payload; - u8_t msg_type; - u32_t xid; - - LWIP_UNUSED_ARG(arg); - - /* Caught DHCPv6 message from netif that does not have DHCPv6 enabled? -> not interested */ - if ((dhcp6 == NULL) || (dhcp6->pcb_allocated == 0)) { - goto free_pbuf_and_return; - } - - LWIP_ERROR("invalid server address type", IP_IS_V6(addr), goto free_pbuf_and_return;); - - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_recv(pbuf = %p) from DHCPv6 server %s port %"U16_F"\n", (void *)p, - ipaddr_ntoa(addr), port)); - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("pbuf->len = %"U16_F"\n", p->len)); - LWIP_DEBUGF(DHCP6_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); - - if (p->len < sizeof(struct dhcp6_msg)) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("DHCPv6 reply message or pbuf too short\n")); - goto free_pbuf_and_return; - } - - /* match transaction ID against what we expected */ - xid = reply_msg->transaction_id[0] << 16; - xid |= reply_msg->transaction_id[1] << 8; - xid |= reply_msg->transaction_id[2]; - if (xid != dhcp6->xid) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, - ("transaction id mismatch reply_msg->xid(%"X32_F")!= dhcp6->xid(%"X32_F")\n", xid, dhcp6->xid)); - goto free_pbuf_and_return; - } - /* option fields could be unfold? */ - if (dhcp6_parse_reply(p, dhcp6) != ERR_OK) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("problem unfolding DHCPv6 message - too short on memory?\n")); - goto free_pbuf_and_return; - } - - /* read DHCP message type */ - msg_type = reply_msg->msgtype; - /* message type is DHCP6 REPLY? */ - if (msg_type == DHCP6_REPLY) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("DHCP6_REPLY received\n")); -#if LWIP_IPV6_DHCP6_STATELESS - /* in info-requesting state? */ - if (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG) { - dhcp6_set_state(dhcp6, DHCP6_STATE_STATELESS_IDLE, "dhcp6_recv"); - dhcp6_handle_config_reply(netif, p); - } else -#endif /* LWIP_IPV6_DHCP6_STATELESS */ - { - /* @todo: handle reply in other states? */ - } - } else { - /* @todo: handle other message types */ - } - -free_pbuf_and_return: - pbuf_free(p); -} - -/** - * A DHCPv6 request has timed out. - * - * The timer that was started with the DHCPv6 request has - * timed out, indicating no response was received in time. - */ -static void -dhcp6_timeout(struct netif *netif, struct dhcp6 *dhcp6) -{ - LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_timeout()\n")); - - LWIP_UNUSED_ARG(netif); - LWIP_UNUSED_ARG(dhcp6); - -#if LWIP_IPV6_DHCP6_STATELESS - /* back-off period has passed, or server selection timed out */ - if (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG) { - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_timeout(): retrying information request\n")); - dhcp6_information_request(netif, dhcp6); - } -#endif /* LWIP_IPV6_DHCP6_STATELESS */ -} - -/** - * DHCPv6 timeout handling (this function must be called every 500ms, - * see @ref DHCP6_TIMER_MSECS). - * - * A DHCPv6 server is expected to respond within a short period of time. - * This timer checks whether an outstanding DHCPv6 request is timed out. - */ -void -dhcp6_tmr(void) -{ - struct netif *netif; - /* loop through netif's */ - NETIF_FOREACH(netif) { - struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); - /* only act on DHCPv6 configured interfaces */ - if (dhcp6 != NULL) { - /* timer is active (non zero), and is about to trigger now */ - if (dhcp6->request_timeout > 1) { - dhcp6->request_timeout--; - } else if (dhcp6->request_timeout == 1) { - dhcp6->request_timeout--; - /* { dhcp6->request_timeout == 0 } */ - LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_tmr(): request timeout\n")); - /* this client's request timeout triggered */ - dhcp6_timeout(netif, dhcp6); - } - } - } -} - -#endif /* LWIP_IPV6 && LWIP_IPV6_DHCP6 */ +/** + * @file + * + * @defgroup dhcp6 DHCPv6 + * @ingroup ip6 + * DHCPv6 client: IPv6 address autoconfiguration as per + * RFC 3315 (stateful DHCPv6) and + * RFC 3736 (stateless DHCPv6). + * + * For now, only stateless DHCPv6 is implemented! + * + * TODO: + * - enable/disable API to not always start when RA is received + * - stateful DHCPv6 (for now, only stateless DHCPv6 for DNS and NTP servers works) + * - create Client Identifier? + * - only start requests if a valid local address is available on the netif + * - only start information requests if required (not for every RA) + * + * dhcp6_enable_stateful() enables stateful DHCPv6 for a netif (stateless disabled)\n + * dhcp6_enable_stateless() enables stateless DHCPv6 for a netif (stateful disabled)\n + * dhcp6_disable() disable DHCPv6 for a netif + * + * When enabled, requests are only issued after receipt of RA with the + * corresponding bits set. + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + */ + +#include "lwip/opt.h" + +#if LWIP_IPV6 && LWIP_IPV6_DHCP6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/dhcp6.h" +#include "lwip/prot/dhcp6.h" +#include "lwip/def.h" +#include "lwip/udp.h" +#include "lwip/dns.h" + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif +#ifndef LWIP_HOOK_DHCP6_APPEND_OPTIONS +#define LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, state, msg, msg_type, options_len_ptr, max_len) +#endif +#ifndef LWIP_HOOK_DHCP6_PARSE_OPTION +#define LWIP_HOOK_DHCP6_PARSE_OPTION(netif, dhcp6, state, msg, msg_type, option, len, pbuf, offset) do { LWIP_UNUSED_ARG(msg); } while(0) +#endif + +#if LWIP_DNS && LWIP_DHCP6_MAX_DNS_SERVERS +#if DNS_MAX_SERVERS > LWIP_DHCP6_MAX_DNS_SERVERS +#define LWIP_DHCP6_PROVIDE_DNS_SERVERS LWIP_DHCP6_MAX_DNS_SERVERS +#else +#define LWIP_DHCP6_PROVIDE_DNS_SERVERS DNS_MAX_SERVERS +#endif +#else +#define LWIP_DHCP6_PROVIDE_DNS_SERVERS 0 +#endif + + +/** Option handling: options are parsed in dhcp6_parse_reply + * and saved in an array where other functions can load them from. + * This might be moved into the struct dhcp6 (not necessarily since + * lwIP is single-threaded and the array is only used while in recv + * callback). */ +enum dhcp6_option_idx { + DHCP6_OPTION_IDX_CLI_ID = 0, + DHCP6_OPTION_IDX_SERVER_ID, +#if LWIP_DHCP6_PROVIDE_DNS_SERVERS + DHCP6_OPTION_IDX_DNS_SERVER, + DHCP6_OPTION_IDX_DOMAIN_LIST, +#endif /* LWIP_DHCP_PROVIDE_DNS_SERVERS */ +#if LWIP_DHCP6_GET_NTP_SRV + DHCP6_OPTION_IDX_NTP_SERVER, +#endif /* LWIP_DHCP_GET_NTP_SRV */ + DHCP6_OPTION_IDX_MAX +}; + +struct dhcp6_option_info { + u8_t option_given; + u16_t val_start; + u16_t val_length; +}; + +/** Holds the decoded option info, only valid while in dhcp6_recv. */ +struct dhcp6_option_info dhcp6_rx_options[DHCP6_OPTION_IDX_MAX]; + +#define dhcp6_option_given(dhcp6, idx) (dhcp6_rx_options[idx].option_given != 0) +#define dhcp6_got_option(dhcp6, idx) (dhcp6_rx_options[idx].option_given = 1) +#define dhcp6_clear_option(dhcp6, idx) (dhcp6_rx_options[idx].option_given = 0) +#define dhcp6_clear_all_options(dhcp6) (memset(dhcp6_rx_options, 0, sizeof(dhcp6_rx_options))) +#define dhcp6_get_option_start(dhcp6, idx) (dhcp6_rx_options[idx].val_start) +#define dhcp6_get_option_length(dhcp6, idx) (dhcp6_rx_options[idx].val_length) +#define dhcp6_set_option(dhcp6, idx, start, len) do { dhcp6_rx_options[idx].val_start = (start); dhcp6_rx_options[idx].val_length = (len); }while(0) + + +const ip_addr_t dhcp6_All_DHCP6_Relay_Agents_and_Servers = IPADDR6_INIT_HOST(0xFF020000, 0, 0, 0x00010002); +const ip_addr_t dhcp6_All_DHCP6_Servers = IPADDR6_INIT_HOST(0xFF020000, 0, 0, 0x00010003); + +static struct udp_pcb *dhcp6_pcb; +static u8_t dhcp6_pcb_refcount; + + +/* receive, unfold, parse and free incoming messages */ +static void dhcp6_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); + +/** Ensure DHCP PCB is allocated and bound */ +static err_t +dhcp6_inc_pcb_refcount(void) +{ + if (dhcp6_pcb_refcount == 0) { + LWIP_ASSERT("dhcp6_inc_pcb_refcount(): memory leak", dhcp6_pcb == NULL); + + /* allocate UDP PCB */ + dhcp6_pcb = udp_new_ip6(); + + if (dhcp6_pcb == NULL) { + return ERR_MEM; + } + + ip_set_option(dhcp6_pcb, SOF_BROADCAST); + + /* set up local and remote port for the pcb -> listen on all interfaces on all src/dest IPs */ + udp_bind(dhcp6_pcb, IP6_ADDR_ANY, DHCP6_CLIENT_PORT); + udp_recv(dhcp6_pcb, dhcp6_recv, NULL); + } + + dhcp6_pcb_refcount++; + + return ERR_OK; +} + +/** Free DHCP PCB if the last netif stops using it */ +static void +dhcp6_dec_pcb_refcount(void) +{ + LWIP_ASSERT("dhcp6_pcb_refcount(): refcount error", (dhcp6_pcb_refcount > 0)); + dhcp6_pcb_refcount--; + + if (dhcp6_pcb_refcount == 0) { + udp_remove(dhcp6_pcb); + dhcp6_pcb = NULL; + } +} + +/** + * @ingroup dhcp6 + * Set a statically allocated struct dhcp6 to work with. + * Using this prevents dhcp6_start to allocate it using mem_malloc. + * + * @param netif the netif for which to set the struct dhcp + * @param dhcp6 (uninitialised) dhcp6 struct allocated by the application + */ +void +dhcp6_set_struct(struct netif *netif, struct dhcp6 *dhcp6) +{ + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("dhcp6 != NULL", dhcp6 != NULL); + LWIP_ASSERT("netif already has a struct dhcp6 set", netif_dhcp6_data(netif) == NULL); + + /* clear data structure */ + memset(dhcp6, 0, sizeof(struct dhcp6)); + /* dhcp6_set_state(&dhcp, DHCP6_STATE_OFF); */ + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, dhcp6); +} + +/** + * @ingroup dhcp6 + * Removes a struct dhcp6 from a netif. + * + * ATTENTION: Only use this when not using dhcp6_set_struct() to allocate the + * struct dhcp6 since the memory is passed back to the heap. + * + * @param netif the netif from which to remove the struct dhcp + */ +void dhcp6_cleanup(struct netif *netif) +{ + LWIP_ASSERT("netif != NULL", netif != NULL); + + if (netif_dhcp6_data(netif) != NULL) { + mem_free(netif_dhcp6_data(netif)); + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, NULL); + } +} + +static struct dhcp6* +dhcp6_get_struct(struct netif *netif, const char *dbg_requester) +{ + struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); + if (dhcp6 == NULL) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("%s: mallocing new DHCPv6 client\n", dbg_requester)); + dhcp6 = (struct dhcp6 *)mem_malloc(sizeof(struct dhcp6)); + if (dhcp6 == NULL) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("%s: could not allocate dhcp6\n", dbg_requester)); + return NULL; + } + + /* clear data structure, this implies DHCP6_STATE_OFF */ + memset(dhcp6, 0, sizeof(struct dhcp6)); + /* store this dhcp6 client in the netif */ + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, dhcp6); + } else { + /* already has DHCP6 client attached */ + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("%s: using existing DHCPv6 client\n", dbg_requester)); + } + + if (!dhcp6->pcb_allocated) { + if (dhcp6_inc_pcb_refcount() != ERR_OK) { /* ensure DHCP6 PCB is allocated */ + mem_free(dhcp6); + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, NULL); + return NULL; + } + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("%s: allocated dhcp6", dbg_requester)); + dhcp6->pcb_allocated = 1; + } + return dhcp6; +} + +/* + * Set the DHCPv6 state + * If the state changed, reset the number of tries. + */ +static void +dhcp6_set_state(struct dhcp6 *dhcp6, u8_t new_state, const char *dbg_caller) +{ + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("DHCPv6 state: %d -> %d (%s)\n", + dhcp6->state, new_state, dbg_caller)); + if (new_state != dhcp6->state) { + dhcp6->state = new_state; + dhcp6->tries = 0; + dhcp6->request_timeout = 0; + } +} + +static int +dhcp6_stateless_enabled(struct dhcp6 *dhcp6) +{ + if ((dhcp6->state == DHCP6_STATE_STATELESS_IDLE) || + (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG)) { + return 1; + } + return 0; +} + +/*static int +dhcp6_stateful_enabled(struct dhcp6 *dhcp6) +{ + if (dhcp6->state == DHCP6_STATE_OFF) { + return 0; + } + if (dhcp6_stateless_enabled(dhcp6)) { + return 0; + } + return 1; +}*/ + +/** + * @ingroup dhcp6 + * Enable stateful DHCPv6 on this netif + * Requests are sent on receipt of an RA message with the + * ND6_RA_FLAG_MANAGED_ADDR_CONFIG flag set. + * + * A struct dhcp6 will be allocated for this netif if not + * set via @ref dhcp6_set_struct before. + * + * @todo: stateful DHCPv6 not supported, yet + */ +err_t +dhcp6_enable_stateful(struct netif *netif) +{ + LWIP_UNUSED_ARG(netif); + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("stateful dhcp6 not implemented yet")); + return ERR_VAL; +} + +/** + * @ingroup dhcp6 + * Enable stateless DHCPv6 on this netif + * Requests are sent on receipt of an RA message with the + * ND6_RA_FLAG_OTHER_CONFIG flag set. + * + * A struct dhcp6 will be allocated for this netif if not + * set via @ref dhcp6_set_struct before. + */ +err_t +dhcp6_enable_stateless(struct netif *netif) +{ + struct dhcp6 *dhcp6; + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_enable_stateless(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); + + dhcp6 = dhcp6_get_struct(netif, "dhcp6_enable_stateless()"); + if (dhcp6 == NULL) { + return ERR_MEM; + } + if (dhcp6_stateless_enabled(dhcp6)) { + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_enable_stateless(): stateless DHCPv6 already enabled")); + return ERR_OK; + } else if (dhcp6->state != DHCP6_STATE_OFF) { + /* stateful running */ + /* @todo: stop stateful once it is implemented */ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_enable_stateless(): switching from stateful to stateless DHCPv6")); + } + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_enable_stateless(): stateless DHCPv6 enabled\n")); + dhcp6_set_state(dhcp6, DHCP6_STATE_STATELESS_IDLE, "dhcp6_enable_stateless"); + return ERR_OK; +} + +/** + * @ingroup dhcp6 + * Disable stateful or stateless DHCPv6 on this netif + * Requests are sent on receipt of an RA message with the + * ND6_RA_FLAG_OTHER_CONFIG flag set. + */ +void +dhcp6_disable(struct netif *netif) +{ + struct dhcp6 *dhcp6; + + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_disable(netif=%p) %c%c%"U16_F"\n", (void *)netif, netif->name[0], netif->name[1], (u16_t)netif->num)); + + dhcp6 = netif_dhcp6_data(netif); + if (dhcp6 != NULL) { + if (dhcp6->state != DHCP6_STATE_OFF) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_disable(): DHCPv6 disabled (old state: %s)\n", + (dhcp6_stateless_enabled(dhcp6) ? "stateless" : "stateful"))); + dhcp6_set_state(dhcp6, DHCP6_STATE_OFF, "dhcp6_disable"); + if (dhcp6->pcb_allocated != 0) { + dhcp6_dec_pcb_refcount(); /* free DHCPv6 PCB if not needed any more */ + dhcp6->pcb_allocated = 0; + } + } + } +} + +/** + * Create a DHCPv6 request, fill in common headers + * + * @param netif the netif under DHCPv6 control + * @param dhcp6 dhcp6 control struct + * @param message_type message type of the request + * @param opt_len_alloc option length to allocate + * @param options_out_len option length on exit + * @return a pbuf for the message + */ +static struct pbuf * +dhcp6_create_msg(struct netif *netif, struct dhcp6 *dhcp6, u8_t message_type, + u16_t opt_len_alloc, u16_t *options_out_len) +{ + struct pbuf *p_out; + struct dhcp6_msg *msg_out; + + LWIP_ERROR("dhcp6_create_msg: netif != NULL", (netif != NULL), return NULL;); + LWIP_ERROR("dhcp6_create_msg: dhcp6 != NULL", (dhcp6 != NULL), return NULL;); + p_out = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct dhcp6_msg) + opt_len_alloc, PBUF_RAM); + if (p_out == NULL) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("dhcp6_create_msg(): could not allocate pbuf\n")); + return NULL; + } + LWIP_ASSERT("dhcp6_create_msg: check that first pbuf can hold struct dhcp6_msg", + (p_out->len >= sizeof(struct dhcp6_msg) + opt_len_alloc)); + + /* @todo: limit new xid for certain message types? */ + /* reuse transaction identifier in retransmissions */ + if (dhcp6->tries == 0) { + dhcp6->xid = LWIP_RAND() & 0xFFFFFF; + } + + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, + ("transaction id xid(%"X32_F")\n", dhcp6->xid)); + + msg_out = (struct dhcp6_msg *)p_out->payload; + memset(msg_out, 0, sizeof(struct dhcp6_msg) + opt_len_alloc); + + msg_out->msgtype = message_type; + msg_out->transaction_id[0] = (u8_t)(dhcp6->xid >> 16); + msg_out->transaction_id[1] = (u8_t)(dhcp6->xid >> 8); + msg_out->transaction_id[2] = (u8_t)dhcp6->xid; + *options_out_len = 0; + return p_out; +} + +static u16_t +dhcp6_option_short(u16_t options_out_len, u8_t *options, u16_t value) +{ + options[options_out_len++] = (u8_t)((value & 0xff00U) >> 8); + options[options_out_len++] = (u8_t) (value & 0x00ffU); + return options_out_len; +} + +static u16_t +dhcp6_option_optionrequest(u16_t options_out_len, u8_t *options, const u16_t *req_options, + u16_t num_req_options, u16_t max_len) +{ + size_t i; + u16_t ret; + + LWIP_ASSERT("dhcp6_option_optionrequest: options_out_len + sizeof(struct dhcp6_msg) + addlen <= max_len", + sizeof(struct dhcp6_msg) + options_out_len + 4U + (2U * num_req_options) <= max_len); + LWIP_UNUSED_ARG(max_len); + + ret = dhcp6_option_short(options_out_len, options, DHCP6_OPTION_ORO); + ret = dhcp6_option_short(ret, options, 2 * num_req_options); + for (i = 0; i < num_req_options; i++) { + ret = dhcp6_option_short(ret, options, req_options[i]); + } + return ret; +} + +/* All options are added, shrink the pbuf to the required size */ +static void +dhcp6_msg_finalize(u16_t options_out_len, struct pbuf *p_out) +{ + /* shrink the pbuf to the actual content length */ + pbuf_realloc(p_out, (u16_t)(sizeof(struct dhcp6_msg) + options_out_len)); +} + + +#if LWIP_IPV6_DHCP6_STATELESS +static void +dhcp6_information_request(struct netif *netif, struct dhcp6 *dhcp6) +{ + const u16_t requested_options[] = {DHCP6_OPTION_DNS_SERVERS, DHCP6_OPTION_DOMAIN_LIST, DHCP6_OPTION_SNTP_SERVERS}; + u16_t msecs; + struct pbuf *p_out; + u16_t options_out_len; + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_information_request()\n")); + /* create and initialize the DHCP message header */ + p_out = dhcp6_create_msg(netif, dhcp6, DHCP6_INFOREQUEST, 4 + sizeof(requested_options), &options_out_len); + if (p_out != NULL) { + err_t err; + struct dhcp6_msg *msg_out = (struct dhcp6_msg *)p_out->payload; + u8_t *options = (u8_t *)(msg_out + 1); + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_information_request: making request\n")); + + options_out_len = dhcp6_option_optionrequest(options_out_len, options, requested_options, + LWIP_ARRAYSIZE(requested_options), p_out->len); + LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, DHCP6_STATE_REQUESTING_CONFIG, msg_out, + DHCP6_INFOREQUEST, options_out_len, p_out->len); + dhcp6_msg_finalize(options_out_len, p_out); + + err = udp_sendto_if(dhcp6_pcb, p_out, &dhcp6_All_DHCP6_Relay_Agents_and_Servers, DHCP6_SERVER_PORT, netif); + pbuf_free(p_out); + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_information_request: INFOREQUESTING -> %d\n", (int)err)); + LWIP_UNUSED_ARG(err); + } else { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("dhcp6_information_request: could not allocate DHCP6 request\n")); + } + dhcp6_set_state(dhcp6, DHCP6_STATE_REQUESTING_CONFIG, "dhcp6_information_request"); + if (dhcp6->tries < 255) { + dhcp6->tries++; + } + msecs = (u16_t)((dhcp6->tries < 6 ? 1 << dhcp6->tries : 60) * 1000); + dhcp6->request_timeout = (u16_t)((msecs + DHCP6_TIMER_MSECS - 1) / DHCP6_TIMER_MSECS); + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_information_request(): set request timeout %"U16_F" msecs\n", msecs)); +} + +static err_t +dhcp6_request_config(struct netif *netif, struct dhcp6 *dhcp6) +{ + /* stateless mode enabled and no request running? */ + if (dhcp6->state == DHCP6_STATE_STATELESS_IDLE) { + /* send Information-request and wait for answer; setup receive timeout */ + dhcp6_information_request(netif, dhcp6); + } + + return ERR_OK; +} + +static void +dhcp6_abort_config_request(struct dhcp6 *dhcp6) +{ + if (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG) { + /* abort running request */ + dhcp6_set_state(dhcp6, DHCP6_STATE_STATELESS_IDLE, "dhcp6_abort_config_request"); + } +} + +/* Handle a REPLY to INFOREQUEST + * This parses DNS and NTP server addresses from the reply. + */ +static void +dhcp6_handle_config_reply(struct netif *netif, struct pbuf *p_msg_in) +{ + struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); + + LWIP_UNUSED_ARG(dhcp6); + LWIP_UNUSED_ARG(p_msg_in); + +#if LWIP_DHCP6_PROVIDE_DNS_SERVERS + if (dhcp6_option_given(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER)) { + ip_addr_t dns_addr; + ip6_addr_t *dns_addr6; + u16_t op_start = dhcp6_get_option_start(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER); + u16_t op_len = dhcp6_get_option_length(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER); + u16_t idx; + u8_t n; + + memset(&dns_addr, 0, sizeof(dns_addr)); + dns_addr6 = ip_2_ip6(&dns_addr); + for (n = 0, idx = op_start; (idx < op_start + op_len) && (n < LWIP_DHCP6_PROVIDE_DNS_SERVERS); + n++, idx += sizeof(struct ip6_addr_packed)) { + u16_t copied = pbuf_copy_partial(p_msg_in, dns_addr6, sizeof(struct ip6_addr_packed), idx); + if (copied != sizeof(struct ip6_addr_packed)) { + /* pbuf length mismatch */ + return; + } + ip6_addr_assign_zone(dns_addr6, IP6_UNKNOWN, netif); + /* @todo: do we need a different offset than DHCP(v4)? */ + dns_setserver(n, &dns_addr); + } + } + /* @ todo: parse and set Domain Search List */ +#endif /* LWIP_DHCP6_PROVIDE_DNS_SERVERS */ + +#if LWIP_DHCP6_GET_NTP_SRV + if (dhcp6_option_given(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER)) { + ip_addr_t ntp_server_addrs[LWIP_DHCP6_MAX_NTP_SERVERS]; + u16_t op_start = dhcp6_get_option_start(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER); + u16_t op_len = dhcp6_get_option_length(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER); + u16_t idx; + u8_t n; + + for (n = 0, idx = op_start; (idx < op_start + op_len) && (n < LWIP_DHCP6_MAX_NTP_SERVERS); + n++, idx += sizeof(struct ip6_addr_packed)) { + u16_t copied; + ip6_addr_t *ntp_addr6 = ip_2_ip6(&ntp_server_addrs[n]); + ip_addr_set_zero_ip6(&ntp_server_addrs[n]); + copied = pbuf_copy_partial(p_msg_in, ntp_addr6, sizeof(struct ip6_addr_packed), idx); + if (copied != sizeof(struct ip6_addr_packed)) { + /* pbuf length mismatch */ + return; + } + ip6_addr_assign_zone(ntp_addr6, IP6_UNKNOWN, netif); + } + dhcp6_set_ntp_servers(n, ntp_server_addrs); + } +#endif /* LWIP_DHCP6_GET_NTP_SRV */ +} +#endif /* LWIP_IPV6_DHCP6_STATELESS */ + +/** This function is called from nd6 module when an RA messsage is received + * It triggers DHCPv6 requests (if enabled). + */ +void +dhcp6_nd6_ra_trigger(struct netif *netif, u8_t managed_addr_config, u8_t other_config) +{ + struct dhcp6 *dhcp6; + + LWIP_ASSERT("netif != NULL", netif != NULL); + dhcp6 = netif_dhcp6_data(netif); + + LWIP_UNUSED_ARG(managed_addr_config); + LWIP_UNUSED_ARG(other_config); + LWIP_UNUSED_ARG(dhcp6); + +#if LWIP_IPV6_DHCP6_STATELESS + if (dhcp6 != NULL) { + if (dhcp6_stateless_enabled(dhcp6)) { + if (other_config) { + dhcp6_request_config(netif, dhcp6); + } else { + dhcp6_abort_config_request(dhcp6); + } + } + } +#endif /* LWIP_IPV6_DHCP6_STATELESS */ +} + +/** + * Parse the DHCPv6 message and extract the DHCPv6 options. + * + * Extract the DHCPv6 options (offset + length) so that we can later easily + * check for them or extract the contents. + */ +static err_t +dhcp6_parse_reply(struct pbuf *p, struct dhcp6 *dhcp6) +{ + u16_t offset; + u16_t offset_max; + u16_t options_idx; + struct dhcp6_msg *msg_in; + + LWIP_UNUSED_ARG(dhcp6); + + /* clear received options */ + dhcp6_clear_all_options(dhcp6); + msg_in = (struct dhcp6_msg *)p->payload; + + /* parse options */ + + options_idx = sizeof(struct dhcp6_msg); + /* parse options to the end of the received packet */ + offset_max = p->tot_len; + + offset = options_idx; + /* at least 4 byte to read? */ + while ((offset + 4 <= offset_max)) { + u8_t op_len_buf[4]; + u8_t *op_len; + u16_t op; + u16_t len; + u16_t val_offset = (u16_t)(offset + 4); + if (val_offset < offset) { + /* overflow */ + return ERR_BUF; + } + /* copy option + length, might be split accross pbufs */ + op_len = (u8_t *)pbuf_get_contiguous(p, op_len_buf, 4, 4, offset); + if (op_len == NULL) { + /* failed to get option and length */ + return ERR_VAL; + } + op = (op_len[0] << 8) | op_len[1]; + len = (op_len[2] << 8) | op_len[3]; + offset = val_offset + len; + if (offset < val_offset) { + /* overflow */ + return ERR_BUF; + } + + switch (op) { + case (DHCP6_OPTION_CLIENTID): + dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_CLI_ID); + dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_CLI_ID, val_offset, len); + break; + case (DHCP6_OPTION_SERVERID): + dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_SERVER_ID); + dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_SERVER_ID, val_offset, len); + break; +#if LWIP_DHCP6_PROVIDE_DNS_SERVERS + case (DHCP6_OPTION_DNS_SERVERS): + dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER); + dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_DNS_SERVER, val_offset, len); + break; + case (DHCP6_OPTION_DOMAIN_LIST): + dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_DOMAIN_LIST); + dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_DOMAIN_LIST, val_offset, len); + break; +#endif /* LWIP_DHCP6_PROVIDE_DNS_SERVERS */ +#if LWIP_DHCP6_GET_NTP_SRV + case (DHCP6_OPTION_SNTP_SERVERS): + dhcp6_got_option(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER); + dhcp6_set_option(dhcp6, DHCP6_OPTION_IDX_NTP_SERVER, val_offset, len); + break; +#endif /* LWIP_DHCP6_GET_NTP_SRV*/ + default: + LWIP_DEBUGF(DHCP6_DEBUG, ("skipping option %"U16_F" in options\n", op)); + LWIP_HOOK_DHCP6_PARSE_OPTION(ip_current_netif(), dhcp6, dhcp6->state, msg_in, + msg_in->msgtype, op, len, q, val_offset); + break; + } + } + return ERR_OK; +} + +static void +dhcp6_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) +{ + struct netif *netif = ip_current_input_netif(); + struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); + struct dhcp6_msg *reply_msg = (struct dhcp6_msg *)p->payload; + u8_t msg_type; + u32_t xid; + + LWIP_UNUSED_ARG(arg); + + /* Caught DHCPv6 message from netif that does not have DHCPv6 enabled? -> not interested */ + if ((dhcp6 == NULL) || (dhcp6->pcb_allocated == 0)) { + goto free_pbuf_and_return; + } + + LWIP_ERROR("invalid server address type", IP_IS_V6(addr), goto free_pbuf_and_return;); + + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_recv(pbuf = %p) from DHCPv6 server %s port %"U16_F"\n", (void *)p, + ipaddr_ntoa(addr), port)); + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("pbuf->len = %"U16_F"\n", p->len)); + LWIP_DEBUGF(DHCP6_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); + + if (p->len < sizeof(struct dhcp6_msg)) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, ("DHCPv6 reply message or pbuf too short\n")); + goto free_pbuf_and_return; + } + + /* match transaction ID against what we expected */ + xid = reply_msg->transaction_id[0] << 16; + xid |= reply_msg->transaction_id[1] << 8; + xid |= reply_msg->transaction_id[2]; + if (xid != dhcp6->xid) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, + ("transaction id mismatch reply_msg->xid(%"X32_F")!= dhcp6->xid(%"X32_F")\n", xid, dhcp6->xid)); + goto free_pbuf_and_return; + } + /* option fields could be unfold? */ + if (dhcp6_parse_reply(p, dhcp6) != ERR_OK) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("problem unfolding DHCPv6 message - too short on memory?\n")); + goto free_pbuf_and_return; + } + + /* read DHCP message type */ + msg_type = reply_msg->msgtype; + /* message type is DHCP6 REPLY? */ + if (msg_type == DHCP6_REPLY) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("DHCP6_REPLY received\n")); +#if LWIP_IPV6_DHCP6_STATELESS + /* in info-requesting state? */ + if (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG) { + dhcp6_set_state(dhcp6, DHCP6_STATE_STATELESS_IDLE, "dhcp6_recv"); + dhcp6_handle_config_reply(netif, p); + } else +#endif /* LWIP_IPV6_DHCP6_STATELESS */ + { + /* @todo: handle reply in other states? */ + } + } else { + /* @todo: handle other message types */ + } + +free_pbuf_and_return: + pbuf_free(p); +} + +/** + * A DHCPv6 request has timed out. + * + * The timer that was started with the DHCPv6 request has + * timed out, indicating no response was received in time. + */ +static void +dhcp6_timeout(struct netif *netif, struct dhcp6 *dhcp6) +{ + LWIP_DEBUGF(DHCP_DEBUG | LWIP_DBG_TRACE, ("dhcp6_timeout()\n")); + + LWIP_UNUSED_ARG(netif); + LWIP_UNUSED_ARG(dhcp6); + +#if LWIP_IPV6_DHCP6_STATELESS + /* back-off period has passed, or server selection timed out */ + if (dhcp6->state == DHCP6_STATE_REQUESTING_CONFIG) { + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE, ("dhcp6_timeout(): retrying information request\n")); + dhcp6_information_request(netif, dhcp6); + } +#endif /* LWIP_IPV6_DHCP6_STATELESS */ +} + +/** + * DHCPv6 timeout handling (this function must be called every 500ms, + * see @ref DHCP6_TIMER_MSECS). + * + * A DHCPv6 server is expected to respond within a short period of time. + * This timer checks whether an outstanding DHCPv6 request is timed out. + */ +void +dhcp6_tmr(void) +{ + struct netif *netif; + /* loop through netif's */ + NETIF_FOREACH(netif) { + struct dhcp6 *dhcp6 = netif_dhcp6_data(netif); + /* only act on DHCPv6 configured interfaces */ + if (dhcp6 != NULL) { + /* timer is active (non zero), and is about to trigger now */ + if (dhcp6->request_timeout > 1) { + dhcp6->request_timeout--; + } else if (dhcp6->request_timeout == 1) { + dhcp6->request_timeout--; + /* { dhcp6->request_timeout == 0 } */ + LWIP_DEBUGF(DHCP6_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("dhcp6_tmr(): request timeout\n")); + /* this client's request timeout triggered */ + dhcp6_timeout(netif, dhcp6); + } + } + } +} + +#endif /* LWIP_IPV6 && LWIP_IPV6_DHCP6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ethip6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ethip6.c index 0a616b6c..fec8b28a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ethip6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ethip6.c @@ -1,123 +1,123 @@ -/** - * @file - * - * Ethernet output for IPv6. Uses ND tables for link-layer addressing. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV6 && LWIP_ETHERNET - -#include "lwip/ethip6.h" -#include "lwip/nd6.h" -#include "lwip/pbuf.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/inet_chksum.h" -#include "lwip/netif.h" -#include "lwip/icmp6.h" -#include "lwip/prot/ethernet.h" -#include "netif/ethernet.h" - -#include - -/** - * Resolve and fill-in Ethernet address header for outgoing IPv6 packet. - * - * For IPv6 multicast, corresponding Ethernet addresses - * are selected and the packet is transmitted on the link. - * - * For unicast addresses, ask the ND6 module what to do. It will either let us - * send the the packet right away, or queue the packet for later itself, unless - * an error occurs. - * - * @todo anycast addresses - * - * @param netif The lwIP network interface which the IP packet will be sent on. - * @param q The pbuf(s) containing the IP packet to be sent. - * @param ip6addr The IP address of the packet destination. - * - * @return - * - ERR_OK or the return value of @ref nd6_get_next_hop_addr_or_queue. - */ -err_t -ethip6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr) -{ - struct eth_addr dest; - const u8_t *hwaddr; - err_t result; - - LWIP_ASSERT_CORE_LOCKED(); - - /* The destination IP address must be properly zoned from here on down. */ - IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif); - - /* multicast destination IP address? */ - if (ip6_addr_ismulticast(ip6addr)) { - /* Hash IP multicast address to MAC address.*/ - dest.addr[0] = 0x33; - dest.addr[1] = 0x33; - dest.addr[2] = ((const u8_t *)(&(ip6addr->addr[3])))[0]; - dest.addr[3] = ((const u8_t *)(&(ip6addr->addr[3])))[1]; - dest.addr[4] = ((const u8_t *)(&(ip6addr->addr[3])))[2]; - dest.addr[5] = ((const u8_t *)(&(ip6addr->addr[3])))[3]; - - /* Send out. */ - return ethernet_output(netif, q, (const struct eth_addr*)(netif->hwaddr), &dest, ETHTYPE_IPV6); - } - - /* We have a unicast destination IP address */ - /* @todo anycast? */ - - /* Ask ND6 what to do with the packet. */ - result = nd6_get_next_hop_addr_or_queue(netif, q, ip6addr, &hwaddr); - if (result != ERR_OK) { - return result; - } - - /* If no hardware address is returned, nd6 has queued the packet for later. */ - if (hwaddr == NULL) { - return ERR_OK; - } - - /* Send out the packet using the returned hardware address. */ - SMEMCPY(dest.addr, hwaddr, 6); - return ethernet_output(netif, q, (const struct eth_addr*)(netif->hwaddr), &dest, ETHTYPE_IPV6); -} - -#endif /* LWIP_IPV6 && LWIP_ETHERNET */ +/** + * @file + * + * Ethernet output for IPv6. Uses ND tables for link-layer addressing. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV6 && LWIP_ETHERNET + +#include "lwip/ethip6.h" +#include "lwip/nd6.h" +#include "lwip/pbuf.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/inet_chksum.h" +#include "lwip/netif.h" +#include "lwip/icmp6.h" +#include "lwip/prot/ethernet.h" +#include "netif/ethernet.h" + +#include + +/** + * Resolve and fill-in Ethernet address header for outgoing IPv6 packet. + * + * For IPv6 multicast, corresponding Ethernet addresses + * are selected and the packet is transmitted on the link. + * + * For unicast addresses, ask the ND6 module what to do. It will either let us + * send the the packet right away, or queue the packet for later itself, unless + * an error occurs. + * + * @todo anycast addresses + * + * @param netif The lwIP network interface which the IP packet will be sent on. + * @param q The pbuf(s) containing the IP packet to be sent. + * @param ip6addr The IP address of the packet destination. + * + * @return + * - ERR_OK or the return value of @ref nd6_get_next_hop_addr_or_queue. + */ +err_t +ethip6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr) +{ + struct eth_addr dest; + const u8_t *hwaddr; + err_t result; + + LWIP_ASSERT_CORE_LOCKED(); + + /* The destination IP address must be properly zoned from here on down. */ + IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif); + + /* multicast destination IP address? */ + if (ip6_addr_ismulticast(ip6addr)) { + /* Hash IP multicast address to MAC address.*/ + dest.addr[0] = 0x33; + dest.addr[1] = 0x33; + dest.addr[2] = ((const u8_t *)(&(ip6addr->addr[3])))[0]; + dest.addr[3] = ((const u8_t *)(&(ip6addr->addr[3])))[1]; + dest.addr[4] = ((const u8_t *)(&(ip6addr->addr[3])))[2]; + dest.addr[5] = ((const u8_t *)(&(ip6addr->addr[3])))[3]; + + /* Send out. */ + return ethernet_output(netif, q, (const struct eth_addr*)(netif->hwaddr), &dest, ETHTYPE_IPV6); + } + + /* We have a unicast destination IP address */ + /* @todo anycast? */ + + /* Ask ND6 what to do with the packet. */ + result = nd6_get_next_hop_addr_or_queue(netif, q, ip6addr, &hwaddr); + if (result != ERR_OK) { + return result; + } + + /* If no hardware address is returned, nd6 has queued the packet for later. */ + if (hwaddr == NULL) { + return ERR_OK; + } + + /* Send out the packet using the returned hardware address. */ + SMEMCPY(dest.addr, hwaddr, 6); + return ethernet_output(netif, q, (const struct eth_addr*)(netif->hwaddr), &dest, ETHTYPE_IPV6); +} + +#endif /* LWIP_IPV6 && LWIP_ETHERNET */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/icmp6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/icmp6.c index 7c936686..167738a0 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/icmp6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/icmp6.c @@ -1,425 +1,425 @@ -/** - * @file - * - * IPv6 version of ICMP, as per RFC 4443. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#include "lwip/opt.h" - -#if LWIP_ICMP6 && LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/icmp6.h" -#include "lwip/prot/icmp6.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/inet_chksum.h" -#include "lwip/pbuf.h" -#include "lwip/netif.h" -#include "lwip/nd6.h" -#include "lwip/mld6.h" -#include "lwip/ip.h" -#include "lwip/stats.h" - -#include - -#if LWIP_ICMP6_DATASIZE == 0 -#undef LWIP_ICMP6_DATASIZE -#define LWIP_ICMP6_DATASIZE 8 -#endif - -/* Forward declarations */ -static void icmp6_send_response(struct pbuf *p, u8_t code, u32_t data, u8_t type); -static void icmp6_send_response_with_addrs(struct pbuf *p, u8_t code, u32_t data, - u8_t type, const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr); -static void icmp6_send_response_with_addrs_and_netif(struct pbuf *p, u8_t code, u32_t data, - u8_t type, const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr, struct netif *netif); - - -/** - * Process an input ICMPv6 message. Called by ip6_input. - * - * Will generate a reply for echo requests. Other messages are forwarded - * to nd6_input, or mld6_input. - * - * @param p the mld packet, p->payload pointing to the icmpv6 header - * @param inp the netif on which this packet was received - */ -void -icmp6_input(struct pbuf *p, struct netif *inp) -{ - struct icmp6_hdr *icmp6hdr; - struct pbuf *r; - const ip6_addr_t *reply_src; - - ICMP6_STATS_INC(icmp6.recv); - - /* Check that ICMPv6 header fits in payload */ - if (p->len < sizeof(struct icmp6_hdr)) { - /* drop short packets */ - pbuf_free(p); - ICMP6_STATS_INC(icmp6.lenerr); - ICMP6_STATS_INC(icmp6.drop); - return; - } - - icmp6hdr = (struct icmp6_hdr *)p->payload; - -#if CHECKSUM_CHECK_ICMP6 - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_ICMP6) { - if (ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->tot_len, ip6_current_src_addr(), - ip6_current_dest_addr()) != 0) { - /* Checksum failed */ - pbuf_free(p); - ICMP6_STATS_INC(icmp6.chkerr); - ICMP6_STATS_INC(icmp6.drop); - return; - } - } -#endif /* CHECKSUM_CHECK_ICMP6 */ - - switch (icmp6hdr->type) { - case ICMP6_TYPE_NA: /* Neighbor advertisement */ - case ICMP6_TYPE_NS: /* Neighbor solicitation */ - case ICMP6_TYPE_RA: /* Router advertisement */ - case ICMP6_TYPE_RD: /* Redirect */ - case ICMP6_TYPE_PTB: /* Packet too big */ - nd6_input(p, inp); - return; - case ICMP6_TYPE_RS: -#if LWIP_IPV6_FORWARD - /* @todo implement router functionality */ -#endif - break; -#if LWIP_IPV6_MLD - case ICMP6_TYPE_MLQ: - case ICMP6_TYPE_MLR: - case ICMP6_TYPE_MLD: - mld6_input(p, inp); - return; -#endif - case ICMP6_TYPE_EREQ: -#if !LWIP_MULTICAST_PING - /* multicast destination address? */ - if (ip6_addr_ismulticast(ip6_current_dest_addr())) { - /* drop */ - pbuf_free(p); - ICMP6_STATS_INC(icmp6.drop); - return; - } -#endif /* LWIP_MULTICAST_PING */ - - /* Allocate reply. */ - r = pbuf_alloc(PBUF_IP, p->tot_len, PBUF_RAM); - if (r == NULL) { - /* drop */ - pbuf_free(p); - ICMP6_STATS_INC(icmp6.memerr); - return; - } - - /* Copy echo request. */ - if (pbuf_copy(r, p) != ERR_OK) { - /* drop */ - pbuf_free(p); - pbuf_free(r); - ICMP6_STATS_INC(icmp6.err); - return; - } - - /* Determine reply source IPv6 address. */ -#if LWIP_MULTICAST_PING - if (ip6_addr_ismulticast(ip6_current_dest_addr())) { - reply_src = ip_2_ip6(ip6_select_source_address(inp, ip6_current_src_addr())); - if (reply_src == NULL) { - /* drop */ - pbuf_free(p); - pbuf_free(r); - ICMP6_STATS_INC(icmp6.rterr); - return; - } - } - else -#endif /* LWIP_MULTICAST_PING */ - { - reply_src = ip6_current_dest_addr(); - } - - /* Set fields in reply. */ - ((struct icmp6_echo_hdr *)(r->payload))->type = ICMP6_TYPE_EREP; - ((struct icmp6_echo_hdr *)(r->payload))->chksum = 0; -#if CHECKSUM_GEN_ICMP6 - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_ICMP6) { - ((struct icmp6_echo_hdr *)(r->payload))->chksum = ip6_chksum_pseudo(r, - IP6_NEXTH_ICMP6, r->tot_len, reply_src, ip6_current_src_addr()); - } -#endif /* CHECKSUM_GEN_ICMP6 */ - - /* Send reply. */ - ICMP6_STATS_INC(icmp6.xmit); - ip6_output_if(r, reply_src, ip6_current_src_addr(), - LWIP_ICMP6_HL, 0, IP6_NEXTH_ICMP6, inp); - pbuf_free(r); - - break; - default: - ICMP6_STATS_INC(icmp6.proterr); - ICMP6_STATS_INC(icmp6.drop); - break; - } - - pbuf_free(p); -} - - -/** - * Send an icmpv6 'destination unreachable' packet. - * - * This function must be used only in direct response to a packet that is being - * received right now. Otherwise, address zones would be lost. - * - * @param p the input packet for which the 'unreachable' should be sent, - * p->payload pointing to the IPv6 header - * @param c ICMPv6 code for the unreachable type - */ -void -icmp6_dest_unreach(struct pbuf *p, enum icmp6_dur_code c) -{ - icmp6_send_response(p, c, 0, ICMP6_TYPE_DUR); -} - -/** - * Send an icmpv6 'packet too big' packet. - * - * This function must be used only in direct response to a packet that is being - * received right now. Otherwise, address zones would be lost. - * - * @param p the input packet for which the 'packet too big' should be sent, - * p->payload pointing to the IPv6 header - * @param mtu the maximum mtu that we can accept - */ -void -icmp6_packet_too_big(struct pbuf *p, u32_t mtu) -{ - icmp6_send_response(p, 0, mtu, ICMP6_TYPE_PTB); -} - -/** - * Send an icmpv6 'time exceeded' packet. - * - * This function must be used only in direct response to a packet that is being - * received right now. Otherwise, address zones would be lost. - * - * @param p the input packet for which the 'time exceeded' should be sent, - * p->payload pointing to the IPv6 header - * @param c ICMPv6 code for the time exceeded type - */ -void -icmp6_time_exceeded(struct pbuf *p, enum icmp6_te_code c) -{ - icmp6_send_response(p, c, 0, ICMP6_TYPE_TE); -} - -/** - * Send an icmpv6 'time exceeded' packet, with explicit source and destination - * addresses. - * - * This function may be used to send a response sometime after receiving the - * packet for which this response is meant. The provided source and destination - * addresses are used primarily to retain their zone information. - * - * @param p the input packet for which the 'time exceeded' should be sent, - * p->payload pointing to the IPv6 header - * @param c ICMPv6 code for the time exceeded type - * @param src_addr source address of the original packet, with zone information - * @param dest_addr destination address of the original packet, with zone - * information - */ -void -icmp6_time_exceeded_with_addrs(struct pbuf *p, enum icmp6_te_code c, - const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr) -{ - icmp6_send_response_with_addrs(p, c, 0, ICMP6_TYPE_TE, src_addr, dest_addr); -} - -/** - * Send an icmpv6 'parameter problem' packet. - * - * This function must be used only in direct response to a packet that is being - * received right now. Otherwise, address zones would be lost and the calculated - * offset would be wrong (calculated against ip6_current_header()). - * - * @param p the input packet for which the 'param problem' should be sent, - * p->payload pointing to the IP header - * @param c ICMPv6 code for the param problem type - * @param pointer the pointer to the byte where the parameter is found - */ -void -icmp6_param_problem(struct pbuf *p, enum icmp6_pp_code c, const void *pointer) -{ - u32_t pointer_u32 = (u32_t)((const u8_t *)pointer - (const u8_t *)ip6_current_header()); - icmp6_send_response(p, c, pointer_u32, ICMP6_TYPE_PP); -} - -/** - * Send an ICMPv6 packet in response to an incoming packet. - * The packet is sent *to* ip_current_src_addr() on ip_current_netif(). - * - * @param p the input packet for which the response should be sent, - * p->payload pointing to the IPv6 header - * @param code Code of the ICMPv6 header - * @param data Additional 32-bit parameter in the ICMPv6 header - * @param type Type of the ICMPv6 header - */ -static void -icmp6_send_response(struct pbuf *p, u8_t code, u32_t data, u8_t type) -{ - const struct ip6_addr *reply_src, *reply_dest; - struct netif *netif = ip_current_netif(); - - LWIP_ASSERT("icmpv6 packet not a direct response", netif != NULL); - reply_dest = ip6_current_src_addr(); - - /* Select an address to use as source. */ - reply_src = ip_2_ip6(ip6_select_source_address(netif, reply_dest)); - if (reply_src == NULL) { - ICMP6_STATS_INC(icmp6.rterr); - return; - } - icmp6_send_response_with_addrs_and_netif(p, code, data, type, reply_src, reply_dest, netif); -} - -/** - * Send an ICMPv6 packet in response to an incoming packet. - * - * Call this function if the packet is NOT sent as a direct response to an - * incoming packet, but rather sometime later (e.g. for a fragment reassembly - * timeout). The caller must provide the zoned source and destination addresses - * from the original packet with the src_addr and dest_addr parameters. The - * reason for this approach is that while the addresses themselves are part of - * the original packet, their zone information is not, thus possibly resulting - * in a link-local response being sent over the wrong link. - * - * @param p the input packet for which the response should be sent, - * p->payload pointing to the IPv6 header - * @param code Code of the ICMPv6 header - * @param data Additional 32-bit parameter in the ICMPv6 header - * @param type Type of the ICMPv6 header - * @param src_addr original source address - * @param dest_addr original destination address - */ -static void -icmp6_send_response_with_addrs(struct pbuf *p, u8_t code, u32_t data, u8_t type, - const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr) -{ - const struct ip6_addr *reply_src, *reply_dest; - struct netif *netif; - - /* Get the destination address and netif for this ICMP message. */ - LWIP_ASSERT("must provide both source and destination", src_addr != NULL); - LWIP_ASSERT("must provide both source and destination", dest_addr != NULL); - - /* Special case, as ip6_current_xxx is either NULL, or points - to a different packet than the one that expired. */ - IP6_ADDR_ZONECHECK(src_addr); - IP6_ADDR_ZONECHECK(dest_addr); - /* Swap source and destination for the reply. */ - reply_dest = src_addr; - reply_src = dest_addr; - netif = ip6_route(reply_src, reply_dest); - if (netif == NULL) { - ICMP6_STATS_INC(icmp6.rterr); - return; - } - icmp6_send_response_with_addrs_and_netif(p, code, data, type, reply_src, - reply_dest, netif); -} - -/** - * Send an ICMPv6 packet (with srd/dst address and netif given). - * - * @param p the input packet for which the response should be sent, - * p->payload pointing to the IPv6 header - * @param code Code of the ICMPv6 header - * @param data Additional 32-bit parameter in the ICMPv6 header - * @param type Type of the ICMPv6 header - * @param reply_src source address of the packet to send - * @param reply_dest destination address of the packet to send - * @param netif netif to send the packet - */ -static void -icmp6_send_response_with_addrs_and_netif(struct pbuf *p, u8_t code, u32_t data, u8_t type, - const ip6_addr_t *reply_src, const ip6_addr_t *reply_dest, struct netif *netif) -{ - struct pbuf *q; - struct icmp6_hdr *icmp6hdr; - - /* ICMPv6 header + IPv6 header + data */ - q = pbuf_alloc(PBUF_IP, sizeof(struct icmp6_hdr) + IP6_HLEN + LWIP_ICMP6_DATASIZE, - PBUF_RAM); - if (q == NULL) { - LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded: failed to allocate pbuf for ICMPv6 packet.\n")); - ICMP6_STATS_INC(icmp6.memerr); - return; - } - LWIP_ASSERT("check that first pbuf can hold icmp 6message", - (q->len >= (sizeof(struct icmp6_hdr) + IP6_HLEN + LWIP_ICMP6_DATASIZE))); - - icmp6hdr = (struct icmp6_hdr *)q->payload; - icmp6hdr->type = type; - icmp6hdr->code = code; - icmp6hdr->data = lwip_htonl(data); - - /* copy fields from original packet */ - SMEMCPY((u8_t *)q->payload + sizeof(struct icmp6_hdr), (u8_t *)p->payload, - IP6_HLEN + LWIP_ICMP6_DATASIZE); - - /* calculate checksum */ - icmp6hdr->chksum = 0; -#if CHECKSUM_GEN_ICMP6 - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { - icmp6hdr->chksum = ip6_chksum_pseudo(q, IP6_NEXTH_ICMP6, q->tot_len, - reply_src, reply_dest); - } -#endif /* CHECKSUM_GEN_ICMP6 */ - - ICMP6_STATS_INC(icmp6.xmit); - ip6_output_if(q, reply_src, reply_dest, LWIP_ICMP6_HL, 0, IP6_NEXTH_ICMP6, netif); - pbuf_free(q); -} - -#endif /* LWIP_ICMP6 && LWIP_IPV6 */ +/** + * @file + * + * IPv6 version of ICMP, as per RFC 4443. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#include "lwip/opt.h" + +#if LWIP_ICMP6 && LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/icmp6.h" +#include "lwip/prot/icmp6.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/inet_chksum.h" +#include "lwip/pbuf.h" +#include "lwip/netif.h" +#include "lwip/nd6.h" +#include "lwip/mld6.h" +#include "lwip/ip.h" +#include "lwip/stats.h" + +#include + +#if LWIP_ICMP6_DATASIZE == 0 +#undef LWIP_ICMP6_DATASIZE +#define LWIP_ICMP6_DATASIZE 8 +#endif + +/* Forward declarations */ +static void icmp6_send_response(struct pbuf *p, u8_t code, u32_t data, u8_t type); +static void icmp6_send_response_with_addrs(struct pbuf *p, u8_t code, u32_t data, + u8_t type, const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr); +static void icmp6_send_response_with_addrs_and_netif(struct pbuf *p, u8_t code, u32_t data, + u8_t type, const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr, struct netif *netif); + + +/** + * Process an input ICMPv6 message. Called by ip6_input. + * + * Will generate a reply for echo requests. Other messages are forwarded + * to nd6_input, or mld6_input. + * + * @param p the mld packet, p->payload pointing to the icmpv6 header + * @param inp the netif on which this packet was received + */ +void +icmp6_input(struct pbuf *p, struct netif *inp) +{ + struct icmp6_hdr *icmp6hdr; + struct pbuf *r; + const ip6_addr_t *reply_src; + + ICMP6_STATS_INC(icmp6.recv); + + /* Check that ICMPv6 header fits in payload */ + if (p->len < sizeof(struct icmp6_hdr)) { + /* drop short packets */ + pbuf_free(p); + ICMP6_STATS_INC(icmp6.lenerr); + ICMP6_STATS_INC(icmp6.drop); + return; + } + + icmp6hdr = (struct icmp6_hdr *)p->payload; + +#if CHECKSUM_CHECK_ICMP6 + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_ICMP6) { + if (ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->tot_len, ip6_current_src_addr(), + ip6_current_dest_addr()) != 0) { + /* Checksum failed */ + pbuf_free(p); + ICMP6_STATS_INC(icmp6.chkerr); + ICMP6_STATS_INC(icmp6.drop); + return; + } + } +#endif /* CHECKSUM_CHECK_ICMP6 */ + + switch (icmp6hdr->type) { + case ICMP6_TYPE_NA: /* Neighbor advertisement */ + case ICMP6_TYPE_NS: /* Neighbor solicitation */ + case ICMP6_TYPE_RA: /* Router advertisement */ + case ICMP6_TYPE_RD: /* Redirect */ + case ICMP6_TYPE_PTB: /* Packet too big */ + nd6_input(p, inp); + return; + case ICMP6_TYPE_RS: +#if LWIP_IPV6_FORWARD + /* @todo implement router functionality */ +#endif + break; +#if LWIP_IPV6_MLD + case ICMP6_TYPE_MLQ: + case ICMP6_TYPE_MLR: + case ICMP6_TYPE_MLD: + mld6_input(p, inp); + return; +#endif + case ICMP6_TYPE_EREQ: +#if !LWIP_MULTICAST_PING + /* multicast destination address? */ + if (ip6_addr_ismulticast(ip6_current_dest_addr())) { + /* drop */ + pbuf_free(p); + ICMP6_STATS_INC(icmp6.drop); + return; + } +#endif /* LWIP_MULTICAST_PING */ + + /* Allocate reply. */ + r = pbuf_alloc(PBUF_IP, p->tot_len, PBUF_RAM); + if (r == NULL) { + /* drop */ + pbuf_free(p); + ICMP6_STATS_INC(icmp6.memerr); + return; + } + + /* Copy echo request. */ + if (pbuf_copy(r, p) != ERR_OK) { + /* drop */ + pbuf_free(p); + pbuf_free(r); + ICMP6_STATS_INC(icmp6.err); + return; + } + + /* Determine reply source IPv6 address. */ +#if LWIP_MULTICAST_PING + if (ip6_addr_ismulticast(ip6_current_dest_addr())) { + reply_src = ip_2_ip6(ip6_select_source_address(inp, ip6_current_src_addr())); + if (reply_src == NULL) { + /* drop */ + pbuf_free(p); + pbuf_free(r); + ICMP6_STATS_INC(icmp6.rterr); + return; + } + } + else +#endif /* LWIP_MULTICAST_PING */ + { + reply_src = ip6_current_dest_addr(); + } + + /* Set fields in reply. */ + ((struct icmp6_echo_hdr *)(r->payload))->type = ICMP6_TYPE_EREP; + ((struct icmp6_echo_hdr *)(r->payload))->chksum = 0; +#if CHECKSUM_GEN_ICMP6 + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_GEN_ICMP6) { + ((struct icmp6_echo_hdr *)(r->payload))->chksum = ip6_chksum_pseudo(r, + IP6_NEXTH_ICMP6, r->tot_len, reply_src, ip6_current_src_addr()); + } +#endif /* CHECKSUM_GEN_ICMP6 */ + + /* Send reply. */ + ICMP6_STATS_INC(icmp6.xmit); + ip6_output_if(r, reply_src, ip6_current_src_addr(), + LWIP_ICMP6_HL, 0, IP6_NEXTH_ICMP6, inp); + pbuf_free(r); + + break; + default: + ICMP6_STATS_INC(icmp6.proterr); + ICMP6_STATS_INC(icmp6.drop); + break; + } + + pbuf_free(p); +} + + +/** + * Send an icmpv6 'destination unreachable' packet. + * + * This function must be used only in direct response to a packet that is being + * received right now. Otherwise, address zones would be lost. + * + * @param p the input packet for which the 'unreachable' should be sent, + * p->payload pointing to the IPv6 header + * @param c ICMPv6 code for the unreachable type + */ +void +icmp6_dest_unreach(struct pbuf *p, enum icmp6_dur_code c) +{ + icmp6_send_response(p, c, 0, ICMP6_TYPE_DUR); +} + +/** + * Send an icmpv6 'packet too big' packet. + * + * This function must be used only in direct response to a packet that is being + * received right now. Otherwise, address zones would be lost. + * + * @param p the input packet for which the 'packet too big' should be sent, + * p->payload pointing to the IPv6 header + * @param mtu the maximum mtu that we can accept + */ +void +icmp6_packet_too_big(struct pbuf *p, u32_t mtu) +{ + icmp6_send_response(p, 0, mtu, ICMP6_TYPE_PTB); +} + +/** + * Send an icmpv6 'time exceeded' packet. + * + * This function must be used only in direct response to a packet that is being + * received right now. Otherwise, address zones would be lost. + * + * @param p the input packet for which the 'time exceeded' should be sent, + * p->payload pointing to the IPv6 header + * @param c ICMPv6 code for the time exceeded type + */ +void +icmp6_time_exceeded(struct pbuf *p, enum icmp6_te_code c) +{ + icmp6_send_response(p, c, 0, ICMP6_TYPE_TE); +} + +/** + * Send an icmpv6 'time exceeded' packet, with explicit source and destination + * addresses. + * + * This function may be used to send a response sometime after receiving the + * packet for which this response is meant. The provided source and destination + * addresses are used primarily to retain their zone information. + * + * @param p the input packet for which the 'time exceeded' should be sent, + * p->payload pointing to the IPv6 header + * @param c ICMPv6 code for the time exceeded type + * @param src_addr source address of the original packet, with zone information + * @param dest_addr destination address of the original packet, with zone + * information + */ +void +icmp6_time_exceeded_with_addrs(struct pbuf *p, enum icmp6_te_code c, + const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr) +{ + icmp6_send_response_with_addrs(p, c, 0, ICMP6_TYPE_TE, src_addr, dest_addr); +} + +/** + * Send an icmpv6 'parameter problem' packet. + * + * This function must be used only in direct response to a packet that is being + * received right now. Otherwise, address zones would be lost and the calculated + * offset would be wrong (calculated against ip6_current_header()). + * + * @param p the input packet for which the 'param problem' should be sent, + * p->payload pointing to the IP header + * @param c ICMPv6 code for the param problem type + * @param pointer the pointer to the byte where the parameter is found + */ +void +icmp6_param_problem(struct pbuf *p, enum icmp6_pp_code c, const void *pointer) +{ + u32_t pointer_u32 = (u32_t)((const u8_t *)pointer - (const u8_t *)ip6_current_header()); + icmp6_send_response(p, c, pointer_u32, ICMP6_TYPE_PP); +} + +/** + * Send an ICMPv6 packet in response to an incoming packet. + * The packet is sent *to* ip_current_src_addr() on ip_current_netif(). + * + * @param p the input packet for which the response should be sent, + * p->payload pointing to the IPv6 header + * @param code Code of the ICMPv6 header + * @param data Additional 32-bit parameter in the ICMPv6 header + * @param type Type of the ICMPv6 header + */ +static void +icmp6_send_response(struct pbuf *p, u8_t code, u32_t data, u8_t type) +{ + const struct ip6_addr *reply_src, *reply_dest; + struct netif *netif = ip_current_netif(); + + LWIP_ASSERT("icmpv6 packet not a direct response", netif != NULL); + reply_dest = ip6_current_src_addr(); + + /* Select an address to use as source. */ + reply_src = ip_2_ip6(ip6_select_source_address(netif, reply_dest)); + if (reply_src == NULL) { + ICMP6_STATS_INC(icmp6.rterr); + return; + } + icmp6_send_response_with_addrs_and_netif(p, code, data, type, reply_src, reply_dest, netif); +} + +/** + * Send an ICMPv6 packet in response to an incoming packet. + * + * Call this function if the packet is NOT sent as a direct response to an + * incoming packet, but rather sometime later (e.g. for a fragment reassembly + * timeout). The caller must provide the zoned source and destination addresses + * from the original packet with the src_addr and dest_addr parameters. The + * reason for this approach is that while the addresses themselves are part of + * the original packet, their zone information is not, thus possibly resulting + * in a link-local response being sent over the wrong link. + * + * @param p the input packet for which the response should be sent, + * p->payload pointing to the IPv6 header + * @param code Code of the ICMPv6 header + * @param data Additional 32-bit parameter in the ICMPv6 header + * @param type Type of the ICMPv6 header + * @param src_addr original source address + * @param dest_addr original destination address + */ +static void +icmp6_send_response_with_addrs(struct pbuf *p, u8_t code, u32_t data, u8_t type, + const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr) +{ + const struct ip6_addr *reply_src, *reply_dest; + struct netif *netif; + + /* Get the destination address and netif for this ICMP message. */ + LWIP_ASSERT("must provide both source and destination", src_addr != NULL); + LWIP_ASSERT("must provide both source and destination", dest_addr != NULL); + + /* Special case, as ip6_current_xxx is either NULL, or points + to a different packet than the one that expired. */ + IP6_ADDR_ZONECHECK(src_addr); + IP6_ADDR_ZONECHECK(dest_addr); + /* Swap source and destination for the reply. */ + reply_dest = src_addr; + reply_src = dest_addr; + netif = ip6_route(reply_src, reply_dest); + if (netif == NULL) { + ICMP6_STATS_INC(icmp6.rterr); + return; + } + icmp6_send_response_with_addrs_and_netif(p, code, data, type, reply_src, + reply_dest, netif); +} + +/** + * Send an ICMPv6 packet (with srd/dst address and netif given). + * + * @param p the input packet for which the response should be sent, + * p->payload pointing to the IPv6 header + * @param code Code of the ICMPv6 header + * @param data Additional 32-bit parameter in the ICMPv6 header + * @param type Type of the ICMPv6 header + * @param reply_src source address of the packet to send + * @param reply_dest destination address of the packet to send + * @param netif netif to send the packet + */ +static void +icmp6_send_response_with_addrs_and_netif(struct pbuf *p, u8_t code, u32_t data, u8_t type, + const ip6_addr_t *reply_src, const ip6_addr_t *reply_dest, struct netif *netif) +{ + struct pbuf *q; + struct icmp6_hdr *icmp6hdr; + + /* ICMPv6 header + IPv6 header + data */ + q = pbuf_alloc(PBUF_IP, sizeof(struct icmp6_hdr) + IP6_HLEN + LWIP_ICMP6_DATASIZE, + PBUF_RAM); + if (q == NULL) { + LWIP_DEBUGF(ICMP_DEBUG, ("icmp_time_exceeded: failed to allocate pbuf for ICMPv6 packet.\n")); + ICMP6_STATS_INC(icmp6.memerr); + return; + } + LWIP_ASSERT("check that first pbuf can hold icmp 6message", + (q->len >= (sizeof(struct icmp6_hdr) + IP6_HLEN + LWIP_ICMP6_DATASIZE))); + + icmp6hdr = (struct icmp6_hdr *)q->payload; + icmp6hdr->type = type; + icmp6hdr->code = code; + icmp6hdr->data = lwip_htonl(data); + + /* copy fields from original packet */ + SMEMCPY((u8_t *)q->payload + sizeof(struct icmp6_hdr), (u8_t *)p->payload, + IP6_HLEN + LWIP_ICMP6_DATASIZE); + + /* calculate checksum */ + icmp6hdr->chksum = 0; +#if CHECKSUM_GEN_ICMP6 + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { + icmp6hdr->chksum = ip6_chksum_pseudo(q, IP6_NEXTH_ICMP6, q->tot_len, + reply_src, reply_dest); + } +#endif /* CHECKSUM_GEN_ICMP6 */ + + ICMP6_STATS_INC(icmp6.xmit); + ip6_output_if(q, reply_src, reply_dest, LWIP_ICMP6_HL, 0, IP6_NEXTH_ICMP6, netif); + pbuf_free(q); +} + +#endif /* LWIP_ICMP6 && LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/inet6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/inet6.c index 7cb16aad..d9a992c2 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/inet6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/inet6.c @@ -1,53 +1,53 @@ -/** - * @file - * - * INET v6 addresses. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV6 && LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/def.h" -#include "lwip/inet.h" - -/** This variable is initialized by the system to contain the wildcard IPv6 address. - */ -const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; - -#endif /* LWIP_IPV6 */ +/** + * @file + * + * INET v6 addresses. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV6 && LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/def.h" +#include "lwip/inet.h" + +/** This variable is initialized by the system to contain the wildcard IPv6 address. + */ +const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; + +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6.c index b0906a39..eda11dc8 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6.c @@ -1,1492 +1,1492 @@ -/** - * @file - * - * IPv6 layer. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/def.h" -#include "lwip/mem.h" -#include "lwip/netif.h" -#include "lwip/ip.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/ip6_frag.h" -#include "lwip/icmp6.h" -#include "lwip/priv/raw_priv.h" -#include "lwip/udp.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/dhcp6.h" -#include "lwip/nd6.h" -#include "lwip/mld6.h" -#include "lwip/debug.h" -#include "lwip/stats.h" - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -/** - * Finds the appropriate network interface for a given IPv6 address. It tries to select - * a netif following a sequence of heuristics: - * 1) if there is only 1 netif, return it - * 2) if the destination is a zoned address, match its zone to a netif - * 3) if the either the source or destination address is a scoped address, - * match the source address's zone (if set) or address (if not) to a netif - * 4) tries to match the destination subnet to a configured address - * 5) tries to find a router-announced route - * 6) tries to match the (unscoped) source address to the netif - * 7) returns the default netif, if configured - * - * Note that each of the two given addresses may or may not be properly zoned. - * - * @param src the source IPv6 address, if known - * @param dest the destination IPv6 address for which to find the route - * @return the netif on which to send to reach dest - */ -struct netif * -ip6_route(const ip6_addr_t *src, const ip6_addr_t *dest) -{ -#if LWIP_SINGLE_NETIF - LWIP_UNUSED_ARG(src); - LWIP_UNUSED_ARG(dest); -#else /* LWIP_SINGLE_NETIF */ - struct netif *netif; - s8_t i; - - LWIP_ASSERT_CORE_LOCKED(); - - /* If single netif configuration, fast return. */ - if ((netif_list != NULL) && (netif_list->next == NULL)) { - if (!netif_is_up(netif_list) || !netif_is_link_up(netif_list) || - (ip6_addr_has_zone(dest) && !ip6_addr_test_zone(dest, netif_list))) { - return NULL; - } - return netif_list; - } - -#if LWIP_IPV6_SCOPES - /* Special processing for zoned destination addresses. This includes link- - * local unicast addresses and interface/link-local multicast addresses. Use - * the zone to find a matching netif. If the address is not zoned, then there - * is technically no "wrong" netif to choose, and we leave routing to other - * rules; in most cases this should be the scoped-source rule below. */ - if (ip6_addr_has_zone(dest)) { - IP6_ADDR_ZONECHECK(dest); - /* Find a netif based on the zone. For custom mappings, one zone may map - * to multiple netifs, so find one that can actually send a packet. */ - NETIF_FOREACH(netif) { - if (ip6_addr_test_zone(dest, netif) && - netif_is_up(netif) && netif_is_link_up(netif)) { - return netif; - } - } - /* No matching netif found. Do no try to route to a different netif, - * as that would be a zone violation, resulting in any packets sent to - * that netif being dropped on output. */ - return NULL; - } -#endif /* LWIP_IPV6_SCOPES */ - - /* Special processing for scoped source and destination addresses. If we get - * here, the destination address does not have a zone, so either way we need - * to look at the source address, which may or may not have a zone. If it - * does, the zone is restrictive: there is (typically) only one matching - * netif for it, and we should avoid routing to any other netif as that would - * result in guaranteed zone violations. For scoped source addresses that do - * not have a zone, use (only) a netif that has that source address locally - * assigned. This case also applies to the loopback source address, which has - * an implied link-local scope. If only the destination address is scoped - * (but, again, not zoned), we still want to use only the source address to - * determine its zone because that's most likely what the user/application - * wants, regardless of whether the source address is scoped. Finally, some - * of this story also applies if scoping is disabled altogether. */ -#if LWIP_IPV6_SCOPES - if (ip6_addr_has_scope(dest, IP6_UNKNOWN) || - ip6_addr_has_scope(src, IP6_UNICAST) || -#else /* LWIP_IPV6_SCOPES */ - if (ip6_addr_islinklocal(dest) || ip6_addr_ismulticast_iflocal(dest) || - ip6_addr_ismulticast_linklocal(dest) || ip6_addr_islinklocal(src) || -#endif /* LWIP_IPV6_SCOPES */ - ip6_addr_isloopback(src)) { -#if LWIP_IPV6_SCOPES - if (ip6_addr_has_zone(src)) { - /* Find a netif matching the source zone (relatively cheap). */ - NETIF_FOREACH(netif) { - if (netif_is_up(netif) && netif_is_link_up(netif) && - ip6_addr_test_zone(src, netif)) { - return netif; - } - } - } else -#endif /* LWIP_IPV6_SCOPES */ - { - /* Find a netif matching the source address (relatively expensive). */ - NETIF_FOREACH(netif) { - if (!netif_is_up(netif) || !netif_is_link_up(netif)) { - continue; - } - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && - ip6_addr_cmp_zoneless(src, netif_ip6_addr(netif, i))) { - return netif; - } - } - } - } - /* Again, do not use any other netif in this case, as that could result in - * zone boundary violations. */ - return NULL; - } - - /* We come here only if neither source nor destination is scoped. */ - IP6_ADDR_ZONECHECK(src); - -#ifdef LWIP_HOOK_IP6_ROUTE - netif = LWIP_HOOK_IP6_ROUTE(src, dest); - if (netif != NULL) { - return netif; - } -#endif - - /* See if the destination subnet matches a configured address. In accordance - * with RFC 5942, dynamically configured addresses do not have an implied - * local subnet, and thus should be considered /128 assignments. However, as - * such, the destination address may still match a local address, and so we - * still need to check for exact matches here. By (lwIP) policy, statically - * configured addresses do always have an implied local /64 subnet. */ - NETIF_FOREACH(netif) { - if (!netif_is_up(netif) || !netif_is_link_up(netif)) { - continue; - } - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && - ip6_addr_netcmp(dest, netif_ip6_addr(netif, i)) && - (netif_ip6_addr_isstatic(netif, i) || - ip6_addr_nethostcmp(dest, netif_ip6_addr(netif, i)))) { - return netif; - } - } - } - - /* Get the netif for a suitable router-announced route. */ - netif = nd6_find_route(dest); - if (netif != NULL) { - return netif; - } - - /* Try with the netif that matches the source address. Given the earlier rule - * for scoped source addresses, this applies to unscoped addresses only. */ - if (!ip6_addr_isany(src)) { - NETIF_FOREACH(netif) { - if (!netif_is_up(netif) || !netif_is_link_up(netif)) { - continue; - } - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && - ip6_addr_cmp(src, netif_ip6_addr(netif, i))) { - return netif; - } - } - } - } - -#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF - /* loopif is disabled, loopback traffic is passed through any netif */ - if (ip6_addr_isloopback(dest)) { - /* don't check for link on loopback traffic */ - if (netif_default != NULL && netif_is_up(netif_default)) { - return netif_default; - } - /* default netif is not up, just use any netif for loopback traffic */ - NETIF_FOREACH(netif) { - if (netif_is_up(netif)) { - return netif; - } - } - return NULL; - } -#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */ -#endif /* !LWIP_SINGLE_NETIF */ - - /* no matching netif found, use default netif, if up */ - if ((netif_default == NULL) || !netif_is_up(netif_default) || !netif_is_link_up(netif_default)) { - return NULL; - } - return netif_default; -} - -/** - * @ingroup ip6 - * Select the best IPv6 source address for a given destination IPv6 address. - * - * This implementation follows RFC 6724 Sec. 5 to the following extent: - * - Rules 1, 2, 3: fully implemented - * - Rules 4, 5, 5.5: not applicable - * - Rule 6: not implemented - * - Rule 7: not applicable - * - Rule 8: limited to "prefer /64 subnet match over non-match" - * - * For Rule 2, we deliberately deviate from RFC 6724 Sec. 3.1 by considering - * ULAs to be of smaller scope than global addresses, to avoid that a preferred - * ULA is picked over a deprecated global address when given a global address - * as destination, as that would likely result in broken two-way communication. - * - * As long as temporary addresses are not supported (as used in Rule 7), a - * proper implementation of Rule 8 would obviate the need to implement Rule 6. - * - * @param netif the netif on which to send a packet - * @param dest the destination we are trying to reach (possibly not properly - * zoned) - * @return the most suitable source address to use, or NULL if no suitable - * source address is found - */ -const ip_addr_t * -ip6_select_source_address(struct netif *netif, const ip6_addr_t *dest) -{ - const ip_addr_t *best_addr; - const ip6_addr_t *cand_addr; - s8_t dest_scope, cand_scope; - s8_t best_scope = IP6_MULTICAST_SCOPE_RESERVED; - u8_t i, cand_pref, cand_bits; - u8_t best_pref = 0; - u8_t best_bits = 0; - - /* Start by determining the scope of the given destination address. These - * tests are hopefully (roughly) in order of likeliness to match. */ - if (ip6_addr_isglobal(dest)) { - dest_scope = IP6_MULTICAST_SCOPE_GLOBAL; - } else if (ip6_addr_islinklocal(dest) || ip6_addr_isloopback(dest)) { - dest_scope = IP6_MULTICAST_SCOPE_LINK_LOCAL; - } else if (ip6_addr_isuniquelocal(dest)) { - dest_scope = IP6_MULTICAST_SCOPE_ORGANIZATION_LOCAL; - } else if (ip6_addr_ismulticast(dest)) { - dest_scope = ip6_addr_multicast_scope(dest); - } else if (ip6_addr_issitelocal(dest)) { - dest_scope = IP6_MULTICAST_SCOPE_SITE_LOCAL; - } else { - /* no match, consider scope global */ - dest_scope = IP6_MULTICAST_SCOPE_GLOBAL; - } - - best_addr = NULL; - - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - /* Consider only valid (= preferred and deprecated) addresses. */ - if (!ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { - continue; - } - /* Determine the scope of this candidate address. Same ordering idea. */ - cand_addr = netif_ip6_addr(netif, i); - if (ip6_addr_isglobal(cand_addr)) { - cand_scope = IP6_MULTICAST_SCOPE_GLOBAL; - } else if (ip6_addr_islinklocal(cand_addr)) { - cand_scope = IP6_MULTICAST_SCOPE_LINK_LOCAL; - } else if (ip6_addr_isuniquelocal(cand_addr)) { - cand_scope = IP6_MULTICAST_SCOPE_ORGANIZATION_LOCAL; - } else if (ip6_addr_issitelocal(cand_addr)) { - cand_scope = IP6_MULTICAST_SCOPE_SITE_LOCAL; - } else { - /* no match, treat as low-priority global scope */ - cand_scope = IP6_MULTICAST_SCOPE_RESERVEDF; - } - cand_pref = ip6_addr_ispreferred(netif_ip6_addr_state(netif, i)); - /* @todo compute the actual common bits, for longest matching prefix. */ - /* We cannot count on the destination address having a proper zone - * assignment, so do not compare zones in this case. */ - cand_bits = ip6_addr_netcmp_zoneless(cand_addr, dest); /* just 1 or 0 for now */ - if (cand_bits && ip6_addr_nethostcmp(cand_addr, dest)) { - return netif_ip_addr6(netif, i); /* Rule 1 */ - } - if ((best_addr == NULL) || /* no alternative yet */ - ((cand_scope < best_scope) && (cand_scope >= dest_scope)) || - ((cand_scope > best_scope) && (best_scope < dest_scope)) || /* Rule 2 */ - ((cand_scope == best_scope) && ((cand_pref > best_pref) || /* Rule 3 */ - ((cand_pref == best_pref) && (cand_bits > best_bits))))) { /* Rule 8 */ - /* We found a new "winning" candidate. */ - best_addr = netif_ip_addr6(netif, i); - best_scope = cand_scope; - best_pref = cand_pref; - best_bits = cand_bits; - } - } - - return best_addr; /* may be NULL */ -} - -#if LWIP_IPV6_FORWARD -/** - * Forwards an IPv6 packet. It finds an appropriate route for the - * packet, decrements the HL value of the packet, and outputs - * the packet on the appropriate interface. - * - * @param p the packet to forward (p->payload points to IP header) - * @param iphdr the IPv6 header of the input packet - * @param inp the netif on which this packet was received - */ -static void -ip6_forward(struct pbuf *p, struct ip6_hdr *iphdr, struct netif *inp) -{ - struct netif *netif; - - /* do not forward link-local or loopback addresses */ - if (ip6_addr_islinklocal(ip6_current_dest_addr()) || - ip6_addr_isloopback(ip6_current_dest_addr())) { - LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not forwarding link-local address.\n")); - IP6_STATS_INC(ip6.rterr); - IP6_STATS_INC(ip6.drop); - return; - } - - /* Find network interface where to forward this IP packet to. */ - netif = ip6_route(IP6_ADDR_ANY6, ip6_current_dest_addr()); - if (netif == NULL) { - LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", - IP6_ADDR_BLOCK1(ip6_current_dest_addr()), - IP6_ADDR_BLOCK2(ip6_current_dest_addr()), - IP6_ADDR_BLOCK3(ip6_current_dest_addr()), - IP6_ADDR_BLOCK4(ip6_current_dest_addr()), - IP6_ADDR_BLOCK5(ip6_current_dest_addr()), - IP6_ADDR_BLOCK6(ip6_current_dest_addr()), - IP6_ADDR_BLOCK7(ip6_current_dest_addr()), - IP6_ADDR_BLOCK8(ip6_current_dest_addr()))); -#if LWIP_ICMP6 - /* Don't send ICMP messages in response to ICMP messages */ - if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) { - icmp6_dest_unreach(p, ICMP6_DUR_NO_ROUTE); - } -#endif /* LWIP_ICMP6 */ - IP6_STATS_INC(ip6.rterr); - IP6_STATS_INC(ip6.drop); - return; - } -#if LWIP_IPV6_SCOPES - /* Do not forward packets with a zoned (e.g., link-local) source address - * outside of their zone. We determined the zone a bit earlier, so we know - * that the address is properly zoned here, so we can safely use has_zone. - * Also skip packets with a loopback source address (link-local implied). */ - if ((ip6_addr_has_zone(ip6_current_src_addr()) && - !ip6_addr_test_zone(ip6_current_src_addr(), netif)) || - ip6_addr_isloopback(ip6_current_src_addr())) { - LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not forwarding packet beyond its source address zone.\n")); - IP6_STATS_INC(ip6.rterr); - IP6_STATS_INC(ip6.drop); - return; - } -#endif /* LWIP_IPV6_SCOPES */ - /* Do not forward packets onto the same network interface on which - * they arrived. */ - if (netif == inp) { - LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not bouncing packets back on incoming interface.\n")); - IP6_STATS_INC(ip6.rterr); - IP6_STATS_INC(ip6.drop); - return; - } - - /* decrement HL */ - IP6H_HOPLIM_SET(iphdr, IP6H_HOPLIM(iphdr) - 1); - /* send ICMP6 if HL == 0 */ - if (IP6H_HOPLIM(iphdr) == 0) { -#if LWIP_ICMP6 - /* Don't send ICMP messages in response to ICMP messages */ - if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) { - icmp6_time_exceeded(p, ICMP6_TE_HL); - } -#endif /* LWIP_ICMP6 */ - IP6_STATS_INC(ip6.drop); - return; - } - - if (netif->mtu && (p->tot_len > netif->mtu)) { -#if LWIP_ICMP6 - /* Don't send ICMP messages in response to ICMP messages */ - if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) { - icmp6_packet_too_big(p, netif->mtu); - } -#endif /* LWIP_ICMP6 */ - IP6_STATS_INC(ip6.drop); - return; - } - - LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: forwarding packet to %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", - IP6_ADDR_BLOCK1(ip6_current_dest_addr()), - IP6_ADDR_BLOCK2(ip6_current_dest_addr()), - IP6_ADDR_BLOCK3(ip6_current_dest_addr()), - IP6_ADDR_BLOCK4(ip6_current_dest_addr()), - IP6_ADDR_BLOCK5(ip6_current_dest_addr()), - IP6_ADDR_BLOCK6(ip6_current_dest_addr()), - IP6_ADDR_BLOCK7(ip6_current_dest_addr()), - IP6_ADDR_BLOCK8(ip6_current_dest_addr()))); - - /* transmit pbuf on chosen interface */ - netif->output_ip6(netif, p, ip6_current_dest_addr()); - IP6_STATS_INC(ip6.fw); - IP6_STATS_INC(ip6.xmit); - return; -} -#endif /* LWIP_IPV6_FORWARD */ - -/** Return true if the current input packet should be accepted on this netif */ -static int -ip6_input_accept(struct netif *netif) -{ - /* interface is up? */ - if (netif_is_up(netif)) { - u8_t i; - /* unicast to this interface address? address configured? */ - /* If custom scopes are used, the destination zone will be tested as - * part of the local-address comparison, but we need to test the source - * scope as well (e.g., is this interface on the same link?). */ - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && - ip6_addr_cmp(ip6_current_dest_addr(), netif_ip6_addr(netif, i)) -#if IPV6_CUSTOM_SCOPES - && (!ip6_addr_has_zone(ip6_current_src_addr()) || - ip6_addr_test_zone(ip6_current_src_addr(), netif)) -#endif /* IPV6_CUSTOM_SCOPES */ - ) { - /* accept on this netif */ - return 1; - } - } - } - return 0; -} - -/** - * This function is called by the network interface device driver when - * an IPv6 packet is received. The function does the basic checks of the - * IP header such as packet size being at least larger than the header - * size etc. If the packet was not destined for us, the packet is - * forwarded (using ip6_forward). - * - * Finally, the packet is sent to the upper layer protocol input function. - * - * @param p the received IPv6 packet (p->payload points to IPv6 header) - * @param inp the netif on which this packet was received - * @return ERR_OK if the packet was processed (could return ERR_* if it wasn't - * processed, but currently always returns ERR_OK) - */ -err_t -ip6_input(struct pbuf *p, struct netif *inp) -{ - struct ip6_hdr *ip6hdr; - struct netif *netif; - const u8_t *nexth; - u16_t hlen, hlen_tot; /* the current header length */ -#if 0 /*IP_ACCEPT_LINK_LAYER_ADDRESSING*/ - @todo - int check_ip_src=1; -#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */ -#if LWIP_RAW - raw_input_state_t raw_status; -#endif /* LWIP_RAW */ - - LWIP_ASSERT_CORE_LOCKED(); - - IP6_STATS_INC(ip6.recv); - - /* identify the IP header */ - ip6hdr = (struct ip6_hdr *)p->payload; - if (IP6H_V(ip6hdr) != 6) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IPv6 packet dropped due to bad version number %"U32_F"\n", - IP6H_V(ip6hdr))); - pbuf_free(p); - IP6_STATS_INC(ip6.err); - IP6_STATS_INC(ip6.drop); - return ERR_OK; - } - -#ifdef LWIP_HOOK_IP6_INPUT - if (LWIP_HOOK_IP6_INPUT(p, inp)) { - /* the packet has been eaten */ - return ERR_OK; - } -#endif - - /* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */ - if ((IP6_HLEN > p->len) || (IP6H_PLEN(ip6hdr) > (p->tot_len - IP6_HLEN))) { - if (IP6_HLEN > p->len) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IPv6 header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n", - (u16_t)IP6_HLEN, p->len)); - } - if ((IP6H_PLEN(ip6hdr) + IP6_HLEN) > p->tot_len) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IPv6 (plen %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n", - (u16_t)(IP6H_PLEN(ip6hdr) + IP6_HLEN), p->tot_len)); - } - /* free (drop) packet pbufs */ - pbuf_free(p); - IP6_STATS_INC(ip6.lenerr); - IP6_STATS_INC(ip6.drop); - return ERR_OK; - } - - /* Trim pbuf. This should have been done at the netif layer, - * but we'll do it anyway just to be sure that its done. */ - pbuf_realloc(p, (u16_t)(IP6_HLEN + IP6H_PLEN(ip6hdr))); - - /* copy IP addresses to aligned ip6_addr_t */ - ip_addr_copy_from_ip6_packed(ip_data.current_iphdr_dest, ip6hdr->dest); - ip_addr_copy_from_ip6_packed(ip_data.current_iphdr_src, ip6hdr->src); - - /* Don't accept virtual IPv4 mapped IPv6 addresses. - * Don't accept multicast source addresses. */ - if (ip6_addr_isipv4mappedipv6(ip_2_ip6(&ip_data.current_iphdr_dest)) || - ip6_addr_isipv4mappedipv6(ip_2_ip6(&ip_data.current_iphdr_src)) || - ip6_addr_ismulticast(ip_2_ip6(&ip_data.current_iphdr_src))) { - /* free (drop) packet pbufs */ - pbuf_free(p); - IP6_STATS_INC(ip6.err); - IP6_STATS_INC(ip6.drop); - return ERR_OK; - } - - /* Set the appropriate zone identifier on the addresses. */ - ip6_addr_assign_zone(ip_2_ip6(&ip_data.current_iphdr_dest), IP6_UNKNOWN, inp); - ip6_addr_assign_zone(ip_2_ip6(&ip_data.current_iphdr_src), IP6_UNICAST, inp); - - /* current header pointer. */ - ip_data.current_ip6_header = ip6hdr; - - /* In netif, used in case we need to send ICMPv6 packets back. */ - ip_data.current_netif = inp; - ip_data.current_input_netif = inp; - - /* match packet against an interface, i.e. is this packet for us? */ - if (ip6_addr_ismulticast(ip6_current_dest_addr())) { - /* Always joined to multicast if-local and link-local all-nodes group. */ - if (ip6_addr_isallnodes_iflocal(ip6_current_dest_addr()) || - ip6_addr_isallnodes_linklocal(ip6_current_dest_addr())) { - netif = inp; - } -#if LWIP_IPV6_MLD - else if (mld6_lookfor_group(inp, ip6_current_dest_addr())) { - netif = inp; - } -#else /* LWIP_IPV6_MLD */ - else if (ip6_addr_issolicitednode(ip6_current_dest_addr())) { - u8_t i; - /* Filter solicited node packets when MLD is not enabled - * (for Neighbor discovery). */ - netif = NULL; - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(inp, i)) && - ip6_addr_cmp_solicitednode(ip6_current_dest_addr(), netif_ip6_addr(inp, i))) { - netif = inp; - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: solicited node packet accepted on interface %c%c\n", - netif->name[0], netif->name[1])); - break; - } - } - } -#endif /* LWIP_IPV6_MLD */ - else { - netif = NULL; - } - } else { - /* start trying with inp. if that's not acceptable, start walking the - list of configured netifs. */ - if (ip6_input_accept(inp)) { - netif = inp; - } else { - netif = NULL; -#if !IPV6_CUSTOM_SCOPES - /* Shortcut: stop looking for other interfaces if either the source or - * the destination has a scope constrained to this interface. Custom - * scopes may break the 1:1 link/interface mapping, however. */ - if (ip6_addr_islinklocal(ip6_current_dest_addr()) || - ip6_addr_islinklocal(ip6_current_src_addr())) { - goto netif_found; - } -#endif /* !IPV6_CUSTOM_SCOPES */ -#if !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF - /* The loopback address is to be considered link-local. Packets to it - * should be dropped on other interfaces, as per RFC 4291 Sec. 2.5.3. - * Its implied scope means packets *from* the loopback address should - * not be accepted on other interfaces, either. These requirements - * cannot be implemented in the case that loopback traffic is sent - * across a non-loopback interface, however. */ - if (ip6_addr_isloopback(ip6_current_dest_addr()) || - ip6_addr_isloopback(ip6_current_src_addr())) { - goto netif_found; - } -#endif /* !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF */ -#if !LWIP_SINGLE_NETIF - NETIF_FOREACH(netif) { - if (netif == inp) { - /* we checked that before already */ - continue; - } - if (ip6_input_accept(netif)) { - break; - } - } -#endif /* !LWIP_SINGLE_NETIF */ - } -netif_found: - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet accepted on interface %c%c\n", - netif ? netif->name[0] : 'X', netif? netif->name[1] : 'X')); - } - - /* "::" packet source address? (used in duplicate address detection) */ - if (ip6_addr_isany(ip6_current_src_addr()) && - (!ip6_addr_issolicitednode(ip6_current_dest_addr()))) { - /* packet source is not valid */ - /* free (drop) packet pbufs */ - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with src ANY_ADDRESS dropped\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - - /* packet not for us? */ - if (netif == NULL) { - /* packet not for us, route or discard */ - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_TRACE, ("ip6_input: packet not for us.\n")); -#if LWIP_IPV6_FORWARD - /* non-multicast packet? */ - if (!ip6_addr_ismulticast(ip6_current_dest_addr())) { - /* try to forward IP packet on (other) interfaces */ - ip6_forward(p, ip6hdr, inp); - } -#endif /* LWIP_IPV6_FORWARD */ - pbuf_free(p); - goto ip6_input_cleanup; - } - - /* current netif pointer. */ - ip_data.current_netif = netif; - - /* Save next header type. */ - nexth = &IP6H_NEXTH(ip6hdr); - - /* Init header length. */ - hlen = hlen_tot = IP6_HLEN; - - /* Move to payload. */ - pbuf_remove_header(p, IP6_HLEN); - - /* Process known option extension headers, if present. */ - while (*nexth != IP6_NEXTH_NONE) - { - switch (*nexth) { - case IP6_NEXTH_HOPBYHOP: - { - s32_t opt_offset; - struct ip6_hbh_hdr *hbh_hdr; - struct ip6_opt_hdr *opt_hdr; - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Hop-by-Hop options header\n")); - - /* Get and check the header length, while staying in packet bounds. */ - hbh_hdr = (struct ip6_hbh_hdr *)p->payload; - - /* Get next header type. */ - nexth = &IP6_HBH_NEXTH(hbh_hdr); - - /* Get the header length. */ - hlen = (u16_t)(8 * (1 + hbh_hdr->_hlen)); - - if ((p->len < 8) || (hlen > p->len)) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", - hlen, p->len)); - /* free (drop) packet pbufs */ - pbuf_free(p); - IP6_STATS_INC(ip6.lenerr); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - - hlen_tot = (u16_t)(hlen_tot + hlen); - - /* The extended option header starts right after Hop-by-Hop header. */ - opt_offset = IP6_HBH_HLEN; - while (opt_offset < hlen) - { - s32_t opt_dlen = 0; - - opt_hdr = (struct ip6_opt_hdr *)((u8_t *)hbh_hdr + opt_offset); - - switch (IP6_OPT_TYPE(opt_hdr)) { - /* @todo: process IPV6 Hop-by-Hop option data */ - case IP6_PAD1_OPTION: - /* PAD1 option doesn't have length and value field */ - opt_dlen = -1; - break; - case IP6_PADN_OPTION: - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - case IP6_ROUTER_ALERT_OPTION: - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - case IP6_JUMBO_OPTION: - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - default: - /* Check 2 MSB of Hop-by-Hop header type. */ - switch (IP6_OPT_TYPE_ACTION(opt_hdr)) { - case 1: - /* Discard the packet. */ - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid Hop-by-Hop option type dropped.\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - case 2: - /* Send ICMP Parameter Problem */ - icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid Hop-by-Hop option type dropped.\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - case 3: - /* Send ICMP Parameter Problem if destination address is not a multicast address */ - if (!ip6_addr_ismulticast(ip6_current_dest_addr())) { - icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); - } - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid Hop-by-Hop option type dropped.\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - default: - /* Skip over this option. */ - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - } - break; - } - - /* Adjust the offset to move to the next extended option header */ - opt_offset = opt_offset + IP6_OPT_HLEN + opt_dlen; - } - pbuf_remove_header(p, hlen); - break; - } - case IP6_NEXTH_DESTOPTS: - { - s32_t opt_offset; - struct ip6_dest_hdr *dest_hdr; - struct ip6_opt_hdr *opt_hdr; - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Destination options header\n")); - - dest_hdr = (struct ip6_dest_hdr *)p->payload; - - /* Get next header type. */ - nexth = &IP6_DEST_NEXTH(dest_hdr); - - /* Get the header length. */ - hlen = 8 * (1 + dest_hdr->_hlen); - if ((p->len < 8) || (hlen > p->len)) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", - hlen, p->len)); - /* free (drop) packet pbufs */ - pbuf_free(p); - IP6_STATS_INC(ip6.lenerr); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - - hlen_tot = (u16_t)(hlen_tot + hlen); - - /* The extended option header starts right after Destination header. */ - opt_offset = IP6_DEST_HLEN; - while (opt_offset < hlen) - { - s32_t opt_dlen = 0; - - opt_hdr = (struct ip6_opt_hdr *)((u8_t *)dest_hdr + opt_offset); - - switch (IP6_OPT_TYPE(opt_hdr)) - { - /* @todo: process IPV6 Destination option data */ - case IP6_PAD1_OPTION: - /* PAD1 option deosn't have length and value field */ - opt_dlen = -1; - break; - case IP6_PADN_OPTION: - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - case IP6_ROUTER_ALERT_OPTION: - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - case IP6_JUMBO_OPTION: - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - case IP6_HOME_ADDRESS_OPTION: - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - default: - /* Check 2 MSB of Destination header type. */ - switch (IP6_OPT_TYPE_ACTION(opt_hdr)) - { - case 1: - /* Discard the packet. */ - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid destination option type dropped.\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - case 2: - /* Send ICMP Parameter Problem */ - icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid destination option type dropped.\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - case 3: - /* Send ICMP Parameter Problem if destination address is not a multicast address */ - if (!ip6_addr_ismulticast(ip6_current_dest_addr())) { - icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); - } - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid destination option type dropped.\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - default: - /* Skip over this option. */ - opt_dlen = IP6_OPT_DLEN(opt_hdr); - break; - } - break; - } - - /* Adjust the offset to move to the next extended option header */ - opt_offset = opt_offset + IP6_OPT_HLEN + opt_dlen; - } - - pbuf_remove_header(p, hlen); - break; - } - case IP6_NEXTH_ROUTING: - { - struct ip6_rout_hdr *rout_hdr; - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Routing header\n")); - - rout_hdr = (struct ip6_rout_hdr *)p->payload; - - /* Get next header type. */ - nexth = &IP6_ROUT_NEXTH(rout_hdr); - - /* Get the header length. */ - hlen = 8 * (1 + rout_hdr->_hlen); - - if ((p->len < 8) || (hlen > p->len)) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", - hlen, p->len)); - /* free (drop) packet pbufs */ - pbuf_free(p); - IP6_STATS_INC(ip6.lenerr); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - - /* Skip over this header. */ - hlen_tot = (u16_t)(hlen_tot + hlen); - - /* if segment left value is 0 in routing header, ignore the option */ - if (IP6_ROUT_SEG_LEFT(rout_hdr)) { - /* The length field of routing option header must be even */ - if (rout_hdr->_hlen & 0x1) { - /* Discard and send parameter field error */ - icmp6_param_problem(p, ICMP6_PP_FIELD, &rout_hdr->_hlen); - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid routing type dropped\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - - switch (IP6_ROUT_TYPE(rout_hdr)) - { - /* TODO: process routing by the type */ - case IP6_ROUT_TYPE2: - break; - case IP6_ROUT_RPL: - break; - default: - /* Discard unrecognized routing type and send parameter field error */ - icmp6_param_problem(p, ICMP6_PP_FIELD, &IP6_ROUT_TYPE(rout_hdr)); - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid routing type dropped\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - } - - pbuf_remove_header(p, hlen); - break; - } - case IP6_NEXTH_FRAGMENT: - { - struct ip6_frag_hdr *frag_hdr; - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header\n")); - - frag_hdr = (struct ip6_frag_hdr *)p->payload; - - /* Get next header type. */ - nexth = &IP6_FRAG_NEXTH(frag_hdr); - - /* Fragment Header length. */ - hlen = 8; - - /* Make sure this header fits in current pbuf. */ - if (hlen > p->len) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", - hlen, p->len)); - /* free (drop) packet pbufs */ - pbuf_free(p); - IP6_FRAG_STATS_INC(ip6_frag.lenerr); - IP6_FRAG_STATS_INC(ip6_frag.drop); - goto ip6_input_cleanup; - } - - hlen_tot = (u16_t)(hlen_tot + hlen); - - /* check payload length is multiple of 8 octets when mbit is set */ - if (IP6_FRAG_MBIT(frag_hdr) && (IP6H_PLEN(ip6hdr) & 0x7)) { - /* ipv6 payload length is not multiple of 8 octets */ - icmp6_param_problem(p, ICMP6_PP_FIELD, LWIP_PACKED_CAST(const void *, &ip6hdr->_plen)); - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid payload length dropped\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - - /* Offset == 0 and more_fragments == 0? */ - if ((frag_hdr->_fragment_offset & - PP_HTONS(IP6_FRAG_OFFSET_MASK | IP6_FRAG_MORE_FLAG)) == 0) { - /* This is a 1-fragment packet. Skip this header and continue. */ - pbuf_remove_header(p, hlen); - } else { -#if LWIP_IPV6_REASS - /* reassemble the packet */ - ip_data.current_ip_header_tot_len = hlen_tot; - p = ip6_reass(p); - /* packet not fully reassembled yet? */ - if (p == NULL) { - goto ip6_input_cleanup; - } - - /* Returned p point to IPv6 header. - * Update all our variables and pointers and continue. */ - ip6hdr = (struct ip6_hdr *)p->payload; - nexth = &IP6H_NEXTH(ip6hdr); - hlen = hlen_tot = IP6_HLEN; - pbuf_remove_header(p, IP6_HLEN); - -#else /* LWIP_IPV6_REASS */ - /* free (drop) packet pbufs */ - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header dropped (with LWIP_IPV6_REASS==0)\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.opterr); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; -#endif /* LWIP_IPV6_REASS */ - } - break; - } - default: - goto options_done; - } - - if (*nexth == IP6_NEXTH_HOPBYHOP) { - /* Hop-by-Hop header comes only as a first option */ - icmp6_param_problem(p, ICMP6_PP_HEADER, nexth); - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Hop-by-Hop options header dropped (only valid as a first option)\n")); - pbuf_free(p); - IP6_STATS_INC(ip6.drop); - goto ip6_input_cleanup; - } - } - -options_done: - - /* send to upper layers */ - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: \n")); - ip6_debug_print(p); - LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len)); - - ip_data.current_ip_header_tot_len = hlen_tot; - -#if LWIP_RAW - /* p points to IPv6 header again for raw_input. */ - pbuf_add_header_force(p, hlen_tot); - /* raw input did not eat the packet? */ - raw_status = raw_input(p, inp); - if (raw_status != RAW_INPUT_EATEN) - { - /* Point to payload. */ - pbuf_remove_header(p, hlen_tot); -#else /* LWIP_RAW */ - { -#endif /* LWIP_RAW */ - switch (*nexth) { - case IP6_NEXTH_NONE: - pbuf_free(p); - break; -#if LWIP_UDP - case IP6_NEXTH_UDP: -#if LWIP_UDPLITE - case IP6_NEXTH_UDPLITE: -#endif /* LWIP_UDPLITE */ - udp_input(p, inp); - break; -#endif /* LWIP_UDP */ -#if LWIP_TCP - case IP6_NEXTH_TCP: - tcp_input(p, inp); - break; -#endif /* LWIP_TCP */ -#if LWIP_ICMP6 - case IP6_NEXTH_ICMP6: - icmp6_input(p, inp); - break; -#endif /* LWIP_ICMP */ - default: -#if LWIP_RAW - if (raw_status == RAW_INPUT_DELIVERED) { - /* @todo: ipv6 mib in-delivers? */ - } else -#endif /* LWIP_RAW */ - { -#if LWIP_ICMP6 - /* p points to IPv6 header again for raw_input. */ - pbuf_add_header_force(p, hlen_tot); - /* send ICMP parameter problem unless it was a multicast or ICMPv6 */ - if ((!ip6_addr_ismulticast(ip6_current_dest_addr())) && - (IP6H_NEXTH(ip6hdr) != IP6_NEXTH_ICMP6)) { - icmp6_param_problem(p, ICMP6_PP_HEADER, nexth); - } -#endif /* LWIP_ICMP */ - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_input: Unsupported transport protocol %"U16_F"\n", (u16_t)IP6H_NEXTH(ip6hdr))); - IP6_STATS_INC(ip6.proterr); - IP6_STATS_INC(ip6.drop); - } - pbuf_free(p); - break; - } - } - -ip6_input_cleanup: - ip_data.current_netif = NULL; - ip_data.current_input_netif = NULL; - ip_data.current_ip6_header = NULL; - ip_data.current_ip_header_tot_len = 0; - ip6_addr_set_zero(ip6_current_src_addr()); - ip6_addr_set_zero(ip6_current_dest_addr()); - - return ERR_OK; -} - - -/** - * Sends an IPv6 packet on a network interface. This function constructs - * the IPv6 header. If the source IPv6 address is NULL, the IPv6 "ANY" address is - * used as source (usually during network startup). If the source IPv6 address it - * IP6_ADDR_ANY, the most appropriate IPv6 address of the outgoing network - * interface is filled in as source address. If the destination IPv6 address is - * LWIP_IP_HDRINCL, p is assumed to already include an IPv6 header and - * p->payload points to it instead of the data. - * - * @param p the packet to send (p->payload points to the data, e.g. next - protocol header; if dest == LWIP_IP_HDRINCL, p already includes an - IPv6 header and p->payload points to that IPv6 header) - * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an - * IP address of the netif is selected and used as source address. - * if src == NULL, IP6_ADDR_ANY is used as source) (src is possibly not - * properly zoned) - * @param dest the destination IPv6 address to send the packet to (possibly not - * properly zoned) - * @param hl the Hop Limit value to be set in the IPv6 header - * @param tc the Traffic Class value to be set in the IPv6 header - * @param nexth the Next Header to be set in the IPv6 header - * @param netif the netif on which to send this packet - * @return ERR_OK if the packet was sent OK - * ERR_BUF if p doesn't have enough space for IPv6/LINK headers - * returns errors returned by netif->output_ip6 - */ -err_t -ip6_output_if(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, - u8_t nexth, struct netif *netif) -{ - const ip6_addr_t *src_used = src; - if (dest != LWIP_IP_HDRINCL) { - if (src != NULL && ip6_addr_isany(src)) { - src_used = ip_2_ip6(ip6_select_source_address(netif, dest)); - if ((src_used == NULL) || ip6_addr_isany(src_used)) { - /* No appropriate source address was found for this packet. */ - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: No suitable source address for packet.\n")); - IP6_STATS_INC(ip6.rterr); - return ERR_RTE; - } - } - } - return ip6_output_if_src(p, src_used, dest, hl, tc, nexth, netif); -} - -/** - * Same as ip6_output_if() but 'src' address is not replaced by netif address - * when it is 'any'. - */ -err_t -ip6_output_if_src(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, - u8_t nexth, struct netif *netif) -{ - struct ip6_hdr *ip6hdr; - ip6_addr_t dest_addr; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); - - /* Should the IPv6 header be generated or is it already included in p? */ - if (dest != LWIP_IP_HDRINCL) { -#if LWIP_IPV6_SCOPES - /* If the destination address is scoped but lacks a zone, add a zone now, - * based on the outgoing interface. The lower layers (e.g., nd6) absolutely - * require addresses to be properly zoned for correctness. In some cases, - * earlier attempts will have been made to add a zone to the destination, - * but this function is the only one that is called in all (other) cases, - * so we must do this here. */ - if (ip6_addr_lacks_zone(dest, IP6_UNKNOWN)) { - ip6_addr_copy(dest_addr, *dest); - ip6_addr_assign_zone(&dest_addr, IP6_UNKNOWN, netif); - dest = &dest_addr; - } -#endif /* LWIP_IPV6_SCOPES */ - - /* generate IPv6 header */ - if (pbuf_add_header(p, IP6_HLEN)) { - LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: not enough room for IPv6 header in pbuf\n")); - IP6_STATS_INC(ip6.err); - return ERR_BUF; - } - - ip6hdr = (struct ip6_hdr *)p->payload; - LWIP_ASSERT("check that first pbuf can hold struct ip6_hdr", - (p->len >= sizeof(struct ip6_hdr))); - - IP6H_HOPLIM_SET(ip6hdr, hl); - IP6H_NEXTH_SET(ip6hdr, nexth); - - /* dest cannot be NULL here */ - ip6_addr_copy_to_packed(ip6hdr->dest, *dest); - - IP6H_VTCFL_SET(ip6hdr, 6, tc, 0); - IP6H_PLEN_SET(ip6hdr, (u16_t)(p->tot_len - IP6_HLEN)); - - if (src == NULL) { - src = IP6_ADDR_ANY6; - } - /* src cannot be NULL here */ - ip6_addr_copy_to_packed(ip6hdr->src, *src); - - } else { - /* IP header already included in p */ - ip6hdr = (struct ip6_hdr *)p->payload; - ip6_addr_copy_from_packed(dest_addr, ip6hdr->dest); - ip6_addr_assign_zone(&dest_addr, IP6_UNKNOWN, netif); - dest = &dest_addr; - } - - IP6_STATS_INC(ip6.xmit); - - LWIP_DEBUGF(IP6_DEBUG, ("ip6_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], (u16_t)netif->num)); - ip6_debug_print(p); - -#if ENABLE_LOOPBACK - { - int i; -#if !LWIP_HAVE_LOOPIF - if (ip6_addr_isloopback(dest)) { - return netif_loop_output(netif, p); - } -#endif /* !LWIP_HAVE_LOOPIF */ - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && - ip6_addr_cmp(dest, netif_ip6_addr(netif, i))) { - /* Packet to self, enqueue it for loopback */ - LWIP_DEBUGF(IP6_DEBUG, ("netif_loop_output()\n")); - return netif_loop_output(netif, p); - } - } - } -#if LWIP_MULTICAST_TX_OPTIONS - if ((p->flags & PBUF_FLAG_MCASTLOOP) != 0) { - netif_loop_output(netif, p); - } -#endif /* LWIP_MULTICAST_TX_OPTIONS */ -#endif /* ENABLE_LOOPBACK */ -#if LWIP_IPV6_FRAG - /* don't fragment if interface has mtu set to 0 [loopif] */ - if (netif_mtu6(netif) && (p->tot_len > nd6_get_destination_mtu(dest, netif))) { - return ip6_frag(p, netif, dest); - } -#endif /* LWIP_IPV6_FRAG */ - - LWIP_DEBUGF(IP6_DEBUG, ("netif->output_ip6()\n")); - return netif->output_ip6(netif, p, dest); -} - -/** - * Simple interface to ip6_output_if. It finds the outgoing network - * interface and calls upon ip6_output_if to do the actual work. - * - * @param p the packet to send (p->payload points to the data, e.g. next - protocol header; if dest == LWIP_IP_HDRINCL, p already includes an - IPv6 header and p->payload points to that IPv6 header) - * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an - * IP address of the netif is selected and used as source address. - * if src == NULL, IP6_ADDR_ANY is used as source) - * @param dest the destination IPv6 address to send the packet to - * @param hl the Hop Limit value to be set in the IPv6 header - * @param tc the Traffic Class value to be set in the IPv6 header - * @param nexth the Next Header to be set in the IPv6 header - * - * @return ERR_RTE if no route is found - * see ip_output_if() for more return values - */ -err_t -ip6_output(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, u8_t nexth) -{ - struct netif *netif; - struct ip6_hdr *ip6hdr; - ip6_addr_t src_addr, dest_addr; - - LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); - - if (dest != LWIP_IP_HDRINCL) { - netif = ip6_route(src, dest); - } else { - /* IP header included in p, read addresses. */ - ip6hdr = (struct ip6_hdr *)p->payload; - ip6_addr_copy_from_packed(src_addr, ip6hdr->src); - ip6_addr_copy_from_packed(dest_addr, ip6hdr->dest); - netif = ip6_route(&src_addr, &dest_addr); - } - - if (netif == NULL) { - LWIP_DEBUGF(IP6_DEBUG, ("ip6_output: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", - IP6_ADDR_BLOCK1(dest), - IP6_ADDR_BLOCK2(dest), - IP6_ADDR_BLOCK3(dest), - IP6_ADDR_BLOCK4(dest), - IP6_ADDR_BLOCK5(dest), - IP6_ADDR_BLOCK6(dest), - IP6_ADDR_BLOCK7(dest), - IP6_ADDR_BLOCK8(dest))); - IP6_STATS_INC(ip6.rterr); - return ERR_RTE; - } - - return ip6_output_if(p, src, dest, hl, tc, nexth, netif); -} - - -#if LWIP_NETIF_USE_HINTS -/** Like ip6_output, but takes and addr_hint pointer that is passed on to netif->addr_hint - * before calling ip6_output_if. - * - * @param p the packet to send (p->payload points to the data, e.g. next - protocol header; if dest == LWIP_IP_HDRINCL, p already includes an - IPv6 header and p->payload points to that IPv6 header) - * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an - * IP address of the netif is selected and used as source address. - * if src == NULL, IP6_ADDR_ANY is used as source) - * @param dest the destination IPv6 address to send the packet to - * @param hl the Hop Limit value to be set in the IPv6 header - * @param tc the Traffic Class value to be set in the IPv6 header - * @param nexth the Next Header to be set in the IPv6 header - * @param netif_hint netif output hint pointer set to netif->hint before - * calling ip_output_if() - * - * @return ERR_RTE if no route is found - * see ip_output_if() for more return values - */ -err_t -ip6_output_hinted(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, u8_t nexth, struct netif_hint *netif_hint) -{ - struct netif *netif; - struct ip6_hdr *ip6hdr; - ip6_addr_t src_addr, dest_addr; - err_t err; - - LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); - - if (dest != LWIP_IP_HDRINCL) { - netif = ip6_route(src, dest); - } else { - /* IP header included in p, read addresses. */ - ip6hdr = (struct ip6_hdr *)p->payload; - ip6_addr_copy_from_packed(src_addr, ip6hdr->src); - ip6_addr_copy_from_packed(dest_addr, ip6hdr->dest); - netif = ip6_route(&src_addr, &dest_addr); - } - - if (netif == NULL) { - LWIP_DEBUGF(IP6_DEBUG, ("ip6_output: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", - IP6_ADDR_BLOCK1(dest), - IP6_ADDR_BLOCK2(dest), - IP6_ADDR_BLOCK3(dest), - IP6_ADDR_BLOCK4(dest), - IP6_ADDR_BLOCK5(dest), - IP6_ADDR_BLOCK6(dest), - IP6_ADDR_BLOCK7(dest), - IP6_ADDR_BLOCK8(dest))); - IP6_STATS_INC(ip6.rterr); - return ERR_RTE; - } - - NETIF_SET_HINTS(netif, netif_hint); - err = ip6_output_if(p, src, dest, hl, tc, nexth, netif); - NETIF_RESET_HINTS(netif); - - return err; -} -#endif /* LWIP_NETIF_USE_HINTS*/ - -#if LWIP_IPV6_MLD -/** - * Add a hop-by-hop options header with a router alert option and padding. - * - * Used by MLD when sending a Multicast listener report/done message. - * - * @param p the packet to which we will prepend the options header - * @param nexth the next header protocol number (e.g. IP6_NEXTH_ICMP6) - * @param value the value of the router alert option data (e.g. IP6_ROUTER_ALERT_VALUE_MLD) - * @return ERR_OK if hop-by-hop header was added, ERR_* otherwise - */ -err_t -ip6_options_add_hbh_ra(struct pbuf *p, u8_t nexth, u8_t value) -{ - u8_t *opt_data; - u32_t offset = 0; - struct ip6_hbh_hdr *hbh_hdr; - struct ip6_opt_hdr *opt_hdr; - - /* fixed 4 bytes for router alert option and 2 bytes padding */ - const u8_t hlen = (sizeof(struct ip6_opt_hdr) * 2) + IP6_ROUTER_ALERT_DLEN; - /* Move pointer to make room for hop-by-hop options header. */ - if (pbuf_add_header(p, sizeof(struct ip6_hbh_hdr) + hlen)) { - LWIP_DEBUGF(IP6_DEBUG, ("ip6_options: no space for options header\n")); - IP6_STATS_INC(ip6.err); - return ERR_BUF; - } - - /* Set fields of Hop-by-Hop header */ - hbh_hdr = (struct ip6_hbh_hdr *)p->payload; - IP6_HBH_NEXTH(hbh_hdr) = nexth; - hbh_hdr->_hlen = 0; - offset = IP6_HBH_HLEN; - - /* Set router alert options to Hop-by-Hop extended option header */ - opt_hdr = (struct ip6_opt_hdr *)((u8_t *)hbh_hdr + offset); - IP6_OPT_TYPE(opt_hdr) = IP6_ROUTER_ALERT_OPTION; - IP6_OPT_DLEN(opt_hdr) = IP6_ROUTER_ALERT_DLEN; - offset += IP6_OPT_HLEN; - - /* Set router alert option data */ - opt_data = (u8_t *)hbh_hdr + offset; - opt_data[0] = value; - opt_data[1] = 0; - offset += IP6_OPT_DLEN(opt_hdr); - - /* add 2 bytes padding to make 8 bytes Hop-by-Hop header length */ - opt_hdr = (struct ip6_opt_hdr *)((u8_t *)hbh_hdr + offset); - IP6_OPT_TYPE(opt_hdr) = IP6_PADN_OPTION; - IP6_OPT_DLEN(opt_hdr) = 0; - - return ERR_OK; -} -#endif /* LWIP_IPV6_MLD */ - -#if IP6_DEBUG -/* Print an IPv6 header by using LWIP_DEBUGF - * @param p an IPv6 packet, p->payload pointing to the IPv6 header - */ -void -ip6_debug_print(struct pbuf *p) -{ - struct ip6_hdr *ip6hdr = (struct ip6_hdr *)p->payload; - - LWIP_DEBUGF(IP6_DEBUG, ("IPv6 header:\n")); - LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP6_DEBUG, ("| %2"U16_F" | %3"U16_F" | %7"U32_F" | (ver, class, flow)\n", - IP6H_V(ip6hdr), - IP6H_TC(ip6hdr), - IP6H_FL(ip6hdr))); - LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP6_DEBUG, ("| %5"U16_F" | %3"U16_F" | %3"U16_F" | (plen, nexth, hopl)\n", - IP6H_PLEN(ip6hdr), - IP6H_NEXTH(ip6hdr), - IP6H_HOPLIM(ip6hdr))); - LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" | (src)\n", - IP6_ADDR_BLOCK1(&(ip6hdr->src)), - IP6_ADDR_BLOCK2(&(ip6hdr->src)), - IP6_ADDR_BLOCK3(&(ip6hdr->src)), - IP6_ADDR_BLOCK4(&(ip6hdr->src)))); - LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" |\n", - IP6_ADDR_BLOCK5(&(ip6hdr->src)), - IP6_ADDR_BLOCK6(&(ip6hdr->src)), - IP6_ADDR_BLOCK7(&(ip6hdr->src)), - IP6_ADDR_BLOCK8(&(ip6hdr->src)))); - LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" | (dest)\n", - IP6_ADDR_BLOCK1(&(ip6hdr->dest)), - IP6_ADDR_BLOCK2(&(ip6hdr->dest)), - IP6_ADDR_BLOCK3(&(ip6hdr->dest)), - IP6_ADDR_BLOCK4(&(ip6hdr->dest)))); - LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" |\n", - IP6_ADDR_BLOCK5(&(ip6hdr->dest)), - IP6_ADDR_BLOCK6(&(ip6hdr->dest)), - IP6_ADDR_BLOCK7(&(ip6hdr->dest)), - IP6_ADDR_BLOCK8(&(ip6hdr->dest)))); - LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); -} -#endif /* IP6_DEBUG */ - -#endif /* LWIP_IPV6 */ +/** + * @file + * + * IPv6 layer. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/netif.h" +#include "lwip/ip.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/ip6_frag.h" +#include "lwip/icmp6.h" +#include "lwip/priv/raw_priv.h" +#include "lwip/udp.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/dhcp6.h" +#include "lwip/nd6.h" +#include "lwip/mld6.h" +#include "lwip/debug.h" +#include "lwip/stats.h" + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +/** + * Finds the appropriate network interface for a given IPv6 address. It tries to select + * a netif following a sequence of heuristics: + * 1) if there is only 1 netif, return it + * 2) if the destination is a zoned address, match its zone to a netif + * 3) if the either the source or destination address is a scoped address, + * match the source address's zone (if set) or address (if not) to a netif + * 4) tries to match the destination subnet to a configured address + * 5) tries to find a router-announced route + * 6) tries to match the (unscoped) source address to the netif + * 7) returns the default netif, if configured + * + * Note that each of the two given addresses may or may not be properly zoned. + * + * @param src the source IPv6 address, if known + * @param dest the destination IPv6 address for which to find the route + * @return the netif on which to send to reach dest + */ +struct netif * +ip6_route(const ip6_addr_t *src, const ip6_addr_t *dest) +{ +#if LWIP_SINGLE_NETIF + LWIP_UNUSED_ARG(src); + LWIP_UNUSED_ARG(dest); +#else /* LWIP_SINGLE_NETIF */ + struct netif *netif; + s8_t i; + + LWIP_ASSERT_CORE_LOCKED(); + + /* If single netif configuration, fast return. */ + if ((netif_list != NULL) && (netif_list->next == NULL)) { + if (!netif_is_up(netif_list) || !netif_is_link_up(netif_list) || + (ip6_addr_has_zone(dest) && !ip6_addr_test_zone(dest, netif_list))) { + return NULL; + } + return netif_list; + } + +#if LWIP_IPV6_SCOPES + /* Special processing for zoned destination addresses. This includes link- + * local unicast addresses and interface/link-local multicast addresses. Use + * the zone to find a matching netif. If the address is not zoned, then there + * is technically no "wrong" netif to choose, and we leave routing to other + * rules; in most cases this should be the scoped-source rule below. */ + if (ip6_addr_has_zone(dest)) { + IP6_ADDR_ZONECHECK(dest); + /* Find a netif based on the zone. For custom mappings, one zone may map + * to multiple netifs, so find one that can actually send a packet. */ + NETIF_FOREACH(netif) { + if (ip6_addr_test_zone(dest, netif) && + netif_is_up(netif) && netif_is_link_up(netif)) { + return netif; + } + } + /* No matching netif found. Do no try to route to a different netif, + * as that would be a zone violation, resulting in any packets sent to + * that netif being dropped on output. */ + return NULL; + } +#endif /* LWIP_IPV6_SCOPES */ + + /* Special processing for scoped source and destination addresses. If we get + * here, the destination address does not have a zone, so either way we need + * to look at the source address, which may or may not have a zone. If it + * does, the zone is restrictive: there is (typically) only one matching + * netif for it, and we should avoid routing to any other netif as that would + * result in guaranteed zone violations. For scoped source addresses that do + * not have a zone, use (only) a netif that has that source address locally + * assigned. This case also applies to the loopback source address, which has + * an implied link-local scope. If only the destination address is scoped + * (but, again, not zoned), we still want to use only the source address to + * determine its zone because that's most likely what the user/application + * wants, regardless of whether the source address is scoped. Finally, some + * of this story also applies if scoping is disabled altogether. */ +#if LWIP_IPV6_SCOPES + if (ip6_addr_has_scope(dest, IP6_UNKNOWN) || + ip6_addr_has_scope(src, IP6_UNICAST) || +#else /* LWIP_IPV6_SCOPES */ + if (ip6_addr_islinklocal(dest) || ip6_addr_ismulticast_iflocal(dest) || + ip6_addr_ismulticast_linklocal(dest) || ip6_addr_islinklocal(src) || +#endif /* LWIP_IPV6_SCOPES */ + ip6_addr_isloopback(src)) { +#if LWIP_IPV6_SCOPES + if (ip6_addr_has_zone(src)) { + /* Find a netif matching the source zone (relatively cheap). */ + NETIF_FOREACH(netif) { + if (netif_is_up(netif) && netif_is_link_up(netif) && + ip6_addr_test_zone(src, netif)) { + return netif; + } + } + } else +#endif /* LWIP_IPV6_SCOPES */ + { + /* Find a netif matching the source address (relatively expensive). */ + NETIF_FOREACH(netif) { + if (!netif_is_up(netif) || !netif_is_link_up(netif)) { + continue; + } + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + ip6_addr_cmp_zoneless(src, netif_ip6_addr(netif, i))) { + return netif; + } + } + } + } + /* Again, do not use any other netif in this case, as that could result in + * zone boundary violations. */ + return NULL; + } + + /* We come here only if neither source nor destination is scoped. */ + IP6_ADDR_ZONECHECK(src); + +#ifdef LWIP_HOOK_IP6_ROUTE + netif = LWIP_HOOK_IP6_ROUTE(src, dest); + if (netif != NULL) { + return netif; + } +#endif + + /* See if the destination subnet matches a configured address. In accordance + * with RFC 5942, dynamically configured addresses do not have an implied + * local subnet, and thus should be considered /128 assignments. However, as + * such, the destination address may still match a local address, and so we + * still need to check for exact matches here. By (lwIP) policy, statically + * configured addresses do always have an implied local /64 subnet. */ + NETIF_FOREACH(netif) { + if (!netif_is_up(netif) || !netif_is_link_up(netif)) { + continue; + } + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + ip6_addr_netcmp(dest, netif_ip6_addr(netif, i)) && + (netif_ip6_addr_isstatic(netif, i) || + ip6_addr_nethostcmp(dest, netif_ip6_addr(netif, i)))) { + return netif; + } + } + } + + /* Get the netif for a suitable router-announced route. */ + netif = nd6_find_route(dest); + if (netif != NULL) { + return netif; + } + + /* Try with the netif that matches the source address. Given the earlier rule + * for scoped source addresses, this applies to unscoped addresses only. */ + if (!ip6_addr_isany(src)) { + NETIF_FOREACH(netif) { + if (!netif_is_up(netif) || !netif_is_link_up(netif)) { + continue; + } + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + ip6_addr_cmp(src, netif_ip6_addr(netif, i))) { + return netif; + } + } + } + } + +#if LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF + /* loopif is disabled, loopback traffic is passed through any netif */ + if (ip6_addr_isloopback(dest)) { + /* don't check for link on loopback traffic */ + if (netif_default != NULL && netif_is_up(netif_default)) { + return netif_default; + } + /* default netif is not up, just use any netif for loopback traffic */ + NETIF_FOREACH(netif) { + if (netif_is_up(netif)) { + return netif; + } + } + return NULL; + } +#endif /* LWIP_NETIF_LOOPBACK && !LWIP_HAVE_LOOPIF */ +#endif /* !LWIP_SINGLE_NETIF */ + + /* no matching netif found, use default netif, if up */ + if ((netif_default == NULL) || !netif_is_up(netif_default) || !netif_is_link_up(netif_default)) { + return NULL; + } + return netif_default; +} + +/** + * @ingroup ip6 + * Select the best IPv6 source address for a given destination IPv6 address. + * + * This implementation follows RFC 6724 Sec. 5 to the following extent: + * - Rules 1, 2, 3: fully implemented + * - Rules 4, 5, 5.5: not applicable + * - Rule 6: not implemented + * - Rule 7: not applicable + * - Rule 8: limited to "prefer /64 subnet match over non-match" + * + * For Rule 2, we deliberately deviate from RFC 6724 Sec. 3.1 by considering + * ULAs to be of smaller scope than global addresses, to avoid that a preferred + * ULA is picked over a deprecated global address when given a global address + * as destination, as that would likely result in broken two-way communication. + * + * As long as temporary addresses are not supported (as used in Rule 7), a + * proper implementation of Rule 8 would obviate the need to implement Rule 6. + * + * @param netif the netif on which to send a packet + * @param dest the destination we are trying to reach (possibly not properly + * zoned) + * @return the most suitable source address to use, or NULL if no suitable + * source address is found + */ +const ip_addr_t * +ip6_select_source_address(struct netif *netif, const ip6_addr_t *dest) +{ + const ip_addr_t *best_addr; + const ip6_addr_t *cand_addr; + s8_t dest_scope, cand_scope; + s8_t best_scope = IP6_MULTICAST_SCOPE_RESERVED; + u8_t i, cand_pref, cand_bits; + u8_t best_pref = 0; + u8_t best_bits = 0; + + /* Start by determining the scope of the given destination address. These + * tests are hopefully (roughly) in order of likeliness to match. */ + if (ip6_addr_isglobal(dest)) { + dest_scope = IP6_MULTICAST_SCOPE_GLOBAL; + } else if (ip6_addr_islinklocal(dest) || ip6_addr_isloopback(dest)) { + dest_scope = IP6_MULTICAST_SCOPE_LINK_LOCAL; + } else if (ip6_addr_isuniquelocal(dest)) { + dest_scope = IP6_MULTICAST_SCOPE_ORGANIZATION_LOCAL; + } else if (ip6_addr_ismulticast(dest)) { + dest_scope = ip6_addr_multicast_scope(dest); + } else if (ip6_addr_issitelocal(dest)) { + dest_scope = IP6_MULTICAST_SCOPE_SITE_LOCAL; + } else { + /* no match, consider scope global */ + dest_scope = IP6_MULTICAST_SCOPE_GLOBAL; + } + + best_addr = NULL; + + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + /* Consider only valid (= preferred and deprecated) addresses. */ + if (!ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { + continue; + } + /* Determine the scope of this candidate address. Same ordering idea. */ + cand_addr = netif_ip6_addr(netif, i); + if (ip6_addr_isglobal(cand_addr)) { + cand_scope = IP6_MULTICAST_SCOPE_GLOBAL; + } else if (ip6_addr_islinklocal(cand_addr)) { + cand_scope = IP6_MULTICAST_SCOPE_LINK_LOCAL; + } else if (ip6_addr_isuniquelocal(cand_addr)) { + cand_scope = IP6_MULTICAST_SCOPE_ORGANIZATION_LOCAL; + } else if (ip6_addr_issitelocal(cand_addr)) { + cand_scope = IP6_MULTICAST_SCOPE_SITE_LOCAL; + } else { + /* no match, treat as low-priority global scope */ + cand_scope = IP6_MULTICAST_SCOPE_RESERVEDF; + } + cand_pref = ip6_addr_ispreferred(netif_ip6_addr_state(netif, i)); + /* @todo compute the actual common bits, for longest matching prefix. */ + /* We cannot count on the destination address having a proper zone + * assignment, so do not compare zones in this case. */ + cand_bits = ip6_addr_netcmp_zoneless(cand_addr, dest); /* just 1 or 0 for now */ + if (cand_bits && ip6_addr_nethostcmp(cand_addr, dest)) { + return netif_ip_addr6(netif, i); /* Rule 1 */ + } + if ((best_addr == NULL) || /* no alternative yet */ + ((cand_scope < best_scope) && (cand_scope >= dest_scope)) || + ((cand_scope > best_scope) && (best_scope < dest_scope)) || /* Rule 2 */ + ((cand_scope == best_scope) && ((cand_pref > best_pref) || /* Rule 3 */ + ((cand_pref == best_pref) && (cand_bits > best_bits))))) { /* Rule 8 */ + /* We found a new "winning" candidate. */ + best_addr = netif_ip_addr6(netif, i); + best_scope = cand_scope; + best_pref = cand_pref; + best_bits = cand_bits; + } + } + + return best_addr; /* may be NULL */ +} + +#if LWIP_IPV6_FORWARD +/** + * Forwards an IPv6 packet. It finds an appropriate route for the + * packet, decrements the HL value of the packet, and outputs + * the packet on the appropriate interface. + * + * @param p the packet to forward (p->payload points to IP header) + * @param iphdr the IPv6 header of the input packet + * @param inp the netif on which this packet was received + */ +static void +ip6_forward(struct pbuf *p, struct ip6_hdr *iphdr, struct netif *inp) +{ + struct netif *netif; + + /* do not forward link-local or loopback addresses */ + if (ip6_addr_islinklocal(ip6_current_dest_addr()) || + ip6_addr_isloopback(ip6_current_dest_addr())) { + LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not forwarding link-local address.\n")); + IP6_STATS_INC(ip6.rterr); + IP6_STATS_INC(ip6.drop); + return; + } + + /* Find network interface where to forward this IP packet to. */ + netif = ip6_route(IP6_ADDR_ANY6, ip6_current_dest_addr()); + if (netif == NULL) { + LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", + IP6_ADDR_BLOCK1(ip6_current_dest_addr()), + IP6_ADDR_BLOCK2(ip6_current_dest_addr()), + IP6_ADDR_BLOCK3(ip6_current_dest_addr()), + IP6_ADDR_BLOCK4(ip6_current_dest_addr()), + IP6_ADDR_BLOCK5(ip6_current_dest_addr()), + IP6_ADDR_BLOCK6(ip6_current_dest_addr()), + IP6_ADDR_BLOCK7(ip6_current_dest_addr()), + IP6_ADDR_BLOCK8(ip6_current_dest_addr()))); +#if LWIP_ICMP6 + /* Don't send ICMP messages in response to ICMP messages */ + if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) { + icmp6_dest_unreach(p, ICMP6_DUR_NO_ROUTE); + } +#endif /* LWIP_ICMP6 */ + IP6_STATS_INC(ip6.rterr); + IP6_STATS_INC(ip6.drop); + return; + } +#if LWIP_IPV6_SCOPES + /* Do not forward packets with a zoned (e.g., link-local) source address + * outside of their zone. We determined the zone a bit earlier, so we know + * that the address is properly zoned here, so we can safely use has_zone. + * Also skip packets with a loopback source address (link-local implied). */ + if ((ip6_addr_has_zone(ip6_current_src_addr()) && + !ip6_addr_test_zone(ip6_current_src_addr(), netif)) || + ip6_addr_isloopback(ip6_current_src_addr())) { + LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not forwarding packet beyond its source address zone.\n")); + IP6_STATS_INC(ip6.rterr); + IP6_STATS_INC(ip6.drop); + return; + } +#endif /* LWIP_IPV6_SCOPES */ + /* Do not forward packets onto the same network interface on which + * they arrived. */ + if (netif == inp) { + LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: not bouncing packets back on incoming interface.\n")); + IP6_STATS_INC(ip6.rterr); + IP6_STATS_INC(ip6.drop); + return; + } + + /* decrement HL */ + IP6H_HOPLIM_SET(iphdr, IP6H_HOPLIM(iphdr) - 1); + /* send ICMP6 if HL == 0 */ + if (IP6H_HOPLIM(iphdr) == 0) { +#if LWIP_ICMP6 + /* Don't send ICMP messages in response to ICMP messages */ + if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) { + icmp6_time_exceeded(p, ICMP6_TE_HL); + } +#endif /* LWIP_ICMP6 */ + IP6_STATS_INC(ip6.drop); + return; + } + + if (netif->mtu && (p->tot_len > netif->mtu)) { +#if LWIP_ICMP6 + /* Don't send ICMP messages in response to ICMP messages */ + if (IP6H_NEXTH(iphdr) != IP6_NEXTH_ICMP6) { + icmp6_packet_too_big(p, netif->mtu); + } +#endif /* LWIP_ICMP6 */ + IP6_STATS_INC(ip6.drop); + return; + } + + LWIP_DEBUGF(IP6_DEBUG, ("ip6_forward: forwarding packet to %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", + IP6_ADDR_BLOCK1(ip6_current_dest_addr()), + IP6_ADDR_BLOCK2(ip6_current_dest_addr()), + IP6_ADDR_BLOCK3(ip6_current_dest_addr()), + IP6_ADDR_BLOCK4(ip6_current_dest_addr()), + IP6_ADDR_BLOCK5(ip6_current_dest_addr()), + IP6_ADDR_BLOCK6(ip6_current_dest_addr()), + IP6_ADDR_BLOCK7(ip6_current_dest_addr()), + IP6_ADDR_BLOCK8(ip6_current_dest_addr()))); + + /* transmit pbuf on chosen interface */ + netif->output_ip6(netif, p, ip6_current_dest_addr()); + IP6_STATS_INC(ip6.fw); + IP6_STATS_INC(ip6.xmit); + return; +} +#endif /* LWIP_IPV6_FORWARD */ + +/** Return true if the current input packet should be accepted on this netif */ +static int +ip6_input_accept(struct netif *netif) +{ + /* interface is up? */ + if (netif_is_up(netif)) { + u8_t i; + /* unicast to this interface address? address configured? */ + /* If custom scopes are used, the destination zone will be tested as + * part of the local-address comparison, but we need to test the source + * scope as well (e.g., is this interface on the same link?). */ + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + ip6_addr_cmp(ip6_current_dest_addr(), netif_ip6_addr(netif, i)) +#if IPV6_CUSTOM_SCOPES + && (!ip6_addr_has_zone(ip6_current_src_addr()) || + ip6_addr_test_zone(ip6_current_src_addr(), netif)) +#endif /* IPV6_CUSTOM_SCOPES */ + ) { + /* accept on this netif */ + return 1; + } + } + } + return 0; +} + +/** + * This function is called by the network interface device driver when + * an IPv6 packet is received. The function does the basic checks of the + * IP header such as packet size being at least larger than the header + * size etc. If the packet was not destined for us, the packet is + * forwarded (using ip6_forward). + * + * Finally, the packet is sent to the upper layer protocol input function. + * + * @param p the received IPv6 packet (p->payload points to IPv6 header) + * @param inp the netif on which this packet was received + * @return ERR_OK if the packet was processed (could return ERR_* if it wasn't + * processed, but currently always returns ERR_OK) + */ +err_t +ip6_input(struct pbuf *p, struct netif *inp) +{ + struct ip6_hdr *ip6hdr; + struct netif *netif; + const u8_t *nexth; + u16_t hlen, hlen_tot; /* the current header length */ +#if 0 /*IP_ACCEPT_LINK_LAYER_ADDRESSING*/ + @todo + int check_ip_src=1; +#endif /* IP_ACCEPT_LINK_LAYER_ADDRESSING */ +#if LWIP_RAW + raw_input_state_t raw_status; +#endif /* LWIP_RAW */ + + LWIP_ASSERT_CORE_LOCKED(); + + IP6_STATS_INC(ip6.recv); + + /* identify the IP header */ + ip6hdr = (struct ip6_hdr *)p->payload; + if (IP6H_V(ip6hdr) != 6) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_WARNING, ("IPv6 packet dropped due to bad version number %"U32_F"\n", + IP6H_V(ip6hdr))); + pbuf_free(p); + IP6_STATS_INC(ip6.err); + IP6_STATS_INC(ip6.drop); + return ERR_OK; + } + +#ifdef LWIP_HOOK_IP6_INPUT + if (LWIP_HOOK_IP6_INPUT(p, inp)) { + /* the packet has been eaten */ + return ERR_OK; + } +#endif + + /* header length exceeds first pbuf length, or ip length exceeds total pbuf length? */ + if ((IP6_HLEN > p->len) || (IP6H_PLEN(ip6hdr) > (p->tot_len - IP6_HLEN))) { + if (IP6_HLEN > p->len) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IPv6 header (len %"U16_F") does not fit in first pbuf (len %"U16_F"), IP packet dropped.\n", + (u16_t)IP6_HLEN, p->len)); + } + if ((IP6H_PLEN(ip6hdr) + IP6_HLEN) > p->tot_len) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IPv6 (plen %"U16_F") is longer than pbuf (len %"U16_F"), IP packet dropped.\n", + (u16_t)(IP6H_PLEN(ip6hdr) + IP6_HLEN), p->tot_len)); + } + /* free (drop) packet pbufs */ + pbuf_free(p); + IP6_STATS_INC(ip6.lenerr); + IP6_STATS_INC(ip6.drop); + return ERR_OK; + } + + /* Trim pbuf. This should have been done at the netif layer, + * but we'll do it anyway just to be sure that its done. */ + pbuf_realloc(p, (u16_t)(IP6_HLEN + IP6H_PLEN(ip6hdr))); + + /* copy IP addresses to aligned ip6_addr_t */ + ip_addr_copy_from_ip6_packed(ip_data.current_iphdr_dest, ip6hdr->dest); + ip_addr_copy_from_ip6_packed(ip_data.current_iphdr_src, ip6hdr->src); + + /* Don't accept virtual IPv4 mapped IPv6 addresses. + * Don't accept multicast source addresses. */ + if (ip6_addr_isipv4mappedipv6(ip_2_ip6(&ip_data.current_iphdr_dest)) || + ip6_addr_isipv4mappedipv6(ip_2_ip6(&ip_data.current_iphdr_src)) || + ip6_addr_ismulticast(ip_2_ip6(&ip_data.current_iphdr_src))) { + /* free (drop) packet pbufs */ + pbuf_free(p); + IP6_STATS_INC(ip6.err); + IP6_STATS_INC(ip6.drop); + return ERR_OK; + } + + /* Set the appropriate zone identifier on the addresses. */ + ip6_addr_assign_zone(ip_2_ip6(&ip_data.current_iphdr_dest), IP6_UNKNOWN, inp); + ip6_addr_assign_zone(ip_2_ip6(&ip_data.current_iphdr_src), IP6_UNICAST, inp); + + /* current header pointer. */ + ip_data.current_ip6_header = ip6hdr; + + /* In netif, used in case we need to send ICMPv6 packets back. */ + ip_data.current_netif = inp; + ip_data.current_input_netif = inp; + + /* match packet against an interface, i.e. is this packet for us? */ + if (ip6_addr_ismulticast(ip6_current_dest_addr())) { + /* Always joined to multicast if-local and link-local all-nodes group. */ + if (ip6_addr_isallnodes_iflocal(ip6_current_dest_addr()) || + ip6_addr_isallnodes_linklocal(ip6_current_dest_addr())) { + netif = inp; + } +#if LWIP_IPV6_MLD + else if (mld6_lookfor_group(inp, ip6_current_dest_addr())) { + netif = inp; + } +#else /* LWIP_IPV6_MLD */ + else if (ip6_addr_issolicitednode(ip6_current_dest_addr())) { + u8_t i; + /* Filter solicited node packets when MLD is not enabled + * (for Neighbor discovery). */ + netif = NULL; + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(inp, i)) && + ip6_addr_cmp_solicitednode(ip6_current_dest_addr(), netif_ip6_addr(inp, i))) { + netif = inp; + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: solicited node packet accepted on interface %c%c\n", + netif->name[0], netif->name[1])); + break; + } + } + } +#endif /* LWIP_IPV6_MLD */ + else { + netif = NULL; + } + } else { + /* start trying with inp. if that's not acceptable, start walking the + list of configured netifs. */ + if (ip6_input_accept(inp)) { + netif = inp; + } else { + netif = NULL; +#if !IPV6_CUSTOM_SCOPES + /* Shortcut: stop looking for other interfaces if either the source or + * the destination has a scope constrained to this interface. Custom + * scopes may break the 1:1 link/interface mapping, however. */ + if (ip6_addr_islinklocal(ip6_current_dest_addr()) || + ip6_addr_islinklocal(ip6_current_src_addr())) { + goto netif_found; + } +#endif /* !IPV6_CUSTOM_SCOPES */ +#if !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF + /* The loopback address is to be considered link-local. Packets to it + * should be dropped on other interfaces, as per RFC 4291 Sec. 2.5.3. + * Its implied scope means packets *from* the loopback address should + * not be accepted on other interfaces, either. These requirements + * cannot be implemented in the case that loopback traffic is sent + * across a non-loopback interface, however. */ + if (ip6_addr_isloopback(ip6_current_dest_addr()) || + ip6_addr_isloopback(ip6_current_src_addr())) { + goto netif_found; + } +#endif /* !LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF */ +#if !LWIP_SINGLE_NETIF + NETIF_FOREACH(netif) { + if (netif == inp) { + /* we checked that before already */ + continue; + } + if (ip6_input_accept(netif)) { + break; + } + } +#endif /* !LWIP_SINGLE_NETIF */ + } +netif_found: + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet accepted on interface %c%c\n", + netif ? netif->name[0] : 'X', netif? netif->name[1] : 'X')); + } + + /* "::" packet source address? (used in duplicate address detection) */ + if (ip6_addr_isany(ip6_current_src_addr()) && + (!ip6_addr_issolicitednode(ip6_current_dest_addr()))) { + /* packet source is not valid */ + /* free (drop) packet pbufs */ + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with src ANY_ADDRESS dropped\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + + /* packet not for us? */ + if (netif == NULL) { + /* packet not for us, route or discard */ + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_TRACE, ("ip6_input: packet not for us.\n")); +#if LWIP_IPV6_FORWARD + /* non-multicast packet? */ + if (!ip6_addr_ismulticast(ip6_current_dest_addr())) { + /* try to forward IP packet on (other) interfaces */ + ip6_forward(p, ip6hdr, inp); + } +#endif /* LWIP_IPV6_FORWARD */ + pbuf_free(p); + goto ip6_input_cleanup; + } + + /* current netif pointer. */ + ip_data.current_netif = netif; + + /* Save next header type. */ + nexth = &IP6H_NEXTH(ip6hdr); + + /* Init header length. */ + hlen = hlen_tot = IP6_HLEN; + + /* Move to payload. */ + pbuf_remove_header(p, IP6_HLEN); + + /* Process known option extension headers, if present. */ + while (*nexth != IP6_NEXTH_NONE) + { + switch (*nexth) { + case IP6_NEXTH_HOPBYHOP: + { + s32_t opt_offset; + struct ip6_hbh_hdr *hbh_hdr; + struct ip6_opt_hdr *opt_hdr; + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Hop-by-Hop options header\n")); + + /* Get and check the header length, while staying in packet bounds. */ + hbh_hdr = (struct ip6_hbh_hdr *)p->payload; + + /* Get next header type. */ + nexth = &IP6_HBH_NEXTH(hbh_hdr); + + /* Get the header length. */ + hlen = (u16_t)(8 * (1 + hbh_hdr->_hlen)); + + if ((p->len < 8) || (hlen > p->len)) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", + hlen, p->len)); + /* free (drop) packet pbufs */ + pbuf_free(p); + IP6_STATS_INC(ip6.lenerr); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + + hlen_tot = (u16_t)(hlen_tot + hlen); + + /* The extended option header starts right after Hop-by-Hop header. */ + opt_offset = IP6_HBH_HLEN; + while (opt_offset < hlen) + { + s32_t opt_dlen = 0; + + opt_hdr = (struct ip6_opt_hdr *)((u8_t *)hbh_hdr + opt_offset); + + switch (IP6_OPT_TYPE(opt_hdr)) { + /* @todo: process IPV6 Hop-by-Hop option data */ + case IP6_PAD1_OPTION: + /* PAD1 option doesn't have length and value field */ + opt_dlen = -1; + break; + case IP6_PADN_OPTION: + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + case IP6_ROUTER_ALERT_OPTION: + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + case IP6_JUMBO_OPTION: + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + default: + /* Check 2 MSB of Hop-by-Hop header type. */ + switch (IP6_OPT_TYPE_ACTION(opt_hdr)) { + case 1: + /* Discard the packet. */ + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid Hop-by-Hop option type dropped.\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + case 2: + /* Send ICMP Parameter Problem */ + icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid Hop-by-Hop option type dropped.\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + case 3: + /* Send ICMP Parameter Problem if destination address is not a multicast address */ + if (!ip6_addr_ismulticast(ip6_current_dest_addr())) { + icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); + } + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid Hop-by-Hop option type dropped.\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + default: + /* Skip over this option. */ + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + } + break; + } + + /* Adjust the offset to move to the next extended option header */ + opt_offset = opt_offset + IP6_OPT_HLEN + opt_dlen; + } + pbuf_remove_header(p, hlen); + break; + } + case IP6_NEXTH_DESTOPTS: + { + s32_t opt_offset; + struct ip6_dest_hdr *dest_hdr; + struct ip6_opt_hdr *opt_hdr; + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Destination options header\n")); + + dest_hdr = (struct ip6_dest_hdr *)p->payload; + + /* Get next header type. */ + nexth = &IP6_DEST_NEXTH(dest_hdr); + + /* Get the header length. */ + hlen = 8 * (1 + dest_hdr->_hlen); + if ((p->len < 8) || (hlen > p->len)) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", + hlen, p->len)); + /* free (drop) packet pbufs */ + pbuf_free(p); + IP6_STATS_INC(ip6.lenerr); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + + hlen_tot = (u16_t)(hlen_tot + hlen); + + /* The extended option header starts right after Destination header. */ + opt_offset = IP6_DEST_HLEN; + while (opt_offset < hlen) + { + s32_t opt_dlen = 0; + + opt_hdr = (struct ip6_opt_hdr *)((u8_t *)dest_hdr + opt_offset); + + switch (IP6_OPT_TYPE(opt_hdr)) + { + /* @todo: process IPV6 Destination option data */ + case IP6_PAD1_OPTION: + /* PAD1 option deosn't have length and value field */ + opt_dlen = -1; + break; + case IP6_PADN_OPTION: + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + case IP6_ROUTER_ALERT_OPTION: + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + case IP6_JUMBO_OPTION: + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + case IP6_HOME_ADDRESS_OPTION: + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + default: + /* Check 2 MSB of Destination header type. */ + switch (IP6_OPT_TYPE_ACTION(opt_hdr)) + { + case 1: + /* Discard the packet. */ + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid destination option type dropped.\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + case 2: + /* Send ICMP Parameter Problem */ + icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid destination option type dropped.\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + case 3: + /* Send ICMP Parameter Problem if destination address is not a multicast address */ + if (!ip6_addr_ismulticast(ip6_current_dest_addr())) { + icmp6_param_problem(p, ICMP6_PP_OPTION, opt_hdr); + } + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid destination option type dropped.\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + default: + /* Skip over this option. */ + opt_dlen = IP6_OPT_DLEN(opt_hdr); + break; + } + break; + } + + /* Adjust the offset to move to the next extended option header */ + opt_offset = opt_offset + IP6_OPT_HLEN + opt_dlen; + } + + pbuf_remove_header(p, hlen); + break; + } + case IP6_NEXTH_ROUTING: + { + struct ip6_rout_hdr *rout_hdr; + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Routing header\n")); + + rout_hdr = (struct ip6_rout_hdr *)p->payload; + + /* Get next header type. */ + nexth = &IP6_ROUT_NEXTH(rout_hdr); + + /* Get the header length. */ + hlen = 8 * (1 + rout_hdr->_hlen); + + if ((p->len < 8) || (hlen > p->len)) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", + hlen, p->len)); + /* free (drop) packet pbufs */ + pbuf_free(p); + IP6_STATS_INC(ip6.lenerr); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + + /* Skip over this header. */ + hlen_tot = (u16_t)(hlen_tot + hlen); + + /* if segment left value is 0 in routing header, ignore the option */ + if (IP6_ROUT_SEG_LEFT(rout_hdr)) { + /* The length field of routing option header must be even */ + if (rout_hdr->_hlen & 0x1) { + /* Discard and send parameter field error */ + icmp6_param_problem(p, ICMP6_PP_FIELD, &rout_hdr->_hlen); + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid routing type dropped\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + + switch (IP6_ROUT_TYPE(rout_hdr)) + { + /* TODO: process routing by the type */ + case IP6_ROUT_TYPE2: + break; + case IP6_ROUT_RPL: + break; + default: + /* Discard unrecognized routing type and send parameter field error */ + icmp6_param_problem(p, ICMP6_PP_FIELD, &IP6_ROUT_TYPE(rout_hdr)); + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid routing type dropped\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + } + + pbuf_remove_header(p, hlen); + break; + } + case IP6_NEXTH_FRAGMENT: + { + struct ip6_frag_hdr *frag_hdr; + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header\n")); + + frag_hdr = (struct ip6_frag_hdr *)p->payload; + + /* Get next header type. */ + nexth = &IP6_FRAG_NEXTH(frag_hdr); + + /* Fragment Header length. */ + hlen = 8; + + /* Make sure this header fits in current pbuf. */ + if (hlen > p->len) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("IPv6 options header (hlen %"U16_F") does not fit in first pbuf (len %"U16_F"), IPv6 packet dropped.\n", + hlen, p->len)); + /* free (drop) packet pbufs */ + pbuf_free(p); + IP6_FRAG_STATS_INC(ip6_frag.lenerr); + IP6_FRAG_STATS_INC(ip6_frag.drop); + goto ip6_input_cleanup; + } + + hlen_tot = (u16_t)(hlen_tot + hlen); + + /* check payload length is multiple of 8 octets when mbit is set */ + if (IP6_FRAG_MBIT(frag_hdr) && (IP6H_PLEN(ip6hdr) & 0x7)) { + /* ipv6 payload length is not multiple of 8 octets */ + icmp6_param_problem(p, ICMP6_PP_FIELD, LWIP_PACKED_CAST(const void *, &ip6hdr->_plen)); + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with invalid payload length dropped\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + + /* Offset == 0 and more_fragments == 0? */ + if ((frag_hdr->_fragment_offset & + PP_HTONS(IP6_FRAG_OFFSET_MASK | IP6_FRAG_MORE_FLAG)) == 0) { + /* This is a 1-fragment packet. Skip this header and continue. */ + pbuf_remove_header(p, hlen); + } else { +#if LWIP_IPV6_REASS + /* reassemble the packet */ + ip_data.current_ip_header_tot_len = hlen_tot; + p = ip6_reass(p); + /* packet not fully reassembled yet? */ + if (p == NULL) { + goto ip6_input_cleanup; + } + + /* Returned p point to IPv6 header. + * Update all our variables and pointers and continue. */ + ip6hdr = (struct ip6_hdr *)p->payload; + nexth = &IP6H_NEXTH(ip6hdr); + hlen = hlen_tot = IP6_HLEN; + pbuf_remove_header(p, IP6_HLEN); + +#else /* LWIP_IPV6_REASS */ + /* free (drop) packet pbufs */ + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Fragment header dropped (with LWIP_IPV6_REASS==0)\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.opterr); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; +#endif /* LWIP_IPV6_REASS */ + } + break; + } + default: + goto options_done; + } + + if (*nexth == IP6_NEXTH_HOPBYHOP) { + /* Hop-by-Hop header comes only as a first option */ + icmp6_param_problem(p, ICMP6_PP_HEADER, nexth); + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: packet with Hop-by-Hop options header dropped (only valid as a first option)\n")); + pbuf_free(p); + IP6_STATS_INC(ip6.drop); + goto ip6_input_cleanup; + } + } + +options_done: + + /* send to upper layers */ + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: \n")); + ip6_debug_print(p); + LWIP_DEBUGF(IP6_DEBUG, ("ip6_input: p->len %"U16_F" p->tot_len %"U16_F"\n", p->len, p->tot_len)); + + ip_data.current_ip_header_tot_len = hlen_tot; + +#if LWIP_RAW + /* p points to IPv6 header again for raw_input. */ + pbuf_add_header_force(p, hlen_tot); + /* raw input did not eat the packet? */ + raw_status = raw_input(p, inp); + if (raw_status != RAW_INPUT_EATEN) + { + /* Point to payload. */ + pbuf_remove_header(p, hlen_tot); +#else /* LWIP_RAW */ + { +#endif /* LWIP_RAW */ + switch (*nexth) { + case IP6_NEXTH_NONE: + pbuf_free(p); + break; +#if LWIP_UDP + case IP6_NEXTH_UDP: +#if LWIP_UDPLITE + case IP6_NEXTH_UDPLITE: +#endif /* LWIP_UDPLITE */ + udp_input(p, inp); + break; +#endif /* LWIP_UDP */ +#if LWIP_TCP + case IP6_NEXTH_TCP: + tcp_input(p, inp); + break; +#endif /* LWIP_TCP */ +#if LWIP_ICMP6 + case IP6_NEXTH_ICMP6: + icmp6_input(p, inp); + break; +#endif /* LWIP_ICMP */ + default: +#if LWIP_RAW + if (raw_status == RAW_INPUT_DELIVERED) { + /* @todo: ipv6 mib in-delivers? */ + } else +#endif /* LWIP_RAW */ + { +#if LWIP_ICMP6 + /* p points to IPv6 header again for raw_input. */ + pbuf_add_header_force(p, hlen_tot); + /* send ICMP parameter problem unless it was a multicast or ICMPv6 */ + if ((!ip6_addr_ismulticast(ip6_current_dest_addr())) && + (IP6H_NEXTH(ip6hdr) != IP6_NEXTH_ICMP6)) { + icmp6_param_problem(p, ICMP6_PP_HEADER, nexth); + } +#endif /* LWIP_ICMP */ + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_input: Unsupported transport protocol %"U16_F"\n", (u16_t)IP6H_NEXTH(ip6hdr))); + IP6_STATS_INC(ip6.proterr); + IP6_STATS_INC(ip6.drop); + } + pbuf_free(p); + break; + } + } + +ip6_input_cleanup: + ip_data.current_netif = NULL; + ip_data.current_input_netif = NULL; + ip_data.current_ip6_header = NULL; + ip_data.current_ip_header_tot_len = 0; + ip6_addr_set_zero(ip6_current_src_addr()); + ip6_addr_set_zero(ip6_current_dest_addr()); + + return ERR_OK; +} + + +/** + * Sends an IPv6 packet on a network interface. This function constructs + * the IPv6 header. If the source IPv6 address is NULL, the IPv6 "ANY" address is + * used as source (usually during network startup). If the source IPv6 address it + * IP6_ADDR_ANY, the most appropriate IPv6 address of the outgoing network + * interface is filled in as source address. If the destination IPv6 address is + * LWIP_IP_HDRINCL, p is assumed to already include an IPv6 header and + * p->payload points to it instead of the data. + * + * @param p the packet to send (p->payload points to the data, e.g. next + protocol header; if dest == LWIP_IP_HDRINCL, p already includes an + IPv6 header and p->payload points to that IPv6 header) + * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an + * IP address of the netif is selected and used as source address. + * if src == NULL, IP6_ADDR_ANY is used as source) (src is possibly not + * properly zoned) + * @param dest the destination IPv6 address to send the packet to (possibly not + * properly zoned) + * @param hl the Hop Limit value to be set in the IPv6 header + * @param tc the Traffic Class value to be set in the IPv6 header + * @param nexth the Next Header to be set in the IPv6 header + * @param netif the netif on which to send this packet + * @return ERR_OK if the packet was sent OK + * ERR_BUF if p doesn't have enough space for IPv6/LINK headers + * returns errors returned by netif->output_ip6 + */ +err_t +ip6_output_if(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, + u8_t nexth, struct netif *netif) +{ + const ip6_addr_t *src_used = src; + if (dest != LWIP_IP_HDRINCL) { + if (src != NULL && ip6_addr_isany(src)) { + src_used = ip_2_ip6(ip6_select_source_address(netif, dest)); + if ((src_used == NULL) || ip6_addr_isany(src_used)) { + /* No appropriate source address was found for this packet. */ + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: No suitable source address for packet.\n")); + IP6_STATS_INC(ip6.rterr); + return ERR_RTE; + } + } + } + return ip6_output_if_src(p, src_used, dest, hl, tc, nexth, netif); +} + +/** + * Same as ip6_output_if() but 'src' address is not replaced by netif address + * when it is 'any'. + */ +err_t +ip6_output_if_src(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, + u8_t nexth, struct netif *netif) +{ + struct ip6_hdr *ip6hdr; + ip6_addr_t dest_addr; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); + + /* Should the IPv6 header be generated or is it already included in p? */ + if (dest != LWIP_IP_HDRINCL) { +#if LWIP_IPV6_SCOPES + /* If the destination address is scoped but lacks a zone, add a zone now, + * based on the outgoing interface. The lower layers (e.g., nd6) absolutely + * require addresses to be properly zoned for correctness. In some cases, + * earlier attempts will have been made to add a zone to the destination, + * but this function is the only one that is called in all (other) cases, + * so we must do this here. */ + if (ip6_addr_lacks_zone(dest, IP6_UNKNOWN)) { + ip6_addr_copy(dest_addr, *dest); + ip6_addr_assign_zone(&dest_addr, IP6_UNKNOWN, netif); + dest = &dest_addr; + } +#endif /* LWIP_IPV6_SCOPES */ + + /* generate IPv6 header */ + if (pbuf_add_header(p, IP6_HLEN)) { + LWIP_DEBUGF(IP6_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("ip6_output: not enough room for IPv6 header in pbuf\n")); + IP6_STATS_INC(ip6.err); + return ERR_BUF; + } + + ip6hdr = (struct ip6_hdr *)p->payload; + LWIP_ASSERT("check that first pbuf can hold struct ip6_hdr", + (p->len >= sizeof(struct ip6_hdr))); + + IP6H_HOPLIM_SET(ip6hdr, hl); + IP6H_NEXTH_SET(ip6hdr, nexth); + + /* dest cannot be NULL here */ + ip6_addr_copy_to_packed(ip6hdr->dest, *dest); + + IP6H_VTCFL_SET(ip6hdr, 6, tc, 0); + IP6H_PLEN_SET(ip6hdr, (u16_t)(p->tot_len - IP6_HLEN)); + + if (src == NULL) { + src = IP6_ADDR_ANY6; + } + /* src cannot be NULL here */ + ip6_addr_copy_to_packed(ip6hdr->src, *src); + + } else { + /* IP header already included in p */ + ip6hdr = (struct ip6_hdr *)p->payload; + ip6_addr_copy_from_packed(dest_addr, ip6hdr->dest); + ip6_addr_assign_zone(&dest_addr, IP6_UNKNOWN, netif); + dest = &dest_addr; + } + + IP6_STATS_INC(ip6.xmit); + + LWIP_DEBUGF(IP6_DEBUG, ("ip6_output_if: %c%c%"U16_F"\n", netif->name[0], netif->name[1], (u16_t)netif->num)); + ip6_debug_print(p); + +#if ENABLE_LOOPBACK + { + int i; +#if !LWIP_HAVE_LOOPIF + if (ip6_addr_isloopback(dest)) { + return netif_loop_output(netif, p); + } +#endif /* !LWIP_HAVE_LOOPIF */ + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + ip6_addr_cmp(dest, netif_ip6_addr(netif, i))) { + /* Packet to self, enqueue it for loopback */ + LWIP_DEBUGF(IP6_DEBUG, ("netif_loop_output()\n")); + return netif_loop_output(netif, p); + } + } + } +#if LWIP_MULTICAST_TX_OPTIONS + if ((p->flags & PBUF_FLAG_MCASTLOOP) != 0) { + netif_loop_output(netif, p); + } +#endif /* LWIP_MULTICAST_TX_OPTIONS */ +#endif /* ENABLE_LOOPBACK */ +#if LWIP_IPV6_FRAG + /* don't fragment if interface has mtu set to 0 [loopif] */ + if (netif_mtu6(netif) && (p->tot_len > nd6_get_destination_mtu(dest, netif))) { + return ip6_frag(p, netif, dest); + } +#endif /* LWIP_IPV6_FRAG */ + + LWIP_DEBUGF(IP6_DEBUG, ("netif->output_ip6()\n")); + return netif->output_ip6(netif, p, dest); +} + +/** + * Simple interface to ip6_output_if. It finds the outgoing network + * interface and calls upon ip6_output_if to do the actual work. + * + * @param p the packet to send (p->payload points to the data, e.g. next + protocol header; if dest == LWIP_IP_HDRINCL, p already includes an + IPv6 header and p->payload points to that IPv6 header) + * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an + * IP address of the netif is selected and used as source address. + * if src == NULL, IP6_ADDR_ANY is used as source) + * @param dest the destination IPv6 address to send the packet to + * @param hl the Hop Limit value to be set in the IPv6 header + * @param tc the Traffic Class value to be set in the IPv6 header + * @param nexth the Next Header to be set in the IPv6 header + * + * @return ERR_RTE if no route is found + * see ip_output_if() for more return values + */ +err_t +ip6_output(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, u8_t nexth) +{ + struct netif *netif; + struct ip6_hdr *ip6hdr; + ip6_addr_t src_addr, dest_addr; + + LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); + + if (dest != LWIP_IP_HDRINCL) { + netif = ip6_route(src, dest); + } else { + /* IP header included in p, read addresses. */ + ip6hdr = (struct ip6_hdr *)p->payload; + ip6_addr_copy_from_packed(src_addr, ip6hdr->src); + ip6_addr_copy_from_packed(dest_addr, ip6hdr->dest); + netif = ip6_route(&src_addr, &dest_addr); + } + + if (netif == NULL) { + LWIP_DEBUGF(IP6_DEBUG, ("ip6_output: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", + IP6_ADDR_BLOCK1(dest), + IP6_ADDR_BLOCK2(dest), + IP6_ADDR_BLOCK3(dest), + IP6_ADDR_BLOCK4(dest), + IP6_ADDR_BLOCK5(dest), + IP6_ADDR_BLOCK6(dest), + IP6_ADDR_BLOCK7(dest), + IP6_ADDR_BLOCK8(dest))); + IP6_STATS_INC(ip6.rterr); + return ERR_RTE; + } + + return ip6_output_if(p, src, dest, hl, tc, nexth, netif); +} + + +#if LWIP_NETIF_USE_HINTS +/** Like ip6_output, but takes and addr_hint pointer that is passed on to netif->addr_hint + * before calling ip6_output_if. + * + * @param p the packet to send (p->payload points to the data, e.g. next + protocol header; if dest == LWIP_IP_HDRINCL, p already includes an + IPv6 header and p->payload points to that IPv6 header) + * @param src the source IPv6 address to send from (if src == IP6_ADDR_ANY, an + * IP address of the netif is selected and used as source address. + * if src == NULL, IP6_ADDR_ANY is used as source) + * @param dest the destination IPv6 address to send the packet to + * @param hl the Hop Limit value to be set in the IPv6 header + * @param tc the Traffic Class value to be set in the IPv6 header + * @param nexth the Next Header to be set in the IPv6 header + * @param netif_hint netif output hint pointer set to netif->hint before + * calling ip_output_if() + * + * @return ERR_RTE if no route is found + * see ip_output_if() for more return values + */ +err_t +ip6_output_hinted(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, u8_t nexth, struct netif_hint *netif_hint) +{ + struct netif *netif; + struct ip6_hdr *ip6hdr; + ip6_addr_t src_addr, dest_addr; + err_t err; + + LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p); + + if (dest != LWIP_IP_HDRINCL) { + netif = ip6_route(src, dest); + } else { + /* IP header included in p, read addresses. */ + ip6hdr = (struct ip6_hdr *)p->payload; + ip6_addr_copy_from_packed(src_addr, ip6hdr->src); + ip6_addr_copy_from_packed(dest_addr, ip6hdr->dest); + netif = ip6_route(&src_addr, &dest_addr); + } + + if (netif == NULL) { + LWIP_DEBUGF(IP6_DEBUG, ("ip6_output: no route for %"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F":%"X16_F"\n", + IP6_ADDR_BLOCK1(dest), + IP6_ADDR_BLOCK2(dest), + IP6_ADDR_BLOCK3(dest), + IP6_ADDR_BLOCK4(dest), + IP6_ADDR_BLOCK5(dest), + IP6_ADDR_BLOCK6(dest), + IP6_ADDR_BLOCK7(dest), + IP6_ADDR_BLOCK8(dest))); + IP6_STATS_INC(ip6.rterr); + return ERR_RTE; + } + + NETIF_SET_HINTS(netif, netif_hint); + err = ip6_output_if(p, src, dest, hl, tc, nexth, netif); + NETIF_RESET_HINTS(netif); + + return err; +} +#endif /* LWIP_NETIF_USE_HINTS*/ + +#if LWIP_IPV6_MLD +/** + * Add a hop-by-hop options header with a router alert option and padding. + * + * Used by MLD when sending a Multicast listener report/done message. + * + * @param p the packet to which we will prepend the options header + * @param nexth the next header protocol number (e.g. IP6_NEXTH_ICMP6) + * @param value the value of the router alert option data (e.g. IP6_ROUTER_ALERT_VALUE_MLD) + * @return ERR_OK if hop-by-hop header was added, ERR_* otherwise + */ +err_t +ip6_options_add_hbh_ra(struct pbuf *p, u8_t nexth, u8_t value) +{ + u8_t *opt_data; + u32_t offset = 0; + struct ip6_hbh_hdr *hbh_hdr; + struct ip6_opt_hdr *opt_hdr; + + /* fixed 4 bytes for router alert option and 2 bytes padding */ + const u8_t hlen = (sizeof(struct ip6_opt_hdr) * 2) + IP6_ROUTER_ALERT_DLEN; + /* Move pointer to make room for hop-by-hop options header. */ + if (pbuf_add_header(p, sizeof(struct ip6_hbh_hdr) + hlen)) { + LWIP_DEBUGF(IP6_DEBUG, ("ip6_options: no space for options header\n")); + IP6_STATS_INC(ip6.err); + return ERR_BUF; + } + + /* Set fields of Hop-by-Hop header */ + hbh_hdr = (struct ip6_hbh_hdr *)p->payload; + IP6_HBH_NEXTH(hbh_hdr) = nexth; + hbh_hdr->_hlen = 0; + offset = IP6_HBH_HLEN; + + /* Set router alert options to Hop-by-Hop extended option header */ + opt_hdr = (struct ip6_opt_hdr *)((u8_t *)hbh_hdr + offset); + IP6_OPT_TYPE(opt_hdr) = IP6_ROUTER_ALERT_OPTION; + IP6_OPT_DLEN(opt_hdr) = IP6_ROUTER_ALERT_DLEN; + offset += IP6_OPT_HLEN; + + /* Set router alert option data */ + opt_data = (u8_t *)hbh_hdr + offset; + opt_data[0] = value; + opt_data[1] = 0; + offset += IP6_OPT_DLEN(opt_hdr); + + /* add 2 bytes padding to make 8 bytes Hop-by-Hop header length */ + opt_hdr = (struct ip6_opt_hdr *)((u8_t *)hbh_hdr + offset); + IP6_OPT_TYPE(opt_hdr) = IP6_PADN_OPTION; + IP6_OPT_DLEN(opt_hdr) = 0; + + return ERR_OK; +} +#endif /* LWIP_IPV6_MLD */ + +#if IP6_DEBUG +/* Print an IPv6 header by using LWIP_DEBUGF + * @param p an IPv6 packet, p->payload pointing to the IPv6 header + */ +void +ip6_debug_print(struct pbuf *p) +{ + struct ip6_hdr *ip6hdr = (struct ip6_hdr *)p->payload; + + LWIP_DEBUGF(IP6_DEBUG, ("IPv6 header:\n")); + LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP6_DEBUG, ("| %2"U16_F" | %3"U16_F" | %7"U32_F" | (ver, class, flow)\n", + IP6H_V(ip6hdr), + IP6H_TC(ip6hdr), + IP6H_FL(ip6hdr))); + LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP6_DEBUG, ("| %5"U16_F" | %3"U16_F" | %3"U16_F" | (plen, nexth, hopl)\n", + IP6H_PLEN(ip6hdr), + IP6H_NEXTH(ip6hdr), + IP6H_HOPLIM(ip6hdr))); + LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" | (src)\n", + IP6_ADDR_BLOCK1(&(ip6hdr->src)), + IP6_ADDR_BLOCK2(&(ip6hdr->src)), + IP6_ADDR_BLOCK3(&(ip6hdr->src)), + IP6_ADDR_BLOCK4(&(ip6hdr->src)))); + LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" |\n", + IP6_ADDR_BLOCK5(&(ip6hdr->src)), + IP6_ADDR_BLOCK6(&(ip6hdr->src)), + IP6_ADDR_BLOCK7(&(ip6hdr->src)), + IP6_ADDR_BLOCK8(&(ip6hdr->src)))); + LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" | (dest)\n", + IP6_ADDR_BLOCK1(&(ip6hdr->dest)), + IP6_ADDR_BLOCK2(&(ip6hdr->dest)), + IP6_ADDR_BLOCK3(&(ip6hdr->dest)), + IP6_ADDR_BLOCK4(&(ip6hdr->dest)))); + LWIP_DEBUGF(IP6_DEBUG, ("| %4"X32_F" | %4"X32_F" | %4"X32_F" | %4"X32_F" |\n", + IP6_ADDR_BLOCK5(&(ip6hdr->dest)), + IP6_ADDR_BLOCK6(&(ip6hdr->dest)), + IP6_ADDR_BLOCK7(&(ip6hdr->dest)), + IP6_ADDR_BLOCK8(&(ip6hdr->dest)))); + LWIP_DEBUGF(IP6_DEBUG, ("+-------------------------------+\n")); +} +#endif /* IP6_DEBUG */ + +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_addr.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_addr.c index aafba72c..687c02f7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_addr.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_addr.c @@ -1,343 +1,343 @@ -/** - * @file - * - * IPv6 addresses. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * Functions for handling IPv6 addresses. - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/ip_addr.h" -#include "lwip/def.h" - -#include - -#if LWIP_IPV4 -#include "lwip/ip4_addr.h" /* for ip6addr_aton to handle IPv4-mapped addresses */ -#endif /* LWIP_IPV4 */ - -/* used by IP6_ADDR_ANY(6) in ip6_addr.h */ -const ip_addr_t ip6_addr_any = IPADDR6_INIT(0ul, 0ul, 0ul, 0ul); - -#define lwip_xchar(i) ((char)((i) < 10 ? '0' + (i) : 'A' + (i) - 10)) - -/** - * Check whether "cp" is a valid ascii representation - * of an IPv6 address and convert to a binary address. - * Returns 1 if the address is valid, 0 if not. - * - * @param cp IPv6 address in ascii representation (e.g. "FF01::1") - * @param addr pointer to which to save the ip address in network order - * @return 1 if cp could be converted to addr, 0 on failure - */ -int -ip6addr_aton(const char *cp, ip6_addr_t *addr) -{ - u32_t addr_index, zero_blocks, current_block_index, current_block_value; - const char *s; -#if LWIP_IPV4 - int check_ipv4_mapped = 0; -#endif /* LWIP_IPV4 */ - - /* Count the number of colons, to count the number of blocks in a "::" sequence - zero_blocks may be 1 even if there are no :: sequences */ - zero_blocks = 8; - for (s = cp; *s != 0; s++) { - if (*s == ':') { - zero_blocks--; -#if LWIP_IPV4 - } else if (*s == '.') { - if ((zero_blocks == 5) ||(zero_blocks == 2)) { - check_ipv4_mapped = 1; - /* last block could be the start of an IPv4 address */ - zero_blocks--; - } else { - /* invalid format */ - return 0; - } - break; -#endif /* LWIP_IPV4 */ - } else if (!lwip_isxdigit(*s)) { - break; - } - } - - /* parse each block */ - addr_index = 0; - current_block_index = 0; - current_block_value = 0; - for (s = cp; *s != 0; s++) { - if (*s == ':') { - if (addr) { - if (current_block_index & 0x1) { - addr->addr[addr_index++] |= current_block_value; - } - else { - addr->addr[addr_index] = current_block_value << 16; - } - } - current_block_index++; -#if LWIP_IPV4 - if (check_ipv4_mapped) { - if (current_block_index == 6) { - ip4_addr_t ip4; - int ret = ip4addr_aton(s + 1, &ip4); - if (ret) { - if (addr) { - addr->addr[3] = lwip_htonl(ip4.addr); - current_block_index++; - goto fix_byte_order_and_return; - } - return 1; - } - } - } -#endif /* LWIP_IPV4 */ - current_block_value = 0; - if (current_block_index > 7) { - /* address too long! */ - return 0; - } - if (s[1] == ':') { - if (s[2] == ':') { - /* invalid format: three successive colons */ - return 0; - } - s++; - /* "::" found, set zeros */ - while (zero_blocks > 0) { - zero_blocks--; - if (current_block_index & 0x1) { - addr_index++; - } else { - if (addr) { - addr->addr[addr_index] = 0; - } - } - current_block_index++; - if (current_block_index > 7) { - /* address too long! */ - return 0; - } - } - } - } else if (lwip_isxdigit(*s)) { - /* add current digit */ - current_block_value = (current_block_value << 4) + - (lwip_isdigit(*s) ? (u32_t)(*s - '0') : - (u32_t)(10 + (lwip_islower(*s) ? *s - 'a' : *s - 'A'))); - } else { - /* unexpected digit, space? CRLF? */ - break; - } - } - - if (addr) { - if (current_block_index & 0x1) { - addr->addr[addr_index++] |= current_block_value; - } - else { - addr->addr[addr_index] = current_block_value << 16; - } -#if LWIP_IPV4 -fix_byte_order_and_return: -#endif - /* convert to network byte order. */ - for (addr_index = 0; addr_index < 4; addr_index++) { - addr->addr[addr_index] = lwip_htonl(addr->addr[addr_index]); - } - - ip6_addr_clear_zone(addr); - } - - if (current_block_index != 7) { - return 0; - } - - return 1; -} - -/** - * Convert numeric IPv6 address into ASCII representation. - * returns ptr to static buffer; not reentrant! - * - * @param addr ip6 address in network order to convert - * @return pointer to a global static (!) buffer that holds the ASCII - * representation of addr - */ -char * -ip6addr_ntoa(const ip6_addr_t *addr) -{ - static char str[40]; - return ip6addr_ntoa_r(addr, str, 40); -} - -/** - * Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used. - * - * @param addr ip6 address in network order to convert - * @param buf target buffer where the string is stored - * @param buflen length of buf - * @return either pointer to buf which now holds the ASCII - * representation of addr or NULL if buf was too small - */ -char * -ip6addr_ntoa_r(const ip6_addr_t *addr, char *buf, int buflen) -{ - u32_t current_block_index, current_block_value, next_block_value; - s32_t i; - u8_t zero_flag, empty_block_flag; - -#if LWIP_IPV4 - if (ip6_addr_isipv4mappedipv6(addr)) { - /* This is an IPv4 mapped address */ - ip4_addr_t addr4; - char *ret; -#define IP4MAPPED_HEADER "::FFFF:" - char *buf_ip4 = buf + sizeof(IP4MAPPED_HEADER) - 1; - int buflen_ip4 = buflen - sizeof(IP4MAPPED_HEADER) + 1; - if (buflen < (int)sizeof(IP4MAPPED_HEADER)) { - return NULL; - } - memcpy(buf, IP4MAPPED_HEADER, sizeof(IP4MAPPED_HEADER)); - addr4.addr = addr->addr[3]; - ret = ip4addr_ntoa_r(&addr4, buf_ip4, buflen_ip4); - if (ret != buf_ip4) { - return NULL; - } - return buf; - } -#endif /* LWIP_IPV4 */ - i = 0; - empty_block_flag = 0; /* used to indicate a zero chain for "::' */ - - for (current_block_index = 0; current_block_index < 8; current_block_index++) { - /* get the current 16-bit block */ - current_block_value = lwip_htonl(addr->addr[current_block_index >> 1]); - if ((current_block_index & 0x1) == 0) { - current_block_value = current_block_value >> 16; - } - current_block_value &= 0xffff; - - /* Check for empty block. */ - if (current_block_value == 0) { - if (current_block_index == 7 && empty_block_flag == 1) { - /* special case, we must render a ':' for the last block. */ - buf[i++] = ':'; - if (i >= buflen) { - return NULL; - } - break; - } - if (empty_block_flag == 0) { - /* generate empty block "::", but only if more than one contiguous zero block, - * according to current formatting suggestions RFC 5952. */ - next_block_value = lwip_htonl(addr->addr[(current_block_index + 1) >> 1]); - if ((current_block_index & 0x1) == 0x01) { - next_block_value = next_block_value >> 16; - } - next_block_value &= 0xffff; - if (next_block_value == 0) { - empty_block_flag = 1; - buf[i++] = ':'; - if (i >= buflen) { - return NULL; - } - continue; /* move on to next block. */ - } - } else if (empty_block_flag == 1) { - /* move on to next block. */ - continue; - } - } else if (empty_block_flag == 1) { - /* Set this flag value so we don't produce multiple empty blocks. */ - empty_block_flag = 2; - } - - if (current_block_index > 0) { - buf[i++] = ':'; - if (i >= buflen) { - return NULL; - } - } - - if ((current_block_value & 0xf000) == 0) { - zero_flag = 1; - } else { - buf[i++] = lwip_xchar(((current_block_value & 0xf000) >> 12)); - zero_flag = 0; - if (i >= buflen) { - return NULL; - } - } - - if (((current_block_value & 0xf00) == 0) && (zero_flag)) { - /* do nothing */ - } else { - buf[i++] = lwip_xchar(((current_block_value & 0xf00) >> 8)); - zero_flag = 0; - if (i >= buflen) { - return NULL; - } - } - - if (((current_block_value & 0xf0) == 0) && (zero_flag)) { - /* do nothing */ - } - else { - buf[i++] = lwip_xchar(((current_block_value & 0xf0) >> 4)); - zero_flag = 0; - if (i >= buflen) { - return NULL; - } - } - - buf[i++] = lwip_xchar((current_block_value & 0xf)); - if (i >= buflen) { - return NULL; - } - } - - buf[i] = 0; - - return buf; -} - -#endif /* LWIP_IPV6 */ +/** + * @file + * + * IPv6 addresses. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * Functions for handling IPv6 addresses. + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/ip_addr.h" +#include "lwip/def.h" + +#include + +#if LWIP_IPV4 +#include "lwip/ip4_addr.h" /* for ip6addr_aton to handle IPv4-mapped addresses */ +#endif /* LWIP_IPV4 */ + +/* used by IP6_ADDR_ANY(6) in ip6_addr.h */ +const ip_addr_t ip6_addr_any = IPADDR6_INIT(0ul, 0ul, 0ul, 0ul); + +#define lwip_xchar(i) ((char)((i) < 10 ? '0' + (i) : 'A' + (i) - 10)) + +/** + * Check whether "cp" is a valid ascii representation + * of an IPv6 address and convert to a binary address. + * Returns 1 if the address is valid, 0 if not. + * + * @param cp IPv6 address in ascii representation (e.g. "FF01::1") + * @param addr pointer to which to save the ip address in network order + * @return 1 if cp could be converted to addr, 0 on failure + */ +int +ip6addr_aton(const char *cp, ip6_addr_t *addr) +{ + u32_t addr_index, zero_blocks, current_block_index, current_block_value; + const char *s; +#if LWIP_IPV4 + int check_ipv4_mapped = 0; +#endif /* LWIP_IPV4 */ + + /* Count the number of colons, to count the number of blocks in a "::" sequence + zero_blocks may be 1 even if there are no :: sequences */ + zero_blocks = 8; + for (s = cp; *s != 0; s++) { + if (*s == ':') { + zero_blocks--; +#if LWIP_IPV4 + } else if (*s == '.') { + if ((zero_blocks == 5) ||(zero_blocks == 2)) { + check_ipv4_mapped = 1; + /* last block could be the start of an IPv4 address */ + zero_blocks--; + } else { + /* invalid format */ + return 0; + } + break; +#endif /* LWIP_IPV4 */ + } else if (!lwip_isxdigit(*s)) { + break; + } + } + + /* parse each block */ + addr_index = 0; + current_block_index = 0; + current_block_value = 0; + for (s = cp; *s != 0; s++) { + if (*s == ':') { + if (addr) { + if (current_block_index & 0x1) { + addr->addr[addr_index++] |= current_block_value; + } + else { + addr->addr[addr_index] = current_block_value << 16; + } + } + current_block_index++; +#if LWIP_IPV4 + if (check_ipv4_mapped) { + if (current_block_index == 6) { + ip4_addr_t ip4; + int ret = ip4addr_aton(s + 1, &ip4); + if (ret) { + if (addr) { + addr->addr[3] = lwip_htonl(ip4.addr); + current_block_index++; + goto fix_byte_order_and_return; + } + return 1; + } + } + } +#endif /* LWIP_IPV4 */ + current_block_value = 0; + if (current_block_index > 7) { + /* address too long! */ + return 0; + } + if (s[1] == ':') { + if (s[2] == ':') { + /* invalid format: three successive colons */ + return 0; + } + s++; + /* "::" found, set zeros */ + while (zero_blocks > 0) { + zero_blocks--; + if (current_block_index & 0x1) { + addr_index++; + } else { + if (addr) { + addr->addr[addr_index] = 0; + } + } + current_block_index++; + if (current_block_index > 7) { + /* address too long! */ + return 0; + } + } + } + } else if (lwip_isxdigit(*s)) { + /* add current digit */ + current_block_value = (current_block_value << 4) + + (lwip_isdigit(*s) ? (u32_t)(*s - '0') : + (u32_t)(10 + (lwip_islower(*s) ? *s - 'a' : *s - 'A'))); + } else { + /* unexpected digit, space? CRLF? */ + break; + } + } + + if (addr) { + if (current_block_index & 0x1) { + addr->addr[addr_index++] |= current_block_value; + } + else { + addr->addr[addr_index] = current_block_value << 16; + } +#if LWIP_IPV4 +fix_byte_order_and_return: +#endif + /* convert to network byte order. */ + for (addr_index = 0; addr_index < 4; addr_index++) { + addr->addr[addr_index] = lwip_htonl(addr->addr[addr_index]); + } + + ip6_addr_clear_zone(addr); + } + + if (current_block_index != 7) { + return 0; + } + + return 1; +} + +/** + * Convert numeric IPv6 address into ASCII representation. + * returns ptr to static buffer; not reentrant! + * + * @param addr ip6 address in network order to convert + * @return pointer to a global static (!) buffer that holds the ASCII + * representation of addr + */ +char * +ip6addr_ntoa(const ip6_addr_t *addr) +{ + static char str[40]; + return ip6addr_ntoa_r(addr, str, 40); +} + +/** + * Same as ipaddr_ntoa, but reentrant since a user-supplied buffer is used. + * + * @param addr ip6 address in network order to convert + * @param buf target buffer where the string is stored + * @param buflen length of buf + * @return either pointer to buf which now holds the ASCII + * representation of addr or NULL if buf was too small + */ +char * +ip6addr_ntoa_r(const ip6_addr_t *addr, char *buf, int buflen) +{ + u32_t current_block_index, current_block_value, next_block_value; + s32_t i; + u8_t zero_flag, empty_block_flag; + +#if LWIP_IPV4 + if (ip6_addr_isipv4mappedipv6(addr)) { + /* This is an IPv4 mapped address */ + ip4_addr_t addr4; + char *ret; +#define IP4MAPPED_HEADER "::FFFF:" + char *buf_ip4 = buf + sizeof(IP4MAPPED_HEADER) - 1; + int buflen_ip4 = buflen - sizeof(IP4MAPPED_HEADER) + 1; + if (buflen < (int)sizeof(IP4MAPPED_HEADER)) { + return NULL; + } + memcpy(buf, IP4MAPPED_HEADER, sizeof(IP4MAPPED_HEADER)); + addr4.addr = addr->addr[3]; + ret = ip4addr_ntoa_r(&addr4, buf_ip4, buflen_ip4); + if (ret != buf_ip4) { + return NULL; + } + return buf; + } +#endif /* LWIP_IPV4 */ + i = 0; + empty_block_flag = 0; /* used to indicate a zero chain for "::' */ + + for (current_block_index = 0; current_block_index < 8; current_block_index++) { + /* get the current 16-bit block */ + current_block_value = lwip_htonl(addr->addr[current_block_index >> 1]); + if ((current_block_index & 0x1) == 0) { + current_block_value = current_block_value >> 16; + } + current_block_value &= 0xffff; + + /* Check for empty block. */ + if (current_block_value == 0) { + if (current_block_index == 7 && empty_block_flag == 1) { + /* special case, we must render a ':' for the last block. */ + buf[i++] = ':'; + if (i >= buflen) { + return NULL; + } + break; + } + if (empty_block_flag == 0) { + /* generate empty block "::", but only if more than one contiguous zero block, + * according to current formatting suggestions RFC 5952. */ + next_block_value = lwip_htonl(addr->addr[(current_block_index + 1) >> 1]); + if ((current_block_index & 0x1) == 0x01) { + next_block_value = next_block_value >> 16; + } + next_block_value &= 0xffff; + if (next_block_value == 0) { + empty_block_flag = 1; + buf[i++] = ':'; + if (i >= buflen) { + return NULL; + } + continue; /* move on to next block. */ + } + } else if (empty_block_flag == 1) { + /* move on to next block. */ + continue; + } + } else if (empty_block_flag == 1) { + /* Set this flag value so we don't produce multiple empty blocks. */ + empty_block_flag = 2; + } + + if (current_block_index > 0) { + buf[i++] = ':'; + if (i >= buflen) { + return NULL; + } + } + + if ((current_block_value & 0xf000) == 0) { + zero_flag = 1; + } else { + buf[i++] = lwip_xchar(((current_block_value & 0xf000) >> 12)); + zero_flag = 0; + if (i >= buflen) { + return NULL; + } + } + + if (((current_block_value & 0xf00) == 0) && (zero_flag)) { + /* do nothing */ + } else { + buf[i++] = lwip_xchar(((current_block_value & 0xf00) >> 8)); + zero_flag = 0; + if (i >= buflen) { + return NULL; + } + } + + if (((current_block_value & 0xf0) == 0) && (zero_flag)) { + /* do nothing */ + } + else { + buf[i++] = lwip_xchar(((current_block_value & 0xf0) >> 4)); + zero_flag = 0; + if (i >= buflen) { + return NULL; + } + } + + buf[i++] = lwip_xchar((current_block_value & 0xf)); + if (i >= buflen) { + return NULL; + } + } + + buf[i] = 0; + + return buf; +} + +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_frag.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_frag.c index 0f277b6e..d6c5d223 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_frag.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/ip6_frag.c @@ -1,862 +1,862 @@ -/** - * @file - * - * IPv6 fragmentation and reassembly. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#include "lwip/opt.h" -#include "lwip/ip6_frag.h" -#include "lwip/ip6.h" -#include "lwip/icmp6.h" -#include "lwip/nd6.h" -#include "lwip/ip.h" - -#include "lwip/pbuf.h" -#include "lwip/memp.h" -#include "lwip/stats.h" - -#include - -#if LWIP_IPV6 && LWIP_IPV6_REASS /* don't build if not configured for use in lwipopts.h */ - - -/** Setting this to 0, you can turn off checking the fragments for overlapping - * regions. The code gets a little smaller. Only use this if you know that - * overlapping won't occur on your network! */ -#ifndef IP_REASS_CHECK_OVERLAP -#define IP_REASS_CHECK_OVERLAP 1 -#endif /* IP_REASS_CHECK_OVERLAP */ - -/** Set to 0 to prevent freeing the oldest datagram when the reassembly buffer is - * full (IP_REASS_MAX_PBUFS pbufs are enqueued). The code gets a little smaller. - * Datagrams will be freed by timeout only. Especially useful when MEMP_NUM_REASSDATA - * is set to 1, so one datagram can be reassembled at a time, only. */ -#ifndef IP_REASS_FREE_OLDEST -#define IP_REASS_FREE_OLDEST 1 -#endif /* IP_REASS_FREE_OLDEST */ - -#if IPV6_FRAG_COPYHEADER -/* The number of bytes we need to "borrow" from (i.e., overwrite in) the header - * that precedes the fragment header for reassembly pruposes. */ -#define IPV6_FRAG_REQROOM ((s16_t)(sizeof(struct ip6_reass_helper) - IP6_FRAG_HLEN)) -#endif - -#define IP_REASS_FLAG_LASTFRAG 0x01 - -/** This is a helper struct which holds the starting - * offset and the ending offset of this fragment to - * easily chain the fragments. - * It has the same packing requirements as the IPv6 header, since it replaces - * the Fragment Header in memory in incoming fragments to keep - * track of the various fragments. - */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_reass_helper { - PACK_STRUCT_FIELD(struct pbuf *next_pbuf); - PACK_STRUCT_FIELD(u16_t start); - PACK_STRUCT_FIELD(u16_t end); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/* static variables */ -static struct ip6_reassdata *reassdatagrams; -static u16_t ip6_reass_pbufcount; - -/* Forward declarations. */ -static void ip6_reass_free_complete_datagram(struct ip6_reassdata *ipr); -#if IP_REASS_FREE_OLDEST -static void ip6_reass_remove_oldest_datagram(struct ip6_reassdata *ipr, int pbufs_needed); -#endif /* IP_REASS_FREE_OLDEST */ - -void -ip6_reass_tmr(void) -{ - struct ip6_reassdata *r, *tmp; - -#if !IPV6_FRAG_COPYHEADER - LWIP_ASSERT("sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN, set IPV6_FRAG_COPYHEADER to 1", - sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN); -#endif /* !IPV6_FRAG_COPYHEADER */ - - r = reassdatagrams; - while (r != NULL) { - /* Decrement the timer. Once it reaches 0, - * clean up the incomplete fragment assembly */ - if (r->timer > 0) { - r->timer--; - r = r->next; - } else { - /* reassembly timed out */ - tmp = r; - /* get the next pointer before freeing */ - r = r->next; - /* free the helper struct and all enqueued pbufs */ - ip6_reass_free_complete_datagram(tmp); - } - } -} - -/** - * Free a datagram (struct ip6_reassdata) and all its pbufs. - * Updates the total count of enqueued pbufs (ip6_reass_pbufcount), - * sends an ICMP time exceeded packet. - * - * @param ipr datagram to free - */ -static void -ip6_reass_free_complete_datagram(struct ip6_reassdata *ipr) -{ - struct ip6_reassdata *prev; - u16_t pbufs_freed = 0; - u16_t clen; - struct pbuf *p; - struct ip6_reass_helper *iprh; - -#if LWIP_ICMP6 - iprh = (struct ip6_reass_helper *)ipr->p->payload; - if (iprh->start == 0) { - /* The first fragment was received, send ICMP time exceeded. */ - /* First, de-queue the first pbuf from r->p. */ - p = ipr->p; - ipr->p = iprh->next_pbuf; - /* Restore the part that we've overwritten with our helper structure, or we - * might send garbage (and disclose a pointer) in the ICMPv6 reply. */ - MEMCPY(p->payload, ipr->orig_hdr, sizeof(iprh)); - /* Then, move back to the original ipv6 header (we are now pointing to Fragment header). - This cannot fail since we already checked when receiving this fragment. */ - if (pbuf_header_force(p, (s16_t)((u8_t*)p->payload - (u8_t*)ipr->iphdr))) { - LWIP_ASSERT("ip6_reass_free: moving p->payload to ip6 header failed\n", 0); - } - else { - /* Reconstruct the zoned source and destination addresses, so that we do - * not end up sending the ICMP response over the wrong link. */ - ip6_addr_t src_addr, dest_addr; - ip6_addr_copy_from_packed(src_addr, IPV6_FRAG_SRC(ipr)); - ip6_addr_set_zone(&src_addr, ipr->src_zone); - ip6_addr_copy_from_packed(dest_addr, IPV6_FRAG_DEST(ipr)); - ip6_addr_set_zone(&dest_addr, ipr->dest_zone); - /* Send the actual ICMP response. */ - icmp6_time_exceeded_with_addrs(p, ICMP6_TE_FRAG, &src_addr, &dest_addr); - } - clen = pbuf_clen(p); - LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); - pbufs_freed = (u16_t)(pbufs_freed + clen); - pbuf_free(p); - } -#endif /* LWIP_ICMP6 */ - - /* First, free all received pbufs. The individual pbufs need to be released - separately as they have not yet been chained */ - p = ipr->p; - while (p != NULL) { - struct pbuf *pcur; - iprh = (struct ip6_reass_helper *)p->payload; - pcur = p; - /* get the next pointer before freeing */ - p = iprh->next_pbuf; - clen = pbuf_clen(pcur); - LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); - pbufs_freed = (u16_t)(pbufs_freed + clen); - pbuf_free(pcur); - } - - /* Then, unchain the struct ip6_reassdata from the list and free it. */ - if (ipr == reassdatagrams) { - reassdatagrams = ipr->next; - } else { - prev = reassdatagrams; - while (prev != NULL) { - if (prev->next == ipr) { - break; - } - prev = prev->next; - } - if (prev != NULL) { - prev->next = ipr->next; - } - } - memp_free(MEMP_IP6_REASSDATA, ipr); - - /* Finally, update number of pbufs in reassembly queue */ - LWIP_ASSERT("ip_reass_pbufcount >= clen", ip6_reass_pbufcount >= pbufs_freed); - ip6_reass_pbufcount = (u16_t)(ip6_reass_pbufcount - pbufs_freed); -} - -#if IP_REASS_FREE_OLDEST -/** - * Free the oldest datagram to make room for enqueueing new fragments. - * The datagram ipr is not freed! - * - * @param ipr ip6_reassdata for the current fragment - * @param pbufs_needed number of pbufs needed to enqueue - * (used for freeing other datagrams if not enough space) - */ -static void -ip6_reass_remove_oldest_datagram(struct ip6_reassdata *ipr, int pbufs_needed) -{ - struct ip6_reassdata *r, *oldest; - - /* Free datagrams until being allowed to enqueue 'pbufs_needed' pbufs, - * but don't free the current datagram! */ - do { - r = oldest = reassdatagrams; - while (r != NULL) { - if (r != ipr) { - if (r->timer <= oldest->timer) { - /* older than the previous oldest */ - oldest = r; - } - } - r = r->next; - } - if (oldest == ipr) { - /* nothing to free, ipr is the only element on the list */ - return; - } - if (oldest != NULL) { - ip6_reass_free_complete_datagram(oldest); - } - } while (((ip6_reass_pbufcount + pbufs_needed) > IP_REASS_MAX_PBUFS) && (reassdatagrams != NULL)); -} -#endif /* IP_REASS_FREE_OLDEST */ - -/** - * Reassembles incoming IPv6 fragments into an IPv6 datagram. - * - * @param p points to the IPv6 Fragment Header - * @return NULL if reassembly is incomplete, pbuf pointing to - * IPv6 Header if reassembly is complete - */ -struct pbuf * -ip6_reass(struct pbuf *p) -{ - struct ip6_reassdata *ipr, *ipr_prev; - struct ip6_reass_helper *iprh, *iprh_tmp, *iprh_prev=NULL; - struct ip6_frag_hdr *frag_hdr; - u16_t offset, len, start, end; - ptrdiff_t hdrdiff; - u16_t clen; - u8_t valid = 1; - struct pbuf *q, *next_pbuf; - - IP6_FRAG_STATS_INC(ip6_frag.recv); - - /* ip6_frag_hdr must be in the first pbuf, not chained. Checked by caller. */ - LWIP_ASSERT("IPv6 fragment header does not fit in first pbuf", - p->len >= sizeof(struct ip6_frag_hdr)); - - frag_hdr = (struct ip6_frag_hdr *) p->payload; - - clen = pbuf_clen(p); - - offset = lwip_ntohs(frag_hdr->_fragment_offset); - - /* Calculate fragment length from IPv6 payload length. - * Adjust for headers before Fragment Header. - * And finally adjust by Fragment Header length. */ - len = lwip_ntohs(ip6_current_header()->_plen); - hdrdiff = (u8_t*)p->payload - (const u8_t*)ip6_current_header(); - LWIP_ASSERT("not a valid pbuf (ip6_input check missing?)", hdrdiff <= 0xFFFF); - LWIP_ASSERT("not a valid pbuf (ip6_input check missing?)", hdrdiff >= IP6_HLEN); - hdrdiff -= IP6_HLEN; - hdrdiff += IP6_FRAG_HLEN; - if (hdrdiff > len) { - IP6_FRAG_STATS_INC(ip6_frag.proterr); - goto nullreturn; - } - len = (u16_t)(len - hdrdiff); - start = (offset & IP6_FRAG_OFFSET_MASK); - if (start > (0xFFFF - len)) { - /* u16_t overflow, cannot handle this */ - IP6_FRAG_STATS_INC(ip6_frag.proterr); - goto nullreturn; - } - - /* Look for the datagram the fragment belongs to in the current datagram queue, - * remembering the previous in the queue for later dequeueing. */ - for (ipr = reassdatagrams, ipr_prev = NULL; ipr != NULL; ipr = ipr->next) { - /* Check if the incoming fragment matches the one currently present - in the reassembly buffer. If so, we proceed with copying the - fragment into the buffer. */ - if ((frag_hdr->_identification == ipr->identification) && - ip6_addr_cmp_packed(ip6_current_src_addr(), &(IPV6_FRAG_SRC(ipr)), ipr->src_zone) && - ip6_addr_cmp_packed(ip6_current_dest_addr(), &(IPV6_FRAG_DEST(ipr)), ipr->dest_zone)) { - IP6_FRAG_STATS_INC(ip6_frag.cachehit); - break; - } - ipr_prev = ipr; - } - - if (ipr == NULL) { - /* Enqueue a new datagram into the datagram queue */ - ipr = (struct ip6_reassdata *)memp_malloc(MEMP_IP6_REASSDATA); - if (ipr == NULL) { -#if IP_REASS_FREE_OLDEST - /* Make room and try again. */ - ip6_reass_remove_oldest_datagram(ipr, clen); - ipr = (struct ip6_reassdata *)memp_malloc(MEMP_IP6_REASSDATA); - if (ipr != NULL) { - /* re-search ipr_prev since it might have been removed */ - for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) { - if (ipr_prev->next == ipr) { - break; - } - } - } else -#endif /* IP_REASS_FREE_OLDEST */ - { - IP6_FRAG_STATS_INC(ip6_frag.memerr); - goto nullreturn; - } - } - - memset(ipr, 0, sizeof(struct ip6_reassdata)); - ipr->timer = IPV6_REASS_MAXAGE; - - /* enqueue the new structure to the front of the list */ - ipr->next = reassdatagrams; - reassdatagrams = ipr; - - /* Use the current IPv6 header for src/dest address reference. - * Eventually, we will replace it when we get the first fragment - * (it might be this one, in any case, it is done later). */ - /* need to use the none-const pointer here: */ - ipr->iphdr = ip_data.current_ip6_header; -#if IPV6_FRAG_COPYHEADER - MEMCPY(&ipr->src, &ip6_current_header()->src, sizeof(ipr->src)); - MEMCPY(&ipr->dest, &ip6_current_header()->dest, sizeof(ipr->dest)); -#endif /* IPV6_FRAG_COPYHEADER */ -#if LWIP_IPV6_SCOPES - /* Also store the address zone information. - * @todo It is possible that due to netif destruction and recreation, the - * stored zones end up resolving to a different interface. In that case, we - * risk sending a "time exceeded" ICMP response over the wrong link. - * Ideally, netif destruction would clean up matching pending reassembly - * structures, but custom zone mappings would make that non-trivial. */ - ipr->src_zone = ip6_addr_zone(ip6_current_src_addr()); - ipr->dest_zone = ip6_addr_zone(ip6_current_dest_addr()); -#endif /* LWIP_IPV6_SCOPES */ - /* copy the fragmented packet id. */ - ipr->identification = frag_hdr->_identification; - - /* copy the nexth field */ - ipr->nexth = frag_hdr->_nexth; - } - - /* Check if we are allowed to enqueue more datagrams. */ - if ((ip6_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) { -#if IP_REASS_FREE_OLDEST - ip6_reass_remove_oldest_datagram(ipr, clen); - if ((ip6_reass_pbufcount + clen) <= IP_REASS_MAX_PBUFS) { - /* re-search ipr_prev since it might have been removed */ - for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) { - if (ipr_prev->next == ipr) { - break; - } - } - } else -#endif /* IP_REASS_FREE_OLDEST */ - { - /* @todo: send ICMPv6 time exceeded here? */ - /* drop this pbuf */ - IP6_FRAG_STATS_INC(ip6_frag.memerr); - goto nullreturn; - } - } - - /* Overwrite Fragment Header with our own helper struct. */ -#if IPV6_FRAG_COPYHEADER - if (IPV6_FRAG_REQROOM > 0) { - /* Make room for struct ip6_reass_helper (only required if sizeof(void*) > 4). - This cannot fail since we already checked when receiving this fragment. */ - u8_t hdrerr = pbuf_header_force(p, IPV6_FRAG_REQROOM); - LWIP_UNUSED_ARG(hdrerr); /* in case of LWIP_NOASSERT */ - LWIP_ASSERT("no room for struct ip6_reass_helper", hdrerr == 0); - } -#else /* IPV6_FRAG_COPYHEADER */ - LWIP_ASSERT("sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN, set IPV6_FRAG_COPYHEADER to 1", - sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN); -#endif /* IPV6_FRAG_COPYHEADER */ - - /* Prepare the pointer to the helper structure, and its initial values. - * Do not yet write to the structure itself, as we still have to make a - * backup of the original data, and we should not do that until we know for - * sure that we are going to add this packet to the list. */ - iprh = (struct ip6_reass_helper *)p->payload; - next_pbuf = NULL; - end = (u16_t)(start + len); - - /* find the right place to insert this pbuf */ - /* Iterate through until we either get to the end of the list (append), - * or we find on with a larger offset (insert). */ - for (q = ipr->p; q != NULL;) { - iprh_tmp = (struct ip6_reass_helper*)q->payload; - if (start < iprh_tmp->start) { -#if IP_REASS_CHECK_OVERLAP - if (end > iprh_tmp->start) { - /* fragment overlaps with following, throw away */ - IP6_FRAG_STATS_INC(ip6_frag.proterr); - goto nullreturn; - } - if (iprh_prev != NULL) { - if (start < iprh_prev->end) { - /* fragment overlaps with previous, throw away */ - IP6_FRAG_STATS_INC(ip6_frag.proterr); - goto nullreturn; - } - } -#endif /* IP_REASS_CHECK_OVERLAP */ - /* the new pbuf should be inserted before this */ - next_pbuf = q; - if (iprh_prev != NULL) { - /* not the fragment with the lowest offset */ - iprh_prev->next_pbuf = p; - } else { - /* fragment with the lowest offset */ - ipr->p = p; - } - break; - } else if (start == iprh_tmp->start) { - /* received the same datagram twice: no need to keep the datagram */ - goto nullreturn; -#if IP_REASS_CHECK_OVERLAP - } else if (start < iprh_tmp->end) { - /* overlap: no need to keep the new datagram */ - IP6_FRAG_STATS_INC(ip6_frag.proterr); - goto nullreturn; -#endif /* IP_REASS_CHECK_OVERLAP */ - } else { - /* Check if the fragments received so far have no gaps. */ - if (iprh_prev != NULL) { - if (iprh_prev->end != iprh_tmp->start) { - /* There is a fragment missing between the current - * and the previous fragment */ - valid = 0; - } - } - } - q = iprh_tmp->next_pbuf; - iprh_prev = iprh_tmp; - } - - /* If q is NULL, then we made it to the end of the list. Determine what to do now */ - if (q == NULL) { - if (iprh_prev != NULL) { - /* this is (for now), the fragment with the highest offset: - * chain it to the last fragment */ -#if IP_REASS_CHECK_OVERLAP - LWIP_ASSERT("check fragments don't overlap", iprh_prev->end <= start); -#endif /* IP_REASS_CHECK_OVERLAP */ - iprh_prev->next_pbuf = p; - if (iprh_prev->end != start) { - valid = 0; - } - } else { -#if IP_REASS_CHECK_OVERLAP - LWIP_ASSERT("no previous fragment, this must be the first fragment!", - ipr->p == NULL); -#endif /* IP_REASS_CHECK_OVERLAP */ - /* this is the first fragment we ever received for this ip datagram */ - ipr->p = p; - } - } - - /* Track the current number of pbufs current 'in-flight', in order to limit - the number of fragments that may be enqueued at any one time */ - ip6_reass_pbufcount = (u16_t)(ip6_reass_pbufcount + clen); - - /* Remember IPv6 header if this is the first fragment. */ - if (start == 0) { - /* need to use the none-const pointer here: */ - ipr->iphdr = ip_data.current_ip6_header; - /* Make a backup of the part of the packet data that we are about to - * overwrite, so that we can restore the original later. */ - MEMCPY(ipr->orig_hdr, p->payload, sizeof(*iprh)); - /* For IPV6_FRAG_COPYHEADER there is no need to copy src/dst again, as they - * will be the same as they were. With LWIP_IPV6_SCOPES, the same applies - * to the source/destination zones. */ - } - /* Only after the backup do we get to fill in the actual helper structure. */ - iprh->next_pbuf = next_pbuf; - iprh->start = start; - iprh->end = end; - - /* If this is the last fragment, calculate total packet length. */ - if ((offset & IP6_FRAG_MORE_FLAG) == 0) { - ipr->datagram_len = iprh->end; - } - - /* Additional validity tests: we have received first and last fragment. */ - iprh_tmp = (struct ip6_reass_helper*)ipr->p->payload; - if (iprh_tmp->start != 0) { - valid = 0; - } - if (ipr->datagram_len == 0) { - valid = 0; - } - - /* Final validity test: no gaps between current and last fragment. */ - iprh_prev = iprh; - q = iprh->next_pbuf; - while ((q != NULL) && valid) { - iprh = (struct ip6_reass_helper*)q->payload; - if (iprh_prev->end != iprh->start) { - valid = 0; - break; - } - iprh_prev = iprh; - q = iprh->next_pbuf; - } - - if (valid) { - /* All fragments have been received */ - struct ip6_hdr* iphdr_ptr; - - /* chain together the pbufs contained within the ip6_reassdata list. */ - iprh = (struct ip6_reass_helper*) ipr->p->payload; - while (iprh != NULL) { - next_pbuf = iprh->next_pbuf; - if (next_pbuf != NULL) { - /* Save next helper struct (will be hidden in next step). */ - iprh_tmp = (struct ip6_reass_helper*)next_pbuf->payload; - - /* hide the fragment header for every succeeding fragment */ - pbuf_remove_header(next_pbuf, IP6_FRAG_HLEN); -#if IPV6_FRAG_COPYHEADER - if (IPV6_FRAG_REQROOM > 0) { - /* hide the extra bytes borrowed from ip6_hdr for struct ip6_reass_helper */ - u8_t hdrerr = pbuf_remove_header(next_pbuf, IPV6_FRAG_REQROOM); - LWIP_UNUSED_ARG(hdrerr); /* in case of LWIP_NOASSERT */ - LWIP_ASSERT("no room for struct ip6_reass_helper", hdrerr == 0); - } -#endif - pbuf_cat(ipr->p, next_pbuf); - } - else { - iprh_tmp = NULL; - } - - iprh = iprh_tmp; - } - - /* Get the first pbuf. */ - p = ipr->p; - -#if IPV6_FRAG_COPYHEADER - if (IPV6_FRAG_REQROOM > 0) { - u8_t hdrerr; - /* Restore (only) the bytes that we overwrote beyond the fragment header. - * Those bytes may belong to either the IPv6 header or an extension - * header placed before the fragment header. */ - MEMCPY(p->payload, ipr->orig_hdr, IPV6_FRAG_REQROOM); - /* get back room for struct ip6_reass_helper (only required if sizeof(void*) > 4) */ - hdrerr = pbuf_remove_header(p, IPV6_FRAG_REQROOM); - LWIP_UNUSED_ARG(hdrerr); /* in case of LWIP_NOASSERT */ - LWIP_ASSERT("no room for struct ip6_reass_helper", hdrerr == 0); - } -#endif - - /* We need to get rid of the fragment header itself, which is somewhere in - * the middle of the packet (but still in the first pbuf of the chain). - * Getting rid of the header is required by RFC 2460 Sec. 4.5 and necessary - * in order to be able to reassemble packets that are close to full size - * (i.e., around 65535 bytes). We simply move up all the headers before the - * fragment header, including the IPv6 header, and adjust the payload start - * accordingly. This works because all these headers are in the first pbuf - * of the chain, and because the caller adjusts all its pointers on - * successful reassembly. */ - MEMMOVE((u8_t*)ipr->iphdr + sizeof(struct ip6_frag_hdr), ipr->iphdr, - (size_t)((u8_t*)p->payload - (u8_t*)ipr->iphdr)); - - /* This is where the IPv6 header is now. */ - iphdr_ptr = (struct ip6_hdr*)((u8_t*)ipr->iphdr + - sizeof(struct ip6_frag_hdr)); - - /* Adjust datagram length by adding header lengths. */ - ipr->datagram_len = (u16_t)(ipr->datagram_len + ((u8_t*)p->payload - (u8_t*)iphdr_ptr) - - IP6_HLEN); - - /* Set payload length in ip header. */ - iphdr_ptr->_plen = lwip_htons(ipr->datagram_len); - - /* With the fragment header gone, we now need to adjust the next-header - * field of whatever header was originally before it. Since the packet made - * it through the original header processing routines at least up to the - * fragment header, we do not need any further sanity checks here. */ - if (IP6H_NEXTH(iphdr_ptr) == IP6_NEXTH_FRAGMENT) { - iphdr_ptr->_nexth = ipr->nexth; - } else { - u8_t *ptr = (u8_t *)iphdr_ptr + IP6_HLEN; - while (*ptr != IP6_NEXTH_FRAGMENT) { - ptr += 8 * (1 + ptr[1]); - } - *ptr = ipr->nexth; - } - - /* release the resources allocated for the fragment queue entry */ - if (reassdatagrams == ipr) { - /* it was the first in the list */ - reassdatagrams = ipr->next; - } else { - /* it wasn't the first, so it must have a valid 'prev' */ - LWIP_ASSERT("sanity check linked list", ipr_prev != NULL); - ipr_prev->next = ipr->next; - } - memp_free(MEMP_IP6_REASSDATA, ipr); - - /* adjust the number of pbufs currently queued for reassembly. */ - clen = pbuf_clen(p); - LWIP_ASSERT("ip6_reass_pbufcount >= clen", ip6_reass_pbufcount >= clen); - ip6_reass_pbufcount = (u16_t)(ip6_reass_pbufcount - clen); - - /* Move pbuf back to IPv6 header. This should never fail. */ - if (pbuf_header_force(p, (s16_t)((u8_t*)p->payload - (u8_t*)iphdr_ptr))) { - LWIP_ASSERT("ip6_reass: moving p->payload to ip6 header failed\n", 0); - pbuf_free(p); - return NULL; - } - - /* Return the pbuf chain */ - return p; - } - /* the datagram is not (yet?) reassembled completely */ - return NULL; - -nullreturn: - IP6_FRAG_STATS_INC(ip6_frag.drop); - pbuf_free(p); - return NULL; -} - -#endif /* LWIP_IPV6 && LWIP_IPV6_REASS */ - -#if LWIP_IPV6 && LWIP_IPV6_FRAG - -#if !LWIP_NETIF_TX_SINGLE_PBUF -/** Allocate a new struct pbuf_custom_ref */ -static struct pbuf_custom_ref* -ip6_frag_alloc_pbuf_custom_ref(void) -{ - return (struct pbuf_custom_ref*)memp_malloc(MEMP_FRAG_PBUF); -} - -/** Free a struct pbuf_custom_ref */ -static void -ip6_frag_free_pbuf_custom_ref(struct pbuf_custom_ref* p) -{ - LWIP_ASSERT("p != NULL", p != NULL); - memp_free(MEMP_FRAG_PBUF, p); -} - -/** Free-callback function to free a 'struct pbuf_custom_ref', called by - * pbuf_free. */ -static void -ip6_frag_free_pbuf_custom(struct pbuf *p) -{ - struct pbuf_custom_ref *pcr = (struct pbuf_custom_ref*)p; - LWIP_ASSERT("pcr != NULL", pcr != NULL); - LWIP_ASSERT("pcr == p", (void*)pcr == (void*)p); - if (pcr->original != NULL) { - pbuf_free(pcr->original); - } - ip6_frag_free_pbuf_custom_ref(pcr); -} -#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ - -/** - * Fragment an IPv6 datagram if too large for the netif or path MTU. - * - * Chop the datagram in MTU sized chunks and send them in order - * by pointing PBUF_REFs into p - * - * @param p ipv6 packet to send - * @param netif the netif on which to send - * @param dest destination ipv6 address to which to send - * - * @return ERR_OK if sent successfully, err_t otherwise - */ -err_t -ip6_frag(struct pbuf *p, struct netif *netif, const ip6_addr_t *dest) -{ - struct ip6_hdr *original_ip6hdr; - struct ip6_hdr *ip6hdr; - struct ip6_frag_hdr *frag_hdr; - struct pbuf *rambuf; -#if !LWIP_NETIF_TX_SINGLE_PBUF - struct pbuf *newpbuf; - u16_t newpbuflen = 0; - u16_t left_to_copy; -#endif - static u32_t identification; - u16_t left, cop; - const u16_t mtu = nd6_get_destination_mtu(dest, netif); - const u16_t nfb = (u16_t)((mtu - (IP6_HLEN + IP6_FRAG_HLEN)) & IP6_FRAG_OFFSET_MASK); - u16_t fragment_offset = 0; - u16_t last; - u16_t poff = IP6_HLEN; - - identification++; - - original_ip6hdr = (struct ip6_hdr *)p->payload; - - /* @todo we assume there are no options in the unfragmentable part (IPv6 header). */ - LWIP_ASSERT("p->tot_len >= IP6_HLEN", p->tot_len >= IP6_HLEN); - left = (u16_t)(p->tot_len - IP6_HLEN); - - while (left) { - last = (left <= nfb); - - /* Fill this fragment */ - cop = last ? left : nfb; - -#if LWIP_NETIF_TX_SINGLE_PBUF - rambuf = pbuf_alloc(PBUF_IP, cop + IP6_FRAG_HLEN, PBUF_RAM); - if (rambuf == NULL) { - IP6_FRAG_STATS_INC(ip6_frag.memerr); - return ERR_MEM; - } - LWIP_ASSERT("this needs a pbuf in one piece!", - (rambuf->len == rambuf->tot_len) && (rambuf->next == NULL)); - poff += pbuf_copy_partial(p, (u8_t*)rambuf->payload + IP6_FRAG_HLEN, cop, poff); - /* make room for the IP header */ - if (pbuf_add_header(rambuf, IP6_HLEN)) { - pbuf_free(rambuf); - IP6_FRAG_STATS_INC(ip6_frag.memerr); - return ERR_MEM; - } - /* fill in the IP header */ - SMEMCPY(rambuf->payload, original_ip6hdr, IP6_HLEN); - ip6hdr = (struct ip6_hdr *)rambuf->payload; - frag_hdr = (struct ip6_frag_hdr *)((u8_t*)rambuf->payload + IP6_HLEN); -#else - /* When not using a static buffer, create a chain of pbufs. - * The first will be a PBUF_RAM holding the link, IPv6, and Fragment header. - * The rest will be PBUF_REFs mirroring the pbuf chain to be fragged, - * but limited to the size of an mtu. - */ - rambuf = pbuf_alloc(PBUF_LINK, IP6_HLEN + IP6_FRAG_HLEN, PBUF_RAM); - if (rambuf == NULL) { - IP6_FRAG_STATS_INC(ip6_frag.memerr); - return ERR_MEM; - } - LWIP_ASSERT("this needs a pbuf in one piece!", - (p->len >= (IP6_HLEN))); - SMEMCPY(rambuf->payload, original_ip6hdr, IP6_HLEN); - ip6hdr = (struct ip6_hdr *)rambuf->payload; - frag_hdr = (struct ip6_frag_hdr *)((u8_t*)rambuf->payload + IP6_HLEN); - - /* Can just adjust p directly for needed offset. */ - p->payload = (u8_t *)p->payload + poff; - p->len = (u16_t)(p->len - poff); - p->tot_len = (u16_t)(p->tot_len - poff); - - left_to_copy = cop; - while (left_to_copy) { - struct pbuf_custom_ref *pcr; - newpbuflen = (left_to_copy < p->len) ? left_to_copy : p->len; - /* Is this pbuf already empty? */ - if (!newpbuflen) { - p = p->next; - continue; - } - pcr = ip6_frag_alloc_pbuf_custom_ref(); - if (pcr == NULL) { - pbuf_free(rambuf); - IP6_FRAG_STATS_INC(ip6_frag.memerr); - return ERR_MEM; - } - /* Mirror this pbuf, although we might not need all of it. */ - newpbuf = pbuf_alloced_custom(PBUF_RAW, newpbuflen, PBUF_REF, &pcr->pc, p->payload, newpbuflen); - if (newpbuf == NULL) { - ip6_frag_free_pbuf_custom_ref(pcr); - pbuf_free(rambuf); - IP6_FRAG_STATS_INC(ip6_frag.memerr); - return ERR_MEM; - } - pbuf_ref(p); - pcr->original = p; - pcr->pc.custom_free_function = ip6_frag_free_pbuf_custom; - - /* Add it to end of rambuf's chain, but using pbuf_cat, not pbuf_chain - * so that it is removed when pbuf_dechain is later called on rambuf. - */ - pbuf_cat(rambuf, newpbuf); - left_to_copy = (u16_t)(left_to_copy - newpbuflen); - if (left_to_copy) { - p = p->next; - } - } - poff = newpbuflen; -#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ - - /* Set headers */ - frag_hdr->_nexth = original_ip6hdr->_nexth; - frag_hdr->reserved = 0; - frag_hdr->_fragment_offset = lwip_htons((u16_t)((fragment_offset & IP6_FRAG_OFFSET_MASK) | (last ? 0 : IP6_FRAG_MORE_FLAG))); - frag_hdr->_identification = lwip_htonl(identification); - - IP6H_NEXTH_SET(ip6hdr, IP6_NEXTH_FRAGMENT); - IP6H_PLEN_SET(ip6hdr, (u16_t)(cop + IP6_FRAG_HLEN)); - - /* No need for separate header pbuf - we allowed room for it in rambuf - * when allocated. - */ - IP6_FRAG_STATS_INC(ip6_frag.xmit); - netif->output_ip6(netif, rambuf, dest); - - /* Unfortunately we can't reuse rambuf - the hardware may still be - * using the buffer. Instead we free it (and the ensuing chain) and - * recreate it next time round the loop. If we're lucky the hardware - * will have already sent the packet, the free will really free, and - * there will be zero memory penalty. - */ - - pbuf_free(rambuf); - left = (u16_t)(left - cop); - fragment_offset = (u16_t)(fragment_offset + cop); - } - return ERR_OK; -} - -#endif /* LWIP_IPV6 && LWIP_IPV6_FRAG */ +/** + * @file + * + * IPv6 fragmentation and reassembly. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#include "lwip/opt.h" +#include "lwip/ip6_frag.h" +#include "lwip/ip6.h" +#include "lwip/icmp6.h" +#include "lwip/nd6.h" +#include "lwip/ip.h" + +#include "lwip/pbuf.h" +#include "lwip/memp.h" +#include "lwip/stats.h" + +#include + +#if LWIP_IPV6 && LWIP_IPV6_REASS /* don't build if not configured for use in lwipopts.h */ + + +/** Setting this to 0, you can turn off checking the fragments for overlapping + * regions. The code gets a little smaller. Only use this if you know that + * overlapping won't occur on your network! */ +#ifndef IP_REASS_CHECK_OVERLAP +#define IP_REASS_CHECK_OVERLAP 1 +#endif /* IP_REASS_CHECK_OVERLAP */ + +/** Set to 0 to prevent freeing the oldest datagram when the reassembly buffer is + * full (IP_REASS_MAX_PBUFS pbufs are enqueued). The code gets a little smaller. + * Datagrams will be freed by timeout only. Especially useful when MEMP_NUM_REASSDATA + * is set to 1, so one datagram can be reassembled at a time, only. */ +#ifndef IP_REASS_FREE_OLDEST +#define IP_REASS_FREE_OLDEST 1 +#endif /* IP_REASS_FREE_OLDEST */ + +#if IPV6_FRAG_COPYHEADER +/* The number of bytes we need to "borrow" from (i.e., overwrite in) the header + * that precedes the fragment header for reassembly pruposes. */ +#define IPV6_FRAG_REQROOM ((s16_t)(sizeof(struct ip6_reass_helper) - IP6_FRAG_HLEN)) +#endif + +#define IP_REASS_FLAG_LASTFRAG 0x01 + +/** This is a helper struct which holds the starting + * offset and the ending offset of this fragment to + * easily chain the fragments. + * It has the same packing requirements as the IPv6 header, since it replaces + * the Fragment Header in memory in incoming fragments to keep + * track of the various fragments. + */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_reass_helper { + PACK_STRUCT_FIELD(struct pbuf *next_pbuf); + PACK_STRUCT_FIELD(u16_t start); + PACK_STRUCT_FIELD(u16_t end); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/* static variables */ +static struct ip6_reassdata *reassdatagrams; +static u16_t ip6_reass_pbufcount; + +/* Forward declarations. */ +static void ip6_reass_free_complete_datagram(struct ip6_reassdata *ipr); +#if IP_REASS_FREE_OLDEST +static void ip6_reass_remove_oldest_datagram(struct ip6_reassdata *ipr, int pbufs_needed); +#endif /* IP_REASS_FREE_OLDEST */ + +void +ip6_reass_tmr(void) +{ + struct ip6_reassdata *r, *tmp; + +#if !IPV6_FRAG_COPYHEADER + LWIP_ASSERT("sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN, set IPV6_FRAG_COPYHEADER to 1", + sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN); +#endif /* !IPV6_FRAG_COPYHEADER */ + + r = reassdatagrams; + while (r != NULL) { + /* Decrement the timer. Once it reaches 0, + * clean up the incomplete fragment assembly */ + if (r->timer > 0) { + r->timer--; + r = r->next; + } else { + /* reassembly timed out */ + tmp = r; + /* get the next pointer before freeing */ + r = r->next; + /* free the helper struct and all enqueued pbufs */ + ip6_reass_free_complete_datagram(tmp); + } + } +} + +/** + * Free a datagram (struct ip6_reassdata) and all its pbufs. + * Updates the total count of enqueued pbufs (ip6_reass_pbufcount), + * sends an ICMP time exceeded packet. + * + * @param ipr datagram to free + */ +static void +ip6_reass_free_complete_datagram(struct ip6_reassdata *ipr) +{ + struct ip6_reassdata *prev; + u16_t pbufs_freed = 0; + u16_t clen; + struct pbuf *p; + struct ip6_reass_helper *iprh; + +#if LWIP_ICMP6 + iprh = (struct ip6_reass_helper *)ipr->p->payload; + if (iprh->start == 0) { + /* The first fragment was received, send ICMP time exceeded. */ + /* First, de-queue the first pbuf from r->p. */ + p = ipr->p; + ipr->p = iprh->next_pbuf; + /* Restore the part that we've overwritten with our helper structure, or we + * might send garbage (and disclose a pointer) in the ICMPv6 reply. */ + MEMCPY(p->payload, ipr->orig_hdr, sizeof(iprh)); + /* Then, move back to the original ipv6 header (we are now pointing to Fragment header). + This cannot fail since we already checked when receiving this fragment. */ + if (pbuf_header_force(p, (s16_t)((u8_t*)p->payload - (u8_t*)ipr->iphdr))) { + LWIP_ASSERT("ip6_reass_free: moving p->payload to ip6 header failed\n", 0); + } + else { + /* Reconstruct the zoned source and destination addresses, so that we do + * not end up sending the ICMP response over the wrong link. */ + ip6_addr_t src_addr, dest_addr; + ip6_addr_copy_from_packed(src_addr, IPV6_FRAG_SRC(ipr)); + ip6_addr_set_zone(&src_addr, ipr->src_zone); + ip6_addr_copy_from_packed(dest_addr, IPV6_FRAG_DEST(ipr)); + ip6_addr_set_zone(&dest_addr, ipr->dest_zone); + /* Send the actual ICMP response. */ + icmp6_time_exceeded_with_addrs(p, ICMP6_TE_FRAG, &src_addr, &dest_addr); + } + clen = pbuf_clen(p); + LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); + pbufs_freed = (u16_t)(pbufs_freed + clen); + pbuf_free(p); + } +#endif /* LWIP_ICMP6 */ + + /* First, free all received pbufs. The individual pbufs need to be released + separately as they have not yet been chained */ + p = ipr->p; + while (p != NULL) { + struct pbuf *pcur; + iprh = (struct ip6_reass_helper *)p->payload; + pcur = p; + /* get the next pointer before freeing */ + p = iprh->next_pbuf; + clen = pbuf_clen(pcur); + LWIP_ASSERT("pbufs_freed + clen <= 0xffff", pbufs_freed + clen <= 0xffff); + pbufs_freed = (u16_t)(pbufs_freed + clen); + pbuf_free(pcur); + } + + /* Then, unchain the struct ip6_reassdata from the list and free it. */ + if (ipr == reassdatagrams) { + reassdatagrams = ipr->next; + } else { + prev = reassdatagrams; + while (prev != NULL) { + if (prev->next == ipr) { + break; + } + prev = prev->next; + } + if (prev != NULL) { + prev->next = ipr->next; + } + } + memp_free(MEMP_IP6_REASSDATA, ipr); + + /* Finally, update number of pbufs in reassembly queue */ + LWIP_ASSERT("ip_reass_pbufcount >= clen", ip6_reass_pbufcount >= pbufs_freed); + ip6_reass_pbufcount = (u16_t)(ip6_reass_pbufcount - pbufs_freed); +} + +#if IP_REASS_FREE_OLDEST +/** + * Free the oldest datagram to make room for enqueueing new fragments. + * The datagram ipr is not freed! + * + * @param ipr ip6_reassdata for the current fragment + * @param pbufs_needed number of pbufs needed to enqueue + * (used for freeing other datagrams if not enough space) + */ +static void +ip6_reass_remove_oldest_datagram(struct ip6_reassdata *ipr, int pbufs_needed) +{ + struct ip6_reassdata *r, *oldest; + + /* Free datagrams until being allowed to enqueue 'pbufs_needed' pbufs, + * but don't free the current datagram! */ + do { + r = oldest = reassdatagrams; + while (r != NULL) { + if (r != ipr) { + if (r->timer <= oldest->timer) { + /* older than the previous oldest */ + oldest = r; + } + } + r = r->next; + } + if (oldest == ipr) { + /* nothing to free, ipr is the only element on the list */ + return; + } + if (oldest != NULL) { + ip6_reass_free_complete_datagram(oldest); + } + } while (((ip6_reass_pbufcount + pbufs_needed) > IP_REASS_MAX_PBUFS) && (reassdatagrams != NULL)); +} +#endif /* IP_REASS_FREE_OLDEST */ + +/** + * Reassembles incoming IPv6 fragments into an IPv6 datagram. + * + * @param p points to the IPv6 Fragment Header + * @return NULL if reassembly is incomplete, pbuf pointing to + * IPv6 Header if reassembly is complete + */ +struct pbuf * +ip6_reass(struct pbuf *p) +{ + struct ip6_reassdata *ipr, *ipr_prev; + struct ip6_reass_helper *iprh, *iprh_tmp, *iprh_prev=NULL; + struct ip6_frag_hdr *frag_hdr; + u16_t offset, len, start, end; + ptrdiff_t hdrdiff; + u16_t clen; + u8_t valid = 1; + struct pbuf *q, *next_pbuf; + + IP6_FRAG_STATS_INC(ip6_frag.recv); + + /* ip6_frag_hdr must be in the first pbuf, not chained. Checked by caller. */ + LWIP_ASSERT("IPv6 fragment header does not fit in first pbuf", + p->len >= sizeof(struct ip6_frag_hdr)); + + frag_hdr = (struct ip6_frag_hdr *) p->payload; + + clen = pbuf_clen(p); + + offset = lwip_ntohs(frag_hdr->_fragment_offset); + + /* Calculate fragment length from IPv6 payload length. + * Adjust for headers before Fragment Header. + * And finally adjust by Fragment Header length. */ + len = lwip_ntohs(ip6_current_header()->_plen); + hdrdiff = (u8_t*)p->payload - (const u8_t*)ip6_current_header(); + LWIP_ASSERT("not a valid pbuf (ip6_input check missing?)", hdrdiff <= 0xFFFF); + LWIP_ASSERT("not a valid pbuf (ip6_input check missing?)", hdrdiff >= IP6_HLEN); + hdrdiff -= IP6_HLEN; + hdrdiff += IP6_FRAG_HLEN; + if (hdrdiff > len) { + IP6_FRAG_STATS_INC(ip6_frag.proterr); + goto nullreturn; + } + len = (u16_t)(len - hdrdiff); + start = (offset & IP6_FRAG_OFFSET_MASK); + if (start > (0xFFFF - len)) { + /* u16_t overflow, cannot handle this */ + IP6_FRAG_STATS_INC(ip6_frag.proterr); + goto nullreturn; + } + + /* Look for the datagram the fragment belongs to in the current datagram queue, + * remembering the previous in the queue for later dequeueing. */ + for (ipr = reassdatagrams, ipr_prev = NULL; ipr != NULL; ipr = ipr->next) { + /* Check if the incoming fragment matches the one currently present + in the reassembly buffer. If so, we proceed with copying the + fragment into the buffer. */ + if ((frag_hdr->_identification == ipr->identification) && + ip6_addr_cmp_packed(ip6_current_src_addr(), &(IPV6_FRAG_SRC(ipr)), ipr->src_zone) && + ip6_addr_cmp_packed(ip6_current_dest_addr(), &(IPV6_FRAG_DEST(ipr)), ipr->dest_zone)) { + IP6_FRAG_STATS_INC(ip6_frag.cachehit); + break; + } + ipr_prev = ipr; + } + + if (ipr == NULL) { + /* Enqueue a new datagram into the datagram queue */ + ipr = (struct ip6_reassdata *)memp_malloc(MEMP_IP6_REASSDATA); + if (ipr == NULL) { +#if IP_REASS_FREE_OLDEST + /* Make room and try again. */ + ip6_reass_remove_oldest_datagram(ipr, clen); + ipr = (struct ip6_reassdata *)memp_malloc(MEMP_IP6_REASSDATA); + if (ipr != NULL) { + /* re-search ipr_prev since it might have been removed */ + for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) { + if (ipr_prev->next == ipr) { + break; + } + } + } else +#endif /* IP_REASS_FREE_OLDEST */ + { + IP6_FRAG_STATS_INC(ip6_frag.memerr); + goto nullreturn; + } + } + + memset(ipr, 0, sizeof(struct ip6_reassdata)); + ipr->timer = IPV6_REASS_MAXAGE; + + /* enqueue the new structure to the front of the list */ + ipr->next = reassdatagrams; + reassdatagrams = ipr; + + /* Use the current IPv6 header for src/dest address reference. + * Eventually, we will replace it when we get the first fragment + * (it might be this one, in any case, it is done later). */ + /* need to use the none-const pointer here: */ + ipr->iphdr = ip_data.current_ip6_header; +#if IPV6_FRAG_COPYHEADER + MEMCPY(&ipr->src, &ip6_current_header()->src, sizeof(ipr->src)); + MEMCPY(&ipr->dest, &ip6_current_header()->dest, sizeof(ipr->dest)); +#endif /* IPV6_FRAG_COPYHEADER */ +#if LWIP_IPV6_SCOPES + /* Also store the address zone information. + * @todo It is possible that due to netif destruction and recreation, the + * stored zones end up resolving to a different interface. In that case, we + * risk sending a "time exceeded" ICMP response over the wrong link. + * Ideally, netif destruction would clean up matching pending reassembly + * structures, but custom zone mappings would make that non-trivial. */ + ipr->src_zone = ip6_addr_zone(ip6_current_src_addr()); + ipr->dest_zone = ip6_addr_zone(ip6_current_dest_addr()); +#endif /* LWIP_IPV6_SCOPES */ + /* copy the fragmented packet id. */ + ipr->identification = frag_hdr->_identification; + + /* copy the nexth field */ + ipr->nexth = frag_hdr->_nexth; + } + + /* Check if we are allowed to enqueue more datagrams. */ + if ((ip6_reass_pbufcount + clen) > IP_REASS_MAX_PBUFS) { +#if IP_REASS_FREE_OLDEST + ip6_reass_remove_oldest_datagram(ipr, clen); + if ((ip6_reass_pbufcount + clen) <= IP_REASS_MAX_PBUFS) { + /* re-search ipr_prev since it might have been removed */ + for (ipr_prev = reassdatagrams; ipr_prev != NULL; ipr_prev = ipr_prev->next) { + if (ipr_prev->next == ipr) { + break; + } + } + } else +#endif /* IP_REASS_FREE_OLDEST */ + { + /* @todo: send ICMPv6 time exceeded here? */ + /* drop this pbuf */ + IP6_FRAG_STATS_INC(ip6_frag.memerr); + goto nullreturn; + } + } + + /* Overwrite Fragment Header with our own helper struct. */ +#if IPV6_FRAG_COPYHEADER + if (IPV6_FRAG_REQROOM > 0) { + /* Make room for struct ip6_reass_helper (only required if sizeof(void*) > 4). + This cannot fail since we already checked when receiving this fragment. */ + u8_t hdrerr = pbuf_header_force(p, IPV6_FRAG_REQROOM); + LWIP_UNUSED_ARG(hdrerr); /* in case of LWIP_NOASSERT */ + LWIP_ASSERT("no room for struct ip6_reass_helper", hdrerr == 0); + } +#else /* IPV6_FRAG_COPYHEADER */ + LWIP_ASSERT("sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN, set IPV6_FRAG_COPYHEADER to 1", + sizeof(struct ip6_reass_helper) <= IP6_FRAG_HLEN); +#endif /* IPV6_FRAG_COPYHEADER */ + + /* Prepare the pointer to the helper structure, and its initial values. + * Do not yet write to the structure itself, as we still have to make a + * backup of the original data, and we should not do that until we know for + * sure that we are going to add this packet to the list. */ + iprh = (struct ip6_reass_helper *)p->payload; + next_pbuf = NULL; + end = (u16_t)(start + len); + + /* find the right place to insert this pbuf */ + /* Iterate through until we either get to the end of the list (append), + * or we find on with a larger offset (insert). */ + for (q = ipr->p; q != NULL;) { + iprh_tmp = (struct ip6_reass_helper*)q->payload; + if (start < iprh_tmp->start) { +#if IP_REASS_CHECK_OVERLAP + if (end > iprh_tmp->start) { + /* fragment overlaps with following, throw away */ + IP6_FRAG_STATS_INC(ip6_frag.proterr); + goto nullreturn; + } + if (iprh_prev != NULL) { + if (start < iprh_prev->end) { + /* fragment overlaps with previous, throw away */ + IP6_FRAG_STATS_INC(ip6_frag.proterr); + goto nullreturn; + } + } +#endif /* IP_REASS_CHECK_OVERLAP */ + /* the new pbuf should be inserted before this */ + next_pbuf = q; + if (iprh_prev != NULL) { + /* not the fragment with the lowest offset */ + iprh_prev->next_pbuf = p; + } else { + /* fragment with the lowest offset */ + ipr->p = p; + } + break; + } else if (start == iprh_tmp->start) { + /* received the same datagram twice: no need to keep the datagram */ + goto nullreturn; +#if IP_REASS_CHECK_OVERLAP + } else if (start < iprh_tmp->end) { + /* overlap: no need to keep the new datagram */ + IP6_FRAG_STATS_INC(ip6_frag.proterr); + goto nullreturn; +#endif /* IP_REASS_CHECK_OVERLAP */ + } else { + /* Check if the fragments received so far have no gaps. */ + if (iprh_prev != NULL) { + if (iprh_prev->end != iprh_tmp->start) { + /* There is a fragment missing between the current + * and the previous fragment */ + valid = 0; + } + } + } + q = iprh_tmp->next_pbuf; + iprh_prev = iprh_tmp; + } + + /* If q is NULL, then we made it to the end of the list. Determine what to do now */ + if (q == NULL) { + if (iprh_prev != NULL) { + /* this is (for now), the fragment with the highest offset: + * chain it to the last fragment */ +#if IP_REASS_CHECK_OVERLAP + LWIP_ASSERT("check fragments don't overlap", iprh_prev->end <= start); +#endif /* IP_REASS_CHECK_OVERLAP */ + iprh_prev->next_pbuf = p; + if (iprh_prev->end != start) { + valid = 0; + } + } else { +#if IP_REASS_CHECK_OVERLAP + LWIP_ASSERT("no previous fragment, this must be the first fragment!", + ipr->p == NULL); +#endif /* IP_REASS_CHECK_OVERLAP */ + /* this is the first fragment we ever received for this ip datagram */ + ipr->p = p; + } + } + + /* Track the current number of pbufs current 'in-flight', in order to limit + the number of fragments that may be enqueued at any one time */ + ip6_reass_pbufcount = (u16_t)(ip6_reass_pbufcount + clen); + + /* Remember IPv6 header if this is the first fragment. */ + if (start == 0) { + /* need to use the none-const pointer here: */ + ipr->iphdr = ip_data.current_ip6_header; + /* Make a backup of the part of the packet data that we are about to + * overwrite, so that we can restore the original later. */ + MEMCPY(ipr->orig_hdr, p->payload, sizeof(*iprh)); + /* For IPV6_FRAG_COPYHEADER there is no need to copy src/dst again, as they + * will be the same as they were. With LWIP_IPV6_SCOPES, the same applies + * to the source/destination zones. */ + } + /* Only after the backup do we get to fill in the actual helper structure. */ + iprh->next_pbuf = next_pbuf; + iprh->start = start; + iprh->end = end; + + /* If this is the last fragment, calculate total packet length. */ + if ((offset & IP6_FRAG_MORE_FLAG) == 0) { + ipr->datagram_len = iprh->end; + } + + /* Additional validity tests: we have received first and last fragment. */ + iprh_tmp = (struct ip6_reass_helper*)ipr->p->payload; + if (iprh_tmp->start != 0) { + valid = 0; + } + if (ipr->datagram_len == 0) { + valid = 0; + } + + /* Final validity test: no gaps between current and last fragment. */ + iprh_prev = iprh; + q = iprh->next_pbuf; + while ((q != NULL) && valid) { + iprh = (struct ip6_reass_helper*)q->payload; + if (iprh_prev->end != iprh->start) { + valid = 0; + break; + } + iprh_prev = iprh; + q = iprh->next_pbuf; + } + + if (valid) { + /* All fragments have been received */ + struct ip6_hdr* iphdr_ptr; + + /* chain together the pbufs contained within the ip6_reassdata list. */ + iprh = (struct ip6_reass_helper*) ipr->p->payload; + while (iprh != NULL) { + next_pbuf = iprh->next_pbuf; + if (next_pbuf != NULL) { + /* Save next helper struct (will be hidden in next step). */ + iprh_tmp = (struct ip6_reass_helper*)next_pbuf->payload; + + /* hide the fragment header for every succeeding fragment */ + pbuf_remove_header(next_pbuf, IP6_FRAG_HLEN); +#if IPV6_FRAG_COPYHEADER + if (IPV6_FRAG_REQROOM > 0) { + /* hide the extra bytes borrowed from ip6_hdr for struct ip6_reass_helper */ + u8_t hdrerr = pbuf_remove_header(next_pbuf, IPV6_FRAG_REQROOM); + LWIP_UNUSED_ARG(hdrerr); /* in case of LWIP_NOASSERT */ + LWIP_ASSERT("no room for struct ip6_reass_helper", hdrerr == 0); + } +#endif + pbuf_cat(ipr->p, next_pbuf); + } + else { + iprh_tmp = NULL; + } + + iprh = iprh_tmp; + } + + /* Get the first pbuf. */ + p = ipr->p; + +#if IPV6_FRAG_COPYHEADER + if (IPV6_FRAG_REQROOM > 0) { + u8_t hdrerr; + /* Restore (only) the bytes that we overwrote beyond the fragment header. + * Those bytes may belong to either the IPv6 header or an extension + * header placed before the fragment header. */ + MEMCPY(p->payload, ipr->orig_hdr, IPV6_FRAG_REQROOM); + /* get back room for struct ip6_reass_helper (only required if sizeof(void*) > 4) */ + hdrerr = pbuf_remove_header(p, IPV6_FRAG_REQROOM); + LWIP_UNUSED_ARG(hdrerr); /* in case of LWIP_NOASSERT */ + LWIP_ASSERT("no room for struct ip6_reass_helper", hdrerr == 0); + } +#endif + + /* We need to get rid of the fragment header itself, which is somewhere in + * the middle of the packet (but still in the first pbuf of the chain). + * Getting rid of the header is required by RFC 2460 Sec. 4.5 and necessary + * in order to be able to reassemble packets that are close to full size + * (i.e., around 65535 bytes). We simply move up all the headers before the + * fragment header, including the IPv6 header, and adjust the payload start + * accordingly. This works because all these headers are in the first pbuf + * of the chain, and because the caller adjusts all its pointers on + * successful reassembly. */ + MEMMOVE((u8_t*)ipr->iphdr + sizeof(struct ip6_frag_hdr), ipr->iphdr, + (size_t)((u8_t*)p->payload - (u8_t*)ipr->iphdr)); + + /* This is where the IPv6 header is now. */ + iphdr_ptr = (struct ip6_hdr*)((u8_t*)ipr->iphdr + + sizeof(struct ip6_frag_hdr)); + + /* Adjust datagram length by adding header lengths. */ + ipr->datagram_len = (u16_t)(ipr->datagram_len + ((u8_t*)p->payload - (u8_t*)iphdr_ptr) + - IP6_HLEN); + + /* Set payload length in ip header. */ + iphdr_ptr->_plen = lwip_htons(ipr->datagram_len); + + /* With the fragment header gone, we now need to adjust the next-header + * field of whatever header was originally before it. Since the packet made + * it through the original header processing routines at least up to the + * fragment header, we do not need any further sanity checks here. */ + if (IP6H_NEXTH(iphdr_ptr) == IP6_NEXTH_FRAGMENT) { + iphdr_ptr->_nexth = ipr->nexth; + } else { + u8_t *ptr = (u8_t *)iphdr_ptr + IP6_HLEN; + while (*ptr != IP6_NEXTH_FRAGMENT) { + ptr += 8 * (1 + ptr[1]); + } + *ptr = ipr->nexth; + } + + /* release the resources allocated for the fragment queue entry */ + if (reassdatagrams == ipr) { + /* it was the first in the list */ + reassdatagrams = ipr->next; + } else { + /* it wasn't the first, so it must have a valid 'prev' */ + LWIP_ASSERT("sanity check linked list", ipr_prev != NULL); + ipr_prev->next = ipr->next; + } + memp_free(MEMP_IP6_REASSDATA, ipr); + + /* adjust the number of pbufs currently queued for reassembly. */ + clen = pbuf_clen(p); + LWIP_ASSERT("ip6_reass_pbufcount >= clen", ip6_reass_pbufcount >= clen); + ip6_reass_pbufcount = (u16_t)(ip6_reass_pbufcount - clen); + + /* Move pbuf back to IPv6 header. This should never fail. */ + if (pbuf_header_force(p, (s16_t)((u8_t*)p->payload - (u8_t*)iphdr_ptr))) { + LWIP_ASSERT("ip6_reass: moving p->payload to ip6 header failed\n", 0); + pbuf_free(p); + return NULL; + } + + /* Return the pbuf chain */ + return p; + } + /* the datagram is not (yet?) reassembled completely */ + return NULL; + +nullreturn: + IP6_FRAG_STATS_INC(ip6_frag.drop); + pbuf_free(p); + return NULL; +} + +#endif /* LWIP_IPV6 && LWIP_IPV6_REASS */ + +#if LWIP_IPV6 && LWIP_IPV6_FRAG + +#if !LWIP_NETIF_TX_SINGLE_PBUF +/** Allocate a new struct pbuf_custom_ref */ +static struct pbuf_custom_ref* +ip6_frag_alloc_pbuf_custom_ref(void) +{ + return (struct pbuf_custom_ref*)memp_malloc(MEMP_FRAG_PBUF); +} + +/** Free a struct pbuf_custom_ref */ +static void +ip6_frag_free_pbuf_custom_ref(struct pbuf_custom_ref* p) +{ + LWIP_ASSERT("p != NULL", p != NULL); + memp_free(MEMP_FRAG_PBUF, p); +} + +/** Free-callback function to free a 'struct pbuf_custom_ref', called by + * pbuf_free. */ +static void +ip6_frag_free_pbuf_custom(struct pbuf *p) +{ + struct pbuf_custom_ref *pcr = (struct pbuf_custom_ref*)p; + LWIP_ASSERT("pcr != NULL", pcr != NULL); + LWIP_ASSERT("pcr == p", (void*)pcr == (void*)p); + if (pcr->original != NULL) { + pbuf_free(pcr->original); + } + ip6_frag_free_pbuf_custom_ref(pcr); +} +#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ + +/** + * Fragment an IPv6 datagram if too large for the netif or path MTU. + * + * Chop the datagram in MTU sized chunks and send them in order + * by pointing PBUF_REFs into p + * + * @param p ipv6 packet to send + * @param netif the netif on which to send + * @param dest destination ipv6 address to which to send + * + * @return ERR_OK if sent successfully, err_t otherwise + */ +err_t +ip6_frag(struct pbuf *p, struct netif *netif, const ip6_addr_t *dest) +{ + struct ip6_hdr *original_ip6hdr; + struct ip6_hdr *ip6hdr; + struct ip6_frag_hdr *frag_hdr; + struct pbuf *rambuf; +#if !LWIP_NETIF_TX_SINGLE_PBUF + struct pbuf *newpbuf; + u16_t newpbuflen = 0; + u16_t left_to_copy; +#endif + static u32_t identification; + u16_t left, cop; + const u16_t mtu = nd6_get_destination_mtu(dest, netif); + const u16_t nfb = (u16_t)((mtu - (IP6_HLEN + IP6_FRAG_HLEN)) & IP6_FRAG_OFFSET_MASK); + u16_t fragment_offset = 0; + u16_t last; + u16_t poff = IP6_HLEN; + + identification++; + + original_ip6hdr = (struct ip6_hdr *)p->payload; + + /* @todo we assume there are no options in the unfragmentable part (IPv6 header). */ + LWIP_ASSERT("p->tot_len >= IP6_HLEN", p->tot_len >= IP6_HLEN); + left = (u16_t)(p->tot_len - IP6_HLEN); + + while (left) { + last = (left <= nfb); + + /* Fill this fragment */ + cop = last ? left : nfb; + +#if LWIP_NETIF_TX_SINGLE_PBUF + rambuf = pbuf_alloc(PBUF_IP, cop + IP6_FRAG_HLEN, PBUF_RAM); + if (rambuf == NULL) { + IP6_FRAG_STATS_INC(ip6_frag.memerr); + return ERR_MEM; + } + LWIP_ASSERT("this needs a pbuf in one piece!", + (rambuf->len == rambuf->tot_len) && (rambuf->next == NULL)); + poff += pbuf_copy_partial(p, (u8_t*)rambuf->payload + IP6_FRAG_HLEN, cop, poff); + /* make room for the IP header */ + if (pbuf_add_header(rambuf, IP6_HLEN)) { + pbuf_free(rambuf); + IP6_FRAG_STATS_INC(ip6_frag.memerr); + return ERR_MEM; + } + /* fill in the IP header */ + SMEMCPY(rambuf->payload, original_ip6hdr, IP6_HLEN); + ip6hdr = (struct ip6_hdr *)rambuf->payload; + frag_hdr = (struct ip6_frag_hdr *)((u8_t*)rambuf->payload + IP6_HLEN); +#else + /* When not using a static buffer, create a chain of pbufs. + * The first will be a PBUF_RAM holding the link, IPv6, and Fragment header. + * The rest will be PBUF_REFs mirroring the pbuf chain to be fragged, + * but limited to the size of an mtu. + */ + rambuf = pbuf_alloc(PBUF_LINK, IP6_HLEN + IP6_FRAG_HLEN, PBUF_RAM); + if (rambuf == NULL) { + IP6_FRAG_STATS_INC(ip6_frag.memerr); + return ERR_MEM; + } + LWIP_ASSERT("this needs a pbuf in one piece!", + (p->len >= (IP6_HLEN))); + SMEMCPY(rambuf->payload, original_ip6hdr, IP6_HLEN); + ip6hdr = (struct ip6_hdr *)rambuf->payload; + frag_hdr = (struct ip6_frag_hdr *)((u8_t*)rambuf->payload + IP6_HLEN); + + /* Can just adjust p directly for needed offset. */ + p->payload = (u8_t *)p->payload + poff; + p->len = (u16_t)(p->len - poff); + p->tot_len = (u16_t)(p->tot_len - poff); + + left_to_copy = cop; + while (left_to_copy) { + struct pbuf_custom_ref *pcr; + newpbuflen = (left_to_copy < p->len) ? left_to_copy : p->len; + /* Is this pbuf already empty? */ + if (!newpbuflen) { + p = p->next; + continue; + } + pcr = ip6_frag_alloc_pbuf_custom_ref(); + if (pcr == NULL) { + pbuf_free(rambuf); + IP6_FRAG_STATS_INC(ip6_frag.memerr); + return ERR_MEM; + } + /* Mirror this pbuf, although we might not need all of it. */ + newpbuf = pbuf_alloced_custom(PBUF_RAW, newpbuflen, PBUF_REF, &pcr->pc, p->payload, newpbuflen); + if (newpbuf == NULL) { + ip6_frag_free_pbuf_custom_ref(pcr); + pbuf_free(rambuf); + IP6_FRAG_STATS_INC(ip6_frag.memerr); + return ERR_MEM; + } + pbuf_ref(p); + pcr->original = p; + pcr->pc.custom_free_function = ip6_frag_free_pbuf_custom; + + /* Add it to end of rambuf's chain, but using pbuf_cat, not pbuf_chain + * so that it is removed when pbuf_dechain is later called on rambuf. + */ + pbuf_cat(rambuf, newpbuf); + left_to_copy = (u16_t)(left_to_copy - newpbuflen); + if (left_to_copy) { + p = p->next; + } + } + poff = newpbuflen; +#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ + + /* Set headers */ + frag_hdr->_nexth = original_ip6hdr->_nexth; + frag_hdr->reserved = 0; + frag_hdr->_fragment_offset = lwip_htons((u16_t)((fragment_offset & IP6_FRAG_OFFSET_MASK) | (last ? 0 : IP6_FRAG_MORE_FLAG))); + frag_hdr->_identification = lwip_htonl(identification); + + IP6H_NEXTH_SET(ip6hdr, IP6_NEXTH_FRAGMENT); + IP6H_PLEN_SET(ip6hdr, (u16_t)(cop + IP6_FRAG_HLEN)); + + /* No need for separate header pbuf - we allowed room for it in rambuf + * when allocated. + */ + IP6_FRAG_STATS_INC(ip6_frag.xmit); + netif->output_ip6(netif, rambuf, dest); + + /* Unfortunately we can't reuse rambuf - the hardware may still be + * using the buffer. Instead we free it (and the ensuing chain) and + * recreate it next time round the loop. If we're lucky the hardware + * will have already sent the packet, the free will really free, and + * there will be zero memory penalty. + */ + + pbuf_free(rambuf); + left = (u16_t)(left - cop); + fragment_offset = (u16_t)(fragment_offset + cop); + } + return ERR_OK; +} + +#endif /* LWIP_IPV6 && LWIP_IPV6_FRAG */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/mld6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/mld6.c index db1d09ae..6387d468 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/mld6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/mld6.c @@ -1,626 +1,626 @@ -/** - * @file - * Multicast listener discovery - * - * @defgroup mld6 MLD6 - * @ingroup ip6 - * Multicast listener discovery for IPv6. Aims to be compliant with RFC 2710. - * No support for MLDv2.\n - * Note: The allnodes (ff01::1, ff02::1) group is assumed be received by your - * netif since it must always be received for correct IPv6 operation (e.g. SLAAC). - * Ensure the netif filters are configured accordingly!\n - * The netif flags also need NETIF_FLAG_MLD6 flag set to enable MLD6 on a - * netif ("netif->flags |= NETIF_FLAG_MLD6;").\n - * To be called from TCPIP thread. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -/* Based on igmp.c implementation of igmp v2 protocol */ - -#include "lwip/opt.h" - -#if LWIP_IPV6 && LWIP_IPV6_MLD /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/mld6.h" -#include "lwip/prot/mld6.h" -#include "lwip/icmp6.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/ip.h" -#include "lwip/inet_chksum.h" -#include "lwip/pbuf.h" -#include "lwip/netif.h" -#include "lwip/memp.h" -#include "lwip/stats.h" - -#include - - -/* - * MLD constants - */ -#define MLD6_HL 1 -#define MLD6_JOIN_DELAYING_MEMBER_TMR_MS (500) - -#define MLD6_GROUP_NON_MEMBER 0 -#define MLD6_GROUP_DELAYING_MEMBER 1 -#define MLD6_GROUP_IDLE_MEMBER 2 - -/* Forward declarations. */ -static struct mld_group *mld6_new_group(struct netif *ifp, const ip6_addr_t *addr); -static err_t mld6_remove_group(struct netif *netif, struct mld_group *group); -static void mld6_delayed_report(struct mld_group *group, u16_t maxresp); -static void mld6_send(struct netif *netif, struct mld_group *group, u8_t type); - - -/** - * Stop MLD processing on interface - * - * @param netif network interface on which stop MLD processing - */ -err_t -mld6_stop(struct netif *netif) -{ - struct mld_group *group = netif_mld6_data(netif); - - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, NULL); - - while (group != NULL) { - struct mld_group *next = group->next; /* avoid use-after-free below */ - - /* disable the group at the MAC level */ - if (netif->mld_mac_filter != NULL) { - netif->mld_mac_filter(netif, &(group->group_address), NETIF_DEL_MAC_FILTER); - } - - /* free group */ - memp_free(MEMP_MLD6_GROUP, group); - - /* move to "next" */ - group = next; - } - return ERR_OK; -} - -/** - * Report MLD memberships for this interface - * - * @param netif network interface on which report MLD memberships - */ -void -mld6_report_groups(struct netif *netif) -{ - struct mld_group *group = netif_mld6_data(netif); - - while (group != NULL) { - mld6_delayed_report(group, MLD6_JOIN_DELAYING_MEMBER_TMR_MS); - group = group->next; - } -} - -/** - * Search for a group that is joined on a netif - * - * @param ifp the network interface for which to look - * @param addr the group ipv6 address to search for - * @return a struct mld_group* if the group has been found, - * NULL if the group wasn't found. - */ -struct mld_group * -mld6_lookfor_group(struct netif *ifp, const ip6_addr_t *addr) -{ - struct mld_group *group = netif_mld6_data(ifp); - - while (group != NULL) { - if (ip6_addr_cmp(&(group->group_address), addr)) { - return group; - } - group = group->next; - } - - return NULL; -} - - -/** - * create a new group - * - * @param ifp the network interface for which to create - * @param addr the new group ipv6 - * @return a struct mld_group*, - * NULL on memory error. - */ -static struct mld_group * -mld6_new_group(struct netif *ifp, const ip6_addr_t *addr) -{ - struct mld_group *group; - - group = (struct mld_group *)memp_malloc(MEMP_MLD6_GROUP); - if (group != NULL) { - ip6_addr_set(&(group->group_address), addr); - group->timer = 0; /* Not running */ - group->group_state = MLD6_GROUP_IDLE_MEMBER; - group->last_reporter_flag = 0; - group->use = 0; - group->next = netif_mld6_data(ifp); - - netif_set_client_data(ifp, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, group); - } - - return group; -} - -/** - * Remove a group from the mld_group_list, but do not free it yet - * - * @param group the group to remove - * @return ERR_OK if group was removed from the list, an err_t otherwise - */ -static err_t -mld6_remove_group(struct netif *netif, struct mld_group *group) -{ - err_t err = ERR_OK; - - /* Is it the first group? */ - if (netif_mld6_data(netif) == group) { - netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, group->next); - } else { - /* look for group further down the list */ - struct mld_group *tmpGroup; - for (tmpGroup = netif_mld6_data(netif); tmpGroup != NULL; tmpGroup = tmpGroup->next) { - if (tmpGroup->next == group) { - tmpGroup->next = group->next; - break; - } - } - /* Group not find group */ - if (tmpGroup == NULL) { - err = ERR_ARG; - } - } - - return err; -} - - -/** - * Process an input MLD message. Called by icmp6_input. - * - * @param p the mld packet, p->payload pointing to the icmpv6 header - * @param inp the netif on which this packet was received - */ -void -mld6_input(struct pbuf *p, struct netif *inp) -{ - struct mld_header *mld_hdr; - struct mld_group *group; - - MLD6_STATS_INC(mld6.recv); - - /* Check that mld header fits in packet. */ - if (p->len < sizeof(struct mld_header)) { - /* @todo debug message */ - pbuf_free(p); - MLD6_STATS_INC(mld6.lenerr); - MLD6_STATS_INC(mld6.drop); - return; - } - - mld_hdr = (struct mld_header *)p->payload; - - switch (mld_hdr->type) { - case ICMP6_TYPE_MLQ: /* Multicast listener query. */ - /* Is it a general query? */ - if (ip6_addr_isallnodes_linklocal(ip6_current_dest_addr()) && - ip6_addr_isany(&(mld_hdr->multicast_address))) { - MLD6_STATS_INC(mld6.rx_general); - /* Report all groups, except all nodes group, and if-local groups. */ - group = netif_mld6_data(inp); - while (group != NULL) { - if ((!(ip6_addr_ismulticast_iflocal(&(group->group_address)))) && - (!(ip6_addr_isallnodes_linklocal(&(group->group_address))))) { - mld6_delayed_report(group, mld_hdr->max_resp_delay); - } - group = group->next; - } - } else { - /* Have we joined this group? - * We use IP6 destination address to have a memory aligned copy. - * mld_hdr->multicast_address should be the same. */ - MLD6_STATS_INC(mld6.rx_group); - group = mld6_lookfor_group(inp, ip6_current_dest_addr()); - if (group != NULL) { - /* Schedule a report. */ - mld6_delayed_report(group, mld_hdr->max_resp_delay); - } - } - break; /* ICMP6_TYPE_MLQ */ - case ICMP6_TYPE_MLR: /* Multicast listener report. */ - /* Have we joined this group? - * We use IP6 destination address to have a memory aligned copy. - * mld_hdr->multicast_address should be the same. */ - MLD6_STATS_INC(mld6.rx_report); - group = mld6_lookfor_group(inp, ip6_current_dest_addr()); - if (group != NULL) { - /* If we are waiting to report, cancel it. */ - if (group->group_state == MLD6_GROUP_DELAYING_MEMBER) { - group->timer = 0; /* stopped */ - group->group_state = MLD6_GROUP_IDLE_MEMBER; - group->last_reporter_flag = 0; - } - } - break; /* ICMP6_TYPE_MLR */ - case ICMP6_TYPE_MLD: /* Multicast listener done. */ - /* Do nothing, router will query us. */ - break; /* ICMP6_TYPE_MLD */ - default: - MLD6_STATS_INC(mld6.proterr); - MLD6_STATS_INC(mld6.drop); - break; - } - - pbuf_free(p); -} - -/** - * @ingroup mld6 - * Join a group on one or all network interfaces. - * - * If the group is to be joined on all interfaces, the given group address must - * not have a zone set (i.e., it must have its zone index set to IP6_NO_ZONE). - * If the group is to be joined on one particular interface, the given group - * address may or may not have a zone set. - * - * @param srcaddr ipv6 address (zoned) of the network interface which should - * join a new group. If IP6_ADDR_ANY6, join on all netifs - * @param groupaddr the ipv6 address of the group to join (possibly but not - * necessarily zoned) - * @return ERR_OK if group was joined on the netif(s), an err_t otherwise - */ -err_t -mld6_joingroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr) -{ - err_t err = ERR_VAL; /* no matching interface */ - struct netif *netif; - - LWIP_ASSERT_CORE_LOCKED(); - - /* loop through netif's */ - NETIF_FOREACH(netif) { - /* Should we join this interface ? */ - if (ip6_addr_isany(srcaddr) || - netif_get_ip6_addr_match(netif, srcaddr) >= 0) { - err = mld6_joingroup_netif(netif, groupaddr); - if (err != ERR_OK) { - return err; - } - } - } - - return err; -} - -/** - * @ingroup mld6 - * Join a group on a network interface. - * - * @param netif the network interface which should join a new group. - * @param groupaddr the ipv6 address of the group to join (possibly but not - * necessarily zoned) - * @return ERR_OK if group was joined on the netif, an err_t otherwise - */ -err_t -mld6_joingroup_netif(struct netif *netif, const ip6_addr_t *groupaddr) -{ - struct mld_group *group; -#if LWIP_IPV6_SCOPES - ip6_addr_t ip6addr; - - /* If the address has a particular scope but no zone set, use the netif to - * set one now. Within the mld6 module, all addresses are properly zoned. */ - if (ip6_addr_lacks_zone(groupaddr, IP6_MULTICAST)) { - ip6_addr_set(&ip6addr, groupaddr); - ip6_addr_assign_zone(&ip6addr, IP6_MULTICAST, netif); - groupaddr = &ip6addr; - } - IP6_ADDR_ZONECHECK_NETIF(groupaddr, netif); -#endif /* LWIP_IPV6_SCOPES */ - - LWIP_ASSERT_CORE_LOCKED(); - - /* find group or create a new one if not found */ - group = mld6_lookfor_group(netif, groupaddr); - - if (group == NULL) { - /* Joining a new group. Create a new group entry. */ - group = mld6_new_group(netif, groupaddr); - if (group == NULL) { - return ERR_MEM; - } - - /* Activate this address on the MAC layer. */ - if (netif->mld_mac_filter != NULL) { - netif->mld_mac_filter(netif, groupaddr, NETIF_ADD_MAC_FILTER); - } - - /* Report our membership. */ - MLD6_STATS_INC(mld6.tx_report); - mld6_send(netif, group, ICMP6_TYPE_MLR); - mld6_delayed_report(group, MLD6_JOIN_DELAYING_MEMBER_TMR_MS); - } - - /* Increment group use */ - group->use++; - return ERR_OK; -} - -/** - * @ingroup mld6 - * Leave a group on a network interface. - * - * Zoning of address follows the same rules as @ref mld6_joingroup. - * - * @param srcaddr ipv6 address (zoned) of the network interface which should - * leave the group. If IP6_ADDR_ANY6, leave on all netifs - * @param groupaddr the ipv6 address of the group to leave (possibly, but not - * necessarily zoned) - * @return ERR_OK if group was left on the netif(s), an err_t otherwise - */ -err_t -mld6_leavegroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr) -{ - err_t err = ERR_VAL; /* no matching interface */ - struct netif *netif; - - LWIP_ASSERT_CORE_LOCKED(); - - /* loop through netif's */ - NETIF_FOREACH(netif) { - /* Should we leave this interface ? */ - if (ip6_addr_isany(srcaddr) || - netif_get_ip6_addr_match(netif, srcaddr) >= 0) { - err_t res = mld6_leavegroup_netif(netif, groupaddr); - if (err != ERR_OK) { - /* Store this result if we have not yet gotten a success */ - err = res; - } - } - } - - return err; -} - -/** - * @ingroup mld6 - * Leave a group on a network interface. - * - * @param netif the network interface which should leave the group. - * @param groupaddr the ipv6 address of the group to leave (possibly, but not - * necessarily zoned) - * @return ERR_OK if group was left on the netif, an err_t otherwise - */ -err_t -mld6_leavegroup_netif(struct netif *netif, const ip6_addr_t *groupaddr) -{ - struct mld_group *group; -#if LWIP_IPV6_SCOPES - ip6_addr_t ip6addr; - - if (ip6_addr_lacks_zone(groupaddr, IP6_MULTICAST)) { - ip6_addr_set(&ip6addr, groupaddr); - ip6_addr_assign_zone(&ip6addr, IP6_MULTICAST, netif); - groupaddr = &ip6addr; - } - IP6_ADDR_ZONECHECK_NETIF(groupaddr, netif); -#endif /* LWIP_IPV6_SCOPES */ - - LWIP_ASSERT_CORE_LOCKED(); - - /* find group */ - group = mld6_lookfor_group(netif, groupaddr); - - if (group != NULL) { - /* Leave if there is no other use of the group */ - if (group->use <= 1) { - /* Remove the group from the list */ - mld6_remove_group(netif, group); - - /* If we are the last reporter for this group */ - if (group->last_reporter_flag) { - MLD6_STATS_INC(mld6.tx_leave); - mld6_send(netif, group, ICMP6_TYPE_MLD); - } - - /* Disable the group at the MAC level */ - if (netif->mld_mac_filter != NULL) { - netif->mld_mac_filter(netif, groupaddr, NETIF_DEL_MAC_FILTER); - } - - /* free group struct */ - memp_free(MEMP_MLD6_GROUP, group); - } else { - /* Decrement group use */ - group->use--; - } - - /* Left group */ - return ERR_OK; - } - - /* Group not found */ - return ERR_VAL; -} - - -/** - * Periodic timer for mld processing. Must be called every - * MLD6_TMR_INTERVAL milliseconds (100). - * - * When a delaying member expires, a membership report is sent. - */ -void -mld6_tmr(void) -{ - struct netif *netif; - - NETIF_FOREACH(netif) { - struct mld_group *group = netif_mld6_data(netif); - - while (group != NULL) { - if (group->timer > 0) { - group->timer--; - if (group->timer == 0) { - /* If the state is MLD6_GROUP_DELAYING_MEMBER then we send a report for this group */ - if (group->group_state == MLD6_GROUP_DELAYING_MEMBER) { - MLD6_STATS_INC(mld6.tx_report); - mld6_send(netif, group, ICMP6_TYPE_MLR); - group->group_state = MLD6_GROUP_IDLE_MEMBER; - } - } - } - group = group->next; - } - } -} - -/** - * Schedule a delayed membership report for a group - * - * @param group the mld_group for which "delaying" membership report - * should be sent - * @param maxresp_in the max resp delay provided in the query - */ -static void -mld6_delayed_report(struct mld_group *group, u16_t maxresp_in) -{ - /* Convert maxresp from milliseconds to tmr ticks */ - u16_t maxresp = maxresp_in / MLD6_TMR_INTERVAL; - if (maxresp == 0) { - maxresp = 1; - } - -#ifdef LWIP_RAND - /* Randomize maxresp. (if LWIP_RAND is supported) */ - maxresp = (u16_t)(LWIP_RAND() % maxresp); - if (maxresp == 0) { - maxresp = 1; - } -#endif /* LWIP_RAND */ - - /* Apply timer value if no report has been scheduled already. */ - if ((group->group_state == MLD6_GROUP_IDLE_MEMBER) || - ((group->group_state == MLD6_GROUP_DELAYING_MEMBER) && - ((group->timer == 0) || (maxresp < group->timer)))) { - group->timer = maxresp; - group->group_state = MLD6_GROUP_DELAYING_MEMBER; - } -} - -/** - * Send a MLD message (report or done). - * - * An IPv6 hop-by-hop options header with a router alert option - * is prepended. - * - * @param group the group to report or quit - * @param type ICMP6_TYPE_MLR (report) or ICMP6_TYPE_MLD (done) - */ -static void -mld6_send(struct netif *netif, struct mld_group *group, u8_t type) -{ - struct mld_header *mld_hdr; - struct pbuf *p; - const ip6_addr_t *src_addr; - - /* Allocate a packet. Size is MLD header + IPv6 Hop-by-hop options header. */ - p = pbuf_alloc(PBUF_IP, sizeof(struct mld_header) + MLD6_HBH_HLEN, PBUF_RAM); - if (p == NULL) { - MLD6_STATS_INC(mld6.memerr); - return; - } - - /* Move to make room for Hop-by-hop options header. */ - if (pbuf_remove_header(p, MLD6_HBH_HLEN)) { - pbuf_free(p); - MLD6_STATS_INC(mld6.lenerr); - return; - } - - /* Select our source address. */ - if (!ip6_addr_isvalid(netif_ip6_addr_state(netif, 0))) { - /* This is a special case, when we are performing duplicate address detection. - * We must join the multicast group, but we don't have a valid address yet. */ - src_addr = IP6_ADDR_ANY6; - } else { - /* Use link-local address as source address. */ - src_addr = netif_ip6_addr(netif, 0); - } - - /* MLD message header pointer. */ - mld_hdr = (struct mld_header *)p->payload; - - /* Set fields. */ - mld_hdr->type = type; - mld_hdr->code = 0; - mld_hdr->chksum = 0; - mld_hdr->max_resp_delay = 0; - mld_hdr->reserved = 0; - ip6_addr_copy_to_packed(mld_hdr->multicast_address, group->group_address); - -#if CHECKSUM_GEN_ICMP6 - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { - mld_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, - src_addr, &(group->group_address)); - } -#endif /* CHECKSUM_GEN_ICMP6 */ - - /* Add hop-by-hop headers options: router alert with MLD value. */ - ip6_options_add_hbh_ra(p, IP6_NEXTH_ICMP6, IP6_ROUTER_ALERT_VALUE_MLD); - - if (type == ICMP6_TYPE_MLR) { - /* Remember we were the last to report */ - group->last_reporter_flag = 1; - } - - /* Send the packet out. */ - MLD6_STATS_INC(mld6.xmit); - ip6_output_if(p, (ip6_addr_isany(src_addr)) ? NULL : src_addr, &(group->group_address), - MLD6_HL, 0, IP6_NEXTH_HOPBYHOP, netif); - pbuf_free(p); -} - -#endif /* LWIP_IPV6 */ +/** + * @file + * Multicast listener discovery + * + * @defgroup mld6 MLD6 + * @ingroup ip6 + * Multicast listener discovery for IPv6. Aims to be compliant with RFC 2710. + * No support for MLDv2.\n + * Note: The allnodes (ff01::1, ff02::1) group is assumed be received by your + * netif since it must always be received for correct IPv6 operation (e.g. SLAAC). + * Ensure the netif filters are configured accordingly!\n + * The netif flags also need NETIF_FLAG_MLD6 flag set to enable MLD6 on a + * netif ("netif->flags |= NETIF_FLAG_MLD6;").\n + * To be called from TCPIP thread. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +/* Based on igmp.c implementation of igmp v2 protocol */ + +#include "lwip/opt.h" + +#if LWIP_IPV6 && LWIP_IPV6_MLD /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/mld6.h" +#include "lwip/prot/mld6.h" +#include "lwip/icmp6.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/ip.h" +#include "lwip/inet_chksum.h" +#include "lwip/pbuf.h" +#include "lwip/netif.h" +#include "lwip/memp.h" +#include "lwip/stats.h" + +#include + + +/* + * MLD constants + */ +#define MLD6_HL 1 +#define MLD6_JOIN_DELAYING_MEMBER_TMR_MS (500) + +#define MLD6_GROUP_NON_MEMBER 0 +#define MLD6_GROUP_DELAYING_MEMBER 1 +#define MLD6_GROUP_IDLE_MEMBER 2 + +/* Forward declarations. */ +static struct mld_group *mld6_new_group(struct netif *ifp, const ip6_addr_t *addr); +static err_t mld6_remove_group(struct netif *netif, struct mld_group *group); +static void mld6_delayed_report(struct mld_group *group, u16_t maxresp); +static void mld6_send(struct netif *netif, struct mld_group *group, u8_t type); + + +/** + * Stop MLD processing on interface + * + * @param netif network interface on which stop MLD processing + */ +err_t +mld6_stop(struct netif *netif) +{ + struct mld_group *group = netif_mld6_data(netif); + + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, NULL); + + while (group != NULL) { + struct mld_group *next = group->next; /* avoid use-after-free below */ + + /* disable the group at the MAC level */ + if (netif->mld_mac_filter != NULL) { + netif->mld_mac_filter(netif, &(group->group_address), NETIF_DEL_MAC_FILTER); + } + + /* free group */ + memp_free(MEMP_MLD6_GROUP, group); + + /* move to "next" */ + group = next; + } + return ERR_OK; +} + +/** + * Report MLD memberships for this interface + * + * @param netif network interface on which report MLD memberships + */ +void +mld6_report_groups(struct netif *netif) +{ + struct mld_group *group = netif_mld6_data(netif); + + while (group != NULL) { + mld6_delayed_report(group, MLD6_JOIN_DELAYING_MEMBER_TMR_MS); + group = group->next; + } +} + +/** + * Search for a group that is joined on a netif + * + * @param ifp the network interface for which to look + * @param addr the group ipv6 address to search for + * @return a struct mld_group* if the group has been found, + * NULL if the group wasn't found. + */ +struct mld_group * +mld6_lookfor_group(struct netif *ifp, const ip6_addr_t *addr) +{ + struct mld_group *group = netif_mld6_data(ifp); + + while (group != NULL) { + if (ip6_addr_cmp(&(group->group_address), addr)) { + return group; + } + group = group->next; + } + + return NULL; +} + + +/** + * create a new group + * + * @param ifp the network interface for which to create + * @param addr the new group ipv6 + * @return a struct mld_group*, + * NULL on memory error. + */ +static struct mld_group * +mld6_new_group(struct netif *ifp, const ip6_addr_t *addr) +{ + struct mld_group *group; + + group = (struct mld_group *)memp_malloc(MEMP_MLD6_GROUP); + if (group != NULL) { + ip6_addr_set(&(group->group_address), addr); + group->timer = 0; /* Not running */ + group->group_state = MLD6_GROUP_IDLE_MEMBER; + group->last_reporter_flag = 0; + group->use = 0; + group->next = netif_mld6_data(ifp); + + netif_set_client_data(ifp, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, group); + } + + return group; +} + +/** + * Remove a group from the mld_group_list, but do not free it yet + * + * @param group the group to remove + * @return ERR_OK if group was removed from the list, an err_t otherwise + */ +static err_t +mld6_remove_group(struct netif *netif, struct mld_group *group) +{ + err_t err = ERR_OK; + + /* Is it the first group? */ + if (netif_mld6_data(netif) == group) { + netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, group->next); + } else { + /* look for group further down the list */ + struct mld_group *tmpGroup; + for (tmpGroup = netif_mld6_data(netif); tmpGroup != NULL; tmpGroup = tmpGroup->next) { + if (tmpGroup->next == group) { + tmpGroup->next = group->next; + break; + } + } + /* Group not find group */ + if (tmpGroup == NULL) { + err = ERR_ARG; + } + } + + return err; +} + + +/** + * Process an input MLD message. Called by icmp6_input. + * + * @param p the mld packet, p->payload pointing to the icmpv6 header + * @param inp the netif on which this packet was received + */ +void +mld6_input(struct pbuf *p, struct netif *inp) +{ + struct mld_header *mld_hdr; + struct mld_group *group; + + MLD6_STATS_INC(mld6.recv); + + /* Check that mld header fits in packet. */ + if (p->len < sizeof(struct mld_header)) { + /* @todo debug message */ + pbuf_free(p); + MLD6_STATS_INC(mld6.lenerr); + MLD6_STATS_INC(mld6.drop); + return; + } + + mld_hdr = (struct mld_header *)p->payload; + + switch (mld_hdr->type) { + case ICMP6_TYPE_MLQ: /* Multicast listener query. */ + /* Is it a general query? */ + if (ip6_addr_isallnodes_linklocal(ip6_current_dest_addr()) && + ip6_addr_isany(&(mld_hdr->multicast_address))) { + MLD6_STATS_INC(mld6.rx_general); + /* Report all groups, except all nodes group, and if-local groups. */ + group = netif_mld6_data(inp); + while (group != NULL) { + if ((!(ip6_addr_ismulticast_iflocal(&(group->group_address)))) && + (!(ip6_addr_isallnodes_linklocal(&(group->group_address))))) { + mld6_delayed_report(group, mld_hdr->max_resp_delay); + } + group = group->next; + } + } else { + /* Have we joined this group? + * We use IP6 destination address to have a memory aligned copy. + * mld_hdr->multicast_address should be the same. */ + MLD6_STATS_INC(mld6.rx_group); + group = mld6_lookfor_group(inp, ip6_current_dest_addr()); + if (group != NULL) { + /* Schedule a report. */ + mld6_delayed_report(group, mld_hdr->max_resp_delay); + } + } + break; /* ICMP6_TYPE_MLQ */ + case ICMP6_TYPE_MLR: /* Multicast listener report. */ + /* Have we joined this group? + * We use IP6 destination address to have a memory aligned copy. + * mld_hdr->multicast_address should be the same. */ + MLD6_STATS_INC(mld6.rx_report); + group = mld6_lookfor_group(inp, ip6_current_dest_addr()); + if (group != NULL) { + /* If we are waiting to report, cancel it. */ + if (group->group_state == MLD6_GROUP_DELAYING_MEMBER) { + group->timer = 0; /* stopped */ + group->group_state = MLD6_GROUP_IDLE_MEMBER; + group->last_reporter_flag = 0; + } + } + break; /* ICMP6_TYPE_MLR */ + case ICMP6_TYPE_MLD: /* Multicast listener done. */ + /* Do nothing, router will query us. */ + break; /* ICMP6_TYPE_MLD */ + default: + MLD6_STATS_INC(mld6.proterr); + MLD6_STATS_INC(mld6.drop); + break; + } + + pbuf_free(p); +} + +/** + * @ingroup mld6 + * Join a group on one or all network interfaces. + * + * If the group is to be joined on all interfaces, the given group address must + * not have a zone set (i.e., it must have its zone index set to IP6_NO_ZONE). + * If the group is to be joined on one particular interface, the given group + * address may or may not have a zone set. + * + * @param srcaddr ipv6 address (zoned) of the network interface which should + * join a new group. If IP6_ADDR_ANY6, join on all netifs + * @param groupaddr the ipv6 address of the group to join (possibly but not + * necessarily zoned) + * @return ERR_OK if group was joined on the netif(s), an err_t otherwise + */ +err_t +mld6_joingroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr) +{ + err_t err = ERR_VAL; /* no matching interface */ + struct netif *netif; + + LWIP_ASSERT_CORE_LOCKED(); + + /* loop through netif's */ + NETIF_FOREACH(netif) { + /* Should we join this interface ? */ + if (ip6_addr_isany(srcaddr) || + netif_get_ip6_addr_match(netif, srcaddr) >= 0) { + err = mld6_joingroup_netif(netif, groupaddr); + if (err != ERR_OK) { + return err; + } + } + } + + return err; +} + +/** + * @ingroup mld6 + * Join a group on a network interface. + * + * @param netif the network interface which should join a new group. + * @param groupaddr the ipv6 address of the group to join (possibly but not + * necessarily zoned) + * @return ERR_OK if group was joined on the netif, an err_t otherwise + */ +err_t +mld6_joingroup_netif(struct netif *netif, const ip6_addr_t *groupaddr) +{ + struct mld_group *group; +#if LWIP_IPV6_SCOPES + ip6_addr_t ip6addr; + + /* If the address has a particular scope but no zone set, use the netif to + * set one now. Within the mld6 module, all addresses are properly zoned. */ + if (ip6_addr_lacks_zone(groupaddr, IP6_MULTICAST)) { + ip6_addr_set(&ip6addr, groupaddr); + ip6_addr_assign_zone(&ip6addr, IP6_MULTICAST, netif); + groupaddr = &ip6addr; + } + IP6_ADDR_ZONECHECK_NETIF(groupaddr, netif); +#endif /* LWIP_IPV6_SCOPES */ + + LWIP_ASSERT_CORE_LOCKED(); + + /* find group or create a new one if not found */ + group = mld6_lookfor_group(netif, groupaddr); + + if (group == NULL) { + /* Joining a new group. Create a new group entry. */ + group = mld6_new_group(netif, groupaddr); + if (group == NULL) { + return ERR_MEM; + } + + /* Activate this address on the MAC layer. */ + if (netif->mld_mac_filter != NULL) { + netif->mld_mac_filter(netif, groupaddr, NETIF_ADD_MAC_FILTER); + } + + /* Report our membership. */ + MLD6_STATS_INC(mld6.tx_report); + mld6_send(netif, group, ICMP6_TYPE_MLR); + mld6_delayed_report(group, MLD6_JOIN_DELAYING_MEMBER_TMR_MS); + } + + /* Increment group use */ + group->use++; + return ERR_OK; +} + +/** + * @ingroup mld6 + * Leave a group on a network interface. + * + * Zoning of address follows the same rules as @ref mld6_joingroup. + * + * @param srcaddr ipv6 address (zoned) of the network interface which should + * leave the group. If IP6_ADDR_ANY6, leave on all netifs + * @param groupaddr the ipv6 address of the group to leave (possibly, but not + * necessarily zoned) + * @return ERR_OK if group was left on the netif(s), an err_t otherwise + */ +err_t +mld6_leavegroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr) +{ + err_t err = ERR_VAL; /* no matching interface */ + struct netif *netif; + + LWIP_ASSERT_CORE_LOCKED(); + + /* loop through netif's */ + NETIF_FOREACH(netif) { + /* Should we leave this interface ? */ + if (ip6_addr_isany(srcaddr) || + netif_get_ip6_addr_match(netif, srcaddr) >= 0) { + err_t res = mld6_leavegroup_netif(netif, groupaddr); + if (err != ERR_OK) { + /* Store this result if we have not yet gotten a success */ + err = res; + } + } + } + + return err; +} + +/** + * @ingroup mld6 + * Leave a group on a network interface. + * + * @param netif the network interface which should leave the group. + * @param groupaddr the ipv6 address of the group to leave (possibly, but not + * necessarily zoned) + * @return ERR_OK if group was left on the netif, an err_t otherwise + */ +err_t +mld6_leavegroup_netif(struct netif *netif, const ip6_addr_t *groupaddr) +{ + struct mld_group *group; +#if LWIP_IPV6_SCOPES + ip6_addr_t ip6addr; + + if (ip6_addr_lacks_zone(groupaddr, IP6_MULTICAST)) { + ip6_addr_set(&ip6addr, groupaddr); + ip6_addr_assign_zone(&ip6addr, IP6_MULTICAST, netif); + groupaddr = &ip6addr; + } + IP6_ADDR_ZONECHECK_NETIF(groupaddr, netif); +#endif /* LWIP_IPV6_SCOPES */ + + LWIP_ASSERT_CORE_LOCKED(); + + /* find group */ + group = mld6_lookfor_group(netif, groupaddr); + + if (group != NULL) { + /* Leave if there is no other use of the group */ + if (group->use <= 1) { + /* Remove the group from the list */ + mld6_remove_group(netif, group); + + /* If we are the last reporter for this group */ + if (group->last_reporter_flag) { + MLD6_STATS_INC(mld6.tx_leave); + mld6_send(netif, group, ICMP6_TYPE_MLD); + } + + /* Disable the group at the MAC level */ + if (netif->mld_mac_filter != NULL) { + netif->mld_mac_filter(netif, groupaddr, NETIF_DEL_MAC_FILTER); + } + + /* free group struct */ + memp_free(MEMP_MLD6_GROUP, group); + } else { + /* Decrement group use */ + group->use--; + } + + /* Left group */ + return ERR_OK; + } + + /* Group not found */ + return ERR_VAL; +} + + +/** + * Periodic timer for mld processing. Must be called every + * MLD6_TMR_INTERVAL milliseconds (100). + * + * When a delaying member expires, a membership report is sent. + */ +void +mld6_tmr(void) +{ + struct netif *netif; + + NETIF_FOREACH(netif) { + struct mld_group *group = netif_mld6_data(netif); + + while (group != NULL) { + if (group->timer > 0) { + group->timer--; + if (group->timer == 0) { + /* If the state is MLD6_GROUP_DELAYING_MEMBER then we send a report for this group */ + if (group->group_state == MLD6_GROUP_DELAYING_MEMBER) { + MLD6_STATS_INC(mld6.tx_report); + mld6_send(netif, group, ICMP6_TYPE_MLR); + group->group_state = MLD6_GROUP_IDLE_MEMBER; + } + } + } + group = group->next; + } + } +} + +/** + * Schedule a delayed membership report for a group + * + * @param group the mld_group for which "delaying" membership report + * should be sent + * @param maxresp_in the max resp delay provided in the query + */ +static void +mld6_delayed_report(struct mld_group *group, u16_t maxresp_in) +{ + /* Convert maxresp from milliseconds to tmr ticks */ + u16_t maxresp = maxresp_in / MLD6_TMR_INTERVAL; + if (maxresp == 0) { + maxresp = 1; + } + +#ifdef LWIP_RAND + /* Randomize maxresp. (if LWIP_RAND is supported) */ + maxresp = (u16_t)(LWIP_RAND() % maxresp); + if (maxresp == 0) { + maxresp = 1; + } +#endif /* LWIP_RAND */ + + /* Apply timer value if no report has been scheduled already. */ + if ((group->group_state == MLD6_GROUP_IDLE_MEMBER) || + ((group->group_state == MLD6_GROUP_DELAYING_MEMBER) && + ((group->timer == 0) || (maxresp < group->timer)))) { + group->timer = maxresp; + group->group_state = MLD6_GROUP_DELAYING_MEMBER; + } +} + +/** + * Send a MLD message (report or done). + * + * An IPv6 hop-by-hop options header with a router alert option + * is prepended. + * + * @param group the group to report or quit + * @param type ICMP6_TYPE_MLR (report) or ICMP6_TYPE_MLD (done) + */ +static void +mld6_send(struct netif *netif, struct mld_group *group, u8_t type) +{ + struct mld_header *mld_hdr; + struct pbuf *p; + const ip6_addr_t *src_addr; + + /* Allocate a packet. Size is MLD header + IPv6 Hop-by-hop options header. */ + p = pbuf_alloc(PBUF_IP, sizeof(struct mld_header) + MLD6_HBH_HLEN, PBUF_RAM); + if (p == NULL) { + MLD6_STATS_INC(mld6.memerr); + return; + } + + /* Move to make room for Hop-by-hop options header. */ + if (pbuf_remove_header(p, MLD6_HBH_HLEN)) { + pbuf_free(p); + MLD6_STATS_INC(mld6.lenerr); + return; + } + + /* Select our source address. */ + if (!ip6_addr_isvalid(netif_ip6_addr_state(netif, 0))) { + /* This is a special case, when we are performing duplicate address detection. + * We must join the multicast group, but we don't have a valid address yet. */ + src_addr = IP6_ADDR_ANY6; + } else { + /* Use link-local address as source address. */ + src_addr = netif_ip6_addr(netif, 0); + } + + /* MLD message header pointer. */ + mld_hdr = (struct mld_header *)p->payload; + + /* Set fields. */ + mld_hdr->type = type; + mld_hdr->code = 0; + mld_hdr->chksum = 0; + mld_hdr->max_resp_delay = 0; + mld_hdr->reserved = 0; + ip6_addr_copy_to_packed(mld_hdr->multicast_address, group->group_address); + +#if CHECKSUM_GEN_ICMP6 + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { + mld_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, + src_addr, &(group->group_address)); + } +#endif /* CHECKSUM_GEN_ICMP6 */ + + /* Add hop-by-hop headers options: router alert with MLD value. */ + ip6_options_add_hbh_ra(p, IP6_NEXTH_ICMP6, IP6_ROUTER_ALERT_VALUE_MLD); + + if (type == ICMP6_TYPE_MLR) { + /* Remember we were the last to report */ + group->last_reporter_flag = 1; + } + + /* Send the packet out. */ + MLD6_STATS_INC(mld6.xmit); + ip6_output_if(p, (ip6_addr_isany(src_addr)) ? NULL : src_addr, &(group->group_address), + MLD6_HL, 0, IP6_NEXTH_HOPBYHOP, netif); + pbuf_free(p); +} + +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/nd6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/nd6.c index 5deb3f14..db0c132e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/nd6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/ipv6/nd6.c @@ -1,2434 +1,2434 @@ -/** - * @file - * - * Neighbor discovery and stateless address autoconfiguration for IPv6. - * Aims to be compliant with RFC 4861 (Neighbor discovery) and RFC 4862 - * (Address autoconfiguration). - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#include "lwip/opt.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/nd6.h" -#include "lwip/priv/nd6_priv.h" -#include "lwip/prot/nd6.h" -#include "lwip/prot/icmp6.h" -#include "lwip/pbuf.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/inet_chksum.h" -#include "lwip/netif.h" -#include "lwip/icmp6.h" -#include "lwip/mld6.h" -#include "lwip/dhcp6.h" -#include "lwip/ip.h" -#include "lwip/stats.h" -#include "lwip/dns.h" - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -#if LWIP_IPV6_DUP_DETECT_ATTEMPTS > IP6_ADDR_TENTATIVE_COUNT_MASK -#error LWIP_IPV6_DUP_DETECT_ATTEMPTS > IP6_ADDR_TENTATIVE_COUNT_MASK -#endif - -/* Router tables. */ -struct nd6_neighbor_cache_entry neighbor_cache[LWIP_ND6_NUM_NEIGHBORS]; -struct nd6_destination_cache_entry destination_cache[LWIP_ND6_NUM_DESTINATIONS]; -struct nd6_prefix_list_entry prefix_list[LWIP_ND6_NUM_PREFIXES]; -struct nd6_router_list_entry default_router_list[LWIP_ND6_NUM_ROUTERS]; - -/* Default values, can be updated by a RA message. */ -u32_t reachable_time = LWIP_ND6_REACHABLE_TIME; -u32_t retrans_timer = LWIP_ND6_RETRANS_TIMER; /* @todo implement this value in timer */ - -/* Index for cache entries. */ -static u8_t nd6_cached_neighbor_index; -static netif_addr_idx_t nd6_cached_destination_index; - -/* Multicast address holder. */ -static ip6_addr_t multicast_address; - -static u8_t nd6_tmr_rs_reduction; - -/* Static buffer to parse RA packet options */ -union ra_options { - struct lladdr_option lladdr; - struct mtu_option mtu; - struct prefix_option prefix; -#if LWIP_ND6_RDNSS_MAX_DNS_SERVERS - struct rdnss_option rdnss; -#endif -}; -static union ra_options nd6_ra_buffer; - -/* Forward declarations. */ -static s8_t nd6_find_neighbor_cache_entry(const ip6_addr_t *ip6addr); -static s8_t nd6_new_neighbor_cache_entry(void); -static void nd6_free_neighbor_cache_entry(s8_t i); -static s16_t nd6_find_destination_cache_entry(const ip6_addr_t *ip6addr); -static s16_t nd6_new_destination_cache_entry(void); -static int nd6_is_prefix_in_netif(const ip6_addr_t *ip6addr, struct netif *netif); -static s8_t nd6_select_router(const ip6_addr_t *ip6addr, struct netif *netif); -static s8_t nd6_get_router(const ip6_addr_t *router_addr, struct netif *netif); -static s8_t nd6_new_router(const ip6_addr_t *router_addr, struct netif *netif); -static s8_t nd6_get_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif); -static s8_t nd6_new_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif); -static s8_t nd6_get_next_hop_entry(const ip6_addr_t *ip6addr, struct netif *netif); -static err_t nd6_queue_packet(s8_t neighbor_index, struct pbuf *q); - -#define ND6_SEND_FLAG_MULTICAST_DEST 0x01 -#define ND6_SEND_FLAG_ALLNODES_DEST 0x02 -#define ND6_SEND_FLAG_ANY_SRC 0x04 -static void nd6_send_ns(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags); -static void nd6_send_na(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags); -static void nd6_send_neighbor_cache_probe(struct nd6_neighbor_cache_entry *entry, u8_t flags); -#if LWIP_IPV6_SEND_ROUTER_SOLICIT -static err_t nd6_send_rs(struct netif *netif); -#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ - -#if LWIP_ND6_QUEUEING -static void nd6_free_q(struct nd6_q_entry *q); -#else /* LWIP_ND6_QUEUEING */ -#define nd6_free_q(q) pbuf_free(q) -#endif /* LWIP_ND6_QUEUEING */ -static void nd6_send_q(s8_t i); - - -/** - * A local address has been determined to be a duplicate. Take the appropriate - * action(s) on the address and the interface as a whole. - * - * @param netif the netif that owns the address - * @param addr_idx the index of the address detected to be a duplicate - */ -static void -nd6_duplicate_addr_detected(struct netif *netif, s8_t addr_idx) -{ - - /* Mark the address as duplicate, but leave its lifetimes alone. If this was - * a manually assigned address, it will remain in existence as duplicate, and - * as such be unusable for any practical purposes until manual intervention. - * If this was an autogenerated address, the address will follow normal - * expiration rules, and thus disappear once its valid lifetime expires. */ - netif_ip6_addr_set_state(netif, addr_idx, IP6_ADDR_DUPLICATED); - -#if LWIP_IPV6_AUTOCONFIG - /* If the affected address was the link-local address that we use to generate - * all other addresses, then we should not continue to use those derived - * addresses either, so mark them as duplicate as well. For autoconfig-only - * setups, this will make the interface effectively unusable, approaching the - * intention of RFC 4862 Sec. 5.4.5. @todo implement the full requirements */ - if (addr_idx == 0) { - s8_t i; - for (i = 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (!ip6_addr_isinvalid(netif_ip6_addr_state(netif, i)) && - !netif_ip6_addr_isstatic(netif, i)) { - netif_ip6_addr_set_state(netif, i, IP6_ADDR_DUPLICATED); - } - } - } -#endif /* LWIP_IPV6_AUTOCONFIG */ -} - -#if LWIP_IPV6_AUTOCONFIG -/** - * We received a router advertisement that contains a prefix with the - * autoconfiguration flag set. Add or update an associated autogenerated - * address. - * - * @param netif the netif on which the router advertisement arrived - * @param prefix_opt a pointer to the prefix option data - * @param prefix_addr an aligned copy of the prefix address - */ -static void -nd6_process_autoconfig_prefix(struct netif *netif, - struct prefix_option *prefix_opt, const ip6_addr_t *prefix_addr) -{ - ip6_addr_t ip6addr; - u32_t valid_life, pref_life; - u8_t addr_state; - s8_t i, free_idx; - - /* The caller already checks RFC 4862 Sec. 5.5.3 points (a) and (b). We do - * the rest, starting with checks for (c) and (d) here. */ - valid_life = lwip_htonl(prefix_opt->valid_lifetime); - pref_life = lwip_htonl(prefix_opt->preferred_lifetime); - if (pref_life > valid_life || prefix_opt->prefix_length != 64) { - return; /* silently ignore this prefix for autoconfiguration purposes */ - } - - /* If an autogenerated address already exists for this prefix, update its - * lifetimes. An address is considered autogenerated if 1) it is not static - * (i.e., manually assigned), and 2) there is an advertised autoconfiguration - * prefix for it (the one we are processing here). This does not necessarily - * exclude the possibility that the address was actually assigned by, say, - * DHCPv6. If that distinction becomes important in the future, more state - * must be kept. As explained elsewhere we also update lifetimes of tentative - * and duplicate addresses. Skip address slot 0 (the link-local address). */ - for (i = 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - addr_state = netif_ip6_addr_state(netif, i); - if (!ip6_addr_isinvalid(addr_state) && !netif_ip6_addr_isstatic(netif, i) && - ip6_addr_netcmp(prefix_addr, netif_ip6_addr(netif, i))) { - /* Update the valid lifetime, as per RFC 4862 Sec. 5.5.3 point (e). - * The valid lifetime will never drop to zero as a result of this. */ - u32_t remaining_life = netif_ip6_addr_valid_life(netif, i); - if (valid_life > ND6_2HRS || valid_life > remaining_life) { - netif_ip6_addr_set_valid_life(netif, i, valid_life); - } else if (remaining_life > ND6_2HRS) { - netif_ip6_addr_set_valid_life(netif, i, ND6_2HRS); - } - LWIP_ASSERT("bad valid lifetime", !netif_ip6_addr_isstatic(netif, i)); - /* Update the preferred lifetime. No bounds checks are needed here. In - * rare cases the advertisement may un-deprecate the address, though. - * Deprecation is left to the timer code where it is handled anyway. */ - if (pref_life > 0 && addr_state == IP6_ADDR_DEPRECATED) { - netif_ip6_addr_set_state(netif, i, IP6_ADDR_PREFERRED); - } - netif_ip6_addr_set_pref_life(netif, i, pref_life); - return; /* there should be at most one matching address */ - } - } - - /* No autogenerated address exists for this prefix yet. See if we can add a - * new one. However, if IPv6 autoconfiguration is administratively disabled, - * do not generate new addresses, but do keep updating lifetimes for existing - * addresses. Also, when adding new addresses, we must protect explicitly - * against a valid lifetime of zero, because again, we use that as a special - * value. The generated address would otherwise expire immediately anyway. - * Finally, the original link-local address must be usable at all. We start - * creating addresses even if the link-local address is still in tentative - * state though, and deal with the fallout of that upon DAD collision. */ - addr_state = netif_ip6_addr_state(netif, 0); - if (!netif->ip6_autoconfig_enabled || valid_life == IP6_ADDR_LIFE_STATIC || - ip6_addr_isinvalid(addr_state) || ip6_addr_isduplicated(addr_state)) { - return; - } - - /* Construct the new address that we intend to use, and then see if that - * address really does not exist. It might have been added manually, after - * all. As a side effect, find a free slot. Note that we cannot use - * netif_add_ip6_address() here, as it would return ERR_OK if the address - * already did exist, resulting in that address being given lifetimes. */ - IP6_ADDR(&ip6addr, prefix_addr->addr[0], prefix_addr->addr[1], - netif_ip6_addr(netif, 0)->addr[2], netif_ip6_addr(netif, 0)->addr[3]); - ip6_addr_assign_zone(&ip6addr, IP6_UNICAST, netif); - - free_idx = 0; - for (i = 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (!ip6_addr_isinvalid(netif_ip6_addr_state(netif, i))) { - if (ip6_addr_cmp(&ip6addr, netif_ip6_addr(netif, i))) { - return; /* formed address already exists */ - } - } else if (free_idx == 0) { - free_idx = i; - } - } - if (free_idx == 0) { - return; /* no address slots available, try again on next advertisement */ - } - - /* Assign the new address to the interface. */ - ip_addr_copy_from_ip6(netif->ip6_addr[free_idx], ip6addr); - netif_ip6_addr_set_valid_life(netif, free_idx, valid_life); - netif_ip6_addr_set_pref_life(netif, free_idx, pref_life); - netif_ip6_addr_set_state(netif, free_idx, IP6_ADDR_TENTATIVE); -} -#endif /* LWIP_IPV6_AUTOCONFIG */ - -/** - * Process an incoming neighbor discovery message - * - * @param p the nd packet, p->payload pointing to the icmpv6 header - * @param inp the netif on which this packet was received - */ -void -nd6_input(struct pbuf *p, struct netif *inp) -{ - u8_t msg_type; - s8_t i; - s16_t dest_idx; - - ND6_STATS_INC(nd6.recv); - - msg_type = *((u8_t *)p->payload); - switch (msg_type) { - case ICMP6_TYPE_NA: /* Neighbor Advertisement. */ - { - struct na_header *na_hdr; - struct lladdr_option *lladdr_opt; - ip6_addr_t target_address; - - /* Check that na header fits in packet. */ - if (p->len < (sizeof(struct na_header))) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - na_hdr = (struct na_header *)p->payload; - - /* Create an aligned, zoned copy of the target address. */ - ip6_addr_copy_from_packed(target_address, na_hdr->target_address); - ip6_addr_assign_zone(&target_address, IP6_UNICAST, inp); - - /* Check a subset of the other RFC 4861 Sec. 7.1.2 requirements. */ - if (IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || na_hdr->code != 0 || - ip6_addr_ismulticast(&target_address)) { - pbuf_free(p); - ND6_STATS_INC(nd6.proterr); - ND6_STATS_INC(nd6.drop); - return; - } - - /* @todo RFC MUST: if IP destination is multicast, Solicited flag is zero */ - /* @todo RFC MUST: all included options have a length greater than zero */ - - /* Unsolicited NA?*/ - if (ip6_addr_ismulticast(ip6_current_dest_addr())) { - /* This is an unsolicited NA. - * link-layer changed? - * part of DAD mechanism? */ - -#if LWIP_IPV6_DUP_DETECT_ATTEMPTS - /* If the target address matches this netif, it is a DAD response. */ - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (!ip6_addr_isinvalid(netif_ip6_addr_state(inp, i)) && - !ip6_addr_isduplicated(netif_ip6_addr_state(inp, i)) && - ip6_addr_cmp(&target_address, netif_ip6_addr(inp, i))) { - /* We are using a duplicate address. */ - nd6_duplicate_addr_detected(inp, i); - - pbuf_free(p); - return; - } - } -#endif /* LWIP_IPV6_DUP_DETECT_ATTEMPTS */ - - /* Check that link-layer address option also fits in packet. */ - if (p->len < (sizeof(struct na_header) + 2)) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct na_header)); - - if (p->len < (sizeof(struct na_header) + (lladdr_opt->length << 3))) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - /* This is an unsolicited NA, most likely there was a LLADDR change. */ - i = nd6_find_neighbor_cache_entry(&target_address); - if (i >= 0) { - if (na_hdr->flags & ND6_FLAG_OVERRIDE) { - MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); - } - } - } else { - /* This is a solicited NA. - * neighbor address resolution response? - * neighbor unreachability detection response? */ - - /* Find the cache entry corresponding to this na. */ - i = nd6_find_neighbor_cache_entry(&target_address); - if (i < 0) { - /* We no longer care about this target address. drop it. */ - pbuf_free(p); - return; - } - - /* Update cache entry. */ - if ((na_hdr->flags & ND6_FLAG_OVERRIDE) || - (neighbor_cache[i].state == ND6_INCOMPLETE)) { - /* Check that link-layer address option also fits in packet. */ - if (p->len < (sizeof(struct na_header) + 2)) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct na_header)); - - if (p->len < (sizeof(struct na_header) + (lladdr_opt->length << 3))) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); - } - - neighbor_cache[i].netif = inp; - neighbor_cache[i].state = ND6_REACHABLE; - neighbor_cache[i].counter.reachable_time = reachable_time; - - /* Send queued packets, if any. */ - if (neighbor_cache[i].q != NULL) { - nd6_send_q(i); - } - } - - break; /* ICMP6_TYPE_NA */ - } - case ICMP6_TYPE_NS: /* Neighbor solicitation. */ - { - struct ns_header *ns_hdr; - struct lladdr_option *lladdr_opt; - ip6_addr_t target_address; - u8_t accepted; - - /* Check that ns header fits in packet. */ - if (p->len < sizeof(struct ns_header)) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - ns_hdr = (struct ns_header *)p->payload; - - /* Create an aligned, zoned copy of the target address. */ - ip6_addr_copy_from_packed(target_address, ns_hdr->target_address); - ip6_addr_assign_zone(&target_address, IP6_UNICAST, inp); - - /* Check a subset of the other RFC 4861 Sec. 7.1.1 requirements. */ - if (IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || ns_hdr->code != 0 || - ip6_addr_ismulticast(&target_address)) { - pbuf_free(p); - ND6_STATS_INC(nd6.proterr); - ND6_STATS_INC(nd6.drop); - return; - } - - /* @todo RFC MUST: all included options have a length greater than zero */ - /* @todo RFC MUST: if IP source is 'any', destination is solicited-node multicast address */ - /* @todo RFC MUST: if IP source is 'any', there is no source LL address option */ - - /* Check if there is a link-layer address provided. Only point to it if in this buffer. */ - if (p->len >= (sizeof(struct ns_header) + 2)) { - lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct ns_header)); - if (p->len < (sizeof(struct ns_header) + (lladdr_opt->length << 3))) { - lladdr_opt = NULL; - } - } else { - lladdr_opt = NULL; - } - - /* Check if the target address is configured on the receiving netif. */ - accepted = 0; - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; ++i) { - if ((ip6_addr_isvalid(netif_ip6_addr_state(inp, i)) || - (ip6_addr_istentative(netif_ip6_addr_state(inp, i)) && - ip6_addr_isany(ip6_current_src_addr()))) && - ip6_addr_cmp(&target_address, netif_ip6_addr(inp, i))) { - accepted = 1; - break; - } - } - - /* NS not for us? */ - if (!accepted) { - pbuf_free(p); - return; - } - - /* Check for ANY address in src (DAD algorithm). */ - if (ip6_addr_isany(ip6_current_src_addr())) { - /* Sender is validating this address. */ - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; ++i) { - if (!ip6_addr_isinvalid(netif_ip6_addr_state(inp, i)) && - ip6_addr_cmp(&target_address, netif_ip6_addr(inp, i))) { - /* Send a NA back so that the sender does not use this address. */ - nd6_send_na(inp, netif_ip6_addr(inp, i), ND6_FLAG_OVERRIDE | ND6_SEND_FLAG_ALLNODES_DEST); - if (ip6_addr_istentative(netif_ip6_addr_state(inp, i))) { - /* We shouldn't use this address either. */ - nd6_duplicate_addr_detected(inp, i); - } - } - } - } else { - /* Sender is trying to resolve our address. */ - /* Verify that they included their own link-layer address. */ - if (lladdr_opt == NULL) { - /* Not a valid message. */ - pbuf_free(p); - ND6_STATS_INC(nd6.proterr); - ND6_STATS_INC(nd6.drop); - return; - } - - i = nd6_find_neighbor_cache_entry(ip6_current_src_addr()); - if (i>= 0) { - /* We already have a record for the solicitor. */ - if (neighbor_cache[i].state == ND6_INCOMPLETE) { - neighbor_cache[i].netif = inp; - MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); - - /* Delay probe in case we get confirmation of reachability from upper layer (TCP). */ - neighbor_cache[i].state = ND6_DELAY; - neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; - } - } else { - /* Add their IPv6 address and link-layer address to neighbor cache. - * We will need it at least to send a unicast NA message, but most - * likely we will also be communicating with this node soon. */ - i = nd6_new_neighbor_cache_entry(); - if (i < 0) { - /* We couldn't assign a cache entry for this neighbor. - * we won't be able to reply. drop it. */ - pbuf_free(p); - ND6_STATS_INC(nd6.memerr); - return; - } - neighbor_cache[i].netif = inp; - MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); - ip6_addr_set(&(neighbor_cache[i].next_hop_address), ip6_current_src_addr()); - - /* Receiving a message does not prove reachability: only in one direction. - * Delay probe in case we get confirmation of reachability from upper layer (TCP). */ - neighbor_cache[i].state = ND6_DELAY; - neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; - } - - /* Send back a NA for us. Allocate the reply pbuf. */ - nd6_send_na(inp, &target_address, ND6_FLAG_SOLICITED | ND6_FLAG_OVERRIDE); - } - - break; /* ICMP6_TYPE_NS */ - } - case ICMP6_TYPE_RA: /* Router Advertisement. */ - { - struct ra_header *ra_hdr; - u8_t *buffer; /* Used to copy options. */ - u16_t offset; -#if LWIP_ND6_RDNSS_MAX_DNS_SERVERS - /* There can be multiple RDNSS options per RA */ - u8_t rdnss_server_idx = 0; -#endif /* LWIP_ND6_RDNSS_MAX_DNS_SERVERS */ - - /* Check that RA header fits in packet. */ - if (p->len < sizeof(struct ra_header)) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - ra_hdr = (struct ra_header *)p->payload; - - /* Check a subset of the other RFC 4861 Sec. 6.1.2 requirements. */ - if (!ip6_addr_islinklocal(ip6_current_src_addr()) || - IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || ra_hdr->code != 0) { - pbuf_free(p); - ND6_STATS_INC(nd6.proterr); - ND6_STATS_INC(nd6.drop); - return; - } - - /* @todo RFC MUST: all included options have a length greater than zero */ - - /* If we are sending RS messages, stop. */ -#if LWIP_IPV6_SEND_ROUTER_SOLICIT - /* ensure at least one solicitation is sent (see RFC 4861, ch. 6.3.7) */ - if ((inp->rs_count < LWIP_ND6_MAX_MULTICAST_SOLICIT) || - (nd6_send_rs(inp) == ERR_OK)) { - inp->rs_count = 0; - } else { - inp->rs_count = 1; - } -#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ - - /* Get the matching default router entry. */ - i = nd6_get_router(ip6_current_src_addr(), inp); - if (i < 0) { - /* Create a new router entry. */ - i = nd6_new_router(ip6_current_src_addr(), inp); - } - - if (i < 0) { - /* Could not create a new router entry. */ - pbuf_free(p); - ND6_STATS_INC(nd6.memerr); - return; - } - - /* Re-set invalidation timer. */ - default_router_list[i].invalidation_timer = lwip_htons(ra_hdr->router_lifetime); - - /* Re-set default timer values. */ -#if LWIP_ND6_ALLOW_RA_UPDATES - if (ra_hdr->retrans_timer > 0) { - retrans_timer = lwip_htonl(ra_hdr->retrans_timer); - } - if (ra_hdr->reachable_time > 0) { - reachable_time = lwip_htonl(ra_hdr->reachable_time); - } -#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ - - /* @todo set default hop limit... */ - /* ra_hdr->current_hop_limit;*/ - - /* Update flags in local entry (incl. preference). */ - default_router_list[i].flags = ra_hdr->flags; - -#if LWIP_IPV6_DHCP6 - /* Trigger DHCPv6 if enabled */ - dhcp6_nd6_ra_trigger(inp, ra_hdr->flags & ND6_RA_FLAG_MANAGED_ADDR_CONFIG, - ra_hdr->flags & ND6_RA_FLAG_OTHER_CONFIG); -#endif - - /* Offset to options. */ - offset = sizeof(struct ra_header); - - /* Process each option. */ - while ((p->tot_len - offset) >= 2) { - u8_t option_type; - u16_t option_len; - int option_len8 = pbuf_try_get_at(p, offset + 1); - if (option_len8 <= 0) { - /* read beyond end or zero length */ - goto lenerr_drop_free_return; - } - option_len = ((u8_t)option_len8) << 3; - if (option_len > p->tot_len - offset) { - /* short packet (option does not fit in) */ - goto lenerr_drop_free_return; - } - if (p->len == p->tot_len) { - /* no need to copy from contiguous pbuf */ - buffer = &((u8_t*)p->payload)[offset]; - } else { - /* check if this option fits into our buffer */ - if (option_len > sizeof(nd6_ra_buffer)) { - option_type = pbuf_get_at(p, offset); - /* invalid option length */ - if (option_type != ND6_OPTION_TYPE_RDNSS) { - goto lenerr_drop_free_return; - } - /* we allow RDNSS option to be longer - we'll just drop some servers */ - option_len = sizeof(nd6_ra_buffer); - } - buffer = (u8_t*)&nd6_ra_buffer; - option_len = pbuf_copy_partial(p, &nd6_ra_buffer, option_len, offset); - } - option_type = buffer[0]; - switch (option_type) { - case ND6_OPTION_TYPE_SOURCE_LLADDR: - { - struct lladdr_option *lladdr_opt; - if (option_len < sizeof(struct lladdr_option)) { - goto lenerr_drop_free_return; - } - lladdr_opt = (struct lladdr_option *)buffer; - if ((default_router_list[i].neighbor_entry != NULL) && - (default_router_list[i].neighbor_entry->state == ND6_INCOMPLETE)) { - SMEMCPY(default_router_list[i].neighbor_entry->lladdr, lladdr_opt->addr, inp->hwaddr_len); - default_router_list[i].neighbor_entry->state = ND6_REACHABLE; - default_router_list[i].neighbor_entry->counter.reachable_time = reachable_time; - } - break; - } - case ND6_OPTION_TYPE_MTU: - { - struct mtu_option *mtu_opt; - u32_t mtu32; - if (option_len < sizeof(struct mtu_option)) { - goto lenerr_drop_free_return; - } - mtu_opt = (struct mtu_option *)buffer; - mtu32 = lwip_htonl(mtu_opt->mtu); - if ((mtu32 >= 1280) && (mtu32 <= 0xffff)) { -#if LWIP_ND6_ALLOW_RA_UPDATES - if (inp->mtu) { - /* don't set the mtu for IPv6 higher than the netif driver supports */ - inp->mtu6 = LWIP_MIN(inp->mtu, (u16_t)mtu32); - } else { - inp->mtu6 = (u16_t)mtu32; - } -#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ - } - break; - } - case ND6_OPTION_TYPE_PREFIX_INFO: - { - struct prefix_option *prefix_opt; - ip6_addr_t prefix_addr; - if (option_len < sizeof(struct prefix_option)) { - goto lenerr_drop_free_return; - } - - prefix_opt = (struct prefix_option *)buffer; - - /* Get a memory-aligned copy of the prefix. */ - ip6_addr_copy_from_packed(prefix_addr, prefix_opt->prefix); - ip6_addr_assign_zone(&prefix_addr, IP6_UNICAST, inp); - - if (!ip6_addr_islinklocal(&prefix_addr)) { - if ((prefix_opt->flags & ND6_PREFIX_FLAG_ON_LINK) && - (prefix_opt->prefix_length == 64)) { - /* Add to on-link prefix list. */ - u32_t valid_life; - s8_t prefix; - - valid_life = lwip_htonl(prefix_opt->valid_lifetime); - - /* find cache entry for this prefix. */ - prefix = nd6_get_onlink_prefix(&prefix_addr, inp); - if (prefix < 0 && valid_life > 0) { - /* Create a new cache entry. */ - prefix = nd6_new_onlink_prefix(&prefix_addr, inp); - } - if (prefix >= 0) { - prefix_list[prefix].invalidation_timer = valid_life; - } - } -#if LWIP_IPV6_AUTOCONFIG - if (prefix_opt->flags & ND6_PREFIX_FLAG_AUTONOMOUS) { - /* Perform processing for autoconfiguration. */ - nd6_process_autoconfig_prefix(inp, prefix_opt, &prefix_addr); - } -#endif /* LWIP_IPV6_AUTOCONFIG */ - } - - break; - } - case ND6_OPTION_TYPE_ROUTE_INFO: - /* @todo implement preferred routes. - struct route_option * route_opt; - route_opt = (struct route_option *)buffer;*/ - - break; -#if LWIP_ND6_RDNSS_MAX_DNS_SERVERS - case ND6_OPTION_TYPE_RDNSS: - { - u8_t num, n; - u16_t copy_offset = offset + SIZEOF_RDNSS_OPTION_BASE; - struct rdnss_option * rdnss_opt; - if (option_len < SIZEOF_RDNSS_OPTION_BASE) { - goto lenerr_drop_free_return; - } - - rdnss_opt = (struct rdnss_option *)buffer; - num = (rdnss_opt->length - 1) / 2; - for (n = 0; (rdnss_server_idx < DNS_MAX_SERVERS) && (n < num); n++) { - ip_addr_t rdnss_address; - - /* Copy directly from pbuf to get an aligned, zoned copy of the prefix. */ - if (pbuf_copy_partial(p, &rdnss_address, sizeof(ip6_addr_p_t), copy_offset) == sizeof(ip6_addr_p_t)) { - IP_SET_TYPE_VAL(rdnss_address, IPADDR_TYPE_V6); - ip6_addr_assign_zone(ip_2_ip6(&rdnss_address), IP6_UNKNOWN, inp); - - if (htonl(rdnss_opt->lifetime) > 0) { - /* TODO implement Lifetime > 0 */ - dns_setserver(rdnss_server_idx++, &rdnss_address); - } else { - /* TODO implement DNS removal in dns.c */ - u8_t s; - for (s = 0; s < DNS_MAX_SERVERS; s++) { - const ip_addr_t *addr = dns_getserver(s); - if(ip_addr_cmp(addr, &rdnss_address)) { - dns_setserver(s, NULL); - } - } - } - } - } - break; - } -#endif /* LWIP_ND6_RDNSS_MAX_DNS_SERVERS */ - default: - /* Unrecognized option, abort. */ - ND6_STATS_INC(nd6.proterr); - break; - } - /* option length is checked earlier to be non-zero to make sure loop ends */ - offset += 8 * (u8_t)option_len8; - } - - break; /* ICMP6_TYPE_RA */ - } - case ICMP6_TYPE_RD: /* Redirect */ - { - struct redirect_header *redir_hdr; - struct lladdr_option *lladdr_opt; - ip6_addr_t destination_address, target_address; - - /* Check that Redir header fits in packet. */ - if (p->len < sizeof(struct redirect_header)) { - /* @todo debug message */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - redir_hdr = (struct redirect_header *)p->payload; - - /* Create an aligned, zoned copy of the destination address. */ - ip6_addr_copy_from_packed(destination_address, redir_hdr->destination_address); - ip6_addr_assign_zone(&destination_address, IP6_UNICAST, inp); - - /* Check a subset of the other RFC 4861 Sec. 8.1 requirements. */ - if (!ip6_addr_islinklocal(ip6_current_src_addr()) || - IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || - redir_hdr->code != 0 || ip6_addr_ismulticast(&destination_address)) { - pbuf_free(p); - ND6_STATS_INC(nd6.proterr); - ND6_STATS_INC(nd6.drop); - return; - } - - /* @todo RFC MUST: IP source address equals first-hop router for destination_address */ - /* @todo RFC MUST: ICMP target address is either link-local address or same as destination_address */ - /* @todo RFC MUST: all included options have a length greater than zero */ - - if (p->len >= (sizeof(struct redirect_header) + 2)) { - lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct redirect_header)); - if (p->len < (sizeof(struct redirect_header) + (lladdr_opt->length << 3))) { - lladdr_opt = NULL; - } - } else { - lladdr_opt = NULL; - } - - /* Find dest address in cache */ - dest_idx = nd6_find_destination_cache_entry(&destination_address); - if (dest_idx < 0) { - /* Destination not in cache, drop packet. */ - pbuf_free(p); - return; - } - - /* Create an aligned, zoned copy of the target address. */ - ip6_addr_copy_from_packed(target_address, redir_hdr->target_address); - ip6_addr_assign_zone(&target_address, IP6_UNICAST, inp); - - /* Set the new target address. */ - ip6_addr_copy(destination_cache[dest_idx].next_hop_addr, target_address); - - /* If Link-layer address of other router is given, try to add to neighbor cache. */ - if (lladdr_opt != NULL) { - if (lladdr_opt->type == ND6_OPTION_TYPE_TARGET_LLADDR) { - i = nd6_find_neighbor_cache_entry(&target_address); - if (i < 0) { - i = nd6_new_neighbor_cache_entry(); - if (i >= 0) { - neighbor_cache[i].netif = inp; - MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); - ip6_addr_copy(neighbor_cache[i].next_hop_address, target_address); - - /* Receiving a message does not prove reachability: only in one direction. - * Delay probe in case we get confirmation of reachability from upper layer (TCP). */ - neighbor_cache[i].state = ND6_DELAY; - neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; - } - } - if (i >= 0) { - if (neighbor_cache[i].state == ND6_INCOMPLETE) { - MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); - /* Receiving a message does not prove reachability: only in one direction. - * Delay probe in case we get confirmation of reachability from upper layer (TCP). */ - neighbor_cache[i].state = ND6_DELAY; - neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; - } - } - } - } - break; /* ICMP6_TYPE_RD */ - } - case ICMP6_TYPE_PTB: /* Packet too big */ - { - struct icmp6_hdr *icmp6hdr; /* Packet too big message */ - struct ip6_hdr *ip6hdr; /* IPv6 header of the packet which caused the error */ - u32_t pmtu; - ip6_addr_t destination_address; - - /* Check that ICMPv6 header + IPv6 header fit in payload */ - if (p->len < (sizeof(struct icmp6_hdr) + IP6_HLEN)) { - /* drop short packets */ - pbuf_free(p); - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - return; - } - - icmp6hdr = (struct icmp6_hdr *)p->payload; - ip6hdr = (struct ip6_hdr *)((u8_t*)p->payload + sizeof(struct icmp6_hdr)); - - /* Create an aligned, zoned copy of the destination address. */ - ip6_addr_copy_from_packed(destination_address, ip6hdr->dest); - ip6_addr_assign_zone(&destination_address, IP6_UNKNOWN, inp); - - /* Look for entry in destination cache. */ - dest_idx = nd6_find_destination_cache_entry(&destination_address); - if (dest_idx < 0) { - /* Destination not in cache, drop packet. */ - pbuf_free(p); - return; - } - - /* Change the Path MTU. */ - pmtu = lwip_htonl(icmp6hdr->data); - destination_cache[dest_idx].pmtu = (u16_t)LWIP_MIN(pmtu, 0xFFFF); - - break; /* ICMP6_TYPE_PTB */ - } - - default: - ND6_STATS_INC(nd6.proterr); - ND6_STATS_INC(nd6.drop); - break; /* default */ - } - - pbuf_free(p); - return; -lenerr_drop_free_return: - ND6_STATS_INC(nd6.lenerr); - ND6_STATS_INC(nd6.drop); - pbuf_free(p); -} - - -/** - * Periodic timer for Neighbor discovery functions: - * - * - Update neighbor reachability states - * - Update destination cache entries age - * - Update invalidation timers of default routers and on-link prefixes - * - Update lifetimes of our addresses - * - Perform duplicate address detection (DAD) for our addresses - * - Send router solicitations - */ -void -nd6_tmr(void) -{ - s8_t i; - struct netif *netif; - - /* Process neighbor entries. */ - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - switch (neighbor_cache[i].state) { - case ND6_INCOMPLETE: - if ((neighbor_cache[i].counter.probes_sent >= LWIP_ND6_MAX_MULTICAST_SOLICIT) && - (!neighbor_cache[i].isrouter)) { - /* Retries exceeded. */ - nd6_free_neighbor_cache_entry(i); - } else { - /* Send a NS for this entry. */ - neighbor_cache[i].counter.probes_sent++; - nd6_send_neighbor_cache_probe(&neighbor_cache[i], ND6_SEND_FLAG_MULTICAST_DEST); - } - break; - case ND6_REACHABLE: - /* Send queued packets, if any are left. Should have been sent already. */ - if (neighbor_cache[i].q != NULL) { - nd6_send_q(i); - } - if (neighbor_cache[i].counter.reachable_time <= ND6_TMR_INTERVAL) { - /* Change to stale state. */ - neighbor_cache[i].state = ND6_STALE; - neighbor_cache[i].counter.stale_time = 0; - } else { - neighbor_cache[i].counter.reachable_time -= ND6_TMR_INTERVAL; - } - break; - case ND6_STALE: - neighbor_cache[i].counter.stale_time++; - break; - case ND6_DELAY: - if (neighbor_cache[i].counter.delay_time <= 1) { - /* Change to PROBE state. */ - neighbor_cache[i].state = ND6_PROBE; - neighbor_cache[i].counter.probes_sent = 0; - } else { - neighbor_cache[i].counter.delay_time--; - } - break; - case ND6_PROBE: - if ((neighbor_cache[i].counter.probes_sent >= LWIP_ND6_MAX_MULTICAST_SOLICIT) && - (!neighbor_cache[i].isrouter)) { - /* Retries exceeded. */ - nd6_free_neighbor_cache_entry(i); - } else { - /* Send a NS for this entry. */ - neighbor_cache[i].counter.probes_sent++; - nd6_send_neighbor_cache_probe(&neighbor_cache[i], 0); - } - break; - case ND6_NO_ENTRY: - default: - /* Do nothing. */ - break; - } - } - - /* Process destination entries. */ - for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { - destination_cache[i].age++; - } - - /* Process router entries. */ - for (i = 0; i < LWIP_ND6_NUM_ROUTERS; i++) { - if (default_router_list[i].neighbor_entry != NULL) { - /* Active entry. */ - if (default_router_list[i].invalidation_timer <= ND6_TMR_INTERVAL / 1000) { - /* No more than 1 second remaining. Clear this entry. Also clear any of - * its destination cache entries, as per RFC 4861 Sec. 5.3 and 6.3.5. */ - s8_t j; - for (j = 0; j < LWIP_ND6_NUM_DESTINATIONS; j++) { - if (ip6_addr_cmp(&destination_cache[j].next_hop_addr, - &default_router_list[i].neighbor_entry->next_hop_address)) { - ip6_addr_set_any(&destination_cache[j].destination_addr); - } - } - default_router_list[i].neighbor_entry->isrouter = 0; - default_router_list[i].neighbor_entry = NULL; - default_router_list[i].invalidation_timer = 0; - default_router_list[i].flags = 0; - } else { - default_router_list[i].invalidation_timer -= ND6_TMR_INTERVAL / 1000; - } - } - } - - /* Process prefix entries. */ - for (i = 0; i < LWIP_ND6_NUM_PREFIXES; i++) { - if (prefix_list[i].netif != NULL) { - if (prefix_list[i].invalidation_timer <= ND6_TMR_INTERVAL / 1000) { - /* Entry timed out, remove it */ - prefix_list[i].invalidation_timer = 0; - prefix_list[i].netif = NULL; - } else { - prefix_list[i].invalidation_timer -= ND6_TMR_INTERVAL / 1000; - } - } - } - - /* Process our own addresses, updating address lifetimes and/or DAD state. */ - NETIF_FOREACH(netif) { - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; ++i) { - u8_t addr_state; -#if LWIP_IPV6_ADDRESS_LIFETIMES - /* Step 1: update address lifetimes (valid and preferred). */ - addr_state = netif_ip6_addr_state(netif, i); - /* RFC 4862 is not entirely clear as to whether address lifetimes affect - * tentative addresses, and is even less clear as to what should happen - * with duplicate addresses. We choose to track and update lifetimes for - * both those types, although for different reasons: - * - for tentative addresses, the line of thought of Sec. 5.7 combined - * with the potentially long period that an address may be in tentative - * state (due to the interface being down) suggests that lifetimes - * should be independent of external factors which would include DAD; - * - for duplicate addresses, retiring them early could result in a new - * but unwanted attempt at marking them as valid, while retiring them - * late/never could clog up address slots on the netif. - * As a result, we may end up expiring addresses of either type here. - */ - if (!ip6_addr_isinvalid(addr_state) && - !netif_ip6_addr_isstatic(netif, i)) { - u32_t life = netif_ip6_addr_valid_life(netif, i); - if (life <= ND6_TMR_INTERVAL / 1000) { - /* The address has expired. */ - netif_ip6_addr_set_valid_life(netif, i, 0); - netif_ip6_addr_set_pref_life(netif, i, 0); - netif_ip6_addr_set_state(netif, i, IP6_ADDR_INVALID); - } else { - if (!ip6_addr_life_isinfinite(life)) { - life -= ND6_TMR_INTERVAL / 1000; - LWIP_ASSERT("bad valid lifetime", life != IP6_ADDR_LIFE_STATIC); - netif_ip6_addr_set_valid_life(netif, i, life); - } - /* The address is still here. Update the preferred lifetime too. */ - life = netif_ip6_addr_pref_life(netif, i); - if (life <= ND6_TMR_INTERVAL / 1000) { - /* This case must also trigger if 'life' was already zero, so as to - * deal correctly with advertised preferred-lifetime reductions. */ - netif_ip6_addr_set_pref_life(netif, i, 0); - if (addr_state == IP6_ADDR_PREFERRED) - netif_ip6_addr_set_state(netif, i, IP6_ADDR_DEPRECATED); - } else if (!ip6_addr_life_isinfinite(life)) { - life -= ND6_TMR_INTERVAL / 1000; - netif_ip6_addr_set_pref_life(netif, i, life); - } - } - } - /* The address state may now have changed, so reobtain it next. */ -#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ - /* Step 2: update DAD state. */ - addr_state = netif_ip6_addr_state(netif, i); - if (ip6_addr_istentative(addr_state)) { - if ((addr_state & IP6_ADDR_TENTATIVE_COUNT_MASK) >= LWIP_IPV6_DUP_DETECT_ATTEMPTS) { - /* No NA received in response. Mark address as valid. For dynamic - * addresses with an expired preferred lifetime, the state is set to - * deprecated right away. That should almost never happen, though. */ - addr_state = IP6_ADDR_PREFERRED; -#if LWIP_IPV6_ADDRESS_LIFETIMES - if (!netif_ip6_addr_isstatic(netif, i) && - netif_ip6_addr_pref_life(netif, i) == 0) { - addr_state = IP6_ADDR_DEPRECATED; - } -#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ - netif_ip6_addr_set_state(netif, i, addr_state); - } else if (netif_is_up(netif) && netif_is_link_up(netif)) { - /* tentative: set next state by increasing by one */ - netif_ip6_addr_set_state(netif, i, addr_state + 1); - /* Send a NS for this address. Use the unspecified address as source - * address in all cases (RFC 4862 Sec. 5.4.2), not in the least - * because as it is, we only consider multicast replies for DAD. */ - nd6_send_ns(netif, netif_ip6_addr(netif, i), - ND6_SEND_FLAG_MULTICAST_DEST | ND6_SEND_FLAG_ANY_SRC); - } - } - } - } - -#if LWIP_IPV6_SEND_ROUTER_SOLICIT - /* Send router solicitation messages, if necessary. */ - if (!nd6_tmr_rs_reduction) { - nd6_tmr_rs_reduction = (ND6_RTR_SOLICITATION_INTERVAL / ND6_TMR_INTERVAL) - 1; - NETIF_FOREACH(netif) { - if ((netif->rs_count > 0) && netif_is_up(netif) && - netif_is_link_up(netif) && - !ip6_addr_isinvalid(netif_ip6_addr_state(netif, 0)) && - !ip6_addr_isduplicated(netif_ip6_addr_state(netif, 0))) { - if (nd6_send_rs(netif) == ERR_OK) { - netif->rs_count--; - } - } - } - } else { - nd6_tmr_rs_reduction--; - } -#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ - -} - -/** Send a neighbor solicitation message for a specific neighbor cache entry - * - * @param entry the neightbor cache entry for wich to send the message - * @param flags one of ND6_SEND_FLAG_* - */ -static void -nd6_send_neighbor_cache_probe(struct nd6_neighbor_cache_entry *entry, u8_t flags) -{ - nd6_send_ns(entry->netif, &entry->next_hop_address, flags); -} - -/** - * Send a neighbor solicitation message - * - * @param netif the netif on which to send the message - * @param target_addr the IPv6 target address for the ND message - * @param flags one of ND6_SEND_FLAG_* - */ -static void -nd6_send_ns(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags) -{ - struct ns_header *ns_hdr; - struct pbuf *p; - const ip6_addr_t *src_addr; - u16_t lladdr_opt_len; - - LWIP_ASSERT("target address is required", target_addr != NULL); - - if (!(flags & ND6_SEND_FLAG_ANY_SRC) && - ip6_addr_isvalid(netif_ip6_addr_state(netif,0))) { - /* Use link-local address as source address. */ - src_addr = netif_ip6_addr(netif, 0); - /* calculate option length (in 8-byte-blocks) */ - lladdr_opt_len = ((netif->hwaddr_len + 2) + 7) >> 3; - } else { - src_addr = IP6_ADDR_ANY6; - /* Option "MUST NOT be included when the source IP address is the unspecified address." */ - lladdr_opt_len = 0; - } - - /* Allocate a packet. */ - p = pbuf_alloc(PBUF_IP, sizeof(struct ns_header) + (lladdr_opt_len << 3), PBUF_RAM); - if (p == NULL) { - ND6_STATS_INC(nd6.memerr); - return; - } - - /* Set fields. */ - ns_hdr = (struct ns_header *)p->payload; - - ns_hdr->type = ICMP6_TYPE_NS; - ns_hdr->code = 0; - ns_hdr->chksum = 0; - ns_hdr->reserved = 0; - ip6_addr_copy_to_packed(ns_hdr->target_address, *target_addr); - - if (lladdr_opt_len != 0) { - struct lladdr_option *lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct ns_header)); - lladdr_opt->type = ND6_OPTION_TYPE_SOURCE_LLADDR; - lladdr_opt->length = (u8_t)lladdr_opt_len; - SMEMCPY(lladdr_opt->addr, netif->hwaddr, netif->hwaddr_len); - } - - /* Generate the solicited node address for the target address. */ - if (flags & ND6_SEND_FLAG_MULTICAST_DEST) { - ip6_addr_set_solicitednode(&multicast_address, target_addr->addr[3]); - ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); - target_addr = &multicast_address; - } - -#if CHECKSUM_GEN_ICMP6 - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { - ns_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, - target_addr); - } -#endif /* CHECKSUM_GEN_ICMP6 */ - - /* Send the packet out. */ - ND6_STATS_INC(nd6.xmit); - ip6_output_if(p, (src_addr == IP6_ADDR_ANY6) ? NULL : src_addr, target_addr, - ND6_HOPLIM, 0, IP6_NEXTH_ICMP6, netif); - pbuf_free(p); -} - -/** - * Send a neighbor advertisement message - * - * @param netif the netif on which to send the message - * @param target_addr the IPv6 target address for the ND message - * @param flags one of ND6_SEND_FLAG_* - */ -static void -nd6_send_na(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags) -{ - struct na_header *na_hdr; - struct lladdr_option *lladdr_opt; - struct pbuf *p; - const ip6_addr_t *src_addr; - const ip6_addr_t *dest_addr; - u16_t lladdr_opt_len; - - LWIP_ASSERT("target address is required", target_addr != NULL); - - /* Use link-local address as source address. */ - /* src_addr = netif_ip6_addr(netif, 0); */ - /* Use target address as source address. */ - src_addr = target_addr; - - /* Allocate a packet. */ - lladdr_opt_len = ((netif->hwaddr_len + 2) >> 3) + (((netif->hwaddr_len + 2) & 0x07) ? 1 : 0); - p = pbuf_alloc(PBUF_IP, sizeof(struct na_header) + (lladdr_opt_len << 3), PBUF_RAM); - if (p == NULL) { - ND6_STATS_INC(nd6.memerr); - return; - } - - /* Set fields. */ - na_hdr = (struct na_header *)p->payload; - lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct na_header)); - - na_hdr->type = ICMP6_TYPE_NA; - na_hdr->code = 0; - na_hdr->chksum = 0; - na_hdr->flags = flags & 0xf0; - na_hdr->reserved[0] = 0; - na_hdr->reserved[1] = 0; - na_hdr->reserved[2] = 0; - ip6_addr_copy_to_packed(na_hdr->target_address, *target_addr); - - lladdr_opt->type = ND6_OPTION_TYPE_TARGET_LLADDR; - lladdr_opt->length = (u8_t)lladdr_opt_len; - SMEMCPY(lladdr_opt->addr, netif->hwaddr, netif->hwaddr_len); - - /* Generate the solicited node address for the target address. */ - if (flags & ND6_SEND_FLAG_MULTICAST_DEST) { - ip6_addr_set_solicitednode(&multicast_address, target_addr->addr[3]); - ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); - dest_addr = &multicast_address; - } else if (flags & ND6_SEND_FLAG_ALLNODES_DEST) { - ip6_addr_set_allnodes_linklocal(&multicast_address); - ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); - dest_addr = &multicast_address; - } else { - dest_addr = ip6_current_src_addr(); - } - -#if CHECKSUM_GEN_ICMP6 - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { - na_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, - dest_addr); - } -#endif /* CHECKSUM_GEN_ICMP6 */ - - /* Send the packet out. */ - ND6_STATS_INC(nd6.xmit); - ip6_output_if(p, src_addr, dest_addr, - ND6_HOPLIM, 0, IP6_NEXTH_ICMP6, netif); - pbuf_free(p); -} - -#if LWIP_IPV6_SEND_ROUTER_SOLICIT -/** - * Send a router solicitation message - * - * @param netif the netif on which to send the message - */ -static err_t -nd6_send_rs(struct netif *netif) -{ - struct rs_header *rs_hdr; - struct lladdr_option *lladdr_opt; - struct pbuf *p; - const ip6_addr_t *src_addr; - err_t err; - u16_t lladdr_opt_len = 0; - - /* Link-local source address, or unspecified address? */ - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, 0))) { - src_addr = netif_ip6_addr(netif, 0); - } else { - src_addr = IP6_ADDR_ANY6; - } - - /* Generate the all routers target address. */ - ip6_addr_set_allrouters_linklocal(&multicast_address); - ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); - - /* Allocate a packet. */ - if (src_addr != IP6_ADDR_ANY6) { - lladdr_opt_len = ((netif->hwaddr_len + 2) >> 3) + (((netif->hwaddr_len + 2) & 0x07) ? 1 : 0); - } - p = pbuf_alloc(PBUF_IP, sizeof(struct rs_header) + (lladdr_opt_len << 3), PBUF_RAM); - if (p == NULL) { - ND6_STATS_INC(nd6.memerr); - return ERR_BUF; - } - - /* Set fields. */ - rs_hdr = (struct rs_header *)p->payload; - - rs_hdr->type = ICMP6_TYPE_RS; - rs_hdr->code = 0; - rs_hdr->chksum = 0; - rs_hdr->reserved = 0; - - if (src_addr != IP6_ADDR_ANY6) { - /* Include our hw address. */ - lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct rs_header)); - lladdr_opt->type = ND6_OPTION_TYPE_SOURCE_LLADDR; - lladdr_opt->length = (u8_t)lladdr_opt_len; - SMEMCPY(lladdr_opt->addr, netif->hwaddr, netif->hwaddr_len); - } - -#if CHECKSUM_GEN_ICMP6 - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { - rs_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, - &multicast_address); - } -#endif /* CHECKSUM_GEN_ICMP6 */ - - /* Send the packet out. */ - ND6_STATS_INC(nd6.xmit); - - err = ip6_output_if(p, (src_addr == IP6_ADDR_ANY6) ? NULL : src_addr, &multicast_address, - ND6_HOPLIM, 0, IP6_NEXTH_ICMP6, netif); - pbuf_free(p); - - return err; -} -#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ - -/** - * Search for a neighbor cache entry - * - * @param ip6addr the IPv6 address of the neighbor - * @return The neighbor cache entry index that matched, -1 if no - * entry is found - */ -static s8_t -nd6_find_neighbor_cache_entry(const ip6_addr_t *ip6addr) -{ - s8_t i; - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if (ip6_addr_cmp(ip6addr, &(neighbor_cache[i].next_hop_address))) { - return i; - } - } - return -1; -} - -/** - * Create a new neighbor cache entry. - * - * If no unused entry is found, will try to recycle an old entry - * according to ad-hoc "age" heuristic. - * - * @return The neighbor cache entry index that was created, -1 if no - * entry could be created - */ -static s8_t -nd6_new_neighbor_cache_entry(void) -{ - s8_t i; - s8_t j; - u32_t time; - - - /* First, try to find an empty entry. */ - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if (neighbor_cache[i].state == ND6_NO_ENTRY) { - return i; - } - } - - /* We need to recycle an entry. in general, do not recycle if it is a router. */ - - /* Next, try to find a Stale entry. */ - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if ((neighbor_cache[i].state == ND6_STALE) && - (!neighbor_cache[i].isrouter)) { - nd6_free_neighbor_cache_entry(i); - return i; - } - } - - /* Next, try to find a Probe entry. */ - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if ((neighbor_cache[i].state == ND6_PROBE) && - (!neighbor_cache[i].isrouter)) { - nd6_free_neighbor_cache_entry(i); - return i; - } - } - - /* Next, try to find a Delayed entry. */ - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if ((neighbor_cache[i].state == ND6_DELAY) && - (!neighbor_cache[i].isrouter)) { - nd6_free_neighbor_cache_entry(i); - return i; - } - } - - /* Next, try to find the oldest reachable entry. */ - time = 0xfffffffful; - j = -1; - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if ((neighbor_cache[i].state == ND6_REACHABLE) && - (!neighbor_cache[i].isrouter)) { - if (neighbor_cache[i].counter.reachable_time < time) { - j = i; - time = neighbor_cache[i].counter.reachable_time; - } - } - } - if (j >= 0) { - nd6_free_neighbor_cache_entry(j); - return j; - } - - /* Next, find oldest incomplete entry without queued packets. */ - time = 0; - j = -1; - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if ( - (neighbor_cache[i].q == NULL) && - (neighbor_cache[i].state == ND6_INCOMPLETE) && - (!neighbor_cache[i].isrouter)) { - if (neighbor_cache[i].counter.probes_sent >= time) { - j = i; - time = neighbor_cache[i].counter.probes_sent; - } - } - } - if (j >= 0) { - nd6_free_neighbor_cache_entry(j); - return j; - } - - /* Next, find oldest incomplete entry with queued packets. */ - time = 0; - j = -1; - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if ((neighbor_cache[i].state == ND6_INCOMPLETE) && - (!neighbor_cache[i].isrouter)) { - if (neighbor_cache[i].counter.probes_sent >= time) { - j = i; - time = neighbor_cache[i].counter.probes_sent; - } - } - } - if (j >= 0) { - nd6_free_neighbor_cache_entry(j); - return j; - } - - /* No more entries to try. */ - return -1; -} - -/** - * Will free any resources associated with a neighbor cache - * entry, and will mark it as unused. - * - * @param i the neighbor cache entry index to free - */ -static void -nd6_free_neighbor_cache_entry(s8_t i) -{ - if ((i < 0) || (i >= LWIP_ND6_NUM_NEIGHBORS)) { - return; - } - if (neighbor_cache[i].isrouter) { - /* isrouter needs to be cleared before deleting a neighbor cache entry */ - return; - } - - /* Free any queued packets. */ - if (neighbor_cache[i].q != NULL) { - nd6_free_q(neighbor_cache[i].q); - neighbor_cache[i].q = NULL; - } - - neighbor_cache[i].state = ND6_NO_ENTRY; - neighbor_cache[i].isrouter = 0; - neighbor_cache[i].netif = NULL; - neighbor_cache[i].counter.reachable_time = 0; - ip6_addr_set_zero(&(neighbor_cache[i].next_hop_address)); -} - -/** - * Search for a destination cache entry - * - * @param ip6addr the IPv6 address of the destination - * @return The destination cache entry index that matched, -1 if no - * entry is found - */ -static s16_t -nd6_find_destination_cache_entry(const ip6_addr_t *ip6addr) -{ - s16_t i; - - IP6_ADDR_ZONECHECK(ip6addr); - - for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { - if (ip6_addr_cmp(ip6addr, &(destination_cache[i].destination_addr))) { - return i; - } - } - return -1; -} - -/** - * Create a new destination cache entry. If no unused entry is found, - * will recycle oldest entry. - * - * @return The destination cache entry index that was created, -1 if no - * entry was created - */ -static s16_t -nd6_new_destination_cache_entry(void) -{ - s16_t i, j; - u32_t age; - - /* Find an empty entry. */ - for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { - if (ip6_addr_isany(&(destination_cache[i].destination_addr))) { - return i; - } - } - - /* Find oldest entry. */ - age = 0; - j = LWIP_ND6_NUM_DESTINATIONS - 1; - for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { - if (destination_cache[i].age > age) { - j = i; - } - } - - return j; -} - -/** - * Clear the destination cache. - * - * This operation may be necessary for consistency in the light of changing - * local addresses and/or use of the gateway hook. - */ -void -nd6_clear_destination_cache(void) -{ - int i; - - for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { - ip6_addr_set_any(&destination_cache[i].destination_addr); - } -} - -/** - * Determine whether an address matches an on-link prefix or the subnet of a - * statically assigned address. - * - * @param ip6addr the IPv6 address to match - * @return 1 if the address is on-link, 0 otherwise - */ -static int -nd6_is_prefix_in_netif(const ip6_addr_t *ip6addr, struct netif *netif) -{ - s8_t i; - - /* Check to see if the address matches an on-link prefix. */ - for (i = 0; i < LWIP_ND6_NUM_PREFIXES; i++) { - if ((prefix_list[i].netif == netif) && - (prefix_list[i].invalidation_timer > 0) && - ip6_addr_netcmp(ip6addr, &(prefix_list[i].prefix))) { - return 1; - } - } - /* Check to see if address prefix matches a manually configured (= static) - * address. Static addresses have an implied /64 subnet assignment. Dynamic - * addresses (from autoconfiguration) have no implied subnet assignment, and - * are thus effectively /128 assignments. See RFC 5942 for more on this. */ - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && - netif_ip6_addr_isstatic(netif, i) && - ip6_addr_netcmp(ip6addr, netif_ip6_addr(netif, i))) { - return 1; - } - } - return 0; -} - -/** - * Select a default router for a destination. - * - * This function is used both for routing and for finding a next-hop target for - * a packet. In the former case, the given netif is NULL, and the returned - * router entry must be for a netif suitable for sending packets (up, link up). - * In the latter case, the given netif is not NULL and restricts router choice. - * - * @param ip6addr the destination address - * @param netif the netif for the outgoing packet, if known - * @return the default router entry index, or -1 if no suitable - * router is found - */ -static s8_t -nd6_select_router(const ip6_addr_t *ip6addr, struct netif *netif) -{ - struct netif *router_netif; - s8_t i, j, valid_router; - static s8_t last_router; - - LWIP_UNUSED_ARG(ip6addr); /* @todo match preferred routes!! (must implement ND6_OPTION_TYPE_ROUTE_INFO) */ - - /* @todo: implement default router preference */ - - /* Look for valid routers. A reachable router is preferred. */ - valid_router = -1; - for (i = 0; i < LWIP_ND6_NUM_ROUTERS; i++) { - /* Is the router netif both set and apppropriate? */ - if (default_router_list[i].neighbor_entry != NULL) { - router_netif = default_router_list[i].neighbor_entry->netif; - if ((router_netif != NULL) && (netif != NULL ? netif == router_netif : - (netif_is_up(router_netif) && netif_is_link_up(router_netif)))) { - /* Is the router valid, i.e., reachable or probably reachable as per - * RFC 4861 Sec. 6.3.6? Note that we will never return a router that - * has no neighbor cache entry, due to the netif association tests. */ - if (default_router_list[i].neighbor_entry->state != ND6_INCOMPLETE) { - /* Is the router known to be reachable? */ - if (default_router_list[i].neighbor_entry->state == ND6_REACHABLE) { - return i; /* valid and reachable - done! */ - } else if (valid_router < 0) { - valid_router = i; /* valid but not known to be reachable */ - } - } - } - } - } - if (valid_router >= 0) { - return valid_router; - } - - /* Look for any router for which we have any information at all. */ - /* last_router is used for round-robin selection of incomplete routers, as - * recommended in RFC 4861 Sec. 6.3.6 point (2). Advance only when picking a - * route, to select the same router as next-hop target in the common case. */ - if ((netif == NULL) && (++last_router >= LWIP_ND6_NUM_ROUTERS)) { - last_router = 0; - } - i = last_router; - for (j = 0; j < LWIP_ND6_NUM_ROUTERS; j++) { - if (default_router_list[i].neighbor_entry != NULL) { - router_netif = default_router_list[i].neighbor_entry->netif; - if ((router_netif != NULL) && (netif != NULL ? netif == router_netif : - (netif_is_up(router_netif) && netif_is_link_up(router_netif)))) { - return i; - } - } - if (++i >= LWIP_ND6_NUM_ROUTERS) { - i = 0; - } - } - - /* no suitable router found. */ - return -1; -} - -/** - * Find a router-announced route to the given destination. This route may be - * based on an on-link prefix or a default router. - * - * If a suitable route is found, the returned netif is guaranteed to be in a - * suitable state (up, link up) to be used for packet transmission. - * - * @param ip6addr the destination IPv6 address - * @return the netif to use for the destination, or NULL if none found - */ -struct netif * -nd6_find_route(const ip6_addr_t *ip6addr) -{ - struct netif *netif; - s8_t i; - - /* @todo decide if it makes sense to check the destination cache first */ - - /* Check if there is a matching on-link prefix. There may be multiple - * matches. Pick the first one that is associated with a suitable netif. */ - for (i = 0; i < LWIP_ND6_NUM_PREFIXES; ++i) { - netif = prefix_list[i].netif; - if ((netif != NULL) && ip6_addr_netcmp(&prefix_list[i].prefix, ip6addr) && - netif_is_up(netif) && netif_is_link_up(netif)) { - return netif; - } - } - - /* No on-link prefix match. Find a router that can forward the packet. */ - i = nd6_select_router(ip6addr, NULL); - if (i >= 0) { - LWIP_ASSERT("selected router must have a neighbor entry", - default_router_list[i].neighbor_entry != NULL); - return default_router_list[i].neighbor_entry->netif; - } - - return NULL; -} - -/** - * Find an entry for a default router. - * - * @param router_addr the IPv6 address of the router - * @param netif the netif on which the router is found, if known - * @return the index of the router entry, or -1 if not found - */ -static s8_t -nd6_get_router(const ip6_addr_t *router_addr, struct netif *netif) -{ - s8_t i; - - IP6_ADDR_ZONECHECK_NETIF(router_addr, netif); - - /* Look for router. */ - for (i = 0; i < LWIP_ND6_NUM_ROUTERS; i++) { - if ((default_router_list[i].neighbor_entry != NULL) && - ((netif != NULL) ? netif == default_router_list[i].neighbor_entry->netif : 1) && - ip6_addr_cmp(router_addr, &(default_router_list[i].neighbor_entry->next_hop_address))) { - return i; - } - } - - /* router not found. */ - return -1; -} - -/** - * Create a new entry for a default router. - * - * @param router_addr the IPv6 address of the router - * @param netif the netif on which the router is connected, if known - * @return the index on the router table, or -1 if could not be created - */ -static s8_t -nd6_new_router(const ip6_addr_t *router_addr, struct netif *netif) -{ - s8_t router_index; - s8_t free_router_index; - s8_t neighbor_index; - - IP6_ADDR_ZONECHECK_NETIF(router_addr, netif); - - /* Do we have a neighbor entry for this router? */ - neighbor_index = nd6_find_neighbor_cache_entry(router_addr); - if (neighbor_index < 0) { - /* Create a neighbor entry for this router. */ - neighbor_index = nd6_new_neighbor_cache_entry(); - if (neighbor_index < 0) { - /* Could not create neighbor entry for this router. */ - return -1; - } - ip6_addr_set(&(neighbor_cache[neighbor_index].next_hop_address), router_addr); - neighbor_cache[neighbor_index].netif = netif; - neighbor_cache[neighbor_index].q = NULL; - neighbor_cache[neighbor_index].state = ND6_INCOMPLETE; - neighbor_cache[neighbor_index].counter.probes_sent = 1; - nd6_send_neighbor_cache_probe(&neighbor_cache[neighbor_index], ND6_SEND_FLAG_MULTICAST_DEST); - } - - /* Mark neighbor as router. */ - neighbor_cache[neighbor_index].isrouter = 1; - - /* Look for empty entry. */ - free_router_index = LWIP_ND6_NUM_ROUTERS; - for (router_index = LWIP_ND6_NUM_ROUTERS - 1; router_index >= 0; router_index--) { - /* check if router already exists (this is a special case for 2 netifs on the same subnet - - e.g. wifi and cable) */ - if(default_router_list[router_index].neighbor_entry == &(neighbor_cache[neighbor_index])){ - return router_index; - } - if (default_router_list[router_index].neighbor_entry == NULL) { - /* remember lowest free index to create a new entry */ - free_router_index = router_index; - } - } - if (free_router_index < LWIP_ND6_NUM_ROUTERS) { - default_router_list[free_router_index].neighbor_entry = &(neighbor_cache[neighbor_index]); - return free_router_index; - } - - /* Could not create a router entry. */ - - /* Mark neighbor entry as not-router. Entry might be useful as neighbor still. */ - neighbor_cache[neighbor_index].isrouter = 0; - - /* router not found. */ - return -1; -} - -/** - * Find the cached entry for an on-link prefix. - * - * @param prefix the IPv6 prefix that is on-link - * @param netif the netif on which the prefix is on-link - * @return the index on the prefix table, or -1 if not found - */ -static s8_t -nd6_get_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif) -{ - s8_t i; - - /* Look for prefix in list. */ - for (i = 0; i < LWIP_ND6_NUM_PREFIXES; ++i) { - if ((ip6_addr_netcmp(&(prefix_list[i].prefix), prefix)) && - (prefix_list[i].netif == netif)) { - return i; - } - } - - /* Entry not available. */ - return -1; -} - -/** - * Creates a new entry for an on-link prefix. - * - * @param prefix the IPv6 prefix that is on-link - * @param netif the netif on which the prefix is on-link - * @return the index on the prefix table, or -1 if not created - */ -static s8_t -nd6_new_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif) -{ - s8_t i; - - /* Create new entry. */ - for (i = 0; i < LWIP_ND6_NUM_PREFIXES; ++i) { - if ((prefix_list[i].netif == NULL) || - (prefix_list[i].invalidation_timer == 0)) { - /* Found empty prefix entry. */ - prefix_list[i].netif = netif; - ip6_addr_set(&(prefix_list[i].prefix), prefix); - return i; - } - } - - /* Entry not available. */ - return -1; -} - -/** - * Determine the next hop for a destination. Will determine if the - * destination is on-link, else a suitable on-link router is selected. - * - * The last entry index is cached for fast entry search. - * - * @param ip6addr the destination address - * @param netif the netif on which the packet will be sent - * @return the neighbor cache entry for the next hop, ERR_RTE if no - * suitable next hop was found, ERR_MEM if no cache entry - * could be created - */ -static s8_t -nd6_get_next_hop_entry(const ip6_addr_t *ip6addr, struct netif *netif) -{ -#ifdef LWIP_HOOK_ND6_GET_GW - const ip6_addr_t *next_hop_addr; -#endif /* LWIP_HOOK_ND6_GET_GW */ - s8_t i; - s16_t dst_idx; - - IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif); - -#if LWIP_NETIF_HWADDRHINT - if (netif->hints != NULL) { - /* per-pcb cached entry was given */ - netif_addr_idx_t addr_hint = netif->hints->addr_hint; - if (addr_hint < LWIP_ND6_NUM_DESTINATIONS) { - nd6_cached_destination_index = addr_hint; - } - } -#endif /* LWIP_NETIF_HWADDRHINT */ - - /* Look for ip6addr in destination cache. */ - if (ip6_addr_cmp(ip6addr, &(destination_cache[nd6_cached_destination_index].destination_addr))) { - /* the cached entry index is the right one! */ - /* do nothing. */ - ND6_STATS_INC(nd6.cachehit); - } else { - /* Search destination cache. */ - dst_idx = nd6_find_destination_cache_entry(ip6addr); - if (dst_idx >= 0) { - /* found destination entry. make it our new cached index. */ - LWIP_ASSERT("type overflow", (size_t)dst_idx < NETIF_ADDR_IDX_MAX); - nd6_cached_destination_index = (netif_addr_idx_t)dst_idx; - } else { - /* Not found. Create a new destination entry. */ - dst_idx = nd6_new_destination_cache_entry(); - if (dst_idx >= 0) { - /* got new destination entry. make it our new cached index. */ - LWIP_ASSERT("type overflow", (size_t)dst_idx < NETIF_ADDR_IDX_MAX); - nd6_cached_destination_index = (netif_addr_idx_t)dst_idx; - } else { - /* Could not create a destination cache entry. */ - return ERR_MEM; - } - - /* Copy dest address to destination cache. */ - ip6_addr_set(&(destination_cache[nd6_cached_destination_index].destination_addr), ip6addr); - - /* Now find the next hop. is it a neighbor? */ - if (ip6_addr_islinklocal(ip6addr) || - nd6_is_prefix_in_netif(ip6addr, netif)) { - /* Destination in local link. */ - destination_cache[nd6_cached_destination_index].pmtu = netif_mtu6(netif); - ip6_addr_copy(destination_cache[nd6_cached_destination_index].next_hop_addr, destination_cache[nd6_cached_destination_index].destination_addr); -#ifdef LWIP_HOOK_ND6_GET_GW - } else if ((next_hop_addr = LWIP_HOOK_ND6_GET_GW(netif, ip6addr)) != NULL) { - /* Next hop for destination provided by hook function. */ - destination_cache[nd6_cached_destination_index].pmtu = netif->mtu; - ip6_addr_set(&destination_cache[nd6_cached_destination_index].next_hop_addr, next_hop_addr); -#endif /* LWIP_HOOK_ND6_GET_GW */ - } else { - /* We need to select a router. */ - i = nd6_select_router(ip6addr, netif); - if (i < 0) { - /* No router found. */ - ip6_addr_set_any(&(destination_cache[nd6_cached_destination_index].destination_addr)); - return ERR_RTE; - } - destination_cache[nd6_cached_destination_index].pmtu = netif_mtu6(netif); /* Start with netif mtu, correct through ICMPv6 if necessary */ - ip6_addr_copy(destination_cache[nd6_cached_destination_index].next_hop_addr, default_router_list[i].neighbor_entry->next_hop_address); - } - } - } - -#if LWIP_NETIF_HWADDRHINT - if (netif->hints != NULL) { - /* per-pcb cached entry was given */ - netif->hints->addr_hint = nd6_cached_destination_index; - } -#endif /* LWIP_NETIF_HWADDRHINT */ - - /* Look in neighbor cache for the next-hop address. */ - if (ip6_addr_cmp(&(destination_cache[nd6_cached_destination_index].next_hop_addr), - &(neighbor_cache[nd6_cached_neighbor_index].next_hop_address))) { - /* Cache hit. */ - /* Do nothing. */ - ND6_STATS_INC(nd6.cachehit); - } else { - i = nd6_find_neighbor_cache_entry(&(destination_cache[nd6_cached_destination_index].next_hop_addr)); - if (i >= 0) { - /* Found a matching record, make it new cached entry. */ - nd6_cached_neighbor_index = i; - } else { - /* Neighbor not in cache. Make a new entry. */ - i = nd6_new_neighbor_cache_entry(); - if (i >= 0) { - /* got new neighbor entry. make it our new cached index. */ - nd6_cached_neighbor_index = i; - } else { - /* Could not create a neighbor cache entry. */ - return ERR_MEM; - } - - /* Initialize fields. */ - ip6_addr_copy(neighbor_cache[i].next_hop_address, - destination_cache[nd6_cached_destination_index].next_hop_addr); - neighbor_cache[i].isrouter = 0; - neighbor_cache[i].netif = netif; - neighbor_cache[i].state = ND6_INCOMPLETE; - neighbor_cache[i].counter.probes_sent = 1; - nd6_send_neighbor_cache_probe(&neighbor_cache[i], ND6_SEND_FLAG_MULTICAST_DEST); - } - } - - /* Reset this destination's age. */ - destination_cache[nd6_cached_destination_index].age = 0; - - return nd6_cached_neighbor_index; -} - -/** - * Queue a packet for a neighbor. - * - * @param neighbor_index the index in the neighbor cache table - * @param q packet to be queued - * @return ERR_OK if succeeded, ERR_MEM if out of memory - */ -static err_t -nd6_queue_packet(s8_t neighbor_index, struct pbuf *q) -{ - err_t result = ERR_MEM; - struct pbuf *p; - int copy_needed = 0; -#if LWIP_ND6_QUEUEING - struct nd6_q_entry *new_entry, *r; -#endif /* LWIP_ND6_QUEUEING */ - - if ((neighbor_index < 0) || (neighbor_index >= LWIP_ND6_NUM_NEIGHBORS)) { - return ERR_ARG; - } - - /* IF q includes a pbuf that must be copied, we have to copy the whole chain - * into a new PBUF_RAM. See the definition of PBUF_NEEDS_COPY for details. */ - p = q; - while (p) { - if (PBUF_NEEDS_COPY(p)) { - copy_needed = 1; - break; - } - p = p->next; - } - if (copy_needed) { - /* copy the whole packet into new pbufs */ - p = pbuf_clone(PBUF_LINK, PBUF_RAM, q); - while ((p == NULL) && (neighbor_cache[neighbor_index].q != NULL)) { - /* Free oldest packet (as per RFC recommendation) */ -#if LWIP_ND6_QUEUEING - r = neighbor_cache[neighbor_index].q; - neighbor_cache[neighbor_index].q = r->next; - r->next = NULL; - nd6_free_q(r); -#else /* LWIP_ND6_QUEUEING */ - pbuf_free(neighbor_cache[neighbor_index].q); - neighbor_cache[neighbor_index].q = NULL; -#endif /* LWIP_ND6_QUEUEING */ - p = pbuf_clone(PBUF_LINK, PBUF_RAM, q); - } - } else { - /* referencing the old pbuf is enough */ - p = q; - pbuf_ref(p); - } - /* packet was copied/ref'd? */ - if (p != NULL) { - /* queue packet ... */ -#if LWIP_ND6_QUEUEING - /* allocate a new nd6 queue entry */ - new_entry = (struct nd6_q_entry *)memp_malloc(MEMP_ND6_QUEUE); - if ((new_entry == NULL) && (neighbor_cache[neighbor_index].q != NULL)) { - /* Free oldest packet (as per RFC recommendation) */ - r = neighbor_cache[neighbor_index].q; - neighbor_cache[neighbor_index].q = r->next; - r->next = NULL; - nd6_free_q(r); - new_entry = (struct nd6_q_entry *)memp_malloc(MEMP_ND6_QUEUE); - } - if (new_entry != NULL) { - new_entry->next = NULL; - new_entry->p = p; - if (neighbor_cache[neighbor_index].q != NULL) { - /* queue was already existent, append the new entry to the end */ - r = neighbor_cache[neighbor_index].q; - while (r->next != NULL) { - r = r->next; - } - r->next = new_entry; - } else { - /* queue did not exist, first item in queue */ - neighbor_cache[neighbor_index].q = new_entry; - } - LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: queued packet %p on neighbor entry %"S16_F"\n", (void *)p, (s16_t)neighbor_index)); - result = ERR_OK; - } else { - /* the pool MEMP_ND6_QUEUE is empty */ - pbuf_free(p); - LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: could not queue a copy of packet %p (out of memory)\n", (void *)p)); - /* { result == ERR_MEM } through initialization */ - } -#else /* LWIP_ND6_QUEUEING */ - /* Queue a single packet. If an older packet is already queued, free it as per RFC. */ - if (neighbor_cache[neighbor_index].q != NULL) { - pbuf_free(neighbor_cache[neighbor_index].q); - } - neighbor_cache[neighbor_index].q = p; - LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: queued packet %p on neighbor entry %"S16_F"\n", (void *)p, (s16_t)neighbor_index)); - result = ERR_OK; -#endif /* LWIP_ND6_QUEUEING */ - } else { - LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: could not queue a copy of packet %p (out of memory)\n", (void *)q)); - /* { result == ERR_MEM } through initialization */ - } - - return result; -} - -#if LWIP_ND6_QUEUEING -/** - * Free a complete queue of nd6 q entries - * - * @param q a queue of nd6_q_entry to free - */ -static void -nd6_free_q(struct nd6_q_entry *q) -{ - struct nd6_q_entry *r; - LWIP_ASSERT("q != NULL", q != NULL); - LWIP_ASSERT("q->p != NULL", q->p != NULL); - while (q) { - r = q; - q = q->next; - LWIP_ASSERT("r->p != NULL", (r->p != NULL)); - pbuf_free(r->p); - memp_free(MEMP_ND6_QUEUE, r); - } -} -#endif /* LWIP_ND6_QUEUEING */ - -/** - * Send queued packets for a neighbor - * - * @param i the neighbor to send packets to - */ -static void -nd6_send_q(s8_t i) -{ - struct ip6_hdr *ip6hdr; - ip6_addr_t dest; -#if LWIP_ND6_QUEUEING - struct nd6_q_entry *q; -#endif /* LWIP_ND6_QUEUEING */ - - if ((i < 0) || (i >= LWIP_ND6_NUM_NEIGHBORS)) { - return; - } - -#if LWIP_ND6_QUEUEING - while (neighbor_cache[i].q != NULL) { - /* remember first in queue */ - q = neighbor_cache[i].q; - /* pop first item off the queue */ - neighbor_cache[i].q = q->next; - /* Get ipv6 header. */ - ip6hdr = (struct ip6_hdr *)(q->p->payload); - /* Create an aligned copy. */ - ip6_addr_copy_from_packed(dest, ip6hdr->dest); - /* Restore the zone, if applicable. */ - ip6_addr_assign_zone(&dest, IP6_UNKNOWN, neighbor_cache[i].netif); - /* send the queued IPv6 packet */ - (neighbor_cache[i].netif)->output_ip6(neighbor_cache[i].netif, q->p, &dest); - /* free the queued IP packet */ - pbuf_free(q->p); - /* now queue entry can be freed */ - memp_free(MEMP_ND6_QUEUE, q); - } -#else /* LWIP_ND6_QUEUEING */ - if (neighbor_cache[i].q != NULL) { - /* Get ipv6 header. */ - ip6hdr = (struct ip6_hdr *)(neighbor_cache[i].q->payload); - /* Create an aligned copy. */ - ip6_addr_copy_from_packed(dest, ip6hdr->dest); - /* Restore the zone, if applicable. */ - ip6_addr_assign_zone(&dest, IP6_UNKNOWN, neighbor_cache[i].netif); - /* send the queued IPv6 packet */ - (neighbor_cache[i].netif)->output_ip6(neighbor_cache[i].netif, neighbor_cache[i].q, &dest); - /* free the queued IP packet */ - pbuf_free(neighbor_cache[i].q); - neighbor_cache[i].q = NULL; - } -#endif /* LWIP_ND6_QUEUEING */ -} - -/** - * A packet is to be transmitted to a specific IPv6 destination on a specific - * interface. Check if we can find the hardware address of the next hop to use - * for the packet. If so, give the hardware address to the caller, which should - * use it to send the packet right away. Otherwise, enqueue the packet for - * later transmission while looking up the hardware address, if possible. - * - * As such, this function returns one of three different possible results: - * - * - ERR_OK with a non-NULL 'hwaddrp': the caller should send the packet now. - * - ERR_OK with a NULL 'hwaddrp': the packet has been enqueued for later. - * - not ERR_OK: something went wrong; forward the error upward in the stack. - * - * @param netif The lwIP network interface on which the IP packet will be sent. - * @param q The pbuf(s) containing the IP packet to be sent. - * @param ip6addr The destination IPv6 address of the packet. - * @param hwaddrp On success, filled with a pointer to a HW address or NULL (meaning - * the packet has been queued). - * @return - * - ERR_OK on success, ERR_RTE if no route was found for the packet, - * or ERR_MEM if low memory conditions prohibit sending the packet at all. - */ -err_t -nd6_get_next_hop_addr_or_queue(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr, const u8_t **hwaddrp) -{ - s8_t i; - - /* Get next hop record. */ - i = nd6_get_next_hop_entry(ip6addr, netif); - if (i < 0) { - /* failed to get a next hop neighbor record. */ - return i; - } - - /* Now that we have a destination record, send or queue the packet. */ - if (neighbor_cache[i].state == ND6_STALE) { - /* Switch to delay state. */ - neighbor_cache[i].state = ND6_DELAY; - neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; - } - /* @todo should we send or queue if PROBE? send for now, to let unicast NS pass. */ - if ((neighbor_cache[i].state == ND6_REACHABLE) || - (neighbor_cache[i].state == ND6_DELAY) || - (neighbor_cache[i].state == ND6_PROBE)) { - - /* Tell the caller to send out the packet now. */ - *hwaddrp = neighbor_cache[i].lladdr; - return ERR_OK; - } - - /* We should queue packet on this interface. */ - *hwaddrp = NULL; - return nd6_queue_packet(i, q); -} - - -/** - * Get the Path MTU for a destination. - * - * @param ip6addr the destination address - * @param netif the netif on which the packet will be sent - * @return the Path MTU, if known, or the netif default MTU - */ -u16_t -nd6_get_destination_mtu(const ip6_addr_t *ip6addr, struct netif *netif) -{ - s16_t i; - - i = nd6_find_destination_cache_entry(ip6addr); - if (i >= 0) { - if (destination_cache[i].pmtu > 0) { - return destination_cache[i].pmtu; - } - } - - if (netif != NULL) { - return netif_mtu6(netif); - } - - return 1280; /* Minimum MTU */ -} - - -#if LWIP_ND6_TCP_REACHABILITY_HINTS -/** - * Provide the Neighbor discovery process with a hint that a - * destination is reachable. Called by tcp_receive when ACKs are - * received or sent (as per RFC). This is useful to avoid sending - * NS messages every 30 seconds. - * - * @param ip6addr the destination address which is know to be reachable - * by an upper layer protocol (TCP) - */ -void -nd6_reachability_hint(const ip6_addr_t *ip6addr) -{ - s8_t i; - s16_t dst_idx; - - /* Find destination in cache. */ - if (ip6_addr_cmp(ip6addr, &(destination_cache[nd6_cached_destination_index].destination_addr))) { - dst_idx = nd6_cached_destination_index; - ND6_STATS_INC(nd6.cachehit); - } else { - dst_idx = nd6_find_destination_cache_entry(ip6addr); - } - if (dst_idx < 0) { - return; - } - - /* Find next hop neighbor in cache. */ - if (ip6_addr_cmp(&(destination_cache[dst_idx].next_hop_addr), &(neighbor_cache[nd6_cached_neighbor_index].next_hop_address))) { - i = nd6_cached_neighbor_index; - ND6_STATS_INC(nd6.cachehit); - } else { - i = nd6_find_neighbor_cache_entry(&(destination_cache[dst_idx].next_hop_addr)); - } - if (i < 0) { - return; - } - - /* For safety: don't set as reachable if we don't have a LL address yet. Misuse protection. */ - if (neighbor_cache[i].state == ND6_INCOMPLETE || neighbor_cache[i].state == ND6_NO_ENTRY) { - return; - } - - /* Set reachability state. */ - neighbor_cache[i].state = ND6_REACHABLE; - neighbor_cache[i].counter.reachable_time = reachable_time; -} -#endif /* LWIP_ND6_TCP_REACHABILITY_HINTS */ - -/** - * Remove all prefix, neighbor_cache and router entries of the specified netif. - * - * @param netif points to a network interface - */ -void -nd6_cleanup_netif(struct netif *netif) -{ - u8_t i; - s8_t router_index; - for (i = 0; i < LWIP_ND6_NUM_PREFIXES; i++) { - if (prefix_list[i].netif == netif) { - prefix_list[i].netif = NULL; - } - } - for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { - if (neighbor_cache[i].netif == netif) { - for (router_index = 0; router_index < LWIP_ND6_NUM_ROUTERS; router_index++) { - if (default_router_list[router_index].neighbor_entry == &neighbor_cache[i]) { - default_router_list[router_index].neighbor_entry = NULL; - default_router_list[router_index].flags = 0; - } - } - neighbor_cache[i].isrouter = 0; - nd6_free_neighbor_cache_entry(i); - } - } - /* Clear the destination cache, since many entries may now have become - * invalid for one of several reasons. As destination cache entries have no - * netif association, use a sledgehammer approach (this can be improved). */ - nd6_clear_destination_cache(); -} - -#if LWIP_IPV6_MLD -/** - * The state of a local IPv6 address entry is about to change. If needed, join - * or leave the solicited-node multicast group for the address. - * - * @param netif The netif that owns the address. - * @param addr_idx The index of the address. - * @param new_state The new (IP6_ADDR_) state for the address. - */ -void -nd6_adjust_mld_membership(struct netif *netif, s8_t addr_idx, u8_t new_state) -{ - u8_t old_state, old_member, new_member; - - old_state = netif_ip6_addr_state(netif, addr_idx); - - /* Determine whether we were, and should be, a member of the solicited-node - * multicast group for this address. For tentative addresses, the group is - * not joined until the address enters the TENTATIVE_1 (or VALID) state. */ - old_member = (old_state != IP6_ADDR_INVALID && old_state != IP6_ADDR_DUPLICATED && old_state != IP6_ADDR_TENTATIVE); - new_member = (new_state != IP6_ADDR_INVALID && new_state != IP6_ADDR_DUPLICATED && new_state != IP6_ADDR_TENTATIVE); - - if (old_member != new_member) { - ip6_addr_set_solicitednode(&multicast_address, netif_ip6_addr(netif, addr_idx)->addr[3]); - ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); - - if (new_member) { - mld6_joingroup_netif(netif, &multicast_address); - } else { - mld6_leavegroup_netif(netif, &multicast_address); - } - } -} -#endif /* LWIP_IPV6_MLD */ - -/** Netif was added, set up, or reconnected (link up) */ -void -nd6_restart_netif(struct netif *netif) -{ -#if LWIP_IPV6_SEND_ROUTER_SOLICIT - /* Send Router Solicitation messages (see RFC 4861, ch. 6.3.7). */ - netif->rs_count = LWIP_ND6_MAX_MULTICAST_SOLICIT; -#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ -} - -#endif /* LWIP_IPV6 */ +/** + * @file + * + * Neighbor discovery and stateless address autoconfiguration for IPv6. + * Aims to be compliant with RFC 4861 (Neighbor discovery) and RFC 4862 + * (Address autoconfiguration). + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#include "lwip/opt.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/nd6.h" +#include "lwip/priv/nd6_priv.h" +#include "lwip/prot/nd6.h" +#include "lwip/prot/icmp6.h" +#include "lwip/pbuf.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/inet_chksum.h" +#include "lwip/netif.h" +#include "lwip/icmp6.h" +#include "lwip/mld6.h" +#include "lwip/dhcp6.h" +#include "lwip/ip.h" +#include "lwip/stats.h" +#include "lwip/dns.h" + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +#if LWIP_IPV6_DUP_DETECT_ATTEMPTS > IP6_ADDR_TENTATIVE_COUNT_MASK +#error LWIP_IPV6_DUP_DETECT_ATTEMPTS > IP6_ADDR_TENTATIVE_COUNT_MASK +#endif + +/* Router tables. */ +struct nd6_neighbor_cache_entry neighbor_cache[LWIP_ND6_NUM_NEIGHBORS]; +struct nd6_destination_cache_entry destination_cache[LWIP_ND6_NUM_DESTINATIONS]; +struct nd6_prefix_list_entry prefix_list[LWIP_ND6_NUM_PREFIXES]; +struct nd6_router_list_entry default_router_list[LWIP_ND6_NUM_ROUTERS]; + +/* Default values, can be updated by a RA message. */ +u32_t reachable_time = LWIP_ND6_REACHABLE_TIME; +u32_t retrans_timer = LWIP_ND6_RETRANS_TIMER; /* @todo implement this value in timer */ + +/* Index for cache entries. */ +static u8_t nd6_cached_neighbor_index; +static netif_addr_idx_t nd6_cached_destination_index; + +/* Multicast address holder. */ +static ip6_addr_t multicast_address; + +static u8_t nd6_tmr_rs_reduction; + +/* Static buffer to parse RA packet options */ +union ra_options { + struct lladdr_option lladdr; + struct mtu_option mtu; + struct prefix_option prefix; +#if LWIP_ND6_RDNSS_MAX_DNS_SERVERS + struct rdnss_option rdnss; +#endif +}; +static union ra_options nd6_ra_buffer; + +/* Forward declarations. */ +static s8_t nd6_find_neighbor_cache_entry(const ip6_addr_t *ip6addr); +static s8_t nd6_new_neighbor_cache_entry(void); +static void nd6_free_neighbor_cache_entry(s8_t i); +static s16_t nd6_find_destination_cache_entry(const ip6_addr_t *ip6addr); +static s16_t nd6_new_destination_cache_entry(void); +static int nd6_is_prefix_in_netif(const ip6_addr_t *ip6addr, struct netif *netif); +static s8_t nd6_select_router(const ip6_addr_t *ip6addr, struct netif *netif); +static s8_t nd6_get_router(const ip6_addr_t *router_addr, struct netif *netif); +static s8_t nd6_new_router(const ip6_addr_t *router_addr, struct netif *netif); +static s8_t nd6_get_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif); +static s8_t nd6_new_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif); +static s8_t nd6_get_next_hop_entry(const ip6_addr_t *ip6addr, struct netif *netif); +static err_t nd6_queue_packet(s8_t neighbor_index, struct pbuf *q); + +#define ND6_SEND_FLAG_MULTICAST_DEST 0x01 +#define ND6_SEND_FLAG_ALLNODES_DEST 0x02 +#define ND6_SEND_FLAG_ANY_SRC 0x04 +static void nd6_send_ns(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags); +static void nd6_send_na(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags); +static void nd6_send_neighbor_cache_probe(struct nd6_neighbor_cache_entry *entry, u8_t flags); +#if LWIP_IPV6_SEND_ROUTER_SOLICIT +static err_t nd6_send_rs(struct netif *netif); +#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ + +#if LWIP_ND6_QUEUEING +static void nd6_free_q(struct nd6_q_entry *q); +#else /* LWIP_ND6_QUEUEING */ +#define nd6_free_q(q) pbuf_free(q) +#endif /* LWIP_ND6_QUEUEING */ +static void nd6_send_q(s8_t i); + + +/** + * A local address has been determined to be a duplicate. Take the appropriate + * action(s) on the address and the interface as a whole. + * + * @param netif the netif that owns the address + * @param addr_idx the index of the address detected to be a duplicate + */ +static void +nd6_duplicate_addr_detected(struct netif *netif, s8_t addr_idx) +{ + + /* Mark the address as duplicate, but leave its lifetimes alone. If this was + * a manually assigned address, it will remain in existence as duplicate, and + * as such be unusable for any practical purposes until manual intervention. + * If this was an autogenerated address, the address will follow normal + * expiration rules, and thus disappear once its valid lifetime expires. */ + netif_ip6_addr_set_state(netif, addr_idx, IP6_ADDR_DUPLICATED); + +#if LWIP_IPV6_AUTOCONFIG + /* If the affected address was the link-local address that we use to generate + * all other addresses, then we should not continue to use those derived + * addresses either, so mark them as duplicate as well. For autoconfig-only + * setups, this will make the interface effectively unusable, approaching the + * intention of RFC 4862 Sec. 5.4.5. @todo implement the full requirements */ + if (addr_idx == 0) { + s8_t i; + for (i = 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (!ip6_addr_isinvalid(netif_ip6_addr_state(netif, i)) && + !netif_ip6_addr_isstatic(netif, i)) { + netif_ip6_addr_set_state(netif, i, IP6_ADDR_DUPLICATED); + } + } + } +#endif /* LWIP_IPV6_AUTOCONFIG */ +} + +#if LWIP_IPV6_AUTOCONFIG +/** + * We received a router advertisement that contains a prefix with the + * autoconfiguration flag set. Add or update an associated autogenerated + * address. + * + * @param netif the netif on which the router advertisement arrived + * @param prefix_opt a pointer to the prefix option data + * @param prefix_addr an aligned copy of the prefix address + */ +static void +nd6_process_autoconfig_prefix(struct netif *netif, + struct prefix_option *prefix_opt, const ip6_addr_t *prefix_addr) +{ + ip6_addr_t ip6addr; + u32_t valid_life, pref_life; + u8_t addr_state; + s8_t i, free_idx; + + /* The caller already checks RFC 4862 Sec. 5.5.3 points (a) and (b). We do + * the rest, starting with checks for (c) and (d) here. */ + valid_life = lwip_htonl(prefix_opt->valid_lifetime); + pref_life = lwip_htonl(prefix_opt->preferred_lifetime); + if (pref_life > valid_life || prefix_opt->prefix_length != 64) { + return; /* silently ignore this prefix for autoconfiguration purposes */ + } + + /* If an autogenerated address already exists for this prefix, update its + * lifetimes. An address is considered autogenerated if 1) it is not static + * (i.e., manually assigned), and 2) there is an advertised autoconfiguration + * prefix for it (the one we are processing here). This does not necessarily + * exclude the possibility that the address was actually assigned by, say, + * DHCPv6. If that distinction becomes important in the future, more state + * must be kept. As explained elsewhere we also update lifetimes of tentative + * and duplicate addresses. Skip address slot 0 (the link-local address). */ + for (i = 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + addr_state = netif_ip6_addr_state(netif, i); + if (!ip6_addr_isinvalid(addr_state) && !netif_ip6_addr_isstatic(netif, i) && + ip6_addr_netcmp(prefix_addr, netif_ip6_addr(netif, i))) { + /* Update the valid lifetime, as per RFC 4862 Sec. 5.5.3 point (e). + * The valid lifetime will never drop to zero as a result of this. */ + u32_t remaining_life = netif_ip6_addr_valid_life(netif, i); + if (valid_life > ND6_2HRS || valid_life > remaining_life) { + netif_ip6_addr_set_valid_life(netif, i, valid_life); + } else if (remaining_life > ND6_2HRS) { + netif_ip6_addr_set_valid_life(netif, i, ND6_2HRS); + } + LWIP_ASSERT("bad valid lifetime", !netif_ip6_addr_isstatic(netif, i)); + /* Update the preferred lifetime. No bounds checks are needed here. In + * rare cases the advertisement may un-deprecate the address, though. + * Deprecation is left to the timer code where it is handled anyway. */ + if (pref_life > 0 && addr_state == IP6_ADDR_DEPRECATED) { + netif_ip6_addr_set_state(netif, i, IP6_ADDR_PREFERRED); + } + netif_ip6_addr_set_pref_life(netif, i, pref_life); + return; /* there should be at most one matching address */ + } + } + + /* No autogenerated address exists for this prefix yet. See if we can add a + * new one. However, if IPv6 autoconfiguration is administratively disabled, + * do not generate new addresses, but do keep updating lifetimes for existing + * addresses. Also, when adding new addresses, we must protect explicitly + * against a valid lifetime of zero, because again, we use that as a special + * value. The generated address would otherwise expire immediately anyway. + * Finally, the original link-local address must be usable at all. We start + * creating addresses even if the link-local address is still in tentative + * state though, and deal with the fallout of that upon DAD collision. */ + addr_state = netif_ip6_addr_state(netif, 0); + if (!netif->ip6_autoconfig_enabled || valid_life == IP6_ADDR_LIFE_STATIC || + ip6_addr_isinvalid(addr_state) || ip6_addr_isduplicated(addr_state)) { + return; + } + + /* Construct the new address that we intend to use, and then see if that + * address really does not exist. It might have been added manually, after + * all. As a side effect, find a free slot. Note that we cannot use + * netif_add_ip6_address() here, as it would return ERR_OK if the address + * already did exist, resulting in that address being given lifetimes. */ + IP6_ADDR(&ip6addr, prefix_addr->addr[0], prefix_addr->addr[1], + netif_ip6_addr(netif, 0)->addr[2], netif_ip6_addr(netif, 0)->addr[3]); + ip6_addr_assign_zone(&ip6addr, IP6_UNICAST, netif); + + free_idx = 0; + for (i = 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (!ip6_addr_isinvalid(netif_ip6_addr_state(netif, i))) { + if (ip6_addr_cmp(&ip6addr, netif_ip6_addr(netif, i))) { + return; /* formed address already exists */ + } + } else if (free_idx == 0) { + free_idx = i; + } + } + if (free_idx == 0) { + return; /* no address slots available, try again on next advertisement */ + } + + /* Assign the new address to the interface. */ + ip_addr_copy_from_ip6(netif->ip6_addr[free_idx], ip6addr); + netif_ip6_addr_set_valid_life(netif, free_idx, valid_life); + netif_ip6_addr_set_pref_life(netif, free_idx, pref_life); + netif_ip6_addr_set_state(netif, free_idx, IP6_ADDR_TENTATIVE); +} +#endif /* LWIP_IPV6_AUTOCONFIG */ + +/** + * Process an incoming neighbor discovery message + * + * @param p the nd packet, p->payload pointing to the icmpv6 header + * @param inp the netif on which this packet was received + */ +void +nd6_input(struct pbuf *p, struct netif *inp) +{ + u8_t msg_type; + s8_t i; + s16_t dest_idx; + + ND6_STATS_INC(nd6.recv); + + msg_type = *((u8_t *)p->payload); + switch (msg_type) { + case ICMP6_TYPE_NA: /* Neighbor Advertisement. */ + { + struct na_header *na_hdr; + struct lladdr_option *lladdr_opt; + ip6_addr_t target_address; + + /* Check that na header fits in packet. */ + if (p->len < (sizeof(struct na_header))) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + na_hdr = (struct na_header *)p->payload; + + /* Create an aligned, zoned copy of the target address. */ + ip6_addr_copy_from_packed(target_address, na_hdr->target_address); + ip6_addr_assign_zone(&target_address, IP6_UNICAST, inp); + + /* Check a subset of the other RFC 4861 Sec. 7.1.2 requirements. */ + if (IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || na_hdr->code != 0 || + ip6_addr_ismulticast(&target_address)) { + pbuf_free(p); + ND6_STATS_INC(nd6.proterr); + ND6_STATS_INC(nd6.drop); + return; + } + + /* @todo RFC MUST: if IP destination is multicast, Solicited flag is zero */ + /* @todo RFC MUST: all included options have a length greater than zero */ + + /* Unsolicited NA?*/ + if (ip6_addr_ismulticast(ip6_current_dest_addr())) { + /* This is an unsolicited NA. + * link-layer changed? + * part of DAD mechanism? */ + +#if LWIP_IPV6_DUP_DETECT_ATTEMPTS + /* If the target address matches this netif, it is a DAD response. */ + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (!ip6_addr_isinvalid(netif_ip6_addr_state(inp, i)) && + !ip6_addr_isduplicated(netif_ip6_addr_state(inp, i)) && + ip6_addr_cmp(&target_address, netif_ip6_addr(inp, i))) { + /* We are using a duplicate address. */ + nd6_duplicate_addr_detected(inp, i); + + pbuf_free(p); + return; + } + } +#endif /* LWIP_IPV6_DUP_DETECT_ATTEMPTS */ + + /* Check that link-layer address option also fits in packet. */ + if (p->len < (sizeof(struct na_header) + 2)) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct na_header)); + + if (p->len < (sizeof(struct na_header) + (lladdr_opt->length << 3))) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + /* This is an unsolicited NA, most likely there was a LLADDR change. */ + i = nd6_find_neighbor_cache_entry(&target_address); + if (i >= 0) { + if (na_hdr->flags & ND6_FLAG_OVERRIDE) { + MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); + } + } + } else { + /* This is a solicited NA. + * neighbor address resolution response? + * neighbor unreachability detection response? */ + + /* Find the cache entry corresponding to this na. */ + i = nd6_find_neighbor_cache_entry(&target_address); + if (i < 0) { + /* We no longer care about this target address. drop it. */ + pbuf_free(p); + return; + } + + /* Update cache entry. */ + if ((na_hdr->flags & ND6_FLAG_OVERRIDE) || + (neighbor_cache[i].state == ND6_INCOMPLETE)) { + /* Check that link-layer address option also fits in packet. */ + if (p->len < (sizeof(struct na_header) + 2)) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct na_header)); + + if (p->len < (sizeof(struct na_header) + (lladdr_opt->length << 3))) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); + } + + neighbor_cache[i].netif = inp; + neighbor_cache[i].state = ND6_REACHABLE; + neighbor_cache[i].counter.reachable_time = reachable_time; + + /* Send queued packets, if any. */ + if (neighbor_cache[i].q != NULL) { + nd6_send_q(i); + } + } + + break; /* ICMP6_TYPE_NA */ + } + case ICMP6_TYPE_NS: /* Neighbor solicitation. */ + { + struct ns_header *ns_hdr; + struct lladdr_option *lladdr_opt; + ip6_addr_t target_address; + u8_t accepted; + + /* Check that ns header fits in packet. */ + if (p->len < sizeof(struct ns_header)) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + ns_hdr = (struct ns_header *)p->payload; + + /* Create an aligned, zoned copy of the target address. */ + ip6_addr_copy_from_packed(target_address, ns_hdr->target_address); + ip6_addr_assign_zone(&target_address, IP6_UNICAST, inp); + + /* Check a subset of the other RFC 4861 Sec. 7.1.1 requirements. */ + if (IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || ns_hdr->code != 0 || + ip6_addr_ismulticast(&target_address)) { + pbuf_free(p); + ND6_STATS_INC(nd6.proterr); + ND6_STATS_INC(nd6.drop); + return; + } + + /* @todo RFC MUST: all included options have a length greater than zero */ + /* @todo RFC MUST: if IP source is 'any', destination is solicited-node multicast address */ + /* @todo RFC MUST: if IP source is 'any', there is no source LL address option */ + + /* Check if there is a link-layer address provided. Only point to it if in this buffer. */ + if (p->len >= (sizeof(struct ns_header) + 2)) { + lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct ns_header)); + if (p->len < (sizeof(struct ns_header) + (lladdr_opt->length << 3))) { + lladdr_opt = NULL; + } + } else { + lladdr_opt = NULL; + } + + /* Check if the target address is configured on the receiving netif. */ + accepted = 0; + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; ++i) { + if ((ip6_addr_isvalid(netif_ip6_addr_state(inp, i)) || + (ip6_addr_istentative(netif_ip6_addr_state(inp, i)) && + ip6_addr_isany(ip6_current_src_addr()))) && + ip6_addr_cmp(&target_address, netif_ip6_addr(inp, i))) { + accepted = 1; + break; + } + } + + /* NS not for us? */ + if (!accepted) { + pbuf_free(p); + return; + } + + /* Check for ANY address in src (DAD algorithm). */ + if (ip6_addr_isany(ip6_current_src_addr())) { + /* Sender is validating this address. */ + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; ++i) { + if (!ip6_addr_isinvalid(netif_ip6_addr_state(inp, i)) && + ip6_addr_cmp(&target_address, netif_ip6_addr(inp, i))) { + /* Send a NA back so that the sender does not use this address. */ + nd6_send_na(inp, netif_ip6_addr(inp, i), ND6_FLAG_OVERRIDE | ND6_SEND_FLAG_ALLNODES_DEST); + if (ip6_addr_istentative(netif_ip6_addr_state(inp, i))) { + /* We shouldn't use this address either. */ + nd6_duplicate_addr_detected(inp, i); + } + } + } + } else { + /* Sender is trying to resolve our address. */ + /* Verify that they included their own link-layer address. */ + if (lladdr_opt == NULL) { + /* Not a valid message. */ + pbuf_free(p); + ND6_STATS_INC(nd6.proterr); + ND6_STATS_INC(nd6.drop); + return; + } + + i = nd6_find_neighbor_cache_entry(ip6_current_src_addr()); + if (i>= 0) { + /* We already have a record for the solicitor. */ + if (neighbor_cache[i].state == ND6_INCOMPLETE) { + neighbor_cache[i].netif = inp; + MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); + + /* Delay probe in case we get confirmation of reachability from upper layer (TCP). */ + neighbor_cache[i].state = ND6_DELAY; + neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; + } + } else { + /* Add their IPv6 address and link-layer address to neighbor cache. + * We will need it at least to send a unicast NA message, but most + * likely we will also be communicating with this node soon. */ + i = nd6_new_neighbor_cache_entry(); + if (i < 0) { + /* We couldn't assign a cache entry for this neighbor. + * we won't be able to reply. drop it. */ + pbuf_free(p); + ND6_STATS_INC(nd6.memerr); + return; + } + neighbor_cache[i].netif = inp; + MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); + ip6_addr_set(&(neighbor_cache[i].next_hop_address), ip6_current_src_addr()); + + /* Receiving a message does not prove reachability: only in one direction. + * Delay probe in case we get confirmation of reachability from upper layer (TCP). */ + neighbor_cache[i].state = ND6_DELAY; + neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; + } + + /* Send back a NA for us. Allocate the reply pbuf. */ + nd6_send_na(inp, &target_address, ND6_FLAG_SOLICITED | ND6_FLAG_OVERRIDE); + } + + break; /* ICMP6_TYPE_NS */ + } + case ICMP6_TYPE_RA: /* Router Advertisement. */ + { + struct ra_header *ra_hdr; + u8_t *buffer; /* Used to copy options. */ + u16_t offset; +#if LWIP_ND6_RDNSS_MAX_DNS_SERVERS + /* There can be multiple RDNSS options per RA */ + u8_t rdnss_server_idx = 0; +#endif /* LWIP_ND6_RDNSS_MAX_DNS_SERVERS */ + + /* Check that RA header fits in packet. */ + if (p->len < sizeof(struct ra_header)) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + ra_hdr = (struct ra_header *)p->payload; + + /* Check a subset of the other RFC 4861 Sec. 6.1.2 requirements. */ + if (!ip6_addr_islinklocal(ip6_current_src_addr()) || + IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || ra_hdr->code != 0) { + pbuf_free(p); + ND6_STATS_INC(nd6.proterr); + ND6_STATS_INC(nd6.drop); + return; + } + + /* @todo RFC MUST: all included options have a length greater than zero */ + + /* If we are sending RS messages, stop. */ +#if LWIP_IPV6_SEND_ROUTER_SOLICIT + /* ensure at least one solicitation is sent (see RFC 4861, ch. 6.3.7) */ + if ((inp->rs_count < LWIP_ND6_MAX_MULTICAST_SOLICIT) || + (nd6_send_rs(inp) == ERR_OK)) { + inp->rs_count = 0; + } else { + inp->rs_count = 1; + } +#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ + + /* Get the matching default router entry. */ + i = nd6_get_router(ip6_current_src_addr(), inp); + if (i < 0) { + /* Create a new router entry. */ + i = nd6_new_router(ip6_current_src_addr(), inp); + } + + if (i < 0) { + /* Could not create a new router entry. */ + pbuf_free(p); + ND6_STATS_INC(nd6.memerr); + return; + } + + /* Re-set invalidation timer. */ + default_router_list[i].invalidation_timer = lwip_htons(ra_hdr->router_lifetime); + + /* Re-set default timer values. */ +#if LWIP_ND6_ALLOW_RA_UPDATES + if (ra_hdr->retrans_timer > 0) { + retrans_timer = lwip_htonl(ra_hdr->retrans_timer); + } + if (ra_hdr->reachable_time > 0) { + reachable_time = lwip_htonl(ra_hdr->reachable_time); + } +#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ + + /* @todo set default hop limit... */ + /* ra_hdr->current_hop_limit;*/ + + /* Update flags in local entry (incl. preference). */ + default_router_list[i].flags = ra_hdr->flags; + +#if LWIP_IPV6_DHCP6 + /* Trigger DHCPv6 if enabled */ + dhcp6_nd6_ra_trigger(inp, ra_hdr->flags & ND6_RA_FLAG_MANAGED_ADDR_CONFIG, + ra_hdr->flags & ND6_RA_FLAG_OTHER_CONFIG); +#endif + + /* Offset to options. */ + offset = sizeof(struct ra_header); + + /* Process each option. */ + while ((p->tot_len - offset) >= 2) { + u8_t option_type; + u16_t option_len; + int option_len8 = pbuf_try_get_at(p, offset + 1); + if (option_len8 <= 0) { + /* read beyond end or zero length */ + goto lenerr_drop_free_return; + } + option_len = ((u8_t)option_len8) << 3; + if (option_len > p->tot_len - offset) { + /* short packet (option does not fit in) */ + goto lenerr_drop_free_return; + } + if (p->len == p->tot_len) { + /* no need to copy from contiguous pbuf */ + buffer = &((u8_t*)p->payload)[offset]; + } else { + /* check if this option fits into our buffer */ + if (option_len > sizeof(nd6_ra_buffer)) { + option_type = pbuf_get_at(p, offset); + /* invalid option length */ + if (option_type != ND6_OPTION_TYPE_RDNSS) { + goto lenerr_drop_free_return; + } + /* we allow RDNSS option to be longer - we'll just drop some servers */ + option_len = sizeof(nd6_ra_buffer); + } + buffer = (u8_t*)&nd6_ra_buffer; + option_len = pbuf_copy_partial(p, &nd6_ra_buffer, option_len, offset); + } + option_type = buffer[0]; + switch (option_type) { + case ND6_OPTION_TYPE_SOURCE_LLADDR: + { + struct lladdr_option *lladdr_opt; + if (option_len < sizeof(struct lladdr_option)) { + goto lenerr_drop_free_return; + } + lladdr_opt = (struct lladdr_option *)buffer; + if ((default_router_list[i].neighbor_entry != NULL) && + (default_router_list[i].neighbor_entry->state == ND6_INCOMPLETE)) { + SMEMCPY(default_router_list[i].neighbor_entry->lladdr, lladdr_opt->addr, inp->hwaddr_len); + default_router_list[i].neighbor_entry->state = ND6_REACHABLE; + default_router_list[i].neighbor_entry->counter.reachable_time = reachable_time; + } + break; + } + case ND6_OPTION_TYPE_MTU: + { + struct mtu_option *mtu_opt; + u32_t mtu32; + if (option_len < sizeof(struct mtu_option)) { + goto lenerr_drop_free_return; + } + mtu_opt = (struct mtu_option *)buffer; + mtu32 = lwip_htonl(mtu_opt->mtu); + if ((mtu32 >= 1280) && (mtu32 <= 0xffff)) { +#if LWIP_ND6_ALLOW_RA_UPDATES + if (inp->mtu) { + /* don't set the mtu for IPv6 higher than the netif driver supports */ + inp->mtu6 = LWIP_MIN(inp->mtu, (u16_t)mtu32); + } else { + inp->mtu6 = (u16_t)mtu32; + } +#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ + } + break; + } + case ND6_OPTION_TYPE_PREFIX_INFO: + { + struct prefix_option *prefix_opt; + ip6_addr_t prefix_addr; + if (option_len < sizeof(struct prefix_option)) { + goto lenerr_drop_free_return; + } + + prefix_opt = (struct prefix_option *)buffer; + + /* Get a memory-aligned copy of the prefix. */ + ip6_addr_copy_from_packed(prefix_addr, prefix_opt->prefix); + ip6_addr_assign_zone(&prefix_addr, IP6_UNICAST, inp); + + if (!ip6_addr_islinklocal(&prefix_addr)) { + if ((prefix_opt->flags & ND6_PREFIX_FLAG_ON_LINK) && + (prefix_opt->prefix_length == 64)) { + /* Add to on-link prefix list. */ + u32_t valid_life; + s8_t prefix; + + valid_life = lwip_htonl(prefix_opt->valid_lifetime); + + /* find cache entry for this prefix. */ + prefix = nd6_get_onlink_prefix(&prefix_addr, inp); + if (prefix < 0 && valid_life > 0) { + /* Create a new cache entry. */ + prefix = nd6_new_onlink_prefix(&prefix_addr, inp); + } + if (prefix >= 0) { + prefix_list[prefix].invalidation_timer = valid_life; + } + } +#if LWIP_IPV6_AUTOCONFIG + if (prefix_opt->flags & ND6_PREFIX_FLAG_AUTONOMOUS) { + /* Perform processing for autoconfiguration. */ + nd6_process_autoconfig_prefix(inp, prefix_opt, &prefix_addr); + } +#endif /* LWIP_IPV6_AUTOCONFIG */ + } + + break; + } + case ND6_OPTION_TYPE_ROUTE_INFO: + /* @todo implement preferred routes. + struct route_option * route_opt; + route_opt = (struct route_option *)buffer;*/ + + break; +#if LWIP_ND6_RDNSS_MAX_DNS_SERVERS + case ND6_OPTION_TYPE_RDNSS: + { + u8_t num, n; + u16_t copy_offset = offset + SIZEOF_RDNSS_OPTION_BASE; + struct rdnss_option * rdnss_opt; + if (option_len < SIZEOF_RDNSS_OPTION_BASE) { + goto lenerr_drop_free_return; + } + + rdnss_opt = (struct rdnss_option *)buffer; + num = (rdnss_opt->length - 1) / 2; + for (n = 0; (rdnss_server_idx < DNS_MAX_SERVERS) && (n < num); n++) { + ip_addr_t rdnss_address; + + /* Copy directly from pbuf to get an aligned, zoned copy of the prefix. */ + if (pbuf_copy_partial(p, &rdnss_address, sizeof(ip6_addr_p_t), copy_offset) == sizeof(ip6_addr_p_t)) { + IP_SET_TYPE_VAL(rdnss_address, IPADDR_TYPE_V6); + ip6_addr_assign_zone(ip_2_ip6(&rdnss_address), IP6_UNKNOWN, inp); + + if (htonl(rdnss_opt->lifetime) > 0) { + /* TODO implement Lifetime > 0 */ + dns_setserver(rdnss_server_idx++, &rdnss_address); + } else { + /* TODO implement DNS removal in dns.c */ + u8_t s; + for (s = 0; s < DNS_MAX_SERVERS; s++) { + const ip_addr_t *addr = dns_getserver(s); + if(ip_addr_cmp(addr, &rdnss_address)) { + dns_setserver(s, NULL); + } + } + } + } + } + break; + } +#endif /* LWIP_ND6_RDNSS_MAX_DNS_SERVERS */ + default: + /* Unrecognized option, abort. */ + ND6_STATS_INC(nd6.proterr); + break; + } + /* option length is checked earlier to be non-zero to make sure loop ends */ + offset += 8 * (u8_t)option_len8; + } + + break; /* ICMP6_TYPE_RA */ + } + case ICMP6_TYPE_RD: /* Redirect */ + { + struct redirect_header *redir_hdr; + struct lladdr_option *lladdr_opt; + ip6_addr_t destination_address, target_address; + + /* Check that Redir header fits in packet. */ + if (p->len < sizeof(struct redirect_header)) { + /* @todo debug message */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + redir_hdr = (struct redirect_header *)p->payload; + + /* Create an aligned, zoned copy of the destination address. */ + ip6_addr_copy_from_packed(destination_address, redir_hdr->destination_address); + ip6_addr_assign_zone(&destination_address, IP6_UNICAST, inp); + + /* Check a subset of the other RFC 4861 Sec. 8.1 requirements. */ + if (!ip6_addr_islinklocal(ip6_current_src_addr()) || + IP6H_HOPLIM(ip6_current_header()) != ND6_HOPLIM || + redir_hdr->code != 0 || ip6_addr_ismulticast(&destination_address)) { + pbuf_free(p); + ND6_STATS_INC(nd6.proterr); + ND6_STATS_INC(nd6.drop); + return; + } + + /* @todo RFC MUST: IP source address equals first-hop router for destination_address */ + /* @todo RFC MUST: ICMP target address is either link-local address or same as destination_address */ + /* @todo RFC MUST: all included options have a length greater than zero */ + + if (p->len >= (sizeof(struct redirect_header) + 2)) { + lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct redirect_header)); + if (p->len < (sizeof(struct redirect_header) + (lladdr_opt->length << 3))) { + lladdr_opt = NULL; + } + } else { + lladdr_opt = NULL; + } + + /* Find dest address in cache */ + dest_idx = nd6_find_destination_cache_entry(&destination_address); + if (dest_idx < 0) { + /* Destination not in cache, drop packet. */ + pbuf_free(p); + return; + } + + /* Create an aligned, zoned copy of the target address. */ + ip6_addr_copy_from_packed(target_address, redir_hdr->target_address); + ip6_addr_assign_zone(&target_address, IP6_UNICAST, inp); + + /* Set the new target address. */ + ip6_addr_copy(destination_cache[dest_idx].next_hop_addr, target_address); + + /* If Link-layer address of other router is given, try to add to neighbor cache. */ + if (lladdr_opt != NULL) { + if (lladdr_opt->type == ND6_OPTION_TYPE_TARGET_LLADDR) { + i = nd6_find_neighbor_cache_entry(&target_address); + if (i < 0) { + i = nd6_new_neighbor_cache_entry(); + if (i >= 0) { + neighbor_cache[i].netif = inp; + MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); + ip6_addr_copy(neighbor_cache[i].next_hop_address, target_address); + + /* Receiving a message does not prove reachability: only in one direction. + * Delay probe in case we get confirmation of reachability from upper layer (TCP). */ + neighbor_cache[i].state = ND6_DELAY; + neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; + } + } + if (i >= 0) { + if (neighbor_cache[i].state == ND6_INCOMPLETE) { + MEMCPY(neighbor_cache[i].lladdr, lladdr_opt->addr, inp->hwaddr_len); + /* Receiving a message does not prove reachability: only in one direction. + * Delay probe in case we get confirmation of reachability from upper layer (TCP). */ + neighbor_cache[i].state = ND6_DELAY; + neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; + } + } + } + } + break; /* ICMP6_TYPE_RD */ + } + case ICMP6_TYPE_PTB: /* Packet too big */ + { + struct icmp6_hdr *icmp6hdr; /* Packet too big message */ + struct ip6_hdr *ip6hdr; /* IPv6 header of the packet which caused the error */ + u32_t pmtu; + ip6_addr_t destination_address; + + /* Check that ICMPv6 header + IPv6 header fit in payload */ + if (p->len < (sizeof(struct icmp6_hdr) + IP6_HLEN)) { + /* drop short packets */ + pbuf_free(p); + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + return; + } + + icmp6hdr = (struct icmp6_hdr *)p->payload; + ip6hdr = (struct ip6_hdr *)((u8_t*)p->payload + sizeof(struct icmp6_hdr)); + + /* Create an aligned, zoned copy of the destination address. */ + ip6_addr_copy_from_packed(destination_address, ip6hdr->dest); + ip6_addr_assign_zone(&destination_address, IP6_UNKNOWN, inp); + + /* Look for entry in destination cache. */ + dest_idx = nd6_find_destination_cache_entry(&destination_address); + if (dest_idx < 0) { + /* Destination not in cache, drop packet. */ + pbuf_free(p); + return; + } + + /* Change the Path MTU. */ + pmtu = lwip_htonl(icmp6hdr->data); + destination_cache[dest_idx].pmtu = (u16_t)LWIP_MIN(pmtu, 0xFFFF); + + break; /* ICMP6_TYPE_PTB */ + } + + default: + ND6_STATS_INC(nd6.proterr); + ND6_STATS_INC(nd6.drop); + break; /* default */ + } + + pbuf_free(p); + return; +lenerr_drop_free_return: + ND6_STATS_INC(nd6.lenerr); + ND6_STATS_INC(nd6.drop); + pbuf_free(p); +} + + +/** + * Periodic timer for Neighbor discovery functions: + * + * - Update neighbor reachability states + * - Update destination cache entries age + * - Update invalidation timers of default routers and on-link prefixes + * - Update lifetimes of our addresses + * - Perform duplicate address detection (DAD) for our addresses + * - Send router solicitations + */ +void +nd6_tmr(void) +{ + s8_t i; + struct netif *netif; + + /* Process neighbor entries. */ + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + switch (neighbor_cache[i].state) { + case ND6_INCOMPLETE: + if ((neighbor_cache[i].counter.probes_sent >= LWIP_ND6_MAX_MULTICAST_SOLICIT) && + (!neighbor_cache[i].isrouter)) { + /* Retries exceeded. */ + nd6_free_neighbor_cache_entry(i); + } else { + /* Send a NS for this entry. */ + neighbor_cache[i].counter.probes_sent++; + nd6_send_neighbor_cache_probe(&neighbor_cache[i], ND6_SEND_FLAG_MULTICAST_DEST); + } + break; + case ND6_REACHABLE: + /* Send queued packets, if any are left. Should have been sent already. */ + if (neighbor_cache[i].q != NULL) { + nd6_send_q(i); + } + if (neighbor_cache[i].counter.reachable_time <= ND6_TMR_INTERVAL) { + /* Change to stale state. */ + neighbor_cache[i].state = ND6_STALE; + neighbor_cache[i].counter.stale_time = 0; + } else { + neighbor_cache[i].counter.reachable_time -= ND6_TMR_INTERVAL; + } + break; + case ND6_STALE: + neighbor_cache[i].counter.stale_time++; + break; + case ND6_DELAY: + if (neighbor_cache[i].counter.delay_time <= 1) { + /* Change to PROBE state. */ + neighbor_cache[i].state = ND6_PROBE; + neighbor_cache[i].counter.probes_sent = 0; + } else { + neighbor_cache[i].counter.delay_time--; + } + break; + case ND6_PROBE: + if ((neighbor_cache[i].counter.probes_sent >= LWIP_ND6_MAX_MULTICAST_SOLICIT) && + (!neighbor_cache[i].isrouter)) { + /* Retries exceeded. */ + nd6_free_neighbor_cache_entry(i); + } else { + /* Send a NS for this entry. */ + neighbor_cache[i].counter.probes_sent++; + nd6_send_neighbor_cache_probe(&neighbor_cache[i], 0); + } + break; + case ND6_NO_ENTRY: + default: + /* Do nothing. */ + break; + } + } + + /* Process destination entries. */ + for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { + destination_cache[i].age++; + } + + /* Process router entries. */ + for (i = 0; i < LWIP_ND6_NUM_ROUTERS; i++) { + if (default_router_list[i].neighbor_entry != NULL) { + /* Active entry. */ + if (default_router_list[i].invalidation_timer <= ND6_TMR_INTERVAL / 1000) { + /* No more than 1 second remaining. Clear this entry. Also clear any of + * its destination cache entries, as per RFC 4861 Sec. 5.3 and 6.3.5. */ + s8_t j; + for (j = 0; j < LWIP_ND6_NUM_DESTINATIONS; j++) { + if (ip6_addr_cmp(&destination_cache[j].next_hop_addr, + &default_router_list[i].neighbor_entry->next_hop_address)) { + ip6_addr_set_any(&destination_cache[j].destination_addr); + } + } + default_router_list[i].neighbor_entry->isrouter = 0; + default_router_list[i].neighbor_entry = NULL; + default_router_list[i].invalidation_timer = 0; + default_router_list[i].flags = 0; + } else { + default_router_list[i].invalidation_timer -= ND6_TMR_INTERVAL / 1000; + } + } + } + + /* Process prefix entries. */ + for (i = 0; i < LWIP_ND6_NUM_PREFIXES; i++) { + if (prefix_list[i].netif != NULL) { + if (prefix_list[i].invalidation_timer <= ND6_TMR_INTERVAL / 1000) { + /* Entry timed out, remove it */ + prefix_list[i].invalidation_timer = 0; + prefix_list[i].netif = NULL; + } else { + prefix_list[i].invalidation_timer -= ND6_TMR_INTERVAL / 1000; + } + } + } + + /* Process our own addresses, updating address lifetimes and/or DAD state. */ + NETIF_FOREACH(netif) { + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; ++i) { + u8_t addr_state; +#if LWIP_IPV6_ADDRESS_LIFETIMES + /* Step 1: update address lifetimes (valid and preferred). */ + addr_state = netif_ip6_addr_state(netif, i); + /* RFC 4862 is not entirely clear as to whether address lifetimes affect + * tentative addresses, and is even less clear as to what should happen + * with duplicate addresses. We choose to track and update lifetimes for + * both those types, although for different reasons: + * - for tentative addresses, the line of thought of Sec. 5.7 combined + * with the potentially long period that an address may be in tentative + * state (due to the interface being down) suggests that lifetimes + * should be independent of external factors which would include DAD; + * - for duplicate addresses, retiring them early could result in a new + * but unwanted attempt at marking them as valid, while retiring them + * late/never could clog up address slots on the netif. + * As a result, we may end up expiring addresses of either type here. + */ + if (!ip6_addr_isinvalid(addr_state) && + !netif_ip6_addr_isstatic(netif, i)) { + u32_t life = netif_ip6_addr_valid_life(netif, i); + if (life <= ND6_TMR_INTERVAL / 1000) { + /* The address has expired. */ + netif_ip6_addr_set_valid_life(netif, i, 0); + netif_ip6_addr_set_pref_life(netif, i, 0); + netif_ip6_addr_set_state(netif, i, IP6_ADDR_INVALID); + } else { + if (!ip6_addr_life_isinfinite(life)) { + life -= ND6_TMR_INTERVAL / 1000; + LWIP_ASSERT("bad valid lifetime", life != IP6_ADDR_LIFE_STATIC); + netif_ip6_addr_set_valid_life(netif, i, life); + } + /* The address is still here. Update the preferred lifetime too. */ + life = netif_ip6_addr_pref_life(netif, i); + if (life <= ND6_TMR_INTERVAL / 1000) { + /* This case must also trigger if 'life' was already zero, so as to + * deal correctly with advertised preferred-lifetime reductions. */ + netif_ip6_addr_set_pref_life(netif, i, 0); + if (addr_state == IP6_ADDR_PREFERRED) + netif_ip6_addr_set_state(netif, i, IP6_ADDR_DEPRECATED); + } else if (!ip6_addr_life_isinfinite(life)) { + life -= ND6_TMR_INTERVAL / 1000; + netif_ip6_addr_set_pref_life(netif, i, life); + } + } + } + /* The address state may now have changed, so reobtain it next. */ +#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ + /* Step 2: update DAD state. */ + addr_state = netif_ip6_addr_state(netif, i); + if (ip6_addr_istentative(addr_state)) { + if ((addr_state & IP6_ADDR_TENTATIVE_COUNT_MASK) >= LWIP_IPV6_DUP_DETECT_ATTEMPTS) { + /* No NA received in response. Mark address as valid. For dynamic + * addresses with an expired preferred lifetime, the state is set to + * deprecated right away. That should almost never happen, though. */ + addr_state = IP6_ADDR_PREFERRED; +#if LWIP_IPV6_ADDRESS_LIFETIMES + if (!netif_ip6_addr_isstatic(netif, i) && + netif_ip6_addr_pref_life(netif, i) == 0) { + addr_state = IP6_ADDR_DEPRECATED; + } +#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ + netif_ip6_addr_set_state(netif, i, addr_state); + } else if (netif_is_up(netif) && netif_is_link_up(netif)) { + /* tentative: set next state by increasing by one */ + netif_ip6_addr_set_state(netif, i, addr_state + 1); + /* Send a NS for this address. Use the unspecified address as source + * address in all cases (RFC 4862 Sec. 5.4.2), not in the least + * because as it is, we only consider multicast replies for DAD. */ + nd6_send_ns(netif, netif_ip6_addr(netif, i), + ND6_SEND_FLAG_MULTICAST_DEST | ND6_SEND_FLAG_ANY_SRC); + } + } + } + } + +#if LWIP_IPV6_SEND_ROUTER_SOLICIT + /* Send router solicitation messages, if necessary. */ + if (!nd6_tmr_rs_reduction) { + nd6_tmr_rs_reduction = (ND6_RTR_SOLICITATION_INTERVAL / ND6_TMR_INTERVAL) - 1; + NETIF_FOREACH(netif) { + if ((netif->rs_count > 0) && netif_is_up(netif) && + netif_is_link_up(netif) && + !ip6_addr_isinvalid(netif_ip6_addr_state(netif, 0)) && + !ip6_addr_isduplicated(netif_ip6_addr_state(netif, 0))) { + if (nd6_send_rs(netif) == ERR_OK) { + netif->rs_count--; + } + } + } + } else { + nd6_tmr_rs_reduction--; + } +#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ + +} + +/** Send a neighbor solicitation message for a specific neighbor cache entry + * + * @param entry the neightbor cache entry for wich to send the message + * @param flags one of ND6_SEND_FLAG_* + */ +static void +nd6_send_neighbor_cache_probe(struct nd6_neighbor_cache_entry *entry, u8_t flags) +{ + nd6_send_ns(entry->netif, &entry->next_hop_address, flags); +} + +/** + * Send a neighbor solicitation message + * + * @param netif the netif on which to send the message + * @param target_addr the IPv6 target address for the ND message + * @param flags one of ND6_SEND_FLAG_* + */ +static void +nd6_send_ns(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags) +{ + struct ns_header *ns_hdr; + struct pbuf *p; + const ip6_addr_t *src_addr; + u16_t lladdr_opt_len; + + LWIP_ASSERT("target address is required", target_addr != NULL); + + if (!(flags & ND6_SEND_FLAG_ANY_SRC) && + ip6_addr_isvalid(netif_ip6_addr_state(netif,0))) { + /* Use link-local address as source address. */ + src_addr = netif_ip6_addr(netif, 0); + /* calculate option length (in 8-byte-blocks) */ + lladdr_opt_len = ((netif->hwaddr_len + 2) + 7) >> 3; + } else { + src_addr = IP6_ADDR_ANY6; + /* Option "MUST NOT be included when the source IP address is the unspecified address." */ + lladdr_opt_len = 0; + } + + /* Allocate a packet. */ + p = pbuf_alloc(PBUF_IP, sizeof(struct ns_header) + (lladdr_opt_len << 3), PBUF_RAM); + if (p == NULL) { + ND6_STATS_INC(nd6.memerr); + return; + } + + /* Set fields. */ + ns_hdr = (struct ns_header *)p->payload; + + ns_hdr->type = ICMP6_TYPE_NS; + ns_hdr->code = 0; + ns_hdr->chksum = 0; + ns_hdr->reserved = 0; + ip6_addr_copy_to_packed(ns_hdr->target_address, *target_addr); + + if (lladdr_opt_len != 0) { + struct lladdr_option *lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct ns_header)); + lladdr_opt->type = ND6_OPTION_TYPE_SOURCE_LLADDR; + lladdr_opt->length = (u8_t)lladdr_opt_len; + SMEMCPY(lladdr_opt->addr, netif->hwaddr, netif->hwaddr_len); + } + + /* Generate the solicited node address for the target address. */ + if (flags & ND6_SEND_FLAG_MULTICAST_DEST) { + ip6_addr_set_solicitednode(&multicast_address, target_addr->addr[3]); + ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); + target_addr = &multicast_address; + } + +#if CHECKSUM_GEN_ICMP6 + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { + ns_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, + target_addr); + } +#endif /* CHECKSUM_GEN_ICMP6 */ + + /* Send the packet out. */ + ND6_STATS_INC(nd6.xmit); + ip6_output_if(p, (src_addr == IP6_ADDR_ANY6) ? NULL : src_addr, target_addr, + ND6_HOPLIM, 0, IP6_NEXTH_ICMP6, netif); + pbuf_free(p); +} + +/** + * Send a neighbor advertisement message + * + * @param netif the netif on which to send the message + * @param target_addr the IPv6 target address for the ND message + * @param flags one of ND6_SEND_FLAG_* + */ +static void +nd6_send_na(struct netif *netif, const ip6_addr_t *target_addr, u8_t flags) +{ + struct na_header *na_hdr; + struct lladdr_option *lladdr_opt; + struct pbuf *p; + const ip6_addr_t *src_addr; + const ip6_addr_t *dest_addr; + u16_t lladdr_opt_len; + + LWIP_ASSERT("target address is required", target_addr != NULL); + + /* Use link-local address as source address. */ + /* src_addr = netif_ip6_addr(netif, 0); */ + /* Use target address as source address. */ + src_addr = target_addr; + + /* Allocate a packet. */ + lladdr_opt_len = ((netif->hwaddr_len + 2) >> 3) + (((netif->hwaddr_len + 2) & 0x07) ? 1 : 0); + p = pbuf_alloc(PBUF_IP, sizeof(struct na_header) + (lladdr_opt_len << 3), PBUF_RAM); + if (p == NULL) { + ND6_STATS_INC(nd6.memerr); + return; + } + + /* Set fields. */ + na_hdr = (struct na_header *)p->payload; + lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct na_header)); + + na_hdr->type = ICMP6_TYPE_NA; + na_hdr->code = 0; + na_hdr->chksum = 0; + na_hdr->flags = flags & 0xf0; + na_hdr->reserved[0] = 0; + na_hdr->reserved[1] = 0; + na_hdr->reserved[2] = 0; + ip6_addr_copy_to_packed(na_hdr->target_address, *target_addr); + + lladdr_opt->type = ND6_OPTION_TYPE_TARGET_LLADDR; + lladdr_opt->length = (u8_t)lladdr_opt_len; + SMEMCPY(lladdr_opt->addr, netif->hwaddr, netif->hwaddr_len); + + /* Generate the solicited node address for the target address. */ + if (flags & ND6_SEND_FLAG_MULTICAST_DEST) { + ip6_addr_set_solicitednode(&multicast_address, target_addr->addr[3]); + ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); + dest_addr = &multicast_address; + } else if (flags & ND6_SEND_FLAG_ALLNODES_DEST) { + ip6_addr_set_allnodes_linklocal(&multicast_address); + ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); + dest_addr = &multicast_address; + } else { + dest_addr = ip6_current_src_addr(); + } + +#if CHECKSUM_GEN_ICMP6 + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { + na_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, + dest_addr); + } +#endif /* CHECKSUM_GEN_ICMP6 */ + + /* Send the packet out. */ + ND6_STATS_INC(nd6.xmit); + ip6_output_if(p, src_addr, dest_addr, + ND6_HOPLIM, 0, IP6_NEXTH_ICMP6, netif); + pbuf_free(p); +} + +#if LWIP_IPV6_SEND_ROUTER_SOLICIT +/** + * Send a router solicitation message + * + * @param netif the netif on which to send the message + */ +static err_t +nd6_send_rs(struct netif *netif) +{ + struct rs_header *rs_hdr; + struct lladdr_option *lladdr_opt; + struct pbuf *p; + const ip6_addr_t *src_addr; + err_t err; + u16_t lladdr_opt_len = 0; + + /* Link-local source address, or unspecified address? */ + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, 0))) { + src_addr = netif_ip6_addr(netif, 0); + } else { + src_addr = IP6_ADDR_ANY6; + } + + /* Generate the all routers target address. */ + ip6_addr_set_allrouters_linklocal(&multicast_address); + ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); + + /* Allocate a packet. */ + if (src_addr != IP6_ADDR_ANY6) { + lladdr_opt_len = ((netif->hwaddr_len + 2) >> 3) + (((netif->hwaddr_len + 2) & 0x07) ? 1 : 0); + } + p = pbuf_alloc(PBUF_IP, sizeof(struct rs_header) + (lladdr_opt_len << 3), PBUF_RAM); + if (p == NULL) { + ND6_STATS_INC(nd6.memerr); + return ERR_BUF; + } + + /* Set fields. */ + rs_hdr = (struct rs_header *)p->payload; + + rs_hdr->type = ICMP6_TYPE_RS; + rs_hdr->code = 0; + rs_hdr->chksum = 0; + rs_hdr->reserved = 0; + + if (src_addr != IP6_ADDR_ANY6) { + /* Include our hw address. */ + lladdr_opt = (struct lladdr_option *)((u8_t*)p->payload + sizeof(struct rs_header)); + lladdr_opt->type = ND6_OPTION_TYPE_SOURCE_LLADDR; + lladdr_opt->length = (u8_t)lladdr_opt_len; + SMEMCPY(lladdr_opt->addr, netif->hwaddr, netif->hwaddr_len); + } + +#if CHECKSUM_GEN_ICMP6 + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_ICMP6) { + rs_hdr->chksum = ip6_chksum_pseudo(p, IP6_NEXTH_ICMP6, p->len, src_addr, + &multicast_address); + } +#endif /* CHECKSUM_GEN_ICMP6 */ + + /* Send the packet out. */ + ND6_STATS_INC(nd6.xmit); + + err = ip6_output_if(p, (src_addr == IP6_ADDR_ANY6) ? NULL : src_addr, &multicast_address, + ND6_HOPLIM, 0, IP6_NEXTH_ICMP6, netif); + pbuf_free(p); + + return err; +} +#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ + +/** + * Search for a neighbor cache entry + * + * @param ip6addr the IPv6 address of the neighbor + * @return The neighbor cache entry index that matched, -1 if no + * entry is found + */ +static s8_t +nd6_find_neighbor_cache_entry(const ip6_addr_t *ip6addr) +{ + s8_t i; + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if (ip6_addr_cmp(ip6addr, &(neighbor_cache[i].next_hop_address))) { + return i; + } + } + return -1; +} + +/** + * Create a new neighbor cache entry. + * + * If no unused entry is found, will try to recycle an old entry + * according to ad-hoc "age" heuristic. + * + * @return The neighbor cache entry index that was created, -1 if no + * entry could be created + */ +static s8_t +nd6_new_neighbor_cache_entry(void) +{ + s8_t i; + s8_t j; + u32_t time; + + + /* First, try to find an empty entry. */ + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if (neighbor_cache[i].state == ND6_NO_ENTRY) { + return i; + } + } + + /* We need to recycle an entry. in general, do not recycle if it is a router. */ + + /* Next, try to find a Stale entry. */ + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if ((neighbor_cache[i].state == ND6_STALE) && + (!neighbor_cache[i].isrouter)) { + nd6_free_neighbor_cache_entry(i); + return i; + } + } + + /* Next, try to find a Probe entry. */ + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if ((neighbor_cache[i].state == ND6_PROBE) && + (!neighbor_cache[i].isrouter)) { + nd6_free_neighbor_cache_entry(i); + return i; + } + } + + /* Next, try to find a Delayed entry. */ + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if ((neighbor_cache[i].state == ND6_DELAY) && + (!neighbor_cache[i].isrouter)) { + nd6_free_neighbor_cache_entry(i); + return i; + } + } + + /* Next, try to find the oldest reachable entry. */ + time = 0xfffffffful; + j = -1; + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if ((neighbor_cache[i].state == ND6_REACHABLE) && + (!neighbor_cache[i].isrouter)) { + if (neighbor_cache[i].counter.reachable_time < time) { + j = i; + time = neighbor_cache[i].counter.reachable_time; + } + } + } + if (j >= 0) { + nd6_free_neighbor_cache_entry(j); + return j; + } + + /* Next, find oldest incomplete entry without queued packets. */ + time = 0; + j = -1; + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if ( + (neighbor_cache[i].q == NULL) && + (neighbor_cache[i].state == ND6_INCOMPLETE) && + (!neighbor_cache[i].isrouter)) { + if (neighbor_cache[i].counter.probes_sent >= time) { + j = i; + time = neighbor_cache[i].counter.probes_sent; + } + } + } + if (j >= 0) { + nd6_free_neighbor_cache_entry(j); + return j; + } + + /* Next, find oldest incomplete entry with queued packets. */ + time = 0; + j = -1; + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if ((neighbor_cache[i].state == ND6_INCOMPLETE) && + (!neighbor_cache[i].isrouter)) { + if (neighbor_cache[i].counter.probes_sent >= time) { + j = i; + time = neighbor_cache[i].counter.probes_sent; + } + } + } + if (j >= 0) { + nd6_free_neighbor_cache_entry(j); + return j; + } + + /* No more entries to try. */ + return -1; +} + +/** + * Will free any resources associated with a neighbor cache + * entry, and will mark it as unused. + * + * @param i the neighbor cache entry index to free + */ +static void +nd6_free_neighbor_cache_entry(s8_t i) +{ + if ((i < 0) || (i >= LWIP_ND6_NUM_NEIGHBORS)) { + return; + } + if (neighbor_cache[i].isrouter) { + /* isrouter needs to be cleared before deleting a neighbor cache entry */ + return; + } + + /* Free any queued packets. */ + if (neighbor_cache[i].q != NULL) { + nd6_free_q(neighbor_cache[i].q); + neighbor_cache[i].q = NULL; + } + + neighbor_cache[i].state = ND6_NO_ENTRY; + neighbor_cache[i].isrouter = 0; + neighbor_cache[i].netif = NULL; + neighbor_cache[i].counter.reachable_time = 0; + ip6_addr_set_zero(&(neighbor_cache[i].next_hop_address)); +} + +/** + * Search for a destination cache entry + * + * @param ip6addr the IPv6 address of the destination + * @return The destination cache entry index that matched, -1 if no + * entry is found + */ +static s16_t +nd6_find_destination_cache_entry(const ip6_addr_t *ip6addr) +{ + s16_t i; + + IP6_ADDR_ZONECHECK(ip6addr); + + for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { + if (ip6_addr_cmp(ip6addr, &(destination_cache[i].destination_addr))) { + return i; + } + } + return -1; +} + +/** + * Create a new destination cache entry. If no unused entry is found, + * will recycle oldest entry. + * + * @return The destination cache entry index that was created, -1 if no + * entry was created + */ +static s16_t +nd6_new_destination_cache_entry(void) +{ + s16_t i, j; + u32_t age; + + /* Find an empty entry. */ + for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { + if (ip6_addr_isany(&(destination_cache[i].destination_addr))) { + return i; + } + } + + /* Find oldest entry. */ + age = 0; + j = LWIP_ND6_NUM_DESTINATIONS - 1; + for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { + if (destination_cache[i].age > age) { + j = i; + } + } + + return j; +} + +/** + * Clear the destination cache. + * + * This operation may be necessary for consistency in the light of changing + * local addresses and/or use of the gateway hook. + */ +void +nd6_clear_destination_cache(void) +{ + int i; + + for (i = 0; i < LWIP_ND6_NUM_DESTINATIONS; i++) { + ip6_addr_set_any(&destination_cache[i].destination_addr); + } +} + +/** + * Determine whether an address matches an on-link prefix or the subnet of a + * statically assigned address. + * + * @param ip6addr the IPv6 address to match + * @return 1 if the address is on-link, 0 otherwise + */ +static int +nd6_is_prefix_in_netif(const ip6_addr_t *ip6addr, struct netif *netif) +{ + s8_t i; + + /* Check to see if the address matches an on-link prefix. */ + for (i = 0; i < LWIP_ND6_NUM_PREFIXES; i++) { + if ((prefix_list[i].netif == netif) && + (prefix_list[i].invalidation_timer > 0) && + ip6_addr_netcmp(ip6addr, &(prefix_list[i].prefix))) { + return 1; + } + } + /* Check to see if address prefix matches a manually configured (= static) + * address. Static addresses have an implied /64 subnet assignment. Dynamic + * addresses (from autoconfiguration) have no implied subnet assignment, and + * are thus effectively /128 assignments. See RFC 5942 for more on this. */ + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i)) && + netif_ip6_addr_isstatic(netif, i) && + ip6_addr_netcmp(ip6addr, netif_ip6_addr(netif, i))) { + return 1; + } + } + return 0; +} + +/** + * Select a default router for a destination. + * + * This function is used both for routing and for finding a next-hop target for + * a packet. In the former case, the given netif is NULL, and the returned + * router entry must be for a netif suitable for sending packets (up, link up). + * In the latter case, the given netif is not NULL and restricts router choice. + * + * @param ip6addr the destination address + * @param netif the netif for the outgoing packet, if known + * @return the default router entry index, or -1 if no suitable + * router is found + */ +static s8_t +nd6_select_router(const ip6_addr_t *ip6addr, struct netif *netif) +{ + struct netif *router_netif; + s8_t i, j, valid_router; + static s8_t last_router; + + LWIP_UNUSED_ARG(ip6addr); /* @todo match preferred routes!! (must implement ND6_OPTION_TYPE_ROUTE_INFO) */ + + /* @todo: implement default router preference */ + + /* Look for valid routers. A reachable router is preferred. */ + valid_router = -1; + for (i = 0; i < LWIP_ND6_NUM_ROUTERS; i++) { + /* Is the router netif both set and apppropriate? */ + if (default_router_list[i].neighbor_entry != NULL) { + router_netif = default_router_list[i].neighbor_entry->netif; + if ((router_netif != NULL) && (netif != NULL ? netif == router_netif : + (netif_is_up(router_netif) && netif_is_link_up(router_netif)))) { + /* Is the router valid, i.e., reachable or probably reachable as per + * RFC 4861 Sec. 6.3.6? Note that we will never return a router that + * has no neighbor cache entry, due to the netif association tests. */ + if (default_router_list[i].neighbor_entry->state != ND6_INCOMPLETE) { + /* Is the router known to be reachable? */ + if (default_router_list[i].neighbor_entry->state == ND6_REACHABLE) { + return i; /* valid and reachable - done! */ + } else if (valid_router < 0) { + valid_router = i; /* valid but not known to be reachable */ + } + } + } + } + } + if (valid_router >= 0) { + return valid_router; + } + + /* Look for any router for which we have any information at all. */ + /* last_router is used for round-robin selection of incomplete routers, as + * recommended in RFC 4861 Sec. 6.3.6 point (2). Advance only when picking a + * route, to select the same router as next-hop target in the common case. */ + if ((netif == NULL) && (++last_router >= LWIP_ND6_NUM_ROUTERS)) { + last_router = 0; + } + i = last_router; + for (j = 0; j < LWIP_ND6_NUM_ROUTERS; j++) { + if (default_router_list[i].neighbor_entry != NULL) { + router_netif = default_router_list[i].neighbor_entry->netif; + if ((router_netif != NULL) && (netif != NULL ? netif == router_netif : + (netif_is_up(router_netif) && netif_is_link_up(router_netif)))) { + return i; + } + } + if (++i >= LWIP_ND6_NUM_ROUTERS) { + i = 0; + } + } + + /* no suitable router found. */ + return -1; +} + +/** + * Find a router-announced route to the given destination. This route may be + * based on an on-link prefix or a default router. + * + * If a suitable route is found, the returned netif is guaranteed to be in a + * suitable state (up, link up) to be used for packet transmission. + * + * @param ip6addr the destination IPv6 address + * @return the netif to use for the destination, or NULL if none found + */ +struct netif * +nd6_find_route(const ip6_addr_t *ip6addr) +{ + struct netif *netif; + s8_t i; + + /* @todo decide if it makes sense to check the destination cache first */ + + /* Check if there is a matching on-link prefix. There may be multiple + * matches. Pick the first one that is associated with a suitable netif. */ + for (i = 0; i < LWIP_ND6_NUM_PREFIXES; ++i) { + netif = prefix_list[i].netif; + if ((netif != NULL) && ip6_addr_netcmp(&prefix_list[i].prefix, ip6addr) && + netif_is_up(netif) && netif_is_link_up(netif)) { + return netif; + } + } + + /* No on-link prefix match. Find a router that can forward the packet. */ + i = nd6_select_router(ip6addr, NULL); + if (i >= 0) { + LWIP_ASSERT("selected router must have a neighbor entry", + default_router_list[i].neighbor_entry != NULL); + return default_router_list[i].neighbor_entry->netif; + } + + return NULL; +} + +/** + * Find an entry for a default router. + * + * @param router_addr the IPv6 address of the router + * @param netif the netif on which the router is found, if known + * @return the index of the router entry, or -1 if not found + */ +static s8_t +nd6_get_router(const ip6_addr_t *router_addr, struct netif *netif) +{ + s8_t i; + + IP6_ADDR_ZONECHECK_NETIF(router_addr, netif); + + /* Look for router. */ + for (i = 0; i < LWIP_ND6_NUM_ROUTERS; i++) { + if ((default_router_list[i].neighbor_entry != NULL) && + ((netif != NULL) ? netif == default_router_list[i].neighbor_entry->netif : 1) && + ip6_addr_cmp(router_addr, &(default_router_list[i].neighbor_entry->next_hop_address))) { + return i; + } + } + + /* router not found. */ + return -1; +} + +/** + * Create a new entry for a default router. + * + * @param router_addr the IPv6 address of the router + * @param netif the netif on which the router is connected, if known + * @return the index on the router table, or -1 if could not be created + */ +static s8_t +nd6_new_router(const ip6_addr_t *router_addr, struct netif *netif) +{ + s8_t router_index; + s8_t free_router_index; + s8_t neighbor_index; + + IP6_ADDR_ZONECHECK_NETIF(router_addr, netif); + + /* Do we have a neighbor entry for this router? */ + neighbor_index = nd6_find_neighbor_cache_entry(router_addr); + if (neighbor_index < 0) { + /* Create a neighbor entry for this router. */ + neighbor_index = nd6_new_neighbor_cache_entry(); + if (neighbor_index < 0) { + /* Could not create neighbor entry for this router. */ + return -1; + } + ip6_addr_set(&(neighbor_cache[neighbor_index].next_hop_address), router_addr); + neighbor_cache[neighbor_index].netif = netif; + neighbor_cache[neighbor_index].q = NULL; + neighbor_cache[neighbor_index].state = ND6_INCOMPLETE; + neighbor_cache[neighbor_index].counter.probes_sent = 1; + nd6_send_neighbor_cache_probe(&neighbor_cache[neighbor_index], ND6_SEND_FLAG_MULTICAST_DEST); + } + + /* Mark neighbor as router. */ + neighbor_cache[neighbor_index].isrouter = 1; + + /* Look for empty entry. */ + free_router_index = LWIP_ND6_NUM_ROUTERS; + for (router_index = LWIP_ND6_NUM_ROUTERS - 1; router_index >= 0; router_index--) { + /* check if router already exists (this is a special case for 2 netifs on the same subnet + - e.g. wifi and cable) */ + if(default_router_list[router_index].neighbor_entry == &(neighbor_cache[neighbor_index])){ + return router_index; + } + if (default_router_list[router_index].neighbor_entry == NULL) { + /* remember lowest free index to create a new entry */ + free_router_index = router_index; + } + } + if (free_router_index < LWIP_ND6_NUM_ROUTERS) { + default_router_list[free_router_index].neighbor_entry = &(neighbor_cache[neighbor_index]); + return free_router_index; + } + + /* Could not create a router entry. */ + + /* Mark neighbor entry as not-router. Entry might be useful as neighbor still. */ + neighbor_cache[neighbor_index].isrouter = 0; + + /* router not found. */ + return -1; +} + +/** + * Find the cached entry for an on-link prefix. + * + * @param prefix the IPv6 prefix that is on-link + * @param netif the netif on which the prefix is on-link + * @return the index on the prefix table, or -1 if not found + */ +static s8_t +nd6_get_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif) +{ + s8_t i; + + /* Look for prefix in list. */ + for (i = 0; i < LWIP_ND6_NUM_PREFIXES; ++i) { + if ((ip6_addr_netcmp(&(prefix_list[i].prefix), prefix)) && + (prefix_list[i].netif == netif)) { + return i; + } + } + + /* Entry not available. */ + return -1; +} + +/** + * Creates a new entry for an on-link prefix. + * + * @param prefix the IPv6 prefix that is on-link + * @param netif the netif on which the prefix is on-link + * @return the index on the prefix table, or -1 if not created + */ +static s8_t +nd6_new_onlink_prefix(const ip6_addr_t *prefix, struct netif *netif) +{ + s8_t i; + + /* Create new entry. */ + for (i = 0; i < LWIP_ND6_NUM_PREFIXES; ++i) { + if ((prefix_list[i].netif == NULL) || + (prefix_list[i].invalidation_timer == 0)) { + /* Found empty prefix entry. */ + prefix_list[i].netif = netif; + ip6_addr_set(&(prefix_list[i].prefix), prefix); + return i; + } + } + + /* Entry not available. */ + return -1; +} + +/** + * Determine the next hop for a destination. Will determine if the + * destination is on-link, else a suitable on-link router is selected. + * + * The last entry index is cached for fast entry search. + * + * @param ip6addr the destination address + * @param netif the netif on which the packet will be sent + * @return the neighbor cache entry for the next hop, ERR_RTE if no + * suitable next hop was found, ERR_MEM if no cache entry + * could be created + */ +static s8_t +nd6_get_next_hop_entry(const ip6_addr_t *ip6addr, struct netif *netif) +{ +#ifdef LWIP_HOOK_ND6_GET_GW + const ip6_addr_t *next_hop_addr; +#endif /* LWIP_HOOK_ND6_GET_GW */ + s8_t i; + s16_t dst_idx; + + IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif); + +#if LWIP_NETIF_HWADDRHINT + if (netif->hints != NULL) { + /* per-pcb cached entry was given */ + netif_addr_idx_t addr_hint = netif->hints->addr_hint; + if (addr_hint < LWIP_ND6_NUM_DESTINATIONS) { + nd6_cached_destination_index = addr_hint; + } + } +#endif /* LWIP_NETIF_HWADDRHINT */ + + /* Look for ip6addr in destination cache. */ + if (ip6_addr_cmp(ip6addr, &(destination_cache[nd6_cached_destination_index].destination_addr))) { + /* the cached entry index is the right one! */ + /* do nothing. */ + ND6_STATS_INC(nd6.cachehit); + } else { + /* Search destination cache. */ + dst_idx = nd6_find_destination_cache_entry(ip6addr); + if (dst_idx >= 0) { + /* found destination entry. make it our new cached index. */ + LWIP_ASSERT("type overflow", (size_t)dst_idx < NETIF_ADDR_IDX_MAX); + nd6_cached_destination_index = (netif_addr_idx_t)dst_idx; + } else { + /* Not found. Create a new destination entry. */ + dst_idx = nd6_new_destination_cache_entry(); + if (dst_idx >= 0) { + /* got new destination entry. make it our new cached index. */ + LWIP_ASSERT("type overflow", (size_t)dst_idx < NETIF_ADDR_IDX_MAX); + nd6_cached_destination_index = (netif_addr_idx_t)dst_idx; + } else { + /* Could not create a destination cache entry. */ + return ERR_MEM; + } + + /* Copy dest address to destination cache. */ + ip6_addr_set(&(destination_cache[nd6_cached_destination_index].destination_addr), ip6addr); + + /* Now find the next hop. is it a neighbor? */ + if (ip6_addr_islinklocal(ip6addr) || + nd6_is_prefix_in_netif(ip6addr, netif)) { + /* Destination in local link. */ + destination_cache[nd6_cached_destination_index].pmtu = netif_mtu6(netif); + ip6_addr_copy(destination_cache[nd6_cached_destination_index].next_hop_addr, destination_cache[nd6_cached_destination_index].destination_addr); +#ifdef LWIP_HOOK_ND6_GET_GW + } else if ((next_hop_addr = LWIP_HOOK_ND6_GET_GW(netif, ip6addr)) != NULL) { + /* Next hop for destination provided by hook function. */ + destination_cache[nd6_cached_destination_index].pmtu = netif->mtu; + ip6_addr_set(&destination_cache[nd6_cached_destination_index].next_hop_addr, next_hop_addr); +#endif /* LWIP_HOOK_ND6_GET_GW */ + } else { + /* We need to select a router. */ + i = nd6_select_router(ip6addr, netif); + if (i < 0) { + /* No router found. */ + ip6_addr_set_any(&(destination_cache[nd6_cached_destination_index].destination_addr)); + return ERR_RTE; + } + destination_cache[nd6_cached_destination_index].pmtu = netif_mtu6(netif); /* Start with netif mtu, correct through ICMPv6 if necessary */ + ip6_addr_copy(destination_cache[nd6_cached_destination_index].next_hop_addr, default_router_list[i].neighbor_entry->next_hop_address); + } + } + } + +#if LWIP_NETIF_HWADDRHINT + if (netif->hints != NULL) { + /* per-pcb cached entry was given */ + netif->hints->addr_hint = nd6_cached_destination_index; + } +#endif /* LWIP_NETIF_HWADDRHINT */ + + /* Look in neighbor cache for the next-hop address. */ + if (ip6_addr_cmp(&(destination_cache[nd6_cached_destination_index].next_hop_addr), + &(neighbor_cache[nd6_cached_neighbor_index].next_hop_address))) { + /* Cache hit. */ + /* Do nothing. */ + ND6_STATS_INC(nd6.cachehit); + } else { + i = nd6_find_neighbor_cache_entry(&(destination_cache[nd6_cached_destination_index].next_hop_addr)); + if (i >= 0) { + /* Found a matching record, make it new cached entry. */ + nd6_cached_neighbor_index = i; + } else { + /* Neighbor not in cache. Make a new entry. */ + i = nd6_new_neighbor_cache_entry(); + if (i >= 0) { + /* got new neighbor entry. make it our new cached index. */ + nd6_cached_neighbor_index = i; + } else { + /* Could not create a neighbor cache entry. */ + return ERR_MEM; + } + + /* Initialize fields. */ + ip6_addr_copy(neighbor_cache[i].next_hop_address, + destination_cache[nd6_cached_destination_index].next_hop_addr); + neighbor_cache[i].isrouter = 0; + neighbor_cache[i].netif = netif; + neighbor_cache[i].state = ND6_INCOMPLETE; + neighbor_cache[i].counter.probes_sent = 1; + nd6_send_neighbor_cache_probe(&neighbor_cache[i], ND6_SEND_FLAG_MULTICAST_DEST); + } + } + + /* Reset this destination's age. */ + destination_cache[nd6_cached_destination_index].age = 0; + + return nd6_cached_neighbor_index; +} + +/** + * Queue a packet for a neighbor. + * + * @param neighbor_index the index in the neighbor cache table + * @param q packet to be queued + * @return ERR_OK if succeeded, ERR_MEM if out of memory + */ +static err_t +nd6_queue_packet(s8_t neighbor_index, struct pbuf *q) +{ + err_t result = ERR_MEM; + struct pbuf *p; + int copy_needed = 0; +#if LWIP_ND6_QUEUEING + struct nd6_q_entry *new_entry, *r; +#endif /* LWIP_ND6_QUEUEING */ + + if ((neighbor_index < 0) || (neighbor_index >= LWIP_ND6_NUM_NEIGHBORS)) { + return ERR_ARG; + } + + /* IF q includes a pbuf that must be copied, we have to copy the whole chain + * into a new PBUF_RAM. See the definition of PBUF_NEEDS_COPY for details. */ + p = q; + while (p) { + if (PBUF_NEEDS_COPY(p)) { + copy_needed = 1; + break; + } + p = p->next; + } + if (copy_needed) { + /* copy the whole packet into new pbufs */ + p = pbuf_clone(PBUF_LINK, PBUF_RAM, q); + while ((p == NULL) && (neighbor_cache[neighbor_index].q != NULL)) { + /* Free oldest packet (as per RFC recommendation) */ +#if LWIP_ND6_QUEUEING + r = neighbor_cache[neighbor_index].q; + neighbor_cache[neighbor_index].q = r->next; + r->next = NULL; + nd6_free_q(r); +#else /* LWIP_ND6_QUEUEING */ + pbuf_free(neighbor_cache[neighbor_index].q); + neighbor_cache[neighbor_index].q = NULL; +#endif /* LWIP_ND6_QUEUEING */ + p = pbuf_clone(PBUF_LINK, PBUF_RAM, q); + } + } else { + /* referencing the old pbuf is enough */ + p = q; + pbuf_ref(p); + } + /* packet was copied/ref'd? */ + if (p != NULL) { + /* queue packet ... */ +#if LWIP_ND6_QUEUEING + /* allocate a new nd6 queue entry */ + new_entry = (struct nd6_q_entry *)memp_malloc(MEMP_ND6_QUEUE); + if ((new_entry == NULL) && (neighbor_cache[neighbor_index].q != NULL)) { + /* Free oldest packet (as per RFC recommendation) */ + r = neighbor_cache[neighbor_index].q; + neighbor_cache[neighbor_index].q = r->next; + r->next = NULL; + nd6_free_q(r); + new_entry = (struct nd6_q_entry *)memp_malloc(MEMP_ND6_QUEUE); + } + if (new_entry != NULL) { + new_entry->next = NULL; + new_entry->p = p; + if (neighbor_cache[neighbor_index].q != NULL) { + /* queue was already existent, append the new entry to the end */ + r = neighbor_cache[neighbor_index].q; + while (r->next != NULL) { + r = r->next; + } + r->next = new_entry; + } else { + /* queue did not exist, first item in queue */ + neighbor_cache[neighbor_index].q = new_entry; + } + LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: queued packet %p on neighbor entry %"S16_F"\n", (void *)p, (s16_t)neighbor_index)); + result = ERR_OK; + } else { + /* the pool MEMP_ND6_QUEUE is empty */ + pbuf_free(p); + LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: could not queue a copy of packet %p (out of memory)\n", (void *)p)); + /* { result == ERR_MEM } through initialization */ + } +#else /* LWIP_ND6_QUEUEING */ + /* Queue a single packet. If an older packet is already queued, free it as per RFC. */ + if (neighbor_cache[neighbor_index].q != NULL) { + pbuf_free(neighbor_cache[neighbor_index].q); + } + neighbor_cache[neighbor_index].q = p; + LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: queued packet %p on neighbor entry %"S16_F"\n", (void *)p, (s16_t)neighbor_index)); + result = ERR_OK; +#endif /* LWIP_ND6_QUEUEING */ + } else { + LWIP_DEBUGF(LWIP_DBG_TRACE, ("ipv6: could not queue a copy of packet %p (out of memory)\n", (void *)q)); + /* { result == ERR_MEM } through initialization */ + } + + return result; +} + +#if LWIP_ND6_QUEUEING +/** + * Free a complete queue of nd6 q entries + * + * @param q a queue of nd6_q_entry to free + */ +static void +nd6_free_q(struct nd6_q_entry *q) +{ + struct nd6_q_entry *r; + LWIP_ASSERT("q != NULL", q != NULL); + LWIP_ASSERT("q->p != NULL", q->p != NULL); + while (q) { + r = q; + q = q->next; + LWIP_ASSERT("r->p != NULL", (r->p != NULL)); + pbuf_free(r->p); + memp_free(MEMP_ND6_QUEUE, r); + } +} +#endif /* LWIP_ND6_QUEUEING */ + +/** + * Send queued packets for a neighbor + * + * @param i the neighbor to send packets to + */ +static void +nd6_send_q(s8_t i) +{ + struct ip6_hdr *ip6hdr; + ip6_addr_t dest; +#if LWIP_ND6_QUEUEING + struct nd6_q_entry *q; +#endif /* LWIP_ND6_QUEUEING */ + + if ((i < 0) || (i >= LWIP_ND6_NUM_NEIGHBORS)) { + return; + } + +#if LWIP_ND6_QUEUEING + while (neighbor_cache[i].q != NULL) { + /* remember first in queue */ + q = neighbor_cache[i].q; + /* pop first item off the queue */ + neighbor_cache[i].q = q->next; + /* Get ipv6 header. */ + ip6hdr = (struct ip6_hdr *)(q->p->payload); + /* Create an aligned copy. */ + ip6_addr_copy_from_packed(dest, ip6hdr->dest); + /* Restore the zone, if applicable. */ + ip6_addr_assign_zone(&dest, IP6_UNKNOWN, neighbor_cache[i].netif); + /* send the queued IPv6 packet */ + (neighbor_cache[i].netif)->output_ip6(neighbor_cache[i].netif, q->p, &dest); + /* free the queued IP packet */ + pbuf_free(q->p); + /* now queue entry can be freed */ + memp_free(MEMP_ND6_QUEUE, q); + } +#else /* LWIP_ND6_QUEUEING */ + if (neighbor_cache[i].q != NULL) { + /* Get ipv6 header. */ + ip6hdr = (struct ip6_hdr *)(neighbor_cache[i].q->payload); + /* Create an aligned copy. */ + ip6_addr_copy_from_packed(dest, ip6hdr->dest); + /* Restore the zone, if applicable. */ + ip6_addr_assign_zone(&dest, IP6_UNKNOWN, neighbor_cache[i].netif); + /* send the queued IPv6 packet */ + (neighbor_cache[i].netif)->output_ip6(neighbor_cache[i].netif, neighbor_cache[i].q, &dest); + /* free the queued IP packet */ + pbuf_free(neighbor_cache[i].q); + neighbor_cache[i].q = NULL; + } +#endif /* LWIP_ND6_QUEUEING */ +} + +/** + * A packet is to be transmitted to a specific IPv6 destination on a specific + * interface. Check if we can find the hardware address of the next hop to use + * for the packet. If so, give the hardware address to the caller, which should + * use it to send the packet right away. Otherwise, enqueue the packet for + * later transmission while looking up the hardware address, if possible. + * + * As such, this function returns one of three different possible results: + * + * - ERR_OK with a non-NULL 'hwaddrp': the caller should send the packet now. + * - ERR_OK with a NULL 'hwaddrp': the packet has been enqueued for later. + * - not ERR_OK: something went wrong; forward the error upward in the stack. + * + * @param netif The lwIP network interface on which the IP packet will be sent. + * @param q The pbuf(s) containing the IP packet to be sent. + * @param ip6addr The destination IPv6 address of the packet. + * @param hwaddrp On success, filled with a pointer to a HW address or NULL (meaning + * the packet has been queued). + * @return + * - ERR_OK on success, ERR_RTE if no route was found for the packet, + * or ERR_MEM if low memory conditions prohibit sending the packet at all. + */ +err_t +nd6_get_next_hop_addr_or_queue(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr, const u8_t **hwaddrp) +{ + s8_t i; + + /* Get next hop record. */ + i = nd6_get_next_hop_entry(ip6addr, netif); + if (i < 0) { + /* failed to get a next hop neighbor record. */ + return i; + } + + /* Now that we have a destination record, send or queue the packet. */ + if (neighbor_cache[i].state == ND6_STALE) { + /* Switch to delay state. */ + neighbor_cache[i].state = ND6_DELAY; + neighbor_cache[i].counter.delay_time = LWIP_ND6_DELAY_FIRST_PROBE_TIME / ND6_TMR_INTERVAL; + } + /* @todo should we send or queue if PROBE? send for now, to let unicast NS pass. */ + if ((neighbor_cache[i].state == ND6_REACHABLE) || + (neighbor_cache[i].state == ND6_DELAY) || + (neighbor_cache[i].state == ND6_PROBE)) { + + /* Tell the caller to send out the packet now. */ + *hwaddrp = neighbor_cache[i].lladdr; + return ERR_OK; + } + + /* We should queue packet on this interface. */ + *hwaddrp = NULL; + return nd6_queue_packet(i, q); +} + + +/** + * Get the Path MTU for a destination. + * + * @param ip6addr the destination address + * @param netif the netif on which the packet will be sent + * @return the Path MTU, if known, or the netif default MTU + */ +u16_t +nd6_get_destination_mtu(const ip6_addr_t *ip6addr, struct netif *netif) +{ + s16_t i; + + i = nd6_find_destination_cache_entry(ip6addr); + if (i >= 0) { + if (destination_cache[i].pmtu > 0) { + return destination_cache[i].pmtu; + } + } + + if (netif != NULL) { + return netif_mtu6(netif); + } + + return 1280; /* Minimum MTU */ +} + + +#if LWIP_ND6_TCP_REACHABILITY_HINTS +/** + * Provide the Neighbor discovery process with a hint that a + * destination is reachable. Called by tcp_receive when ACKs are + * received or sent (as per RFC). This is useful to avoid sending + * NS messages every 30 seconds. + * + * @param ip6addr the destination address which is know to be reachable + * by an upper layer protocol (TCP) + */ +void +nd6_reachability_hint(const ip6_addr_t *ip6addr) +{ + s8_t i; + s16_t dst_idx; + + /* Find destination in cache. */ + if (ip6_addr_cmp(ip6addr, &(destination_cache[nd6_cached_destination_index].destination_addr))) { + dst_idx = nd6_cached_destination_index; + ND6_STATS_INC(nd6.cachehit); + } else { + dst_idx = nd6_find_destination_cache_entry(ip6addr); + } + if (dst_idx < 0) { + return; + } + + /* Find next hop neighbor in cache. */ + if (ip6_addr_cmp(&(destination_cache[dst_idx].next_hop_addr), &(neighbor_cache[nd6_cached_neighbor_index].next_hop_address))) { + i = nd6_cached_neighbor_index; + ND6_STATS_INC(nd6.cachehit); + } else { + i = nd6_find_neighbor_cache_entry(&(destination_cache[dst_idx].next_hop_addr)); + } + if (i < 0) { + return; + } + + /* For safety: don't set as reachable if we don't have a LL address yet. Misuse protection. */ + if (neighbor_cache[i].state == ND6_INCOMPLETE || neighbor_cache[i].state == ND6_NO_ENTRY) { + return; + } + + /* Set reachability state. */ + neighbor_cache[i].state = ND6_REACHABLE; + neighbor_cache[i].counter.reachable_time = reachable_time; +} +#endif /* LWIP_ND6_TCP_REACHABILITY_HINTS */ + +/** + * Remove all prefix, neighbor_cache and router entries of the specified netif. + * + * @param netif points to a network interface + */ +void +nd6_cleanup_netif(struct netif *netif) +{ + u8_t i; + s8_t router_index; + for (i = 0; i < LWIP_ND6_NUM_PREFIXES; i++) { + if (prefix_list[i].netif == netif) { + prefix_list[i].netif = NULL; + } + } + for (i = 0; i < LWIP_ND6_NUM_NEIGHBORS; i++) { + if (neighbor_cache[i].netif == netif) { + for (router_index = 0; router_index < LWIP_ND6_NUM_ROUTERS; router_index++) { + if (default_router_list[router_index].neighbor_entry == &neighbor_cache[i]) { + default_router_list[router_index].neighbor_entry = NULL; + default_router_list[router_index].flags = 0; + } + } + neighbor_cache[i].isrouter = 0; + nd6_free_neighbor_cache_entry(i); + } + } + /* Clear the destination cache, since many entries may now have become + * invalid for one of several reasons. As destination cache entries have no + * netif association, use a sledgehammer approach (this can be improved). */ + nd6_clear_destination_cache(); +} + +#if LWIP_IPV6_MLD +/** + * The state of a local IPv6 address entry is about to change. If needed, join + * or leave the solicited-node multicast group for the address. + * + * @param netif The netif that owns the address. + * @param addr_idx The index of the address. + * @param new_state The new (IP6_ADDR_) state for the address. + */ +void +nd6_adjust_mld_membership(struct netif *netif, s8_t addr_idx, u8_t new_state) +{ + u8_t old_state, old_member, new_member; + + old_state = netif_ip6_addr_state(netif, addr_idx); + + /* Determine whether we were, and should be, a member of the solicited-node + * multicast group for this address. For tentative addresses, the group is + * not joined until the address enters the TENTATIVE_1 (or VALID) state. */ + old_member = (old_state != IP6_ADDR_INVALID && old_state != IP6_ADDR_DUPLICATED && old_state != IP6_ADDR_TENTATIVE); + new_member = (new_state != IP6_ADDR_INVALID && new_state != IP6_ADDR_DUPLICATED && new_state != IP6_ADDR_TENTATIVE); + + if (old_member != new_member) { + ip6_addr_set_solicitednode(&multicast_address, netif_ip6_addr(netif, addr_idx)->addr[3]); + ip6_addr_assign_zone(&multicast_address, IP6_MULTICAST, netif); + + if (new_member) { + mld6_joingroup_netif(netif, &multicast_address); + } else { + mld6_leavegroup_netif(netif, &multicast_address); + } + } +} +#endif /* LWIP_IPV6_MLD */ + +/** Netif was added, set up, or reconnected (link up) */ +void +nd6_restart_netif(struct netif *netif) +{ +#if LWIP_IPV6_SEND_ROUTER_SOLICIT + /* Send Router Solicitation messages (see RFC 4861, ch. 6.3.7). */ + netif->rs_count = LWIP_ND6_MAX_MULTICAST_SOLICIT; +#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ +} + +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/mem.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/mem.c index 16fd9849..315fb3c5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/mem.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/mem.c @@ -1,1017 +1,1017 @@ -/** - * @file - * Dynamic memory manager - * - * This is a lightweight replacement for the standard C library malloc(). - * - * If you want to use the standard C library malloc() instead, define - * MEM_LIBC_MALLOC to 1 in your lwipopts.h - * - * To let mem_malloc() use pools (prevents fragmentation and is much faster than - * a heap but might waste some memory), define MEM_USE_POOLS to 1, define - * MEMP_USE_CUSTOM_POOLS to 1 and create a file "lwippools.h" that includes a list - * of pools like this (more pools can be added between _START and _END): - * - * Define three pools with sizes 256, 512, and 1512 bytes - * LWIP_MALLOC_MEMPOOL_START - * LWIP_MALLOC_MEMPOOL(20, 256) - * LWIP_MALLOC_MEMPOOL(10, 512) - * LWIP_MALLOC_MEMPOOL(5, 1512) - * LWIP_MALLOC_MEMPOOL_END - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * Simon Goldschmidt - * - */ - -#include "lwip/opt.h" -#include "lwip/mem.h" -#include "lwip/def.h" -#include "lwip/sys.h" -#include "lwip/stats.h" -#include "lwip/err.h" - -#include - -#if MEM_LIBC_MALLOC -#include /* for malloc()/free() */ -#endif - -/* This is overridable for tests only... */ -#ifndef LWIP_MEM_ILLEGAL_FREE -#define LWIP_MEM_ILLEGAL_FREE(msg) LWIP_ASSERT(msg, 0) -#endif - -#define MEM_STATS_INC_LOCKED(x) SYS_ARCH_LOCKED(MEM_STATS_INC(x)) -#define MEM_STATS_INC_USED_LOCKED(x, y) SYS_ARCH_LOCKED(MEM_STATS_INC_USED(x, y)) -#define MEM_STATS_DEC_USED_LOCKED(x, y) SYS_ARCH_LOCKED(MEM_STATS_DEC_USED(x, y)) - -#if MEM_OVERFLOW_CHECK -#define MEM_SANITY_OFFSET MEM_SANITY_REGION_BEFORE_ALIGNED -#define MEM_SANITY_OVERHEAD (MEM_SANITY_REGION_BEFORE_ALIGNED + MEM_SANITY_REGION_AFTER_ALIGNED) -#else -#define MEM_SANITY_OFFSET 0 -#define MEM_SANITY_OVERHEAD 0 -#endif - -#if MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK -/** - * Check if a mep element was victim of an overflow or underflow - * (e.g. the restricted area after/before it has been altered) - * - * @param p the mem element to check - * @param size allocated size of the element - * @param descr1 description of the element source shown on error - * @param descr2 description of the element source shown on error - */ -void -mem_overflow_check_raw(void *p, size_t size, const char *descr1, const char *descr2) -{ -#if MEM_SANITY_REGION_AFTER_ALIGNED || MEM_SANITY_REGION_BEFORE_ALIGNED - u16_t k; - u8_t *m; - -#if MEM_SANITY_REGION_AFTER_ALIGNED > 0 - m = (u8_t *)p + size; - for (k = 0; k < MEM_SANITY_REGION_AFTER_ALIGNED; k++) { - if (m[k] != 0xcd) { - char errstr[128]; - snprintf(errstr, sizeof(errstr), "detected mem overflow in %s%s", descr1, descr2); - LWIP_ASSERT(errstr, 0); - } - } -#endif /* MEM_SANITY_REGION_AFTER_ALIGNED > 0 */ - -#if MEM_SANITY_REGION_BEFORE_ALIGNED > 0 - m = (u8_t *)p - MEM_SANITY_REGION_BEFORE_ALIGNED; - for (k = 0; k < MEM_SANITY_REGION_BEFORE_ALIGNED; k++) { - if (m[k] != 0xcd) { - char errstr[128]; - snprintf(errstr, sizeof(errstr), "detected mem underflow in %s%s", descr1, descr2); - LWIP_ASSERT(errstr, 0); - } - } -#endif /* MEM_SANITY_REGION_BEFORE_ALIGNED > 0 */ -#else - LWIP_UNUSED_ARG(p); - LWIP_UNUSED_ARG(desc); - LWIP_UNUSED_ARG(descr); -#endif -} - -/** - * Initialize the restricted area of a mem element. - */ -void -mem_overflow_init_raw(void *p, size_t size) -{ -#if MEM_SANITY_REGION_BEFORE_ALIGNED > 0 || MEM_SANITY_REGION_AFTER_ALIGNED > 0 - u8_t *m; -#if MEM_SANITY_REGION_BEFORE_ALIGNED > 0 - m = (u8_t *)p - MEM_SANITY_REGION_BEFORE_ALIGNED; - memset(m, 0xcd, MEM_SANITY_REGION_BEFORE_ALIGNED); -#endif -#if MEM_SANITY_REGION_AFTER_ALIGNED > 0 - m = (u8_t *)p + size; - memset(m, 0xcd, MEM_SANITY_REGION_AFTER_ALIGNED); -#endif -#else /* MEM_SANITY_REGION_BEFORE_ALIGNED > 0 || MEM_SANITY_REGION_AFTER_ALIGNED > 0 */ - LWIP_UNUSED_ARG(p); - LWIP_UNUSED_ARG(desc); -#endif /* MEM_SANITY_REGION_BEFORE_ALIGNED > 0 || MEM_SANITY_REGION_AFTER_ALIGNED > 0 */ -} -#endif /* MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK */ - -#if MEM_LIBC_MALLOC || MEM_USE_POOLS - -/** mem_init is not used when using pools instead of a heap or using - * C library malloc(). - */ -void -mem_init(void) -{ -} - -/** mem_trim is not used when using pools instead of a heap or using - * C library malloc(): we can't free part of a pool element and the stack - * support mem_trim() to return a different pointer - */ -void * -mem_trim(void *mem, mem_size_t size) -{ - LWIP_UNUSED_ARG(size); - return mem; -} -#endif /* MEM_LIBC_MALLOC || MEM_USE_POOLS */ - -#if MEM_LIBC_MALLOC -/* lwIP heap implemented using C library malloc() */ - -/* in case C library malloc() needs extra protection, - * allow these defines to be overridden. - */ -#ifndef mem_clib_free -#define mem_clib_free free -#endif -#ifndef mem_clib_malloc -#define mem_clib_malloc malloc -#endif -#ifndef mem_clib_calloc -#define mem_clib_calloc calloc -#endif - -#if LWIP_STATS && MEM_STATS -#define MEM_LIBC_STATSHELPER_SIZE LWIP_MEM_ALIGN_SIZE(sizeof(mem_size_t)) -#else -#define MEM_LIBC_STATSHELPER_SIZE 0 -#endif - -/** - * Allocate a block of memory with a minimum of 'size' bytes. - * - * @param size is the minimum size of the requested block in bytes. - * @return pointer to allocated memory or NULL if no free memory was found. - * - * Note that the returned value must always be aligned (as defined by MEM_ALIGNMENT). - */ -void * -mem_malloc(mem_size_t size) -{ - void *ret = mem_clib_malloc(size + MEM_LIBC_STATSHELPER_SIZE); - if (ret == NULL) { - MEM_STATS_INC_LOCKED(err); - } else { - LWIP_ASSERT("malloc() must return aligned memory", LWIP_MEM_ALIGN(ret) == ret); -#if LWIP_STATS && MEM_STATS - *(mem_size_t *)ret = size; - ret = (u8_t *)ret + MEM_LIBC_STATSHELPER_SIZE; - MEM_STATS_INC_USED_LOCKED(used, size); -#endif - } - return ret; -} - -/** Put memory back on the heap - * - * @param rmem is the pointer as returned by a previous call to mem_malloc() - */ -void -mem_free(void *rmem) -{ - LWIP_ASSERT("rmem != NULL", (rmem != NULL)); - LWIP_ASSERT("rmem == MEM_ALIGN(rmem)", (rmem == LWIP_MEM_ALIGN(rmem))); -#if LWIP_STATS && MEM_STATS - rmem = (u8_t *)rmem - MEM_LIBC_STATSHELPER_SIZE; - MEM_STATS_DEC_USED_LOCKED(used, *(mem_size_t *)rmem); -#endif - mem_clib_free(rmem); -} - -#elif MEM_USE_POOLS - -/* lwIP heap implemented with different sized pools */ - -/** - * Allocate memory: determine the smallest pool that is big enough - * to contain an element of 'size' and get an element from that pool. - * - * @param size the size in bytes of the memory needed - * @return a pointer to the allocated memory or NULL if the pool is empty - */ -void * -mem_malloc(mem_size_t size) -{ - void *ret; - struct memp_malloc_helper *element = NULL; - memp_t poolnr; - mem_size_t required_size = size + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper)); - - for (poolnr = MEMP_POOL_FIRST; poolnr <= MEMP_POOL_LAST; poolnr = (memp_t)(poolnr + 1)) { - /* is this pool big enough to hold an element of the required size - plus a struct memp_malloc_helper that saves the pool this element came from? */ - if (required_size <= memp_pools[poolnr]->size) { - element = (struct memp_malloc_helper *)memp_malloc(poolnr); - if (element == NULL) { - /* No need to DEBUGF or ASSERT: This error is already taken care of in memp.c */ -#if MEM_USE_POOLS_TRY_BIGGER_POOL - /** Try a bigger pool if this one is empty! */ - if (poolnr < MEMP_POOL_LAST) { - continue; - } -#endif /* MEM_USE_POOLS_TRY_BIGGER_POOL */ - MEM_STATS_INC_LOCKED(err); - return NULL; - } - break; - } - } - if (poolnr > MEMP_POOL_LAST) { - LWIP_ASSERT("mem_malloc(): no pool is that big!", 0); - MEM_STATS_INC_LOCKED(err); - return NULL; - } - - /* save the pool number this element came from */ - element->poolnr = poolnr; - /* and return a pointer to the memory directly after the struct memp_malloc_helper */ - ret = (u8_t *)element + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper)); - -#if MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) - /* truncating to u16_t is safe because struct memp_desc::size is u16_t */ - element->size = (u16_t)size; - MEM_STATS_INC_USED_LOCKED(used, element->size); -#endif /* MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) */ -#if MEMP_OVERFLOW_CHECK - /* initialize unused memory (diff between requested size and selected pool's size) */ - memset((u8_t *)ret + size, 0xcd, memp_pools[poolnr]->size - size); -#endif /* MEMP_OVERFLOW_CHECK */ - return ret; -} - -/** - * Free memory previously allocated by mem_malloc. Loads the pool number - * and calls memp_free with that pool number to put the element back into - * its pool - * - * @param rmem the memory element to free - */ -void -mem_free(void *rmem) -{ - struct memp_malloc_helper *hmem; - - LWIP_ASSERT("rmem != NULL", (rmem != NULL)); - LWIP_ASSERT("rmem == MEM_ALIGN(rmem)", (rmem == LWIP_MEM_ALIGN(rmem))); - - /* get the original struct memp_malloc_helper */ - /* cast through void* to get rid of alignment warnings */ - hmem = (struct memp_malloc_helper *)(void *)((u8_t *)rmem - LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper))); - - LWIP_ASSERT("hmem != NULL", (hmem != NULL)); - LWIP_ASSERT("hmem == MEM_ALIGN(hmem)", (hmem == LWIP_MEM_ALIGN(hmem))); - LWIP_ASSERT("hmem->poolnr < MEMP_MAX", (hmem->poolnr < MEMP_MAX)); - - MEM_STATS_DEC_USED_LOCKED(used, hmem->size); -#if MEMP_OVERFLOW_CHECK - { - u16_t i; - LWIP_ASSERT("MEM_USE_POOLS: invalid chunk size", - hmem->size <= memp_pools[hmem->poolnr]->size); - /* check that unused memory remained untouched (diff between requested size and selected pool's size) */ - for (i = hmem->size; i < memp_pools[hmem->poolnr]->size; i++) { - u8_t data = *((u8_t *)rmem + i); - LWIP_ASSERT("MEM_USE_POOLS: mem overflow detected", data == 0xcd); - } - } -#endif /* MEMP_OVERFLOW_CHECK */ - - /* and put it in the pool we saved earlier */ - memp_free(hmem->poolnr, hmem); -} - -#else /* MEM_USE_POOLS */ -/* lwIP replacement for your libc malloc() */ - -/** - * The heap is made up as a list of structs of this type. - * This does not have to be aligned since for getting its size, - * we only use the macro SIZEOF_STRUCT_MEM, which automatically aligns. - */ -struct mem { - /** index (-> ram[next]) of the next struct */ - mem_size_t next; - /** index (-> ram[prev]) of the previous struct */ - mem_size_t prev; - /** 1: this area is used; 0: this area is unused */ - u8_t used; -#if MEM_OVERFLOW_CHECK - /** this keeps track of the user allocation size for guard checks */ - mem_size_t user_size; -#endif -}; - -/** All allocated blocks will be MIN_SIZE bytes big, at least! - * MIN_SIZE can be overridden to suit your needs. Smaller values save space, - * larger values could prevent too small blocks to fragment the RAM too much. */ -#ifndef MIN_SIZE -#define MIN_SIZE 12 -#endif /* MIN_SIZE */ -/* some alignment macros: we define them here for better source code layout */ -#define MIN_SIZE_ALIGNED LWIP_MEM_ALIGN_SIZE(MIN_SIZE) -#define SIZEOF_STRUCT_MEM LWIP_MEM_ALIGN_SIZE(sizeof(struct mem)) -#define MEM_SIZE_ALIGNED LWIP_MEM_ALIGN_SIZE(MEM_SIZE) - -/** If you want to relocate the heap to external memory, simply define - * LWIP_RAM_HEAP_POINTER as a void-pointer to that location. - * If so, make sure the memory at that location is big enough (see below on - * how that space is calculated). */ -#ifndef LWIP_RAM_HEAP_POINTER -/** the heap. we need one struct mem at the end and some room for alignment */ -LWIP_DECLARE_MEMORY_ALIGNED(ram_heap, MEM_SIZE_ALIGNED + (2U * SIZEOF_STRUCT_MEM)); -#define LWIP_RAM_HEAP_POINTER ram_heap -#endif /* LWIP_RAM_HEAP_POINTER */ - -/** pointer to the heap (ram_heap): for alignment, ram is now a pointer instead of an array */ -static u8_t *ram; -/** the last entry, always unused! */ -static struct mem *ram_end; - -/** concurrent access protection */ -#if !NO_SYS -static sys_mutex_t mem_mutex; -#endif - -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - -static volatile u8_t mem_free_count; - -/* Allow mem_free from other (e.g. interrupt) context */ -#define LWIP_MEM_FREE_DECL_PROTECT() SYS_ARCH_DECL_PROTECT(lev_free) -#define LWIP_MEM_FREE_PROTECT() SYS_ARCH_PROTECT(lev_free) -#define LWIP_MEM_FREE_UNPROTECT() SYS_ARCH_UNPROTECT(lev_free) -#define LWIP_MEM_ALLOC_DECL_PROTECT() SYS_ARCH_DECL_PROTECT(lev_alloc) -#define LWIP_MEM_ALLOC_PROTECT() SYS_ARCH_PROTECT(lev_alloc) -#define LWIP_MEM_ALLOC_UNPROTECT() SYS_ARCH_UNPROTECT(lev_alloc) -#define LWIP_MEM_LFREE_VOLATILE volatile - -#else /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - -/* Protect the heap only by using a mutex */ -#define LWIP_MEM_FREE_DECL_PROTECT() -#define LWIP_MEM_FREE_PROTECT() sys_mutex_lock(&mem_mutex) -#define LWIP_MEM_FREE_UNPROTECT() sys_mutex_unlock(&mem_mutex) -/* mem_malloc is protected using mutex AND LWIP_MEM_ALLOC_PROTECT */ -#define LWIP_MEM_ALLOC_DECL_PROTECT() -#define LWIP_MEM_ALLOC_PROTECT() -#define LWIP_MEM_ALLOC_UNPROTECT() -#define LWIP_MEM_LFREE_VOLATILE - -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - -/** pointer to the lowest free block, this is used for faster search */ -static struct mem * LWIP_MEM_LFREE_VOLATILE lfree; - -#if MEM_SANITY_CHECK -static void mem_sanity(void); -#define MEM_SANITY() mem_sanity() -#else -#define MEM_SANITY() -#endif - -#if MEM_OVERFLOW_CHECK -static void -mem_overflow_init_element(struct mem *mem, mem_size_t user_size) -{ - void *p = (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET; - mem->user_size = user_size; - mem_overflow_init_raw(p, user_size); -} - -static void -mem_overflow_check_element(struct mem *mem) -{ - void *p = (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET; - mem_overflow_check_raw(p, mem->user_size, "heap", ""); -} -#else /* MEM_OVERFLOW_CHECK */ -#define mem_overflow_init_element(mem, size) -#define mem_overflow_check_element(mem) -#endif /* MEM_OVERFLOW_CHECK */ - -static struct mem * -ptr_to_mem(mem_size_t ptr) -{ - return (struct mem *)(void *)&ram[ptr]; -} - -static mem_size_t -mem_to_ptr(void *mem) -{ - return (mem_size_t)((u8_t *)mem - ram); -} - -/** - * "Plug holes" by combining adjacent empty struct mems. - * After this function is through, there should not exist - * one empty struct mem pointing to another empty struct mem. - * - * @param mem this points to a struct mem which just has been freed - * @internal this function is only called by mem_free() and mem_trim() - * - * This assumes access to the heap is protected by the calling function - * already. - */ -static void -plug_holes(struct mem *mem) -{ - struct mem *nmem; - struct mem *pmem; - - LWIP_ASSERT("plug_holes: mem >= ram", (u8_t *)mem >= ram); - LWIP_ASSERT("plug_holes: mem < ram_end", (u8_t *)mem < (u8_t *)ram_end); - LWIP_ASSERT("plug_holes: mem->used == 0", mem->used == 0); - - /* plug hole forward */ - LWIP_ASSERT("plug_holes: mem->next <= MEM_SIZE_ALIGNED", mem->next <= MEM_SIZE_ALIGNED); - - nmem = ptr_to_mem(mem->next); - if (mem != nmem && nmem->used == 0 && (u8_t *)nmem != (u8_t *)ram_end) { - /* if mem->next is unused and not end of ram, combine mem and mem->next */ - if (lfree == nmem) { - lfree = mem; - } - mem->next = nmem->next; - if (nmem->next != MEM_SIZE_ALIGNED) { - ptr_to_mem(nmem->next)->prev = mem_to_ptr(mem); - } - } - - /* plug hole backward */ - pmem = ptr_to_mem(mem->prev); - if (pmem != mem && pmem->used == 0) { - /* if mem->prev is unused, combine mem and mem->prev */ - if (lfree == mem) { - lfree = pmem; - } - pmem->next = mem->next; - if (mem->next != MEM_SIZE_ALIGNED) { - ptr_to_mem(mem->next)->prev = mem_to_ptr(pmem); - } - } -} - -/** - * Zero the heap and initialize start, end and lowest-free - */ -void -mem_init(void) -{ - struct mem *mem; - - LWIP_ASSERT("Sanity check alignment", - (SIZEOF_STRUCT_MEM & (MEM_ALIGNMENT - 1)) == 0); - - /* align the heap */ - ram = (u8_t *)LWIP_MEM_ALIGN(LWIP_RAM_HEAP_POINTER); - /* initialize the start of the heap */ - mem = (struct mem *)(void *)ram; - mem->next = MEM_SIZE_ALIGNED; - mem->prev = 0; - mem->used = 0; - /* initialize the end of the heap */ - ram_end = ptr_to_mem(MEM_SIZE_ALIGNED); - ram_end->used = 1; - ram_end->next = MEM_SIZE_ALIGNED; - ram_end->prev = MEM_SIZE_ALIGNED; - MEM_SANITY(); - - /* initialize the lowest-free pointer to the start of the heap */ - lfree = (struct mem *)(void *)ram; - - MEM_STATS_AVAIL(avail, MEM_SIZE_ALIGNED); - - if (sys_mutex_new(&mem_mutex) != ERR_OK) { - LWIP_ASSERT("failed to create mem_mutex", 0); - } -} - -/* Check if a struct mem is correctly linked. - * If not, double-free is a possible reason. - */ -static int -mem_link_valid(struct mem *mem) -{ - struct mem *nmem, *pmem; - mem_size_t rmem_idx; - rmem_idx = mem_to_ptr(mem); - nmem = ptr_to_mem(mem->next); - pmem = ptr_to_mem(mem->prev); - if ((mem->next > MEM_SIZE_ALIGNED) || (mem->prev > MEM_SIZE_ALIGNED) || - ((mem->prev != rmem_idx) && (pmem->next != rmem_idx)) || - ((nmem != ram_end) && (nmem->prev != rmem_idx))) { - return 0; - } - return 1; -} - -#if MEM_SANITY_CHECK -static void -mem_sanity(void) -{ - struct mem *mem; - u8_t last_used; - - /* begin with first element here */ - mem = (struct mem *)ram; - LWIP_ASSERT("heap element used valid", (mem->used == 0) || (mem->used == 1)); - last_used = mem->used; - LWIP_ASSERT("heap element prev ptr valid", mem->prev == 0); - LWIP_ASSERT("heap element next ptr valid", mem->next <= MEM_SIZE_ALIGNED); - LWIP_ASSERT("heap element next ptr aligned", LWIP_MEM_ALIGN(ptr_to_mem(mem->next) == ptr_to_mem(mem->next))); - - /* check all elements before the end of the heap */ - for (mem = ptr_to_mem(mem->next); - ((u8_t *)mem > ram) && (mem < ram_end); - mem = ptr_to_mem(mem->next)) { - LWIP_ASSERT("heap element aligned", LWIP_MEM_ALIGN(mem) == mem); - LWIP_ASSERT("heap element prev ptr valid", mem->prev <= MEM_SIZE_ALIGNED); - LWIP_ASSERT("heap element next ptr valid", mem->next <= MEM_SIZE_ALIGNED); - LWIP_ASSERT("heap element prev ptr aligned", LWIP_MEM_ALIGN(ptr_to_mem(mem->prev) == ptr_to_mem(mem->prev))); - LWIP_ASSERT("heap element next ptr aligned", LWIP_MEM_ALIGN(ptr_to_mem(mem->next) == ptr_to_mem(mem->next))); - - if (last_used == 0) { - /* 2 unused elements in a row? */ - LWIP_ASSERT("heap element unused?", mem->used == 1); - } else { - LWIP_ASSERT("heap element unused member", (mem->used == 0) || (mem->used == 1)); - } - - LWIP_ASSERT("heap element link valid", mem_link_valid(mem)); - - /* used/unused altering */ - last_used = mem->used; - } - LWIP_ASSERT("heap end ptr sanity", mem == ptr_to_mem(MEM_SIZE_ALIGNED)); - LWIP_ASSERT("heap element used valid", mem->used == 1); - LWIP_ASSERT("heap element prev ptr valid", mem->prev == MEM_SIZE_ALIGNED); - LWIP_ASSERT("heap element next ptr valid", mem->next == MEM_SIZE_ALIGNED); -} -#endif /* MEM_SANITY_CHECK */ - -/** - * Put a struct mem back on the heap - * - * @param rmem is the data portion of a struct mem as returned by a previous - * call to mem_malloc() - */ -void -mem_free(void *rmem) -{ - struct mem *mem; - LWIP_MEM_FREE_DECL_PROTECT(); - - if (rmem == NULL) { - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("mem_free(p == NULL) was called.\n")); - return; - } - if ((((mem_ptr_t)rmem) & (MEM_ALIGNMENT - 1)) != 0) { - LWIP_MEM_ILLEGAL_FREE("mem_free: sanity check alignment"); - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: sanity check alignment\n")); - /* protect mem stats from concurrent access */ - MEM_STATS_INC_LOCKED(illegal); - return; - } - - /* Get the corresponding struct mem: */ - /* cast through void* to get rid of alignment warnings */ - mem = (struct mem *)(void *)((u8_t *)rmem - (SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET)); - - if ((u8_t *)mem < ram || (u8_t *)rmem + MIN_SIZE_ALIGNED > (u8_t *)ram_end) { - LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory"); - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory\n")); - /* protect mem stats from concurrent access */ - MEM_STATS_INC_LOCKED(illegal); - return; - } -#if MEM_OVERFLOW_CHECK - mem_overflow_check_element(mem); -#endif - /* protect the heap from concurrent access */ - LWIP_MEM_FREE_PROTECT(); - /* mem has to be in a used state */ - if (!mem->used) { - LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory: double free"); - LWIP_MEM_FREE_UNPROTECT(); - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory: double free?\n")); - /* protect mem stats from concurrent access */ - MEM_STATS_INC_LOCKED(illegal); - return; - } - - if (!mem_link_valid(mem)) { - LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory: non-linked: double free"); - LWIP_MEM_FREE_UNPROTECT(); - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory: non-linked: double free?\n")); - /* protect mem stats from concurrent access */ - MEM_STATS_INC_LOCKED(illegal); - return; - } - - /* mem is now unused. */ - mem->used = 0; - - if (mem < lfree) { - /* the newly freed struct is now the lowest */ - lfree = mem; - } - - MEM_STATS_DEC_USED(used, mem->next - (mem_size_t)(((u8_t *)mem - ram))); - - /* finally, see if prev or next are free also */ - plug_holes(mem); - MEM_SANITY(); -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - mem_free_count = 1; -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - LWIP_MEM_FREE_UNPROTECT(); -} - -/** - * Shrink memory returned by mem_malloc(). - * - * @param rmem pointer to memory allocated by mem_malloc the is to be shrinked - * @param new_size required size after shrinking (needs to be smaller than or - * equal to the previous size) - * @return for compatibility reasons: is always == rmem, at the moment - * or NULL if newsize is > old size, in which case rmem is NOT touched - * or freed! - */ -void * -mem_trim(void *rmem, mem_size_t new_size) -{ - mem_size_t size, newsize; - mem_size_t ptr, ptr2; - struct mem *mem, *mem2; - /* use the FREE_PROTECT here: it protects with sem OR SYS_ARCH_PROTECT */ - LWIP_MEM_FREE_DECL_PROTECT(); - - /* Expand the size of the allocated memory region so that we can - adjust for alignment. */ - newsize = (mem_size_t)LWIP_MEM_ALIGN_SIZE(new_size); - if (newsize < MIN_SIZE_ALIGNED) { - /* every data block must be at least MIN_SIZE_ALIGNED long */ - newsize = MIN_SIZE_ALIGNED; - } -#if MEM_OVERFLOW_CHECK - newsize += MEM_SANITY_REGION_BEFORE_ALIGNED + MEM_SANITY_REGION_AFTER_ALIGNED; -#endif - if ((newsize > MEM_SIZE_ALIGNED) || (newsize < new_size)) { - return NULL; - } - - LWIP_ASSERT("mem_trim: legal memory", (u8_t *)rmem >= (u8_t *)ram && - (u8_t *)rmem < (u8_t *)ram_end); - - if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) { - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_trim: illegal memory\n")); - /* protect mem stats from concurrent access */ - MEM_STATS_INC_LOCKED(illegal); - return rmem; - } - /* Get the corresponding struct mem ... */ - /* cast through void* to get rid of alignment warnings */ - mem = (struct mem *)(void *)((u8_t *)rmem - (SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET)); -#if MEM_OVERFLOW_CHECK - mem_overflow_check_element(mem); -#endif - /* ... and its offset pointer */ - ptr = mem_to_ptr(mem); - - size = (mem_size_t)((mem_size_t)(mem->next - ptr) - (SIZEOF_STRUCT_MEM + MEM_SANITY_OVERHEAD)); - LWIP_ASSERT("mem_trim can only shrink memory", newsize <= size); - if (newsize > size) { - /* not supported */ - return NULL; - } - if (newsize == size) { - /* No change in size, simply return */ - return rmem; - } - - /* protect the heap from concurrent access */ - LWIP_MEM_FREE_PROTECT(); - - mem2 = ptr_to_mem(mem->next); - if (mem2->used == 0) { - /* The next struct is unused, we can simply move it at little */ - mem_size_t next; - LWIP_ASSERT("invalid next ptr", mem->next != MEM_SIZE_ALIGNED); - /* remember the old next pointer */ - next = mem2->next; - /* create new struct mem which is moved directly after the shrinked mem */ - ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + newsize); - if (lfree == mem2) { - lfree = ptr_to_mem(ptr2); - } - mem2 = ptr_to_mem(ptr2); - mem2->used = 0; - /* restore the next pointer */ - mem2->next = next; - /* link it back to mem */ - mem2->prev = ptr; - /* link mem to it */ - mem->next = ptr2; - /* last thing to restore linked list: as we have moved mem2, - * let 'mem2->next->prev' point to mem2 again. but only if mem2->next is not - * the end of the heap */ - if (mem2->next != MEM_SIZE_ALIGNED) { - ptr_to_mem(mem2->next)->prev = ptr2; - } - MEM_STATS_DEC_USED(used, (size - newsize)); - /* no need to plug holes, we've already done that */ - } else if (newsize + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED <= size) { - /* Next struct is used but there's room for another struct mem with - * at least MIN_SIZE_ALIGNED of data. - * Old size ('size') must be big enough to contain at least 'newsize' plus a struct mem - * ('SIZEOF_STRUCT_MEM') with some data ('MIN_SIZE_ALIGNED'). - * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty - * region that couldn't hold data, but when mem->next gets freed, - * the 2 regions would be combined, resulting in more free memory */ - ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + newsize); - LWIP_ASSERT("invalid next ptr", mem->next != MEM_SIZE_ALIGNED); - mem2 = ptr_to_mem(ptr2); - if (mem2 < lfree) { - lfree = mem2; - } - mem2->used = 0; - mem2->next = mem->next; - mem2->prev = ptr; - mem->next = ptr2; - if (mem2->next != MEM_SIZE_ALIGNED) { - ptr_to_mem(mem2->next)->prev = ptr2; - } - MEM_STATS_DEC_USED(used, (size - newsize)); - /* the original mem->next is used, so no need to plug holes! */ - } - /* else { - next struct mem is used but size between mem and mem2 is not big enough - to create another struct mem - -> don't do anyhting. - -> the remaining space stays unused since it is too small - } */ -#if MEM_OVERFLOW_CHECK - mem_overflow_init_element(mem, new_size); -#endif - MEM_SANITY(); -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - mem_free_count = 1; -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - LWIP_MEM_FREE_UNPROTECT(); - return rmem; -} - -/** - * Allocate a block of memory with a minimum of 'size' bytes. - * - * @param size_in is the minimum size of the requested block in bytes. - * @return pointer to allocated memory or NULL if no free memory was found. - * - * Note that the returned value will always be aligned (as defined by MEM_ALIGNMENT). - */ -void * -mem_malloc(mem_size_t size_in) -{ - mem_size_t ptr, ptr2, size; - struct mem *mem, *mem2; -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - u8_t local_mem_free_count = 0; -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - LWIP_MEM_ALLOC_DECL_PROTECT(); - - if (size_in == 0) { - return NULL; - } - - /* Expand the size of the allocated memory region so that we can - adjust for alignment. */ - size = (mem_size_t)LWIP_MEM_ALIGN_SIZE(size_in); - if (size < MIN_SIZE_ALIGNED) { - /* every data block must be at least MIN_SIZE_ALIGNED long */ - size = MIN_SIZE_ALIGNED; - } -#if MEM_OVERFLOW_CHECK - size += MEM_SANITY_REGION_BEFORE_ALIGNED + MEM_SANITY_REGION_AFTER_ALIGNED; -#endif - if ((size > MEM_SIZE_ALIGNED) || (size < size_in)) { - return NULL; - } - - /* protect the heap from concurrent access */ - sys_mutex_lock(&mem_mutex); - LWIP_MEM_ALLOC_PROTECT(); -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - /* run as long as a mem_free disturbed mem_malloc or mem_trim */ - do { - local_mem_free_count = 0; -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - - /* Scan through the heap searching for a free block that is big enough, - * beginning with the lowest free block. - */ - for (ptr = mem_to_ptr(lfree); ptr < MEM_SIZE_ALIGNED - size; - ptr = ptr_to_mem(ptr)->next) { - mem = ptr_to_mem(ptr); -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - mem_free_count = 0; - LWIP_MEM_ALLOC_UNPROTECT(); - /* allow mem_free or mem_trim to run */ - LWIP_MEM_ALLOC_PROTECT(); - if (mem_free_count != 0) { - /* If mem_free or mem_trim have run, we have to restart since they - could have altered our current struct mem. */ - local_mem_free_count = 1; - break; - } -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - - if ((!mem->used) && - (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) { - /* mem is not used and at least perfect fit is possible: - * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */ - - if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) { - /* (in addition to the above, we test if another struct mem (SIZEOF_STRUCT_MEM) containing - * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem') - * -> split large block, create empty remainder, - * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if - * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size, - * struct mem would fit in but no data between mem2 and mem2->next - * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty - * region that couldn't hold data, but when mem->next gets freed, - * the 2 regions would be combined, resulting in more free memory - */ - ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + size); - LWIP_ASSERT("invalid next ptr",ptr2 != MEM_SIZE_ALIGNED); - /* create mem2 struct */ - mem2 = ptr_to_mem(ptr2); - mem2->used = 0; - mem2->next = mem->next; - mem2->prev = ptr; - /* and insert it between mem and mem->next */ - mem->next = ptr2; - mem->used = 1; - - if (mem2->next != MEM_SIZE_ALIGNED) { - ptr_to_mem(mem2->next)->prev = ptr2; - } - MEM_STATS_INC_USED(used, (size + SIZEOF_STRUCT_MEM)); - } else { - /* (a mem2 struct does no fit into the user data space of mem and mem->next will always - * be used at this point: if not we have 2 unused structs in a row, plug_holes should have - * take care of this). - * -> near fit or exact fit: do not split, no mem2 creation - * also can't move mem->next directly behind mem, since mem->next - * will always be used at this point! - */ - mem->used = 1; - MEM_STATS_INC_USED(used, mem->next - mem_to_ptr(mem)); - } -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT -mem_malloc_adjust_lfree: -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - if (mem == lfree) { - struct mem *cur = lfree; - /* Find next free block after mem and update lowest free pointer */ - while (cur->used && cur != ram_end) { -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - mem_free_count = 0; - LWIP_MEM_ALLOC_UNPROTECT(); - /* prevent high interrupt latency... */ - LWIP_MEM_ALLOC_PROTECT(); - if (mem_free_count != 0) { - /* If mem_free or mem_trim have run, we have to restart since they - could have altered our current struct mem or lfree. */ - goto mem_malloc_adjust_lfree; - } -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - cur = ptr_to_mem(cur->next); - } - lfree = cur; - LWIP_ASSERT("mem_malloc: !lfree->used", ((lfree == ram_end) || (!lfree->used))); - } - LWIP_MEM_ALLOC_UNPROTECT(); - sys_mutex_unlock(&mem_mutex); - LWIP_ASSERT("mem_malloc: allocated memory not above ram_end.", - (mem_ptr_t)mem + SIZEOF_STRUCT_MEM + size <= (mem_ptr_t)ram_end); - LWIP_ASSERT("mem_malloc: allocated memory properly aligned.", - ((mem_ptr_t)mem + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT == 0); - LWIP_ASSERT("mem_malloc: sanity check alignment", - (((mem_ptr_t)mem) & (MEM_ALIGNMENT - 1)) == 0); - -#if MEM_OVERFLOW_CHECK - mem_overflow_init_element(mem, size_in); -#endif - MEM_SANITY(); - return (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET; - } - } -#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT - /* if we got interrupted by a mem_free, try again */ - } while (local_mem_free_count != 0); -#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ - MEM_STATS_INC(err); - LWIP_MEM_ALLOC_UNPROTECT(); - sys_mutex_unlock(&mem_mutex); - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mem_malloc: could not allocate %"S16_F" bytes\n", (s16_t)size)); - return NULL; -} - -#endif /* MEM_USE_POOLS */ - -#if MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) -void * -mem_calloc(mem_size_t count, mem_size_t size) -{ - return mem_clib_calloc(count, size); -} - -#else /* MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) */ -/** - * Contiguously allocates enough space for count objects that are size bytes - * of memory each and returns a pointer to the allocated memory. - * - * The allocated memory is filled with bytes of value zero. - * - * @param count number of objects to allocate - * @param size size of the objects to allocate - * @return pointer to allocated memory / NULL pointer if there is an error - */ -void * -mem_calloc(mem_size_t count, mem_size_t size) -{ - void *p; - size_t alloc_size = (size_t)count * (size_t)size; - - if ((size_t)(mem_size_t)alloc_size != alloc_size) { - LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mem_calloc: could not allocate %"SZT_F" bytes\n", alloc_size)); - return NULL; - } - - /* allocate 'count' objects of size 'size' */ - p = mem_malloc((mem_size_t)alloc_size); - if (p) { - /* zero the memory */ - memset(p, 0, alloc_size); - } - return p; -} -#endif /* MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) */ +/** + * @file + * Dynamic memory manager + * + * This is a lightweight replacement for the standard C library malloc(). + * + * If you want to use the standard C library malloc() instead, define + * MEM_LIBC_MALLOC to 1 in your lwipopts.h + * + * To let mem_malloc() use pools (prevents fragmentation and is much faster than + * a heap but might waste some memory), define MEM_USE_POOLS to 1, define + * MEMP_USE_CUSTOM_POOLS to 1 and create a file "lwippools.h" that includes a list + * of pools like this (more pools can be added between _START and _END): + * + * Define three pools with sizes 256, 512, and 1512 bytes + * LWIP_MALLOC_MEMPOOL_START + * LWIP_MALLOC_MEMPOOL(20, 256) + * LWIP_MALLOC_MEMPOOL(10, 512) + * LWIP_MALLOC_MEMPOOL(5, 1512) + * LWIP_MALLOC_MEMPOOL_END + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * Simon Goldschmidt + * + */ + +#include "lwip/opt.h" +#include "lwip/mem.h" +#include "lwip/def.h" +#include "lwip/sys.h" +#include "lwip/stats.h" +#include "lwip/err.h" + +#include + +#if MEM_LIBC_MALLOC +#include /* for malloc()/free() */ +#endif + +/* This is overridable for tests only... */ +#ifndef LWIP_MEM_ILLEGAL_FREE +#define LWIP_MEM_ILLEGAL_FREE(msg) LWIP_ASSERT(msg, 0) +#endif + +#define MEM_STATS_INC_LOCKED(x) SYS_ARCH_LOCKED(MEM_STATS_INC(x)) +#define MEM_STATS_INC_USED_LOCKED(x, y) SYS_ARCH_LOCKED(MEM_STATS_INC_USED(x, y)) +#define MEM_STATS_DEC_USED_LOCKED(x, y) SYS_ARCH_LOCKED(MEM_STATS_DEC_USED(x, y)) + +#if MEM_OVERFLOW_CHECK +#define MEM_SANITY_OFFSET MEM_SANITY_REGION_BEFORE_ALIGNED +#define MEM_SANITY_OVERHEAD (MEM_SANITY_REGION_BEFORE_ALIGNED + MEM_SANITY_REGION_AFTER_ALIGNED) +#else +#define MEM_SANITY_OFFSET 0 +#define MEM_SANITY_OVERHEAD 0 +#endif + +#if MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK +/** + * Check if a mep element was victim of an overflow or underflow + * (e.g. the restricted area after/before it has been altered) + * + * @param p the mem element to check + * @param size allocated size of the element + * @param descr1 description of the element source shown on error + * @param descr2 description of the element source shown on error + */ +void +mem_overflow_check_raw(void *p, size_t size, const char *descr1, const char *descr2) +{ +#if MEM_SANITY_REGION_AFTER_ALIGNED || MEM_SANITY_REGION_BEFORE_ALIGNED + u16_t k; + u8_t *m; + +#if MEM_SANITY_REGION_AFTER_ALIGNED > 0 + m = (u8_t *)p + size; + for (k = 0; k < MEM_SANITY_REGION_AFTER_ALIGNED; k++) { + if (m[k] != 0xcd) { + char errstr[128]; + snprintf(errstr, sizeof(errstr), "detected mem overflow in %s%s", descr1, descr2); + LWIP_ASSERT(errstr, 0); + } + } +#endif /* MEM_SANITY_REGION_AFTER_ALIGNED > 0 */ + +#if MEM_SANITY_REGION_BEFORE_ALIGNED > 0 + m = (u8_t *)p - MEM_SANITY_REGION_BEFORE_ALIGNED; + for (k = 0; k < MEM_SANITY_REGION_BEFORE_ALIGNED; k++) { + if (m[k] != 0xcd) { + char errstr[128]; + snprintf(errstr, sizeof(errstr), "detected mem underflow in %s%s", descr1, descr2); + LWIP_ASSERT(errstr, 0); + } + } +#endif /* MEM_SANITY_REGION_BEFORE_ALIGNED > 0 */ +#else + LWIP_UNUSED_ARG(p); + LWIP_UNUSED_ARG(desc); + LWIP_UNUSED_ARG(descr); +#endif +} + +/** + * Initialize the restricted area of a mem element. + */ +void +mem_overflow_init_raw(void *p, size_t size) +{ +#if MEM_SANITY_REGION_BEFORE_ALIGNED > 0 || MEM_SANITY_REGION_AFTER_ALIGNED > 0 + u8_t *m; +#if MEM_SANITY_REGION_BEFORE_ALIGNED > 0 + m = (u8_t *)p - MEM_SANITY_REGION_BEFORE_ALIGNED; + memset(m, 0xcd, MEM_SANITY_REGION_BEFORE_ALIGNED); +#endif +#if MEM_SANITY_REGION_AFTER_ALIGNED > 0 + m = (u8_t *)p + size; + memset(m, 0xcd, MEM_SANITY_REGION_AFTER_ALIGNED); +#endif +#else /* MEM_SANITY_REGION_BEFORE_ALIGNED > 0 || MEM_SANITY_REGION_AFTER_ALIGNED > 0 */ + LWIP_UNUSED_ARG(p); + LWIP_UNUSED_ARG(desc); +#endif /* MEM_SANITY_REGION_BEFORE_ALIGNED > 0 || MEM_SANITY_REGION_AFTER_ALIGNED > 0 */ +} +#endif /* MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK */ + +#if MEM_LIBC_MALLOC || MEM_USE_POOLS + +/** mem_init is not used when using pools instead of a heap or using + * C library malloc(). + */ +void +mem_init(void) +{ +} + +/** mem_trim is not used when using pools instead of a heap or using + * C library malloc(): we can't free part of a pool element and the stack + * support mem_trim() to return a different pointer + */ +void * +mem_trim(void *mem, mem_size_t size) +{ + LWIP_UNUSED_ARG(size); + return mem; +} +#endif /* MEM_LIBC_MALLOC || MEM_USE_POOLS */ + +#if MEM_LIBC_MALLOC +/* lwIP heap implemented using C library malloc() */ + +/* in case C library malloc() needs extra protection, + * allow these defines to be overridden. + */ +#ifndef mem_clib_free +#define mem_clib_free free +#endif +#ifndef mem_clib_malloc +#define mem_clib_malloc malloc +#endif +#ifndef mem_clib_calloc +#define mem_clib_calloc calloc +#endif + +#if LWIP_STATS && MEM_STATS +#define MEM_LIBC_STATSHELPER_SIZE LWIP_MEM_ALIGN_SIZE(sizeof(mem_size_t)) +#else +#define MEM_LIBC_STATSHELPER_SIZE 0 +#endif + +/** + * Allocate a block of memory with a minimum of 'size' bytes. + * + * @param size is the minimum size of the requested block in bytes. + * @return pointer to allocated memory or NULL if no free memory was found. + * + * Note that the returned value must always be aligned (as defined by MEM_ALIGNMENT). + */ +void * +mem_malloc(mem_size_t size) +{ + void *ret = mem_clib_malloc(size + MEM_LIBC_STATSHELPER_SIZE); + if (ret == NULL) { + MEM_STATS_INC_LOCKED(err); + } else { + LWIP_ASSERT("malloc() must return aligned memory", LWIP_MEM_ALIGN(ret) == ret); +#if LWIP_STATS && MEM_STATS + *(mem_size_t *)ret = size; + ret = (u8_t *)ret + MEM_LIBC_STATSHELPER_SIZE; + MEM_STATS_INC_USED_LOCKED(used, size); +#endif + } + return ret; +} + +/** Put memory back on the heap + * + * @param rmem is the pointer as returned by a previous call to mem_malloc() + */ +void +mem_free(void *rmem) +{ + LWIP_ASSERT("rmem != NULL", (rmem != NULL)); + LWIP_ASSERT("rmem == MEM_ALIGN(rmem)", (rmem == LWIP_MEM_ALIGN(rmem))); +#if LWIP_STATS && MEM_STATS + rmem = (u8_t *)rmem - MEM_LIBC_STATSHELPER_SIZE; + MEM_STATS_DEC_USED_LOCKED(used, *(mem_size_t *)rmem); +#endif + mem_clib_free(rmem); +} + +#elif MEM_USE_POOLS + +/* lwIP heap implemented with different sized pools */ + +/** + * Allocate memory: determine the smallest pool that is big enough + * to contain an element of 'size' and get an element from that pool. + * + * @param size the size in bytes of the memory needed + * @return a pointer to the allocated memory or NULL if the pool is empty + */ +void * +mem_malloc(mem_size_t size) +{ + void *ret; + struct memp_malloc_helper *element = NULL; + memp_t poolnr; + mem_size_t required_size = size + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper)); + + for (poolnr = MEMP_POOL_FIRST; poolnr <= MEMP_POOL_LAST; poolnr = (memp_t)(poolnr + 1)) { + /* is this pool big enough to hold an element of the required size + plus a struct memp_malloc_helper that saves the pool this element came from? */ + if (required_size <= memp_pools[poolnr]->size) { + element = (struct memp_malloc_helper *)memp_malloc(poolnr); + if (element == NULL) { + /* No need to DEBUGF or ASSERT: This error is already taken care of in memp.c */ +#if MEM_USE_POOLS_TRY_BIGGER_POOL + /** Try a bigger pool if this one is empty! */ + if (poolnr < MEMP_POOL_LAST) { + continue; + } +#endif /* MEM_USE_POOLS_TRY_BIGGER_POOL */ + MEM_STATS_INC_LOCKED(err); + return NULL; + } + break; + } + } + if (poolnr > MEMP_POOL_LAST) { + LWIP_ASSERT("mem_malloc(): no pool is that big!", 0); + MEM_STATS_INC_LOCKED(err); + return NULL; + } + + /* save the pool number this element came from */ + element->poolnr = poolnr; + /* and return a pointer to the memory directly after the struct memp_malloc_helper */ + ret = (u8_t *)element + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper)); + +#if MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) + /* truncating to u16_t is safe because struct memp_desc::size is u16_t */ + element->size = (u16_t)size; + MEM_STATS_INC_USED_LOCKED(used, element->size); +#endif /* MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) */ +#if MEMP_OVERFLOW_CHECK + /* initialize unused memory (diff between requested size and selected pool's size) */ + memset((u8_t *)ret + size, 0xcd, memp_pools[poolnr]->size - size); +#endif /* MEMP_OVERFLOW_CHECK */ + return ret; +} + +/** + * Free memory previously allocated by mem_malloc. Loads the pool number + * and calls memp_free with that pool number to put the element back into + * its pool + * + * @param rmem the memory element to free + */ +void +mem_free(void *rmem) +{ + struct memp_malloc_helper *hmem; + + LWIP_ASSERT("rmem != NULL", (rmem != NULL)); + LWIP_ASSERT("rmem == MEM_ALIGN(rmem)", (rmem == LWIP_MEM_ALIGN(rmem))); + + /* get the original struct memp_malloc_helper */ + /* cast through void* to get rid of alignment warnings */ + hmem = (struct memp_malloc_helper *)(void *)((u8_t *)rmem - LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper))); + + LWIP_ASSERT("hmem != NULL", (hmem != NULL)); + LWIP_ASSERT("hmem == MEM_ALIGN(hmem)", (hmem == LWIP_MEM_ALIGN(hmem))); + LWIP_ASSERT("hmem->poolnr < MEMP_MAX", (hmem->poolnr < MEMP_MAX)); + + MEM_STATS_DEC_USED_LOCKED(used, hmem->size); +#if MEMP_OVERFLOW_CHECK + { + u16_t i; + LWIP_ASSERT("MEM_USE_POOLS: invalid chunk size", + hmem->size <= memp_pools[hmem->poolnr]->size); + /* check that unused memory remained untouched (diff between requested size and selected pool's size) */ + for (i = hmem->size; i < memp_pools[hmem->poolnr]->size; i++) { + u8_t data = *((u8_t *)rmem + i); + LWIP_ASSERT("MEM_USE_POOLS: mem overflow detected", data == 0xcd); + } + } +#endif /* MEMP_OVERFLOW_CHECK */ + + /* and put it in the pool we saved earlier */ + memp_free(hmem->poolnr, hmem); +} + +#else /* MEM_USE_POOLS */ +/* lwIP replacement for your libc malloc() */ + +/** + * The heap is made up as a list of structs of this type. + * This does not have to be aligned since for getting its size, + * we only use the macro SIZEOF_STRUCT_MEM, which automatically aligns. + */ +struct mem { + /** index (-> ram[next]) of the next struct */ + mem_size_t next; + /** index (-> ram[prev]) of the previous struct */ + mem_size_t prev; + /** 1: this area is used; 0: this area is unused */ + u8_t used; +#if MEM_OVERFLOW_CHECK + /** this keeps track of the user allocation size for guard checks */ + mem_size_t user_size; +#endif +}; + +/** All allocated blocks will be MIN_SIZE bytes big, at least! + * MIN_SIZE can be overridden to suit your needs. Smaller values save space, + * larger values could prevent too small blocks to fragment the RAM too much. */ +#ifndef MIN_SIZE +#define MIN_SIZE 12 +#endif /* MIN_SIZE */ +/* some alignment macros: we define them here for better source code layout */ +#define MIN_SIZE_ALIGNED LWIP_MEM_ALIGN_SIZE(MIN_SIZE) +#define SIZEOF_STRUCT_MEM LWIP_MEM_ALIGN_SIZE(sizeof(struct mem)) +#define MEM_SIZE_ALIGNED LWIP_MEM_ALIGN_SIZE(MEM_SIZE) + +/** If you want to relocate the heap to external memory, simply define + * LWIP_RAM_HEAP_POINTER as a void-pointer to that location. + * If so, make sure the memory at that location is big enough (see below on + * how that space is calculated). */ +#ifndef LWIP_RAM_HEAP_POINTER +/** the heap. we need one struct mem at the end and some room for alignment */ +LWIP_DECLARE_MEMORY_ALIGNED(ram_heap, MEM_SIZE_ALIGNED + (2U * SIZEOF_STRUCT_MEM)); +#define LWIP_RAM_HEAP_POINTER ram_heap +#endif /* LWIP_RAM_HEAP_POINTER */ + +/** pointer to the heap (ram_heap): for alignment, ram is now a pointer instead of an array */ +static u8_t *ram; +/** the last entry, always unused! */ +static struct mem *ram_end; + +/** concurrent access protection */ +#if !NO_SYS +static sys_mutex_t mem_mutex; +#endif + +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + +static volatile u8_t mem_free_count; + +/* Allow mem_free from other (e.g. interrupt) context */ +#define LWIP_MEM_FREE_DECL_PROTECT() SYS_ARCH_DECL_PROTECT(lev_free) +#define LWIP_MEM_FREE_PROTECT() SYS_ARCH_PROTECT(lev_free) +#define LWIP_MEM_FREE_UNPROTECT() SYS_ARCH_UNPROTECT(lev_free) +#define LWIP_MEM_ALLOC_DECL_PROTECT() SYS_ARCH_DECL_PROTECT(lev_alloc) +#define LWIP_MEM_ALLOC_PROTECT() SYS_ARCH_PROTECT(lev_alloc) +#define LWIP_MEM_ALLOC_UNPROTECT() SYS_ARCH_UNPROTECT(lev_alloc) +#define LWIP_MEM_LFREE_VOLATILE volatile + +#else /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + +/* Protect the heap only by using a mutex */ +#define LWIP_MEM_FREE_DECL_PROTECT() +#define LWIP_MEM_FREE_PROTECT() sys_mutex_lock(&mem_mutex) +#define LWIP_MEM_FREE_UNPROTECT() sys_mutex_unlock(&mem_mutex) +/* mem_malloc is protected using mutex AND LWIP_MEM_ALLOC_PROTECT */ +#define LWIP_MEM_ALLOC_DECL_PROTECT() +#define LWIP_MEM_ALLOC_PROTECT() +#define LWIP_MEM_ALLOC_UNPROTECT() +#define LWIP_MEM_LFREE_VOLATILE + +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + +/** pointer to the lowest free block, this is used for faster search */ +static struct mem * LWIP_MEM_LFREE_VOLATILE lfree; + +#if MEM_SANITY_CHECK +static void mem_sanity(void); +#define MEM_SANITY() mem_sanity() +#else +#define MEM_SANITY() +#endif + +#if MEM_OVERFLOW_CHECK +static void +mem_overflow_init_element(struct mem *mem, mem_size_t user_size) +{ + void *p = (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET; + mem->user_size = user_size; + mem_overflow_init_raw(p, user_size); +} + +static void +mem_overflow_check_element(struct mem *mem) +{ + void *p = (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET; + mem_overflow_check_raw(p, mem->user_size, "heap", ""); +} +#else /* MEM_OVERFLOW_CHECK */ +#define mem_overflow_init_element(mem, size) +#define mem_overflow_check_element(mem) +#endif /* MEM_OVERFLOW_CHECK */ + +static struct mem * +ptr_to_mem(mem_size_t ptr) +{ + return (struct mem *)(void *)&ram[ptr]; +} + +static mem_size_t +mem_to_ptr(void *mem) +{ + return (mem_size_t)((u8_t *)mem - ram); +} + +/** + * "Plug holes" by combining adjacent empty struct mems. + * After this function is through, there should not exist + * one empty struct mem pointing to another empty struct mem. + * + * @param mem this points to a struct mem which just has been freed + * @internal this function is only called by mem_free() and mem_trim() + * + * This assumes access to the heap is protected by the calling function + * already. + */ +static void +plug_holes(struct mem *mem) +{ + struct mem *nmem; + struct mem *pmem; + + LWIP_ASSERT("plug_holes: mem >= ram", (u8_t *)mem >= ram); + LWIP_ASSERT("plug_holes: mem < ram_end", (u8_t *)mem < (u8_t *)ram_end); + LWIP_ASSERT("plug_holes: mem->used == 0", mem->used == 0); + + /* plug hole forward */ + LWIP_ASSERT("plug_holes: mem->next <= MEM_SIZE_ALIGNED", mem->next <= MEM_SIZE_ALIGNED); + + nmem = ptr_to_mem(mem->next); + if (mem != nmem && nmem->used == 0 && (u8_t *)nmem != (u8_t *)ram_end) { + /* if mem->next is unused and not end of ram, combine mem and mem->next */ + if (lfree == nmem) { + lfree = mem; + } + mem->next = nmem->next; + if (nmem->next != MEM_SIZE_ALIGNED) { + ptr_to_mem(nmem->next)->prev = mem_to_ptr(mem); + } + } + + /* plug hole backward */ + pmem = ptr_to_mem(mem->prev); + if (pmem != mem && pmem->used == 0) { + /* if mem->prev is unused, combine mem and mem->prev */ + if (lfree == mem) { + lfree = pmem; + } + pmem->next = mem->next; + if (mem->next != MEM_SIZE_ALIGNED) { + ptr_to_mem(mem->next)->prev = mem_to_ptr(pmem); + } + } +} + +/** + * Zero the heap and initialize start, end and lowest-free + */ +void +mem_init(void) +{ + struct mem *mem; + + LWIP_ASSERT("Sanity check alignment", + (SIZEOF_STRUCT_MEM & (MEM_ALIGNMENT - 1)) == 0); + + /* align the heap */ + ram = (u8_t *)LWIP_MEM_ALIGN(LWIP_RAM_HEAP_POINTER); + /* initialize the start of the heap */ + mem = (struct mem *)(void *)ram; + mem->next = MEM_SIZE_ALIGNED; + mem->prev = 0; + mem->used = 0; + /* initialize the end of the heap */ + ram_end = ptr_to_mem(MEM_SIZE_ALIGNED); + ram_end->used = 1; + ram_end->next = MEM_SIZE_ALIGNED; + ram_end->prev = MEM_SIZE_ALIGNED; + MEM_SANITY(); + + /* initialize the lowest-free pointer to the start of the heap */ + lfree = (struct mem *)(void *)ram; + + MEM_STATS_AVAIL(avail, MEM_SIZE_ALIGNED); + + if (sys_mutex_new(&mem_mutex) != ERR_OK) { + LWIP_ASSERT("failed to create mem_mutex", 0); + } +} + +/* Check if a struct mem is correctly linked. + * If not, double-free is a possible reason. + */ +static int +mem_link_valid(struct mem *mem) +{ + struct mem *nmem, *pmem; + mem_size_t rmem_idx; + rmem_idx = mem_to_ptr(mem); + nmem = ptr_to_mem(mem->next); + pmem = ptr_to_mem(mem->prev); + if ((mem->next > MEM_SIZE_ALIGNED) || (mem->prev > MEM_SIZE_ALIGNED) || + ((mem->prev != rmem_idx) && (pmem->next != rmem_idx)) || + ((nmem != ram_end) && (nmem->prev != rmem_idx))) { + return 0; + } + return 1; +} + +#if MEM_SANITY_CHECK +static void +mem_sanity(void) +{ + struct mem *mem; + u8_t last_used; + + /* begin with first element here */ + mem = (struct mem *)ram; + LWIP_ASSERT("heap element used valid", (mem->used == 0) || (mem->used == 1)); + last_used = mem->used; + LWIP_ASSERT("heap element prev ptr valid", mem->prev == 0); + LWIP_ASSERT("heap element next ptr valid", mem->next <= MEM_SIZE_ALIGNED); + LWIP_ASSERT("heap element next ptr aligned", LWIP_MEM_ALIGN(ptr_to_mem(mem->next) == ptr_to_mem(mem->next))); + + /* check all elements before the end of the heap */ + for (mem = ptr_to_mem(mem->next); + ((u8_t *)mem > ram) && (mem < ram_end); + mem = ptr_to_mem(mem->next)) { + LWIP_ASSERT("heap element aligned", LWIP_MEM_ALIGN(mem) == mem); + LWIP_ASSERT("heap element prev ptr valid", mem->prev <= MEM_SIZE_ALIGNED); + LWIP_ASSERT("heap element next ptr valid", mem->next <= MEM_SIZE_ALIGNED); + LWIP_ASSERT("heap element prev ptr aligned", LWIP_MEM_ALIGN(ptr_to_mem(mem->prev) == ptr_to_mem(mem->prev))); + LWIP_ASSERT("heap element next ptr aligned", LWIP_MEM_ALIGN(ptr_to_mem(mem->next) == ptr_to_mem(mem->next))); + + if (last_used == 0) { + /* 2 unused elements in a row? */ + LWIP_ASSERT("heap element unused?", mem->used == 1); + } else { + LWIP_ASSERT("heap element unused member", (mem->used == 0) || (mem->used == 1)); + } + + LWIP_ASSERT("heap element link valid", mem_link_valid(mem)); + + /* used/unused altering */ + last_used = mem->used; + } + LWIP_ASSERT("heap end ptr sanity", mem == ptr_to_mem(MEM_SIZE_ALIGNED)); + LWIP_ASSERT("heap element used valid", mem->used == 1); + LWIP_ASSERT("heap element prev ptr valid", mem->prev == MEM_SIZE_ALIGNED); + LWIP_ASSERT("heap element next ptr valid", mem->next == MEM_SIZE_ALIGNED); +} +#endif /* MEM_SANITY_CHECK */ + +/** + * Put a struct mem back on the heap + * + * @param rmem is the data portion of a struct mem as returned by a previous + * call to mem_malloc() + */ +void +mem_free(void *rmem) +{ + struct mem *mem; + LWIP_MEM_FREE_DECL_PROTECT(); + + if (rmem == NULL) { + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("mem_free(p == NULL) was called.\n")); + return; + } + if ((((mem_ptr_t)rmem) & (MEM_ALIGNMENT - 1)) != 0) { + LWIP_MEM_ILLEGAL_FREE("mem_free: sanity check alignment"); + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: sanity check alignment\n")); + /* protect mem stats from concurrent access */ + MEM_STATS_INC_LOCKED(illegal); + return; + } + + /* Get the corresponding struct mem: */ + /* cast through void* to get rid of alignment warnings */ + mem = (struct mem *)(void *)((u8_t *)rmem - (SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET)); + + if ((u8_t *)mem < ram || (u8_t *)rmem + MIN_SIZE_ALIGNED > (u8_t *)ram_end) { + LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory"); + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory\n")); + /* protect mem stats from concurrent access */ + MEM_STATS_INC_LOCKED(illegal); + return; + } +#if MEM_OVERFLOW_CHECK + mem_overflow_check_element(mem); +#endif + /* protect the heap from concurrent access */ + LWIP_MEM_FREE_PROTECT(); + /* mem has to be in a used state */ + if (!mem->used) { + LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory: double free"); + LWIP_MEM_FREE_UNPROTECT(); + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory: double free?\n")); + /* protect mem stats from concurrent access */ + MEM_STATS_INC_LOCKED(illegal); + return; + } + + if (!mem_link_valid(mem)) { + LWIP_MEM_ILLEGAL_FREE("mem_free: illegal memory: non-linked: double free"); + LWIP_MEM_FREE_UNPROTECT(); + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_free: illegal memory: non-linked: double free?\n")); + /* protect mem stats from concurrent access */ + MEM_STATS_INC_LOCKED(illegal); + return; + } + + /* mem is now unused. */ + mem->used = 0; + + if (mem < lfree) { + /* the newly freed struct is now the lowest */ + lfree = mem; + } + + MEM_STATS_DEC_USED(used, mem->next - (mem_size_t)(((u8_t *)mem - ram))); + + /* finally, see if prev or next are free also */ + plug_holes(mem); + MEM_SANITY(); +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + mem_free_count = 1; +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + LWIP_MEM_FREE_UNPROTECT(); +} + +/** + * Shrink memory returned by mem_malloc(). + * + * @param rmem pointer to memory allocated by mem_malloc the is to be shrinked + * @param new_size required size after shrinking (needs to be smaller than or + * equal to the previous size) + * @return for compatibility reasons: is always == rmem, at the moment + * or NULL if newsize is > old size, in which case rmem is NOT touched + * or freed! + */ +void * +mem_trim(void *rmem, mem_size_t new_size) +{ + mem_size_t size, newsize; + mem_size_t ptr, ptr2; + struct mem *mem, *mem2; + /* use the FREE_PROTECT here: it protects with sem OR SYS_ARCH_PROTECT */ + LWIP_MEM_FREE_DECL_PROTECT(); + + /* Expand the size of the allocated memory region so that we can + adjust for alignment. */ + newsize = (mem_size_t)LWIP_MEM_ALIGN_SIZE(new_size); + if (newsize < MIN_SIZE_ALIGNED) { + /* every data block must be at least MIN_SIZE_ALIGNED long */ + newsize = MIN_SIZE_ALIGNED; + } +#if MEM_OVERFLOW_CHECK + newsize += MEM_SANITY_REGION_BEFORE_ALIGNED + MEM_SANITY_REGION_AFTER_ALIGNED; +#endif + if ((newsize > MEM_SIZE_ALIGNED) || (newsize < new_size)) { + return NULL; + } + + LWIP_ASSERT("mem_trim: legal memory", (u8_t *)rmem >= (u8_t *)ram && + (u8_t *)rmem < (u8_t *)ram_end); + + if ((u8_t *)rmem < (u8_t *)ram || (u8_t *)rmem >= (u8_t *)ram_end) { + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("mem_trim: illegal memory\n")); + /* protect mem stats from concurrent access */ + MEM_STATS_INC_LOCKED(illegal); + return rmem; + } + /* Get the corresponding struct mem ... */ + /* cast through void* to get rid of alignment warnings */ + mem = (struct mem *)(void *)((u8_t *)rmem - (SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET)); +#if MEM_OVERFLOW_CHECK + mem_overflow_check_element(mem); +#endif + /* ... and its offset pointer */ + ptr = mem_to_ptr(mem); + + size = (mem_size_t)((mem_size_t)(mem->next - ptr) - (SIZEOF_STRUCT_MEM + MEM_SANITY_OVERHEAD)); + LWIP_ASSERT("mem_trim can only shrink memory", newsize <= size); + if (newsize > size) { + /* not supported */ + return NULL; + } + if (newsize == size) { + /* No change in size, simply return */ + return rmem; + } + + /* protect the heap from concurrent access */ + LWIP_MEM_FREE_PROTECT(); + + mem2 = ptr_to_mem(mem->next); + if (mem2->used == 0) { + /* The next struct is unused, we can simply move it at little */ + mem_size_t next; + LWIP_ASSERT("invalid next ptr", mem->next != MEM_SIZE_ALIGNED); + /* remember the old next pointer */ + next = mem2->next; + /* create new struct mem which is moved directly after the shrinked mem */ + ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + newsize); + if (lfree == mem2) { + lfree = ptr_to_mem(ptr2); + } + mem2 = ptr_to_mem(ptr2); + mem2->used = 0; + /* restore the next pointer */ + mem2->next = next; + /* link it back to mem */ + mem2->prev = ptr; + /* link mem to it */ + mem->next = ptr2; + /* last thing to restore linked list: as we have moved mem2, + * let 'mem2->next->prev' point to mem2 again. but only if mem2->next is not + * the end of the heap */ + if (mem2->next != MEM_SIZE_ALIGNED) { + ptr_to_mem(mem2->next)->prev = ptr2; + } + MEM_STATS_DEC_USED(used, (size - newsize)); + /* no need to plug holes, we've already done that */ + } else if (newsize + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED <= size) { + /* Next struct is used but there's room for another struct mem with + * at least MIN_SIZE_ALIGNED of data. + * Old size ('size') must be big enough to contain at least 'newsize' plus a struct mem + * ('SIZEOF_STRUCT_MEM') with some data ('MIN_SIZE_ALIGNED'). + * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty + * region that couldn't hold data, but when mem->next gets freed, + * the 2 regions would be combined, resulting in more free memory */ + ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + newsize); + LWIP_ASSERT("invalid next ptr", mem->next != MEM_SIZE_ALIGNED); + mem2 = ptr_to_mem(ptr2); + if (mem2 < lfree) { + lfree = mem2; + } + mem2->used = 0; + mem2->next = mem->next; + mem2->prev = ptr; + mem->next = ptr2; + if (mem2->next != MEM_SIZE_ALIGNED) { + ptr_to_mem(mem2->next)->prev = ptr2; + } + MEM_STATS_DEC_USED(used, (size - newsize)); + /* the original mem->next is used, so no need to plug holes! */ + } + /* else { + next struct mem is used but size between mem and mem2 is not big enough + to create another struct mem + -> don't do anyhting. + -> the remaining space stays unused since it is too small + } */ +#if MEM_OVERFLOW_CHECK + mem_overflow_init_element(mem, new_size); +#endif + MEM_SANITY(); +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + mem_free_count = 1; +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + LWIP_MEM_FREE_UNPROTECT(); + return rmem; +} + +/** + * Allocate a block of memory with a minimum of 'size' bytes. + * + * @param size_in is the minimum size of the requested block in bytes. + * @return pointer to allocated memory or NULL if no free memory was found. + * + * Note that the returned value will always be aligned (as defined by MEM_ALIGNMENT). + */ +void * +mem_malloc(mem_size_t size_in) +{ + mem_size_t ptr, ptr2, size; + struct mem *mem, *mem2; +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + u8_t local_mem_free_count = 0; +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + LWIP_MEM_ALLOC_DECL_PROTECT(); + + if (size_in == 0) { + return NULL; + } + + /* Expand the size of the allocated memory region so that we can + adjust for alignment. */ + size = (mem_size_t)LWIP_MEM_ALIGN_SIZE(size_in); + if (size < MIN_SIZE_ALIGNED) { + /* every data block must be at least MIN_SIZE_ALIGNED long */ + size = MIN_SIZE_ALIGNED; + } +#if MEM_OVERFLOW_CHECK + size += MEM_SANITY_REGION_BEFORE_ALIGNED + MEM_SANITY_REGION_AFTER_ALIGNED; +#endif + if ((size > MEM_SIZE_ALIGNED) || (size < size_in)) { + return NULL; + } + + /* protect the heap from concurrent access */ + sys_mutex_lock(&mem_mutex); + LWIP_MEM_ALLOC_PROTECT(); +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + /* run as long as a mem_free disturbed mem_malloc or mem_trim */ + do { + local_mem_free_count = 0; +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + + /* Scan through the heap searching for a free block that is big enough, + * beginning with the lowest free block. + */ + for (ptr = mem_to_ptr(lfree); ptr < MEM_SIZE_ALIGNED - size; + ptr = ptr_to_mem(ptr)->next) { + mem = ptr_to_mem(ptr); +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + mem_free_count = 0; + LWIP_MEM_ALLOC_UNPROTECT(); + /* allow mem_free or mem_trim to run */ + LWIP_MEM_ALLOC_PROTECT(); + if (mem_free_count != 0) { + /* If mem_free or mem_trim have run, we have to restart since they + could have altered our current struct mem. */ + local_mem_free_count = 1; + break; + } +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + + if ((!mem->used) && + (mem->next - (ptr + SIZEOF_STRUCT_MEM)) >= size) { + /* mem is not used and at least perfect fit is possible: + * mem->next - (ptr + SIZEOF_STRUCT_MEM) gives us the 'user data size' of mem */ + + if (mem->next - (ptr + SIZEOF_STRUCT_MEM) >= (size + SIZEOF_STRUCT_MEM + MIN_SIZE_ALIGNED)) { + /* (in addition to the above, we test if another struct mem (SIZEOF_STRUCT_MEM) containing + * at least MIN_SIZE_ALIGNED of data also fits in the 'user data space' of 'mem') + * -> split large block, create empty remainder, + * remainder must be large enough to contain MIN_SIZE_ALIGNED data: if + * mem->next - (ptr + (2*SIZEOF_STRUCT_MEM)) == size, + * struct mem would fit in but no data between mem2 and mem2->next + * @todo we could leave out MIN_SIZE_ALIGNED. We would create an empty + * region that couldn't hold data, but when mem->next gets freed, + * the 2 regions would be combined, resulting in more free memory + */ + ptr2 = (mem_size_t)(ptr + SIZEOF_STRUCT_MEM + size); + LWIP_ASSERT("invalid next ptr",ptr2 != MEM_SIZE_ALIGNED); + /* create mem2 struct */ + mem2 = ptr_to_mem(ptr2); + mem2->used = 0; + mem2->next = mem->next; + mem2->prev = ptr; + /* and insert it between mem and mem->next */ + mem->next = ptr2; + mem->used = 1; + + if (mem2->next != MEM_SIZE_ALIGNED) { + ptr_to_mem(mem2->next)->prev = ptr2; + } + MEM_STATS_INC_USED(used, (size + SIZEOF_STRUCT_MEM)); + } else { + /* (a mem2 struct does no fit into the user data space of mem and mem->next will always + * be used at this point: if not we have 2 unused structs in a row, plug_holes should have + * take care of this). + * -> near fit or exact fit: do not split, no mem2 creation + * also can't move mem->next directly behind mem, since mem->next + * will always be used at this point! + */ + mem->used = 1; + MEM_STATS_INC_USED(used, mem->next - mem_to_ptr(mem)); + } +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT +mem_malloc_adjust_lfree: +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + if (mem == lfree) { + struct mem *cur = lfree; + /* Find next free block after mem and update lowest free pointer */ + while (cur->used && cur != ram_end) { +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + mem_free_count = 0; + LWIP_MEM_ALLOC_UNPROTECT(); + /* prevent high interrupt latency... */ + LWIP_MEM_ALLOC_PROTECT(); + if (mem_free_count != 0) { + /* If mem_free or mem_trim have run, we have to restart since they + could have altered our current struct mem or lfree. */ + goto mem_malloc_adjust_lfree; + } +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + cur = ptr_to_mem(cur->next); + } + lfree = cur; + LWIP_ASSERT("mem_malloc: !lfree->used", ((lfree == ram_end) || (!lfree->used))); + } + LWIP_MEM_ALLOC_UNPROTECT(); + sys_mutex_unlock(&mem_mutex); + LWIP_ASSERT("mem_malloc: allocated memory not above ram_end.", + (mem_ptr_t)mem + SIZEOF_STRUCT_MEM + size <= (mem_ptr_t)ram_end); + LWIP_ASSERT("mem_malloc: allocated memory properly aligned.", + ((mem_ptr_t)mem + SIZEOF_STRUCT_MEM) % MEM_ALIGNMENT == 0); + LWIP_ASSERT("mem_malloc: sanity check alignment", + (((mem_ptr_t)mem) & (MEM_ALIGNMENT - 1)) == 0); + +#if MEM_OVERFLOW_CHECK + mem_overflow_init_element(mem, size_in); +#endif + MEM_SANITY(); + return (u8_t *)mem + SIZEOF_STRUCT_MEM + MEM_SANITY_OFFSET; + } + } +#if LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT + /* if we got interrupted by a mem_free, try again */ + } while (local_mem_free_count != 0); +#endif /* LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT */ + MEM_STATS_INC(err); + LWIP_MEM_ALLOC_UNPROTECT(); + sys_mutex_unlock(&mem_mutex); + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mem_malloc: could not allocate %"S16_F" bytes\n", (s16_t)size)); + return NULL; +} + +#endif /* MEM_USE_POOLS */ + +#if MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) +void * +mem_calloc(mem_size_t count, mem_size_t size) +{ + return mem_clib_calloc(count, size); +} + +#else /* MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) */ +/** + * Contiguously allocates enough space for count objects that are size bytes + * of memory each and returns a pointer to the allocated memory. + * + * The allocated memory is filled with bytes of value zero. + * + * @param count number of objects to allocate + * @param size size of the objects to allocate + * @return pointer to allocated memory / NULL pointer if there is an error + */ +void * +mem_calloc(mem_size_t count, mem_size_t size) +{ + void *p; + size_t alloc_size = (size_t)count * (size_t)size; + + if ((size_t)(mem_size_t)alloc_size != alloc_size) { + LWIP_DEBUGF(MEM_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("mem_calloc: could not allocate %"SZT_F" bytes\n", alloc_size)); + return NULL; + } + + /* allocate 'count' objects of size 'size' */ + p = mem_malloc((mem_size_t)alloc_size); + if (p) { + /* zero the memory */ + memset(p, 0, alloc_size); + } + return p; +} +#endif /* MEM_LIBC_MALLOC && (!LWIP_STATS || !MEM_STATS) */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/memp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/memp.c index 18771f62..352ce5a5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/memp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/memp.c @@ -1,447 +1,447 @@ -/** - * @file - * Dynamic pool memory manager - * - * lwIP has dedicated pools for many structures (netconn, protocol control blocks, - * packet buffers, ...). All these pools are managed here. - * - * @defgroup mempool Memory pools - * @ingroup infrastructure - * Custom memory pools - - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#include "lwip/memp.h" -#include "lwip/sys.h" -#include "lwip/stats.h" - -#include - -/* Make sure we include everything we need for size calculation required by memp_std.h */ -#include "lwip/pbuf.h" -#include "lwip/raw.h" -#include "lwip/udp.h" -#include "lwip/tcp.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/altcp.h" -#include "lwip/ip4_frag.h" -#include "lwip/netbuf.h" -#include "lwip/api.h" -#include "lwip/priv/tcpip_priv.h" -#include "lwip/priv/api_msg.h" -#include "lwip/priv/sockets_priv.h" -#include "lwip/etharp.h" -#include "lwip/igmp.h" -#include "lwip/timeouts.h" -/* needed by default MEMP_NUM_SYS_TIMEOUT */ -#include "netif/ppp/ppp_opts.h" -#include "lwip/netdb.h" -#include "lwip/dns.h" -#include "lwip/priv/nd6_priv.h" -#include "lwip/ip6_frag.h" -#include "lwip/mld6.h" - -#define LWIP_MEMPOOL(name,num,size,desc) LWIP_MEMPOOL_DECLARE(name,num,size,desc) -#include "lwip/priv/memp_std.h" - -const struct memp_desc *const memp_pools[MEMP_MAX] = { -#define LWIP_MEMPOOL(name,num,size,desc) &memp_ ## name, -#include "lwip/priv/memp_std.h" -}; - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -#if MEMP_MEM_MALLOC && MEMP_OVERFLOW_CHECK >= 2 -#undef MEMP_OVERFLOW_CHECK -/* MEMP_OVERFLOW_CHECK >= 2 does not work with MEMP_MEM_MALLOC, use 1 instead */ -#define MEMP_OVERFLOW_CHECK 1 -#endif - -#if MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC -/** - * Check that memp-lists don't form a circle, using "Floyd's cycle-finding algorithm". - */ -static int -memp_sanity(const struct memp_desc *desc) -{ - struct memp *t, *h; - - t = *desc->tab; - if (t != NULL) { - for (h = t->next; (t != NULL) && (h != NULL); t = t->next, - h = ((h->next != NULL) ? h->next->next : NULL)) { - if (t == h) { - return 0; - } - } - } - - return 1; -} -#endif /* MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC */ - -#if MEMP_OVERFLOW_CHECK -/** - * Check if a memp element was victim of an overflow or underflow - * (e.g. the restricted area after/before it has been altered) - * - * @param p the memp element to check - * @param desc the pool p comes from - */ -static void -memp_overflow_check_element(struct memp *p, const struct memp_desc *desc) -{ - mem_overflow_check_raw((u8_t *)p + MEMP_SIZE, desc->size, "pool ", desc->desc); -} - -/** - * Initialize the restricted area of on memp element. - */ -static void -memp_overflow_init_element(struct memp *p, const struct memp_desc *desc) -{ - mem_overflow_init_raw((u8_t *)p + MEMP_SIZE, desc->size); -} - -#if MEMP_OVERFLOW_CHECK >= 2 -/** - * Do an overflow check for all elements in every pool. - * - * @see memp_overflow_check_element for a description of the check - */ -static void -memp_overflow_check_all(void) -{ - u16_t i, j; - struct memp *p; - SYS_ARCH_DECL_PROTECT(old_level); - SYS_ARCH_PROTECT(old_level); - - for (i = 0; i < MEMP_MAX; ++i) { - p = (struct memp *)LWIP_MEM_ALIGN(memp_pools[i]->base); - for (j = 0; j < memp_pools[i]->num; ++j) { - memp_overflow_check_element(p, memp_pools[i]); - p = LWIP_ALIGNMENT_CAST(struct memp *, ((u8_t *)p + MEMP_SIZE + memp_pools[i]->size + MEM_SANITY_REGION_AFTER_ALIGNED)); - } - } - SYS_ARCH_UNPROTECT(old_level); -} -#endif /* MEMP_OVERFLOW_CHECK >= 2 */ -#endif /* MEMP_OVERFLOW_CHECK */ - -/** - * Initialize custom memory pool. - * Related functions: memp_malloc_pool, memp_free_pool - * - * @param desc pool to initialize - */ -void -memp_init_pool(const struct memp_desc *desc) -{ -#if MEMP_MEM_MALLOC - LWIP_UNUSED_ARG(desc); -#else - int i; - struct memp *memp; - - *desc->tab = NULL; - memp = (struct memp *)LWIP_MEM_ALIGN(desc->base); -#if MEMP_MEM_INIT - /* force memset on pool memory */ - memset(memp, 0, (size_t)desc->num * (MEMP_SIZE + desc->size -#if MEMP_OVERFLOW_CHECK - + MEM_SANITY_REGION_AFTER_ALIGNED -#endif - )); -#endif - /* create a linked list of memp elements */ - for (i = 0; i < desc->num; ++i) { - memp->next = *desc->tab; - *desc->tab = memp; -#if MEMP_OVERFLOW_CHECK - memp_overflow_init_element(memp, desc); -#endif /* MEMP_OVERFLOW_CHECK */ - /* cast through void* to get rid of alignment warnings */ - memp = (struct memp *)(void *)((u8_t *)memp + MEMP_SIZE + desc->size -#if MEMP_OVERFLOW_CHECK - + MEM_SANITY_REGION_AFTER_ALIGNED -#endif - ); - } -#if MEMP_STATS - desc->stats->avail = desc->num; -#endif /* MEMP_STATS */ -#endif /* !MEMP_MEM_MALLOC */ - -#if MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) - desc->stats->name = desc->desc; -#endif /* MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) */ -} - -/** - * Initializes lwIP built-in pools. - * Related functions: memp_malloc, memp_free - * - * Carves out memp_memory into linked lists for each pool-type. - */ -void -memp_init(void) -{ - u16_t i; - - /* for every pool: */ - for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) { - memp_init_pool(memp_pools[i]); - -#if LWIP_STATS && MEMP_STATS - lwip_stats.memp[i] = memp_pools[i]->stats; -#endif - } - -#if MEMP_OVERFLOW_CHECK >= 2 - /* check everything a first time to see if it worked */ - memp_overflow_check_all(); -#endif /* MEMP_OVERFLOW_CHECK >= 2 */ -} - -static void * -#if !MEMP_OVERFLOW_CHECK -do_memp_malloc_pool(const struct memp_desc *desc) -#else -do_memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line) -#endif -{ - struct memp *memp; - SYS_ARCH_DECL_PROTECT(old_level); - -#if MEMP_MEM_MALLOC - memp = (struct memp *)mem_malloc(MEMP_SIZE + MEMP_ALIGN_SIZE(desc->size)); - SYS_ARCH_PROTECT(old_level); -#else /* MEMP_MEM_MALLOC */ - SYS_ARCH_PROTECT(old_level); - - memp = *desc->tab; -#endif /* MEMP_MEM_MALLOC */ - - if (memp != NULL) { -#if !MEMP_MEM_MALLOC -#if MEMP_OVERFLOW_CHECK == 1 - memp_overflow_check_element(memp, desc); -#endif /* MEMP_OVERFLOW_CHECK */ - - *desc->tab = memp->next; -#if MEMP_OVERFLOW_CHECK - memp->next = NULL; -#endif /* MEMP_OVERFLOW_CHECK */ -#endif /* !MEMP_MEM_MALLOC */ -#if MEMP_OVERFLOW_CHECK - memp->file = file; - memp->line = line; -#if MEMP_MEM_MALLOC - memp_overflow_init_element(memp, desc); -#endif /* MEMP_MEM_MALLOC */ -#endif /* MEMP_OVERFLOW_CHECK */ - LWIP_ASSERT("memp_malloc: memp properly aligned", - ((mem_ptr_t)memp % MEM_ALIGNMENT) == 0); -#if MEMP_STATS - desc->stats->used++; - if (desc->stats->used > desc->stats->max) { - desc->stats->max = desc->stats->used; - } -#endif - SYS_ARCH_UNPROTECT(old_level); - /* cast through u8_t* to get rid of alignment warnings */ - return ((u8_t *)memp + MEMP_SIZE); - } else { -#if MEMP_STATS - desc->stats->err++; -#endif - SYS_ARCH_UNPROTECT(old_level); - LWIP_DEBUGF(MEMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("memp_malloc: out of memory in pool %s\n", desc->desc)); - } - - return NULL; -} - -/** - * Get an element from a custom pool. - * - * @param desc the pool to get an element from - * - * @return a pointer to the allocated memory or a NULL pointer on error - */ -void * -#if !MEMP_OVERFLOW_CHECK -memp_malloc_pool(const struct memp_desc *desc) -#else -memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line) -#endif -{ - LWIP_ASSERT("invalid pool desc", desc != NULL); - if (desc == NULL) { - return NULL; - } - -#if !MEMP_OVERFLOW_CHECK - return do_memp_malloc_pool(desc); -#else - return do_memp_malloc_pool_fn(desc, file, line); -#endif -} - -/** - * Get an element from a specific pool. - * - * @param type the pool to get an element from - * - * @return a pointer to the allocated memory or a NULL pointer on error - */ -void * -#if !MEMP_OVERFLOW_CHECK -memp_malloc(memp_t type) -#else -memp_malloc_fn(memp_t type, const char *file, const int line) -#endif -{ - void *memp; - LWIP_ERROR("memp_malloc: type < MEMP_MAX", (type < MEMP_MAX), return NULL;); - -#if MEMP_OVERFLOW_CHECK >= 2 - memp_overflow_check_all(); -#endif /* MEMP_OVERFLOW_CHECK >= 2 */ - -#if !MEMP_OVERFLOW_CHECK - memp = do_memp_malloc_pool(memp_pools[type]); -#else - memp = do_memp_malloc_pool_fn(memp_pools[type], file, line); -#endif - - return memp; -} - -static void -do_memp_free_pool(const struct memp_desc *desc, void *mem) -{ - struct memp *memp; - SYS_ARCH_DECL_PROTECT(old_level); - - LWIP_ASSERT("memp_free: mem properly aligned", - ((mem_ptr_t)mem % MEM_ALIGNMENT) == 0); - - /* cast through void* to get rid of alignment warnings */ - memp = (struct memp *)(void *)((u8_t *)mem - MEMP_SIZE); - - SYS_ARCH_PROTECT(old_level); - -#if MEMP_OVERFLOW_CHECK == 1 - memp_overflow_check_element(memp, desc); -#endif /* MEMP_OVERFLOW_CHECK */ - -#if MEMP_STATS - desc->stats->used--; -#endif - -#if MEMP_MEM_MALLOC - LWIP_UNUSED_ARG(desc); - SYS_ARCH_UNPROTECT(old_level); - mem_free(memp); -#else /* MEMP_MEM_MALLOC */ - memp->next = *desc->tab; - *desc->tab = memp; - -#if MEMP_SANITY_CHECK - LWIP_ASSERT("memp sanity", memp_sanity(desc)); -#endif /* MEMP_SANITY_CHECK */ - - SYS_ARCH_UNPROTECT(old_level); -#endif /* !MEMP_MEM_MALLOC */ -} - -/** - * Put a custom pool element back into its pool. - * - * @param desc the pool where to put mem - * @param mem the memp element to free - */ -void -memp_free_pool(const struct memp_desc *desc, void *mem) -{ - LWIP_ASSERT("invalid pool desc", desc != NULL); - if ((desc == NULL) || (mem == NULL)) { - return; - } - - do_memp_free_pool(desc, mem); -} - -/** - * Put an element back into its pool. - * - * @param type the pool where to put mem - * @param mem the memp element to free - */ -void -memp_free(memp_t type, void *mem) -{ -#ifdef LWIP_HOOK_MEMP_AVAILABLE - struct memp *old_first; -#endif - - LWIP_ERROR("memp_free: type < MEMP_MAX", (type < MEMP_MAX), return;); - - if (mem == NULL) { - return; - } - -#if MEMP_OVERFLOW_CHECK >= 2 - memp_overflow_check_all(); -#endif /* MEMP_OVERFLOW_CHECK >= 2 */ - -#ifdef LWIP_HOOK_MEMP_AVAILABLE - old_first = *memp_pools[type]->tab; -#endif - - do_memp_free_pool(memp_pools[type], mem); - -#ifdef LWIP_HOOK_MEMP_AVAILABLE - if (old_first == NULL) { - LWIP_HOOK_MEMP_AVAILABLE(type); - } -#endif -} +/** + * @file + * Dynamic pool memory manager + * + * lwIP has dedicated pools for many structures (netconn, protocol control blocks, + * packet buffers, ...). All these pools are managed here. + * + * @defgroup mempool Memory pools + * @ingroup infrastructure + * Custom memory pools + + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#include "lwip/memp.h" +#include "lwip/sys.h" +#include "lwip/stats.h" + +#include + +/* Make sure we include everything we need for size calculation required by memp_std.h */ +#include "lwip/pbuf.h" +#include "lwip/raw.h" +#include "lwip/udp.h" +#include "lwip/tcp.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/altcp.h" +#include "lwip/ip4_frag.h" +#include "lwip/netbuf.h" +#include "lwip/api.h" +#include "lwip/priv/tcpip_priv.h" +#include "lwip/priv/api_msg.h" +#include "lwip/priv/sockets_priv.h" +#include "lwip/etharp.h" +#include "lwip/igmp.h" +#include "lwip/timeouts.h" +/* needed by default MEMP_NUM_SYS_TIMEOUT */ +#include "netif/ppp/ppp_opts.h" +#include "lwip/netdb.h" +#include "lwip/dns.h" +#include "lwip/priv/nd6_priv.h" +#include "lwip/ip6_frag.h" +#include "lwip/mld6.h" + +#define LWIP_MEMPOOL(name,num,size,desc) LWIP_MEMPOOL_DECLARE(name,num,size,desc) +#include "lwip/priv/memp_std.h" + +const struct memp_desc *const memp_pools[MEMP_MAX] = { +#define LWIP_MEMPOOL(name,num,size,desc) &memp_ ## name, +#include "lwip/priv/memp_std.h" +}; + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +#if MEMP_MEM_MALLOC && MEMP_OVERFLOW_CHECK >= 2 +#undef MEMP_OVERFLOW_CHECK +/* MEMP_OVERFLOW_CHECK >= 2 does not work with MEMP_MEM_MALLOC, use 1 instead */ +#define MEMP_OVERFLOW_CHECK 1 +#endif + +#if MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC +/** + * Check that memp-lists don't form a circle, using "Floyd's cycle-finding algorithm". + */ +static int +memp_sanity(const struct memp_desc *desc) +{ + struct memp *t, *h; + + t = *desc->tab; + if (t != NULL) { + for (h = t->next; (t != NULL) && (h != NULL); t = t->next, + h = ((h->next != NULL) ? h->next->next : NULL)) { + if (t == h) { + return 0; + } + } + } + + return 1; +} +#endif /* MEMP_SANITY_CHECK && !MEMP_MEM_MALLOC */ + +#if MEMP_OVERFLOW_CHECK +/** + * Check if a memp element was victim of an overflow or underflow + * (e.g. the restricted area after/before it has been altered) + * + * @param p the memp element to check + * @param desc the pool p comes from + */ +static void +memp_overflow_check_element(struct memp *p, const struct memp_desc *desc) +{ + mem_overflow_check_raw((u8_t *)p + MEMP_SIZE, desc->size, "pool ", desc->desc); +} + +/** + * Initialize the restricted area of on memp element. + */ +static void +memp_overflow_init_element(struct memp *p, const struct memp_desc *desc) +{ + mem_overflow_init_raw((u8_t *)p + MEMP_SIZE, desc->size); +} + +#if MEMP_OVERFLOW_CHECK >= 2 +/** + * Do an overflow check for all elements in every pool. + * + * @see memp_overflow_check_element for a description of the check + */ +static void +memp_overflow_check_all(void) +{ + u16_t i, j; + struct memp *p; + SYS_ARCH_DECL_PROTECT(old_level); + SYS_ARCH_PROTECT(old_level); + + for (i = 0; i < MEMP_MAX; ++i) { + p = (struct memp *)LWIP_MEM_ALIGN(memp_pools[i]->base); + for (j = 0; j < memp_pools[i]->num; ++j) { + memp_overflow_check_element(p, memp_pools[i]); + p = LWIP_ALIGNMENT_CAST(struct memp *, ((u8_t *)p + MEMP_SIZE + memp_pools[i]->size + MEM_SANITY_REGION_AFTER_ALIGNED)); + } + } + SYS_ARCH_UNPROTECT(old_level); +} +#endif /* MEMP_OVERFLOW_CHECK >= 2 */ +#endif /* MEMP_OVERFLOW_CHECK */ + +/** + * Initialize custom memory pool. + * Related functions: memp_malloc_pool, memp_free_pool + * + * @param desc pool to initialize + */ +void +memp_init_pool(const struct memp_desc *desc) +{ +#if MEMP_MEM_MALLOC + LWIP_UNUSED_ARG(desc); +#else + int i; + struct memp *memp; + + *desc->tab = NULL; + memp = (struct memp *)LWIP_MEM_ALIGN(desc->base); +#if MEMP_MEM_INIT + /* force memset on pool memory */ + memset(memp, 0, (size_t)desc->num * (MEMP_SIZE + desc->size +#if MEMP_OVERFLOW_CHECK + + MEM_SANITY_REGION_AFTER_ALIGNED +#endif + )); +#endif + /* create a linked list of memp elements */ + for (i = 0; i < desc->num; ++i) { + memp->next = *desc->tab; + *desc->tab = memp; +#if MEMP_OVERFLOW_CHECK + memp_overflow_init_element(memp, desc); +#endif /* MEMP_OVERFLOW_CHECK */ + /* cast through void* to get rid of alignment warnings */ + memp = (struct memp *)(void *)((u8_t *)memp + MEMP_SIZE + desc->size +#if MEMP_OVERFLOW_CHECK + + MEM_SANITY_REGION_AFTER_ALIGNED +#endif + ); + } +#if MEMP_STATS + desc->stats->avail = desc->num; +#endif /* MEMP_STATS */ +#endif /* !MEMP_MEM_MALLOC */ + +#if MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) + desc->stats->name = desc->desc; +#endif /* MEMP_STATS && (defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY) */ +} + +/** + * Initializes lwIP built-in pools. + * Related functions: memp_malloc, memp_free + * + * Carves out memp_memory into linked lists for each pool-type. + */ +void +memp_init(void) +{ + u16_t i; + + /* for every pool: */ + for (i = 0; i < LWIP_ARRAYSIZE(memp_pools); i++) { + memp_init_pool(memp_pools[i]); + +#if LWIP_STATS && MEMP_STATS + lwip_stats.memp[i] = memp_pools[i]->stats; +#endif + } + +#if MEMP_OVERFLOW_CHECK >= 2 + /* check everything a first time to see if it worked */ + memp_overflow_check_all(); +#endif /* MEMP_OVERFLOW_CHECK >= 2 */ +} + +static void * +#if !MEMP_OVERFLOW_CHECK +do_memp_malloc_pool(const struct memp_desc *desc) +#else +do_memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line) +#endif +{ + struct memp *memp; + SYS_ARCH_DECL_PROTECT(old_level); + +#if MEMP_MEM_MALLOC + memp = (struct memp *)mem_malloc(MEMP_SIZE + MEMP_ALIGN_SIZE(desc->size)); + SYS_ARCH_PROTECT(old_level); +#else /* MEMP_MEM_MALLOC */ + SYS_ARCH_PROTECT(old_level); + + memp = *desc->tab; +#endif /* MEMP_MEM_MALLOC */ + + if (memp != NULL) { +#if !MEMP_MEM_MALLOC +#if MEMP_OVERFLOW_CHECK == 1 + memp_overflow_check_element(memp, desc); +#endif /* MEMP_OVERFLOW_CHECK */ + + *desc->tab = memp->next; +#if MEMP_OVERFLOW_CHECK + memp->next = NULL; +#endif /* MEMP_OVERFLOW_CHECK */ +#endif /* !MEMP_MEM_MALLOC */ +#if MEMP_OVERFLOW_CHECK + memp->file = file; + memp->line = line; +#if MEMP_MEM_MALLOC + memp_overflow_init_element(memp, desc); +#endif /* MEMP_MEM_MALLOC */ +#endif /* MEMP_OVERFLOW_CHECK */ + LWIP_ASSERT("memp_malloc: memp properly aligned", + ((mem_ptr_t)memp % MEM_ALIGNMENT) == 0); +#if MEMP_STATS + desc->stats->used++; + if (desc->stats->used > desc->stats->max) { + desc->stats->max = desc->stats->used; + } +#endif + SYS_ARCH_UNPROTECT(old_level); + /* cast through u8_t* to get rid of alignment warnings */ + return ((u8_t *)memp + MEMP_SIZE); + } else { +#if MEMP_STATS + desc->stats->err++; +#endif + SYS_ARCH_UNPROTECT(old_level); + LWIP_DEBUGF(MEMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("memp_malloc: out of memory in pool %s\n", desc->desc)); + } + + return NULL; +} + +/** + * Get an element from a custom pool. + * + * @param desc the pool to get an element from + * + * @return a pointer to the allocated memory or a NULL pointer on error + */ +void * +#if !MEMP_OVERFLOW_CHECK +memp_malloc_pool(const struct memp_desc *desc) +#else +memp_malloc_pool_fn(const struct memp_desc *desc, const char *file, const int line) +#endif +{ + LWIP_ASSERT("invalid pool desc", desc != NULL); + if (desc == NULL) { + return NULL; + } + +#if !MEMP_OVERFLOW_CHECK + return do_memp_malloc_pool(desc); +#else + return do_memp_malloc_pool_fn(desc, file, line); +#endif +} + +/** + * Get an element from a specific pool. + * + * @param type the pool to get an element from + * + * @return a pointer to the allocated memory or a NULL pointer on error + */ +void * +#if !MEMP_OVERFLOW_CHECK +memp_malloc(memp_t type) +#else +memp_malloc_fn(memp_t type, const char *file, const int line) +#endif +{ + void *memp; + LWIP_ERROR("memp_malloc: type < MEMP_MAX", (type < MEMP_MAX), return NULL;); + +#if MEMP_OVERFLOW_CHECK >= 2 + memp_overflow_check_all(); +#endif /* MEMP_OVERFLOW_CHECK >= 2 */ + +#if !MEMP_OVERFLOW_CHECK + memp = do_memp_malloc_pool(memp_pools[type]); +#else + memp = do_memp_malloc_pool_fn(memp_pools[type], file, line); +#endif + + return memp; +} + +static void +do_memp_free_pool(const struct memp_desc *desc, void *mem) +{ + struct memp *memp; + SYS_ARCH_DECL_PROTECT(old_level); + + LWIP_ASSERT("memp_free: mem properly aligned", + ((mem_ptr_t)mem % MEM_ALIGNMENT) == 0); + + /* cast through void* to get rid of alignment warnings */ + memp = (struct memp *)(void *)((u8_t *)mem - MEMP_SIZE); + + SYS_ARCH_PROTECT(old_level); + +#if MEMP_OVERFLOW_CHECK == 1 + memp_overflow_check_element(memp, desc); +#endif /* MEMP_OVERFLOW_CHECK */ + +#if MEMP_STATS + desc->stats->used--; +#endif + +#if MEMP_MEM_MALLOC + LWIP_UNUSED_ARG(desc); + SYS_ARCH_UNPROTECT(old_level); + mem_free(memp); +#else /* MEMP_MEM_MALLOC */ + memp->next = *desc->tab; + *desc->tab = memp; + +#if MEMP_SANITY_CHECK + LWIP_ASSERT("memp sanity", memp_sanity(desc)); +#endif /* MEMP_SANITY_CHECK */ + + SYS_ARCH_UNPROTECT(old_level); +#endif /* !MEMP_MEM_MALLOC */ +} + +/** + * Put a custom pool element back into its pool. + * + * @param desc the pool where to put mem + * @param mem the memp element to free + */ +void +memp_free_pool(const struct memp_desc *desc, void *mem) +{ + LWIP_ASSERT("invalid pool desc", desc != NULL); + if ((desc == NULL) || (mem == NULL)) { + return; + } + + do_memp_free_pool(desc, mem); +} + +/** + * Put an element back into its pool. + * + * @param type the pool where to put mem + * @param mem the memp element to free + */ +void +memp_free(memp_t type, void *mem) +{ +#ifdef LWIP_HOOK_MEMP_AVAILABLE + struct memp *old_first; +#endif + + LWIP_ERROR("memp_free: type < MEMP_MAX", (type < MEMP_MAX), return;); + + if (mem == NULL) { + return; + } + +#if MEMP_OVERFLOW_CHECK >= 2 + memp_overflow_check_all(); +#endif /* MEMP_OVERFLOW_CHECK >= 2 */ + +#ifdef LWIP_HOOK_MEMP_AVAILABLE + old_first = *memp_pools[type]->tab; +#endif + + do_memp_free_pool(memp_pools[type], mem); + +#ifdef LWIP_HOOK_MEMP_AVAILABLE + if (old_first == NULL) { + LWIP_HOOK_MEMP_AVAILABLE(type); + } +#endif +} diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/netif.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/netif.c index 8c125671..654f375f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/netif.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/netif.c @@ -1,1796 +1,1796 @@ -/** - * @file - * lwIP network interface abstraction - * - * @defgroup netif Network interface (NETIF) - * @ingroup callbackstyle_api - * - * @defgroup netif_ip4 IPv4 address handling - * @ingroup netif - * - * @defgroup netif_ip6 IPv6 address handling - * @ingroup netif - * - * @defgroup netif_cd Client data handling - * Store data (void*) on a netif for application usage. - * @see @ref LWIP_NUM_NETIF_CLIENT_DATA - * @ingroup netif - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - */ - -#include "lwip/opt.h" - -#include /* memset */ -#include /* atoi */ - -#include "lwip/def.h" -#include "lwip/ip_addr.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/udp.h" -#include "lwip/priv/raw_priv.h" -#include "lwip/snmp.h" -#include "lwip/igmp.h" -#include "lwip/etharp.h" -#include "lwip/stats.h" -#include "lwip/sys.h" -#include "lwip/ip.h" -#if ENABLE_LOOPBACK -#if LWIP_NETIF_LOOPBACK_MULTITHREADING -#include "lwip/tcpip.h" -#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ -#endif /* ENABLE_LOOPBACK */ - -#include "netif/ethernet.h" - -#if LWIP_AUTOIP -#include "lwip/autoip.h" -#endif /* LWIP_AUTOIP */ -#if LWIP_DHCP -#include "lwip/dhcp.h" -#endif /* LWIP_DHCP */ -#if LWIP_IPV6_DHCP6 -#include "lwip/dhcp6.h" -#endif /* LWIP_IPV6_DHCP6 */ -#if LWIP_IPV6_MLD -#include "lwip/mld6.h" -#endif /* LWIP_IPV6_MLD */ -#if LWIP_IPV6 -#include "lwip/nd6.h" -#endif - -#if LWIP_NETIF_STATUS_CALLBACK -#define NETIF_STATUS_CALLBACK(n) do{ if (n->status_callback) { (n->status_callback)(n); }}while(0) -#else -#define NETIF_STATUS_CALLBACK(n) -#endif /* LWIP_NETIF_STATUS_CALLBACK */ - -#if LWIP_NETIF_LINK_CALLBACK -#define NETIF_LINK_CALLBACK(n) do{ if (n->link_callback) { (n->link_callback)(n); }}while(0) -#else -#define NETIF_LINK_CALLBACK(n) -#endif /* LWIP_NETIF_LINK_CALLBACK */ - -#if LWIP_NETIF_EXT_STATUS_CALLBACK -static netif_ext_callback_t *ext_callback; -#endif - -#if !LWIP_SINGLE_NETIF -struct netif *netif_list; -#endif /* !LWIP_SINGLE_NETIF */ -struct netif *netif_default; - -#define netif_index_to_num(index) ((index) - 1) -static u8_t netif_num; - -#if LWIP_NUM_NETIF_CLIENT_DATA > 0 -static u8_t netif_client_id; -#endif - -#define NETIF_REPORT_TYPE_IPV4 0x01 -#define NETIF_REPORT_TYPE_IPV6 0x02 -static void netif_issue_reports(struct netif *netif, u8_t report_type); - -#if LWIP_IPV6 -static err_t netif_null_output_ip6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr); -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 -static err_t netif_null_output_ip4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr); -#endif /* LWIP_IPV4 */ - -#if LWIP_HAVE_LOOPIF -#if LWIP_IPV4 -static err_t netif_loop_output_ipv4(struct netif *netif, struct pbuf *p, const ip4_addr_t *addr); -#endif -#if LWIP_IPV6 -static err_t netif_loop_output_ipv6(struct netif *netif, struct pbuf *p, const ip6_addr_t *addr); -#endif - - -static struct netif loop_netif; - -/** - * Initialize a lwip network interface structure for a loopback interface - * - * @param netif the lwip network interface structure for this loopif - * @return ERR_OK if the loopif is initialized - * ERR_MEM if private data couldn't be allocated - */ -static err_t -netif_loopif_init(struct netif *netif) -{ - LWIP_ASSERT("netif_loopif_init: invalid netif", netif != NULL); - - /* initialize the snmp variables and counters inside the struct netif - * ifSpeed: no assumption can be made! - */ - MIB2_INIT_NETIF(netif, snmp_ifType_softwareLoopback, 0); - - netif->name[0] = 'l'; - netif->name[1] = 'o'; -#if LWIP_IPV4 - netif->output = netif_loop_output_ipv4; -#endif -#if LWIP_IPV6 - netif->output_ip6 = netif_loop_output_ipv6; -#endif -#if LWIP_LOOPIF_MULTICAST - netif_set_flags(netif, NETIF_FLAG_IGMP); -#endif - NETIF_SET_CHECKSUM_CTRL(netif, NETIF_CHECKSUM_DISABLE_ALL); - return ERR_OK; -} -#endif /* LWIP_HAVE_LOOPIF */ - -void -netif_init(void) -{ -#if LWIP_HAVE_LOOPIF -#if LWIP_IPV4 -#define LOOPIF_ADDRINIT &loop_ipaddr, &loop_netmask, &loop_gw, - ip4_addr_t loop_ipaddr, loop_netmask, loop_gw; - IP4_ADDR(&loop_gw, 127, 0, 0, 1); - IP4_ADDR(&loop_ipaddr, 127, 0, 0, 1); - IP4_ADDR(&loop_netmask, 255, 0, 0, 0); -#else /* LWIP_IPV4 */ -#define LOOPIF_ADDRINIT -#endif /* LWIP_IPV4 */ - -#if NO_SYS - netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, ip_input); -#else /* NO_SYS */ - netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, tcpip_input); -#endif /* NO_SYS */ - -#if LWIP_IPV6 - IP_ADDR6_HOST(loop_netif.ip6_addr, 0, 0, 0, 0x00000001UL); - loop_netif.ip6_addr_state[0] = IP6_ADDR_VALID; -#endif /* LWIP_IPV6 */ - - netif_set_link_up(&loop_netif); - netif_set_up(&loop_netif); - -#endif /* LWIP_HAVE_LOOPIF */ -} - -/** - * @ingroup lwip_nosys - * Forwards a received packet for input processing with - * ethernet_input() or ip_input() depending on netif flags. - * Don't call directly, pass to netif_add() and call - * netif->input(). - * Only works if the netif driver correctly sets - * NETIF_FLAG_ETHARP and/or NETIF_FLAG_ETHERNET flag! - */ -err_t -netif_input(struct pbuf *p, struct netif *inp) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("netif_input: invalid pbuf", p != NULL); - LWIP_ASSERT("netif_input: invalid netif", inp != NULL); - -#if LWIP_ETHERNET - if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) { - return ethernet_input(p, inp); - } else -#endif /* LWIP_ETHERNET */ - return ip_input(p, inp); -} - -/** - * @ingroup netif - * Add a network interface to the list of lwIP netifs. - * - * Same as @ref netif_add but without IPv4 addresses - */ -struct netif * -netif_add_noaddr(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input) -{ - return netif_add(netif, -#if LWIP_IPV4 - NULL, NULL, NULL, -#endif /* LWIP_IPV4*/ - state, init, input); -} - -/** - * @ingroup netif - * Add a network interface to the list of lwIP netifs. - * - * @param netif a pre-allocated netif structure - * @param ipaddr IP address for the new netif - * @param netmask network mask for the new netif - * @param gw default gateway IP address for the new netif - * @param state opaque data passed to the new netif - * @param init callback function that initializes the interface - * @param input callback function that is called to pass - * ingress packets up in the protocol layer stack.\n - * It is recommended to use a function that passes the input directly - * to the stack (netif_input(), NO_SYS=1 mode) or via sending a - * message to TCPIP thread (tcpip_input(), NO_SYS=0 mode).\n - * These functions use netif flags NETIF_FLAG_ETHARP and NETIF_FLAG_ETHERNET - * to decide whether to forward to ethernet_input() or ip_input(). - * In other words, the functions only work when the netif - * driver is implemented correctly!\n - * Most members of struct netif should be be initialized by the - * netif init function = netif driver (init parameter of this function).\n - * IPv6: Don't forget to call netif_create_ip6_linklocal_address() after - * setting the MAC address in struct netif.hwaddr - * (IPv6 requires a link-local address). - * - * @return netif, or NULL if failed. - */ -struct netif * -netif_add(struct netif *netif, -#if LWIP_IPV4 - const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, -#endif /* LWIP_IPV4 */ - void *state, netif_init_fn init, netif_input_fn input) -{ -#if LWIP_IPV6 - s8_t i; -#endif - - LWIP_ASSERT_CORE_LOCKED(); - -#if LWIP_SINGLE_NETIF - if (netif_default != NULL) { - LWIP_ASSERT("single netif already set", 0); - return NULL; - } -#endif - - LWIP_ERROR("netif_add: invalid netif", netif != NULL, return NULL); - LWIP_ERROR("netif_add: No init function given", init != NULL, return NULL); - -#if LWIP_IPV4 - if (ipaddr == NULL) { - ipaddr = ip_2_ip4(IP4_ADDR_ANY); - } - if (netmask == NULL) { - netmask = ip_2_ip4(IP4_ADDR_ANY); - } - if (gw == NULL) { - gw = ip_2_ip4(IP4_ADDR_ANY); - } - - /* reset new interface configuration state */ - ip_addr_set_zero_ip4(&netif->ip_addr); - ip_addr_set_zero_ip4(&netif->netmask); - ip_addr_set_zero_ip4(&netif->gw); - netif->output = netif_null_output_ip4; -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - ip_addr_set_zero_ip6(&netif->ip6_addr[i]); - netif->ip6_addr_state[i] = IP6_ADDR_INVALID; -#if LWIP_IPV6_ADDRESS_LIFETIMES - netif->ip6_addr_valid_life[i] = IP6_ADDR_LIFE_STATIC; - netif->ip6_addr_pref_life[i] = IP6_ADDR_LIFE_STATIC; -#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ - } - netif->output_ip6 = netif_null_output_ip6; -#endif /* LWIP_IPV6 */ - NETIF_SET_CHECKSUM_CTRL(netif, NETIF_CHECKSUM_ENABLE_ALL); - netif->mtu = 0; - netif->flags = 0; -#ifdef netif_get_client_data - memset(netif->client_data, 0, sizeof(netif->client_data)); -#endif /* LWIP_NUM_NETIF_CLIENT_DATA */ -#if LWIP_IPV6 -#if LWIP_IPV6_AUTOCONFIG - /* IPv6 address autoconfiguration not enabled by default */ - netif->ip6_autoconfig_enabled = 0; -#endif /* LWIP_IPV6_AUTOCONFIG */ - nd6_restart_netif(netif); -#endif /* LWIP_IPV6 */ -#if LWIP_NETIF_STATUS_CALLBACK - netif->status_callback = NULL; -#endif /* LWIP_NETIF_STATUS_CALLBACK */ -#if LWIP_NETIF_LINK_CALLBACK - netif->link_callback = NULL; -#endif /* LWIP_NETIF_LINK_CALLBACK */ -#if LWIP_IGMP - netif->igmp_mac_filter = NULL; -#endif /* LWIP_IGMP */ -#if LWIP_IPV6 && LWIP_IPV6_MLD - netif->mld_mac_filter = NULL; -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ -#if ENABLE_LOOPBACK - netif->loop_first = NULL; - netif->loop_last = NULL; -#endif /* ENABLE_LOOPBACK */ - - /* remember netif specific state information data */ - netif->state = state; - netif->num = netif_num; - netif->input = input; - - - NETIF_RESET_HINTS(netif); -#if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS - netif->loop_cnt_current = 0; -#endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */ - -#if LWIP_IPV4 - netif_set_addr(netif, ipaddr, netmask, gw); -#endif /* LWIP_IPV4 */ - - /* call user specified initialization function for netif */ - if (init(netif) != ERR_OK) { - return NULL; - } -#if LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES - /* Initialize the MTU for IPv6 to the one set by the netif driver. - This can be updated later by RA. */ - netif->mtu6 = netif->mtu; -#endif /* LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES */ - -#if !LWIP_SINGLE_NETIF - /* Assign a unique netif number in the range [0..254], so that (num+1) can - serve as an interface index that fits in a u8_t. - We assume that the new netif has not yet been added to the list here. - This algorithm is O(n^2), but that should be OK for lwIP. - */ - { - struct netif *netif2; - int num_netifs; - do { - if (netif->num == 255) { - netif->num = 0; - } - num_netifs = 0; - for (netif2 = netif_list; netif2 != NULL; netif2 = netif2->next) { - LWIP_ASSERT("netif already added", netif2 != netif); - num_netifs++; - LWIP_ASSERT("too many netifs, max. supported number is 255", num_netifs <= 255); - if (netif2->num == netif->num) { - netif->num++; - break; - } - } - } while (netif2 != NULL); - } - if (netif->num == 254) { - netif_num = 0; - } else { - netif_num = (u8_t)(netif->num + 1); - } - - /* add this netif to the list */ - netif->next = netif_list; - netif_list = netif; -#endif /* "LWIP_SINGLE_NETIF */ - mib2_netif_added(netif); - -#if LWIP_IGMP - /* start IGMP processing */ - if (netif->flags & NETIF_FLAG_IGMP) { - igmp_start(netif); - } -#endif /* LWIP_IGMP */ - - LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP", - netif->name[0], netif->name[1])); -#if LWIP_IPV4 - LWIP_DEBUGF(NETIF_DEBUG, (" addr ")); - ip4_addr_debug_print(NETIF_DEBUG, ipaddr); - LWIP_DEBUGF(NETIF_DEBUG, (" netmask ")); - ip4_addr_debug_print(NETIF_DEBUG, netmask); - LWIP_DEBUGF(NETIF_DEBUG, (" gw ")); - ip4_addr_debug_print(NETIF_DEBUG, gw); -#endif /* LWIP_IPV4 */ - LWIP_DEBUGF(NETIF_DEBUG, ("\n")); - - netif_invoke_ext_callback(netif, LWIP_NSC_NETIF_ADDED, NULL); - - return netif; -} - -static void -netif_do_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) -{ -#if LWIP_TCP - tcp_netif_ip_addr_changed(old_addr, new_addr); -#endif /* LWIP_TCP */ -#if LWIP_UDP - udp_netif_ip_addr_changed(old_addr, new_addr); -#endif /* LWIP_UDP */ -#if LWIP_RAW - raw_netif_ip_addr_changed(old_addr, new_addr); -#endif /* LWIP_RAW */ -} - -#if LWIP_IPV4 -static int -netif_do_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr, ip_addr_t *old_addr) -{ - LWIP_ASSERT("invalid pointer", ipaddr != NULL); - LWIP_ASSERT("invalid pointer", old_addr != NULL); - - /* address is actually being changed? */ - if (ip4_addr_cmp(ipaddr, netif_ip4_addr(netif)) == 0) { - ip_addr_t new_addr; - *ip_2_ip4(&new_addr) = *ipaddr; - IP_SET_TYPE_VAL(new_addr, IPADDR_TYPE_V4); - - ip_addr_copy(*old_addr, *netif_ip_addr4(netif)); - - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: netif address being changed\n")); - netif_do_ip_addr_changed(old_addr, &new_addr); - - mib2_remove_ip4(netif); - mib2_remove_route_ip4(0, netif); - /* set new IP address to netif */ - ip4_addr_set(ip_2_ip4(&netif->ip_addr), ipaddr); - IP_SET_TYPE_VAL(netif->ip_addr, IPADDR_TYPE_V4); - mib2_add_ip4(netif); - mib2_add_route_ip4(0, netif); - - netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4); - - NETIF_STATUS_CALLBACK(netif); - return 1; /* address changed */ - } - return 0; /* address unchanged */ -} - -/** - * @ingroup netif_ip4 - * Change the IP address of a network interface - * - * @param netif the network interface to change - * @param ipaddr the new IP address - * - * @note call netif_set_addr() if you also want to change netmask and - * default gateway - */ -void -netif_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr) -{ - ip_addr_t old_addr; - - LWIP_ERROR("netif_set_ipaddr: invalid netif", netif != NULL, return); - - /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ - if (ipaddr == NULL) { - ipaddr = IP4_ADDR_ANY4; - } - - LWIP_ASSERT_CORE_LOCKED(); - - if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - netif_ext_callback_args_t args; - args.ipv4_changed.old_address = &old_addr; - netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_ADDRESS_CHANGED, &args); -#endif - } -} - -static int -netif_do_set_netmask(struct netif *netif, const ip4_addr_t *netmask, ip_addr_t *old_nm) -{ - /* address is actually being changed? */ - if (ip4_addr_cmp(netmask, netif_ip4_netmask(netif)) == 0) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - LWIP_ASSERT("invalid pointer", old_nm != NULL); - ip_addr_copy(*old_nm, *netif_ip_netmask4(netif)); -#else - LWIP_UNUSED_ARG(old_nm); -#endif - mib2_remove_route_ip4(0, netif); - /* set new netmask to netif */ - ip4_addr_set(ip_2_ip4(&netif->netmask), netmask); - IP_SET_TYPE_VAL(netif->netmask, IPADDR_TYPE_V4); - mib2_add_route_ip4(0, netif); - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: netmask of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - netif->name[0], netif->name[1], - ip4_addr1_16(netif_ip4_netmask(netif)), - ip4_addr2_16(netif_ip4_netmask(netif)), - ip4_addr3_16(netif_ip4_netmask(netif)), - ip4_addr4_16(netif_ip4_netmask(netif)))); - return 1; /* netmask changed */ - } - return 0; /* netmask unchanged */ -} - -/** - * @ingroup netif_ip4 - * Change the netmask of a network interface - * - * @param netif the network interface to change - * @param netmask the new netmask - * - * @note call netif_set_addr() if you also want to change ip address and - * default gateway - */ -void -netif_set_netmask(struct netif *netif, const ip4_addr_t *netmask) -{ -#if LWIP_NETIF_EXT_STATUS_CALLBACK - ip_addr_t old_nm_val; - ip_addr_t *old_nm = &old_nm_val; -#else - ip_addr_t *old_nm = NULL; -#endif - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("netif_set_netmask: invalid netif", netif != NULL, return); - - /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ - if (netmask == NULL) { - netmask = IP4_ADDR_ANY4; - } - - if (netif_do_set_netmask(netif, netmask, old_nm)) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - netif_ext_callback_args_t args; - args.ipv4_changed.old_netmask = old_nm; - netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_NETMASK_CHANGED, &args); -#endif - } -} - -static int -netif_do_set_gw(struct netif *netif, const ip4_addr_t *gw, ip_addr_t *old_gw) -{ - /* address is actually being changed? */ - if (ip4_addr_cmp(gw, netif_ip4_gw(netif)) == 0) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - LWIP_ASSERT("invalid pointer", old_gw != NULL); - ip_addr_copy(*old_gw, *netif_ip_gw4(netif)); -#else - LWIP_UNUSED_ARG(old_gw); -#endif - - ip4_addr_set(ip_2_ip4(&netif->gw), gw); - IP_SET_TYPE_VAL(netif->gw, IPADDR_TYPE_V4); - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: GW address of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", - netif->name[0], netif->name[1], - ip4_addr1_16(netif_ip4_gw(netif)), - ip4_addr2_16(netif_ip4_gw(netif)), - ip4_addr3_16(netif_ip4_gw(netif)), - ip4_addr4_16(netif_ip4_gw(netif)))); - return 1; /* gateway changed */ - } - return 0; /* gateway unchanged */ -} - -/** - * @ingroup netif_ip4 - * Change the default gateway for a network interface - * - * @param netif the network interface to change - * @param gw the new default gateway - * - * @note call netif_set_addr() if you also want to change ip address and netmask - */ -void -netif_set_gw(struct netif *netif, const ip4_addr_t *gw) -{ -#if LWIP_NETIF_EXT_STATUS_CALLBACK - ip_addr_t old_gw_val; - ip_addr_t *old_gw = &old_gw_val; -#else - ip_addr_t *old_gw = NULL; -#endif - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("netif_set_gw: invalid netif", netif != NULL, return); - - /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ - if (gw == NULL) { - gw = IP4_ADDR_ANY4; - } - - if (netif_do_set_gw(netif, gw, old_gw)) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - netif_ext_callback_args_t args; - args.ipv4_changed.old_gw = old_gw; - netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_GATEWAY_CHANGED, &args); -#endif - } -} - -/** - * @ingroup netif_ip4 - * Change IP address configuration for a network interface (including netmask - * and default gateway). - * - * @param netif the network interface to change - * @param ipaddr the new IP address - * @param netmask the new netmask - * @param gw the new default gateway - */ -void -netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, - const ip4_addr_t *gw) -{ -#if LWIP_NETIF_EXT_STATUS_CALLBACK - netif_nsc_reason_t change_reason = LWIP_NSC_NONE; - netif_ext_callback_args_t cb_args; - ip_addr_t old_nm_val; - ip_addr_t old_gw_val; - ip_addr_t *old_nm = &old_nm_val; - ip_addr_t *old_gw = &old_gw_val; -#else - ip_addr_t *old_nm = NULL; - ip_addr_t *old_gw = NULL; -#endif - ip_addr_t old_addr; - int remove; - - LWIP_ASSERT_CORE_LOCKED(); - - /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ - if (ipaddr == NULL) { - ipaddr = IP4_ADDR_ANY4; - } - if (netmask == NULL) { - netmask = IP4_ADDR_ANY4; - } - if (gw == NULL) { - gw = IP4_ADDR_ANY4; - } - - remove = ip4_addr_isany(ipaddr); - if (remove) { - /* when removing an address, we have to remove it *before* changing netmask/gw - to ensure that tcp RST segment can be sent correctly */ - if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - change_reason |= LWIP_NSC_IPV4_ADDRESS_CHANGED; - cb_args.ipv4_changed.old_address = &old_addr; -#endif - } - } - if (netif_do_set_netmask(netif, netmask, old_nm)) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - change_reason |= LWIP_NSC_IPV4_NETMASK_CHANGED; - cb_args.ipv4_changed.old_netmask = old_nm; -#endif - } - if (netif_do_set_gw(netif, gw, old_gw)) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - change_reason |= LWIP_NSC_IPV4_GATEWAY_CHANGED; - cb_args.ipv4_changed.old_gw = old_gw; -#endif - } - if (!remove) { - /* set ipaddr last to ensure netmask/gw have been set when status callback is called */ - if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - change_reason |= LWIP_NSC_IPV4_ADDRESS_CHANGED; - cb_args.ipv4_changed.old_address = &old_addr; -#endif - } - } - -#if LWIP_NETIF_EXT_STATUS_CALLBACK - if (change_reason != LWIP_NSC_NONE) { - change_reason |= LWIP_NSC_IPV4_SETTINGS_CHANGED; - netif_invoke_ext_callback(netif, change_reason, &cb_args); - } -#endif -} -#endif /* LWIP_IPV4*/ - -/** - * @ingroup netif - * Remove a network interface from the list of lwIP netifs. - * - * @param netif the network interface to remove - */ -void -netif_remove(struct netif *netif) -{ -#if LWIP_IPV6 - int i; -#endif - - LWIP_ASSERT_CORE_LOCKED(); - - if (netif == NULL) { - return; - } - - netif_invoke_ext_callback(netif, LWIP_NSC_NETIF_REMOVED, NULL); - -#if LWIP_IPV4 - if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { - netif_do_ip_addr_changed(netif_ip_addr4(netif), NULL); - } - -#if LWIP_IGMP - /* stop IGMP processing */ - if (netif->flags & NETIF_FLAG_IGMP) { - igmp_stop(netif); - } -#endif /* LWIP_IGMP */ -#endif /* LWIP_IPV4*/ - -#if LWIP_IPV6 - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { - netif_do_ip_addr_changed(netif_ip_addr6(netif, i), NULL); - } - } -#if LWIP_IPV6_MLD - /* stop MLD processing */ - mld6_stop(netif); -#endif /* LWIP_IPV6_MLD */ -#endif /* LWIP_IPV6 */ - if (netif_is_up(netif)) { - /* set netif down before removing (call callback function) */ - netif_set_down(netif); - } - - mib2_remove_ip4(netif); - - /* this netif is default? */ - if (netif_default == netif) { - /* reset default netif */ - netif_set_default(NULL); - } -#if !LWIP_SINGLE_NETIF - /* is it the first netif? */ - if (netif_list == netif) { - netif_list = netif->next; - } else { - /* look for netif further down the list */ - struct netif *tmp_netif; - NETIF_FOREACH(tmp_netif) { - if (tmp_netif->next == netif) { - tmp_netif->next = netif->next; - break; - } - } - if (tmp_netif == NULL) { - return; /* netif is not on the list */ - } - } -#endif /* !LWIP_SINGLE_NETIF */ - mib2_netif_removed(netif); -#if LWIP_NETIF_REMOVE_CALLBACK - if (netif->remove_callback) { - netif->remove_callback(netif); - } -#endif /* LWIP_NETIF_REMOVE_CALLBACK */ - LWIP_DEBUGF( NETIF_DEBUG, ("netif_remove: removed netif\n") ); -} - -/** - * @ingroup netif - * Set a network interface as the default network interface - * (used to output all packets for which no specific route is found) - * - * @param netif the default network interface - */ -void -netif_set_default(struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - - if (netif == NULL) { - /* remove default route */ - mib2_remove_route_ip4(1, netif); - } else { - /* install default route */ - mib2_add_route_ip4(1, netif); - } - netif_default = netif; - LWIP_DEBUGF(NETIF_DEBUG, ("netif: setting default interface %c%c\n", - netif ? netif->name[0] : '\'', netif ? netif->name[1] : '\'')); -} - -/** - * @ingroup netif - * Bring an interface up, available for processing - * traffic. - */ -void -netif_set_up(struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("netif_set_up: invalid netif", netif != NULL, return); - - if (!(netif->flags & NETIF_FLAG_UP)) { - netif_set_flags(netif, NETIF_FLAG_UP); - - MIB2_COPY_SYSUPTIME_TO(&netif->ts); - - NETIF_STATUS_CALLBACK(netif); - -#if LWIP_NETIF_EXT_STATUS_CALLBACK - { - netif_ext_callback_args_t args; - args.status_changed.state = 1; - netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args); - } -#endif - - netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6); -#if LWIP_IPV6 - nd6_restart_netif(netif); -#endif /* LWIP_IPV6 */ - } -} - -/** Send ARP/IGMP/MLD/RS events, e.g. on link-up/netif-up or addr-change - */ -static void -netif_issue_reports(struct netif *netif, u8_t report_type) -{ - LWIP_ASSERT("netif_issue_reports: invalid netif", netif != NULL); - - /* Only send reports when both link and admin states are up */ - if (!(netif->flags & NETIF_FLAG_LINK_UP) || - !(netif->flags & NETIF_FLAG_UP)) { - return; - } - -#if LWIP_IPV4 - if ((report_type & NETIF_REPORT_TYPE_IPV4) && - !ip4_addr_isany_val(*netif_ip4_addr(netif))) { -#if LWIP_ARP - /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */ - if (netif->flags & (NETIF_FLAG_ETHARP)) { - etharp_gratuitous(netif); - } -#endif /* LWIP_ARP */ - -#if LWIP_IGMP - /* resend IGMP memberships */ - if (netif->flags & NETIF_FLAG_IGMP) { - igmp_report_groups(netif); - } -#endif /* LWIP_IGMP */ - } -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 - if (report_type & NETIF_REPORT_TYPE_IPV6) { -#if LWIP_IPV6_MLD - /* send mld memberships */ - mld6_report_groups(netif); -#endif /* LWIP_IPV6_MLD */ - } -#endif /* LWIP_IPV6 */ -} - -/** - * @ingroup netif - * Bring an interface down, disabling any traffic processing. - */ -void -netif_set_down(struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("netif_set_down: invalid netif", netif != NULL, return); - - if (netif->flags & NETIF_FLAG_UP) { -#if LWIP_NETIF_EXT_STATUS_CALLBACK - { - netif_ext_callback_args_t args; - args.status_changed.state = 0; - netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args); - } -#endif - - netif_clear_flags(netif, NETIF_FLAG_UP); - MIB2_COPY_SYSUPTIME_TO(&netif->ts); - -#if LWIP_IPV4 && LWIP_ARP - if (netif->flags & NETIF_FLAG_ETHARP) { - etharp_cleanup_netif(netif); - } -#endif /* LWIP_IPV4 && LWIP_ARP */ - -#if LWIP_IPV6 - nd6_cleanup_netif(netif); -#endif /* LWIP_IPV6 */ - - NETIF_STATUS_CALLBACK(netif); - } -} - -#if LWIP_NETIF_STATUS_CALLBACK -/** - * @ingroup netif - * Set callback to be called when interface is brought up/down or address is changed while up - */ -void -netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback) -{ - LWIP_ASSERT_CORE_LOCKED(); - - if (netif) { - netif->status_callback = status_callback; - } -} -#endif /* LWIP_NETIF_STATUS_CALLBACK */ - -#if LWIP_NETIF_REMOVE_CALLBACK -/** - * @ingroup netif - * Set callback to be called when the interface has been removed - */ -void -netif_set_remove_callback(struct netif *netif, netif_status_callback_fn remove_callback) -{ - LWIP_ASSERT_CORE_LOCKED(); - - if (netif) { - netif->remove_callback = remove_callback; - } -} -#endif /* LWIP_NETIF_REMOVE_CALLBACK */ - -/** - * @ingroup netif - * Called by a driver when its link goes up - */ -void -netif_set_link_up(struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("netif_set_link_up: invalid netif", netif != NULL, return); - - if (!(netif->flags & NETIF_FLAG_LINK_UP)) { - netif_set_flags(netif, NETIF_FLAG_LINK_UP); - -#if LWIP_DHCP - dhcp_network_changed(netif); -#endif /* LWIP_DHCP */ - -#if LWIP_AUTOIP - autoip_network_changed(netif); -#endif /* LWIP_AUTOIP */ - - netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6); -#if LWIP_IPV6 - nd6_restart_netif(netif); -#endif /* LWIP_IPV6 */ - - NETIF_LINK_CALLBACK(netif); -#if LWIP_NETIF_EXT_STATUS_CALLBACK - { - netif_ext_callback_args_t args; - args.link_changed.state = 1; - netif_invoke_ext_callback(netif, LWIP_NSC_LINK_CHANGED, &args); - } -#endif - } -} - -/** - * @ingroup netif - * Called by a driver when its link goes down - */ -void -netif_set_link_down(struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("netif_set_link_down: invalid netif", netif != NULL, return); - - if (netif->flags & NETIF_FLAG_LINK_UP) { - netif_clear_flags(netif, NETIF_FLAG_LINK_UP); - NETIF_LINK_CALLBACK(netif); -#if LWIP_NETIF_EXT_STATUS_CALLBACK - { - netif_ext_callback_args_t args; - args.link_changed.state = 0; - netif_invoke_ext_callback(netif, LWIP_NSC_LINK_CHANGED, &args); - } -#endif - } -} - -#if LWIP_NETIF_LINK_CALLBACK -/** - * @ingroup netif - * Set callback to be called when link is brought up/down - */ -void -netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_callback) -{ - LWIP_ASSERT_CORE_LOCKED(); - - if (netif) { - netif->link_callback = link_callback; - } -} -#endif /* LWIP_NETIF_LINK_CALLBACK */ - -#if ENABLE_LOOPBACK -/** - * @ingroup netif - * Send an IP packet to be received on the same netif (loopif-like). - * The pbuf is simply copied and handed back to netif->input. - * In multithreaded mode, this is done directly since netif->input must put - * the packet on a queue. - * In callback mode, the packet is put on an internal queue and is fed to - * netif->input by netif_poll(). - * - * @param netif the lwip network interface structure - * @param p the (IP) packet to 'send' - * @return ERR_OK if the packet has been sent - * ERR_MEM if the pbuf used to copy the packet couldn't be allocated - */ -err_t -netif_loop_output(struct netif *netif, struct pbuf *p) -{ - struct pbuf *r; - err_t err; - struct pbuf *last; -#if LWIP_LOOPBACK_MAX_PBUFS - u16_t clen = 0; -#endif /* LWIP_LOOPBACK_MAX_PBUFS */ - /* If we have a loopif, SNMP counters are adjusted for it, - * if not they are adjusted for 'netif'. */ -#if MIB2_STATS -#if LWIP_HAVE_LOOPIF - struct netif *stats_if = &loop_netif; -#else /* LWIP_HAVE_LOOPIF */ - struct netif *stats_if = netif; -#endif /* LWIP_HAVE_LOOPIF */ -#endif /* MIB2_STATS */ -#if LWIP_NETIF_LOOPBACK_MULTITHREADING - u8_t schedule_poll = 0; -#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ - SYS_ARCH_DECL_PROTECT(lev); - - LWIP_ASSERT("netif_loop_output: invalid netif", netif != NULL); - LWIP_ASSERT("netif_loop_output: invalid pbuf", p != NULL); - - /* Allocate a new pbuf */ - r = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM); - if (r == NULL) { - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(stats_if, ifoutdiscards); - return ERR_MEM; - } -#if LWIP_LOOPBACK_MAX_PBUFS - clen = pbuf_clen(r); - /* check for overflow or too many pbuf on queue */ - if (((netif->loop_cnt_current + clen) < netif->loop_cnt_current) || - ((netif->loop_cnt_current + clen) > LWIP_MIN(LWIP_LOOPBACK_MAX_PBUFS, 0xFFFF))) { - pbuf_free(r); - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(stats_if, ifoutdiscards); - return ERR_MEM; - } - netif->loop_cnt_current = (u16_t)(netif->loop_cnt_current + clen); -#endif /* LWIP_LOOPBACK_MAX_PBUFS */ - - /* Copy the whole pbuf queue p into the single pbuf r */ - if ((err = pbuf_copy(r, p)) != ERR_OK) { - pbuf_free(r); - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(stats_if, ifoutdiscards); - return err; - } - - /* Put the packet on a linked list which gets emptied through calling - netif_poll(). */ - - /* let last point to the last pbuf in chain r */ - for (last = r; last->next != NULL; last = last->next) { - /* nothing to do here, just get to the last pbuf */ - } - - SYS_ARCH_PROTECT(lev); - if (netif->loop_first != NULL) { - LWIP_ASSERT("if first != NULL, last must also be != NULL", netif->loop_last != NULL); - netif->loop_last->next = r; - netif->loop_last = last; - } else { - netif->loop_first = r; - netif->loop_last = last; -#if LWIP_NETIF_LOOPBACK_MULTITHREADING - /* No existing packets queued, schedule poll */ - schedule_poll = 1; -#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ - } - SYS_ARCH_UNPROTECT(lev); - - LINK_STATS_INC(link.xmit); - MIB2_STATS_NETIF_ADD(stats_if, ifoutoctets, p->tot_len); - MIB2_STATS_NETIF_INC(stats_if, ifoutucastpkts); - -#if LWIP_NETIF_LOOPBACK_MULTITHREADING - /* For multithreading environment, schedule a call to netif_poll */ - if (schedule_poll) { - tcpip_try_callback((tcpip_callback_fn)netif_poll, netif); - } -#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ - - return ERR_OK; -} - -#if LWIP_HAVE_LOOPIF -#if LWIP_IPV4 -static err_t -netif_loop_output_ipv4(struct netif *netif, struct pbuf *p, const ip4_addr_t *addr) -{ - LWIP_UNUSED_ARG(addr); - return netif_loop_output(netif, p); -} -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -static err_t -netif_loop_output_ipv6(struct netif *netif, struct pbuf *p, const ip6_addr_t *addr) -{ - LWIP_UNUSED_ARG(addr); - return netif_loop_output(netif, p); -} -#endif /* LWIP_IPV6 */ -#endif /* LWIP_HAVE_LOOPIF */ - - -/** - * Call netif_poll() in the main loop of your application. This is to prevent - * reentering non-reentrant functions like tcp_input(). Packets passed to - * netif_loop_output() are put on a list that is passed to netif->input() by - * netif_poll(). - */ -void -netif_poll(struct netif *netif) -{ - /* If we have a loopif, SNMP counters are adjusted for it, - * if not they are adjusted for 'netif'. */ -#if MIB2_STATS -#if LWIP_HAVE_LOOPIF - struct netif *stats_if = &loop_netif; -#else /* LWIP_HAVE_LOOPIF */ - struct netif *stats_if = netif; -#endif /* LWIP_HAVE_LOOPIF */ -#endif /* MIB2_STATS */ - SYS_ARCH_DECL_PROTECT(lev); - - LWIP_ASSERT("netif_poll: invalid netif", netif != NULL); - - /* Get a packet from the list. With SYS_LIGHTWEIGHT_PROT=1, this is protected */ - SYS_ARCH_PROTECT(lev); - while (netif->loop_first != NULL) { - struct pbuf *in, *in_end; -#if LWIP_LOOPBACK_MAX_PBUFS - u8_t clen = 1; -#endif /* LWIP_LOOPBACK_MAX_PBUFS */ - - in = in_end = netif->loop_first; - while (in_end->len != in_end->tot_len) { - LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL); - in_end = in_end->next; -#if LWIP_LOOPBACK_MAX_PBUFS - clen++; -#endif /* LWIP_LOOPBACK_MAX_PBUFS */ - } -#if LWIP_LOOPBACK_MAX_PBUFS - /* adjust the number of pbufs on queue */ - LWIP_ASSERT("netif->loop_cnt_current underflow", - ((netif->loop_cnt_current - clen) < netif->loop_cnt_current)); - netif->loop_cnt_current = (u16_t)(netif->loop_cnt_current - clen); -#endif /* LWIP_LOOPBACK_MAX_PBUFS */ - - /* 'in_end' now points to the last pbuf from 'in' */ - if (in_end == netif->loop_last) { - /* this was the last pbuf in the list */ - netif->loop_first = netif->loop_last = NULL; - } else { - /* pop the pbuf off the list */ - netif->loop_first = in_end->next; - LWIP_ASSERT("should not be null since first != last!", netif->loop_first != NULL); - } - /* De-queue the pbuf from its successors on the 'loop_' list. */ - in_end->next = NULL; - SYS_ARCH_UNPROTECT(lev); - - in->if_idx = netif_get_index(netif); - - LINK_STATS_INC(link.recv); - MIB2_STATS_NETIF_ADD(stats_if, ifinoctets, in->tot_len); - MIB2_STATS_NETIF_INC(stats_if, ifinucastpkts); - /* loopback packets are always IP packets! */ - if (ip_input(in, netif) != ERR_OK) { - pbuf_free(in); - } - SYS_ARCH_PROTECT(lev); - } - SYS_ARCH_UNPROTECT(lev); -} - -#if !LWIP_NETIF_LOOPBACK_MULTITHREADING -/** - * Calls netif_poll() for every netif on the netif_list. - */ -void -netif_poll_all(void) -{ - struct netif *netif; - /* loop through netifs */ - NETIF_FOREACH(netif) { - netif_poll(netif); - } -} -#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */ -#endif /* ENABLE_LOOPBACK */ - -#if LWIP_NUM_NETIF_CLIENT_DATA > 0 -/** - * @ingroup netif_cd - * Allocate an index to store data in client_data member of struct netif. - * Returned value is an index in mentioned array. - * @see LWIP_NUM_NETIF_CLIENT_DATA - */ -u8_t -netif_alloc_client_data_id(void) -{ - u8_t result = netif_client_id; - netif_client_id++; - - LWIP_ASSERT_CORE_LOCKED(); - -#if LWIP_NUM_NETIF_CLIENT_DATA > 256 -#error LWIP_NUM_NETIF_CLIENT_DATA must be <= 256 -#endif - LWIP_ASSERT("Increase LWIP_NUM_NETIF_CLIENT_DATA in lwipopts.h", result < LWIP_NUM_NETIF_CLIENT_DATA); - return (u8_t)(result + LWIP_NETIF_CLIENT_DATA_INDEX_MAX); -} -#endif - -#if LWIP_IPV6 -/** - * @ingroup netif_ip6 - * Change an IPv6 address of a network interface - * - * @param netif the network interface to change - * @param addr_idx index of the IPv6 address - * @param addr6 the new IPv6 address - * - * @note call netif_ip6_addr_set_state() to set the address valid/temptative - */ -void -netif_ip6_addr_set(struct netif *netif, s8_t addr_idx, const ip6_addr_t *addr6) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("netif_ip6_addr_set: invalid netif", netif != NULL); - LWIP_ASSERT("netif_ip6_addr_set: invalid addr6", addr6 != NULL); - - netif_ip6_addr_set_parts(netif, addr_idx, addr6->addr[0], addr6->addr[1], - addr6->addr[2], addr6->addr[3]); -} - -/* - * Change an IPv6 address of a network interface (internal version taking 4 * u32_t) - * - * @param netif the network interface to change - * @param addr_idx index of the IPv6 address - * @param i0 word0 of the new IPv6 address - * @param i1 word1 of the new IPv6 address - * @param i2 word2 of the new IPv6 address - * @param i3 word3 of the new IPv6 address - */ -void -netif_ip6_addr_set_parts(struct netif *netif, s8_t addr_idx, u32_t i0, u32_t i1, u32_t i2, u32_t i3) -{ - ip_addr_t old_addr; - ip_addr_t new_ipaddr; - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("invalid index", addr_idx < LWIP_IPV6_NUM_ADDRESSES); - - ip6_addr_copy(*ip_2_ip6(&old_addr), *netif_ip6_addr(netif, addr_idx)); - IP_SET_TYPE_VAL(old_addr, IPADDR_TYPE_V6); - - /* address is actually being changed? */ - if ((ip_2_ip6(&old_addr)->addr[0] != i0) || (ip_2_ip6(&old_addr)->addr[1] != i1) || - (ip_2_ip6(&old_addr)->addr[2] != i2) || (ip_2_ip6(&old_addr)->addr[3] != i3)) { - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_ip6_addr_set: netif address being changed\n")); - - IP_ADDR6(&new_ipaddr, i0, i1, i2, i3); - ip6_addr_assign_zone(ip_2_ip6(&new_ipaddr), IP6_UNICAST, netif); - - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, addr_idx))) { - netif_do_ip_addr_changed(netif_ip_addr6(netif, addr_idx), &new_ipaddr); - } - /* @todo: remove/readd mib2 ip6 entries? */ - - ip_addr_copy(netif->ip6_addr[addr_idx], new_ipaddr); - - if (ip6_addr_isvalid(netif_ip6_addr_state(netif, addr_idx))) { - netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV6); - NETIF_STATUS_CALLBACK(netif); - } - -#if LWIP_NETIF_EXT_STATUS_CALLBACK - { - netif_ext_callback_args_t args; - args.ipv6_set.addr_index = addr_idx; - args.ipv6_set.old_address = &old_addr; - netif_invoke_ext_callback(netif, LWIP_NSC_IPV6_SET, &args); - } -#endif - } - - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: IPv6 address %d of interface %c%c set to %s/0x%"X8_F"\n", - addr_idx, netif->name[0], netif->name[1], ip6addr_ntoa(netif_ip6_addr(netif, addr_idx)), - netif_ip6_addr_state(netif, addr_idx))); -} - -/** - * @ingroup netif_ip6 - * Change the state of an IPv6 address of a network interface - * (INVALID, TEMPTATIVE, PREFERRED, DEPRECATED, where TEMPTATIVE - * includes the number of checks done, see ip6_addr.h) - * - * @param netif the network interface to change - * @param addr_idx index of the IPv6 address - * @param state the new IPv6 address state - */ -void -netif_ip6_addr_set_state(struct netif *netif, s8_t addr_idx, u8_t state) -{ - u8_t old_state; - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("invalid index", addr_idx < LWIP_IPV6_NUM_ADDRESSES); - - old_state = netif_ip6_addr_state(netif, addr_idx); - /* state is actually being changed? */ - if (old_state != state) { - u8_t old_valid = old_state & IP6_ADDR_VALID; - u8_t new_valid = state & IP6_ADDR_VALID; - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_ip6_addr_set_state: netif address state being changed\n")); - -#if LWIP_IPV6_MLD - /* Reevaluate solicited-node multicast group membership. */ - if (netif->flags & NETIF_FLAG_MLD6) { - nd6_adjust_mld_membership(netif, addr_idx, state); - } -#endif /* LWIP_IPV6_MLD */ - - if (old_valid && !new_valid) { - /* address about to be removed by setting invalid */ - netif_do_ip_addr_changed(netif_ip_addr6(netif, addr_idx), NULL); - /* @todo: remove mib2 ip6 entries? */ - } - netif->ip6_addr_state[addr_idx] = state; - - if (!old_valid && new_valid) { - /* address added by setting valid */ - /* This is a good moment to check that the address is properly zoned. */ - IP6_ADDR_ZONECHECK_NETIF(netif_ip6_addr(netif, addr_idx), netif); - /* @todo: add mib2 ip6 entries? */ - netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV6); - } - if ((old_state & ~IP6_ADDR_TENTATIVE_COUNT_MASK) != - (state & ~IP6_ADDR_TENTATIVE_COUNT_MASK)) { - /* address state has changed -> call the callback function */ - NETIF_STATUS_CALLBACK(netif); - } - -#if LWIP_NETIF_EXT_STATUS_CALLBACK - { - netif_ext_callback_args_t args; - args.ipv6_addr_state_changed.addr_index = addr_idx; - args.ipv6_addr_state_changed.old_state = old_state; - args.ipv6_addr_state_changed.address = netif_ip_addr6(netif, addr_idx); - netif_invoke_ext_callback(netif, LWIP_NSC_IPV6_ADDR_STATE_CHANGED, &args); - } -#endif - } - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: IPv6 address %d of interface %c%c set to %s/0x%"X8_F"\n", - addr_idx, netif->name[0], netif->name[1], ip6addr_ntoa(netif_ip6_addr(netif, addr_idx)), - netif_ip6_addr_state(netif, addr_idx))); -} - -/** - * Checks if a specific local address is present on the netif and returns its - * index. Depending on its state, it may or may not be assigned to the - * interface (as per RFC terminology). - * - * The given address may or may not be zoned (i.e., have a zone index other - * than IP6_NO_ZONE). If the address is zoned, it must have the correct zone - * for the given netif, or no match will be found. - * - * @param netif the netif to check - * @param ip6addr the IPv6 address to find - * @return >= 0: address found, this is its index - * -1: address not found on this netif - */ -s8_t -netif_get_ip6_addr_match(struct netif *netif, const ip6_addr_t *ip6addr) -{ - s8_t i; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("netif_get_ip6_addr_match: invalid netif", netif != NULL); - LWIP_ASSERT("netif_get_ip6_addr_match: invalid ip6addr", ip6addr != NULL); - -#if LWIP_IPV6_SCOPES - if (ip6_addr_has_zone(ip6addr) && !ip6_addr_test_zone(ip6addr, netif)) { - return -1; /* wrong zone, no match */ - } -#endif /* LWIP_IPV6_SCOPES */ - - for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (!ip6_addr_isinvalid(netif_ip6_addr_state(netif, i)) && - ip6_addr_cmp_zoneless(netif_ip6_addr(netif, i), ip6addr)) { - return i; - } - } - return -1; -} - -/** - * @ingroup netif_ip6 - * Create a link-local IPv6 address on a netif (stored in slot 0) - * - * @param netif the netif to create the address on - * @param from_mac_48bit if != 0, assume hwadr is a 48-bit MAC address (std conversion) - * if == 0, use hwaddr directly as interface ID - */ -void -netif_create_ip6_linklocal_address(struct netif *netif, u8_t from_mac_48bit) -{ - u8_t i, addr_index; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("netif_create_ip6_linklocal_address: invalid netif", netif != NULL); - - /* Link-local prefix. */ - ip_2_ip6(&netif->ip6_addr[0])->addr[0] = PP_HTONL(0xfe800000ul); - ip_2_ip6(&netif->ip6_addr[0])->addr[1] = 0; - - /* Generate interface ID. */ - if (from_mac_48bit) { - /* Assume hwaddr is a 48-bit IEEE 802 MAC. Convert to EUI-64 address. Complement Group bit. */ - ip_2_ip6(&netif->ip6_addr[0])->addr[2] = lwip_htonl((((u32_t)(netif->hwaddr[0] ^ 0x02)) << 24) | - ((u32_t)(netif->hwaddr[1]) << 16) | - ((u32_t)(netif->hwaddr[2]) << 8) | - (0xff)); - ip_2_ip6(&netif->ip6_addr[0])->addr[3] = lwip_htonl((u32_t)(0xfeul << 24) | - ((u32_t)(netif->hwaddr[3]) << 16) | - ((u32_t)(netif->hwaddr[4]) << 8) | - (netif->hwaddr[5])); - } else { - /* Use hwaddr directly as interface ID. */ - ip_2_ip6(&netif->ip6_addr[0])->addr[2] = 0; - ip_2_ip6(&netif->ip6_addr[0])->addr[3] = 0; - - addr_index = 3; - for (i = 0; (i < 8) && (i < netif->hwaddr_len); i++) { - if (i == 4) { - addr_index--; - } - ip_2_ip6(&netif->ip6_addr[0])->addr[addr_index] |= lwip_htonl(((u32_t)(netif->hwaddr[netif->hwaddr_len - i - 1])) << (8 * (i & 0x03))); - } - } - - /* Set a link-local zone. Even though the zone is implied by the owning - * netif, setting the zone anyway has two important conceptual advantages: - * 1) it avoids the need for a ton of exceptions in internal code, allowing - * e.g. ip6_addr_cmp() to be used on local addresses; - * 2) the properly zoned address is visible externally, e.g. when any outside - * code enumerates available addresses or uses one to bind a socket. - * Any external code unaware of address scoping is likely to just ignore the - * zone field, so this should not create any compatibility problems. */ - ip6_addr_assign_zone(ip_2_ip6(&netif->ip6_addr[0]), IP6_UNICAST, netif); - - /* Set address state. */ -#if LWIP_IPV6_DUP_DETECT_ATTEMPTS - /* Will perform duplicate address detection (DAD). */ - netif_ip6_addr_set_state(netif, 0, IP6_ADDR_TENTATIVE); -#else - /* Consider address valid. */ - netif_ip6_addr_set_state(netif, 0, IP6_ADDR_PREFERRED); -#endif /* LWIP_IPV6_AUTOCONFIG */ -} - -/** - * @ingroup netif_ip6 - * This function allows for the easy addition of a new IPv6 address to an interface. - * It takes care of finding an empty slot and then sets the address tentative - * (to make sure that all the subsequent processing happens). - * - * @param netif netif to add the address on - * @param ip6addr address to add - * @param chosen_idx if != NULL, the chosen IPv6 address index will be stored here - */ -err_t -netif_add_ip6_address(struct netif *netif, const ip6_addr_t *ip6addr, s8_t *chosen_idx) -{ - s8_t i; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("netif_add_ip6_address: invalid netif", netif != NULL); - LWIP_ASSERT("netif_add_ip6_address: invalid ip6addr", ip6addr != NULL); - - i = netif_get_ip6_addr_match(netif, ip6addr); - if (i >= 0) { - /* Address already added */ - if (chosen_idx != NULL) { - *chosen_idx = i; - } - return ERR_OK; - } - - /* Find a free slot. The first one is reserved for link-local addresses. */ - for (i = ip6_addr_islinklocal(ip6addr) ? 0 : 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { - if (ip6_addr_isinvalid(netif_ip6_addr_state(netif, i))) { - ip_addr_copy_from_ip6(netif->ip6_addr[i], *ip6addr); - ip6_addr_assign_zone(ip_2_ip6(&netif->ip6_addr[i]), IP6_UNICAST, netif); - netif_ip6_addr_set_state(netif, i, IP6_ADDR_TENTATIVE); - if (chosen_idx != NULL) { - *chosen_idx = i; - } - return ERR_OK; - } - } - - if (chosen_idx != NULL) { - *chosen_idx = -1; - } - return ERR_VAL; -} - -/** Dummy IPv6 output function for netifs not supporting IPv6 - */ -static err_t -netif_null_output_ip6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr) -{ - LWIP_UNUSED_ARG(netif); - LWIP_UNUSED_ARG(p); - LWIP_UNUSED_ARG(ipaddr); - - return ERR_IF; -} -#endif /* LWIP_IPV6 */ - -#if LWIP_IPV4 -/** Dummy IPv4 output function for netifs not supporting IPv4 - */ -static err_t -netif_null_output_ip4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr) -{ - LWIP_UNUSED_ARG(netif); - LWIP_UNUSED_ARG(p); - LWIP_UNUSED_ARG(ipaddr); - - return ERR_IF; -} -#endif /* LWIP_IPV4 */ - -/** -* @ingroup netif -* Return the interface index for the netif with name -* or NETIF_NO_INDEX if not found/on error -* -* @param name the name of the netif -*/ -u8_t -netif_name_to_index(const char *name) -{ - struct netif *netif = netif_find(name); - if (netif != NULL) { - return netif_get_index(netif); - } - /* No name found, return invalid index */ - return NETIF_NO_INDEX; -} - -/** -* @ingroup netif -* Return the interface name for the netif matching index -* or NULL if not found/on error -* -* @param idx the interface index of the netif -* @param name char buffer of at least NETIF_NAMESIZE bytes -*/ -char * -netif_index_to_name(u8_t idx, char *name) -{ - struct netif *netif = netif_get_by_index(idx); - - if (netif != NULL) { - name[0] = netif->name[0]; - name[1] = netif->name[1]; - lwip_itoa(&name[2], NETIF_NAMESIZE - 2, netif_index_to_num(idx)); - return name; - } - return NULL; -} - -/** -* @ingroup netif -* Return the interface for the netif index -* -* @param idx index of netif to find -*/ -struct netif * -netif_get_by_index(u8_t idx) -{ - struct netif *netif; - - LWIP_ASSERT_CORE_LOCKED(); - - if (idx != NETIF_NO_INDEX) { - NETIF_FOREACH(netif) { - if (idx == netif_get_index(netif)) { - return netif; /* found! */ - } - } - } - - return NULL; -} - -/** - * @ingroup netif - * Find a network interface by searching for its name - * - * @param name the name of the netif (like netif->name) plus concatenated number - * in ascii representation (e.g. 'en0') - */ -struct netif * -netif_find(const char *name) -{ - struct netif *netif; - u8_t num; - - LWIP_ASSERT_CORE_LOCKED(); - - if (name == NULL) { - return NULL; - } - - num = (u8_t)atoi(&name[2]); - - NETIF_FOREACH(netif) { - if (num == netif->num && - name[0] == netif->name[0] && - name[1] == netif->name[1]) { - LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: found %c%c\n", name[0], name[1])); - return netif; - } - } - LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: didn't find %c%c\n", name[0], name[1])); - return NULL; -} - -#if LWIP_NETIF_EXT_STATUS_CALLBACK -/** - * @ingroup netif - * Add extended netif events listener - * @param callback pointer to listener structure - * @param fn callback function - */ -void -netif_add_ext_callback(netif_ext_callback_t *callback, netif_ext_callback_fn fn) -{ - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("callback must be != NULL", callback != NULL); - LWIP_ASSERT("fn must be != NULL", fn != NULL); - - callback->callback_fn = fn; - callback->next = ext_callback; - ext_callback = callback; -} - -/** - * @ingroup netif - * Remove extended netif events listener - * @param callback pointer to listener structure - */ -void -netif_remove_ext_callback(netif_ext_callback_t* callback) -{ - netif_ext_callback_t *last, *iter; - - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("callback must be != NULL", callback != NULL); - - if (ext_callback == NULL) { - return; - } - - if (callback == ext_callback) { - ext_callback = ext_callback->next; - } else { - last = ext_callback; - for (iter = ext_callback->next; iter != NULL; last = iter, iter = iter->next) { - if (iter == callback) { - LWIP_ASSERT("last != NULL", last != NULL); - last->next = callback->next; - callback->next = NULL; - return; - } - } - } -} - -/** - * Invoke extended netif status event - * @param netif netif that is affected by change - * @param reason change reason - * @param args depends on reason, see reason description - */ -void -netif_invoke_ext_callback(struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args) -{ - netif_ext_callback_t *callback = ext_callback; - - LWIP_ASSERT("netif must be != NULL", netif != NULL); - - while (callback != NULL) { - callback->callback_fn(netif, reason, args); - callback = callback->next; - } -} -#endif /* LWIP_NETIF_EXT_STATUS_CALLBACK */ +/** + * @file + * lwIP network interface abstraction + * + * @defgroup netif Network interface (NETIF) + * @ingroup callbackstyle_api + * + * @defgroup netif_ip4 IPv4 address handling + * @ingroup netif + * + * @defgroup netif_ip6 IPv6 address handling + * @ingroup netif + * + * @defgroup netif_cd Client data handling + * Store data (void*) on a netif for application usage. + * @see @ref LWIP_NUM_NETIF_CLIENT_DATA + * @ingroup netif + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + */ + +#include "lwip/opt.h" + +#include /* memset */ +#include /* atoi */ + +#include "lwip/def.h" +#include "lwip/ip_addr.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/udp.h" +#include "lwip/priv/raw_priv.h" +#include "lwip/snmp.h" +#include "lwip/igmp.h" +#include "lwip/etharp.h" +#include "lwip/stats.h" +#include "lwip/sys.h" +#include "lwip/ip.h" +#if ENABLE_LOOPBACK +#if LWIP_NETIF_LOOPBACK_MULTITHREADING +#include "lwip/tcpip.h" +#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ +#endif /* ENABLE_LOOPBACK */ + +#include "netif/ethernet.h" + +#if LWIP_AUTOIP +#include "lwip/autoip.h" +#endif /* LWIP_AUTOIP */ +#if LWIP_DHCP +#include "lwip/dhcp.h" +#endif /* LWIP_DHCP */ +#if LWIP_IPV6_DHCP6 +#include "lwip/dhcp6.h" +#endif /* LWIP_IPV6_DHCP6 */ +#if LWIP_IPV6_MLD +#include "lwip/mld6.h" +#endif /* LWIP_IPV6_MLD */ +#if LWIP_IPV6 +#include "lwip/nd6.h" +#endif + +#if LWIP_NETIF_STATUS_CALLBACK +#define NETIF_STATUS_CALLBACK(n) do{ if (n->status_callback) { (n->status_callback)(n); }}while(0) +#else +#define NETIF_STATUS_CALLBACK(n) +#endif /* LWIP_NETIF_STATUS_CALLBACK */ + +#if LWIP_NETIF_LINK_CALLBACK +#define NETIF_LINK_CALLBACK(n) do{ if (n->link_callback) { (n->link_callback)(n); }}while(0) +#else +#define NETIF_LINK_CALLBACK(n) +#endif /* LWIP_NETIF_LINK_CALLBACK */ + +#if LWIP_NETIF_EXT_STATUS_CALLBACK +static netif_ext_callback_t *ext_callback; +#endif + +#if !LWIP_SINGLE_NETIF +struct netif *netif_list; +#endif /* !LWIP_SINGLE_NETIF */ +struct netif *netif_default; + +#define netif_index_to_num(index) ((index) - 1) +static u8_t netif_num; + +#if LWIP_NUM_NETIF_CLIENT_DATA > 0 +static u8_t netif_client_id; +#endif + +#define NETIF_REPORT_TYPE_IPV4 0x01 +#define NETIF_REPORT_TYPE_IPV6 0x02 +static void netif_issue_reports(struct netif *netif, u8_t report_type); + +#if LWIP_IPV6 +static err_t netif_null_output_ip6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr); +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 +static err_t netif_null_output_ip4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr); +#endif /* LWIP_IPV4 */ + +#if LWIP_HAVE_LOOPIF +#if LWIP_IPV4 +static err_t netif_loop_output_ipv4(struct netif *netif, struct pbuf *p, const ip4_addr_t *addr); +#endif +#if LWIP_IPV6 +static err_t netif_loop_output_ipv6(struct netif *netif, struct pbuf *p, const ip6_addr_t *addr); +#endif + + +static struct netif loop_netif; + +/** + * Initialize a lwip network interface structure for a loopback interface + * + * @param netif the lwip network interface structure for this loopif + * @return ERR_OK if the loopif is initialized + * ERR_MEM if private data couldn't be allocated + */ +static err_t +netif_loopif_init(struct netif *netif) +{ + LWIP_ASSERT("netif_loopif_init: invalid netif", netif != NULL); + + /* initialize the snmp variables and counters inside the struct netif + * ifSpeed: no assumption can be made! + */ + MIB2_INIT_NETIF(netif, snmp_ifType_softwareLoopback, 0); + + netif->name[0] = 'l'; + netif->name[1] = 'o'; +#if LWIP_IPV4 + netif->output = netif_loop_output_ipv4; +#endif +#if LWIP_IPV6 + netif->output_ip6 = netif_loop_output_ipv6; +#endif +#if LWIP_LOOPIF_MULTICAST + netif_set_flags(netif, NETIF_FLAG_IGMP); +#endif + NETIF_SET_CHECKSUM_CTRL(netif, NETIF_CHECKSUM_DISABLE_ALL); + return ERR_OK; +} +#endif /* LWIP_HAVE_LOOPIF */ + +void +netif_init(void) +{ +#if LWIP_HAVE_LOOPIF +#if LWIP_IPV4 +#define LOOPIF_ADDRINIT &loop_ipaddr, &loop_netmask, &loop_gw, + ip4_addr_t loop_ipaddr, loop_netmask, loop_gw; + IP4_ADDR(&loop_gw, 127, 0, 0, 1); + IP4_ADDR(&loop_ipaddr, 127, 0, 0, 1); + IP4_ADDR(&loop_netmask, 255, 0, 0, 0); +#else /* LWIP_IPV4 */ +#define LOOPIF_ADDRINIT +#endif /* LWIP_IPV4 */ + +#if NO_SYS + netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, ip_input); +#else /* NO_SYS */ + netif_add(&loop_netif, LOOPIF_ADDRINIT NULL, netif_loopif_init, tcpip_input); +#endif /* NO_SYS */ + +#if LWIP_IPV6 + IP_ADDR6_HOST(loop_netif.ip6_addr, 0, 0, 0, 0x00000001UL); + loop_netif.ip6_addr_state[0] = IP6_ADDR_VALID; +#endif /* LWIP_IPV6 */ + + netif_set_link_up(&loop_netif); + netif_set_up(&loop_netif); + +#endif /* LWIP_HAVE_LOOPIF */ +} + +/** + * @ingroup lwip_nosys + * Forwards a received packet for input processing with + * ethernet_input() or ip_input() depending on netif flags. + * Don't call directly, pass to netif_add() and call + * netif->input(). + * Only works if the netif driver correctly sets + * NETIF_FLAG_ETHARP and/or NETIF_FLAG_ETHERNET flag! + */ +err_t +netif_input(struct pbuf *p, struct netif *inp) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("netif_input: invalid pbuf", p != NULL); + LWIP_ASSERT("netif_input: invalid netif", inp != NULL); + +#if LWIP_ETHERNET + if (inp->flags & (NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET)) { + return ethernet_input(p, inp); + } else +#endif /* LWIP_ETHERNET */ + return ip_input(p, inp); +} + +/** + * @ingroup netif + * Add a network interface to the list of lwIP netifs. + * + * Same as @ref netif_add but without IPv4 addresses + */ +struct netif * +netif_add_noaddr(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input) +{ + return netif_add(netif, +#if LWIP_IPV4 + NULL, NULL, NULL, +#endif /* LWIP_IPV4*/ + state, init, input); +} + +/** + * @ingroup netif + * Add a network interface to the list of lwIP netifs. + * + * @param netif a pre-allocated netif structure + * @param ipaddr IP address for the new netif + * @param netmask network mask for the new netif + * @param gw default gateway IP address for the new netif + * @param state opaque data passed to the new netif + * @param init callback function that initializes the interface + * @param input callback function that is called to pass + * ingress packets up in the protocol layer stack.\n + * It is recommended to use a function that passes the input directly + * to the stack (netif_input(), NO_SYS=1 mode) or via sending a + * message to TCPIP thread (tcpip_input(), NO_SYS=0 mode).\n + * These functions use netif flags NETIF_FLAG_ETHARP and NETIF_FLAG_ETHERNET + * to decide whether to forward to ethernet_input() or ip_input(). + * In other words, the functions only work when the netif + * driver is implemented correctly!\n + * Most members of struct netif should be be initialized by the + * netif init function = netif driver (init parameter of this function).\n + * IPv6: Don't forget to call netif_create_ip6_linklocal_address() after + * setting the MAC address in struct netif.hwaddr + * (IPv6 requires a link-local address). + * + * @return netif, or NULL if failed. + */ +struct netif * +netif_add(struct netif *netif, +#if LWIP_IPV4 + const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, +#endif /* LWIP_IPV4 */ + void *state, netif_init_fn init, netif_input_fn input) +{ +#if LWIP_IPV6 + s8_t i; +#endif + + LWIP_ASSERT_CORE_LOCKED(); + +#if LWIP_SINGLE_NETIF + if (netif_default != NULL) { + LWIP_ASSERT("single netif already set", 0); + return NULL; + } +#endif + + LWIP_ERROR("netif_add: invalid netif", netif != NULL, return NULL); + LWIP_ERROR("netif_add: No init function given", init != NULL, return NULL); + +#if LWIP_IPV4 + if (ipaddr == NULL) { + ipaddr = ip_2_ip4(IP4_ADDR_ANY); + } + if (netmask == NULL) { + netmask = ip_2_ip4(IP4_ADDR_ANY); + } + if (gw == NULL) { + gw = ip_2_ip4(IP4_ADDR_ANY); + } + + /* reset new interface configuration state */ + ip_addr_set_zero_ip4(&netif->ip_addr); + ip_addr_set_zero_ip4(&netif->netmask); + ip_addr_set_zero_ip4(&netif->gw); + netif->output = netif_null_output_ip4; +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + ip_addr_set_zero_ip6(&netif->ip6_addr[i]); + netif->ip6_addr_state[i] = IP6_ADDR_INVALID; +#if LWIP_IPV6_ADDRESS_LIFETIMES + netif->ip6_addr_valid_life[i] = IP6_ADDR_LIFE_STATIC; + netif->ip6_addr_pref_life[i] = IP6_ADDR_LIFE_STATIC; +#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ + } + netif->output_ip6 = netif_null_output_ip6; +#endif /* LWIP_IPV6 */ + NETIF_SET_CHECKSUM_CTRL(netif, NETIF_CHECKSUM_ENABLE_ALL); + netif->mtu = 0; + netif->flags = 0; +#ifdef netif_get_client_data + memset(netif->client_data, 0, sizeof(netif->client_data)); +#endif /* LWIP_NUM_NETIF_CLIENT_DATA */ +#if LWIP_IPV6 +#if LWIP_IPV6_AUTOCONFIG + /* IPv6 address autoconfiguration not enabled by default */ + netif->ip6_autoconfig_enabled = 0; +#endif /* LWIP_IPV6_AUTOCONFIG */ + nd6_restart_netif(netif); +#endif /* LWIP_IPV6 */ +#if LWIP_NETIF_STATUS_CALLBACK + netif->status_callback = NULL; +#endif /* LWIP_NETIF_STATUS_CALLBACK */ +#if LWIP_NETIF_LINK_CALLBACK + netif->link_callback = NULL; +#endif /* LWIP_NETIF_LINK_CALLBACK */ +#if LWIP_IGMP + netif->igmp_mac_filter = NULL; +#endif /* LWIP_IGMP */ +#if LWIP_IPV6 && LWIP_IPV6_MLD + netif->mld_mac_filter = NULL; +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ +#if ENABLE_LOOPBACK + netif->loop_first = NULL; + netif->loop_last = NULL; +#endif /* ENABLE_LOOPBACK */ + + /* remember netif specific state information data */ + netif->state = state; + netif->num = netif_num; + netif->input = input; + + + NETIF_RESET_HINTS(netif); +#if ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS + netif->loop_cnt_current = 0; +#endif /* ENABLE_LOOPBACK && LWIP_LOOPBACK_MAX_PBUFS */ + +#if LWIP_IPV4 + netif_set_addr(netif, ipaddr, netmask, gw); +#endif /* LWIP_IPV4 */ + + /* call user specified initialization function for netif */ + if (init(netif) != ERR_OK) { + return NULL; + } +#if LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES + /* Initialize the MTU for IPv6 to the one set by the netif driver. + This can be updated later by RA. */ + netif->mtu6 = netif->mtu; +#endif /* LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES */ + +#if !LWIP_SINGLE_NETIF + /* Assign a unique netif number in the range [0..254], so that (num+1) can + serve as an interface index that fits in a u8_t. + We assume that the new netif has not yet been added to the list here. + This algorithm is O(n^2), but that should be OK for lwIP. + */ + { + struct netif *netif2; + int num_netifs; + do { + if (netif->num == 255) { + netif->num = 0; + } + num_netifs = 0; + for (netif2 = netif_list; netif2 != NULL; netif2 = netif2->next) { + LWIP_ASSERT("netif already added", netif2 != netif); + num_netifs++; + LWIP_ASSERT("too many netifs, max. supported number is 255", num_netifs <= 255); + if (netif2->num == netif->num) { + netif->num++; + break; + } + } + } while (netif2 != NULL); + } + if (netif->num == 254) { + netif_num = 0; + } else { + netif_num = (u8_t)(netif->num + 1); + } + + /* add this netif to the list */ + netif->next = netif_list; + netif_list = netif; +#endif /* "LWIP_SINGLE_NETIF */ + mib2_netif_added(netif); + +#if LWIP_IGMP + /* start IGMP processing */ + if (netif->flags & NETIF_FLAG_IGMP) { + igmp_start(netif); + } +#endif /* LWIP_IGMP */ + + LWIP_DEBUGF(NETIF_DEBUG, ("netif: added interface %c%c IP", + netif->name[0], netif->name[1])); +#if LWIP_IPV4 + LWIP_DEBUGF(NETIF_DEBUG, (" addr ")); + ip4_addr_debug_print(NETIF_DEBUG, ipaddr); + LWIP_DEBUGF(NETIF_DEBUG, (" netmask ")); + ip4_addr_debug_print(NETIF_DEBUG, netmask); + LWIP_DEBUGF(NETIF_DEBUG, (" gw ")); + ip4_addr_debug_print(NETIF_DEBUG, gw); +#endif /* LWIP_IPV4 */ + LWIP_DEBUGF(NETIF_DEBUG, ("\n")); + + netif_invoke_ext_callback(netif, LWIP_NSC_NETIF_ADDED, NULL); + + return netif; +} + +static void +netif_do_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) +{ +#if LWIP_TCP + tcp_netif_ip_addr_changed(old_addr, new_addr); +#endif /* LWIP_TCP */ +#if LWIP_UDP + udp_netif_ip_addr_changed(old_addr, new_addr); +#endif /* LWIP_UDP */ +#if LWIP_RAW + raw_netif_ip_addr_changed(old_addr, new_addr); +#endif /* LWIP_RAW */ +} + +#if LWIP_IPV4 +static int +netif_do_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr, ip_addr_t *old_addr) +{ + LWIP_ASSERT("invalid pointer", ipaddr != NULL); + LWIP_ASSERT("invalid pointer", old_addr != NULL); + + /* address is actually being changed? */ + if (ip4_addr_cmp(ipaddr, netif_ip4_addr(netif)) == 0) { + ip_addr_t new_addr; + *ip_2_ip4(&new_addr) = *ipaddr; + IP_SET_TYPE_VAL(new_addr, IPADDR_TYPE_V4); + + ip_addr_copy(*old_addr, *netif_ip_addr4(netif)); + + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: netif address being changed\n")); + netif_do_ip_addr_changed(old_addr, &new_addr); + + mib2_remove_ip4(netif); + mib2_remove_route_ip4(0, netif); + /* set new IP address to netif */ + ip4_addr_set(ip_2_ip4(&netif->ip_addr), ipaddr); + IP_SET_TYPE_VAL(netif->ip_addr, IPADDR_TYPE_V4); + mib2_add_ip4(netif); + mib2_add_route_ip4(0, netif); + + netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4); + + NETIF_STATUS_CALLBACK(netif); + return 1; /* address changed */ + } + return 0; /* address unchanged */ +} + +/** + * @ingroup netif_ip4 + * Change the IP address of a network interface + * + * @param netif the network interface to change + * @param ipaddr the new IP address + * + * @note call netif_set_addr() if you also want to change netmask and + * default gateway + */ +void +netif_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr) +{ + ip_addr_t old_addr; + + LWIP_ERROR("netif_set_ipaddr: invalid netif", netif != NULL, return); + + /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ + if (ipaddr == NULL) { + ipaddr = IP4_ADDR_ANY4; + } + + LWIP_ASSERT_CORE_LOCKED(); + + if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + netif_ext_callback_args_t args; + args.ipv4_changed.old_address = &old_addr; + netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_ADDRESS_CHANGED, &args); +#endif + } +} + +static int +netif_do_set_netmask(struct netif *netif, const ip4_addr_t *netmask, ip_addr_t *old_nm) +{ + /* address is actually being changed? */ + if (ip4_addr_cmp(netmask, netif_ip4_netmask(netif)) == 0) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + LWIP_ASSERT("invalid pointer", old_nm != NULL); + ip_addr_copy(*old_nm, *netif_ip_netmask4(netif)); +#else + LWIP_UNUSED_ARG(old_nm); +#endif + mib2_remove_route_ip4(0, netif); + /* set new netmask to netif */ + ip4_addr_set(ip_2_ip4(&netif->netmask), netmask); + IP_SET_TYPE_VAL(netif->netmask, IPADDR_TYPE_V4); + mib2_add_route_ip4(0, netif); + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: netmask of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + netif->name[0], netif->name[1], + ip4_addr1_16(netif_ip4_netmask(netif)), + ip4_addr2_16(netif_ip4_netmask(netif)), + ip4_addr3_16(netif_ip4_netmask(netif)), + ip4_addr4_16(netif_ip4_netmask(netif)))); + return 1; /* netmask changed */ + } + return 0; /* netmask unchanged */ +} + +/** + * @ingroup netif_ip4 + * Change the netmask of a network interface + * + * @param netif the network interface to change + * @param netmask the new netmask + * + * @note call netif_set_addr() if you also want to change ip address and + * default gateway + */ +void +netif_set_netmask(struct netif *netif, const ip4_addr_t *netmask) +{ +#if LWIP_NETIF_EXT_STATUS_CALLBACK + ip_addr_t old_nm_val; + ip_addr_t *old_nm = &old_nm_val; +#else + ip_addr_t *old_nm = NULL; +#endif + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("netif_set_netmask: invalid netif", netif != NULL, return); + + /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ + if (netmask == NULL) { + netmask = IP4_ADDR_ANY4; + } + + if (netif_do_set_netmask(netif, netmask, old_nm)) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + netif_ext_callback_args_t args; + args.ipv4_changed.old_netmask = old_nm; + netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_NETMASK_CHANGED, &args); +#endif + } +} + +static int +netif_do_set_gw(struct netif *netif, const ip4_addr_t *gw, ip_addr_t *old_gw) +{ + /* address is actually being changed? */ + if (ip4_addr_cmp(gw, netif_ip4_gw(netif)) == 0) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + LWIP_ASSERT("invalid pointer", old_gw != NULL); + ip_addr_copy(*old_gw, *netif_ip_gw4(netif)); +#else + LWIP_UNUSED_ARG(old_gw); +#endif + + ip4_addr_set(ip_2_ip4(&netif->gw), gw); + IP_SET_TYPE_VAL(netif->gw, IPADDR_TYPE_V4); + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: GW address of interface %c%c set to %"U16_F".%"U16_F".%"U16_F".%"U16_F"\n", + netif->name[0], netif->name[1], + ip4_addr1_16(netif_ip4_gw(netif)), + ip4_addr2_16(netif_ip4_gw(netif)), + ip4_addr3_16(netif_ip4_gw(netif)), + ip4_addr4_16(netif_ip4_gw(netif)))); + return 1; /* gateway changed */ + } + return 0; /* gateway unchanged */ +} + +/** + * @ingroup netif_ip4 + * Change the default gateway for a network interface + * + * @param netif the network interface to change + * @param gw the new default gateway + * + * @note call netif_set_addr() if you also want to change ip address and netmask + */ +void +netif_set_gw(struct netif *netif, const ip4_addr_t *gw) +{ +#if LWIP_NETIF_EXT_STATUS_CALLBACK + ip_addr_t old_gw_val; + ip_addr_t *old_gw = &old_gw_val; +#else + ip_addr_t *old_gw = NULL; +#endif + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("netif_set_gw: invalid netif", netif != NULL, return); + + /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ + if (gw == NULL) { + gw = IP4_ADDR_ANY4; + } + + if (netif_do_set_gw(netif, gw, old_gw)) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + netif_ext_callback_args_t args; + args.ipv4_changed.old_gw = old_gw; + netif_invoke_ext_callback(netif, LWIP_NSC_IPV4_GATEWAY_CHANGED, &args); +#endif + } +} + +/** + * @ingroup netif_ip4 + * Change IP address configuration for a network interface (including netmask + * and default gateway). + * + * @param netif the network interface to change + * @param ipaddr the new IP address + * @param netmask the new netmask + * @param gw the new default gateway + */ +void +netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, + const ip4_addr_t *gw) +{ +#if LWIP_NETIF_EXT_STATUS_CALLBACK + netif_nsc_reason_t change_reason = LWIP_NSC_NONE; + netif_ext_callback_args_t cb_args; + ip_addr_t old_nm_val; + ip_addr_t old_gw_val; + ip_addr_t *old_nm = &old_nm_val; + ip_addr_t *old_gw = &old_gw_val; +#else + ip_addr_t *old_nm = NULL; + ip_addr_t *old_gw = NULL; +#endif + ip_addr_t old_addr; + int remove; + + LWIP_ASSERT_CORE_LOCKED(); + + /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ + if (ipaddr == NULL) { + ipaddr = IP4_ADDR_ANY4; + } + if (netmask == NULL) { + netmask = IP4_ADDR_ANY4; + } + if (gw == NULL) { + gw = IP4_ADDR_ANY4; + } + + remove = ip4_addr_isany(ipaddr); + if (remove) { + /* when removing an address, we have to remove it *before* changing netmask/gw + to ensure that tcp RST segment can be sent correctly */ + if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + change_reason |= LWIP_NSC_IPV4_ADDRESS_CHANGED; + cb_args.ipv4_changed.old_address = &old_addr; +#endif + } + } + if (netif_do_set_netmask(netif, netmask, old_nm)) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + change_reason |= LWIP_NSC_IPV4_NETMASK_CHANGED; + cb_args.ipv4_changed.old_netmask = old_nm; +#endif + } + if (netif_do_set_gw(netif, gw, old_gw)) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + change_reason |= LWIP_NSC_IPV4_GATEWAY_CHANGED; + cb_args.ipv4_changed.old_gw = old_gw; +#endif + } + if (!remove) { + /* set ipaddr last to ensure netmask/gw have been set when status callback is called */ + if (netif_do_set_ipaddr(netif, ipaddr, &old_addr)) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + change_reason |= LWIP_NSC_IPV4_ADDRESS_CHANGED; + cb_args.ipv4_changed.old_address = &old_addr; +#endif + } + } + +#if LWIP_NETIF_EXT_STATUS_CALLBACK + if (change_reason != LWIP_NSC_NONE) { + change_reason |= LWIP_NSC_IPV4_SETTINGS_CHANGED; + netif_invoke_ext_callback(netif, change_reason, &cb_args); + } +#endif +} +#endif /* LWIP_IPV4*/ + +/** + * @ingroup netif + * Remove a network interface from the list of lwIP netifs. + * + * @param netif the network interface to remove + */ +void +netif_remove(struct netif *netif) +{ +#if LWIP_IPV6 + int i; +#endif + + LWIP_ASSERT_CORE_LOCKED(); + + if (netif == NULL) { + return; + } + + netif_invoke_ext_callback(netif, LWIP_NSC_NETIF_REMOVED, NULL); + +#if LWIP_IPV4 + if (!ip4_addr_isany_val(*netif_ip4_addr(netif))) { + netif_do_ip_addr_changed(netif_ip_addr4(netif), NULL); + } + +#if LWIP_IGMP + /* stop IGMP processing */ + if (netif->flags & NETIF_FLAG_IGMP) { + igmp_stop(netif); + } +#endif /* LWIP_IGMP */ +#endif /* LWIP_IPV4*/ + +#if LWIP_IPV6 + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, i))) { + netif_do_ip_addr_changed(netif_ip_addr6(netif, i), NULL); + } + } +#if LWIP_IPV6_MLD + /* stop MLD processing */ + mld6_stop(netif); +#endif /* LWIP_IPV6_MLD */ +#endif /* LWIP_IPV6 */ + if (netif_is_up(netif)) { + /* set netif down before removing (call callback function) */ + netif_set_down(netif); + } + + mib2_remove_ip4(netif); + + /* this netif is default? */ + if (netif_default == netif) { + /* reset default netif */ + netif_set_default(NULL); + } +#if !LWIP_SINGLE_NETIF + /* is it the first netif? */ + if (netif_list == netif) { + netif_list = netif->next; + } else { + /* look for netif further down the list */ + struct netif *tmp_netif; + NETIF_FOREACH(tmp_netif) { + if (tmp_netif->next == netif) { + tmp_netif->next = netif->next; + break; + } + } + if (tmp_netif == NULL) { + return; /* netif is not on the list */ + } + } +#endif /* !LWIP_SINGLE_NETIF */ + mib2_netif_removed(netif); +#if LWIP_NETIF_REMOVE_CALLBACK + if (netif->remove_callback) { + netif->remove_callback(netif); + } +#endif /* LWIP_NETIF_REMOVE_CALLBACK */ + LWIP_DEBUGF( NETIF_DEBUG, ("netif_remove: removed netif\n") ); +} + +/** + * @ingroup netif + * Set a network interface as the default network interface + * (used to output all packets for which no specific route is found) + * + * @param netif the default network interface + */ +void +netif_set_default(struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + + if (netif == NULL) { + /* remove default route */ + mib2_remove_route_ip4(1, netif); + } else { + /* install default route */ + mib2_add_route_ip4(1, netif); + } + netif_default = netif; + LWIP_DEBUGF(NETIF_DEBUG, ("netif: setting default interface %c%c\n", + netif ? netif->name[0] : '\'', netif ? netif->name[1] : '\'')); +} + +/** + * @ingroup netif + * Bring an interface up, available for processing + * traffic. + */ +void +netif_set_up(struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("netif_set_up: invalid netif", netif != NULL, return); + + if (!(netif->flags & NETIF_FLAG_UP)) { + netif_set_flags(netif, NETIF_FLAG_UP); + + MIB2_COPY_SYSUPTIME_TO(&netif->ts); + + NETIF_STATUS_CALLBACK(netif); + +#if LWIP_NETIF_EXT_STATUS_CALLBACK + { + netif_ext_callback_args_t args; + args.status_changed.state = 1; + netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args); + } +#endif + + netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6); +#if LWIP_IPV6 + nd6_restart_netif(netif); +#endif /* LWIP_IPV6 */ + } +} + +/** Send ARP/IGMP/MLD/RS events, e.g. on link-up/netif-up or addr-change + */ +static void +netif_issue_reports(struct netif *netif, u8_t report_type) +{ + LWIP_ASSERT("netif_issue_reports: invalid netif", netif != NULL); + + /* Only send reports when both link and admin states are up */ + if (!(netif->flags & NETIF_FLAG_LINK_UP) || + !(netif->flags & NETIF_FLAG_UP)) { + return; + } + +#if LWIP_IPV4 + if ((report_type & NETIF_REPORT_TYPE_IPV4) && + !ip4_addr_isany_val(*netif_ip4_addr(netif))) { +#if LWIP_ARP + /* For Ethernet network interfaces, we would like to send a "gratuitous ARP" */ + if (netif->flags & (NETIF_FLAG_ETHARP)) { + etharp_gratuitous(netif); + } +#endif /* LWIP_ARP */ + +#if LWIP_IGMP + /* resend IGMP memberships */ + if (netif->flags & NETIF_FLAG_IGMP) { + igmp_report_groups(netif); + } +#endif /* LWIP_IGMP */ + } +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 + if (report_type & NETIF_REPORT_TYPE_IPV6) { +#if LWIP_IPV6_MLD + /* send mld memberships */ + mld6_report_groups(netif); +#endif /* LWIP_IPV6_MLD */ + } +#endif /* LWIP_IPV6 */ +} + +/** + * @ingroup netif + * Bring an interface down, disabling any traffic processing. + */ +void +netif_set_down(struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("netif_set_down: invalid netif", netif != NULL, return); + + if (netif->flags & NETIF_FLAG_UP) { +#if LWIP_NETIF_EXT_STATUS_CALLBACK + { + netif_ext_callback_args_t args; + args.status_changed.state = 0; + netif_invoke_ext_callback(netif, LWIP_NSC_STATUS_CHANGED, &args); + } +#endif + + netif_clear_flags(netif, NETIF_FLAG_UP); + MIB2_COPY_SYSUPTIME_TO(&netif->ts); + +#if LWIP_IPV4 && LWIP_ARP + if (netif->flags & NETIF_FLAG_ETHARP) { + etharp_cleanup_netif(netif); + } +#endif /* LWIP_IPV4 && LWIP_ARP */ + +#if LWIP_IPV6 + nd6_cleanup_netif(netif); +#endif /* LWIP_IPV6 */ + + NETIF_STATUS_CALLBACK(netif); + } +} + +#if LWIP_NETIF_STATUS_CALLBACK +/** + * @ingroup netif + * Set callback to be called when interface is brought up/down or address is changed while up + */ +void +netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback) +{ + LWIP_ASSERT_CORE_LOCKED(); + + if (netif) { + netif->status_callback = status_callback; + } +} +#endif /* LWIP_NETIF_STATUS_CALLBACK */ + +#if LWIP_NETIF_REMOVE_CALLBACK +/** + * @ingroup netif + * Set callback to be called when the interface has been removed + */ +void +netif_set_remove_callback(struct netif *netif, netif_status_callback_fn remove_callback) +{ + LWIP_ASSERT_CORE_LOCKED(); + + if (netif) { + netif->remove_callback = remove_callback; + } +} +#endif /* LWIP_NETIF_REMOVE_CALLBACK */ + +/** + * @ingroup netif + * Called by a driver when its link goes up + */ +void +netif_set_link_up(struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("netif_set_link_up: invalid netif", netif != NULL, return); + + if (!(netif->flags & NETIF_FLAG_LINK_UP)) { + netif_set_flags(netif, NETIF_FLAG_LINK_UP); + +#if LWIP_DHCP + dhcp_network_changed(netif); +#endif /* LWIP_DHCP */ + +#if LWIP_AUTOIP + autoip_network_changed(netif); +#endif /* LWIP_AUTOIP */ + + netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV4 | NETIF_REPORT_TYPE_IPV6); +#if LWIP_IPV6 + nd6_restart_netif(netif); +#endif /* LWIP_IPV6 */ + + NETIF_LINK_CALLBACK(netif); +#if LWIP_NETIF_EXT_STATUS_CALLBACK + { + netif_ext_callback_args_t args; + args.link_changed.state = 1; + netif_invoke_ext_callback(netif, LWIP_NSC_LINK_CHANGED, &args); + } +#endif + } +} + +/** + * @ingroup netif + * Called by a driver when its link goes down + */ +void +netif_set_link_down(struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("netif_set_link_down: invalid netif", netif != NULL, return); + + if (netif->flags & NETIF_FLAG_LINK_UP) { + netif_clear_flags(netif, NETIF_FLAG_LINK_UP); + NETIF_LINK_CALLBACK(netif); +#if LWIP_NETIF_EXT_STATUS_CALLBACK + { + netif_ext_callback_args_t args; + args.link_changed.state = 0; + netif_invoke_ext_callback(netif, LWIP_NSC_LINK_CHANGED, &args); + } +#endif + } +} + +#if LWIP_NETIF_LINK_CALLBACK +/** + * @ingroup netif + * Set callback to be called when link is brought up/down + */ +void +netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_callback) +{ + LWIP_ASSERT_CORE_LOCKED(); + + if (netif) { + netif->link_callback = link_callback; + } +} +#endif /* LWIP_NETIF_LINK_CALLBACK */ + +#if ENABLE_LOOPBACK +/** + * @ingroup netif + * Send an IP packet to be received on the same netif (loopif-like). + * The pbuf is simply copied and handed back to netif->input. + * In multithreaded mode, this is done directly since netif->input must put + * the packet on a queue. + * In callback mode, the packet is put on an internal queue and is fed to + * netif->input by netif_poll(). + * + * @param netif the lwip network interface structure + * @param p the (IP) packet to 'send' + * @return ERR_OK if the packet has been sent + * ERR_MEM if the pbuf used to copy the packet couldn't be allocated + */ +err_t +netif_loop_output(struct netif *netif, struct pbuf *p) +{ + struct pbuf *r; + err_t err; + struct pbuf *last; +#if LWIP_LOOPBACK_MAX_PBUFS + u16_t clen = 0; +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ + /* If we have a loopif, SNMP counters are adjusted for it, + * if not they are adjusted for 'netif'. */ +#if MIB2_STATS +#if LWIP_HAVE_LOOPIF + struct netif *stats_if = &loop_netif; +#else /* LWIP_HAVE_LOOPIF */ + struct netif *stats_if = netif; +#endif /* LWIP_HAVE_LOOPIF */ +#endif /* MIB2_STATS */ +#if LWIP_NETIF_LOOPBACK_MULTITHREADING + u8_t schedule_poll = 0; +#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ + SYS_ARCH_DECL_PROTECT(lev); + + LWIP_ASSERT("netif_loop_output: invalid netif", netif != NULL); + LWIP_ASSERT("netif_loop_output: invalid pbuf", p != NULL); + + /* Allocate a new pbuf */ + r = pbuf_alloc(PBUF_LINK, p->tot_len, PBUF_RAM); + if (r == NULL) { + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(stats_if, ifoutdiscards); + return ERR_MEM; + } +#if LWIP_LOOPBACK_MAX_PBUFS + clen = pbuf_clen(r); + /* check for overflow or too many pbuf on queue */ + if (((netif->loop_cnt_current + clen) < netif->loop_cnt_current) || + ((netif->loop_cnt_current + clen) > LWIP_MIN(LWIP_LOOPBACK_MAX_PBUFS, 0xFFFF))) { + pbuf_free(r); + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(stats_if, ifoutdiscards); + return ERR_MEM; + } + netif->loop_cnt_current = (u16_t)(netif->loop_cnt_current + clen); +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ + + /* Copy the whole pbuf queue p into the single pbuf r */ + if ((err = pbuf_copy(r, p)) != ERR_OK) { + pbuf_free(r); + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(stats_if, ifoutdiscards); + return err; + } + + /* Put the packet on a linked list which gets emptied through calling + netif_poll(). */ + + /* let last point to the last pbuf in chain r */ + for (last = r; last->next != NULL; last = last->next) { + /* nothing to do here, just get to the last pbuf */ + } + + SYS_ARCH_PROTECT(lev); + if (netif->loop_first != NULL) { + LWIP_ASSERT("if first != NULL, last must also be != NULL", netif->loop_last != NULL); + netif->loop_last->next = r; + netif->loop_last = last; + } else { + netif->loop_first = r; + netif->loop_last = last; +#if LWIP_NETIF_LOOPBACK_MULTITHREADING + /* No existing packets queued, schedule poll */ + schedule_poll = 1; +#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ + } + SYS_ARCH_UNPROTECT(lev); + + LINK_STATS_INC(link.xmit); + MIB2_STATS_NETIF_ADD(stats_if, ifoutoctets, p->tot_len); + MIB2_STATS_NETIF_INC(stats_if, ifoutucastpkts); + +#if LWIP_NETIF_LOOPBACK_MULTITHREADING + /* For multithreading environment, schedule a call to netif_poll */ + if (schedule_poll) { + tcpip_try_callback((tcpip_callback_fn)netif_poll, netif); + } +#endif /* LWIP_NETIF_LOOPBACK_MULTITHREADING */ + + return ERR_OK; +} + +#if LWIP_HAVE_LOOPIF +#if LWIP_IPV4 +static err_t +netif_loop_output_ipv4(struct netif *netif, struct pbuf *p, const ip4_addr_t *addr) +{ + LWIP_UNUSED_ARG(addr); + return netif_loop_output(netif, p); +} +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +static err_t +netif_loop_output_ipv6(struct netif *netif, struct pbuf *p, const ip6_addr_t *addr) +{ + LWIP_UNUSED_ARG(addr); + return netif_loop_output(netif, p); +} +#endif /* LWIP_IPV6 */ +#endif /* LWIP_HAVE_LOOPIF */ + + +/** + * Call netif_poll() in the main loop of your application. This is to prevent + * reentering non-reentrant functions like tcp_input(). Packets passed to + * netif_loop_output() are put on a list that is passed to netif->input() by + * netif_poll(). + */ +void +netif_poll(struct netif *netif) +{ + /* If we have a loopif, SNMP counters are adjusted for it, + * if not they are adjusted for 'netif'. */ +#if MIB2_STATS +#if LWIP_HAVE_LOOPIF + struct netif *stats_if = &loop_netif; +#else /* LWIP_HAVE_LOOPIF */ + struct netif *stats_if = netif; +#endif /* LWIP_HAVE_LOOPIF */ +#endif /* MIB2_STATS */ + SYS_ARCH_DECL_PROTECT(lev); + + LWIP_ASSERT("netif_poll: invalid netif", netif != NULL); + + /* Get a packet from the list. With SYS_LIGHTWEIGHT_PROT=1, this is protected */ + SYS_ARCH_PROTECT(lev); + while (netif->loop_first != NULL) { + struct pbuf *in, *in_end; +#if LWIP_LOOPBACK_MAX_PBUFS + u8_t clen = 1; +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ + + in = in_end = netif->loop_first; + while (in_end->len != in_end->tot_len) { + LWIP_ASSERT("bogus pbuf: len != tot_len but next == NULL!", in_end->next != NULL); + in_end = in_end->next; +#if LWIP_LOOPBACK_MAX_PBUFS + clen++; +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ + } +#if LWIP_LOOPBACK_MAX_PBUFS + /* adjust the number of pbufs on queue */ + LWIP_ASSERT("netif->loop_cnt_current underflow", + ((netif->loop_cnt_current - clen) < netif->loop_cnt_current)); + netif->loop_cnt_current = (u16_t)(netif->loop_cnt_current - clen); +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ + + /* 'in_end' now points to the last pbuf from 'in' */ + if (in_end == netif->loop_last) { + /* this was the last pbuf in the list */ + netif->loop_first = netif->loop_last = NULL; + } else { + /* pop the pbuf off the list */ + netif->loop_first = in_end->next; + LWIP_ASSERT("should not be null since first != last!", netif->loop_first != NULL); + } + /* De-queue the pbuf from its successors on the 'loop_' list. */ + in_end->next = NULL; + SYS_ARCH_UNPROTECT(lev); + + in->if_idx = netif_get_index(netif); + + LINK_STATS_INC(link.recv); + MIB2_STATS_NETIF_ADD(stats_if, ifinoctets, in->tot_len); + MIB2_STATS_NETIF_INC(stats_if, ifinucastpkts); + /* loopback packets are always IP packets! */ + if (ip_input(in, netif) != ERR_OK) { + pbuf_free(in); + } + SYS_ARCH_PROTECT(lev); + } + SYS_ARCH_UNPROTECT(lev); +} + +#if !LWIP_NETIF_LOOPBACK_MULTITHREADING +/** + * Calls netif_poll() for every netif on the netif_list. + */ +void +netif_poll_all(void) +{ + struct netif *netif; + /* loop through netifs */ + NETIF_FOREACH(netif) { + netif_poll(netif); + } +} +#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */ +#endif /* ENABLE_LOOPBACK */ + +#if LWIP_NUM_NETIF_CLIENT_DATA > 0 +/** + * @ingroup netif_cd + * Allocate an index to store data in client_data member of struct netif. + * Returned value is an index in mentioned array. + * @see LWIP_NUM_NETIF_CLIENT_DATA + */ +u8_t +netif_alloc_client_data_id(void) +{ + u8_t result = netif_client_id; + netif_client_id++; + + LWIP_ASSERT_CORE_LOCKED(); + +#if LWIP_NUM_NETIF_CLIENT_DATA > 256 +#error LWIP_NUM_NETIF_CLIENT_DATA must be <= 256 +#endif + LWIP_ASSERT("Increase LWIP_NUM_NETIF_CLIENT_DATA in lwipopts.h", result < LWIP_NUM_NETIF_CLIENT_DATA); + return (u8_t)(result + LWIP_NETIF_CLIENT_DATA_INDEX_MAX); +} +#endif + +#if LWIP_IPV6 +/** + * @ingroup netif_ip6 + * Change an IPv6 address of a network interface + * + * @param netif the network interface to change + * @param addr_idx index of the IPv6 address + * @param addr6 the new IPv6 address + * + * @note call netif_ip6_addr_set_state() to set the address valid/temptative + */ +void +netif_ip6_addr_set(struct netif *netif, s8_t addr_idx, const ip6_addr_t *addr6) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("netif_ip6_addr_set: invalid netif", netif != NULL); + LWIP_ASSERT("netif_ip6_addr_set: invalid addr6", addr6 != NULL); + + netif_ip6_addr_set_parts(netif, addr_idx, addr6->addr[0], addr6->addr[1], + addr6->addr[2], addr6->addr[3]); +} + +/* + * Change an IPv6 address of a network interface (internal version taking 4 * u32_t) + * + * @param netif the network interface to change + * @param addr_idx index of the IPv6 address + * @param i0 word0 of the new IPv6 address + * @param i1 word1 of the new IPv6 address + * @param i2 word2 of the new IPv6 address + * @param i3 word3 of the new IPv6 address + */ +void +netif_ip6_addr_set_parts(struct netif *netif, s8_t addr_idx, u32_t i0, u32_t i1, u32_t i2, u32_t i3) +{ + ip_addr_t old_addr; + ip_addr_t new_ipaddr; + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("invalid index", addr_idx < LWIP_IPV6_NUM_ADDRESSES); + + ip6_addr_copy(*ip_2_ip6(&old_addr), *netif_ip6_addr(netif, addr_idx)); + IP_SET_TYPE_VAL(old_addr, IPADDR_TYPE_V6); + + /* address is actually being changed? */ + if ((ip_2_ip6(&old_addr)->addr[0] != i0) || (ip_2_ip6(&old_addr)->addr[1] != i1) || + (ip_2_ip6(&old_addr)->addr[2] != i2) || (ip_2_ip6(&old_addr)->addr[3] != i3)) { + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_ip6_addr_set: netif address being changed\n")); + + IP_ADDR6(&new_ipaddr, i0, i1, i2, i3); + ip6_addr_assign_zone(ip_2_ip6(&new_ipaddr), IP6_UNICAST, netif); + + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, addr_idx))) { + netif_do_ip_addr_changed(netif_ip_addr6(netif, addr_idx), &new_ipaddr); + } + /* @todo: remove/readd mib2 ip6 entries? */ + + ip_addr_copy(netif->ip6_addr[addr_idx], new_ipaddr); + + if (ip6_addr_isvalid(netif_ip6_addr_state(netif, addr_idx))) { + netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV6); + NETIF_STATUS_CALLBACK(netif); + } + +#if LWIP_NETIF_EXT_STATUS_CALLBACK + { + netif_ext_callback_args_t args; + args.ipv6_set.addr_index = addr_idx; + args.ipv6_set.old_address = &old_addr; + netif_invoke_ext_callback(netif, LWIP_NSC_IPV6_SET, &args); + } +#endif + } + + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: IPv6 address %d of interface %c%c set to %s/0x%"X8_F"\n", + addr_idx, netif->name[0], netif->name[1], ip6addr_ntoa(netif_ip6_addr(netif, addr_idx)), + netif_ip6_addr_state(netif, addr_idx))); +} + +/** + * @ingroup netif_ip6 + * Change the state of an IPv6 address of a network interface + * (INVALID, TEMPTATIVE, PREFERRED, DEPRECATED, where TEMPTATIVE + * includes the number of checks done, see ip6_addr.h) + * + * @param netif the network interface to change + * @param addr_idx index of the IPv6 address + * @param state the new IPv6 address state + */ +void +netif_ip6_addr_set_state(struct netif *netif, s8_t addr_idx, u8_t state) +{ + u8_t old_state; + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("invalid index", addr_idx < LWIP_IPV6_NUM_ADDRESSES); + + old_state = netif_ip6_addr_state(netif, addr_idx); + /* state is actually being changed? */ + if (old_state != state) { + u8_t old_valid = old_state & IP6_ADDR_VALID; + u8_t new_valid = state & IP6_ADDR_VALID; + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_ip6_addr_set_state: netif address state being changed\n")); + +#if LWIP_IPV6_MLD + /* Reevaluate solicited-node multicast group membership. */ + if (netif->flags & NETIF_FLAG_MLD6) { + nd6_adjust_mld_membership(netif, addr_idx, state); + } +#endif /* LWIP_IPV6_MLD */ + + if (old_valid && !new_valid) { + /* address about to be removed by setting invalid */ + netif_do_ip_addr_changed(netif_ip_addr6(netif, addr_idx), NULL); + /* @todo: remove mib2 ip6 entries? */ + } + netif->ip6_addr_state[addr_idx] = state; + + if (!old_valid && new_valid) { + /* address added by setting valid */ + /* This is a good moment to check that the address is properly zoned. */ + IP6_ADDR_ZONECHECK_NETIF(netif_ip6_addr(netif, addr_idx), netif); + /* @todo: add mib2 ip6 entries? */ + netif_issue_reports(netif, NETIF_REPORT_TYPE_IPV6); + } + if ((old_state & ~IP6_ADDR_TENTATIVE_COUNT_MASK) != + (state & ~IP6_ADDR_TENTATIVE_COUNT_MASK)) { + /* address state has changed -> call the callback function */ + NETIF_STATUS_CALLBACK(netif); + } + +#if LWIP_NETIF_EXT_STATUS_CALLBACK + { + netif_ext_callback_args_t args; + args.ipv6_addr_state_changed.addr_index = addr_idx; + args.ipv6_addr_state_changed.old_state = old_state; + args.ipv6_addr_state_changed.address = netif_ip_addr6(netif, addr_idx); + netif_invoke_ext_callback(netif, LWIP_NSC_IPV6_ADDR_STATE_CHANGED, &args); + } +#endif + } + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("netif: IPv6 address %d of interface %c%c set to %s/0x%"X8_F"\n", + addr_idx, netif->name[0], netif->name[1], ip6addr_ntoa(netif_ip6_addr(netif, addr_idx)), + netif_ip6_addr_state(netif, addr_idx))); +} + +/** + * Checks if a specific local address is present on the netif and returns its + * index. Depending on its state, it may or may not be assigned to the + * interface (as per RFC terminology). + * + * The given address may or may not be zoned (i.e., have a zone index other + * than IP6_NO_ZONE). If the address is zoned, it must have the correct zone + * for the given netif, or no match will be found. + * + * @param netif the netif to check + * @param ip6addr the IPv6 address to find + * @return >= 0: address found, this is its index + * -1: address not found on this netif + */ +s8_t +netif_get_ip6_addr_match(struct netif *netif, const ip6_addr_t *ip6addr) +{ + s8_t i; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("netif_get_ip6_addr_match: invalid netif", netif != NULL); + LWIP_ASSERT("netif_get_ip6_addr_match: invalid ip6addr", ip6addr != NULL); + +#if LWIP_IPV6_SCOPES + if (ip6_addr_has_zone(ip6addr) && !ip6_addr_test_zone(ip6addr, netif)) { + return -1; /* wrong zone, no match */ + } +#endif /* LWIP_IPV6_SCOPES */ + + for (i = 0; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (!ip6_addr_isinvalid(netif_ip6_addr_state(netif, i)) && + ip6_addr_cmp_zoneless(netif_ip6_addr(netif, i), ip6addr)) { + return i; + } + } + return -1; +} + +/** + * @ingroup netif_ip6 + * Create a link-local IPv6 address on a netif (stored in slot 0) + * + * @param netif the netif to create the address on + * @param from_mac_48bit if != 0, assume hwadr is a 48-bit MAC address (std conversion) + * if == 0, use hwaddr directly as interface ID + */ +void +netif_create_ip6_linklocal_address(struct netif *netif, u8_t from_mac_48bit) +{ + u8_t i, addr_index; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("netif_create_ip6_linklocal_address: invalid netif", netif != NULL); + + /* Link-local prefix. */ + ip_2_ip6(&netif->ip6_addr[0])->addr[0] = PP_HTONL(0xfe800000ul); + ip_2_ip6(&netif->ip6_addr[0])->addr[1] = 0; + + /* Generate interface ID. */ + if (from_mac_48bit) { + /* Assume hwaddr is a 48-bit IEEE 802 MAC. Convert to EUI-64 address. Complement Group bit. */ + ip_2_ip6(&netif->ip6_addr[0])->addr[2] = lwip_htonl((((u32_t)(netif->hwaddr[0] ^ 0x02)) << 24) | + ((u32_t)(netif->hwaddr[1]) << 16) | + ((u32_t)(netif->hwaddr[2]) << 8) | + (0xff)); + ip_2_ip6(&netif->ip6_addr[0])->addr[3] = lwip_htonl((u32_t)(0xfeul << 24) | + ((u32_t)(netif->hwaddr[3]) << 16) | + ((u32_t)(netif->hwaddr[4]) << 8) | + (netif->hwaddr[5])); + } else { + /* Use hwaddr directly as interface ID. */ + ip_2_ip6(&netif->ip6_addr[0])->addr[2] = 0; + ip_2_ip6(&netif->ip6_addr[0])->addr[3] = 0; + + addr_index = 3; + for (i = 0; (i < 8) && (i < netif->hwaddr_len); i++) { + if (i == 4) { + addr_index--; + } + ip_2_ip6(&netif->ip6_addr[0])->addr[addr_index] |= lwip_htonl(((u32_t)(netif->hwaddr[netif->hwaddr_len - i - 1])) << (8 * (i & 0x03))); + } + } + + /* Set a link-local zone. Even though the zone is implied by the owning + * netif, setting the zone anyway has two important conceptual advantages: + * 1) it avoids the need for a ton of exceptions in internal code, allowing + * e.g. ip6_addr_cmp() to be used on local addresses; + * 2) the properly zoned address is visible externally, e.g. when any outside + * code enumerates available addresses or uses one to bind a socket. + * Any external code unaware of address scoping is likely to just ignore the + * zone field, so this should not create any compatibility problems. */ + ip6_addr_assign_zone(ip_2_ip6(&netif->ip6_addr[0]), IP6_UNICAST, netif); + + /* Set address state. */ +#if LWIP_IPV6_DUP_DETECT_ATTEMPTS + /* Will perform duplicate address detection (DAD). */ + netif_ip6_addr_set_state(netif, 0, IP6_ADDR_TENTATIVE); +#else + /* Consider address valid. */ + netif_ip6_addr_set_state(netif, 0, IP6_ADDR_PREFERRED); +#endif /* LWIP_IPV6_AUTOCONFIG */ +} + +/** + * @ingroup netif_ip6 + * This function allows for the easy addition of a new IPv6 address to an interface. + * It takes care of finding an empty slot and then sets the address tentative + * (to make sure that all the subsequent processing happens). + * + * @param netif netif to add the address on + * @param ip6addr address to add + * @param chosen_idx if != NULL, the chosen IPv6 address index will be stored here + */ +err_t +netif_add_ip6_address(struct netif *netif, const ip6_addr_t *ip6addr, s8_t *chosen_idx) +{ + s8_t i; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("netif_add_ip6_address: invalid netif", netif != NULL); + LWIP_ASSERT("netif_add_ip6_address: invalid ip6addr", ip6addr != NULL); + + i = netif_get_ip6_addr_match(netif, ip6addr); + if (i >= 0) { + /* Address already added */ + if (chosen_idx != NULL) { + *chosen_idx = i; + } + return ERR_OK; + } + + /* Find a free slot. The first one is reserved for link-local addresses. */ + for (i = ip6_addr_islinklocal(ip6addr) ? 0 : 1; i < LWIP_IPV6_NUM_ADDRESSES; i++) { + if (ip6_addr_isinvalid(netif_ip6_addr_state(netif, i))) { + ip_addr_copy_from_ip6(netif->ip6_addr[i], *ip6addr); + ip6_addr_assign_zone(ip_2_ip6(&netif->ip6_addr[i]), IP6_UNICAST, netif); + netif_ip6_addr_set_state(netif, i, IP6_ADDR_TENTATIVE); + if (chosen_idx != NULL) { + *chosen_idx = i; + } + return ERR_OK; + } + } + + if (chosen_idx != NULL) { + *chosen_idx = -1; + } + return ERR_VAL; +} + +/** Dummy IPv6 output function for netifs not supporting IPv6 + */ +static err_t +netif_null_output_ip6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr) +{ + LWIP_UNUSED_ARG(netif); + LWIP_UNUSED_ARG(p); + LWIP_UNUSED_ARG(ipaddr); + + return ERR_IF; +} +#endif /* LWIP_IPV6 */ + +#if LWIP_IPV4 +/** Dummy IPv4 output function for netifs not supporting IPv4 + */ +static err_t +netif_null_output_ip4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr) +{ + LWIP_UNUSED_ARG(netif); + LWIP_UNUSED_ARG(p); + LWIP_UNUSED_ARG(ipaddr); + + return ERR_IF; +} +#endif /* LWIP_IPV4 */ + +/** +* @ingroup netif +* Return the interface index for the netif with name +* or NETIF_NO_INDEX if not found/on error +* +* @param name the name of the netif +*/ +u8_t +netif_name_to_index(const char *name) +{ + struct netif *netif = netif_find(name); + if (netif != NULL) { + return netif_get_index(netif); + } + /* No name found, return invalid index */ + return NETIF_NO_INDEX; +} + +/** +* @ingroup netif +* Return the interface name for the netif matching index +* or NULL if not found/on error +* +* @param idx the interface index of the netif +* @param name char buffer of at least NETIF_NAMESIZE bytes +*/ +char * +netif_index_to_name(u8_t idx, char *name) +{ + struct netif *netif = netif_get_by_index(idx); + + if (netif != NULL) { + name[0] = netif->name[0]; + name[1] = netif->name[1]; + lwip_itoa(&name[2], NETIF_NAMESIZE - 2, netif_index_to_num(idx)); + return name; + } + return NULL; +} + +/** +* @ingroup netif +* Return the interface for the netif index +* +* @param idx index of netif to find +*/ +struct netif * +netif_get_by_index(u8_t idx) +{ + struct netif *netif; + + LWIP_ASSERT_CORE_LOCKED(); + + if (idx != NETIF_NO_INDEX) { + NETIF_FOREACH(netif) { + if (idx == netif_get_index(netif)) { + return netif; /* found! */ + } + } + } + + return NULL; +} + +/** + * @ingroup netif + * Find a network interface by searching for its name + * + * @param name the name of the netif (like netif->name) plus concatenated number + * in ascii representation (e.g. 'en0') + */ +struct netif * +netif_find(const char *name) +{ + struct netif *netif; + u8_t num; + + LWIP_ASSERT_CORE_LOCKED(); + + if (name == NULL) { + return NULL; + } + + num = (u8_t)atoi(&name[2]); + + NETIF_FOREACH(netif) { + if (num == netif->num && + name[0] == netif->name[0] && + name[1] == netif->name[1]) { + LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: found %c%c\n", name[0], name[1])); + return netif; + } + } + LWIP_DEBUGF(NETIF_DEBUG, ("netif_find: didn't find %c%c\n", name[0], name[1])); + return NULL; +} + +#if LWIP_NETIF_EXT_STATUS_CALLBACK +/** + * @ingroup netif + * Add extended netif events listener + * @param callback pointer to listener structure + * @param fn callback function + */ +void +netif_add_ext_callback(netif_ext_callback_t *callback, netif_ext_callback_fn fn) +{ + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("callback must be != NULL", callback != NULL); + LWIP_ASSERT("fn must be != NULL", fn != NULL); + + callback->callback_fn = fn; + callback->next = ext_callback; + ext_callback = callback; +} + +/** + * @ingroup netif + * Remove extended netif events listener + * @param callback pointer to listener structure + */ +void +netif_remove_ext_callback(netif_ext_callback_t* callback) +{ + netif_ext_callback_t *last, *iter; + + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("callback must be != NULL", callback != NULL); + + if (ext_callback == NULL) { + return; + } + + if (callback == ext_callback) { + ext_callback = ext_callback->next; + } else { + last = ext_callback; + for (iter = ext_callback->next; iter != NULL; last = iter, iter = iter->next) { + if (iter == callback) { + LWIP_ASSERT("last != NULL", last != NULL); + last->next = callback->next; + callback->next = NULL; + return; + } + } + } +} + +/** + * Invoke extended netif status event + * @param netif netif that is affected by change + * @param reason change reason + * @param args depends on reason, see reason description + */ +void +netif_invoke_ext_callback(struct netif *netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t *args) +{ + netif_ext_callback_t *callback = ext_callback; + + LWIP_ASSERT("netif must be != NULL", netif != NULL); + + while (callback != NULL) { + callback->callback_fn(netif, reason, args); + callback = callback->next; + } +} +#endif /* LWIP_NETIF_EXT_STATUS_CALLBACK */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/pbuf.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/pbuf.c index 7579d862..a209e0ca 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/pbuf.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/pbuf.c @@ -1,1514 +1,1514 @@ -/** - * @file - * Packet buffer management - */ - -/** - * @defgroup pbuf Packet buffers (PBUF) - * @ingroup infrastructure - * - * Packets are built from the pbuf data structure. It supports dynamic - * memory allocation for packet contents or can reference externally - * managed packet contents both in RAM and ROM. Quick allocation for - * incoming packets is provided through pools with fixed sized pbufs. - * - * A packet may span over multiple pbufs, chained as a singly linked - * list. This is called a "pbuf chain". - * - * Multiple packets may be queued, also using this singly linked list. - * This is called a "packet queue". - * - * So, a packet queue consists of one or more pbuf chains, each of - * which consist of one or more pbufs. CURRENTLY, PACKET QUEUES ARE - * NOT SUPPORTED!!! Use helper structs to queue multiple packets. - * - * The differences between a pbuf chain and a packet queue are very - * precise but subtle. - * - * The last pbuf of a packet has a ->tot_len field that equals the - * ->len field. It can be found by traversing the list. If the last - * pbuf of a packet has a ->next field other than NULL, more packets - * are on the queue. - * - * Therefore, looping through a pbuf of a single packet, has an - * loop end condition (tot_len == p->len), NOT (next == NULL). - * - * Example of custom pbuf usage: @ref zerocopyrx - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#include "lwip/pbuf.h" -#include "lwip/stats.h" -#include "lwip/def.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/sys.h" -#include "lwip/netif.h" -#if LWIP_TCP && TCP_QUEUE_OOSEQ -#include "lwip/priv/tcp_priv.h" -#endif -#if LWIP_CHECKSUM_ON_COPY -#include "lwip/inet_chksum.h" -#endif - -#include - -#define SIZEOF_STRUCT_PBUF LWIP_MEM_ALIGN_SIZE(sizeof(struct pbuf)) -/* Since the pool is created in memp, PBUF_POOL_BUFSIZE will be automatically - aligned there. Therefore, PBUF_POOL_BUFSIZE_ALIGNED can be used here. */ -#define PBUF_POOL_BUFSIZE_ALIGNED LWIP_MEM_ALIGN_SIZE(PBUF_POOL_BUFSIZE) - -static const struct pbuf * -pbuf_skip_const(const struct pbuf *in, u16_t in_offset, u16_t *out_offset); - -#if !LWIP_TCP || !TCP_QUEUE_OOSEQ || !PBUF_POOL_FREE_OOSEQ -#define PBUF_POOL_IS_EMPTY() -#else /* !LWIP_TCP || !TCP_QUEUE_OOSEQ || !PBUF_POOL_FREE_OOSEQ */ - -#if !NO_SYS -#ifndef PBUF_POOL_FREE_OOSEQ_QUEUE_CALL -#include "lwip/tcpip.h" -#define PBUF_POOL_FREE_OOSEQ_QUEUE_CALL() do { \ - if (tcpip_try_callback(pbuf_free_ooseq_callback, NULL) != ERR_OK) { \ - SYS_ARCH_PROTECT(old_level); \ - pbuf_free_ooseq_pending = 0; \ - SYS_ARCH_UNPROTECT(old_level); \ - } } while(0) -#endif /* PBUF_POOL_FREE_OOSEQ_QUEUE_CALL */ -#endif /* !NO_SYS */ - -volatile u8_t pbuf_free_ooseq_pending; -#define PBUF_POOL_IS_EMPTY() pbuf_pool_is_empty() - -/** - * Attempt to reclaim some memory from queued out-of-sequence TCP segments - * if we run out of pool pbufs. It's better to give priority to new packets - * if we're running out. - * - * This must be done in the correct thread context therefore this function - * can only be used with NO_SYS=0 and through tcpip_callback. - */ -#if !NO_SYS -static -#endif /* !NO_SYS */ -void -pbuf_free_ooseq(void) -{ - struct tcp_pcb *pcb; - SYS_ARCH_SET(pbuf_free_ooseq_pending, 0); - - for (pcb = tcp_active_pcbs; NULL != pcb; pcb = pcb->next) { - if (pcb->ooseq != NULL) { - /** Free the ooseq pbufs of one PCB only */ - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free_ooseq: freeing out-of-sequence pbufs\n")); - tcp_free_ooseq(pcb); - return; - } - } -} - -#if !NO_SYS -/** - * Just a callback function for tcpip_callback() that calls pbuf_free_ooseq(). - */ -static void -pbuf_free_ooseq_callback(void *arg) -{ - LWIP_UNUSED_ARG(arg); - pbuf_free_ooseq(); -} -#endif /* !NO_SYS */ - -/** Queue a call to pbuf_free_ooseq if not already queued. */ -static void -pbuf_pool_is_empty(void) -{ -#ifndef PBUF_POOL_FREE_OOSEQ_QUEUE_CALL - SYS_ARCH_SET(pbuf_free_ooseq_pending, 1); -#else /* PBUF_POOL_FREE_OOSEQ_QUEUE_CALL */ - u8_t queued; - SYS_ARCH_DECL_PROTECT(old_level); - SYS_ARCH_PROTECT(old_level); - queued = pbuf_free_ooseq_pending; - pbuf_free_ooseq_pending = 1; - SYS_ARCH_UNPROTECT(old_level); - - if (!queued) { - /* queue a call to pbuf_free_ooseq if not already queued */ - PBUF_POOL_FREE_OOSEQ_QUEUE_CALL(); - } -#endif /* PBUF_POOL_FREE_OOSEQ_QUEUE_CALL */ -} -#endif /* !LWIP_TCP || !TCP_QUEUE_OOSEQ || !PBUF_POOL_FREE_OOSEQ */ - -/* Initialize members of struct pbuf after allocation */ -static void -pbuf_init_alloced_pbuf(struct pbuf *p, void *payload, u16_t tot_len, u16_t len, pbuf_type type, u8_t flags) -{ - p->next = NULL; - p->payload = payload; - p->tot_len = tot_len; - p->len = len; - p->type_internal = (u8_t)type; - p->flags = flags; - p->ref = 1; - p->if_idx = NETIF_NO_INDEX; -} - -/** - * @ingroup pbuf - * Allocates a pbuf of the given type (possibly a chain for PBUF_POOL type). - * - * The actual memory allocated for the pbuf is determined by the - * layer at which the pbuf is allocated and the requested size - * (from the size parameter). - * - * @param layer header size - * @param length size of the pbuf's payload - * @param type this parameter decides how and where the pbuf - * should be allocated as follows: - * - * - PBUF_RAM: buffer memory for pbuf is allocated as one large - * chunk. This includes protocol headers as well. - * - PBUF_ROM: no buffer memory is allocated for the pbuf, even for - * protocol headers. Additional headers must be prepended - * by allocating another pbuf and chain in to the front of - * the ROM pbuf. It is assumed that the memory used is really - * similar to ROM in that it is immutable and will not be - * changed. Memory which is dynamic should generally not - * be attached to PBUF_ROM pbufs. Use PBUF_REF instead. - * - PBUF_REF: no buffer memory is allocated for the pbuf, even for - * protocol headers. It is assumed that the pbuf is only - * being used in a single thread. If the pbuf gets queued, - * then pbuf_take should be called to copy the buffer. - * - PBUF_POOL: the pbuf is allocated as a pbuf chain, with pbufs from - * the pbuf pool that is allocated during pbuf_init(). - * - * @return the allocated pbuf. If multiple pbufs where allocated, this - * is the first pbuf of a pbuf chain. - */ -struct pbuf * -pbuf_alloc(pbuf_layer layer, u16_t length, pbuf_type type) -{ - struct pbuf *p; - u16_t offset = (u16_t)layer; - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F")\n", length)); - - switch (type) { - case PBUF_REF: /* fall through */ - case PBUF_ROM: - p = pbuf_alloc_reference(NULL, length, type); - break; - case PBUF_POOL: { - struct pbuf *q, *last; - u16_t rem_len; /* remaining length */ - p = NULL; - last = NULL; - rem_len = length; - do { - u16_t qlen; - q = (struct pbuf *)memp_malloc(MEMP_PBUF_POOL); - if (q == NULL) { - PBUF_POOL_IS_EMPTY(); - /* free chain so far allocated */ - if (p) { - pbuf_free(p); - } - /* bail out unsuccessfully */ - return NULL; - } - qlen = LWIP_MIN(rem_len, (u16_t)(PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset))); - pbuf_init_alloced_pbuf(q, LWIP_MEM_ALIGN((void *)((u8_t *)q + SIZEOF_STRUCT_PBUF + offset)), - rem_len, qlen, type, 0); - LWIP_ASSERT("pbuf_alloc: pbuf q->payload properly aligned", - ((mem_ptr_t)q->payload % MEM_ALIGNMENT) == 0); - LWIP_ASSERT("PBUF_POOL_BUFSIZE must be bigger than MEM_ALIGNMENT", - (PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset)) > 0 ); - if (p == NULL) { - /* allocated head of pbuf chain (into p) */ - p = q; - } else { - /* make previous pbuf point to this pbuf */ - last->next = q; - } - last = q; - rem_len = (u16_t)(rem_len - qlen); - offset = 0; - } while (rem_len > 0); - break; - } - case PBUF_RAM: { - u16_t payload_len = (u16_t)(LWIP_MEM_ALIGN_SIZE(offset) + LWIP_MEM_ALIGN_SIZE(length)); - mem_size_t alloc_len = (mem_size_t)(LWIP_MEM_ALIGN_SIZE(SIZEOF_STRUCT_PBUF) + payload_len); - - /* bug #50040: Check for integer overflow when calculating alloc_len */ - if ((payload_len < LWIP_MEM_ALIGN_SIZE(length)) || - (alloc_len < LWIP_MEM_ALIGN_SIZE(length))) { - return NULL; - } - - /* If pbuf is to be allocated in RAM, allocate memory for it. */ - p = (struct pbuf *)mem_malloc(alloc_len); - if (p == NULL) { - return NULL; - } - pbuf_init_alloced_pbuf(p, LWIP_MEM_ALIGN((void *)((u8_t *)p + SIZEOF_STRUCT_PBUF + offset)), - length, length, type, 0); - LWIP_ASSERT("pbuf_alloc: pbuf->payload properly aligned", - ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0); - break; - } - default: - LWIP_ASSERT("pbuf_alloc: erroneous type", 0); - return NULL; - } - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F") == %p\n", length, (void *)p)); - return p; -} - -/** - * @ingroup pbuf - * Allocates a pbuf for referenced data. - * Referenced data can be volatile (PBUF_REF) or long-lived (PBUF_ROM). - * - * The actual memory allocated for the pbuf is determined by the - * layer at which the pbuf is allocated and the requested size - * (from the size parameter). - * - * @param payload referenced payload - * @param length size of the pbuf's payload - * @param type this parameter decides how and where the pbuf - * should be allocated as follows: - * - * - PBUF_ROM: It is assumed that the memory used is really - * similar to ROM in that it is immutable and will not be - * changed. Memory which is dynamic should generally not - * be attached to PBUF_ROM pbufs. Use PBUF_REF instead. - * - PBUF_REF: It is assumed that the pbuf is only - * being used in a single thread. If the pbuf gets queued, - * then pbuf_take should be called to copy the buffer. - * - * @return the allocated pbuf. - */ -struct pbuf * -pbuf_alloc_reference(void *payload, u16_t length, pbuf_type type) -{ - struct pbuf *p; - LWIP_ASSERT("invalid pbuf_type", (type == PBUF_REF) || (type == PBUF_ROM)); - /* only allocate memory for the pbuf structure */ - p = (struct pbuf *)memp_malloc(MEMP_PBUF); - if (p == NULL) { - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("pbuf_alloc_reference: Could not allocate MEMP_PBUF for PBUF_%s.\n", - (type == PBUF_ROM) ? "ROM" : "REF")); - return NULL; - } - pbuf_init_alloced_pbuf(p, payload, length, length, type, 0); - return p; -} - - -#if LWIP_SUPPORT_CUSTOM_PBUF -/** - * @ingroup pbuf - * Initialize a custom pbuf (already allocated). - * Example of custom pbuf usage: @ref zerocopyrx - * - * @param l header size - * @param length size of the pbuf's payload - * @param type type of the pbuf (only used to treat the pbuf accordingly, as - * this function allocates no memory) - * @param p pointer to the custom pbuf to initialize (already allocated) - * @param payload_mem pointer to the buffer that is used for payload and headers, - * must be at least big enough to hold 'length' plus the header size, - * may be NULL if set later. - * ATTENTION: The caller is responsible for correct alignment of this buffer!! - * @param payload_mem_len the size of the 'payload_mem' buffer, must be at least - * big enough to hold 'length' plus the header size - */ -struct pbuf * -pbuf_alloced_custom(pbuf_layer l, u16_t length, pbuf_type type, struct pbuf_custom *p, - void *payload_mem, u16_t payload_mem_len) -{ - u16_t offset = (u16_t)l; - void *payload; - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloced_custom(length=%"U16_F")\n", length)); - - if (LWIP_MEM_ALIGN_SIZE(offset) + length > payload_mem_len) { - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_WARNING, ("pbuf_alloced_custom(length=%"U16_F") buffer too short\n", length)); - return NULL; - } - - if (payload_mem != NULL) { - payload = (u8_t *)payload_mem + LWIP_MEM_ALIGN_SIZE(offset); - } else { - payload = NULL; - } - pbuf_init_alloced_pbuf(&p->pbuf, payload, length, length, type, PBUF_FLAG_IS_CUSTOM); - return &p->pbuf; -} -#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ - -/** - * @ingroup pbuf - * Shrink a pbuf chain to a desired length. - * - * @param p pbuf to shrink. - * @param new_len desired new length of pbuf chain - * - * Depending on the desired length, the first few pbufs in a chain might - * be skipped and left unchanged. The new last pbuf in the chain will be - * resized, and any remaining pbufs will be freed. - * - * @note If the pbuf is ROM/REF, only the ->tot_len and ->len fields are adjusted. - * @note May not be called on a packet queue. - * - * @note Despite its name, pbuf_realloc cannot grow the size of a pbuf (chain). - */ -void -pbuf_realloc(struct pbuf *p, u16_t new_len) -{ - struct pbuf *q; - u16_t rem_len; /* remaining length */ - u16_t shrink; - - LWIP_ASSERT("pbuf_realloc: p != NULL", p != NULL); - - /* desired length larger than current length? */ - if (new_len >= p->tot_len) { - /* enlarging not yet supported */ - return; - } - - /* the pbuf chain grows by (new_len - p->tot_len) bytes - * (which may be negative in case of shrinking) */ - shrink = (u16_t)(p->tot_len - new_len); - - /* first, step over any pbufs that should remain in the chain */ - rem_len = new_len; - q = p; - /* should this pbuf be kept? */ - while (rem_len > q->len) { - /* decrease remaining length by pbuf length */ - rem_len = (u16_t)(rem_len - q->len); - /* decrease total length indicator */ - q->tot_len = (u16_t)(q->tot_len - shrink); - /* proceed to next pbuf in chain */ - q = q->next; - LWIP_ASSERT("pbuf_realloc: q != NULL", q != NULL); - } - /* we have now reached the new last pbuf (in q) */ - /* rem_len == desired length for pbuf q */ - - /* shrink allocated memory for PBUF_RAM */ - /* (other types merely adjust their length fields */ - if (pbuf_match_allocsrc(q, PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP) && (rem_len != q->len) -#if LWIP_SUPPORT_CUSTOM_PBUF - && ((q->flags & PBUF_FLAG_IS_CUSTOM) == 0) -#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ - ) { - /* reallocate and adjust the length of the pbuf that will be split */ - q = (struct pbuf *)mem_trim(q, (mem_size_t)(((u8_t *)q->payload - (u8_t *)q) + rem_len)); - LWIP_ASSERT("mem_trim returned q == NULL", q != NULL); - } - /* adjust length fields for new last pbuf */ - q->len = rem_len; - q->tot_len = q->len; - - /* any remaining pbufs in chain? */ - if (q->next != NULL) { - /* free remaining pbufs in chain */ - pbuf_free(q->next); - } - /* q is last packet in chain */ - q->next = NULL; - -} - -/** - * Adjusts the payload pointer to reveal headers in the payload. - * @see pbuf_add_header. - * - * @param p pbuf to change the header size. - * @param header_size_increment Number of bytes to increment header size. - * @param force Allow 'header_size_increment > 0' for PBUF_REF/PBUF_ROM types - * - * @return non-zero on failure, zero on success. - * - */ -static u8_t -pbuf_add_header_impl(struct pbuf *p, size_t header_size_increment, u8_t force) -{ - u16_t type_internal; - void *payload; - u16_t increment_magnitude; - - LWIP_ASSERT("p != NULL", p != NULL); - if ((p == NULL) || (header_size_increment > 0xFFFF)) { - return 1; - } - if (header_size_increment == 0) { - return 0; - } - - increment_magnitude = (u16_t)header_size_increment; - /* Do not allow tot_len to wrap as a result. */ - if ((u16_t)(increment_magnitude + p->tot_len) < increment_magnitude) { - return 1; - } - - type_internal = p->type_internal; - - /* pbuf types containing payloads? */ - if (type_internal & PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS) { - /* set new payload pointer */ - payload = (u8_t *)p->payload - header_size_increment; - /* boundary check fails? */ - if ((u8_t *)payload < (u8_t *)p + SIZEOF_STRUCT_PBUF) { - LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, - ("pbuf_add_header: failed as %p < %p (not enough space for new header size)\n", - (void *)payload, (void *)((u8_t *)p + SIZEOF_STRUCT_PBUF))); - /* bail out unsuccessfully */ - return 1; - } - /* pbuf types referring to external payloads? */ - } else { - /* hide a header in the payload? */ - if (force) { - payload = (u8_t *)p->payload - header_size_increment; - } else { - /* cannot expand payload to front (yet!) - * bail out unsuccessfully */ - return 1; - } - } - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_add_header: old %p new %p (%"U16_F")\n", - (void *)p->payload, (void *)payload, increment_magnitude)); - - /* modify pbuf fields */ - p->payload = payload; - p->len = (u16_t)(p->len + increment_magnitude); - p->tot_len = (u16_t)(p->tot_len + increment_magnitude); - - - return 0; -} - -/** - * Adjusts the payload pointer to reveal headers in the payload. - * - * Adjusts the ->payload pointer so that space for a header - * appears in the pbuf payload. - * - * The ->payload, ->tot_len and ->len fields are adjusted. - * - * @param p pbuf to change the header size. - * @param header_size_increment Number of bytes to increment header size which - * increases the size of the pbuf. New space is on the front. - * If header_size_increment is 0, this function does nothing and returns successful. - * - * PBUF_ROM and PBUF_REF type buffers cannot have their sizes increased, so - * the call will fail. A check is made that the increase in header size does - * not move the payload pointer in front of the start of the buffer. - * - * @return non-zero on failure, zero on success. - * - */ -u8_t -pbuf_add_header(struct pbuf *p, size_t header_size_increment) -{ - return pbuf_add_header_impl(p, header_size_increment, 0); -} - -/** - * Same as @ref pbuf_add_header but does not check if 'header_size > 0' is allowed. - * This is used internally only, to allow PBUF_REF for RX. - */ -u8_t -pbuf_add_header_force(struct pbuf *p, size_t header_size_increment) -{ - return pbuf_add_header_impl(p, header_size_increment, 1); -} - -/** - * Adjusts the payload pointer to hide headers in the payload. - * - * Adjusts the ->payload pointer so that space for a header - * disappears in the pbuf payload. - * - * The ->payload, ->tot_len and ->len fields are adjusted. - * - * @param p pbuf to change the header size. - * @param header_size_decrement Number of bytes to decrement header size which - * decreases the size of the pbuf. - * If header_size_decrement is 0, this function does nothing and returns successful. - * @return non-zero on failure, zero on success. - * - */ -u8_t -pbuf_remove_header(struct pbuf *p, size_t header_size_decrement) -{ - void *payload; - u16_t increment_magnitude; - - LWIP_ASSERT("p != NULL", p != NULL); - if ((p == NULL) || (header_size_decrement > 0xFFFF)) { - return 1; - } - if (header_size_decrement == 0) { - return 0; - } - - increment_magnitude = (u16_t)header_size_decrement; - /* Check that we aren't going to move off the end of the pbuf */ - LWIP_ERROR("increment_magnitude <= p->len", (increment_magnitude <= p->len), return 1;); - - /* remember current payload pointer */ - payload = p->payload; - LWIP_UNUSED_ARG(payload); /* only used in LWIP_DEBUGF below */ - - /* increase payload pointer (guarded by length check above) */ - p->payload = (u8_t *)p->payload + header_size_decrement; - /* modify pbuf length fields */ - p->len = (u16_t)(p->len - increment_magnitude); - p->tot_len = (u16_t)(p->tot_len - increment_magnitude); - - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_remove_header: old %p new %p (%"U16_F")\n", - (void *)payload, (void *)p->payload, increment_magnitude)); - - return 0; -} - -static u8_t -pbuf_header_impl(struct pbuf *p, s16_t header_size_increment, u8_t force) -{ - if (header_size_increment < 0) { - return pbuf_remove_header(p, (size_t) - header_size_increment); - } else { - return pbuf_add_header_impl(p, (size_t)header_size_increment, force); - } -} - -/** - * Adjusts the payload pointer to hide or reveal headers in the payload. - * - * Adjusts the ->payload pointer so that space for a header - * (dis)appears in the pbuf payload. - * - * The ->payload, ->tot_len and ->len fields are adjusted. - * - * @param p pbuf to change the header size. - * @param header_size_increment Number of bytes to increment header size which - * increases the size of the pbuf. New space is on the front. - * (Using a negative value decreases the header size.) - * If header_size_increment is 0, this function does nothing and returns successful. - * - * PBUF_ROM and PBUF_REF type buffers cannot have their sizes increased, so - * the call will fail. A check is made that the increase in header size does - * not move the payload pointer in front of the start of the buffer. - * @return non-zero on failure, zero on success. - * - */ -u8_t -pbuf_header(struct pbuf *p, s16_t header_size_increment) -{ - return pbuf_header_impl(p, header_size_increment, 0); -} - -/** - * Same as pbuf_header but does not check if 'header_size > 0' is allowed. - * This is used internally only, to allow PBUF_REF for RX. - */ -u8_t -pbuf_header_force(struct pbuf *p, s16_t header_size_increment) -{ - return pbuf_header_impl(p, header_size_increment, 1); -} - -/** Similar to pbuf_header(-size) but de-refs header pbufs for (size >= p->len) - * - * @param q pbufs to operate on - * @param size The number of bytes to remove from the beginning of the pbuf list. - * While size >= p->len, pbufs are freed. - * ATTENTION: this is the opposite direction as @ref pbuf_header, but - * takes an u16_t not s16_t! - * @return the new head pbuf - */ -struct pbuf * -pbuf_free_header(struct pbuf *q, u16_t size) -{ - struct pbuf *p = q; - u16_t free_left = size; - while (free_left && p) { - if (free_left >= p->len) { - struct pbuf *f = p; - free_left = (u16_t)(free_left - p->len); - p = p->next; - f->next = 0; - pbuf_free(f); - } else { - pbuf_remove_header(p, free_left); - free_left = 0; - } - } - return p; -} - -/** - * @ingroup pbuf - * Dereference a pbuf chain or queue and deallocate any no-longer-used - * pbufs at the head of this chain or queue. - * - * Decrements the pbuf reference count. If it reaches zero, the pbuf is - * deallocated. - * - * For a pbuf chain, this is repeated for each pbuf in the chain, - * up to the first pbuf which has a non-zero reference count after - * decrementing. So, when all reference counts are one, the whole - * chain is free'd. - * - * @param p The pbuf (chain) to be dereferenced. - * - * @return the number of pbufs that were de-allocated - * from the head of the chain. - * - * @note MUST NOT be called on a packet queue (Not verified to work yet). - * @note the reference counter of a pbuf equals the number of pointers - * that refer to the pbuf (or into the pbuf). - * - * @internal examples: - * - * Assuming existing chains a->b->c with the following reference - * counts, calling pbuf_free(a) results in: - * - * 1->2->3 becomes ...1->3 - * 3->3->3 becomes 2->3->3 - * 1->1->2 becomes ......1 - * 2->1->1 becomes 1->1->1 - * 1->1->1 becomes ....... - * - */ -u8_t -pbuf_free(struct pbuf *p) -{ - u8_t alloc_src; - struct pbuf *q; - u8_t count; - - if (p == NULL) { - LWIP_ASSERT("p != NULL", p != NULL); - /* if assertions are disabled, proceed with debug output */ - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("pbuf_free(p == NULL) was called.\n")); - return 0; - } - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free(%p)\n", (void *)p)); - - PERF_START; - - count = 0; - /* de-allocate all consecutive pbufs from the head of the chain that - * obtain a zero reference count after decrementing*/ - while (p != NULL) { - LWIP_PBUF_REF_T ref; - SYS_ARCH_DECL_PROTECT(old_level); - /* Since decrementing ref cannot be guaranteed to be a single machine operation - * we must protect it. We put the new ref into a local variable to prevent - * further protection. */ - SYS_ARCH_PROTECT(old_level); - /* all pbufs in a chain are referenced at least once */ - LWIP_ASSERT("pbuf_free: p->ref > 0", p->ref > 0); - /* decrease reference count (number of pointers to pbuf) */ - ref = --(p->ref); - SYS_ARCH_UNPROTECT(old_level); - /* this pbuf is no longer referenced to? */ - if (ref == 0) { - /* remember next pbuf in chain for next iteration */ - q = p->next; - LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: deallocating %p\n", (void *)p)); - alloc_src = pbuf_get_allocsrc(p); -#if LWIP_SUPPORT_CUSTOM_PBUF - /* is this a custom pbuf? */ - if ((p->flags & PBUF_FLAG_IS_CUSTOM) != 0) { - struct pbuf_custom *pc = (struct pbuf_custom *)p; - LWIP_ASSERT("pc->custom_free_function != NULL", pc->custom_free_function != NULL); - pc->custom_free_function(p); - } else -#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ - { - /* is this a pbuf from the pool? */ - if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL) { - memp_free(MEMP_PBUF_POOL, p); - /* is this a ROM or RAM referencing pbuf? */ - } else if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF) { - memp_free(MEMP_PBUF, p); - /* type == PBUF_RAM */ - } else if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP) { - mem_free(p); - } else { - /* @todo: support freeing other types */ - LWIP_ASSERT("invalid pbuf type", 0); - } - } - count++; - /* proceed to next pbuf */ - p = q; - /* p->ref > 0, this pbuf is still referenced to */ - /* (and so the remaining pbufs in chain as well) */ - } else { - LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: %p has ref %"U16_F", ending here.\n", (void *)p, (u16_t)ref)); - /* stop walking through the chain */ - p = NULL; - } - } - PERF_STOP("pbuf_free"); - /* return number of de-allocated pbufs */ - return count; -} - -/** - * Count number of pbufs in a chain - * - * @param p first pbuf of chain - * @return the number of pbufs in a chain - */ -u16_t -pbuf_clen(const struct pbuf *p) -{ - u16_t len; - - len = 0; - while (p != NULL) { - ++len; - p = p->next; - } - return len; -} - -/** - * @ingroup pbuf - * Increment the reference count of the pbuf. - * - * @param p pbuf to increase reference counter of - * - */ -void -pbuf_ref(struct pbuf *p) -{ - /* pbuf given? */ - if (p != NULL) { - SYS_ARCH_SET(p->ref, (LWIP_PBUF_REF_T)(p->ref + 1)); - LWIP_ASSERT("pbuf ref overflow", p->ref > 0); - } -} - -/** - * @ingroup pbuf - * Concatenate two pbufs (each may be a pbuf chain) and take over - * the caller's reference of the tail pbuf. - * - * @note The caller MAY NOT reference the tail pbuf afterwards. - * Use pbuf_chain() for that purpose. - * - * This function explicitly does not check for tot_len overflow to prevent - * failing to queue too long pbufs. This can produce invalid pbufs, so - * handle with care! - * - * @see pbuf_chain() - */ -void -pbuf_cat(struct pbuf *h, struct pbuf *t) -{ - struct pbuf *p; - - LWIP_ERROR("(h != NULL) && (t != NULL) (programmer violates API)", - ((h != NULL) && (t != NULL)), return;); - - /* proceed to last pbuf of chain */ - for (p = h; p->next != NULL; p = p->next) { - /* add total length of second chain to all totals of first chain */ - p->tot_len = (u16_t)(p->tot_len + t->tot_len); - } - /* { p is last pbuf of first h chain, p->next == NULL } */ - LWIP_ASSERT("p->tot_len == p->len (of last pbuf in chain)", p->tot_len == p->len); - LWIP_ASSERT("p->next == NULL", p->next == NULL); - /* add total length of second chain to last pbuf total of first chain */ - p->tot_len = (u16_t)(p->tot_len + t->tot_len); - /* chain last pbuf of head (p) with first of tail (t) */ - p->next = t; - /* p->next now references t, but the caller will drop its reference to t, - * so netto there is no change to the reference count of t. - */ -} - -/** - * @ingroup pbuf - * Chain two pbufs (or pbuf chains) together. - * - * The caller MUST call pbuf_free(t) once it has stopped - * using it. Use pbuf_cat() instead if you no longer use t. - * - * @param h head pbuf (chain) - * @param t tail pbuf (chain) - * @note The pbufs MUST belong to the same packet. - * @note MAY NOT be called on a packet queue. - * - * The ->tot_len fields of all pbufs of the head chain are adjusted. - * The ->next field of the last pbuf of the head chain is adjusted. - * The ->ref field of the first pbuf of the tail chain is adjusted. - * - */ -void -pbuf_chain(struct pbuf *h, struct pbuf *t) -{ - pbuf_cat(h, t); - /* t is now referenced by h */ - pbuf_ref(t); - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_chain: %p references %p\n", (void *)h, (void *)t)); -} - -/** - * Dechains the first pbuf from its succeeding pbufs in the chain. - * - * Makes p->tot_len field equal to p->len. - * @param p pbuf to dechain - * @return remainder of the pbuf chain, or NULL if it was de-allocated. - * @note May not be called on a packet queue. - */ -struct pbuf * -pbuf_dechain(struct pbuf *p) -{ - struct pbuf *q; - u8_t tail_gone = 1; - /* tail */ - q = p->next; - /* pbuf has successor in chain? */ - if (q != NULL) { - /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */ - LWIP_ASSERT("p->tot_len == p->len + q->tot_len", q->tot_len == p->tot_len - p->len); - /* enforce invariant if assertion is disabled */ - q->tot_len = (u16_t)(p->tot_len - p->len); - /* decouple pbuf from remainder */ - p->next = NULL; - /* total length of pbuf p is its own length only */ - p->tot_len = p->len; - /* q is no longer referenced by p, free it */ - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_dechain: unreferencing %p\n", (void *)q)); - tail_gone = pbuf_free(q); - if (tail_gone > 0) { - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, - ("pbuf_dechain: deallocated %p (as it is no longer referenced)\n", (void *)q)); - } - /* return remaining tail or NULL if deallocated */ - } - /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */ - LWIP_ASSERT("p->tot_len == p->len", p->tot_len == p->len); - return ((tail_gone > 0) ? NULL : q); -} - -/** - * @ingroup pbuf - * Create PBUF_RAM copies of pbufs. - * - * Used to queue packets on behalf of the lwIP stack, such as - * ARP based queueing. - * - * @note You MUST explicitly use p = pbuf_take(p); - * - * @note Only one packet is copied, no packet queue! - * - * @param p_to pbuf destination of the copy - * @param p_from pbuf source of the copy - * - * @return ERR_OK if pbuf was copied - * ERR_ARG if one of the pbufs is NULL or p_to is not big - * enough to hold p_from - */ -err_t -pbuf_copy(struct pbuf *p_to, const struct pbuf *p_from) -{ - size_t offset_to = 0, offset_from = 0, len; - - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy(%p, %p)\n", - (const void *)p_to, (const void *)p_from)); - - /* is the target big enough to hold the source? */ - LWIP_ERROR("pbuf_copy: target not big enough to hold source", ((p_to != NULL) && - (p_from != NULL) && (p_to->tot_len >= p_from->tot_len)), return ERR_ARG;); - - /* iterate through pbuf chain */ - do { - /* copy one part of the original chain */ - if ((p_to->len - offset_to) >= (p_from->len - offset_from)) { - /* complete current p_from fits into current p_to */ - len = p_from->len - offset_from; - } else { - /* current p_from does not fit into current p_to */ - len = p_to->len - offset_to; - } - MEMCPY((u8_t *)p_to->payload + offset_to, (u8_t *)p_from->payload + offset_from, len); - offset_to += len; - offset_from += len; - LWIP_ASSERT("offset_to <= p_to->len", offset_to <= p_to->len); - LWIP_ASSERT("offset_from <= p_from->len", offset_from <= p_from->len); - if (offset_from >= p_from->len) { - /* on to next p_from (if any) */ - offset_from = 0; - p_from = p_from->next; - } - if (offset_to == p_to->len) { - /* on to next p_to (if any) */ - offset_to = 0; - p_to = p_to->next; - LWIP_ERROR("p_to != NULL", (p_to != NULL) || (p_from == NULL), return ERR_ARG;); - } - - if ((p_from != NULL) && (p_from->len == p_from->tot_len)) { - /* don't copy more than one packet! */ - LWIP_ERROR("pbuf_copy() does not allow packet queues!", - (p_from->next == NULL), return ERR_VAL;); - } - if ((p_to != NULL) && (p_to->len == p_to->tot_len)) { - /* don't copy more than one packet! */ - LWIP_ERROR("pbuf_copy() does not allow packet queues!", - (p_to->next == NULL), return ERR_VAL;); - } - } while (p_from); - LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy: end of chain reached.\n")); - return ERR_OK; -} - -/** - * @ingroup pbuf - * Copy (part of) the contents of a packet buffer - * to an application supplied buffer. - * - * @param buf the pbuf from which to copy data - * @param dataptr the application supplied buffer - * @param len length of data to copy (dataptr must be big enough). No more - * than buf->tot_len will be copied, irrespective of len - * @param offset offset into the packet buffer from where to begin copying len bytes - * @return the number of bytes copied, or 0 on failure - */ -u16_t -pbuf_copy_partial(const struct pbuf *buf, void *dataptr, u16_t len, u16_t offset) -{ - const struct pbuf *p; - u16_t left = 0; - u16_t buf_copy_len; - u16_t copied_total = 0; - - LWIP_ERROR("pbuf_copy_partial: invalid buf", (buf != NULL), return 0;); - LWIP_ERROR("pbuf_copy_partial: invalid dataptr", (dataptr != NULL), return 0;); - - /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */ - for (p = buf; len != 0 && p != NULL; p = p->next) { - if ((offset != 0) && (offset >= p->len)) { - /* don't copy from this buffer -> on to the next */ - offset = (u16_t)(offset - p->len); - } else { - /* copy from this buffer. maybe only partially. */ - buf_copy_len = (u16_t)(p->len - offset); - if (buf_copy_len > len) { - buf_copy_len = len; - } - /* copy the necessary parts of the buffer */ - MEMCPY(&((char *)dataptr)[left], &((char *)p->payload)[offset], buf_copy_len); - copied_total = (u16_t)(copied_total + buf_copy_len); - left = (u16_t)(left + buf_copy_len); - len = (u16_t)(len - buf_copy_len); - offset = 0; - } - } - return copied_total; -} - -/** - * @ingroup pbuf - * Get part of a pbuf's payload as contiguous memory. The returned memory is - * either a pointer into the pbuf's payload or, if split over multiple pbufs, - * a copy into the user-supplied buffer. - * - * @param p the pbuf from which to copy data - * @param buffer the application supplied buffer - * @param bufsize size of the application supplied buffer - * @param len length of data to copy (dataptr must be big enough). No more - * than buf->tot_len will be copied, irrespective of len - * @param offset offset into the packet buffer from where to begin copying len bytes - * @return the number of bytes copied, or 0 on failure - */ -void * -pbuf_get_contiguous(const struct pbuf *p, void *buffer, size_t bufsize, u16_t len, u16_t offset) -{ - const struct pbuf *q; - u16_t out_offset; - - LWIP_ERROR("pbuf_get_contiguous: invalid buf", (p != NULL), return NULL;); - LWIP_ERROR("pbuf_get_contiguous: invalid dataptr", (buffer != NULL), return NULL;); - LWIP_ERROR("pbuf_get_contiguous: invalid dataptr", (bufsize >= len), return NULL;); - - q = pbuf_skip_const(p, offset, &out_offset); - if (q != NULL) { - if (q->len >= (out_offset + len)) { - /* all data in this pbuf, return zero-copy */ - return (u8_t *)q->payload + out_offset; - } - /* need to copy */ - if (pbuf_copy_partial(q, buffer, len, out_offset) != len) { - /* copying failed: pbuf is too short */ - return NULL; - } - return buffer; - } - /* pbuf is too short (offset does not fit in) */ - return NULL; -} - -#if LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE -/** - * This method modifies a 'pbuf chain', so that its total length is - * smaller than 64K. The remainder of the original pbuf chain is stored - * in *rest. - * This function never creates new pbufs, but splits an existing chain - * in two parts. The tot_len of the modified packet queue will likely be - * smaller than 64K. - * 'packet queues' are not supported by this function. - * - * @param p the pbuf queue to be split - * @param rest pointer to store the remainder (after the first 64K) - */ -void pbuf_split_64k(struct pbuf *p, struct pbuf **rest) -{ - *rest = NULL; - if ((p != NULL) && (p->next != NULL)) { - u16_t tot_len_front = p->len; - struct pbuf *i = p; - struct pbuf *r = p->next; - - /* continue until the total length (summed up as u16_t) overflows */ - while ((r != NULL) && ((u16_t)(tot_len_front + r->len) >= tot_len_front)) { - tot_len_front = (u16_t)(tot_len_front + r->len); - i = r; - r = r->next; - } - /* i now points to last packet of the first segment. Set next - pointer to NULL */ - i->next = NULL; - - if (r != NULL) { - /* Update the tot_len field in the first part */ - for (i = p; i != NULL; i = i->next) { - i->tot_len = (u16_t)(i->tot_len - r->tot_len); - LWIP_ASSERT("tot_len/len mismatch in last pbuf", - (i->next != NULL) || (i->tot_len == i->len)); - } - if (p->flags & PBUF_FLAG_TCP_FIN) { - r->flags |= PBUF_FLAG_TCP_FIN; - } - - /* tot_len field in rest does not need modifications */ - /* reference counters do not need modifications */ - *rest = r; - } - } -} -#endif /* LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - -/* Actual implementation of pbuf_skip() but returning const pointer... */ -static const struct pbuf * -pbuf_skip_const(const struct pbuf *in, u16_t in_offset, u16_t *out_offset) -{ - u16_t offset_left = in_offset; - const struct pbuf *q = in; - - /* get the correct pbuf */ - while ((q != NULL) && (q->len <= offset_left)) { - offset_left = (u16_t)(offset_left - q->len); - q = q->next; - } - if (out_offset != NULL) { - *out_offset = offset_left; - } - return q; -} - -/** - * @ingroup pbuf - * Skip a number of bytes at the start of a pbuf - * - * @param in input pbuf - * @param in_offset offset to skip - * @param out_offset resulting offset in the returned pbuf - * @return the pbuf in the queue where the offset is - */ -struct pbuf * -pbuf_skip(struct pbuf *in, u16_t in_offset, u16_t *out_offset) -{ - const struct pbuf *out = pbuf_skip_const(in, in_offset, out_offset); - return LWIP_CONST_CAST(struct pbuf *, out); -} - -/** - * @ingroup pbuf - * Copy application supplied data into a pbuf. - * This function can only be used to copy the equivalent of buf->tot_len data. - * - * @param buf pbuf to fill with data - * @param dataptr application supplied data buffer - * @param len length of the application supplied data buffer - * - * @return ERR_OK if successful, ERR_MEM if the pbuf is not big enough - */ -err_t -pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len) -{ - struct pbuf *p; - size_t buf_copy_len; - size_t total_copy_len = len; - size_t copied_total = 0; - - LWIP_ERROR("pbuf_take: invalid buf", (buf != NULL), return ERR_ARG;); - LWIP_ERROR("pbuf_take: invalid dataptr", (dataptr != NULL), return ERR_ARG;); - LWIP_ERROR("pbuf_take: buf not large enough", (buf->tot_len >= len), return ERR_MEM;); - - if ((buf == NULL) || (dataptr == NULL) || (buf->tot_len < len)) { - return ERR_ARG; - } - - /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */ - for (p = buf; total_copy_len != 0; p = p->next) { - LWIP_ASSERT("pbuf_take: invalid pbuf", p != NULL); - buf_copy_len = total_copy_len; - if (buf_copy_len > p->len) { - /* this pbuf cannot hold all remaining data */ - buf_copy_len = p->len; - } - /* copy the necessary parts of the buffer */ - MEMCPY(p->payload, &((const char *)dataptr)[copied_total], buf_copy_len); - total_copy_len -= buf_copy_len; - copied_total += buf_copy_len; - } - LWIP_ASSERT("did not copy all data", total_copy_len == 0 && copied_total == len); - return ERR_OK; -} - -/** - * @ingroup pbuf - * Same as pbuf_take() but puts data at an offset - * - * @param buf pbuf to fill with data - * @param dataptr application supplied data buffer - * @param len length of the application supplied data buffer - * @param offset offset in pbuf where to copy dataptr to - * - * @return ERR_OK if successful, ERR_MEM if the pbuf is not big enough - */ -err_t -pbuf_take_at(struct pbuf *buf, const void *dataptr, u16_t len, u16_t offset) -{ - u16_t target_offset; - struct pbuf *q = pbuf_skip(buf, offset, &target_offset); - - /* return requested data if pbuf is OK */ - if ((q != NULL) && (q->tot_len >= target_offset + len)) { - u16_t remaining_len = len; - const u8_t *src_ptr = (const u8_t *)dataptr; - /* copy the part that goes into the first pbuf */ - u16_t first_copy_len; - LWIP_ASSERT("check pbuf_skip result", target_offset < q->len); - first_copy_len = (u16_t)LWIP_MIN(q->len - target_offset, len); - MEMCPY(((u8_t *)q->payload) + target_offset, dataptr, first_copy_len); - remaining_len = (u16_t)(remaining_len - first_copy_len); - src_ptr += first_copy_len; - if (remaining_len > 0) { - return pbuf_take(q->next, src_ptr, remaining_len); - } - return ERR_OK; - } - return ERR_MEM; -} - -/** - * @ingroup pbuf - * Creates a single pbuf out of a queue of pbufs. - * - * @remark: Either the source pbuf 'p' is freed by this function or the original - * pbuf 'p' is returned, therefore the caller has to check the result! - * - * @param p the source pbuf - * @param layer pbuf_layer of the new pbuf - * - * @return a new, single pbuf (p->next is NULL) - * or the old pbuf if allocation fails - */ -struct pbuf * -pbuf_coalesce(struct pbuf *p, pbuf_layer layer) -{ - struct pbuf *q; - if (p->next == NULL) { - return p; - } - q = pbuf_clone(layer, PBUF_RAM, p); - if (q == NULL) { - /* @todo: what do we do now? */ - return p; - } - pbuf_free(p); - return q; -} - -/** - * @ingroup pbuf - * Allocates a new pbuf of same length (via pbuf_alloc()) and copies the source - * pbuf into this new pbuf (using pbuf_copy()). - * - * @param layer pbuf_layer of the new pbuf - * @param type this parameter decides how and where the pbuf should be allocated - * (@see pbuf_alloc()) - * @param p the source pbuf - * - * @return a new pbuf or NULL if allocation fails - */ -struct pbuf * -pbuf_clone(pbuf_layer layer, pbuf_type type, struct pbuf *p) -{ - struct pbuf *q; - err_t err; - q = pbuf_alloc(layer, p->tot_len, type); - if (q == NULL) { - return NULL; - } - err = pbuf_copy(q, p); - LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */ - LWIP_ASSERT("pbuf_copy failed", err == ERR_OK); - return q; -} - -#if LWIP_CHECKSUM_ON_COPY -/** - * Copies data into a single pbuf (*not* into a pbuf queue!) and updates - * the checksum while copying - * - * @param p the pbuf to copy data into - * @param start_offset offset of p->payload where to copy the data to - * @param dataptr data to copy into the pbuf - * @param len length of data to copy into the pbuf - * @param chksum pointer to the checksum which is updated - * @return ERR_OK if successful, another error if the data does not fit - * within the (first) pbuf (no pbuf queues!) - */ -err_t -pbuf_fill_chksum(struct pbuf *p, u16_t start_offset, const void *dataptr, - u16_t len, u16_t *chksum) -{ - u32_t acc; - u16_t copy_chksum; - char *dst_ptr; - LWIP_ASSERT("p != NULL", p != NULL); - LWIP_ASSERT("dataptr != NULL", dataptr != NULL); - LWIP_ASSERT("chksum != NULL", chksum != NULL); - LWIP_ASSERT("len != 0", len != 0); - - if ((start_offset >= p->len) || (start_offset + len > p->len)) { - return ERR_ARG; - } - - dst_ptr = ((char *)p->payload) + start_offset; - copy_chksum = LWIP_CHKSUM_COPY(dst_ptr, dataptr, len); - if ((start_offset & 1) != 0) { - copy_chksum = SWAP_BYTES_IN_WORD(copy_chksum); - } - acc = *chksum; - acc += copy_chksum; - *chksum = FOLD_U32T(acc); - return ERR_OK; -} -#endif /* LWIP_CHECKSUM_ON_COPY */ - -/** - * @ingroup pbuf - * Get one byte from the specified position in a pbuf - * WARNING: returns zero for offset >= p->tot_len - * - * @param p pbuf to parse - * @param offset offset into p of the byte to return - * @return byte at an offset into p OR ZERO IF 'offset' >= p->tot_len - */ -u8_t -pbuf_get_at(const struct pbuf *p, u16_t offset) -{ - int ret = pbuf_try_get_at(p, offset); - if (ret >= 0) { - return (u8_t)ret; - } - return 0; -} - -/** - * @ingroup pbuf - * Get one byte from the specified position in a pbuf - * - * @param p pbuf to parse - * @param offset offset into p of the byte to return - * @return byte at an offset into p [0..0xFF] OR negative if 'offset' >= p->tot_len - */ -int -pbuf_try_get_at(const struct pbuf *p, u16_t offset) -{ - u16_t q_idx; - const struct pbuf *q = pbuf_skip_const(p, offset, &q_idx); - - /* return requested data if pbuf is OK */ - if ((q != NULL) && (q->len > q_idx)) { - return ((u8_t *)q->payload)[q_idx]; - } - return -1; -} - -/** - * @ingroup pbuf - * Put one byte to the specified position in a pbuf - * WARNING: silently ignores offset >= p->tot_len - * - * @param p pbuf to fill - * @param offset offset into p of the byte to write - * @param data byte to write at an offset into p - */ -void -pbuf_put_at(struct pbuf *p, u16_t offset, u8_t data) -{ - u16_t q_idx; - struct pbuf *q = pbuf_skip(p, offset, &q_idx); - - /* write requested data if pbuf is OK */ - if ((q != NULL) && (q->len > q_idx)) { - ((u8_t *)q->payload)[q_idx] = data; - } -} - -/** - * @ingroup pbuf - * Compare pbuf contents at specified offset with memory s2, both of length n - * - * @param p pbuf to compare - * @param offset offset into p at which to start comparing - * @param s2 buffer to compare - * @param n length of buffer to compare - * @return zero if equal, nonzero otherwise - * (0xffff if p is too short, diffoffset+1 otherwise) - */ -u16_t -pbuf_memcmp(const struct pbuf *p, u16_t offset, const void *s2, u16_t n) -{ - u16_t start = offset; - const struct pbuf *q = p; - u16_t i; - - /* pbuf long enough to perform check? */ - if (p->tot_len < (offset + n)) { - return 0xffff; - } - - /* get the correct pbuf from chain. We know it succeeds because of p->tot_len check above. */ - while ((q != NULL) && (q->len <= start)) { - start = (u16_t)(start - q->len); - q = q->next; - } - - /* return requested data if pbuf is OK */ - for (i = 0; i < n; i++) { - /* We know pbuf_get_at() succeeds because of p->tot_len check above. */ - u8_t a = pbuf_get_at(q, (u16_t)(start + i)); - u8_t b = ((const u8_t *)s2)[i]; - if (a != b) { - return (u16_t)LWIP_MIN(i + 1, 0xFFFF); - } - } - return 0; -} - -/** - * @ingroup pbuf - * Find occurrence of mem (with length mem_len) in pbuf p, starting at offset - * start_offset. - * - * @param p pbuf to search, maximum length is 0xFFFE since 0xFFFF is used as - * return value 'not found' - * @param mem search for the contents of this buffer - * @param mem_len length of 'mem' - * @param start_offset offset into p at which to start searching - * @return 0xFFFF if substr was not found in p or the index where it was found - */ -u16_t -pbuf_memfind(const struct pbuf *p, const void *mem, u16_t mem_len, u16_t start_offset) -{ - u16_t i; - u16_t max_cmp_start = (u16_t)(p->tot_len - mem_len); - if (p->tot_len >= mem_len + start_offset) { - for (i = start_offset; i <= max_cmp_start; i++) { - u16_t plus = pbuf_memcmp(p, i, mem, mem_len); - if (plus == 0) { - return i; - } - } - } - return 0xFFFF; -} - -/** - * Find occurrence of substr with length substr_len in pbuf p, start at offset - * start_offset - * WARNING: in contrast to strstr(), this one does not stop at the first \0 in - * the pbuf/source string! - * - * @param p pbuf to search, maximum length is 0xFFFE since 0xFFFF is used as - * return value 'not found' - * @param substr string to search for in p, maximum length is 0xFFFE - * @return 0xFFFF if substr was not found in p or the index where it was found - */ -u16_t -pbuf_strstr(const struct pbuf *p, const char *substr) -{ - size_t substr_len; - if ((substr == NULL) || (substr[0] == 0) || (p->tot_len == 0xFFFF)) { - return 0xFFFF; - } - substr_len = strlen(substr); - if (substr_len >= 0xFFFF) { - return 0xFFFF; - } - return pbuf_memfind(p, substr, (u16_t)substr_len, 0); -} +/** + * @file + * Packet buffer management + */ + +/** + * @defgroup pbuf Packet buffers (PBUF) + * @ingroup infrastructure + * + * Packets are built from the pbuf data structure. It supports dynamic + * memory allocation for packet contents or can reference externally + * managed packet contents both in RAM and ROM. Quick allocation for + * incoming packets is provided through pools with fixed sized pbufs. + * + * A packet may span over multiple pbufs, chained as a singly linked + * list. This is called a "pbuf chain". + * + * Multiple packets may be queued, also using this singly linked list. + * This is called a "packet queue". + * + * So, a packet queue consists of one or more pbuf chains, each of + * which consist of one or more pbufs. CURRENTLY, PACKET QUEUES ARE + * NOT SUPPORTED!!! Use helper structs to queue multiple packets. + * + * The differences between a pbuf chain and a packet queue are very + * precise but subtle. + * + * The last pbuf of a packet has a ->tot_len field that equals the + * ->len field. It can be found by traversing the list. If the last + * pbuf of a packet has a ->next field other than NULL, more packets + * are on the queue. + * + * Therefore, looping through a pbuf of a single packet, has an + * loop end condition (tot_len == p->len), NOT (next == NULL). + * + * Example of custom pbuf usage: @ref zerocopyrx + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#include "lwip/pbuf.h" +#include "lwip/stats.h" +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/sys.h" +#include "lwip/netif.h" +#if LWIP_TCP && TCP_QUEUE_OOSEQ +#include "lwip/priv/tcp_priv.h" +#endif +#if LWIP_CHECKSUM_ON_COPY +#include "lwip/inet_chksum.h" +#endif + +#include + +#define SIZEOF_STRUCT_PBUF LWIP_MEM_ALIGN_SIZE(sizeof(struct pbuf)) +/* Since the pool is created in memp, PBUF_POOL_BUFSIZE will be automatically + aligned there. Therefore, PBUF_POOL_BUFSIZE_ALIGNED can be used here. */ +#define PBUF_POOL_BUFSIZE_ALIGNED LWIP_MEM_ALIGN_SIZE(PBUF_POOL_BUFSIZE) + +static const struct pbuf * +pbuf_skip_const(const struct pbuf *in, u16_t in_offset, u16_t *out_offset); + +#if !LWIP_TCP || !TCP_QUEUE_OOSEQ || !PBUF_POOL_FREE_OOSEQ +#define PBUF_POOL_IS_EMPTY() +#else /* !LWIP_TCP || !TCP_QUEUE_OOSEQ || !PBUF_POOL_FREE_OOSEQ */ + +#if !NO_SYS +#ifndef PBUF_POOL_FREE_OOSEQ_QUEUE_CALL +#include "lwip/tcpip.h" +#define PBUF_POOL_FREE_OOSEQ_QUEUE_CALL() do { \ + if (tcpip_try_callback(pbuf_free_ooseq_callback, NULL) != ERR_OK) { \ + SYS_ARCH_PROTECT(old_level); \ + pbuf_free_ooseq_pending = 0; \ + SYS_ARCH_UNPROTECT(old_level); \ + } } while(0) +#endif /* PBUF_POOL_FREE_OOSEQ_QUEUE_CALL */ +#endif /* !NO_SYS */ + +volatile u8_t pbuf_free_ooseq_pending; +#define PBUF_POOL_IS_EMPTY() pbuf_pool_is_empty() + +/** + * Attempt to reclaim some memory from queued out-of-sequence TCP segments + * if we run out of pool pbufs. It's better to give priority to new packets + * if we're running out. + * + * This must be done in the correct thread context therefore this function + * can only be used with NO_SYS=0 and through tcpip_callback. + */ +#if !NO_SYS +static +#endif /* !NO_SYS */ +void +pbuf_free_ooseq(void) +{ + struct tcp_pcb *pcb; + SYS_ARCH_SET(pbuf_free_ooseq_pending, 0); + + for (pcb = tcp_active_pcbs; NULL != pcb; pcb = pcb->next) { + if (pcb->ooseq != NULL) { + /** Free the ooseq pbufs of one PCB only */ + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free_ooseq: freeing out-of-sequence pbufs\n")); + tcp_free_ooseq(pcb); + return; + } + } +} + +#if !NO_SYS +/** + * Just a callback function for tcpip_callback() that calls pbuf_free_ooseq(). + */ +static void +pbuf_free_ooseq_callback(void *arg) +{ + LWIP_UNUSED_ARG(arg); + pbuf_free_ooseq(); +} +#endif /* !NO_SYS */ + +/** Queue a call to pbuf_free_ooseq if not already queued. */ +static void +pbuf_pool_is_empty(void) +{ +#ifndef PBUF_POOL_FREE_OOSEQ_QUEUE_CALL + SYS_ARCH_SET(pbuf_free_ooseq_pending, 1); +#else /* PBUF_POOL_FREE_OOSEQ_QUEUE_CALL */ + u8_t queued; + SYS_ARCH_DECL_PROTECT(old_level); + SYS_ARCH_PROTECT(old_level); + queued = pbuf_free_ooseq_pending; + pbuf_free_ooseq_pending = 1; + SYS_ARCH_UNPROTECT(old_level); + + if (!queued) { + /* queue a call to pbuf_free_ooseq if not already queued */ + PBUF_POOL_FREE_OOSEQ_QUEUE_CALL(); + } +#endif /* PBUF_POOL_FREE_OOSEQ_QUEUE_CALL */ +} +#endif /* !LWIP_TCP || !TCP_QUEUE_OOSEQ || !PBUF_POOL_FREE_OOSEQ */ + +/* Initialize members of struct pbuf after allocation */ +static void +pbuf_init_alloced_pbuf(struct pbuf *p, void *payload, u16_t tot_len, u16_t len, pbuf_type type, u8_t flags) +{ + p->next = NULL; + p->payload = payload; + p->tot_len = tot_len; + p->len = len; + p->type_internal = (u8_t)type; + p->flags = flags; + p->ref = 1; + p->if_idx = NETIF_NO_INDEX; +} + +/** + * @ingroup pbuf + * Allocates a pbuf of the given type (possibly a chain for PBUF_POOL type). + * + * The actual memory allocated for the pbuf is determined by the + * layer at which the pbuf is allocated and the requested size + * (from the size parameter). + * + * @param layer header size + * @param length size of the pbuf's payload + * @param type this parameter decides how and where the pbuf + * should be allocated as follows: + * + * - PBUF_RAM: buffer memory for pbuf is allocated as one large + * chunk. This includes protocol headers as well. + * - PBUF_ROM: no buffer memory is allocated for the pbuf, even for + * protocol headers. Additional headers must be prepended + * by allocating another pbuf and chain in to the front of + * the ROM pbuf. It is assumed that the memory used is really + * similar to ROM in that it is immutable and will not be + * changed. Memory which is dynamic should generally not + * be attached to PBUF_ROM pbufs. Use PBUF_REF instead. + * - PBUF_REF: no buffer memory is allocated for the pbuf, even for + * protocol headers. It is assumed that the pbuf is only + * being used in a single thread. If the pbuf gets queued, + * then pbuf_take should be called to copy the buffer. + * - PBUF_POOL: the pbuf is allocated as a pbuf chain, with pbufs from + * the pbuf pool that is allocated during pbuf_init(). + * + * @return the allocated pbuf. If multiple pbufs where allocated, this + * is the first pbuf of a pbuf chain. + */ +struct pbuf * +pbuf_alloc(pbuf_layer layer, u16_t length, pbuf_type type) +{ + struct pbuf *p; + u16_t offset = (u16_t)layer; + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F")\n", length)); + + switch (type) { + case PBUF_REF: /* fall through */ + case PBUF_ROM: + p = pbuf_alloc_reference(NULL, length, type); + break; + case PBUF_POOL: { + struct pbuf *q, *last; + u16_t rem_len; /* remaining length */ + p = NULL; + last = NULL; + rem_len = length; + do { + u16_t qlen; + q = (struct pbuf *)memp_malloc(MEMP_PBUF_POOL); + if (q == NULL) { + PBUF_POOL_IS_EMPTY(); + /* free chain so far allocated */ + if (p) { + pbuf_free(p); + } + /* bail out unsuccessfully */ + return NULL; + } + qlen = LWIP_MIN(rem_len, (u16_t)(PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset))); + pbuf_init_alloced_pbuf(q, LWIP_MEM_ALIGN((void *)((u8_t *)q + SIZEOF_STRUCT_PBUF + offset)), + rem_len, qlen, type, 0); + LWIP_ASSERT("pbuf_alloc: pbuf q->payload properly aligned", + ((mem_ptr_t)q->payload % MEM_ALIGNMENT) == 0); + LWIP_ASSERT("PBUF_POOL_BUFSIZE must be bigger than MEM_ALIGNMENT", + (PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset)) > 0 ); + if (p == NULL) { + /* allocated head of pbuf chain (into p) */ + p = q; + } else { + /* make previous pbuf point to this pbuf */ + last->next = q; + } + last = q; + rem_len = (u16_t)(rem_len - qlen); + offset = 0; + } while (rem_len > 0); + break; + } + case PBUF_RAM: { + u16_t payload_len = (u16_t)(LWIP_MEM_ALIGN_SIZE(offset) + LWIP_MEM_ALIGN_SIZE(length)); + mem_size_t alloc_len = (mem_size_t)(LWIP_MEM_ALIGN_SIZE(SIZEOF_STRUCT_PBUF) + payload_len); + + /* bug #50040: Check for integer overflow when calculating alloc_len */ + if ((payload_len < LWIP_MEM_ALIGN_SIZE(length)) || + (alloc_len < LWIP_MEM_ALIGN_SIZE(length))) { + return NULL; + } + + /* If pbuf is to be allocated in RAM, allocate memory for it. */ + p = (struct pbuf *)mem_malloc(alloc_len); + if (p == NULL) { + return NULL; + } + pbuf_init_alloced_pbuf(p, LWIP_MEM_ALIGN((void *)((u8_t *)p + SIZEOF_STRUCT_PBUF + offset)), + length, length, type, 0); + LWIP_ASSERT("pbuf_alloc: pbuf->payload properly aligned", + ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0); + break; + } + default: + LWIP_ASSERT("pbuf_alloc: erroneous type", 0); + return NULL; + } + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%"U16_F") == %p\n", length, (void *)p)); + return p; +} + +/** + * @ingroup pbuf + * Allocates a pbuf for referenced data. + * Referenced data can be volatile (PBUF_REF) or long-lived (PBUF_ROM). + * + * The actual memory allocated for the pbuf is determined by the + * layer at which the pbuf is allocated and the requested size + * (from the size parameter). + * + * @param payload referenced payload + * @param length size of the pbuf's payload + * @param type this parameter decides how and where the pbuf + * should be allocated as follows: + * + * - PBUF_ROM: It is assumed that the memory used is really + * similar to ROM in that it is immutable and will not be + * changed. Memory which is dynamic should generally not + * be attached to PBUF_ROM pbufs. Use PBUF_REF instead. + * - PBUF_REF: It is assumed that the pbuf is only + * being used in a single thread. If the pbuf gets queued, + * then pbuf_take should be called to copy the buffer. + * + * @return the allocated pbuf. + */ +struct pbuf * +pbuf_alloc_reference(void *payload, u16_t length, pbuf_type type) +{ + struct pbuf *p; + LWIP_ASSERT("invalid pbuf_type", (type == PBUF_REF) || (type == PBUF_ROM)); + /* only allocate memory for the pbuf structure */ + p = (struct pbuf *)memp_malloc(MEMP_PBUF); + if (p == NULL) { + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("pbuf_alloc_reference: Could not allocate MEMP_PBUF for PBUF_%s.\n", + (type == PBUF_ROM) ? "ROM" : "REF")); + return NULL; + } + pbuf_init_alloced_pbuf(p, payload, length, length, type, 0); + return p; +} + + +#if LWIP_SUPPORT_CUSTOM_PBUF +/** + * @ingroup pbuf + * Initialize a custom pbuf (already allocated). + * Example of custom pbuf usage: @ref zerocopyrx + * + * @param l header size + * @param length size of the pbuf's payload + * @param type type of the pbuf (only used to treat the pbuf accordingly, as + * this function allocates no memory) + * @param p pointer to the custom pbuf to initialize (already allocated) + * @param payload_mem pointer to the buffer that is used for payload and headers, + * must be at least big enough to hold 'length' plus the header size, + * may be NULL if set later. + * ATTENTION: The caller is responsible for correct alignment of this buffer!! + * @param payload_mem_len the size of the 'payload_mem' buffer, must be at least + * big enough to hold 'length' plus the header size + */ +struct pbuf * +pbuf_alloced_custom(pbuf_layer l, u16_t length, pbuf_type type, struct pbuf_custom *p, + void *payload_mem, u16_t payload_mem_len) +{ + u16_t offset = (u16_t)l; + void *payload; + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloced_custom(length=%"U16_F")\n", length)); + + if (LWIP_MEM_ALIGN_SIZE(offset) + length > payload_mem_len) { + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_WARNING, ("pbuf_alloced_custom(length=%"U16_F") buffer too short\n", length)); + return NULL; + } + + if (payload_mem != NULL) { + payload = (u8_t *)payload_mem + LWIP_MEM_ALIGN_SIZE(offset); + } else { + payload = NULL; + } + pbuf_init_alloced_pbuf(&p->pbuf, payload, length, length, type, PBUF_FLAG_IS_CUSTOM); + return &p->pbuf; +} +#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ + +/** + * @ingroup pbuf + * Shrink a pbuf chain to a desired length. + * + * @param p pbuf to shrink. + * @param new_len desired new length of pbuf chain + * + * Depending on the desired length, the first few pbufs in a chain might + * be skipped and left unchanged. The new last pbuf in the chain will be + * resized, and any remaining pbufs will be freed. + * + * @note If the pbuf is ROM/REF, only the ->tot_len and ->len fields are adjusted. + * @note May not be called on a packet queue. + * + * @note Despite its name, pbuf_realloc cannot grow the size of a pbuf (chain). + */ +void +pbuf_realloc(struct pbuf *p, u16_t new_len) +{ + struct pbuf *q; + u16_t rem_len; /* remaining length */ + u16_t shrink; + + LWIP_ASSERT("pbuf_realloc: p != NULL", p != NULL); + + /* desired length larger than current length? */ + if (new_len >= p->tot_len) { + /* enlarging not yet supported */ + return; + } + + /* the pbuf chain grows by (new_len - p->tot_len) bytes + * (which may be negative in case of shrinking) */ + shrink = (u16_t)(p->tot_len - new_len); + + /* first, step over any pbufs that should remain in the chain */ + rem_len = new_len; + q = p; + /* should this pbuf be kept? */ + while (rem_len > q->len) { + /* decrease remaining length by pbuf length */ + rem_len = (u16_t)(rem_len - q->len); + /* decrease total length indicator */ + q->tot_len = (u16_t)(q->tot_len - shrink); + /* proceed to next pbuf in chain */ + q = q->next; + LWIP_ASSERT("pbuf_realloc: q != NULL", q != NULL); + } + /* we have now reached the new last pbuf (in q) */ + /* rem_len == desired length for pbuf q */ + + /* shrink allocated memory for PBUF_RAM */ + /* (other types merely adjust their length fields */ + if (pbuf_match_allocsrc(q, PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP) && (rem_len != q->len) +#if LWIP_SUPPORT_CUSTOM_PBUF + && ((q->flags & PBUF_FLAG_IS_CUSTOM) == 0) +#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ + ) { + /* reallocate and adjust the length of the pbuf that will be split */ + q = (struct pbuf *)mem_trim(q, (mem_size_t)(((u8_t *)q->payload - (u8_t *)q) + rem_len)); + LWIP_ASSERT("mem_trim returned q == NULL", q != NULL); + } + /* adjust length fields for new last pbuf */ + q->len = rem_len; + q->tot_len = q->len; + + /* any remaining pbufs in chain? */ + if (q->next != NULL) { + /* free remaining pbufs in chain */ + pbuf_free(q->next); + } + /* q is last packet in chain */ + q->next = NULL; + +} + +/** + * Adjusts the payload pointer to reveal headers in the payload. + * @see pbuf_add_header. + * + * @param p pbuf to change the header size. + * @param header_size_increment Number of bytes to increment header size. + * @param force Allow 'header_size_increment > 0' for PBUF_REF/PBUF_ROM types + * + * @return non-zero on failure, zero on success. + * + */ +static u8_t +pbuf_add_header_impl(struct pbuf *p, size_t header_size_increment, u8_t force) +{ + u16_t type_internal; + void *payload; + u16_t increment_magnitude; + + LWIP_ASSERT("p != NULL", p != NULL); + if ((p == NULL) || (header_size_increment > 0xFFFF)) { + return 1; + } + if (header_size_increment == 0) { + return 0; + } + + increment_magnitude = (u16_t)header_size_increment; + /* Do not allow tot_len to wrap as a result. */ + if ((u16_t)(increment_magnitude + p->tot_len) < increment_magnitude) { + return 1; + } + + type_internal = p->type_internal; + + /* pbuf types containing payloads? */ + if (type_internal & PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS) { + /* set new payload pointer */ + payload = (u8_t *)p->payload - header_size_increment; + /* boundary check fails? */ + if ((u8_t *)payload < (u8_t *)p + SIZEOF_STRUCT_PBUF) { + LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, + ("pbuf_add_header: failed as %p < %p (not enough space for new header size)\n", + (void *)payload, (void *)((u8_t *)p + SIZEOF_STRUCT_PBUF))); + /* bail out unsuccessfully */ + return 1; + } + /* pbuf types referring to external payloads? */ + } else { + /* hide a header in the payload? */ + if (force) { + payload = (u8_t *)p->payload - header_size_increment; + } else { + /* cannot expand payload to front (yet!) + * bail out unsuccessfully */ + return 1; + } + } + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_add_header: old %p new %p (%"U16_F")\n", + (void *)p->payload, (void *)payload, increment_magnitude)); + + /* modify pbuf fields */ + p->payload = payload; + p->len = (u16_t)(p->len + increment_magnitude); + p->tot_len = (u16_t)(p->tot_len + increment_magnitude); + + + return 0; +} + +/** + * Adjusts the payload pointer to reveal headers in the payload. + * + * Adjusts the ->payload pointer so that space for a header + * appears in the pbuf payload. + * + * The ->payload, ->tot_len and ->len fields are adjusted. + * + * @param p pbuf to change the header size. + * @param header_size_increment Number of bytes to increment header size which + * increases the size of the pbuf. New space is on the front. + * If header_size_increment is 0, this function does nothing and returns successful. + * + * PBUF_ROM and PBUF_REF type buffers cannot have their sizes increased, so + * the call will fail. A check is made that the increase in header size does + * not move the payload pointer in front of the start of the buffer. + * + * @return non-zero on failure, zero on success. + * + */ +u8_t +pbuf_add_header(struct pbuf *p, size_t header_size_increment) +{ + return pbuf_add_header_impl(p, header_size_increment, 0); +} + +/** + * Same as @ref pbuf_add_header but does not check if 'header_size > 0' is allowed. + * This is used internally only, to allow PBUF_REF for RX. + */ +u8_t +pbuf_add_header_force(struct pbuf *p, size_t header_size_increment) +{ + return pbuf_add_header_impl(p, header_size_increment, 1); +} + +/** + * Adjusts the payload pointer to hide headers in the payload. + * + * Adjusts the ->payload pointer so that space for a header + * disappears in the pbuf payload. + * + * The ->payload, ->tot_len and ->len fields are adjusted. + * + * @param p pbuf to change the header size. + * @param header_size_decrement Number of bytes to decrement header size which + * decreases the size of the pbuf. + * If header_size_decrement is 0, this function does nothing and returns successful. + * @return non-zero on failure, zero on success. + * + */ +u8_t +pbuf_remove_header(struct pbuf *p, size_t header_size_decrement) +{ + void *payload; + u16_t increment_magnitude; + + LWIP_ASSERT("p != NULL", p != NULL); + if ((p == NULL) || (header_size_decrement > 0xFFFF)) { + return 1; + } + if (header_size_decrement == 0) { + return 0; + } + + increment_magnitude = (u16_t)header_size_decrement; + /* Check that we aren't going to move off the end of the pbuf */ + LWIP_ERROR("increment_magnitude <= p->len", (increment_magnitude <= p->len), return 1;); + + /* remember current payload pointer */ + payload = p->payload; + LWIP_UNUSED_ARG(payload); /* only used in LWIP_DEBUGF below */ + + /* increase payload pointer (guarded by length check above) */ + p->payload = (u8_t *)p->payload + header_size_decrement; + /* modify pbuf length fields */ + p->len = (u16_t)(p->len - increment_magnitude); + p->tot_len = (u16_t)(p->tot_len - increment_magnitude); + + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_remove_header: old %p new %p (%"U16_F")\n", + (void *)payload, (void *)p->payload, increment_magnitude)); + + return 0; +} + +static u8_t +pbuf_header_impl(struct pbuf *p, s16_t header_size_increment, u8_t force) +{ + if (header_size_increment < 0) { + return pbuf_remove_header(p, (size_t) - header_size_increment); + } else { + return pbuf_add_header_impl(p, (size_t)header_size_increment, force); + } +} + +/** + * Adjusts the payload pointer to hide or reveal headers in the payload. + * + * Adjusts the ->payload pointer so that space for a header + * (dis)appears in the pbuf payload. + * + * The ->payload, ->tot_len and ->len fields are adjusted. + * + * @param p pbuf to change the header size. + * @param header_size_increment Number of bytes to increment header size which + * increases the size of the pbuf. New space is on the front. + * (Using a negative value decreases the header size.) + * If header_size_increment is 0, this function does nothing and returns successful. + * + * PBUF_ROM and PBUF_REF type buffers cannot have their sizes increased, so + * the call will fail. A check is made that the increase in header size does + * not move the payload pointer in front of the start of the buffer. + * @return non-zero on failure, zero on success. + * + */ +u8_t +pbuf_header(struct pbuf *p, s16_t header_size_increment) +{ + return pbuf_header_impl(p, header_size_increment, 0); +} + +/** + * Same as pbuf_header but does not check if 'header_size > 0' is allowed. + * This is used internally only, to allow PBUF_REF for RX. + */ +u8_t +pbuf_header_force(struct pbuf *p, s16_t header_size_increment) +{ + return pbuf_header_impl(p, header_size_increment, 1); +} + +/** Similar to pbuf_header(-size) but de-refs header pbufs for (size >= p->len) + * + * @param q pbufs to operate on + * @param size The number of bytes to remove from the beginning of the pbuf list. + * While size >= p->len, pbufs are freed. + * ATTENTION: this is the opposite direction as @ref pbuf_header, but + * takes an u16_t not s16_t! + * @return the new head pbuf + */ +struct pbuf * +pbuf_free_header(struct pbuf *q, u16_t size) +{ + struct pbuf *p = q; + u16_t free_left = size; + while (free_left && p) { + if (free_left >= p->len) { + struct pbuf *f = p; + free_left = (u16_t)(free_left - p->len); + p = p->next; + f->next = 0; + pbuf_free(f); + } else { + pbuf_remove_header(p, free_left); + free_left = 0; + } + } + return p; +} + +/** + * @ingroup pbuf + * Dereference a pbuf chain or queue and deallocate any no-longer-used + * pbufs at the head of this chain or queue. + * + * Decrements the pbuf reference count. If it reaches zero, the pbuf is + * deallocated. + * + * For a pbuf chain, this is repeated for each pbuf in the chain, + * up to the first pbuf which has a non-zero reference count after + * decrementing. So, when all reference counts are one, the whole + * chain is free'd. + * + * @param p The pbuf (chain) to be dereferenced. + * + * @return the number of pbufs that were de-allocated + * from the head of the chain. + * + * @note MUST NOT be called on a packet queue (Not verified to work yet). + * @note the reference counter of a pbuf equals the number of pointers + * that refer to the pbuf (or into the pbuf). + * + * @internal examples: + * + * Assuming existing chains a->b->c with the following reference + * counts, calling pbuf_free(a) results in: + * + * 1->2->3 becomes ...1->3 + * 3->3->3 becomes 2->3->3 + * 1->1->2 becomes ......1 + * 2->1->1 becomes 1->1->1 + * 1->1->1 becomes ....... + * + */ +u8_t +pbuf_free(struct pbuf *p) +{ + u8_t alloc_src; + struct pbuf *q; + u8_t count; + + if (p == NULL) { + LWIP_ASSERT("p != NULL", p != NULL); + /* if assertions are disabled, proceed with debug output */ + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("pbuf_free(p == NULL) was called.\n")); + return 0; + } + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free(%p)\n", (void *)p)); + + PERF_START; + + count = 0; + /* de-allocate all consecutive pbufs from the head of the chain that + * obtain a zero reference count after decrementing*/ + while (p != NULL) { + LWIP_PBUF_REF_T ref; + SYS_ARCH_DECL_PROTECT(old_level); + /* Since decrementing ref cannot be guaranteed to be a single machine operation + * we must protect it. We put the new ref into a local variable to prevent + * further protection. */ + SYS_ARCH_PROTECT(old_level); + /* all pbufs in a chain are referenced at least once */ + LWIP_ASSERT("pbuf_free: p->ref > 0", p->ref > 0); + /* decrease reference count (number of pointers to pbuf) */ + ref = --(p->ref); + SYS_ARCH_UNPROTECT(old_level); + /* this pbuf is no longer referenced to? */ + if (ref == 0) { + /* remember next pbuf in chain for next iteration */ + q = p->next; + LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: deallocating %p\n", (void *)p)); + alloc_src = pbuf_get_allocsrc(p); +#if LWIP_SUPPORT_CUSTOM_PBUF + /* is this a custom pbuf? */ + if ((p->flags & PBUF_FLAG_IS_CUSTOM) != 0) { + struct pbuf_custom *pc = (struct pbuf_custom *)p; + LWIP_ASSERT("pc->custom_free_function != NULL", pc->custom_free_function != NULL); + pc->custom_free_function(p); + } else +#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ + { + /* is this a pbuf from the pool? */ + if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL) { + memp_free(MEMP_PBUF_POOL, p); + /* is this a ROM or RAM referencing pbuf? */ + } else if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF) { + memp_free(MEMP_PBUF, p); + /* type == PBUF_RAM */ + } else if (alloc_src == PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP) { + mem_free(p); + } else { + /* @todo: support freeing other types */ + LWIP_ASSERT("invalid pbuf type", 0); + } + } + count++; + /* proceed to next pbuf */ + p = q; + /* p->ref > 0, this pbuf is still referenced to */ + /* (and so the remaining pbufs in chain as well) */ + } else { + LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: %p has ref %"U16_F", ending here.\n", (void *)p, (u16_t)ref)); + /* stop walking through the chain */ + p = NULL; + } + } + PERF_STOP("pbuf_free"); + /* return number of de-allocated pbufs */ + return count; +} + +/** + * Count number of pbufs in a chain + * + * @param p first pbuf of chain + * @return the number of pbufs in a chain + */ +u16_t +pbuf_clen(const struct pbuf *p) +{ + u16_t len; + + len = 0; + while (p != NULL) { + ++len; + p = p->next; + } + return len; +} + +/** + * @ingroup pbuf + * Increment the reference count of the pbuf. + * + * @param p pbuf to increase reference counter of + * + */ +void +pbuf_ref(struct pbuf *p) +{ + /* pbuf given? */ + if (p != NULL) { + SYS_ARCH_SET(p->ref, (LWIP_PBUF_REF_T)(p->ref + 1)); + LWIP_ASSERT("pbuf ref overflow", p->ref > 0); + } +} + +/** + * @ingroup pbuf + * Concatenate two pbufs (each may be a pbuf chain) and take over + * the caller's reference of the tail pbuf. + * + * @note The caller MAY NOT reference the tail pbuf afterwards. + * Use pbuf_chain() for that purpose. + * + * This function explicitly does not check for tot_len overflow to prevent + * failing to queue too long pbufs. This can produce invalid pbufs, so + * handle with care! + * + * @see pbuf_chain() + */ +void +pbuf_cat(struct pbuf *h, struct pbuf *t) +{ + struct pbuf *p; + + LWIP_ERROR("(h != NULL) && (t != NULL) (programmer violates API)", + ((h != NULL) && (t != NULL)), return;); + + /* proceed to last pbuf of chain */ + for (p = h; p->next != NULL; p = p->next) { + /* add total length of second chain to all totals of first chain */ + p->tot_len = (u16_t)(p->tot_len + t->tot_len); + } + /* { p is last pbuf of first h chain, p->next == NULL } */ + LWIP_ASSERT("p->tot_len == p->len (of last pbuf in chain)", p->tot_len == p->len); + LWIP_ASSERT("p->next == NULL", p->next == NULL); + /* add total length of second chain to last pbuf total of first chain */ + p->tot_len = (u16_t)(p->tot_len + t->tot_len); + /* chain last pbuf of head (p) with first of tail (t) */ + p->next = t; + /* p->next now references t, but the caller will drop its reference to t, + * so netto there is no change to the reference count of t. + */ +} + +/** + * @ingroup pbuf + * Chain two pbufs (or pbuf chains) together. + * + * The caller MUST call pbuf_free(t) once it has stopped + * using it. Use pbuf_cat() instead if you no longer use t. + * + * @param h head pbuf (chain) + * @param t tail pbuf (chain) + * @note The pbufs MUST belong to the same packet. + * @note MAY NOT be called on a packet queue. + * + * The ->tot_len fields of all pbufs of the head chain are adjusted. + * The ->next field of the last pbuf of the head chain is adjusted. + * The ->ref field of the first pbuf of the tail chain is adjusted. + * + */ +void +pbuf_chain(struct pbuf *h, struct pbuf *t) +{ + pbuf_cat(h, t); + /* t is now referenced by h */ + pbuf_ref(t); + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_chain: %p references %p\n", (void *)h, (void *)t)); +} + +/** + * Dechains the first pbuf from its succeeding pbufs in the chain. + * + * Makes p->tot_len field equal to p->len. + * @param p pbuf to dechain + * @return remainder of the pbuf chain, or NULL if it was de-allocated. + * @note May not be called on a packet queue. + */ +struct pbuf * +pbuf_dechain(struct pbuf *p) +{ + struct pbuf *q; + u8_t tail_gone = 1; + /* tail */ + q = p->next; + /* pbuf has successor in chain? */ + if (q != NULL) { + /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */ + LWIP_ASSERT("p->tot_len == p->len + q->tot_len", q->tot_len == p->tot_len - p->len); + /* enforce invariant if assertion is disabled */ + q->tot_len = (u16_t)(p->tot_len - p->len); + /* decouple pbuf from remainder */ + p->next = NULL; + /* total length of pbuf p is its own length only */ + p->tot_len = p->len; + /* q is no longer referenced by p, free it */ + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_dechain: unreferencing %p\n", (void *)q)); + tail_gone = pbuf_free(q); + if (tail_gone > 0) { + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, + ("pbuf_dechain: deallocated %p (as it is no longer referenced)\n", (void *)q)); + } + /* return remaining tail or NULL if deallocated */ + } + /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */ + LWIP_ASSERT("p->tot_len == p->len", p->tot_len == p->len); + return ((tail_gone > 0) ? NULL : q); +} + +/** + * @ingroup pbuf + * Create PBUF_RAM copies of pbufs. + * + * Used to queue packets on behalf of the lwIP stack, such as + * ARP based queueing. + * + * @note You MUST explicitly use p = pbuf_take(p); + * + * @note Only one packet is copied, no packet queue! + * + * @param p_to pbuf destination of the copy + * @param p_from pbuf source of the copy + * + * @return ERR_OK if pbuf was copied + * ERR_ARG if one of the pbufs is NULL or p_to is not big + * enough to hold p_from + */ +err_t +pbuf_copy(struct pbuf *p_to, const struct pbuf *p_from) +{ + size_t offset_to = 0, offset_from = 0, len; + + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy(%p, %p)\n", + (const void *)p_to, (const void *)p_from)); + + /* is the target big enough to hold the source? */ + LWIP_ERROR("pbuf_copy: target not big enough to hold source", ((p_to != NULL) && + (p_from != NULL) && (p_to->tot_len >= p_from->tot_len)), return ERR_ARG;); + + /* iterate through pbuf chain */ + do { + /* copy one part of the original chain */ + if ((p_to->len - offset_to) >= (p_from->len - offset_from)) { + /* complete current p_from fits into current p_to */ + len = p_from->len - offset_from; + } else { + /* current p_from does not fit into current p_to */ + len = p_to->len - offset_to; + } + MEMCPY((u8_t *)p_to->payload + offset_to, (u8_t *)p_from->payload + offset_from, len); + offset_to += len; + offset_from += len; + LWIP_ASSERT("offset_to <= p_to->len", offset_to <= p_to->len); + LWIP_ASSERT("offset_from <= p_from->len", offset_from <= p_from->len); + if (offset_from >= p_from->len) { + /* on to next p_from (if any) */ + offset_from = 0; + p_from = p_from->next; + } + if (offset_to == p_to->len) { + /* on to next p_to (if any) */ + offset_to = 0; + p_to = p_to->next; + LWIP_ERROR("p_to != NULL", (p_to != NULL) || (p_from == NULL), return ERR_ARG;); + } + + if ((p_from != NULL) && (p_from->len == p_from->tot_len)) { + /* don't copy more than one packet! */ + LWIP_ERROR("pbuf_copy() does not allow packet queues!", + (p_from->next == NULL), return ERR_VAL;); + } + if ((p_to != NULL) && (p_to->len == p_to->tot_len)) { + /* don't copy more than one packet! */ + LWIP_ERROR("pbuf_copy() does not allow packet queues!", + (p_to->next == NULL), return ERR_VAL;); + } + } while (p_from); + LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy: end of chain reached.\n")); + return ERR_OK; +} + +/** + * @ingroup pbuf + * Copy (part of) the contents of a packet buffer + * to an application supplied buffer. + * + * @param buf the pbuf from which to copy data + * @param dataptr the application supplied buffer + * @param len length of data to copy (dataptr must be big enough). No more + * than buf->tot_len will be copied, irrespective of len + * @param offset offset into the packet buffer from where to begin copying len bytes + * @return the number of bytes copied, or 0 on failure + */ +u16_t +pbuf_copy_partial(const struct pbuf *buf, void *dataptr, u16_t len, u16_t offset) +{ + const struct pbuf *p; + u16_t left = 0; + u16_t buf_copy_len; + u16_t copied_total = 0; + + LWIP_ERROR("pbuf_copy_partial: invalid buf", (buf != NULL), return 0;); + LWIP_ERROR("pbuf_copy_partial: invalid dataptr", (dataptr != NULL), return 0;); + + /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */ + for (p = buf; len != 0 && p != NULL; p = p->next) { + if ((offset != 0) && (offset >= p->len)) { + /* don't copy from this buffer -> on to the next */ + offset = (u16_t)(offset - p->len); + } else { + /* copy from this buffer. maybe only partially. */ + buf_copy_len = (u16_t)(p->len - offset); + if (buf_copy_len > len) { + buf_copy_len = len; + } + /* copy the necessary parts of the buffer */ + MEMCPY(&((char *)dataptr)[left], &((char *)p->payload)[offset], buf_copy_len); + copied_total = (u16_t)(copied_total + buf_copy_len); + left = (u16_t)(left + buf_copy_len); + len = (u16_t)(len - buf_copy_len); + offset = 0; + } + } + return copied_total; +} + +/** + * @ingroup pbuf + * Get part of a pbuf's payload as contiguous memory. The returned memory is + * either a pointer into the pbuf's payload or, if split over multiple pbufs, + * a copy into the user-supplied buffer. + * + * @param p the pbuf from which to copy data + * @param buffer the application supplied buffer + * @param bufsize size of the application supplied buffer + * @param len length of data to copy (dataptr must be big enough). No more + * than buf->tot_len will be copied, irrespective of len + * @param offset offset into the packet buffer from where to begin copying len bytes + * @return the number of bytes copied, or 0 on failure + */ +void * +pbuf_get_contiguous(const struct pbuf *p, void *buffer, size_t bufsize, u16_t len, u16_t offset) +{ + const struct pbuf *q; + u16_t out_offset; + + LWIP_ERROR("pbuf_get_contiguous: invalid buf", (p != NULL), return NULL;); + LWIP_ERROR("pbuf_get_contiguous: invalid dataptr", (buffer != NULL), return NULL;); + LWIP_ERROR("pbuf_get_contiguous: invalid dataptr", (bufsize >= len), return NULL;); + + q = pbuf_skip_const(p, offset, &out_offset); + if (q != NULL) { + if (q->len >= (out_offset + len)) { + /* all data in this pbuf, return zero-copy */ + return (u8_t *)q->payload + out_offset; + } + /* need to copy */ + if (pbuf_copy_partial(q, buffer, len, out_offset) != len) { + /* copying failed: pbuf is too short */ + return NULL; + } + return buffer; + } + /* pbuf is too short (offset does not fit in) */ + return NULL; +} + +#if LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE +/** + * This method modifies a 'pbuf chain', so that its total length is + * smaller than 64K. The remainder of the original pbuf chain is stored + * in *rest. + * This function never creates new pbufs, but splits an existing chain + * in two parts. The tot_len of the modified packet queue will likely be + * smaller than 64K. + * 'packet queues' are not supported by this function. + * + * @param p the pbuf queue to be split + * @param rest pointer to store the remainder (after the first 64K) + */ +void pbuf_split_64k(struct pbuf *p, struct pbuf **rest) +{ + *rest = NULL; + if ((p != NULL) && (p->next != NULL)) { + u16_t tot_len_front = p->len; + struct pbuf *i = p; + struct pbuf *r = p->next; + + /* continue until the total length (summed up as u16_t) overflows */ + while ((r != NULL) && ((u16_t)(tot_len_front + r->len) >= tot_len_front)) { + tot_len_front = (u16_t)(tot_len_front + r->len); + i = r; + r = r->next; + } + /* i now points to last packet of the first segment. Set next + pointer to NULL */ + i->next = NULL; + + if (r != NULL) { + /* Update the tot_len field in the first part */ + for (i = p; i != NULL; i = i->next) { + i->tot_len = (u16_t)(i->tot_len - r->tot_len); + LWIP_ASSERT("tot_len/len mismatch in last pbuf", + (i->next != NULL) || (i->tot_len == i->len)); + } + if (p->flags & PBUF_FLAG_TCP_FIN) { + r->flags |= PBUF_FLAG_TCP_FIN; + } + + /* tot_len field in rest does not need modifications */ + /* reference counters do not need modifications */ + *rest = r; + } + } +} +#endif /* LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + +/* Actual implementation of pbuf_skip() but returning const pointer... */ +static const struct pbuf * +pbuf_skip_const(const struct pbuf *in, u16_t in_offset, u16_t *out_offset) +{ + u16_t offset_left = in_offset; + const struct pbuf *q = in; + + /* get the correct pbuf */ + while ((q != NULL) && (q->len <= offset_left)) { + offset_left = (u16_t)(offset_left - q->len); + q = q->next; + } + if (out_offset != NULL) { + *out_offset = offset_left; + } + return q; +} + +/** + * @ingroup pbuf + * Skip a number of bytes at the start of a pbuf + * + * @param in input pbuf + * @param in_offset offset to skip + * @param out_offset resulting offset in the returned pbuf + * @return the pbuf in the queue where the offset is + */ +struct pbuf * +pbuf_skip(struct pbuf *in, u16_t in_offset, u16_t *out_offset) +{ + const struct pbuf *out = pbuf_skip_const(in, in_offset, out_offset); + return LWIP_CONST_CAST(struct pbuf *, out); +} + +/** + * @ingroup pbuf + * Copy application supplied data into a pbuf. + * This function can only be used to copy the equivalent of buf->tot_len data. + * + * @param buf pbuf to fill with data + * @param dataptr application supplied data buffer + * @param len length of the application supplied data buffer + * + * @return ERR_OK if successful, ERR_MEM if the pbuf is not big enough + */ +err_t +pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len) +{ + struct pbuf *p; + size_t buf_copy_len; + size_t total_copy_len = len; + size_t copied_total = 0; + + LWIP_ERROR("pbuf_take: invalid buf", (buf != NULL), return ERR_ARG;); + LWIP_ERROR("pbuf_take: invalid dataptr", (dataptr != NULL), return ERR_ARG;); + LWIP_ERROR("pbuf_take: buf not large enough", (buf->tot_len >= len), return ERR_MEM;); + + if ((buf == NULL) || (dataptr == NULL) || (buf->tot_len < len)) { + return ERR_ARG; + } + + /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */ + for (p = buf; total_copy_len != 0; p = p->next) { + LWIP_ASSERT("pbuf_take: invalid pbuf", p != NULL); + buf_copy_len = total_copy_len; + if (buf_copy_len > p->len) { + /* this pbuf cannot hold all remaining data */ + buf_copy_len = p->len; + } + /* copy the necessary parts of the buffer */ + MEMCPY(p->payload, &((const char *)dataptr)[copied_total], buf_copy_len); + total_copy_len -= buf_copy_len; + copied_total += buf_copy_len; + } + LWIP_ASSERT("did not copy all data", total_copy_len == 0 && copied_total == len); + return ERR_OK; +} + +/** + * @ingroup pbuf + * Same as pbuf_take() but puts data at an offset + * + * @param buf pbuf to fill with data + * @param dataptr application supplied data buffer + * @param len length of the application supplied data buffer + * @param offset offset in pbuf where to copy dataptr to + * + * @return ERR_OK if successful, ERR_MEM if the pbuf is not big enough + */ +err_t +pbuf_take_at(struct pbuf *buf, const void *dataptr, u16_t len, u16_t offset) +{ + u16_t target_offset; + struct pbuf *q = pbuf_skip(buf, offset, &target_offset); + + /* return requested data if pbuf is OK */ + if ((q != NULL) && (q->tot_len >= target_offset + len)) { + u16_t remaining_len = len; + const u8_t *src_ptr = (const u8_t *)dataptr; + /* copy the part that goes into the first pbuf */ + u16_t first_copy_len; + LWIP_ASSERT("check pbuf_skip result", target_offset < q->len); + first_copy_len = (u16_t)LWIP_MIN(q->len - target_offset, len); + MEMCPY(((u8_t *)q->payload) + target_offset, dataptr, first_copy_len); + remaining_len = (u16_t)(remaining_len - first_copy_len); + src_ptr += first_copy_len; + if (remaining_len > 0) { + return pbuf_take(q->next, src_ptr, remaining_len); + } + return ERR_OK; + } + return ERR_MEM; +} + +/** + * @ingroup pbuf + * Creates a single pbuf out of a queue of pbufs. + * + * @remark: Either the source pbuf 'p' is freed by this function or the original + * pbuf 'p' is returned, therefore the caller has to check the result! + * + * @param p the source pbuf + * @param layer pbuf_layer of the new pbuf + * + * @return a new, single pbuf (p->next is NULL) + * or the old pbuf if allocation fails + */ +struct pbuf * +pbuf_coalesce(struct pbuf *p, pbuf_layer layer) +{ + struct pbuf *q; + if (p->next == NULL) { + return p; + } + q = pbuf_clone(layer, PBUF_RAM, p); + if (q == NULL) { + /* @todo: what do we do now? */ + return p; + } + pbuf_free(p); + return q; +} + +/** + * @ingroup pbuf + * Allocates a new pbuf of same length (via pbuf_alloc()) and copies the source + * pbuf into this new pbuf (using pbuf_copy()). + * + * @param layer pbuf_layer of the new pbuf + * @param type this parameter decides how and where the pbuf should be allocated + * (@see pbuf_alloc()) + * @param p the source pbuf + * + * @return a new pbuf or NULL if allocation fails + */ +struct pbuf * +pbuf_clone(pbuf_layer layer, pbuf_type type, struct pbuf *p) +{ + struct pbuf *q; + err_t err; + q = pbuf_alloc(layer, p->tot_len, type); + if (q == NULL) { + return NULL; + } + err = pbuf_copy(q, p); + LWIP_UNUSED_ARG(err); /* in case of LWIP_NOASSERT */ + LWIP_ASSERT("pbuf_copy failed", err == ERR_OK); + return q; +} + +#if LWIP_CHECKSUM_ON_COPY +/** + * Copies data into a single pbuf (*not* into a pbuf queue!) and updates + * the checksum while copying + * + * @param p the pbuf to copy data into + * @param start_offset offset of p->payload where to copy the data to + * @param dataptr data to copy into the pbuf + * @param len length of data to copy into the pbuf + * @param chksum pointer to the checksum which is updated + * @return ERR_OK if successful, another error if the data does not fit + * within the (first) pbuf (no pbuf queues!) + */ +err_t +pbuf_fill_chksum(struct pbuf *p, u16_t start_offset, const void *dataptr, + u16_t len, u16_t *chksum) +{ + u32_t acc; + u16_t copy_chksum; + char *dst_ptr; + LWIP_ASSERT("p != NULL", p != NULL); + LWIP_ASSERT("dataptr != NULL", dataptr != NULL); + LWIP_ASSERT("chksum != NULL", chksum != NULL); + LWIP_ASSERT("len != 0", len != 0); + + if ((start_offset >= p->len) || (start_offset + len > p->len)) { + return ERR_ARG; + } + + dst_ptr = ((char *)p->payload) + start_offset; + copy_chksum = LWIP_CHKSUM_COPY(dst_ptr, dataptr, len); + if ((start_offset & 1) != 0) { + copy_chksum = SWAP_BYTES_IN_WORD(copy_chksum); + } + acc = *chksum; + acc += copy_chksum; + *chksum = FOLD_U32T(acc); + return ERR_OK; +} +#endif /* LWIP_CHECKSUM_ON_COPY */ + +/** + * @ingroup pbuf + * Get one byte from the specified position in a pbuf + * WARNING: returns zero for offset >= p->tot_len + * + * @param p pbuf to parse + * @param offset offset into p of the byte to return + * @return byte at an offset into p OR ZERO IF 'offset' >= p->tot_len + */ +u8_t +pbuf_get_at(const struct pbuf *p, u16_t offset) +{ + int ret = pbuf_try_get_at(p, offset); + if (ret >= 0) { + return (u8_t)ret; + } + return 0; +} + +/** + * @ingroup pbuf + * Get one byte from the specified position in a pbuf + * + * @param p pbuf to parse + * @param offset offset into p of the byte to return + * @return byte at an offset into p [0..0xFF] OR negative if 'offset' >= p->tot_len + */ +int +pbuf_try_get_at(const struct pbuf *p, u16_t offset) +{ + u16_t q_idx; + const struct pbuf *q = pbuf_skip_const(p, offset, &q_idx); + + /* return requested data if pbuf is OK */ + if ((q != NULL) && (q->len > q_idx)) { + return ((u8_t *)q->payload)[q_idx]; + } + return -1; +} + +/** + * @ingroup pbuf + * Put one byte to the specified position in a pbuf + * WARNING: silently ignores offset >= p->tot_len + * + * @param p pbuf to fill + * @param offset offset into p of the byte to write + * @param data byte to write at an offset into p + */ +void +pbuf_put_at(struct pbuf *p, u16_t offset, u8_t data) +{ + u16_t q_idx; + struct pbuf *q = pbuf_skip(p, offset, &q_idx); + + /* write requested data if pbuf is OK */ + if ((q != NULL) && (q->len > q_idx)) { + ((u8_t *)q->payload)[q_idx] = data; + } +} + +/** + * @ingroup pbuf + * Compare pbuf contents at specified offset with memory s2, both of length n + * + * @param p pbuf to compare + * @param offset offset into p at which to start comparing + * @param s2 buffer to compare + * @param n length of buffer to compare + * @return zero if equal, nonzero otherwise + * (0xffff if p is too short, diffoffset+1 otherwise) + */ +u16_t +pbuf_memcmp(const struct pbuf *p, u16_t offset, const void *s2, u16_t n) +{ + u16_t start = offset; + const struct pbuf *q = p; + u16_t i; + + /* pbuf long enough to perform check? */ + if (p->tot_len < (offset + n)) { + return 0xffff; + } + + /* get the correct pbuf from chain. We know it succeeds because of p->tot_len check above. */ + while ((q != NULL) && (q->len <= start)) { + start = (u16_t)(start - q->len); + q = q->next; + } + + /* return requested data if pbuf is OK */ + for (i = 0; i < n; i++) { + /* We know pbuf_get_at() succeeds because of p->tot_len check above. */ + u8_t a = pbuf_get_at(q, (u16_t)(start + i)); + u8_t b = ((const u8_t *)s2)[i]; + if (a != b) { + return (u16_t)LWIP_MIN(i + 1, 0xFFFF); + } + } + return 0; +} + +/** + * @ingroup pbuf + * Find occurrence of mem (with length mem_len) in pbuf p, starting at offset + * start_offset. + * + * @param p pbuf to search, maximum length is 0xFFFE since 0xFFFF is used as + * return value 'not found' + * @param mem search for the contents of this buffer + * @param mem_len length of 'mem' + * @param start_offset offset into p at which to start searching + * @return 0xFFFF if substr was not found in p or the index where it was found + */ +u16_t +pbuf_memfind(const struct pbuf *p, const void *mem, u16_t mem_len, u16_t start_offset) +{ + u16_t i; + u16_t max_cmp_start = (u16_t)(p->tot_len - mem_len); + if (p->tot_len >= mem_len + start_offset) { + for (i = start_offset; i <= max_cmp_start; i++) { + u16_t plus = pbuf_memcmp(p, i, mem, mem_len); + if (plus == 0) { + return i; + } + } + } + return 0xFFFF; +} + +/** + * Find occurrence of substr with length substr_len in pbuf p, start at offset + * start_offset + * WARNING: in contrast to strstr(), this one does not stop at the first \0 in + * the pbuf/source string! + * + * @param p pbuf to search, maximum length is 0xFFFE since 0xFFFF is used as + * return value 'not found' + * @param substr string to search for in p, maximum length is 0xFFFE + * @return 0xFFFF if substr was not found in p or the index where it was found + */ +u16_t +pbuf_strstr(const struct pbuf *p, const char *substr) +{ + size_t substr_len; + if ((substr == NULL) || (substr[0] == 0) || (p->tot_len == 0xFFFF)) { + return 0xFFFF; + } + substr_len = strlen(substr); + if (substr_len >= 0xFFFF) { + return 0xFFFF; + } + return pbuf_memfind(p, substr, (u16_t)substr_len, 0); +} diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/raw.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/raw.c index 7a424325..3b34544b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/raw.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/raw.c @@ -1,671 +1,671 @@ -/** - * @file - * Implementation of raw protocol PCBs for low-level handling of - * different types of protocols besides (or overriding) those - * already available in lwIP.\n - * See also @ref raw_raw - * - * @defgroup raw_raw RAW - * @ingroup callbackstyle_api - * Implementation of raw protocol PCBs for low-level handling of - * different types of protocols besides (or overriding) those - * already available in lwIP.\n - * @see @ref api - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_RAW /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/def.h" -#include "lwip/memp.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/raw.h" -#include "lwip/priv/raw_priv.h" -#include "lwip/stats.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/inet_chksum.h" - -#include - -/** The list of RAW PCBs */ -static struct raw_pcb *raw_pcbs; - -static u8_t -raw_input_local_match(struct raw_pcb *pcb, u8_t broadcast) -{ - LWIP_UNUSED_ARG(broadcast); /* in IPv6 only case */ - - /* check if PCB is bound to specific netif */ - if ((pcb->netif_idx != NETIF_NO_INDEX) && - (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { - return 0; - } - -#if LWIP_IPV4 && LWIP_IPV6 - /* Dual-stack: PCBs listening to any IP type also listen to any IP address */ - if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { -#if IP_SOF_BROADCAST_RECV - if ((broadcast != 0) && !ip_get_option(pcb, SOF_BROADCAST)) { - return 0; - } -#endif /* IP_SOF_BROADCAST_RECV */ - return 1; - } -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - - /* Only need to check PCB if incoming IP version matches PCB IP version */ - if (IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ip_current_dest_addr())) { -#if LWIP_IPV4 - /* Special case: IPv4 broadcast: receive all broadcasts - * Note: broadcast variable can only be 1 if it is an IPv4 broadcast */ - if (broadcast != 0) { -#if IP_SOF_BROADCAST_RECV - if (ip_get_option(pcb, SOF_BROADCAST)) -#endif /* IP_SOF_BROADCAST_RECV */ - { - if (ip4_addr_isany(ip_2_ip4(&pcb->local_ip))) { - return 1; - } - } - } else -#endif /* LWIP_IPV4 */ - /* Handle IPv4 and IPv6: catch all or exact match */ - if (ip_addr_isany(&pcb->local_ip) || - ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { - return 1; - } - } - - return 0; -} - -/** - * Determine if in incoming IP packet is covered by a RAW PCB - * and if so, pass it to a user-provided receive callback function. - * - * Given an incoming IP datagram (as a chain of pbufs) this function - * finds a corresponding RAW PCB and calls the corresponding receive - * callback function. - * - * @param p pbuf to be demultiplexed to a RAW PCB. - * @param inp network interface on which the datagram was received. - * @return - 1 if the packet has been eaten by a RAW PCB receive - * callback function. The caller MAY NOT not reference the - * packet any longer, and MAY NOT call pbuf_free(). - * @return - 0 if packet is not eaten (pbuf is still referenced by the - * caller). - * - */ -raw_input_state_t -raw_input(struct pbuf *p, struct netif *inp) -{ - struct raw_pcb *pcb, *prev; - s16_t proto; - raw_input_state_t ret = RAW_INPUT_NONE; - u8_t broadcast = ip_addr_isbroadcast(ip_current_dest_addr(), ip_current_netif()); - - LWIP_UNUSED_ARG(inp); - -#if LWIP_IPV6 -#if LWIP_IPV4 - if (IP_HDR_GET_VERSION(p->payload) == 6) -#endif /* LWIP_IPV4 */ - { - struct ip6_hdr *ip6hdr = (struct ip6_hdr *)p->payload; - proto = IP6H_NEXTH(ip6hdr); - } -#if LWIP_IPV4 - else -#endif /* LWIP_IPV4 */ -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 - { - proto = IPH_PROTO((struct ip_hdr *)p->payload); - } -#endif /* LWIP_IPV4 */ - - prev = NULL; - pcb = raw_pcbs; - /* loop through all raw pcbs until the packet is eaten by one */ - /* this allows multiple pcbs to match against the packet by design */ - while (pcb != NULL) { - if ((pcb->protocol == proto) && raw_input_local_match(pcb, broadcast) && - (((pcb->flags & RAW_FLAGS_CONNECTED) == 0) || - ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()))) { - /* receive callback function available? */ - if (pcb->recv != NULL) { - u8_t eaten; -#ifndef LWIP_NOASSERT - void *old_payload = p->payload; -#endif - ret = RAW_INPUT_DELIVERED; - /* the receive callback function did not eat the packet? */ - eaten = pcb->recv(pcb->recv_arg, pcb, p, ip_current_src_addr()); - if (eaten != 0) { - /* receive function ate the packet */ - p = NULL; - if (prev != NULL) { - /* move the pcb to the front of raw_pcbs so that is - found faster next time */ - prev->next = pcb->next; - pcb->next = raw_pcbs; - raw_pcbs = pcb; - } - return RAW_INPUT_EATEN; - } else { - /* sanity-check that the receive callback did not alter the pbuf */ - LWIP_ASSERT("raw pcb recv callback altered pbuf payload pointer without eating packet", - p->payload == old_payload); - } - } - /* no receive callback function was set for this raw PCB */ - } - /* drop the packet */ - prev = pcb; - pcb = pcb->next; - } - return ret; -} - -/** - * @ingroup raw_raw - * Bind a RAW PCB. - * - * @param pcb RAW PCB to be bound with a local address ipaddr. - * @param ipaddr local IP address to bind with. Use IP4_ADDR_ANY to - * bind to all local interfaces. - * - * @return lwIP error code. - * - ERR_OK. Successful. No error occurred. - * - ERR_USE. The specified IP address is already bound to by - * another RAW PCB. - * - * @see raw_disconnect() - */ -err_t -raw_bind(struct raw_pcb *pcb, const ip_addr_t *ipaddr) -{ - LWIP_ASSERT_CORE_LOCKED(); - if ((pcb == NULL) || (ipaddr == NULL)) { - return ERR_VAL; - } - ip_addr_set_ipaddr(&pcb->local_ip, ipaddr); -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - /* If the given IP address should have a zone but doesn't, assign one now. - * This is legacy support: scope-aware callers should always provide properly - * zoned source addresses. */ - if (IP_IS_V6(&pcb->local_ip) && - ip6_addr_lacks_zone(ip_2_ip6(&pcb->local_ip), IP6_UNKNOWN)) { - ip6_addr_select_zone(ip_2_ip6(&pcb->local_ip), ip_2_ip6(&pcb->local_ip)); - } -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - return ERR_OK; -} - -/** - * @ingroup raw_raw - * Bind an RAW PCB to a specific netif. - * After calling this function, all packets received via this PCB - * are guaranteed to have come in via the specified netif, and all - * outgoing packets will go out via the specified netif. - * - * @param pcb RAW PCB to be bound with netif. - * @param netif netif to bind to. Can be NULL. - * - * @see raw_disconnect() - */ -void -raw_bind_netif(struct raw_pcb *pcb, const struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (netif != NULL) { - pcb->netif_idx = netif_get_index(netif); - } else { - pcb->netif_idx = NETIF_NO_INDEX; - } -} - -/** - * @ingroup raw_raw - * Connect an RAW PCB. This function is required by upper layers - * of lwip. Using the raw api you could use raw_sendto() instead - * - * This will associate the RAW PCB with the remote address. - * - * @param pcb RAW PCB to be connected with remote address ipaddr and port. - * @param ipaddr remote IP address to connect with. - * - * @return lwIP error code - * - * @see raw_disconnect() and raw_sendto() - */ -err_t -raw_connect(struct raw_pcb *pcb, const ip_addr_t *ipaddr) -{ - LWIP_ASSERT_CORE_LOCKED(); - if ((pcb == NULL) || (ipaddr == NULL)) { - return ERR_VAL; - } - ip_addr_set_ipaddr(&pcb->remote_ip, ipaddr); -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - /* If the given IP address should have a zone but doesn't, assign one now, - * using the bound address to make a more informed decision when possible. */ - if (IP_IS_V6(&pcb->remote_ip) && - ip6_addr_lacks_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNKNOWN)) { - ip6_addr_select_zone(ip_2_ip6(&pcb->remote_ip), ip_2_ip6(&pcb->local_ip)); - } -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - raw_set_flags(pcb, RAW_FLAGS_CONNECTED); - return ERR_OK; -} - -/** - * @ingroup raw_raw - * Disconnect a RAW PCB. - * - * @param pcb the raw pcb to disconnect. - */ -void -raw_disconnect(struct raw_pcb *pcb) -{ - LWIP_ASSERT_CORE_LOCKED(); - /* reset remote address association */ -#if LWIP_IPV4 && LWIP_IPV6 - if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { - ip_addr_copy(pcb->remote_ip, *IP_ANY_TYPE); - } else { -#endif - ip_addr_set_any(IP_IS_V6_VAL(pcb->remote_ip), &pcb->remote_ip); -#if LWIP_IPV4 && LWIP_IPV6 - } -#endif - pcb->netif_idx = NETIF_NO_INDEX; - /* mark PCB as unconnected */ - raw_clear_flags(pcb, RAW_FLAGS_CONNECTED); -} - -/** - * @ingroup raw_raw - * Set the callback function for received packets that match the - * raw PCB's protocol and binding. - * - * The callback function MUST either - * - eat the packet by calling pbuf_free() and returning non-zero. The - * packet will not be passed to other raw PCBs or other protocol layers. - * - not free the packet, and return zero. The packet will be matched - * against further PCBs and/or forwarded to another protocol layers. - */ -void -raw_recv(struct raw_pcb *pcb, raw_recv_fn recv, void *recv_arg) -{ - LWIP_ASSERT_CORE_LOCKED(); - /* remember recv() callback and user data */ - pcb->recv = recv; - pcb->recv_arg = recv_arg; -} - -/** - * @ingroup raw_raw - * Send the raw IP packet to the given address. An IP header will be prepended - * to the packet, unless the RAW_FLAGS_HDRINCL flag is set on the PCB. In that - * case, the packet must include an IP header, which will then be sent as is. - * - * @param pcb the raw pcb which to send - * @param p the IP payload to send - * @param ipaddr the destination address of the IP packet - * - */ -err_t -raw_sendto(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *ipaddr) -{ - struct netif *netif; - const ip_addr_t *src_ip; - - if ((pcb == NULL) || (ipaddr == NULL) || !IP_ADDR_PCB_VERSION_MATCH(pcb, ipaddr)) { - return ERR_VAL; - } - - LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_TRACE, ("raw_sendto\n")); - - if (pcb->netif_idx != NETIF_NO_INDEX) { - netif = netif_get_by_index(pcb->netif_idx); - } else { -#if LWIP_MULTICAST_TX_OPTIONS - netif = NULL; - if (ip_addr_ismulticast(ipaddr)) { - /* For multicast-destined packets, use the user-provided interface index to - * determine the outgoing interface, if an interface index is set and a - * matching netif can be found. Otherwise, fall back to regular routing. */ - netif = netif_get_by_index(pcb->mcast_ifindex); - } - - if (netif == NULL) -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - { - netif = ip_route(&pcb->local_ip, ipaddr); - } - } - - if (netif == NULL) { - LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_LEVEL_WARNING, ("raw_sendto: No route to ")); - ip_addr_debug_print(RAW_DEBUG | LWIP_DBG_LEVEL_WARNING, ipaddr); - return ERR_RTE; - } - - if (ip_addr_isany(&pcb->local_ip) || ip_addr_ismulticast(&pcb->local_ip)) { - /* use outgoing network interface IP address as source address */ - src_ip = ip_netif_get_local_ip(netif, ipaddr); -#if LWIP_IPV6 - if (src_ip == NULL) { - return ERR_RTE; - } -#endif /* LWIP_IPV6 */ - } else { - /* use RAW PCB local IP address as source address */ - src_ip = &pcb->local_ip; - } - - return raw_sendto_if_src(pcb, p, ipaddr, netif, src_ip); -} - -/** - * @ingroup raw_raw - * Send the raw IP packet to the given address, using a particular outgoing - * netif and source IP address. An IP header will be prepended to the packet, - * unless the RAW_FLAGS_HDRINCL flag is set on the PCB. In that case, the - * packet must include an IP header, which will then be sent as is. - * - * @param pcb RAW PCB used to send the data - * @param p chain of pbufs to be sent - * @param dst_ip destination IP address - * @param netif the netif used for sending - * @param src_ip source IP address - */ -err_t -raw_sendto_if_src(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, - struct netif *netif, const ip_addr_t *src_ip) -{ - err_t err; - struct pbuf *q; /* q will be sent down the stack */ - u16_t header_size; - u8_t ttl; - - LWIP_ASSERT_CORE_LOCKED(); - - if ((pcb == NULL) || (dst_ip == NULL) || (netif == NULL) || (src_ip == NULL) || - !IP_ADDR_PCB_VERSION_MATCH(pcb, src_ip) || !IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { - return ERR_VAL; - } - - header_size = ( -#if LWIP_IPV4 && LWIP_IPV6 - IP_IS_V6(dst_ip) ? IP6_HLEN : IP_HLEN); -#elif LWIP_IPV4 - IP_HLEN); -#else - IP6_HLEN); -#endif - - /* Handle the HDRINCL option as an exception: none of the code below applies - * to this case, and sending the packet needs to be done differently too. */ - if (pcb->flags & RAW_FLAGS_HDRINCL) { - /* A full header *must* be present in the first pbuf of the chain, as the - * output routines may access its fields directly. */ - if (p->len < header_size) { - return ERR_VAL; - } - /* @todo multicast loop support, if at all desired for this scenario.. */ - NETIF_SET_HINTS(netif, &pcb->netif_hints); - err = ip_output_if_hdrincl(p, src_ip, dst_ip, netif); - NETIF_RESET_HINTS(netif); - return err; - } - - /* packet too large to add an IP header without causing an overflow? */ - if ((u16_t)(p->tot_len + header_size) < p->tot_len) { - return ERR_MEM; - } - /* not enough space to add an IP header to first pbuf in given p chain? */ - if (pbuf_add_header(p, header_size)) { - /* allocate header in new pbuf */ - q = pbuf_alloc(PBUF_IP, 0, PBUF_RAM); - /* new header pbuf could not be allocated? */ - if (q == NULL) { - LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("raw_sendto: could not allocate header\n")); - return ERR_MEM; - } - if (p->tot_len != 0) { - /* chain header q in front of given pbuf p */ - pbuf_chain(q, p); - } - /* { first pbuf q points to header pbuf } */ - LWIP_DEBUGF(RAW_DEBUG, ("raw_sendto: added header pbuf %p before given pbuf %p\n", (void *)q, (void *)p)); - } else { - /* first pbuf q equals given pbuf */ - q = p; - if (pbuf_remove_header(q, header_size)) { - LWIP_ASSERT("Can't restore header we just removed!", 0); - return ERR_MEM; - } - } - -#if IP_SOF_BROADCAST - if (IP_IS_V4(dst_ip)) { - /* broadcast filter? */ - if (!ip_get_option(pcb, SOF_BROADCAST) && ip_addr_isbroadcast(dst_ip, netif)) { - LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_LEVEL_WARNING, ("raw_sendto: SOF_BROADCAST not enabled on pcb %p\n", (void *)pcb)); - /* free any temporary header pbuf allocated by pbuf_header() */ - if (q != p) { - pbuf_free(q); - } - return ERR_VAL; - } - } -#endif /* IP_SOF_BROADCAST */ - - /* Multicast Loop? */ -#if LWIP_MULTICAST_TX_OPTIONS - if (((pcb->flags & RAW_FLAGS_MULTICAST_LOOP) != 0) && ip_addr_ismulticast(dst_ip)) { - q->flags |= PBUF_FLAG_MCASTLOOP; - } -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - -#if LWIP_IPV6 - /* If requested, based on the IPV6_CHECKSUM socket option per RFC3542, - compute the checksum and update the checksum in the payload. */ - if (IP_IS_V6(dst_ip) && pcb->chksum_reqd) { - u16_t chksum = ip6_chksum_pseudo(p, pcb->protocol, p->tot_len, ip_2_ip6(src_ip), ip_2_ip6(dst_ip)); - LWIP_ASSERT("Checksum must fit into first pbuf", p->len >= (pcb->chksum_offset + 2)); - SMEMCPY(((u8_t *)p->payload) + pcb->chksum_offset, &chksum, sizeof(u16_t)); - } -#endif - - /* Determine TTL to use */ -#if LWIP_MULTICAST_TX_OPTIONS - ttl = (ip_addr_ismulticast(dst_ip) ? raw_get_multicast_ttl(pcb) : pcb->ttl); -#else /* LWIP_MULTICAST_TX_OPTIONS */ - ttl = pcb->ttl; -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - - NETIF_SET_HINTS(netif, &pcb->netif_hints); - err = ip_output_if(q, src_ip, dst_ip, ttl, pcb->tos, pcb->protocol, netif); - NETIF_RESET_HINTS(netif); - - /* did we chain a header earlier? */ - if (q != p) { - /* free the header */ - pbuf_free(q); - } - return err; -} - -/** - * @ingroup raw_raw - * Send the raw IP packet to the address given by raw_connect() - * - * @param pcb the raw pcb which to send - * @param p the IP payload to send - * - */ -err_t -raw_send(struct raw_pcb *pcb, struct pbuf *p) -{ - return raw_sendto(pcb, p, &pcb->remote_ip); -} - -/** - * @ingroup raw_raw - * Remove an RAW PCB. - * - * @param pcb RAW PCB to be removed. The PCB is removed from the list of - * RAW PCB's and the data structure is freed from memory. - * - * @see raw_new() - */ -void -raw_remove(struct raw_pcb *pcb) -{ - struct raw_pcb *pcb2; - LWIP_ASSERT_CORE_LOCKED(); - /* pcb to be removed is first in list? */ - if (raw_pcbs == pcb) { - /* make list start at 2nd pcb */ - raw_pcbs = raw_pcbs->next; - /* pcb not 1st in list */ - } else { - for (pcb2 = raw_pcbs; pcb2 != NULL; pcb2 = pcb2->next) { - /* find pcb in raw_pcbs list */ - if (pcb2->next != NULL && pcb2->next == pcb) { - /* remove pcb from list */ - pcb2->next = pcb->next; - break; - } - } - } - memp_free(MEMP_RAW_PCB, pcb); -} - -/** - * @ingroup raw_raw - * Create a RAW PCB. - * - * @return The RAW PCB which was created. NULL if the PCB data structure - * could not be allocated. - * - * @param proto the protocol number of the IPs payload (e.g. IP_PROTO_ICMP) - * - * @see raw_remove() - */ -struct raw_pcb * -raw_new(u8_t proto) -{ - struct raw_pcb *pcb; - - LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_TRACE, ("raw_new\n")); - LWIP_ASSERT_CORE_LOCKED(); - - pcb = (struct raw_pcb *)memp_malloc(MEMP_RAW_PCB); - /* could allocate RAW PCB? */ - if (pcb != NULL) { - /* initialize PCB to all zeroes */ - memset(pcb, 0, sizeof(struct raw_pcb)); - pcb->protocol = proto; - pcb->ttl = RAW_TTL; -#if LWIP_MULTICAST_TX_OPTIONS - raw_set_multicast_ttl(pcb, RAW_TTL); -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - pcb->next = raw_pcbs; - raw_pcbs = pcb; - } - return pcb; -} - -/** - * @ingroup raw_raw - * Create a RAW PCB for specific IP type. - * - * @return The RAW PCB which was created. NULL if the PCB data structure - * could not be allocated. - * - * @param type IP address type, see @ref lwip_ip_addr_type definitions. - * If you want to listen to IPv4 and IPv6 (dual-stack) packets, - * supply @ref IPADDR_TYPE_ANY as argument and bind to @ref IP_ANY_TYPE. - * @param proto the protocol number (next header) of the IPv6 packet payload - * (e.g. IP6_NEXTH_ICMP6) - * - * @see raw_remove() - */ -struct raw_pcb * -raw_new_ip_type(u8_t type, u8_t proto) -{ - struct raw_pcb *pcb; - LWIP_ASSERT_CORE_LOCKED(); - pcb = raw_new(proto); -#if LWIP_IPV4 && LWIP_IPV6 - if (pcb != NULL) { - IP_SET_TYPE_VAL(pcb->local_ip, type); - IP_SET_TYPE_VAL(pcb->remote_ip, type); - } -#else /* LWIP_IPV4 && LWIP_IPV6 */ - LWIP_UNUSED_ARG(type); -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - return pcb; -} - -/** This function is called from netif.c when address is changed - * - * @param old_addr IP address of the netif before change - * @param new_addr IP address of the netif after change - */ -void raw_netif_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) -{ - struct raw_pcb *rpcb; - - if (!ip_addr_isany(old_addr) && !ip_addr_isany(new_addr)) { - for (rpcb = raw_pcbs; rpcb != NULL; rpcb = rpcb->next) { - /* PCB bound to current local interface address? */ - if (ip_addr_cmp(&rpcb->local_ip, old_addr)) { - /* The PCB is bound to the old ipaddr and - * is set to bound to the new one instead */ - ip_addr_copy(rpcb->local_ip, *new_addr); - } - } - } -} - -#endif /* LWIP_RAW */ +/** + * @file + * Implementation of raw protocol PCBs for low-level handling of + * different types of protocols besides (or overriding) those + * already available in lwIP.\n + * See also @ref raw_raw + * + * @defgroup raw_raw RAW + * @ingroup callbackstyle_api + * Implementation of raw protocol PCBs for low-level handling of + * different types of protocols besides (or overriding) those + * already available in lwIP.\n + * @see @ref api + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_RAW /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/def.h" +#include "lwip/memp.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/raw.h" +#include "lwip/priv/raw_priv.h" +#include "lwip/stats.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/inet_chksum.h" + +#include + +/** The list of RAW PCBs */ +static struct raw_pcb *raw_pcbs; + +static u8_t +raw_input_local_match(struct raw_pcb *pcb, u8_t broadcast) +{ + LWIP_UNUSED_ARG(broadcast); /* in IPv6 only case */ + + /* check if PCB is bound to specific netif */ + if ((pcb->netif_idx != NETIF_NO_INDEX) && + (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { + return 0; + } + +#if LWIP_IPV4 && LWIP_IPV6 + /* Dual-stack: PCBs listening to any IP type also listen to any IP address */ + if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { +#if IP_SOF_BROADCAST_RECV + if ((broadcast != 0) && !ip_get_option(pcb, SOF_BROADCAST)) { + return 0; + } +#endif /* IP_SOF_BROADCAST_RECV */ + return 1; + } +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + + /* Only need to check PCB if incoming IP version matches PCB IP version */ + if (IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ip_current_dest_addr())) { +#if LWIP_IPV4 + /* Special case: IPv4 broadcast: receive all broadcasts + * Note: broadcast variable can only be 1 if it is an IPv4 broadcast */ + if (broadcast != 0) { +#if IP_SOF_BROADCAST_RECV + if (ip_get_option(pcb, SOF_BROADCAST)) +#endif /* IP_SOF_BROADCAST_RECV */ + { + if (ip4_addr_isany(ip_2_ip4(&pcb->local_ip))) { + return 1; + } + } + } else +#endif /* LWIP_IPV4 */ + /* Handle IPv4 and IPv6: catch all or exact match */ + if (ip_addr_isany(&pcb->local_ip) || + ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { + return 1; + } + } + + return 0; +} + +/** + * Determine if in incoming IP packet is covered by a RAW PCB + * and if so, pass it to a user-provided receive callback function. + * + * Given an incoming IP datagram (as a chain of pbufs) this function + * finds a corresponding RAW PCB and calls the corresponding receive + * callback function. + * + * @param p pbuf to be demultiplexed to a RAW PCB. + * @param inp network interface on which the datagram was received. + * @return - 1 if the packet has been eaten by a RAW PCB receive + * callback function. The caller MAY NOT not reference the + * packet any longer, and MAY NOT call pbuf_free(). + * @return - 0 if packet is not eaten (pbuf is still referenced by the + * caller). + * + */ +raw_input_state_t +raw_input(struct pbuf *p, struct netif *inp) +{ + struct raw_pcb *pcb, *prev; + s16_t proto; + raw_input_state_t ret = RAW_INPUT_NONE; + u8_t broadcast = ip_addr_isbroadcast(ip_current_dest_addr(), ip_current_netif()); + + LWIP_UNUSED_ARG(inp); + +#if LWIP_IPV6 +#if LWIP_IPV4 + if (IP_HDR_GET_VERSION(p->payload) == 6) +#endif /* LWIP_IPV4 */ + { + struct ip6_hdr *ip6hdr = (struct ip6_hdr *)p->payload; + proto = IP6H_NEXTH(ip6hdr); + } +#if LWIP_IPV4 + else +#endif /* LWIP_IPV4 */ +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 + { + proto = IPH_PROTO((struct ip_hdr *)p->payload); + } +#endif /* LWIP_IPV4 */ + + prev = NULL; + pcb = raw_pcbs; + /* loop through all raw pcbs until the packet is eaten by one */ + /* this allows multiple pcbs to match against the packet by design */ + while (pcb != NULL) { + if ((pcb->protocol == proto) && raw_input_local_match(pcb, broadcast) && + (((pcb->flags & RAW_FLAGS_CONNECTED) == 0) || + ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()))) { + /* receive callback function available? */ + if (pcb->recv != NULL) { + u8_t eaten; +#ifndef LWIP_NOASSERT + void *old_payload = p->payload; +#endif + ret = RAW_INPUT_DELIVERED; + /* the receive callback function did not eat the packet? */ + eaten = pcb->recv(pcb->recv_arg, pcb, p, ip_current_src_addr()); + if (eaten != 0) { + /* receive function ate the packet */ + p = NULL; + if (prev != NULL) { + /* move the pcb to the front of raw_pcbs so that is + found faster next time */ + prev->next = pcb->next; + pcb->next = raw_pcbs; + raw_pcbs = pcb; + } + return RAW_INPUT_EATEN; + } else { + /* sanity-check that the receive callback did not alter the pbuf */ + LWIP_ASSERT("raw pcb recv callback altered pbuf payload pointer without eating packet", + p->payload == old_payload); + } + } + /* no receive callback function was set for this raw PCB */ + } + /* drop the packet */ + prev = pcb; + pcb = pcb->next; + } + return ret; +} + +/** + * @ingroup raw_raw + * Bind a RAW PCB. + * + * @param pcb RAW PCB to be bound with a local address ipaddr. + * @param ipaddr local IP address to bind with. Use IP4_ADDR_ANY to + * bind to all local interfaces. + * + * @return lwIP error code. + * - ERR_OK. Successful. No error occurred. + * - ERR_USE. The specified IP address is already bound to by + * another RAW PCB. + * + * @see raw_disconnect() + */ +err_t +raw_bind(struct raw_pcb *pcb, const ip_addr_t *ipaddr) +{ + LWIP_ASSERT_CORE_LOCKED(); + if ((pcb == NULL) || (ipaddr == NULL)) { + return ERR_VAL; + } + ip_addr_set_ipaddr(&pcb->local_ip, ipaddr); +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + /* If the given IP address should have a zone but doesn't, assign one now. + * This is legacy support: scope-aware callers should always provide properly + * zoned source addresses. */ + if (IP_IS_V6(&pcb->local_ip) && + ip6_addr_lacks_zone(ip_2_ip6(&pcb->local_ip), IP6_UNKNOWN)) { + ip6_addr_select_zone(ip_2_ip6(&pcb->local_ip), ip_2_ip6(&pcb->local_ip)); + } +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + return ERR_OK; +} + +/** + * @ingroup raw_raw + * Bind an RAW PCB to a specific netif. + * After calling this function, all packets received via this PCB + * are guaranteed to have come in via the specified netif, and all + * outgoing packets will go out via the specified netif. + * + * @param pcb RAW PCB to be bound with netif. + * @param netif netif to bind to. Can be NULL. + * + * @see raw_disconnect() + */ +void +raw_bind_netif(struct raw_pcb *pcb, const struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (netif != NULL) { + pcb->netif_idx = netif_get_index(netif); + } else { + pcb->netif_idx = NETIF_NO_INDEX; + } +} + +/** + * @ingroup raw_raw + * Connect an RAW PCB. This function is required by upper layers + * of lwip. Using the raw api you could use raw_sendto() instead + * + * This will associate the RAW PCB with the remote address. + * + * @param pcb RAW PCB to be connected with remote address ipaddr and port. + * @param ipaddr remote IP address to connect with. + * + * @return lwIP error code + * + * @see raw_disconnect() and raw_sendto() + */ +err_t +raw_connect(struct raw_pcb *pcb, const ip_addr_t *ipaddr) +{ + LWIP_ASSERT_CORE_LOCKED(); + if ((pcb == NULL) || (ipaddr == NULL)) { + return ERR_VAL; + } + ip_addr_set_ipaddr(&pcb->remote_ip, ipaddr); +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + /* If the given IP address should have a zone but doesn't, assign one now, + * using the bound address to make a more informed decision when possible. */ + if (IP_IS_V6(&pcb->remote_ip) && + ip6_addr_lacks_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNKNOWN)) { + ip6_addr_select_zone(ip_2_ip6(&pcb->remote_ip), ip_2_ip6(&pcb->local_ip)); + } +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + raw_set_flags(pcb, RAW_FLAGS_CONNECTED); + return ERR_OK; +} + +/** + * @ingroup raw_raw + * Disconnect a RAW PCB. + * + * @param pcb the raw pcb to disconnect. + */ +void +raw_disconnect(struct raw_pcb *pcb) +{ + LWIP_ASSERT_CORE_LOCKED(); + /* reset remote address association */ +#if LWIP_IPV4 && LWIP_IPV6 + if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { + ip_addr_copy(pcb->remote_ip, *IP_ANY_TYPE); + } else { +#endif + ip_addr_set_any(IP_IS_V6_VAL(pcb->remote_ip), &pcb->remote_ip); +#if LWIP_IPV4 && LWIP_IPV6 + } +#endif + pcb->netif_idx = NETIF_NO_INDEX; + /* mark PCB as unconnected */ + raw_clear_flags(pcb, RAW_FLAGS_CONNECTED); +} + +/** + * @ingroup raw_raw + * Set the callback function for received packets that match the + * raw PCB's protocol and binding. + * + * The callback function MUST either + * - eat the packet by calling pbuf_free() and returning non-zero. The + * packet will not be passed to other raw PCBs or other protocol layers. + * - not free the packet, and return zero. The packet will be matched + * against further PCBs and/or forwarded to another protocol layers. + */ +void +raw_recv(struct raw_pcb *pcb, raw_recv_fn recv, void *recv_arg) +{ + LWIP_ASSERT_CORE_LOCKED(); + /* remember recv() callback and user data */ + pcb->recv = recv; + pcb->recv_arg = recv_arg; +} + +/** + * @ingroup raw_raw + * Send the raw IP packet to the given address. An IP header will be prepended + * to the packet, unless the RAW_FLAGS_HDRINCL flag is set on the PCB. In that + * case, the packet must include an IP header, which will then be sent as is. + * + * @param pcb the raw pcb which to send + * @param p the IP payload to send + * @param ipaddr the destination address of the IP packet + * + */ +err_t +raw_sendto(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *ipaddr) +{ + struct netif *netif; + const ip_addr_t *src_ip; + + if ((pcb == NULL) || (ipaddr == NULL) || !IP_ADDR_PCB_VERSION_MATCH(pcb, ipaddr)) { + return ERR_VAL; + } + + LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_TRACE, ("raw_sendto\n")); + + if (pcb->netif_idx != NETIF_NO_INDEX) { + netif = netif_get_by_index(pcb->netif_idx); + } else { +#if LWIP_MULTICAST_TX_OPTIONS + netif = NULL; + if (ip_addr_ismulticast(ipaddr)) { + /* For multicast-destined packets, use the user-provided interface index to + * determine the outgoing interface, if an interface index is set and a + * matching netif can be found. Otherwise, fall back to regular routing. */ + netif = netif_get_by_index(pcb->mcast_ifindex); + } + + if (netif == NULL) +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + { + netif = ip_route(&pcb->local_ip, ipaddr); + } + } + + if (netif == NULL) { + LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_LEVEL_WARNING, ("raw_sendto: No route to ")); + ip_addr_debug_print(RAW_DEBUG | LWIP_DBG_LEVEL_WARNING, ipaddr); + return ERR_RTE; + } + + if (ip_addr_isany(&pcb->local_ip) || ip_addr_ismulticast(&pcb->local_ip)) { + /* use outgoing network interface IP address as source address */ + src_ip = ip_netif_get_local_ip(netif, ipaddr); +#if LWIP_IPV6 + if (src_ip == NULL) { + return ERR_RTE; + } +#endif /* LWIP_IPV6 */ + } else { + /* use RAW PCB local IP address as source address */ + src_ip = &pcb->local_ip; + } + + return raw_sendto_if_src(pcb, p, ipaddr, netif, src_ip); +} + +/** + * @ingroup raw_raw + * Send the raw IP packet to the given address, using a particular outgoing + * netif and source IP address. An IP header will be prepended to the packet, + * unless the RAW_FLAGS_HDRINCL flag is set on the PCB. In that case, the + * packet must include an IP header, which will then be sent as is. + * + * @param pcb RAW PCB used to send the data + * @param p chain of pbufs to be sent + * @param dst_ip destination IP address + * @param netif the netif used for sending + * @param src_ip source IP address + */ +err_t +raw_sendto_if_src(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, + struct netif *netif, const ip_addr_t *src_ip) +{ + err_t err; + struct pbuf *q; /* q will be sent down the stack */ + u16_t header_size; + u8_t ttl; + + LWIP_ASSERT_CORE_LOCKED(); + + if ((pcb == NULL) || (dst_ip == NULL) || (netif == NULL) || (src_ip == NULL) || + !IP_ADDR_PCB_VERSION_MATCH(pcb, src_ip) || !IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { + return ERR_VAL; + } + + header_size = ( +#if LWIP_IPV4 && LWIP_IPV6 + IP_IS_V6(dst_ip) ? IP6_HLEN : IP_HLEN); +#elif LWIP_IPV4 + IP_HLEN); +#else + IP6_HLEN); +#endif + + /* Handle the HDRINCL option as an exception: none of the code below applies + * to this case, and sending the packet needs to be done differently too. */ + if (pcb->flags & RAW_FLAGS_HDRINCL) { + /* A full header *must* be present in the first pbuf of the chain, as the + * output routines may access its fields directly. */ + if (p->len < header_size) { + return ERR_VAL; + } + /* @todo multicast loop support, if at all desired for this scenario.. */ + NETIF_SET_HINTS(netif, &pcb->netif_hints); + err = ip_output_if_hdrincl(p, src_ip, dst_ip, netif); + NETIF_RESET_HINTS(netif); + return err; + } + + /* packet too large to add an IP header without causing an overflow? */ + if ((u16_t)(p->tot_len + header_size) < p->tot_len) { + return ERR_MEM; + } + /* not enough space to add an IP header to first pbuf in given p chain? */ + if (pbuf_add_header(p, header_size)) { + /* allocate header in new pbuf */ + q = pbuf_alloc(PBUF_IP, 0, PBUF_RAM); + /* new header pbuf could not be allocated? */ + if (q == NULL) { + LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("raw_sendto: could not allocate header\n")); + return ERR_MEM; + } + if (p->tot_len != 0) { + /* chain header q in front of given pbuf p */ + pbuf_chain(q, p); + } + /* { first pbuf q points to header pbuf } */ + LWIP_DEBUGF(RAW_DEBUG, ("raw_sendto: added header pbuf %p before given pbuf %p\n", (void *)q, (void *)p)); + } else { + /* first pbuf q equals given pbuf */ + q = p; + if (pbuf_remove_header(q, header_size)) { + LWIP_ASSERT("Can't restore header we just removed!", 0); + return ERR_MEM; + } + } + +#if IP_SOF_BROADCAST + if (IP_IS_V4(dst_ip)) { + /* broadcast filter? */ + if (!ip_get_option(pcb, SOF_BROADCAST) && ip_addr_isbroadcast(dst_ip, netif)) { + LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_LEVEL_WARNING, ("raw_sendto: SOF_BROADCAST not enabled on pcb %p\n", (void *)pcb)); + /* free any temporary header pbuf allocated by pbuf_header() */ + if (q != p) { + pbuf_free(q); + } + return ERR_VAL; + } + } +#endif /* IP_SOF_BROADCAST */ + + /* Multicast Loop? */ +#if LWIP_MULTICAST_TX_OPTIONS + if (((pcb->flags & RAW_FLAGS_MULTICAST_LOOP) != 0) && ip_addr_ismulticast(dst_ip)) { + q->flags |= PBUF_FLAG_MCASTLOOP; + } +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + +#if LWIP_IPV6 + /* If requested, based on the IPV6_CHECKSUM socket option per RFC3542, + compute the checksum and update the checksum in the payload. */ + if (IP_IS_V6(dst_ip) && pcb->chksum_reqd) { + u16_t chksum = ip6_chksum_pseudo(p, pcb->protocol, p->tot_len, ip_2_ip6(src_ip), ip_2_ip6(dst_ip)); + LWIP_ASSERT("Checksum must fit into first pbuf", p->len >= (pcb->chksum_offset + 2)); + SMEMCPY(((u8_t *)p->payload) + pcb->chksum_offset, &chksum, sizeof(u16_t)); + } +#endif + + /* Determine TTL to use */ +#if LWIP_MULTICAST_TX_OPTIONS + ttl = (ip_addr_ismulticast(dst_ip) ? raw_get_multicast_ttl(pcb) : pcb->ttl); +#else /* LWIP_MULTICAST_TX_OPTIONS */ + ttl = pcb->ttl; +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + + NETIF_SET_HINTS(netif, &pcb->netif_hints); + err = ip_output_if(q, src_ip, dst_ip, ttl, pcb->tos, pcb->protocol, netif); + NETIF_RESET_HINTS(netif); + + /* did we chain a header earlier? */ + if (q != p) { + /* free the header */ + pbuf_free(q); + } + return err; +} + +/** + * @ingroup raw_raw + * Send the raw IP packet to the address given by raw_connect() + * + * @param pcb the raw pcb which to send + * @param p the IP payload to send + * + */ +err_t +raw_send(struct raw_pcb *pcb, struct pbuf *p) +{ + return raw_sendto(pcb, p, &pcb->remote_ip); +} + +/** + * @ingroup raw_raw + * Remove an RAW PCB. + * + * @param pcb RAW PCB to be removed. The PCB is removed from the list of + * RAW PCB's and the data structure is freed from memory. + * + * @see raw_new() + */ +void +raw_remove(struct raw_pcb *pcb) +{ + struct raw_pcb *pcb2; + LWIP_ASSERT_CORE_LOCKED(); + /* pcb to be removed is first in list? */ + if (raw_pcbs == pcb) { + /* make list start at 2nd pcb */ + raw_pcbs = raw_pcbs->next; + /* pcb not 1st in list */ + } else { + for (pcb2 = raw_pcbs; pcb2 != NULL; pcb2 = pcb2->next) { + /* find pcb in raw_pcbs list */ + if (pcb2->next != NULL && pcb2->next == pcb) { + /* remove pcb from list */ + pcb2->next = pcb->next; + break; + } + } + } + memp_free(MEMP_RAW_PCB, pcb); +} + +/** + * @ingroup raw_raw + * Create a RAW PCB. + * + * @return The RAW PCB which was created. NULL if the PCB data structure + * could not be allocated. + * + * @param proto the protocol number of the IPs payload (e.g. IP_PROTO_ICMP) + * + * @see raw_remove() + */ +struct raw_pcb * +raw_new(u8_t proto) +{ + struct raw_pcb *pcb; + + LWIP_DEBUGF(RAW_DEBUG | LWIP_DBG_TRACE, ("raw_new\n")); + LWIP_ASSERT_CORE_LOCKED(); + + pcb = (struct raw_pcb *)memp_malloc(MEMP_RAW_PCB); + /* could allocate RAW PCB? */ + if (pcb != NULL) { + /* initialize PCB to all zeroes */ + memset(pcb, 0, sizeof(struct raw_pcb)); + pcb->protocol = proto; + pcb->ttl = RAW_TTL; +#if LWIP_MULTICAST_TX_OPTIONS + raw_set_multicast_ttl(pcb, RAW_TTL); +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + pcb->next = raw_pcbs; + raw_pcbs = pcb; + } + return pcb; +} + +/** + * @ingroup raw_raw + * Create a RAW PCB for specific IP type. + * + * @return The RAW PCB which was created. NULL if the PCB data structure + * could not be allocated. + * + * @param type IP address type, see @ref lwip_ip_addr_type definitions. + * If you want to listen to IPv4 and IPv6 (dual-stack) packets, + * supply @ref IPADDR_TYPE_ANY as argument and bind to @ref IP_ANY_TYPE. + * @param proto the protocol number (next header) of the IPv6 packet payload + * (e.g. IP6_NEXTH_ICMP6) + * + * @see raw_remove() + */ +struct raw_pcb * +raw_new_ip_type(u8_t type, u8_t proto) +{ + struct raw_pcb *pcb; + LWIP_ASSERT_CORE_LOCKED(); + pcb = raw_new(proto); +#if LWIP_IPV4 && LWIP_IPV6 + if (pcb != NULL) { + IP_SET_TYPE_VAL(pcb->local_ip, type); + IP_SET_TYPE_VAL(pcb->remote_ip, type); + } +#else /* LWIP_IPV4 && LWIP_IPV6 */ + LWIP_UNUSED_ARG(type); +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + return pcb; +} + +/** This function is called from netif.c when address is changed + * + * @param old_addr IP address of the netif before change + * @param new_addr IP address of the netif after change + */ +void raw_netif_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) +{ + struct raw_pcb *rpcb; + + if (!ip_addr_isany(old_addr) && !ip_addr_isany(new_addr)) { + for (rpcb = raw_pcbs; rpcb != NULL; rpcb = rpcb->next) { + /* PCB bound to current local interface address? */ + if (ip_addr_cmp(&rpcb->local_ip, old_addr)) { + /* The PCB is bound to the old ipaddr and + * is set to bound to the new one instead */ + ip_addr_copy(rpcb->local_ip, *new_addr); + } + } + } +} + +#endif /* LWIP_RAW */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/stats.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/stats.c index 4602842a..34e9b270 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/stats.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/stats.c @@ -1,169 +1,169 @@ -/** - * @file - * Statistics module - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_STATS /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/def.h" -#include "lwip/stats.h" -#include "lwip/mem.h" -#include "lwip/debug.h" - -#include - -struct stats_ lwip_stats; - -void -stats_init(void) -{ -#ifdef LWIP_DEBUG -#if MEM_STATS - lwip_stats.mem.name = "MEM"; -#endif /* MEM_STATS */ -#endif /* LWIP_DEBUG */ -} - -#if LWIP_STATS_DISPLAY -void -stats_display_proto(struct stats_proto *proto, const char *name) -{ - LWIP_PLATFORM_DIAG(("\n%s\n\t", name)); - LWIP_PLATFORM_DIAG(("xmit: %"STAT_COUNTER_F"\n\t", proto->xmit)); - LWIP_PLATFORM_DIAG(("recv: %"STAT_COUNTER_F"\n\t", proto->recv)); - LWIP_PLATFORM_DIAG(("fw: %"STAT_COUNTER_F"\n\t", proto->fw)); - LWIP_PLATFORM_DIAG(("drop: %"STAT_COUNTER_F"\n\t", proto->drop)); - LWIP_PLATFORM_DIAG(("chkerr: %"STAT_COUNTER_F"\n\t", proto->chkerr)); - LWIP_PLATFORM_DIAG(("lenerr: %"STAT_COUNTER_F"\n\t", proto->lenerr)); - LWIP_PLATFORM_DIAG(("memerr: %"STAT_COUNTER_F"\n\t", proto->memerr)); - LWIP_PLATFORM_DIAG(("rterr: %"STAT_COUNTER_F"\n\t", proto->rterr)); - LWIP_PLATFORM_DIAG(("proterr: %"STAT_COUNTER_F"\n\t", proto->proterr)); - LWIP_PLATFORM_DIAG(("opterr: %"STAT_COUNTER_F"\n\t", proto->opterr)); - LWIP_PLATFORM_DIAG(("err: %"STAT_COUNTER_F"\n\t", proto->err)); - LWIP_PLATFORM_DIAG(("cachehit: %"STAT_COUNTER_F"\n", proto->cachehit)); -} - -#if IGMP_STATS || MLD6_STATS -void -stats_display_igmp(struct stats_igmp *igmp, const char *name) -{ - LWIP_PLATFORM_DIAG(("\n%s\n\t", name)); - LWIP_PLATFORM_DIAG(("xmit: %"STAT_COUNTER_F"\n\t", igmp->xmit)); - LWIP_PLATFORM_DIAG(("recv: %"STAT_COUNTER_F"\n\t", igmp->recv)); - LWIP_PLATFORM_DIAG(("drop: %"STAT_COUNTER_F"\n\t", igmp->drop)); - LWIP_PLATFORM_DIAG(("chkerr: %"STAT_COUNTER_F"\n\t", igmp->chkerr)); - LWIP_PLATFORM_DIAG(("lenerr: %"STAT_COUNTER_F"\n\t", igmp->lenerr)); - LWIP_PLATFORM_DIAG(("memerr: %"STAT_COUNTER_F"\n\t", igmp->memerr)); - LWIP_PLATFORM_DIAG(("proterr: %"STAT_COUNTER_F"\n\t", igmp->proterr)); - LWIP_PLATFORM_DIAG(("rx_v1: %"STAT_COUNTER_F"\n\t", igmp->rx_v1)); - LWIP_PLATFORM_DIAG(("rx_group: %"STAT_COUNTER_F"\n\t", igmp->rx_group)); - LWIP_PLATFORM_DIAG(("rx_general: %"STAT_COUNTER_F"\n\t", igmp->rx_general)); - LWIP_PLATFORM_DIAG(("rx_report: %"STAT_COUNTER_F"\n\t", igmp->rx_report)); - LWIP_PLATFORM_DIAG(("tx_join: %"STAT_COUNTER_F"\n\t", igmp->tx_join)); - LWIP_PLATFORM_DIAG(("tx_leave: %"STAT_COUNTER_F"\n\t", igmp->tx_leave)); - LWIP_PLATFORM_DIAG(("tx_report: %"STAT_COUNTER_F"\n", igmp->tx_report)); -} -#endif /* IGMP_STATS || MLD6_STATS */ - -#if MEM_STATS || MEMP_STATS -void -stats_display_mem(struct stats_mem *mem, const char *name) -{ - LWIP_PLATFORM_DIAG(("\nMEM %s\n\t", name)); - LWIP_PLATFORM_DIAG(("avail: %"MEM_SIZE_F"\n\t", mem->avail)); - LWIP_PLATFORM_DIAG(("used: %"MEM_SIZE_F"\n\t", mem->used)); - LWIP_PLATFORM_DIAG(("max: %"MEM_SIZE_F"\n\t", mem->max)); - LWIP_PLATFORM_DIAG(("err: %"STAT_COUNTER_F"\n", mem->err)); -} - -#if MEMP_STATS -void -stats_display_memp(struct stats_mem *mem, int idx) -{ - if (idx < MEMP_MAX) { - stats_display_mem(mem, mem->name); - } -} -#endif /* MEMP_STATS */ -#endif /* MEM_STATS || MEMP_STATS */ - -#if SYS_STATS -void -stats_display_sys(struct stats_sys *sys) -{ - LWIP_PLATFORM_DIAG(("\nSYS\n\t")); - LWIP_PLATFORM_DIAG(("sem.used: %"STAT_COUNTER_F"\n\t", sys->sem.used)); - LWIP_PLATFORM_DIAG(("sem.max: %"STAT_COUNTER_F"\n\t", sys->sem.max)); - LWIP_PLATFORM_DIAG(("sem.err: %"STAT_COUNTER_F"\n\t", sys->sem.err)); - LWIP_PLATFORM_DIAG(("mutex.used: %"STAT_COUNTER_F"\n\t", sys->mutex.used)); - LWIP_PLATFORM_DIAG(("mutex.max: %"STAT_COUNTER_F"\n\t", sys->mutex.max)); - LWIP_PLATFORM_DIAG(("mutex.err: %"STAT_COUNTER_F"\n\t", sys->mutex.err)); - LWIP_PLATFORM_DIAG(("mbox.used: %"STAT_COUNTER_F"\n\t", sys->mbox.used)); - LWIP_PLATFORM_DIAG(("mbox.max: %"STAT_COUNTER_F"\n\t", sys->mbox.max)); - LWIP_PLATFORM_DIAG(("mbox.err: %"STAT_COUNTER_F"\n", sys->mbox.err)); -} -#endif /* SYS_STATS */ - -void -stats_display(void) -{ - s16_t i; - - LINK_STATS_DISPLAY(); - ETHARP_STATS_DISPLAY(); - IPFRAG_STATS_DISPLAY(); - IP6_FRAG_STATS_DISPLAY(); - IP_STATS_DISPLAY(); - ND6_STATS_DISPLAY(); - IP6_STATS_DISPLAY(); - IGMP_STATS_DISPLAY(); - MLD6_STATS_DISPLAY(); - ICMP_STATS_DISPLAY(); - ICMP6_STATS_DISPLAY(); - UDP_STATS_DISPLAY(); - TCP_STATS_DISPLAY(); - MEM_STATS_DISPLAY(); - for (i = 0; i < MEMP_MAX; i++) { - MEMP_STATS_DISPLAY(i); - } - SYS_STATS_DISPLAY(); -} -#endif /* LWIP_STATS_DISPLAY */ - -#endif /* LWIP_STATS */ - +/** + * @file + * Statistics module + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_STATS /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/def.h" +#include "lwip/stats.h" +#include "lwip/mem.h" +#include "lwip/debug.h" + +#include + +struct stats_ lwip_stats; + +void +stats_init(void) +{ +#ifdef LWIP_DEBUG +#if MEM_STATS + lwip_stats.mem.name = "MEM"; +#endif /* MEM_STATS */ +#endif /* LWIP_DEBUG */ +} + +#if LWIP_STATS_DISPLAY +void +stats_display_proto(struct stats_proto *proto, const char *name) +{ + LWIP_PLATFORM_DIAG(("\n%s\n\t", name)); + LWIP_PLATFORM_DIAG(("xmit: %"STAT_COUNTER_F"\n\t", proto->xmit)); + LWIP_PLATFORM_DIAG(("recv: %"STAT_COUNTER_F"\n\t", proto->recv)); + LWIP_PLATFORM_DIAG(("fw: %"STAT_COUNTER_F"\n\t", proto->fw)); + LWIP_PLATFORM_DIAG(("drop: %"STAT_COUNTER_F"\n\t", proto->drop)); + LWIP_PLATFORM_DIAG(("chkerr: %"STAT_COUNTER_F"\n\t", proto->chkerr)); + LWIP_PLATFORM_DIAG(("lenerr: %"STAT_COUNTER_F"\n\t", proto->lenerr)); + LWIP_PLATFORM_DIAG(("memerr: %"STAT_COUNTER_F"\n\t", proto->memerr)); + LWIP_PLATFORM_DIAG(("rterr: %"STAT_COUNTER_F"\n\t", proto->rterr)); + LWIP_PLATFORM_DIAG(("proterr: %"STAT_COUNTER_F"\n\t", proto->proterr)); + LWIP_PLATFORM_DIAG(("opterr: %"STAT_COUNTER_F"\n\t", proto->opterr)); + LWIP_PLATFORM_DIAG(("err: %"STAT_COUNTER_F"\n\t", proto->err)); + LWIP_PLATFORM_DIAG(("cachehit: %"STAT_COUNTER_F"\n", proto->cachehit)); +} + +#if IGMP_STATS || MLD6_STATS +void +stats_display_igmp(struct stats_igmp *igmp, const char *name) +{ + LWIP_PLATFORM_DIAG(("\n%s\n\t", name)); + LWIP_PLATFORM_DIAG(("xmit: %"STAT_COUNTER_F"\n\t", igmp->xmit)); + LWIP_PLATFORM_DIAG(("recv: %"STAT_COUNTER_F"\n\t", igmp->recv)); + LWIP_PLATFORM_DIAG(("drop: %"STAT_COUNTER_F"\n\t", igmp->drop)); + LWIP_PLATFORM_DIAG(("chkerr: %"STAT_COUNTER_F"\n\t", igmp->chkerr)); + LWIP_PLATFORM_DIAG(("lenerr: %"STAT_COUNTER_F"\n\t", igmp->lenerr)); + LWIP_PLATFORM_DIAG(("memerr: %"STAT_COUNTER_F"\n\t", igmp->memerr)); + LWIP_PLATFORM_DIAG(("proterr: %"STAT_COUNTER_F"\n\t", igmp->proterr)); + LWIP_PLATFORM_DIAG(("rx_v1: %"STAT_COUNTER_F"\n\t", igmp->rx_v1)); + LWIP_PLATFORM_DIAG(("rx_group: %"STAT_COUNTER_F"\n\t", igmp->rx_group)); + LWIP_PLATFORM_DIAG(("rx_general: %"STAT_COUNTER_F"\n\t", igmp->rx_general)); + LWIP_PLATFORM_DIAG(("rx_report: %"STAT_COUNTER_F"\n\t", igmp->rx_report)); + LWIP_PLATFORM_DIAG(("tx_join: %"STAT_COUNTER_F"\n\t", igmp->tx_join)); + LWIP_PLATFORM_DIAG(("tx_leave: %"STAT_COUNTER_F"\n\t", igmp->tx_leave)); + LWIP_PLATFORM_DIAG(("tx_report: %"STAT_COUNTER_F"\n", igmp->tx_report)); +} +#endif /* IGMP_STATS || MLD6_STATS */ + +#if MEM_STATS || MEMP_STATS +void +stats_display_mem(struct stats_mem *mem, const char *name) +{ + LWIP_PLATFORM_DIAG(("\nMEM %s\n\t", name)); + LWIP_PLATFORM_DIAG(("avail: %"MEM_SIZE_F"\n\t", mem->avail)); + LWIP_PLATFORM_DIAG(("used: %"MEM_SIZE_F"\n\t", mem->used)); + LWIP_PLATFORM_DIAG(("max: %"MEM_SIZE_F"\n\t", mem->max)); + LWIP_PLATFORM_DIAG(("err: %"STAT_COUNTER_F"\n", mem->err)); +} + +#if MEMP_STATS +void +stats_display_memp(struct stats_mem *mem, int idx) +{ + if (idx < MEMP_MAX) { + stats_display_mem(mem, mem->name); + } +} +#endif /* MEMP_STATS */ +#endif /* MEM_STATS || MEMP_STATS */ + +#if SYS_STATS +void +stats_display_sys(struct stats_sys *sys) +{ + LWIP_PLATFORM_DIAG(("\nSYS\n\t")); + LWIP_PLATFORM_DIAG(("sem.used: %"STAT_COUNTER_F"\n\t", sys->sem.used)); + LWIP_PLATFORM_DIAG(("sem.max: %"STAT_COUNTER_F"\n\t", sys->sem.max)); + LWIP_PLATFORM_DIAG(("sem.err: %"STAT_COUNTER_F"\n\t", sys->sem.err)); + LWIP_PLATFORM_DIAG(("mutex.used: %"STAT_COUNTER_F"\n\t", sys->mutex.used)); + LWIP_PLATFORM_DIAG(("mutex.max: %"STAT_COUNTER_F"\n\t", sys->mutex.max)); + LWIP_PLATFORM_DIAG(("mutex.err: %"STAT_COUNTER_F"\n\t", sys->mutex.err)); + LWIP_PLATFORM_DIAG(("mbox.used: %"STAT_COUNTER_F"\n\t", sys->mbox.used)); + LWIP_PLATFORM_DIAG(("mbox.max: %"STAT_COUNTER_F"\n\t", sys->mbox.max)); + LWIP_PLATFORM_DIAG(("mbox.err: %"STAT_COUNTER_F"\n", sys->mbox.err)); +} +#endif /* SYS_STATS */ + +void +stats_display(void) +{ + s16_t i; + + LINK_STATS_DISPLAY(); + ETHARP_STATS_DISPLAY(); + IPFRAG_STATS_DISPLAY(); + IP6_FRAG_STATS_DISPLAY(); + IP_STATS_DISPLAY(); + ND6_STATS_DISPLAY(); + IP6_STATS_DISPLAY(); + IGMP_STATS_DISPLAY(); + MLD6_STATS_DISPLAY(); + ICMP_STATS_DISPLAY(); + ICMP6_STATS_DISPLAY(); + UDP_STATS_DISPLAY(); + TCP_STATS_DISPLAY(); + MEM_STATS_DISPLAY(); + for (i = 0; i < MEMP_MAX; i++) { + MEMP_STATS_DISPLAY(i); + } + SYS_STATS_DISPLAY(); +} +#endif /* LWIP_STATS_DISPLAY */ + +#endif /* LWIP_STATS */ + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/sys.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/sys.c index b95f4bd6..5f08352b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/sys.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/sys.c @@ -1,148 +1,148 @@ -/** - * @file - * lwIP Operating System abstraction - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -/** - * @defgroup sys_layer Porting (system abstraction layer) - * @ingroup lwip - * - * @defgroup sys_os OS abstraction layer - * @ingroup sys_layer - * No need to implement functions in this section in NO_SYS mode. - * The OS-specific code should be implemented in arch/sys_arch.h - * and sys_arch.c of your port. - * - * The operating system emulation layer provides a common interface - * between the lwIP code and the underlying operating system kernel. The - * general idea is that porting lwIP to new architectures requires only - * small changes to a few header files and a new sys_arch - * implementation. It is also possible to do a sys_arch implementation - * that does not rely on any underlying operating system. - * - * The sys_arch provides semaphores, mailboxes and mutexes to lwIP. For the full - * lwIP functionality, multiple threads support can be implemented in the - * sys_arch, but this is not required for the basic lwIP - * functionality. Timer scheduling is implemented in lwIP, but can be implemented - * by the sys_arch port (LWIP_TIMERS_CUSTOM==1). - * - * In addition to the source file providing the functionality of sys_arch, - * the OS emulation layer must provide several header files defining - * macros used throughout lwip. The files required and the macros they - * must define are listed below the sys_arch description. - * - * Since lwIP 1.4.0, semaphore, mutexes and mailbox functions are prototyped in a way that - * allows both using pointers or actual OS structures to be used. This way, memory - * required for such types can be either allocated in place (globally or on the - * stack) or on the heap (allocated internally in the "*_new()" functions). - * - * Note: - * ----- - * Be careful with using mem_malloc() in sys_arch. When malloc() refers to - * mem_malloc() you can run into a circular function call problem. In mem.c - * mem_init() tries to allocate a semaphore using mem_malloc, which of course - * can't be performed when sys_arch uses mem_malloc. - * - * @defgroup sys_sem Semaphores - * @ingroup sys_os - * Semaphores can be either counting or binary - lwIP works with both - * kinds. - * Semaphores are represented by the type "sys_sem_t" which is typedef'd - * in the sys_arch.h file. Mailboxes are equivalently represented by the - * type "sys_mbox_t". Mutexes are represented by the type "sys_mutex_t". - * lwIP does not place any restrictions on how these types are represented - * internally. - * - * @defgroup sys_mutex Mutexes - * @ingroup sys_os - * Mutexes are recommended to correctly handle priority inversion, - * especially if you use LWIP_CORE_LOCKING . - * - * @defgroup sys_mbox Mailboxes - * @ingroup sys_os - * Mailboxes should be implemented as a queue which allows multiple messages - * to be posted (implementing as a rendez-vous point where only one message can be - * posted at a time can have a highly negative impact on performance). A message - * in a mailbox is just a pointer, nothing more. - * - * @defgroup sys_time Time - * @ingroup sys_layer - * - * @defgroup sys_prot Critical sections - * @ingroup sys_layer - * Used to protect short regions of code against concurrent access. - * - Your system is a bare-metal system (probably with an RTOS) - * and interrupts are under your control: - * Implement this as LockInterrupts() / UnlockInterrupts() - * - Your system uses an RTOS with deferred interrupt handling from a - * worker thread: Implement as a global mutex or lock/unlock scheduler - * - Your system uses a high-level OS with e.g. POSIX signals: - * Implement as a global mutex - * - * @defgroup sys_misc Misc - * @ingroup sys_os - */ - -#include "lwip/opt.h" - -#include "lwip/sys.h" - -/* Most of the functions defined in sys.h must be implemented in the - * architecture-dependent file sys_arch.c */ - -#if !NO_SYS - -#ifndef sys_msleep -/** - * Sleep for some ms. Timeouts are NOT processed while sleeping. - * - * @param ms number of milliseconds to sleep - */ -void -sys_msleep(u32_t ms) -{ - if (ms > 0) { - sys_sem_t delaysem; - err_t err = sys_sem_new(&delaysem, 0); - if (err == ERR_OK) { - sys_arch_sem_wait(&delaysem, ms); - sys_sem_free(&delaysem); - } - } -} -#endif /* sys_msleep */ - -#endif /* !NO_SYS */ +/** + * @file + * lwIP Operating System abstraction + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/** + * @defgroup sys_layer Porting (system abstraction layer) + * @ingroup lwip + * + * @defgroup sys_os OS abstraction layer + * @ingroup sys_layer + * No need to implement functions in this section in NO_SYS mode. + * The OS-specific code should be implemented in arch/sys_arch.h + * and sys_arch.c of your port. + * + * The operating system emulation layer provides a common interface + * between the lwIP code and the underlying operating system kernel. The + * general idea is that porting lwIP to new architectures requires only + * small changes to a few header files and a new sys_arch + * implementation. It is also possible to do a sys_arch implementation + * that does not rely on any underlying operating system. + * + * The sys_arch provides semaphores, mailboxes and mutexes to lwIP. For the full + * lwIP functionality, multiple threads support can be implemented in the + * sys_arch, but this is not required for the basic lwIP + * functionality. Timer scheduling is implemented in lwIP, but can be implemented + * by the sys_arch port (LWIP_TIMERS_CUSTOM==1). + * + * In addition to the source file providing the functionality of sys_arch, + * the OS emulation layer must provide several header files defining + * macros used throughout lwip. The files required and the macros they + * must define are listed below the sys_arch description. + * + * Since lwIP 1.4.0, semaphore, mutexes and mailbox functions are prototyped in a way that + * allows both using pointers or actual OS structures to be used. This way, memory + * required for such types can be either allocated in place (globally or on the + * stack) or on the heap (allocated internally in the "*_new()" functions). + * + * Note: + * ----- + * Be careful with using mem_malloc() in sys_arch. When malloc() refers to + * mem_malloc() you can run into a circular function call problem. In mem.c + * mem_init() tries to allocate a semaphore using mem_malloc, which of course + * can't be performed when sys_arch uses mem_malloc. + * + * @defgroup sys_sem Semaphores + * @ingroup sys_os + * Semaphores can be either counting or binary - lwIP works with both + * kinds. + * Semaphores are represented by the type "sys_sem_t" which is typedef'd + * in the sys_arch.h file. Mailboxes are equivalently represented by the + * type "sys_mbox_t". Mutexes are represented by the type "sys_mutex_t". + * lwIP does not place any restrictions on how these types are represented + * internally. + * + * @defgroup sys_mutex Mutexes + * @ingroup sys_os + * Mutexes are recommended to correctly handle priority inversion, + * especially if you use LWIP_CORE_LOCKING . + * + * @defgroup sys_mbox Mailboxes + * @ingroup sys_os + * Mailboxes should be implemented as a queue which allows multiple messages + * to be posted (implementing as a rendez-vous point where only one message can be + * posted at a time can have a highly negative impact on performance). A message + * in a mailbox is just a pointer, nothing more. + * + * @defgroup sys_time Time + * @ingroup sys_layer + * + * @defgroup sys_prot Critical sections + * @ingroup sys_layer + * Used to protect short regions of code against concurrent access. + * - Your system is a bare-metal system (probably with an RTOS) + * and interrupts are under your control: + * Implement this as LockInterrupts() / UnlockInterrupts() + * - Your system uses an RTOS with deferred interrupt handling from a + * worker thread: Implement as a global mutex or lock/unlock scheduler + * - Your system uses a high-level OS with e.g. POSIX signals: + * Implement as a global mutex + * + * @defgroup sys_misc Misc + * @ingroup sys_os + */ + +#include "lwip/opt.h" + +#include "lwip/sys.h" + +/* Most of the functions defined in sys.h must be implemented in the + * architecture-dependent file sys_arch.c */ + +#if !NO_SYS + +#ifndef sys_msleep +/** + * Sleep for some ms. Timeouts are NOT processed while sleeping. + * + * @param ms number of milliseconds to sleep + */ +void +sys_msleep(u32_t ms) +{ + if (ms > 0) { + sys_sem_t delaysem; + err_t err = sys_sem_new(&delaysem, 0); + if (err == ERR_OK) { + sys_arch_sem_wait(&delaysem, ms); + sys_sem_free(&delaysem); + } + } +} +#endif /* sys_msleep */ + +#endif /* !NO_SYS */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp.c index 2ff37ef3..bd7d64ec 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp.c @@ -1,2686 +1,2686 @@ -/** - * @file - * Transmission Control Protocol for IP - * See also @ref tcp_raw - * - * @defgroup tcp_raw TCP - * @ingroup callbackstyle_api - * Transmission Control Protocol for IP\n - * @see @ref api - * - * Common functions for the TCP implementation, such as functions - * for manipulating the data structures and the TCP timer functions. TCP functions - * related to input and output is found in tcp_in.c and tcp_out.c respectively.\n - * - * TCP connection setup - * -------------------- - * The functions used for setting up connections is similar to that of - * the sequential API and of the BSD socket API. A new TCP connection - * identifier (i.e., a protocol control block - PCB) is created with the - * tcp_new() function. This PCB can then be either set to listen for new - * incoming connections or be explicitly connected to another host. - * - tcp_new() - * - tcp_bind() - * - tcp_listen() and tcp_listen_with_backlog() - * - tcp_accept() - * - tcp_connect() - * - * Sending TCP data - * ---------------- - * TCP data is sent by enqueueing the data with a call to tcp_write() and - * triggering to send by calling tcp_output(). When the data is successfully - * transmitted to the remote host, the application will be notified with a - * call to a specified callback function. - * - tcp_write() - * - tcp_output() - * - tcp_sent() - * - * Receiving TCP data - * ------------------ - * TCP data reception is callback based - an application specified - * callback function is called when new data arrives. When the - * application has taken the data, it has to call the tcp_recved() - * function to indicate that TCP can advertise increase the receive - * window. - * - tcp_recv() - * - tcp_recved() - * - * Application polling - * ------------------- - * When a connection is idle (i.e., no data is either transmitted or - * received), lwIP will repeatedly poll the application by calling a - * specified callback function. This can be used either as a watchdog - * timer for killing connections that have stayed idle for too long, or - * as a method of waiting for memory to become available. For instance, - * if a call to tcp_write() has failed because memory wasn't available, - * the application may use the polling functionality to call tcp_write() - * again when the connection has been idle for a while. - * - tcp_poll() - * - * Closing and aborting connections - * -------------------------------- - * - tcp_close() - * - tcp_abort() - * - tcp_err() - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/def.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/tcp.h" -#include "lwip/priv/tcp_priv.h" -#include "lwip/debug.h" -#include "lwip/stats.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/nd6.h" - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -#ifndef TCP_LOCAL_PORT_RANGE_START -/* From http://www.iana.org/assignments/port-numbers: - "The Dynamic and/or Private Ports are those from 49152 through 65535" */ -#define TCP_LOCAL_PORT_RANGE_START 0xc000 -#define TCP_LOCAL_PORT_RANGE_END 0xffff -#define TCP_ENSURE_LOCAL_PORT_RANGE(port) ((u16_t)(((port) & (u16_t)~TCP_LOCAL_PORT_RANGE_START) + TCP_LOCAL_PORT_RANGE_START)) -#endif - -#if LWIP_TCP_KEEPALIVE -#define TCP_KEEP_DUR(pcb) ((pcb)->keep_cnt * (pcb)->keep_intvl) -#define TCP_KEEP_INTVL(pcb) ((pcb)->keep_intvl) -#else /* LWIP_TCP_KEEPALIVE */ -#define TCP_KEEP_DUR(pcb) TCP_MAXIDLE -#define TCP_KEEP_INTVL(pcb) TCP_KEEPINTVL_DEFAULT -#endif /* LWIP_TCP_KEEPALIVE */ - -/* As initial send MSS, we use TCP_MSS but limit it to 536. */ -#if TCP_MSS > 536 -#define INITIAL_MSS 536 -#else -#define INITIAL_MSS TCP_MSS -#endif - -static 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" -}; - -/* last local TCP port */ -static u16_t tcp_port = TCP_LOCAL_PORT_RANGE_START; - -/* Incremented every coarse grained timer shot (typically every 500 ms). */ -u32_t tcp_ticks; -static const u8_t tcp_backoff[13] = -{ 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7}; -/* Times per slowtmr hits */ -static const u8_t tcp_persist_backoff[7] = { 3, 6, 12, 24, 48, 96, 120 }; - -/* The TCP PCB lists. */ - -/** List of all TCP PCBs bound but not yet (connected || listening) */ -struct tcp_pcb *tcp_bound_pcbs; -/** List of all TCP PCBs in LISTEN state */ -union tcp_listen_pcbs_t tcp_listen_pcbs; -/** List of all TCP PCBs that are in a state in which - * they accept or send data. */ -struct tcp_pcb *tcp_active_pcbs; -/** List of all TCP PCBs in TIME-WAIT state */ -struct tcp_pcb *tcp_tw_pcbs; - -/** An array with all (non-temporary) PCB lists, mainly used for smaller code size */ -struct tcp_pcb **const tcp_pcb_lists[] = {&tcp_listen_pcbs.pcbs, &tcp_bound_pcbs, - &tcp_active_pcbs, &tcp_tw_pcbs -}; - -u8_t tcp_active_pcbs_changed; - -/** Timer counter to handle calling slow-timer from tcp_tmr() */ -static u8_t tcp_timer; -static u8_t tcp_timer_ctr; -static u16_t tcp_new_port(void); - -static err_t tcp_close_shutdown_fin(struct tcp_pcb *pcb); -#if LWIP_TCP_PCB_NUM_EXT_ARGS -static void tcp_ext_arg_invoke_callbacks_destroyed(struct tcp_pcb_ext_args *ext_args); -#endif - -/** - * Initialize this module. - */ -void -tcp_init(void) -{ -#ifdef LWIP_RAND - tcp_port = TCP_ENSURE_LOCAL_PORT_RANGE(LWIP_RAND()); -#endif /* LWIP_RAND */ -} - -/** Free a tcp pcb */ -void -tcp_free(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_free: LISTEN", pcb->state != LISTEN); -#if LWIP_TCP_PCB_NUM_EXT_ARGS - tcp_ext_arg_invoke_callbacks_destroyed(pcb->ext_args); -#endif - memp_free(MEMP_TCP_PCB, pcb); -} - -/** Free a tcp listen pcb */ -static void -tcp_free_listen(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_free_listen: !LISTEN", pcb->state != LISTEN); -#if LWIP_TCP_PCB_NUM_EXT_ARGS - tcp_ext_arg_invoke_callbacks_destroyed(pcb->ext_args); -#endif - memp_free(MEMP_TCP_PCB_LISTEN, pcb); -} - -/** - * Called periodically to dispatch TCP timers. - */ -void -tcp_tmr(void) -{ - /* Call tcp_fasttmr() every 250 ms */ - tcp_fasttmr(); - - if (++tcp_timer & 1) { - /* Call tcp_slowtmr() every 500 ms, i.e., every other timer - tcp_tmr() is called. */ - tcp_slowtmr(); - } -} - -#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG -/** Called when a listen pcb is closed. Iterates one pcb list and removes the - * closed listener pcb from pcb->listener if matching. - */ -static void -tcp_remove_listener(struct tcp_pcb *list, struct tcp_pcb_listen *lpcb) -{ - struct tcp_pcb *pcb; - - LWIP_ASSERT("tcp_remove_listener: invalid listener", lpcb != NULL); - - for (pcb = list; pcb != NULL; pcb = pcb->next) { - if (pcb->listener == lpcb) { - pcb->listener = NULL; - } - } -} -#endif - -/** Called when a listen pcb is closed. Iterates all pcb lists and removes the - * closed listener pcb from pcb->listener if matching. - */ -static void -tcp_listen_closed(struct tcp_pcb *pcb) -{ -#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG - size_t i; - LWIP_ASSERT("pcb != NULL", pcb != NULL); - LWIP_ASSERT("pcb->state == LISTEN", pcb->state == LISTEN); - for (i = 1; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) { - tcp_remove_listener(*tcp_pcb_lists[i], (struct tcp_pcb_listen *)pcb); - } -#endif - LWIP_UNUSED_ARG(pcb); -} - -#if TCP_LISTEN_BACKLOG -/** @ingroup tcp_raw - * Delay accepting a connection in respect to the listen backlog: - * the number of outstanding connections is increased until - * tcp_backlog_accepted() is called. - * - * ATTENTION: the caller is responsible for calling tcp_backlog_accepted() - * or else the backlog feature will get out of sync! - * - * @param pcb the connection pcb which is not fully accepted yet - */ -void -tcp_backlog_delayed(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("pcb != NULL", pcb != NULL); - LWIP_ASSERT_CORE_LOCKED(); - if ((pcb->flags & TF_BACKLOGPEND) == 0) { - if (pcb->listener != NULL) { - pcb->listener->accepts_pending++; - LWIP_ASSERT("accepts_pending != 0", pcb->listener->accepts_pending != 0); - tcp_set_flags(pcb, TF_BACKLOGPEND); - } - } -} - -/** @ingroup tcp_raw - * A delayed-accept a connection is accepted (or closed/aborted): decreases - * the number of outstanding connections after calling tcp_backlog_delayed(). - * - * ATTENTION: the caller is responsible for calling tcp_backlog_accepted() - * or else the backlog feature will get out of sync! - * - * @param pcb the connection pcb which is now fully accepted (or closed/aborted) - */ -void -tcp_backlog_accepted(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("pcb != NULL", pcb != NULL); - LWIP_ASSERT_CORE_LOCKED(); - if ((pcb->flags & TF_BACKLOGPEND) != 0) { - if (pcb->listener != NULL) { - LWIP_ASSERT("accepts_pending != 0", pcb->listener->accepts_pending != 0); - pcb->listener->accepts_pending--; - tcp_clear_flags(pcb, TF_BACKLOGPEND); - } - } -} -#endif /* TCP_LISTEN_BACKLOG */ - -/** - * Closes the TX side of a connection held by the PCB. - * For tcp_close(), a RST is sent if the application didn't receive all data - * (tcp_recved() not called for all data passed to recv callback). - * - * Listening pcbs are freed and may not be referenced any more. - * Connection pcbs are freed if not yet connected and may not be referenced - * any more. If a connection is established (at least SYN received or in - * a closing state), the connection is closed, and put in a closing state. - * The pcb is then automatically freed in tcp_slowtmr(). It is therefore - * unsafe to reference it. - * - * @param pcb the tcp_pcb to close - * @return ERR_OK if connection has been closed - * another err_t if closing failed and pcb is not freed - */ -static err_t -tcp_close_shutdown(struct tcp_pcb *pcb, u8_t rst_on_unacked_data) -{ - LWIP_ASSERT("tcp_close_shutdown: invalid pcb", pcb != NULL); - - if (rst_on_unacked_data && ((pcb->state == ESTABLISHED) || (pcb->state == CLOSE_WAIT))) { - if ((pcb->refused_data != NULL) || (pcb->rcv_wnd != TCP_WND_MAX(pcb))) { - /* Not all data received by application, send RST to tell the remote - side about this. */ - LWIP_ASSERT("pcb->flags & TF_RXCLOSED", pcb->flags & TF_RXCLOSED); - - /* don't call tcp_abort here: we must not deallocate the pcb since - that might not be expected when calling tcp_close */ - tcp_rst(pcb, pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip, - pcb->local_port, pcb->remote_port); - - tcp_pcb_purge(pcb); - TCP_RMV_ACTIVE(pcb); - /* Deallocate the pcb since we already sent a RST for it */ - if (tcp_input_pcb == pcb) { - /* prevent using a deallocated pcb: free it from tcp_input later */ - tcp_trigger_input_pcb_close(); - } else { - tcp_free(pcb); - } - return ERR_OK; - } - } - - /* - states which free the pcb are handled here, - - states which send FIN and change state are handled in tcp_close_shutdown_fin() */ - switch (pcb->state) { - case CLOSED: - /* Closing a pcb in the CLOSED state might seem erroneous, - * however, it is in this state once allocated and as yet unused - * and the user needs some way to free it should the need arise. - * Calling tcp_close() with a pcb that has already been closed, (i.e. twice) - * or for a pcb that has been used and then entered the CLOSED state - * is erroneous, but this should never happen as the pcb has in those cases - * been freed, and so any remaining handles are bogus. */ - if (pcb->local_port != 0) { - TCP_RMV(&tcp_bound_pcbs, pcb); - } - tcp_free(pcb); - break; - case LISTEN: - tcp_listen_closed(pcb); - tcp_pcb_remove(&tcp_listen_pcbs.pcbs, pcb); - tcp_free_listen(pcb); - break; - case SYN_SENT: - TCP_PCB_REMOVE_ACTIVE(pcb); - tcp_free(pcb); - MIB2_STATS_INC(mib2.tcpattemptfails); - break; - default: - return tcp_close_shutdown_fin(pcb); - } - return ERR_OK; -} - -static err_t -tcp_close_shutdown_fin(struct tcp_pcb *pcb) -{ - err_t err; - LWIP_ASSERT("pcb != NULL", pcb != NULL); - - switch (pcb->state) { - case SYN_RCVD: - err = tcp_send_fin(pcb); - if (err == ERR_OK) { - tcp_backlog_accepted(pcb); - MIB2_STATS_INC(mib2.tcpattemptfails); - pcb->state = FIN_WAIT_1; - } - break; - case ESTABLISHED: - err = tcp_send_fin(pcb); - if (err == ERR_OK) { - MIB2_STATS_INC(mib2.tcpestabresets); - pcb->state = FIN_WAIT_1; - } - break; - case CLOSE_WAIT: - err = tcp_send_fin(pcb); - if (err == ERR_OK) { - MIB2_STATS_INC(mib2.tcpestabresets); - pcb->state = LAST_ACK; - } - break; - default: - /* Has already been closed, do nothing. */ - return ERR_OK; - } - - if (err == ERR_OK) { - /* To ensure all data has been sent when tcp_close returns, we have - to make sure tcp_output doesn't fail. - Since we don't really have to ensure all data has been sent when tcp_close - returns (unsent data is sent from tcp timer functions, also), we don't care - for the return value of tcp_output for now. */ - tcp_output(pcb); - } else if (err == ERR_MEM) { - /* Mark this pcb for closing. Closing is retried from tcp_tmr. */ - tcp_set_flags(pcb, TF_CLOSEPEND); - /* We have to return ERR_OK from here to indicate to the callers that this - pcb should not be used any more as it will be freed soon via tcp_tmr. - This is OK here since sending FIN does not guarantee a time frime for - actually freeing the pcb, either (it is left in closure states for - remote ACK or timeout) */ - return ERR_OK; - } - return err; -} - -/** - * @ingroup tcp_raw - * Closes the connection held by the PCB. - * - * Listening pcbs are freed and may not be referenced any more. - * Connection pcbs are freed if not yet connected and may not be referenced - * any more. If a connection is established (at least SYN received or in - * a closing state), the connection is closed, and put in a closing state. - * The pcb is then automatically freed in tcp_slowtmr(). It is therefore - * unsafe to reference it (unless an error is returned). - * - * The function may return ERR_MEM if no memory - * was available for closing the connection. If so, the application - * should wait and try again either by using the acknowledgment - * callback or the polling functionality. If the close succeeds, the - * function returns ERR_OK. - * - * @param pcb the tcp_pcb to close - * @return ERR_OK if connection has been closed - * another err_t if closing failed and pcb is not freed - */ -err_t -tcp_close(struct tcp_pcb *pcb) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_close: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in ")); - - tcp_debug_print_state(pcb->state); - - if (pcb->state != LISTEN) { - /* Set a flag not to receive any more data... */ - tcp_set_flags(pcb, TF_RXCLOSED); - } - /* ... and close */ - return tcp_close_shutdown(pcb, 1); -} - -/** - * @ingroup tcp_raw - * Causes all or part of a full-duplex connection of this PCB to be shut down. - * This doesn't deallocate the PCB unless shutting down both sides! - * Shutting down both sides is the same as calling tcp_close, so if it succeds - * (i.e. returns ER_OK), the PCB must not be referenced any more! - * - * @param pcb PCB to shutdown - * @param shut_rx shut down receive side if this is != 0 - * @param shut_tx shut down send side if this is != 0 - * @return ERR_OK if shutdown succeeded (or the PCB has already been shut down) - * another err_t on error. - */ -err_t -tcp_shutdown(struct tcp_pcb *pcb, int shut_rx, int shut_tx) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_shutdown: invalid pcb", pcb != NULL, return ERR_ARG); - - if (pcb->state == LISTEN) { - return ERR_CONN; - } - if (shut_rx) { - /* shut down the receive side: set a flag not to receive any more data... */ - tcp_set_flags(pcb, TF_RXCLOSED); - if (shut_tx) { - /* shutting down the tx AND rx side is the same as closing for the raw API */ - return tcp_close_shutdown(pcb, 1); - } - /* ... and free buffered data */ - if (pcb->refused_data != NULL) { - pbuf_free(pcb->refused_data); - pcb->refused_data = NULL; - } - } - if (shut_tx) { - /* This can't happen twice since if it succeeds, the pcb's state is changed. - Only close in these states as the others directly deallocate the PCB */ - switch (pcb->state) { - case SYN_RCVD: - case ESTABLISHED: - case CLOSE_WAIT: - return tcp_close_shutdown(pcb, (u8_t)shut_rx); - default: - /* Not (yet?) connected, cannot shutdown the TX side as that would bring us - into CLOSED state, where the PCB is deallocated. */ - return ERR_CONN; - } - } - return ERR_OK; -} - -/** - * Abandons a connection and optionally sends a RST to the remote - * host. Deletes the local protocol control block. This is done when - * a connection is killed because of shortage of memory. - * - * @param pcb the tcp_pcb to abort - * @param reset boolean to indicate whether a reset should be sent - */ -void -tcp_abandon(struct tcp_pcb *pcb, int reset) -{ - u32_t seqno, ackno; -#if LWIP_CALLBACK_API - tcp_err_fn errf; -#endif /* LWIP_CALLBACK_API */ - void *errf_arg; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_abandon: invalid pcb", pcb != NULL, return); - - /* pcb->state LISTEN not allowed here */ - LWIP_ASSERT("don't call tcp_abort/tcp_abandon for listen-pcbs", - pcb->state != LISTEN); - /* Figure out on which TCP PCB list we are, and remove us. If we - are in an active state, call the receive function associated with - the PCB with a NULL argument, and send an RST to the remote end. */ - if (pcb->state == TIME_WAIT) { - tcp_pcb_remove(&tcp_tw_pcbs, pcb); - tcp_free(pcb); - } else { - int send_rst = 0; - u16_t local_port = 0; - enum tcp_state last_state; - seqno = pcb->snd_nxt; - ackno = pcb->rcv_nxt; -#if LWIP_CALLBACK_API - errf = pcb->errf; -#endif /* LWIP_CALLBACK_API */ - errf_arg = pcb->callback_arg; - if (pcb->state == CLOSED) { - if (pcb->local_port != 0) { - /* bound, not yet opened */ - TCP_RMV(&tcp_bound_pcbs, pcb); - } - } else { - send_rst = reset; - local_port = pcb->local_port; - TCP_PCB_REMOVE_ACTIVE(pcb); - } - if (pcb->unacked != NULL) { - tcp_segs_free(pcb->unacked); - } - if (pcb->unsent != NULL) { - tcp_segs_free(pcb->unsent); - } -#if TCP_QUEUE_OOSEQ - if (pcb->ooseq != NULL) { - tcp_segs_free(pcb->ooseq); - } -#endif /* TCP_QUEUE_OOSEQ */ - tcp_backlog_accepted(pcb); - if (send_rst) { - LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_abandon: sending RST\n")); - tcp_rst(pcb, seqno, ackno, &pcb->local_ip, &pcb->remote_ip, local_port, pcb->remote_port); - } - last_state = pcb->state; - tcp_free(pcb); - TCP_EVENT_ERR(last_state, errf, errf_arg, ERR_ABRT); - } -} - -/** - * @ingroup tcp_raw - * Aborts the connection by sending a RST (reset) segment to the remote - * host. The pcb is deallocated. This function never fails. - * - * ATTENTION: When calling this from one of the TCP callbacks, make - * sure you always return ERR_ABRT (and never return ERR_ABRT otherwise - * or you will risk accessing deallocated memory or memory leaks! - * - * @param pcb the tcp pcb to abort - */ -void -tcp_abort(struct tcp_pcb *pcb) -{ - tcp_abandon(pcb, 1); -} - -/** - * @ingroup tcp_raw - * Binds the connection to a local port number and IP address. If the - * IP address is not given (i.e., ipaddr == IP_ANY_TYPE), the connection is - * bound to all local IP addresses. - * If another connection is bound to the same port, the function will - * return ERR_USE, otherwise ERR_OK is returned. - * - * @param pcb the tcp_pcb to bind (no check is done whether this pcb is - * already bound!) - * @param ipaddr the local ip address to bind to (use IPx_ADDR_ANY to bind - * to any local address - * @param port the local port to bind to - * @return ERR_USE if the port is already in use - * ERR_VAL if bind failed because the PCB is not in a valid state - * ERR_OK if bound - */ -err_t -tcp_bind(struct tcp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port) -{ - int i; - int max_pcb_list = NUM_TCP_PCB_LISTS; - struct tcp_pcb *cpcb; -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - ip_addr_t zoned_ipaddr; -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - - LWIP_ASSERT_CORE_LOCKED(); - -#if LWIP_IPV4 - /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ - if (ipaddr == NULL) { - ipaddr = IP4_ADDR_ANY; - } -#else /* LWIP_IPV4 */ - LWIP_ERROR("tcp_bind: invalid ipaddr", ipaddr != NULL, return ERR_ARG); -#endif /* LWIP_IPV4 */ - - LWIP_ERROR("tcp_bind: invalid pcb", pcb != NULL, return ERR_ARG); - - LWIP_ERROR("tcp_bind: can only bind in state CLOSED", pcb->state == CLOSED, return ERR_VAL); - -#if SO_REUSE - /* Unless the REUSEADDR flag is set, - we have to check the pcbs in TIME-WAIT state, also. - We do not dump TIME_WAIT pcb's; they can still be matched by incoming - packets using both local and remote IP addresses and ports to distinguish. - */ - if (ip_get_option(pcb, SOF_REUSEADDR)) { - max_pcb_list = NUM_TCP_PCB_LISTS_NO_TIME_WAIT; - } -#endif /* SO_REUSE */ - -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - /* If the given IP address should have a zone but doesn't, assign one now. - * This is legacy support: scope-aware callers should always provide properly - * zoned source addresses. Do the zone selection before the address-in-use - * check below; as such we have to make a temporary copy of the address. */ - if (IP_IS_V6(ipaddr) && ip6_addr_lacks_zone(ip_2_ip6(ipaddr), IP6_UNICAST)) { - ip_addr_copy(zoned_ipaddr, *ipaddr); - ip6_addr_select_zone(ip_2_ip6(&zoned_ipaddr), ip_2_ip6(&zoned_ipaddr)); - ipaddr = &zoned_ipaddr; - } -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - - if (port == 0) { - port = tcp_new_port(); - if (port == 0) { - return ERR_BUF; - } - } else { - /* Check if the address already is in use (on all lists) */ - for (i = 0; i < max_pcb_list; i++) { - for (cpcb = *tcp_pcb_lists[i]; cpcb != NULL; cpcb = cpcb->next) { - if (cpcb->local_port == port) { -#if SO_REUSE - /* Omit checking for the same port if both pcbs have REUSEADDR set. - For SO_REUSEADDR, the duplicate-check for a 5-tuple is done in - tcp_connect. */ - if (!ip_get_option(pcb, SOF_REUSEADDR) || - !ip_get_option(cpcb, SOF_REUSEADDR)) -#endif /* SO_REUSE */ - { - /* @todo: check accept_any_ip_version */ - if ((IP_IS_V6(ipaddr) == IP_IS_V6_VAL(cpcb->local_ip)) && - (ip_addr_isany(&cpcb->local_ip) || - ip_addr_isany(ipaddr) || - ip_addr_cmp(&cpcb->local_ip, ipaddr))) { - return ERR_USE; - } - } - } - } - } - } - - if (!ip_addr_isany(ipaddr) -#if LWIP_IPV4 && LWIP_IPV6 - || (IP_GET_TYPE(ipaddr) != IP_GET_TYPE(&pcb->local_ip)) -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - ) { - ip_addr_set(&pcb->local_ip, ipaddr); - } - pcb->local_port = port; - TCP_REG(&tcp_bound_pcbs, pcb); - LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: bind to port %"U16_F"\n", port)); - return ERR_OK; -} - -/** - * @ingroup tcp_raw - * Binds the connection to a netif and IP address. - * After calling this function, all packets received via this PCB - * are guaranteed to have come in via the specified netif, and all - * outgoing packets will go out via the specified netif. - * - * @param pcb the tcp_pcb to bind. - * @param netif the netif to bind to. Can be NULL. - */ -void -tcp_bind_netif(struct tcp_pcb *pcb, const struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (netif != NULL) { - pcb->netif_idx = netif_get_index(netif); - } else { - pcb->netif_idx = NETIF_NO_INDEX; - } -} - -#if LWIP_CALLBACK_API -/** - * Default accept callback if no accept callback is specified by the user. - */ -static err_t -tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err) -{ - LWIP_UNUSED_ARG(arg); - LWIP_UNUSED_ARG(err); - - LWIP_ASSERT("tcp_accept_null: invalid pcb", pcb != NULL); - - tcp_abort(pcb); - - return ERR_ABRT; -} -#endif /* LWIP_CALLBACK_API */ - -/** - * @ingroup tcp_raw - * Set the state of the connection to be LISTEN, which means that it - * is able to accept incoming connections. The protocol control block - * is reallocated in order to consume less memory. Setting the - * connection to LISTEN is an irreversible process. - * When an incoming connection is accepted, the function specified with - * the tcp_accept() function will be called. The pcb has to be bound - * to a local port with the tcp_bind() function. - * - * The tcp_listen() function returns a new connection identifier, and - * the one passed as an argument to the function will be - * deallocated. The reason for this behavior is that less memory is - * needed for a connection that is listening, so tcp_listen() will - * reclaim the memory needed for the original connection and allocate a - * new smaller memory block for the listening connection. - * - * tcp_listen() may return NULL if no memory was available for the - * listening connection. If so, the memory associated with the pcb - * passed as an argument to tcp_listen() will not be deallocated. - * - * The backlog limits the number of outstanding connections - * in the listen queue to the value specified by the backlog argument. - * To use it, your need to set TCP_LISTEN_BACKLOG=1 in your lwipopts.h. - * - * @param pcb the original tcp_pcb - * @param backlog the incoming connections queue limit - * @return tcp_pcb used for listening, consumes less memory. - * - * @note The original tcp_pcb is freed. This function therefore has to be - * called like this: - * tpcb = tcp_listen_with_backlog(tpcb, backlog); - */ -struct tcp_pcb * -tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog) -{ - LWIP_ASSERT_CORE_LOCKED(); - return tcp_listen_with_backlog_and_err(pcb, backlog, NULL); -} - -/** - * @ingroup tcp_raw - * Set the state of the connection to be LISTEN, which means that it - * is able to accept incoming connections. The protocol control block - * is reallocated in order to consume less memory. Setting the - * connection to LISTEN is an irreversible process. - * - * @param pcb the original tcp_pcb - * @param backlog the incoming connections queue limit - * @param err when NULL is returned, this contains the error reason - * @return tcp_pcb used for listening, consumes less memory. - * - * @note The original tcp_pcb is freed. This function therefore has to be - * called like this: - * tpcb = tcp_listen_with_backlog_and_err(tpcb, backlog, &err); - */ -struct tcp_pcb * -tcp_listen_with_backlog_and_err(struct tcp_pcb *pcb, u8_t backlog, err_t *err) -{ - struct tcp_pcb_listen *lpcb = NULL; - err_t res; - - LWIP_UNUSED_ARG(backlog); - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_listen_with_backlog_and_err: invalid pcb", pcb != NULL, res = ERR_ARG; goto done); - LWIP_ERROR("tcp_listen_with_backlog_and_err: pcb already connected", pcb->state == CLOSED, res = ERR_CLSD; goto done); - - /* already listening? */ - if (pcb->state == LISTEN) { - lpcb = (struct tcp_pcb_listen *)pcb; - res = ERR_ALREADY; - goto done; - } -#if SO_REUSE - if (ip_get_option(pcb, SOF_REUSEADDR)) { - /* Since SOF_REUSEADDR allows reusing a local address before the pcb's usage - is declared (listen-/connection-pcb), we have to make sure now that - this port is only used once for every local IP. */ - for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) { - if ((lpcb->local_port == pcb->local_port) && - ip_addr_cmp(&lpcb->local_ip, &pcb->local_ip)) { - /* this address/port is already used */ - lpcb = NULL; - res = ERR_USE; - goto done; - } - } - } -#endif /* SO_REUSE */ - lpcb = (struct tcp_pcb_listen *)memp_malloc(MEMP_TCP_PCB_LISTEN); - if (lpcb == NULL) { - res = ERR_MEM; - goto done; - } - lpcb->callback_arg = pcb->callback_arg; - lpcb->local_port = pcb->local_port; - lpcb->state = LISTEN; - lpcb->prio = pcb->prio; - lpcb->so_options = pcb->so_options; - lpcb->netif_idx = NETIF_NO_INDEX; - lpcb->ttl = pcb->ttl; - lpcb->tos = pcb->tos; -#if LWIP_IPV4 && LWIP_IPV6 - IP_SET_TYPE_VAL(lpcb->remote_ip, pcb->local_ip.type); -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - ip_addr_copy(lpcb->local_ip, pcb->local_ip); - if (pcb->local_port != 0) { - TCP_RMV(&tcp_bound_pcbs, pcb); - } -#if LWIP_TCP_PCB_NUM_EXT_ARGS - /* copy over ext_args to listening pcb */ - memcpy(&lpcb->ext_args, &pcb->ext_args, sizeof(pcb->ext_args)); -#endif - tcp_free(pcb); -#if LWIP_CALLBACK_API - lpcb->accept = tcp_accept_null; -#endif /* LWIP_CALLBACK_API */ -#if TCP_LISTEN_BACKLOG - lpcb->accepts_pending = 0; - tcp_backlog_set(lpcb, backlog); -#endif /* TCP_LISTEN_BACKLOG */ - TCP_REG(&tcp_listen_pcbs.pcbs, (struct tcp_pcb *)lpcb); - res = ERR_OK; -done: - if (err != NULL) { - *err = res; - } - return (struct tcp_pcb *)lpcb; -} - -/** - * Update the state that tracks the available window space to advertise. - * - * Returns how much extra window would be advertised if we sent an - * update now. - */ -u32_t -tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb) -{ - u32_t new_right_edge; - - LWIP_ASSERT("tcp_update_rcv_ann_wnd: invalid pcb", pcb != NULL); - new_right_edge = pcb->rcv_nxt + pcb->rcv_wnd; - - if (TCP_SEQ_GEQ(new_right_edge, pcb->rcv_ann_right_edge + LWIP_MIN((TCP_WND / 2), pcb->mss))) { - /* we can advertise more window */ - pcb->rcv_ann_wnd = pcb->rcv_wnd; - return new_right_edge - pcb->rcv_ann_right_edge; - } else { - if (TCP_SEQ_GT(pcb->rcv_nxt, pcb->rcv_ann_right_edge)) { - /* Can happen due to other end sending out of advertised window, - * but within actual available (but not yet advertised) window */ - pcb->rcv_ann_wnd = 0; - } else { - /* keep the right edge of window constant */ - u32_t new_rcv_ann_wnd = pcb->rcv_ann_right_edge - pcb->rcv_nxt; -#if !LWIP_WND_SCALE - LWIP_ASSERT("new_rcv_ann_wnd <= 0xffff", new_rcv_ann_wnd <= 0xffff); -#endif - pcb->rcv_ann_wnd = (tcpwnd_size_t)new_rcv_ann_wnd; - } - return 0; - } -} - -/** - * @ingroup tcp_raw - * This function should be called by the application when it has - * processed the data. The purpose is to advertise a larger window - * when the data has been processed. - * - * @param pcb the tcp_pcb for which data is read - * @param len the amount of bytes that have been read by the application - */ -void -tcp_recved(struct tcp_pcb *pcb, u16_t len) -{ - u32_t wnd_inflation; - tcpwnd_size_t rcv_wnd; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_recved: invalid pcb", pcb != NULL, return); - - /* pcb->state LISTEN not allowed here */ - LWIP_ASSERT("don't call tcp_recved for listen-pcbs", - pcb->state != LISTEN); - - rcv_wnd = (tcpwnd_size_t)(pcb->rcv_wnd + len); - if ((rcv_wnd > TCP_WND_MAX(pcb)) || (rcv_wnd < pcb->rcv_wnd)) { - /* window got too big or tcpwnd_size_t overflow */ - LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: window got too big or tcpwnd_size_t overflow\n")); - pcb->rcv_wnd = TCP_WND_MAX(pcb); - } else { - pcb->rcv_wnd = rcv_wnd; - } - - wnd_inflation = tcp_update_rcv_ann_wnd(pcb); - - /* If the change in the right edge of window is significant (default - * watermark is TCP_WND/4), then send an explicit update now. - * Otherwise wait for a packet to be sent in the normal course of - * events (or more window to be available later) */ - if (wnd_inflation >= TCP_WND_UPDATE_THRESHOLD) { - tcp_ack_now(pcb); - tcp_output(pcb); - } - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: received %"U16_F" bytes, wnd %"TCPWNDSIZE_F" (%"TCPWNDSIZE_F").\n", - len, pcb->rcv_wnd, (u16_t)(TCP_WND_MAX(pcb) - pcb->rcv_wnd))); -} - -/** - * Allocate a new local TCP port. - * - * @return a new (free) local TCP port number - */ -static u16_t -tcp_new_port(void) -{ - u8_t i; - u16_t n = 0; - struct tcp_pcb *pcb; - -again: - tcp_port++; - if (tcp_port == TCP_LOCAL_PORT_RANGE_END) { - tcp_port = TCP_LOCAL_PORT_RANGE_START; - } - /* Check all PCB lists. */ - for (i = 0; i < NUM_TCP_PCB_LISTS; i++) { - for (pcb = *tcp_pcb_lists[i]; pcb != NULL; pcb = pcb->next) { - if (pcb->local_port == tcp_port) { - n++; - if (n > (TCP_LOCAL_PORT_RANGE_END - TCP_LOCAL_PORT_RANGE_START)) { - return 0; - } - goto again; - } - } - } - return tcp_port; -} - -/** - * @ingroup tcp_raw - * Connects to another host. The function given as the "connected" - * argument will be called when the connection has been established. - * Sets up the pcb to connect to the remote host and sends the - * initial SYN segment which opens the connection. - * - * The tcp_connect() function returns immediately; it does not wait for - * the connection to be properly setup. Instead, it will call the - * function specified as the fourth argument (the "connected" argument) - * when the connection is established. If the connection could not be - * properly established, either because the other host refused the - * connection or because the other host didn't answer, the "err" - * callback function of this pcb (registered with tcp_err, see below) - * will be called. - * - * The tcp_connect() function can return ERR_MEM if no memory is - * available for enqueueing the SYN segment. If the SYN indeed was - * enqueued successfully, the tcp_connect() function returns ERR_OK. - * - * @param pcb the tcp_pcb used to establish the connection - * @param ipaddr the remote ip address to connect to - * @param port the remote tcp port to connect to - * @param connected callback function to call when connected (on error, - the err calback will be called) - * @return ERR_VAL if invalid arguments are given - * ERR_OK if connect request has been sent - * other err_t values if connect request couldn't be sent - */ -err_t -tcp_connect(struct tcp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port, - tcp_connected_fn connected) -{ - struct netif *netif = NULL; - err_t ret; - u32_t iss; - u16_t old_local_port; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_connect: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_ERROR("tcp_connect: invalid ipaddr", ipaddr != NULL, return ERR_ARG); - - LWIP_ERROR("tcp_connect: can only connect from state CLOSED", pcb->state == CLOSED, return ERR_ISCONN); - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_connect to port %"U16_F"\n", port)); - ip_addr_set(&pcb->remote_ip, ipaddr); - pcb->remote_port = port; - - if (pcb->netif_idx != NETIF_NO_INDEX) { - netif = netif_get_by_index(pcb->netif_idx); - } else { - /* check if we have a route to the remote host */ - netif = ip_route(&pcb->local_ip, &pcb->remote_ip); - } - if (netif == NULL) { - /* Don't even try to send a SYN packet if we have no route since that will fail. */ - return ERR_RTE; - } - - /* check if local IP has been assigned to pcb, if not, get one */ - if (ip_addr_isany(&pcb->local_ip)) { - const ip_addr_t *local_ip = ip_netif_get_local_ip(netif, ipaddr); - if (local_ip == NULL) { - return ERR_RTE; - } - ip_addr_copy(pcb->local_ip, *local_ip); - } - -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - /* If the given IP address should have a zone but doesn't, assign one now. - * Given that we already have the target netif, this is easy and cheap. */ - if (IP_IS_V6(&pcb->remote_ip) && - ip6_addr_lacks_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNICAST)) { - ip6_addr_assign_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNICAST, netif); - } -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - - old_local_port = pcb->local_port; - if (pcb->local_port == 0) { - pcb->local_port = tcp_new_port(); - if (pcb->local_port == 0) { - return ERR_BUF; - } - } else { -#if SO_REUSE - if (ip_get_option(pcb, SOF_REUSEADDR)) { - /* Since SOF_REUSEADDR allows reusing a local address, we have to make sure - now that the 5-tuple is unique. */ - struct tcp_pcb *cpcb; - int i; - /* Don't check listen- and bound-PCBs, check active- and TIME-WAIT PCBs. */ - for (i = 2; i < NUM_TCP_PCB_LISTS; i++) { - for (cpcb = *tcp_pcb_lists[i]; cpcb != NULL; cpcb = cpcb->next) { - if ((cpcb->local_port == pcb->local_port) && - (cpcb->remote_port == port) && - ip_addr_cmp(&cpcb->local_ip, &pcb->local_ip) && - ip_addr_cmp(&cpcb->remote_ip, ipaddr)) { - /* linux returns EISCONN here, but ERR_USE should be OK for us */ - return ERR_USE; - } - } - } - } -#endif /* SO_REUSE */ - } - - iss = tcp_next_iss(pcb); - pcb->rcv_nxt = 0; - pcb->snd_nxt = iss; - pcb->lastack = iss - 1; - pcb->snd_wl2 = iss - 1; - pcb->snd_lbb = iss - 1; - /* Start with a window that does not need scaling. When window scaling is - enabled and used, the window is enlarged when both sides agree on scaling. */ - pcb->rcv_wnd = pcb->rcv_ann_wnd = TCPWND_MIN16(TCP_WND); - pcb->rcv_ann_right_edge = pcb->rcv_nxt; - pcb->snd_wnd = TCP_WND; - /* As initial send MSS, we use TCP_MSS but limit it to 536. - The send MSS is updated when an MSS option is received. */ - pcb->mss = INITIAL_MSS; -#if TCP_CALCULATE_EFF_SEND_MSS - pcb->mss = tcp_eff_send_mss_netif(pcb->mss, netif, &pcb->remote_ip); -#endif /* TCP_CALCULATE_EFF_SEND_MSS */ - pcb->cwnd = 1; -#if LWIP_CALLBACK_API - pcb->connected = connected; -#else /* LWIP_CALLBACK_API */ - LWIP_UNUSED_ARG(connected); -#endif /* LWIP_CALLBACK_API */ - - /* Send a SYN together with the MSS option. */ - ret = tcp_enqueue_flags(pcb, TCP_SYN); - if (ret == ERR_OK) { - /* SYN segment was enqueued, changed the pcbs state now */ - pcb->state = SYN_SENT; - if (old_local_port != 0) { - TCP_RMV(&tcp_bound_pcbs, pcb); - } - TCP_REG_ACTIVE(pcb); - MIB2_STATS_INC(mib2.tcpactiveopens); - - tcp_output(pcb); - } - return ret; -} - -/** - * Called every 500 ms and implements the retransmission timer and the timer that - * removes PCBs that have been in TIME-WAIT for enough time. It also increments - * various timers such as the inactivity timer in each PCB. - * - * Automatically called from tcp_tmr(). - */ -void -tcp_slowtmr(void) -{ - struct tcp_pcb *pcb, *prev; - tcpwnd_size_t eff_wnd; - u8_t pcb_remove; /* flag if a PCB should be removed */ - u8_t pcb_reset; /* flag if a RST should be sent when removing */ - err_t err; - - err = ERR_OK; - - ++tcp_ticks; - ++tcp_timer_ctr; - -tcp_slowtmr_start: - /* Steps through all of the active PCBs. */ - prev = NULL; - pcb = tcp_active_pcbs; - if (pcb == NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: no active pcbs\n")); - } - while (pcb != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: processing active pcb\n")); - LWIP_ASSERT("tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED); - LWIP_ASSERT("tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN); - LWIP_ASSERT("tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT); - if (pcb->last_timer == tcp_timer_ctr) { - /* skip this pcb, we have already processed it */ - prev = pcb; - pcb = pcb->next; - continue; - } - pcb->last_timer = tcp_timer_ctr; - - pcb_remove = 0; - pcb_reset = 0; - - if (pcb->state == SYN_SENT && pcb->nrtx >= TCP_SYNMAXRTX) { - ++pcb_remove; - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max SYN retries reached\n")); - } else if (pcb->nrtx >= TCP_MAXRTX) { - ++pcb_remove; - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max DATA retries reached\n")); - } else { - if (pcb->persist_backoff > 0) { - LWIP_ASSERT("tcp_slowtimr: persist ticking with in-flight data", pcb->unacked == NULL); - LWIP_ASSERT("tcp_slowtimr: persist ticking with empty send buffer", pcb->unsent != NULL); - if (pcb->persist_probe >= TCP_MAXRTX) { - ++pcb_remove; /* max probes reached */ - } else { - u8_t backoff_cnt = tcp_persist_backoff[pcb->persist_backoff - 1]; - if (pcb->persist_cnt < backoff_cnt) { - pcb->persist_cnt++; - } - if (pcb->persist_cnt >= backoff_cnt) { - int next_slot = 1; /* increment timer to next slot */ - /* If snd_wnd is zero, send 1 byte probes */ - if (pcb->snd_wnd == 0) { - if (tcp_zero_window_probe(pcb) != ERR_OK) { - next_slot = 0; /* try probe again with current slot */ - } - /* snd_wnd not fully closed, split unsent head and fill window */ - } else { - if (tcp_split_unsent_seg(pcb, (u16_t)pcb->snd_wnd) == ERR_OK) { - if (tcp_output(pcb) == ERR_OK) { - /* sending will cancel persist timer, else retry with current slot */ - next_slot = 0; - } - } - } - if (next_slot) { - pcb->persist_cnt = 0; - if (pcb->persist_backoff < sizeof(tcp_persist_backoff)) { - pcb->persist_backoff++; - } - } - } - } - } else { - /* Increase the retransmission timer if it is running */ - if ((pcb->rtime >= 0) && (pcb->rtime < 0x7FFF)) { - ++pcb->rtime; - } - - if (pcb->rtime >= pcb->rto) { - /* Time for a retransmission. */ - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_slowtmr: rtime %"S16_F - " pcb->rto %"S16_F"\n", - pcb->rtime, pcb->rto)); - /* If prepare phase fails but we have unsent data but no unacked data, - still execute the backoff calculations below, as this means we somehow - failed to send segment. */ - if ((tcp_rexmit_rto_prepare(pcb) == ERR_OK) || ((pcb->unacked == NULL) && (pcb->unsent != NULL))) { - /* Double retransmission time-out unless we are trying to - * connect to somebody (i.e., we are in SYN_SENT). */ - if (pcb->state != SYN_SENT) { - u8_t backoff_idx = LWIP_MIN(pcb->nrtx, sizeof(tcp_backoff) - 1); - int calc_rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[backoff_idx]; - pcb->rto = (s16_t)LWIP_MIN(calc_rto, 0x7FFF); - } - - /* Reset the retransmission timer. */ - pcb->rtime = 0; - - /* Reduce congestion window and ssthresh. */ - eff_wnd = LWIP_MIN(pcb->cwnd, pcb->snd_wnd); - pcb->ssthresh = eff_wnd >> 1; - if (pcb->ssthresh < (tcpwnd_size_t)(pcb->mss << 1)) { - pcb->ssthresh = (tcpwnd_size_t)(pcb->mss << 1); - } - pcb->cwnd = pcb->mss; - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: cwnd %"TCPWNDSIZE_F - " ssthresh %"TCPWNDSIZE_F"\n", - pcb->cwnd, pcb->ssthresh)); - pcb->bytes_acked = 0; - - /* The following needs to be called AFTER cwnd is set to one - mss - STJ */ - tcp_rexmit_rto_commit(pcb); - } - } - } - } - /* Check if this PCB has stayed too long in FIN-WAIT-2 */ - if (pcb->state == FIN_WAIT_2) { - /* If this PCB is in FIN_WAIT_2 because of SHUT_WR don't let it time out. */ - if (pcb->flags & TF_RXCLOSED) { - /* PCB was fully closed (either through close() or SHUT_RDWR): - normal FIN-WAIT timeout handling. */ - if ((u32_t)(tcp_ticks - pcb->tmr) > - TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) { - ++pcb_remove; - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in FIN-WAIT-2\n")); - } - } - } - - /* Check if KEEPALIVE should be sent */ - if (ip_get_option(pcb, SOF_KEEPALIVE) && - ((pcb->state == ESTABLISHED) || - (pcb->state == CLOSE_WAIT))) { - if ((u32_t)(tcp_ticks - pcb->tmr) > - (pcb->keep_idle + TCP_KEEP_DUR(pcb)) / TCP_SLOW_INTERVAL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: KEEPALIVE timeout. Aborting connection to ")); - ip_addr_debug_print_val(TCP_DEBUG, pcb->remote_ip); - LWIP_DEBUGF(TCP_DEBUG, ("\n")); - - ++pcb_remove; - ++pcb_reset; - } else if ((u32_t)(tcp_ticks - pcb->tmr) > - (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEP_INTVL(pcb)) - / TCP_SLOW_INTERVAL) { - err = tcp_keepalive(pcb); - if (err == ERR_OK) { - pcb->keep_cnt_sent++; - } - } - } - - /* If this PCB has queued out of sequence data, but has been - inactive for too long, will drop the data (it will eventually - be retransmitted). */ -#if TCP_QUEUE_OOSEQ - if (pcb->ooseq != NULL && - (tcp_ticks - pcb->tmr >= (u32_t)pcb->rto * TCP_OOSEQ_TIMEOUT)) { - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: dropping OOSEQ queued data\n")); - tcp_free_ooseq(pcb); - } -#endif /* TCP_QUEUE_OOSEQ */ - - /* Check if this PCB has stayed too long in SYN-RCVD */ - if (pcb->state == SYN_RCVD) { - if ((u32_t)(tcp_ticks - pcb->tmr) > - TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) { - ++pcb_remove; - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in SYN-RCVD\n")); - } - } - - /* Check if this PCB has stayed too long in LAST-ACK */ - if (pcb->state == LAST_ACK) { - if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) { - ++pcb_remove; - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in LAST-ACK\n")); - } - } - - /* If the PCB should be removed, do it. */ - if (pcb_remove) { - struct tcp_pcb *pcb2; -#if LWIP_CALLBACK_API - tcp_err_fn err_fn = pcb->errf; -#endif /* LWIP_CALLBACK_API */ - void *err_arg; - enum tcp_state last_state; - tcp_pcb_purge(pcb); - /* Remove PCB from tcp_active_pcbs list. */ - if (prev != NULL) { - LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs); - prev->next = pcb->next; - } else { - /* This PCB was the first. */ - LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb); - tcp_active_pcbs = pcb->next; - } - - if (pcb_reset) { - tcp_rst(pcb, pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip, - pcb->local_port, pcb->remote_port); - } - - err_arg = pcb->callback_arg; - last_state = pcb->state; - pcb2 = pcb; - pcb = pcb->next; - tcp_free(pcb2); - - tcp_active_pcbs_changed = 0; - TCP_EVENT_ERR(last_state, err_fn, err_arg, ERR_ABRT); - if (tcp_active_pcbs_changed) { - goto tcp_slowtmr_start; - } - } else { - /* get the 'next' element now and work with 'prev' below (in case of abort) */ - prev = pcb; - pcb = pcb->next; - - /* We check if we should poll the connection. */ - ++prev->polltmr; - if (prev->polltmr >= prev->pollinterval) { - prev->polltmr = 0; - LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling application\n")); - tcp_active_pcbs_changed = 0; - TCP_EVENT_POLL(prev, err); - if (tcp_active_pcbs_changed) { - goto tcp_slowtmr_start; - } - /* if err == ERR_ABRT, 'prev' is already deallocated */ - if (err == ERR_OK) { - tcp_output(prev); - } - } - } - } - - - /* Steps through all of the TIME-WAIT PCBs. */ - prev = NULL; - pcb = tcp_tw_pcbs; - while (pcb != NULL) { - LWIP_ASSERT("tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT); - pcb_remove = 0; - - /* Check if this PCB has stayed long enough in TIME-WAIT */ - if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) { - ++pcb_remove; - } - - /* If the PCB should be removed, do it. */ - if (pcb_remove) { - struct tcp_pcb *pcb2; - tcp_pcb_purge(pcb); - /* Remove PCB from tcp_tw_pcbs list. */ - if (prev != NULL) { - LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs); - prev->next = pcb->next; - } else { - /* This PCB was the first. */ - LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb); - tcp_tw_pcbs = pcb->next; - } - pcb2 = pcb; - pcb = pcb->next; - tcp_free(pcb2); - } else { - prev = pcb; - pcb = pcb->next; - } - } -} - -/** - * Is called every TCP_FAST_INTERVAL (250 ms) and process data previously - * "refused" by upper layer (application) and sends delayed ACKs or pending FINs. - * - * Automatically called from tcp_tmr(). - */ -void -tcp_fasttmr(void) -{ - struct tcp_pcb *pcb; - - ++tcp_timer_ctr; - -tcp_fasttmr_start: - pcb = tcp_active_pcbs; - - while (pcb != NULL) { - if (pcb->last_timer != tcp_timer_ctr) { - struct tcp_pcb *next; - pcb->last_timer = tcp_timer_ctr; - /* send delayed ACKs */ - if (pcb->flags & TF_ACK_DELAY) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: delayed ACK\n")); - tcp_ack_now(pcb); - tcp_output(pcb); - tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); - } - /* send pending FIN */ - if (pcb->flags & TF_CLOSEPEND) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: pending FIN\n")); - tcp_clear_flags(pcb, TF_CLOSEPEND); - tcp_close_shutdown_fin(pcb); - } - - next = pcb->next; - - /* If there is data which was previously "refused" by upper layer */ - if (pcb->refused_data != NULL) { - tcp_active_pcbs_changed = 0; - tcp_process_refused_data(pcb); - if (tcp_active_pcbs_changed) { - /* application callback has changed the pcb list: restart the loop */ - goto tcp_fasttmr_start; - } - } - pcb = next; - } else { - pcb = pcb->next; - } - } -} - -/** Call tcp_output for all active pcbs that have TF_NAGLEMEMERR set */ -void -tcp_txnow(void) -{ - struct tcp_pcb *pcb; - - for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { - if (pcb->flags & TF_NAGLEMEMERR) { - tcp_output(pcb); - } - } -} - -/** Pass pcb->refused_data to the recv callback */ -err_t -tcp_process_refused_data(struct tcp_pcb *pcb) -{ -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - struct pbuf *rest; -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - - LWIP_ERROR("tcp_process_refused_data: invalid pcb", pcb != NULL, return ERR_ARG); - -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - while (pcb->refused_data != NULL) -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - { - err_t err; - u8_t refused_flags = pcb->refused_data->flags; - /* set pcb->refused_data to NULL in case the callback frees it and then - closes the pcb */ - struct pbuf *refused_data = pcb->refused_data; -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - pbuf_split_64k(refused_data, &rest); - pcb->refused_data = rest; -#else /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - pcb->refused_data = NULL; -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - /* Notify again application with data previously received. */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: notify kept packet\n")); - TCP_EVENT_RECV(pcb, refused_data, ERR_OK, err); - if (err == ERR_OK) { - /* did refused_data include a FIN? */ - if ((refused_flags & PBUF_FLAG_TCP_FIN) -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - && (rest == NULL) -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - ) { - /* correct rcv_wnd as the application won't call tcp_recved() - for the FIN's seqno */ - if (pcb->rcv_wnd != TCP_WND_MAX(pcb)) { - pcb->rcv_wnd++; - } - TCP_EVENT_CLOSED(pcb, err); - if (err == ERR_ABRT) { - return ERR_ABRT; - } - } - } else if (err == ERR_ABRT) { - /* if err == ERR_ABRT, 'pcb' is already deallocated */ - /* Drop incoming packets because pcb is "full" (only if the incoming - segment contains data). */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: drop incoming packets, because pcb is \"full\"\n")); - return ERR_ABRT; - } else { - /* data is still refused, pbuf is still valid (go on for ACK-only packets) */ -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - if (rest != NULL) { - pbuf_cat(refused_data, rest); - } -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - pcb->refused_data = refused_data; - return ERR_INPROGRESS; - } - } - return ERR_OK; -} - -/** - * Deallocates a list of TCP segments (tcp_seg structures). - * - * @param seg tcp_seg list of TCP segments to free - */ -void -tcp_segs_free(struct tcp_seg *seg) -{ - while (seg != NULL) { - struct tcp_seg *next = seg->next; - tcp_seg_free(seg); - seg = next; - } -} - -/** - * Frees a TCP segment (tcp_seg structure). - * - * @param seg single tcp_seg to free - */ -void -tcp_seg_free(struct tcp_seg *seg) -{ - if (seg != NULL) { - if (seg->p != NULL) { - pbuf_free(seg->p); -#if TCP_DEBUG - seg->p = NULL; -#endif /* TCP_DEBUG */ - } - memp_free(MEMP_TCP_SEG, seg); - } -} - -/** - * @ingroup tcp - * Sets the priority of a connection. - * - * @param pcb the tcp_pcb to manipulate - * @param prio new priority - */ -void -tcp_setprio(struct tcp_pcb *pcb, u8_t prio) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_setprio: invalid pcb", pcb != NULL, return); - - pcb->prio = prio; -} - -#if TCP_QUEUE_OOSEQ -/** - * Returns a copy of the given TCP segment. - * The pbuf and data are not copied, only the pointers - * - * @param seg the old tcp_seg - * @return a copy of seg - */ -struct tcp_seg * -tcp_seg_copy(struct tcp_seg *seg) -{ - struct tcp_seg *cseg; - - LWIP_ASSERT("tcp_seg_copy: invalid seg", seg != NULL); - - cseg = (struct tcp_seg *)memp_malloc(MEMP_TCP_SEG); - if (cseg == NULL) { - return NULL; - } - SMEMCPY((u8_t *)cseg, (const u8_t *)seg, sizeof(struct tcp_seg)); - pbuf_ref(cseg->p); - return cseg; -} -#endif /* TCP_QUEUE_OOSEQ */ - -#if LWIP_CALLBACK_API -/** - * Default receive callback that is called if the user didn't register - * a recv callback for the pcb. - */ -err_t -tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) -{ - LWIP_UNUSED_ARG(arg); - - LWIP_ERROR("tcp_recv_null: invalid pcb", pcb != NULL, return ERR_ARG); - - if (p != NULL) { - tcp_recved(pcb, p->tot_len); - pbuf_free(p); - } else if (err == ERR_OK) { - return tcp_close(pcb); - } - return ERR_OK; -} -#endif /* LWIP_CALLBACK_API */ - -/** - * Kills the oldest active connection that has a lower priority than 'prio'. - * - * @param prio minimum priority - */ -static void -tcp_kill_prio(u8_t prio) -{ - struct tcp_pcb *pcb, *inactive; - u32_t inactivity; - u8_t mprio; - - mprio = LWIP_MIN(TCP_PRIO_MAX, prio); - - /* We want to kill connections with a lower prio, so bail out if - * supplied prio is 0 - there can never be a lower prio - */ - if (mprio == 0) { - return; - } - - /* We only want kill connections with a lower prio, so decrement prio by one - * and start searching for oldest connection with same or lower priority than mprio. - * We want to find the connections with the lowest possible prio, and among - * these the one with the longest inactivity time. - */ - mprio--; - - inactivity = 0; - inactive = NULL; - for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { - /* lower prio is always a kill candidate */ - if ((pcb->prio < mprio) || - /* longer inactivity is also a kill candidate */ - ((pcb->prio == mprio) && ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity))) { - inactivity = tcp_ticks - pcb->tmr; - inactive = pcb; - mprio = pcb->prio; - } - } - if (inactive != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_prio: killing oldest PCB %p (%"S32_F")\n", - (void *)inactive, inactivity)); - tcp_abort(inactive); - } -} - -/** - * Kills the oldest connection that is in specific state. - * Called from tcp_alloc() for LAST_ACK and CLOSING if no more connections are available. - */ -static void -tcp_kill_state(enum tcp_state state) -{ - struct tcp_pcb *pcb, *inactive; - u32_t inactivity; - - LWIP_ASSERT("invalid state", (state == CLOSING) || (state == LAST_ACK)); - - inactivity = 0; - inactive = NULL; - /* Go through the list of active pcbs and get the oldest pcb that is in state - CLOSING/LAST_ACK. */ - for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { - if (pcb->state == state) { - if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) { - inactivity = tcp_ticks - pcb->tmr; - inactive = pcb; - } - } - } - if (inactive != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_closing: killing oldest %s PCB %p (%"S32_F")\n", - tcp_state_str[state], (void *)inactive, inactivity)); - /* Don't send a RST, since no data is lost. */ - tcp_abandon(inactive, 0); - } -} - -/** - * Kills the oldest connection that is in TIME_WAIT state. - * Called from tcp_alloc() if no more connections are available. - */ -static void -tcp_kill_timewait(void) -{ - struct tcp_pcb *pcb, *inactive; - u32_t inactivity; - - inactivity = 0; - inactive = NULL; - /* Go through the list of TIME_WAIT pcbs and get the oldest pcb. */ - for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { - if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) { - inactivity = tcp_ticks - pcb->tmr; - inactive = pcb; - } - } - if (inactive != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_timewait: killing oldest TIME-WAIT PCB %p (%"S32_F")\n", - (void *)inactive, inactivity)); - tcp_abort(inactive); - } -} - -/* Called when allocating a pcb fails. - * In this case, we want to handle all pcbs that want to close first: if we can - * now send the FIN (which failed before), the pcb might be in a state that is - * OK for us to now free it. - */ -static void -tcp_handle_closepend(void) -{ - struct tcp_pcb *pcb = tcp_active_pcbs; - - while (pcb != NULL) { - struct tcp_pcb *next = pcb->next; - /* send pending FIN */ - if (pcb->flags & TF_CLOSEPEND) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_handle_closepend: pending FIN\n")); - tcp_clear_flags(pcb, TF_CLOSEPEND); - tcp_close_shutdown_fin(pcb); - } - pcb = next; - } -} - -/** - * Allocate a new tcp_pcb structure. - * - * @param prio priority for the new pcb - * @return a new tcp_pcb that initially is in state CLOSED - */ -struct tcp_pcb * -tcp_alloc(u8_t prio) -{ - struct tcp_pcb *pcb; - - LWIP_ASSERT_CORE_LOCKED(); - - pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); - if (pcb == NULL) { - /* Try to send FIN for all pcbs stuck in TF_CLOSEPEND first */ - tcp_handle_closepend(); - - /* Try killing oldest connection in TIME-WAIT. */ - LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest TIME-WAIT connection\n")); - tcp_kill_timewait(); - /* Try to allocate a tcp_pcb again. */ - pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); - if (pcb == NULL) { - /* Try killing oldest connection in LAST-ACK (these wouldn't go to TIME-WAIT). */ - LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest LAST-ACK connection\n")); - tcp_kill_state(LAST_ACK); - /* Try to allocate a tcp_pcb again. */ - pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); - if (pcb == NULL) { - /* Try killing oldest connection in CLOSING. */ - LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest CLOSING connection\n")); - tcp_kill_state(CLOSING); - /* Try to allocate a tcp_pcb again. */ - pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); - if (pcb == NULL) { - /* Try killing oldest active connection with lower priority than the new one. */ - LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing oldest connection with prio lower than %d\n", prio)); - tcp_kill_prio(prio); - /* Try to allocate a tcp_pcb again. */ - pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); - if (pcb != NULL) { - /* adjust err stats: memp_malloc failed multiple times before */ - MEMP_STATS_DEC(err, MEMP_TCP_PCB); - } - } - if (pcb != NULL) { - /* adjust err stats: memp_malloc failed multiple times before */ - MEMP_STATS_DEC(err, MEMP_TCP_PCB); - } - } - if (pcb != NULL) { - /* adjust err stats: memp_malloc failed multiple times before */ - MEMP_STATS_DEC(err, MEMP_TCP_PCB); - } - } - if (pcb != NULL) { - /* adjust err stats: memp_malloc failed above */ - MEMP_STATS_DEC(err, MEMP_TCP_PCB); - } - } - if (pcb != NULL) { - /* zero out the whole pcb, so there is no need to initialize members to zero */ - memset(pcb, 0, sizeof(struct tcp_pcb)); - pcb->prio = prio; - pcb->snd_buf = TCP_SND_BUF; - /* Start with a window that does not need scaling. When window scaling is - enabled and used, the window is enlarged when both sides agree on scaling. */ - pcb->rcv_wnd = pcb->rcv_ann_wnd = TCPWND_MIN16(TCP_WND); - pcb->ttl = TCP_TTL; - /* As initial send MSS, we use TCP_MSS but limit it to 536. - The send MSS is updated when an MSS option is received. */ - pcb->mss = INITIAL_MSS; - pcb->rto = 3000 / TCP_SLOW_INTERVAL; - pcb->sv = 3000 / TCP_SLOW_INTERVAL; - pcb->rtime = -1; - pcb->cwnd = 1; - pcb->tmr = tcp_ticks; - pcb->last_timer = tcp_timer_ctr; - - /* RFC 5681 recommends setting ssthresh abritrarily high and gives an example - of using the largest advertised receive window. We've seen complications with - receiving TCPs that use window scaling and/or window auto-tuning where the - initial advertised window is very small and then grows rapidly once the - connection is established. To avoid these complications, we set ssthresh to the - largest effective cwnd (amount of in-flight data) that the sender can have. */ - pcb->ssthresh = TCP_SND_BUF; - -#if LWIP_CALLBACK_API - pcb->recv = tcp_recv_null; -#endif /* LWIP_CALLBACK_API */ - - /* Init KEEPALIVE timer */ - pcb->keep_idle = TCP_KEEPIDLE_DEFAULT; - -#if LWIP_TCP_KEEPALIVE - pcb->keep_intvl = TCP_KEEPINTVL_DEFAULT; - pcb->keep_cnt = TCP_KEEPCNT_DEFAULT; -#endif /* LWIP_TCP_KEEPALIVE */ - } - return pcb; -} - -/** - * @ingroup tcp_raw - * Creates a new TCP protocol control block but doesn't place it on - * any of the TCP PCB lists. - * The pcb is not put on any list until binding using tcp_bind(). - * If memory is not available for creating the new pcb, NULL is returned. - * - * @internal: Maybe there should be a idle TCP PCB list where these - * PCBs are put on. Port reservation using tcp_bind() is implemented but - * allocated pcbs that are not bound can't be killed automatically if wanting - * to allocate a pcb with higher prio (@see tcp_kill_prio()) - * - * @return a new tcp_pcb that initially is in state CLOSED - */ -struct tcp_pcb * -tcp_new(void) -{ - return tcp_alloc(TCP_PRIO_NORMAL); -} - -/** - * @ingroup tcp_raw - * Creates a new TCP protocol control block but doesn't - * place it on any of the TCP PCB lists. - * The pcb is not put on any list until binding using tcp_bind(). - * - * @param type IP address type, see @ref lwip_ip_addr_type definitions. - * If you want to listen to IPv4 and IPv6 (dual-stack) connections, - * supply @ref IPADDR_TYPE_ANY as argument and bind to @ref IP_ANY_TYPE. - * @return a new tcp_pcb that initially is in state CLOSED - */ -struct tcp_pcb * -tcp_new_ip_type(u8_t type) -{ - struct tcp_pcb *pcb; - pcb = tcp_alloc(TCP_PRIO_NORMAL); -#if LWIP_IPV4 && LWIP_IPV6 - if (pcb != NULL) { - IP_SET_TYPE_VAL(pcb->local_ip, type); - IP_SET_TYPE_VAL(pcb->remote_ip, type); - } -#else - LWIP_UNUSED_ARG(type); -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - return pcb; -} - -/** - * @ingroup tcp_raw - * Specifies the program specific state that should be passed to all - * other callback functions. The "pcb" argument is the current TCP - * connection control block, and the "arg" argument is the argument - * that will be passed to the callbacks. - * - * @param pcb tcp_pcb to set the callback argument - * @param arg void pointer argument to pass to callback functions - */ -void -tcp_arg(struct tcp_pcb *pcb, void *arg) -{ - LWIP_ASSERT_CORE_LOCKED(); - /* This function is allowed to be called for both listen pcbs and - connection pcbs. */ - if (pcb != NULL) { - pcb->callback_arg = arg; - } -} -#if LWIP_CALLBACK_API - -/** - * @ingroup tcp_raw - * Sets the callback function that will be called when new data - * arrives. The callback function will be passed a NULL pbuf to - * indicate that the remote host has closed the connection. If the - * callback function returns ERR_OK or ERR_ABRT it must have - * freed the pbuf, otherwise it must not have freed it. - * - * @param pcb tcp_pcb to set the recv callback - * @param recv callback function to call for this pcb when data is received - */ -void -tcp_recv(struct tcp_pcb *pcb, tcp_recv_fn recv) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (pcb != NULL) { - LWIP_ASSERT("invalid socket state for recv callback", pcb->state != LISTEN); - pcb->recv = recv; - } -} - -/** - * @ingroup tcp_raw - * Specifies the callback function that should be called when data has - * successfully been received (i.e., acknowledged) by the remote - * host. The len argument passed to the callback function gives the - * amount bytes that was acknowledged by the last acknowledgment. - * - * @param pcb tcp_pcb to set the sent callback - * @param sent callback function to call for this pcb when data is successfully sent - */ -void -tcp_sent(struct tcp_pcb *pcb, tcp_sent_fn sent) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (pcb != NULL) { - LWIP_ASSERT("invalid socket state for sent callback", pcb->state != LISTEN); - pcb->sent = sent; - } -} - -/** - * @ingroup tcp_raw - * Used to specify the function that should be called when a fatal error - * has occurred on the connection. - * - * If a connection is aborted because of an error, the application is - * alerted of this event by the err callback. Errors that might abort a - * connection are when there is a shortage of memory. The callback - * function to be called is set using the tcp_err() function. - * - * @note The corresponding pcb is already freed when this callback is called! - * - * @param pcb tcp_pcb to set the err callback - * @param err callback function to call for this pcb when a fatal error - * has occurred on the connection - */ -void -tcp_err(struct tcp_pcb *pcb, tcp_err_fn err) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (pcb != NULL) { - LWIP_ASSERT("invalid socket state for err callback", pcb->state != LISTEN); - pcb->errf = err; - } -} - -/** - * @ingroup tcp_raw - * Used for specifying the function that should be called when a - * LISTENing connection has been connected to another host. - * - * @param pcb tcp_pcb to set the accept callback - * @param accept callback function to call for this pcb when LISTENing - * connection has been connected to another host - */ -void -tcp_accept(struct tcp_pcb *pcb, tcp_accept_fn accept) -{ - LWIP_ASSERT_CORE_LOCKED(); - if ((pcb != NULL) && (pcb->state == LISTEN)) { - struct tcp_pcb_listen *lpcb = (struct tcp_pcb_listen *)pcb; - lpcb->accept = accept; - } -} -#endif /* LWIP_CALLBACK_API */ - - -/** - * @ingroup tcp_raw - * Specifies the polling interval and the callback function that should - * be called to poll the application. The interval is specified in - * number of TCP coarse grained timer shots, which typically occurs - * twice a second. An interval of 10 means that the application would - * be polled every 5 seconds. - * - * When a connection is idle (i.e., no data is either transmitted or - * received), lwIP will repeatedly poll the application by calling a - * specified callback function. This can be used either as a watchdog - * timer for killing connections that have stayed idle for too long, or - * as a method of waiting for memory to become available. For instance, - * if a call to tcp_write() has failed because memory wasn't available, - * the application may use the polling functionality to call tcp_write() - * again when the connection has been idle for a while. - */ -void -tcp_poll(struct tcp_pcb *pcb, tcp_poll_fn poll, u8_t interval) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("tcp_poll: invalid pcb", pcb != NULL, return); - LWIP_ASSERT("invalid socket state for poll", pcb->state != LISTEN); - -#if LWIP_CALLBACK_API - pcb->poll = poll; -#else /* LWIP_CALLBACK_API */ - LWIP_UNUSED_ARG(poll); -#endif /* LWIP_CALLBACK_API */ - pcb->pollinterval = interval; -} - -/** - * Purges a TCP PCB. Removes any buffered data and frees the buffer memory - * (pcb->ooseq, pcb->unsent and pcb->unacked are freed). - * - * @param pcb tcp_pcb to purge. The pcb itself is not deallocated! - */ -void -tcp_pcb_purge(struct tcp_pcb *pcb) -{ - LWIP_ERROR("tcp_pcb_purge: invalid pcb", pcb != NULL, return); - - if (pcb->state != CLOSED && - pcb->state != TIME_WAIT && - pcb->state != LISTEN) { - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge\n")); - - tcp_backlog_accepted(pcb); - - if (pcb->refused_data != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->refused_data\n")); - pbuf_free(pcb->refused_data); - pcb->refused_data = NULL; - } - if (pcb->unsent != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: not all data sent\n")); - } - if (pcb->unacked != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->unacked\n")); - } -#if TCP_QUEUE_OOSEQ - if (pcb->ooseq != NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->ooseq\n")); - tcp_free_ooseq(pcb); - } -#endif /* TCP_QUEUE_OOSEQ */ - - /* Stop the retransmission timer as it will expect data on unacked - queue if it fires */ - pcb->rtime = -1; - - tcp_segs_free(pcb->unsent); - tcp_segs_free(pcb->unacked); - pcb->unacked = pcb->unsent = NULL; -#if TCP_OVERSIZE - pcb->unsent_oversize = 0; -#endif /* TCP_OVERSIZE */ - } -} - -/** - * Purges the PCB and removes it from a PCB list. Any delayed ACKs are sent first. - * - * @param pcblist PCB list to purge. - * @param pcb tcp_pcb to purge. The pcb itself is NOT deallocated! - */ -void -tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_pcb_remove: invalid pcb", pcb != NULL); - LWIP_ASSERT("tcp_pcb_remove: invalid pcblist", pcblist != NULL); - - TCP_RMV(pcblist, pcb); - - tcp_pcb_purge(pcb); - - /* if there is an outstanding delayed ACKs, send it */ - if ((pcb->state != TIME_WAIT) && - (pcb->state != LISTEN) && - (pcb->flags & TF_ACK_DELAY)) { - tcp_ack_now(pcb); - tcp_output(pcb); - } - - if (pcb->state != LISTEN) { - LWIP_ASSERT("unsent segments leaking", pcb->unsent == NULL); - LWIP_ASSERT("unacked segments leaking", pcb->unacked == NULL); -#if TCP_QUEUE_OOSEQ - LWIP_ASSERT("ooseq segments leaking", pcb->ooseq == NULL); -#endif /* TCP_QUEUE_OOSEQ */ - } - - pcb->state = CLOSED; - /* reset the local port to prevent the pcb from being 'bound' */ - pcb->local_port = 0; - - LWIP_ASSERT("tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane()); -} - -/** - * Calculates a new initial sequence number for new connections. - * - * @return u32_t pseudo random sequence number - */ -u32_t -tcp_next_iss(struct tcp_pcb *pcb) -{ -#ifdef LWIP_HOOK_TCP_ISN - LWIP_ASSERT("tcp_next_iss: invalid pcb", pcb != NULL); - return LWIP_HOOK_TCP_ISN(&pcb->local_ip, pcb->local_port, &pcb->remote_ip, pcb->remote_port); -#else /* LWIP_HOOK_TCP_ISN */ - static u32_t iss = 6510; - - LWIP_ASSERT("tcp_next_iss: invalid pcb", pcb != NULL); - LWIP_UNUSED_ARG(pcb); - - iss += tcp_ticks; /* XXX */ - return iss; -#endif /* LWIP_HOOK_TCP_ISN */ -} - -#if TCP_CALCULATE_EFF_SEND_MSS -/** - * Calculates the effective send mss that can be used for a specific IP address - * by calculating the minimum of TCP_MSS and the mtu (if set) of the target - * netif (if not NULL). - */ -u16_t -tcp_eff_send_mss_netif(u16_t sendmss, struct netif *outif, const ip_addr_t *dest) -{ - u16_t mss_s; - u16_t mtu; - - LWIP_UNUSED_ARG(dest); /* in case IPv6 is disabled */ - - LWIP_ASSERT("tcp_eff_send_mss_netif: invalid dst_ip", dest != NULL); - -#if LWIP_IPV6 -#if LWIP_IPV4 - if (IP_IS_V6(dest)) -#endif /* LWIP_IPV4 */ - { - /* First look in destination cache, to see if there is a Path MTU. */ - mtu = nd6_get_destination_mtu(ip_2_ip6(dest), outif); - } -#if LWIP_IPV4 - else -#endif /* LWIP_IPV4 */ -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 - { - if (outif == NULL) { - return sendmss; - } - mtu = outif->mtu; - } -#endif /* LWIP_IPV4 */ - - if (mtu != 0) { - u16_t offset; -#if LWIP_IPV6 -#if LWIP_IPV4 - if (IP_IS_V6(dest)) -#endif /* LWIP_IPV4 */ - { - offset = IP6_HLEN + TCP_HLEN; - } -#if LWIP_IPV4 - else -#endif /* LWIP_IPV4 */ -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 - { - offset = IP_HLEN + TCP_HLEN; - } -#endif /* LWIP_IPV4 */ - mss_s = (mtu > offset) ? (u16_t)(mtu - offset) : 0; - /* RFC 1122, chap 4.2.2.6: - * Eff.snd.MSS = min(SendMSS+20, MMS_S) - TCPhdrsize - IPoptionsize - * We correct for TCP options in tcp_write(), and don't support IP options. - */ - sendmss = LWIP_MIN(sendmss, mss_s); - } - return sendmss; -} -#endif /* TCP_CALCULATE_EFF_SEND_MSS */ - -/** Helper function for tcp_netif_ip_addr_changed() that iterates a pcb list */ -static void -tcp_netif_ip_addr_changed_pcblist(const ip_addr_t *old_addr, struct tcp_pcb *pcb_list) -{ - struct tcp_pcb *pcb; - pcb = pcb_list; - - LWIP_ASSERT("tcp_netif_ip_addr_changed_pcblist: invalid old_addr", old_addr != NULL); - - while (pcb != NULL) { - /* PCB bound to current local interface address? */ - if (ip_addr_cmp(&pcb->local_ip, old_addr) -#if LWIP_AUTOIP - /* connections to link-local addresses must persist (RFC3927 ch. 1.9) */ - && (!IP_IS_V4_VAL(pcb->local_ip) || !ip4_addr_islinklocal(ip_2_ip4(&pcb->local_ip))) -#endif /* LWIP_AUTOIP */ - ) { - /* this connection must be aborted */ - struct tcp_pcb *next = pcb->next; - LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: aborting TCP pcb %p\n", (void *)pcb)); - tcp_abort(pcb); - pcb = next; - } else { - pcb = pcb->next; - } - } -} - -/** This function is called from netif.c when address is changed or netif is removed - * - * @param old_addr IP address of the netif before change - * @param new_addr IP address of the netif after change or NULL if netif has been removed - */ -void -tcp_netif_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) -{ - struct tcp_pcb_listen *lpcb; - - if (!ip_addr_isany(old_addr)) { - tcp_netif_ip_addr_changed_pcblist(old_addr, tcp_active_pcbs); - tcp_netif_ip_addr_changed_pcblist(old_addr, tcp_bound_pcbs); - - if (!ip_addr_isany(new_addr)) { - /* PCB bound to current local interface address? */ - for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) { - /* PCB bound to current local interface address? */ - if (ip_addr_cmp(&lpcb->local_ip, old_addr)) { - /* The PCB is listening to the old ipaddr and - * is set to listen to the new one instead */ - ip_addr_copy(lpcb->local_ip, *new_addr); - } - } - } - } -} - -const char * -tcp_debug_state_str(enum tcp_state s) -{ - return tcp_state_str[s]; -} - -err_t -tcp_tcp_get_tcp_addrinfo(struct tcp_pcb *pcb, int local, ip_addr_t *addr, u16_t *port) -{ - if (pcb) { - if (local) { - if (addr) { - *addr = pcb->local_ip; - } - if (port) { - *port = pcb->local_port; - } - } else { - if (addr) { - *addr = pcb->remote_ip; - } - if (port) { - *port = pcb->remote_port; - } - } - return ERR_OK; - } - return ERR_VAL; -} - -#if TCP_QUEUE_OOSEQ -/* Free all ooseq pbufs (and possibly reset SACK state) */ -void -tcp_free_ooseq(struct tcp_pcb *pcb) -{ - if (pcb->ooseq) { - tcp_segs_free(pcb->ooseq); - pcb->ooseq = NULL; -#if LWIP_TCP_SACK_OUT - memset(pcb->rcv_sacks, 0, sizeof(pcb->rcv_sacks)); -#endif /* LWIP_TCP_SACK_OUT */ - } -} -#endif /* TCP_QUEUE_OOSEQ */ - -#if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG -/** - * Print a tcp header for debugging purposes. - * - * @param tcphdr pointer to a struct tcp_hdr - */ -void -tcp_debug_print(struct tcp_hdr *tcphdr) -{ - LWIP_DEBUGF(TCP_DEBUG, ("TCP header:\n")); - LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(TCP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n", - lwip_ntohs(tcphdr->src), lwip_ntohs(tcphdr->dest))); - LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (seq no)\n", - lwip_ntohl(tcphdr->seqno))); - LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (ack no)\n", - lwip_ntohl(tcphdr->ackno))); - LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(TCP_DEBUG, ("| %2"U16_F" | |%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"| %5"U16_F" | (hdrlen, flags (", - TCPH_HDRLEN(tcphdr), - (u16_t)(TCPH_FLAGS(tcphdr) >> 5 & 1), - (u16_t)(TCPH_FLAGS(tcphdr) >> 4 & 1), - (u16_t)(TCPH_FLAGS(tcphdr) >> 3 & 1), - (u16_t)(TCPH_FLAGS(tcphdr) >> 2 & 1), - (u16_t)(TCPH_FLAGS(tcphdr) >> 1 & 1), - (u16_t)(TCPH_FLAGS(tcphdr) & 1), - lwip_ntohs(tcphdr->wnd))); - tcp_debug_print_flags(TCPH_FLAGS(tcphdr)); - LWIP_DEBUGF(TCP_DEBUG, ("), win)\n")); - LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(TCP_DEBUG, ("| 0x%04"X16_F" | %5"U16_F" | (chksum, urgp)\n", - lwip_ntohs(tcphdr->chksum), lwip_ntohs(tcphdr->urgp))); - LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); -} - -/** - * Print a tcp state for debugging purposes. - * - * @param s enum tcp_state to print - */ -void -tcp_debug_print_state(enum tcp_state s) -{ - LWIP_DEBUGF(TCP_DEBUG, ("State: %s\n", tcp_state_str[s])); -} - -/** - * Print tcp flags for debugging purposes. - * - * @param flags tcp flags, all active flags are printed - */ -void -tcp_debug_print_flags(u8_t flags) -{ - if (flags & TCP_FIN) { - LWIP_DEBUGF(TCP_DEBUG, ("FIN ")); - } - if (flags & TCP_SYN) { - LWIP_DEBUGF(TCP_DEBUG, ("SYN ")); - } - if (flags & TCP_RST) { - LWIP_DEBUGF(TCP_DEBUG, ("RST ")); - } - if (flags & TCP_PSH) { - LWIP_DEBUGF(TCP_DEBUG, ("PSH ")); - } - if (flags & TCP_ACK) { - LWIP_DEBUGF(TCP_DEBUG, ("ACK ")); - } - if (flags & TCP_URG) { - LWIP_DEBUGF(TCP_DEBUG, ("URG ")); - } - if (flags & TCP_ECE) { - LWIP_DEBUGF(TCP_DEBUG, ("ECE ")); - } - if (flags & TCP_CWR) { - LWIP_DEBUGF(TCP_DEBUG, ("CWR ")); - } - LWIP_DEBUGF(TCP_DEBUG, ("\n")); -} - -/** - * Print all tcp_pcbs in every list for debugging purposes. - */ -void -tcp_debug_print_pcbs(void) -{ - struct tcp_pcb *pcb; - struct tcp_pcb_listen *pcbl; - - LWIP_DEBUGF(TCP_DEBUG, ("Active PCB states:\n")); - for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { - LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ", - pcb->local_port, pcb->remote_port, - pcb->snd_nxt, pcb->rcv_nxt)); - tcp_debug_print_state(pcb->state); - } - - LWIP_DEBUGF(TCP_DEBUG, ("Listen PCB states:\n")); - for (pcbl = tcp_listen_pcbs.listen_pcbs; pcbl != NULL; pcbl = pcbl->next) { - LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F" ", pcbl->local_port)); - tcp_debug_print_state(pcbl->state); - } - - LWIP_DEBUGF(TCP_DEBUG, ("TIME-WAIT PCB states:\n")); - for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { - LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ", - pcb->local_port, pcb->remote_port, - pcb->snd_nxt, pcb->rcv_nxt)); - tcp_debug_print_state(pcb->state); - } -} - -/** - * Check state consistency of the tcp_pcb lists. - */ -s16_t -tcp_pcbs_sane(void) -{ - struct tcp_pcb *pcb; - for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { - LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED); - LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN); - LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT); - } - for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { - LWIP_ASSERT("tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT); - } - return 1; -} -#endif /* TCP_DEBUG */ - -#if LWIP_TCP_PCB_NUM_EXT_ARGS -/** - * @defgroup tcp_raw_extargs ext arguments - * @ingroup tcp_raw - * Additional data storage per tcp pcb\n - * @see @ref tcp_raw - * - * When LWIP_TCP_PCB_NUM_EXT_ARGS is > 0, every tcp pcb (including listen pcb) - * includes a number of additional argument entries in an array. - * - * To support memory management, in addition to a 'void *', callbacks can be - * provided to manage transition from listening pcbs to connections and to - * deallocate memory when a pcb is deallocated (see struct @ref tcp_ext_arg_callbacks). - * - * After allocating this index, use @ref tcp_ext_arg_set and @ref tcp_ext_arg_get - * to store and load arguments from this index for a given pcb. - */ - -static u8_t tcp_ext_arg_id; - -/** - * @ingroup tcp_raw_extargs - * Allocate an index to store data in ext_args member of struct tcp_pcb. - * Returned value is an index in mentioned array. - * The index is *global* over all pcbs! - * - * When @ref LWIP_TCP_PCB_NUM_EXT_ARGS is > 0, every tcp pcb (including listen pcb) - * includes a number of additional argument entries in an array. - * - * To support memory management, in addition to a 'void *', callbacks can be - * provided to manage transition from listening pcbs to connections and to - * deallocate memory when a pcb is deallocated (see struct @ref tcp_ext_arg_callbacks). - * - * After allocating this index, use @ref tcp_ext_arg_set and @ref tcp_ext_arg_get - * to store and load arguments from this index for a given pcb. - * - * @return a unique index into struct tcp_pcb.ext_args - */ -u8_t -tcp_ext_arg_alloc_id(void) -{ - u8_t result = tcp_ext_arg_id; - tcp_ext_arg_id++; - - LWIP_ASSERT_CORE_LOCKED(); - -#if LWIP_TCP_PCB_NUM_EXT_ARGS >= 255 -#error LWIP_TCP_PCB_NUM_EXT_ARGS -#endif - LWIP_ASSERT("Increase LWIP_TCP_PCB_NUM_EXT_ARGS in lwipopts.h", result < LWIP_TCP_PCB_NUM_EXT_ARGS); - return result; -} - -/** - * @ingroup tcp_raw_extargs - * Set callbacks for a given index of ext_args on the specified pcb. - * - * @param pcb tcp_pcb for which to set the callback - * @param id ext_args index to set (allocated via @ref tcp_ext_arg_alloc_id) - * @param callbacks callback table (const since it is referenced, not copied!) - */ -void -tcp_ext_arg_set_callbacks(struct tcp_pcb *pcb, uint8_t id, const struct tcp_ext_arg_callbacks * const callbacks) -{ - LWIP_ASSERT("pcb != NULL", pcb != NULL); - LWIP_ASSERT("id < LWIP_TCP_PCB_NUM_EXT_ARGS", id < LWIP_TCP_PCB_NUM_EXT_ARGS); - LWIP_ASSERT("callbacks != NULL", callbacks != NULL); - - LWIP_ASSERT_CORE_LOCKED(); - - pcb->ext_args[id].callbacks = callbacks; -} - -/** - * @ingroup tcp_raw_extargs - * Set data for a given index of ext_args on the specified pcb. - * - * @param pcb tcp_pcb for which to set the data - * @param id ext_args index to set (allocated via @ref tcp_ext_arg_alloc_id) - * @param arg data pointer to set - */ -void tcp_ext_arg_set(struct tcp_pcb *pcb, uint8_t id, void *arg) -{ - LWIP_ASSERT("pcb != NULL", pcb != NULL); - LWIP_ASSERT("id < LWIP_TCP_PCB_NUM_EXT_ARGS", id < LWIP_TCP_PCB_NUM_EXT_ARGS); - - LWIP_ASSERT_CORE_LOCKED(); - - pcb->ext_args[id].data = arg; -} - -/** - * @ingroup tcp_raw_extargs - * Set data for a given index of ext_args on the specified pcb. - * - * @param pcb tcp_pcb for which to set the data - * @param id ext_args index to set (allocated via @ref tcp_ext_arg_alloc_id) - * @return data pointer at the given index - */ -void *tcp_ext_arg_get(const struct tcp_pcb *pcb, uint8_t id) -{ - LWIP_ASSERT("pcb != NULL", pcb != NULL); - LWIP_ASSERT("id < LWIP_TCP_PCB_NUM_EXT_ARGS", id < LWIP_TCP_PCB_NUM_EXT_ARGS); - - LWIP_ASSERT_CORE_LOCKED(); - - return pcb->ext_args[id].data; -} - -/** This function calls the "destroy" callback for all ext_args once a pcb is - * freed. - */ -static void -tcp_ext_arg_invoke_callbacks_destroyed(struct tcp_pcb_ext_args *ext_args) -{ - int i; - LWIP_ASSERT("ext_args != NULL", ext_args != NULL); - - for (i = 0; i < LWIP_TCP_PCB_NUM_EXT_ARGS; i++) { - if (ext_args[i].callbacks != NULL) { - if (ext_args[i].callbacks->destroy != NULL) { - ext_args[i].callbacks->destroy((u8_t)i, ext_args[i].data); - } - } - } -} - -/** This function calls the "passive_open" callback for all ext_args if a connection - * is in the process of being accepted. This is called just after the SYN is - * received and before a SYN/ACK is sent, to allow to modify the very first - * segment sent even on passive open. Naturally, the "accepted" callback of the - * pcb has not been called yet! - */ -err_t -tcp_ext_arg_invoke_callbacks_passive_open(struct tcp_pcb_listen *lpcb, struct tcp_pcb *cpcb) -{ - int i; - LWIP_ASSERT("lpcb != NULL", lpcb != NULL); - LWIP_ASSERT("cpcb != NULL", cpcb != NULL); - - for (i = 0; i < LWIP_TCP_PCB_NUM_EXT_ARGS; i++) { - if (lpcb->ext_args[i].callbacks != NULL) { - if (lpcb->ext_args[i].callbacks->passive_open != NULL) { - err_t err = lpcb->ext_args[i].callbacks->passive_open((u8_t)i, lpcb, cpcb); - if (err != ERR_OK) { - return err; - } - } - } - } - return ERR_OK; -} -#endif /* LWIP_TCP_PCB_NUM_EXT_ARGS */ - -#endif /* LWIP_TCP */ +/** + * @file + * Transmission Control Protocol for IP + * See also @ref tcp_raw + * + * @defgroup tcp_raw TCP + * @ingroup callbackstyle_api + * Transmission Control Protocol for IP\n + * @see @ref api + * + * Common functions for the TCP implementation, such as functions + * for manipulating the data structures and the TCP timer functions. TCP functions + * related to input and output is found in tcp_in.c and tcp_out.c respectively.\n + * + * TCP connection setup + * -------------------- + * The functions used for setting up connections is similar to that of + * the sequential API and of the BSD socket API. A new TCP connection + * identifier (i.e., a protocol control block - PCB) is created with the + * tcp_new() function. This PCB can then be either set to listen for new + * incoming connections or be explicitly connected to another host. + * - tcp_new() + * - tcp_bind() + * - tcp_listen() and tcp_listen_with_backlog() + * - tcp_accept() + * - tcp_connect() + * + * Sending TCP data + * ---------------- + * TCP data is sent by enqueueing the data with a call to tcp_write() and + * triggering to send by calling tcp_output(). When the data is successfully + * transmitted to the remote host, the application will be notified with a + * call to a specified callback function. + * - tcp_write() + * - tcp_output() + * - tcp_sent() + * + * Receiving TCP data + * ------------------ + * TCP data reception is callback based - an application specified + * callback function is called when new data arrives. When the + * application has taken the data, it has to call the tcp_recved() + * function to indicate that TCP can advertise increase the receive + * window. + * - tcp_recv() + * - tcp_recved() + * + * Application polling + * ------------------- + * When a connection is idle (i.e., no data is either transmitted or + * received), lwIP will repeatedly poll the application by calling a + * specified callback function. This can be used either as a watchdog + * timer for killing connections that have stayed idle for too long, or + * as a method of waiting for memory to become available. For instance, + * if a call to tcp_write() has failed because memory wasn't available, + * the application may use the polling functionality to call tcp_write() + * again when the connection has been idle for a while. + * - tcp_poll() + * + * Closing and aborting connections + * -------------------------------- + * - tcp_close() + * - tcp_abort() + * - tcp_err() + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/tcp.h" +#include "lwip/priv/tcp_priv.h" +#include "lwip/debug.h" +#include "lwip/stats.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/nd6.h" + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +#ifndef TCP_LOCAL_PORT_RANGE_START +/* From http://www.iana.org/assignments/port-numbers: + "The Dynamic and/or Private Ports are those from 49152 through 65535" */ +#define TCP_LOCAL_PORT_RANGE_START 0xc000 +#define TCP_LOCAL_PORT_RANGE_END 0xffff +#define TCP_ENSURE_LOCAL_PORT_RANGE(port) ((u16_t)(((port) & (u16_t)~TCP_LOCAL_PORT_RANGE_START) + TCP_LOCAL_PORT_RANGE_START)) +#endif + +#if LWIP_TCP_KEEPALIVE +#define TCP_KEEP_DUR(pcb) ((pcb)->keep_cnt * (pcb)->keep_intvl) +#define TCP_KEEP_INTVL(pcb) ((pcb)->keep_intvl) +#else /* LWIP_TCP_KEEPALIVE */ +#define TCP_KEEP_DUR(pcb) TCP_MAXIDLE +#define TCP_KEEP_INTVL(pcb) TCP_KEEPINTVL_DEFAULT +#endif /* LWIP_TCP_KEEPALIVE */ + +/* As initial send MSS, we use TCP_MSS but limit it to 536. */ +#if TCP_MSS > 536 +#define INITIAL_MSS 536 +#else +#define INITIAL_MSS TCP_MSS +#endif + +static 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" +}; + +/* last local TCP port */ +static u16_t tcp_port = TCP_LOCAL_PORT_RANGE_START; + +/* Incremented every coarse grained timer shot (typically every 500 ms). */ +u32_t tcp_ticks; +static const u8_t tcp_backoff[13] = +{ 1, 2, 3, 4, 5, 6, 7, 7, 7, 7, 7, 7, 7}; +/* Times per slowtmr hits */ +static const u8_t tcp_persist_backoff[7] = { 3, 6, 12, 24, 48, 96, 120 }; + +/* The TCP PCB lists. */ + +/** List of all TCP PCBs bound but not yet (connected || listening) */ +struct tcp_pcb *tcp_bound_pcbs; +/** List of all TCP PCBs in LISTEN state */ +union tcp_listen_pcbs_t tcp_listen_pcbs; +/** List of all TCP PCBs that are in a state in which + * they accept or send data. */ +struct tcp_pcb *tcp_active_pcbs; +/** List of all TCP PCBs in TIME-WAIT state */ +struct tcp_pcb *tcp_tw_pcbs; + +/** An array with all (non-temporary) PCB lists, mainly used for smaller code size */ +struct tcp_pcb **const tcp_pcb_lists[] = {&tcp_listen_pcbs.pcbs, &tcp_bound_pcbs, + &tcp_active_pcbs, &tcp_tw_pcbs +}; + +u8_t tcp_active_pcbs_changed; + +/** Timer counter to handle calling slow-timer from tcp_tmr() */ +static u8_t tcp_timer; +static u8_t tcp_timer_ctr; +static u16_t tcp_new_port(void); + +static err_t tcp_close_shutdown_fin(struct tcp_pcb *pcb); +#if LWIP_TCP_PCB_NUM_EXT_ARGS +static void tcp_ext_arg_invoke_callbacks_destroyed(struct tcp_pcb_ext_args *ext_args); +#endif + +/** + * Initialize this module. + */ +void +tcp_init(void) +{ +#ifdef LWIP_RAND + tcp_port = TCP_ENSURE_LOCAL_PORT_RANGE(LWIP_RAND()); +#endif /* LWIP_RAND */ +} + +/** Free a tcp pcb */ +void +tcp_free(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_free: LISTEN", pcb->state != LISTEN); +#if LWIP_TCP_PCB_NUM_EXT_ARGS + tcp_ext_arg_invoke_callbacks_destroyed(pcb->ext_args); +#endif + memp_free(MEMP_TCP_PCB, pcb); +} + +/** Free a tcp listen pcb */ +static void +tcp_free_listen(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_free_listen: !LISTEN", pcb->state != LISTEN); +#if LWIP_TCP_PCB_NUM_EXT_ARGS + tcp_ext_arg_invoke_callbacks_destroyed(pcb->ext_args); +#endif + memp_free(MEMP_TCP_PCB_LISTEN, pcb); +} + +/** + * Called periodically to dispatch TCP timers. + */ +void +tcp_tmr(void) +{ + /* Call tcp_fasttmr() every 250 ms */ + tcp_fasttmr(); + + if (++tcp_timer & 1) { + /* Call tcp_slowtmr() every 500 ms, i.e., every other timer + tcp_tmr() is called. */ + tcp_slowtmr(); + } +} + +#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG +/** Called when a listen pcb is closed. Iterates one pcb list and removes the + * closed listener pcb from pcb->listener if matching. + */ +static void +tcp_remove_listener(struct tcp_pcb *list, struct tcp_pcb_listen *lpcb) +{ + struct tcp_pcb *pcb; + + LWIP_ASSERT("tcp_remove_listener: invalid listener", lpcb != NULL); + + for (pcb = list; pcb != NULL; pcb = pcb->next) { + if (pcb->listener == lpcb) { + pcb->listener = NULL; + } + } +} +#endif + +/** Called when a listen pcb is closed. Iterates all pcb lists and removes the + * closed listener pcb from pcb->listener if matching. + */ +static void +tcp_listen_closed(struct tcp_pcb *pcb) +{ +#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG + size_t i; + LWIP_ASSERT("pcb != NULL", pcb != NULL); + LWIP_ASSERT("pcb->state == LISTEN", pcb->state == LISTEN); + for (i = 1; i < LWIP_ARRAYSIZE(tcp_pcb_lists); i++) { + tcp_remove_listener(*tcp_pcb_lists[i], (struct tcp_pcb_listen *)pcb); + } +#endif + LWIP_UNUSED_ARG(pcb); +} + +#if TCP_LISTEN_BACKLOG +/** @ingroup tcp_raw + * Delay accepting a connection in respect to the listen backlog: + * the number of outstanding connections is increased until + * tcp_backlog_accepted() is called. + * + * ATTENTION: the caller is responsible for calling tcp_backlog_accepted() + * or else the backlog feature will get out of sync! + * + * @param pcb the connection pcb which is not fully accepted yet + */ +void +tcp_backlog_delayed(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("pcb != NULL", pcb != NULL); + LWIP_ASSERT_CORE_LOCKED(); + if ((pcb->flags & TF_BACKLOGPEND) == 0) { + if (pcb->listener != NULL) { + pcb->listener->accepts_pending++; + LWIP_ASSERT("accepts_pending != 0", pcb->listener->accepts_pending != 0); + tcp_set_flags(pcb, TF_BACKLOGPEND); + } + } +} + +/** @ingroup tcp_raw + * A delayed-accept a connection is accepted (or closed/aborted): decreases + * the number of outstanding connections after calling tcp_backlog_delayed(). + * + * ATTENTION: the caller is responsible for calling tcp_backlog_accepted() + * or else the backlog feature will get out of sync! + * + * @param pcb the connection pcb which is now fully accepted (or closed/aborted) + */ +void +tcp_backlog_accepted(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("pcb != NULL", pcb != NULL); + LWIP_ASSERT_CORE_LOCKED(); + if ((pcb->flags & TF_BACKLOGPEND) != 0) { + if (pcb->listener != NULL) { + LWIP_ASSERT("accepts_pending != 0", pcb->listener->accepts_pending != 0); + pcb->listener->accepts_pending--; + tcp_clear_flags(pcb, TF_BACKLOGPEND); + } + } +} +#endif /* TCP_LISTEN_BACKLOG */ + +/** + * Closes the TX side of a connection held by the PCB. + * For tcp_close(), a RST is sent if the application didn't receive all data + * (tcp_recved() not called for all data passed to recv callback). + * + * Listening pcbs are freed and may not be referenced any more. + * Connection pcbs are freed if not yet connected and may not be referenced + * any more. If a connection is established (at least SYN received or in + * a closing state), the connection is closed, and put in a closing state. + * The pcb is then automatically freed in tcp_slowtmr(). It is therefore + * unsafe to reference it. + * + * @param pcb the tcp_pcb to close + * @return ERR_OK if connection has been closed + * another err_t if closing failed and pcb is not freed + */ +static err_t +tcp_close_shutdown(struct tcp_pcb *pcb, u8_t rst_on_unacked_data) +{ + LWIP_ASSERT("tcp_close_shutdown: invalid pcb", pcb != NULL); + + if (rst_on_unacked_data && ((pcb->state == ESTABLISHED) || (pcb->state == CLOSE_WAIT))) { + if ((pcb->refused_data != NULL) || (pcb->rcv_wnd != TCP_WND_MAX(pcb))) { + /* Not all data received by application, send RST to tell the remote + side about this. */ + LWIP_ASSERT("pcb->flags & TF_RXCLOSED", pcb->flags & TF_RXCLOSED); + + /* don't call tcp_abort here: we must not deallocate the pcb since + that might not be expected when calling tcp_close */ + tcp_rst(pcb, pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip, + pcb->local_port, pcb->remote_port); + + tcp_pcb_purge(pcb); + TCP_RMV_ACTIVE(pcb); + /* Deallocate the pcb since we already sent a RST for it */ + if (tcp_input_pcb == pcb) { + /* prevent using a deallocated pcb: free it from tcp_input later */ + tcp_trigger_input_pcb_close(); + } else { + tcp_free(pcb); + } + return ERR_OK; + } + } + + /* - states which free the pcb are handled here, + - states which send FIN and change state are handled in tcp_close_shutdown_fin() */ + switch (pcb->state) { + case CLOSED: + /* Closing a pcb in the CLOSED state might seem erroneous, + * however, it is in this state once allocated and as yet unused + * and the user needs some way to free it should the need arise. + * Calling tcp_close() with a pcb that has already been closed, (i.e. twice) + * or for a pcb that has been used and then entered the CLOSED state + * is erroneous, but this should never happen as the pcb has in those cases + * been freed, and so any remaining handles are bogus. */ + if (pcb->local_port != 0) { + TCP_RMV(&tcp_bound_pcbs, pcb); + } + tcp_free(pcb); + break; + case LISTEN: + tcp_listen_closed(pcb); + tcp_pcb_remove(&tcp_listen_pcbs.pcbs, pcb); + tcp_free_listen(pcb); + break; + case SYN_SENT: + TCP_PCB_REMOVE_ACTIVE(pcb); + tcp_free(pcb); + MIB2_STATS_INC(mib2.tcpattemptfails); + break; + default: + return tcp_close_shutdown_fin(pcb); + } + return ERR_OK; +} + +static err_t +tcp_close_shutdown_fin(struct tcp_pcb *pcb) +{ + err_t err; + LWIP_ASSERT("pcb != NULL", pcb != NULL); + + switch (pcb->state) { + case SYN_RCVD: + err = tcp_send_fin(pcb); + if (err == ERR_OK) { + tcp_backlog_accepted(pcb); + MIB2_STATS_INC(mib2.tcpattemptfails); + pcb->state = FIN_WAIT_1; + } + break; + case ESTABLISHED: + err = tcp_send_fin(pcb); + if (err == ERR_OK) { + MIB2_STATS_INC(mib2.tcpestabresets); + pcb->state = FIN_WAIT_1; + } + break; + case CLOSE_WAIT: + err = tcp_send_fin(pcb); + if (err == ERR_OK) { + MIB2_STATS_INC(mib2.tcpestabresets); + pcb->state = LAST_ACK; + } + break; + default: + /* Has already been closed, do nothing. */ + return ERR_OK; + } + + if (err == ERR_OK) { + /* To ensure all data has been sent when tcp_close returns, we have + to make sure tcp_output doesn't fail. + Since we don't really have to ensure all data has been sent when tcp_close + returns (unsent data is sent from tcp timer functions, also), we don't care + for the return value of tcp_output for now. */ + tcp_output(pcb); + } else if (err == ERR_MEM) { + /* Mark this pcb for closing. Closing is retried from tcp_tmr. */ + tcp_set_flags(pcb, TF_CLOSEPEND); + /* We have to return ERR_OK from here to indicate to the callers that this + pcb should not be used any more as it will be freed soon via tcp_tmr. + This is OK here since sending FIN does not guarantee a time frime for + actually freeing the pcb, either (it is left in closure states for + remote ACK or timeout) */ + return ERR_OK; + } + return err; +} + +/** + * @ingroup tcp_raw + * Closes the connection held by the PCB. + * + * Listening pcbs are freed and may not be referenced any more. + * Connection pcbs are freed if not yet connected and may not be referenced + * any more. If a connection is established (at least SYN received or in + * a closing state), the connection is closed, and put in a closing state. + * The pcb is then automatically freed in tcp_slowtmr(). It is therefore + * unsafe to reference it (unless an error is returned). + * + * The function may return ERR_MEM if no memory + * was available for closing the connection. If so, the application + * should wait and try again either by using the acknowledgment + * callback or the polling functionality. If the close succeeds, the + * function returns ERR_OK. + * + * @param pcb the tcp_pcb to close + * @return ERR_OK if connection has been closed + * another err_t if closing failed and pcb is not freed + */ +err_t +tcp_close(struct tcp_pcb *pcb) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_close: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_DEBUGF(TCP_DEBUG, ("tcp_close: closing in ")); + + tcp_debug_print_state(pcb->state); + + if (pcb->state != LISTEN) { + /* Set a flag not to receive any more data... */ + tcp_set_flags(pcb, TF_RXCLOSED); + } + /* ... and close */ + return tcp_close_shutdown(pcb, 1); +} + +/** + * @ingroup tcp_raw + * Causes all or part of a full-duplex connection of this PCB to be shut down. + * This doesn't deallocate the PCB unless shutting down both sides! + * Shutting down both sides is the same as calling tcp_close, so if it succeds + * (i.e. returns ER_OK), the PCB must not be referenced any more! + * + * @param pcb PCB to shutdown + * @param shut_rx shut down receive side if this is != 0 + * @param shut_tx shut down send side if this is != 0 + * @return ERR_OK if shutdown succeeded (or the PCB has already been shut down) + * another err_t on error. + */ +err_t +tcp_shutdown(struct tcp_pcb *pcb, int shut_rx, int shut_tx) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_shutdown: invalid pcb", pcb != NULL, return ERR_ARG); + + if (pcb->state == LISTEN) { + return ERR_CONN; + } + if (shut_rx) { + /* shut down the receive side: set a flag not to receive any more data... */ + tcp_set_flags(pcb, TF_RXCLOSED); + if (shut_tx) { + /* shutting down the tx AND rx side is the same as closing for the raw API */ + return tcp_close_shutdown(pcb, 1); + } + /* ... and free buffered data */ + if (pcb->refused_data != NULL) { + pbuf_free(pcb->refused_data); + pcb->refused_data = NULL; + } + } + if (shut_tx) { + /* This can't happen twice since if it succeeds, the pcb's state is changed. + Only close in these states as the others directly deallocate the PCB */ + switch (pcb->state) { + case SYN_RCVD: + case ESTABLISHED: + case CLOSE_WAIT: + return tcp_close_shutdown(pcb, (u8_t)shut_rx); + default: + /* Not (yet?) connected, cannot shutdown the TX side as that would bring us + into CLOSED state, where the PCB is deallocated. */ + return ERR_CONN; + } + } + return ERR_OK; +} + +/** + * Abandons a connection and optionally sends a RST to the remote + * host. Deletes the local protocol control block. This is done when + * a connection is killed because of shortage of memory. + * + * @param pcb the tcp_pcb to abort + * @param reset boolean to indicate whether a reset should be sent + */ +void +tcp_abandon(struct tcp_pcb *pcb, int reset) +{ + u32_t seqno, ackno; +#if LWIP_CALLBACK_API + tcp_err_fn errf; +#endif /* LWIP_CALLBACK_API */ + void *errf_arg; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_abandon: invalid pcb", pcb != NULL, return); + + /* pcb->state LISTEN not allowed here */ + LWIP_ASSERT("don't call tcp_abort/tcp_abandon for listen-pcbs", + pcb->state != LISTEN); + /* Figure out on which TCP PCB list we are, and remove us. If we + are in an active state, call the receive function associated with + the PCB with a NULL argument, and send an RST to the remote end. */ + if (pcb->state == TIME_WAIT) { + tcp_pcb_remove(&tcp_tw_pcbs, pcb); + tcp_free(pcb); + } else { + int send_rst = 0; + u16_t local_port = 0; + enum tcp_state last_state; + seqno = pcb->snd_nxt; + ackno = pcb->rcv_nxt; +#if LWIP_CALLBACK_API + errf = pcb->errf; +#endif /* LWIP_CALLBACK_API */ + errf_arg = pcb->callback_arg; + if (pcb->state == CLOSED) { + if (pcb->local_port != 0) { + /* bound, not yet opened */ + TCP_RMV(&tcp_bound_pcbs, pcb); + } + } else { + send_rst = reset; + local_port = pcb->local_port; + TCP_PCB_REMOVE_ACTIVE(pcb); + } + if (pcb->unacked != NULL) { + tcp_segs_free(pcb->unacked); + } + if (pcb->unsent != NULL) { + tcp_segs_free(pcb->unsent); + } +#if TCP_QUEUE_OOSEQ + if (pcb->ooseq != NULL) { + tcp_segs_free(pcb->ooseq); + } +#endif /* TCP_QUEUE_OOSEQ */ + tcp_backlog_accepted(pcb); + if (send_rst) { + LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_abandon: sending RST\n")); + tcp_rst(pcb, seqno, ackno, &pcb->local_ip, &pcb->remote_ip, local_port, pcb->remote_port); + } + last_state = pcb->state; + tcp_free(pcb); + TCP_EVENT_ERR(last_state, errf, errf_arg, ERR_ABRT); + } +} + +/** + * @ingroup tcp_raw + * Aborts the connection by sending a RST (reset) segment to the remote + * host. The pcb is deallocated. This function never fails. + * + * ATTENTION: When calling this from one of the TCP callbacks, make + * sure you always return ERR_ABRT (and never return ERR_ABRT otherwise + * or you will risk accessing deallocated memory or memory leaks! + * + * @param pcb the tcp pcb to abort + */ +void +tcp_abort(struct tcp_pcb *pcb) +{ + tcp_abandon(pcb, 1); +} + +/** + * @ingroup tcp_raw + * Binds the connection to a local port number and IP address. If the + * IP address is not given (i.e., ipaddr == IP_ANY_TYPE), the connection is + * bound to all local IP addresses. + * If another connection is bound to the same port, the function will + * return ERR_USE, otherwise ERR_OK is returned. + * + * @param pcb the tcp_pcb to bind (no check is done whether this pcb is + * already bound!) + * @param ipaddr the local ip address to bind to (use IPx_ADDR_ANY to bind + * to any local address + * @param port the local port to bind to + * @return ERR_USE if the port is already in use + * ERR_VAL if bind failed because the PCB is not in a valid state + * ERR_OK if bound + */ +err_t +tcp_bind(struct tcp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port) +{ + int i; + int max_pcb_list = NUM_TCP_PCB_LISTS; + struct tcp_pcb *cpcb; +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + ip_addr_t zoned_ipaddr; +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + + LWIP_ASSERT_CORE_LOCKED(); + +#if LWIP_IPV4 + /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ + if (ipaddr == NULL) { + ipaddr = IP4_ADDR_ANY; + } +#else /* LWIP_IPV4 */ + LWIP_ERROR("tcp_bind: invalid ipaddr", ipaddr != NULL, return ERR_ARG); +#endif /* LWIP_IPV4 */ + + LWIP_ERROR("tcp_bind: invalid pcb", pcb != NULL, return ERR_ARG); + + LWIP_ERROR("tcp_bind: can only bind in state CLOSED", pcb->state == CLOSED, return ERR_VAL); + +#if SO_REUSE + /* Unless the REUSEADDR flag is set, + we have to check the pcbs in TIME-WAIT state, also. + We do not dump TIME_WAIT pcb's; they can still be matched by incoming + packets using both local and remote IP addresses and ports to distinguish. + */ + if (ip_get_option(pcb, SOF_REUSEADDR)) { + max_pcb_list = NUM_TCP_PCB_LISTS_NO_TIME_WAIT; + } +#endif /* SO_REUSE */ + +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + /* If the given IP address should have a zone but doesn't, assign one now. + * This is legacy support: scope-aware callers should always provide properly + * zoned source addresses. Do the zone selection before the address-in-use + * check below; as such we have to make a temporary copy of the address. */ + if (IP_IS_V6(ipaddr) && ip6_addr_lacks_zone(ip_2_ip6(ipaddr), IP6_UNICAST)) { + ip_addr_copy(zoned_ipaddr, *ipaddr); + ip6_addr_select_zone(ip_2_ip6(&zoned_ipaddr), ip_2_ip6(&zoned_ipaddr)); + ipaddr = &zoned_ipaddr; + } +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + + if (port == 0) { + port = tcp_new_port(); + if (port == 0) { + return ERR_BUF; + } + } else { + /* Check if the address already is in use (on all lists) */ + for (i = 0; i < max_pcb_list; i++) { + for (cpcb = *tcp_pcb_lists[i]; cpcb != NULL; cpcb = cpcb->next) { + if (cpcb->local_port == port) { +#if SO_REUSE + /* Omit checking for the same port if both pcbs have REUSEADDR set. + For SO_REUSEADDR, the duplicate-check for a 5-tuple is done in + tcp_connect. */ + if (!ip_get_option(pcb, SOF_REUSEADDR) || + !ip_get_option(cpcb, SOF_REUSEADDR)) +#endif /* SO_REUSE */ + { + /* @todo: check accept_any_ip_version */ + if ((IP_IS_V6(ipaddr) == IP_IS_V6_VAL(cpcb->local_ip)) && + (ip_addr_isany(&cpcb->local_ip) || + ip_addr_isany(ipaddr) || + ip_addr_cmp(&cpcb->local_ip, ipaddr))) { + return ERR_USE; + } + } + } + } + } + } + + if (!ip_addr_isany(ipaddr) +#if LWIP_IPV4 && LWIP_IPV6 + || (IP_GET_TYPE(ipaddr) != IP_GET_TYPE(&pcb->local_ip)) +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + ) { + ip_addr_set(&pcb->local_ip, ipaddr); + } + pcb->local_port = port; + TCP_REG(&tcp_bound_pcbs, pcb); + LWIP_DEBUGF(TCP_DEBUG, ("tcp_bind: bind to port %"U16_F"\n", port)); + return ERR_OK; +} + +/** + * @ingroup tcp_raw + * Binds the connection to a netif and IP address. + * After calling this function, all packets received via this PCB + * are guaranteed to have come in via the specified netif, and all + * outgoing packets will go out via the specified netif. + * + * @param pcb the tcp_pcb to bind. + * @param netif the netif to bind to. Can be NULL. + */ +void +tcp_bind_netif(struct tcp_pcb *pcb, const struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (netif != NULL) { + pcb->netif_idx = netif_get_index(netif); + } else { + pcb->netif_idx = NETIF_NO_INDEX; + } +} + +#if LWIP_CALLBACK_API +/** + * Default accept callback if no accept callback is specified by the user. + */ +static err_t +tcp_accept_null(void *arg, struct tcp_pcb *pcb, err_t err) +{ + LWIP_UNUSED_ARG(arg); + LWIP_UNUSED_ARG(err); + + LWIP_ASSERT("tcp_accept_null: invalid pcb", pcb != NULL); + + tcp_abort(pcb); + + return ERR_ABRT; +} +#endif /* LWIP_CALLBACK_API */ + +/** + * @ingroup tcp_raw + * Set the state of the connection to be LISTEN, which means that it + * is able to accept incoming connections. The protocol control block + * is reallocated in order to consume less memory. Setting the + * connection to LISTEN is an irreversible process. + * When an incoming connection is accepted, the function specified with + * the tcp_accept() function will be called. The pcb has to be bound + * to a local port with the tcp_bind() function. + * + * The tcp_listen() function returns a new connection identifier, and + * the one passed as an argument to the function will be + * deallocated. The reason for this behavior is that less memory is + * needed for a connection that is listening, so tcp_listen() will + * reclaim the memory needed for the original connection and allocate a + * new smaller memory block for the listening connection. + * + * tcp_listen() may return NULL if no memory was available for the + * listening connection. If so, the memory associated with the pcb + * passed as an argument to tcp_listen() will not be deallocated. + * + * The backlog limits the number of outstanding connections + * in the listen queue to the value specified by the backlog argument. + * To use it, your need to set TCP_LISTEN_BACKLOG=1 in your lwipopts.h. + * + * @param pcb the original tcp_pcb + * @param backlog the incoming connections queue limit + * @return tcp_pcb used for listening, consumes less memory. + * + * @note The original tcp_pcb is freed. This function therefore has to be + * called like this: + * tpcb = tcp_listen_with_backlog(tpcb, backlog); + */ +struct tcp_pcb * +tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog) +{ + LWIP_ASSERT_CORE_LOCKED(); + return tcp_listen_with_backlog_and_err(pcb, backlog, NULL); +} + +/** + * @ingroup tcp_raw + * Set the state of the connection to be LISTEN, which means that it + * is able to accept incoming connections. The protocol control block + * is reallocated in order to consume less memory. Setting the + * connection to LISTEN is an irreversible process. + * + * @param pcb the original tcp_pcb + * @param backlog the incoming connections queue limit + * @param err when NULL is returned, this contains the error reason + * @return tcp_pcb used for listening, consumes less memory. + * + * @note The original tcp_pcb is freed. This function therefore has to be + * called like this: + * tpcb = tcp_listen_with_backlog_and_err(tpcb, backlog, &err); + */ +struct tcp_pcb * +tcp_listen_with_backlog_and_err(struct tcp_pcb *pcb, u8_t backlog, err_t *err) +{ + struct tcp_pcb_listen *lpcb = NULL; + err_t res; + + LWIP_UNUSED_ARG(backlog); + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_listen_with_backlog_and_err: invalid pcb", pcb != NULL, res = ERR_ARG; goto done); + LWIP_ERROR("tcp_listen_with_backlog_and_err: pcb already connected", pcb->state == CLOSED, res = ERR_CLSD; goto done); + + /* already listening? */ + if (pcb->state == LISTEN) { + lpcb = (struct tcp_pcb_listen *)pcb; + res = ERR_ALREADY; + goto done; + } +#if SO_REUSE + if (ip_get_option(pcb, SOF_REUSEADDR)) { + /* Since SOF_REUSEADDR allows reusing a local address before the pcb's usage + is declared (listen-/connection-pcb), we have to make sure now that + this port is only used once for every local IP. */ + for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) { + if ((lpcb->local_port == pcb->local_port) && + ip_addr_cmp(&lpcb->local_ip, &pcb->local_ip)) { + /* this address/port is already used */ + lpcb = NULL; + res = ERR_USE; + goto done; + } + } + } +#endif /* SO_REUSE */ + lpcb = (struct tcp_pcb_listen *)memp_malloc(MEMP_TCP_PCB_LISTEN); + if (lpcb == NULL) { + res = ERR_MEM; + goto done; + } + lpcb->callback_arg = pcb->callback_arg; + lpcb->local_port = pcb->local_port; + lpcb->state = LISTEN; + lpcb->prio = pcb->prio; + lpcb->so_options = pcb->so_options; + lpcb->netif_idx = NETIF_NO_INDEX; + lpcb->ttl = pcb->ttl; + lpcb->tos = pcb->tos; +#if LWIP_IPV4 && LWIP_IPV6 + IP_SET_TYPE_VAL(lpcb->remote_ip, pcb->local_ip.type); +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + ip_addr_copy(lpcb->local_ip, pcb->local_ip); + if (pcb->local_port != 0) { + TCP_RMV(&tcp_bound_pcbs, pcb); + } +#if LWIP_TCP_PCB_NUM_EXT_ARGS + /* copy over ext_args to listening pcb */ + memcpy(&lpcb->ext_args, &pcb->ext_args, sizeof(pcb->ext_args)); +#endif + tcp_free(pcb); +#if LWIP_CALLBACK_API + lpcb->accept = tcp_accept_null; +#endif /* LWIP_CALLBACK_API */ +#if TCP_LISTEN_BACKLOG + lpcb->accepts_pending = 0; + tcp_backlog_set(lpcb, backlog); +#endif /* TCP_LISTEN_BACKLOG */ + TCP_REG(&tcp_listen_pcbs.pcbs, (struct tcp_pcb *)lpcb); + res = ERR_OK; +done: + if (err != NULL) { + *err = res; + } + return (struct tcp_pcb *)lpcb; +} + +/** + * Update the state that tracks the available window space to advertise. + * + * Returns how much extra window would be advertised if we sent an + * update now. + */ +u32_t +tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb) +{ + u32_t new_right_edge; + + LWIP_ASSERT("tcp_update_rcv_ann_wnd: invalid pcb", pcb != NULL); + new_right_edge = pcb->rcv_nxt + pcb->rcv_wnd; + + if (TCP_SEQ_GEQ(new_right_edge, pcb->rcv_ann_right_edge + LWIP_MIN((TCP_WND / 2), pcb->mss))) { + /* we can advertise more window */ + pcb->rcv_ann_wnd = pcb->rcv_wnd; + return new_right_edge - pcb->rcv_ann_right_edge; + } else { + if (TCP_SEQ_GT(pcb->rcv_nxt, pcb->rcv_ann_right_edge)) { + /* Can happen due to other end sending out of advertised window, + * but within actual available (but not yet advertised) window */ + pcb->rcv_ann_wnd = 0; + } else { + /* keep the right edge of window constant */ + u32_t new_rcv_ann_wnd = pcb->rcv_ann_right_edge - pcb->rcv_nxt; +#if !LWIP_WND_SCALE + LWIP_ASSERT("new_rcv_ann_wnd <= 0xffff", new_rcv_ann_wnd <= 0xffff); +#endif + pcb->rcv_ann_wnd = (tcpwnd_size_t)new_rcv_ann_wnd; + } + return 0; + } +} + +/** + * @ingroup tcp_raw + * This function should be called by the application when it has + * processed the data. The purpose is to advertise a larger window + * when the data has been processed. + * + * @param pcb the tcp_pcb for which data is read + * @param len the amount of bytes that have been read by the application + */ +void +tcp_recved(struct tcp_pcb *pcb, u16_t len) +{ + u32_t wnd_inflation; + tcpwnd_size_t rcv_wnd; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_recved: invalid pcb", pcb != NULL, return); + + /* pcb->state LISTEN not allowed here */ + LWIP_ASSERT("don't call tcp_recved for listen-pcbs", + pcb->state != LISTEN); + + rcv_wnd = (tcpwnd_size_t)(pcb->rcv_wnd + len); + if ((rcv_wnd > TCP_WND_MAX(pcb)) || (rcv_wnd < pcb->rcv_wnd)) { + /* window got too big or tcpwnd_size_t overflow */ + LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: window got too big or tcpwnd_size_t overflow\n")); + pcb->rcv_wnd = TCP_WND_MAX(pcb); + } else { + pcb->rcv_wnd = rcv_wnd; + } + + wnd_inflation = tcp_update_rcv_ann_wnd(pcb); + + /* If the change in the right edge of window is significant (default + * watermark is TCP_WND/4), then send an explicit update now. + * Otherwise wait for a packet to be sent in the normal course of + * events (or more window to be available later) */ + if (wnd_inflation >= TCP_WND_UPDATE_THRESHOLD) { + tcp_ack_now(pcb); + tcp_output(pcb); + } + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_recved: received %"U16_F" bytes, wnd %"TCPWNDSIZE_F" (%"TCPWNDSIZE_F").\n", + len, pcb->rcv_wnd, (u16_t)(TCP_WND_MAX(pcb) - pcb->rcv_wnd))); +} + +/** + * Allocate a new local TCP port. + * + * @return a new (free) local TCP port number + */ +static u16_t +tcp_new_port(void) +{ + u8_t i; + u16_t n = 0; + struct tcp_pcb *pcb; + +again: + tcp_port++; + if (tcp_port == TCP_LOCAL_PORT_RANGE_END) { + tcp_port = TCP_LOCAL_PORT_RANGE_START; + } + /* Check all PCB lists. */ + for (i = 0; i < NUM_TCP_PCB_LISTS; i++) { + for (pcb = *tcp_pcb_lists[i]; pcb != NULL; pcb = pcb->next) { + if (pcb->local_port == tcp_port) { + n++; + if (n > (TCP_LOCAL_PORT_RANGE_END - TCP_LOCAL_PORT_RANGE_START)) { + return 0; + } + goto again; + } + } + } + return tcp_port; +} + +/** + * @ingroup tcp_raw + * Connects to another host. The function given as the "connected" + * argument will be called when the connection has been established. + * Sets up the pcb to connect to the remote host and sends the + * initial SYN segment which opens the connection. + * + * The tcp_connect() function returns immediately; it does not wait for + * the connection to be properly setup. Instead, it will call the + * function specified as the fourth argument (the "connected" argument) + * when the connection is established. If the connection could not be + * properly established, either because the other host refused the + * connection or because the other host didn't answer, the "err" + * callback function of this pcb (registered with tcp_err, see below) + * will be called. + * + * The tcp_connect() function can return ERR_MEM if no memory is + * available for enqueueing the SYN segment. If the SYN indeed was + * enqueued successfully, the tcp_connect() function returns ERR_OK. + * + * @param pcb the tcp_pcb used to establish the connection + * @param ipaddr the remote ip address to connect to + * @param port the remote tcp port to connect to + * @param connected callback function to call when connected (on error, + the err calback will be called) + * @return ERR_VAL if invalid arguments are given + * ERR_OK if connect request has been sent + * other err_t values if connect request couldn't be sent + */ +err_t +tcp_connect(struct tcp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port, + tcp_connected_fn connected) +{ + struct netif *netif = NULL; + err_t ret; + u32_t iss; + u16_t old_local_port; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_connect: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_ERROR("tcp_connect: invalid ipaddr", ipaddr != NULL, return ERR_ARG); + + LWIP_ERROR("tcp_connect: can only connect from state CLOSED", pcb->state == CLOSED, return ERR_ISCONN); + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_connect to port %"U16_F"\n", port)); + ip_addr_set(&pcb->remote_ip, ipaddr); + pcb->remote_port = port; + + if (pcb->netif_idx != NETIF_NO_INDEX) { + netif = netif_get_by_index(pcb->netif_idx); + } else { + /* check if we have a route to the remote host */ + netif = ip_route(&pcb->local_ip, &pcb->remote_ip); + } + if (netif == NULL) { + /* Don't even try to send a SYN packet if we have no route since that will fail. */ + return ERR_RTE; + } + + /* check if local IP has been assigned to pcb, if not, get one */ + if (ip_addr_isany(&pcb->local_ip)) { + const ip_addr_t *local_ip = ip_netif_get_local_ip(netif, ipaddr); + if (local_ip == NULL) { + return ERR_RTE; + } + ip_addr_copy(pcb->local_ip, *local_ip); + } + +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + /* If the given IP address should have a zone but doesn't, assign one now. + * Given that we already have the target netif, this is easy and cheap. */ + if (IP_IS_V6(&pcb->remote_ip) && + ip6_addr_lacks_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNICAST)) { + ip6_addr_assign_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNICAST, netif); + } +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + + old_local_port = pcb->local_port; + if (pcb->local_port == 0) { + pcb->local_port = tcp_new_port(); + if (pcb->local_port == 0) { + return ERR_BUF; + } + } else { +#if SO_REUSE + if (ip_get_option(pcb, SOF_REUSEADDR)) { + /* Since SOF_REUSEADDR allows reusing a local address, we have to make sure + now that the 5-tuple is unique. */ + struct tcp_pcb *cpcb; + int i; + /* Don't check listen- and bound-PCBs, check active- and TIME-WAIT PCBs. */ + for (i = 2; i < NUM_TCP_PCB_LISTS; i++) { + for (cpcb = *tcp_pcb_lists[i]; cpcb != NULL; cpcb = cpcb->next) { + if ((cpcb->local_port == pcb->local_port) && + (cpcb->remote_port == port) && + ip_addr_cmp(&cpcb->local_ip, &pcb->local_ip) && + ip_addr_cmp(&cpcb->remote_ip, ipaddr)) { + /* linux returns EISCONN here, but ERR_USE should be OK for us */ + return ERR_USE; + } + } + } + } +#endif /* SO_REUSE */ + } + + iss = tcp_next_iss(pcb); + pcb->rcv_nxt = 0; + pcb->snd_nxt = iss; + pcb->lastack = iss - 1; + pcb->snd_wl2 = iss - 1; + pcb->snd_lbb = iss - 1; + /* Start with a window that does not need scaling. When window scaling is + enabled and used, the window is enlarged when both sides agree on scaling. */ + pcb->rcv_wnd = pcb->rcv_ann_wnd = TCPWND_MIN16(TCP_WND); + pcb->rcv_ann_right_edge = pcb->rcv_nxt; + pcb->snd_wnd = TCP_WND; + /* As initial send MSS, we use TCP_MSS but limit it to 536. + The send MSS is updated when an MSS option is received. */ + pcb->mss = INITIAL_MSS; +#if TCP_CALCULATE_EFF_SEND_MSS + pcb->mss = tcp_eff_send_mss_netif(pcb->mss, netif, &pcb->remote_ip); +#endif /* TCP_CALCULATE_EFF_SEND_MSS */ + pcb->cwnd = 1; +#if LWIP_CALLBACK_API + pcb->connected = connected; +#else /* LWIP_CALLBACK_API */ + LWIP_UNUSED_ARG(connected); +#endif /* LWIP_CALLBACK_API */ + + /* Send a SYN together with the MSS option. */ + ret = tcp_enqueue_flags(pcb, TCP_SYN); + if (ret == ERR_OK) { + /* SYN segment was enqueued, changed the pcbs state now */ + pcb->state = SYN_SENT; + if (old_local_port != 0) { + TCP_RMV(&tcp_bound_pcbs, pcb); + } + TCP_REG_ACTIVE(pcb); + MIB2_STATS_INC(mib2.tcpactiveopens); + + tcp_output(pcb); + } + return ret; +} + +/** + * Called every 500 ms and implements the retransmission timer and the timer that + * removes PCBs that have been in TIME-WAIT for enough time. It also increments + * various timers such as the inactivity timer in each PCB. + * + * Automatically called from tcp_tmr(). + */ +void +tcp_slowtmr(void) +{ + struct tcp_pcb *pcb, *prev; + tcpwnd_size_t eff_wnd; + u8_t pcb_remove; /* flag if a PCB should be removed */ + u8_t pcb_reset; /* flag if a RST should be sent when removing */ + err_t err; + + err = ERR_OK; + + ++tcp_ticks; + ++tcp_timer_ctr; + +tcp_slowtmr_start: + /* Steps through all of the active PCBs. */ + prev = NULL; + pcb = tcp_active_pcbs; + if (pcb == NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: no active pcbs\n")); + } + while (pcb != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: processing active pcb\n")); + LWIP_ASSERT("tcp_slowtmr: active pcb->state != CLOSED\n", pcb->state != CLOSED); + LWIP_ASSERT("tcp_slowtmr: active pcb->state != LISTEN\n", pcb->state != LISTEN); + LWIP_ASSERT("tcp_slowtmr: active pcb->state != TIME-WAIT\n", pcb->state != TIME_WAIT); + if (pcb->last_timer == tcp_timer_ctr) { + /* skip this pcb, we have already processed it */ + prev = pcb; + pcb = pcb->next; + continue; + } + pcb->last_timer = tcp_timer_ctr; + + pcb_remove = 0; + pcb_reset = 0; + + if (pcb->state == SYN_SENT && pcb->nrtx >= TCP_SYNMAXRTX) { + ++pcb_remove; + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max SYN retries reached\n")); + } else if (pcb->nrtx >= TCP_MAXRTX) { + ++pcb_remove; + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: max DATA retries reached\n")); + } else { + if (pcb->persist_backoff > 0) { + LWIP_ASSERT("tcp_slowtimr: persist ticking with in-flight data", pcb->unacked == NULL); + LWIP_ASSERT("tcp_slowtimr: persist ticking with empty send buffer", pcb->unsent != NULL); + if (pcb->persist_probe >= TCP_MAXRTX) { + ++pcb_remove; /* max probes reached */ + } else { + u8_t backoff_cnt = tcp_persist_backoff[pcb->persist_backoff - 1]; + if (pcb->persist_cnt < backoff_cnt) { + pcb->persist_cnt++; + } + if (pcb->persist_cnt >= backoff_cnt) { + int next_slot = 1; /* increment timer to next slot */ + /* If snd_wnd is zero, send 1 byte probes */ + if (pcb->snd_wnd == 0) { + if (tcp_zero_window_probe(pcb) != ERR_OK) { + next_slot = 0; /* try probe again with current slot */ + } + /* snd_wnd not fully closed, split unsent head and fill window */ + } else { + if (tcp_split_unsent_seg(pcb, (u16_t)pcb->snd_wnd) == ERR_OK) { + if (tcp_output(pcb) == ERR_OK) { + /* sending will cancel persist timer, else retry with current slot */ + next_slot = 0; + } + } + } + if (next_slot) { + pcb->persist_cnt = 0; + if (pcb->persist_backoff < sizeof(tcp_persist_backoff)) { + pcb->persist_backoff++; + } + } + } + } + } else { + /* Increase the retransmission timer if it is running */ + if ((pcb->rtime >= 0) && (pcb->rtime < 0x7FFF)) { + ++pcb->rtime; + } + + if (pcb->rtime >= pcb->rto) { + /* Time for a retransmission. */ + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_slowtmr: rtime %"S16_F + " pcb->rto %"S16_F"\n", + pcb->rtime, pcb->rto)); + /* If prepare phase fails but we have unsent data but no unacked data, + still execute the backoff calculations below, as this means we somehow + failed to send segment. */ + if ((tcp_rexmit_rto_prepare(pcb) == ERR_OK) || ((pcb->unacked == NULL) && (pcb->unsent != NULL))) { + /* Double retransmission time-out unless we are trying to + * connect to somebody (i.e., we are in SYN_SENT). */ + if (pcb->state != SYN_SENT) { + u8_t backoff_idx = LWIP_MIN(pcb->nrtx, sizeof(tcp_backoff) - 1); + int calc_rto = ((pcb->sa >> 3) + pcb->sv) << tcp_backoff[backoff_idx]; + pcb->rto = (s16_t)LWIP_MIN(calc_rto, 0x7FFF); + } + + /* Reset the retransmission timer. */ + pcb->rtime = 0; + + /* Reduce congestion window and ssthresh. */ + eff_wnd = LWIP_MIN(pcb->cwnd, pcb->snd_wnd); + pcb->ssthresh = eff_wnd >> 1; + if (pcb->ssthresh < (tcpwnd_size_t)(pcb->mss << 1)) { + pcb->ssthresh = (tcpwnd_size_t)(pcb->mss << 1); + } + pcb->cwnd = pcb->mss; + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: cwnd %"TCPWNDSIZE_F + " ssthresh %"TCPWNDSIZE_F"\n", + pcb->cwnd, pcb->ssthresh)); + pcb->bytes_acked = 0; + + /* The following needs to be called AFTER cwnd is set to one + mss - STJ */ + tcp_rexmit_rto_commit(pcb); + } + } + } + } + /* Check if this PCB has stayed too long in FIN-WAIT-2 */ + if (pcb->state == FIN_WAIT_2) { + /* If this PCB is in FIN_WAIT_2 because of SHUT_WR don't let it time out. */ + if (pcb->flags & TF_RXCLOSED) { + /* PCB was fully closed (either through close() or SHUT_RDWR): + normal FIN-WAIT timeout handling. */ + if ((u32_t)(tcp_ticks - pcb->tmr) > + TCP_FIN_WAIT_TIMEOUT / TCP_SLOW_INTERVAL) { + ++pcb_remove; + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in FIN-WAIT-2\n")); + } + } + } + + /* Check if KEEPALIVE should be sent */ + if (ip_get_option(pcb, SOF_KEEPALIVE) && + ((pcb->state == ESTABLISHED) || + (pcb->state == CLOSE_WAIT))) { + if ((u32_t)(tcp_ticks - pcb->tmr) > + (pcb->keep_idle + TCP_KEEP_DUR(pcb)) / TCP_SLOW_INTERVAL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: KEEPALIVE timeout. Aborting connection to ")); + ip_addr_debug_print_val(TCP_DEBUG, pcb->remote_ip); + LWIP_DEBUGF(TCP_DEBUG, ("\n")); + + ++pcb_remove; + ++pcb_reset; + } else if ((u32_t)(tcp_ticks - pcb->tmr) > + (pcb->keep_idle + pcb->keep_cnt_sent * TCP_KEEP_INTVL(pcb)) + / TCP_SLOW_INTERVAL) { + err = tcp_keepalive(pcb); + if (err == ERR_OK) { + pcb->keep_cnt_sent++; + } + } + } + + /* If this PCB has queued out of sequence data, but has been + inactive for too long, will drop the data (it will eventually + be retransmitted). */ +#if TCP_QUEUE_OOSEQ + if (pcb->ooseq != NULL && + (tcp_ticks - pcb->tmr >= (u32_t)pcb->rto * TCP_OOSEQ_TIMEOUT)) { + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_slowtmr: dropping OOSEQ queued data\n")); + tcp_free_ooseq(pcb); + } +#endif /* TCP_QUEUE_OOSEQ */ + + /* Check if this PCB has stayed too long in SYN-RCVD */ + if (pcb->state == SYN_RCVD) { + if ((u32_t)(tcp_ticks - pcb->tmr) > + TCP_SYN_RCVD_TIMEOUT / TCP_SLOW_INTERVAL) { + ++pcb_remove; + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in SYN-RCVD\n")); + } + } + + /* Check if this PCB has stayed too long in LAST-ACK */ + if (pcb->state == LAST_ACK) { + if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) { + ++pcb_remove; + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: removing pcb stuck in LAST-ACK\n")); + } + } + + /* If the PCB should be removed, do it. */ + if (pcb_remove) { + struct tcp_pcb *pcb2; +#if LWIP_CALLBACK_API + tcp_err_fn err_fn = pcb->errf; +#endif /* LWIP_CALLBACK_API */ + void *err_arg; + enum tcp_state last_state; + tcp_pcb_purge(pcb); + /* Remove PCB from tcp_active_pcbs list. */ + if (prev != NULL) { + LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_active_pcbs", pcb != tcp_active_pcbs); + prev->next = pcb->next; + } else { + /* This PCB was the first. */ + LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_active_pcbs", tcp_active_pcbs == pcb); + tcp_active_pcbs = pcb->next; + } + + if (pcb_reset) { + tcp_rst(pcb, pcb->snd_nxt, pcb->rcv_nxt, &pcb->local_ip, &pcb->remote_ip, + pcb->local_port, pcb->remote_port); + } + + err_arg = pcb->callback_arg; + last_state = pcb->state; + pcb2 = pcb; + pcb = pcb->next; + tcp_free(pcb2); + + tcp_active_pcbs_changed = 0; + TCP_EVENT_ERR(last_state, err_fn, err_arg, ERR_ABRT); + if (tcp_active_pcbs_changed) { + goto tcp_slowtmr_start; + } + } else { + /* get the 'next' element now and work with 'prev' below (in case of abort) */ + prev = pcb; + pcb = pcb->next; + + /* We check if we should poll the connection. */ + ++prev->polltmr; + if (prev->polltmr >= prev->pollinterval) { + prev->polltmr = 0; + LWIP_DEBUGF(TCP_DEBUG, ("tcp_slowtmr: polling application\n")); + tcp_active_pcbs_changed = 0; + TCP_EVENT_POLL(prev, err); + if (tcp_active_pcbs_changed) { + goto tcp_slowtmr_start; + } + /* if err == ERR_ABRT, 'prev' is already deallocated */ + if (err == ERR_OK) { + tcp_output(prev); + } + } + } + } + + + /* Steps through all of the TIME-WAIT PCBs. */ + prev = NULL; + pcb = tcp_tw_pcbs; + while (pcb != NULL) { + LWIP_ASSERT("tcp_slowtmr: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT); + pcb_remove = 0; + + /* Check if this PCB has stayed long enough in TIME-WAIT */ + if ((u32_t)(tcp_ticks - pcb->tmr) > 2 * TCP_MSL / TCP_SLOW_INTERVAL) { + ++pcb_remove; + } + + /* If the PCB should be removed, do it. */ + if (pcb_remove) { + struct tcp_pcb *pcb2; + tcp_pcb_purge(pcb); + /* Remove PCB from tcp_tw_pcbs list. */ + if (prev != NULL) { + LWIP_ASSERT("tcp_slowtmr: middle tcp != tcp_tw_pcbs", pcb != tcp_tw_pcbs); + prev->next = pcb->next; + } else { + /* This PCB was the first. */ + LWIP_ASSERT("tcp_slowtmr: first pcb == tcp_tw_pcbs", tcp_tw_pcbs == pcb); + tcp_tw_pcbs = pcb->next; + } + pcb2 = pcb; + pcb = pcb->next; + tcp_free(pcb2); + } else { + prev = pcb; + pcb = pcb->next; + } + } +} + +/** + * Is called every TCP_FAST_INTERVAL (250 ms) and process data previously + * "refused" by upper layer (application) and sends delayed ACKs or pending FINs. + * + * Automatically called from tcp_tmr(). + */ +void +tcp_fasttmr(void) +{ + struct tcp_pcb *pcb; + + ++tcp_timer_ctr; + +tcp_fasttmr_start: + pcb = tcp_active_pcbs; + + while (pcb != NULL) { + if (pcb->last_timer != tcp_timer_ctr) { + struct tcp_pcb *next; + pcb->last_timer = tcp_timer_ctr; + /* send delayed ACKs */ + if (pcb->flags & TF_ACK_DELAY) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: delayed ACK\n")); + tcp_ack_now(pcb); + tcp_output(pcb); + tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); + } + /* send pending FIN */ + if (pcb->flags & TF_CLOSEPEND) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_fasttmr: pending FIN\n")); + tcp_clear_flags(pcb, TF_CLOSEPEND); + tcp_close_shutdown_fin(pcb); + } + + next = pcb->next; + + /* If there is data which was previously "refused" by upper layer */ + if (pcb->refused_data != NULL) { + tcp_active_pcbs_changed = 0; + tcp_process_refused_data(pcb); + if (tcp_active_pcbs_changed) { + /* application callback has changed the pcb list: restart the loop */ + goto tcp_fasttmr_start; + } + } + pcb = next; + } else { + pcb = pcb->next; + } + } +} + +/** Call tcp_output for all active pcbs that have TF_NAGLEMEMERR set */ +void +tcp_txnow(void) +{ + struct tcp_pcb *pcb; + + for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { + if (pcb->flags & TF_NAGLEMEMERR) { + tcp_output(pcb); + } + } +} + +/** Pass pcb->refused_data to the recv callback */ +err_t +tcp_process_refused_data(struct tcp_pcb *pcb) +{ +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + struct pbuf *rest; +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + + LWIP_ERROR("tcp_process_refused_data: invalid pcb", pcb != NULL, return ERR_ARG); + +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + while (pcb->refused_data != NULL) +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + { + err_t err; + u8_t refused_flags = pcb->refused_data->flags; + /* set pcb->refused_data to NULL in case the callback frees it and then + closes the pcb */ + struct pbuf *refused_data = pcb->refused_data; +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + pbuf_split_64k(refused_data, &rest); + pcb->refused_data = rest; +#else /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + pcb->refused_data = NULL; +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + /* Notify again application with data previously received. */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: notify kept packet\n")); + TCP_EVENT_RECV(pcb, refused_data, ERR_OK, err); + if (err == ERR_OK) { + /* did refused_data include a FIN? */ + if ((refused_flags & PBUF_FLAG_TCP_FIN) +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + && (rest == NULL) +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + ) { + /* correct rcv_wnd as the application won't call tcp_recved() + for the FIN's seqno */ + if (pcb->rcv_wnd != TCP_WND_MAX(pcb)) { + pcb->rcv_wnd++; + } + TCP_EVENT_CLOSED(pcb, err); + if (err == ERR_ABRT) { + return ERR_ABRT; + } + } + } else if (err == ERR_ABRT) { + /* if err == ERR_ABRT, 'pcb' is already deallocated */ + /* Drop incoming packets because pcb is "full" (only if the incoming + segment contains data). */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: drop incoming packets, because pcb is \"full\"\n")); + return ERR_ABRT; + } else { + /* data is still refused, pbuf is still valid (go on for ACK-only packets) */ +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + if (rest != NULL) { + pbuf_cat(refused_data, rest); + } +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + pcb->refused_data = refused_data; + return ERR_INPROGRESS; + } + } + return ERR_OK; +} + +/** + * Deallocates a list of TCP segments (tcp_seg structures). + * + * @param seg tcp_seg list of TCP segments to free + */ +void +tcp_segs_free(struct tcp_seg *seg) +{ + while (seg != NULL) { + struct tcp_seg *next = seg->next; + tcp_seg_free(seg); + seg = next; + } +} + +/** + * Frees a TCP segment (tcp_seg structure). + * + * @param seg single tcp_seg to free + */ +void +tcp_seg_free(struct tcp_seg *seg) +{ + if (seg != NULL) { + if (seg->p != NULL) { + pbuf_free(seg->p); +#if TCP_DEBUG + seg->p = NULL; +#endif /* TCP_DEBUG */ + } + memp_free(MEMP_TCP_SEG, seg); + } +} + +/** + * @ingroup tcp + * Sets the priority of a connection. + * + * @param pcb the tcp_pcb to manipulate + * @param prio new priority + */ +void +tcp_setprio(struct tcp_pcb *pcb, u8_t prio) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_setprio: invalid pcb", pcb != NULL, return); + + pcb->prio = prio; +} + +#if TCP_QUEUE_OOSEQ +/** + * Returns a copy of the given TCP segment. + * The pbuf and data are not copied, only the pointers + * + * @param seg the old tcp_seg + * @return a copy of seg + */ +struct tcp_seg * +tcp_seg_copy(struct tcp_seg *seg) +{ + struct tcp_seg *cseg; + + LWIP_ASSERT("tcp_seg_copy: invalid seg", seg != NULL); + + cseg = (struct tcp_seg *)memp_malloc(MEMP_TCP_SEG); + if (cseg == NULL) { + return NULL; + } + SMEMCPY((u8_t *)cseg, (const u8_t *)seg, sizeof(struct tcp_seg)); + pbuf_ref(cseg->p); + return cseg; +} +#endif /* TCP_QUEUE_OOSEQ */ + +#if LWIP_CALLBACK_API +/** + * Default receive callback that is called if the user didn't register + * a recv callback for the pcb. + */ +err_t +tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err) +{ + LWIP_UNUSED_ARG(arg); + + LWIP_ERROR("tcp_recv_null: invalid pcb", pcb != NULL, return ERR_ARG); + + if (p != NULL) { + tcp_recved(pcb, p->tot_len); + pbuf_free(p); + } else if (err == ERR_OK) { + return tcp_close(pcb); + } + return ERR_OK; +} +#endif /* LWIP_CALLBACK_API */ + +/** + * Kills the oldest active connection that has a lower priority than 'prio'. + * + * @param prio minimum priority + */ +static void +tcp_kill_prio(u8_t prio) +{ + struct tcp_pcb *pcb, *inactive; + u32_t inactivity; + u8_t mprio; + + mprio = LWIP_MIN(TCP_PRIO_MAX, prio); + + /* We want to kill connections with a lower prio, so bail out if + * supplied prio is 0 - there can never be a lower prio + */ + if (mprio == 0) { + return; + } + + /* We only want kill connections with a lower prio, so decrement prio by one + * and start searching for oldest connection with same or lower priority than mprio. + * We want to find the connections with the lowest possible prio, and among + * these the one with the longest inactivity time. + */ + mprio--; + + inactivity = 0; + inactive = NULL; + for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { + /* lower prio is always a kill candidate */ + if ((pcb->prio < mprio) || + /* longer inactivity is also a kill candidate */ + ((pcb->prio == mprio) && ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity))) { + inactivity = tcp_ticks - pcb->tmr; + inactive = pcb; + mprio = pcb->prio; + } + } + if (inactive != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_prio: killing oldest PCB %p (%"S32_F")\n", + (void *)inactive, inactivity)); + tcp_abort(inactive); + } +} + +/** + * Kills the oldest connection that is in specific state. + * Called from tcp_alloc() for LAST_ACK and CLOSING if no more connections are available. + */ +static void +tcp_kill_state(enum tcp_state state) +{ + struct tcp_pcb *pcb, *inactive; + u32_t inactivity; + + LWIP_ASSERT("invalid state", (state == CLOSING) || (state == LAST_ACK)); + + inactivity = 0; + inactive = NULL; + /* Go through the list of active pcbs and get the oldest pcb that is in state + CLOSING/LAST_ACK. */ + for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { + if (pcb->state == state) { + if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) { + inactivity = tcp_ticks - pcb->tmr; + inactive = pcb; + } + } + } + if (inactive != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_closing: killing oldest %s PCB %p (%"S32_F")\n", + tcp_state_str[state], (void *)inactive, inactivity)); + /* Don't send a RST, since no data is lost. */ + tcp_abandon(inactive, 0); + } +} + +/** + * Kills the oldest connection that is in TIME_WAIT state. + * Called from tcp_alloc() if no more connections are available. + */ +static void +tcp_kill_timewait(void) +{ + struct tcp_pcb *pcb, *inactive; + u32_t inactivity; + + inactivity = 0; + inactive = NULL; + /* Go through the list of TIME_WAIT pcbs and get the oldest pcb. */ + for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { + if ((u32_t)(tcp_ticks - pcb->tmr) >= inactivity) { + inactivity = tcp_ticks - pcb->tmr; + inactive = pcb; + } + } + if (inactive != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_kill_timewait: killing oldest TIME-WAIT PCB %p (%"S32_F")\n", + (void *)inactive, inactivity)); + tcp_abort(inactive); + } +} + +/* Called when allocating a pcb fails. + * In this case, we want to handle all pcbs that want to close first: if we can + * now send the FIN (which failed before), the pcb might be in a state that is + * OK for us to now free it. + */ +static void +tcp_handle_closepend(void) +{ + struct tcp_pcb *pcb = tcp_active_pcbs; + + while (pcb != NULL) { + struct tcp_pcb *next = pcb->next; + /* send pending FIN */ + if (pcb->flags & TF_CLOSEPEND) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_handle_closepend: pending FIN\n")); + tcp_clear_flags(pcb, TF_CLOSEPEND); + tcp_close_shutdown_fin(pcb); + } + pcb = next; + } +} + +/** + * Allocate a new tcp_pcb structure. + * + * @param prio priority for the new pcb + * @return a new tcp_pcb that initially is in state CLOSED + */ +struct tcp_pcb * +tcp_alloc(u8_t prio) +{ + struct tcp_pcb *pcb; + + LWIP_ASSERT_CORE_LOCKED(); + + pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); + if (pcb == NULL) { + /* Try to send FIN for all pcbs stuck in TF_CLOSEPEND first */ + tcp_handle_closepend(); + + /* Try killing oldest connection in TIME-WAIT. */ + LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest TIME-WAIT connection\n")); + tcp_kill_timewait(); + /* Try to allocate a tcp_pcb again. */ + pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); + if (pcb == NULL) { + /* Try killing oldest connection in LAST-ACK (these wouldn't go to TIME-WAIT). */ + LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest LAST-ACK connection\n")); + tcp_kill_state(LAST_ACK); + /* Try to allocate a tcp_pcb again. */ + pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); + if (pcb == NULL) { + /* Try killing oldest connection in CLOSING. */ + LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing off oldest CLOSING connection\n")); + tcp_kill_state(CLOSING); + /* Try to allocate a tcp_pcb again. */ + pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); + if (pcb == NULL) { + /* Try killing oldest active connection with lower priority than the new one. */ + LWIP_DEBUGF(TCP_DEBUG, ("tcp_alloc: killing oldest connection with prio lower than %d\n", prio)); + tcp_kill_prio(prio); + /* Try to allocate a tcp_pcb again. */ + pcb = (struct tcp_pcb *)memp_malloc(MEMP_TCP_PCB); + if (pcb != NULL) { + /* adjust err stats: memp_malloc failed multiple times before */ + MEMP_STATS_DEC(err, MEMP_TCP_PCB); + } + } + if (pcb != NULL) { + /* adjust err stats: memp_malloc failed multiple times before */ + MEMP_STATS_DEC(err, MEMP_TCP_PCB); + } + } + if (pcb != NULL) { + /* adjust err stats: memp_malloc failed multiple times before */ + MEMP_STATS_DEC(err, MEMP_TCP_PCB); + } + } + if (pcb != NULL) { + /* adjust err stats: memp_malloc failed above */ + MEMP_STATS_DEC(err, MEMP_TCP_PCB); + } + } + if (pcb != NULL) { + /* zero out the whole pcb, so there is no need to initialize members to zero */ + memset(pcb, 0, sizeof(struct tcp_pcb)); + pcb->prio = prio; + pcb->snd_buf = TCP_SND_BUF; + /* Start with a window that does not need scaling. When window scaling is + enabled and used, the window is enlarged when both sides agree on scaling. */ + pcb->rcv_wnd = pcb->rcv_ann_wnd = TCPWND_MIN16(TCP_WND); + pcb->ttl = TCP_TTL; + /* As initial send MSS, we use TCP_MSS but limit it to 536. + The send MSS is updated when an MSS option is received. */ + pcb->mss = INITIAL_MSS; + pcb->rto = 3000 / TCP_SLOW_INTERVAL; + pcb->sv = 3000 / TCP_SLOW_INTERVAL; + pcb->rtime = -1; + pcb->cwnd = 1; + pcb->tmr = tcp_ticks; + pcb->last_timer = tcp_timer_ctr; + + /* RFC 5681 recommends setting ssthresh abritrarily high and gives an example + of using the largest advertised receive window. We've seen complications with + receiving TCPs that use window scaling and/or window auto-tuning where the + initial advertised window is very small and then grows rapidly once the + connection is established. To avoid these complications, we set ssthresh to the + largest effective cwnd (amount of in-flight data) that the sender can have. */ + pcb->ssthresh = TCP_SND_BUF; + +#if LWIP_CALLBACK_API + pcb->recv = tcp_recv_null; +#endif /* LWIP_CALLBACK_API */ + + /* Init KEEPALIVE timer */ + pcb->keep_idle = TCP_KEEPIDLE_DEFAULT; + +#if LWIP_TCP_KEEPALIVE + pcb->keep_intvl = TCP_KEEPINTVL_DEFAULT; + pcb->keep_cnt = TCP_KEEPCNT_DEFAULT; +#endif /* LWIP_TCP_KEEPALIVE */ + } + return pcb; +} + +/** + * @ingroup tcp_raw + * Creates a new TCP protocol control block but doesn't place it on + * any of the TCP PCB lists. + * The pcb is not put on any list until binding using tcp_bind(). + * If memory is not available for creating the new pcb, NULL is returned. + * + * @internal: Maybe there should be a idle TCP PCB list where these + * PCBs are put on. Port reservation using tcp_bind() is implemented but + * allocated pcbs that are not bound can't be killed automatically if wanting + * to allocate a pcb with higher prio (@see tcp_kill_prio()) + * + * @return a new tcp_pcb that initially is in state CLOSED + */ +struct tcp_pcb * +tcp_new(void) +{ + return tcp_alloc(TCP_PRIO_NORMAL); +} + +/** + * @ingroup tcp_raw + * Creates a new TCP protocol control block but doesn't + * place it on any of the TCP PCB lists. + * The pcb is not put on any list until binding using tcp_bind(). + * + * @param type IP address type, see @ref lwip_ip_addr_type definitions. + * If you want to listen to IPv4 and IPv6 (dual-stack) connections, + * supply @ref IPADDR_TYPE_ANY as argument and bind to @ref IP_ANY_TYPE. + * @return a new tcp_pcb that initially is in state CLOSED + */ +struct tcp_pcb * +tcp_new_ip_type(u8_t type) +{ + struct tcp_pcb *pcb; + pcb = tcp_alloc(TCP_PRIO_NORMAL); +#if LWIP_IPV4 && LWIP_IPV6 + if (pcb != NULL) { + IP_SET_TYPE_VAL(pcb->local_ip, type); + IP_SET_TYPE_VAL(pcb->remote_ip, type); + } +#else + LWIP_UNUSED_ARG(type); +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + return pcb; +} + +/** + * @ingroup tcp_raw + * Specifies the program specific state that should be passed to all + * other callback functions. The "pcb" argument is the current TCP + * connection control block, and the "arg" argument is the argument + * that will be passed to the callbacks. + * + * @param pcb tcp_pcb to set the callback argument + * @param arg void pointer argument to pass to callback functions + */ +void +tcp_arg(struct tcp_pcb *pcb, void *arg) +{ + LWIP_ASSERT_CORE_LOCKED(); + /* This function is allowed to be called for both listen pcbs and + connection pcbs. */ + if (pcb != NULL) { + pcb->callback_arg = arg; + } +} +#if LWIP_CALLBACK_API + +/** + * @ingroup tcp_raw + * Sets the callback function that will be called when new data + * arrives. The callback function will be passed a NULL pbuf to + * indicate that the remote host has closed the connection. If the + * callback function returns ERR_OK or ERR_ABRT it must have + * freed the pbuf, otherwise it must not have freed it. + * + * @param pcb tcp_pcb to set the recv callback + * @param recv callback function to call for this pcb when data is received + */ +void +tcp_recv(struct tcp_pcb *pcb, tcp_recv_fn recv) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (pcb != NULL) { + LWIP_ASSERT("invalid socket state for recv callback", pcb->state != LISTEN); + pcb->recv = recv; + } +} + +/** + * @ingroup tcp_raw + * Specifies the callback function that should be called when data has + * successfully been received (i.e., acknowledged) by the remote + * host. The len argument passed to the callback function gives the + * amount bytes that was acknowledged by the last acknowledgment. + * + * @param pcb tcp_pcb to set the sent callback + * @param sent callback function to call for this pcb when data is successfully sent + */ +void +tcp_sent(struct tcp_pcb *pcb, tcp_sent_fn sent) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (pcb != NULL) { + LWIP_ASSERT("invalid socket state for sent callback", pcb->state != LISTEN); + pcb->sent = sent; + } +} + +/** + * @ingroup tcp_raw + * Used to specify the function that should be called when a fatal error + * has occurred on the connection. + * + * If a connection is aborted because of an error, the application is + * alerted of this event by the err callback. Errors that might abort a + * connection are when there is a shortage of memory. The callback + * function to be called is set using the tcp_err() function. + * + * @note The corresponding pcb is already freed when this callback is called! + * + * @param pcb tcp_pcb to set the err callback + * @param err callback function to call for this pcb when a fatal error + * has occurred on the connection + */ +void +tcp_err(struct tcp_pcb *pcb, tcp_err_fn err) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (pcb != NULL) { + LWIP_ASSERT("invalid socket state for err callback", pcb->state != LISTEN); + pcb->errf = err; + } +} + +/** + * @ingroup tcp_raw + * Used for specifying the function that should be called when a + * LISTENing connection has been connected to another host. + * + * @param pcb tcp_pcb to set the accept callback + * @param accept callback function to call for this pcb when LISTENing + * connection has been connected to another host + */ +void +tcp_accept(struct tcp_pcb *pcb, tcp_accept_fn accept) +{ + LWIP_ASSERT_CORE_LOCKED(); + if ((pcb != NULL) && (pcb->state == LISTEN)) { + struct tcp_pcb_listen *lpcb = (struct tcp_pcb_listen *)pcb; + lpcb->accept = accept; + } +} +#endif /* LWIP_CALLBACK_API */ + + +/** + * @ingroup tcp_raw + * Specifies the polling interval and the callback function that should + * be called to poll the application. The interval is specified in + * number of TCP coarse grained timer shots, which typically occurs + * twice a second. An interval of 10 means that the application would + * be polled every 5 seconds. + * + * When a connection is idle (i.e., no data is either transmitted or + * received), lwIP will repeatedly poll the application by calling a + * specified callback function. This can be used either as a watchdog + * timer for killing connections that have stayed idle for too long, or + * as a method of waiting for memory to become available. For instance, + * if a call to tcp_write() has failed because memory wasn't available, + * the application may use the polling functionality to call tcp_write() + * again when the connection has been idle for a while. + */ +void +tcp_poll(struct tcp_pcb *pcb, tcp_poll_fn poll, u8_t interval) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("tcp_poll: invalid pcb", pcb != NULL, return); + LWIP_ASSERT("invalid socket state for poll", pcb->state != LISTEN); + +#if LWIP_CALLBACK_API + pcb->poll = poll; +#else /* LWIP_CALLBACK_API */ + LWIP_UNUSED_ARG(poll); +#endif /* LWIP_CALLBACK_API */ + pcb->pollinterval = interval; +} + +/** + * Purges a TCP PCB. Removes any buffered data and frees the buffer memory + * (pcb->ooseq, pcb->unsent and pcb->unacked are freed). + * + * @param pcb tcp_pcb to purge. The pcb itself is not deallocated! + */ +void +tcp_pcb_purge(struct tcp_pcb *pcb) +{ + LWIP_ERROR("tcp_pcb_purge: invalid pcb", pcb != NULL, return); + + if (pcb->state != CLOSED && + pcb->state != TIME_WAIT && + pcb->state != LISTEN) { + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge\n")); + + tcp_backlog_accepted(pcb); + + if (pcb->refused_data != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->refused_data\n")); + pbuf_free(pcb->refused_data); + pcb->refused_data = NULL; + } + if (pcb->unsent != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: not all data sent\n")); + } + if (pcb->unacked != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->unacked\n")); + } +#if TCP_QUEUE_OOSEQ + if (pcb->ooseq != NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_pcb_purge: data left on ->ooseq\n")); + tcp_free_ooseq(pcb); + } +#endif /* TCP_QUEUE_OOSEQ */ + + /* Stop the retransmission timer as it will expect data on unacked + queue if it fires */ + pcb->rtime = -1; + + tcp_segs_free(pcb->unsent); + tcp_segs_free(pcb->unacked); + pcb->unacked = pcb->unsent = NULL; +#if TCP_OVERSIZE + pcb->unsent_oversize = 0; +#endif /* TCP_OVERSIZE */ + } +} + +/** + * Purges the PCB and removes it from a PCB list. Any delayed ACKs are sent first. + * + * @param pcblist PCB list to purge. + * @param pcb tcp_pcb to purge. The pcb itself is NOT deallocated! + */ +void +tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_pcb_remove: invalid pcb", pcb != NULL); + LWIP_ASSERT("tcp_pcb_remove: invalid pcblist", pcblist != NULL); + + TCP_RMV(pcblist, pcb); + + tcp_pcb_purge(pcb); + + /* if there is an outstanding delayed ACKs, send it */ + if ((pcb->state != TIME_WAIT) && + (pcb->state != LISTEN) && + (pcb->flags & TF_ACK_DELAY)) { + tcp_ack_now(pcb); + tcp_output(pcb); + } + + if (pcb->state != LISTEN) { + LWIP_ASSERT("unsent segments leaking", pcb->unsent == NULL); + LWIP_ASSERT("unacked segments leaking", pcb->unacked == NULL); +#if TCP_QUEUE_OOSEQ + LWIP_ASSERT("ooseq segments leaking", pcb->ooseq == NULL); +#endif /* TCP_QUEUE_OOSEQ */ + } + + pcb->state = CLOSED; + /* reset the local port to prevent the pcb from being 'bound' */ + pcb->local_port = 0; + + LWIP_ASSERT("tcp_pcb_remove: tcp_pcbs_sane()", tcp_pcbs_sane()); +} + +/** + * Calculates a new initial sequence number for new connections. + * + * @return u32_t pseudo random sequence number + */ +u32_t +tcp_next_iss(struct tcp_pcb *pcb) +{ +#ifdef LWIP_HOOK_TCP_ISN + LWIP_ASSERT("tcp_next_iss: invalid pcb", pcb != NULL); + return LWIP_HOOK_TCP_ISN(&pcb->local_ip, pcb->local_port, &pcb->remote_ip, pcb->remote_port); +#else /* LWIP_HOOK_TCP_ISN */ + static u32_t iss = 6510; + + LWIP_ASSERT("tcp_next_iss: invalid pcb", pcb != NULL); + LWIP_UNUSED_ARG(pcb); + + iss += tcp_ticks; /* XXX */ + return iss; +#endif /* LWIP_HOOK_TCP_ISN */ +} + +#if TCP_CALCULATE_EFF_SEND_MSS +/** + * Calculates the effective send mss that can be used for a specific IP address + * by calculating the minimum of TCP_MSS and the mtu (if set) of the target + * netif (if not NULL). + */ +u16_t +tcp_eff_send_mss_netif(u16_t sendmss, struct netif *outif, const ip_addr_t *dest) +{ + u16_t mss_s; + u16_t mtu; + + LWIP_UNUSED_ARG(dest); /* in case IPv6 is disabled */ + + LWIP_ASSERT("tcp_eff_send_mss_netif: invalid dst_ip", dest != NULL); + +#if LWIP_IPV6 +#if LWIP_IPV4 + if (IP_IS_V6(dest)) +#endif /* LWIP_IPV4 */ + { + /* First look in destination cache, to see if there is a Path MTU. */ + mtu = nd6_get_destination_mtu(ip_2_ip6(dest), outif); + } +#if LWIP_IPV4 + else +#endif /* LWIP_IPV4 */ +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 + { + if (outif == NULL) { + return sendmss; + } + mtu = outif->mtu; + } +#endif /* LWIP_IPV4 */ + + if (mtu != 0) { + u16_t offset; +#if LWIP_IPV6 +#if LWIP_IPV4 + if (IP_IS_V6(dest)) +#endif /* LWIP_IPV4 */ + { + offset = IP6_HLEN + TCP_HLEN; + } +#if LWIP_IPV4 + else +#endif /* LWIP_IPV4 */ +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 + { + offset = IP_HLEN + TCP_HLEN; + } +#endif /* LWIP_IPV4 */ + mss_s = (mtu > offset) ? (u16_t)(mtu - offset) : 0; + /* RFC 1122, chap 4.2.2.6: + * Eff.snd.MSS = min(SendMSS+20, MMS_S) - TCPhdrsize - IPoptionsize + * We correct for TCP options in tcp_write(), and don't support IP options. + */ + sendmss = LWIP_MIN(sendmss, mss_s); + } + return sendmss; +} +#endif /* TCP_CALCULATE_EFF_SEND_MSS */ + +/** Helper function for tcp_netif_ip_addr_changed() that iterates a pcb list */ +static void +tcp_netif_ip_addr_changed_pcblist(const ip_addr_t *old_addr, struct tcp_pcb *pcb_list) +{ + struct tcp_pcb *pcb; + pcb = pcb_list; + + LWIP_ASSERT("tcp_netif_ip_addr_changed_pcblist: invalid old_addr", old_addr != NULL); + + while (pcb != NULL) { + /* PCB bound to current local interface address? */ + if (ip_addr_cmp(&pcb->local_ip, old_addr) +#if LWIP_AUTOIP + /* connections to link-local addresses must persist (RFC3927 ch. 1.9) */ + && (!IP_IS_V4_VAL(pcb->local_ip) || !ip4_addr_islinklocal(ip_2_ip4(&pcb->local_ip))) +#endif /* LWIP_AUTOIP */ + ) { + /* this connection must be aborted */ + struct tcp_pcb *next = pcb->next; + LWIP_DEBUGF(NETIF_DEBUG | LWIP_DBG_STATE, ("netif_set_ipaddr: aborting TCP pcb %p\n", (void *)pcb)); + tcp_abort(pcb); + pcb = next; + } else { + pcb = pcb->next; + } + } +} + +/** This function is called from netif.c when address is changed or netif is removed + * + * @param old_addr IP address of the netif before change + * @param new_addr IP address of the netif after change or NULL if netif has been removed + */ +void +tcp_netif_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) +{ + struct tcp_pcb_listen *lpcb; + + if (!ip_addr_isany(old_addr)) { + tcp_netif_ip_addr_changed_pcblist(old_addr, tcp_active_pcbs); + tcp_netif_ip_addr_changed_pcblist(old_addr, tcp_bound_pcbs); + + if (!ip_addr_isany(new_addr)) { + /* PCB bound to current local interface address? */ + for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) { + /* PCB bound to current local interface address? */ + if (ip_addr_cmp(&lpcb->local_ip, old_addr)) { + /* The PCB is listening to the old ipaddr and + * is set to listen to the new one instead */ + ip_addr_copy(lpcb->local_ip, *new_addr); + } + } + } + } +} + +const char * +tcp_debug_state_str(enum tcp_state s) +{ + return tcp_state_str[s]; +} + +err_t +tcp_tcp_get_tcp_addrinfo(struct tcp_pcb *pcb, int local, ip_addr_t *addr, u16_t *port) +{ + if (pcb) { + if (local) { + if (addr) { + *addr = pcb->local_ip; + } + if (port) { + *port = pcb->local_port; + } + } else { + if (addr) { + *addr = pcb->remote_ip; + } + if (port) { + *port = pcb->remote_port; + } + } + return ERR_OK; + } + return ERR_VAL; +} + +#if TCP_QUEUE_OOSEQ +/* Free all ooseq pbufs (and possibly reset SACK state) */ +void +tcp_free_ooseq(struct tcp_pcb *pcb) +{ + if (pcb->ooseq) { + tcp_segs_free(pcb->ooseq); + pcb->ooseq = NULL; +#if LWIP_TCP_SACK_OUT + memset(pcb->rcv_sacks, 0, sizeof(pcb->rcv_sacks)); +#endif /* LWIP_TCP_SACK_OUT */ + } +} +#endif /* TCP_QUEUE_OOSEQ */ + +#if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG +/** + * Print a tcp header for debugging purposes. + * + * @param tcphdr pointer to a struct tcp_hdr + */ +void +tcp_debug_print(struct tcp_hdr *tcphdr) +{ + LWIP_DEBUGF(TCP_DEBUG, ("TCP header:\n")); + LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(TCP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n", + lwip_ntohs(tcphdr->src), lwip_ntohs(tcphdr->dest))); + LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (seq no)\n", + lwip_ntohl(tcphdr->seqno))); + LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(TCP_DEBUG, ("| %010"U32_F" | (ack no)\n", + lwip_ntohl(tcphdr->ackno))); + LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(TCP_DEBUG, ("| %2"U16_F" | |%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"%"U16_F"| %5"U16_F" | (hdrlen, flags (", + TCPH_HDRLEN(tcphdr), + (u16_t)(TCPH_FLAGS(tcphdr) >> 5 & 1), + (u16_t)(TCPH_FLAGS(tcphdr) >> 4 & 1), + (u16_t)(TCPH_FLAGS(tcphdr) >> 3 & 1), + (u16_t)(TCPH_FLAGS(tcphdr) >> 2 & 1), + (u16_t)(TCPH_FLAGS(tcphdr) >> 1 & 1), + (u16_t)(TCPH_FLAGS(tcphdr) & 1), + lwip_ntohs(tcphdr->wnd))); + tcp_debug_print_flags(TCPH_FLAGS(tcphdr)); + LWIP_DEBUGF(TCP_DEBUG, ("), win)\n")); + LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(TCP_DEBUG, ("| 0x%04"X16_F" | %5"U16_F" | (chksum, urgp)\n", + lwip_ntohs(tcphdr->chksum), lwip_ntohs(tcphdr->urgp))); + LWIP_DEBUGF(TCP_DEBUG, ("+-------------------------------+\n")); +} + +/** + * Print a tcp state for debugging purposes. + * + * @param s enum tcp_state to print + */ +void +tcp_debug_print_state(enum tcp_state s) +{ + LWIP_DEBUGF(TCP_DEBUG, ("State: %s\n", tcp_state_str[s])); +} + +/** + * Print tcp flags for debugging purposes. + * + * @param flags tcp flags, all active flags are printed + */ +void +tcp_debug_print_flags(u8_t flags) +{ + if (flags & TCP_FIN) { + LWIP_DEBUGF(TCP_DEBUG, ("FIN ")); + } + if (flags & TCP_SYN) { + LWIP_DEBUGF(TCP_DEBUG, ("SYN ")); + } + if (flags & TCP_RST) { + LWIP_DEBUGF(TCP_DEBUG, ("RST ")); + } + if (flags & TCP_PSH) { + LWIP_DEBUGF(TCP_DEBUG, ("PSH ")); + } + if (flags & TCP_ACK) { + LWIP_DEBUGF(TCP_DEBUG, ("ACK ")); + } + if (flags & TCP_URG) { + LWIP_DEBUGF(TCP_DEBUG, ("URG ")); + } + if (flags & TCP_ECE) { + LWIP_DEBUGF(TCP_DEBUG, ("ECE ")); + } + if (flags & TCP_CWR) { + LWIP_DEBUGF(TCP_DEBUG, ("CWR ")); + } + LWIP_DEBUGF(TCP_DEBUG, ("\n")); +} + +/** + * Print all tcp_pcbs in every list for debugging purposes. + */ +void +tcp_debug_print_pcbs(void) +{ + struct tcp_pcb *pcb; + struct tcp_pcb_listen *pcbl; + + LWIP_DEBUGF(TCP_DEBUG, ("Active PCB states:\n")); + for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { + LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ", + pcb->local_port, pcb->remote_port, + pcb->snd_nxt, pcb->rcv_nxt)); + tcp_debug_print_state(pcb->state); + } + + LWIP_DEBUGF(TCP_DEBUG, ("Listen PCB states:\n")); + for (pcbl = tcp_listen_pcbs.listen_pcbs; pcbl != NULL; pcbl = pcbl->next) { + LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F" ", pcbl->local_port)); + tcp_debug_print_state(pcbl->state); + } + + LWIP_DEBUGF(TCP_DEBUG, ("TIME-WAIT PCB states:\n")); + for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { + LWIP_DEBUGF(TCP_DEBUG, ("Local port %"U16_F", foreign port %"U16_F" snd_nxt %"U32_F" rcv_nxt %"U32_F" ", + pcb->local_port, pcb->remote_port, + pcb->snd_nxt, pcb->rcv_nxt)); + tcp_debug_print_state(pcb->state); + } +} + +/** + * Check state consistency of the tcp_pcb lists. + */ +s16_t +tcp_pcbs_sane(void) +{ + struct tcp_pcb *pcb; + for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { + LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != CLOSED", pcb->state != CLOSED); + LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != LISTEN", pcb->state != LISTEN); + LWIP_ASSERT("tcp_pcbs_sane: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT); + } + for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { + LWIP_ASSERT("tcp_pcbs_sane: tw pcb->state == TIME-WAIT", pcb->state == TIME_WAIT); + } + return 1; +} +#endif /* TCP_DEBUG */ + +#if LWIP_TCP_PCB_NUM_EXT_ARGS +/** + * @defgroup tcp_raw_extargs ext arguments + * @ingroup tcp_raw + * Additional data storage per tcp pcb\n + * @see @ref tcp_raw + * + * When LWIP_TCP_PCB_NUM_EXT_ARGS is > 0, every tcp pcb (including listen pcb) + * includes a number of additional argument entries in an array. + * + * To support memory management, in addition to a 'void *', callbacks can be + * provided to manage transition from listening pcbs to connections and to + * deallocate memory when a pcb is deallocated (see struct @ref tcp_ext_arg_callbacks). + * + * After allocating this index, use @ref tcp_ext_arg_set and @ref tcp_ext_arg_get + * to store and load arguments from this index for a given pcb. + */ + +static u8_t tcp_ext_arg_id; + +/** + * @ingroup tcp_raw_extargs + * Allocate an index to store data in ext_args member of struct tcp_pcb. + * Returned value is an index in mentioned array. + * The index is *global* over all pcbs! + * + * When @ref LWIP_TCP_PCB_NUM_EXT_ARGS is > 0, every tcp pcb (including listen pcb) + * includes a number of additional argument entries in an array. + * + * To support memory management, in addition to a 'void *', callbacks can be + * provided to manage transition from listening pcbs to connections and to + * deallocate memory when a pcb is deallocated (see struct @ref tcp_ext_arg_callbacks). + * + * After allocating this index, use @ref tcp_ext_arg_set and @ref tcp_ext_arg_get + * to store and load arguments from this index for a given pcb. + * + * @return a unique index into struct tcp_pcb.ext_args + */ +u8_t +tcp_ext_arg_alloc_id(void) +{ + u8_t result = tcp_ext_arg_id; + tcp_ext_arg_id++; + + LWIP_ASSERT_CORE_LOCKED(); + +#if LWIP_TCP_PCB_NUM_EXT_ARGS >= 255 +#error LWIP_TCP_PCB_NUM_EXT_ARGS +#endif + LWIP_ASSERT("Increase LWIP_TCP_PCB_NUM_EXT_ARGS in lwipopts.h", result < LWIP_TCP_PCB_NUM_EXT_ARGS); + return result; +} + +/** + * @ingroup tcp_raw_extargs + * Set callbacks for a given index of ext_args on the specified pcb. + * + * @param pcb tcp_pcb for which to set the callback + * @param id ext_args index to set (allocated via @ref tcp_ext_arg_alloc_id) + * @param callbacks callback table (const since it is referenced, not copied!) + */ +void +tcp_ext_arg_set_callbacks(struct tcp_pcb *pcb, uint8_t id, const struct tcp_ext_arg_callbacks * const callbacks) +{ + LWIP_ASSERT("pcb != NULL", pcb != NULL); + LWIP_ASSERT("id < LWIP_TCP_PCB_NUM_EXT_ARGS", id < LWIP_TCP_PCB_NUM_EXT_ARGS); + LWIP_ASSERT("callbacks != NULL", callbacks != NULL); + + LWIP_ASSERT_CORE_LOCKED(); + + pcb->ext_args[id].callbacks = callbacks; +} + +/** + * @ingroup tcp_raw_extargs + * Set data for a given index of ext_args on the specified pcb. + * + * @param pcb tcp_pcb for which to set the data + * @param id ext_args index to set (allocated via @ref tcp_ext_arg_alloc_id) + * @param arg data pointer to set + */ +void tcp_ext_arg_set(struct tcp_pcb *pcb, uint8_t id, void *arg) +{ + LWIP_ASSERT("pcb != NULL", pcb != NULL); + LWIP_ASSERT("id < LWIP_TCP_PCB_NUM_EXT_ARGS", id < LWIP_TCP_PCB_NUM_EXT_ARGS); + + LWIP_ASSERT_CORE_LOCKED(); + + pcb->ext_args[id].data = arg; +} + +/** + * @ingroup tcp_raw_extargs + * Set data for a given index of ext_args on the specified pcb. + * + * @param pcb tcp_pcb for which to set the data + * @param id ext_args index to set (allocated via @ref tcp_ext_arg_alloc_id) + * @return data pointer at the given index + */ +void *tcp_ext_arg_get(const struct tcp_pcb *pcb, uint8_t id) +{ + LWIP_ASSERT("pcb != NULL", pcb != NULL); + LWIP_ASSERT("id < LWIP_TCP_PCB_NUM_EXT_ARGS", id < LWIP_TCP_PCB_NUM_EXT_ARGS); + + LWIP_ASSERT_CORE_LOCKED(); + + return pcb->ext_args[id].data; +} + +/** This function calls the "destroy" callback for all ext_args once a pcb is + * freed. + */ +static void +tcp_ext_arg_invoke_callbacks_destroyed(struct tcp_pcb_ext_args *ext_args) +{ + int i; + LWIP_ASSERT("ext_args != NULL", ext_args != NULL); + + for (i = 0; i < LWIP_TCP_PCB_NUM_EXT_ARGS; i++) { + if (ext_args[i].callbacks != NULL) { + if (ext_args[i].callbacks->destroy != NULL) { + ext_args[i].callbacks->destroy((u8_t)i, ext_args[i].data); + } + } + } +} + +/** This function calls the "passive_open" callback for all ext_args if a connection + * is in the process of being accepted. This is called just after the SYN is + * received and before a SYN/ACK is sent, to allow to modify the very first + * segment sent even on passive open. Naturally, the "accepted" callback of the + * pcb has not been called yet! + */ +err_t +tcp_ext_arg_invoke_callbacks_passive_open(struct tcp_pcb_listen *lpcb, struct tcp_pcb *cpcb) +{ + int i; + LWIP_ASSERT("lpcb != NULL", lpcb != NULL); + LWIP_ASSERT("cpcb != NULL", cpcb != NULL); + + for (i = 0; i < LWIP_TCP_PCB_NUM_EXT_ARGS; i++) { + if (lpcb->ext_args[i].callbacks != NULL) { + if (lpcb->ext_args[i].callbacks->passive_open != NULL) { + err_t err = lpcb->ext_args[i].callbacks->passive_open((u8_t)i, lpcb, cpcb); + if (err != ERR_OK) { + return err; + } + } + } + } + return ERR_OK; +} +#endif /* LWIP_TCP_PCB_NUM_EXT_ARGS */ + +#endif /* LWIP_TCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_in.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_in.c index 46701780..428a6f48 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_in.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_in.c @@ -1,2178 +1,2178 @@ -/** - * @file - * Transmission Control Protocol, incoming traffic - * - * The input processing functions of the TCP layer. - * - * These functions are generally called in the order (ip_input() ->) - * tcp_input() -> * tcp_process() -> tcp_receive() (-> application). - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/priv/tcp_priv.h" -#include "lwip/def.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/inet_chksum.h" -#include "lwip/stats.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#if LWIP_ND6_TCP_REACHABILITY_HINTS -#include "lwip/nd6.h" -#endif /* LWIP_ND6_TCP_REACHABILITY_HINTS */ - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -/** Initial CWND calculation as defined RFC 2581 */ -#define LWIP_TCP_CALC_INITIAL_CWND(mss) ((tcpwnd_size_t)LWIP_MIN((4U * (mss)), LWIP_MAX((2U * (mss)), 4380U))) - -/* These variables are global to all functions involved in the input - processing of TCP segments. They are set by the tcp_input() - function. */ -static struct tcp_seg inseg; -static struct tcp_hdr *tcphdr; -static u16_t tcphdr_optlen; -static u16_t tcphdr_opt1len; -static u8_t *tcphdr_opt2; -static u16_t tcp_optidx; -static u32_t seqno, ackno; -static tcpwnd_size_t recv_acked; -static u16_t tcplen; -static u8_t flags; - -static u8_t recv_flags; -static struct pbuf *recv_data; - -struct tcp_pcb *tcp_input_pcb; - -/* Forward declarations. */ -static err_t tcp_process(struct tcp_pcb *pcb); -static void tcp_receive(struct tcp_pcb *pcb); -static void tcp_parseopt(struct tcp_pcb *pcb); - -static void tcp_listen_input(struct tcp_pcb_listen *pcb); -static void tcp_timewait_input(struct tcp_pcb *pcb); - -static int tcp_input_delayed_close(struct tcp_pcb *pcb); - -#if LWIP_TCP_SACK_OUT -static void tcp_add_sack(struct tcp_pcb *pcb, u32_t left, u32_t right); -static void tcp_remove_sacks_lt(struct tcp_pcb *pcb, u32_t seq); -#if defined(TCP_OOSEQ_BYTES_LIMIT) || defined(TCP_OOSEQ_PBUFS_LIMIT) -static void tcp_remove_sacks_gt(struct tcp_pcb *pcb, u32_t seq); -#endif /* TCP_OOSEQ_BYTES_LIMIT || TCP_OOSEQ_PBUFS_LIMIT */ -#endif /* LWIP_TCP_SACK_OUT */ - -/** - * The initial input processing of TCP. It verifies the TCP header, demultiplexes - * the segment between the PCBs and passes it on to tcp_process(), which implements - * the TCP finite state machine. This function is called by the IP layer (in - * ip_input()). - * - * @param p received TCP segment to process (p->payload pointing to the TCP header) - * @param inp network interface on which this segment was received - */ -void -tcp_input(struct pbuf *p, struct netif *inp) -{ - struct tcp_pcb *pcb, *prev; - struct tcp_pcb_listen *lpcb; -#if SO_REUSE - struct tcp_pcb *lpcb_prev = NULL; - struct tcp_pcb_listen *lpcb_any = NULL; -#endif /* SO_REUSE */ - u8_t hdrlen_bytes; - err_t err; - - LWIP_UNUSED_ARG(inp); - LWIP_ASSERT_CORE_LOCKED(); - LWIP_ASSERT("tcp_input: invalid pbuf", p != NULL); - - PERF_START; - - TCP_STATS_INC(tcp.recv); - MIB2_STATS_INC(mib2.tcpinsegs); - - tcphdr = (struct tcp_hdr *)p->payload; - -#if TCP_INPUT_DEBUG - tcp_debug_print(tcphdr); -#endif - - /* Check that TCP header fits in payload */ - if (p->len < TCP_HLEN) { - /* drop short packets */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: short packet (%"U16_F" bytes) discarded\n", p->tot_len)); - TCP_STATS_INC(tcp.lenerr); - goto dropped; - } - - /* Don't even process incoming broadcasts/multicasts. */ - if (ip_addr_isbroadcast(ip_current_dest_addr(), ip_current_netif()) || - ip_addr_ismulticast(ip_current_dest_addr())) { - TCP_STATS_INC(tcp.proterr); - goto dropped; - } - -#if CHECKSUM_CHECK_TCP - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_TCP) { - /* Verify TCP checksum. */ - u16_t chksum = ip_chksum_pseudo(p, IP_PROTO_TCP, p->tot_len, - ip_current_src_addr(), ip_current_dest_addr()); - if (chksum != 0) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packet discarded due to failing checksum 0x%04"X16_F"\n", - chksum)); - tcp_debug_print(tcphdr); - TCP_STATS_INC(tcp.chkerr); - goto dropped; - } - } -#endif /* CHECKSUM_CHECK_TCP */ - - /* sanity-check header length */ - hdrlen_bytes = TCPH_HDRLEN_BYTES(tcphdr); - if ((hdrlen_bytes < TCP_HLEN) || (hdrlen_bytes > p->tot_len)) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: invalid header length (%"U16_F")\n", (u16_t)hdrlen_bytes)); - TCP_STATS_INC(tcp.lenerr); - goto dropped; - } - - /* Move the payload pointer in the pbuf so that it points to the - TCP data instead of the TCP header. */ - tcphdr_optlen = (u16_t)(hdrlen_bytes - TCP_HLEN); - tcphdr_opt2 = NULL; - if (p->len >= hdrlen_bytes) { - /* all options are in the first pbuf */ - tcphdr_opt1len = tcphdr_optlen; - pbuf_remove_header(p, hdrlen_bytes); /* cannot fail */ - } else { - u16_t opt2len; - /* TCP header fits into first pbuf, options don't - data is in the next pbuf */ - /* there must be a next pbuf, due to hdrlen_bytes sanity check above */ - LWIP_ASSERT("p->next != NULL", p->next != NULL); - - /* advance over the TCP header (cannot fail) */ - pbuf_remove_header(p, TCP_HLEN); - - /* determine how long the first and second parts of the options are */ - tcphdr_opt1len = p->len; - opt2len = (u16_t)(tcphdr_optlen - tcphdr_opt1len); - - /* options continue in the next pbuf: set p to zero length and hide the - options in the next pbuf (adjusting p->tot_len) */ - pbuf_remove_header(p, tcphdr_opt1len); - - /* check that the options fit in the second pbuf */ - if (opt2len > p->next->len) { - /* drop short packets */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: options overflow second pbuf (%"U16_F" bytes)\n", p->next->len)); - TCP_STATS_INC(tcp.lenerr); - goto dropped; - } - - /* remember the pointer to the second part of the options */ - tcphdr_opt2 = (u8_t *)p->next->payload; - - /* advance p->next to point after the options, and manually - adjust p->tot_len to keep it consistent with the changed p->next */ - pbuf_remove_header(p->next, opt2len); - p->tot_len = (u16_t)(p->tot_len - opt2len); - - LWIP_ASSERT("p->len == 0", p->len == 0); - LWIP_ASSERT("p->tot_len == p->next->tot_len", p->tot_len == p->next->tot_len); - } - - /* Convert fields in TCP header to host byte order. */ - tcphdr->src = lwip_ntohs(tcphdr->src); - tcphdr->dest = lwip_ntohs(tcphdr->dest); - seqno = tcphdr->seqno = lwip_ntohl(tcphdr->seqno); - ackno = tcphdr->ackno = lwip_ntohl(tcphdr->ackno); - tcphdr->wnd = lwip_ntohs(tcphdr->wnd); - - flags = TCPH_FLAGS(tcphdr); - tcplen = p->tot_len; - if (flags & (TCP_FIN | TCP_SYN)) { - tcplen++; - if (tcplen < p->tot_len) { - /* u16_t overflow, cannot handle this */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: length u16_t overflow, cannot handle this\n")); - TCP_STATS_INC(tcp.lenerr); - goto dropped; - } - } - - /* Demultiplex an incoming segment. First, we check if it is destined - for an active connection. */ - prev = NULL; - - for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { - LWIP_ASSERT("tcp_input: active pcb->state != CLOSED", pcb->state != CLOSED); - LWIP_ASSERT("tcp_input: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT); - LWIP_ASSERT("tcp_input: active pcb->state != LISTEN", pcb->state != LISTEN); - - /* check if PCB is bound to specific netif */ - if ((pcb->netif_idx != NETIF_NO_INDEX) && - (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { - prev = pcb; - continue; - } - - if (pcb->remote_port == tcphdr->src && - pcb->local_port == tcphdr->dest && - ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()) && - ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { - /* Move this PCB to the front of the list so that subsequent - lookups will be faster (we exploit locality in TCP segment - arrivals). */ - LWIP_ASSERT("tcp_input: pcb->next != pcb (before cache)", pcb->next != pcb); - if (prev != NULL) { - prev->next = pcb->next; - pcb->next = tcp_active_pcbs; - tcp_active_pcbs = pcb; - } else { - TCP_STATS_INC(tcp.cachehit); - } - LWIP_ASSERT("tcp_input: pcb->next != pcb (after cache)", pcb->next != pcb); - break; - } - prev = pcb; - } - - if (pcb == NULL) { - /* If it did not go to an active connection, we check the connections - in the TIME-WAIT state. */ - for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { - LWIP_ASSERT("tcp_input: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT); - - /* check if PCB is bound to specific netif */ - if ((pcb->netif_idx != NETIF_NO_INDEX) && - (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { - continue; - } - - if (pcb->remote_port == tcphdr->src && - pcb->local_port == tcphdr->dest && - ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()) && - ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { - /* We don't really care enough to move this PCB to the front - of the list since we are not very likely to receive that - many segments for connections in TIME-WAIT. */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packed for TIME_WAITing connection.\n")); -#ifdef LWIP_HOOK_TCP_INPACKET_PCB - if (LWIP_HOOK_TCP_INPACKET_PCB(pcb, tcphdr, tcphdr_optlen, tcphdr_opt1len, - tcphdr_opt2, p) == ERR_OK) -#endif - { - tcp_timewait_input(pcb); - } - pbuf_free(p); - return; - } - } - - /* Finally, if we still did not get a match, we check all PCBs that - are LISTENing for incoming connections. */ - prev = NULL; - for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) { - /* check if PCB is bound to specific netif */ - if ((lpcb->netif_idx != NETIF_NO_INDEX) && - (lpcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { - prev = (struct tcp_pcb *)lpcb; - continue; - } - - if (lpcb->local_port == tcphdr->dest) { - if (IP_IS_ANY_TYPE_VAL(lpcb->local_ip)) { - /* found an ANY TYPE (IPv4/IPv6) match */ -#if SO_REUSE - lpcb_any = lpcb; - lpcb_prev = prev; -#else /* SO_REUSE */ - break; -#endif /* SO_REUSE */ - } else if (IP_ADDR_PCB_VERSION_MATCH_EXACT(lpcb, ip_current_dest_addr())) { - if (ip_addr_cmp(&lpcb->local_ip, ip_current_dest_addr())) { - /* found an exact match */ - break; - } else if (ip_addr_isany(&lpcb->local_ip)) { - /* found an ANY-match */ -#if SO_REUSE - lpcb_any = lpcb; - lpcb_prev = prev; -#else /* SO_REUSE */ - break; -#endif /* SO_REUSE */ - } - } - } - prev = (struct tcp_pcb *)lpcb; - } -#if SO_REUSE - /* first try specific local IP */ - if (lpcb == NULL) { - /* only pass to ANY if no specific local IP has been found */ - lpcb = lpcb_any; - prev = lpcb_prev; - } -#endif /* SO_REUSE */ - if (lpcb != NULL) { - /* Move this PCB to the front of the list so that subsequent - lookups will be faster (we exploit locality in TCP segment - arrivals). */ - if (prev != NULL) { - ((struct tcp_pcb_listen *)prev)->next = lpcb->next; - /* our successor is the remainder of the listening list */ - lpcb->next = tcp_listen_pcbs.listen_pcbs; - /* put this listening pcb at the head of the listening list */ - tcp_listen_pcbs.listen_pcbs = lpcb; - } else { - TCP_STATS_INC(tcp.cachehit); - } - - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packed for LISTENing connection.\n")); -#ifdef LWIP_HOOK_TCP_INPACKET_PCB - if (LWIP_HOOK_TCP_INPACKET_PCB((struct tcp_pcb *)lpcb, tcphdr, tcphdr_optlen, - tcphdr_opt1len, tcphdr_opt2, p) == ERR_OK) -#endif - { - tcp_listen_input(lpcb); - } - pbuf_free(p); - return; - } - } - -#if TCP_INPUT_DEBUG - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("+-+-+-+-+-+-+-+-+-+-+-+-+-+- tcp_input: flags ")); - tcp_debug_print_flags(TCPH_FLAGS(tcphdr)); - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n")); -#endif /* TCP_INPUT_DEBUG */ - - -#ifdef LWIP_HOOK_TCP_INPACKET_PCB - if ((pcb != NULL) && LWIP_HOOK_TCP_INPACKET_PCB(pcb, tcphdr, tcphdr_optlen, - tcphdr_opt1len, tcphdr_opt2, p) != ERR_OK) { - pbuf_free(p); - return; - } -#endif - if (pcb != NULL) { - /* The incoming segment belongs to a connection. */ -#if TCP_INPUT_DEBUG - tcp_debug_print_state(pcb->state); -#endif /* TCP_INPUT_DEBUG */ - - /* Set up a tcp_seg structure. */ - inseg.next = NULL; - inseg.len = p->tot_len; - inseg.p = p; - inseg.tcphdr = tcphdr; - - recv_data = NULL; - recv_flags = 0; - recv_acked = 0; - - if (flags & TCP_PSH) { - p->flags |= PBUF_FLAG_PUSH; - } - - /* If there is data which was previously "refused" by upper layer */ - if (pcb->refused_data != NULL) { - if ((tcp_process_refused_data(pcb) == ERR_ABRT) || - ((pcb->refused_data != NULL) && (tcplen > 0))) { - /* pcb has been aborted or refused data is still refused and the new - segment contains data */ - if (pcb->rcv_ann_wnd == 0) { - /* this is a zero-window probe, we respond to it with current RCV.NXT - and drop the data segment */ - tcp_send_empty_ack(pcb); - } - TCP_STATS_INC(tcp.drop); - MIB2_STATS_INC(mib2.tcpinerrs); - goto aborted; - } - } - tcp_input_pcb = pcb; - err = tcp_process(pcb); - /* A return value of ERR_ABRT means that tcp_abort() was called - and that the pcb has been freed. If so, we don't do anything. */ - if (err != ERR_ABRT) { - if (recv_flags & TF_RESET) { - /* TF_RESET means that the connection was reset by the other - end. We then call the error callback to inform the - application that the connection is dead before we - deallocate the PCB. */ - TCP_EVENT_ERR(pcb->state, pcb->errf, pcb->callback_arg, ERR_RST); - tcp_pcb_remove(&tcp_active_pcbs, pcb); - tcp_free(pcb); - } else { - err = ERR_OK; - /* If the application has registered a "sent" function to be - called when new send buffer space is available, we call it - now. */ - if (recv_acked > 0) { - u16_t acked16; -#if LWIP_WND_SCALE - /* recv_acked is u32_t but the sent callback only takes a u16_t, - so we might have to call it multiple times. */ - u32_t acked = recv_acked; - while (acked > 0) { - acked16 = (u16_t)LWIP_MIN(acked, 0xffffu); - acked -= acked16; -#else - { - acked16 = recv_acked; -#endif - TCP_EVENT_SENT(pcb, (u16_t)acked16, err); - if (err == ERR_ABRT) { - goto aborted; - } - } - recv_acked = 0; - } - if (tcp_input_delayed_close(pcb)) { - goto aborted; - } -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - while (recv_data != NULL) { - struct pbuf *rest = NULL; - pbuf_split_64k(recv_data, &rest); -#else /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - if (recv_data != NULL) { -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - - LWIP_ASSERT("pcb->refused_data == NULL", pcb->refused_data == NULL); - if (pcb->flags & TF_RXCLOSED) { - /* received data although already closed -> abort (send RST) to - notify the remote host that not all data has been processed */ - pbuf_free(recv_data); -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - if (rest != NULL) { - pbuf_free(rest); - } -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - tcp_abort(pcb); - goto aborted; - } - - /* Notify application that data has been received. */ - TCP_EVENT_RECV(pcb, recv_data, ERR_OK, err); - if (err == ERR_ABRT) { -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - if (rest != NULL) { - pbuf_free(rest); - } -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - goto aborted; - } - - /* If the upper layer can't receive this data, store it */ - if (err != ERR_OK) { -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - if (rest != NULL) { - pbuf_cat(recv_data, rest); - } -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - pcb->refused_data = recv_data; - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: keep incoming packet, because pcb is \"full\"\n")); -#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE - break; - } else { - /* Upper layer received the data, go on with the rest if > 64K */ - recv_data = rest; -#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - } - } - - /* If a FIN segment was received, we call the callback - function with a NULL buffer to indicate EOF. */ - if (recv_flags & TF_GOT_FIN) { - if (pcb->refused_data != NULL) { - /* Delay this if we have refused data. */ - pcb->refused_data->flags |= PBUF_FLAG_TCP_FIN; - } else { - /* correct rcv_wnd as the application won't call tcp_recved() - for the FIN's seqno */ - if (pcb->rcv_wnd != TCP_WND_MAX(pcb)) { - pcb->rcv_wnd++; - } - TCP_EVENT_CLOSED(pcb, err); - if (err == ERR_ABRT) { - goto aborted; - } - } - } - - tcp_input_pcb = NULL; - if (tcp_input_delayed_close(pcb)) { - goto aborted; - } - /* Try to send something out. */ - tcp_output(pcb); -#if TCP_INPUT_DEBUG -#if TCP_DEBUG - tcp_debug_print_state(pcb->state); -#endif /* TCP_DEBUG */ -#endif /* TCP_INPUT_DEBUG */ - } - } - /* Jump target if pcb has been aborted in a callback (by calling tcp_abort()). - Below this line, 'pcb' may not be dereferenced! */ -aborted: - tcp_input_pcb = NULL; - recv_data = NULL; - - /* give up our reference to inseg.p */ - if (inseg.p != NULL) { - pbuf_free(inseg.p); - inseg.p = NULL; - } - } else { - /* If no matching PCB was found, send a TCP RST (reset) to the - sender. */ - LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_input: no PCB match found, resetting.\n")); - if (!(TCPH_FLAGS(tcphdr) & TCP_RST)) { - TCP_STATS_INC(tcp.proterr); - TCP_STATS_INC(tcp.drop); - tcp_rst(NULL, ackno, seqno + tcplen, ip_current_dest_addr(), - ip_current_src_addr(), tcphdr->dest, tcphdr->src); - } - pbuf_free(p); - } - - LWIP_ASSERT("tcp_input: tcp_pcbs_sane()", tcp_pcbs_sane()); - PERF_STOP("tcp_input"); - return; -dropped: - TCP_STATS_INC(tcp.drop); - MIB2_STATS_INC(mib2.tcpinerrs); - pbuf_free(p); -} - -/** Called from tcp_input to check for TF_CLOSED flag. This results in closing - * and deallocating a pcb at the correct place to ensure noone references it - * any more. - * @returns 1 if the pcb has been closed and deallocated, 0 otherwise - */ -static int -tcp_input_delayed_close(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_input_delayed_close: invalid pcb", pcb != NULL); - - if (recv_flags & TF_CLOSED) { - /* The connection has been closed and we will deallocate the - PCB. */ - if (!(pcb->flags & TF_RXCLOSED)) { - /* Connection closed although the application has only shut down the - tx side: call the PCB's err callback and indicate the closure to - ensure the application doesn't continue using the PCB. */ - TCP_EVENT_ERR(pcb->state, pcb->errf, pcb->callback_arg, ERR_CLSD); - } - tcp_pcb_remove(&tcp_active_pcbs, pcb); - tcp_free(pcb); - return 1; - } - return 0; -} - -/** - * Called by tcp_input() when a segment arrives for a listening - * connection (from tcp_input()). - * - * @param pcb the tcp_pcb_listen for which a segment arrived - * - * @note the segment which arrived is saved in global variables, therefore only the pcb - * involved is passed as a parameter to this function - */ -static void -tcp_listen_input(struct tcp_pcb_listen *pcb) -{ - struct tcp_pcb *npcb; - u32_t iss; - err_t rc; - - if (flags & TCP_RST) { - /* An incoming RST should be ignored. Return. */ - return; - } - - LWIP_ASSERT("tcp_listen_input: invalid pcb", pcb != NULL); - - /* In the LISTEN state, we check for incoming SYN segments, - creates a new PCB, and responds with a SYN|ACK. */ - if (flags & TCP_ACK) { - /* For incoming segments with the ACK flag set, respond with a - RST. */ - LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_listen_input: ACK in LISTEN, sending reset\n")); - tcp_rst((const struct tcp_pcb *)pcb, ackno, seqno + tcplen, ip_current_dest_addr(), - ip_current_src_addr(), tcphdr->dest, tcphdr->src); - } else if (flags & TCP_SYN) { - LWIP_DEBUGF(TCP_DEBUG, ("TCP connection request %"U16_F" -> %"U16_F".\n", tcphdr->src, tcphdr->dest)); -#if TCP_LISTEN_BACKLOG - if (pcb->accepts_pending >= pcb->backlog) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_listen_input: listen backlog exceeded for port %"U16_F"\n", tcphdr->dest)); - return; - } -#endif /* TCP_LISTEN_BACKLOG */ - npcb = tcp_alloc(pcb->prio); - /* If a new PCB could not be created (probably due to lack of memory), - we don't do anything, but rely on the sender will retransmit the - SYN at a time when we have more memory available. */ - if (npcb == NULL) { - err_t err; - LWIP_DEBUGF(TCP_DEBUG, ("tcp_listen_input: could not allocate PCB\n")); - TCP_STATS_INC(tcp.memerr); - TCP_EVENT_ACCEPT(pcb, NULL, pcb->callback_arg, ERR_MEM, err); - LWIP_UNUSED_ARG(err); /* err not useful here */ - return; - } -#if TCP_LISTEN_BACKLOG - pcb->accepts_pending++; - tcp_set_flags(npcb, TF_BACKLOGPEND); -#endif /* TCP_LISTEN_BACKLOG */ - /* Set up the new PCB. */ - ip_addr_copy(npcb->local_ip, *ip_current_dest_addr()); - ip_addr_copy(npcb->remote_ip, *ip_current_src_addr()); - npcb->local_port = pcb->local_port; - npcb->remote_port = tcphdr->src; - npcb->state = SYN_RCVD; - npcb->rcv_nxt = seqno + 1; - npcb->rcv_ann_right_edge = npcb->rcv_nxt; - iss = tcp_next_iss(npcb); - npcb->snd_wl2 = iss; - npcb->snd_nxt = iss; - npcb->lastack = iss; - npcb->snd_lbb = iss; - npcb->snd_wl1 = seqno - 1;/* initialise to seqno-1 to force window update */ - npcb->callback_arg = pcb->callback_arg; -#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG - npcb->listener = pcb; -#endif /* LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG */ - /* inherit socket options */ - npcb->so_options = pcb->so_options & SOF_INHERITED; - npcb->netif_idx = pcb->netif_idx; - /* Register the new PCB so that we can begin receiving segments - for it. */ - TCP_REG_ACTIVE(npcb); - - /* Parse any options in the SYN. */ - tcp_parseopt(npcb); - npcb->snd_wnd = tcphdr->wnd; - npcb->snd_wnd_max = npcb->snd_wnd; - -#if TCP_CALCULATE_EFF_SEND_MSS - npcb->mss = tcp_eff_send_mss(npcb->mss, &npcb->local_ip, &npcb->remote_ip); -#endif /* TCP_CALCULATE_EFF_SEND_MSS */ - - MIB2_STATS_INC(mib2.tcppassiveopens); - -#if LWIP_TCP_PCB_NUM_EXT_ARGS - if (tcp_ext_arg_invoke_callbacks_passive_open(pcb, npcb) != ERR_OK) { - tcp_abandon(npcb, 0); - return; - } -#endif - - /* Send a SYN|ACK together with the MSS option. */ - rc = tcp_enqueue_flags(npcb, TCP_SYN | TCP_ACK); - if (rc != ERR_OK) { - tcp_abandon(npcb, 0); - return; - } - tcp_output(npcb); - } - return; -} - -/** - * Called by tcp_input() when a segment arrives for a connection in - * TIME_WAIT. - * - * @param pcb the tcp_pcb for which a segment arrived - * - * @note the segment which arrived is saved in global variables, therefore only the pcb - * involved is passed as a parameter to this function - */ -static void -tcp_timewait_input(struct tcp_pcb *pcb) -{ - /* RFC 1337: in TIME_WAIT, ignore RST and ACK FINs + any 'acceptable' segments */ - /* RFC 793 3.9 Event Processing - Segment Arrives: - * - first check sequence number - we skip that one in TIME_WAIT (always - * acceptable since we only send ACKs) - * - second check the RST bit (... return) */ - if (flags & TCP_RST) { - return; - } - - LWIP_ASSERT("tcp_timewait_input: invalid pcb", pcb != NULL); - - /* - fourth, check the SYN bit, */ - if (flags & TCP_SYN) { - /* If an incoming segment is not acceptable, an acknowledgment - should be sent in reply */ - if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt + pcb->rcv_wnd)) { - /* If the SYN is in the window it is an error, send a reset */ - tcp_rst(pcb, ackno, seqno + tcplen, ip_current_dest_addr(), - ip_current_src_addr(), tcphdr->dest, tcphdr->src); - return; - } - } else if (flags & TCP_FIN) { - /* - eighth, check the FIN bit: Remain in the TIME-WAIT state. - Restart the 2 MSL time-wait timeout.*/ - pcb->tmr = tcp_ticks; - } - - if ((tcplen > 0)) { - /* Acknowledge data, FIN or out-of-window SYN */ - tcp_ack_now(pcb); - tcp_output(pcb); - } - return; -} - -/** - * Implements the TCP state machine. Called by tcp_input. In some - * states tcp_receive() is called to receive data. The tcp_seg - * argument will be freed by the caller (tcp_input()) unless the - * recv_data pointer in the pcb is set. - * - * @param pcb the tcp_pcb for which a segment arrived - * - * @note the segment which arrived is saved in global variables, therefore only the pcb - * involved is passed as a parameter to this function - */ -static err_t -tcp_process(struct tcp_pcb *pcb) -{ - struct tcp_seg *rseg; - u8_t acceptable = 0; - err_t err; - - err = ERR_OK; - - LWIP_ASSERT("tcp_process: invalid pcb", pcb != NULL); - - /* Process incoming RST segments. */ - if (flags & TCP_RST) { - /* First, determine if the reset is acceptable. */ - if (pcb->state == SYN_SENT) { - /* "In the SYN-SENT state (a RST received in response to an initial SYN), - the RST is acceptable if the ACK field acknowledges the SYN." */ - if (ackno == pcb->snd_nxt) { - acceptable = 1; - } - } else { - /* "In all states except SYN-SENT, all reset (RST) segments are validated - by checking their SEQ-fields." */ - if (seqno == pcb->rcv_nxt) { - acceptable = 1; - } else if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, - pcb->rcv_nxt + pcb->rcv_wnd)) { - /* If the sequence number is inside the window, we send a challenge ACK - and wait for a re-send with matching sequence number. - This follows RFC 5961 section 3.2 and addresses CVE-2004-0230 - (RST spoofing attack), which is present in RFC 793 RST handling. */ - tcp_ack_now(pcb); - } - } - - if (acceptable) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: Connection RESET\n")); - LWIP_ASSERT("tcp_input: pcb->state != CLOSED", pcb->state != CLOSED); - recv_flags |= TF_RESET; - tcp_clear_flags(pcb, TF_ACK_DELAY); - return ERR_RST; - } else { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n", - seqno, pcb->rcv_nxt)); - LWIP_DEBUGF(TCP_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n", - seqno, pcb->rcv_nxt)); - return ERR_OK; - } - } - - if ((flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) { - /* Cope with new connection attempt after remote end crashed */ - tcp_ack_now(pcb); - return ERR_OK; - } - - if ((pcb->flags & TF_RXCLOSED) == 0) { - /* Update the PCB (in)activity timer unless rx is closed (see tcp_shutdown) */ - pcb->tmr = tcp_ticks; - } - pcb->keep_cnt_sent = 0; - pcb->persist_probe = 0; - - tcp_parseopt(pcb); - - /* Do different things depending on the TCP state. */ - switch (pcb->state) { - case SYN_SENT: - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("SYN-SENT: ackno %"U32_F" pcb->snd_nxt %"U32_F" unacked %"U32_F"\n", ackno, - pcb->snd_nxt, lwip_ntohl(pcb->unacked->tcphdr->seqno))); - /* received SYN ACK with expected sequence number? */ - if ((flags & TCP_ACK) && (flags & TCP_SYN) - && (ackno == pcb->lastack + 1)) { - pcb->rcv_nxt = seqno + 1; - pcb->rcv_ann_right_edge = pcb->rcv_nxt; - pcb->lastack = ackno; - pcb->snd_wnd = tcphdr->wnd; - pcb->snd_wnd_max = pcb->snd_wnd; - pcb->snd_wl1 = seqno - 1; /* initialise to seqno - 1 to force window update */ - pcb->state = ESTABLISHED; - -#if TCP_CALCULATE_EFF_SEND_MSS - pcb->mss = tcp_eff_send_mss(pcb->mss, &pcb->local_ip, &pcb->remote_ip); -#endif /* TCP_CALCULATE_EFF_SEND_MSS */ - - pcb->cwnd = LWIP_TCP_CALC_INITIAL_CWND(pcb->mss); - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_process (SENT): cwnd %"TCPWNDSIZE_F - " ssthresh %"TCPWNDSIZE_F"\n", - pcb->cwnd, pcb->ssthresh)); - LWIP_ASSERT("pcb->snd_queuelen > 0", (pcb->snd_queuelen > 0)); - --pcb->snd_queuelen; - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_process: SYN-SENT --queuelen %"TCPWNDSIZE_F"\n", (tcpwnd_size_t)pcb->snd_queuelen)); - rseg = pcb->unacked; - if (rseg == NULL) { - /* might happen if tcp_output fails in tcp_rexmit_rto() - in which case the segment is on the unsent list */ - rseg = pcb->unsent; - LWIP_ASSERT("no segment to free", rseg != NULL); - pcb->unsent = rseg->next; - } else { - pcb->unacked = rseg->next; - } - tcp_seg_free(rseg); - - /* If there's nothing left to acknowledge, stop the retransmit - timer, otherwise reset it to start again */ - if (pcb->unacked == NULL) { - pcb->rtime = -1; - } else { - pcb->rtime = 0; - pcb->nrtx = 0; - } - - /* Call the user specified function to call when successfully - * connected. */ - TCP_EVENT_CONNECTED(pcb, ERR_OK, err); - if (err == ERR_ABRT) { - return ERR_ABRT; - } - tcp_ack_now(pcb); - } - /* received ACK? possibly a half-open connection */ - else if (flags & TCP_ACK) { - /* send a RST to bring the other side in a non-synchronized state. */ - tcp_rst(pcb, ackno, seqno + tcplen, ip_current_dest_addr(), - ip_current_src_addr(), tcphdr->dest, tcphdr->src); - /* Resend SYN immediately (don't wait for rto timeout) to establish - connection faster, but do not send more SYNs than we otherwise would - have, or we might get caught in a loop on loopback interfaces. */ - if (pcb->nrtx < TCP_SYNMAXRTX) { - pcb->rtime = 0; - tcp_rexmit_rto(pcb); - } - } - break; - case SYN_RCVD: - if (flags & TCP_ACK) { - /* expected ACK number? */ - if (TCP_SEQ_BETWEEN(ackno, pcb->lastack + 1, pcb->snd_nxt)) { - pcb->state = ESTABLISHED; - LWIP_DEBUGF(TCP_DEBUG, ("TCP connection established %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); -#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG - if (pcb->listener == NULL) { - /* listen pcb might be closed by now */ - err = ERR_VAL; - } else -#endif /* LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG */ - { -#if LWIP_CALLBACK_API - LWIP_ASSERT("pcb->listener->accept != NULL", pcb->listener->accept != NULL); -#endif - tcp_backlog_accepted(pcb); - /* Call the accept function. */ - TCP_EVENT_ACCEPT(pcb->listener, pcb, pcb->callback_arg, ERR_OK, err); - } - if (err != ERR_OK) { - /* If the accept function returns with an error, we abort - * the connection. */ - /* Already aborted? */ - if (err != ERR_ABRT) { - tcp_abort(pcb); - } - return ERR_ABRT; - } - /* If there was any data contained within this ACK, - * we'd better pass it on to the application as well. */ - tcp_receive(pcb); - - /* Prevent ACK for SYN to generate a sent event */ - if (recv_acked != 0) { - recv_acked--; - } - - pcb->cwnd = LWIP_TCP_CALC_INITIAL_CWND(pcb->mss); - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_process (SYN_RCVD): cwnd %"TCPWNDSIZE_F - " ssthresh %"TCPWNDSIZE_F"\n", - pcb->cwnd, pcb->ssthresh)); - - if (recv_flags & TF_GOT_FIN) { - tcp_ack_now(pcb); - pcb->state = CLOSE_WAIT; - } - } else { - /* incorrect ACK number, send RST */ - tcp_rst(pcb, ackno, seqno + tcplen, ip_current_dest_addr(), - ip_current_src_addr(), tcphdr->dest, tcphdr->src); - } - } else if ((flags & TCP_SYN) && (seqno == pcb->rcv_nxt - 1)) { - /* Looks like another copy of the SYN - retransmit our SYN-ACK */ - tcp_rexmit(pcb); - } - break; - case CLOSE_WAIT: - /* FALLTHROUGH */ - case ESTABLISHED: - tcp_receive(pcb); - if (recv_flags & TF_GOT_FIN) { /* passive close */ - tcp_ack_now(pcb); - pcb->state = CLOSE_WAIT; - } - break; - case FIN_WAIT_1: - tcp_receive(pcb); - if (recv_flags & TF_GOT_FIN) { - if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt) && - pcb->unsent == NULL) { - LWIP_DEBUGF(TCP_DEBUG, - ("TCP connection closed: FIN_WAIT_1 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); - tcp_ack_now(pcb); - tcp_pcb_purge(pcb); - TCP_RMV_ACTIVE(pcb); - pcb->state = TIME_WAIT; - TCP_REG(&tcp_tw_pcbs, pcb); - } else { - tcp_ack_now(pcb); - pcb->state = CLOSING; - } - } else if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt) && - pcb->unsent == NULL) { - pcb->state = FIN_WAIT_2; - } - break; - case FIN_WAIT_2: - tcp_receive(pcb); - if (recv_flags & TF_GOT_FIN) { - LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: FIN_WAIT_2 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); - tcp_ack_now(pcb); - tcp_pcb_purge(pcb); - TCP_RMV_ACTIVE(pcb); - pcb->state = TIME_WAIT; - TCP_REG(&tcp_tw_pcbs, pcb); - } - break; - case CLOSING: - tcp_receive(pcb); - if ((flags & TCP_ACK) && ackno == pcb->snd_nxt && pcb->unsent == NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: CLOSING %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); - tcp_pcb_purge(pcb); - TCP_RMV_ACTIVE(pcb); - pcb->state = TIME_WAIT; - TCP_REG(&tcp_tw_pcbs, pcb); - } - break; - case LAST_ACK: - tcp_receive(pcb); - if ((flags & TCP_ACK) && ackno == pcb->snd_nxt && pcb->unsent == NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: LAST_ACK %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); - /* bugfix #21699: don't set pcb->state to CLOSED here or we risk leaking segments */ - recv_flags |= TF_CLOSED; - } - break; - default: - break; - } - return ERR_OK; -} - -#if TCP_QUEUE_OOSEQ -/** - * Insert segment into the list (segments covered with new one will be deleted) - * - * Called from tcp_receive() - */ -static void -tcp_oos_insert_segment(struct tcp_seg *cseg, struct tcp_seg *next) -{ - struct tcp_seg *old_seg; - - LWIP_ASSERT("tcp_oos_insert_segment: invalid cseg", cseg != NULL); - - if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) { - /* received segment overlaps all following segments */ - tcp_segs_free(next); - next = NULL; - } else { - /* delete some following segments - oos queue may have segments with FIN flag */ - while (next && - TCP_SEQ_GEQ((seqno + cseg->len), - (next->tcphdr->seqno + next->len))) { - /* cseg with FIN already processed */ - if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) { - TCPH_SET_FLAG(cseg->tcphdr, TCP_FIN); - } - old_seg = next; - next = next->next; - tcp_seg_free(old_seg); - } - if (next && - TCP_SEQ_GT(seqno + cseg->len, next->tcphdr->seqno)) { - /* We need to trim the incoming segment. */ - cseg->len = (u16_t)(next->tcphdr->seqno - seqno); - pbuf_realloc(cseg->p, cseg->len); - } - } - cseg->next = next; -} -#endif /* TCP_QUEUE_OOSEQ */ - -/** Remove segments from a list if the incoming ACK acknowledges them */ -static struct tcp_seg * -tcp_free_acked_segments(struct tcp_pcb *pcb, struct tcp_seg *seg_list, const char *dbg_list_name, - struct tcp_seg *dbg_other_seg_list) -{ - struct tcp_seg *next; - u16_t clen; - - LWIP_UNUSED_ARG(dbg_list_name); - LWIP_UNUSED_ARG(dbg_other_seg_list); - - while (seg_list != NULL && - TCP_SEQ_LEQ(lwip_ntohl(seg_list->tcphdr->seqno) + - TCP_TCPLEN(seg_list), ackno)) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->%s\n", - lwip_ntohl(seg_list->tcphdr->seqno), - lwip_ntohl(seg_list->tcphdr->seqno) + TCP_TCPLEN(seg_list), - dbg_list_name)); - - next = seg_list; - seg_list = seg_list->next; - - clen = pbuf_clen(next->p); - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_receive: queuelen %"TCPWNDSIZE_F" ... ", - (tcpwnd_size_t)pcb->snd_queuelen)); - LWIP_ASSERT("pcb->snd_queuelen >= pbuf_clen(next->p)", (pcb->snd_queuelen >= clen)); - - pcb->snd_queuelen = (u16_t)(pcb->snd_queuelen - clen); - recv_acked = (tcpwnd_size_t)(recv_acked + next->len); - tcp_seg_free(next); - - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("%"TCPWNDSIZE_F" (after freeing %s)\n", - (tcpwnd_size_t)pcb->snd_queuelen, - dbg_list_name)); - if (pcb->snd_queuelen != 0) { - LWIP_ASSERT("tcp_receive: valid queue length", - seg_list != NULL || dbg_other_seg_list != NULL); - } - } - return seg_list; -} - -/** - * Called by tcp_process. Checks if the given segment is an ACK for outstanding - * data, and if so frees the memory of the buffered data. Next, it places the - * segment on any of the receive queues (pcb->recved or pcb->ooseq). If the segment - * is buffered, the pbuf is referenced by pbuf_ref so that it will not be freed until - * it has been removed from the buffer. - * - * If the incoming segment constitutes an ACK for a segment that was used for RTT - * estimation, the RTT is estimated here as well. - * - * Called from tcp_process(). - */ -static void -tcp_receive(struct tcp_pcb *pcb) -{ - s16_t m; - u32_t right_wnd_edge; - int found_dupack = 0; - - LWIP_ASSERT("tcp_receive: invalid pcb", pcb != NULL); - LWIP_ASSERT("tcp_receive: wrong state", pcb->state >= ESTABLISHED); - - if (flags & TCP_ACK) { - right_wnd_edge = pcb->snd_wnd + pcb->snd_wl2; - - /* Update window. */ - if (TCP_SEQ_LT(pcb->snd_wl1, seqno) || - (pcb->snd_wl1 == seqno && TCP_SEQ_LT(pcb->snd_wl2, ackno)) || - (pcb->snd_wl2 == ackno && (u32_t)SND_WND_SCALE(pcb, tcphdr->wnd) > pcb->snd_wnd)) { - pcb->snd_wnd = SND_WND_SCALE(pcb, tcphdr->wnd); - /* keep track of the biggest window announced by the remote host to calculate - the maximum segment size */ - if (pcb->snd_wnd_max < pcb->snd_wnd) { - pcb->snd_wnd_max = pcb->snd_wnd; - } - pcb->snd_wl1 = seqno; - pcb->snd_wl2 = ackno; - LWIP_DEBUGF(TCP_WND_DEBUG, ("tcp_receive: window update %"TCPWNDSIZE_F"\n", pcb->snd_wnd)); -#if TCP_WND_DEBUG - } else { - if (pcb->snd_wnd != (tcpwnd_size_t)SND_WND_SCALE(pcb, tcphdr->wnd)) { - LWIP_DEBUGF(TCP_WND_DEBUG, - ("tcp_receive: no window update lastack %"U32_F" ackno %" - U32_F" wl1 %"U32_F" seqno %"U32_F" wl2 %"U32_F"\n", - pcb->lastack, ackno, pcb->snd_wl1, seqno, pcb->snd_wl2)); - } -#endif /* TCP_WND_DEBUG */ - } - - /* (From Stevens TCP/IP Illustrated Vol II, p970.) Its only a - * duplicate ack if: - * 1) It doesn't ACK new data - * 2) length of received packet is zero (i.e. no payload) - * 3) the advertised window hasn't changed - * 4) There is outstanding unacknowledged data (retransmission timer running) - * 5) The ACK is == biggest ACK sequence number so far seen (snd_una) - * - * If it passes all five, should process as a dupack: - * a) dupacks < 3: do nothing - * b) dupacks == 3: fast retransmit - * c) dupacks > 3: increase cwnd - * - * If it only passes 1-3, should reset dupack counter (and add to - * stats, which we don't do in lwIP) - * - * If it only passes 1, should reset dupack counter - * - */ - - /* Clause 1 */ - if (TCP_SEQ_LEQ(ackno, pcb->lastack)) { - /* Clause 2 */ - if (tcplen == 0) { - /* Clause 3 */ - if (pcb->snd_wl2 + pcb->snd_wnd == right_wnd_edge) { - /* Clause 4 */ - if (pcb->rtime >= 0) { - /* Clause 5 */ - if (pcb->lastack == ackno) { - found_dupack = 1; - if ((u8_t)(pcb->dupacks + 1) > pcb->dupacks) { - ++pcb->dupacks; - } - if (pcb->dupacks > 3) { - /* Inflate the congestion window */ - TCP_WND_INC(pcb->cwnd, pcb->mss); - } - if (pcb->dupacks >= 3) { - /* Do fast retransmit (checked via TF_INFR, not via dupacks count) */ - tcp_rexmit_fast(pcb); - } - } - } - } - } - /* If Clause (1) or more is true, but not a duplicate ack, reset - * count of consecutive duplicate acks */ - if (!found_dupack) { - pcb->dupacks = 0; - } - } else if (TCP_SEQ_BETWEEN(ackno, pcb->lastack + 1, pcb->snd_nxt)) { - /* We come here when the ACK acknowledges new data. */ - tcpwnd_size_t acked; - - /* Reset the "IN Fast Retransmit" flag, since we are no longer - in fast retransmit. Also reset the congestion window to the - slow start threshold. */ - if (pcb->flags & TF_INFR) { - tcp_clear_flags(pcb, TF_INFR); - pcb->cwnd = pcb->ssthresh; - pcb->bytes_acked = 0; - } - - /* Reset the number of retransmissions. */ - pcb->nrtx = 0; - - /* Reset the retransmission time-out. */ - pcb->rto = (s16_t)((pcb->sa >> 3) + pcb->sv); - - /* Record how much data this ACK acks */ - acked = (tcpwnd_size_t)(ackno - pcb->lastack); - - /* Reset the fast retransmit variables. */ - pcb->dupacks = 0; - pcb->lastack = ackno; - - /* Update the congestion control variables (cwnd and - ssthresh). */ - if (pcb->state >= ESTABLISHED) { - if (pcb->cwnd < pcb->ssthresh) { - tcpwnd_size_t increase; - /* limit to 1 SMSS segment during period following RTO */ - u8_t num_seg = (pcb->flags & TF_RTO) ? 1 : 2; - /* RFC 3465, section 2.2 Slow Start */ - increase = LWIP_MIN(acked, (tcpwnd_size_t)(num_seg * pcb->mss)); - TCP_WND_INC(pcb->cwnd, increase); - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_receive: slow start cwnd %"TCPWNDSIZE_F"\n", pcb->cwnd)); - } else { - /* RFC 3465, section 2.1 Congestion Avoidance */ - TCP_WND_INC(pcb->bytes_acked, acked); - if (pcb->bytes_acked >= pcb->cwnd) { - pcb->bytes_acked = (tcpwnd_size_t)(pcb->bytes_acked - pcb->cwnd); - TCP_WND_INC(pcb->cwnd, pcb->mss); - } - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_receive: congestion avoidance cwnd %"TCPWNDSIZE_F"\n", pcb->cwnd)); - } - } - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: ACK for %"U32_F", unacked->seqno %"U32_F":%"U32_F"\n", - ackno, - pcb->unacked != NULL ? - lwip_ntohl(pcb->unacked->tcphdr->seqno) : 0, - pcb->unacked != NULL ? - lwip_ntohl(pcb->unacked->tcphdr->seqno) + TCP_TCPLEN(pcb->unacked) : 0)); - - /* Remove segment from the unacknowledged list if the incoming - ACK acknowledges them. */ - pcb->unacked = tcp_free_acked_segments(pcb, pcb->unacked, "unacked", pcb->unsent); - /* We go through the ->unsent list to see if any of the segments - on the list are acknowledged by the ACK. This may seem - strange since an "unsent" segment shouldn't be acked. The - rationale is that lwIP puts all outstanding segments on the - ->unsent list after a retransmission, so these segments may - in fact have been sent once. */ - pcb->unsent = tcp_free_acked_segments(pcb, pcb->unsent, "unsent", pcb->unacked); - - /* If there's nothing left to acknowledge, stop the retransmit - timer, otherwise reset it to start again */ - if (pcb->unacked == NULL) { - pcb->rtime = -1; - } else { - pcb->rtime = 0; - } - - pcb->polltmr = 0; - -#if TCP_OVERSIZE - if (pcb->unsent == NULL) { - pcb->unsent_oversize = 0; - } -#endif /* TCP_OVERSIZE */ - -#if LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS - if (ip_current_is_v6()) { - /* Inform neighbor reachability of forward progress. */ - nd6_reachability_hint(ip6_current_src_addr()); - } -#endif /* LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS*/ - - pcb->snd_buf = (tcpwnd_size_t)(pcb->snd_buf + recv_acked); - /* check if this ACK ends our retransmission of in-flight data */ - if (pcb->flags & TF_RTO) { - /* RTO is done if - 1) both queues are empty or - 2) unacked is empty and unsent head contains data not part of RTO or - 3) unacked head contains data not part of RTO */ - if (pcb->unacked == NULL) { - if ((pcb->unsent == NULL) || - (TCP_SEQ_LEQ(pcb->rto_end, lwip_ntohl(pcb->unsent->tcphdr->seqno)))) { - tcp_clear_flags(pcb, TF_RTO); - } - } else if (TCP_SEQ_LEQ(pcb->rto_end, lwip_ntohl(pcb->unacked->tcphdr->seqno))) { - tcp_clear_flags(pcb, TF_RTO); - } - } - /* End of ACK for new data processing. */ - } else { - /* Out of sequence ACK, didn't really ack anything */ - tcp_send_empty_ack(pcb); - } - - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: pcb->rttest %"U32_F" rtseq %"U32_F" ackno %"U32_F"\n", - pcb->rttest, pcb->rtseq, ackno)); - - /* RTT estimation calculations. This is done by checking if the - incoming segment acknowledges the segment we use to take a - round-trip time measurement. */ - if (pcb->rttest && TCP_SEQ_LT(pcb->rtseq, ackno)) { - /* diff between this shouldn't exceed 32K since this are tcp timer ticks - and a round-trip shouldn't be that long... */ - m = (s16_t)(tcp_ticks - pcb->rttest); - - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: experienced rtt %"U16_F" ticks (%"U16_F" msec).\n", - m, (u16_t)(m * TCP_SLOW_INTERVAL))); - - /* This is taken directly from VJs original code in his paper */ - m = (s16_t)(m - (pcb->sa >> 3)); - pcb->sa = (s16_t)(pcb->sa + m); - if (m < 0) { - m = (s16_t) - m; - } - m = (s16_t)(m - (pcb->sv >> 2)); - pcb->sv = (s16_t)(pcb->sv + m); - pcb->rto = (s16_t)((pcb->sa >> 3) + pcb->sv); - - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: RTO %"U16_F" (%"U16_F" milliseconds)\n", - pcb->rto, (u16_t)(pcb->rto * TCP_SLOW_INTERVAL))); - - pcb->rttest = 0; - } - } - - /* If the incoming segment contains data, we must process it - further unless the pcb already received a FIN. - (RFC 793, chapter 3.9, "SEGMENT ARRIVES" in states CLOSE-WAIT, CLOSING, - LAST-ACK and TIME-WAIT: "Ignore the segment text.") */ - if ((tcplen > 0) && (pcb->state < CLOSE_WAIT)) { - /* This code basically does three things: - - +) If the incoming segment contains data that is the next - in-sequence data, this data is passed to the application. This - might involve trimming the first edge of the data. The rcv_nxt - variable and the advertised window are adjusted. - - +) If the incoming segment has data that is above the next - sequence number expected (->rcv_nxt), the segment is placed on - the ->ooseq queue. This is done by finding the appropriate - place in the ->ooseq queue (which is ordered by sequence - number) and trim the segment in both ends if needed. An - immediate ACK is sent to indicate that we received an - out-of-sequence segment. - - +) Finally, we check if the first segment on the ->ooseq queue - now is in sequence (i.e., if rcv_nxt >= ooseq->seqno). If - rcv_nxt > ooseq->seqno, we must trim the first edge of the - segment on ->ooseq before we adjust rcv_nxt. The data in the - segments that are now on sequence are chained onto the - incoming segment so that we only need to call the application - once. - */ - - /* First, we check if we must trim the first edge. We have to do - this if the sequence number of the incoming segment is less - than rcv_nxt, and the sequence number plus the length of the - segment is larger than rcv_nxt. */ - /* if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)) { - if (TCP_SEQ_LT(pcb->rcv_nxt, seqno + tcplen)) {*/ - if (TCP_SEQ_BETWEEN(pcb->rcv_nxt, seqno + 1, seqno + tcplen - 1)) { - /* Trimming the first edge is done by pushing the payload - pointer in the pbuf downwards. This is somewhat tricky since - we do not want to discard the full contents of the pbuf up to - the new starting point of the data since we have to keep the - TCP header which is present in the first pbuf in the chain. - - What is done is really quite a nasty hack: the first pbuf in - the pbuf chain is pointed to by inseg.p. Since we need to be - able to deallocate the whole pbuf, we cannot change this - inseg.p pointer to point to any of the later pbufs in the - chain. Instead, we point the ->payload pointer in the first - pbuf to data in one of the later pbufs. We also set the - inseg.data pointer to point to the right place. This way, the - ->p pointer will still point to the first pbuf, but the - ->p->payload pointer will point to data in another pbuf. - - After we are done with adjusting the pbuf pointers we must - adjust the ->data pointer in the seg and the segment - length.*/ - - struct pbuf *p = inseg.p; - u32_t off32 = pcb->rcv_nxt - seqno; - u16_t new_tot_len, off; - LWIP_ASSERT("inseg.p != NULL", inseg.p); - LWIP_ASSERT("insane offset!", (off32 < 0xffff)); - off = (u16_t)off32; - LWIP_ASSERT("pbuf too short!", (((s32_t)inseg.p->tot_len) >= off)); - inseg.len -= off; - new_tot_len = (u16_t)(inseg.p->tot_len - off); - while (p->len < off) { - off -= p->len; - /* all pbufs up to and including this one have len==0, so tot_len is equal */ - p->tot_len = new_tot_len; - p->len = 0; - p = p->next; - } - /* cannot fail... */ - pbuf_remove_header(p, off); - inseg.tcphdr->seqno = seqno = pcb->rcv_nxt; - } else { - if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)) { - /* the whole segment is < rcv_nxt */ - /* must be a duplicate of a packet that has already been correctly handled */ - - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: duplicate seqno %"U32_F"\n", seqno)); - tcp_ack_now(pcb); - } - } - - /* The sequence number must be within the window (above rcv_nxt - and below rcv_nxt + rcv_wnd) in order to be further - processed. */ - if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, - pcb->rcv_nxt + pcb->rcv_wnd - 1)) { - if (pcb->rcv_nxt == seqno) { - /* The incoming segment is the next in sequence. We check if - we have to trim the end of the segment and update rcv_nxt - and pass the data to the application. */ - tcplen = TCP_TCPLEN(&inseg); - - if (tcplen > pcb->rcv_wnd) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, - ("tcp_receive: other end overran receive window" - "seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n", - seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd)); - if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) { - /* Must remove the FIN from the header as we're trimming - * that byte of sequence-space from the packet */ - TCPH_FLAGS_SET(inseg.tcphdr, TCPH_FLAGS(inseg.tcphdr) & ~(unsigned int)TCP_FIN); - } - /* Adjust length of segment to fit in the window. */ - TCPWND_CHECK16(pcb->rcv_wnd); - inseg.len = (u16_t)pcb->rcv_wnd; - if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) { - inseg.len -= 1; - } - pbuf_realloc(inseg.p, inseg.len); - tcplen = TCP_TCPLEN(&inseg); - LWIP_ASSERT("tcp_receive: segment not trimmed correctly to rcv_wnd\n", - (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd)); - } -#if TCP_QUEUE_OOSEQ - /* Received in-sequence data, adjust ooseq data if: - - FIN has been received or - - inseq overlaps with ooseq */ - if (pcb->ooseq != NULL) { - if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, - ("tcp_receive: received in-order FIN, binning ooseq queue\n")); - /* Received in-order FIN means anything that was received - * out of order must now have been received in-order, so - * bin the ooseq queue */ - while (pcb->ooseq != NULL) { - struct tcp_seg *old_ooseq = pcb->ooseq; - pcb->ooseq = pcb->ooseq->next; - tcp_seg_free(old_ooseq); - } - } else { - struct tcp_seg *next = pcb->ooseq; - /* Remove all segments on ooseq that are covered by inseg already. - * FIN is copied from ooseq to inseg if present. */ - while (next && - TCP_SEQ_GEQ(seqno + tcplen, - next->tcphdr->seqno + next->len)) { - struct tcp_seg *tmp; - /* inseg cannot have FIN here (already processed above) */ - if ((TCPH_FLAGS(next->tcphdr) & TCP_FIN) != 0 && - (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) == 0) { - TCPH_SET_FLAG(inseg.tcphdr, TCP_FIN); - tcplen = TCP_TCPLEN(&inseg); - } - tmp = next; - next = next->next; - tcp_seg_free(tmp); - } - /* Now trim right side of inseg if it overlaps with the first - * segment on ooseq */ - if (next && - TCP_SEQ_GT(seqno + tcplen, - next->tcphdr->seqno)) { - /* inseg cannot have FIN here (already processed above) */ - inseg.len = (u16_t)(next->tcphdr->seqno - seqno); - if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) { - inseg.len -= 1; - } - pbuf_realloc(inseg.p, inseg.len); - tcplen = TCP_TCPLEN(&inseg); - LWIP_ASSERT("tcp_receive: segment not trimmed correctly to ooseq queue\n", - (seqno + tcplen) == next->tcphdr->seqno); - } - pcb->ooseq = next; - } - } -#endif /* TCP_QUEUE_OOSEQ */ - - pcb->rcv_nxt = seqno + tcplen; - - /* Update the receiver's (our) window. */ - LWIP_ASSERT("tcp_receive: tcplen > rcv_wnd\n", pcb->rcv_wnd >= tcplen); - pcb->rcv_wnd -= tcplen; - - tcp_update_rcv_ann_wnd(pcb); - - /* If there is data in the segment, we make preparations to - pass this up to the application. The ->recv_data variable - is used for holding the pbuf that goes to the - application. The code for reassembling out-of-sequence data - chains its data on this pbuf as well. - - If the segment was a FIN, we set the TF_GOT_FIN flag that will - be used to indicate to the application that the remote side has - closed its end of the connection. */ - if (inseg.p->tot_len > 0) { - recv_data = inseg.p; - /* Since this pbuf now is the responsibility of the - application, we delete our reference to it so that we won't - (mistakingly) deallocate it. */ - inseg.p = NULL; - } - if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: received FIN.\n")); - recv_flags |= TF_GOT_FIN; - } - -#if TCP_QUEUE_OOSEQ - /* We now check if we have segments on the ->ooseq queue that - are now in sequence. */ - while (pcb->ooseq != NULL && - pcb->ooseq->tcphdr->seqno == pcb->rcv_nxt) { - - struct tcp_seg *cseg = pcb->ooseq; - seqno = pcb->ooseq->tcphdr->seqno; - - pcb->rcv_nxt += TCP_TCPLEN(cseg); - LWIP_ASSERT("tcp_receive: ooseq tcplen > rcv_wnd\n", - pcb->rcv_wnd >= TCP_TCPLEN(cseg)); - pcb->rcv_wnd -= TCP_TCPLEN(cseg); - - tcp_update_rcv_ann_wnd(pcb); - - if (cseg->p->tot_len > 0) { - /* Chain this pbuf onto the pbuf that we will pass to - the application. */ - /* With window scaling, this can overflow recv_data->tot_len, but - that's not a problem since we explicitly fix that before passing - recv_data to the application. */ - if (recv_data) { - pbuf_cat(recv_data, cseg->p); - } else { - recv_data = cseg->p; - } - cseg->p = NULL; - } - if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: dequeued FIN.\n")); - recv_flags |= TF_GOT_FIN; - if (pcb->state == ESTABLISHED) { /* force passive close or we can move to active close */ - pcb->state = CLOSE_WAIT; - } - } - - pcb->ooseq = cseg->next; - tcp_seg_free(cseg); - } -#if LWIP_TCP_SACK_OUT - if (pcb->flags & TF_SACK) { - if (pcb->ooseq != NULL) { - /* Some segments may have been removed from ooseq, let's remove all SACKs that - describe anything before the new beginning of that list. */ - tcp_remove_sacks_lt(pcb, pcb->ooseq->tcphdr->seqno); - } else if (LWIP_TCP_SACK_VALID(pcb, 0)) { - /* ooseq has been cleared. Nothing to SACK */ - memset(pcb->rcv_sacks, 0, sizeof(pcb->rcv_sacks)); - } - } -#endif /* LWIP_TCP_SACK_OUT */ -#endif /* TCP_QUEUE_OOSEQ */ - - - /* Acknowledge the segment(s). */ - tcp_ack(pcb); - -#if LWIP_TCP_SACK_OUT - if (LWIP_TCP_SACK_VALID(pcb, 0)) { - /* Normally the ACK for the data received could be piggy-backed on a data packet, - but lwIP currently does not support including SACKs in data packets. So we force - it to respond with an empty ACK packet (only if there is at least one SACK to be sent). - NOTE: tcp_send_empty_ack() on success clears the ACK flags (set by tcp_ack()) */ - tcp_send_empty_ack(pcb); - } -#endif /* LWIP_TCP_SACK_OUT */ - -#if LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS - if (ip_current_is_v6()) { - /* Inform neighbor reachability of forward progress. */ - nd6_reachability_hint(ip6_current_src_addr()); - } -#endif /* LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS*/ - - } else { - /* We get here if the incoming segment is out-of-sequence. */ - -#if TCP_QUEUE_OOSEQ - /* We queue the segment on the ->ooseq queue. */ - if (pcb->ooseq == NULL) { - pcb->ooseq = tcp_seg_copy(&inseg); -#if LWIP_TCP_SACK_OUT - if (pcb->flags & TF_SACK) { - /* All the SACKs should be invalid, so we can simply store the most recent one: */ - pcb->rcv_sacks[0].left = seqno; - pcb->rcv_sacks[0].right = seqno + inseg.len; - } -#endif /* LWIP_TCP_SACK_OUT */ - } else { - /* If the queue is not empty, we walk through the queue and - try to find a place where the sequence number of the - incoming segment is between the sequence numbers of the - previous and the next segment on the ->ooseq queue. That is - the place where we put the incoming segment. If needed, we - trim the second edges of the previous and the incoming - segment so that it will fit into the sequence. - - If the incoming segment has the same sequence number as a - segment on the ->ooseq queue, we discard the segment that - contains less data. */ - -#if LWIP_TCP_SACK_OUT - /* This is the left edge of the lowest possible SACK range. - It may start before the newly received segment (possibly adjusted below). */ - u32_t sackbeg = TCP_SEQ_LT(seqno, pcb->ooseq->tcphdr->seqno) ? seqno : pcb->ooseq->tcphdr->seqno; -#endif /* LWIP_TCP_SACK_OUT */ - struct tcp_seg *next, *prev = NULL; - for (next = pcb->ooseq; next != NULL; next = next->next) { - if (seqno == next->tcphdr->seqno) { - /* The sequence number of the incoming segment is the - same as the sequence number of the segment on - ->ooseq. We check the lengths to see which one to - discard. */ - if (inseg.len > next->len) { - /* The incoming segment is larger than the old - segment. We replace some segments with the new - one. */ - struct tcp_seg *cseg = tcp_seg_copy(&inseg); - if (cseg != NULL) { - if (prev != NULL) { - prev->next = cseg; - } else { - pcb->ooseq = cseg; - } - tcp_oos_insert_segment(cseg, next); - } - break; - } else { - /* Either the lengths are the same or the incoming - segment was smaller than the old one; in either - case, we ditch the incoming segment. */ - break; - } - } else { - if (prev == NULL) { - if (TCP_SEQ_LT(seqno, next->tcphdr->seqno)) { - /* The sequence number of the incoming segment is lower - than the sequence number of the first segment on the - queue. We put the incoming segment first on the - queue. */ - struct tcp_seg *cseg = tcp_seg_copy(&inseg); - if (cseg != NULL) { - pcb->ooseq = cseg; - tcp_oos_insert_segment(cseg, next); - } - break; - } - } else { - /*if (TCP_SEQ_LT(prev->tcphdr->seqno, seqno) && - TCP_SEQ_LT(seqno, next->tcphdr->seqno)) {*/ - if (TCP_SEQ_BETWEEN(seqno, prev->tcphdr->seqno + 1, next->tcphdr->seqno - 1)) { - /* The sequence number of the incoming segment is in - between the sequence numbers of the previous and - the next segment on ->ooseq. We trim trim the previous - segment, delete next segments that included in received segment - and trim received, if needed. */ - struct tcp_seg *cseg = tcp_seg_copy(&inseg); - if (cseg != NULL) { - if (TCP_SEQ_GT(prev->tcphdr->seqno + prev->len, seqno)) { - /* We need to trim the prev segment. */ - prev->len = (u16_t)(seqno - prev->tcphdr->seqno); - pbuf_realloc(prev->p, prev->len); - } - prev->next = cseg; - tcp_oos_insert_segment(cseg, next); - } - break; - } - } - -#if LWIP_TCP_SACK_OUT - /* The new segment goes after the 'next' one. If there is a "hole" in sequence numbers - between 'prev' and the beginning of 'next', we want to move sackbeg. */ - if (prev != NULL && prev->tcphdr->seqno + prev->len != next->tcphdr->seqno) { - sackbeg = next->tcphdr->seqno; - } -#endif /* LWIP_TCP_SACK_OUT */ - - /* We don't use 'prev' below, so let's set it to current 'next'. - This way even if we break the loop below, 'prev' will be pointing - at the segment right in front of the newly added one. */ - prev = next; - - /* If the "next" segment is the last segment on the - ooseq queue, we add the incoming segment to the end - of the list. */ - if (next->next == NULL && - TCP_SEQ_GT(seqno, next->tcphdr->seqno)) { - if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) { - /* segment "next" already contains all data */ - break; - } - next->next = tcp_seg_copy(&inseg); - if (next->next != NULL) { - if (TCP_SEQ_GT(next->tcphdr->seqno + next->len, seqno)) { - /* We need to trim the last segment. */ - next->len = (u16_t)(seqno - next->tcphdr->seqno); - pbuf_realloc(next->p, next->len); - } - /* check if the remote side overruns our receive window */ - if (TCP_SEQ_GT((u32_t)tcplen + seqno, pcb->rcv_nxt + (u32_t)pcb->rcv_wnd)) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, - ("tcp_receive: other end overran receive window" - "seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n", - seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd)); - if (TCPH_FLAGS(next->next->tcphdr) & TCP_FIN) { - /* Must remove the FIN from the header as we're trimming - * that byte of sequence-space from the packet */ - TCPH_FLAGS_SET(next->next->tcphdr, TCPH_FLAGS(next->next->tcphdr) & ~TCP_FIN); - } - /* Adjust length of segment to fit in the window. */ - next->next->len = (u16_t)(pcb->rcv_nxt + pcb->rcv_wnd - seqno); - pbuf_realloc(next->next->p, next->next->len); - tcplen = TCP_TCPLEN(next->next); - LWIP_ASSERT("tcp_receive: segment not trimmed correctly to rcv_wnd\n", - (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd)); - } - } - break; - } - } - } - -#if LWIP_TCP_SACK_OUT - if (pcb->flags & TF_SACK) { - if (prev == NULL) { - /* The new segment is at the beginning. sackbeg should already be set properly. - We need to find the right edge. */ - next = pcb->ooseq; - } else if (prev->next != NULL) { - /* The new segment was added after 'prev'. If there is a "hole" between 'prev' and 'prev->next', - we need to move sackbeg. After that we should find the right edge. */ - next = prev->next; - if (prev->tcphdr->seqno + prev->len != next->tcphdr->seqno) { - sackbeg = next->tcphdr->seqno; - } - } else { - next = NULL; - } - if (next != NULL) { - u32_t sackend = next->tcphdr->seqno; - for ( ; (next != NULL) && (sackend == next->tcphdr->seqno); next = next->next) { - sackend += next->len; - } - tcp_add_sack(pcb, sackbeg, sackend); - } - } -#endif /* LWIP_TCP_SACK_OUT */ - } -#if defined(TCP_OOSEQ_BYTES_LIMIT) || defined(TCP_OOSEQ_PBUFS_LIMIT) - { - /* Check that the data on ooseq doesn't exceed one of the limits - and throw away everything above that limit. */ -#ifdef TCP_OOSEQ_BYTES_LIMIT - const u32_t ooseq_max_blen = TCP_OOSEQ_BYTES_LIMIT(pcb); - u32_t ooseq_blen = 0; -#endif -#ifdef TCP_OOSEQ_PBUFS_LIMIT - const u16_t ooseq_max_qlen = TCP_OOSEQ_PBUFS_LIMIT(pcb); - u16_t ooseq_qlen = 0; -#endif - struct tcp_seg *next, *prev = NULL; - for (next = pcb->ooseq; next != NULL; prev = next, next = next->next) { - struct pbuf *p = next->p; - int stop_here = 0; -#ifdef TCP_OOSEQ_BYTES_LIMIT - ooseq_blen += p->tot_len; - if (ooseq_blen > ooseq_max_blen) { - stop_here = 1; - } -#endif -#ifdef TCP_OOSEQ_PBUFS_LIMIT - ooseq_qlen += pbuf_clen(p); - if (ooseq_qlen > ooseq_max_qlen) { - stop_here = 1; - } -#endif - if (stop_here) { -#if LWIP_TCP_SACK_OUT - if (pcb->flags & TF_SACK) { - /* Let's remove all SACKs from next's seqno up. */ - tcp_remove_sacks_gt(pcb, next->tcphdr->seqno); - } -#endif /* LWIP_TCP_SACK_OUT */ - /* too much ooseq data, dump this and everything after it */ - tcp_segs_free(next); - if (prev == NULL) { - /* first ooseq segment is too much, dump the whole queue */ - pcb->ooseq = NULL; - } else { - /* just dump 'next' and everything after it */ - prev->next = NULL; - } - break; - } - } - } -#endif /* TCP_OOSEQ_BYTES_LIMIT || TCP_OOSEQ_PBUFS_LIMIT */ -#endif /* TCP_QUEUE_OOSEQ */ - - /* We send the ACK packet after we've (potentially) dealt with SACKs, - so they can be included in the acknowledgment. */ - tcp_send_empty_ack(pcb); - } - } else { - /* The incoming segment is not within the window. */ - tcp_send_empty_ack(pcb); - } - } else { - /* Segments with length 0 is taken care of here. Segments that - fall out of the window are ACKed. */ - if (!TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt + pcb->rcv_wnd - 1)) { - tcp_ack_now(pcb); - } - } -} - -static u8_t -tcp_get_next_optbyte(void) -{ - u16_t optidx = tcp_optidx++; - if ((tcphdr_opt2 == NULL) || (optidx < tcphdr_opt1len)) { - u8_t *opts = (u8_t *)tcphdr + TCP_HLEN; - return opts[optidx]; - } else { - u8_t idx = (u8_t)(optidx - tcphdr_opt1len); - return tcphdr_opt2[idx]; - } -} - -/** - * Parses the options contained in the incoming segment. - * - * Called from tcp_listen_input() and tcp_process(). - * Currently, only the MSS option is supported! - * - * @param pcb the tcp_pcb for which a segment arrived - */ -static void -tcp_parseopt(struct tcp_pcb *pcb) -{ - u8_t data; - u16_t mss; -#if LWIP_TCP_TIMESTAMPS - u32_t tsval; -#endif - - LWIP_ASSERT("tcp_parseopt: invalid pcb", pcb != NULL); - - /* Parse the TCP MSS option, if present. */ - if (tcphdr_optlen != 0) { - for (tcp_optidx = 0; tcp_optidx < tcphdr_optlen; ) { - u8_t opt = tcp_get_next_optbyte(); - switch (opt) { - case LWIP_TCP_OPT_EOL: - /* End of options. */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: EOL\n")); - return; - case LWIP_TCP_OPT_NOP: - /* NOP option. */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: NOP\n")); - break; - case LWIP_TCP_OPT_MSS: - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: MSS\n")); - if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_MSS || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_MSS) > tcphdr_optlen) { - /* Bad length */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); - return; - } - /* An MSS option with the right option length. */ - mss = (u16_t)(tcp_get_next_optbyte() << 8); - mss |= tcp_get_next_optbyte(); - /* Limit the mss to the configured TCP_MSS and prevent division by zero */ - pcb->mss = ((mss > TCP_MSS) || (mss == 0)) ? TCP_MSS : mss; - break; -#if LWIP_WND_SCALE - case LWIP_TCP_OPT_WS: - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: WND_SCALE\n")); - if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_WS || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_WS) > tcphdr_optlen) { - /* Bad length */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); - return; - } - /* An WND_SCALE option with the right option length. */ - data = tcp_get_next_optbyte(); - /* If syn was received with wnd scale option, - activate wnd scale opt, but only if this is not a retransmission */ - if ((flags & TCP_SYN) && !(pcb->flags & TF_WND_SCALE)) { - pcb->snd_scale = data; - if (pcb->snd_scale > 14U) { - pcb->snd_scale = 14U; - } - pcb->rcv_scale = TCP_RCV_SCALE; - tcp_set_flags(pcb, TF_WND_SCALE); - /* window scaling is enabled, we can use the full receive window */ - LWIP_ASSERT("window not at default value", pcb->rcv_wnd == TCPWND_MIN16(TCP_WND)); - LWIP_ASSERT("window not at default value", pcb->rcv_ann_wnd == TCPWND_MIN16(TCP_WND)); - pcb->rcv_wnd = pcb->rcv_ann_wnd = TCP_WND; - } - break; -#endif /* LWIP_WND_SCALE */ -#if LWIP_TCP_TIMESTAMPS - case LWIP_TCP_OPT_TS: - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: TS\n")); - if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_TS || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_TS) > tcphdr_optlen) { - /* Bad length */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); - return; - } - /* TCP timestamp option with valid length */ - tsval = tcp_get_next_optbyte(); - tsval |= (tcp_get_next_optbyte() << 8); - tsval |= (tcp_get_next_optbyte() << 16); - tsval |= (tcp_get_next_optbyte() << 24); - if (flags & TCP_SYN) { - pcb->ts_recent = lwip_ntohl(tsval); - /* Enable sending timestamps in every segment now that we know - the remote host supports it. */ - tcp_set_flags(pcb, TF_TIMESTAMP); - } else if (TCP_SEQ_BETWEEN(pcb->ts_lastacksent, seqno, seqno + tcplen)) { - pcb->ts_recent = lwip_ntohl(tsval); - } - /* Advance to next option (6 bytes already read) */ - tcp_optidx += LWIP_TCP_OPT_LEN_TS - 6; - break; -#endif /* LWIP_TCP_TIMESTAMPS */ -#if LWIP_TCP_SACK_OUT - case LWIP_TCP_OPT_SACK_PERM: - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: SACK_PERM\n")); - if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_SACK_PERM || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_SACK_PERM) > tcphdr_optlen) { - /* Bad length */ - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); - return; - } - /* TCP SACK_PERM option with valid length */ - if (flags & TCP_SYN) { - /* We only set it if we receive it in a SYN (or SYN+ACK) packet */ - tcp_set_flags(pcb, TF_SACK); - } - break; -#endif /* LWIP_TCP_SACK_OUT */ - default: - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: other\n")); - data = tcp_get_next_optbyte(); - if (data < 2) { - LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); - /* If the length field is zero, the options are malformed - and we don't process them further. */ - return; - } - /* All other options have a length field, so that we easily - can skip past them. */ - tcp_optidx += data - 2; - } - } - } -} - -void -tcp_trigger_input_pcb_close(void) -{ - recv_flags |= TF_CLOSED; -} - -#if LWIP_TCP_SACK_OUT -/** - * Called by tcp_receive() to add new SACK entry. - * - * The new SACK entry will be placed at the beginning of rcv_sacks[], as the newest one. - * Existing SACK entries will be "pushed back", to preserve their order. - * This is the behavior described in RFC 2018, section 4. - * - * @param pcb the tcp_pcb for which a segment arrived - * @param left the left side of the SACK (the first sequence number) - * @param right the right side of the SACK (the first sequence number past this SACK) - */ -static void -tcp_add_sack(struct tcp_pcb *pcb, u32_t left, u32_t right) -{ - u8_t i; - u8_t unused_idx; - - if ((pcb->flags & TF_SACK) == 0 || !TCP_SEQ_LT(left, right)) { - return; - } - - /* First, let's remove all SACKs that are no longer needed (because they overlap with the newest one), - while moving all other SACKs forward. - We run this loop for all entries, until we find the first invalid one. - There is no point checking after that. */ - for (i = unused_idx = 0; (i < LWIP_TCP_MAX_SACK_NUM) && LWIP_TCP_SACK_VALID(pcb, i); ++i) { - /* We only want to use SACK at [i] if it doesn't overlap with left:right range. - It does not overlap if its right side is before the newly added SACK, - or if its left side is after the newly added SACK. - NOTE: The equality should not really happen, but it doesn't hurt. */ - if (TCP_SEQ_LEQ(pcb->rcv_sacks[i].right, left) || TCP_SEQ_LEQ(right, pcb->rcv_sacks[i].left)) { - if (unused_idx != i) { - /* We don't need to copy if it's already in the right spot */ - pcb->rcv_sacks[unused_idx] = pcb->rcv_sacks[i]; - } - ++unused_idx; - } - } - - /* Now 'unused_idx' is the index of the first invalid SACK entry, - anywhere between 0 (no valid entries) and LWIP_TCP_MAX_SACK_NUM (all entries are valid). - We want to clear this and all following SACKs. - However, we will be adding another one in the front (and shifting everything else back). - So let's just iterate from the back, and set each entry to the one to the left if it's valid, - or to 0 if it is not. */ - for (i = LWIP_TCP_MAX_SACK_NUM - 1; i > 0; --i) { - /* [i] is the index we are setting, and the value should be at index [i-1], - or 0 if that index is unused (>= unused_idx). */ - if (i - 1 >= unused_idx) { - /* [i-1] is unused. Let's clear [i]. */ - pcb->rcv_sacks[i].left = pcb->rcv_sacks[i].right = 0; - } else { - pcb->rcv_sacks[i] = pcb->rcv_sacks[i - 1]; - } - } - - /* And now we can store the newest SACK */ - pcb->rcv_sacks[0].left = left; - pcb->rcv_sacks[0].right = right; -} - -/** - * Called to remove a range of SACKs. - * - * SACK entries will be removed or adjusted to not acknowledge any sequence - * numbers that are less than 'seq' passed. It not only invalidates entries, - * but also moves all entries that are still valid to the beginning. - * - * @param pcb the tcp_pcb to modify - * @param seq the lowest sequence number to keep in SACK entries - */ -static void -tcp_remove_sacks_lt(struct tcp_pcb *pcb, u32_t seq) -{ - u8_t i; - u8_t unused_idx; - - /* We run this loop for all entries, until we find the first invalid one. - There is no point checking after that. */ - for (i = unused_idx = 0; (i < LWIP_TCP_MAX_SACK_NUM) && LWIP_TCP_SACK_VALID(pcb, i); ++i) { - /* We only want to use SACK at index [i] if its right side is > 'seq'. */ - if (TCP_SEQ_GT(pcb->rcv_sacks[i].right, seq)) { - if (unused_idx != i) { - /* We only copy it if it's not in the right spot already. */ - pcb->rcv_sacks[unused_idx] = pcb->rcv_sacks[i]; - } - /* NOTE: It is possible that its left side is < 'seq', in which case we should adjust it. */ - if (TCP_SEQ_LT(pcb->rcv_sacks[unused_idx].left, seq)) { - pcb->rcv_sacks[unused_idx].left = seq; - } - ++unused_idx; - } - } - - /* We also need to invalidate everything from 'unused_idx' till the end */ - for (i = unused_idx; i < LWIP_TCP_MAX_SACK_NUM; ++i) { - pcb->rcv_sacks[i].left = pcb->rcv_sacks[i].right = 0; - } -} - -#if defined(TCP_OOSEQ_BYTES_LIMIT) || defined(TCP_OOSEQ_PBUFS_LIMIT) -/** - * Called to remove a range of SACKs. - * - * SACK entries will be removed or adjusted to not acknowledge any sequence - * numbers that are greater than (or equal to) 'seq' passed. It not only invalidates entries, - * but also moves all entries that are still valid to the beginning. - * - * @param pcb the tcp_pcb to modify - * @param seq the highest sequence number to keep in SACK entries - */ -static void -tcp_remove_sacks_gt(struct tcp_pcb *pcb, u32_t seq) -{ - u8_t i; - u8_t unused_idx; - - /* We run this loop for all entries, until we find the first invalid one. - There is no point checking after that. */ - for (i = unused_idx = 0; (i < LWIP_TCP_MAX_SACK_NUM) && LWIP_TCP_SACK_VALID(pcb, i); ++i) { - /* We only want to use SACK at index [i] if its left side is < 'seq'. */ - if (TCP_SEQ_LT(pcb->rcv_sacks[i].left, seq)) { - if (unused_idx != i) { - /* We only copy it if it's not in the right spot already. */ - pcb->rcv_sacks[unused_idx] = pcb->rcv_sacks[i]; - } - /* NOTE: It is possible that its right side is > 'seq', in which case we should adjust it. */ - if (TCP_SEQ_GT(pcb->rcv_sacks[unused_idx].right, seq)) { - pcb->rcv_sacks[unused_idx].right = seq; - } - ++unused_idx; - } - } - - /* We also need to invalidate everything from 'unused_idx' till the end */ - for (i = unused_idx; i < LWIP_TCP_MAX_SACK_NUM; ++i) { - pcb->rcv_sacks[i].left = pcb->rcv_sacks[i].right = 0; - } -} -#endif /* TCP_OOSEQ_BYTES_LIMIT || TCP_OOSEQ_PBUFS_LIMIT */ - -#endif /* LWIP_TCP_SACK_OUT */ - -#endif /* LWIP_TCP */ +/** + * @file + * Transmission Control Protocol, incoming traffic + * + * The input processing functions of the TCP layer. + * + * These functions are generally called in the order (ip_input() ->) + * tcp_input() -> * tcp_process() -> tcp_receive() (-> application). + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/priv/tcp_priv.h" +#include "lwip/def.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/inet_chksum.h" +#include "lwip/stats.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#if LWIP_ND6_TCP_REACHABILITY_HINTS +#include "lwip/nd6.h" +#endif /* LWIP_ND6_TCP_REACHABILITY_HINTS */ + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +/** Initial CWND calculation as defined RFC 2581 */ +#define LWIP_TCP_CALC_INITIAL_CWND(mss) ((tcpwnd_size_t)LWIP_MIN((4U * (mss)), LWIP_MAX((2U * (mss)), 4380U))) + +/* These variables are global to all functions involved in the input + processing of TCP segments. They are set by the tcp_input() + function. */ +static struct tcp_seg inseg; +static struct tcp_hdr *tcphdr; +static u16_t tcphdr_optlen; +static u16_t tcphdr_opt1len; +static u8_t *tcphdr_opt2; +static u16_t tcp_optidx; +static u32_t seqno, ackno; +static tcpwnd_size_t recv_acked; +static u16_t tcplen; +static u8_t flags; + +static u8_t recv_flags; +static struct pbuf *recv_data; + +struct tcp_pcb *tcp_input_pcb; + +/* Forward declarations. */ +static err_t tcp_process(struct tcp_pcb *pcb); +static void tcp_receive(struct tcp_pcb *pcb); +static void tcp_parseopt(struct tcp_pcb *pcb); + +static void tcp_listen_input(struct tcp_pcb_listen *pcb); +static void tcp_timewait_input(struct tcp_pcb *pcb); + +static int tcp_input_delayed_close(struct tcp_pcb *pcb); + +#if LWIP_TCP_SACK_OUT +static void tcp_add_sack(struct tcp_pcb *pcb, u32_t left, u32_t right); +static void tcp_remove_sacks_lt(struct tcp_pcb *pcb, u32_t seq); +#if defined(TCP_OOSEQ_BYTES_LIMIT) || defined(TCP_OOSEQ_PBUFS_LIMIT) +static void tcp_remove_sacks_gt(struct tcp_pcb *pcb, u32_t seq); +#endif /* TCP_OOSEQ_BYTES_LIMIT || TCP_OOSEQ_PBUFS_LIMIT */ +#endif /* LWIP_TCP_SACK_OUT */ + +/** + * The initial input processing of TCP. It verifies the TCP header, demultiplexes + * the segment between the PCBs and passes it on to tcp_process(), which implements + * the TCP finite state machine. This function is called by the IP layer (in + * ip_input()). + * + * @param p received TCP segment to process (p->payload pointing to the TCP header) + * @param inp network interface on which this segment was received + */ +void +tcp_input(struct pbuf *p, struct netif *inp) +{ + struct tcp_pcb *pcb, *prev; + struct tcp_pcb_listen *lpcb; +#if SO_REUSE + struct tcp_pcb *lpcb_prev = NULL; + struct tcp_pcb_listen *lpcb_any = NULL; +#endif /* SO_REUSE */ + u8_t hdrlen_bytes; + err_t err; + + LWIP_UNUSED_ARG(inp); + LWIP_ASSERT_CORE_LOCKED(); + LWIP_ASSERT("tcp_input: invalid pbuf", p != NULL); + + PERF_START; + + TCP_STATS_INC(tcp.recv); + MIB2_STATS_INC(mib2.tcpinsegs); + + tcphdr = (struct tcp_hdr *)p->payload; + +#if TCP_INPUT_DEBUG + tcp_debug_print(tcphdr); +#endif + + /* Check that TCP header fits in payload */ + if (p->len < TCP_HLEN) { + /* drop short packets */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: short packet (%"U16_F" bytes) discarded\n", p->tot_len)); + TCP_STATS_INC(tcp.lenerr); + goto dropped; + } + + /* Don't even process incoming broadcasts/multicasts. */ + if (ip_addr_isbroadcast(ip_current_dest_addr(), ip_current_netif()) || + ip_addr_ismulticast(ip_current_dest_addr())) { + TCP_STATS_INC(tcp.proterr); + goto dropped; + } + +#if CHECKSUM_CHECK_TCP + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_TCP) { + /* Verify TCP checksum. */ + u16_t chksum = ip_chksum_pseudo(p, IP_PROTO_TCP, p->tot_len, + ip_current_src_addr(), ip_current_dest_addr()); + if (chksum != 0) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packet discarded due to failing checksum 0x%04"X16_F"\n", + chksum)); + tcp_debug_print(tcphdr); + TCP_STATS_INC(tcp.chkerr); + goto dropped; + } + } +#endif /* CHECKSUM_CHECK_TCP */ + + /* sanity-check header length */ + hdrlen_bytes = TCPH_HDRLEN_BYTES(tcphdr); + if ((hdrlen_bytes < TCP_HLEN) || (hdrlen_bytes > p->tot_len)) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: invalid header length (%"U16_F")\n", (u16_t)hdrlen_bytes)); + TCP_STATS_INC(tcp.lenerr); + goto dropped; + } + + /* Move the payload pointer in the pbuf so that it points to the + TCP data instead of the TCP header. */ + tcphdr_optlen = (u16_t)(hdrlen_bytes - TCP_HLEN); + tcphdr_opt2 = NULL; + if (p->len >= hdrlen_bytes) { + /* all options are in the first pbuf */ + tcphdr_opt1len = tcphdr_optlen; + pbuf_remove_header(p, hdrlen_bytes); /* cannot fail */ + } else { + u16_t opt2len; + /* TCP header fits into first pbuf, options don't - data is in the next pbuf */ + /* there must be a next pbuf, due to hdrlen_bytes sanity check above */ + LWIP_ASSERT("p->next != NULL", p->next != NULL); + + /* advance over the TCP header (cannot fail) */ + pbuf_remove_header(p, TCP_HLEN); + + /* determine how long the first and second parts of the options are */ + tcphdr_opt1len = p->len; + opt2len = (u16_t)(tcphdr_optlen - tcphdr_opt1len); + + /* options continue in the next pbuf: set p to zero length and hide the + options in the next pbuf (adjusting p->tot_len) */ + pbuf_remove_header(p, tcphdr_opt1len); + + /* check that the options fit in the second pbuf */ + if (opt2len > p->next->len) { + /* drop short packets */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: options overflow second pbuf (%"U16_F" bytes)\n", p->next->len)); + TCP_STATS_INC(tcp.lenerr); + goto dropped; + } + + /* remember the pointer to the second part of the options */ + tcphdr_opt2 = (u8_t *)p->next->payload; + + /* advance p->next to point after the options, and manually + adjust p->tot_len to keep it consistent with the changed p->next */ + pbuf_remove_header(p->next, opt2len); + p->tot_len = (u16_t)(p->tot_len - opt2len); + + LWIP_ASSERT("p->len == 0", p->len == 0); + LWIP_ASSERT("p->tot_len == p->next->tot_len", p->tot_len == p->next->tot_len); + } + + /* Convert fields in TCP header to host byte order. */ + tcphdr->src = lwip_ntohs(tcphdr->src); + tcphdr->dest = lwip_ntohs(tcphdr->dest); + seqno = tcphdr->seqno = lwip_ntohl(tcphdr->seqno); + ackno = tcphdr->ackno = lwip_ntohl(tcphdr->ackno); + tcphdr->wnd = lwip_ntohs(tcphdr->wnd); + + flags = TCPH_FLAGS(tcphdr); + tcplen = p->tot_len; + if (flags & (TCP_FIN | TCP_SYN)) { + tcplen++; + if (tcplen < p->tot_len) { + /* u16_t overflow, cannot handle this */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: length u16_t overflow, cannot handle this\n")); + TCP_STATS_INC(tcp.lenerr); + goto dropped; + } + } + + /* Demultiplex an incoming segment. First, we check if it is destined + for an active connection. */ + prev = NULL; + + for (pcb = tcp_active_pcbs; pcb != NULL; pcb = pcb->next) { + LWIP_ASSERT("tcp_input: active pcb->state != CLOSED", pcb->state != CLOSED); + LWIP_ASSERT("tcp_input: active pcb->state != TIME-WAIT", pcb->state != TIME_WAIT); + LWIP_ASSERT("tcp_input: active pcb->state != LISTEN", pcb->state != LISTEN); + + /* check if PCB is bound to specific netif */ + if ((pcb->netif_idx != NETIF_NO_INDEX) && + (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { + prev = pcb; + continue; + } + + if (pcb->remote_port == tcphdr->src && + pcb->local_port == tcphdr->dest && + ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()) && + ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { + /* Move this PCB to the front of the list so that subsequent + lookups will be faster (we exploit locality in TCP segment + arrivals). */ + LWIP_ASSERT("tcp_input: pcb->next != pcb (before cache)", pcb->next != pcb); + if (prev != NULL) { + prev->next = pcb->next; + pcb->next = tcp_active_pcbs; + tcp_active_pcbs = pcb; + } else { + TCP_STATS_INC(tcp.cachehit); + } + LWIP_ASSERT("tcp_input: pcb->next != pcb (after cache)", pcb->next != pcb); + break; + } + prev = pcb; + } + + if (pcb == NULL) { + /* If it did not go to an active connection, we check the connections + in the TIME-WAIT state. */ + for (pcb = tcp_tw_pcbs; pcb != NULL; pcb = pcb->next) { + LWIP_ASSERT("tcp_input: TIME-WAIT pcb->state == TIME-WAIT", pcb->state == TIME_WAIT); + + /* check if PCB is bound to specific netif */ + if ((pcb->netif_idx != NETIF_NO_INDEX) && + (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { + continue; + } + + if (pcb->remote_port == tcphdr->src && + pcb->local_port == tcphdr->dest && + ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()) && + ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { + /* We don't really care enough to move this PCB to the front + of the list since we are not very likely to receive that + many segments for connections in TIME-WAIT. */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packed for TIME_WAITing connection.\n")); +#ifdef LWIP_HOOK_TCP_INPACKET_PCB + if (LWIP_HOOK_TCP_INPACKET_PCB(pcb, tcphdr, tcphdr_optlen, tcphdr_opt1len, + tcphdr_opt2, p) == ERR_OK) +#endif + { + tcp_timewait_input(pcb); + } + pbuf_free(p); + return; + } + } + + /* Finally, if we still did not get a match, we check all PCBs that + are LISTENing for incoming connections. */ + prev = NULL; + for (lpcb = tcp_listen_pcbs.listen_pcbs; lpcb != NULL; lpcb = lpcb->next) { + /* check if PCB is bound to specific netif */ + if ((lpcb->netif_idx != NETIF_NO_INDEX) && + (lpcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { + prev = (struct tcp_pcb *)lpcb; + continue; + } + + if (lpcb->local_port == tcphdr->dest) { + if (IP_IS_ANY_TYPE_VAL(lpcb->local_ip)) { + /* found an ANY TYPE (IPv4/IPv6) match */ +#if SO_REUSE + lpcb_any = lpcb; + lpcb_prev = prev; +#else /* SO_REUSE */ + break; +#endif /* SO_REUSE */ + } else if (IP_ADDR_PCB_VERSION_MATCH_EXACT(lpcb, ip_current_dest_addr())) { + if (ip_addr_cmp(&lpcb->local_ip, ip_current_dest_addr())) { + /* found an exact match */ + break; + } else if (ip_addr_isany(&lpcb->local_ip)) { + /* found an ANY-match */ +#if SO_REUSE + lpcb_any = lpcb; + lpcb_prev = prev; +#else /* SO_REUSE */ + break; +#endif /* SO_REUSE */ + } + } + } + prev = (struct tcp_pcb *)lpcb; + } +#if SO_REUSE + /* first try specific local IP */ + if (lpcb == NULL) { + /* only pass to ANY if no specific local IP has been found */ + lpcb = lpcb_any; + prev = lpcb_prev; + } +#endif /* SO_REUSE */ + if (lpcb != NULL) { + /* Move this PCB to the front of the list so that subsequent + lookups will be faster (we exploit locality in TCP segment + arrivals). */ + if (prev != NULL) { + ((struct tcp_pcb_listen *)prev)->next = lpcb->next; + /* our successor is the remainder of the listening list */ + lpcb->next = tcp_listen_pcbs.listen_pcbs; + /* put this listening pcb at the head of the listening list */ + tcp_listen_pcbs.listen_pcbs = lpcb; + } else { + TCP_STATS_INC(tcp.cachehit); + } + + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: packed for LISTENing connection.\n")); +#ifdef LWIP_HOOK_TCP_INPACKET_PCB + if (LWIP_HOOK_TCP_INPACKET_PCB((struct tcp_pcb *)lpcb, tcphdr, tcphdr_optlen, + tcphdr_opt1len, tcphdr_opt2, p) == ERR_OK) +#endif + { + tcp_listen_input(lpcb); + } + pbuf_free(p); + return; + } + } + +#if TCP_INPUT_DEBUG + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("+-+-+-+-+-+-+-+-+-+-+-+-+-+- tcp_input: flags ")); + tcp_debug_print_flags(TCPH_FLAGS(tcphdr)); + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("-+-+-+-+-+-+-+-+-+-+-+-+-+-+\n")); +#endif /* TCP_INPUT_DEBUG */ + + +#ifdef LWIP_HOOK_TCP_INPACKET_PCB + if ((pcb != NULL) && LWIP_HOOK_TCP_INPACKET_PCB(pcb, tcphdr, tcphdr_optlen, + tcphdr_opt1len, tcphdr_opt2, p) != ERR_OK) { + pbuf_free(p); + return; + } +#endif + if (pcb != NULL) { + /* The incoming segment belongs to a connection. */ +#if TCP_INPUT_DEBUG + tcp_debug_print_state(pcb->state); +#endif /* TCP_INPUT_DEBUG */ + + /* Set up a tcp_seg structure. */ + inseg.next = NULL; + inseg.len = p->tot_len; + inseg.p = p; + inseg.tcphdr = tcphdr; + + recv_data = NULL; + recv_flags = 0; + recv_acked = 0; + + if (flags & TCP_PSH) { + p->flags |= PBUF_FLAG_PUSH; + } + + /* If there is data which was previously "refused" by upper layer */ + if (pcb->refused_data != NULL) { + if ((tcp_process_refused_data(pcb) == ERR_ABRT) || + ((pcb->refused_data != NULL) && (tcplen > 0))) { + /* pcb has been aborted or refused data is still refused and the new + segment contains data */ + if (pcb->rcv_ann_wnd == 0) { + /* this is a zero-window probe, we respond to it with current RCV.NXT + and drop the data segment */ + tcp_send_empty_ack(pcb); + } + TCP_STATS_INC(tcp.drop); + MIB2_STATS_INC(mib2.tcpinerrs); + goto aborted; + } + } + tcp_input_pcb = pcb; + err = tcp_process(pcb); + /* A return value of ERR_ABRT means that tcp_abort() was called + and that the pcb has been freed. If so, we don't do anything. */ + if (err != ERR_ABRT) { + if (recv_flags & TF_RESET) { + /* TF_RESET means that the connection was reset by the other + end. We then call the error callback to inform the + application that the connection is dead before we + deallocate the PCB. */ + TCP_EVENT_ERR(pcb->state, pcb->errf, pcb->callback_arg, ERR_RST); + tcp_pcb_remove(&tcp_active_pcbs, pcb); + tcp_free(pcb); + } else { + err = ERR_OK; + /* If the application has registered a "sent" function to be + called when new send buffer space is available, we call it + now. */ + if (recv_acked > 0) { + u16_t acked16; +#if LWIP_WND_SCALE + /* recv_acked is u32_t but the sent callback only takes a u16_t, + so we might have to call it multiple times. */ + u32_t acked = recv_acked; + while (acked > 0) { + acked16 = (u16_t)LWIP_MIN(acked, 0xffffu); + acked -= acked16; +#else + { + acked16 = recv_acked; +#endif + TCP_EVENT_SENT(pcb, (u16_t)acked16, err); + if (err == ERR_ABRT) { + goto aborted; + } + } + recv_acked = 0; + } + if (tcp_input_delayed_close(pcb)) { + goto aborted; + } +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + while (recv_data != NULL) { + struct pbuf *rest = NULL; + pbuf_split_64k(recv_data, &rest); +#else /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + if (recv_data != NULL) { +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + + LWIP_ASSERT("pcb->refused_data == NULL", pcb->refused_data == NULL); + if (pcb->flags & TF_RXCLOSED) { + /* received data although already closed -> abort (send RST) to + notify the remote host that not all data has been processed */ + pbuf_free(recv_data); +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + if (rest != NULL) { + pbuf_free(rest); + } +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + tcp_abort(pcb); + goto aborted; + } + + /* Notify application that data has been received. */ + TCP_EVENT_RECV(pcb, recv_data, ERR_OK, err); + if (err == ERR_ABRT) { +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + if (rest != NULL) { + pbuf_free(rest); + } +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + goto aborted; + } + + /* If the upper layer can't receive this data, store it */ + if (err != ERR_OK) { +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + if (rest != NULL) { + pbuf_cat(recv_data, rest); + } +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + pcb->refused_data = recv_data; + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_input: keep incoming packet, because pcb is \"full\"\n")); +#if TCP_QUEUE_OOSEQ && LWIP_WND_SCALE + break; + } else { + /* Upper layer received the data, go on with the rest if > 64K */ + recv_data = rest; +#endif /* TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + } + } + + /* If a FIN segment was received, we call the callback + function with a NULL buffer to indicate EOF. */ + if (recv_flags & TF_GOT_FIN) { + if (pcb->refused_data != NULL) { + /* Delay this if we have refused data. */ + pcb->refused_data->flags |= PBUF_FLAG_TCP_FIN; + } else { + /* correct rcv_wnd as the application won't call tcp_recved() + for the FIN's seqno */ + if (pcb->rcv_wnd != TCP_WND_MAX(pcb)) { + pcb->rcv_wnd++; + } + TCP_EVENT_CLOSED(pcb, err); + if (err == ERR_ABRT) { + goto aborted; + } + } + } + + tcp_input_pcb = NULL; + if (tcp_input_delayed_close(pcb)) { + goto aborted; + } + /* Try to send something out. */ + tcp_output(pcb); +#if TCP_INPUT_DEBUG +#if TCP_DEBUG + tcp_debug_print_state(pcb->state); +#endif /* TCP_DEBUG */ +#endif /* TCP_INPUT_DEBUG */ + } + } + /* Jump target if pcb has been aborted in a callback (by calling tcp_abort()). + Below this line, 'pcb' may not be dereferenced! */ +aborted: + tcp_input_pcb = NULL; + recv_data = NULL; + + /* give up our reference to inseg.p */ + if (inseg.p != NULL) { + pbuf_free(inseg.p); + inseg.p = NULL; + } + } else { + /* If no matching PCB was found, send a TCP RST (reset) to the + sender. */ + LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_input: no PCB match found, resetting.\n")); + if (!(TCPH_FLAGS(tcphdr) & TCP_RST)) { + TCP_STATS_INC(tcp.proterr); + TCP_STATS_INC(tcp.drop); + tcp_rst(NULL, ackno, seqno + tcplen, ip_current_dest_addr(), + ip_current_src_addr(), tcphdr->dest, tcphdr->src); + } + pbuf_free(p); + } + + LWIP_ASSERT("tcp_input: tcp_pcbs_sane()", tcp_pcbs_sane()); + PERF_STOP("tcp_input"); + return; +dropped: + TCP_STATS_INC(tcp.drop); + MIB2_STATS_INC(mib2.tcpinerrs); + pbuf_free(p); +} + +/** Called from tcp_input to check for TF_CLOSED flag. This results in closing + * and deallocating a pcb at the correct place to ensure noone references it + * any more. + * @returns 1 if the pcb has been closed and deallocated, 0 otherwise + */ +static int +tcp_input_delayed_close(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_input_delayed_close: invalid pcb", pcb != NULL); + + if (recv_flags & TF_CLOSED) { + /* The connection has been closed and we will deallocate the + PCB. */ + if (!(pcb->flags & TF_RXCLOSED)) { + /* Connection closed although the application has only shut down the + tx side: call the PCB's err callback and indicate the closure to + ensure the application doesn't continue using the PCB. */ + TCP_EVENT_ERR(pcb->state, pcb->errf, pcb->callback_arg, ERR_CLSD); + } + tcp_pcb_remove(&tcp_active_pcbs, pcb); + tcp_free(pcb); + return 1; + } + return 0; +} + +/** + * Called by tcp_input() when a segment arrives for a listening + * connection (from tcp_input()). + * + * @param pcb the tcp_pcb_listen for which a segment arrived + * + * @note the segment which arrived is saved in global variables, therefore only the pcb + * involved is passed as a parameter to this function + */ +static void +tcp_listen_input(struct tcp_pcb_listen *pcb) +{ + struct tcp_pcb *npcb; + u32_t iss; + err_t rc; + + if (flags & TCP_RST) { + /* An incoming RST should be ignored. Return. */ + return; + } + + LWIP_ASSERT("tcp_listen_input: invalid pcb", pcb != NULL); + + /* In the LISTEN state, we check for incoming SYN segments, + creates a new PCB, and responds with a SYN|ACK. */ + if (flags & TCP_ACK) { + /* For incoming segments with the ACK flag set, respond with a + RST. */ + LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_listen_input: ACK in LISTEN, sending reset\n")); + tcp_rst((const struct tcp_pcb *)pcb, ackno, seqno + tcplen, ip_current_dest_addr(), + ip_current_src_addr(), tcphdr->dest, tcphdr->src); + } else if (flags & TCP_SYN) { + LWIP_DEBUGF(TCP_DEBUG, ("TCP connection request %"U16_F" -> %"U16_F".\n", tcphdr->src, tcphdr->dest)); +#if TCP_LISTEN_BACKLOG + if (pcb->accepts_pending >= pcb->backlog) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_listen_input: listen backlog exceeded for port %"U16_F"\n", tcphdr->dest)); + return; + } +#endif /* TCP_LISTEN_BACKLOG */ + npcb = tcp_alloc(pcb->prio); + /* If a new PCB could not be created (probably due to lack of memory), + we don't do anything, but rely on the sender will retransmit the + SYN at a time when we have more memory available. */ + if (npcb == NULL) { + err_t err; + LWIP_DEBUGF(TCP_DEBUG, ("tcp_listen_input: could not allocate PCB\n")); + TCP_STATS_INC(tcp.memerr); + TCP_EVENT_ACCEPT(pcb, NULL, pcb->callback_arg, ERR_MEM, err); + LWIP_UNUSED_ARG(err); /* err not useful here */ + return; + } +#if TCP_LISTEN_BACKLOG + pcb->accepts_pending++; + tcp_set_flags(npcb, TF_BACKLOGPEND); +#endif /* TCP_LISTEN_BACKLOG */ + /* Set up the new PCB. */ + ip_addr_copy(npcb->local_ip, *ip_current_dest_addr()); + ip_addr_copy(npcb->remote_ip, *ip_current_src_addr()); + npcb->local_port = pcb->local_port; + npcb->remote_port = tcphdr->src; + npcb->state = SYN_RCVD; + npcb->rcv_nxt = seqno + 1; + npcb->rcv_ann_right_edge = npcb->rcv_nxt; + iss = tcp_next_iss(npcb); + npcb->snd_wl2 = iss; + npcb->snd_nxt = iss; + npcb->lastack = iss; + npcb->snd_lbb = iss; + npcb->snd_wl1 = seqno - 1;/* initialise to seqno-1 to force window update */ + npcb->callback_arg = pcb->callback_arg; +#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG + npcb->listener = pcb; +#endif /* LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG */ + /* inherit socket options */ + npcb->so_options = pcb->so_options & SOF_INHERITED; + npcb->netif_idx = pcb->netif_idx; + /* Register the new PCB so that we can begin receiving segments + for it. */ + TCP_REG_ACTIVE(npcb); + + /* Parse any options in the SYN. */ + tcp_parseopt(npcb); + npcb->snd_wnd = tcphdr->wnd; + npcb->snd_wnd_max = npcb->snd_wnd; + +#if TCP_CALCULATE_EFF_SEND_MSS + npcb->mss = tcp_eff_send_mss(npcb->mss, &npcb->local_ip, &npcb->remote_ip); +#endif /* TCP_CALCULATE_EFF_SEND_MSS */ + + MIB2_STATS_INC(mib2.tcppassiveopens); + +#if LWIP_TCP_PCB_NUM_EXT_ARGS + if (tcp_ext_arg_invoke_callbacks_passive_open(pcb, npcb) != ERR_OK) { + tcp_abandon(npcb, 0); + return; + } +#endif + + /* Send a SYN|ACK together with the MSS option. */ + rc = tcp_enqueue_flags(npcb, TCP_SYN | TCP_ACK); + if (rc != ERR_OK) { + tcp_abandon(npcb, 0); + return; + } + tcp_output(npcb); + } + return; +} + +/** + * Called by tcp_input() when a segment arrives for a connection in + * TIME_WAIT. + * + * @param pcb the tcp_pcb for which a segment arrived + * + * @note the segment which arrived is saved in global variables, therefore only the pcb + * involved is passed as a parameter to this function + */ +static void +tcp_timewait_input(struct tcp_pcb *pcb) +{ + /* RFC 1337: in TIME_WAIT, ignore RST and ACK FINs + any 'acceptable' segments */ + /* RFC 793 3.9 Event Processing - Segment Arrives: + * - first check sequence number - we skip that one in TIME_WAIT (always + * acceptable since we only send ACKs) + * - second check the RST bit (... return) */ + if (flags & TCP_RST) { + return; + } + + LWIP_ASSERT("tcp_timewait_input: invalid pcb", pcb != NULL); + + /* - fourth, check the SYN bit, */ + if (flags & TCP_SYN) { + /* If an incoming segment is not acceptable, an acknowledgment + should be sent in reply */ + if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt + pcb->rcv_wnd)) { + /* If the SYN is in the window it is an error, send a reset */ + tcp_rst(pcb, ackno, seqno + tcplen, ip_current_dest_addr(), + ip_current_src_addr(), tcphdr->dest, tcphdr->src); + return; + } + } else if (flags & TCP_FIN) { + /* - eighth, check the FIN bit: Remain in the TIME-WAIT state. + Restart the 2 MSL time-wait timeout.*/ + pcb->tmr = tcp_ticks; + } + + if ((tcplen > 0)) { + /* Acknowledge data, FIN or out-of-window SYN */ + tcp_ack_now(pcb); + tcp_output(pcb); + } + return; +} + +/** + * Implements the TCP state machine. Called by tcp_input. In some + * states tcp_receive() is called to receive data. The tcp_seg + * argument will be freed by the caller (tcp_input()) unless the + * recv_data pointer in the pcb is set. + * + * @param pcb the tcp_pcb for which a segment arrived + * + * @note the segment which arrived is saved in global variables, therefore only the pcb + * involved is passed as a parameter to this function + */ +static err_t +tcp_process(struct tcp_pcb *pcb) +{ + struct tcp_seg *rseg; + u8_t acceptable = 0; + err_t err; + + err = ERR_OK; + + LWIP_ASSERT("tcp_process: invalid pcb", pcb != NULL); + + /* Process incoming RST segments. */ + if (flags & TCP_RST) { + /* First, determine if the reset is acceptable. */ + if (pcb->state == SYN_SENT) { + /* "In the SYN-SENT state (a RST received in response to an initial SYN), + the RST is acceptable if the ACK field acknowledges the SYN." */ + if (ackno == pcb->snd_nxt) { + acceptable = 1; + } + } else { + /* "In all states except SYN-SENT, all reset (RST) segments are validated + by checking their SEQ-fields." */ + if (seqno == pcb->rcv_nxt) { + acceptable = 1; + } else if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, + pcb->rcv_nxt + pcb->rcv_wnd)) { + /* If the sequence number is inside the window, we send a challenge ACK + and wait for a re-send with matching sequence number. + This follows RFC 5961 section 3.2 and addresses CVE-2004-0230 + (RST spoofing attack), which is present in RFC 793 RST handling. */ + tcp_ack_now(pcb); + } + } + + if (acceptable) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: Connection RESET\n")); + LWIP_ASSERT("tcp_input: pcb->state != CLOSED", pcb->state != CLOSED); + recv_flags |= TF_RESET; + tcp_clear_flags(pcb, TF_ACK_DELAY); + return ERR_RST; + } else { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n", + seqno, pcb->rcv_nxt)); + LWIP_DEBUGF(TCP_DEBUG, ("tcp_process: unacceptable reset seqno %"U32_F" rcv_nxt %"U32_F"\n", + seqno, pcb->rcv_nxt)); + return ERR_OK; + } + } + + if ((flags & TCP_SYN) && (pcb->state != SYN_SENT && pcb->state != SYN_RCVD)) { + /* Cope with new connection attempt after remote end crashed */ + tcp_ack_now(pcb); + return ERR_OK; + } + + if ((pcb->flags & TF_RXCLOSED) == 0) { + /* Update the PCB (in)activity timer unless rx is closed (see tcp_shutdown) */ + pcb->tmr = tcp_ticks; + } + pcb->keep_cnt_sent = 0; + pcb->persist_probe = 0; + + tcp_parseopt(pcb); + + /* Do different things depending on the TCP state. */ + switch (pcb->state) { + case SYN_SENT: + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("SYN-SENT: ackno %"U32_F" pcb->snd_nxt %"U32_F" unacked %"U32_F"\n", ackno, + pcb->snd_nxt, lwip_ntohl(pcb->unacked->tcphdr->seqno))); + /* received SYN ACK with expected sequence number? */ + if ((flags & TCP_ACK) && (flags & TCP_SYN) + && (ackno == pcb->lastack + 1)) { + pcb->rcv_nxt = seqno + 1; + pcb->rcv_ann_right_edge = pcb->rcv_nxt; + pcb->lastack = ackno; + pcb->snd_wnd = tcphdr->wnd; + pcb->snd_wnd_max = pcb->snd_wnd; + pcb->snd_wl1 = seqno - 1; /* initialise to seqno - 1 to force window update */ + pcb->state = ESTABLISHED; + +#if TCP_CALCULATE_EFF_SEND_MSS + pcb->mss = tcp_eff_send_mss(pcb->mss, &pcb->local_ip, &pcb->remote_ip); +#endif /* TCP_CALCULATE_EFF_SEND_MSS */ + + pcb->cwnd = LWIP_TCP_CALC_INITIAL_CWND(pcb->mss); + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_process (SENT): cwnd %"TCPWNDSIZE_F + " ssthresh %"TCPWNDSIZE_F"\n", + pcb->cwnd, pcb->ssthresh)); + LWIP_ASSERT("pcb->snd_queuelen > 0", (pcb->snd_queuelen > 0)); + --pcb->snd_queuelen; + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_process: SYN-SENT --queuelen %"TCPWNDSIZE_F"\n", (tcpwnd_size_t)pcb->snd_queuelen)); + rseg = pcb->unacked; + if (rseg == NULL) { + /* might happen if tcp_output fails in tcp_rexmit_rto() + in which case the segment is on the unsent list */ + rseg = pcb->unsent; + LWIP_ASSERT("no segment to free", rseg != NULL); + pcb->unsent = rseg->next; + } else { + pcb->unacked = rseg->next; + } + tcp_seg_free(rseg); + + /* If there's nothing left to acknowledge, stop the retransmit + timer, otherwise reset it to start again */ + if (pcb->unacked == NULL) { + pcb->rtime = -1; + } else { + pcb->rtime = 0; + pcb->nrtx = 0; + } + + /* Call the user specified function to call when successfully + * connected. */ + TCP_EVENT_CONNECTED(pcb, ERR_OK, err); + if (err == ERR_ABRT) { + return ERR_ABRT; + } + tcp_ack_now(pcb); + } + /* received ACK? possibly a half-open connection */ + else if (flags & TCP_ACK) { + /* send a RST to bring the other side in a non-synchronized state. */ + tcp_rst(pcb, ackno, seqno + tcplen, ip_current_dest_addr(), + ip_current_src_addr(), tcphdr->dest, tcphdr->src); + /* Resend SYN immediately (don't wait for rto timeout) to establish + connection faster, but do not send more SYNs than we otherwise would + have, or we might get caught in a loop on loopback interfaces. */ + if (pcb->nrtx < TCP_SYNMAXRTX) { + pcb->rtime = 0; + tcp_rexmit_rto(pcb); + } + } + break; + case SYN_RCVD: + if (flags & TCP_ACK) { + /* expected ACK number? */ + if (TCP_SEQ_BETWEEN(ackno, pcb->lastack + 1, pcb->snd_nxt)) { + pcb->state = ESTABLISHED; + LWIP_DEBUGF(TCP_DEBUG, ("TCP connection established %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); +#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG + if (pcb->listener == NULL) { + /* listen pcb might be closed by now */ + err = ERR_VAL; + } else +#endif /* LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG */ + { +#if LWIP_CALLBACK_API + LWIP_ASSERT("pcb->listener->accept != NULL", pcb->listener->accept != NULL); +#endif + tcp_backlog_accepted(pcb); + /* Call the accept function. */ + TCP_EVENT_ACCEPT(pcb->listener, pcb, pcb->callback_arg, ERR_OK, err); + } + if (err != ERR_OK) { + /* If the accept function returns with an error, we abort + * the connection. */ + /* Already aborted? */ + if (err != ERR_ABRT) { + tcp_abort(pcb); + } + return ERR_ABRT; + } + /* If there was any data contained within this ACK, + * we'd better pass it on to the application as well. */ + tcp_receive(pcb); + + /* Prevent ACK for SYN to generate a sent event */ + if (recv_acked != 0) { + recv_acked--; + } + + pcb->cwnd = LWIP_TCP_CALC_INITIAL_CWND(pcb->mss); + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_process (SYN_RCVD): cwnd %"TCPWNDSIZE_F + " ssthresh %"TCPWNDSIZE_F"\n", + pcb->cwnd, pcb->ssthresh)); + + if (recv_flags & TF_GOT_FIN) { + tcp_ack_now(pcb); + pcb->state = CLOSE_WAIT; + } + } else { + /* incorrect ACK number, send RST */ + tcp_rst(pcb, ackno, seqno + tcplen, ip_current_dest_addr(), + ip_current_src_addr(), tcphdr->dest, tcphdr->src); + } + } else if ((flags & TCP_SYN) && (seqno == pcb->rcv_nxt - 1)) { + /* Looks like another copy of the SYN - retransmit our SYN-ACK */ + tcp_rexmit(pcb); + } + break; + case CLOSE_WAIT: + /* FALLTHROUGH */ + case ESTABLISHED: + tcp_receive(pcb); + if (recv_flags & TF_GOT_FIN) { /* passive close */ + tcp_ack_now(pcb); + pcb->state = CLOSE_WAIT; + } + break; + case FIN_WAIT_1: + tcp_receive(pcb); + if (recv_flags & TF_GOT_FIN) { + if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt) && + pcb->unsent == NULL) { + LWIP_DEBUGF(TCP_DEBUG, + ("TCP connection closed: FIN_WAIT_1 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); + tcp_ack_now(pcb); + tcp_pcb_purge(pcb); + TCP_RMV_ACTIVE(pcb); + pcb->state = TIME_WAIT; + TCP_REG(&tcp_tw_pcbs, pcb); + } else { + tcp_ack_now(pcb); + pcb->state = CLOSING; + } + } else if ((flags & TCP_ACK) && (ackno == pcb->snd_nxt) && + pcb->unsent == NULL) { + pcb->state = FIN_WAIT_2; + } + break; + case FIN_WAIT_2: + tcp_receive(pcb); + if (recv_flags & TF_GOT_FIN) { + LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: FIN_WAIT_2 %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); + tcp_ack_now(pcb); + tcp_pcb_purge(pcb); + TCP_RMV_ACTIVE(pcb); + pcb->state = TIME_WAIT; + TCP_REG(&tcp_tw_pcbs, pcb); + } + break; + case CLOSING: + tcp_receive(pcb); + if ((flags & TCP_ACK) && ackno == pcb->snd_nxt && pcb->unsent == NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: CLOSING %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); + tcp_pcb_purge(pcb); + TCP_RMV_ACTIVE(pcb); + pcb->state = TIME_WAIT; + TCP_REG(&tcp_tw_pcbs, pcb); + } + break; + case LAST_ACK: + tcp_receive(pcb); + if ((flags & TCP_ACK) && ackno == pcb->snd_nxt && pcb->unsent == NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("TCP connection closed: LAST_ACK %"U16_F" -> %"U16_F".\n", inseg.tcphdr->src, inseg.tcphdr->dest)); + /* bugfix #21699: don't set pcb->state to CLOSED here or we risk leaking segments */ + recv_flags |= TF_CLOSED; + } + break; + default: + break; + } + return ERR_OK; +} + +#if TCP_QUEUE_OOSEQ +/** + * Insert segment into the list (segments covered with new one will be deleted) + * + * Called from tcp_receive() + */ +static void +tcp_oos_insert_segment(struct tcp_seg *cseg, struct tcp_seg *next) +{ + struct tcp_seg *old_seg; + + LWIP_ASSERT("tcp_oos_insert_segment: invalid cseg", cseg != NULL); + + if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) { + /* received segment overlaps all following segments */ + tcp_segs_free(next); + next = NULL; + } else { + /* delete some following segments + oos queue may have segments with FIN flag */ + while (next && + TCP_SEQ_GEQ((seqno + cseg->len), + (next->tcphdr->seqno + next->len))) { + /* cseg with FIN already processed */ + if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) { + TCPH_SET_FLAG(cseg->tcphdr, TCP_FIN); + } + old_seg = next; + next = next->next; + tcp_seg_free(old_seg); + } + if (next && + TCP_SEQ_GT(seqno + cseg->len, next->tcphdr->seqno)) { + /* We need to trim the incoming segment. */ + cseg->len = (u16_t)(next->tcphdr->seqno - seqno); + pbuf_realloc(cseg->p, cseg->len); + } + } + cseg->next = next; +} +#endif /* TCP_QUEUE_OOSEQ */ + +/** Remove segments from a list if the incoming ACK acknowledges them */ +static struct tcp_seg * +tcp_free_acked_segments(struct tcp_pcb *pcb, struct tcp_seg *seg_list, const char *dbg_list_name, + struct tcp_seg *dbg_other_seg_list) +{ + struct tcp_seg *next; + u16_t clen; + + LWIP_UNUSED_ARG(dbg_list_name); + LWIP_UNUSED_ARG(dbg_other_seg_list); + + while (seg_list != NULL && + TCP_SEQ_LEQ(lwip_ntohl(seg_list->tcphdr->seqno) + + TCP_TCPLEN(seg_list), ackno)) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: removing %"U32_F":%"U32_F" from pcb->%s\n", + lwip_ntohl(seg_list->tcphdr->seqno), + lwip_ntohl(seg_list->tcphdr->seqno) + TCP_TCPLEN(seg_list), + dbg_list_name)); + + next = seg_list; + seg_list = seg_list->next; + + clen = pbuf_clen(next->p); + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_receive: queuelen %"TCPWNDSIZE_F" ... ", + (tcpwnd_size_t)pcb->snd_queuelen)); + LWIP_ASSERT("pcb->snd_queuelen >= pbuf_clen(next->p)", (pcb->snd_queuelen >= clen)); + + pcb->snd_queuelen = (u16_t)(pcb->snd_queuelen - clen); + recv_acked = (tcpwnd_size_t)(recv_acked + next->len); + tcp_seg_free(next); + + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("%"TCPWNDSIZE_F" (after freeing %s)\n", + (tcpwnd_size_t)pcb->snd_queuelen, + dbg_list_name)); + if (pcb->snd_queuelen != 0) { + LWIP_ASSERT("tcp_receive: valid queue length", + seg_list != NULL || dbg_other_seg_list != NULL); + } + } + return seg_list; +} + +/** + * Called by tcp_process. Checks if the given segment is an ACK for outstanding + * data, and if so frees the memory of the buffered data. Next, it places the + * segment on any of the receive queues (pcb->recved or pcb->ooseq). If the segment + * is buffered, the pbuf is referenced by pbuf_ref so that it will not be freed until + * it has been removed from the buffer. + * + * If the incoming segment constitutes an ACK for a segment that was used for RTT + * estimation, the RTT is estimated here as well. + * + * Called from tcp_process(). + */ +static void +tcp_receive(struct tcp_pcb *pcb) +{ + s16_t m; + u32_t right_wnd_edge; + int found_dupack = 0; + + LWIP_ASSERT("tcp_receive: invalid pcb", pcb != NULL); + LWIP_ASSERT("tcp_receive: wrong state", pcb->state >= ESTABLISHED); + + if (flags & TCP_ACK) { + right_wnd_edge = pcb->snd_wnd + pcb->snd_wl2; + + /* Update window. */ + if (TCP_SEQ_LT(pcb->snd_wl1, seqno) || + (pcb->snd_wl1 == seqno && TCP_SEQ_LT(pcb->snd_wl2, ackno)) || + (pcb->snd_wl2 == ackno && (u32_t)SND_WND_SCALE(pcb, tcphdr->wnd) > pcb->snd_wnd)) { + pcb->snd_wnd = SND_WND_SCALE(pcb, tcphdr->wnd); + /* keep track of the biggest window announced by the remote host to calculate + the maximum segment size */ + if (pcb->snd_wnd_max < pcb->snd_wnd) { + pcb->snd_wnd_max = pcb->snd_wnd; + } + pcb->snd_wl1 = seqno; + pcb->snd_wl2 = ackno; + LWIP_DEBUGF(TCP_WND_DEBUG, ("tcp_receive: window update %"TCPWNDSIZE_F"\n", pcb->snd_wnd)); +#if TCP_WND_DEBUG + } else { + if (pcb->snd_wnd != (tcpwnd_size_t)SND_WND_SCALE(pcb, tcphdr->wnd)) { + LWIP_DEBUGF(TCP_WND_DEBUG, + ("tcp_receive: no window update lastack %"U32_F" ackno %" + U32_F" wl1 %"U32_F" seqno %"U32_F" wl2 %"U32_F"\n", + pcb->lastack, ackno, pcb->snd_wl1, seqno, pcb->snd_wl2)); + } +#endif /* TCP_WND_DEBUG */ + } + + /* (From Stevens TCP/IP Illustrated Vol II, p970.) Its only a + * duplicate ack if: + * 1) It doesn't ACK new data + * 2) length of received packet is zero (i.e. no payload) + * 3) the advertised window hasn't changed + * 4) There is outstanding unacknowledged data (retransmission timer running) + * 5) The ACK is == biggest ACK sequence number so far seen (snd_una) + * + * If it passes all five, should process as a dupack: + * a) dupacks < 3: do nothing + * b) dupacks == 3: fast retransmit + * c) dupacks > 3: increase cwnd + * + * If it only passes 1-3, should reset dupack counter (and add to + * stats, which we don't do in lwIP) + * + * If it only passes 1, should reset dupack counter + * + */ + + /* Clause 1 */ + if (TCP_SEQ_LEQ(ackno, pcb->lastack)) { + /* Clause 2 */ + if (tcplen == 0) { + /* Clause 3 */ + if (pcb->snd_wl2 + pcb->snd_wnd == right_wnd_edge) { + /* Clause 4 */ + if (pcb->rtime >= 0) { + /* Clause 5 */ + if (pcb->lastack == ackno) { + found_dupack = 1; + if ((u8_t)(pcb->dupacks + 1) > pcb->dupacks) { + ++pcb->dupacks; + } + if (pcb->dupacks > 3) { + /* Inflate the congestion window */ + TCP_WND_INC(pcb->cwnd, pcb->mss); + } + if (pcb->dupacks >= 3) { + /* Do fast retransmit (checked via TF_INFR, not via dupacks count) */ + tcp_rexmit_fast(pcb); + } + } + } + } + } + /* If Clause (1) or more is true, but not a duplicate ack, reset + * count of consecutive duplicate acks */ + if (!found_dupack) { + pcb->dupacks = 0; + } + } else if (TCP_SEQ_BETWEEN(ackno, pcb->lastack + 1, pcb->snd_nxt)) { + /* We come here when the ACK acknowledges new data. */ + tcpwnd_size_t acked; + + /* Reset the "IN Fast Retransmit" flag, since we are no longer + in fast retransmit. Also reset the congestion window to the + slow start threshold. */ + if (pcb->flags & TF_INFR) { + tcp_clear_flags(pcb, TF_INFR); + pcb->cwnd = pcb->ssthresh; + pcb->bytes_acked = 0; + } + + /* Reset the number of retransmissions. */ + pcb->nrtx = 0; + + /* Reset the retransmission time-out. */ + pcb->rto = (s16_t)((pcb->sa >> 3) + pcb->sv); + + /* Record how much data this ACK acks */ + acked = (tcpwnd_size_t)(ackno - pcb->lastack); + + /* Reset the fast retransmit variables. */ + pcb->dupacks = 0; + pcb->lastack = ackno; + + /* Update the congestion control variables (cwnd and + ssthresh). */ + if (pcb->state >= ESTABLISHED) { + if (pcb->cwnd < pcb->ssthresh) { + tcpwnd_size_t increase; + /* limit to 1 SMSS segment during period following RTO */ + u8_t num_seg = (pcb->flags & TF_RTO) ? 1 : 2; + /* RFC 3465, section 2.2 Slow Start */ + increase = LWIP_MIN(acked, (tcpwnd_size_t)(num_seg * pcb->mss)); + TCP_WND_INC(pcb->cwnd, increase); + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_receive: slow start cwnd %"TCPWNDSIZE_F"\n", pcb->cwnd)); + } else { + /* RFC 3465, section 2.1 Congestion Avoidance */ + TCP_WND_INC(pcb->bytes_acked, acked); + if (pcb->bytes_acked >= pcb->cwnd) { + pcb->bytes_acked = (tcpwnd_size_t)(pcb->bytes_acked - pcb->cwnd); + TCP_WND_INC(pcb->cwnd, pcb->mss); + } + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_receive: congestion avoidance cwnd %"TCPWNDSIZE_F"\n", pcb->cwnd)); + } + } + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: ACK for %"U32_F", unacked->seqno %"U32_F":%"U32_F"\n", + ackno, + pcb->unacked != NULL ? + lwip_ntohl(pcb->unacked->tcphdr->seqno) : 0, + pcb->unacked != NULL ? + lwip_ntohl(pcb->unacked->tcphdr->seqno) + TCP_TCPLEN(pcb->unacked) : 0)); + + /* Remove segment from the unacknowledged list if the incoming + ACK acknowledges them. */ + pcb->unacked = tcp_free_acked_segments(pcb, pcb->unacked, "unacked", pcb->unsent); + /* We go through the ->unsent list to see if any of the segments + on the list are acknowledged by the ACK. This may seem + strange since an "unsent" segment shouldn't be acked. The + rationale is that lwIP puts all outstanding segments on the + ->unsent list after a retransmission, so these segments may + in fact have been sent once. */ + pcb->unsent = tcp_free_acked_segments(pcb, pcb->unsent, "unsent", pcb->unacked); + + /* If there's nothing left to acknowledge, stop the retransmit + timer, otherwise reset it to start again */ + if (pcb->unacked == NULL) { + pcb->rtime = -1; + } else { + pcb->rtime = 0; + } + + pcb->polltmr = 0; + +#if TCP_OVERSIZE + if (pcb->unsent == NULL) { + pcb->unsent_oversize = 0; + } +#endif /* TCP_OVERSIZE */ + +#if LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS + if (ip_current_is_v6()) { + /* Inform neighbor reachability of forward progress. */ + nd6_reachability_hint(ip6_current_src_addr()); + } +#endif /* LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS*/ + + pcb->snd_buf = (tcpwnd_size_t)(pcb->snd_buf + recv_acked); + /* check if this ACK ends our retransmission of in-flight data */ + if (pcb->flags & TF_RTO) { + /* RTO is done if + 1) both queues are empty or + 2) unacked is empty and unsent head contains data not part of RTO or + 3) unacked head contains data not part of RTO */ + if (pcb->unacked == NULL) { + if ((pcb->unsent == NULL) || + (TCP_SEQ_LEQ(pcb->rto_end, lwip_ntohl(pcb->unsent->tcphdr->seqno)))) { + tcp_clear_flags(pcb, TF_RTO); + } + } else if (TCP_SEQ_LEQ(pcb->rto_end, lwip_ntohl(pcb->unacked->tcphdr->seqno))) { + tcp_clear_flags(pcb, TF_RTO); + } + } + /* End of ACK for new data processing. */ + } else { + /* Out of sequence ACK, didn't really ack anything */ + tcp_send_empty_ack(pcb); + } + + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: pcb->rttest %"U32_F" rtseq %"U32_F" ackno %"U32_F"\n", + pcb->rttest, pcb->rtseq, ackno)); + + /* RTT estimation calculations. This is done by checking if the + incoming segment acknowledges the segment we use to take a + round-trip time measurement. */ + if (pcb->rttest && TCP_SEQ_LT(pcb->rtseq, ackno)) { + /* diff between this shouldn't exceed 32K since this are tcp timer ticks + and a round-trip shouldn't be that long... */ + m = (s16_t)(tcp_ticks - pcb->rttest); + + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: experienced rtt %"U16_F" ticks (%"U16_F" msec).\n", + m, (u16_t)(m * TCP_SLOW_INTERVAL))); + + /* This is taken directly from VJs original code in his paper */ + m = (s16_t)(m - (pcb->sa >> 3)); + pcb->sa = (s16_t)(pcb->sa + m); + if (m < 0) { + m = (s16_t) - m; + } + m = (s16_t)(m - (pcb->sv >> 2)); + pcb->sv = (s16_t)(pcb->sv + m); + pcb->rto = (s16_t)((pcb->sa >> 3) + pcb->sv); + + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_receive: RTO %"U16_F" (%"U16_F" milliseconds)\n", + pcb->rto, (u16_t)(pcb->rto * TCP_SLOW_INTERVAL))); + + pcb->rttest = 0; + } + } + + /* If the incoming segment contains data, we must process it + further unless the pcb already received a FIN. + (RFC 793, chapter 3.9, "SEGMENT ARRIVES" in states CLOSE-WAIT, CLOSING, + LAST-ACK and TIME-WAIT: "Ignore the segment text.") */ + if ((tcplen > 0) && (pcb->state < CLOSE_WAIT)) { + /* This code basically does three things: + + +) If the incoming segment contains data that is the next + in-sequence data, this data is passed to the application. This + might involve trimming the first edge of the data. The rcv_nxt + variable and the advertised window are adjusted. + + +) If the incoming segment has data that is above the next + sequence number expected (->rcv_nxt), the segment is placed on + the ->ooseq queue. This is done by finding the appropriate + place in the ->ooseq queue (which is ordered by sequence + number) and trim the segment in both ends if needed. An + immediate ACK is sent to indicate that we received an + out-of-sequence segment. + + +) Finally, we check if the first segment on the ->ooseq queue + now is in sequence (i.e., if rcv_nxt >= ooseq->seqno). If + rcv_nxt > ooseq->seqno, we must trim the first edge of the + segment on ->ooseq before we adjust rcv_nxt. The data in the + segments that are now on sequence are chained onto the + incoming segment so that we only need to call the application + once. + */ + + /* First, we check if we must trim the first edge. We have to do + this if the sequence number of the incoming segment is less + than rcv_nxt, and the sequence number plus the length of the + segment is larger than rcv_nxt. */ + /* if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)) { + if (TCP_SEQ_LT(pcb->rcv_nxt, seqno + tcplen)) {*/ + if (TCP_SEQ_BETWEEN(pcb->rcv_nxt, seqno + 1, seqno + tcplen - 1)) { + /* Trimming the first edge is done by pushing the payload + pointer in the pbuf downwards. This is somewhat tricky since + we do not want to discard the full contents of the pbuf up to + the new starting point of the data since we have to keep the + TCP header which is present in the first pbuf in the chain. + + What is done is really quite a nasty hack: the first pbuf in + the pbuf chain is pointed to by inseg.p. Since we need to be + able to deallocate the whole pbuf, we cannot change this + inseg.p pointer to point to any of the later pbufs in the + chain. Instead, we point the ->payload pointer in the first + pbuf to data in one of the later pbufs. We also set the + inseg.data pointer to point to the right place. This way, the + ->p pointer will still point to the first pbuf, but the + ->p->payload pointer will point to data in another pbuf. + + After we are done with adjusting the pbuf pointers we must + adjust the ->data pointer in the seg and the segment + length.*/ + + struct pbuf *p = inseg.p; + u32_t off32 = pcb->rcv_nxt - seqno; + u16_t new_tot_len, off; + LWIP_ASSERT("inseg.p != NULL", inseg.p); + LWIP_ASSERT("insane offset!", (off32 < 0xffff)); + off = (u16_t)off32; + LWIP_ASSERT("pbuf too short!", (((s32_t)inseg.p->tot_len) >= off)); + inseg.len -= off; + new_tot_len = (u16_t)(inseg.p->tot_len - off); + while (p->len < off) { + off -= p->len; + /* all pbufs up to and including this one have len==0, so tot_len is equal */ + p->tot_len = new_tot_len; + p->len = 0; + p = p->next; + } + /* cannot fail... */ + pbuf_remove_header(p, off); + inseg.tcphdr->seqno = seqno = pcb->rcv_nxt; + } else { + if (TCP_SEQ_LT(seqno, pcb->rcv_nxt)) { + /* the whole segment is < rcv_nxt */ + /* must be a duplicate of a packet that has already been correctly handled */ + + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: duplicate seqno %"U32_F"\n", seqno)); + tcp_ack_now(pcb); + } + } + + /* The sequence number must be within the window (above rcv_nxt + and below rcv_nxt + rcv_wnd) in order to be further + processed. */ + if (TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, + pcb->rcv_nxt + pcb->rcv_wnd - 1)) { + if (pcb->rcv_nxt == seqno) { + /* The incoming segment is the next in sequence. We check if + we have to trim the end of the segment and update rcv_nxt + and pass the data to the application. */ + tcplen = TCP_TCPLEN(&inseg); + + if (tcplen > pcb->rcv_wnd) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, + ("tcp_receive: other end overran receive window" + "seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n", + seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd)); + if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) { + /* Must remove the FIN from the header as we're trimming + * that byte of sequence-space from the packet */ + TCPH_FLAGS_SET(inseg.tcphdr, TCPH_FLAGS(inseg.tcphdr) & ~(unsigned int)TCP_FIN); + } + /* Adjust length of segment to fit in the window. */ + TCPWND_CHECK16(pcb->rcv_wnd); + inseg.len = (u16_t)pcb->rcv_wnd; + if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) { + inseg.len -= 1; + } + pbuf_realloc(inseg.p, inseg.len); + tcplen = TCP_TCPLEN(&inseg); + LWIP_ASSERT("tcp_receive: segment not trimmed correctly to rcv_wnd\n", + (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd)); + } +#if TCP_QUEUE_OOSEQ + /* Received in-sequence data, adjust ooseq data if: + - FIN has been received or + - inseq overlaps with ooseq */ + if (pcb->ooseq != NULL) { + if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, + ("tcp_receive: received in-order FIN, binning ooseq queue\n")); + /* Received in-order FIN means anything that was received + * out of order must now have been received in-order, so + * bin the ooseq queue */ + while (pcb->ooseq != NULL) { + struct tcp_seg *old_ooseq = pcb->ooseq; + pcb->ooseq = pcb->ooseq->next; + tcp_seg_free(old_ooseq); + } + } else { + struct tcp_seg *next = pcb->ooseq; + /* Remove all segments on ooseq that are covered by inseg already. + * FIN is copied from ooseq to inseg if present. */ + while (next && + TCP_SEQ_GEQ(seqno + tcplen, + next->tcphdr->seqno + next->len)) { + struct tcp_seg *tmp; + /* inseg cannot have FIN here (already processed above) */ + if ((TCPH_FLAGS(next->tcphdr) & TCP_FIN) != 0 && + (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) == 0) { + TCPH_SET_FLAG(inseg.tcphdr, TCP_FIN); + tcplen = TCP_TCPLEN(&inseg); + } + tmp = next; + next = next->next; + tcp_seg_free(tmp); + } + /* Now trim right side of inseg if it overlaps with the first + * segment on ooseq */ + if (next && + TCP_SEQ_GT(seqno + tcplen, + next->tcphdr->seqno)) { + /* inseg cannot have FIN here (already processed above) */ + inseg.len = (u16_t)(next->tcphdr->seqno - seqno); + if (TCPH_FLAGS(inseg.tcphdr) & TCP_SYN) { + inseg.len -= 1; + } + pbuf_realloc(inseg.p, inseg.len); + tcplen = TCP_TCPLEN(&inseg); + LWIP_ASSERT("tcp_receive: segment not trimmed correctly to ooseq queue\n", + (seqno + tcplen) == next->tcphdr->seqno); + } + pcb->ooseq = next; + } + } +#endif /* TCP_QUEUE_OOSEQ */ + + pcb->rcv_nxt = seqno + tcplen; + + /* Update the receiver's (our) window. */ + LWIP_ASSERT("tcp_receive: tcplen > rcv_wnd\n", pcb->rcv_wnd >= tcplen); + pcb->rcv_wnd -= tcplen; + + tcp_update_rcv_ann_wnd(pcb); + + /* If there is data in the segment, we make preparations to + pass this up to the application. The ->recv_data variable + is used for holding the pbuf that goes to the + application. The code for reassembling out-of-sequence data + chains its data on this pbuf as well. + + If the segment was a FIN, we set the TF_GOT_FIN flag that will + be used to indicate to the application that the remote side has + closed its end of the connection. */ + if (inseg.p->tot_len > 0) { + recv_data = inseg.p; + /* Since this pbuf now is the responsibility of the + application, we delete our reference to it so that we won't + (mistakingly) deallocate it. */ + inseg.p = NULL; + } + if (TCPH_FLAGS(inseg.tcphdr) & TCP_FIN) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: received FIN.\n")); + recv_flags |= TF_GOT_FIN; + } + +#if TCP_QUEUE_OOSEQ + /* We now check if we have segments on the ->ooseq queue that + are now in sequence. */ + while (pcb->ooseq != NULL && + pcb->ooseq->tcphdr->seqno == pcb->rcv_nxt) { + + struct tcp_seg *cseg = pcb->ooseq; + seqno = pcb->ooseq->tcphdr->seqno; + + pcb->rcv_nxt += TCP_TCPLEN(cseg); + LWIP_ASSERT("tcp_receive: ooseq tcplen > rcv_wnd\n", + pcb->rcv_wnd >= TCP_TCPLEN(cseg)); + pcb->rcv_wnd -= TCP_TCPLEN(cseg); + + tcp_update_rcv_ann_wnd(pcb); + + if (cseg->p->tot_len > 0) { + /* Chain this pbuf onto the pbuf that we will pass to + the application. */ + /* With window scaling, this can overflow recv_data->tot_len, but + that's not a problem since we explicitly fix that before passing + recv_data to the application. */ + if (recv_data) { + pbuf_cat(recv_data, cseg->p); + } else { + recv_data = cseg->p; + } + cseg->p = NULL; + } + if (TCPH_FLAGS(cseg->tcphdr) & TCP_FIN) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_receive: dequeued FIN.\n")); + recv_flags |= TF_GOT_FIN; + if (pcb->state == ESTABLISHED) { /* force passive close or we can move to active close */ + pcb->state = CLOSE_WAIT; + } + } + + pcb->ooseq = cseg->next; + tcp_seg_free(cseg); + } +#if LWIP_TCP_SACK_OUT + if (pcb->flags & TF_SACK) { + if (pcb->ooseq != NULL) { + /* Some segments may have been removed from ooseq, let's remove all SACKs that + describe anything before the new beginning of that list. */ + tcp_remove_sacks_lt(pcb, pcb->ooseq->tcphdr->seqno); + } else if (LWIP_TCP_SACK_VALID(pcb, 0)) { + /* ooseq has been cleared. Nothing to SACK */ + memset(pcb->rcv_sacks, 0, sizeof(pcb->rcv_sacks)); + } + } +#endif /* LWIP_TCP_SACK_OUT */ +#endif /* TCP_QUEUE_OOSEQ */ + + + /* Acknowledge the segment(s). */ + tcp_ack(pcb); + +#if LWIP_TCP_SACK_OUT + if (LWIP_TCP_SACK_VALID(pcb, 0)) { + /* Normally the ACK for the data received could be piggy-backed on a data packet, + but lwIP currently does not support including SACKs in data packets. So we force + it to respond with an empty ACK packet (only if there is at least one SACK to be sent). + NOTE: tcp_send_empty_ack() on success clears the ACK flags (set by tcp_ack()) */ + tcp_send_empty_ack(pcb); + } +#endif /* LWIP_TCP_SACK_OUT */ + +#if LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS + if (ip_current_is_v6()) { + /* Inform neighbor reachability of forward progress. */ + nd6_reachability_hint(ip6_current_src_addr()); + } +#endif /* LWIP_IPV6 && LWIP_ND6_TCP_REACHABILITY_HINTS*/ + + } else { + /* We get here if the incoming segment is out-of-sequence. */ + +#if TCP_QUEUE_OOSEQ + /* We queue the segment on the ->ooseq queue. */ + if (pcb->ooseq == NULL) { + pcb->ooseq = tcp_seg_copy(&inseg); +#if LWIP_TCP_SACK_OUT + if (pcb->flags & TF_SACK) { + /* All the SACKs should be invalid, so we can simply store the most recent one: */ + pcb->rcv_sacks[0].left = seqno; + pcb->rcv_sacks[0].right = seqno + inseg.len; + } +#endif /* LWIP_TCP_SACK_OUT */ + } else { + /* If the queue is not empty, we walk through the queue and + try to find a place where the sequence number of the + incoming segment is between the sequence numbers of the + previous and the next segment on the ->ooseq queue. That is + the place where we put the incoming segment. If needed, we + trim the second edges of the previous and the incoming + segment so that it will fit into the sequence. + + If the incoming segment has the same sequence number as a + segment on the ->ooseq queue, we discard the segment that + contains less data. */ + +#if LWIP_TCP_SACK_OUT + /* This is the left edge of the lowest possible SACK range. + It may start before the newly received segment (possibly adjusted below). */ + u32_t sackbeg = TCP_SEQ_LT(seqno, pcb->ooseq->tcphdr->seqno) ? seqno : pcb->ooseq->tcphdr->seqno; +#endif /* LWIP_TCP_SACK_OUT */ + struct tcp_seg *next, *prev = NULL; + for (next = pcb->ooseq; next != NULL; next = next->next) { + if (seqno == next->tcphdr->seqno) { + /* The sequence number of the incoming segment is the + same as the sequence number of the segment on + ->ooseq. We check the lengths to see which one to + discard. */ + if (inseg.len > next->len) { + /* The incoming segment is larger than the old + segment. We replace some segments with the new + one. */ + struct tcp_seg *cseg = tcp_seg_copy(&inseg); + if (cseg != NULL) { + if (prev != NULL) { + prev->next = cseg; + } else { + pcb->ooseq = cseg; + } + tcp_oos_insert_segment(cseg, next); + } + break; + } else { + /* Either the lengths are the same or the incoming + segment was smaller than the old one; in either + case, we ditch the incoming segment. */ + break; + } + } else { + if (prev == NULL) { + if (TCP_SEQ_LT(seqno, next->tcphdr->seqno)) { + /* The sequence number of the incoming segment is lower + than the sequence number of the first segment on the + queue. We put the incoming segment first on the + queue. */ + struct tcp_seg *cseg = tcp_seg_copy(&inseg); + if (cseg != NULL) { + pcb->ooseq = cseg; + tcp_oos_insert_segment(cseg, next); + } + break; + } + } else { + /*if (TCP_SEQ_LT(prev->tcphdr->seqno, seqno) && + TCP_SEQ_LT(seqno, next->tcphdr->seqno)) {*/ + if (TCP_SEQ_BETWEEN(seqno, prev->tcphdr->seqno + 1, next->tcphdr->seqno - 1)) { + /* The sequence number of the incoming segment is in + between the sequence numbers of the previous and + the next segment on ->ooseq. We trim trim the previous + segment, delete next segments that included in received segment + and trim received, if needed. */ + struct tcp_seg *cseg = tcp_seg_copy(&inseg); + if (cseg != NULL) { + if (TCP_SEQ_GT(prev->tcphdr->seqno + prev->len, seqno)) { + /* We need to trim the prev segment. */ + prev->len = (u16_t)(seqno - prev->tcphdr->seqno); + pbuf_realloc(prev->p, prev->len); + } + prev->next = cseg; + tcp_oos_insert_segment(cseg, next); + } + break; + } + } + +#if LWIP_TCP_SACK_OUT + /* The new segment goes after the 'next' one. If there is a "hole" in sequence numbers + between 'prev' and the beginning of 'next', we want to move sackbeg. */ + if (prev != NULL && prev->tcphdr->seqno + prev->len != next->tcphdr->seqno) { + sackbeg = next->tcphdr->seqno; + } +#endif /* LWIP_TCP_SACK_OUT */ + + /* We don't use 'prev' below, so let's set it to current 'next'. + This way even if we break the loop below, 'prev' will be pointing + at the segment right in front of the newly added one. */ + prev = next; + + /* If the "next" segment is the last segment on the + ooseq queue, we add the incoming segment to the end + of the list. */ + if (next->next == NULL && + TCP_SEQ_GT(seqno, next->tcphdr->seqno)) { + if (TCPH_FLAGS(next->tcphdr) & TCP_FIN) { + /* segment "next" already contains all data */ + break; + } + next->next = tcp_seg_copy(&inseg); + if (next->next != NULL) { + if (TCP_SEQ_GT(next->tcphdr->seqno + next->len, seqno)) { + /* We need to trim the last segment. */ + next->len = (u16_t)(seqno - next->tcphdr->seqno); + pbuf_realloc(next->p, next->len); + } + /* check if the remote side overruns our receive window */ + if (TCP_SEQ_GT((u32_t)tcplen + seqno, pcb->rcv_nxt + (u32_t)pcb->rcv_wnd)) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, + ("tcp_receive: other end overran receive window" + "seqno %"U32_F" len %"U16_F" right edge %"U32_F"\n", + seqno, tcplen, pcb->rcv_nxt + pcb->rcv_wnd)); + if (TCPH_FLAGS(next->next->tcphdr) & TCP_FIN) { + /* Must remove the FIN from the header as we're trimming + * that byte of sequence-space from the packet */ + TCPH_FLAGS_SET(next->next->tcphdr, TCPH_FLAGS(next->next->tcphdr) & ~TCP_FIN); + } + /* Adjust length of segment to fit in the window. */ + next->next->len = (u16_t)(pcb->rcv_nxt + pcb->rcv_wnd - seqno); + pbuf_realloc(next->next->p, next->next->len); + tcplen = TCP_TCPLEN(next->next); + LWIP_ASSERT("tcp_receive: segment not trimmed correctly to rcv_wnd\n", + (seqno + tcplen) == (pcb->rcv_nxt + pcb->rcv_wnd)); + } + } + break; + } + } + } + +#if LWIP_TCP_SACK_OUT + if (pcb->flags & TF_SACK) { + if (prev == NULL) { + /* The new segment is at the beginning. sackbeg should already be set properly. + We need to find the right edge. */ + next = pcb->ooseq; + } else if (prev->next != NULL) { + /* The new segment was added after 'prev'. If there is a "hole" between 'prev' and 'prev->next', + we need to move sackbeg. After that we should find the right edge. */ + next = prev->next; + if (prev->tcphdr->seqno + prev->len != next->tcphdr->seqno) { + sackbeg = next->tcphdr->seqno; + } + } else { + next = NULL; + } + if (next != NULL) { + u32_t sackend = next->tcphdr->seqno; + for ( ; (next != NULL) && (sackend == next->tcphdr->seqno); next = next->next) { + sackend += next->len; + } + tcp_add_sack(pcb, sackbeg, sackend); + } + } +#endif /* LWIP_TCP_SACK_OUT */ + } +#if defined(TCP_OOSEQ_BYTES_LIMIT) || defined(TCP_OOSEQ_PBUFS_LIMIT) + { + /* Check that the data on ooseq doesn't exceed one of the limits + and throw away everything above that limit. */ +#ifdef TCP_OOSEQ_BYTES_LIMIT + const u32_t ooseq_max_blen = TCP_OOSEQ_BYTES_LIMIT(pcb); + u32_t ooseq_blen = 0; +#endif +#ifdef TCP_OOSEQ_PBUFS_LIMIT + const u16_t ooseq_max_qlen = TCP_OOSEQ_PBUFS_LIMIT(pcb); + u16_t ooseq_qlen = 0; +#endif + struct tcp_seg *next, *prev = NULL; + for (next = pcb->ooseq; next != NULL; prev = next, next = next->next) { + struct pbuf *p = next->p; + int stop_here = 0; +#ifdef TCP_OOSEQ_BYTES_LIMIT + ooseq_blen += p->tot_len; + if (ooseq_blen > ooseq_max_blen) { + stop_here = 1; + } +#endif +#ifdef TCP_OOSEQ_PBUFS_LIMIT + ooseq_qlen += pbuf_clen(p); + if (ooseq_qlen > ooseq_max_qlen) { + stop_here = 1; + } +#endif + if (stop_here) { +#if LWIP_TCP_SACK_OUT + if (pcb->flags & TF_SACK) { + /* Let's remove all SACKs from next's seqno up. */ + tcp_remove_sacks_gt(pcb, next->tcphdr->seqno); + } +#endif /* LWIP_TCP_SACK_OUT */ + /* too much ooseq data, dump this and everything after it */ + tcp_segs_free(next); + if (prev == NULL) { + /* first ooseq segment is too much, dump the whole queue */ + pcb->ooseq = NULL; + } else { + /* just dump 'next' and everything after it */ + prev->next = NULL; + } + break; + } + } + } +#endif /* TCP_OOSEQ_BYTES_LIMIT || TCP_OOSEQ_PBUFS_LIMIT */ +#endif /* TCP_QUEUE_OOSEQ */ + + /* We send the ACK packet after we've (potentially) dealt with SACKs, + so they can be included in the acknowledgment. */ + tcp_send_empty_ack(pcb); + } + } else { + /* The incoming segment is not within the window. */ + tcp_send_empty_ack(pcb); + } + } else { + /* Segments with length 0 is taken care of here. Segments that + fall out of the window are ACKed. */ + if (!TCP_SEQ_BETWEEN(seqno, pcb->rcv_nxt, pcb->rcv_nxt + pcb->rcv_wnd - 1)) { + tcp_ack_now(pcb); + } + } +} + +static u8_t +tcp_get_next_optbyte(void) +{ + u16_t optidx = tcp_optidx++; + if ((tcphdr_opt2 == NULL) || (optidx < tcphdr_opt1len)) { + u8_t *opts = (u8_t *)tcphdr + TCP_HLEN; + return opts[optidx]; + } else { + u8_t idx = (u8_t)(optidx - tcphdr_opt1len); + return tcphdr_opt2[idx]; + } +} + +/** + * Parses the options contained in the incoming segment. + * + * Called from tcp_listen_input() and tcp_process(). + * Currently, only the MSS option is supported! + * + * @param pcb the tcp_pcb for which a segment arrived + */ +static void +tcp_parseopt(struct tcp_pcb *pcb) +{ + u8_t data; + u16_t mss; +#if LWIP_TCP_TIMESTAMPS + u32_t tsval; +#endif + + LWIP_ASSERT("tcp_parseopt: invalid pcb", pcb != NULL); + + /* Parse the TCP MSS option, if present. */ + if (tcphdr_optlen != 0) { + for (tcp_optidx = 0; tcp_optidx < tcphdr_optlen; ) { + u8_t opt = tcp_get_next_optbyte(); + switch (opt) { + case LWIP_TCP_OPT_EOL: + /* End of options. */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: EOL\n")); + return; + case LWIP_TCP_OPT_NOP: + /* NOP option. */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: NOP\n")); + break; + case LWIP_TCP_OPT_MSS: + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: MSS\n")); + if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_MSS || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_MSS) > tcphdr_optlen) { + /* Bad length */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); + return; + } + /* An MSS option with the right option length. */ + mss = (u16_t)(tcp_get_next_optbyte() << 8); + mss |= tcp_get_next_optbyte(); + /* Limit the mss to the configured TCP_MSS and prevent division by zero */ + pcb->mss = ((mss > TCP_MSS) || (mss == 0)) ? TCP_MSS : mss; + break; +#if LWIP_WND_SCALE + case LWIP_TCP_OPT_WS: + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: WND_SCALE\n")); + if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_WS || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_WS) > tcphdr_optlen) { + /* Bad length */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); + return; + } + /* An WND_SCALE option with the right option length. */ + data = tcp_get_next_optbyte(); + /* If syn was received with wnd scale option, + activate wnd scale opt, but only if this is not a retransmission */ + if ((flags & TCP_SYN) && !(pcb->flags & TF_WND_SCALE)) { + pcb->snd_scale = data; + if (pcb->snd_scale > 14U) { + pcb->snd_scale = 14U; + } + pcb->rcv_scale = TCP_RCV_SCALE; + tcp_set_flags(pcb, TF_WND_SCALE); + /* window scaling is enabled, we can use the full receive window */ + LWIP_ASSERT("window not at default value", pcb->rcv_wnd == TCPWND_MIN16(TCP_WND)); + LWIP_ASSERT("window not at default value", pcb->rcv_ann_wnd == TCPWND_MIN16(TCP_WND)); + pcb->rcv_wnd = pcb->rcv_ann_wnd = TCP_WND; + } + break; +#endif /* LWIP_WND_SCALE */ +#if LWIP_TCP_TIMESTAMPS + case LWIP_TCP_OPT_TS: + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: TS\n")); + if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_TS || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_TS) > tcphdr_optlen) { + /* Bad length */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); + return; + } + /* TCP timestamp option with valid length */ + tsval = tcp_get_next_optbyte(); + tsval |= (tcp_get_next_optbyte() << 8); + tsval |= (tcp_get_next_optbyte() << 16); + tsval |= (tcp_get_next_optbyte() << 24); + if (flags & TCP_SYN) { + pcb->ts_recent = lwip_ntohl(tsval); + /* Enable sending timestamps in every segment now that we know + the remote host supports it. */ + tcp_set_flags(pcb, TF_TIMESTAMP); + } else if (TCP_SEQ_BETWEEN(pcb->ts_lastacksent, seqno, seqno + tcplen)) { + pcb->ts_recent = lwip_ntohl(tsval); + } + /* Advance to next option (6 bytes already read) */ + tcp_optidx += LWIP_TCP_OPT_LEN_TS - 6; + break; +#endif /* LWIP_TCP_TIMESTAMPS */ +#if LWIP_TCP_SACK_OUT + case LWIP_TCP_OPT_SACK_PERM: + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: SACK_PERM\n")); + if (tcp_get_next_optbyte() != LWIP_TCP_OPT_LEN_SACK_PERM || (tcp_optidx - 2 + LWIP_TCP_OPT_LEN_SACK_PERM) > tcphdr_optlen) { + /* Bad length */ + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); + return; + } + /* TCP SACK_PERM option with valid length */ + if (flags & TCP_SYN) { + /* We only set it if we receive it in a SYN (or SYN+ACK) packet */ + tcp_set_flags(pcb, TF_SACK); + } + break; +#endif /* LWIP_TCP_SACK_OUT */ + default: + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: other\n")); + data = tcp_get_next_optbyte(); + if (data < 2) { + LWIP_DEBUGF(TCP_INPUT_DEBUG, ("tcp_parseopt: bad length\n")); + /* If the length field is zero, the options are malformed + and we don't process them further. */ + return; + } + /* All other options have a length field, so that we easily + can skip past them. */ + tcp_optidx += data - 2; + } + } + } +} + +void +tcp_trigger_input_pcb_close(void) +{ + recv_flags |= TF_CLOSED; +} + +#if LWIP_TCP_SACK_OUT +/** + * Called by tcp_receive() to add new SACK entry. + * + * The new SACK entry will be placed at the beginning of rcv_sacks[], as the newest one. + * Existing SACK entries will be "pushed back", to preserve their order. + * This is the behavior described in RFC 2018, section 4. + * + * @param pcb the tcp_pcb for which a segment arrived + * @param left the left side of the SACK (the first sequence number) + * @param right the right side of the SACK (the first sequence number past this SACK) + */ +static void +tcp_add_sack(struct tcp_pcb *pcb, u32_t left, u32_t right) +{ + u8_t i; + u8_t unused_idx; + + if ((pcb->flags & TF_SACK) == 0 || !TCP_SEQ_LT(left, right)) { + return; + } + + /* First, let's remove all SACKs that are no longer needed (because they overlap with the newest one), + while moving all other SACKs forward. + We run this loop for all entries, until we find the first invalid one. + There is no point checking after that. */ + for (i = unused_idx = 0; (i < LWIP_TCP_MAX_SACK_NUM) && LWIP_TCP_SACK_VALID(pcb, i); ++i) { + /* We only want to use SACK at [i] if it doesn't overlap with left:right range. + It does not overlap if its right side is before the newly added SACK, + or if its left side is after the newly added SACK. + NOTE: The equality should not really happen, but it doesn't hurt. */ + if (TCP_SEQ_LEQ(pcb->rcv_sacks[i].right, left) || TCP_SEQ_LEQ(right, pcb->rcv_sacks[i].left)) { + if (unused_idx != i) { + /* We don't need to copy if it's already in the right spot */ + pcb->rcv_sacks[unused_idx] = pcb->rcv_sacks[i]; + } + ++unused_idx; + } + } + + /* Now 'unused_idx' is the index of the first invalid SACK entry, + anywhere between 0 (no valid entries) and LWIP_TCP_MAX_SACK_NUM (all entries are valid). + We want to clear this and all following SACKs. + However, we will be adding another one in the front (and shifting everything else back). + So let's just iterate from the back, and set each entry to the one to the left if it's valid, + or to 0 if it is not. */ + for (i = LWIP_TCP_MAX_SACK_NUM - 1; i > 0; --i) { + /* [i] is the index we are setting, and the value should be at index [i-1], + or 0 if that index is unused (>= unused_idx). */ + if (i - 1 >= unused_idx) { + /* [i-1] is unused. Let's clear [i]. */ + pcb->rcv_sacks[i].left = pcb->rcv_sacks[i].right = 0; + } else { + pcb->rcv_sacks[i] = pcb->rcv_sacks[i - 1]; + } + } + + /* And now we can store the newest SACK */ + pcb->rcv_sacks[0].left = left; + pcb->rcv_sacks[0].right = right; +} + +/** + * Called to remove a range of SACKs. + * + * SACK entries will be removed or adjusted to not acknowledge any sequence + * numbers that are less than 'seq' passed. It not only invalidates entries, + * but also moves all entries that are still valid to the beginning. + * + * @param pcb the tcp_pcb to modify + * @param seq the lowest sequence number to keep in SACK entries + */ +static void +tcp_remove_sacks_lt(struct tcp_pcb *pcb, u32_t seq) +{ + u8_t i; + u8_t unused_idx; + + /* We run this loop for all entries, until we find the first invalid one. + There is no point checking after that. */ + for (i = unused_idx = 0; (i < LWIP_TCP_MAX_SACK_NUM) && LWIP_TCP_SACK_VALID(pcb, i); ++i) { + /* We only want to use SACK at index [i] if its right side is > 'seq'. */ + if (TCP_SEQ_GT(pcb->rcv_sacks[i].right, seq)) { + if (unused_idx != i) { + /* We only copy it if it's not in the right spot already. */ + pcb->rcv_sacks[unused_idx] = pcb->rcv_sacks[i]; + } + /* NOTE: It is possible that its left side is < 'seq', in which case we should adjust it. */ + if (TCP_SEQ_LT(pcb->rcv_sacks[unused_idx].left, seq)) { + pcb->rcv_sacks[unused_idx].left = seq; + } + ++unused_idx; + } + } + + /* We also need to invalidate everything from 'unused_idx' till the end */ + for (i = unused_idx; i < LWIP_TCP_MAX_SACK_NUM; ++i) { + pcb->rcv_sacks[i].left = pcb->rcv_sacks[i].right = 0; + } +} + +#if defined(TCP_OOSEQ_BYTES_LIMIT) || defined(TCP_OOSEQ_PBUFS_LIMIT) +/** + * Called to remove a range of SACKs. + * + * SACK entries will be removed or adjusted to not acknowledge any sequence + * numbers that are greater than (or equal to) 'seq' passed. It not only invalidates entries, + * but also moves all entries that are still valid to the beginning. + * + * @param pcb the tcp_pcb to modify + * @param seq the highest sequence number to keep in SACK entries + */ +static void +tcp_remove_sacks_gt(struct tcp_pcb *pcb, u32_t seq) +{ + u8_t i; + u8_t unused_idx; + + /* We run this loop for all entries, until we find the first invalid one. + There is no point checking after that. */ + for (i = unused_idx = 0; (i < LWIP_TCP_MAX_SACK_NUM) && LWIP_TCP_SACK_VALID(pcb, i); ++i) { + /* We only want to use SACK at index [i] if its left side is < 'seq'. */ + if (TCP_SEQ_LT(pcb->rcv_sacks[i].left, seq)) { + if (unused_idx != i) { + /* We only copy it if it's not in the right spot already. */ + pcb->rcv_sacks[unused_idx] = pcb->rcv_sacks[i]; + } + /* NOTE: It is possible that its right side is > 'seq', in which case we should adjust it. */ + if (TCP_SEQ_GT(pcb->rcv_sacks[unused_idx].right, seq)) { + pcb->rcv_sacks[unused_idx].right = seq; + } + ++unused_idx; + } + } + + /* We also need to invalidate everything from 'unused_idx' till the end */ + for (i = unused_idx; i < LWIP_TCP_MAX_SACK_NUM; ++i) { + pcb->rcv_sacks[i].left = pcb->rcv_sacks[i].right = 0; + } +} +#endif /* TCP_OOSEQ_BYTES_LIMIT || TCP_OOSEQ_PBUFS_LIMIT */ + +#endif /* LWIP_TCP_SACK_OUT */ + +#endif /* LWIP_TCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_out.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_out.c index 375e18d7..724df109 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_out.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/tcp_out.c @@ -1,2190 +1,2190 @@ -/** - * @file - * Transmission Control Protocol, outgoing traffic - * - * The output functions of TCP. - * - * There are two distinct ways for TCP segments to get sent: - * - queued data: these are segments transferring data or segments containing - * SYN or FIN (which both count as one sequence number). They are created as - * struct @ref pbuf together with a struct tcp_seg and enqueue to the - * unsent list of the pcb. They are sent by tcp_output: - * - @ref tcp_write : creates data segments - * - @ref tcp_split_unsent_seg : splits a data segment - * - @ref tcp_enqueue_flags : creates SYN-only or FIN-only segments - * - @ref tcp_output / tcp_output_segment : finalize the tcp header - * (e.g. sequence numbers, options, checksum) and output to IP - * - the various tcp_rexmit functions shuffle around segments between the - * unsent an unacked lists to retransmit them - * - tcp_create_segment and tcp_pbuf_prealloc allocate pbuf and - * segment for these functions - * - direct send: these segments don't contain data but control the connection - * behaviour. They are created as pbuf only and sent directly without - * enqueueing them: - * - @ref tcp_send_empty_ack sends an ACK-only segment - * - @ref tcp_rst sends a RST segment - * - @ref tcp_keepalive sends a keepalive segment - * - @ref tcp_zero_window_probe sends a window probe segment - * - tcp_output_alloc_header allocates a header-only pbuf for these functions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#include "lwip/opt.h" - -#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/priv/tcp_priv.h" -#include "lwip/def.h" -#include "lwip/mem.h" -#include "lwip/memp.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/inet_chksum.h" -#include "lwip/stats.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#if LWIP_TCP_TIMESTAMPS -#include "lwip/sys.h" -#endif - -#include - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -/* Allow to add custom TCP header options by defining this hook */ -#ifdef LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH -#define LWIP_TCP_OPT_LENGTH_SEGMENT(flags, pcb) LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH(pcb, LWIP_TCP_OPT_LENGTH(flags)) -#else -#define LWIP_TCP_OPT_LENGTH_SEGMENT(flags, pcb) LWIP_TCP_OPT_LENGTH(flags) -#endif - -/* Define some copy-macros for checksum-on-copy so that the code looks - nicer by preventing too many ifdef's. */ -#if TCP_CHECKSUM_ON_COPY -#define TCP_DATA_COPY(dst, src, len, seg) do { \ - tcp_seg_add_chksum(LWIP_CHKSUM_COPY(dst, src, len), \ - len, &seg->chksum, &seg->chksum_swapped); \ - seg->flags |= TF_SEG_DATA_CHECKSUMMED; } while(0) -#define TCP_DATA_COPY2(dst, src, len, chksum, chksum_swapped) \ - tcp_seg_add_chksum(LWIP_CHKSUM_COPY(dst, src, len), len, chksum, chksum_swapped); -#else /* TCP_CHECKSUM_ON_COPY*/ -#define TCP_DATA_COPY(dst, src, len, seg) MEMCPY(dst, src, len) -#define TCP_DATA_COPY2(dst, src, len, chksum, chksum_swapped) MEMCPY(dst, src, len) -#endif /* TCP_CHECKSUM_ON_COPY*/ - -/** Define this to 1 for an extra check that the output checksum is valid - * (usefule when the checksum is generated by the application, not the stack) */ -#ifndef TCP_CHECKSUM_ON_COPY_SANITY_CHECK -#define TCP_CHECKSUM_ON_COPY_SANITY_CHECK 0 -#endif -/* Allow to override the failure of sanity check from warning to e.g. hard failure */ -#if TCP_CHECKSUM_ON_COPY_SANITY_CHECK -#ifndef TCP_CHECKSUM_ON_COPY_SANITY_CHECK_FAIL -#define TCP_CHECKSUM_ON_COPY_SANITY_CHECK_FAIL(msg) LWIP_DEBUGF(TCP_DEBUG | LWIP_DBG_LEVEL_WARNING, msg) -#endif -#endif - -#if TCP_OVERSIZE -/** The size of segment pbufs created when TCP_OVERSIZE is enabled */ -#ifndef TCP_OVERSIZE_CALC_LENGTH -#define TCP_OVERSIZE_CALC_LENGTH(length) ((length) + TCP_OVERSIZE) -#endif -#endif - -/* Forward declarations.*/ -static err_t tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb, struct netif *netif); - -/* tcp_route: common code that returns a fixed bound netif or calls ip_route */ -static struct netif * -tcp_route(const struct tcp_pcb *pcb, const ip_addr_t *src, const ip_addr_t *dst) -{ - LWIP_UNUSED_ARG(src); /* in case IPv4-only and source-based routing is disabled */ - - if ((pcb != NULL) && (pcb->netif_idx != NETIF_NO_INDEX)) { - return netif_get_by_index(pcb->netif_idx); - } else { - return ip_route(src, dst); - } -} - -/** - * Create a TCP segment with prefilled header. - * - * Called by @ref tcp_write, @ref tcp_enqueue_flags and @ref tcp_split_unsent_seg - * - * @param pcb Protocol control block for the TCP connection. - * @param p pbuf that is used to hold the TCP header. - * @param hdrflags TCP flags for header. - * @param seqno TCP sequence number of this packet - * @param optflags options to include in TCP header - * @return a new tcp_seg pointing to p, or NULL. - * The TCP header is filled in except ackno and wnd. - * p is freed on failure. - */ -static struct tcp_seg * -tcp_create_segment(const struct tcp_pcb *pcb, struct pbuf *p, u8_t hdrflags, u32_t seqno, u8_t optflags) -{ - struct tcp_seg *seg; - u8_t optlen; - - LWIP_ASSERT("tcp_create_segment: invalid pcb", pcb != NULL); - LWIP_ASSERT("tcp_create_segment: invalid pbuf", p != NULL); - - optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb); - - if ((seg = (struct tcp_seg *)memp_malloc(MEMP_TCP_SEG)) == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_create_segment: no memory.\n")); - pbuf_free(p); - return NULL; - } - seg->flags = optflags; - seg->next = NULL; - seg->p = p; - LWIP_ASSERT("p->tot_len >= optlen", p->tot_len >= optlen); - seg->len = p->tot_len - optlen; -#if TCP_OVERSIZE_DBGCHECK - seg->oversize_left = 0; -#endif /* TCP_OVERSIZE_DBGCHECK */ -#if TCP_CHECKSUM_ON_COPY - seg->chksum = 0; - seg->chksum_swapped = 0; - /* check optflags */ - LWIP_ASSERT("invalid optflags passed: TF_SEG_DATA_CHECKSUMMED", - (optflags & TF_SEG_DATA_CHECKSUMMED) == 0); -#endif /* TCP_CHECKSUM_ON_COPY */ - - /* build TCP header */ - if (pbuf_add_header(p, TCP_HLEN)) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_create_segment: no room for TCP header in pbuf.\n")); - TCP_STATS_INC(tcp.err); - tcp_seg_free(seg); - return NULL; - } - seg->tcphdr = (struct tcp_hdr *)seg->p->payload; - seg->tcphdr->src = lwip_htons(pcb->local_port); - seg->tcphdr->dest = lwip_htons(pcb->remote_port); - seg->tcphdr->seqno = lwip_htonl(seqno); - /* ackno is set in tcp_output */ - TCPH_HDRLEN_FLAGS_SET(seg->tcphdr, (5 + optlen / 4), hdrflags); - /* wnd and chksum are set in tcp_output */ - seg->tcphdr->urgp = 0; - return seg; -} - -/** - * Allocate a PBUF_RAM pbuf, perhaps with extra space at the end. - * - * This function is like pbuf_alloc(layer, length, PBUF_RAM) except - * there may be extra bytes available at the end. - * - * Called by @ref tcp_write - * - * @param layer flag to define header size. - * @param length size of the pbuf's payload. - * @param max_length maximum usable size of payload+oversize. - * @param oversize pointer to a u16_t that will receive the number of usable tail bytes. - * @param pcb The TCP connection that will enqueue the pbuf. - * @param apiflags API flags given to tcp_write. - * @param first_seg true when this pbuf will be used in the first enqueued segment. - */ -#if TCP_OVERSIZE -static struct pbuf * -tcp_pbuf_prealloc(pbuf_layer layer, u16_t length, u16_t max_length, - u16_t *oversize, const struct tcp_pcb *pcb, u8_t apiflags, - u8_t first_seg) -{ - struct pbuf *p; - u16_t alloc = length; - - LWIP_ASSERT("tcp_pbuf_prealloc: invalid oversize", oversize != NULL); - LWIP_ASSERT("tcp_pbuf_prealloc: invalid pcb", pcb != NULL); - -#if LWIP_NETIF_TX_SINGLE_PBUF - LWIP_UNUSED_ARG(max_length); - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(apiflags); - LWIP_UNUSED_ARG(first_seg); - alloc = max_length; -#else /* LWIP_NETIF_TX_SINGLE_PBUF */ - if (length < max_length) { - /* Should we allocate an oversized pbuf, or just the minimum - * length required? If tcp_write is going to be called again - * before this segment is transmitted, we want the oversized - * buffer. If the segment will be transmitted immediately, we can - * save memory by allocating only length. We use a simple - * heuristic based on the following information: - * - * Did the user set TCP_WRITE_FLAG_MORE? - * - * Will the Nagle algorithm defer transmission of this segment? - */ - if ((apiflags & TCP_WRITE_FLAG_MORE) || - (!(pcb->flags & TF_NODELAY) && - (!first_seg || - pcb->unsent != NULL || - pcb->unacked != NULL))) { - alloc = LWIP_MIN(max_length, LWIP_MEM_ALIGN_SIZE(TCP_OVERSIZE_CALC_LENGTH(length))); - } - } -#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ - p = pbuf_alloc(layer, alloc, PBUF_RAM); - if (p == NULL) { - return NULL; - } - LWIP_ASSERT("need unchained pbuf", p->next == NULL); - *oversize = p->len - length; - /* trim p->len to the currently used size */ - p->len = p->tot_len = length; - return p; -} -#else /* TCP_OVERSIZE */ -#define tcp_pbuf_prealloc(layer, length, mx, os, pcb, api, fst) pbuf_alloc((layer), (length), PBUF_RAM) -#endif /* TCP_OVERSIZE */ - -#if TCP_CHECKSUM_ON_COPY -/** Add a checksum of newly added data to the segment. - * - * Called by tcp_write and tcp_split_unsent_seg. - */ -static void -tcp_seg_add_chksum(u16_t chksum, u16_t len, u16_t *seg_chksum, - u8_t *seg_chksum_swapped) -{ - u32_t helper; - /* add chksum to old chksum and fold to u16_t */ - helper = chksum + *seg_chksum; - chksum = FOLD_U32T(helper); - if ((len & 1) != 0) { - *seg_chksum_swapped = 1 - *seg_chksum_swapped; - chksum = SWAP_BYTES_IN_WORD(chksum); - } - *seg_chksum = chksum; -} -#endif /* TCP_CHECKSUM_ON_COPY */ - -/** Checks if tcp_write is allowed or not (checks state, snd_buf and snd_queuelen). - * - * @param pcb the tcp pcb to check for - * @param len length of data to send (checked agains snd_buf) - * @return ERR_OK if tcp_write is allowed to proceed, another err_t otherwise - */ -static err_t -tcp_write_checks(struct tcp_pcb *pcb, u16_t len) -{ - LWIP_ASSERT("tcp_write_checks: invalid pcb", pcb != NULL); - - /* connection is in invalid state for data transmission? */ - if ((pcb->state != ESTABLISHED) && - (pcb->state != CLOSE_WAIT) && - (pcb->state != SYN_SENT) && - (pcb->state != SYN_RCVD)) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_STATE | LWIP_DBG_LEVEL_SEVERE, ("tcp_write() called in invalid state\n")); - return ERR_CONN; - } else if (len == 0) { - return ERR_OK; - } - - /* fail on too much data */ - if (len > pcb->snd_buf) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("tcp_write: too much data (len=%"U16_F" > snd_buf=%"TCPWNDSIZE_F")\n", - len, pcb->snd_buf)); - tcp_set_flags(pcb, TF_NAGLEMEMERR); - return ERR_MEM; - } - - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: queuelen: %"TCPWNDSIZE_F"\n", (tcpwnd_size_t)pcb->snd_queuelen)); - - /* If total number of pbufs on the unsent/unacked queues exceeds the - * configured maximum, return an error */ - /* check for configured max queuelen and possible overflow */ - if (pcb->snd_queuelen >= LWIP_MIN(TCP_SND_QUEUELEN, (TCP_SNDQUEUELEN_OVERFLOW + 1))) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("tcp_write: too long queue %"U16_F" (max %"U16_F")\n", - pcb->snd_queuelen, (u16_t)TCP_SND_QUEUELEN)); - TCP_STATS_INC(tcp.memerr); - tcp_set_flags(pcb, TF_NAGLEMEMERR); - return ERR_MEM; - } - if (pcb->snd_queuelen != 0) { - LWIP_ASSERT("tcp_write: pbufs on queue => at least one queue non-empty", - pcb->unacked != NULL || pcb->unsent != NULL); - } else { - LWIP_ASSERT("tcp_write: no pbufs on queue => both queues empty", - pcb->unacked == NULL && pcb->unsent == NULL); - } - return ERR_OK; -} - -/** - * @ingroup tcp_raw - * Write data for sending (but does not send it immediately). - * - * It waits in the expectation of more data being sent soon (as - * it can send them more efficiently by combining them together). - * To prompt the system to send data now, call tcp_output() after - * calling tcp_write(). - * - * This function enqueues the data pointed to by the argument dataptr. The length of - * the data is passed as the len parameter. The apiflags can be one or more of: - * - TCP_WRITE_FLAG_COPY: indicates whether the new memory should be allocated - * for the data to be copied into. If this flag is not given, no new memory - * should be allocated and the data should only be referenced by pointer. This - * also means that the memory behind dataptr must not change until the data is - * ACKed by the remote host - * - TCP_WRITE_FLAG_MORE: indicates that more data follows. If this is omitted, - * the PSH flag is set in the last segment created by this call to tcp_write. - * If this flag is given, the PSH flag is not set. - * - * The tcp_write() function will fail and return ERR_MEM if the length - * of the data exceeds the current send buffer size or if the length of - * the queue of outgoing segment is larger than the upper limit defined - * in lwipopts.h. The number of bytes available in the output queue can - * be retrieved with the tcp_sndbuf() function. - * - * The proper way to use this function is to call the function with at - * most tcp_sndbuf() bytes of data. If the function returns ERR_MEM, - * the application should wait until some of the currently enqueued - * data has been successfully received by the other host and try again. - * - * @param pcb Protocol control block for the TCP connection to enqueue data for. - * @param arg Pointer to the data to be enqueued for sending. - * @param len Data length in bytes - * @param apiflags combination of following flags : - * - TCP_WRITE_FLAG_COPY (0x01) data will be copied into memory belonging to the stack - * - TCP_WRITE_FLAG_MORE (0x02) for TCP connection, PSH flag will not be set on last segment sent, - * @return ERR_OK if enqueued, another err_t on error - */ -err_t -tcp_write(struct tcp_pcb *pcb, const void *arg, u16_t len, u8_t apiflags) -{ - struct pbuf *concat_p = NULL; - struct tcp_seg *last_unsent = NULL, *seg = NULL, *prev_seg = NULL, *queue = NULL; - u16_t pos = 0; /* position in 'arg' data */ - u16_t queuelen; - u8_t optlen; - u8_t optflags = 0; -#if TCP_OVERSIZE - u16_t oversize = 0; - u16_t oversize_used = 0; -#if TCP_OVERSIZE_DBGCHECK - u16_t oversize_add = 0; -#endif /* TCP_OVERSIZE_DBGCHECK*/ -#endif /* TCP_OVERSIZE */ - u16_t extendlen = 0; -#if TCP_CHECKSUM_ON_COPY - u16_t concat_chksum = 0; - u8_t concat_chksum_swapped = 0; - u16_t concat_chksummed = 0; -#endif /* TCP_CHECKSUM_ON_COPY */ - err_t err; - u16_t mss_local; - - LWIP_ERROR("tcp_write: invalid pcb", pcb != NULL, return ERR_ARG); - - /* don't allocate segments bigger than half the maximum window we ever received */ - mss_local = LWIP_MIN(pcb->mss, TCPWND_MIN16(pcb->snd_wnd_max / 2)); - mss_local = mss_local ? mss_local : pcb->mss; - - LWIP_ASSERT_CORE_LOCKED(); - -#if LWIP_NETIF_TX_SINGLE_PBUF - /* Always copy to try to create single pbufs for TX */ - apiflags |= TCP_WRITE_FLAG_COPY; -#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ - - LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_write(pcb=%p, data=%p, len=%"U16_F", apiflags=%"U16_F")\n", - (void *)pcb, arg, len, (u16_t)apiflags)); - LWIP_ERROR("tcp_write: arg == NULL (programmer violates API)", - arg != NULL, return ERR_ARG;); - - err = tcp_write_checks(pcb, len); - if (err != ERR_OK) { - return err; - } - queuelen = pcb->snd_queuelen; - -#if LWIP_TCP_TIMESTAMPS - if ((pcb->flags & TF_TIMESTAMP)) { - /* Make sure the timestamp option is only included in data segments if we - agreed about it with the remote host. */ - optflags = TF_SEG_OPTS_TS; - optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(TF_SEG_OPTS_TS, pcb); - /* ensure that segments can hold at least one data byte... */ - mss_local = LWIP_MAX(mss_local, LWIP_TCP_OPT_LEN_TS + 1); - } else -#endif /* LWIP_TCP_TIMESTAMPS */ - { - optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); - } - - - /* - * TCP segmentation is done in three phases with increasing complexity: - * - * 1. Copy data directly into an oversized pbuf. - * 2. Chain a new pbuf to the end of pcb->unsent. - * 3. Create new segments. - * - * We may run out of memory at any point. In that case we must - * return ERR_MEM and not change anything in pcb. Therefore, all - * changes are recorded in local variables and committed at the end - * of the function. Some pcb fields are maintained in local copies: - * - * queuelen = pcb->snd_queuelen - * oversize = pcb->unsent_oversize - * - * These variables are set consistently by the phases: - * - * seg points to the last segment tampered with. - * - * pos records progress as data is segmented. - */ - - /* Find the tail of the unsent queue. */ - if (pcb->unsent != NULL) { - u16_t space; - u16_t unsent_optlen; - - /* @todo: this could be sped up by keeping last_unsent in the pcb */ - for (last_unsent = pcb->unsent; last_unsent->next != NULL; - last_unsent = last_unsent->next); - - /* Usable space at the end of the last unsent segment */ - unsent_optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(last_unsent->flags, pcb); - LWIP_ASSERT("mss_local is too small", mss_local >= last_unsent->len + unsent_optlen); - space = mss_local - (last_unsent->len + unsent_optlen); - - /* - * Phase 1: Copy data directly into an oversized pbuf. - * - * The number of bytes copied is recorded in the oversize_used - * variable. The actual copying is done at the bottom of the - * function. - */ -#if TCP_OVERSIZE -#if TCP_OVERSIZE_DBGCHECK - /* check that pcb->unsent_oversize matches last_unsent->oversize_left */ - LWIP_ASSERT("unsent_oversize mismatch (pcb vs. last_unsent)", - pcb->unsent_oversize == last_unsent->oversize_left); -#endif /* TCP_OVERSIZE_DBGCHECK */ - oversize = pcb->unsent_oversize; - if (oversize > 0) { - LWIP_ASSERT("inconsistent oversize vs. space", oversize <= space); - seg = last_unsent; - oversize_used = LWIP_MIN(space, LWIP_MIN(oversize, len)); - pos += oversize_used; - oversize -= oversize_used; - space -= oversize_used; - } - /* now we are either finished or oversize is zero */ - LWIP_ASSERT("inconsistent oversize vs. len", (oversize == 0) || (pos == len)); -#endif /* TCP_OVERSIZE */ - -#if !LWIP_NETIF_TX_SINGLE_PBUF - /* - * Phase 2: Chain a new pbuf to the end of pcb->unsent. - * - * As an exception when NOT copying the data, if the given data buffer - * directly follows the last unsent data buffer in memory, extend the last - * ROM pbuf reference to the buffer, thus saving a ROM pbuf allocation. - * - * We don't extend segments containing SYN/FIN flags or options - * (len==0). The new pbuf is kept in concat_p and pbuf_cat'ed at - * the end. - * - * This phase is skipped for LWIP_NETIF_TX_SINGLE_PBUF as we could only execute - * it after rexmit puts a segment from unacked to unsent and at this point, - * oversize info is lost. - */ - if ((pos < len) && (space > 0) && (last_unsent->len > 0)) { - u16_t seglen = LWIP_MIN(space, len - pos); - seg = last_unsent; - - /* Create a pbuf with a copy or reference to seglen bytes. We - * can use PBUF_RAW here since the data appears in the middle of - * a segment. A header will never be prepended. */ - if (apiflags & TCP_WRITE_FLAG_COPY) { - /* Data is copied */ - if ((concat_p = tcp_pbuf_prealloc(PBUF_RAW, seglen, space, &oversize, pcb, apiflags, 1)) == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n", - seglen)); - goto memerr; - } -#if TCP_OVERSIZE_DBGCHECK - oversize_add = oversize; -#endif /* TCP_OVERSIZE_DBGCHECK */ - TCP_DATA_COPY2(concat_p->payload, (const u8_t *)arg + pos, seglen, &concat_chksum, &concat_chksum_swapped); -#if TCP_CHECKSUM_ON_COPY - concat_chksummed += seglen; -#endif /* TCP_CHECKSUM_ON_COPY */ - queuelen += pbuf_clen(concat_p); - } else { - /* Data is not copied */ - /* If the last unsent pbuf is of type PBUF_ROM, try to extend it. */ - struct pbuf *p; - for (p = last_unsent->p; p->next != NULL; p = p->next); - if (((p->type_internal & (PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS | PBUF_TYPE_FLAG_DATA_VOLATILE)) == 0) && - (const u8_t *)p->payload + p->len == (const u8_t *)arg) { - LWIP_ASSERT("tcp_write: ROM pbufs cannot be oversized", pos == 0); - extendlen = seglen; - } else { - if ((concat_p = pbuf_alloc(PBUF_RAW, seglen, PBUF_ROM)) == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("tcp_write: could not allocate memory for zero-copy pbuf\n")); - goto memerr; - } - /* reference the non-volatile payload data */ - ((struct pbuf_rom *)concat_p)->payload = (const u8_t *)arg + pos; - queuelen += pbuf_clen(concat_p); - } -#if TCP_CHECKSUM_ON_COPY - /* calculate the checksum of nocopy-data */ - tcp_seg_add_chksum(~inet_chksum((const u8_t *)arg + pos, seglen), seglen, - &concat_chksum, &concat_chksum_swapped); - concat_chksummed += seglen; -#endif /* TCP_CHECKSUM_ON_COPY */ - } - - pos += seglen; - } -#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ - } else { -#if TCP_OVERSIZE - LWIP_ASSERT("unsent_oversize mismatch (pcb->unsent is NULL)", - pcb->unsent_oversize == 0); -#endif /* TCP_OVERSIZE */ - } - - /* - * Phase 3: Create new segments. - * - * The new segments are chained together in the local 'queue' - * variable, ready to be appended to pcb->unsent. - */ - while (pos < len) { - struct pbuf *p; - u16_t left = len - pos; - u16_t max_len = mss_local - optlen; - u16_t seglen = LWIP_MIN(left, max_len); -#if TCP_CHECKSUM_ON_COPY - u16_t chksum = 0; - u8_t chksum_swapped = 0; -#endif /* TCP_CHECKSUM_ON_COPY */ - - if (apiflags & TCP_WRITE_FLAG_COPY) { - /* If copy is set, memory should be allocated and data copied - * into pbuf */ - if ((p = tcp_pbuf_prealloc(PBUF_TRANSPORT, seglen + optlen, mss_local, &oversize, pcb, apiflags, queue == NULL)) == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n", seglen)); - goto memerr; - } - LWIP_ASSERT("tcp_write: check that first pbuf can hold the complete seglen", - (p->len >= seglen)); - TCP_DATA_COPY2((char *)p->payload + optlen, (const u8_t *)arg + pos, seglen, &chksum, &chksum_swapped); - } else { - /* Copy is not set: First allocate a pbuf for holding the data. - * Since the referenced data is available at least until it is - * sent out on the link (as it has to be ACKed by the remote - * party) we can safely use PBUF_ROM instead of PBUF_REF here. - */ - struct pbuf *p2; -#if TCP_OVERSIZE - LWIP_ASSERT("oversize == 0", oversize == 0); -#endif /* TCP_OVERSIZE */ - if ((p2 = pbuf_alloc(PBUF_TRANSPORT, seglen, PBUF_ROM)) == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write: could not allocate memory for zero-copy pbuf\n")); - goto memerr; - } -#if TCP_CHECKSUM_ON_COPY - /* calculate the checksum of nocopy-data */ - chksum = ~inet_chksum((const u8_t *)arg + pos, seglen); - if (seglen & 1) { - chksum_swapped = 1; - chksum = SWAP_BYTES_IN_WORD(chksum); - } -#endif /* TCP_CHECKSUM_ON_COPY */ - /* reference the non-volatile payload data */ - ((struct pbuf_rom *)p2)->payload = (const u8_t *)arg + pos; - - /* Second, allocate a pbuf for the headers. */ - if ((p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) { - /* If allocation fails, we have to deallocate the data pbuf as - * well. */ - pbuf_free(p2); - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write: could not allocate memory for header pbuf\n")); - goto memerr; - } - /* Concatenate the headers and data pbufs together. */ - pbuf_cat(p/*header*/, p2/*data*/); - } - - queuelen += pbuf_clen(p); - - /* Now that there are more segments queued, we check again if the - * length of the queue exceeds the configured maximum or - * overflows. */ - if (queuelen > LWIP_MIN(TCP_SND_QUEUELEN, TCP_SNDQUEUELEN_OVERFLOW)) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write: queue too long %"U16_F" (%d)\n", - queuelen, (int)TCP_SND_QUEUELEN)); - pbuf_free(p); - goto memerr; - } - - if ((seg = tcp_create_segment(pcb, p, 0, pcb->snd_lbb + pos, optflags)) == NULL) { - goto memerr; - } -#if TCP_OVERSIZE_DBGCHECK - seg->oversize_left = oversize; -#endif /* TCP_OVERSIZE_DBGCHECK */ -#if TCP_CHECKSUM_ON_COPY - seg->chksum = chksum; - seg->chksum_swapped = chksum_swapped; - seg->flags |= TF_SEG_DATA_CHECKSUMMED; -#endif /* TCP_CHECKSUM_ON_COPY */ - - /* first segment of to-be-queued data? */ - if (queue == NULL) { - queue = seg; - } else { - /* Attach the segment to the end of the queued segments */ - LWIP_ASSERT("prev_seg != NULL", prev_seg != NULL); - prev_seg->next = seg; - } - /* remember last segment of to-be-queued data for next iteration */ - prev_seg = seg; - - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, ("tcp_write: queueing %"U32_F":%"U32_F"\n", - lwip_ntohl(seg->tcphdr->seqno), - lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg))); - - pos += seglen; - } - - /* - * All three segmentation phases were successful. We can commit the - * transaction. - */ -#if TCP_OVERSIZE_DBGCHECK - if ((last_unsent != NULL) && (oversize_add != 0)) { - last_unsent->oversize_left += oversize_add; - } -#endif /* TCP_OVERSIZE_DBGCHECK */ - - /* - * Phase 1: If data has been added to the preallocated tail of - * last_unsent, we update the length fields of the pbuf chain. - */ -#if TCP_OVERSIZE - if (oversize_used > 0) { - struct pbuf *p; - /* Bump tot_len of whole chain, len of tail */ - for (p = last_unsent->p; p; p = p->next) { - p->tot_len += oversize_used; - if (p->next == NULL) { - TCP_DATA_COPY((char *)p->payload + p->len, arg, oversize_used, last_unsent); - p->len += oversize_used; - } - } - last_unsent->len += oversize_used; -#if TCP_OVERSIZE_DBGCHECK - LWIP_ASSERT("last_unsent->oversize_left >= oversize_used", - last_unsent->oversize_left >= oversize_used); - last_unsent->oversize_left -= oversize_used; -#endif /* TCP_OVERSIZE_DBGCHECK */ - } - pcb->unsent_oversize = oversize; -#endif /* TCP_OVERSIZE */ - - /* - * Phase 2: concat_p can be concatenated onto last_unsent->p, unless we - * determined that the last ROM pbuf can be extended to include the new data. - */ - if (concat_p != NULL) { - LWIP_ASSERT("tcp_write: cannot concatenate when pcb->unsent is empty", - (last_unsent != NULL)); - pbuf_cat(last_unsent->p, concat_p); - last_unsent->len += concat_p->tot_len; - } else if (extendlen > 0) { - struct pbuf *p; - LWIP_ASSERT("tcp_write: extension of reference requires reference", - last_unsent != NULL && last_unsent->p != NULL); - for (p = last_unsent->p; p->next != NULL; p = p->next) { - p->tot_len += extendlen; - } - p->tot_len += extendlen; - p->len += extendlen; - last_unsent->len += extendlen; - } - -#if TCP_CHECKSUM_ON_COPY - if (concat_chksummed) { - LWIP_ASSERT("tcp_write: concat checksum needs concatenated data", - concat_p != NULL || extendlen > 0); - /*if concat checksumm swapped - swap it back */ - if (concat_chksum_swapped) { - concat_chksum = SWAP_BYTES_IN_WORD(concat_chksum); - } - tcp_seg_add_chksum(concat_chksum, concat_chksummed, &last_unsent->chksum, - &last_unsent->chksum_swapped); - last_unsent->flags |= TF_SEG_DATA_CHECKSUMMED; - } -#endif /* TCP_CHECKSUM_ON_COPY */ - - /* - * Phase 3: Append queue to pcb->unsent. Queue may be NULL, but that - * is harmless - */ - if (last_unsent == NULL) { - pcb->unsent = queue; - } else { - last_unsent->next = queue; - } - - /* - * Finally update the pcb state. - */ - pcb->snd_lbb += len; - pcb->snd_buf -= len; - pcb->snd_queuelen = queuelen; - - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: %"S16_F" (after enqueued)\n", - pcb->snd_queuelen)); - if (pcb->snd_queuelen != 0) { - LWIP_ASSERT("tcp_write: valid queue length", - pcb->unacked != NULL || pcb->unsent != NULL); - } - - /* Set the PSH flag in the last segment that we enqueued. */ - if (seg != NULL && seg->tcphdr != NULL && ((apiflags & TCP_WRITE_FLAG_MORE) == 0)) { - TCPH_SET_FLAG(seg->tcphdr, TCP_PSH); - } - - return ERR_OK; -memerr: - tcp_set_flags(pcb, TF_NAGLEMEMERR); - TCP_STATS_INC(tcp.memerr); - - if (concat_p != NULL) { - pbuf_free(concat_p); - } - if (queue != NULL) { - tcp_segs_free(queue); - } - if (pcb->snd_queuelen != 0) { - LWIP_ASSERT("tcp_write: valid queue length", pcb->unacked != NULL || - pcb->unsent != NULL); - } - LWIP_DEBUGF(TCP_QLEN_DEBUG | LWIP_DBG_STATE, ("tcp_write: %"S16_F" (with mem err)\n", pcb->snd_queuelen)); - return ERR_MEM; -} - -/** - * Split segment on the head of the unsent queue. If return is not - * ERR_OK, existing head remains intact - * - * The split is accomplished by creating a new TCP segment and pbuf - * which holds the remainder payload after the split. The original - * pbuf is trimmed to new length. This allows splitting of read-only - * pbufs - * - * @param pcb the tcp_pcb for which to split the unsent head - * @param split the amount of payload to remain in the head - */ -err_t -tcp_split_unsent_seg(struct tcp_pcb *pcb, u16_t split) -{ - struct tcp_seg *seg = NULL, *useg = NULL; - struct pbuf *p = NULL; - u8_t optlen; - u8_t optflags; - u8_t split_flags; - u8_t remainder_flags; - u16_t remainder; - u16_t offset; -#if TCP_CHECKSUM_ON_COPY - u16_t chksum = 0; - u8_t chksum_swapped = 0; - struct pbuf *q; -#endif /* TCP_CHECKSUM_ON_COPY */ - - LWIP_ASSERT("tcp_split_unsent_seg: invalid pcb", pcb != NULL); - - useg = pcb->unsent; - if (useg == NULL) { - return ERR_MEM; - } - - if (split == 0) { - LWIP_ASSERT("Can't split segment into length 0", 0); - return ERR_VAL; - } - - if (useg->len <= split) { - return ERR_OK; - } - - LWIP_ASSERT("split <= mss", split <= pcb->mss); - LWIP_ASSERT("useg->len > 0", useg->len > 0); - - /* We should check that we don't exceed TCP_SND_QUEUELEN but we need - * to split this packet so we may actually exceed the max value by - * one! - */ - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue: split_unsent_seg: %u\n", (unsigned int)pcb->snd_queuelen)); - - optflags = useg->flags; -#if TCP_CHECKSUM_ON_COPY - /* Remove since checksum is not stored until after tcp_create_segment() */ - optflags &= ~TF_SEG_DATA_CHECKSUMMED; -#endif /* TCP_CHECKSUM_ON_COPY */ - optlen = LWIP_TCP_OPT_LENGTH(optflags); - remainder = useg->len - split; - - /* Create new pbuf for the remainder of the split */ - p = pbuf_alloc(PBUF_TRANSPORT, remainder + optlen, PBUF_RAM); - if (p == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("tcp_split_unsent_seg: could not allocate memory for pbuf remainder %u\n", remainder)); - goto memerr; - } - - /* Offset into the original pbuf is past TCP/IP headers, options, and split amount */ - offset = useg->p->tot_len - useg->len + split; - /* Copy remainder into new pbuf, headers and options will not be filled out */ - if (pbuf_copy_partial(useg->p, (u8_t *)p->payload + optlen, remainder, offset ) != remainder) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("tcp_split_unsent_seg: could not copy pbuf remainder %u\n", remainder)); - goto memerr; - } -#if TCP_CHECKSUM_ON_COPY - /* calculate the checksum on remainder data */ - tcp_seg_add_chksum(~inet_chksum((const u8_t *)p->payload + optlen, remainder), remainder, - &chksum, &chksum_swapped); -#endif /* TCP_CHECKSUM_ON_COPY */ - - /* Options are created when calling tcp_output() */ - - /* Migrate flags from original segment */ - split_flags = TCPH_FLAGS(useg->tcphdr); - remainder_flags = 0; /* ACK added in tcp_output() */ - - if (split_flags & TCP_PSH) { - split_flags &= ~TCP_PSH; - remainder_flags |= TCP_PSH; - } - if (split_flags & TCP_FIN) { - split_flags &= ~TCP_FIN; - remainder_flags |= TCP_FIN; - } - /* SYN should be left on split, RST should not be present with data */ - - seg = tcp_create_segment(pcb, p, remainder_flags, lwip_ntohl(useg->tcphdr->seqno) + split, optflags); - if (seg == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("tcp_split_unsent_seg: could not create new TCP segment\n")); - goto memerr; - } - -#if TCP_CHECKSUM_ON_COPY - seg->chksum = chksum; - seg->chksum_swapped = chksum_swapped; - seg->flags |= TF_SEG_DATA_CHECKSUMMED; -#endif /* TCP_CHECKSUM_ON_COPY */ - - /* Remove this segment from the queue since trimming it may free pbufs */ - pcb->snd_queuelen -= pbuf_clen(useg->p); - - /* Trim the original pbuf into our split size. At this point our remainder segment must be setup - successfully because we are modifying the original segment */ - pbuf_realloc(useg->p, useg->p->tot_len - remainder); - useg->len -= remainder; - TCPH_SET_FLAG(useg->tcphdr, split_flags); -#if TCP_OVERSIZE_DBGCHECK - /* By trimming, realloc may have actually shrunk the pbuf, so clear oversize_left */ - useg->oversize_left = 0; -#endif /* TCP_OVERSIZE_DBGCHECK */ - - /* Add back to the queue with new trimmed pbuf */ - pcb->snd_queuelen += pbuf_clen(useg->p); - -#if TCP_CHECKSUM_ON_COPY - /* The checksum on the split segment is now incorrect. We need to re-run it over the split */ - useg->chksum = 0; - useg->chksum_swapped = 0; - q = useg->p; - offset = q->tot_len - useg->len; /* Offset due to exposed headers */ - - /* Advance to the pbuf where the offset ends */ - while (q != NULL && offset > q->len) { - offset -= q->len; - q = q->next; - } - LWIP_ASSERT("Found start of payload pbuf", q != NULL); - /* Checksum the first payload pbuf accounting for offset, then other pbufs are all payload */ - for (; q != NULL; offset = 0, q = q->next) { - tcp_seg_add_chksum(~inet_chksum((const u8_t *)q->payload + offset, q->len - offset), q->len - offset, - &useg->chksum, &useg->chksum_swapped); - } -#endif /* TCP_CHECKSUM_ON_COPY */ - - /* Update number of segments on the queues. Note that length now may - * exceed TCP_SND_QUEUELEN! We don't have to touch pcb->snd_buf - * because the total amount of data is constant when packet is split */ - pcb->snd_queuelen += pbuf_clen(seg->p); - - /* Finally insert remainder into queue after split (which stays head) */ - seg->next = useg->next; - useg->next = seg; - -#if TCP_OVERSIZE - /* If remainder is last segment on the unsent, ensure we clear the oversize amount - * because the remainder is always sized to the exact remaining amount */ - if (seg->next == NULL) { - pcb->unsent_oversize = 0; - } -#endif /* TCP_OVERSIZE */ - - return ERR_OK; -memerr: - TCP_STATS_INC(tcp.memerr); - - LWIP_ASSERT("seg == NULL", seg == NULL); - if (p != NULL) { - pbuf_free(p); - } - - return ERR_MEM; -} - -/** - * Called by tcp_close() to send a segment including FIN flag but not data. - * This FIN may be added to an existing segment or a new, otherwise empty - * segment is enqueued. - * - * @param pcb the tcp_pcb over which to send a segment - * @return ERR_OK if sent, another err_t otherwise - */ -err_t -tcp_send_fin(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_send_fin: invalid pcb", pcb != NULL); - - /* first, try to add the fin to the last unsent segment */ - if (pcb->unsent != NULL) { - struct tcp_seg *last_unsent; - for (last_unsent = pcb->unsent; last_unsent->next != NULL; - last_unsent = last_unsent->next); - - if ((TCPH_FLAGS(last_unsent->tcphdr) & (TCP_SYN | TCP_FIN | TCP_RST)) == 0) { - /* no SYN/FIN/RST flag in the header, we can add the FIN flag */ - TCPH_SET_FLAG(last_unsent->tcphdr, TCP_FIN); - tcp_set_flags(pcb, TF_FIN); - return ERR_OK; - } - } - /* no data, no length, flags, copy=1, no optdata */ - return tcp_enqueue_flags(pcb, TCP_FIN); -} - -/** - * Enqueue SYN or FIN for transmission. - * - * Called by @ref tcp_connect, tcp_listen_input, and @ref tcp_close - * (via @ref tcp_send_fin) - * - * @param pcb Protocol control block for the TCP connection. - * @param flags TCP header flags to set in the outgoing segment. - */ -err_t -tcp_enqueue_flags(struct tcp_pcb *pcb, u8_t flags) -{ - struct pbuf *p; - struct tcp_seg *seg; - u8_t optflags = 0; - u8_t optlen = 0; - - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: queuelen: %"U16_F"\n", (u16_t)pcb->snd_queuelen)); - - LWIP_ASSERT("tcp_enqueue_flags: need either TCP_SYN or TCP_FIN in flags (programmer violates API)", - (flags & (TCP_SYN | TCP_FIN)) != 0); - LWIP_ASSERT("tcp_enqueue_flags: invalid pcb", pcb != NULL); - - /* No need to check pcb->snd_queuelen if only SYN or FIN are allowed! */ - - /* Get options for this segment. This is a special case since this is the - only place where a SYN can be sent. */ - if (flags & TCP_SYN) { - optflags = TF_SEG_OPTS_MSS; -#if LWIP_WND_SCALE - if ((pcb->state != SYN_RCVD) || (pcb->flags & TF_WND_SCALE)) { - /* In a (sent in state SYN_RCVD), the window scale option may only - be sent if we received a window scale option from the remote host. */ - optflags |= TF_SEG_OPTS_WND_SCALE; - } -#endif /* LWIP_WND_SCALE */ -#if LWIP_TCP_SACK_OUT - if ((pcb->state != SYN_RCVD) || (pcb->flags & TF_SACK)) { - /* In a (sent in state SYN_RCVD), the SACK_PERM option may only - be sent if we received a SACK_PERM option from the remote host. */ - optflags |= TF_SEG_OPTS_SACK_PERM; - } -#endif /* LWIP_TCP_SACK_OUT */ - } -#if LWIP_TCP_TIMESTAMPS - if ((pcb->flags & TF_TIMESTAMP) || ((flags & TCP_SYN) && (pcb->state != SYN_RCVD))) { - /* Make sure the timestamp option is only included in data segments if we - agreed about it with the remote host (and in active open SYN segments). */ - optflags |= TF_SEG_OPTS_TS; - } -#endif /* LWIP_TCP_TIMESTAMPS */ - optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb); - - /* Allocate pbuf with room for TCP header + options */ - if ((p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) { - tcp_set_flags(pcb, TF_NAGLEMEMERR); - TCP_STATS_INC(tcp.memerr); - return ERR_MEM; - } - LWIP_ASSERT("tcp_enqueue_flags: check that first pbuf can hold optlen", - (p->len >= optlen)); - - /* Allocate memory for tcp_seg, and fill in fields. */ - if ((seg = tcp_create_segment(pcb, p, flags, pcb->snd_lbb, optflags)) == NULL) { - tcp_set_flags(pcb, TF_NAGLEMEMERR); - TCP_STATS_INC(tcp.memerr); - return ERR_MEM; - } - LWIP_ASSERT("seg->tcphdr not aligned", ((mem_ptr_t)seg->tcphdr % LWIP_MIN(MEM_ALIGNMENT, 4)) == 0); - LWIP_ASSERT("tcp_enqueue_flags: invalid segment length", seg->len == 0); - - LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, - ("tcp_enqueue_flags: queueing %"U32_F":%"U32_F" (0x%"X16_F")\n", - lwip_ntohl(seg->tcphdr->seqno), - lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg), - (u16_t)flags)); - - /* Now append seg to pcb->unsent queue */ - if (pcb->unsent == NULL) { - pcb->unsent = seg; - } else { - struct tcp_seg *useg; - for (useg = pcb->unsent; useg->next != NULL; useg = useg->next); - useg->next = seg; - } -#if TCP_OVERSIZE - /* The new unsent tail has no space */ - pcb->unsent_oversize = 0; -#endif /* TCP_OVERSIZE */ - - /* SYN and FIN bump the sequence number */ - if ((flags & TCP_SYN) || (flags & TCP_FIN)) { - pcb->snd_lbb++; - /* optlen does not influence snd_buf */ - } - if (flags & TCP_FIN) { - tcp_set_flags(pcb, TF_FIN); - } - - /* update number of segments on the queues */ - pcb->snd_queuelen += pbuf_clen(seg->p); - LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: %"S16_F" (after enqueued)\n", pcb->snd_queuelen)); - if (pcb->snd_queuelen != 0) { - LWIP_ASSERT("tcp_enqueue_flags: invalid queue length", - pcb->unacked != NULL || pcb->unsent != NULL); - } - - return ERR_OK; -} - -#if LWIP_TCP_TIMESTAMPS -/* Build a timestamp option (12 bytes long) at the specified options pointer) - * - * @param pcb tcp_pcb - * @param opts option pointer where to store the timestamp option - */ -static void -tcp_build_timestamp_option(const struct tcp_pcb *pcb, u32_t *opts) -{ - LWIP_ASSERT("tcp_build_timestamp_option: invalid pcb", pcb != NULL); - - /* Pad with two NOP options to make everything nicely aligned */ - opts[0] = PP_HTONL(0x0101080A); - opts[1] = lwip_htonl(sys_now()); - opts[2] = lwip_htonl(pcb->ts_recent); -} -#endif - -#if LWIP_TCP_SACK_OUT -/** - * Calculates the number of SACK entries that should be generated. - * It takes into account whether TF_SACK flag is set, - * the number of SACK entries in tcp_pcb that are valid, - * as well as the available options size. - * - * @param pcb tcp_pcb - * @param optlen the length of other TCP options (in bytes) - * @return the number of SACK ranges that can be used - */ -static u8_t -tcp_get_num_sacks(const struct tcp_pcb *pcb, u8_t optlen) -{ - u8_t num_sacks = 0; - - LWIP_ASSERT("tcp_get_num_sacks: invalid pcb", pcb != NULL); - - if (pcb->flags & TF_SACK) { - u8_t i; - - /* The first SACK takes up 12 bytes (it includes SACK header and two NOP options), - each additional one - 8 bytes. */ - optlen += 12; - - /* Max options size = 40, number of SACK array entries = LWIP_TCP_MAX_SACK_NUM */ - for (i = 0; (i < LWIP_TCP_MAX_SACK_NUM) && (optlen <= TCP_MAX_OPTION_BYTES) && - LWIP_TCP_SACK_VALID(pcb, i); ++i) { - ++num_sacks; - optlen += 8; - } - } - - return num_sacks; -} - -/** Build a SACK option (12 or more bytes long) at the specified options pointer) - * - * @param pcb tcp_pcb - * @param opts option pointer where to store the SACK option - * @param num_sacks the number of SACKs to store - */ -static void -tcp_build_sack_option(const struct tcp_pcb *pcb, u32_t *opts, u8_t num_sacks) -{ - u8_t i; - - LWIP_ASSERT("tcp_build_sack_option: invalid pcb", pcb != NULL); - LWIP_ASSERT("tcp_build_sack_option: invalid opts", opts != NULL); - - /* Pad with two NOP options to make everything nicely aligned. - We add the length (of just the SACK option, not the NOPs in front of it), - which is 2B of header, plus 8B for each SACK. */ - *(opts++) = PP_HTONL(0x01010500 + 2 + num_sacks * 8); - - for (i = 0; i < num_sacks; ++i) { - *(opts++) = lwip_htonl(pcb->rcv_sacks[i].left); - *(opts++) = lwip_htonl(pcb->rcv_sacks[i].right); - } -} - -#endif - -#if LWIP_WND_SCALE -/** Build a window scale option (3 bytes long) at the specified options pointer) - * - * @param opts option pointer where to store the window scale option - */ -static void -tcp_build_wnd_scale_option(u32_t *opts) -{ - LWIP_ASSERT("tcp_build_wnd_scale_option: invalid opts", opts != NULL); - - /* Pad with one NOP option to make everything nicely aligned */ - opts[0] = PP_HTONL(0x01030300 | TCP_RCV_SCALE); -} -#endif - -/** - * @ingroup tcp_raw - * Find out what we can send and send it - * - * @param pcb Protocol control block for the TCP connection to send data - * @return ERR_OK if data has been sent or nothing to send - * another err_t on error - */ -err_t -tcp_output(struct tcp_pcb *pcb) -{ - struct tcp_seg *seg, *useg; - u32_t wnd, snd_nxt; - err_t err; - struct netif *netif; -#if TCP_CWND_DEBUG - s16_t i = 0; -#endif /* TCP_CWND_DEBUG */ - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("tcp_output: invalid pcb", pcb != NULL); - /* pcb->state LISTEN not allowed here */ - LWIP_ASSERT("don't call tcp_output for listen-pcbs", - pcb->state != LISTEN); - - /* First, check if we are invoked by the TCP input processing - code. If so, we do not output anything. Instead, we rely on the - input processing code to call us when input processing is done - with. */ - if (tcp_input_pcb == pcb) { - return ERR_OK; - } - - wnd = LWIP_MIN(pcb->snd_wnd, pcb->cwnd); - - seg = pcb->unsent; - - if (seg == NULL) { - LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: nothing to send (%p)\n", - (void *)pcb->unsent)); - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"TCPWNDSIZE_F - ", cwnd %"TCPWNDSIZE_F", wnd %"U32_F - ", seg == NULL, ack %"U32_F"\n", - pcb->snd_wnd, pcb->cwnd, wnd, pcb->lastack)); - - /* If the TF_ACK_NOW flag is set and the ->unsent queue is empty, construct - * an empty ACK segment and send it. */ - if (pcb->flags & TF_ACK_NOW) { - return tcp_send_empty_ack(pcb); - } - /* nothing to send: shortcut out of here */ - goto output_done; - } else { - LWIP_DEBUGF(TCP_CWND_DEBUG, - ("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F - ", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n", - pcb->snd_wnd, pcb->cwnd, wnd, - lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len, - lwip_ntohl(seg->tcphdr->seqno), pcb->lastack)); - } - - netif = tcp_route(pcb, &pcb->local_ip, &pcb->remote_ip); - if (netif == NULL) { - return ERR_RTE; - } - - /* If we don't have a local IP address, we get one from netif */ - if (ip_addr_isany(&pcb->local_ip)) { - const ip_addr_t *local_ip = ip_netif_get_local_ip(netif, &pcb->remote_ip); - if (local_ip == NULL) { - return ERR_RTE; - } - ip_addr_copy(pcb->local_ip, *local_ip); - } - - /* Handle the current segment not fitting within the window */ - if (lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd) { - /* We need to start the persistent timer when the next unsent segment does not fit - * within the remaining (could be 0) send window and RTO timer is not running (we - * have no in-flight data). If window is still too small after persist timer fires, - * then we split the segment. We don't consider the congestion window since a cwnd - * smaller than 1 SMSS implies in-flight data - */ - if (wnd == pcb->snd_wnd && pcb->unacked == NULL && pcb->persist_backoff == 0) { - pcb->persist_cnt = 0; - pcb->persist_backoff = 1; - pcb->persist_probe = 0; - } - /* We need an ACK, but can't send data now, so send an empty ACK */ - if (pcb->flags & TF_ACK_NOW) { - return tcp_send_empty_ack(pcb); - } - goto output_done; - } - /* Stop persist timer, above conditions are not active */ - pcb->persist_backoff = 0; - - /* useg should point to last segment on unacked queue */ - useg = pcb->unacked; - if (useg != NULL) { - for (; useg->next != NULL; useg = useg->next); - } - /* data available and window allows it to be sent? */ - while (seg != NULL && - lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) { - LWIP_ASSERT("RST not expected here!", - (TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0); - /* Stop sending if the nagle algorithm would prevent it - * Don't stop: - * - if tcp_write had a memory error before (prevent delayed ACK timeout) or - * - if FIN was already enqueued for this PCB (SYN is always alone in a segment - - * either seg->next != NULL or pcb->unacked == NULL; - * RST is no sent using tcp_write/tcp_output. - */ - if ((tcp_do_output_nagle(pcb) == 0) && - ((pcb->flags & (TF_NAGLEMEMERR | TF_FIN)) == 0)) { - break; - } -#if TCP_CWND_DEBUG - LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F", effwnd %"U32_F", seq %"U32_F", ack %"U32_F", i %"S16_F"\n", - pcb->snd_wnd, pcb->cwnd, wnd, - lwip_ntohl(seg->tcphdr->seqno) + seg->len - - pcb->lastack, - lwip_ntohl(seg->tcphdr->seqno), pcb->lastack, i)); - ++i; -#endif /* TCP_CWND_DEBUG */ - - if (pcb->state != SYN_SENT) { - TCPH_SET_FLAG(seg->tcphdr, TCP_ACK); - } - - err = tcp_output_segment(seg, pcb, netif); - if (err != ERR_OK) { - /* segment could not be sent, for whatever reason */ - tcp_set_flags(pcb, TF_NAGLEMEMERR); - return err; - } -#if TCP_OVERSIZE_DBGCHECK - seg->oversize_left = 0; -#endif /* TCP_OVERSIZE_DBGCHECK */ - pcb->unsent = seg->next; - if (pcb->state != SYN_SENT) { - tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); - } - snd_nxt = lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg); - if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) { - pcb->snd_nxt = snd_nxt; - } - /* put segment on unacknowledged list if length > 0 */ - if (TCP_TCPLEN(seg) > 0) { - seg->next = NULL; - /* unacked list is empty? */ - if (pcb->unacked == NULL) { - pcb->unacked = seg; - useg = seg; - /* unacked list is not empty? */ - } else { - /* In the case of fast retransmit, the packet should not go to the tail - * of the unacked queue, but rather somewhere before it. We need to check for - * this case. -STJ Jul 27, 2004 */ - if (TCP_SEQ_LT(lwip_ntohl(seg->tcphdr->seqno), lwip_ntohl(useg->tcphdr->seqno))) { - /* add segment to before tail of unacked list, keeping the list sorted */ - struct tcp_seg **cur_seg = &(pcb->unacked); - while (*cur_seg && - TCP_SEQ_LT(lwip_ntohl((*cur_seg)->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno))) { - cur_seg = &((*cur_seg)->next ); - } - seg->next = (*cur_seg); - (*cur_seg) = seg; - } else { - /* add segment to tail of unacked list */ - useg->next = seg; - useg = useg->next; - } - } - /* do not queue empty segments on the unacked list */ - } else { - tcp_seg_free(seg); - } - seg = pcb->unsent; - } -#if TCP_OVERSIZE - if (pcb->unsent == NULL) { - /* last unsent has been removed, reset unsent_oversize */ - pcb->unsent_oversize = 0; - } -#endif /* TCP_OVERSIZE */ - -output_done: - tcp_clear_flags(pcb, TF_NAGLEMEMERR); - return ERR_OK; -} - -/** Check if a segment's pbufs are used by someone else than TCP. - * This can happen on retransmission if the pbuf of this segment is still - * referenced by the netif driver due to deferred transmission. - * This is the case (only!) if someone down the TX call path called - * pbuf_ref() on one of the pbufs! - * - * @arg seg the tcp segment to check - * @return 1 if ref != 1, 0 if ref == 1 - */ -static int -tcp_output_segment_busy(const struct tcp_seg *seg) -{ - LWIP_ASSERT("tcp_output_segment_busy: invalid seg", seg != NULL); - - /* We only need to check the first pbuf here: - If a pbuf is queued for transmission, a driver calls pbuf_ref(), - which only changes the ref count of the first pbuf */ - if (seg->p->ref != 1) { - /* other reference found */ - return 1; - } - /* no other references found */ - return 0; -} - -/** - * Called by tcp_output() to actually send a TCP segment over IP. - * - * @param seg the tcp_seg to send - * @param pcb the tcp_pcb for the TCP connection used to send the segment - * @param netif the netif used to send the segment - */ -static err_t -tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb, struct netif *netif) -{ - err_t err; - u16_t len; - u32_t *opts; -#if TCP_CHECKSUM_ON_COPY - int seg_chksum_was_swapped = 0; -#endif - - LWIP_ASSERT("tcp_output_segment: invalid seg", seg != NULL); - LWIP_ASSERT("tcp_output_segment: invalid pcb", pcb != NULL); - LWIP_ASSERT("tcp_output_segment: invalid netif", netif != NULL); - - if (tcp_output_segment_busy(seg)) { - /* This should not happen: rexmit functions should have checked this. - However, since this function modifies p->len, we must not continue in this case. */ - LWIP_DEBUGF(TCP_RTO_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_output_segment: segment busy\n")); - return ERR_OK; - } - - /* The TCP header has already been constructed, but the ackno and - wnd fields remain. */ - seg->tcphdr->ackno = lwip_htonl(pcb->rcv_nxt); - - /* advertise our receive window size in this TCP segment */ -#if LWIP_WND_SCALE - if (seg->flags & TF_SEG_OPTS_WND_SCALE) { - /* The Window field in a SYN segment itself (the only type where we send - the window scale option) is never scaled. */ - seg->tcphdr->wnd = lwip_htons(TCPWND_MIN16(pcb->rcv_ann_wnd)); - } else -#endif /* LWIP_WND_SCALE */ - { - seg->tcphdr->wnd = lwip_htons(TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd))); - } - - pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd; - - /* Add any requested options. NB MSS option is only set on SYN - packets, so ignore it here */ - /* cast through void* to get rid of alignment warnings */ - opts = (u32_t *)(void *)(seg->tcphdr + 1); - if (seg->flags & TF_SEG_OPTS_MSS) { - u16_t mss; -#if TCP_CALCULATE_EFF_SEND_MSS - mss = tcp_eff_send_mss_netif(TCP_MSS, netif, &pcb->remote_ip); -#else /* TCP_CALCULATE_EFF_SEND_MSS */ - mss = TCP_MSS; -#endif /* TCP_CALCULATE_EFF_SEND_MSS */ - *opts = TCP_BUILD_MSS_OPTION(mss); - opts += 1; - } -#if LWIP_TCP_TIMESTAMPS - pcb->ts_lastacksent = pcb->rcv_nxt; - - if (seg->flags & TF_SEG_OPTS_TS) { - tcp_build_timestamp_option(pcb, opts); - opts += 3; - } -#endif -#if LWIP_WND_SCALE - if (seg->flags & TF_SEG_OPTS_WND_SCALE) { - tcp_build_wnd_scale_option(opts); - opts += 1; - } -#endif -#if LWIP_TCP_SACK_OUT - if (seg->flags & TF_SEG_OPTS_SACK_PERM) { - /* Pad with two NOP options to make everything nicely aligned - * NOTE: When we send both timestamp and SACK_PERM options, - * we could use the first two NOPs before the timestamp to store SACK_PERM option, - * but that would complicate the code. - */ - *(opts++) = PP_HTONL(0x01010402); - } -#endif - - /* Set retransmission timer running if it is not currently enabled - This must be set before checking the route. */ - if (pcb->rtime < 0) { - pcb->rtime = 0; - } - - if (pcb->rttest == 0) { - pcb->rttest = tcp_ticks; - pcb->rtseq = lwip_ntohl(seg->tcphdr->seqno); - - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_output_segment: rtseq %"U32_F"\n", pcb->rtseq)); - } - LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output_segment: %"U32_F":%"U32_F"\n", - lwip_htonl(seg->tcphdr->seqno), lwip_htonl(seg->tcphdr->seqno) + - seg->len)); - - len = (u16_t)((u8_t *)seg->tcphdr - (u8_t *)seg->p->payload); - if (len == 0) { - /** Exclude retransmitted segments from this count. */ - MIB2_STATS_INC(mib2.tcpoutsegs); - } - - seg->p->len -= len; - seg->p->tot_len -= len; - - seg->p->payload = seg->tcphdr; - - seg->tcphdr->chksum = 0; - -#ifdef LWIP_HOOK_TCP_OUT_ADD_TCPOPTS - opts = LWIP_HOOK_TCP_OUT_ADD_TCPOPTS(seg->p, seg->tcphdr, pcb, opts); -#endif - LWIP_ASSERT("options not filled", (u8_t *)opts == ((u8_t *)(seg->tcphdr + 1)) + LWIP_TCP_OPT_LENGTH_SEGMENT(seg->flags, pcb)); - -#if CHECKSUM_GEN_TCP - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_TCP) { -#if TCP_CHECKSUM_ON_COPY - u32_t acc; -#if TCP_CHECKSUM_ON_COPY_SANITY_CHECK - u16_t chksum_slow = ip_chksum_pseudo(seg->p, IP_PROTO_TCP, - seg->p->tot_len, &pcb->local_ip, &pcb->remote_ip); -#endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */ - if ((seg->flags & TF_SEG_DATA_CHECKSUMMED) == 0) { - LWIP_ASSERT("data included but not checksummed", - seg->p->tot_len == TCPH_HDRLEN_BYTES(seg->tcphdr)); - } - - /* rebuild TCP header checksum (TCP header changes for retransmissions!) */ - acc = ip_chksum_pseudo_partial(seg->p, IP_PROTO_TCP, - seg->p->tot_len, TCPH_HDRLEN_BYTES(seg->tcphdr), &pcb->local_ip, &pcb->remote_ip); - /* add payload checksum */ - if (seg->chksum_swapped) { - seg_chksum_was_swapped = 1; - seg->chksum = SWAP_BYTES_IN_WORD(seg->chksum); - seg->chksum_swapped = 0; - } - acc = (u16_t)~acc + seg->chksum; - seg->tcphdr->chksum = (u16_t)~FOLD_U32T(acc); -#if TCP_CHECKSUM_ON_COPY_SANITY_CHECK - if (chksum_slow != seg->tcphdr->chksum) { - TCP_CHECKSUM_ON_COPY_SANITY_CHECK_FAIL( - ("tcp_output_segment: calculated checksum is %"X16_F" instead of %"X16_F"\n", - seg->tcphdr->chksum, chksum_slow)); - seg->tcphdr->chksum = chksum_slow; - } -#endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */ -#else /* TCP_CHECKSUM_ON_COPY */ - seg->tcphdr->chksum = ip_chksum_pseudo(seg->p, IP_PROTO_TCP, - seg->p->tot_len, &pcb->local_ip, &pcb->remote_ip); -#endif /* TCP_CHECKSUM_ON_COPY */ - } -#endif /* CHECKSUM_GEN_TCP */ - TCP_STATS_INC(tcp.xmit); - - NETIF_SET_HINTS(netif, &(pcb->netif_hints)); - err = ip_output_if(seg->p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, - pcb->tos, IP_PROTO_TCP, netif); - NETIF_RESET_HINTS(netif); - -#if TCP_CHECKSUM_ON_COPY - if (seg_chksum_was_swapped) { - /* if data is added to this segment later, chksum needs to be swapped, - so restore this now */ - seg->chksum = SWAP_BYTES_IN_WORD(seg->chksum); - seg->chksum_swapped = 1; - } -#endif - - return err; -} - -/** - * Requeue all unacked segments for retransmission - * - * Called by tcp_slowtmr() for slow retransmission. - * - * @param pcb the tcp_pcb for which to re-enqueue all unacked segments - */ -err_t -tcp_rexmit_rto_prepare(struct tcp_pcb *pcb) -{ - struct tcp_seg *seg; - - LWIP_ASSERT("tcp_rexmit_rto_prepare: invalid pcb", pcb != NULL); - - if (pcb->unacked == NULL) { - return ERR_VAL; - } - - /* Move all unacked segments to the head of the unsent queue. - However, give up if any of the unsent pbufs are still referenced by the - netif driver due to deferred transmission. No point loading the link further - if it is struggling to flush its buffered writes. */ - for (seg = pcb->unacked; seg->next != NULL; seg = seg->next) { - if (tcp_output_segment_busy(seg)) { - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_rexmit_rto: segment busy\n")); - return ERR_VAL; - } - } - if (tcp_output_segment_busy(seg)) { - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_rexmit_rto: segment busy\n")); - return ERR_VAL; - } - /* concatenate unsent queue after unacked queue */ - seg->next = pcb->unsent; -#if TCP_OVERSIZE_DBGCHECK - /* if last unsent changed, we need to update unsent_oversize */ - if (pcb->unsent == NULL) { - pcb->unsent_oversize = seg->oversize_left; - } -#endif /* TCP_OVERSIZE_DBGCHECK */ - /* unsent queue is the concatenated queue (of unacked, unsent) */ - pcb->unsent = pcb->unacked; - /* unacked queue is now empty */ - pcb->unacked = NULL; - - /* Mark RTO in-progress */ - tcp_set_flags(pcb, TF_RTO); - /* Record the next byte following retransmit */ - pcb->rto_end = lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg); - /* Don't take any RTT measurements after retransmitting. */ - pcb->rttest = 0; - - return ERR_OK; -} - -/** - * Requeue all unacked segments for retransmission - * - * Called by tcp_slowtmr() for slow retransmission. - * - * @param pcb the tcp_pcb for which to re-enqueue all unacked segments - */ -void -tcp_rexmit_rto_commit(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_rexmit_rto_commit: invalid pcb", pcb != NULL); - - /* increment number of retransmissions */ - if (pcb->nrtx < 0xFF) { - ++pcb->nrtx; - } - /* Do the actual retransmission */ - tcp_output(pcb); -} - -/** - * Requeue all unacked segments for retransmission - * - * Called by tcp_process() only, tcp_slowtmr() needs to do some things between - * "prepare" and "commit". - * - * @param pcb the tcp_pcb for which to re-enqueue all unacked segments - */ -void -tcp_rexmit_rto(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_rexmit_rto: invalid pcb", pcb != NULL); - - if (tcp_rexmit_rto_prepare(pcb) == ERR_OK) { - tcp_rexmit_rto_commit(pcb); - } -} - -/** - * Requeue the first unacked segment for retransmission - * - * Called by tcp_receive() for fast retransmit. - * - * @param pcb the tcp_pcb for which to retransmit the first unacked segment - */ -err_t -tcp_rexmit(struct tcp_pcb *pcb) -{ - struct tcp_seg *seg; - struct tcp_seg **cur_seg; - - LWIP_ASSERT("tcp_rexmit: invalid pcb", pcb != NULL); - - if (pcb->unacked == NULL) { - return ERR_VAL; - } - - seg = pcb->unacked; - - /* Give up if the segment is still referenced by the netif driver - due to deferred transmission. */ - if (tcp_output_segment_busy(seg)) { - LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_rexmit busy\n")); - return ERR_VAL; - } - - /* Move the first unacked segment to the unsent queue */ - /* Keep the unsent queue sorted. */ - pcb->unacked = seg->next; - - cur_seg = &(pcb->unsent); - while (*cur_seg && - TCP_SEQ_LT(lwip_ntohl((*cur_seg)->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno))) { - cur_seg = &((*cur_seg)->next ); - } - seg->next = *cur_seg; - *cur_seg = seg; -#if TCP_OVERSIZE - if (seg->next == NULL) { - /* the retransmitted segment is last in unsent, so reset unsent_oversize */ - pcb->unsent_oversize = 0; - } -#endif /* TCP_OVERSIZE */ - - if (pcb->nrtx < 0xFF) { - ++pcb->nrtx; - } - - /* Don't take any rtt measurements after retransmitting. */ - pcb->rttest = 0; - - /* Do the actual retransmission. */ - MIB2_STATS_INC(mib2.tcpretranssegs); - /* No need to call tcp_output: we are always called from tcp_input() - and thus tcp_output directly returns. */ - return ERR_OK; -} - - -/** - * Handle retransmission after three dupacks received - * - * @param pcb the tcp_pcb for which to retransmit the first unacked segment - */ -void -tcp_rexmit_fast(struct tcp_pcb *pcb) -{ - LWIP_ASSERT("tcp_rexmit_fast: invalid pcb", pcb != NULL); - - if (pcb->unacked != NULL && !(pcb->flags & TF_INFR)) { - /* This is fast retransmit. Retransmit the first unacked segment. */ - LWIP_DEBUGF(TCP_FR_DEBUG, - ("tcp_receive: dupacks %"U16_F" (%"U32_F - "), fast retransmit %"U32_F"\n", - (u16_t)pcb->dupacks, pcb->lastack, - lwip_ntohl(pcb->unacked->tcphdr->seqno))); - if (tcp_rexmit(pcb) == ERR_OK) { - /* Set ssthresh to half of the minimum of the current - * cwnd and the advertised window */ - pcb->ssthresh = LWIP_MIN(pcb->cwnd, pcb->snd_wnd) / 2; - - /* The minimum value for ssthresh should be 2 MSS */ - if (pcb->ssthresh < (2U * pcb->mss)) { - LWIP_DEBUGF(TCP_FR_DEBUG, - ("tcp_receive: The minimum value for ssthresh %"TCPWNDSIZE_F - " should be min 2 mss %"U16_F"...\n", - pcb->ssthresh, (u16_t)(2 * pcb->mss))); - pcb->ssthresh = 2 * pcb->mss; - } - - pcb->cwnd = pcb->ssthresh + 3 * pcb->mss; - tcp_set_flags(pcb, TF_INFR); - - /* Reset the retransmission timer to prevent immediate rto retransmissions */ - pcb->rtime = 0; - } - } -} - -static struct pbuf * -tcp_output_alloc_header_common(u32_t ackno, u16_t optlen, u16_t datalen, - u32_t seqno_be /* already in network byte order */, - u16_t src_port, u16_t dst_port, u8_t flags, u16_t wnd) -{ - struct tcp_hdr *tcphdr; - struct pbuf *p; - - p = pbuf_alloc(PBUF_IP, TCP_HLEN + optlen + datalen, PBUF_RAM); - if (p != NULL) { - LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr", - (p->len >= TCP_HLEN + optlen)); - tcphdr = (struct tcp_hdr *)p->payload; - tcphdr->src = lwip_htons(src_port); - tcphdr->dest = lwip_htons(dst_port); - tcphdr->seqno = seqno_be; - tcphdr->ackno = lwip_htonl(ackno); - TCPH_HDRLEN_FLAGS_SET(tcphdr, (5 + optlen / 4), flags); - tcphdr->wnd = lwip_htons(wnd); - tcphdr->chksum = 0; - tcphdr->urgp = 0; - } - return p; -} - -/** Allocate a pbuf and create a tcphdr at p->payload, used for output - * functions other than the default tcp_output -> tcp_output_segment - * (e.g. tcp_send_empty_ack, etc.) - * - * @param pcb tcp pcb for which to send a packet (used to initialize tcp_hdr) - * @param optlen length of header-options - * @param datalen length of tcp data to reserve in pbuf - * @param seqno_be seqno in network byte order (big-endian) - * @return pbuf with p->payload being the tcp_hdr - */ -static struct pbuf * -tcp_output_alloc_header(struct tcp_pcb *pcb, u16_t optlen, u16_t datalen, - u32_t seqno_be /* already in network byte order */) -{ - struct pbuf *p; - - LWIP_ASSERT("tcp_output_alloc_header: invalid pcb", pcb != NULL); - - p = tcp_output_alloc_header_common(pcb->rcv_nxt, optlen, datalen, - seqno_be, pcb->local_port, pcb->remote_port, TCP_ACK, - TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd))); - if (p != NULL) { - /* If we're sending a packet, update the announced right window edge */ - pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd; - } - return p; -} - -/* Fill in options for control segments */ -static void -tcp_output_fill_options(const struct tcp_pcb *pcb, struct pbuf *p, u8_t optflags, u8_t num_sacks) -{ - struct tcp_hdr *tcphdr; - u32_t *opts; - u16_t sacks_len = 0; - - LWIP_ASSERT("tcp_output_fill_options: invalid pbuf", p != NULL); - - tcphdr = (struct tcp_hdr *)p->payload; - opts = (u32_t *)(void *)(tcphdr + 1); - - /* NB. MSS and window scale options are only sent on SYNs, so ignore them here */ - -#if LWIP_TCP_TIMESTAMPS - if (optflags & TF_SEG_OPTS_TS) { - tcp_build_timestamp_option(pcb, opts); - opts += 3; - } -#endif - -#if LWIP_TCP_SACK_OUT - if (pcb && (num_sacks > 0)) { - tcp_build_sack_option(pcb, opts, num_sacks); - /* 1 word for SACKs header (including 2xNOP), and 2 words for each SACK */ - sacks_len = 1 + num_sacks * 2; - opts += sacks_len; - } -#else - LWIP_UNUSED_ARG(num_sacks); -#endif - -#ifdef LWIP_HOOK_TCP_OUT_ADD_TCPOPTS - opts = LWIP_HOOK_TCP_OUT_ADD_TCPOPTS(p, tcphdr, pcb, opts); -#endif - - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(sacks_len); - LWIP_ASSERT("options not filled", (u8_t *)opts == ((u8_t *)(tcphdr + 1)) + sacks_len * 4 + LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb)); - LWIP_UNUSED_ARG(optflags); /* for LWIP_NOASSERT */ - LWIP_UNUSED_ARG(opts); /* for LWIP_NOASSERT */ -} - -/** Output a control segment pbuf to IP. - * - * Called from tcp_rst, tcp_send_empty_ack, tcp_keepalive and tcp_zero_window_probe, - * this function combines selecting a netif for transmission, generating the tcp - * header checksum and calling ip_output_if while handling netif hints and stats. - */ -static err_t -tcp_output_control_segment(const struct tcp_pcb *pcb, struct pbuf *p, - const ip_addr_t *src, const ip_addr_t *dst) -{ - err_t err; - struct netif *netif; - - LWIP_ASSERT("tcp_output_control_segment: invalid pbuf", p != NULL); - - netif = tcp_route(pcb, src, dst); - if (netif == NULL) { - err = ERR_RTE; - } else { - u8_t ttl, tos; -#if CHECKSUM_GEN_TCP - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_TCP) { - struct tcp_hdr *tcphdr = (struct tcp_hdr *)p->payload; - tcphdr->chksum = ip_chksum_pseudo(p, IP_PROTO_TCP, p->tot_len, - src, dst); - } -#endif - if (pcb != NULL) { - NETIF_SET_HINTS(netif, LWIP_CONST_CAST(struct netif_hint*, &(pcb->netif_hints))); - ttl = pcb->ttl; - tos = pcb->tos; - } else { - /* Send output with hardcoded TTL/HL since we have no access to the pcb */ - ttl = TCP_TTL; - tos = 0; - } - TCP_STATS_INC(tcp.xmit); - err = ip_output_if(p, src, dst, ttl, tos, IP_PROTO_TCP, netif); - NETIF_RESET_HINTS(netif); - } - pbuf_free(p); - return err; -} - -/** - * Send a TCP RESET packet (empty segment with RST flag set) either to - * abort a connection or to show that there is no matching local connection - * for a received segment. - * - * Called by tcp_abort() (to abort a local connection), tcp_input() (if no - * matching local pcb was found), tcp_listen_input() (if incoming segment - * has ACK flag set) and tcp_process() (received segment in the wrong state) - * - * Since a RST segment is in most cases not sent for an active connection, - * tcp_rst() has a number of arguments that are taken from a tcp_pcb for - * most other segment output functions. - * - * @param pcb TCP pcb (may be NULL if no pcb is available) - * @param seqno the sequence number to use for the outgoing segment - * @param ackno the acknowledge number to use for the outgoing segment - * @param local_ip the local IP address to send the segment from - * @param remote_ip the remote IP address to send the segment to - * @param local_port the local TCP port to send the segment from - * @param remote_port the remote TCP port to send the segment to - */ -void -tcp_rst(const struct tcp_pcb *pcb, u32_t seqno, u32_t ackno, - const ip_addr_t *local_ip, const ip_addr_t *remote_ip, - u16_t local_port, u16_t remote_port) -{ - struct pbuf *p; - u16_t wnd; - u8_t optlen; - - LWIP_ASSERT("tcp_rst: invalid local_ip", local_ip != NULL); - LWIP_ASSERT("tcp_rst: invalid remote_ip", remote_ip != NULL); - - optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); - -#if LWIP_WND_SCALE - wnd = PP_HTONS(((TCP_WND >> TCP_RCV_SCALE) & 0xFFFF)); -#else - wnd = PP_HTONS(TCP_WND); -#endif - - p = tcp_output_alloc_header_common(ackno, optlen, 0, lwip_htonl(seqno), local_port, - remote_port, TCP_RST | TCP_ACK, wnd); - if (p == NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_rst: could not allocate memory for pbuf\n")); - return; - } - tcp_output_fill_options(pcb, p, 0, optlen); - - MIB2_STATS_INC(mib2.tcpoutrsts); - - tcp_output_control_segment(pcb, p, local_ip, remote_ip); - LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_rst: seqno %"U32_F" ackno %"U32_F".\n", seqno, ackno)); -} - -/** - * Send an ACK without data. - * - * @param pcb Protocol control block for the TCP connection to send the ACK - */ -err_t -tcp_send_empty_ack(struct tcp_pcb *pcb) -{ - err_t err; - struct pbuf *p; - u8_t optlen, optflags = 0; - u8_t num_sacks = 0; - - LWIP_ASSERT("tcp_send_empty_ack: invalid pcb", pcb != NULL); - -#if LWIP_TCP_TIMESTAMPS - if (pcb->flags & TF_TIMESTAMP) { - optflags = TF_SEG_OPTS_TS; - } -#endif - optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb); - -#if LWIP_TCP_SACK_OUT - /* For now, SACKs are only sent with empty ACKs */ - if ((num_sacks = tcp_get_num_sacks(pcb, optlen)) > 0) { - optlen += 4 + num_sacks * 8; /* 4 bytes for header (including 2*NOP), plus 8B for each SACK */ - } -#endif - - p = tcp_output_alloc_header(pcb, optlen, 0, lwip_htonl(pcb->snd_nxt)); - if (p == NULL) { - /* let tcp_fasttmr retry sending this ACK */ - tcp_set_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); - LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: (ACK) could not allocate pbuf\n")); - return ERR_BUF; - } - tcp_output_fill_options(pcb, p, optflags, num_sacks); - -#if LWIP_TCP_TIMESTAMPS - pcb->ts_lastacksent = pcb->rcv_nxt; -#endif - - LWIP_DEBUGF(TCP_OUTPUT_DEBUG, - ("tcp_output: sending ACK for %"U32_F"\n", pcb->rcv_nxt)); - err = tcp_output_control_segment(pcb, p, &pcb->local_ip, &pcb->remote_ip); - if (err != ERR_OK) { - /* let tcp_fasttmr retry sending this ACK */ - tcp_set_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); - } else { - /* remove ACK flags from the PCB, as we sent an empty ACK now */ - tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); - } - - return err; -} - -/** - * Send keepalive packets to keep a connection active although - * no data is sent over it. - * - * Called by tcp_slowtmr() - * - * @param pcb the tcp_pcb for which to send a keepalive packet - */ -err_t -tcp_keepalive(struct tcp_pcb *pcb) -{ - err_t err; - struct pbuf *p; - u8_t optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); - - LWIP_ASSERT("tcp_keepalive: invalid pcb", pcb != NULL); - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: sending KEEPALIVE probe to ")); - ip_addr_debug_print_val(TCP_DEBUG, pcb->remote_ip); - LWIP_DEBUGF(TCP_DEBUG, ("\n")); - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F" pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", - tcp_ticks, pcb->tmr, (u16_t)pcb->keep_cnt_sent)); - - p = tcp_output_alloc_header(pcb, optlen, 0, lwip_htonl(pcb->snd_nxt - 1)); - if (p == NULL) { - LWIP_DEBUGF(TCP_DEBUG, - ("tcp_keepalive: could not allocate memory for pbuf\n")); - return ERR_MEM; - } - tcp_output_fill_options(pcb, p, 0, optlen); - err = tcp_output_control_segment(pcb, p, &pcb->local_ip, &pcb->remote_ip); - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: seqno %"U32_F" ackno %"U32_F" err %d.\n", - pcb->snd_nxt - 1, pcb->rcv_nxt, (int)err)); - return err; -} - -/** - * Send persist timer zero-window probes to keep a connection active - * when a window update is lost. - * - * Called by tcp_slowtmr() - * - * @param pcb the tcp_pcb for which to send a zero-window probe packet - */ -err_t -tcp_zero_window_probe(struct tcp_pcb *pcb) -{ - err_t err; - struct pbuf *p; - struct tcp_hdr *tcphdr; - struct tcp_seg *seg; - u16_t len; - u8_t is_fin; - u32_t snd_nxt; - u8_t optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); - - LWIP_ASSERT("tcp_zero_window_probe: invalid pcb", pcb != NULL); - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: sending ZERO WINDOW probe to ")); - ip_addr_debug_print_val(TCP_DEBUG, pcb->remote_ip); - LWIP_DEBUGF(TCP_DEBUG, ("\n")); - - LWIP_DEBUGF(TCP_DEBUG, - ("tcp_zero_window_probe: tcp_ticks %"U32_F - " pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", - tcp_ticks, pcb->tmr, (u16_t)pcb->keep_cnt_sent)); - - /* Only consider unsent, persist timer should be off when there is data in-flight */ - seg = pcb->unsent; - if (seg == NULL) { - /* Not expected, persist timer should be off when the send buffer is empty */ - return ERR_OK; - } - - /* increment probe count. NOTE: we record probe even if it fails - to actually transmit due to an error. This ensures memory exhaustion/ - routing problem doesn't leave a zero-window pcb as an indefinite zombie. - RTO mechanism has similar behavior, see pcb->nrtx */ - if (pcb->persist_probe < 0xFF) { - ++pcb->persist_probe; - } - - is_fin = ((TCPH_FLAGS(seg->tcphdr) & TCP_FIN) != 0) && (seg->len == 0); - /* we want to send one seqno: either FIN or data (no options) */ - len = is_fin ? 0 : 1; - - p = tcp_output_alloc_header(pcb, optlen, len, seg->tcphdr->seqno); - if (p == NULL) { - LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: no memory for pbuf\n")); - return ERR_MEM; - } - tcphdr = (struct tcp_hdr *)p->payload; - - if (is_fin) { - /* FIN segment, no data */ - TCPH_FLAGS_SET(tcphdr, TCP_ACK | TCP_FIN); - } else { - /* Data segment, copy in one byte from the head of the unacked queue */ - char *d = ((char *)p->payload + TCP_HLEN); - /* Depending on whether the segment has already been sent (unacked) or not - (unsent), seg->p->payload points to the IP header or TCP header. - Ensure we copy the first TCP data byte: */ - pbuf_copy_partial(seg->p, d, 1, seg->p->tot_len - seg->len); - } - - /* The byte may be acknowledged without the window being opened. */ - snd_nxt = lwip_ntohl(seg->tcphdr->seqno) + 1; - if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) { - pcb->snd_nxt = snd_nxt; - } - tcp_output_fill_options(pcb, p, 0, optlen); - - err = tcp_output_control_segment(pcb, p, &pcb->local_ip, &pcb->remote_ip); - - LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: seqno %"U32_F - " ackno %"U32_F" err %d.\n", - pcb->snd_nxt - 1, pcb->rcv_nxt, (int)err)); - return err; -} -#endif /* LWIP_TCP */ +/** + * @file + * Transmission Control Protocol, outgoing traffic + * + * The output functions of TCP. + * + * There are two distinct ways for TCP segments to get sent: + * - queued data: these are segments transferring data or segments containing + * SYN or FIN (which both count as one sequence number). They are created as + * struct @ref pbuf together with a struct tcp_seg and enqueue to the + * unsent list of the pcb. They are sent by tcp_output: + * - @ref tcp_write : creates data segments + * - @ref tcp_split_unsent_seg : splits a data segment + * - @ref tcp_enqueue_flags : creates SYN-only or FIN-only segments + * - @ref tcp_output / tcp_output_segment : finalize the tcp header + * (e.g. sequence numbers, options, checksum) and output to IP + * - the various tcp_rexmit functions shuffle around segments between the + * unsent an unacked lists to retransmit them + * - tcp_create_segment and tcp_pbuf_prealloc allocate pbuf and + * segment for these functions + * - direct send: these segments don't contain data but control the connection + * behaviour. They are created as pbuf only and sent directly without + * enqueueing them: + * - @ref tcp_send_empty_ack sends an ACK-only segment + * - @ref tcp_rst sends a RST segment + * - @ref tcp_keepalive sends a keepalive segment + * - @ref tcp_zero_window_probe sends a window probe segment + * - tcp_output_alloc_header allocates a header-only pbuf for these functions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#include "lwip/opt.h" + +#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/priv/tcp_priv.h" +#include "lwip/def.h" +#include "lwip/mem.h" +#include "lwip/memp.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/inet_chksum.h" +#include "lwip/stats.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#if LWIP_TCP_TIMESTAMPS +#include "lwip/sys.h" +#endif + +#include + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +/* Allow to add custom TCP header options by defining this hook */ +#ifdef LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH +#define LWIP_TCP_OPT_LENGTH_SEGMENT(flags, pcb) LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH(pcb, LWIP_TCP_OPT_LENGTH(flags)) +#else +#define LWIP_TCP_OPT_LENGTH_SEGMENT(flags, pcb) LWIP_TCP_OPT_LENGTH(flags) +#endif + +/* Define some copy-macros for checksum-on-copy so that the code looks + nicer by preventing too many ifdef's. */ +#if TCP_CHECKSUM_ON_COPY +#define TCP_DATA_COPY(dst, src, len, seg) do { \ + tcp_seg_add_chksum(LWIP_CHKSUM_COPY(dst, src, len), \ + len, &seg->chksum, &seg->chksum_swapped); \ + seg->flags |= TF_SEG_DATA_CHECKSUMMED; } while(0) +#define TCP_DATA_COPY2(dst, src, len, chksum, chksum_swapped) \ + tcp_seg_add_chksum(LWIP_CHKSUM_COPY(dst, src, len), len, chksum, chksum_swapped); +#else /* TCP_CHECKSUM_ON_COPY*/ +#define TCP_DATA_COPY(dst, src, len, seg) MEMCPY(dst, src, len) +#define TCP_DATA_COPY2(dst, src, len, chksum, chksum_swapped) MEMCPY(dst, src, len) +#endif /* TCP_CHECKSUM_ON_COPY*/ + +/** Define this to 1 for an extra check that the output checksum is valid + * (usefule when the checksum is generated by the application, not the stack) */ +#ifndef TCP_CHECKSUM_ON_COPY_SANITY_CHECK +#define TCP_CHECKSUM_ON_COPY_SANITY_CHECK 0 +#endif +/* Allow to override the failure of sanity check from warning to e.g. hard failure */ +#if TCP_CHECKSUM_ON_COPY_SANITY_CHECK +#ifndef TCP_CHECKSUM_ON_COPY_SANITY_CHECK_FAIL +#define TCP_CHECKSUM_ON_COPY_SANITY_CHECK_FAIL(msg) LWIP_DEBUGF(TCP_DEBUG | LWIP_DBG_LEVEL_WARNING, msg) +#endif +#endif + +#if TCP_OVERSIZE +/** The size of segment pbufs created when TCP_OVERSIZE is enabled */ +#ifndef TCP_OVERSIZE_CALC_LENGTH +#define TCP_OVERSIZE_CALC_LENGTH(length) ((length) + TCP_OVERSIZE) +#endif +#endif + +/* Forward declarations.*/ +static err_t tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb, struct netif *netif); + +/* tcp_route: common code that returns a fixed bound netif or calls ip_route */ +static struct netif * +tcp_route(const struct tcp_pcb *pcb, const ip_addr_t *src, const ip_addr_t *dst) +{ + LWIP_UNUSED_ARG(src); /* in case IPv4-only and source-based routing is disabled */ + + if ((pcb != NULL) && (pcb->netif_idx != NETIF_NO_INDEX)) { + return netif_get_by_index(pcb->netif_idx); + } else { + return ip_route(src, dst); + } +} + +/** + * Create a TCP segment with prefilled header. + * + * Called by @ref tcp_write, @ref tcp_enqueue_flags and @ref tcp_split_unsent_seg + * + * @param pcb Protocol control block for the TCP connection. + * @param p pbuf that is used to hold the TCP header. + * @param hdrflags TCP flags for header. + * @param seqno TCP sequence number of this packet + * @param optflags options to include in TCP header + * @return a new tcp_seg pointing to p, or NULL. + * The TCP header is filled in except ackno and wnd. + * p is freed on failure. + */ +static struct tcp_seg * +tcp_create_segment(const struct tcp_pcb *pcb, struct pbuf *p, u8_t hdrflags, u32_t seqno, u8_t optflags) +{ + struct tcp_seg *seg; + u8_t optlen; + + LWIP_ASSERT("tcp_create_segment: invalid pcb", pcb != NULL); + LWIP_ASSERT("tcp_create_segment: invalid pbuf", p != NULL); + + optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb); + + if ((seg = (struct tcp_seg *)memp_malloc(MEMP_TCP_SEG)) == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_create_segment: no memory.\n")); + pbuf_free(p); + return NULL; + } + seg->flags = optflags; + seg->next = NULL; + seg->p = p; + LWIP_ASSERT("p->tot_len >= optlen", p->tot_len >= optlen); + seg->len = p->tot_len - optlen; +#if TCP_OVERSIZE_DBGCHECK + seg->oversize_left = 0; +#endif /* TCP_OVERSIZE_DBGCHECK */ +#if TCP_CHECKSUM_ON_COPY + seg->chksum = 0; + seg->chksum_swapped = 0; + /* check optflags */ + LWIP_ASSERT("invalid optflags passed: TF_SEG_DATA_CHECKSUMMED", + (optflags & TF_SEG_DATA_CHECKSUMMED) == 0); +#endif /* TCP_CHECKSUM_ON_COPY */ + + /* build TCP header */ + if (pbuf_add_header(p, TCP_HLEN)) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_create_segment: no room for TCP header in pbuf.\n")); + TCP_STATS_INC(tcp.err); + tcp_seg_free(seg); + return NULL; + } + seg->tcphdr = (struct tcp_hdr *)seg->p->payload; + seg->tcphdr->src = lwip_htons(pcb->local_port); + seg->tcphdr->dest = lwip_htons(pcb->remote_port); + seg->tcphdr->seqno = lwip_htonl(seqno); + /* ackno is set in tcp_output */ + TCPH_HDRLEN_FLAGS_SET(seg->tcphdr, (5 + optlen / 4), hdrflags); + /* wnd and chksum are set in tcp_output */ + seg->tcphdr->urgp = 0; + return seg; +} + +/** + * Allocate a PBUF_RAM pbuf, perhaps with extra space at the end. + * + * This function is like pbuf_alloc(layer, length, PBUF_RAM) except + * there may be extra bytes available at the end. + * + * Called by @ref tcp_write + * + * @param layer flag to define header size. + * @param length size of the pbuf's payload. + * @param max_length maximum usable size of payload+oversize. + * @param oversize pointer to a u16_t that will receive the number of usable tail bytes. + * @param pcb The TCP connection that will enqueue the pbuf. + * @param apiflags API flags given to tcp_write. + * @param first_seg true when this pbuf will be used in the first enqueued segment. + */ +#if TCP_OVERSIZE +static struct pbuf * +tcp_pbuf_prealloc(pbuf_layer layer, u16_t length, u16_t max_length, + u16_t *oversize, const struct tcp_pcb *pcb, u8_t apiflags, + u8_t first_seg) +{ + struct pbuf *p; + u16_t alloc = length; + + LWIP_ASSERT("tcp_pbuf_prealloc: invalid oversize", oversize != NULL); + LWIP_ASSERT("tcp_pbuf_prealloc: invalid pcb", pcb != NULL); + +#if LWIP_NETIF_TX_SINGLE_PBUF + LWIP_UNUSED_ARG(max_length); + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(apiflags); + LWIP_UNUSED_ARG(first_seg); + alloc = max_length; +#else /* LWIP_NETIF_TX_SINGLE_PBUF */ + if (length < max_length) { + /* Should we allocate an oversized pbuf, or just the minimum + * length required? If tcp_write is going to be called again + * before this segment is transmitted, we want the oversized + * buffer. If the segment will be transmitted immediately, we can + * save memory by allocating only length. We use a simple + * heuristic based on the following information: + * + * Did the user set TCP_WRITE_FLAG_MORE? + * + * Will the Nagle algorithm defer transmission of this segment? + */ + if ((apiflags & TCP_WRITE_FLAG_MORE) || + (!(pcb->flags & TF_NODELAY) && + (!first_seg || + pcb->unsent != NULL || + pcb->unacked != NULL))) { + alloc = LWIP_MIN(max_length, LWIP_MEM_ALIGN_SIZE(TCP_OVERSIZE_CALC_LENGTH(length))); + } + } +#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ + p = pbuf_alloc(layer, alloc, PBUF_RAM); + if (p == NULL) { + return NULL; + } + LWIP_ASSERT("need unchained pbuf", p->next == NULL); + *oversize = p->len - length; + /* trim p->len to the currently used size */ + p->len = p->tot_len = length; + return p; +} +#else /* TCP_OVERSIZE */ +#define tcp_pbuf_prealloc(layer, length, mx, os, pcb, api, fst) pbuf_alloc((layer), (length), PBUF_RAM) +#endif /* TCP_OVERSIZE */ + +#if TCP_CHECKSUM_ON_COPY +/** Add a checksum of newly added data to the segment. + * + * Called by tcp_write and tcp_split_unsent_seg. + */ +static void +tcp_seg_add_chksum(u16_t chksum, u16_t len, u16_t *seg_chksum, + u8_t *seg_chksum_swapped) +{ + u32_t helper; + /* add chksum to old chksum and fold to u16_t */ + helper = chksum + *seg_chksum; + chksum = FOLD_U32T(helper); + if ((len & 1) != 0) { + *seg_chksum_swapped = 1 - *seg_chksum_swapped; + chksum = SWAP_BYTES_IN_WORD(chksum); + } + *seg_chksum = chksum; +} +#endif /* TCP_CHECKSUM_ON_COPY */ + +/** Checks if tcp_write is allowed or not (checks state, snd_buf and snd_queuelen). + * + * @param pcb the tcp pcb to check for + * @param len length of data to send (checked agains snd_buf) + * @return ERR_OK if tcp_write is allowed to proceed, another err_t otherwise + */ +static err_t +tcp_write_checks(struct tcp_pcb *pcb, u16_t len) +{ + LWIP_ASSERT("tcp_write_checks: invalid pcb", pcb != NULL); + + /* connection is in invalid state for data transmission? */ + if ((pcb->state != ESTABLISHED) && + (pcb->state != CLOSE_WAIT) && + (pcb->state != SYN_SENT) && + (pcb->state != SYN_RCVD)) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_STATE | LWIP_DBG_LEVEL_SEVERE, ("tcp_write() called in invalid state\n")); + return ERR_CONN; + } else if (len == 0) { + return ERR_OK; + } + + /* fail on too much data */ + if (len > pcb->snd_buf) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("tcp_write: too much data (len=%"U16_F" > snd_buf=%"TCPWNDSIZE_F")\n", + len, pcb->snd_buf)); + tcp_set_flags(pcb, TF_NAGLEMEMERR); + return ERR_MEM; + } + + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: queuelen: %"TCPWNDSIZE_F"\n", (tcpwnd_size_t)pcb->snd_queuelen)); + + /* If total number of pbufs on the unsent/unacked queues exceeds the + * configured maximum, return an error */ + /* check for configured max queuelen and possible overflow */ + if (pcb->snd_queuelen >= LWIP_MIN(TCP_SND_QUEUELEN, (TCP_SNDQUEUELEN_OVERFLOW + 1))) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SEVERE, ("tcp_write: too long queue %"U16_F" (max %"U16_F")\n", + pcb->snd_queuelen, (u16_t)TCP_SND_QUEUELEN)); + TCP_STATS_INC(tcp.memerr); + tcp_set_flags(pcb, TF_NAGLEMEMERR); + return ERR_MEM; + } + if (pcb->snd_queuelen != 0) { + LWIP_ASSERT("tcp_write: pbufs on queue => at least one queue non-empty", + pcb->unacked != NULL || pcb->unsent != NULL); + } else { + LWIP_ASSERT("tcp_write: no pbufs on queue => both queues empty", + pcb->unacked == NULL && pcb->unsent == NULL); + } + return ERR_OK; +} + +/** + * @ingroup tcp_raw + * Write data for sending (but does not send it immediately). + * + * It waits in the expectation of more data being sent soon (as + * it can send them more efficiently by combining them together). + * To prompt the system to send data now, call tcp_output() after + * calling tcp_write(). + * + * This function enqueues the data pointed to by the argument dataptr. The length of + * the data is passed as the len parameter. The apiflags can be one or more of: + * - TCP_WRITE_FLAG_COPY: indicates whether the new memory should be allocated + * for the data to be copied into. If this flag is not given, no new memory + * should be allocated and the data should only be referenced by pointer. This + * also means that the memory behind dataptr must not change until the data is + * ACKed by the remote host + * - TCP_WRITE_FLAG_MORE: indicates that more data follows. If this is omitted, + * the PSH flag is set in the last segment created by this call to tcp_write. + * If this flag is given, the PSH flag is not set. + * + * The tcp_write() function will fail and return ERR_MEM if the length + * of the data exceeds the current send buffer size or if the length of + * the queue of outgoing segment is larger than the upper limit defined + * in lwipopts.h. The number of bytes available in the output queue can + * be retrieved with the tcp_sndbuf() function. + * + * The proper way to use this function is to call the function with at + * most tcp_sndbuf() bytes of data. If the function returns ERR_MEM, + * the application should wait until some of the currently enqueued + * data has been successfully received by the other host and try again. + * + * @param pcb Protocol control block for the TCP connection to enqueue data for. + * @param arg Pointer to the data to be enqueued for sending. + * @param len Data length in bytes + * @param apiflags combination of following flags : + * - TCP_WRITE_FLAG_COPY (0x01) data will be copied into memory belonging to the stack + * - TCP_WRITE_FLAG_MORE (0x02) for TCP connection, PSH flag will not be set on last segment sent, + * @return ERR_OK if enqueued, another err_t on error + */ +err_t +tcp_write(struct tcp_pcb *pcb, const void *arg, u16_t len, u8_t apiflags) +{ + struct pbuf *concat_p = NULL; + struct tcp_seg *last_unsent = NULL, *seg = NULL, *prev_seg = NULL, *queue = NULL; + u16_t pos = 0; /* position in 'arg' data */ + u16_t queuelen; + u8_t optlen; + u8_t optflags = 0; +#if TCP_OVERSIZE + u16_t oversize = 0; + u16_t oversize_used = 0; +#if TCP_OVERSIZE_DBGCHECK + u16_t oversize_add = 0; +#endif /* TCP_OVERSIZE_DBGCHECK*/ +#endif /* TCP_OVERSIZE */ + u16_t extendlen = 0; +#if TCP_CHECKSUM_ON_COPY + u16_t concat_chksum = 0; + u8_t concat_chksum_swapped = 0; + u16_t concat_chksummed = 0; +#endif /* TCP_CHECKSUM_ON_COPY */ + err_t err; + u16_t mss_local; + + LWIP_ERROR("tcp_write: invalid pcb", pcb != NULL, return ERR_ARG); + + /* don't allocate segments bigger than half the maximum window we ever received */ + mss_local = LWIP_MIN(pcb->mss, TCPWND_MIN16(pcb->snd_wnd_max / 2)); + mss_local = mss_local ? mss_local : pcb->mss; + + LWIP_ASSERT_CORE_LOCKED(); + +#if LWIP_NETIF_TX_SINGLE_PBUF + /* Always copy to try to create single pbufs for TX */ + apiflags |= TCP_WRITE_FLAG_COPY; +#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ + + LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_write(pcb=%p, data=%p, len=%"U16_F", apiflags=%"U16_F")\n", + (void *)pcb, arg, len, (u16_t)apiflags)); + LWIP_ERROR("tcp_write: arg == NULL (programmer violates API)", + arg != NULL, return ERR_ARG;); + + err = tcp_write_checks(pcb, len); + if (err != ERR_OK) { + return err; + } + queuelen = pcb->snd_queuelen; + +#if LWIP_TCP_TIMESTAMPS + if ((pcb->flags & TF_TIMESTAMP)) { + /* Make sure the timestamp option is only included in data segments if we + agreed about it with the remote host. */ + optflags = TF_SEG_OPTS_TS; + optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(TF_SEG_OPTS_TS, pcb); + /* ensure that segments can hold at least one data byte... */ + mss_local = LWIP_MAX(mss_local, LWIP_TCP_OPT_LEN_TS + 1); + } else +#endif /* LWIP_TCP_TIMESTAMPS */ + { + optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); + } + + + /* + * TCP segmentation is done in three phases with increasing complexity: + * + * 1. Copy data directly into an oversized pbuf. + * 2. Chain a new pbuf to the end of pcb->unsent. + * 3. Create new segments. + * + * We may run out of memory at any point. In that case we must + * return ERR_MEM and not change anything in pcb. Therefore, all + * changes are recorded in local variables and committed at the end + * of the function. Some pcb fields are maintained in local copies: + * + * queuelen = pcb->snd_queuelen + * oversize = pcb->unsent_oversize + * + * These variables are set consistently by the phases: + * + * seg points to the last segment tampered with. + * + * pos records progress as data is segmented. + */ + + /* Find the tail of the unsent queue. */ + if (pcb->unsent != NULL) { + u16_t space; + u16_t unsent_optlen; + + /* @todo: this could be sped up by keeping last_unsent in the pcb */ + for (last_unsent = pcb->unsent; last_unsent->next != NULL; + last_unsent = last_unsent->next); + + /* Usable space at the end of the last unsent segment */ + unsent_optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(last_unsent->flags, pcb); + LWIP_ASSERT("mss_local is too small", mss_local >= last_unsent->len + unsent_optlen); + space = mss_local - (last_unsent->len + unsent_optlen); + + /* + * Phase 1: Copy data directly into an oversized pbuf. + * + * The number of bytes copied is recorded in the oversize_used + * variable. The actual copying is done at the bottom of the + * function. + */ +#if TCP_OVERSIZE +#if TCP_OVERSIZE_DBGCHECK + /* check that pcb->unsent_oversize matches last_unsent->oversize_left */ + LWIP_ASSERT("unsent_oversize mismatch (pcb vs. last_unsent)", + pcb->unsent_oversize == last_unsent->oversize_left); +#endif /* TCP_OVERSIZE_DBGCHECK */ + oversize = pcb->unsent_oversize; + if (oversize > 0) { + LWIP_ASSERT("inconsistent oversize vs. space", oversize <= space); + seg = last_unsent; + oversize_used = LWIP_MIN(space, LWIP_MIN(oversize, len)); + pos += oversize_used; + oversize -= oversize_used; + space -= oversize_used; + } + /* now we are either finished or oversize is zero */ + LWIP_ASSERT("inconsistent oversize vs. len", (oversize == 0) || (pos == len)); +#endif /* TCP_OVERSIZE */ + +#if !LWIP_NETIF_TX_SINGLE_PBUF + /* + * Phase 2: Chain a new pbuf to the end of pcb->unsent. + * + * As an exception when NOT copying the data, if the given data buffer + * directly follows the last unsent data buffer in memory, extend the last + * ROM pbuf reference to the buffer, thus saving a ROM pbuf allocation. + * + * We don't extend segments containing SYN/FIN flags or options + * (len==0). The new pbuf is kept in concat_p and pbuf_cat'ed at + * the end. + * + * This phase is skipped for LWIP_NETIF_TX_SINGLE_PBUF as we could only execute + * it after rexmit puts a segment from unacked to unsent and at this point, + * oversize info is lost. + */ + if ((pos < len) && (space > 0) && (last_unsent->len > 0)) { + u16_t seglen = LWIP_MIN(space, len - pos); + seg = last_unsent; + + /* Create a pbuf with a copy or reference to seglen bytes. We + * can use PBUF_RAW here since the data appears in the middle of + * a segment. A header will never be prepended. */ + if (apiflags & TCP_WRITE_FLAG_COPY) { + /* Data is copied */ + if ((concat_p = tcp_pbuf_prealloc(PBUF_RAW, seglen, space, &oversize, pcb, apiflags, 1)) == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n", + seglen)); + goto memerr; + } +#if TCP_OVERSIZE_DBGCHECK + oversize_add = oversize; +#endif /* TCP_OVERSIZE_DBGCHECK */ + TCP_DATA_COPY2(concat_p->payload, (const u8_t *)arg + pos, seglen, &concat_chksum, &concat_chksum_swapped); +#if TCP_CHECKSUM_ON_COPY + concat_chksummed += seglen; +#endif /* TCP_CHECKSUM_ON_COPY */ + queuelen += pbuf_clen(concat_p); + } else { + /* Data is not copied */ + /* If the last unsent pbuf is of type PBUF_ROM, try to extend it. */ + struct pbuf *p; + for (p = last_unsent->p; p->next != NULL; p = p->next); + if (((p->type_internal & (PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS | PBUF_TYPE_FLAG_DATA_VOLATILE)) == 0) && + (const u8_t *)p->payload + p->len == (const u8_t *)arg) { + LWIP_ASSERT("tcp_write: ROM pbufs cannot be oversized", pos == 0); + extendlen = seglen; + } else { + if ((concat_p = pbuf_alloc(PBUF_RAW, seglen, PBUF_ROM)) == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("tcp_write: could not allocate memory for zero-copy pbuf\n")); + goto memerr; + } + /* reference the non-volatile payload data */ + ((struct pbuf_rom *)concat_p)->payload = (const u8_t *)arg + pos; + queuelen += pbuf_clen(concat_p); + } +#if TCP_CHECKSUM_ON_COPY + /* calculate the checksum of nocopy-data */ + tcp_seg_add_chksum(~inet_chksum((const u8_t *)arg + pos, seglen), seglen, + &concat_chksum, &concat_chksum_swapped); + concat_chksummed += seglen; +#endif /* TCP_CHECKSUM_ON_COPY */ + } + + pos += seglen; + } +#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ + } else { +#if TCP_OVERSIZE + LWIP_ASSERT("unsent_oversize mismatch (pcb->unsent is NULL)", + pcb->unsent_oversize == 0); +#endif /* TCP_OVERSIZE */ + } + + /* + * Phase 3: Create new segments. + * + * The new segments are chained together in the local 'queue' + * variable, ready to be appended to pcb->unsent. + */ + while (pos < len) { + struct pbuf *p; + u16_t left = len - pos; + u16_t max_len = mss_local - optlen; + u16_t seglen = LWIP_MIN(left, max_len); +#if TCP_CHECKSUM_ON_COPY + u16_t chksum = 0; + u8_t chksum_swapped = 0; +#endif /* TCP_CHECKSUM_ON_COPY */ + + if (apiflags & TCP_WRITE_FLAG_COPY) { + /* If copy is set, memory should be allocated and data copied + * into pbuf */ + if ((p = tcp_pbuf_prealloc(PBUF_TRANSPORT, seglen + optlen, mss_local, &oversize, pcb, apiflags, queue == NULL)) == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write : could not allocate memory for pbuf copy size %"U16_F"\n", seglen)); + goto memerr; + } + LWIP_ASSERT("tcp_write: check that first pbuf can hold the complete seglen", + (p->len >= seglen)); + TCP_DATA_COPY2((char *)p->payload + optlen, (const u8_t *)arg + pos, seglen, &chksum, &chksum_swapped); + } else { + /* Copy is not set: First allocate a pbuf for holding the data. + * Since the referenced data is available at least until it is + * sent out on the link (as it has to be ACKed by the remote + * party) we can safely use PBUF_ROM instead of PBUF_REF here. + */ + struct pbuf *p2; +#if TCP_OVERSIZE + LWIP_ASSERT("oversize == 0", oversize == 0); +#endif /* TCP_OVERSIZE */ + if ((p2 = pbuf_alloc(PBUF_TRANSPORT, seglen, PBUF_ROM)) == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write: could not allocate memory for zero-copy pbuf\n")); + goto memerr; + } +#if TCP_CHECKSUM_ON_COPY + /* calculate the checksum of nocopy-data */ + chksum = ~inet_chksum((const u8_t *)arg + pos, seglen); + if (seglen & 1) { + chksum_swapped = 1; + chksum = SWAP_BYTES_IN_WORD(chksum); + } +#endif /* TCP_CHECKSUM_ON_COPY */ + /* reference the non-volatile payload data */ + ((struct pbuf_rom *)p2)->payload = (const u8_t *)arg + pos; + + /* Second, allocate a pbuf for the headers. */ + if ((p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) { + /* If allocation fails, we have to deallocate the data pbuf as + * well. */ + pbuf_free(p2); + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write: could not allocate memory for header pbuf\n")); + goto memerr; + } + /* Concatenate the headers and data pbufs together. */ + pbuf_cat(p/*header*/, p2/*data*/); + } + + queuelen += pbuf_clen(p); + + /* Now that there are more segments queued, we check again if the + * length of the queue exceeds the configured maximum or + * overflows. */ + if (queuelen > LWIP_MIN(TCP_SND_QUEUELEN, TCP_SNDQUEUELEN_OVERFLOW)) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_write: queue too long %"U16_F" (%d)\n", + queuelen, (int)TCP_SND_QUEUELEN)); + pbuf_free(p); + goto memerr; + } + + if ((seg = tcp_create_segment(pcb, p, 0, pcb->snd_lbb + pos, optflags)) == NULL) { + goto memerr; + } +#if TCP_OVERSIZE_DBGCHECK + seg->oversize_left = oversize; +#endif /* TCP_OVERSIZE_DBGCHECK */ +#if TCP_CHECKSUM_ON_COPY + seg->chksum = chksum; + seg->chksum_swapped = chksum_swapped; + seg->flags |= TF_SEG_DATA_CHECKSUMMED; +#endif /* TCP_CHECKSUM_ON_COPY */ + + /* first segment of to-be-queued data? */ + if (queue == NULL) { + queue = seg; + } else { + /* Attach the segment to the end of the queued segments */ + LWIP_ASSERT("prev_seg != NULL", prev_seg != NULL); + prev_seg->next = seg; + } + /* remember last segment of to-be-queued data for next iteration */ + prev_seg = seg; + + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, ("tcp_write: queueing %"U32_F":%"U32_F"\n", + lwip_ntohl(seg->tcphdr->seqno), + lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg))); + + pos += seglen; + } + + /* + * All three segmentation phases were successful. We can commit the + * transaction. + */ +#if TCP_OVERSIZE_DBGCHECK + if ((last_unsent != NULL) && (oversize_add != 0)) { + last_unsent->oversize_left += oversize_add; + } +#endif /* TCP_OVERSIZE_DBGCHECK */ + + /* + * Phase 1: If data has been added to the preallocated tail of + * last_unsent, we update the length fields of the pbuf chain. + */ +#if TCP_OVERSIZE + if (oversize_used > 0) { + struct pbuf *p; + /* Bump tot_len of whole chain, len of tail */ + for (p = last_unsent->p; p; p = p->next) { + p->tot_len += oversize_used; + if (p->next == NULL) { + TCP_DATA_COPY((char *)p->payload + p->len, arg, oversize_used, last_unsent); + p->len += oversize_used; + } + } + last_unsent->len += oversize_used; +#if TCP_OVERSIZE_DBGCHECK + LWIP_ASSERT("last_unsent->oversize_left >= oversize_used", + last_unsent->oversize_left >= oversize_used); + last_unsent->oversize_left -= oversize_used; +#endif /* TCP_OVERSIZE_DBGCHECK */ + } + pcb->unsent_oversize = oversize; +#endif /* TCP_OVERSIZE */ + + /* + * Phase 2: concat_p can be concatenated onto last_unsent->p, unless we + * determined that the last ROM pbuf can be extended to include the new data. + */ + if (concat_p != NULL) { + LWIP_ASSERT("tcp_write: cannot concatenate when pcb->unsent is empty", + (last_unsent != NULL)); + pbuf_cat(last_unsent->p, concat_p); + last_unsent->len += concat_p->tot_len; + } else if (extendlen > 0) { + struct pbuf *p; + LWIP_ASSERT("tcp_write: extension of reference requires reference", + last_unsent != NULL && last_unsent->p != NULL); + for (p = last_unsent->p; p->next != NULL; p = p->next) { + p->tot_len += extendlen; + } + p->tot_len += extendlen; + p->len += extendlen; + last_unsent->len += extendlen; + } + +#if TCP_CHECKSUM_ON_COPY + if (concat_chksummed) { + LWIP_ASSERT("tcp_write: concat checksum needs concatenated data", + concat_p != NULL || extendlen > 0); + /*if concat checksumm swapped - swap it back */ + if (concat_chksum_swapped) { + concat_chksum = SWAP_BYTES_IN_WORD(concat_chksum); + } + tcp_seg_add_chksum(concat_chksum, concat_chksummed, &last_unsent->chksum, + &last_unsent->chksum_swapped); + last_unsent->flags |= TF_SEG_DATA_CHECKSUMMED; + } +#endif /* TCP_CHECKSUM_ON_COPY */ + + /* + * Phase 3: Append queue to pcb->unsent. Queue may be NULL, but that + * is harmless + */ + if (last_unsent == NULL) { + pcb->unsent = queue; + } else { + last_unsent->next = queue; + } + + /* + * Finally update the pcb state. + */ + pcb->snd_lbb += len; + pcb->snd_buf -= len; + pcb->snd_queuelen = queuelen; + + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_write: %"S16_F" (after enqueued)\n", + pcb->snd_queuelen)); + if (pcb->snd_queuelen != 0) { + LWIP_ASSERT("tcp_write: valid queue length", + pcb->unacked != NULL || pcb->unsent != NULL); + } + + /* Set the PSH flag in the last segment that we enqueued. */ + if (seg != NULL && seg->tcphdr != NULL && ((apiflags & TCP_WRITE_FLAG_MORE) == 0)) { + TCPH_SET_FLAG(seg->tcphdr, TCP_PSH); + } + + return ERR_OK; +memerr: + tcp_set_flags(pcb, TF_NAGLEMEMERR); + TCP_STATS_INC(tcp.memerr); + + if (concat_p != NULL) { + pbuf_free(concat_p); + } + if (queue != NULL) { + tcp_segs_free(queue); + } + if (pcb->snd_queuelen != 0) { + LWIP_ASSERT("tcp_write: valid queue length", pcb->unacked != NULL || + pcb->unsent != NULL); + } + LWIP_DEBUGF(TCP_QLEN_DEBUG | LWIP_DBG_STATE, ("tcp_write: %"S16_F" (with mem err)\n", pcb->snd_queuelen)); + return ERR_MEM; +} + +/** + * Split segment on the head of the unsent queue. If return is not + * ERR_OK, existing head remains intact + * + * The split is accomplished by creating a new TCP segment and pbuf + * which holds the remainder payload after the split. The original + * pbuf is trimmed to new length. This allows splitting of read-only + * pbufs + * + * @param pcb the tcp_pcb for which to split the unsent head + * @param split the amount of payload to remain in the head + */ +err_t +tcp_split_unsent_seg(struct tcp_pcb *pcb, u16_t split) +{ + struct tcp_seg *seg = NULL, *useg = NULL; + struct pbuf *p = NULL; + u8_t optlen; + u8_t optflags; + u8_t split_flags; + u8_t remainder_flags; + u16_t remainder; + u16_t offset; +#if TCP_CHECKSUM_ON_COPY + u16_t chksum = 0; + u8_t chksum_swapped = 0; + struct pbuf *q; +#endif /* TCP_CHECKSUM_ON_COPY */ + + LWIP_ASSERT("tcp_split_unsent_seg: invalid pcb", pcb != NULL); + + useg = pcb->unsent; + if (useg == NULL) { + return ERR_MEM; + } + + if (split == 0) { + LWIP_ASSERT("Can't split segment into length 0", 0); + return ERR_VAL; + } + + if (useg->len <= split) { + return ERR_OK; + } + + LWIP_ASSERT("split <= mss", split <= pcb->mss); + LWIP_ASSERT("useg->len > 0", useg->len > 0); + + /* We should check that we don't exceed TCP_SND_QUEUELEN but we need + * to split this packet so we may actually exceed the max value by + * one! + */ + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue: split_unsent_seg: %u\n", (unsigned int)pcb->snd_queuelen)); + + optflags = useg->flags; +#if TCP_CHECKSUM_ON_COPY + /* Remove since checksum is not stored until after tcp_create_segment() */ + optflags &= ~TF_SEG_DATA_CHECKSUMMED; +#endif /* TCP_CHECKSUM_ON_COPY */ + optlen = LWIP_TCP_OPT_LENGTH(optflags); + remainder = useg->len - split; + + /* Create new pbuf for the remainder of the split */ + p = pbuf_alloc(PBUF_TRANSPORT, remainder + optlen, PBUF_RAM); + if (p == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("tcp_split_unsent_seg: could not allocate memory for pbuf remainder %u\n", remainder)); + goto memerr; + } + + /* Offset into the original pbuf is past TCP/IP headers, options, and split amount */ + offset = useg->p->tot_len - useg->len + split; + /* Copy remainder into new pbuf, headers and options will not be filled out */ + if (pbuf_copy_partial(useg->p, (u8_t *)p->payload + optlen, remainder, offset ) != remainder) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("tcp_split_unsent_seg: could not copy pbuf remainder %u\n", remainder)); + goto memerr; + } +#if TCP_CHECKSUM_ON_COPY + /* calculate the checksum on remainder data */ + tcp_seg_add_chksum(~inet_chksum((const u8_t *)p->payload + optlen, remainder), remainder, + &chksum, &chksum_swapped); +#endif /* TCP_CHECKSUM_ON_COPY */ + + /* Options are created when calling tcp_output() */ + + /* Migrate flags from original segment */ + split_flags = TCPH_FLAGS(useg->tcphdr); + remainder_flags = 0; /* ACK added in tcp_output() */ + + if (split_flags & TCP_PSH) { + split_flags &= ~TCP_PSH; + remainder_flags |= TCP_PSH; + } + if (split_flags & TCP_FIN) { + split_flags &= ~TCP_FIN; + remainder_flags |= TCP_FIN; + } + /* SYN should be left on split, RST should not be present with data */ + + seg = tcp_create_segment(pcb, p, remainder_flags, lwip_ntohl(useg->tcphdr->seqno) + split, optflags); + if (seg == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("tcp_split_unsent_seg: could not create new TCP segment\n")); + goto memerr; + } + +#if TCP_CHECKSUM_ON_COPY + seg->chksum = chksum; + seg->chksum_swapped = chksum_swapped; + seg->flags |= TF_SEG_DATA_CHECKSUMMED; +#endif /* TCP_CHECKSUM_ON_COPY */ + + /* Remove this segment from the queue since trimming it may free pbufs */ + pcb->snd_queuelen -= pbuf_clen(useg->p); + + /* Trim the original pbuf into our split size. At this point our remainder segment must be setup + successfully because we are modifying the original segment */ + pbuf_realloc(useg->p, useg->p->tot_len - remainder); + useg->len -= remainder; + TCPH_SET_FLAG(useg->tcphdr, split_flags); +#if TCP_OVERSIZE_DBGCHECK + /* By trimming, realloc may have actually shrunk the pbuf, so clear oversize_left */ + useg->oversize_left = 0; +#endif /* TCP_OVERSIZE_DBGCHECK */ + + /* Add back to the queue with new trimmed pbuf */ + pcb->snd_queuelen += pbuf_clen(useg->p); + +#if TCP_CHECKSUM_ON_COPY + /* The checksum on the split segment is now incorrect. We need to re-run it over the split */ + useg->chksum = 0; + useg->chksum_swapped = 0; + q = useg->p; + offset = q->tot_len - useg->len; /* Offset due to exposed headers */ + + /* Advance to the pbuf where the offset ends */ + while (q != NULL && offset > q->len) { + offset -= q->len; + q = q->next; + } + LWIP_ASSERT("Found start of payload pbuf", q != NULL); + /* Checksum the first payload pbuf accounting for offset, then other pbufs are all payload */ + for (; q != NULL; offset = 0, q = q->next) { + tcp_seg_add_chksum(~inet_chksum((const u8_t *)q->payload + offset, q->len - offset), q->len - offset, + &useg->chksum, &useg->chksum_swapped); + } +#endif /* TCP_CHECKSUM_ON_COPY */ + + /* Update number of segments on the queues. Note that length now may + * exceed TCP_SND_QUEUELEN! We don't have to touch pcb->snd_buf + * because the total amount of data is constant when packet is split */ + pcb->snd_queuelen += pbuf_clen(seg->p); + + /* Finally insert remainder into queue after split (which stays head) */ + seg->next = useg->next; + useg->next = seg; + +#if TCP_OVERSIZE + /* If remainder is last segment on the unsent, ensure we clear the oversize amount + * because the remainder is always sized to the exact remaining amount */ + if (seg->next == NULL) { + pcb->unsent_oversize = 0; + } +#endif /* TCP_OVERSIZE */ + + return ERR_OK; +memerr: + TCP_STATS_INC(tcp.memerr); + + LWIP_ASSERT("seg == NULL", seg == NULL); + if (p != NULL) { + pbuf_free(p); + } + + return ERR_MEM; +} + +/** + * Called by tcp_close() to send a segment including FIN flag but not data. + * This FIN may be added to an existing segment or a new, otherwise empty + * segment is enqueued. + * + * @param pcb the tcp_pcb over which to send a segment + * @return ERR_OK if sent, another err_t otherwise + */ +err_t +tcp_send_fin(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_send_fin: invalid pcb", pcb != NULL); + + /* first, try to add the fin to the last unsent segment */ + if (pcb->unsent != NULL) { + struct tcp_seg *last_unsent; + for (last_unsent = pcb->unsent; last_unsent->next != NULL; + last_unsent = last_unsent->next); + + if ((TCPH_FLAGS(last_unsent->tcphdr) & (TCP_SYN | TCP_FIN | TCP_RST)) == 0) { + /* no SYN/FIN/RST flag in the header, we can add the FIN flag */ + TCPH_SET_FLAG(last_unsent->tcphdr, TCP_FIN); + tcp_set_flags(pcb, TF_FIN); + return ERR_OK; + } + } + /* no data, no length, flags, copy=1, no optdata */ + return tcp_enqueue_flags(pcb, TCP_FIN); +} + +/** + * Enqueue SYN or FIN for transmission. + * + * Called by @ref tcp_connect, tcp_listen_input, and @ref tcp_close + * (via @ref tcp_send_fin) + * + * @param pcb Protocol control block for the TCP connection. + * @param flags TCP header flags to set in the outgoing segment. + */ +err_t +tcp_enqueue_flags(struct tcp_pcb *pcb, u8_t flags) +{ + struct pbuf *p; + struct tcp_seg *seg; + u8_t optflags = 0; + u8_t optlen = 0; + + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: queuelen: %"U16_F"\n", (u16_t)pcb->snd_queuelen)); + + LWIP_ASSERT("tcp_enqueue_flags: need either TCP_SYN or TCP_FIN in flags (programmer violates API)", + (flags & (TCP_SYN | TCP_FIN)) != 0); + LWIP_ASSERT("tcp_enqueue_flags: invalid pcb", pcb != NULL); + + /* No need to check pcb->snd_queuelen if only SYN or FIN are allowed! */ + + /* Get options for this segment. This is a special case since this is the + only place where a SYN can be sent. */ + if (flags & TCP_SYN) { + optflags = TF_SEG_OPTS_MSS; +#if LWIP_WND_SCALE + if ((pcb->state != SYN_RCVD) || (pcb->flags & TF_WND_SCALE)) { + /* In a (sent in state SYN_RCVD), the window scale option may only + be sent if we received a window scale option from the remote host. */ + optflags |= TF_SEG_OPTS_WND_SCALE; + } +#endif /* LWIP_WND_SCALE */ +#if LWIP_TCP_SACK_OUT + if ((pcb->state != SYN_RCVD) || (pcb->flags & TF_SACK)) { + /* In a (sent in state SYN_RCVD), the SACK_PERM option may only + be sent if we received a SACK_PERM option from the remote host. */ + optflags |= TF_SEG_OPTS_SACK_PERM; + } +#endif /* LWIP_TCP_SACK_OUT */ + } +#if LWIP_TCP_TIMESTAMPS + if ((pcb->flags & TF_TIMESTAMP) || ((flags & TCP_SYN) && (pcb->state != SYN_RCVD))) { + /* Make sure the timestamp option is only included in data segments if we + agreed about it with the remote host (and in active open SYN segments). */ + optflags |= TF_SEG_OPTS_TS; + } +#endif /* LWIP_TCP_TIMESTAMPS */ + optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb); + + /* Allocate pbuf with room for TCP header + options */ + if ((p = pbuf_alloc(PBUF_TRANSPORT, optlen, PBUF_RAM)) == NULL) { + tcp_set_flags(pcb, TF_NAGLEMEMERR); + TCP_STATS_INC(tcp.memerr); + return ERR_MEM; + } + LWIP_ASSERT("tcp_enqueue_flags: check that first pbuf can hold optlen", + (p->len >= optlen)); + + /* Allocate memory for tcp_seg, and fill in fields. */ + if ((seg = tcp_create_segment(pcb, p, flags, pcb->snd_lbb, optflags)) == NULL) { + tcp_set_flags(pcb, TF_NAGLEMEMERR); + TCP_STATS_INC(tcp.memerr); + return ERR_MEM; + } + LWIP_ASSERT("seg->tcphdr not aligned", ((mem_ptr_t)seg->tcphdr % LWIP_MIN(MEM_ALIGNMENT, 4)) == 0); + LWIP_ASSERT("tcp_enqueue_flags: invalid segment length", seg->len == 0); + + LWIP_DEBUGF(TCP_OUTPUT_DEBUG | LWIP_DBG_TRACE, + ("tcp_enqueue_flags: queueing %"U32_F":%"U32_F" (0x%"X16_F")\n", + lwip_ntohl(seg->tcphdr->seqno), + lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg), + (u16_t)flags)); + + /* Now append seg to pcb->unsent queue */ + if (pcb->unsent == NULL) { + pcb->unsent = seg; + } else { + struct tcp_seg *useg; + for (useg = pcb->unsent; useg->next != NULL; useg = useg->next); + useg->next = seg; + } +#if TCP_OVERSIZE + /* The new unsent tail has no space */ + pcb->unsent_oversize = 0; +#endif /* TCP_OVERSIZE */ + + /* SYN and FIN bump the sequence number */ + if ((flags & TCP_SYN) || (flags & TCP_FIN)) { + pcb->snd_lbb++; + /* optlen does not influence snd_buf */ + } + if (flags & TCP_FIN) { + tcp_set_flags(pcb, TF_FIN); + } + + /* update number of segments on the queues */ + pcb->snd_queuelen += pbuf_clen(seg->p); + LWIP_DEBUGF(TCP_QLEN_DEBUG, ("tcp_enqueue_flags: %"S16_F" (after enqueued)\n", pcb->snd_queuelen)); + if (pcb->snd_queuelen != 0) { + LWIP_ASSERT("tcp_enqueue_flags: invalid queue length", + pcb->unacked != NULL || pcb->unsent != NULL); + } + + return ERR_OK; +} + +#if LWIP_TCP_TIMESTAMPS +/* Build a timestamp option (12 bytes long) at the specified options pointer) + * + * @param pcb tcp_pcb + * @param opts option pointer where to store the timestamp option + */ +static void +tcp_build_timestamp_option(const struct tcp_pcb *pcb, u32_t *opts) +{ + LWIP_ASSERT("tcp_build_timestamp_option: invalid pcb", pcb != NULL); + + /* Pad with two NOP options to make everything nicely aligned */ + opts[0] = PP_HTONL(0x0101080A); + opts[1] = lwip_htonl(sys_now()); + opts[2] = lwip_htonl(pcb->ts_recent); +} +#endif + +#if LWIP_TCP_SACK_OUT +/** + * Calculates the number of SACK entries that should be generated. + * It takes into account whether TF_SACK flag is set, + * the number of SACK entries in tcp_pcb that are valid, + * as well as the available options size. + * + * @param pcb tcp_pcb + * @param optlen the length of other TCP options (in bytes) + * @return the number of SACK ranges that can be used + */ +static u8_t +tcp_get_num_sacks(const struct tcp_pcb *pcb, u8_t optlen) +{ + u8_t num_sacks = 0; + + LWIP_ASSERT("tcp_get_num_sacks: invalid pcb", pcb != NULL); + + if (pcb->flags & TF_SACK) { + u8_t i; + + /* The first SACK takes up 12 bytes (it includes SACK header and two NOP options), + each additional one - 8 bytes. */ + optlen += 12; + + /* Max options size = 40, number of SACK array entries = LWIP_TCP_MAX_SACK_NUM */ + for (i = 0; (i < LWIP_TCP_MAX_SACK_NUM) && (optlen <= TCP_MAX_OPTION_BYTES) && + LWIP_TCP_SACK_VALID(pcb, i); ++i) { + ++num_sacks; + optlen += 8; + } + } + + return num_sacks; +} + +/** Build a SACK option (12 or more bytes long) at the specified options pointer) + * + * @param pcb tcp_pcb + * @param opts option pointer where to store the SACK option + * @param num_sacks the number of SACKs to store + */ +static void +tcp_build_sack_option(const struct tcp_pcb *pcb, u32_t *opts, u8_t num_sacks) +{ + u8_t i; + + LWIP_ASSERT("tcp_build_sack_option: invalid pcb", pcb != NULL); + LWIP_ASSERT("tcp_build_sack_option: invalid opts", opts != NULL); + + /* Pad with two NOP options to make everything nicely aligned. + We add the length (of just the SACK option, not the NOPs in front of it), + which is 2B of header, plus 8B for each SACK. */ + *(opts++) = PP_HTONL(0x01010500 + 2 + num_sacks * 8); + + for (i = 0; i < num_sacks; ++i) { + *(opts++) = lwip_htonl(pcb->rcv_sacks[i].left); + *(opts++) = lwip_htonl(pcb->rcv_sacks[i].right); + } +} + +#endif + +#if LWIP_WND_SCALE +/** Build a window scale option (3 bytes long) at the specified options pointer) + * + * @param opts option pointer where to store the window scale option + */ +static void +tcp_build_wnd_scale_option(u32_t *opts) +{ + LWIP_ASSERT("tcp_build_wnd_scale_option: invalid opts", opts != NULL); + + /* Pad with one NOP option to make everything nicely aligned */ + opts[0] = PP_HTONL(0x01030300 | TCP_RCV_SCALE); +} +#endif + +/** + * @ingroup tcp_raw + * Find out what we can send and send it + * + * @param pcb Protocol control block for the TCP connection to send data + * @return ERR_OK if data has been sent or nothing to send + * another err_t on error + */ +err_t +tcp_output(struct tcp_pcb *pcb) +{ + struct tcp_seg *seg, *useg; + u32_t wnd, snd_nxt; + err_t err; + struct netif *netif; +#if TCP_CWND_DEBUG + s16_t i = 0; +#endif /* TCP_CWND_DEBUG */ + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("tcp_output: invalid pcb", pcb != NULL); + /* pcb->state LISTEN not allowed here */ + LWIP_ASSERT("don't call tcp_output for listen-pcbs", + pcb->state != LISTEN); + + /* First, check if we are invoked by the TCP input processing + code. If so, we do not output anything. Instead, we rely on the + input processing code to call us when input processing is done + with. */ + if (tcp_input_pcb == pcb) { + return ERR_OK; + } + + wnd = LWIP_MIN(pcb->snd_wnd, pcb->cwnd); + + seg = pcb->unsent; + + if (seg == NULL) { + LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: nothing to send (%p)\n", + (void *)pcb->unsent)); + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"TCPWNDSIZE_F + ", cwnd %"TCPWNDSIZE_F", wnd %"U32_F + ", seg == NULL, ack %"U32_F"\n", + pcb->snd_wnd, pcb->cwnd, wnd, pcb->lastack)); + + /* If the TF_ACK_NOW flag is set and the ->unsent queue is empty, construct + * an empty ACK segment and send it. */ + if (pcb->flags & TF_ACK_NOW) { + return tcp_send_empty_ack(pcb); + } + /* nothing to send: shortcut out of here */ + goto output_done; + } else { + LWIP_DEBUGF(TCP_CWND_DEBUG, + ("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F + ", effwnd %"U32_F", seq %"U32_F", ack %"U32_F"\n", + pcb->snd_wnd, pcb->cwnd, wnd, + lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len, + lwip_ntohl(seg->tcphdr->seqno), pcb->lastack)); + } + + netif = tcp_route(pcb, &pcb->local_ip, &pcb->remote_ip); + if (netif == NULL) { + return ERR_RTE; + } + + /* If we don't have a local IP address, we get one from netif */ + if (ip_addr_isany(&pcb->local_ip)) { + const ip_addr_t *local_ip = ip_netif_get_local_ip(netif, &pcb->remote_ip); + if (local_ip == NULL) { + return ERR_RTE; + } + ip_addr_copy(pcb->local_ip, *local_ip); + } + + /* Handle the current segment not fitting within the window */ + if (lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len > wnd) { + /* We need to start the persistent timer when the next unsent segment does not fit + * within the remaining (could be 0) send window and RTO timer is not running (we + * have no in-flight data). If window is still too small after persist timer fires, + * then we split the segment. We don't consider the congestion window since a cwnd + * smaller than 1 SMSS implies in-flight data + */ + if (wnd == pcb->snd_wnd && pcb->unacked == NULL && pcb->persist_backoff == 0) { + pcb->persist_cnt = 0; + pcb->persist_backoff = 1; + pcb->persist_probe = 0; + } + /* We need an ACK, but can't send data now, so send an empty ACK */ + if (pcb->flags & TF_ACK_NOW) { + return tcp_send_empty_ack(pcb); + } + goto output_done; + } + /* Stop persist timer, above conditions are not active */ + pcb->persist_backoff = 0; + + /* useg should point to last segment on unacked queue */ + useg = pcb->unacked; + if (useg != NULL) { + for (; useg->next != NULL; useg = useg->next); + } + /* data available and window allows it to be sent? */ + while (seg != NULL && + lwip_ntohl(seg->tcphdr->seqno) - pcb->lastack + seg->len <= wnd) { + LWIP_ASSERT("RST not expected here!", + (TCPH_FLAGS(seg->tcphdr) & TCP_RST) == 0); + /* Stop sending if the nagle algorithm would prevent it + * Don't stop: + * - if tcp_write had a memory error before (prevent delayed ACK timeout) or + * - if FIN was already enqueued for this PCB (SYN is always alone in a segment - + * either seg->next != NULL or pcb->unacked == NULL; + * RST is no sent using tcp_write/tcp_output. + */ + if ((tcp_do_output_nagle(pcb) == 0) && + ((pcb->flags & (TF_NAGLEMEMERR | TF_FIN)) == 0)) { + break; + } +#if TCP_CWND_DEBUG + LWIP_DEBUGF(TCP_CWND_DEBUG, ("tcp_output: snd_wnd %"TCPWNDSIZE_F", cwnd %"TCPWNDSIZE_F", wnd %"U32_F", effwnd %"U32_F", seq %"U32_F", ack %"U32_F", i %"S16_F"\n", + pcb->snd_wnd, pcb->cwnd, wnd, + lwip_ntohl(seg->tcphdr->seqno) + seg->len - + pcb->lastack, + lwip_ntohl(seg->tcphdr->seqno), pcb->lastack, i)); + ++i; +#endif /* TCP_CWND_DEBUG */ + + if (pcb->state != SYN_SENT) { + TCPH_SET_FLAG(seg->tcphdr, TCP_ACK); + } + + err = tcp_output_segment(seg, pcb, netif); + if (err != ERR_OK) { + /* segment could not be sent, for whatever reason */ + tcp_set_flags(pcb, TF_NAGLEMEMERR); + return err; + } +#if TCP_OVERSIZE_DBGCHECK + seg->oversize_left = 0; +#endif /* TCP_OVERSIZE_DBGCHECK */ + pcb->unsent = seg->next; + if (pcb->state != SYN_SENT) { + tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); + } + snd_nxt = lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg); + if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) { + pcb->snd_nxt = snd_nxt; + } + /* put segment on unacknowledged list if length > 0 */ + if (TCP_TCPLEN(seg) > 0) { + seg->next = NULL; + /* unacked list is empty? */ + if (pcb->unacked == NULL) { + pcb->unacked = seg; + useg = seg; + /* unacked list is not empty? */ + } else { + /* In the case of fast retransmit, the packet should not go to the tail + * of the unacked queue, but rather somewhere before it. We need to check for + * this case. -STJ Jul 27, 2004 */ + if (TCP_SEQ_LT(lwip_ntohl(seg->tcphdr->seqno), lwip_ntohl(useg->tcphdr->seqno))) { + /* add segment to before tail of unacked list, keeping the list sorted */ + struct tcp_seg **cur_seg = &(pcb->unacked); + while (*cur_seg && + TCP_SEQ_LT(lwip_ntohl((*cur_seg)->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno))) { + cur_seg = &((*cur_seg)->next ); + } + seg->next = (*cur_seg); + (*cur_seg) = seg; + } else { + /* add segment to tail of unacked list */ + useg->next = seg; + useg = useg->next; + } + } + /* do not queue empty segments on the unacked list */ + } else { + tcp_seg_free(seg); + } + seg = pcb->unsent; + } +#if TCP_OVERSIZE + if (pcb->unsent == NULL) { + /* last unsent has been removed, reset unsent_oversize */ + pcb->unsent_oversize = 0; + } +#endif /* TCP_OVERSIZE */ + +output_done: + tcp_clear_flags(pcb, TF_NAGLEMEMERR); + return ERR_OK; +} + +/** Check if a segment's pbufs are used by someone else than TCP. + * This can happen on retransmission if the pbuf of this segment is still + * referenced by the netif driver due to deferred transmission. + * This is the case (only!) if someone down the TX call path called + * pbuf_ref() on one of the pbufs! + * + * @arg seg the tcp segment to check + * @return 1 if ref != 1, 0 if ref == 1 + */ +static int +tcp_output_segment_busy(const struct tcp_seg *seg) +{ + LWIP_ASSERT("tcp_output_segment_busy: invalid seg", seg != NULL); + + /* We only need to check the first pbuf here: + If a pbuf is queued for transmission, a driver calls pbuf_ref(), + which only changes the ref count of the first pbuf */ + if (seg->p->ref != 1) { + /* other reference found */ + return 1; + } + /* no other references found */ + return 0; +} + +/** + * Called by tcp_output() to actually send a TCP segment over IP. + * + * @param seg the tcp_seg to send + * @param pcb the tcp_pcb for the TCP connection used to send the segment + * @param netif the netif used to send the segment + */ +static err_t +tcp_output_segment(struct tcp_seg *seg, struct tcp_pcb *pcb, struct netif *netif) +{ + err_t err; + u16_t len; + u32_t *opts; +#if TCP_CHECKSUM_ON_COPY + int seg_chksum_was_swapped = 0; +#endif + + LWIP_ASSERT("tcp_output_segment: invalid seg", seg != NULL); + LWIP_ASSERT("tcp_output_segment: invalid pcb", pcb != NULL); + LWIP_ASSERT("tcp_output_segment: invalid netif", netif != NULL); + + if (tcp_output_segment_busy(seg)) { + /* This should not happen: rexmit functions should have checked this. + However, since this function modifies p->len, we must not continue in this case. */ + LWIP_DEBUGF(TCP_RTO_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("tcp_output_segment: segment busy\n")); + return ERR_OK; + } + + /* The TCP header has already been constructed, but the ackno and + wnd fields remain. */ + seg->tcphdr->ackno = lwip_htonl(pcb->rcv_nxt); + + /* advertise our receive window size in this TCP segment */ +#if LWIP_WND_SCALE + if (seg->flags & TF_SEG_OPTS_WND_SCALE) { + /* The Window field in a SYN segment itself (the only type where we send + the window scale option) is never scaled. */ + seg->tcphdr->wnd = lwip_htons(TCPWND_MIN16(pcb->rcv_ann_wnd)); + } else +#endif /* LWIP_WND_SCALE */ + { + seg->tcphdr->wnd = lwip_htons(TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd))); + } + + pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd; + + /* Add any requested options. NB MSS option is only set on SYN + packets, so ignore it here */ + /* cast through void* to get rid of alignment warnings */ + opts = (u32_t *)(void *)(seg->tcphdr + 1); + if (seg->flags & TF_SEG_OPTS_MSS) { + u16_t mss; +#if TCP_CALCULATE_EFF_SEND_MSS + mss = tcp_eff_send_mss_netif(TCP_MSS, netif, &pcb->remote_ip); +#else /* TCP_CALCULATE_EFF_SEND_MSS */ + mss = TCP_MSS; +#endif /* TCP_CALCULATE_EFF_SEND_MSS */ + *opts = TCP_BUILD_MSS_OPTION(mss); + opts += 1; + } +#if LWIP_TCP_TIMESTAMPS + pcb->ts_lastacksent = pcb->rcv_nxt; + + if (seg->flags & TF_SEG_OPTS_TS) { + tcp_build_timestamp_option(pcb, opts); + opts += 3; + } +#endif +#if LWIP_WND_SCALE + if (seg->flags & TF_SEG_OPTS_WND_SCALE) { + tcp_build_wnd_scale_option(opts); + opts += 1; + } +#endif +#if LWIP_TCP_SACK_OUT + if (seg->flags & TF_SEG_OPTS_SACK_PERM) { + /* Pad with two NOP options to make everything nicely aligned + * NOTE: When we send both timestamp and SACK_PERM options, + * we could use the first two NOPs before the timestamp to store SACK_PERM option, + * but that would complicate the code. + */ + *(opts++) = PP_HTONL(0x01010402); + } +#endif + + /* Set retransmission timer running if it is not currently enabled + This must be set before checking the route. */ + if (pcb->rtime < 0) { + pcb->rtime = 0; + } + + if (pcb->rttest == 0) { + pcb->rttest = tcp_ticks; + pcb->rtseq = lwip_ntohl(seg->tcphdr->seqno); + + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_output_segment: rtseq %"U32_F"\n", pcb->rtseq)); + } + LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output_segment: %"U32_F":%"U32_F"\n", + lwip_htonl(seg->tcphdr->seqno), lwip_htonl(seg->tcphdr->seqno) + + seg->len)); + + len = (u16_t)((u8_t *)seg->tcphdr - (u8_t *)seg->p->payload); + if (len == 0) { + /** Exclude retransmitted segments from this count. */ + MIB2_STATS_INC(mib2.tcpoutsegs); + } + + seg->p->len -= len; + seg->p->tot_len -= len; + + seg->p->payload = seg->tcphdr; + + seg->tcphdr->chksum = 0; + +#ifdef LWIP_HOOK_TCP_OUT_ADD_TCPOPTS + opts = LWIP_HOOK_TCP_OUT_ADD_TCPOPTS(seg->p, seg->tcphdr, pcb, opts); +#endif + LWIP_ASSERT("options not filled", (u8_t *)opts == ((u8_t *)(seg->tcphdr + 1)) + LWIP_TCP_OPT_LENGTH_SEGMENT(seg->flags, pcb)); + +#if CHECKSUM_GEN_TCP + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_TCP) { +#if TCP_CHECKSUM_ON_COPY + u32_t acc; +#if TCP_CHECKSUM_ON_COPY_SANITY_CHECK + u16_t chksum_slow = ip_chksum_pseudo(seg->p, IP_PROTO_TCP, + seg->p->tot_len, &pcb->local_ip, &pcb->remote_ip); +#endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */ + if ((seg->flags & TF_SEG_DATA_CHECKSUMMED) == 0) { + LWIP_ASSERT("data included but not checksummed", + seg->p->tot_len == TCPH_HDRLEN_BYTES(seg->tcphdr)); + } + + /* rebuild TCP header checksum (TCP header changes for retransmissions!) */ + acc = ip_chksum_pseudo_partial(seg->p, IP_PROTO_TCP, + seg->p->tot_len, TCPH_HDRLEN_BYTES(seg->tcphdr), &pcb->local_ip, &pcb->remote_ip); + /* add payload checksum */ + if (seg->chksum_swapped) { + seg_chksum_was_swapped = 1; + seg->chksum = SWAP_BYTES_IN_WORD(seg->chksum); + seg->chksum_swapped = 0; + } + acc = (u16_t)~acc + seg->chksum; + seg->tcphdr->chksum = (u16_t)~FOLD_U32T(acc); +#if TCP_CHECKSUM_ON_COPY_SANITY_CHECK + if (chksum_slow != seg->tcphdr->chksum) { + TCP_CHECKSUM_ON_COPY_SANITY_CHECK_FAIL( + ("tcp_output_segment: calculated checksum is %"X16_F" instead of %"X16_F"\n", + seg->tcphdr->chksum, chksum_slow)); + seg->tcphdr->chksum = chksum_slow; + } +#endif /* TCP_CHECKSUM_ON_COPY_SANITY_CHECK */ +#else /* TCP_CHECKSUM_ON_COPY */ + seg->tcphdr->chksum = ip_chksum_pseudo(seg->p, IP_PROTO_TCP, + seg->p->tot_len, &pcb->local_ip, &pcb->remote_ip); +#endif /* TCP_CHECKSUM_ON_COPY */ + } +#endif /* CHECKSUM_GEN_TCP */ + TCP_STATS_INC(tcp.xmit); + + NETIF_SET_HINTS(netif, &(pcb->netif_hints)); + err = ip_output_if(seg->p, &pcb->local_ip, &pcb->remote_ip, pcb->ttl, + pcb->tos, IP_PROTO_TCP, netif); + NETIF_RESET_HINTS(netif); + +#if TCP_CHECKSUM_ON_COPY + if (seg_chksum_was_swapped) { + /* if data is added to this segment later, chksum needs to be swapped, + so restore this now */ + seg->chksum = SWAP_BYTES_IN_WORD(seg->chksum); + seg->chksum_swapped = 1; + } +#endif + + return err; +} + +/** + * Requeue all unacked segments for retransmission + * + * Called by tcp_slowtmr() for slow retransmission. + * + * @param pcb the tcp_pcb for which to re-enqueue all unacked segments + */ +err_t +tcp_rexmit_rto_prepare(struct tcp_pcb *pcb) +{ + struct tcp_seg *seg; + + LWIP_ASSERT("tcp_rexmit_rto_prepare: invalid pcb", pcb != NULL); + + if (pcb->unacked == NULL) { + return ERR_VAL; + } + + /* Move all unacked segments to the head of the unsent queue. + However, give up if any of the unsent pbufs are still referenced by the + netif driver due to deferred transmission. No point loading the link further + if it is struggling to flush its buffered writes. */ + for (seg = pcb->unacked; seg->next != NULL; seg = seg->next) { + if (tcp_output_segment_busy(seg)) { + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_rexmit_rto: segment busy\n")); + return ERR_VAL; + } + } + if (tcp_output_segment_busy(seg)) { + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_rexmit_rto: segment busy\n")); + return ERR_VAL; + } + /* concatenate unsent queue after unacked queue */ + seg->next = pcb->unsent; +#if TCP_OVERSIZE_DBGCHECK + /* if last unsent changed, we need to update unsent_oversize */ + if (pcb->unsent == NULL) { + pcb->unsent_oversize = seg->oversize_left; + } +#endif /* TCP_OVERSIZE_DBGCHECK */ + /* unsent queue is the concatenated queue (of unacked, unsent) */ + pcb->unsent = pcb->unacked; + /* unacked queue is now empty */ + pcb->unacked = NULL; + + /* Mark RTO in-progress */ + tcp_set_flags(pcb, TF_RTO); + /* Record the next byte following retransmit */ + pcb->rto_end = lwip_ntohl(seg->tcphdr->seqno) + TCP_TCPLEN(seg); + /* Don't take any RTT measurements after retransmitting. */ + pcb->rttest = 0; + + return ERR_OK; +} + +/** + * Requeue all unacked segments for retransmission + * + * Called by tcp_slowtmr() for slow retransmission. + * + * @param pcb the tcp_pcb for which to re-enqueue all unacked segments + */ +void +tcp_rexmit_rto_commit(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_rexmit_rto_commit: invalid pcb", pcb != NULL); + + /* increment number of retransmissions */ + if (pcb->nrtx < 0xFF) { + ++pcb->nrtx; + } + /* Do the actual retransmission */ + tcp_output(pcb); +} + +/** + * Requeue all unacked segments for retransmission + * + * Called by tcp_process() only, tcp_slowtmr() needs to do some things between + * "prepare" and "commit". + * + * @param pcb the tcp_pcb for which to re-enqueue all unacked segments + */ +void +tcp_rexmit_rto(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_rexmit_rto: invalid pcb", pcb != NULL); + + if (tcp_rexmit_rto_prepare(pcb) == ERR_OK) { + tcp_rexmit_rto_commit(pcb); + } +} + +/** + * Requeue the first unacked segment for retransmission + * + * Called by tcp_receive() for fast retransmit. + * + * @param pcb the tcp_pcb for which to retransmit the first unacked segment + */ +err_t +tcp_rexmit(struct tcp_pcb *pcb) +{ + struct tcp_seg *seg; + struct tcp_seg **cur_seg; + + LWIP_ASSERT("tcp_rexmit: invalid pcb", pcb != NULL); + + if (pcb->unacked == NULL) { + return ERR_VAL; + } + + seg = pcb->unacked; + + /* Give up if the segment is still referenced by the netif driver + due to deferred transmission. */ + if (tcp_output_segment_busy(seg)) { + LWIP_DEBUGF(TCP_RTO_DEBUG, ("tcp_rexmit busy\n")); + return ERR_VAL; + } + + /* Move the first unacked segment to the unsent queue */ + /* Keep the unsent queue sorted. */ + pcb->unacked = seg->next; + + cur_seg = &(pcb->unsent); + while (*cur_seg && + TCP_SEQ_LT(lwip_ntohl((*cur_seg)->tcphdr->seqno), lwip_ntohl(seg->tcphdr->seqno))) { + cur_seg = &((*cur_seg)->next ); + } + seg->next = *cur_seg; + *cur_seg = seg; +#if TCP_OVERSIZE + if (seg->next == NULL) { + /* the retransmitted segment is last in unsent, so reset unsent_oversize */ + pcb->unsent_oversize = 0; + } +#endif /* TCP_OVERSIZE */ + + if (pcb->nrtx < 0xFF) { + ++pcb->nrtx; + } + + /* Don't take any rtt measurements after retransmitting. */ + pcb->rttest = 0; + + /* Do the actual retransmission. */ + MIB2_STATS_INC(mib2.tcpretranssegs); + /* No need to call tcp_output: we are always called from tcp_input() + and thus tcp_output directly returns. */ + return ERR_OK; +} + + +/** + * Handle retransmission after three dupacks received + * + * @param pcb the tcp_pcb for which to retransmit the first unacked segment + */ +void +tcp_rexmit_fast(struct tcp_pcb *pcb) +{ + LWIP_ASSERT("tcp_rexmit_fast: invalid pcb", pcb != NULL); + + if (pcb->unacked != NULL && !(pcb->flags & TF_INFR)) { + /* This is fast retransmit. Retransmit the first unacked segment. */ + LWIP_DEBUGF(TCP_FR_DEBUG, + ("tcp_receive: dupacks %"U16_F" (%"U32_F + "), fast retransmit %"U32_F"\n", + (u16_t)pcb->dupacks, pcb->lastack, + lwip_ntohl(pcb->unacked->tcphdr->seqno))); + if (tcp_rexmit(pcb) == ERR_OK) { + /* Set ssthresh to half of the minimum of the current + * cwnd and the advertised window */ + pcb->ssthresh = LWIP_MIN(pcb->cwnd, pcb->snd_wnd) / 2; + + /* The minimum value for ssthresh should be 2 MSS */ + if (pcb->ssthresh < (2U * pcb->mss)) { + LWIP_DEBUGF(TCP_FR_DEBUG, + ("tcp_receive: The minimum value for ssthresh %"TCPWNDSIZE_F + " should be min 2 mss %"U16_F"...\n", + pcb->ssthresh, (u16_t)(2 * pcb->mss))); + pcb->ssthresh = 2 * pcb->mss; + } + + pcb->cwnd = pcb->ssthresh + 3 * pcb->mss; + tcp_set_flags(pcb, TF_INFR); + + /* Reset the retransmission timer to prevent immediate rto retransmissions */ + pcb->rtime = 0; + } + } +} + +static struct pbuf * +tcp_output_alloc_header_common(u32_t ackno, u16_t optlen, u16_t datalen, + u32_t seqno_be /* already in network byte order */, + u16_t src_port, u16_t dst_port, u8_t flags, u16_t wnd) +{ + struct tcp_hdr *tcphdr; + struct pbuf *p; + + p = pbuf_alloc(PBUF_IP, TCP_HLEN + optlen + datalen, PBUF_RAM); + if (p != NULL) { + LWIP_ASSERT("check that first pbuf can hold struct tcp_hdr", + (p->len >= TCP_HLEN + optlen)); + tcphdr = (struct tcp_hdr *)p->payload; + tcphdr->src = lwip_htons(src_port); + tcphdr->dest = lwip_htons(dst_port); + tcphdr->seqno = seqno_be; + tcphdr->ackno = lwip_htonl(ackno); + TCPH_HDRLEN_FLAGS_SET(tcphdr, (5 + optlen / 4), flags); + tcphdr->wnd = lwip_htons(wnd); + tcphdr->chksum = 0; + tcphdr->urgp = 0; + } + return p; +} + +/** Allocate a pbuf and create a tcphdr at p->payload, used for output + * functions other than the default tcp_output -> tcp_output_segment + * (e.g. tcp_send_empty_ack, etc.) + * + * @param pcb tcp pcb for which to send a packet (used to initialize tcp_hdr) + * @param optlen length of header-options + * @param datalen length of tcp data to reserve in pbuf + * @param seqno_be seqno in network byte order (big-endian) + * @return pbuf with p->payload being the tcp_hdr + */ +static struct pbuf * +tcp_output_alloc_header(struct tcp_pcb *pcb, u16_t optlen, u16_t datalen, + u32_t seqno_be /* already in network byte order */) +{ + struct pbuf *p; + + LWIP_ASSERT("tcp_output_alloc_header: invalid pcb", pcb != NULL); + + p = tcp_output_alloc_header_common(pcb->rcv_nxt, optlen, datalen, + seqno_be, pcb->local_port, pcb->remote_port, TCP_ACK, + TCPWND_MIN16(RCV_WND_SCALE(pcb, pcb->rcv_ann_wnd))); + if (p != NULL) { + /* If we're sending a packet, update the announced right window edge */ + pcb->rcv_ann_right_edge = pcb->rcv_nxt + pcb->rcv_ann_wnd; + } + return p; +} + +/* Fill in options for control segments */ +static void +tcp_output_fill_options(const struct tcp_pcb *pcb, struct pbuf *p, u8_t optflags, u8_t num_sacks) +{ + struct tcp_hdr *tcphdr; + u32_t *opts; + u16_t sacks_len = 0; + + LWIP_ASSERT("tcp_output_fill_options: invalid pbuf", p != NULL); + + tcphdr = (struct tcp_hdr *)p->payload; + opts = (u32_t *)(void *)(tcphdr + 1); + + /* NB. MSS and window scale options are only sent on SYNs, so ignore them here */ + +#if LWIP_TCP_TIMESTAMPS + if (optflags & TF_SEG_OPTS_TS) { + tcp_build_timestamp_option(pcb, opts); + opts += 3; + } +#endif + +#if LWIP_TCP_SACK_OUT + if (pcb && (num_sacks > 0)) { + tcp_build_sack_option(pcb, opts, num_sacks); + /* 1 word for SACKs header (including 2xNOP), and 2 words for each SACK */ + sacks_len = 1 + num_sacks * 2; + opts += sacks_len; + } +#else + LWIP_UNUSED_ARG(num_sacks); +#endif + +#ifdef LWIP_HOOK_TCP_OUT_ADD_TCPOPTS + opts = LWIP_HOOK_TCP_OUT_ADD_TCPOPTS(p, tcphdr, pcb, opts); +#endif + + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(sacks_len); + LWIP_ASSERT("options not filled", (u8_t *)opts == ((u8_t *)(tcphdr + 1)) + sacks_len * 4 + LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb)); + LWIP_UNUSED_ARG(optflags); /* for LWIP_NOASSERT */ + LWIP_UNUSED_ARG(opts); /* for LWIP_NOASSERT */ +} + +/** Output a control segment pbuf to IP. + * + * Called from tcp_rst, tcp_send_empty_ack, tcp_keepalive and tcp_zero_window_probe, + * this function combines selecting a netif for transmission, generating the tcp + * header checksum and calling ip_output_if while handling netif hints and stats. + */ +static err_t +tcp_output_control_segment(const struct tcp_pcb *pcb, struct pbuf *p, + const ip_addr_t *src, const ip_addr_t *dst) +{ + err_t err; + struct netif *netif; + + LWIP_ASSERT("tcp_output_control_segment: invalid pbuf", p != NULL); + + netif = tcp_route(pcb, src, dst); + if (netif == NULL) { + err = ERR_RTE; + } else { + u8_t ttl, tos; +#if CHECKSUM_GEN_TCP + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_TCP) { + struct tcp_hdr *tcphdr = (struct tcp_hdr *)p->payload; + tcphdr->chksum = ip_chksum_pseudo(p, IP_PROTO_TCP, p->tot_len, + src, dst); + } +#endif + if (pcb != NULL) { + NETIF_SET_HINTS(netif, LWIP_CONST_CAST(struct netif_hint*, &(pcb->netif_hints))); + ttl = pcb->ttl; + tos = pcb->tos; + } else { + /* Send output with hardcoded TTL/HL since we have no access to the pcb */ + ttl = TCP_TTL; + tos = 0; + } + TCP_STATS_INC(tcp.xmit); + err = ip_output_if(p, src, dst, ttl, tos, IP_PROTO_TCP, netif); + NETIF_RESET_HINTS(netif); + } + pbuf_free(p); + return err; +} + +/** + * Send a TCP RESET packet (empty segment with RST flag set) either to + * abort a connection or to show that there is no matching local connection + * for a received segment. + * + * Called by tcp_abort() (to abort a local connection), tcp_input() (if no + * matching local pcb was found), tcp_listen_input() (if incoming segment + * has ACK flag set) and tcp_process() (received segment in the wrong state) + * + * Since a RST segment is in most cases not sent for an active connection, + * tcp_rst() has a number of arguments that are taken from a tcp_pcb for + * most other segment output functions. + * + * @param pcb TCP pcb (may be NULL if no pcb is available) + * @param seqno the sequence number to use for the outgoing segment + * @param ackno the acknowledge number to use for the outgoing segment + * @param local_ip the local IP address to send the segment from + * @param remote_ip the remote IP address to send the segment to + * @param local_port the local TCP port to send the segment from + * @param remote_port the remote TCP port to send the segment to + */ +void +tcp_rst(const struct tcp_pcb *pcb, u32_t seqno, u32_t ackno, + const ip_addr_t *local_ip, const ip_addr_t *remote_ip, + u16_t local_port, u16_t remote_port) +{ + struct pbuf *p; + u16_t wnd; + u8_t optlen; + + LWIP_ASSERT("tcp_rst: invalid local_ip", local_ip != NULL); + LWIP_ASSERT("tcp_rst: invalid remote_ip", remote_ip != NULL); + + optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); + +#if LWIP_WND_SCALE + wnd = PP_HTONS(((TCP_WND >> TCP_RCV_SCALE) & 0xFFFF)); +#else + wnd = PP_HTONS(TCP_WND); +#endif + + p = tcp_output_alloc_header_common(ackno, optlen, 0, lwip_htonl(seqno), local_port, + remote_port, TCP_RST | TCP_ACK, wnd); + if (p == NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_rst: could not allocate memory for pbuf\n")); + return; + } + tcp_output_fill_options(pcb, p, 0, optlen); + + MIB2_STATS_INC(mib2.tcpoutrsts); + + tcp_output_control_segment(pcb, p, local_ip, remote_ip); + LWIP_DEBUGF(TCP_RST_DEBUG, ("tcp_rst: seqno %"U32_F" ackno %"U32_F".\n", seqno, ackno)); +} + +/** + * Send an ACK without data. + * + * @param pcb Protocol control block for the TCP connection to send the ACK + */ +err_t +tcp_send_empty_ack(struct tcp_pcb *pcb) +{ + err_t err; + struct pbuf *p; + u8_t optlen, optflags = 0; + u8_t num_sacks = 0; + + LWIP_ASSERT("tcp_send_empty_ack: invalid pcb", pcb != NULL); + +#if LWIP_TCP_TIMESTAMPS + if (pcb->flags & TF_TIMESTAMP) { + optflags = TF_SEG_OPTS_TS; + } +#endif + optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(optflags, pcb); + +#if LWIP_TCP_SACK_OUT + /* For now, SACKs are only sent with empty ACKs */ + if ((num_sacks = tcp_get_num_sacks(pcb, optlen)) > 0) { + optlen += 4 + num_sacks * 8; /* 4 bytes for header (including 2*NOP), plus 8B for each SACK */ + } +#endif + + p = tcp_output_alloc_header(pcb, optlen, 0, lwip_htonl(pcb->snd_nxt)); + if (p == NULL) { + /* let tcp_fasttmr retry sending this ACK */ + tcp_set_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); + LWIP_DEBUGF(TCP_OUTPUT_DEBUG, ("tcp_output: (ACK) could not allocate pbuf\n")); + return ERR_BUF; + } + tcp_output_fill_options(pcb, p, optflags, num_sacks); + +#if LWIP_TCP_TIMESTAMPS + pcb->ts_lastacksent = pcb->rcv_nxt; +#endif + + LWIP_DEBUGF(TCP_OUTPUT_DEBUG, + ("tcp_output: sending ACK for %"U32_F"\n", pcb->rcv_nxt)); + err = tcp_output_control_segment(pcb, p, &pcb->local_ip, &pcb->remote_ip); + if (err != ERR_OK) { + /* let tcp_fasttmr retry sending this ACK */ + tcp_set_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); + } else { + /* remove ACK flags from the PCB, as we sent an empty ACK now */ + tcp_clear_flags(pcb, TF_ACK_DELAY | TF_ACK_NOW); + } + + return err; +} + +/** + * Send keepalive packets to keep a connection active although + * no data is sent over it. + * + * Called by tcp_slowtmr() + * + * @param pcb the tcp_pcb for which to send a keepalive packet + */ +err_t +tcp_keepalive(struct tcp_pcb *pcb) +{ + err_t err; + struct pbuf *p; + u8_t optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); + + LWIP_ASSERT("tcp_keepalive: invalid pcb", pcb != NULL); + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: sending KEEPALIVE probe to ")); + ip_addr_debug_print_val(TCP_DEBUG, pcb->remote_ip); + LWIP_DEBUGF(TCP_DEBUG, ("\n")); + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: tcp_ticks %"U32_F" pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", + tcp_ticks, pcb->tmr, (u16_t)pcb->keep_cnt_sent)); + + p = tcp_output_alloc_header(pcb, optlen, 0, lwip_htonl(pcb->snd_nxt - 1)); + if (p == NULL) { + LWIP_DEBUGF(TCP_DEBUG, + ("tcp_keepalive: could not allocate memory for pbuf\n")); + return ERR_MEM; + } + tcp_output_fill_options(pcb, p, 0, optlen); + err = tcp_output_control_segment(pcb, p, &pcb->local_ip, &pcb->remote_ip); + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_keepalive: seqno %"U32_F" ackno %"U32_F" err %d.\n", + pcb->snd_nxt - 1, pcb->rcv_nxt, (int)err)); + return err; +} + +/** + * Send persist timer zero-window probes to keep a connection active + * when a window update is lost. + * + * Called by tcp_slowtmr() + * + * @param pcb the tcp_pcb for which to send a zero-window probe packet + */ +err_t +tcp_zero_window_probe(struct tcp_pcb *pcb) +{ + err_t err; + struct pbuf *p; + struct tcp_hdr *tcphdr; + struct tcp_seg *seg; + u16_t len; + u8_t is_fin; + u32_t snd_nxt; + u8_t optlen = LWIP_TCP_OPT_LENGTH_SEGMENT(0, pcb); + + LWIP_ASSERT("tcp_zero_window_probe: invalid pcb", pcb != NULL); + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: sending ZERO WINDOW probe to ")); + ip_addr_debug_print_val(TCP_DEBUG, pcb->remote_ip); + LWIP_DEBUGF(TCP_DEBUG, ("\n")); + + LWIP_DEBUGF(TCP_DEBUG, + ("tcp_zero_window_probe: tcp_ticks %"U32_F + " pcb->tmr %"U32_F" pcb->keep_cnt_sent %"U16_F"\n", + tcp_ticks, pcb->tmr, (u16_t)pcb->keep_cnt_sent)); + + /* Only consider unsent, persist timer should be off when there is data in-flight */ + seg = pcb->unsent; + if (seg == NULL) { + /* Not expected, persist timer should be off when the send buffer is empty */ + return ERR_OK; + } + + /* increment probe count. NOTE: we record probe even if it fails + to actually transmit due to an error. This ensures memory exhaustion/ + routing problem doesn't leave a zero-window pcb as an indefinite zombie. + RTO mechanism has similar behavior, see pcb->nrtx */ + if (pcb->persist_probe < 0xFF) { + ++pcb->persist_probe; + } + + is_fin = ((TCPH_FLAGS(seg->tcphdr) & TCP_FIN) != 0) && (seg->len == 0); + /* we want to send one seqno: either FIN or data (no options) */ + len = is_fin ? 0 : 1; + + p = tcp_output_alloc_header(pcb, optlen, len, seg->tcphdr->seqno); + if (p == NULL) { + LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: no memory for pbuf\n")); + return ERR_MEM; + } + tcphdr = (struct tcp_hdr *)p->payload; + + if (is_fin) { + /* FIN segment, no data */ + TCPH_FLAGS_SET(tcphdr, TCP_ACK | TCP_FIN); + } else { + /* Data segment, copy in one byte from the head of the unacked queue */ + char *d = ((char *)p->payload + TCP_HLEN); + /* Depending on whether the segment has already been sent (unacked) or not + (unsent), seg->p->payload points to the IP header or TCP header. + Ensure we copy the first TCP data byte: */ + pbuf_copy_partial(seg->p, d, 1, seg->p->tot_len - seg->len); + } + + /* The byte may be acknowledged without the window being opened. */ + snd_nxt = lwip_ntohl(seg->tcphdr->seqno) + 1; + if (TCP_SEQ_LT(pcb->snd_nxt, snd_nxt)) { + pcb->snd_nxt = snd_nxt; + } + tcp_output_fill_options(pcb, p, 0, optlen); + + err = tcp_output_control_segment(pcb, p, &pcb->local_ip, &pcb->remote_ip); + + LWIP_DEBUGF(TCP_DEBUG, ("tcp_zero_window_probe: seqno %"U32_F + " ackno %"U32_F" err %d.\n", + pcb->snd_nxt - 1, pcb->rcv_nxt, (int)err)); + return err; +} +#endif /* LWIP_TCP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/timeouts.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/timeouts.c index c3431e89..f37acfec 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/timeouts.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/timeouts.c @@ -1,451 +1,451 @@ -/** - * @file - * Stack-internal timers implementation. - * This file includes timer callbacks for stack-internal timers as well as - * functions to set up or stop timers and check for expired timers. - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * Simon Goldschmidt - * - */ - -#include "lwip/opt.h" - -#include "lwip/timeouts.h" -#include "lwip/priv/tcp_priv.h" - -#include "lwip/def.h" -#include "lwip/memp.h" -#include "lwip/priv/tcpip_priv.h" - -#include "lwip/ip4_frag.h" -#include "lwip/etharp.h" -#include "lwip/dhcp.h" -#include "lwip/autoip.h" -#include "lwip/igmp.h" -#include "lwip/dns.h" -#include "lwip/nd6.h" -#include "lwip/ip6_frag.h" -#include "lwip/mld6.h" -#include "lwip/dhcp6.h" -#include "lwip/sys.h" -#include "lwip/pbuf.h" - -#if LWIP_DEBUG_TIMERNAMES -#define HANDLER(x) x, #x -#else /* LWIP_DEBUG_TIMERNAMES */ -#define HANDLER(x) x -#endif /* LWIP_DEBUG_TIMERNAMES */ - -#define LWIP_MAX_TIMEOUT 0x7fffffff - -/* Check if timer's expiry time is greater than time and care about u32_t wraparounds */ -#define TIME_LESS_THAN(t, compare_to) ( (((u32_t)((t)-(compare_to))) > LWIP_MAX_TIMEOUT) ? 1 : 0 ) - -/** This array contains all stack-internal cyclic timers. To get the number of - * timers, use LWIP_ARRAYSIZE() */ -const struct lwip_cyclic_timer lwip_cyclic_timers[] = { -#if LWIP_TCP - /* The TCP timer is a special case: it does not have to run always and - is triggered to start from TCP using tcp_timer_needed() */ - {TCP_TMR_INTERVAL, HANDLER(tcp_tmr)}, -#endif /* LWIP_TCP */ -#if LWIP_IPV4 -#if IP_REASSEMBLY - {IP_TMR_INTERVAL, HANDLER(ip_reass_tmr)}, -#endif /* IP_REASSEMBLY */ -#if LWIP_ARP - {ARP_TMR_INTERVAL, HANDLER(etharp_tmr)}, -#endif /* LWIP_ARP */ -#if LWIP_DHCP - {DHCP_COARSE_TIMER_MSECS, HANDLER(dhcp_coarse_tmr)}, - {DHCP_FINE_TIMER_MSECS, HANDLER(dhcp_fine_tmr)}, -#endif /* LWIP_DHCP */ -#if LWIP_AUTOIP - {AUTOIP_TMR_INTERVAL, HANDLER(autoip_tmr)}, -#endif /* LWIP_AUTOIP */ -#if LWIP_IGMP - {IGMP_TMR_INTERVAL, HANDLER(igmp_tmr)}, -#endif /* LWIP_IGMP */ -#endif /* LWIP_IPV4 */ -#if LWIP_DNS - {DNS_TMR_INTERVAL, HANDLER(dns_tmr)}, -#endif /* LWIP_DNS */ -#if LWIP_IPV6 - {ND6_TMR_INTERVAL, HANDLER(nd6_tmr)}, -#if LWIP_IPV6_REASS - {IP6_REASS_TMR_INTERVAL, HANDLER(ip6_reass_tmr)}, -#endif /* LWIP_IPV6_REASS */ -#if LWIP_IPV6_MLD - {MLD6_TMR_INTERVAL, HANDLER(mld6_tmr)}, -#endif /* LWIP_IPV6_MLD */ -#if LWIP_IPV6_DHCP6 - {DHCP6_TIMER_MSECS, HANDLER(dhcp6_tmr)}, -#endif /* LWIP_IPV6_DHCP6 */ -#endif /* LWIP_IPV6 */ -}; -const int lwip_num_cyclic_timers = LWIP_ARRAYSIZE(lwip_cyclic_timers); - -#if LWIP_TIMERS && !LWIP_TIMERS_CUSTOM - -/** The one and only timeout list */ -static struct sys_timeo *next_timeout; - -static u32_t current_timeout_due_time; - -#if LWIP_TESTMODE -struct sys_timeo** -sys_timeouts_get_next_timeout(void) -{ - return &next_timeout; -} -#endif - -#if LWIP_TCP -/** global variable that shows if the tcp timer is currently scheduled or not */ -static int tcpip_tcp_timer_active; - -/** - * Timer callback function that calls tcp_tmr() and reschedules itself. - * - * @param arg unused argument - */ -static void -tcpip_tcp_timer(void *arg) -{ - LWIP_UNUSED_ARG(arg); - - /* call TCP timer handler */ - tcp_tmr(); - /* timer still needed? */ - if (tcp_active_pcbs || tcp_tw_pcbs) { - /* restart timer */ - sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL); - } else { - /* disable timer */ - tcpip_tcp_timer_active = 0; - } -} - -/** - * Called from TCP_REG when registering a new PCB: - * the reason is to have the TCP timer only running when - * there are active (or time-wait) PCBs. - */ -void -tcp_timer_needed(void) -{ - LWIP_ASSERT_CORE_LOCKED(); - - /* timer is off but needed again? */ - if (!tcpip_tcp_timer_active && (tcp_active_pcbs || tcp_tw_pcbs)) { - /* enable and start timer */ - tcpip_tcp_timer_active = 1; - sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL); - } -} -#endif /* LWIP_TCP */ - -static void -#if LWIP_DEBUG_TIMERNAMES -sys_timeout_abs(u32_t abs_time, sys_timeout_handler handler, void *arg, const char *handler_name) -#else /* LWIP_DEBUG_TIMERNAMES */ -sys_timeout_abs(u32_t abs_time, sys_timeout_handler handler, void *arg) -#endif -{ - struct sys_timeo *timeout, *t; - - timeout = (struct sys_timeo *)memp_malloc(MEMP_SYS_TIMEOUT); - if (timeout == NULL) { - LWIP_ASSERT("sys_timeout: timeout != NULL, pool MEMP_SYS_TIMEOUT is empty", timeout != NULL); - return; - } - - timeout->next = NULL; - timeout->h = handler; - timeout->arg = arg; - timeout->time = abs_time; - -#if LWIP_DEBUG_TIMERNAMES - timeout->handler_name = handler_name; - LWIP_DEBUGF(TIMERS_DEBUG, ("sys_timeout: %p abs_time=%"U32_F" handler=%s arg=%p\n", - (void *)timeout, abs_time, handler_name, (void *)arg)); -#endif /* LWIP_DEBUG_TIMERNAMES */ - - if (next_timeout == NULL) { - next_timeout = timeout; - return; - } - if (TIME_LESS_THAN(timeout->time, next_timeout->time)) { - timeout->next = next_timeout; - next_timeout = timeout; - } else { - for (t = next_timeout; t != NULL; t = t->next) { - if ((t->next == NULL) || TIME_LESS_THAN(timeout->time, t->next->time)) { - timeout->next = t->next; - t->next = timeout; - break; - } - } - } -} - -/** - * Timer callback function that calls cyclic->handler() and reschedules itself. - * - * @param arg unused argument - */ -#if !LWIP_TESTMODE -static -#endif -void -lwip_cyclic_timer(void *arg) -{ - u32_t now; - u32_t next_timeout_time; - const struct lwip_cyclic_timer *cyclic = (const struct lwip_cyclic_timer *)arg; - -#if LWIP_DEBUG_TIMERNAMES - LWIP_DEBUGF(TIMERS_DEBUG, ("tcpip: %s()\n", cyclic->handler_name)); -#endif - cyclic->handler(); - - now = sys_now(); - next_timeout_time = (u32_t)(current_timeout_due_time + cyclic->interval_ms); /* overflow handled by TIME_LESS_THAN macro */ - if (TIME_LESS_THAN(next_timeout_time, now)) { - /* timer would immediately expire again -> "overload" -> restart without any correction */ -#if LWIP_DEBUG_TIMERNAMES - sys_timeout_abs((u32_t)(now + cyclic->interval_ms), lwip_cyclic_timer, arg, cyclic->handler_name); -#else - sys_timeout_abs((u32_t)(now + cyclic->interval_ms), lwip_cyclic_timer, arg); -#endif - - } else { - /* correct cyclic interval with handler execution delay and sys_check_timeouts jitter */ -#if LWIP_DEBUG_TIMERNAMES - sys_timeout_abs(next_timeout_time, lwip_cyclic_timer, arg, cyclic->handler_name); -#else - sys_timeout_abs(next_timeout_time, lwip_cyclic_timer, arg); -#endif - } -} - -/** Initialize this module */ -void sys_timeouts_init(void) -{ - size_t i; - /* tcp_tmr() at index 0 is started on demand */ - for (i = (LWIP_TCP ? 1 : 0); i < LWIP_ARRAYSIZE(lwip_cyclic_timers); i++) { - /* we have to cast via size_t to get rid of const warning - (this is OK as cyclic_timer() casts back to const* */ - sys_timeout(lwip_cyclic_timers[i].interval_ms, lwip_cyclic_timer, LWIP_CONST_CAST(void *, &lwip_cyclic_timers[i])); - } -} - -/** - * Create a one-shot timer (aka timeout). Timeouts are processed in the - * following cases: - * - while waiting for a message using sys_timeouts_mbox_fetch() - * - by calling sys_check_timeouts() (NO_SYS==1 only) - * - * @param msecs time in milliseconds after that the timer should expire - * @param handler callback function to call when msecs have elapsed - * @param arg argument to pass to the callback function - */ -#if LWIP_DEBUG_TIMERNAMES -void -sys_timeout_debug(u32_t msecs, sys_timeout_handler handler, void *arg, const char *handler_name) -#else /* LWIP_DEBUG_TIMERNAMES */ -void -sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg) -#endif /* LWIP_DEBUG_TIMERNAMES */ -{ - u32_t next_timeout_time; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("Timeout time too long, max is LWIP_UINT32_MAX/4 msecs", msecs <= (LWIP_UINT32_MAX / 4)); - - next_timeout_time = (u32_t)(sys_now() + msecs); /* overflow handled by TIME_LESS_THAN macro */ - -#if LWIP_DEBUG_TIMERNAMES - sys_timeout_abs(next_timeout_time, handler, arg, handler_name); -#else - sys_timeout_abs(next_timeout_time, handler, arg); -#endif -} - -/** - * Go through timeout list (for this task only) and remove the first matching - * entry (subsequent entries remain untouched), even though the timeout has not - * triggered yet. - * - * @param handler callback function that would be called by the timeout - * @param arg callback argument that would be passed to handler -*/ -void -sys_untimeout(sys_timeout_handler handler, void *arg) -{ - struct sys_timeo *prev_t, *t; - - LWIP_ASSERT_CORE_LOCKED(); - - if (next_timeout == NULL) { - return; - } - - for (t = next_timeout, prev_t = NULL; t != NULL; prev_t = t, t = t->next) { - if ((t->h == handler) && (t->arg == arg)) { - /* We have a match */ - /* Unlink from previous in list */ - if (prev_t == NULL) { - next_timeout = t->next; - } else { - prev_t->next = t->next; - } - memp_free(MEMP_SYS_TIMEOUT, t); - return; - } - } - return; -} - -/** - * @ingroup lwip_nosys - * Handle timeouts for NO_SYS==1 (i.e. without using - * tcpip_thread/sys_timeouts_mbox_fetch(). Uses sys_now() to call timeout - * handler functions when timeouts expire. - * - * Must be called periodically from your main loop. - */ -void -sys_check_timeouts(void) -{ - u32_t now; - - LWIP_ASSERT_CORE_LOCKED(); - - /* Process only timers expired at the start of the function. */ - now = sys_now(); - - do { - struct sys_timeo *tmptimeout; - sys_timeout_handler handler; - void *arg; - - PBUF_CHECK_FREE_OOSEQ(); - - tmptimeout = next_timeout; - if (tmptimeout == NULL) { - return; - } - - if (TIME_LESS_THAN(now, tmptimeout->time)) { - return; - } - - /* Timeout has expired */ - next_timeout = tmptimeout->next; - handler = tmptimeout->h; - arg = tmptimeout->arg; - current_timeout_due_time = tmptimeout->time; -#if LWIP_DEBUG_TIMERNAMES - if (handler != NULL) { - LWIP_DEBUGF(TIMERS_DEBUG, ("sct calling h=%s t=%"U32_F" arg=%p\n", - tmptimeout->handler_name, sys_now() - tmptimeout->time, arg)); - } -#endif /* LWIP_DEBUG_TIMERNAMES */ - memp_free(MEMP_SYS_TIMEOUT, tmptimeout); - if (handler != NULL) { - handler(arg); - } - LWIP_TCPIP_THREAD_ALIVE(); - - /* Repeat until all expired timers have been called */ - } while (1); -} - -/** Rebase the timeout times to the current time. - * This is necessary if sys_check_timeouts() hasn't been called for a long - * time (e.g. while saving energy) to prevent all timer functions of that - * period being called. - */ -void -sys_restart_timeouts(void) -{ - u32_t now; - u32_t base; - struct sys_timeo *t; - - if (next_timeout == NULL) { - return; - } - - now = sys_now(); - base = next_timeout->time; - - for (t = next_timeout; t != NULL; t = t->next) { - t->time = (t->time - base) + now; - } -} - -/** Return the time left before the next timeout is due. If no timeouts are - * enqueued, returns 0xffffffff - */ -u32_t -sys_timeouts_sleeptime(void) -{ - u32_t now; - - LWIP_ASSERT_CORE_LOCKED(); - - if (next_timeout == NULL) { - return SYS_TIMEOUTS_SLEEPTIME_INFINITE; - } - now = sys_now(); - if (TIME_LESS_THAN(next_timeout->time, now)) { - return 0; - } else { - u32_t ret = (u32_t)(next_timeout->time - now); - LWIP_ASSERT("invalid sleeptime", ret <= LWIP_MAX_TIMEOUT); - return ret; - } -} - -#else /* LWIP_TIMERS && !LWIP_TIMERS_CUSTOM */ -/* Satisfy the TCP code which calls this function */ -void -tcp_timer_needed(void) -{ -} -#endif /* LWIP_TIMERS && !LWIP_TIMERS_CUSTOM */ +/** + * @file + * Stack-internal timers implementation. + * This file includes timer callbacks for stack-internal timers as well as + * functions to set up or stop timers and check for expired timers. + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * Simon Goldschmidt + * + */ + +#include "lwip/opt.h" + +#include "lwip/timeouts.h" +#include "lwip/priv/tcp_priv.h" + +#include "lwip/def.h" +#include "lwip/memp.h" +#include "lwip/priv/tcpip_priv.h" + +#include "lwip/ip4_frag.h" +#include "lwip/etharp.h" +#include "lwip/dhcp.h" +#include "lwip/autoip.h" +#include "lwip/igmp.h" +#include "lwip/dns.h" +#include "lwip/nd6.h" +#include "lwip/ip6_frag.h" +#include "lwip/mld6.h" +#include "lwip/dhcp6.h" +#include "lwip/sys.h" +#include "lwip/pbuf.h" + +#if LWIP_DEBUG_TIMERNAMES +#define HANDLER(x) x, #x +#else /* LWIP_DEBUG_TIMERNAMES */ +#define HANDLER(x) x +#endif /* LWIP_DEBUG_TIMERNAMES */ + +#define LWIP_MAX_TIMEOUT 0x7fffffff + +/* Check if timer's expiry time is greater than time and care about u32_t wraparounds */ +#define TIME_LESS_THAN(t, compare_to) ( (((u32_t)((t)-(compare_to))) > LWIP_MAX_TIMEOUT) ? 1 : 0 ) + +/** This array contains all stack-internal cyclic timers. To get the number of + * timers, use LWIP_ARRAYSIZE() */ +const struct lwip_cyclic_timer lwip_cyclic_timers[] = { +#if LWIP_TCP + /* The TCP timer is a special case: it does not have to run always and + is triggered to start from TCP using tcp_timer_needed() */ + {TCP_TMR_INTERVAL, HANDLER(tcp_tmr)}, +#endif /* LWIP_TCP */ +#if LWIP_IPV4 +#if IP_REASSEMBLY + {IP_TMR_INTERVAL, HANDLER(ip_reass_tmr)}, +#endif /* IP_REASSEMBLY */ +#if LWIP_ARP + {ARP_TMR_INTERVAL, HANDLER(etharp_tmr)}, +#endif /* LWIP_ARP */ +#if LWIP_DHCP + {DHCP_COARSE_TIMER_MSECS, HANDLER(dhcp_coarse_tmr)}, + {DHCP_FINE_TIMER_MSECS, HANDLER(dhcp_fine_tmr)}, +#endif /* LWIP_DHCP */ +#if LWIP_AUTOIP + {AUTOIP_TMR_INTERVAL, HANDLER(autoip_tmr)}, +#endif /* LWIP_AUTOIP */ +#if LWIP_IGMP + {IGMP_TMR_INTERVAL, HANDLER(igmp_tmr)}, +#endif /* LWIP_IGMP */ +#endif /* LWIP_IPV4 */ +#if LWIP_DNS + {DNS_TMR_INTERVAL, HANDLER(dns_tmr)}, +#endif /* LWIP_DNS */ +#if LWIP_IPV6 + {ND6_TMR_INTERVAL, HANDLER(nd6_tmr)}, +#if LWIP_IPV6_REASS + {IP6_REASS_TMR_INTERVAL, HANDLER(ip6_reass_tmr)}, +#endif /* LWIP_IPV6_REASS */ +#if LWIP_IPV6_MLD + {MLD6_TMR_INTERVAL, HANDLER(mld6_tmr)}, +#endif /* LWIP_IPV6_MLD */ +#if LWIP_IPV6_DHCP6 + {DHCP6_TIMER_MSECS, HANDLER(dhcp6_tmr)}, +#endif /* LWIP_IPV6_DHCP6 */ +#endif /* LWIP_IPV6 */ +}; +const int lwip_num_cyclic_timers = LWIP_ARRAYSIZE(lwip_cyclic_timers); + +#if LWIP_TIMERS && !LWIP_TIMERS_CUSTOM + +/** The one and only timeout list */ +static struct sys_timeo *next_timeout; + +static u32_t current_timeout_due_time; + +#if LWIP_TESTMODE +struct sys_timeo** +sys_timeouts_get_next_timeout(void) +{ + return &next_timeout; +} +#endif + +#if LWIP_TCP +/** global variable that shows if the tcp timer is currently scheduled or not */ +static int tcpip_tcp_timer_active; + +/** + * Timer callback function that calls tcp_tmr() and reschedules itself. + * + * @param arg unused argument + */ +static void +tcpip_tcp_timer(void *arg) +{ + LWIP_UNUSED_ARG(arg); + + /* call TCP timer handler */ + tcp_tmr(); + /* timer still needed? */ + if (tcp_active_pcbs || tcp_tw_pcbs) { + /* restart timer */ + sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL); + } else { + /* disable timer */ + tcpip_tcp_timer_active = 0; + } +} + +/** + * Called from TCP_REG when registering a new PCB: + * the reason is to have the TCP timer only running when + * there are active (or time-wait) PCBs. + */ +void +tcp_timer_needed(void) +{ + LWIP_ASSERT_CORE_LOCKED(); + + /* timer is off but needed again? */ + if (!tcpip_tcp_timer_active && (tcp_active_pcbs || tcp_tw_pcbs)) { + /* enable and start timer */ + tcpip_tcp_timer_active = 1; + sys_timeout(TCP_TMR_INTERVAL, tcpip_tcp_timer, NULL); + } +} +#endif /* LWIP_TCP */ + +static void +#if LWIP_DEBUG_TIMERNAMES +sys_timeout_abs(u32_t abs_time, sys_timeout_handler handler, void *arg, const char *handler_name) +#else /* LWIP_DEBUG_TIMERNAMES */ +sys_timeout_abs(u32_t abs_time, sys_timeout_handler handler, void *arg) +#endif +{ + struct sys_timeo *timeout, *t; + + timeout = (struct sys_timeo *)memp_malloc(MEMP_SYS_TIMEOUT); + if (timeout == NULL) { + LWIP_ASSERT("sys_timeout: timeout != NULL, pool MEMP_SYS_TIMEOUT is empty", timeout != NULL); + return; + } + + timeout->next = NULL; + timeout->h = handler; + timeout->arg = arg; + timeout->time = abs_time; + +#if LWIP_DEBUG_TIMERNAMES + timeout->handler_name = handler_name; + LWIP_DEBUGF(TIMERS_DEBUG, ("sys_timeout: %p abs_time=%"U32_F" handler=%s arg=%p\n", + (void *)timeout, abs_time, handler_name, (void *)arg)); +#endif /* LWIP_DEBUG_TIMERNAMES */ + + if (next_timeout == NULL) { + next_timeout = timeout; + return; + } + if (TIME_LESS_THAN(timeout->time, next_timeout->time)) { + timeout->next = next_timeout; + next_timeout = timeout; + } else { + for (t = next_timeout; t != NULL; t = t->next) { + if ((t->next == NULL) || TIME_LESS_THAN(timeout->time, t->next->time)) { + timeout->next = t->next; + t->next = timeout; + break; + } + } + } +} + +/** + * Timer callback function that calls cyclic->handler() and reschedules itself. + * + * @param arg unused argument + */ +#if !LWIP_TESTMODE +static +#endif +void +lwip_cyclic_timer(void *arg) +{ + u32_t now; + u32_t next_timeout_time; + const struct lwip_cyclic_timer *cyclic = (const struct lwip_cyclic_timer *)arg; + +#if LWIP_DEBUG_TIMERNAMES + LWIP_DEBUGF(TIMERS_DEBUG, ("tcpip: %s()\n", cyclic->handler_name)); +#endif + cyclic->handler(); + + now = sys_now(); + next_timeout_time = (u32_t)(current_timeout_due_time + cyclic->interval_ms); /* overflow handled by TIME_LESS_THAN macro */ + if (TIME_LESS_THAN(next_timeout_time, now)) { + /* timer would immediately expire again -> "overload" -> restart without any correction */ +#if LWIP_DEBUG_TIMERNAMES + sys_timeout_abs((u32_t)(now + cyclic->interval_ms), lwip_cyclic_timer, arg, cyclic->handler_name); +#else + sys_timeout_abs((u32_t)(now + cyclic->interval_ms), lwip_cyclic_timer, arg); +#endif + + } else { + /* correct cyclic interval with handler execution delay and sys_check_timeouts jitter */ +#if LWIP_DEBUG_TIMERNAMES + sys_timeout_abs(next_timeout_time, lwip_cyclic_timer, arg, cyclic->handler_name); +#else + sys_timeout_abs(next_timeout_time, lwip_cyclic_timer, arg); +#endif + } +} + +/** Initialize this module */ +void sys_timeouts_init(void) +{ + size_t i; + /* tcp_tmr() at index 0 is started on demand */ + for (i = (LWIP_TCP ? 1 : 0); i < LWIP_ARRAYSIZE(lwip_cyclic_timers); i++) { + /* we have to cast via size_t to get rid of const warning + (this is OK as cyclic_timer() casts back to const* */ + sys_timeout(lwip_cyclic_timers[i].interval_ms, lwip_cyclic_timer, LWIP_CONST_CAST(void *, &lwip_cyclic_timers[i])); + } +} + +/** + * Create a one-shot timer (aka timeout). Timeouts are processed in the + * following cases: + * - while waiting for a message using sys_timeouts_mbox_fetch() + * - by calling sys_check_timeouts() (NO_SYS==1 only) + * + * @param msecs time in milliseconds after that the timer should expire + * @param handler callback function to call when msecs have elapsed + * @param arg argument to pass to the callback function + */ +#if LWIP_DEBUG_TIMERNAMES +void +sys_timeout_debug(u32_t msecs, sys_timeout_handler handler, void *arg, const char *handler_name) +#else /* LWIP_DEBUG_TIMERNAMES */ +void +sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg) +#endif /* LWIP_DEBUG_TIMERNAMES */ +{ + u32_t next_timeout_time; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("Timeout time too long, max is LWIP_UINT32_MAX/4 msecs", msecs <= (LWIP_UINT32_MAX / 4)); + + next_timeout_time = (u32_t)(sys_now() + msecs); /* overflow handled by TIME_LESS_THAN macro */ + +#if LWIP_DEBUG_TIMERNAMES + sys_timeout_abs(next_timeout_time, handler, arg, handler_name); +#else + sys_timeout_abs(next_timeout_time, handler, arg); +#endif +} + +/** + * Go through timeout list (for this task only) and remove the first matching + * entry (subsequent entries remain untouched), even though the timeout has not + * triggered yet. + * + * @param handler callback function that would be called by the timeout + * @param arg callback argument that would be passed to handler +*/ +void +sys_untimeout(sys_timeout_handler handler, void *arg) +{ + struct sys_timeo *prev_t, *t; + + LWIP_ASSERT_CORE_LOCKED(); + + if (next_timeout == NULL) { + return; + } + + for (t = next_timeout, prev_t = NULL; t != NULL; prev_t = t, t = t->next) { + if ((t->h == handler) && (t->arg == arg)) { + /* We have a match */ + /* Unlink from previous in list */ + if (prev_t == NULL) { + next_timeout = t->next; + } else { + prev_t->next = t->next; + } + memp_free(MEMP_SYS_TIMEOUT, t); + return; + } + } + return; +} + +/** + * @ingroup lwip_nosys + * Handle timeouts for NO_SYS==1 (i.e. without using + * tcpip_thread/sys_timeouts_mbox_fetch(). Uses sys_now() to call timeout + * handler functions when timeouts expire. + * + * Must be called periodically from your main loop. + */ +void +sys_check_timeouts(void) +{ + u32_t now; + + LWIP_ASSERT_CORE_LOCKED(); + + /* Process only timers expired at the start of the function. */ + now = sys_now(); + + do { + struct sys_timeo *tmptimeout; + sys_timeout_handler handler; + void *arg; + + PBUF_CHECK_FREE_OOSEQ(); + + tmptimeout = next_timeout; + if (tmptimeout == NULL) { + return; + } + + if (TIME_LESS_THAN(now, tmptimeout->time)) { + return; + } + + /* Timeout has expired */ + next_timeout = tmptimeout->next; + handler = tmptimeout->h; + arg = tmptimeout->arg; + current_timeout_due_time = tmptimeout->time; +#if LWIP_DEBUG_TIMERNAMES + if (handler != NULL) { + LWIP_DEBUGF(TIMERS_DEBUG, ("sct calling h=%s t=%"U32_F" arg=%p\n", + tmptimeout->handler_name, sys_now() - tmptimeout->time, arg)); + } +#endif /* LWIP_DEBUG_TIMERNAMES */ + memp_free(MEMP_SYS_TIMEOUT, tmptimeout); + if (handler != NULL) { + handler(arg); + } + LWIP_TCPIP_THREAD_ALIVE(); + + /* Repeat until all expired timers have been called */ + } while (1); +} + +/** Rebase the timeout times to the current time. + * This is necessary if sys_check_timeouts() hasn't been called for a long + * time (e.g. while saving energy) to prevent all timer functions of that + * period being called. + */ +void +sys_restart_timeouts(void) +{ + u32_t now; + u32_t base; + struct sys_timeo *t; + + if (next_timeout == NULL) { + return; + } + + now = sys_now(); + base = next_timeout->time; + + for (t = next_timeout; t != NULL; t = t->next) { + t->time = (t->time - base) + now; + } +} + +/** Return the time left before the next timeout is due. If no timeouts are + * enqueued, returns 0xffffffff + */ +u32_t +sys_timeouts_sleeptime(void) +{ + u32_t now; + + LWIP_ASSERT_CORE_LOCKED(); + + if (next_timeout == NULL) { + return SYS_TIMEOUTS_SLEEPTIME_INFINITE; + } + now = sys_now(); + if (TIME_LESS_THAN(next_timeout->time, now)) { + return 0; + } else { + u32_t ret = (u32_t)(next_timeout->time - now); + LWIP_ASSERT("invalid sleeptime", ret <= LWIP_MAX_TIMEOUT); + return ret; + } +} + +#else /* LWIP_TIMERS && !LWIP_TIMERS_CUSTOM */ +/* Satisfy the TCP code which calls this function */ +void +tcp_timer_needed(void) +{ +} +#endif /* LWIP_TIMERS && !LWIP_TIMERS_CUSTOM */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/udp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/udp.c index 4f45f8d7..9d2cb4af 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/udp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/core/udp.c @@ -1,1314 +1,1314 @@ -/** - * @file - * User Datagram Protocol module\n - * The code for the User Datagram Protocol UDP & UDPLite (RFC 3828).\n - * See also @ref udp_raw - * - * @defgroup udp_raw UDP - * @ingroup callbackstyle_api - * User Datagram Protocol module\n - * @see @ref api - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -/* @todo Check the use of '(struct udp_pcb).chksum_len_rx'! - */ - -#include "lwip/opt.h" - -#if LWIP_UDP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/udp.h" -#include "lwip/def.h" -#include "lwip/memp.h" -#include "lwip/inet_chksum.h" -#include "lwip/ip_addr.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" -#include "lwip/icmp.h" -#include "lwip/icmp6.h" -#include "lwip/stats.h" -#include "lwip/snmp.h" -#include "lwip/dhcp.h" - -#include - -#ifndef UDP_LOCAL_PORT_RANGE_START -/* From http://www.iana.org/assignments/port-numbers: - "The Dynamic and/or Private Ports are those from 49152 through 65535" */ -#define UDP_LOCAL_PORT_RANGE_START 0xc000 -#define UDP_LOCAL_PORT_RANGE_END 0xffff -#define UDP_ENSURE_LOCAL_PORT_RANGE(port) ((u16_t)(((port) & (u16_t)~UDP_LOCAL_PORT_RANGE_START) + UDP_LOCAL_PORT_RANGE_START)) -#endif - -/* last local UDP port */ -static u16_t udp_port = UDP_LOCAL_PORT_RANGE_START; - -/* The list of UDP PCBs */ -/* exported in udp.h (was static) */ -struct udp_pcb *udp_pcbs; - -/** - * Initialize this module. - */ -void -udp_init(void) -{ -#ifdef LWIP_RAND - udp_port = UDP_ENSURE_LOCAL_PORT_RANGE(LWIP_RAND()); -#endif /* LWIP_RAND */ -} - -/** - * Allocate a new local UDP port. - * - * @return a new (free) local UDP port number - */ -static u16_t -udp_new_port(void) -{ - u16_t n = 0; - struct udp_pcb *pcb; - -again: - if (udp_port++ == UDP_LOCAL_PORT_RANGE_END) { - udp_port = UDP_LOCAL_PORT_RANGE_START; - } - /* Check all PCBs. */ - for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) { - if (pcb->local_port == udp_port) { - if (++n > (UDP_LOCAL_PORT_RANGE_END - UDP_LOCAL_PORT_RANGE_START)) { - return 0; - } - goto again; - } - } - return udp_port; -} - -/** Common code to see if the current input packet matches the pcb - * (current input packet is accessed via ip(4/6)_current_* macros) - * - * @param pcb pcb to check - * @param inp network interface on which the datagram was received (only used for IPv4) - * @param broadcast 1 if his is an IPv4 broadcast (global or subnet-only), 0 otherwise (only used for IPv4) - * @return 1 on match, 0 otherwise - */ -static u8_t -udp_input_local_match(struct udp_pcb *pcb, struct netif *inp, u8_t broadcast) -{ - LWIP_UNUSED_ARG(inp); /* in IPv6 only case */ - LWIP_UNUSED_ARG(broadcast); /* in IPv6 only case */ - - LWIP_ASSERT("udp_input_local_match: invalid pcb", pcb != NULL); - LWIP_ASSERT("udp_input_local_match: invalid netif", inp != NULL); - - /* check if PCB is bound to specific netif */ - if ((pcb->netif_idx != NETIF_NO_INDEX) && - (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { - return 0; - } - - /* Dual-stack: PCBs listening to any IP type also listen to any IP address */ - if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { -#if LWIP_IPV4 && IP_SOF_BROADCAST_RECV - if ((broadcast != 0) && !ip_get_option(pcb, SOF_BROADCAST)) { - return 0; - } -#endif /* LWIP_IPV4 && IP_SOF_BROADCAST_RECV */ - return 1; - } - - /* Only need to check PCB if incoming IP version matches PCB IP version */ - if (IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ip_current_dest_addr())) { -#if LWIP_IPV4 - /* Special case: IPv4 broadcast: all or broadcasts in my subnet - * Note: broadcast variable can only be 1 if it is an IPv4 broadcast */ - if (broadcast != 0) { -#if IP_SOF_BROADCAST_RECV - if (ip_get_option(pcb, SOF_BROADCAST)) -#endif /* IP_SOF_BROADCAST_RECV */ - { - if (ip4_addr_isany(ip_2_ip4(&pcb->local_ip)) || - ((ip4_current_dest_addr()->addr == IPADDR_BROADCAST)) || - ip4_addr_netcmp(ip_2_ip4(&pcb->local_ip), ip4_current_dest_addr(), netif_ip4_netmask(inp))) { - return 1; - } - } - } else -#endif /* LWIP_IPV4 */ - /* Handle IPv4 and IPv6: all or exact match */ - if (ip_addr_isany(&pcb->local_ip) || ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { - return 1; - } - } - - return 0; -} - -/** - * Process an incoming UDP datagram. - * - * Given an incoming UDP datagram (as a chain of pbufs) this function - * finds a corresponding UDP PCB and hands over the pbuf to the pcbs - * recv function. If no pcb is found or the datagram is incorrect, the - * pbuf is freed. - * - * @param p pbuf to be demultiplexed to a UDP PCB (p->payload pointing to the UDP header) - * @param inp network interface on which the datagram was received. - * - */ -void -udp_input(struct pbuf *p, struct netif *inp) -{ - struct udp_hdr *udphdr; - struct udp_pcb *pcb, *prev; - struct udp_pcb *uncon_pcb; - u16_t src, dest; - u8_t broadcast; - u8_t for_us = 0; - - LWIP_UNUSED_ARG(inp); - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ASSERT("udp_input: invalid pbuf", p != NULL); - LWIP_ASSERT("udp_input: invalid netif", inp != NULL); - - PERF_START; - - UDP_STATS_INC(udp.recv); - - /* Check minimum length (UDP header) */ - if (p->len < UDP_HLEN) { - /* drop short packets */ - LWIP_DEBUGF(UDP_DEBUG, - ("udp_input: short UDP datagram (%"U16_F" bytes) discarded\n", p->tot_len)); - UDP_STATS_INC(udp.lenerr); - UDP_STATS_INC(udp.drop); - MIB2_STATS_INC(mib2.udpinerrors); - pbuf_free(p); - goto end; - } - - udphdr = (struct udp_hdr *)p->payload; - - /* is broadcast packet ? */ - broadcast = ip_addr_isbroadcast(ip_current_dest_addr(), ip_current_netif()); - - LWIP_DEBUGF(UDP_DEBUG, ("udp_input: received datagram of length %"U16_F"\n", p->tot_len)); - - /* convert src and dest ports to host byte order */ - src = lwip_ntohs(udphdr->src); - dest = lwip_ntohs(udphdr->dest); - - udp_debug_print(udphdr); - - /* print the UDP source and destination */ - LWIP_DEBUGF(UDP_DEBUG, ("udp (")); - ip_addr_debug_print_val(UDP_DEBUG, *ip_current_dest_addr()); - LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F") <-- (", lwip_ntohs(udphdr->dest))); - ip_addr_debug_print_val(UDP_DEBUG, *ip_current_src_addr()); - LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F")\n", lwip_ntohs(udphdr->src))); - - pcb = NULL; - prev = NULL; - uncon_pcb = NULL; - /* Iterate through the UDP pcb list for a matching pcb. - * 'Perfect match' pcbs (connected to the remote port & ip address) are - * preferred. If no perfect match is found, the first unconnected pcb that - * matches the local port and ip address gets the datagram. */ - for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) { - /* print the PCB local and remote address */ - LWIP_DEBUGF(UDP_DEBUG, ("pcb (")); - ip_addr_debug_print_val(UDP_DEBUG, pcb->local_ip); - LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F") <-- (", pcb->local_port)); - ip_addr_debug_print_val(UDP_DEBUG, pcb->remote_ip); - LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F")\n", pcb->remote_port)); - - /* compare PCB local addr+port to UDP destination addr+port */ - if ((pcb->local_port == dest) && - (udp_input_local_match(pcb, inp, broadcast) != 0)) { - if ((pcb->flags & UDP_FLAGS_CONNECTED) == 0) { - if (uncon_pcb == NULL) { - /* the first unconnected matching PCB */ - uncon_pcb = pcb; -#if LWIP_IPV4 - } else if (broadcast && ip4_current_dest_addr()->addr == IPADDR_BROADCAST) { - /* global broadcast address (only valid for IPv4; match was checked before) */ - if (!IP_IS_V4_VAL(uncon_pcb->local_ip) || !ip4_addr_cmp(ip_2_ip4(&uncon_pcb->local_ip), netif_ip4_addr(inp))) { - /* uncon_pcb does not match the input netif, check this pcb */ - if (IP_IS_V4_VAL(pcb->local_ip) && ip4_addr_cmp(ip_2_ip4(&pcb->local_ip), netif_ip4_addr(inp))) { - /* better match */ - uncon_pcb = pcb; - } - } -#endif /* LWIP_IPV4 */ - } -#if SO_REUSE - else if (!ip_addr_isany(&pcb->local_ip)) { - /* prefer specific IPs over catch-all */ - uncon_pcb = pcb; - } -#endif /* SO_REUSE */ - } - - /* compare PCB remote addr+port to UDP source addr+port */ - if ((pcb->remote_port == src) && - (ip_addr_isany_val(pcb->remote_ip) || - ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()))) { - /* the first fully matching PCB */ - if (prev != NULL) { - /* move the pcb to the front of udp_pcbs so that is - found faster next time */ - prev->next = pcb->next; - pcb->next = udp_pcbs; - udp_pcbs = pcb; - } else { - UDP_STATS_INC(udp.cachehit); - } - break; - } - } - - prev = pcb; - } - /* no fully matching pcb found? then look for an unconnected pcb */ - if (pcb == NULL) { - pcb = uncon_pcb; - } - - /* Check checksum if this is a match or if it was directed at us. */ - if (pcb != NULL) { - for_us = 1; - } else { -#if LWIP_IPV6 - if (ip_current_is_v6()) { - for_us = netif_get_ip6_addr_match(inp, ip6_current_dest_addr()) >= 0; - } -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 - if (!ip_current_is_v6()) { - for_us = ip4_addr_cmp(netif_ip4_addr(inp), ip4_current_dest_addr()); - } -#endif /* LWIP_IPV4 */ - } - - if (for_us) { - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_input: calculating checksum\n")); -#if CHECKSUM_CHECK_UDP - IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_UDP) { -#if LWIP_UDPLITE - if (ip_current_header_proto() == IP_PROTO_UDPLITE) { - /* Do the UDP Lite checksum */ - u16_t chklen = lwip_ntohs(udphdr->len); - if (chklen < sizeof(struct udp_hdr)) { - if (chklen == 0) { - /* For UDP-Lite, checksum length of 0 means checksum - over the complete packet (See RFC 3828 chap. 3.1) */ - chklen = p->tot_len; - } else { - /* At least the UDP-Lite header must be covered by the - checksum! (Again, see RFC 3828 chap. 3.1) */ - goto chkerr; - } - } - if (ip_chksum_pseudo_partial(p, IP_PROTO_UDPLITE, - p->tot_len, chklen, - ip_current_src_addr(), ip_current_dest_addr()) != 0) { - goto chkerr; - } - } else -#endif /* LWIP_UDPLITE */ - { - if (udphdr->chksum != 0) { - if (ip_chksum_pseudo(p, IP_PROTO_UDP, p->tot_len, - ip_current_src_addr(), - ip_current_dest_addr()) != 0) { - goto chkerr; - } - } - } - } -#endif /* CHECKSUM_CHECK_UDP */ - if (pbuf_remove_header(p, UDP_HLEN)) { - /* Can we cope with this failing? Just assert for now */ - LWIP_ASSERT("pbuf_remove_header failed\n", 0); - UDP_STATS_INC(udp.drop); - MIB2_STATS_INC(mib2.udpinerrors); - pbuf_free(p); - goto end; - } - - if (pcb != NULL) { - MIB2_STATS_INC(mib2.udpindatagrams); -#if SO_REUSE && SO_REUSE_RXTOALL - if (ip_get_option(pcb, SOF_REUSEADDR) && - (broadcast || ip_addr_ismulticast(ip_current_dest_addr()))) { - /* pass broadcast- or multicast packets to all multicast pcbs - if SOF_REUSEADDR is set on the first match */ - struct udp_pcb *mpcb; - for (mpcb = udp_pcbs; mpcb != NULL; mpcb = mpcb->next) { - if (mpcb != pcb) { - /* compare PCB local addr+port to UDP destination addr+port */ - if ((mpcb->local_port == dest) && - (udp_input_local_match(mpcb, inp, broadcast) != 0)) { - /* pass a copy of the packet to all local matches */ - if (mpcb->recv != NULL) { - struct pbuf *q; - q = pbuf_clone(PBUF_RAW, PBUF_POOL, p); - if (q != NULL) { - mpcb->recv(mpcb->recv_arg, mpcb, q, ip_current_src_addr(), src); - } - } - } - } - } - } -#endif /* SO_REUSE && SO_REUSE_RXTOALL */ - /* callback */ - if (pcb->recv != NULL) { - /* now the recv function is responsible for freeing p */ - pcb->recv(pcb->recv_arg, pcb, p, ip_current_src_addr(), src); - } else { - /* no recv function registered? then we have to free the pbuf! */ - pbuf_free(p); - goto end; - } - } else { - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_input: not for us.\n")); - -#if LWIP_ICMP || LWIP_ICMP6 - /* No match was found, send ICMP destination port unreachable unless - destination address was broadcast/multicast. */ - if (!broadcast && !ip_addr_ismulticast(ip_current_dest_addr())) { - /* move payload pointer back to ip header */ - pbuf_header_force(p, (s16_t)(ip_current_header_tot_len() + UDP_HLEN)); - icmp_port_unreach(ip_current_is_v6(), p); - } -#endif /* LWIP_ICMP || LWIP_ICMP6 */ - UDP_STATS_INC(udp.proterr); - UDP_STATS_INC(udp.drop); - MIB2_STATS_INC(mib2.udpnoports); - pbuf_free(p); - } - } else { - pbuf_free(p); - } -end: - PERF_STOP("udp_input"); - return; -#if CHECKSUM_CHECK_UDP -chkerr: - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("udp_input: UDP (or UDP Lite) datagram discarded due to failing checksum\n")); - UDP_STATS_INC(udp.chkerr); - UDP_STATS_INC(udp.drop); - MIB2_STATS_INC(mib2.udpinerrors); - pbuf_free(p); - PERF_STOP("udp_input"); -#endif /* CHECKSUM_CHECK_UDP */ -} - -/** - * @ingroup udp_raw - * Sends the pbuf p using UDP. The pbuf is not deallocated. - * - * - * @param pcb UDP PCB used to send the data. - * @param p chain of pbuf's to be sent. - * - * The datagram will be sent to the current remote_ip & remote_port - * stored in pcb. If the pcb is not bound to a port, it will - * automatically be bound to a random port. - * - * @return lwIP error code. - * - ERR_OK. Successful. No error occurred. - * - ERR_MEM. Out of memory. - * - ERR_RTE. Could not find route to destination address. - * - ERR_VAL. No PCB or PCB is dual-stack - * - More errors could be returned by lower protocol layers. - * - * @see udp_disconnect() udp_sendto() - */ -err_t -udp_send(struct udp_pcb *pcb, struct pbuf *p) -{ - LWIP_ERROR("udp_send: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_ERROR("udp_send: invalid pbuf", p != NULL, return ERR_ARG); - - if (IP_IS_ANY_TYPE_VAL(pcb->remote_ip)) { - return ERR_VAL; - } - - /* send to the packet using remote ip and port stored in the pcb */ - return udp_sendto(pcb, p, &pcb->remote_ip, pcb->remote_port); -} - -#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP -/** @ingroup udp_raw - * Same as udp_send() but with checksum - */ -err_t -udp_send_chksum(struct udp_pcb *pcb, struct pbuf *p, - u8_t have_chksum, u16_t chksum) -{ - LWIP_ERROR("udp_send_chksum: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_ERROR("udp_send_chksum: invalid pbuf", p != NULL, return ERR_ARG); - - if (IP_IS_ANY_TYPE_VAL(pcb->remote_ip)) { - return ERR_VAL; - } - - /* send to the packet using remote ip and port stored in the pcb */ - return udp_sendto_chksum(pcb, p, &pcb->remote_ip, pcb->remote_port, - have_chksum, chksum); -} -#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ - -/** - * @ingroup udp_raw - * Send data to a specified address using UDP. - * - * @param pcb UDP PCB used to send the data. - * @param p chain of pbuf's to be sent. - * @param dst_ip Destination IP address. - * @param dst_port Destination UDP port. - * - * dst_ip & dst_port are expected to be in the same byte order as in the pcb. - * - * If the PCB already has a remote address association, it will - * be restored after the data is sent. - * - * @return lwIP error code (@see udp_send for possible error codes) - * - * @see udp_disconnect() udp_send() - */ -err_t -udp_sendto(struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port) -{ -#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP - return udp_sendto_chksum(pcb, p, dst_ip, dst_port, 0, 0); -} - -/** @ingroup udp_raw - * Same as udp_sendto(), but with checksum */ -err_t -udp_sendto_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, - u16_t dst_port, u8_t have_chksum, u16_t chksum) -{ -#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ - struct netif *netif; - - LWIP_ERROR("udp_sendto: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto: invalid pbuf", p != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto: invalid dst_ip", dst_ip != NULL, return ERR_ARG); - - if (!IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { - return ERR_VAL; - } - - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_send\n")); - - if (pcb->netif_idx != NETIF_NO_INDEX) { - netif = netif_get_by_index(pcb->netif_idx); - } else { -#if LWIP_MULTICAST_TX_OPTIONS - netif = NULL; - if (ip_addr_ismulticast(dst_ip)) { - /* For IPv6, the interface to use for packets with a multicast destination - * is specified using an interface index. The same approach may be used for - * IPv4 as well, in which case it overrides the IPv4 multicast override - * address below. Here we have to look up the netif by going through the - * list, but by doing so we skip a route lookup. If the interface index has - * gone stale, we fall through and do the regular route lookup after all. */ - if (pcb->mcast_ifindex != NETIF_NO_INDEX) { - netif = netif_get_by_index(pcb->mcast_ifindex); - } -#if LWIP_IPV4 - else -#if LWIP_IPV6 - if (IP_IS_V4(dst_ip)) -#endif /* LWIP_IPV6 */ - { - /* IPv4 does not use source-based routing by default, so we use an - administratively selected interface for multicast by default. - However, this can be overridden by setting an interface address - in pcb->mcast_ip4 that is used for routing. If this routing lookup - fails, we try regular routing as though no override was set. */ - if (!ip4_addr_isany_val(pcb->mcast_ip4) && - !ip4_addr_cmp(&pcb->mcast_ip4, IP4_ADDR_BROADCAST)) { - netif = ip4_route_src(ip_2_ip4(&pcb->local_ip), &pcb->mcast_ip4); - } - } -#endif /* LWIP_IPV4 */ - } - - if (netif == NULL) -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - { - /* find the outgoing network interface for this packet */ - netif = ip_route(&pcb->local_ip, dst_ip); - } - } - - /* no outgoing network interface could be found? */ - if (netif == NULL) { - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("udp_send: No route to ")); - ip_addr_debug_print(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, dst_ip); - LWIP_DEBUGF(UDP_DEBUG, ("\n")); - UDP_STATS_INC(udp.rterr); - return ERR_RTE; - } -#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP - return udp_sendto_if_chksum(pcb, p, dst_ip, dst_port, netif, have_chksum, chksum); -#else /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ - return udp_sendto_if(pcb, p, dst_ip, dst_port, netif); -#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ -} - -/** - * @ingroup udp_raw - * Send data to a specified address using UDP. - * The netif used for sending can be specified. - * - * This function exists mainly for DHCP, to be able to send UDP packets - * on a netif that is still down. - * - * @param pcb UDP PCB used to send the data. - * @param p chain of pbuf's to be sent. - * @param dst_ip Destination IP address. - * @param dst_port Destination UDP port. - * @param netif the netif used for sending. - * - * dst_ip & dst_port are expected to be in the same byte order as in the pcb. - * - * @return lwIP error code (@see udp_send for possible error codes) - * - * @see udp_disconnect() udp_send() - */ -err_t -udp_sendto_if(struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif) -{ -#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP - return udp_sendto_if_chksum(pcb, p, dst_ip, dst_port, netif, 0, 0); -} - -/** Same as udp_sendto_if(), but with checksum */ -err_t -udp_sendto_if_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, - u16_t dst_port, struct netif *netif, u8_t have_chksum, - u16_t chksum) -{ -#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ - const ip_addr_t *src_ip; - - LWIP_ERROR("udp_sendto_if: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto_if: invalid pbuf", p != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto_if: invalid dst_ip", dst_ip != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto_if: invalid netif", netif != NULL, return ERR_ARG); - - if (!IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { - return ERR_VAL; - } - - /* PCB local address is IP_ANY_ADDR or multicast? */ -#if LWIP_IPV6 - if (IP_IS_V6(dst_ip)) { - if (ip6_addr_isany(ip_2_ip6(&pcb->local_ip)) || - ip6_addr_ismulticast(ip_2_ip6(&pcb->local_ip))) { - src_ip = ip6_select_source_address(netif, ip_2_ip6(dst_ip)); - if (src_ip == NULL) { - /* No suitable source address was found. */ - return ERR_RTE; - } - } else { - /* use UDP PCB local IPv6 address as source address, if still valid. */ - if (netif_get_ip6_addr_match(netif, ip_2_ip6(&pcb->local_ip)) < 0) { - /* Address isn't valid anymore. */ - return ERR_RTE; - } - src_ip = &pcb->local_ip; - } - } -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 && LWIP_IPV6 - else -#endif /* LWIP_IPV4 && LWIP_IPV6 */ -#if LWIP_IPV4 - if (ip4_addr_isany(ip_2_ip4(&pcb->local_ip)) || - ip4_addr_ismulticast(ip_2_ip4(&pcb->local_ip))) { - /* if the local_ip is any or multicast - * use the outgoing network interface IP address as source address */ - src_ip = netif_ip_addr4(netif); - } else { - /* check if UDP PCB local IP address is correct - * this could be an old address if netif->ip_addr has changed */ - if (!ip4_addr_cmp(ip_2_ip4(&(pcb->local_ip)), netif_ip4_addr(netif))) { - /* local_ip doesn't match, drop the packet */ - return ERR_RTE; - } - /* use UDP PCB local IP address as source address */ - src_ip = &pcb->local_ip; - } -#endif /* LWIP_IPV4 */ -#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP - return udp_sendto_if_src_chksum(pcb, p, dst_ip, dst_port, netif, have_chksum, chksum, src_ip); -#else /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ - return udp_sendto_if_src(pcb, p, dst_ip, dst_port, netif, src_ip); -#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ -} - -/** @ingroup udp_raw - * Same as @ref udp_sendto_if, but with source address */ -err_t -udp_sendto_if_src(struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif, const ip_addr_t *src_ip) -{ -#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP - return udp_sendto_if_src_chksum(pcb, p, dst_ip, dst_port, netif, 0, 0, src_ip); -} - -/** Same as udp_sendto_if_src(), but with checksum */ -err_t -udp_sendto_if_src_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, - u16_t dst_port, struct netif *netif, u8_t have_chksum, - u16_t chksum, const ip_addr_t *src_ip) -{ -#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ - struct udp_hdr *udphdr; - err_t err; - struct pbuf *q; /* q will be sent down the stack */ - u8_t ip_proto; - u8_t ttl; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("udp_sendto_if_src: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto_if_src: invalid pbuf", p != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto_if_src: invalid dst_ip", dst_ip != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto_if_src: invalid src_ip", src_ip != NULL, return ERR_ARG); - LWIP_ERROR("udp_sendto_if_src: invalid netif", netif != NULL, return ERR_ARG); - - if (!IP_ADDR_PCB_VERSION_MATCH(pcb, src_ip) || - !IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { - return ERR_VAL; - } - -#if LWIP_IPV4 && IP_SOF_BROADCAST - /* broadcast filter? */ - if (!ip_get_option(pcb, SOF_BROADCAST) && -#if LWIP_IPV6 - IP_IS_V4(dst_ip) && -#endif /* LWIP_IPV6 */ - ip_addr_isbroadcast(dst_ip, netif)) { - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, - ("udp_sendto_if: SOF_BROADCAST not enabled on pcb %p\n", (void *)pcb)); - return ERR_VAL; - } -#endif /* LWIP_IPV4 && IP_SOF_BROADCAST */ - - /* if the PCB is not yet bound to a port, bind it here */ - if (pcb->local_port == 0) { - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_send: not yet bound to a port, binding now\n")); - err = udp_bind(pcb, &pcb->local_ip, pcb->local_port); - if (err != ERR_OK) { - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("udp_send: forced port bind failed\n")); - return err; - } - } - - /* packet too large to add a UDP header without causing an overflow? */ - if ((u16_t)(p->tot_len + UDP_HLEN) < p->tot_len) { - return ERR_MEM; - } - /* not enough space to add an UDP header to first pbuf in given p chain? */ - if (pbuf_add_header(p, UDP_HLEN)) { - /* allocate header in a separate new pbuf */ - q = pbuf_alloc(PBUF_IP, UDP_HLEN, PBUF_RAM); - /* new header pbuf could not be allocated? */ - if (q == NULL) { - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("udp_send: could not allocate header\n")); - return ERR_MEM; - } - if (p->tot_len != 0) { - /* chain header q in front of given pbuf p (only if p contains data) */ - pbuf_chain(q, p); - } - /* first pbuf q points to header pbuf */ - LWIP_DEBUGF(UDP_DEBUG, - ("udp_send: added header pbuf %p before given pbuf %p\n", (void *)q, (void *)p)); - } else { - /* adding space for header within p succeeded */ - /* first pbuf q equals given pbuf */ - q = p; - LWIP_DEBUGF(UDP_DEBUG, ("udp_send: added header in given pbuf %p\n", (void *)p)); - } - LWIP_ASSERT("check that first pbuf can hold struct udp_hdr", - (q->len >= sizeof(struct udp_hdr))); - /* q now represents the packet to be sent */ - udphdr = (struct udp_hdr *)q->payload; - udphdr->src = lwip_htons(pcb->local_port); - udphdr->dest = lwip_htons(dst_port); - /* in UDP, 0 checksum means 'no checksum' */ - udphdr->chksum = 0x0000; - - /* Multicast Loop? */ -#if LWIP_MULTICAST_TX_OPTIONS - if (((pcb->flags & UDP_FLAGS_MULTICAST_LOOP) != 0) && ip_addr_ismulticast(dst_ip)) { - q->flags |= PBUF_FLAG_MCASTLOOP; - } -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - - LWIP_DEBUGF(UDP_DEBUG, ("udp_send: sending datagram of length %"U16_F"\n", q->tot_len)); - -#if LWIP_UDPLITE - /* UDP Lite protocol? */ - if (pcb->flags & UDP_FLAGS_UDPLITE) { - u16_t chklen, chklen_hdr; - LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP LITE packet length %"U16_F"\n", q->tot_len)); - /* set UDP message length in UDP header */ - chklen_hdr = chklen = pcb->chksum_len_tx; - if ((chklen < sizeof(struct udp_hdr)) || (chklen > q->tot_len)) { - if (chklen != 0) { - LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP LITE pcb->chksum_len is illegal: %"U16_F"\n", chklen)); - } - /* For UDP-Lite, checksum length of 0 means checksum - over the complete packet. (See RFC 3828 chap. 3.1) - At least the UDP-Lite header must be covered by the - checksum, therefore, if chksum_len has an illegal - value, we generate the checksum over the complete - packet to be safe. */ - chklen_hdr = 0; - chklen = q->tot_len; - } - udphdr->len = lwip_htons(chklen_hdr); - /* calculate checksum */ -#if CHECKSUM_GEN_UDP - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) { -#if LWIP_CHECKSUM_ON_COPY - if (have_chksum) { - chklen = UDP_HLEN; - } -#endif /* LWIP_CHECKSUM_ON_COPY */ - udphdr->chksum = ip_chksum_pseudo_partial(q, IP_PROTO_UDPLITE, - q->tot_len, chklen, src_ip, dst_ip); -#if LWIP_CHECKSUM_ON_COPY - if (have_chksum) { - u32_t acc; - acc = udphdr->chksum + (u16_t)~(chksum); - udphdr->chksum = FOLD_U32T(acc); - } -#endif /* LWIP_CHECKSUM_ON_COPY */ - - /* chksum zero must become 0xffff, as zero means 'no checksum' */ - if (udphdr->chksum == 0x0000) { - udphdr->chksum = 0xffff; - } - } -#endif /* CHECKSUM_GEN_UDP */ - - ip_proto = IP_PROTO_UDPLITE; - } else -#endif /* LWIP_UDPLITE */ - { /* UDP */ - LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP packet length %"U16_F"\n", q->tot_len)); - udphdr->len = lwip_htons(q->tot_len); - /* calculate checksum */ -#if CHECKSUM_GEN_UDP - IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) { - /* Checksum is mandatory over IPv6. */ - if (IP_IS_V6(dst_ip) || (pcb->flags & UDP_FLAGS_NOCHKSUM) == 0) { - u16_t udpchksum; -#if LWIP_CHECKSUM_ON_COPY - if (have_chksum) { - u32_t acc; - udpchksum = ip_chksum_pseudo_partial(q, IP_PROTO_UDP, - q->tot_len, UDP_HLEN, src_ip, dst_ip); - acc = udpchksum + (u16_t)~(chksum); - udpchksum = FOLD_U32T(acc); - } else -#endif /* LWIP_CHECKSUM_ON_COPY */ - { - udpchksum = ip_chksum_pseudo(q, IP_PROTO_UDP, q->tot_len, - src_ip, dst_ip); - } - - /* chksum zero must become 0xffff, as zero means 'no checksum' */ - if (udpchksum == 0x0000) { - udpchksum = 0xffff; - } - udphdr->chksum = udpchksum; - } - } -#endif /* CHECKSUM_GEN_UDP */ - ip_proto = IP_PROTO_UDP; - } - - /* Determine TTL to use */ -#if LWIP_MULTICAST_TX_OPTIONS - ttl = (ip_addr_ismulticast(dst_ip) ? udp_get_multicast_ttl(pcb) : pcb->ttl); -#else /* LWIP_MULTICAST_TX_OPTIONS */ - ttl = pcb->ttl; -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - - LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP checksum 0x%04"X16_F"\n", udphdr->chksum)); - LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,0x%02"X16_F",)\n", (u16_t)ip_proto)); - /* output to IP */ - NETIF_SET_HINTS(netif, &(pcb->netif_hints)); - err = ip_output_if_src(q, src_ip, dst_ip, ttl, pcb->tos, ip_proto, netif); - NETIF_RESET_HINTS(netif); - - /* @todo: must this be increased even if error occurred? */ - MIB2_STATS_INC(mib2.udpoutdatagrams); - - /* did we chain a separate header pbuf earlier? */ - if (q != p) { - /* free the header pbuf */ - pbuf_free(q); - q = NULL; - /* p is still referenced by the caller, and will live on */ - } - - UDP_STATS_INC(udp.xmit); - return err; -} - -/** - * @ingroup udp_raw - * Bind an UDP PCB. - * - * @param pcb UDP PCB to be bound with a local address ipaddr and port. - * @param ipaddr local IP address to bind with. Use IP_ANY_TYPE to - * bind to all local interfaces. - * @param port local UDP port to bind with. Use 0 to automatically bind - * to a random port between UDP_LOCAL_PORT_RANGE_START and - * UDP_LOCAL_PORT_RANGE_END. - * - * ipaddr & port are expected to be in the same byte order as in the pcb. - * - * @return lwIP error code. - * - ERR_OK. Successful. No error occurred. - * - ERR_USE. The specified ipaddr and port are already bound to by - * another UDP PCB. - * - * @see udp_disconnect() - */ -err_t -udp_bind(struct udp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port) -{ - struct udp_pcb *ipcb; - u8_t rebind; -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - ip_addr_t zoned_ipaddr; -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - - LWIP_ASSERT_CORE_LOCKED(); - -#if LWIP_IPV4 - /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ - if (ipaddr == NULL) { - ipaddr = IP4_ADDR_ANY; - } -#else /* LWIP_IPV4 */ - LWIP_ERROR("udp_bind: invalid ipaddr", ipaddr != NULL, return ERR_ARG); -#endif /* LWIP_IPV4 */ - - LWIP_ERROR("udp_bind: invalid pcb", pcb != NULL, return ERR_ARG); - - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_bind(ipaddr = ")); - ip_addr_debug_print(UDP_DEBUG | LWIP_DBG_TRACE, ipaddr); - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, (", port = %"U16_F")\n", port)); - - rebind = 0; - /* Check for double bind and rebind of the same pcb */ - for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { - /* is this UDP PCB already on active list? */ - if (pcb == ipcb) { - rebind = 1; - break; - } - } - -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - /* If the given IP address should have a zone but doesn't, assign one now. - * This is legacy support: scope-aware callers should always provide properly - * zoned source addresses. Do the zone selection before the address-in-use - * check below; as such we have to make a temporary copy of the address. */ - if (IP_IS_V6(ipaddr) && ip6_addr_lacks_zone(ip_2_ip6(ipaddr), IP6_UNKNOWN)) { - ip_addr_copy(zoned_ipaddr, *ipaddr); - ip6_addr_select_zone(ip_2_ip6(&zoned_ipaddr), ip_2_ip6(&zoned_ipaddr)); - ipaddr = &zoned_ipaddr; - } -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - - /* no port specified? */ - if (port == 0) { - port = udp_new_port(); - if (port == 0) { - /* no more ports available in local range */ - LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: out of free UDP ports\n")); - return ERR_USE; - } - } else { - for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { - if (pcb != ipcb) { - /* By default, we don't allow to bind to a port that any other udp - PCB is already bound to, unless *all* PCBs with that port have tha - REUSEADDR flag set. */ -#if SO_REUSE - if (!ip_get_option(pcb, SOF_REUSEADDR) || - !ip_get_option(ipcb, SOF_REUSEADDR)) -#endif /* SO_REUSE */ - { - /* port matches that of PCB in list and REUSEADDR not set -> reject */ - if ((ipcb->local_port == port) && - /* IP address matches or any IP used? */ - (ip_addr_cmp(&ipcb->local_ip, ipaddr) || ip_addr_isany(ipaddr) || - ip_addr_isany(&ipcb->local_ip))) { - /* other PCB already binds to this local IP and port */ - LWIP_DEBUGF(UDP_DEBUG, - ("udp_bind: local port %"U16_F" already bound by another pcb\n", port)); - return ERR_USE; - } - } - } - } - } - - ip_addr_set_ipaddr(&pcb->local_ip, ipaddr); - - pcb->local_port = port; - mib2_udp_bind(pcb); - /* pcb not active yet? */ - if (rebind == 0) { - /* place the PCB on the active list if not already there */ - pcb->next = udp_pcbs; - udp_pcbs = pcb; - } - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("udp_bind: bound to ")); - ip_addr_debug_print_val(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, pcb->local_ip); - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, (", port %"U16_F")\n", pcb->local_port)); - return ERR_OK; -} - -/** - * @ingroup udp_raw - * Bind an UDP PCB to a specific netif. - * After calling this function, all packets received via this PCB - * are guaranteed to have come in via the specified netif, and all - * outgoing packets will go out via the specified netif. - * - * @param pcb UDP PCB to be bound. - * @param netif netif to bind udp pcb to. Can be NULL. - * - * @see udp_disconnect() - */ -void -udp_bind_netif(struct udp_pcb *pcb, const struct netif *netif) -{ - LWIP_ASSERT_CORE_LOCKED(); - - if (netif != NULL) { - pcb->netif_idx = netif_get_index(netif); - } else { - pcb->netif_idx = NETIF_NO_INDEX; - } -} - -/** - * @ingroup udp_raw - * Sets the remote end of the pcb. This function does not generate any - * network traffic, but only sets the remote address of the pcb. - * - * @param pcb UDP PCB to be connected with remote address ipaddr and port. - * @param ipaddr remote IP address to connect with. - * @param port remote UDP port to connect with. - * - * @return lwIP error code - * - * ipaddr & port are expected to be in the same byte order as in the pcb. - * - * The udp pcb is bound to a random local port if not already bound. - * - * @see udp_disconnect() - */ -err_t -udp_connect(struct udp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port) -{ - struct udp_pcb *ipcb; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("udp_connect: invalid pcb", pcb != NULL, return ERR_ARG); - LWIP_ERROR("udp_connect: invalid ipaddr", ipaddr != NULL, return ERR_ARG); - - if (pcb->local_port == 0) { - err_t err = udp_bind(pcb, &pcb->local_ip, pcb->local_port); - if (err != ERR_OK) { - return err; - } - } - - ip_addr_set_ipaddr(&pcb->remote_ip, ipaddr); -#if LWIP_IPV6 && LWIP_IPV6_SCOPES - /* If the given IP address should have a zone but doesn't, assign one now, - * using the bound address to make a more informed decision when possible. */ - if (IP_IS_V6(&pcb->remote_ip) && - ip6_addr_lacks_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNKNOWN)) { - ip6_addr_select_zone(ip_2_ip6(&pcb->remote_ip), ip_2_ip6(&pcb->local_ip)); - } -#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ - - pcb->remote_port = port; - pcb->flags |= UDP_FLAGS_CONNECTED; - - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("udp_connect: connected to ")); - ip_addr_debug_print_val(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, - pcb->remote_ip); - LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, (", port %"U16_F")\n", pcb->remote_port)); - - /* Insert UDP PCB into the list of active UDP PCBs. */ - for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { - if (pcb == ipcb) { - /* already on the list, just return */ - return ERR_OK; - } - } - /* PCB not yet on the list, add PCB now */ - pcb->next = udp_pcbs; - udp_pcbs = pcb; - return ERR_OK; -} - -/** - * @ingroup udp_raw - * Remove the remote end of the pcb. This function does not generate - * any network traffic, but only removes the remote address of the pcb. - * - * @param pcb the udp pcb to disconnect. - */ -void -udp_disconnect(struct udp_pcb *pcb) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("udp_disconnect: invalid pcb", pcb != NULL, return); - - /* reset remote address association */ -#if LWIP_IPV4 && LWIP_IPV6 - if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { - ip_addr_copy(pcb->remote_ip, *IP_ANY_TYPE); - } else { -#endif - ip_addr_set_any(IP_IS_V6_VAL(pcb->remote_ip), &pcb->remote_ip); -#if LWIP_IPV4 && LWIP_IPV6 - } -#endif - pcb->remote_port = 0; - pcb->netif_idx = NETIF_NO_INDEX; - /* mark PCB as unconnected */ - udp_clear_flags(pcb, UDP_FLAGS_CONNECTED); -} - -/** - * @ingroup udp_raw - * Set a receive callback for a UDP PCB. - * This callback will be called when receiving a datagram for the pcb. - * - * @param pcb the pcb for which to set the recv callback - * @param recv function pointer of the callback function - * @param recv_arg additional argument to pass to the callback function - */ -void -udp_recv(struct udp_pcb *pcb, udp_recv_fn recv, void *recv_arg) -{ - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("udp_recv: invalid pcb", pcb != NULL, return); - - /* remember recv() callback and user data */ - pcb->recv = recv; - pcb->recv_arg = recv_arg; -} - -/** - * @ingroup udp_raw - * Removes and deallocates the pcb. - * - * @param pcb UDP PCB to be removed. The PCB is removed from the list of - * UDP PCB's and the data structure is freed from memory. - * - * @see udp_new() - */ -void -udp_remove(struct udp_pcb *pcb) -{ - struct udp_pcb *pcb2; - - LWIP_ASSERT_CORE_LOCKED(); - - LWIP_ERROR("udp_remove: invalid pcb", pcb != NULL, return); - - mib2_udp_unbind(pcb); - /* pcb to be removed is first in list? */ - if (udp_pcbs == pcb) { - /* make list start at 2nd pcb */ - udp_pcbs = udp_pcbs->next; - /* pcb not 1st in list */ - } else { - for (pcb2 = udp_pcbs; pcb2 != NULL; pcb2 = pcb2->next) { - /* find pcb in udp_pcbs list */ - if (pcb2->next != NULL && pcb2->next == pcb) { - /* remove pcb from list */ - pcb2->next = pcb->next; - break; - } - } - } - memp_free(MEMP_UDP_PCB, pcb); -} - -/** - * @ingroup udp_raw - * Creates a new UDP pcb which can be used for UDP communication. The - * pcb is not active until it has either been bound to a local address - * or connected to a remote address. - * - * @return The UDP PCB which was created. NULL if the PCB data structure - * could not be allocated. - * - * @see udp_remove() - */ -struct udp_pcb * -udp_new(void) -{ - struct udp_pcb *pcb; - - LWIP_ASSERT_CORE_LOCKED(); - - pcb = (struct udp_pcb *)memp_malloc(MEMP_UDP_PCB); - /* could allocate UDP PCB? */ - if (pcb != NULL) { - /* UDP Lite: by initializing to all zeroes, chksum_len is set to 0 - * which means checksum is generated over the whole datagram per default - * (recommended as default by RFC 3828). */ - /* initialize PCB to all zeroes */ - memset(pcb, 0, sizeof(struct udp_pcb)); - pcb->ttl = UDP_TTL; -#if LWIP_MULTICAST_TX_OPTIONS - udp_set_multicast_ttl(pcb, UDP_TTL); -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - } - return pcb; -} - -/** - * @ingroup udp_raw - * Create a UDP PCB for specific IP type. - * The pcb is not active until it has either been bound to a local address - * or connected to a remote address. - * - * @param type IP address type, see @ref lwip_ip_addr_type definitions. - * If you want to listen to IPv4 and IPv6 (dual-stack) packets, - * supply @ref IPADDR_TYPE_ANY as argument and bind to @ref IP_ANY_TYPE. - * @return The UDP PCB which was created. NULL if the PCB data structure - * could not be allocated. - * - * @see udp_remove() - */ -struct udp_pcb * -udp_new_ip_type(u8_t type) -{ - struct udp_pcb *pcb; - - LWIP_ASSERT_CORE_LOCKED(); - - pcb = udp_new(); -#if LWIP_IPV4 && LWIP_IPV6 - if (pcb != NULL) { - IP_SET_TYPE_VAL(pcb->local_ip, type); - IP_SET_TYPE_VAL(pcb->remote_ip, type); - } -#else - LWIP_UNUSED_ARG(type); -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - return pcb; -} - -/** This function is called from netif.c when address is changed - * - * @param old_addr IP address of the netif before change - * @param new_addr IP address of the netif after change - */ -void udp_netif_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) -{ - struct udp_pcb *upcb; - - if (!ip_addr_isany(old_addr) && !ip_addr_isany(new_addr)) { - for (upcb = udp_pcbs; upcb != NULL; upcb = upcb->next) { - /* PCB bound to current local interface address? */ - if (ip_addr_cmp(&upcb->local_ip, old_addr)) { - /* The PCB is bound to the old ipaddr and - * is set to bound to the new one instead */ - ip_addr_copy(upcb->local_ip, *new_addr); - } - } - } -} - -#if UDP_DEBUG -/** - * Print UDP header information for debug purposes. - * - * @param udphdr pointer to the udp header in memory. - */ -void -udp_debug_print(struct udp_hdr *udphdr) -{ - LWIP_DEBUGF(UDP_DEBUG, ("UDP header:\n")); - LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n", - lwip_ntohs(udphdr->src), lwip_ntohs(udphdr->dest))); - LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); - LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | 0x%04"X16_F" | (len, chksum)\n", - lwip_ntohs(udphdr->len), lwip_ntohs(udphdr->chksum))); - LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); -} -#endif /* UDP_DEBUG */ - -#endif /* LWIP_UDP */ +/** + * @file + * User Datagram Protocol module\n + * The code for the User Datagram Protocol UDP & UDPLite (RFC 3828).\n + * See also @ref udp_raw + * + * @defgroup udp_raw UDP + * @ingroup callbackstyle_api + * User Datagram Protocol module\n + * @see @ref api + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/* @todo Check the use of '(struct udp_pcb).chksum_len_rx'! + */ + +#include "lwip/opt.h" + +#if LWIP_UDP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/udp.h" +#include "lwip/def.h" +#include "lwip/memp.h" +#include "lwip/inet_chksum.h" +#include "lwip/ip_addr.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" +#include "lwip/icmp.h" +#include "lwip/icmp6.h" +#include "lwip/stats.h" +#include "lwip/snmp.h" +#include "lwip/dhcp.h" + +#include + +#ifndef UDP_LOCAL_PORT_RANGE_START +/* From http://www.iana.org/assignments/port-numbers: + "The Dynamic and/or Private Ports are those from 49152 through 65535" */ +#define UDP_LOCAL_PORT_RANGE_START 0xc000 +#define UDP_LOCAL_PORT_RANGE_END 0xffff +#define UDP_ENSURE_LOCAL_PORT_RANGE(port) ((u16_t)(((port) & (u16_t)~UDP_LOCAL_PORT_RANGE_START) + UDP_LOCAL_PORT_RANGE_START)) +#endif + +/* last local UDP port */ +static u16_t udp_port = UDP_LOCAL_PORT_RANGE_START; + +/* The list of UDP PCBs */ +/* exported in udp.h (was static) */ +struct udp_pcb *udp_pcbs; + +/** + * Initialize this module. + */ +void +udp_init(void) +{ +#ifdef LWIP_RAND + udp_port = UDP_ENSURE_LOCAL_PORT_RANGE(LWIP_RAND()); +#endif /* LWIP_RAND */ +} + +/** + * Allocate a new local UDP port. + * + * @return a new (free) local UDP port number + */ +static u16_t +udp_new_port(void) +{ + u16_t n = 0; + struct udp_pcb *pcb; + +again: + if (udp_port++ == UDP_LOCAL_PORT_RANGE_END) { + udp_port = UDP_LOCAL_PORT_RANGE_START; + } + /* Check all PCBs. */ + for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) { + if (pcb->local_port == udp_port) { + if (++n > (UDP_LOCAL_PORT_RANGE_END - UDP_LOCAL_PORT_RANGE_START)) { + return 0; + } + goto again; + } + } + return udp_port; +} + +/** Common code to see if the current input packet matches the pcb + * (current input packet is accessed via ip(4/6)_current_* macros) + * + * @param pcb pcb to check + * @param inp network interface on which the datagram was received (only used for IPv4) + * @param broadcast 1 if his is an IPv4 broadcast (global or subnet-only), 0 otherwise (only used for IPv4) + * @return 1 on match, 0 otherwise + */ +static u8_t +udp_input_local_match(struct udp_pcb *pcb, struct netif *inp, u8_t broadcast) +{ + LWIP_UNUSED_ARG(inp); /* in IPv6 only case */ + LWIP_UNUSED_ARG(broadcast); /* in IPv6 only case */ + + LWIP_ASSERT("udp_input_local_match: invalid pcb", pcb != NULL); + LWIP_ASSERT("udp_input_local_match: invalid netif", inp != NULL); + + /* check if PCB is bound to specific netif */ + if ((pcb->netif_idx != NETIF_NO_INDEX) && + (pcb->netif_idx != netif_get_index(ip_data.current_input_netif))) { + return 0; + } + + /* Dual-stack: PCBs listening to any IP type also listen to any IP address */ + if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { +#if LWIP_IPV4 && IP_SOF_BROADCAST_RECV + if ((broadcast != 0) && !ip_get_option(pcb, SOF_BROADCAST)) { + return 0; + } +#endif /* LWIP_IPV4 && IP_SOF_BROADCAST_RECV */ + return 1; + } + + /* Only need to check PCB if incoming IP version matches PCB IP version */ + if (IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ip_current_dest_addr())) { +#if LWIP_IPV4 + /* Special case: IPv4 broadcast: all or broadcasts in my subnet + * Note: broadcast variable can only be 1 if it is an IPv4 broadcast */ + if (broadcast != 0) { +#if IP_SOF_BROADCAST_RECV + if (ip_get_option(pcb, SOF_BROADCAST)) +#endif /* IP_SOF_BROADCAST_RECV */ + { + if (ip4_addr_isany(ip_2_ip4(&pcb->local_ip)) || + ((ip4_current_dest_addr()->addr == IPADDR_BROADCAST)) || + ip4_addr_netcmp(ip_2_ip4(&pcb->local_ip), ip4_current_dest_addr(), netif_ip4_netmask(inp))) { + return 1; + } + } + } else +#endif /* LWIP_IPV4 */ + /* Handle IPv4 and IPv6: all or exact match */ + if (ip_addr_isany(&pcb->local_ip) || ip_addr_cmp(&pcb->local_ip, ip_current_dest_addr())) { + return 1; + } + } + + return 0; +} + +/** + * Process an incoming UDP datagram. + * + * Given an incoming UDP datagram (as a chain of pbufs) this function + * finds a corresponding UDP PCB and hands over the pbuf to the pcbs + * recv function. If no pcb is found or the datagram is incorrect, the + * pbuf is freed. + * + * @param p pbuf to be demultiplexed to a UDP PCB (p->payload pointing to the UDP header) + * @param inp network interface on which the datagram was received. + * + */ +void +udp_input(struct pbuf *p, struct netif *inp) +{ + struct udp_hdr *udphdr; + struct udp_pcb *pcb, *prev; + struct udp_pcb *uncon_pcb; + u16_t src, dest; + u8_t broadcast; + u8_t for_us = 0; + + LWIP_UNUSED_ARG(inp); + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ASSERT("udp_input: invalid pbuf", p != NULL); + LWIP_ASSERT("udp_input: invalid netif", inp != NULL); + + PERF_START; + + UDP_STATS_INC(udp.recv); + + /* Check minimum length (UDP header) */ + if (p->len < UDP_HLEN) { + /* drop short packets */ + LWIP_DEBUGF(UDP_DEBUG, + ("udp_input: short UDP datagram (%"U16_F" bytes) discarded\n", p->tot_len)); + UDP_STATS_INC(udp.lenerr); + UDP_STATS_INC(udp.drop); + MIB2_STATS_INC(mib2.udpinerrors); + pbuf_free(p); + goto end; + } + + udphdr = (struct udp_hdr *)p->payload; + + /* is broadcast packet ? */ + broadcast = ip_addr_isbroadcast(ip_current_dest_addr(), ip_current_netif()); + + LWIP_DEBUGF(UDP_DEBUG, ("udp_input: received datagram of length %"U16_F"\n", p->tot_len)); + + /* convert src and dest ports to host byte order */ + src = lwip_ntohs(udphdr->src); + dest = lwip_ntohs(udphdr->dest); + + udp_debug_print(udphdr); + + /* print the UDP source and destination */ + LWIP_DEBUGF(UDP_DEBUG, ("udp (")); + ip_addr_debug_print_val(UDP_DEBUG, *ip_current_dest_addr()); + LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F") <-- (", lwip_ntohs(udphdr->dest))); + ip_addr_debug_print_val(UDP_DEBUG, *ip_current_src_addr()); + LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F")\n", lwip_ntohs(udphdr->src))); + + pcb = NULL; + prev = NULL; + uncon_pcb = NULL; + /* Iterate through the UDP pcb list for a matching pcb. + * 'Perfect match' pcbs (connected to the remote port & ip address) are + * preferred. If no perfect match is found, the first unconnected pcb that + * matches the local port and ip address gets the datagram. */ + for (pcb = udp_pcbs; pcb != NULL; pcb = pcb->next) { + /* print the PCB local and remote address */ + LWIP_DEBUGF(UDP_DEBUG, ("pcb (")); + ip_addr_debug_print_val(UDP_DEBUG, pcb->local_ip); + LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F") <-- (", pcb->local_port)); + ip_addr_debug_print_val(UDP_DEBUG, pcb->remote_ip); + LWIP_DEBUGF(UDP_DEBUG, (", %"U16_F")\n", pcb->remote_port)); + + /* compare PCB local addr+port to UDP destination addr+port */ + if ((pcb->local_port == dest) && + (udp_input_local_match(pcb, inp, broadcast) != 0)) { + if ((pcb->flags & UDP_FLAGS_CONNECTED) == 0) { + if (uncon_pcb == NULL) { + /* the first unconnected matching PCB */ + uncon_pcb = pcb; +#if LWIP_IPV4 + } else if (broadcast && ip4_current_dest_addr()->addr == IPADDR_BROADCAST) { + /* global broadcast address (only valid for IPv4; match was checked before) */ + if (!IP_IS_V4_VAL(uncon_pcb->local_ip) || !ip4_addr_cmp(ip_2_ip4(&uncon_pcb->local_ip), netif_ip4_addr(inp))) { + /* uncon_pcb does not match the input netif, check this pcb */ + if (IP_IS_V4_VAL(pcb->local_ip) && ip4_addr_cmp(ip_2_ip4(&pcb->local_ip), netif_ip4_addr(inp))) { + /* better match */ + uncon_pcb = pcb; + } + } +#endif /* LWIP_IPV4 */ + } +#if SO_REUSE + else if (!ip_addr_isany(&pcb->local_ip)) { + /* prefer specific IPs over catch-all */ + uncon_pcb = pcb; + } +#endif /* SO_REUSE */ + } + + /* compare PCB remote addr+port to UDP source addr+port */ + if ((pcb->remote_port == src) && + (ip_addr_isany_val(pcb->remote_ip) || + ip_addr_cmp(&pcb->remote_ip, ip_current_src_addr()))) { + /* the first fully matching PCB */ + if (prev != NULL) { + /* move the pcb to the front of udp_pcbs so that is + found faster next time */ + prev->next = pcb->next; + pcb->next = udp_pcbs; + udp_pcbs = pcb; + } else { + UDP_STATS_INC(udp.cachehit); + } + break; + } + } + + prev = pcb; + } + /* no fully matching pcb found? then look for an unconnected pcb */ + if (pcb == NULL) { + pcb = uncon_pcb; + } + + /* Check checksum if this is a match or if it was directed at us. */ + if (pcb != NULL) { + for_us = 1; + } else { +#if LWIP_IPV6 + if (ip_current_is_v6()) { + for_us = netif_get_ip6_addr_match(inp, ip6_current_dest_addr()) >= 0; + } +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 + if (!ip_current_is_v6()) { + for_us = ip4_addr_cmp(netif_ip4_addr(inp), ip4_current_dest_addr()); + } +#endif /* LWIP_IPV4 */ + } + + if (for_us) { + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_input: calculating checksum\n")); +#if CHECKSUM_CHECK_UDP + IF__NETIF_CHECKSUM_ENABLED(inp, NETIF_CHECKSUM_CHECK_UDP) { +#if LWIP_UDPLITE + if (ip_current_header_proto() == IP_PROTO_UDPLITE) { + /* Do the UDP Lite checksum */ + u16_t chklen = lwip_ntohs(udphdr->len); + if (chklen < sizeof(struct udp_hdr)) { + if (chklen == 0) { + /* For UDP-Lite, checksum length of 0 means checksum + over the complete packet (See RFC 3828 chap. 3.1) */ + chklen = p->tot_len; + } else { + /* At least the UDP-Lite header must be covered by the + checksum! (Again, see RFC 3828 chap. 3.1) */ + goto chkerr; + } + } + if (ip_chksum_pseudo_partial(p, IP_PROTO_UDPLITE, + p->tot_len, chklen, + ip_current_src_addr(), ip_current_dest_addr()) != 0) { + goto chkerr; + } + } else +#endif /* LWIP_UDPLITE */ + { + if (udphdr->chksum != 0) { + if (ip_chksum_pseudo(p, IP_PROTO_UDP, p->tot_len, + ip_current_src_addr(), + ip_current_dest_addr()) != 0) { + goto chkerr; + } + } + } + } +#endif /* CHECKSUM_CHECK_UDP */ + if (pbuf_remove_header(p, UDP_HLEN)) { + /* Can we cope with this failing? Just assert for now */ + LWIP_ASSERT("pbuf_remove_header failed\n", 0); + UDP_STATS_INC(udp.drop); + MIB2_STATS_INC(mib2.udpinerrors); + pbuf_free(p); + goto end; + } + + if (pcb != NULL) { + MIB2_STATS_INC(mib2.udpindatagrams); +#if SO_REUSE && SO_REUSE_RXTOALL + if (ip_get_option(pcb, SOF_REUSEADDR) && + (broadcast || ip_addr_ismulticast(ip_current_dest_addr()))) { + /* pass broadcast- or multicast packets to all multicast pcbs + if SOF_REUSEADDR is set on the first match */ + struct udp_pcb *mpcb; + for (mpcb = udp_pcbs; mpcb != NULL; mpcb = mpcb->next) { + if (mpcb != pcb) { + /* compare PCB local addr+port to UDP destination addr+port */ + if ((mpcb->local_port == dest) && + (udp_input_local_match(mpcb, inp, broadcast) != 0)) { + /* pass a copy of the packet to all local matches */ + if (mpcb->recv != NULL) { + struct pbuf *q; + q = pbuf_clone(PBUF_RAW, PBUF_POOL, p); + if (q != NULL) { + mpcb->recv(mpcb->recv_arg, mpcb, q, ip_current_src_addr(), src); + } + } + } + } + } + } +#endif /* SO_REUSE && SO_REUSE_RXTOALL */ + /* callback */ + if (pcb->recv != NULL) { + /* now the recv function is responsible for freeing p */ + pcb->recv(pcb->recv_arg, pcb, p, ip_current_src_addr(), src); + } else { + /* no recv function registered? then we have to free the pbuf! */ + pbuf_free(p); + goto end; + } + } else { + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_input: not for us.\n")); + +#if LWIP_ICMP || LWIP_ICMP6 + /* No match was found, send ICMP destination port unreachable unless + destination address was broadcast/multicast. */ + if (!broadcast && !ip_addr_ismulticast(ip_current_dest_addr())) { + /* move payload pointer back to ip header */ + pbuf_header_force(p, (s16_t)(ip_current_header_tot_len() + UDP_HLEN)); + icmp_port_unreach(ip_current_is_v6(), p); + } +#endif /* LWIP_ICMP || LWIP_ICMP6 */ + UDP_STATS_INC(udp.proterr); + UDP_STATS_INC(udp.drop); + MIB2_STATS_INC(mib2.udpnoports); + pbuf_free(p); + } + } else { + pbuf_free(p); + } +end: + PERF_STOP("udp_input"); + return; +#if CHECKSUM_CHECK_UDP +chkerr: + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("udp_input: UDP (or UDP Lite) datagram discarded due to failing checksum\n")); + UDP_STATS_INC(udp.chkerr); + UDP_STATS_INC(udp.drop); + MIB2_STATS_INC(mib2.udpinerrors); + pbuf_free(p); + PERF_STOP("udp_input"); +#endif /* CHECKSUM_CHECK_UDP */ +} + +/** + * @ingroup udp_raw + * Sends the pbuf p using UDP. The pbuf is not deallocated. + * + * + * @param pcb UDP PCB used to send the data. + * @param p chain of pbuf's to be sent. + * + * The datagram will be sent to the current remote_ip & remote_port + * stored in pcb. If the pcb is not bound to a port, it will + * automatically be bound to a random port. + * + * @return lwIP error code. + * - ERR_OK. Successful. No error occurred. + * - ERR_MEM. Out of memory. + * - ERR_RTE. Could not find route to destination address. + * - ERR_VAL. No PCB or PCB is dual-stack + * - More errors could be returned by lower protocol layers. + * + * @see udp_disconnect() udp_sendto() + */ +err_t +udp_send(struct udp_pcb *pcb, struct pbuf *p) +{ + LWIP_ERROR("udp_send: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_ERROR("udp_send: invalid pbuf", p != NULL, return ERR_ARG); + + if (IP_IS_ANY_TYPE_VAL(pcb->remote_ip)) { + return ERR_VAL; + } + + /* send to the packet using remote ip and port stored in the pcb */ + return udp_sendto(pcb, p, &pcb->remote_ip, pcb->remote_port); +} + +#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP +/** @ingroup udp_raw + * Same as udp_send() but with checksum + */ +err_t +udp_send_chksum(struct udp_pcb *pcb, struct pbuf *p, + u8_t have_chksum, u16_t chksum) +{ + LWIP_ERROR("udp_send_chksum: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_ERROR("udp_send_chksum: invalid pbuf", p != NULL, return ERR_ARG); + + if (IP_IS_ANY_TYPE_VAL(pcb->remote_ip)) { + return ERR_VAL; + } + + /* send to the packet using remote ip and port stored in the pcb */ + return udp_sendto_chksum(pcb, p, &pcb->remote_ip, pcb->remote_port, + have_chksum, chksum); +} +#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ + +/** + * @ingroup udp_raw + * Send data to a specified address using UDP. + * + * @param pcb UDP PCB used to send the data. + * @param p chain of pbuf's to be sent. + * @param dst_ip Destination IP address. + * @param dst_port Destination UDP port. + * + * dst_ip & dst_port are expected to be in the same byte order as in the pcb. + * + * If the PCB already has a remote address association, it will + * be restored after the data is sent. + * + * @return lwIP error code (@see udp_send for possible error codes) + * + * @see udp_disconnect() udp_send() + */ +err_t +udp_sendto(struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port) +{ +#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP + return udp_sendto_chksum(pcb, p, dst_ip, dst_port, 0, 0); +} + +/** @ingroup udp_raw + * Same as udp_sendto(), but with checksum */ +err_t +udp_sendto_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, + u16_t dst_port, u8_t have_chksum, u16_t chksum) +{ +#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ + struct netif *netif; + + LWIP_ERROR("udp_sendto: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto: invalid pbuf", p != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto: invalid dst_ip", dst_ip != NULL, return ERR_ARG); + + if (!IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { + return ERR_VAL; + } + + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_send\n")); + + if (pcb->netif_idx != NETIF_NO_INDEX) { + netif = netif_get_by_index(pcb->netif_idx); + } else { +#if LWIP_MULTICAST_TX_OPTIONS + netif = NULL; + if (ip_addr_ismulticast(dst_ip)) { + /* For IPv6, the interface to use for packets with a multicast destination + * is specified using an interface index. The same approach may be used for + * IPv4 as well, in which case it overrides the IPv4 multicast override + * address below. Here we have to look up the netif by going through the + * list, but by doing so we skip a route lookup. If the interface index has + * gone stale, we fall through and do the regular route lookup after all. */ + if (pcb->mcast_ifindex != NETIF_NO_INDEX) { + netif = netif_get_by_index(pcb->mcast_ifindex); + } +#if LWIP_IPV4 + else +#if LWIP_IPV6 + if (IP_IS_V4(dst_ip)) +#endif /* LWIP_IPV6 */ + { + /* IPv4 does not use source-based routing by default, so we use an + administratively selected interface for multicast by default. + However, this can be overridden by setting an interface address + in pcb->mcast_ip4 that is used for routing. If this routing lookup + fails, we try regular routing as though no override was set. */ + if (!ip4_addr_isany_val(pcb->mcast_ip4) && + !ip4_addr_cmp(&pcb->mcast_ip4, IP4_ADDR_BROADCAST)) { + netif = ip4_route_src(ip_2_ip4(&pcb->local_ip), &pcb->mcast_ip4); + } + } +#endif /* LWIP_IPV4 */ + } + + if (netif == NULL) +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + { + /* find the outgoing network interface for this packet */ + netif = ip_route(&pcb->local_ip, dst_ip); + } + } + + /* no outgoing network interface could be found? */ + if (netif == NULL) { + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("udp_send: No route to ")); + ip_addr_debug_print(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, dst_ip); + LWIP_DEBUGF(UDP_DEBUG, ("\n")); + UDP_STATS_INC(udp.rterr); + return ERR_RTE; + } +#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP + return udp_sendto_if_chksum(pcb, p, dst_ip, dst_port, netif, have_chksum, chksum); +#else /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ + return udp_sendto_if(pcb, p, dst_ip, dst_port, netif); +#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ +} + +/** + * @ingroup udp_raw + * Send data to a specified address using UDP. + * The netif used for sending can be specified. + * + * This function exists mainly for DHCP, to be able to send UDP packets + * on a netif that is still down. + * + * @param pcb UDP PCB used to send the data. + * @param p chain of pbuf's to be sent. + * @param dst_ip Destination IP address. + * @param dst_port Destination UDP port. + * @param netif the netif used for sending. + * + * dst_ip & dst_port are expected to be in the same byte order as in the pcb. + * + * @return lwIP error code (@see udp_send for possible error codes) + * + * @see udp_disconnect() udp_send() + */ +err_t +udp_sendto_if(struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif) +{ +#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP + return udp_sendto_if_chksum(pcb, p, dst_ip, dst_port, netif, 0, 0); +} + +/** Same as udp_sendto_if(), but with checksum */ +err_t +udp_sendto_if_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, + u16_t dst_port, struct netif *netif, u8_t have_chksum, + u16_t chksum) +{ +#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ + const ip_addr_t *src_ip; + + LWIP_ERROR("udp_sendto_if: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto_if: invalid pbuf", p != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto_if: invalid dst_ip", dst_ip != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto_if: invalid netif", netif != NULL, return ERR_ARG); + + if (!IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { + return ERR_VAL; + } + + /* PCB local address is IP_ANY_ADDR or multicast? */ +#if LWIP_IPV6 + if (IP_IS_V6(dst_ip)) { + if (ip6_addr_isany(ip_2_ip6(&pcb->local_ip)) || + ip6_addr_ismulticast(ip_2_ip6(&pcb->local_ip))) { + src_ip = ip6_select_source_address(netif, ip_2_ip6(dst_ip)); + if (src_ip == NULL) { + /* No suitable source address was found. */ + return ERR_RTE; + } + } else { + /* use UDP PCB local IPv6 address as source address, if still valid. */ + if (netif_get_ip6_addr_match(netif, ip_2_ip6(&pcb->local_ip)) < 0) { + /* Address isn't valid anymore. */ + return ERR_RTE; + } + src_ip = &pcb->local_ip; + } + } +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 && LWIP_IPV6 + else +#endif /* LWIP_IPV4 && LWIP_IPV6 */ +#if LWIP_IPV4 + if (ip4_addr_isany(ip_2_ip4(&pcb->local_ip)) || + ip4_addr_ismulticast(ip_2_ip4(&pcb->local_ip))) { + /* if the local_ip is any or multicast + * use the outgoing network interface IP address as source address */ + src_ip = netif_ip_addr4(netif); + } else { + /* check if UDP PCB local IP address is correct + * this could be an old address if netif->ip_addr has changed */ + if (!ip4_addr_cmp(ip_2_ip4(&(pcb->local_ip)), netif_ip4_addr(netif))) { + /* local_ip doesn't match, drop the packet */ + return ERR_RTE; + } + /* use UDP PCB local IP address as source address */ + src_ip = &pcb->local_ip; + } +#endif /* LWIP_IPV4 */ +#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP + return udp_sendto_if_src_chksum(pcb, p, dst_ip, dst_port, netif, have_chksum, chksum, src_ip); +#else /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ + return udp_sendto_if_src(pcb, p, dst_ip, dst_port, netif, src_ip); +#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ +} + +/** @ingroup udp_raw + * Same as @ref udp_sendto_if, but with source address */ +err_t +udp_sendto_if_src(struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif, const ip_addr_t *src_ip) +{ +#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP + return udp_sendto_if_src_chksum(pcb, p, dst_ip, dst_port, netif, 0, 0, src_ip); +} + +/** Same as udp_sendto_if_src(), but with checksum */ +err_t +udp_sendto_if_src_chksum(struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, + u16_t dst_port, struct netif *netif, u8_t have_chksum, + u16_t chksum, const ip_addr_t *src_ip) +{ +#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ + struct udp_hdr *udphdr; + err_t err; + struct pbuf *q; /* q will be sent down the stack */ + u8_t ip_proto; + u8_t ttl; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("udp_sendto_if_src: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto_if_src: invalid pbuf", p != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto_if_src: invalid dst_ip", dst_ip != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto_if_src: invalid src_ip", src_ip != NULL, return ERR_ARG); + LWIP_ERROR("udp_sendto_if_src: invalid netif", netif != NULL, return ERR_ARG); + + if (!IP_ADDR_PCB_VERSION_MATCH(pcb, src_ip) || + !IP_ADDR_PCB_VERSION_MATCH(pcb, dst_ip)) { + return ERR_VAL; + } + +#if LWIP_IPV4 && IP_SOF_BROADCAST + /* broadcast filter? */ + if (!ip_get_option(pcb, SOF_BROADCAST) && +#if LWIP_IPV6 + IP_IS_V4(dst_ip) && +#endif /* LWIP_IPV6 */ + ip_addr_isbroadcast(dst_ip, netif)) { + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, + ("udp_sendto_if: SOF_BROADCAST not enabled on pcb %p\n", (void *)pcb)); + return ERR_VAL; + } +#endif /* LWIP_IPV4 && IP_SOF_BROADCAST */ + + /* if the PCB is not yet bound to a port, bind it here */ + if (pcb->local_port == 0) { + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_send: not yet bound to a port, binding now\n")); + err = udp_bind(pcb, &pcb->local_ip, pcb->local_port); + if (err != ERR_OK) { + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("udp_send: forced port bind failed\n")); + return err; + } + } + + /* packet too large to add a UDP header without causing an overflow? */ + if ((u16_t)(p->tot_len + UDP_HLEN) < p->tot_len) { + return ERR_MEM; + } + /* not enough space to add an UDP header to first pbuf in given p chain? */ + if (pbuf_add_header(p, UDP_HLEN)) { + /* allocate header in a separate new pbuf */ + q = pbuf_alloc(PBUF_IP, UDP_HLEN, PBUF_RAM); + /* new header pbuf could not be allocated? */ + if (q == NULL) { + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, ("udp_send: could not allocate header\n")); + return ERR_MEM; + } + if (p->tot_len != 0) { + /* chain header q in front of given pbuf p (only if p contains data) */ + pbuf_chain(q, p); + } + /* first pbuf q points to header pbuf */ + LWIP_DEBUGF(UDP_DEBUG, + ("udp_send: added header pbuf %p before given pbuf %p\n", (void *)q, (void *)p)); + } else { + /* adding space for header within p succeeded */ + /* first pbuf q equals given pbuf */ + q = p; + LWIP_DEBUGF(UDP_DEBUG, ("udp_send: added header in given pbuf %p\n", (void *)p)); + } + LWIP_ASSERT("check that first pbuf can hold struct udp_hdr", + (q->len >= sizeof(struct udp_hdr))); + /* q now represents the packet to be sent */ + udphdr = (struct udp_hdr *)q->payload; + udphdr->src = lwip_htons(pcb->local_port); + udphdr->dest = lwip_htons(dst_port); + /* in UDP, 0 checksum means 'no checksum' */ + udphdr->chksum = 0x0000; + + /* Multicast Loop? */ +#if LWIP_MULTICAST_TX_OPTIONS + if (((pcb->flags & UDP_FLAGS_MULTICAST_LOOP) != 0) && ip_addr_ismulticast(dst_ip)) { + q->flags |= PBUF_FLAG_MCASTLOOP; + } +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + + LWIP_DEBUGF(UDP_DEBUG, ("udp_send: sending datagram of length %"U16_F"\n", q->tot_len)); + +#if LWIP_UDPLITE + /* UDP Lite protocol? */ + if (pcb->flags & UDP_FLAGS_UDPLITE) { + u16_t chklen, chklen_hdr; + LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP LITE packet length %"U16_F"\n", q->tot_len)); + /* set UDP message length in UDP header */ + chklen_hdr = chklen = pcb->chksum_len_tx; + if ((chklen < sizeof(struct udp_hdr)) || (chklen > q->tot_len)) { + if (chklen != 0) { + LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP LITE pcb->chksum_len is illegal: %"U16_F"\n", chklen)); + } + /* For UDP-Lite, checksum length of 0 means checksum + over the complete packet. (See RFC 3828 chap. 3.1) + At least the UDP-Lite header must be covered by the + checksum, therefore, if chksum_len has an illegal + value, we generate the checksum over the complete + packet to be safe. */ + chklen_hdr = 0; + chklen = q->tot_len; + } + udphdr->len = lwip_htons(chklen_hdr); + /* calculate checksum */ +#if CHECKSUM_GEN_UDP + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) { +#if LWIP_CHECKSUM_ON_COPY + if (have_chksum) { + chklen = UDP_HLEN; + } +#endif /* LWIP_CHECKSUM_ON_COPY */ + udphdr->chksum = ip_chksum_pseudo_partial(q, IP_PROTO_UDPLITE, + q->tot_len, chklen, src_ip, dst_ip); +#if LWIP_CHECKSUM_ON_COPY + if (have_chksum) { + u32_t acc; + acc = udphdr->chksum + (u16_t)~(chksum); + udphdr->chksum = FOLD_U32T(acc); + } +#endif /* LWIP_CHECKSUM_ON_COPY */ + + /* chksum zero must become 0xffff, as zero means 'no checksum' */ + if (udphdr->chksum == 0x0000) { + udphdr->chksum = 0xffff; + } + } +#endif /* CHECKSUM_GEN_UDP */ + + ip_proto = IP_PROTO_UDPLITE; + } else +#endif /* LWIP_UDPLITE */ + { /* UDP */ + LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP packet length %"U16_F"\n", q->tot_len)); + udphdr->len = lwip_htons(q->tot_len); + /* calculate checksum */ +#if CHECKSUM_GEN_UDP + IF__NETIF_CHECKSUM_ENABLED(netif, NETIF_CHECKSUM_GEN_UDP) { + /* Checksum is mandatory over IPv6. */ + if (IP_IS_V6(dst_ip) || (pcb->flags & UDP_FLAGS_NOCHKSUM) == 0) { + u16_t udpchksum; +#if LWIP_CHECKSUM_ON_COPY + if (have_chksum) { + u32_t acc; + udpchksum = ip_chksum_pseudo_partial(q, IP_PROTO_UDP, + q->tot_len, UDP_HLEN, src_ip, dst_ip); + acc = udpchksum + (u16_t)~(chksum); + udpchksum = FOLD_U32T(acc); + } else +#endif /* LWIP_CHECKSUM_ON_COPY */ + { + udpchksum = ip_chksum_pseudo(q, IP_PROTO_UDP, q->tot_len, + src_ip, dst_ip); + } + + /* chksum zero must become 0xffff, as zero means 'no checksum' */ + if (udpchksum == 0x0000) { + udpchksum = 0xffff; + } + udphdr->chksum = udpchksum; + } + } +#endif /* CHECKSUM_GEN_UDP */ + ip_proto = IP_PROTO_UDP; + } + + /* Determine TTL to use */ +#if LWIP_MULTICAST_TX_OPTIONS + ttl = (ip_addr_ismulticast(dst_ip) ? udp_get_multicast_ttl(pcb) : pcb->ttl); +#else /* LWIP_MULTICAST_TX_OPTIONS */ + ttl = pcb->ttl; +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + + LWIP_DEBUGF(UDP_DEBUG, ("udp_send: UDP checksum 0x%04"X16_F"\n", udphdr->chksum)); + LWIP_DEBUGF(UDP_DEBUG, ("udp_send: ip_output_if (,,,,0x%02"X16_F",)\n", (u16_t)ip_proto)); + /* output to IP */ + NETIF_SET_HINTS(netif, &(pcb->netif_hints)); + err = ip_output_if_src(q, src_ip, dst_ip, ttl, pcb->tos, ip_proto, netif); + NETIF_RESET_HINTS(netif); + + /* @todo: must this be increased even if error occurred? */ + MIB2_STATS_INC(mib2.udpoutdatagrams); + + /* did we chain a separate header pbuf earlier? */ + if (q != p) { + /* free the header pbuf */ + pbuf_free(q); + q = NULL; + /* p is still referenced by the caller, and will live on */ + } + + UDP_STATS_INC(udp.xmit); + return err; +} + +/** + * @ingroup udp_raw + * Bind an UDP PCB. + * + * @param pcb UDP PCB to be bound with a local address ipaddr and port. + * @param ipaddr local IP address to bind with. Use IP_ANY_TYPE to + * bind to all local interfaces. + * @param port local UDP port to bind with. Use 0 to automatically bind + * to a random port between UDP_LOCAL_PORT_RANGE_START and + * UDP_LOCAL_PORT_RANGE_END. + * + * ipaddr & port are expected to be in the same byte order as in the pcb. + * + * @return lwIP error code. + * - ERR_OK. Successful. No error occurred. + * - ERR_USE. The specified ipaddr and port are already bound to by + * another UDP PCB. + * + * @see udp_disconnect() + */ +err_t +udp_bind(struct udp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port) +{ + struct udp_pcb *ipcb; + u8_t rebind; +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + ip_addr_t zoned_ipaddr; +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + + LWIP_ASSERT_CORE_LOCKED(); + +#if LWIP_IPV4 + /* Don't propagate NULL pointer (IPv4 ANY) to subsequent functions */ + if (ipaddr == NULL) { + ipaddr = IP4_ADDR_ANY; + } +#else /* LWIP_IPV4 */ + LWIP_ERROR("udp_bind: invalid ipaddr", ipaddr != NULL, return ERR_ARG); +#endif /* LWIP_IPV4 */ + + LWIP_ERROR("udp_bind: invalid pcb", pcb != NULL, return ERR_ARG); + + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, ("udp_bind(ipaddr = ")); + ip_addr_debug_print(UDP_DEBUG | LWIP_DBG_TRACE, ipaddr); + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE, (", port = %"U16_F")\n", port)); + + rebind = 0; + /* Check for double bind and rebind of the same pcb */ + for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { + /* is this UDP PCB already on active list? */ + if (pcb == ipcb) { + rebind = 1; + break; + } + } + +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + /* If the given IP address should have a zone but doesn't, assign one now. + * This is legacy support: scope-aware callers should always provide properly + * zoned source addresses. Do the zone selection before the address-in-use + * check below; as such we have to make a temporary copy of the address. */ + if (IP_IS_V6(ipaddr) && ip6_addr_lacks_zone(ip_2_ip6(ipaddr), IP6_UNKNOWN)) { + ip_addr_copy(zoned_ipaddr, *ipaddr); + ip6_addr_select_zone(ip_2_ip6(&zoned_ipaddr), ip_2_ip6(&zoned_ipaddr)); + ipaddr = &zoned_ipaddr; + } +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + + /* no port specified? */ + if (port == 0) { + port = udp_new_port(); + if (port == 0) { + /* no more ports available in local range */ + LWIP_DEBUGF(UDP_DEBUG, ("udp_bind: out of free UDP ports\n")); + return ERR_USE; + } + } else { + for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { + if (pcb != ipcb) { + /* By default, we don't allow to bind to a port that any other udp + PCB is already bound to, unless *all* PCBs with that port have tha + REUSEADDR flag set. */ +#if SO_REUSE + if (!ip_get_option(pcb, SOF_REUSEADDR) || + !ip_get_option(ipcb, SOF_REUSEADDR)) +#endif /* SO_REUSE */ + { + /* port matches that of PCB in list and REUSEADDR not set -> reject */ + if ((ipcb->local_port == port) && + /* IP address matches or any IP used? */ + (ip_addr_cmp(&ipcb->local_ip, ipaddr) || ip_addr_isany(ipaddr) || + ip_addr_isany(&ipcb->local_ip))) { + /* other PCB already binds to this local IP and port */ + LWIP_DEBUGF(UDP_DEBUG, + ("udp_bind: local port %"U16_F" already bound by another pcb\n", port)); + return ERR_USE; + } + } + } + } + } + + ip_addr_set_ipaddr(&pcb->local_ip, ipaddr); + + pcb->local_port = port; + mib2_udp_bind(pcb); + /* pcb not active yet? */ + if (rebind == 0) { + /* place the PCB on the active list if not already there */ + pcb->next = udp_pcbs; + udp_pcbs = pcb; + } + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("udp_bind: bound to ")); + ip_addr_debug_print_val(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, pcb->local_ip); + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, (", port %"U16_F")\n", pcb->local_port)); + return ERR_OK; +} + +/** + * @ingroup udp_raw + * Bind an UDP PCB to a specific netif. + * After calling this function, all packets received via this PCB + * are guaranteed to have come in via the specified netif, and all + * outgoing packets will go out via the specified netif. + * + * @param pcb UDP PCB to be bound. + * @param netif netif to bind udp pcb to. Can be NULL. + * + * @see udp_disconnect() + */ +void +udp_bind_netif(struct udp_pcb *pcb, const struct netif *netif) +{ + LWIP_ASSERT_CORE_LOCKED(); + + if (netif != NULL) { + pcb->netif_idx = netif_get_index(netif); + } else { + pcb->netif_idx = NETIF_NO_INDEX; + } +} + +/** + * @ingroup udp_raw + * Sets the remote end of the pcb. This function does not generate any + * network traffic, but only sets the remote address of the pcb. + * + * @param pcb UDP PCB to be connected with remote address ipaddr and port. + * @param ipaddr remote IP address to connect with. + * @param port remote UDP port to connect with. + * + * @return lwIP error code + * + * ipaddr & port are expected to be in the same byte order as in the pcb. + * + * The udp pcb is bound to a random local port if not already bound. + * + * @see udp_disconnect() + */ +err_t +udp_connect(struct udp_pcb *pcb, const ip_addr_t *ipaddr, u16_t port) +{ + struct udp_pcb *ipcb; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("udp_connect: invalid pcb", pcb != NULL, return ERR_ARG); + LWIP_ERROR("udp_connect: invalid ipaddr", ipaddr != NULL, return ERR_ARG); + + if (pcb->local_port == 0) { + err_t err = udp_bind(pcb, &pcb->local_ip, pcb->local_port); + if (err != ERR_OK) { + return err; + } + } + + ip_addr_set_ipaddr(&pcb->remote_ip, ipaddr); +#if LWIP_IPV6 && LWIP_IPV6_SCOPES + /* If the given IP address should have a zone but doesn't, assign one now, + * using the bound address to make a more informed decision when possible. */ + if (IP_IS_V6(&pcb->remote_ip) && + ip6_addr_lacks_zone(ip_2_ip6(&pcb->remote_ip), IP6_UNKNOWN)) { + ip6_addr_select_zone(ip_2_ip6(&pcb->remote_ip), ip_2_ip6(&pcb->local_ip)); + } +#endif /* LWIP_IPV6 && LWIP_IPV6_SCOPES */ + + pcb->remote_port = port; + pcb->flags |= UDP_FLAGS_CONNECTED; + + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, ("udp_connect: connected to ")); + ip_addr_debug_print_val(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, + pcb->remote_ip); + LWIP_DEBUGF(UDP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_STATE, (", port %"U16_F")\n", pcb->remote_port)); + + /* Insert UDP PCB into the list of active UDP PCBs. */ + for (ipcb = udp_pcbs; ipcb != NULL; ipcb = ipcb->next) { + if (pcb == ipcb) { + /* already on the list, just return */ + return ERR_OK; + } + } + /* PCB not yet on the list, add PCB now */ + pcb->next = udp_pcbs; + udp_pcbs = pcb; + return ERR_OK; +} + +/** + * @ingroup udp_raw + * Remove the remote end of the pcb. This function does not generate + * any network traffic, but only removes the remote address of the pcb. + * + * @param pcb the udp pcb to disconnect. + */ +void +udp_disconnect(struct udp_pcb *pcb) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("udp_disconnect: invalid pcb", pcb != NULL, return); + + /* reset remote address association */ +#if LWIP_IPV4 && LWIP_IPV6 + if (IP_IS_ANY_TYPE_VAL(pcb->local_ip)) { + ip_addr_copy(pcb->remote_ip, *IP_ANY_TYPE); + } else { +#endif + ip_addr_set_any(IP_IS_V6_VAL(pcb->remote_ip), &pcb->remote_ip); +#if LWIP_IPV4 && LWIP_IPV6 + } +#endif + pcb->remote_port = 0; + pcb->netif_idx = NETIF_NO_INDEX; + /* mark PCB as unconnected */ + udp_clear_flags(pcb, UDP_FLAGS_CONNECTED); +} + +/** + * @ingroup udp_raw + * Set a receive callback for a UDP PCB. + * This callback will be called when receiving a datagram for the pcb. + * + * @param pcb the pcb for which to set the recv callback + * @param recv function pointer of the callback function + * @param recv_arg additional argument to pass to the callback function + */ +void +udp_recv(struct udp_pcb *pcb, udp_recv_fn recv, void *recv_arg) +{ + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("udp_recv: invalid pcb", pcb != NULL, return); + + /* remember recv() callback and user data */ + pcb->recv = recv; + pcb->recv_arg = recv_arg; +} + +/** + * @ingroup udp_raw + * Removes and deallocates the pcb. + * + * @param pcb UDP PCB to be removed. The PCB is removed from the list of + * UDP PCB's and the data structure is freed from memory. + * + * @see udp_new() + */ +void +udp_remove(struct udp_pcb *pcb) +{ + struct udp_pcb *pcb2; + + LWIP_ASSERT_CORE_LOCKED(); + + LWIP_ERROR("udp_remove: invalid pcb", pcb != NULL, return); + + mib2_udp_unbind(pcb); + /* pcb to be removed is first in list? */ + if (udp_pcbs == pcb) { + /* make list start at 2nd pcb */ + udp_pcbs = udp_pcbs->next; + /* pcb not 1st in list */ + } else { + for (pcb2 = udp_pcbs; pcb2 != NULL; pcb2 = pcb2->next) { + /* find pcb in udp_pcbs list */ + if (pcb2->next != NULL && pcb2->next == pcb) { + /* remove pcb from list */ + pcb2->next = pcb->next; + break; + } + } + } + memp_free(MEMP_UDP_PCB, pcb); +} + +/** + * @ingroup udp_raw + * Creates a new UDP pcb which can be used for UDP communication. The + * pcb is not active until it has either been bound to a local address + * or connected to a remote address. + * + * @return The UDP PCB which was created. NULL if the PCB data structure + * could not be allocated. + * + * @see udp_remove() + */ +struct udp_pcb * +udp_new(void) +{ + struct udp_pcb *pcb; + + LWIP_ASSERT_CORE_LOCKED(); + + pcb = (struct udp_pcb *)memp_malloc(MEMP_UDP_PCB); + /* could allocate UDP PCB? */ + if (pcb != NULL) { + /* UDP Lite: by initializing to all zeroes, chksum_len is set to 0 + * which means checksum is generated over the whole datagram per default + * (recommended as default by RFC 3828). */ + /* initialize PCB to all zeroes */ + memset(pcb, 0, sizeof(struct udp_pcb)); + pcb->ttl = UDP_TTL; +#if LWIP_MULTICAST_TX_OPTIONS + udp_set_multicast_ttl(pcb, UDP_TTL); +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + } + return pcb; +} + +/** + * @ingroup udp_raw + * Create a UDP PCB for specific IP type. + * The pcb is not active until it has either been bound to a local address + * or connected to a remote address. + * + * @param type IP address type, see @ref lwip_ip_addr_type definitions. + * If you want to listen to IPv4 and IPv6 (dual-stack) packets, + * supply @ref IPADDR_TYPE_ANY as argument and bind to @ref IP_ANY_TYPE. + * @return The UDP PCB which was created. NULL if the PCB data structure + * could not be allocated. + * + * @see udp_remove() + */ +struct udp_pcb * +udp_new_ip_type(u8_t type) +{ + struct udp_pcb *pcb; + + LWIP_ASSERT_CORE_LOCKED(); + + pcb = udp_new(); +#if LWIP_IPV4 && LWIP_IPV6 + if (pcb != NULL) { + IP_SET_TYPE_VAL(pcb->local_ip, type); + IP_SET_TYPE_VAL(pcb->remote_ip, type); + } +#else + LWIP_UNUSED_ARG(type); +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + return pcb; +} + +/** This function is called from netif.c when address is changed + * + * @param old_addr IP address of the netif before change + * @param new_addr IP address of the netif after change + */ +void udp_netif_ip_addr_changed(const ip_addr_t *old_addr, const ip_addr_t *new_addr) +{ + struct udp_pcb *upcb; + + if (!ip_addr_isany(old_addr) && !ip_addr_isany(new_addr)) { + for (upcb = udp_pcbs; upcb != NULL; upcb = upcb->next) { + /* PCB bound to current local interface address? */ + if (ip_addr_cmp(&upcb->local_ip, old_addr)) { + /* The PCB is bound to the old ipaddr and + * is set to bound to the new one instead */ + ip_addr_copy(upcb->local_ip, *new_addr); + } + } + } +} + +#if UDP_DEBUG +/** + * Print UDP header information for debug purposes. + * + * @param udphdr pointer to the udp header in memory. + */ +void +udp_debug_print(struct udp_hdr *udphdr) +{ + LWIP_DEBUGF(UDP_DEBUG, ("UDP header:\n")); + LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | %5"U16_F" | (src port, dest port)\n", + lwip_ntohs(udphdr->src), lwip_ntohs(udphdr->dest))); + LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); + LWIP_DEBUGF(UDP_DEBUG, ("| %5"U16_F" | 0x%04"X16_F" | (len, chksum)\n", + lwip_ntohs(udphdr->len), lwip_ntohs(udphdr->chksum))); + LWIP_DEBUGF(UDP_DEBUG, ("+-------------------------------+\n")); +} +#endif /* UDP_DEBUG */ + +#endif /* LWIP_UDP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/arpa/inet.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/arpa/inet.h index 68267e51..0ed9baf3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/arpa/inet.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/arpa/inet.h @@ -1,33 +1,33 @@ -/** - * @file - * This file is a posix wrapper for lwip/sockets.h. - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/sockets.h" +/** + * @file + * This file is a posix wrapper for lwip/sockets.h. + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/sockets.h" diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/net/if.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/net/if.h index a17e8ade..6b8e63a5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/net/if.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/net/if.h @@ -1,36 +1,36 @@ -/** - * @file - * This file is a posix wrapper for lwip/if_api.h. - */ - -/* - * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/if_api.h" +/** + * @file + * This file is a posix wrapper for lwip/if_api.h. + */ + +/* + * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/if_api.h" diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/netdb.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/netdb.h index 29abbafe..12d4c7f5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/netdb.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/netdb.h @@ -1,33 +1,33 @@ -/** - * @file - * This file is a posix wrapper for lwip/netdb.h. - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/netdb.h" +/** + * @file + * This file is a posix wrapper for lwip/netdb.h. + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/netdb.h" diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/sys/socket.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/sys/socket.h index 68267e51..0ed9baf3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/sys/socket.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/posix/sys/socket.h @@ -1,33 +1,33 @@ -/** - * @file - * This file is a posix wrapper for lwip/sockets.h. - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/sockets.h" +/** + * @file + * This file is a posix wrapper for lwip/sockets.h. + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/sockets.h" diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/stdc/errno.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/stdc/errno.h index a3bbfd26..98a9aec9 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/stdc/errno.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/compat/stdc/errno.h @@ -1,33 +1,33 @@ -/** - * @file - * This file is a posix/stdc wrapper for lwip/errno.h. - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/errno.h" +/** + * @file + * This file is a posix/stdc wrapper for lwip/errno.h. + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/errno.h" diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp.h index 08bb8d54..97abc54d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp.h @@ -1,201 +1,201 @@ -/** - * @file - * Application layered TCP connection API (to be used from TCPIP thread)\n - * - * This file contains the generic API. - * For more details see @ref altcp_api. - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_ALTCP_H -#define LWIP_HDR_ALTCP_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/tcpbase.h" -#include "lwip/err.h" -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct altcp_pcb; -struct altcp_functions; - -typedef err_t (*altcp_accept_fn)(void *arg, struct altcp_pcb *new_conn, err_t err); -typedef err_t (*altcp_connected_fn)(void *arg, struct altcp_pcb *conn, err_t err); -typedef err_t (*altcp_recv_fn)(void *arg, struct altcp_pcb *conn, struct pbuf *p, err_t err); -typedef err_t (*altcp_sent_fn)(void *arg, struct altcp_pcb *conn, u16_t len); -typedef err_t (*altcp_poll_fn)(void *arg, struct altcp_pcb *conn); -typedef void (*altcp_err_fn)(void *arg, err_t err); - -typedef struct altcp_pcb* (*altcp_new_fn)(void *arg, u8_t ip_type); - -struct altcp_pcb { - const struct altcp_functions *fns; - struct altcp_pcb *inner_conn; - void *arg; - void *state; - /* application callbacks */ - altcp_accept_fn accept; - altcp_connected_fn connected; - altcp_recv_fn recv; - altcp_sent_fn sent; - altcp_poll_fn poll; - altcp_err_fn err; - u8_t pollinterval; -}; - -/** @ingroup altcp */ -typedef struct altcp_allocator_s { - /** Allocator function */ - altcp_new_fn alloc; - /** Argument to allocator function */ - void *arg; -} altcp_allocator_t; - -struct altcp_pcb *altcp_new(altcp_allocator_t *allocator); -struct altcp_pcb *altcp_new_ip6(altcp_allocator_t *allocator); -struct altcp_pcb *altcp_new_ip_type(altcp_allocator_t *allocator, u8_t ip_type); - -void altcp_arg(struct altcp_pcb *conn, void *arg); -void altcp_accept(struct altcp_pcb *conn, altcp_accept_fn accept); -void altcp_recv(struct altcp_pcb *conn, altcp_recv_fn recv); -void altcp_sent(struct altcp_pcb *conn, altcp_sent_fn sent); -void altcp_poll(struct altcp_pcb *conn, altcp_poll_fn poll, u8_t interval); -void altcp_err(struct altcp_pcb *conn, altcp_err_fn err); - -void altcp_recved(struct altcp_pcb *conn, u16_t len); -err_t altcp_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port); -err_t altcp_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected); - -/* return conn for source code compatibility to tcp callback API only */ -struct altcp_pcb *altcp_listen_with_backlog_and_err(struct altcp_pcb *conn, u8_t backlog, err_t *err); -#define altcp_listen_with_backlog(conn, backlog) altcp_listen_with_backlog_and_err(conn, backlog, NULL) -/** @ingroup altcp */ -#define altcp_listen(conn) altcp_listen_with_backlog_and_err(conn, TCP_DEFAULT_LISTEN_BACKLOG, NULL) - -void altcp_abort(struct altcp_pcb *conn); -err_t altcp_close(struct altcp_pcb *conn); -err_t altcp_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx); - -err_t altcp_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags); -err_t altcp_output(struct altcp_pcb *conn); - -u16_t altcp_mss(struct altcp_pcb *conn); -u16_t altcp_sndbuf(struct altcp_pcb *conn); -u16_t altcp_sndqueuelen(struct altcp_pcb *conn); -void altcp_nagle_disable(struct altcp_pcb *conn); -void altcp_nagle_enable(struct altcp_pcb *conn); -int altcp_nagle_disabled(struct altcp_pcb *conn); - -void altcp_setprio(struct altcp_pcb *conn, u8_t prio); - -err_t altcp_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port); -ip_addr_t *altcp_get_ip(struct altcp_pcb *conn, int local); -u16_t altcp_get_port(struct altcp_pcb *conn, int local); - -#ifdef LWIP_DEBUG -enum tcp_state altcp_dbg_get_tcp_state(struct altcp_pcb *conn); -#endif - -#ifdef __cplusplus -} -#endif - -#else /* LWIP_ALTCP */ - -/* ALTCP disabled, define everything to link against tcp callback API (e.g. to get a small non-ssl httpd) */ - -#include "lwip/tcp.h" - -#define altcp_accept_fn tcp_accept_fn -#define altcp_connected_fn tcp_connected_fn -#define altcp_recv_fn tcp_recv_fn -#define altcp_sent_fn tcp_sent_fn -#define altcp_poll_fn tcp_poll_fn -#define altcp_err_fn tcp_err_fn - -#define altcp_pcb tcp_pcb -#define altcp_tcp_new_ip_type tcp_new_ip_type -#define altcp_tcp_new tcp_new -#define altcp_tcp_new_ip6 tcp_new_ip6 - -#define altcp_new(allocator) tcp_new() -#define altcp_new_ip6(allocator) tcp_new_ip6() -#define altcp_new_ip_type(allocator, ip_type) tcp_new_ip_type(ip_type) - -#define altcp_arg tcp_arg -#define altcp_accept tcp_accept -#define altcp_recv tcp_recv -#define altcp_sent tcp_sent -#define altcp_poll tcp_poll -#define altcp_err tcp_err - -#define altcp_recved tcp_recved -#define altcp_bind tcp_bind -#define altcp_connect tcp_connect - -#define altcp_listen_with_backlog_and_err tcp_listen_with_backlog_and_err -#define altcp_listen_with_backlog tcp_listen_with_backlog -#define altcp_listen tcp_listen - -#define altcp_abort tcp_abort -#define altcp_close tcp_close -#define altcp_shutdown tcp_shutdown - -#define altcp_write tcp_write -#define altcp_output tcp_output - -#define altcp_mss tcp_mss -#define altcp_sndbuf tcp_sndbuf -#define altcp_sndqueuelen tcp_sndqueuelen -#define altcp_nagle_disable tcp_nagle_disable -#define altcp_nagle_enable tcp_nagle_enable -#define altcp_nagle_disabled tcp_nagle_disabled -#define altcp_setprio tcp_setprio - -#define altcp_get_tcp_addrinfo tcp_get_tcp_addrinfo -#define altcp_get_ip(pcb, local) ((local) ? (&(pcb)->local_ip) : (&(pcb)->remote_ip)) - -#ifdef LWIP_DEBUG -#define altcp_dbg_get_tcp_state tcp_dbg_get_tcp_state -#endif - -#endif /* LWIP_ALTCP */ - -#endif /* LWIP_HDR_ALTCP_H */ +/** + * @file + * Application layered TCP connection API (to be used from TCPIP thread)\n + * + * This file contains the generic API. + * For more details see @ref altcp_api. + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_ALTCP_H +#define LWIP_HDR_ALTCP_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/tcpbase.h" +#include "lwip/err.h" +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct altcp_pcb; +struct altcp_functions; + +typedef err_t (*altcp_accept_fn)(void *arg, struct altcp_pcb *new_conn, err_t err); +typedef err_t (*altcp_connected_fn)(void *arg, struct altcp_pcb *conn, err_t err); +typedef err_t (*altcp_recv_fn)(void *arg, struct altcp_pcb *conn, struct pbuf *p, err_t err); +typedef err_t (*altcp_sent_fn)(void *arg, struct altcp_pcb *conn, u16_t len); +typedef err_t (*altcp_poll_fn)(void *arg, struct altcp_pcb *conn); +typedef void (*altcp_err_fn)(void *arg, err_t err); + +typedef struct altcp_pcb* (*altcp_new_fn)(void *arg, u8_t ip_type); + +struct altcp_pcb { + const struct altcp_functions *fns; + struct altcp_pcb *inner_conn; + void *arg; + void *state; + /* application callbacks */ + altcp_accept_fn accept; + altcp_connected_fn connected; + altcp_recv_fn recv; + altcp_sent_fn sent; + altcp_poll_fn poll; + altcp_err_fn err; + u8_t pollinterval; +}; + +/** @ingroup altcp */ +typedef struct altcp_allocator_s { + /** Allocator function */ + altcp_new_fn alloc; + /** Argument to allocator function */ + void *arg; +} altcp_allocator_t; + +struct altcp_pcb *altcp_new(altcp_allocator_t *allocator); +struct altcp_pcb *altcp_new_ip6(altcp_allocator_t *allocator); +struct altcp_pcb *altcp_new_ip_type(altcp_allocator_t *allocator, u8_t ip_type); + +void altcp_arg(struct altcp_pcb *conn, void *arg); +void altcp_accept(struct altcp_pcb *conn, altcp_accept_fn accept); +void altcp_recv(struct altcp_pcb *conn, altcp_recv_fn recv); +void altcp_sent(struct altcp_pcb *conn, altcp_sent_fn sent); +void altcp_poll(struct altcp_pcb *conn, altcp_poll_fn poll, u8_t interval); +void altcp_err(struct altcp_pcb *conn, altcp_err_fn err); + +void altcp_recved(struct altcp_pcb *conn, u16_t len); +err_t altcp_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port); +err_t altcp_connect(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected); + +/* return conn for source code compatibility to tcp callback API only */ +struct altcp_pcb *altcp_listen_with_backlog_and_err(struct altcp_pcb *conn, u8_t backlog, err_t *err); +#define altcp_listen_with_backlog(conn, backlog) altcp_listen_with_backlog_and_err(conn, backlog, NULL) +/** @ingroup altcp */ +#define altcp_listen(conn) altcp_listen_with_backlog_and_err(conn, TCP_DEFAULT_LISTEN_BACKLOG, NULL) + +void altcp_abort(struct altcp_pcb *conn); +err_t altcp_close(struct altcp_pcb *conn); +err_t altcp_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx); + +err_t altcp_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags); +err_t altcp_output(struct altcp_pcb *conn); + +u16_t altcp_mss(struct altcp_pcb *conn); +u16_t altcp_sndbuf(struct altcp_pcb *conn); +u16_t altcp_sndqueuelen(struct altcp_pcb *conn); +void altcp_nagle_disable(struct altcp_pcb *conn); +void altcp_nagle_enable(struct altcp_pcb *conn); +int altcp_nagle_disabled(struct altcp_pcb *conn); + +void altcp_setprio(struct altcp_pcb *conn, u8_t prio); + +err_t altcp_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port); +ip_addr_t *altcp_get_ip(struct altcp_pcb *conn, int local); +u16_t altcp_get_port(struct altcp_pcb *conn, int local); + +#ifdef LWIP_DEBUG +enum tcp_state altcp_dbg_get_tcp_state(struct altcp_pcb *conn); +#endif + +#ifdef __cplusplus +} +#endif + +#else /* LWIP_ALTCP */ + +/* ALTCP disabled, define everything to link against tcp callback API (e.g. to get a small non-ssl httpd) */ + +#include "lwip/tcp.h" + +#define altcp_accept_fn tcp_accept_fn +#define altcp_connected_fn tcp_connected_fn +#define altcp_recv_fn tcp_recv_fn +#define altcp_sent_fn tcp_sent_fn +#define altcp_poll_fn tcp_poll_fn +#define altcp_err_fn tcp_err_fn + +#define altcp_pcb tcp_pcb +#define altcp_tcp_new_ip_type tcp_new_ip_type +#define altcp_tcp_new tcp_new +#define altcp_tcp_new_ip6 tcp_new_ip6 + +#define altcp_new(allocator) tcp_new() +#define altcp_new_ip6(allocator) tcp_new_ip6() +#define altcp_new_ip_type(allocator, ip_type) tcp_new_ip_type(ip_type) + +#define altcp_arg tcp_arg +#define altcp_accept tcp_accept +#define altcp_recv tcp_recv +#define altcp_sent tcp_sent +#define altcp_poll tcp_poll +#define altcp_err tcp_err + +#define altcp_recved tcp_recved +#define altcp_bind tcp_bind +#define altcp_connect tcp_connect + +#define altcp_listen_with_backlog_and_err tcp_listen_with_backlog_and_err +#define altcp_listen_with_backlog tcp_listen_with_backlog +#define altcp_listen tcp_listen + +#define altcp_abort tcp_abort +#define altcp_close tcp_close +#define altcp_shutdown tcp_shutdown + +#define altcp_write tcp_write +#define altcp_output tcp_output + +#define altcp_mss tcp_mss +#define altcp_sndbuf tcp_sndbuf +#define altcp_sndqueuelen tcp_sndqueuelen +#define altcp_nagle_disable tcp_nagle_disable +#define altcp_nagle_enable tcp_nagle_enable +#define altcp_nagle_disabled tcp_nagle_disabled +#define altcp_setprio tcp_setprio + +#define altcp_get_tcp_addrinfo tcp_get_tcp_addrinfo +#define altcp_get_ip(pcb, local) ((local) ? (&(pcb)->local_ip) : (&(pcb)->remote_ip)) + +#ifdef LWIP_DEBUG +#define altcp_dbg_get_tcp_state tcp_dbg_get_tcp_state +#endif + +#endif /* LWIP_ALTCP */ + +#endif /* LWIP_HDR_ALTCP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tcp.h index 53550c70..dbde5846 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tcp.h @@ -1,72 +1,72 @@ -/** - * @file - * Application layered TCP connection API (to be used from TCPIP thread)\n - * This interface mimics the tcp callback API to the application while preventing - * direct linking (much like virtual functions). - * This way, an application can make use of other application layer protocols - * on top of TCP without knowing the details (e.g. TLS, proxy connection). - * - * This file contains the base implementation calling into tcp. - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_ALTCP_TCP_H -#define LWIP_HDR_ALTCP_TCP_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/altcp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct altcp_pcb *altcp_tcp_new_ip_type(u8_t ip_type); - -#define altcp_tcp_new() altcp_tcp_new_ip_type(IPADDR_TYPE_V4) -#define altcp_tcp_new_ip6() altcp_tcp_new_ip_type(IPADDR_TYPE_V6) - -struct altcp_pcb *altcp_tcp_alloc(void *arg, u8_t ip_type); - -struct tcp_pcb; -struct altcp_pcb *altcp_tcp_wrap(struct tcp_pcb *tpcb); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_ALTCP */ - -#endif /* LWIP_HDR_ALTCP_TCP_H */ +/** + * @file + * Application layered TCP connection API (to be used from TCPIP thread)\n + * This interface mimics the tcp callback API to the application while preventing + * direct linking (much like virtual functions). + * This way, an application can make use of other application layer protocols + * on top of TCP without knowing the details (e.g. TLS, proxy connection). + * + * This file contains the base implementation calling into tcp. + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_ALTCP_TCP_H +#define LWIP_HDR_ALTCP_TCP_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/altcp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct altcp_pcb *altcp_tcp_new_ip_type(u8_t ip_type); + +#define altcp_tcp_new() altcp_tcp_new_ip_type(IPADDR_TYPE_V4) +#define altcp_tcp_new_ip6() altcp_tcp_new_ip_type(IPADDR_TYPE_V6) + +struct altcp_pcb *altcp_tcp_alloc(void *arg, u8_t ip_type); + +struct tcp_pcb; +struct altcp_pcb *altcp_tcp_wrap(struct tcp_pcb *tpcb); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_ALTCP */ + +#endif /* LWIP_HDR_ALTCP_TCP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tls.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tls.h index c5a68200..7b17c608 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tls.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/altcp_tls.h @@ -1,117 +1,117 @@ -/** - * @file - * Application layered TCP/TLS connection API (to be used from TCPIP thread) - * - * @defgroup altcp_tls TLS layer - * @ingroup altcp - * This file contains function prototypes for a TLS layer. - * A port to ARM mbedtls is provided in the apps/ tree - * (LWIP_ALTCP_TLS_MBEDTLS option). - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_ALTCP_TLS_H -#define LWIP_HDR_ALTCP_TLS_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#if LWIP_ALTCP_TLS - -#include "lwip/altcp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** @ingroup altcp_tls - * ALTCP_TLS configuration handle, content depends on port (e.g. mbedtls) - */ -struct altcp_tls_config; - -/** @ingroup altcp_tls - * Create an ALTCP_TLS server configuration handle - */ -struct altcp_tls_config *altcp_tls_create_config_server_privkey_cert(const u8_t *privkey, size_t privkey_len, - const u8_t *privkey_pass, size_t privkey_pass_len, - const u8_t *cert, size_t cert_len); - -/** @ingroup altcp_tls - * Create an ALTCP_TLS client configuration handle - */ -struct altcp_tls_config *altcp_tls_create_config_client(const u8_t *cert, size_t cert_len); - -/** @ingroup altcp_tls - * Create an ALTCP_TLS client configuration handle with two-way server/client authentication - */ -struct altcp_tls_config *altcp_tls_create_config_client_2wayauth(const u8_t *ca, size_t ca_len, const u8_t *privkey, size_t privkey_len, - const u8_t *privkey_pass, size_t privkey_pass_len, - const u8_t *cert, size_t cert_len); - -/** @ingroup altcp_tls - * Free an ALTCP_TLS configuration handle - */ -void altcp_tls_free_config(struct altcp_tls_config *conf); - -/** @ingroup altcp_tls - * Create new ALTCP_TLS layer wrapping an existing pcb as inner connection (e.g. TLS over TCP) - */ -struct altcp_pcb *altcp_tls_wrap(struct altcp_tls_config *config, struct altcp_pcb *inner_pcb); - -/** @ingroup altcp_tls - * Create new ALTCP_TLS pcb and its inner tcp pcb - */ -struct altcp_pcb *altcp_tls_new(struct altcp_tls_config *config, u8_t ip_type); - -/** @ingroup altcp_tls - * Create new ALTCP_TLS layer pcb and its inner tcp pcb. - * Same as @ref altcp_tls_new but this allocator function fits to - * @ref altcp_allocator_t / @ref altcp_new.\n - 'arg' must contain a struct altcp_tls_config *. - */ -struct altcp_pcb *altcp_tls_alloc(void *arg, u8_t ip_type); - -/** @ingroup altcp_tls - * Return pointer to internal TLS context so application can tweak it. - * Real type depends on port (e.g. mbedtls) - */ -void *altcp_tls_context(struct altcp_pcb *conn); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_ALTCP_TLS */ -#endif /* LWIP_ALTCP */ -#endif /* LWIP_HDR_ALTCP_TLS_H */ +/** + * @file + * Application layered TCP/TLS connection API (to be used from TCPIP thread) + * + * @defgroup altcp_tls TLS layer + * @ingroup altcp + * This file contains function prototypes for a TLS layer. + * A port to ARM mbedtls is provided in the apps/ tree + * (LWIP_ALTCP_TLS_MBEDTLS option). + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_ALTCP_TLS_H +#define LWIP_HDR_ALTCP_TLS_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#if LWIP_ALTCP_TLS + +#include "lwip/altcp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @ingroup altcp_tls + * ALTCP_TLS configuration handle, content depends on port (e.g. mbedtls) + */ +struct altcp_tls_config; + +/** @ingroup altcp_tls + * Create an ALTCP_TLS server configuration handle + */ +struct altcp_tls_config *altcp_tls_create_config_server_privkey_cert(const u8_t *privkey, size_t privkey_len, + const u8_t *privkey_pass, size_t privkey_pass_len, + const u8_t *cert, size_t cert_len); + +/** @ingroup altcp_tls + * Create an ALTCP_TLS client configuration handle + */ +struct altcp_tls_config *altcp_tls_create_config_client(const u8_t *cert, size_t cert_len); + +/** @ingroup altcp_tls + * Create an ALTCP_TLS client configuration handle with two-way server/client authentication + */ +struct altcp_tls_config *altcp_tls_create_config_client_2wayauth(const u8_t *ca, size_t ca_len, const u8_t *privkey, size_t privkey_len, + const u8_t *privkey_pass, size_t privkey_pass_len, + const u8_t *cert, size_t cert_len); + +/** @ingroup altcp_tls + * Free an ALTCP_TLS configuration handle + */ +void altcp_tls_free_config(struct altcp_tls_config *conf); + +/** @ingroup altcp_tls + * Create new ALTCP_TLS layer wrapping an existing pcb as inner connection (e.g. TLS over TCP) + */ +struct altcp_pcb *altcp_tls_wrap(struct altcp_tls_config *config, struct altcp_pcb *inner_pcb); + +/** @ingroup altcp_tls + * Create new ALTCP_TLS pcb and its inner tcp pcb + */ +struct altcp_pcb *altcp_tls_new(struct altcp_tls_config *config, u8_t ip_type); + +/** @ingroup altcp_tls + * Create new ALTCP_TLS layer pcb and its inner tcp pcb. + * Same as @ref altcp_tls_new but this allocator function fits to + * @ref altcp_allocator_t / @ref altcp_new.\n + 'arg' must contain a struct altcp_tls_config *. + */ +struct altcp_pcb *altcp_tls_alloc(void *arg, u8_t ip_type); + +/** @ingroup altcp_tls + * Return pointer to internal TLS context so application can tweak it. + * Real type depends on port (e.g. mbedtls) + */ +void *altcp_tls_context(struct altcp_pcb *conn); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_ALTCP_TLS */ +#endif /* LWIP_ALTCP */ +#endif /* LWIP_HDR_ALTCP_TLS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/api.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/api.h index eca6ac21..c2afaf26 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/api.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/api.h @@ -1,431 +1,431 @@ -/** - * @file - * netconn API (to be used from non-TCPIP threads) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_API_H -#define LWIP_HDR_API_H - -#include "lwip/opt.h" - -#if LWIP_NETCONN || LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ -/* Note: Netconn API is always available when sockets are enabled - - * sockets are implemented on top of them */ - -#include "lwip/arch.h" -#include "lwip/netbuf.h" -#include "lwip/sys.h" -#include "lwip/ip_addr.h" -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* Throughout this file, IP addresses and port numbers are expected to be in - * the same byte order as in the corresponding pcb. - */ - -/* Flags for netconn_write (u8_t) */ -#define NETCONN_NOFLAG 0x00 -#define NETCONN_NOCOPY 0x00 /* Only for source code compatibility */ -#define NETCONN_COPY 0x01 -#define NETCONN_MORE 0x02 -#define NETCONN_DONTBLOCK 0x04 -#define NETCONN_NOAUTORCVD 0x08 /* prevent netconn_recv_data_tcp() from updating the tcp window - must be done manually via netconn_tcp_recvd() */ -#define NETCONN_NOFIN 0x10 /* upper layer already received data, leave FIN in queue until called again */ - -/* Flags for struct netconn.flags (u8_t) */ -/** This netconn had an error, don't block on recvmbox/acceptmbox any more */ -#define NETCONN_FLAG_MBOXCLOSED 0x01 -/** Should this netconn avoid blocking? */ -#define NETCONN_FLAG_NON_BLOCKING 0x02 -/** Was the last connect action a non-blocking one? */ -#define NETCONN_FLAG_IN_NONBLOCKING_CONNECT 0x04 -#if LWIP_NETCONN_FULLDUPLEX - /** The mbox of this netconn is being deallocated, don't use it anymore */ -#define NETCONN_FLAG_MBOXINVALID 0x08 -#endif /* LWIP_NETCONN_FULLDUPLEX */ -/** If a nonblocking write has been rejected before, poll_tcp needs to - check if the netconn is writable again */ -#define NETCONN_FLAG_CHECK_WRITESPACE 0x10 -#if LWIP_IPV6 -/** If this flag is set then only IPv6 communication is allowed on the - netconn. As per RFC#3493 this features defaults to OFF allowing - dual-stack usage by default. */ -#define NETCONN_FLAG_IPV6_V6ONLY 0x20 -#endif /* LWIP_IPV6 */ -#if LWIP_NETBUF_RECVINFO -/** Received packet info will be recorded for this netconn */ -#define NETCONN_FLAG_PKTINFO 0x40 -#endif /* LWIP_NETBUF_RECVINFO */ -/** A FIN has been received but not passed to the application yet */ -#define NETCONN_FIN_RX_PENDING 0x80 - -/* Helpers to process several netconn_types by the same code */ -#define NETCONNTYPE_GROUP(t) ((t)&0xF0) -#define NETCONNTYPE_DATAGRAM(t) ((t)&0xE0) -#if LWIP_IPV6 -#define NETCONN_TYPE_IPV6 0x08 -#define NETCONNTYPE_ISIPV6(t) (((t)&NETCONN_TYPE_IPV6) != 0) -#define NETCONNTYPE_ISUDPLITE(t) (((t)&0xF3) == NETCONN_UDPLITE) -#define NETCONNTYPE_ISUDPNOCHKSUM(t) (((t)&0xF3) == NETCONN_UDPNOCHKSUM) -#else /* LWIP_IPV6 */ -#define NETCONNTYPE_ISIPV6(t) (0) -#define NETCONNTYPE_ISUDPLITE(t) ((t) == NETCONN_UDPLITE) -#define NETCONNTYPE_ISUDPNOCHKSUM(t) ((t) == NETCONN_UDPNOCHKSUM) -#endif /* LWIP_IPV6 */ - -/** @ingroup netconn_common - * Protocol family and type of the netconn - */ -enum netconn_type { - NETCONN_INVALID = 0, - /** TCP IPv4 */ - NETCONN_TCP = 0x10, -#if LWIP_IPV6 - /** TCP IPv6 */ - NETCONN_TCP_IPV6 = NETCONN_TCP | NETCONN_TYPE_IPV6 /* 0x18 */, -#endif /* LWIP_IPV6 */ - /** UDP IPv4 */ - NETCONN_UDP = 0x20, - /** UDP IPv4 lite */ - NETCONN_UDPLITE = 0x21, - /** UDP IPv4 no checksum */ - NETCONN_UDPNOCHKSUM = 0x22, - -#if LWIP_IPV6 - /** UDP IPv6 (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ - NETCONN_UDP_IPV6 = NETCONN_UDP | NETCONN_TYPE_IPV6 /* 0x28 */, - /** UDP IPv6 lite (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ - NETCONN_UDPLITE_IPV6 = NETCONN_UDPLITE | NETCONN_TYPE_IPV6 /* 0x29 */, - /** UDP IPv6 no checksum (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ - NETCONN_UDPNOCHKSUM_IPV6 = NETCONN_UDPNOCHKSUM | NETCONN_TYPE_IPV6 /* 0x2a */, -#endif /* LWIP_IPV6 */ - - /** Raw connection IPv4 */ - NETCONN_RAW = 0x40 -#if LWIP_IPV6 - /** Raw connection IPv6 (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ - , NETCONN_RAW_IPV6 = NETCONN_RAW | NETCONN_TYPE_IPV6 /* 0x48 */ -#endif /* LWIP_IPV6 */ -}; - -/** Current state of the netconn. Non-TCP netconns are always - * in state NETCONN_NONE! */ -enum netconn_state { - NETCONN_NONE, - NETCONN_WRITE, - NETCONN_LISTEN, - NETCONN_CONNECT, - NETCONN_CLOSE -}; - -/** Used to inform the callback function about changes - * - * Event explanation: - * - * In the netconn implementation, there are three ways to block a client: - * - * - accept mbox (sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, 0); in netconn_accept()) - * - receive mbox (sys_arch_mbox_fetch(&conn->recvmbox, &buf, 0); in netconn_recv_data()) - * - send queue is full (sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); in lwip_netconn_do_write()) - * - * The events have to be seen as events signaling the state of these mboxes/semaphores. For non-blocking - * connections, you need to know in advance whether a call to a netconn function call would block or not, - * and these events tell you about that. - * - * RCVPLUS events say: Safe to perform a potentially blocking call call once more. - * They are counted in sockets - three RCVPLUS events for accept mbox means you are safe - * to call netconn_accept 3 times without being blocked. - * Same thing for receive mbox. - * - * RCVMINUS events say: Your call to to a possibly blocking function is "acknowledged". - * Socket implementation decrements the counter. - * - * For TX, there is no need to count, its merely a flag. SENDPLUS means you may send something. - * SENDPLUS occurs when enough data was delivered to peer so netconn_send() can be called again. - * A SENDMINUS event occurs when the next call to a netconn_send() would be blocking. - */ -enum netconn_evt { - NETCONN_EVT_RCVPLUS, - NETCONN_EVT_RCVMINUS, - NETCONN_EVT_SENDPLUS, - NETCONN_EVT_SENDMINUS, - NETCONN_EVT_ERROR -}; - -#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) -/** Used for netconn_join_leave_group() */ -enum netconn_igmp { - NETCONN_JOIN, - NETCONN_LEAVE -}; -#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ - -#if LWIP_DNS -/* Used for netconn_gethostbyname_addrtype(), these should match the DNS_ADDRTYPE defines in dns.h */ -#define NETCONN_DNS_DEFAULT NETCONN_DNS_IPV4_IPV6 -#define NETCONN_DNS_IPV4 0 -#define NETCONN_DNS_IPV6 1 -#define NETCONN_DNS_IPV4_IPV6 2 /* try to resolve IPv4 first, try IPv6 if IPv4 fails only */ -#define NETCONN_DNS_IPV6_IPV4 3 /* try to resolve IPv6 first, try IPv4 if IPv6 fails only */ -#endif /* LWIP_DNS */ - -/* forward-declare some structs to avoid to include their headers */ -struct ip_pcb; -struct tcp_pcb; -struct udp_pcb; -struct raw_pcb; -struct netconn; -struct api_msg; - -/** A callback prototype to inform about events for a netconn */ -typedef void (* netconn_callback)(struct netconn *, enum netconn_evt, u16_t len); - -/** A netconn descriptor */ -struct netconn { - /** type of the netconn (TCP, UDP or RAW) */ - enum netconn_type type; - /** current state of the netconn */ - enum netconn_state state; - /** the lwIP internal protocol control block */ - union { - struct ip_pcb *ip; - struct tcp_pcb *tcp; - struct udp_pcb *udp; - struct raw_pcb *raw; - } pcb; - /** the last asynchronous unreported error this netconn had */ - err_t pending_err; -#if !LWIP_NETCONN_SEM_PER_THREAD - /** sem that is used to synchronously execute functions in the core context */ - sys_sem_t op_completed; -#endif - /** mbox where received packets are stored until they are fetched - by the netconn application thread (can grow quite big) */ - sys_mbox_t recvmbox; -#if LWIP_TCP - /** mbox where new connections are stored until processed - by the application thread */ - sys_mbox_t acceptmbox; -#endif /* LWIP_TCP */ -#if LWIP_NETCONN_FULLDUPLEX - /** number of threads waiting on an mbox. This is required to unblock - all threads when closing while threads are waiting. */ - int mbox_threads_waiting; -#endif - /** only used for socket layer */ -#if LWIP_SOCKET - int socket; -#endif /* LWIP_SOCKET */ -#if LWIP_SO_SNDTIMEO - /** timeout to wait for sending data (which means enqueueing data for sending - in internal buffers) in milliseconds */ - s32_t send_timeout; -#endif /* LWIP_SO_RCVTIMEO */ -#if LWIP_SO_RCVTIMEO - /** timeout in milliseconds to wait for new data to be received - (or connections to arrive for listening netconns) */ - u32_t recv_timeout; -#endif /* LWIP_SO_RCVTIMEO */ -#if LWIP_SO_RCVBUF - /** maximum amount of bytes queued in recvmbox - not used for TCP: adjust TCP_WND instead! */ - int recv_bufsize; - /** number of bytes currently in recvmbox to be received, - tested against recv_bufsize to limit bytes on recvmbox - for UDP and RAW, used for FIONREAD */ - int recv_avail; -#endif /* LWIP_SO_RCVBUF */ -#if LWIP_SO_LINGER - /** values <0 mean linger is disabled, values > 0 are seconds to linger */ - s16_t linger; -#endif /* LWIP_SO_LINGER */ - /** flags holding more netconn-internal state, see NETCONN_FLAG_* defines */ - u8_t flags; -#if LWIP_TCP - /** TCP: when data passed to netconn_write doesn't fit into the send buffer, - this temporarily stores the message. - Also used during connect and close. */ - struct api_msg *current_msg; -#endif /* LWIP_TCP */ - /** A callback function that is informed about events for this netconn */ - netconn_callback callback; -}; - -/** This vector type is passed to @ref netconn_write_vectors_partly to send - * multiple buffers at once. - * ATTENTION: This type has to directly map struct iovec since one is casted - * into the other! - */ -struct netvector { - /** pointer to the application buffer that contains the data to send */ - const void *ptr; - /** size of the application data to send */ - size_t len; -}; - -/** Register an Network connection event */ -#define API_EVENT(c,e,l) if (c->callback) { \ - (*c->callback)(c, e, l); \ - } - -/* Network connection functions: */ - -/** @ingroup netconn_common - * Create new netconn connection - * @param t @ref netconn_type */ -#define netconn_new(t) netconn_new_with_proto_and_callback(t, 0, NULL) -#define netconn_new_with_callback(t, c) netconn_new_with_proto_and_callback(t, 0, c) -struct netconn *netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, - netconn_callback callback); -err_t netconn_prepare_delete(struct netconn *conn); -err_t netconn_delete(struct netconn *conn); -/** Get the type of a netconn (as enum netconn_type). */ -#define netconn_type(conn) (conn->type) - -err_t netconn_getaddr(struct netconn *conn, ip_addr_t *addr, - u16_t *port, u8_t local); -/** @ingroup netconn_common */ -#define netconn_peer(c,i,p) netconn_getaddr(c,i,p,0) -/** @ingroup netconn_common */ -#define netconn_addr(c,i,p) netconn_getaddr(c,i,p,1) - -err_t netconn_bind(struct netconn *conn, const ip_addr_t *addr, u16_t port); -err_t netconn_bind_if(struct netconn *conn, u8_t if_idx); -err_t netconn_connect(struct netconn *conn, const ip_addr_t *addr, u16_t port); -err_t netconn_disconnect (struct netconn *conn); -err_t netconn_listen_with_backlog(struct netconn *conn, u8_t backlog); -/** @ingroup netconn_tcp */ -#define netconn_listen(conn) netconn_listen_with_backlog(conn, TCP_DEFAULT_LISTEN_BACKLOG) -err_t netconn_accept(struct netconn *conn, struct netconn **new_conn); -err_t netconn_recv(struct netconn *conn, struct netbuf **new_buf); -err_t netconn_recv_udp_raw_netbuf(struct netconn *conn, struct netbuf **new_buf); -err_t netconn_recv_udp_raw_netbuf_flags(struct netconn *conn, struct netbuf **new_buf, u8_t apiflags); -err_t netconn_recv_tcp_pbuf(struct netconn *conn, struct pbuf **new_buf); -err_t netconn_recv_tcp_pbuf_flags(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags); -err_t netconn_tcp_recvd(struct netconn *conn, size_t len); -err_t netconn_sendto(struct netconn *conn, struct netbuf *buf, - const ip_addr_t *addr, u16_t port); -err_t netconn_send(struct netconn *conn, struct netbuf *buf); -err_t netconn_write_partly(struct netconn *conn, const void *dataptr, size_t size, - u8_t apiflags, size_t *bytes_written); -err_t netconn_write_vectors_partly(struct netconn *conn, struct netvector *vectors, u16_t vectorcnt, - u8_t apiflags, size_t *bytes_written); -/** @ingroup netconn_tcp */ -#define netconn_write(conn, dataptr, size, apiflags) \ - netconn_write_partly(conn, dataptr, size, apiflags, NULL) -err_t netconn_close(struct netconn *conn); -err_t netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx); - -#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) -err_t netconn_join_leave_group(struct netconn *conn, const ip_addr_t *multiaddr, - const ip_addr_t *netif_addr, enum netconn_igmp join_or_leave); -err_t netconn_join_leave_group_netif(struct netconn *conn, const ip_addr_t *multiaddr, - u8_t if_idx, enum netconn_igmp join_or_leave); -#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ -#if LWIP_DNS -#if LWIP_IPV4 && LWIP_IPV6 -err_t netconn_gethostbyname_addrtype(const char *name, ip_addr_t *addr, u8_t dns_addrtype); -#define netconn_gethostbyname(name, addr) netconn_gethostbyname_addrtype(name, addr, NETCONN_DNS_DEFAULT) -#else /* LWIP_IPV4 && LWIP_IPV6 */ -err_t netconn_gethostbyname(const char *name, ip_addr_t *addr); -#define netconn_gethostbyname_addrtype(name, addr, dns_addrtype) netconn_gethostbyname(name, addr) -#endif /* LWIP_IPV4 && LWIP_IPV6 */ -#endif /* LWIP_DNS */ - -err_t netconn_err(struct netconn *conn); -#define netconn_recv_bufsize(conn) ((conn)->recv_bufsize) - -#define netconn_set_flags(conn, set_flags) do { (conn)->flags = (u8_t)((conn)->flags | (set_flags)); } while(0) -#define netconn_clear_flags(conn, clr_flags) do { (conn)->flags = (u8_t)((conn)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) -#define netconn_is_flag_set(conn, flag) (((conn)->flags & (flag)) != 0) - -/** Set the blocking status of netconn calls (@todo: write/send is missing) */ -#define netconn_set_nonblocking(conn, val) do { if(val) { \ - netconn_set_flags(conn, NETCONN_FLAG_NON_BLOCKING); \ -} else { \ - netconn_clear_flags(conn, NETCONN_FLAG_NON_BLOCKING); }} while(0) -/** Get the blocking status of netconn calls (@todo: write/send is missing) */ -#define netconn_is_nonblocking(conn) (((conn)->flags & NETCONN_FLAG_NON_BLOCKING) != 0) - -#if LWIP_IPV6 -/** @ingroup netconn_common - * TCP: Set the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY) - */ -#define netconn_set_ipv6only(conn, val) do { if(val) { \ - netconn_set_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); \ -} else { \ - netconn_clear_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); }} while(0) -/** @ingroup netconn_common - * TCP: Get the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY) - */ -#define netconn_get_ipv6only(conn) (((conn)->flags & NETCONN_FLAG_IPV6_V6ONLY) != 0) -#endif /* LWIP_IPV6 */ - -#if LWIP_SO_SNDTIMEO -/** Set the send timeout in milliseconds */ -#define netconn_set_sendtimeout(conn, timeout) ((conn)->send_timeout = (timeout)) -/** Get the send timeout in milliseconds */ -#define netconn_get_sendtimeout(conn) ((conn)->send_timeout) -#endif /* LWIP_SO_SNDTIMEO */ -#if LWIP_SO_RCVTIMEO -/** Set the receive timeout in milliseconds */ -#define netconn_set_recvtimeout(conn, timeout) ((conn)->recv_timeout = (timeout)) -/** Get the receive timeout in milliseconds */ -#define netconn_get_recvtimeout(conn) ((conn)->recv_timeout) -#endif /* LWIP_SO_RCVTIMEO */ -#if LWIP_SO_RCVBUF -/** Set the receive buffer in bytes */ -#define netconn_set_recvbufsize(conn, recvbufsize) ((conn)->recv_bufsize = (recvbufsize)) -/** Get the receive buffer in bytes */ -#define netconn_get_recvbufsize(conn) ((conn)->recv_bufsize) -#endif /* LWIP_SO_RCVBUF*/ - -#if LWIP_NETCONN_SEM_PER_THREAD -void netconn_thread_init(void); -void netconn_thread_cleanup(void); -#else /* LWIP_NETCONN_SEM_PER_THREAD */ -#define netconn_thread_init() -#define netconn_thread_cleanup() -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_NETCONN || LWIP_SOCKET */ - -#endif /* LWIP_HDR_API_H */ +/** + * @file + * netconn API (to be used from non-TCPIP threads) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_API_H +#define LWIP_HDR_API_H + +#include "lwip/opt.h" + +#if LWIP_NETCONN || LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ +/* Note: Netconn API is always available when sockets are enabled - + * sockets are implemented on top of them */ + +#include "lwip/arch.h" +#include "lwip/netbuf.h" +#include "lwip/sys.h" +#include "lwip/ip_addr.h" +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Throughout this file, IP addresses and port numbers are expected to be in + * the same byte order as in the corresponding pcb. + */ + +/* Flags for netconn_write (u8_t) */ +#define NETCONN_NOFLAG 0x00 +#define NETCONN_NOCOPY 0x00 /* Only for source code compatibility */ +#define NETCONN_COPY 0x01 +#define NETCONN_MORE 0x02 +#define NETCONN_DONTBLOCK 0x04 +#define NETCONN_NOAUTORCVD 0x08 /* prevent netconn_recv_data_tcp() from updating the tcp window - must be done manually via netconn_tcp_recvd() */ +#define NETCONN_NOFIN 0x10 /* upper layer already received data, leave FIN in queue until called again */ + +/* Flags for struct netconn.flags (u8_t) */ +/** This netconn had an error, don't block on recvmbox/acceptmbox any more */ +#define NETCONN_FLAG_MBOXCLOSED 0x01 +/** Should this netconn avoid blocking? */ +#define NETCONN_FLAG_NON_BLOCKING 0x02 +/** Was the last connect action a non-blocking one? */ +#define NETCONN_FLAG_IN_NONBLOCKING_CONNECT 0x04 +#if LWIP_NETCONN_FULLDUPLEX + /** The mbox of this netconn is being deallocated, don't use it anymore */ +#define NETCONN_FLAG_MBOXINVALID 0x08 +#endif /* LWIP_NETCONN_FULLDUPLEX */ +/** If a nonblocking write has been rejected before, poll_tcp needs to + check if the netconn is writable again */ +#define NETCONN_FLAG_CHECK_WRITESPACE 0x10 +#if LWIP_IPV6 +/** If this flag is set then only IPv6 communication is allowed on the + netconn. As per RFC#3493 this features defaults to OFF allowing + dual-stack usage by default. */ +#define NETCONN_FLAG_IPV6_V6ONLY 0x20 +#endif /* LWIP_IPV6 */ +#if LWIP_NETBUF_RECVINFO +/** Received packet info will be recorded for this netconn */ +#define NETCONN_FLAG_PKTINFO 0x40 +#endif /* LWIP_NETBUF_RECVINFO */ +/** A FIN has been received but not passed to the application yet */ +#define NETCONN_FIN_RX_PENDING 0x80 + +/* Helpers to process several netconn_types by the same code */ +#define NETCONNTYPE_GROUP(t) ((t)&0xF0) +#define NETCONNTYPE_DATAGRAM(t) ((t)&0xE0) +#if LWIP_IPV6 +#define NETCONN_TYPE_IPV6 0x08 +#define NETCONNTYPE_ISIPV6(t) (((t)&NETCONN_TYPE_IPV6) != 0) +#define NETCONNTYPE_ISUDPLITE(t) (((t)&0xF3) == NETCONN_UDPLITE) +#define NETCONNTYPE_ISUDPNOCHKSUM(t) (((t)&0xF3) == NETCONN_UDPNOCHKSUM) +#else /* LWIP_IPV6 */ +#define NETCONNTYPE_ISIPV6(t) (0) +#define NETCONNTYPE_ISUDPLITE(t) ((t) == NETCONN_UDPLITE) +#define NETCONNTYPE_ISUDPNOCHKSUM(t) ((t) == NETCONN_UDPNOCHKSUM) +#endif /* LWIP_IPV6 */ + +/** @ingroup netconn_common + * Protocol family and type of the netconn + */ +enum netconn_type { + NETCONN_INVALID = 0, + /** TCP IPv4 */ + NETCONN_TCP = 0x10, +#if LWIP_IPV6 + /** TCP IPv6 */ + NETCONN_TCP_IPV6 = NETCONN_TCP | NETCONN_TYPE_IPV6 /* 0x18 */, +#endif /* LWIP_IPV6 */ + /** UDP IPv4 */ + NETCONN_UDP = 0x20, + /** UDP IPv4 lite */ + NETCONN_UDPLITE = 0x21, + /** UDP IPv4 no checksum */ + NETCONN_UDPNOCHKSUM = 0x22, + +#if LWIP_IPV6 + /** UDP IPv6 (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ + NETCONN_UDP_IPV6 = NETCONN_UDP | NETCONN_TYPE_IPV6 /* 0x28 */, + /** UDP IPv6 lite (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ + NETCONN_UDPLITE_IPV6 = NETCONN_UDPLITE | NETCONN_TYPE_IPV6 /* 0x29 */, + /** UDP IPv6 no checksum (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ + NETCONN_UDPNOCHKSUM_IPV6 = NETCONN_UDPNOCHKSUM | NETCONN_TYPE_IPV6 /* 0x2a */, +#endif /* LWIP_IPV6 */ + + /** Raw connection IPv4 */ + NETCONN_RAW = 0x40 +#if LWIP_IPV6 + /** Raw connection IPv6 (dual-stack by default, unless you call @ref netconn_set_ipv6only) */ + , NETCONN_RAW_IPV6 = NETCONN_RAW | NETCONN_TYPE_IPV6 /* 0x48 */ +#endif /* LWIP_IPV6 */ +}; + +/** Current state of the netconn. Non-TCP netconns are always + * in state NETCONN_NONE! */ +enum netconn_state { + NETCONN_NONE, + NETCONN_WRITE, + NETCONN_LISTEN, + NETCONN_CONNECT, + NETCONN_CLOSE +}; + +/** Used to inform the callback function about changes + * + * Event explanation: + * + * In the netconn implementation, there are three ways to block a client: + * + * - accept mbox (sys_arch_mbox_fetch(&conn->acceptmbox, &accept_ptr, 0); in netconn_accept()) + * - receive mbox (sys_arch_mbox_fetch(&conn->recvmbox, &buf, 0); in netconn_recv_data()) + * - send queue is full (sys_arch_sem_wait(LWIP_API_MSG_SEM(msg), 0); in lwip_netconn_do_write()) + * + * The events have to be seen as events signaling the state of these mboxes/semaphores. For non-blocking + * connections, you need to know in advance whether a call to a netconn function call would block or not, + * and these events tell you about that. + * + * RCVPLUS events say: Safe to perform a potentially blocking call call once more. + * They are counted in sockets - three RCVPLUS events for accept mbox means you are safe + * to call netconn_accept 3 times without being blocked. + * Same thing for receive mbox. + * + * RCVMINUS events say: Your call to to a possibly blocking function is "acknowledged". + * Socket implementation decrements the counter. + * + * For TX, there is no need to count, its merely a flag. SENDPLUS means you may send something. + * SENDPLUS occurs when enough data was delivered to peer so netconn_send() can be called again. + * A SENDMINUS event occurs when the next call to a netconn_send() would be blocking. + */ +enum netconn_evt { + NETCONN_EVT_RCVPLUS, + NETCONN_EVT_RCVMINUS, + NETCONN_EVT_SENDPLUS, + NETCONN_EVT_SENDMINUS, + NETCONN_EVT_ERROR +}; + +#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) +/** Used for netconn_join_leave_group() */ +enum netconn_igmp { + NETCONN_JOIN, + NETCONN_LEAVE +}; +#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ + +#if LWIP_DNS +/* Used for netconn_gethostbyname_addrtype(), these should match the DNS_ADDRTYPE defines in dns.h */ +#define NETCONN_DNS_DEFAULT NETCONN_DNS_IPV4_IPV6 +#define NETCONN_DNS_IPV4 0 +#define NETCONN_DNS_IPV6 1 +#define NETCONN_DNS_IPV4_IPV6 2 /* try to resolve IPv4 first, try IPv6 if IPv4 fails only */ +#define NETCONN_DNS_IPV6_IPV4 3 /* try to resolve IPv6 first, try IPv4 if IPv6 fails only */ +#endif /* LWIP_DNS */ + +/* forward-declare some structs to avoid to include their headers */ +struct ip_pcb; +struct tcp_pcb; +struct udp_pcb; +struct raw_pcb; +struct netconn; +struct api_msg; + +/** A callback prototype to inform about events for a netconn */ +typedef void (* netconn_callback)(struct netconn *, enum netconn_evt, u16_t len); + +/** A netconn descriptor */ +struct netconn { + /** type of the netconn (TCP, UDP or RAW) */ + enum netconn_type type; + /** current state of the netconn */ + enum netconn_state state; + /** the lwIP internal protocol control block */ + union { + struct ip_pcb *ip; + struct tcp_pcb *tcp; + struct udp_pcb *udp; + struct raw_pcb *raw; + } pcb; + /** the last asynchronous unreported error this netconn had */ + err_t pending_err; +#if !LWIP_NETCONN_SEM_PER_THREAD + /** sem that is used to synchronously execute functions in the core context */ + sys_sem_t op_completed; +#endif + /** mbox where received packets are stored until they are fetched + by the netconn application thread (can grow quite big) */ + sys_mbox_t recvmbox; +#if LWIP_TCP + /** mbox where new connections are stored until processed + by the application thread */ + sys_mbox_t acceptmbox; +#endif /* LWIP_TCP */ +#if LWIP_NETCONN_FULLDUPLEX + /** number of threads waiting on an mbox. This is required to unblock + all threads when closing while threads are waiting. */ + int mbox_threads_waiting; +#endif + /** only used for socket layer */ +#if LWIP_SOCKET + int socket; +#endif /* LWIP_SOCKET */ +#if LWIP_SO_SNDTIMEO + /** timeout to wait for sending data (which means enqueueing data for sending + in internal buffers) in milliseconds */ + s32_t send_timeout; +#endif /* LWIP_SO_RCVTIMEO */ +#if LWIP_SO_RCVTIMEO + /** timeout in milliseconds to wait for new data to be received + (or connections to arrive for listening netconns) */ + u32_t recv_timeout; +#endif /* LWIP_SO_RCVTIMEO */ +#if LWIP_SO_RCVBUF + /** maximum amount of bytes queued in recvmbox + not used for TCP: adjust TCP_WND instead! */ + int recv_bufsize; + /** number of bytes currently in recvmbox to be received, + tested against recv_bufsize to limit bytes on recvmbox + for UDP and RAW, used for FIONREAD */ + int recv_avail; +#endif /* LWIP_SO_RCVBUF */ +#if LWIP_SO_LINGER + /** values <0 mean linger is disabled, values > 0 are seconds to linger */ + s16_t linger; +#endif /* LWIP_SO_LINGER */ + /** flags holding more netconn-internal state, see NETCONN_FLAG_* defines */ + u8_t flags; +#if LWIP_TCP + /** TCP: when data passed to netconn_write doesn't fit into the send buffer, + this temporarily stores the message. + Also used during connect and close. */ + struct api_msg *current_msg; +#endif /* LWIP_TCP */ + /** A callback function that is informed about events for this netconn */ + netconn_callback callback; +}; + +/** This vector type is passed to @ref netconn_write_vectors_partly to send + * multiple buffers at once. + * ATTENTION: This type has to directly map struct iovec since one is casted + * into the other! + */ +struct netvector { + /** pointer to the application buffer that contains the data to send */ + const void *ptr; + /** size of the application data to send */ + size_t len; +}; + +/** Register an Network connection event */ +#define API_EVENT(c,e,l) if (c->callback) { \ + (*c->callback)(c, e, l); \ + } + +/* Network connection functions: */ + +/** @ingroup netconn_common + * Create new netconn connection + * @param t @ref netconn_type */ +#define netconn_new(t) netconn_new_with_proto_and_callback(t, 0, NULL) +#define netconn_new_with_callback(t, c) netconn_new_with_proto_and_callback(t, 0, c) +struct netconn *netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto, + netconn_callback callback); +err_t netconn_prepare_delete(struct netconn *conn); +err_t netconn_delete(struct netconn *conn); +/** Get the type of a netconn (as enum netconn_type). */ +#define netconn_type(conn) (conn->type) + +err_t netconn_getaddr(struct netconn *conn, ip_addr_t *addr, + u16_t *port, u8_t local); +/** @ingroup netconn_common */ +#define netconn_peer(c,i,p) netconn_getaddr(c,i,p,0) +/** @ingroup netconn_common */ +#define netconn_addr(c,i,p) netconn_getaddr(c,i,p,1) + +err_t netconn_bind(struct netconn *conn, const ip_addr_t *addr, u16_t port); +err_t netconn_bind_if(struct netconn *conn, u8_t if_idx); +err_t netconn_connect(struct netconn *conn, const ip_addr_t *addr, u16_t port); +err_t netconn_disconnect (struct netconn *conn); +err_t netconn_listen_with_backlog(struct netconn *conn, u8_t backlog); +/** @ingroup netconn_tcp */ +#define netconn_listen(conn) netconn_listen_with_backlog(conn, TCP_DEFAULT_LISTEN_BACKLOG) +err_t netconn_accept(struct netconn *conn, struct netconn **new_conn); +err_t netconn_recv(struct netconn *conn, struct netbuf **new_buf); +err_t netconn_recv_udp_raw_netbuf(struct netconn *conn, struct netbuf **new_buf); +err_t netconn_recv_udp_raw_netbuf_flags(struct netconn *conn, struct netbuf **new_buf, u8_t apiflags); +err_t netconn_recv_tcp_pbuf(struct netconn *conn, struct pbuf **new_buf); +err_t netconn_recv_tcp_pbuf_flags(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags); +err_t netconn_tcp_recvd(struct netconn *conn, size_t len); +err_t netconn_sendto(struct netconn *conn, struct netbuf *buf, + const ip_addr_t *addr, u16_t port); +err_t netconn_send(struct netconn *conn, struct netbuf *buf); +err_t netconn_write_partly(struct netconn *conn, const void *dataptr, size_t size, + u8_t apiflags, size_t *bytes_written); +err_t netconn_write_vectors_partly(struct netconn *conn, struct netvector *vectors, u16_t vectorcnt, + u8_t apiflags, size_t *bytes_written); +/** @ingroup netconn_tcp */ +#define netconn_write(conn, dataptr, size, apiflags) \ + netconn_write_partly(conn, dataptr, size, apiflags, NULL) +err_t netconn_close(struct netconn *conn); +err_t netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx); + +#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) +err_t netconn_join_leave_group(struct netconn *conn, const ip_addr_t *multiaddr, + const ip_addr_t *netif_addr, enum netconn_igmp join_or_leave); +err_t netconn_join_leave_group_netif(struct netconn *conn, const ip_addr_t *multiaddr, + u8_t if_idx, enum netconn_igmp join_or_leave); +#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ +#if LWIP_DNS +#if LWIP_IPV4 && LWIP_IPV6 +err_t netconn_gethostbyname_addrtype(const char *name, ip_addr_t *addr, u8_t dns_addrtype); +#define netconn_gethostbyname(name, addr) netconn_gethostbyname_addrtype(name, addr, NETCONN_DNS_DEFAULT) +#else /* LWIP_IPV4 && LWIP_IPV6 */ +err_t netconn_gethostbyname(const char *name, ip_addr_t *addr); +#define netconn_gethostbyname_addrtype(name, addr, dns_addrtype) netconn_gethostbyname(name, addr) +#endif /* LWIP_IPV4 && LWIP_IPV6 */ +#endif /* LWIP_DNS */ + +err_t netconn_err(struct netconn *conn); +#define netconn_recv_bufsize(conn) ((conn)->recv_bufsize) + +#define netconn_set_flags(conn, set_flags) do { (conn)->flags = (u8_t)((conn)->flags | (set_flags)); } while(0) +#define netconn_clear_flags(conn, clr_flags) do { (conn)->flags = (u8_t)((conn)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) +#define netconn_is_flag_set(conn, flag) (((conn)->flags & (flag)) != 0) + +/** Set the blocking status of netconn calls (@todo: write/send is missing) */ +#define netconn_set_nonblocking(conn, val) do { if(val) { \ + netconn_set_flags(conn, NETCONN_FLAG_NON_BLOCKING); \ +} else { \ + netconn_clear_flags(conn, NETCONN_FLAG_NON_BLOCKING); }} while(0) +/** Get the blocking status of netconn calls (@todo: write/send is missing) */ +#define netconn_is_nonblocking(conn) (((conn)->flags & NETCONN_FLAG_NON_BLOCKING) != 0) + +#if LWIP_IPV6 +/** @ingroup netconn_common + * TCP: Set the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY) + */ +#define netconn_set_ipv6only(conn, val) do { if(val) { \ + netconn_set_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); \ +} else { \ + netconn_clear_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); }} while(0) +/** @ingroup netconn_common + * TCP: Get the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY) + */ +#define netconn_get_ipv6only(conn) (((conn)->flags & NETCONN_FLAG_IPV6_V6ONLY) != 0) +#endif /* LWIP_IPV6 */ + +#if LWIP_SO_SNDTIMEO +/** Set the send timeout in milliseconds */ +#define netconn_set_sendtimeout(conn, timeout) ((conn)->send_timeout = (timeout)) +/** Get the send timeout in milliseconds */ +#define netconn_get_sendtimeout(conn) ((conn)->send_timeout) +#endif /* LWIP_SO_SNDTIMEO */ +#if LWIP_SO_RCVTIMEO +/** Set the receive timeout in milliseconds */ +#define netconn_set_recvtimeout(conn, timeout) ((conn)->recv_timeout = (timeout)) +/** Get the receive timeout in milliseconds */ +#define netconn_get_recvtimeout(conn) ((conn)->recv_timeout) +#endif /* LWIP_SO_RCVTIMEO */ +#if LWIP_SO_RCVBUF +/** Set the receive buffer in bytes */ +#define netconn_set_recvbufsize(conn, recvbufsize) ((conn)->recv_bufsize = (recvbufsize)) +/** Get the receive buffer in bytes */ +#define netconn_get_recvbufsize(conn) ((conn)->recv_bufsize) +#endif /* LWIP_SO_RCVBUF*/ + +#if LWIP_NETCONN_SEM_PER_THREAD +void netconn_thread_init(void); +void netconn_thread_cleanup(void); +#else /* LWIP_NETCONN_SEM_PER_THREAD */ +#define netconn_thread_init() +#define netconn_thread_cleanup() +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_NETCONN || LWIP_SOCKET */ + +#endif /* LWIP_HDR_API_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/FILES b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/FILES index c983076c..adfc0f33 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/FILES +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/FILES @@ -1,2 +1,2 @@ -This directory contains application headers. -Every application shall provide one api file APP.h and optionally one options file APP_opts.h +This directory contains application headers. +Every application shall provide one api file APP.h and optionally one options file APP_opts.h diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_proxyconnect.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_proxyconnect.h index a7c35279..65d31279 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_proxyconnect.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_proxyconnect.h @@ -1,79 +1,79 @@ -/** - * @file - * Application layered TCP connection API that executes a proxy-connect. - * - * This file provides a starting layer that executes a proxy-connect e.g. to - * set up TLS connections through a http proxy. - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#ifndef LWIP_HDR_APPS_ALTCP_PROXYCONNECT_H -#define LWIP_HDR_APPS_ALTCP_PROXYCONNECT_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/ip_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct altcp_proxyconnect_config { - ip_addr_t proxy_addr; - u16_t proxy_port; -}; - - -struct altcp_pcb *altcp_proxyconnect_new(struct altcp_proxyconnect_config *config, struct altcp_pcb *inner_pcb); -struct altcp_pcb *altcp_proxyconnect_new_tcp(struct altcp_proxyconnect_config *config, u8_t ip_type); - -struct altcp_pcb *altcp_proxyconnect_alloc(void *arg, u8_t ip_type); - -#if LWIP_ALTCP_TLS -struct altcp_proxyconnect_tls_config { - struct altcp_proxyconnect_config proxy; - struct altcp_tls_config *tls_config; -}; - -struct altcp_pcb *altcp_proxyconnect_tls_alloc(void *arg, u8_t ip_type); -#endif /* LWIP_ALTCP_TLS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_ALTCP */ -#endif /* LWIP_HDR_APPS_ALTCP_PROXYCONNECT_H */ +/** + * @file + * Application layered TCP connection API that executes a proxy-connect. + * + * This file provides a starting layer that executes a proxy-connect e.g. to + * set up TLS connections through a http proxy. + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#ifndef LWIP_HDR_APPS_ALTCP_PROXYCONNECT_H +#define LWIP_HDR_APPS_ALTCP_PROXYCONNECT_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/ip_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct altcp_proxyconnect_config { + ip_addr_t proxy_addr; + u16_t proxy_port; +}; + + +struct altcp_pcb *altcp_proxyconnect_new(struct altcp_proxyconnect_config *config, struct altcp_pcb *inner_pcb); +struct altcp_pcb *altcp_proxyconnect_new_tcp(struct altcp_proxyconnect_config *config, u8_t ip_type); + +struct altcp_pcb *altcp_proxyconnect_alloc(void *arg, u8_t ip_type); + +#if LWIP_ALTCP_TLS +struct altcp_proxyconnect_tls_config { + struct altcp_proxyconnect_config proxy; + struct altcp_tls_config *tls_config; +}; + +struct altcp_pcb *altcp_proxyconnect_tls_alloc(void *arg, u8_t ip_type); +#endif /* LWIP_ALTCP_TLS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_ALTCP */ +#endif /* LWIP_HDR_APPS_ALTCP_PROXYCONNECT_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_tls_mbedtls_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_tls_mbedtls_opts.h index 63f72e3e..36cddd93 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_tls_mbedtls_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/altcp_tls_mbedtls_opts.h @@ -1,67 +1,67 @@ -/** - * @file - * Application layered TCP/TLS connection API (to be used from TCPIP thread) - * - * This file contains options for an mbedtls port of the TLS layer. - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_ALTCP_TLS_OPTS_H -#define LWIP_HDR_ALTCP_TLS_OPTS_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -/** LWIP_ALTCP_TLS_MBEDTLS==1: use mbedTLS for TLS support for altcp API - * mbedtls include directory must be reachable via include search path - */ -#ifndef LWIP_ALTCP_TLS_MBEDTLS -#define LWIP_ALTCP_TLS_MBEDTLS 0 -#endif - -/** Configure debug level of this file */ -#ifndef ALTCP_MBEDTLS_DEBUG -#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_OFF -#endif - -/** Set a session timeout in seconds for the basic session cache - * ATTENTION: Using a session cache can lower security by reusing keys! - */ -#ifndef ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS -#define ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS 0 -#endif - -#endif /* LWIP_ALTCP */ - -#endif /* LWIP_HDR_ALTCP_TLS_OPTS_H */ +/** + * @file + * Application layered TCP/TLS connection API (to be used from TCPIP thread) + * + * This file contains options for an mbedtls port of the TLS layer. + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_ALTCP_TLS_OPTS_H +#define LWIP_HDR_ALTCP_TLS_OPTS_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +/** LWIP_ALTCP_TLS_MBEDTLS==1: use mbedTLS for TLS support for altcp API + * mbedtls include directory must be reachable via include search path + */ +#ifndef LWIP_ALTCP_TLS_MBEDTLS +#define LWIP_ALTCP_TLS_MBEDTLS 0 +#endif + +/** Configure debug level of this file */ +#ifndef ALTCP_MBEDTLS_DEBUG +#define ALTCP_MBEDTLS_DEBUG LWIP_DBG_OFF +#endif + +/** Set a session timeout in seconds for the basic session cache + * ATTENTION: Using a session cache can lower security by reusing keys! + */ +#ifndef ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS +#define ALTCP_MBEDTLS_SESSION_CACHE_TIMEOUT_SECONDS 0 +#endif + +#endif /* LWIP_ALTCP */ + +#endif /* LWIP_HDR_ALTCP_TLS_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/fs.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/fs.h index 02bde1fc..67b9a60a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/fs.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/fs.h @@ -1,126 +1,126 @@ -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_APPS_FS_H -#define LWIP_HDR_APPS_FS_H - -#include "httpd_opts.h" -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define FS_READ_EOF -1 -#define FS_READ_DELAYED -2 - -#if HTTPD_PRECALCULATED_CHECKSUM -struct fsdata_chksum { - u32_t offset; - u16_t chksum; - u16_t len; -}; -#endif /* HTTPD_PRECALCULATED_CHECKSUM */ - -#define FS_FILE_FLAGS_HEADER_INCLUDED 0x01 -#define FS_FILE_FLAGS_HEADER_PERSISTENT 0x02 -#define FS_FILE_FLAGS_HEADER_HTTPVER_1_1 0x04 -#define FS_FILE_FLAGS_SSI 0x08 - -/** Define FS_FILE_EXTENSION_T_DEFINED if you have typedef'ed to your private - * pointer type (defaults to 'void' so the default usage is 'void*') - */ -#ifndef FS_FILE_EXTENSION_T_DEFINED -typedef void fs_file_extension; -#endif - -struct fs_file { - const char *data; - int len; - int index; - /* pextension is free for implementations to hold private (extensional) - arbitrary data, e.g. holding some file state or file system handle */ - fs_file_extension *pextension; -#if HTTPD_PRECALCULATED_CHECKSUM - const struct fsdata_chksum *chksum; - u16_t chksum_count; -#endif /* HTTPD_PRECALCULATED_CHECKSUM */ - u8_t flags; -#if LWIP_HTTPD_CUSTOM_FILES - u8_t is_custom_file; -#endif /* LWIP_HTTPD_CUSTOM_FILES */ -#if LWIP_HTTPD_FILE_STATE - void *state; -#endif /* LWIP_HTTPD_FILE_STATE */ -}; - -#if LWIP_HTTPD_FS_ASYNC_READ -typedef void (*fs_wait_cb)(void *arg); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ - -err_t fs_open(struct fs_file *file, const char *name); -void fs_close(struct fs_file *file); -#if LWIP_HTTPD_DYNAMIC_FILE_READ -#if LWIP_HTTPD_FS_ASYNC_READ -int fs_read_async(struct fs_file *file, char *buffer, int count, fs_wait_cb callback_fn, void *callback_arg); -#else /* LWIP_HTTPD_FS_ASYNC_READ */ -int fs_read(struct fs_file *file, char *buffer, int count); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ -#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ -#if LWIP_HTTPD_FS_ASYNC_READ -int fs_is_file_ready(struct fs_file *file, fs_wait_cb callback_fn, void *callback_arg); -#endif /* LWIP_HTTPD_FS_ASYNC_READ */ -int fs_bytes_left(struct fs_file *file); - -#if LWIP_HTTPD_FILE_STATE -/** This user-defined function is called when a file is opened. */ -void *fs_state_init(struct fs_file *file, const char *name); -/** This user-defined function is called when a file is closed. */ -void fs_state_free(struct fs_file *file, void *state); -#endif /* #if LWIP_HTTPD_FILE_STATE */ - -struct fsdata_file { - const struct fsdata_file *next; - const unsigned char *name; - const unsigned char *data; - int len; - u8_t flags; -#if HTTPD_PRECALCULATED_CHECKSUM - u16_t chksum_count; - const struct fsdata_chksum *chksum; -#endif /* HTTPD_PRECALCULATED_CHECKSUM */ -}; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_FS_H */ +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_APPS_FS_H +#define LWIP_HDR_APPS_FS_H + +#include "httpd_opts.h" +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define FS_READ_EOF -1 +#define FS_READ_DELAYED -2 + +#if HTTPD_PRECALCULATED_CHECKSUM +struct fsdata_chksum { + u32_t offset; + u16_t chksum; + u16_t len; +}; +#endif /* HTTPD_PRECALCULATED_CHECKSUM */ + +#define FS_FILE_FLAGS_HEADER_INCLUDED 0x01 +#define FS_FILE_FLAGS_HEADER_PERSISTENT 0x02 +#define FS_FILE_FLAGS_HEADER_HTTPVER_1_1 0x04 +#define FS_FILE_FLAGS_SSI 0x08 + +/** Define FS_FILE_EXTENSION_T_DEFINED if you have typedef'ed to your private + * pointer type (defaults to 'void' so the default usage is 'void*') + */ +#ifndef FS_FILE_EXTENSION_T_DEFINED +typedef void fs_file_extension; +#endif + +struct fs_file { + const char *data; + int len; + int index; + /* pextension is free for implementations to hold private (extensional) + arbitrary data, e.g. holding some file state or file system handle */ + fs_file_extension *pextension; +#if HTTPD_PRECALCULATED_CHECKSUM + const struct fsdata_chksum *chksum; + u16_t chksum_count; +#endif /* HTTPD_PRECALCULATED_CHECKSUM */ + u8_t flags; +#if LWIP_HTTPD_CUSTOM_FILES + u8_t is_custom_file; +#endif /* LWIP_HTTPD_CUSTOM_FILES */ +#if LWIP_HTTPD_FILE_STATE + void *state; +#endif /* LWIP_HTTPD_FILE_STATE */ +}; + +#if LWIP_HTTPD_FS_ASYNC_READ +typedef void (*fs_wait_cb)(void *arg); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ + +err_t fs_open(struct fs_file *file, const char *name); +void fs_close(struct fs_file *file); +#if LWIP_HTTPD_DYNAMIC_FILE_READ +#if LWIP_HTTPD_FS_ASYNC_READ +int fs_read_async(struct fs_file *file, char *buffer, int count, fs_wait_cb callback_fn, void *callback_arg); +#else /* LWIP_HTTPD_FS_ASYNC_READ */ +int fs_read(struct fs_file *file, char *buffer, int count); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ +#endif /* LWIP_HTTPD_DYNAMIC_FILE_READ */ +#if LWIP_HTTPD_FS_ASYNC_READ +int fs_is_file_ready(struct fs_file *file, fs_wait_cb callback_fn, void *callback_arg); +#endif /* LWIP_HTTPD_FS_ASYNC_READ */ +int fs_bytes_left(struct fs_file *file); + +#if LWIP_HTTPD_FILE_STATE +/** This user-defined function is called when a file is opened. */ +void *fs_state_init(struct fs_file *file, const char *name); +/** This user-defined function is called when a file is closed. */ +void fs_state_free(struct fs_file *file, void *state); +#endif /* #if LWIP_HTTPD_FILE_STATE */ + +struct fsdata_file { + const struct fsdata_file *next; + const unsigned char *name; + const unsigned char *data; + int len; + u8_t flags; +#if HTTPD_PRECALCULATED_CHECKSUM + u16_t chksum_count; + const struct fsdata_chksum *chksum; +#endif /* HTTPD_PRECALCULATED_CHECKSUM */ +}; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_FS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/http_client.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/http_client.h index f4754b3a..8a063083 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/http_client.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/http_client.h @@ -1,160 +1,160 @@ -/** - * @file - * HTTP client - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#ifndef LWIP_HDR_APPS_HTTP_CLIENT_H -#define LWIP_HDR_APPS_HTTP_CLIENT_H - -#include "lwip/opt.h" -#include "lwip/ip_addr.h" -#include "lwip/err.h" -#include "lwip/altcp.h" -#include "lwip/prot/iana.h" -#include "lwip/pbuf.h" - -#if LWIP_TCP && LWIP_CALLBACK_API - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @ingroup httpc - * HTTPC_HAVE_FILE_IO: define this to 1 to have functions dowloading directly - * to disk via fopen/fwrite. - * These functions are example implementations of the interface only. - */ -#ifndef LWIP_HTTPC_HAVE_FILE_IO -#define LWIP_HTTPC_HAVE_FILE_IO 0 -#endif - -/** - * @ingroup httpc - * The default TCP port used for HTTP - */ -#define HTTP_DEFAULT_PORT LWIP_IANA_PORT_HTTP - -/** - * @ingroup httpc - * HTTP client result codes - */ -typedef enum ehttpc_result { - /** File successfully received */ - HTTPC_RESULT_OK = 0, - /** Unknown error */ - HTTPC_RESULT_ERR_UNKNOWN = 1, - /** Connection to server failed */ - HTTPC_RESULT_ERR_CONNECT = 2, - /** Failed to resolve server hostname */ - HTTPC_RESULT_ERR_HOSTNAME = 3, - /** Connection unexpectedly closed by remote server */ - HTTPC_RESULT_ERR_CLOSED = 4, - /** Connection timed out (server didn't respond in time) */ - HTTPC_RESULT_ERR_TIMEOUT = 5, - /** Server responded with an error code */ - HTTPC_RESULT_ERR_SVR_RESP = 6, - /** Local memory error */ - HTTPC_RESULT_ERR_MEM = 7, - /** Local abort */ - HTTPC_RESULT_LOCAL_ABORT = 8, - /** Content length mismatch */ - HTTPC_RESULT_ERR_CONTENT_LEN = 9 -} httpc_result_t; - -typedef struct _httpc_state httpc_state_t; - -/** - * @ingroup httpc - * Prototype of a http client callback function - * - * @param arg argument specified when initiating the request - * @param httpc_result result of the http transfer (see enum httpc_result_t) - * @param rx_content_len number of bytes received (without headers) - * @param srv_res this contains the http status code received (if any) - * @param err an error returned by internal lwip functions, can help to specify - * the source of the error but must not necessarily be != ERR_OK - */ -typedef void (*httpc_result_fn)(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, u32_t srv_res, err_t err); - -/** - * @ingroup httpc - * Prototype of http client callback: called when the headers are received - * - * @param connection http client connection - * @param arg argument specified when initiating the request - * @param hdr header pbuf(s) (may contain data also) - * @param hdr_len length of the heders in 'hdr' - * @param content_len content length as received in the headers (-1 if not received) - * @return if != ERR_OK is returned, the connection is aborted - */ -typedef err_t (*httpc_headers_done_fn)(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len); - -typedef struct _httpc_connection { - ip_addr_t proxy_addr; - u16_t proxy_port; - u8_t use_proxy; - /* @todo: add username:pass? */ - -#if LWIP_ALTCP - altcp_allocator_t *altcp_allocator; -#endif - - /* this callback is called when the transfer is finished (or aborted) */ - httpc_result_fn result_fn; - /* this callback is called after receiving the http headers - It can abort the connection by returning != ERR_OK */ - httpc_headers_done_fn headers_done_fn; -} httpc_connection_t; - -err_t httpc_get_file(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, - altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection); -err_t httpc_get_file_dns(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, - altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection); - -#if LWIP_HTTPC_HAVE_FILE_IO -err_t httpc_get_file_to_disk(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, - void* callback_arg, const char* local_file_name, httpc_state_t **connection); -err_t httpc_get_file_dns_to_disk(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, - void* callback_arg, const char* local_file_name, httpc_state_t **connection); -#endif /* LWIP_HTTPC_HAVE_FILE_IO */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_TCP && LWIP_CALLBACK_API */ - -#endif /* LWIP_HDR_APPS_HTTP_CLIENT_H */ +/** + * @file + * HTTP client + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#ifndef LWIP_HDR_APPS_HTTP_CLIENT_H +#define LWIP_HDR_APPS_HTTP_CLIENT_H + +#include "lwip/opt.h" +#include "lwip/ip_addr.h" +#include "lwip/err.h" +#include "lwip/altcp.h" +#include "lwip/prot/iana.h" +#include "lwip/pbuf.h" + +#if LWIP_TCP && LWIP_CALLBACK_API + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @ingroup httpc + * HTTPC_HAVE_FILE_IO: define this to 1 to have functions dowloading directly + * to disk via fopen/fwrite. + * These functions are example implementations of the interface only. + */ +#ifndef LWIP_HTTPC_HAVE_FILE_IO +#define LWIP_HTTPC_HAVE_FILE_IO 0 +#endif + +/** + * @ingroup httpc + * The default TCP port used for HTTP + */ +#define HTTP_DEFAULT_PORT LWIP_IANA_PORT_HTTP + +/** + * @ingroup httpc + * HTTP client result codes + */ +typedef enum ehttpc_result { + /** File successfully received */ + HTTPC_RESULT_OK = 0, + /** Unknown error */ + HTTPC_RESULT_ERR_UNKNOWN = 1, + /** Connection to server failed */ + HTTPC_RESULT_ERR_CONNECT = 2, + /** Failed to resolve server hostname */ + HTTPC_RESULT_ERR_HOSTNAME = 3, + /** Connection unexpectedly closed by remote server */ + HTTPC_RESULT_ERR_CLOSED = 4, + /** Connection timed out (server didn't respond in time) */ + HTTPC_RESULT_ERR_TIMEOUT = 5, + /** Server responded with an error code */ + HTTPC_RESULT_ERR_SVR_RESP = 6, + /** Local memory error */ + HTTPC_RESULT_ERR_MEM = 7, + /** Local abort */ + HTTPC_RESULT_LOCAL_ABORT = 8, + /** Content length mismatch */ + HTTPC_RESULT_ERR_CONTENT_LEN = 9 +} httpc_result_t; + +typedef struct _httpc_state httpc_state_t; + +/** + * @ingroup httpc + * Prototype of a http client callback function + * + * @param arg argument specified when initiating the request + * @param httpc_result result of the http transfer (see enum httpc_result_t) + * @param rx_content_len number of bytes received (without headers) + * @param srv_res this contains the http status code received (if any) + * @param err an error returned by internal lwip functions, can help to specify + * the source of the error but must not necessarily be != ERR_OK + */ +typedef void (*httpc_result_fn)(void *arg, httpc_result_t httpc_result, u32_t rx_content_len, u32_t srv_res, err_t err); + +/** + * @ingroup httpc + * Prototype of http client callback: called when the headers are received + * + * @param connection http client connection + * @param arg argument specified when initiating the request + * @param hdr header pbuf(s) (may contain data also) + * @param hdr_len length of the heders in 'hdr' + * @param content_len content length as received in the headers (-1 if not received) + * @return if != ERR_OK is returned, the connection is aborted + */ +typedef err_t (*httpc_headers_done_fn)(httpc_state_t *connection, void *arg, struct pbuf *hdr, u16_t hdr_len, u32_t content_len); + +typedef struct _httpc_connection { + ip_addr_t proxy_addr; + u16_t proxy_port; + u8_t use_proxy; + /* @todo: add username:pass? */ + +#if LWIP_ALTCP + altcp_allocator_t *altcp_allocator; +#endif + + /* this callback is called when the transfer is finished (or aborted) */ + httpc_result_fn result_fn; + /* this callback is called after receiving the http headers + It can abort the connection by returning != ERR_OK */ + httpc_headers_done_fn headers_done_fn; +} httpc_connection_t; + +err_t httpc_get_file(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, + altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection); +err_t httpc_get_file_dns(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, + altcp_recv_fn recv_fn, void* callback_arg, httpc_state_t **connection); + +#if LWIP_HTTPC_HAVE_FILE_IO +err_t httpc_get_file_to_disk(const ip_addr_t* server_addr, u16_t port, const char* uri, const httpc_connection_t *settings, + void* callback_arg, const char* local_file_name, httpc_state_t **connection); +err_t httpc_get_file_dns_to_disk(const char* server_name, u16_t port, const char* uri, const httpc_connection_t *settings, + void* callback_arg, const char* local_file_name, httpc_state_t **connection); +#endif /* LWIP_HTTPC_HAVE_FILE_IO */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_TCP && LWIP_CALLBACK_API */ + +#endif /* LWIP_HDR_APPS_HTTP_CLIENT_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd.h index 615261ea..e872429f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd.h @@ -1,255 +1,255 @@ -/** - * @file - * HTTP server - */ - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - * This version of the file has been modified by Texas Instruments to offer - * simple server-side-include (SSI) and Common Gateway Interface (CGI) - * capability. - */ - -#ifndef LWIP_HDR_APPS_HTTPD_H -#define LWIP_HDR_APPS_HTTPD_H - -#include "httpd_opts.h" -#include "lwip/err.h" -#include "lwip/pbuf.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_HTTPD_CGI - -/** - * @ingroup httpd - * Function pointer for a CGI script handler. - * - * This function is called each time the HTTPD server is asked for a file - * whose name was previously registered as a CGI function using a call to - * http_set_cgi_handlers. The iIndex parameter provides the index of the - * CGI within the cgis array passed to http_set_cgi_handlers. Parameters - * pcParam and pcValue provide access to the parameters provided along with - * the URI. iNumParams provides a count of the entries in the pcParam and - * pcValue arrays. Each entry in the pcParam array contains the name of a - * parameter with the corresponding entry in the pcValue array containing the - * value for that parameter. Note that pcParam may contain multiple elements - * with the same name if, for example, a multi-selection list control is used - * in the form generating the data. - * - * The function should return a pointer to a character string which is the - * path and filename of the response that is to be sent to the connected - * browser, for example "/thanks.htm" or "/response/error.ssi". - * - * The maximum number of parameters that will be passed to this function via - * iNumParams is defined by LWIP_HTTPD_MAX_CGI_PARAMETERS. Any parameters in - * the incoming HTTP request above this number will be discarded. - * - * Requests intended for use by this CGI mechanism must be sent using the GET - * method (which encodes all parameters within the URI rather than in a block - * later in the request). Attempts to use the POST method will result in the - * request being ignored. - * - */ -typedef const char *(*tCGIHandler)(int iIndex, int iNumParams, char *pcParam[], - char *pcValue[]); - -/** - * @ingroup httpd - * Structure defining the base filename (URL) of a CGI and the associated - * function which is to be called when that URL is requested. - */ -typedef struct -{ - const char *pcCGIName; - tCGIHandler pfnCGIHandler; -} tCGI; - -void http_set_cgi_handlers(const tCGI *pCGIs, int iNumHandlers); - -#endif /* LWIP_HTTPD_CGI */ - -#if LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI - -#if LWIP_HTTPD_CGI_SSI -/* we have to prototype this struct here to make it available for the handler */ -struct fs_file; - -/** Define this generic CGI handler in your application. - * It is called once for every URI with parameters. - * The parameters can be stored to the object passed as connection_state, which - * is allocated to file->state via fs_state_init() from fs_open() or fs_open_custom(). - * Content creation via SSI or complete dynamic files can retrieve the CGI params from there. - */ -extern void httpd_cgi_handler(struct fs_file *file, const char* uri, int iNumParams, - char **pcParam, char **pcValue -#if defined(LWIP_HTTPD_FILE_STATE) && LWIP_HTTPD_FILE_STATE - , void *connection_state -#endif /* LWIP_HTTPD_FILE_STATE */ - ); -#endif /* LWIP_HTTPD_CGI_SSI */ - -#endif /* LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI */ - -#if LWIP_HTTPD_SSI - -/** - * @ingroup httpd - * Function pointer for the SSI tag handler callback. - * - * This function will be called each time the HTTPD server detects a tag of the - * form in files with extensions mentioned in the g_pcSSIExtensions - * array (currently .shtml, .shtm, .ssi, .xml, .json) where "name" appears as - * one of the tags supplied to http_set_ssi_handler in the tags array. The - * returned insert string, which will be appended after the the string - * "" in file sent back to the client, should be written to pointer - * pcInsert. iInsertLen contains the size of the buffer pointed to by - * pcInsert. The iIndex parameter provides the zero-based index of the tag as - * found in the tags array and identifies the tag that is to be processed. - * - * The handler returns the number of characters written to pcInsert excluding - * any terminating NULL or HTTPD_SSI_TAG_UNKNOWN when tag is not recognized. - * - * Note that the behavior of this SSI mechanism is somewhat different from the - * "normal" SSI processing as found in, for example, the Apache web server. In - * this case, the inserted text is appended following the SSI tag rather than - * replacing the tag entirely. This allows for an implementation that does not - * require significant additional buffering of output data yet which will still - * offer usable SSI functionality. One downside to this approach is when - * attempting to use SSI within JavaScript. The SSI tag is structured to - * resemble an HTML comment but this syntax does not constitute a comment - * within JavaScript and, hence, leaving the tag in place will result in - * problems in these cases. In order to avoid these problems, define - * LWIP_HTTPD_SSI_INCLUDE_TAG as zero in your lwip options file, or use JavaScript - * style block comments in the form / * # name * / (without the spaces). - */ -typedef u16_t (*tSSIHandler)( -#if LWIP_HTTPD_SSI_RAW - const char* ssi_tag_name, -#else /* LWIP_HTTPD_SSI_RAW */ - int iIndex, -#endif /* LWIP_HTTPD_SSI_RAW */ - char *pcInsert, int iInsertLen -#if LWIP_HTTPD_SSI_MULTIPART - , u16_t current_tag_part, u16_t *next_tag_part -#endif /* LWIP_HTTPD_SSI_MULTIPART */ -#if defined(LWIP_HTTPD_FILE_STATE) && LWIP_HTTPD_FILE_STATE - , void *connection_state -#endif /* LWIP_HTTPD_FILE_STATE */ - ); - -/** Set the SSI handler function - * (if LWIP_HTTPD_SSI_RAW==1, only the first argument is used) - */ -void http_set_ssi_handler(tSSIHandler pfnSSIHandler, - const char **ppcTags, int iNumTags); - -/** For LWIP_HTTPD_SSI_RAW==1, return this to indicate the tag is unknown. - * In this case, the webserver writes a warning into the page. - * You can also just return 0 to write nothing for unknown tags. - */ -#define HTTPD_SSI_TAG_UNKNOWN 0xFFFF - -#endif /* LWIP_HTTPD_SSI */ - -#if LWIP_HTTPD_SUPPORT_POST - -/* These functions must be implemented by the application */ - -/** - * @ingroup httpd - * Called when a POST request has been received. The application can decide - * whether to accept it or not. - * - * @param connection Unique connection identifier, valid until httpd_post_end - * is called. - * @param uri The HTTP header URI receiving the POST request. - * @param http_request The raw HTTP request (the first packet, normally). - * @param http_request_len Size of 'http_request'. - * @param content_len Content-Length from HTTP header. - * @param response_uri Filename of response file, to be filled when denying the - * request - * @param response_uri_len Size of the 'response_uri' buffer. - * @param post_auto_wnd Set this to 0 to let the callback code handle window - * updates by calling 'httpd_post_data_recved' (to throttle rx speed) - * default is 1 (httpd handles window updates automatically) - * @return ERR_OK: Accept the POST request, data may be passed in - * another err_t: Deny the POST request, send back 'bad request'. - */ -err_t httpd_post_begin(void *connection, const char *uri, const char *http_request, - u16_t http_request_len, int content_len, char *response_uri, - u16_t response_uri_len, u8_t *post_auto_wnd); - -/** - * @ingroup httpd - * Called for each pbuf of data that has been received for a POST. - * ATTENTION: The application is responsible for freeing the pbufs passed in! - * - * @param connection Unique connection identifier. - * @param p Received data. - * @return ERR_OK: Data accepted. - * another err_t: Data denied, http_post_get_response_uri will be called. - */ -err_t httpd_post_receive_data(void *connection, struct pbuf *p); - -/** - * @ingroup httpd - * Called when all data is received or when the connection is closed. - * The application must return the filename/URI of a file to send in response - * to this POST request. If the response_uri buffer is untouched, a 404 - * response is returned. - * - * @param connection Unique connection identifier. - * @param response_uri Filename of response file, to be filled when denying the request - * @param response_uri_len Size of the 'response_uri' buffer. - */ -void httpd_post_finished(void *connection, char *response_uri, u16_t response_uri_len); - -#if LWIP_HTTPD_POST_MANUAL_WND -void httpd_post_data_recved(void *connection, u16_t recved_len); -#endif /* LWIP_HTTPD_POST_MANUAL_WND */ - -#endif /* LWIP_HTTPD_SUPPORT_POST */ - -void httpd_init(void); - -#if HTTPD_ENABLE_HTTPS -struct altcp_tls_config; -void httpd_inits(struct altcp_tls_config *conf); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_HTTPD_H */ +/** + * @file + * HTTP server + */ + +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + * This version of the file has been modified by Texas Instruments to offer + * simple server-side-include (SSI) and Common Gateway Interface (CGI) + * capability. + */ + +#ifndef LWIP_HDR_APPS_HTTPD_H +#define LWIP_HDR_APPS_HTTPD_H + +#include "httpd_opts.h" +#include "lwip/err.h" +#include "lwip/pbuf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_HTTPD_CGI + +/** + * @ingroup httpd + * Function pointer for a CGI script handler. + * + * This function is called each time the HTTPD server is asked for a file + * whose name was previously registered as a CGI function using a call to + * http_set_cgi_handlers. The iIndex parameter provides the index of the + * CGI within the cgis array passed to http_set_cgi_handlers. Parameters + * pcParam and pcValue provide access to the parameters provided along with + * the URI. iNumParams provides a count of the entries in the pcParam and + * pcValue arrays. Each entry in the pcParam array contains the name of a + * parameter with the corresponding entry in the pcValue array containing the + * value for that parameter. Note that pcParam may contain multiple elements + * with the same name if, for example, a multi-selection list control is used + * in the form generating the data. + * + * The function should return a pointer to a character string which is the + * path and filename of the response that is to be sent to the connected + * browser, for example "/thanks.htm" or "/response/error.ssi". + * + * The maximum number of parameters that will be passed to this function via + * iNumParams is defined by LWIP_HTTPD_MAX_CGI_PARAMETERS. Any parameters in + * the incoming HTTP request above this number will be discarded. + * + * Requests intended for use by this CGI mechanism must be sent using the GET + * method (which encodes all parameters within the URI rather than in a block + * later in the request). Attempts to use the POST method will result in the + * request being ignored. + * + */ +typedef const char *(*tCGIHandler)(int iIndex, int iNumParams, char *pcParam[], + char *pcValue[]); + +/** + * @ingroup httpd + * Structure defining the base filename (URL) of a CGI and the associated + * function which is to be called when that URL is requested. + */ +typedef struct +{ + const char *pcCGIName; + tCGIHandler pfnCGIHandler; +} tCGI; + +void http_set_cgi_handlers(const tCGI *pCGIs, int iNumHandlers); + +#endif /* LWIP_HTTPD_CGI */ + +#if LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI + +#if LWIP_HTTPD_CGI_SSI +/* we have to prototype this struct here to make it available for the handler */ +struct fs_file; + +/** Define this generic CGI handler in your application. + * It is called once for every URI with parameters. + * The parameters can be stored to the object passed as connection_state, which + * is allocated to file->state via fs_state_init() from fs_open() or fs_open_custom(). + * Content creation via SSI or complete dynamic files can retrieve the CGI params from there. + */ +extern void httpd_cgi_handler(struct fs_file *file, const char* uri, int iNumParams, + char **pcParam, char **pcValue +#if defined(LWIP_HTTPD_FILE_STATE) && LWIP_HTTPD_FILE_STATE + , void *connection_state +#endif /* LWIP_HTTPD_FILE_STATE */ + ); +#endif /* LWIP_HTTPD_CGI_SSI */ + +#endif /* LWIP_HTTPD_CGI || LWIP_HTTPD_CGI_SSI */ + +#if LWIP_HTTPD_SSI + +/** + * @ingroup httpd + * Function pointer for the SSI tag handler callback. + * + * This function will be called each time the HTTPD server detects a tag of the + * form in files with extensions mentioned in the g_pcSSIExtensions + * array (currently .shtml, .shtm, .ssi, .xml, .json) where "name" appears as + * one of the tags supplied to http_set_ssi_handler in the tags array. The + * returned insert string, which will be appended after the the string + * "" in file sent back to the client, should be written to pointer + * pcInsert. iInsertLen contains the size of the buffer pointed to by + * pcInsert. The iIndex parameter provides the zero-based index of the tag as + * found in the tags array and identifies the tag that is to be processed. + * + * The handler returns the number of characters written to pcInsert excluding + * any terminating NULL or HTTPD_SSI_TAG_UNKNOWN when tag is not recognized. + * + * Note that the behavior of this SSI mechanism is somewhat different from the + * "normal" SSI processing as found in, for example, the Apache web server. In + * this case, the inserted text is appended following the SSI tag rather than + * replacing the tag entirely. This allows for an implementation that does not + * require significant additional buffering of output data yet which will still + * offer usable SSI functionality. One downside to this approach is when + * attempting to use SSI within JavaScript. The SSI tag is structured to + * resemble an HTML comment but this syntax does not constitute a comment + * within JavaScript and, hence, leaving the tag in place will result in + * problems in these cases. In order to avoid these problems, define + * LWIP_HTTPD_SSI_INCLUDE_TAG as zero in your lwip options file, or use JavaScript + * style block comments in the form / * # name * / (without the spaces). + */ +typedef u16_t (*tSSIHandler)( +#if LWIP_HTTPD_SSI_RAW + const char* ssi_tag_name, +#else /* LWIP_HTTPD_SSI_RAW */ + int iIndex, +#endif /* LWIP_HTTPD_SSI_RAW */ + char *pcInsert, int iInsertLen +#if LWIP_HTTPD_SSI_MULTIPART + , u16_t current_tag_part, u16_t *next_tag_part +#endif /* LWIP_HTTPD_SSI_MULTIPART */ +#if defined(LWIP_HTTPD_FILE_STATE) && LWIP_HTTPD_FILE_STATE + , void *connection_state +#endif /* LWIP_HTTPD_FILE_STATE */ + ); + +/** Set the SSI handler function + * (if LWIP_HTTPD_SSI_RAW==1, only the first argument is used) + */ +void http_set_ssi_handler(tSSIHandler pfnSSIHandler, + const char **ppcTags, int iNumTags); + +/** For LWIP_HTTPD_SSI_RAW==1, return this to indicate the tag is unknown. + * In this case, the webserver writes a warning into the page. + * You can also just return 0 to write nothing for unknown tags. + */ +#define HTTPD_SSI_TAG_UNKNOWN 0xFFFF + +#endif /* LWIP_HTTPD_SSI */ + +#if LWIP_HTTPD_SUPPORT_POST + +/* These functions must be implemented by the application */ + +/** + * @ingroup httpd + * Called when a POST request has been received. The application can decide + * whether to accept it or not. + * + * @param connection Unique connection identifier, valid until httpd_post_end + * is called. + * @param uri The HTTP header URI receiving the POST request. + * @param http_request The raw HTTP request (the first packet, normally). + * @param http_request_len Size of 'http_request'. + * @param content_len Content-Length from HTTP header. + * @param response_uri Filename of response file, to be filled when denying the + * request + * @param response_uri_len Size of the 'response_uri' buffer. + * @param post_auto_wnd Set this to 0 to let the callback code handle window + * updates by calling 'httpd_post_data_recved' (to throttle rx speed) + * default is 1 (httpd handles window updates automatically) + * @return ERR_OK: Accept the POST request, data may be passed in + * another err_t: Deny the POST request, send back 'bad request'. + */ +err_t httpd_post_begin(void *connection, const char *uri, const char *http_request, + u16_t http_request_len, int content_len, char *response_uri, + u16_t response_uri_len, u8_t *post_auto_wnd); + +/** + * @ingroup httpd + * Called for each pbuf of data that has been received for a POST. + * ATTENTION: The application is responsible for freeing the pbufs passed in! + * + * @param connection Unique connection identifier. + * @param p Received data. + * @return ERR_OK: Data accepted. + * another err_t: Data denied, http_post_get_response_uri will be called. + */ +err_t httpd_post_receive_data(void *connection, struct pbuf *p); + +/** + * @ingroup httpd + * Called when all data is received or when the connection is closed. + * The application must return the filename/URI of a file to send in response + * to this POST request. If the response_uri buffer is untouched, a 404 + * response is returned. + * + * @param connection Unique connection identifier. + * @param response_uri Filename of response file, to be filled when denying the request + * @param response_uri_len Size of the 'response_uri' buffer. + */ +void httpd_post_finished(void *connection, char *response_uri, u16_t response_uri_len); + +#if LWIP_HTTPD_POST_MANUAL_WND +void httpd_post_data_recved(void *connection, u16_t recved_len); +#endif /* LWIP_HTTPD_POST_MANUAL_WND */ + +#endif /* LWIP_HTTPD_SUPPORT_POST */ + +void httpd_init(void); + +#if HTTPD_ENABLE_HTTPS +struct altcp_tls_config; +void httpd_inits(struct altcp_tls_config *conf); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_HTTPD_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd_opts.h index 733e1171..8723961f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/httpd_opts.h @@ -1,396 +1,396 @@ -/** - * @file - * HTTP server options list - */ - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - * This version of the file has been modified by Texas Instruments to offer - * simple server-side-include (SSI) and Common Gateway Interface (CGI) - * capability. - */ - -#ifndef LWIP_HDR_APPS_HTTPD_OPTS_H -#define LWIP_HDR_APPS_HTTPD_OPTS_H - -#include "lwip/opt.h" -#include "lwip/prot/iana.h" - -/** - * @defgroup httpd_opts Options - * @ingroup httpd - * @{ - */ - -/** Set this to 1 to support CGI (old style). - * - * This old style CGI support works by registering an array of URLs and - * associated CGI handler functions (@ref http_set_cgi_handlers). - * This list is scanned just before fs_open is called from request handling. - * The handler can return a new URL that is used internally by the httpd to - * load the returned page (passed to fs_open). - * - * Use this CGI type e.g. to execute specific actions and return a page that - * does not depend on the CGI parameters. - */ -#if !defined LWIP_HTTPD_CGI || defined __DOXYGEN__ -#define LWIP_HTTPD_CGI 0 -#endif - -/** Set this to 1 to support CGI (new style). - * - * This new style CGI support works by calling a global function - * (@ref tCGIHandler) for all URLs that are found. fs_open is called first - * and the URL can not be written by the CGI handler. Instead, this handler gets - * passed the http file state, an object where it can store information derived - * from the CGI URL or parameters. This file state is later passed to SSI, so - * the SSI code can return data depending on CGI input. - * - * Use this CGI handler if you want CGI information passed on to SSI. - */ -#if !defined LWIP_HTTPD_CGI_SSI || defined __DOXYGEN__ -#define LWIP_HTTPD_CGI_SSI 0 -#endif - -/** Set this to 1 to support SSI (Server-Side-Includes) - * - * In contrast to other http servers, this only calls a preregistered callback - * function (@see http_set_ssi_handler) for each tag (in the format of - * ) encountered in SSI-enabled pages. - * SSI-enabled pages must have one of the predefined SSI-enabled file extensions. - * All files with one of these extensions are parsed when sent. - * - * A downside of the current SSI implementation is that persistent connections - * don't work, as the file length is not known in advance (and httpd currently - * relies on the Content-Length header for persistent connections). - * - * To save memory, the maximum tag length is limited (@see LWIP_HTTPD_MAX_TAG_NAME_LEN). - * To save memory, the maximum insertion string length is limited (@see - * LWIP_HTTPD_MAX_TAG_INSERT_LEN). If this is not enought, @ref LWIP_HTTPD_SSI_MULTIPART - * can be used. - */ -#if !defined LWIP_HTTPD_SSI || defined __DOXYGEN__ -#define LWIP_HTTPD_SSI 0 -#endif - -/** Set this to 1 to implement an SSI tag handler callback that gets a const char* - * to the tag (instead of an index into a pre-registered array of known tags) - * If this is 0, the SSI handler callback function is only called pre-registered tags. - */ -#if !defined LWIP_HTTPD_SSI_RAW || defined __DOXYGEN__ -#define LWIP_HTTPD_SSI_RAW 0 -#endif - -/** Set this to 0 to prevent parsing the file extension at runtime to decide - * if a file should be scanned for SSI tags or not. - * Default is 1 (file extensions are checked using the g_pcSSIExtensions array) - * Set to 2 to override this runtime test function. - * - * This is enabled by default, but if you only use a newer version of makefsdata - * supporting the "-ssi" option, this info is already present in - */ -#if !defined LWIP_HTTPD_SSI_BY_FILE_EXTENSION || defined __DOXYGEN__ -#define LWIP_HTTPD_SSI_BY_FILE_EXTENSION 1 -#endif - -/** Set this to 1 to support HTTP POST */ -#if !defined LWIP_HTTPD_SUPPORT_POST || defined __DOXYGEN__ -#define LWIP_HTTPD_SUPPORT_POST 0 -#endif - -/* The maximum number of parameters that the CGI handler can be sent. */ -#if !defined LWIP_HTTPD_MAX_CGI_PARAMETERS || defined __DOXYGEN__ -#define LWIP_HTTPD_MAX_CGI_PARAMETERS 16 -#endif - -/** LWIP_HTTPD_SSI_MULTIPART==1: SSI handler function is called with 2 more - * arguments indicating a counter for insert string that are too long to be - * inserted at once: the SSI handler function must then set 'next_tag_part' - * which will be passed back to it in the next call. */ -#if !defined LWIP_HTTPD_SSI_MULTIPART || defined __DOXYGEN__ -#define LWIP_HTTPD_SSI_MULTIPART 0 -#endif - -/* The maximum length of the string comprising the SSI tag name - * ATTENTION: tags longer than this are ignored, not truncated! - */ -#if !defined LWIP_HTTPD_MAX_TAG_NAME_LEN || defined __DOXYGEN__ -#define LWIP_HTTPD_MAX_TAG_NAME_LEN 8 -#endif - -/* The maximum length of string that can be returned to replace any given tag - * If this buffer is not long enough, use LWIP_HTTPD_SSI_MULTIPART. - */ -#if !defined LWIP_HTTPD_MAX_TAG_INSERT_LEN || defined __DOXYGEN__ -#define LWIP_HTTPD_MAX_TAG_INSERT_LEN 192 -#endif - -#if !defined LWIP_HTTPD_POST_MANUAL_WND || defined __DOXYGEN__ -#define LWIP_HTTPD_POST_MANUAL_WND 0 -#endif - -/** This string is passed in the HTTP header as "Server: " */ -#if !defined HTTPD_SERVER_AGENT || defined __DOXYGEN__ -#define HTTPD_SERVER_AGENT "lwIP/" LWIP_VERSION_STRING " (http://savannah.nongnu.org/projects/lwip)" -#endif - -/** Set this to 1 if you want to include code that creates HTTP headers - * at runtime. Default is off: HTTP headers are then created statically - * by the makefsdata tool. Static headers mean smaller code size, but - * the (readonly) fsdata will grow a bit as every file includes the HTTP - * header. */ -#if !defined LWIP_HTTPD_DYNAMIC_HEADERS || defined __DOXYGEN__ -#define LWIP_HTTPD_DYNAMIC_HEADERS 0 -#endif - -#if !defined HTTPD_DEBUG || defined __DOXYGEN__ -#define HTTPD_DEBUG LWIP_DBG_OFF -#endif - -/** Set this to 1 to use a memp pool for allocating - * struct http_state instead of the heap. - * If enabled, you'll need to define MEMP_NUM_PARALLEL_HTTPD_CONNS - * (and MEMP_NUM_PARALLEL_HTTPD_SSI_CONNS for SSI) to set the size of - * the pool(s). - */ -#if !defined HTTPD_USE_MEM_POOL || defined __DOXYGEN__ -#define HTTPD_USE_MEM_POOL 0 -#endif - -/** The server port for HTTPD to use */ -#if !defined HTTPD_SERVER_PORT || defined __DOXYGEN__ -#define HTTPD_SERVER_PORT LWIP_IANA_PORT_HTTP -#endif - -/** The https server port for HTTPD to use */ -#if !defined HTTPD_SERVER_PORT_HTTPS || defined __DOXYGEN__ -#define HTTPD_SERVER_PORT_HTTPS LWIP_IANA_PORT_HTTPS -#endif - -/** Enable https support? */ -#if !defined HTTPD_ENABLE_HTTPS || defined __DOXYGEN__ -#define HTTPD_ENABLE_HTTPS 0 -#endif - -/** Maximum retries before the connection is aborted/closed. - * - number of times pcb->poll is called -> default is 4*500ms = 2s; - * - reset when pcb->sent is called - */ -#if !defined HTTPD_MAX_RETRIES || defined __DOXYGEN__ -#define HTTPD_MAX_RETRIES 4 -#endif - -/** The poll delay is X*500ms */ -#if !defined HTTPD_POLL_INTERVAL || defined __DOXYGEN__ -#define HTTPD_POLL_INTERVAL 4 -#endif - -/** Priority for tcp pcbs created by HTTPD (very low by default). - * Lower priorities get killed first when running out of memory. - */ -#if !defined HTTPD_TCP_PRIO || defined __DOXYGEN__ -#define HTTPD_TCP_PRIO TCP_PRIO_MIN -#endif - -/** Set this to 1 to enable timing each file sent */ -#if !defined LWIP_HTTPD_TIMING || defined __DOXYGEN__ -#define LWIP_HTTPD_TIMING 0 -#endif -/** Set this to 1 to enable timing each file sent */ -#if !defined HTTPD_DEBUG_TIMING || defined __DOXYGEN__ -#define HTTPD_DEBUG_TIMING LWIP_DBG_OFF -#endif - -/** Set this to one to show error pages when parsing a request fails instead - of simply closing the connection. */ -#if !defined LWIP_HTTPD_SUPPORT_EXTSTATUS || defined __DOXYGEN__ -#define LWIP_HTTPD_SUPPORT_EXTSTATUS 0 -#endif - -/** Set this to 0 to drop support for HTTP/0.9 clients (to save some bytes) */ -#if !defined LWIP_HTTPD_SUPPORT_V09 || defined __DOXYGEN__ -#define LWIP_HTTPD_SUPPORT_V09 1 -#endif - -/** Set this to 1 to enable HTTP/1.1 persistent connections. - * ATTENTION: If the generated file system includes HTTP headers, these must - * include the "Connection: keep-alive" header (pass argument "-11" to makefsdata). - */ -#if !defined LWIP_HTTPD_SUPPORT_11_KEEPALIVE || defined __DOXYGEN__ -#define LWIP_HTTPD_SUPPORT_11_KEEPALIVE 0 -#endif - -/** Set this to 1 to support HTTP request coming in in multiple packets/pbufs */ -#if !defined LWIP_HTTPD_SUPPORT_REQUESTLIST || defined __DOXYGEN__ -#define LWIP_HTTPD_SUPPORT_REQUESTLIST 1 -#endif - -#if LWIP_HTTPD_SUPPORT_REQUESTLIST -/** Number of rx pbufs to enqueue to parse an incoming request (up to the first - newline) */ -#if !defined LWIP_HTTPD_REQ_QUEUELEN || defined __DOXYGEN__ -#define LWIP_HTTPD_REQ_QUEUELEN 5 -#endif - -/** Number of (TCP payload-) bytes (in pbufs) to enqueue to parse and incoming - request (up to the first double-newline) */ -#if !defined LWIP_HTTPD_REQ_BUFSIZE || defined __DOXYGEN__ -#define LWIP_HTTPD_REQ_BUFSIZE LWIP_HTTPD_MAX_REQ_LENGTH -#endif - -/** Defines the maximum length of a HTTP request line (up to the first CRLF, - copied from pbuf into this a global buffer when pbuf- or packet-queues - are received - otherwise the input pbuf is used directly) */ -#if !defined LWIP_HTTPD_MAX_REQ_LENGTH || defined __DOXYGEN__ -#define LWIP_HTTPD_MAX_REQ_LENGTH LWIP_MIN(1023, (LWIP_HTTPD_REQ_QUEUELEN * PBUF_POOL_BUFSIZE)) -#endif -#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ - -/** This is the size of a static buffer used when URIs end with '/'. - * In this buffer, the directory requested is concatenated with all the - * configured default file names. - * Set to 0 to disable checking default filenames on non-root directories. - */ -#if !defined LWIP_HTTPD_MAX_REQUEST_URI_LEN || defined __DOXYGEN__ -#define LWIP_HTTPD_MAX_REQUEST_URI_LEN 63 -#endif - -/** Maximum length of the filename to send as response to a POST request, - * filled in by the application when a POST is finished. - */ -#if !defined LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN || defined __DOXYGEN__ -#define LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN 63 -#endif - -/** Set this to 0 to not send the SSI tag (default is on, so the tag will - * be sent in the HTML page */ -#if !defined LWIP_HTTPD_SSI_INCLUDE_TAG || defined __DOXYGEN__ -#define LWIP_HTTPD_SSI_INCLUDE_TAG 1 -#endif - -/** Set this to 1 to call tcp_abort when tcp_close fails with memory error. - * This can be used to prevent consuming all memory in situations where the - * HTTP server has low priority compared to other communication. */ -#if !defined LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR || defined __DOXYGEN__ -#define LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR 0 -#endif - -/** Set this to 1 to kill the oldest connection when running out of - * memory for 'struct http_state' or 'struct http_ssi_state'. - * ATTENTION: This puts all connections on a linked list, so may be kind of slow. - */ -#if !defined LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED || defined __DOXYGEN__ -#define LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED 0 -#endif - -/** Set this to 1 to send URIs without extension without headers - * (who uses this at all??) */ -#if !defined LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI || defined __DOXYGEN__ -#define LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI 0 -#endif - -/** Default: Tags are sent from struct http_state and are therefore volatile */ -#if !defined HTTP_IS_TAG_VOLATILE || defined __DOXYGEN__ -#define HTTP_IS_TAG_VOLATILE(ptr) TCP_WRITE_FLAG_COPY -#endif - -/* By default, the httpd is limited to send 2*pcb->mss to keep resource usage low - when http is not an important protocol in the device. */ -#if !defined HTTPD_LIMIT_SENDING_TO_2MSS || defined __DOXYGEN__ -#define HTTPD_LIMIT_SENDING_TO_2MSS 1 -#endif - -/* Define this to a function that returns the maximum amount of data to enqueue. - The function have this signature: u16_t fn(struct altcp_pcb* pcb); - The best place to define this is the hooks file (@see LWIP_HOOK_FILENAME) */ -#if !defined HTTPD_MAX_WRITE_LEN || defined __DOXYGEN__ -#if HTTPD_LIMIT_SENDING_TO_2MSS -#define HTTPD_MAX_WRITE_LEN(pcb) ((u16_t)(2 * altcp_mss(pcb))) -#endif -#endif - -/*------------------- FS OPTIONS -------------------*/ - -/** Set this to 1 and provide the functions: - * - "int fs_open_custom(struct fs_file *file, const char *name)" - * Called first for every opened file to allow opening files - * that are not included in fsdata(_custom).c - * - "void fs_close_custom(struct fs_file *file)" - * Called to free resources allocated by fs_open_custom(). - */ -#if !defined LWIP_HTTPD_CUSTOM_FILES || defined __DOXYGEN__ -#define LWIP_HTTPD_CUSTOM_FILES 0 -#endif - -/** Set this to 1 to support fs_read() to dynamically read file data. - * Without this (default=off), only one-block files are supported, - * and the contents must be ready after fs_open(). - */ -#if !defined LWIP_HTTPD_DYNAMIC_FILE_READ || defined __DOXYGEN__ -#define LWIP_HTTPD_DYNAMIC_FILE_READ 0 -#endif - -/** Set this to 1 to include an application state argument per file - * that is opened. This allows to keep a state per connection/file. - */ -#if !defined LWIP_HTTPD_FILE_STATE || defined __DOXYGEN__ -#define LWIP_HTTPD_FILE_STATE 0 -#endif - -/** HTTPD_PRECALCULATED_CHECKSUM==1: include precompiled checksums for - * predefined (MSS-sized) chunks of the files to prevent having to calculate - * the checksums at runtime. */ -#if !defined HTTPD_PRECALCULATED_CHECKSUM || defined __DOXYGEN__ -#define HTTPD_PRECALCULATED_CHECKSUM 0 -#endif - -/** LWIP_HTTPD_FS_ASYNC_READ==1: support asynchronous read operations - * (fs_read_async returns FS_READ_DELAYED and calls a callback when finished). - */ -#if !defined LWIP_HTTPD_FS_ASYNC_READ || defined __DOXYGEN__ -#define LWIP_HTTPD_FS_ASYNC_READ 0 -#endif - -/** Filename (including path) to use as FS data file */ -#if !defined HTTPD_FSDATA_FILE || defined __DOXYGEN__ -/* HTTPD_USE_CUSTOM_FSDATA: Compatibility with deprecated lwIP option */ -#if defined(HTTPD_USE_CUSTOM_FSDATA) && (HTTPD_USE_CUSTOM_FSDATA != 0) -#define HTTPD_FSDATA_FILE "fsdata_custom.c" -#else -#define HTTPD_FSDATA_FILE "fsdata.c" -#endif -#endif - -/** - * @} - */ - -#endif /* LWIP_HDR_APPS_HTTPD_OPTS_H */ +/** + * @file + * HTTP server options list + */ + +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + * This version of the file has been modified by Texas Instruments to offer + * simple server-side-include (SSI) and Common Gateway Interface (CGI) + * capability. + */ + +#ifndef LWIP_HDR_APPS_HTTPD_OPTS_H +#define LWIP_HDR_APPS_HTTPD_OPTS_H + +#include "lwip/opt.h" +#include "lwip/prot/iana.h" + +/** + * @defgroup httpd_opts Options + * @ingroup httpd + * @{ + */ + +/** Set this to 1 to support CGI (old style). + * + * This old style CGI support works by registering an array of URLs and + * associated CGI handler functions (@ref http_set_cgi_handlers). + * This list is scanned just before fs_open is called from request handling. + * The handler can return a new URL that is used internally by the httpd to + * load the returned page (passed to fs_open). + * + * Use this CGI type e.g. to execute specific actions and return a page that + * does not depend on the CGI parameters. + */ +#if !defined LWIP_HTTPD_CGI || defined __DOXYGEN__ +#define LWIP_HTTPD_CGI 0 +#endif + +/** Set this to 1 to support CGI (new style). + * + * This new style CGI support works by calling a global function + * (@ref tCGIHandler) for all URLs that are found. fs_open is called first + * and the URL can not be written by the CGI handler. Instead, this handler gets + * passed the http file state, an object where it can store information derived + * from the CGI URL or parameters. This file state is later passed to SSI, so + * the SSI code can return data depending on CGI input. + * + * Use this CGI handler if you want CGI information passed on to SSI. + */ +#if !defined LWIP_HTTPD_CGI_SSI || defined __DOXYGEN__ +#define LWIP_HTTPD_CGI_SSI 0 +#endif + +/** Set this to 1 to support SSI (Server-Side-Includes) + * + * In contrast to other http servers, this only calls a preregistered callback + * function (@see http_set_ssi_handler) for each tag (in the format of + * ) encountered in SSI-enabled pages. + * SSI-enabled pages must have one of the predefined SSI-enabled file extensions. + * All files with one of these extensions are parsed when sent. + * + * A downside of the current SSI implementation is that persistent connections + * don't work, as the file length is not known in advance (and httpd currently + * relies on the Content-Length header for persistent connections). + * + * To save memory, the maximum tag length is limited (@see LWIP_HTTPD_MAX_TAG_NAME_LEN). + * To save memory, the maximum insertion string length is limited (@see + * LWIP_HTTPD_MAX_TAG_INSERT_LEN). If this is not enought, @ref LWIP_HTTPD_SSI_MULTIPART + * can be used. + */ +#if !defined LWIP_HTTPD_SSI || defined __DOXYGEN__ +#define LWIP_HTTPD_SSI 0 +#endif + +/** Set this to 1 to implement an SSI tag handler callback that gets a const char* + * to the tag (instead of an index into a pre-registered array of known tags) + * If this is 0, the SSI handler callback function is only called pre-registered tags. + */ +#if !defined LWIP_HTTPD_SSI_RAW || defined __DOXYGEN__ +#define LWIP_HTTPD_SSI_RAW 0 +#endif + +/** Set this to 0 to prevent parsing the file extension at runtime to decide + * if a file should be scanned for SSI tags or not. + * Default is 1 (file extensions are checked using the g_pcSSIExtensions array) + * Set to 2 to override this runtime test function. + * + * This is enabled by default, but if you only use a newer version of makefsdata + * supporting the "-ssi" option, this info is already present in + */ +#if !defined LWIP_HTTPD_SSI_BY_FILE_EXTENSION || defined __DOXYGEN__ +#define LWIP_HTTPD_SSI_BY_FILE_EXTENSION 1 +#endif + +/** Set this to 1 to support HTTP POST */ +#if !defined LWIP_HTTPD_SUPPORT_POST || defined __DOXYGEN__ +#define LWIP_HTTPD_SUPPORT_POST 0 +#endif + +/* The maximum number of parameters that the CGI handler can be sent. */ +#if !defined LWIP_HTTPD_MAX_CGI_PARAMETERS || defined __DOXYGEN__ +#define LWIP_HTTPD_MAX_CGI_PARAMETERS 16 +#endif + +/** LWIP_HTTPD_SSI_MULTIPART==1: SSI handler function is called with 2 more + * arguments indicating a counter for insert string that are too long to be + * inserted at once: the SSI handler function must then set 'next_tag_part' + * which will be passed back to it in the next call. */ +#if !defined LWIP_HTTPD_SSI_MULTIPART || defined __DOXYGEN__ +#define LWIP_HTTPD_SSI_MULTIPART 0 +#endif + +/* The maximum length of the string comprising the SSI tag name + * ATTENTION: tags longer than this are ignored, not truncated! + */ +#if !defined LWIP_HTTPD_MAX_TAG_NAME_LEN || defined __DOXYGEN__ +#define LWIP_HTTPD_MAX_TAG_NAME_LEN 8 +#endif + +/* The maximum length of string that can be returned to replace any given tag + * If this buffer is not long enough, use LWIP_HTTPD_SSI_MULTIPART. + */ +#if !defined LWIP_HTTPD_MAX_TAG_INSERT_LEN || defined __DOXYGEN__ +#define LWIP_HTTPD_MAX_TAG_INSERT_LEN 192 +#endif + +#if !defined LWIP_HTTPD_POST_MANUAL_WND || defined __DOXYGEN__ +#define LWIP_HTTPD_POST_MANUAL_WND 0 +#endif + +/** This string is passed in the HTTP header as "Server: " */ +#if !defined HTTPD_SERVER_AGENT || defined __DOXYGEN__ +#define HTTPD_SERVER_AGENT "lwIP/" LWIP_VERSION_STRING " (http://savannah.nongnu.org/projects/lwip)" +#endif + +/** Set this to 1 if you want to include code that creates HTTP headers + * at runtime. Default is off: HTTP headers are then created statically + * by the makefsdata tool. Static headers mean smaller code size, but + * the (readonly) fsdata will grow a bit as every file includes the HTTP + * header. */ +#if !defined LWIP_HTTPD_DYNAMIC_HEADERS || defined __DOXYGEN__ +#define LWIP_HTTPD_DYNAMIC_HEADERS 0 +#endif + +#if !defined HTTPD_DEBUG || defined __DOXYGEN__ +#define HTTPD_DEBUG LWIP_DBG_OFF +#endif + +/** Set this to 1 to use a memp pool for allocating + * struct http_state instead of the heap. + * If enabled, you'll need to define MEMP_NUM_PARALLEL_HTTPD_CONNS + * (and MEMP_NUM_PARALLEL_HTTPD_SSI_CONNS for SSI) to set the size of + * the pool(s). + */ +#if !defined HTTPD_USE_MEM_POOL || defined __DOXYGEN__ +#define HTTPD_USE_MEM_POOL 0 +#endif + +/** The server port for HTTPD to use */ +#if !defined HTTPD_SERVER_PORT || defined __DOXYGEN__ +#define HTTPD_SERVER_PORT LWIP_IANA_PORT_HTTP +#endif + +/** The https server port for HTTPD to use */ +#if !defined HTTPD_SERVER_PORT_HTTPS || defined __DOXYGEN__ +#define HTTPD_SERVER_PORT_HTTPS LWIP_IANA_PORT_HTTPS +#endif + +/** Enable https support? */ +#if !defined HTTPD_ENABLE_HTTPS || defined __DOXYGEN__ +#define HTTPD_ENABLE_HTTPS 0 +#endif + +/** Maximum retries before the connection is aborted/closed. + * - number of times pcb->poll is called -> default is 4*500ms = 2s; + * - reset when pcb->sent is called + */ +#if !defined HTTPD_MAX_RETRIES || defined __DOXYGEN__ +#define HTTPD_MAX_RETRIES 4 +#endif + +/** The poll delay is X*500ms */ +#if !defined HTTPD_POLL_INTERVAL || defined __DOXYGEN__ +#define HTTPD_POLL_INTERVAL 4 +#endif + +/** Priority for tcp pcbs created by HTTPD (very low by default). + * Lower priorities get killed first when running out of memory. + */ +#if !defined HTTPD_TCP_PRIO || defined __DOXYGEN__ +#define HTTPD_TCP_PRIO TCP_PRIO_MIN +#endif + +/** Set this to 1 to enable timing each file sent */ +#if !defined LWIP_HTTPD_TIMING || defined __DOXYGEN__ +#define LWIP_HTTPD_TIMING 0 +#endif +/** Set this to 1 to enable timing each file sent */ +#if !defined HTTPD_DEBUG_TIMING || defined __DOXYGEN__ +#define HTTPD_DEBUG_TIMING LWIP_DBG_OFF +#endif + +/** Set this to one to show error pages when parsing a request fails instead + of simply closing the connection. */ +#if !defined LWIP_HTTPD_SUPPORT_EXTSTATUS || defined __DOXYGEN__ +#define LWIP_HTTPD_SUPPORT_EXTSTATUS 0 +#endif + +/** Set this to 0 to drop support for HTTP/0.9 clients (to save some bytes) */ +#if !defined LWIP_HTTPD_SUPPORT_V09 || defined __DOXYGEN__ +#define LWIP_HTTPD_SUPPORT_V09 1 +#endif + +/** Set this to 1 to enable HTTP/1.1 persistent connections. + * ATTENTION: If the generated file system includes HTTP headers, these must + * include the "Connection: keep-alive" header (pass argument "-11" to makefsdata). + */ +#if !defined LWIP_HTTPD_SUPPORT_11_KEEPALIVE || defined __DOXYGEN__ +#define LWIP_HTTPD_SUPPORT_11_KEEPALIVE 0 +#endif + +/** Set this to 1 to support HTTP request coming in in multiple packets/pbufs */ +#if !defined LWIP_HTTPD_SUPPORT_REQUESTLIST || defined __DOXYGEN__ +#define LWIP_HTTPD_SUPPORT_REQUESTLIST 1 +#endif + +#if LWIP_HTTPD_SUPPORT_REQUESTLIST +/** Number of rx pbufs to enqueue to parse an incoming request (up to the first + newline) */ +#if !defined LWIP_HTTPD_REQ_QUEUELEN || defined __DOXYGEN__ +#define LWIP_HTTPD_REQ_QUEUELEN 5 +#endif + +/** Number of (TCP payload-) bytes (in pbufs) to enqueue to parse and incoming + request (up to the first double-newline) */ +#if !defined LWIP_HTTPD_REQ_BUFSIZE || defined __DOXYGEN__ +#define LWIP_HTTPD_REQ_BUFSIZE LWIP_HTTPD_MAX_REQ_LENGTH +#endif + +/** Defines the maximum length of a HTTP request line (up to the first CRLF, + copied from pbuf into this a global buffer when pbuf- or packet-queues + are received - otherwise the input pbuf is used directly) */ +#if !defined LWIP_HTTPD_MAX_REQ_LENGTH || defined __DOXYGEN__ +#define LWIP_HTTPD_MAX_REQ_LENGTH LWIP_MIN(1023, (LWIP_HTTPD_REQ_QUEUELEN * PBUF_POOL_BUFSIZE)) +#endif +#endif /* LWIP_HTTPD_SUPPORT_REQUESTLIST */ + +/** This is the size of a static buffer used when URIs end with '/'. + * In this buffer, the directory requested is concatenated with all the + * configured default file names. + * Set to 0 to disable checking default filenames on non-root directories. + */ +#if !defined LWIP_HTTPD_MAX_REQUEST_URI_LEN || defined __DOXYGEN__ +#define LWIP_HTTPD_MAX_REQUEST_URI_LEN 63 +#endif + +/** Maximum length of the filename to send as response to a POST request, + * filled in by the application when a POST is finished. + */ +#if !defined LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN || defined __DOXYGEN__ +#define LWIP_HTTPD_POST_MAX_RESPONSE_URI_LEN 63 +#endif + +/** Set this to 0 to not send the SSI tag (default is on, so the tag will + * be sent in the HTML page */ +#if !defined LWIP_HTTPD_SSI_INCLUDE_TAG || defined __DOXYGEN__ +#define LWIP_HTTPD_SSI_INCLUDE_TAG 1 +#endif + +/** Set this to 1 to call tcp_abort when tcp_close fails with memory error. + * This can be used to prevent consuming all memory in situations where the + * HTTP server has low priority compared to other communication. */ +#if !defined LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR || defined __DOXYGEN__ +#define LWIP_HTTPD_ABORT_ON_CLOSE_MEM_ERROR 0 +#endif + +/** Set this to 1 to kill the oldest connection when running out of + * memory for 'struct http_state' or 'struct http_ssi_state'. + * ATTENTION: This puts all connections on a linked list, so may be kind of slow. + */ +#if !defined LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED || defined __DOXYGEN__ +#define LWIP_HTTPD_KILL_OLD_ON_CONNECTIONS_EXCEEDED 0 +#endif + +/** Set this to 1 to send URIs without extension without headers + * (who uses this at all??) */ +#if !defined LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI || defined __DOXYGEN__ +#define LWIP_HTTPD_OMIT_HEADER_FOR_EXTENSIONLESS_URI 0 +#endif + +/** Default: Tags are sent from struct http_state and are therefore volatile */ +#if !defined HTTP_IS_TAG_VOLATILE || defined __DOXYGEN__ +#define HTTP_IS_TAG_VOLATILE(ptr) TCP_WRITE_FLAG_COPY +#endif + +/* By default, the httpd is limited to send 2*pcb->mss to keep resource usage low + when http is not an important protocol in the device. */ +#if !defined HTTPD_LIMIT_SENDING_TO_2MSS || defined __DOXYGEN__ +#define HTTPD_LIMIT_SENDING_TO_2MSS 1 +#endif + +/* Define this to a function that returns the maximum amount of data to enqueue. + The function have this signature: u16_t fn(struct altcp_pcb* pcb); + The best place to define this is the hooks file (@see LWIP_HOOK_FILENAME) */ +#if !defined HTTPD_MAX_WRITE_LEN || defined __DOXYGEN__ +#if HTTPD_LIMIT_SENDING_TO_2MSS +#define HTTPD_MAX_WRITE_LEN(pcb) ((u16_t)(2 * altcp_mss(pcb))) +#endif +#endif + +/*------------------- FS OPTIONS -------------------*/ + +/** Set this to 1 and provide the functions: + * - "int fs_open_custom(struct fs_file *file, const char *name)" + * Called first for every opened file to allow opening files + * that are not included in fsdata(_custom).c + * - "void fs_close_custom(struct fs_file *file)" + * Called to free resources allocated by fs_open_custom(). + */ +#if !defined LWIP_HTTPD_CUSTOM_FILES || defined __DOXYGEN__ +#define LWIP_HTTPD_CUSTOM_FILES 0 +#endif + +/** Set this to 1 to support fs_read() to dynamically read file data. + * Without this (default=off), only one-block files are supported, + * and the contents must be ready after fs_open(). + */ +#if !defined LWIP_HTTPD_DYNAMIC_FILE_READ || defined __DOXYGEN__ +#define LWIP_HTTPD_DYNAMIC_FILE_READ 0 +#endif + +/** Set this to 1 to include an application state argument per file + * that is opened. This allows to keep a state per connection/file. + */ +#if !defined LWIP_HTTPD_FILE_STATE || defined __DOXYGEN__ +#define LWIP_HTTPD_FILE_STATE 0 +#endif + +/** HTTPD_PRECALCULATED_CHECKSUM==1: include precompiled checksums for + * predefined (MSS-sized) chunks of the files to prevent having to calculate + * the checksums at runtime. */ +#if !defined HTTPD_PRECALCULATED_CHECKSUM || defined __DOXYGEN__ +#define HTTPD_PRECALCULATED_CHECKSUM 0 +#endif + +/** LWIP_HTTPD_FS_ASYNC_READ==1: support asynchronous read operations + * (fs_read_async returns FS_READ_DELAYED and calls a callback when finished). + */ +#if !defined LWIP_HTTPD_FS_ASYNC_READ || defined __DOXYGEN__ +#define LWIP_HTTPD_FS_ASYNC_READ 0 +#endif + +/** Filename (including path) to use as FS data file */ +#if !defined HTTPD_FSDATA_FILE || defined __DOXYGEN__ +/* HTTPD_USE_CUSTOM_FSDATA: Compatibility with deprecated lwIP option */ +#if defined(HTTPD_USE_CUSTOM_FSDATA) && (HTTPD_USE_CUSTOM_FSDATA != 0) +#define HTTPD_FSDATA_FILE "fsdata_custom.c" +#else +#define HTTPD_FSDATA_FILE "fsdata.c" +#endif +#endif + +/** + * @} + */ + +#endif /* LWIP_HDR_APPS_HTTPD_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/lwiperf.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/lwiperf.h index ff4d6f73..cc86e7f8 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/lwiperf.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/lwiperf.h @@ -1,100 +1,100 @@ -/** - * @file - * lwIP iPerf server implementation - */ - -/* - * Copyright (c) 2014 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_APPS_LWIPERF_H -#define LWIP_HDR_APPS_LWIPERF_H - -#include "lwip/opt.h" -#include "lwip/ip_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define LWIPERF_TCP_PORT_DEFAULT 5001 - -/** lwIPerf test results */ -enum lwiperf_report_type -{ - /** The server side test is done */ - LWIPERF_TCP_DONE_SERVER, - /** The client side test is done */ - LWIPERF_TCP_DONE_CLIENT, - /** Local error lead to test abort */ - LWIPERF_TCP_ABORTED_LOCAL, - /** Data check error lead to test abort */ - LWIPERF_TCP_ABORTED_LOCAL_DATAERROR, - /** Transmit error lead to test abort */ - LWIPERF_TCP_ABORTED_LOCAL_TXERROR, - /** Remote side aborted the test */ - LWIPERF_TCP_ABORTED_REMOTE -}; - -/** Control */ -enum lwiperf_client_type -{ - /** Unidirectional tx only test */ - LWIPERF_CLIENT, - /** Do a bidirectional test simultaneously */ - LWIPERF_DUAL, - /** Do a bidirectional test individually */ - LWIPERF_TRADEOFF -}; - -/** Prototype of a report function that is called when a session is finished. - This report function can show the test results. - @param report_type contains the test result */ -typedef void (*lwiperf_report_fn)(void *arg, enum lwiperf_report_type report_type, - const ip_addr_t* local_addr, u16_t local_port, const ip_addr_t* remote_addr, u16_t remote_port, - u32_t bytes_transferred, u32_t ms_duration, u32_t bandwidth_kbitpsec); - -void* lwiperf_start_tcp_server(const ip_addr_t* local_addr, u16_t local_port, - lwiperf_report_fn report_fn, void* report_arg); -void* lwiperf_start_tcp_server_default(lwiperf_report_fn report_fn, void* report_arg); -void* lwiperf_start_tcp_client(const ip_addr_t* remote_addr, u16_t remote_port, - enum lwiperf_client_type type, - lwiperf_report_fn report_fn, void* report_arg); -void* lwiperf_start_tcp_client_default(const ip_addr_t* remote_addr, - lwiperf_report_fn report_fn, void* report_arg); - -void lwiperf_abort(void* lwiperf_session); - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_LWIPERF_H */ +/** + * @file + * lwIP iPerf server implementation + */ + +/* + * Copyright (c) 2014 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_APPS_LWIPERF_H +#define LWIP_HDR_APPS_LWIPERF_H + +#include "lwip/opt.h" +#include "lwip/ip_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define LWIPERF_TCP_PORT_DEFAULT 5001 + +/** lwIPerf test results */ +enum lwiperf_report_type +{ + /** The server side test is done */ + LWIPERF_TCP_DONE_SERVER, + /** The client side test is done */ + LWIPERF_TCP_DONE_CLIENT, + /** Local error lead to test abort */ + LWIPERF_TCP_ABORTED_LOCAL, + /** Data check error lead to test abort */ + LWIPERF_TCP_ABORTED_LOCAL_DATAERROR, + /** Transmit error lead to test abort */ + LWIPERF_TCP_ABORTED_LOCAL_TXERROR, + /** Remote side aborted the test */ + LWIPERF_TCP_ABORTED_REMOTE +}; + +/** Control */ +enum lwiperf_client_type +{ + /** Unidirectional tx only test */ + LWIPERF_CLIENT, + /** Do a bidirectional test simultaneously */ + LWIPERF_DUAL, + /** Do a bidirectional test individually */ + LWIPERF_TRADEOFF +}; + +/** Prototype of a report function that is called when a session is finished. + This report function can show the test results. + @param report_type contains the test result */ +typedef void (*lwiperf_report_fn)(void *arg, enum lwiperf_report_type report_type, + const ip_addr_t* local_addr, u16_t local_port, const ip_addr_t* remote_addr, u16_t remote_port, + u32_t bytes_transferred, u32_t ms_duration, u32_t bandwidth_kbitpsec); + +void* lwiperf_start_tcp_server(const ip_addr_t* local_addr, u16_t local_port, + lwiperf_report_fn report_fn, void* report_arg); +void* lwiperf_start_tcp_server_default(lwiperf_report_fn report_fn, void* report_arg); +void* lwiperf_start_tcp_client(const ip_addr_t* remote_addr, u16_t remote_port, + enum lwiperf_client_type type, + lwiperf_report_fn report_fn, void* report_arg); +void* lwiperf_start_tcp_client_default(const ip_addr_t* remote_addr, + lwiperf_report_fn report_fn, void* report_arg); + +void lwiperf_abort(void* lwiperf_session); + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_LWIPERF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns.h index 3c3d054d..20d7ee2a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns.h @@ -1,105 +1,105 @@ -/** - * @file - * MDNS responder - */ - - /* - * Copyright (c) 2015 Verisure Innovation AB - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Erik Ekman - * - */ - -#ifndef LWIP_HDR_APPS_MDNS_H -#define LWIP_HDR_APPS_MDNS_H - -#include "lwip/apps/mdns_opts.h" -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_MDNS_RESPONDER - -enum mdns_sd_proto { - DNSSD_PROTO_UDP = 0, - DNSSD_PROTO_TCP = 1 -}; - -#define MDNS_PROBING_CONFLICT 0 -#define MDNS_PROBING_SUCCESSFUL 1 - -#define MDNS_LABEL_MAXLEN 63 - -struct mdns_host; -struct mdns_service; - -/** Callback function to add text to a reply, called when generating the reply */ -typedef void (*service_get_txt_fn_t)(struct mdns_service *service, void *txt_userdata); - -/** Callback function to let application know the result of probing network for name - * uniqueness, called with result MDNS_PROBING_SUCCESSFUL if no other node claimed - * use for the name for the netif or a service and is safe to use, or MDNS_PROBING_CONFLICT - * if another node is already using it and mdns is disabled on this interface */ -typedef void (*mdns_name_result_cb_t)(struct netif* netif, u8_t result); - -void mdns_resp_init(void); - -void mdns_resp_register_name_result_cb(mdns_name_result_cb_t cb); - -err_t mdns_resp_add_netif(struct netif *netif, const char *hostname, u32_t dns_ttl); -err_t mdns_resp_remove_netif(struct netif *netif); -err_t mdns_resp_rename_netif(struct netif *netif, const char *hostname); - -s8_t mdns_resp_add_service(struct netif *netif, const char *name, const char *service, enum mdns_sd_proto proto, u16_t port, u32_t dns_ttl, service_get_txt_fn_t txt_fn, void *txt_userdata); -err_t mdns_resp_del_service(struct netif *netif, s8_t slot); -err_t mdns_resp_rename_service(struct netif *netif, s8_t slot, const char *name); - -err_t mdns_resp_add_service_txtitem(struct mdns_service *service, const char *txt, u8_t txt_len); - -void mdns_resp_restart(struct netif *netif); -void mdns_resp_announce(struct netif *netif); - -/** - * @ingroup mdns - * Announce IP settings have changed on netif. - * Call this in your callback registered by netif_set_status_callback(). - * No need to call this function when LWIP_NETIF_EXT_STATUS_CALLBACK==1, - * this handled automatically for you. - * @param netif The network interface where settings have changed. - */ -#define mdns_resp_netif_settings_changed(netif) mdns_resp_announce(netif) - -#endif /* LWIP_MDNS_RESPONDER */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_MDNS_H */ +/** + * @file + * MDNS responder + */ + + /* + * Copyright (c) 2015 Verisure Innovation AB + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Erik Ekman + * + */ + +#ifndef LWIP_HDR_APPS_MDNS_H +#define LWIP_HDR_APPS_MDNS_H + +#include "lwip/apps/mdns_opts.h" +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_MDNS_RESPONDER + +enum mdns_sd_proto { + DNSSD_PROTO_UDP = 0, + DNSSD_PROTO_TCP = 1 +}; + +#define MDNS_PROBING_CONFLICT 0 +#define MDNS_PROBING_SUCCESSFUL 1 + +#define MDNS_LABEL_MAXLEN 63 + +struct mdns_host; +struct mdns_service; + +/** Callback function to add text to a reply, called when generating the reply */ +typedef void (*service_get_txt_fn_t)(struct mdns_service *service, void *txt_userdata); + +/** Callback function to let application know the result of probing network for name + * uniqueness, called with result MDNS_PROBING_SUCCESSFUL if no other node claimed + * use for the name for the netif or a service and is safe to use, or MDNS_PROBING_CONFLICT + * if another node is already using it and mdns is disabled on this interface */ +typedef void (*mdns_name_result_cb_t)(struct netif* netif, u8_t result); + +void mdns_resp_init(void); + +void mdns_resp_register_name_result_cb(mdns_name_result_cb_t cb); + +err_t mdns_resp_add_netif(struct netif *netif, const char *hostname, u32_t dns_ttl); +err_t mdns_resp_remove_netif(struct netif *netif); +err_t mdns_resp_rename_netif(struct netif *netif, const char *hostname); + +s8_t mdns_resp_add_service(struct netif *netif, const char *name, const char *service, enum mdns_sd_proto proto, u16_t port, u32_t dns_ttl, service_get_txt_fn_t txt_fn, void *txt_userdata); +err_t mdns_resp_del_service(struct netif *netif, s8_t slot); +err_t mdns_resp_rename_service(struct netif *netif, s8_t slot, const char *name); + +err_t mdns_resp_add_service_txtitem(struct mdns_service *service, const char *txt, u8_t txt_len); + +void mdns_resp_restart(struct netif *netif); +void mdns_resp_announce(struct netif *netif); + +/** + * @ingroup mdns + * Announce IP settings have changed on netif. + * Call this in your callback registered by netif_set_status_callback(). + * No need to call this function when LWIP_NETIF_EXT_STATUS_CALLBACK==1, + * this handled automatically for you. + * @param netif The network interface where settings have changed. + */ +#define mdns_resp_netif_settings_changed(netif) mdns_resp_announce(netif) + +#endif /* LWIP_MDNS_RESPONDER */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_MDNS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_opts.h index 74d3f41e..45f2c50c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_opts.h @@ -1,81 +1,81 @@ -/** - * @file - * MDNS responder - */ - - /* - * Copyright (c) 2015 Verisure Innovation AB - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Erik Ekman - * - */ - -#ifndef LWIP_HDR_APPS_MDNS_OPTS_H -#define LWIP_HDR_APPS_MDNS_OPTS_H - -#include "lwip/opt.h" - -/** - * @defgroup mdns_opts Options - * @ingroup mdns - * @{ - */ - -/** - * LWIP_MDNS_RESPONDER==1: Turn on multicast DNS module. UDP must be available for MDNS - * transport. IGMP is needed for IPv4 multicast. - */ -#ifndef LWIP_MDNS_RESPONDER -#define LWIP_MDNS_RESPONDER 0 -#endif /* LWIP_MDNS_RESPONDER */ - -/** The maximum number of services per netif */ -#ifndef MDNS_MAX_SERVICES -#define MDNS_MAX_SERVICES 1 -#endif - -/** MDNS_RESP_USENETIF_EXTCALLBACK==1: register an ext_callback on the netif - * to automatically restart probing/announcing on status or address change. - */ -#ifndef MDNS_RESP_USENETIF_EXTCALLBACK -#define MDNS_RESP_USENETIF_EXTCALLBACK LWIP_NETIF_EXT_STATUS_CALLBACK -#endif - -/** - * MDNS_DEBUG: Enable debugging for multicast DNS. - */ -#ifndef MDNS_DEBUG -#define MDNS_DEBUG LWIP_DBG_OFF -#endif - -/** - * @} - */ - -#endif /* LWIP_HDR_APPS_MDNS_OPTS_H */ - +/** + * @file + * MDNS responder + */ + + /* + * Copyright (c) 2015 Verisure Innovation AB + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Erik Ekman + * + */ + +#ifndef LWIP_HDR_APPS_MDNS_OPTS_H +#define LWIP_HDR_APPS_MDNS_OPTS_H + +#include "lwip/opt.h" + +/** + * @defgroup mdns_opts Options + * @ingroup mdns + * @{ + */ + +/** + * LWIP_MDNS_RESPONDER==1: Turn on multicast DNS module. UDP must be available for MDNS + * transport. IGMP is needed for IPv4 multicast. + */ +#ifndef LWIP_MDNS_RESPONDER +#define LWIP_MDNS_RESPONDER 0 +#endif /* LWIP_MDNS_RESPONDER */ + +/** The maximum number of services per netif */ +#ifndef MDNS_MAX_SERVICES +#define MDNS_MAX_SERVICES 1 +#endif + +/** MDNS_RESP_USENETIF_EXTCALLBACK==1: register an ext_callback on the netif + * to automatically restart probing/announcing on status or address change. + */ +#ifndef MDNS_RESP_USENETIF_EXTCALLBACK +#define MDNS_RESP_USENETIF_EXTCALLBACK LWIP_NETIF_EXT_STATUS_CALLBACK +#endif + +/** + * MDNS_DEBUG: Enable debugging for multicast DNS. + */ +#ifndef MDNS_DEBUG +#define MDNS_DEBUG LWIP_DBG_OFF +#endif + +/** + * @} + */ + +#endif /* LWIP_HDR_APPS_MDNS_OPTS_H */ + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_priv.h index 23941577..9635b5b1 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mdns_priv.h @@ -1,74 +1,74 @@ -/** - * @file - * MDNS responder private definitions - */ - - /* - * Copyright (c) 2015 Verisure Innovation AB - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Erik Ekman - * - */ -#ifndef LWIP_HDR_MDNS_PRIV_H -#define LWIP_HDR_MDNS_PRIV_H - -#include "lwip/apps/mdns_opts.h" -#include "lwip/pbuf.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_MDNS_RESPONDER - -/* Domain struct and methods - visible for unit tests */ - -#define MDNS_DOMAIN_MAXLEN 256 -#define MDNS_READNAME_ERROR 0xFFFF - -struct mdns_domain { - /* Encoded domain name */ - u8_t name[MDNS_DOMAIN_MAXLEN]; - /* Total length of domain name, including zero */ - u16_t length; - /* Set if compression of this domain is not allowed */ - u8_t skip_compression; -}; - -err_t mdns_domain_add_label(struct mdns_domain *domain, const char *label, u8_t len); -u16_t mdns_readname(struct pbuf *p, u16_t offset, struct mdns_domain *domain); -int mdns_domain_eq(struct mdns_domain *a, struct mdns_domain *b); -u16_t mdns_compress_domain(struct pbuf *pbuf, u16_t *offset, struct mdns_domain *domain); - -#endif /* LWIP_MDNS_RESPONDER */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_MDNS_PRIV_H */ +/** + * @file + * MDNS responder private definitions + */ + + /* + * Copyright (c) 2015 Verisure Innovation AB + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Erik Ekman + * + */ +#ifndef LWIP_HDR_MDNS_PRIV_H +#define LWIP_HDR_MDNS_PRIV_H + +#include "lwip/apps/mdns_opts.h" +#include "lwip/pbuf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_MDNS_RESPONDER + +/* Domain struct and methods - visible for unit tests */ + +#define MDNS_DOMAIN_MAXLEN 256 +#define MDNS_READNAME_ERROR 0xFFFF + +struct mdns_domain { + /* Encoded domain name */ + u8_t name[MDNS_DOMAIN_MAXLEN]; + /* Total length of domain name, including zero */ + u16_t length; + /* Set if compression of this domain is not allowed */ + u8_t skip_compression; +}; + +err_t mdns_domain_add_label(struct mdns_domain *domain, const char *label, u8_t len); +u16_t mdns_readname(struct pbuf *p, u16_t offset, struct mdns_domain *domain); +int mdns_domain_eq(struct mdns_domain *a, struct mdns_domain *b); +u16_t mdns_compress_domain(struct pbuf *pbuf, u16_t *offset, struct mdns_domain *domain); + +#endif /* LWIP_MDNS_RESPONDER */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_MDNS_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt.h index e796ae11..c2bb2288 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt.h @@ -1,205 +1,205 @@ -/** - * @file - * MQTT client - */ - -/* - * Copyright (c) 2016 Erik Andersson - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Erik Andersson - * - */ -#ifndef LWIP_HDR_APPS_MQTT_CLIENT_H -#define LWIP_HDR_APPS_MQTT_CLIENT_H - -#include "lwip/apps/mqtt_opts.h" -#include "lwip/err.h" -#include "lwip/ip_addr.h" -#include "lwip/prot/iana.h" - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct mqtt_client_s mqtt_client_t; - -#if LWIP_ALTCP && LWIP_ALTCP_TLS -struct altcp_tls_config; -#endif - -/** @ingroup mqtt - * Default MQTT port (non-TLS) */ -#define MQTT_PORT LWIP_IANA_PORT_MQTT -/** @ingroup mqtt - * Default MQTT TLS port */ -#define MQTT_TLS_PORT LWIP_IANA_PORT_SECURE_MQTT - -/*---------------------------------------------------------------------------------------------- */ -/* Connection with server */ - -/** - * @ingroup mqtt - * Client information and connection parameters */ -struct mqtt_connect_client_info_t { - /** Client identifier, must be set by caller */ - const char *client_id; - /** User name, set to NULL if not used */ - const char* client_user; - /** Password, set to NULL if not used */ - const char* client_pass; - /** keep alive time in seconds, 0 to disable keep alive functionality*/ - u16_t keep_alive; - /** will topic, set to NULL if will is not to be used, - will_msg, will_qos and will retain are then ignored */ - const char* will_topic; - /** will_msg, see will_topic */ - const char* will_msg; - /** will_qos, see will_topic */ - u8_t will_qos; - /** will_retain, see will_topic */ - u8_t will_retain; -#if LWIP_ALTCP && LWIP_ALTCP_TLS - /** TLS configuration for secure connections */ - struct altcp_tls_config *tls_config; -#endif -}; - -/** - * @ingroup mqtt - * Connection status codes */ -typedef enum -{ - /** Accepted */ - MQTT_CONNECT_ACCEPTED = 0, - /** Refused protocol version */ - MQTT_CONNECT_REFUSED_PROTOCOL_VERSION = 1, - /** Refused identifier */ - MQTT_CONNECT_REFUSED_IDENTIFIER = 2, - /** Refused server */ - MQTT_CONNECT_REFUSED_SERVER = 3, - /** Refused user credentials */ - MQTT_CONNECT_REFUSED_USERNAME_PASS = 4, - /** Refused not authorized */ - MQTT_CONNECT_REFUSED_NOT_AUTHORIZED_ = 5, - /** Disconnected */ - MQTT_CONNECT_DISCONNECTED = 256, - /** Timeout */ - MQTT_CONNECT_TIMEOUT = 257 -} mqtt_connection_status_t; - -/** - * @ingroup mqtt - * Function prototype for mqtt connection status callback. Called when - * client has connected to the server after initiating a mqtt connection attempt by - * calling mqtt_client_connect() or when connection is closed by server or an error - * - * @param client MQTT client itself - * @param arg Additional argument to pass to the callback function - * @param status Connect result code or disconnection notification @see mqtt_connection_status_t - * - */ -typedef void (*mqtt_connection_cb_t)(mqtt_client_t *client, void *arg, mqtt_connection_status_t status); - - -/** - * @ingroup mqtt - * Data callback flags */ -enum { - /** Flag set when last fragment of data arrives in data callback */ - MQTT_DATA_FLAG_LAST = 1 -}; - -/** - * @ingroup mqtt - * Function prototype for MQTT incoming publish data callback function. Called when data - * arrives to a subscribed topic @see mqtt_subscribe - * - * @param arg Additional argument to pass to the callback function - * @param data User data, pointed object, data may not be referenced after callback return, - NULL is passed when all publish data are delivered - * @param len Length of publish data fragment - * @param flags MQTT_DATA_FLAG_LAST set when this call contains the last part of data from publish message - * - */ -typedef void (*mqtt_incoming_data_cb_t)(void *arg, const u8_t *data, u16_t len, u8_t flags); - - -/** - * @ingroup mqtt - * Function prototype for MQTT incoming publish function. Called when an incoming publish - * arrives to a subscribed topic @see mqtt_subscribe - * - * @param arg Additional argument to pass to the callback function - * @param topic Zero terminated Topic text string, topic may not be referenced after callback return - * @param tot_len Total length of publish data, if set to 0 (no publish payload) data callback will not be invoked - */ -typedef void (*mqtt_incoming_publish_cb_t)(void *arg, const char *topic, u32_t tot_len); - - -/** - * @ingroup mqtt - * Function prototype for mqtt request callback. Called when a subscribe, unsubscribe - * or publish request has completed - * @param arg Pointer to user data supplied when invoking request - * @param err ERR_OK on success - * ERR_TIMEOUT if no response was received within timeout, - * ERR_ABRT if (un)subscribe was denied - */ -typedef void (*mqtt_request_cb_t)(void *arg, err_t err); - - -err_t mqtt_client_connect(mqtt_client_t *client, const ip_addr_t *ipaddr, u16_t port, mqtt_connection_cb_t cb, void *arg, - const struct mqtt_connect_client_info_t *client_info); - -void mqtt_disconnect(mqtt_client_t *client); - -mqtt_client_t *mqtt_client_new(void); -void mqtt_client_free(mqtt_client_t* client); - -u8_t mqtt_client_is_connected(mqtt_client_t *client); - -void mqtt_set_inpub_callback(mqtt_client_t *client, mqtt_incoming_publish_cb_t, - mqtt_incoming_data_cb_t data_cb, void *arg); - -err_t mqtt_sub_unsub(mqtt_client_t *client, const char *topic, u8_t qos, mqtt_request_cb_t cb, void *arg, u8_t sub); - -/** @ingroup mqtt - *Subscribe to topic */ -#define mqtt_subscribe(client, topic, qos, cb, arg) mqtt_sub_unsub(client, topic, qos, cb, arg, 1) -/** @ingroup mqtt - * Unsubscribe to topic */ -#define mqtt_unsubscribe(client, topic, cb, arg) mqtt_sub_unsub(client, topic, 0, cb, arg, 0) - -err_t mqtt_publish(mqtt_client_t *client, const char *topic, const void *payload, u16_t payload_length, u8_t qos, u8_t retain, - mqtt_request_cb_t cb, void *arg); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_MQTT_CLIENT_H */ +/** + * @file + * MQTT client + */ + +/* + * Copyright (c) 2016 Erik Andersson + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Erik Andersson + * + */ +#ifndef LWIP_HDR_APPS_MQTT_CLIENT_H +#define LWIP_HDR_APPS_MQTT_CLIENT_H + +#include "lwip/apps/mqtt_opts.h" +#include "lwip/err.h" +#include "lwip/ip_addr.h" +#include "lwip/prot/iana.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct mqtt_client_s mqtt_client_t; + +#if LWIP_ALTCP && LWIP_ALTCP_TLS +struct altcp_tls_config; +#endif + +/** @ingroup mqtt + * Default MQTT port (non-TLS) */ +#define MQTT_PORT LWIP_IANA_PORT_MQTT +/** @ingroup mqtt + * Default MQTT TLS port */ +#define MQTT_TLS_PORT LWIP_IANA_PORT_SECURE_MQTT + +/*---------------------------------------------------------------------------------------------- */ +/* Connection with server */ + +/** + * @ingroup mqtt + * Client information and connection parameters */ +struct mqtt_connect_client_info_t { + /** Client identifier, must be set by caller */ + const char *client_id; + /** User name, set to NULL if not used */ + const char* client_user; + /** Password, set to NULL if not used */ + const char* client_pass; + /** keep alive time in seconds, 0 to disable keep alive functionality*/ + u16_t keep_alive; + /** will topic, set to NULL if will is not to be used, + will_msg, will_qos and will retain are then ignored */ + const char* will_topic; + /** will_msg, see will_topic */ + const char* will_msg; + /** will_qos, see will_topic */ + u8_t will_qos; + /** will_retain, see will_topic */ + u8_t will_retain; +#if LWIP_ALTCP && LWIP_ALTCP_TLS + /** TLS configuration for secure connections */ + struct altcp_tls_config *tls_config; +#endif +}; + +/** + * @ingroup mqtt + * Connection status codes */ +typedef enum +{ + /** Accepted */ + MQTT_CONNECT_ACCEPTED = 0, + /** Refused protocol version */ + MQTT_CONNECT_REFUSED_PROTOCOL_VERSION = 1, + /** Refused identifier */ + MQTT_CONNECT_REFUSED_IDENTIFIER = 2, + /** Refused server */ + MQTT_CONNECT_REFUSED_SERVER = 3, + /** Refused user credentials */ + MQTT_CONNECT_REFUSED_USERNAME_PASS = 4, + /** Refused not authorized */ + MQTT_CONNECT_REFUSED_NOT_AUTHORIZED_ = 5, + /** Disconnected */ + MQTT_CONNECT_DISCONNECTED = 256, + /** Timeout */ + MQTT_CONNECT_TIMEOUT = 257 +} mqtt_connection_status_t; + +/** + * @ingroup mqtt + * Function prototype for mqtt connection status callback. Called when + * client has connected to the server after initiating a mqtt connection attempt by + * calling mqtt_client_connect() or when connection is closed by server or an error + * + * @param client MQTT client itself + * @param arg Additional argument to pass to the callback function + * @param status Connect result code or disconnection notification @see mqtt_connection_status_t + * + */ +typedef void (*mqtt_connection_cb_t)(mqtt_client_t *client, void *arg, mqtt_connection_status_t status); + + +/** + * @ingroup mqtt + * Data callback flags */ +enum { + /** Flag set when last fragment of data arrives in data callback */ + MQTT_DATA_FLAG_LAST = 1 +}; + +/** + * @ingroup mqtt + * Function prototype for MQTT incoming publish data callback function. Called when data + * arrives to a subscribed topic @see mqtt_subscribe + * + * @param arg Additional argument to pass to the callback function + * @param data User data, pointed object, data may not be referenced after callback return, + NULL is passed when all publish data are delivered + * @param len Length of publish data fragment + * @param flags MQTT_DATA_FLAG_LAST set when this call contains the last part of data from publish message + * + */ +typedef void (*mqtt_incoming_data_cb_t)(void *arg, const u8_t *data, u16_t len, u8_t flags); + + +/** + * @ingroup mqtt + * Function prototype for MQTT incoming publish function. Called when an incoming publish + * arrives to a subscribed topic @see mqtt_subscribe + * + * @param arg Additional argument to pass to the callback function + * @param topic Zero terminated Topic text string, topic may not be referenced after callback return + * @param tot_len Total length of publish data, if set to 0 (no publish payload) data callback will not be invoked + */ +typedef void (*mqtt_incoming_publish_cb_t)(void *arg, const char *topic, u32_t tot_len); + + +/** + * @ingroup mqtt + * Function prototype for mqtt request callback. Called when a subscribe, unsubscribe + * or publish request has completed + * @param arg Pointer to user data supplied when invoking request + * @param err ERR_OK on success + * ERR_TIMEOUT if no response was received within timeout, + * ERR_ABRT if (un)subscribe was denied + */ +typedef void (*mqtt_request_cb_t)(void *arg, err_t err); + + +err_t mqtt_client_connect(mqtt_client_t *client, const ip_addr_t *ipaddr, u16_t port, mqtt_connection_cb_t cb, void *arg, + const struct mqtt_connect_client_info_t *client_info); + +void mqtt_disconnect(mqtt_client_t *client); + +mqtt_client_t *mqtt_client_new(void); +void mqtt_client_free(mqtt_client_t* client); + +u8_t mqtt_client_is_connected(mqtt_client_t *client); + +void mqtt_set_inpub_callback(mqtt_client_t *client, mqtt_incoming_publish_cb_t, + mqtt_incoming_data_cb_t data_cb, void *arg); + +err_t mqtt_sub_unsub(mqtt_client_t *client, const char *topic, u8_t qos, mqtt_request_cb_t cb, void *arg, u8_t sub); + +/** @ingroup mqtt + *Subscribe to topic */ +#define mqtt_subscribe(client, topic, qos, cb, arg) mqtt_sub_unsub(client, topic, qos, cb, arg, 1) +/** @ingroup mqtt + * Unsubscribe to topic */ +#define mqtt_unsubscribe(client, topic, cb, arg) mqtt_sub_unsub(client, topic, 0, cb, arg, 0) + +err_t mqtt_publish(mqtt_client_t *client, const char *topic, const void *payload, u16_t payload_length, u8_t qos, u8_t retain, + mqtt_request_cb_t cb, void *arg); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_MQTT_CLIENT_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_opts.h index e0561301..4226d21e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_opts.h @@ -1,103 +1,103 @@ -/** - * @file - * MQTT client options - */ - -/* - * Copyright (c) 2016 Erik Andersson - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Erik Andersson - * - */ -#ifndef LWIP_HDR_APPS_MQTT_OPTS_H -#define LWIP_HDR_APPS_MQTT_OPTS_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @defgroup mqtt_opts Options - * @ingroup mqtt - * @{ - */ - -/** - * Output ring-buffer size, must be able to fit largest outgoing publish message topic+payloads - */ -#ifndef MQTT_OUTPUT_RINGBUF_SIZE -#define MQTT_OUTPUT_RINGBUF_SIZE 256 -#endif - -/** - * Number of bytes in receive buffer, must be at least the size of the longest incoming topic + 8 - * If one wants to avoid fragmented incoming publish, set length to max incoming topic length + max payload length + 8 - */ -#ifndef MQTT_VAR_HEADER_BUFFER_LEN -#define MQTT_VAR_HEADER_BUFFER_LEN 128 -#endif - -/** - * Maximum number of pending subscribe, unsubscribe and publish requests to server . - */ -#ifndef MQTT_REQ_MAX_IN_FLIGHT -#define MQTT_REQ_MAX_IN_FLIGHT 4 -#endif - -/** - * Seconds between each cyclic timer call. - */ -#ifndef MQTT_CYCLIC_TIMER_INTERVAL -#define MQTT_CYCLIC_TIMER_INTERVAL 5 -#endif - -/** - * Publish, subscribe and unsubscribe request timeout in seconds. - */ -#ifndef MQTT_REQ_TIMEOUT -#define MQTT_REQ_TIMEOUT 30 -#endif - -/** - * Seconds for MQTT connect response timeout after sending connect request - */ -#ifndef MQTT_CONNECT_TIMOUT -#define MQTT_CONNECT_TIMOUT 100 -#endif - -/** - * @} - */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_MQTT_OPTS_H */ +/** + * @file + * MQTT client options + */ + +/* + * Copyright (c) 2016 Erik Andersson + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Erik Andersson + * + */ +#ifndef LWIP_HDR_APPS_MQTT_OPTS_H +#define LWIP_HDR_APPS_MQTT_OPTS_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup mqtt_opts Options + * @ingroup mqtt + * @{ + */ + +/** + * Output ring-buffer size, must be able to fit largest outgoing publish message topic+payloads + */ +#ifndef MQTT_OUTPUT_RINGBUF_SIZE +#define MQTT_OUTPUT_RINGBUF_SIZE 256 +#endif + +/** + * Number of bytes in receive buffer, must be at least the size of the longest incoming topic + 8 + * If one wants to avoid fragmented incoming publish, set length to max incoming topic length + max payload length + 8 + */ +#ifndef MQTT_VAR_HEADER_BUFFER_LEN +#define MQTT_VAR_HEADER_BUFFER_LEN 128 +#endif + +/** + * Maximum number of pending subscribe, unsubscribe and publish requests to server . + */ +#ifndef MQTT_REQ_MAX_IN_FLIGHT +#define MQTT_REQ_MAX_IN_FLIGHT 4 +#endif + +/** + * Seconds between each cyclic timer call. + */ +#ifndef MQTT_CYCLIC_TIMER_INTERVAL +#define MQTT_CYCLIC_TIMER_INTERVAL 5 +#endif + +/** + * Publish, subscribe and unsubscribe request timeout in seconds. + */ +#ifndef MQTT_REQ_TIMEOUT +#define MQTT_REQ_TIMEOUT 30 +#endif + +/** + * Seconds for MQTT connect response timeout after sending connect request + */ +#ifndef MQTT_CONNECT_TIMOUT +#define MQTT_CONNECT_TIMOUT 100 +#endif + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_MQTT_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_priv.h index 04d2336b..b775913c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/mqtt_priv.h @@ -1,104 +1,104 @@ -/** - * @file - * MQTT client (private interface) - */ - -/* - * Copyright (c) 2016 Erik Andersson - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Erik Andersson - * - */ -#ifndef LWIP_HDR_APPS_MQTT_PRIV_H -#define LWIP_HDR_APPS_MQTT_PRIV_H - -#include "lwip/apps/mqtt.h" -#include "lwip/altcp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** Pending request item, binds application callback to pending server requests */ -struct mqtt_request_t -{ - /** Next item in list, NULL means this is the last in chain, - next pointing at itself means request is unallocated */ - struct mqtt_request_t *next; - /** Callback to upper layer */ - mqtt_request_cb_t cb; - void *arg; - /** MQTT packet identifier */ - u16_t pkt_id; - /** Expire time relative to element before this */ - u16_t timeout_diff; -}; - -/** Ring buffer */ -struct mqtt_ringbuf_t { - u16_t put; - u16_t get; - u8_t buf[MQTT_OUTPUT_RINGBUF_SIZE]; -}; - -/** MQTT client */ -struct mqtt_client_s -{ - /** Timers and timeouts */ - u16_t cyclic_tick; - u16_t keep_alive; - u16_t server_watchdog; - /** Packet identifier generator*/ - u16_t pkt_id_seq; - /** Packet identifier of pending incoming publish */ - u16_t inpub_pkt_id; - /** Connection state */ - u8_t conn_state; - struct altcp_pcb *conn; - /** Connection callback */ - void *connect_arg; - mqtt_connection_cb_t connect_cb; - /** Pending requests to server */ - struct mqtt_request_t *pend_req_queue; - struct mqtt_request_t req_list[MQTT_REQ_MAX_IN_FLIGHT]; - void *inpub_arg; - /** Incoming data callback */ - mqtt_incoming_data_cb_t data_cb; - mqtt_incoming_publish_cb_t pub_cb; - /** Input */ - u32_t msg_idx; - u8_t rx_buffer[MQTT_VAR_HEADER_BUFFER_LEN]; - /** Output ring-buffer */ - struct mqtt_ringbuf_t output; -}; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_MQTT_PRIV_H */ +/** + * @file + * MQTT client (private interface) + */ + +/* + * Copyright (c) 2016 Erik Andersson + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Erik Andersson + * + */ +#ifndef LWIP_HDR_APPS_MQTT_PRIV_H +#define LWIP_HDR_APPS_MQTT_PRIV_H + +#include "lwip/apps/mqtt.h" +#include "lwip/altcp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Pending request item, binds application callback to pending server requests */ +struct mqtt_request_t +{ + /** Next item in list, NULL means this is the last in chain, + next pointing at itself means request is unallocated */ + struct mqtt_request_t *next; + /** Callback to upper layer */ + mqtt_request_cb_t cb; + void *arg; + /** MQTT packet identifier */ + u16_t pkt_id; + /** Expire time relative to element before this */ + u16_t timeout_diff; +}; + +/** Ring buffer */ +struct mqtt_ringbuf_t { + u16_t put; + u16_t get; + u8_t buf[MQTT_OUTPUT_RINGBUF_SIZE]; +}; + +/** MQTT client */ +struct mqtt_client_s +{ + /** Timers and timeouts */ + u16_t cyclic_tick; + u16_t keep_alive; + u16_t server_watchdog; + /** Packet identifier generator*/ + u16_t pkt_id_seq; + /** Packet identifier of pending incoming publish */ + u16_t inpub_pkt_id; + /** Connection state */ + u8_t conn_state; + struct altcp_pcb *conn; + /** Connection callback */ + void *connect_arg; + mqtt_connection_cb_t connect_cb; + /** Pending requests to server */ + struct mqtt_request_t *pend_req_queue; + struct mqtt_request_t req_list[MQTT_REQ_MAX_IN_FLIGHT]; + void *inpub_arg; + /** Incoming data callback */ + mqtt_incoming_data_cb_t data_cb; + mqtt_incoming_publish_cb_t pub_cb; + /** Input */ + u32_t msg_idx; + u8_t rx_buffer[MQTT_VAR_HEADER_BUFFER_LEN]; + /** Output ring-buffer */ + struct mqtt_ringbuf_t output; +}; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_MQTT_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns.h index c5aedb6e..a326d33b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns.h @@ -1,51 +1,51 @@ -/** - * @file - * NETBIOS name service responder - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ -#ifndef LWIP_HDR_APPS_NETBIOS_H -#define LWIP_HDR_APPS_NETBIOS_H - -#include "lwip/apps/netbiosns_opts.h" - -#ifdef __cplusplus -extern "C" { -#endif - -void netbiosns_init(void); -#ifndef NETBIOS_LWIP_NAME -void netbiosns_set_name(const char* hostname); -#endif -void netbiosns_stop(void); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_NETBIOS_H */ +/** + * @file + * NETBIOS name service responder + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ +#ifndef LWIP_HDR_APPS_NETBIOS_H +#define LWIP_HDR_APPS_NETBIOS_H + +#include "lwip/apps/netbiosns_opts.h" + +#ifdef __cplusplus +extern "C" { +#endif + +void netbiosns_init(void); +#ifndef NETBIOS_LWIP_NAME +void netbiosns_set_name(const char* hostname); +#endif +void netbiosns_stop(void); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_NETBIOS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns_opts.h index 0bab59eb..1f51ab02 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/netbiosns_opts.h @@ -1,66 +1,66 @@ -/** - * @file - * NETBIOS name service responder options - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ -#ifndef LWIP_HDR_APPS_NETBIOS_OPTS_H -#define LWIP_HDR_APPS_NETBIOS_OPTS_H - -#include "lwip/opt.h" - -/** - * @defgroup netbiosns_opts Options - * @ingroup netbiosns - * @{ - */ - -/** NetBIOS name of lwip device - * This must be uppercase until NETBIOS_STRCMP() is defined to a string - * comparision function that is case insensitive. - * If you want to use the netif's hostname, use this (with LWIP_NETIF_HOSTNAME): - * (ip_current_netif() != NULL ? ip_current_netif()->hostname != NULL ? ip_current_netif()->hostname : "" : "") - * - * If this is not defined, netbiosns_set_name() can be called at runtime to change the name. - */ -#ifdef __DOXYGEN__ -#define NETBIOS_LWIP_NAME "NETBIOSLWIPDEV" -#endif - -/** Respond to NetBIOS name queries - * Default is disabled - */ -#if !defined LWIP_NETBIOS_RESPOND_NAME_QUERY || defined __DOXYGEN__ -#define LWIP_NETBIOS_RESPOND_NAME_QUERY 0 -#endif - -/** - * @} - */ - -#endif /* LWIP_HDR_APPS_NETBIOS_OPTS_H */ +/** + * @file + * NETBIOS name service responder options + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ +#ifndef LWIP_HDR_APPS_NETBIOS_OPTS_H +#define LWIP_HDR_APPS_NETBIOS_OPTS_H + +#include "lwip/opt.h" + +/** + * @defgroup netbiosns_opts Options + * @ingroup netbiosns + * @{ + */ + +/** NetBIOS name of lwip device + * This must be uppercase until NETBIOS_STRCMP() is defined to a string + * comparision function that is case insensitive. + * If you want to use the netif's hostname, use this (with LWIP_NETIF_HOSTNAME): + * (ip_current_netif() != NULL ? ip_current_netif()->hostname != NULL ? ip_current_netif()->hostname : "" : "") + * + * If this is not defined, netbiosns_set_name() can be called at runtime to change the name. + */ +#ifdef __DOXYGEN__ +#define NETBIOS_LWIP_NAME "NETBIOSLWIPDEV" +#endif + +/** Respond to NetBIOS name queries + * Default is disabled + */ +#if !defined LWIP_NETBIOS_RESPOND_NAME_QUERY || defined __DOXYGEN__ +#define LWIP_NETBIOS_RESPOND_NAME_QUERY 0 +#endif + +/** + * @} + */ + +#endif /* LWIP_HDR_APPS_NETBIOS_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp.h index e6076a10..fb4a4a7c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp.h @@ -1,128 +1,128 @@ -#ifndef LWIP_HDR_APPS_SMTP_H -#define LWIP_HDR_APPS_SMTP_H - -#ifdef __cplusplus -extern "C" { -#endif - -#include "lwip/apps/smtp_opts.h" -#include "lwip/err.h" -#include "lwip/prot/iana.h" - -/** The default TCP port used for SMTP */ -#define SMTP_DEFAULT_PORT LWIP_IANA_PORT_SMTP -/** The default TCP port used for SMTPS */ -#define SMTPS_DEFAULT_PORT LWIP_IANA_PORT_SMTPS - -/** Email successfully sent */ -#define SMTP_RESULT_OK 0 -/** Unknown error */ -#define SMTP_RESULT_ERR_UNKNOWN 1 -/** Connection to server failed */ -#define SMTP_RESULT_ERR_CONNECT 2 -/** Failed to resolve server hostname */ -#define SMTP_RESULT_ERR_HOSTNAME 3 -/** Connection unexpectedly closed by remote server */ -#define SMTP_RESULT_ERR_CLOSED 4 -/** Connection timed out (server didn't respond in time) */ -#define SMTP_RESULT_ERR_TIMEOUT 5 -/** Server responded with an unknown response code */ -#define SMTP_RESULT_ERR_SVR_RESP 6 -/** Out of resources locally */ -#define SMTP_RESULT_ERR_MEM 7 - -/** Prototype of an smtp callback function - * - * @param arg argument specified when initiating the email - * @param smtp_result result of the mail transfer (see defines SMTP_RESULT_*) - * @param srv_err if aborted by the server, this contains the error code received - * @param err an error returned by internal lwip functions, can help to specify - * the source of the error but must not necessarily be != ERR_OK - */ -typedef void (*smtp_result_fn)(void *arg, u8_t smtp_result, u16_t srv_err, err_t err); - -/** This structure is used as argument for smtp_send_mail_int(), - * which in turn can be used with tcpip_callback() to send mail - * from interrupt context, e.g. like this: - * struct smtp_send_request *req; (to be filled) - * tcpip_try_callback(smtp_send_mail_int, (void*)req); - * - * For member description, see parameter description of smtp_send_mail(). - * When using with tcpip_callback, this structure has to stay allocated - * (e.g. using mem_malloc/mem_free) until its 'callback_fn' is called. - */ -struct smtp_send_request { - const char *from; - const char* to; - const char* subject; - const char* body; - smtp_result_fn callback_fn; - void* callback_arg; - /** If this is != 0, data is *not* copied into an extra buffer - * but used from the pointers supplied in this struct. - * This means less memory usage, but data must stay untouched until - * the callback function is called. */ - u8_t static_data; -}; - - -#if SMTP_BODYDH - -#ifndef SMTP_BODYDH_BUFFER_SIZE -#define SMTP_BODYDH_BUFFER_SIZE 256 -#endif /* SMTP_BODYDH_BUFFER_SIZE */ - -struct smtp_bodydh { - u16_t state; - u16_t length; /* Length of content in buffer */ - char buffer[SMTP_BODYDH_BUFFER_SIZE]; /* buffer for generated content */ -#ifdef SMTP_BODYDH_USER_SIZE - u8_t user[SMTP_BODYDH_USER_SIZE]; -#endif /* SMTP_BODYDH_USER_SIZE */ -}; - -enum bdh_retvals_e { - BDH_DONE = 0, - BDH_WORKING -}; - -/** Prototype of an smtp body callback function - * It receives a struct smtp_bodydh, and a buffer to write data, - * must return BDH_WORKING to be called again and BDH_DONE when - * it has finished processing. This one tries to fill one TCP buffer with - * data, your function will be repeatedly called until that happens; so if you - * know you'll be taking too long to serve your request, pause once in a while - * by writing length=0 to avoid hogging system resources - * - * @param arg argument specified when initiating the email - * @param smtp_bodydh state handling + buffer structure - */ -typedef int (*smtp_bodycback_fn)(void *arg, struct smtp_bodydh *bodydh); - -err_t smtp_send_mail_bodycback(const char *from, const char* to, const char* subject, - smtp_bodycback_fn bodycback_fn, smtp_result_fn callback_fn, void* callback_arg); - -#endif /* SMTP_BODYDH */ - - -err_t smtp_set_server_addr(const char* server); -void smtp_set_server_port(u16_t port); -#if LWIP_ALTCP && LWIP_ALTCP_TLS -struct altcp_tls_config; -void smtp_set_tls_config(struct altcp_tls_config *tls_config); -#endif -err_t smtp_set_auth(const char* username, const char* pass); -err_t smtp_send_mail(const char *from, const char* to, const char* subject, const char* body, - smtp_result_fn callback_fn, void* callback_arg); -err_t smtp_send_mail_static(const char *from, const char* to, const char* subject, const char* body, - smtp_result_fn callback_fn, void* callback_arg); -void smtp_send_mail_int(void *arg); -#ifdef LWIP_DEBUG -const char* smtp_result_str(u8_t smtp_result); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SMTP_H */ +#ifndef LWIP_HDR_APPS_SMTP_H +#define LWIP_HDR_APPS_SMTP_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "lwip/apps/smtp_opts.h" +#include "lwip/err.h" +#include "lwip/prot/iana.h" + +/** The default TCP port used for SMTP */ +#define SMTP_DEFAULT_PORT LWIP_IANA_PORT_SMTP +/** The default TCP port used for SMTPS */ +#define SMTPS_DEFAULT_PORT LWIP_IANA_PORT_SMTPS + +/** Email successfully sent */ +#define SMTP_RESULT_OK 0 +/** Unknown error */ +#define SMTP_RESULT_ERR_UNKNOWN 1 +/** Connection to server failed */ +#define SMTP_RESULT_ERR_CONNECT 2 +/** Failed to resolve server hostname */ +#define SMTP_RESULT_ERR_HOSTNAME 3 +/** Connection unexpectedly closed by remote server */ +#define SMTP_RESULT_ERR_CLOSED 4 +/** Connection timed out (server didn't respond in time) */ +#define SMTP_RESULT_ERR_TIMEOUT 5 +/** Server responded with an unknown response code */ +#define SMTP_RESULT_ERR_SVR_RESP 6 +/** Out of resources locally */ +#define SMTP_RESULT_ERR_MEM 7 + +/** Prototype of an smtp callback function + * + * @param arg argument specified when initiating the email + * @param smtp_result result of the mail transfer (see defines SMTP_RESULT_*) + * @param srv_err if aborted by the server, this contains the error code received + * @param err an error returned by internal lwip functions, can help to specify + * the source of the error but must not necessarily be != ERR_OK + */ +typedef void (*smtp_result_fn)(void *arg, u8_t smtp_result, u16_t srv_err, err_t err); + +/** This structure is used as argument for smtp_send_mail_int(), + * which in turn can be used with tcpip_callback() to send mail + * from interrupt context, e.g. like this: + * struct smtp_send_request *req; (to be filled) + * tcpip_try_callback(smtp_send_mail_int, (void*)req); + * + * For member description, see parameter description of smtp_send_mail(). + * When using with tcpip_callback, this structure has to stay allocated + * (e.g. using mem_malloc/mem_free) until its 'callback_fn' is called. + */ +struct smtp_send_request { + const char *from; + const char* to; + const char* subject; + const char* body; + smtp_result_fn callback_fn; + void* callback_arg; + /** If this is != 0, data is *not* copied into an extra buffer + * but used from the pointers supplied in this struct. + * This means less memory usage, but data must stay untouched until + * the callback function is called. */ + u8_t static_data; +}; + + +#if SMTP_BODYDH + +#ifndef SMTP_BODYDH_BUFFER_SIZE +#define SMTP_BODYDH_BUFFER_SIZE 256 +#endif /* SMTP_BODYDH_BUFFER_SIZE */ + +struct smtp_bodydh { + u16_t state; + u16_t length; /* Length of content in buffer */ + char buffer[SMTP_BODYDH_BUFFER_SIZE]; /* buffer for generated content */ +#ifdef SMTP_BODYDH_USER_SIZE + u8_t user[SMTP_BODYDH_USER_SIZE]; +#endif /* SMTP_BODYDH_USER_SIZE */ +}; + +enum bdh_retvals_e { + BDH_DONE = 0, + BDH_WORKING +}; + +/** Prototype of an smtp body callback function + * It receives a struct smtp_bodydh, and a buffer to write data, + * must return BDH_WORKING to be called again and BDH_DONE when + * it has finished processing. This one tries to fill one TCP buffer with + * data, your function will be repeatedly called until that happens; so if you + * know you'll be taking too long to serve your request, pause once in a while + * by writing length=0 to avoid hogging system resources + * + * @param arg argument specified when initiating the email + * @param smtp_bodydh state handling + buffer structure + */ +typedef int (*smtp_bodycback_fn)(void *arg, struct smtp_bodydh *bodydh); + +err_t smtp_send_mail_bodycback(const char *from, const char* to, const char* subject, + smtp_bodycback_fn bodycback_fn, smtp_result_fn callback_fn, void* callback_arg); + +#endif /* SMTP_BODYDH */ + + +err_t smtp_set_server_addr(const char* server); +void smtp_set_server_port(u16_t port); +#if LWIP_ALTCP && LWIP_ALTCP_TLS +struct altcp_tls_config; +void smtp_set_tls_config(struct altcp_tls_config *tls_config); +#endif +err_t smtp_set_auth(const char* username, const char* pass); +err_t smtp_send_mail(const char *from, const char* to, const char* subject, const char* body, + smtp_result_fn callback_fn, void* callback_arg); +err_t smtp_send_mail_static(const char *from, const char* to, const char* subject, const char* body, + smtp_result_fn callback_fn, void* callback_arg); +void smtp_send_mail_int(void *arg); +#ifdef LWIP_DEBUG +const char* smtp_result_str(u8_t smtp_result); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SMTP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp_opts.h index 29c0c086..bc743f67 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/smtp_opts.h @@ -1,81 +1,81 @@ -#ifndef LWIP_HDR_APPS_SMTP_OPTS_H -#define LWIP_HDR_APPS_SMTP_OPTS_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @defgroup smtp_opts Options - * @ingroup smtp - * - * @{ - */ - -/** Set this to 1 to enable data handler callback on BODY */ -#ifndef SMTP_BODYDH -#define SMTP_BODYDH 0 -#endif - -/** SMTP_DEBUG: Enable debugging for SNTP. */ -#ifndef SMTP_DEBUG -#define SMTP_DEBUG LWIP_DBG_OFF -#endif - -/** Maximum length reserved for server name including terminating 0 byte */ -#ifndef SMTP_MAX_SERVERNAME_LEN -#define SMTP_MAX_SERVERNAME_LEN 256 -#endif - -/** Maximum length reserved for username */ -#ifndef SMTP_MAX_USERNAME_LEN -#define SMTP_MAX_USERNAME_LEN 32 -#endif - -/** Maximum length reserved for password */ -#ifndef SMTP_MAX_PASS_LEN -#define SMTP_MAX_PASS_LEN 32 -#endif - -/** Set this to 0 if you know the authentication data will not change - * during the smtp session, which saves some heap space. */ -#ifndef SMTP_COPY_AUTHDATA -#define SMTP_COPY_AUTHDATA 1 -#endif - -/** Set this to 0 to save some code space if you know for sure that all data - * passed to this module conforms to the requirements in the SMTP RFC. - * WARNING: use this with care! - */ -#ifndef SMTP_CHECK_DATA -#define SMTP_CHECK_DATA 1 -#endif - -/** Set this to 1 to enable AUTH PLAIN support */ -#ifndef SMTP_SUPPORT_AUTH_PLAIN -#define SMTP_SUPPORT_AUTH_PLAIN 1 -#endif - -/** Set this to 1 to enable AUTH LOGIN support */ -#ifndef SMTP_SUPPORT_AUTH_LOGIN -#define SMTP_SUPPORT_AUTH_LOGIN 1 -#endif - -/* Memory allocation/deallocation can be overridden... */ -#ifndef SMTP_STATE_MALLOC -#define SMTP_STATE_MALLOC(size) mem_malloc(size) -#define SMTP_STATE_FREE(ptr) mem_free(ptr) -#endif - -/** - * @} - */ - -#ifdef __cplusplus -} -#endif - -#endif /* SMTP_OPTS_H */ - +#ifndef LWIP_HDR_APPS_SMTP_OPTS_H +#define LWIP_HDR_APPS_SMTP_OPTS_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup smtp_opts Options + * @ingroup smtp + * + * @{ + */ + +/** Set this to 1 to enable data handler callback on BODY */ +#ifndef SMTP_BODYDH +#define SMTP_BODYDH 0 +#endif + +/** SMTP_DEBUG: Enable debugging for SNTP. */ +#ifndef SMTP_DEBUG +#define SMTP_DEBUG LWIP_DBG_OFF +#endif + +/** Maximum length reserved for server name including terminating 0 byte */ +#ifndef SMTP_MAX_SERVERNAME_LEN +#define SMTP_MAX_SERVERNAME_LEN 256 +#endif + +/** Maximum length reserved for username */ +#ifndef SMTP_MAX_USERNAME_LEN +#define SMTP_MAX_USERNAME_LEN 32 +#endif + +/** Maximum length reserved for password */ +#ifndef SMTP_MAX_PASS_LEN +#define SMTP_MAX_PASS_LEN 32 +#endif + +/** Set this to 0 if you know the authentication data will not change + * during the smtp session, which saves some heap space. */ +#ifndef SMTP_COPY_AUTHDATA +#define SMTP_COPY_AUTHDATA 1 +#endif + +/** Set this to 0 to save some code space if you know for sure that all data + * passed to this module conforms to the requirements in the SMTP RFC. + * WARNING: use this with care! + */ +#ifndef SMTP_CHECK_DATA +#define SMTP_CHECK_DATA 1 +#endif + +/** Set this to 1 to enable AUTH PLAIN support */ +#ifndef SMTP_SUPPORT_AUTH_PLAIN +#define SMTP_SUPPORT_AUTH_PLAIN 1 +#endif + +/** Set this to 1 to enable AUTH LOGIN support */ +#ifndef SMTP_SUPPORT_AUTH_LOGIN +#define SMTP_SUPPORT_AUTH_LOGIN 1 +#endif + +/* Memory allocation/deallocation can be overridden... */ +#ifndef SMTP_STATE_MALLOC +#define SMTP_STATE_MALLOC(size) mem_malloc(size) +#define SMTP_STATE_FREE(ptr) mem_free(ptr) +#endif + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* SMTP_OPTS_H */ + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp.h index 15b154ea..a3f8eb15 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp.h @@ -1,135 +1,135 @@ -/** - * @file - * SNMP server main API - start and basic configuration - */ - -/* - * Copyright (c) 2001, 2002 Leon Woestenberg - * Copyright (c) 2001, 2002 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Leon Woestenberg - * Martin Hentschel - * - */ -#ifndef LWIP_HDR_APPS_SNMP_H -#define LWIP_HDR_APPS_SNMP_H - -#include "lwip/apps/snmp_opts.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/err.h" -#include "lwip/apps/snmp_core.h" - -/** SNMP variable binding descriptor (publically needed for traps) */ -struct snmp_varbind -{ - /** pointer to next varbind, NULL for last in list */ - struct snmp_varbind *next; - /** pointer to previous varbind, NULL for first in list */ - struct snmp_varbind *prev; - - /** object identifier */ - struct snmp_obj_id oid; - - /** value ASN1 type */ - u8_t type; - /** object value length */ - u16_t value_len; - /** object value */ - void *value; -}; - -/** - * @ingroup snmp_core - * Agent setup, start listening to port 161. - */ -void snmp_init(void); -void snmp_set_mibs(const struct snmp_mib **mibs, u8_t num_mibs); - -void snmp_set_device_enterprise_oid(const struct snmp_obj_id* device_enterprise_oid); -const struct snmp_obj_id* snmp_get_device_enterprise_oid(void); - -void snmp_trap_dst_enable(u8_t dst_idx, u8_t enable); -void snmp_trap_dst_ip_set(u8_t dst_idx, const ip_addr_t *dst); - -/** Generic trap: cold start */ -#define SNMP_GENTRAP_COLDSTART 0 -/** Generic trap: warm start */ -#define SNMP_GENTRAP_WARMSTART 1 -/** Generic trap: link down */ -#define SNMP_GENTRAP_LINKDOWN 2 -/** Generic trap: link up */ -#define SNMP_GENTRAP_LINKUP 3 -/** Generic trap: authentication failure */ -#define SNMP_GENTRAP_AUTH_FAILURE 4 -/** Generic trap: EGP neighbor lost */ -#define SNMP_GENTRAP_EGP_NEIGHBOR_LOSS 5 -/** Generic trap: enterprise specific */ -#define SNMP_GENTRAP_ENTERPRISE_SPECIFIC 6 - -err_t snmp_send_trap_generic(s32_t generic_trap); -err_t snmp_send_trap_specific(s32_t specific_trap, struct snmp_varbind *varbinds); -err_t snmp_send_trap(const struct snmp_obj_id* oid, s32_t generic_trap, s32_t specific_trap, struct snmp_varbind *varbinds); - -#define SNMP_AUTH_TRAPS_DISABLED 0 -#define SNMP_AUTH_TRAPS_ENABLED 1 -void snmp_set_auth_traps_enabled(u8_t enable); -u8_t snmp_get_auth_traps_enabled(void); - -u8_t snmp_v1_enabled(void); -u8_t snmp_v2c_enabled(void); -u8_t snmp_v3_enabled(void); -void snmp_v1_enable(u8_t enable); -void snmp_v2c_enable(u8_t enable); -void snmp_v3_enable(u8_t enable); - -const char * snmp_get_community(void); -const char * snmp_get_community_write(void); -const char * snmp_get_community_trap(void); -void snmp_set_community(const char * const community); -void snmp_set_community_write(const char * const community); -void snmp_set_community_trap(const char * const community); - -void snmp_coldstart_trap(void); -void snmp_authfail_trap(void); - -typedef void (*snmp_write_callback_fct)(const u32_t* oid, u8_t oid_len, void* callback_arg); -void snmp_set_write_callback(snmp_write_callback_fct write_callback, void* callback_arg); - -#endif /* LWIP_SNMP */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SNMP_H */ +/** + * @file + * SNMP server main API - start and basic configuration + */ + +/* + * Copyright (c) 2001, 2002 Leon Woestenberg + * Copyright (c) 2001, 2002 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Leon Woestenberg + * Martin Hentschel + * + */ +#ifndef LWIP_HDR_APPS_SNMP_H +#define LWIP_HDR_APPS_SNMP_H + +#include "lwip/apps/snmp_opts.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/err.h" +#include "lwip/apps/snmp_core.h" + +/** SNMP variable binding descriptor (publically needed for traps) */ +struct snmp_varbind +{ + /** pointer to next varbind, NULL for last in list */ + struct snmp_varbind *next; + /** pointer to previous varbind, NULL for first in list */ + struct snmp_varbind *prev; + + /** object identifier */ + struct snmp_obj_id oid; + + /** value ASN1 type */ + u8_t type; + /** object value length */ + u16_t value_len; + /** object value */ + void *value; +}; + +/** + * @ingroup snmp_core + * Agent setup, start listening to port 161. + */ +void snmp_init(void); +void snmp_set_mibs(const struct snmp_mib **mibs, u8_t num_mibs); + +void snmp_set_device_enterprise_oid(const struct snmp_obj_id* device_enterprise_oid); +const struct snmp_obj_id* snmp_get_device_enterprise_oid(void); + +void snmp_trap_dst_enable(u8_t dst_idx, u8_t enable); +void snmp_trap_dst_ip_set(u8_t dst_idx, const ip_addr_t *dst); + +/** Generic trap: cold start */ +#define SNMP_GENTRAP_COLDSTART 0 +/** Generic trap: warm start */ +#define SNMP_GENTRAP_WARMSTART 1 +/** Generic trap: link down */ +#define SNMP_GENTRAP_LINKDOWN 2 +/** Generic trap: link up */ +#define SNMP_GENTRAP_LINKUP 3 +/** Generic trap: authentication failure */ +#define SNMP_GENTRAP_AUTH_FAILURE 4 +/** Generic trap: EGP neighbor lost */ +#define SNMP_GENTRAP_EGP_NEIGHBOR_LOSS 5 +/** Generic trap: enterprise specific */ +#define SNMP_GENTRAP_ENTERPRISE_SPECIFIC 6 + +err_t snmp_send_trap_generic(s32_t generic_trap); +err_t snmp_send_trap_specific(s32_t specific_trap, struct snmp_varbind *varbinds); +err_t snmp_send_trap(const struct snmp_obj_id* oid, s32_t generic_trap, s32_t specific_trap, struct snmp_varbind *varbinds); + +#define SNMP_AUTH_TRAPS_DISABLED 0 +#define SNMP_AUTH_TRAPS_ENABLED 1 +void snmp_set_auth_traps_enabled(u8_t enable); +u8_t snmp_get_auth_traps_enabled(void); + +u8_t snmp_v1_enabled(void); +u8_t snmp_v2c_enabled(void); +u8_t snmp_v3_enabled(void); +void snmp_v1_enable(u8_t enable); +void snmp_v2c_enable(u8_t enable); +void snmp_v3_enable(u8_t enable); + +const char * snmp_get_community(void); +const char * snmp_get_community_write(void); +const char * snmp_get_community_trap(void); +void snmp_set_community(const char * const community); +void snmp_set_community_write(const char * const community); +void snmp_set_community_trap(const char * const community); + +void snmp_coldstart_trap(void); +void snmp_authfail_trap(void); + +typedef void (*snmp_write_callback_fct)(const u32_t* oid, u8_t oid_len, void* callback_arg); +void snmp_set_write_callback(snmp_write_callback_fct write_callback, void* callback_arg); + +#endif /* LWIP_SNMP */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SNMP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_core.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_core.h index 4748df69..6021c722 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_core.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_core.h @@ -1,377 +1,377 @@ -/** - * @file - * SNMP core API for implementing MIBs - */ - -/* - * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Christiaan Simons - * Martin Hentschel - */ - -#ifndef LWIP_HDR_APPS_SNMP_CORE_H -#define LWIP_HDR_APPS_SNMP_CORE_H - -#include "lwip/apps/snmp_opts.h" - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/ip_addr.h" -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* basic ASN1 defines */ -#define SNMP_ASN1_CLASS_UNIVERSAL 0x00 -#define SNMP_ASN1_CLASS_APPLICATION 0x40 -#define SNMP_ASN1_CLASS_CONTEXT 0x80 -#define SNMP_ASN1_CLASS_PRIVATE 0xC0 - -#define SNMP_ASN1_CONTENTTYPE_PRIMITIVE 0x00 -#define SNMP_ASN1_CONTENTTYPE_CONSTRUCTED 0x20 - -/* universal tags (from ASN.1 spec.) */ -#define SNMP_ASN1_UNIVERSAL_END_OF_CONTENT 0 -#define SNMP_ASN1_UNIVERSAL_INTEGER 2 -#define SNMP_ASN1_UNIVERSAL_OCTET_STRING 4 -#define SNMP_ASN1_UNIVERSAL_NULL 5 -#define SNMP_ASN1_UNIVERSAL_OBJECT_ID 6 -#define SNMP_ASN1_UNIVERSAL_SEQUENCE_OF 16 - -/* application specific (SNMP) tags (from SNMPv2-SMI) */ -#define SNMP_ASN1_APPLICATION_IPADDR 0 /* [APPLICATION 0] IMPLICIT OCTET STRING (SIZE (4)) */ -#define SNMP_ASN1_APPLICATION_COUNTER 1 /* [APPLICATION 1] IMPLICIT INTEGER (0..4294967295) => u32_t */ -#define SNMP_ASN1_APPLICATION_GAUGE 2 /* [APPLICATION 2] IMPLICIT INTEGER (0..4294967295) => u32_t */ -#define SNMP_ASN1_APPLICATION_TIMETICKS 3 /* [APPLICATION 3] IMPLICIT INTEGER (0..4294967295) => u32_t */ -#define SNMP_ASN1_APPLICATION_OPAQUE 4 /* [APPLICATION 4] IMPLICIT OCTET STRING */ -#define SNMP_ASN1_APPLICATION_COUNTER64 6 /* [APPLICATION 6] IMPLICIT INTEGER (0..18446744073709551615) */ - -/* context specific (SNMP) tags (from RFC 1905) */ -#define SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_INSTANCE 1 - -/* full ASN1 type defines */ -#define SNMP_ASN1_TYPE_END_OF_CONTENT (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_END_OF_CONTENT) -#define SNMP_ASN1_TYPE_INTEGER (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_INTEGER) -#define SNMP_ASN1_TYPE_OCTET_STRING (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_OCTET_STRING) -#define SNMP_ASN1_TYPE_NULL (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_NULL) -#define SNMP_ASN1_TYPE_OBJECT_ID (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_OBJECT_ID) -#define SNMP_ASN1_TYPE_SEQUENCE (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_UNIVERSAL_SEQUENCE_OF) -#define SNMP_ASN1_TYPE_IPADDR (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_IPADDR) -#define SNMP_ASN1_TYPE_IPADDRESS SNMP_ASN1_TYPE_IPADDR -#define SNMP_ASN1_TYPE_COUNTER (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_COUNTER) -#define SNMP_ASN1_TYPE_COUNTER32 SNMP_ASN1_TYPE_COUNTER -#define SNMP_ASN1_TYPE_GAUGE (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_GAUGE) -#define SNMP_ASN1_TYPE_GAUGE32 SNMP_ASN1_TYPE_GAUGE -#define SNMP_ASN1_TYPE_UNSIGNED32 SNMP_ASN1_TYPE_GAUGE -#define SNMP_ASN1_TYPE_TIMETICKS (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_TIMETICKS) -#define SNMP_ASN1_TYPE_OPAQUE (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_OPAQUE) -#if LWIP_HAVE_INT64 -#define SNMP_ASN1_TYPE_COUNTER64 (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_COUNTER64) -#endif - -#define SNMP_VARBIND_EXCEPTION_OFFSET 0xF0 -#define SNMP_VARBIND_EXCEPTION_MASK 0x0F - -/** error codes predefined by SNMP prot. */ -typedef enum { - SNMP_ERR_NOERROR = 0, -/* -outdated v1 error codes. do not use anmore! -#define SNMP_ERR_NOSUCHNAME 2 use SNMP_ERR_NOSUCHINSTANCE instead -#define SNMP_ERR_BADVALUE 3 use SNMP_ERR_WRONGTYPE,SNMP_ERR_WRONGLENGTH,SNMP_ERR_WRONGENCODING or SNMP_ERR_WRONGVALUE instead -#define SNMP_ERR_READONLY 4 use SNMP_ERR_NOTWRITABLE instead -*/ - SNMP_ERR_GENERROR = 5, - SNMP_ERR_NOACCESS = 6, - SNMP_ERR_WRONGTYPE = 7, - SNMP_ERR_WRONGLENGTH = 8, - SNMP_ERR_WRONGENCODING = 9, - SNMP_ERR_WRONGVALUE = 10, - SNMP_ERR_NOCREATION = 11, - SNMP_ERR_INCONSISTENTVALUE = 12, - SNMP_ERR_RESOURCEUNAVAILABLE = 13, - SNMP_ERR_COMMITFAILED = 14, - SNMP_ERR_UNDOFAILED = 15, - SNMP_ERR_NOTWRITABLE = 17, - SNMP_ERR_INCONSISTENTNAME = 18, - - SNMP_ERR_NOSUCHINSTANCE = SNMP_VARBIND_EXCEPTION_OFFSET + SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_INSTANCE -} snmp_err_t; - -/** internal object identifier representation */ -struct snmp_obj_id -{ - u8_t len; - u32_t id[SNMP_MAX_OBJ_ID_LEN]; -}; - -struct snmp_obj_id_const_ref -{ - u8_t len; - const u32_t* id; -}; - -extern const struct snmp_obj_id_const_ref snmp_zero_dot_zero; /* administrative identifier from SNMPv2-SMI */ - -/** SNMP variant value, used as reference in struct snmp_node_instance and table implementation */ -union snmp_variant_value -{ - void* ptr; - const void* const_ptr; - u32_t u32; - s32_t s32; -#if LWIP_HAVE_INT64 - u64_t u64; -#endif -}; - - -/** -SNMP MIB node types - tree node is the only node the stack can process in order to walk the tree, - all other nodes are assumed to be leaf nodes. - This cannot be an enum because users may want to define their own node types. -*/ -#define SNMP_NODE_TREE 0x00 -/* predefined leaf node types */ -#define SNMP_NODE_SCALAR 0x01 -#define SNMP_NODE_SCALAR_ARRAY 0x02 -#define SNMP_NODE_TABLE 0x03 -#define SNMP_NODE_THREADSYNC 0x04 - -/** node "base class" layout, the mandatory fields for a node */ -struct snmp_node -{ - /** one out of SNMP_NODE_TREE or any leaf node type (like SNMP_NODE_SCALAR) */ - u8_t node_type; - /** the number assigned to this node which used as part of the full OID */ - u32_t oid; -}; - -/** SNMP node instance access types */ -typedef enum { - SNMP_NODE_INSTANCE_ACCESS_READ = 1, - SNMP_NODE_INSTANCE_ACCESS_WRITE = 2, - SNMP_NODE_INSTANCE_READ_ONLY = SNMP_NODE_INSTANCE_ACCESS_READ, - SNMP_NODE_INSTANCE_READ_WRITE = (SNMP_NODE_INSTANCE_ACCESS_READ | SNMP_NODE_INSTANCE_ACCESS_WRITE), - SNMP_NODE_INSTANCE_WRITE_ONLY = SNMP_NODE_INSTANCE_ACCESS_WRITE, - SNMP_NODE_INSTANCE_NOT_ACCESSIBLE = 0 -} snmp_access_t; - -struct snmp_node_instance; - -typedef s16_t (*node_instance_get_value_method)(struct snmp_node_instance*, void*); -typedef snmp_err_t (*node_instance_set_test_method)(struct snmp_node_instance*, u16_t, void*); -typedef snmp_err_t (*node_instance_set_value_method)(struct snmp_node_instance*, u16_t, void*); -typedef void (*node_instance_release_method)(struct snmp_node_instance*); - -#define SNMP_GET_VALUE_RAW_DATA 0x4000 /* do not use 0x8000 because return value of node_instance_get_value_method is signed16 and 0x8000 would be the signed bit */ - -/** SNMP node instance */ -struct snmp_node_instance -{ - /** prefilled with the node, get_instance() is called on; may be changed by user to any value to pass an arbitrary node between calls to get_instance() and get_value/test_value/set_value */ - const struct snmp_node* node; - /** prefilled with the instance id requested; for get_instance() this is the exact oid requested; for get_next_instance() this is the relative starting point, stack expects relative oid of next node here */ - struct snmp_obj_id instance_oid; - - /** ASN type for this object (see snmp_asn1.h for definitions) */ - u8_t asn1_type; - /** one out of instance access types defined above (SNMP_NODE_INSTANCE_READ_ONLY,...) */ - snmp_access_t access; - - /** returns object value for the given object identifier. Return values <0 to indicate an error */ - node_instance_get_value_method get_value; - /** tests length and/or range BEFORE setting */ - node_instance_set_test_method set_test; - /** sets object value, only called when set_test() was successful */ - node_instance_set_value_method set_value; - /** called in any case when the instance is not required anymore by stack (useful for freeing memory allocated in get_instance/get_next_instance methods) */ - node_instance_release_method release_instance; - - /** reference to pass arbitrary value between calls to get_instance() and get_value/test_value/set_value */ - union snmp_variant_value reference; - /** see reference (if reference is a pointer, the length of underlying data may be stored here or anything else) */ - u32_t reference_len; -}; - - -/** SNMP tree node */ -struct snmp_tree_node -{ - /** inherited "base class" members */ - struct snmp_node node; - u16_t subnode_count; - const struct snmp_node* const *subnodes; -}; - -#define SNMP_CREATE_TREE_NODE(oid, subnodes) \ - {{ SNMP_NODE_TREE, (oid) }, \ - (u16_t)LWIP_ARRAYSIZE(subnodes), (subnodes) } - -#define SNMP_CREATE_EMPTY_TREE_NODE(oid) \ - {{ SNMP_NODE_TREE, (oid) }, \ - 0, NULL } - -/** SNMP leaf node */ -struct snmp_leaf_node -{ - /** inherited "base class" members */ - struct snmp_node node; - snmp_err_t (*get_instance)(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); - snmp_err_t (*get_next_instance)(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); -}; - -/** represents a single mib with its base oid and root node */ -struct snmp_mib -{ - const u32_t *base_oid; - u8_t base_oid_len; - const struct snmp_node *root_node; -}; - -#define SNMP_MIB_CREATE(oid_list, root_node) { (oid_list), (u8_t)LWIP_ARRAYSIZE(oid_list), root_node } - -/** OID range structure */ -struct snmp_oid_range -{ - u32_t min; - u32_t max; -}; - -/** checks if incoming OID length and values are in allowed ranges */ -u8_t snmp_oid_in_range(const u32_t *oid_in, u8_t oid_len, const struct snmp_oid_range *oid_ranges, u8_t oid_ranges_len); - -typedef enum { - SNMP_NEXT_OID_STATUS_SUCCESS, - SNMP_NEXT_OID_STATUS_NO_MATCH, - SNMP_NEXT_OID_STATUS_BUF_TO_SMALL -} snmp_next_oid_status_t; - -/** state for next_oid_init / next_oid_check functions */ -struct snmp_next_oid_state -{ - const u32_t* start_oid; - u8_t start_oid_len; - - u32_t* next_oid; - u8_t next_oid_len; - u8_t next_oid_max_len; - - snmp_next_oid_status_t status; - void* reference; -}; - -void snmp_next_oid_init(struct snmp_next_oid_state *state, - const u32_t *start_oid, u8_t start_oid_len, - u32_t *next_oid_buf, u8_t next_oid_max_len); -u8_t snmp_next_oid_precheck(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len); -u8_t snmp_next_oid_check(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len, void* reference); - -void snmp_oid_assign(struct snmp_obj_id* target, const u32_t *oid, u8_t oid_len); -void snmp_oid_combine(struct snmp_obj_id* target, const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len); -void snmp_oid_prefix(struct snmp_obj_id* target, const u32_t *oid, u8_t oid_len); -void snmp_oid_append(struct snmp_obj_id* target, const u32_t *oid, u8_t oid_len); -u8_t snmp_oid_equal(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len); -s8_t snmp_oid_compare(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len); - -#if LWIP_IPV4 -u8_t snmp_oid_to_ip4(const u32_t *oid, ip4_addr_t *ip); -void snmp_ip4_to_oid(const ip4_addr_t *ip, u32_t *oid); -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 -u8_t snmp_oid_to_ip6(const u32_t *oid, ip6_addr_t *ip); -void snmp_ip6_to_oid(const ip6_addr_t *ip, u32_t *oid); -#endif /* LWIP_IPV6 */ -#if LWIP_IPV4 || LWIP_IPV6 -u8_t snmp_ip_to_oid(const ip_addr_t *ip, u32_t *oid); -u8_t snmp_ip_port_to_oid(const ip_addr_t *ip, u16_t port, u32_t *oid); - -u8_t snmp_oid_to_ip(const u32_t *oid, u8_t oid_len, ip_addr_t *ip); -u8_t snmp_oid_to_ip_port(const u32_t *oid, u8_t oid_len, ip_addr_t *ip, u16_t *port); -#endif /* LWIP_IPV4 || LWIP_IPV6 */ - -struct netif; -u8_t netif_to_num(const struct netif *netif); - -snmp_err_t snmp_set_test_ok(struct snmp_node_instance* instance, u16_t value_len, void* value); /* generic function which can be used if test is always successful */ - -err_t snmp_decode_bits(const u8_t *buf, u32_t buf_len, u32_t *bit_value); -err_t snmp_decode_truthvalue(const s32_t *asn1_value, u8_t *bool_value); -u8_t snmp_encode_bits(u8_t *buf, u32_t buf_len, u32_t bit_value, u8_t bit_count); -u8_t snmp_encode_truthvalue(s32_t *asn1_value, u32_t bool_value); - -struct snmp_statistics -{ - u32_t inpkts; - u32_t outpkts; - u32_t inbadversions; - u32_t inbadcommunitynames; - u32_t inbadcommunityuses; - u32_t inasnparseerrs; - u32_t intoobigs; - u32_t innosuchnames; - u32_t inbadvalues; - u32_t inreadonlys; - u32_t ingenerrs; - u32_t intotalreqvars; - u32_t intotalsetvars; - u32_t ingetrequests; - u32_t ingetnexts; - u32_t insetrequests; - u32_t ingetresponses; - u32_t intraps; - u32_t outtoobigs; - u32_t outnosuchnames; - u32_t outbadvalues; - u32_t outgenerrs; - u32_t outgetrequests; - u32_t outgetnexts; - u32_t outsetrequests; - u32_t outgetresponses; - u32_t outtraps; -#if LWIP_SNMP_V3 - u32_t unsupportedseclevels; - u32_t notintimewindows; - u32_t unknownusernames; - u32_t unknownengineids; - u32_t wrongdigests; - u32_t decryptionerrors; -#endif -}; - -extern struct snmp_statistics snmp_stats; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_SNMP */ - -#endif /* LWIP_HDR_APPS_SNMP_CORE_H */ +/** + * @file + * SNMP core API for implementing MIBs + */ + +/* + * Copyright (c) 2006 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Christiaan Simons + * Martin Hentschel + */ + +#ifndef LWIP_HDR_APPS_SNMP_CORE_H +#define LWIP_HDR_APPS_SNMP_CORE_H + +#include "lwip/apps/snmp_opts.h" + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/ip_addr.h" +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* basic ASN1 defines */ +#define SNMP_ASN1_CLASS_UNIVERSAL 0x00 +#define SNMP_ASN1_CLASS_APPLICATION 0x40 +#define SNMP_ASN1_CLASS_CONTEXT 0x80 +#define SNMP_ASN1_CLASS_PRIVATE 0xC0 + +#define SNMP_ASN1_CONTENTTYPE_PRIMITIVE 0x00 +#define SNMP_ASN1_CONTENTTYPE_CONSTRUCTED 0x20 + +/* universal tags (from ASN.1 spec.) */ +#define SNMP_ASN1_UNIVERSAL_END_OF_CONTENT 0 +#define SNMP_ASN1_UNIVERSAL_INTEGER 2 +#define SNMP_ASN1_UNIVERSAL_OCTET_STRING 4 +#define SNMP_ASN1_UNIVERSAL_NULL 5 +#define SNMP_ASN1_UNIVERSAL_OBJECT_ID 6 +#define SNMP_ASN1_UNIVERSAL_SEQUENCE_OF 16 + +/* application specific (SNMP) tags (from SNMPv2-SMI) */ +#define SNMP_ASN1_APPLICATION_IPADDR 0 /* [APPLICATION 0] IMPLICIT OCTET STRING (SIZE (4)) */ +#define SNMP_ASN1_APPLICATION_COUNTER 1 /* [APPLICATION 1] IMPLICIT INTEGER (0..4294967295) => u32_t */ +#define SNMP_ASN1_APPLICATION_GAUGE 2 /* [APPLICATION 2] IMPLICIT INTEGER (0..4294967295) => u32_t */ +#define SNMP_ASN1_APPLICATION_TIMETICKS 3 /* [APPLICATION 3] IMPLICIT INTEGER (0..4294967295) => u32_t */ +#define SNMP_ASN1_APPLICATION_OPAQUE 4 /* [APPLICATION 4] IMPLICIT OCTET STRING */ +#define SNMP_ASN1_APPLICATION_COUNTER64 6 /* [APPLICATION 6] IMPLICIT INTEGER (0..18446744073709551615) */ + +/* context specific (SNMP) tags (from RFC 1905) */ +#define SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_INSTANCE 1 + +/* full ASN1 type defines */ +#define SNMP_ASN1_TYPE_END_OF_CONTENT (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_END_OF_CONTENT) +#define SNMP_ASN1_TYPE_INTEGER (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_INTEGER) +#define SNMP_ASN1_TYPE_OCTET_STRING (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_OCTET_STRING) +#define SNMP_ASN1_TYPE_NULL (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_NULL) +#define SNMP_ASN1_TYPE_OBJECT_ID (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_UNIVERSAL_OBJECT_ID) +#define SNMP_ASN1_TYPE_SEQUENCE (SNMP_ASN1_CLASS_UNIVERSAL | SNMP_ASN1_CONTENTTYPE_CONSTRUCTED | SNMP_ASN1_UNIVERSAL_SEQUENCE_OF) +#define SNMP_ASN1_TYPE_IPADDR (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_IPADDR) +#define SNMP_ASN1_TYPE_IPADDRESS SNMP_ASN1_TYPE_IPADDR +#define SNMP_ASN1_TYPE_COUNTER (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_COUNTER) +#define SNMP_ASN1_TYPE_COUNTER32 SNMP_ASN1_TYPE_COUNTER +#define SNMP_ASN1_TYPE_GAUGE (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_GAUGE) +#define SNMP_ASN1_TYPE_GAUGE32 SNMP_ASN1_TYPE_GAUGE +#define SNMP_ASN1_TYPE_UNSIGNED32 SNMP_ASN1_TYPE_GAUGE +#define SNMP_ASN1_TYPE_TIMETICKS (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_TIMETICKS) +#define SNMP_ASN1_TYPE_OPAQUE (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_OPAQUE) +#if LWIP_HAVE_INT64 +#define SNMP_ASN1_TYPE_COUNTER64 (SNMP_ASN1_CLASS_APPLICATION | SNMP_ASN1_CONTENTTYPE_PRIMITIVE | SNMP_ASN1_APPLICATION_COUNTER64) +#endif + +#define SNMP_VARBIND_EXCEPTION_OFFSET 0xF0 +#define SNMP_VARBIND_EXCEPTION_MASK 0x0F + +/** error codes predefined by SNMP prot. */ +typedef enum { + SNMP_ERR_NOERROR = 0, +/* +outdated v1 error codes. do not use anmore! +#define SNMP_ERR_NOSUCHNAME 2 use SNMP_ERR_NOSUCHINSTANCE instead +#define SNMP_ERR_BADVALUE 3 use SNMP_ERR_WRONGTYPE,SNMP_ERR_WRONGLENGTH,SNMP_ERR_WRONGENCODING or SNMP_ERR_WRONGVALUE instead +#define SNMP_ERR_READONLY 4 use SNMP_ERR_NOTWRITABLE instead +*/ + SNMP_ERR_GENERROR = 5, + SNMP_ERR_NOACCESS = 6, + SNMP_ERR_WRONGTYPE = 7, + SNMP_ERR_WRONGLENGTH = 8, + SNMP_ERR_WRONGENCODING = 9, + SNMP_ERR_WRONGVALUE = 10, + SNMP_ERR_NOCREATION = 11, + SNMP_ERR_INCONSISTENTVALUE = 12, + SNMP_ERR_RESOURCEUNAVAILABLE = 13, + SNMP_ERR_COMMITFAILED = 14, + SNMP_ERR_UNDOFAILED = 15, + SNMP_ERR_NOTWRITABLE = 17, + SNMP_ERR_INCONSISTENTNAME = 18, + + SNMP_ERR_NOSUCHINSTANCE = SNMP_VARBIND_EXCEPTION_OFFSET + SNMP_ASN1_CONTEXT_VARBIND_NO_SUCH_INSTANCE +} snmp_err_t; + +/** internal object identifier representation */ +struct snmp_obj_id +{ + u8_t len; + u32_t id[SNMP_MAX_OBJ_ID_LEN]; +}; + +struct snmp_obj_id_const_ref +{ + u8_t len; + const u32_t* id; +}; + +extern const struct snmp_obj_id_const_ref snmp_zero_dot_zero; /* administrative identifier from SNMPv2-SMI */ + +/** SNMP variant value, used as reference in struct snmp_node_instance and table implementation */ +union snmp_variant_value +{ + void* ptr; + const void* const_ptr; + u32_t u32; + s32_t s32; +#if LWIP_HAVE_INT64 + u64_t u64; +#endif +}; + + +/** +SNMP MIB node types + tree node is the only node the stack can process in order to walk the tree, + all other nodes are assumed to be leaf nodes. + This cannot be an enum because users may want to define their own node types. +*/ +#define SNMP_NODE_TREE 0x00 +/* predefined leaf node types */ +#define SNMP_NODE_SCALAR 0x01 +#define SNMP_NODE_SCALAR_ARRAY 0x02 +#define SNMP_NODE_TABLE 0x03 +#define SNMP_NODE_THREADSYNC 0x04 + +/** node "base class" layout, the mandatory fields for a node */ +struct snmp_node +{ + /** one out of SNMP_NODE_TREE or any leaf node type (like SNMP_NODE_SCALAR) */ + u8_t node_type; + /** the number assigned to this node which used as part of the full OID */ + u32_t oid; +}; + +/** SNMP node instance access types */ +typedef enum { + SNMP_NODE_INSTANCE_ACCESS_READ = 1, + SNMP_NODE_INSTANCE_ACCESS_WRITE = 2, + SNMP_NODE_INSTANCE_READ_ONLY = SNMP_NODE_INSTANCE_ACCESS_READ, + SNMP_NODE_INSTANCE_READ_WRITE = (SNMP_NODE_INSTANCE_ACCESS_READ | SNMP_NODE_INSTANCE_ACCESS_WRITE), + SNMP_NODE_INSTANCE_WRITE_ONLY = SNMP_NODE_INSTANCE_ACCESS_WRITE, + SNMP_NODE_INSTANCE_NOT_ACCESSIBLE = 0 +} snmp_access_t; + +struct snmp_node_instance; + +typedef s16_t (*node_instance_get_value_method)(struct snmp_node_instance*, void*); +typedef snmp_err_t (*node_instance_set_test_method)(struct snmp_node_instance*, u16_t, void*); +typedef snmp_err_t (*node_instance_set_value_method)(struct snmp_node_instance*, u16_t, void*); +typedef void (*node_instance_release_method)(struct snmp_node_instance*); + +#define SNMP_GET_VALUE_RAW_DATA 0x4000 /* do not use 0x8000 because return value of node_instance_get_value_method is signed16 and 0x8000 would be the signed bit */ + +/** SNMP node instance */ +struct snmp_node_instance +{ + /** prefilled with the node, get_instance() is called on; may be changed by user to any value to pass an arbitrary node between calls to get_instance() and get_value/test_value/set_value */ + const struct snmp_node* node; + /** prefilled with the instance id requested; for get_instance() this is the exact oid requested; for get_next_instance() this is the relative starting point, stack expects relative oid of next node here */ + struct snmp_obj_id instance_oid; + + /** ASN type for this object (see snmp_asn1.h for definitions) */ + u8_t asn1_type; + /** one out of instance access types defined above (SNMP_NODE_INSTANCE_READ_ONLY,...) */ + snmp_access_t access; + + /** returns object value for the given object identifier. Return values <0 to indicate an error */ + node_instance_get_value_method get_value; + /** tests length and/or range BEFORE setting */ + node_instance_set_test_method set_test; + /** sets object value, only called when set_test() was successful */ + node_instance_set_value_method set_value; + /** called in any case when the instance is not required anymore by stack (useful for freeing memory allocated in get_instance/get_next_instance methods) */ + node_instance_release_method release_instance; + + /** reference to pass arbitrary value between calls to get_instance() and get_value/test_value/set_value */ + union snmp_variant_value reference; + /** see reference (if reference is a pointer, the length of underlying data may be stored here or anything else) */ + u32_t reference_len; +}; + + +/** SNMP tree node */ +struct snmp_tree_node +{ + /** inherited "base class" members */ + struct snmp_node node; + u16_t subnode_count; + const struct snmp_node* const *subnodes; +}; + +#define SNMP_CREATE_TREE_NODE(oid, subnodes) \ + {{ SNMP_NODE_TREE, (oid) }, \ + (u16_t)LWIP_ARRAYSIZE(subnodes), (subnodes) } + +#define SNMP_CREATE_EMPTY_TREE_NODE(oid) \ + {{ SNMP_NODE_TREE, (oid) }, \ + 0, NULL } + +/** SNMP leaf node */ +struct snmp_leaf_node +{ + /** inherited "base class" members */ + struct snmp_node node; + snmp_err_t (*get_instance)(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); + snmp_err_t (*get_next_instance)(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); +}; + +/** represents a single mib with its base oid and root node */ +struct snmp_mib +{ + const u32_t *base_oid; + u8_t base_oid_len; + const struct snmp_node *root_node; +}; + +#define SNMP_MIB_CREATE(oid_list, root_node) { (oid_list), (u8_t)LWIP_ARRAYSIZE(oid_list), root_node } + +/** OID range structure */ +struct snmp_oid_range +{ + u32_t min; + u32_t max; +}; + +/** checks if incoming OID length and values are in allowed ranges */ +u8_t snmp_oid_in_range(const u32_t *oid_in, u8_t oid_len, const struct snmp_oid_range *oid_ranges, u8_t oid_ranges_len); + +typedef enum { + SNMP_NEXT_OID_STATUS_SUCCESS, + SNMP_NEXT_OID_STATUS_NO_MATCH, + SNMP_NEXT_OID_STATUS_BUF_TO_SMALL +} snmp_next_oid_status_t; + +/** state for next_oid_init / next_oid_check functions */ +struct snmp_next_oid_state +{ + const u32_t* start_oid; + u8_t start_oid_len; + + u32_t* next_oid; + u8_t next_oid_len; + u8_t next_oid_max_len; + + snmp_next_oid_status_t status; + void* reference; +}; + +void snmp_next_oid_init(struct snmp_next_oid_state *state, + const u32_t *start_oid, u8_t start_oid_len, + u32_t *next_oid_buf, u8_t next_oid_max_len); +u8_t snmp_next_oid_precheck(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len); +u8_t snmp_next_oid_check(struct snmp_next_oid_state *state, const u32_t *oid, u8_t oid_len, void* reference); + +void snmp_oid_assign(struct snmp_obj_id* target, const u32_t *oid, u8_t oid_len); +void snmp_oid_combine(struct snmp_obj_id* target, const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len); +void snmp_oid_prefix(struct snmp_obj_id* target, const u32_t *oid, u8_t oid_len); +void snmp_oid_append(struct snmp_obj_id* target, const u32_t *oid, u8_t oid_len); +u8_t snmp_oid_equal(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len); +s8_t snmp_oid_compare(const u32_t *oid1, u8_t oid1_len, const u32_t *oid2, u8_t oid2_len); + +#if LWIP_IPV4 +u8_t snmp_oid_to_ip4(const u32_t *oid, ip4_addr_t *ip); +void snmp_ip4_to_oid(const ip4_addr_t *ip, u32_t *oid); +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 +u8_t snmp_oid_to_ip6(const u32_t *oid, ip6_addr_t *ip); +void snmp_ip6_to_oid(const ip6_addr_t *ip, u32_t *oid); +#endif /* LWIP_IPV6 */ +#if LWIP_IPV4 || LWIP_IPV6 +u8_t snmp_ip_to_oid(const ip_addr_t *ip, u32_t *oid); +u8_t snmp_ip_port_to_oid(const ip_addr_t *ip, u16_t port, u32_t *oid); + +u8_t snmp_oid_to_ip(const u32_t *oid, u8_t oid_len, ip_addr_t *ip); +u8_t snmp_oid_to_ip_port(const u32_t *oid, u8_t oid_len, ip_addr_t *ip, u16_t *port); +#endif /* LWIP_IPV4 || LWIP_IPV6 */ + +struct netif; +u8_t netif_to_num(const struct netif *netif); + +snmp_err_t snmp_set_test_ok(struct snmp_node_instance* instance, u16_t value_len, void* value); /* generic function which can be used if test is always successful */ + +err_t snmp_decode_bits(const u8_t *buf, u32_t buf_len, u32_t *bit_value); +err_t snmp_decode_truthvalue(const s32_t *asn1_value, u8_t *bool_value); +u8_t snmp_encode_bits(u8_t *buf, u32_t buf_len, u32_t bit_value, u8_t bit_count); +u8_t snmp_encode_truthvalue(s32_t *asn1_value, u32_t bool_value); + +struct snmp_statistics +{ + u32_t inpkts; + u32_t outpkts; + u32_t inbadversions; + u32_t inbadcommunitynames; + u32_t inbadcommunityuses; + u32_t inasnparseerrs; + u32_t intoobigs; + u32_t innosuchnames; + u32_t inbadvalues; + u32_t inreadonlys; + u32_t ingenerrs; + u32_t intotalreqvars; + u32_t intotalsetvars; + u32_t ingetrequests; + u32_t ingetnexts; + u32_t insetrequests; + u32_t ingetresponses; + u32_t intraps; + u32_t outtoobigs; + u32_t outnosuchnames; + u32_t outbadvalues; + u32_t outgenerrs; + u32_t outgetrequests; + u32_t outgetnexts; + u32_t outsetrequests; + u32_t outgetresponses; + u32_t outtraps; +#if LWIP_SNMP_V3 + u32_t unsupportedseclevels; + u32_t notintimewindows; + u32_t unknownusernames; + u32_t unknownengineids; + u32_t wrongdigests; + u32_t decryptionerrors; +#endif +}; + +extern struct snmp_statistics snmp_stats; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_SNMP */ + +#endif /* LWIP_HDR_APPS_SNMP_CORE_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_mib2.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_mib2.h index 392ee257..2f4a6893 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_mib2.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_mib2.h @@ -1,78 +1,78 @@ -/** - * @file - * SNMP MIB2 API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Dirk Ziegelmeier - * - */ -#ifndef LWIP_HDR_APPS_SNMP_MIB2_H -#define LWIP_HDR_APPS_SNMP_MIB2_H - -#include "lwip/apps/snmp_opts.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ -#if SNMP_LWIP_MIB2 - -#include "lwip/apps/snmp_core.h" - -extern const struct snmp_mib mib2; - -#if SNMP_USE_NETCONN -#include "lwip/apps/snmp_threadsync.h" -void snmp_mib2_lwip_synchronizer(snmp_threadsync_called_fn fn, void* arg); -extern struct snmp_threadsync_instance snmp_mib2_lwip_locks; -#endif - -#ifndef SNMP_SYSSERVICES -#define SNMP_SYSSERVICES ((1 << 6) | (1 << 3) | ((IP_FORWARD) << 2)) -#endif - -void snmp_mib2_set_sysdescr(const u8_t* str, const u16_t* len); /* read-only be defintion */ -void snmp_mib2_set_syscontact(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize); -void snmp_mib2_set_syscontact_readonly(const u8_t *ocstr, const u16_t *ocstrlen); -void snmp_mib2_set_sysname(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize); -void snmp_mib2_set_sysname_readonly(const u8_t *ocstr, const u16_t *ocstrlen); -void snmp_mib2_set_syslocation(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize); -void snmp_mib2_set_syslocation_readonly(const u8_t *ocstr, const u16_t *ocstrlen); - -#endif /* SNMP_LWIP_MIB2 */ -#endif /* LWIP_SNMP */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SNMP_MIB2_H */ +/** + * @file + * SNMP MIB2 API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Dirk Ziegelmeier + * + */ +#ifndef LWIP_HDR_APPS_SNMP_MIB2_H +#define LWIP_HDR_APPS_SNMP_MIB2_H + +#include "lwip/apps/snmp_opts.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ +#if SNMP_LWIP_MIB2 + +#include "lwip/apps/snmp_core.h" + +extern const struct snmp_mib mib2; + +#if SNMP_USE_NETCONN +#include "lwip/apps/snmp_threadsync.h" +void snmp_mib2_lwip_synchronizer(snmp_threadsync_called_fn fn, void* arg); +extern struct snmp_threadsync_instance snmp_mib2_lwip_locks; +#endif + +#ifndef SNMP_SYSSERVICES +#define SNMP_SYSSERVICES ((1 << 6) | (1 << 3) | ((IP_FORWARD) << 2)) +#endif + +void snmp_mib2_set_sysdescr(const u8_t* str, const u16_t* len); /* read-only be defintion */ +void snmp_mib2_set_syscontact(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize); +void snmp_mib2_set_syscontact_readonly(const u8_t *ocstr, const u16_t *ocstrlen); +void snmp_mib2_set_sysname(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize); +void snmp_mib2_set_sysname_readonly(const u8_t *ocstr, const u16_t *ocstrlen); +void snmp_mib2_set_syslocation(u8_t *ocstr, u16_t *ocstrlen, u16_t bufsize); +void snmp_mib2_set_syslocation_readonly(const u8_t *ocstr, const u16_t *ocstrlen); + +#endif /* SNMP_LWIP_MIB2 */ +#endif /* LWIP_SNMP */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SNMP_MIB2_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_opts.h index 1c635048..c892d22a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_opts.h @@ -1,297 +1,297 @@ -/** - * @file - * SNMP server options list - */ - -/* - * Copyright (c) 2015 Dirk Ziegelmeier - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Dirk Ziegelmeier - * - */ -#ifndef LWIP_HDR_SNMP_OPTS_H -#define LWIP_HDR_SNMP_OPTS_H - -#include "lwip/opt.h" - -/** - * @defgroup snmp_opts Options - * @ingroup snmp - * @{ - */ - -/** - * LWIP_SNMP==1: This enables the lwIP SNMP agent. UDP must be available - * for SNMP transport. - * If you want to use your own SNMP agent, leave this disabled. - * To integrate MIB2 of an external agent, you need to enable - * LWIP_MIB2_CALLBACKS and MIB2_STATS. This will give you the callbacks - * and statistics counters you need to get MIB2 working. - */ -#if !defined LWIP_SNMP || defined __DOXYGEN__ -#define LWIP_SNMP 0 -#endif - -/** - * SNMP_USE_NETCONN: Use netconn API instead of raw API. - * Makes SNMP agent run in a worker thread, so blocking operations - * can be done in MIB calls. - */ -#if !defined SNMP_USE_NETCONN || defined __DOXYGEN__ -#define SNMP_USE_NETCONN 0 -#endif - -/** - * SNMP_USE_RAW: Use raw API. - * SNMP agent does not run in a worker thread, so blocking operations - * should not be done in MIB calls. - */ -#if !defined SNMP_USE_RAW || defined __DOXYGEN__ -#define SNMP_USE_RAW 1 -#endif - -#if SNMP_USE_NETCONN && SNMP_USE_RAW -#error SNMP stack can use only one of the APIs {raw, netconn} -#endif - -#if LWIP_SNMP && !SNMP_USE_NETCONN && !SNMP_USE_RAW -#error SNMP stack needs a receive API and UDP {raw, netconn} -#endif - -#if SNMP_USE_NETCONN -/** - * SNMP_STACK_SIZE: Stack size of SNMP netconn worker thread - */ -#if !defined SNMP_STACK_SIZE || defined __DOXYGEN__ -#define SNMP_STACK_SIZE DEFAULT_THREAD_STACKSIZE -#endif - -/** - * SNMP_THREAD_PRIO: SNMP netconn worker thread priority - */ -#if !defined SNMP_THREAD_PRIO || defined __DOXYGEN__ -#define SNMP_THREAD_PRIO DEFAULT_THREAD_PRIO -#endif -#endif /* SNMP_USE_NETCONN */ - -/** - * SNMP_TRAP_DESTINATIONS: Number of trap destinations. At least one trap - * destination is required - */ -#if !defined SNMP_TRAP_DESTINATIONS || defined __DOXYGEN__ -#define SNMP_TRAP_DESTINATIONS 1 -#endif - -/** - * Only allow SNMP write actions that are 'safe' (e.g. disabling netifs is not - * a safe action and disabled when SNMP_SAFE_REQUESTS = 1). - * Unsafe requests are disabled by default! - */ -#if !defined SNMP_SAFE_REQUESTS || defined __DOXYGEN__ -#define SNMP_SAFE_REQUESTS 1 -#endif - -/** - * The maximum length of strings used. - */ -#if !defined SNMP_MAX_OCTET_STRING_LEN || defined __DOXYGEN__ -#define SNMP_MAX_OCTET_STRING_LEN 127 -#endif - -/** - * The maximum number of Sub ID's inside an object identifier. - * Indirectly this also limits the maximum depth of SNMP tree. - */ -#if !defined SNMP_MAX_OBJ_ID_LEN || defined __DOXYGEN__ -#define SNMP_MAX_OBJ_ID_LEN 50 -#endif - -#if !defined SNMP_MAX_VALUE_SIZE || defined __DOXYGEN__ -/** - * The minimum size of a value. - */ -#define SNMP_MIN_VALUE_SIZE (2 * sizeof(u32_t*)) /* size required to store the basic types (8 bytes for counter64) */ -/** - * The maximum size of a value. - */ -#define SNMP_MAX_VALUE_SIZE LWIP_MAX(LWIP_MAX((SNMP_MAX_OCTET_STRING_LEN), sizeof(u32_t)*(SNMP_MAX_OBJ_ID_LEN)), SNMP_MIN_VALUE_SIZE) -#endif - -/** - * The snmp read-access community. Used for write-access and traps, too - * unless SNMP_COMMUNITY_WRITE or SNMP_COMMUNITY_TRAP are enabled, respectively. - */ -#if !defined SNMP_COMMUNITY || defined __DOXYGEN__ -#define SNMP_COMMUNITY "public" -#endif - -/** - * The snmp write-access community. - * Set this community to "" in order to disallow any write access. - */ -#if !defined SNMP_COMMUNITY_WRITE || defined __DOXYGEN__ -#define SNMP_COMMUNITY_WRITE "private" -#endif - -/** - * The snmp community used for sending traps. - */ -#if !defined SNMP_COMMUNITY_TRAP || defined __DOXYGEN__ -#define SNMP_COMMUNITY_TRAP "public" -#endif - -/** - * The maximum length of community string. - * If community names shall be adjusted at runtime via snmp_set_community() calls, - * enter here the possible maximum length (+1 for terminating null character). - */ -#if !defined SNMP_MAX_COMMUNITY_STR_LEN || defined __DOXYGEN__ -#define SNMP_MAX_COMMUNITY_STR_LEN LWIP_MAX(LWIP_MAX(sizeof(SNMP_COMMUNITY), sizeof(SNMP_COMMUNITY_WRITE)), sizeof(SNMP_COMMUNITY_TRAP)) -#endif - -/** - * The OID identifiying the device. This may be the enterprise OID itself or any OID located below it in tree. - */ -#if !defined SNMP_DEVICE_ENTERPRISE_OID || defined __DOXYGEN__ -#define SNMP_LWIP_ENTERPRISE_OID 26381 -/** - * IANA assigned enterprise ID for lwIP is 26381 - * @see http://www.iana.org/assignments/enterprise-numbers - * - * @note this enterprise ID is assigned to the lwIP project, - * all object identifiers living under this ID are assigned - * by the lwIP maintainers! - * @note don't change this define, use snmp_set_device_enterprise_oid() - * - * If you need to create your own private MIB you'll need - * to apply for your own enterprise ID with IANA: - * http://www.iana.org/numbers.html - */ -#define SNMP_DEVICE_ENTERPRISE_OID {1, 3, 6, 1, 4, 1, SNMP_LWIP_ENTERPRISE_OID} -/** - * Length of SNMP_DEVICE_ENTERPRISE_OID - */ -#define SNMP_DEVICE_ENTERPRISE_OID_LEN 7 -#endif - -/** - * SNMP_DEBUG: Enable debugging for SNMP messages. - */ -#if !defined SNMP_DEBUG || defined __DOXYGEN__ -#define SNMP_DEBUG LWIP_DBG_OFF -#endif - -/** - * SNMP_MIB_DEBUG: Enable debugging for SNMP MIBs. - */ -#if !defined SNMP_MIB_DEBUG || defined __DOXYGEN__ -#define SNMP_MIB_DEBUG LWIP_DBG_OFF -#endif - -/** - * Indicates if the MIB2 implementation of LWIP SNMP stack is used. - */ -#if !defined SNMP_LWIP_MIB2 || defined __DOXYGEN__ -#define SNMP_LWIP_MIB2 LWIP_SNMP -#endif - -/** - * Value return for sysDesc field of MIB2. - */ -#if !defined SNMP_LWIP_MIB2_SYSDESC || defined __DOXYGEN__ -#define SNMP_LWIP_MIB2_SYSDESC "lwIP" -#endif - -/** - * Value return for sysName field of MIB2. - * To make sysName field settable, call snmp_mib2_set_sysname() to provide the necessary buffers. - */ -#if !defined SNMP_LWIP_MIB2_SYSNAME || defined __DOXYGEN__ -#define SNMP_LWIP_MIB2_SYSNAME "FQDN-unk" -#endif - -/** - * Value return for sysContact field of MIB2. - * To make sysContact field settable, call snmp_mib2_set_syscontact() to provide the necessary buffers. - */ -#if !defined SNMP_LWIP_MIB2_SYSCONTACT || defined __DOXYGEN__ -#define SNMP_LWIP_MIB2_SYSCONTACT "" -#endif - -/** - * Value return for sysLocation field of MIB2. - * To make sysLocation field settable, call snmp_mib2_set_syslocation() to provide the necessary buffers. - */ -#if !defined SNMP_LWIP_MIB2_SYSLOCATION || defined __DOXYGEN__ -#define SNMP_LWIP_MIB2_SYSLOCATION "" -#endif - -/** - * This value is used to limit the repetitions processed in GetBulk requests (value == 0 means no limitation). - * This may be useful to limit the load for a single request. - * According to SNMP RFC 1905 it is allowed to not return all requested variables from a GetBulk request if system load would be too high. - * so the effect is that the client will do more requests to gather all data. - * For the stack this could be useful in case that SNMP processing is done in TCP/IP thread. In this situation a request with many - * repetitions could block the thread for a longer time. Setting limit here will keep the stack more responsive. - */ -#if !defined SNMP_LWIP_GETBULK_MAX_REPETITIONS || defined __DOXYGEN__ -#define SNMP_LWIP_GETBULK_MAX_REPETITIONS 0 -#endif - -/** - * @} - */ - -/* - ------------------------------------ - ---------- SNMPv3 options ---------- - ------------------------------------ -*/ - -/** - * LWIP_SNMP_V3==1: This enables EXPERIMENTAL SNMPv3 support. LWIP_SNMP must - * also be enabled. - * THIS IS UNDER DEVELOPMENT AND SHOULD NOT BE ENABLED IN PRODUCTS. - */ -#ifndef LWIP_SNMP_V3 -#define LWIP_SNMP_V3 0 -#endif - -#ifndef LWIP_SNMP_V3_MBEDTLS -#define LWIP_SNMP_V3_MBEDTLS LWIP_SNMP_V3 -#endif - -#ifndef LWIP_SNMP_V3_CRYPTO -#define LWIP_SNMP_V3_CRYPTO LWIP_SNMP_V3_MBEDTLS -#endif - -#ifndef LWIP_SNMP_CONFIGURE_VERSIONS -#define LWIP_SNMP_CONFIGURE_VERSIONS 0 -#endif - -#endif /* LWIP_HDR_SNMP_OPTS_H */ +/** + * @file + * SNMP server options list + */ + +/* + * Copyright (c) 2015 Dirk Ziegelmeier + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Dirk Ziegelmeier + * + */ +#ifndef LWIP_HDR_SNMP_OPTS_H +#define LWIP_HDR_SNMP_OPTS_H + +#include "lwip/opt.h" + +/** + * @defgroup snmp_opts Options + * @ingroup snmp + * @{ + */ + +/** + * LWIP_SNMP==1: This enables the lwIP SNMP agent. UDP must be available + * for SNMP transport. + * If you want to use your own SNMP agent, leave this disabled. + * To integrate MIB2 of an external agent, you need to enable + * LWIP_MIB2_CALLBACKS and MIB2_STATS. This will give you the callbacks + * and statistics counters you need to get MIB2 working. + */ +#if !defined LWIP_SNMP || defined __DOXYGEN__ +#define LWIP_SNMP 0 +#endif + +/** + * SNMP_USE_NETCONN: Use netconn API instead of raw API. + * Makes SNMP agent run in a worker thread, so blocking operations + * can be done in MIB calls. + */ +#if !defined SNMP_USE_NETCONN || defined __DOXYGEN__ +#define SNMP_USE_NETCONN 0 +#endif + +/** + * SNMP_USE_RAW: Use raw API. + * SNMP agent does not run in a worker thread, so blocking operations + * should not be done in MIB calls. + */ +#if !defined SNMP_USE_RAW || defined __DOXYGEN__ +#define SNMP_USE_RAW 1 +#endif + +#if SNMP_USE_NETCONN && SNMP_USE_RAW +#error SNMP stack can use only one of the APIs {raw, netconn} +#endif + +#if LWIP_SNMP && !SNMP_USE_NETCONN && !SNMP_USE_RAW +#error SNMP stack needs a receive API and UDP {raw, netconn} +#endif + +#if SNMP_USE_NETCONN +/** + * SNMP_STACK_SIZE: Stack size of SNMP netconn worker thread + */ +#if !defined SNMP_STACK_SIZE || defined __DOXYGEN__ +#define SNMP_STACK_SIZE DEFAULT_THREAD_STACKSIZE +#endif + +/** + * SNMP_THREAD_PRIO: SNMP netconn worker thread priority + */ +#if !defined SNMP_THREAD_PRIO || defined __DOXYGEN__ +#define SNMP_THREAD_PRIO DEFAULT_THREAD_PRIO +#endif +#endif /* SNMP_USE_NETCONN */ + +/** + * SNMP_TRAP_DESTINATIONS: Number of trap destinations. At least one trap + * destination is required + */ +#if !defined SNMP_TRAP_DESTINATIONS || defined __DOXYGEN__ +#define SNMP_TRAP_DESTINATIONS 1 +#endif + +/** + * Only allow SNMP write actions that are 'safe' (e.g. disabling netifs is not + * a safe action and disabled when SNMP_SAFE_REQUESTS = 1). + * Unsafe requests are disabled by default! + */ +#if !defined SNMP_SAFE_REQUESTS || defined __DOXYGEN__ +#define SNMP_SAFE_REQUESTS 1 +#endif + +/** + * The maximum length of strings used. + */ +#if !defined SNMP_MAX_OCTET_STRING_LEN || defined __DOXYGEN__ +#define SNMP_MAX_OCTET_STRING_LEN 127 +#endif + +/** + * The maximum number of Sub ID's inside an object identifier. + * Indirectly this also limits the maximum depth of SNMP tree. + */ +#if !defined SNMP_MAX_OBJ_ID_LEN || defined __DOXYGEN__ +#define SNMP_MAX_OBJ_ID_LEN 50 +#endif + +#if !defined SNMP_MAX_VALUE_SIZE || defined __DOXYGEN__ +/** + * The minimum size of a value. + */ +#define SNMP_MIN_VALUE_SIZE (2 * sizeof(u32_t*)) /* size required to store the basic types (8 bytes for counter64) */ +/** + * The maximum size of a value. + */ +#define SNMP_MAX_VALUE_SIZE LWIP_MAX(LWIP_MAX((SNMP_MAX_OCTET_STRING_LEN), sizeof(u32_t)*(SNMP_MAX_OBJ_ID_LEN)), SNMP_MIN_VALUE_SIZE) +#endif + +/** + * The snmp read-access community. Used for write-access and traps, too + * unless SNMP_COMMUNITY_WRITE or SNMP_COMMUNITY_TRAP are enabled, respectively. + */ +#if !defined SNMP_COMMUNITY || defined __DOXYGEN__ +#define SNMP_COMMUNITY "public" +#endif + +/** + * The snmp write-access community. + * Set this community to "" in order to disallow any write access. + */ +#if !defined SNMP_COMMUNITY_WRITE || defined __DOXYGEN__ +#define SNMP_COMMUNITY_WRITE "private" +#endif + +/** + * The snmp community used for sending traps. + */ +#if !defined SNMP_COMMUNITY_TRAP || defined __DOXYGEN__ +#define SNMP_COMMUNITY_TRAP "public" +#endif + +/** + * The maximum length of community string. + * If community names shall be adjusted at runtime via snmp_set_community() calls, + * enter here the possible maximum length (+1 for terminating null character). + */ +#if !defined SNMP_MAX_COMMUNITY_STR_LEN || defined __DOXYGEN__ +#define SNMP_MAX_COMMUNITY_STR_LEN LWIP_MAX(LWIP_MAX(sizeof(SNMP_COMMUNITY), sizeof(SNMP_COMMUNITY_WRITE)), sizeof(SNMP_COMMUNITY_TRAP)) +#endif + +/** + * The OID identifiying the device. This may be the enterprise OID itself or any OID located below it in tree. + */ +#if !defined SNMP_DEVICE_ENTERPRISE_OID || defined __DOXYGEN__ +#define SNMP_LWIP_ENTERPRISE_OID 26381 +/** + * IANA assigned enterprise ID for lwIP is 26381 + * @see http://www.iana.org/assignments/enterprise-numbers + * + * @note this enterprise ID is assigned to the lwIP project, + * all object identifiers living under this ID are assigned + * by the lwIP maintainers! + * @note don't change this define, use snmp_set_device_enterprise_oid() + * + * If you need to create your own private MIB you'll need + * to apply for your own enterprise ID with IANA: + * http://www.iana.org/numbers.html + */ +#define SNMP_DEVICE_ENTERPRISE_OID {1, 3, 6, 1, 4, 1, SNMP_LWIP_ENTERPRISE_OID} +/** + * Length of SNMP_DEVICE_ENTERPRISE_OID + */ +#define SNMP_DEVICE_ENTERPRISE_OID_LEN 7 +#endif + +/** + * SNMP_DEBUG: Enable debugging for SNMP messages. + */ +#if !defined SNMP_DEBUG || defined __DOXYGEN__ +#define SNMP_DEBUG LWIP_DBG_OFF +#endif + +/** + * SNMP_MIB_DEBUG: Enable debugging for SNMP MIBs. + */ +#if !defined SNMP_MIB_DEBUG || defined __DOXYGEN__ +#define SNMP_MIB_DEBUG LWIP_DBG_OFF +#endif + +/** + * Indicates if the MIB2 implementation of LWIP SNMP stack is used. + */ +#if !defined SNMP_LWIP_MIB2 || defined __DOXYGEN__ +#define SNMP_LWIP_MIB2 LWIP_SNMP +#endif + +/** + * Value return for sysDesc field of MIB2. + */ +#if !defined SNMP_LWIP_MIB2_SYSDESC || defined __DOXYGEN__ +#define SNMP_LWIP_MIB2_SYSDESC "lwIP" +#endif + +/** + * Value return for sysName field of MIB2. + * To make sysName field settable, call snmp_mib2_set_sysname() to provide the necessary buffers. + */ +#if !defined SNMP_LWIP_MIB2_SYSNAME || defined __DOXYGEN__ +#define SNMP_LWIP_MIB2_SYSNAME "FQDN-unk" +#endif + +/** + * Value return for sysContact field of MIB2. + * To make sysContact field settable, call snmp_mib2_set_syscontact() to provide the necessary buffers. + */ +#if !defined SNMP_LWIP_MIB2_SYSCONTACT || defined __DOXYGEN__ +#define SNMP_LWIP_MIB2_SYSCONTACT "" +#endif + +/** + * Value return for sysLocation field of MIB2. + * To make sysLocation field settable, call snmp_mib2_set_syslocation() to provide the necessary buffers. + */ +#if !defined SNMP_LWIP_MIB2_SYSLOCATION || defined __DOXYGEN__ +#define SNMP_LWIP_MIB2_SYSLOCATION "" +#endif + +/** + * This value is used to limit the repetitions processed in GetBulk requests (value == 0 means no limitation). + * This may be useful to limit the load for a single request. + * According to SNMP RFC 1905 it is allowed to not return all requested variables from a GetBulk request if system load would be too high. + * so the effect is that the client will do more requests to gather all data. + * For the stack this could be useful in case that SNMP processing is done in TCP/IP thread. In this situation a request with many + * repetitions could block the thread for a longer time. Setting limit here will keep the stack more responsive. + */ +#if !defined SNMP_LWIP_GETBULK_MAX_REPETITIONS || defined __DOXYGEN__ +#define SNMP_LWIP_GETBULK_MAX_REPETITIONS 0 +#endif + +/** + * @} + */ + +/* + ------------------------------------ + ---------- SNMPv3 options ---------- + ------------------------------------ +*/ + +/** + * LWIP_SNMP_V3==1: This enables EXPERIMENTAL SNMPv3 support. LWIP_SNMP must + * also be enabled. + * THIS IS UNDER DEVELOPMENT AND SHOULD NOT BE ENABLED IN PRODUCTS. + */ +#ifndef LWIP_SNMP_V3 +#define LWIP_SNMP_V3 0 +#endif + +#ifndef LWIP_SNMP_V3_MBEDTLS +#define LWIP_SNMP_V3_MBEDTLS LWIP_SNMP_V3 +#endif + +#ifndef LWIP_SNMP_V3_CRYPTO +#define LWIP_SNMP_V3_CRYPTO LWIP_SNMP_V3_MBEDTLS +#endif + +#ifndef LWIP_SNMP_CONFIGURE_VERSIONS +#define LWIP_SNMP_CONFIGURE_VERSIONS 0 +#endif + +#endif /* LWIP_HDR_SNMP_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_scalar.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_scalar.h index 99bcdf95..40a060c6 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_scalar.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_scalar.h @@ -1,113 +1,113 @@ -/** - * @file - * SNMP server MIB API to implement scalar nodes - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * - */ - -#ifndef LWIP_HDR_APPS_SNMP_SCALAR_H -#define LWIP_HDR_APPS_SNMP_SCALAR_H - -#include "lwip/apps/snmp_opts.h" -#include "lwip/apps/snmp_core.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -/** basic scalar node */ -struct snmp_scalar_node -{ - /** inherited "base class" members */ - struct snmp_leaf_node node; - u8_t asn1_type; - snmp_access_t access; - node_instance_get_value_method get_value; - node_instance_set_test_method set_test; - node_instance_set_value_method set_value; -}; - - -snmp_err_t snmp_scalar_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); -snmp_err_t snmp_scalar_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); - -#define SNMP_SCALAR_CREATE_NODE(oid, access, asn1_type, get_value_method, set_test_method, set_value_method) \ - {{{ SNMP_NODE_SCALAR, (oid) }, \ - snmp_scalar_get_instance, \ - snmp_scalar_get_next_instance }, \ - (asn1_type), (access), (get_value_method), (set_test_method), (set_value_method) } - -#define SNMP_SCALAR_CREATE_NODE_READONLY(oid, asn1_type, get_value_method) SNMP_SCALAR_CREATE_NODE(oid, SNMP_NODE_INSTANCE_READ_ONLY, asn1_type, get_value_method, NULL, NULL) - -/** scalar array node - a tree node which contains scalars only as children */ -struct snmp_scalar_array_node_def -{ - u32_t oid; - u8_t asn1_type; - snmp_access_t access; -}; - -typedef s16_t (*snmp_scalar_array_get_value_method)(const struct snmp_scalar_array_node_def*, void*); -typedef snmp_err_t (*snmp_scalar_array_set_test_method)(const struct snmp_scalar_array_node_def*, u16_t, void*); -typedef snmp_err_t (*snmp_scalar_array_set_value_method)(const struct snmp_scalar_array_node_def*, u16_t, void*); - -/** basic scalar array node */ -struct snmp_scalar_array_node -{ - /** inherited "base class" members */ - struct snmp_leaf_node node; - u16_t array_node_count; - const struct snmp_scalar_array_node_def* array_nodes; - snmp_scalar_array_get_value_method get_value; - snmp_scalar_array_set_test_method set_test; - snmp_scalar_array_set_value_method set_value; -}; - -snmp_err_t snmp_scalar_array_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); -snmp_err_t snmp_scalar_array_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); - -#define SNMP_SCALAR_CREATE_ARRAY_NODE(oid, array_nodes, get_value_method, set_test_method, set_value_method) \ - {{{ SNMP_NODE_SCALAR_ARRAY, (oid) }, \ - snmp_scalar_array_get_instance, \ - snmp_scalar_array_get_next_instance }, \ - (u16_t)LWIP_ARRAYSIZE(array_nodes), (array_nodes), (get_value_method), (set_test_method), (set_value_method) } - -#endif /* LWIP_SNMP */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SNMP_SCALAR_H */ +/** + * @file + * SNMP server MIB API to implement scalar nodes + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * + */ + +#ifndef LWIP_HDR_APPS_SNMP_SCALAR_H +#define LWIP_HDR_APPS_SNMP_SCALAR_H + +#include "lwip/apps/snmp_opts.h" +#include "lwip/apps/snmp_core.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +/** basic scalar node */ +struct snmp_scalar_node +{ + /** inherited "base class" members */ + struct snmp_leaf_node node; + u8_t asn1_type; + snmp_access_t access; + node_instance_get_value_method get_value; + node_instance_set_test_method set_test; + node_instance_set_value_method set_value; +}; + + +snmp_err_t snmp_scalar_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); +snmp_err_t snmp_scalar_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); + +#define SNMP_SCALAR_CREATE_NODE(oid, access, asn1_type, get_value_method, set_test_method, set_value_method) \ + {{{ SNMP_NODE_SCALAR, (oid) }, \ + snmp_scalar_get_instance, \ + snmp_scalar_get_next_instance }, \ + (asn1_type), (access), (get_value_method), (set_test_method), (set_value_method) } + +#define SNMP_SCALAR_CREATE_NODE_READONLY(oid, asn1_type, get_value_method) SNMP_SCALAR_CREATE_NODE(oid, SNMP_NODE_INSTANCE_READ_ONLY, asn1_type, get_value_method, NULL, NULL) + +/** scalar array node - a tree node which contains scalars only as children */ +struct snmp_scalar_array_node_def +{ + u32_t oid; + u8_t asn1_type; + snmp_access_t access; +}; + +typedef s16_t (*snmp_scalar_array_get_value_method)(const struct snmp_scalar_array_node_def*, void*); +typedef snmp_err_t (*snmp_scalar_array_set_test_method)(const struct snmp_scalar_array_node_def*, u16_t, void*); +typedef snmp_err_t (*snmp_scalar_array_set_value_method)(const struct snmp_scalar_array_node_def*, u16_t, void*); + +/** basic scalar array node */ +struct snmp_scalar_array_node +{ + /** inherited "base class" members */ + struct snmp_leaf_node node; + u16_t array_node_count; + const struct snmp_scalar_array_node_def* array_nodes; + snmp_scalar_array_get_value_method get_value; + snmp_scalar_array_set_test_method set_test; + snmp_scalar_array_set_value_method set_value; +}; + +snmp_err_t snmp_scalar_array_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); +snmp_err_t snmp_scalar_array_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); + +#define SNMP_SCALAR_CREATE_ARRAY_NODE(oid, array_nodes, get_value_method, set_test_method, set_value_method) \ + {{{ SNMP_NODE_SCALAR_ARRAY, (oid) }, \ + snmp_scalar_array_get_instance, \ + snmp_scalar_array_get_next_instance }, \ + (u16_t)LWIP_ARRAYSIZE(array_nodes), (array_nodes), (get_value_method), (set_test_method), (set_value_method) } + +#endif /* LWIP_SNMP */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SNMP_SCALAR_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_framework.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_framework.h index 9f4b41c2..47409cc2 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_framework.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_framework.h @@ -1,32 +1,32 @@ -/* -Generated by LwipMibCompiler -*/ - -#ifndef LWIP_HDR_APPS_SNMP_FRAMEWORK_MIB_H -#define LWIP_HDR_APPS_SNMP_FRAMEWORK_MIB_H - -#include "lwip/apps/snmp_opts.h" -#if LWIP_SNMP - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include "lwip/apps/snmp_core.h" - -extern const struct snmp_obj_id usmNoAuthProtocol; -extern const struct snmp_obj_id usmHMACMD5AuthProtocol; -extern const struct snmp_obj_id usmHMACSHAAuthProtocol; - -extern const struct snmp_obj_id usmNoPrivProtocol; -extern const struct snmp_obj_id usmDESPrivProtocol; -extern const struct snmp_obj_id usmAESPrivProtocol; - -extern const struct snmp_mib snmpframeworkmib; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* LWIP_SNMP */ -#endif /* LWIP_HDR_APPS_SNMP_FRAMEWORK_MIB_H */ +/* +Generated by LwipMibCompiler +*/ + +#ifndef LWIP_HDR_APPS_SNMP_FRAMEWORK_MIB_H +#define LWIP_HDR_APPS_SNMP_FRAMEWORK_MIB_H + +#include "lwip/apps/snmp_opts.h" +#if LWIP_SNMP + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include "lwip/apps/snmp_core.h" + +extern const struct snmp_obj_id usmNoAuthProtocol; +extern const struct snmp_obj_id usmHMACMD5AuthProtocol; +extern const struct snmp_obj_id usmHMACSHAAuthProtocol; + +extern const struct snmp_obj_id usmNoPrivProtocol; +extern const struct snmp_obj_id usmDESPrivProtocol; +extern const struct snmp_obj_id usmAESPrivProtocol; + +extern const struct snmp_mib snmpframeworkmib; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* LWIP_SNMP */ +#endif /* LWIP_HDR_APPS_SNMP_FRAMEWORK_MIB_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_usm.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_usm.h index ae09baa5..88cfcd8e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_usm.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_snmpv2_usm.h @@ -1,24 +1,24 @@ -/* -Generated by LwipMibCompiler -*/ - -#ifndef LWIP_HDR_APPS_SNMP_USER_BASED_SM_MIB_H -#define LWIP_HDR_APPS_SNMP_USER_BASED_SM_MIB_H - -#include "lwip/apps/snmp_opts.h" -#if LWIP_SNMP - -#ifdef __cplusplus -extern "C" { -#endif /* __cplusplus */ - -#include "lwip/apps/snmp_core.h" - -extern const struct snmp_mib snmpusmmib; - -#ifdef __cplusplus -} -#endif /* __cplusplus */ - -#endif /* LWIP_SNMP */ -#endif /* LWIP_HDR_APPS_SNMP_USER_BASED_SM_MIB_H */ +/* +Generated by LwipMibCompiler +*/ + +#ifndef LWIP_HDR_APPS_SNMP_USER_BASED_SM_MIB_H +#define LWIP_HDR_APPS_SNMP_USER_BASED_SM_MIB_H + +#include "lwip/apps/snmp_opts.h" +#if LWIP_SNMP + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include "lwip/apps/snmp_core.h" + +extern const struct snmp_mib snmpusmmib; + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* LWIP_SNMP */ +#endif /* LWIP_HDR_APPS_SNMP_USER_BASED_SM_MIB_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_table.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_table.h index 6930d0b4..4988b51c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_table.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_table.h @@ -1,134 +1,134 @@ -/** - * @file - * SNMP server MIB API to implement table nodes - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Martin Hentschel - * - */ - -#ifndef LWIP_HDR_APPS_SNMP_TABLE_H -#define LWIP_HDR_APPS_SNMP_TABLE_H - -#include "lwip/apps/snmp_opts.h" -#include "lwip/apps/snmp_core.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -/** default (customizable) read/write table */ -struct snmp_table_col_def -{ - u32_t index; - u8_t asn1_type; - snmp_access_t access; -}; - -/** table node */ -struct snmp_table_node -{ - /** inherited "base class" members */ - struct snmp_leaf_node node; - u16_t column_count; - const struct snmp_table_col_def* columns; - snmp_err_t (*get_cell_instance)(const u32_t* column, const u32_t* row_oid, u8_t row_oid_len, struct snmp_node_instance* cell_instance); - snmp_err_t (*get_next_cell_instance)(const u32_t* column, struct snmp_obj_id* row_oid, struct snmp_node_instance* cell_instance); - /** returns object value for the given object identifier */ - node_instance_get_value_method get_value; - /** tests length and/or range BEFORE setting */ - node_instance_set_test_method set_test; - /** sets object value, only called when set_test() was successful */ - node_instance_set_value_method set_value; -}; - -snmp_err_t snmp_table_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); -snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); - -#define SNMP_TABLE_CREATE(oid, columns, get_cell_instance_method, get_next_cell_instance_method, get_value_method, set_test_method, set_value_method) \ - {{{ SNMP_NODE_TABLE, (oid) }, \ - snmp_table_get_instance, \ - snmp_table_get_next_instance }, \ - (u16_t)LWIP_ARRAYSIZE(columns), (columns), \ - (get_cell_instance_method), (get_next_cell_instance_method), \ - (get_value_method), (set_test_method), (set_value_method)} - -#define SNMP_TABLE_GET_COLUMN_FROM_OID(oid) ((oid)[1]) /* first array value is (fixed) row entry (fixed to 1) and 2nd value is column, follow3ed by instance */ - - -/** simple read-only table */ -typedef enum { - SNMP_VARIANT_VALUE_TYPE_U32, - SNMP_VARIANT_VALUE_TYPE_S32, - SNMP_VARIANT_VALUE_TYPE_PTR, - SNMP_VARIANT_VALUE_TYPE_CONST_PTR -} snmp_table_column_data_type_t; - -struct snmp_table_simple_col_def -{ - u32_t index; - u8_t asn1_type; - snmp_table_column_data_type_t data_type; /* depending of what union member is used to store the value*/ -}; - -/** simple read-only table node */ -struct snmp_table_simple_node -{ - /* inherited "base class" members */ - struct snmp_leaf_node node; - u16_t column_count; - const struct snmp_table_simple_col_def* columns; - snmp_err_t (*get_cell_value)(const u32_t* column, const u32_t* row_oid, u8_t row_oid_len, union snmp_variant_value* value, u32_t* value_len); - snmp_err_t (*get_next_cell_instance_and_value)(const u32_t* column, struct snmp_obj_id* row_oid, union snmp_variant_value* value, u32_t* value_len); -}; - -snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); -snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); - -#define SNMP_TABLE_CREATE_SIMPLE(oid, columns, get_cell_value_method, get_next_cell_instance_and_value_method) \ - {{{ SNMP_NODE_TABLE, (oid) }, \ - snmp_table_simple_get_instance, \ - snmp_table_simple_get_next_instance }, \ - (u16_t)LWIP_ARRAYSIZE(columns), (columns), (get_cell_value_method), (get_next_cell_instance_and_value_method) } - -s16_t snmp_table_extract_value_from_s32ref(struct snmp_node_instance* instance, void* value); -s16_t snmp_table_extract_value_from_u32ref(struct snmp_node_instance* instance, void* value); -s16_t snmp_table_extract_value_from_refconstptr(struct snmp_node_instance* instance, void* value); - -#endif /* LWIP_SNMP */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SNMP_TABLE_H */ +/** + * @file + * SNMP server MIB API to implement table nodes + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Martin Hentschel + * + */ + +#ifndef LWIP_HDR_APPS_SNMP_TABLE_H +#define LWIP_HDR_APPS_SNMP_TABLE_H + +#include "lwip/apps/snmp_opts.h" +#include "lwip/apps/snmp_core.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +/** default (customizable) read/write table */ +struct snmp_table_col_def +{ + u32_t index; + u8_t asn1_type; + snmp_access_t access; +}; + +/** table node */ +struct snmp_table_node +{ + /** inherited "base class" members */ + struct snmp_leaf_node node; + u16_t column_count; + const struct snmp_table_col_def* columns; + snmp_err_t (*get_cell_instance)(const u32_t* column, const u32_t* row_oid, u8_t row_oid_len, struct snmp_node_instance* cell_instance); + snmp_err_t (*get_next_cell_instance)(const u32_t* column, struct snmp_obj_id* row_oid, struct snmp_node_instance* cell_instance); + /** returns object value for the given object identifier */ + node_instance_get_value_method get_value; + /** tests length and/or range BEFORE setting */ + node_instance_set_test_method set_test; + /** sets object value, only called when set_test() was successful */ + node_instance_set_value_method set_value; +}; + +snmp_err_t snmp_table_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); +snmp_err_t snmp_table_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); + +#define SNMP_TABLE_CREATE(oid, columns, get_cell_instance_method, get_next_cell_instance_method, get_value_method, set_test_method, set_value_method) \ + {{{ SNMP_NODE_TABLE, (oid) }, \ + snmp_table_get_instance, \ + snmp_table_get_next_instance }, \ + (u16_t)LWIP_ARRAYSIZE(columns), (columns), \ + (get_cell_instance_method), (get_next_cell_instance_method), \ + (get_value_method), (set_test_method), (set_value_method)} + +#define SNMP_TABLE_GET_COLUMN_FROM_OID(oid) ((oid)[1]) /* first array value is (fixed) row entry (fixed to 1) and 2nd value is column, follow3ed by instance */ + + +/** simple read-only table */ +typedef enum { + SNMP_VARIANT_VALUE_TYPE_U32, + SNMP_VARIANT_VALUE_TYPE_S32, + SNMP_VARIANT_VALUE_TYPE_PTR, + SNMP_VARIANT_VALUE_TYPE_CONST_PTR +} snmp_table_column_data_type_t; + +struct snmp_table_simple_col_def +{ + u32_t index; + u8_t asn1_type; + snmp_table_column_data_type_t data_type; /* depending of what union member is used to store the value*/ +}; + +/** simple read-only table node */ +struct snmp_table_simple_node +{ + /* inherited "base class" members */ + struct snmp_leaf_node node; + u16_t column_count; + const struct snmp_table_simple_col_def* columns; + snmp_err_t (*get_cell_value)(const u32_t* column, const u32_t* row_oid, u8_t row_oid_len, union snmp_variant_value* value, u32_t* value_len); + snmp_err_t (*get_next_cell_instance_and_value)(const u32_t* column, struct snmp_obj_id* row_oid, union snmp_variant_value* value, u32_t* value_len); +}; + +snmp_err_t snmp_table_simple_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); +snmp_err_t snmp_table_simple_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); + +#define SNMP_TABLE_CREATE_SIMPLE(oid, columns, get_cell_value_method, get_next_cell_instance_and_value_method) \ + {{{ SNMP_NODE_TABLE, (oid) }, \ + snmp_table_simple_get_instance, \ + snmp_table_simple_get_next_instance }, \ + (u16_t)LWIP_ARRAYSIZE(columns), (columns), (get_cell_value_method), (get_next_cell_instance_and_value_method) } + +s16_t snmp_table_extract_value_from_s32ref(struct snmp_node_instance* instance, void* value); +s16_t snmp_table_extract_value_from_u32ref(struct snmp_node_instance* instance, void* value); +s16_t snmp_table_extract_value_from_refconstptr(struct snmp_node_instance* instance, void* value); + +#endif /* LWIP_SNMP */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SNMP_TABLE_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_threadsync.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_threadsync.h index 5eb35387..a25dbf2d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_threadsync.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmp_threadsync.h @@ -1,114 +1,114 @@ -/** - * @file - * SNMP server MIB API to implement thread synchronization - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Dirk Ziegelmeier - * - */ - -#ifndef LWIP_HDR_APPS_SNMP_THREADSYNC_H -#define LWIP_HDR_APPS_SNMP_THREADSYNC_H - -#include "lwip/apps/snmp_opts.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/apps/snmp_core.h" -#include "lwip/sys.h" - -typedef void (*snmp_threadsync_called_fn)(void* arg); -typedef void (*snmp_threadsync_synchronizer_fn)(snmp_threadsync_called_fn fn, void* arg); - - -/** Thread sync runtime data. For internal usage only. */ -struct threadsync_data -{ - union { - snmp_err_t err; - s16_t s16; - } retval; - union { - const u32_t *root_oid; - void *value; - } arg1; - union { - u8_t root_oid_len; - u16_t len; - } arg2; - const struct snmp_threadsync_node *threadsync_node; - struct snmp_node_instance proxy_instance; -}; - -/** Thread sync instance. Needed EXCATLY once for every thread to be synced into. */ -struct snmp_threadsync_instance -{ - sys_sem_t sem; - sys_mutex_t sem_usage_mutex; - snmp_threadsync_synchronizer_fn sync_fn; - struct threadsync_data data; -}; - -/** SNMP thread sync proxy leaf node */ -struct snmp_threadsync_node -{ - /* inherited "base class" members */ - struct snmp_leaf_node node; - - const struct snmp_leaf_node *target; - struct snmp_threadsync_instance *instance; -}; - -snmp_err_t snmp_threadsync_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); -snmp_err_t snmp_threadsync_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); - -/** Create thread sync proxy node */ -#define SNMP_CREATE_THREAD_SYNC_NODE(oid, target_leaf_node, threadsync_instance) \ - {{{ SNMP_NODE_THREADSYNC, (oid) }, \ - snmp_threadsync_get_instance, \ - snmp_threadsync_get_next_instance }, \ - (target_leaf_node), \ - (threadsync_instance) } - -/** Create thread sync instance data */ -void snmp_threadsync_init(struct snmp_threadsync_instance *instance, snmp_threadsync_synchronizer_fn sync_fn); - -#endif /* LWIP_SNMP */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SNMP_THREADSYNC_H */ +/** + * @file + * SNMP server MIB API to implement thread synchronization + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Dirk Ziegelmeier + * + */ + +#ifndef LWIP_HDR_APPS_SNMP_THREADSYNC_H +#define LWIP_HDR_APPS_SNMP_THREADSYNC_H + +#include "lwip/apps/snmp_opts.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_SNMP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/apps/snmp_core.h" +#include "lwip/sys.h" + +typedef void (*snmp_threadsync_called_fn)(void* arg); +typedef void (*snmp_threadsync_synchronizer_fn)(snmp_threadsync_called_fn fn, void* arg); + + +/** Thread sync runtime data. For internal usage only. */ +struct threadsync_data +{ + union { + snmp_err_t err; + s16_t s16; + } retval; + union { + const u32_t *root_oid; + void *value; + } arg1; + union { + u8_t root_oid_len; + u16_t len; + } arg2; + const struct snmp_threadsync_node *threadsync_node; + struct snmp_node_instance proxy_instance; +}; + +/** Thread sync instance. Needed EXCATLY once for every thread to be synced into. */ +struct snmp_threadsync_instance +{ + sys_sem_t sem; + sys_mutex_t sem_usage_mutex; + snmp_threadsync_synchronizer_fn sync_fn; + struct threadsync_data data; +}; + +/** SNMP thread sync proxy leaf node */ +struct snmp_threadsync_node +{ + /* inherited "base class" members */ + struct snmp_leaf_node node; + + const struct snmp_leaf_node *target; + struct snmp_threadsync_instance *instance; +}; + +snmp_err_t snmp_threadsync_get_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); +snmp_err_t snmp_threadsync_get_next_instance(const u32_t *root_oid, u8_t root_oid_len, struct snmp_node_instance* instance); + +/** Create thread sync proxy node */ +#define SNMP_CREATE_THREAD_SYNC_NODE(oid, target_leaf_node, threadsync_instance) \ + {{{ SNMP_NODE_THREADSYNC, (oid) }, \ + snmp_threadsync_get_instance, \ + snmp_threadsync_get_next_instance }, \ + (target_leaf_node), \ + (threadsync_instance) } + +/** Create thread sync instance data */ +void snmp_threadsync_init(struct snmp_threadsync_instance *instance, snmp_threadsync_synchronizer_fn sync_fn); + +#endif /* LWIP_SNMP */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SNMP_THREADSYNC_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmpv3.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmpv3.h index bd7d3147..e0dda649 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmpv3.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/snmpv3.h @@ -1,114 +1,114 @@ -/** - * @file - * Additional SNMPv3 functionality RFC3414 and RFC3826. - */ - -/* - * Copyright (c) 2016 Elias Oenal. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Elias Oenal - */ - -#ifndef LWIP_HDR_APPS_SNMP_V3_H -#define LWIP_HDR_APPS_SNMP_V3_H - -#include "lwip/apps/snmp_opts.h" -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_SNMP && LWIP_SNMP_V3 - -typedef enum -{ - SNMP_V3_AUTH_ALGO_INVAL = 0, - SNMP_V3_AUTH_ALGO_MD5 = 1, - SNMP_V3_AUTH_ALGO_SHA = 2 -} snmpv3_auth_algo_t; - -typedef enum -{ - SNMP_V3_PRIV_ALGO_INVAL = 0, - SNMP_V3_PRIV_ALGO_DES = 1, - SNMP_V3_PRIV_ALGO_AES = 2 -} snmpv3_priv_algo_t; - -typedef enum -{ - SNMP_V3_USER_STORAGETYPE_OTHER = 1, - SNMP_V3_USER_STORAGETYPE_VOLATILE = 2, - SNMP_V3_USER_STORAGETYPE_NONVOLATILE = 3, - SNMP_V3_USER_STORAGETYPE_PERMANENT = 4, - SNMP_V3_USER_STORAGETYPE_READONLY = 5 -} snmpv3_user_storagetype_t; - -/* - * The following callback functions must be implemented by the application. - * There is a dummy implementation in snmpv3_dummy.c. - */ - -void snmpv3_get_engine_id(const char **id, u8_t *len); -err_t snmpv3_set_engine_id(const char* id, u8_t len); - -u32_t snmpv3_get_engine_boots(void); -void snmpv3_set_engine_boots(u32_t boots); - -u32_t snmpv3_get_engine_time(void); -void snmpv3_reset_engine_time(void); - -err_t snmpv3_get_user(const char* username, snmpv3_auth_algo_t *auth_algo, u8_t *auth_key, snmpv3_priv_algo_t *priv_algo, u8_t *priv_key); -u8_t snmpv3_get_amount_of_users(void); -err_t snmpv3_get_user_storagetype(const char *username, snmpv3_user_storagetype_t *storagetype); -err_t snmpv3_get_username(char *username, u8_t index); - -/* The following functions are provided by the SNMPv3 agent */ - -void snmpv3_engine_id_changed(void); -s32_t snmpv3_get_engine_time_internal(void); - -void snmpv3_password_to_key_md5( - const u8_t *password, /* IN */ - size_t passwordlen, /* IN */ - const u8_t *engineID, /* IN - pointer to snmpEngineID */ - u8_t engineLength, /* IN - length of snmpEngineID */ - u8_t *key); /* OUT - pointer to caller 16-octet buffer */ - -void snmpv3_password_to_key_sha( - const u8_t *password, /* IN */ - size_t passwordlen, /* IN */ - const u8_t *engineID, /* IN - pointer to snmpEngineID */ - u8_t engineLength, /* IN - length of snmpEngineID */ - u8_t *key); /* OUT - pointer to caller 20-octet buffer */ - -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SNMP_V3_H */ +/** + * @file + * Additional SNMPv3 functionality RFC3414 and RFC3826. + */ + +/* + * Copyright (c) 2016 Elias Oenal. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Elias Oenal + */ + +#ifndef LWIP_HDR_APPS_SNMP_V3_H +#define LWIP_HDR_APPS_SNMP_V3_H + +#include "lwip/apps/snmp_opts.h" +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_SNMP && LWIP_SNMP_V3 + +typedef enum +{ + SNMP_V3_AUTH_ALGO_INVAL = 0, + SNMP_V3_AUTH_ALGO_MD5 = 1, + SNMP_V3_AUTH_ALGO_SHA = 2 +} snmpv3_auth_algo_t; + +typedef enum +{ + SNMP_V3_PRIV_ALGO_INVAL = 0, + SNMP_V3_PRIV_ALGO_DES = 1, + SNMP_V3_PRIV_ALGO_AES = 2 +} snmpv3_priv_algo_t; + +typedef enum +{ + SNMP_V3_USER_STORAGETYPE_OTHER = 1, + SNMP_V3_USER_STORAGETYPE_VOLATILE = 2, + SNMP_V3_USER_STORAGETYPE_NONVOLATILE = 3, + SNMP_V3_USER_STORAGETYPE_PERMANENT = 4, + SNMP_V3_USER_STORAGETYPE_READONLY = 5 +} snmpv3_user_storagetype_t; + +/* + * The following callback functions must be implemented by the application. + * There is a dummy implementation in snmpv3_dummy.c. + */ + +void snmpv3_get_engine_id(const char **id, u8_t *len); +err_t snmpv3_set_engine_id(const char* id, u8_t len); + +u32_t snmpv3_get_engine_boots(void); +void snmpv3_set_engine_boots(u32_t boots); + +u32_t snmpv3_get_engine_time(void); +void snmpv3_reset_engine_time(void); + +err_t snmpv3_get_user(const char* username, snmpv3_auth_algo_t *auth_algo, u8_t *auth_key, snmpv3_priv_algo_t *priv_algo, u8_t *priv_key); +u8_t snmpv3_get_amount_of_users(void); +err_t snmpv3_get_user_storagetype(const char *username, snmpv3_user_storagetype_t *storagetype); +err_t snmpv3_get_username(char *username, u8_t index); + +/* The following functions are provided by the SNMPv3 agent */ + +void snmpv3_engine_id_changed(void); +s32_t snmpv3_get_engine_time_internal(void); + +void snmpv3_password_to_key_md5( + const u8_t *password, /* IN */ + size_t passwordlen, /* IN */ + const u8_t *engineID, /* IN - pointer to snmpEngineID */ + u8_t engineLength, /* IN - length of snmpEngineID */ + u8_t *key); /* OUT - pointer to caller 16-octet buffer */ + +void snmpv3_password_to_key_sha( + const u8_t *password, /* IN */ + size_t passwordlen, /* IN */ + const u8_t *engineID, /* IN - pointer to snmpEngineID */ + u8_t engineLength, /* IN - length of snmpEngineID */ + u8_t *key); /* OUT - pointer to caller 20-octet buffer */ + +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SNMP_V3_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp.h index 00135b49..3c0f95f7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp.h @@ -1,80 +1,80 @@ -/** - * @file - * SNTP client API - */ - -/* - * Copyright (c) 2007-2009 Frédéric Bernon, Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Frédéric Bernon, Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_APPS_SNTP_H -#define LWIP_HDR_APPS_SNTP_H - -#include "lwip/apps/sntp_opts.h" -#include "lwip/ip_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* SNTP operating modes: default is to poll using unicast. - The mode has to be set before calling sntp_init(). */ -#define SNTP_OPMODE_POLL 0 -#define SNTP_OPMODE_LISTENONLY 1 -void sntp_setoperatingmode(u8_t operating_mode); -u8_t sntp_getoperatingmode(void); - -void sntp_init(void); -void sntp_stop(void); -u8_t sntp_enabled(void); - -void sntp_setserver(u8_t idx, const ip_addr_t *addr); -const ip_addr_t* sntp_getserver(u8_t idx); - -#if SNTP_MONITOR_SERVER_REACHABILITY -u8_t sntp_getreachability(u8_t idx); -#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ - -#if SNTP_SERVER_DNS -void sntp_setservername(u8_t idx, const char *server); -const char *sntp_getservername(u8_t idx); -#endif /* SNTP_SERVER_DNS */ - -#if SNTP_GET_SERVERS_FROM_DHCP -void sntp_servermode_dhcp(int set_servers_from_dhcp); -#else /* SNTP_GET_SERVERS_FROM_DHCP */ -#define sntp_servermode_dhcp(x) -#endif /* SNTP_GET_SERVERS_FROM_DHCP */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_SNTP_H */ +/** + * @file + * SNTP client API + */ + +/* + * Copyright (c) 2007-2009 Frédéric Bernon, Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Frédéric Bernon, Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_APPS_SNTP_H +#define LWIP_HDR_APPS_SNTP_H + +#include "lwip/apps/sntp_opts.h" +#include "lwip/ip_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* SNTP operating modes: default is to poll using unicast. + The mode has to be set before calling sntp_init(). */ +#define SNTP_OPMODE_POLL 0 +#define SNTP_OPMODE_LISTENONLY 1 +void sntp_setoperatingmode(u8_t operating_mode); +u8_t sntp_getoperatingmode(void); + +void sntp_init(void); +void sntp_stop(void); +u8_t sntp_enabled(void); + +void sntp_setserver(u8_t idx, const ip_addr_t *addr); +const ip_addr_t* sntp_getserver(u8_t idx); + +#if SNTP_MONITOR_SERVER_REACHABILITY +u8_t sntp_getreachability(u8_t idx); +#endif /* SNTP_MONITOR_SERVER_REACHABILITY */ + +#if SNTP_SERVER_DNS +void sntp_setservername(u8_t idx, const char *server); +const char *sntp_getservername(u8_t idx); +#endif /* SNTP_SERVER_DNS */ + +#if SNTP_GET_SERVERS_FROM_DHCP +void sntp_servermode_dhcp(int set_servers_from_dhcp); +#else /* SNTP_GET_SERVERS_FROM_DHCP */ +#define sntp_servermode_dhcp(x) +#endif /* SNTP_GET_SERVERS_FROM_DHCP */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_SNTP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp_opts.h index c25a3861..ed98040f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/sntp_opts.h @@ -1,209 +1,209 @@ -/** - * @file - * SNTP client options list - */ - -/* - * Copyright (c) 2007-2009 Frédéric Bernon, Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Frédéric Bernon, Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_APPS_SNTP_OPTS_H -#define LWIP_HDR_APPS_SNTP_OPTS_H - -#include "lwip/opt.h" -#include "lwip/prot/iana.h" - -/** - * @defgroup sntp_opts Options - * @ingroup sntp - * @{ - */ - -/** SNTP macro to change system time in seconds - * Define SNTP_SET_SYSTEM_TIME_US(sec, us) to set the time in microseconds - * instead of this one if you need the additional precision. Alternatively, - * define SNTP_SET_SYSTEM_TIME_NTP(sec, frac) in order to work with native - * NTP timestamps instead. - */ -#if !defined SNTP_SET_SYSTEM_TIME || defined __DOXYGEN__ -#define SNTP_SET_SYSTEM_TIME(sec) LWIP_UNUSED_ARG(sec) -#endif - -/** The maximum number of SNTP servers that can be set */ -#if !defined SNTP_MAX_SERVERS || defined __DOXYGEN__ -#define SNTP_MAX_SERVERS LWIP_DHCP_MAX_NTP_SERVERS -#endif - -/** Set this to 1 to implement the callback function called by dhcp when - * NTP servers are received. */ -#if !defined SNTP_GET_SERVERS_FROM_DHCP || defined __DOXYGEN__ -#define SNTP_GET_SERVERS_FROM_DHCP LWIP_DHCP_GET_NTP_SRV -#endif - -/** Set this to 1 to support DNS names (or IP address strings) to set sntp servers - * One server address/name can be defined as default if SNTP_SERVER_DNS == 1: - * \#define SNTP_SERVER_ADDRESS "pool.ntp.org" - */ -#if !defined SNTP_SERVER_DNS || defined __DOXYGEN__ -#define SNTP_SERVER_DNS 0 -#endif - -/** - * SNTP_DEBUG: Enable debugging for SNTP. - */ -#if !defined SNTP_DEBUG || defined __DOXYGEN__ -#define SNTP_DEBUG LWIP_DBG_OFF -#endif - -/** SNTP server port */ -#if !defined SNTP_PORT || defined __DOXYGEN__ -#define SNTP_PORT LWIP_IANA_PORT_SNTP -#endif - -/** Sanity check: - * Define this to - * - 0 to turn off sanity checks (default; smaller code) - * - >= 1 to check address and port of the response packet to ensure the - * response comes from the server we sent the request to. - * - >= 2 to check returned Originate Timestamp against Transmit Timestamp - * sent to the server (to ensure response to older request). - * - >= 3 @todo: discard reply if any of the VN, Stratum, or Transmit Timestamp - * fields is 0 or the Mode field is not 4 (unicast) or 5 (broadcast). - * - >= 4 @todo: to check that the Root Delay and Root Dispersion fields are each - * greater than or equal to 0 and less than infinity, where infinity is - * currently a cozy number like one second. This check avoids using a - * server whose synchronization source has expired for a very long time. - */ -#if !defined SNTP_CHECK_RESPONSE || defined __DOXYGEN__ -#define SNTP_CHECK_RESPONSE 0 -#endif - -/** Enable round-trip delay compensation. - * Compensate for the round-trip delay by calculating the clock offset from - * the originate, receive, transmit and destination timestamps, as per RFC. - * - * The calculation requires compiler support for 64-bit integers. Also, either - * SNTP_SET_SYSTEM_TIME_US or SNTP_SET_SYSTEM_TIME_NTP has to be implemented - * for setting the system clock with sub-second precision. Likewise, either - * SNTP_GET_SYSTEM_TIME or SNTP_GET_SYSTEM_TIME_NTP needs to be implemented - * with sub-second precision. - * - * Although not strictly required, it makes sense to combine this option with - * SNTP_CHECK_RESPONSE >= 2 for sanity-checking of the received timestamps. - * Also, in order for the round-trip calculation to work, the difference - * between the local clock and the NTP server clock must not be larger than - * about 34 years. If that limit is exceeded, the implementation will fall back - * to setting the clock without compensation. In order to ensure that the local - * clock is always within the permitted range for compensation, even at first - * try, it may be necessary to store at least the current year in non-volatile - * memory. - */ -#if !defined SNTP_COMP_ROUNDTRIP || defined __DOXYGEN__ -#define SNTP_COMP_ROUNDTRIP 0 -#endif - -/** According to the RFC, this shall be a random delay - * between 1 and 5 minutes (in milliseconds) to prevent load peaks. - * This can be defined to a random generation function, - * which must return the delay in milliseconds as u32_t. - * Turned off by default. - */ -#if !defined SNTP_STARTUP_DELAY || defined __DOXYGEN__ -#ifdef LWIP_RAND -#define SNTP_STARTUP_DELAY 1 -#else -#define SNTP_STARTUP_DELAY 0 -#endif -#endif - -/** If you want the startup delay to be a function, define this - * to a function (including the brackets) and define SNTP_STARTUP_DELAY to 1. - */ -#if !defined SNTP_STARTUP_DELAY_FUNC || defined __DOXYGEN__ -#define SNTP_STARTUP_DELAY_FUNC (LWIP_RAND() % 5000) -#endif - -/** SNTP receive timeout - in milliseconds - * Also used as retry timeout - this shouldn't be too low. - * Default is 15 seconds. Must not be beolw 15 seconds by specification (i.e. 15000) - */ -#if !defined SNTP_RECV_TIMEOUT || defined __DOXYGEN__ -#define SNTP_RECV_TIMEOUT 15000 -#endif - -/** SNTP update delay - in milliseconds - * Default is 1 hour. Must not be beolw 60 seconds by specification (i.e. 60000) - */ -#if !defined SNTP_UPDATE_DELAY || defined __DOXYGEN__ -#define SNTP_UPDATE_DELAY 3600000 -#endif - -/** SNTP macro to get system time, used with SNTP_CHECK_RESPONSE >= 2 - * to send in request and compare in response. Also used for round-trip - * delay compensation if SNTP_COMP_ROUNDTRIP != 0. - * Alternatively, define SNTP_GET_SYSTEM_TIME_NTP(sec, frac) in order to - * work with native NTP timestamps instead. - */ -#if !defined SNTP_GET_SYSTEM_TIME || defined __DOXYGEN__ -#define SNTP_GET_SYSTEM_TIME(sec, us) do { (sec) = 0; (us) = 0; } while(0) -#endif - -/** Default retry timeout (in milliseconds) if the response - * received is invalid. - * This is doubled with each retry until SNTP_RETRY_TIMEOUT_MAX is reached. - */ -#if !defined SNTP_RETRY_TIMEOUT || defined __DOXYGEN__ -#define SNTP_RETRY_TIMEOUT SNTP_RECV_TIMEOUT -#endif - -/** Maximum retry timeout (in milliseconds). */ -#if !defined SNTP_RETRY_TIMEOUT_MAX || defined __DOXYGEN__ -#define SNTP_RETRY_TIMEOUT_MAX (SNTP_RETRY_TIMEOUT * 10) -#endif - -/** Increase retry timeout with every retry sent - * Default is on to conform to RFC. - */ -#if !defined SNTP_RETRY_TIMEOUT_EXP || defined __DOXYGEN__ -#define SNTP_RETRY_TIMEOUT_EXP 1 -#endif - -/** Keep a reachability shift register per server - * Default is on to conform to RFC. - */ -#if !defined SNTP_MONITOR_SERVER_REACHABILITY || defined __DOXYGEN__ -#define SNTP_MONITOR_SERVER_REACHABILITY 1 -#endif - -/** - * @} - */ - -#endif /* LWIP_HDR_APPS_SNTP_OPTS_H */ +/** + * @file + * SNTP client options list + */ + +/* + * Copyright (c) 2007-2009 Frédéric Bernon, Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Frédéric Bernon, Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_APPS_SNTP_OPTS_H +#define LWIP_HDR_APPS_SNTP_OPTS_H + +#include "lwip/opt.h" +#include "lwip/prot/iana.h" + +/** + * @defgroup sntp_opts Options + * @ingroup sntp + * @{ + */ + +/** SNTP macro to change system time in seconds + * Define SNTP_SET_SYSTEM_TIME_US(sec, us) to set the time in microseconds + * instead of this one if you need the additional precision. Alternatively, + * define SNTP_SET_SYSTEM_TIME_NTP(sec, frac) in order to work with native + * NTP timestamps instead. + */ +#if !defined SNTP_SET_SYSTEM_TIME || defined __DOXYGEN__ +#define SNTP_SET_SYSTEM_TIME(sec) LWIP_UNUSED_ARG(sec) +#endif + +/** The maximum number of SNTP servers that can be set */ +#if !defined SNTP_MAX_SERVERS || defined __DOXYGEN__ +#define SNTP_MAX_SERVERS LWIP_DHCP_MAX_NTP_SERVERS +#endif + +/** Set this to 1 to implement the callback function called by dhcp when + * NTP servers are received. */ +#if !defined SNTP_GET_SERVERS_FROM_DHCP || defined __DOXYGEN__ +#define SNTP_GET_SERVERS_FROM_DHCP LWIP_DHCP_GET_NTP_SRV +#endif + +/** Set this to 1 to support DNS names (or IP address strings) to set sntp servers + * One server address/name can be defined as default if SNTP_SERVER_DNS == 1: + * \#define SNTP_SERVER_ADDRESS "pool.ntp.org" + */ +#if !defined SNTP_SERVER_DNS || defined __DOXYGEN__ +#define SNTP_SERVER_DNS 0 +#endif + +/** + * SNTP_DEBUG: Enable debugging for SNTP. + */ +#if !defined SNTP_DEBUG || defined __DOXYGEN__ +#define SNTP_DEBUG LWIP_DBG_OFF +#endif + +/** SNTP server port */ +#if !defined SNTP_PORT || defined __DOXYGEN__ +#define SNTP_PORT LWIP_IANA_PORT_SNTP +#endif + +/** Sanity check: + * Define this to + * - 0 to turn off sanity checks (default; smaller code) + * - >= 1 to check address and port of the response packet to ensure the + * response comes from the server we sent the request to. + * - >= 2 to check returned Originate Timestamp against Transmit Timestamp + * sent to the server (to ensure response to older request). + * - >= 3 @todo: discard reply if any of the VN, Stratum, or Transmit Timestamp + * fields is 0 or the Mode field is not 4 (unicast) or 5 (broadcast). + * - >= 4 @todo: to check that the Root Delay and Root Dispersion fields are each + * greater than or equal to 0 and less than infinity, where infinity is + * currently a cozy number like one second. This check avoids using a + * server whose synchronization source has expired for a very long time. + */ +#if !defined SNTP_CHECK_RESPONSE || defined __DOXYGEN__ +#define SNTP_CHECK_RESPONSE 0 +#endif + +/** Enable round-trip delay compensation. + * Compensate for the round-trip delay by calculating the clock offset from + * the originate, receive, transmit and destination timestamps, as per RFC. + * + * The calculation requires compiler support for 64-bit integers. Also, either + * SNTP_SET_SYSTEM_TIME_US or SNTP_SET_SYSTEM_TIME_NTP has to be implemented + * for setting the system clock with sub-second precision. Likewise, either + * SNTP_GET_SYSTEM_TIME or SNTP_GET_SYSTEM_TIME_NTP needs to be implemented + * with sub-second precision. + * + * Although not strictly required, it makes sense to combine this option with + * SNTP_CHECK_RESPONSE >= 2 for sanity-checking of the received timestamps. + * Also, in order for the round-trip calculation to work, the difference + * between the local clock and the NTP server clock must not be larger than + * about 34 years. If that limit is exceeded, the implementation will fall back + * to setting the clock without compensation. In order to ensure that the local + * clock is always within the permitted range for compensation, even at first + * try, it may be necessary to store at least the current year in non-volatile + * memory. + */ +#if !defined SNTP_COMP_ROUNDTRIP || defined __DOXYGEN__ +#define SNTP_COMP_ROUNDTRIP 0 +#endif + +/** According to the RFC, this shall be a random delay + * between 1 and 5 minutes (in milliseconds) to prevent load peaks. + * This can be defined to a random generation function, + * which must return the delay in milliseconds as u32_t. + * Turned off by default. + */ +#if !defined SNTP_STARTUP_DELAY || defined __DOXYGEN__ +#ifdef LWIP_RAND +#define SNTP_STARTUP_DELAY 1 +#else +#define SNTP_STARTUP_DELAY 0 +#endif +#endif + +/** If you want the startup delay to be a function, define this + * to a function (including the brackets) and define SNTP_STARTUP_DELAY to 1. + */ +#if !defined SNTP_STARTUP_DELAY_FUNC || defined __DOXYGEN__ +#define SNTP_STARTUP_DELAY_FUNC (LWIP_RAND() % 5000) +#endif + +/** SNTP receive timeout - in milliseconds + * Also used as retry timeout - this shouldn't be too low. + * Default is 15 seconds. Must not be beolw 15 seconds by specification (i.e. 15000) + */ +#if !defined SNTP_RECV_TIMEOUT || defined __DOXYGEN__ +#define SNTP_RECV_TIMEOUT 15000 +#endif + +/** SNTP update delay - in milliseconds + * Default is 1 hour. Must not be beolw 60 seconds by specification (i.e. 60000) + */ +#if !defined SNTP_UPDATE_DELAY || defined __DOXYGEN__ +#define SNTP_UPDATE_DELAY 3600000 +#endif + +/** SNTP macro to get system time, used with SNTP_CHECK_RESPONSE >= 2 + * to send in request and compare in response. Also used for round-trip + * delay compensation if SNTP_COMP_ROUNDTRIP != 0. + * Alternatively, define SNTP_GET_SYSTEM_TIME_NTP(sec, frac) in order to + * work with native NTP timestamps instead. + */ +#if !defined SNTP_GET_SYSTEM_TIME || defined __DOXYGEN__ +#define SNTP_GET_SYSTEM_TIME(sec, us) do { (sec) = 0; (us) = 0; } while(0) +#endif + +/** Default retry timeout (in milliseconds) if the response + * received is invalid. + * This is doubled with each retry until SNTP_RETRY_TIMEOUT_MAX is reached. + */ +#if !defined SNTP_RETRY_TIMEOUT || defined __DOXYGEN__ +#define SNTP_RETRY_TIMEOUT SNTP_RECV_TIMEOUT +#endif + +/** Maximum retry timeout (in milliseconds). */ +#if !defined SNTP_RETRY_TIMEOUT_MAX || defined __DOXYGEN__ +#define SNTP_RETRY_TIMEOUT_MAX (SNTP_RETRY_TIMEOUT * 10) +#endif + +/** Increase retry timeout with every retry sent + * Default is on to conform to RFC. + */ +#if !defined SNTP_RETRY_TIMEOUT_EXP || defined __DOXYGEN__ +#define SNTP_RETRY_TIMEOUT_EXP 1 +#endif + +/** Keep a reachability shift register per server + * Default is on to conform to RFC. + */ +#if !defined SNTP_MONITOR_SERVER_REACHABILITY || defined __DOXYGEN__ +#define SNTP_MONITOR_SERVER_REACHABILITY 1 +#endif + +/** + * @} + */ + +#endif /* LWIP_HDR_APPS_SNTP_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_opts.h index d187b821..198f632b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_opts.h @@ -1,106 +1,106 @@ -/** - * - * @file tftp_opts.h - * - * @author Logan Gunthorpe - * - * @brief Trivial File Transfer Protocol (RFC 1350) implementation options - * - * Copyright (c) Deltatee Enterprises Ltd. 2013 - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Logan Gunthorpe - * - */ - -#ifndef LWIP_HDR_APPS_TFTP_OPTS_H -#define LWIP_HDR_APPS_TFTP_OPTS_H - -#include "lwip/opt.h" -#include "lwip/prot/iana.h" - -/** - * @defgroup tftp_opts Options - * @ingroup tftp - * @{ - */ - -/** - * Enable TFTP debug messages - */ -#if !defined TFTP_DEBUG || defined __DOXYGEN__ -#define TFTP_DEBUG LWIP_DBG_OFF -#endif - -/** - * TFTP server port - */ -#if !defined TFTP_PORT || defined __DOXYGEN__ -#define TFTP_PORT LWIP_IANA_PORT_TFTP -#endif - -/** - * TFTP timeout - */ -#if !defined TFTP_TIMEOUT_MSECS || defined __DOXYGEN__ -#define TFTP_TIMEOUT_MSECS 10000 -#endif - -/** - * Max. number of retries when a file is read from server - */ -#if !defined TFTP_MAX_RETRIES || defined __DOXYGEN__ -#define TFTP_MAX_RETRIES 5 -#endif - -/** - * TFTP timer cyclic interval - */ -#if !defined TFTP_TIMER_MSECS || defined __DOXYGEN__ -#define TFTP_TIMER_MSECS (TFTP_TIMEOUT_MSECS / 10) -#endif - -/** - * Max. length of TFTP filename - */ -#if !defined TFTP_MAX_FILENAME_LEN || defined __DOXYGEN__ -#define TFTP_MAX_FILENAME_LEN 20 -#endif - -/** - * Max. length of TFTP mode - */ -#if !defined TFTP_MAX_MODE_LEN || defined __DOXYGEN__ -#define TFTP_MAX_MODE_LEN 7 -#endif - -/** - * @} - */ - -#endif /* LWIP_HDR_APPS_TFTP_OPTS_H */ +/** + * + * @file tftp_opts.h + * + * @author Logan Gunthorpe + * + * @brief Trivial File Transfer Protocol (RFC 1350) implementation options + * + * Copyright (c) Deltatee Enterprises Ltd. 2013 + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Logan Gunthorpe + * + */ + +#ifndef LWIP_HDR_APPS_TFTP_OPTS_H +#define LWIP_HDR_APPS_TFTP_OPTS_H + +#include "lwip/opt.h" +#include "lwip/prot/iana.h" + +/** + * @defgroup tftp_opts Options + * @ingroup tftp + * @{ + */ + +/** + * Enable TFTP debug messages + */ +#if !defined TFTP_DEBUG || defined __DOXYGEN__ +#define TFTP_DEBUG LWIP_DBG_OFF +#endif + +/** + * TFTP server port + */ +#if !defined TFTP_PORT || defined __DOXYGEN__ +#define TFTP_PORT LWIP_IANA_PORT_TFTP +#endif + +/** + * TFTP timeout + */ +#if !defined TFTP_TIMEOUT_MSECS || defined __DOXYGEN__ +#define TFTP_TIMEOUT_MSECS 10000 +#endif + +/** + * Max. number of retries when a file is read from server + */ +#if !defined TFTP_MAX_RETRIES || defined __DOXYGEN__ +#define TFTP_MAX_RETRIES 5 +#endif + +/** + * TFTP timer cyclic interval + */ +#if !defined TFTP_TIMER_MSECS || defined __DOXYGEN__ +#define TFTP_TIMER_MSECS (TFTP_TIMEOUT_MSECS / 10) +#endif + +/** + * Max. length of TFTP filename + */ +#if !defined TFTP_MAX_FILENAME_LEN || defined __DOXYGEN__ +#define TFTP_MAX_FILENAME_LEN 20 +#endif + +/** + * Max. length of TFTP mode + */ +#if !defined TFTP_MAX_MODE_LEN || defined __DOXYGEN__ +#define TFTP_MAX_MODE_LEN 7 +#endif + +/** + * @} + */ + +#endif /* LWIP_HDR_APPS_TFTP_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_server.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_server.h index 3ce5e405..0a7fbee0 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_server.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/apps/tftp_server.h @@ -1,95 +1,95 @@ -/** - * - * @file tftp_server.h - * - * @author Logan Gunthorpe - * - * @brief Trivial File Transfer Protocol (RFC 1350) - * - * Copyright (c) Deltatee Enterprises Ltd. 2013 - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Logan Gunthorpe - * - */ - -#ifndef LWIP_HDR_APPS_TFTP_SERVER_H -#define LWIP_HDR_APPS_TFTP_SERVER_H - -#include "lwip/apps/tftp_opts.h" -#include "lwip/err.h" -#include "lwip/pbuf.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** @ingroup tftp - * TFTP context containing callback functions for TFTP transfers - */ -struct tftp_context { - /** - * Open file for read/write. - * @param fname Filename - * @param mode Mode string from TFTP RFC 1350 (netascii, octet, mail) - * @param write Flag indicating read (0) or write (!= 0) access - * @returns File handle supplied to other functions - */ - void* (*open)(const char* fname, const char* mode, u8_t write); - /** - * Close file handle - * @param handle File handle returned by open() - */ - void (*close)(void* handle); - /** - * Read from file - * @param handle File handle returned by open() - * @param buf Target buffer to copy read data to - * @param bytes Number of bytes to copy to buf - * @returns >= 0: Success; < 0: Error - */ - int (*read)(void* handle, void* buf, int bytes); - /** - * Write to file - * @param handle File handle returned by open() - * @param pbuf PBUF adjusted such that payload pointer points - * to the beginning of write data. In other words, - * TFTP headers are stripped off. - * @returns >= 0: Success; < 0: Error - */ - int (*write)(void* handle, struct pbuf* p); -}; - -err_t tftp_init(const struct tftp_context* ctx); -void tftp_cleanup(void); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_APPS_TFTP_SERVER_H */ +/** + * + * @file tftp_server.h + * + * @author Logan Gunthorpe + * + * @brief Trivial File Transfer Protocol (RFC 1350) + * + * Copyright (c) Deltatee Enterprises Ltd. 2013 + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Logan Gunthorpe + * + */ + +#ifndef LWIP_HDR_APPS_TFTP_SERVER_H +#define LWIP_HDR_APPS_TFTP_SERVER_H + +#include "lwip/apps/tftp_opts.h" +#include "lwip/err.h" +#include "lwip/pbuf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @ingroup tftp + * TFTP context containing callback functions for TFTP transfers + */ +struct tftp_context { + /** + * Open file for read/write. + * @param fname Filename + * @param mode Mode string from TFTP RFC 1350 (netascii, octet, mail) + * @param write Flag indicating read (0) or write (!= 0) access + * @returns File handle supplied to other functions + */ + void* (*open)(const char* fname, const char* mode, u8_t write); + /** + * Close file handle + * @param handle File handle returned by open() + */ + void (*close)(void* handle); + /** + * Read from file + * @param handle File handle returned by open() + * @param buf Target buffer to copy read data to + * @param bytes Number of bytes to copy to buf + * @returns >= 0: Success; < 0: Error + */ + int (*read)(void* handle, void* buf, int bytes); + /** + * Write to file + * @param handle File handle returned by open() + * @param pbuf PBUF adjusted such that payload pointer points + * to the beginning of write data. In other words, + * TFTP headers are stripped off. + * @returns >= 0: Success; < 0: Error + */ + int (*write)(void* handle, struct pbuf* p); +}; + +err_t tftp_init(const struct tftp_context* ctx); +void tftp_cleanup(void); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_APPS_TFTP_SERVER_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/arch.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/arch.h index d281da73..808bdff5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/arch.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/arch.h @@ -1,393 +1,394 @@ -/** - * @file - * Support for different processor and compiler architectures - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_ARCH_H -#define LWIP_HDR_ARCH_H - -#ifndef LITTLE_ENDIAN -#define LITTLE_ENDIAN 1234 -#endif - -#ifndef BIG_ENDIAN -#define BIG_ENDIAN 4321 -#endif - -#include "arch/cc.h" - -/** - * @defgroup compiler_abstraction Compiler/platform abstraction - * @ingroup sys_layer - * All defines related to this section must not be placed in lwipopts.h, - * but in arch/cc.h! - * If the compiler does not provide memset() this file must include a - * definition of it, or include a file which defines it. - * These options cannot be \#defined in lwipopts.h since they are not options - * of lwIP itself, but options of the lwIP port to your system. - * @{ - */ - -/** Define the byte order of the system. - * Needed for conversion of network data to host byte order. - * Allowed values: LITTLE_ENDIAN and BIG_ENDIAN - */ -#ifndef BYTE_ORDER -#define BYTE_ORDER LITTLE_ENDIAN -#endif - -/** Define random number generator function of your system */ -#ifdef __DOXYGEN__ -#define LWIP_RAND() ((u32_t)rand()) -#endif - -/** Platform specific diagnostic output.\n - * Note the default implementation pulls in printf, which may - * in turn pull in a lot of standard libary code. In resource-constrained - * systems, this should be defined to something less resource-consuming. - */ -#ifndef LWIP_PLATFORM_DIAG -#define LWIP_PLATFORM_DIAG(x) do {printf x;} while(0) -#include -#include -#endif - -/** Platform specific assertion handling.\n - * Note the default implementation pulls in printf, fflush and abort, which may - * in turn pull in a lot of standard libary code. In resource-constrained - * systems, this should be defined to something less resource-consuming. - */ -#ifndef LWIP_PLATFORM_ASSERT -#define LWIP_PLATFORM_ASSERT(x) do {printf("Assertion \"%s\" failed at line %d in %s\n", \ - x, __LINE__, __FILE__); fflush(NULL); abort();} while(0) -#include -#include -#endif - -/** Define this to 1 in arch/cc.h of your port if you do not want to - * include stddef.h header to get size_t. You need to typedef size_t - * by yourself in this case. - */ -#ifndef LWIP_NO_STDDEF_H -#define LWIP_NO_STDDEF_H 0 -#endif - -#if !LWIP_NO_STDDEF_H -#include /* for size_t */ -#endif - -/** Define this to 1 in arch/cc.h of your port if your compiler does not provide - * the stdint.h header. You need to typedef the generic types listed in - * lwip/arch.h yourself in this case (u8_t, u16_t...). - */ -#ifndef LWIP_NO_STDINT_H -#define LWIP_NO_STDINT_H 0 -#endif - -/* Define generic types used in lwIP */ -#if !LWIP_NO_STDINT_H -#include -/* stdint.h is C99 which should also provide support for 64-bit integers */ -#if !defined(LWIP_HAVE_INT64) && defined(UINT64_MAX) -#define LWIP_HAVE_INT64 1 -#endif -typedef uint8_t u8_t; -typedef int8_t s8_t; -typedef uint16_t u16_t; -typedef int16_t s16_t; -typedef uint32_t u32_t; -typedef int32_t s32_t; -#if LWIP_HAVE_INT64 -typedef uint64_t u64_t; -typedef int64_t s64_t; -#endif -typedef uintptr_t mem_ptr_t; -#endif - -/** Define this to 1 in arch/cc.h of your port if your compiler does not provide - * the inttypes.h header. You need to define the format strings listed in - * lwip/arch.h yourself in this case (X8_F, U16_F...). - */ -#ifndef LWIP_NO_INTTYPES_H -#define LWIP_NO_INTTYPES_H 0 -#endif - -/* Define (sn)printf formatters for these lwIP types */ -#if !LWIP_NO_INTTYPES_H -#include -#ifndef X8_F -#define X8_F "02" PRIx8 -#endif -#ifndef U16_F -#define U16_F PRIu16 -#endif -#ifndef S16_F -#define S16_F PRId16 -#endif -#ifndef X16_F -#define X16_F PRIx16 -#endif -#ifndef U32_F -#define U32_F PRIu32 -#endif -#ifndef S32_F -#define S32_F PRId32 -#endif -#ifndef X32_F -#define X32_F PRIx32 -#endif -#ifndef SZT_F -#define SZT_F PRIuPTR -#endif -#endif - -/** Define this to 1 in arch/cc.h of your port if your compiler does not provide - * the limits.h header. You need to define the type limits yourself in this case - * (e.g. INT_MAX, SSIZE_MAX). - */ -#ifndef LWIP_NO_LIMITS_H -#define LWIP_NO_LIMITS_H 0 -#endif - -/* Include limits.h? */ -#if !LWIP_NO_LIMITS_H -#include -#endif - -/* Do we need to define ssize_t? This is a compatibility hack: - * Unfortunately, this type seems to be unavailable on some systems (even if - * sys/types or unistd.h are available). - * Being like that, we define it to 'int' if SSIZE_MAX is not defined. - */ -#ifdef SSIZE_MAX -/* If SSIZE_MAX is defined, unistd.h should provide the type as well */ -#ifndef LWIP_NO_UNISTD_H -#define LWIP_NO_UNISTD_H 0 -#endif -#if !LWIP_NO_UNISTD_H -#include -#endif -#else /* SSIZE_MAX */ -typedef int ssize_t; -#define SSIZE_MAX INT_MAX -#endif /* SSIZE_MAX */ - -/* some maximum values needed in lwip code */ -#define LWIP_UINT32_MAX 0xffffffff - -/** Define this to 1 in arch/cc.h of your port if your compiler does not provide - * the ctype.h header. If ctype.h is available, a few character functions - * are mapped to the appropriate functions (lwip_islower, lwip_isdigit...), if - * not, a private implementation is provided. - */ -#ifndef LWIP_NO_CTYPE_H -#define LWIP_NO_CTYPE_H 0 -#endif - -#if LWIP_NO_CTYPE_H -#define lwip_in_range(c, lo, up) ((u8_t)(c) >= (lo) && (u8_t)(c) <= (up)) -#define lwip_isdigit(c) lwip_in_range((c), '0', '9') -#define lwip_isxdigit(c) (lwip_isdigit(c) || lwip_in_range((c), 'a', 'f') || lwip_in_range((c), 'A', 'F')) -#define lwip_islower(c) lwip_in_range((c), 'a', 'z') -#define lwip_isspace(c) ((c) == ' ' || (c) == '\f' || (c) == '\n' || (c) == '\r' || (c) == '\t' || (c) == '\v') -#define lwip_isupper(c) lwip_in_range((c), 'A', 'Z') -#define lwip_tolower(c) (lwip_isupper(c) ? (c) - 'A' + 'a' : c) -#define lwip_toupper(c) (lwip_islower(c) ? (c) - 'a' + 'A' : c) -#else -#include -#define lwip_isdigit(c) isdigit((unsigned char)(c)) -#define lwip_isxdigit(c) isxdigit((unsigned char)(c)) -#define lwip_islower(c) islower((unsigned char)(c)) -#define lwip_isspace(c) isspace((unsigned char)(c)) -#define lwip_isupper(c) isupper((unsigned char)(c)) -#define lwip_tolower(c) tolower((unsigned char)(c)) -#define lwip_toupper(c) toupper((unsigned char)(c)) -#endif - -/** C++ const_cast(val) equivalent to remove constness from a value (GCC -Wcast-qual) */ -#ifndef LWIP_CONST_CAST -#define LWIP_CONST_CAST(target_type, val) ((target_type)((ptrdiff_t)val)) -#endif - -/** Get rid of alignment cast warnings (GCC -Wcast-align) */ -#ifndef LWIP_ALIGNMENT_CAST -#define LWIP_ALIGNMENT_CAST(target_type, val) LWIP_CONST_CAST(target_type, val) -#endif - -/** Get rid of warnings related to pointer-to-numeric and vice-versa casts, - * e.g. "conversion from 'u8_t' to 'void *' of greater size" - */ -#ifndef LWIP_PTR_NUMERIC_CAST -#define LWIP_PTR_NUMERIC_CAST(target_type, val) LWIP_CONST_CAST(target_type, val) -#endif - -/** Avoid warnings/errors related to implicitly casting away packed attributes by doing a explicit cast */ -#ifndef LWIP_PACKED_CAST -#define LWIP_PACKED_CAST(target_type, val) LWIP_CONST_CAST(target_type, val) -#endif - -/** Allocates a memory buffer of specified size that is of sufficient size to align - * its start address using LWIP_MEM_ALIGN. - * You can declare your own version here e.g. to enforce alignment without adding - * trailing padding bytes (see LWIP_MEM_ALIGN_BUFFER) or your own section placement - * requirements.\n - * e.g. if you use gcc and need 32 bit alignment:\n - * \#define LWIP_DECLARE_MEMORY_ALIGNED(variable_name, size) u8_t variable_name[size] \_\_attribute\_\_((aligned(4)))\n - * or more portable:\n - * \#define LWIP_DECLARE_MEMORY_ALIGNED(variable_name, size) u32_t variable_name[(size + sizeof(u32_t) - 1) / sizeof(u32_t)] - */ -#ifndef LWIP_DECLARE_MEMORY_ALIGNED -#define LWIP_DECLARE_MEMORY_ALIGNED(variable_name, size) u8_t variable_name[LWIP_MEM_ALIGN_BUFFER(size)] -#endif - -/** Calculate memory size for an aligned buffer - returns the next highest - * multiple of MEM_ALIGNMENT (e.g. LWIP_MEM_ALIGN_SIZE(3) and - * LWIP_MEM_ALIGN_SIZE(4) will both yield 4 for MEM_ALIGNMENT == 4). - */ -#ifndef LWIP_MEM_ALIGN_SIZE -#define LWIP_MEM_ALIGN_SIZE(size) (((size) + MEM_ALIGNMENT - 1U) & ~(MEM_ALIGNMENT-1U)) -#endif - -/** Calculate safe memory size for an aligned buffer when using an unaligned - * type as storage. This includes a safety-margin on (MEM_ALIGNMENT - 1) at the - * start (e.g. if buffer is u8_t[] and actual data will be u32_t*) - */ -#ifndef LWIP_MEM_ALIGN_BUFFER -#define LWIP_MEM_ALIGN_BUFFER(size) (((size) + MEM_ALIGNMENT - 1U)) -#endif - -/** Align a memory pointer to the alignment defined by MEM_ALIGNMENT - * so that ADDR % MEM_ALIGNMENT == 0 - */ -#ifndef LWIP_MEM_ALIGN -#define LWIP_MEM_ALIGN(addr) ((void *)(((mem_ptr_t)(addr) + MEM_ALIGNMENT - 1) & ~(mem_ptr_t)(MEM_ALIGNMENT-1))) -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -/** Packed structs support. - * Placed BEFORE declaration of a packed struct.\n - * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n - * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. - */ -#ifndef PACK_STRUCT_BEGIN -#define PACK_STRUCT_BEGIN -#endif /* PACK_STRUCT_BEGIN */ - -/** Packed structs support. - * Placed AFTER declaration of a packed struct.\n - * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n - * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. - */ -#ifndef PACK_STRUCT_END -#define PACK_STRUCT_END -#endif /* PACK_STRUCT_END */ - -/** Packed structs support. - * Placed between end of declaration of a packed struct and trailing semicolon.\n - * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n - * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. - */ -#ifndef PACK_STRUCT_STRUCT -#if defined(__GNUC__) || defined(__clang__) -#define PACK_STRUCT_STRUCT __attribute__((packed)) -#else -#define PACK_STRUCT_STRUCT -#endif -#endif /* PACK_STRUCT_STRUCT */ - -/** Packed structs support. - * Wraps u32_t and u16_t members.\n - * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n - * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. - */ -#ifndef PACK_STRUCT_FIELD -#define PACK_STRUCT_FIELD(x) x -#endif /* PACK_STRUCT_FIELD */ - -/** Packed structs support. - * Wraps u8_t members, where some compilers warn that packing is not necessary.\n - * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n - * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. - */ -#ifndef PACK_STRUCT_FLD_8 -#define PACK_STRUCT_FLD_8(x) PACK_STRUCT_FIELD(x) -#endif /* PACK_STRUCT_FLD_8 */ - -/** Packed structs support. - * Wraps members that are packed structs themselves, where some compilers warn that packing is not necessary.\n - * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n - * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. - */ -#ifndef PACK_STRUCT_FLD_S -#define PACK_STRUCT_FLD_S(x) PACK_STRUCT_FIELD(x) -#endif /* PACK_STRUCT_FLD_S */ - -/** PACK_STRUCT_USE_INCLUDES==1: Packed structs support using \#include files before and after struct to be packed.\n - * The file included BEFORE the struct is "arch/bpstruct.h".\n - * The file included AFTER the struct is "arch/epstruct.h".\n - * This can be used to implement struct packing on MS Visual C compilers, see - * the Win32 port in the lwIP contrib repository for reference. - * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n - * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. - */ -#ifdef __DOXYGEN__ -#define PACK_STRUCT_USE_INCLUDES -#endif - -/** Eliminates compiler warning about unused arguments (GCC -Wextra -Wunused). */ -#ifndef LWIP_UNUSED_ARG -#define LWIP_UNUSED_ARG(x) (void)x -#endif /* LWIP_UNUSED_ARG */ - -/** LWIP_PROVIDE_ERRNO==1: Let lwIP provide ERRNO values and the 'errno' variable. - * If this is disabled, cc.h must either define 'errno', include , - * define LWIP_ERRNO_STDINCLUDE to get included or - * define LWIP_ERRNO_INCLUDE to or equivalent. - */ -#if defined __DOXYGEN__ -#define LWIP_PROVIDE_ERRNO -#endif - -/** - * @} - */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_ARCH_H */ +/** + * @file + * Support for different processor and compiler architectures + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_ARCH_H +#define LWIP_HDR_ARCH_H + +#ifndef LITTLE_ENDIAN +#define LITTLE_ENDIAN 1234 +#endif + +#ifndef BIG_ENDIAN +#define BIG_ENDIAN 4321 +#endif + +#include "arch/cc.h" + +/** + * @defgroup compiler_abstraction Compiler/platform abstraction + * @ingroup sys_layer + * All defines related to this section must not be placed in lwipopts.h, + * but in arch/cc.h! + * If the compiler does not provide memset() this file must include a + * definition of it, or include a file which defines it. + * These options cannot be \#defined in lwipopts.h since they are not options + * of lwIP itself, but options of the lwIP port to your system. + * @{ + */ + +/** Define the byte order of the system. + * Needed for conversion of network data to host byte order. + * Allowed values: LITTLE_ENDIAN and BIG_ENDIAN + */ +#ifndef BYTE_ORDER +#define BYTE_ORDER LITTLE_ENDIAN +#endif + +/** Define random number generator function of your system */ +#ifdef __DOXYGEN__ +#define LWIP_RAND() ((u32_t)rand()) +#endif + +/** Platform specific diagnostic output.\n + * Note the default implementation pulls in printf, which may + * in turn pull in a lot of standard libary code. In resource-constrained + * systems, this should be defined to something less resource-consuming. + */ +#ifndef LWIP_PLATFORM_DIAG +#include "xs_base.h" +#define LWIP_PLATFORM_DIAG(x) do {KPrintf x;} while(0) +#include +#include +#endif + +/** Platform specific assertion handling.\n + * Note the default implementation pulls in printf, fflush and abort, which may + * in turn pull in a lot of standard libary code. In resource-constrained + * systems, this should be defined to something less resource-consuming. + */ +#ifndef LWIP_PLATFORM_ASSERT +#define LWIP_PLATFORM_ASSERT(x) do {KPrintf("Assertion \"%s\" failed at line %d in %s\n", \ + x, __LINE__, __FILE__); fflush(NULL); abort();} while(0) +#include +#include +#endif + +/** Define this to 1 in arch/cc.h of your port if you do not want to + * include stddef.h header to get size_t. You need to typedef size_t + * by yourself in this case. + */ +#ifndef LWIP_NO_STDDEF_H +#define LWIP_NO_STDDEF_H 0 +#endif + +#if !LWIP_NO_STDDEF_H +#include /* for size_t */ +#endif + +/** Define this to 1 in arch/cc.h of your port if your compiler does not provide + * the stdint.h header. You need to typedef the generic types listed in + * lwip/arch.h yourself in this case (u8_t, u16_t...). + */ +#ifndef LWIP_NO_STDINT_H +#define LWIP_NO_STDINT_H 0 +#endif + +/* Define generic types used in lwIP */ +#if !LWIP_NO_STDINT_H +#include +/* stdint.h is C99 which should also provide support for 64-bit integers */ +#if !defined(LWIP_HAVE_INT64) && defined(UINT64_MAX) +#define LWIP_HAVE_INT64 1 +#endif +typedef uint8_t u8_t; +typedef int8_t s8_t; +typedef uint16_t u16_t; +typedef int16_t s16_t; +typedef uint32_t u32_t; +typedef int32_t s32_t; +#if LWIP_HAVE_INT64 +typedef uint64_t u64_t; +typedef int64_t s64_t; +#endif +typedef uintptr_t mem_ptr_t; +#endif + +/** Define this to 1 in arch/cc.h of your port if your compiler does not provide + * the inttypes.h header. You need to define the format strings listed in + * lwip/arch.h yourself in this case (X8_F, U16_F...). + */ +#ifndef LWIP_NO_INTTYPES_H +#define LWIP_NO_INTTYPES_H 0 +#endif + +/* Define (sn)printf formatters for these lwIP types */ +#if !LWIP_NO_INTTYPES_H +#include +#ifndef X8_F +#define X8_F "02" PRIx8 +#endif +#ifndef U16_F +#define U16_F PRIu16 +#endif +#ifndef S16_F +#define S16_F PRId16 +#endif +#ifndef X16_F +#define X16_F PRIx16 +#endif +#ifndef U32_F +#define U32_F PRIu32 +#endif +#ifndef S32_F +#define S32_F PRId32 +#endif +#ifndef X32_F +#define X32_F PRIx32 +#endif +#ifndef SZT_F +#define SZT_F PRIuPTR +#endif +#endif + +/** Define this to 1 in arch/cc.h of your port if your compiler does not provide + * the limits.h header. You need to define the type limits yourself in this case + * (e.g. INT_MAX, SSIZE_MAX). + */ +#ifndef LWIP_NO_LIMITS_H +#define LWIP_NO_LIMITS_H 0 +#endif + +/* Include limits.h? */ +#if !LWIP_NO_LIMITS_H +#include +#endif + +/* Do we need to define ssize_t? This is a compatibility hack: + * Unfortunately, this type seems to be unavailable on some systems (even if + * sys/types or unistd.h are available). + * Being like that, we define it to 'int' if SSIZE_MAX is not defined. + */ +#ifdef SSIZE_MAX +/* If SSIZE_MAX is defined, unistd.h should provide the type as well */ +#ifndef LWIP_NO_UNISTD_H +#define LWIP_NO_UNISTD_H 0 +#endif +#if !LWIP_NO_UNISTD_H +#include +#endif +#else /* SSIZE_MAX */ +typedef int ssize_t; +#define SSIZE_MAX INT_MAX +#endif /* SSIZE_MAX */ + +/* some maximum values needed in lwip code */ +#define LWIP_UINT32_MAX 0xffffffff + +/** Define this to 1 in arch/cc.h of your port if your compiler does not provide + * the ctype.h header. If ctype.h is available, a few character functions + * are mapped to the appropriate functions (lwip_islower, lwip_isdigit...), if + * not, a private implementation is provided. + */ +#ifndef LWIP_NO_CTYPE_H +#define LWIP_NO_CTYPE_H 0 +#endif + +#if LWIP_NO_CTYPE_H +#define lwip_in_range(c, lo, up) ((u8_t)(c) >= (lo) && (u8_t)(c) <= (up)) +#define lwip_isdigit(c) lwip_in_range((c), '0', '9') +#define lwip_isxdigit(c) (lwip_isdigit(c) || lwip_in_range((c), 'a', 'f') || lwip_in_range((c), 'A', 'F')) +#define lwip_islower(c) lwip_in_range((c), 'a', 'z') +#define lwip_isspace(c) ((c) == ' ' || (c) == '\f' || (c) == '\n' || (c) == '\r' || (c) == '\t' || (c) == '\v') +#define lwip_isupper(c) lwip_in_range((c), 'A', 'Z') +#define lwip_tolower(c) (lwip_isupper(c) ? (c) - 'A' + 'a' : c) +#define lwip_toupper(c) (lwip_islower(c) ? (c) - 'a' + 'A' : c) +#else +#include +#define lwip_isdigit(c) isdigit((unsigned char)(c)) +#define lwip_isxdigit(c) isxdigit((unsigned char)(c)) +#define lwip_islower(c) islower((unsigned char)(c)) +#define lwip_isspace(c) isspace((unsigned char)(c)) +#define lwip_isupper(c) isupper((unsigned char)(c)) +#define lwip_tolower(c) tolower((unsigned char)(c)) +#define lwip_toupper(c) toupper((unsigned char)(c)) +#endif + +/** C++ const_cast(val) equivalent to remove constness from a value (GCC -Wcast-qual) */ +#ifndef LWIP_CONST_CAST +#define LWIP_CONST_CAST(target_type, val) ((target_type)((ptrdiff_t)val)) +#endif + +/** Get rid of alignment cast warnings (GCC -Wcast-align) */ +#ifndef LWIP_ALIGNMENT_CAST +#define LWIP_ALIGNMENT_CAST(target_type, val) LWIP_CONST_CAST(target_type, val) +#endif + +/** Get rid of warnings related to pointer-to-numeric and vice-versa casts, + * e.g. "conversion from 'u8_t' to 'void *' of greater size" + */ +#ifndef LWIP_PTR_NUMERIC_CAST +#define LWIP_PTR_NUMERIC_CAST(target_type, val) LWIP_CONST_CAST(target_type, val) +#endif + +/** Avoid warnings/errors related to implicitly casting away packed attributes by doing a explicit cast */ +#ifndef LWIP_PACKED_CAST +#define LWIP_PACKED_CAST(target_type, val) LWIP_CONST_CAST(target_type, val) +#endif + +/** Allocates a memory buffer of specified size that is of sufficient size to align + * its start address using LWIP_MEM_ALIGN. + * You can declare your own version here e.g. to enforce alignment without adding + * trailing padding bytes (see LWIP_MEM_ALIGN_BUFFER) or your own section placement + * requirements.\n + * e.g. if you use gcc and need 32 bit alignment:\n + * \#define LWIP_DECLARE_MEMORY_ALIGNED(variable_name, size) u8_t variable_name[size] \_\_attribute\_\_((aligned(4)))\n + * or more portable:\n + * \#define LWIP_DECLARE_MEMORY_ALIGNED(variable_name, size) u32_t variable_name[(size + sizeof(u32_t) - 1) / sizeof(u32_t)] + */ +#ifndef LWIP_DECLARE_MEMORY_ALIGNED +#define LWIP_DECLARE_MEMORY_ALIGNED(variable_name, size) u8_t variable_name[LWIP_MEM_ALIGN_BUFFER(size)] +#endif + +/** Calculate memory size for an aligned buffer - returns the next highest + * multiple of MEM_ALIGNMENT (e.g. LWIP_MEM_ALIGN_SIZE(3) and + * LWIP_MEM_ALIGN_SIZE(4) will both yield 4 for MEM_ALIGNMENT == 4). + */ +#ifndef LWIP_MEM_ALIGN_SIZE +#define LWIP_MEM_ALIGN_SIZE(size) (((size) + MEM_ALIGNMENT - 1U) & ~(MEM_ALIGNMENT-1U)) +#endif + +/** Calculate safe memory size for an aligned buffer when using an unaligned + * type as storage. This includes a safety-margin on (MEM_ALIGNMENT - 1) at the + * start (e.g. if buffer is u8_t[] and actual data will be u32_t*) + */ +#ifndef LWIP_MEM_ALIGN_BUFFER +#define LWIP_MEM_ALIGN_BUFFER(size) (((size) + MEM_ALIGNMENT - 1U)) +#endif + +/** Align a memory pointer to the alignment defined by MEM_ALIGNMENT + * so that ADDR % MEM_ALIGNMENT == 0 + */ +#ifndef LWIP_MEM_ALIGN +#define LWIP_MEM_ALIGN(addr) ((void *)(((mem_ptr_t)(addr) + MEM_ALIGNMENT - 1) & ~(mem_ptr_t)(MEM_ALIGNMENT-1))) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** Packed structs support. + * Placed BEFORE declaration of a packed struct.\n + * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n + * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. + */ +#ifndef PACK_STRUCT_BEGIN +#define PACK_STRUCT_BEGIN +#endif /* PACK_STRUCT_BEGIN */ + +/** Packed structs support. + * Placed AFTER declaration of a packed struct.\n + * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n + * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. + */ +#ifndef PACK_STRUCT_END +#define PACK_STRUCT_END +#endif /* PACK_STRUCT_END */ + +/** Packed structs support. + * Placed between end of declaration of a packed struct and trailing semicolon.\n + * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n + * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. + */ +#ifndef PACK_STRUCT_STRUCT +#if defined(__GNUC__) || defined(__clang__) +#define PACK_STRUCT_STRUCT __attribute__((packed)) +#else +#define PACK_STRUCT_STRUCT +#endif +#endif /* PACK_STRUCT_STRUCT */ + +/** Packed structs support. + * Wraps u32_t and u16_t members.\n + * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n + * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. + */ +#ifndef PACK_STRUCT_FIELD +#define PACK_STRUCT_FIELD(x) x +#endif /* PACK_STRUCT_FIELD */ + +/** Packed structs support. + * Wraps u8_t members, where some compilers warn that packing is not necessary.\n + * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n + * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. + */ +#ifndef PACK_STRUCT_FLD_8 +#define PACK_STRUCT_FLD_8(x) PACK_STRUCT_FIELD(x) +#endif /* PACK_STRUCT_FLD_8 */ + +/** Packed structs support. + * Wraps members that are packed structs themselves, where some compilers warn that packing is not necessary.\n + * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n + * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. + */ +#ifndef PACK_STRUCT_FLD_S +#define PACK_STRUCT_FLD_S(x) PACK_STRUCT_FIELD(x) +#endif /* PACK_STRUCT_FLD_S */ + +/** PACK_STRUCT_USE_INCLUDES==1: Packed structs support using \#include files before and after struct to be packed.\n + * The file included BEFORE the struct is "arch/bpstruct.h".\n + * The file included AFTER the struct is "arch/epstruct.h".\n + * This can be used to implement struct packing on MS Visual C compilers, see + * the Win32 port in the lwIP contrib repository for reference. + * For examples of packed struct declarations, see include/lwip/prot/ subfolder.\n + * A port to GCC/clang is included in lwIP, if you use these compilers there is nothing to do here. + */ +#ifdef __DOXYGEN__ +#define PACK_STRUCT_USE_INCLUDES +#endif + +/** Eliminates compiler warning about unused arguments (GCC -Wextra -Wunused). */ +#ifndef LWIP_UNUSED_ARG +#define LWIP_UNUSED_ARG(x) (void)x +#endif /* LWIP_UNUSED_ARG */ + +/** LWIP_PROVIDE_ERRNO==1: Let lwIP provide ERRNO values and the 'errno' variable. + * If this is disabled, cc.h must either define 'errno', include , + * define LWIP_ERRNO_STDINCLUDE to get included or + * define LWIP_ERRNO_INCLUDE to or equivalent. + */ +#if defined __DOXYGEN__ +#define LWIP_PROVIDE_ERRNO +#endif + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_ARCH_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/autoip.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/autoip.h index 5c6d13e7..1d85bccf 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/autoip.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/autoip.h @@ -1,99 +1,99 @@ -/** - * @file - * - * AutoIP Automatic LinkLocal IP Configuration - */ - -/* - * - * Copyright (c) 2007 Dominik Spies - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dominik Spies - * - * This is a AutoIP implementation for the lwIP TCP/IP stack. It aims to conform - * with RFC 3927. - * - */ - -#ifndef LWIP_HDR_AUTOIP_H -#define LWIP_HDR_AUTOIP_H - -#include "lwip/opt.h" - -#if LWIP_IPV4 && LWIP_AUTOIP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/netif.h" -/* #include "lwip/udp.h" */ -#include "lwip/etharp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** AutoIP Timing */ -#define AUTOIP_TMR_INTERVAL 100 -#define AUTOIP_TICKS_PER_SECOND (1000 / AUTOIP_TMR_INTERVAL) - -/** AutoIP state information per netif */ -struct autoip -{ - /** the currently selected, probed, announced or used LL IP-Address */ - ip4_addr_t llipaddr; - /** current AutoIP state machine state */ - u8_t state; - /** sent number of probes or announces, dependent on state */ - u8_t sent_num; - /** ticks to wait, tick is AUTOIP_TMR_INTERVAL long */ - u16_t ttw; - /** ticks until a conflict can be solved by defending */ - u8_t lastconflict; - /** total number of probed/used Link Local IP-Addresses */ - u8_t tried_llipaddr; -}; - - -void autoip_set_struct(struct netif *netif, struct autoip *autoip); -/** Remove a struct autoip previously set to the netif using autoip_set_struct() */ -#define autoip_remove_struct(netif) do { (netif)->autoip = NULL; } while (0) -err_t autoip_start(struct netif *netif); -err_t autoip_stop(struct netif *netif); -void autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr); -void autoip_tmr(void); -void autoip_network_changed(struct netif *netif); -u8_t autoip_supplied_address(const struct netif *netif); - -/* for lwIP internal use by ip4.c */ -u8_t autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr); - -#define netif_autoip_data(netif) ((struct autoip*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV4 && LWIP_AUTOIP */ - -#endif /* LWIP_HDR_AUTOIP_H */ +/** + * @file + * + * AutoIP Automatic LinkLocal IP Configuration + */ + +/* + * + * Copyright (c) 2007 Dominik Spies + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dominik Spies + * + * This is a AutoIP implementation for the lwIP TCP/IP stack. It aims to conform + * with RFC 3927. + * + */ + +#ifndef LWIP_HDR_AUTOIP_H +#define LWIP_HDR_AUTOIP_H + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_AUTOIP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/netif.h" +/* #include "lwip/udp.h" */ +#include "lwip/etharp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** AutoIP Timing */ +#define AUTOIP_TMR_INTERVAL 100 +#define AUTOIP_TICKS_PER_SECOND (1000 / AUTOIP_TMR_INTERVAL) + +/** AutoIP state information per netif */ +struct autoip +{ + /** the currently selected, probed, announced or used LL IP-Address */ + ip4_addr_t llipaddr; + /** current AutoIP state machine state */ + u8_t state; + /** sent number of probes or announces, dependent on state */ + u8_t sent_num; + /** ticks to wait, tick is AUTOIP_TMR_INTERVAL long */ + u16_t ttw; + /** ticks until a conflict can be solved by defending */ + u8_t lastconflict; + /** total number of probed/used Link Local IP-Addresses */ + u8_t tried_llipaddr; +}; + + +void autoip_set_struct(struct netif *netif, struct autoip *autoip); +/** Remove a struct autoip previously set to the netif using autoip_set_struct() */ +#define autoip_remove_struct(netif) do { (netif)->autoip = NULL; } while (0) +err_t autoip_start(struct netif *netif); +err_t autoip_stop(struct netif *netif); +void autoip_arp_reply(struct netif *netif, struct etharp_hdr *hdr); +void autoip_tmr(void); +void autoip_network_changed(struct netif *netif); +u8_t autoip_supplied_address(const struct netif *netif); + +/* for lwIP internal use by ip4.c */ +u8_t autoip_accept_packet(struct netif *netif, const ip4_addr_t *addr); + +#define netif_autoip_data(netif) ((struct autoip*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV4 && LWIP_AUTOIP */ + +#endif /* LWIP_HDR_AUTOIP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/debug.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/debug.h index 346ac47d..baa6a409 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/debug.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/debug.h @@ -1,161 +1,161 @@ -/** - * @file - * Debug messages infrastructure - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_DEBUG_H -#define LWIP_HDR_DEBUG_H - -#include "lwip/arch.h" -#include "lwip/opt.h" - -/** - * @defgroup debugging_levels LWIP_DBG_MIN_LEVEL and LWIP_DBG_TYPES_ON values - * @ingroup lwip_opts_debugmsg - * @{ - */ - -/** @name Debug level (LWIP_DBG_MIN_LEVEL) - * @{ - */ -/** Debug level: ALL messages*/ -#define LWIP_DBG_LEVEL_ALL 0x00 -/** Debug level: Warnings. bad checksums, dropped packets, ... */ -#define LWIP_DBG_LEVEL_WARNING 0x01 -/** Debug level: Serious. memory allocation failures, ... */ -#define LWIP_DBG_LEVEL_SERIOUS 0x02 -/** Debug level: Severe */ -#define LWIP_DBG_LEVEL_SEVERE 0x03 -/** - * @} - */ - -#define LWIP_DBG_MASK_LEVEL 0x03 -/* compatibility define only */ -#define LWIP_DBG_LEVEL_OFF LWIP_DBG_LEVEL_ALL - -/** @name Enable/disable debug messages completely (LWIP_DBG_TYPES_ON) - * @{ - */ -/** flag for LWIP_DEBUGF to enable that debug message */ -#define LWIP_DBG_ON 0x80U -/** flag for LWIP_DEBUGF to disable that debug message */ -#define LWIP_DBG_OFF 0x00U -/** - * @} - */ - -/** @name Debug message types (LWIP_DBG_TYPES_ON) - * @{ - */ -/** flag for LWIP_DEBUGF indicating a tracing message (to follow program flow) */ -#define LWIP_DBG_TRACE 0x40U -/** flag for LWIP_DEBUGF indicating a state debug message (to follow module states) */ -#define LWIP_DBG_STATE 0x20U -/** flag for LWIP_DEBUGF indicating newly added code, not thoroughly tested yet */ -#define LWIP_DBG_FRESH 0x10U -/** flag for LWIP_DEBUGF to halt after printing this debug message */ -#define LWIP_DBG_HALT 0x08U -/** - * @} - */ - -/** - * @} - */ - -/** - * @defgroup lwip_assertions Assertion handling - * @ingroup lwip_opts_debug - * @{ - */ -/** - * LWIP_NOASSERT: Disable LWIP_ASSERT checks: - * To disable assertions define LWIP_NOASSERT in arch/cc.h. - */ -#ifdef __DOXYGEN__ -#define LWIP_NOASSERT -#undef LWIP_NOASSERT -#endif -/** - * @} - */ - -#ifndef LWIP_NOASSERT -#define LWIP_ASSERT(message, assertion) do { if (!(assertion)) { \ - LWIP_PLATFORM_ASSERT(message); }} while(0) -#else /* LWIP_NOASSERT */ -#define LWIP_ASSERT(message, assertion) -#endif /* LWIP_NOASSERT */ - -#ifndef LWIP_ERROR -#ifndef LWIP_NOASSERT -#define LWIP_PLATFORM_ERROR(message) LWIP_PLATFORM_ASSERT(message) -#elif defined LWIP_DEBUG -#define LWIP_PLATFORM_ERROR(message) LWIP_PLATFORM_DIAG((message)) -#else -#define LWIP_PLATFORM_ERROR(message) -#endif - -/* if "expression" isn't true, then print "message" and execute "handler" expression */ -#define LWIP_ERROR(message, expression, handler) do { if (!(expression)) { \ - LWIP_PLATFORM_ERROR(message); handler;}} while(0) -#endif /* LWIP_ERROR */ - -/** Enable debug message printing, but only if debug message type is enabled - * AND is of correct type AND is at least LWIP_DBG_LEVEL. - */ -#ifdef __DOXYGEN__ -#define LWIP_DEBUG -#undef LWIP_DEBUG -#endif - -#ifdef LWIP_DEBUG -#define LWIP_DEBUGF(debug, message) do { \ - if ( \ - ((debug) & LWIP_DBG_ON) && \ - ((debug) & LWIP_DBG_TYPES_ON) && \ - ((s16_t)((debug) & LWIP_DBG_MASK_LEVEL) >= LWIP_DBG_MIN_LEVEL)) { \ - LWIP_PLATFORM_DIAG(message); \ - if ((debug) & LWIP_DBG_HALT) { \ - while(1); \ - } \ - } \ - } while(0) - -#else /* LWIP_DEBUG */ -#define LWIP_DEBUGF(debug, message) -#endif /* LWIP_DEBUG */ - -#endif /* LWIP_HDR_DEBUG_H */ +/** + * @file + * Debug messages infrastructure + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_DEBUG_H +#define LWIP_HDR_DEBUG_H + +#include "lwip/arch.h" +#include "lwip/opt.h" + +/** + * @defgroup debugging_levels LWIP_DBG_MIN_LEVEL and LWIP_DBG_TYPES_ON values + * @ingroup lwip_opts_debugmsg + * @{ + */ + +/** @name Debug level (LWIP_DBG_MIN_LEVEL) + * @{ + */ +/** Debug level: ALL messages*/ +#define LWIP_DBG_LEVEL_ALL 0x00 +/** Debug level: Warnings. bad checksums, dropped packets, ... */ +#define LWIP_DBG_LEVEL_WARNING 0x01 +/** Debug level: Serious. memory allocation failures, ... */ +#define LWIP_DBG_LEVEL_SERIOUS 0x02 +/** Debug level: Severe */ +#define LWIP_DBG_LEVEL_SEVERE 0x03 +/** + * @} + */ + +#define LWIP_DBG_MASK_LEVEL 0x03 +/* compatibility define only */ +#define LWIP_DBG_LEVEL_OFF LWIP_DBG_LEVEL_ALL + +/** @name Enable/disable debug messages completely (LWIP_DBG_TYPES_ON) + * @{ + */ +/** flag for LWIP_DEBUGF to enable that debug message */ +#define LWIP_DBG_ON 0x80U +/** flag for LWIP_DEBUGF to disable that debug message */ +#define LWIP_DBG_OFF 0x00U +/** + * @} + */ + +/** @name Debug message types (LWIP_DBG_TYPES_ON) + * @{ + */ +/** flag for LWIP_DEBUGF indicating a tracing message (to follow program flow) */ +#define LWIP_DBG_TRACE 0x40U +/** flag for LWIP_DEBUGF indicating a state debug message (to follow module states) */ +#define LWIP_DBG_STATE 0x20U +/** flag for LWIP_DEBUGF indicating newly added code, not thoroughly tested yet */ +#define LWIP_DBG_FRESH 0x10U +/** flag for LWIP_DEBUGF to halt after printing this debug message */ +#define LWIP_DBG_HALT 0x08U +/** + * @} + */ + +/** + * @} + */ + +/** + * @defgroup lwip_assertions Assertion handling + * @ingroup lwip_opts_debug + * @{ + */ +/** + * LWIP_NOASSERT: Disable LWIP_ASSERT checks: + * To disable assertions define LWIP_NOASSERT in arch/cc.h. + */ +#ifdef __DOXYGEN__ +#define LWIP_NOASSERT +#undef LWIP_NOASSERT +#endif +/** + * @} + */ + +#ifndef LWIP_NOASSERT +#define LWIP_ASSERT(message, assertion) do { if (!(assertion)) { \ + LWIP_PLATFORM_ASSERT(message); }} while(0) +#else /* LWIP_NOASSERT */ +#define LWIP_ASSERT(message, assertion) +#endif /* LWIP_NOASSERT */ + +#ifndef LWIP_ERROR +#ifndef LWIP_NOASSERT +#define LWIP_PLATFORM_ERROR(message) LWIP_PLATFORM_ASSERT(message) +#elif defined LWIP_DEBUG +#define LWIP_PLATFORM_ERROR(message) LWIP_PLATFORM_DIAG((message)) +#else +#define LWIP_PLATFORM_ERROR(message) +#endif + +/* if "expression" isn't true, then print "message" and execute "handler" expression */ +#define LWIP_ERROR(message, expression, handler) do { if (!(expression)) { \ + LWIP_PLATFORM_ERROR(message); handler;}} while(0) +#endif /* LWIP_ERROR */ + +/** Enable debug message printing, but only if debug message type is enabled + * AND is of correct type AND is at least LWIP_DBG_LEVEL. + */ +#ifdef __DOXYGEN__ +#define LWIP_DEBUG +#undef LWIP_DEBUG +#endif + +#ifdef LWIP_DEBUG +#define LWIP_DEBUGF(debug, message) do { \ + if ( \ + ((debug) & LWIP_DBG_ON) && \ + ((debug) & LWIP_DBG_TYPES_ON) && \ + ((s16_t)((debug) & LWIP_DBG_MASK_LEVEL) >= LWIP_DBG_MIN_LEVEL)) { \ + LWIP_PLATFORM_DIAG(message); \ + if ((debug) & LWIP_DBG_HALT) { \ + while(1); \ + } \ + } \ + } while(0) + +#else /* LWIP_DEBUG */ +#define LWIP_DEBUGF(debug, message) +#endif /* LWIP_DEBUG */ + +#endif /* LWIP_HDR_DEBUG_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/def.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/def.h index 10b5ac26..dfb266d1 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/def.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/def.h @@ -1,152 +1,152 @@ -/** - * @file - * various utility macros - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -/** - * @defgroup perf Performance measurement - * @ingroup sys_layer - * All defines related to this section must not be placed in lwipopts.h, - * but in arch/perf.h! - * Measurement calls made throughout lwip, these can be defined to nothing. - * - PERF_START: start measuring something. - * - PERF_STOP(x): stop measuring something, and record the result. - */ - -#ifndef LWIP_HDR_DEF_H -#define LWIP_HDR_DEF_H - -/* arch.h might define NULL already */ -#include "lwip/arch.h" -#include "lwip/opt.h" -#if LWIP_PERF -#include "arch/perf.h" -#else /* LWIP_PERF */ -#define PERF_START /* null definition */ -#define PERF_STOP(x) /* null definition */ -#endif /* LWIP_PERF */ - -#ifdef __cplusplus -extern "C" { -#endif - -#define LWIP_MAX(x , y) (((x) > (y)) ? (x) : (y)) -#define LWIP_MIN(x , y) (((x) < (y)) ? (x) : (y)) - -/* Get the number of entries in an array ('x' must NOT be a pointer!) */ -#define LWIP_ARRAYSIZE(x) (sizeof(x)/sizeof((x)[0])) - -/** Create u32_t value from bytes */ -#define LWIP_MAKEU32(a,b,c,d) (((u32_t)((a) & 0xff) << 24) | \ - ((u32_t)((b) & 0xff) << 16) | \ - ((u32_t)((c) & 0xff) << 8) | \ - (u32_t)((d) & 0xff)) - -#ifndef NULL -#ifdef __cplusplus -#define NULL 0 -#else -#define NULL ((void *)0) -#endif -#endif - -#if BYTE_ORDER == BIG_ENDIAN -#define lwip_htons(x) ((u16_t)(x)) -#define lwip_ntohs(x) ((u16_t)(x)) -#define lwip_htonl(x) ((u32_t)(x)) -#define lwip_ntohl(x) ((u32_t)(x)) -#define PP_HTONS(x) ((u16_t)(x)) -#define PP_NTOHS(x) ((u16_t)(x)) -#define PP_HTONL(x) ((u32_t)(x)) -#define PP_NTOHL(x) ((u32_t)(x)) -#else /* BYTE_ORDER != BIG_ENDIAN */ -#ifndef lwip_htons -u16_t lwip_htons(u16_t x); -#endif -#define lwip_ntohs(x) lwip_htons(x) - -#ifndef lwip_htonl -u32_t lwip_htonl(u32_t x); -#endif -#define lwip_ntohl(x) lwip_htonl(x) - -/* These macros should be calculated by the preprocessor and are used - with compile-time constants only (so that there is no little-endian - overhead at runtime). */ -#define PP_HTONS(x) ((u16_t)((((x) & (u16_t)0x00ffU) << 8) | (((x) & (u16_t)0xff00U) >> 8))) -#define PP_NTOHS(x) PP_HTONS(x) -#define PP_HTONL(x) ((((x) & (u32_t)0x000000ffUL) << 24) | \ - (((x) & (u32_t)0x0000ff00UL) << 8) | \ - (((x) & (u32_t)0x00ff0000UL) >> 8) | \ - (((x) & (u32_t)0xff000000UL) >> 24)) -#define PP_NTOHL(x) PP_HTONL(x) -#endif /* BYTE_ORDER == BIG_ENDIAN */ - -/* Provide usual function names as macros for users, but this can be turned off */ -#ifndef LWIP_DONT_PROVIDE_BYTEORDER_FUNCTIONS -#define htons(x) lwip_htons(x) -#define ntohs(x) lwip_ntohs(x) -#define htonl(x) lwip_htonl(x) -#define ntohl(x) lwip_ntohl(x) -#endif - -/* Functions that are not available as standard implementations. - * In cc.h, you can #define these to implementations available on - * your platform to save some code bytes if you use these functions - * in your application, too. - */ - -#ifndef lwip_itoa -/* This can be #defined to itoa() or snprintf(result, bufsize, "%d", number) depending on your platform */ -void lwip_itoa(char* result, size_t bufsize, int number); -#endif -#ifndef lwip_strnicmp -/* This can be #defined to strnicmp() or strncasecmp() depending on your platform */ -int lwip_strnicmp(const char* str1, const char* str2, size_t len); -#endif -#ifndef lwip_stricmp -/* This can be #defined to stricmp() or strcasecmp() depending on your platform */ -int lwip_stricmp(const char* str1, const char* str2); -#endif -#ifndef lwip_strnstr -/* This can be #defined to strnstr() depending on your platform */ -char* lwip_strnstr(const char* buffer, const char* token, size_t n); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_DEF_H */ +/** + * @file + * various utility macros + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/** + * @defgroup perf Performance measurement + * @ingroup sys_layer + * All defines related to this section must not be placed in lwipopts.h, + * but in arch/perf.h! + * Measurement calls made throughout lwip, these can be defined to nothing. + * - PERF_START: start measuring something. + * - PERF_STOP(x): stop measuring something, and record the result. + */ + +#ifndef LWIP_HDR_DEF_H +#define LWIP_HDR_DEF_H + +/* arch.h might define NULL already */ +#include "lwip/arch.h" +#include "lwip/opt.h" +#if LWIP_PERF +#include "arch/perf.h" +#else /* LWIP_PERF */ +#define PERF_START /* null definition */ +#define PERF_STOP(x) /* null definition */ +#endif /* LWIP_PERF */ + +#ifdef __cplusplus +extern "C" { +#endif + +#define LWIP_MAX(x , y) (((x) > (y)) ? (x) : (y)) +#define LWIP_MIN(x , y) (((x) < (y)) ? (x) : (y)) + +/* Get the number of entries in an array ('x' must NOT be a pointer!) */ +#define LWIP_ARRAYSIZE(x) (sizeof(x)/sizeof((x)[0])) + +/** Create u32_t value from bytes */ +#define LWIP_MAKEU32(a,b,c,d) (((u32_t)((a) & 0xff) << 24) | \ + ((u32_t)((b) & 0xff) << 16) | \ + ((u32_t)((c) & 0xff) << 8) | \ + (u32_t)((d) & 0xff)) + +#ifndef NULL +#ifdef __cplusplus +#define NULL 0 +#else +#define NULL ((void *)0) +#endif +#endif + +#if BYTE_ORDER == BIG_ENDIAN +#define lwip_htons(x) ((u16_t)(x)) +#define lwip_ntohs(x) ((u16_t)(x)) +#define lwip_htonl(x) ((u32_t)(x)) +#define lwip_ntohl(x) ((u32_t)(x)) +#define PP_HTONS(x) ((u16_t)(x)) +#define PP_NTOHS(x) ((u16_t)(x)) +#define PP_HTONL(x) ((u32_t)(x)) +#define PP_NTOHL(x) ((u32_t)(x)) +#else /* BYTE_ORDER != BIG_ENDIAN */ +#ifndef lwip_htons +u16_t lwip_htons(u16_t x); +#endif +#define lwip_ntohs(x) lwip_htons(x) + +#ifndef lwip_htonl +u32_t lwip_htonl(u32_t x); +#endif +#define lwip_ntohl(x) lwip_htonl(x) + +/* These macros should be calculated by the preprocessor and are used + with compile-time constants only (so that there is no little-endian + overhead at runtime). */ +#define PP_HTONS(x) ((u16_t)((((x) & (u16_t)0x00ffU) << 8) | (((x) & (u16_t)0xff00U) >> 8))) +#define PP_NTOHS(x) PP_HTONS(x) +#define PP_HTONL(x) ((((x) & (u32_t)0x000000ffUL) << 24) | \ + (((x) & (u32_t)0x0000ff00UL) << 8) | \ + (((x) & (u32_t)0x00ff0000UL) >> 8) | \ + (((x) & (u32_t)0xff000000UL) >> 24)) +#define PP_NTOHL(x) PP_HTONL(x) +#endif /* BYTE_ORDER == BIG_ENDIAN */ + +/* Provide usual function names as macros for users, but this can be turned off */ +#ifndef LWIP_DONT_PROVIDE_BYTEORDER_FUNCTIONS +#define htons(x) lwip_htons(x) +#define ntohs(x) lwip_ntohs(x) +#define htonl(x) lwip_htonl(x) +#define ntohl(x) lwip_ntohl(x) +#endif + +/* Functions that are not available as standard implementations. + * In cc.h, you can #define these to implementations available on + * your platform to save some code bytes if you use these functions + * in your application, too. + */ + +#ifndef lwip_itoa +/* This can be #defined to itoa() or snprintf(result, bufsize, "%d", number) depending on your platform */ +void lwip_itoa(char* result, size_t bufsize, int number); +#endif +#ifndef lwip_strnicmp +/* This can be #defined to strnicmp() or strncasecmp() depending on your platform */ +int lwip_strnicmp(const char* str1, const char* str2, size_t len); +#endif +#ifndef lwip_stricmp +/* This can be #defined to stricmp() or strcasecmp() depending on your platform */ +int lwip_stricmp(const char* str1, const char* str2); +#endif +#ifndef lwip_strnstr +/* This can be #defined to strnstr() depending on your platform */ +char* lwip_strnstr(const char* buffer, const char* token, size_t n); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_DEF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp.h index a965efd9..c78aa0ba 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp.h @@ -1,139 +1,139 @@ -/** - * @file - * DHCP client API - */ - -/* - * Copyright (c) 2001-2004 Leon Woestenberg - * Copyright (c) 2001-2004 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Leon Woestenberg - * - */ -#ifndef LWIP_HDR_DHCP_H -#define LWIP_HDR_DHCP_H - -#include "lwip/opt.h" - -#if LWIP_DHCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/netif.h" -#include "lwip/udp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** period (in seconds) of the application calling dhcp_coarse_tmr() */ -#define DHCP_COARSE_TIMER_SECS 60 -/** period (in milliseconds) of the application calling dhcp_coarse_tmr() */ -#define DHCP_COARSE_TIMER_MSECS (DHCP_COARSE_TIMER_SECS * 1000UL) -/** period (in milliseconds) of the application calling dhcp_fine_tmr() */ -#define DHCP_FINE_TIMER_MSECS 500 - -#define DHCP_BOOT_FILE_LEN 128U - -/* AutoIP cooperation flags (struct dhcp.autoip_coop_state) */ -typedef enum { - DHCP_AUTOIP_COOP_STATE_OFF = 0, - DHCP_AUTOIP_COOP_STATE_ON = 1 -} dhcp_autoip_coop_state_enum_t; - -struct dhcp -{ - /** transaction identifier of last sent request */ - u32_t xid; - /** track PCB allocation state */ - u8_t pcb_allocated; - /** current DHCP state machine state */ - u8_t state; - /** retries of current request */ - u8_t tries; -#if LWIP_DHCP_AUTOIP_COOP - u8_t autoip_coop_state; -#endif - u8_t subnet_mask_given; - - u16_t request_timeout; /* #ticks with period DHCP_FINE_TIMER_SECS for request timeout */ - u16_t t1_timeout; /* #ticks with period DHCP_COARSE_TIMER_SECS for renewal time */ - u16_t t2_timeout; /* #ticks with period DHCP_COARSE_TIMER_SECS for rebind time */ - u16_t t1_renew_time; /* #ticks with period DHCP_COARSE_TIMER_SECS until next renew try */ - u16_t t2_rebind_time; /* #ticks with period DHCP_COARSE_TIMER_SECS until next rebind try */ - u16_t lease_used; /* #ticks with period DHCP_COARSE_TIMER_SECS since last received DHCP ack */ - u16_t t0_timeout; /* #ticks with period DHCP_COARSE_TIMER_SECS for lease time */ - ip_addr_t server_ip_addr; /* dhcp server address that offered this lease (ip_addr_t because passed to UDP) */ - ip4_addr_t offered_ip_addr; - ip4_addr_t offered_sn_mask; - ip4_addr_t offered_gw_addr; - - u32_t offered_t0_lease; /* lease period (in seconds) */ - u32_t offered_t1_renew; /* recommended renew time (usually 50% of lease period) */ - u32_t offered_t2_rebind; /* recommended rebind time (usually 87.5 of lease period) */ -#if LWIP_DHCP_BOOTP_FILE - ip4_addr_t offered_si_addr; - char boot_file_name[DHCP_BOOT_FILE_LEN]; -#endif /* LWIP_DHCP_BOOTPFILE */ -}; - - -void dhcp_set_struct(struct netif *netif, struct dhcp *dhcp); -/** Remove a struct dhcp previously set to the netif using dhcp_set_struct() */ -#define dhcp_remove_struct(netif) netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, NULL) -void dhcp_cleanup(struct netif *netif); -err_t dhcp_start(struct netif *netif); -err_t dhcp_renew(struct netif *netif); -err_t dhcp_release(struct netif *netif); -void dhcp_stop(struct netif *netif); -void dhcp_release_and_stop(struct netif *netif); -void dhcp_inform(struct netif *netif); -void dhcp_network_changed(struct netif *netif); -#if DHCP_DOES_ARP_CHECK -void dhcp_arp_reply(struct netif *netif, const ip4_addr_t *addr); -#endif -u8_t dhcp_supplied_address(const struct netif *netif); -/* to be called every minute */ -void dhcp_coarse_tmr(void); -/* to be called every half second */ -void dhcp_fine_tmr(void); - -#if LWIP_DHCP_GET_NTP_SRV -/** This function must exist, in other to add offered NTP servers to - * the NTP (or SNTP) engine. - * See LWIP_DHCP_MAX_NTP_SERVERS */ -extern void dhcp_set_ntp_servers(u8_t num_ntp_servers, const ip4_addr_t* ntp_server_addrs); -#endif /* LWIP_DHCP_GET_NTP_SRV */ - -#define netif_dhcp_data(netif) ((struct dhcp*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_DHCP */ - -#endif /*LWIP_HDR_DHCP_H*/ +/** + * @file + * DHCP client API + */ + +/* + * Copyright (c) 2001-2004 Leon Woestenberg + * Copyright (c) 2001-2004 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Leon Woestenberg + * + */ +#ifndef LWIP_HDR_DHCP_H +#define LWIP_HDR_DHCP_H + +#include "lwip/opt.h" + +#if LWIP_DHCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/netif.h" +#include "lwip/udp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** period (in seconds) of the application calling dhcp_coarse_tmr() */ +#define DHCP_COARSE_TIMER_SECS 60 +/** period (in milliseconds) of the application calling dhcp_coarse_tmr() */ +#define DHCP_COARSE_TIMER_MSECS (DHCP_COARSE_TIMER_SECS * 1000UL) +/** period (in milliseconds) of the application calling dhcp_fine_tmr() */ +#define DHCP_FINE_TIMER_MSECS 500 + +#define DHCP_BOOT_FILE_LEN 128U + +/* AutoIP cooperation flags (struct dhcp.autoip_coop_state) */ +typedef enum { + DHCP_AUTOIP_COOP_STATE_OFF = 0, + DHCP_AUTOIP_COOP_STATE_ON = 1 +} dhcp_autoip_coop_state_enum_t; + +struct dhcp +{ + /** transaction identifier of last sent request */ + u32_t xid; + /** track PCB allocation state */ + u8_t pcb_allocated; + /** current DHCP state machine state */ + u8_t state; + /** retries of current request */ + u8_t tries; +#if LWIP_DHCP_AUTOIP_COOP + u8_t autoip_coop_state; +#endif + u8_t subnet_mask_given; + + u16_t request_timeout; /* #ticks with period DHCP_FINE_TIMER_SECS for request timeout */ + u16_t t1_timeout; /* #ticks with period DHCP_COARSE_TIMER_SECS for renewal time */ + u16_t t2_timeout; /* #ticks with period DHCP_COARSE_TIMER_SECS for rebind time */ + u16_t t1_renew_time; /* #ticks with period DHCP_COARSE_TIMER_SECS until next renew try */ + u16_t t2_rebind_time; /* #ticks with period DHCP_COARSE_TIMER_SECS until next rebind try */ + u16_t lease_used; /* #ticks with period DHCP_COARSE_TIMER_SECS since last received DHCP ack */ + u16_t t0_timeout; /* #ticks with period DHCP_COARSE_TIMER_SECS for lease time */ + ip_addr_t server_ip_addr; /* dhcp server address that offered this lease (ip_addr_t because passed to UDP) */ + ip4_addr_t offered_ip_addr; + ip4_addr_t offered_sn_mask; + ip4_addr_t offered_gw_addr; + + u32_t offered_t0_lease; /* lease period (in seconds) */ + u32_t offered_t1_renew; /* recommended renew time (usually 50% of lease period) */ + u32_t offered_t2_rebind; /* recommended rebind time (usually 87.5 of lease period) */ +#if LWIP_DHCP_BOOTP_FILE + ip4_addr_t offered_si_addr; + char boot_file_name[DHCP_BOOT_FILE_LEN]; +#endif /* LWIP_DHCP_BOOTPFILE */ +}; + + +void dhcp_set_struct(struct netif *netif, struct dhcp *dhcp); +/** Remove a struct dhcp previously set to the netif using dhcp_set_struct() */ +#define dhcp_remove_struct(netif) netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, NULL) +void dhcp_cleanup(struct netif *netif); +err_t dhcp_start(struct netif *netif); +err_t dhcp_renew(struct netif *netif); +err_t dhcp_release(struct netif *netif); +void dhcp_stop(struct netif *netif); +void dhcp_release_and_stop(struct netif *netif); +void dhcp_inform(struct netif *netif); +void dhcp_network_changed(struct netif *netif); +#if DHCP_DOES_ARP_CHECK +void dhcp_arp_reply(struct netif *netif, const ip4_addr_t *addr); +#endif +u8_t dhcp_supplied_address(const struct netif *netif); +/* to be called every minute */ +void dhcp_coarse_tmr(void); +/* to be called every half second */ +void dhcp_fine_tmr(void); + +#if LWIP_DHCP_GET_NTP_SRV +/** This function must exist, in other to add offered NTP servers to + * the NTP (or SNTP) engine. + * See LWIP_DHCP_MAX_NTP_SERVERS */ +extern void dhcp_set_ntp_servers(u8_t num_ntp_servers, const ip4_addr_t* ntp_server_addrs); +#endif /* LWIP_DHCP_GET_NTP_SRV */ + +#define netif_dhcp_data(netif) ((struct dhcp*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_DHCP */ + +#endif /*LWIP_HDR_DHCP_H*/ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp6.h index 61ca4c42..5cc4a015 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dhcp6.h @@ -1,104 +1,104 @@ -/** - * @file - * - * DHCPv6 client: IPv6 address autoconfiguration as per - * RFC 3315 (stateful DHCPv6) and - * RFC 3736 (stateless DHCPv6). - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - */ - -#ifndef LWIP_HDR_IP6_DHCP6_H -#define LWIP_HDR_IP6_DHCP6_H - -#include "lwip/opt.h" - -#if LWIP_IPV6_DHCP6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/err.h" -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** period (in milliseconds) of the application calling dhcp6_tmr() */ -#define DHCP6_TIMER_MSECS 500 - -struct dhcp6 -{ - /** transaction identifier of last sent request */ - u32_t xid; - /** track PCB allocation state */ - u8_t pcb_allocated; - /** current DHCPv6 state machine state */ - u8_t state; - /** retries of current request */ - u8_t tries; - /** if request config is triggered while another action is active, this keeps track of it */ - u8_t request_config_pending; - /** #ticks with period DHCP6_TIMER_MSECS for request timeout */ - u16_t request_timeout; -#if LWIP_IPV6_DHCP6_STATEFUL - /* @todo: add more members here to keep track of stateful DHCPv6 data, like lease times */ -#endif /* LWIP_IPV6_DHCP6_STATEFUL */ -}; - -void dhcp6_set_struct(struct netif *netif, struct dhcp6 *dhcp6); -/** Remove a struct dhcp6 previously set to the netif using dhcp6_set_struct() */ -#define dhcp6_remove_struct(netif) netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, NULL) -void dhcp6_cleanup(struct netif *netif); - -err_t dhcp6_enable_stateful(struct netif *netif); -err_t dhcp6_enable_stateless(struct netif *netif); -void dhcp6_disable(struct netif *netif); - -void dhcp6_tmr(void); - -void dhcp6_nd6_ra_trigger(struct netif *netif, u8_t managed_addr_config, u8_t other_config); - -#if LWIP_DHCP6_GET_NTP_SRV -/** This function must exist, in other to add offered NTP servers to - * the NTP (or SNTP) engine. - * See LWIP_DHCP6_MAX_NTP_SERVERS */ -extern void dhcp6_set_ntp_servers(u8_t num_ntp_servers, const ip_addr_t* ntp_server_addrs); -#endif /* LWIP_DHCP6_GET_NTP_SRV */ - -#define netif_dhcp6_data(netif) ((struct dhcp6*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6_DHCP6 */ - -#endif /* LWIP_HDR_IP6_DHCP6_H */ +/** + * @file + * + * DHCPv6 client: IPv6 address autoconfiguration as per + * RFC 3315 (stateful DHCPv6) and + * RFC 3736 (stateless DHCPv6). + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + */ + +#ifndef LWIP_HDR_IP6_DHCP6_H +#define LWIP_HDR_IP6_DHCP6_H + +#include "lwip/opt.h" + +#if LWIP_IPV6_DHCP6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/err.h" +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** period (in milliseconds) of the application calling dhcp6_tmr() */ +#define DHCP6_TIMER_MSECS 500 + +struct dhcp6 +{ + /** transaction identifier of last sent request */ + u32_t xid; + /** track PCB allocation state */ + u8_t pcb_allocated; + /** current DHCPv6 state machine state */ + u8_t state; + /** retries of current request */ + u8_t tries; + /** if request config is triggered while another action is active, this keeps track of it */ + u8_t request_config_pending; + /** #ticks with period DHCP6_TIMER_MSECS for request timeout */ + u16_t request_timeout; +#if LWIP_IPV6_DHCP6_STATEFUL + /* @todo: add more members here to keep track of stateful DHCPv6 data, like lease times */ +#endif /* LWIP_IPV6_DHCP6_STATEFUL */ +}; + +void dhcp6_set_struct(struct netif *netif, struct dhcp6 *dhcp6); +/** Remove a struct dhcp6 previously set to the netif using dhcp6_set_struct() */ +#define dhcp6_remove_struct(netif) netif_set_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, NULL) +void dhcp6_cleanup(struct netif *netif); + +err_t dhcp6_enable_stateful(struct netif *netif); +err_t dhcp6_enable_stateless(struct netif *netif); +void dhcp6_disable(struct netif *netif); + +void dhcp6_tmr(void); + +void dhcp6_nd6_ra_trigger(struct netif *netif, u8_t managed_addr_config, u8_t other_config); + +#if LWIP_DHCP6_GET_NTP_SRV +/** This function must exist, in other to add offered NTP servers to + * the NTP (or SNTP) engine. + * See LWIP_DHCP6_MAX_NTP_SERVERS */ +extern void dhcp6_set_ntp_servers(u8_t num_ntp_servers, const ip_addr_t* ntp_server_addrs); +#endif /* LWIP_DHCP6_GET_NTP_SRV */ + +#define netif_dhcp6_data(netif) ((struct dhcp6*)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6_DHCP6 */ + +#endif /* LWIP_HDR_IP6_DHCP6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dns.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dns.h index eed68258..09134154 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dns.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/dns.h @@ -1,131 +1,131 @@ -/** - * @file - * DNS API - */ - -/** - * lwip DNS resolver header file. - - * Author: Jim Pettinato - * April 2007 - - * ported from uIP resolv.c Copyright (c) 2002-2003, Adam Dunkels. - * - * 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. The name of the author may not be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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_DNS_H -#define LWIP_HDR_DNS_H - -#include "lwip/opt.h" - -#if LWIP_DNS - -#include "lwip/ip_addr.h" -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** DNS timer period */ -#define DNS_TMR_INTERVAL 1000 - -/* DNS resolve types: */ -#define LWIP_DNS_ADDRTYPE_IPV4 0 -#define LWIP_DNS_ADDRTYPE_IPV6 1 -#define LWIP_DNS_ADDRTYPE_IPV4_IPV6 2 /* try to resolve IPv4 first, try IPv6 if IPv4 fails only */ -#define LWIP_DNS_ADDRTYPE_IPV6_IPV4 3 /* try to resolve IPv6 first, try IPv4 if IPv6 fails only */ -#if LWIP_IPV4 && LWIP_IPV6 -#ifndef LWIP_DNS_ADDRTYPE_DEFAULT -#define LWIP_DNS_ADDRTYPE_DEFAULT LWIP_DNS_ADDRTYPE_IPV4_IPV6 -#endif -#elif LWIP_IPV4 -#define LWIP_DNS_ADDRTYPE_DEFAULT LWIP_DNS_ADDRTYPE_IPV4 -#else -#define LWIP_DNS_ADDRTYPE_DEFAULT LWIP_DNS_ADDRTYPE_IPV6 -#endif - -#if DNS_LOCAL_HOSTLIST -/** struct used for local host-list */ -struct local_hostlist_entry { - /** static hostname */ - const char *name; - /** static host address in network byteorder */ - ip_addr_t addr; - struct local_hostlist_entry *next; -}; -#define DNS_LOCAL_HOSTLIST_ELEM(name, addr_init) {name, addr_init, NULL} -#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC -#ifndef DNS_LOCAL_HOSTLIST_MAX_NAMELEN -#define DNS_LOCAL_HOSTLIST_MAX_NAMELEN DNS_MAX_NAME_LENGTH -#endif -#define LOCALHOSTLIST_ELEM_SIZE ((sizeof(struct local_hostlist_entry) + DNS_LOCAL_HOSTLIST_MAX_NAMELEN + 1)) -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ -#endif /* DNS_LOCAL_HOSTLIST */ - -#if LWIP_IPV4 -extern const ip_addr_t dns_mquery_v4group; -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 -extern const ip_addr_t dns_mquery_v6group; -#endif /* LWIP_IPV6 */ - -/** Callback which is invoked when a hostname is found. - * A function of this type must be implemented by the application using the DNS resolver. - * @param name pointer to the name that was looked up. - * @param ipaddr pointer to an ip_addr_t containing the IP address of the hostname, - * or NULL if the name could not be found (or on any other error). - * @param callback_arg a user-specified callback argument passed to dns_gethostbyname -*/ -typedef void (*dns_found_callback)(const char *name, const ip_addr_t *ipaddr, void *callback_arg); - -void dns_init(void); -void dns_tmr(void); -void dns_setserver(u8_t numdns, const ip_addr_t *dnsserver); -const ip_addr_t* dns_getserver(u8_t numdns); -err_t dns_gethostbyname(const char *hostname, ip_addr_t *addr, - dns_found_callback found, void *callback_arg); -err_t dns_gethostbyname_addrtype(const char *hostname, ip_addr_t *addr, - dns_found_callback found, void *callback_arg, - u8_t dns_addrtype); - - -#if DNS_LOCAL_HOSTLIST -size_t dns_local_iterate(dns_found_callback iterator_fn, void *iterator_arg); -err_t dns_local_lookup(const char *hostname, ip_addr_t *addr, u8_t dns_addrtype); -#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC -int dns_local_removehost(const char *hostname, const ip_addr_t *addr); -err_t dns_local_addhost(const char *hostname, const ip_addr_t *addr); -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ -#endif /* DNS_LOCAL_HOSTLIST */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_DNS */ - -#endif /* LWIP_HDR_DNS_H */ +/** + * @file + * DNS API + */ + +/** + * lwip DNS resolver header file. + + * Author: Jim Pettinato + * April 2007 + + * ported from uIP resolv.c Copyright (c) 2002-2003, Adam Dunkels. + * + * 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. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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_DNS_H +#define LWIP_HDR_DNS_H + +#include "lwip/opt.h" + +#if LWIP_DNS + +#include "lwip/ip_addr.h" +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** DNS timer period */ +#define DNS_TMR_INTERVAL 1000 + +/* DNS resolve types: */ +#define LWIP_DNS_ADDRTYPE_IPV4 0 +#define LWIP_DNS_ADDRTYPE_IPV6 1 +#define LWIP_DNS_ADDRTYPE_IPV4_IPV6 2 /* try to resolve IPv4 first, try IPv6 if IPv4 fails only */ +#define LWIP_DNS_ADDRTYPE_IPV6_IPV4 3 /* try to resolve IPv6 first, try IPv4 if IPv6 fails only */ +#if LWIP_IPV4 && LWIP_IPV6 +#ifndef LWIP_DNS_ADDRTYPE_DEFAULT +#define LWIP_DNS_ADDRTYPE_DEFAULT LWIP_DNS_ADDRTYPE_IPV4_IPV6 +#endif +#elif LWIP_IPV4 +#define LWIP_DNS_ADDRTYPE_DEFAULT LWIP_DNS_ADDRTYPE_IPV4 +#else +#define LWIP_DNS_ADDRTYPE_DEFAULT LWIP_DNS_ADDRTYPE_IPV6 +#endif + +#if DNS_LOCAL_HOSTLIST +/** struct used for local host-list */ +struct local_hostlist_entry { + /** static hostname */ + const char *name; + /** static host address in network byteorder */ + ip_addr_t addr; + struct local_hostlist_entry *next; +}; +#define DNS_LOCAL_HOSTLIST_ELEM(name, addr_init) {name, addr_init, NULL} +#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC +#ifndef DNS_LOCAL_HOSTLIST_MAX_NAMELEN +#define DNS_LOCAL_HOSTLIST_MAX_NAMELEN DNS_MAX_NAME_LENGTH +#endif +#define LOCALHOSTLIST_ELEM_SIZE ((sizeof(struct local_hostlist_entry) + DNS_LOCAL_HOSTLIST_MAX_NAMELEN + 1)) +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ +#endif /* DNS_LOCAL_HOSTLIST */ + +#if LWIP_IPV4 +extern const ip_addr_t dns_mquery_v4group; +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 +extern const ip_addr_t dns_mquery_v6group; +#endif /* LWIP_IPV6 */ + +/** Callback which is invoked when a hostname is found. + * A function of this type must be implemented by the application using the DNS resolver. + * @param name pointer to the name that was looked up. + * @param ipaddr pointer to an ip_addr_t containing the IP address of the hostname, + * or NULL if the name could not be found (or on any other error). + * @param callback_arg a user-specified callback argument passed to dns_gethostbyname +*/ +typedef void (*dns_found_callback)(const char *name, const ip_addr_t *ipaddr, void *callback_arg); + +void dns_init(void); +void dns_tmr(void); +void dns_setserver(u8_t numdns, const ip_addr_t *dnsserver); +const ip_addr_t* dns_getserver(u8_t numdns); +err_t dns_gethostbyname(const char *hostname, ip_addr_t *addr, + dns_found_callback found, void *callback_arg); +err_t dns_gethostbyname_addrtype(const char *hostname, ip_addr_t *addr, + dns_found_callback found, void *callback_arg, + u8_t dns_addrtype); + + +#if DNS_LOCAL_HOSTLIST +size_t dns_local_iterate(dns_found_callback iterator_fn, void *iterator_arg); +err_t dns_local_lookup(const char *hostname, ip_addr_t *addr, u8_t dns_addrtype); +#if DNS_LOCAL_HOSTLIST_IS_DYNAMIC +int dns_local_removehost(const char *hostname, const ip_addr_t *addr); +err_t dns_local_addhost(const char *hostname, const ip_addr_t *addr); +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ +#endif /* DNS_LOCAL_HOSTLIST */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_DNS */ + +#endif /* LWIP_HDR_DNS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/err.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/err.h index 63c138a3..887d9b3f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/err.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/err.h @@ -1,117 +1,117 @@ -/** - * @file - * lwIP Error codes - */ -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_ERR_H -#define LWIP_HDR_ERR_H - -#include "lwip/opt.h" -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @defgroup infrastructure_errors Error codes - * @ingroup infrastructure - * @{ - */ - -/** Definitions for error constants. */ -typedef enum { -/** No error, everything OK. */ - ERR_OK = 0, -/** Out of memory error. */ - ERR_MEM = -1, -/** Buffer error. */ - ERR_BUF = -2, -/** Timeout. */ - ERR_TIMEOUT = -3, -/** Routing problem. */ - ERR_RTE = -4, -/** Operation in progress */ - ERR_INPROGRESS = -5, -/** Illegal value. */ - ERR_VAL = -6, -/** Operation would block. */ - ERR_WOULDBLOCK = -7, -/** Address in use. */ - ERR_USE = -8, -/** Already connecting. */ - ERR_ALREADY = -9, -/** Conn already established.*/ - ERR_ISCONN = -10, -/** Not connected. */ - ERR_CONN = -11, -/** Low-level netif error */ - ERR_IF = -12, - -/** Connection aborted. */ - ERR_ABRT = -13, -/** Connection reset. */ - ERR_RST = -14, -/** Connection closed. */ - ERR_CLSD = -15, -/** Illegal argument. */ - ERR_ARG = -16 -} err_enum_t; - -/** Define LWIP_ERR_T in cc.h if you want to use - * a different type for your platform (must be signed). */ -#ifdef LWIP_ERR_T -typedef LWIP_ERR_T err_t; -#else /* LWIP_ERR_T */ -typedef s8_t err_t; -#endif /* LWIP_ERR_T*/ - -/** - * @} - */ - -#ifdef LWIP_DEBUG -extern const char *lwip_strerr(err_t err); -#else -#define lwip_strerr(x) "" -#endif /* LWIP_DEBUG */ - -#if !NO_SYS -int err_to_errno(err_t err); -#endif /* !NO_SYS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_ERR_H */ +/** + * @file + * lwIP Error codes + */ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_ERR_H +#define LWIP_HDR_ERR_H + +#include "lwip/opt.h" +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup infrastructure_errors Error codes + * @ingroup infrastructure + * @{ + */ + +/** Definitions for error constants. */ +typedef enum { +/** No error, everything OK. */ + ERR_OK = 0, +/** Out of memory error. */ + ERR_MEM = -1, +/** Buffer error. */ + ERR_BUF = -2, +/** Timeout. */ + ERR_TIMEOUT = -3, +/** Routing problem. */ + ERR_RTE = -4, +/** Operation in progress */ + ERR_INPROGRESS = -5, +/** Illegal value. */ + ERR_VAL = -6, +/** Operation would block. */ + ERR_WOULDBLOCK = -7, +/** Address in use. */ + ERR_USE = -8, +/** Already connecting. */ + ERR_ALREADY = -9, +/** Conn already established.*/ + ERR_ISCONN = -10, +/** Not connected. */ + ERR_CONN = -11, +/** Low-level netif error */ + ERR_IF = -12, + +/** Connection aborted. */ + ERR_ABRT = -13, +/** Connection reset. */ + ERR_RST = -14, +/** Connection closed. */ + ERR_CLSD = -15, +/** Illegal argument. */ + ERR_ARG = -16 +} err_enum_t; + +/** Define LWIP_ERR_T in cc.h if you want to use + * a different type for your platform (must be signed). */ +#ifdef LWIP_ERR_T +typedef LWIP_ERR_T err_t; +#else /* LWIP_ERR_T */ +typedef s8_t err_t; +#endif /* LWIP_ERR_T*/ + +/** + * @} + */ + +#ifdef LWIP_DEBUG +extern const char *lwip_strerr(err_t err); +#else +#define lwip_strerr(x) "" +#endif /* LWIP_DEBUG */ + +#if !NO_SYS +int err_to_errno(err_t err); +#endif /* !NO_SYS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_ERR_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/errno.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/errno.h index 769fe774..17fadeee 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/errno.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/errno.h @@ -1,198 +1,198 @@ -/** - * @file - * Posix Errno defines - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_ERRNO_H -#define LWIP_HDR_ERRNO_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef LWIP_PROVIDE_ERRNO - -#define EPERM 1 /* Operation not permitted */ -#define ENOENT 2 /* No such file or directory */ -#define ESRCH 3 /* No such process */ -#define EINTR 4 /* Interrupted system call */ -#define EIO 5 /* I/O error */ -#define ENXIO 6 /* No such device or address */ -#define E2BIG 7 /* Arg list too long */ -#define ENOEXEC 8 /* Exec format error */ -#define EBADF 9 /* Bad file number */ -#define ECHILD 10 /* No child processes */ -#define EAGAIN 11 /* Try again */ -#define ENOMEM 12 /* Out of memory */ -#define EACCES 13 /* Permission denied */ -#define EFAULT 14 /* Bad address */ -#define ENOTBLK 15 /* Block device required */ -#define EBUSY 16 /* Device or resource busy */ -#define EEXIST 17 /* File exists */ -#define EXDEV 18 /* Cross-device link */ -#define ENODEV 19 /* No such device */ -#define ENOTDIR 20 /* Not a directory */ -#define EISDIR 21 /* Is a directory */ -#define EINVAL 22 /* Invalid argument */ -#define ENFILE 23 /* File table overflow */ -#define EMFILE 24 /* Too many open files */ -#define ENOTTY 25 /* Not a typewriter */ -#define ETXTBSY 26 /* Text file busy */ -#define EFBIG 27 /* File too large */ -#define ENOSPC 28 /* No space left on device */ -#define ESPIPE 29 /* Illegal seek */ -#define EROFS 30 /* Read-only file system */ -#define EMLINK 31 /* Too many links */ -#define EPIPE 32 /* Broken pipe */ -#define EDOM 33 /* Math argument out of domain of func */ -#define ERANGE 34 /* Math result not representable */ -// #define EDEADLK 35 /* Resource deadlock would occur */ -// #define ENAMETOOLONG 36 /* File name too long */ -// #define ENOLCK 37 /* No record locks available */ -// #define ENOSYS 38 /* Function not implemented */ -// #define ENOTEMPTY 39 /* Directory not empty */ -// #define ELOOP 40 /* Too many symbolic links encountered */ -#define EWOULDBLOCK EAGAIN /* Operation would block */ -// #define ENOMSG 42 /* No message of desired type */ -// #define EIDRM 43 /* Identifier removed */ -#define ECHRNG 44 /* Channel number out of range */ -#define EL2NSYNC 45 /* Level 2 not synchronized */ -#define EL3HLT 46 /* Level 3 halted */ -#define EL3RST 47 /* Level 3 reset */ -#define ELNRNG 48 /* Link number out of range */ -#define EUNATCH 49 /* Protocol driver not attached */ -#define ENOCSI 50 /* No CSI structure available */ -#define EL2HLT 51 /* Level 2 halted */ -#define EBADE 52 /* Invalid exchange */ -#define EBADR 53 /* Invalid request descriptor */ -#define EXFULL 54 /* Exchange full */ -#define ENOANO 55 /* No anode */ -#define EBADRQC 56 /* Invalid request code */ -#define EBADSLT 57 /* Invalid slot */ - -#define EDEADLOCK EDEADLK - -#define EBFONT 59 /* Bad font file format */ -#define ENOSTR 60 /* Device not a stream */ -#define ENODATA 61 /* No data available */ -#define ETIME 62 /* Timer expired */ -#define ENOSR 63 /* Out of streams resources */ -#define ENONET 64 /* Machine is not on the network */ -#define ENOPKG 65 /* Package not installed */ -#define EREMOTE 66 /* Object is remote */ -#define ENOLINK 67 /* Link has been severed */ -#define EADV 68 /* Advertise error */ -#define ESRMNT 69 /* Srmount error */ -#define ECOMM 70 /* Communication error on send */ -#define EPROTO 71 /* Protocol error */ -// #define EMULTIHOP 72 /* Multihop attempted */ -#define EDOTDOT 73 /* RFS specific error */ -// #define EBADMSG 74 /* Not a data message */ -// #define EOVERFLOW 75 /* Value too large for defined data type */ -#define ENOTUNIQ 76 /* Name not unique on network */ -#define EBADFD 77 /* File descriptor in bad state */ -#define EREMCHG 78 /* Remote address changed */ -#define ELIBACC 79 /* Can not access a needed shared library */ -#define ELIBBAD 80 /* Accessing a corrupted shared library */ -#define ELIBSCN 81 /* .lib section in a.out corrupted */ -#define ELIBMAX 82 /* Attempting to link in too many shared libraries */ -#define ELIBEXEC 83 /* Cannot exec a shared library directly */ -// #define EILSEQ 84 /* Illegal byte sequence */ -#define ERESTART 85 /* Interrupted system call should be restarted */ -#define ESTRPIPE 86 /* Streams pipe error */ -#define EUSERS 87 /* Too many users */ -// #define ENOTSOCK 88 /* Socket operation on non-socket */ -// #define EDESTADDRREQ 89 /* Destination address required */ -// #define EMSGSIZE 90 /* Message too long */ -// #define EPROTOTYPE 91 /* Protocol wrong type for socket */ -// #define ENOPROTOOPT 92 /* Protocol not available */ -// #define EPROTONOSUPPORT 93 /* Protocol not supported */ -#define ESOCKTNOSUPPORT 94 /* Socket type not supported */ -#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */ -#define EPFNOSUPPORT 96 /* Protocol family not supported */ -// #define EAFNOSUPPORT 97 /* Address family not supported by protocol */ -// #define EADDRINUSE 98 /* Address already in use */ -// #define EADDRNOTAVAIL 99 /* Cannot assign requested address */ -// #define ENETDOWN 100 /* Network is down */ -// #define ENETUNREACH 101 /* Network is unreachable */ -// #define ENETRESET 102 /* Network dropped connection because of reset */ -// #define ECONNABORTED 103 /* Software caused connection abort */ -#define ECONNRESET 104 /* Connection reset by peer */ -#define ENOBUFS 105 /* No buffer space available */ -// #define EISCONN 106 /* Transport endpoint is already connected */ -// #define ENOTCONN 107 /* Transport endpoint is not connected */ -#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */ -// #define ETOOMANYREFS 109 /* Too many references: cannot splice */ -// #define ETIMEDOUT 110 /* Connection timed out */ -#define ECONNREFUSED 111 /* Connection refused */ -// #define EHOSTDOWN 112 /* Host is down */ -// #define EHOSTUNREACH 113 /* No route to host */ -// #define EALREADY 114 /* Operation already in progress */ -// #define EINPROGRESS 115 /* Operation now in progress */ -// #define ESTALE 116 /* Stale NFS file handle */ -#define EUCLEAN 117 /* Structure needs cleaning */ -#define ENOTNAM 118 /* Not a XENIX named type file */ -#define ENAVAIL 119 /* No XENIX semaphores available */ -#define EISNAM 120 /* Is a named type file */ -#define EREMOTEIO 121 /* Remote I/O error */ -// #define EDQUOT 122 /* Quota exceeded */ - -#define ENOMEDIUM 123 /* No medium found */ -#define EMEDIUMTYPE 124 /* Wrong medium type */ - -#ifndef errno -extern int errno; -#endif - -#else /* LWIP_PROVIDE_ERRNO */ - -/* Define LWIP_ERRNO_STDINCLUDE if you want to include here */ -#ifdef LWIP_ERRNO_STDINCLUDE -#include -#else /* LWIP_ERRNO_STDINCLUDE */ -/* Define LWIP_ERRNO_INCLUDE to an equivalent of to include the error defines here */ -#ifdef LWIP_ERRNO_INCLUDE -#include LWIP_ERRNO_INCLUDE -#endif /* LWIP_ERRNO_INCLUDE */ -#endif /* LWIP_ERRNO_STDINCLUDE */ - -#endif /* LWIP_PROVIDE_ERRNO */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_ERRNO_H */ +/** + * @file + * Posix Errno defines + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_ERRNO_H +#define LWIP_HDR_ERRNO_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef LWIP_PROVIDE_ERRNO + +#define EPERM 1 /* Operation not permitted */ +#define ENOENT 2 /* No such file or directory */ +#define ESRCH 3 /* No such process */ +#define EINTR 4 /* Interrupted system call */ +#define EIO 5 /* I/O error */ +#define ENXIO 6 /* No such device or address */ +#define E2BIG 7 /* Arg list too long */ +#define ENOEXEC 8 /* Exec format error */ +#define EBADF 9 /* Bad file number */ +#define ECHILD 10 /* No child processes */ +#define EAGAIN 11 /* Try again */ +#define ENOMEM 12 /* Out of memory */ +#define EACCES 13 /* Permission denied */ +#define EFAULT 14 /* Bad address */ +#define ENOTBLK 15 /* Block device required */ +#define EBUSY 16 /* Device or resource busy */ +#define EEXIST 17 /* File exists */ +#define EXDEV 18 /* Cross-device link */ +#define ENODEV 19 /* No such device */ +#define ENOTDIR 20 /* Not a directory */ +#define EISDIR 21 /* Is a directory */ +#define EINVAL 22 /* Invalid argument */ +#define ENFILE 23 /* File table overflow */ +#define EMFILE 24 /* Too many open files */ +#define ENOTTY 25 /* Not a typewriter */ +#define ETXTBSY 26 /* Text file busy */ +#define EFBIG 27 /* File too large */ +#define ENOSPC 28 /* No space left on device */ +#define ESPIPE 29 /* Illegal seek */ +#define EROFS 30 /* Read-only file system */ +#define EMLINK 31 /* Too many links */ +#define EPIPE 32 /* Broken pipe */ +#define EDOM 33 /* Math argument out of domain of func */ +#define ERANGE 34 /* Math result not representable */ +// #define EDEADLK 35 /* Resource deadlock would occur */ +// #define ENAMETOOLONG 36 /* File name too long */ +// #define ENOLCK 37 /* No record locks available */ +// #define ENOSYS 38 /* Function not implemented */ +// #define ENOTEMPTY 39 /* Directory not empty */ +// #define ELOOP 40 /* Too many symbolic links encountered */ +#define EWOULDBLOCK EAGAIN /* Operation would block */ +// #define ENOMSG 42 /* No message of desired type */ +// #define EIDRM 43 /* Identifier removed */ +#define ECHRNG 44 /* Channel number out of range */ +#define EL2NSYNC 45 /* Level 2 not synchronized */ +#define EL3HLT 46 /* Level 3 halted */ +#define EL3RST 47 /* Level 3 reset */ +#define ELNRNG 48 /* Link number out of range */ +#define EUNATCH 49 /* Protocol driver not attached */ +#define ENOCSI 50 /* No CSI structure available */ +#define EL2HLT 51 /* Level 2 halted */ +#define EBADE 52 /* Invalid exchange */ +#define EBADR 53 /* Invalid request descriptor */ +#define EXFULL 54 /* Exchange full */ +#define ENOANO 55 /* No anode */ +#define EBADRQC 56 /* Invalid request code */ +#define EBADSLT 57 /* Invalid slot */ + +#define EDEADLOCK EDEADLK + +#define EBFONT 59 /* Bad font file format */ +#define ENOSTR 60 /* Device not a stream */ +#define ENODATA 61 /* No data available */ +#define ETIME 62 /* Timer expired */ +#define ENOSR 63 /* Out of streams resources */ +#define ENONET 64 /* Machine is not on the network */ +#define ENOPKG 65 /* Package not installed */ +#define EREMOTE 66 /* Object is remote */ +#define ENOLINK 67 /* Link has been severed */ +#define EADV 68 /* Advertise error */ +#define ESRMNT 69 /* Srmount error */ +#define ECOMM 70 /* Communication error on send */ +#define EPROTO 71 /* Protocol error */ +// #define EMULTIHOP 72 /* Multihop attempted */ +#define EDOTDOT 73 /* RFS specific error */ +// #define EBADMSG 74 /* Not a data message */ +// #define EOVERFLOW 75 /* Value too large for defined data type */ +#define ENOTUNIQ 76 /* Name not unique on network */ +#define EBADFD 77 /* File descriptor in bad state */ +#define EREMCHG 78 /* Remote address changed */ +#define ELIBACC 79 /* Can not access a needed shared library */ +#define ELIBBAD 80 /* Accessing a corrupted shared library */ +#define ELIBSCN 81 /* .lib section in a.out corrupted */ +#define ELIBMAX 82 /* Attempting to link in too many shared libraries */ +#define ELIBEXEC 83 /* Cannot exec a shared library directly */ +// #define EILSEQ 84 /* Illegal byte sequence */ +#define ERESTART 85 /* Interrupted system call should be restarted */ +#define ESTRPIPE 86 /* Streams pipe error */ +#define EUSERS 87 /* Too many users */ +// #define ENOTSOCK 88 /* Socket operation on non-socket */ +// #define EDESTADDRREQ 89 /* Destination address required */ +// #define EMSGSIZE 90 /* Message too long */ +// #define EPROTOTYPE 91 /* Protocol wrong type for socket */ +// #define ENOPROTOOPT 92 /* Protocol not available */ +// #define EPROTONOSUPPORT 93 /* Protocol not supported */ +#define ESOCKTNOSUPPORT 94 /* Socket type not supported */ +#define EOPNOTSUPP 95 /* Operation not supported on transport endpoint */ +#define EPFNOSUPPORT 96 /* Protocol family not supported */ +// #define EAFNOSUPPORT 97 /* Address family not supported by protocol */ +// #define EADDRINUSE 98 /* Address already in use */ +// #define EADDRNOTAVAIL 99 /* Cannot assign requested address */ +// #define ENETDOWN 100 /* Network is down */ +// #define ENETUNREACH 101 /* Network is unreachable */ +// #define ENETRESET 102 /* Network dropped connection because of reset */ +// #define ECONNABORTED 103 /* Software caused connection abort */ +#define ECONNRESET 104 /* Connection reset by peer */ +#define ENOBUFS 105 /* No buffer space available */ +// #define EISCONN 106 /* Transport endpoint is already connected */ +// #define ENOTCONN 107 /* Transport endpoint is not connected */ +#define ESHUTDOWN 108 /* Cannot send after transport endpoint shutdown */ +// #define ETOOMANYREFS 109 /* Too many references: cannot splice */ +// #define ETIMEDOUT 110 /* Connection timed out */ +#define ECONNREFUSED 111 /* Connection refused */ +// #define EHOSTDOWN 112 /* Host is down */ +// #define EHOSTUNREACH 113 /* No route to host */ +// #define EALREADY 114 /* Operation already in progress */ +// #define EINPROGRESS 115 /* Operation now in progress */ +// #define ESTALE 116 /* Stale NFS file handle */ +#define EUCLEAN 117 /* Structure needs cleaning */ +#define ENOTNAM 118 /* Not a XENIX named type file */ +#define ENAVAIL 119 /* No XENIX semaphores available */ +#define EISNAM 120 /* Is a named type file */ +#define EREMOTEIO 121 /* Remote I/O error */ +// #define EDQUOT 122 /* Quota exceeded */ + +#define ENOMEDIUM 123 /* No medium found */ +#define EMEDIUMTYPE 124 /* Wrong medium type */ + +#ifndef errno +extern int errno; +#endif + +#else /* LWIP_PROVIDE_ERRNO */ + +/* Define LWIP_ERRNO_STDINCLUDE if you want to include here */ +#ifdef LWIP_ERRNO_STDINCLUDE +#include +#else /* LWIP_ERRNO_STDINCLUDE */ +/* Define LWIP_ERRNO_INCLUDE to an equivalent of to include the error defines here */ +#ifdef LWIP_ERRNO_INCLUDE +#include LWIP_ERRNO_INCLUDE +#endif /* LWIP_ERRNO_INCLUDE */ +#endif /* LWIP_ERRNO_STDINCLUDE */ + +#endif /* LWIP_PROVIDE_ERRNO */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_ERRNO_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/etharp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/etharp.h index b018f074..2036b246 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/etharp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/etharp.h @@ -1,105 +1,105 @@ -/** - * @file - * Ethernet output function - handles OUTGOING ethernet level traffic, implements - * ARP resolving. - * To be used in most low-level netif implementations - */ - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * Copyright (c) 2003-2004 Leon Woestenberg - * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#ifndef LWIP_HDR_NETIF_ETHARP_H -#define LWIP_HDR_NETIF_ETHARP_H - -#include "lwip/opt.h" - -#if LWIP_ARP || LWIP_ETHERNET /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/ip4_addr.h" -#include "lwip/netif.h" -#include "lwip/ip4.h" -#include "lwip/prot/ethernet.h" - -#if LWIP_IPV4 && LWIP_ARP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/prot/etharp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** 1 seconds period */ -#define ARP_TMR_INTERVAL 1000 - -#if ARP_QUEUEING -/** struct for queueing outgoing packets for unknown address - * defined here to be accessed by memp.h - */ -struct etharp_q_entry { - struct etharp_q_entry *next; - struct pbuf *p; -}; -#endif /* ARP_QUEUEING */ - -#define etharp_init() /* Compatibility define, no init needed. */ -void etharp_tmr(void); -ssize_t etharp_find_addr(struct netif *netif, const ip4_addr_t *ipaddr, - struct eth_addr **eth_ret, const ip4_addr_t **ip_ret); -int etharp_get_entry(size_t i, ip4_addr_t **ipaddr, struct netif **netif, struct eth_addr **eth_ret); -err_t etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr); -err_t etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q); -err_t etharp_request(struct netif *netif, const ip4_addr_t *ipaddr); -/** For Ethernet network interfaces, we might want to send "gratuitous ARP"; - * this is an ARP packet sent by a node in order to spontaneously cause other - * nodes to update an entry in their ARP cache. - * From RFC 3220 "IP Mobility Support for IPv4" section 4.6. */ -#define etharp_gratuitous(netif) etharp_request((netif), netif_ip4_addr(netif)) -void etharp_cleanup_netif(struct netif *netif); - -#if ETHARP_SUPPORT_STATIC_ENTRIES -err_t etharp_add_static_entry(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr); -err_t etharp_remove_static_entry(const ip4_addr_t *ipaddr); -#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ - -void etharp_input(struct pbuf *p, struct netif *netif); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV4 && LWIP_ARP */ -#endif /* LWIP_ARP || LWIP_ETHERNET */ - -#endif /* LWIP_HDR_NETIF_ETHARP_H */ +/** + * @file + * Ethernet output function - handles OUTGOING ethernet level traffic, implements + * ARP resolving. + * To be used in most low-level netif implementations + */ + +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * Copyright (c) 2003-2004 Leon Woestenberg + * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#ifndef LWIP_HDR_NETIF_ETHARP_H +#define LWIP_HDR_NETIF_ETHARP_H + +#include "lwip/opt.h" + +#if LWIP_ARP || LWIP_ETHERNET /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/ip4_addr.h" +#include "lwip/netif.h" +#include "lwip/ip4.h" +#include "lwip/prot/ethernet.h" + +#if LWIP_IPV4 && LWIP_ARP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/prot/etharp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** 1 seconds period */ +#define ARP_TMR_INTERVAL 1000 + +#if ARP_QUEUEING +/** struct for queueing outgoing packets for unknown address + * defined here to be accessed by memp.h + */ +struct etharp_q_entry { + struct etharp_q_entry *next; + struct pbuf *p; +}; +#endif /* ARP_QUEUEING */ + +#define etharp_init() /* Compatibility define, no init needed. */ +void etharp_tmr(void); +ssize_t etharp_find_addr(struct netif *netif, const ip4_addr_t *ipaddr, + struct eth_addr **eth_ret, const ip4_addr_t **ip_ret); +int etharp_get_entry(size_t i, ip4_addr_t **ipaddr, struct netif **netif, struct eth_addr **eth_ret); +err_t etharp_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr); +err_t etharp_query(struct netif *netif, const ip4_addr_t *ipaddr, struct pbuf *q); +err_t etharp_request(struct netif *netif, const ip4_addr_t *ipaddr); +/** For Ethernet network interfaces, we might want to send "gratuitous ARP"; + * this is an ARP packet sent by a node in order to spontaneously cause other + * nodes to update an entry in their ARP cache. + * From RFC 3220 "IP Mobility Support for IPv4" section 4.6. */ +#define etharp_gratuitous(netif) etharp_request((netif), netif_ip4_addr(netif)) +void etharp_cleanup_netif(struct netif *netif); + +#if ETHARP_SUPPORT_STATIC_ENTRIES +err_t etharp_add_static_entry(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr); +err_t etharp_remove_static_entry(const ip4_addr_t *ipaddr); +#endif /* ETHARP_SUPPORT_STATIC_ENTRIES */ + +void etharp_input(struct pbuf *p, struct netif *netif); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV4 && LWIP_ARP */ +#endif /* LWIP_ARP || LWIP_ETHERNET */ + +#endif /* LWIP_HDR_NETIF_ETHARP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ethip6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ethip6.h index f393c9cd..5e88dffd 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ethip6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ethip6.h @@ -1,68 +1,68 @@ -/** - * @file - * - * Ethernet output for IPv6. Uses ND tables for link-layer addressing. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#ifndef LWIP_HDR_ETHIP6_H -#define LWIP_HDR_ETHIP6_H - -#include "lwip/opt.h" - -#if LWIP_IPV6 && LWIP_ETHERNET /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" - - -#ifdef __cplusplus -extern "C" { -#endif - - -err_t ethip6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 && LWIP_ETHERNET */ - -#endif /* LWIP_HDR_ETHIP6_H */ +/** + * @file + * + * Ethernet output for IPv6. Uses ND tables for link-layer addressing. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#ifndef LWIP_HDR_ETHIP6_H +#define LWIP_HDR_ETHIP6_H + +#include "lwip/opt.h" + +#if LWIP_IPV6 && LWIP_ETHERNET /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" + + +#ifdef __cplusplus +extern "C" { +#endif + + +err_t ethip6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 && LWIP_ETHERNET */ + +#endif /* LWIP_HDR_ETHIP6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp.h index d0d67b69..f5a31fd4 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp.h @@ -1,110 +1,110 @@ -/** - * @file - * ICMP API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_ICMP_H -#define LWIP_HDR_ICMP_H - -#include "lwip/opt.h" -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/prot/icmp.h" - -#if LWIP_IPV6 && LWIP_ICMP6 -#include "lwip/icmp6.h" -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -/** ICMP destination unreachable codes */ -enum icmp_dur_type { - /** net unreachable */ - ICMP_DUR_NET = 0, - /** host unreachable */ - ICMP_DUR_HOST = 1, - /** protocol unreachable */ - ICMP_DUR_PROTO = 2, - /** port unreachable */ - ICMP_DUR_PORT = 3, - /** fragmentation needed and DF set */ - ICMP_DUR_FRAG = 4, - /** source route failed */ - ICMP_DUR_SR = 5 -}; - -/** ICMP time exceeded codes */ -enum icmp_te_type { - /** time to live exceeded in transit */ - ICMP_TE_TTL = 0, - /** fragment reassembly time exceeded */ - ICMP_TE_FRAG = 1 -}; - -#if LWIP_IPV4 && LWIP_ICMP /* don't build if not configured for use in lwipopts.h */ - -void icmp_input(struct pbuf *p, struct netif *inp); -void icmp_dest_unreach(struct pbuf *p, enum icmp_dur_type t); -void icmp_time_exceeded(struct pbuf *p, enum icmp_te_type t); - -#endif /* LWIP_IPV4 && LWIP_ICMP */ - -#if LWIP_IPV4 && LWIP_IPV6 -#if LWIP_ICMP && LWIP_ICMP6 -#define icmp_port_unreach(isipv6, pbuf) ((isipv6) ? \ - icmp6_dest_unreach(pbuf, ICMP6_DUR_PORT) : \ - icmp_dest_unreach(pbuf, ICMP_DUR_PORT)) -#elif LWIP_ICMP -#define icmp_port_unreach(isipv6, pbuf) do{ if(!(isipv6)) { icmp_dest_unreach(pbuf, ICMP_DUR_PORT);}}while(0) -#elif LWIP_ICMP6 -#define icmp_port_unreach(isipv6, pbuf) do{ if(isipv6) { icmp6_dest_unreach(pbuf, ICMP6_DUR_PORT);}}while(0) -#else -#define icmp_port_unreach(isipv6, pbuf) -#endif -#elif LWIP_IPV6 && LWIP_ICMP6 -#define icmp_port_unreach(isipv6, pbuf) icmp6_dest_unreach(pbuf, ICMP6_DUR_PORT) -#elif LWIP_IPV4 && LWIP_ICMP -#define icmp_port_unreach(isipv6, pbuf) icmp_dest_unreach(pbuf, ICMP_DUR_PORT) -#else /* (LWIP_IPV6 && LWIP_ICMP6) || (LWIP_IPV4 && LWIP_ICMP) */ -#define icmp_port_unreach(isipv6, pbuf) -#endif /* (LWIP_IPV6 && LWIP_ICMP6) || (LWIP_IPV4 && LWIP_ICMP) LWIP_IPV4*/ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_ICMP_H */ +/** + * @file + * ICMP API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_ICMP_H +#define LWIP_HDR_ICMP_H + +#include "lwip/opt.h" +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/prot/icmp.h" + +#if LWIP_IPV6 && LWIP_ICMP6 +#include "lwip/icmp6.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/** ICMP destination unreachable codes */ +enum icmp_dur_type { + /** net unreachable */ + ICMP_DUR_NET = 0, + /** host unreachable */ + ICMP_DUR_HOST = 1, + /** protocol unreachable */ + ICMP_DUR_PROTO = 2, + /** port unreachable */ + ICMP_DUR_PORT = 3, + /** fragmentation needed and DF set */ + ICMP_DUR_FRAG = 4, + /** source route failed */ + ICMP_DUR_SR = 5 +}; + +/** ICMP time exceeded codes */ +enum icmp_te_type { + /** time to live exceeded in transit */ + ICMP_TE_TTL = 0, + /** fragment reassembly time exceeded */ + ICMP_TE_FRAG = 1 +}; + +#if LWIP_IPV4 && LWIP_ICMP /* don't build if not configured for use in lwipopts.h */ + +void icmp_input(struct pbuf *p, struct netif *inp); +void icmp_dest_unreach(struct pbuf *p, enum icmp_dur_type t); +void icmp_time_exceeded(struct pbuf *p, enum icmp_te_type t); + +#endif /* LWIP_IPV4 && LWIP_ICMP */ + +#if LWIP_IPV4 && LWIP_IPV6 +#if LWIP_ICMP && LWIP_ICMP6 +#define icmp_port_unreach(isipv6, pbuf) ((isipv6) ? \ + icmp6_dest_unreach(pbuf, ICMP6_DUR_PORT) : \ + icmp_dest_unreach(pbuf, ICMP_DUR_PORT)) +#elif LWIP_ICMP +#define icmp_port_unreach(isipv6, pbuf) do{ if(!(isipv6)) { icmp_dest_unreach(pbuf, ICMP_DUR_PORT);}}while(0) +#elif LWIP_ICMP6 +#define icmp_port_unreach(isipv6, pbuf) do{ if(isipv6) { icmp6_dest_unreach(pbuf, ICMP6_DUR_PORT);}}while(0) +#else +#define icmp_port_unreach(isipv6, pbuf) +#endif +#elif LWIP_IPV6 && LWIP_ICMP6 +#define icmp_port_unreach(isipv6, pbuf) icmp6_dest_unreach(pbuf, ICMP6_DUR_PORT) +#elif LWIP_IPV4 && LWIP_ICMP +#define icmp_port_unreach(isipv6, pbuf) icmp_dest_unreach(pbuf, ICMP_DUR_PORT) +#else /* (LWIP_IPV6 && LWIP_ICMP6) || (LWIP_IPV4 && LWIP_ICMP) */ +#define icmp_port_unreach(isipv6, pbuf) +#endif /* (LWIP_IPV6 && LWIP_ICMP6) || (LWIP_IPV4 && LWIP_ICMP) LWIP_IPV4*/ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_ICMP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp6.h index cb383d93..0ccb7899 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/icmp6.h @@ -1,72 +1,72 @@ -/** - * @file - * - * IPv6 version of ICMP, as per RFC 4443. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ -#ifndef LWIP_HDR_ICMP6_H -#define LWIP_HDR_ICMP6_H - -#include "lwip/opt.h" -#include "lwip/pbuf.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" -#include "lwip/prot/icmp6.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_ICMP6 && LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -void icmp6_input(struct pbuf *p, struct netif *inp); -void icmp6_dest_unreach(struct pbuf *p, enum icmp6_dur_code c); -void icmp6_packet_too_big(struct pbuf *p, u32_t mtu); -void icmp6_time_exceeded(struct pbuf *p, enum icmp6_te_code c); -void icmp6_time_exceeded_with_addrs(struct pbuf *p, enum icmp6_te_code c, - const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr); -void icmp6_param_problem(struct pbuf *p, enum icmp6_pp_code c, const void *pointer); - -#endif /* LWIP_ICMP6 && LWIP_IPV6 */ - - -#ifdef __cplusplus -} -#endif - - -#endif /* LWIP_HDR_ICMP6_H */ +/** + * @file + * + * IPv6 version of ICMP, as per RFC 4443. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ +#ifndef LWIP_HDR_ICMP6_H +#define LWIP_HDR_ICMP6_H + +#include "lwip/opt.h" +#include "lwip/pbuf.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" +#include "lwip/prot/icmp6.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_ICMP6 && LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +void icmp6_input(struct pbuf *p, struct netif *inp); +void icmp6_dest_unreach(struct pbuf *p, enum icmp6_dur_code c); +void icmp6_packet_too_big(struct pbuf *p, u32_t mtu); +void icmp6_time_exceeded(struct pbuf *p, enum icmp6_te_code c); +void icmp6_time_exceeded_with_addrs(struct pbuf *p, enum icmp6_te_code c, + const ip6_addr_t *src_addr, const ip6_addr_t *dest_addr); +void icmp6_param_problem(struct pbuf *p, enum icmp6_pp_code c, const void *pointer); + +#endif /* LWIP_ICMP6 && LWIP_IPV6 */ + + +#ifdef __cplusplus +} +#endif + + +#endif /* LWIP_HDR_ICMP6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/if_api.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/if_api.h index d8261f77..39017abd 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/if_api.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/if_api.h @@ -1,68 +1,68 @@ -/** - * @file - * Interface Identification APIs from: - * RFC 3493: Basic Socket Interface Extensions for IPv6 - * Section 4: Interface Identification - */ - -/* - * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Joel Cunningham - * - */ -#ifndef LWIP_HDR_IF_H -#define LWIP_HDR_IF_H - -#include "lwip/opt.h" - -#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define IF_NAMESIZE NETIF_NAMESIZE - -char * lwip_if_indextoname(unsigned int ifindex, char *ifname); -unsigned int lwip_if_nametoindex(const char *ifname); - -#if LWIP_COMPAT_SOCKETS -#define if_indextoname(ifindex, ifname) lwip_if_indextoname(ifindex,ifname) -#define if_nametoindex(ifname) lwip_if_nametoindex(ifname) -#endif /* LWIP_COMPAT_SOCKETS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_SOCKET */ - -#endif /* LWIP_HDR_IF_H */ +/** + * @file + * Interface Identification APIs from: + * RFC 3493: Basic Socket Interface Extensions for IPv6 + * Section 4: Interface Identification + */ + +/* + * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Joel Cunningham + * + */ +#ifndef LWIP_HDR_IF_H +#define LWIP_HDR_IF_H + +#include "lwip/opt.h" + +#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define IF_NAMESIZE NETIF_NAMESIZE + +char * lwip_if_indextoname(unsigned int ifindex, char *ifname); +unsigned int lwip_if_nametoindex(const char *ifname); + +#if LWIP_COMPAT_SOCKETS +#define if_indextoname(ifindex, ifname) lwip_if_indextoname(ifindex,ifname) +#define if_nametoindex(ifname) lwip_if_nametoindex(ifname) +#endif /* LWIP_COMPAT_SOCKETS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_SOCKET */ + +#endif /* LWIP_HDR_IF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/igmp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/igmp.h index ca52a2d3..ffd80e68 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/igmp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/igmp.h @@ -1,115 +1,115 @@ -/** - * @file - * IGMP API - */ - -/* - * Copyright (c) 2002 CITEL Technologies 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 CITEL Technologies Ltd 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 CITEL TECHNOLOGIES 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 CITEL TECHNOLOGIES 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. - * - * This file is a contribution to the lwIP TCP/IP stack. - * The Swedish Institute of Computer Science and Adam Dunkels - * are specifically granted permission to redistribute this - * source code. -*/ - -#ifndef LWIP_HDR_IGMP_H -#define LWIP_HDR_IGMP_H - -#include "lwip/opt.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/pbuf.h" - -#if LWIP_IPV4 && LWIP_IGMP /* don't build if not configured for use in lwipopts.h */ - -#ifdef __cplusplus -extern "C" { -#endif - -/* IGMP timer */ -#define IGMP_TMR_INTERVAL 100 /* Milliseconds */ -#define IGMP_V1_DELAYING_MEMBER_TMR (1000/IGMP_TMR_INTERVAL) -#define IGMP_JOIN_DELAYING_MEMBER_TMR (500 /IGMP_TMR_INTERVAL) - -/* Compatibility defines (don't use for new code) */ -#define IGMP_DEL_MAC_FILTER NETIF_DEL_MAC_FILTER -#define IGMP_ADD_MAC_FILTER NETIF_ADD_MAC_FILTER - -/** - * igmp group structure - there is - * a list of groups for each interface - * these should really be linked from the interface, but - * if we keep them separate we will not affect the lwip original code - * too much - * - * There will be a group for the all systems group address but this - * will not run the state machine as it is used to kick off reports - * from all the other groups - */ -struct igmp_group { - /** next link */ - struct igmp_group *next; - /** multicast address */ - ip4_addr_t group_address; - /** signifies we were the last person to report */ - u8_t last_reporter_flag; - /** current state of the group */ - u8_t group_state; - /** timer for reporting, negative is OFF */ - u16_t timer; - /** counter of simultaneous uses */ - u8_t use; -}; - -/* Prototypes */ -void igmp_init(void); -err_t igmp_start(struct netif *netif); -err_t igmp_stop(struct netif *netif); -void igmp_report_groups(struct netif *netif); -struct igmp_group *igmp_lookfor_group(struct netif *ifp, const ip4_addr_t *addr); -void igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest); -err_t igmp_joingroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr); -err_t igmp_joingroup_netif(struct netif *netif, const ip4_addr_t *groupaddr); -err_t igmp_leavegroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr); -err_t igmp_leavegroup_netif(struct netif *netif, const ip4_addr_t *groupaddr); -void igmp_tmr(void); - -/** @ingroup igmp - * Get list head of IGMP groups for netif. - * Note: The allsystems group IP is contained in the list as first entry. - * @see @ref netif_set_igmp_mac_filter() - */ -#define netif_igmp_data(netif) ((struct igmp_group *)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV4 && LWIP_IGMP */ - -#endif /* LWIP_HDR_IGMP_H */ +/** + * @file + * IGMP API + */ + +/* + * Copyright (c) 2002 CITEL Technologies 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 CITEL Technologies Ltd 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 CITEL TECHNOLOGIES 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 CITEL TECHNOLOGIES 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. + * + * This file is a contribution to the lwIP TCP/IP stack. + * The Swedish Institute of Computer Science and Adam Dunkels + * are specifically granted permission to redistribute this + * source code. +*/ + +#ifndef LWIP_HDR_IGMP_H +#define LWIP_HDR_IGMP_H + +#include "lwip/opt.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/pbuf.h" + +#if LWIP_IPV4 && LWIP_IGMP /* don't build if not configured for use in lwipopts.h */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* IGMP timer */ +#define IGMP_TMR_INTERVAL 100 /* Milliseconds */ +#define IGMP_V1_DELAYING_MEMBER_TMR (1000/IGMP_TMR_INTERVAL) +#define IGMP_JOIN_DELAYING_MEMBER_TMR (500 /IGMP_TMR_INTERVAL) + +/* Compatibility defines (don't use for new code) */ +#define IGMP_DEL_MAC_FILTER NETIF_DEL_MAC_FILTER +#define IGMP_ADD_MAC_FILTER NETIF_ADD_MAC_FILTER + +/** + * igmp group structure - there is + * a list of groups for each interface + * these should really be linked from the interface, but + * if we keep them separate we will not affect the lwip original code + * too much + * + * There will be a group for the all systems group address but this + * will not run the state machine as it is used to kick off reports + * from all the other groups + */ +struct igmp_group { + /** next link */ + struct igmp_group *next; + /** multicast address */ + ip4_addr_t group_address; + /** signifies we were the last person to report */ + u8_t last_reporter_flag; + /** current state of the group */ + u8_t group_state; + /** timer for reporting, negative is OFF */ + u16_t timer; + /** counter of simultaneous uses */ + u8_t use; +}; + +/* Prototypes */ +void igmp_init(void); +err_t igmp_start(struct netif *netif); +err_t igmp_stop(struct netif *netif); +void igmp_report_groups(struct netif *netif); +struct igmp_group *igmp_lookfor_group(struct netif *ifp, const ip4_addr_t *addr); +void igmp_input(struct pbuf *p, struct netif *inp, const ip4_addr_t *dest); +err_t igmp_joingroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr); +err_t igmp_joingroup_netif(struct netif *netif, const ip4_addr_t *groupaddr); +err_t igmp_leavegroup(const ip4_addr_t *ifaddr, const ip4_addr_t *groupaddr); +err_t igmp_leavegroup_netif(struct netif *netif, const ip4_addr_t *groupaddr); +void igmp_tmr(void); + +/** @ingroup igmp + * Get list head of IGMP groups for netif. + * Note: The allsystems group IP is contained in the list as first entry. + * @see @ref netif_set_igmp_mac_filter() + */ +#define netif_igmp_data(netif) ((struct igmp_group *)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_IGMP)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV4 && LWIP_IGMP */ + +#endif /* LWIP_HDR_IGMP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet.h index 36f6ec73..2982a0f4 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet.h @@ -1,169 +1,169 @@ -/** - * @file - * This file (together with sockets.h) aims to provide structs and functions from - * - arpa/inet.h - * - netinet/in.h - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_INET_H -#define LWIP_HDR_INET_H - -#include "lwip/opt.h" -#include "lwip/def.h" -#include "lwip/ip_addr.h" -#include "lwip/ip6_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* If your port already typedef's in_addr_t, define IN_ADDR_T_DEFINED - to prevent this code from redefining it. */ -#if !defined(in_addr_t) && !defined(IN_ADDR_T_DEFINED) -typedef u32_t in_addr_t; -#endif - -struct in_addr { - in_addr_t s_addr; -}; - -struct in6_addr { - union { - u32_t u32_addr[4]; - u8_t u8_addr[16]; - } un; -#define s6_addr un.u8_addr -}; - -/** 255.255.255.255 */ -#define INADDR_NONE IPADDR_NONE -/** 127.0.0.1 */ -#define INADDR_LOOPBACK IPADDR_LOOPBACK -/** 0.0.0.0 */ -#define INADDR_ANY IPADDR_ANY -/** 255.255.255.255 */ -#define INADDR_BROADCAST IPADDR_BROADCAST - -/** This macro can be used to initialize a variable of type struct in6_addr - to the IPv6 wildcard address. */ -#define IN6ADDR_ANY_INIT {{{0,0,0,0}}} -/** This macro can be used to initialize a variable of type struct in6_addr - to the IPv6 loopback address. */ -#define IN6ADDR_LOOPBACK_INIT {{{0,0,0,PP_HTONL(1)}}} -/** This variable is initialized by the system to contain the wildcard IPv6 address. */ -extern const struct in6_addr in6addr_any; - -/* Definitions of the bits in an (IPv4) Internet address integer. - - On subnets, host and network parts are found according to - the subnet mask, not these masks. */ -#define IN_CLASSA(a) IP_CLASSA(a) -#define IN_CLASSA_NET IP_CLASSA_NET -#define IN_CLASSA_NSHIFT IP_CLASSA_NSHIFT -#define IN_CLASSA_HOST IP_CLASSA_HOST -#define IN_CLASSA_MAX IP_CLASSA_MAX - -#define IN_CLASSB(b) IP_CLASSB(b) -#define IN_CLASSB_NET IP_CLASSB_NET -#define IN_CLASSB_NSHIFT IP_CLASSB_NSHIFT -#define IN_CLASSB_HOST IP_CLASSB_HOST -#define IN_CLASSB_MAX IP_CLASSB_MAX - -#define IN_CLASSC(c) IP_CLASSC(c) -#define IN_CLASSC_NET IP_CLASSC_NET -#define IN_CLASSC_NSHIFT IP_CLASSC_NSHIFT -#define IN_CLASSC_HOST IP_CLASSC_HOST -#define IN_CLASSC_MAX IP_CLASSC_MAX - -#define IN_CLASSD(d) IP_CLASSD(d) -#define IN_CLASSD_NET IP_CLASSD_NET /* These ones aren't really */ -#define IN_CLASSD_NSHIFT IP_CLASSD_NSHIFT /* net and host fields, but */ -#define IN_CLASSD_HOST IP_CLASSD_HOST /* routing needn't know. */ -#define IN_CLASSD_MAX IP_CLASSD_MAX - -#define IN_MULTICAST(a) IP_MULTICAST(a) - -#define IN_EXPERIMENTAL(a) IP_EXPERIMENTAL(a) -#define IN_BADCLASS(a) IP_BADCLASS(a) - -#define IN_LOOPBACKNET IP_LOOPBACKNET - - -#ifndef INET_ADDRSTRLEN -#define INET_ADDRSTRLEN IP4ADDR_STRLEN_MAX -#endif -#if LWIP_IPV6 -#ifndef INET6_ADDRSTRLEN -#define INET6_ADDRSTRLEN IP6ADDR_STRLEN_MAX -#endif -#endif - -#if LWIP_IPV4 - -#define inet_addr_from_ip4addr(target_inaddr, source_ipaddr) ((target_inaddr)->s_addr = ip4_addr_get_u32(source_ipaddr)) -#define inet_addr_to_ip4addr(target_ipaddr, source_inaddr) (ip4_addr_set_u32(target_ipaddr, (source_inaddr)->s_addr)) - -/* directly map this to the lwip internal functions */ -#define inet_addr(cp) ipaddr_addr(cp) -#define inet_aton(cp, addr) ip4addr_aton(cp, (ip4_addr_t*)addr) -#define inet_ntoa(addr) ip4addr_ntoa((const ip4_addr_t*)&(addr)) -#define inet_ntoa_r(addr, buf, buflen) ip4addr_ntoa_r((const ip4_addr_t*)&(addr), buf, buflen) - -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -#define inet6_addr_from_ip6addr(target_in6addr, source_ip6addr) {(target_in6addr)->un.u32_addr[0] = (source_ip6addr)->addr[0]; \ - (target_in6addr)->un.u32_addr[1] = (source_ip6addr)->addr[1]; \ - (target_in6addr)->un.u32_addr[2] = (source_ip6addr)->addr[2]; \ - (target_in6addr)->un.u32_addr[3] = (source_ip6addr)->addr[3];} -#define inet6_addr_to_ip6addr(target_ip6addr, source_in6addr) {(target_ip6addr)->addr[0] = (source_in6addr)->un.u32_addr[0]; \ - (target_ip6addr)->addr[1] = (source_in6addr)->un.u32_addr[1]; \ - (target_ip6addr)->addr[2] = (source_in6addr)->un.u32_addr[2]; \ - (target_ip6addr)->addr[3] = (source_in6addr)->un.u32_addr[3]; \ - ip6_addr_clear_zone(target_ip6addr);} - -/* directly map this to the lwip internal functions */ -#define inet6_aton(cp, addr) ip6addr_aton(cp, (ip6_addr_t*)addr) -#define inet6_ntoa(addr) ip6addr_ntoa((const ip6_addr_t*)&(addr)) -#define inet6_ntoa_r(addr, buf, buflen) ip6addr_ntoa_r((const ip6_addr_t*)&(addr), buf, buflen) - -#endif /* LWIP_IPV6 */ - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_INET_H */ +/** + * @file + * This file (together with sockets.h) aims to provide structs and functions from + * - arpa/inet.h + * - netinet/in.h + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_INET_H +#define LWIP_HDR_INET_H + +#include "lwip/opt.h" +#include "lwip/def.h" +#include "lwip/ip_addr.h" +#include "lwip/ip6_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* If your port already typedef's in_addr_t, define IN_ADDR_T_DEFINED + to prevent this code from redefining it. */ +#if !defined(in_addr_t) && !defined(IN_ADDR_T_DEFINED) +typedef u32_t in_addr_t; +#endif + +struct in_addr { + in_addr_t s_addr; +}; + +struct in6_addr { + union { + u32_t u32_addr[4]; + u8_t u8_addr[16]; + } un; +#define s6_addr un.u8_addr +}; + +/** 255.255.255.255 */ +#define INADDR_NONE IPADDR_NONE +/** 127.0.0.1 */ +#define INADDR_LOOPBACK IPADDR_LOOPBACK +/** 0.0.0.0 */ +#define INADDR_ANY IPADDR_ANY +/** 255.255.255.255 */ +#define INADDR_BROADCAST IPADDR_BROADCAST + +/** This macro can be used to initialize a variable of type struct in6_addr + to the IPv6 wildcard address. */ +#define IN6ADDR_ANY_INIT {{{0,0,0,0}}} +/** This macro can be used to initialize a variable of type struct in6_addr + to the IPv6 loopback address. */ +#define IN6ADDR_LOOPBACK_INIT {{{0,0,0,PP_HTONL(1)}}} +/** This variable is initialized by the system to contain the wildcard IPv6 address. */ +extern const struct in6_addr in6addr_any; + +/* Definitions of the bits in an (IPv4) Internet address integer. + + On subnets, host and network parts are found according to + the subnet mask, not these masks. */ +#define IN_CLASSA(a) IP_CLASSA(a) +#define IN_CLASSA_NET IP_CLASSA_NET +#define IN_CLASSA_NSHIFT IP_CLASSA_NSHIFT +#define IN_CLASSA_HOST IP_CLASSA_HOST +#define IN_CLASSA_MAX IP_CLASSA_MAX + +#define IN_CLASSB(b) IP_CLASSB(b) +#define IN_CLASSB_NET IP_CLASSB_NET +#define IN_CLASSB_NSHIFT IP_CLASSB_NSHIFT +#define IN_CLASSB_HOST IP_CLASSB_HOST +#define IN_CLASSB_MAX IP_CLASSB_MAX + +#define IN_CLASSC(c) IP_CLASSC(c) +#define IN_CLASSC_NET IP_CLASSC_NET +#define IN_CLASSC_NSHIFT IP_CLASSC_NSHIFT +#define IN_CLASSC_HOST IP_CLASSC_HOST +#define IN_CLASSC_MAX IP_CLASSC_MAX + +#define IN_CLASSD(d) IP_CLASSD(d) +#define IN_CLASSD_NET IP_CLASSD_NET /* These ones aren't really */ +#define IN_CLASSD_NSHIFT IP_CLASSD_NSHIFT /* net and host fields, but */ +#define IN_CLASSD_HOST IP_CLASSD_HOST /* routing needn't know. */ +#define IN_CLASSD_MAX IP_CLASSD_MAX + +#define IN_MULTICAST(a) IP_MULTICAST(a) + +#define IN_EXPERIMENTAL(a) IP_EXPERIMENTAL(a) +#define IN_BADCLASS(a) IP_BADCLASS(a) + +#define IN_LOOPBACKNET IP_LOOPBACKNET + + +#ifndef INET_ADDRSTRLEN +#define INET_ADDRSTRLEN IP4ADDR_STRLEN_MAX +#endif +#if LWIP_IPV6 +#ifndef INET6_ADDRSTRLEN +#define INET6_ADDRSTRLEN IP6ADDR_STRLEN_MAX +#endif +#endif + +#if LWIP_IPV4 + +#define inet_addr_from_ip4addr(target_inaddr, source_ipaddr) ((target_inaddr)->s_addr = ip4_addr_get_u32(source_ipaddr)) +#define inet_addr_to_ip4addr(target_ipaddr, source_inaddr) (ip4_addr_set_u32(target_ipaddr, (source_inaddr)->s_addr)) + +/* directly map this to the lwip internal functions */ +#define inet_addr(cp) ipaddr_addr(cp) +#define inet_aton(cp, addr) ip4addr_aton(cp, (ip4_addr_t*)addr) +#define inet_ntoa(addr) ip4addr_ntoa((const ip4_addr_t*)&(addr)) +#define inet_ntoa_r(addr, buf, buflen) ip4addr_ntoa_r((const ip4_addr_t*)&(addr), buf, buflen) + +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +#define inet6_addr_from_ip6addr(target_in6addr, source_ip6addr) {(target_in6addr)->un.u32_addr[0] = (source_ip6addr)->addr[0]; \ + (target_in6addr)->un.u32_addr[1] = (source_ip6addr)->addr[1]; \ + (target_in6addr)->un.u32_addr[2] = (source_ip6addr)->addr[2]; \ + (target_in6addr)->un.u32_addr[3] = (source_ip6addr)->addr[3];} +#define inet6_addr_to_ip6addr(target_ip6addr, source_in6addr) {(target_ip6addr)->addr[0] = (source_in6addr)->un.u32_addr[0]; \ + (target_ip6addr)->addr[1] = (source_in6addr)->un.u32_addr[1]; \ + (target_ip6addr)->addr[2] = (source_in6addr)->un.u32_addr[2]; \ + (target_ip6addr)->addr[3] = (source_in6addr)->un.u32_addr[3]; \ + ip6_addr_clear_zone(target_ip6addr);} + +/* directly map this to the lwip internal functions */ +#define inet6_aton(cp, addr) ip6addr_aton(cp, (ip6_addr_t*)addr) +#define inet6_ntoa(addr) ip6addr_ntoa((const ip6_addr_t*)&(addr)) +#define inet6_ntoa_r(addr, buf, buflen) ip6addr_ntoa_r((const ip6_addr_t*)&(addr), buf, buflen) + +#endif /* LWIP_IPV6 */ + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_INET_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet_chksum.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet_chksum.h index 46ec2ae6..76893ef5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet_chksum.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/inet_chksum.h @@ -1,105 +1,105 @@ -/** - * @file - * IP checksum calculation functions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_INET_CHKSUM_H -#define LWIP_HDR_INET_CHKSUM_H - -#include "lwip/opt.h" - -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" - -/** Swap the bytes in an u16_t: much like lwip_htons() for little-endian */ -#ifndef SWAP_BYTES_IN_WORD -#define SWAP_BYTES_IN_WORD(w) (((w) & 0xff) << 8) | (((w) & 0xff00) >> 8) -#endif /* SWAP_BYTES_IN_WORD */ - -/** Split an u32_t in two u16_ts and add them up */ -#ifndef FOLD_U32T -#define FOLD_U32T(u) ((u32_t)(((u) >> 16) + ((u) & 0x0000ffffUL))) -#endif - -#if LWIP_CHECKSUM_ON_COPY -/** Function-like macro: same as MEMCPY but returns the checksum of copied data - as u16_t */ -# ifndef LWIP_CHKSUM_COPY -# define LWIP_CHKSUM_COPY(dst, src, len) lwip_chksum_copy(dst, src, len) -# ifndef LWIP_CHKSUM_COPY_ALGORITHM -# define LWIP_CHKSUM_COPY_ALGORITHM 1 -# endif /* LWIP_CHKSUM_COPY_ALGORITHM */ -# else /* LWIP_CHKSUM_COPY */ -# define LWIP_CHKSUM_COPY_ALGORITHM 0 -# endif /* LWIP_CHKSUM_COPY */ -#else /* LWIP_CHECKSUM_ON_COPY */ -# define LWIP_CHKSUM_COPY_ALGORITHM 0 -#endif /* LWIP_CHECKSUM_ON_COPY */ - -#ifdef __cplusplus -extern "C" { -#endif - -u16_t inet_chksum(const void *dataptr, u16_t len); -u16_t inet_chksum_pbuf(struct pbuf *p); -#if LWIP_CHKSUM_COPY_ALGORITHM -u16_t lwip_chksum_copy(void *dst, const void *src, u16_t len); -#endif /* LWIP_CHKSUM_COPY_ALGORITHM */ - -#if LWIP_IPV4 -u16_t inet_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, - const ip4_addr_t *src, const ip4_addr_t *dest); -u16_t inet_chksum_pseudo_partial(struct pbuf *p, u8_t proto, - u16_t proto_len, u16_t chksum_len, const ip4_addr_t *src, const ip4_addr_t *dest); -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -u16_t ip6_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, - const ip6_addr_t *src, const ip6_addr_t *dest); -u16_t ip6_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, - u16_t chksum_len, const ip6_addr_t *src, const ip6_addr_t *dest); -#endif /* LWIP_IPV6 */ - - -u16_t ip_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, - const ip_addr_t *src, const ip_addr_t *dest); -u16_t ip_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, - u16_t chksum_len, const ip_addr_t *src, const ip_addr_t *dest); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_INET_H */ - +/** + * @file + * IP checksum calculation functions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_INET_CHKSUM_H +#define LWIP_HDR_INET_CHKSUM_H + +#include "lwip/opt.h" + +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" + +/** Swap the bytes in an u16_t: much like lwip_htons() for little-endian */ +#ifndef SWAP_BYTES_IN_WORD +#define SWAP_BYTES_IN_WORD(w) (((w) & 0xff) << 8) | (((w) & 0xff00) >> 8) +#endif /* SWAP_BYTES_IN_WORD */ + +/** Split an u32_t in two u16_ts and add them up */ +#ifndef FOLD_U32T +#define FOLD_U32T(u) ((u32_t)(((u) >> 16) + ((u) & 0x0000ffffUL))) +#endif + +#if LWIP_CHECKSUM_ON_COPY +/** Function-like macro: same as MEMCPY but returns the checksum of copied data + as u16_t */ +# ifndef LWIP_CHKSUM_COPY +# define LWIP_CHKSUM_COPY(dst, src, len) lwip_chksum_copy(dst, src, len) +# ifndef LWIP_CHKSUM_COPY_ALGORITHM +# define LWIP_CHKSUM_COPY_ALGORITHM 1 +# endif /* LWIP_CHKSUM_COPY_ALGORITHM */ +# else /* LWIP_CHKSUM_COPY */ +# define LWIP_CHKSUM_COPY_ALGORITHM 0 +# endif /* LWIP_CHKSUM_COPY */ +#else /* LWIP_CHECKSUM_ON_COPY */ +# define LWIP_CHKSUM_COPY_ALGORITHM 0 +#endif /* LWIP_CHECKSUM_ON_COPY */ + +#ifdef __cplusplus +extern "C" { +#endif + +u16_t inet_chksum(const void *dataptr, u16_t len); +u16_t inet_chksum_pbuf(struct pbuf *p); +#if LWIP_CHKSUM_COPY_ALGORITHM +u16_t lwip_chksum_copy(void *dst, const void *src, u16_t len); +#endif /* LWIP_CHKSUM_COPY_ALGORITHM */ + +#if LWIP_IPV4 +u16_t inet_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, + const ip4_addr_t *src, const ip4_addr_t *dest); +u16_t inet_chksum_pseudo_partial(struct pbuf *p, u8_t proto, + u16_t proto_len, u16_t chksum_len, const ip4_addr_t *src, const ip4_addr_t *dest); +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +u16_t ip6_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, + const ip6_addr_t *src, const ip6_addr_t *dest); +u16_t ip6_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, + u16_t chksum_len, const ip6_addr_t *src, const ip6_addr_t *dest); +#endif /* LWIP_IPV6 */ + + +u16_t ip_chksum_pseudo(struct pbuf *p, u8_t proto, u16_t proto_len, + const ip_addr_t *src, const ip_addr_t *dest); +u16_t ip_chksum_pseudo_partial(struct pbuf *p, u8_t proto, u16_t proto_len, + u16_t chksum_len, const ip_addr_t *src, const ip_addr_t *dest); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_INET_H */ + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h index 48c256bc..a149be18 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h @@ -1,100 +1,100 @@ -/** - * @file - * lwIP initialization API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_INIT_H -#define LWIP_HDR_INIT_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @defgroup lwip_version Version - * @ingroup lwip - * @{ - */ - -/** X.x.x: Major version of the stack */ -#define LWIP_VERSION_MAJOR 2 -/** x.X.x: Minor version of the stack */ -#define LWIP_VERSION_MINOR 1 -/** x.x.X: Revision of the stack */ -#define LWIP_VERSION_REVISION 2 -/** For release candidates, this is set to 1..254 - * For official releases, this is set to 255 (LWIP_RC_RELEASE) - * For development versions (Git), this is set to 0 (LWIP_RC_DEVELOPMENT) */ -#define LWIP_VERSION_RC LWIP_RC_RELEASE - -/** LWIP_VERSION_RC is set to LWIP_RC_RELEASE for official releases */ -#define LWIP_RC_RELEASE 255 -/** LWIP_VERSION_RC is set to LWIP_RC_DEVELOPMENT for Git versions */ -#define LWIP_RC_DEVELOPMENT 0 - -#define LWIP_VERSION_IS_RELEASE (LWIP_VERSION_RC == LWIP_RC_RELEASE) -#define LWIP_VERSION_IS_DEVELOPMENT (LWIP_VERSION_RC == LWIP_RC_DEVELOPMENT) -#define LWIP_VERSION_IS_RC ((LWIP_VERSION_RC != LWIP_RC_RELEASE) && (LWIP_VERSION_RC != LWIP_RC_DEVELOPMENT)) - -/* Some helper defines to get a version string */ -#define LWIP_VERSTR2(x) #x -#define LWIP_VERSTR(x) LWIP_VERSTR2(x) -#if LWIP_VERSION_IS_RELEASE -#define LWIP_VERSION_STRING_SUFFIX "" -#elif LWIP_VERSION_IS_DEVELOPMENT -#define LWIP_VERSION_STRING_SUFFIX "d" -#else -#define LWIP_VERSION_STRING_SUFFIX "rc" LWIP_VERSTR(LWIP_VERSION_RC) -#endif - -/** Provides the version of the stack */ -#define LWIP_VERSION ((LWIP_VERSION_MAJOR) << 24 | (LWIP_VERSION_MINOR) << 16 | \ - (LWIP_VERSION_REVISION) << 8 | (LWIP_VERSION_RC)) -/** Provides the version of the stack as string */ -#define LWIP_VERSION_STRING LWIP_VERSTR(LWIP_VERSION_MAJOR) "." LWIP_VERSTR(LWIP_VERSION_MINOR) "." LWIP_VERSTR(LWIP_VERSION_REVISION) LWIP_VERSION_STRING_SUFFIX - -/** - * @} - */ - -/* Modules initialization */ -void lwip_init(void); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_INIT_H */ +/** + * @file + * lwIP initialization API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_INIT_H +#define LWIP_HDR_INIT_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup lwip_version Version + * @ingroup lwip + * @{ + */ + +/** X.x.x: Major version of the stack */ +#define LWIP_VERSION_MAJOR 2 +/** x.X.x: Minor version of the stack */ +#define LWIP_VERSION_MINOR 1 +/** x.x.X: Revision of the stack */ +#define LWIP_VERSION_REVISION 2 +/** For release candidates, this is set to 1..254 + * For official releases, this is set to 255 (LWIP_RC_RELEASE) + * For development versions (Git), this is set to 0 (LWIP_RC_DEVELOPMENT) */ +#define LWIP_VERSION_RC LWIP_RC_RELEASE + +/** LWIP_VERSION_RC is set to LWIP_RC_RELEASE for official releases */ +#define LWIP_RC_RELEASE 255 +/** LWIP_VERSION_RC is set to LWIP_RC_DEVELOPMENT for Git versions */ +#define LWIP_RC_DEVELOPMENT 0 + +#define LWIP_VERSION_IS_RELEASE (LWIP_VERSION_RC == LWIP_RC_RELEASE) +#define LWIP_VERSION_IS_DEVELOPMENT (LWIP_VERSION_RC == LWIP_RC_DEVELOPMENT) +#define LWIP_VERSION_IS_RC ((LWIP_VERSION_RC != LWIP_RC_RELEASE) && (LWIP_VERSION_RC != LWIP_RC_DEVELOPMENT)) + +/* Some helper defines to get a version string */ +#define LWIP_VERSTR2(x) #x +#define LWIP_VERSTR(x) LWIP_VERSTR2(x) +#if LWIP_VERSION_IS_RELEASE +#define LWIP_VERSION_STRING_SUFFIX "" +#elif LWIP_VERSION_IS_DEVELOPMENT +#define LWIP_VERSION_STRING_SUFFIX "d" +#else +#define LWIP_VERSION_STRING_SUFFIX "rc" LWIP_VERSTR(LWIP_VERSION_RC) +#endif + +/** Provides the version of the stack */ +#define LWIP_VERSION ((LWIP_VERSION_MAJOR) << 24 | (LWIP_VERSION_MINOR) << 16 | \ + (LWIP_VERSION_REVISION) << 8 | (LWIP_VERSION_RC)) +/** Provides the version of the stack as string */ +#define LWIP_VERSION_STRING LWIP_VERSTR(LWIP_VERSION_MAJOR) "." LWIP_VERSTR(LWIP_VERSION_MINOR) "." LWIP_VERSTR(LWIP_VERSION_REVISION) LWIP_VERSION_STRING_SUFFIX + +/** + * @} + */ + +/* Modules initialization */ +void lwip_init(void); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_INIT_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h.cmake.in b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h.cmake.in index d7c017ea..9b609b74 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h.cmake.in +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/init.h.cmake.in @@ -1,100 +1,100 @@ -/** - * @file - * lwIP initialization API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_INIT_H -#define LWIP_HDR_INIT_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @defgroup lwip_version Version - * @ingroup lwip - * @{ - */ - -/** X.x.x: Major version of the stack */ -#define LWIP_VERSION_MAJOR ${LWIP_VERSION_MAJOR} -/** x.X.x: Minor version of the stack */ -#define LWIP_VERSION_MINOR ${LWIP_VERSION_MINOR} -/** x.x.X: Revision of the stack */ -#define LWIP_VERSION_REVISION ${LWIP_VERSION_REVISION} -/** For release candidates, this is set to 1..254 - * For official releases, this is set to 255 (LWIP_RC_RELEASE) - * For development versions (Git), this is set to 0 (LWIP_RC_DEVELOPMENT) */ -#define LWIP_VERSION_RC ${LWIP_VERSION_RC} - -/** LWIP_VERSION_RC is set to LWIP_RC_RELEASE for official releases */ -#define LWIP_RC_RELEASE 255 -/** LWIP_VERSION_RC is set to LWIP_RC_DEVELOPMENT for Git versions */ -#define LWIP_RC_DEVELOPMENT 0 - -#define LWIP_VERSION_IS_RELEASE (LWIP_VERSION_RC == LWIP_RC_RELEASE) -#define LWIP_VERSION_IS_DEVELOPMENT (LWIP_VERSION_RC == LWIP_RC_DEVELOPMENT) -#define LWIP_VERSION_IS_RC ((LWIP_VERSION_RC != LWIP_RC_RELEASE) && (LWIP_VERSION_RC != LWIP_RC_DEVELOPMENT)) - -/* Some helper defines to get a version string */ -#define LWIP_VERSTR2(x) #x -#define LWIP_VERSTR(x) LWIP_VERSTR2(x) -#if LWIP_VERSION_IS_RELEASE -#define LWIP_VERSION_STRING_SUFFIX "" -#elif LWIP_VERSION_IS_DEVELOPMENT -#define LWIP_VERSION_STRING_SUFFIX "d" -#else -#define LWIP_VERSION_STRING_SUFFIX "rc" LWIP_VERSTR(LWIP_VERSION_RC) -#endif - -/** Provides the version of the stack */ -#define LWIP_VERSION ((LWIP_VERSION_MAJOR) << 24 | (LWIP_VERSION_MINOR) << 16 | \ - (LWIP_VERSION_REVISION) << 8 | (LWIP_VERSION_RC)) -/** Provides the version of the stack as string */ -#define LWIP_VERSION_STRING LWIP_VERSTR(LWIP_VERSION_MAJOR) "." LWIP_VERSTR(LWIP_VERSION_MINOR) "." LWIP_VERSTR(LWIP_VERSION_REVISION) LWIP_VERSION_STRING_SUFFIX - -/** - * @} - */ - -/* Modules initialization */ -void lwip_init(void); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_INIT_H */ +/** + * @file + * lwIP initialization API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_INIT_H +#define LWIP_HDR_INIT_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup lwip_version Version + * @ingroup lwip + * @{ + */ + +/** X.x.x: Major version of the stack */ +#define LWIP_VERSION_MAJOR ${LWIP_VERSION_MAJOR} +/** x.X.x: Minor version of the stack */ +#define LWIP_VERSION_MINOR ${LWIP_VERSION_MINOR} +/** x.x.X: Revision of the stack */ +#define LWIP_VERSION_REVISION ${LWIP_VERSION_REVISION} +/** For release candidates, this is set to 1..254 + * For official releases, this is set to 255 (LWIP_RC_RELEASE) + * For development versions (Git), this is set to 0 (LWIP_RC_DEVELOPMENT) */ +#define LWIP_VERSION_RC ${LWIP_VERSION_RC} + +/** LWIP_VERSION_RC is set to LWIP_RC_RELEASE for official releases */ +#define LWIP_RC_RELEASE 255 +/** LWIP_VERSION_RC is set to LWIP_RC_DEVELOPMENT for Git versions */ +#define LWIP_RC_DEVELOPMENT 0 + +#define LWIP_VERSION_IS_RELEASE (LWIP_VERSION_RC == LWIP_RC_RELEASE) +#define LWIP_VERSION_IS_DEVELOPMENT (LWIP_VERSION_RC == LWIP_RC_DEVELOPMENT) +#define LWIP_VERSION_IS_RC ((LWIP_VERSION_RC != LWIP_RC_RELEASE) && (LWIP_VERSION_RC != LWIP_RC_DEVELOPMENT)) + +/* Some helper defines to get a version string */ +#define LWIP_VERSTR2(x) #x +#define LWIP_VERSTR(x) LWIP_VERSTR2(x) +#if LWIP_VERSION_IS_RELEASE +#define LWIP_VERSION_STRING_SUFFIX "" +#elif LWIP_VERSION_IS_DEVELOPMENT +#define LWIP_VERSION_STRING_SUFFIX "d" +#else +#define LWIP_VERSION_STRING_SUFFIX "rc" LWIP_VERSTR(LWIP_VERSION_RC) +#endif + +/** Provides the version of the stack */ +#define LWIP_VERSION ((LWIP_VERSION_MAJOR) << 24 | (LWIP_VERSION_MINOR) << 16 | \ + (LWIP_VERSION_REVISION) << 8 | (LWIP_VERSION_RC)) +/** Provides the version of the stack as string */ +#define LWIP_VERSION_STRING LWIP_VERSTR(LWIP_VERSION_MAJOR) "." LWIP_VERSTR(LWIP_VERSION_MINOR) "." LWIP_VERSTR(LWIP_VERSION_REVISION) LWIP_VERSION_STRING_SUFFIX + +/** + * @} + */ + +/* Modules initialization */ +void lwip_init(void); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_INIT_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip.h index 28889d54..653c3b2f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip.h @@ -1,330 +1,330 @@ -/** - * @file - * IP API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_IP_H -#define LWIP_HDR_IP_H - -#include "lwip/opt.h" - -#include "lwip/def.h" -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" -#include "lwip/err.h" -#include "lwip/netif.h" -#include "lwip/ip4.h" -#include "lwip/ip6.h" -#include "lwip/prot/ip.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* This is passed as the destination address to ip_output_if (not - to ip_output), meaning that an IP header already is constructed - in the pbuf. This is used when TCP retransmits. */ -#define LWIP_IP_HDRINCL NULL - -/** pbufs passed to IP must have a ref-count of 1 as their payload pointer - gets altered as the packet is passed down the stack */ -#ifndef LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX -#define LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p) LWIP_ASSERT("p->ref == 1", (p)->ref == 1) -#endif - -#if LWIP_NETIF_USE_HINTS -#define IP_PCB_NETIFHINT ;struct netif_hint netif_hints -#else /* LWIP_NETIF_USE_HINTS */ -#define IP_PCB_NETIFHINT -#endif /* LWIP_NETIF_USE_HINTS */ - -/** This is the common part of all PCB types. It needs to be at the - beginning of a PCB type definition. It is located here so that - changes to this common part are made in one location instead of - having to change all PCB structs. */ -#define IP_PCB \ - /* ip addresses in network byte order */ \ - ip_addr_t local_ip; \ - ip_addr_t remote_ip; \ - /* Bound netif index */ \ - u8_t netif_idx; \ - /* Socket options */ \ - u8_t so_options; \ - /* Type Of Service */ \ - u8_t tos; \ - /* Time To Live */ \ - u8_t ttl \ - /* link layer address resolution hint */ \ - IP_PCB_NETIFHINT - -struct ip_pcb { - /* Common members of all PCB types */ - IP_PCB; -}; - -/* - * Option flags per-socket. These are the same like SO_XXX in sockets.h - */ -#define SOF_REUSEADDR 0x04U /* allow local address reuse */ -#define SOF_KEEPALIVE 0x08U /* keep connections alive */ -#define SOF_BROADCAST 0x20U /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */ - -/* These flags are inherited (e.g. from a listen-pcb to a connection-pcb): */ -#define SOF_INHERITED (SOF_REUSEADDR|SOF_KEEPALIVE) - -/** Global variables of this module, kept in a struct for efficient access using base+index. */ -struct ip_globals -{ - /** The interface that accepted the packet for the current callback invocation. */ - struct netif *current_netif; - /** The interface that received the packet for the current callback invocation. */ - struct netif *current_input_netif; -#if LWIP_IPV4 - /** Header of the input packet currently being processed. */ - const struct ip_hdr *current_ip4_header; -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 - /** Header of the input IPv6 packet currently being processed. */ - struct ip6_hdr *current_ip6_header; -#endif /* LWIP_IPV6 */ - /** Total header length of current_ip4/6_header (i.e. after this, the UDP/TCP header starts) */ - u16_t current_ip_header_tot_len; - /** Source IP address of current_header */ - ip_addr_t current_iphdr_src; - /** Destination IP address of current_header */ - ip_addr_t current_iphdr_dest; -}; -extern struct ip_globals ip_data; - - -/** Get the interface that accepted the current packet. - * This may or may not be the receiving netif, depending on your netif/network setup. - * This function must only be called from a receive callback (udp_recv, - * raw_recv, tcp_accept). It will return NULL otherwise. */ -#define ip_current_netif() (ip_data.current_netif) -/** Get the interface that received the current packet. - * This function must only be called from a receive callback (udp_recv, - * raw_recv, tcp_accept). It will return NULL otherwise. */ -#define ip_current_input_netif() (ip_data.current_input_netif) -/** Total header length of ip(6)_current_header() (i.e. after this, the UDP/TCP header starts) */ -#define ip_current_header_tot_len() (ip_data.current_ip_header_tot_len) -/** Source IP address of current_header */ -#define ip_current_src_addr() (&ip_data.current_iphdr_src) -/** Destination IP address of current_header */ -#define ip_current_dest_addr() (&ip_data.current_iphdr_dest) - -#if LWIP_IPV4 && LWIP_IPV6 -/** Get the IPv4 header of the current packet. - * This function must only be called from a receive callback (udp_recv, - * raw_recv, tcp_accept). It will return NULL otherwise. */ -#define ip4_current_header() ip_data.current_ip4_header -/** Get the IPv6 header of the current packet. - * This function must only be called from a receive callback (udp_recv, - * raw_recv, tcp_accept). It will return NULL otherwise. */ -#define ip6_current_header() ((const struct ip6_hdr*)(ip_data.current_ip6_header)) -/** Returns TRUE if the current IP input packet is IPv6, FALSE if it is IPv4 */ -#define ip_current_is_v6() (ip6_current_header() != NULL) -/** Source IPv6 address of current_header */ -#define ip6_current_src_addr() (ip_2_ip6(&ip_data.current_iphdr_src)) -/** Destination IPv6 address of current_header */ -#define ip6_current_dest_addr() (ip_2_ip6(&ip_data.current_iphdr_dest)) -/** Get the transport layer protocol */ -#define ip_current_header_proto() (ip_current_is_v6() ? \ - IP6H_NEXTH(ip6_current_header()) :\ - IPH_PROTO(ip4_current_header())) -/** Get the transport layer header */ -#define ip_next_header_ptr() ((const void*)((ip_current_is_v6() ? \ - (const u8_t*)ip6_current_header() : (const u8_t*)ip4_current_header()) + ip_current_header_tot_len())) - -/** Source IP4 address of current_header */ -#define ip4_current_src_addr() (ip_2_ip4(&ip_data.current_iphdr_src)) -/** Destination IP4 address of current_header */ -#define ip4_current_dest_addr() (ip_2_ip4(&ip_data.current_iphdr_dest)) - -#elif LWIP_IPV4 /* LWIP_IPV4 && LWIP_IPV6 */ - -/** Get the IPv4 header of the current packet. - * This function must only be called from a receive callback (udp_recv, - * raw_recv, tcp_accept). It will return NULL otherwise. */ -#define ip4_current_header() ip_data.current_ip4_header -/** Always returns FALSE when only supporting IPv4 only */ -#define ip_current_is_v6() 0 -/** Get the transport layer protocol */ -#define ip_current_header_proto() IPH_PROTO(ip4_current_header()) -/** Get the transport layer header */ -#define ip_next_header_ptr() ((const void*)((const u8_t*)ip4_current_header() + ip_current_header_tot_len())) -/** Source IP4 address of current_header */ -#define ip4_current_src_addr() (&ip_data.current_iphdr_src) -/** Destination IP4 address of current_header */ -#define ip4_current_dest_addr() (&ip_data.current_iphdr_dest) - -#elif LWIP_IPV6 /* LWIP_IPV4 && LWIP_IPV6 */ - -/** Get the IPv6 header of the current packet. - * This function must only be called from a receive callback (udp_recv, - * raw_recv, tcp_accept). It will return NULL otherwise. */ -#define ip6_current_header() ((const struct ip6_hdr*)(ip_data.current_ip6_header)) -/** Always returns TRUE when only supporting IPv6 only */ -#define ip_current_is_v6() 1 -/** Get the transport layer protocol */ -#define ip_current_header_proto() IP6H_NEXTH(ip6_current_header()) -/** Get the transport layer header */ -#define ip_next_header_ptr() ((const void*)(((const u8_t*)ip6_current_header()) + ip_current_header_tot_len())) -/** Source IP6 address of current_header */ -#define ip6_current_src_addr() (&ip_data.current_iphdr_src) -/** Destination IP6 address of current_header */ -#define ip6_current_dest_addr() (&ip_data.current_iphdr_dest) - -#endif /* LWIP_IPV6 */ - -/** Union source address of current_header */ -#define ip_current_src_addr() (&ip_data.current_iphdr_src) -/** Union destination address of current_header */ -#define ip_current_dest_addr() (&ip_data.current_iphdr_dest) - -/** Gets an IP pcb option (SOF_* flags) */ -#define ip_get_option(pcb, opt) ((pcb)->so_options & (opt)) -/** Sets an IP pcb option (SOF_* flags) */ -#define ip_set_option(pcb, opt) ((pcb)->so_options = (u8_t)((pcb)->so_options | (opt))) -/** Resets an IP pcb option (SOF_* flags) */ -#define ip_reset_option(pcb, opt) ((pcb)->so_options = (u8_t)((pcb)->so_options & ~(opt))) - -#if LWIP_IPV4 && LWIP_IPV6 -/** - * @ingroup ip - * Output IP packet, netif is selected by source address - */ -#define ip_output(p, src, dest, ttl, tos, proto) \ - (IP_IS_V6(dest) ? \ - ip6_output(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto) : \ - ip4_output(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto)) -/** - * @ingroup ip - * Output IP packet to specified interface - */ -#define ip_output_if(p, src, dest, ttl, tos, proto, netif) \ - (IP_IS_V6(dest) ? \ - ip6_output_if(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif) : \ - ip4_output_if(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif)) -/** - * @ingroup ip - * Output IP packet to interface specifying source address - */ -#define ip_output_if_src(p, src, dest, ttl, tos, proto, netif) \ - (IP_IS_V6(dest) ? \ - ip6_output_if_src(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif) : \ - ip4_output_if_src(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif)) -/** Output IP packet that already includes an IP header. */ -#define ip_output_if_hdrincl(p, src, dest, netif) \ - (IP_IS_V6(dest) ? \ - ip6_output_if(p, ip_2_ip6(src), LWIP_IP_HDRINCL, 0, 0, 0, netif) : \ - ip4_output_if(p, ip_2_ip4(src), LWIP_IP_HDRINCL, 0, 0, 0, netif)) -/** Output IP packet with netif_hint */ -#define ip_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) \ - (IP_IS_V6(dest) ? \ - ip6_output_hinted(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif_hint) : \ - ip4_output_hinted(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif_hint)) -/** - * @ingroup ip - * Get netif for address combination. See \ref ip6_route and \ref ip4_route - */ -#define ip_route(src, dest) \ - (IP_IS_V6(dest) ? \ - ip6_route(ip_2_ip6(src), ip_2_ip6(dest)) : \ - ip4_route_src(ip_2_ip4(src), ip_2_ip4(dest))) -/** - * @ingroup ip - * Get netif for IP. - */ -#define ip_netif_get_local_ip(netif, dest) (IP_IS_V6(dest) ? \ - ip6_netif_get_local_ip(netif, ip_2_ip6(dest)) : \ - ip4_netif_get_local_ip(netif)) -#define ip_debug_print(is_ipv6, p) ((is_ipv6) ? ip6_debug_print(p) : ip4_debug_print(p)) - -err_t ip_input(struct pbuf *p, struct netif *inp); - -#elif LWIP_IPV4 /* LWIP_IPV4 && LWIP_IPV6 */ - -#define ip_output(p, src, dest, ttl, tos, proto) \ - ip4_output(p, src, dest, ttl, tos, proto) -#define ip_output_if(p, src, dest, ttl, tos, proto, netif) \ - ip4_output_if(p, src, dest, ttl, tos, proto, netif) -#define ip_output_if_src(p, src, dest, ttl, tos, proto, netif) \ - ip4_output_if_src(p, src, dest, ttl, tos, proto, netif) -#define ip_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) \ - ip4_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) -#define ip_output_if_hdrincl(p, src, dest, netif) \ - ip4_output_if(p, src, LWIP_IP_HDRINCL, 0, 0, 0, netif) -#define ip_route(src, dest) \ - ip4_route_src(src, dest) -#define ip_netif_get_local_ip(netif, dest) \ - ip4_netif_get_local_ip(netif) -#define ip_debug_print(is_ipv6, p) ip4_debug_print(p) - -#define ip_input ip4_input - -#elif LWIP_IPV6 /* LWIP_IPV4 && LWIP_IPV6 */ - -#define ip_output(p, src, dest, ttl, tos, proto) \ - ip6_output(p, src, dest, ttl, tos, proto) -#define ip_output_if(p, src, dest, ttl, tos, proto, netif) \ - ip6_output_if(p, src, dest, ttl, tos, proto, netif) -#define ip_output_if_src(p, src, dest, ttl, tos, proto, netif) \ - ip6_output_if_src(p, src, dest, ttl, tos, proto, netif) -#define ip_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) \ - ip6_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) -#define ip_output_if_hdrincl(p, src, dest, netif) \ - ip6_output_if(p, src, LWIP_IP_HDRINCL, 0, 0, 0, netif) -#define ip_route(src, dest) \ - ip6_route(src, dest) -#define ip_netif_get_local_ip(netif, dest) \ - ip6_netif_get_local_ip(netif, dest) -#define ip_debug_print(is_ipv6, p) ip6_debug_print(p) - -#define ip_input ip6_input - -#endif /* LWIP_IPV6 */ - -#define ip_route_get_local_ip(src, dest, netif, ipaddr) do { \ - (netif) = ip_route(src, dest); \ - (ipaddr) = ip_netif_get_local_ip(netif, dest); \ -}while(0) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_IP_H */ - - +/** + * @file + * IP API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_IP_H +#define LWIP_HDR_IP_H + +#include "lwip/opt.h" + +#include "lwip/def.h" +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" +#include "lwip/err.h" +#include "lwip/netif.h" +#include "lwip/ip4.h" +#include "lwip/ip6.h" +#include "lwip/prot/ip.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* This is passed as the destination address to ip_output_if (not + to ip_output), meaning that an IP header already is constructed + in the pbuf. This is used when TCP retransmits. */ +#define LWIP_IP_HDRINCL NULL + +/** pbufs passed to IP must have a ref-count of 1 as their payload pointer + gets altered as the packet is passed down the stack */ +#ifndef LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX +#define LWIP_IP_CHECK_PBUF_REF_COUNT_FOR_TX(p) LWIP_ASSERT("p->ref == 1", (p)->ref == 1) +#endif + +#if LWIP_NETIF_USE_HINTS +#define IP_PCB_NETIFHINT ;struct netif_hint netif_hints +#else /* LWIP_NETIF_USE_HINTS */ +#define IP_PCB_NETIFHINT +#endif /* LWIP_NETIF_USE_HINTS */ + +/** This is the common part of all PCB types. It needs to be at the + beginning of a PCB type definition. It is located here so that + changes to this common part are made in one location instead of + having to change all PCB structs. */ +#define IP_PCB \ + /* ip addresses in network byte order */ \ + ip_addr_t local_ip; \ + ip_addr_t remote_ip; \ + /* Bound netif index */ \ + u8_t netif_idx; \ + /* Socket options */ \ + u8_t so_options; \ + /* Type Of Service */ \ + u8_t tos; \ + /* Time To Live */ \ + u8_t ttl \ + /* link layer address resolution hint */ \ + IP_PCB_NETIFHINT + +struct ip_pcb { + /* Common members of all PCB types */ + IP_PCB; +}; + +/* + * Option flags per-socket. These are the same like SO_XXX in sockets.h + */ +#define SOF_REUSEADDR 0x04U /* allow local address reuse */ +#define SOF_KEEPALIVE 0x08U /* keep connections alive */ +#define SOF_BROADCAST 0x20U /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */ + +/* These flags are inherited (e.g. from a listen-pcb to a connection-pcb): */ +#define SOF_INHERITED (SOF_REUSEADDR|SOF_KEEPALIVE) + +/** Global variables of this module, kept in a struct for efficient access using base+index. */ +struct ip_globals +{ + /** The interface that accepted the packet for the current callback invocation. */ + struct netif *current_netif; + /** The interface that received the packet for the current callback invocation. */ + struct netif *current_input_netif; +#if LWIP_IPV4 + /** Header of the input packet currently being processed. */ + const struct ip_hdr *current_ip4_header; +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 + /** Header of the input IPv6 packet currently being processed. */ + struct ip6_hdr *current_ip6_header; +#endif /* LWIP_IPV6 */ + /** Total header length of current_ip4/6_header (i.e. after this, the UDP/TCP header starts) */ + u16_t current_ip_header_tot_len; + /** Source IP address of current_header */ + ip_addr_t current_iphdr_src; + /** Destination IP address of current_header */ + ip_addr_t current_iphdr_dest; +}; +extern struct ip_globals ip_data; + + +/** Get the interface that accepted the current packet. + * This may or may not be the receiving netif, depending on your netif/network setup. + * This function must only be called from a receive callback (udp_recv, + * raw_recv, tcp_accept). It will return NULL otherwise. */ +#define ip_current_netif() (ip_data.current_netif) +/** Get the interface that received the current packet. + * This function must only be called from a receive callback (udp_recv, + * raw_recv, tcp_accept). It will return NULL otherwise. */ +#define ip_current_input_netif() (ip_data.current_input_netif) +/** Total header length of ip(6)_current_header() (i.e. after this, the UDP/TCP header starts) */ +#define ip_current_header_tot_len() (ip_data.current_ip_header_tot_len) +/** Source IP address of current_header */ +#define ip_current_src_addr() (&ip_data.current_iphdr_src) +/** Destination IP address of current_header */ +#define ip_current_dest_addr() (&ip_data.current_iphdr_dest) + +#if LWIP_IPV4 && LWIP_IPV6 +/** Get the IPv4 header of the current packet. + * This function must only be called from a receive callback (udp_recv, + * raw_recv, tcp_accept). It will return NULL otherwise. */ +#define ip4_current_header() ip_data.current_ip4_header +/** Get the IPv6 header of the current packet. + * This function must only be called from a receive callback (udp_recv, + * raw_recv, tcp_accept). It will return NULL otherwise. */ +#define ip6_current_header() ((const struct ip6_hdr*)(ip_data.current_ip6_header)) +/** Returns TRUE if the current IP input packet is IPv6, FALSE if it is IPv4 */ +#define ip_current_is_v6() (ip6_current_header() != NULL) +/** Source IPv6 address of current_header */ +#define ip6_current_src_addr() (ip_2_ip6(&ip_data.current_iphdr_src)) +/** Destination IPv6 address of current_header */ +#define ip6_current_dest_addr() (ip_2_ip6(&ip_data.current_iphdr_dest)) +/** Get the transport layer protocol */ +#define ip_current_header_proto() (ip_current_is_v6() ? \ + IP6H_NEXTH(ip6_current_header()) :\ + IPH_PROTO(ip4_current_header())) +/** Get the transport layer header */ +#define ip_next_header_ptr() ((const void*)((ip_current_is_v6() ? \ + (const u8_t*)ip6_current_header() : (const u8_t*)ip4_current_header()) + ip_current_header_tot_len())) + +/** Source IP4 address of current_header */ +#define ip4_current_src_addr() (ip_2_ip4(&ip_data.current_iphdr_src)) +/** Destination IP4 address of current_header */ +#define ip4_current_dest_addr() (ip_2_ip4(&ip_data.current_iphdr_dest)) + +#elif LWIP_IPV4 /* LWIP_IPV4 && LWIP_IPV6 */ + +/** Get the IPv4 header of the current packet. + * This function must only be called from a receive callback (udp_recv, + * raw_recv, tcp_accept). It will return NULL otherwise. */ +#define ip4_current_header() ip_data.current_ip4_header +/** Always returns FALSE when only supporting IPv4 only */ +#define ip_current_is_v6() 0 +/** Get the transport layer protocol */ +#define ip_current_header_proto() IPH_PROTO(ip4_current_header()) +/** Get the transport layer header */ +#define ip_next_header_ptr() ((const void*)((const u8_t*)ip4_current_header() + ip_current_header_tot_len())) +/** Source IP4 address of current_header */ +#define ip4_current_src_addr() (&ip_data.current_iphdr_src) +/** Destination IP4 address of current_header */ +#define ip4_current_dest_addr() (&ip_data.current_iphdr_dest) + +#elif LWIP_IPV6 /* LWIP_IPV4 && LWIP_IPV6 */ + +/** Get the IPv6 header of the current packet. + * This function must only be called from a receive callback (udp_recv, + * raw_recv, tcp_accept). It will return NULL otherwise. */ +#define ip6_current_header() ((const struct ip6_hdr*)(ip_data.current_ip6_header)) +/** Always returns TRUE when only supporting IPv6 only */ +#define ip_current_is_v6() 1 +/** Get the transport layer protocol */ +#define ip_current_header_proto() IP6H_NEXTH(ip6_current_header()) +/** Get the transport layer header */ +#define ip_next_header_ptr() ((const void*)(((const u8_t*)ip6_current_header()) + ip_current_header_tot_len())) +/** Source IP6 address of current_header */ +#define ip6_current_src_addr() (&ip_data.current_iphdr_src) +/** Destination IP6 address of current_header */ +#define ip6_current_dest_addr() (&ip_data.current_iphdr_dest) + +#endif /* LWIP_IPV6 */ + +/** Union source address of current_header */ +#define ip_current_src_addr() (&ip_data.current_iphdr_src) +/** Union destination address of current_header */ +#define ip_current_dest_addr() (&ip_data.current_iphdr_dest) + +/** Gets an IP pcb option (SOF_* flags) */ +#define ip_get_option(pcb, opt) ((pcb)->so_options & (opt)) +/** Sets an IP pcb option (SOF_* flags) */ +#define ip_set_option(pcb, opt) ((pcb)->so_options = (u8_t)((pcb)->so_options | (opt))) +/** Resets an IP pcb option (SOF_* flags) */ +#define ip_reset_option(pcb, opt) ((pcb)->so_options = (u8_t)((pcb)->so_options & ~(opt))) + +#if LWIP_IPV4 && LWIP_IPV6 +/** + * @ingroup ip + * Output IP packet, netif is selected by source address + */ +#define ip_output(p, src, dest, ttl, tos, proto) \ + (IP_IS_V6(dest) ? \ + ip6_output(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto) : \ + ip4_output(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto)) +/** + * @ingroup ip + * Output IP packet to specified interface + */ +#define ip_output_if(p, src, dest, ttl, tos, proto, netif) \ + (IP_IS_V6(dest) ? \ + ip6_output_if(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif) : \ + ip4_output_if(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif)) +/** + * @ingroup ip + * Output IP packet to interface specifying source address + */ +#define ip_output_if_src(p, src, dest, ttl, tos, proto, netif) \ + (IP_IS_V6(dest) ? \ + ip6_output_if_src(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif) : \ + ip4_output_if_src(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif)) +/** Output IP packet that already includes an IP header. */ +#define ip_output_if_hdrincl(p, src, dest, netif) \ + (IP_IS_V6(dest) ? \ + ip6_output_if(p, ip_2_ip6(src), LWIP_IP_HDRINCL, 0, 0, 0, netif) : \ + ip4_output_if(p, ip_2_ip4(src), LWIP_IP_HDRINCL, 0, 0, 0, netif)) +/** Output IP packet with netif_hint */ +#define ip_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) \ + (IP_IS_V6(dest) ? \ + ip6_output_hinted(p, ip_2_ip6(src), ip_2_ip6(dest), ttl, tos, proto, netif_hint) : \ + ip4_output_hinted(p, ip_2_ip4(src), ip_2_ip4(dest), ttl, tos, proto, netif_hint)) +/** + * @ingroup ip + * Get netif for address combination. See \ref ip6_route and \ref ip4_route + */ +#define ip_route(src, dest) \ + (IP_IS_V6(dest) ? \ + ip6_route(ip_2_ip6(src), ip_2_ip6(dest)) : \ + ip4_route_src(ip_2_ip4(src), ip_2_ip4(dest))) +/** + * @ingroup ip + * Get netif for IP. + */ +#define ip_netif_get_local_ip(netif, dest) (IP_IS_V6(dest) ? \ + ip6_netif_get_local_ip(netif, ip_2_ip6(dest)) : \ + ip4_netif_get_local_ip(netif)) +#define ip_debug_print(is_ipv6, p) ((is_ipv6) ? ip6_debug_print(p) : ip4_debug_print(p)) + +err_t ip_input(struct pbuf *p, struct netif *inp); + +#elif LWIP_IPV4 /* LWIP_IPV4 && LWIP_IPV6 */ + +#define ip_output(p, src, dest, ttl, tos, proto) \ + ip4_output(p, src, dest, ttl, tos, proto) +#define ip_output_if(p, src, dest, ttl, tos, proto, netif) \ + ip4_output_if(p, src, dest, ttl, tos, proto, netif) +#define ip_output_if_src(p, src, dest, ttl, tos, proto, netif) \ + ip4_output_if_src(p, src, dest, ttl, tos, proto, netif) +#define ip_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) \ + ip4_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) +#define ip_output_if_hdrincl(p, src, dest, netif) \ + ip4_output_if(p, src, LWIP_IP_HDRINCL, 0, 0, 0, netif) +#define ip_route(src, dest) \ + ip4_route_src(src, dest) +#define ip_netif_get_local_ip(netif, dest) \ + ip4_netif_get_local_ip(netif) +#define ip_debug_print(is_ipv6, p) ip4_debug_print(p) + +#define ip_input ip4_input + +#elif LWIP_IPV6 /* LWIP_IPV4 && LWIP_IPV6 */ + +#define ip_output(p, src, dest, ttl, tos, proto) \ + ip6_output(p, src, dest, ttl, tos, proto) +#define ip_output_if(p, src, dest, ttl, tos, proto, netif) \ + ip6_output_if(p, src, dest, ttl, tos, proto, netif) +#define ip_output_if_src(p, src, dest, ttl, tos, proto, netif) \ + ip6_output_if_src(p, src, dest, ttl, tos, proto, netif) +#define ip_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) \ + ip6_output_hinted(p, src, dest, ttl, tos, proto, netif_hint) +#define ip_output_if_hdrincl(p, src, dest, netif) \ + ip6_output_if(p, src, LWIP_IP_HDRINCL, 0, 0, 0, netif) +#define ip_route(src, dest) \ + ip6_route(src, dest) +#define ip_netif_get_local_ip(netif, dest) \ + ip6_netif_get_local_ip(netif, dest) +#define ip_debug_print(is_ipv6, p) ip6_debug_print(p) + +#define ip_input ip6_input + +#endif /* LWIP_IPV6 */ + +#define ip_route_get_local_ip(src, dest, netif, ipaddr) do { \ + (netif) = ip_route(src, dest); \ + (ipaddr) = ip_netif_get_local_ip(netif, dest); \ +}while(0) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_IP_H */ + + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4.h index 6409c4be..fd35a336 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4.h @@ -1,111 +1,111 @@ -/** - * @file - * IPv4 API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_IP4_H -#define LWIP_HDR_IP4_H - -#include "lwip/opt.h" - -#if LWIP_IPV4 - -#include "lwip/def.h" -#include "lwip/pbuf.h" -#include "lwip/ip4_addr.h" -#include "lwip/err.h" -#include "lwip/netif.h" -#include "lwip/prot/ip4.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef LWIP_HOOK_IP4_ROUTE_SRC -#define LWIP_IPV4_SRC_ROUTING 1 -#else -#define LWIP_IPV4_SRC_ROUTING 0 -#endif - -/** Currently, the function ip_output_if_opt() is only used with IGMP */ -#define IP_OPTIONS_SEND (LWIP_IPV4 && LWIP_IGMP) - -#define ip_init() /* Compatibility define, no init needed. */ -struct netif *ip4_route(const ip4_addr_t *dest); -#if LWIP_IPV4_SRC_ROUTING -struct netif *ip4_route_src(const ip4_addr_t *src, const ip4_addr_t *dest); -#else /* LWIP_IPV4_SRC_ROUTING */ -#define ip4_route_src(src, dest) ip4_route(dest) -#endif /* LWIP_IPV4_SRC_ROUTING */ -err_t ip4_input(struct pbuf *p, struct netif *inp); -err_t ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto); -err_t ip4_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif *netif); -err_t ip4_output_if_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif *netif); -#if LWIP_NETIF_USE_HINTS -err_t ip4_output_hinted(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif_hint *netif_hint); -#endif /* LWIP_NETIF_USE_HINTS */ -#if IP_OPTIONS_SEND -err_t ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, - u16_t optlen); -err_t ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, - u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, - u16_t optlen); -#endif /* IP_OPTIONS_SEND */ - -#if LWIP_MULTICAST_TX_OPTIONS -void ip4_set_default_multicast_netif(struct netif* default_multicast_netif); -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - -#define ip4_netif_get_local_ip(netif) (((netif) != NULL) ? netif_ip_addr4(netif) : NULL) - -#if IP_DEBUG -void ip4_debug_print(struct pbuf *p); -#else -#define ip4_debug_print(p) -#endif /* IP_DEBUG */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV4 */ - -#endif /* LWIP_HDR_IP_H */ - - +/** + * @file + * IPv4 API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_IP4_H +#define LWIP_HDR_IP4_H + +#include "lwip/opt.h" + +#if LWIP_IPV4 + +#include "lwip/def.h" +#include "lwip/pbuf.h" +#include "lwip/ip4_addr.h" +#include "lwip/err.h" +#include "lwip/netif.h" +#include "lwip/prot/ip4.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef LWIP_HOOK_IP4_ROUTE_SRC +#define LWIP_IPV4_SRC_ROUTING 1 +#else +#define LWIP_IPV4_SRC_ROUTING 0 +#endif + +/** Currently, the function ip_output_if_opt() is only used with IGMP */ +#define IP_OPTIONS_SEND (LWIP_IPV4 && LWIP_IGMP) + +#define ip_init() /* Compatibility define, no init needed. */ +struct netif *ip4_route(const ip4_addr_t *dest); +#if LWIP_IPV4_SRC_ROUTING +struct netif *ip4_route_src(const ip4_addr_t *src, const ip4_addr_t *dest); +#else /* LWIP_IPV4_SRC_ROUTING */ +#define ip4_route_src(src, dest) ip4_route(dest) +#endif /* LWIP_IPV4_SRC_ROUTING */ +err_t ip4_input(struct pbuf *p, struct netif *inp); +err_t ip4_output(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto); +err_t ip4_output_if(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif *netif); +err_t ip4_output_if_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif *netif); +#if LWIP_NETIF_USE_HINTS +err_t ip4_output_hinted(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif_hint *netif_hint); +#endif /* LWIP_NETIF_USE_HINTS */ +#if IP_OPTIONS_SEND +err_t ip4_output_if_opt(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, + u16_t optlen); +err_t ip4_output_if_opt_src(struct pbuf *p, const ip4_addr_t *src, const ip4_addr_t *dest, + u8_t ttl, u8_t tos, u8_t proto, struct netif *netif, void *ip_options, + u16_t optlen); +#endif /* IP_OPTIONS_SEND */ + +#if LWIP_MULTICAST_TX_OPTIONS +void ip4_set_default_multicast_netif(struct netif* default_multicast_netif); +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + +#define ip4_netif_get_local_ip(netif) (((netif) != NULL) ? netif_ip_addr4(netif) : NULL) + +#if IP_DEBUG +void ip4_debug_print(struct pbuf *p); +#else +#define ip4_debug_print(p) +#endif /* IP_DEBUG */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV4 */ + +#endif /* LWIP_HDR_IP_H */ + + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_addr.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_addr.h index 9990756c..f244c4f5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_addr.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_addr.h @@ -1,216 +1,216 @@ -/** - * @file - * IPv4 address API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_IP4_ADDR_H -#define LWIP_HDR_IP4_ADDR_H - -#include "lwip/opt.h" -#include "lwip/def.h" - -#if LWIP_IPV4 - -#ifdef __cplusplus -extern "C" { -#endif - -/** This is the aligned version of ip4_addr_t, - used as local variable, on the stack, etc. */ -struct ip4_addr { - u32_t addr; -}; - -/** ip4_addr_t uses a struct for convenience only, so that the same defines can - * operate both on ip4_addr_t as well as on ip4_addr_p_t. */ -typedef struct ip4_addr ip4_addr_t; - -/* Forward declaration to not include netif.h */ -struct netif; - -/** 255.255.255.255 */ -#define IPADDR_NONE ((u32_t)0xffffffffUL) -/** 127.0.0.1 */ -#define IPADDR_LOOPBACK ((u32_t)0x7f000001UL) -/** 0.0.0.0 */ -#define IPADDR_ANY ((u32_t)0x00000000UL) -/** 255.255.255.255 */ -#define IPADDR_BROADCAST ((u32_t)0xffffffffUL) - -/* Definitions of the bits in an Internet address integer. - - On subnets, host and network parts are found according to - the subnet mask, not these masks. */ -#define IP_CLASSA(a) ((((u32_t)(a)) & 0x80000000UL) == 0) -#define IP_CLASSA_NET 0xff000000 -#define IP_CLASSA_NSHIFT 24 -#define IP_CLASSA_HOST (0xffffffff & ~IP_CLASSA_NET) -#define IP_CLASSA_MAX 128 - -#define IP_CLASSB(a) ((((u32_t)(a)) & 0xc0000000UL) == 0x80000000UL) -#define IP_CLASSB_NET 0xffff0000 -#define IP_CLASSB_NSHIFT 16 -#define IP_CLASSB_HOST (0xffffffff & ~IP_CLASSB_NET) -#define IP_CLASSB_MAX 65536 - -#define IP_CLASSC(a) ((((u32_t)(a)) & 0xe0000000UL) == 0xc0000000UL) -#define IP_CLASSC_NET 0xffffff00 -#define IP_CLASSC_NSHIFT 8 -#define IP_CLASSC_HOST (0xffffffff & ~IP_CLASSC_NET) - -#define IP_CLASSD(a) (((u32_t)(a) & 0xf0000000UL) == 0xe0000000UL) -#define IP_CLASSD_NET 0xf0000000 /* These ones aren't really */ -#define IP_CLASSD_NSHIFT 28 /* net and host fields, but */ -#define IP_CLASSD_HOST 0x0fffffff /* routing needn't know. */ -#define IP_MULTICAST(a) IP_CLASSD(a) - -#define IP_EXPERIMENTAL(a) (((u32_t)(a) & 0xf0000000UL) == 0xf0000000UL) -#define IP_BADCLASS(a) (((u32_t)(a) & 0xf0000000UL) == 0xf0000000UL) - -#define IP_LOOPBACKNET 127 /* official! */ - -/** Set an IP address given by the four byte-parts */ -#define IP4_ADDR(ipaddr, a,b,c,d) (ipaddr)->addr = PP_HTONL(LWIP_MAKEU32(a,b,c,d)) - -/** Copy IP address - faster than ip4_addr_set: no NULL check */ -#define ip4_addr_copy(dest, src) ((dest).addr = (src).addr) -/** Safely copy one IP address to another (src may be NULL) */ -#define ip4_addr_set(dest, src) ((dest)->addr = \ - ((src) == NULL ? 0 : \ - (src)->addr)) -/** Set complete address to zero */ -#define ip4_addr_set_zero(ipaddr) ((ipaddr)->addr = 0) -/** Set address to IPADDR_ANY (no need for lwip_htonl()) */ -#define ip4_addr_set_any(ipaddr) ((ipaddr)->addr = IPADDR_ANY) -/** Set address to loopback address */ -#define ip4_addr_set_loopback(ipaddr) ((ipaddr)->addr = PP_HTONL(IPADDR_LOOPBACK)) -/** Check if an address is in the loopback region */ -#define ip4_addr_isloopback(ipaddr) (((ipaddr)->addr & PP_HTONL(IP_CLASSA_NET)) == PP_HTONL(((u32_t)IP_LOOPBACKNET) << 24)) -/** Safely copy one IP address to another and change byte order - * from host- to network-order. */ -#define ip4_addr_set_hton(dest, src) ((dest)->addr = \ - ((src) == NULL ? 0:\ - lwip_htonl((src)->addr))) -/** IPv4 only: set the IP address given as an u32_t */ -#define ip4_addr_set_u32(dest_ipaddr, src_u32) ((dest_ipaddr)->addr = (src_u32)) -/** IPv4 only: get the IP address as an u32_t */ -#define ip4_addr_get_u32(src_ipaddr) ((src_ipaddr)->addr) - -/** Get the network address by combining host address with netmask */ -#define ip4_addr_get_network(target, host, netmask) do { ((target)->addr = ((host)->addr) & ((netmask)->addr)); } while(0) - -/** - * Determine if two address are on the same network. - * - * @arg addr1 IP address 1 - * @arg addr2 IP address 2 - * @arg mask network identifier mask - * @return !0 if the network identifiers of both address match - */ -#define ip4_addr_netcmp(addr1, addr2, mask) (((addr1)->addr & \ - (mask)->addr) == \ - ((addr2)->addr & \ - (mask)->addr)) -#define ip4_addr_cmp(addr1, addr2) ((addr1)->addr == (addr2)->addr) - -#define ip4_addr_isany_val(addr1) ((addr1).addr == IPADDR_ANY) -#define ip4_addr_isany(addr1) ((addr1) == NULL || ip4_addr_isany_val(*(addr1))) - -#define ip4_addr_isbroadcast(addr1, netif) ip4_addr_isbroadcast_u32((addr1)->addr, netif) -u8_t ip4_addr_isbroadcast_u32(u32_t addr, const struct netif *netif); - -#define ip_addr_netmask_valid(netmask) ip4_addr_netmask_valid((netmask)->addr) -u8_t ip4_addr_netmask_valid(u32_t netmask); - -#define ip4_addr_ismulticast(addr1) (((addr1)->addr & PP_HTONL(0xf0000000UL)) == PP_HTONL(0xe0000000UL)) - -#define ip4_addr_islinklocal(addr1) (((addr1)->addr & PP_HTONL(0xffff0000UL)) == PP_HTONL(0xa9fe0000UL)) - -#define ip4_addr_debug_print_parts(debug, a, b, c, d) \ - LWIP_DEBUGF(debug, ("%" U16_F ".%" U16_F ".%" U16_F ".%" U16_F, a, b, c, d)) -#define ip4_addr_debug_print(debug, ipaddr) \ - ip4_addr_debug_print_parts(debug, \ - (u16_t)((ipaddr) != NULL ? ip4_addr1_16(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? ip4_addr2_16(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? ip4_addr3_16(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? ip4_addr4_16(ipaddr) : 0)) -#define ip4_addr_debug_print_val(debug, ipaddr) \ - ip4_addr_debug_print_parts(debug, \ - ip4_addr1_16_val(ipaddr), \ - ip4_addr2_16_val(ipaddr), \ - ip4_addr3_16_val(ipaddr), \ - ip4_addr4_16_val(ipaddr)) - -/* Get one byte from the 4-byte address */ -#define ip4_addr_get_byte(ipaddr, idx) (((const u8_t*)(&(ipaddr)->addr))[idx]) -#define ip4_addr1(ipaddr) ip4_addr_get_byte(ipaddr, 0) -#define ip4_addr2(ipaddr) ip4_addr_get_byte(ipaddr, 1) -#define ip4_addr3(ipaddr) ip4_addr_get_byte(ipaddr, 2) -#define ip4_addr4(ipaddr) ip4_addr_get_byte(ipaddr, 3) -/* Get one byte from the 4-byte address, but argument is 'ip4_addr_t', - * not a pointer */ -#define ip4_addr_get_byte_val(ipaddr, idx) ((u8_t)(((ipaddr).addr >> (idx * 8)) & 0xff)) -#define ip4_addr1_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 0) -#define ip4_addr2_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 1) -#define ip4_addr3_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 2) -#define ip4_addr4_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 3) -/* These are cast to u16_t, with the intent that they are often arguments - * to printf using the U16_F format from cc.h. */ -#define ip4_addr1_16(ipaddr) ((u16_t)ip4_addr1(ipaddr)) -#define ip4_addr2_16(ipaddr) ((u16_t)ip4_addr2(ipaddr)) -#define ip4_addr3_16(ipaddr) ((u16_t)ip4_addr3(ipaddr)) -#define ip4_addr4_16(ipaddr) ((u16_t)ip4_addr4(ipaddr)) -#define ip4_addr1_16_val(ipaddr) ((u16_t)ip4_addr1_val(ipaddr)) -#define ip4_addr2_16_val(ipaddr) ((u16_t)ip4_addr2_val(ipaddr)) -#define ip4_addr3_16_val(ipaddr) ((u16_t)ip4_addr3_val(ipaddr)) -#define ip4_addr4_16_val(ipaddr) ((u16_t)ip4_addr4_val(ipaddr)) - -#define IP4ADDR_STRLEN_MAX 16 - -/** For backwards compatibility */ -#define ip_ntoa(ipaddr) ipaddr_ntoa(ipaddr) - -u32_t ipaddr_addr(const char *cp); -int ip4addr_aton(const char *cp, ip4_addr_t *addr); -/** returns ptr to static buffer; not reentrant! */ -char *ip4addr_ntoa(const ip4_addr_t *addr); -char *ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV4 */ - -#endif /* LWIP_HDR_IP_ADDR_H */ +/** + * @file + * IPv4 address API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_IP4_ADDR_H +#define LWIP_HDR_IP4_ADDR_H + +#include "lwip/opt.h" +#include "lwip/def.h" + +#if LWIP_IPV4 + +#ifdef __cplusplus +extern "C" { +#endif + +/** This is the aligned version of ip4_addr_t, + used as local variable, on the stack, etc. */ +struct ip4_addr { + u32_t addr; +}; + +/** ip4_addr_t uses a struct for convenience only, so that the same defines can + * operate both on ip4_addr_t as well as on ip4_addr_p_t. */ +typedef struct ip4_addr ip4_addr_t; + +/* Forward declaration to not include netif.h */ +struct netif; + +/** 255.255.255.255 */ +#define IPADDR_NONE ((u32_t)0xffffffffUL) +/** 127.0.0.1 */ +#define IPADDR_LOOPBACK ((u32_t)0x7f000001UL) +/** 0.0.0.0 */ +#define IPADDR_ANY ((u32_t)0x00000000UL) +/** 255.255.255.255 */ +#define IPADDR_BROADCAST ((u32_t)0xffffffffUL) + +/* Definitions of the bits in an Internet address integer. + + On subnets, host and network parts are found according to + the subnet mask, not these masks. */ +#define IP_CLASSA(a) ((((u32_t)(a)) & 0x80000000UL) == 0) +#define IP_CLASSA_NET 0xff000000 +#define IP_CLASSA_NSHIFT 24 +#define IP_CLASSA_HOST (0xffffffff & ~IP_CLASSA_NET) +#define IP_CLASSA_MAX 128 + +#define IP_CLASSB(a) ((((u32_t)(a)) & 0xc0000000UL) == 0x80000000UL) +#define IP_CLASSB_NET 0xffff0000 +#define IP_CLASSB_NSHIFT 16 +#define IP_CLASSB_HOST (0xffffffff & ~IP_CLASSB_NET) +#define IP_CLASSB_MAX 65536 + +#define IP_CLASSC(a) ((((u32_t)(a)) & 0xe0000000UL) == 0xc0000000UL) +#define IP_CLASSC_NET 0xffffff00 +#define IP_CLASSC_NSHIFT 8 +#define IP_CLASSC_HOST (0xffffffff & ~IP_CLASSC_NET) + +#define IP_CLASSD(a) (((u32_t)(a) & 0xf0000000UL) == 0xe0000000UL) +#define IP_CLASSD_NET 0xf0000000 /* These ones aren't really */ +#define IP_CLASSD_NSHIFT 28 /* net and host fields, but */ +#define IP_CLASSD_HOST 0x0fffffff /* routing needn't know. */ +#define IP_MULTICAST(a) IP_CLASSD(a) + +#define IP_EXPERIMENTAL(a) (((u32_t)(a) & 0xf0000000UL) == 0xf0000000UL) +#define IP_BADCLASS(a) (((u32_t)(a) & 0xf0000000UL) == 0xf0000000UL) + +#define IP_LOOPBACKNET 127 /* official! */ + +/** Set an IP address given by the four byte-parts */ +#define IP4_ADDR(ipaddr, a,b,c,d) (ipaddr)->addr = PP_HTONL(LWIP_MAKEU32(a,b,c,d)) + +/** Copy IP address - faster than ip4_addr_set: no NULL check */ +#define ip4_addr_copy(dest, src) ((dest).addr = (src).addr) +/** Safely copy one IP address to another (src may be NULL) */ +#define ip4_addr_set(dest, src) ((dest)->addr = \ + ((src) == NULL ? 0 : \ + (src)->addr)) +/** Set complete address to zero */ +#define ip4_addr_set_zero(ipaddr) ((ipaddr)->addr = 0) +/** Set address to IPADDR_ANY (no need for lwip_htonl()) */ +#define ip4_addr_set_any(ipaddr) ((ipaddr)->addr = IPADDR_ANY) +/** Set address to loopback address */ +#define ip4_addr_set_loopback(ipaddr) ((ipaddr)->addr = PP_HTONL(IPADDR_LOOPBACK)) +/** Check if an address is in the loopback region */ +#define ip4_addr_isloopback(ipaddr) (((ipaddr)->addr & PP_HTONL(IP_CLASSA_NET)) == PP_HTONL(((u32_t)IP_LOOPBACKNET) << 24)) +/** Safely copy one IP address to another and change byte order + * from host- to network-order. */ +#define ip4_addr_set_hton(dest, src) ((dest)->addr = \ + ((src) == NULL ? 0:\ + lwip_htonl((src)->addr))) +/** IPv4 only: set the IP address given as an u32_t */ +#define ip4_addr_set_u32(dest_ipaddr, src_u32) ((dest_ipaddr)->addr = (src_u32)) +/** IPv4 only: get the IP address as an u32_t */ +#define ip4_addr_get_u32(src_ipaddr) ((src_ipaddr)->addr) + +/** Get the network address by combining host address with netmask */ +#define ip4_addr_get_network(target, host, netmask) do { ((target)->addr = ((host)->addr) & ((netmask)->addr)); } while(0) + +/** + * Determine if two address are on the same network. + * + * @arg addr1 IP address 1 + * @arg addr2 IP address 2 + * @arg mask network identifier mask + * @return !0 if the network identifiers of both address match + */ +#define ip4_addr_netcmp(addr1, addr2, mask) (((addr1)->addr & \ + (mask)->addr) == \ + ((addr2)->addr & \ + (mask)->addr)) +#define ip4_addr_cmp(addr1, addr2) ((addr1)->addr == (addr2)->addr) + +#define ip4_addr_isany_val(addr1) ((addr1).addr == IPADDR_ANY) +#define ip4_addr_isany(addr1) ((addr1) == NULL || ip4_addr_isany_val(*(addr1))) + +#define ip4_addr_isbroadcast(addr1, netif) ip4_addr_isbroadcast_u32((addr1)->addr, netif) +u8_t ip4_addr_isbroadcast_u32(u32_t addr, const struct netif *netif); + +#define ip_addr_netmask_valid(netmask) ip4_addr_netmask_valid((netmask)->addr) +u8_t ip4_addr_netmask_valid(u32_t netmask); + +#define ip4_addr_ismulticast(addr1) (((addr1)->addr & PP_HTONL(0xf0000000UL)) == PP_HTONL(0xe0000000UL)) + +#define ip4_addr_islinklocal(addr1) (((addr1)->addr & PP_HTONL(0xffff0000UL)) == PP_HTONL(0xa9fe0000UL)) + +#define ip4_addr_debug_print_parts(debug, a, b, c, d) \ + LWIP_DEBUGF(debug, ("%" U16_F ".%" U16_F ".%" U16_F ".%" U16_F, a, b, c, d)) +#define ip4_addr_debug_print(debug, ipaddr) \ + ip4_addr_debug_print_parts(debug, \ + (u16_t)((ipaddr) != NULL ? ip4_addr1_16(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? ip4_addr2_16(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? ip4_addr3_16(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? ip4_addr4_16(ipaddr) : 0)) +#define ip4_addr_debug_print_val(debug, ipaddr) \ + ip4_addr_debug_print_parts(debug, \ + ip4_addr1_16_val(ipaddr), \ + ip4_addr2_16_val(ipaddr), \ + ip4_addr3_16_val(ipaddr), \ + ip4_addr4_16_val(ipaddr)) + +/* Get one byte from the 4-byte address */ +#define ip4_addr_get_byte(ipaddr, idx) (((const u8_t*)(&(ipaddr)->addr))[idx]) +#define ip4_addr1(ipaddr) ip4_addr_get_byte(ipaddr, 0) +#define ip4_addr2(ipaddr) ip4_addr_get_byte(ipaddr, 1) +#define ip4_addr3(ipaddr) ip4_addr_get_byte(ipaddr, 2) +#define ip4_addr4(ipaddr) ip4_addr_get_byte(ipaddr, 3) +/* Get one byte from the 4-byte address, but argument is 'ip4_addr_t', + * not a pointer */ +#define ip4_addr_get_byte_val(ipaddr, idx) ((u8_t)(((ipaddr).addr >> (idx * 8)) & 0xff)) +#define ip4_addr1_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 0) +#define ip4_addr2_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 1) +#define ip4_addr3_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 2) +#define ip4_addr4_val(ipaddr) ip4_addr_get_byte_val(ipaddr, 3) +/* These are cast to u16_t, with the intent that they are often arguments + * to printf using the U16_F format from cc.h. */ +#define ip4_addr1_16(ipaddr) ((u16_t)ip4_addr1(ipaddr)) +#define ip4_addr2_16(ipaddr) ((u16_t)ip4_addr2(ipaddr)) +#define ip4_addr3_16(ipaddr) ((u16_t)ip4_addr3(ipaddr)) +#define ip4_addr4_16(ipaddr) ((u16_t)ip4_addr4(ipaddr)) +#define ip4_addr1_16_val(ipaddr) ((u16_t)ip4_addr1_val(ipaddr)) +#define ip4_addr2_16_val(ipaddr) ((u16_t)ip4_addr2_val(ipaddr)) +#define ip4_addr3_16_val(ipaddr) ((u16_t)ip4_addr3_val(ipaddr)) +#define ip4_addr4_16_val(ipaddr) ((u16_t)ip4_addr4_val(ipaddr)) + +#define IP4ADDR_STRLEN_MAX 16 + +/** For backwards compatibility */ +#define ip_ntoa(ipaddr) ipaddr_ntoa(ipaddr) + +u32_t ipaddr_addr(const char *cp); +int ip4addr_aton(const char *cp, ip4_addr_t *addr); +/** returns ptr to static buffer; not reentrant! */ +char *ip4addr_ntoa(const ip4_addr_t *addr); +char *ip4addr_ntoa_r(const ip4_addr_t *addr, char *buf, int buflen); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV4 */ + +#endif /* LWIP_HDR_IP_ADDR_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_frag.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_frag.h index 18cd2d05..ed5bf14a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_frag.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip4_frag.h @@ -1,100 +1,100 @@ -/** - * @file - * IP fragmentation/reassembly - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Jani Monoses - * - */ - -#ifndef LWIP_HDR_IP4_FRAG_H -#define LWIP_HDR_IP4_FRAG_H - -#include "lwip/opt.h" -#include "lwip/err.h" -#include "lwip/pbuf.h" -#include "lwip/netif.h" -#include "lwip/ip_addr.h" -#include "lwip/ip.h" - -#if LWIP_IPV4 - -#ifdef __cplusplus -extern "C" { -#endif - -#if IP_REASSEMBLY -/* The IP reassembly timer interval in milliseconds. */ -#define IP_TMR_INTERVAL 1000 - -/** IP reassembly helper struct. - * This is exported because memp needs to know the size. - */ -struct ip_reassdata { - struct ip_reassdata *next; - struct pbuf *p; - struct ip_hdr iphdr; - u16_t datagram_len; - u8_t flags; - u8_t timer; -}; - -void ip_reass_init(void); -void ip_reass_tmr(void); -struct pbuf * ip4_reass(struct pbuf *p); -#endif /* IP_REASSEMBLY */ - -#if IP_FRAG -#if !LWIP_NETIF_TX_SINGLE_PBUF -#ifndef LWIP_PBUF_CUSTOM_REF_DEFINED -#define LWIP_PBUF_CUSTOM_REF_DEFINED -/** A custom pbuf that holds a reference to another pbuf, which is freed - * when this custom pbuf is freed. This is used to create a custom PBUF_REF - * that points into the original pbuf. */ -struct pbuf_custom_ref { - /** 'base class' */ - struct pbuf_custom pc; - /** pointer to the original pbuf that is referenced */ - struct pbuf *original; -}; -#endif /* LWIP_PBUF_CUSTOM_REF_DEFINED */ -#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ - -err_t ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest); -#endif /* IP_FRAG */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV4 */ - -#endif /* LWIP_HDR_IP4_FRAG_H */ +/** + * @file + * IP fragmentation/reassembly + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Jani Monoses + * + */ + +#ifndef LWIP_HDR_IP4_FRAG_H +#define LWIP_HDR_IP4_FRAG_H + +#include "lwip/opt.h" +#include "lwip/err.h" +#include "lwip/pbuf.h" +#include "lwip/netif.h" +#include "lwip/ip_addr.h" +#include "lwip/ip.h" + +#if LWIP_IPV4 + +#ifdef __cplusplus +extern "C" { +#endif + +#if IP_REASSEMBLY +/* The IP reassembly timer interval in milliseconds. */ +#define IP_TMR_INTERVAL 1000 + +/** IP reassembly helper struct. + * This is exported because memp needs to know the size. + */ +struct ip_reassdata { + struct ip_reassdata *next; + struct pbuf *p; + struct ip_hdr iphdr; + u16_t datagram_len; + u8_t flags; + u8_t timer; +}; + +void ip_reass_init(void); +void ip_reass_tmr(void); +struct pbuf * ip4_reass(struct pbuf *p); +#endif /* IP_REASSEMBLY */ + +#if IP_FRAG +#if !LWIP_NETIF_TX_SINGLE_PBUF +#ifndef LWIP_PBUF_CUSTOM_REF_DEFINED +#define LWIP_PBUF_CUSTOM_REF_DEFINED +/** A custom pbuf that holds a reference to another pbuf, which is freed + * when this custom pbuf is freed. This is used to create a custom PBUF_REF + * that points into the original pbuf. */ +struct pbuf_custom_ref { + /** 'base class' */ + struct pbuf_custom pc; + /** pointer to the original pbuf that is referenced */ + struct pbuf *original; +}; +#endif /* LWIP_PBUF_CUSTOM_REF_DEFINED */ +#endif /* !LWIP_NETIF_TX_SINGLE_PBUF */ + +err_t ip4_frag(struct pbuf *p, struct netif *netif, const ip4_addr_t *dest); +#endif /* IP_FRAG */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV4 */ + +#endif /* LWIP_HDR_IP4_FRAG_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6.h index 706f66dc..f894e063 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6.h @@ -1,93 +1,93 @@ -/** - * @file - * - * IPv6 layer. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ -#ifndef LWIP_HDR_IP6_H -#define LWIP_HDR_IP6_H - -#include "lwip/opt.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/ip6_addr.h" -#include "lwip/prot/ip6.h" -#include "lwip/def.h" -#include "lwip/pbuf.h" -#include "lwip/netif.h" - -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct netif *ip6_route(const ip6_addr_t *src, const ip6_addr_t *dest); -const ip_addr_t *ip6_select_source_address(struct netif *netif, const ip6_addr_t * dest); -err_t ip6_input(struct pbuf *p, struct netif *inp); -err_t ip6_output(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, u8_t nexth); -err_t ip6_output_if(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, u8_t nexth, struct netif *netif); -err_t ip6_output_if_src(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, u8_t nexth, struct netif *netif); -#if LWIP_NETIF_USE_HINTS -err_t ip6_output_hinted(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, - u8_t hl, u8_t tc, u8_t nexth, struct netif_hint *netif_hint); -#endif /* LWIP_NETIF_USE_HINTS */ -#if LWIP_IPV6_MLD -err_t ip6_options_add_hbh_ra(struct pbuf * p, u8_t nexth, u8_t value); -#endif /* LWIP_IPV6_MLD */ - -#define ip6_netif_get_local_ip(netif, dest) (((netif) != NULL) ? \ - ip6_select_source_address(netif, dest) : NULL) - -#if IP6_DEBUG -void ip6_debug_print(struct pbuf *p); -#else -#define ip6_debug_print(p) -#endif /* IP6_DEBUG */ - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 */ - -#endif /* LWIP_HDR_IP6_H */ +/** + * @file + * + * IPv6 layer. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ +#ifndef LWIP_HDR_IP6_H +#define LWIP_HDR_IP6_H + +#include "lwip/opt.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/ip6_addr.h" +#include "lwip/prot/ip6.h" +#include "lwip/def.h" +#include "lwip/pbuf.h" +#include "lwip/netif.h" + +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct netif *ip6_route(const ip6_addr_t *src, const ip6_addr_t *dest); +const ip_addr_t *ip6_select_source_address(struct netif *netif, const ip6_addr_t * dest); +err_t ip6_input(struct pbuf *p, struct netif *inp); +err_t ip6_output(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, u8_t nexth); +err_t ip6_output_if(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, u8_t nexth, struct netif *netif); +err_t ip6_output_if_src(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, u8_t nexth, struct netif *netif); +#if LWIP_NETIF_USE_HINTS +err_t ip6_output_hinted(struct pbuf *p, const ip6_addr_t *src, const ip6_addr_t *dest, + u8_t hl, u8_t tc, u8_t nexth, struct netif_hint *netif_hint); +#endif /* LWIP_NETIF_USE_HINTS */ +#if LWIP_IPV6_MLD +err_t ip6_options_add_hbh_ra(struct pbuf * p, u8_t nexth, u8_t value); +#endif /* LWIP_IPV6_MLD */ + +#define ip6_netif_get_local_ip(netif, dest) (((netif) != NULL) ? \ + ip6_select_source_address(netif, dest) : NULL) + +#if IP6_DEBUG +void ip6_debug_print(struct pbuf *p); +#else +#define ip6_debug_print(p) +#endif /* IP6_DEBUG */ + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 */ + +#endif /* LWIP_HDR_IP6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_addr.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_addr.h index 7c1f9136..29c2a34d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_addr.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_addr.h @@ -1,352 +1,352 @@ -/** - * @file - * - * IPv6 addresses. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * Structs and macros for handling IPv6 addresses. - * - * Please coordinate changes and requests with Ivan Delamer - * - */ -#ifndef LWIP_HDR_IP6_ADDR_H -#define LWIP_HDR_IP6_ADDR_H - -#include "lwip/opt.h" -#include "def.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/ip6_zone.h" - -#ifdef __cplusplus -extern "C" { -#endif - - -/** This is the aligned version of ip6_addr_t, - used as local variable, on the stack, etc. */ -struct ip6_addr { - u32_t addr[4]; -#if LWIP_IPV6_SCOPES - u8_t zone; -#endif /* LWIP_IPV6_SCOPES */ -}; - -/** IPv6 address */ -typedef struct ip6_addr ip6_addr_t; - -/** Set an IPv6 partial address given by byte-parts */ -#define IP6_ADDR_PART(ip6addr, index, a,b,c,d) \ - (ip6addr)->addr[index] = PP_HTONL(LWIP_MAKEU32(a,b,c,d)) - -/** Set a full IPv6 address by passing the 4 u32_t indices in network byte order - (use PP_HTONL() for constants) */ -#define IP6_ADDR(ip6addr, idx0, idx1, idx2, idx3) do { \ - (ip6addr)->addr[0] = idx0; \ - (ip6addr)->addr[1] = idx1; \ - (ip6addr)->addr[2] = idx2; \ - (ip6addr)->addr[3] = idx3; \ - ip6_addr_clear_zone(ip6addr); } while(0) - -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK1(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[0]) >> 16) & 0xffff)) -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK2(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[0])) & 0xffff)) -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK3(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[1]) >> 16) & 0xffff)) -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK4(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[1])) & 0xffff)) -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK5(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[2]) >> 16) & 0xffff)) -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK6(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[2])) & 0xffff)) -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK7(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[3]) >> 16) & 0xffff)) -/** Access address in 16-bit block */ -#define IP6_ADDR_BLOCK8(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[3])) & 0xffff)) - -/** Copy IPv6 address - faster than ip6_addr_set: no NULL check */ -#define ip6_addr_copy(dest, src) do{(dest).addr[0] = (src).addr[0]; \ - (dest).addr[1] = (src).addr[1]; \ - (dest).addr[2] = (src).addr[2]; \ - (dest).addr[3] = (src).addr[3]; \ - ip6_addr_copy_zone((dest), (src)); }while(0) -/** Safely copy one IPv6 address to another (src may be NULL) */ -#define ip6_addr_set(dest, src) do{(dest)->addr[0] = (src) == NULL ? 0 : (src)->addr[0]; \ - (dest)->addr[1] = (src) == NULL ? 0 : (src)->addr[1]; \ - (dest)->addr[2] = (src) == NULL ? 0 : (src)->addr[2]; \ - (dest)->addr[3] = (src) == NULL ? 0 : (src)->addr[3]; \ - ip6_addr_set_zone((dest), (src) == NULL ? IP6_NO_ZONE : ip6_addr_zone(src)); }while(0) - -/** Copy packed IPv6 address to unpacked IPv6 address; zone is not set */ -#define ip6_addr_copy_from_packed(dest, src) do{(dest).addr[0] = (src).addr[0]; \ - (dest).addr[1] = (src).addr[1]; \ - (dest).addr[2] = (src).addr[2]; \ - (dest).addr[3] = (src).addr[3]; \ - ip6_addr_clear_zone(&dest); }while(0) - -/** Copy unpacked IPv6 address to packed IPv6 address; zone is lost */ -#define ip6_addr_copy_to_packed(dest, src) do{(dest).addr[0] = (src).addr[0]; \ - (dest).addr[1] = (src).addr[1]; \ - (dest).addr[2] = (src).addr[2]; \ - (dest).addr[3] = (src).addr[3]; }while(0) - -/** Set complete address to zero */ -#define ip6_addr_set_zero(ip6addr) do{(ip6addr)->addr[0] = 0; \ - (ip6addr)->addr[1] = 0; \ - (ip6addr)->addr[2] = 0; \ - (ip6addr)->addr[3] = 0; \ - ip6_addr_clear_zone(ip6addr);}while(0) - -/** Set address to ipv6 'any' (no need for lwip_htonl()) */ -#define ip6_addr_set_any(ip6addr) ip6_addr_set_zero(ip6addr) -/** Set address to ipv6 loopback address */ -#define ip6_addr_set_loopback(ip6addr) do{(ip6addr)->addr[0] = 0; \ - (ip6addr)->addr[1] = 0; \ - (ip6addr)->addr[2] = 0; \ - (ip6addr)->addr[3] = PP_HTONL(0x00000001UL); \ - ip6_addr_clear_zone(ip6addr);}while(0) -/** Safely copy one IPv6 address to another and change byte order - * from host- to network-order. */ -#define ip6_addr_set_hton(dest, src) do{(dest)->addr[0] = (src) == NULL ? 0 : lwip_htonl((src)->addr[0]); \ - (dest)->addr[1] = (src) == NULL ? 0 : lwip_htonl((src)->addr[1]); \ - (dest)->addr[2] = (src) == NULL ? 0 : lwip_htonl((src)->addr[2]); \ - (dest)->addr[3] = (src) == NULL ? 0 : lwip_htonl((src)->addr[3]); \ - ip6_addr_set_zone((dest), (src) == NULL ? IP6_NO_ZONE : ip6_addr_zone(src));}while(0) - - -/** Compare IPv6 networks, ignoring zone information. To be used sparingly! */ -#define ip6_addr_netcmp_zoneless(addr1, addr2) (((addr1)->addr[0] == (addr2)->addr[0]) && \ - ((addr1)->addr[1] == (addr2)->addr[1])) - -/** - * Determine if two IPv6 address are on the same network. - * - * @param addr1 IPv6 address 1 - * @param addr2 IPv6 address 2 - * @return 1 if the network identifiers of both address match, 0 if not - */ -#define ip6_addr_netcmp(addr1, addr2) (ip6_addr_netcmp_zoneless((addr1), (addr2)) && \ - ip6_addr_cmp_zone((addr1), (addr2))) - -/* Exact-host comparison *after* ip6_addr_netcmp() succeeded, for efficiency. */ -#define ip6_addr_nethostcmp(addr1, addr2) (((addr1)->addr[2] == (addr2)->addr[2]) && \ - ((addr1)->addr[3] == (addr2)->addr[3])) - -/** Compare IPv6 addresses, ignoring zone information. To be used sparingly! */ -#define ip6_addr_cmp_zoneless(addr1, addr2) (((addr1)->addr[0] == (addr2)->addr[0]) && \ - ((addr1)->addr[1] == (addr2)->addr[1]) && \ - ((addr1)->addr[2] == (addr2)->addr[2]) && \ - ((addr1)->addr[3] == (addr2)->addr[3])) -/** - * Determine if two IPv6 addresses are the same. In particular, the address - * part of both must be the same, and the zone must be compatible. - * - * @param addr1 IPv6 address 1 - * @param addr2 IPv6 address 2 - * @return 1 if the addresses are considered equal, 0 if not - */ -#define ip6_addr_cmp(addr1, addr2) (ip6_addr_cmp_zoneless((addr1), (addr2)) && \ - ip6_addr_cmp_zone((addr1), (addr2))) - -/** Compare IPv6 address to packed address and zone */ -#define ip6_addr_cmp_packed(ip6addr, paddr, zone_idx) (((ip6addr)->addr[0] == (paddr)->addr[0]) && \ - ((ip6addr)->addr[1] == (paddr)->addr[1]) && \ - ((ip6addr)->addr[2] == (paddr)->addr[2]) && \ - ((ip6addr)->addr[3] == (paddr)->addr[3]) && \ - ip6_addr_equals_zone((ip6addr), (zone_idx))) - -#define ip6_get_subnet_id(ip6addr) (lwip_htonl((ip6addr)->addr[2]) & 0x0000ffffUL) - -#define ip6_addr_isany_val(ip6addr) (((ip6addr).addr[0] == 0) && \ - ((ip6addr).addr[1] == 0) && \ - ((ip6addr).addr[2] == 0) && \ - ((ip6addr).addr[3] == 0)) -#define ip6_addr_isany(ip6addr) (((ip6addr) == NULL) || ip6_addr_isany_val(*(ip6addr))) - -#define ip6_addr_isloopback(ip6addr) (((ip6addr)->addr[0] == 0UL) && \ - ((ip6addr)->addr[1] == 0UL) && \ - ((ip6addr)->addr[2] == 0UL) && \ - ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL))) - -#define ip6_addr_isglobal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xe0000000UL)) == PP_HTONL(0x20000000UL)) - -#define ip6_addr_islinklocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xffc00000UL)) == PP_HTONL(0xfe800000UL)) - -#define ip6_addr_issitelocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xffc00000UL)) == PP_HTONL(0xfec00000UL)) - -#define ip6_addr_isuniquelocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xfe000000UL)) == PP_HTONL(0xfc000000UL)) - -#define ip6_addr_isipv4mappedipv6(ip6addr) (((ip6addr)->addr[0] == 0) && ((ip6addr)->addr[1] == 0) && (((ip6addr)->addr[2]) == PP_HTONL(0x0000FFFFUL))) - -#define ip6_addr_ismulticast(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff000000UL)) == PP_HTONL(0xff000000UL)) -#define ip6_addr_multicast_transient_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00100000UL)) -#define ip6_addr_multicast_prefix_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00200000UL)) -#define ip6_addr_multicast_rendezvous_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00400000UL)) -#define ip6_addr_multicast_scope(ip6addr) ((lwip_htonl((ip6addr)->addr[0]) >> 16) & 0xf) -#define IP6_MULTICAST_SCOPE_RESERVED 0x0 -#define IP6_MULTICAST_SCOPE_RESERVED0 0x0 -#define IP6_MULTICAST_SCOPE_INTERFACE_LOCAL 0x1 -#define IP6_MULTICAST_SCOPE_LINK_LOCAL 0x2 -#define IP6_MULTICAST_SCOPE_RESERVED3 0x3 -#define IP6_MULTICAST_SCOPE_ADMIN_LOCAL 0x4 -#define IP6_MULTICAST_SCOPE_SITE_LOCAL 0x5 -#define IP6_MULTICAST_SCOPE_ORGANIZATION_LOCAL 0x8 -#define IP6_MULTICAST_SCOPE_GLOBAL 0xe -#define IP6_MULTICAST_SCOPE_RESERVEDF 0xf -#define ip6_addr_ismulticast_iflocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff010000UL)) -#define ip6_addr_ismulticast_linklocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff020000UL)) -#define ip6_addr_ismulticast_adminlocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff040000UL)) -#define ip6_addr_ismulticast_sitelocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff050000UL)) -#define ip6_addr_ismulticast_orglocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff080000UL)) -#define ip6_addr_ismulticast_global(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff0e0000UL)) - -/* Scoping note: while interface-local and link-local multicast addresses do - * have a scope (i.e., they are meaningful only in the context of a particular - * interface), the following functions are not assigning or comparing zone - * indices. The reason for this is backward compatibility. Any call site that - * produces a non-global multicast address must assign a multicast address as - * appropriate itself. */ - -#define ip6_addr_isallnodes_iflocal(ip6addr) (((ip6addr)->addr[0] == PP_HTONL(0xff010000UL)) && \ - ((ip6addr)->addr[1] == 0UL) && \ - ((ip6addr)->addr[2] == 0UL) && \ - ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL))) - -#define ip6_addr_isallnodes_linklocal(ip6addr) (((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ - ((ip6addr)->addr[1] == 0UL) && \ - ((ip6addr)->addr[2] == 0UL) && \ - ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL))) -#define ip6_addr_set_allnodes_linklocal(ip6addr) do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); \ - (ip6addr)->addr[1] = 0; \ - (ip6addr)->addr[2] = 0; \ - (ip6addr)->addr[3] = PP_HTONL(0x00000001UL); \ - ip6_addr_clear_zone(ip6addr); }while(0) - -#define ip6_addr_isallrouters_linklocal(ip6addr) (((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ - ((ip6addr)->addr[1] == 0UL) && \ - ((ip6addr)->addr[2] == 0UL) && \ - ((ip6addr)->addr[3] == PP_HTONL(0x00000002UL))) -#define ip6_addr_set_allrouters_linklocal(ip6addr) do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); \ - (ip6addr)->addr[1] = 0; \ - (ip6addr)->addr[2] = 0; \ - (ip6addr)->addr[3] = PP_HTONL(0x00000002UL); \ - ip6_addr_clear_zone(ip6addr); }while(0) - -#define ip6_addr_issolicitednode(ip6addr) ( ((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ - ((ip6addr)->addr[2] == PP_HTONL(0x00000001UL)) && \ - (((ip6addr)->addr[3] & PP_HTONL(0xff000000UL)) == PP_HTONL(0xff000000UL)) ) - -#define ip6_addr_set_solicitednode(ip6addr, if_id) do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); \ - (ip6addr)->addr[1] = 0; \ - (ip6addr)->addr[2] = PP_HTONL(0x00000001UL); \ - (ip6addr)->addr[3] = (PP_HTONL(0xff000000UL) | (if_id)); \ - ip6_addr_clear_zone(ip6addr); }while(0) - -#define ip6_addr_cmp_solicitednode(ip6addr, sn_addr) (((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ - ((ip6addr)->addr[1] == 0) && \ - ((ip6addr)->addr[2] == PP_HTONL(0x00000001UL)) && \ - ((ip6addr)->addr[3] == (PP_HTONL(0xff000000UL) | (sn_addr)->addr[3]))) - -/* IPv6 address states. */ -#define IP6_ADDR_INVALID 0x00 -#define IP6_ADDR_TENTATIVE 0x08 -#define IP6_ADDR_TENTATIVE_1 0x09 /* 1 probe sent */ -#define IP6_ADDR_TENTATIVE_2 0x0a /* 2 probes sent */ -#define IP6_ADDR_TENTATIVE_3 0x0b /* 3 probes sent */ -#define IP6_ADDR_TENTATIVE_4 0x0c /* 4 probes sent */ -#define IP6_ADDR_TENTATIVE_5 0x0d /* 5 probes sent */ -#define IP6_ADDR_TENTATIVE_6 0x0e /* 6 probes sent */ -#define IP6_ADDR_TENTATIVE_7 0x0f /* 7 probes sent */ -#define IP6_ADDR_VALID 0x10 /* This bit marks an address as valid (preferred or deprecated) */ -#define IP6_ADDR_PREFERRED 0x30 -#define IP6_ADDR_DEPRECATED 0x10 /* Same as VALID (valid but not preferred) */ -#define IP6_ADDR_DUPLICATED 0x40 /* Failed DAD test, not valid */ - -#define IP6_ADDR_TENTATIVE_COUNT_MASK 0x07 /* 1-7 probes sent */ - -#define ip6_addr_isinvalid(addr_state) (addr_state == IP6_ADDR_INVALID) -#define ip6_addr_istentative(addr_state) (addr_state & IP6_ADDR_TENTATIVE) -#define ip6_addr_isvalid(addr_state) (addr_state & IP6_ADDR_VALID) /* Include valid, preferred, and deprecated. */ -#define ip6_addr_ispreferred(addr_state) (addr_state == IP6_ADDR_PREFERRED) -#define ip6_addr_isdeprecated(addr_state) (addr_state == IP6_ADDR_DEPRECATED) -#define ip6_addr_isduplicated(addr_state) (addr_state == IP6_ADDR_DUPLICATED) - -#if LWIP_IPV6_ADDRESS_LIFETIMES -#define IP6_ADDR_LIFE_STATIC (0) -#define IP6_ADDR_LIFE_INFINITE (0xffffffffUL) -#define ip6_addr_life_isstatic(addr_life) ((addr_life) == IP6_ADDR_LIFE_STATIC) -#define ip6_addr_life_isinfinite(addr_life) ((addr_life) == IP6_ADDR_LIFE_INFINITE) -#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ - -#define ip6_addr_debug_print_parts(debug, a, b, c, d, e, f, g, h) \ - LWIP_DEBUGF(debug, ("%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F, \ - a, b, c, d, e, f, g, h)) -#define ip6_addr_debug_print(debug, ipaddr) \ - ip6_addr_debug_print_parts(debug, \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK1(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK2(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK3(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK4(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK5(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK6(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK7(ipaddr) : 0), \ - (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK8(ipaddr) : 0)) -#define ip6_addr_debug_print_val(debug, ipaddr) \ - ip6_addr_debug_print_parts(debug, \ - IP6_ADDR_BLOCK1(&(ipaddr)), \ - IP6_ADDR_BLOCK2(&(ipaddr)), \ - IP6_ADDR_BLOCK3(&(ipaddr)), \ - IP6_ADDR_BLOCK4(&(ipaddr)), \ - IP6_ADDR_BLOCK5(&(ipaddr)), \ - IP6_ADDR_BLOCK6(&(ipaddr)), \ - IP6_ADDR_BLOCK7(&(ipaddr)), \ - IP6_ADDR_BLOCK8(&(ipaddr))) - -#define IP6ADDR_STRLEN_MAX 46 - -int ip6addr_aton(const char *cp, ip6_addr_t *addr); -/** returns ptr to static buffer; not reentrant! */ -char *ip6addr_ntoa(const ip6_addr_t *addr); -char *ip6addr_ntoa_r(const ip6_addr_t *addr, char *buf, int buflen); - - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 */ - -#endif /* LWIP_HDR_IP6_ADDR_H */ +/** + * @file + * + * IPv6 addresses. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * Structs and macros for handling IPv6 addresses. + * + * Please coordinate changes and requests with Ivan Delamer + * + */ +#ifndef LWIP_HDR_IP6_ADDR_H +#define LWIP_HDR_IP6_ADDR_H + +#include "lwip/opt.h" +#include "def.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/ip6_zone.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** This is the aligned version of ip6_addr_t, + used as local variable, on the stack, etc. */ +struct ip6_addr { + u32_t addr[4]; +#if LWIP_IPV6_SCOPES + u8_t zone; +#endif /* LWIP_IPV6_SCOPES */ +}; + +/** IPv6 address */ +typedef struct ip6_addr ip6_addr_t; + +/** Set an IPv6 partial address given by byte-parts */ +#define IP6_ADDR_PART(ip6addr, index, a,b,c,d) \ + (ip6addr)->addr[index] = PP_HTONL(LWIP_MAKEU32(a,b,c,d)) + +/** Set a full IPv6 address by passing the 4 u32_t indices in network byte order + (use PP_HTONL() for constants) */ +#define IP6_ADDR(ip6addr, idx0, idx1, idx2, idx3) do { \ + (ip6addr)->addr[0] = idx0; \ + (ip6addr)->addr[1] = idx1; \ + (ip6addr)->addr[2] = idx2; \ + (ip6addr)->addr[3] = idx3; \ + ip6_addr_clear_zone(ip6addr); } while(0) + +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK1(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[0]) >> 16) & 0xffff)) +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK2(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[0])) & 0xffff)) +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK3(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[1]) >> 16) & 0xffff)) +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK4(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[1])) & 0xffff)) +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK5(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[2]) >> 16) & 0xffff)) +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK6(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[2])) & 0xffff)) +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK7(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[3]) >> 16) & 0xffff)) +/** Access address in 16-bit block */ +#define IP6_ADDR_BLOCK8(ip6addr) ((u16_t)((lwip_htonl((ip6addr)->addr[3])) & 0xffff)) + +/** Copy IPv6 address - faster than ip6_addr_set: no NULL check */ +#define ip6_addr_copy(dest, src) do{(dest).addr[0] = (src).addr[0]; \ + (dest).addr[1] = (src).addr[1]; \ + (dest).addr[2] = (src).addr[2]; \ + (dest).addr[3] = (src).addr[3]; \ + ip6_addr_copy_zone((dest), (src)); }while(0) +/** Safely copy one IPv6 address to another (src may be NULL) */ +#define ip6_addr_set(dest, src) do{(dest)->addr[0] = (src) == NULL ? 0 : (src)->addr[0]; \ + (dest)->addr[1] = (src) == NULL ? 0 : (src)->addr[1]; \ + (dest)->addr[2] = (src) == NULL ? 0 : (src)->addr[2]; \ + (dest)->addr[3] = (src) == NULL ? 0 : (src)->addr[3]; \ + ip6_addr_set_zone((dest), (src) == NULL ? IP6_NO_ZONE : ip6_addr_zone(src)); }while(0) + +/** Copy packed IPv6 address to unpacked IPv6 address; zone is not set */ +#define ip6_addr_copy_from_packed(dest, src) do{(dest).addr[0] = (src).addr[0]; \ + (dest).addr[1] = (src).addr[1]; \ + (dest).addr[2] = (src).addr[2]; \ + (dest).addr[3] = (src).addr[3]; \ + ip6_addr_clear_zone(&dest); }while(0) + +/** Copy unpacked IPv6 address to packed IPv6 address; zone is lost */ +#define ip6_addr_copy_to_packed(dest, src) do{(dest).addr[0] = (src).addr[0]; \ + (dest).addr[1] = (src).addr[1]; \ + (dest).addr[2] = (src).addr[2]; \ + (dest).addr[3] = (src).addr[3]; }while(0) + +/** Set complete address to zero */ +#define ip6_addr_set_zero(ip6addr) do{(ip6addr)->addr[0] = 0; \ + (ip6addr)->addr[1] = 0; \ + (ip6addr)->addr[2] = 0; \ + (ip6addr)->addr[3] = 0; \ + ip6_addr_clear_zone(ip6addr);}while(0) + +/** Set address to ipv6 'any' (no need for lwip_htonl()) */ +#define ip6_addr_set_any(ip6addr) ip6_addr_set_zero(ip6addr) +/** Set address to ipv6 loopback address */ +#define ip6_addr_set_loopback(ip6addr) do{(ip6addr)->addr[0] = 0; \ + (ip6addr)->addr[1] = 0; \ + (ip6addr)->addr[2] = 0; \ + (ip6addr)->addr[3] = PP_HTONL(0x00000001UL); \ + ip6_addr_clear_zone(ip6addr);}while(0) +/** Safely copy one IPv6 address to another and change byte order + * from host- to network-order. */ +#define ip6_addr_set_hton(dest, src) do{(dest)->addr[0] = (src) == NULL ? 0 : lwip_htonl((src)->addr[0]); \ + (dest)->addr[1] = (src) == NULL ? 0 : lwip_htonl((src)->addr[1]); \ + (dest)->addr[2] = (src) == NULL ? 0 : lwip_htonl((src)->addr[2]); \ + (dest)->addr[3] = (src) == NULL ? 0 : lwip_htonl((src)->addr[3]); \ + ip6_addr_set_zone((dest), (src) == NULL ? IP6_NO_ZONE : ip6_addr_zone(src));}while(0) + + +/** Compare IPv6 networks, ignoring zone information. To be used sparingly! */ +#define ip6_addr_netcmp_zoneless(addr1, addr2) (((addr1)->addr[0] == (addr2)->addr[0]) && \ + ((addr1)->addr[1] == (addr2)->addr[1])) + +/** + * Determine if two IPv6 address are on the same network. + * + * @param addr1 IPv6 address 1 + * @param addr2 IPv6 address 2 + * @return 1 if the network identifiers of both address match, 0 if not + */ +#define ip6_addr_netcmp(addr1, addr2) (ip6_addr_netcmp_zoneless((addr1), (addr2)) && \ + ip6_addr_cmp_zone((addr1), (addr2))) + +/* Exact-host comparison *after* ip6_addr_netcmp() succeeded, for efficiency. */ +#define ip6_addr_nethostcmp(addr1, addr2) (((addr1)->addr[2] == (addr2)->addr[2]) && \ + ((addr1)->addr[3] == (addr2)->addr[3])) + +/** Compare IPv6 addresses, ignoring zone information. To be used sparingly! */ +#define ip6_addr_cmp_zoneless(addr1, addr2) (((addr1)->addr[0] == (addr2)->addr[0]) && \ + ((addr1)->addr[1] == (addr2)->addr[1]) && \ + ((addr1)->addr[2] == (addr2)->addr[2]) && \ + ((addr1)->addr[3] == (addr2)->addr[3])) +/** + * Determine if two IPv6 addresses are the same. In particular, the address + * part of both must be the same, and the zone must be compatible. + * + * @param addr1 IPv6 address 1 + * @param addr2 IPv6 address 2 + * @return 1 if the addresses are considered equal, 0 if not + */ +#define ip6_addr_cmp(addr1, addr2) (ip6_addr_cmp_zoneless((addr1), (addr2)) && \ + ip6_addr_cmp_zone((addr1), (addr2))) + +/** Compare IPv6 address to packed address and zone */ +#define ip6_addr_cmp_packed(ip6addr, paddr, zone_idx) (((ip6addr)->addr[0] == (paddr)->addr[0]) && \ + ((ip6addr)->addr[1] == (paddr)->addr[1]) && \ + ((ip6addr)->addr[2] == (paddr)->addr[2]) && \ + ((ip6addr)->addr[3] == (paddr)->addr[3]) && \ + ip6_addr_equals_zone((ip6addr), (zone_idx))) + +#define ip6_get_subnet_id(ip6addr) (lwip_htonl((ip6addr)->addr[2]) & 0x0000ffffUL) + +#define ip6_addr_isany_val(ip6addr) (((ip6addr).addr[0] == 0) && \ + ((ip6addr).addr[1] == 0) && \ + ((ip6addr).addr[2] == 0) && \ + ((ip6addr).addr[3] == 0)) +#define ip6_addr_isany(ip6addr) (((ip6addr) == NULL) || ip6_addr_isany_val(*(ip6addr))) + +#define ip6_addr_isloopback(ip6addr) (((ip6addr)->addr[0] == 0UL) && \ + ((ip6addr)->addr[1] == 0UL) && \ + ((ip6addr)->addr[2] == 0UL) && \ + ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL))) + +#define ip6_addr_isglobal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xe0000000UL)) == PP_HTONL(0x20000000UL)) + +#define ip6_addr_islinklocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xffc00000UL)) == PP_HTONL(0xfe800000UL)) + +#define ip6_addr_issitelocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xffc00000UL)) == PP_HTONL(0xfec00000UL)) + +#define ip6_addr_isuniquelocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xfe000000UL)) == PP_HTONL(0xfc000000UL)) + +#define ip6_addr_isipv4mappedipv6(ip6addr) (((ip6addr)->addr[0] == 0) && ((ip6addr)->addr[1] == 0) && (((ip6addr)->addr[2]) == PP_HTONL(0x0000FFFFUL))) + +#define ip6_addr_ismulticast(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff000000UL)) == PP_HTONL(0xff000000UL)) +#define ip6_addr_multicast_transient_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00100000UL)) +#define ip6_addr_multicast_prefix_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00200000UL)) +#define ip6_addr_multicast_rendezvous_flag(ip6addr) ((ip6addr)->addr[0] & PP_HTONL(0x00400000UL)) +#define ip6_addr_multicast_scope(ip6addr) ((lwip_htonl((ip6addr)->addr[0]) >> 16) & 0xf) +#define IP6_MULTICAST_SCOPE_RESERVED 0x0 +#define IP6_MULTICAST_SCOPE_RESERVED0 0x0 +#define IP6_MULTICAST_SCOPE_INTERFACE_LOCAL 0x1 +#define IP6_MULTICAST_SCOPE_LINK_LOCAL 0x2 +#define IP6_MULTICAST_SCOPE_RESERVED3 0x3 +#define IP6_MULTICAST_SCOPE_ADMIN_LOCAL 0x4 +#define IP6_MULTICAST_SCOPE_SITE_LOCAL 0x5 +#define IP6_MULTICAST_SCOPE_ORGANIZATION_LOCAL 0x8 +#define IP6_MULTICAST_SCOPE_GLOBAL 0xe +#define IP6_MULTICAST_SCOPE_RESERVEDF 0xf +#define ip6_addr_ismulticast_iflocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff010000UL)) +#define ip6_addr_ismulticast_linklocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff020000UL)) +#define ip6_addr_ismulticast_adminlocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff040000UL)) +#define ip6_addr_ismulticast_sitelocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff050000UL)) +#define ip6_addr_ismulticast_orglocal(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff080000UL)) +#define ip6_addr_ismulticast_global(ip6addr) (((ip6addr)->addr[0] & PP_HTONL(0xff8f0000UL)) == PP_HTONL(0xff0e0000UL)) + +/* Scoping note: while interface-local and link-local multicast addresses do + * have a scope (i.e., they are meaningful only in the context of a particular + * interface), the following functions are not assigning or comparing zone + * indices. The reason for this is backward compatibility. Any call site that + * produces a non-global multicast address must assign a multicast address as + * appropriate itself. */ + +#define ip6_addr_isallnodes_iflocal(ip6addr) (((ip6addr)->addr[0] == PP_HTONL(0xff010000UL)) && \ + ((ip6addr)->addr[1] == 0UL) && \ + ((ip6addr)->addr[2] == 0UL) && \ + ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL))) + +#define ip6_addr_isallnodes_linklocal(ip6addr) (((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ + ((ip6addr)->addr[1] == 0UL) && \ + ((ip6addr)->addr[2] == 0UL) && \ + ((ip6addr)->addr[3] == PP_HTONL(0x00000001UL))) +#define ip6_addr_set_allnodes_linklocal(ip6addr) do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); \ + (ip6addr)->addr[1] = 0; \ + (ip6addr)->addr[2] = 0; \ + (ip6addr)->addr[3] = PP_HTONL(0x00000001UL); \ + ip6_addr_clear_zone(ip6addr); }while(0) + +#define ip6_addr_isallrouters_linklocal(ip6addr) (((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ + ((ip6addr)->addr[1] == 0UL) && \ + ((ip6addr)->addr[2] == 0UL) && \ + ((ip6addr)->addr[3] == PP_HTONL(0x00000002UL))) +#define ip6_addr_set_allrouters_linklocal(ip6addr) do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); \ + (ip6addr)->addr[1] = 0; \ + (ip6addr)->addr[2] = 0; \ + (ip6addr)->addr[3] = PP_HTONL(0x00000002UL); \ + ip6_addr_clear_zone(ip6addr); }while(0) + +#define ip6_addr_issolicitednode(ip6addr) ( ((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ + ((ip6addr)->addr[2] == PP_HTONL(0x00000001UL)) && \ + (((ip6addr)->addr[3] & PP_HTONL(0xff000000UL)) == PP_HTONL(0xff000000UL)) ) + +#define ip6_addr_set_solicitednode(ip6addr, if_id) do{(ip6addr)->addr[0] = PP_HTONL(0xff020000UL); \ + (ip6addr)->addr[1] = 0; \ + (ip6addr)->addr[2] = PP_HTONL(0x00000001UL); \ + (ip6addr)->addr[3] = (PP_HTONL(0xff000000UL) | (if_id)); \ + ip6_addr_clear_zone(ip6addr); }while(0) + +#define ip6_addr_cmp_solicitednode(ip6addr, sn_addr) (((ip6addr)->addr[0] == PP_HTONL(0xff020000UL)) && \ + ((ip6addr)->addr[1] == 0) && \ + ((ip6addr)->addr[2] == PP_HTONL(0x00000001UL)) && \ + ((ip6addr)->addr[3] == (PP_HTONL(0xff000000UL) | (sn_addr)->addr[3]))) + +/* IPv6 address states. */ +#define IP6_ADDR_INVALID 0x00 +#define IP6_ADDR_TENTATIVE 0x08 +#define IP6_ADDR_TENTATIVE_1 0x09 /* 1 probe sent */ +#define IP6_ADDR_TENTATIVE_2 0x0a /* 2 probes sent */ +#define IP6_ADDR_TENTATIVE_3 0x0b /* 3 probes sent */ +#define IP6_ADDR_TENTATIVE_4 0x0c /* 4 probes sent */ +#define IP6_ADDR_TENTATIVE_5 0x0d /* 5 probes sent */ +#define IP6_ADDR_TENTATIVE_6 0x0e /* 6 probes sent */ +#define IP6_ADDR_TENTATIVE_7 0x0f /* 7 probes sent */ +#define IP6_ADDR_VALID 0x10 /* This bit marks an address as valid (preferred or deprecated) */ +#define IP6_ADDR_PREFERRED 0x30 +#define IP6_ADDR_DEPRECATED 0x10 /* Same as VALID (valid but not preferred) */ +#define IP6_ADDR_DUPLICATED 0x40 /* Failed DAD test, not valid */ + +#define IP6_ADDR_TENTATIVE_COUNT_MASK 0x07 /* 1-7 probes sent */ + +#define ip6_addr_isinvalid(addr_state) (addr_state == IP6_ADDR_INVALID) +#define ip6_addr_istentative(addr_state) (addr_state & IP6_ADDR_TENTATIVE) +#define ip6_addr_isvalid(addr_state) (addr_state & IP6_ADDR_VALID) /* Include valid, preferred, and deprecated. */ +#define ip6_addr_ispreferred(addr_state) (addr_state == IP6_ADDR_PREFERRED) +#define ip6_addr_isdeprecated(addr_state) (addr_state == IP6_ADDR_DEPRECATED) +#define ip6_addr_isduplicated(addr_state) (addr_state == IP6_ADDR_DUPLICATED) + +#if LWIP_IPV6_ADDRESS_LIFETIMES +#define IP6_ADDR_LIFE_STATIC (0) +#define IP6_ADDR_LIFE_INFINITE (0xffffffffUL) +#define ip6_addr_life_isstatic(addr_life) ((addr_life) == IP6_ADDR_LIFE_STATIC) +#define ip6_addr_life_isinfinite(addr_life) ((addr_life) == IP6_ADDR_LIFE_INFINITE) +#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ + +#define ip6_addr_debug_print_parts(debug, a, b, c, d, e, f, g, h) \ + LWIP_DEBUGF(debug, ("%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F ":%" X16_F, \ + a, b, c, d, e, f, g, h)) +#define ip6_addr_debug_print(debug, ipaddr) \ + ip6_addr_debug_print_parts(debug, \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK1(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK2(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK3(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK4(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK5(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK6(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK7(ipaddr) : 0), \ + (u16_t)((ipaddr) != NULL ? IP6_ADDR_BLOCK8(ipaddr) : 0)) +#define ip6_addr_debug_print_val(debug, ipaddr) \ + ip6_addr_debug_print_parts(debug, \ + IP6_ADDR_BLOCK1(&(ipaddr)), \ + IP6_ADDR_BLOCK2(&(ipaddr)), \ + IP6_ADDR_BLOCK3(&(ipaddr)), \ + IP6_ADDR_BLOCK4(&(ipaddr)), \ + IP6_ADDR_BLOCK5(&(ipaddr)), \ + IP6_ADDR_BLOCK6(&(ipaddr)), \ + IP6_ADDR_BLOCK7(&(ipaddr)), \ + IP6_ADDR_BLOCK8(&(ipaddr))) + +#define IP6ADDR_STRLEN_MAX 46 + +int ip6addr_aton(const char *cp, ip6_addr_t *addr); +/** returns ptr to static buffer; not reentrant! */ +char *ip6addr_ntoa(const ip6_addr_t *addr); +char *ip6addr_ntoa_r(const ip6_addr_t *addr, char *buf, int buflen); + + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 */ + +#endif /* LWIP_HDR_IP6_ADDR_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_frag.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_frag.h index 71940dd7..87e0e86a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_frag.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_frag.h @@ -1,144 +1,144 @@ -/** - * @file - * - * IPv6 fragmentation and reassembly. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ -#ifndef LWIP_HDR_IP6_FRAG_H -#define LWIP_HDR_IP6_FRAG_H - -#include "lwip/opt.h" -#include "lwip/pbuf.h" -#include "lwip/ip6_addr.h" -#include "lwip/ip6.h" -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - - -#if LWIP_IPV6 && LWIP_IPV6_REASS /* don't build if not configured for use in lwipopts.h */ - -/** The IPv6 reassembly timer interval in milliseconds. */ -#define IP6_REASS_TMR_INTERVAL 1000 - -/** IP6_FRAG_COPYHEADER==1: for platforms where sizeof(void*) > 4, "struct - * ip6_reass_helper" is too large to be stored in the IPv6 fragment header, and - * will bleed into the header before it, which may be the IPv6 header or an - * extension header. This means that for each first fragment packet, we need to - * 1) make a copy of some IPv6 header fields (src+dest) that we need later on, - * just in case we do overwrite part of the IPv6 header, and 2) make a copy of - * the header data that we overwrote, so that we can restore it before either - * completing reassembly or sending an ICMPv6 reply. The last part is true even - * if this setting is disabled, but if it is enabled, we need to save a bit - * more data (up to the size of a pointer) because we overwrite more. */ -#ifndef IPV6_FRAG_COPYHEADER -#define IPV6_FRAG_COPYHEADER 0 -#endif - -/* With IPV6_FRAG_COPYHEADER==1, a helper structure may (or, depending on the - * presence of extensions, may not) overwrite part of the IP header. Therefore, - * we copy the fields that we need from the IP header for as long as the helper - * structure may still be in place. This is easier than temporarily restoring - * those fields in the IP header each time we need to perform checks on them. */ -#if IPV6_FRAG_COPYHEADER -#define IPV6_FRAG_SRC(ipr) ((ipr)->src) -#define IPV6_FRAG_DEST(ipr) ((ipr)->dest) -#else /* IPV6_FRAG_COPYHEADER */ -#define IPV6_FRAG_SRC(ipr) ((ipr)->iphdr->src) -#define IPV6_FRAG_DEST(ipr) ((ipr)->iphdr->dest) -#endif /* IPV6_FRAG_COPYHEADER */ - -/** IPv6 reassembly helper struct. - * This is exported because memp needs to know the size. - */ -struct ip6_reassdata { - struct ip6_reassdata *next; - struct pbuf *p; - struct ip6_hdr *iphdr; /* pointer to the first (original) IPv6 header */ -#if IPV6_FRAG_COPYHEADER - ip6_addr_p_t src; /* copy of the source address in the IP header */ - ip6_addr_p_t dest; /* copy of the destination address in the IP header */ - /* This buffer (for the part of the original header that we overwrite) will - * be slightly oversized, but we cannot compute the exact size from here. */ - u8_t orig_hdr[sizeof(struct ip6_frag_hdr) + sizeof(void*)]; -#else /* IPV6_FRAG_COPYHEADER */ - /* In this case we still need the buffer, for sending ICMPv6 replies. */ - u8_t orig_hdr[sizeof(struct ip6_frag_hdr)]; -#endif /* IPV6_FRAG_COPYHEADER */ - u32_t identification; - u16_t datagram_len; - u8_t nexth; - u8_t timer; -#if LWIP_IPV6_SCOPES - u8_t src_zone; /* zone of original packet's source address */ - u8_t dest_zone; /* zone of original packet's destination address */ -#endif /* LWIP_IPV6_SCOPES */ -}; - -#define ip6_reass_init() /* Compatibility define */ -void ip6_reass_tmr(void); -struct pbuf *ip6_reass(struct pbuf *p); - -#endif /* LWIP_IPV6 && LWIP_IPV6_REASS */ - -#if LWIP_IPV6 && LWIP_IPV6_FRAG /* don't build if not configured for use in lwipopts.h */ - -#ifndef LWIP_PBUF_CUSTOM_REF_DEFINED -#define LWIP_PBUF_CUSTOM_REF_DEFINED -/** A custom pbuf that holds a reference to another pbuf, which is freed - * when this custom pbuf is freed. This is used to create a custom PBUF_REF - * that points into the original pbuf. */ -struct pbuf_custom_ref { - /** 'base class' */ - struct pbuf_custom pc; - /** pointer to the original pbuf that is referenced */ - struct pbuf *original; -}; -#endif /* LWIP_PBUF_CUSTOM_REF_DEFINED */ - -err_t ip6_frag(struct pbuf *p, struct netif *netif, const ip6_addr_t *dest); - -#endif /* LWIP_IPV6 && LWIP_IPV6_FRAG */ - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_IP6_FRAG_H */ +/** + * @file + * + * IPv6 fragmentation and reassembly. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ +#ifndef LWIP_HDR_IP6_FRAG_H +#define LWIP_HDR_IP6_FRAG_H + +#include "lwip/opt.h" +#include "lwip/pbuf.h" +#include "lwip/ip6_addr.h" +#include "lwip/ip6.h" +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +#if LWIP_IPV6 && LWIP_IPV6_REASS /* don't build if not configured for use in lwipopts.h */ + +/** The IPv6 reassembly timer interval in milliseconds. */ +#define IP6_REASS_TMR_INTERVAL 1000 + +/** IP6_FRAG_COPYHEADER==1: for platforms where sizeof(void*) > 4, "struct + * ip6_reass_helper" is too large to be stored in the IPv6 fragment header, and + * will bleed into the header before it, which may be the IPv6 header or an + * extension header. This means that for each first fragment packet, we need to + * 1) make a copy of some IPv6 header fields (src+dest) that we need later on, + * just in case we do overwrite part of the IPv6 header, and 2) make a copy of + * the header data that we overwrote, so that we can restore it before either + * completing reassembly or sending an ICMPv6 reply. The last part is true even + * if this setting is disabled, but if it is enabled, we need to save a bit + * more data (up to the size of a pointer) because we overwrite more. */ +#ifndef IPV6_FRAG_COPYHEADER +#define IPV6_FRAG_COPYHEADER 0 +#endif + +/* With IPV6_FRAG_COPYHEADER==1, a helper structure may (or, depending on the + * presence of extensions, may not) overwrite part of the IP header. Therefore, + * we copy the fields that we need from the IP header for as long as the helper + * structure may still be in place. This is easier than temporarily restoring + * those fields in the IP header each time we need to perform checks on them. */ +#if IPV6_FRAG_COPYHEADER +#define IPV6_FRAG_SRC(ipr) ((ipr)->src) +#define IPV6_FRAG_DEST(ipr) ((ipr)->dest) +#else /* IPV6_FRAG_COPYHEADER */ +#define IPV6_FRAG_SRC(ipr) ((ipr)->iphdr->src) +#define IPV6_FRAG_DEST(ipr) ((ipr)->iphdr->dest) +#endif /* IPV6_FRAG_COPYHEADER */ + +/** IPv6 reassembly helper struct. + * This is exported because memp needs to know the size. + */ +struct ip6_reassdata { + struct ip6_reassdata *next; + struct pbuf *p; + struct ip6_hdr *iphdr; /* pointer to the first (original) IPv6 header */ +#if IPV6_FRAG_COPYHEADER + ip6_addr_p_t src; /* copy of the source address in the IP header */ + ip6_addr_p_t dest; /* copy of the destination address in the IP header */ + /* This buffer (for the part of the original header that we overwrite) will + * be slightly oversized, but we cannot compute the exact size from here. */ + u8_t orig_hdr[sizeof(struct ip6_frag_hdr) + sizeof(void*)]; +#else /* IPV6_FRAG_COPYHEADER */ + /* In this case we still need the buffer, for sending ICMPv6 replies. */ + u8_t orig_hdr[sizeof(struct ip6_frag_hdr)]; +#endif /* IPV6_FRAG_COPYHEADER */ + u32_t identification; + u16_t datagram_len; + u8_t nexth; + u8_t timer; +#if LWIP_IPV6_SCOPES + u8_t src_zone; /* zone of original packet's source address */ + u8_t dest_zone; /* zone of original packet's destination address */ +#endif /* LWIP_IPV6_SCOPES */ +}; + +#define ip6_reass_init() /* Compatibility define */ +void ip6_reass_tmr(void); +struct pbuf *ip6_reass(struct pbuf *p); + +#endif /* LWIP_IPV6 && LWIP_IPV6_REASS */ + +#if LWIP_IPV6 && LWIP_IPV6_FRAG /* don't build if not configured for use in lwipopts.h */ + +#ifndef LWIP_PBUF_CUSTOM_REF_DEFINED +#define LWIP_PBUF_CUSTOM_REF_DEFINED +/** A custom pbuf that holds a reference to another pbuf, which is freed + * when this custom pbuf is freed. This is used to create a custom PBUF_REF + * that points into the original pbuf. */ +struct pbuf_custom_ref { + /** 'base class' */ + struct pbuf_custom pc; + /** pointer to the original pbuf that is referenced */ + struct pbuf *original; +}; +#endif /* LWIP_PBUF_CUSTOM_REF_DEFINED */ + +err_t ip6_frag(struct pbuf *p, struct netif *netif, const ip6_addr_t *dest); + +#endif /* LWIP_IPV6 && LWIP_IPV6_FRAG */ + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_IP6_FRAG_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_zone.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_zone.h index 235141ea..525790e6 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_zone.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip6_zone.h @@ -1,304 +1,304 @@ -/** - * @file - * - * IPv6 address scopes, zones, and scoping policy. - * - * This header provides the means to implement support for IPv6 address scopes, - * as per RFC 4007. An address scope can be either global or more constrained. - * In lwIP, we say that an address "has a scope" or "is scoped" when its scope - * is constrained, in which case the address is meaningful only in a specific - * "zone." For unicast addresses, only link-local addresses have a scope; in - * that case, the scope is the link. For multicast addresses, there are various - * scopes defined by RFC 4007 and others. For any constrained scope, a system - * must establish a (potentially one-to-many) mapping between zones and local - * interfaces. For example, a link-local address is valid on only one link (its - * zone). That link may be attached to one or more local interfaces. The - * decisions on which scopes are constrained and the mapping between zones and - * interfaces is together what we refer to as the "scoping policy" - more on - * this in a bit. - * - * In lwIP, each IPv6 address has an associated zone index. This zone index may - * be set to "no zone" (IP6_NO_ZONE, 0) or an actual zone. We say that an - * address "has a zone" or "is zoned" when its zone index is *not* set to "no - * zone." In lwIP, in principle, each address should be "properly zoned," which - * means that if the address has a zone if and only if has a scope. As such, it - * is a rule that an unscoped (e.g., global) address must never have a zone. - * Even though one could argue that there is always one zone even for global - * scopes, this rule exists for implementation simplicity. Violation of the - * rule will trigger assertions or otherwise result in undesired behavior. - * - * Backward compatibility prevents us from requiring that applications always - * provide properly zoned addresses. We do enforce the rule that the in the - * lwIP link layer (everything below netif->output_ip6() and in particular ND6) - * *all* addresses are properly zoned. Thus, on the output paths down the - * stack, various places deal with the case of addresses that lack a zone. - * Some of them are best-effort for efficiency (e.g. the PCB bind and connect - * API calls' attempts to add missing zones); ultimately the IPv6 output - * handler (@ref ip6_output_if_src) will set a zone if necessary. - * - * Aside from dealing with scoped addresses lacking a zone, a proper IPv6 - * implementation must also ensure that a packet with a scoped source and/or - * destination address does not leave its zone. This is currently implemented - * in the input and forward functions. However, for output, these checks are - * deliberately omitted in order to keep the implementation lightweight. The - * routing algorithm in @ref ip6_route will take decisions such that it will - * not cause zone violations unless the application sets bad addresses, though. - * - * In terms of scoping policy, lwIP implements the default policy from RFC 4007 - * using macros in this file. This policy considers link-local unicast - * addresses and (only) interface-local and link-local multicast addresses as - * having a scope. For all these addresses, the zone is equal to the interface. - * As shown below in this file, it is possible to implement a custom policy. - */ - -/* - * Copyright (c) 2017 The MINIX 3 Project. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: David van Moolenbroek - * - */ -#ifndef LWIP_HDR_IP6_ZONE_H -#define LWIP_HDR_IP6_ZONE_H - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @defgroup ip6_zones IPv6 Zones - * @ingroup ip6 - * @{ - */ - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -/** Identifier for "no zone". */ -#define IP6_NO_ZONE 0 - -#if LWIP_IPV6_SCOPES - -/** Zone initializer for static IPv6 address initialization, including comma. */ -#define IPADDR6_ZONE_INIT , IP6_NO_ZONE - -/** Return the zone index of the given IPv6 address; possibly "no zone". */ -#define ip6_addr_zone(ip6addr) ((ip6addr)->zone) - -/** Does the given IPv6 address have a zone set? (0/1) */ -#define ip6_addr_has_zone(ip6addr) (ip6_addr_zone(ip6addr) != IP6_NO_ZONE) - -/** Set the zone field of an IPv6 address to a particular value. */ -#define ip6_addr_set_zone(ip6addr, zone_idx) ((ip6addr)->zone = (zone_idx)) - -/** Clear the zone field of an IPv6 address, setting it to "no zone". */ -#define ip6_addr_clear_zone(ip6addr) ((ip6addr)->zone = IP6_NO_ZONE) - -/** Copy the zone field from the second IPv6 address to the first one. */ -#define ip6_addr_copy_zone(ip6addr1, ip6addr2) ((ip6addr1).zone = (ip6addr2).zone) - -/** Is the zone field of the given IPv6 address equal to the given zone index? (0/1) */ -#define ip6_addr_equals_zone(ip6addr, zone_idx) ((ip6addr)->zone == (zone_idx)) - -/** Are the zone fields of the given IPv6 addresses equal? (0/1) - * This macro must only be used on IPv6 addresses of the same scope. */ -#define ip6_addr_cmp_zone(ip6addr1, ip6addr2) ((ip6addr1)->zone == (ip6addr2)->zone) - -/** Symbolic constants for the 'type' parameters in some of the macros. - * These exist for efficiency only, allowing the macros to avoid certain tests - * when the address is known not to be of a certain type. Dead code elimination - * will do the rest. IP6_MULTICAST is supported but currently not optimized. - * @see ip6_addr_has_scope, ip6_addr_assign_zone, ip6_addr_lacks_zone. - */ -enum lwip_ipv6_scope_type -{ - /** Unknown */ - IP6_UNKNOWN = 0, - /** Unicast */ - IP6_UNICAST = 1, - /** Multicast */ - IP6_MULTICAST = 2 -}; - -/** IPV6_CUSTOM_SCOPES: together, the following three macro definitions, - * @ref ip6_addr_has_scope, @ref ip6_addr_assign_zone, and - * @ref ip6_addr_test_zone, completely define the lwIP scoping policy. - * The definitions below implement the default policy from RFC 4007 Sec. 6. - * Should an implementation desire to implement a different policy, it can - * define IPV6_CUSTOM_SCOPES to 1 and supply its own definitions for the three - * macros instead. - */ -#ifndef IPV6_CUSTOM_SCOPES -#define IPV6_CUSTOM_SCOPES 0 -#endif /* !IPV6_CUSTOM_SCOPES */ - -#if !IPV6_CUSTOM_SCOPES - -/** - * Determine whether an IPv6 address has a constrained scope, and as such is - * meaningful only if accompanied by a zone index to identify the scope's zone. - * The given address type may be used to eliminate at compile time certain - * checks that will evaluate to false at run time anyway. - * - * This default implementation follows the default model of RFC 4007, where - * only interface-local and link-local scopes are defined. - * - * Even though the unicast loopback address does have an implied link-local - * scope, in this implementation it does not have an explicitly assigned zone - * index. As such it should not be tested for in this macro. - * - * @param ip6addr the IPv6 address (const); only its address part is examined. - * @param type address type; see @ref lwip_ipv6_scope_type. - * @return 1 if the address has a constrained scope, 0 if it does not. - */ -#define ip6_addr_has_scope(ip6addr, type) \ - (ip6_addr_islinklocal(ip6addr) || (((type) != IP6_UNICAST) && \ - (ip6_addr_ismulticast_iflocal(ip6addr) || \ - ip6_addr_ismulticast_linklocal(ip6addr)))) - -/** - * Assign a zone index to an IPv6 address, based on a network interface. If the - * given address has a scope, the assigned zone index is that scope's zone of - * the given netif; otherwise, the assigned zone index is "no zone". - * - * This default implementation follows the default model of RFC 4007, where - * only interface-local and link-local scopes are defined, and the zone index - * of both of those scopes always equals the index of the network interface. - * As such, this default implementation need not distinguish between different - * constrained scopes when assigning the zone. - * - * @param ip6addr the IPv6 address; its address part is examined, and its zone - * index is assigned. - * @param type address type; see @ref lwip_ipv6_scope_type. - * @param netif the network interface (const). - */ -#define ip6_addr_assign_zone(ip6addr, type, netif) \ - (ip6_addr_set_zone((ip6addr), \ - ip6_addr_has_scope((ip6addr), (type)) ? netif_get_index(netif) : 0)) - -/** - * Test whether an IPv6 address is "zone-compatible" with a network interface. - * That is, test whether the network interface is part of the zone associated - * with the address. For efficiency, this macro is only ever called if the - * given address is either scoped or zoned, and thus, it need not test this. - * If an address is scoped but not zoned, or zoned and not scoped, it is - * considered not zone-compatible with any netif. - * - * This default implementation follows the default model of RFC 4007, where - * only interface-local and link-local scopes are defined, and the zone index - * of both of those scopes always equals the index of the network interface. - * As such, there is always only one matching netif for a specific zone index, - * but all call sites of this macro currently support multiple matching netifs - * as well (at no additional expense in the common case). - * - * @param ip6addr the IPv6 address (const). - * @param netif the network interface (const). - * @return 1 if the address is scope-compatible with the netif, 0 if not. - */ -#define ip6_addr_test_zone(ip6addr, netif) \ - (ip6_addr_equals_zone((ip6addr), netif_get_index(netif))) - -#endif /* !IPV6_CUSTOM_SCOPES */ - -/** Does the given IPv6 address have a scope, and as such should also have a - * zone to be meaningful, but does not actually have a zone? (0/1) */ -#define ip6_addr_lacks_zone(ip6addr, type) \ - (!ip6_addr_has_zone(ip6addr) && ip6_addr_has_scope((ip6addr), (type))) - -/** - * Try to select a zone for a scoped address that does not yet have a zone. - * Called from PCB bind and connect routines, for two reasons: 1) to save on - * this (relatively expensive) selection for every individual packet route - * operation and 2) to allow the application to obtain the selected zone from - * the PCB as is customary for e.g. getsockname/getpeername BSD socket calls. - * - * Ideally, callers would always supply a properly zoned address, in which case - * this function would not be needed. It exists both for compatibility with the - * BSD socket API (which accepts zoneless destination addresses) and for - * backward compatibility with pre-scoping lwIP code. - * - * It may be impossible to select a zone, e.g. if there are no netifs. In that - * case, the address's zone field will be left as is. - * - * @param dest the IPv6 address for which to select and set a zone. - * @param src source IPv6 address (const); may be equal to dest. - */ -#define ip6_addr_select_zone(dest, src) do { struct netif *selected_netif; \ - selected_netif = ip6_route((src), (dest)); \ - if (selected_netif != NULL) { \ - ip6_addr_assign_zone((dest), IP6_UNKNOWN, selected_netif); \ - } } while (0) - -/** - * @} - */ - -#else /* LWIP_IPV6_SCOPES */ - -#define IPADDR6_ZONE_INIT -#define ip6_addr_zone(ip6addr) (IP6_NO_ZONE) -#define ip6_addr_has_zone(ip6addr) (0) -#define ip6_addr_set_zone(ip6addr, zone_idx) -#define ip6_addr_clear_zone(ip6addr) -#define ip6_addr_copy_zone(ip6addr1, ip6addr2) -#define ip6_addr_equals_zone(ip6addr, zone_idx) (1) -#define ip6_addr_cmp_zone(ip6addr1, ip6addr2) (1) -#define IPV6_CUSTOM_SCOPES 0 -#define ip6_addr_has_scope(ip6addr, type) (0) -#define ip6_addr_assign_zone(ip6addr, type, netif) -#define ip6_addr_test_zone(ip6addr, netif) (1) -#define ip6_addr_lacks_zone(ip6addr, type) (0) -#define ip6_addr_select_zone(ip6addr, src) - -#endif /* LWIP_IPV6_SCOPES */ - -#if LWIP_IPV6_SCOPES && LWIP_IPV6_SCOPES_DEBUG - -/** Verify that the given IPv6 address is properly zoned. */ -#define IP6_ADDR_ZONECHECK(ip6addr) LWIP_ASSERT("IPv6 zone check failed", \ - ip6_addr_has_scope(ip6addr, IP6_UNKNOWN) == ip6_addr_has_zone(ip6addr)) - -/** Verify that the given IPv6 address is properly zoned for the given netif. */ -#define IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif) LWIP_ASSERT("IPv6 netif zone check failed", \ - ip6_addr_has_scope(ip6addr, IP6_UNKNOWN) ? \ - (ip6_addr_has_zone(ip6addr) && \ - (((netif) == NULL) || ip6_addr_test_zone((ip6addr), (netif)))) : \ - !ip6_addr_has_zone(ip6addr)) - -#else /* LWIP_IPV6_SCOPES && LWIP_IPV6_SCOPES_DEBUG */ - -#define IP6_ADDR_ZONECHECK(ip6addr) -#define IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif) - -#endif /* LWIP_IPV6_SCOPES && LWIP_IPV6_SCOPES_DEBUG */ - -#endif /* LWIP_IPV6 */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_IP6_ZONE_H */ +/** + * @file + * + * IPv6 address scopes, zones, and scoping policy. + * + * This header provides the means to implement support for IPv6 address scopes, + * as per RFC 4007. An address scope can be either global or more constrained. + * In lwIP, we say that an address "has a scope" or "is scoped" when its scope + * is constrained, in which case the address is meaningful only in a specific + * "zone." For unicast addresses, only link-local addresses have a scope; in + * that case, the scope is the link. For multicast addresses, there are various + * scopes defined by RFC 4007 and others. For any constrained scope, a system + * must establish a (potentially one-to-many) mapping between zones and local + * interfaces. For example, a link-local address is valid on only one link (its + * zone). That link may be attached to one or more local interfaces. The + * decisions on which scopes are constrained and the mapping between zones and + * interfaces is together what we refer to as the "scoping policy" - more on + * this in a bit. + * + * In lwIP, each IPv6 address has an associated zone index. This zone index may + * be set to "no zone" (IP6_NO_ZONE, 0) or an actual zone. We say that an + * address "has a zone" or "is zoned" when its zone index is *not* set to "no + * zone." In lwIP, in principle, each address should be "properly zoned," which + * means that if the address has a zone if and only if has a scope. As such, it + * is a rule that an unscoped (e.g., global) address must never have a zone. + * Even though one could argue that there is always one zone even for global + * scopes, this rule exists for implementation simplicity. Violation of the + * rule will trigger assertions or otherwise result in undesired behavior. + * + * Backward compatibility prevents us from requiring that applications always + * provide properly zoned addresses. We do enforce the rule that the in the + * lwIP link layer (everything below netif->output_ip6() and in particular ND6) + * *all* addresses are properly zoned. Thus, on the output paths down the + * stack, various places deal with the case of addresses that lack a zone. + * Some of them are best-effort for efficiency (e.g. the PCB bind and connect + * API calls' attempts to add missing zones); ultimately the IPv6 output + * handler (@ref ip6_output_if_src) will set a zone if necessary. + * + * Aside from dealing with scoped addresses lacking a zone, a proper IPv6 + * implementation must also ensure that a packet with a scoped source and/or + * destination address does not leave its zone. This is currently implemented + * in the input and forward functions. However, for output, these checks are + * deliberately omitted in order to keep the implementation lightweight. The + * routing algorithm in @ref ip6_route will take decisions such that it will + * not cause zone violations unless the application sets bad addresses, though. + * + * In terms of scoping policy, lwIP implements the default policy from RFC 4007 + * using macros in this file. This policy considers link-local unicast + * addresses and (only) interface-local and link-local multicast addresses as + * having a scope. For all these addresses, the zone is equal to the interface. + * As shown below in this file, it is possible to implement a custom policy. + */ + +/* + * Copyright (c) 2017 The MINIX 3 Project. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: David van Moolenbroek + * + */ +#ifndef LWIP_HDR_IP6_ZONE_H +#define LWIP_HDR_IP6_ZONE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup ip6_zones IPv6 Zones + * @ingroup ip6 + * @{ + */ + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +/** Identifier for "no zone". */ +#define IP6_NO_ZONE 0 + +#if LWIP_IPV6_SCOPES + +/** Zone initializer for static IPv6 address initialization, including comma. */ +#define IPADDR6_ZONE_INIT , IP6_NO_ZONE + +/** Return the zone index of the given IPv6 address; possibly "no zone". */ +#define ip6_addr_zone(ip6addr) ((ip6addr)->zone) + +/** Does the given IPv6 address have a zone set? (0/1) */ +#define ip6_addr_has_zone(ip6addr) (ip6_addr_zone(ip6addr) != IP6_NO_ZONE) + +/** Set the zone field of an IPv6 address to a particular value. */ +#define ip6_addr_set_zone(ip6addr, zone_idx) ((ip6addr)->zone = (zone_idx)) + +/** Clear the zone field of an IPv6 address, setting it to "no zone". */ +#define ip6_addr_clear_zone(ip6addr) ((ip6addr)->zone = IP6_NO_ZONE) + +/** Copy the zone field from the second IPv6 address to the first one. */ +#define ip6_addr_copy_zone(ip6addr1, ip6addr2) ((ip6addr1).zone = (ip6addr2).zone) + +/** Is the zone field of the given IPv6 address equal to the given zone index? (0/1) */ +#define ip6_addr_equals_zone(ip6addr, zone_idx) ((ip6addr)->zone == (zone_idx)) + +/** Are the zone fields of the given IPv6 addresses equal? (0/1) + * This macro must only be used on IPv6 addresses of the same scope. */ +#define ip6_addr_cmp_zone(ip6addr1, ip6addr2) ((ip6addr1)->zone == (ip6addr2)->zone) + +/** Symbolic constants for the 'type' parameters in some of the macros. + * These exist for efficiency only, allowing the macros to avoid certain tests + * when the address is known not to be of a certain type. Dead code elimination + * will do the rest. IP6_MULTICAST is supported but currently not optimized. + * @see ip6_addr_has_scope, ip6_addr_assign_zone, ip6_addr_lacks_zone. + */ +enum lwip_ipv6_scope_type +{ + /** Unknown */ + IP6_UNKNOWN = 0, + /** Unicast */ + IP6_UNICAST = 1, + /** Multicast */ + IP6_MULTICAST = 2 +}; + +/** IPV6_CUSTOM_SCOPES: together, the following three macro definitions, + * @ref ip6_addr_has_scope, @ref ip6_addr_assign_zone, and + * @ref ip6_addr_test_zone, completely define the lwIP scoping policy. + * The definitions below implement the default policy from RFC 4007 Sec. 6. + * Should an implementation desire to implement a different policy, it can + * define IPV6_CUSTOM_SCOPES to 1 and supply its own definitions for the three + * macros instead. + */ +#ifndef IPV6_CUSTOM_SCOPES +#define IPV6_CUSTOM_SCOPES 0 +#endif /* !IPV6_CUSTOM_SCOPES */ + +#if !IPV6_CUSTOM_SCOPES + +/** + * Determine whether an IPv6 address has a constrained scope, and as such is + * meaningful only if accompanied by a zone index to identify the scope's zone. + * The given address type may be used to eliminate at compile time certain + * checks that will evaluate to false at run time anyway. + * + * This default implementation follows the default model of RFC 4007, where + * only interface-local and link-local scopes are defined. + * + * Even though the unicast loopback address does have an implied link-local + * scope, in this implementation it does not have an explicitly assigned zone + * index. As such it should not be tested for in this macro. + * + * @param ip6addr the IPv6 address (const); only its address part is examined. + * @param type address type; see @ref lwip_ipv6_scope_type. + * @return 1 if the address has a constrained scope, 0 if it does not. + */ +#define ip6_addr_has_scope(ip6addr, type) \ + (ip6_addr_islinklocal(ip6addr) || (((type) != IP6_UNICAST) && \ + (ip6_addr_ismulticast_iflocal(ip6addr) || \ + ip6_addr_ismulticast_linklocal(ip6addr)))) + +/** + * Assign a zone index to an IPv6 address, based on a network interface. If the + * given address has a scope, the assigned zone index is that scope's zone of + * the given netif; otherwise, the assigned zone index is "no zone". + * + * This default implementation follows the default model of RFC 4007, where + * only interface-local and link-local scopes are defined, and the zone index + * of both of those scopes always equals the index of the network interface. + * As such, this default implementation need not distinguish between different + * constrained scopes when assigning the zone. + * + * @param ip6addr the IPv6 address; its address part is examined, and its zone + * index is assigned. + * @param type address type; see @ref lwip_ipv6_scope_type. + * @param netif the network interface (const). + */ +#define ip6_addr_assign_zone(ip6addr, type, netif) \ + (ip6_addr_set_zone((ip6addr), \ + ip6_addr_has_scope((ip6addr), (type)) ? netif_get_index(netif) : 0)) + +/** + * Test whether an IPv6 address is "zone-compatible" with a network interface. + * That is, test whether the network interface is part of the zone associated + * with the address. For efficiency, this macro is only ever called if the + * given address is either scoped or zoned, and thus, it need not test this. + * If an address is scoped but not zoned, or zoned and not scoped, it is + * considered not zone-compatible with any netif. + * + * This default implementation follows the default model of RFC 4007, where + * only interface-local and link-local scopes are defined, and the zone index + * of both of those scopes always equals the index of the network interface. + * As such, there is always only one matching netif for a specific zone index, + * but all call sites of this macro currently support multiple matching netifs + * as well (at no additional expense in the common case). + * + * @param ip6addr the IPv6 address (const). + * @param netif the network interface (const). + * @return 1 if the address is scope-compatible with the netif, 0 if not. + */ +#define ip6_addr_test_zone(ip6addr, netif) \ + (ip6_addr_equals_zone((ip6addr), netif_get_index(netif))) + +#endif /* !IPV6_CUSTOM_SCOPES */ + +/** Does the given IPv6 address have a scope, and as such should also have a + * zone to be meaningful, but does not actually have a zone? (0/1) */ +#define ip6_addr_lacks_zone(ip6addr, type) \ + (!ip6_addr_has_zone(ip6addr) && ip6_addr_has_scope((ip6addr), (type))) + +/** + * Try to select a zone for a scoped address that does not yet have a zone. + * Called from PCB bind and connect routines, for two reasons: 1) to save on + * this (relatively expensive) selection for every individual packet route + * operation and 2) to allow the application to obtain the selected zone from + * the PCB as is customary for e.g. getsockname/getpeername BSD socket calls. + * + * Ideally, callers would always supply a properly zoned address, in which case + * this function would not be needed. It exists both for compatibility with the + * BSD socket API (which accepts zoneless destination addresses) and for + * backward compatibility with pre-scoping lwIP code. + * + * It may be impossible to select a zone, e.g. if there are no netifs. In that + * case, the address's zone field will be left as is. + * + * @param dest the IPv6 address for which to select and set a zone. + * @param src source IPv6 address (const); may be equal to dest. + */ +#define ip6_addr_select_zone(dest, src) do { struct netif *selected_netif; \ + selected_netif = ip6_route((src), (dest)); \ + if (selected_netif != NULL) { \ + ip6_addr_assign_zone((dest), IP6_UNKNOWN, selected_netif); \ + } } while (0) + +/** + * @} + */ + +#else /* LWIP_IPV6_SCOPES */ + +#define IPADDR6_ZONE_INIT +#define ip6_addr_zone(ip6addr) (IP6_NO_ZONE) +#define ip6_addr_has_zone(ip6addr) (0) +#define ip6_addr_set_zone(ip6addr, zone_idx) +#define ip6_addr_clear_zone(ip6addr) +#define ip6_addr_copy_zone(ip6addr1, ip6addr2) +#define ip6_addr_equals_zone(ip6addr, zone_idx) (1) +#define ip6_addr_cmp_zone(ip6addr1, ip6addr2) (1) +#define IPV6_CUSTOM_SCOPES 0 +#define ip6_addr_has_scope(ip6addr, type) (0) +#define ip6_addr_assign_zone(ip6addr, type, netif) +#define ip6_addr_test_zone(ip6addr, netif) (1) +#define ip6_addr_lacks_zone(ip6addr, type) (0) +#define ip6_addr_select_zone(ip6addr, src) + +#endif /* LWIP_IPV6_SCOPES */ + +#if LWIP_IPV6_SCOPES && LWIP_IPV6_SCOPES_DEBUG + +/** Verify that the given IPv6 address is properly zoned. */ +#define IP6_ADDR_ZONECHECK(ip6addr) LWIP_ASSERT("IPv6 zone check failed", \ + ip6_addr_has_scope(ip6addr, IP6_UNKNOWN) == ip6_addr_has_zone(ip6addr)) + +/** Verify that the given IPv6 address is properly zoned for the given netif. */ +#define IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif) LWIP_ASSERT("IPv6 netif zone check failed", \ + ip6_addr_has_scope(ip6addr, IP6_UNKNOWN) ? \ + (ip6_addr_has_zone(ip6addr) && \ + (((netif) == NULL) || ip6_addr_test_zone((ip6addr), (netif)))) : \ + !ip6_addr_has_zone(ip6addr)) + +#else /* LWIP_IPV6_SCOPES && LWIP_IPV6_SCOPES_DEBUG */ + +#define IP6_ADDR_ZONECHECK(ip6addr) +#define IP6_ADDR_ZONECHECK_NETIF(ip6addr, netif) + +#endif /* LWIP_IPV6_SCOPES && LWIP_IPV6_SCOPES_DEBUG */ + +#endif /* LWIP_IPV6 */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_IP6_ZONE_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip_addr.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip_addr.h index f98fa8ad..2f977709 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip_addr.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/ip_addr.h @@ -1,438 +1,438 @@ -/** - * @file - * IP address API (common IPv4 and IPv6) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_IP_ADDR_H -#define LWIP_HDR_IP_ADDR_H - -#include "lwip/opt.h" -#include "lwip/def.h" - -#include "lwip/ip4_addr.h" -#include "lwip/ip6_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** @ingroup ipaddr - * IP address types for use in ip_addr_t.type member. - * @see tcp_new_ip_type(), udp_new_ip_type(), raw_new_ip_type(). - */ -enum lwip_ip_addr_type { - /** IPv4 */ - IPADDR_TYPE_V4 = 0U, - /** IPv6 */ - IPADDR_TYPE_V6 = 6U, - /** IPv4+IPv6 ("dual-stack") */ - IPADDR_TYPE_ANY = 46U -}; - -#if LWIP_IPV4 && LWIP_IPV6 -/** - * @ingroup ipaddr - * A union struct for both IP version's addresses. - * ATTENTION: watch out for its size when adding IPv6 address scope! - */ -typedef struct ip_addr { - union { - ip6_addr_t ip6; - ip4_addr_t ip4; - } u_addr; - /** @ref lwip_ip_addr_type */ - u8_t type; -} ip_addr_t; - -extern const ip_addr_t ip_addr_any_type; - -/** @ingroup ip4addr */ -#define IPADDR4_INIT(u32val) { { { { u32val, 0ul, 0ul, 0ul } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_V4 } -/** @ingroup ip4addr */ -#define IPADDR4_INIT_BYTES(a,b,c,d) IPADDR4_INIT(PP_HTONL(LWIP_MAKEU32(a,b,c,d))) - -/** @ingroup ip6addr */ -#define IPADDR6_INIT(a, b, c, d) { { { { a, b, c, d } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_V6 } -/** @ingroup ip6addr */ -#define IPADDR6_INIT_HOST(a, b, c, d) { { { { PP_HTONL(a), PP_HTONL(b), PP_HTONL(c), PP_HTONL(d) } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_V6 } - -/** @ingroup ipaddr */ -#define IP_IS_ANY_TYPE_VAL(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_ANY) -/** @ingroup ipaddr */ -#define IPADDR_ANY_TYPE_INIT { { { { 0ul, 0ul, 0ul, 0ul } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_ANY } - -/** @ingroup ip4addr */ -#define IP_IS_V4_VAL(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_V4) -/** @ingroup ip6addr */ -#define IP_IS_V6_VAL(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_V6) -/** @ingroup ip4addr */ -#define IP_IS_V4(ipaddr) (((ipaddr) == NULL) || IP_IS_V4_VAL(*(ipaddr))) -/** @ingroup ip6addr */ -#define IP_IS_V6(ipaddr) (((ipaddr) != NULL) && IP_IS_V6_VAL(*(ipaddr))) - -#define IP_SET_TYPE_VAL(ipaddr, iptype) do { (ipaddr).type = (iptype); }while(0) -#define IP_SET_TYPE(ipaddr, iptype) do { if((ipaddr) != NULL) { IP_SET_TYPE_VAL(*(ipaddr), iptype); }}while(0) -#define IP_GET_TYPE(ipaddr) ((ipaddr)->type) - -#define IP_ADDR_RAW_SIZE(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_V4 ? sizeof(ip4_addr_t) : sizeof(ip6_addr_t)) - -#define IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ipaddr) (IP_GET_TYPE(&pcb->local_ip) == IP_GET_TYPE(ipaddr)) -#define IP_ADDR_PCB_VERSION_MATCH(pcb, ipaddr) (IP_IS_ANY_TYPE_VAL(pcb->local_ip) || IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ipaddr)) - -/** @ingroup ip6addr - * Convert generic ip address to specific protocol version - */ -#define ip_2_ip6(ipaddr) (&((ipaddr)->u_addr.ip6)) -/** @ingroup ip4addr - * Convert generic ip address to specific protocol version - */ -#define ip_2_ip4(ipaddr) (&((ipaddr)->u_addr.ip4)) - -/** @ingroup ip4addr */ -#define IP_ADDR4(ipaddr,a,b,c,d) do { IP4_ADDR(ip_2_ip4(ipaddr),a,b,c,d); \ - IP_SET_TYPE_VAL(*(ipaddr), IPADDR_TYPE_V4); } while(0) -/** @ingroup ip6addr */ -#define IP_ADDR6(ipaddr,i0,i1,i2,i3) do { IP6_ADDR(ip_2_ip6(ipaddr),i0,i1,i2,i3); \ - IP_SET_TYPE_VAL(*(ipaddr), IPADDR_TYPE_V6); } while(0) -/** @ingroup ip6addr */ -#define IP_ADDR6_HOST(ipaddr,i0,i1,i2,i3) IP_ADDR6(ipaddr,PP_HTONL(i0),PP_HTONL(i1),PP_HTONL(i2),PP_HTONL(i3)) - -#define ip_clear_no4(ipaddr) do { ip_2_ip6(ipaddr)->addr[1] = \ - ip_2_ip6(ipaddr)->addr[2] = \ - ip_2_ip6(ipaddr)->addr[3] = 0; \ - ip6_addr_clear_zone(ip_2_ip6(ipaddr)); }while(0) - -/** @ingroup ipaddr */ -#define ip_addr_copy(dest, src) do{ IP_SET_TYPE_VAL(dest, IP_GET_TYPE(&src)); if(IP_IS_V6_VAL(src)){ \ - ip6_addr_copy(*ip_2_ip6(&(dest)), *ip_2_ip6(&(src))); }else{ \ - ip4_addr_copy(*ip_2_ip4(&(dest)), *ip_2_ip4(&(src))); ip_clear_no4(&dest); }}while(0) -/** @ingroup ip6addr */ -#define ip_addr_copy_from_ip6(dest, src) do{ \ - ip6_addr_copy(*ip_2_ip6(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V6); }while(0) -/** @ingroup ip6addr */ -#define ip_addr_copy_from_ip6_packed(dest, src) do{ \ - ip6_addr_copy_from_packed(*ip_2_ip6(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V6); }while(0) -/** @ingroup ip4addr */ -#define ip_addr_copy_from_ip4(dest, src) do{ \ - ip4_addr_copy(*ip_2_ip4(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V4); ip_clear_no4(&dest); }while(0) -/** @ingroup ip4addr */ -#define ip_addr_set_ip4_u32(ipaddr, val) do{if(ipaddr){ip4_addr_set_u32(ip_2_ip4(ipaddr), val); \ - IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) -/** @ingroup ip4addr */ -#define ip_addr_set_ip4_u32_val(ipaddr, val) do{ ip4_addr_set_u32(ip_2_ip4(&(ipaddr)), val); \ - IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }while(0) -/** @ingroup ip4addr */ -#define ip_addr_get_ip4_u32(ipaddr) (((ipaddr) && IP_IS_V4(ipaddr)) ? \ - ip4_addr_get_u32(ip_2_ip4(ipaddr)) : 0) -/** @ingroup ipaddr */ -#define ip_addr_set(dest, src) do{ IP_SET_TYPE(dest, IP_GET_TYPE(src)); if(IP_IS_V6(src)){ \ - ip6_addr_set(ip_2_ip6(dest), ip_2_ip6(src)); }else{ \ - ip4_addr_set(ip_2_ip4(dest), ip_2_ip4(src)); ip_clear_no4(dest); }}while(0) -/** @ingroup ipaddr */ -#define ip_addr_set_ipaddr(dest, src) ip_addr_set(dest, src) -/** @ingroup ipaddr */ -#define ip_addr_set_zero(ipaddr) do{ \ - ip6_addr_set_zero(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, 0); }while(0) -/** @ingroup ip5addr */ -#define ip_addr_set_zero_ip4(ipaddr) do{ \ - ip6_addr_set_zero(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); }while(0) -/** @ingroup ip6addr */ -#define ip_addr_set_zero_ip6(ipaddr) do{ \ - ip6_addr_set_zero(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }while(0) -/** @ingroup ipaddr */ -#define ip_addr_set_any(is_ipv6, ipaddr) do{if(is_ipv6){ \ - ip6_addr_set_any(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }else{ \ - ip4_addr_set_any(ip_2_ip4(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) -/** @ingroup ipaddr */ -#define ip_addr_set_any_val(is_ipv6, ipaddr) do{if(is_ipv6){ \ - ip6_addr_set_any(ip_2_ip6(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V6); }else{ \ - ip4_addr_set_any(ip_2_ip4(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }}while(0) -/** @ingroup ipaddr */ -#define ip_addr_set_loopback(is_ipv6, ipaddr) do{if(is_ipv6){ \ - ip6_addr_set_loopback(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }else{ \ - ip4_addr_set_loopback(ip_2_ip4(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) -/** @ingroup ipaddr */ -#define ip_addr_set_loopback_val(is_ipv6, ipaddr) do{if(is_ipv6){ \ - ip6_addr_set_loopback(ip_2_ip6(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V6); }else{ \ - ip4_addr_set_loopback(ip_2_ip4(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }}while(0) -/** @ingroup ipaddr */ -#define ip_addr_set_hton(dest, src) do{if(IP_IS_V6(src)){ \ - ip6_addr_set_hton(ip_2_ip6(dest), ip_2_ip6(src)); IP_SET_TYPE(dest, IPADDR_TYPE_V6); }else{ \ - ip4_addr_set_hton(ip_2_ip4(dest), ip_2_ip4(src)); IP_SET_TYPE(dest, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) -/** @ingroup ipaddr */ -#define ip_addr_get_network(target, host, netmask) do{if(IP_IS_V6(host)){ \ - ip4_addr_set_zero(ip_2_ip4(target)); IP_SET_TYPE(target, IPADDR_TYPE_V6); } else { \ - ip4_addr_get_network(ip_2_ip4(target), ip_2_ip4(host), ip_2_ip4(netmask)); IP_SET_TYPE(target, IPADDR_TYPE_V4); }}while(0) -/** @ingroup ipaddr */ -#define ip_addr_netcmp(addr1, addr2, mask) ((IP_IS_V6(addr1) && IP_IS_V6(addr2)) ? \ - 0 : \ - ip4_addr_netcmp(ip_2_ip4(addr1), ip_2_ip4(addr2), mask)) -/** @ingroup ipaddr */ -#define ip_addr_cmp(addr1, addr2) ((IP_GET_TYPE(addr1) != IP_GET_TYPE(addr2)) ? 0 : (IP_IS_V6_VAL(*(addr1)) ? \ - ip6_addr_cmp(ip_2_ip6(addr1), ip_2_ip6(addr2)) : \ - ip4_addr_cmp(ip_2_ip4(addr1), ip_2_ip4(addr2)))) -/** @ingroup ipaddr */ -#define ip_addr_cmp_zoneless(addr1, addr2) ((IP_GET_TYPE(addr1) != IP_GET_TYPE(addr2)) ? 0 : (IP_IS_V6_VAL(*(addr1)) ? \ - ip6_addr_cmp_zoneless(ip_2_ip6(addr1), ip_2_ip6(addr2)) : \ - ip4_addr_cmp(ip_2_ip4(addr1), ip_2_ip4(addr2)))) -/** @ingroup ipaddr */ -#define ip_addr_isany(ipaddr) (((ipaddr) == NULL) ? 1 : ((IP_IS_V6(ipaddr)) ? \ - ip6_addr_isany(ip_2_ip6(ipaddr)) : \ - ip4_addr_isany(ip_2_ip4(ipaddr)))) -/** @ingroup ipaddr */ -#define ip_addr_isany_val(ipaddr) ((IP_IS_V6_VAL(ipaddr)) ? \ - ip6_addr_isany_val(*ip_2_ip6(&(ipaddr))) : \ - ip4_addr_isany_val(*ip_2_ip4(&(ipaddr)))) -/** @ingroup ipaddr */ -#define ip_addr_isbroadcast(ipaddr, netif) ((IP_IS_V6(ipaddr)) ? \ - 0 : \ - ip4_addr_isbroadcast(ip_2_ip4(ipaddr), netif)) -/** @ingroup ipaddr */ -#define ip_addr_ismulticast(ipaddr) ((IP_IS_V6(ipaddr)) ? \ - ip6_addr_ismulticast(ip_2_ip6(ipaddr)) : \ - ip4_addr_ismulticast(ip_2_ip4(ipaddr))) -/** @ingroup ipaddr */ -#define ip_addr_isloopback(ipaddr) ((IP_IS_V6(ipaddr)) ? \ - ip6_addr_isloopback(ip_2_ip6(ipaddr)) : \ - ip4_addr_isloopback(ip_2_ip4(ipaddr))) -/** @ingroup ipaddr */ -#define ip_addr_islinklocal(ipaddr) ((IP_IS_V6(ipaddr)) ? \ - ip6_addr_islinklocal(ip_2_ip6(ipaddr)) : \ - ip4_addr_islinklocal(ip_2_ip4(ipaddr))) -#define ip_addr_debug_print(debug, ipaddr) do { if(IP_IS_V6(ipaddr)) { \ - ip6_addr_debug_print(debug, ip_2_ip6(ipaddr)); } else { \ - ip4_addr_debug_print(debug, ip_2_ip4(ipaddr)); }}while(0) -#define ip_addr_debug_print_val(debug, ipaddr) do { if(IP_IS_V6_VAL(ipaddr)) { \ - ip6_addr_debug_print_val(debug, *ip_2_ip6(&(ipaddr))); } else { \ - ip4_addr_debug_print_val(debug, *ip_2_ip4(&(ipaddr))); }}while(0) -char *ipaddr_ntoa(const ip_addr_t *addr); -char *ipaddr_ntoa_r(const ip_addr_t *addr, char *buf, int buflen); -int ipaddr_aton(const char *cp, ip_addr_t *addr); - -/** @ingroup ipaddr */ -#define IPADDR_STRLEN_MAX IP6ADDR_STRLEN_MAX - -/** @ingroup ipaddr */ -#define ip4_2_ipv4_mapped_ipv6(ip6addr, ip4addr) do { \ - (ip6addr)->addr[3] = (ip4addr)->addr; \ - (ip6addr)->addr[2] = PP_HTONL(0x0000FFFFUL); \ - (ip6addr)->addr[1] = 0; \ - (ip6addr)->addr[0] = 0; \ - ip6_addr_clear_zone(ip6addr); } while(0); - -/** @ingroup ipaddr */ -#define unmap_ipv4_mapped_ipv6(ip4addr, ip6addr) \ - (ip4addr)->addr = (ip6addr)->addr[3]; - -#define IP46_ADDR_ANY(type) (((type) == IPADDR_TYPE_V6)? IP6_ADDR_ANY : IP4_ADDR_ANY) - -#else /* LWIP_IPV4 && LWIP_IPV6 */ - -#define IP_ADDR_PCB_VERSION_MATCH(addr, pcb) 1 -#define IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ipaddr) 1 - -#define ip_addr_set_any_val(is_ipv6, ipaddr) ip_addr_set_any(is_ipv6, &(ipaddr)) -#define ip_addr_set_loopback_val(is_ipv6, ipaddr) ip_addr_set_loopback(is_ipv6, &(ipaddr)) - -#if LWIP_IPV4 - -typedef ip4_addr_t ip_addr_t; -#define IPADDR4_INIT(u32val) { u32val } -#define IPADDR4_INIT_BYTES(a,b,c,d) IPADDR4_INIT(PP_HTONL(LWIP_MAKEU32(a,b,c,d))) -#define IP_IS_V4_VAL(ipaddr) 1 -#define IP_IS_V6_VAL(ipaddr) 0 -#define IP_IS_V4(ipaddr) 1 -#define IP_IS_V6(ipaddr) 0 -#define IP_IS_ANY_TYPE_VAL(ipaddr) 0 -#define IP_SET_TYPE_VAL(ipaddr, iptype) -#define IP_SET_TYPE(ipaddr, iptype) -#define IP_GET_TYPE(ipaddr) IPADDR_TYPE_V4 -#define IP_ADDR_RAW_SIZE(ipaddr) sizeof(ip4_addr_t) -#define ip_2_ip4(ipaddr) (ipaddr) -#define IP_ADDR4(ipaddr,a,b,c,d) IP4_ADDR(ipaddr,a,b,c,d) - -#define ip_addr_copy(dest, src) ip4_addr_copy(dest, src) -#define ip_addr_copy_from_ip4(dest, src) ip4_addr_copy(dest, src) -#define ip_addr_set_ip4_u32(ipaddr, val) ip4_addr_set_u32(ip_2_ip4(ipaddr), val) -#define ip_addr_set_ip4_u32_val(ipaddr, val) ip_addr_set_ip4_u32(&(ipaddr), val) -#define ip_addr_get_ip4_u32(ipaddr) ip4_addr_get_u32(ip_2_ip4(ipaddr)) -#define ip_addr_set(dest, src) ip4_addr_set(dest, src) -#define ip_addr_set_ipaddr(dest, src) ip4_addr_set(dest, src) -#define ip_addr_set_zero(ipaddr) ip4_addr_set_zero(ipaddr) -#define ip_addr_set_zero_ip4(ipaddr) ip4_addr_set_zero(ipaddr) -#define ip_addr_set_any(is_ipv6, ipaddr) ip4_addr_set_any(ipaddr) -#define ip_addr_set_loopback(is_ipv6, ipaddr) ip4_addr_set_loopback(ipaddr) -#define ip_addr_set_hton(dest, src) ip4_addr_set_hton(dest, src) -#define ip_addr_get_network(target, host, mask) ip4_addr_get_network(target, host, mask) -#define ip_addr_netcmp(addr1, addr2, mask) ip4_addr_netcmp(addr1, addr2, mask) -#define ip_addr_cmp(addr1, addr2) ip4_addr_cmp(addr1, addr2) -#define ip_addr_isany(ipaddr) ip4_addr_isany(ipaddr) -#define ip_addr_isany_val(ipaddr) ip4_addr_isany_val(ipaddr) -#define ip_addr_isloopback(ipaddr) ip4_addr_isloopback(ipaddr) -#define ip_addr_islinklocal(ipaddr) ip4_addr_islinklocal(ipaddr) -#define ip_addr_isbroadcast(addr, netif) ip4_addr_isbroadcast(addr, netif) -#define ip_addr_ismulticast(ipaddr) ip4_addr_ismulticast(ipaddr) -#define ip_addr_debug_print(debug, ipaddr) ip4_addr_debug_print(debug, ipaddr) -#define ip_addr_debug_print_val(debug, ipaddr) ip4_addr_debug_print_val(debug, ipaddr) -#define ipaddr_ntoa(ipaddr) ip4addr_ntoa(ipaddr) -#define ipaddr_ntoa_r(ipaddr, buf, buflen) ip4addr_ntoa_r(ipaddr, buf, buflen) -#define ipaddr_aton(cp, addr) ip4addr_aton(cp, addr) - -#define IPADDR_STRLEN_MAX IP4ADDR_STRLEN_MAX - -#define IP46_ADDR_ANY(type) (IP4_ADDR_ANY) - -#else /* LWIP_IPV4 */ - -typedef ip6_addr_t ip_addr_t; -#define IPADDR6_INIT(a, b, c, d) { { a, b, c, d } IPADDR6_ZONE_INIT } -#define IPADDR6_INIT_HOST(a, b, c, d) { { PP_HTONL(a), PP_HTONL(b), PP_HTONL(c), PP_HTONL(d) } IPADDR6_ZONE_INIT } -#define IP_IS_V4_VAL(ipaddr) 0 -#define IP_IS_V6_VAL(ipaddr) 1 -#define IP_IS_V4(ipaddr) 0 -#define IP_IS_V6(ipaddr) 1 -#define IP_IS_ANY_TYPE_VAL(ipaddr) 0 -#define IP_SET_TYPE_VAL(ipaddr, iptype) -#define IP_SET_TYPE(ipaddr, iptype) -#define IP_GET_TYPE(ipaddr) IPADDR_TYPE_V6 -#define IP_ADDR_RAW_SIZE(ipaddr) sizeof(ip6_addr_t) -#define ip_2_ip6(ipaddr) (ipaddr) -#define IP_ADDR6(ipaddr,i0,i1,i2,i3) IP6_ADDR(ipaddr,i0,i1,i2,i3) -#define IP_ADDR6_HOST(ipaddr,i0,i1,i2,i3) IP_ADDR6(ipaddr,PP_HTONL(i0),PP_HTONL(i1),PP_HTONL(i2),PP_HTONL(i3)) - -#define ip_addr_copy(dest, src) ip6_addr_copy(dest, src) -#define ip_addr_copy_from_ip6(dest, src) ip6_addr_copy(dest, src) -#define ip_addr_copy_from_ip6_packed(dest, src) ip6_addr_copy_from_packed(dest, src) -#define ip_addr_set(dest, src) ip6_addr_set(dest, src) -#define ip_addr_set_ipaddr(dest, src) ip6_addr_set(dest, src) -#define ip_addr_set_zero(ipaddr) ip6_addr_set_zero(ipaddr) -#define ip_addr_set_zero_ip6(ipaddr) ip6_addr_set_zero(ipaddr) -#define ip_addr_set_any(is_ipv6, ipaddr) ip6_addr_set_any(ipaddr) -#define ip_addr_set_loopback(is_ipv6, ipaddr) ip6_addr_set_loopback(ipaddr) -#define ip_addr_set_hton(dest, src) ip6_addr_set_hton(dest, src) -#define ip_addr_get_network(target, host, mask) ip6_addr_set_zero(target) -#define ip_addr_netcmp(addr1, addr2, mask) 0 -#define ip_addr_cmp(addr1, addr2) ip6_addr_cmp(addr1, addr2) -#define ip_addr_cmp_zoneless(addr1, addr2) ip6_addr_cmp_zoneless(addr1, addr2) -#define ip_addr_isany(ipaddr) ip6_addr_isany(ipaddr) -#define ip_addr_isany_val(ipaddr) ip6_addr_isany_val(ipaddr) -#define ip_addr_isloopback(ipaddr) ip6_addr_isloopback(ipaddr) -#define ip_addr_islinklocal(ipaddr) ip6_addr_islinklocal(ipaddr) -#define ip_addr_isbroadcast(addr, netif) 0 -#define ip_addr_ismulticast(ipaddr) ip6_addr_ismulticast(ipaddr) -#define ip_addr_debug_print(debug, ipaddr) ip6_addr_debug_print(debug, ipaddr) -#define ip_addr_debug_print_val(debug, ipaddr) ip6_addr_debug_print_val(debug, ipaddr) -#define ipaddr_ntoa(ipaddr) ip6addr_ntoa(ipaddr) -#define ipaddr_ntoa_r(ipaddr, buf, buflen) ip6addr_ntoa_r(ipaddr, buf, buflen) -#define ipaddr_aton(cp, addr) ip6addr_aton(cp, addr) - -#define IPADDR_STRLEN_MAX IP6ADDR_STRLEN_MAX - -#define IP46_ADDR_ANY(type) (IP6_ADDR_ANY) - -#endif /* LWIP_IPV4 */ -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - -#if LWIP_IPV4 - -extern const ip_addr_t ip_addr_any; -extern const ip_addr_t ip_addr_broadcast; - -/** - * @ingroup ip4addr - * Can be used as a fixed/const ip_addr_t - * for the IP wildcard. - * Defined to @ref IP4_ADDR_ANY when IPv4 is enabled. - * Defined to @ref IP6_ADDR_ANY in IPv6 only systems. - * Use this if you can handle IPv4 _AND_ IPv6 addresses. - * Use @ref IP4_ADDR_ANY or @ref IP6_ADDR_ANY when the IP - * type matters. - */ -#define IP_ADDR_ANY IP4_ADDR_ANY -/** - * @ingroup ip4addr - * Can be used as a fixed/const ip_addr_t - * for the IPv4 wildcard and the broadcast address - */ -#define IP4_ADDR_ANY (&ip_addr_any) -/** - * @ingroup ip4addr - * Can be used as a fixed/const ip4_addr_t - * for the wildcard and the broadcast address - */ -#define IP4_ADDR_ANY4 (ip_2_ip4(&ip_addr_any)) - -/** @ingroup ip4addr */ -#define IP_ADDR_BROADCAST (&ip_addr_broadcast) -/** @ingroup ip4addr */ -#define IP4_ADDR_BROADCAST (ip_2_ip4(&ip_addr_broadcast)) - -#endif /* LWIP_IPV4*/ - -#if LWIP_IPV6 - -extern const ip_addr_t ip6_addr_any; - -/** - * @ingroup ip6addr - * IP6_ADDR_ANY can be used as a fixed ip_addr_t - * for the IPv6 wildcard address - */ -#define IP6_ADDR_ANY (&ip6_addr_any) -/** - * @ingroup ip6addr - * IP6_ADDR_ANY6 can be used as a fixed ip6_addr_t - * for the IPv6 wildcard address - */ -#define IP6_ADDR_ANY6 (ip_2_ip6(&ip6_addr_any)) - -#if !LWIP_IPV4 -/** IPv6-only configurations */ -#define IP_ADDR_ANY IP6_ADDR_ANY -#endif /* !LWIP_IPV4 */ - -#endif - -#if LWIP_IPV4 && LWIP_IPV6 -/** @ingroup ipaddr */ -#define IP_ANY_TYPE (&ip_addr_any_type) -#else -#define IP_ANY_TYPE IP_ADDR_ANY -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_IP_ADDR_H */ +/** + * @file + * IP address API (common IPv4 and IPv6) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_IP_ADDR_H +#define LWIP_HDR_IP_ADDR_H + +#include "lwip/opt.h" +#include "lwip/def.h" + +#include "lwip/ip4_addr.h" +#include "lwip/ip6_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** @ingroup ipaddr + * IP address types for use in ip_addr_t.type member. + * @see tcp_new_ip_type(), udp_new_ip_type(), raw_new_ip_type(). + */ +enum lwip_ip_addr_type { + /** IPv4 */ + IPADDR_TYPE_V4 = 0U, + /** IPv6 */ + IPADDR_TYPE_V6 = 6U, + /** IPv4+IPv6 ("dual-stack") */ + IPADDR_TYPE_ANY = 46U +}; + +#if LWIP_IPV4 && LWIP_IPV6 +/** + * @ingroup ipaddr + * A union struct for both IP version's addresses. + * ATTENTION: watch out for its size when adding IPv6 address scope! + */ +typedef struct ip_addr { + union { + ip6_addr_t ip6; + ip4_addr_t ip4; + } u_addr; + /** @ref lwip_ip_addr_type */ + u8_t type; +} ip_addr_t; + +extern const ip_addr_t ip_addr_any_type; + +/** @ingroup ip4addr */ +#define IPADDR4_INIT(u32val) { { { { u32val, 0ul, 0ul, 0ul } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_V4 } +/** @ingroup ip4addr */ +#define IPADDR4_INIT_BYTES(a,b,c,d) IPADDR4_INIT(PP_HTONL(LWIP_MAKEU32(a,b,c,d))) + +/** @ingroup ip6addr */ +#define IPADDR6_INIT(a, b, c, d) { { { { a, b, c, d } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_V6 } +/** @ingroup ip6addr */ +#define IPADDR6_INIT_HOST(a, b, c, d) { { { { PP_HTONL(a), PP_HTONL(b), PP_HTONL(c), PP_HTONL(d) } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_V6 } + +/** @ingroup ipaddr */ +#define IP_IS_ANY_TYPE_VAL(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_ANY) +/** @ingroup ipaddr */ +#define IPADDR_ANY_TYPE_INIT { { { { 0ul, 0ul, 0ul, 0ul } IPADDR6_ZONE_INIT } }, IPADDR_TYPE_ANY } + +/** @ingroup ip4addr */ +#define IP_IS_V4_VAL(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_V4) +/** @ingroup ip6addr */ +#define IP_IS_V6_VAL(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_V6) +/** @ingroup ip4addr */ +#define IP_IS_V4(ipaddr) (((ipaddr) == NULL) || IP_IS_V4_VAL(*(ipaddr))) +/** @ingroup ip6addr */ +#define IP_IS_V6(ipaddr) (((ipaddr) != NULL) && IP_IS_V6_VAL(*(ipaddr))) + +#define IP_SET_TYPE_VAL(ipaddr, iptype) do { (ipaddr).type = (iptype); }while(0) +#define IP_SET_TYPE(ipaddr, iptype) do { if((ipaddr) != NULL) { IP_SET_TYPE_VAL(*(ipaddr), iptype); }}while(0) +#define IP_GET_TYPE(ipaddr) ((ipaddr)->type) + +#define IP_ADDR_RAW_SIZE(ipaddr) (IP_GET_TYPE(&ipaddr) == IPADDR_TYPE_V4 ? sizeof(ip4_addr_t) : sizeof(ip6_addr_t)) + +#define IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ipaddr) (IP_GET_TYPE(&pcb->local_ip) == IP_GET_TYPE(ipaddr)) +#define IP_ADDR_PCB_VERSION_MATCH(pcb, ipaddr) (IP_IS_ANY_TYPE_VAL(pcb->local_ip) || IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ipaddr)) + +/** @ingroup ip6addr + * Convert generic ip address to specific protocol version + */ +#define ip_2_ip6(ipaddr) (&((ipaddr)->u_addr.ip6)) +/** @ingroup ip4addr + * Convert generic ip address to specific protocol version + */ +#define ip_2_ip4(ipaddr) (&((ipaddr)->u_addr.ip4)) + +/** @ingroup ip4addr */ +#define IP_ADDR4(ipaddr,a,b,c,d) do { IP4_ADDR(ip_2_ip4(ipaddr),a,b,c,d); \ + IP_SET_TYPE_VAL(*(ipaddr), IPADDR_TYPE_V4); } while(0) +/** @ingroup ip6addr */ +#define IP_ADDR6(ipaddr,i0,i1,i2,i3) do { IP6_ADDR(ip_2_ip6(ipaddr),i0,i1,i2,i3); \ + IP_SET_TYPE_VAL(*(ipaddr), IPADDR_TYPE_V6); } while(0) +/** @ingroup ip6addr */ +#define IP_ADDR6_HOST(ipaddr,i0,i1,i2,i3) IP_ADDR6(ipaddr,PP_HTONL(i0),PP_HTONL(i1),PP_HTONL(i2),PP_HTONL(i3)) + +#define ip_clear_no4(ipaddr) do { ip_2_ip6(ipaddr)->addr[1] = \ + ip_2_ip6(ipaddr)->addr[2] = \ + ip_2_ip6(ipaddr)->addr[3] = 0; \ + ip6_addr_clear_zone(ip_2_ip6(ipaddr)); }while(0) + +/** @ingroup ipaddr */ +#define ip_addr_copy(dest, src) do{ IP_SET_TYPE_VAL(dest, IP_GET_TYPE(&src)); if(IP_IS_V6_VAL(src)){ \ + ip6_addr_copy(*ip_2_ip6(&(dest)), *ip_2_ip6(&(src))); }else{ \ + ip4_addr_copy(*ip_2_ip4(&(dest)), *ip_2_ip4(&(src))); ip_clear_no4(&dest); }}while(0) +/** @ingroup ip6addr */ +#define ip_addr_copy_from_ip6(dest, src) do{ \ + ip6_addr_copy(*ip_2_ip6(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V6); }while(0) +/** @ingroup ip6addr */ +#define ip_addr_copy_from_ip6_packed(dest, src) do{ \ + ip6_addr_copy_from_packed(*ip_2_ip6(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V6); }while(0) +/** @ingroup ip4addr */ +#define ip_addr_copy_from_ip4(dest, src) do{ \ + ip4_addr_copy(*ip_2_ip4(&(dest)), src); IP_SET_TYPE_VAL(dest, IPADDR_TYPE_V4); ip_clear_no4(&dest); }while(0) +/** @ingroup ip4addr */ +#define ip_addr_set_ip4_u32(ipaddr, val) do{if(ipaddr){ip4_addr_set_u32(ip_2_ip4(ipaddr), val); \ + IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) +/** @ingroup ip4addr */ +#define ip_addr_set_ip4_u32_val(ipaddr, val) do{ ip4_addr_set_u32(ip_2_ip4(&(ipaddr)), val); \ + IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }while(0) +/** @ingroup ip4addr */ +#define ip_addr_get_ip4_u32(ipaddr) (((ipaddr) && IP_IS_V4(ipaddr)) ? \ + ip4_addr_get_u32(ip_2_ip4(ipaddr)) : 0) +/** @ingroup ipaddr */ +#define ip_addr_set(dest, src) do{ IP_SET_TYPE(dest, IP_GET_TYPE(src)); if(IP_IS_V6(src)){ \ + ip6_addr_set(ip_2_ip6(dest), ip_2_ip6(src)); }else{ \ + ip4_addr_set(ip_2_ip4(dest), ip_2_ip4(src)); ip_clear_no4(dest); }}while(0) +/** @ingroup ipaddr */ +#define ip_addr_set_ipaddr(dest, src) ip_addr_set(dest, src) +/** @ingroup ipaddr */ +#define ip_addr_set_zero(ipaddr) do{ \ + ip6_addr_set_zero(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, 0); }while(0) +/** @ingroup ip5addr */ +#define ip_addr_set_zero_ip4(ipaddr) do{ \ + ip6_addr_set_zero(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); }while(0) +/** @ingroup ip6addr */ +#define ip_addr_set_zero_ip6(ipaddr) do{ \ + ip6_addr_set_zero(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }while(0) +/** @ingroup ipaddr */ +#define ip_addr_set_any(is_ipv6, ipaddr) do{if(is_ipv6){ \ + ip6_addr_set_any(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }else{ \ + ip4_addr_set_any(ip_2_ip4(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) +/** @ingroup ipaddr */ +#define ip_addr_set_any_val(is_ipv6, ipaddr) do{if(is_ipv6){ \ + ip6_addr_set_any(ip_2_ip6(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V6); }else{ \ + ip4_addr_set_any(ip_2_ip4(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }}while(0) +/** @ingroup ipaddr */ +#define ip_addr_set_loopback(is_ipv6, ipaddr) do{if(is_ipv6){ \ + ip6_addr_set_loopback(ip_2_ip6(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V6); }else{ \ + ip4_addr_set_loopback(ip_2_ip4(ipaddr)); IP_SET_TYPE(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) +/** @ingroup ipaddr */ +#define ip_addr_set_loopback_val(is_ipv6, ipaddr) do{if(is_ipv6){ \ + ip6_addr_set_loopback(ip_2_ip6(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V6); }else{ \ + ip4_addr_set_loopback(ip_2_ip4(&(ipaddr))); IP_SET_TYPE_VAL(ipaddr, IPADDR_TYPE_V4); ip_clear_no4(&ipaddr); }}while(0) +/** @ingroup ipaddr */ +#define ip_addr_set_hton(dest, src) do{if(IP_IS_V6(src)){ \ + ip6_addr_set_hton(ip_2_ip6(dest), ip_2_ip6(src)); IP_SET_TYPE(dest, IPADDR_TYPE_V6); }else{ \ + ip4_addr_set_hton(ip_2_ip4(dest), ip_2_ip4(src)); IP_SET_TYPE(dest, IPADDR_TYPE_V4); ip_clear_no4(ipaddr); }}while(0) +/** @ingroup ipaddr */ +#define ip_addr_get_network(target, host, netmask) do{if(IP_IS_V6(host)){ \ + ip4_addr_set_zero(ip_2_ip4(target)); IP_SET_TYPE(target, IPADDR_TYPE_V6); } else { \ + ip4_addr_get_network(ip_2_ip4(target), ip_2_ip4(host), ip_2_ip4(netmask)); IP_SET_TYPE(target, IPADDR_TYPE_V4); }}while(0) +/** @ingroup ipaddr */ +#define ip_addr_netcmp(addr1, addr2, mask) ((IP_IS_V6(addr1) && IP_IS_V6(addr2)) ? \ + 0 : \ + ip4_addr_netcmp(ip_2_ip4(addr1), ip_2_ip4(addr2), mask)) +/** @ingroup ipaddr */ +#define ip_addr_cmp(addr1, addr2) ((IP_GET_TYPE(addr1) != IP_GET_TYPE(addr2)) ? 0 : (IP_IS_V6_VAL(*(addr1)) ? \ + ip6_addr_cmp(ip_2_ip6(addr1), ip_2_ip6(addr2)) : \ + ip4_addr_cmp(ip_2_ip4(addr1), ip_2_ip4(addr2)))) +/** @ingroup ipaddr */ +#define ip_addr_cmp_zoneless(addr1, addr2) ((IP_GET_TYPE(addr1) != IP_GET_TYPE(addr2)) ? 0 : (IP_IS_V6_VAL(*(addr1)) ? \ + ip6_addr_cmp_zoneless(ip_2_ip6(addr1), ip_2_ip6(addr2)) : \ + ip4_addr_cmp(ip_2_ip4(addr1), ip_2_ip4(addr2)))) +/** @ingroup ipaddr */ +#define ip_addr_isany(ipaddr) (((ipaddr) == NULL) ? 1 : ((IP_IS_V6(ipaddr)) ? \ + ip6_addr_isany(ip_2_ip6(ipaddr)) : \ + ip4_addr_isany(ip_2_ip4(ipaddr)))) +/** @ingroup ipaddr */ +#define ip_addr_isany_val(ipaddr) ((IP_IS_V6_VAL(ipaddr)) ? \ + ip6_addr_isany_val(*ip_2_ip6(&(ipaddr))) : \ + ip4_addr_isany_val(*ip_2_ip4(&(ipaddr)))) +/** @ingroup ipaddr */ +#define ip_addr_isbroadcast(ipaddr, netif) ((IP_IS_V6(ipaddr)) ? \ + 0 : \ + ip4_addr_isbroadcast(ip_2_ip4(ipaddr), netif)) +/** @ingroup ipaddr */ +#define ip_addr_ismulticast(ipaddr) ((IP_IS_V6(ipaddr)) ? \ + ip6_addr_ismulticast(ip_2_ip6(ipaddr)) : \ + ip4_addr_ismulticast(ip_2_ip4(ipaddr))) +/** @ingroup ipaddr */ +#define ip_addr_isloopback(ipaddr) ((IP_IS_V6(ipaddr)) ? \ + ip6_addr_isloopback(ip_2_ip6(ipaddr)) : \ + ip4_addr_isloopback(ip_2_ip4(ipaddr))) +/** @ingroup ipaddr */ +#define ip_addr_islinklocal(ipaddr) ((IP_IS_V6(ipaddr)) ? \ + ip6_addr_islinklocal(ip_2_ip6(ipaddr)) : \ + ip4_addr_islinklocal(ip_2_ip4(ipaddr))) +#define ip_addr_debug_print(debug, ipaddr) do { if(IP_IS_V6(ipaddr)) { \ + ip6_addr_debug_print(debug, ip_2_ip6(ipaddr)); } else { \ + ip4_addr_debug_print(debug, ip_2_ip4(ipaddr)); }}while(0) +#define ip_addr_debug_print_val(debug, ipaddr) do { if(IP_IS_V6_VAL(ipaddr)) { \ + ip6_addr_debug_print_val(debug, *ip_2_ip6(&(ipaddr))); } else { \ + ip4_addr_debug_print_val(debug, *ip_2_ip4(&(ipaddr))); }}while(0) +char *ipaddr_ntoa(const ip_addr_t *addr); +char *ipaddr_ntoa_r(const ip_addr_t *addr, char *buf, int buflen); +int ipaddr_aton(const char *cp, ip_addr_t *addr); + +/** @ingroup ipaddr */ +#define IPADDR_STRLEN_MAX IP6ADDR_STRLEN_MAX + +/** @ingroup ipaddr */ +#define ip4_2_ipv4_mapped_ipv6(ip6addr, ip4addr) do { \ + (ip6addr)->addr[3] = (ip4addr)->addr; \ + (ip6addr)->addr[2] = PP_HTONL(0x0000FFFFUL); \ + (ip6addr)->addr[1] = 0; \ + (ip6addr)->addr[0] = 0; \ + ip6_addr_clear_zone(ip6addr); } while(0); + +/** @ingroup ipaddr */ +#define unmap_ipv4_mapped_ipv6(ip4addr, ip6addr) \ + (ip4addr)->addr = (ip6addr)->addr[3]; + +#define IP46_ADDR_ANY(type) (((type) == IPADDR_TYPE_V6)? IP6_ADDR_ANY : IP4_ADDR_ANY) + +#else /* LWIP_IPV4 && LWIP_IPV6 */ + +#define IP_ADDR_PCB_VERSION_MATCH(addr, pcb) 1 +#define IP_ADDR_PCB_VERSION_MATCH_EXACT(pcb, ipaddr) 1 + +#define ip_addr_set_any_val(is_ipv6, ipaddr) ip_addr_set_any(is_ipv6, &(ipaddr)) +#define ip_addr_set_loopback_val(is_ipv6, ipaddr) ip_addr_set_loopback(is_ipv6, &(ipaddr)) + +#if LWIP_IPV4 + +typedef ip4_addr_t ip_addr_t; +#define IPADDR4_INIT(u32val) { u32val } +#define IPADDR4_INIT_BYTES(a,b,c,d) IPADDR4_INIT(PP_HTONL(LWIP_MAKEU32(a,b,c,d))) +#define IP_IS_V4_VAL(ipaddr) 1 +#define IP_IS_V6_VAL(ipaddr) 0 +#define IP_IS_V4(ipaddr) 1 +#define IP_IS_V6(ipaddr) 0 +#define IP_IS_ANY_TYPE_VAL(ipaddr) 0 +#define IP_SET_TYPE_VAL(ipaddr, iptype) +#define IP_SET_TYPE(ipaddr, iptype) +#define IP_GET_TYPE(ipaddr) IPADDR_TYPE_V4 +#define IP_ADDR_RAW_SIZE(ipaddr) sizeof(ip4_addr_t) +#define ip_2_ip4(ipaddr) (ipaddr) +#define IP_ADDR4(ipaddr,a,b,c,d) IP4_ADDR(ipaddr,a,b,c,d) + +#define ip_addr_copy(dest, src) ip4_addr_copy(dest, src) +#define ip_addr_copy_from_ip4(dest, src) ip4_addr_copy(dest, src) +#define ip_addr_set_ip4_u32(ipaddr, val) ip4_addr_set_u32(ip_2_ip4(ipaddr), val) +#define ip_addr_set_ip4_u32_val(ipaddr, val) ip_addr_set_ip4_u32(&(ipaddr), val) +#define ip_addr_get_ip4_u32(ipaddr) ip4_addr_get_u32(ip_2_ip4(ipaddr)) +#define ip_addr_set(dest, src) ip4_addr_set(dest, src) +#define ip_addr_set_ipaddr(dest, src) ip4_addr_set(dest, src) +#define ip_addr_set_zero(ipaddr) ip4_addr_set_zero(ipaddr) +#define ip_addr_set_zero_ip4(ipaddr) ip4_addr_set_zero(ipaddr) +#define ip_addr_set_any(is_ipv6, ipaddr) ip4_addr_set_any(ipaddr) +#define ip_addr_set_loopback(is_ipv6, ipaddr) ip4_addr_set_loopback(ipaddr) +#define ip_addr_set_hton(dest, src) ip4_addr_set_hton(dest, src) +#define ip_addr_get_network(target, host, mask) ip4_addr_get_network(target, host, mask) +#define ip_addr_netcmp(addr1, addr2, mask) ip4_addr_netcmp(addr1, addr2, mask) +#define ip_addr_cmp(addr1, addr2) ip4_addr_cmp(addr1, addr2) +#define ip_addr_isany(ipaddr) ip4_addr_isany(ipaddr) +#define ip_addr_isany_val(ipaddr) ip4_addr_isany_val(ipaddr) +#define ip_addr_isloopback(ipaddr) ip4_addr_isloopback(ipaddr) +#define ip_addr_islinklocal(ipaddr) ip4_addr_islinklocal(ipaddr) +#define ip_addr_isbroadcast(addr, netif) ip4_addr_isbroadcast(addr, netif) +#define ip_addr_ismulticast(ipaddr) ip4_addr_ismulticast(ipaddr) +#define ip_addr_debug_print(debug, ipaddr) ip4_addr_debug_print(debug, ipaddr) +#define ip_addr_debug_print_val(debug, ipaddr) ip4_addr_debug_print_val(debug, ipaddr) +#define ipaddr_ntoa(ipaddr) ip4addr_ntoa(ipaddr) +#define ipaddr_ntoa_r(ipaddr, buf, buflen) ip4addr_ntoa_r(ipaddr, buf, buflen) +#define ipaddr_aton(cp, addr) ip4addr_aton(cp, addr) + +#define IPADDR_STRLEN_MAX IP4ADDR_STRLEN_MAX + +#define IP46_ADDR_ANY(type) (IP4_ADDR_ANY) + +#else /* LWIP_IPV4 */ + +typedef ip6_addr_t ip_addr_t; +#define IPADDR6_INIT(a, b, c, d) { { a, b, c, d } IPADDR6_ZONE_INIT } +#define IPADDR6_INIT_HOST(a, b, c, d) { { PP_HTONL(a), PP_HTONL(b), PP_HTONL(c), PP_HTONL(d) } IPADDR6_ZONE_INIT } +#define IP_IS_V4_VAL(ipaddr) 0 +#define IP_IS_V6_VAL(ipaddr) 1 +#define IP_IS_V4(ipaddr) 0 +#define IP_IS_V6(ipaddr) 1 +#define IP_IS_ANY_TYPE_VAL(ipaddr) 0 +#define IP_SET_TYPE_VAL(ipaddr, iptype) +#define IP_SET_TYPE(ipaddr, iptype) +#define IP_GET_TYPE(ipaddr) IPADDR_TYPE_V6 +#define IP_ADDR_RAW_SIZE(ipaddr) sizeof(ip6_addr_t) +#define ip_2_ip6(ipaddr) (ipaddr) +#define IP_ADDR6(ipaddr,i0,i1,i2,i3) IP6_ADDR(ipaddr,i0,i1,i2,i3) +#define IP_ADDR6_HOST(ipaddr,i0,i1,i2,i3) IP_ADDR6(ipaddr,PP_HTONL(i0),PP_HTONL(i1),PP_HTONL(i2),PP_HTONL(i3)) + +#define ip_addr_copy(dest, src) ip6_addr_copy(dest, src) +#define ip_addr_copy_from_ip6(dest, src) ip6_addr_copy(dest, src) +#define ip_addr_copy_from_ip6_packed(dest, src) ip6_addr_copy_from_packed(dest, src) +#define ip_addr_set(dest, src) ip6_addr_set(dest, src) +#define ip_addr_set_ipaddr(dest, src) ip6_addr_set(dest, src) +#define ip_addr_set_zero(ipaddr) ip6_addr_set_zero(ipaddr) +#define ip_addr_set_zero_ip6(ipaddr) ip6_addr_set_zero(ipaddr) +#define ip_addr_set_any(is_ipv6, ipaddr) ip6_addr_set_any(ipaddr) +#define ip_addr_set_loopback(is_ipv6, ipaddr) ip6_addr_set_loopback(ipaddr) +#define ip_addr_set_hton(dest, src) ip6_addr_set_hton(dest, src) +#define ip_addr_get_network(target, host, mask) ip6_addr_set_zero(target) +#define ip_addr_netcmp(addr1, addr2, mask) 0 +#define ip_addr_cmp(addr1, addr2) ip6_addr_cmp(addr1, addr2) +#define ip_addr_cmp_zoneless(addr1, addr2) ip6_addr_cmp_zoneless(addr1, addr2) +#define ip_addr_isany(ipaddr) ip6_addr_isany(ipaddr) +#define ip_addr_isany_val(ipaddr) ip6_addr_isany_val(ipaddr) +#define ip_addr_isloopback(ipaddr) ip6_addr_isloopback(ipaddr) +#define ip_addr_islinklocal(ipaddr) ip6_addr_islinklocal(ipaddr) +#define ip_addr_isbroadcast(addr, netif) 0 +#define ip_addr_ismulticast(ipaddr) ip6_addr_ismulticast(ipaddr) +#define ip_addr_debug_print(debug, ipaddr) ip6_addr_debug_print(debug, ipaddr) +#define ip_addr_debug_print_val(debug, ipaddr) ip6_addr_debug_print_val(debug, ipaddr) +#define ipaddr_ntoa(ipaddr) ip6addr_ntoa(ipaddr) +#define ipaddr_ntoa_r(ipaddr, buf, buflen) ip6addr_ntoa_r(ipaddr, buf, buflen) +#define ipaddr_aton(cp, addr) ip6addr_aton(cp, addr) + +#define IPADDR_STRLEN_MAX IP6ADDR_STRLEN_MAX + +#define IP46_ADDR_ANY(type) (IP6_ADDR_ANY) + +#endif /* LWIP_IPV4 */ +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + +#if LWIP_IPV4 + +extern const ip_addr_t ip_addr_any; +extern const ip_addr_t ip_addr_broadcast; + +/** + * @ingroup ip4addr + * Can be used as a fixed/const ip_addr_t + * for the IP wildcard. + * Defined to @ref IP4_ADDR_ANY when IPv4 is enabled. + * Defined to @ref IP6_ADDR_ANY in IPv6 only systems. + * Use this if you can handle IPv4 _AND_ IPv6 addresses. + * Use @ref IP4_ADDR_ANY or @ref IP6_ADDR_ANY when the IP + * type matters. + */ +#define IP_ADDR_ANY IP4_ADDR_ANY +/** + * @ingroup ip4addr + * Can be used as a fixed/const ip_addr_t + * for the IPv4 wildcard and the broadcast address + */ +#define IP4_ADDR_ANY (&ip_addr_any) +/** + * @ingroup ip4addr + * Can be used as a fixed/const ip4_addr_t + * for the wildcard and the broadcast address + */ +#define IP4_ADDR_ANY4 (ip_2_ip4(&ip_addr_any)) + +/** @ingroup ip4addr */ +#define IP_ADDR_BROADCAST (&ip_addr_broadcast) +/** @ingroup ip4addr */ +#define IP4_ADDR_BROADCAST (ip_2_ip4(&ip_addr_broadcast)) + +#endif /* LWIP_IPV4*/ + +#if LWIP_IPV6 + +extern const ip_addr_t ip6_addr_any; + +/** + * @ingroup ip6addr + * IP6_ADDR_ANY can be used as a fixed ip_addr_t + * for the IPv6 wildcard address + */ +#define IP6_ADDR_ANY (&ip6_addr_any) +/** + * @ingroup ip6addr + * IP6_ADDR_ANY6 can be used as a fixed ip6_addr_t + * for the IPv6 wildcard address + */ +#define IP6_ADDR_ANY6 (ip_2_ip6(&ip6_addr_any)) + +#if !LWIP_IPV4 +/** IPv6-only configurations */ +#define IP_ADDR_ANY IP6_ADDR_ANY +#endif /* !LWIP_IPV4 */ + +#endif + +#if LWIP_IPV4 && LWIP_IPV6 +/** @ingroup ipaddr */ +#define IP_ANY_TYPE (&ip_addr_any_type) +#else +#define IP_ANY_TYPE IP_ADDR_ANY +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_IP_ADDR_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mem.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mem.h index 424de91b..ff208d25 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mem.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mem.h @@ -1,82 +1,82 @@ -/** - * @file - * Heap API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_MEM_H -#define LWIP_HDR_MEM_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if MEM_LIBC_MALLOC - -#include "lwip/arch.h" - -typedef size_t mem_size_t; -#define MEM_SIZE_F SZT_F - -#elif MEM_USE_POOLS - -typedef u16_t mem_size_t; -#define MEM_SIZE_F U16_F - -#else - -/* MEM_SIZE would have to be aligned, but using 64000 here instead of - * 65535 leaves some room for alignment... - */ -#if MEM_SIZE > 64000L -typedef u32_t mem_size_t; -#define MEM_SIZE_F U32_F -#else -typedef u16_t mem_size_t; -#define MEM_SIZE_F U16_F -#endif /* MEM_SIZE > 64000 */ -#endif - -void mem_init(void); -void *mem_trim(void *mem, mem_size_t size); -void *mem_malloc(mem_size_t size); -void *mem_calloc(mem_size_t count, mem_size_t size); -void mem_free(void *mem); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_MEM_H */ +/** + * @file + * Heap API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_MEM_H +#define LWIP_HDR_MEM_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if MEM_LIBC_MALLOC + +#include "lwip/arch.h" + +typedef size_t mem_size_t; +#define MEM_SIZE_F SZT_F + +#elif MEM_USE_POOLS + +typedef u16_t mem_size_t; +#define MEM_SIZE_F U16_F + +#else + +/* MEM_SIZE would have to be aligned, but using 64000 here instead of + * 65535 leaves some room for alignment... + */ +#if MEM_SIZE > 64000L +typedef u32_t mem_size_t; +#define MEM_SIZE_F U32_F +#else +typedef u16_t mem_size_t; +#define MEM_SIZE_F U16_F +#endif /* MEM_SIZE > 64000 */ +#endif + +void mem_init(void); +void *mem_trim(void *mem, mem_size_t size); +void *mem_malloc(mem_size_t size); +void *mem_calloc(mem_size_t count, mem_size_t size); +void mem_free(void *mem); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_MEM_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/memp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/memp.h index 74ac8189..1630b26c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/memp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/memp.h @@ -1,155 +1,155 @@ -/** - * @file - * Memory pool API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#ifndef LWIP_HDR_MEMP_H -#define LWIP_HDR_MEMP_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* run once with empty definition to handle all custom includes in lwippools.h */ -#define LWIP_MEMPOOL(name,num,size,desc) -#include "lwip/priv/memp_std.h" - -/** Create the list of all memory pools managed by memp. MEMP_MAX represents a NULL pool at the end */ -typedef enum { -#define LWIP_MEMPOOL(name,num,size,desc) MEMP_##name, -#include "lwip/priv/memp_std.h" - MEMP_MAX -} memp_t; - -#include "lwip/priv/memp_priv.h" -#include "lwip/stats.h" - -extern const struct memp_desc* const memp_pools[MEMP_MAX]; - -/** - * @ingroup mempool - * Declare prototype for private memory pool if it is used in multiple files - */ -#define LWIP_MEMPOOL_PROTOTYPE(name) extern const struct memp_desc memp_ ## name - -#if MEMP_MEM_MALLOC - -#define LWIP_MEMPOOL_DECLARE(name,num,size,desc) \ - LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_ ## name) \ - const struct memp_desc memp_ ## name = { \ - DECLARE_LWIP_MEMPOOL_DESC(desc) \ - LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_ ## name) \ - LWIP_MEM_ALIGN_SIZE(size) \ - }; - -#else /* MEMP_MEM_MALLOC */ - -/** - * @ingroup mempool - * Declare a private memory pool - * Private mempools example: - * .h: only when pool is used in multiple .c files: LWIP_MEMPOOL_PROTOTYPE(my_private_pool); - * .c: - * - in global variables section: LWIP_MEMPOOL_DECLARE(my_private_pool, 10, sizeof(foo), "Some description") - * - call ONCE before using pool (e.g. in some init() function): LWIP_MEMPOOL_INIT(my_private_pool); - * - allocate: void* my_new_mem = LWIP_MEMPOOL_ALLOC(my_private_pool); - * - free: LWIP_MEMPOOL_FREE(my_private_pool, my_new_mem); - * - * To relocate a pool, declare it as extern in cc.h. Example for GCC: - * extern u8_t \_\_attribute\_\_((section(".onchip_mem"))) memp_memory_my_private_pool_base[]; - */ -#define LWIP_MEMPOOL_DECLARE(name,num,size,desc) \ - LWIP_DECLARE_MEMORY_ALIGNED(memp_memory_ ## name ## _base, ((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))); \ - \ - LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_ ## name) \ - \ - static struct memp *memp_tab_ ## name; \ - \ - const struct memp_desc memp_ ## name = { \ - DECLARE_LWIP_MEMPOOL_DESC(desc) \ - LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_ ## name) \ - LWIP_MEM_ALIGN_SIZE(size), \ - (num), \ - memp_memory_ ## name ## _base, \ - &memp_tab_ ## name \ - }; - -#endif /* MEMP_MEM_MALLOC */ - -/** - * @ingroup mempool - * Initialize a private memory pool - */ -#define LWIP_MEMPOOL_INIT(name) memp_init_pool(&memp_ ## name) -/** - * @ingroup mempool - * Allocate from a private memory pool - */ -#define LWIP_MEMPOOL_ALLOC(name) memp_malloc_pool(&memp_ ## name) -/** - * @ingroup mempool - * Free element from a private memory pool - */ -#define LWIP_MEMPOOL_FREE(name, x) memp_free_pool(&memp_ ## name, (x)) - -#if MEM_USE_POOLS -/** This structure is used to save the pool one element came from. - * This has to be defined here as it is required for pool size calculation. */ -struct memp_malloc_helper -{ - memp_t poolnr; -#if MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) - u16_t size; -#endif /* MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) */ -}; -#endif /* MEM_USE_POOLS */ - -void memp_init(void); - -#if MEMP_OVERFLOW_CHECK -void *memp_malloc_fn(memp_t type, const char* file, const int line); -#define memp_malloc(t) memp_malloc_fn((t), __FILE__, __LINE__) -#else -void *memp_malloc(memp_t type); -#endif -void memp_free(memp_t type, void *mem); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_MEMP_H */ +/** + * @file + * Memory pool API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#ifndef LWIP_HDR_MEMP_H +#define LWIP_HDR_MEMP_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* run once with empty definition to handle all custom includes in lwippools.h */ +#define LWIP_MEMPOOL(name,num,size,desc) +#include "lwip/priv/memp_std.h" + +/** Create the list of all memory pools managed by memp. MEMP_MAX represents a NULL pool at the end */ +typedef enum { +#define LWIP_MEMPOOL(name,num,size,desc) MEMP_##name, +#include "lwip/priv/memp_std.h" + MEMP_MAX +} memp_t; + +#include "lwip/priv/memp_priv.h" +#include "lwip/stats.h" + +extern const struct memp_desc* const memp_pools[MEMP_MAX]; + +/** + * @ingroup mempool + * Declare prototype for private memory pool if it is used in multiple files + */ +#define LWIP_MEMPOOL_PROTOTYPE(name) extern const struct memp_desc memp_ ## name + +#if MEMP_MEM_MALLOC + +#define LWIP_MEMPOOL_DECLARE(name,num,size,desc) \ + LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_ ## name) \ + const struct memp_desc memp_ ## name = { \ + DECLARE_LWIP_MEMPOOL_DESC(desc) \ + LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_ ## name) \ + LWIP_MEM_ALIGN_SIZE(size) \ + }; + +#else /* MEMP_MEM_MALLOC */ + +/** + * @ingroup mempool + * Declare a private memory pool + * Private mempools example: + * .h: only when pool is used in multiple .c files: LWIP_MEMPOOL_PROTOTYPE(my_private_pool); + * .c: + * - in global variables section: LWIP_MEMPOOL_DECLARE(my_private_pool, 10, sizeof(foo), "Some description") + * - call ONCE before using pool (e.g. in some init() function): LWIP_MEMPOOL_INIT(my_private_pool); + * - allocate: void* my_new_mem = LWIP_MEMPOOL_ALLOC(my_private_pool); + * - free: LWIP_MEMPOOL_FREE(my_private_pool, my_new_mem); + * + * To relocate a pool, declare it as extern in cc.h. Example for GCC: + * extern u8_t \_\_attribute\_\_((section(".onchip_mem"))) memp_memory_my_private_pool_base[]; + */ +#define LWIP_MEMPOOL_DECLARE(name,num,size,desc) \ + LWIP_DECLARE_MEMORY_ALIGNED(memp_memory_ ## name ## _base, ((num) * (MEMP_SIZE + MEMP_ALIGN_SIZE(size)))); \ + \ + LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(memp_stats_ ## name) \ + \ + static struct memp *memp_tab_ ## name; \ + \ + const struct memp_desc memp_ ## name = { \ + DECLARE_LWIP_MEMPOOL_DESC(desc) \ + LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(memp_stats_ ## name) \ + LWIP_MEM_ALIGN_SIZE(size), \ + (num), \ + memp_memory_ ## name ## _base, \ + &memp_tab_ ## name \ + }; + +#endif /* MEMP_MEM_MALLOC */ + +/** + * @ingroup mempool + * Initialize a private memory pool + */ +#define LWIP_MEMPOOL_INIT(name) memp_init_pool(&memp_ ## name) +/** + * @ingroup mempool + * Allocate from a private memory pool + */ +#define LWIP_MEMPOOL_ALLOC(name) memp_malloc_pool(&memp_ ## name) +/** + * @ingroup mempool + * Free element from a private memory pool + */ +#define LWIP_MEMPOOL_FREE(name, x) memp_free_pool(&memp_ ## name, (x)) + +#if MEM_USE_POOLS +/** This structure is used to save the pool one element came from. + * This has to be defined here as it is required for pool size calculation. */ +struct memp_malloc_helper +{ + memp_t poolnr; +#if MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) + u16_t size; +#endif /* MEMP_OVERFLOW_CHECK || (LWIP_STATS && MEM_STATS) */ +}; +#endif /* MEM_USE_POOLS */ + +void memp_init(void); + +#if MEMP_OVERFLOW_CHECK +void *memp_malloc_fn(memp_t type, const char* file, const int line); +#define memp_malloc(t) memp_malloc_fn((t), __FILE__, __LINE__) +#else +void *memp_malloc(memp_t type); +#endif +void memp_free(memp_t type, void *mem); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_MEMP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mld6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mld6.h index f8c99d9d..7fa0797f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mld6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/mld6.h @@ -1,99 +1,99 @@ -/** - * @file - * - * Multicast listener discovery for IPv6. Aims to be compliant with RFC 2710. - * No support for MLDv2. - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#ifndef LWIP_HDR_MLD6_H -#define LWIP_HDR_MLD6_H - -#include "lwip/opt.h" - -#if LWIP_IPV6_MLD && LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** MLD group */ -struct mld_group { - /** next link */ - struct mld_group *next; - /** multicast address */ - ip6_addr_t group_address; - /** signifies we were the last person to report */ - u8_t last_reporter_flag; - /** current state of the group */ - u8_t group_state; - /** timer for reporting */ - u16_t timer; - /** counter of simultaneous uses */ - u8_t use; -}; - -#define MLD6_TMR_INTERVAL 100 /* Milliseconds */ - -err_t mld6_stop(struct netif *netif); -void mld6_report_groups(struct netif *netif); -void mld6_tmr(void); -struct mld_group *mld6_lookfor_group(struct netif *ifp, const ip6_addr_t *addr); -void mld6_input(struct pbuf *p, struct netif *inp); -err_t mld6_joingroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr); -err_t mld6_joingroup_netif(struct netif *netif, const ip6_addr_t *groupaddr); -err_t mld6_leavegroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr); -err_t mld6_leavegroup_netif(struct netif *netif, const ip6_addr_t *groupaddr); - -/** @ingroup mld6 - * Get list head of MLD6 groups for netif. - * Note: The allnodes group IP is NOT in the list, since it must always - * be received for correct IPv6 operation. - * @see @ref netif_set_mld_mac_filter() - */ -#define netif_mld6_data(netif) ((struct mld_group *)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6_MLD && LWIP_IPV6 */ - -#endif /* LWIP_HDR_MLD6_H */ +/** + * @file + * + * Multicast listener discovery for IPv6. Aims to be compliant with RFC 2710. + * No support for MLDv2. + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#ifndef LWIP_HDR_MLD6_H +#define LWIP_HDR_MLD6_H + +#include "lwip/opt.h" + +#if LWIP_IPV6_MLD && LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** MLD group */ +struct mld_group { + /** next link */ + struct mld_group *next; + /** multicast address */ + ip6_addr_t group_address; + /** signifies we were the last person to report */ + u8_t last_reporter_flag; + /** current state of the group */ + u8_t group_state; + /** timer for reporting */ + u16_t timer; + /** counter of simultaneous uses */ + u8_t use; +}; + +#define MLD6_TMR_INTERVAL 100 /* Milliseconds */ + +err_t mld6_stop(struct netif *netif); +void mld6_report_groups(struct netif *netif); +void mld6_tmr(void); +struct mld_group *mld6_lookfor_group(struct netif *ifp, const ip6_addr_t *addr); +void mld6_input(struct pbuf *p, struct netif *inp); +err_t mld6_joingroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr); +err_t mld6_joingroup_netif(struct netif *netif, const ip6_addr_t *groupaddr); +err_t mld6_leavegroup(const ip6_addr_t *srcaddr, const ip6_addr_t *groupaddr); +err_t mld6_leavegroup_netif(struct netif *netif, const ip6_addr_t *groupaddr); + +/** @ingroup mld6 + * Get list head of MLD6 groups for netif. + * Note: The allnodes group IP is NOT in the list, since it must always + * be received for correct IPv6 operation. + * @see @ref netif_set_mld_mac_filter() + */ +#define netif_mld6_data(netif) ((struct mld_group *)netif_get_client_data(netif, LWIP_NETIF_CLIENT_DATA_INDEX_MLD6)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6_MLD && LWIP_IPV6 */ + +#endif /* LWIP_HDR_MLD6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/nd6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/nd6.h index 89137d5d..c30e624f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/nd6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/nd6.h @@ -1,90 +1,90 @@ -/** - * @file - * - * Neighbor discovery and stateless address autoconfiguration for IPv6. - * Aims to be compliant with RFC 4861 (Neighbor discovery) and RFC 4862 - * (Address autoconfiguration). - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#ifndef LWIP_HDR_ND6_H -#define LWIP_HDR_ND6_H - -#include "lwip/opt.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/ip6_addr.h" -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** 1 second period */ -#define ND6_TMR_INTERVAL 1000 - -/** Router solicitations are sent in 4 second intervals (see RFC 4861, ch. 6.3.7) */ -#ifndef ND6_RTR_SOLICITATION_INTERVAL -#define ND6_RTR_SOLICITATION_INTERVAL 4000 -#endif - -struct pbuf; -struct netif; - -void nd6_tmr(void); -void nd6_input(struct pbuf *p, struct netif *inp); -void nd6_clear_destination_cache(void); -struct netif *nd6_find_route(const ip6_addr_t *ip6addr); -err_t nd6_get_next_hop_addr_or_queue(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr, const u8_t **hwaddrp); -u16_t nd6_get_destination_mtu(const ip6_addr_t *ip6addr, struct netif *netif); -#if LWIP_ND6_TCP_REACHABILITY_HINTS -void nd6_reachability_hint(const ip6_addr_t *ip6addr); -#endif /* LWIP_ND6_TCP_REACHABILITY_HINTS */ -void nd6_cleanup_netif(struct netif *netif); -#if LWIP_IPV6_MLD -void nd6_adjust_mld_membership(struct netif *netif, s8_t addr_idx, u8_t new_state); -#endif /* LWIP_IPV6_MLD */ -void nd6_restart_netif(struct netif *netif); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 */ - -#endif /* LWIP_HDR_ND6_H */ +/** + * @file + * + * Neighbor discovery and stateless address autoconfiguration for IPv6. + * Aims to be compliant with RFC 4861 (Neighbor discovery) and RFC 4862 + * (Address autoconfiguration). + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#ifndef LWIP_HDR_ND6_H +#define LWIP_HDR_ND6_H + +#include "lwip/opt.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/ip6_addr.h" +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** 1 second period */ +#define ND6_TMR_INTERVAL 1000 + +/** Router solicitations are sent in 4 second intervals (see RFC 4861, ch. 6.3.7) */ +#ifndef ND6_RTR_SOLICITATION_INTERVAL +#define ND6_RTR_SOLICITATION_INTERVAL 4000 +#endif + +struct pbuf; +struct netif; + +void nd6_tmr(void); +void nd6_input(struct pbuf *p, struct netif *inp); +void nd6_clear_destination_cache(void); +struct netif *nd6_find_route(const ip6_addr_t *ip6addr); +err_t nd6_get_next_hop_addr_or_queue(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr, const u8_t **hwaddrp); +u16_t nd6_get_destination_mtu(const ip6_addr_t *ip6addr, struct netif *netif); +#if LWIP_ND6_TCP_REACHABILITY_HINTS +void nd6_reachability_hint(const ip6_addr_t *ip6addr); +#endif /* LWIP_ND6_TCP_REACHABILITY_HINTS */ +void nd6_cleanup_netif(struct netif *netif); +#if LWIP_IPV6_MLD +void nd6_adjust_mld_membership(struct netif *netif, s8_t addr_idx, u8_t new_state); +#endif /* LWIP_IPV6_MLD */ +void nd6_restart_netif(struct netif *netif); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 */ + +#endif /* LWIP_HDR_ND6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netbuf.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netbuf.h index e92c934e..42a911bc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netbuf.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netbuf.h @@ -1,116 +1,116 @@ -/** - * @file - * netbuf API (for netconn API) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_NETBUF_H -#define LWIP_HDR_NETBUF_H - -#include "lwip/opt.h" - -#if LWIP_NETCONN || LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ -/* Note: Netconn API is always available when sockets are enabled - - * sockets are implemented on top of them */ - -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" -#include "lwip/ip6_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** This netbuf has dest-addr/port set */ -#define NETBUF_FLAG_DESTADDR 0x01 -/** This netbuf includes a checksum */ -#define NETBUF_FLAG_CHKSUM 0x02 - -/** "Network buffer" - contains data and addressing info */ -struct netbuf { - struct pbuf *p, *ptr; - ip_addr_t addr; - u16_t port; -#if LWIP_NETBUF_RECVINFO || LWIP_CHECKSUM_ON_COPY - u8_t flags; - u16_t toport_chksum; -#if LWIP_NETBUF_RECVINFO - ip_addr_t toaddr; -#endif /* LWIP_NETBUF_RECVINFO */ -#endif /* LWIP_NETBUF_RECVINFO || LWIP_CHECKSUM_ON_COPY */ -}; - -/* Network buffer functions: */ -struct netbuf * netbuf_new (void); -void netbuf_delete (struct netbuf *buf); -void * netbuf_alloc (struct netbuf *buf, u16_t size); -void netbuf_free (struct netbuf *buf); -err_t netbuf_ref (struct netbuf *buf, - const void *dataptr, u16_t size); -void netbuf_chain (struct netbuf *head, struct netbuf *tail); - -err_t netbuf_data (struct netbuf *buf, - void **dataptr, u16_t *len); -s8_t netbuf_next (struct netbuf *buf); -void netbuf_first (struct netbuf *buf); - - -#define netbuf_copy_partial(buf, dataptr, len, offset) \ - pbuf_copy_partial((buf)->p, (dataptr), (len), (offset)) -#define netbuf_copy(buf,dataptr,len) netbuf_copy_partial(buf, dataptr, len, 0) -#define netbuf_take(buf, dataptr, len) pbuf_take((buf)->p, dataptr, len) -#define netbuf_len(buf) ((buf)->p->tot_len) -#define netbuf_fromaddr(buf) (&((buf)->addr)) -#define netbuf_set_fromaddr(buf, fromaddr) ip_addr_set(&((buf)->addr), fromaddr) -#define netbuf_fromport(buf) ((buf)->port) -#if LWIP_NETBUF_RECVINFO -#define netbuf_destaddr(buf) (&((buf)->toaddr)) -#define netbuf_set_destaddr(buf, destaddr) ip_addr_set(&((buf)->toaddr), destaddr) -#if LWIP_CHECKSUM_ON_COPY -#define netbuf_destport(buf) (((buf)->flags & NETBUF_FLAG_DESTADDR) ? (buf)->toport_chksum : 0) -#else /* LWIP_CHECKSUM_ON_COPY */ -#define netbuf_destport(buf) ((buf)->toport_chksum) -#endif /* LWIP_CHECKSUM_ON_COPY */ -#endif /* LWIP_NETBUF_RECVINFO */ -#if LWIP_CHECKSUM_ON_COPY -#define netbuf_set_chksum(buf, chksum) do { (buf)->flags = NETBUF_FLAG_CHKSUM; \ - (buf)->toport_chksum = chksum; } while(0) -#endif /* LWIP_CHECKSUM_ON_COPY */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_NETCONN || LWIP_SOCKET */ - -#endif /* LWIP_HDR_NETBUF_H */ +/** + * @file + * netbuf API (for netconn API) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_NETBUF_H +#define LWIP_HDR_NETBUF_H + +#include "lwip/opt.h" + +#if LWIP_NETCONN || LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ +/* Note: Netconn API is always available when sockets are enabled - + * sockets are implemented on top of them */ + +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" +#include "lwip/ip6_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** This netbuf has dest-addr/port set */ +#define NETBUF_FLAG_DESTADDR 0x01 +/** This netbuf includes a checksum */ +#define NETBUF_FLAG_CHKSUM 0x02 + +/** "Network buffer" - contains data and addressing info */ +struct netbuf { + struct pbuf *p, *ptr; + ip_addr_t addr; + u16_t port; +#if LWIP_NETBUF_RECVINFO || LWIP_CHECKSUM_ON_COPY + u8_t flags; + u16_t toport_chksum; +#if LWIP_NETBUF_RECVINFO + ip_addr_t toaddr; +#endif /* LWIP_NETBUF_RECVINFO */ +#endif /* LWIP_NETBUF_RECVINFO || LWIP_CHECKSUM_ON_COPY */ +}; + +/* Network buffer functions: */ +struct netbuf * netbuf_new (void); +void netbuf_delete (struct netbuf *buf); +void * netbuf_alloc (struct netbuf *buf, u16_t size); +void netbuf_free (struct netbuf *buf); +err_t netbuf_ref (struct netbuf *buf, + const void *dataptr, u16_t size); +void netbuf_chain (struct netbuf *head, struct netbuf *tail); + +err_t netbuf_data (struct netbuf *buf, + void **dataptr, u16_t *len); +s8_t netbuf_next (struct netbuf *buf); +void netbuf_first (struct netbuf *buf); + + +#define netbuf_copy_partial(buf, dataptr, len, offset) \ + pbuf_copy_partial((buf)->p, (dataptr), (len), (offset)) +#define netbuf_copy(buf,dataptr,len) netbuf_copy_partial(buf, dataptr, len, 0) +#define netbuf_take(buf, dataptr, len) pbuf_take((buf)->p, dataptr, len) +#define netbuf_len(buf) ((buf)->p->tot_len) +#define netbuf_fromaddr(buf) (&((buf)->addr)) +#define netbuf_set_fromaddr(buf, fromaddr) ip_addr_set(&((buf)->addr), fromaddr) +#define netbuf_fromport(buf) ((buf)->port) +#if LWIP_NETBUF_RECVINFO +#define netbuf_destaddr(buf) (&((buf)->toaddr)) +#define netbuf_set_destaddr(buf, destaddr) ip_addr_set(&((buf)->toaddr), destaddr) +#if LWIP_CHECKSUM_ON_COPY +#define netbuf_destport(buf) (((buf)->flags & NETBUF_FLAG_DESTADDR) ? (buf)->toport_chksum : 0) +#else /* LWIP_CHECKSUM_ON_COPY */ +#define netbuf_destport(buf) ((buf)->toport_chksum) +#endif /* LWIP_CHECKSUM_ON_COPY */ +#endif /* LWIP_NETBUF_RECVINFO */ +#if LWIP_CHECKSUM_ON_COPY +#define netbuf_set_chksum(buf, chksum) do { (buf)->flags = NETBUF_FLAG_CHKSUM; \ + (buf)->toport_chksum = chksum; } while(0) +#endif /* LWIP_CHECKSUM_ON_COPY */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_NETCONN || LWIP_SOCKET */ + +#endif /* LWIP_HDR_NETBUF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netdb.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netdb.h index 6aae914b..d3d15dfa 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netdb.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netdb.h @@ -1,150 +1,150 @@ -/** - * @file - * NETDB API (sockets) - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_NETDB_H -#define LWIP_HDR_NETDB_H - -#include "lwip/opt.h" - -#if LWIP_DNS && LWIP_SOCKET - -#include "lwip/arch.h" -#include "lwip/inet.h" -#include "lwip/sockets.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* some rarely used options */ -#ifndef LWIP_DNS_API_DECLARE_H_ERRNO -#define LWIP_DNS_API_DECLARE_H_ERRNO 1 -#endif - -#ifndef LWIP_DNS_API_DEFINE_ERRORS -#define LWIP_DNS_API_DEFINE_ERRORS 1 -#endif - -#ifndef LWIP_DNS_API_DEFINE_FLAGS -#define LWIP_DNS_API_DEFINE_FLAGS 1 -#endif - -#ifndef LWIP_DNS_API_DECLARE_STRUCTS -#define LWIP_DNS_API_DECLARE_STRUCTS 1 -#endif - -#if LWIP_DNS_API_DEFINE_ERRORS -/** Errors used by the DNS API functions, h_errno can be one of them */ -#define EAI_NONAME 200 -#define EAI_SERVICE 201 -#define EAI_FAIL 202 -#define EAI_MEMORY 203 -#define EAI_FAMILY 204 - -#define HOST_NOT_FOUND 210 -#define NO_DATA 211 -#define NO_RECOVERY 212 -#define TRY_AGAIN 213 -#endif /* LWIP_DNS_API_DEFINE_ERRORS */ - -#if LWIP_DNS_API_DEFINE_FLAGS -/* input flags for struct addrinfo */ -#define AI_PASSIVE 0x01 -#define AI_CANONNAME 0x02 -#define AI_NUMERICHOST 0x04 -#define AI_NUMERICSERV 0x08 -#define AI_V4MAPPED 0x10 -#define AI_ALL 0x20 -#define AI_ADDRCONFIG 0x40 -#endif /* LWIP_DNS_API_DEFINE_FLAGS */ - -#if LWIP_DNS_API_DECLARE_STRUCTS -struct hostent { - char *h_name; /* Official name of the host. */ - char **h_aliases; /* A pointer to an array of pointers to alternative host names, - terminated by a null pointer. */ - int h_addrtype; /* Address type. */ - int h_length; /* The length, in bytes, of the address. */ - char **h_addr_list; /* A pointer to an array of pointers to network addresses (in - network byte order) for the host, terminated by a null pointer. */ -#define h_addr h_addr_list[0] /* for backward compatibility */ -}; - -struct addrinfo { - int ai_flags; /* Input flags. */ - int ai_family; /* Address family of socket. */ - int ai_socktype; /* Socket type. */ - int ai_protocol; /* Protocol of socket. */ - socklen_t ai_addrlen; /* Length of socket address. */ - struct sockaddr *ai_addr; /* Socket address of socket. */ - char *ai_canonname; /* Canonical name of service location. */ - struct addrinfo *ai_next; /* Pointer to next in list. */ -}; -#endif /* LWIP_DNS_API_DECLARE_STRUCTS */ - -#define NETDB_ELEM_SIZE (sizeof(struct addrinfo) + sizeof(struct sockaddr_storage) + DNS_MAX_NAME_LENGTH + 1) - -#if LWIP_DNS_API_DECLARE_H_ERRNO -/* application accessible error code set by the DNS API functions */ -extern int h_errno; -#endif /* LWIP_DNS_API_DECLARE_H_ERRNO*/ - -struct hostent *lwip_gethostbyname(const char *name); -int lwip_gethostbyname_r(const char *name, struct hostent *ret, char *buf, - size_t buflen, struct hostent **result, int *h_errnop); -void lwip_freeaddrinfo(struct addrinfo *ai); -int lwip_getaddrinfo(const char *nodename, - const char *servname, - const struct addrinfo *hints, - struct addrinfo **res); - -#if LWIP_COMPAT_SOCKETS -/** @ingroup netdbapi */ -#define gethostbyname(name) lwip_gethostbyname(name) -/** @ingroup netdbapi */ -#define gethostbyname_r(name, ret, buf, buflen, result, h_errnop) \ - lwip_gethostbyname_r(name, ret, buf, buflen, result, h_errnop) -/** @ingroup netdbapi */ -#define freeaddrinfo(addrinfo) lwip_freeaddrinfo(addrinfo) -/** @ingroup netdbapi */ -#define getaddrinfo(nodname, servname, hints, res) \ - lwip_getaddrinfo(nodname, servname, hints, res) -#endif /* LWIP_COMPAT_SOCKETS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_DNS && LWIP_SOCKET */ - -#endif /* LWIP_HDR_NETDB_H */ +/** + * @file + * NETDB API (sockets) + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_NETDB_H +#define LWIP_HDR_NETDB_H + +#include "lwip/opt.h" + +#if LWIP_DNS && LWIP_SOCKET + +#include "lwip/arch.h" +#include "lwip/inet.h" +#include "lwip/sockets.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* some rarely used options */ +#ifndef LWIP_DNS_API_DECLARE_H_ERRNO +#define LWIP_DNS_API_DECLARE_H_ERRNO 1 +#endif + +#ifndef LWIP_DNS_API_DEFINE_ERRORS +#define LWIP_DNS_API_DEFINE_ERRORS 1 +#endif + +#ifndef LWIP_DNS_API_DEFINE_FLAGS +#define LWIP_DNS_API_DEFINE_FLAGS 1 +#endif + +#ifndef LWIP_DNS_API_DECLARE_STRUCTS +#define LWIP_DNS_API_DECLARE_STRUCTS 1 +#endif + +#if LWIP_DNS_API_DEFINE_ERRORS +/** Errors used by the DNS API functions, h_errno can be one of them */ +#define EAI_NONAME 200 +#define EAI_SERVICE 201 +#define EAI_FAIL 202 +#define EAI_MEMORY 203 +#define EAI_FAMILY 204 + +#define HOST_NOT_FOUND 210 +#define NO_DATA 211 +#define NO_RECOVERY 212 +#define TRY_AGAIN 213 +#endif /* LWIP_DNS_API_DEFINE_ERRORS */ + +#if LWIP_DNS_API_DEFINE_FLAGS +/* input flags for struct addrinfo */ +#define AI_PASSIVE 0x01 +#define AI_CANONNAME 0x02 +#define AI_NUMERICHOST 0x04 +#define AI_NUMERICSERV 0x08 +#define AI_V4MAPPED 0x10 +#define AI_ALL 0x20 +#define AI_ADDRCONFIG 0x40 +#endif /* LWIP_DNS_API_DEFINE_FLAGS */ + +#if LWIP_DNS_API_DECLARE_STRUCTS +struct hostent { + char *h_name; /* Official name of the host. */ + char **h_aliases; /* A pointer to an array of pointers to alternative host names, + terminated by a null pointer. */ + int h_addrtype; /* Address type. */ + int h_length; /* The length, in bytes, of the address. */ + char **h_addr_list; /* A pointer to an array of pointers to network addresses (in + network byte order) for the host, terminated by a null pointer. */ +#define h_addr h_addr_list[0] /* for backward compatibility */ +}; + +struct addrinfo { + int ai_flags; /* Input flags. */ + int ai_family; /* Address family of socket. */ + int ai_socktype; /* Socket type. */ + int ai_protocol; /* Protocol of socket. */ + socklen_t ai_addrlen; /* Length of socket address. */ + struct sockaddr *ai_addr; /* Socket address of socket. */ + char *ai_canonname; /* Canonical name of service location. */ + struct addrinfo *ai_next; /* Pointer to next in list. */ +}; +#endif /* LWIP_DNS_API_DECLARE_STRUCTS */ + +#define NETDB_ELEM_SIZE (sizeof(struct addrinfo) + sizeof(struct sockaddr_storage) + DNS_MAX_NAME_LENGTH + 1) + +#if LWIP_DNS_API_DECLARE_H_ERRNO +/* application accessible error code set by the DNS API functions */ +extern int h_errno; +#endif /* LWIP_DNS_API_DECLARE_H_ERRNO*/ + +struct hostent *lwip_gethostbyname(const char *name); +int lwip_gethostbyname_r(const char *name, struct hostent *ret, char *buf, + size_t buflen, struct hostent **result, int *h_errnop); +void lwip_freeaddrinfo(struct addrinfo *ai); +int lwip_getaddrinfo(const char *nodename, + const char *servname, + const struct addrinfo *hints, + struct addrinfo **res); + +#if LWIP_COMPAT_SOCKETS +/** @ingroup netdbapi */ +#define gethostbyname(name) lwip_gethostbyname(name) +/** @ingroup netdbapi */ +#define gethostbyname_r(name, ret, buf, buflen, result, h_errnop) \ + lwip_gethostbyname_r(name, ret, buf, buflen, result, h_errnop) +/** @ingroup netdbapi */ +#define freeaddrinfo(addrinfo) lwip_freeaddrinfo(addrinfo) +/** @ingroup netdbapi */ +#define getaddrinfo(nodname, servname, hints, res) \ + lwip_getaddrinfo(nodname, servname, hints, res) +#endif /* LWIP_COMPAT_SOCKETS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_DNS && LWIP_SOCKET */ + +#endif /* LWIP_HDR_NETDB_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netif.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netif.h index d3ec064a..911196ab 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netif.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netif.h @@ -1,669 +1,669 @@ -/** - * @file - * netif API (to be used from TCPIP thread) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_NETIF_H -#define LWIP_HDR_NETIF_H - -#include "lwip/opt.h" - -#define ENABLE_LOOPBACK (LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF) - -#include "lwip/err.h" - -#include "lwip/ip_addr.h" - -#include "lwip/def.h" -#include "lwip/pbuf.h" -#include "lwip/stats.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* Throughout this file, IP addresses are expected to be in - * the same byte order as in IP_PCB. */ - -/** Must be the maximum of all used hardware address lengths - across all types of interfaces in use. - This does not have to be changed, normally. */ -#ifndef NETIF_MAX_HWADDR_LEN -#define NETIF_MAX_HWADDR_LEN 6U -#endif - -/** The size of a fully constructed netif name which the - * netif can be identified by in APIs. Composed of - * 2 chars, 3 (max) digits, and 1 \0 - */ -#define NETIF_NAMESIZE 6 - -/** - * @defgroup netif_flags Flags - * @ingroup netif - * @{ - */ - -/** Whether the network interface is 'up'. This is - * a software flag used to control whether this network - * interface is enabled and processes traffic. - * It must be set by the startup code before this netif can be used - * (also for dhcp/autoip). - */ -#define NETIF_FLAG_UP 0x01U -/** If set, the netif has broadcast capability. - * Set by the netif driver in its init function. */ -#define NETIF_FLAG_BROADCAST 0x02U -/** If set, the interface has an active link - * (set by the network interface driver). - * Either set by the netif driver in its init function (if the link - * is up at that time) or at a later point once the link comes up - * (if link detection is supported by the hardware). */ -#define NETIF_FLAG_LINK_UP 0x04U -/** If set, the netif is an ethernet device using ARP. - * Set by the netif driver in its init function. - * Used to check input packet types and use of DHCP. */ -#define NETIF_FLAG_ETHARP 0x08U -/** If set, the netif is an ethernet device. It might not use - * ARP or TCP/IP if it is used for PPPoE only. - */ -#define NETIF_FLAG_ETHERNET 0x10U -/** If set, the netif has IGMP capability. - * Set by the netif driver in its init function. */ -#define NETIF_FLAG_IGMP 0x20U -/** If set, the netif has MLD6 capability. - * Set by the netif driver in its init function. */ -#define NETIF_FLAG_MLD6 0x40U - -/** - * @} - */ - -enum lwip_internal_netif_client_data_index -{ -#if LWIP_IPV4 -#if LWIP_DHCP - LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, -#endif -#if LWIP_AUTOIP - LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, -#endif -#if LWIP_IGMP - LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, -#endif -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 -#if LWIP_IPV6_DHCP6 - LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, -#endif -#if LWIP_IPV6_MLD - LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, -#endif -#endif /* LWIP_IPV6 */ - LWIP_NETIF_CLIENT_DATA_INDEX_MAX -}; - -#if LWIP_CHECKSUM_CTRL_PER_NETIF -#define NETIF_CHECKSUM_GEN_IP 0x0001 -#define NETIF_CHECKSUM_GEN_UDP 0x0002 -#define NETIF_CHECKSUM_GEN_TCP 0x0004 -#define NETIF_CHECKSUM_GEN_ICMP 0x0008 -#define NETIF_CHECKSUM_GEN_ICMP6 0x0010 -#define NETIF_CHECKSUM_CHECK_IP 0x0100 -#define NETIF_CHECKSUM_CHECK_UDP 0x0200 -#define NETIF_CHECKSUM_CHECK_TCP 0x0400 -#define NETIF_CHECKSUM_CHECK_ICMP 0x0800 -#define NETIF_CHECKSUM_CHECK_ICMP6 0x1000 -#define NETIF_CHECKSUM_ENABLE_ALL 0xFFFF -#define NETIF_CHECKSUM_DISABLE_ALL 0x0000 -#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ - -struct netif; - -/** MAC Filter Actions, these are passed to a netif's igmp_mac_filter or - * mld_mac_filter callback function. */ -enum netif_mac_filter_action { - /** Delete a filter entry */ - NETIF_DEL_MAC_FILTER = 0, - /** Add a filter entry */ - NETIF_ADD_MAC_FILTER = 1 -}; - -/** Function prototype for netif init functions. Set up flags and output/linkoutput - * callback functions in this function. - * - * @param netif The netif to initialize - */ -typedef err_t (*netif_init_fn)(struct netif *netif); -/** Function prototype for netif->input functions. This function is saved as 'input' - * callback function in the netif struct. Call it when a packet has been received. - * - * @param p The received packet, copied into a pbuf - * @param inp The netif which received the packet - * @return ERR_OK if the packet was handled - * != ERR_OK is the packet was NOT handled, in this case, the caller has - * to free the pbuf - */ -typedef err_t (*netif_input_fn)(struct pbuf *p, struct netif *inp); - -#if LWIP_IPV4 -/** Function prototype for netif->output functions. Called by lwIP when a packet - * shall be sent. For ethernet netif, set this to 'etharp_output' and set - * 'linkoutput'. - * - * @param netif The netif which shall send a packet - * @param p The packet to send (p->payload points to IP header) - * @param ipaddr The IP address to which the packet shall be sent - */ -typedef err_t (*netif_output_fn)(struct netif *netif, struct pbuf *p, - const ip4_addr_t *ipaddr); -#endif /* LWIP_IPV4*/ - -#if LWIP_IPV6 -/** Function prototype for netif->output_ip6 functions. Called by lwIP when a packet - * shall be sent. For ethernet netif, set this to 'ethip6_output' and set - * 'linkoutput'. - * - * @param netif The netif which shall send a packet - * @param p The packet to send (p->payload points to IP header) - * @param ipaddr The IPv6 address to which the packet shall be sent - */ -typedef err_t (*netif_output_ip6_fn)(struct netif *netif, struct pbuf *p, - const ip6_addr_t *ipaddr); -#endif /* LWIP_IPV6 */ - -/** Function prototype for netif->linkoutput functions. Only used for ethernet - * netifs. This function is called by ARP when a packet shall be sent. - * - * @param netif The netif which shall send a packet - * @param p The packet to send (raw ethernet packet) - */ -typedef err_t (*netif_linkoutput_fn)(struct netif *netif, struct pbuf *p); -/** Function prototype for netif status- or link-callback functions. */ -typedef void (*netif_status_callback_fn)(struct netif *netif); -#if LWIP_IPV4 && LWIP_IGMP -/** Function prototype for netif igmp_mac_filter functions */ -typedef err_t (*netif_igmp_mac_filter_fn)(struct netif *netif, - const ip4_addr_t *group, enum netif_mac_filter_action action); -#endif /* LWIP_IPV4 && LWIP_IGMP */ -#if LWIP_IPV6 && LWIP_IPV6_MLD -/** Function prototype for netif mld_mac_filter functions */ -typedef err_t (*netif_mld_mac_filter_fn)(struct netif *netif, - const ip6_addr_t *group, enum netif_mac_filter_action action); -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ - -#if LWIP_DHCP || LWIP_AUTOIP || LWIP_IGMP || LWIP_IPV6_MLD || LWIP_IPV6_DHCP6 || (LWIP_NUM_NETIF_CLIENT_DATA > 0) -#if LWIP_NUM_NETIF_CLIENT_DATA > 0 -u8_t netif_alloc_client_data_id(void); -#endif -/** @ingroup netif_cd - * Set client data. Obtain ID from netif_alloc_client_data_id(). - */ -#define netif_set_client_data(netif, id, data) netif_get_client_data(netif, id) = (data) -/** @ingroup netif_cd - * Get client data. Obtain ID from netif_alloc_client_data_id(). - */ -#define netif_get_client_data(netif, id) (netif)->client_data[(id)] -#endif - -#if (LWIP_IPV4 && LWIP_ARP && (ARP_TABLE_SIZE > 0x7f)) || (LWIP_IPV6 && (LWIP_ND6_NUM_DESTINATIONS > 0x7f)) -typedef u16_t netif_addr_idx_t; -#define NETIF_ADDR_IDX_MAX 0x7FFF -#else -typedef u8_t netif_addr_idx_t; -#define NETIF_ADDR_IDX_MAX 0x7F -#endif - -#if LWIP_NETIF_HWADDRHINT -#define LWIP_NETIF_USE_HINTS 1 -struct netif_hint { - netif_addr_idx_t addr_hint; -}; -#else /* LWIP_NETIF_HWADDRHINT */ -#define LWIP_NETIF_USE_HINTS 0 -#endif /* LWIP_NETIF_HWADDRHINT */ - -/** Generic data structure used for all lwIP network interfaces. - * The following fields should be filled in by the initialization - * function for the device driver: hwaddr_len, hwaddr[], mtu, flags */ -struct netif { -#if !LWIP_SINGLE_NETIF - /** pointer to next in linked list */ - struct netif *next; -#endif - -#if LWIP_IPV4 - /** IP address configuration in network byte order */ - ip_addr_t ip_addr; - ip_addr_t netmask; - ip_addr_t gw; -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 - /** Array of IPv6 addresses for this netif. */ - ip_addr_t ip6_addr[LWIP_IPV6_NUM_ADDRESSES]; - /** The state of each IPv6 address (Tentative, Preferred, etc). - * @see ip6_addr.h */ - u8_t ip6_addr_state[LWIP_IPV6_NUM_ADDRESSES]; -#if LWIP_IPV6_ADDRESS_LIFETIMES - /** Remaining valid and preferred lifetime of each IPv6 address, in seconds. - * For valid lifetimes, the special value of IP6_ADDR_LIFE_STATIC (0) - * indicates the address is static and has no lifetimes. */ - u32_t ip6_addr_valid_life[LWIP_IPV6_NUM_ADDRESSES]; - u32_t ip6_addr_pref_life[LWIP_IPV6_NUM_ADDRESSES]; -#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ -#endif /* LWIP_IPV6 */ - /** This function is called by the network device driver - * to pass a packet up the TCP/IP stack. */ - netif_input_fn input; -#if LWIP_IPV4 - /** This function is called by the IP module when it wants - * to send a packet on the interface. This function typically - * first resolves the hardware address, then sends the packet. - * For ethernet physical layer, this is usually etharp_output() */ - netif_output_fn output; -#endif /* LWIP_IPV4 */ - /** This function is called by ethernet_output() when it wants - * to send a packet on the interface. This function outputs - * the pbuf as-is on the link medium. */ - netif_linkoutput_fn linkoutput; -#if LWIP_IPV6 - /** This function is called by the IPv6 module when it wants - * to send a packet on the interface. This function typically - * first resolves the hardware address, then sends the packet. - * For ethernet physical layer, this is usually ethip6_output() */ - netif_output_ip6_fn output_ip6; -#endif /* LWIP_IPV6 */ -#if LWIP_NETIF_STATUS_CALLBACK - /** This function is called when the netif state is set to up or down - */ - netif_status_callback_fn status_callback; -#endif /* LWIP_NETIF_STATUS_CALLBACK */ -#if LWIP_NETIF_LINK_CALLBACK - /** This function is called when the netif link is set to up or down - */ - netif_status_callback_fn link_callback; -#endif /* LWIP_NETIF_LINK_CALLBACK */ -#if LWIP_NETIF_REMOVE_CALLBACK - /** This function is called when the netif has been removed */ - netif_status_callback_fn remove_callback; -#endif /* LWIP_NETIF_REMOVE_CALLBACK */ - /** This field can be set by the device driver and could point - * to state information for the device. */ - void *state; -#ifdef netif_get_client_data - void* client_data[LWIP_NETIF_CLIENT_DATA_INDEX_MAX + LWIP_NUM_NETIF_CLIENT_DATA]; -#endif -#if LWIP_NETIF_HOSTNAME - /* the hostname for this netif, NULL is a valid value */ - const char* hostname; -#endif /* LWIP_NETIF_HOSTNAME */ -#if LWIP_CHECKSUM_CTRL_PER_NETIF - u16_t chksum_flags; -#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF*/ - /** maximum transfer unit (in bytes) */ - u16_t mtu; -#if LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES - /** maximum transfer unit (in bytes), updated by RA */ - u16_t mtu6; -#endif /* LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES */ - /** link level hardware address of this interface */ - u8_t hwaddr[NETIF_MAX_HWADDR_LEN]; - /** number of bytes used in hwaddr */ - u8_t hwaddr_len; - /** flags (@see @ref netif_flags) */ - u8_t flags; - /** descriptive abbreviation */ - char name[2]; - /** number of this interface. Used for @ref if_api and @ref netifapi_netif, - * as well as for IPv6 zones */ - u8_t num; -#if LWIP_IPV6_AUTOCONFIG - /** is this netif enabled for IPv6 autoconfiguration */ - u8_t ip6_autoconfig_enabled; -#endif /* LWIP_IPV6_AUTOCONFIG */ -#if LWIP_IPV6_SEND_ROUTER_SOLICIT - /** Number of Router Solicitation messages that remain to be sent. */ - u8_t rs_count; -#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ -#if MIB2_STATS - /** link type (from "snmp_ifType" enum from snmp_mib2.h) */ - u8_t link_type; - /** (estimate) link speed */ - u32_t link_speed; - /** timestamp at last change made (up/down) */ - u32_t ts; - /** counters */ - struct stats_mib2_netif_ctrs mib2_counters; -#endif /* MIB2_STATS */ -#if LWIP_IPV4 && LWIP_IGMP - /** This function could be called to add or delete an entry in the multicast - filter table of the ethernet MAC.*/ - netif_igmp_mac_filter_fn igmp_mac_filter; -#endif /* LWIP_IPV4 && LWIP_IGMP */ -#if LWIP_IPV6 && LWIP_IPV6_MLD - /** This function could be called to add or delete an entry in the IPv6 multicast - filter table of the ethernet MAC. */ - netif_mld_mac_filter_fn mld_mac_filter; -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ -#if LWIP_NETIF_USE_HINTS - struct netif_hint *hints; -#endif /* LWIP_NETIF_USE_HINTS */ -#if ENABLE_LOOPBACK - /* List of packets to be queued for ourselves. */ - struct pbuf *loop_first; - struct pbuf *loop_last; -#if LWIP_LOOPBACK_MAX_PBUFS - u16_t loop_cnt_current; -#endif /* LWIP_LOOPBACK_MAX_PBUFS */ -#endif /* ENABLE_LOOPBACK */ -}; - -#if LWIP_CHECKSUM_CTRL_PER_NETIF -#define NETIF_SET_CHECKSUM_CTRL(netif, chksumflags) do { \ - (netif)->chksum_flags = chksumflags; } while(0) -#define IF__NETIF_CHECKSUM_ENABLED(netif, chksumflag) if (((netif) == NULL) || (((netif)->chksum_flags & (chksumflag)) != 0)) -#else /* LWIP_CHECKSUM_CTRL_PER_NETIF */ -#define NETIF_SET_CHECKSUM_CTRL(netif, chksumflags) -#define IF__NETIF_CHECKSUM_ENABLED(netif, chksumflag) -#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ - -#if LWIP_SINGLE_NETIF -#define NETIF_FOREACH(netif) if (((netif) = netif_default) != NULL) -#else /* LWIP_SINGLE_NETIF */ -/** The list of network interfaces. */ -extern struct netif *netif_list; -#define NETIF_FOREACH(netif) for ((netif) = netif_list; (netif) != NULL; (netif) = (netif)->next) -#endif /* LWIP_SINGLE_NETIF */ -/** The default network interface. */ -extern struct netif *netif_default; - -void netif_init(void); - -struct netif *netif_add_noaddr(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input); - -#if LWIP_IPV4 -struct netif *netif_add(struct netif *netif, - const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, - void *state, netif_init_fn init, netif_input_fn input); -void netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, - const ip4_addr_t *gw); -#else /* LWIP_IPV4 */ -struct netif *netif_add(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input); -#endif /* LWIP_IPV4 */ -void netif_remove(struct netif * netif); - -/* Returns a network interface given its name. The name is of the form - "et0", where the first two letters are the "name" field in the - netif structure, and the digit is in the num field in the same - structure. */ -struct netif *netif_find(const char *name); - -void netif_set_default(struct netif *netif); - -#if LWIP_IPV4 -void netif_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr); -void netif_set_netmask(struct netif *netif, const ip4_addr_t *netmask); -void netif_set_gw(struct netif *netif, const ip4_addr_t *gw); -/** @ingroup netif_ip4 */ -#define netif_ip4_addr(netif) ((const ip4_addr_t*)ip_2_ip4(&((netif)->ip_addr))) -/** @ingroup netif_ip4 */ -#define netif_ip4_netmask(netif) ((const ip4_addr_t*)ip_2_ip4(&((netif)->netmask))) -/** @ingroup netif_ip4 */ -#define netif_ip4_gw(netif) ((const ip4_addr_t*)ip_2_ip4(&((netif)->gw))) -/** @ingroup netif_ip4 */ -#define netif_ip_addr4(netif) ((const ip_addr_t*)&((netif)->ip_addr)) -/** @ingroup netif_ip4 */ -#define netif_ip_netmask4(netif) ((const ip_addr_t*)&((netif)->netmask)) -/** @ingroup netif_ip4 */ -#define netif_ip_gw4(netif) ((const ip_addr_t*)&((netif)->gw)) -#endif /* LWIP_IPV4 */ - -#define netif_set_flags(netif, set_flags) do { (netif)->flags = (u8_t)((netif)->flags | (set_flags)); } while(0) -#define netif_clear_flags(netif, clr_flags) do { (netif)->flags = (u8_t)((netif)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) -#define netif_is_flag_set(nefif, flag) (((netif)->flags & (flag)) != 0) - -void netif_set_up(struct netif *netif); -void netif_set_down(struct netif *netif); -/** @ingroup netif - * Ask if an interface is up - */ -#define netif_is_up(netif) (((netif)->flags & NETIF_FLAG_UP) ? (u8_t)1 : (u8_t)0) - -#if LWIP_NETIF_STATUS_CALLBACK -void netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback); -#endif /* LWIP_NETIF_STATUS_CALLBACK */ -#if LWIP_NETIF_REMOVE_CALLBACK -void netif_set_remove_callback(struct netif *netif, netif_status_callback_fn remove_callback); -#endif /* LWIP_NETIF_REMOVE_CALLBACK */ - -void netif_set_link_up(struct netif *netif); -void netif_set_link_down(struct netif *netif); -/** Ask if a link is up */ -#define netif_is_link_up(netif) (((netif)->flags & NETIF_FLAG_LINK_UP) ? (u8_t)1 : (u8_t)0) - -#if LWIP_NETIF_LINK_CALLBACK -void netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_callback); -#endif /* LWIP_NETIF_LINK_CALLBACK */ - -#if LWIP_NETIF_HOSTNAME -/** @ingroup netif */ -#define netif_set_hostname(netif, name) do { if((netif) != NULL) { (netif)->hostname = name; }}while(0) -/** @ingroup netif */ -#define netif_get_hostname(netif) (((netif) != NULL) ? ((netif)->hostname) : NULL) -#endif /* LWIP_NETIF_HOSTNAME */ - -#if LWIP_IGMP -/** @ingroup netif */ -#define netif_set_igmp_mac_filter(netif, function) do { if((netif) != NULL) { (netif)->igmp_mac_filter = function; }}while(0) -#define netif_get_igmp_mac_filter(netif) (((netif) != NULL) ? ((netif)->igmp_mac_filter) : NULL) -#endif /* LWIP_IGMP */ - -#if LWIP_IPV6 && LWIP_IPV6_MLD -/** @ingroup netif */ -#define netif_set_mld_mac_filter(netif, function) do { if((netif) != NULL) { (netif)->mld_mac_filter = function; }}while(0) -#define netif_get_mld_mac_filter(netif) (((netif) != NULL) ? ((netif)->mld_mac_filter) : NULL) -#define netif_mld_mac_filter(netif, addr, action) do { if((netif) && (netif)->mld_mac_filter) { (netif)->mld_mac_filter((netif), (addr), (action)); }}while(0) -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ - -#if ENABLE_LOOPBACK -err_t netif_loop_output(struct netif *netif, struct pbuf *p); -void netif_poll(struct netif *netif); -#if !LWIP_NETIF_LOOPBACK_MULTITHREADING -void netif_poll_all(void); -#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */ -#endif /* ENABLE_LOOPBACK */ - -err_t netif_input(struct pbuf *p, struct netif *inp); - -#if LWIP_IPV6 -/** @ingroup netif_ip6 */ -#define netif_ip_addr6(netif, i) ((const ip_addr_t*)(&((netif)->ip6_addr[i]))) -/** @ingroup netif_ip6 */ -#define netif_ip6_addr(netif, i) ((const ip6_addr_t*)ip_2_ip6(&((netif)->ip6_addr[i]))) -void netif_ip6_addr_set(struct netif *netif, s8_t addr_idx, const ip6_addr_t *addr6); -void netif_ip6_addr_set_parts(struct netif *netif, s8_t addr_idx, u32_t i0, u32_t i1, u32_t i2, u32_t i3); -#define netif_ip6_addr_state(netif, i) ((netif)->ip6_addr_state[i]) -void netif_ip6_addr_set_state(struct netif* netif, s8_t addr_idx, u8_t state); -s8_t netif_get_ip6_addr_match(struct netif *netif, const ip6_addr_t *ip6addr); -void netif_create_ip6_linklocal_address(struct netif *netif, u8_t from_mac_48bit); -err_t netif_add_ip6_address(struct netif *netif, const ip6_addr_t *ip6addr, s8_t *chosen_idx); -#define netif_set_ip6_autoconfig_enabled(netif, action) do { if(netif) { (netif)->ip6_autoconfig_enabled = (action); }}while(0) -#if LWIP_IPV6_ADDRESS_LIFETIMES -#define netif_ip6_addr_valid_life(netif, i) \ - (((netif) != NULL) ? ((netif)->ip6_addr_valid_life[i]) : IP6_ADDR_LIFE_STATIC) -#define netif_ip6_addr_set_valid_life(netif, i, secs) \ - do { if (netif != NULL) { (netif)->ip6_addr_valid_life[i] = (secs); }} while (0) -#define netif_ip6_addr_pref_life(netif, i) \ - (((netif) != NULL) ? ((netif)->ip6_addr_pref_life[i]) : IP6_ADDR_LIFE_STATIC) -#define netif_ip6_addr_set_pref_life(netif, i, secs) \ - do { if (netif != NULL) { (netif)->ip6_addr_pref_life[i] = (secs); }} while (0) -#define netif_ip6_addr_isstatic(netif, i) \ - (netif_ip6_addr_valid_life((netif), (i)) == IP6_ADDR_LIFE_STATIC) -#else /* !LWIP_IPV6_ADDRESS_LIFETIMES */ -#define netif_ip6_addr_isstatic(netif, i) (1) /* all addresses are static */ -#endif /* !LWIP_IPV6_ADDRESS_LIFETIMES */ -#if LWIP_ND6_ALLOW_RA_UPDATES -#define netif_mtu6(netif) ((netif)->mtu6) -#else /* LWIP_ND6_ALLOW_RA_UPDATES */ -#define netif_mtu6(netif) ((netif)->mtu) -#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ -#endif /* LWIP_IPV6 */ - -#if LWIP_NETIF_USE_HINTS -#define NETIF_SET_HINTS(netif, netifhint) (netif)->hints = (netifhint) -#define NETIF_RESET_HINTS(netif) (netif)->hints = NULL -#else /* LWIP_NETIF_USE_HINTS */ -#define NETIF_SET_HINTS(netif, netifhint) -#define NETIF_RESET_HINTS(netif) -#endif /* LWIP_NETIF_USE_HINTS */ - -u8_t netif_name_to_index(const char *name); -char * netif_index_to_name(u8_t idx, char *name); -struct netif* netif_get_by_index(u8_t idx); - -/* Interface indexes always start at 1 per RFC 3493, section 4, num starts at 0 (internal index is 0..254)*/ -#define netif_get_index(netif) ((u8_t)((netif)->num + 1)) -#define NETIF_NO_INDEX (0) - -/** - * @ingroup netif - * Extended netif status callback (NSC) reasons flags. - * May be extended in the future! - */ -typedef u16_t netif_nsc_reason_t; - -/* used for initialization only */ -#define LWIP_NSC_NONE 0x0000 -/** netif was added. arg: NULL. Called AFTER netif was added. */ -#define LWIP_NSC_NETIF_ADDED 0x0001 -/** netif was removed. arg: NULL. Called BEFORE netif is removed. */ -#define LWIP_NSC_NETIF_REMOVED 0x0002 -/** link changed */ -#define LWIP_NSC_LINK_CHANGED 0x0004 -/** netif administrative status changed.\n - * up is called AFTER netif is set up.\n - * down is called BEFORE the netif is actually set down. */ -#define LWIP_NSC_STATUS_CHANGED 0x0008 -/** IPv4 address has changed */ -#define LWIP_NSC_IPV4_ADDRESS_CHANGED 0x0010 -/** IPv4 gateway has changed */ -#define LWIP_NSC_IPV4_GATEWAY_CHANGED 0x0020 -/** IPv4 netmask has changed */ -#define LWIP_NSC_IPV4_NETMASK_CHANGED 0x0040 -/** called AFTER IPv4 address/gateway/netmask changes have been applied */ -#define LWIP_NSC_IPV4_SETTINGS_CHANGED 0x0080 -/** IPv6 address was added */ -#define LWIP_NSC_IPV6_SET 0x0100 -/** IPv6 address state has changed */ -#define LWIP_NSC_IPV6_ADDR_STATE_CHANGED 0x0200 - -/** @ingroup netif - * Argument supplied to netif_ext_callback_fn. - */ -typedef union -{ - /** Args to LWIP_NSC_LINK_CHANGED callback */ - struct link_changed_s - { - /** 1: up; 0: down */ - u8_t state; - } link_changed; - /** Args to LWIP_NSC_STATUS_CHANGED callback */ - struct status_changed_s - { - /** 1: up; 0: down */ - u8_t state; - } status_changed; - /** Args to LWIP_NSC_IPV4_ADDRESS_CHANGED|LWIP_NSC_IPV4_GATEWAY_CHANGED|LWIP_NSC_IPV4_NETMASK_CHANGED|LWIP_NSC_IPV4_SETTINGS_CHANGED callback */ - struct ipv4_changed_s - { - /** Old IPv4 address */ - const ip_addr_t* old_address; - const ip_addr_t* old_netmask; - const ip_addr_t* old_gw; - } ipv4_changed; - /** Args to LWIP_NSC_IPV6_SET callback */ - struct ipv6_set_s - { - /** Index of changed IPv6 address */ - s8_t addr_index; - /** Old IPv6 address */ - const ip_addr_t* old_address; - } ipv6_set; - /** Args to LWIP_NSC_IPV6_ADDR_STATE_CHANGED callback */ - struct ipv6_addr_state_changed_s - { - /** Index of affected IPv6 address */ - s8_t addr_index; - /** Old IPv6 address state */ - u8_t old_state; - /** Affected IPv6 address */ - const ip_addr_t* address; - } ipv6_addr_state_changed; -} netif_ext_callback_args_t; - -/** - * @ingroup netif - * Function used for extended netif status callbacks - * Note: When parsing reason argument, keep in mind that more reasons may be added in the future! - * @param netif netif that is affected by change - * @param reason change reason - * @param args depends on reason, see reason description - */ -typedef void (*netif_ext_callback_fn)(struct netif* netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t* args); - -#if LWIP_NETIF_EXT_STATUS_CALLBACK -struct netif_ext_callback; -typedef struct netif_ext_callback -{ - netif_ext_callback_fn callback_fn; - struct netif_ext_callback* next; -} netif_ext_callback_t; - -#define NETIF_DECLARE_EXT_CALLBACK(name) static netif_ext_callback_t name; -void netif_add_ext_callback(netif_ext_callback_t* callback, netif_ext_callback_fn fn); -void netif_remove_ext_callback(netif_ext_callback_t* callback); -void netif_invoke_ext_callback(struct netif* netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t* args); -#else -#define NETIF_DECLARE_EXT_CALLBACK(name) -#define netif_add_ext_callback(callback, fn) -#define netif_remove_ext_callback(callback) -#define netif_invoke_ext_callback(netif, reason, args) -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_NETIF_H */ +/** + * @file + * netif API (to be used from TCPIP thread) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_NETIF_H +#define LWIP_HDR_NETIF_H + +#include "lwip/opt.h" + +#define ENABLE_LOOPBACK (LWIP_NETIF_LOOPBACK || LWIP_HAVE_LOOPIF) + +#include "lwip/err.h" + +#include "lwip/ip_addr.h" + +#include "lwip/def.h" +#include "lwip/pbuf.h" +#include "lwip/stats.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Throughout this file, IP addresses are expected to be in + * the same byte order as in IP_PCB. */ + +/** Must be the maximum of all used hardware address lengths + across all types of interfaces in use. + This does not have to be changed, normally. */ +#ifndef NETIF_MAX_HWADDR_LEN +#define NETIF_MAX_HWADDR_LEN 6U +#endif + +/** The size of a fully constructed netif name which the + * netif can be identified by in APIs. Composed of + * 2 chars, 3 (max) digits, and 1 \0 + */ +#define NETIF_NAMESIZE 6 + +/** + * @defgroup netif_flags Flags + * @ingroup netif + * @{ + */ + +/** Whether the network interface is 'up'. This is + * a software flag used to control whether this network + * interface is enabled and processes traffic. + * It must be set by the startup code before this netif can be used + * (also for dhcp/autoip). + */ +#define NETIF_FLAG_UP 0x01U +/** If set, the netif has broadcast capability. + * Set by the netif driver in its init function. */ +#define NETIF_FLAG_BROADCAST 0x02U +/** If set, the interface has an active link + * (set by the network interface driver). + * Either set by the netif driver in its init function (if the link + * is up at that time) or at a later point once the link comes up + * (if link detection is supported by the hardware). */ +#define NETIF_FLAG_LINK_UP 0x04U +/** If set, the netif is an ethernet device using ARP. + * Set by the netif driver in its init function. + * Used to check input packet types and use of DHCP. */ +#define NETIF_FLAG_ETHARP 0x08U +/** If set, the netif is an ethernet device. It might not use + * ARP or TCP/IP if it is used for PPPoE only. + */ +#define NETIF_FLAG_ETHERNET 0x10U +/** If set, the netif has IGMP capability. + * Set by the netif driver in its init function. */ +#define NETIF_FLAG_IGMP 0x20U +/** If set, the netif has MLD6 capability. + * Set by the netif driver in its init function. */ +#define NETIF_FLAG_MLD6 0x40U + +/** + * @} + */ + +enum lwip_internal_netif_client_data_index +{ +#if LWIP_IPV4 +#if LWIP_DHCP + LWIP_NETIF_CLIENT_DATA_INDEX_DHCP, +#endif +#if LWIP_AUTOIP + LWIP_NETIF_CLIENT_DATA_INDEX_AUTOIP, +#endif +#if LWIP_IGMP + LWIP_NETIF_CLIENT_DATA_INDEX_IGMP, +#endif +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 +#if LWIP_IPV6_DHCP6 + LWIP_NETIF_CLIENT_DATA_INDEX_DHCP6, +#endif +#if LWIP_IPV6_MLD + LWIP_NETIF_CLIENT_DATA_INDEX_MLD6, +#endif +#endif /* LWIP_IPV6 */ + LWIP_NETIF_CLIENT_DATA_INDEX_MAX +}; + +#if LWIP_CHECKSUM_CTRL_PER_NETIF +#define NETIF_CHECKSUM_GEN_IP 0x0001 +#define NETIF_CHECKSUM_GEN_UDP 0x0002 +#define NETIF_CHECKSUM_GEN_TCP 0x0004 +#define NETIF_CHECKSUM_GEN_ICMP 0x0008 +#define NETIF_CHECKSUM_GEN_ICMP6 0x0010 +#define NETIF_CHECKSUM_CHECK_IP 0x0100 +#define NETIF_CHECKSUM_CHECK_UDP 0x0200 +#define NETIF_CHECKSUM_CHECK_TCP 0x0400 +#define NETIF_CHECKSUM_CHECK_ICMP 0x0800 +#define NETIF_CHECKSUM_CHECK_ICMP6 0x1000 +#define NETIF_CHECKSUM_ENABLE_ALL 0xFFFF +#define NETIF_CHECKSUM_DISABLE_ALL 0x0000 +#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ + +struct netif; + +/** MAC Filter Actions, these are passed to a netif's igmp_mac_filter or + * mld_mac_filter callback function. */ +enum netif_mac_filter_action { + /** Delete a filter entry */ + NETIF_DEL_MAC_FILTER = 0, + /** Add a filter entry */ + NETIF_ADD_MAC_FILTER = 1 +}; + +/** Function prototype for netif init functions. Set up flags and output/linkoutput + * callback functions in this function. + * + * @param netif The netif to initialize + */ +typedef err_t (*netif_init_fn)(struct netif *netif); +/** Function prototype for netif->input functions. This function is saved as 'input' + * callback function in the netif struct. Call it when a packet has been received. + * + * @param p The received packet, copied into a pbuf + * @param inp The netif which received the packet + * @return ERR_OK if the packet was handled + * != ERR_OK is the packet was NOT handled, in this case, the caller has + * to free the pbuf + */ +typedef err_t (*netif_input_fn)(struct pbuf *p, struct netif *inp); + +#if LWIP_IPV4 +/** Function prototype for netif->output functions. Called by lwIP when a packet + * shall be sent. For ethernet netif, set this to 'etharp_output' and set + * 'linkoutput'. + * + * @param netif The netif which shall send a packet + * @param p The packet to send (p->payload points to IP header) + * @param ipaddr The IP address to which the packet shall be sent + */ +typedef err_t (*netif_output_fn)(struct netif *netif, struct pbuf *p, + const ip4_addr_t *ipaddr); +#endif /* LWIP_IPV4*/ + +#if LWIP_IPV6 +/** Function prototype for netif->output_ip6 functions. Called by lwIP when a packet + * shall be sent. For ethernet netif, set this to 'ethip6_output' and set + * 'linkoutput'. + * + * @param netif The netif which shall send a packet + * @param p The packet to send (p->payload points to IP header) + * @param ipaddr The IPv6 address to which the packet shall be sent + */ +typedef err_t (*netif_output_ip6_fn)(struct netif *netif, struct pbuf *p, + const ip6_addr_t *ipaddr); +#endif /* LWIP_IPV6 */ + +/** Function prototype for netif->linkoutput functions. Only used for ethernet + * netifs. This function is called by ARP when a packet shall be sent. + * + * @param netif The netif which shall send a packet + * @param p The packet to send (raw ethernet packet) + */ +typedef err_t (*netif_linkoutput_fn)(struct netif *netif, struct pbuf *p); +/** Function prototype for netif status- or link-callback functions. */ +typedef void (*netif_status_callback_fn)(struct netif *netif); +#if LWIP_IPV4 && LWIP_IGMP +/** Function prototype for netif igmp_mac_filter functions */ +typedef err_t (*netif_igmp_mac_filter_fn)(struct netif *netif, + const ip4_addr_t *group, enum netif_mac_filter_action action); +#endif /* LWIP_IPV4 && LWIP_IGMP */ +#if LWIP_IPV6 && LWIP_IPV6_MLD +/** Function prototype for netif mld_mac_filter functions */ +typedef err_t (*netif_mld_mac_filter_fn)(struct netif *netif, + const ip6_addr_t *group, enum netif_mac_filter_action action); +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ + +#if LWIP_DHCP || LWIP_AUTOIP || LWIP_IGMP || LWIP_IPV6_MLD || LWIP_IPV6_DHCP6 || (LWIP_NUM_NETIF_CLIENT_DATA > 0) +#if LWIP_NUM_NETIF_CLIENT_DATA > 0 +u8_t netif_alloc_client_data_id(void); +#endif +/** @ingroup netif_cd + * Set client data. Obtain ID from netif_alloc_client_data_id(). + */ +#define netif_set_client_data(netif, id, data) netif_get_client_data(netif, id) = (data) +/** @ingroup netif_cd + * Get client data. Obtain ID from netif_alloc_client_data_id(). + */ +#define netif_get_client_data(netif, id) (netif)->client_data[(id)] +#endif + +#if (LWIP_IPV4 && LWIP_ARP && (ARP_TABLE_SIZE > 0x7f)) || (LWIP_IPV6 && (LWIP_ND6_NUM_DESTINATIONS > 0x7f)) +typedef u16_t netif_addr_idx_t; +#define NETIF_ADDR_IDX_MAX 0x7FFF +#else +typedef u8_t netif_addr_idx_t; +#define NETIF_ADDR_IDX_MAX 0x7F +#endif + +#if LWIP_NETIF_HWADDRHINT +#define LWIP_NETIF_USE_HINTS 1 +struct netif_hint { + netif_addr_idx_t addr_hint; +}; +#else /* LWIP_NETIF_HWADDRHINT */ +#define LWIP_NETIF_USE_HINTS 0 +#endif /* LWIP_NETIF_HWADDRHINT */ + +/** Generic data structure used for all lwIP network interfaces. + * The following fields should be filled in by the initialization + * function for the device driver: hwaddr_len, hwaddr[], mtu, flags */ +struct netif { +#if !LWIP_SINGLE_NETIF + /** pointer to next in linked list */ + struct netif *next; +#endif + +#if LWIP_IPV4 + /** IP address configuration in network byte order */ + ip_addr_t ip_addr; + ip_addr_t netmask; + ip_addr_t gw; +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 + /** Array of IPv6 addresses for this netif. */ + ip_addr_t ip6_addr[LWIP_IPV6_NUM_ADDRESSES]; + /** The state of each IPv6 address (Tentative, Preferred, etc). + * @see ip6_addr.h */ + u8_t ip6_addr_state[LWIP_IPV6_NUM_ADDRESSES]; +#if LWIP_IPV6_ADDRESS_LIFETIMES + /** Remaining valid and preferred lifetime of each IPv6 address, in seconds. + * For valid lifetimes, the special value of IP6_ADDR_LIFE_STATIC (0) + * indicates the address is static and has no lifetimes. */ + u32_t ip6_addr_valid_life[LWIP_IPV6_NUM_ADDRESSES]; + u32_t ip6_addr_pref_life[LWIP_IPV6_NUM_ADDRESSES]; +#endif /* LWIP_IPV6_ADDRESS_LIFETIMES */ +#endif /* LWIP_IPV6 */ + /** This function is called by the network device driver + * to pass a packet up the TCP/IP stack. */ + netif_input_fn input; +#if LWIP_IPV4 + /** This function is called by the IP module when it wants + * to send a packet on the interface. This function typically + * first resolves the hardware address, then sends the packet. + * For ethernet physical layer, this is usually etharp_output() */ + netif_output_fn output; +#endif /* LWIP_IPV4 */ + /** This function is called by ethernet_output() when it wants + * to send a packet on the interface. This function outputs + * the pbuf as-is on the link medium. */ + netif_linkoutput_fn linkoutput; +#if LWIP_IPV6 + /** This function is called by the IPv6 module when it wants + * to send a packet on the interface. This function typically + * first resolves the hardware address, then sends the packet. + * For ethernet physical layer, this is usually ethip6_output() */ + netif_output_ip6_fn output_ip6; +#endif /* LWIP_IPV6 */ +#if LWIP_NETIF_STATUS_CALLBACK + /** This function is called when the netif state is set to up or down + */ + netif_status_callback_fn status_callback; +#endif /* LWIP_NETIF_STATUS_CALLBACK */ +#if LWIP_NETIF_LINK_CALLBACK + /** This function is called when the netif link is set to up or down + */ + netif_status_callback_fn link_callback; +#endif /* LWIP_NETIF_LINK_CALLBACK */ +#if LWIP_NETIF_REMOVE_CALLBACK + /** This function is called when the netif has been removed */ + netif_status_callback_fn remove_callback; +#endif /* LWIP_NETIF_REMOVE_CALLBACK */ + /** This field can be set by the device driver and could point + * to state information for the device. */ + void *state; +#ifdef netif_get_client_data + void* client_data[LWIP_NETIF_CLIENT_DATA_INDEX_MAX + LWIP_NUM_NETIF_CLIENT_DATA]; +#endif +#if LWIP_NETIF_HOSTNAME + /* the hostname for this netif, NULL is a valid value */ + const char* hostname; +#endif /* LWIP_NETIF_HOSTNAME */ +#if LWIP_CHECKSUM_CTRL_PER_NETIF + u16_t chksum_flags; +#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF*/ + /** maximum transfer unit (in bytes) */ + u16_t mtu; +#if LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES + /** maximum transfer unit (in bytes), updated by RA */ + u16_t mtu6; +#endif /* LWIP_IPV6 && LWIP_ND6_ALLOW_RA_UPDATES */ + /** link level hardware address of this interface */ + u8_t hwaddr[NETIF_MAX_HWADDR_LEN]; + /** number of bytes used in hwaddr */ + u8_t hwaddr_len; + /** flags (@see @ref netif_flags) */ + u8_t flags; + /** descriptive abbreviation */ + char name[2]; + /** number of this interface. Used for @ref if_api and @ref netifapi_netif, + * as well as for IPv6 zones */ + u8_t num; +#if LWIP_IPV6_AUTOCONFIG + /** is this netif enabled for IPv6 autoconfiguration */ + u8_t ip6_autoconfig_enabled; +#endif /* LWIP_IPV6_AUTOCONFIG */ +#if LWIP_IPV6_SEND_ROUTER_SOLICIT + /** Number of Router Solicitation messages that remain to be sent. */ + u8_t rs_count; +#endif /* LWIP_IPV6_SEND_ROUTER_SOLICIT */ +#if MIB2_STATS + /** link type (from "snmp_ifType" enum from snmp_mib2.h) */ + u8_t link_type; + /** (estimate) link speed */ + u32_t link_speed; + /** timestamp at last change made (up/down) */ + u32_t ts; + /** counters */ + struct stats_mib2_netif_ctrs mib2_counters; +#endif /* MIB2_STATS */ +#if LWIP_IPV4 && LWIP_IGMP + /** This function could be called to add or delete an entry in the multicast + filter table of the ethernet MAC.*/ + netif_igmp_mac_filter_fn igmp_mac_filter; +#endif /* LWIP_IPV4 && LWIP_IGMP */ +#if LWIP_IPV6 && LWIP_IPV6_MLD + /** This function could be called to add or delete an entry in the IPv6 multicast + filter table of the ethernet MAC. */ + netif_mld_mac_filter_fn mld_mac_filter; +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ +#if LWIP_NETIF_USE_HINTS + struct netif_hint *hints; +#endif /* LWIP_NETIF_USE_HINTS */ +#if ENABLE_LOOPBACK + /* List of packets to be queued for ourselves. */ + struct pbuf *loop_first; + struct pbuf *loop_last; +#if LWIP_LOOPBACK_MAX_PBUFS + u16_t loop_cnt_current; +#endif /* LWIP_LOOPBACK_MAX_PBUFS */ +#endif /* ENABLE_LOOPBACK */ +}; + +#if LWIP_CHECKSUM_CTRL_PER_NETIF +#define NETIF_SET_CHECKSUM_CTRL(netif, chksumflags) do { \ + (netif)->chksum_flags = chksumflags; } while(0) +#define IF__NETIF_CHECKSUM_ENABLED(netif, chksumflag) if (((netif) == NULL) || (((netif)->chksum_flags & (chksumflag)) != 0)) +#else /* LWIP_CHECKSUM_CTRL_PER_NETIF */ +#define NETIF_SET_CHECKSUM_CTRL(netif, chksumflags) +#define IF__NETIF_CHECKSUM_ENABLED(netif, chksumflag) +#endif /* LWIP_CHECKSUM_CTRL_PER_NETIF */ + +#if LWIP_SINGLE_NETIF +#define NETIF_FOREACH(netif) if (((netif) = netif_default) != NULL) +#else /* LWIP_SINGLE_NETIF */ +/** The list of network interfaces. */ +extern struct netif *netif_list; +#define NETIF_FOREACH(netif) for ((netif) = netif_list; (netif) != NULL; (netif) = (netif)->next) +#endif /* LWIP_SINGLE_NETIF */ +/** The default network interface. */ +extern struct netif *netif_default; + +void netif_init(void); + +struct netif *netif_add_noaddr(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input); + +#if LWIP_IPV4 +struct netif *netif_add(struct netif *netif, + const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, + void *state, netif_init_fn init, netif_input_fn input); +void netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, + const ip4_addr_t *gw); +#else /* LWIP_IPV4 */ +struct netif *netif_add(struct netif *netif, void *state, netif_init_fn init, netif_input_fn input); +#endif /* LWIP_IPV4 */ +void netif_remove(struct netif * netif); + +/* Returns a network interface given its name. The name is of the form + "et0", where the first two letters are the "name" field in the + netif structure, and the digit is in the num field in the same + structure. */ +struct netif *netif_find(const char *name); + +void netif_set_default(struct netif *netif); + +#if LWIP_IPV4 +void netif_set_ipaddr(struct netif *netif, const ip4_addr_t *ipaddr); +void netif_set_netmask(struct netif *netif, const ip4_addr_t *netmask); +void netif_set_gw(struct netif *netif, const ip4_addr_t *gw); +/** @ingroup netif_ip4 */ +#define netif_ip4_addr(netif) ((const ip4_addr_t*)ip_2_ip4(&((netif)->ip_addr))) +/** @ingroup netif_ip4 */ +#define netif_ip4_netmask(netif) ((const ip4_addr_t*)ip_2_ip4(&((netif)->netmask))) +/** @ingroup netif_ip4 */ +#define netif_ip4_gw(netif) ((const ip4_addr_t*)ip_2_ip4(&((netif)->gw))) +/** @ingroup netif_ip4 */ +#define netif_ip_addr4(netif) ((const ip_addr_t*)&((netif)->ip_addr)) +/** @ingroup netif_ip4 */ +#define netif_ip_netmask4(netif) ((const ip_addr_t*)&((netif)->netmask)) +/** @ingroup netif_ip4 */ +#define netif_ip_gw4(netif) ((const ip_addr_t*)&((netif)->gw)) +#endif /* LWIP_IPV4 */ + +#define netif_set_flags(netif, set_flags) do { (netif)->flags = (u8_t)((netif)->flags | (set_flags)); } while(0) +#define netif_clear_flags(netif, clr_flags) do { (netif)->flags = (u8_t)((netif)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) +#define netif_is_flag_set(nefif, flag) (((netif)->flags & (flag)) != 0) + +void netif_set_up(struct netif *netif); +void netif_set_down(struct netif *netif); +/** @ingroup netif + * Ask if an interface is up + */ +#define netif_is_up(netif) (((netif)->flags & NETIF_FLAG_UP) ? (u8_t)1 : (u8_t)0) + +#if LWIP_NETIF_STATUS_CALLBACK +void netif_set_status_callback(struct netif *netif, netif_status_callback_fn status_callback); +#endif /* LWIP_NETIF_STATUS_CALLBACK */ +#if LWIP_NETIF_REMOVE_CALLBACK +void netif_set_remove_callback(struct netif *netif, netif_status_callback_fn remove_callback); +#endif /* LWIP_NETIF_REMOVE_CALLBACK */ + +void netif_set_link_up(struct netif *netif); +void netif_set_link_down(struct netif *netif); +/** Ask if a link is up */ +#define netif_is_link_up(netif) (((netif)->flags & NETIF_FLAG_LINK_UP) ? (u8_t)1 : (u8_t)0) + +#if LWIP_NETIF_LINK_CALLBACK +void netif_set_link_callback(struct netif *netif, netif_status_callback_fn link_callback); +#endif /* LWIP_NETIF_LINK_CALLBACK */ + +#if LWIP_NETIF_HOSTNAME +/** @ingroup netif */ +#define netif_set_hostname(netif, name) do { if((netif) != NULL) { (netif)->hostname = name; }}while(0) +/** @ingroup netif */ +#define netif_get_hostname(netif) (((netif) != NULL) ? ((netif)->hostname) : NULL) +#endif /* LWIP_NETIF_HOSTNAME */ + +#if LWIP_IGMP +/** @ingroup netif */ +#define netif_set_igmp_mac_filter(netif, function) do { if((netif) != NULL) { (netif)->igmp_mac_filter = function; }}while(0) +#define netif_get_igmp_mac_filter(netif) (((netif) != NULL) ? ((netif)->igmp_mac_filter) : NULL) +#endif /* LWIP_IGMP */ + +#if LWIP_IPV6 && LWIP_IPV6_MLD +/** @ingroup netif */ +#define netif_set_mld_mac_filter(netif, function) do { if((netif) != NULL) { (netif)->mld_mac_filter = function; }}while(0) +#define netif_get_mld_mac_filter(netif) (((netif) != NULL) ? ((netif)->mld_mac_filter) : NULL) +#define netif_mld_mac_filter(netif, addr, action) do { if((netif) && (netif)->mld_mac_filter) { (netif)->mld_mac_filter((netif), (addr), (action)); }}while(0) +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ + +#if ENABLE_LOOPBACK +err_t netif_loop_output(struct netif *netif, struct pbuf *p); +void netif_poll(struct netif *netif); +#if !LWIP_NETIF_LOOPBACK_MULTITHREADING +void netif_poll_all(void); +#endif /* !LWIP_NETIF_LOOPBACK_MULTITHREADING */ +#endif /* ENABLE_LOOPBACK */ + +err_t netif_input(struct pbuf *p, struct netif *inp); + +#if LWIP_IPV6 +/** @ingroup netif_ip6 */ +#define netif_ip_addr6(netif, i) ((const ip_addr_t*)(&((netif)->ip6_addr[i]))) +/** @ingroup netif_ip6 */ +#define netif_ip6_addr(netif, i) ((const ip6_addr_t*)ip_2_ip6(&((netif)->ip6_addr[i]))) +void netif_ip6_addr_set(struct netif *netif, s8_t addr_idx, const ip6_addr_t *addr6); +void netif_ip6_addr_set_parts(struct netif *netif, s8_t addr_idx, u32_t i0, u32_t i1, u32_t i2, u32_t i3); +#define netif_ip6_addr_state(netif, i) ((netif)->ip6_addr_state[i]) +void netif_ip6_addr_set_state(struct netif* netif, s8_t addr_idx, u8_t state); +s8_t netif_get_ip6_addr_match(struct netif *netif, const ip6_addr_t *ip6addr); +void netif_create_ip6_linklocal_address(struct netif *netif, u8_t from_mac_48bit); +err_t netif_add_ip6_address(struct netif *netif, const ip6_addr_t *ip6addr, s8_t *chosen_idx); +#define netif_set_ip6_autoconfig_enabled(netif, action) do { if(netif) { (netif)->ip6_autoconfig_enabled = (action); }}while(0) +#if LWIP_IPV6_ADDRESS_LIFETIMES +#define netif_ip6_addr_valid_life(netif, i) \ + (((netif) != NULL) ? ((netif)->ip6_addr_valid_life[i]) : IP6_ADDR_LIFE_STATIC) +#define netif_ip6_addr_set_valid_life(netif, i, secs) \ + do { if (netif != NULL) { (netif)->ip6_addr_valid_life[i] = (secs); }} while (0) +#define netif_ip6_addr_pref_life(netif, i) \ + (((netif) != NULL) ? ((netif)->ip6_addr_pref_life[i]) : IP6_ADDR_LIFE_STATIC) +#define netif_ip6_addr_set_pref_life(netif, i, secs) \ + do { if (netif != NULL) { (netif)->ip6_addr_pref_life[i] = (secs); }} while (0) +#define netif_ip6_addr_isstatic(netif, i) \ + (netif_ip6_addr_valid_life((netif), (i)) == IP6_ADDR_LIFE_STATIC) +#else /* !LWIP_IPV6_ADDRESS_LIFETIMES */ +#define netif_ip6_addr_isstatic(netif, i) (1) /* all addresses are static */ +#endif /* !LWIP_IPV6_ADDRESS_LIFETIMES */ +#if LWIP_ND6_ALLOW_RA_UPDATES +#define netif_mtu6(netif) ((netif)->mtu6) +#else /* LWIP_ND6_ALLOW_RA_UPDATES */ +#define netif_mtu6(netif) ((netif)->mtu) +#endif /* LWIP_ND6_ALLOW_RA_UPDATES */ +#endif /* LWIP_IPV6 */ + +#if LWIP_NETIF_USE_HINTS +#define NETIF_SET_HINTS(netif, netifhint) (netif)->hints = (netifhint) +#define NETIF_RESET_HINTS(netif) (netif)->hints = NULL +#else /* LWIP_NETIF_USE_HINTS */ +#define NETIF_SET_HINTS(netif, netifhint) +#define NETIF_RESET_HINTS(netif) +#endif /* LWIP_NETIF_USE_HINTS */ + +u8_t netif_name_to_index(const char *name); +char * netif_index_to_name(u8_t idx, char *name); +struct netif* netif_get_by_index(u8_t idx); + +/* Interface indexes always start at 1 per RFC 3493, section 4, num starts at 0 (internal index is 0..254)*/ +#define netif_get_index(netif) ((u8_t)((netif)->num + 1)) +#define NETIF_NO_INDEX (0) + +/** + * @ingroup netif + * Extended netif status callback (NSC) reasons flags. + * May be extended in the future! + */ +typedef u16_t netif_nsc_reason_t; + +/* used for initialization only */ +#define LWIP_NSC_NONE 0x0000 +/** netif was added. arg: NULL. Called AFTER netif was added. */ +#define LWIP_NSC_NETIF_ADDED 0x0001 +/** netif was removed. arg: NULL. Called BEFORE netif is removed. */ +#define LWIP_NSC_NETIF_REMOVED 0x0002 +/** link changed */ +#define LWIP_NSC_LINK_CHANGED 0x0004 +/** netif administrative status changed.\n + * up is called AFTER netif is set up.\n + * down is called BEFORE the netif is actually set down. */ +#define LWIP_NSC_STATUS_CHANGED 0x0008 +/** IPv4 address has changed */ +#define LWIP_NSC_IPV4_ADDRESS_CHANGED 0x0010 +/** IPv4 gateway has changed */ +#define LWIP_NSC_IPV4_GATEWAY_CHANGED 0x0020 +/** IPv4 netmask has changed */ +#define LWIP_NSC_IPV4_NETMASK_CHANGED 0x0040 +/** called AFTER IPv4 address/gateway/netmask changes have been applied */ +#define LWIP_NSC_IPV4_SETTINGS_CHANGED 0x0080 +/** IPv6 address was added */ +#define LWIP_NSC_IPV6_SET 0x0100 +/** IPv6 address state has changed */ +#define LWIP_NSC_IPV6_ADDR_STATE_CHANGED 0x0200 + +/** @ingroup netif + * Argument supplied to netif_ext_callback_fn. + */ +typedef union +{ + /** Args to LWIP_NSC_LINK_CHANGED callback */ + struct link_changed_s + { + /** 1: up; 0: down */ + u8_t state; + } link_changed; + /** Args to LWIP_NSC_STATUS_CHANGED callback */ + struct status_changed_s + { + /** 1: up; 0: down */ + u8_t state; + } status_changed; + /** Args to LWIP_NSC_IPV4_ADDRESS_CHANGED|LWIP_NSC_IPV4_GATEWAY_CHANGED|LWIP_NSC_IPV4_NETMASK_CHANGED|LWIP_NSC_IPV4_SETTINGS_CHANGED callback */ + struct ipv4_changed_s + { + /** Old IPv4 address */ + const ip_addr_t* old_address; + const ip_addr_t* old_netmask; + const ip_addr_t* old_gw; + } ipv4_changed; + /** Args to LWIP_NSC_IPV6_SET callback */ + struct ipv6_set_s + { + /** Index of changed IPv6 address */ + s8_t addr_index; + /** Old IPv6 address */ + const ip_addr_t* old_address; + } ipv6_set; + /** Args to LWIP_NSC_IPV6_ADDR_STATE_CHANGED callback */ + struct ipv6_addr_state_changed_s + { + /** Index of affected IPv6 address */ + s8_t addr_index; + /** Old IPv6 address state */ + u8_t old_state; + /** Affected IPv6 address */ + const ip_addr_t* address; + } ipv6_addr_state_changed; +} netif_ext_callback_args_t; + +/** + * @ingroup netif + * Function used for extended netif status callbacks + * Note: When parsing reason argument, keep in mind that more reasons may be added in the future! + * @param netif netif that is affected by change + * @param reason change reason + * @param args depends on reason, see reason description + */ +typedef void (*netif_ext_callback_fn)(struct netif* netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t* args); + +#if LWIP_NETIF_EXT_STATUS_CALLBACK +struct netif_ext_callback; +typedef struct netif_ext_callback +{ + netif_ext_callback_fn callback_fn; + struct netif_ext_callback* next; +} netif_ext_callback_t; + +#define NETIF_DECLARE_EXT_CALLBACK(name) static netif_ext_callback_t name; +void netif_add_ext_callback(netif_ext_callback_t* callback, netif_ext_callback_fn fn); +void netif_remove_ext_callback(netif_ext_callback_t* callback); +void netif_invoke_ext_callback(struct netif* netif, netif_nsc_reason_t reason, const netif_ext_callback_args_t* args); +#else +#define NETIF_DECLARE_EXT_CALLBACK(name) +#define netif_add_ext_callback(callback, fn) +#define netif_remove_ext_callback(callback) +#define netif_invoke_ext_callback(netif, reason, args) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_NETIF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netifapi.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netifapi.h index 5bbd8f88..e0631791 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netifapi.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/netifapi.h @@ -1,161 +1,161 @@ -/** - * @file - * netif API (to be used from non-TCPIP threads) - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ -#ifndef LWIP_HDR_NETIFAPI_H -#define LWIP_HDR_NETIFAPI_H - -#include "lwip/opt.h" - -#if LWIP_NETIF_API /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/sys.h" -#include "lwip/netif.h" -#include "lwip/dhcp.h" -#include "lwip/autoip.h" -#include "lwip/priv/tcpip_priv.h" -#include "lwip/priv/api_msg.h" -#include "lwip/prot/ethernet.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* API for application */ -#if LWIP_ARP && LWIP_IPV4 -/* Used for netfiapi_arp_* APIs */ -enum netifapi_arp_entry { - NETIFAPI_ARP_PERM /* Permanent entry */ - /* Other entry types can be added here */ -}; - -/** @ingroup netifapi_arp */ -err_t netifapi_arp_add(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, enum netifapi_arp_entry type); -/** @ingroup netifapi_arp */ -err_t netifapi_arp_remove(const ip4_addr_t *ipaddr, enum netifapi_arp_entry type); -#endif /* LWIP_ARP && LWIP_IPV4 */ - -err_t netifapi_netif_add(struct netif *netif, -#if LWIP_IPV4 - const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, -#endif /* LWIP_IPV4 */ - void *state, netif_init_fn init, netif_input_fn input); - -#if LWIP_IPV4 -err_t netifapi_netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, - const ip4_addr_t *netmask, const ip4_addr_t *gw); -#endif /* LWIP_IPV4*/ - -err_t netifapi_netif_common(struct netif *netif, netifapi_void_fn voidfunc, - netifapi_errt_fn errtfunc); - -/** @ingroup netifapi_netif */ -err_t netifapi_netif_name_to_index(const char *name, u8_t *index); -/** @ingroup netifapi_netif */ -err_t netifapi_netif_index_to_name(u8_t index, char *name); - -/** @ingroup netifapi_netif - * @see netif_remove() - */ -#define netifapi_netif_remove(n) netifapi_netif_common(n, netif_remove, NULL) -/** @ingroup netifapi_netif - * @see netif_set_up() - */ -#define netifapi_netif_set_up(n) netifapi_netif_common(n, netif_set_up, NULL) -/** @ingroup netifapi_netif - * @see netif_set_down() - */ -#define netifapi_netif_set_down(n) netifapi_netif_common(n, netif_set_down, NULL) -/** @ingroup netifapi_netif - * @see netif_set_default() - */ -#define netifapi_netif_set_default(n) netifapi_netif_common(n, netif_set_default, NULL) -/** @ingroup netifapi_netif - * @see netif_set_link_up() - */ -#define netifapi_netif_set_link_up(n) netifapi_netif_common(n, netif_set_link_up, NULL) -/** @ingroup netifapi_netif - * @see netif_set_link_down() - */ -#define netifapi_netif_set_link_down(n) netifapi_netif_common(n, netif_set_link_down, NULL) - -/** - * @defgroup netifapi_dhcp4 DHCPv4 - * @ingroup netifapi - * To be called from non-TCPIP threads - */ -/** @ingroup netifapi_dhcp4 - * @see dhcp_start() - */ -#define netifapi_dhcp_start(n) netifapi_netif_common(n, NULL, dhcp_start) -/** - * @ingroup netifapi_dhcp4 - * @deprecated Use netifapi_dhcp_release_and_stop() instead. - */ -#define netifapi_dhcp_stop(n) netifapi_netif_common(n, dhcp_stop, NULL) -/** @ingroup netifapi_dhcp4 - * @see dhcp_inform() - */ -#define netifapi_dhcp_inform(n) netifapi_netif_common(n, dhcp_inform, NULL) -/** @ingroup netifapi_dhcp4 - * @see dhcp_renew() - */ -#define netifapi_dhcp_renew(n) netifapi_netif_common(n, NULL, dhcp_renew) -/** - * @ingroup netifapi_dhcp4 - * @deprecated Use netifapi_dhcp_release_and_stop() instead. - */ -#define netifapi_dhcp_release(n) netifapi_netif_common(n, NULL, dhcp_release) -/** @ingroup netifapi_dhcp4 - * @see dhcp_release_and_stop() - */ -#define netifapi_dhcp_release_and_stop(n) netifapi_netif_common(n, dhcp_release_and_stop, NULL) - -/** - * @defgroup netifapi_autoip AUTOIP - * @ingroup netifapi - * To be called from non-TCPIP threads - */ -/** @ingroup netifapi_autoip - * @see autoip_start() - */ -#define netifapi_autoip_start(n) netifapi_netif_common(n, NULL, autoip_start) -/** @ingroup netifapi_autoip - * @see autoip_stop() - */ -#define netifapi_autoip_stop(n) netifapi_netif_common(n, NULL, autoip_stop) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_NETIF_API */ - -#endif /* LWIP_HDR_NETIFAPI_H */ +/** + * @file + * netif API (to be used from non-TCPIP threads) + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ +#ifndef LWIP_HDR_NETIFAPI_H +#define LWIP_HDR_NETIFAPI_H + +#include "lwip/opt.h" + +#if LWIP_NETIF_API /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/sys.h" +#include "lwip/netif.h" +#include "lwip/dhcp.h" +#include "lwip/autoip.h" +#include "lwip/priv/tcpip_priv.h" +#include "lwip/priv/api_msg.h" +#include "lwip/prot/ethernet.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* API for application */ +#if LWIP_ARP && LWIP_IPV4 +/* Used for netfiapi_arp_* APIs */ +enum netifapi_arp_entry { + NETIFAPI_ARP_PERM /* Permanent entry */ + /* Other entry types can be added here */ +}; + +/** @ingroup netifapi_arp */ +err_t netifapi_arp_add(const ip4_addr_t *ipaddr, struct eth_addr *ethaddr, enum netifapi_arp_entry type); +/** @ingroup netifapi_arp */ +err_t netifapi_arp_remove(const ip4_addr_t *ipaddr, enum netifapi_arp_entry type); +#endif /* LWIP_ARP && LWIP_IPV4 */ + +err_t netifapi_netif_add(struct netif *netif, +#if LWIP_IPV4 + const ip4_addr_t *ipaddr, const ip4_addr_t *netmask, const ip4_addr_t *gw, +#endif /* LWIP_IPV4 */ + void *state, netif_init_fn init, netif_input_fn input); + +#if LWIP_IPV4 +err_t netifapi_netif_set_addr(struct netif *netif, const ip4_addr_t *ipaddr, + const ip4_addr_t *netmask, const ip4_addr_t *gw); +#endif /* LWIP_IPV4*/ + +err_t netifapi_netif_common(struct netif *netif, netifapi_void_fn voidfunc, + netifapi_errt_fn errtfunc); + +/** @ingroup netifapi_netif */ +err_t netifapi_netif_name_to_index(const char *name, u8_t *index); +/** @ingroup netifapi_netif */ +err_t netifapi_netif_index_to_name(u8_t index, char *name); + +/** @ingroup netifapi_netif + * @see netif_remove() + */ +#define netifapi_netif_remove(n) netifapi_netif_common(n, netif_remove, NULL) +/** @ingroup netifapi_netif + * @see netif_set_up() + */ +#define netifapi_netif_set_up(n) netifapi_netif_common(n, netif_set_up, NULL) +/** @ingroup netifapi_netif + * @see netif_set_down() + */ +#define netifapi_netif_set_down(n) netifapi_netif_common(n, netif_set_down, NULL) +/** @ingroup netifapi_netif + * @see netif_set_default() + */ +#define netifapi_netif_set_default(n) netifapi_netif_common(n, netif_set_default, NULL) +/** @ingroup netifapi_netif + * @see netif_set_link_up() + */ +#define netifapi_netif_set_link_up(n) netifapi_netif_common(n, netif_set_link_up, NULL) +/** @ingroup netifapi_netif + * @see netif_set_link_down() + */ +#define netifapi_netif_set_link_down(n) netifapi_netif_common(n, netif_set_link_down, NULL) + +/** + * @defgroup netifapi_dhcp4 DHCPv4 + * @ingroup netifapi + * To be called from non-TCPIP threads + */ +/** @ingroup netifapi_dhcp4 + * @see dhcp_start() + */ +#define netifapi_dhcp_start(n) netifapi_netif_common(n, NULL, dhcp_start) +/** + * @ingroup netifapi_dhcp4 + * @deprecated Use netifapi_dhcp_release_and_stop() instead. + */ +#define netifapi_dhcp_stop(n) netifapi_netif_common(n, dhcp_stop, NULL) +/** @ingroup netifapi_dhcp4 + * @see dhcp_inform() + */ +#define netifapi_dhcp_inform(n) netifapi_netif_common(n, dhcp_inform, NULL) +/** @ingroup netifapi_dhcp4 + * @see dhcp_renew() + */ +#define netifapi_dhcp_renew(n) netifapi_netif_common(n, NULL, dhcp_renew) +/** + * @ingroup netifapi_dhcp4 + * @deprecated Use netifapi_dhcp_release_and_stop() instead. + */ +#define netifapi_dhcp_release(n) netifapi_netif_common(n, NULL, dhcp_release) +/** @ingroup netifapi_dhcp4 + * @see dhcp_release_and_stop() + */ +#define netifapi_dhcp_release_and_stop(n) netifapi_netif_common(n, dhcp_release_and_stop, NULL) + +/** + * @defgroup netifapi_autoip AUTOIP + * @ingroup netifapi + * To be called from non-TCPIP threads + */ +/** @ingroup netifapi_autoip + * @see autoip_start() + */ +#define netifapi_autoip_start(n) netifapi_netif_common(n, NULL, autoip_start) +/** @ingroup netifapi_autoip + * @see autoip_stop() + */ +#define netifapi_autoip_stop(n) netifapi_netif_common(n, NULL, autoip_stop) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_NETIF_API */ + +#endif /* LWIP_HDR_NETIFAPI_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/opt.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/opt.h index e902c134..0d427d22 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/opt.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/opt.h @@ -1,3519 +1,3519 @@ -/** - * @file - * - * lwIP Options Configuration - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -/* - * NOTE: || defined __DOXYGEN__ is a workaround for doxygen bug - - * without this, doxygen does not see the actual #define - */ - -#if !defined LWIP_HDR_OPT_H -#define LWIP_HDR_OPT_H - -/* - * Include user defined options first. Anything not defined in these files - * will be set to standard values. Override anything you don't like! - */ -#include "lwipopts.h" -#include "lwip/debug.h" - -/** - * @defgroup lwip_opts Options (lwipopts.h) - * @ingroup lwip - * - * @defgroup lwip_opts_debug Debugging - * @ingroup lwip_opts - * - * @defgroup lwip_opts_infrastructure Infrastructure - * @ingroup lwip_opts - * - * @defgroup lwip_opts_callback Callback-style APIs - * @ingroup lwip_opts - * - * @defgroup lwip_opts_threadsafe_apis Thread-safe APIs - * @ingroup lwip_opts - */ - - /* - ------------------------------------ - -------------- NO SYS -------------- - ------------------------------------ -*/ -/** - * @defgroup lwip_opts_nosys NO_SYS - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * NO_SYS==1: Use lwIP without OS-awareness (no thread, semaphores, mutexes or - * mboxes). This means threaded APIs cannot be used (socket, netconn, - * i.e. everything in the 'api' folder), only the callback-style raw API is - * available (and you have to watch out for yourself that you don't access - * lwIP functions/structures from more than one context at a time!) - */ -#if !defined NO_SYS || defined __DOXYGEN__ -#define NO_SYS 0 -#endif -/** - * @} - */ - -/** - * @defgroup lwip_opts_timers Timers - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * LWIP_TIMERS==0: Drop support for sys_timeout and lwip-internal cyclic timers. - * (the array of lwip-internal cyclic timers is still provided) - * (check NO_SYS_NO_TIMERS for compatibility to old versions) - */ -#if !defined LWIP_TIMERS || defined __DOXYGEN__ -#ifdef NO_SYS_NO_TIMERS -#define LWIP_TIMERS (!NO_SYS || (NO_SYS && !NO_SYS_NO_TIMERS)) -#else -#define LWIP_TIMERS 1 -#endif -#endif - -/** - * LWIP_TIMERS_CUSTOM==1: Provide your own timer implementation. - * Function prototypes in timeouts.h and the array of lwip-internal cyclic timers - * are still included, but the implementation is not. The following functions - * will be required: sys_timeouts_init(), sys_timeout(), sys_untimeout(), - * sys_timeouts_mbox_fetch() - */ -#if !defined LWIP_TIMERS_CUSTOM || defined __DOXYGEN__ -#define LWIP_TIMERS_CUSTOM 0 -#endif -/** - * @} - */ - -/** - * @defgroup lwip_opts_memcpy memcpy - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * MEMCPY: override this if you have a faster implementation at hand than the - * one included in your C library - */ -#if !defined MEMCPY || defined __DOXYGEN__ -#define MEMCPY(dst,src,len) memcpy(dst,src,len) -#endif - -/** - * SMEMCPY: override this with care! Some compilers (e.g. gcc) can inline a - * call to memcpy() if the length is known at compile time and is small. - */ -#if !defined SMEMCPY || defined __DOXYGEN__ -#define SMEMCPY(dst,src,len) memcpy(dst,src,len) -#endif - -/** - * MEMMOVE: override this if you have a faster implementation at hand than the - * one included in your C library. lwIP currently uses MEMMOVE only when IPv6 - * fragmentation support is enabled. - */ -#if !defined MEMMOVE || defined __DOXYGEN__ -#define MEMMOVE(dst,src,len) memmove(dst,src,len) -#endif -/** - * @} - */ - -/* - ------------------------------------ - ----------- Core locking ----------- - ------------------------------------ -*/ -/** - * @defgroup lwip_opts_lock Core locking and MPU - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * LWIP_MPU_COMPATIBLE: enables special memory management mechanism - * which makes lwip able to work on MPU (Memory Protection Unit) system - * by not passing stack-pointers to other threads - * (this decreases performance as memory is allocated from pools instead - * of keeping it on the stack) - */ -#if !defined LWIP_MPU_COMPATIBLE || defined __DOXYGEN__ -#define LWIP_MPU_COMPATIBLE 0 -#endif - -/** - * LWIP_TCPIP_CORE_LOCKING - * Creates a global mutex that is held during TCPIP thread operations. - * Can be locked by client code to perform lwIP operations without changing - * into TCPIP thread using callbacks. See LOCK_TCPIP_CORE() and - * UNLOCK_TCPIP_CORE(). - * Your system should provide mutexes supporting priority inversion to use this. - */ -#if !defined LWIP_TCPIP_CORE_LOCKING || defined __DOXYGEN__ -#define LWIP_TCPIP_CORE_LOCKING 1 -#endif - -/** - * LWIP_TCPIP_CORE_LOCKING_INPUT: when LWIP_TCPIP_CORE_LOCKING is enabled, - * this lets tcpip_input() grab the mutex for input packets as well, - * instead of allocating a message and passing it to tcpip_thread. - * - * ATTENTION: this does not work when tcpip_input() is called from - * interrupt context! - */ -#if !defined LWIP_TCPIP_CORE_LOCKING_INPUT || defined __DOXYGEN__ -#define LWIP_TCPIP_CORE_LOCKING_INPUT 0 -#endif - -/** - * SYS_LIGHTWEIGHT_PROT==1: enable inter-task protection (and task-vs-interrupt - * protection) for certain critical regions during buffer allocation, deallocation - * and memory allocation and deallocation. - * ATTENTION: This is required when using lwIP from more than one context! If - * you disable this, you must be sure what you are doing! - */ -#if !defined SYS_LIGHTWEIGHT_PROT || defined __DOXYGEN__ -#define SYS_LIGHTWEIGHT_PROT 1 -#endif - -/** - * Macro/function to check whether lwIP's threading/locking - * requirements are satisfied during current function call. - * This macro usually calls a function that is implemented in the OS-dependent - * sys layer and performs the following checks: - * - Not in ISR (this should be checked for NO_SYS==1, too!) - * - If @ref LWIP_TCPIP_CORE_LOCKING = 1: TCPIP core lock is held - * - If @ref LWIP_TCPIP_CORE_LOCKING = 0: function is called from TCPIP thread - * @see @ref multithreading - */ -#if !defined LWIP_ASSERT_CORE_LOCKED || defined __DOXYGEN__ -#define LWIP_ASSERT_CORE_LOCKED() -#endif - -/** - * Called as first thing in the lwIP TCPIP thread. Can be used in conjunction - * with @ref LWIP_ASSERT_CORE_LOCKED to check core locking. - * @see @ref multithreading - */ -#if !defined LWIP_MARK_TCPIP_THREAD || defined __DOXYGEN__ -#define LWIP_MARK_TCPIP_THREAD() -#endif -/** - * @} - */ - -/* - ------------------------------------ - ---------- Memory options ---------- - ------------------------------------ -*/ -/** - * @defgroup lwip_opts_mem Heap and memory pools - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * MEM_LIBC_MALLOC==1: Use malloc/free/realloc provided by your C-library - * instead of the lwip internal allocator. Can save code size if you - * already use it. - */ -#if !defined MEM_LIBC_MALLOC || defined __DOXYGEN__ -#define MEM_LIBC_MALLOC 0 -#endif - -/** - * MEMP_MEM_MALLOC==1: Use mem_malloc/mem_free instead of the lwip pool allocator. - * Especially useful with MEM_LIBC_MALLOC but handle with care regarding execution - * speed (heap alloc can be much slower than pool alloc) and usage from interrupts - * (especially if your netif driver allocates PBUF_POOL pbufs for received frames - * from interrupt)! - * ATTENTION: Currently, this uses the heap for ALL pools (also for private pools, - * not only for internal pools defined in memp_std.h)! - */ -#if !defined MEMP_MEM_MALLOC || defined __DOXYGEN__ -#define MEMP_MEM_MALLOC 0 -#endif - -/** - * MEMP_MEM_INIT==1: Force use of memset to initialize pool memory. - * Useful if pool are moved in uninitialized section of memory. This will ensure - * default values in pcbs struct are well initialized in all conditions. - */ -#if !defined MEMP_MEM_INIT || defined __DOXYGEN__ -#define MEMP_MEM_INIT 0 -#endif - -/** - * MEM_ALIGNMENT: should be set to the alignment of the CPU - * 4 byte alignment -> \#define MEM_ALIGNMENT 4 - * 2 byte alignment -> \#define MEM_ALIGNMENT 2 - */ -#if !defined MEM_ALIGNMENT || defined __DOXYGEN__ -#define MEM_ALIGNMENT 1 -#endif - -/** - * MEM_SIZE: the size of the heap memory. If the application will send - * a lot of data that needs to be copied, this should be set high. - */ -#if !defined MEM_SIZE || defined __DOXYGEN__ -#define MEM_SIZE 1600 -#endif - -/** - * MEMP_OVERFLOW_CHECK: memp overflow protection reserves a configurable - * amount of bytes before and after each memp element in every pool and fills - * it with a prominent default value. - * MEMP_OVERFLOW_CHECK == 0 no checking - * MEMP_OVERFLOW_CHECK == 1 checks each element when it is freed - * MEMP_OVERFLOW_CHECK >= 2 checks each element in every pool every time - * memp_malloc() or memp_free() is called (useful but slow!) - */ -#if !defined MEMP_OVERFLOW_CHECK || defined __DOXYGEN__ -#define MEMP_OVERFLOW_CHECK 0 -#endif - -/** - * MEMP_SANITY_CHECK==1: run a sanity check after each memp_free() to make - * sure that there are no cycles in the linked lists. - */ -#if !defined MEMP_SANITY_CHECK || defined __DOXYGEN__ -#define MEMP_SANITY_CHECK 0 -#endif - -/** - * MEM_OVERFLOW_CHECK: mem overflow protection reserves a configurable - * amount of bytes before and after each heap allocation chunk and fills - * it with a prominent default value. - * MEM_OVERFLOW_CHECK == 0 no checking - * MEM_OVERFLOW_CHECK == 1 checks each element when it is freed - * MEM_OVERFLOW_CHECK >= 2 checks all heap elements every time - * mem_malloc() or mem_free() is called (useful but slow!) - */ -#if !defined MEM_OVERFLOW_CHECK || defined __DOXYGEN__ -#define MEM_OVERFLOW_CHECK 0 -#endif - -/** - * MEM_SANITY_CHECK==1: run a sanity check after each mem_free() to make - * sure that the linked list of heap elements is not corrupted. - */ -#if !defined MEM_SANITY_CHECK || defined __DOXYGEN__ -#define MEM_SANITY_CHECK 0 -#endif - -/** - * MEM_USE_POOLS==1: Use an alternative to malloc() by allocating from a set - * of memory pools of various sizes. When mem_malloc is called, an element of - * the smallest pool that can provide the length needed is returned. - * To use this, MEMP_USE_CUSTOM_POOLS also has to be enabled. - */ -#if !defined MEM_USE_POOLS || defined __DOXYGEN__ -#define MEM_USE_POOLS 0 -#endif - -/** - * MEM_USE_POOLS_TRY_BIGGER_POOL==1: if one malloc-pool is empty, try the next - * bigger pool - WARNING: THIS MIGHT WASTE MEMORY but it can make a system more - * reliable. */ -#if !defined MEM_USE_POOLS_TRY_BIGGER_POOL || defined __DOXYGEN__ -#define MEM_USE_POOLS_TRY_BIGGER_POOL 0 -#endif - -/** - * MEMP_USE_CUSTOM_POOLS==1: whether to include a user file lwippools.h - * that defines additional pools beyond the "standard" ones required - * by lwIP. If you set this to 1, you must have lwippools.h in your - * include path somewhere. - */ -#if !defined MEMP_USE_CUSTOM_POOLS || defined __DOXYGEN__ -#define MEMP_USE_CUSTOM_POOLS 0 -#endif - -/** - * Set this to 1 if you want to free PBUF_RAM pbufs (or call mem_free()) from - * interrupt context (or another context that doesn't allow waiting for a - * semaphore). - * If set to 1, mem_malloc will be protected by a semaphore and SYS_ARCH_PROTECT, - * while mem_free will only use SYS_ARCH_PROTECT. mem_malloc SYS_ARCH_UNPROTECTs - * with each loop so that mem_free can run. - * - * ATTENTION: As you can see from the above description, this leads to dis-/ - * enabling interrupts often, which can be slow! Also, on low memory, mem_malloc - * can need longer. - * - * If you don't want that, at least for NO_SYS=0, you can still use the following - * functions to enqueue a deallocation call which then runs in the tcpip_thread - * context: - * - pbuf_free_callback(p); - * - mem_free_callback(m); - */ -#if !defined LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT || defined __DOXYGEN__ -#define LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT 0 -#endif -/** - * @} - */ - -/* - ------------------------------------------------ - ---------- Internal Memory Pool Sizes ---------- - ------------------------------------------------ -*/ -/** - * @defgroup lwip_opts_memp Internal memory pools - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF). - * If the application sends a lot of data out of ROM (or other static memory), - * this should be set high. - */ -#if !defined MEMP_NUM_PBUF || defined __DOXYGEN__ -#define MEMP_NUM_PBUF 16 -#endif - -/** - * MEMP_NUM_RAW_PCB: Number of raw connection PCBs - * (requires the LWIP_RAW option) - */ -#if !defined MEMP_NUM_RAW_PCB || defined __DOXYGEN__ -#define MEMP_NUM_RAW_PCB 4 -#endif - -/** - * MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One - * per active UDP "connection". - * (requires the LWIP_UDP option) - */ -#if !defined MEMP_NUM_UDP_PCB || defined __DOXYGEN__ -#define MEMP_NUM_UDP_PCB 4 -#endif - -/** - * MEMP_NUM_TCP_PCB: the number of simultaneously active TCP connections. - * (requires the LWIP_TCP option) - */ -#if !defined MEMP_NUM_TCP_PCB || defined __DOXYGEN__ -#define MEMP_NUM_TCP_PCB 5 -#endif - -/** - * MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections. - * (requires the LWIP_TCP option) - */ -#if !defined MEMP_NUM_TCP_PCB_LISTEN || defined __DOXYGEN__ -#define MEMP_NUM_TCP_PCB_LISTEN 8 -#endif - -/** - * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments. - * (requires the LWIP_TCP option) - */ -#if !defined MEMP_NUM_TCP_SEG || defined __DOXYGEN__ -#define MEMP_NUM_TCP_SEG 16 -#endif - -/** - * MEMP_NUM_ALTCP_PCB: the number of simultaneously active altcp layer pcbs. - * (requires the LWIP_ALTCP option) - * Connections with multiple layers require more than one altcp_pcb (e.g. TLS - * over TCP requires 2 altcp_pcbs, one for TLS and one for TCP). - */ -#if !defined MEMP_NUM_ALTCP_PCB || defined __DOXYGEN__ -#define MEMP_NUM_ALTCP_PCB MEMP_NUM_TCP_PCB -#endif - -/** - * MEMP_NUM_REASSDATA: the number of IP packets simultaneously queued for - * reassembly (whole packets, not fragments!) - */ -#if !defined MEMP_NUM_REASSDATA || defined __DOXYGEN__ -#define MEMP_NUM_REASSDATA 5 -#endif - -/** - * MEMP_NUM_FRAG_PBUF: the number of IP fragments simultaneously sent - * (fragments, not whole packets!). - * This is only used with LWIP_NETIF_TX_SINGLE_PBUF==0 and only has to be > 1 - * with DMA-enabled MACs where the packet is not yet sent when netif->output - * returns. - */ -#if !defined MEMP_NUM_FRAG_PBUF || defined __DOXYGEN__ -#define MEMP_NUM_FRAG_PBUF 15 -#endif - -/** - * MEMP_NUM_ARP_QUEUE: the number of simultaneously queued outgoing - * packets (pbufs) that are waiting for an ARP request (to resolve - * their destination address) to finish. - * (requires the ARP_QUEUEING option) - */ -#if !defined MEMP_NUM_ARP_QUEUE || defined __DOXYGEN__ -#define MEMP_NUM_ARP_QUEUE 30 -#endif - -/** - * MEMP_NUM_IGMP_GROUP: The number of multicast groups whose network interfaces - * can be members at the same time (one per netif - allsystems group -, plus one - * per netif membership). - * (requires the LWIP_IGMP option) - */ -#if !defined MEMP_NUM_IGMP_GROUP || defined __DOXYGEN__ -#define MEMP_NUM_IGMP_GROUP 8 -#endif - -/** - * The number of sys timeouts used by the core stack (not apps) - * The default number of timeouts is calculated here for all enabled modules. - */ -#define LWIP_NUM_SYS_TIMEOUT_INTERNAL (LWIP_TCP + IP_REASSEMBLY + LWIP_ARP + (2*LWIP_DHCP) + LWIP_AUTOIP + LWIP_IGMP + LWIP_DNS + PPP_NUM_TIMEOUTS + (LWIP_IPV6 * (1 + LWIP_IPV6_REASS + LWIP_IPV6_MLD))) - -/** - * MEMP_NUM_SYS_TIMEOUT: the number of simultaneously active timeouts. - * The default number of timeouts is calculated here for all enabled modules. - * The formula expects settings to be either '0' or '1'. - */ -#if !defined MEMP_NUM_SYS_TIMEOUT || defined __DOXYGEN__ -#define MEMP_NUM_SYS_TIMEOUT LWIP_NUM_SYS_TIMEOUT_INTERNAL -#endif - -/** - * MEMP_NUM_NETBUF: the number of struct netbufs. - * (only needed if you use the sequential API, like api_lib.c) - */ -#if !defined MEMP_NUM_NETBUF || defined __DOXYGEN__ -#define MEMP_NUM_NETBUF 2 -#endif - -/** - * MEMP_NUM_NETCONN: the number of struct netconns. - * (only needed if you use the sequential API, like api_lib.c) - */ -#if !defined MEMP_NUM_NETCONN || defined __DOXYGEN__ -#define MEMP_NUM_NETCONN 4 -#endif - -/** - * MEMP_NUM_SELECT_CB: the number of struct lwip_select_cb. - * (Only needed if you have LWIP_MPU_COMPATIBLE==1 and use the socket API. - * In that case, you need one per thread calling lwip_select.) - */ -#if !defined MEMP_NUM_SELECT_CB || defined __DOXYGEN__ -#define MEMP_NUM_SELECT_CB 4 -#endif - -/** - * MEMP_NUM_TCPIP_MSG_API: the number of struct tcpip_msg, which are used - * for callback/timeout API communication. - * (only needed if you use tcpip.c) - */ -#if !defined MEMP_NUM_TCPIP_MSG_API || defined __DOXYGEN__ -#define MEMP_NUM_TCPIP_MSG_API 8 -#endif - -/** - * MEMP_NUM_TCPIP_MSG_INPKT: the number of struct tcpip_msg, which are used - * for incoming packets. - * (only needed if you use tcpip.c) - */ -#if !defined MEMP_NUM_TCPIP_MSG_INPKT || defined __DOXYGEN__ -#define MEMP_NUM_TCPIP_MSG_INPKT 8 -#endif - -/** - * MEMP_NUM_NETDB: the number of concurrently running lwip_addrinfo() calls - * (before freeing the corresponding memory using lwip_freeaddrinfo()). - */ -#if !defined MEMP_NUM_NETDB || defined __DOXYGEN__ -#define MEMP_NUM_NETDB 1 -#endif - -/** - * MEMP_NUM_LOCALHOSTLIST: the number of host entries in the local host list - * if DNS_LOCAL_HOSTLIST_IS_DYNAMIC==1. - */ -#if !defined MEMP_NUM_LOCALHOSTLIST || defined __DOXYGEN__ -#define MEMP_NUM_LOCALHOSTLIST 1 -#endif - -/** - * PBUF_POOL_SIZE: the number of buffers in the pbuf pool. - */ -#if !defined PBUF_POOL_SIZE || defined __DOXYGEN__ -#define PBUF_POOL_SIZE 16 -#endif - -/** MEMP_NUM_API_MSG: the number of concurrently active calls to various - * socket, netconn, and tcpip functions - */ -#if !defined MEMP_NUM_API_MSG || defined __DOXYGEN__ -#define MEMP_NUM_API_MSG MEMP_NUM_TCPIP_MSG_API -#endif - -/** MEMP_NUM_DNS_API_MSG: the number of concurrently active calls to netconn_gethostbyname - */ -#if !defined MEMP_NUM_DNS_API_MSG || defined __DOXYGEN__ -#define MEMP_NUM_DNS_API_MSG MEMP_NUM_TCPIP_MSG_API -#endif - -/** MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA: the number of concurrently active calls - * to getsockopt/setsockopt - */ -#if !defined MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA || defined __DOXYGEN__ -#define MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA MEMP_NUM_TCPIP_MSG_API -#endif - -/** MEMP_NUM_NETIFAPI_MSG: the number of concurrently active calls to the - * netifapi functions - */ -#if !defined MEMP_NUM_NETIFAPI_MSG || defined __DOXYGEN__ -#define MEMP_NUM_NETIFAPI_MSG MEMP_NUM_TCPIP_MSG_API -#endif -/** - * @} - */ - -/* - --------------------------------- - ---------- ARP options ---------- - --------------------------------- -*/ -/** - * @defgroup lwip_opts_arp ARP - * @ingroup lwip_opts_ipv4 - * @{ - */ -/** - * LWIP_ARP==1: Enable ARP functionality. - */ -#if !defined LWIP_ARP || defined __DOXYGEN__ -#define LWIP_ARP 1 -#endif - -/** - * ARP_TABLE_SIZE: Number of active MAC-IP address pairs cached. - */ -#if !defined ARP_TABLE_SIZE || defined __DOXYGEN__ -#define ARP_TABLE_SIZE 10 -#endif - -/** the time an ARP entry stays valid after its last update, - * for ARP_TMR_INTERVAL = 1000, this is - * (60 * 5) seconds = 5 minutes. - */ -#if !defined ARP_MAXAGE || defined __DOXYGEN__ -#define ARP_MAXAGE 300 -#endif - -/** - * ARP_QUEUEING==1: Multiple outgoing packets are queued during hardware address - * resolution. By default, only the most recent packet is queued per IP address. - * This is sufficient for most protocols and mainly reduces TCP connection - * startup time. Set this to 1 if you know your application sends more than one - * packet in a row to an IP address that is not in the ARP cache. - */ -#if !defined ARP_QUEUEING || defined __DOXYGEN__ -#define ARP_QUEUEING 0 -#endif - -/** The maximum number of packets which may be queued for each - * unresolved address by other network layers. Defaults to 3, 0 means disabled. - * Old packets are dropped, new packets are queued. - */ -#if !defined ARP_QUEUE_LEN || defined __DOXYGEN__ -#define ARP_QUEUE_LEN 3 -#endif - -/** - * ETHARP_SUPPORT_VLAN==1: support receiving and sending ethernet packets with - * VLAN header. See the description of LWIP_HOOK_VLAN_CHECK and - * LWIP_HOOK_VLAN_SET hooks to check/set VLAN headers. - * Additionally, you can define ETHARP_VLAN_CHECK to an u16_t VLAN ID to check. - * If ETHARP_VLAN_CHECK is defined, only VLAN-traffic for this VLAN is accepted. - * If ETHARP_VLAN_CHECK is not defined, all traffic is accepted. - * Alternatively, define a function/define ETHARP_VLAN_CHECK_FN(eth_hdr, vlan) - * that returns 1 to accept a packet or 0 to drop a packet. - */ -#if !defined ETHARP_SUPPORT_VLAN || defined __DOXYGEN__ -#define ETHARP_SUPPORT_VLAN 0 -#endif - -/** LWIP_ETHERNET==1: enable ethernet support even though ARP might be disabled - */ -#if !defined LWIP_ETHERNET || defined __DOXYGEN__ -#define LWIP_ETHERNET LWIP_ARP -#endif - -/** ETH_PAD_SIZE: number of bytes added before the ethernet header to ensure - * alignment of payload after that header. Since the header is 14 bytes long, - * without this padding e.g. addresses in the IP header will not be aligned - * on a 32-bit boundary, so setting this to 2 can speed up 32-bit-platforms. - */ -#if !defined ETH_PAD_SIZE || defined __DOXYGEN__ -#define ETH_PAD_SIZE 0 -#endif - -/** ETHARP_SUPPORT_STATIC_ENTRIES==1: enable code to support static ARP table - * entries (using etharp_add_static_entry/etharp_remove_static_entry). - */ -#if !defined ETHARP_SUPPORT_STATIC_ENTRIES || defined __DOXYGEN__ -#define ETHARP_SUPPORT_STATIC_ENTRIES 0 -#endif - -/** ETHARP_TABLE_MATCH_NETIF==1: Match netif for ARP table entries. - * If disabled, duplicate IP address on multiple netifs are not supported - * (but this should only occur for AutoIP). - */ -#if !defined ETHARP_TABLE_MATCH_NETIF || defined __DOXYGEN__ -#define ETHARP_TABLE_MATCH_NETIF !LWIP_SINGLE_NETIF -#endif -/** - * @} - */ - -/* - -------------------------------- - ---------- IP options ---------- - -------------------------------- -*/ -/** - * @defgroup lwip_opts_ipv4 IPv4 - * @ingroup lwip_opts - * @{ - */ -/** - * LWIP_IPV4==1: Enable IPv4 - */ -#if !defined LWIP_IPV4 || defined __DOXYGEN__ -#define LWIP_IPV4 1 -#endif - -/** - * IP_FORWARD==1: Enables the ability to forward IP packets across network - * interfaces. If you are going to run lwIP on a device with only one network - * interface, define this to 0. - */ -#if !defined IP_FORWARD || defined __DOXYGEN__ -#define IP_FORWARD 0 -#endif - -/** - * IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that - * this option does not affect outgoing packet sizes, which can be controlled - * via IP_FRAG. - */ -#if !defined IP_REASSEMBLY || defined __DOXYGEN__ -#define IP_REASSEMBLY 1 -#endif - -/** - * IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note - * that this option does not affect incoming packet sizes, which can be - * controlled via IP_REASSEMBLY. - */ -#if !defined IP_FRAG || defined __DOXYGEN__ -#define IP_FRAG 1 -#endif - -#if !LWIP_IPV4 -/* disable IPv4 extensions when IPv4 is disabled */ -#undef IP_FORWARD -#define IP_FORWARD 0 -#undef IP_REASSEMBLY -#define IP_REASSEMBLY 0 -#undef IP_FRAG -#define IP_FRAG 0 -#endif /* !LWIP_IPV4 */ - -/** - * IP_OPTIONS_ALLOWED: Defines the behavior for IP options. - * IP_OPTIONS_ALLOWED==0: All packets with IP options are dropped. - * IP_OPTIONS_ALLOWED==1: IP options are allowed (but not parsed). - */ -#if !defined IP_OPTIONS_ALLOWED || defined __DOXYGEN__ -#define IP_OPTIONS_ALLOWED 1 -#endif - -/** - * IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally) - * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived - * in this time, the whole packet is discarded. - */ -#if !defined IP_REASS_MAXAGE || defined __DOXYGEN__ -#define IP_REASS_MAXAGE 15 -#endif - -/** - * IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled. - * Since the received pbufs are enqueued, be sure to configure - * PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive - * packets even if the maximum amount of fragments is enqueued for reassembly! - * When IPv4 *and* IPv6 are enabled, this even changes to - * (PBUF_POOL_SIZE > 2 * IP_REASS_MAX_PBUFS)! - */ -#if !defined IP_REASS_MAX_PBUFS || defined __DOXYGEN__ -#define IP_REASS_MAX_PBUFS 10 -#endif - -/** - * IP_DEFAULT_TTL: Default value for Time-To-Live used by transport layers. - */ -#if !defined IP_DEFAULT_TTL || defined __DOXYGEN__ -#define IP_DEFAULT_TTL 255 -#endif - -/** - * IP_SOF_BROADCAST=1: Use the SOF_BROADCAST field to enable broadcast - * filter per pcb on udp and raw send operations. To enable broadcast filter - * on recv operations, you also have to set IP_SOF_BROADCAST_RECV=1. - */ -#if !defined IP_SOF_BROADCAST || defined __DOXYGEN__ -#define IP_SOF_BROADCAST 0 -#endif - -/** - * IP_SOF_BROADCAST_RECV (requires IP_SOF_BROADCAST=1) enable the broadcast - * filter on recv operations. - */ -#if !defined IP_SOF_BROADCAST_RECV || defined __DOXYGEN__ -#define IP_SOF_BROADCAST_RECV 0 -#endif - -/** - * IP_FORWARD_ALLOW_TX_ON_RX_NETIF==1: allow ip_forward() to send packets back - * out on the netif where it was received. This should only be used for - * wireless networks. - * ATTENTION: When this is 1, make sure your netif driver correctly marks incoming - * link-layer-broadcast/multicast packets as such using the corresponding pbuf flags! - */ -#if !defined IP_FORWARD_ALLOW_TX_ON_RX_NETIF || defined __DOXYGEN__ -#define IP_FORWARD_ALLOW_TX_ON_RX_NETIF 0 -#endif -/** - * @} - */ - -/* - ---------------------------------- - ---------- ICMP options ---------- - ---------------------------------- -*/ -/** - * @defgroup lwip_opts_icmp ICMP - * @ingroup lwip_opts_ipv4 - * @{ - */ -/** - * LWIP_ICMP==1: Enable ICMP module inside the IP stack. - * Be careful, disable that make your product non-compliant to RFC1122 - */ -#if !defined LWIP_ICMP || defined __DOXYGEN__ -#define LWIP_ICMP 1 -#endif - -/** - * ICMP_TTL: Default value for Time-To-Live used by ICMP packets. - */ -#if !defined ICMP_TTL || defined __DOXYGEN__ -#define ICMP_TTL IP_DEFAULT_TTL -#endif - -/** - * LWIP_BROADCAST_PING==1: respond to broadcast pings (default is unicast only) - */ -#if !defined LWIP_BROADCAST_PING || defined __DOXYGEN__ -#define LWIP_BROADCAST_PING 0 -#endif - -/** - * LWIP_MULTICAST_PING==1: respond to multicast pings (default is unicast only) - */ -#if !defined LWIP_MULTICAST_PING || defined __DOXYGEN__ -#define LWIP_MULTICAST_PING 0 -#endif -/** - * @} - */ - -/* - --------------------------------- - ---------- RAW options ---------- - --------------------------------- -*/ -/** - * @defgroup lwip_opts_raw RAW - * @ingroup lwip_opts_callback - * @{ - */ -/** - * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. - */ -#if !defined LWIP_RAW || defined __DOXYGEN__ -#define LWIP_RAW 0 -#endif - -/** - * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. - */ -#if !defined RAW_TTL || defined __DOXYGEN__ -#define RAW_TTL IP_DEFAULT_TTL -#endif -/** - * @} - */ - -/* - ---------------------------------- - ---------- DHCP options ---------- - ---------------------------------- -*/ -/** - * @defgroup lwip_opts_dhcp DHCP - * @ingroup lwip_opts_ipv4 - * @{ - */ -/** - * LWIP_DHCP==1: Enable DHCP module. - */ -#if !defined LWIP_DHCP || defined __DOXYGEN__ -#define LWIP_DHCP 0 -#endif -#if !LWIP_IPV4 -/* disable DHCP when IPv4 is disabled */ -#undef LWIP_DHCP -#define LWIP_DHCP 0 -#endif /* !LWIP_IPV4 */ - -/** - * DHCP_DOES_ARP_CHECK==1: Do an ARP check on the offered address. - */ -#if !defined DHCP_DOES_ARP_CHECK || defined __DOXYGEN__ -#define DHCP_DOES_ARP_CHECK (LWIP_DHCP && LWIP_ARP) -#endif - -/** - * LWIP_DHCP_BOOTP_FILE==1: Store offered_si_addr and boot_file_name. - */ -#if !defined LWIP_DHCP_BOOTP_FILE || defined __DOXYGEN__ -#define LWIP_DHCP_BOOTP_FILE 0 -#endif - -/** - * LWIP_DHCP_GETS_NTP==1: Request NTP servers with discover/select. For each - * response packet, an callback is called, which has to be provided by the port: - * void dhcp_set_ntp_servers(u8_t num_ntp_servers, ip_addr_t* ntp_server_addrs); -*/ -#if !defined LWIP_DHCP_GET_NTP_SRV || defined __DOXYGEN__ -#define LWIP_DHCP_GET_NTP_SRV 0 -#endif - -/** - * The maximum of NTP servers requested - */ -#if !defined LWIP_DHCP_MAX_NTP_SERVERS || defined __DOXYGEN__ -#define LWIP_DHCP_MAX_NTP_SERVERS 1 -#endif - -/** - * LWIP_DHCP_MAX_DNS_SERVERS > 0: Request DNS servers with discover/select. - * DNS servers received in the response are passed to DNS via @ref dns_setserver() - * (up to the maximum limit defined here). - */ -#if !defined LWIP_DHCP_MAX_DNS_SERVERS || defined __DOXYGEN__ -#define LWIP_DHCP_MAX_DNS_SERVERS DNS_MAX_SERVERS -#endif -/** - * @} - */ - -/* - ------------------------------------ - ---------- AUTOIP options ---------- - ------------------------------------ -*/ -/** - * @defgroup lwip_opts_autoip AUTOIP - * @ingroup lwip_opts_ipv4 - * @{ - */ -/** - * LWIP_AUTOIP==1: Enable AUTOIP module. - */ -#if !defined LWIP_AUTOIP || defined __DOXYGEN__ -#define LWIP_AUTOIP 0 -#endif -#if !LWIP_IPV4 -/* disable AUTOIP when IPv4 is disabled */ -#undef LWIP_AUTOIP -#define LWIP_AUTOIP 0 -#endif /* !LWIP_IPV4 */ - -/** - * LWIP_DHCP_AUTOIP_COOP==1: Allow DHCP and AUTOIP to be both enabled on - * the same interface at the same time. - */ -#if !defined LWIP_DHCP_AUTOIP_COOP || defined __DOXYGEN__ -#define LWIP_DHCP_AUTOIP_COOP 0 -#endif - -/** - * LWIP_DHCP_AUTOIP_COOP_TRIES: Set to the number of DHCP DISCOVER probes - * that should be sent before falling back on AUTOIP (the DHCP client keeps - * running in this case). This can be set as low as 1 to get an AutoIP address - * very quickly, but you should be prepared to handle a changing IP address - * when DHCP overrides AutoIP. - */ -#if !defined LWIP_DHCP_AUTOIP_COOP_TRIES || defined __DOXYGEN__ -#define LWIP_DHCP_AUTOIP_COOP_TRIES 9 -#endif -/** - * @} - */ - -/* - ---------------------------------- - ----- SNMP MIB2 support ----- - ---------------------------------- -*/ -/** - * @defgroup lwip_opts_mib2 SNMP MIB2 callbacks - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * LWIP_MIB2_CALLBACKS==1: Turn on SNMP MIB2 callbacks. - * Turn this on to get callbacks needed to implement MIB2. - * Usually MIB2_STATS should be enabled, too. - */ -#if !defined LWIP_MIB2_CALLBACKS || defined __DOXYGEN__ -#define LWIP_MIB2_CALLBACKS 0 -#endif -/** - * @} - */ - -/* - ---------------------------------- - -------- Multicast options ------- - ---------------------------------- -*/ -/** - * @defgroup lwip_opts_multicast Multicast - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * LWIP_MULTICAST_TX_OPTIONS==1: Enable multicast TX support like the socket options - * IP_MULTICAST_TTL/IP_MULTICAST_IF/IP_MULTICAST_LOOP, as well as (currently only) - * core support for the corresponding IPv6 options. - */ -#if !defined LWIP_MULTICAST_TX_OPTIONS || defined __DOXYGEN__ -#define LWIP_MULTICAST_TX_OPTIONS ((LWIP_IGMP || LWIP_IPV6_MLD) && (LWIP_UDP || LWIP_RAW)) -#endif -/** - * @} - */ - -/* - ---------------------------------- - ---------- IGMP options ---------- - ---------------------------------- -*/ -/** - * @defgroup lwip_opts_igmp IGMP - * @ingroup lwip_opts_ipv4 - * @{ - */ -/** - * LWIP_IGMP==1: Turn on IGMP module. - */ -#if !defined LWIP_IGMP || defined __DOXYGEN__ -#define LWIP_IGMP 0 -#endif -#if !LWIP_IPV4 -#undef LWIP_IGMP -#define LWIP_IGMP 0 -#endif -/** - * @} - */ - -/* - ---------------------------------- - ---------- DNS options ----------- - ---------------------------------- -*/ -/** - * @defgroup lwip_opts_dns DNS - * @ingroup lwip_opts_callback - * @{ - */ -/** - * LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS - * transport. - */ -#if !defined LWIP_DNS || defined __DOXYGEN__ -#define LWIP_DNS 0 -#endif - -/** DNS maximum number of entries to maintain locally. */ -#if !defined DNS_TABLE_SIZE || defined __DOXYGEN__ -#define DNS_TABLE_SIZE 4 -#endif - -/** DNS maximum host name length supported in the name table. */ -#if !defined DNS_MAX_NAME_LENGTH || defined __DOXYGEN__ -#define DNS_MAX_NAME_LENGTH 256 -#endif - -/** The maximum of DNS servers - * The first server can be initialized automatically by defining - * DNS_SERVER_ADDRESS(ipaddr), where 'ipaddr' is an 'ip_addr_t*' - */ -#if !defined DNS_MAX_SERVERS || defined __DOXYGEN__ -#define DNS_MAX_SERVERS 2 -#endif - -/** DNS maximum number of retries when asking for a name, before "timeout". */ -#if !defined DNS_MAX_RETRIES || defined __DOXYGEN__ -#define DNS_MAX_RETRIES 4 -#endif - -/** DNS do a name checking between the query and the response. */ -#if !defined DNS_DOES_NAME_CHECK || defined __DOXYGEN__ -#define DNS_DOES_NAME_CHECK 1 -#endif - -/** LWIP_DNS_SECURE: controls the security level of the DNS implementation - * Use all DNS security features by default. - * This is overridable but should only be needed by very small targets - * or when using against non standard DNS servers. */ -#if !defined LWIP_DNS_SECURE || defined __DOXYGEN__ -#define LWIP_DNS_SECURE (LWIP_DNS_SECURE_RAND_XID | LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING | LWIP_DNS_SECURE_RAND_SRC_PORT) -#endif - -/* A list of DNS security features follows */ -#define LWIP_DNS_SECURE_RAND_XID 1 -#define LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING 2 -#define LWIP_DNS_SECURE_RAND_SRC_PORT 4 - -/** DNS_LOCAL_HOSTLIST: Implements a local host-to-address list. If enabled, you have to define an initializer: - * \#define DNS_LOCAL_HOSTLIST_INIT {DNS_LOCAL_HOSTLIST_ELEM("host_ip4", IPADDR4_INIT_BYTES(1,2,3,4)), \ - * DNS_LOCAL_HOSTLIST_ELEM("host_ip6", IPADDR6_INIT_HOST(123, 234, 345, 456)} - * - * Instead, you can also use an external function: - * \#define DNS_LOOKUP_LOCAL_EXTERN(x) extern err_t my_lookup_function(const char *name, ip_addr_t *addr, u8_t dns_addrtype) - * that looks up the IP address and returns ERR_OK if found (LWIP_DNS_ADDRTYPE_xxx is passed in dns_addrtype). - */ -#if !defined DNS_LOCAL_HOSTLIST || defined __DOXYGEN__ -#define DNS_LOCAL_HOSTLIST 0 -#endif /* DNS_LOCAL_HOSTLIST */ - -/** If this is turned on, the local host-list can be dynamically changed - * at runtime. */ -#if !defined DNS_LOCAL_HOSTLIST_IS_DYNAMIC || defined __DOXYGEN__ -#define DNS_LOCAL_HOSTLIST_IS_DYNAMIC 0 -#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - -/** Set this to 1 to enable querying ".local" names via mDNS - * using a One-Shot Multicast DNS Query */ -#if !defined LWIP_DNS_SUPPORT_MDNS_QUERIES || defined __DOXYGEN__ -#define LWIP_DNS_SUPPORT_MDNS_QUERIES 0 -#endif -/** - * @} - */ - -/* - --------------------------------- - ---------- UDP options ---------- - --------------------------------- -*/ -/** - * @defgroup lwip_opts_udp UDP - * @ingroup lwip_opts_callback - * @{ - */ -/** - * LWIP_UDP==1: Turn on UDP. - */ -#if !defined LWIP_UDP || defined __DOXYGEN__ -#define LWIP_UDP 1 -#endif - -/** - * LWIP_UDPLITE==1: Turn on UDP-Lite. (Requires LWIP_UDP) - */ -#if !defined LWIP_UDPLITE || defined __DOXYGEN__ -#define LWIP_UDPLITE 0 -#endif - -/** - * UDP_TTL: Default Time-To-Live value. - */ -#if !defined UDP_TTL || defined __DOXYGEN__ -#define UDP_TTL IP_DEFAULT_TTL -#endif - -/** - * LWIP_NETBUF_RECVINFO==1: append destination addr and port to every netbuf. - */ -#if !defined LWIP_NETBUF_RECVINFO || defined __DOXYGEN__ -#define LWIP_NETBUF_RECVINFO 0 -#endif -/** - * @} - */ - -/* - --------------------------------- - ---------- TCP options ---------- - --------------------------------- -*/ -/** - * @defgroup lwip_opts_tcp TCP - * @ingroup lwip_opts_callback - * @{ - */ -/** - * LWIP_TCP==1: Turn on TCP. - */ -#if !defined LWIP_TCP || defined __DOXYGEN__ -#define LWIP_TCP 1 -#endif - -/** - * TCP_TTL: Default Time-To-Live value. - */ -#if !defined TCP_TTL || defined __DOXYGEN__ -#define TCP_TTL IP_DEFAULT_TTL -#endif - -/** - * TCP_WND: The size of a TCP window. This must be at least - * (2 * TCP_MSS) for things to work well. - * ATTENTION: when using TCP_RCV_SCALE, TCP_WND is the total size - * with scaling applied. Maximum window value in the TCP header - * will be TCP_WND >> TCP_RCV_SCALE - */ -#if !defined TCP_WND || defined __DOXYGEN__ -#define TCP_WND (4 * TCP_MSS) -#endif - -/** - * TCP_MAXRTX: Maximum number of retransmissions of data segments. - */ -#if !defined TCP_MAXRTX || defined __DOXYGEN__ -#define TCP_MAXRTX 12 -#endif - -/** - * TCP_SYNMAXRTX: Maximum number of retransmissions of SYN segments. - */ -#if !defined TCP_SYNMAXRTX || defined __DOXYGEN__ -#define TCP_SYNMAXRTX 6 -#endif - -/** - * TCP_QUEUE_OOSEQ==1: TCP will queue segments that arrive out of order. - * Define to 0 if your device is low on memory. - */ -#if !defined TCP_QUEUE_OOSEQ || defined __DOXYGEN__ -#define TCP_QUEUE_OOSEQ LWIP_TCP -#endif - -/** - * LWIP_TCP_SACK_OUT==1: TCP will support sending selective acknowledgements (SACKs). - */ -#if !defined LWIP_TCP_SACK_OUT || defined __DOXYGEN__ -#define LWIP_TCP_SACK_OUT 0 -#endif - -/** - * LWIP_TCP_MAX_SACK_NUM: The maximum number of SACK values to include in TCP segments. - * Must be at least 1, but is only used if LWIP_TCP_SACK_OUT is enabled. - * NOTE: Even though we never send more than 3 or 4 SACK ranges in a single segment - * (depending on other options), setting this option to values greater than 4 is not pointless. - * This is basically the max number of SACK ranges we want to keep track of. - * As new data is delivered, some of the SACK ranges may be removed or merged. - * In that case some of those older SACK ranges may be used again. - * The amount of memory used to store SACK ranges is LWIP_TCP_MAX_SACK_NUM * 8 bytes for each TCP PCB. - */ -#if !defined LWIP_TCP_MAX_SACK_NUM || defined __DOXYGEN__ -#define LWIP_TCP_MAX_SACK_NUM 4 -#endif - -/** - * TCP_MSS: TCP Maximum segment size. (default is 536, a conservative default, - * you might want to increase this.) - * For the receive side, this MSS is advertised to the remote side - * when opening a connection. For the transmit size, this MSS sets - * an upper limit on the MSS advertised by the remote host. - */ -#if !defined TCP_MSS || defined __DOXYGEN__ -#define TCP_MSS 536 -#endif - -/** - * TCP_CALCULATE_EFF_SEND_MSS: "The maximum size of a segment that TCP really - * sends, the 'effective send MSS,' MUST be the smaller of the send MSS (which - * reflects the available reassembly buffer size at the remote host) and the - * largest size permitted by the IP layer" (RFC 1122) - * Setting this to 1 enables code that checks TCP_MSS against the MTU of the - * netif used for a connection and limits the MSS if it would be too big otherwise. - */ -#if !defined TCP_CALCULATE_EFF_SEND_MSS || defined __DOXYGEN__ -#define TCP_CALCULATE_EFF_SEND_MSS 1 -#endif - - -/** - * TCP_SND_BUF: TCP sender buffer space (bytes). - * To achieve good performance, this should be at least 2 * TCP_MSS. - */ -#if !defined TCP_SND_BUF || defined __DOXYGEN__ -#define TCP_SND_BUF (2 * TCP_MSS) -#endif - -/** - * TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least - * as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. - */ -#if !defined TCP_SND_QUEUELEN || defined __DOXYGEN__ -#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1))/(TCP_MSS)) -#endif - -/** - * TCP_SNDLOWAT: TCP writable space (bytes). This must be less than - * TCP_SND_BUF. It is the amount of space which must be available in the - * TCP snd_buf for select to return writable (combined with TCP_SNDQUEUELOWAT). - */ -#if !defined TCP_SNDLOWAT || defined __DOXYGEN__ -#define TCP_SNDLOWAT LWIP_MIN(LWIP_MAX(((TCP_SND_BUF)/2), (2 * TCP_MSS) + 1), (TCP_SND_BUF) - 1) -#endif - -/** - * TCP_SNDQUEUELOWAT: TCP writable bufs (pbuf count). This must be less - * than TCP_SND_QUEUELEN. If the number of pbufs queued on a pcb drops below - * this number, select returns writable (combined with TCP_SNDLOWAT). - */ -#if !defined TCP_SNDQUEUELOWAT || defined __DOXYGEN__ -#define TCP_SNDQUEUELOWAT LWIP_MAX(((TCP_SND_QUEUELEN)/2), 5) -#endif - -/** - * TCP_OOSEQ_MAX_BYTES: The default maximum number of bytes queued on ooseq per - * pcb if TCP_OOSEQ_BYTES_LIMIT is not defined. Default is 0 (no limit). - * Only valid for TCP_QUEUE_OOSEQ==1. - */ -#if !defined TCP_OOSEQ_MAX_BYTES || defined __DOXYGEN__ -#define TCP_OOSEQ_MAX_BYTES 0 -#endif - -/** - * TCP_OOSEQ_BYTES_LIMIT(pcb): Return the maximum number of bytes to be queued - * on ooseq per pcb, given the pcb. Only valid for TCP_QUEUE_OOSEQ==1 && - * TCP_OOSEQ_MAX_BYTES==1. - * Use this to override TCP_OOSEQ_MAX_BYTES to a dynamic value per pcb. - */ -#if !defined TCP_OOSEQ_BYTES_LIMIT -#if TCP_OOSEQ_MAX_BYTES -#define TCP_OOSEQ_BYTES_LIMIT(pcb) TCP_OOSEQ_MAX_BYTES -#elif defined __DOXYGEN__ -#define TCP_OOSEQ_BYTES_LIMIT(pcb) -#endif -#endif - -/** - * TCP_OOSEQ_MAX_PBUFS: The default maximum number of pbufs queued on ooseq per - * pcb if TCP_OOSEQ_BYTES_LIMIT is not defined. Default is 0 (no limit). - * Only valid for TCP_QUEUE_OOSEQ==1. - */ -#if !defined TCP_OOSEQ_MAX_PBUFS || defined __DOXYGEN__ -#define TCP_OOSEQ_MAX_PBUFS 0 -#endif - -/** - * TCP_OOSEQ_PBUFS_LIMIT(pcb): Return the maximum number of pbufs to be queued - * on ooseq per pcb, given the pcb. Only valid for TCP_QUEUE_OOSEQ==1 && - * TCP_OOSEQ_MAX_PBUFS==1. - * Use this to override TCP_OOSEQ_MAX_PBUFS to a dynamic value per pcb. - */ -#if !defined TCP_OOSEQ_PBUFS_LIMIT -#if TCP_OOSEQ_MAX_PBUFS -#define TCP_OOSEQ_PBUFS_LIMIT(pcb) TCP_OOSEQ_MAX_PBUFS -#elif defined __DOXYGEN__ -#define TCP_OOSEQ_PBUFS_LIMIT(pcb) -#endif -#endif - -/** - * TCP_LISTEN_BACKLOG: Enable the backlog option for tcp listen pcb. - */ -#if !defined TCP_LISTEN_BACKLOG || defined __DOXYGEN__ -#define TCP_LISTEN_BACKLOG 0 -#endif - -/** - * The maximum allowed backlog for TCP listen netconns. - * This backlog is used unless another is explicitly specified. - * 0xff is the maximum (u8_t). - */ -#if !defined TCP_DEFAULT_LISTEN_BACKLOG || defined __DOXYGEN__ -#define TCP_DEFAULT_LISTEN_BACKLOG 0xff -#endif - -/** - * TCP_OVERSIZE: The maximum number of bytes that tcp_write may - * allocate ahead of time in an attempt to create shorter pbuf chains - * for transmission. The meaningful range is 0 to TCP_MSS. Some - * suggested values are: - * - * 0: Disable oversized allocation. Each tcp_write() allocates a new - pbuf (old behaviour). - * 1: Allocate size-aligned pbufs with minimal excess. Use this if your - * scatter-gather DMA requires aligned fragments. - * 128: Limit the pbuf/memory overhead to 20%. - * TCP_MSS: Try to create unfragmented TCP packets. - * TCP_MSS/4: Try to create 4 fragments or less per TCP packet. - */ -#if !defined TCP_OVERSIZE || defined __DOXYGEN__ -#define TCP_OVERSIZE TCP_MSS -#endif - -/** - * LWIP_TCP_TIMESTAMPS==1: support the TCP timestamp option. - * The timestamp option is currently only used to help remote hosts, it is not - * really used locally. Therefore, it is only enabled when a TS option is - * received in the initial SYN packet from a remote host. - */ -#if !defined LWIP_TCP_TIMESTAMPS || defined __DOXYGEN__ -#define LWIP_TCP_TIMESTAMPS 0 -#endif - -/** - * TCP_WND_UPDATE_THRESHOLD: difference in window to trigger an - * explicit window update - */ -#if !defined TCP_WND_UPDATE_THRESHOLD || defined __DOXYGEN__ -#define TCP_WND_UPDATE_THRESHOLD LWIP_MIN((TCP_WND / 4), (TCP_MSS * 4)) -#endif - -/** - * LWIP_EVENT_API and LWIP_CALLBACK_API: Only one of these should be set to 1. - * LWIP_EVENT_API==1: The user defines lwip_tcp_event() to receive all - * events (accept, sent, etc) that happen in the system. - * LWIP_CALLBACK_API==1: The PCB callback function is called directly - * for the event. This is the default. - */ -#if !defined(LWIP_EVENT_API) && !defined(LWIP_CALLBACK_API) || defined __DOXYGEN__ -#define LWIP_EVENT_API 0 -#define LWIP_CALLBACK_API 1 -#else -#ifndef LWIP_EVENT_API -#define LWIP_EVENT_API 0 -#endif -#ifndef LWIP_CALLBACK_API -#define LWIP_CALLBACK_API 0 -#endif -#endif - -/** - * LWIP_WND_SCALE and TCP_RCV_SCALE: - * Set LWIP_WND_SCALE to 1 to enable window scaling. - * Set TCP_RCV_SCALE to the desired scaling factor (shift count in the - * range of [0..14]). - * When LWIP_WND_SCALE is enabled but TCP_RCV_SCALE is 0, we can use a large - * send window while having a small receive window only. - */ -#if !defined LWIP_WND_SCALE || defined __DOXYGEN__ -#define LWIP_WND_SCALE 0 -#define TCP_RCV_SCALE 0 -#endif - -/** - * LWIP_TCP_PCB_NUM_EXT_ARGS: - * When this is > 0, every tcp pcb (including listen pcb) includes a number of - * additional argument entries in an array (see tcp_ext_arg_alloc_id) - */ -#if !defined LWIP_TCP_PCB_NUM_EXT_ARGS || defined __DOXYGEN__ -#define LWIP_TCP_PCB_NUM_EXT_ARGS 0 -#endif - -/** LWIP_ALTCP==1: enable the altcp API. - * altcp is an abstraction layer that prevents applications linking against the - * tcp.h functions but provides the same functionality. It is used to e.g. add - * SSL/TLS or proxy-connect support to an application written for the tcp callback - * API without that application knowing the protocol details. - * - * With LWIP_ALTCP==0, applications written against the altcp API can still be - * compiled but are directly linked against the tcp.h callback API and then - * cannot use layered protocols. - * - * See @ref altcp_api - */ -#if !defined LWIP_ALTCP || defined __DOXYGEN__ -#define LWIP_ALTCP 0 -#endif - -/** LWIP_ALTCP_TLS==1: enable TLS support for altcp API. - * This needs a port of the functions in altcp_tls.h to a TLS library. - * A port to ARM mbedtls is provided with lwIP, see apps/altcp_tls/ directory - * and LWIP_ALTCP_TLS_MBEDTLS option. - */ -#if !defined LWIP_ALTCP_TLS || defined __DOXYGEN__ -#define LWIP_ALTCP_TLS 0 -#endif - -/** - * @} - */ - -/* - ---------------------------------- - ---------- Pbuf options ---------- - ---------------------------------- -*/ -/** - * @defgroup lwip_opts_pbuf PBUF - * @ingroup lwip_opts - * @{ - */ -/** - * PBUF_LINK_HLEN: the number of bytes that should be allocated for a - * link level header. The default is 14, the standard value for - * Ethernet. - */ -#if !defined PBUF_LINK_HLEN || defined __DOXYGEN__ -#if defined LWIP_HOOK_VLAN_SET && !defined __DOXYGEN__ -#define PBUF_LINK_HLEN (18 + ETH_PAD_SIZE) -#else /* LWIP_HOOK_VLAN_SET */ -#define PBUF_LINK_HLEN (14 + ETH_PAD_SIZE) -#endif /* LWIP_HOOK_VLAN_SET */ -#endif - -/** - * PBUF_LINK_ENCAPSULATION_HLEN: the number of bytes that should be allocated - * for an additional encapsulation header before ethernet headers (e.g. 802.11) - */ -#if !defined PBUF_LINK_ENCAPSULATION_HLEN || defined __DOXYGEN__ -#define PBUF_LINK_ENCAPSULATION_HLEN 0 -#endif - -/** - * PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. The default is - * designed to accommodate single full size TCP frame in one pbuf, including - * TCP_MSS, IP header, and link header. - */ -#if !defined PBUF_POOL_BUFSIZE || defined __DOXYGEN__ -#define PBUF_POOL_BUFSIZE LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_ENCAPSULATION_HLEN+PBUF_LINK_HLEN) -#endif - -/** - * LWIP_PBUF_REF_T: Refcount type in pbuf. - * Default width of u8_t can be increased if 255 refs are not enough for you. - */ -#if !defined LWIP_PBUF_REF_T || defined __DOXYGEN__ -#define LWIP_PBUF_REF_T u8_t -#endif -/** - * @} - */ - -/* - ------------------------------------------------ - ---------- Network Interfaces options ---------- - ------------------------------------------------ -*/ -/** - * @defgroup lwip_opts_netif NETIF - * @ingroup lwip_opts - * @{ - */ -/** - * LWIP_SINGLE_NETIF==1: use a single netif only. This is the common case for - * small real-life targets. Some code like routing etc. can be left out. - */ -#if !defined LWIP_SINGLE_NETIF || defined __DOXYGEN__ -#define LWIP_SINGLE_NETIF 0 -#endif - -/** - * LWIP_NETIF_HOSTNAME==1: use DHCP_OPTION_HOSTNAME with netif's hostname - * field. - */ -#if !defined LWIP_NETIF_HOSTNAME || defined __DOXYGEN__ -#define LWIP_NETIF_HOSTNAME 0 -#endif - -/** - * LWIP_NETIF_API==1: Support netif api (in netifapi.c) - */ -#if !defined LWIP_NETIF_API || defined __DOXYGEN__ -#define LWIP_NETIF_API 0 -#endif - -/** - * LWIP_NETIF_STATUS_CALLBACK==1: Support a callback function whenever an interface - * changes its up/down status (i.e., due to DHCP IP acquisition) - */ -#if !defined LWIP_NETIF_STATUS_CALLBACK || defined __DOXYGEN__ -#define LWIP_NETIF_STATUS_CALLBACK 0 -#endif - -/** - * LWIP_NETIF_EXT_STATUS_CALLBACK==1: Support an extended callback function - * for several netif related event that supports multiple subscribers. - * @see netif_ext_status_callback - */ -#if !defined LWIP_NETIF_EXT_STATUS_CALLBACK || defined __DOXYGEN__ -#define LWIP_NETIF_EXT_STATUS_CALLBACK 0 -#endif - -/** - * LWIP_NETIF_LINK_CALLBACK==1: Support a callback function from an interface - * whenever the link changes (i.e., link down) - */ -#if !defined LWIP_NETIF_LINK_CALLBACK || defined __DOXYGEN__ -#define LWIP_NETIF_LINK_CALLBACK 0 -#endif - -/** - * LWIP_NETIF_REMOVE_CALLBACK==1: Support a callback function that is called - * when a netif has been removed - */ -#if !defined LWIP_NETIF_REMOVE_CALLBACK || defined __DOXYGEN__ -#define LWIP_NETIF_REMOVE_CALLBACK 0 -#endif - -/** - * LWIP_NETIF_HWADDRHINT==1: Cache link-layer-address hints (e.g. table - * indices) in struct netif. TCP and UDP can make use of this to prevent - * scanning the ARP table for every sent packet. While this is faster for big - * ARP tables or many concurrent connections, it might be counterproductive - * if you have a tiny ARP table or if there never are concurrent connections. - */ -#if !defined LWIP_NETIF_HWADDRHINT || defined __DOXYGEN__ -#define LWIP_NETIF_HWADDRHINT 0 -#endif - -/** - * LWIP_NETIF_TX_SINGLE_PBUF: if this is set to 1, lwIP *tries* to put all data - * to be sent into one single pbuf. This is for compatibility with DMA-enabled - * MACs that do not support scatter-gather. - * Beware that this might involve CPU-memcpy before transmitting that would not - * be needed without this flag! Use this only if you need to! - * - * ATTENTION: a driver should *NOT* rely on getting single pbufs but check TX - * pbufs for being in one piece. If not, @ref pbuf_clone can be used to get - * a single pbuf: - * if (p->next != NULL) { - * struct pbuf *q = pbuf_clone(PBUF_RAW, PBUF_RAM, p); - * if (q == NULL) { - * return ERR_MEM; - * } - * p = q; ATTENTION: do NOT free the old 'p' as the ref belongs to the caller! - * } - */ -#if !defined LWIP_NETIF_TX_SINGLE_PBUF || defined __DOXYGEN__ -#define LWIP_NETIF_TX_SINGLE_PBUF 0 -#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ - -/** - * LWIP_NUM_NETIF_CLIENT_DATA: Number of clients that may store - * data in client_data member array of struct netif (max. 256). - */ -#if !defined LWIP_NUM_NETIF_CLIENT_DATA || defined __DOXYGEN__ -#define LWIP_NUM_NETIF_CLIENT_DATA 0 -#endif -/** - * @} - */ - -/* - ------------------------------------ - ---------- LOOPIF options ---------- - ------------------------------------ -*/ -/** - * @defgroup lwip_opts_loop Loopback interface - * @ingroup lwip_opts_netif - * @{ - */ -/** - * LWIP_HAVE_LOOPIF==1: Support loop interface (127.0.0.1). - * This is only needed when no real netifs are available. If at least one other - * netif is available, loopback traffic uses this netif. - */ -#if !defined LWIP_HAVE_LOOPIF || defined __DOXYGEN__ -#define LWIP_HAVE_LOOPIF (LWIP_NETIF_LOOPBACK && !LWIP_SINGLE_NETIF) -#endif - -/** - * LWIP_LOOPIF_MULTICAST==1: Support multicast/IGMP on loop interface (127.0.0.1). - */ -#if !defined LWIP_LOOPIF_MULTICAST || defined __DOXYGEN__ -#define LWIP_LOOPIF_MULTICAST 0 -#endif - -/** - * LWIP_NETIF_LOOPBACK==1: Support sending packets with a destination IP - * address equal to the netif IP address, looping them back up the stack. - */ -#if !defined LWIP_NETIF_LOOPBACK || defined __DOXYGEN__ -#define LWIP_NETIF_LOOPBACK 0 -#endif - -/** - * LWIP_LOOPBACK_MAX_PBUFS: Maximum number of pbufs on queue for loopback - * sending for each netif (0 = disabled) - */ -#if !defined LWIP_LOOPBACK_MAX_PBUFS || defined __DOXYGEN__ -#define LWIP_LOOPBACK_MAX_PBUFS 0 -#endif - -/** - * LWIP_NETIF_LOOPBACK_MULTITHREADING: Indicates whether threading is enabled in - * the system, as netifs must change how they behave depending on this setting - * for the LWIP_NETIF_LOOPBACK option to work. - * Setting this is needed to avoid reentering non-reentrant functions like - * tcp_input(). - * LWIP_NETIF_LOOPBACK_MULTITHREADING==1: Indicates that the user is using a - * multithreaded environment like tcpip.c. In this case, netif->input() - * is called directly. - * LWIP_NETIF_LOOPBACK_MULTITHREADING==0: Indicates a polling (or NO_SYS) setup. - * The packets are put on a list and netif_poll() must be called in - * the main application loop. - */ -#if !defined LWIP_NETIF_LOOPBACK_MULTITHREADING || defined __DOXYGEN__ -#define LWIP_NETIF_LOOPBACK_MULTITHREADING (!NO_SYS) -#endif -/** - * @} - */ - -/* - ------------------------------------ - ---------- Thread options ---------- - ------------------------------------ -*/ -/** - * @defgroup lwip_opts_thread Threading - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * TCPIP_THREAD_NAME: The name assigned to the main tcpip thread. - */ -#if !defined TCPIP_THREAD_NAME || defined __DOXYGEN__ -#define TCPIP_THREAD_NAME "tcpip_thread" -#endif - -/** - * TCPIP_THREAD_STACKSIZE: The stack size used by the main tcpip thread. - * The stack size value itself is platform-dependent, but is passed to - * sys_thread_new() when the thread is created. - */ -#if !defined TCPIP_THREAD_STACKSIZE || defined __DOXYGEN__ -#define TCPIP_THREAD_STACKSIZE 0 -#endif - -/** - * TCPIP_THREAD_PRIO: The priority assigned to the main tcpip thread. - * The priority value itself is platform-dependent, but is passed to - * sys_thread_new() when the thread is created. - */ -#if !defined TCPIP_THREAD_PRIO || defined __DOXYGEN__ -#define TCPIP_THREAD_PRIO 1 -#endif - -/** - * TCPIP_MBOX_SIZE: The mailbox size for the tcpip thread messages - * The queue size value itself is platform-dependent, but is passed to - * sys_mbox_new() when tcpip_init is called. - */ -#if !defined TCPIP_MBOX_SIZE || defined __DOXYGEN__ -#define TCPIP_MBOX_SIZE 0 -#endif - -/** - * Define this to something that triggers a watchdog. This is called from - * tcpip_thread after processing a message. - */ -#if !defined LWIP_TCPIP_THREAD_ALIVE || defined __DOXYGEN__ -#define LWIP_TCPIP_THREAD_ALIVE() -#endif - -/** - * SLIPIF_THREAD_NAME: The name assigned to the slipif_loop thread. - */ -#if !defined SLIPIF_THREAD_NAME || defined __DOXYGEN__ -#define SLIPIF_THREAD_NAME "slipif_loop" -#endif - -/** - * SLIP_THREAD_STACKSIZE: The stack size used by the slipif_loop thread. - * The stack size value itself is platform-dependent, but is passed to - * sys_thread_new() when the thread is created. - */ -#if !defined SLIPIF_THREAD_STACKSIZE || defined __DOXYGEN__ -#define SLIPIF_THREAD_STACKSIZE 0 -#endif - -/** - * SLIPIF_THREAD_PRIO: The priority assigned to the slipif_loop thread. - * The priority value itself is platform-dependent, but is passed to - * sys_thread_new() when the thread is created. - */ -#if !defined SLIPIF_THREAD_PRIO || defined __DOXYGEN__ -#define SLIPIF_THREAD_PRIO 1 -#endif - -/** - * DEFAULT_THREAD_NAME: The name assigned to any other lwIP thread. - */ -#if !defined DEFAULT_THREAD_NAME || defined __DOXYGEN__ -#define DEFAULT_THREAD_NAME "lwIP" -#endif - -/** - * DEFAULT_THREAD_STACKSIZE: The stack size used by any other lwIP thread. - * The stack size value itself is platform-dependent, but is passed to - * sys_thread_new() when the thread is created. - */ -#if !defined DEFAULT_THREAD_STACKSIZE || defined __DOXYGEN__ -#define DEFAULT_THREAD_STACKSIZE 0 -#endif - -/** - * DEFAULT_THREAD_PRIO: The priority assigned to any other lwIP thread. - * The priority value itself is platform-dependent, but is passed to - * sys_thread_new() when the thread is created. - */ -#if !defined DEFAULT_THREAD_PRIO || defined __DOXYGEN__ -#define DEFAULT_THREAD_PRIO 1 -#endif - -/** - * DEFAULT_RAW_RECVMBOX_SIZE: The mailbox size for the incoming packets on a - * NETCONN_RAW. The queue size value itself is platform-dependent, but is passed - * to sys_mbox_new() when the recvmbox is created. - */ -#if !defined DEFAULT_RAW_RECVMBOX_SIZE || defined __DOXYGEN__ -#define DEFAULT_RAW_RECVMBOX_SIZE 0 -#endif - -/** - * DEFAULT_UDP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a - * NETCONN_UDP. The queue size value itself is platform-dependent, but is passed - * to sys_mbox_new() when the recvmbox is created. - */ -#if !defined DEFAULT_UDP_RECVMBOX_SIZE || defined __DOXYGEN__ -#define DEFAULT_UDP_RECVMBOX_SIZE 0 -#endif - -/** - * DEFAULT_TCP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a - * NETCONN_TCP. The queue size value itself is platform-dependent, but is passed - * to sys_mbox_new() when the recvmbox is created. - */ -#if !defined DEFAULT_TCP_RECVMBOX_SIZE || defined __DOXYGEN__ -#define DEFAULT_TCP_RECVMBOX_SIZE 0 -#endif - -/** - * DEFAULT_ACCEPTMBOX_SIZE: The mailbox size for the incoming connections. - * The queue size value itself is platform-dependent, but is passed to - * sys_mbox_new() when the acceptmbox is created. - */ -#if !defined DEFAULT_ACCEPTMBOX_SIZE || defined __DOXYGEN__ -#define DEFAULT_ACCEPTMBOX_SIZE 0 -#endif -/** - * @} - */ - -/* - ---------------------------------------------- - ---------- Sequential layer options ---------- - ---------------------------------------------- -*/ -/** - * @defgroup lwip_opts_netconn Netconn - * @ingroup lwip_opts_threadsafe_apis - * @{ - */ -/** - * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c) - */ -#if !defined LWIP_NETCONN || defined __DOXYGEN__ -#define LWIP_NETCONN 1 -#endif - -/** LWIP_TCPIP_TIMEOUT==1: Enable tcpip_timeout/tcpip_untimeout to create - * timers running in tcpip_thread from another thread. - */ -#if !defined LWIP_TCPIP_TIMEOUT || defined __DOXYGEN__ -#define LWIP_TCPIP_TIMEOUT 0 -#endif - -/** LWIP_NETCONN_SEM_PER_THREAD==1: Use one (thread-local) semaphore per - * thread calling socket/netconn functions instead of allocating one - * semaphore per netconn (and per select etc.) - * ATTENTION: a thread-local semaphore for API calls is needed: - * - LWIP_NETCONN_THREAD_SEM_GET() returning a sys_sem_t* - * - LWIP_NETCONN_THREAD_SEM_ALLOC() creating the semaphore - * - LWIP_NETCONN_THREAD_SEM_FREE() freeing the semaphore - * The latter 2 can be invoked up by calling netconn_thread_init()/netconn_thread_cleanup(). - * Ports may call these for threads created with sys_thread_new(). - */ -#if !defined LWIP_NETCONN_SEM_PER_THREAD || defined __DOXYGEN__ -#define LWIP_NETCONN_SEM_PER_THREAD 0 -#endif - -/** LWIP_NETCONN_FULLDUPLEX==1: Enable code that allows reading from one thread, - * writing from a 2nd thread and closing from a 3rd thread at the same time. - * ATTENTION: This is currently really alpha! Some requirements: - * - LWIP_NETCONN_SEM_PER_THREAD==1 is required to use one socket/netconn from - * multiple threads at once - * - sys_mbox_free() has to unblock receive tasks waiting on recvmbox/acceptmbox - * and prevent a task pending on this during/after deletion - */ -#if !defined LWIP_NETCONN_FULLDUPLEX || defined __DOXYGEN__ -#define LWIP_NETCONN_FULLDUPLEX 0 -#endif -/** - * @} - */ - -/* - ------------------------------------ - ---------- Socket options ---------- - ------------------------------------ -*/ -/** - * @defgroup lwip_opts_socket Sockets - * @ingroup lwip_opts_threadsafe_apis - * @{ - */ -/** - * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c) - */ -#if !defined LWIP_SOCKET || defined __DOXYGEN__ -#define LWIP_SOCKET 1 -#endif - -/** - * LWIP_COMPAT_SOCKETS==1: Enable BSD-style sockets functions names through defines. - * LWIP_COMPAT_SOCKETS==2: Same as ==1 but correctly named functions are created. - * While this helps code completion, it might conflict with existing libraries. - * (only used if you use sockets.c) - */ -#if !defined LWIP_COMPAT_SOCKETS || defined __DOXYGEN__ -#define LWIP_COMPAT_SOCKETS 1 -#endif - -/** - * LWIP_POSIX_SOCKETS_IO_NAMES==1: Enable POSIX-style sockets functions names. - * Disable this option if you use a POSIX operating system that uses the same - * names (read, write & close). (only used if you use sockets.c) - */ -#if !defined LWIP_POSIX_SOCKETS_IO_NAMES || defined __DOXYGEN__ -#define LWIP_POSIX_SOCKETS_IO_NAMES 1 -#endif - -/** - * LWIP_SOCKET_OFFSET==n: Increases the file descriptor number created by LwIP with n. - * This can be useful when there are multiple APIs which create file descriptors. - * When they all start with a different offset and you won't make them overlap you can - * re implement read/write/close/ioctl/fnctl to send the requested action to the right - * library (sharing select will need more work though). - */ -#if !defined LWIP_SOCKET_OFFSET || defined __DOXYGEN__ -#define LWIP_SOCKET_OFFSET 0 -#endif - -/** - * LWIP_TCP_KEEPALIVE==1: Enable TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT - * options processing. Note that TCP_KEEPIDLE and TCP_KEEPINTVL have to be set - * in seconds. (does not require sockets.c, and will affect tcp.c) - */ -#if !defined LWIP_TCP_KEEPALIVE || defined __DOXYGEN__ -#define LWIP_TCP_KEEPALIVE 0 -#endif - -/** - * LWIP_SO_SNDTIMEO==1: Enable send timeout for sockets/netconns and - * SO_SNDTIMEO processing. - */ -#if !defined LWIP_SO_SNDTIMEO || defined __DOXYGEN__ -#define LWIP_SO_SNDTIMEO 0 -#endif - -/** - * LWIP_SO_RCVTIMEO==1: Enable receive timeout for sockets/netconns and - * SO_RCVTIMEO processing. - */ -#if !defined LWIP_SO_RCVTIMEO || defined __DOXYGEN__ -#define LWIP_SO_RCVTIMEO 0 -#endif - -/** - * LWIP_SO_SNDRCVTIMEO_NONSTANDARD==1: SO_RCVTIMEO/SO_SNDTIMEO take an int - * (milliseconds, much like winsock does) instead of a struct timeval (default). - */ -#if !defined LWIP_SO_SNDRCVTIMEO_NONSTANDARD || defined __DOXYGEN__ -#define LWIP_SO_SNDRCVTIMEO_NONSTANDARD 0 -#endif - -/** - * LWIP_SO_RCVBUF==1: Enable SO_RCVBUF processing. - */ -#if !defined LWIP_SO_RCVBUF || defined __DOXYGEN__ -#define LWIP_SO_RCVBUF 0 -#endif - -/** - * LWIP_SO_LINGER==1: Enable SO_LINGER processing. - */ -#if !defined LWIP_SO_LINGER || defined __DOXYGEN__ -#define LWIP_SO_LINGER 0 -#endif - -/** - * If LWIP_SO_RCVBUF is used, this is the default value for recv_bufsize. - */ -#if !defined RECV_BUFSIZE_DEFAULT || defined __DOXYGEN__ -#define RECV_BUFSIZE_DEFAULT INT_MAX -#endif - -/** - * By default, TCP socket/netconn close waits 20 seconds max to send the FIN - */ -#if !defined LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT || defined __DOXYGEN__ -#define LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT 20000 -#endif - -/** - * SO_REUSE==1: Enable SO_REUSEADDR option. - */ -#if !defined SO_REUSE || defined __DOXYGEN__ -#define SO_REUSE 0 -#endif - -/** - * SO_REUSE_RXTOALL==1: Pass a copy of incoming broadcast/multicast packets - * to all local matches if SO_REUSEADDR is turned on. - * WARNING: Adds a memcpy for every packet if passing to more than one pcb! - */ -#if !defined SO_REUSE_RXTOALL || defined __DOXYGEN__ -#define SO_REUSE_RXTOALL 0 -#endif - -/** - * LWIP_FIONREAD_LINUXMODE==0 (default): ioctl/FIONREAD returns the amount of - * pending data in the network buffer. This is the way windows does it. It's - * the default for lwIP since it is smaller. - * LWIP_FIONREAD_LINUXMODE==1: ioctl/FIONREAD returns the size of the next - * pending datagram in bytes. This is the way linux does it. This code is only - * here for compatibility. - */ -#if !defined LWIP_FIONREAD_LINUXMODE || defined __DOXYGEN__ -#define LWIP_FIONREAD_LINUXMODE 0 -#endif - -/** - * LWIP_SOCKET_SELECT==1 (default): enable select() for sockets (uses a netconn - * callback to keep track of events). - * This saves RAM (counters per socket) and code (netconn event callback), which - * should improve performance a bit). - */ -#if !defined LWIP_SOCKET_SELECT || defined __DOXYGEN__ -#define LWIP_SOCKET_SELECT 1 -#endif - -/** - * LWIP_SOCKET_POLL==1 (default): enable poll() for sockets (including - * struct pollfd, nfds_t, and constants) - */ -#if !defined LWIP_SOCKET_POLL || defined __DOXYGEN__ -#define LWIP_SOCKET_POLL 1 -#endif -/** - * @} - */ - -/* - ---------------------------------------- - ---------- Statistics options ---------- - ---------------------------------------- -*/ -/** - * @defgroup lwip_opts_stats Statistics - * @ingroup lwip_opts_debug - * @{ - */ -/** - * LWIP_STATS==1: Enable statistics collection in lwip_stats. - */ -#if !defined LWIP_STATS || defined __DOXYGEN__ -#define LWIP_STATS 1 -#endif - -#if LWIP_STATS - -/** - * LWIP_STATS_DISPLAY==1: Compile in the statistics output functions. - */ -#if !defined LWIP_STATS_DISPLAY || defined __DOXYGEN__ -#define LWIP_STATS_DISPLAY 0 -#endif - -/** - * LINK_STATS==1: Enable link stats. - */ -#if !defined LINK_STATS || defined __DOXYGEN__ -#define LINK_STATS 1 -#endif - -/** - * ETHARP_STATS==1: Enable etharp stats. - */ -#if !defined ETHARP_STATS || defined __DOXYGEN__ -#define ETHARP_STATS (LWIP_ARP) -#endif - -/** - * IP_STATS==1: Enable IP stats. - */ -#if !defined IP_STATS || defined __DOXYGEN__ -#define IP_STATS 1 -#endif - -/** - * IPFRAG_STATS==1: Enable IP fragmentation stats. Default is - * on if using either frag or reass. - */ -#if !defined IPFRAG_STATS || defined __DOXYGEN__ -#define IPFRAG_STATS (IP_REASSEMBLY || IP_FRAG) -#endif - -/** - * ICMP_STATS==1: Enable ICMP stats. - */ -#if !defined ICMP_STATS || defined __DOXYGEN__ -#define ICMP_STATS 1 -#endif - -/** - * IGMP_STATS==1: Enable IGMP stats. - */ -#if !defined IGMP_STATS || defined __DOXYGEN__ -#define IGMP_STATS (LWIP_IGMP) -#endif - -/** - * UDP_STATS==1: Enable UDP stats. Default is on if - * UDP enabled, otherwise off. - */ -#if !defined UDP_STATS || defined __DOXYGEN__ -#define UDP_STATS (LWIP_UDP) -#endif - -/** - * TCP_STATS==1: Enable TCP stats. Default is on if TCP - * enabled, otherwise off. - */ -#if !defined TCP_STATS || defined __DOXYGEN__ -#define TCP_STATS (LWIP_TCP) -#endif - -/** - * MEM_STATS==1: Enable mem.c stats. - */ -#if !defined MEM_STATS || defined __DOXYGEN__ -// #define MEM_STATS ((MEM_LIBC_MALLOC == 0) && (MEM_USE_POOLS == 0)) -#endif - -/** - * MEMP_STATS==1: Enable memp.c pool stats. - */ -#if !defined MEMP_STATS || defined __DOXYGEN__ -#define MEMP_STATS (MEMP_MEM_MALLOC == 0) -#endif - -/** - * SYS_STATS==1: Enable system stats (sem and mbox counts, etc). - */ -#if !defined SYS_STATS || defined __DOXYGEN__ -#define SYS_STATS (NO_SYS == 0) -#endif - -/** - * IP6_STATS==1: Enable IPv6 stats. - */ -#if !defined IP6_STATS || defined __DOXYGEN__ -#define IP6_STATS (LWIP_IPV6) -#endif - -/** - * ICMP6_STATS==1: Enable ICMP for IPv6 stats. - */ -#if !defined ICMP6_STATS || defined __DOXYGEN__ -#define ICMP6_STATS (LWIP_IPV6 && LWIP_ICMP6) -#endif - -/** - * IP6_FRAG_STATS==1: Enable IPv6 fragmentation stats. - */ -#if !defined IP6_FRAG_STATS || defined __DOXYGEN__ -#define IP6_FRAG_STATS (LWIP_IPV6 && (LWIP_IPV6_FRAG || LWIP_IPV6_REASS)) -#endif - -/** - * MLD6_STATS==1: Enable MLD for IPv6 stats. - */ -#if !defined MLD6_STATS || defined __DOXYGEN__ -#define MLD6_STATS (LWIP_IPV6 && LWIP_IPV6_MLD) -#endif - -/** - * ND6_STATS==1: Enable Neighbor discovery for IPv6 stats. - */ -#if !defined ND6_STATS || defined __DOXYGEN__ -#define ND6_STATS (LWIP_IPV6) -#endif - -/** - * MIB2_STATS==1: Stats for SNMP MIB2. - */ -#if !defined MIB2_STATS || defined __DOXYGEN__ -#define MIB2_STATS 0 -#endif - -#else - -#define LINK_STATS 0 -#define ETHARP_STATS 0 -#define IP_STATS 0 -#define IPFRAG_STATS 0 -#define ICMP_STATS 0 -#define IGMP_STATS 0 -#define UDP_STATS 0 -#define TCP_STATS 0 -// #define MEM_STATS 0 -#define MEMP_STATS 0 -#define SYS_STATS 0 -#define LWIP_STATS_DISPLAY 0 -#define IP6_STATS 0 -#define ICMP6_STATS 0 -#define IP6_FRAG_STATS 0 -#define MLD6_STATS 0 -#define ND6_STATS 0 -#define MIB2_STATS 0 - -#endif /* LWIP_STATS */ -/** - * @} - */ - -/* - -------------------------------------- - ---------- Checksum options ---------- - -------------------------------------- -*/ -/** - * @defgroup lwip_opts_checksum Checksum - * @ingroup lwip_opts_infrastructure - * @{ - */ -/** - * LWIP_CHECKSUM_CTRL_PER_NETIF==1: Checksum generation/check can be enabled/disabled - * per netif. - * ATTENTION: if enabled, the CHECKSUM_GEN_* and CHECKSUM_CHECK_* defines must be enabled! - */ -#if !defined LWIP_CHECKSUM_CTRL_PER_NETIF || defined __DOXYGEN__ -#define LWIP_CHECKSUM_CTRL_PER_NETIF 0 -#endif - -/** - * CHECKSUM_GEN_IP==1: Generate checksums in software for outgoing IP packets. - */ -#if !defined CHECKSUM_GEN_IP || defined __DOXYGEN__ -#define CHECKSUM_GEN_IP 1 -#endif - -/** - * CHECKSUM_GEN_UDP==1: Generate checksums in software for outgoing UDP packets. - */ -#if !defined CHECKSUM_GEN_UDP || defined __DOXYGEN__ -#define CHECKSUM_GEN_UDP 1 -#endif - -/** - * CHECKSUM_GEN_TCP==1: Generate checksums in software for outgoing TCP packets. - */ -#if !defined CHECKSUM_GEN_TCP || defined __DOXYGEN__ -#define CHECKSUM_GEN_TCP 1 -#endif - -/** - * CHECKSUM_GEN_ICMP==1: Generate checksums in software for outgoing ICMP packets. - */ -#if !defined CHECKSUM_GEN_ICMP || defined __DOXYGEN__ -#define CHECKSUM_GEN_ICMP 1 -#endif - -/** - * CHECKSUM_GEN_ICMP6==1: Generate checksums in software for outgoing ICMP6 packets. - */ -#if !defined CHECKSUM_GEN_ICMP6 || defined __DOXYGEN__ -#define CHECKSUM_GEN_ICMP6 1 -#endif - -/** - * CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets. - */ -#if !defined CHECKSUM_CHECK_IP || defined __DOXYGEN__ -#define CHECKSUM_CHECK_IP 1 -#endif - -/** - * CHECKSUM_CHECK_UDP==1: Check checksums in software for incoming UDP packets. - */ -#if !defined CHECKSUM_CHECK_UDP || defined __DOXYGEN__ -#define CHECKSUM_CHECK_UDP 1 -#endif - -/** - * CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets. - */ -#if !defined CHECKSUM_CHECK_TCP || defined __DOXYGEN__ -#define CHECKSUM_CHECK_TCP 1 -#endif - -/** - * CHECKSUM_CHECK_ICMP==1: Check checksums in software for incoming ICMP packets. - */ -#if !defined CHECKSUM_CHECK_ICMP || defined __DOXYGEN__ -#define CHECKSUM_CHECK_ICMP 1 -#endif - -/** - * CHECKSUM_CHECK_ICMP6==1: Check checksums in software for incoming ICMPv6 packets - */ -#if !defined CHECKSUM_CHECK_ICMP6 || defined __DOXYGEN__ -#define CHECKSUM_CHECK_ICMP6 1 -#endif - -/** - * LWIP_CHECKSUM_ON_COPY==1: Calculate checksum when copying data from - * application buffers to pbufs. - */ -#if !defined LWIP_CHECKSUM_ON_COPY || defined __DOXYGEN__ -#define LWIP_CHECKSUM_ON_COPY 0 -#endif -/** - * @} - */ - -/* - --------------------------------------- - ---------- IPv6 options --------------- - --------------------------------------- -*/ -/** - * @defgroup lwip_opts_ipv6 IPv6 - * @ingroup lwip_opts - * @{ - */ -/** - * LWIP_IPV6==1: Enable IPv6 - */ -#if !defined LWIP_IPV6 || defined __DOXYGEN__ -#define LWIP_IPV6 0 -#endif - -/** - * IPV6_REASS_MAXAGE: Maximum time (in multiples of IP6_REASS_TMR_INTERVAL - so seconds, normally) - * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived - * in this time, the whole packet is discarded. - */ -#if !defined IPV6_REASS_MAXAGE || defined __DOXYGEN__ -#define IPV6_REASS_MAXAGE 60 -#endif - -/** - * LWIP_IPV6_SCOPES==1: Enable support for IPv6 address scopes, ensuring that - * e.g. link-local addresses are really treated as link-local. Disable this - * setting only for single-interface configurations. - * All addresses that have a scope according to the default policy (link-local - * unicast addresses, interface-local and link-local multicast addresses) should - * now have a zone set on them before being passed to the core API, although - * lwIP will currently attempt to select a zone on the caller's behalf when - * necessary. Applications that directly assign IPv6 addresses to interfaces - * (which is NOT recommended) must now ensure that link-local addresses carry - * the netif's zone. See the new ip6_zone.h header file for more information and - * relevant macros. For now it is still possible to turn off scopes support - * through the new LWIP_IPV6_SCOPES option. When upgrading an implementation that - * uses the core API directly, it is highly recommended to enable - * LWIP_IPV6_SCOPES_DEBUG at least for a while, to ensure e.g. proper address - * initialization. - */ -#if !defined LWIP_IPV6_SCOPES || defined __DOXYGEN__ -#define LWIP_IPV6_SCOPES (LWIP_IPV6 && !LWIP_SINGLE_NETIF) -#endif - -/** - * LWIP_IPV6_SCOPES_DEBUG==1: Perform run-time checks to verify that addresses - * are properly zoned (see ip6_zone.h on what that means) where it matters. - * Enabling this setting is highly recommended when upgrading from an existing - * installation that is not yet scope-aware; otherwise it may be too expensive. - */ -#if !defined LWIP_IPV6_SCOPES_DEBUG || defined __DOXYGEN__ -#define LWIP_IPV6_SCOPES_DEBUG 0 -#endif - -/** - * LWIP_IPV6_NUM_ADDRESSES: Number of IPv6 addresses per netif. - */ -#if !defined LWIP_IPV6_NUM_ADDRESSES || defined __DOXYGEN__ -#define LWIP_IPV6_NUM_ADDRESSES 3 -#endif - -/** - * LWIP_IPV6_FORWARD==1: Forward IPv6 packets across netifs - */ -#if !defined LWIP_IPV6_FORWARD || defined __DOXYGEN__ -#define LWIP_IPV6_FORWARD 0 -#endif - -/** - * LWIP_IPV6_FRAG==1: Fragment outgoing IPv6 packets that are too big. - */ -#if !defined LWIP_IPV6_FRAG || defined __DOXYGEN__ -#define LWIP_IPV6_FRAG 1 -#endif - -/** - * LWIP_IPV6_REASS==1: reassemble incoming IPv6 packets that fragmented - */ -#if !defined LWIP_IPV6_REASS || defined __DOXYGEN__ -#define LWIP_IPV6_REASS LWIP_IPV6 -#endif - -/** - * LWIP_IPV6_SEND_ROUTER_SOLICIT==1: Send router solicitation messages during - * network startup. - */ -#if !defined LWIP_IPV6_SEND_ROUTER_SOLICIT || defined __DOXYGEN__ -#define LWIP_IPV6_SEND_ROUTER_SOLICIT 1 -#endif - -/** - * LWIP_IPV6_AUTOCONFIG==1: Enable stateless address autoconfiguration as per RFC 4862. - */ -#if !defined LWIP_IPV6_AUTOCONFIG || defined __DOXYGEN__ -#define LWIP_IPV6_AUTOCONFIG LWIP_IPV6 -#endif - -/** - * LWIP_IPV6_ADDRESS_LIFETIMES==1: Keep valid and preferred lifetimes for each - * IPv6 address. Required for LWIP_IPV6_AUTOCONFIG. May still be enabled - * otherwise, in which case the application may assign address lifetimes with - * the appropriate macros. Addresses with no lifetime are assumed to be static. - * If this option is disabled, all addresses are assumed to be static. - */ -#if !defined LWIP_IPV6_ADDRESS_LIFETIMES || defined __DOXYGEN__ -#define LWIP_IPV6_ADDRESS_LIFETIMES LWIP_IPV6_AUTOCONFIG -#endif - -/** - * LWIP_IPV6_DUP_DETECT_ATTEMPTS=[0..7]: Number of duplicate address detection attempts. - */ -#if !defined LWIP_IPV6_DUP_DETECT_ATTEMPTS || defined __DOXYGEN__ -#define LWIP_IPV6_DUP_DETECT_ATTEMPTS 1 -#endif -/** - * @} - */ - -/** - * @defgroup lwip_opts_icmp6 ICMP6 - * @ingroup lwip_opts_ipv6 - * @{ - */ -/** - * LWIP_ICMP6==1: Enable ICMPv6 (mandatory per RFC) - */ -#if !defined LWIP_ICMP6 || defined __DOXYGEN__ -#define LWIP_ICMP6 LWIP_IPV6 -#endif - -/** - * LWIP_ICMP6_DATASIZE: bytes from original packet to send back in - * ICMPv6 error messages. - */ -#if !defined LWIP_ICMP6_DATASIZE || defined __DOXYGEN__ -#define LWIP_ICMP6_DATASIZE 8 -#endif - -/** - * LWIP_ICMP6_HL: default hop limit for ICMPv6 messages - */ -#if !defined LWIP_ICMP6_HL || defined __DOXYGEN__ -#define LWIP_ICMP6_HL 255 -#endif -/** - * @} - */ - -/** - * @defgroup lwip_opts_mld6 Multicast listener discovery - * @ingroup lwip_opts_ipv6 - * @{ - */ -/** - * LWIP_IPV6_MLD==1: Enable multicast listener discovery protocol. - * If LWIP_IPV6 is enabled but this setting is disabled, the MAC layer must - * indiscriminately pass all inbound IPv6 multicast traffic to lwIP. - */ -#if !defined LWIP_IPV6_MLD || defined __DOXYGEN__ -#define LWIP_IPV6_MLD LWIP_IPV6 -#endif - -/** - * MEMP_NUM_MLD6_GROUP: Max number of IPv6 multicast groups that can be joined. - * There must be enough groups so that each netif can join the solicited-node - * multicast group for each of its local addresses, plus one for MDNS if - * applicable, plus any number of groups to be joined on UDP sockets. - */ -#if !defined MEMP_NUM_MLD6_GROUP || defined __DOXYGEN__ -#define MEMP_NUM_MLD6_GROUP 4 -#endif -/** - * @} - */ - -/** - * @defgroup lwip_opts_nd6 Neighbor discovery - * @ingroup lwip_opts_ipv6 - * @{ - */ -/** - * LWIP_ND6_QUEUEING==1: queue outgoing IPv6 packets while MAC address - * is being resolved. - */ -#if !defined LWIP_ND6_QUEUEING || defined __DOXYGEN__ -#define LWIP_ND6_QUEUEING LWIP_IPV6 -#endif - -/** - * MEMP_NUM_ND6_QUEUE: Max number of IPv6 packets to queue during MAC resolution. - */ -#if !defined MEMP_NUM_ND6_QUEUE || defined __DOXYGEN__ -#define MEMP_NUM_ND6_QUEUE 20 -#endif - -/** - * LWIP_ND6_NUM_NEIGHBORS: Number of entries in IPv6 neighbor cache - */ -#if !defined LWIP_ND6_NUM_NEIGHBORS || defined __DOXYGEN__ -#define LWIP_ND6_NUM_NEIGHBORS 10 -#endif - -/** - * LWIP_ND6_NUM_DESTINATIONS: number of entries in IPv6 destination cache - */ -#if !defined LWIP_ND6_NUM_DESTINATIONS || defined __DOXYGEN__ -#define LWIP_ND6_NUM_DESTINATIONS 10 -#endif - -/** - * LWIP_ND6_NUM_PREFIXES: number of entries in IPv6 on-link prefixes cache - */ -#if !defined LWIP_ND6_NUM_PREFIXES || defined __DOXYGEN__ -#define LWIP_ND6_NUM_PREFIXES 5 -#endif - -/** - * LWIP_ND6_NUM_ROUTERS: number of entries in IPv6 default router cache - */ -#if !defined LWIP_ND6_NUM_ROUTERS || defined __DOXYGEN__ -#define LWIP_ND6_NUM_ROUTERS 3 -#endif - -/** - * LWIP_ND6_MAX_MULTICAST_SOLICIT: max number of multicast solicit messages to send - * (neighbor solicit and router solicit) - */ -#if !defined LWIP_ND6_MAX_MULTICAST_SOLICIT || defined __DOXYGEN__ -#define LWIP_ND6_MAX_MULTICAST_SOLICIT 3 -#endif - -/** - * LWIP_ND6_MAX_UNICAST_SOLICIT: max number of unicast neighbor solicitation messages - * to send during neighbor reachability detection. - */ -#if !defined LWIP_ND6_MAX_UNICAST_SOLICIT || defined __DOXYGEN__ -#define LWIP_ND6_MAX_UNICAST_SOLICIT 3 -#endif - -/** - * Unused: See ND RFC (time in milliseconds). - */ -#if !defined LWIP_ND6_MAX_ANYCAST_DELAY_TIME || defined __DOXYGEN__ -#define LWIP_ND6_MAX_ANYCAST_DELAY_TIME 1000 -#endif - -/** - * Unused: See ND RFC - */ -#if !defined LWIP_ND6_MAX_NEIGHBOR_ADVERTISEMENT || defined __DOXYGEN__ -#define LWIP_ND6_MAX_NEIGHBOR_ADVERTISEMENT 3 -#endif - -/** - * LWIP_ND6_REACHABLE_TIME: default neighbor reachable time (in milliseconds). - * May be updated by router advertisement messages. - */ -#if !defined LWIP_ND6_REACHABLE_TIME || defined __DOXYGEN__ -#define LWIP_ND6_REACHABLE_TIME 30000 -#endif - -/** - * LWIP_ND6_RETRANS_TIMER: default retransmission timer for solicitation messages - */ -#if !defined LWIP_ND6_RETRANS_TIMER || defined __DOXYGEN__ -#define LWIP_ND6_RETRANS_TIMER 1000 -#endif - -/** - * LWIP_ND6_DELAY_FIRST_PROBE_TIME: Delay before first unicast neighbor solicitation - * message is sent, during neighbor reachability detection. - */ -#if !defined LWIP_ND6_DELAY_FIRST_PROBE_TIME || defined __DOXYGEN__ -#define LWIP_ND6_DELAY_FIRST_PROBE_TIME 5000 -#endif - -/** - * LWIP_ND6_ALLOW_RA_UPDATES==1: Allow Router Advertisement messages to update - * Reachable time and retransmission timers, and netif MTU. - */ -#if !defined LWIP_ND6_ALLOW_RA_UPDATES || defined __DOXYGEN__ -#define LWIP_ND6_ALLOW_RA_UPDATES 1 -#endif - -/** - * LWIP_ND6_TCP_REACHABILITY_HINTS==1: Allow TCP to provide Neighbor Discovery - * with reachability hints for connected destinations. This helps avoid sending - * unicast neighbor solicitation messages. - */ -#if !defined LWIP_ND6_TCP_REACHABILITY_HINTS || defined __DOXYGEN__ -#define LWIP_ND6_TCP_REACHABILITY_HINTS 1 -#endif - -/** - * LWIP_ND6_RDNSS_MAX_DNS_SERVERS > 0: Use IPv6 Router Advertisement Recursive - * DNS Server Option (as per RFC 6106) to copy a defined maximum number of DNS - * servers to the DNS module. - */ -#if !defined LWIP_ND6_RDNSS_MAX_DNS_SERVERS || defined __DOXYGEN__ -#define LWIP_ND6_RDNSS_MAX_DNS_SERVERS 0 -#endif -/** - * @} - */ - -/** - * @defgroup lwip_opts_dhcpv6 DHCPv6 - * @ingroup lwip_opts_ipv6 - * @{ - */ -/** - * LWIP_IPV6_DHCP6==1: enable DHCPv6 stateful/stateless address autoconfiguration. - */ -#if !defined LWIP_IPV6_DHCP6 || defined __DOXYGEN__ -#define LWIP_IPV6_DHCP6 0 -#endif - -/** - * LWIP_IPV6_DHCP6_STATEFUL==1: enable DHCPv6 stateful address autoconfiguration. - * (not supported, yet!) - */ -#if !defined LWIP_IPV6_DHCP6_STATEFUL || defined __DOXYGEN__ -#define LWIP_IPV6_DHCP6_STATEFUL 0 -#endif - -/** - * LWIP_IPV6_DHCP6_STATELESS==1: enable DHCPv6 stateless address autoconfiguration. - */ -#if !defined LWIP_IPV6_DHCP6_STATELESS || defined __DOXYGEN__ -#define LWIP_IPV6_DHCP6_STATELESS LWIP_IPV6_DHCP6 -#endif - -/** - * LWIP_DHCP6_GETS_NTP==1: Request NTP servers via DHCPv6. For each - * response packet, a callback is called, which has to be provided by the port: - * void dhcp6_set_ntp_servers(u8_t num_ntp_servers, ip_addr_t* ntp_server_addrs); -*/ -#if !defined LWIP_DHCP6_GET_NTP_SRV || defined __DOXYGEN__ -#define LWIP_DHCP6_GET_NTP_SRV 0 -#endif - -/** - * The maximum of NTP servers requested - */ -#if !defined LWIP_DHCP6_MAX_NTP_SERVERS || defined __DOXYGEN__ -#define LWIP_DHCP6_MAX_NTP_SERVERS 1 -#endif - -/** - * LWIP_DHCP6_MAX_DNS_SERVERS > 0: Request DNS servers via DHCPv6. - * DNS servers received in the response are passed to DNS via @ref dns_setserver() - * (up to the maximum limit defined here). - */ -#if !defined LWIP_DHCP6_MAX_DNS_SERVERS || defined __DOXYGEN__ -#define LWIP_DHCP6_MAX_DNS_SERVERS DNS_MAX_SERVERS -#endif -/** - * @} - */ - -/* - --------------------------------------- - ---------- Hook options --------------- - --------------------------------------- -*/ - -/** - * @defgroup lwip_opts_hooks Hooks - * @ingroup lwip_opts_infrastructure - * Hooks are undefined by default, define them to a function if you need them. - * @{ - */ - -/** - * LWIP_HOOK_FILENAME: Custom filename to \#include in files that provide hooks. - * Declare your hook function prototypes in there, you may also \#include all headers - * providing data types that are need in this file. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_FILENAME "path/to/my/lwip_hooks.h" -#endif - -/** - * LWIP_HOOK_TCP_ISN: - * Hook for generation of the Initial Sequence Number (ISN) for a new TCP - * connection. The default lwIP ISN generation algorithm is very basic and may - * allow for TCP spoofing attacks. This hook provides the means to implement - * the standardized ISN generation algorithm from RFC 6528 (see contrib/adons/tcp_isn), - * or any other desired algorithm as a replacement. - * Called from tcp_connect() and tcp_listen_input() when an ISN is needed for - * a new TCP connection, if TCP support (@ref LWIP_TCP) is enabled.\n - * Signature:\code{.c} - * u32_t my_hook_tcp_isn(const ip_addr_t* local_ip, u16_t local_port, const ip_addr_t* remote_ip, u16_t remote_port); - * \endcode - * - it may be necessary to use "struct ip_addr" (ip4_addr, ip6_addr) instead of "ip_addr_t" in function declarations\n - * Arguments: - * - local_ip: pointer to the local IP address of the connection - * - local_port: local port number of the connection (host-byte order) - * - remote_ip: pointer to the remote IP address of the connection - * - remote_port: remote port number of the connection (host-byte order)\n - * Return value: - * - the 32-bit Initial Sequence Number to use for the new TCP connection. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_TCP_ISN(local_ip, local_port, remote_ip, remote_port) -#endif - -/** - * LWIP_HOOK_TCP_INPACKET_PCB: - * Hook for intercepting incoming packets before they are passed to a pcb. This - * allows updating some state or even dropping a packet. - * Signature:\code{.c} - * err_t my_hook_tcp_inpkt(struct tcp_pcb *pcb, struct tcp_hdr *hdr, u16_t optlen, u16_t opt1len, u8_t *opt2, struct pbuf *p); - * \endcode - * Arguments: - * - pcb: tcp_pcb selected for input of this packet (ATTENTION: this may be - * struct tcp_pcb_listen if pcb->state == LISTEN) - * - hdr: pointer to tcp header (ATTENTION: tcp options may not be in one piece!) - * - optlen: tcp option length - * - opt1len: tcp option length 1st part - * - opt2: if this is != NULL, tcp options are split among 2 pbufs. In that case, - * options start at right after the tcp header ('(u8_t*)(hdr + 1)') for - * the first 'opt1len' bytes and the rest starts at 'opt2'. opt2len can - * be simply calculated: 'opt2len = optlen - opt1len;' - * - p: input packet, p->payload points to application data (that's why tcp hdr - * and options are passed in seperately) - * Return value: - * - ERR_OK: continue input of this packet as normal - * - != ERR_OK: drop this packet for input (don't continue input processing) - * - * ATTENTION: don't call any tcp api functions that might change tcp state (pcb - * state or any pcb lists) from this callback! - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_TCP_INPACKET_PCB(pcb, hdr, optlen, opt1len, opt2, p) -#endif - -/** - * LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH: - * Hook for increasing the size of the options allocated with a tcp header. - * Together with LWIP_HOOK_TCP_OUT_ADD_TCPOPTS, this can be used to add custom - * options to outgoing tcp segments. - * Signature:\code{.c} - * u8_t my_hook_tcp_out_tcpopt_length(const struct tcp_pcb *pcb, u8_t internal_option_length); - * \endcode - * Arguments: - * - pcb: tcp_pcb that transmits (ATTENTION: this may be NULL or - * struct tcp_pcb_listen if pcb->state == LISTEN) - * - internal_option_length: tcp option length used by the stack internally - * Return value: - * - a number of bytes to allocate for tcp options (internal_option_length <= ret <= 40) - * - * ATTENTION: don't call any tcp api functions that might change tcp state (pcb - * state or any pcb lists) from this callback! - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH(pcb, internal_len) -#endif - -/** - * LWIP_HOOK_TCP_OUT_ADD_TCPOPTS: - * Hook for adding custom options to outgoing tcp segments. - * Space for these custom options has to be reserved via LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH. - * Signature:\code{.c} - * u32_t *my_hook_tcp_out_add_tcpopts(struct pbuf *p, struct tcp_hdr *hdr, const struct tcp_pcb *pcb, u32_t *opts); - * \endcode - * Arguments: - * - p: output packet, p->payload pointing to tcp header, data follows - * - hdr: tcp header - * - pcb: tcp_pcb that transmits (ATTENTION: this may be NULL or - * struct tcp_pcb_listen if pcb->state == LISTEN) - * - opts: pointer where to add the custom options (there may already be options - * between the header and these) - * Return value: - * - pointer pointing directly after the inserted options - * - * ATTENTION: don't call any tcp api functions that might change tcp state (pcb - * state or any pcb lists) from this callback! - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_TCP_OUT_ADD_TCPOPTS(p, hdr, pcb, opts) -#endif - -/** - * LWIP_HOOK_IP4_INPUT(pbuf, input_netif): - * Called from ip_input() (IPv4) - * Signature:\code{.c} - * int my_hook(struct pbuf *pbuf, struct netif *input_netif); - * \endcode - * Arguments: - * - pbuf: received struct pbuf passed to ip_input() - * - input_netif: struct netif on which the packet has been received - * Return values: - * - 0: Hook has not consumed the packet, packet is processed as normal - * - != 0: Hook has consumed the packet. - * If the hook consumed the packet, 'pbuf' is in the responsibility of the hook - * (i.e. free it when done). - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_IP4_INPUT(pbuf, input_netif) -#endif - -/** - * LWIP_HOOK_IP4_ROUTE(dest): - * Called from ip_route() (IPv4) - * Signature:\code{.c} - * struct netif *my_hook(const ip4_addr_t *dest); - * \endcode - * Arguments: - * - dest: destination IPv4 address - * Returns values: - * - the destination netif - * - NULL if no destination netif is found. In that case, ip_route() continues as normal. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_IP4_ROUTE() -#endif - -/** - * LWIP_HOOK_IP4_ROUTE_SRC(src, dest): - * Source-based routing for IPv4 - called from ip_route() (IPv4) - * Signature:\code{.c} - * struct netif *my_hook(const ip4_addr_t *src, const ip4_addr_t *dest); - * \endcode - * Arguments: - * - src: local/source IPv4 address - * - dest: destination IPv4 address - * Returns values: - * - the destination netif - * - NULL if no destination netif is found. In that case, ip_route() continues as normal. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_IP4_ROUTE_SRC(src, dest) -#endif - -/** - * LWIP_HOOK_IP4_CANFORWARD(src, dest): - * Check if an IPv4 can be forwarded - called from: - * ip4_input() -> ip4_forward() -> ip4_canforward() (IPv4) - * - source address is available via ip4_current_src_addr() - * - calling an output function in this context (e.g. multicast router) is allowed - * Signature:\code{.c} - * int my_hook(struct pbuf *p, u32_t dest_addr_hostorder); - * \endcode - * Arguments: - * - p: packet to forward - * - dest: destination IPv4 address - * Returns values: - * - 1: forward - * - 0: don't forward - * - -1: no decision. In that case, ip4_canforward() continues as normal. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_IP4_CANFORWARD(src, dest) -#endif - -/** - * LWIP_HOOK_ETHARP_GET_GW(netif, dest): - * Called from etharp_output() (IPv4) - * Signature:\code{.c} - * const ip4_addr_t *my_hook(struct netif *netif, const ip4_addr_t *dest); - * \endcode - * Arguments: - * - netif: the netif used for sending - * - dest: the destination IPv4 address - * Return values: - * - the IPv4 address of the gateway to handle the specified destination IPv4 address - * - NULL, in which case the netif's default gateway is used - * - * The returned address MUST be directly reachable on the specified netif! - * This function is meant to implement advanced IPv4 routing together with - * LWIP_HOOK_IP4_ROUTE(). The actual routing/gateway table implementation is - * not part of lwIP but can e.g. be hidden in the netif's state argument. -*/ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_ETHARP_GET_GW(netif, dest) -#endif - -/** - * LWIP_HOOK_IP6_INPUT(pbuf, input_netif): - * Called from ip6_input() (IPv6) - * Signature:\code{.c} - * int my_hook(struct pbuf *pbuf, struct netif *input_netif); - * \endcode - * Arguments: - * - pbuf: received struct pbuf passed to ip6_input() - * - input_netif: struct netif on which the packet has been received - * Return values: - * - 0: Hook has not consumed the packet, packet is processed as normal - * - != 0: Hook has consumed the packet. - * If the hook consumed the packet, 'pbuf' is in the responsibility of the hook - * (i.e. free it when done). - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_IP6_INPUT(pbuf, input_netif) -#endif - -/** - * LWIP_HOOK_IP6_ROUTE(src, dest): - * Called from ip_route() (IPv6) - * Signature:\code{.c} - * struct netif *my_hook(const ip6_addr_t *dest, const ip6_addr_t *src); - * \endcode - * Arguments: - * - src: source IPv6 address - * - dest: destination IPv6 address - * Return values: - * - the destination netif - * - NULL if no destination netif is found. In that case, ip6_route() continues as normal. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_IP6_ROUTE(src, dest) -#endif - -/** - * LWIP_HOOK_ND6_GET_GW(netif, dest): - * Called from nd6_get_next_hop_entry() (IPv6) - * Signature:\code{.c} - * const ip6_addr_t *my_hook(struct netif *netif, const ip6_addr_t *dest); - * \endcode - * Arguments: - * - netif: the netif used for sending - * - dest: the destination IPv6 address - * Return values: - * - the IPv6 address of the next hop to handle the specified destination IPv6 address - * - NULL, in which case a NDP-discovered router is used instead - * - * The returned address MUST be directly reachable on the specified netif! - * This function is meant to implement advanced IPv6 routing together with - * LWIP_HOOK_IP6_ROUTE(). The actual routing/gateway table implementation is - * not part of lwIP but can e.g. be hidden in the netif's state argument. -*/ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_ND6_GET_GW(netif, dest) -#endif - -/** - * LWIP_HOOK_VLAN_CHECK(netif, eth_hdr, vlan_hdr): - * Called from ethernet_input() if VLAN support is enabled - * Signature:\code{.c} - * int my_hook(struct netif *netif, struct eth_hdr *eth_hdr, struct eth_vlan_hdr *vlan_hdr); - * \endcode - * Arguments: - * - netif: struct netif on which the packet has been received - * - eth_hdr: struct eth_hdr of the packet - * - vlan_hdr: struct eth_vlan_hdr of the packet - * Return values: - * - 0: Packet must be dropped. - * - != 0: Packet must be accepted. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_VLAN_CHECK(netif, eth_hdr, vlan_hdr) -#endif - -/** - * LWIP_HOOK_VLAN_SET: - * Hook can be used to set prio_vid field of vlan_hdr. If you need to store data - * on per-netif basis to implement this callback, see @ref netif_cd. - * Called from ethernet_output() if VLAN support (@ref ETHARP_SUPPORT_VLAN) is enabled.\n - * Signature:\code{.c} - * s32_t my_hook_vlan_set(struct netif* netif, struct pbuf* pbuf, const struct eth_addr* src, const struct eth_addr* dst, u16_t eth_type);\n - * \endcode - * Arguments: - * - netif: struct netif that the packet will be sent through - * - p: struct pbuf packet to be sent - * - src: source eth address - * - dst: destination eth address - * - eth_type: ethernet type to packet to be sent\n - * - * - * Return values: - * - <0: Packet shall not contain VLAN header. - * - 0 <= return value <= 0xFFFF: Packet shall contain VLAN header. Return value is prio_vid in host byte order. - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_VLAN_SET(netif, p, src, dst, eth_type) -#endif - -/** - * LWIP_HOOK_MEMP_AVAILABLE(memp_t_type): - * Called from memp_free() when a memp pool was empty and an item is now available - * Signature:\code{.c} - * void my_hook(memp_t type); - * \endcode - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_MEMP_AVAILABLE(memp_t_type) -#endif - -/** - * LWIP_HOOK_UNKNOWN_ETH_PROTOCOL(pbuf, netif): - * Called from ethernet_input() when an unknown eth type is encountered. - * Signature:\code{.c} - * err_t my_hook(struct pbuf* pbuf, struct netif* netif); - * \endcode - * Arguments: - * - p: rx packet with unknown eth type - * - netif: netif on which the packet has been received - * Return values: - * - ERR_OK if packet is accepted (hook function now owns the pbuf) - * - any error code otherwise (pbuf is freed) - * - * Payload points to ethernet header! - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_UNKNOWN_ETH_PROTOCOL(pbuf, netif) -#endif - -/** - * LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, state, msg, msg_type, options_len_ptr): - * Called from various dhcp functions when sending a DHCP message. - * This hook is called just before the DHCP message trailer is added, so the - * options are at the end of a DHCP message. - * Signature:\code{.c} - * void my_hook(struct netif *netif, struct dhcp *dhcp, u8_t state, struct dhcp_msg *msg, - * u8_t msg_type, u16_t *options_len_ptr); - * \endcode - * Arguments: - * - netif: struct netif that the packet will be sent through - * - dhcp: struct dhcp on that netif - * - state: current dhcp state (dhcp_state_enum_t as an u8_t) - * - msg: struct dhcp_msg that will be sent - * - msg_type: dhcp message type to be sent (u8_t) - * - options_len_ptr: pointer to the current length of options in the dhcp_msg "msg" - * (must be increased when options are added!) - * - * Options need to appended like this: - * LWIP_ASSERT("dhcp option overflow", *options_len_ptr + option_len + 2 <= DHCP_OPTIONS_LEN); - * msg->options[(*options_len_ptr)++] = <option_number>; - * msg->options[(*options_len_ptr)++] = <option_len>; - * msg->options[(*options_len_ptr)++] = <option_bytes>; - * [...] - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, state, msg, msg_type, options_len_ptr) -#endif - -/** - * LWIP_HOOK_DHCP_PARSE_OPTION(netif, dhcp, state, msg, msg_type, option, len, pbuf, option_value_offset): - * Called from dhcp_parse_reply when receiving a DHCP message. - * This hook is called for every option in the received message that is not handled internally. - * Signature:\code{.c} - * void my_hook(struct netif *netif, struct dhcp *dhcp, u8_t state, struct dhcp_msg *msg, - * u8_t msg_type, u8_t option, u8_t option_len, struct pbuf *pbuf, u16_t option_value_offset); - * \endcode - * Arguments: - * - netif: struct netif that the packet will be sent through - * - dhcp: struct dhcp on that netif - * - state: current dhcp state (dhcp_state_enum_t as an u8_t) - * - msg: struct dhcp_msg that was received - * - msg_type: dhcp message type received (u8_t, ATTENTION: only valid after - * the message type option has been parsed!) - * - option: option value (u8_t) - * - len: option data length (u8_t) - * - pbuf: pbuf where option data is contained - * - option_value_offset: offset in pbuf where option data begins - * - * A nice way to get the option contents is pbuf_get_contiguous(): - * u8_t buf[32]; - * u8_t *ptr = (u8_t*)pbuf_get_contiguous(p, buf, sizeof(buf), LWIP_MIN(option_len, sizeof(buf)), offset); - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_DHCP_PARSE_OPTION(netif, dhcp, state, msg, msg_type, option, len, pbuf, offset) -#endif - -/** - * LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, state, msg, msg_type, options_len_ptr, max_len): - * Called from various dhcp6 functions when sending a DHCP6 message. - * This hook is called just before the DHCP6 message is sent, so the - * options are at the end of a DHCP6 message. - * Signature:\code{.c} - * void my_hook(struct netif *netif, struct dhcp6 *dhcp, u8_t state, struct dhcp6_msg *msg, - * u8_t msg_type, u16_t *options_len_ptr); - * \endcode - * Arguments: - * - netif: struct netif that the packet will be sent through - * - dhcp6: struct dhcp6 on that netif - * - state: current dhcp6 state (dhcp6_state_enum_t as an u8_t) - * - msg: struct dhcp6_msg that will be sent - * - msg_type: dhcp6 message type to be sent (u8_t) - * - options_len_ptr: pointer to the current length of options in the dhcp6_msg "msg" - * (must be increased when options are added!) - * - * Options need to appended like this: - * u8_t *options = (u8_t *)(msg + 1); - * LWIP_ASSERT("dhcp option overflow", sizeof(struct dhcp6_msg) + *options_len_ptr + newoptlen <= max_len); - * options[(*options_len_ptr)++] = <option_data>; - * [...] - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, state, msg, msg_type, options_len_ptr, max_len) -#endif - -/** - * LWIP_HOOK_SOCKETS_SETSOCKOPT(s, sock, level, optname, optval, optlen, err) - * Called from socket API to implement setsockopt() for options not provided by lwIP. - * Core lock is held when this hook is called. - * Signature:\code{.c} - * int my_hook(int s, struct lwip_sock *sock, int level, int optname, const void *optval, socklen_t optlen, int *err) - * \endcode - * Arguments: - * - s: socket file descriptor - * - sock: internal socket descriptor (see lwip/priv/sockets_priv.h) - * - level: protocol level at which the option resides - * - optname: option to set - * - optval: value to set - * - optlen: size of optval - * - err: output error - * Return values: - * - 0: Hook has not consumed the option, code continues as normal (to internal options) - * - != 0: Hook has consumed the option, 'err' is returned - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_SOCKETS_SETSOCKOPT(s, sock, level, optname, optval, optlen, err) -#endif - -/** - * LWIP_HOOK_SOCKETS_GETSOCKOPT(s, sock, level, optname, optval, optlen, err) - * Called from socket API to implement getsockopt() for options not provided by lwIP. - * Core lock is held when this hook is called. - * Signature:\code{.c} - * int my_hook(int s, struct lwip_sock *sock, int level, int optname, void *optval, socklen_t *optlen, int *err) - * \endcode - * Arguments: - * - s: socket file descriptor - * - sock: internal socket descriptor (see lwip/priv/sockets_priv.h) - * - level: protocol level at which the option resides - * - optname: option to get - * - optval: value to get - * - optlen: size of optval - * - err: output error - * Return values: - * - 0: Hook has not consumed the option, code continues as normal (to internal options) - * - != 0: Hook has consumed the option, 'err' is returned - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_SOCKETS_GETSOCKOPT(s, sock, level, optname, optval, optlen, err) -#endif - -/** - * LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, addrtype, err) - * Called from netconn APIs (not usable with callback apps) allowing an - * external DNS resolver (which uses sequential API) to handle the query. - * Signature:\code{.c} - * int my_hook(const char *name, ip_addr_t *addr, u8_t addrtype, err_t *err) - * \endcode - * Arguments: - * - name: hostname to resolve - * - addr: output host address - * - addrtype: type of address to query - * - err: output error - * Return values: - * - 0: Hook has not consumed hostname query, query continues into DNS module - * - != 0: Hook has consumed the query - * - * err must also be checked to determine if the hook consumed the query, but - * the query failed - */ -#ifdef __DOXYGEN__ -#define LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, addrtype, err) -#endif -/** - * @} - */ - -/* - --------------------------------------- - ---------- Debugging options ---------- - --------------------------------------- -*/ -/** - * @defgroup lwip_opts_debugmsg Debug messages - * @ingroup lwip_opts_debug - * @{ - */ -/** - * LWIP_DBG_MIN_LEVEL: After masking, the value of the debug is - * compared against this value. If it is smaller, then debugging - * messages are written. - * @see debugging_levels - */ -#if !defined LWIP_DBG_MIN_LEVEL || defined __DOXYGEN__ -#define LWIP_DBG_MIN_LEVEL LWIP_DBG_LEVEL_ALL -#endif - -/** - * LWIP_DBG_TYPES_ON: A mask that can be used to globally enable/disable - * debug messages of certain types. - * @see debugging_levels - */ -#if !defined LWIP_DBG_TYPES_ON || defined __DOXYGEN__ -#define LWIP_DBG_TYPES_ON LWIP_DBG_ON -#endif - -/** - * ETHARP_DEBUG: Enable debugging in etharp.c. - */ -#if !defined ETHARP_DEBUG || defined __DOXYGEN__ -#define ETHARP_DEBUG LWIP_DBG_OFF -#endif - -/** - * NETIF_DEBUG: Enable debugging in netif.c. - */ -#if !defined NETIF_DEBUG || defined __DOXYGEN__ -#define NETIF_DEBUG LWIP_DBG_OFF -#endif - -/** - * PBUF_DEBUG: Enable debugging in pbuf.c. - */ -#if !defined PBUF_DEBUG || defined __DOXYGEN__ -#define PBUF_DEBUG LWIP_DBG_OFF -#endif - -/** - * API_LIB_DEBUG: Enable debugging in api_lib.c. - */ -#if !defined API_LIB_DEBUG || defined __DOXYGEN__ -#define API_LIB_DEBUG LWIP_DBG_OFF -#endif - -/** - * API_MSG_DEBUG: Enable debugging in api_msg.c. - */ -#if !defined API_MSG_DEBUG || defined __DOXYGEN__ -#define API_MSG_DEBUG LWIP_DBG_OFF -#endif - -/** - * SOCKETS_DEBUG: Enable debugging in sockets.c. - */ -#if !defined SOCKETS_DEBUG || defined __DOXYGEN__ -#define SOCKETS_DEBUG LWIP_DBG_OFF -#endif - -/** - * ICMP_DEBUG: Enable debugging in icmp.c. - */ -#if !defined ICMP_DEBUG || defined __DOXYGEN__ -#define ICMP_DEBUG LWIP_DBG_OFF -#endif - -/** - * IGMP_DEBUG: Enable debugging in igmp.c. - */ -#if !defined IGMP_DEBUG || defined __DOXYGEN__ -#define IGMP_DEBUG LWIP_DBG_OFF -#endif - -/** - * INET_DEBUG: Enable debugging in inet.c. - */ -#if !defined INET_DEBUG || defined __DOXYGEN__ -#define INET_DEBUG LWIP_DBG_OFF -#endif - -/** - * IP_DEBUG: Enable debugging for IP. - */ -#if !defined IP_DEBUG || defined __DOXYGEN__ -#define IP_DEBUG LWIP_DBG_OFF -#endif - -/** - * IP_REASS_DEBUG: Enable debugging in ip_frag.c for both frag & reass. - */ -#if !defined IP_REASS_DEBUG || defined __DOXYGEN__ -#define IP_REASS_DEBUG LWIP_DBG_OFF -#endif - -/** - * RAW_DEBUG: Enable debugging in raw.c. - */ -#if !defined RAW_DEBUG || defined __DOXYGEN__ -#define RAW_DEBUG LWIP_DBG_OFF -#endif - -/** - * MEM_DEBUG: Enable debugging in mem.c. - */ -#if !defined MEM_DEBUG || defined __DOXYGEN__ -#define MEM_DEBUG LWIP_DBG_OFF -#endif - -/** - * MEMP_DEBUG: Enable debugging in memp.c. - */ -#if !defined MEMP_DEBUG || defined __DOXYGEN__ -#define MEMP_DEBUG LWIP_DBG_OFF -#endif - -/** - * SYS_DEBUG: Enable debugging in sys.c. - */ -#if !defined SYS_DEBUG || defined __DOXYGEN__ -#define SYS_DEBUG LWIP_DBG_OFF -#endif - -/** - * TIMERS_DEBUG: Enable debugging in timers.c. - */ -#if !defined TIMERS_DEBUG || defined __DOXYGEN__ -#define TIMERS_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_DEBUG: Enable debugging for TCP. - */ -#if !defined TCP_DEBUG || defined __DOXYGEN__ -#define TCP_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_INPUT_DEBUG: Enable debugging in tcp_in.c for incoming debug. - */ -#if !defined TCP_INPUT_DEBUG || defined __DOXYGEN__ -#define TCP_INPUT_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_FR_DEBUG: Enable debugging in tcp_in.c for fast retransmit. - */ -#if !defined TCP_FR_DEBUG || defined __DOXYGEN__ -#define TCP_FR_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_RTO_DEBUG: Enable debugging in TCP for retransmit - * timeout. - */ -#if !defined TCP_RTO_DEBUG || defined __DOXYGEN__ -#define TCP_RTO_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_CWND_DEBUG: Enable debugging for TCP congestion window. - */ -#if !defined TCP_CWND_DEBUG || defined __DOXYGEN__ -#define TCP_CWND_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_WND_DEBUG: Enable debugging in tcp_in.c for window updating. - */ -#if !defined TCP_WND_DEBUG || defined __DOXYGEN__ -#define TCP_WND_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_OUTPUT_DEBUG: Enable debugging in tcp_out.c output functions. - */ -#if !defined TCP_OUTPUT_DEBUG || defined __DOXYGEN__ -#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_RST_DEBUG: Enable debugging for TCP with the RST message. - */ -#if !defined TCP_RST_DEBUG || defined __DOXYGEN__ -#define TCP_RST_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCP_QLEN_DEBUG: Enable debugging for TCP queue lengths. - */ -#if !defined TCP_QLEN_DEBUG || defined __DOXYGEN__ -#define TCP_QLEN_DEBUG LWIP_DBG_OFF -#endif - -/** - * UDP_DEBUG: Enable debugging in UDP. - */ -#if !defined UDP_DEBUG || defined __DOXYGEN__ -#define UDP_DEBUG LWIP_DBG_OFF -#endif - -/** - * TCPIP_DEBUG: Enable debugging in tcpip.c. - */ -#if !defined TCPIP_DEBUG || defined __DOXYGEN__ -#define TCPIP_DEBUG LWIP_DBG_OFF -#endif - -/** - * SLIP_DEBUG: Enable debugging in slipif.c. - */ -#if !defined SLIP_DEBUG || defined __DOXYGEN__ -#define SLIP_DEBUG LWIP_DBG_OFF -#endif - -/** - * DHCP_DEBUG: Enable debugging in dhcp.c. - */ -#if !defined DHCP_DEBUG || defined __DOXYGEN__ -#define DHCP_DEBUG LWIP_DBG_OFF -#endif - -/** - * AUTOIP_DEBUG: Enable debugging in autoip.c. - */ -#if !defined AUTOIP_DEBUG || defined __DOXYGEN__ -#define AUTOIP_DEBUG LWIP_DBG_OFF -#endif - -/** - * DNS_DEBUG: Enable debugging for DNS. - */ -#if !defined DNS_DEBUG || defined __DOXYGEN__ -#define DNS_DEBUG LWIP_DBG_OFF -#endif - -/** - * IP6_DEBUG: Enable debugging for IPv6. - */ -#if !defined IP6_DEBUG || defined __DOXYGEN__ -#define IP6_DEBUG LWIP_DBG_OFF -#endif - -/** - * DHCP6_DEBUG: Enable debugging in dhcp6.c. - */ -#if !defined DHCP6_DEBUG || defined __DOXYGEN__ -#define DHCP6_DEBUG LWIP_DBG_OFF -#endif -/** - * @} - */ - -/** - * LWIP_TESTMODE: Changes to make unit test possible - */ -#if !defined LWIP_TESTMODE -#define LWIP_TESTMODE 0 -#endif - -/* - -------------------------------------------------- - ---------- Performance tracking options ---------- - -------------------------------------------------- -*/ -/** - * @defgroup lwip_opts_perf Performance - * @ingroup lwip_opts_debug - * @{ - */ -/** - * LWIP_PERF: Enable performance testing for lwIP - * (if enabled, arch/perf.h is included) - */ -#if !defined LWIP_PERF || defined __DOXYGEN__ -#define LWIP_PERF 0 -#endif -/** - * @} - */ - -#endif /* LWIP_HDR_OPT_H */ +/** + * @file + * + * lwIP Options Configuration + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +/* + * NOTE: || defined __DOXYGEN__ is a workaround for doxygen bug - + * without this, doxygen does not see the actual #define + */ + +#if !defined LWIP_HDR_OPT_H +#define LWIP_HDR_OPT_H + +/* + * Include user defined options first. Anything not defined in these files + * will be set to standard values. Override anything you don't like! + */ +#include "lwipopts.h" +#include "lwip/debug.h" + +/** + * @defgroup lwip_opts Options (lwipopts.h) + * @ingroup lwip + * + * @defgroup lwip_opts_debug Debugging + * @ingroup lwip_opts + * + * @defgroup lwip_opts_infrastructure Infrastructure + * @ingroup lwip_opts + * + * @defgroup lwip_opts_callback Callback-style APIs + * @ingroup lwip_opts + * + * @defgroup lwip_opts_threadsafe_apis Thread-safe APIs + * @ingroup lwip_opts + */ + + /* + ------------------------------------ + -------------- NO SYS -------------- + ------------------------------------ +*/ +/** + * @defgroup lwip_opts_nosys NO_SYS + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * NO_SYS==1: Use lwIP without OS-awareness (no thread, semaphores, mutexes or + * mboxes). This means threaded APIs cannot be used (socket, netconn, + * i.e. everything in the 'api' folder), only the callback-style raw API is + * available (and you have to watch out for yourself that you don't access + * lwIP functions/structures from more than one context at a time!) + */ +#if !defined NO_SYS || defined __DOXYGEN__ +#define NO_SYS 0 +#endif +/** + * @} + */ + +/** + * @defgroup lwip_opts_timers Timers + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * LWIP_TIMERS==0: Drop support for sys_timeout and lwip-internal cyclic timers. + * (the array of lwip-internal cyclic timers is still provided) + * (check NO_SYS_NO_TIMERS for compatibility to old versions) + */ +#if !defined LWIP_TIMERS || defined __DOXYGEN__ +#ifdef NO_SYS_NO_TIMERS +#define LWIP_TIMERS (!NO_SYS || (NO_SYS && !NO_SYS_NO_TIMERS)) +#else +#define LWIP_TIMERS 1 +#endif +#endif + +/** + * LWIP_TIMERS_CUSTOM==1: Provide your own timer implementation. + * Function prototypes in timeouts.h and the array of lwip-internal cyclic timers + * are still included, but the implementation is not. The following functions + * will be required: sys_timeouts_init(), sys_timeout(), sys_untimeout(), + * sys_timeouts_mbox_fetch() + */ +#if !defined LWIP_TIMERS_CUSTOM || defined __DOXYGEN__ +#define LWIP_TIMERS_CUSTOM 0 +#endif +/** + * @} + */ + +/** + * @defgroup lwip_opts_memcpy memcpy + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * MEMCPY: override this if you have a faster implementation at hand than the + * one included in your C library + */ +#if !defined MEMCPY || defined __DOXYGEN__ +#define MEMCPY(dst,src,len) memcpy(dst,src,len) +#endif + +/** + * SMEMCPY: override this with care! Some compilers (e.g. gcc) can inline a + * call to memcpy() if the length is known at compile time and is small. + */ +#if !defined SMEMCPY || defined __DOXYGEN__ +#define SMEMCPY(dst,src,len) memcpy(dst,src,len) +#endif + +/** + * MEMMOVE: override this if you have a faster implementation at hand than the + * one included in your C library. lwIP currently uses MEMMOVE only when IPv6 + * fragmentation support is enabled. + */ +#if !defined MEMMOVE || defined __DOXYGEN__ +#define MEMMOVE(dst,src,len) memmove(dst,src,len) +#endif +/** + * @} + */ + +/* + ------------------------------------ + ----------- Core locking ----------- + ------------------------------------ +*/ +/** + * @defgroup lwip_opts_lock Core locking and MPU + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * LWIP_MPU_COMPATIBLE: enables special memory management mechanism + * which makes lwip able to work on MPU (Memory Protection Unit) system + * by not passing stack-pointers to other threads + * (this decreases performance as memory is allocated from pools instead + * of keeping it on the stack) + */ +#if !defined LWIP_MPU_COMPATIBLE || defined __DOXYGEN__ +#define LWIP_MPU_COMPATIBLE 0 +#endif + +/** + * LWIP_TCPIP_CORE_LOCKING + * Creates a global mutex that is held during TCPIP thread operations. + * Can be locked by client code to perform lwIP operations without changing + * into TCPIP thread using callbacks. See LOCK_TCPIP_CORE() and + * UNLOCK_TCPIP_CORE(). + * Your system should provide mutexes supporting priority inversion to use this. + */ +#if !defined LWIP_TCPIP_CORE_LOCKING || defined __DOXYGEN__ +#define LWIP_TCPIP_CORE_LOCKING 1 +#endif + +/** + * LWIP_TCPIP_CORE_LOCKING_INPUT: when LWIP_TCPIP_CORE_LOCKING is enabled, + * this lets tcpip_input() grab the mutex for input packets as well, + * instead of allocating a message and passing it to tcpip_thread. + * + * ATTENTION: this does not work when tcpip_input() is called from + * interrupt context! + */ +#if !defined LWIP_TCPIP_CORE_LOCKING_INPUT || defined __DOXYGEN__ +#define LWIP_TCPIP_CORE_LOCKING_INPUT 0 +#endif + +/** + * SYS_LIGHTWEIGHT_PROT==1: enable inter-task protection (and task-vs-interrupt + * protection) for certain critical regions during buffer allocation, deallocation + * and memory allocation and deallocation. + * ATTENTION: This is required when using lwIP from more than one context! If + * you disable this, you must be sure what you are doing! + */ +#if !defined SYS_LIGHTWEIGHT_PROT || defined __DOXYGEN__ +#define SYS_LIGHTWEIGHT_PROT 1 +#endif + +/** + * Macro/function to check whether lwIP's threading/locking + * requirements are satisfied during current function call. + * This macro usually calls a function that is implemented in the OS-dependent + * sys layer and performs the following checks: + * - Not in ISR (this should be checked for NO_SYS==1, too!) + * - If @ref LWIP_TCPIP_CORE_LOCKING = 1: TCPIP core lock is held + * - If @ref LWIP_TCPIP_CORE_LOCKING = 0: function is called from TCPIP thread + * @see @ref multithreading + */ +#if !defined LWIP_ASSERT_CORE_LOCKED || defined __DOXYGEN__ +#define LWIP_ASSERT_CORE_LOCKED() +#endif + +/** + * Called as first thing in the lwIP TCPIP thread. Can be used in conjunction + * with @ref LWIP_ASSERT_CORE_LOCKED to check core locking. + * @see @ref multithreading + */ +#if !defined LWIP_MARK_TCPIP_THREAD || defined __DOXYGEN__ +#define LWIP_MARK_TCPIP_THREAD() +#endif +/** + * @} + */ + +/* + ------------------------------------ + ---------- Memory options ---------- + ------------------------------------ +*/ +/** + * @defgroup lwip_opts_mem Heap and memory pools + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * MEM_LIBC_MALLOC==1: Use malloc/free/realloc provided by your C-library + * instead of the lwip internal allocator. Can save code size if you + * already use it. + */ +#if !defined MEM_LIBC_MALLOC || defined __DOXYGEN__ +#define MEM_LIBC_MALLOC 0 +#endif + +/** + * MEMP_MEM_MALLOC==1: Use mem_malloc/mem_free instead of the lwip pool allocator. + * Especially useful with MEM_LIBC_MALLOC but handle with care regarding execution + * speed (heap alloc can be much slower than pool alloc) and usage from interrupts + * (especially if your netif driver allocates PBUF_POOL pbufs for received frames + * from interrupt)! + * ATTENTION: Currently, this uses the heap for ALL pools (also for private pools, + * not only for internal pools defined in memp_std.h)! + */ +#if !defined MEMP_MEM_MALLOC || defined __DOXYGEN__ +#define MEMP_MEM_MALLOC 0 +#endif + +/** + * MEMP_MEM_INIT==1: Force use of memset to initialize pool memory. + * Useful if pool are moved in uninitialized section of memory. This will ensure + * default values in pcbs struct are well initialized in all conditions. + */ +#if !defined MEMP_MEM_INIT || defined __DOXYGEN__ +#define MEMP_MEM_INIT 0 +#endif + +/** + * MEM_ALIGNMENT: should be set to the alignment of the CPU + * 4 byte alignment -> \#define MEM_ALIGNMENT 4 + * 2 byte alignment -> \#define MEM_ALIGNMENT 2 + */ +#if !defined MEM_ALIGNMENT || defined __DOXYGEN__ +#define MEM_ALIGNMENT 1 +#endif + +/** + * MEM_SIZE: the size of the heap memory. If the application will send + * a lot of data that needs to be copied, this should be set high. + */ +#if !defined MEM_SIZE || defined __DOXYGEN__ +#define MEM_SIZE 1600 +#endif + +/** + * MEMP_OVERFLOW_CHECK: memp overflow protection reserves a configurable + * amount of bytes before and after each memp element in every pool and fills + * it with a prominent default value. + * MEMP_OVERFLOW_CHECK == 0 no checking + * MEMP_OVERFLOW_CHECK == 1 checks each element when it is freed + * MEMP_OVERFLOW_CHECK >= 2 checks each element in every pool every time + * memp_malloc() or memp_free() is called (useful but slow!) + */ +#if !defined MEMP_OVERFLOW_CHECK || defined __DOXYGEN__ +#define MEMP_OVERFLOW_CHECK 0 +#endif + +/** + * MEMP_SANITY_CHECK==1: run a sanity check after each memp_free() to make + * sure that there are no cycles in the linked lists. + */ +#if !defined MEMP_SANITY_CHECK || defined __DOXYGEN__ +#define MEMP_SANITY_CHECK 0 +#endif + +/** + * MEM_OVERFLOW_CHECK: mem overflow protection reserves a configurable + * amount of bytes before and after each heap allocation chunk and fills + * it with a prominent default value. + * MEM_OVERFLOW_CHECK == 0 no checking + * MEM_OVERFLOW_CHECK == 1 checks each element when it is freed + * MEM_OVERFLOW_CHECK >= 2 checks all heap elements every time + * mem_malloc() or mem_free() is called (useful but slow!) + */ +#if !defined MEM_OVERFLOW_CHECK || defined __DOXYGEN__ +#define MEM_OVERFLOW_CHECK 0 +#endif + +/** + * MEM_SANITY_CHECK==1: run a sanity check after each mem_free() to make + * sure that the linked list of heap elements is not corrupted. + */ +#if !defined MEM_SANITY_CHECK || defined __DOXYGEN__ +#define MEM_SANITY_CHECK 0 +#endif + +/** + * MEM_USE_POOLS==1: Use an alternative to malloc() by allocating from a set + * of memory pools of various sizes. When mem_malloc is called, an element of + * the smallest pool that can provide the length needed is returned. + * To use this, MEMP_USE_CUSTOM_POOLS also has to be enabled. + */ +#if !defined MEM_USE_POOLS || defined __DOXYGEN__ +#define MEM_USE_POOLS 0 +#endif + +/** + * MEM_USE_POOLS_TRY_BIGGER_POOL==1: if one malloc-pool is empty, try the next + * bigger pool - WARNING: THIS MIGHT WASTE MEMORY but it can make a system more + * reliable. */ +#if !defined MEM_USE_POOLS_TRY_BIGGER_POOL || defined __DOXYGEN__ +#define MEM_USE_POOLS_TRY_BIGGER_POOL 0 +#endif + +/** + * MEMP_USE_CUSTOM_POOLS==1: whether to include a user file lwippools.h + * that defines additional pools beyond the "standard" ones required + * by lwIP. If you set this to 1, you must have lwippools.h in your + * include path somewhere. + */ +#if !defined MEMP_USE_CUSTOM_POOLS || defined __DOXYGEN__ +#define MEMP_USE_CUSTOM_POOLS 0 +#endif + +/** + * Set this to 1 if you want to free PBUF_RAM pbufs (or call mem_free()) from + * interrupt context (or another context that doesn't allow waiting for a + * semaphore). + * If set to 1, mem_malloc will be protected by a semaphore and SYS_ARCH_PROTECT, + * while mem_free will only use SYS_ARCH_PROTECT. mem_malloc SYS_ARCH_UNPROTECTs + * with each loop so that mem_free can run. + * + * ATTENTION: As you can see from the above description, this leads to dis-/ + * enabling interrupts often, which can be slow! Also, on low memory, mem_malloc + * can need longer. + * + * If you don't want that, at least for NO_SYS=0, you can still use the following + * functions to enqueue a deallocation call which then runs in the tcpip_thread + * context: + * - pbuf_free_callback(p); + * - mem_free_callback(m); + */ +#if !defined LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT || defined __DOXYGEN__ +#define LWIP_ALLOW_MEM_FREE_FROM_OTHER_CONTEXT 0 +#endif +/** + * @} + */ + +/* + ------------------------------------------------ + ---------- Internal Memory Pool Sizes ---------- + ------------------------------------------------ +*/ +/** + * @defgroup lwip_opts_memp Internal memory pools + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * MEMP_NUM_PBUF: the number of memp struct pbufs (used for PBUF_ROM and PBUF_REF). + * If the application sends a lot of data out of ROM (or other static memory), + * this should be set high. + */ +#if !defined MEMP_NUM_PBUF || defined __DOXYGEN__ +#define MEMP_NUM_PBUF 16 +#endif + +/** + * MEMP_NUM_RAW_PCB: Number of raw connection PCBs + * (requires the LWIP_RAW option) + */ +#if !defined MEMP_NUM_RAW_PCB || defined __DOXYGEN__ +#define MEMP_NUM_RAW_PCB 4 +#endif + +/** + * MEMP_NUM_UDP_PCB: the number of UDP protocol control blocks. One + * per active UDP "connection". + * (requires the LWIP_UDP option) + */ +#if !defined MEMP_NUM_UDP_PCB || defined __DOXYGEN__ +#define MEMP_NUM_UDP_PCB 4 +#endif + +/** + * MEMP_NUM_TCP_PCB: the number of simultaneously active TCP connections. + * (requires the LWIP_TCP option) + */ +#if !defined MEMP_NUM_TCP_PCB || defined __DOXYGEN__ +#define MEMP_NUM_TCP_PCB 5 +#endif + +/** + * MEMP_NUM_TCP_PCB_LISTEN: the number of listening TCP connections. + * (requires the LWIP_TCP option) + */ +#if !defined MEMP_NUM_TCP_PCB_LISTEN || defined __DOXYGEN__ +#define MEMP_NUM_TCP_PCB_LISTEN 8 +#endif + +/** + * MEMP_NUM_TCP_SEG: the number of simultaneously queued TCP segments. + * (requires the LWIP_TCP option) + */ +#if !defined MEMP_NUM_TCP_SEG || defined __DOXYGEN__ +#define MEMP_NUM_TCP_SEG 16 +#endif + +/** + * MEMP_NUM_ALTCP_PCB: the number of simultaneously active altcp layer pcbs. + * (requires the LWIP_ALTCP option) + * Connections with multiple layers require more than one altcp_pcb (e.g. TLS + * over TCP requires 2 altcp_pcbs, one for TLS and one for TCP). + */ +#if !defined MEMP_NUM_ALTCP_PCB || defined __DOXYGEN__ +#define MEMP_NUM_ALTCP_PCB MEMP_NUM_TCP_PCB +#endif + +/** + * MEMP_NUM_REASSDATA: the number of IP packets simultaneously queued for + * reassembly (whole packets, not fragments!) + */ +#if !defined MEMP_NUM_REASSDATA || defined __DOXYGEN__ +#define MEMP_NUM_REASSDATA 5 +#endif + +/** + * MEMP_NUM_FRAG_PBUF: the number of IP fragments simultaneously sent + * (fragments, not whole packets!). + * This is only used with LWIP_NETIF_TX_SINGLE_PBUF==0 and only has to be > 1 + * with DMA-enabled MACs where the packet is not yet sent when netif->output + * returns. + */ +#if !defined MEMP_NUM_FRAG_PBUF || defined __DOXYGEN__ +#define MEMP_NUM_FRAG_PBUF 15 +#endif + +/** + * MEMP_NUM_ARP_QUEUE: the number of simultaneously queued outgoing + * packets (pbufs) that are waiting for an ARP request (to resolve + * their destination address) to finish. + * (requires the ARP_QUEUEING option) + */ +#if !defined MEMP_NUM_ARP_QUEUE || defined __DOXYGEN__ +#define MEMP_NUM_ARP_QUEUE 30 +#endif + +/** + * MEMP_NUM_IGMP_GROUP: The number of multicast groups whose network interfaces + * can be members at the same time (one per netif - allsystems group -, plus one + * per netif membership). + * (requires the LWIP_IGMP option) + */ +#if !defined MEMP_NUM_IGMP_GROUP || defined __DOXYGEN__ +#define MEMP_NUM_IGMP_GROUP 8 +#endif + +/** + * The number of sys timeouts used by the core stack (not apps) + * The default number of timeouts is calculated here for all enabled modules. + */ +#define LWIP_NUM_SYS_TIMEOUT_INTERNAL (LWIP_TCP + IP_REASSEMBLY + LWIP_ARP + (2*LWIP_DHCP) + LWIP_AUTOIP + LWIP_IGMP + LWIP_DNS + PPP_NUM_TIMEOUTS + (LWIP_IPV6 * (1 + LWIP_IPV6_REASS + LWIP_IPV6_MLD))) + +/** + * MEMP_NUM_SYS_TIMEOUT: the number of simultaneously active timeouts. + * The default number of timeouts is calculated here for all enabled modules. + * The formula expects settings to be either '0' or '1'. + */ +#if !defined MEMP_NUM_SYS_TIMEOUT || defined __DOXYGEN__ +#define MEMP_NUM_SYS_TIMEOUT LWIP_NUM_SYS_TIMEOUT_INTERNAL +#endif + +/** + * MEMP_NUM_NETBUF: the number of struct netbufs. + * (only needed if you use the sequential API, like api_lib.c) + */ +#if !defined MEMP_NUM_NETBUF || defined __DOXYGEN__ +#define MEMP_NUM_NETBUF 2 +#endif + +/** + * MEMP_NUM_NETCONN: the number of struct netconns. + * (only needed if you use the sequential API, like api_lib.c) + */ +#if !defined MEMP_NUM_NETCONN || defined __DOXYGEN__ +#define MEMP_NUM_NETCONN 4 +#endif + +/** + * MEMP_NUM_SELECT_CB: the number of struct lwip_select_cb. + * (Only needed if you have LWIP_MPU_COMPATIBLE==1 and use the socket API. + * In that case, you need one per thread calling lwip_select.) + */ +#if !defined MEMP_NUM_SELECT_CB || defined __DOXYGEN__ +#define MEMP_NUM_SELECT_CB 4 +#endif + +/** + * MEMP_NUM_TCPIP_MSG_API: the number of struct tcpip_msg, which are used + * for callback/timeout API communication. + * (only needed if you use tcpip.c) + */ +#if !defined MEMP_NUM_TCPIP_MSG_API || defined __DOXYGEN__ +#define MEMP_NUM_TCPIP_MSG_API 8 +#endif + +/** + * MEMP_NUM_TCPIP_MSG_INPKT: the number of struct tcpip_msg, which are used + * for incoming packets. + * (only needed if you use tcpip.c) + */ +#if !defined MEMP_NUM_TCPIP_MSG_INPKT || defined __DOXYGEN__ +#define MEMP_NUM_TCPIP_MSG_INPKT 8 +#endif + +/** + * MEMP_NUM_NETDB: the number of concurrently running lwip_addrinfo() calls + * (before freeing the corresponding memory using lwip_freeaddrinfo()). + */ +#if !defined MEMP_NUM_NETDB || defined __DOXYGEN__ +#define MEMP_NUM_NETDB 1 +#endif + +/** + * MEMP_NUM_LOCALHOSTLIST: the number of host entries in the local host list + * if DNS_LOCAL_HOSTLIST_IS_DYNAMIC==1. + */ +#if !defined MEMP_NUM_LOCALHOSTLIST || defined __DOXYGEN__ +#define MEMP_NUM_LOCALHOSTLIST 1 +#endif + +/** + * PBUF_POOL_SIZE: the number of buffers in the pbuf pool. + */ +#if !defined PBUF_POOL_SIZE || defined __DOXYGEN__ +#define PBUF_POOL_SIZE 16 +#endif + +/** MEMP_NUM_API_MSG: the number of concurrently active calls to various + * socket, netconn, and tcpip functions + */ +#if !defined MEMP_NUM_API_MSG || defined __DOXYGEN__ +#define MEMP_NUM_API_MSG MEMP_NUM_TCPIP_MSG_API +#endif + +/** MEMP_NUM_DNS_API_MSG: the number of concurrently active calls to netconn_gethostbyname + */ +#if !defined MEMP_NUM_DNS_API_MSG || defined __DOXYGEN__ +#define MEMP_NUM_DNS_API_MSG MEMP_NUM_TCPIP_MSG_API +#endif + +/** MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA: the number of concurrently active calls + * to getsockopt/setsockopt + */ +#if !defined MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA || defined __DOXYGEN__ +#define MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA MEMP_NUM_TCPIP_MSG_API +#endif + +/** MEMP_NUM_NETIFAPI_MSG: the number of concurrently active calls to the + * netifapi functions + */ +#if !defined MEMP_NUM_NETIFAPI_MSG || defined __DOXYGEN__ +#define MEMP_NUM_NETIFAPI_MSG MEMP_NUM_TCPIP_MSG_API +#endif +/** + * @} + */ + +/* + --------------------------------- + ---------- ARP options ---------- + --------------------------------- +*/ +/** + * @defgroup lwip_opts_arp ARP + * @ingroup lwip_opts_ipv4 + * @{ + */ +/** + * LWIP_ARP==1: Enable ARP functionality. + */ +#if !defined LWIP_ARP || defined __DOXYGEN__ +#define LWIP_ARP 1 +#endif + +/** + * ARP_TABLE_SIZE: Number of active MAC-IP address pairs cached. + */ +#if !defined ARP_TABLE_SIZE || defined __DOXYGEN__ +#define ARP_TABLE_SIZE 10 +#endif + +/** the time an ARP entry stays valid after its last update, + * for ARP_TMR_INTERVAL = 1000, this is + * (60 * 5) seconds = 5 minutes. + */ +#if !defined ARP_MAXAGE || defined __DOXYGEN__ +#define ARP_MAXAGE 300 +#endif + +/** + * ARP_QUEUEING==1: Multiple outgoing packets are queued during hardware address + * resolution. By default, only the most recent packet is queued per IP address. + * This is sufficient for most protocols and mainly reduces TCP connection + * startup time. Set this to 1 if you know your application sends more than one + * packet in a row to an IP address that is not in the ARP cache. + */ +#if !defined ARP_QUEUEING || defined __DOXYGEN__ +#define ARP_QUEUEING 0 +#endif + +/** The maximum number of packets which may be queued for each + * unresolved address by other network layers. Defaults to 3, 0 means disabled. + * Old packets are dropped, new packets are queued. + */ +#if !defined ARP_QUEUE_LEN || defined __DOXYGEN__ +#define ARP_QUEUE_LEN 3 +#endif + +/** + * ETHARP_SUPPORT_VLAN==1: support receiving and sending ethernet packets with + * VLAN header. See the description of LWIP_HOOK_VLAN_CHECK and + * LWIP_HOOK_VLAN_SET hooks to check/set VLAN headers. + * Additionally, you can define ETHARP_VLAN_CHECK to an u16_t VLAN ID to check. + * If ETHARP_VLAN_CHECK is defined, only VLAN-traffic for this VLAN is accepted. + * If ETHARP_VLAN_CHECK is not defined, all traffic is accepted. + * Alternatively, define a function/define ETHARP_VLAN_CHECK_FN(eth_hdr, vlan) + * that returns 1 to accept a packet or 0 to drop a packet. + */ +#if !defined ETHARP_SUPPORT_VLAN || defined __DOXYGEN__ +#define ETHARP_SUPPORT_VLAN 0 +#endif + +/** LWIP_ETHERNET==1: enable ethernet support even though ARP might be disabled + */ +#if !defined LWIP_ETHERNET || defined __DOXYGEN__ +#define LWIP_ETHERNET LWIP_ARP +#endif + +/** ETH_PAD_SIZE: number of bytes added before the ethernet header to ensure + * alignment of payload after that header. Since the header is 14 bytes long, + * without this padding e.g. addresses in the IP header will not be aligned + * on a 32-bit boundary, so setting this to 2 can speed up 32-bit-platforms. + */ +#if !defined ETH_PAD_SIZE || defined __DOXYGEN__ +#define ETH_PAD_SIZE 0 +#endif + +/** ETHARP_SUPPORT_STATIC_ENTRIES==1: enable code to support static ARP table + * entries (using etharp_add_static_entry/etharp_remove_static_entry). + */ +#if !defined ETHARP_SUPPORT_STATIC_ENTRIES || defined __DOXYGEN__ +#define ETHARP_SUPPORT_STATIC_ENTRIES 0 +#endif + +/** ETHARP_TABLE_MATCH_NETIF==1: Match netif for ARP table entries. + * If disabled, duplicate IP address on multiple netifs are not supported + * (but this should only occur for AutoIP). + */ +#if !defined ETHARP_TABLE_MATCH_NETIF || defined __DOXYGEN__ +#define ETHARP_TABLE_MATCH_NETIF !LWIP_SINGLE_NETIF +#endif +/** + * @} + */ + +/* + -------------------------------- + ---------- IP options ---------- + -------------------------------- +*/ +/** + * @defgroup lwip_opts_ipv4 IPv4 + * @ingroup lwip_opts + * @{ + */ +/** + * LWIP_IPV4==1: Enable IPv4 + */ +#if !defined LWIP_IPV4 || defined __DOXYGEN__ +#define LWIP_IPV4 1 +#endif + +/** + * IP_FORWARD==1: Enables the ability to forward IP packets across network + * interfaces. If you are going to run lwIP on a device with only one network + * interface, define this to 0. + */ +#if !defined IP_FORWARD || defined __DOXYGEN__ +#define IP_FORWARD 0 +#endif + +/** + * IP_REASSEMBLY==1: Reassemble incoming fragmented IP packets. Note that + * this option does not affect outgoing packet sizes, which can be controlled + * via IP_FRAG. + */ +#if !defined IP_REASSEMBLY || defined __DOXYGEN__ +#define IP_REASSEMBLY 1 +#endif + +/** + * IP_FRAG==1: Fragment outgoing IP packets if their size exceeds MTU. Note + * that this option does not affect incoming packet sizes, which can be + * controlled via IP_REASSEMBLY. + */ +#if !defined IP_FRAG || defined __DOXYGEN__ +#define IP_FRAG 1 +#endif + +#if !LWIP_IPV4 +/* disable IPv4 extensions when IPv4 is disabled */ +#undef IP_FORWARD +#define IP_FORWARD 0 +#undef IP_REASSEMBLY +#define IP_REASSEMBLY 0 +#undef IP_FRAG +#define IP_FRAG 0 +#endif /* !LWIP_IPV4 */ + +/** + * IP_OPTIONS_ALLOWED: Defines the behavior for IP options. + * IP_OPTIONS_ALLOWED==0: All packets with IP options are dropped. + * IP_OPTIONS_ALLOWED==1: IP options are allowed (but not parsed). + */ +#if !defined IP_OPTIONS_ALLOWED || defined __DOXYGEN__ +#define IP_OPTIONS_ALLOWED 1 +#endif + +/** + * IP_REASS_MAXAGE: Maximum time (in multiples of IP_TMR_INTERVAL - so seconds, normally) + * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived + * in this time, the whole packet is discarded. + */ +#if !defined IP_REASS_MAXAGE || defined __DOXYGEN__ +#define IP_REASS_MAXAGE 15 +#endif + +/** + * IP_REASS_MAX_PBUFS: Total maximum amount of pbufs waiting to be reassembled. + * Since the received pbufs are enqueued, be sure to configure + * PBUF_POOL_SIZE > IP_REASS_MAX_PBUFS so that the stack is still able to receive + * packets even if the maximum amount of fragments is enqueued for reassembly! + * When IPv4 *and* IPv6 are enabled, this even changes to + * (PBUF_POOL_SIZE > 2 * IP_REASS_MAX_PBUFS)! + */ +#if !defined IP_REASS_MAX_PBUFS || defined __DOXYGEN__ +#define IP_REASS_MAX_PBUFS 10 +#endif + +/** + * IP_DEFAULT_TTL: Default value for Time-To-Live used by transport layers. + */ +#if !defined IP_DEFAULT_TTL || defined __DOXYGEN__ +#define IP_DEFAULT_TTL 255 +#endif + +/** + * IP_SOF_BROADCAST=1: Use the SOF_BROADCAST field to enable broadcast + * filter per pcb on udp and raw send operations. To enable broadcast filter + * on recv operations, you also have to set IP_SOF_BROADCAST_RECV=1. + */ +#if !defined IP_SOF_BROADCAST || defined __DOXYGEN__ +#define IP_SOF_BROADCAST 0 +#endif + +/** + * IP_SOF_BROADCAST_RECV (requires IP_SOF_BROADCAST=1) enable the broadcast + * filter on recv operations. + */ +#if !defined IP_SOF_BROADCAST_RECV || defined __DOXYGEN__ +#define IP_SOF_BROADCAST_RECV 0 +#endif + +/** + * IP_FORWARD_ALLOW_TX_ON_RX_NETIF==1: allow ip_forward() to send packets back + * out on the netif where it was received. This should only be used for + * wireless networks. + * ATTENTION: When this is 1, make sure your netif driver correctly marks incoming + * link-layer-broadcast/multicast packets as such using the corresponding pbuf flags! + */ +#if !defined IP_FORWARD_ALLOW_TX_ON_RX_NETIF || defined __DOXYGEN__ +#define IP_FORWARD_ALLOW_TX_ON_RX_NETIF 0 +#endif +/** + * @} + */ + +/* + ---------------------------------- + ---------- ICMP options ---------- + ---------------------------------- +*/ +/** + * @defgroup lwip_opts_icmp ICMP + * @ingroup lwip_opts_ipv4 + * @{ + */ +/** + * LWIP_ICMP==1: Enable ICMP module inside the IP stack. + * Be careful, disable that make your product non-compliant to RFC1122 + */ +#if !defined LWIP_ICMP || defined __DOXYGEN__ +#define LWIP_ICMP 1 +#endif + +/** + * ICMP_TTL: Default value for Time-To-Live used by ICMP packets. + */ +#if !defined ICMP_TTL || defined __DOXYGEN__ +#define ICMP_TTL IP_DEFAULT_TTL +#endif + +/** + * LWIP_BROADCAST_PING==1: respond to broadcast pings (default is unicast only) + */ +#if !defined LWIP_BROADCAST_PING || defined __DOXYGEN__ +#define LWIP_BROADCAST_PING 0 +#endif + +/** + * LWIP_MULTICAST_PING==1: respond to multicast pings (default is unicast only) + */ +#if !defined LWIP_MULTICAST_PING || defined __DOXYGEN__ +#define LWIP_MULTICAST_PING 0 +#endif +/** + * @} + */ + +/* + --------------------------------- + ---------- RAW options ---------- + --------------------------------- +*/ +/** + * @defgroup lwip_opts_raw RAW + * @ingroup lwip_opts_callback + * @{ + */ +/** + * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. + */ +#if !defined LWIP_RAW || defined __DOXYGEN__ +#define LWIP_RAW 1 +#endif + +/** + * LWIP_RAW==1: Enable application layer to hook into the IP layer itself. + */ +#if !defined RAW_TTL || defined __DOXYGEN__ +#define RAW_TTL IP_DEFAULT_TTL +#endif +/** + * @} + */ + +/* + ---------------------------------- + ---------- DHCP options ---------- + ---------------------------------- +*/ +/** + * @defgroup lwip_opts_dhcp DHCP + * @ingroup lwip_opts_ipv4 + * @{ + */ +/** + * LWIP_DHCP==1: Enable DHCP module. + */ +#if !defined LWIP_DHCP || defined __DOXYGEN__ +#define LWIP_DHCP 0 +#endif +#if !LWIP_IPV4 +/* disable DHCP when IPv4 is disabled */ +#undef LWIP_DHCP +#define LWIP_DHCP 0 +#endif /* !LWIP_IPV4 */ + +/** + * DHCP_DOES_ARP_CHECK==1: Do an ARP check on the offered address. + */ +#if !defined DHCP_DOES_ARP_CHECK || defined __DOXYGEN__ +#define DHCP_DOES_ARP_CHECK (LWIP_DHCP && LWIP_ARP) +#endif + +/** + * LWIP_DHCP_BOOTP_FILE==1: Store offered_si_addr and boot_file_name. + */ +#if !defined LWIP_DHCP_BOOTP_FILE || defined __DOXYGEN__ +#define LWIP_DHCP_BOOTP_FILE 0 +#endif + +/** + * LWIP_DHCP_GETS_NTP==1: Request NTP servers with discover/select. For each + * response packet, an callback is called, which has to be provided by the port: + * void dhcp_set_ntp_servers(u8_t num_ntp_servers, ip_addr_t* ntp_server_addrs); +*/ +#if !defined LWIP_DHCP_GET_NTP_SRV || defined __DOXYGEN__ +#define LWIP_DHCP_GET_NTP_SRV 0 +#endif + +/** + * The maximum of NTP servers requested + */ +#if !defined LWIP_DHCP_MAX_NTP_SERVERS || defined __DOXYGEN__ +#define LWIP_DHCP_MAX_NTP_SERVERS 1 +#endif + +/** + * LWIP_DHCP_MAX_DNS_SERVERS > 0: Request DNS servers with discover/select. + * DNS servers received in the response are passed to DNS via @ref dns_setserver() + * (up to the maximum limit defined here). + */ +#if !defined LWIP_DHCP_MAX_DNS_SERVERS || defined __DOXYGEN__ +#define LWIP_DHCP_MAX_DNS_SERVERS DNS_MAX_SERVERS +#endif +/** + * @} + */ + +/* + ------------------------------------ + ---------- AUTOIP options ---------- + ------------------------------------ +*/ +/** + * @defgroup lwip_opts_autoip AUTOIP + * @ingroup lwip_opts_ipv4 + * @{ + */ +/** + * LWIP_AUTOIP==1: Enable AUTOIP module. + */ +#if !defined LWIP_AUTOIP || defined __DOXYGEN__ +#define LWIP_AUTOIP 0 +#endif +#if !LWIP_IPV4 +/* disable AUTOIP when IPv4 is disabled */ +#undef LWIP_AUTOIP +#define LWIP_AUTOIP 0 +#endif /* !LWIP_IPV4 */ + +/** + * LWIP_DHCP_AUTOIP_COOP==1: Allow DHCP and AUTOIP to be both enabled on + * the same interface at the same time. + */ +#if !defined LWIP_DHCP_AUTOIP_COOP || defined __DOXYGEN__ +#define LWIP_DHCP_AUTOIP_COOP 0 +#endif + +/** + * LWIP_DHCP_AUTOIP_COOP_TRIES: Set to the number of DHCP DISCOVER probes + * that should be sent before falling back on AUTOIP (the DHCP client keeps + * running in this case). This can be set as low as 1 to get an AutoIP address + * very quickly, but you should be prepared to handle a changing IP address + * when DHCP overrides AutoIP. + */ +#if !defined LWIP_DHCP_AUTOIP_COOP_TRIES || defined __DOXYGEN__ +#define LWIP_DHCP_AUTOIP_COOP_TRIES 9 +#endif +/** + * @} + */ + +/* + ---------------------------------- + ----- SNMP MIB2 support ----- + ---------------------------------- +*/ +/** + * @defgroup lwip_opts_mib2 SNMP MIB2 callbacks + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * LWIP_MIB2_CALLBACKS==1: Turn on SNMP MIB2 callbacks. + * Turn this on to get callbacks needed to implement MIB2. + * Usually MIB2_STATS should be enabled, too. + */ +#if !defined LWIP_MIB2_CALLBACKS || defined __DOXYGEN__ +#define LWIP_MIB2_CALLBACKS 0 +#endif +/** + * @} + */ + +/* + ---------------------------------- + -------- Multicast options ------- + ---------------------------------- +*/ +/** + * @defgroup lwip_opts_multicast Multicast + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * LWIP_MULTICAST_TX_OPTIONS==1: Enable multicast TX support like the socket options + * IP_MULTICAST_TTL/IP_MULTICAST_IF/IP_MULTICAST_LOOP, as well as (currently only) + * core support for the corresponding IPv6 options. + */ +#if !defined LWIP_MULTICAST_TX_OPTIONS || defined __DOXYGEN__ +#define LWIP_MULTICAST_TX_OPTIONS ((LWIP_IGMP || LWIP_IPV6_MLD) && (LWIP_UDP || LWIP_RAW)) +#endif +/** + * @} + */ + +/* + ---------------------------------- + ---------- IGMP options ---------- + ---------------------------------- +*/ +/** + * @defgroup lwip_opts_igmp IGMP + * @ingroup lwip_opts_ipv4 + * @{ + */ +/** + * LWIP_IGMP==1: Turn on IGMP module. + */ +#if !defined LWIP_IGMP || defined __DOXYGEN__ +#define LWIP_IGMP 0 +#endif +#if !LWIP_IPV4 +#undef LWIP_IGMP +#define LWIP_IGMP 0 +#endif +/** + * @} + */ + +/* + ---------------------------------- + ---------- DNS options ----------- + ---------------------------------- +*/ +/** + * @defgroup lwip_opts_dns DNS + * @ingroup lwip_opts_callback + * @{ + */ +/** + * LWIP_DNS==1: Turn on DNS module. UDP must be available for DNS + * transport. + */ +#if !defined LWIP_DNS || defined __DOXYGEN__ +#define LWIP_DNS 0 +#endif + +/** DNS maximum number of entries to maintain locally. */ +#if !defined DNS_TABLE_SIZE || defined __DOXYGEN__ +#define DNS_TABLE_SIZE 4 +#endif + +/** DNS maximum host name length supported in the name table. */ +#if !defined DNS_MAX_NAME_LENGTH || defined __DOXYGEN__ +#define DNS_MAX_NAME_LENGTH 256 +#endif + +/** The maximum of DNS servers + * The first server can be initialized automatically by defining + * DNS_SERVER_ADDRESS(ipaddr), where 'ipaddr' is an 'ip_addr_t*' + */ +#if !defined DNS_MAX_SERVERS || defined __DOXYGEN__ +#define DNS_MAX_SERVERS 2 +#endif + +/** DNS maximum number of retries when asking for a name, before "timeout". */ +#if !defined DNS_MAX_RETRIES || defined __DOXYGEN__ +#define DNS_MAX_RETRIES 4 +#endif + +/** DNS do a name checking between the query and the response. */ +#if !defined DNS_DOES_NAME_CHECK || defined __DOXYGEN__ +#define DNS_DOES_NAME_CHECK 1 +#endif + +/** LWIP_DNS_SECURE: controls the security level of the DNS implementation + * Use all DNS security features by default. + * This is overridable but should only be needed by very small targets + * or when using against non standard DNS servers. */ +#if !defined LWIP_DNS_SECURE || defined __DOXYGEN__ +#define LWIP_DNS_SECURE (LWIP_DNS_SECURE_RAND_XID | LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING | LWIP_DNS_SECURE_RAND_SRC_PORT) +#endif + +/* A list of DNS security features follows */ +#define LWIP_DNS_SECURE_RAND_XID 1 +#define LWIP_DNS_SECURE_NO_MULTIPLE_OUTSTANDING 2 +#define LWIP_DNS_SECURE_RAND_SRC_PORT 4 + +/** DNS_LOCAL_HOSTLIST: Implements a local host-to-address list. If enabled, you have to define an initializer: + * \#define DNS_LOCAL_HOSTLIST_INIT {DNS_LOCAL_HOSTLIST_ELEM("host_ip4", IPADDR4_INIT_BYTES(1,2,3,4)), \ + * DNS_LOCAL_HOSTLIST_ELEM("host_ip6", IPADDR6_INIT_HOST(123, 234, 345, 456)} + * + * Instead, you can also use an external function: + * \#define DNS_LOOKUP_LOCAL_EXTERN(x) extern err_t my_lookup_function(const char *name, ip_addr_t *addr, u8_t dns_addrtype) + * that looks up the IP address and returns ERR_OK if found (LWIP_DNS_ADDRTYPE_xxx is passed in dns_addrtype). + */ +#if !defined DNS_LOCAL_HOSTLIST || defined __DOXYGEN__ +#define DNS_LOCAL_HOSTLIST 0 +#endif /* DNS_LOCAL_HOSTLIST */ + +/** If this is turned on, the local host-list can be dynamically changed + * at runtime. */ +#if !defined DNS_LOCAL_HOSTLIST_IS_DYNAMIC || defined __DOXYGEN__ +#define DNS_LOCAL_HOSTLIST_IS_DYNAMIC 0 +#endif /* DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + +/** Set this to 1 to enable querying ".local" names via mDNS + * using a One-Shot Multicast DNS Query */ +#if !defined LWIP_DNS_SUPPORT_MDNS_QUERIES || defined __DOXYGEN__ +#define LWIP_DNS_SUPPORT_MDNS_QUERIES 0 +#endif +/** + * @} + */ + +/* + --------------------------------- + ---------- UDP options ---------- + --------------------------------- +*/ +/** + * @defgroup lwip_opts_udp UDP + * @ingroup lwip_opts_callback + * @{ + */ +/** + * LWIP_UDP==1: Turn on UDP. + */ +#if !defined LWIP_UDP || defined __DOXYGEN__ +#define LWIP_UDP 1 +#endif + +/** + * LWIP_UDPLITE==1: Turn on UDP-Lite. (Requires LWIP_UDP) + */ +#if !defined LWIP_UDPLITE || defined __DOXYGEN__ +#define LWIP_UDPLITE 0 +#endif + +/** + * UDP_TTL: Default Time-To-Live value. + */ +#if !defined UDP_TTL || defined __DOXYGEN__ +#define UDP_TTL IP_DEFAULT_TTL +#endif + +/** + * LWIP_NETBUF_RECVINFO==1: append destination addr and port to every netbuf. + */ +#if !defined LWIP_NETBUF_RECVINFO || defined __DOXYGEN__ +#define LWIP_NETBUF_RECVINFO 0 +#endif +/** + * @} + */ + +/* + --------------------------------- + ---------- TCP options ---------- + --------------------------------- +*/ +/** + * @defgroup lwip_opts_tcp TCP + * @ingroup lwip_opts_callback + * @{ + */ +/** + * LWIP_TCP==1: Turn on TCP. + */ +#if !defined LWIP_TCP || defined __DOXYGEN__ +#define LWIP_TCP 1 +#endif + +/** + * TCP_TTL: Default Time-To-Live value. + */ +#if !defined TCP_TTL || defined __DOXYGEN__ +#define TCP_TTL IP_DEFAULT_TTL +#endif + +/** + * TCP_WND: The size of a TCP window. This must be at least + * (2 * TCP_MSS) for things to work well. + * ATTENTION: when using TCP_RCV_SCALE, TCP_WND is the total size + * with scaling applied. Maximum window value in the TCP header + * will be TCP_WND >> TCP_RCV_SCALE + */ +#if !defined TCP_WND || defined __DOXYGEN__ +#define TCP_WND (4 * TCP_MSS) +#endif + +/** + * TCP_MAXRTX: Maximum number of retransmissions of data segments. + */ +#if !defined TCP_MAXRTX || defined __DOXYGEN__ +#define TCP_MAXRTX 12 +#endif + +/** + * TCP_SYNMAXRTX: Maximum number of retransmissions of SYN segments. + */ +#if !defined TCP_SYNMAXRTX || defined __DOXYGEN__ +#define TCP_SYNMAXRTX 6 +#endif + +/** + * TCP_QUEUE_OOSEQ==1: TCP will queue segments that arrive out of order. + * Define to 0 if your device is low on memory. + */ +#if !defined TCP_QUEUE_OOSEQ || defined __DOXYGEN__ +#define TCP_QUEUE_OOSEQ LWIP_TCP +#endif + +/** + * LWIP_TCP_SACK_OUT==1: TCP will support sending selective acknowledgements (SACKs). + */ +#if !defined LWIP_TCP_SACK_OUT || defined __DOXYGEN__ +#define LWIP_TCP_SACK_OUT 0 +#endif + +/** + * LWIP_TCP_MAX_SACK_NUM: The maximum number of SACK values to include in TCP segments. + * Must be at least 1, but is only used if LWIP_TCP_SACK_OUT is enabled. + * NOTE: Even though we never send more than 3 or 4 SACK ranges in a single segment + * (depending on other options), setting this option to values greater than 4 is not pointless. + * This is basically the max number of SACK ranges we want to keep track of. + * As new data is delivered, some of the SACK ranges may be removed or merged. + * In that case some of those older SACK ranges may be used again. + * The amount of memory used to store SACK ranges is LWIP_TCP_MAX_SACK_NUM * 8 bytes for each TCP PCB. + */ +#if !defined LWIP_TCP_MAX_SACK_NUM || defined __DOXYGEN__ +#define LWIP_TCP_MAX_SACK_NUM 4 +#endif + +/** + * TCP_MSS: TCP Maximum segment size. (default is 536, a conservative default, + * you might want to increase this.) + * For the receive side, this MSS is advertised to the remote side + * when opening a connection. For the transmit size, this MSS sets + * an upper limit on the MSS advertised by the remote host. + */ +#if !defined TCP_MSS || defined __DOXYGEN__ +#define TCP_MSS 536 +#endif + +/** + * TCP_CALCULATE_EFF_SEND_MSS: "The maximum size of a segment that TCP really + * sends, the 'effective send MSS,' MUST be the smaller of the send MSS (which + * reflects the available reassembly buffer size at the remote host) and the + * largest size permitted by the IP layer" (RFC 1122) + * Setting this to 1 enables code that checks TCP_MSS against the MTU of the + * netif used for a connection and limits the MSS if it would be too big otherwise. + */ +#if !defined TCP_CALCULATE_EFF_SEND_MSS || defined __DOXYGEN__ +#define TCP_CALCULATE_EFF_SEND_MSS 1 +#endif + + +/** + * TCP_SND_BUF: TCP sender buffer space (bytes). + * To achieve good performance, this should be at least 2 * TCP_MSS. + */ +#if !defined TCP_SND_BUF || defined __DOXYGEN__ +#define TCP_SND_BUF (2 * TCP_MSS) +#endif + +/** + * TCP_SND_QUEUELEN: TCP sender buffer space (pbufs). This must be at least + * as much as (2 * TCP_SND_BUF/TCP_MSS) for things to work. + */ +#if !defined TCP_SND_QUEUELEN || defined __DOXYGEN__ +#define TCP_SND_QUEUELEN ((4 * (TCP_SND_BUF) + (TCP_MSS - 1))/(TCP_MSS)) +#endif + +/** + * TCP_SNDLOWAT: TCP writable space (bytes). This must be less than + * TCP_SND_BUF. It is the amount of space which must be available in the + * TCP snd_buf for select to return writable (combined with TCP_SNDQUEUELOWAT). + */ +#if !defined TCP_SNDLOWAT || defined __DOXYGEN__ +#define TCP_SNDLOWAT LWIP_MIN(LWIP_MAX(((TCP_SND_BUF)/2), (2 * TCP_MSS) + 1), (TCP_SND_BUF) - 1) +#endif + +/** + * TCP_SNDQUEUELOWAT: TCP writable bufs (pbuf count). This must be less + * than TCP_SND_QUEUELEN. If the number of pbufs queued on a pcb drops below + * this number, select returns writable (combined with TCP_SNDLOWAT). + */ +#if !defined TCP_SNDQUEUELOWAT || defined __DOXYGEN__ +#define TCP_SNDQUEUELOWAT LWIP_MAX(((TCP_SND_QUEUELEN)/2), 5) +#endif + +/** + * TCP_OOSEQ_MAX_BYTES: The default maximum number of bytes queued on ooseq per + * pcb if TCP_OOSEQ_BYTES_LIMIT is not defined. Default is 0 (no limit). + * Only valid for TCP_QUEUE_OOSEQ==1. + */ +#if !defined TCP_OOSEQ_MAX_BYTES || defined __DOXYGEN__ +#define TCP_OOSEQ_MAX_BYTES 0 +#endif + +/** + * TCP_OOSEQ_BYTES_LIMIT(pcb): Return the maximum number of bytes to be queued + * on ooseq per pcb, given the pcb. Only valid for TCP_QUEUE_OOSEQ==1 && + * TCP_OOSEQ_MAX_BYTES==1. + * Use this to override TCP_OOSEQ_MAX_BYTES to a dynamic value per pcb. + */ +#if !defined TCP_OOSEQ_BYTES_LIMIT +#if TCP_OOSEQ_MAX_BYTES +#define TCP_OOSEQ_BYTES_LIMIT(pcb) TCP_OOSEQ_MAX_BYTES +#elif defined __DOXYGEN__ +#define TCP_OOSEQ_BYTES_LIMIT(pcb) +#endif +#endif + +/** + * TCP_OOSEQ_MAX_PBUFS: The default maximum number of pbufs queued on ooseq per + * pcb if TCP_OOSEQ_BYTES_LIMIT is not defined. Default is 0 (no limit). + * Only valid for TCP_QUEUE_OOSEQ==1. + */ +#if !defined TCP_OOSEQ_MAX_PBUFS || defined __DOXYGEN__ +#define TCP_OOSEQ_MAX_PBUFS 0 +#endif + +/** + * TCP_OOSEQ_PBUFS_LIMIT(pcb): Return the maximum number of pbufs to be queued + * on ooseq per pcb, given the pcb. Only valid for TCP_QUEUE_OOSEQ==1 && + * TCP_OOSEQ_MAX_PBUFS==1. + * Use this to override TCP_OOSEQ_MAX_PBUFS to a dynamic value per pcb. + */ +#if !defined TCP_OOSEQ_PBUFS_LIMIT +#if TCP_OOSEQ_MAX_PBUFS +#define TCP_OOSEQ_PBUFS_LIMIT(pcb) TCP_OOSEQ_MAX_PBUFS +#elif defined __DOXYGEN__ +#define TCP_OOSEQ_PBUFS_LIMIT(pcb) +#endif +#endif + +/** + * TCP_LISTEN_BACKLOG: Enable the backlog option for tcp listen pcb. + */ +#if !defined TCP_LISTEN_BACKLOG || defined __DOXYGEN__ +#define TCP_LISTEN_BACKLOG 0 +#endif + +/** + * The maximum allowed backlog for TCP listen netconns. + * This backlog is used unless another is explicitly specified. + * 0xff is the maximum (u8_t). + */ +#if !defined TCP_DEFAULT_LISTEN_BACKLOG || defined __DOXYGEN__ +#define TCP_DEFAULT_LISTEN_BACKLOG 0xff +#endif + +/** + * TCP_OVERSIZE: The maximum number of bytes that tcp_write may + * allocate ahead of time in an attempt to create shorter pbuf chains + * for transmission. The meaningful range is 0 to TCP_MSS. Some + * suggested values are: + * + * 0: Disable oversized allocation. Each tcp_write() allocates a new + pbuf (old behaviour). + * 1: Allocate size-aligned pbufs with minimal excess. Use this if your + * scatter-gather DMA requires aligned fragments. + * 128: Limit the pbuf/memory overhead to 20%. + * TCP_MSS: Try to create unfragmented TCP packets. + * TCP_MSS/4: Try to create 4 fragments or less per TCP packet. + */ +#if !defined TCP_OVERSIZE || defined __DOXYGEN__ +#define TCP_OVERSIZE TCP_MSS +#endif + +/** + * LWIP_TCP_TIMESTAMPS==1: support the TCP timestamp option. + * The timestamp option is currently only used to help remote hosts, it is not + * really used locally. Therefore, it is only enabled when a TS option is + * received in the initial SYN packet from a remote host. + */ +#if !defined LWIP_TCP_TIMESTAMPS || defined __DOXYGEN__ +#define LWIP_TCP_TIMESTAMPS 0 +#endif + +/** + * TCP_WND_UPDATE_THRESHOLD: difference in window to trigger an + * explicit window update + */ +#if !defined TCP_WND_UPDATE_THRESHOLD || defined __DOXYGEN__ +#define TCP_WND_UPDATE_THRESHOLD LWIP_MIN((TCP_WND / 4), (TCP_MSS * 4)) +#endif + +/** + * LWIP_EVENT_API and LWIP_CALLBACK_API: Only one of these should be set to 1. + * LWIP_EVENT_API==1: The user defines lwip_tcp_event() to receive all + * events (accept, sent, etc) that happen in the system. + * LWIP_CALLBACK_API==1: The PCB callback function is called directly + * for the event. This is the default. + */ +#if !defined(LWIP_EVENT_API) && !defined(LWIP_CALLBACK_API) || defined __DOXYGEN__ +#define LWIP_EVENT_API 0 +#define LWIP_CALLBACK_API 1 +#else +#ifndef LWIP_EVENT_API +#define LWIP_EVENT_API 0 +#endif +#ifndef LWIP_CALLBACK_API +#define LWIP_CALLBACK_API 0 +#endif +#endif + +/** + * LWIP_WND_SCALE and TCP_RCV_SCALE: + * Set LWIP_WND_SCALE to 1 to enable window scaling. + * Set TCP_RCV_SCALE to the desired scaling factor (shift count in the + * range of [0..14]). + * When LWIP_WND_SCALE is enabled but TCP_RCV_SCALE is 0, we can use a large + * send window while having a small receive window only. + */ +#if !defined LWIP_WND_SCALE || defined __DOXYGEN__ +#define LWIP_WND_SCALE 0 +#define TCP_RCV_SCALE 0 +#endif + +/** + * LWIP_TCP_PCB_NUM_EXT_ARGS: + * When this is > 0, every tcp pcb (including listen pcb) includes a number of + * additional argument entries in an array (see tcp_ext_arg_alloc_id) + */ +#if !defined LWIP_TCP_PCB_NUM_EXT_ARGS || defined __DOXYGEN__ +#define LWIP_TCP_PCB_NUM_EXT_ARGS 0 +#endif + +/** LWIP_ALTCP==1: enable the altcp API. + * altcp is an abstraction layer that prevents applications linking against the + * tcp.h functions but provides the same functionality. It is used to e.g. add + * SSL/TLS or proxy-connect support to an application written for the tcp callback + * API without that application knowing the protocol details. + * + * With LWIP_ALTCP==0, applications written against the altcp API can still be + * compiled but are directly linked against the tcp.h callback API and then + * cannot use layered protocols. + * + * See @ref altcp_api + */ +#if !defined LWIP_ALTCP || defined __DOXYGEN__ +#define LWIP_ALTCP 0 +#endif + +/** LWIP_ALTCP_TLS==1: enable TLS support for altcp API. + * This needs a port of the functions in altcp_tls.h to a TLS library. + * A port to ARM mbedtls is provided with lwIP, see apps/altcp_tls/ directory + * and LWIP_ALTCP_TLS_MBEDTLS option. + */ +#if !defined LWIP_ALTCP_TLS || defined __DOXYGEN__ +#define LWIP_ALTCP_TLS 0 +#endif + +/** + * @} + */ + +/* + ---------------------------------- + ---------- Pbuf options ---------- + ---------------------------------- +*/ +/** + * @defgroup lwip_opts_pbuf PBUF + * @ingroup lwip_opts + * @{ + */ +/** + * PBUF_LINK_HLEN: the number of bytes that should be allocated for a + * link level header. The default is 14, the standard value for + * Ethernet. + */ +#if !defined PBUF_LINK_HLEN || defined __DOXYGEN__ +#if defined LWIP_HOOK_VLAN_SET && !defined __DOXYGEN__ +#define PBUF_LINK_HLEN (18 + ETH_PAD_SIZE) +#else /* LWIP_HOOK_VLAN_SET */ +#define PBUF_LINK_HLEN (14 + ETH_PAD_SIZE) +#endif /* LWIP_HOOK_VLAN_SET */ +#endif + +/** + * PBUF_LINK_ENCAPSULATION_HLEN: the number of bytes that should be allocated + * for an additional encapsulation header before ethernet headers (e.g. 802.11) + */ +#if !defined PBUF_LINK_ENCAPSULATION_HLEN || defined __DOXYGEN__ +#define PBUF_LINK_ENCAPSULATION_HLEN 0 +#endif + +/** + * PBUF_POOL_BUFSIZE: the size of each pbuf in the pbuf pool. The default is + * designed to accommodate single full size TCP frame in one pbuf, including + * TCP_MSS, IP header, and link header. + */ +#if !defined PBUF_POOL_BUFSIZE || defined __DOXYGEN__ +#define PBUF_POOL_BUFSIZE LWIP_MEM_ALIGN_SIZE(TCP_MSS+40+PBUF_LINK_ENCAPSULATION_HLEN+PBUF_LINK_HLEN) +#endif + +/** + * LWIP_PBUF_REF_T: Refcount type in pbuf. + * Default width of u8_t can be increased if 255 refs are not enough for you. + */ +#if !defined LWIP_PBUF_REF_T || defined __DOXYGEN__ +#define LWIP_PBUF_REF_T u8_t +#endif +/** + * @} + */ + +/* + ------------------------------------------------ + ---------- Network Interfaces options ---------- + ------------------------------------------------ +*/ +/** + * @defgroup lwip_opts_netif NETIF + * @ingroup lwip_opts + * @{ + */ +/** + * LWIP_SINGLE_NETIF==1: use a single netif only. This is the common case for + * small real-life targets. Some code like routing etc. can be left out. + */ +#if !defined LWIP_SINGLE_NETIF || defined __DOXYGEN__ +#define LWIP_SINGLE_NETIF 0 +#endif + +/** + * LWIP_NETIF_HOSTNAME==1: use DHCP_OPTION_HOSTNAME with netif's hostname + * field. + */ +#if !defined LWIP_NETIF_HOSTNAME || defined __DOXYGEN__ +#define LWIP_NETIF_HOSTNAME 0 +#endif + +/** + * LWIP_NETIF_API==1: Support netif api (in netifapi.c) + */ +#if !defined LWIP_NETIF_API || defined __DOXYGEN__ +#define LWIP_NETIF_API 0 +#endif + +/** + * LWIP_NETIF_STATUS_CALLBACK==1: Support a callback function whenever an interface + * changes its up/down status (i.e., due to DHCP IP acquisition) + */ +#if !defined LWIP_NETIF_STATUS_CALLBACK || defined __DOXYGEN__ +#define LWIP_NETIF_STATUS_CALLBACK 0 +#endif + +/** + * LWIP_NETIF_EXT_STATUS_CALLBACK==1: Support an extended callback function + * for several netif related event that supports multiple subscribers. + * @see netif_ext_status_callback + */ +#if !defined LWIP_NETIF_EXT_STATUS_CALLBACK || defined __DOXYGEN__ +#define LWIP_NETIF_EXT_STATUS_CALLBACK 0 +#endif + +/** + * LWIP_NETIF_LINK_CALLBACK==1: Support a callback function from an interface + * whenever the link changes (i.e., link down) + */ +#if !defined LWIP_NETIF_LINK_CALLBACK || defined __DOXYGEN__ +#define LWIP_NETIF_LINK_CALLBACK 0 +#endif + +/** + * LWIP_NETIF_REMOVE_CALLBACK==1: Support a callback function that is called + * when a netif has been removed + */ +#if !defined LWIP_NETIF_REMOVE_CALLBACK || defined __DOXYGEN__ +#define LWIP_NETIF_REMOVE_CALLBACK 0 +#endif + +/** + * LWIP_NETIF_HWADDRHINT==1: Cache link-layer-address hints (e.g. table + * indices) in struct netif. TCP and UDP can make use of this to prevent + * scanning the ARP table for every sent packet. While this is faster for big + * ARP tables or many concurrent connections, it might be counterproductive + * if you have a tiny ARP table or if there never are concurrent connections. + */ +#if !defined LWIP_NETIF_HWADDRHINT || defined __DOXYGEN__ +#define LWIP_NETIF_HWADDRHINT 0 +#endif + +/** + * LWIP_NETIF_TX_SINGLE_PBUF: if this is set to 1, lwIP *tries* to put all data + * to be sent into one single pbuf. This is for compatibility with DMA-enabled + * MACs that do not support scatter-gather. + * Beware that this might involve CPU-memcpy before transmitting that would not + * be needed without this flag! Use this only if you need to! + * + * ATTENTION: a driver should *NOT* rely on getting single pbufs but check TX + * pbufs for being in one piece. If not, @ref pbuf_clone can be used to get + * a single pbuf: + * if (p->next != NULL) { + * struct pbuf *q = pbuf_clone(PBUF_RAW, PBUF_RAM, p); + * if (q == NULL) { + * return ERR_MEM; + * } + * p = q; ATTENTION: do NOT free the old 'p' as the ref belongs to the caller! + * } + */ +#if !defined LWIP_NETIF_TX_SINGLE_PBUF || defined __DOXYGEN__ +#define LWIP_NETIF_TX_SINGLE_PBUF 0 +#endif /* LWIP_NETIF_TX_SINGLE_PBUF */ + +/** + * LWIP_NUM_NETIF_CLIENT_DATA: Number of clients that may store + * data in client_data member array of struct netif (max. 256). + */ +#if !defined LWIP_NUM_NETIF_CLIENT_DATA || defined __DOXYGEN__ +#define LWIP_NUM_NETIF_CLIENT_DATA 0 +#endif +/** + * @} + */ + +/* + ------------------------------------ + ---------- LOOPIF options ---------- + ------------------------------------ +*/ +/** + * @defgroup lwip_opts_loop Loopback interface + * @ingroup lwip_opts_netif + * @{ + */ +/** + * LWIP_HAVE_LOOPIF==1: Support loop interface (127.0.0.1). + * This is only needed when no real netifs are available. If at least one other + * netif is available, loopback traffic uses this netif. + */ +#if !defined LWIP_HAVE_LOOPIF || defined __DOXYGEN__ +#define LWIP_HAVE_LOOPIF (LWIP_NETIF_LOOPBACK && !LWIP_SINGLE_NETIF) +#endif + +/** + * LWIP_LOOPIF_MULTICAST==1: Support multicast/IGMP on loop interface (127.0.0.1). + */ +#if !defined LWIP_LOOPIF_MULTICAST || defined __DOXYGEN__ +#define LWIP_LOOPIF_MULTICAST 0 +#endif + +/** + * LWIP_NETIF_LOOPBACK==1: Support sending packets with a destination IP + * address equal to the netif IP address, looping them back up the stack. + */ +#if !defined LWIP_NETIF_LOOPBACK || defined __DOXYGEN__ +#define LWIP_NETIF_LOOPBACK 0 +#endif + +/** + * LWIP_LOOPBACK_MAX_PBUFS: Maximum number of pbufs on queue for loopback + * sending for each netif (0 = disabled) + */ +#if !defined LWIP_LOOPBACK_MAX_PBUFS || defined __DOXYGEN__ +#define LWIP_LOOPBACK_MAX_PBUFS 0 +#endif + +/** + * LWIP_NETIF_LOOPBACK_MULTITHREADING: Indicates whether threading is enabled in + * the system, as netifs must change how they behave depending on this setting + * for the LWIP_NETIF_LOOPBACK option to work. + * Setting this is needed to avoid reentering non-reentrant functions like + * tcp_input(). + * LWIP_NETIF_LOOPBACK_MULTITHREADING==1: Indicates that the user is using a + * multithreaded environment like tcpip.c. In this case, netif->input() + * is called directly. + * LWIP_NETIF_LOOPBACK_MULTITHREADING==0: Indicates a polling (or NO_SYS) setup. + * The packets are put on a list and netif_poll() must be called in + * the main application loop. + */ +#if !defined LWIP_NETIF_LOOPBACK_MULTITHREADING || defined __DOXYGEN__ +#define LWIP_NETIF_LOOPBACK_MULTITHREADING (!NO_SYS) +#endif +/** + * @} + */ + +/* + ------------------------------------ + ---------- Thread options ---------- + ------------------------------------ +*/ +/** + * @defgroup lwip_opts_thread Threading + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * TCPIP_THREAD_NAME: The name assigned to the main tcpip thread. + */ +#if !defined TCPIP_THREAD_NAME || defined __DOXYGEN__ +#define TCPIP_THREAD_NAME "tcpip_thread" +#endif + +/** + * TCPIP_THREAD_STACKSIZE: The stack size used by the main tcpip thread. + * The stack size value itself is platform-dependent, but is passed to + * sys_thread_new() when the thread is created. + */ +#if !defined TCPIP_THREAD_STACKSIZE || defined __DOXYGEN__ +#define TCPIP_THREAD_STACKSIZE 4096 +#endif + +/** + * TCPIP_THREAD_PRIO: The priority assigned to the main tcpip thread. + * The priority value itself is platform-dependent, but is passed to + * sys_thread_new() when the thread is created. + */ +#if !defined TCPIP_THREAD_PRIO || defined __DOXYGEN__ +#define TCPIP_THREAD_PRIO 25 +#endif + +/** + * TCPIP_MBOX_SIZE: The mailbox size for the tcpip thread messages + * The queue size value itself is platform-dependent, but is passed to + * sys_mbox_new() when tcpip_init is called. + */ +#if !defined TCPIP_MBOX_SIZE || defined __DOXYGEN__ +#define TCPIP_MBOX_SIZE 10 +#endif + +/** + * Define this to something that triggers a watchdog. This is called from + * tcpip_thread after processing a message. + */ +#if !defined LWIP_TCPIP_THREAD_ALIVE || defined __DOXYGEN__ +#define LWIP_TCPIP_THREAD_ALIVE() +#endif + +/** + * SLIPIF_THREAD_NAME: The name assigned to the slipif_loop thread. + */ +#if !defined SLIPIF_THREAD_NAME || defined __DOXYGEN__ +#define SLIPIF_THREAD_NAME "slipif_loop" +#endif + +/** + * SLIP_THREAD_STACKSIZE: The stack size used by the slipif_loop thread. + * The stack size value itself is platform-dependent, but is passed to + * sys_thread_new() when the thread is created. + */ +#if !defined SLIPIF_THREAD_STACKSIZE || defined __DOXYGEN__ +#define SLIPIF_THREAD_STACKSIZE 0 +#endif + +/** + * SLIPIF_THREAD_PRIO: The priority assigned to the slipif_loop thread. + * The priority value itself is platform-dependent, but is passed to + * sys_thread_new() when the thread is created. + */ +#if !defined SLIPIF_THREAD_PRIO || defined __DOXYGEN__ +#define SLIPIF_THREAD_PRIO 1 +#endif + +/** + * DEFAULT_THREAD_NAME: The name assigned to any other lwIP thread. + */ +#if !defined DEFAULT_THREAD_NAME || defined __DOXYGEN__ +#define DEFAULT_THREAD_NAME "lwIP" +#endif + +/** + * DEFAULT_THREAD_STACKSIZE: The stack size used by any other lwIP thread. + * The stack size value itself is platform-dependent, but is passed to + * sys_thread_new() when the thread is created. + */ +#if !defined DEFAULT_THREAD_STACKSIZE || defined __DOXYGEN__ +#define DEFAULT_THREAD_STACKSIZE 4096 +#endif + +/** + * DEFAULT_THREAD_PRIO: The priority assigned to any other lwIP thread. + * The priority value itself is platform-dependent, but is passed to + * sys_thread_new() when the thread is created. + */ +#if !defined DEFAULT_THREAD_PRIO || defined __DOXYGEN__ +#define DEFAULT_THREAD_PRIO 25 +#endif + +/** + * DEFAULT_RAW_RECVMBOX_SIZE: The mailbox size for the incoming packets on a + * NETCONN_RAW. The queue size value itself is platform-dependent, but is passed + * to sys_mbox_new() when the recvmbox is created. + */ +#if !defined DEFAULT_RAW_RECVMBOX_SIZE || defined __DOXYGEN__ +#define DEFAULT_RAW_RECVMBOX_SIZE 10 +#endif + +/** + * DEFAULT_UDP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a + * NETCONN_UDP. The queue size value itself is platform-dependent, but is passed + * to sys_mbox_new() when the recvmbox is created. + */ +#if !defined DEFAULT_UDP_RECVMBOX_SIZE || defined __DOXYGEN__ +#define DEFAULT_UDP_RECVMBOX_SIZE 10 +#endif + +/** + * DEFAULT_TCP_RECVMBOX_SIZE: The mailbox size for the incoming packets on a + * NETCONN_TCP. The queue size value itself is platform-dependent, but is passed + * to sys_mbox_new() when the recvmbox is created. + */ +#if !defined DEFAULT_TCP_RECVMBOX_SIZE || defined __DOXYGEN__ +#define DEFAULT_TCP_RECVMBOX_SIZE 10 +#endif + +/** + * DEFAULT_ACCEPTMBOX_SIZE: The mailbox size for the incoming connections. + * The queue size value itself is platform-dependent, but is passed to + * sys_mbox_new() when the acceptmbox is created. + */ +#if !defined DEFAULT_ACCEPTMBOX_SIZE || defined __DOXYGEN__ +#define DEFAULT_ACCEPTMBOX_SIZE 10 +#endif +/** + * @} + */ + +/* + ---------------------------------------------- + ---------- Sequential layer options ---------- + ---------------------------------------------- +*/ +/** + * @defgroup lwip_opts_netconn Netconn + * @ingroup lwip_opts_threadsafe_apis + * @{ + */ +/** + * LWIP_NETCONN==1: Enable Netconn API (require to use api_lib.c) + */ +#if !defined LWIP_NETCONN || defined __DOXYGEN__ +#define LWIP_NETCONN 1 +#endif + +/** LWIP_TCPIP_TIMEOUT==1: Enable tcpip_timeout/tcpip_untimeout to create + * timers running in tcpip_thread from another thread. + */ +#if !defined LWIP_TCPIP_TIMEOUT || defined __DOXYGEN__ +#define LWIP_TCPIP_TIMEOUT 0 +#endif + +/** LWIP_NETCONN_SEM_PER_THREAD==1: Use one (thread-local) semaphore per + * thread calling socket/netconn functions instead of allocating one + * semaphore per netconn (and per select etc.) + * ATTENTION: a thread-local semaphore for API calls is needed: + * - LWIP_NETCONN_THREAD_SEM_GET() returning a sys_sem_t* + * - LWIP_NETCONN_THREAD_SEM_ALLOC() creating the semaphore + * - LWIP_NETCONN_THREAD_SEM_FREE() freeing the semaphore + * The latter 2 can be invoked up by calling netconn_thread_init()/netconn_thread_cleanup(). + * Ports may call these for threads created with sys_thread_new(). + */ +#if !defined LWIP_NETCONN_SEM_PER_THREAD || defined __DOXYGEN__ +#define LWIP_NETCONN_SEM_PER_THREAD 0 +#endif + +/** LWIP_NETCONN_FULLDUPLEX==1: Enable code that allows reading from one thread, + * writing from a 2nd thread and closing from a 3rd thread at the same time. + * ATTENTION: This is currently really alpha! Some requirements: + * - LWIP_NETCONN_SEM_PER_THREAD==1 is required to use one socket/netconn from + * multiple threads at once + * - sys_mbox_free() has to unblock receive tasks waiting on recvmbox/acceptmbox + * and prevent a task pending on this during/after deletion + */ +#if !defined LWIP_NETCONN_FULLDUPLEX || defined __DOXYGEN__ +#define LWIP_NETCONN_FULLDUPLEX 0 +#endif +/** + * @} + */ + +/* + ------------------------------------ + ---------- Socket options ---------- + ------------------------------------ +*/ +/** + * @defgroup lwip_opts_socket Sockets + * @ingroup lwip_opts_threadsafe_apis + * @{ + */ +/** + * LWIP_SOCKET==1: Enable Socket API (require to use sockets.c) + */ +#if !defined LWIP_SOCKET || defined __DOXYGEN__ +#define LWIP_SOCKET 1 +#endif + +/** + * LWIP_COMPAT_SOCKETS==1: Enable BSD-style sockets functions names through defines. + * LWIP_COMPAT_SOCKETS==2: Same as ==1 but correctly named functions are created. + * While this helps code completion, it might conflict with existing libraries. + * (only used if you use sockets.c) + */ +#if !defined LWIP_COMPAT_SOCKETS || defined __DOXYGEN__ +#define LWIP_COMPAT_SOCKETS 1 +#endif + +/** + * LWIP_POSIX_SOCKETS_IO_NAMES==1: Enable POSIX-style sockets functions names. + * Disable this option if you use a POSIX operating system that uses the same + * names (read, write & close). (only used if you use sockets.c) + */ +#if !defined LWIP_POSIX_SOCKETS_IO_NAMES || defined __DOXYGEN__ +#define LWIP_POSIX_SOCKETS_IO_NAMES 1 +#endif + +/** + * LWIP_SOCKET_OFFSET==n: Increases the file descriptor number created by LwIP with n. + * This can be useful when there are multiple APIs which create file descriptors. + * When they all start with a different offset and you won't make them overlap you can + * re implement read/write/close/ioctl/fnctl to send the requested action to the right + * library (sharing select will need more work though). + */ +#if !defined LWIP_SOCKET_OFFSET || defined __DOXYGEN__ +#define LWIP_SOCKET_OFFSET 0 +#endif + +/** + * LWIP_TCP_KEEPALIVE==1: Enable TCP_KEEPIDLE, TCP_KEEPINTVL and TCP_KEEPCNT + * options processing. Note that TCP_KEEPIDLE and TCP_KEEPINTVL have to be set + * in seconds. (does not require sockets.c, and will affect tcp.c) + */ +#if !defined LWIP_TCP_KEEPALIVE || defined __DOXYGEN__ +#define LWIP_TCP_KEEPALIVE 0 +#endif + +/** + * LWIP_SO_SNDTIMEO==1: Enable send timeout for sockets/netconns and + * SO_SNDTIMEO processing. + */ +#if !defined LWIP_SO_SNDTIMEO || defined __DOXYGEN__ +#define LWIP_SO_SNDTIMEO 0 +#endif + +/** + * LWIP_SO_RCVTIMEO==1: Enable receive timeout for sockets/netconns and + * SO_RCVTIMEO processing. + */ +#if !defined LWIP_SO_RCVTIMEO || defined __DOXYGEN__ +#define LWIP_SO_RCVTIMEO 0 +#endif + +/** + * LWIP_SO_SNDRCVTIMEO_NONSTANDARD==1: SO_RCVTIMEO/SO_SNDTIMEO take an int + * (milliseconds, much like winsock does) instead of a struct timeval (default). + */ +#if !defined LWIP_SO_SNDRCVTIMEO_NONSTANDARD || defined __DOXYGEN__ +#define LWIP_SO_SNDRCVTIMEO_NONSTANDARD 0 +#endif + +/** + * LWIP_SO_RCVBUF==1: Enable SO_RCVBUF processing. + */ +#if !defined LWIP_SO_RCVBUF || defined __DOXYGEN__ +#define LWIP_SO_RCVBUF 0 +#endif + +/** + * LWIP_SO_LINGER==1: Enable SO_LINGER processing. + */ +#if !defined LWIP_SO_LINGER || defined __DOXYGEN__ +#define LWIP_SO_LINGER 0 +#endif + +/** + * If LWIP_SO_RCVBUF is used, this is the default value for recv_bufsize. + */ +#if !defined RECV_BUFSIZE_DEFAULT || defined __DOXYGEN__ +#define RECV_BUFSIZE_DEFAULT INT_MAX +#endif + +/** + * By default, TCP socket/netconn close waits 20 seconds max to send the FIN + */ +#if !defined LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT || defined __DOXYGEN__ +#define LWIP_TCP_CLOSE_TIMEOUT_MS_DEFAULT 20000 +#endif + +/** + * SO_REUSE==1: Enable SO_REUSEADDR option. + */ +#if !defined SO_REUSE || defined __DOXYGEN__ +#define SO_REUSE 0 +#endif + +/** + * SO_REUSE_RXTOALL==1: Pass a copy of incoming broadcast/multicast packets + * to all local matches if SO_REUSEADDR is turned on. + * WARNING: Adds a memcpy for every packet if passing to more than one pcb! + */ +#if !defined SO_REUSE_RXTOALL || defined __DOXYGEN__ +#define SO_REUSE_RXTOALL 0 +#endif + +/** + * LWIP_FIONREAD_LINUXMODE==0 (default): ioctl/FIONREAD returns the amount of + * pending data in the network buffer. This is the way windows does it. It's + * the default for lwIP since it is smaller. + * LWIP_FIONREAD_LINUXMODE==1: ioctl/FIONREAD returns the size of the next + * pending datagram in bytes. This is the way linux does it. This code is only + * here for compatibility. + */ +#if !defined LWIP_FIONREAD_LINUXMODE || defined __DOXYGEN__ +#define LWIP_FIONREAD_LINUXMODE 0 +#endif + +/** + * LWIP_SOCKET_SELECT==1 (default): enable select() for sockets (uses a netconn + * callback to keep track of events). + * This saves RAM (counters per socket) and code (netconn event callback), which + * should improve performance a bit). + */ +#if !defined LWIP_SOCKET_SELECT || defined __DOXYGEN__ +#define LWIP_SOCKET_SELECT 1 +#endif + +/** + * LWIP_SOCKET_POLL==1 (default): enable poll() for sockets (including + * struct pollfd, nfds_t, and constants) + */ +#if !defined LWIP_SOCKET_POLL || defined __DOXYGEN__ +#define LWIP_SOCKET_POLL 1 +#endif +/** + * @} + */ + +/* + ---------------------------------------- + ---------- Statistics options ---------- + ---------------------------------------- +*/ +/** + * @defgroup lwip_opts_stats Statistics + * @ingroup lwip_opts_debug + * @{ + */ +/** + * LWIP_STATS==1: Enable statistics collection in lwip_stats. + */ +#if !defined LWIP_STATS || defined __DOXYGEN__ +#define LWIP_STATS 1 +#endif + +#if LWIP_STATS + +/** + * LWIP_STATS_DISPLAY==1: Compile in the statistics output functions. + */ +#if !defined LWIP_STATS_DISPLAY || defined __DOXYGEN__ +#define LWIP_STATS_DISPLAY 0 +#endif + +/** + * LINK_STATS==1: Enable link stats. + */ +#if !defined LINK_STATS || defined __DOXYGEN__ +#define LINK_STATS 1 +#endif + +/** + * ETHARP_STATS==1: Enable etharp stats. + */ +#if !defined ETHARP_STATS || defined __DOXYGEN__ +#define ETHARP_STATS (LWIP_ARP) +#endif + +/** + * IP_STATS==1: Enable IP stats. + */ +#if !defined IP_STATS || defined __DOXYGEN__ +#define IP_STATS 1 +#endif + +/** + * IPFRAG_STATS==1: Enable IP fragmentation stats. Default is + * on if using either frag or reass. + */ +#if !defined IPFRAG_STATS || defined __DOXYGEN__ +#define IPFRAG_STATS (IP_REASSEMBLY || IP_FRAG) +#endif + +/** + * ICMP_STATS==1: Enable ICMP stats. + */ +#if !defined ICMP_STATS || defined __DOXYGEN__ +#define ICMP_STATS 1 +#endif + +/** + * IGMP_STATS==1: Enable IGMP stats. + */ +#if !defined IGMP_STATS || defined __DOXYGEN__ +#define IGMP_STATS (LWIP_IGMP) +#endif + +/** + * UDP_STATS==1: Enable UDP stats. Default is on if + * UDP enabled, otherwise off. + */ +#if !defined UDP_STATS || defined __DOXYGEN__ +#define UDP_STATS (LWIP_UDP) +#endif + +/** + * TCP_STATS==1: Enable TCP stats. Default is on if TCP + * enabled, otherwise off. + */ +#if !defined TCP_STATS || defined __DOXYGEN__ +#define TCP_STATS (LWIP_TCP) +#endif + +/** + * MEM_STATS==1: Enable mem.c stats. + */ +#if !defined MEM_STATS || defined __DOXYGEN__ +// #define MEM_STATS ((MEM_LIBC_MALLOC == 0) && (MEM_USE_POOLS == 0)) +#endif + +/** + * MEMP_STATS==1: Enable memp.c pool stats. + */ +#if !defined MEMP_STATS || defined __DOXYGEN__ +#define MEMP_STATS (MEMP_MEM_MALLOC == 0) +#endif + +/** + * SYS_STATS==1: Enable system stats (sem and mbox counts, etc). + */ +#if !defined SYS_STATS || defined __DOXYGEN__ +#define SYS_STATS (NO_SYS == 0) +#endif + +/** + * IP6_STATS==1: Enable IPv6 stats. + */ +#if !defined IP6_STATS || defined __DOXYGEN__ +#define IP6_STATS (LWIP_IPV6) +#endif + +/** + * ICMP6_STATS==1: Enable ICMP for IPv6 stats. + */ +#if !defined ICMP6_STATS || defined __DOXYGEN__ +#define ICMP6_STATS (LWIP_IPV6 && LWIP_ICMP6) +#endif + +/** + * IP6_FRAG_STATS==1: Enable IPv6 fragmentation stats. + */ +#if !defined IP6_FRAG_STATS || defined __DOXYGEN__ +#define IP6_FRAG_STATS (LWIP_IPV6 && (LWIP_IPV6_FRAG || LWIP_IPV6_REASS)) +#endif + +/** + * MLD6_STATS==1: Enable MLD for IPv6 stats. + */ +#if !defined MLD6_STATS || defined __DOXYGEN__ +#define MLD6_STATS (LWIP_IPV6 && LWIP_IPV6_MLD) +#endif + +/** + * ND6_STATS==1: Enable Neighbor discovery for IPv6 stats. + */ +#if !defined ND6_STATS || defined __DOXYGEN__ +#define ND6_STATS (LWIP_IPV6) +#endif + +/** + * MIB2_STATS==1: Stats for SNMP MIB2. + */ +#if !defined MIB2_STATS || defined __DOXYGEN__ +#define MIB2_STATS 0 +#endif + +#else + +#define LINK_STATS 0 +#define ETHARP_STATS 0 +#define IP_STATS 0 +#define IPFRAG_STATS 0 +#define ICMP_STATS 0 +#define IGMP_STATS 0 +#define UDP_STATS 0 +#define TCP_STATS 0 +// #define MEM_STATS 0 +#define MEMP_STATS 0 +#define SYS_STATS 0 +#define LWIP_STATS_DISPLAY 0 +#define IP6_STATS 0 +#define ICMP6_STATS 0 +#define IP6_FRAG_STATS 0 +#define MLD6_STATS 0 +#define ND6_STATS 0 +#define MIB2_STATS 0 + +#endif /* LWIP_STATS */ +/** + * @} + */ + +/* + -------------------------------------- + ---------- Checksum options ---------- + -------------------------------------- +*/ +/** + * @defgroup lwip_opts_checksum Checksum + * @ingroup lwip_opts_infrastructure + * @{ + */ +/** + * LWIP_CHECKSUM_CTRL_PER_NETIF==1: Checksum generation/check can be enabled/disabled + * per netif. + * ATTENTION: if enabled, the CHECKSUM_GEN_* and CHECKSUM_CHECK_* defines must be enabled! + */ +#if !defined LWIP_CHECKSUM_CTRL_PER_NETIF || defined __DOXYGEN__ +#define LWIP_CHECKSUM_CTRL_PER_NETIF 0 +#endif + +/** + * CHECKSUM_GEN_IP==1: Generate checksums in software for outgoing IP packets. + */ +#if !defined CHECKSUM_GEN_IP || defined __DOXYGEN__ +#define CHECKSUM_GEN_IP 1 +#endif + +/** + * CHECKSUM_GEN_UDP==1: Generate checksums in software for outgoing UDP packets. + */ +#if !defined CHECKSUM_GEN_UDP || defined __DOXYGEN__ +#define CHECKSUM_GEN_UDP 1 +#endif + +/** + * CHECKSUM_GEN_TCP==1: Generate checksums in software for outgoing TCP packets. + */ +#if !defined CHECKSUM_GEN_TCP || defined __DOXYGEN__ +#define CHECKSUM_GEN_TCP 1 +#endif + +/** + * CHECKSUM_GEN_ICMP==1: Generate checksums in software for outgoing ICMP packets. + */ +#if !defined CHECKSUM_GEN_ICMP || defined __DOXYGEN__ +#define CHECKSUM_GEN_ICMP 1 +#endif + +/** + * CHECKSUM_GEN_ICMP6==1: Generate checksums in software for outgoing ICMP6 packets. + */ +#if !defined CHECKSUM_GEN_ICMP6 || defined __DOXYGEN__ +#define CHECKSUM_GEN_ICMP6 1 +#endif + +/** + * CHECKSUM_CHECK_IP==1: Check checksums in software for incoming IP packets. + */ +#if !defined CHECKSUM_CHECK_IP || defined __DOXYGEN__ +#define CHECKSUM_CHECK_IP 1 +#endif + +/** + * CHECKSUM_CHECK_UDP==1: Check checksums in software for incoming UDP packets. + */ +#if !defined CHECKSUM_CHECK_UDP || defined __DOXYGEN__ +#define CHECKSUM_CHECK_UDP 1 +#endif + +/** + * CHECKSUM_CHECK_TCP==1: Check checksums in software for incoming TCP packets. + */ +#if !defined CHECKSUM_CHECK_TCP || defined __DOXYGEN__ +#define CHECKSUM_CHECK_TCP 1 +#endif + +/** + * CHECKSUM_CHECK_ICMP==1: Check checksums in software for incoming ICMP packets. + */ +#if !defined CHECKSUM_CHECK_ICMP || defined __DOXYGEN__ +#define CHECKSUM_CHECK_ICMP 1 +#endif + +/** + * CHECKSUM_CHECK_ICMP6==1: Check checksums in software for incoming ICMPv6 packets + */ +#if !defined CHECKSUM_CHECK_ICMP6 || defined __DOXYGEN__ +#define CHECKSUM_CHECK_ICMP6 1 +#endif + +/** + * LWIP_CHECKSUM_ON_COPY==1: Calculate checksum when copying data from + * application buffers to pbufs. + */ +#if !defined LWIP_CHECKSUM_ON_COPY || defined __DOXYGEN__ +#define LWIP_CHECKSUM_ON_COPY 0 +#endif +/** + * @} + */ + +/* + --------------------------------------- + ---------- IPv6 options --------------- + --------------------------------------- +*/ +/** + * @defgroup lwip_opts_ipv6 IPv6 + * @ingroup lwip_opts + * @{ + */ +/** + * LWIP_IPV6==1: Enable IPv6 + */ +#if !defined LWIP_IPV6 || defined __DOXYGEN__ +#define LWIP_IPV6 0 +#endif + +/** + * IPV6_REASS_MAXAGE: Maximum time (in multiples of IP6_REASS_TMR_INTERVAL - so seconds, normally) + * a fragmented IP packet waits for all fragments to arrive. If not all fragments arrived + * in this time, the whole packet is discarded. + */ +#if !defined IPV6_REASS_MAXAGE || defined __DOXYGEN__ +#define IPV6_REASS_MAXAGE 60 +#endif + +/** + * LWIP_IPV6_SCOPES==1: Enable support for IPv6 address scopes, ensuring that + * e.g. link-local addresses are really treated as link-local. Disable this + * setting only for single-interface configurations. + * All addresses that have a scope according to the default policy (link-local + * unicast addresses, interface-local and link-local multicast addresses) should + * now have a zone set on them before being passed to the core API, although + * lwIP will currently attempt to select a zone on the caller's behalf when + * necessary. Applications that directly assign IPv6 addresses to interfaces + * (which is NOT recommended) must now ensure that link-local addresses carry + * the netif's zone. See the new ip6_zone.h header file for more information and + * relevant macros. For now it is still possible to turn off scopes support + * through the new LWIP_IPV6_SCOPES option. When upgrading an implementation that + * uses the core API directly, it is highly recommended to enable + * LWIP_IPV6_SCOPES_DEBUG at least for a while, to ensure e.g. proper address + * initialization. + */ +#if !defined LWIP_IPV6_SCOPES || defined __DOXYGEN__ +#define LWIP_IPV6_SCOPES (LWIP_IPV6 && !LWIP_SINGLE_NETIF) +#endif + +/** + * LWIP_IPV6_SCOPES_DEBUG==1: Perform run-time checks to verify that addresses + * are properly zoned (see ip6_zone.h on what that means) where it matters. + * Enabling this setting is highly recommended when upgrading from an existing + * installation that is not yet scope-aware; otherwise it may be too expensive. + */ +#if !defined LWIP_IPV6_SCOPES_DEBUG || defined __DOXYGEN__ +#define LWIP_IPV6_SCOPES_DEBUG 0 +#endif + +/** + * LWIP_IPV6_NUM_ADDRESSES: Number of IPv6 addresses per netif. + */ +#if !defined LWIP_IPV6_NUM_ADDRESSES || defined __DOXYGEN__ +#define LWIP_IPV6_NUM_ADDRESSES 3 +#endif + +/** + * LWIP_IPV6_FORWARD==1: Forward IPv6 packets across netifs + */ +#if !defined LWIP_IPV6_FORWARD || defined __DOXYGEN__ +#define LWIP_IPV6_FORWARD 0 +#endif + +/** + * LWIP_IPV6_FRAG==1: Fragment outgoing IPv6 packets that are too big. + */ +#if !defined LWIP_IPV6_FRAG || defined __DOXYGEN__ +#define LWIP_IPV6_FRAG 1 +#endif + +/** + * LWIP_IPV6_REASS==1: reassemble incoming IPv6 packets that fragmented + */ +#if !defined LWIP_IPV6_REASS || defined __DOXYGEN__ +#define LWIP_IPV6_REASS LWIP_IPV6 +#endif + +/** + * LWIP_IPV6_SEND_ROUTER_SOLICIT==1: Send router solicitation messages during + * network startup. + */ +#if !defined LWIP_IPV6_SEND_ROUTER_SOLICIT || defined __DOXYGEN__ +#define LWIP_IPV6_SEND_ROUTER_SOLICIT 1 +#endif + +/** + * LWIP_IPV6_AUTOCONFIG==1: Enable stateless address autoconfiguration as per RFC 4862. + */ +#if !defined LWIP_IPV6_AUTOCONFIG || defined __DOXYGEN__ +#define LWIP_IPV6_AUTOCONFIG LWIP_IPV6 +#endif + +/** + * LWIP_IPV6_ADDRESS_LIFETIMES==1: Keep valid and preferred lifetimes for each + * IPv6 address. Required for LWIP_IPV6_AUTOCONFIG. May still be enabled + * otherwise, in which case the application may assign address lifetimes with + * the appropriate macros. Addresses with no lifetime are assumed to be static. + * If this option is disabled, all addresses are assumed to be static. + */ +#if !defined LWIP_IPV6_ADDRESS_LIFETIMES || defined __DOXYGEN__ +#define LWIP_IPV6_ADDRESS_LIFETIMES LWIP_IPV6_AUTOCONFIG +#endif + +/** + * LWIP_IPV6_DUP_DETECT_ATTEMPTS=[0..7]: Number of duplicate address detection attempts. + */ +#if !defined LWIP_IPV6_DUP_DETECT_ATTEMPTS || defined __DOXYGEN__ +#define LWIP_IPV6_DUP_DETECT_ATTEMPTS 1 +#endif +/** + * @} + */ + +/** + * @defgroup lwip_opts_icmp6 ICMP6 + * @ingroup lwip_opts_ipv6 + * @{ + */ +/** + * LWIP_ICMP6==1: Enable ICMPv6 (mandatory per RFC) + */ +#if !defined LWIP_ICMP6 || defined __DOXYGEN__ +#define LWIP_ICMP6 LWIP_IPV6 +#endif + +/** + * LWIP_ICMP6_DATASIZE: bytes from original packet to send back in + * ICMPv6 error messages. + */ +#if !defined LWIP_ICMP6_DATASIZE || defined __DOXYGEN__ +#define LWIP_ICMP6_DATASIZE 8 +#endif + +/** + * LWIP_ICMP6_HL: default hop limit for ICMPv6 messages + */ +#if !defined LWIP_ICMP6_HL || defined __DOXYGEN__ +#define LWIP_ICMP6_HL 255 +#endif +/** + * @} + */ + +/** + * @defgroup lwip_opts_mld6 Multicast listener discovery + * @ingroup lwip_opts_ipv6 + * @{ + */ +/** + * LWIP_IPV6_MLD==1: Enable multicast listener discovery protocol. + * If LWIP_IPV6 is enabled but this setting is disabled, the MAC layer must + * indiscriminately pass all inbound IPv6 multicast traffic to lwIP. + */ +#if !defined LWIP_IPV6_MLD || defined __DOXYGEN__ +#define LWIP_IPV6_MLD LWIP_IPV6 +#endif + +/** + * MEMP_NUM_MLD6_GROUP: Max number of IPv6 multicast groups that can be joined. + * There must be enough groups so that each netif can join the solicited-node + * multicast group for each of its local addresses, plus one for MDNS if + * applicable, plus any number of groups to be joined on UDP sockets. + */ +#if !defined MEMP_NUM_MLD6_GROUP || defined __DOXYGEN__ +#define MEMP_NUM_MLD6_GROUP 4 +#endif +/** + * @} + */ + +/** + * @defgroup lwip_opts_nd6 Neighbor discovery + * @ingroup lwip_opts_ipv6 + * @{ + */ +/** + * LWIP_ND6_QUEUEING==1: queue outgoing IPv6 packets while MAC address + * is being resolved. + */ +#if !defined LWIP_ND6_QUEUEING || defined __DOXYGEN__ +#define LWIP_ND6_QUEUEING LWIP_IPV6 +#endif + +/** + * MEMP_NUM_ND6_QUEUE: Max number of IPv6 packets to queue during MAC resolution. + */ +#if !defined MEMP_NUM_ND6_QUEUE || defined __DOXYGEN__ +#define MEMP_NUM_ND6_QUEUE 20 +#endif + +/** + * LWIP_ND6_NUM_NEIGHBORS: Number of entries in IPv6 neighbor cache + */ +#if !defined LWIP_ND6_NUM_NEIGHBORS || defined __DOXYGEN__ +#define LWIP_ND6_NUM_NEIGHBORS 10 +#endif + +/** + * LWIP_ND6_NUM_DESTINATIONS: number of entries in IPv6 destination cache + */ +#if !defined LWIP_ND6_NUM_DESTINATIONS || defined __DOXYGEN__ +#define LWIP_ND6_NUM_DESTINATIONS 10 +#endif + +/** + * LWIP_ND6_NUM_PREFIXES: number of entries in IPv6 on-link prefixes cache + */ +#if !defined LWIP_ND6_NUM_PREFIXES || defined __DOXYGEN__ +#define LWIP_ND6_NUM_PREFIXES 5 +#endif + +/** + * LWIP_ND6_NUM_ROUTERS: number of entries in IPv6 default router cache + */ +#if !defined LWIP_ND6_NUM_ROUTERS || defined __DOXYGEN__ +#define LWIP_ND6_NUM_ROUTERS 3 +#endif + +/** + * LWIP_ND6_MAX_MULTICAST_SOLICIT: max number of multicast solicit messages to send + * (neighbor solicit and router solicit) + */ +#if !defined LWIP_ND6_MAX_MULTICAST_SOLICIT || defined __DOXYGEN__ +#define LWIP_ND6_MAX_MULTICAST_SOLICIT 3 +#endif + +/** + * LWIP_ND6_MAX_UNICAST_SOLICIT: max number of unicast neighbor solicitation messages + * to send during neighbor reachability detection. + */ +#if !defined LWIP_ND6_MAX_UNICAST_SOLICIT || defined __DOXYGEN__ +#define LWIP_ND6_MAX_UNICAST_SOLICIT 3 +#endif + +/** + * Unused: See ND RFC (time in milliseconds). + */ +#if !defined LWIP_ND6_MAX_ANYCAST_DELAY_TIME || defined __DOXYGEN__ +#define LWIP_ND6_MAX_ANYCAST_DELAY_TIME 1000 +#endif + +/** + * Unused: See ND RFC + */ +#if !defined LWIP_ND6_MAX_NEIGHBOR_ADVERTISEMENT || defined __DOXYGEN__ +#define LWIP_ND6_MAX_NEIGHBOR_ADVERTISEMENT 3 +#endif + +/** + * LWIP_ND6_REACHABLE_TIME: default neighbor reachable time (in milliseconds). + * May be updated by router advertisement messages. + */ +#if !defined LWIP_ND6_REACHABLE_TIME || defined __DOXYGEN__ +#define LWIP_ND6_REACHABLE_TIME 30000 +#endif + +/** + * LWIP_ND6_RETRANS_TIMER: default retransmission timer for solicitation messages + */ +#if !defined LWIP_ND6_RETRANS_TIMER || defined __DOXYGEN__ +#define LWIP_ND6_RETRANS_TIMER 1000 +#endif + +/** + * LWIP_ND6_DELAY_FIRST_PROBE_TIME: Delay before first unicast neighbor solicitation + * message is sent, during neighbor reachability detection. + */ +#if !defined LWIP_ND6_DELAY_FIRST_PROBE_TIME || defined __DOXYGEN__ +#define LWIP_ND6_DELAY_FIRST_PROBE_TIME 5000 +#endif + +/** + * LWIP_ND6_ALLOW_RA_UPDATES==1: Allow Router Advertisement messages to update + * Reachable time and retransmission timers, and netif MTU. + */ +#if !defined LWIP_ND6_ALLOW_RA_UPDATES || defined __DOXYGEN__ +#define LWIP_ND6_ALLOW_RA_UPDATES 1 +#endif + +/** + * LWIP_ND6_TCP_REACHABILITY_HINTS==1: Allow TCP to provide Neighbor Discovery + * with reachability hints for connected destinations. This helps avoid sending + * unicast neighbor solicitation messages. + */ +#if !defined LWIP_ND6_TCP_REACHABILITY_HINTS || defined __DOXYGEN__ +#define LWIP_ND6_TCP_REACHABILITY_HINTS 1 +#endif + +/** + * LWIP_ND6_RDNSS_MAX_DNS_SERVERS > 0: Use IPv6 Router Advertisement Recursive + * DNS Server Option (as per RFC 6106) to copy a defined maximum number of DNS + * servers to the DNS module. + */ +#if !defined LWIP_ND6_RDNSS_MAX_DNS_SERVERS || defined __DOXYGEN__ +#define LWIP_ND6_RDNSS_MAX_DNS_SERVERS 0 +#endif +/** + * @} + */ + +/** + * @defgroup lwip_opts_dhcpv6 DHCPv6 + * @ingroup lwip_opts_ipv6 + * @{ + */ +/** + * LWIP_IPV6_DHCP6==1: enable DHCPv6 stateful/stateless address autoconfiguration. + */ +#if !defined LWIP_IPV6_DHCP6 || defined __DOXYGEN__ +#define LWIP_IPV6_DHCP6 0 +#endif + +/** + * LWIP_IPV6_DHCP6_STATEFUL==1: enable DHCPv6 stateful address autoconfiguration. + * (not supported, yet!) + */ +#if !defined LWIP_IPV6_DHCP6_STATEFUL || defined __DOXYGEN__ +#define LWIP_IPV6_DHCP6_STATEFUL 0 +#endif + +/** + * LWIP_IPV6_DHCP6_STATELESS==1: enable DHCPv6 stateless address autoconfiguration. + */ +#if !defined LWIP_IPV6_DHCP6_STATELESS || defined __DOXYGEN__ +#define LWIP_IPV6_DHCP6_STATELESS LWIP_IPV6_DHCP6 +#endif + +/** + * LWIP_DHCP6_GETS_NTP==1: Request NTP servers via DHCPv6. For each + * response packet, a callback is called, which has to be provided by the port: + * void dhcp6_set_ntp_servers(u8_t num_ntp_servers, ip_addr_t* ntp_server_addrs); +*/ +#if !defined LWIP_DHCP6_GET_NTP_SRV || defined __DOXYGEN__ +#define LWIP_DHCP6_GET_NTP_SRV 0 +#endif + +/** + * The maximum of NTP servers requested + */ +#if !defined LWIP_DHCP6_MAX_NTP_SERVERS || defined __DOXYGEN__ +#define LWIP_DHCP6_MAX_NTP_SERVERS 1 +#endif + +/** + * LWIP_DHCP6_MAX_DNS_SERVERS > 0: Request DNS servers via DHCPv6. + * DNS servers received in the response are passed to DNS via @ref dns_setserver() + * (up to the maximum limit defined here). + */ +#if !defined LWIP_DHCP6_MAX_DNS_SERVERS || defined __DOXYGEN__ +#define LWIP_DHCP6_MAX_DNS_SERVERS DNS_MAX_SERVERS +#endif +/** + * @} + */ + +/* + --------------------------------------- + ---------- Hook options --------------- + --------------------------------------- +*/ + +/** + * @defgroup lwip_opts_hooks Hooks + * @ingroup lwip_opts_infrastructure + * Hooks are undefined by default, define them to a function if you need them. + * @{ + */ + +/** + * LWIP_HOOK_FILENAME: Custom filename to \#include in files that provide hooks. + * Declare your hook function prototypes in there, you may also \#include all headers + * providing data types that are need in this file. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_FILENAME "path/to/my/lwip_hooks.h" +#endif + +/** + * LWIP_HOOK_TCP_ISN: + * Hook for generation of the Initial Sequence Number (ISN) for a new TCP + * connection. The default lwIP ISN generation algorithm is very basic and may + * allow for TCP spoofing attacks. This hook provides the means to implement + * the standardized ISN generation algorithm from RFC 6528 (see contrib/adons/tcp_isn), + * or any other desired algorithm as a replacement. + * Called from tcp_connect() and tcp_listen_input() when an ISN is needed for + * a new TCP connection, if TCP support (@ref LWIP_TCP) is enabled.\n + * Signature:\code{.c} + * u32_t my_hook_tcp_isn(const ip_addr_t* local_ip, u16_t local_port, const ip_addr_t* remote_ip, u16_t remote_port); + * \endcode + * - it may be necessary to use "struct ip_addr" (ip4_addr, ip6_addr) instead of "ip_addr_t" in function declarations\n + * Arguments: + * - local_ip: pointer to the local IP address of the connection + * - local_port: local port number of the connection (host-byte order) + * - remote_ip: pointer to the remote IP address of the connection + * - remote_port: remote port number of the connection (host-byte order)\n + * Return value: + * - the 32-bit Initial Sequence Number to use for the new TCP connection. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_TCP_ISN(local_ip, local_port, remote_ip, remote_port) +#endif + +/** + * LWIP_HOOK_TCP_INPACKET_PCB: + * Hook for intercepting incoming packets before they are passed to a pcb. This + * allows updating some state or even dropping a packet. + * Signature:\code{.c} + * err_t my_hook_tcp_inpkt(struct tcp_pcb *pcb, struct tcp_hdr *hdr, u16_t optlen, u16_t opt1len, u8_t *opt2, struct pbuf *p); + * \endcode + * Arguments: + * - pcb: tcp_pcb selected for input of this packet (ATTENTION: this may be + * struct tcp_pcb_listen if pcb->state == LISTEN) + * - hdr: pointer to tcp header (ATTENTION: tcp options may not be in one piece!) + * - optlen: tcp option length + * - opt1len: tcp option length 1st part + * - opt2: if this is != NULL, tcp options are split among 2 pbufs. In that case, + * options start at right after the tcp header ('(u8_t*)(hdr + 1)') for + * the first 'opt1len' bytes and the rest starts at 'opt2'. opt2len can + * be simply calculated: 'opt2len = optlen - opt1len;' + * - p: input packet, p->payload points to application data (that's why tcp hdr + * and options are passed in seperately) + * Return value: + * - ERR_OK: continue input of this packet as normal + * - != ERR_OK: drop this packet for input (don't continue input processing) + * + * ATTENTION: don't call any tcp api functions that might change tcp state (pcb + * state or any pcb lists) from this callback! + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_TCP_INPACKET_PCB(pcb, hdr, optlen, opt1len, opt2, p) +#endif + +/** + * LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH: + * Hook for increasing the size of the options allocated with a tcp header. + * Together with LWIP_HOOK_TCP_OUT_ADD_TCPOPTS, this can be used to add custom + * options to outgoing tcp segments. + * Signature:\code{.c} + * u8_t my_hook_tcp_out_tcpopt_length(const struct tcp_pcb *pcb, u8_t internal_option_length); + * \endcode + * Arguments: + * - pcb: tcp_pcb that transmits (ATTENTION: this may be NULL or + * struct tcp_pcb_listen if pcb->state == LISTEN) + * - internal_option_length: tcp option length used by the stack internally + * Return value: + * - a number of bytes to allocate for tcp options (internal_option_length <= ret <= 40) + * + * ATTENTION: don't call any tcp api functions that might change tcp state (pcb + * state or any pcb lists) from this callback! + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH(pcb, internal_len) +#endif + +/** + * LWIP_HOOK_TCP_OUT_ADD_TCPOPTS: + * Hook for adding custom options to outgoing tcp segments. + * Space for these custom options has to be reserved via LWIP_HOOK_TCP_OUT_TCPOPT_LENGTH. + * Signature:\code{.c} + * u32_t *my_hook_tcp_out_add_tcpopts(struct pbuf *p, struct tcp_hdr *hdr, const struct tcp_pcb *pcb, u32_t *opts); + * \endcode + * Arguments: + * - p: output packet, p->payload pointing to tcp header, data follows + * - hdr: tcp header + * - pcb: tcp_pcb that transmits (ATTENTION: this may be NULL or + * struct tcp_pcb_listen if pcb->state == LISTEN) + * - opts: pointer where to add the custom options (there may already be options + * between the header and these) + * Return value: + * - pointer pointing directly after the inserted options + * + * ATTENTION: don't call any tcp api functions that might change tcp state (pcb + * state or any pcb lists) from this callback! + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_TCP_OUT_ADD_TCPOPTS(p, hdr, pcb, opts) +#endif + +/** + * LWIP_HOOK_IP4_INPUT(pbuf, input_netif): + * Called from ip_input() (IPv4) + * Signature:\code{.c} + * int my_hook(struct pbuf *pbuf, struct netif *input_netif); + * \endcode + * Arguments: + * - pbuf: received struct pbuf passed to ip_input() + * - input_netif: struct netif on which the packet has been received + * Return values: + * - 0: Hook has not consumed the packet, packet is processed as normal + * - != 0: Hook has consumed the packet. + * If the hook consumed the packet, 'pbuf' is in the responsibility of the hook + * (i.e. free it when done). + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_IP4_INPUT(pbuf, input_netif) +#endif + +/** + * LWIP_HOOK_IP4_ROUTE(dest): + * Called from ip_route() (IPv4) + * Signature:\code{.c} + * struct netif *my_hook(const ip4_addr_t *dest); + * \endcode + * Arguments: + * - dest: destination IPv4 address + * Returns values: + * - the destination netif + * - NULL if no destination netif is found. In that case, ip_route() continues as normal. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_IP4_ROUTE() +#endif + +/** + * LWIP_HOOK_IP4_ROUTE_SRC(src, dest): + * Source-based routing for IPv4 - called from ip_route() (IPv4) + * Signature:\code{.c} + * struct netif *my_hook(const ip4_addr_t *src, const ip4_addr_t *dest); + * \endcode + * Arguments: + * - src: local/source IPv4 address + * - dest: destination IPv4 address + * Returns values: + * - the destination netif + * - NULL if no destination netif is found. In that case, ip_route() continues as normal. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_IP4_ROUTE_SRC(src, dest) +#endif + +/** + * LWIP_HOOK_IP4_CANFORWARD(src, dest): + * Check if an IPv4 can be forwarded - called from: + * ip4_input() -> ip4_forward() -> ip4_canforward() (IPv4) + * - source address is available via ip4_current_src_addr() + * - calling an output function in this context (e.g. multicast router) is allowed + * Signature:\code{.c} + * int my_hook(struct pbuf *p, u32_t dest_addr_hostorder); + * \endcode + * Arguments: + * - p: packet to forward + * - dest: destination IPv4 address + * Returns values: + * - 1: forward + * - 0: don't forward + * - -1: no decision. In that case, ip4_canforward() continues as normal. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_IP4_CANFORWARD(src, dest) +#endif + +/** + * LWIP_HOOK_ETHARP_GET_GW(netif, dest): + * Called from etharp_output() (IPv4) + * Signature:\code{.c} + * const ip4_addr_t *my_hook(struct netif *netif, const ip4_addr_t *dest); + * \endcode + * Arguments: + * - netif: the netif used for sending + * - dest: the destination IPv4 address + * Return values: + * - the IPv4 address of the gateway to handle the specified destination IPv4 address + * - NULL, in which case the netif's default gateway is used + * + * The returned address MUST be directly reachable on the specified netif! + * This function is meant to implement advanced IPv4 routing together with + * LWIP_HOOK_IP4_ROUTE(). The actual routing/gateway table implementation is + * not part of lwIP but can e.g. be hidden in the netif's state argument. +*/ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_ETHARP_GET_GW(netif, dest) +#endif + +/** + * LWIP_HOOK_IP6_INPUT(pbuf, input_netif): + * Called from ip6_input() (IPv6) + * Signature:\code{.c} + * int my_hook(struct pbuf *pbuf, struct netif *input_netif); + * \endcode + * Arguments: + * - pbuf: received struct pbuf passed to ip6_input() + * - input_netif: struct netif on which the packet has been received + * Return values: + * - 0: Hook has not consumed the packet, packet is processed as normal + * - != 0: Hook has consumed the packet. + * If the hook consumed the packet, 'pbuf' is in the responsibility of the hook + * (i.e. free it when done). + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_IP6_INPUT(pbuf, input_netif) +#endif + +/** + * LWIP_HOOK_IP6_ROUTE(src, dest): + * Called from ip_route() (IPv6) + * Signature:\code{.c} + * struct netif *my_hook(const ip6_addr_t *dest, const ip6_addr_t *src); + * \endcode + * Arguments: + * - src: source IPv6 address + * - dest: destination IPv6 address + * Return values: + * - the destination netif + * - NULL if no destination netif is found. In that case, ip6_route() continues as normal. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_IP6_ROUTE(src, dest) +#endif + +/** + * LWIP_HOOK_ND6_GET_GW(netif, dest): + * Called from nd6_get_next_hop_entry() (IPv6) + * Signature:\code{.c} + * const ip6_addr_t *my_hook(struct netif *netif, const ip6_addr_t *dest); + * \endcode + * Arguments: + * - netif: the netif used for sending + * - dest: the destination IPv6 address + * Return values: + * - the IPv6 address of the next hop to handle the specified destination IPv6 address + * - NULL, in which case a NDP-discovered router is used instead + * + * The returned address MUST be directly reachable on the specified netif! + * This function is meant to implement advanced IPv6 routing together with + * LWIP_HOOK_IP6_ROUTE(). The actual routing/gateway table implementation is + * not part of lwIP but can e.g. be hidden in the netif's state argument. +*/ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_ND6_GET_GW(netif, dest) +#endif + +/** + * LWIP_HOOK_VLAN_CHECK(netif, eth_hdr, vlan_hdr): + * Called from ethernet_input() if VLAN support is enabled + * Signature:\code{.c} + * int my_hook(struct netif *netif, struct eth_hdr *eth_hdr, struct eth_vlan_hdr *vlan_hdr); + * \endcode + * Arguments: + * - netif: struct netif on which the packet has been received + * - eth_hdr: struct eth_hdr of the packet + * - vlan_hdr: struct eth_vlan_hdr of the packet + * Return values: + * - 0: Packet must be dropped. + * - != 0: Packet must be accepted. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_VLAN_CHECK(netif, eth_hdr, vlan_hdr) +#endif + +/** + * LWIP_HOOK_VLAN_SET: + * Hook can be used to set prio_vid field of vlan_hdr. If you need to store data + * on per-netif basis to implement this callback, see @ref netif_cd. + * Called from ethernet_output() if VLAN support (@ref ETHARP_SUPPORT_VLAN) is enabled.\n + * Signature:\code{.c} + * s32_t my_hook_vlan_set(struct netif* netif, struct pbuf* pbuf, const struct eth_addr* src, const struct eth_addr* dst, u16_t eth_type);\n + * \endcode + * Arguments: + * - netif: struct netif that the packet will be sent through + * - p: struct pbuf packet to be sent + * - src: source eth address + * - dst: destination eth address + * - eth_type: ethernet type to packet to be sent\n + * + * + * Return values: + * - <0: Packet shall not contain VLAN header. + * - 0 <= return value <= 0xFFFF: Packet shall contain VLAN header. Return value is prio_vid in host byte order. + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_VLAN_SET(netif, p, src, dst, eth_type) +#endif + +/** + * LWIP_HOOK_MEMP_AVAILABLE(memp_t_type): + * Called from memp_free() when a memp pool was empty and an item is now available + * Signature:\code{.c} + * void my_hook(memp_t type); + * \endcode + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_MEMP_AVAILABLE(memp_t_type) +#endif + +/** + * LWIP_HOOK_UNKNOWN_ETH_PROTOCOL(pbuf, netif): + * Called from ethernet_input() when an unknown eth type is encountered. + * Signature:\code{.c} + * err_t my_hook(struct pbuf* pbuf, struct netif* netif); + * \endcode + * Arguments: + * - p: rx packet with unknown eth type + * - netif: netif on which the packet has been received + * Return values: + * - ERR_OK if packet is accepted (hook function now owns the pbuf) + * - any error code otherwise (pbuf is freed) + * + * Payload points to ethernet header! + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_UNKNOWN_ETH_PROTOCOL(pbuf, netif) +#endif + +/** + * LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, state, msg, msg_type, options_len_ptr): + * Called from various dhcp functions when sending a DHCP message. + * This hook is called just before the DHCP message trailer is added, so the + * options are at the end of a DHCP message. + * Signature:\code{.c} + * void my_hook(struct netif *netif, struct dhcp *dhcp, u8_t state, struct dhcp_msg *msg, + * u8_t msg_type, u16_t *options_len_ptr); + * \endcode + * Arguments: + * - netif: struct netif that the packet will be sent through + * - dhcp: struct dhcp on that netif + * - state: current dhcp state (dhcp_state_enum_t as an u8_t) + * - msg: struct dhcp_msg that will be sent + * - msg_type: dhcp message type to be sent (u8_t) + * - options_len_ptr: pointer to the current length of options in the dhcp_msg "msg" + * (must be increased when options are added!) + * + * Options need to appended like this: + * LWIP_ASSERT("dhcp option overflow", *options_len_ptr + option_len + 2 <= DHCP_OPTIONS_LEN); + * msg->options[(*options_len_ptr)++] = <option_number>; + * msg->options[(*options_len_ptr)++] = <option_len>; + * msg->options[(*options_len_ptr)++] = <option_bytes>; + * [...] + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_DHCP_APPEND_OPTIONS(netif, dhcp, state, msg, msg_type, options_len_ptr) +#endif + +/** + * LWIP_HOOK_DHCP_PARSE_OPTION(netif, dhcp, state, msg, msg_type, option, len, pbuf, option_value_offset): + * Called from dhcp_parse_reply when receiving a DHCP message. + * This hook is called for every option in the received message that is not handled internally. + * Signature:\code{.c} + * void my_hook(struct netif *netif, struct dhcp *dhcp, u8_t state, struct dhcp_msg *msg, + * u8_t msg_type, u8_t option, u8_t option_len, struct pbuf *pbuf, u16_t option_value_offset); + * \endcode + * Arguments: + * - netif: struct netif that the packet will be sent through + * - dhcp: struct dhcp on that netif + * - state: current dhcp state (dhcp_state_enum_t as an u8_t) + * - msg: struct dhcp_msg that was received + * - msg_type: dhcp message type received (u8_t, ATTENTION: only valid after + * the message type option has been parsed!) + * - option: option value (u8_t) + * - len: option data length (u8_t) + * - pbuf: pbuf where option data is contained + * - option_value_offset: offset in pbuf where option data begins + * + * A nice way to get the option contents is pbuf_get_contiguous(): + * u8_t buf[32]; + * u8_t *ptr = (u8_t*)pbuf_get_contiguous(p, buf, sizeof(buf), LWIP_MIN(option_len, sizeof(buf)), offset); + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_DHCP_PARSE_OPTION(netif, dhcp, state, msg, msg_type, option, len, pbuf, offset) +#endif + +/** + * LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, state, msg, msg_type, options_len_ptr, max_len): + * Called from various dhcp6 functions when sending a DHCP6 message. + * This hook is called just before the DHCP6 message is sent, so the + * options are at the end of a DHCP6 message. + * Signature:\code{.c} + * void my_hook(struct netif *netif, struct dhcp6 *dhcp, u8_t state, struct dhcp6_msg *msg, + * u8_t msg_type, u16_t *options_len_ptr); + * \endcode + * Arguments: + * - netif: struct netif that the packet will be sent through + * - dhcp6: struct dhcp6 on that netif + * - state: current dhcp6 state (dhcp6_state_enum_t as an u8_t) + * - msg: struct dhcp6_msg that will be sent + * - msg_type: dhcp6 message type to be sent (u8_t) + * - options_len_ptr: pointer to the current length of options in the dhcp6_msg "msg" + * (must be increased when options are added!) + * + * Options need to appended like this: + * u8_t *options = (u8_t *)(msg + 1); + * LWIP_ASSERT("dhcp option overflow", sizeof(struct dhcp6_msg) + *options_len_ptr + newoptlen <= max_len); + * options[(*options_len_ptr)++] = <option_data>; + * [...] + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_DHCP6_APPEND_OPTIONS(netif, dhcp6, state, msg, msg_type, options_len_ptr, max_len) +#endif + +/** + * LWIP_HOOK_SOCKETS_SETSOCKOPT(s, sock, level, optname, optval, optlen, err) + * Called from socket API to implement setsockopt() for options not provided by lwIP. + * Core lock is held when this hook is called. + * Signature:\code{.c} + * int my_hook(int s, struct lwip_sock *sock, int level, int optname, const void *optval, socklen_t optlen, int *err) + * \endcode + * Arguments: + * - s: socket file descriptor + * - sock: internal socket descriptor (see lwip/priv/sockets_priv.h) + * - level: protocol level at which the option resides + * - optname: option to set + * - optval: value to set + * - optlen: size of optval + * - err: output error + * Return values: + * - 0: Hook has not consumed the option, code continues as normal (to internal options) + * - != 0: Hook has consumed the option, 'err' is returned + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_SOCKETS_SETSOCKOPT(s, sock, level, optname, optval, optlen, err) +#endif + +/** + * LWIP_HOOK_SOCKETS_GETSOCKOPT(s, sock, level, optname, optval, optlen, err) + * Called from socket API to implement getsockopt() for options not provided by lwIP. + * Core lock is held when this hook is called. + * Signature:\code{.c} + * int my_hook(int s, struct lwip_sock *sock, int level, int optname, void *optval, socklen_t *optlen, int *err) + * \endcode + * Arguments: + * - s: socket file descriptor + * - sock: internal socket descriptor (see lwip/priv/sockets_priv.h) + * - level: protocol level at which the option resides + * - optname: option to get + * - optval: value to get + * - optlen: size of optval + * - err: output error + * Return values: + * - 0: Hook has not consumed the option, code continues as normal (to internal options) + * - != 0: Hook has consumed the option, 'err' is returned + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_SOCKETS_GETSOCKOPT(s, sock, level, optname, optval, optlen, err) +#endif + +/** + * LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, addrtype, err) + * Called from netconn APIs (not usable with callback apps) allowing an + * external DNS resolver (which uses sequential API) to handle the query. + * Signature:\code{.c} + * int my_hook(const char *name, ip_addr_t *addr, u8_t addrtype, err_t *err) + * \endcode + * Arguments: + * - name: hostname to resolve + * - addr: output host address + * - addrtype: type of address to query + * - err: output error + * Return values: + * - 0: Hook has not consumed hostname query, query continues into DNS module + * - != 0: Hook has consumed the query + * + * err must also be checked to determine if the hook consumed the query, but + * the query failed + */ +#ifdef __DOXYGEN__ +#define LWIP_HOOK_NETCONN_EXTERNAL_RESOLVE(name, addr, addrtype, err) +#endif +/** + * @} + */ + +/* + --------------------------------------- + ---------- Debugging options ---------- + --------------------------------------- +*/ +/** + * @defgroup lwip_opts_debugmsg Debug messages + * @ingroup lwip_opts_debug + * @{ + */ +/** + * LWIP_DBG_MIN_LEVEL: After masking, the value of the debug is + * compared against this value. If it is smaller, then debugging + * messages are written. + * @see debugging_levels + */ +#if !defined LWIP_DBG_MIN_LEVEL || defined __DOXYGEN__ +#define LWIP_DBG_MIN_LEVEL LWIP_DBG_LEVEL_ALL +#endif + +/** + * LWIP_DBG_TYPES_ON: A mask that can be used to globally enable/disable + * debug messages of certain types. + * @see debugging_levels + */ +#if !defined LWIP_DBG_TYPES_ON || defined __DOXYGEN__ +#define LWIP_DBG_TYPES_ON LWIP_DBG_ON +#endif + +/** + * ETHARP_DEBUG: Enable debugging in etharp.c. + */ +#if !defined ETHARP_DEBUG || defined __DOXYGEN__ +#define ETHARP_DEBUG LWIP_DBG_OFF +#endif + +/** + * NETIF_DEBUG: Enable debugging in netif.c. + */ +#if !defined NETIF_DEBUG || defined __DOXYGEN__ +#define NETIF_DEBUG LWIP_DBG_OFF +#endif + +/** + * PBUF_DEBUG: Enable debugging in pbuf.c. + */ +#if !defined PBUF_DEBUG || defined __DOXYGEN__ +#define PBUF_DEBUG LWIP_DBG_OFF +#endif + +/** + * API_LIB_DEBUG: Enable debugging in api_lib.c. + */ +#if !defined API_LIB_DEBUG || defined __DOXYGEN__ +#define API_LIB_DEBUG LWIP_DBG_OFF +#endif + +/** + * API_MSG_DEBUG: Enable debugging in api_msg.c. + */ +#if !defined API_MSG_DEBUG || defined __DOXYGEN__ +#define API_MSG_DEBUG LWIP_DBG_OFF +#endif + +/** + * SOCKETS_DEBUG: Enable debugging in sockets.c. + */ +#if !defined SOCKETS_DEBUG || defined __DOXYGEN__ +#define SOCKETS_DEBUG LWIP_DBG_OFF +#endif + +/** + * ICMP_DEBUG: Enable debugging in icmp.c. + */ +#if !defined ICMP_DEBUG || defined __DOXYGEN__ +#define ICMP_DEBUG LWIP_DBG_OFF +#endif + +/** + * IGMP_DEBUG: Enable debugging in igmp.c. + */ +#if !defined IGMP_DEBUG || defined __DOXYGEN__ +#define IGMP_DEBUG LWIP_DBG_OFF +#endif + +/** + * INET_DEBUG: Enable debugging in inet.c. + */ +#if !defined INET_DEBUG || defined __DOXYGEN__ +#define INET_DEBUG LWIP_DBG_OFF +#endif + +/** + * IP_DEBUG: Enable debugging for IP. + */ +#if !defined IP_DEBUG || defined __DOXYGEN__ +#define IP_DEBUG LWIP_DBG_OFF +#endif + +/** + * IP_REASS_DEBUG: Enable debugging in ip_frag.c for both frag & reass. + */ +#if !defined IP_REASS_DEBUG || defined __DOXYGEN__ +#define IP_REASS_DEBUG LWIP_DBG_OFF +#endif + +/** + * RAW_DEBUG: Enable debugging in raw.c. + */ +#if !defined RAW_DEBUG || defined __DOXYGEN__ +#define RAW_DEBUG LWIP_DBG_OFF +#endif + +/** + * MEM_DEBUG: Enable debugging in mem.c. + */ +#if !defined MEM_DEBUG || defined __DOXYGEN__ +#define MEM_DEBUG LWIP_DBG_OFF +#endif + +/** + * MEMP_DEBUG: Enable debugging in memp.c. + */ +#if !defined MEMP_DEBUG || defined __DOXYGEN__ +#define MEMP_DEBUG LWIP_DBG_OFF +#endif + +/** + * SYS_DEBUG: Enable debugging in sys.c. + */ +#if !defined SYS_DEBUG || defined __DOXYGEN__ +#define SYS_DEBUG LWIP_DBG_OFF +#endif + +/** + * TIMERS_DEBUG: Enable debugging in timers.c. + */ +#if !defined TIMERS_DEBUG || defined __DOXYGEN__ +#define TIMERS_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_DEBUG: Enable debugging for TCP. + */ +#if !defined TCP_DEBUG || defined __DOXYGEN__ +#define TCP_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_INPUT_DEBUG: Enable debugging in tcp_in.c for incoming debug. + */ +#if !defined TCP_INPUT_DEBUG || defined __DOXYGEN__ +#define TCP_INPUT_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_FR_DEBUG: Enable debugging in tcp_in.c for fast retransmit. + */ +#if !defined TCP_FR_DEBUG || defined __DOXYGEN__ +#define TCP_FR_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_RTO_DEBUG: Enable debugging in TCP for retransmit + * timeout. + */ +#if !defined TCP_RTO_DEBUG || defined __DOXYGEN__ +#define TCP_RTO_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_CWND_DEBUG: Enable debugging for TCP congestion window. + */ +#if !defined TCP_CWND_DEBUG || defined __DOXYGEN__ +#define TCP_CWND_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_WND_DEBUG: Enable debugging in tcp_in.c for window updating. + */ +#if !defined TCP_WND_DEBUG || defined __DOXYGEN__ +#define TCP_WND_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_OUTPUT_DEBUG: Enable debugging in tcp_out.c output functions. + */ +#if !defined TCP_OUTPUT_DEBUG || defined __DOXYGEN__ +#define TCP_OUTPUT_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_RST_DEBUG: Enable debugging for TCP with the RST message. + */ +#if !defined TCP_RST_DEBUG || defined __DOXYGEN__ +#define TCP_RST_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCP_QLEN_DEBUG: Enable debugging for TCP queue lengths. + */ +#if !defined TCP_QLEN_DEBUG || defined __DOXYGEN__ +#define TCP_QLEN_DEBUG LWIP_DBG_OFF +#endif + +/** + * UDP_DEBUG: Enable debugging in UDP. + */ +#if !defined UDP_DEBUG || defined __DOXYGEN__ +#define UDP_DEBUG LWIP_DBG_OFF +#endif + +/** + * TCPIP_DEBUG: Enable debugging in tcpip.c. + */ +#if !defined TCPIP_DEBUG || defined __DOXYGEN__ +#define TCPIP_DEBUG LWIP_DBG_OFF +#endif + +/** + * SLIP_DEBUG: Enable debugging in slipif.c. + */ +#if !defined SLIP_DEBUG || defined __DOXYGEN__ +#define SLIP_DEBUG LWIP_DBG_OFF +#endif + +/** + * DHCP_DEBUG: Enable debugging in dhcp.c. + */ +#if !defined DHCP_DEBUG || defined __DOXYGEN__ +#define DHCP_DEBUG LWIP_DBG_OFF +#endif + +/** + * AUTOIP_DEBUG: Enable debugging in autoip.c. + */ +#if !defined AUTOIP_DEBUG || defined __DOXYGEN__ +#define AUTOIP_DEBUG LWIP_DBG_OFF +#endif + +/** + * DNS_DEBUG: Enable debugging for DNS. + */ +#if !defined DNS_DEBUG || defined __DOXYGEN__ +#define DNS_DEBUG LWIP_DBG_OFF +#endif + +/** + * IP6_DEBUG: Enable debugging for IPv6. + */ +#if !defined IP6_DEBUG || defined __DOXYGEN__ +#define IP6_DEBUG LWIP_DBG_OFF +#endif + +/** + * DHCP6_DEBUG: Enable debugging in dhcp6.c. + */ +#if !defined DHCP6_DEBUG || defined __DOXYGEN__ +#define DHCP6_DEBUG LWIP_DBG_OFF +#endif +/** + * @} + */ + +/** + * LWIP_TESTMODE: Changes to make unit test possible + */ +#if !defined LWIP_TESTMODE +#define LWIP_TESTMODE 0 +#endif + +/* + -------------------------------------------------- + ---------- Performance tracking options ---------- + -------------------------------------------------- +*/ +/** + * @defgroup lwip_opts_perf Performance + * @ingroup lwip_opts_debug + * @{ + */ +/** + * LWIP_PERF: Enable performance testing for lwIP + * (if enabled, arch/perf.h is included) + */ +#if !defined LWIP_PERF || defined __DOXYGEN__ +#define LWIP_PERF 0 +#endif +/** + * @} + */ + +#endif /* LWIP_HDR_OPT_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/pbuf.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/pbuf.h index 328c772d..82902a4e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/pbuf.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/pbuf.h @@ -1,322 +1,322 @@ -/** - * @file - * pbuf API - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#ifndef LWIP_HDR_PBUF_H -#define LWIP_HDR_PBUF_H - -#include "lwip/opt.h" -#include "lwip/err.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** LWIP_SUPPORT_CUSTOM_PBUF==1: Custom pbufs behave much like their pbuf type - * but they are allocated by external code (initialised by calling - * pbuf_alloced_custom()) and when pbuf_free gives up their last reference, they - * are freed by calling pbuf_custom->custom_free_function(). - * Currently, the pbuf_custom code is only needed for one specific configuration - * of IP_FRAG, unless required by external driver/application code. */ -#ifndef LWIP_SUPPORT_CUSTOM_PBUF -#define LWIP_SUPPORT_CUSTOM_PBUF ((IP_FRAG && !LWIP_NETIF_TX_SINGLE_PBUF) || (LWIP_IPV6 && LWIP_IPV6_FRAG)) -#endif - -/** @ingroup pbuf - * PBUF_NEEDS_COPY(p): return a boolean value indicating whether the given - * pbuf needs to be copied in order to be kept around beyond the current call - * stack without risking being corrupted. The default setting provides safety: - * it will make a copy iof any pbuf chain that does not consist entirely of - * PBUF_ROM type pbufs. For setups with zero-copy support, it may be redefined - * to evaluate to true in all cases, for example. However, doing so also has an - * effect on the application side: any buffers that are *not* copied must also - * *not* be reused by the application after passing them to lwIP. For example, - * when setting PBUF_NEEDS_COPY to (0), after using udp_send() with a PBUF_RAM - * pbuf, the application must free the pbuf immediately, rather than reusing it - * for other purposes. For more background information on this, see tasks #6735 - * and #7896, and bugs #11400 and #49914. */ -#ifndef PBUF_NEEDS_COPY -#define PBUF_NEEDS_COPY(p) ((p)->type_internal & PBUF_TYPE_FLAG_DATA_VOLATILE) -#endif /* PBUF_NEEDS_COPY */ - -/* @todo: We need a mechanism to prevent wasting memory in every pbuf - (TCP vs. UDP, IPv4 vs. IPv6: UDP/IPv4 packets may waste up to 28 bytes) */ - -#define PBUF_TRANSPORT_HLEN 20 -#if LWIP_IPV6 -#define PBUF_IP_HLEN 40 -#else -#define PBUF_IP_HLEN 20 -#endif - -/** - * @ingroup pbuf - * Enumeration of pbuf layers - */ -typedef enum { - /** Includes spare room for transport layer header, e.g. UDP header. - * Use this if you intend to pass the pbuf to functions like udp_send(). - */ - PBUF_TRANSPORT = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN, - /** Includes spare room for IP header. - * Use this if you intend to pass the pbuf to functions like raw_send(). - */ - PBUF_IP = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN, - /** Includes spare room for link layer header (ethernet header). - * Use this if you intend to pass the pbuf to functions like ethernet_output(). - * @see PBUF_LINK_HLEN - */ - PBUF_LINK = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN, - /** Includes spare room for additional encapsulation header before ethernet - * headers (e.g. 802.11). - * Use this if you intend to pass the pbuf to functions like netif->linkoutput(). - * @see PBUF_LINK_ENCAPSULATION_HLEN - */ - PBUF_RAW_TX = PBUF_LINK_ENCAPSULATION_HLEN, - /** Use this for input packets in a netif driver when calling netif->input() - * in the most common case - ethernet-layer netif driver. */ - PBUF_RAW = 0 -} pbuf_layer; - - -/* Base flags for pbuf_type definitions: */ - -/** Indicates that the payload directly follows the struct pbuf. - * This makes @ref pbuf_header work in both directions. */ -#define PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS 0x80 -/** Indicates the data stored in this pbuf can change. If this pbuf needs - * to be queued, it must be copied/duplicated. */ -#define PBUF_TYPE_FLAG_DATA_VOLATILE 0x40 -/** 4 bits are reserved for 16 allocation sources (e.g. heap, pool1, pool2, etc) - * Internally, we use: 0=heap, 1=MEMP_PBUF, 2=MEMP_PBUF_POOL -> 13 types free*/ -#define PBUF_TYPE_ALLOC_SRC_MASK 0x0F -/** Indicates this pbuf is used for RX (if not set, indicates use for TX). - * This information can be used to keep some spare RX buffers e.g. for - * receiving TCP ACKs to unblock a connection) */ -#define PBUF_ALLOC_FLAG_RX 0x0100 -/** Indicates the application needs the pbuf payload to be in one piece */ -#define PBUF_ALLOC_FLAG_DATA_CONTIGUOUS 0x0200 - -#define PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP 0x00 -#define PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF 0x01 -#define PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL 0x02 -/** First pbuf allocation type for applications */ -#define PBUF_TYPE_ALLOC_SRC_MASK_APP_MIN 0x03 -/** Last pbuf allocation type for applications */ -#define PBUF_TYPE_ALLOC_SRC_MASK_APP_MAX PBUF_TYPE_ALLOC_SRC_MASK - -/** - * @ingroup pbuf - * Enumeration of pbuf types - */ -typedef enum { - /** pbuf data is stored in RAM, used for TX mostly, struct pbuf and its payload - are allocated in one piece of contiguous memory (so the first payload byte - can be calculated from struct pbuf). - pbuf_alloc() allocates PBUF_RAM pbufs as unchained pbufs (although that might - change in future versions). - This should be used for all OUTGOING packets (TX).*/ - PBUF_RAM = (PBUF_ALLOC_FLAG_DATA_CONTIGUOUS | PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS | PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP), - /** pbuf data is stored in ROM, i.e. struct pbuf and its payload are located in - totally different memory areas. Since it points to ROM, payload does not - have to be copied when queued for transmission. */ - PBUF_ROM = PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF, - /** pbuf comes from the pbuf pool. Much like PBUF_ROM but payload might change - so it has to be duplicated when queued before transmitting, depending on - who has a 'ref' to it. */ - PBUF_REF = (PBUF_TYPE_FLAG_DATA_VOLATILE | PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF), - /** pbuf payload refers to RAM. This one comes from a pool and should be used - for RX. Payload can be chained (scatter-gather RX) but like PBUF_RAM, struct - pbuf and its payload are allocated in one piece of contiguous memory (so - the first payload byte can be calculated from struct pbuf). - Don't use this for TX, if the pool becomes empty e.g. because of TCP queuing, - you are unable to receive TCP acks! */ - PBUF_POOL = (PBUF_ALLOC_FLAG_RX | PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS | PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL) -} pbuf_type; - - -/** indicates this packet's data should be immediately passed to the application */ -#define PBUF_FLAG_PUSH 0x01U -/** indicates this is a custom pbuf: pbuf_free calls pbuf_custom->custom_free_function() - when the last reference is released (plus custom PBUF_RAM cannot be trimmed) */ -#define PBUF_FLAG_IS_CUSTOM 0x02U -/** indicates this pbuf is UDP multicast to be looped back */ -#define PBUF_FLAG_MCASTLOOP 0x04U -/** indicates this pbuf was received as link-level broadcast */ -#define PBUF_FLAG_LLBCAST 0x08U -/** indicates this pbuf was received as link-level multicast */ -#define PBUF_FLAG_LLMCAST 0x10U -/** indicates this pbuf includes a TCP FIN flag */ -#define PBUF_FLAG_TCP_FIN 0x20U - -/** Main packet buffer struct */ -struct pbuf { - /** next pbuf in singly linked pbuf chain */ - struct pbuf *next; - - /** pointer to the actual data in the buffer */ - void *payload; - - /** - * total length of this buffer and all next buffers in chain - * belonging to the same packet. - * - * For non-queue packet chains this is the invariant: - * p->tot_len == p->len + (p->next? p->next->tot_len: 0) - */ - u16_t tot_len; - - /** length of this buffer */ - u16_t len; - - /** a bit field indicating pbuf type and allocation sources - (see PBUF_TYPE_FLAG_*, PBUF_ALLOC_FLAG_* and PBUF_TYPE_ALLOC_SRC_MASK) - */ - u8_t type_internal; - - /** misc flags */ - u8_t flags; - - /** - * the reference count always equals the number of pointers - * that refer to this pbuf. This can be pointers from an application, - * the stack itself, or pbuf->next pointers from a chain. - */ - LWIP_PBUF_REF_T ref; - - /** For incoming packets, this contains the input netif's index */ - u8_t if_idx; -}; - - -/** Helper struct for const-correctness only. - * The only meaning of this one is to provide a const payload pointer - * for PBUF_ROM type. - */ -struct pbuf_rom { - /** next pbuf in singly linked pbuf chain */ - struct pbuf *next; - - /** pointer to the actual data in the buffer */ - const void *payload; -}; - -#if LWIP_SUPPORT_CUSTOM_PBUF -/** Prototype for a function to free a custom pbuf */ -typedef void (*pbuf_free_custom_fn)(struct pbuf *p); - -/** A custom pbuf: like a pbuf, but following a function pointer to free it. */ -struct pbuf_custom { - /** The actual pbuf */ - struct pbuf pbuf; - /** This function is called when pbuf_free deallocates this pbuf(_custom) */ - pbuf_free_custom_fn custom_free_function; -}; -#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ - -/** Define this to 0 to prevent freeing ooseq pbufs when the PBUF_POOL is empty */ -#ifndef PBUF_POOL_FREE_OOSEQ -#define PBUF_POOL_FREE_OOSEQ 1 -#endif /* PBUF_POOL_FREE_OOSEQ */ -#if LWIP_TCP && TCP_QUEUE_OOSEQ && NO_SYS && PBUF_POOL_FREE_OOSEQ -extern volatile u8_t pbuf_free_ooseq_pending; -void pbuf_free_ooseq(void); -/** When not using sys_check_timeouts(), call PBUF_CHECK_FREE_OOSEQ() - at regular intervals from main level to check if ooseq pbufs need to be - freed! */ -#define PBUF_CHECK_FREE_OOSEQ() do { if(pbuf_free_ooseq_pending) { \ - /* pbuf_alloc() reported PBUF_POOL to be empty -> try to free some \ - ooseq queued pbufs now */ \ - pbuf_free_ooseq(); }}while(0) -#else /* LWIP_TCP && TCP_QUEUE_OOSEQ && NO_SYS && PBUF_POOL_FREE_OOSEQ */ - /* Otherwise declare an empty PBUF_CHECK_FREE_OOSEQ */ - #define PBUF_CHECK_FREE_OOSEQ() -#endif /* LWIP_TCP && TCP_QUEUE_OOSEQ && NO_SYS && PBUF_POOL_FREE_OOSEQ*/ - -/* Initializes the pbuf module. This call is empty for now, but may not be in future. */ -#define pbuf_init() - -struct pbuf *pbuf_alloc(pbuf_layer l, u16_t length, pbuf_type type); -struct pbuf *pbuf_alloc_reference(void *payload, u16_t length, pbuf_type type); -#if LWIP_SUPPORT_CUSTOM_PBUF -struct pbuf *pbuf_alloced_custom(pbuf_layer l, u16_t length, pbuf_type type, - struct pbuf_custom *p, void *payload_mem, - u16_t payload_mem_len); -#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ -void pbuf_realloc(struct pbuf *p, u16_t size); -#define pbuf_get_allocsrc(p) ((p)->type_internal & PBUF_TYPE_ALLOC_SRC_MASK) -#define pbuf_match_allocsrc(p, type) (pbuf_get_allocsrc(p) == ((type) & PBUF_TYPE_ALLOC_SRC_MASK)) -#define pbuf_match_type(p, type) pbuf_match_allocsrc(p, type) -u8_t pbuf_header(struct pbuf *p, s16_t header_size); -u8_t pbuf_header_force(struct pbuf *p, s16_t header_size); -u8_t pbuf_add_header(struct pbuf *p, size_t header_size_increment); -u8_t pbuf_add_header_force(struct pbuf *p, size_t header_size_increment); -u8_t pbuf_remove_header(struct pbuf *p, size_t header_size); -struct pbuf *pbuf_free_header(struct pbuf *q, u16_t size); -void pbuf_ref(struct pbuf *p); -u8_t pbuf_free(struct pbuf *p); -u16_t pbuf_clen(const struct pbuf *p); -void pbuf_cat(struct pbuf *head, struct pbuf *tail); -void pbuf_chain(struct pbuf *head, struct pbuf *tail); -struct pbuf *pbuf_dechain(struct pbuf *p); -err_t pbuf_copy(struct pbuf *p_to, const struct pbuf *p_from); -u16_t pbuf_copy_partial(const struct pbuf *p, void *dataptr, u16_t len, u16_t offset); -void *pbuf_get_contiguous(const struct pbuf *p, void *buffer, size_t bufsize, u16_t len, u16_t offset); -err_t pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len); -err_t pbuf_take_at(struct pbuf *buf, const void *dataptr, u16_t len, u16_t offset); -struct pbuf *pbuf_skip(struct pbuf* in, u16_t in_offset, u16_t* out_offset); -struct pbuf *pbuf_coalesce(struct pbuf *p, pbuf_layer layer); -struct pbuf *pbuf_clone(pbuf_layer l, pbuf_type type, struct pbuf *p); -#if LWIP_CHECKSUM_ON_COPY -err_t pbuf_fill_chksum(struct pbuf *p, u16_t start_offset, const void *dataptr, - u16_t len, u16_t *chksum); -#endif /* LWIP_CHECKSUM_ON_COPY */ -#if LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE -void pbuf_split_64k(struct pbuf *p, struct pbuf **rest); -#endif /* LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ - -u8_t pbuf_get_at(const struct pbuf* p, u16_t offset); -int pbuf_try_get_at(const struct pbuf* p, u16_t offset); -void pbuf_put_at(struct pbuf* p, u16_t offset, u8_t data); -u16_t pbuf_memcmp(const struct pbuf* p, u16_t offset, const void* s2, u16_t n); -u16_t pbuf_memfind(const struct pbuf* p, const void* mem, u16_t mem_len, u16_t start_offset); -u16_t pbuf_strstr(const struct pbuf* p, const char* substr); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PBUF_H */ +/** + * @file + * pbuf API + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#ifndef LWIP_HDR_PBUF_H +#define LWIP_HDR_PBUF_H + +#include "lwip/opt.h" +#include "lwip/err.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** LWIP_SUPPORT_CUSTOM_PBUF==1: Custom pbufs behave much like their pbuf type + * but they are allocated by external code (initialised by calling + * pbuf_alloced_custom()) and when pbuf_free gives up their last reference, they + * are freed by calling pbuf_custom->custom_free_function(). + * Currently, the pbuf_custom code is only needed for one specific configuration + * of IP_FRAG, unless required by external driver/application code. */ +#ifndef LWIP_SUPPORT_CUSTOM_PBUF +#define LWIP_SUPPORT_CUSTOM_PBUF ((IP_FRAG && !LWIP_NETIF_TX_SINGLE_PBUF) || (LWIP_IPV6 && LWIP_IPV6_FRAG)) +#endif + +/** @ingroup pbuf + * PBUF_NEEDS_COPY(p): return a boolean value indicating whether the given + * pbuf needs to be copied in order to be kept around beyond the current call + * stack without risking being corrupted. The default setting provides safety: + * it will make a copy iof any pbuf chain that does not consist entirely of + * PBUF_ROM type pbufs. For setups with zero-copy support, it may be redefined + * to evaluate to true in all cases, for example. However, doing so also has an + * effect on the application side: any buffers that are *not* copied must also + * *not* be reused by the application after passing them to lwIP. For example, + * when setting PBUF_NEEDS_COPY to (0), after using udp_send() with a PBUF_RAM + * pbuf, the application must free the pbuf immediately, rather than reusing it + * for other purposes. For more background information on this, see tasks #6735 + * and #7896, and bugs #11400 and #49914. */ +#ifndef PBUF_NEEDS_COPY +#define PBUF_NEEDS_COPY(p) ((p)->type_internal & PBUF_TYPE_FLAG_DATA_VOLATILE) +#endif /* PBUF_NEEDS_COPY */ + +/* @todo: We need a mechanism to prevent wasting memory in every pbuf + (TCP vs. UDP, IPv4 vs. IPv6: UDP/IPv4 packets may waste up to 28 bytes) */ + +#define PBUF_TRANSPORT_HLEN 20 +#if LWIP_IPV6 +#define PBUF_IP_HLEN 40 +#else +#define PBUF_IP_HLEN 20 +#endif + +/** + * @ingroup pbuf + * Enumeration of pbuf layers + */ +typedef enum { + /** Includes spare room for transport layer header, e.g. UDP header. + * Use this if you intend to pass the pbuf to functions like udp_send(). + */ + PBUF_TRANSPORT = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN + PBUF_TRANSPORT_HLEN, + /** Includes spare room for IP header. + * Use this if you intend to pass the pbuf to functions like raw_send(). + */ + PBUF_IP = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN + PBUF_IP_HLEN, + /** Includes spare room for link layer header (ethernet header). + * Use this if you intend to pass the pbuf to functions like ethernet_output(). + * @see PBUF_LINK_HLEN + */ + PBUF_LINK = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN, + /** Includes spare room for additional encapsulation header before ethernet + * headers (e.g. 802.11). + * Use this if you intend to pass the pbuf to functions like netif->linkoutput(). + * @see PBUF_LINK_ENCAPSULATION_HLEN + */ + PBUF_RAW_TX = PBUF_LINK_ENCAPSULATION_HLEN, + /** Use this for input packets in a netif driver when calling netif->input() + * in the most common case - ethernet-layer netif driver. */ + PBUF_RAW = 0 +} pbuf_layer; + + +/* Base flags for pbuf_type definitions: */ + +/** Indicates that the payload directly follows the struct pbuf. + * This makes @ref pbuf_header work in both directions. */ +#define PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS 0x80 +/** Indicates the data stored in this pbuf can change. If this pbuf needs + * to be queued, it must be copied/duplicated. */ +#define PBUF_TYPE_FLAG_DATA_VOLATILE 0x40 +/** 4 bits are reserved for 16 allocation sources (e.g. heap, pool1, pool2, etc) + * Internally, we use: 0=heap, 1=MEMP_PBUF, 2=MEMP_PBUF_POOL -> 13 types free*/ +#define PBUF_TYPE_ALLOC_SRC_MASK 0x0F +/** Indicates this pbuf is used for RX (if not set, indicates use for TX). + * This information can be used to keep some spare RX buffers e.g. for + * receiving TCP ACKs to unblock a connection) */ +#define PBUF_ALLOC_FLAG_RX 0x0100 +/** Indicates the application needs the pbuf payload to be in one piece */ +#define PBUF_ALLOC_FLAG_DATA_CONTIGUOUS 0x0200 + +#define PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP 0x00 +#define PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF 0x01 +#define PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL 0x02 +/** First pbuf allocation type for applications */ +#define PBUF_TYPE_ALLOC_SRC_MASK_APP_MIN 0x03 +/** Last pbuf allocation type for applications */ +#define PBUF_TYPE_ALLOC_SRC_MASK_APP_MAX PBUF_TYPE_ALLOC_SRC_MASK + +/** + * @ingroup pbuf + * Enumeration of pbuf types + */ +typedef enum { + /** pbuf data is stored in RAM, used for TX mostly, struct pbuf and its payload + are allocated in one piece of contiguous memory (so the first payload byte + can be calculated from struct pbuf). + pbuf_alloc() allocates PBUF_RAM pbufs as unchained pbufs (although that might + change in future versions). + This should be used for all OUTGOING packets (TX).*/ + PBUF_RAM = (PBUF_ALLOC_FLAG_DATA_CONTIGUOUS | PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS | PBUF_TYPE_ALLOC_SRC_MASK_STD_HEAP), + /** pbuf data is stored in ROM, i.e. struct pbuf and its payload are located in + totally different memory areas. Since it points to ROM, payload does not + have to be copied when queued for transmission. */ + PBUF_ROM = PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF, + /** pbuf comes from the pbuf pool. Much like PBUF_ROM but payload might change + so it has to be duplicated when queued before transmitting, depending on + who has a 'ref' to it. */ + PBUF_REF = (PBUF_TYPE_FLAG_DATA_VOLATILE | PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF), + /** pbuf payload refers to RAM. This one comes from a pool and should be used + for RX. Payload can be chained (scatter-gather RX) but like PBUF_RAM, struct + pbuf and its payload are allocated in one piece of contiguous memory (so + the first payload byte can be calculated from struct pbuf). + Don't use this for TX, if the pool becomes empty e.g. because of TCP queuing, + you are unable to receive TCP acks! */ + PBUF_POOL = (PBUF_ALLOC_FLAG_RX | PBUF_TYPE_FLAG_STRUCT_DATA_CONTIGUOUS | PBUF_TYPE_ALLOC_SRC_MASK_STD_MEMP_PBUF_POOL) +} pbuf_type; + + +/** indicates this packet's data should be immediately passed to the application */ +#define PBUF_FLAG_PUSH 0x01U +/** indicates this is a custom pbuf: pbuf_free calls pbuf_custom->custom_free_function() + when the last reference is released (plus custom PBUF_RAM cannot be trimmed) */ +#define PBUF_FLAG_IS_CUSTOM 0x02U +/** indicates this pbuf is UDP multicast to be looped back */ +#define PBUF_FLAG_MCASTLOOP 0x04U +/** indicates this pbuf was received as link-level broadcast */ +#define PBUF_FLAG_LLBCAST 0x08U +/** indicates this pbuf was received as link-level multicast */ +#define PBUF_FLAG_LLMCAST 0x10U +/** indicates this pbuf includes a TCP FIN flag */ +#define PBUF_FLAG_TCP_FIN 0x20U + +/** Main packet buffer struct */ +struct pbuf { + /** next pbuf in singly linked pbuf chain */ + struct pbuf *next; + + /** pointer to the actual data in the buffer */ + void *payload; + + /** + * total length of this buffer and all next buffers in chain + * belonging to the same packet. + * + * For non-queue packet chains this is the invariant: + * p->tot_len == p->len + (p->next? p->next->tot_len: 0) + */ + u16_t tot_len; + + /** length of this buffer */ + u16_t len; + + /** a bit field indicating pbuf type and allocation sources + (see PBUF_TYPE_FLAG_*, PBUF_ALLOC_FLAG_* and PBUF_TYPE_ALLOC_SRC_MASK) + */ + u8_t type_internal; + + /** misc flags */ + u8_t flags; + + /** + * the reference count always equals the number of pointers + * that refer to this pbuf. This can be pointers from an application, + * the stack itself, or pbuf->next pointers from a chain. + */ + LWIP_PBUF_REF_T ref; + + /** For incoming packets, this contains the input netif's index */ + u8_t if_idx; +}; + + +/** Helper struct for const-correctness only. + * The only meaning of this one is to provide a const payload pointer + * for PBUF_ROM type. + */ +struct pbuf_rom { + /** next pbuf in singly linked pbuf chain */ + struct pbuf *next; + + /** pointer to the actual data in the buffer */ + const void *payload; +}; + +#if LWIP_SUPPORT_CUSTOM_PBUF +/** Prototype for a function to free a custom pbuf */ +typedef void (*pbuf_free_custom_fn)(struct pbuf *p); + +/** A custom pbuf: like a pbuf, but following a function pointer to free it. */ +struct pbuf_custom { + /** The actual pbuf */ + struct pbuf pbuf; + /** This function is called when pbuf_free deallocates this pbuf(_custom) */ + pbuf_free_custom_fn custom_free_function; +}; +#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ + +/** Define this to 0 to prevent freeing ooseq pbufs when the PBUF_POOL is empty */ +#ifndef PBUF_POOL_FREE_OOSEQ +#define PBUF_POOL_FREE_OOSEQ 1 +#endif /* PBUF_POOL_FREE_OOSEQ */ +#if LWIP_TCP && TCP_QUEUE_OOSEQ && NO_SYS && PBUF_POOL_FREE_OOSEQ +extern volatile u8_t pbuf_free_ooseq_pending; +void pbuf_free_ooseq(void); +/** When not using sys_check_timeouts(), call PBUF_CHECK_FREE_OOSEQ() + at regular intervals from main level to check if ooseq pbufs need to be + freed! */ +#define PBUF_CHECK_FREE_OOSEQ() do { if(pbuf_free_ooseq_pending) { \ + /* pbuf_alloc() reported PBUF_POOL to be empty -> try to free some \ + ooseq queued pbufs now */ \ + pbuf_free_ooseq(); }}while(0) +#else /* LWIP_TCP && TCP_QUEUE_OOSEQ && NO_SYS && PBUF_POOL_FREE_OOSEQ */ + /* Otherwise declare an empty PBUF_CHECK_FREE_OOSEQ */ + #define PBUF_CHECK_FREE_OOSEQ() +#endif /* LWIP_TCP && TCP_QUEUE_OOSEQ && NO_SYS && PBUF_POOL_FREE_OOSEQ*/ + +/* Initializes the pbuf module. This call is empty for now, but may not be in future. */ +#define pbuf_init() + +struct pbuf *pbuf_alloc(pbuf_layer l, u16_t length, pbuf_type type); +struct pbuf *pbuf_alloc_reference(void *payload, u16_t length, pbuf_type type); +#if LWIP_SUPPORT_CUSTOM_PBUF +struct pbuf *pbuf_alloced_custom(pbuf_layer l, u16_t length, pbuf_type type, + struct pbuf_custom *p, void *payload_mem, + u16_t payload_mem_len); +#endif /* LWIP_SUPPORT_CUSTOM_PBUF */ +void pbuf_realloc(struct pbuf *p, u16_t size); +#define pbuf_get_allocsrc(p) ((p)->type_internal & PBUF_TYPE_ALLOC_SRC_MASK) +#define pbuf_match_allocsrc(p, type) (pbuf_get_allocsrc(p) == ((type) & PBUF_TYPE_ALLOC_SRC_MASK)) +#define pbuf_match_type(p, type) pbuf_match_allocsrc(p, type) +u8_t pbuf_header(struct pbuf *p, s16_t header_size); +u8_t pbuf_header_force(struct pbuf *p, s16_t header_size); +u8_t pbuf_add_header(struct pbuf *p, size_t header_size_increment); +u8_t pbuf_add_header_force(struct pbuf *p, size_t header_size_increment); +u8_t pbuf_remove_header(struct pbuf *p, size_t header_size); +struct pbuf *pbuf_free_header(struct pbuf *q, u16_t size); +void pbuf_ref(struct pbuf *p); +u8_t pbuf_free(struct pbuf *p); +u16_t pbuf_clen(const struct pbuf *p); +void pbuf_cat(struct pbuf *head, struct pbuf *tail); +void pbuf_chain(struct pbuf *head, struct pbuf *tail); +struct pbuf *pbuf_dechain(struct pbuf *p); +err_t pbuf_copy(struct pbuf *p_to, const struct pbuf *p_from); +u16_t pbuf_copy_partial(const struct pbuf *p, void *dataptr, u16_t len, u16_t offset); +void *pbuf_get_contiguous(const struct pbuf *p, void *buffer, size_t bufsize, u16_t len, u16_t offset); +err_t pbuf_take(struct pbuf *buf, const void *dataptr, u16_t len); +err_t pbuf_take_at(struct pbuf *buf, const void *dataptr, u16_t len, u16_t offset); +struct pbuf *pbuf_skip(struct pbuf* in, u16_t in_offset, u16_t* out_offset); +struct pbuf *pbuf_coalesce(struct pbuf *p, pbuf_layer layer); +struct pbuf *pbuf_clone(pbuf_layer l, pbuf_type type, struct pbuf *p); +#if LWIP_CHECKSUM_ON_COPY +err_t pbuf_fill_chksum(struct pbuf *p, u16_t start_offset, const void *dataptr, + u16_t len, u16_t *chksum); +#endif /* LWIP_CHECKSUM_ON_COPY */ +#if LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE +void pbuf_split_64k(struct pbuf *p, struct pbuf **rest); +#endif /* LWIP_TCP && TCP_QUEUE_OOSEQ && LWIP_WND_SCALE */ + +u8_t pbuf_get_at(const struct pbuf* p, u16_t offset); +int pbuf_try_get_at(const struct pbuf* p, u16_t offset); +void pbuf_put_at(struct pbuf* p, u16_t offset, u8_t data); +u16_t pbuf_memcmp(const struct pbuf* p, u16_t offset, const void* s2, u16_t n); +u16_t pbuf_memfind(const struct pbuf* p, const void* mem, u16_t mem_len, u16_t start_offset); +u16_t pbuf_strstr(const struct pbuf* p, const char* substr); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PBUF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/altcp_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/altcp_priv.h index 381fc968..2d3b2fdb 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/altcp_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/altcp_priv.h @@ -1,146 +1,146 @@ -/** - * @file - * Application layered TCP connection API (to be used from TCPIP thread)\n - * This interface mimics the tcp callback API to the application while preventing - * direct linking (much like virtual functions). - * This way, an application can make use of other application layer protocols - * on top of TCP without knowing the details (e.g. TLS, proxy connection). - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_ALTCP_PRIV_H -#define LWIP_HDR_ALTCP_PRIV_H - -#include "lwip/opt.h" - -#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/altcp.h" -#include "lwip/ip_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct altcp_pcb *altcp_alloc(void); -void altcp_free(struct altcp_pcb *conn); - -/* Function prototypes for application layers */ -typedef void (*altcp_set_poll_fn)(struct altcp_pcb *conn, u8_t interval); -typedef void (*altcp_recved_fn)(struct altcp_pcb *conn, u16_t len); -typedef err_t (*altcp_bind_fn)(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port); -typedef err_t (*altcp_connect_fn)(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected); - -typedef struct altcp_pcb *(*altcp_listen_fn)(struct altcp_pcb *conn, u8_t backlog, err_t *err); - -typedef void (*altcp_abort_fn)(struct altcp_pcb *conn); -typedef err_t (*altcp_close_fn)(struct altcp_pcb *conn); -typedef err_t (*altcp_shutdown_fn)(struct altcp_pcb *conn, int shut_rx, int shut_tx); - -typedef err_t (*altcp_write_fn)(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags); -typedef err_t (*altcp_output_fn)(struct altcp_pcb *conn); - -typedef u16_t (*altcp_mss_fn)(struct altcp_pcb *conn); -typedef u16_t (*altcp_sndbuf_fn)(struct altcp_pcb *conn); -typedef u16_t (*altcp_sndqueuelen_fn)(struct altcp_pcb *conn); -typedef void (*altcp_nagle_disable_fn)(struct altcp_pcb *conn); -typedef void (*altcp_nagle_enable_fn)(struct altcp_pcb *conn); -typedef int (*altcp_nagle_disabled_fn)(struct altcp_pcb *conn); - -typedef void (*altcp_setprio_fn)(struct altcp_pcb *conn, u8_t prio); - -typedef void (*altcp_dealloc_fn)(struct altcp_pcb *conn); - -typedef err_t (*altcp_get_tcp_addrinfo_fn)(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port); -typedef ip_addr_t *(*altcp_get_ip_fn)(struct altcp_pcb *conn, int local); -typedef u16_t (*altcp_get_port_fn)(struct altcp_pcb *conn, int local); - -#ifdef LWIP_DEBUG -typedef enum tcp_state (*altcp_dbg_get_tcp_state_fn)(struct altcp_pcb *conn); -#endif - -struct altcp_functions { - altcp_set_poll_fn set_poll; - altcp_recved_fn recved; - altcp_bind_fn bind; - altcp_connect_fn connect; - altcp_listen_fn listen; - altcp_abort_fn abort; - altcp_close_fn close; - altcp_shutdown_fn shutdown; - altcp_write_fn write; - altcp_output_fn output; - altcp_mss_fn mss; - altcp_sndbuf_fn sndbuf; - altcp_sndqueuelen_fn sndqueuelen; - altcp_nagle_disable_fn nagle_disable; - altcp_nagle_enable_fn nagle_enable; - altcp_nagle_disabled_fn nagle_disabled; - altcp_setprio_fn setprio; - altcp_dealloc_fn dealloc; - altcp_get_tcp_addrinfo_fn addrinfo; - altcp_get_ip_fn getip; - altcp_get_port_fn getport; -#ifdef LWIP_DEBUG - altcp_dbg_get_tcp_state_fn dbg_get_tcp_state; -#endif -}; - -void altcp_default_set_poll(struct altcp_pcb *conn, u8_t interval); -void altcp_default_recved(struct altcp_pcb *conn, u16_t len); -err_t altcp_default_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port); -err_t altcp_default_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx); -err_t altcp_default_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags); -err_t altcp_default_output(struct altcp_pcb *conn); -u16_t altcp_default_mss(struct altcp_pcb *conn); -u16_t altcp_default_sndbuf(struct altcp_pcb *conn); -u16_t altcp_default_sndqueuelen(struct altcp_pcb *conn); -void altcp_default_nagle_disable(struct altcp_pcb *conn); -void altcp_default_nagle_enable(struct altcp_pcb *conn); -int altcp_default_nagle_disabled(struct altcp_pcb *conn); -void altcp_default_setprio(struct altcp_pcb *conn, u8_t prio); -void altcp_default_dealloc(struct altcp_pcb *conn); -err_t altcp_default_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port); -ip_addr_t *altcp_default_get_ip(struct altcp_pcb *conn, int local); -u16_t altcp_default_get_port(struct altcp_pcb *conn, int local); -#ifdef LWIP_DEBUG -enum tcp_state altcp_default_dbg_get_tcp_state(struct altcp_pcb *conn); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_ALTCP */ - -#endif /* LWIP_HDR_ALTCP_PRIV_H */ +/** + * @file + * Application layered TCP connection API (to be used from TCPIP thread)\n + * This interface mimics the tcp callback API to the application while preventing + * direct linking (much like virtual functions). + * This way, an application can make use of other application layer protocols + * on top of TCP without knowing the details (e.g. TLS, proxy connection). + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_ALTCP_PRIV_H +#define LWIP_HDR_ALTCP_PRIV_H + +#include "lwip/opt.h" + +#if LWIP_ALTCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/altcp.h" +#include "lwip/ip_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct altcp_pcb *altcp_alloc(void); +void altcp_free(struct altcp_pcb *conn); + +/* Function prototypes for application layers */ +typedef void (*altcp_set_poll_fn)(struct altcp_pcb *conn, u8_t interval); +typedef void (*altcp_recved_fn)(struct altcp_pcb *conn, u16_t len); +typedef err_t (*altcp_bind_fn)(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port); +typedef err_t (*altcp_connect_fn)(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port, altcp_connected_fn connected); + +typedef struct altcp_pcb *(*altcp_listen_fn)(struct altcp_pcb *conn, u8_t backlog, err_t *err); + +typedef void (*altcp_abort_fn)(struct altcp_pcb *conn); +typedef err_t (*altcp_close_fn)(struct altcp_pcb *conn); +typedef err_t (*altcp_shutdown_fn)(struct altcp_pcb *conn, int shut_rx, int shut_tx); + +typedef err_t (*altcp_write_fn)(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags); +typedef err_t (*altcp_output_fn)(struct altcp_pcb *conn); + +typedef u16_t (*altcp_mss_fn)(struct altcp_pcb *conn); +typedef u16_t (*altcp_sndbuf_fn)(struct altcp_pcb *conn); +typedef u16_t (*altcp_sndqueuelen_fn)(struct altcp_pcb *conn); +typedef void (*altcp_nagle_disable_fn)(struct altcp_pcb *conn); +typedef void (*altcp_nagle_enable_fn)(struct altcp_pcb *conn); +typedef int (*altcp_nagle_disabled_fn)(struct altcp_pcb *conn); + +typedef void (*altcp_setprio_fn)(struct altcp_pcb *conn, u8_t prio); + +typedef void (*altcp_dealloc_fn)(struct altcp_pcb *conn); + +typedef err_t (*altcp_get_tcp_addrinfo_fn)(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port); +typedef ip_addr_t *(*altcp_get_ip_fn)(struct altcp_pcb *conn, int local); +typedef u16_t (*altcp_get_port_fn)(struct altcp_pcb *conn, int local); + +#ifdef LWIP_DEBUG +typedef enum tcp_state (*altcp_dbg_get_tcp_state_fn)(struct altcp_pcb *conn); +#endif + +struct altcp_functions { + altcp_set_poll_fn set_poll; + altcp_recved_fn recved; + altcp_bind_fn bind; + altcp_connect_fn connect; + altcp_listen_fn listen; + altcp_abort_fn abort; + altcp_close_fn close; + altcp_shutdown_fn shutdown; + altcp_write_fn write; + altcp_output_fn output; + altcp_mss_fn mss; + altcp_sndbuf_fn sndbuf; + altcp_sndqueuelen_fn sndqueuelen; + altcp_nagle_disable_fn nagle_disable; + altcp_nagle_enable_fn nagle_enable; + altcp_nagle_disabled_fn nagle_disabled; + altcp_setprio_fn setprio; + altcp_dealloc_fn dealloc; + altcp_get_tcp_addrinfo_fn addrinfo; + altcp_get_ip_fn getip; + altcp_get_port_fn getport; +#ifdef LWIP_DEBUG + altcp_dbg_get_tcp_state_fn dbg_get_tcp_state; +#endif +}; + +void altcp_default_set_poll(struct altcp_pcb *conn, u8_t interval); +void altcp_default_recved(struct altcp_pcb *conn, u16_t len); +err_t altcp_default_bind(struct altcp_pcb *conn, const ip_addr_t *ipaddr, u16_t port); +err_t altcp_default_shutdown(struct altcp_pcb *conn, int shut_rx, int shut_tx); +err_t altcp_default_write(struct altcp_pcb *conn, const void *dataptr, u16_t len, u8_t apiflags); +err_t altcp_default_output(struct altcp_pcb *conn); +u16_t altcp_default_mss(struct altcp_pcb *conn); +u16_t altcp_default_sndbuf(struct altcp_pcb *conn); +u16_t altcp_default_sndqueuelen(struct altcp_pcb *conn); +void altcp_default_nagle_disable(struct altcp_pcb *conn); +void altcp_default_nagle_enable(struct altcp_pcb *conn); +int altcp_default_nagle_disabled(struct altcp_pcb *conn); +void altcp_default_setprio(struct altcp_pcb *conn, u8_t prio); +void altcp_default_dealloc(struct altcp_pcb *conn); +err_t altcp_default_get_tcp_addrinfo(struct altcp_pcb *conn, int local, ip_addr_t *addr, u16_t *port); +ip_addr_t *altcp_default_get_ip(struct altcp_pcb *conn, int local); +u16_t altcp_default_get_port(struct altcp_pcb *conn, int local); +#ifdef LWIP_DEBUG +enum tcp_state altcp_default_dbg_get_tcp_state(struct altcp_pcb *conn); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_ALTCP */ + +#endif /* LWIP_HDR_ALTCP_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/api_msg.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/api_msg.h index 64c87631..9e8ffc9e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/api_msg.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/api_msg.h @@ -1,272 +1,272 @@ -/** - * @file - * netconn API lwIP internal implementations (do not use in application code) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_API_MSG_H -#define LWIP_HDR_API_MSG_H - -#include "lwip/opt.h" - -#include "lwip/arch.h" -#include "lwip/ip_addr.h" -#include "lwip/err.h" -#include "lwip/sys.h" -#include "lwip/igmp.h" -#include "lwip/api.h" -#include "lwip/priv/tcpip_priv.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_NETCONN || LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ -/* Note: Netconn API is always available when sockets are enabled - - * sockets are implemented on top of them */ - -#if LWIP_MPU_COMPATIBLE -#if LWIP_NETCONN_SEM_PER_THREAD -#define API_MSG_M_DEF_SEM(m) *m -#else -#define API_MSG_M_DEF_SEM(m) API_MSG_M_DEF(m) -#endif -#else /* LWIP_MPU_COMPATIBLE */ -#define API_MSG_M_DEF_SEM(m) API_MSG_M_DEF(m) -#endif /* LWIP_MPU_COMPATIBLE */ - -/* For the netconn API, these values are use as a bitmask! */ -#define NETCONN_SHUT_RD 1 -#define NETCONN_SHUT_WR 2 -#define NETCONN_SHUT_RDWR (NETCONN_SHUT_RD | NETCONN_SHUT_WR) - -/* IP addresses and port numbers are expected to be in - * the same byte order as in the corresponding pcb. - */ -/** This struct includes everything that is necessary to execute a function - for a netconn in another thread context (mainly used to process netconns - in the tcpip_thread context to be thread safe). */ -struct api_msg { - /** The netconn which to process - always needed: it includes the semaphore - which is used to block the application thread until the function finished. */ - struct netconn *conn; - /** The return value of the function executed in tcpip_thread. */ - err_t err; - /** Depending on the executed function, one of these union members is used */ - union { - /** used for lwip_netconn_do_send */ - struct netbuf *b; - /** used for lwip_netconn_do_newconn */ - struct { - u8_t proto; - } n; - /** used for lwip_netconn_do_bind and lwip_netconn_do_connect */ - struct { - API_MSG_M_DEF_C(ip_addr_t, ipaddr); - u16_t port; - u8_t if_idx; - } bc; - /** used for lwip_netconn_do_getaddr */ - struct { - ip_addr_t API_MSG_M_DEF(ipaddr); - u16_t API_MSG_M_DEF(port); - u8_t local; - } ad; - /** used for lwip_netconn_do_write */ - struct { - /** current vector to write */ - const struct netvector *vector; - /** number of unwritten vectors */ - u16_t vector_cnt; - /** offset into current vector */ - size_t vector_off; - /** total length across vectors */ - size_t len; - /** offset into total length/output of bytes written when err == ERR_OK */ - size_t offset; - u8_t apiflags; -#if LWIP_SO_SNDTIMEO - u32_t time_started; -#endif /* LWIP_SO_SNDTIMEO */ - } w; - /** used for lwip_netconn_do_recv */ - struct { - size_t len; - } r; -#if LWIP_TCP - /** used for lwip_netconn_do_close (/shutdown) */ - struct { - u8_t shut; -#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER - u32_t time_started; -#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ - u8_t polls_left; -#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ - } sd; -#endif /* LWIP_TCP */ -#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) - /** used for lwip_netconn_do_join_leave_group */ - struct { - API_MSG_M_DEF_C(ip_addr_t, multiaddr); - API_MSG_M_DEF_C(ip_addr_t, netif_addr); - u8_t if_idx; - enum netconn_igmp join_or_leave; - } jl; -#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ -#if TCP_LISTEN_BACKLOG - struct { - u8_t backlog; - } lb; -#endif /* TCP_LISTEN_BACKLOG */ - } msg; -#if LWIP_NETCONN_SEM_PER_THREAD - sys_sem_t* op_completed_sem; -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ -}; - -#if LWIP_NETCONN_SEM_PER_THREAD -#define LWIP_API_MSG_SEM(msg) ((msg)->op_completed_sem) -#else /* LWIP_NETCONN_SEM_PER_THREAD */ -#define LWIP_API_MSG_SEM(msg) (&(msg)->conn->op_completed) -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - - -#if LWIP_DNS -/** As lwip_netconn_do_gethostbyname requires more arguments but doesn't require a netconn, - it has its own struct (to avoid struct api_msg getting bigger than necessary). - lwip_netconn_do_gethostbyname must be called using tcpip_callback instead of tcpip_apimsg - (see netconn_gethostbyname). */ -struct dns_api_msg { - /** Hostname to query or dotted IP address string */ -#if LWIP_MPU_COMPATIBLE - char name[DNS_MAX_NAME_LENGTH]; -#else /* LWIP_MPU_COMPATIBLE */ - const char *name; -#endif /* LWIP_MPU_COMPATIBLE */ - /** The resolved address is stored here */ - ip_addr_t API_MSG_M_DEF(addr); -#if LWIP_IPV4 && LWIP_IPV6 - /** Type of resolve call */ - u8_t dns_addrtype; -#endif /* LWIP_IPV4 && LWIP_IPV6 */ - /** This semaphore is posted when the name is resolved, the application thread - should wait on it. */ - sys_sem_t API_MSG_M_DEF_SEM(sem); - /** Errors are given back here */ - err_t API_MSG_M_DEF(err); -}; -#endif /* LWIP_DNS */ - -#if LWIP_NETCONN_FULLDUPLEX -int lwip_netconn_is_deallocated_msg(void *msg); -#endif -int lwip_netconn_is_err_msg(void *msg, err_t *err); -void lwip_netconn_do_newconn (void *m); -void lwip_netconn_do_delconn (void *m); -void lwip_netconn_do_bind (void *m); -void lwip_netconn_do_bind_if (void *m); -void lwip_netconn_do_connect (void *m); -void lwip_netconn_do_disconnect (void *m); -void lwip_netconn_do_listen (void *m); -void lwip_netconn_do_send (void *m); -void lwip_netconn_do_recv (void *m); -#if TCP_LISTEN_BACKLOG -void lwip_netconn_do_accepted (void *m); -#endif /* TCP_LISTEN_BACKLOG */ -void lwip_netconn_do_write (void *m); -void lwip_netconn_do_getaddr (void *m); -void lwip_netconn_do_close (void *m); -void lwip_netconn_do_shutdown (void *m); -#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) -void lwip_netconn_do_join_leave_group(void *m); -void lwip_netconn_do_join_leave_group_netif(void *m); -#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ - -#if LWIP_DNS -void lwip_netconn_do_gethostbyname(void *arg); -#endif /* LWIP_DNS */ - -struct netconn* netconn_alloc(enum netconn_type t, netconn_callback callback); -void netconn_free(struct netconn *conn); - -#endif /* LWIP_NETCONN || LWIP_SOCKET */ - -#if LWIP_NETIF_API /* don't build if not configured for use in lwipopts.h */ - -/* netifapi related lwIP internal definitions */ - -#if LWIP_MPU_COMPATIBLE -#define NETIFAPI_IPADDR_DEF(type, m) type m -#else /* LWIP_MPU_COMPATIBLE */ -#define NETIFAPI_IPADDR_DEF(type, m) const type * m -#endif /* LWIP_MPU_COMPATIBLE */ - -typedef void (*netifapi_void_fn)(struct netif *netif); -typedef err_t (*netifapi_errt_fn)(struct netif *netif); - -struct netifapi_msg { - struct tcpip_api_call_data call; - struct netif *netif; - union { - struct { -#if LWIP_IPV4 - NETIFAPI_IPADDR_DEF(ip4_addr_t, ipaddr); - NETIFAPI_IPADDR_DEF(ip4_addr_t, netmask); - NETIFAPI_IPADDR_DEF(ip4_addr_t, gw); -#endif /* LWIP_IPV4 */ - void *state; - netif_init_fn init; - netif_input_fn input; - } add; - struct { - netifapi_void_fn voidfunc; - netifapi_errt_fn errtfunc; - } common; - struct { -#if LWIP_MPU_COMPATIBLE - char name[NETIF_NAMESIZE]; -#else /* LWIP_MPU_COMPATIBLE */ - char *name; -#endif /* LWIP_MPU_COMPATIBLE */ - u8_t index; - } ifs; - } msg; -}; - -#endif /* LWIP_NETIF_API */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_API_MSG_H */ +/** + * @file + * netconn API lwIP internal implementations (do not use in application code) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_API_MSG_H +#define LWIP_HDR_API_MSG_H + +#include "lwip/opt.h" + +#include "lwip/arch.h" +#include "lwip/ip_addr.h" +#include "lwip/err.h" +#include "lwip/sys.h" +#include "lwip/igmp.h" +#include "lwip/api.h" +#include "lwip/priv/tcpip_priv.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_NETCONN || LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ +/* Note: Netconn API is always available when sockets are enabled - + * sockets are implemented on top of them */ + +#if LWIP_MPU_COMPATIBLE +#if LWIP_NETCONN_SEM_PER_THREAD +#define API_MSG_M_DEF_SEM(m) *m +#else +#define API_MSG_M_DEF_SEM(m) API_MSG_M_DEF(m) +#endif +#else /* LWIP_MPU_COMPATIBLE */ +#define API_MSG_M_DEF_SEM(m) API_MSG_M_DEF(m) +#endif /* LWIP_MPU_COMPATIBLE */ + +/* For the netconn API, these values are use as a bitmask! */ +#define NETCONN_SHUT_RD 1 +#define NETCONN_SHUT_WR 2 +#define NETCONN_SHUT_RDWR (NETCONN_SHUT_RD | NETCONN_SHUT_WR) + +/* IP addresses and port numbers are expected to be in + * the same byte order as in the corresponding pcb. + */ +/** This struct includes everything that is necessary to execute a function + for a netconn in another thread context (mainly used to process netconns + in the tcpip_thread context to be thread safe). */ +struct api_msg { + /** The netconn which to process - always needed: it includes the semaphore + which is used to block the application thread until the function finished. */ + struct netconn *conn; + /** The return value of the function executed in tcpip_thread. */ + err_t err; + /** Depending on the executed function, one of these union members is used */ + union { + /** used for lwip_netconn_do_send */ + struct netbuf *b; + /** used for lwip_netconn_do_newconn */ + struct { + u8_t proto; + } n; + /** used for lwip_netconn_do_bind and lwip_netconn_do_connect */ + struct { + API_MSG_M_DEF_C(ip_addr_t, ipaddr); + u16_t port; + u8_t if_idx; + } bc; + /** used for lwip_netconn_do_getaddr */ + struct { + ip_addr_t API_MSG_M_DEF(ipaddr); + u16_t API_MSG_M_DEF(port); + u8_t local; + } ad; + /** used for lwip_netconn_do_write */ + struct { + /** current vector to write */ + const struct netvector *vector; + /** number of unwritten vectors */ + u16_t vector_cnt; + /** offset into current vector */ + size_t vector_off; + /** total length across vectors */ + size_t len; + /** offset into total length/output of bytes written when err == ERR_OK */ + size_t offset; + u8_t apiflags; +#if LWIP_SO_SNDTIMEO + u32_t time_started; +#endif /* LWIP_SO_SNDTIMEO */ + } w; + /** used for lwip_netconn_do_recv */ + struct { + size_t len; + } r; +#if LWIP_TCP + /** used for lwip_netconn_do_close (/shutdown) */ + struct { + u8_t shut; +#if LWIP_SO_SNDTIMEO || LWIP_SO_LINGER + u32_t time_started; +#else /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ + u8_t polls_left; +#endif /* LWIP_SO_SNDTIMEO || LWIP_SO_LINGER */ + } sd; +#endif /* LWIP_TCP */ +#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) + /** used for lwip_netconn_do_join_leave_group */ + struct { + API_MSG_M_DEF_C(ip_addr_t, multiaddr); + API_MSG_M_DEF_C(ip_addr_t, netif_addr); + u8_t if_idx; + enum netconn_igmp join_or_leave; + } jl; +#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ +#if TCP_LISTEN_BACKLOG + struct { + u8_t backlog; + } lb; +#endif /* TCP_LISTEN_BACKLOG */ + } msg; +#if LWIP_NETCONN_SEM_PER_THREAD + sys_sem_t* op_completed_sem; +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ +}; + +#if LWIP_NETCONN_SEM_PER_THREAD +#define LWIP_API_MSG_SEM(msg) ((msg)->op_completed_sem) +#else /* LWIP_NETCONN_SEM_PER_THREAD */ +#define LWIP_API_MSG_SEM(msg) (&(msg)->conn->op_completed) +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + + +#if LWIP_DNS +/** As lwip_netconn_do_gethostbyname requires more arguments but doesn't require a netconn, + it has its own struct (to avoid struct api_msg getting bigger than necessary). + lwip_netconn_do_gethostbyname must be called using tcpip_callback instead of tcpip_apimsg + (see netconn_gethostbyname). */ +struct dns_api_msg { + /** Hostname to query or dotted IP address string */ +#if LWIP_MPU_COMPATIBLE + char name[DNS_MAX_NAME_LENGTH]; +#else /* LWIP_MPU_COMPATIBLE */ + const char *name; +#endif /* LWIP_MPU_COMPATIBLE */ + /** The resolved address is stored here */ + ip_addr_t API_MSG_M_DEF(addr); +#if LWIP_IPV4 && LWIP_IPV6 + /** Type of resolve call */ + u8_t dns_addrtype; +#endif /* LWIP_IPV4 && LWIP_IPV6 */ + /** This semaphore is posted when the name is resolved, the application thread + should wait on it. */ + sys_sem_t API_MSG_M_DEF_SEM(sem); + /** Errors are given back here */ + err_t API_MSG_M_DEF(err); +}; +#endif /* LWIP_DNS */ + +#if LWIP_NETCONN_FULLDUPLEX +int lwip_netconn_is_deallocated_msg(void *msg); +#endif +int lwip_netconn_is_err_msg(void *msg, err_t *err); +void lwip_netconn_do_newconn (void *m); +void lwip_netconn_do_delconn (void *m); +void lwip_netconn_do_bind (void *m); +void lwip_netconn_do_bind_if (void *m); +void lwip_netconn_do_connect (void *m); +void lwip_netconn_do_disconnect (void *m); +void lwip_netconn_do_listen (void *m); +void lwip_netconn_do_send (void *m); +void lwip_netconn_do_recv (void *m); +#if TCP_LISTEN_BACKLOG +void lwip_netconn_do_accepted (void *m); +#endif /* TCP_LISTEN_BACKLOG */ +void lwip_netconn_do_write (void *m); +void lwip_netconn_do_getaddr (void *m); +void lwip_netconn_do_close (void *m); +void lwip_netconn_do_shutdown (void *m); +#if LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) +void lwip_netconn_do_join_leave_group(void *m); +void lwip_netconn_do_join_leave_group_netif(void *m); +#endif /* LWIP_IGMP || (LWIP_IPV6 && LWIP_IPV6_MLD) */ + +#if LWIP_DNS +void lwip_netconn_do_gethostbyname(void *arg); +#endif /* LWIP_DNS */ + +struct netconn* netconn_alloc(enum netconn_type t, netconn_callback callback); +void netconn_free(struct netconn *conn); + +#endif /* LWIP_NETCONN || LWIP_SOCKET */ + +#if LWIP_NETIF_API /* don't build if not configured for use in lwipopts.h */ + +/* netifapi related lwIP internal definitions */ + +#if LWIP_MPU_COMPATIBLE +#define NETIFAPI_IPADDR_DEF(type, m) type m +#else /* LWIP_MPU_COMPATIBLE */ +#define NETIFAPI_IPADDR_DEF(type, m) const type * m +#endif /* LWIP_MPU_COMPATIBLE */ + +typedef void (*netifapi_void_fn)(struct netif *netif); +typedef err_t (*netifapi_errt_fn)(struct netif *netif); + +struct netifapi_msg { + struct tcpip_api_call_data call; + struct netif *netif; + union { + struct { +#if LWIP_IPV4 + NETIFAPI_IPADDR_DEF(ip4_addr_t, ipaddr); + NETIFAPI_IPADDR_DEF(ip4_addr_t, netmask); + NETIFAPI_IPADDR_DEF(ip4_addr_t, gw); +#endif /* LWIP_IPV4 */ + void *state; + netif_init_fn init; + netif_input_fn input; + } add; + struct { + netifapi_void_fn voidfunc; + netifapi_errt_fn errtfunc; + } common; + struct { +#if LWIP_MPU_COMPATIBLE + char name[NETIF_NAMESIZE]; +#else /* LWIP_MPU_COMPATIBLE */ + char *name; +#endif /* LWIP_MPU_COMPATIBLE */ + u8_t index; + } ifs; + } msg; +}; + +#endif /* LWIP_NETIF_API */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_API_MSG_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/mem_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/mem_priv.h index 5abd9b5d..8630d754 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/mem_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/mem_priv.h @@ -1,84 +1,84 @@ -/** - * @file - * lwIP internal memory implementations (do not use in application code) - */ - -/* - * Copyright (c) 2018 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#ifndef LWIP_HDR_MEM_PRIV_H -#define LWIP_HDR_MEM_PRIV_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#include "lwip/mem.h" - -#if MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK -/* if MEM_OVERFLOW_CHECK or MEMP_OVERFLOW_CHECK is turned on, we reserve some - * bytes at the beginning and at the end of each element, initialize them as - * 0xcd and check them later. - * If MEM(P)_OVERFLOW_CHECK is >= 2, on every call to mem(p)_malloc or mem(p)_free, - * every single element in each pool/heap is checked! - * This is VERY SLOW but also very helpful. - * MEM_SANITY_REGION_BEFORE and MEM_SANITY_REGION_AFTER can be overridden in - * lwipopts.h to change the amount reserved for checking. */ -#ifndef MEM_SANITY_REGION_BEFORE -#define MEM_SANITY_REGION_BEFORE 16 -#endif /* MEM_SANITY_REGION_BEFORE*/ -#if MEM_SANITY_REGION_BEFORE > 0 -#define MEM_SANITY_REGION_BEFORE_ALIGNED LWIP_MEM_ALIGN_SIZE(MEM_SANITY_REGION_BEFORE) -#else -#define MEM_SANITY_REGION_BEFORE_ALIGNED 0 -#endif /* MEM_SANITY_REGION_BEFORE*/ -#ifndef MEM_SANITY_REGION_AFTER -#define MEM_SANITY_REGION_AFTER 16 -#endif /* MEM_SANITY_REGION_AFTER*/ -#if MEM_SANITY_REGION_AFTER > 0 -#define MEM_SANITY_REGION_AFTER_ALIGNED LWIP_MEM_ALIGN_SIZE(MEM_SANITY_REGION_AFTER) -#else -#define MEM_SANITY_REGION_AFTER_ALIGNED 0 -#endif /* MEM_SANITY_REGION_AFTER*/ - -void mem_overflow_init_raw(void *p, size_t size); -void mem_overflow_check_raw(void *p, size_t size, const char *descr1, const char *descr2); - -#endif /* MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_MEMP_PRIV_H */ +/** + * @file + * lwIP internal memory implementations (do not use in application code) + */ + +/* + * Copyright (c) 2018 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#ifndef LWIP_HDR_MEM_PRIV_H +#define LWIP_HDR_MEM_PRIV_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#include "lwip/mem.h" + +#if MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK +/* if MEM_OVERFLOW_CHECK or MEMP_OVERFLOW_CHECK is turned on, we reserve some + * bytes at the beginning and at the end of each element, initialize them as + * 0xcd and check them later. + * If MEM(P)_OVERFLOW_CHECK is >= 2, on every call to mem(p)_malloc or mem(p)_free, + * every single element in each pool/heap is checked! + * This is VERY SLOW but also very helpful. + * MEM_SANITY_REGION_BEFORE and MEM_SANITY_REGION_AFTER can be overridden in + * lwipopts.h to change the amount reserved for checking. */ +#ifndef MEM_SANITY_REGION_BEFORE +#define MEM_SANITY_REGION_BEFORE 16 +#endif /* MEM_SANITY_REGION_BEFORE*/ +#if MEM_SANITY_REGION_BEFORE > 0 +#define MEM_SANITY_REGION_BEFORE_ALIGNED LWIP_MEM_ALIGN_SIZE(MEM_SANITY_REGION_BEFORE) +#else +#define MEM_SANITY_REGION_BEFORE_ALIGNED 0 +#endif /* MEM_SANITY_REGION_BEFORE*/ +#ifndef MEM_SANITY_REGION_AFTER +#define MEM_SANITY_REGION_AFTER 16 +#endif /* MEM_SANITY_REGION_AFTER*/ +#if MEM_SANITY_REGION_AFTER > 0 +#define MEM_SANITY_REGION_AFTER_ALIGNED LWIP_MEM_ALIGN_SIZE(MEM_SANITY_REGION_AFTER) +#else +#define MEM_SANITY_REGION_AFTER_ALIGNED 0 +#endif /* MEM_SANITY_REGION_AFTER*/ + +void mem_overflow_init_raw(void *p, size_t size); +void mem_overflow_check_raw(void *p, size_t size, const char *descr1, const char *descr2); + +#endif /* MEM_OVERFLOW_CHECK || MEMP_OVERFLOW_CHECK */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_MEMP_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_priv.h index f9930fd7..1f14cb16 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_priv.h @@ -1,161 +1,161 @@ -/** - * @file - * memory pools lwIP internal implementations (do not use in application code) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#ifndef LWIP_HDR_MEMP_PRIV_H -#define LWIP_HDR_MEMP_PRIV_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#include "lwip/mem.h" -#include "lwip/priv/mem_priv.h" - -#if MEMP_OVERFLOW_CHECK - - -/* MEMP_SIZE: save space for struct memp and for sanity check */ -#define MEMP_SIZE (LWIP_MEM_ALIGN_SIZE(sizeof(struct memp)) + MEM_SANITY_REGION_BEFORE_ALIGNED) -#define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x) + MEM_SANITY_REGION_AFTER_ALIGNED) - -#else /* MEMP_OVERFLOW_CHECK */ - -/* No sanity checks - * We don't need to preserve the struct memp while not allocated, so we - * can save a little space and set MEMP_SIZE to 0. - */ -#define MEMP_SIZE 0 -#define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x)) - -#endif /* MEMP_OVERFLOW_CHECK */ - -#if !MEMP_MEM_MALLOC || MEMP_OVERFLOW_CHECK -struct memp { - struct memp *next; -#if MEMP_OVERFLOW_CHECK - const char *file; - int line; -#endif /* MEMP_OVERFLOW_CHECK */ -}; -#endif /* !MEMP_MEM_MALLOC || MEMP_OVERFLOW_CHECK */ - -#if MEM_USE_POOLS && MEMP_USE_CUSTOM_POOLS -/* Use a helper type to get the start and end of the user "memory pools" for mem_malloc */ -typedef enum { - /* Get the first (via: - MEMP_POOL_HELPER_START = ((u8_t) 1*MEMP_POOL_A + 0*MEMP_POOL_B + 0*MEMP_POOL_C + 0)*/ - MEMP_POOL_HELPER_FIRST = ((u8_t) -#define LWIP_MEMPOOL(name,num,size,desc) -#define LWIP_MALLOC_MEMPOOL_START 1 -#define LWIP_MALLOC_MEMPOOL(num, size) * MEMP_POOL_##size + 0 -#define LWIP_MALLOC_MEMPOOL_END -#include "lwip/priv/memp_std.h" - ) , - /* Get the last (via: - MEMP_POOL_HELPER_END = ((u8_t) 0 + MEMP_POOL_A*0 + MEMP_POOL_B*0 + MEMP_POOL_C*1) */ - MEMP_POOL_HELPER_LAST = ((u8_t) -#define LWIP_MEMPOOL(name,num,size,desc) -#define LWIP_MALLOC_MEMPOOL_START -#define LWIP_MALLOC_MEMPOOL(num, size) 0 + MEMP_POOL_##size * -#define LWIP_MALLOC_MEMPOOL_END 1 -#include "lwip/priv/memp_std.h" - ) -} memp_pool_helper_t; - -/* The actual start and stop values are here (cast them over) - We use this helper type and these defines so we can avoid using const memp_t values */ -#define MEMP_POOL_FIRST ((memp_t) MEMP_POOL_HELPER_FIRST) -#define MEMP_POOL_LAST ((memp_t) MEMP_POOL_HELPER_LAST) -#endif /* MEM_USE_POOLS && MEMP_USE_CUSTOM_POOLS */ - -/** Memory pool descriptor */ -struct memp_desc { -#if defined(LWIP_DEBUG) || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY - /** Textual description */ - const char *desc; -#endif /* LWIP_DEBUG || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY */ -#if MEMP_STATS - /** Statistics */ - struct stats_mem *stats; -#endif - - /** Element size */ - u16_t size; - -#if !MEMP_MEM_MALLOC - /** Number of elements */ - u16_t num; - - /** Base address */ - u8_t *base; - - /** First free element of each pool. Elements form a linked list. */ - struct memp **tab; -#endif /* MEMP_MEM_MALLOC */ -}; - -#if defined(LWIP_DEBUG) || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY -#define DECLARE_LWIP_MEMPOOL_DESC(desc) (desc), -#else -#define DECLARE_LWIP_MEMPOOL_DESC(desc) -#endif - -#if MEMP_STATS -#define LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(name) static struct stats_mem name; -#define LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(name) &name, -#else -#define LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(name) -#define LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(name) -#endif - -void memp_init_pool(const struct memp_desc *desc); - -#if MEMP_OVERFLOW_CHECK -void *memp_malloc_pool_fn(const struct memp_desc* desc, const char* file, const int line); -#define memp_malloc_pool(d) memp_malloc_pool_fn((d), __FILE__, __LINE__) -#else -void *memp_malloc_pool(const struct memp_desc *desc); -#endif -void memp_free_pool(const struct memp_desc* desc, void *mem); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_MEMP_PRIV_H */ +/** + * @file + * memory pools lwIP internal implementations (do not use in application code) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#ifndef LWIP_HDR_MEMP_PRIV_H +#define LWIP_HDR_MEMP_PRIV_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#include "lwip/mem.h" +#include "lwip/priv/mem_priv.h" + +#if MEMP_OVERFLOW_CHECK + + +/* MEMP_SIZE: save space for struct memp and for sanity check */ +#define MEMP_SIZE (LWIP_MEM_ALIGN_SIZE(sizeof(struct memp)) + MEM_SANITY_REGION_BEFORE_ALIGNED) +#define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x) + MEM_SANITY_REGION_AFTER_ALIGNED) + +#else /* MEMP_OVERFLOW_CHECK */ + +/* No sanity checks + * We don't need to preserve the struct memp while not allocated, so we + * can save a little space and set MEMP_SIZE to 0. + */ +#define MEMP_SIZE 0 +#define MEMP_ALIGN_SIZE(x) (LWIP_MEM_ALIGN_SIZE(x)) + +#endif /* MEMP_OVERFLOW_CHECK */ + +#if !MEMP_MEM_MALLOC || MEMP_OVERFLOW_CHECK +struct memp { + struct memp *next; +#if MEMP_OVERFLOW_CHECK + const char *file; + int line; +#endif /* MEMP_OVERFLOW_CHECK */ +}; +#endif /* !MEMP_MEM_MALLOC || MEMP_OVERFLOW_CHECK */ + +#if MEM_USE_POOLS && MEMP_USE_CUSTOM_POOLS +/* Use a helper type to get the start and end of the user "memory pools" for mem_malloc */ +typedef enum { + /* Get the first (via: + MEMP_POOL_HELPER_START = ((u8_t) 1*MEMP_POOL_A + 0*MEMP_POOL_B + 0*MEMP_POOL_C + 0)*/ + MEMP_POOL_HELPER_FIRST = ((u8_t) +#define LWIP_MEMPOOL(name,num,size,desc) +#define LWIP_MALLOC_MEMPOOL_START 1 +#define LWIP_MALLOC_MEMPOOL(num, size) * MEMP_POOL_##size + 0 +#define LWIP_MALLOC_MEMPOOL_END +#include "lwip/priv/memp_std.h" + ) , + /* Get the last (via: + MEMP_POOL_HELPER_END = ((u8_t) 0 + MEMP_POOL_A*0 + MEMP_POOL_B*0 + MEMP_POOL_C*1) */ + MEMP_POOL_HELPER_LAST = ((u8_t) +#define LWIP_MEMPOOL(name,num,size,desc) +#define LWIP_MALLOC_MEMPOOL_START +#define LWIP_MALLOC_MEMPOOL(num, size) 0 + MEMP_POOL_##size * +#define LWIP_MALLOC_MEMPOOL_END 1 +#include "lwip/priv/memp_std.h" + ) +} memp_pool_helper_t; + +/* The actual start and stop values are here (cast them over) + We use this helper type and these defines so we can avoid using const memp_t values */ +#define MEMP_POOL_FIRST ((memp_t) MEMP_POOL_HELPER_FIRST) +#define MEMP_POOL_LAST ((memp_t) MEMP_POOL_HELPER_LAST) +#endif /* MEM_USE_POOLS && MEMP_USE_CUSTOM_POOLS */ + +/** Memory pool descriptor */ +struct memp_desc { +#if defined(LWIP_DEBUG) || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY + /** Textual description */ + const char *desc; +#endif /* LWIP_DEBUG || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY */ +#if MEMP_STATS + /** Statistics */ + struct stats_mem *stats; +#endif + + /** Element size */ + u16_t size; + +#if !MEMP_MEM_MALLOC + /** Number of elements */ + u16_t num; + + /** Base address */ + u8_t *base; + + /** First free element of each pool. Elements form a linked list. */ + struct memp **tab; +#endif /* MEMP_MEM_MALLOC */ +}; + +#if defined(LWIP_DEBUG) || MEMP_OVERFLOW_CHECK || LWIP_STATS_DISPLAY +#define DECLARE_LWIP_MEMPOOL_DESC(desc) (desc), +#else +#define DECLARE_LWIP_MEMPOOL_DESC(desc) +#endif + +#if MEMP_STATS +#define LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(name) static struct stats_mem name; +#define LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(name) &name, +#else +#define LWIP_MEMPOOL_DECLARE_STATS_INSTANCE(name) +#define LWIP_MEMPOOL_DECLARE_STATS_REFERENCE(name) +#endif + +void memp_init_pool(const struct memp_desc *desc); + +#if MEMP_OVERFLOW_CHECK +void *memp_malloc_pool_fn(const struct memp_desc* desc, const char* file, const int line); +#define memp_malloc_pool(d) memp_malloc_pool_fn((d), __FILE__, __LINE__) +#else +void *memp_malloc_pool(const struct memp_desc *desc); +#endif +void memp_free_pool(const struct memp_desc* desc, void *mem); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_MEMP_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_std.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_std.h index 4d3b192d..669ad4d7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_std.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/memp_std.h @@ -1,153 +1,153 @@ -/** - * @file - * lwIP internal memory pools (do not use in application code) - * This file is deliberately included multiple times: once with empty - * definition of LWIP_MEMPOOL() to handle all includes and multiple times - * to build up various lists of mem pools. - */ - -/* - * SETUP: Make sure we define everything we will need. - * - * We have create three types of pools: - * 1) MEMPOOL - standard pools - * 2) MALLOC_MEMPOOL - to be used by mem_malloc in mem.c - * 3) PBUF_MEMPOOL - a mempool of pbuf's, so include space for the pbuf struct - * - * If the include'r doesn't require any special treatment of each of the types - * above, then will declare #2 & #3 to be just standard mempools. - */ -#ifndef LWIP_MALLOC_MEMPOOL -/* This treats "malloc pools" just like any other pool. - The pools are a little bigger to provide 'size' as the amount of user data. */ -#define LWIP_MALLOC_MEMPOOL(num, size) LWIP_MEMPOOL(POOL_##size, num, (size + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper))), "MALLOC_"#size) -#define LWIP_MALLOC_MEMPOOL_START -#define LWIP_MALLOC_MEMPOOL_END -#endif /* LWIP_MALLOC_MEMPOOL */ - -#ifndef LWIP_PBUF_MEMPOOL -/* This treats "pbuf pools" just like any other pool. - * Allocates buffers for a pbuf struct AND a payload size */ -#define LWIP_PBUF_MEMPOOL(name, num, payload, desc) LWIP_MEMPOOL(name, num, (LWIP_MEM_ALIGN_SIZE(sizeof(struct pbuf)) + LWIP_MEM_ALIGN_SIZE(payload)), desc) -#endif /* LWIP_PBUF_MEMPOOL */ - - -/* - * A list of internal pools used by LWIP. - * - * LWIP_MEMPOOL(pool_name, number_elements, element_size, pool_description) - * creates a pool name MEMP_pool_name. description is used in stats.c - */ -#if LWIP_RAW -LWIP_MEMPOOL(RAW_PCB, MEMP_NUM_RAW_PCB, sizeof(struct raw_pcb), "RAW_PCB") -#endif /* LWIP_RAW */ - -#if LWIP_UDP -LWIP_MEMPOOL(UDP_PCB, MEMP_NUM_UDP_PCB, sizeof(struct udp_pcb), "UDP_PCB") -#endif /* LWIP_UDP */ - -#if LWIP_TCP -LWIP_MEMPOOL(TCP_PCB, MEMP_NUM_TCP_PCB, sizeof(struct tcp_pcb), "TCP_PCB") -LWIP_MEMPOOL(TCP_PCB_LISTEN, MEMP_NUM_TCP_PCB_LISTEN, sizeof(struct tcp_pcb_listen), "TCP_PCB_LISTEN") -LWIP_MEMPOOL(TCP_SEG, MEMP_NUM_TCP_SEG, sizeof(struct tcp_seg), "TCP_SEG") -#endif /* LWIP_TCP */ - -#if LWIP_ALTCP && LWIP_TCP -LWIP_MEMPOOL(ALTCP_PCB, MEMP_NUM_ALTCP_PCB, sizeof(struct altcp_pcb), "ALTCP_PCB") -#endif /* LWIP_ALTCP && LWIP_TCP */ - -#if LWIP_IPV4 && IP_REASSEMBLY -LWIP_MEMPOOL(REASSDATA, MEMP_NUM_REASSDATA, sizeof(struct ip_reassdata), "REASSDATA") -#endif /* LWIP_IPV4 && IP_REASSEMBLY */ -#if (IP_FRAG && !LWIP_NETIF_TX_SINGLE_PBUF) || (LWIP_IPV6 && LWIP_IPV6_FRAG) -LWIP_MEMPOOL(FRAG_PBUF, MEMP_NUM_FRAG_PBUF, sizeof(struct pbuf_custom_ref),"FRAG_PBUF") -#endif /* IP_FRAG && !LWIP_NETIF_TX_SINGLE_PBUF || (LWIP_IPV6 && LWIP_IPV6_FRAG) */ - -#if LWIP_NETCONN || LWIP_SOCKET -LWIP_MEMPOOL(NETBUF, MEMP_NUM_NETBUF, sizeof(struct netbuf), "NETBUF") -LWIP_MEMPOOL(NETCONN, MEMP_NUM_NETCONN, sizeof(struct netconn), "NETCONN") -#endif /* LWIP_NETCONN || LWIP_SOCKET */ - -#if NO_SYS==0 -LWIP_MEMPOOL(TCPIP_MSG_API, MEMP_NUM_TCPIP_MSG_API, sizeof(struct tcpip_msg), "TCPIP_MSG_API") -#if LWIP_MPU_COMPATIBLE -LWIP_MEMPOOL(API_MSG, MEMP_NUM_API_MSG, sizeof(struct api_msg), "API_MSG") -#if LWIP_DNS -LWIP_MEMPOOL(DNS_API_MSG, MEMP_NUM_DNS_API_MSG, sizeof(struct dns_api_msg), "DNS_API_MSG") -#endif -#if LWIP_SOCKET && !LWIP_TCPIP_CORE_LOCKING -LWIP_MEMPOOL(SOCKET_SETGETSOCKOPT_DATA, MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA, sizeof(struct lwip_setgetsockopt_data), "SOCKET_SETGETSOCKOPT_DATA") -#endif -#if LWIP_SOCKET && (LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL) -LWIP_MEMPOOL(SELECT_CB, MEMP_NUM_SELECT_CB, sizeof(struct lwip_select_cb), "SELECT_CB") -#endif /* LWIP_SOCKET && (LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL) */ -#if LWIP_NETIF_API -LWIP_MEMPOOL(NETIFAPI_MSG, MEMP_NUM_NETIFAPI_MSG, sizeof(struct netifapi_msg), "NETIFAPI_MSG") -#endif -#endif /* LWIP_MPU_COMPATIBLE */ -#if !LWIP_TCPIP_CORE_LOCKING_INPUT -LWIP_MEMPOOL(TCPIP_MSG_INPKT,MEMP_NUM_TCPIP_MSG_INPKT, sizeof(struct tcpip_msg), "TCPIP_MSG_INPKT") -#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ -#endif /* NO_SYS==0 */ - -#if LWIP_IPV4 && LWIP_ARP && ARP_QUEUEING -LWIP_MEMPOOL(ARP_QUEUE, MEMP_NUM_ARP_QUEUE, sizeof(struct etharp_q_entry), "ARP_QUEUE") -#endif /* LWIP_IPV4 && LWIP_ARP && ARP_QUEUEING */ - -#if LWIP_IGMP -LWIP_MEMPOOL(IGMP_GROUP, MEMP_NUM_IGMP_GROUP, sizeof(struct igmp_group), "IGMP_GROUP") -#endif /* LWIP_IGMP */ - -#if LWIP_TIMERS && !LWIP_TIMERS_CUSTOM -LWIP_MEMPOOL(SYS_TIMEOUT, MEMP_NUM_SYS_TIMEOUT, sizeof(struct sys_timeo), "SYS_TIMEOUT") -#endif /* LWIP_TIMERS && !LWIP_TIMERS_CUSTOM */ - -#if LWIP_DNS && LWIP_SOCKET -LWIP_MEMPOOL(NETDB, MEMP_NUM_NETDB, NETDB_ELEM_SIZE, "NETDB") -#endif /* LWIP_DNS && LWIP_SOCKET */ -#if LWIP_DNS && DNS_LOCAL_HOSTLIST && DNS_LOCAL_HOSTLIST_IS_DYNAMIC -LWIP_MEMPOOL(LOCALHOSTLIST, MEMP_NUM_LOCALHOSTLIST, LOCALHOSTLIST_ELEM_SIZE, "LOCALHOSTLIST") -#endif /* LWIP_DNS && DNS_LOCAL_HOSTLIST && DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ - -#if LWIP_IPV6 && LWIP_ND6_QUEUEING -LWIP_MEMPOOL(ND6_QUEUE, MEMP_NUM_ND6_QUEUE, sizeof(struct nd6_q_entry), "ND6_QUEUE") -#endif /* LWIP_IPV6 && LWIP_ND6_QUEUEING */ - -#if LWIP_IPV6 && LWIP_IPV6_REASS -LWIP_MEMPOOL(IP6_REASSDATA, MEMP_NUM_REASSDATA, sizeof(struct ip6_reassdata), "IP6_REASSDATA") -#endif /* LWIP_IPV6 && LWIP_IPV6_REASS */ - -#if LWIP_IPV6 && LWIP_IPV6_MLD -LWIP_MEMPOOL(MLD6_GROUP, MEMP_NUM_MLD6_GROUP, sizeof(struct mld_group), "MLD6_GROUP") -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ - - -/* - * A list of pools of pbuf's used by LWIP. - * - * LWIP_PBUF_MEMPOOL(pool_name, number_elements, pbuf_payload_size, pool_description) - * creates a pool name MEMP_pool_name. description is used in stats.c - * This allocates enough space for the pbuf struct and a payload. - * (Example: pbuf_payload_size=0 allocates only size for the struct) - */ -LWIP_MEMPOOL(PBUF, MEMP_NUM_PBUF, sizeof(struct pbuf), "PBUF_REF/ROM") -LWIP_PBUF_MEMPOOL(PBUF_POOL, PBUF_POOL_SIZE, PBUF_POOL_BUFSIZE, "PBUF_POOL") - - -/* - * Allow for user-defined pools; this must be explicitly set in lwipopts.h - * since the default is to NOT look for lwippools.h - */ -#if MEMP_USE_CUSTOM_POOLS -#include "lwippools.h" -#endif /* MEMP_USE_CUSTOM_POOLS */ - -/* - * REQUIRED CLEANUP: Clear up so we don't get "multiply defined" error later - * (#undef is ignored for something that is not defined) - */ -#undef LWIP_MEMPOOL -#undef LWIP_MALLOC_MEMPOOL -#undef LWIP_MALLOC_MEMPOOL_START -#undef LWIP_MALLOC_MEMPOOL_END -#undef LWIP_PBUF_MEMPOOL +/** + * @file + * lwIP internal memory pools (do not use in application code) + * This file is deliberately included multiple times: once with empty + * definition of LWIP_MEMPOOL() to handle all includes and multiple times + * to build up various lists of mem pools. + */ + +/* + * SETUP: Make sure we define everything we will need. + * + * We have create three types of pools: + * 1) MEMPOOL - standard pools + * 2) MALLOC_MEMPOOL - to be used by mem_malloc in mem.c + * 3) PBUF_MEMPOOL - a mempool of pbuf's, so include space for the pbuf struct + * + * If the include'r doesn't require any special treatment of each of the types + * above, then will declare #2 & #3 to be just standard mempools. + */ +#ifndef LWIP_MALLOC_MEMPOOL +/* This treats "malloc pools" just like any other pool. + The pools are a little bigger to provide 'size' as the amount of user data. */ +#define LWIP_MALLOC_MEMPOOL(num, size) LWIP_MEMPOOL(POOL_##size, num, (size + LWIP_MEM_ALIGN_SIZE(sizeof(struct memp_malloc_helper))), "MALLOC_"#size) +#define LWIP_MALLOC_MEMPOOL_START +#define LWIP_MALLOC_MEMPOOL_END +#endif /* LWIP_MALLOC_MEMPOOL */ + +#ifndef LWIP_PBUF_MEMPOOL +/* This treats "pbuf pools" just like any other pool. + * Allocates buffers for a pbuf struct AND a payload size */ +#define LWIP_PBUF_MEMPOOL(name, num, payload, desc) LWIP_MEMPOOL(name, num, (LWIP_MEM_ALIGN_SIZE(sizeof(struct pbuf)) + LWIP_MEM_ALIGN_SIZE(payload)), desc) +#endif /* LWIP_PBUF_MEMPOOL */ + + +/* + * A list of internal pools used by LWIP. + * + * LWIP_MEMPOOL(pool_name, number_elements, element_size, pool_description) + * creates a pool name MEMP_pool_name. description is used in stats.c + */ +#if LWIP_RAW +LWIP_MEMPOOL(RAW_PCB, MEMP_NUM_RAW_PCB, sizeof(struct raw_pcb), "RAW_PCB") +#endif /* LWIP_RAW */ + +#if LWIP_UDP +LWIP_MEMPOOL(UDP_PCB, MEMP_NUM_UDP_PCB, sizeof(struct udp_pcb), "UDP_PCB") +#endif /* LWIP_UDP */ + +#if LWIP_TCP +LWIP_MEMPOOL(TCP_PCB, MEMP_NUM_TCP_PCB, sizeof(struct tcp_pcb), "TCP_PCB") +LWIP_MEMPOOL(TCP_PCB_LISTEN, MEMP_NUM_TCP_PCB_LISTEN, sizeof(struct tcp_pcb_listen), "TCP_PCB_LISTEN") +LWIP_MEMPOOL(TCP_SEG, MEMP_NUM_TCP_SEG, sizeof(struct tcp_seg), "TCP_SEG") +#endif /* LWIP_TCP */ + +#if LWIP_ALTCP && LWIP_TCP +LWIP_MEMPOOL(ALTCP_PCB, MEMP_NUM_ALTCP_PCB, sizeof(struct altcp_pcb), "ALTCP_PCB") +#endif /* LWIP_ALTCP && LWIP_TCP */ + +#if LWIP_IPV4 && IP_REASSEMBLY +LWIP_MEMPOOL(REASSDATA, MEMP_NUM_REASSDATA, sizeof(struct ip_reassdata), "REASSDATA") +#endif /* LWIP_IPV4 && IP_REASSEMBLY */ +#if (IP_FRAG && !LWIP_NETIF_TX_SINGLE_PBUF) || (LWIP_IPV6 && LWIP_IPV6_FRAG) +LWIP_MEMPOOL(FRAG_PBUF, MEMP_NUM_FRAG_PBUF, sizeof(struct pbuf_custom_ref),"FRAG_PBUF") +#endif /* IP_FRAG && !LWIP_NETIF_TX_SINGLE_PBUF || (LWIP_IPV6 && LWIP_IPV6_FRAG) */ + +#if LWIP_NETCONN || LWIP_SOCKET +LWIP_MEMPOOL(NETBUF, MEMP_NUM_NETBUF, sizeof(struct netbuf), "NETBUF") +LWIP_MEMPOOL(NETCONN, MEMP_NUM_NETCONN, sizeof(struct netconn), "NETCONN") +#endif /* LWIP_NETCONN || LWIP_SOCKET */ + +#if NO_SYS==0 +LWIP_MEMPOOL(TCPIP_MSG_API, MEMP_NUM_TCPIP_MSG_API, sizeof(struct tcpip_msg), "TCPIP_MSG_API") +#if LWIP_MPU_COMPATIBLE +LWIP_MEMPOOL(API_MSG, MEMP_NUM_API_MSG, sizeof(struct api_msg), "API_MSG") +#if LWIP_DNS +LWIP_MEMPOOL(DNS_API_MSG, MEMP_NUM_DNS_API_MSG, sizeof(struct dns_api_msg), "DNS_API_MSG") +#endif +#if LWIP_SOCKET && !LWIP_TCPIP_CORE_LOCKING +LWIP_MEMPOOL(SOCKET_SETGETSOCKOPT_DATA, MEMP_NUM_SOCKET_SETGETSOCKOPT_DATA, sizeof(struct lwip_setgetsockopt_data), "SOCKET_SETGETSOCKOPT_DATA") +#endif +#if LWIP_SOCKET && (LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL) +LWIP_MEMPOOL(SELECT_CB, MEMP_NUM_SELECT_CB, sizeof(struct lwip_select_cb), "SELECT_CB") +#endif /* LWIP_SOCKET && (LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL) */ +#if LWIP_NETIF_API +LWIP_MEMPOOL(NETIFAPI_MSG, MEMP_NUM_NETIFAPI_MSG, sizeof(struct netifapi_msg), "NETIFAPI_MSG") +#endif +#endif /* LWIP_MPU_COMPATIBLE */ +#if !LWIP_TCPIP_CORE_LOCKING_INPUT +LWIP_MEMPOOL(TCPIP_MSG_INPKT,MEMP_NUM_TCPIP_MSG_INPKT, sizeof(struct tcpip_msg), "TCPIP_MSG_INPKT") +#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ +#endif /* NO_SYS==0 */ + +#if LWIP_IPV4 && LWIP_ARP && ARP_QUEUEING +LWIP_MEMPOOL(ARP_QUEUE, MEMP_NUM_ARP_QUEUE, sizeof(struct etharp_q_entry), "ARP_QUEUE") +#endif /* LWIP_IPV4 && LWIP_ARP && ARP_QUEUEING */ + +#if LWIP_IGMP +LWIP_MEMPOOL(IGMP_GROUP, MEMP_NUM_IGMP_GROUP, sizeof(struct igmp_group), "IGMP_GROUP") +#endif /* LWIP_IGMP */ + +#if LWIP_TIMERS && !LWIP_TIMERS_CUSTOM +LWIP_MEMPOOL(SYS_TIMEOUT, MEMP_NUM_SYS_TIMEOUT, sizeof(struct sys_timeo), "SYS_TIMEOUT") +#endif /* LWIP_TIMERS && !LWIP_TIMERS_CUSTOM */ + +#if LWIP_DNS && LWIP_SOCKET +LWIP_MEMPOOL(NETDB, MEMP_NUM_NETDB, NETDB_ELEM_SIZE, "NETDB") +#endif /* LWIP_DNS && LWIP_SOCKET */ +#if LWIP_DNS && DNS_LOCAL_HOSTLIST && DNS_LOCAL_HOSTLIST_IS_DYNAMIC +LWIP_MEMPOOL(LOCALHOSTLIST, MEMP_NUM_LOCALHOSTLIST, LOCALHOSTLIST_ELEM_SIZE, "LOCALHOSTLIST") +#endif /* LWIP_DNS && DNS_LOCAL_HOSTLIST && DNS_LOCAL_HOSTLIST_IS_DYNAMIC */ + +#if LWIP_IPV6 && LWIP_ND6_QUEUEING +LWIP_MEMPOOL(ND6_QUEUE, MEMP_NUM_ND6_QUEUE, sizeof(struct nd6_q_entry), "ND6_QUEUE") +#endif /* LWIP_IPV6 && LWIP_ND6_QUEUEING */ + +#if LWIP_IPV6 && LWIP_IPV6_REASS +LWIP_MEMPOOL(IP6_REASSDATA, MEMP_NUM_REASSDATA, sizeof(struct ip6_reassdata), "IP6_REASSDATA") +#endif /* LWIP_IPV6 && LWIP_IPV6_REASS */ + +#if LWIP_IPV6 && LWIP_IPV6_MLD +LWIP_MEMPOOL(MLD6_GROUP, MEMP_NUM_MLD6_GROUP, sizeof(struct mld_group), "MLD6_GROUP") +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ + + +/* + * A list of pools of pbuf's used by LWIP. + * + * LWIP_PBUF_MEMPOOL(pool_name, number_elements, pbuf_payload_size, pool_description) + * creates a pool name MEMP_pool_name. description is used in stats.c + * This allocates enough space for the pbuf struct and a payload. + * (Example: pbuf_payload_size=0 allocates only size for the struct) + */ +LWIP_MEMPOOL(PBUF, MEMP_NUM_PBUF, sizeof(struct pbuf), "PBUF_REF/ROM") +LWIP_PBUF_MEMPOOL(PBUF_POOL, PBUF_POOL_SIZE, PBUF_POOL_BUFSIZE, "PBUF_POOL") + + +/* + * Allow for user-defined pools; this must be explicitly set in lwipopts.h + * since the default is to NOT look for lwippools.h + */ +#if MEMP_USE_CUSTOM_POOLS +#include "lwippools.h" +#endif /* MEMP_USE_CUSTOM_POOLS */ + +/* + * REQUIRED CLEANUP: Clear up so we don't get "multiply defined" error later + * (#undef is ignored for something that is not defined) + */ +#undef LWIP_MEMPOOL +#undef LWIP_MALLOC_MEMPOOL +#undef LWIP_MALLOC_MEMPOOL_START +#undef LWIP_MALLOC_MEMPOOL_END +#undef LWIP_PBUF_MEMPOOL diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/nd6_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/nd6_priv.h index 61c0b73b..cc3007d9 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/nd6_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/nd6_priv.h @@ -1,142 +1,142 @@ -/** - * @file - * - * Neighbor discovery and stateless address autoconfiguration for IPv6. - * Aims to be compliant with RFC 4861 (Neighbor discovery) and RFC 4862 - * (Address autoconfiguration). - */ - -/* - * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#ifndef LWIP_HDR_ND6_PRIV_H -#define LWIP_HDR_ND6_PRIV_H - -#include "lwip/opt.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" - - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_ND6_QUEUEING -/** struct for queueing outgoing packets for unknown address - * defined here to be accessed by memp.h - */ -struct nd6_q_entry { - struct nd6_q_entry *next; - struct pbuf *p; -}; -#endif /* LWIP_ND6_QUEUEING */ - -/** Struct for tables. */ -struct nd6_neighbor_cache_entry { - ip6_addr_t next_hop_address; - struct netif *netif; - u8_t lladdr[NETIF_MAX_HWADDR_LEN]; - /*u32_t pmtu;*/ -#if LWIP_ND6_QUEUEING - /** Pointer to queue of pending outgoing packets on this entry. */ - struct nd6_q_entry *q; -#else /* LWIP_ND6_QUEUEING */ - /** Pointer to a single pending outgoing packet on this entry. */ - struct pbuf *q; -#endif /* LWIP_ND6_QUEUEING */ - u8_t state; - u8_t isrouter; - union { - u32_t reachable_time; /* in seconds */ - u32_t delay_time; /* ticks (ND6_TMR_INTERVAL) */ - u32_t probes_sent; - u32_t stale_time; /* ticks (ND6_TMR_INTERVAL) */ - } counter; -}; - -struct nd6_destination_cache_entry { - ip6_addr_t destination_addr; - ip6_addr_t next_hop_addr; - u16_t pmtu; - u32_t age; -}; - -struct nd6_prefix_list_entry { - ip6_addr_t prefix; - struct netif *netif; - u32_t invalidation_timer; /* in seconds */ -}; - -struct nd6_router_list_entry { - struct nd6_neighbor_cache_entry *neighbor_entry; - u32_t invalidation_timer; /* in seconds */ - u8_t flags; -}; - -enum nd6_neighbor_cache_entry_state { - ND6_NO_ENTRY = 0, - ND6_INCOMPLETE, - ND6_REACHABLE, - ND6_STALE, - ND6_DELAY, - ND6_PROBE -}; - -#define ND6_HOPLIM 255 /* maximum hop limit, required in all ND packets */ - -#define ND6_2HRS 7200 /* two hours, expressed in number of seconds */ - -/* Router tables. */ -/* @todo make these static? and entries accessible through API? */ -extern struct nd6_neighbor_cache_entry neighbor_cache[]; -extern struct nd6_destination_cache_entry destination_cache[]; -extern struct nd6_prefix_list_entry prefix_list[]; -extern struct nd6_router_list_entry default_router_list[]; - -/* Default values, can be updated by a RA message. */ -extern u32_t reachable_time; -extern u32_t retrans_timer; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 */ - -#endif /* LWIP_HDR_ND6_PRIV_H */ +/** + * @file + * + * Neighbor discovery and stateless address autoconfiguration for IPv6. + * Aims to be compliant with RFC 4861 (Neighbor discovery) and RFC 4862 + * (Address autoconfiguration). + */ + +/* + * Copyright (c) 2010 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#ifndef LWIP_HDR_ND6_PRIV_H +#define LWIP_HDR_ND6_PRIV_H + +#include "lwip/opt.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" + + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_ND6_QUEUEING +/** struct for queueing outgoing packets for unknown address + * defined here to be accessed by memp.h + */ +struct nd6_q_entry { + struct nd6_q_entry *next; + struct pbuf *p; +}; +#endif /* LWIP_ND6_QUEUEING */ + +/** Struct for tables. */ +struct nd6_neighbor_cache_entry { + ip6_addr_t next_hop_address; + struct netif *netif; + u8_t lladdr[NETIF_MAX_HWADDR_LEN]; + /*u32_t pmtu;*/ +#if LWIP_ND6_QUEUEING + /** Pointer to queue of pending outgoing packets on this entry. */ + struct nd6_q_entry *q; +#else /* LWIP_ND6_QUEUEING */ + /** Pointer to a single pending outgoing packet on this entry. */ + struct pbuf *q; +#endif /* LWIP_ND6_QUEUEING */ + u8_t state; + u8_t isrouter; + union { + u32_t reachable_time; /* in seconds */ + u32_t delay_time; /* ticks (ND6_TMR_INTERVAL) */ + u32_t probes_sent; + u32_t stale_time; /* ticks (ND6_TMR_INTERVAL) */ + } counter; +}; + +struct nd6_destination_cache_entry { + ip6_addr_t destination_addr; + ip6_addr_t next_hop_addr; + u16_t pmtu; + u32_t age; +}; + +struct nd6_prefix_list_entry { + ip6_addr_t prefix; + struct netif *netif; + u32_t invalidation_timer; /* in seconds */ +}; + +struct nd6_router_list_entry { + struct nd6_neighbor_cache_entry *neighbor_entry; + u32_t invalidation_timer; /* in seconds */ + u8_t flags; +}; + +enum nd6_neighbor_cache_entry_state { + ND6_NO_ENTRY = 0, + ND6_INCOMPLETE, + ND6_REACHABLE, + ND6_STALE, + ND6_DELAY, + ND6_PROBE +}; + +#define ND6_HOPLIM 255 /* maximum hop limit, required in all ND packets */ + +#define ND6_2HRS 7200 /* two hours, expressed in number of seconds */ + +/* Router tables. */ +/* @todo make these static? and entries accessible through API? */ +extern struct nd6_neighbor_cache_entry neighbor_cache[]; +extern struct nd6_destination_cache_entry destination_cache[]; +extern struct nd6_prefix_list_entry prefix_list[]; +extern struct nd6_router_list_entry default_router_list[]; + +/* Default values, can be updated by a RA message. */ +extern u32_t reachable_time; +extern u32_t retrans_timer; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 */ + +#endif /* LWIP_HDR_ND6_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/raw_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/raw_priv.h index 08354221..d4561d4f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/raw_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/raw_priv.h @@ -1,69 +1,69 @@ -/** - * @file - * raw API internal implementations (do not use in application code) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_RAW_PRIV_H -#define LWIP_HDR_RAW_PRIV_H - -#include "lwip/opt.h" - -#if LWIP_RAW /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/raw.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** return codes for raw_input */ -typedef enum raw_input_state -{ - RAW_INPUT_NONE = 0, /* pbuf did not match any pcbs */ - RAW_INPUT_EATEN, /* pbuf handed off and delivered to pcb */ - RAW_INPUT_DELIVERED /* pbuf only delivered to pcb (pbuf can still be referenced) */ -} raw_input_state_t; - -/* The following functions are the lower layer interface to RAW. */ -raw_input_state_t raw_input(struct pbuf *p, struct netif *inp); - -void raw_netif_ip_addr_changed(const ip_addr_t* old_addr, const ip_addr_t* new_addr); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_RAW */ - -#endif /* LWIP_HDR_RAW_PRIV_H */ +/** + * @file + * raw API internal implementations (do not use in application code) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_RAW_PRIV_H +#define LWIP_HDR_RAW_PRIV_H + +#include "lwip/opt.h" + +#if LWIP_RAW /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/raw.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** return codes for raw_input */ +typedef enum raw_input_state +{ + RAW_INPUT_NONE = 0, /* pbuf did not match any pcbs */ + RAW_INPUT_EATEN, /* pbuf handed off and delivered to pcb */ + RAW_INPUT_DELIVERED /* pbuf only delivered to pcb (pbuf can still be referenced) */ +} raw_input_state_t; + +/* The following functions are the lower layer interface to RAW. */ +raw_input_state_t raw_input(struct pbuf *p, struct netif *inp); + +void raw_netif_ip_addr_changed(const ip_addr_t* old_addr, const ip_addr_t* new_addr); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_RAW */ + +#endif /* LWIP_HDR_RAW_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/sockets_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/sockets_priv.h index e481cd1c..d8f9904d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/sockets_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/sockets_priv.h @@ -1,175 +1,175 @@ -/** - * @file - * Sockets API internal implementations (do not use in application code) - */ - -/* - * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Joel Cunningham - * - */ -#ifndef LWIP_HDR_SOCKETS_PRIV_H -#define LWIP_HDR_SOCKETS_PRIV_H - -#include "lwip/opt.h" - -#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/err.h" -#include "lwip/sockets.h" -#include "lwip/sys.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define NUM_SOCKETS MEMP_NUM_NETCONN - -/** This is overridable for the rare case where more than 255 threads - * select on the same socket... - */ -#ifndef SELWAIT_T -#define SELWAIT_T u8_t -#endif - -union lwip_sock_lastdata { - struct netbuf *netbuf; - struct pbuf *pbuf; -}; - -/** Contains all internal pointers and states used for a socket */ -struct lwip_sock { - /** sockets currently are built on netconns, each socket has one netconn */ - struct netconn *conn; - /** data that was left from the previous read */ - union lwip_sock_lastdata lastdata; -#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL - /** number of times data was received, set by event_callback(), - tested by the receive and select functions */ - s16_t rcvevent; - /** number of times data was ACKed (free send buffer), set by event_callback(), - tested by select */ - u16_t sendevent; - /** error happened for this socket, set by event_callback(), tested by select */ - u16_t errevent; - /** counter of how many threads are waiting for this socket using select */ - SELWAIT_T select_waiting; -#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ -#if LWIP_NETCONN_FULLDUPLEX - /* counter of how many threads are using a struct lwip_sock (not the 'int') */ - u8_t fd_used; - /* status of pending close/delete actions */ - u8_t fd_free_pending; -#define LWIP_SOCK_FD_FREE_TCP 1 -#define LWIP_SOCK_FD_FREE_FREE 2 -#endif -}; - -#ifndef set_errno -#define set_errno(err) do { if (err) { errno = (err); } } while(0) -#endif - -#if !LWIP_TCPIP_CORE_LOCKING -/** Maximum optlen used by setsockopt/getsockopt */ -#define LWIP_SETGETSOCKOPT_MAXOPTLEN LWIP_MAX(16, sizeof(struct ifreq)) - -/** This struct is used to pass data to the set/getsockopt_internal - * functions running in tcpip_thread context (only a void* is allowed) */ -struct lwip_setgetsockopt_data { - /** socket index for which to change options */ - int s; - /** level of the option to process */ - int level; - /** name of the option to process */ - int optname; - /** set: value to set the option to - * get: value of the option is stored here */ -#if LWIP_MPU_COMPATIBLE - u8_t optval[LWIP_SETGETSOCKOPT_MAXOPTLEN]; -#else - union { - void *p; - const void *pc; - } optval; -#endif - /** size of *optval */ - socklen_t optlen; - /** if an error occurs, it is temporarily stored here */ - int err; - /** semaphore to wake up the calling task */ - void* completed_sem; -}; -#endif /* !LWIP_TCPIP_CORE_LOCKING */ - -#ifdef __cplusplus -} -#endif - -struct lwip_sock* lwip_socket_dbg_get_socket(int fd); - -#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL - -#if LWIP_NETCONN_SEM_PER_THREAD -#define SELECT_SEM_T sys_sem_t* -#define SELECT_SEM_PTR(sem) (sem) -#else /* LWIP_NETCONN_SEM_PER_THREAD */ -#define SELECT_SEM_T sys_sem_t -#define SELECT_SEM_PTR(sem) (&(sem)) -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ - -/** Description for a task waiting in select */ -struct lwip_select_cb { - /** Pointer to the next waiting task */ - struct lwip_select_cb *next; - /** Pointer to the previous waiting task */ - struct lwip_select_cb *prev; -#if LWIP_SOCKET_SELECT - /** readset passed to select */ - fd_set *readset; - /** writeset passed to select */ - fd_set *writeset; - /** unimplemented: exceptset passed to select */ - fd_set *exceptset; -#endif /* LWIP_SOCKET_SELECT */ -#if LWIP_SOCKET_POLL - /** fds passed to poll; NULL if select */ - struct pollfd *poll_fds; - /** nfds passed to poll; 0 if select */ - nfds_t poll_nfds; -#endif /* LWIP_SOCKET_POLL */ - /** don't signal the same semaphore twice: set to 1 when signalled */ - int sem_signalled; - /** semaphore to wake up a task waiting for select */ - SELECT_SEM_T sem; -}; -#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ - -#endif /* LWIP_SOCKET */ - -#endif /* LWIP_HDR_SOCKETS_PRIV_H */ +/** + * @file + * Sockets API internal implementations (do not use in application code) + */ + +/* + * Copyright (c) 2017 Joel Cunningham, Garmin International, Inc. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Joel Cunningham + * + */ +#ifndef LWIP_HDR_SOCKETS_PRIV_H +#define LWIP_HDR_SOCKETS_PRIV_H + +#include "lwip/opt.h" + +#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/err.h" +#include "lwip/sockets.h" +#include "lwip/sys.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define NUM_SOCKETS MEMP_NUM_NETCONN + +/** This is overridable for the rare case where more than 255 threads + * select on the same socket... + */ +#ifndef SELWAIT_T +#define SELWAIT_T u8_t +#endif + +union lwip_sock_lastdata { + struct netbuf *netbuf; + struct pbuf *pbuf; +}; + +/** Contains all internal pointers and states used for a socket */ +struct lwip_sock { + /** sockets currently are built on netconns, each socket has one netconn */ + struct netconn *conn; + /** data that was left from the previous read */ + union lwip_sock_lastdata lastdata; +#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL + /** number of times data was received, set by event_callback(), + tested by the receive and select functions */ + s16_t rcvevent; + /** number of times data was ACKed (free send buffer), set by event_callback(), + tested by select */ + u16_t sendevent; + /** error happened for this socket, set by event_callback(), tested by select */ + u16_t errevent; + /** counter of how many threads are waiting for this socket using select */ + SELWAIT_T select_waiting; +#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ +#if LWIP_NETCONN_FULLDUPLEX + /* counter of how many threads are using a struct lwip_sock (not the 'int') */ + u8_t fd_used; + /* status of pending close/delete actions */ + u8_t fd_free_pending; +#define LWIP_SOCK_FD_FREE_TCP 1 +#define LWIP_SOCK_FD_FREE_FREE 2 +#endif +}; + +#ifndef set_errno +#define set_errno(err) do { if (err) { errno = (err); } } while(0) +#endif + +#if !LWIP_TCPIP_CORE_LOCKING +/** Maximum optlen used by setsockopt/getsockopt */ +#define LWIP_SETGETSOCKOPT_MAXOPTLEN LWIP_MAX(16, sizeof(struct ifreq)) + +/** This struct is used to pass data to the set/getsockopt_internal + * functions running in tcpip_thread context (only a void* is allowed) */ +struct lwip_setgetsockopt_data { + /** socket index for which to change options */ + int s; + /** level of the option to process */ + int level; + /** name of the option to process */ + int optname; + /** set: value to set the option to + * get: value of the option is stored here */ +#if LWIP_MPU_COMPATIBLE + u8_t optval[LWIP_SETGETSOCKOPT_MAXOPTLEN]; +#else + union { + void *p; + const void *pc; + } optval; +#endif + /** size of *optval */ + socklen_t optlen; + /** if an error occurs, it is temporarily stored here */ + int err; + /** semaphore to wake up the calling task */ + void* completed_sem; +}; +#endif /* !LWIP_TCPIP_CORE_LOCKING */ + +#ifdef __cplusplus +} +#endif + +struct lwip_sock* lwip_socket_dbg_get_socket(int fd); + +#if LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL + +#if LWIP_NETCONN_SEM_PER_THREAD +#define SELECT_SEM_T sys_sem_t* +#define SELECT_SEM_PTR(sem) (sem) +#else /* LWIP_NETCONN_SEM_PER_THREAD */ +#define SELECT_SEM_T sys_sem_t +#define SELECT_SEM_PTR(sem) (&(sem)) +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ + +/** Description for a task waiting in select */ +struct lwip_select_cb { + /** Pointer to the next waiting task */ + struct lwip_select_cb *next; + /** Pointer to the previous waiting task */ + struct lwip_select_cb *prev; +#if LWIP_SOCKET_SELECT + /** readset passed to select */ + fd_set *readset; + /** writeset passed to select */ + fd_set *writeset; + /** unimplemented: exceptset passed to select */ + fd_set *exceptset; +#endif /* LWIP_SOCKET_SELECT */ +#if LWIP_SOCKET_POLL + /** fds passed to poll; NULL if select */ + struct pollfd *poll_fds; + /** nfds passed to poll; 0 if select */ + nfds_t poll_nfds; +#endif /* LWIP_SOCKET_POLL */ + /** don't signal the same semaphore twice: set to 1 when signalled */ + int sem_signalled; + /** semaphore to wake up a task waiting for select */ + SELECT_SEM_T sem; +}; +#endif /* LWIP_SOCKET_SELECT || LWIP_SOCKET_POLL */ + +#endif /* LWIP_SOCKET */ + +#endif /* LWIP_HDR_SOCKETS_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcp_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcp_priv.h index 96e07e33..72f9126d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcp_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcp_priv.h @@ -1,523 +1,523 @@ -/** - * @file - * TCP internal implementations (do not use in application code) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_TCP_PRIV_H -#define LWIP_HDR_TCP_PRIV_H - -#include "lwip/opt.h" - -#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/tcp.h" -#include "lwip/mem.h" -#include "lwip/pbuf.h" -#include "lwip/ip.h" -#include "lwip/icmp.h" -#include "lwip/err.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" -#include "lwip/prot/tcp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* Functions for interfacing with TCP: */ - -/* Lower layer interface to TCP: */ -void tcp_init (void); /* Initialize this module. */ -void tcp_tmr (void); /* Must be called every - TCP_TMR_INTERVAL - ms. (Typically 250 ms). */ -/* It is also possible to call these two functions at the right - intervals (instead of calling tcp_tmr()). */ -void tcp_slowtmr (void); -void tcp_fasttmr (void); - -/* Call this from a netif driver (watch out for threading issues!) that has - returned a memory error on transmit and now has free buffers to send more. - This iterates all active pcbs that had an error and tries to call - tcp_output, so use this with care as it might slow down the system. */ -void tcp_txnow (void); - -/* Only used by IP to pass a TCP segment to TCP: */ -void tcp_input (struct pbuf *p, struct netif *inp); -/* Used within the TCP code only: */ -struct tcp_pcb * tcp_alloc (u8_t prio); -void tcp_free (struct tcp_pcb *pcb); -void tcp_abandon (struct tcp_pcb *pcb, int reset); -err_t tcp_send_empty_ack(struct tcp_pcb *pcb); -err_t tcp_rexmit (struct tcp_pcb *pcb); -err_t tcp_rexmit_rto_prepare(struct tcp_pcb *pcb); -void tcp_rexmit_rto_commit(struct tcp_pcb *pcb); -void tcp_rexmit_rto (struct tcp_pcb *pcb); -void tcp_rexmit_fast (struct tcp_pcb *pcb); -u32_t tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb); -err_t tcp_process_refused_data(struct tcp_pcb *pcb); - -/** - * This is the Nagle algorithm: try to combine user data to send as few TCP - * segments as possible. Only send if - * - no previously transmitted data on the connection remains unacknowledged or - * - the TF_NODELAY flag is set (nagle algorithm turned off for this pcb) or - * - the only unsent segment is at least pcb->mss bytes long (or there is more - * than one unsent segment - with lwIP, this can happen although unsent->len < mss) - * - or if we are in fast-retransmit (TF_INFR) - */ -#define tcp_do_output_nagle(tpcb) ((((tpcb)->unacked == NULL) || \ - ((tpcb)->flags & (TF_NODELAY | TF_INFR)) || \ - (((tpcb)->unsent != NULL) && (((tpcb)->unsent->next != NULL) || \ - ((tpcb)->unsent->len >= (tpcb)->mss))) || \ - ((tcp_sndbuf(tpcb) == 0) || (tcp_sndqueuelen(tpcb) >= TCP_SND_QUEUELEN)) \ - ) ? 1 : 0) -#define tcp_output_nagle(tpcb) (tcp_do_output_nagle(tpcb) ? tcp_output(tpcb) : ERR_OK) - - -#define TCP_SEQ_LT(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) < 0) -#define TCP_SEQ_LEQ(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) <= 0) -#define TCP_SEQ_GT(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) > 0) -#define TCP_SEQ_GEQ(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) >= 0) -/* is b<=a<=c? */ -#if 0 /* see bug #10548 */ -#define TCP_SEQ_BETWEEN(a,b,c) ((c)-(b) >= (a)-(b)) -#endif -#define TCP_SEQ_BETWEEN(a,b,c) (TCP_SEQ_GEQ(a,b) && TCP_SEQ_LEQ(a,c)) - -#ifndef TCP_TMR_INTERVAL -#define TCP_TMR_INTERVAL 250 /* The TCP timer interval in milliseconds. */ -#endif /* TCP_TMR_INTERVAL */ - -#ifndef TCP_FAST_INTERVAL -#define TCP_FAST_INTERVAL TCP_TMR_INTERVAL /* the fine grained timeout in milliseconds */ -#endif /* TCP_FAST_INTERVAL */ - -#ifndef TCP_SLOW_INTERVAL -#define TCP_SLOW_INTERVAL (2*TCP_TMR_INTERVAL) /* the coarse grained timeout in milliseconds */ -#endif /* TCP_SLOW_INTERVAL */ - -#define TCP_FIN_WAIT_TIMEOUT 20000 /* milliseconds */ -#define TCP_SYN_RCVD_TIMEOUT 20000 /* milliseconds */ - -#define TCP_OOSEQ_TIMEOUT 6U /* x RTO */ - -#ifndef TCP_MSL -#define TCP_MSL 60000UL /* The maximum segment lifetime in milliseconds */ -#endif - -/* Keepalive values, compliant with RFC 1122. Don't change this unless you know what you're doing */ -#ifndef TCP_KEEPIDLE_DEFAULT -#define TCP_KEEPIDLE_DEFAULT 7200000UL /* Default KEEPALIVE timer in milliseconds */ -#endif - -#ifndef TCP_KEEPINTVL_DEFAULT -#define TCP_KEEPINTVL_DEFAULT 75000UL /* Default Time between KEEPALIVE probes in milliseconds */ -#endif - -#ifndef TCP_KEEPCNT_DEFAULT -#define TCP_KEEPCNT_DEFAULT 9U /* Default Counter for KEEPALIVE probes */ -#endif - -#define TCP_MAXIDLE TCP_KEEPCNT_DEFAULT * TCP_KEEPINTVL_DEFAULT /* Maximum KEEPALIVE probe time */ - -#define TCP_TCPLEN(seg) ((seg)->len + (((TCPH_FLAGS((seg)->tcphdr) & (TCP_FIN | TCP_SYN)) != 0) ? 1U : 0U)) - -/** Flags used on input processing, not on pcb->flags -*/ -#define TF_RESET (u8_t)0x08U /* Connection was reset. */ -#define TF_CLOSED (u8_t)0x10U /* Connection was successfully closed. */ -#define TF_GOT_FIN (u8_t)0x20U /* Connection was closed by the remote end. */ - - -#if LWIP_EVENT_API - -#define TCP_EVENT_ACCEPT(lpcb,pcb,arg,err,ret) ret = lwip_tcp_event(arg, (pcb),\ - LWIP_EVENT_ACCEPT, NULL, 0, err) -#define TCP_EVENT_SENT(pcb,space,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ - LWIP_EVENT_SENT, NULL, space, ERR_OK) -#define TCP_EVENT_RECV(pcb,p,err,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ - LWIP_EVENT_RECV, (p), 0, (err)) -#define TCP_EVENT_CLOSED(pcb,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ - LWIP_EVENT_RECV, NULL, 0, ERR_OK) -#define TCP_EVENT_CONNECTED(pcb,err,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ - LWIP_EVENT_CONNECTED, NULL, 0, (err)) -#define TCP_EVENT_POLL(pcb,ret) do { if ((pcb)->state != SYN_RCVD) { \ - ret = lwip_tcp_event((pcb)->callback_arg, (pcb), LWIP_EVENT_POLL, NULL, 0, ERR_OK); \ - } else { \ - ret = ERR_ARG; } } while(0) -/* For event API, last state SYN_RCVD must be excluded here: the application - has not seen this pcb, yet! */ -#define TCP_EVENT_ERR(last_state,errf,arg,err) do { if (last_state != SYN_RCVD) { \ - lwip_tcp_event((arg), NULL, LWIP_EVENT_ERR, NULL, 0, (err)); } } while(0) - -#else /* LWIP_EVENT_API */ - -#define TCP_EVENT_ACCEPT(lpcb,pcb,arg,err,ret) \ - do { \ - if((lpcb)->accept != NULL) \ - (ret) = (lpcb)->accept((arg),(pcb),(err)); \ - else (ret) = ERR_ARG; \ - } while (0) - -#define TCP_EVENT_SENT(pcb,space,ret) \ - do { \ - if((pcb)->sent != NULL) \ - (ret) = (pcb)->sent((pcb)->callback_arg,(pcb),(space)); \ - else (ret) = ERR_OK; \ - } while (0) - -#define TCP_EVENT_RECV(pcb,p,err,ret) \ - do { \ - if((pcb)->recv != NULL) { \ - (ret) = (pcb)->recv((pcb)->callback_arg,(pcb),(p),(err));\ - } else { \ - (ret) = tcp_recv_null(NULL, (pcb), (p), (err)); \ - } \ - } while (0) - -#define TCP_EVENT_CLOSED(pcb,ret) \ - do { \ - if(((pcb)->recv != NULL)) { \ - (ret) = (pcb)->recv((pcb)->callback_arg,(pcb),NULL,ERR_OK);\ - } else { \ - (ret) = ERR_OK; \ - } \ - } while (0) - -#define TCP_EVENT_CONNECTED(pcb,err,ret) \ - do { \ - if((pcb)->connected != NULL) \ - (ret) = (pcb)->connected((pcb)->callback_arg,(pcb),(err)); \ - else (ret) = ERR_OK; \ - } while (0) - -#define TCP_EVENT_POLL(pcb,ret) \ - do { \ - if((pcb)->poll != NULL) \ - (ret) = (pcb)->poll((pcb)->callback_arg,(pcb)); \ - else (ret) = ERR_OK; \ - } while (0) - -#define TCP_EVENT_ERR(last_state,errf,arg,err) \ - do { \ - LWIP_UNUSED_ARG(last_state); \ - if((errf) != NULL) \ - (errf)((arg),(err)); \ - } while (0) - -#endif /* LWIP_EVENT_API */ - -/** Enabled extra-check for TCP_OVERSIZE if LWIP_DEBUG is enabled */ -#if TCP_OVERSIZE && defined(LWIP_DEBUG) -#define TCP_OVERSIZE_DBGCHECK 1 -#else -#define TCP_OVERSIZE_DBGCHECK 0 -#endif - -/** Don't generate checksum on copy if CHECKSUM_GEN_TCP is disabled */ -#define TCP_CHECKSUM_ON_COPY (LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_TCP) - -/* This structure represents a TCP segment on the unsent, unacked and ooseq queues */ -struct tcp_seg { - struct tcp_seg *next; /* used when putting segments on a queue */ - struct pbuf *p; /* buffer containing data + TCP header */ - u16_t len; /* the TCP length of this segment */ -#if TCP_OVERSIZE_DBGCHECK - u16_t oversize_left; /* Extra bytes available at the end of the last - pbuf in unsent (used for asserting vs. - tcp_pcb.unsent_oversize only) */ -#endif /* TCP_OVERSIZE_DBGCHECK */ -#if TCP_CHECKSUM_ON_COPY - u16_t chksum; - u8_t chksum_swapped; -#endif /* TCP_CHECKSUM_ON_COPY */ - u8_t flags; -#define TF_SEG_OPTS_MSS (u8_t)0x01U /* Include MSS option (only used in SYN segments) */ -#define TF_SEG_OPTS_TS (u8_t)0x02U /* Include timestamp option. */ -#define TF_SEG_DATA_CHECKSUMMED (u8_t)0x04U /* ALL data (not the header) is - checksummed into 'chksum' */ -#define TF_SEG_OPTS_WND_SCALE (u8_t)0x08U /* Include WND SCALE option (only used in SYN segments) */ -#define TF_SEG_OPTS_SACK_PERM (u8_t)0x10U /* Include SACK Permitted option (only used in SYN segments) */ - struct tcp_hdr *tcphdr; /* the TCP header */ -}; - -#define LWIP_TCP_OPT_EOL 0 -#define LWIP_TCP_OPT_NOP 1 -#define LWIP_TCP_OPT_MSS 2 -#define LWIP_TCP_OPT_WS 3 -#define LWIP_TCP_OPT_SACK_PERM 4 -#define LWIP_TCP_OPT_TS 8 - -#define LWIP_TCP_OPT_LEN_MSS 4 -#if LWIP_TCP_TIMESTAMPS -#define LWIP_TCP_OPT_LEN_TS 10 -#define LWIP_TCP_OPT_LEN_TS_OUT 12 /* aligned for output (includes NOP padding) */ -#else -#define LWIP_TCP_OPT_LEN_TS_OUT 0 -#endif -#if LWIP_WND_SCALE -#define LWIP_TCP_OPT_LEN_WS 3 -#define LWIP_TCP_OPT_LEN_WS_OUT 4 /* aligned for output (includes NOP padding) */ -#else -#define LWIP_TCP_OPT_LEN_WS_OUT 0 -#endif - -#if LWIP_TCP_SACK_OUT -#define LWIP_TCP_OPT_LEN_SACK_PERM 2 -#define LWIP_TCP_OPT_LEN_SACK_PERM_OUT 4 /* aligned for output (includes NOP padding) */ -#else -#define LWIP_TCP_OPT_LEN_SACK_PERM_OUT 0 -#endif - -#define LWIP_TCP_OPT_LENGTH(flags) \ - ((flags) & TF_SEG_OPTS_MSS ? LWIP_TCP_OPT_LEN_MSS : 0) + \ - ((flags) & TF_SEG_OPTS_TS ? LWIP_TCP_OPT_LEN_TS_OUT : 0) + \ - ((flags) & TF_SEG_OPTS_WND_SCALE ? LWIP_TCP_OPT_LEN_WS_OUT : 0) + \ - ((flags) & TF_SEG_OPTS_SACK_PERM ? LWIP_TCP_OPT_LEN_SACK_PERM_OUT : 0) - -/** This returns a TCP header option for MSS in an u32_t */ -#define TCP_BUILD_MSS_OPTION(mss) lwip_htonl(0x02040000 | ((mss) & 0xFFFF)) - -#if LWIP_WND_SCALE -#define TCPWNDSIZE_F U32_F -#define TCPWND_MAX 0xFFFFFFFFU -#define TCPWND_CHECK16(x) LWIP_ASSERT("window size > 0xFFFF", (x) <= 0xFFFF) -#define TCPWND_MIN16(x) ((u16_t)LWIP_MIN((x), 0xFFFF)) -#else /* LWIP_WND_SCALE */ -#define TCPWNDSIZE_F U16_F -#define TCPWND_MAX 0xFFFFU -#define TCPWND_CHECK16(x) -#define TCPWND_MIN16(x) x -#endif /* LWIP_WND_SCALE */ - -/* Global variables: */ -extern struct tcp_pcb *tcp_input_pcb; -extern u32_t tcp_ticks; -extern u8_t tcp_active_pcbs_changed; - -/* The TCP PCB lists. */ -union tcp_listen_pcbs_t { /* List of all TCP PCBs in LISTEN state. */ - struct tcp_pcb_listen *listen_pcbs; - struct tcp_pcb *pcbs; -}; -extern struct tcp_pcb *tcp_bound_pcbs; -extern union tcp_listen_pcbs_t tcp_listen_pcbs; -extern struct tcp_pcb *tcp_active_pcbs; /* List of all TCP PCBs that are in a - state in which they accept or send - data. */ -extern struct tcp_pcb *tcp_tw_pcbs; /* List of all TCP PCBs in TIME-WAIT. */ - -#define NUM_TCP_PCB_LISTS_NO_TIME_WAIT 3 -#define NUM_TCP_PCB_LISTS 4 -extern struct tcp_pcb ** const tcp_pcb_lists[NUM_TCP_PCB_LISTS]; - -/* Axioms about the above lists: - 1) Every TCP PCB that is not CLOSED is in one of the lists. - 2) A PCB is only in one of the lists. - 3) All PCBs in the tcp_listen_pcbs list is in LISTEN state. - 4) All PCBs in the tcp_tw_pcbs list is in TIME-WAIT state. -*/ -/* Define two macros, TCP_REG and TCP_RMV that registers a TCP PCB - with a PCB list or removes a PCB from a list, respectively. */ -#ifndef TCP_DEBUG_PCB_LISTS -#define TCP_DEBUG_PCB_LISTS 0 -#endif -#if TCP_DEBUG_PCB_LISTS -#define TCP_REG(pcbs, npcb) do {\ - struct tcp_pcb *tcp_tmp_pcb; \ - LWIP_DEBUGF(TCP_DEBUG, ("TCP_REG %p local port %"U16_F"\n", (void *)(npcb), (npcb)->local_port)); \ - for (tcp_tmp_pcb = *(pcbs); \ - tcp_tmp_pcb != NULL; \ - tcp_tmp_pcb = tcp_tmp_pcb->next) { \ - LWIP_ASSERT("TCP_REG: already registered\n", tcp_tmp_pcb != (npcb)); \ - } \ - LWIP_ASSERT("TCP_REG: pcb->state != CLOSED", ((pcbs) == &tcp_bound_pcbs) || ((npcb)->state != CLOSED)); \ - (npcb)->next = *(pcbs); \ - LWIP_ASSERT("TCP_REG: npcb->next != npcb", (npcb)->next != (npcb)); \ - *(pcbs) = (npcb); \ - LWIP_ASSERT("TCP_REG: tcp_pcbs sane", tcp_pcbs_sane()); \ - tcp_timer_needed(); \ - } while(0) -#define TCP_RMV(pcbs, npcb) do { \ - struct tcp_pcb *tcp_tmp_pcb; \ - LWIP_ASSERT("TCP_RMV: pcbs != NULL", *(pcbs) != NULL); \ - LWIP_DEBUGF(TCP_DEBUG, ("TCP_RMV: removing %p from %p\n", (void *)(npcb), (void *)(*(pcbs)))); \ - if(*(pcbs) == (npcb)) { \ - *(pcbs) = (*pcbs)->next; \ - } else for (tcp_tmp_pcb = *(pcbs); tcp_tmp_pcb != NULL; tcp_tmp_pcb = tcp_tmp_pcb->next) { \ - if(tcp_tmp_pcb->next == (npcb)) { \ - tcp_tmp_pcb->next = (npcb)->next; \ - break; \ - } \ - } \ - (npcb)->next = NULL; \ - LWIP_ASSERT("TCP_RMV: tcp_pcbs sane", tcp_pcbs_sane()); \ - LWIP_DEBUGF(TCP_DEBUG, ("TCP_RMV: removed %p from %p\n", (void *)(npcb), (void *)(*(pcbs)))); \ - } while(0) - -#else /* LWIP_DEBUG */ - -#define TCP_REG(pcbs, npcb) \ - do { \ - (npcb)->next = *pcbs; \ - *(pcbs) = (npcb); \ - tcp_timer_needed(); \ - } while (0) - -#define TCP_RMV(pcbs, npcb) \ - do { \ - if(*(pcbs) == (npcb)) { \ - (*(pcbs)) = (*pcbs)->next; \ - } \ - else { \ - struct tcp_pcb *tcp_tmp_pcb; \ - for (tcp_tmp_pcb = *pcbs; \ - tcp_tmp_pcb != NULL; \ - tcp_tmp_pcb = tcp_tmp_pcb->next) { \ - if(tcp_tmp_pcb->next == (npcb)) { \ - tcp_tmp_pcb->next = (npcb)->next; \ - break; \ - } \ - } \ - } \ - (npcb)->next = NULL; \ - } while(0) - -#endif /* LWIP_DEBUG */ - -#define TCP_REG_ACTIVE(npcb) \ - do { \ - TCP_REG(&tcp_active_pcbs, npcb); \ - tcp_active_pcbs_changed = 1; \ - } while (0) - -#define TCP_RMV_ACTIVE(npcb) \ - do { \ - TCP_RMV(&tcp_active_pcbs, npcb); \ - tcp_active_pcbs_changed = 1; \ - } while (0) - -#define TCP_PCB_REMOVE_ACTIVE(pcb) \ - do { \ - tcp_pcb_remove(&tcp_active_pcbs, pcb); \ - tcp_active_pcbs_changed = 1; \ - } while (0) - - -/* Internal functions: */ -struct tcp_pcb *tcp_pcb_copy(struct tcp_pcb *pcb); -void tcp_pcb_purge(struct tcp_pcb *pcb); -void tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb); - -void tcp_segs_free(struct tcp_seg *seg); -void tcp_seg_free(struct tcp_seg *seg); -struct tcp_seg *tcp_seg_copy(struct tcp_seg *seg); - -#define tcp_ack(pcb) \ - do { \ - if((pcb)->flags & TF_ACK_DELAY) { \ - tcp_clear_flags(pcb, TF_ACK_DELAY); \ - tcp_ack_now(pcb); \ - } \ - else { \ - tcp_set_flags(pcb, TF_ACK_DELAY); \ - } \ - } while (0) - -#define tcp_ack_now(pcb) \ - tcp_set_flags(pcb, TF_ACK_NOW) - -err_t tcp_send_fin(struct tcp_pcb *pcb); -err_t tcp_enqueue_flags(struct tcp_pcb *pcb, u8_t flags); - -void tcp_rexmit_seg(struct tcp_pcb *pcb, struct tcp_seg *seg); - -void tcp_rst(const struct tcp_pcb* pcb, u32_t seqno, u32_t ackno, - const ip_addr_t *local_ip, const ip_addr_t *remote_ip, - u16_t local_port, u16_t remote_port); - -u32_t tcp_next_iss(struct tcp_pcb *pcb); - -err_t tcp_keepalive(struct tcp_pcb *pcb); -err_t tcp_split_unsent_seg(struct tcp_pcb *pcb, u16_t split); -err_t tcp_zero_window_probe(struct tcp_pcb *pcb); -void tcp_trigger_input_pcb_close(void); - -#if TCP_CALCULATE_EFF_SEND_MSS -u16_t tcp_eff_send_mss_netif(u16_t sendmss, struct netif *outif, - const ip_addr_t *dest); -#define tcp_eff_send_mss(sendmss, src, dest) \ - tcp_eff_send_mss_netif(sendmss, ip_route(src, dest), dest) -#endif /* TCP_CALCULATE_EFF_SEND_MSS */ - -#if LWIP_CALLBACK_API -err_t tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err); -#endif /* LWIP_CALLBACK_API */ - -#if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG -void tcp_debug_print(struct tcp_hdr *tcphdr); -void tcp_debug_print_flags(u8_t flags); -void tcp_debug_print_state(enum tcp_state s); -void tcp_debug_print_pcbs(void); -s16_t tcp_pcbs_sane(void); -#else -# define tcp_debug_print(tcphdr) -# define tcp_debug_print_flags(flags) -# define tcp_debug_print_state(s) -# define tcp_debug_print_pcbs() -# define tcp_pcbs_sane() 1 -#endif /* TCP_DEBUG */ - -/** External function (implemented in timers.c), called when TCP detects - * that a timer is needed (i.e. active- or time-wait-pcb found). */ -void tcp_timer_needed(void); - -void tcp_netif_ip_addr_changed(const ip_addr_t* old_addr, const ip_addr_t* new_addr); - -#if TCP_QUEUE_OOSEQ -void tcp_free_ooseq(struct tcp_pcb *pcb); -#endif - -#if LWIP_TCP_PCB_NUM_EXT_ARGS -err_t tcp_ext_arg_invoke_callbacks_passive_open(struct tcp_pcb_listen *lpcb, struct tcp_pcb *cpcb); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_TCP */ - -#endif /* LWIP_HDR_TCP_PRIV_H */ +/** + * @file + * TCP internal implementations (do not use in application code) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_TCP_PRIV_H +#define LWIP_HDR_TCP_PRIV_H + +#include "lwip/opt.h" + +#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/tcp.h" +#include "lwip/mem.h" +#include "lwip/pbuf.h" +#include "lwip/ip.h" +#include "lwip/icmp.h" +#include "lwip/err.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" +#include "lwip/prot/tcp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Functions for interfacing with TCP: */ + +/* Lower layer interface to TCP: */ +void tcp_init (void); /* Initialize this module. */ +void tcp_tmr (void); /* Must be called every + TCP_TMR_INTERVAL + ms. (Typically 250 ms). */ +/* It is also possible to call these two functions at the right + intervals (instead of calling tcp_tmr()). */ +void tcp_slowtmr (void); +void tcp_fasttmr (void); + +/* Call this from a netif driver (watch out for threading issues!) that has + returned a memory error on transmit and now has free buffers to send more. + This iterates all active pcbs that had an error and tries to call + tcp_output, so use this with care as it might slow down the system. */ +void tcp_txnow (void); + +/* Only used by IP to pass a TCP segment to TCP: */ +void tcp_input (struct pbuf *p, struct netif *inp); +/* Used within the TCP code only: */ +struct tcp_pcb * tcp_alloc (u8_t prio); +void tcp_free (struct tcp_pcb *pcb); +void tcp_abandon (struct tcp_pcb *pcb, int reset); +err_t tcp_send_empty_ack(struct tcp_pcb *pcb); +err_t tcp_rexmit (struct tcp_pcb *pcb); +err_t tcp_rexmit_rto_prepare(struct tcp_pcb *pcb); +void tcp_rexmit_rto_commit(struct tcp_pcb *pcb); +void tcp_rexmit_rto (struct tcp_pcb *pcb); +void tcp_rexmit_fast (struct tcp_pcb *pcb); +u32_t tcp_update_rcv_ann_wnd(struct tcp_pcb *pcb); +err_t tcp_process_refused_data(struct tcp_pcb *pcb); + +/** + * This is the Nagle algorithm: try to combine user data to send as few TCP + * segments as possible. Only send if + * - no previously transmitted data on the connection remains unacknowledged or + * - the TF_NODELAY flag is set (nagle algorithm turned off for this pcb) or + * - the only unsent segment is at least pcb->mss bytes long (or there is more + * than one unsent segment - with lwIP, this can happen although unsent->len < mss) + * - or if we are in fast-retransmit (TF_INFR) + */ +#define tcp_do_output_nagle(tpcb) ((((tpcb)->unacked == NULL) || \ + ((tpcb)->flags & (TF_NODELAY | TF_INFR)) || \ + (((tpcb)->unsent != NULL) && (((tpcb)->unsent->next != NULL) || \ + ((tpcb)->unsent->len >= (tpcb)->mss))) || \ + ((tcp_sndbuf(tpcb) == 0) || (tcp_sndqueuelen(tpcb) >= TCP_SND_QUEUELEN)) \ + ) ? 1 : 0) +#define tcp_output_nagle(tpcb) (tcp_do_output_nagle(tpcb) ? tcp_output(tpcb) : ERR_OK) + + +#define TCP_SEQ_LT(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) < 0) +#define TCP_SEQ_LEQ(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) <= 0) +#define TCP_SEQ_GT(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) > 0) +#define TCP_SEQ_GEQ(a,b) ((s32_t)((u32_t)(a) - (u32_t)(b)) >= 0) +/* is b<=a<=c? */ +#if 0 /* see bug #10548 */ +#define TCP_SEQ_BETWEEN(a,b,c) ((c)-(b) >= (a)-(b)) +#endif +#define TCP_SEQ_BETWEEN(a,b,c) (TCP_SEQ_GEQ(a,b) && TCP_SEQ_LEQ(a,c)) + +#ifndef TCP_TMR_INTERVAL +#define TCP_TMR_INTERVAL 250 /* The TCP timer interval in milliseconds. */ +#endif /* TCP_TMR_INTERVAL */ + +#ifndef TCP_FAST_INTERVAL +#define TCP_FAST_INTERVAL TCP_TMR_INTERVAL /* the fine grained timeout in milliseconds */ +#endif /* TCP_FAST_INTERVAL */ + +#ifndef TCP_SLOW_INTERVAL +#define TCP_SLOW_INTERVAL (2*TCP_TMR_INTERVAL) /* the coarse grained timeout in milliseconds */ +#endif /* TCP_SLOW_INTERVAL */ + +#define TCP_FIN_WAIT_TIMEOUT 20000 /* milliseconds */ +#define TCP_SYN_RCVD_TIMEOUT 20000 /* milliseconds */ + +#define TCP_OOSEQ_TIMEOUT 6U /* x RTO */ + +#ifndef TCP_MSL +#define TCP_MSL 60000UL /* The maximum segment lifetime in milliseconds */ +#endif + +/* Keepalive values, compliant with RFC 1122. Don't change this unless you know what you're doing */ +#ifndef TCP_KEEPIDLE_DEFAULT +#define TCP_KEEPIDLE_DEFAULT 7200000UL /* Default KEEPALIVE timer in milliseconds */ +#endif + +#ifndef TCP_KEEPINTVL_DEFAULT +#define TCP_KEEPINTVL_DEFAULT 75000UL /* Default Time between KEEPALIVE probes in milliseconds */ +#endif + +#ifndef TCP_KEEPCNT_DEFAULT +#define TCP_KEEPCNT_DEFAULT 9U /* Default Counter for KEEPALIVE probes */ +#endif + +#define TCP_MAXIDLE TCP_KEEPCNT_DEFAULT * TCP_KEEPINTVL_DEFAULT /* Maximum KEEPALIVE probe time */ + +#define TCP_TCPLEN(seg) ((seg)->len + (((TCPH_FLAGS((seg)->tcphdr) & (TCP_FIN | TCP_SYN)) != 0) ? 1U : 0U)) + +/** Flags used on input processing, not on pcb->flags +*/ +#define TF_RESET (u8_t)0x08U /* Connection was reset. */ +#define TF_CLOSED (u8_t)0x10U /* Connection was successfully closed. */ +#define TF_GOT_FIN (u8_t)0x20U /* Connection was closed by the remote end. */ + + +#if LWIP_EVENT_API + +#define TCP_EVENT_ACCEPT(lpcb,pcb,arg,err,ret) ret = lwip_tcp_event(arg, (pcb),\ + LWIP_EVENT_ACCEPT, NULL, 0, err) +#define TCP_EVENT_SENT(pcb,space,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ + LWIP_EVENT_SENT, NULL, space, ERR_OK) +#define TCP_EVENT_RECV(pcb,p,err,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ + LWIP_EVENT_RECV, (p), 0, (err)) +#define TCP_EVENT_CLOSED(pcb,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ + LWIP_EVENT_RECV, NULL, 0, ERR_OK) +#define TCP_EVENT_CONNECTED(pcb,err,ret) ret = lwip_tcp_event((pcb)->callback_arg, (pcb),\ + LWIP_EVENT_CONNECTED, NULL, 0, (err)) +#define TCP_EVENT_POLL(pcb,ret) do { if ((pcb)->state != SYN_RCVD) { \ + ret = lwip_tcp_event((pcb)->callback_arg, (pcb), LWIP_EVENT_POLL, NULL, 0, ERR_OK); \ + } else { \ + ret = ERR_ARG; } } while(0) +/* For event API, last state SYN_RCVD must be excluded here: the application + has not seen this pcb, yet! */ +#define TCP_EVENT_ERR(last_state,errf,arg,err) do { if (last_state != SYN_RCVD) { \ + lwip_tcp_event((arg), NULL, LWIP_EVENT_ERR, NULL, 0, (err)); } } while(0) + +#else /* LWIP_EVENT_API */ + +#define TCP_EVENT_ACCEPT(lpcb,pcb,arg,err,ret) \ + do { \ + if((lpcb)->accept != NULL) \ + (ret) = (lpcb)->accept((arg),(pcb),(err)); \ + else (ret) = ERR_ARG; \ + } while (0) + +#define TCP_EVENT_SENT(pcb,space,ret) \ + do { \ + if((pcb)->sent != NULL) \ + (ret) = (pcb)->sent((pcb)->callback_arg,(pcb),(space)); \ + else (ret) = ERR_OK; \ + } while (0) + +#define TCP_EVENT_RECV(pcb,p,err,ret) \ + do { \ + if((pcb)->recv != NULL) { \ + (ret) = (pcb)->recv((pcb)->callback_arg,(pcb),(p),(err));\ + } else { \ + (ret) = tcp_recv_null(NULL, (pcb), (p), (err)); \ + } \ + } while (0) + +#define TCP_EVENT_CLOSED(pcb,ret) \ + do { \ + if(((pcb)->recv != NULL)) { \ + (ret) = (pcb)->recv((pcb)->callback_arg,(pcb),NULL,ERR_OK);\ + } else { \ + (ret) = ERR_OK; \ + } \ + } while (0) + +#define TCP_EVENT_CONNECTED(pcb,err,ret) \ + do { \ + if((pcb)->connected != NULL) \ + (ret) = (pcb)->connected((pcb)->callback_arg,(pcb),(err)); \ + else (ret) = ERR_OK; \ + } while (0) + +#define TCP_EVENT_POLL(pcb,ret) \ + do { \ + if((pcb)->poll != NULL) \ + (ret) = (pcb)->poll((pcb)->callback_arg,(pcb)); \ + else (ret) = ERR_OK; \ + } while (0) + +#define TCP_EVENT_ERR(last_state,errf,arg,err) \ + do { \ + LWIP_UNUSED_ARG(last_state); \ + if((errf) != NULL) \ + (errf)((arg),(err)); \ + } while (0) + +#endif /* LWIP_EVENT_API */ + +/** Enabled extra-check for TCP_OVERSIZE if LWIP_DEBUG is enabled */ +#if TCP_OVERSIZE && defined(LWIP_DEBUG) +#define TCP_OVERSIZE_DBGCHECK 1 +#else +#define TCP_OVERSIZE_DBGCHECK 0 +#endif + +/** Don't generate checksum on copy if CHECKSUM_GEN_TCP is disabled */ +#define TCP_CHECKSUM_ON_COPY (LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_TCP) + +/* This structure represents a TCP segment on the unsent, unacked and ooseq queues */ +struct tcp_seg { + struct tcp_seg *next; /* used when putting segments on a queue */ + struct pbuf *p; /* buffer containing data + TCP header */ + u16_t len; /* the TCP length of this segment */ +#if TCP_OVERSIZE_DBGCHECK + u16_t oversize_left; /* Extra bytes available at the end of the last + pbuf in unsent (used for asserting vs. + tcp_pcb.unsent_oversize only) */ +#endif /* TCP_OVERSIZE_DBGCHECK */ +#if TCP_CHECKSUM_ON_COPY + u16_t chksum; + u8_t chksum_swapped; +#endif /* TCP_CHECKSUM_ON_COPY */ + u8_t flags; +#define TF_SEG_OPTS_MSS (u8_t)0x01U /* Include MSS option (only used in SYN segments) */ +#define TF_SEG_OPTS_TS (u8_t)0x02U /* Include timestamp option. */ +#define TF_SEG_DATA_CHECKSUMMED (u8_t)0x04U /* ALL data (not the header) is + checksummed into 'chksum' */ +#define TF_SEG_OPTS_WND_SCALE (u8_t)0x08U /* Include WND SCALE option (only used in SYN segments) */ +#define TF_SEG_OPTS_SACK_PERM (u8_t)0x10U /* Include SACK Permitted option (only used in SYN segments) */ + struct tcp_hdr *tcphdr; /* the TCP header */ +}; + +#define LWIP_TCP_OPT_EOL 0 +#define LWIP_TCP_OPT_NOP 1 +#define LWIP_TCP_OPT_MSS 2 +#define LWIP_TCP_OPT_WS 3 +#define LWIP_TCP_OPT_SACK_PERM 4 +#define LWIP_TCP_OPT_TS 8 + +#define LWIP_TCP_OPT_LEN_MSS 4 +#if LWIP_TCP_TIMESTAMPS +#define LWIP_TCP_OPT_LEN_TS 10 +#define LWIP_TCP_OPT_LEN_TS_OUT 12 /* aligned for output (includes NOP padding) */ +#else +#define LWIP_TCP_OPT_LEN_TS_OUT 0 +#endif +#if LWIP_WND_SCALE +#define LWIP_TCP_OPT_LEN_WS 3 +#define LWIP_TCP_OPT_LEN_WS_OUT 4 /* aligned for output (includes NOP padding) */ +#else +#define LWIP_TCP_OPT_LEN_WS_OUT 0 +#endif + +#if LWIP_TCP_SACK_OUT +#define LWIP_TCP_OPT_LEN_SACK_PERM 2 +#define LWIP_TCP_OPT_LEN_SACK_PERM_OUT 4 /* aligned for output (includes NOP padding) */ +#else +#define LWIP_TCP_OPT_LEN_SACK_PERM_OUT 0 +#endif + +#define LWIP_TCP_OPT_LENGTH(flags) \ + ((flags) & TF_SEG_OPTS_MSS ? LWIP_TCP_OPT_LEN_MSS : 0) + \ + ((flags) & TF_SEG_OPTS_TS ? LWIP_TCP_OPT_LEN_TS_OUT : 0) + \ + ((flags) & TF_SEG_OPTS_WND_SCALE ? LWIP_TCP_OPT_LEN_WS_OUT : 0) + \ + ((flags) & TF_SEG_OPTS_SACK_PERM ? LWIP_TCP_OPT_LEN_SACK_PERM_OUT : 0) + +/** This returns a TCP header option for MSS in an u32_t */ +#define TCP_BUILD_MSS_OPTION(mss) lwip_htonl(0x02040000 | ((mss) & 0xFFFF)) + +#if LWIP_WND_SCALE +#define TCPWNDSIZE_F U32_F +#define TCPWND_MAX 0xFFFFFFFFU +#define TCPWND_CHECK16(x) LWIP_ASSERT("window size > 0xFFFF", (x) <= 0xFFFF) +#define TCPWND_MIN16(x) ((u16_t)LWIP_MIN((x), 0xFFFF)) +#else /* LWIP_WND_SCALE */ +#define TCPWNDSIZE_F U16_F +#define TCPWND_MAX 0xFFFFU +#define TCPWND_CHECK16(x) +#define TCPWND_MIN16(x) x +#endif /* LWIP_WND_SCALE */ + +/* Global variables: */ +extern struct tcp_pcb *tcp_input_pcb; +extern u32_t tcp_ticks; +extern u8_t tcp_active_pcbs_changed; + +/* The TCP PCB lists. */ +union tcp_listen_pcbs_t { /* List of all TCP PCBs in LISTEN state. */ + struct tcp_pcb_listen *listen_pcbs; + struct tcp_pcb *pcbs; +}; +extern struct tcp_pcb *tcp_bound_pcbs; +extern union tcp_listen_pcbs_t tcp_listen_pcbs; +extern struct tcp_pcb *tcp_active_pcbs; /* List of all TCP PCBs that are in a + state in which they accept or send + data. */ +extern struct tcp_pcb *tcp_tw_pcbs; /* List of all TCP PCBs in TIME-WAIT. */ + +#define NUM_TCP_PCB_LISTS_NO_TIME_WAIT 3 +#define NUM_TCP_PCB_LISTS 4 +extern struct tcp_pcb ** const tcp_pcb_lists[NUM_TCP_PCB_LISTS]; + +/* Axioms about the above lists: + 1) Every TCP PCB that is not CLOSED is in one of the lists. + 2) A PCB is only in one of the lists. + 3) All PCBs in the tcp_listen_pcbs list is in LISTEN state. + 4) All PCBs in the tcp_tw_pcbs list is in TIME-WAIT state. +*/ +/* Define two macros, TCP_REG and TCP_RMV that registers a TCP PCB + with a PCB list or removes a PCB from a list, respectively. */ +#ifndef TCP_DEBUG_PCB_LISTS +#define TCP_DEBUG_PCB_LISTS 0 +#endif +#if TCP_DEBUG_PCB_LISTS +#define TCP_REG(pcbs, npcb) do {\ + struct tcp_pcb *tcp_tmp_pcb; \ + LWIP_DEBUGF(TCP_DEBUG, ("TCP_REG %p local port %"U16_F"\n", (void *)(npcb), (npcb)->local_port)); \ + for (tcp_tmp_pcb = *(pcbs); \ + tcp_tmp_pcb != NULL; \ + tcp_tmp_pcb = tcp_tmp_pcb->next) { \ + LWIP_ASSERT("TCP_REG: already registered\n", tcp_tmp_pcb != (npcb)); \ + } \ + LWIP_ASSERT("TCP_REG: pcb->state != CLOSED", ((pcbs) == &tcp_bound_pcbs) || ((npcb)->state != CLOSED)); \ + (npcb)->next = *(pcbs); \ + LWIP_ASSERT("TCP_REG: npcb->next != npcb", (npcb)->next != (npcb)); \ + *(pcbs) = (npcb); \ + LWIP_ASSERT("TCP_REG: tcp_pcbs sane", tcp_pcbs_sane()); \ + tcp_timer_needed(); \ + } while(0) +#define TCP_RMV(pcbs, npcb) do { \ + struct tcp_pcb *tcp_tmp_pcb; \ + LWIP_ASSERT("TCP_RMV: pcbs != NULL", *(pcbs) != NULL); \ + LWIP_DEBUGF(TCP_DEBUG, ("TCP_RMV: removing %p from %p\n", (void *)(npcb), (void *)(*(pcbs)))); \ + if(*(pcbs) == (npcb)) { \ + *(pcbs) = (*pcbs)->next; \ + } else for (tcp_tmp_pcb = *(pcbs); tcp_tmp_pcb != NULL; tcp_tmp_pcb = tcp_tmp_pcb->next) { \ + if(tcp_tmp_pcb->next == (npcb)) { \ + tcp_tmp_pcb->next = (npcb)->next; \ + break; \ + } \ + } \ + (npcb)->next = NULL; \ + LWIP_ASSERT("TCP_RMV: tcp_pcbs sane", tcp_pcbs_sane()); \ + LWIP_DEBUGF(TCP_DEBUG, ("TCP_RMV: removed %p from %p\n", (void *)(npcb), (void *)(*(pcbs)))); \ + } while(0) + +#else /* LWIP_DEBUG */ + +#define TCP_REG(pcbs, npcb) \ + do { \ + (npcb)->next = *pcbs; \ + *(pcbs) = (npcb); \ + tcp_timer_needed(); \ + } while (0) + +#define TCP_RMV(pcbs, npcb) \ + do { \ + if(*(pcbs) == (npcb)) { \ + (*(pcbs)) = (*pcbs)->next; \ + } \ + else { \ + struct tcp_pcb *tcp_tmp_pcb; \ + for (tcp_tmp_pcb = *pcbs; \ + tcp_tmp_pcb != NULL; \ + tcp_tmp_pcb = tcp_tmp_pcb->next) { \ + if(tcp_tmp_pcb->next == (npcb)) { \ + tcp_tmp_pcb->next = (npcb)->next; \ + break; \ + } \ + } \ + } \ + (npcb)->next = NULL; \ + } while(0) + +#endif /* LWIP_DEBUG */ + +#define TCP_REG_ACTIVE(npcb) \ + do { \ + TCP_REG(&tcp_active_pcbs, npcb); \ + tcp_active_pcbs_changed = 1; \ + } while (0) + +#define TCP_RMV_ACTIVE(npcb) \ + do { \ + TCP_RMV(&tcp_active_pcbs, npcb); \ + tcp_active_pcbs_changed = 1; \ + } while (0) + +#define TCP_PCB_REMOVE_ACTIVE(pcb) \ + do { \ + tcp_pcb_remove(&tcp_active_pcbs, pcb); \ + tcp_active_pcbs_changed = 1; \ + } while (0) + + +/* Internal functions: */ +struct tcp_pcb *tcp_pcb_copy(struct tcp_pcb *pcb); +void tcp_pcb_purge(struct tcp_pcb *pcb); +void tcp_pcb_remove(struct tcp_pcb **pcblist, struct tcp_pcb *pcb); + +void tcp_segs_free(struct tcp_seg *seg); +void tcp_seg_free(struct tcp_seg *seg); +struct tcp_seg *tcp_seg_copy(struct tcp_seg *seg); + +#define tcp_ack(pcb) \ + do { \ + if((pcb)->flags & TF_ACK_DELAY) { \ + tcp_clear_flags(pcb, TF_ACK_DELAY); \ + tcp_ack_now(pcb); \ + } \ + else { \ + tcp_set_flags(pcb, TF_ACK_DELAY); \ + } \ + } while (0) + +#define tcp_ack_now(pcb) \ + tcp_set_flags(pcb, TF_ACK_NOW) + +err_t tcp_send_fin(struct tcp_pcb *pcb); +err_t tcp_enqueue_flags(struct tcp_pcb *pcb, u8_t flags); + +void tcp_rexmit_seg(struct tcp_pcb *pcb, struct tcp_seg *seg); + +void tcp_rst(const struct tcp_pcb* pcb, u32_t seqno, u32_t ackno, + const ip_addr_t *local_ip, const ip_addr_t *remote_ip, + u16_t local_port, u16_t remote_port); + +u32_t tcp_next_iss(struct tcp_pcb *pcb); + +err_t tcp_keepalive(struct tcp_pcb *pcb); +err_t tcp_split_unsent_seg(struct tcp_pcb *pcb, u16_t split); +err_t tcp_zero_window_probe(struct tcp_pcb *pcb); +void tcp_trigger_input_pcb_close(void); + +#if TCP_CALCULATE_EFF_SEND_MSS +u16_t tcp_eff_send_mss_netif(u16_t sendmss, struct netif *outif, + const ip_addr_t *dest); +#define tcp_eff_send_mss(sendmss, src, dest) \ + tcp_eff_send_mss_netif(sendmss, ip_route(src, dest), dest) +#endif /* TCP_CALCULATE_EFF_SEND_MSS */ + +#if LWIP_CALLBACK_API +err_t tcp_recv_null(void *arg, struct tcp_pcb *pcb, struct pbuf *p, err_t err); +#endif /* LWIP_CALLBACK_API */ + +#if TCP_DEBUG || TCP_INPUT_DEBUG || TCP_OUTPUT_DEBUG +void tcp_debug_print(struct tcp_hdr *tcphdr); +void tcp_debug_print_flags(u8_t flags); +void tcp_debug_print_state(enum tcp_state s); +void tcp_debug_print_pcbs(void); +s16_t tcp_pcbs_sane(void); +#else +# define tcp_debug_print(tcphdr) +# define tcp_debug_print_flags(flags) +# define tcp_debug_print_state(s) +# define tcp_debug_print_pcbs() +# define tcp_pcbs_sane() 1 +#endif /* TCP_DEBUG */ + +/** External function (implemented in timers.c), called when TCP detects + * that a timer is needed (i.e. active- or time-wait-pcb found). */ +void tcp_timer_needed(void); + +void tcp_netif_ip_addr_changed(const ip_addr_t* old_addr, const ip_addr_t* new_addr); + +#if TCP_QUEUE_OOSEQ +void tcp_free_ooseq(struct tcp_pcb *pcb); +#endif + +#if LWIP_TCP_PCB_NUM_EXT_ARGS +err_t tcp_ext_arg_invoke_callbacks_passive_open(struct tcp_pcb_listen *lpcb, struct tcp_pcb *cpcb); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_TCP */ + +#endif /* LWIP_HDR_TCP_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcpip_priv.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcpip_priv.h index 327673b9..74be634b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcpip_priv.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/priv/tcpip_priv.h @@ -1,170 +1,170 @@ -/** - * @file - * TCPIP API internal implementations (do not use in application code) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_TCPIP_PRIV_H -#define LWIP_HDR_TCPIP_PRIV_H - -#include "lwip/opt.h" - -#if !NO_SYS /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/tcpip.h" -#include "lwip/sys.h" -#include "lwip/timeouts.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct pbuf; -struct netif; - -#if LWIP_MPU_COMPATIBLE -#define API_VAR_REF(name) (*(name)) -#define API_VAR_DECLARE(type, name) type * name -#define API_VAR_ALLOC_EXT(type, pool, name, errorblock) do { \ - name = (type *)memp_malloc(pool); \ - if (name == NULL) { \ - errorblock; \ - } \ - } while(0) -#define API_VAR_ALLOC(type, pool, name, errorval) API_VAR_ALLOC_EXT(type, pool, name, return errorval) -#define API_VAR_ALLOC_POOL(type, pool, name, errorval) do { \ - name = (type *)LWIP_MEMPOOL_ALLOC(pool); \ - if (name == NULL) { \ - return errorval; \ - } \ - } while(0) -#define API_VAR_FREE(pool, name) memp_free(pool, name) -#define API_VAR_FREE_POOL(pool, name) LWIP_MEMPOOL_FREE(pool, name) -#define API_EXPR_REF(expr) (&(expr)) -#if LWIP_NETCONN_SEM_PER_THREAD -#define API_EXPR_REF_SEM(expr) (expr) -#else -#define API_EXPR_REF_SEM(expr) API_EXPR_REF(expr) -#endif -#define API_EXPR_DEREF(expr) expr -#define API_MSG_M_DEF(m) m -#define API_MSG_M_DEF_C(t, m) t m -#else /* LWIP_MPU_COMPATIBLE */ -#define API_VAR_REF(name) name -#define API_VAR_DECLARE(type, name) type name -#define API_VAR_ALLOC_EXT(type, pool, name, errorblock) -#define API_VAR_ALLOC(type, pool, name, errorval) -#define API_VAR_ALLOC_POOL(type, pool, name, errorval) -#define API_VAR_FREE(pool, name) -#define API_VAR_FREE_POOL(pool, name) -#define API_EXPR_REF(expr) expr -#define API_EXPR_REF_SEM(expr) API_EXPR_REF(expr) -#define API_EXPR_DEREF(expr) (*(expr)) -#define API_MSG_M_DEF(m) *m -#define API_MSG_M_DEF_C(t, m) const t * m -#endif /* LWIP_MPU_COMPATIBLE */ - -err_t tcpip_send_msg_wait_sem(tcpip_callback_fn fn, void *apimsg, sys_sem_t* sem); - -struct tcpip_api_call_data -{ -#if !LWIP_TCPIP_CORE_LOCKING - err_t err; -#if !LWIP_NETCONN_SEM_PER_THREAD - sys_sem_t sem; -#endif /* LWIP_NETCONN_SEM_PER_THREAD */ -#else /* !LWIP_TCPIP_CORE_LOCKING */ - u8_t dummy; /* avoid empty struct :-( */ -#endif /* !LWIP_TCPIP_CORE_LOCKING */ -}; -typedef err_t (*tcpip_api_call_fn)(struct tcpip_api_call_data* call); -err_t tcpip_api_call(tcpip_api_call_fn fn, struct tcpip_api_call_data *call); - -enum tcpip_msg_type { -#if !LWIP_TCPIP_CORE_LOCKING - TCPIP_MSG_API, - TCPIP_MSG_API_CALL, -#endif /* !LWIP_TCPIP_CORE_LOCKING */ -#if !LWIP_TCPIP_CORE_LOCKING_INPUT - TCPIP_MSG_INPKT, -#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ -#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS - TCPIP_MSG_TIMEOUT, - TCPIP_MSG_UNTIMEOUT, -#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ - TCPIP_MSG_CALLBACK, - TCPIP_MSG_CALLBACK_STATIC -}; - -struct tcpip_msg { - enum tcpip_msg_type type; - union { -#if !LWIP_TCPIP_CORE_LOCKING - struct { - tcpip_callback_fn function; - void* msg; - } api_msg; - struct { - tcpip_api_call_fn function; - struct tcpip_api_call_data *arg; - sys_sem_t *sem; - } api_call; -#endif /* LWIP_TCPIP_CORE_LOCKING */ -#if !LWIP_TCPIP_CORE_LOCKING_INPUT - struct { - struct pbuf *p; - struct netif *netif; - netif_input_fn input_fn; - } inp; -#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ - struct { - tcpip_callback_fn function; - void *ctx; - } cb; -#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS - struct { - u32_t msecs; - sys_timeout_handler h; - void *arg; - } tmo; -#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ - } msg; -}; - -#ifdef __cplusplus -} -#endif - -#endif /* !NO_SYS */ - -#endif /* LWIP_HDR_TCPIP_PRIV_H */ +/** + * @file + * TCPIP API internal implementations (do not use in application code) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_TCPIP_PRIV_H +#define LWIP_HDR_TCPIP_PRIV_H + +#include "lwip/opt.h" + +#if !NO_SYS /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/tcpip.h" +#include "lwip/sys.h" +#include "lwip/timeouts.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct pbuf; +struct netif; + +#if LWIP_MPU_COMPATIBLE +#define API_VAR_REF(name) (*(name)) +#define API_VAR_DECLARE(type, name) type * name +#define API_VAR_ALLOC_EXT(type, pool, name, errorblock) do { \ + name = (type *)memp_malloc(pool); \ + if (name == NULL) { \ + errorblock; \ + } \ + } while(0) +#define API_VAR_ALLOC(type, pool, name, errorval) API_VAR_ALLOC_EXT(type, pool, name, return errorval) +#define API_VAR_ALLOC_POOL(type, pool, name, errorval) do { \ + name = (type *)LWIP_MEMPOOL_ALLOC(pool); \ + if (name == NULL) { \ + return errorval; \ + } \ + } while(0) +#define API_VAR_FREE(pool, name) memp_free(pool, name) +#define API_VAR_FREE_POOL(pool, name) LWIP_MEMPOOL_FREE(pool, name) +#define API_EXPR_REF(expr) (&(expr)) +#if LWIP_NETCONN_SEM_PER_THREAD +#define API_EXPR_REF_SEM(expr) (expr) +#else +#define API_EXPR_REF_SEM(expr) API_EXPR_REF(expr) +#endif +#define API_EXPR_DEREF(expr) expr +#define API_MSG_M_DEF(m) m +#define API_MSG_M_DEF_C(t, m) t m +#else /* LWIP_MPU_COMPATIBLE */ +#define API_VAR_REF(name) name +#define API_VAR_DECLARE(type, name) type name +#define API_VAR_ALLOC_EXT(type, pool, name, errorblock) +#define API_VAR_ALLOC(type, pool, name, errorval) +#define API_VAR_ALLOC_POOL(type, pool, name, errorval) +#define API_VAR_FREE(pool, name) +#define API_VAR_FREE_POOL(pool, name) +#define API_EXPR_REF(expr) expr +#define API_EXPR_REF_SEM(expr) API_EXPR_REF(expr) +#define API_EXPR_DEREF(expr) (*(expr)) +#define API_MSG_M_DEF(m) *m +#define API_MSG_M_DEF_C(t, m) const t * m +#endif /* LWIP_MPU_COMPATIBLE */ + +err_t tcpip_send_msg_wait_sem(tcpip_callback_fn fn, void *apimsg, sys_sem_t* sem); + +struct tcpip_api_call_data +{ +#if !LWIP_TCPIP_CORE_LOCKING + err_t err; +#if !LWIP_NETCONN_SEM_PER_THREAD + sys_sem_t sem; +#endif /* LWIP_NETCONN_SEM_PER_THREAD */ +#else /* !LWIP_TCPIP_CORE_LOCKING */ + u8_t dummy; /* avoid empty struct :-( */ +#endif /* !LWIP_TCPIP_CORE_LOCKING */ +}; +typedef err_t (*tcpip_api_call_fn)(struct tcpip_api_call_data* call); +err_t tcpip_api_call(tcpip_api_call_fn fn, struct tcpip_api_call_data *call); + +enum tcpip_msg_type { +#if !LWIP_TCPIP_CORE_LOCKING + TCPIP_MSG_API, + TCPIP_MSG_API_CALL, +#endif /* !LWIP_TCPIP_CORE_LOCKING */ +#if !LWIP_TCPIP_CORE_LOCKING_INPUT + TCPIP_MSG_INPKT, +#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ +#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS + TCPIP_MSG_TIMEOUT, + TCPIP_MSG_UNTIMEOUT, +#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ + TCPIP_MSG_CALLBACK, + TCPIP_MSG_CALLBACK_STATIC +}; + +struct tcpip_msg { + enum tcpip_msg_type type; + union { +#if !LWIP_TCPIP_CORE_LOCKING + struct { + tcpip_callback_fn function; + void* msg; + } api_msg; + struct { + tcpip_api_call_fn function; + struct tcpip_api_call_data *arg; + sys_sem_t *sem; + } api_call; +#endif /* LWIP_TCPIP_CORE_LOCKING */ +#if !LWIP_TCPIP_CORE_LOCKING_INPUT + struct { + struct pbuf *p; + struct netif *netif; + netif_input_fn input_fn; + } inp; +#endif /* !LWIP_TCPIP_CORE_LOCKING_INPUT */ + struct { + tcpip_callback_fn function; + void *ctx; + } cb; +#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS + struct { + u32_t msecs; + sys_timeout_handler h; + void *arg; + } tmo; +#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ + } msg; +}; + +#ifdef __cplusplus +} +#endif + +#endif /* !NO_SYS */ + +#endif /* LWIP_HDR_TCPIP_PRIV_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/autoip.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/autoip.h index 3fe15327..fd3af8a9 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/autoip.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/autoip.h @@ -1,78 +1,78 @@ -/** - * @file - * AutoIP protocol definitions - */ - -/* - * - * Copyright (c) 2007 Dominik Spies - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Dominik Spies - * - * This is a AutoIP implementation for the lwIP TCP/IP stack. It aims to conform - * with RFC 3927. - * - */ - -#ifndef LWIP_HDR_PROT_AUTOIP_H -#define LWIP_HDR_PROT_AUTOIP_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* 169.254.0.0 */ -#define AUTOIP_NET 0xA9FE0000 -/* 169.254.1.0 */ -#define AUTOIP_RANGE_START (AUTOIP_NET | 0x0100) -/* 169.254.254.255 */ -#define AUTOIP_RANGE_END (AUTOIP_NET | 0xFEFF) - -/* RFC 3927 Constants */ -#define PROBE_WAIT 1 /* second (initial random delay) */ -#define PROBE_MIN 1 /* second (minimum delay till repeated probe) */ -#define PROBE_MAX 2 /* seconds (maximum delay till repeated probe) */ -#define PROBE_NUM 3 /* (number of probe packets) */ -#define ANNOUNCE_NUM 2 /* (number of announcement packets) */ -#define ANNOUNCE_INTERVAL 2 /* seconds (time between announcement packets) */ -#define ANNOUNCE_WAIT 2 /* seconds (delay before announcing) */ -#define MAX_CONFLICTS 10 /* (max conflicts before rate limiting) */ -#define RATE_LIMIT_INTERVAL 60 /* seconds (delay between successive attempts) */ -#define DEFEND_INTERVAL 10 /* seconds (min. wait between defensive ARPs) */ - -/* AutoIP client states */ -typedef enum { - AUTOIP_STATE_OFF = 0, - AUTOIP_STATE_PROBING = 1, - AUTOIP_STATE_ANNOUNCING = 2, - AUTOIP_STATE_BOUND = 3 -} autoip_state_enum_t; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_AUTOIP_H */ +/** + * @file + * AutoIP protocol definitions + */ + +/* + * + * Copyright (c) 2007 Dominik Spies + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Dominik Spies + * + * This is a AutoIP implementation for the lwIP TCP/IP stack. It aims to conform + * with RFC 3927. + * + */ + +#ifndef LWIP_HDR_PROT_AUTOIP_H +#define LWIP_HDR_PROT_AUTOIP_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* 169.254.0.0 */ +#define AUTOIP_NET 0xA9FE0000 +/* 169.254.1.0 */ +#define AUTOIP_RANGE_START (AUTOIP_NET | 0x0100) +/* 169.254.254.255 */ +#define AUTOIP_RANGE_END (AUTOIP_NET | 0xFEFF) + +/* RFC 3927 Constants */ +#define PROBE_WAIT 1 /* second (initial random delay) */ +#define PROBE_MIN 1 /* second (minimum delay till repeated probe) */ +#define PROBE_MAX 2 /* seconds (maximum delay till repeated probe) */ +#define PROBE_NUM 3 /* (number of probe packets) */ +#define ANNOUNCE_NUM 2 /* (number of announcement packets) */ +#define ANNOUNCE_INTERVAL 2 /* seconds (time between announcement packets) */ +#define ANNOUNCE_WAIT 2 /* seconds (delay before announcing) */ +#define MAX_CONFLICTS 10 /* (max conflicts before rate limiting) */ +#define RATE_LIMIT_INTERVAL 60 /* seconds (delay between successive attempts) */ +#define DEFEND_INTERVAL 10 /* seconds (min. wait between defensive ARPs) */ + +/* AutoIP client states */ +typedef enum { + AUTOIP_STATE_OFF = 0, + AUTOIP_STATE_PROBING = 1, + AUTOIP_STATE_ANNOUNCING = 2, + AUTOIP_STATE_BOUND = 3 +} autoip_state_enum_t; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_AUTOIP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp.h index 6d16ce36..ab18dca3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp.h @@ -1,178 +1,178 @@ -/** - * @file - * DHCP protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Leon Woestenberg - * Copyright (c) 2001-2004 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Leon Woestenberg - * - */ -#ifndef LWIP_HDR_PROT_DHCP_H -#define LWIP_HDR_PROT_DHCP_H - -#include "lwip/opt.h" -#include "lwip/arch.h" -#include "lwip/prot/ip4.h" - -#ifdef __cplusplus -extern "C" { -#endif - - /* DHCP message item offsets and length */ -#define DHCP_CHADDR_LEN 16U -#define DHCP_SNAME_OFS 44U -#define DHCP_SNAME_LEN 64U -#define DHCP_FILE_OFS 108U -#define DHCP_FILE_LEN 128U -#define DHCP_MSG_LEN 236U -#define DHCP_OPTIONS_OFS (DHCP_MSG_LEN + 4U) /* 4 byte: cookie */ - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** minimum set of fields of any DHCP message */ -struct dhcp_msg -{ - PACK_STRUCT_FLD_8(u8_t op); - PACK_STRUCT_FLD_8(u8_t htype); - PACK_STRUCT_FLD_8(u8_t hlen); - PACK_STRUCT_FLD_8(u8_t hops); - PACK_STRUCT_FIELD(u32_t xid); - PACK_STRUCT_FIELD(u16_t secs); - PACK_STRUCT_FIELD(u16_t flags); - PACK_STRUCT_FLD_S(ip4_addr_p_t ciaddr); - PACK_STRUCT_FLD_S(ip4_addr_p_t yiaddr); - PACK_STRUCT_FLD_S(ip4_addr_p_t siaddr); - PACK_STRUCT_FLD_S(ip4_addr_p_t giaddr); - PACK_STRUCT_FLD_8(u8_t chaddr[DHCP_CHADDR_LEN]); - PACK_STRUCT_FLD_8(u8_t sname[DHCP_SNAME_LEN]); - PACK_STRUCT_FLD_8(u8_t file[DHCP_FILE_LEN]); - PACK_STRUCT_FIELD(u32_t cookie); -#define DHCP_MIN_OPTIONS_LEN 68U -/** make sure user does not configure this too small */ -#if ((defined(DHCP_OPTIONS_LEN)) && (DHCP_OPTIONS_LEN < DHCP_MIN_OPTIONS_LEN)) -# undef DHCP_OPTIONS_LEN -#endif -/** allow this to be configured in lwipopts.h, but not too small */ -#if (!defined(DHCP_OPTIONS_LEN)) -/** set this to be sufficient for your options in outgoing DHCP msgs */ -# define DHCP_OPTIONS_LEN DHCP_MIN_OPTIONS_LEN -#endif - PACK_STRUCT_FLD_8(u8_t options[DHCP_OPTIONS_LEN]); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - - -/* DHCP client states */ -typedef enum { - DHCP_STATE_OFF = 0, - DHCP_STATE_REQUESTING = 1, - DHCP_STATE_INIT = 2, - DHCP_STATE_REBOOTING = 3, - DHCP_STATE_REBINDING = 4, - DHCP_STATE_RENEWING = 5, - DHCP_STATE_SELECTING = 6, - DHCP_STATE_INFORMING = 7, - DHCP_STATE_CHECKING = 8, - DHCP_STATE_PERMANENT = 9, /* not yet implemented */ - DHCP_STATE_BOUND = 10, - DHCP_STATE_RELEASING = 11, /* not yet implemented */ - DHCP_STATE_BACKING_OFF = 12 -} dhcp_state_enum_t; - -/* DHCP op codes */ -#define DHCP_BOOTREQUEST 1 -#define DHCP_BOOTREPLY 2 - -/* DHCP message types */ -#define DHCP_DISCOVER 1 -#define DHCP_OFFER 2 -#define DHCP_REQUEST 3 -#define DHCP_DECLINE 4 -#define DHCP_ACK 5 -#define DHCP_NAK 6 -#define DHCP_RELEASE 7 -#define DHCP_INFORM 8 - -#define DHCP_MAGIC_COOKIE 0x63825363UL - -/* This is a list of options for BOOTP and DHCP, see RFC 2132 for descriptions */ - -/* BootP options */ -#define DHCP_OPTION_PAD 0 -#define DHCP_OPTION_SUBNET_MASK 1 /* RFC 2132 3.3 */ -#define DHCP_OPTION_ROUTER 3 -#define DHCP_OPTION_DNS_SERVER 6 -#define DHCP_OPTION_HOSTNAME 12 -#define DHCP_OPTION_IP_TTL 23 -#define DHCP_OPTION_MTU 26 -#define DHCP_OPTION_BROADCAST 28 -#define DHCP_OPTION_TCP_TTL 37 -#define DHCP_OPTION_NTP 42 -#define DHCP_OPTION_END 255 - -/* DHCP options */ -#define DHCP_OPTION_REQUESTED_IP 50 /* RFC 2132 9.1, requested IP address */ -#define DHCP_OPTION_LEASE_TIME 51 /* RFC 2132 9.2, time in seconds, in 4 bytes */ -#define DHCP_OPTION_OVERLOAD 52 /* RFC2132 9.3, use file and/or sname field for options */ - -#define DHCP_OPTION_MESSAGE_TYPE 53 /* RFC 2132 9.6, important for DHCP */ -#define DHCP_OPTION_MESSAGE_TYPE_LEN 1 - -#define DHCP_OPTION_SERVER_ID 54 /* RFC 2132 9.7, server IP address */ -#define DHCP_OPTION_PARAMETER_REQUEST_LIST 55 /* RFC 2132 9.8, requested option types */ - -#define DHCP_OPTION_MAX_MSG_SIZE 57 /* RFC 2132 9.10, message size accepted >= 576 */ -#define DHCP_OPTION_MAX_MSG_SIZE_LEN 2 - -#define DHCP_OPTION_T1 58 /* T1 renewal time */ -#define DHCP_OPTION_T2 59 /* T2 rebinding time */ -#define DHCP_OPTION_US 60 -#define DHCP_OPTION_CLIENT_ID 61 -#define DHCP_OPTION_TFTP_SERVERNAME 66 -#define DHCP_OPTION_BOOTFILE 67 - -/* possible combinations of overloading the file and sname fields with options */ -#define DHCP_OVERLOAD_NONE 0 -#define DHCP_OVERLOAD_FILE 1 -#define DHCP_OVERLOAD_SNAME 2 -#define DHCP_OVERLOAD_SNAME_FILE 3 - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_DHCP_H */ +/** + * @file + * DHCP protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Leon Woestenberg + * Copyright (c) 2001-2004 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Leon Woestenberg + * + */ +#ifndef LWIP_HDR_PROT_DHCP_H +#define LWIP_HDR_PROT_DHCP_H + +#include "lwip/opt.h" +#include "lwip/arch.h" +#include "lwip/prot/ip4.h" + +#ifdef __cplusplus +extern "C" { +#endif + + /* DHCP message item offsets and length */ +#define DHCP_CHADDR_LEN 16U +#define DHCP_SNAME_OFS 44U +#define DHCP_SNAME_LEN 64U +#define DHCP_FILE_OFS 108U +#define DHCP_FILE_LEN 128U +#define DHCP_MSG_LEN 236U +#define DHCP_OPTIONS_OFS (DHCP_MSG_LEN + 4U) /* 4 byte: cookie */ + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** minimum set of fields of any DHCP message */ +struct dhcp_msg +{ + PACK_STRUCT_FLD_8(u8_t op); + PACK_STRUCT_FLD_8(u8_t htype); + PACK_STRUCT_FLD_8(u8_t hlen); + PACK_STRUCT_FLD_8(u8_t hops); + PACK_STRUCT_FIELD(u32_t xid); + PACK_STRUCT_FIELD(u16_t secs); + PACK_STRUCT_FIELD(u16_t flags); + PACK_STRUCT_FLD_S(ip4_addr_p_t ciaddr); + PACK_STRUCT_FLD_S(ip4_addr_p_t yiaddr); + PACK_STRUCT_FLD_S(ip4_addr_p_t siaddr); + PACK_STRUCT_FLD_S(ip4_addr_p_t giaddr); + PACK_STRUCT_FLD_8(u8_t chaddr[DHCP_CHADDR_LEN]); + PACK_STRUCT_FLD_8(u8_t sname[DHCP_SNAME_LEN]); + PACK_STRUCT_FLD_8(u8_t file[DHCP_FILE_LEN]); + PACK_STRUCT_FIELD(u32_t cookie); +#define DHCP_MIN_OPTIONS_LEN 68U +/** make sure user does not configure this too small */ +#if ((defined(DHCP_OPTIONS_LEN)) && (DHCP_OPTIONS_LEN < DHCP_MIN_OPTIONS_LEN)) +# undef DHCP_OPTIONS_LEN +#endif +/** allow this to be configured in lwipopts.h, but not too small */ +#if (!defined(DHCP_OPTIONS_LEN)) +/** set this to be sufficient for your options in outgoing DHCP msgs */ +# define DHCP_OPTIONS_LEN DHCP_MIN_OPTIONS_LEN +#endif + PACK_STRUCT_FLD_8(u8_t options[DHCP_OPTIONS_LEN]); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + + +/* DHCP client states */ +typedef enum { + DHCP_STATE_OFF = 0, + DHCP_STATE_REQUESTING = 1, + DHCP_STATE_INIT = 2, + DHCP_STATE_REBOOTING = 3, + DHCP_STATE_REBINDING = 4, + DHCP_STATE_RENEWING = 5, + DHCP_STATE_SELECTING = 6, + DHCP_STATE_INFORMING = 7, + DHCP_STATE_CHECKING = 8, + DHCP_STATE_PERMANENT = 9, /* not yet implemented */ + DHCP_STATE_BOUND = 10, + DHCP_STATE_RELEASING = 11, /* not yet implemented */ + DHCP_STATE_BACKING_OFF = 12 +} dhcp_state_enum_t; + +/* DHCP op codes */ +#define DHCP_BOOTREQUEST 1 +#define DHCP_BOOTREPLY 2 + +/* DHCP message types */ +#define DHCP_DISCOVER 1 +#define DHCP_OFFER 2 +#define DHCP_REQUEST 3 +#define DHCP_DECLINE 4 +#define DHCP_ACK 5 +#define DHCP_NAK 6 +#define DHCP_RELEASE 7 +#define DHCP_INFORM 8 + +#define DHCP_MAGIC_COOKIE 0x63825363UL + +/* This is a list of options for BOOTP and DHCP, see RFC 2132 for descriptions */ + +/* BootP options */ +#define DHCP_OPTION_PAD 0 +#define DHCP_OPTION_SUBNET_MASK 1 /* RFC 2132 3.3 */ +#define DHCP_OPTION_ROUTER 3 +#define DHCP_OPTION_DNS_SERVER 6 +#define DHCP_OPTION_HOSTNAME 12 +#define DHCP_OPTION_IP_TTL 23 +#define DHCP_OPTION_MTU 26 +#define DHCP_OPTION_BROADCAST 28 +#define DHCP_OPTION_TCP_TTL 37 +#define DHCP_OPTION_NTP 42 +#define DHCP_OPTION_END 255 + +/* DHCP options */ +#define DHCP_OPTION_REQUESTED_IP 50 /* RFC 2132 9.1, requested IP address */ +#define DHCP_OPTION_LEASE_TIME 51 /* RFC 2132 9.2, time in seconds, in 4 bytes */ +#define DHCP_OPTION_OVERLOAD 52 /* RFC2132 9.3, use file and/or sname field for options */ + +#define DHCP_OPTION_MESSAGE_TYPE 53 /* RFC 2132 9.6, important for DHCP */ +#define DHCP_OPTION_MESSAGE_TYPE_LEN 1 + +#define DHCP_OPTION_SERVER_ID 54 /* RFC 2132 9.7, server IP address */ +#define DHCP_OPTION_PARAMETER_REQUEST_LIST 55 /* RFC 2132 9.8, requested option types */ + +#define DHCP_OPTION_MAX_MSG_SIZE 57 /* RFC 2132 9.10, message size accepted >= 576 */ +#define DHCP_OPTION_MAX_MSG_SIZE_LEN 2 + +#define DHCP_OPTION_T1 58 /* T1 renewal time */ +#define DHCP_OPTION_T2 59 /* T2 rebinding time */ +#define DHCP_OPTION_US 60 +#define DHCP_OPTION_CLIENT_ID 61 +#define DHCP_OPTION_TFTP_SERVERNAME 66 +#define DHCP_OPTION_BOOTFILE 67 + +/* possible combinations of overloading the file and sname fields with options */ +#define DHCP_OVERLOAD_NONE 0 +#define DHCP_OVERLOAD_FILE 1 +#define DHCP_OVERLOAD_SNAME 2 +#define DHCP_OVERLOAD_SNAME_FILE 3 + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_DHCP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp6.h index 1be5f840..0754c91b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dhcp6.h @@ -1,138 +1,138 @@ -/** - * @file - * DHCPv6 protocol definitions - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_PROT_DHCP6_H -#define LWIP_HDR_PROT_DHCP6_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define DHCP6_CLIENT_PORT 546 -#define DHCP6_SERVER_PORT 547 - - - /* DHCPv6 message item offsets and length */ -#define DHCP6_TRANSACTION_ID_LEN 3 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** minimum set of fields of any DHCPv6 message */ -struct dhcp6_msg -{ - PACK_STRUCT_FLD_8(u8_t msgtype); - PACK_STRUCT_FLD_8(u8_t transaction_id[DHCP6_TRANSACTION_ID_LEN]); - /* options follow */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - - -/* DHCP6 client states */ -typedef enum { - DHCP6_STATE_OFF = 0, - DHCP6_STATE_STATELESS_IDLE = 1, - DHCP6_STATE_REQUESTING_CONFIG = 2 -} dhcp6_state_enum_t; - -/* DHCPv6 message types */ -#define DHCP6_SOLICIT 1 -#define DHCP6_ADVERTISE 2 -#define DHCP6_REQUEST 3 -#define DHCP6_CONFIRM 4 -#define DHCP6_RENEW 5 -#define DHCP6_REBIND 6 -#define DHCP6_REPLY 7 -#define DHCP6_RELEASE 8 -#define DHCP6_DECLINE 9 -#define DHCP6_RECONFIGURE 10 -#define DHCP6_INFOREQUEST 11 -#define DHCP6_RELAYFORW 12 -#define DHCP6_RELAYREPL 13 -/* More message types see https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml */ - -/** DHCPv6 status codes */ -#define DHCP6_STATUS_SUCCESS 0 /* Success. */ -#define DHCP6_STATUS_UNSPECFAIL 1 /* Failure, reason unspecified; this status code is sent by either a client or a server to indicate a failure not explicitly specified in this document. */ -#define DHCP6_STATUS_NOADDRSAVAIL 2 /* Server has no addresses available to assign to the IA(s). */ -#define DHCP6_STATUS_NOBINDING 3 /* Client record (binding) unavailable. */ -#define DHCP6_STATUS_NOTONLINK 4 /* The prefix for the address is not appropriate for the link to which the client is attached. */ -#define DHCP6_STATUS_USEMULTICAST 5 /* Sent by a server to a client to force the client to send messages to the server using the All_DHCP_Relay_Agents_and_Servers address. */ -/* More status codes see https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml */ - -/** DHCPv6 DUID types */ -#define DHCP6_DUID_LLT 1 /* LLT: Link-layer Address Plus Time */ -#define DHCP6_DUID_EN 2 /* EN: Enterprise number */ -#define DHCP6_DUID_LL 3 /* LL: Link-layer Address */ -#define DHCP6_DUID_UUID 4 /* UUID (RFC 6355) */ - -/* DHCPv6 options */ -#define DHCP6_OPTION_CLIENTID 1 -#define DHCP6_OPTION_SERVERID 2 -#define DHCP6_OPTION_IA_NA 3 -#define DHCP6_OPTION_IA_TA 4 -#define DHCP6_OPTION_IAADDR 5 -#define DHCP6_OPTION_ORO 6 -#define DHCP6_OPTION_PREFERENCE 7 -#define DHCP6_OPTION_ELAPSED_TIME 8 -#define DHCP6_OPTION_RELAY_MSG 9 -#define DHCP6_OPTION_AUTH 11 -#define DHCP6_OPTION_UNICAST 12 -#define DHCP6_OPTION_STATUS_CODE 13 -#define DHCP6_OPTION_RAPID_COMMIT 14 -#define DHCP6_OPTION_USER_CLASS 15 -#define DHCP6_OPTION_VENDOR_CLASS 16 -#define DHCP6_OPTION_VENDOR_OPTS 17 -#define DHCP6_OPTION_INTERFACE_ID 18 -#define DHCP6_OPTION_RECONF_MSG 19 -#define DHCP6_OPTION_RECONF_ACCEPT 20 -/* More options see https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml */ -#define DHCP6_OPTION_DNS_SERVERS 23 /* RFC 3646 */ -#define DHCP6_OPTION_DOMAIN_LIST 24 /* RFC 3646 */ -#define DHCP6_OPTION_SNTP_SERVERS 31 /* RFC 4075 */ - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_DHCP6_H */ +/** + * @file + * DHCPv6 protocol definitions + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_PROT_DHCP6_H +#define LWIP_HDR_PROT_DHCP6_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define DHCP6_CLIENT_PORT 546 +#define DHCP6_SERVER_PORT 547 + + + /* DHCPv6 message item offsets and length */ +#define DHCP6_TRANSACTION_ID_LEN 3 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** minimum set of fields of any DHCPv6 message */ +struct dhcp6_msg +{ + PACK_STRUCT_FLD_8(u8_t msgtype); + PACK_STRUCT_FLD_8(u8_t transaction_id[DHCP6_TRANSACTION_ID_LEN]); + /* options follow */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + + +/* DHCP6 client states */ +typedef enum { + DHCP6_STATE_OFF = 0, + DHCP6_STATE_STATELESS_IDLE = 1, + DHCP6_STATE_REQUESTING_CONFIG = 2 +} dhcp6_state_enum_t; + +/* DHCPv6 message types */ +#define DHCP6_SOLICIT 1 +#define DHCP6_ADVERTISE 2 +#define DHCP6_REQUEST 3 +#define DHCP6_CONFIRM 4 +#define DHCP6_RENEW 5 +#define DHCP6_REBIND 6 +#define DHCP6_REPLY 7 +#define DHCP6_RELEASE 8 +#define DHCP6_DECLINE 9 +#define DHCP6_RECONFIGURE 10 +#define DHCP6_INFOREQUEST 11 +#define DHCP6_RELAYFORW 12 +#define DHCP6_RELAYREPL 13 +/* More message types see https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml */ + +/** DHCPv6 status codes */ +#define DHCP6_STATUS_SUCCESS 0 /* Success. */ +#define DHCP6_STATUS_UNSPECFAIL 1 /* Failure, reason unspecified; this status code is sent by either a client or a server to indicate a failure not explicitly specified in this document. */ +#define DHCP6_STATUS_NOADDRSAVAIL 2 /* Server has no addresses available to assign to the IA(s). */ +#define DHCP6_STATUS_NOBINDING 3 /* Client record (binding) unavailable. */ +#define DHCP6_STATUS_NOTONLINK 4 /* The prefix for the address is not appropriate for the link to which the client is attached. */ +#define DHCP6_STATUS_USEMULTICAST 5 /* Sent by a server to a client to force the client to send messages to the server using the All_DHCP_Relay_Agents_and_Servers address. */ +/* More status codes see https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml */ + +/** DHCPv6 DUID types */ +#define DHCP6_DUID_LLT 1 /* LLT: Link-layer Address Plus Time */ +#define DHCP6_DUID_EN 2 /* EN: Enterprise number */ +#define DHCP6_DUID_LL 3 /* LL: Link-layer Address */ +#define DHCP6_DUID_UUID 4 /* UUID (RFC 6355) */ + +/* DHCPv6 options */ +#define DHCP6_OPTION_CLIENTID 1 +#define DHCP6_OPTION_SERVERID 2 +#define DHCP6_OPTION_IA_NA 3 +#define DHCP6_OPTION_IA_TA 4 +#define DHCP6_OPTION_IAADDR 5 +#define DHCP6_OPTION_ORO 6 +#define DHCP6_OPTION_PREFERENCE 7 +#define DHCP6_OPTION_ELAPSED_TIME 8 +#define DHCP6_OPTION_RELAY_MSG 9 +#define DHCP6_OPTION_AUTH 11 +#define DHCP6_OPTION_UNICAST 12 +#define DHCP6_OPTION_STATUS_CODE 13 +#define DHCP6_OPTION_RAPID_COMMIT 14 +#define DHCP6_OPTION_USER_CLASS 15 +#define DHCP6_OPTION_VENDOR_CLASS 16 +#define DHCP6_OPTION_VENDOR_OPTS 17 +#define DHCP6_OPTION_INTERFACE_ID 18 +#define DHCP6_OPTION_RECONF_MSG 19 +#define DHCP6_OPTION_RECONF_ACCEPT 20 +/* More options see https://www.iana.org/assignments/dhcpv6-parameters/dhcpv6-parameters.xhtml */ +#define DHCP6_OPTION_DNS_SERVERS 23 /* RFC 3646 */ +#define DHCP6_OPTION_DOMAIN_LIST 24 /* RFC 3646 */ +#define DHCP6_OPTION_SNTP_SERVERS 31 /* RFC 4075 */ + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_DHCP6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dns.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dns.h index 022a32c1..94782d6e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dns.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/dns.h @@ -1,140 +1,140 @@ -/** - * @file - * DNS - host name to IP address resolver. - */ - -/* - * Port to lwIP from uIP - * by Jim Pettinato April 2007 - * - * security fixes and more by Simon Goldschmidt - * - * uIP version Copyright (c) 2002-2003, Adam Dunkels. - * 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. The name of the author may not be used to endorse or promote - * products derived from this software without specific prior - * written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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_PROT_DNS_H -#define LWIP_HDR_PROT_DNS_H - -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** DNS server port address */ -#ifndef DNS_SERVER_PORT -#define DNS_SERVER_PORT 53 -#endif - -/* DNS field TYPE used for "Resource Records" */ -#define DNS_RRTYPE_A 1 /* a host address */ -#define DNS_RRTYPE_NS 2 /* an authoritative name server */ -#define DNS_RRTYPE_MD 3 /* a mail destination (Obsolete - use MX) */ -#define DNS_RRTYPE_MF 4 /* a mail forwarder (Obsolete - use MX) */ -#define DNS_RRTYPE_CNAME 5 /* the canonical name for an alias */ -#define DNS_RRTYPE_SOA 6 /* marks the start of a zone of authority */ -#define DNS_RRTYPE_MB 7 /* a mailbox domain name (EXPERIMENTAL) */ -#define DNS_RRTYPE_MG 8 /* a mail group member (EXPERIMENTAL) */ -#define DNS_RRTYPE_MR 9 /* a mail rename domain name (EXPERIMENTAL) */ -#define DNS_RRTYPE_NULL 10 /* a null RR (EXPERIMENTAL) */ -#define DNS_RRTYPE_WKS 11 /* a well known service description */ -#define DNS_RRTYPE_PTR 12 /* a domain name pointer */ -#define DNS_RRTYPE_HINFO 13 /* host information */ -#define DNS_RRTYPE_MINFO 14 /* mailbox or mail list information */ -#define DNS_RRTYPE_MX 15 /* mail exchange */ -#define DNS_RRTYPE_TXT 16 /* text strings */ -#define DNS_RRTYPE_AAAA 28 /* IPv6 address */ -#define DNS_RRTYPE_SRV 33 /* service location */ -#define DNS_RRTYPE_ANY 255 /* any type */ - -/* DNS field CLASS used for "Resource Records" */ -#define DNS_RRCLASS_IN 1 /* the Internet */ -#define DNS_RRCLASS_CS 2 /* the CSNET class (Obsolete - used only for examples in some obsolete RFCs) */ -#define DNS_RRCLASS_CH 3 /* the CHAOS class */ -#define DNS_RRCLASS_HS 4 /* Hesiod [Dyer 87] */ -#define DNS_RRCLASS_ANY 255 /* any class */ -#define DNS_RRCLASS_FLUSH 0x800 /* Flush bit */ - -/* DNS protocol flags */ -#define DNS_FLAG1_RESPONSE 0x80 -#define DNS_FLAG1_OPCODE_STATUS 0x10 -#define DNS_FLAG1_OPCODE_INVERSE 0x08 -#define DNS_FLAG1_OPCODE_STANDARD 0x00 -#define DNS_FLAG1_AUTHORATIVE 0x04 -#define DNS_FLAG1_TRUNC 0x02 -#define DNS_FLAG1_RD 0x01 -#define DNS_FLAG2_RA 0x80 -#define DNS_FLAG2_ERR_MASK 0x0f -#define DNS_FLAG2_ERR_NONE 0x00 -#define DNS_FLAG2_ERR_NAME 0x03 - -#define DNS_HDR_GET_OPCODE(hdr) ((((hdr)->flags1) >> 3) & 0xF) - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** DNS message header */ -struct dns_hdr { - PACK_STRUCT_FIELD(u16_t id); - PACK_STRUCT_FLD_8(u8_t flags1); - PACK_STRUCT_FLD_8(u8_t flags2); - PACK_STRUCT_FIELD(u16_t numquestions); - PACK_STRUCT_FIELD(u16_t numanswers); - PACK_STRUCT_FIELD(u16_t numauthrr); - PACK_STRUCT_FIELD(u16_t numextrarr); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define SIZEOF_DNS_HDR 12 - - -/* Multicast DNS definitions */ - -/** UDP port for multicast DNS queries */ -#ifndef DNS_MQUERY_PORT -#define DNS_MQUERY_PORT 5353 -#endif - -/* IPv4 group for multicast DNS queries: 224.0.0.251 */ -#ifndef DNS_MQUERY_IPV4_GROUP_INIT -#define DNS_MQUERY_IPV4_GROUP_INIT IPADDR4_INIT_BYTES(224,0,0,251) -#endif - -/* IPv6 group for multicast DNS queries: FF02::FB */ -#ifndef DNS_MQUERY_IPV6_GROUP_INIT -#define DNS_MQUERY_IPV6_GROUP_INIT IPADDR6_INIT_HOST(0xFF020000,0,0,0xFB) -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_DNS_H */ +/** + * @file + * DNS - host name to IP address resolver. + */ + +/* + * Port to lwIP from uIP + * by Jim Pettinato April 2007 + * + * security fixes and more by Simon Goldschmidt + * + * uIP version Copyright (c) 2002-2003, Adam Dunkels. + * 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. The name of the author may not be used to endorse or promote + * products derived from this software without specific prior + * written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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_PROT_DNS_H +#define LWIP_HDR_PROT_DNS_H + +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** DNS server port address */ +#ifndef DNS_SERVER_PORT +#define DNS_SERVER_PORT 53 +#endif + +/* DNS field TYPE used for "Resource Records" */ +#define DNS_RRTYPE_A 1 /* a host address */ +#define DNS_RRTYPE_NS 2 /* an authoritative name server */ +#define DNS_RRTYPE_MD 3 /* a mail destination (Obsolete - use MX) */ +#define DNS_RRTYPE_MF 4 /* a mail forwarder (Obsolete - use MX) */ +#define DNS_RRTYPE_CNAME 5 /* the canonical name for an alias */ +#define DNS_RRTYPE_SOA 6 /* marks the start of a zone of authority */ +#define DNS_RRTYPE_MB 7 /* a mailbox domain name (EXPERIMENTAL) */ +#define DNS_RRTYPE_MG 8 /* a mail group member (EXPERIMENTAL) */ +#define DNS_RRTYPE_MR 9 /* a mail rename domain name (EXPERIMENTAL) */ +#define DNS_RRTYPE_NULL 10 /* a null RR (EXPERIMENTAL) */ +#define DNS_RRTYPE_WKS 11 /* a well known service description */ +#define DNS_RRTYPE_PTR 12 /* a domain name pointer */ +#define DNS_RRTYPE_HINFO 13 /* host information */ +#define DNS_RRTYPE_MINFO 14 /* mailbox or mail list information */ +#define DNS_RRTYPE_MX 15 /* mail exchange */ +#define DNS_RRTYPE_TXT 16 /* text strings */ +#define DNS_RRTYPE_AAAA 28 /* IPv6 address */ +#define DNS_RRTYPE_SRV 33 /* service location */ +#define DNS_RRTYPE_ANY 255 /* any type */ + +/* DNS field CLASS used for "Resource Records" */ +#define DNS_RRCLASS_IN 1 /* the Internet */ +#define DNS_RRCLASS_CS 2 /* the CSNET class (Obsolete - used only for examples in some obsolete RFCs) */ +#define DNS_RRCLASS_CH 3 /* the CHAOS class */ +#define DNS_RRCLASS_HS 4 /* Hesiod [Dyer 87] */ +#define DNS_RRCLASS_ANY 255 /* any class */ +#define DNS_RRCLASS_FLUSH 0x800 /* Flush bit */ + +/* DNS protocol flags */ +#define DNS_FLAG1_RESPONSE 0x80 +#define DNS_FLAG1_OPCODE_STATUS 0x10 +#define DNS_FLAG1_OPCODE_INVERSE 0x08 +#define DNS_FLAG1_OPCODE_STANDARD 0x00 +#define DNS_FLAG1_AUTHORATIVE 0x04 +#define DNS_FLAG1_TRUNC 0x02 +#define DNS_FLAG1_RD 0x01 +#define DNS_FLAG2_RA 0x80 +#define DNS_FLAG2_ERR_MASK 0x0f +#define DNS_FLAG2_ERR_NONE 0x00 +#define DNS_FLAG2_ERR_NAME 0x03 + +#define DNS_HDR_GET_OPCODE(hdr) ((((hdr)->flags1) >> 3) & 0xF) + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** DNS message header */ +struct dns_hdr { + PACK_STRUCT_FIELD(u16_t id); + PACK_STRUCT_FLD_8(u8_t flags1); + PACK_STRUCT_FLD_8(u8_t flags2); + PACK_STRUCT_FIELD(u16_t numquestions); + PACK_STRUCT_FIELD(u16_t numanswers); + PACK_STRUCT_FIELD(u16_t numauthrr); + PACK_STRUCT_FIELD(u16_t numextrarr); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define SIZEOF_DNS_HDR 12 + + +/* Multicast DNS definitions */ + +/** UDP port for multicast DNS queries */ +#ifndef DNS_MQUERY_PORT +#define DNS_MQUERY_PORT 5353 +#endif + +/* IPv4 group for multicast DNS queries: 224.0.0.251 */ +#ifndef DNS_MQUERY_IPV4_GROUP_INIT +#define DNS_MQUERY_IPV4_GROUP_INIT IPADDR4_INIT_BYTES(224,0,0,251) +#endif + +/* IPv6 group for multicast DNS queries: FF02::FB */ +#ifndef DNS_MQUERY_IPV6_GROUP_INIT +#define DNS_MQUERY_IPV6_GROUP_INIT IPADDR6_INIT_HOST(0xFF020000,0,0,0xFB) +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_DNS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/etharp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/etharp.h index 9e4b02c6..811c2284 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/etharp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/etharp.h @@ -1,114 +1,114 @@ -/** - * @file - * ARP protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_ETHARP_H -#define LWIP_HDR_PROT_ETHARP_H - -#include "lwip/arch.h" -#include "lwip/prot/ethernet.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef ETHARP_HWADDR_LEN -#define ETHARP_HWADDR_LEN ETH_HWADDR_LEN -#endif - -/** - * struct ip4_addr_wordaligned is used in the definition of the ARP packet format in - * order to support compilers that don't have structure packing. - */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip4_addr_wordaligned { - PACK_STRUCT_FIELD(u16_t addrw[2]); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** MEMCPY-like copying of IP addresses where addresses are known to be - * 16-bit-aligned if the port is correctly configured (so a port could define - * this to copying 2 u16_t's) - no NULL-pointer-checking needed. */ -#ifndef IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T -#define IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(dest, src) SMEMCPY(dest, src, sizeof(ip4_addr_t)) -#endif - - /** MEMCPY-like copying of IP addresses where addresses are known to be - * 16-bit-aligned if the port is correctly configured (so a port could define - * this to copying 2 u16_t's) - no NULL-pointer-checking needed. */ -#ifndef IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T -#define IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(dest, src) SMEMCPY(dest, src, sizeof(ip4_addr_t)) -#endif - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** the ARP message, see RFC 826 ("Packet format") */ -struct etharp_hdr { - PACK_STRUCT_FIELD(u16_t hwtype); - PACK_STRUCT_FIELD(u16_t proto); - PACK_STRUCT_FLD_8(u8_t hwlen); - PACK_STRUCT_FLD_8(u8_t protolen); - PACK_STRUCT_FIELD(u16_t opcode); - PACK_STRUCT_FLD_S(struct eth_addr shwaddr); - PACK_STRUCT_FLD_S(struct ip4_addr_wordaligned sipaddr); - PACK_STRUCT_FLD_S(struct eth_addr dhwaddr); - PACK_STRUCT_FLD_S(struct ip4_addr_wordaligned dipaddr); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#define SIZEOF_ETHARP_HDR 28 - -/* ARP message types (opcodes) */ -enum etharp_opcode { - ARP_REQUEST = 1, - ARP_REPLY = 2 -}; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_ETHARP_H */ +/** + * @file + * ARP protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_ETHARP_H +#define LWIP_HDR_PROT_ETHARP_H + +#include "lwip/arch.h" +#include "lwip/prot/ethernet.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef ETHARP_HWADDR_LEN +#define ETHARP_HWADDR_LEN ETH_HWADDR_LEN +#endif + +/** + * struct ip4_addr_wordaligned is used in the definition of the ARP packet format in + * order to support compilers that don't have structure packing. + */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip4_addr_wordaligned { + PACK_STRUCT_FIELD(u16_t addrw[2]); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** MEMCPY-like copying of IP addresses where addresses are known to be + * 16-bit-aligned if the port is correctly configured (so a port could define + * this to copying 2 u16_t's) - no NULL-pointer-checking needed. */ +#ifndef IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T +#define IPADDR_WORDALIGNED_COPY_TO_IP4_ADDR_T(dest, src) SMEMCPY(dest, src, sizeof(ip4_addr_t)) +#endif + + /** MEMCPY-like copying of IP addresses where addresses are known to be + * 16-bit-aligned if the port is correctly configured (so a port could define + * this to copying 2 u16_t's) - no NULL-pointer-checking needed. */ +#ifndef IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T +#define IPADDR_WORDALIGNED_COPY_FROM_IP4_ADDR_T(dest, src) SMEMCPY(dest, src, sizeof(ip4_addr_t)) +#endif + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** the ARP message, see RFC 826 ("Packet format") */ +struct etharp_hdr { + PACK_STRUCT_FIELD(u16_t hwtype); + PACK_STRUCT_FIELD(u16_t proto); + PACK_STRUCT_FLD_8(u8_t hwlen); + PACK_STRUCT_FLD_8(u8_t protolen); + PACK_STRUCT_FIELD(u16_t opcode); + PACK_STRUCT_FLD_S(struct eth_addr shwaddr); + PACK_STRUCT_FLD_S(struct ip4_addr_wordaligned sipaddr); + PACK_STRUCT_FLD_S(struct eth_addr dhwaddr); + PACK_STRUCT_FLD_S(struct ip4_addr_wordaligned dipaddr); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#define SIZEOF_ETHARP_HDR 28 + +/* ARP message types (opcodes) */ +enum etharp_opcode { + ARP_REQUEST = 1, + ARP_REPLY = 2 +}; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_ETHARP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ethernet.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ethernet.h index fef49e2a..309e5746 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ethernet.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ethernet.h @@ -1,125 +1,125 @@ -/** - * @file - * Ethernet protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_ETHERNET_H -#define LWIP_HDR_PROT_ETHERNET_H - -#include "lwip/arch.h" -#include "lwip/prot/ieee.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef ETH_HWADDR_LEN -#ifdef ETHARP_HWADDR_LEN -#define ETH_HWADDR_LEN ETHARP_HWADDR_LEN /* compatibility mode */ -#else -#define ETH_HWADDR_LEN 6 -#endif -#endif - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** An Ethernet MAC address */ -struct eth_addr { - PACK_STRUCT_FLD_8(u8_t addr[ETH_HWADDR_LEN]); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Initialize a struct eth_addr with its 6 bytes (takes care of correct braces) */ -#define ETH_ADDR(b0, b1, b2, b3, b4, b5) {{b0, b1, b2, b3, b4, b5}} - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** Ethernet header */ -struct eth_hdr { -#if ETH_PAD_SIZE - PACK_STRUCT_FLD_8(u8_t padding[ETH_PAD_SIZE]); -#endif - PACK_STRUCT_FLD_S(struct eth_addr dest); - PACK_STRUCT_FLD_S(struct eth_addr src); - PACK_STRUCT_FIELD(u16_t type); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#define SIZEOF_ETH_HDR (14 + ETH_PAD_SIZE) - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** VLAN header inserted between ethernet header and payload - * if 'type' in ethernet header is ETHTYPE_VLAN. - * See IEEE802.Q */ -struct eth_vlan_hdr { - PACK_STRUCT_FIELD(u16_t prio_vid); - PACK_STRUCT_FIELD(u16_t tpid); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#define SIZEOF_VLAN_HDR 4 -#define VLAN_ID(vlan_hdr) (lwip_htons((vlan_hdr)->prio_vid) & 0xFFF) - -/** The 24-bit IANA IPv4-multicast OUI is 01-00-5e: */ -#define LL_IP4_MULTICAST_ADDR_0 0x01 -#define LL_IP4_MULTICAST_ADDR_1 0x00 -#define LL_IP4_MULTICAST_ADDR_2 0x5e - -/** IPv6 multicast uses this prefix */ -#define LL_IP6_MULTICAST_ADDR_0 0x33 -#define LL_IP6_MULTICAST_ADDR_1 0x33 - -#define eth_addr_cmp(addr1, addr2) (memcmp((addr1)->addr, (addr2)->addr, ETH_HWADDR_LEN) == 0) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_ETHERNET_H */ +/** + * @file + * Ethernet protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_ETHERNET_H +#define LWIP_HDR_PROT_ETHERNET_H + +#include "lwip/arch.h" +#include "lwip/prot/ieee.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef ETH_HWADDR_LEN +#ifdef ETHARP_HWADDR_LEN +#define ETH_HWADDR_LEN ETHARP_HWADDR_LEN /* compatibility mode */ +#else +#define ETH_HWADDR_LEN 6 +#endif +#endif + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** An Ethernet MAC address */ +struct eth_addr { + PACK_STRUCT_FLD_8(u8_t addr[ETH_HWADDR_LEN]); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Initialize a struct eth_addr with its 6 bytes (takes care of correct braces) */ +#define ETH_ADDR(b0, b1, b2, b3, b4, b5) {{b0, b1, b2, b3, b4, b5}} + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** Ethernet header */ +struct eth_hdr { +#if ETH_PAD_SIZE + PACK_STRUCT_FLD_8(u8_t padding[ETH_PAD_SIZE]); +#endif + PACK_STRUCT_FLD_S(struct eth_addr dest); + PACK_STRUCT_FLD_S(struct eth_addr src); + PACK_STRUCT_FIELD(u16_t type); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#define SIZEOF_ETH_HDR (14 + ETH_PAD_SIZE) + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** VLAN header inserted between ethernet header and payload + * if 'type' in ethernet header is ETHTYPE_VLAN. + * See IEEE802.Q */ +struct eth_vlan_hdr { + PACK_STRUCT_FIELD(u16_t prio_vid); + PACK_STRUCT_FIELD(u16_t tpid); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#define SIZEOF_VLAN_HDR 4 +#define VLAN_ID(vlan_hdr) (lwip_htons((vlan_hdr)->prio_vid) & 0xFFF) + +/** The 24-bit IANA IPv4-multicast OUI is 01-00-5e: */ +#define LL_IP4_MULTICAST_ADDR_0 0x01 +#define LL_IP4_MULTICAST_ADDR_1 0x00 +#define LL_IP4_MULTICAST_ADDR_2 0x5e + +/** IPv6 multicast uses this prefix */ +#define LL_IP6_MULTICAST_ADDR_0 0x33 +#define LL_IP6_MULTICAST_ADDR_1 0x33 + +#define eth_addr_cmp(addr1, addr2) (memcmp((addr1)->addr, (addr2)->addr, ETH_HWADDR_LEN) == 0) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_ETHERNET_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/iana.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/iana.h index 859d238d..32890ccc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/iana.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/iana.h @@ -1,97 +1,97 @@ -/** - * @file - * IANA assigned numbers (RFC 1700 and successors) - * - * @defgroup iana IANA assigned numbers - * @ingroup infrastructure - */ - -/* - * Copyright (c) 2017 Dirk Ziegelmeier. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Dirk Ziegelmeier - * - */ - -#ifndef LWIP_HDR_PROT_IANA_H -#define LWIP_HDR_PROT_IANA_H - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @ingroup iana - * Hardware types - */ -enum lwip_iana_hwtype { - /** Ethernet */ - LWIP_IANA_HWTYPE_ETHERNET = 1 -}; - -/** - * @ingroup iana - * Port numbers - * https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt - */ -enum lwip_iana_port_number { - /** SMTP */ - LWIP_IANA_PORT_SMTP = 25, - /** DHCP server */ - LWIP_IANA_PORT_DHCP_SERVER = 67, - /** DHCP client */ - LWIP_IANA_PORT_DHCP_CLIENT = 68, - /** TFTP */ - LWIP_IANA_PORT_TFTP = 69, - /** HTTP */ - LWIP_IANA_PORT_HTTP = 80, - /** SNTP */ - LWIP_IANA_PORT_SNTP = 123, - /** NETBIOS */ - LWIP_IANA_PORT_NETBIOS = 137, - /** SNMP */ - LWIP_IANA_PORT_SNMP = 161, - /** SNMP traps */ - LWIP_IANA_PORT_SNMP_TRAP = 162, - /** HTTPS */ - LWIP_IANA_PORT_HTTPS = 443, - /** SMTPS */ - LWIP_IANA_PORT_SMTPS = 465, - /** MQTT */ - LWIP_IANA_PORT_MQTT = 1883, - /** MDNS */ - LWIP_IANA_PORT_MDNS = 5353, - /** Secure MQTT */ - LWIP_IANA_PORT_SECURE_MQTT = 8883 -}; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_IANA_H */ +/** + * @file + * IANA assigned numbers (RFC 1700 and successors) + * + * @defgroup iana IANA assigned numbers + * @ingroup infrastructure + */ + +/* + * Copyright (c) 2017 Dirk Ziegelmeier. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Dirk Ziegelmeier + * + */ + +#ifndef LWIP_HDR_PROT_IANA_H +#define LWIP_HDR_PROT_IANA_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @ingroup iana + * Hardware types + */ +enum lwip_iana_hwtype { + /** Ethernet */ + LWIP_IANA_HWTYPE_ETHERNET = 1 +}; + +/** + * @ingroup iana + * Port numbers + * https://www.iana.org/assignments/service-names-port-numbers/service-names-port-numbers.txt + */ +enum lwip_iana_port_number { + /** SMTP */ + LWIP_IANA_PORT_SMTP = 25, + /** DHCP server */ + LWIP_IANA_PORT_DHCP_SERVER = 67, + /** DHCP client */ + LWIP_IANA_PORT_DHCP_CLIENT = 68, + /** TFTP */ + LWIP_IANA_PORT_TFTP = 69, + /** HTTP */ + LWIP_IANA_PORT_HTTP = 80, + /** SNTP */ + LWIP_IANA_PORT_SNTP = 123, + /** NETBIOS */ + LWIP_IANA_PORT_NETBIOS = 137, + /** SNMP */ + LWIP_IANA_PORT_SNMP = 161, + /** SNMP traps */ + LWIP_IANA_PORT_SNMP_TRAP = 162, + /** HTTPS */ + LWIP_IANA_PORT_HTTPS = 443, + /** SMTPS */ + LWIP_IANA_PORT_SMTPS = 465, + /** MQTT */ + LWIP_IANA_PORT_MQTT = 1883, + /** MDNS */ + LWIP_IANA_PORT_MDNS = 5353, + /** Secure MQTT */ + LWIP_IANA_PORT_SECURE_MQTT = 8883 +}; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_IANA_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp.h index d8183fd3..7d19385c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp.h @@ -1,91 +1,91 @@ -/** - * @file - * ICMP protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_ICMP_H -#define LWIP_HDR_PROT_ICMP_H - -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define ICMP_ER 0 /* echo reply */ -#define ICMP_DUR 3 /* destination unreachable */ -#define ICMP_SQ 4 /* source quench */ -#define ICMP_RD 5 /* redirect */ -#define ICMP_ECHO 8 /* echo */ -#define ICMP_TE 11 /* time exceeded */ -#define ICMP_PP 12 /* parameter problem */ -#define ICMP_TS 13 /* timestamp */ -#define ICMP_TSR 14 /* timestamp reply */ -#define ICMP_IRQ 15 /* information request */ -#define ICMP_IR 16 /* information reply */ -#define ICMP_AM 17 /* address mask request */ -#define ICMP_AMR 18 /* address mask reply */ - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -/** This is the standard ICMP header only that the u32_t data - * is split to two u16_t like ICMP echo needs it. - * This header is also used for other ICMP types that do not - * use the data part. - */ -PACK_STRUCT_BEGIN -struct icmp_echo_hdr { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u16_t id); - PACK_STRUCT_FIELD(u16_t seqno); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/* Compatibility defines, old versions used to combine type and code to an u16_t */ -#define ICMPH_TYPE(hdr) ((hdr)->type) -#define ICMPH_CODE(hdr) ((hdr)->code) -#define ICMPH_TYPE_SET(hdr, t) ((hdr)->type = (t)) -#define ICMPH_CODE_SET(hdr, c) ((hdr)->code = (c)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_ICMP_H */ +/** + * @file + * ICMP protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_ICMP_H +#define LWIP_HDR_PROT_ICMP_H + +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ICMP_ER 0 /* echo reply */ +#define ICMP_DUR 3 /* destination unreachable */ +#define ICMP_SQ 4 /* source quench */ +#define ICMP_RD 5 /* redirect */ +#define ICMP_ECHO 8 /* echo */ +#define ICMP_TE 11 /* time exceeded */ +#define ICMP_PP 12 /* parameter problem */ +#define ICMP_TS 13 /* timestamp */ +#define ICMP_TSR 14 /* timestamp reply */ +#define ICMP_IRQ 15 /* information request */ +#define ICMP_IR 16 /* information reply */ +#define ICMP_AM 17 /* address mask request */ +#define ICMP_AMR 18 /* address mask reply */ + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +/** This is the standard ICMP header only that the u32_t data + * is split to two u16_t like ICMP echo needs it. + * This header is also used for other ICMP types that do not + * use the data part. + */ +PACK_STRUCT_BEGIN +struct icmp_echo_hdr { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u16_t id); + PACK_STRUCT_FIELD(u16_t seqno); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/* Compatibility defines, old versions used to combine type and code to an u16_t */ +#define ICMPH_TYPE(hdr) ((hdr)->type) +#define ICMPH_CODE(hdr) ((hdr)->code) +#define ICMPH_TYPE_SET(hdr, t) ((hdr)->type = (t)) +#define ICMPH_CODE_SET(hdr, c) ((hdr)->code = (c)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_ICMP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp6.h index b1c6d56b..34611204 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/icmp6.h @@ -1,170 +1,170 @@ -/** - * @file - * ICMP6 protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_ICMP6_H -#define LWIP_HDR_PROT_ICMP6_H - -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** ICMP type */ -enum icmp6_type { - /** Destination unreachable */ - ICMP6_TYPE_DUR = 1, - /** Packet too big */ - ICMP6_TYPE_PTB = 2, - /** Time exceeded */ - ICMP6_TYPE_TE = 3, - /** Parameter problem */ - ICMP6_TYPE_PP = 4, - /** Private experimentation */ - ICMP6_TYPE_PE1 = 100, - /** Private experimentation */ - ICMP6_TYPE_PE2 = 101, - /** Reserved for expansion of error messages */ - ICMP6_TYPE_RSV_ERR = 127, - - /** Echo request */ - ICMP6_TYPE_EREQ = 128, - /** Echo reply */ - ICMP6_TYPE_EREP = 129, - /** Multicast listener query */ - ICMP6_TYPE_MLQ = 130, - /** Multicast listener report */ - ICMP6_TYPE_MLR = 131, - /** Multicast listener done */ - ICMP6_TYPE_MLD = 132, - /** Router solicitation */ - ICMP6_TYPE_RS = 133, - /** Router advertisement */ - ICMP6_TYPE_RA = 134, - /** Neighbor solicitation */ - ICMP6_TYPE_NS = 135, - /** Neighbor advertisement */ - ICMP6_TYPE_NA = 136, - /** Redirect */ - ICMP6_TYPE_RD = 137, - /** Multicast router advertisement */ - ICMP6_TYPE_MRA = 151, - /** Multicast router solicitation */ - ICMP6_TYPE_MRS = 152, - /** Multicast router termination */ - ICMP6_TYPE_MRT = 153, - /** Private experimentation */ - ICMP6_TYPE_PE3 = 200, - /** Private experimentation */ - ICMP6_TYPE_PE4 = 201, - /** Reserved for expansion of informational messages */ - ICMP6_TYPE_RSV_INF = 255 -}; - -/** ICMP destination unreachable codes */ -enum icmp6_dur_code { - /** No route to destination */ - ICMP6_DUR_NO_ROUTE = 0, - /** Communication with destination administratively prohibited */ - ICMP6_DUR_PROHIBITED = 1, - /** Beyond scope of source address */ - ICMP6_DUR_SCOPE = 2, - /** Address unreachable */ - ICMP6_DUR_ADDRESS = 3, - /** Port unreachable */ - ICMP6_DUR_PORT = 4, - /** Source address failed ingress/egress policy */ - ICMP6_DUR_POLICY = 5, - /** Reject route to destination */ - ICMP6_DUR_REJECT_ROUTE = 6 -}; - -/** ICMP time exceeded codes */ -enum icmp6_te_code { - /** Hop limit exceeded in transit */ - ICMP6_TE_HL = 0, - /** Fragment reassembly time exceeded */ - ICMP6_TE_FRAG = 1 -}; - -/** ICMP parameter code */ -enum icmp6_pp_code { - /** Erroneous header field encountered */ - ICMP6_PP_FIELD = 0, - /** Unrecognized next header type encountered */ - ICMP6_PP_HEADER = 1, - /** Unrecognized IPv6 option encountered */ - ICMP6_PP_OPTION = 2 -}; - -/** This is the standard ICMP6 header. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct icmp6_hdr { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u32_t data); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** This is the ICMP6 header adapted for echo req/resp. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct icmp6_echo_hdr { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u16_t id); - PACK_STRUCT_FIELD(u16_t seqno); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_ICMP6_H */ +/** + * @file + * ICMP6 protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_ICMP6_H +#define LWIP_HDR_PROT_ICMP6_H + +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** ICMP type */ +enum icmp6_type { + /** Destination unreachable */ + ICMP6_TYPE_DUR = 1, + /** Packet too big */ + ICMP6_TYPE_PTB = 2, + /** Time exceeded */ + ICMP6_TYPE_TE = 3, + /** Parameter problem */ + ICMP6_TYPE_PP = 4, + /** Private experimentation */ + ICMP6_TYPE_PE1 = 100, + /** Private experimentation */ + ICMP6_TYPE_PE2 = 101, + /** Reserved for expansion of error messages */ + ICMP6_TYPE_RSV_ERR = 127, + + /** Echo request */ + ICMP6_TYPE_EREQ = 128, + /** Echo reply */ + ICMP6_TYPE_EREP = 129, + /** Multicast listener query */ + ICMP6_TYPE_MLQ = 130, + /** Multicast listener report */ + ICMP6_TYPE_MLR = 131, + /** Multicast listener done */ + ICMP6_TYPE_MLD = 132, + /** Router solicitation */ + ICMP6_TYPE_RS = 133, + /** Router advertisement */ + ICMP6_TYPE_RA = 134, + /** Neighbor solicitation */ + ICMP6_TYPE_NS = 135, + /** Neighbor advertisement */ + ICMP6_TYPE_NA = 136, + /** Redirect */ + ICMP6_TYPE_RD = 137, + /** Multicast router advertisement */ + ICMP6_TYPE_MRA = 151, + /** Multicast router solicitation */ + ICMP6_TYPE_MRS = 152, + /** Multicast router termination */ + ICMP6_TYPE_MRT = 153, + /** Private experimentation */ + ICMP6_TYPE_PE3 = 200, + /** Private experimentation */ + ICMP6_TYPE_PE4 = 201, + /** Reserved for expansion of informational messages */ + ICMP6_TYPE_RSV_INF = 255 +}; + +/** ICMP destination unreachable codes */ +enum icmp6_dur_code { + /** No route to destination */ + ICMP6_DUR_NO_ROUTE = 0, + /** Communication with destination administratively prohibited */ + ICMP6_DUR_PROHIBITED = 1, + /** Beyond scope of source address */ + ICMP6_DUR_SCOPE = 2, + /** Address unreachable */ + ICMP6_DUR_ADDRESS = 3, + /** Port unreachable */ + ICMP6_DUR_PORT = 4, + /** Source address failed ingress/egress policy */ + ICMP6_DUR_POLICY = 5, + /** Reject route to destination */ + ICMP6_DUR_REJECT_ROUTE = 6 +}; + +/** ICMP time exceeded codes */ +enum icmp6_te_code { + /** Hop limit exceeded in transit */ + ICMP6_TE_HL = 0, + /** Fragment reassembly time exceeded */ + ICMP6_TE_FRAG = 1 +}; + +/** ICMP parameter code */ +enum icmp6_pp_code { + /** Erroneous header field encountered */ + ICMP6_PP_FIELD = 0, + /** Unrecognized next header type encountered */ + ICMP6_PP_HEADER = 1, + /** Unrecognized IPv6 option encountered */ + ICMP6_PP_OPTION = 2 +}; + +/** This is the standard ICMP6 header. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct icmp6_hdr { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u32_t data); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** This is the ICMP6 header adapted for echo req/resp. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct icmp6_echo_hdr { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u16_t id); + PACK_STRUCT_FIELD(u16_t seqno); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_ICMP6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ieee.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ieee.h index ef651b15..abbb9e31 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ieee.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ieee.h @@ -1,91 +1,91 @@ -/** - * @file - * IEEE assigned numbers - * - * @defgroup ieee IEEE assigned numbers - * @ingroup infrastructure - */ - -/* - * Copyright (c) 2017 Dirk Ziegelmeier. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Dirk Ziegelmeier - * - */ - -#ifndef LWIP_HDR_PROT_IEEE_H -#define LWIP_HDR_PROT_IEEE_H - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @ingroup ieee - * A list of often ethtypes (although lwIP does not use all of them). - */ -enum lwip_ieee_eth_type { - /** Internet protocol v4 */ - ETHTYPE_IP = 0x0800U, - /** Address resolution protocol */ - ETHTYPE_ARP = 0x0806U, - /** Wake on lan */ - ETHTYPE_WOL = 0x0842U, - /** RARP */ - ETHTYPE_RARP = 0x8035U, - /** Virtual local area network */ - ETHTYPE_VLAN = 0x8100U, - /** Internet protocol v6 */ - ETHTYPE_IPV6 = 0x86DDU, - /** PPP Over Ethernet Discovery Stage */ - ETHTYPE_PPPOEDISC = 0x8863U, - /** PPP Over Ethernet Session Stage */ - ETHTYPE_PPPOE = 0x8864U, - /** Jumbo Frames */ - ETHTYPE_JUMBO = 0x8870U, - /** Process field network */ - ETHTYPE_PROFINET = 0x8892U, - /** Ethernet for control automation technology */ - ETHTYPE_ETHERCAT = 0x88A4U, - /** Link layer discovery protocol */ - ETHTYPE_LLDP = 0x88CCU, - /** Serial real-time communication system */ - ETHTYPE_SERCOS = 0x88CDU, - /** Media redundancy protocol */ - ETHTYPE_MRP = 0x88E3U, - /** Precision time protocol */ - ETHTYPE_PTP = 0x88F7U, - /** Q-in-Q, 802.1ad */ - ETHTYPE_QINQ = 0x9100U -}; - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_IEEE_H */ +/** + * @file + * IEEE assigned numbers + * + * @defgroup ieee IEEE assigned numbers + * @ingroup infrastructure + */ + +/* + * Copyright (c) 2017 Dirk Ziegelmeier. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Dirk Ziegelmeier + * + */ + +#ifndef LWIP_HDR_PROT_IEEE_H +#define LWIP_HDR_PROT_IEEE_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @ingroup ieee + * A list of often ethtypes (although lwIP does not use all of them). + */ +enum lwip_ieee_eth_type { + /** Internet protocol v4 */ + ETHTYPE_IP = 0x0800U, + /** Address resolution protocol */ + ETHTYPE_ARP = 0x0806U, + /** Wake on lan */ + ETHTYPE_WOL = 0x0842U, + /** RARP */ + ETHTYPE_RARP = 0x8035U, + /** Virtual local area network */ + ETHTYPE_VLAN = 0x8100U, + /** Internet protocol v6 */ + ETHTYPE_IPV6 = 0x86DDU, + /** PPP Over Ethernet Discovery Stage */ + ETHTYPE_PPPOEDISC = 0x8863U, + /** PPP Over Ethernet Session Stage */ + ETHTYPE_PPPOE = 0x8864U, + /** Jumbo Frames */ + ETHTYPE_JUMBO = 0x8870U, + /** Process field network */ + ETHTYPE_PROFINET = 0x8892U, + /** Ethernet for control automation technology */ + ETHTYPE_ETHERCAT = 0x88A4U, + /** Link layer discovery protocol */ + ETHTYPE_LLDP = 0x88CCU, + /** Serial real-time communication system */ + ETHTYPE_SERCOS = 0x88CDU, + /** Media redundancy protocol */ + ETHTYPE_MRP = 0x88E3U, + /** Precision time protocol */ + ETHTYPE_PTP = 0x88F7U, + /** Q-in-Q, 802.1ad */ + ETHTYPE_QINQ = 0x9100U +}; + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_IEEE_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/igmp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/igmp.h index 41e4e675..46b81a9d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/igmp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/igmp.h @@ -1,90 +1,90 @@ -/** - * @file - * IGMP protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_IGMP_H -#define LWIP_HDR_PROT_IGMP_H - -#include "lwip/arch.h" -#include "lwip/prot/ip4.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * IGMP constants - */ -#define IGMP_TTL 1 -#define IGMP_MINLEN 8 -#define ROUTER_ALERT 0x9404U -#define ROUTER_ALERTLEN 4 - -/* - * IGMP message types, including version number. - */ -#define IGMP_MEMB_QUERY 0x11 /* Membership query */ -#define IGMP_V1_MEMB_REPORT 0x12 /* Ver. 1 membership report */ -#define IGMP_V2_MEMB_REPORT 0x16 /* Ver. 2 membership report */ -#define IGMP_LEAVE_GROUP 0x17 /* Leave-group message */ - -/* Group membership states */ -#define IGMP_GROUP_NON_MEMBER 0 -#define IGMP_GROUP_DELAYING_MEMBER 1 -#define IGMP_GROUP_IDLE_MEMBER 2 - -/** - * IGMP packet format. - */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct igmp_msg { - PACK_STRUCT_FLD_8(u8_t igmp_msgtype); - PACK_STRUCT_FLD_8(u8_t igmp_maxresp); - PACK_STRUCT_FIELD(u16_t igmp_checksum); - PACK_STRUCT_FLD_S(ip4_addr_p_t igmp_group_address); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_IGMP_H */ +/** + * @file + * IGMP protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_IGMP_H +#define LWIP_HDR_PROT_IGMP_H + +#include "lwip/arch.h" +#include "lwip/prot/ip4.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * IGMP constants + */ +#define IGMP_TTL 1 +#define IGMP_MINLEN 8 +#define ROUTER_ALERT 0x9404U +#define ROUTER_ALERTLEN 4 + +/* + * IGMP message types, including version number. + */ +#define IGMP_MEMB_QUERY 0x11 /* Membership query */ +#define IGMP_V1_MEMB_REPORT 0x12 /* Ver. 1 membership report */ +#define IGMP_V2_MEMB_REPORT 0x16 /* Ver. 2 membership report */ +#define IGMP_LEAVE_GROUP 0x17 /* Leave-group message */ + +/* Group membership states */ +#define IGMP_GROUP_NON_MEMBER 0 +#define IGMP_GROUP_DELAYING_MEMBER 1 +#define IGMP_GROUP_IDLE_MEMBER 2 + +/** + * IGMP packet format. + */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct igmp_msg { + PACK_STRUCT_FLD_8(u8_t igmp_msgtype); + PACK_STRUCT_FLD_8(u8_t igmp_maxresp); + PACK_STRUCT_FIELD(u16_t igmp_checksum); + PACK_STRUCT_FLD_S(ip4_addr_p_t igmp_group_address); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_IGMP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip.h index 3ce496c4..223158f5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip.h @@ -1,59 +1,59 @@ -/** - * @file - * IP protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_IP_H -#define LWIP_HDR_PROT_IP_H - -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define IP_PROTO_ICMP 1 -#define IP_PROTO_IGMP 2 -#define IP_PROTO_UDP 17 -#define IP_PROTO_UDPLITE 136 -#define IP_PROTO_TCP 6 - -/** This operates on a void* by loading the first byte */ -#define IP_HDR_GET_VERSION(ptr) ((*(u8_t*)(ptr)) >> 4) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_IP_H */ +/** + * @file + * IP protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_IP_H +#define LWIP_HDR_PROT_IP_H + +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define IP_PROTO_ICMP 1 +#define IP_PROTO_IGMP 2 +#define IP_PROTO_UDP 17 +#define IP_PROTO_UDPLITE 136 +#define IP_PROTO_TCP 6 + +/** This operates on a void* by loading the first byte */ +#define IP_HDR_GET_VERSION(ptr) ((*(u8_t*)(ptr)) >> 4) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_IP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip4.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip4.h index 4635a7a6..93474611 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip4.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip4.h @@ -1,131 +1,131 @@ -/** - * @file - * IPv4 protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_IP4_H -#define LWIP_HDR_PROT_IP4_H - -#include "lwip/arch.h" -#include "lwip/ip4_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** This is the packed version of ip4_addr_t, - used in network headers that are itself packed */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip4_addr_packed { - PACK_STRUCT_FIELD(u32_t addr); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -typedef struct ip4_addr_packed ip4_addr_p_t; - -/* Size of the IPv4 header. Same as 'sizeof(struct ip_hdr)'. */ -#define IP_HLEN 20 -/* Maximum size of the IPv4 header with options. */ -#define IP_HLEN_MAX 60 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/* The IPv4 header */ -struct ip_hdr { - /* version / header length */ - PACK_STRUCT_FLD_8(u8_t _v_hl); - /* type of service */ - PACK_STRUCT_FLD_8(u8_t _tos); - /* total length */ - PACK_STRUCT_FIELD(u16_t _len); - /* identification */ - PACK_STRUCT_FIELD(u16_t _id); - /* fragment offset field */ - PACK_STRUCT_FIELD(u16_t _offset); -#define IP_RF 0x8000U /* reserved fragment flag */ -#define IP_DF 0x4000U /* don't fragment flag */ -#define IP_MF 0x2000U /* more fragments flag */ -#define IP_OFFMASK 0x1fffU /* mask for fragmenting bits */ - /* time to live */ - PACK_STRUCT_FLD_8(u8_t _ttl); - /* protocol*/ - PACK_STRUCT_FLD_8(u8_t _proto); - /* checksum */ - PACK_STRUCT_FIELD(u16_t _chksum); - /* source and destination IP addresses */ - PACK_STRUCT_FLD_S(ip4_addr_p_t src); - PACK_STRUCT_FLD_S(ip4_addr_p_t dest); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/* Macros to get struct ip_hdr fields: */ -#define IPH_V(hdr) ((hdr)->_v_hl >> 4) -#define IPH_HL(hdr) ((hdr)->_v_hl & 0x0f) -#define IPH_HL_BYTES(hdr) ((u8_t)(IPH_HL(hdr) * 4)) -#define IPH_TOS(hdr) ((hdr)->_tos) -#define IPH_LEN(hdr) ((hdr)->_len) -#define IPH_ID(hdr) ((hdr)->_id) -#define IPH_OFFSET(hdr) ((hdr)->_offset) -#define IPH_OFFSET_BYTES(hdr) ((u16_t)((lwip_ntohs(IPH_OFFSET(hdr)) & IP_OFFMASK) * 8U)) -#define IPH_TTL(hdr) ((hdr)->_ttl) -#define IPH_PROTO(hdr) ((hdr)->_proto) -#define IPH_CHKSUM(hdr) ((hdr)->_chksum) - -/* Macros to set struct ip_hdr fields: */ -#define IPH_VHL_SET(hdr, v, hl) (hdr)->_v_hl = (u8_t)((((v) << 4) | (hl))) -#define IPH_TOS_SET(hdr, tos) (hdr)->_tos = (tos) -#define IPH_LEN_SET(hdr, len) (hdr)->_len = (len) -#define IPH_ID_SET(hdr, id) (hdr)->_id = (id) -#define IPH_OFFSET_SET(hdr, off) (hdr)->_offset = (off) -#define IPH_TTL_SET(hdr, ttl) (hdr)->_ttl = (u8_t)(ttl) -#define IPH_PROTO_SET(hdr, proto) (hdr)->_proto = (u8_t)(proto) -#define IPH_CHKSUM_SET(hdr, chksum) (hdr)->_chksum = (chksum) - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_IP4_H */ +/** + * @file + * IPv4 protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_IP4_H +#define LWIP_HDR_PROT_IP4_H + +#include "lwip/arch.h" +#include "lwip/ip4_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** This is the packed version of ip4_addr_t, + used in network headers that are itself packed */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip4_addr_packed { + PACK_STRUCT_FIELD(u32_t addr); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +typedef struct ip4_addr_packed ip4_addr_p_t; + +/* Size of the IPv4 header. Same as 'sizeof(struct ip_hdr)'. */ +#define IP_HLEN 20 +/* Maximum size of the IPv4 header with options. */ +#define IP_HLEN_MAX 60 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/* The IPv4 header */ +struct ip_hdr { + /* version / header length */ + PACK_STRUCT_FLD_8(u8_t _v_hl); + /* type of service */ + PACK_STRUCT_FLD_8(u8_t _tos); + /* total length */ + PACK_STRUCT_FIELD(u16_t _len); + /* identification */ + PACK_STRUCT_FIELD(u16_t _id); + /* fragment offset field */ + PACK_STRUCT_FIELD(u16_t _offset); +#define IP_RF 0x8000U /* reserved fragment flag */ +#define IP_DF 0x4000U /* don't fragment flag */ +#define IP_MF 0x2000U /* more fragments flag */ +#define IP_OFFMASK 0x1fffU /* mask for fragmenting bits */ + /* time to live */ + PACK_STRUCT_FLD_8(u8_t _ttl); + /* protocol*/ + PACK_STRUCT_FLD_8(u8_t _proto); + /* checksum */ + PACK_STRUCT_FIELD(u16_t _chksum); + /* source and destination IP addresses */ + PACK_STRUCT_FLD_S(ip4_addr_p_t src); + PACK_STRUCT_FLD_S(ip4_addr_p_t dest); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/* Macros to get struct ip_hdr fields: */ +#define IPH_V(hdr) ((hdr)->_v_hl >> 4) +#define IPH_HL(hdr) ((hdr)->_v_hl & 0x0f) +#define IPH_HL_BYTES(hdr) ((u8_t)(IPH_HL(hdr) * 4)) +#define IPH_TOS(hdr) ((hdr)->_tos) +#define IPH_LEN(hdr) ((hdr)->_len) +#define IPH_ID(hdr) ((hdr)->_id) +#define IPH_OFFSET(hdr) ((hdr)->_offset) +#define IPH_OFFSET_BYTES(hdr) ((u16_t)((lwip_ntohs(IPH_OFFSET(hdr)) & IP_OFFMASK) * 8U)) +#define IPH_TTL(hdr) ((hdr)->_ttl) +#define IPH_PROTO(hdr) ((hdr)->_proto) +#define IPH_CHKSUM(hdr) ((hdr)->_chksum) + +/* Macros to set struct ip_hdr fields: */ +#define IPH_VHL_SET(hdr, v, hl) (hdr)->_v_hl = (u8_t)((((v) << 4) | (hl))) +#define IPH_TOS_SET(hdr, tos) (hdr)->_tos = (tos) +#define IPH_LEN_SET(hdr, len) (hdr)->_len = (len) +#define IPH_ID_SET(hdr, id) (hdr)->_id = (id) +#define IPH_OFFSET_SET(hdr, off) (hdr)->_offset = (off) +#define IPH_TTL_SET(hdr, ttl) (hdr)->_ttl = (u8_t)(ttl) +#define IPH_PROTO_SET(hdr, proto) (hdr)->_proto = (u8_t)(proto) +#define IPH_CHKSUM_SET(hdr, chksum) (hdr)->_chksum = (chksum) + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_IP4_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip6.h index 272d6cea..0f6de455 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/ip6.h @@ -1,233 +1,233 @@ -/** - * @file - * IPv6 protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_IP6_H -#define LWIP_HDR_PROT_IP6_H - -#include "lwip/arch.h" -#include "lwip/ip6_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** This is the packed version of ip6_addr_t, - used in network headers that are itself packed */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_addr_packed { - PACK_STRUCT_FIELD(u32_t addr[4]); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -typedef struct ip6_addr_packed ip6_addr_p_t; - -#define IP6_HLEN 40 - -#define IP6_NEXTH_HOPBYHOP 0 -#define IP6_NEXTH_TCP 6 -#define IP6_NEXTH_UDP 17 -#define IP6_NEXTH_ENCAPS 41 -#define IP6_NEXTH_ROUTING 43 -#define IP6_NEXTH_FRAGMENT 44 -#define IP6_NEXTH_ICMP6 58 -#define IP6_NEXTH_NONE 59 -#define IP6_NEXTH_DESTOPTS 60 -#define IP6_NEXTH_UDPLITE 136 - -/** The IPv6 header. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_hdr { - /** version / traffic class / flow label */ - PACK_STRUCT_FIELD(u32_t _v_tc_fl); - /** payload length */ - PACK_STRUCT_FIELD(u16_t _plen); - /** next header */ - PACK_STRUCT_FLD_8(u8_t _nexth); - /** hop limit */ - PACK_STRUCT_FLD_8(u8_t _hoplim); - /** source and destination IP addresses */ - PACK_STRUCT_FLD_S(ip6_addr_p_t src); - PACK_STRUCT_FLD_S(ip6_addr_p_t dest); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define IP6H_V(hdr) ((lwip_ntohl((hdr)->_v_tc_fl) >> 28) & 0x0f) -#define IP6H_TC(hdr) ((lwip_ntohl((hdr)->_v_tc_fl) >> 20) & 0xff) -#define IP6H_FL(hdr) (lwip_ntohl((hdr)->_v_tc_fl) & 0x000fffff) -#define IP6H_PLEN(hdr) (lwip_ntohs((hdr)->_plen)) -#define IP6H_NEXTH(hdr) ((hdr)->_nexth) -#define IP6H_NEXTH_P(hdr) ((u8_t *)(hdr) + 6) -#define IP6H_HOPLIM(hdr) ((hdr)->_hoplim) -#define IP6H_VTCFL_SET(hdr, v, tc, fl) (hdr)->_v_tc_fl = (lwip_htonl((((u32_t)(v)) << 28) | (((u32_t)(tc)) << 20) | (fl))) -#define IP6H_PLEN_SET(hdr, plen) (hdr)->_plen = lwip_htons(plen) -#define IP6H_NEXTH_SET(hdr, nexth) (hdr)->_nexth = (nexth) -#define IP6H_HOPLIM_SET(hdr, hl) (hdr)->_hoplim = (u8_t)(hl) - -/* ipv6 extended options header */ -#define IP6_PAD1_OPTION 0 -#define IP6_PADN_OPTION 1 -#define IP6_ROUTER_ALERT_OPTION 5 -#define IP6_JUMBO_OPTION 194 -#define IP6_HOME_ADDRESS_OPTION 201 -#define IP6_ROUTER_ALERT_DLEN 2 -#define IP6_ROUTER_ALERT_VALUE_MLD 0 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_opt_hdr { - /* router alert option type */ - PACK_STRUCT_FLD_8(u8_t _opt_type); - /* router alert option data len */ - PACK_STRUCT_FLD_8(u8_t _opt_dlen); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define IP6_OPT_HLEN 2 -#define IP6_OPT_TYPE_ACTION(hdr) ((((hdr)->_opt_type) >> 6) & 0x3) -#define IP6_OPT_TYPE_CHANGE(hdr) ((((hdr)->_opt_type) >> 5) & 0x1) -#define IP6_OPT_TYPE(hdr) ((hdr)->_opt_type) -#define IP6_OPT_DLEN(hdr) ((hdr)->_opt_dlen) - -/* Hop-by-Hop header. */ -#define IP6_HBH_HLEN 2 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_hbh_hdr { - /* next header */ - PACK_STRUCT_FLD_8(u8_t _nexth); - /* header length in 8-octet units */ - PACK_STRUCT_FLD_8(u8_t _hlen); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define IP6_HBH_NEXTH(hdr) ((hdr)->_nexth) - -/* Destination header. */ -#define IP6_DEST_HLEN 2 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_dest_hdr { - /* next header */ - PACK_STRUCT_FLD_8(u8_t _nexth); - /* header length in 8-octet units */ - PACK_STRUCT_FLD_8(u8_t _hlen); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define IP6_DEST_NEXTH(hdr) ((hdr)->_nexth) - -/* Routing header */ -#define IP6_ROUT_TYPE2 2 -#define IP6_ROUT_RPL 3 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_rout_hdr { - /* next header */ - PACK_STRUCT_FLD_8(u8_t _nexth); - /* reserved */ - PACK_STRUCT_FLD_8(u8_t _hlen); - /* fragment offset */ - PACK_STRUCT_FIELD(u8_t _routing_type); - /* fragmented packet identification */ - PACK_STRUCT_FIELD(u8_t _segments_left); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define IP6_ROUT_NEXTH(hdr) ((hdr)->_nexth) -#define IP6_ROUT_TYPE(hdr) ((hdr)->_routing_type) -#define IP6_ROUT_SEG_LEFT(hdr) ((hdr)->_segments_left) - -/* Fragment header. */ -#define IP6_FRAG_HLEN 8 -#define IP6_FRAG_OFFSET_MASK 0xfff8 -#define IP6_FRAG_MORE_FLAG 0x0001 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ip6_frag_hdr { - /* next header */ - PACK_STRUCT_FLD_8(u8_t _nexth); - /* reserved */ - PACK_STRUCT_FLD_8(u8_t reserved); - /* fragment offset */ - PACK_STRUCT_FIELD(u16_t _fragment_offset); - /* fragmented packet identification */ - PACK_STRUCT_FIELD(u32_t _identification); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define IP6_FRAG_NEXTH(hdr) ((hdr)->_nexth) -#define IP6_FRAG_MBIT(hdr) (lwip_ntohs((hdr)->_fragment_offset) & 0x1) -#define IP6_FRAG_ID(hdr) (lwip_ntohl((hdr)->_identification)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_IP6_H */ +/** + * @file + * IPv6 protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_IP6_H +#define LWIP_HDR_PROT_IP6_H + +#include "lwip/arch.h" +#include "lwip/ip6_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** This is the packed version of ip6_addr_t, + used in network headers that are itself packed */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_addr_packed { + PACK_STRUCT_FIELD(u32_t addr[4]); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +typedef struct ip6_addr_packed ip6_addr_p_t; + +#define IP6_HLEN 40 + +#define IP6_NEXTH_HOPBYHOP 0 +#define IP6_NEXTH_TCP 6 +#define IP6_NEXTH_UDP 17 +#define IP6_NEXTH_ENCAPS 41 +#define IP6_NEXTH_ROUTING 43 +#define IP6_NEXTH_FRAGMENT 44 +#define IP6_NEXTH_ICMP6 58 +#define IP6_NEXTH_NONE 59 +#define IP6_NEXTH_DESTOPTS 60 +#define IP6_NEXTH_UDPLITE 136 + +/** The IPv6 header. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_hdr { + /** version / traffic class / flow label */ + PACK_STRUCT_FIELD(u32_t _v_tc_fl); + /** payload length */ + PACK_STRUCT_FIELD(u16_t _plen); + /** next header */ + PACK_STRUCT_FLD_8(u8_t _nexth); + /** hop limit */ + PACK_STRUCT_FLD_8(u8_t _hoplim); + /** source and destination IP addresses */ + PACK_STRUCT_FLD_S(ip6_addr_p_t src); + PACK_STRUCT_FLD_S(ip6_addr_p_t dest); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define IP6H_V(hdr) ((lwip_ntohl((hdr)->_v_tc_fl) >> 28) & 0x0f) +#define IP6H_TC(hdr) ((lwip_ntohl((hdr)->_v_tc_fl) >> 20) & 0xff) +#define IP6H_FL(hdr) (lwip_ntohl((hdr)->_v_tc_fl) & 0x000fffff) +#define IP6H_PLEN(hdr) (lwip_ntohs((hdr)->_plen)) +#define IP6H_NEXTH(hdr) ((hdr)->_nexth) +#define IP6H_NEXTH_P(hdr) ((u8_t *)(hdr) + 6) +#define IP6H_HOPLIM(hdr) ((hdr)->_hoplim) +#define IP6H_VTCFL_SET(hdr, v, tc, fl) (hdr)->_v_tc_fl = (lwip_htonl((((u32_t)(v)) << 28) | (((u32_t)(tc)) << 20) | (fl))) +#define IP6H_PLEN_SET(hdr, plen) (hdr)->_plen = lwip_htons(plen) +#define IP6H_NEXTH_SET(hdr, nexth) (hdr)->_nexth = (nexth) +#define IP6H_HOPLIM_SET(hdr, hl) (hdr)->_hoplim = (u8_t)(hl) + +/* ipv6 extended options header */ +#define IP6_PAD1_OPTION 0 +#define IP6_PADN_OPTION 1 +#define IP6_ROUTER_ALERT_OPTION 5 +#define IP6_JUMBO_OPTION 194 +#define IP6_HOME_ADDRESS_OPTION 201 +#define IP6_ROUTER_ALERT_DLEN 2 +#define IP6_ROUTER_ALERT_VALUE_MLD 0 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_opt_hdr { + /* router alert option type */ + PACK_STRUCT_FLD_8(u8_t _opt_type); + /* router alert option data len */ + PACK_STRUCT_FLD_8(u8_t _opt_dlen); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define IP6_OPT_HLEN 2 +#define IP6_OPT_TYPE_ACTION(hdr) ((((hdr)->_opt_type) >> 6) & 0x3) +#define IP6_OPT_TYPE_CHANGE(hdr) ((((hdr)->_opt_type) >> 5) & 0x1) +#define IP6_OPT_TYPE(hdr) ((hdr)->_opt_type) +#define IP6_OPT_DLEN(hdr) ((hdr)->_opt_dlen) + +/* Hop-by-Hop header. */ +#define IP6_HBH_HLEN 2 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_hbh_hdr { + /* next header */ + PACK_STRUCT_FLD_8(u8_t _nexth); + /* header length in 8-octet units */ + PACK_STRUCT_FLD_8(u8_t _hlen); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define IP6_HBH_NEXTH(hdr) ((hdr)->_nexth) + +/* Destination header. */ +#define IP6_DEST_HLEN 2 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_dest_hdr { + /* next header */ + PACK_STRUCT_FLD_8(u8_t _nexth); + /* header length in 8-octet units */ + PACK_STRUCT_FLD_8(u8_t _hlen); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define IP6_DEST_NEXTH(hdr) ((hdr)->_nexth) + +/* Routing header */ +#define IP6_ROUT_TYPE2 2 +#define IP6_ROUT_RPL 3 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_rout_hdr { + /* next header */ + PACK_STRUCT_FLD_8(u8_t _nexth); + /* reserved */ + PACK_STRUCT_FLD_8(u8_t _hlen); + /* fragment offset */ + PACK_STRUCT_FIELD(u8_t _routing_type); + /* fragmented packet identification */ + PACK_STRUCT_FIELD(u8_t _segments_left); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define IP6_ROUT_NEXTH(hdr) ((hdr)->_nexth) +#define IP6_ROUT_TYPE(hdr) ((hdr)->_routing_type) +#define IP6_ROUT_SEG_LEFT(hdr) ((hdr)->_segments_left) + +/* Fragment header. */ +#define IP6_FRAG_HLEN 8 +#define IP6_FRAG_OFFSET_MASK 0xfff8 +#define IP6_FRAG_MORE_FLAG 0x0001 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ip6_frag_hdr { + /* next header */ + PACK_STRUCT_FLD_8(u8_t _nexth); + /* reserved */ + PACK_STRUCT_FLD_8(u8_t reserved); + /* fragment offset */ + PACK_STRUCT_FIELD(u16_t _fragment_offset); + /* fragmented packet identification */ + PACK_STRUCT_FIELD(u32_t _identification); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define IP6_FRAG_NEXTH(hdr) ((hdr)->_nexth) +#define IP6_FRAG_MBIT(hdr) (lwip_ntohs((hdr)->_fragment_offset) & 0x1) +#define IP6_FRAG_ID(hdr) (lwip_ntohl((hdr)->_identification)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_IP6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/mld6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/mld6.h index 27a63bf0..71f1dcbd 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/mld6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/mld6.h @@ -1,71 +1,71 @@ -/** - * @file - * MLD6 protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_MLD6_H -#define LWIP_HDR_PROT_MLD6_H - -#include "lwip/arch.h" -#include "lwip/prot/ip6.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define MLD6_HBH_HLEN 8 -/** Multicast listener report/query/done message header. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct mld_header { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u16_t max_resp_delay); - PACK_STRUCT_FIELD(u16_t reserved); - PACK_STRUCT_FLD_S(ip6_addr_p_t multicast_address); - /* Options follow. */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_MLD6_H */ +/** + * @file + * MLD6 protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_MLD6_H +#define LWIP_HDR_PROT_MLD6_H + +#include "lwip/arch.h" +#include "lwip/prot/ip6.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MLD6_HBH_HLEN 8 +/** Multicast listener report/query/done message header. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct mld_header { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u16_t max_resp_delay); + PACK_STRUCT_FIELD(u16_t reserved); + PACK_STRUCT_FLD_S(ip6_addr_p_t multicast_address); + /* Options follow. */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_MLD6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/nd6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/nd6.h index af87e29d..c270d07c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/nd6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/nd6.h @@ -1,274 +1,274 @@ -/** - * @file - * ND6 protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_ND6_H -#define LWIP_HDR_PROT_ND6_H - -#include "lwip/arch.h" -#include "lwip/ip6_addr.h" -#include "lwip/prot/ip6.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** Neighbor solicitation message header. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ns_header { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u32_t reserved); - PACK_STRUCT_FLD_S(ip6_addr_p_t target_address); - /* Options follow. */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Neighbor advertisement message header. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct na_header { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FLD_8(u8_t flags); - PACK_STRUCT_FLD_8(u8_t reserved[3]); - PACK_STRUCT_FLD_S(ip6_addr_p_t target_address); - /* Options follow. */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#define ND6_FLAG_ROUTER (0x80) -#define ND6_FLAG_SOLICITED (0x40) -#define ND6_FLAG_OVERRIDE (0x20) - -/** Router solicitation message header. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct rs_header { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u32_t reserved); - /* Options follow. */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Router advertisement message header. */ -#define ND6_RA_FLAG_MANAGED_ADDR_CONFIG (0x80) -#define ND6_RA_FLAG_OTHER_CONFIG (0x40) -#define ND6_RA_FLAG_HOME_AGENT (0x20) -#define ND6_RA_PREFERENCE_MASK (0x18) -#define ND6_RA_PREFERENCE_HIGH (0x08) -#define ND6_RA_PREFERENCE_MEDIUM (0x00) -#define ND6_RA_PREFERENCE_LOW (0x18) -#define ND6_RA_PREFERENCE_DISABLED (0x10) -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct ra_header { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FLD_8(u8_t current_hop_limit); - PACK_STRUCT_FLD_8(u8_t flags); - PACK_STRUCT_FIELD(u16_t router_lifetime); - PACK_STRUCT_FIELD(u32_t reachable_time); - PACK_STRUCT_FIELD(u32_t retrans_timer); - /* Options follow. */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Redirect message header. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct redirect_header { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u32_t reserved); - PACK_STRUCT_FLD_S(ip6_addr_p_t target_address); - PACK_STRUCT_FLD_S(ip6_addr_p_t destination_address); - /* Options follow. */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Link-layer address option. */ -#define ND6_OPTION_TYPE_SOURCE_LLADDR (0x01) -#define ND6_OPTION_TYPE_TARGET_LLADDR (0x02) -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct lladdr_option { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t length); - PACK_STRUCT_FLD_8(u8_t addr[NETIF_MAX_HWADDR_LEN]); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Prefix information option. */ -#define ND6_OPTION_TYPE_PREFIX_INFO (0x03) -#define ND6_PREFIX_FLAG_ON_LINK (0x80) -#define ND6_PREFIX_FLAG_AUTONOMOUS (0x40) -#define ND6_PREFIX_FLAG_ROUTER_ADDRESS (0x20) -#define ND6_PREFIX_FLAG_SITE_PREFIX (0x10) -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct prefix_option { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t length); - PACK_STRUCT_FLD_8(u8_t prefix_length); - PACK_STRUCT_FLD_8(u8_t flags); - PACK_STRUCT_FIELD(u32_t valid_lifetime); - PACK_STRUCT_FIELD(u32_t preferred_lifetime); - PACK_STRUCT_FLD_8(u8_t reserved2[3]); - PACK_STRUCT_FLD_8(u8_t site_prefix_length); - PACK_STRUCT_FLD_S(ip6_addr_p_t prefix); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Redirected header option. */ -#define ND6_OPTION_TYPE_REDIR_HDR (0x04) -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct redirected_header_option { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t length); - PACK_STRUCT_FLD_8(u8_t reserved[6]); - /* Portion of redirected packet follows. */ - /* PACK_STRUCT_FLD_8(u8_t redirected[8]); */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** MTU option. */ -#define ND6_OPTION_TYPE_MTU (0x05) -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct mtu_option { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t length); - PACK_STRUCT_FIELD(u16_t reserved); - PACK_STRUCT_FIELD(u32_t mtu); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Route information option. */ -#define ND6_OPTION_TYPE_ROUTE_INFO (24) -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct route_option { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t length); - PACK_STRUCT_FLD_8(u8_t prefix_length); - PACK_STRUCT_FLD_8(u8_t preference); - PACK_STRUCT_FIELD(u32_t route_lifetime); - PACK_STRUCT_FLD_S(ip6_addr_p_t prefix); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/** Recursive DNS Server Option. */ -#define ND6_OPTION_TYPE_RDNSS (25) -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct rdnss_option { - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t length); - PACK_STRUCT_FIELD(u16_t reserved); - PACK_STRUCT_FIELD(u32_t lifetime); - PACK_STRUCT_FLD_S(ip6_addr_p_t rdnss_address[1]); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#define SIZEOF_RDNSS_OPTION_BASE 8 /* size without addresses */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_ND6_H */ +/** + * @file + * ND6 protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_ND6_H +#define LWIP_HDR_PROT_ND6_H + +#include "lwip/arch.h" +#include "lwip/ip6_addr.h" +#include "lwip/prot/ip6.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Neighbor solicitation message header. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ns_header { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u32_t reserved); + PACK_STRUCT_FLD_S(ip6_addr_p_t target_address); + /* Options follow. */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Neighbor advertisement message header. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct na_header { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FLD_8(u8_t flags); + PACK_STRUCT_FLD_8(u8_t reserved[3]); + PACK_STRUCT_FLD_S(ip6_addr_p_t target_address); + /* Options follow. */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#define ND6_FLAG_ROUTER (0x80) +#define ND6_FLAG_SOLICITED (0x40) +#define ND6_FLAG_OVERRIDE (0x20) + +/** Router solicitation message header. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct rs_header { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u32_t reserved); + /* Options follow. */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Router advertisement message header. */ +#define ND6_RA_FLAG_MANAGED_ADDR_CONFIG (0x80) +#define ND6_RA_FLAG_OTHER_CONFIG (0x40) +#define ND6_RA_FLAG_HOME_AGENT (0x20) +#define ND6_RA_PREFERENCE_MASK (0x18) +#define ND6_RA_PREFERENCE_HIGH (0x08) +#define ND6_RA_PREFERENCE_MEDIUM (0x00) +#define ND6_RA_PREFERENCE_LOW (0x18) +#define ND6_RA_PREFERENCE_DISABLED (0x10) +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct ra_header { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FLD_8(u8_t current_hop_limit); + PACK_STRUCT_FLD_8(u8_t flags); + PACK_STRUCT_FIELD(u16_t router_lifetime); + PACK_STRUCT_FIELD(u32_t reachable_time); + PACK_STRUCT_FIELD(u32_t retrans_timer); + /* Options follow. */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Redirect message header. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct redirect_header { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u32_t reserved); + PACK_STRUCT_FLD_S(ip6_addr_p_t target_address); + PACK_STRUCT_FLD_S(ip6_addr_p_t destination_address); + /* Options follow. */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Link-layer address option. */ +#define ND6_OPTION_TYPE_SOURCE_LLADDR (0x01) +#define ND6_OPTION_TYPE_TARGET_LLADDR (0x02) +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct lladdr_option { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t length); + PACK_STRUCT_FLD_8(u8_t addr[NETIF_MAX_HWADDR_LEN]); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Prefix information option. */ +#define ND6_OPTION_TYPE_PREFIX_INFO (0x03) +#define ND6_PREFIX_FLAG_ON_LINK (0x80) +#define ND6_PREFIX_FLAG_AUTONOMOUS (0x40) +#define ND6_PREFIX_FLAG_ROUTER_ADDRESS (0x20) +#define ND6_PREFIX_FLAG_SITE_PREFIX (0x10) +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct prefix_option { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t length); + PACK_STRUCT_FLD_8(u8_t prefix_length); + PACK_STRUCT_FLD_8(u8_t flags); + PACK_STRUCT_FIELD(u32_t valid_lifetime); + PACK_STRUCT_FIELD(u32_t preferred_lifetime); + PACK_STRUCT_FLD_8(u8_t reserved2[3]); + PACK_STRUCT_FLD_8(u8_t site_prefix_length); + PACK_STRUCT_FLD_S(ip6_addr_p_t prefix); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Redirected header option. */ +#define ND6_OPTION_TYPE_REDIR_HDR (0x04) +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct redirected_header_option { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t length); + PACK_STRUCT_FLD_8(u8_t reserved[6]); + /* Portion of redirected packet follows. */ + /* PACK_STRUCT_FLD_8(u8_t redirected[8]); */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** MTU option. */ +#define ND6_OPTION_TYPE_MTU (0x05) +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct mtu_option { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t length); + PACK_STRUCT_FIELD(u16_t reserved); + PACK_STRUCT_FIELD(u32_t mtu); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Route information option. */ +#define ND6_OPTION_TYPE_ROUTE_INFO (24) +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct route_option { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t length); + PACK_STRUCT_FLD_8(u8_t prefix_length); + PACK_STRUCT_FLD_8(u8_t preference); + PACK_STRUCT_FIELD(u32_t route_lifetime); + PACK_STRUCT_FLD_S(ip6_addr_p_t prefix); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/** Recursive DNS Server Option. */ +#define ND6_OPTION_TYPE_RDNSS (25) +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct rdnss_option { + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t length); + PACK_STRUCT_FIELD(u16_t reserved); + PACK_STRUCT_FIELD(u32_t lifetime); + PACK_STRUCT_FLD_S(ip6_addr_p_t rdnss_address[1]); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#define SIZEOF_RDNSS_OPTION_BASE 8 /* size without addresses */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_ND6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/tcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/tcp.h index f5a3dc8c..c1d7de1f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/tcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/tcp.h @@ -1,100 +1,100 @@ -/** - * @file - * TCP protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_TCP_H -#define LWIP_HDR_PROT_TCP_H - -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* Length of the TCP header, excluding options. */ -#define TCP_HLEN 20 - -/* Fields are (of course) in network byte order. - * Some fields are converted to host byte order in tcp_input(). - */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct tcp_hdr { - PACK_STRUCT_FIELD(u16_t src); - PACK_STRUCT_FIELD(u16_t dest); - PACK_STRUCT_FIELD(u32_t seqno); - PACK_STRUCT_FIELD(u32_t ackno); - PACK_STRUCT_FIELD(u16_t _hdrlen_rsvd_flags); - PACK_STRUCT_FIELD(u16_t wnd); - PACK_STRUCT_FIELD(u16_t chksum); - PACK_STRUCT_FIELD(u16_t urgp); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/* TCP header flags bits */ -#define TCP_FIN 0x01U -#define TCP_SYN 0x02U -#define TCP_RST 0x04U -#define TCP_PSH 0x08U -#define TCP_ACK 0x10U -#define TCP_URG 0x20U -#define TCP_ECE 0x40U -#define TCP_CWR 0x80U -/* Valid TCP header flags */ -#define TCP_FLAGS 0x3fU - -#define TCP_MAX_OPTION_BYTES 40 - -#define TCPH_HDRLEN(phdr) ((u16_t)(lwip_ntohs((phdr)->_hdrlen_rsvd_flags) >> 12)) -#define TCPH_HDRLEN_BYTES(phdr) ((u8_t)(TCPH_HDRLEN(phdr) << 2)) -#define TCPH_FLAGS(phdr) ((u8_t)((lwip_ntohs((phdr)->_hdrlen_rsvd_flags) & TCP_FLAGS))) - -#define TCPH_HDRLEN_SET(phdr, len) (phdr)->_hdrlen_rsvd_flags = lwip_htons(((len) << 12) | TCPH_FLAGS(phdr)) -#define TCPH_FLAGS_SET(phdr, flags) (phdr)->_hdrlen_rsvd_flags = (((phdr)->_hdrlen_rsvd_flags & PP_HTONS(~TCP_FLAGS)) | lwip_htons(flags)) -#define TCPH_HDRLEN_FLAGS_SET(phdr, len, flags) (phdr)->_hdrlen_rsvd_flags = (u16_t)(lwip_htons((u16_t)((len) << 12) | (flags))) - -#define TCPH_SET_FLAG(phdr, flags ) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags | lwip_htons(flags)) -#define TCPH_UNSET_FLAG(phdr, flags) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags & ~lwip_htons(flags)) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_TCP_H */ +/** + * @file + * TCP protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_TCP_H +#define LWIP_HDR_PROT_TCP_H + +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Length of the TCP header, excluding options. */ +#define TCP_HLEN 20 + +/* Fields are (of course) in network byte order. + * Some fields are converted to host byte order in tcp_input(). + */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct tcp_hdr { + PACK_STRUCT_FIELD(u16_t src); + PACK_STRUCT_FIELD(u16_t dest); + PACK_STRUCT_FIELD(u32_t seqno); + PACK_STRUCT_FIELD(u32_t ackno); + PACK_STRUCT_FIELD(u16_t _hdrlen_rsvd_flags); + PACK_STRUCT_FIELD(u16_t wnd); + PACK_STRUCT_FIELD(u16_t chksum); + PACK_STRUCT_FIELD(u16_t urgp); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/* TCP header flags bits */ +#define TCP_FIN 0x01U +#define TCP_SYN 0x02U +#define TCP_RST 0x04U +#define TCP_PSH 0x08U +#define TCP_ACK 0x10U +#define TCP_URG 0x20U +#define TCP_ECE 0x40U +#define TCP_CWR 0x80U +/* Valid TCP header flags */ +#define TCP_FLAGS 0x3fU + +#define TCP_MAX_OPTION_BYTES 40 + +#define TCPH_HDRLEN(phdr) ((u16_t)(lwip_ntohs((phdr)->_hdrlen_rsvd_flags) >> 12)) +#define TCPH_HDRLEN_BYTES(phdr) ((u8_t)(TCPH_HDRLEN(phdr) << 2)) +#define TCPH_FLAGS(phdr) ((u8_t)((lwip_ntohs((phdr)->_hdrlen_rsvd_flags) & TCP_FLAGS))) + +#define TCPH_HDRLEN_SET(phdr, len) (phdr)->_hdrlen_rsvd_flags = lwip_htons(((len) << 12) | TCPH_FLAGS(phdr)) +#define TCPH_FLAGS_SET(phdr, flags) (phdr)->_hdrlen_rsvd_flags = (((phdr)->_hdrlen_rsvd_flags & PP_HTONS(~TCP_FLAGS)) | lwip_htons(flags)) +#define TCPH_HDRLEN_FLAGS_SET(phdr, len, flags) (phdr)->_hdrlen_rsvd_flags = (u16_t)(lwip_htons((u16_t)((len) << 12) | (flags))) + +#define TCPH_SET_FLAG(phdr, flags ) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags | lwip_htons(flags)) +#define TCPH_UNSET_FLAG(phdr, flags) (phdr)->_hdrlen_rsvd_flags = ((phdr)->_hdrlen_rsvd_flags & ~lwip_htons(flags)) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_TCP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/udp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/udp.h index 4904b7e2..664f19a3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/udp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/prot/udp.h @@ -1,68 +1,68 @@ -/** - * @file - * UDP protocol definitions - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_PROT_UDP_H -#define LWIP_HDR_PROT_UDP_H - -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define UDP_HLEN 8 - -/* Fields are (of course) in network byte order. */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct udp_hdr { - PACK_STRUCT_FIELD(u16_t src); - PACK_STRUCT_FIELD(u16_t dest); /* src/dest UDP ports */ - PACK_STRUCT_FIELD(u16_t len); - PACK_STRUCT_FIELD(u16_t chksum); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_PROT_UDP_H */ +/** + * @file + * UDP protocol definitions + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_PROT_UDP_H +#define LWIP_HDR_PROT_UDP_H + +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define UDP_HLEN 8 + +/* Fields are (of course) in network byte order. */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct udp_hdr { + PACK_STRUCT_FIELD(u16_t src); + PACK_STRUCT_FIELD(u16_t dest); /* src/dest UDP ports */ + PACK_STRUCT_FIELD(u16_t len); + PACK_STRUCT_FIELD(u16_t chksum); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_PROT_UDP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/raw.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/raw.h index 1be1273c..b129bd3b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/raw.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/raw.h @@ -1,143 +1,143 @@ -/** - * @file - * raw API (to be used from TCPIP thread)\n - * See also @ref raw_raw - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_RAW_H -#define LWIP_HDR_RAW_H - -#include "lwip/opt.h" - -#if LWIP_RAW /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/def.h" -#include "lwip/ip.h" -#include "lwip/ip_addr.h" -#include "lwip/ip6_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define RAW_FLAGS_CONNECTED 0x01U -#define RAW_FLAGS_HDRINCL 0x02U -#define RAW_FLAGS_MULTICAST_LOOP 0x04U - -struct raw_pcb; - -/** Function prototype for raw pcb receive callback functions. - * @param arg user supplied argument (raw_pcb.recv_arg) - * @param pcb the raw_pcb which received data - * @param p the packet buffer that was received - * @param addr the remote IP address from which the packet was received - * @return 1 if the packet was 'eaten' (aka. deleted), - * 0 if the packet lives on - * If returning 1, the callback is responsible for freeing the pbuf - * if it's not used any more. - */ -typedef u8_t (*raw_recv_fn)(void *arg, struct raw_pcb *pcb, struct pbuf *p, - const ip_addr_t *addr); - -/** the RAW protocol control block */ -struct raw_pcb { - /* Common members of all PCB types */ - IP_PCB; - - struct raw_pcb *next; - - u8_t protocol; - u8_t flags; - -#if LWIP_MULTICAST_TX_OPTIONS - /** outgoing network interface for multicast packets, by interface index (if nonzero) */ - u8_t mcast_ifindex; - /** TTL for outgoing multicast packets */ - u8_t mcast_ttl; -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - - /** receive callback function */ - raw_recv_fn recv; - /* user-supplied argument for the recv callback */ - void *recv_arg; -#if LWIP_IPV6 - /* fields for handling checksum computations as per RFC3542. */ - u16_t chksum_offset; - u8_t chksum_reqd; -#endif -}; - -/* The following functions is the application layer interface to the - RAW code. */ -struct raw_pcb * raw_new (u8_t proto); -struct raw_pcb * raw_new_ip_type(u8_t type, u8_t proto); -void raw_remove (struct raw_pcb *pcb); -err_t raw_bind (struct raw_pcb *pcb, const ip_addr_t *ipaddr); -void raw_bind_netif (struct raw_pcb *pcb, const struct netif *netif); -err_t raw_connect (struct raw_pcb *pcb, const ip_addr_t *ipaddr); -void raw_disconnect (struct raw_pcb *pcb); - -err_t raw_sendto (struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *ipaddr); -err_t raw_sendto_if_src(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, struct netif *netif, const ip_addr_t *src_ip); -err_t raw_send (struct raw_pcb *pcb, struct pbuf *p); - -void raw_recv (struct raw_pcb *pcb, raw_recv_fn recv, void *recv_arg); - -#define raw_flags(pcb) ((pcb)->flags) -#define raw_setflags(pcb,f) ((pcb)->flags = (f)) - -#define raw_set_flags(pcb, set_flags) do { (pcb)->flags = (u8_t)((pcb)->flags | (set_flags)); } while(0) -#define raw_clear_flags(pcb, clr_flags) do { (pcb)->flags = (u8_t)((pcb)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) -#define raw_is_flag_set(pcb, flag) (((pcb)->flags & (flag)) != 0) - -#define raw_init() /* Compatibility define, no init needed. */ - -/* for compatibility with older implementation */ -#define raw_new_ip6(proto) raw_new_ip_type(IPADDR_TYPE_V6, proto) - -#if LWIP_MULTICAST_TX_OPTIONS -#define raw_set_multicast_netif_index(pcb, idx) ((pcb)->mcast_ifindex = (idx)) -#define raw_get_multicast_netif_index(pcb) ((pcb)->mcast_ifindex) -#define raw_set_multicast_ttl(pcb, value) ((pcb)->mcast_ttl = (value)) -#define raw_get_multicast_ttl(pcb) ((pcb)->mcast_ttl) -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_RAW */ - -#endif /* LWIP_HDR_RAW_H */ +/** + * @file + * raw API (to be used from TCPIP thread)\n + * See also @ref raw_raw + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_RAW_H +#define LWIP_HDR_RAW_H + +#include "lwip/opt.h" + +#if LWIP_RAW /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/def.h" +#include "lwip/ip.h" +#include "lwip/ip_addr.h" +#include "lwip/ip6_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define RAW_FLAGS_CONNECTED 0x01U +#define RAW_FLAGS_HDRINCL 0x02U +#define RAW_FLAGS_MULTICAST_LOOP 0x04U + +struct raw_pcb; + +/** Function prototype for raw pcb receive callback functions. + * @param arg user supplied argument (raw_pcb.recv_arg) + * @param pcb the raw_pcb which received data + * @param p the packet buffer that was received + * @param addr the remote IP address from which the packet was received + * @return 1 if the packet was 'eaten' (aka. deleted), + * 0 if the packet lives on + * If returning 1, the callback is responsible for freeing the pbuf + * if it's not used any more. + */ +typedef u8_t (*raw_recv_fn)(void *arg, struct raw_pcb *pcb, struct pbuf *p, + const ip_addr_t *addr); + +/** the RAW protocol control block */ +struct raw_pcb { + /* Common members of all PCB types */ + IP_PCB; + + struct raw_pcb *next; + + u8_t protocol; + u8_t flags; + +#if LWIP_MULTICAST_TX_OPTIONS + /** outgoing network interface for multicast packets, by interface index (if nonzero) */ + u8_t mcast_ifindex; + /** TTL for outgoing multicast packets */ + u8_t mcast_ttl; +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + + /** receive callback function */ + raw_recv_fn recv; + /* user-supplied argument for the recv callback */ + void *recv_arg; +#if LWIP_IPV6 + /* fields for handling checksum computations as per RFC3542. */ + u16_t chksum_offset; + u8_t chksum_reqd; +#endif +}; + +/* The following functions is the application layer interface to the + RAW code. */ +struct raw_pcb * raw_new (u8_t proto); +struct raw_pcb * raw_new_ip_type(u8_t type, u8_t proto); +void raw_remove (struct raw_pcb *pcb); +err_t raw_bind (struct raw_pcb *pcb, const ip_addr_t *ipaddr); +void raw_bind_netif (struct raw_pcb *pcb, const struct netif *netif); +err_t raw_connect (struct raw_pcb *pcb, const ip_addr_t *ipaddr); +void raw_disconnect (struct raw_pcb *pcb); + +err_t raw_sendto (struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *ipaddr); +err_t raw_sendto_if_src(struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *dst_ip, struct netif *netif, const ip_addr_t *src_ip); +err_t raw_send (struct raw_pcb *pcb, struct pbuf *p); + +void raw_recv (struct raw_pcb *pcb, raw_recv_fn recv, void *recv_arg); + +#define raw_flags(pcb) ((pcb)->flags) +#define raw_setflags(pcb,f) ((pcb)->flags = (f)) + +#define raw_set_flags(pcb, set_flags) do { (pcb)->flags = (u8_t)((pcb)->flags | (set_flags)); } while(0) +#define raw_clear_flags(pcb, clr_flags) do { (pcb)->flags = (u8_t)((pcb)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) +#define raw_is_flag_set(pcb, flag) (((pcb)->flags & (flag)) != 0) + +#define raw_init() /* Compatibility define, no init needed. */ + +/* for compatibility with older implementation */ +#define raw_new_ip6(proto) raw_new_ip_type(IPADDR_TYPE_V6, proto) + +#if LWIP_MULTICAST_TX_OPTIONS +#define raw_set_multicast_netif_index(pcb, idx) ((pcb)->mcast_ifindex = (idx)) +#define raw_get_multicast_netif_index(pcb) ((pcb)->mcast_ifindex) +#define raw_set_multicast_ttl(pcb, value) ((pcb)->mcast_ttl = (value)) +#define raw_get_multicast_ttl(pcb) ((pcb)->mcast_ttl) +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_RAW */ + +#endif /* LWIP_HDR_RAW_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sio.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sio.h index efa8adea..7643e195 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sio.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sio.h @@ -1,142 +1,142 @@ -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - */ - -/* - * This is the interface to the platform specific serial IO module - * It needs to be implemented by those platforms which need SLIP or PPP - */ - -#ifndef SIO_H -#define SIO_H - -#include "lwip/arch.h" -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* If you want to define sio_fd_t elsewhere or differently, - define this in your cc.h file. */ -#ifndef __sio_fd_t_defined -typedef void * sio_fd_t; -#endif - -/* The following functions can be defined to something else in your cc.h file - or be implemented in your custom sio.c file. */ - -#ifndef sio_open -/** - * Opens a serial device for communication. - * - * @param devnum device number - * @return handle to serial device if successful, NULL otherwise - */ -sio_fd_t sio_open(u8_t devnum); -#endif - -#ifndef sio_send -/** - * Sends a single character to the serial device. - * - * @param c character to send - * @param fd serial device handle - * - * @note This function will block until the character can be sent. - */ -void sio_send(u8_t c, sio_fd_t fd); -#endif - -#ifndef sio_recv -/** - * Receives a single character from the serial device. - * - * @param fd serial device handle - * - * @note This function will block until a character is received. - */ -u8_t sio_recv(sio_fd_t fd); -#endif - -#ifndef sio_read -/** - * Reads from the serial device. - * - * @param fd serial device handle - * @param data pointer to data buffer for receiving - * @param len maximum length (in bytes) of data to receive - * @return number of bytes actually received - may be 0 if aborted by sio_read_abort - * - * @note This function will block until data can be received. The blocking - * can be cancelled by calling sio_read_abort(). - */ -u32_t sio_read(sio_fd_t fd, u8_t *data, u32_t len); -#endif - -#ifndef sio_tryread -/** - * Tries to read from the serial device. Same as sio_read but returns - * immediately if no data is available and never blocks. - * - * @param fd serial device handle - * @param data pointer to data buffer for receiving - * @param len maximum length (in bytes) of data to receive - * @return number of bytes actually received - */ -u32_t sio_tryread(sio_fd_t fd, u8_t *data, u32_t len); -#endif - -#ifndef sio_write -/** - * Writes to the serial device. - * - * @param fd serial device handle - * @param data pointer to data to send - * @param len length (in bytes) of data to send - * @return number of bytes actually sent - * - * @note This function will block until all data can be sent. - */ -u32_t sio_write(sio_fd_t fd, u8_t *data, u32_t len); -#endif - -#ifndef sio_read_abort -/** - * Aborts a blocking sio_read() call. - * - * @param fd serial device handle - */ -void sio_read_abort(sio_fd_t fd); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* SIO_H */ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + */ + +/* + * This is the interface to the platform specific serial IO module + * It needs to be implemented by those platforms which need SLIP or PPP + */ + +#ifndef SIO_H +#define SIO_H + +#include "lwip/arch.h" +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* If you want to define sio_fd_t elsewhere or differently, + define this in your cc.h file. */ +#ifndef __sio_fd_t_defined +typedef void * sio_fd_t; +#endif + +/* The following functions can be defined to something else in your cc.h file + or be implemented in your custom sio.c file. */ + +#ifndef sio_open +/** + * Opens a serial device for communication. + * + * @param devnum device number + * @return handle to serial device if successful, NULL otherwise + */ +sio_fd_t sio_open(u8_t devnum); +#endif + +#ifndef sio_send +/** + * Sends a single character to the serial device. + * + * @param c character to send + * @param fd serial device handle + * + * @note This function will block until the character can be sent. + */ +void sio_send(u8_t c, sio_fd_t fd); +#endif + +#ifndef sio_recv +/** + * Receives a single character from the serial device. + * + * @param fd serial device handle + * + * @note This function will block until a character is received. + */ +u8_t sio_recv(sio_fd_t fd); +#endif + +#ifndef sio_read +/** + * Reads from the serial device. + * + * @param fd serial device handle + * @param data pointer to data buffer for receiving + * @param len maximum length (in bytes) of data to receive + * @return number of bytes actually received - may be 0 if aborted by sio_read_abort + * + * @note This function will block until data can be received. The blocking + * can be cancelled by calling sio_read_abort(). + */ +u32_t sio_read(sio_fd_t fd, u8_t *data, u32_t len); +#endif + +#ifndef sio_tryread +/** + * Tries to read from the serial device. Same as sio_read but returns + * immediately if no data is available and never blocks. + * + * @param fd serial device handle + * @param data pointer to data buffer for receiving + * @param len maximum length (in bytes) of data to receive + * @return number of bytes actually received + */ +u32_t sio_tryread(sio_fd_t fd, u8_t *data, u32_t len); +#endif + +#ifndef sio_write +/** + * Writes to the serial device. + * + * @param fd serial device handle + * @param data pointer to data to send + * @param len length (in bytes) of data to send + * @return number of bytes actually sent + * + * @note This function will block until all data can be sent. + */ +u32_t sio_write(sio_fd_t fd, u8_t *data, u32_t len); +#endif + +#ifndef sio_read_abort +/** + * Aborts a blocking sio_read() call. + * + * @param fd serial device handle + */ +void sio_read_abort(sio_fd_t fd); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* SIO_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/snmp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/snmp.h index 80e6e57c..8704d0b4 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/snmp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/snmp.h @@ -1,213 +1,213 @@ -/** - * @file - * SNMP support API for implementing netifs and statitics for MIB2 - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Dirk Ziegelmeier - * - */ -#ifndef LWIP_HDR_SNMP_H -#define LWIP_HDR_SNMP_H - -#include "lwip/opt.h" -#include "lwip/ip_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct udp_pcb; -struct netif; - -/** - * @defgroup netif_mib2 MIB2 statistics - * @ingroup netif - */ - -/* MIB2 statistics functions */ -#if MIB2_STATS /* don't build if not configured for use in lwipopts.h */ -/** - * @ingroup netif_mib2 - * @see RFC1213, "MIB-II, 6. Definitions" - */ -enum snmp_ifType { - snmp_ifType_other=1, /* none of the following */ - snmp_ifType_regular1822, - snmp_ifType_hdh1822, - snmp_ifType_ddn_x25, - snmp_ifType_rfc877_x25, - snmp_ifType_ethernet_csmacd, - snmp_ifType_iso88023_csmacd, - snmp_ifType_iso88024_tokenBus, - snmp_ifType_iso88025_tokenRing, - snmp_ifType_iso88026_man, - snmp_ifType_starLan, - snmp_ifType_proteon_10Mbit, - snmp_ifType_proteon_80Mbit, - snmp_ifType_hyperchannel, - snmp_ifType_fddi, - snmp_ifType_lapb, - snmp_ifType_sdlc, - snmp_ifType_ds1, /* T-1 */ - snmp_ifType_e1, /* european equiv. of T-1 */ - snmp_ifType_basicISDN, - snmp_ifType_primaryISDN, /* proprietary serial */ - snmp_ifType_propPointToPointSerial, - snmp_ifType_ppp, - snmp_ifType_softwareLoopback, - snmp_ifType_eon, /* CLNP over IP [11] */ - snmp_ifType_ethernet_3Mbit, - snmp_ifType_nsip, /* XNS over IP */ - snmp_ifType_slip, /* generic SLIP */ - snmp_ifType_ultra, /* ULTRA technologies */ - snmp_ifType_ds3, /* T-3 */ - snmp_ifType_sip, /* SMDS */ - snmp_ifType_frame_relay -}; - -/** This macro has a precision of ~49 days because sys_now returns u32_t. \#define your own if you want ~490 days. */ -#ifndef MIB2_COPY_SYSUPTIME_TO -#define MIB2_COPY_SYSUPTIME_TO(ptrToVal) (*(ptrToVal) = (sys_now() / 10)) -#endif - -/** - * @ingroup netif_mib2 - * Increment stats member for SNMP MIB2 stats (struct stats_mib2_netif_ctrs) - */ -#define MIB2_STATS_NETIF_INC(n, x) do { ++(n)->mib2_counters.x; } while(0) -/** - * @ingroup netif_mib2 - * Add value to stats member for SNMP MIB2 stats (struct stats_mib2_netif_ctrs) - */ -#define MIB2_STATS_NETIF_ADD(n, x, val) do { (n)->mib2_counters.x += (val); } while(0) - -/** - * @ingroup netif_mib2 - * Init MIB2 statistic counters in netif - * @param netif Netif to init - * @param type one of enum @ref snmp_ifType - * @param speed your link speed here (units: bits per second) - */ -#define MIB2_INIT_NETIF(netif, type, speed) do { \ - (netif)->link_type = (type); \ - (netif)->link_speed = (speed);\ - (netif)->ts = 0; \ - (netif)->mib2_counters.ifinoctets = 0; \ - (netif)->mib2_counters.ifinucastpkts = 0; \ - (netif)->mib2_counters.ifinnucastpkts = 0; \ - (netif)->mib2_counters.ifindiscards = 0; \ - (netif)->mib2_counters.ifinerrors = 0; \ - (netif)->mib2_counters.ifinunknownprotos = 0; \ - (netif)->mib2_counters.ifoutoctets = 0; \ - (netif)->mib2_counters.ifoutucastpkts = 0; \ - (netif)->mib2_counters.ifoutnucastpkts = 0; \ - (netif)->mib2_counters.ifoutdiscards = 0; \ - (netif)->mib2_counters.ifouterrors = 0; } while(0) -#else /* MIB2_STATS */ -#ifndef MIB2_COPY_SYSUPTIME_TO -#define MIB2_COPY_SYSUPTIME_TO(ptrToVal) -#endif -#define MIB2_INIT_NETIF(netif, type, speed) -#define MIB2_STATS_NETIF_INC(n, x) -#define MIB2_STATS_NETIF_ADD(n, x, val) -#endif /* MIB2_STATS */ - -/* LWIP MIB2 callbacks */ -#if LWIP_MIB2_CALLBACKS /* don't build if not configured for use in lwipopts.h */ -/* network interface */ -void mib2_netif_added(struct netif *ni); -void mib2_netif_removed(struct netif *ni); - -#if LWIP_IPV4 && LWIP_ARP -/* ARP (for atTable and ipNetToMediaTable) */ -void mib2_add_arp_entry(struct netif *ni, ip4_addr_t *ip); -void mib2_remove_arp_entry(struct netif *ni, ip4_addr_t *ip); -#else /* LWIP_IPV4 && LWIP_ARP */ -#define mib2_add_arp_entry(ni,ip) -#define mib2_remove_arp_entry(ni,ip) -#endif /* LWIP_IPV4 && LWIP_ARP */ - -/* IP */ -#if LWIP_IPV4 -void mib2_add_ip4(struct netif *ni); -void mib2_remove_ip4(struct netif *ni); -void mib2_add_route_ip4(u8_t dflt, struct netif *ni); -void mib2_remove_route_ip4(u8_t dflt, struct netif *ni); -#endif /* LWIP_IPV4 */ - -/* UDP */ -#if LWIP_UDP -void mib2_udp_bind(struct udp_pcb *pcb); -void mib2_udp_unbind(struct udp_pcb *pcb); -#endif /* LWIP_UDP */ - -#else /* LWIP_MIB2_CALLBACKS */ -/* LWIP_MIB2_CALLBACKS support not available */ -/* define everything to be empty */ - -/* network interface */ -#define mib2_netif_added(ni) -#define mib2_netif_removed(ni) - -/* ARP */ -#define mib2_add_arp_entry(ni,ip) -#define mib2_remove_arp_entry(ni,ip) - -/* IP */ -#define mib2_add_ip4(ni) -#define mib2_remove_ip4(ni) -#define mib2_add_route_ip4(dflt, ni) -#define mib2_remove_route_ip4(dflt, ni) - -/* UDP */ -#define mib2_udp_bind(pcb) -#define mib2_udp_unbind(pcb) -#endif /* LWIP_MIB2_CALLBACKS */ - -/* for source-code compatibility reasons only, can be removed (not used internally) */ -#define NETIF_INIT_SNMP MIB2_INIT_NETIF -#define snmp_add_ifinoctets(ni,value) MIB2_STATS_NETIF_ADD(ni, ifinoctets, value) -#define snmp_inc_ifinucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifinucastpkts) -#define snmp_inc_ifinnucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifinnucastpkts) -#define snmp_inc_ifindiscards(ni) MIB2_STATS_NETIF_INC(ni, ifindiscards) -#define snmp_inc_ifinerrors(ni) MIB2_STATS_NETIF_INC(ni, ifinerrors) -#define snmp_inc_ifinunknownprotos(ni) MIB2_STATS_NETIF_INC(ni, ifinunknownprotos) -#define snmp_add_ifoutoctets(ni,value) MIB2_STATS_NETIF_ADD(ni, ifoutoctets, value) -#define snmp_inc_ifoutucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifoutucastpkts) -#define snmp_inc_ifoutnucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifoutnucastpkts) -#define snmp_inc_ifoutdiscards(ni) MIB2_STATS_NETIF_INC(ni, ifoutdiscards) -#define snmp_inc_ifouterrors(ni) MIB2_STATS_NETIF_INC(ni, ifouterrors) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_SNMP_H */ +/** + * @file + * SNMP support API for implementing netifs and statitics for MIB2 + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Dirk Ziegelmeier + * + */ +#ifndef LWIP_HDR_SNMP_H +#define LWIP_HDR_SNMP_H + +#include "lwip/opt.h" +#include "lwip/ip_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct udp_pcb; +struct netif; + +/** + * @defgroup netif_mib2 MIB2 statistics + * @ingroup netif + */ + +/* MIB2 statistics functions */ +#if MIB2_STATS /* don't build if not configured for use in lwipopts.h */ +/** + * @ingroup netif_mib2 + * @see RFC1213, "MIB-II, 6. Definitions" + */ +enum snmp_ifType { + snmp_ifType_other=1, /* none of the following */ + snmp_ifType_regular1822, + snmp_ifType_hdh1822, + snmp_ifType_ddn_x25, + snmp_ifType_rfc877_x25, + snmp_ifType_ethernet_csmacd, + snmp_ifType_iso88023_csmacd, + snmp_ifType_iso88024_tokenBus, + snmp_ifType_iso88025_tokenRing, + snmp_ifType_iso88026_man, + snmp_ifType_starLan, + snmp_ifType_proteon_10Mbit, + snmp_ifType_proteon_80Mbit, + snmp_ifType_hyperchannel, + snmp_ifType_fddi, + snmp_ifType_lapb, + snmp_ifType_sdlc, + snmp_ifType_ds1, /* T-1 */ + snmp_ifType_e1, /* european equiv. of T-1 */ + snmp_ifType_basicISDN, + snmp_ifType_primaryISDN, /* proprietary serial */ + snmp_ifType_propPointToPointSerial, + snmp_ifType_ppp, + snmp_ifType_softwareLoopback, + snmp_ifType_eon, /* CLNP over IP [11] */ + snmp_ifType_ethernet_3Mbit, + snmp_ifType_nsip, /* XNS over IP */ + snmp_ifType_slip, /* generic SLIP */ + snmp_ifType_ultra, /* ULTRA technologies */ + snmp_ifType_ds3, /* T-3 */ + snmp_ifType_sip, /* SMDS */ + snmp_ifType_frame_relay +}; + +/** This macro has a precision of ~49 days because sys_now returns u32_t. \#define your own if you want ~490 days. */ +#ifndef MIB2_COPY_SYSUPTIME_TO +#define MIB2_COPY_SYSUPTIME_TO(ptrToVal) (*(ptrToVal) = (sys_now() / 10)) +#endif + +/** + * @ingroup netif_mib2 + * Increment stats member for SNMP MIB2 stats (struct stats_mib2_netif_ctrs) + */ +#define MIB2_STATS_NETIF_INC(n, x) do { ++(n)->mib2_counters.x; } while(0) +/** + * @ingroup netif_mib2 + * Add value to stats member for SNMP MIB2 stats (struct stats_mib2_netif_ctrs) + */ +#define MIB2_STATS_NETIF_ADD(n, x, val) do { (n)->mib2_counters.x += (val); } while(0) + +/** + * @ingroup netif_mib2 + * Init MIB2 statistic counters in netif + * @param netif Netif to init + * @param type one of enum @ref snmp_ifType + * @param speed your link speed here (units: bits per second) + */ +#define MIB2_INIT_NETIF(netif, type, speed) do { \ + (netif)->link_type = (type); \ + (netif)->link_speed = (speed);\ + (netif)->ts = 0; \ + (netif)->mib2_counters.ifinoctets = 0; \ + (netif)->mib2_counters.ifinucastpkts = 0; \ + (netif)->mib2_counters.ifinnucastpkts = 0; \ + (netif)->mib2_counters.ifindiscards = 0; \ + (netif)->mib2_counters.ifinerrors = 0; \ + (netif)->mib2_counters.ifinunknownprotos = 0; \ + (netif)->mib2_counters.ifoutoctets = 0; \ + (netif)->mib2_counters.ifoutucastpkts = 0; \ + (netif)->mib2_counters.ifoutnucastpkts = 0; \ + (netif)->mib2_counters.ifoutdiscards = 0; \ + (netif)->mib2_counters.ifouterrors = 0; } while(0) +#else /* MIB2_STATS */ +#ifndef MIB2_COPY_SYSUPTIME_TO +#define MIB2_COPY_SYSUPTIME_TO(ptrToVal) +#endif +#define MIB2_INIT_NETIF(netif, type, speed) +#define MIB2_STATS_NETIF_INC(n, x) +#define MIB2_STATS_NETIF_ADD(n, x, val) +#endif /* MIB2_STATS */ + +/* LWIP MIB2 callbacks */ +#if LWIP_MIB2_CALLBACKS /* don't build if not configured for use in lwipopts.h */ +/* network interface */ +void mib2_netif_added(struct netif *ni); +void mib2_netif_removed(struct netif *ni); + +#if LWIP_IPV4 && LWIP_ARP +/* ARP (for atTable and ipNetToMediaTable) */ +void mib2_add_arp_entry(struct netif *ni, ip4_addr_t *ip); +void mib2_remove_arp_entry(struct netif *ni, ip4_addr_t *ip); +#else /* LWIP_IPV4 && LWIP_ARP */ +#define mib2_add_arp_entry(ni,ip) +#define mib2_remove_arp_entry(ni,ip) +#endif /* LWIP_IPV4 && LWIP_ARP */ + +/* IP */ +#if LWIP_IPV4 +void mib2_add_ip4(struct netif *ni); +void mib2_remove_ip4(struct netif *ni); +void mib2_add_route_ip4(u8_t dflt, struct netif *ni); +void mib2_remove_route_ip4(u8_t dflt, struct netif *ni); +#endif /* LWIP_IPV4 */ + +/* UDP */ +#if LWIP_UDP +void mib2_udp_bind(struct udp_pcb *pcb); +void mib2_udp_unbind(struct udp_pcb *pcb); +#endif /* LWIP_UDP */ + +#else /* LWIP_MIB2_CALLBACKS */ +/* LWIP_MIB2_CALLBACKS support not available */ +/* define everything to be empty */ + +/* network interface */ +#define mib2_netif_added(ni) +#define mib2_netif_removed(ni) + +/* ARP */ +#define mib2_add_arp_entry(ni,ip) +#define mib2_remove_arp_entry(ni,ip) + +/* IP */ +#define mib2_add_ip4(ni) +#define mib2_remove_ip4(ni) +#define mib2_add_route_ip4(dflt, ni) +#define mib2_remove_route_ip4(dflt, ni) + +/* UDP */ +#define mib2_udp_bind(pcb) +#define mib2_udp_unbind(pcb) +#endif /* LWIP_MIB2_CALLBACKS */ + +/* for source-code compatibility reasons only, can be removed (not used internally) */ +#define NETIF_INIT_SNMP MIB2_INIT_NETIF +#define snmp_add_ifinoctets(ni,value) MIB2_STATS_NETIF_ADD(ni, ifinoctets, value) +#define snmp_inc_ifinucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifinucastpkts) +#define snmp_inc_ifinnucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifinnucastpkts) +#define snmp_inc_ifindiscards(ni) MIB2_STATS_NETIF_INC(ni, ifindiscards) +#define snmp_inc_ifinerrors(ni) MIB2_STATS_NETIF_INC(ni, ifinerrors) +#define snmp_inc_ifinunknownprotos(ni) MIB2_STATS_NETIF_INC(ni, ifinunknownprotos) +#define snmp_add_ifoutoctets(ni,value) MIB2_STATS_NETIF_ADD(ni, ifoutoctets, value) +#define snmp_inc_ifoutucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifoutucastpkts) +#define snmp_inc_ifoutnucastpkts(ni) MIB2_STATS_NETIF_INC(ni, ifoutnucastpkts) +#define snmp_inc_ifoutdiscards(ni) MIB2_STATS_NETIF_INC(ni, ifoutdiscards) +#define snmp_inc_ifouterrors(ni) MIB2_STATS_NETIF_INC(ni, ifouterrors) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_SNMP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sockets.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sockets.h index 61a4b258..a07937e3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sockets.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sockets.h @@ -1,688 +1,688 @@ -/** - * @file - * Socket API (to be used from non-TCPIP threads) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - - -#ifndef LWIP_HDR_SOCKETS_H -#define LWIP_HDR_SOCKETS_H - -#include "lwip/opt.h" - -#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/err.h" -#include "lwip/inet.h" -#include "lwip/errno.h" - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -/* If your port already typedef's sa_family_t, define SA_FAMILY_T_DEFINED - to prevent this code from redefining it. */ -#if !defined(sa_family_t) && !defined(SA_FAMILY_T_DEFINED) -typedef u8_t sa_family_t; -#endif -/* If your port already typedef's in_port_t, define IN_PORT_T_DEFINED - to prevent this code from redefining it. */ -#if !defined(in_port_t) && !defined(IN_PORT_T_DEFINED) -typedef u16_t in_port_t; -#endif - -#if LWIP_IPV4 -/* members are in network byte order */ -struct sockaddr_in { - u8_t sin_len; - sa_family_t sin_family; - in_port_t sin_port; - struct in_addr sin_addr; -#define SIN_ZERO_LEN 8 - char sin_zero[SIN_ZERO_LEN]; -}; -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -struct sockaddr_in6 { - u8_t sin6_len; /* length of this structure */ - sa_family_t sin6_family; /* AF_INET6 */ - in_port_t sin6_port; /* Transport layer port # */ - u32_t sin6_flowinfo; /* IPv6 flow information */ - struct in6_addr sin6_addr; /* IPv6 address */ - u32_t sin6_scope_id; /* Set of interfaces for scope */ -}; -#endif /* LWIP_IPV6 */ - -struct sockaddr { - u8_t sa_len; - sa_family_t sa_family; - char sa_data[14]; -}; - -struct sockaddr_storage { - u8_t s2_len; - sa_family_t ss_family; - char s2_data1[2]; - u32_t s2_data2[3]; -#if LWIP_IPV6 - u32_t s2_data3[3]; -#endif /* LWIP_IPV6 */ -}; - -/* If your port already typedef's socklen_t, define SOCKLEN_T_DEFINED - to prevent this code from redefining it. */ -#if !defined(socklen_t) && !defined(SOCKLEN_T_DEFINED) -typedef u32_t socklen_t; -#endif - -#if !defined IOV_MAX -#define IOV_MAX 0xFFFF -#elif IOV_MAX > 0xFFFF -#error "IOV_MAX larger than supported by LwIP" -#endif /* IOV_MAX */ - -#if !defined(iovec) -struct iovec { - void *iov_base; - size_t iov_len; -}; -#endif - -struct msghdr { - void *msg_name; - socklen_t msg_namelen; - struct iovec *msg_iov; - int msg_iovlen; - void *msg_control; - socklen_t msg_controllen; - int msg_flags; -}; - -/* struct msghdr->msg_flags bit field values */ -#define MSG_TRUNC 0x04 -#define MSG_CTRUNC 0x08 - -/* RFC 3542, Section 20: Ancillary Data */ -struct cmsghdr { - socklen_t cmsg_len; /* number of bytes, including header */ - int cmsg_level; /* originating protocol */ - int cmsg_type; /* protocol-specific type */ -}; -/* Data section follows header and possible padding, typically referred to as - unsigned char cmsg_data[]; */ - -/* cmsg header/data alignment. NOTE: we align to native word size (double word -size on 16-bit arch) so structures are not placed at an unaligned address. -16-bit arch needs double word to ensure 32-bit alignment because socklen_t -could be 32 bits. If we ever have cmsg data with a 64-bit variable, alignment -will need to increase long long */ -#define ALIGN_H(size) (((size) + sizeof(long) - 1U) & ~(sizeof(long)-1U)) -#define ALIGN_D(size) ALIGN_H(size) - -#define CMSG_FIRSTHDR(mhdr) \ - ((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? \ - (struct cmsghdr *)(mhdr)->msg_control : \ - (struct cmsghdr *)NULL) - -#define CMSG_NXTHDR(mhdr, cmsg) \ - (((cmsg) == NULL) ? CMSG_FIRSTHDR(mhdr) : \ - (((u8_t *)(cmsg) + ALIGN_H((cmsg)->cmsg_len) \ - + ALIGN_D(sizeof(struct cmsghdr)) > \ - (u8_t *)((mhdr)->msg_control) + (mhdr)->msg_controllen) ? \ - (struct cmsghdr *)NULL : \ - (struct cmsghdr *)((void*)((u8_t *)(cmsg) + \ - ALIGN_H((cmsg)->cmsg_len))))) - -#define CMSG_DATA(cmsg) ((void*)((u8_t *)(cmsg) + \ - ALIGN_D(sizeof(struct cmsghdr)))) - -#define CMSG_SPACE(length) (ALIGN_D(sizeof(struct cmsghdr)) + \ - ALIGN_H(length)) - -#define CMSG_LEN(length) (ALIGN_D(sizeof(struct cmsghdr)) + \ - length) - -/* Set socket options argument */ -#define IFNAMSIZ NETIF_NAMESIZE -struct ifreq { - char ifr_name[IFNAMSIZ]; /* Interface name */ -}; - -/* Socket protocol types (TCP/UDP/RAW) */ -#define SOCK_STREAM 1 -#define SOCK_DGRAM 2 -#define SOCK_RAW 3 - -/* - * Option flags per-socket. These must match the SOF_ flags in ip.h (checked in init.c) - */ -#define SO_REUSEADDR 0x0004 /* Allow local address reuse */ -#define SO_KEEPALIVE 0x0008 /* keep connections alive */ -#define SO_BROADCAST 0x0020 /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */ - - -/* - * Additional options, not kept in so_options. - */ -#define SO_DEBUG 0x0001 /* Unimplemented: turn on debugging info recording */ -#define SO_ACCEPTCONN 0x0002 /* socket has had listen() */ -#define SO_DONTROUTE 0x0010 /* Unimplemented: just use interface addresses */ -#define SO_USELOOPBACK 0x0040 /* Unimplemented: bypass hardware when possible */ -#define SO_LINGER 0x0080 /* linger on close if data present */ -#define SO_DONTLINGER ((int)(~SO_LINGER)) -#define SO_OOBINLINE 0x0100 /* Unimplemented: leave received OOB data in line */ -#define SO_REUSEPORT 0x0200 /* Unimplemented: allow local address & port reuse */ -#define SO_SNDBUF 0x1001 /* Unimplemented: send buffer size */ -#define SO_RCVBUF 0x1002 /* receive buffer size */ -#define SO_SNDLOWAT 0x1003 /* Unimplemented: send low-water mark */ -#define SO_RCVLOWAT 0x1004 /* Unimplemented: receive low-water mark */ -#define SO_SNDTIMEO 0x1005 /* send timeout */ -#define SO_RCVTIMEO 0x1006 /* receive timeout */ -#define SO_ERROR 0x1007 /* get error status and clear */ -#define SO_TYPE 0x1008 /* get socket type */ -#define SO_CONTIMEO 0x1009 /* Unimplemented: connect timeout */ -#define SO_NO_CHECK 0x100a /* don't create UDP checksum */ -#define SO_BINDTODEVICE 0x100b /* bind to device */ - -/* - * Structure used for manipulating linger option. - */ -struct linger { - int l_onoff; /* option on/off */ - int l_linger; /* linger time in seconds */ -}; - -/* - * Level number for (get/set)sockopt() to apply to socket itself. - */ -#define SOL_SOCKET 0xfff /* options for socket level */ - - -#define AF_UNSPEC 0 -#define AF_INET 2 -#if LWIP_IPV6 -#define AF_INET6 10 -#else /* LWIP_IPV6 */ -#define AF_INET6 AF_UNSPEC -#endif /* LWIP_IPV6 */ -#define PF_INET AF_INET -#define PF_INET6 AF_INET6 -#define PF_UNSPEC AF_UNSPEC - -#define IPPROTO_IP 0 -#define IPPROTO_ICMP 1 -#define IPPROTO_TCP 6 -#define IPPROTO_UDP 17 -#if LWIP_IPV6 -#define IPPROTO_IPV6 41 -#define IPPROTO_ICMPV6 58 -#endif /* LWIP_IPV6 */ -#define IPPROTO_UDPLITE 136 -#define IPPROTO_RAW 255 - -/* Flags we can use with send and recv. */ -#define MSG_PEEK 0x01 /* Peeks at an incoming message */ -#define MSG_WAITALL 0x02 /* Unimplemented: Requests that the function block until the full amount of data requested can be returned */ -#define MSG_OOB 0x04 /* Unimplemented: Requests out-of-band data. The significance and semantics of out-of-band data are protocol-specific */ -#define MSG_DONTWAIT 0x08 /* Nonblocking i/o for this operation only */ -#define MSG_MORE 0x10 /* Sender will send more */ -#define MSG_NOSIGNAL 0x20 /* Uninmplemented: Requests not to send the SIGPIPE signal if an attempt to send is made on a stream-oriented socket that is no longer connected. */ - - -/* - * Options for level IPPROTO_IP - */ -#define IP_TOS 1 -#define IP_TTL 2 -#define IP_PKTINFO 8 - -#if LWIP_TCP -/* - * Options for level IPPROTO_TCP - */ -#define TCP_NODELAY 0x01 /* don't delay send to coalesce packets */ -#define TCP_KEEPALIVE 0x02 /* send KEEPALIVE probes when idle for pcb->keep_idle milliseconds */ -#define TCP_KEEPIDLE 0x03 /* set pcb->keep_idle - Same as TCP_KEEPALIVE, but use seconds for get/setsockopt */ -#define TCP_KEEPINTVL 0x04 /* set pcb->keep_intvl - Use seconds for get/setsockopt */ -#define TCP_KEEPCNT 0x05 /* set pcb->keep_cnt - Use number of probes sent for get/setsockopt */ -#endif /* LWIP_TCP */ - -#if LWIP_IPV6 -/* - * Options for level IPPROTO_IPV6 - */ -#define IPV6_CHECKSUM 7 /* RFC3542: calculate and insert the ICMPv6 checksum for raw sockets. */ -#define IPV6_V6ONLY 27 /* RFC3493: boolean control to restrict AF_INET6 sockets to IPv6 communications only. */ -#endif /* LWIP_IPV6 */ - -#if LWIP_UDP && LWIP_UDPLITE -/* - * Options for level IPPROTO_UDPLITE - */ -#define UDPLITE_SEND_CSCOV 0x01 /* sender checksum coverage */ -#define UDPLITE_RECV_CSCOV 0x02 /* minimal receiver checksum coverage */ -#endif /* LWIP_UDP && LWIP_UDPLITE*/ - - -#if LWIP_MULTICAST_TX_OPTIONS -/* - * Options and types for UDP multicast traffic handling - */ -#define IP_MULTICAST_TTL 5 -#define IP_MULTICAST_IF 6 -#define IP_MULTICAST_LOOP 7 -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - -#if LWIP_IGMP -/* - * Options and types related to multicast membership - */ -#define IP_ADD_MEMBERSHIP 3 -#define IP_DROP_MEMBERSHIP 4 - -typedef struct ip_mreq { - struct in_addr imr_multiaddr; /* IP multicast address of group */ - struct in_addr imr_interface; /* local IP address of interface */ -} ip_mreq; -#endif /* LWIP_IGMP */ - -#if LWIP_IPV4 -struct in_pktinfo { - unsigned int ipi_ifindex; /* Interface index */ - struct in_addr ipi_addr; /* Destination (from header) address */ -}; -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6_MLD -/* - * Options and types related to IPv6 multicast membership - */ -#define IPV6_JOIN_GROUP 12 -#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP -#define IPV6_LEAVE_GROUP 13 -#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP - -typedef struct ipv6_mreq { - struct in6_addr ipv6mr_multiaddr; /* IPv6 multicast addr */ - unsigned int ipv6mr_interface; /* interface index, or 0 */ -} ipv6_mreq; -#endif /* LWIP_IPV6_MLD */ - -/* - * The Type of Service provides an indication of the abstract - * parameters of the quality of service desired. These parameters are - * to be used to guide the selection of the actual service parameters - * when transmitting a datagram through a particular network. Several - * networks offer service precedence, which somehow treats high - * precedence traffic as more important than other traffic (generally - * by accepting only traffic above a certain precedence at time of high - * load). The major choice is a three way tradeoff between low-delay, - * high-reliability, and high-throughput. - * The use of the Delay, Throughput, and Reliability indications may - * increase the cost (in some sense) of the service. In many networks - * better performance for one of these parameters is coupled with worse - * performance on another. Except for very unusual cases at most two - * of these three indications should be set. - */ -#define IPTOS_TOS_MASK 0x1E -#define IPTOS_TOS(tos) ((tos) & IPTOS_TOS_MASK) -#define IPTOS_LOWDELAY 0x10 -#define IPTOS_THROUGHPUT 0x08 -#define IPTOS_RELIABILITY 0x04 -#define IPTOS_LOWCOST 0x02 -#define IPTOS_MINCOST IPTOS_LOWCOST - -/* - * The Network Control precedence designation is intended to be used - * within a network only. The actual use and control of that - * designation is up to each network. The Internetwork Control - * designation is intended for use by gateway control originators only. - * If the actual use of these precedence designations is of concern to - * a particular network, it is the responsibility of that network to - * control the access to, and use of, those precedence designations. - */ -#define IPTOS_PREC_MASK 0xe0 -#define IPTOS_PREC(tos) ((tos) & IPTOS_PREC_MASK) -#define IPTOS_PREC_NETCONTROL 0xe0 -#define IPTOS_PREC_INTERNETCONTROL 0xc0 -#define IPTOS_PREC_CRITIC_ECP 0xa0 -#define IPTOS_PREC_FLASHOVERRIDE 0x80 -#define IPTOS_PREC_FLASH 0x60 -#define IPTOS_PREC_IMMEDIATE 0x40 -#define IPTOS_PREC_PRIORITY 0x20 -#define IPTOS_PREC_ROUTINE 0x00 - - -/* - * Commands for ioctlsocket(), taken from the BSD file fcntl.h. - * lwip_ioctl only supports FIONREAD and FIONBIO, for now - * - * Ioctl's have the command encoded in the lower word, - * and the size of any in or out parameters in the upper - * word. The high 2 bits of the upper word are used - * to encode the in/out status of the parameter; for now - * we restrict parameters to at most 128 bytes. - */ -#if !defined(FIONREAD) || !defined(FIONBIO) -#define IOCPARM_MASK 0x7fU /* parameters must be < 128 bytes */ -#define IOC_VOID 0x20000000UL /* no parameters */ -#define IOC_OUT 0x40000000UL /* copy out parameters */ -#define IOC_IN 0x80000000UL /* copy in parameters */ -#define IOC_INOUT (IOC_IN|IOC_OUT) - /* 0x20000000 distinguishes new & - old ioctl's */ -#define _IO(x,y) ((long)(IOC_VOID|((x)<<8)|(y))) - -#define _IOR(x,y,t) ((long)(IOC_OUT|((sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y))) - -#define _IOW(x,y,t) ((long)(IOC_IN|((sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y))) -#endif /* !defined(FIONREAD) || !defined(FIONBIO) */ - -#ifndef FIONREAD -#define FIONREAD _IOR('f', 127, unsigned long) /* get # bytes to read */ -#endif -#ifndef FIONBIO -#define FIONBIO _IOW('f', 126, unsigned long) /* set/clear non-blocking i/o */ -#endif - -/* Socket I/O Controls: unimplemented */ -#ifndef SIOCSHIWAT -#define SIOCSHIWAT _IOW('s', 0, unsigned long) /* set high watermark */ -#define SIOCGHIWAT _IOR('s', 1, unsigned long) /* get high watermark */ -#define SIOCSLOWAT _IOW('s', 2, unsigned long) /* set low watermark */ -#define SIOCGLOWAT _IOR('s', 3, unsigned long) /* get low watermark */ -#define SIOCATMARK _IOR('s', 7, unsigned long) /* at oob mark? */ -#endif - -/* commands for fnctl */ -#ifndef F_GETFL -#define F_GETFL 3 -#endif -#ifndef F_SETFL -#define F_SETFL 4 -#endif - -/* File status flags and file access modes for fnctl, - these are bits in an int. */ -#ifndef O_NONBLOCK -#define O_NONBLOCK 1 /* nonblocking I/O */ -#endif -#ifndef O_NDELAY -#define O_NDELAY O_NONBLOCK /* same as O_NONBLOCK, for compatibility */ -#endif -#ifndef O_RDONLY -#define O_RDONLY 2 -#endif -#ifndef O_WRONLY -#define O_WRONLY 4 -#endif -#ifndef O_RDWR -#define O_RDWR (O_RDONLY|O_WRONLY) -#endif - -#ifndef SHUT_RD - #define SHUT_RD 0 - #define SHUT_WR 1 - #define SHUT_RDWR 2 -#endif - -/* FD_SET used for lwip_select */ -#ifndef FD_SET -#undef FD_SETSIZE -/* Make FD_SETSIZE match NUM_SOCKETS in socket.c */ -#define FD_SETSIZE MEMP_NUM_NETCONN -#define LWIP_SELECT_MAXNFDS (FD_SETSIZE + LWIP_SOCKET_OFFSET) -#define FDSETSAFESET(n, code) do { \ - if (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0)) { \ - code; }} while(0) -#define FDSETSAFEGET(n, code) (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0) ?\ - (code) : 0) -#define FD_SET(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] | (1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))) -#define FD_CLR(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] & ~(1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))) -#define FD_ISSET(n,p) FDSETSAFEGET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] & (1 << (((n)-LWIP_SOCKET_OFFSET) & 7))) -#define FD_ZERO(p) memset((void*)(p), 0, sizeof(*(p))) - -typedef struct fd_set -{ - unsigned char fd_bits [(FD_SETSIZE+7)/8]; -} fd_set; - -#elif FD_SETSIZE < (LWIP_SOCKET_OFFSET + MEMP_NUM_NETCONN) -#error "external FD_SETSIZE too small for number of sockets" -#else -#define LWIP_SELECT_MAXNFDS FD_SETSIZE -#endif /* FD_SET */ - -/* poll-related defines and types */ -/* @todo: find a better way to guard the definition of these defines and types if already defined */ -#if !defined(POLLIN) && !defined(POLLOUT) -#define POLLIN 0x1 -#define POLLOUT 0x2 -#define POLLERR 0x4 -#define POLLNVAL 0x8 -/* Below values are unimplemented */ -#define POLLRDNORM 0x10 -#define POLLRDBAND 0x20 -#define POLLPRI 0x40 -#define POLLWRNORM 0x80 -#define POLLWRBAND 0x100 -#define POLLHUP 0x200 -typedef unsigned int nfds_t; -struct pollfd -{ - int fd; - short events; - short revents; -}; -#endif - -/** LWIP_TIMEVAL_PRIVATE: if you want to use the struct timeval provided - * by your system, set this to 0 and include in cc.h */ -#ifndef LWIP_TIMEVAL_PRIVATE -#define LWIP_TIMEVAL_PRIVATE 1 -#endif - -#if LWIP_TIMEVAL_PRIVATE -// struct timeval { -// long tv_sec; /* seconds */ -// long tv_usec; /* and microseconds */ -// }; -#endif /* LWIP_TIMEVAL_PRIVATE */ - -#define lwip_socket_init() /* Compatibility define, no init needed. */ -void lwip_socket_thread_init(void); /* LWIP_NETCONN_SEM_PER_THREAD==1: initialize thread-local semaphore */ -void lwip_socket_thread_cleanup(void); /* LWIP_NETCONN_SEM_PER_THREAD==1: destroy thread-local semaphore */ - -#if LWIP_COMPAT_SOCKETS == 2 -/* This helps code parsers/code completion by not having the COMPAT functions as defines */ -#define lwip_accept accept -#define lwip_bind bind -#define lwip_shutdown shutdown -#define lwip_getpeername getpeername -#define lwip_getsockname getsockname -#define lwip_setsockopt setsockopt -#define lwip_getsockopt getsockopt -#define lwip_close closesocket -#define lwip_connect connect -#define lwip_listen listen -#define lwip_recv recv -#define lwip_recvmsg recvmsg -#define lwip_recvfrom recvfrom -#define lwip_send send -#define lwip_sendmsg sendmsg -#define lwip_sendto sendto -#define lwip_socket socket -#if LWIP_SOCKET_SELECT -#define lwip_select select -#endif -#if LWIP_SOCKET_POLL -#define lwip_poll poll -#endif -#define lwip_ioctl ioctlsocket -#define lwip_inet_ntop inet_ntop -#define lwip_inet_pton inet_pton - -#if LWIP_POSIX_SOCKETS_IO_NAMES -#define lwip_read read -#define lwip_readv readv -#define lwip_write write -#define lwip_writev writev -#undef lwip_close -#define lwip_close close -#define closesocket(s) close(s) -int fcntl(int s, int cmd, ...); -#undef lwip_ioctl -#define lwip_ioctl ioctl -#define ioctlsocket ioctl -#endif /* LWIP_POSIX_SOCKETS_IO_NAMES */ -#endif /* LWIP_COMPAT_SOCKETS == 2 */ - -int lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen); -int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen); -int lwip_shutdown(int s, int how); -int lwip_getpeername (int s, struct sockaddr *name, socklen_t *namelen); -int lwip_getsockname (int s, struct sockaddr *name, socklen_t *namelen); -int lwip_getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen); -int lwip_setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen); - int lwip_close(int s); -int lwip_connect(int s, const struct sockaddr *name, socklen_t namelen); -int lwip_listen(int s, int backlog); -ssize_t lwip_recv(int s, void *mem, size_t len, int flags); -ssize_t lwip_read(int s, void *mem, size_t len); -ssize_t lwip_readv(int s, const struct iovec *iov, int iovcnt); -ssize_t lwip_recvfrom(int s, void *mem, size_t len, int flags, - struct sockaddr *from, socklen_t *fromlen); -ssize_t lwip_recvmsg(int s, struct msghdr *message, int flags); -ssize_t lwip_send(int s, const void *dataptr, size_t size, int flags); -ssize_t lwip_sendmsg(int s, const struct msghdr *message, int flags); -ssize_t lwip_sendto(int s, const void *dataptr, size_t size, int flags, - const struct sockaddr *to, socklen_t tolen); -int lwip_socket(int domain, int type, int protocol); -ssize_t lwip_write(int s, const void *dataptr, size_t size); -ssize_t lwip_writev(int s, const struct iovec *iov, int iovcnt); -#if LWIP_SOCKET_SELECT -int lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, - struct timeval *timeout); -#endif -#if LWIP_SOCKET_POLL -int lwip_poll(struct pollfd *fds, nfds_t nfds, int timeout); -#endif -int lwip_ioctl(int s, long cmd, void *argp); -int lwip_fcntl(int s, int cmd, int val); -const char *lwip_inet_ntop(int af, const void *src, char *dst, socklen_t size); -int lwip_inet_pton(int af, const char *src, void *dst); - -#if LWIP_COMPAT_SOCKETS -#if LWIP_COMPAT_SOCKETS != 2 -/** @ingroup socket */ -#define accept(s,addr,addrlen) lwip_accept(s,addr,addrlen) -/** @ingroup socket */ -#define bind(s,name,namelen) lwip_bind(s,name,namelen) -/** @ingroup socket */ -#define shutdown(s,how) lwip_shutdown(s,how) -/** @ingroup socket */ -#define getpeername(s,name,namelen) lwip_getpeername(s,name,namelen) -/** @ingroup socket */ -#define getsockname(s,name,namelen) lwip_getsockname(s,name,namelen) -/** @ingroup socket */ -#define setsockopt(s,level,optname,opval,optlen) lwip_setsockopt(s,level,optname,opval,optlen) -/** @ingroup socket */ -#define getsockopt(s,level,optname,opval,optlen) lwip_getsockopt(s,level,optname,opval,optlen) -/** @ingroup socket */ -#define closesocket(s) lwip_close(s) -/** @ingroup socket */ -#define connect(s,name,namelen) lwip_connect(s,name,namelen) -/** @ingroup socket */ -#define listen(s,backlog) lwip_listen(s,backlog) -/** @ingroup socket */ -#define recv(s,mem,len,flags) lwip_recv(s,mem,len,flags) -/** @ingroup socket */ -#define recvmsg(s,message,flags) lwip_recvmsg(s,message,flags) -/** @ingroup socket */ -#define recvfrom(s,mem,len,flags,from,fromlen) lwip_recvfrom(s,mem,len,flags,from,fromlen) -/** @ingroup socket */ -#define send(s,dataptr,size,flags) lwip_send(s,dataptr,size,flags) -/** @ingroup socket */ -#define sendmsg(s,message,flags) lwip_sendmsg(s,message,flags) -/** @ingroup socket */ -#define sendto(s,dataptr,size,flags,to,tolen) lwip_sendto(s,dataptr,size,flags,to,tolen) -/** @ingroup socket */ -#define socket(domain,type,protocol) lwip_socket(domain,type,protocol) -#if LWIP_SOCKET_SELECT -/** @ingroup socket */ -#define select(maxfdp1,readset,writeset,exceptset,timeout) lwip_select(maxfdp1,readset,writeset,exceptset,timeout) -#endif -#if LWIP_SOCKET_POLL -/** @ingroup socket */ -#define poll(fds,nfds,timeout) lwip_poll(fds,nfds,timeout) -#endif -/** @ingroup socket */ -#define ioctlsocket(s,cmd,argp) lwip_ioctl(s,cmd,argp) -/** @ingroup socket */ -#define inet_ntop(af,src,dst,size) lwip_inet_ntop(af,src,dst,size) -/** @ingroup socket */ -#define inet_pton(af,src,dst) lwip_inet_pton(af,src,dst) - -#if LWIP_POSIX_SOCKETS_IO_NAMES -/** @ingroup socket */ -#define read(s,mem,len) lwip_read(s,mem,len) -/** @ingroup socket */ -#define readv(s,iov,iovcnt) lwip_readv(s,iov,iovcnt) -/** @ingroup socket */ -#define write(s,dataptr,len) lwip_write(s,dataptr,len) -/** @ingroup socket */ -#define writev(s,iov,iovcnt) lwip_writev(s,iov,iovcnt) -/** @ingroup socket */ -#define close(s) lwip_close(s) -/** @ingroup socket */ -#define fcntl(s,cmd,val) lwip_fcntl(s,cmd,val) -/** @ingroup socket */ -#define ioctl(s,cmd,argp) lwip_ioctl(s,cmd,argp) -#endif /* LWIP_POSIX_SOCKETS_IO_NAMES */ -#endif /* LWIP_COMPAT_SOCKETS != 2 */ - -#endif /* LWIP_COMPAT_SOCKETS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_SOCKET */ - -#endif /* LWIP_HDR_SOCKETS_H */ +/** + * @file + * Socket API (to be used from non-TCPIP threads) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + + +#ifndef LWIP_HDR_SOCKETS_H +#define LWIP_HDR_SOCKETS_H + +#include "lwip/opt.h" + +#if LWIP_SOCKET /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/err.h" +#include "lwip/inet.h" +#include "lwip/errno.h" + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/* If your port already typedef's sa_family_t, define SA_FAMILY_T_DEFINED + to prevent this code from redefining it. */ +#if !defined(sa_family_t) && !defined(SA_FAMILY_T_DEFINED) +typedef u8_t sa_family_t; +#endif +/* If your port already typedef's in_port_t, define IN_PORT_T_DEFINED + to prevent this code from redefining it. */ +#if !defined(in_port_t) && !defined(IN_PORT_T_DEFINED) +typedef u16_t in_port_t; +#endif + +#if LWIP_IPV4 +/* members are in network byte order */ +struct sockaddr_in { + u8_t sin_len; + sa_family_t sin_family; + in_port_t sin_port; + struct in_addr sin_addr; +#define SIN_ZERO_LEN 8 + char sin_zero[SIN_ZERO_LEN]; +}; +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +struct sockaddr_in6 { + u8_t sin6_len; /* length of this structure */ + sa_family_t sin6_family; /* AF_INET6 */ + in_port_t sin6_port; /* Transport layer port # */ + u32_t sin6_flowinfo; /* IPv6 flow information */ + struct in6_addr sin6_addr; /* IPv6 address */ + u32_t sin6_scope_id; /* Set of interfaces for scope */ +}; +#endif /* LWIP_IPV6 */ + +struct sockaddr { + u8_t sa_len; + sa_family_t sa_family; + char sa_data[14]; +}; + +struct sockaddr_storage { + u8_t s2_len; + sa_family_t ss_family; + char s2_data1[2]; + u32_t s2_data2[3]; +#if LWIP_IPV6 + u32_t s2_data3[3]; +#endif /* LWIP_IPV6 */ +}; + +/* If your port already typedef's socklen_t, define SOCKLEN_T_DEFINED + to prevent this code from redefining it. */ +#if !defined(socklen_t) && !defined(SOCKLEN_T_DEFINED) +typedef u32_t socklen_t; +#endif + +#if !defined IOV_MAX +#define IOV_MAX 0xFFFF +#elif IOV_MAX > 0xFFFF +#error "IOV_MAX larger than supported by LwIP" +#endif /* IOV_MAX */ + +#if !defined(iovec) +struct iovec { + void *iov_base; + size_t iov_len; +}; +#endif + +struct msghdr { + void *msg_name; + socklen_t msg_namelen; + struct iovec *msg_iov; + int msg_iovlen; + void *msg_control; + socklen_t msg_controllen; + int msg_flags; +}; + +/* struct msghdr->msg_flags bit field values */ +#define MSG_TRUNC 0x04 +#define MSG_CTRUNC 0x08 + +/* RFC 3542, Section 20: Ancillary Data */ +struct cmsghdr { + socklen_t cmsg_len; /* number of bytes, including header */ + int cmsg_level; /* originating protocol */ + int cmsg_type; /* protocol-specific type */ +}; +/* Data section follows header and possible padding, typically referred to as + unsigned char cmsg_data[]; */ + +/* cmsg header/data alignment. NOTE: we align to native word size (double word +size on 16-bit arch) so structures are not placed at an unaligned address. +16-bit arch needs double word to ensure 32-bit alignment because socklen_t +could be 32 bits. If we ever have cmsg data with a 64-bit variable, alignment +will need to increase long long */ +#define ALIGN_H(size) (((size) + sizeof(long) - 1U) & ~(sizeof(long)-1U)) +#define ALIGN_D(size) ALIGN_H(size) + +#define CMSG_FIRSTHDR(mhdr) \ + ((mhdr)->msg_controllen >= sizeof(struct cmsghdr) ? \ + (struct cmsghdr *)(mhdr)->msg_control : \ + (struct cmsghdr *)NULL) + +#define CMSG_NXTHDR(mhdr, cmsg) \ + (((cmsg) == NULL) ? CMSG_FIRSTHDR(mhdr) : \ + (((u8_t *)(cmsg) + ALIGN_H((cmsg)->cmsg_len) \ + + ALIGN_D(sizeof(struct cmsghdr)) > \ + (u8_t *)((mhdr)->msg_control) + (mhdr)->msg_controllen) ? \ + (struct cmsghdr *)NULL : \ + (struct cmsghdr *)((void*)((u8_t *)(cmsg) + \ + ALIGN_H((cmsg)->cmsg_len))))) + +#define CMSG_DATA(cmsg) ((void*)((u8_t *)(cmsg) + \ + ALIGN_D(sizeof(struct cmsghdr)))) + +#define CMSG_SPACE(length) (ALIGN_D(sizeof(struct cmsghdr)) + \ + ALIGN_H(length)) + +#define CMSG_LEN(length) (ALIGN_D(sizeof(struct cmsghdr)) + \ + length) + +/* Set socket options argument */ +#define IFNAMSIZ NETIF_NAMESIZE +struct ifreq { + char ifr_name[IFNAMSIZ]; /* Interface name */ +}; + +/* Socket protocol types (TCP/UDP/RAW) */ +#define SOCK_STREAM 1 +#define SOCK_DGRAM 2 +#define SOCK_RAW 3 + +/* + * Option flags per-socket. These must match the SOF_ flags in ip.h (checked in init.c) + */ +#define SO_REUSEADDR 0x0004 /* Allow local address reuse */ +#define SO_KEEPALIVE 0x0008 /* keep connections alive */ +#define SO_BROADCAST 0x0020 /* permit to send and to receive broadcast messages (see IP_SOF_BROADCAST option) */ + + +/* + * Additional options, not kept in so_options. + */ +#define SO_DEBUG 0x0001 /* Unimplemented: turn on debugging info recording */ +#define SO_ACCEPTCONN 0x0002 /* socket has had listen() */ +#define SO_DONTROUTE 0x0010 /* Unimplemented: just use interface addresses */ +#define SO_USELOOPBACK 0x0040 /* Unimplemented: bypass hardware when possible */ +#define SO_LINGER 0x0080 /* linger on close if data present */ +#define SO_DONTLINGER ((int)(~SO_LINGER)) +#define SO_OOBINLINE 0x0100 /* Unimplemented: leave received OOB data in line */ +#define SO_REUSEPORT 0x0200 /* Unimplemented: allow local address & port reuse */ +#define SO_SNDBUF 0x1001 /* Unimplemented: send buffer size */ +#define SO_RCVBUF 0x1002 /* receive buffer size */ +#define SO_SNDLOWAT 0x1003 /* Unimplemented: send low-water mark */ +#define SO_RCVLOWAT 0x1004 /* Unimplemented: receive low-water mark */ +#define SO_SNDTIMEO 0x1005 /* send timeout */ +#define SO_RCVTIMEO 0x1006 /* receive timeout */ +#define SO_ERROR 0x1007 /* get error status and clear */ +#define SO_TYPE 0x1008 /* get socket type */ +#define SO_CONTIMEO 0x1009 /* Unimplemented: connect timeout */ +#define SO_NO_CHECK 0x100a /* don't create UDP checksum */ +#define SO_BINDTODEVICE 0x100b /* bind to device */ + +/* + * Structure used for manipulating linger option. + */ +struct linger { + int l_onoff; /* option on/off */ + int l_linger; /* linger time in seconds */ +}; + +/* + * Level number for (get/set)sockopt() to apply to socket itself. + */ +#define SOL_SOCKET 0xfff /* options for socket level */ + + +#define AF_UNSPEC 0 +#define AF_INET 2 +#if LWIP_IPV6 +#define AF_INET6 10 +#else /* LWIP_IPV6 */ +#define AF_INET6 AF_UNSPEC +#endif /* LWIP_IPV6 */ +#define PF_INET AF_INET +#define PF_INET6 AF_INET6 +#define PF_UNSPEC AF_UNSPEC + +#define IPPROTO_IP 0 +#define IPPROTO_ICMP 1 +#define IPPROTO_TCP 6 +#define IPPROTO_UDP 17 +#if LWIP_IPV6 +#define IPPROTO_IPV6 41 +#define IPPROTO_ICMPV6 58 +#endif /* LWIP_IPV6 */ +#define IPPROTO_UDPLITE 136 +#define IPPROTO_RAW 255 + +/* Flags we can use with send and recv. */ +#define MSG_PEEK 0x01 /* Peeks at an incoming message */ +#define MSG_WAITALL 0x02 /* Unimplemented: Requests that the function block until the full amount of data requested can be returned */ +#define MSG_OOB 0x04 /* Unimplemented: Requests out-of-band data. The significance and semantics of out-of-band data are protocol-specific */ +#define MSG_DONTWAIT 0x08 /* Nonblocking i/o for this operation only */ +#define MSG_MORE 0x10 /* Sender will send more */ +#define MSG_NOSIGNAL 0x20 /* Uninmplemented: Requests not to send the SIGPIPE signal if an attempt to send is made on a stream-oriented socket that is no longer connected. */ + + +/* + * Options for level IPPROTO_IP + */ +#define IP_TOS 1 +#define IP_TTL 2 +#define IP_PKTINFO 8 + +#if LWIP_TCP +/* + * Options for level IPPROTO_TCP + */ +#define TCP_NODELAY 0x01 /* don't delay send to coalesce packets */ +#define TCP_KEEPALIVE 0x02 /* send KEEPALIVE probes when idle for pcb->keep_idle milliseconds */ +#define TCP_KEEPIDLE 0x03 /* set pcb->keep_idle - Same as TCP_KEEPALIVE, but use seconds for get/setsockopt */ +#define TCP_KEEPINTVL 0x04 /* set pcb->keep_intvl - Use seconds for get/setsockopt */ +#define TCP_KEEPCNT 0x05 /* set pcb->keep_cnt - Use number of probes sent for get/setsockopt */ +#endif /* LWIP_TCP */ + +#if LWIP_IPV6 +/* + * Options for level IPPROTO_IPV6 + */ +#define IPV6_CHECKSUM 7 /* RFC3542: calculate and insert the ICMPv6 checksum for raw sockets. */ +#define IPV6_V6ONLY 27 /* RFC3493: boolean control to restrict AF_INET6 sockets to IPv6 communications only. */ +#endif /* LWIP_IPV6 */ + +#if LWIP_UDP && LWIP_UDPLITE +/* + * Options for level IPPROTO_UDPLITE + */ +#define UDPLITE_SEND_CSCOV 0x01 /* sender checksum coverage */ +#define UDPLITE_RECV_CSCOV 0x02 /* minimal receiver checksum coverage */ +#endif /* LWIP_UDP && LWIP_UDPLITE*/ + + +#if LWIP_MULTICAST_TX_OPTIONS +/* + * Options and types for UDP multicast traffic handling + */ +#define IP_MULTICAST_TTL 5 +#define IP_MULTICAST_IF 6 +#define IP_MULTICAST_LOOP 7 +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + +#if LWIP_IGMP +/* + * Options and types related to multicast membership + */ +#define IP_ADD_MEMBERSHIP 3 +#define IP_DROP_MEMBERSHIP 4 + +typedef struct ip_mreq { + struct in_addr imr_multiaddr; /* IP multicast address of group */ + struct in_addr imr_interface; /* local IP address of interface */ +} ip_mreq; +#endif /* LWIP_IGMP */ + +#if LWIP_IPV4 +struct in_pktinfo { + unsigned int ipi_ifindex; /* Interface index */ + struct in_addr ipi_addr; /* Destination (from header) address */ +}; +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6_MLD +/* + * Options and types related to IPv6 multicast membership + */ +#define IPV6_JOIN_GROUP 12 +#define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP +#define IPV6_LEAVE_GROUP 13 +#define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP + +typedef struct ipv6_mreq { + struct in6_addr ipv6mr_multiaddr; /* IPv6 multicast addr */ + unsigned int ipv6mr_interface; /* interface index, or 0 */ +} ipv6_mreq; +#endif /* LWIP_IPV6_MLD */ + +/* + * The Type of Service provides an indication of the abstract + * parameters of the quality of service desired. These parameters are + * to be used to guide the selection of the actual service parameters + * when transmitting a datagram through a particular network. Several + * networks offer service precedence, which somehow treats high + * precedence traffic as more important than other traffic (generally + * by accepting only traffic above a certain precedence at time of high + * load). The major choice is a three way tradeoff between low-delay, + * high-reliability, and high-throughput. + * The use of the Delay, Throughput, and Reliability indications may + * increase the cost (in some sense) of the service. In many networks + * better performance for one of these parameters is coupled with worse + * performance on another. Except for very unusual cases at most two + * of these three indications should be set. + */ +#define IPTOS_TOS_MASK 0x1E +#define IPTOS_TOS(tos) ((tos) & IPTOS_TOS_MASK) +#define IPTOS_LOWDELAY 0x10 +#define IPTOS_THROUGHPUT 0x08 +#define IPTOS_RELIABILITY 0x04 +#define IPTOS_LOWCOST 0x02 +#define IPTOS_MINCOST IPTOS_LOWCOST + +/* + * The Network Control precedence designation is intended to be used + * within a network only. The actual use and control of that + * designation is up to each network. The Internetwork Control + * designation is intended for use by gateway control originators only. + * If the actual use of these precedence designations is of concern to + * a particular network, it is the responsibility of that network to + * control the access to, and use of, those precedence designations. + */ +#define IPTOS_PREC_MASK 0xe0 +#define IPTOS_PREC(tos) ((tos) & IPTOS_PREC_MASK) +#define IPTOS_PREC_NETCONTROL 0xe0 +#define IPTOS_PREC_INTERNETCONTROL 0xc0 +#define IPTOS_PREC_CRITIC_ECP 0xa0 +#define IPTOS_PREC_FLASHOVERRIDE 0x80 +#define IPTOS_PREC_FLASH 0x60 +#define IPTOS_PREC_IMMEDIATE 0x40 +#define IPTOS_PREC_PRIORITY 0x20 +#define IPTOS_PREC_ROUTINE 0x00 + + +/* + * Commands for ioctlsocket(), taken from the BSD file fcntl.h. + * lwip_ioctl only supports FIONREAD and FIONBIO, for now + * + * Ioctl's have the command encoded in the lower word, + * and the size of any in or out parameters in the upper + * word. The high 2 bits of the upper word are used + * to encode the in/out status of the parameter; for now + * we restrict parameters to at most 128 bytes. + */ +#if !defined(FIONREAD) || !defined(FIONBIO) +#define IOCPARM_MASK 0x7fU /* parameters must be < 128 bytes */ +#define IOC_VOID 0x20000000UL /* no parameters */ +#define IOC_OUT 0x40000000UL /* copy out parameters */ +#define IOC_IN 0x80000000UL /* copy in parameters */ +#define IOC_INOUT (IOC_IN|IOC_OUT) + /* 0x20000000 distinguishes new & + old ioctl's */ +#define _IO(x,y) ((long)(IOC_VOID|((x)<<8)|(y))) + +#define _IOR(x,y,t) ((long)(IOC_OUT|((sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y))) + +#define _IOW(x,y,t) ((long)(IOC_IN|((sizeof(t)&IOCPARM_MASK)<<16)|((x)<<8)|(y))) +#endif /* !defined(FIONREAD) || !defined(FIONBIO) */ + +#ifndef FIONREAD +#define FIONREAD _IOR('f', 127, unsigned long) /* get # bytes to read */ +#endif +#ifndef FIONBIO +#define FIONBIO _IOW('f', 126, unsigned long) /* set/clear non-blocking i/o */ +#endif + +/* Socket I/O Controls: unimplemented */ +#ifndef SIOCSHIWAT +#define SIOCSHIWAT _IOW('s', 0, unsigned long) /* set high watermark */ +#define SIOCGHIWAT _IOR('s', 1, unsigned long) /* get high watermark */ +#define SIOCSLOWAT _IOW('s', 2, unsigned long) /* set low watermark */ +#define SIOCGLOWAT _IOR('s', 3, unsigned long) /* get low watermark */ +#define SIOCATMARK _IOR('s', 7, unsigned long) /* at oob mark? */ +#endif + +/* commands for fnctl */ +#ifndef F_GETFL +#define F_GETFL 3 +#endif +#ifndef F_SETFL +#define F_SETFL 4 +#endif + +/* File status flags and file access modes for fnctl, + these are bits in an int. */ +#ifndef O_NONBLOCK +#define O_NONBLOCK 1 /* nonblocking I/O */ +#endif +#ifndef O_NDELAY +#define O_NDELAY O_NONBLOCK /* same as O_NONBLOCK, for compatibility */ +#endif +#ifndef O_RDONLY +#define O_RDONLY 2 +#endif +#ifndef O_WRONLY +#define O_WRONLY 4 +#endif +#ifndef O_RDWR +#define O_RDWR (O_RDONLY|O_WRONLY) +#endif + +#ifndef SHUT_RD + #define SHUT_RD 0 + #define SHUT_WR 1 + #define SHUT_RDWR 2 +#endif + +/* FD_SET used for lwip_select */ +#ifndef FD_SET +#undef FD_SETSIZE +/* Make FD_SETSIZE match NUM_SOCKETS in socket.c */ +#define FD_SETSIZE MEMP_NUM_NETCONN +#define LWIP_SELECT_MAXNFDS (FD_SETSIZE + LWIP_SOCKET_OFFSET) +#define FDSETSAFESET(n, code) do { \ + if (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0)) { \ + code; }} while(0) +#define FDSETSAFEGET(n, code) (((n) - LWIP_SOCKET_OFFSET < MEMP_NUM_NETCONN) && (((int)(n) - LWIP_SOCKET_OFFSET) >= 0) ?\ + (code) : 0) +#define FD_SET(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] | (1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))) +#define FD_CLR(n, p) FDSETSAFESET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] = (u8_t)((p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] & ~(1 << (((n)-LWIP_SOCKET_OFFSET) & 7)))) +#define FD_ISSET(n,p) FDSETSAFEGET(n, (p)->fd_bits[((n)-LWIP_SOCKET_OFFSET)/8] & (1 << (((n)-LWIP_SOCKET_OFFSET) & 7))) +#define FD_ZERO(p) memset((void*)(p), 0, sizeof(*(p))) + +typedef struct fd_set +{ + unsigned char fd_bits [(FD_SETSIZE+7)/8]; +} fd_set; + +#elif FD_SETSIZE < (LWIP_SOCKET_OFFSET + MEMP_NUM_NETCONN) +#error "external FD_SETSIZE too small for number of sockets" +#else +#define LWIP_SELECT_MAXNFDS FD_SETSIZE +#endif /* FD_SET */ + +/* poll-related defines and types */ +/* @todo: find a better way to guard the definition of these defines and types if already defined */ +#if !defined(POLLIN) && !defined(POLLOUT) +#define POLLIN 0x1 +#define POLLOUT 0x2 +#define POLLERR 0x4 +#define POLLNVAL 0x8 +/* Below values are unimplemented */ +#define POLLRDNORM 0x10 +#define POLLRDBAND 0x20 +#define POLLPRI 0x40 +#define POLLWRNORM 0x80 +#define POLLWRBAND 0x100 +#define POLLHUP 0x200 +typedef unsigned int nfds_t; +struct pollfd +{ + int fd; + short events; + short revents; +}; +#endif + +/** LWIP_TIMEVAL_PRIVATE: if you want to use the struct timeval provided + * by your system, set this to 0 and include in cc.h */ +#ifndef LWIP_TIMEVAL_PRIVATE +#define LWIP_TIMEVAL_PRIVATE 1 +#endif + +#if LWIP_TIMEVAL_PRIVATE +// struct timeval { +// long tv_sec; /* seconds */ +// long tv_usec; /* and microseconds */ +// }; +#endif /* LWIP_TIMEVAL_PRIVATE */ + +#define lwip_socket_init() /* Compatibility define, no init needed. */ +void lwip_socket_thread_init(void); /* LWIP_NETCONN_SEM_PER_THREAD==1: initialize thread-local semaphore */ +void lwip_socket_thread_cleanup(void); /* LWIP_NETCONN_SEM_PER_THREAD==1: destroy thread-local semaphore */ + +#if LWIP_COMPAT_SOCKETS == 2 +/* This helps code parsers/code completion by not having the COMPAT functions as defines */ +#define lwip_accept accept +#define lwip_bind bind +#define lwip_shutdown shutdown +#define lwip_getpeername getpeername +#define lwip_getsockname getsockname +#define lwip_setsockopt setsockopt +#define lwip_getsockopt getsockopt +#define lwip_close closesocket +#define lwip_connect connect +#define lwip_listen listen +#define lwip_recv recv +#define lwip_recvmsg recvmsg +#define lwip_recvfrom recvfrom +#define lwip_send send +#define lwip_sendmsg sendmsg +#define lwip_sendto sendto +#define lwip_socket socket +#if LWIP_SOCKET_SELECT +#define lwip_select select +#endif +#if LWIP_SOCKET_POLL +#define lwip_poll poll +#endif +#define lwip_ioctl ioctlsocket +#define lwip_inet_ntop inet_ntop +#define lwip_inet_pton inet_pton + +#if LWIP_POSIX_SOCKETS_IO_NAMES +#define lwip_read read +#define lwip_readv readv +#define lwip_write write +#define lwip_writev writev +#undef lwip_close +#define lwip_close close +#define closesocket(s) close(s) +int fcntl(int s, int cmd, ...); +#undef lwip_ioctl +#define lwip_ioctl ioctl +#define ioctlsocket ioctl +#endif /* LWIP_POSIX_SOCKETS_IO_NAMES */ +#endif /* LWIP_COMPAT_SOCKETS == 2 */ + +int lwip_accept(int s, struct sockaddr *addr, socklen_t *addrlen); +int lwip_bind(int s, const struct sockaddr *name, socklen_t namelen); +int lwip_shutdown(int s, int how); +int lwip_getpeername (int s, struct sockaddr *name, socklen_t *namelen); +int lwip_getsockname (int s, struct sockaddr *name, socklen_t *namelen); +int lwip_getsockopt (int s, int level, int optname, void *optval, socklen_t *optlen); +int lwip_setsockopt (int s, int level, int optname, const void *optval, socklen_t optlen); + int lwip_close(int s); +int lwip_connect(int s, const struct sockaddr *name, socklen_t namelen); +int lwip_listen(int s, int backlog); +ssize_t lwip_recv(int s, void *mem, size_t len, int flags); +ssize_t lwip_read(int s, void *mem, size_t len); +ssize_t lwip_readv(int s, const struct iovec *iov, int iovcnt); +ssize_t lwip_recvfrom(int s, void *mem, size_t len, int flags, + struct sockaddr *from, socklen_t *fromlen); +ssize_t lwip_recvmsg(int s, struct msghdr *message, int flags); +ssize_t lwip_send(int s, const void *dataptr, size_t size, int flags); +ssize_t lwip_sendmsg(int s, const struct msghdr *message, int flags); +ssize_t lwip_sendto(int s, const void *dataptr, size_t size, int flags, + const struct sockaddr *to, socklen_t tolen); +int lwip_socket(int domain, int type, int protocol); +ssize_t lwip_write(int s, const void *dataptr, size_t size); +ssize_t lwip_writev(int s, const struct iovec *iov, int iovcnt); +#if LWIP_SOCKET_SELECT +int lwip_select(int maxfdp1, fd_set *readset, fd_set *writeset, fd_set *exceptset, + struct timeval *timeout); +#endif +#if LWIP_SOCKET_POLL +int lwip_poll(struct pollfd *fds, nfds_t nfds, int timeout); +#endif +int lwip_ioctl(int s, long cmd, void *argp); +int lwip_fcntl(int s, int cmd, int val); +const char *lwip_inet_ntop(int af, const void *src, char *dst, socklen_t size); +int lwip_inet_pton(int af, const char *src, void *dst); + +#if LWIP_COMPAT_SOCKETS +#if LWIP_COMPAT_SOCKETS != 2 +/** @ingroup socket */ +#define accept(s,addr,addrlen) lwip_accept(s,addr,addrlen) +/** @ingroup socket */ +#define bind(s,name,namelen) lwip_bind(s,name,namelen) +/** @ingroup socket */ +#define shutdown(s,how) lwip_shutdown(s,how) +/** @ingroup socket */ +#define getpeername(s,name,namelen) lwip_getpeername(s,name,namelen) +/** @ingroup socket */ +#define getsockname(s,name,namelen) lwip_getsockname(s,name,namelen) +/** @ingroup socket */ +#define setsockopt(s,level,optname,opval,optlen) lwip_setsockopt(s,level,optname,opval,optlen) +/** @ingroup socket */ +#define getsockopt(s,level,optname,opval,optlen) lwip_getsockopt(s,level,optname,opval,optlen) +/** @ingroup socket */ +#define closesocket(s) lwip_close(s) +/** @ingroup socket */ +#define connect(s,name,namelen) lwip_connect(s,name,namelen) +/** @ingroup socket */ +#define listen(s,backlog) lwip_listen(s,backlog) +/** @ingroup socket */ +#define recv(s,mem,len,flags) lwip_recv(s,mem,len,flags) +/** @ingroup socket */ +#define recvmsg(s,message,flags) lwip_recvmsg(s,message,flags) +/** @ingroup socket */ +#define recvfrom(s,mem,len,flags,from,fromlen) lwip_recvfrom(s,mem,len,flags,from,fromlen) +/** @ingroup socket */ +#define send(s,dataptr,size,flags) lwip_send(s,dataptr,size,flags) +/** @ingroup socket */ +#define sendmsg(s,message,flags) lwip_sendmsg(s,message,flags) +/** @ingroup socket */ +#define sendto(s,dataptr,size,flags,to,tolen) lwip_sendto(s,dataptr,size,flags,to,tolen) +/** @ingroup socket */ +#define socket(domain,type,protocol) lwip_socket(domain,type,protocol) +#if LWIP_SOCKET_SELECT +/** @ingroup socket */ +#define select(maxfdp1,readset,writeset,exceptset,timeout) lwip_select(maxfdp1,readset,writeset,exceptset,timeout) +#endif +#if LWIP_SOCKET_POLL +/** @ingroup socket */ +#define poll(fds,nfds,timeout) lwip_poll(fds,nfds,timeout) +#endif +/** @ingroup socket */ +#define ioctlsocket(s,cmd,argp) lwip_ioctl(s,cmd,argp) +/** @ingroup socket */ +#define inet_ntop(af,src,dst,size) lwip_inet_ntop(af,src,dst,size) +/** @ingroup socket */ +#define inet_pton(af,src,dst) lwip_inet_pton(af,src,dst) + +#if LWIP_POSIX_SOCKETS_IO_NAMES +/** @ingroup socket */ +#define read(s,mem,len) lwip_read(s,mem,len) +/** @ingroup socket */ +#define readv(s,iov,iovcnt) lwip_readv(s,iov,iovcnt) +/** @ingroup socket */ +#define write(s,dataptr,len) lwip_write(s,dataptr,len) +/** @ingroup socket */ +#define writev(s,iov,iovcnt) lwip_writev(s,iov,iovcnt) +/** @ingroup socket */ +#define close(s) lwip_close(s) +/** @ingroup socket */ +#define fcntl(s,cmd,val) lwip_fcntl(s,cmd,val) +/** @ingroup socket */ +#define ioctl(s,cmd,argp) lwip_ioctl(s,cmd,argp) +#endif /* LWIP_POSIX_SOCKETS_IO_NAMES */ +#endif /* LWIP_COMPAT_SOCKETS != 2 */ + +#endif /* LWIP_COMPAT_SOCKETS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_SOCKET */ + +#endif /* LWIP_HDR_SOCKETS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/stats.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/stats.h index 1cf4e59d..b570dbac 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/stats.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/stats.h @@ -1,491 +1,491 @@ -/** - * @file - * Statistics API (to be used from TCPIP thread) - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_STATS_H -#define LWIP_HDR_STATS_H - -#include "lwip/opt.h" - -#include "lwip/mem.h" -#include "lwip/memp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_STATS - -#ifndef LWIP_STATS_LARGE -#define LWIP_STATS_LARGE 0 -#endif - -#if LWIP_STATS_LARGE -#define STAT_COUNTER u32_t -#define STAT_COUNTER_F U32_F -#else -#define STAT_COUNTER u16_t -#define STAT_COUNTER_F U16_F -#endif - -/** Protocol related stats */ -struct stats_proto { - STAT_COUNTER xmit; /* Transmitted packets. */ - STAT_COUNTER recv; /* Received packets. */ - STAT_COUNTER fw; /* Forwarded packets. */ - STAT_COUNTER drop; /* Dropped packets. */ - STAT_COUNTER chkerr; /* Checksum error. */ - STAT_COUNTER lenerr; /* Invalid length error. */ - STAT_COUNTER memerr; /* Out of memory error. */ - STAT_COUNTER rterr; /* Routing error. */ - STAT_COUNTER proterr; /* Protocol error. */ - STAT_COUNTER opterr; /* Error in options. */ - STAT_COUNTER err; /* Misc error. */ - STAT_COUNTER cachehit; -}; - -/** IGMP stats */ -struct stats_igmp { - STAT_COUNTER xmit; /* Transmitted packets. */ - STAT_COUNTER recv; /* Received packets. */ - STAT_COUNTER drop; /* Dropped packets. */ - STAT_COUNTER chkerr; /* Checksum error. */ - STAT_COUNTER lenerr; /* Invalid length error. */ - STAT_COUNTER memerr; /* Out of memory error. */ - STAT_COUNTER proterr; /* Protocol error. */ - STAT_COUNTER rx_v1; /* Received v1 frames. */ - STAT_COUNTER rx_group; /* Received group-specific queries. */ - STAT_COUNTER rx_general; /* Received general queries. */ - STAT_COUNTER rx_report; /* Received reports. */ - STAT_COUNTER tx_join; /* Sent joins. */ - STAT_COUNTER tx_leave; /* Sent leaves. */ - STAT_COUNTER tx_report; /* Sent reports. */ -}; - -/** Memory stats */ -struct stats_mem { -#if defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY - const char *name; -#endif /* defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY */ - STAT_COUNTER err; - mem_size_t avail; - mem_size_t used; - mem_size_t max; - STAT_COUNTER illegal; -}; - -/** System element stats */ -struct stats_syselem { - STAT_COUNTER used; - STAT_COUNTER max; - STAT_COUNTER err; -}; - -/** System stats */ -struct stats_sys { - struct stats_syselem sem; - struct stats_syselem mutex; - struct stats_syselem mbox; -}; - -/** SNMP MIB2 stats */ -struct stats_mib2 { - /* IP */ - u32_t ipinhdrerrors; - u32_t ipinaddrerrors; - u32_t ipinunknownprotos; - u32_t ipindiscards; - u32_t ipindelivers; - u32_t ipoutrequests; - u32_t ipoutdiscards; - u32_t ipoutnoroutes; - u32_t ipreasmoks; - u32_t ipreasmfails; - u32_t ipfragoks; - u32_t ipfragfails; - u32_t ipfragcreates; - u32_t ipreasmreqds; - u32_t ipforwdatagrams; - u32_t ipinreceives; - - /* TCP */ - u32_t tcpactiveopens; - u32_t tcppassiveopens; - u32_t tcpattemptfails; - u32_t tcpestabresets; - u32_t tcpoutsegs; - u32_t tcpretranssegs; - u32_t tcpinsegs; - u32_t tcpinerrs; - u32_t tcpoutrsts; - - /* UDP */ - u32_t udpindatagrams; - u32_t udpnoports; - u32_t udpinerrors; - u32_t udpoutdatagrams; - - /* ICMP */ - u32_t icmpinmsgs; - u32_t icmpinerrors; - u32_t icmpindestunreachs; - u32_t icmpintimeexcds; - u32_t icmpinparmprobs; - u32_t icmpinsrcquenchs; - u32_t icmpinredirects; - u32_t icmpinechos; - u32_t icmpinechoreps; - u32_t icmpintimestamps; - u32_t icmpintimestampreps; - u32_t icmpinaddrmasks; - u32_t icmpinaddrmaskreps; - u32_t icmpoutmsgs; - u32_t icmpouterrors; - u32_t icmpoutdestunreachs; - u32_t icmpouttimeexcds; - u32_t icmpoutechos; /* can be incremented by user application ('ping') */ - u32_t icmpoutechoreps; -}; - -/** - * @ingroup netif_mib2 - * SNMP MIB2 interface stats - */ -struct stats_mib2_netif_ctrs { - /** The total number of octets received on the interface, including framing characters */ - u32_t ifinoctets; - /** The number of packets, delivered by this sub-layer to a higher (sub-)layer, which were - * not addressed to a multicast or broadcast address at this sub-layer */ - u32_t ifinucastpkts; - /** The number of packets, delivered by this sub-layer to a higher (sub-)layer, which were - * addressed to a multicast or broadcast address at this sub-layer */ - u32_t ifinnucastpkts; - /** The number of inbound packets which were chosen to be discarded even though no errors had - * been detected to prevent their being deliverable to a higher-layer protocol. One possible - * reason for discarding such a packet could be to free up buffer space */ - u32_t ifindiscards; - /** For packet-oriented interfaces, the number of inbound packets that contained errors - * preventing them from being deliverable to a higher-layer protocol. For character- - * oriented or fixed-length interfaces, the number of inbound transmission units that - * contained errors preventing them from being deliverable to a higher-layer protocol. */ - u32_t ifinerrors; - /** For packet-oriented interfaces, the number of packets received via the interface which - * were discarded because of an unknown or unsupported protocol. For character-oriented - * or fixed-length interfaces that support protocol multiplexing the number of transmission - * units received via the interface which were discarded because of an unknown or unsupported - * protocol. For any interface that does not support protocol multiplexing, this counter will - * always be 0 */ - u32_t ifinunknownprotos; - /** The total number of octets transmitted out of the interface, including framing characters. */ - u32_t ifoutoctets; - /** The total number of packets that higher-level protocols requested be transmitted, and - * which were not addressed to a multicast or broadcast address at this sub-layer, including - * those that were discarded or not sent. */ - u32_t ifoutucastpkts; - /** The total number of packets that higher-level protocols requested be transmitted, and which - * were addressed to a multicast or broadcast address at this sub-layer, including - * those that were discarded or not sent. */ - u32_t ifoutnucastpkts; - /** The number of outbound packets which were chosen to be discarded even though no errors had - * been detected to prevent their being transmitted. One possible reason for discarding - * such a packet could be to free up buffer space. */ - u32_t ifoutdiscards; - /** For packet-oriented interfaces, the number of outbound packets that could not be transmitted - * because of errors. For character-oriented or fixed-length interfaces, the number of outbound - * transmission units that could not be transmitted because of errors. */ - u32_t ifouterrors; -}; - -/** lwIP stats container */ -struct stats_ { -#if LINK_STATS - /** Link level */ - struct stats_proto link; -#endif -#if ETHARP_STATS - /** ARP */ - struct stats_proto etharp; -#endif -#if IPFRAG_STATS - /** Fragmentation */ - struct stats_proto ip_frag; -#endif -#if IP_STATS - /** IP */ - struct stats_proto ip; -#endif -#if ICMP_STATS - /** ICMP */ - struct stats_proto icmp; -#endif -#if IGMP_STATS - /** IGMP */ - struct stats_igmp igmp; -#endif -#if UDP_STATS - /** UDP */ - struct stats_proto udp; -#endif -#if TCP_STATS - /** TCP */ - struct stats_proto tcp; -#endif -#if MEM_STATS - /** Heap */ - struct stats_mem mem; -#endif -#if MEMP_STATS - /** Internal memory pools */ - struct stats_mem *memp[MEMP_MAX]; -#endif -#if SYS_STATS - /** System */ - struct stats_sys sys; -#endif -#if IP6_STATS - /** IPv6 */ - struct stats_proto ip6; -#endif -#if ICMP6_STATS - /** ICMP6 */ - struct stats_proto icmp6; -#endif -#if IP6_FRAG_STATS - /** IPv6 fragmentation */ - struct stats_proto ip6_frag; -#endif -#if MLD6_STATS - /** Multicast listener discovery */ - struct stats_igmp mld6; -#endif -#if ND6_STATS - /** Neighbor discovery */ - struct stats_proto nd6; -#endif -#if MIB2_STATS - /** SNMP MIB2 */ - struct stats_mib2 mib2; -#endif -}; - -/** Global variable containing lwIP internal statistics. Add this to your debugger's watchlist. */ -extern struct stats_ lwip_stats; - -/** Init statistics */ -void stats_init(void); - -#define STATS_INC(x) ++lwip_stats.x -#define STATS_DEC(x) --lwip_stats.x -#define STATS_INC_USED(x, y, type) do { lwip_stats.x.used = (type)(lwip_stats.x.used + y); \ - if (lwip_stats.x.max < lwip_stats.x.used) { \ - lwip_stats.x.max = lwip_stats.x.used; \ - } \ - } while(0) -#define STATS_GET(x) lwip_stats.x -#else /* LWIP_STATS */ -#define stats_init() -#define STATS_INC(x) -#define STATS_DEC(x) -#define STATS_INC_USED(x, y, type) -#endif /* LWIP_STATS */ - -#if TCP_STATS -#define TCP_STATS_INC(x) STATS_INC(x) -#define TCP_STATS_DISPLAY() stats_display_proto(&lwip_stats.tcp, "TCP") -#else -#define TCP_STATS_INC(x) -#define TCP_STATS_DISPLAY() -#endif - -#if UDP_STATS -#define UDP_STATS_INC(x) STATS_INC(x) -#define UDP_STATS_DISPLAY() stats_display_proto(&lwip_stats.udp, "UDP") -#else -#define UDP_STATS_INC(x) -#define UDP_STATS_DISPLAY() -#endif - -#if ICMP_STATS -#define ICMP_STATS_INC(x) STATS_INC(x) -#define ICMP_STATS_DISPLAY() stats_display_proto(&lwip_stats.icmp, "ICMP") -#else -#define ICMP_STATS_INC(x) -#define ICMP_STATS_DISPLAY() -#endif - -#if IGMP_STATS -#define IGMP_STATS_INC(x) STATS_INC(x) -#define IGMP_STATS_DISPLAY() stats_display_igmp(&lwip_stats.igmp, "IGMP") -#else -#define IGMP_STATS_INC(x) -#define IGMP_STATS_DISPLAY() -#endif - -#if IP_STATS -#define IP_STATS_INC(x) STATS_INC(x) -#define IP_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip, "IP") -#else -#define IP_STATS_INC(x) -#define IP_STATS_DISPLAY() -#endif - -#if IPFRAG_STATS -#define IPFRAG_STATS_INC(x) STATS_INC(x) -#define IPFRAG_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip_frag, "IP_FRAG") -#else -#define IPFRAG_STATS_INC(x) -#define IPFRAG_STATS_DISPLAY() -#endif - -#if ETHARP_STATS -#define ETHARP_STATS_INC(x) STATS_INC(x) -#define ETHARP_STATS_DISPLAY() stats_display_proto(&lwip_stats.etharp, "ETHARP") -#else -#define ETHARP_STATS_INC(x) -#define ETHARP_STATS_DISPLAY() -#endif - -#if LINK_STATS -#define LINK_STATS_INC(x) STATS_INC(x) -#define LINK_STATS_DISPLAY() stats_display_proto(&lwip_stats.link, "LINK") -#else -#define LINK_STATS_INC(x) -#define LINK_STATS_DISPLAY() -#endif - -#if MEM_STATS -#define MEM_STATS_AVAIL(x, y) lwip_stats.mem.x = y -#define MEM_STATS_INC(x) STATS_INC(mem.x) -#define MEM_STATS_INC_USED(x, y) STATS_INC_USED(mem, y, mem_size_t) -#define MEM_STATS_DEC_USED(x, y) lwip_stats.mem.x = (mem_size_t)((lwip_stats.mem.x) - (y)) -#define MEM_STATS_DISPLAY() stats_display_mem(&lwip_stats.mem, "HEAP") -#else -#define MEM_STATS_AVAIL(x, y) -#define MEM_STATS_INC(x) -#define MEM_STATS_INC_USED(x, y) -#define MEM_STATS_DEC_USED(x, y) -#define MEM_STATS_DISPLAY() -#endif - - #if MEMP_STATS -#define MEMP_STATS_DEC(x, i) STATS_DEC(memp[i]->x) -#define MEMP_STATS_DISPLAY(i) stats_display_memp(lwip_stats.memp[i], i) -#define MEMP_STATS_GET(x, i) STATS_GET(memp[i]->x) - #else -#define MEMP_STATS_DEC(x, i) -#define MEMP_STATS_DISPLAY(i) -#define MEMP_STATS_GET(x, i) 0 -#endif - -#if SYS_STATS -#define SYS_STATS_INC(x) STATS_INC(sys.x) -#define SYS_STATS_DEC(x) STATS_DEC(sys.x) -#define SYS_STATS_INC_USED(x) STATS_INC_USED(sys.x, 1, STAT_COUNTER) -#define SYS_STATS_DISPLAY() stats_display_sys(&lwip_stats.sys) -#else -#define SYS_STATS_INC(x) -#define SYS_STATS_DEC(x) -#define SYS_STATS_INC_USED(x) -#define SYS_STATS_DISPLAY() -#endif - -#if IP6_STATS -#define IP6_STATS_INC(x) STATS_INC(x) -#define IP6_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip6, "IPv6") -#else -#define IP6_STATS_INC(x) -#define IP6_STATS_DISPLAY() -#endif - -#if ICMP6_STATS -#define ICMP6_STATS_INC(x) STATS_INC(x) -#define ICMP6_STATS_DISPLAY() stats_display_proto(&lwip_stats.icmp6, "ICMPv6") -#else -#define ICMP6_STATS_INC(x) -#define ICMP6_STATS_DISPLAY() -#endif - -#if IP6_FRAG_STATS -#define IP6_FRAG_STATS_INC(x) STATS_INC(x) -#define IP6_FRAG_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip6_frag, "IPv6 FRAG") -#else -#define IP6_FRAG_STATS_INC(x) -#define IP6_FRAG_STATS_DISPLAY() -#endif - -#if MLD6_STATS -#define MLD6_STATS_INC(x) STATS_INC(x) -#define MLD6_STATS_DISPLAY() stats_display_igmp(&lwip_stats.mld6, "MLDv1") -#else -#define MLD6_STATS_INC(x) -#define MLD6_STATS_DISPLAY() -#endif - -#if ND6_STATS -#define ND6_STATS_INC(x) STATS_INC(x) -#define ND6_STATS_DISPLAY() stats_display_proto(&lwip_stats.nd6, "ND") -#else -#define ND6_STATS_INC(x) -#define ND6_STATS_DISPLAY() -#endif - -#if MIB2_STATS -#define MIB2_STATS_INC(x) STATS_INC(x) -#else -#define MIB2_STATS_INC(x) -#endif - -/* Display of statistics */ -#if LWIP_STATS_DISPLAY -void stats_display(void); -void stats_display_proto(struct stats_proto *proto, const char *name); -void stats_display_igmp(struct stats_igmp *igmp, const char *name); -void stats_display_mem(struct stats_mem *mem, const char *name); -void stats_display_memp(struct stats_mem *mem, int index); -void stats_display_sys(struct stats_sys *sys); -#else /* LWIP_STATS_DISPLAY */ -#define stats_display() -#define stats_display_proto(proto, name) -#define stats_display_igmp(igmp, name) -#define stats_display_mem(mem, name) -#define stats_display_memp(mem, index) -#define stats_display_sys(sys) -#endif /* LWIP_STATS_DISPLAY */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_STATS_H */ +/** + * @file + * Statistics API (to be used from TCPIP thread) + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_STATS_H +#define LWIP_HDR_STATS_H + +#include "lwip/opt.h" + +#include "lwip/mem.h" +#include "lwip/memp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_STATS + +#ifndef LWIP_STATS_LARGE +#define LWIP_STATS_LARGE 0 +#endif + +#if LWIP_STATS_LARGE +#define STAT_COUNTER u32_t +#define STAT_COUNTER_F U32_F +#else +#define STAT_COUNTER u16_t +#define STAT_COUNTER_F U16_F +#endif + +/** Protocol related stats */ +struct stats_proto { + STAT_COUNTER xmit; /* Transmitted packets. */ + STAT_COUNTER recv; /* Received packets. */ + STAT_COUNTER fw; /* Forwarded packets. */ + STAT_COUNTER drop; /* Dropped packets. */ + STAT_COUNTER chkerr; /* Checksum error. */ + STAT_COUNTER lenerr; /* Invalid length error. */ + STAT_COUNTER memerr; /* Out of memory error. */ + STAT_COUNTER rterr; /* Routing error. */ + STAT_COUNTER proterr; /* Protocol error. */ + STAT_COUNTER opterr; /* Error in options. */ + STAT_COUNTER err; /* Misc error. */ + STAT_COUNTER cachehit; +}; + +/** IGMP stats */ +struct stats_igmp { + STAT_COUNTER xmit; /* Transmitted packets. */ + STAT_COUNTER recv; /* Received packets. */ + STAT_COUNTER drop; /* Dropped packets. */ + STAT_COUNTER chkerr; /* Checksum error. */ + STAT_COUNTER lenerr; /* Invalid length error. */ + STAT_COUNTER memerr; /* Out of memory error. */ + STAT_COUNTER proterr; /* Protocol error. */ + STAT_COUNTER rx_v1; /* Received v1 frames. */ + STAT_COUNTER rx_group; /* Received group-specific queries. */ + STAT_COUNTER rx_general; /* Received general queries. */ + STAT_COUNTER rx_report; /* Received reports. */ + STAT_COUNTER tx_join; /* Sent joins. */ + STAT_COUNTER tx_leave; /* Sent leaves. */ + STAT_COUNTER tx_report; /* Sent reports. */ +}; + +/** Memory stats */ +struct stats_mem { +#if defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY + const char *name; +#endif /* defined(LWIP_DEBUG) || LWIP_STATS_DISPLAY */ + STAT_COUNTER err; + mem_size_t avail; + mem_size_t used; + mem_size_t max; + STAT_COUNTER illegal; +}; + +/** System element stats */ +struct stats_syselem { + STAT_COUNTER used; + STAT_COUNTER max; + STAT_COUNTER err; +}; + +/** System stats */ +struct stats_sys { + struct stats_syselem sem; + struct stats_syselem mutex; + struct stats_syselem mbox; +}; + +/** SNMP MIB2 stats */ +struct stats_mib2 { + /* IP */ + u32_t ipinhdrerrors; + u32_t ipinaddrerrors; + u32_t ipinunknownprotos; + u32_t ipindiscards; + u32_t ipindelivers; + u32_t ipoutrequests; + u32_t ipoutdiscards; + u32_t ipoutnoroutes; + u32_t ipreasmoks; + u32_t ipreasmfails; + u32_t ipfragoks; + u32_t ipfragfails; + u32_t ipfragcreates; + u32_t ipreasmreqds; + u32_t ipforwdatagrams; + u32_t ipinreceives; + + /* TCP */ + u32_t tcpactiveopens; + u32_t tcppassiveopens; + u32_t tcpattemptfails; + u32_t tcpestabresets; + u32_t tcpoutsegs; + u32_t tcpretranssegs; + u32_t tcpinsegs; + u32_t tcpinerrs; + u32_t tcpoutrsts; + + /* UDP */ + u32_t udpindatagrams; + u32_t udpnoports; + u32_t udpinerrors; + u32_t udpoutdatagrams; + + /* ICMP */ + u32_t icmpinmsgs; + u32_t icmpinerrors; + u32_t icmpindestunreachs; + u32_t icmpintimeexcds; + u32_t icmpinparmprobs; + u32_t icmpinsrcquenchs; + u32_t icmpinredirects; + u32_t icmpinechos; + u32_t icmpinechoreps; + u32_t icmpintimestamps; + u32_t icmpintimestampreps; + u32_t icmpinaddrmasks; + u32_t icmpinaddrmaskreps; + u32_t icmpoutmsgs; + u32_t icmpouterrors; + u32_t icmpoutdestunreachs; + u32_t icmpouttimeexcds; + u32_t icmpoutechos; /* can be incremented by user application ('ping') */ + u32_t icmpoutechoreps; +}; + +/** + * @ingroup netif_mib2 + * SNMP MIB2 interface stats + */ +struct stats_mib2_netif_ctrs { + /** The total number of octets received on the interface, including framing characters */ + u32_t ifinoctets; + /** The number of packets, delivered by this sub-layer to a higher (sub-)layer, which were + * not addressed to a multicast or broadcast address at this sub-layer */ + u32_t ifinucastpkts; + /** The number of packets, delivered by this sub-layer to a higher (sub-)layer, which were + * addressed to a multicast or broadcast address at this sub-layer */ + u32_t ifinnucastpkts; + /** The number of inbound packets which were chosen to be discarded even though no errors had + * been detected to prevent their being deliverable to a higher-layer protocol. One possible + * reason for discarding such a packet could be to free up buffer space */ + u32_t ifindiscards; + /** For packet-oriented interfaces, the number of inbound packets that contained errors + * preventing them from being deliverable to a higher-layer protocol. For character- + * oriented or fixed-length interfaces, the number of inbound transmission units that + * contained errors preventing them from being deliverable to a higher-layer protocol. */ + u32_t ifinerrors; + /** For packet-oriented interfaces, the number of packets received via the interface which + * were discarded because of an unknown or unsupported protocol. For character-oriented + * or fixed-length interfaces that support protocol multiplexing the number of transmission + * units received via the interface which were discarded because of an unknown or unsupported + * protocol. For any interface that does not support protocol multiplexing, this counter will + * always be 0 */ + u32_t ifinunknownprotos; + /** The total number of octets transmitted out of the interface, including framing characters. */ + u32_t ifoutoctets; + /** The total number of packets that higher-level protocols requested be transmitted, and + * which were not addressed to a multicast or broadcast address at this sub-layer, including + * those that were discarded or not sent. */ + u32_t ifoutucastpkts; + /** The total number of packets that higher-level protocols requested be transmitted, and which + * were addressed to a multicast or broadcast address at this sub-layer, including + * those that were discarded or not sent. */ + u32_t ifoutnucastpkts; + /** The number of outbound packets which were chosen to be discarded even though no errors had + * been detected to prevent their being transmitted. One possible reason for discarding + * such a packet could be to free up buffer space. */ + u32_t ifoutdiscards; + /** For packet-oriented interfaces, the number of outbound packets that could not be transmitted + * because of errors. For character-oriented or fixed-length interfaces, the number of outbound + * transmission units that could not be transmitted because of errors. */ + u32_t ifouterrors; +}; + +/** lwIP stats container */ +struct stats_ { +#if LINK_STATS + /** Link level */ + struct stats_proto link; +#endif +#if ETHARP_STATS + /** ARP */ + struct stats_proto etharp; +#endif +#if IPFRAG_STATS + /** Fragmentation */ + struct stats_proto ip_frag; +#endif +#if IP_STATS + /** IP */ + struct stats_proto ip; +#endif +#if ICMP_STATS + /** ICMP */ + struct stats_proto icmp; +#endif +#if IGMP_STATS + /** IGMP */ + struct stats_igmp igmp; +#endif +#if UDP_STATS + /** UDP */ + struct stats_proto udp; +#endif +#if TCP_STATS + /** TCP */ + struct stats_proto tcp; +#endif +#if MEM_STATS + /** Heap */ + struct stats_mem mem; +#endif +#if MEMP_STATS + /** Internal memory pools */ + struct stats_mem *memp[MEMP_MAX]; +#endif +#if SYS_STATS + /** System */ + struct stats_sys sys; +#endif +#if IP6_STATS + /** IPv6 */ + struct stats_proto ip6; +#endif +#if ICMP6_STATS + /** ICMP6 */ + struct stats_proto icmp6; +#endif +#if IP6_FRAG_STATS + /** IPv6 fragmentation */ + struct stats_proto ip6_frag; +#endif +#if MLD6_STATS + /** Multicast listener discovery */ + struct stats_igmp mld6; +#endif +#if ND6_STATS + /** Neighbor discovery */ + struct stats_proto nd6; +#endif +#if MIB2_STATS + /** SNMP MIB2 */ + struct stats_mib2 mib2; +#endif +}; + +/** Global variable containing lwIP internal statistics. Add this to your debugger's watchlist. */ +extern struct stats_ lwip_stats; + +/** Init statistics */ +void stats_init(void); + +#define STATS_INC(x) ++lwip_stats.x +#define STATS_DEC(x) --lwip_stats.x +#define STATS_INC_USED(x, y, type) do { lwip_stats.x.used = (type)(lwip_stats.x.used + y); \ + if (lwip_stats.x.max < lwip_stats.x.used) { \ + lwip_stats.x.max = lwip_stats.x.used; \ + } \ + } while(0) +#define STATS_GET(x) lwip_stats.x +#else /* LWIP_STATS */ +#define stats_init() +#define STATS_INC(x) +#define STATS_DEC(x) +#define STATS_INC_USED(x, y, type) +#endif /* LWIP_STATS */ + +#if TCP_STATS +#define TCP_STATS_INC(x) STATS_INC(x) +#define TCP_STATS_DISPLAY() stats_display_proto(&lwip_stats.tcp, "TCP") +#else +#define TCP_STATS_INC(x) +#define TCP_STATS_DISPLAY() +#endif + +#if UDP_STATS +#define UDP_STATS_INC(x) STATS_INC(x) +#define UDP_STATS_DISPLAY() stats_display_proto(&lwip_stats.udp, "UDP") +#else +#define UDP_STATS_INC(x) +#define UDP_STATS_DISPLAY() +#endif + +#if ICMP_STATS +#define ICMP_STATS_INC(x) STATS_INC(x) +#define ICMP_STATS_DISPLAY() stats_display_proto(&lwip_stats.icmp, "ICMP") +#else +#define ICMP_STATS_INC(x) +#define ICMP_STATS_DISPLAY() +#endif + +#if IGMP_STATS +#define IGMP_STATS_INC(x) STATS_INC(x) +#define IGMP_STATS_DISPLAY() stats_display_igmp(&lwip_stats.igmp, "IGMP") +#else +#define IGMP_STATS_INC(x) +#define IGMP_STATS_DISPLAY() +#endif + +#if IP_STATS +#define IP_STATS_INC(x) STATS_INC(x) +#define IP_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip, "IP") +#else +#define IP_STATS_INC(x) +#define IP_STATS_DISPLAY() +#endif + +#if IPFRAG_STATS +#define IPFRAG_STATS_INC(x) STATS_INC(x) +#define IPFRAG_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip_frag, "IP_FRAG") +#else +#define IPFRAG_STATS_INC(x) +#define IPFRAG_STATS_DISPLAY() +#endif + +#if ETHARP_STATS +#define ETHARP_STATS_INC(x) STATS_INC(x) +#define ETHARP_STATS_DISPLAY() stats_display_proto(&lwip_stats.etharp, "ETHARP") +#else +#define ETHARP_STATS_INC(x) +#define ETHARP_STATS_DISPLAY() +#endif + +#if LINK_STATS +#define LINK_STATS_INC(x) STATS_INC(x) +#define LINK_STATS_DISPLAY() stats_display_proto(&lwip_stats.link, "LINK") +#else +#define LINK_STATS_INC(x) +#define LINK_STATS_DISPLAY() +#endif + +#if MEM_STATS +#define MEM_STATS_AVAIL(x, y) lwip_stats.mem.x = y +#define MEM_STATS_INC(x) STATS_INC(mem.x) +#define MEM_STATS_INC_USED(x, y) STATS_INC_USED(mem, y, mem_size_t) +#define MEM_STATS_DEC_USED(x, y) lwip_stats.mem.x = (mem_size_t)((lwip_stats.mem.x) - (y)) +#define MEM_STATS_DISPLAY() stats_display_mem(&lwip_stats.mem, "HEAP") +#else +#define MEM_STATS_AVAIL(x, y) +#define MEM_STATS_INC(x) +#define MEM_STATS_INC_USED(x, y) +#define MEM_STATS_DEC_USED(x, y) +#define MEM_STATS_DISPLAY() +#endif + + #if MEMP_STATS +#define MEMP_STATS_DEC(x, i) STATS_DEC(memp[i]->x) +#define MEMP_STATS_DISPLAY(i) stats_display_memp(lwip_stats.memp[i], i) +#define MEMP_STATS_GET(x, i) STATS_GET(memp[i]->x) + #else +#define MEMP_STATS_DEC(x, i) +#define MEMP_STATS_DISPLAY(i) +#define MEMP_STATS_GET(x, i) 0 +#endif + +#if SYS_STATS +#define SYS_STATS_INC(x) STATS_INC(sys.x) +#define SYS_STATS_DEC(x) STATS_DEC(sys.x) +#define SYS_STATS_INC_USED(x) STATS_INC_USED(sys.x, 1, STAT_COUNTER) +#define SYS_STATS_DISPLAY() stats_display_sys(&lwip_stats.sys) +#else +#define SYS_STATS_INC(x) +#define SYS_STATS_DEC(x) +#define SYS_STATS_INC_USED(x) +#define SYS_STATS_DISPLAY() +#endif + +#if IP6_STATS +#define IP6_STATS_INC(x) STATS_INC(x) +#define IP6_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip6, "IPv6") +#else +#define IP6_STATS_INC(x) +#define IP6_STATS_DISPLAY() +#endif + +#if ICMP6_STATS +#define ICMP6_STATS_INC(x) STATS_INC(x) +#define ICMP6_STATS_DISPLAY() stats_display_proto(&lwip_stats.icmp6, "ICMPv6") +#else +#define ICMP6_STATS_INC(x) +#define ICMP6_STATS_DISPLAY() +#endif + +#if IP6_FRAG_STATS +#define IP6_FRAG_STATS_INC(x) STATS_INC(x) +#define IP6_FRAG_STATS_DISPLAY() stats_display_proto(&lwip_stats.ip6_frag, "IPv6 FRAG") +#else +#define IP6_FRAG_STATS_INC(x) +#define IP6_FRAG_STATS_DISPLAY() +#endif + +#if MLD6_STATS +#define MLD6_STATS_INC(x) STATS_INC(x) +#define MLD6_STATS_DISPLAY() stats_display_igmp(&lwip_stats.mld6, "MLDv1") +#else +#define MLD6_STATS_INC(x) +#define MLD6_STATS_DISPLAY() +#endif + +#if ND6_STATS +#define ND6_STATS_INC(x) STATS_INC(x) +#define ND6_STATS_DISPLAY() stats_display_proto(&lwip_stats.nd6, "ND") +#else +#define ND6_STATS_INC(x) +#define ND6_STATS_DISPLAY() +#endif + +#if MIB2_STATS +#define MIB2_STATS_INC(x) STATS_INC(x) +#else +#define MIB2_STATS_INC(x) +#endif + +/* Display of statistics */ +#if LWIP_STATS_DISPLAY +void stats_display(void); +void stats_display_proto(struct stats_proto *proto, const char *name); +void stats_display_igmp(struct stats_igmp *igmp, const char *name); +void stats_display_mem(struct stats_mem *mem, const char *name); +void stats_display_memp(struct stats_mem *mem, int index); +void stats_display_sys(struct stats_sys *sys); +#else /* LWIP_STATS_DISPLAY */ +#define stats_display() +#define stats_display_proto(proto, name) +#define stats_display_igmp(igmp, name) +#define stats_display_mem(mem, name) +#define stats_display_memp(mem, index) +#define stats_display_sys(sys) +#endif /* LWIP_STATS_DISPLAY */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_STATS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sys.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sys.h index cd834705..cf13e1dc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sys.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/sys.h @@ -1,560 +1,560 @@ -/** - * @file - * OS abstraction layer - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - */ - -#ifndef LWIP_HDR_SYS_H -#define LWIP_HDR_SYS_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if NO_SYS - -/* For a totally minimal and standalone system, we provide null - definitions of the sys_ functions. */ -typedef u8_t sys_sem_t; -typedef u8_t sys_mutex_t; -typedef u8_t sys_mbox_t; - -#define sys_sem_new(s, c) ERR_OK -#define sys_sem_signal(s) -#define sys_sem_wait(s) -#define sys_arch_sem_wait(s,t) -#define sys_sem_free(s) -#define sys_sem_valid(s) 0 -#define sys_sem_valid_val(s) 0 -#define sys_sem_set_invalid(s) -#define sys_sem_set_invalid_val(s) -#define sys_mutex_new(mu) ERR_OK -#define sys_mutex_lock(mu) -#define sys_mutex_unlock(mu) -#define sys_mutex_free(mu) -#define sys_mutex_valid(mu) 0 -#define sys_mutex_set_invalid(mu) -#define sys_mbox_new(m, s) ERR_OK -#define sys_mbox_fetch(m,d) -#define sys_mbox_tryfetch(m,d) -#define sys_mbox_post(m,d) -#define sys_mbox_trypost(m,d) -#define sys_mbox_free(m) -#define sys_mbox_valid(m) -#define sys_mbox_valid_val(m) -#define sys_mbox_set_invalid(m) -#define sys_mbox_set_invalid_val(m) - -#define sys_thread_new(n,t,a,s,p) - -#define sys_msleep(t) - -#else /* NO_SYS */ - -/** Return code for timeouts from sys_arch_mbox_fetch and sys_arch_sem_wait */ -#define SYS_ARCH_TIMEOUT 0xffffffffUL - -/** sys_mbox_tryfetch() returns SYS_MBOX_EMPTY if appropriate. - * For now we use the same magic value, but we allow this to change in future. - */ -#define SYS_MBOX_EMPTY SYS_ARCH_TIMEOUT - -#include "lwip/err.h" -#include "arch/sys_arch.h" - -/** Function prototype for thread functions */ -typedef void (*lwip_thread_fn)(void *arg); - -/* Function prototypes for functions to be implemented by platform ports - (in sys_arch.c) */ - -/* Mutex functions: */ - -/** Define LWIP_COMPAT_MUTEX if the port has no mutexes and binary semaphores - should be used instead */ -#ifndef LWIP_COMPAT_MUTEX -#define LWIP_COMPAT_MUTEX 0 -#endif - -#if LWIP_COMPAT_MUTEX -/* for old ports that don't have mutexes: define them to binary semaphores */ -#define sys_mutex_t sys_sem_t -#define sys_mutex_new(mutex) sys_sem_new(mutex, 1) -#define sys_mutex_lock(mutex) sys_sem_wait(mutex) -#define sys_mutex_unlock(mutex) sys_sem_signal(mutex) -#define sys_mutex_free(mutex) sys_sem_free(mutex) -#define sys_mutex_valid(mutex) sys_sem_valid(mutex) -#define sys_mutex_set_invalid(mutex) sys_sem_set_invalid(mutex) - -#else /* LWIP_COMPAT_MUTEX */ - -/** - * @ingroup sys_mutex - * Create a new mutex. - * Note that mutexes are expected to not be taken recursively by the lwIP code, - * so both implementation types (recursive or non-recursive) should work. - * The mutex is allocated to the memory that 'mutex' - * points to (which can be both a pointer or the actual OS structure). - * If the mutex has been created, ERR_OK should be returned. Returning any - * other error will provide a hint what went wrong, but except for assertions, - * no real error handling is implemented. - * - * @param mutex pointer to the mutex to create - * @return ERR_OK if successful, another err_t otherwise - */ -err_t sys_mutex_new(sys_mutex_t *mutex); -/** - * @ingroup sys_mutex - * Blocks the thread until the mutex can be grabbed. - * @param mutex the mutex to lock - */ -void sys_mutex_lock(sys_mutex_t *mutex); -/** - * @ingroup sys_mutex - * Releases the mutex previously locked through 'sys_mutex_lock()'. - * @param mutex the mutex to unlock - */ -void sys_mutex_unlock(sys_mutex_t *mutex); -/** - * @ingroup sys_mutex - * Deallocates a mutex. - * @param mutex the mutex to delete - */ -void sys_mutex_free(sys_mutex_t *mutex); -#ifndef sys_mutex_valid -/** - * @ingroup sys_mutex - * Returns 1 if the mutes is valid, 0 if it is not valid. - * When using pointers, a simple way is to check the pointer for != NULL. - * When directly using OS structures, implementing this may be more complex. - * This may also be a define, in which case the function is not prototyped. - */ -int sys_mutex_valid(sys_mutex_t *mutex); -#endif -#ifndef sys_mutex_set_invalid -/** - * @ingroup sys_mutex - * Invalidate a mutex so that sys_mutex_valid() returns 0. - * ATTENTION: This does NOT mean that the mutex shall be deallocated: - * sys_mutex_free() is always called before calling this function! - * This may also be a define, in which case the function is not prototyped. - */ -void sys_mutex_set_invalid(sys_mutex_t *mutex); -#endif -#endif /* LWIP_COMPAT_MUTEX */ - -/* Semaphore functions: */ - -/** - * @ingroup sys_sem - * Create a new semaphore - * Creates a new semaphore. The semaphore is allocated to the memory that 'sem' - * points to (which can be both a pointer or the actual OS structure). - * The "count" argument specifies the initial state of the semaphore (which is - * either 0 or 1). - * If the semaphore has been created, ERR_OK should be returned. Returning any - * other error will provide a hint what went wrong, but except for assertions, - * no real error handling is implemented. - * - * @param sem pointer to the semaphore to create - * @param count initial count of the semaphore - * @return ERR_OK if successful, another err_t otherwise - */ -err_t sys_sem_new(sys_sem_t *sem, u8_t count); -/** - * @ingroup sys_sem - * Signals a semaphore - * @param sem the semaphore to signal - */ -void sys_sem_signal(sys_sem_t *sem); -/** - * @ingroup sys_sem - * Blocks the thread while waiting for the semaphore to be signaled. If the - * "timeout" argument is non-zero, the thread should only be blocked for the - * specified time (measured in milliseconds). If the "timeout" argument is zero, - * the thread should be blocked until the semaphore is signalled. - * - * The return value is SYS_ARCH_TIMEOUT if the semaphore wasn't signaled within - * the specified time or any other value if it was signaled (with or without - * waiting). - * Notice that lwIP implements a function with a similar name, - * sys_sem_wait(), that uses the sys_arch_sem_wait() function. - * - * @param sem the semaphore to wait for - * @param timeout timeout in milliseconds to wait (0 = wait forever) - * @return SYS_ARCH_TIMEOUT on timeout, any other value on success - */ -u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout); -/** - * @ingroup sys_sem - * Deallocates a semaphore. - * @param sem semaphore to delete - */ -void sys_sem_free(sys_sem_t *sem); -/** Wait for a semaphore - forever/no timeout */ -#define sys_sem_wait(sem) sys_arch_sem_wait(sem, 0) -#ifndef sys_sem_valid -/** - * @ingroup sys_sem - * Returns 1 if the semaphore is valid, 0 if it is not valid. - * When using pointers, a simple way is to check the pointer for != NULL. - * When directly using OS structures, implementing this may be more complex. - * This may also be a define, in which case the function is not prototyped. - */ -int sys_sem_valid(sys_sem_t *sem); -#endif -#ifndef sys_sem_set_invalid -/** - * @ingroup sys_sem - * Invalidate a semaphore so that sys_sem_valid() returns 0. - * ATTENTION: This does NOT mean that the semaphore shall be deallocated: - * sys_sem_free() is always called before calling this function! - * This may also be a define, in which case the function is not prototyped. - */ -void sys_sem_set_invalid(sys_sem_t *sem); -#endif -#ifndef sys_sem_valid_val -/** - * Same as sys_sem_valid() but taking a value, not a pointer - */ -#define sys_sem_valid_val(sem) sys_sem_valid(&(sem)) -#endif -#ifndef sys_sem_set_invalid_val -/** - * Same as sys_sem_set_invalid() but taking a value, not a pointer - */ -#define sys_sem_set_invalid_val(sem) sys_sem_set_invalid(&(sem)) -#endif - -#ifndef sys_msleep -/** - * @ingroup sys_misc - * Sleep for specified number of ms - */ -void sys_msleep(u32_t ms); /* only has a (close to) 1 ms resolution. */ -#endif - -/* Mailbox functions. */ - -/** - * @ingroup sys_mbox - * Creates an empty mailbox for maximum "size" elements. Elements stored - * in mailboxes are pointers. You have to define macros "_MBOX_SIZE" - * in your lwipopts.h, or ignore this parameter in your implementation - * and use a default size. - * If the mailbox has been created, ERR_OK should be returned. Returning any - * other error will provide a hint what went wrong, but except for assertions, - * no real error handling is implemented. - * - * @param mbox pointer to the mbox to create - * @param size (minimum) number of messages in this mbox - * @return ERR_OK if successful, another err_t otherwise - */ -err_t sys_mbox_new(sys_mbox_t *mbox, int size); -/** - * @ingroup sys_mbox - * Post a message to an mbox - may not fail - * -> blocks if full, only to be used from tasks NOT from ISR! - * - * @param mbox mbox to posts the message - * @param msg message to post (ATTENTION: can be NULL) - */ -void sys_mbox_post(sys_mbox_t *mbox, void *msg); -/** - * @ingroup sys_mbox - * Try to post a message to an mbox - may fail if full. - * Can be used from ISR (if the sys arch layer allows this). - * Returns ERR_MEM if it is full, else, ERR_OK if the "msg" is posted. - * - * @param mbox mbox to posts the message - * @param msg message to post (ATTENTION: can be NULL) - */ -err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg); -/** - * @ingroup sys_mbox - * Try to post a message to an mbox - may fail if full. - * To be be used from ISR. - * Returns ERR_MEM if it is full, else, ERR_OK if the "msg" is posted. - * - * @param mbox mbox to posts the message - * @param msg message to post (ATTENTION: can be NULL) - */ -err_t sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg); -/** - * @ingroup sys_mbox - * Blocks the thread until a message arrives in the mailbox, but does - * not block the thread longer than "timeout" milliseconds (similar to - * the sys_arch_sem_wait() function). If "timeout" is 0, the thread should - * be blocked until a message arrives. The "msg" argument is a result - * parameter that is set by the function (i.e., by doing "*msg = - * ptr"). The "msg" parameter maybe NULL to indicate that the message - * should be dropped. - * The return values are the same as for the sys_arch_sem_wait() function: - * SYS_ARCH_TIMEOUT if there was a timeout, any other value if a messages - * is received. - * - * Note that a function with a similar name, sys_mbox_fetch(), is - * implemented by lwIP. - * - * @param mbox mbox to get a message from - * @param msg pointer where the message is stored - * @param timeout maximum time (in milliseconds) to wait for a message (0 = wait forever) - * @return SYS_ARCH_TIMEOUT on timeout, any other value if a message has been received - */ -u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout); -/* Allow port to override with a macro, e.g. special timeout for sys_arch_mbox_fetch() */ -#ifndef sys_arch_mbox_tryfetch -/** - * @ingroup sys_mbox - * This is similar to sys_arch_mbox_fetch, however if a message is not - * present in the mailbox, it immediately returns with the code - * SYS_MBOX_EMPTY. On success 0 is returned. - * To allow for efficient implementations, this can be defined as a - * function-like macro in sys_arch.h instead of a normal function. For - * example, a naive implementation could be: - * \#define sys_arch_mbox_tryfetch(mbox,msg) sys_arch_mbox_fetch(mbox,msg,1) - * although this would introduce unnecessary delays. - * - * @param mbox mbox to get a message from - * @param msg pointer where the message is stored - * @return 0 (milliseconds) if a message has been received - * or SYS_MBOX_EMPTY if the mailbox is empty - */ -u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg); -#endif -/** - * For now, we map straight to sys_arch implementation. - */ -#define sys_mbox_tryfetch(mbox, msg) sys_arch_mbox_tryfetch(mbox, msg) -/** - * @ingroup sys_mbox - * Deallocates a mailbox. If there are messages still present in the - * mailbox when the mailbox is deallocated, it is an indication of a - * programming error in lwIP and the developer should be notified. - * - * @param mbox mbox to delete - */ -void sys_mbox_free(sys_mbox_t *mbox); -#define sys_mbox_fetch(mbox, msg) sys_arch_mbox_fetch(mbox, msg, 0) -#ifndef sys_mbox_valid -/** - * @ingroup sys_mbox - * Returns 1 if the mailbox is valid, 0 if it is not valid. - * When using pointers, a simple way is to check the pointer for != NULL. - * When directly using OS structures, implementing this may be more complex. - * This may also be a define, in which case the function is not prototyped. - */ -int sys_mbox_valid(sys_mbox_t *mbox); -#endif -#ifndef sys_mbox_set_invalid -/** - * @ingroup sys_mbox - * Invalidate a mailbox so that sys_mbox_valid() returns 0. - * ATTENTION: This does NOT mean that the mailbox shall be deallocated: - * sys_mbox_free() is always called before calling this function! - * This may also be a define, in which case the function is not prototyped. - */ -void sys_mbox_set_invalid(sys_mbox_t *mbox); -#endif -#ifndef sys_mbox_valid_val -/** - * Same as sys_mbox_valid() but taking a value, not a pointer - */ -#define sys_mbox_valid_val(mbox) sys_mbox_valid(&(mbox)) -#endif -#ifndef sys_mbox_set_invalid_val -/** - * Same as sys_mbox_set_invalid() but taking a value, not a pointer - */ -#define sys_mbox_set_invalid_val(mbox) sys_mbox_set_invalid(&(mbox)) -#endif - - -/** - * @ingroup sys_misc - * The only thread function: - * Starts a new thread named "name" with priority "prio" that will begin its - * execution in the function "thread()". The "arg" argument will be passed as an - * argument to the thread() function. The stack size to used for this thread is - * the "stacksize" parameter. The id of the new thread is returned. Both the id - * and the priority are system dependent. - * ATTENTION: although this function returns a value, it MUST NOT FAIL (ports have to assert this!) - * - * @param name human-readable name for the thread (used for debugging purposes) - * @param thread thread-function - * @param arg parameter passed to 'thread' - * @param stacksize stack size in bytes for the new thread (may be ignored by ports) - * @param prio priority of the new thread (may be ignored by ports) */ -sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio); - -#endif /* NO_SYS */ - -/** - * @ingroup sys_misc - * sys_init() must be called before anything else. - * Initialize the sys_arch layer. - */ -void sys_init(void); - -#ifndef sys_jiffies -/** - * Ticks/jiffies since power up. - */ -u32_t sys_jiffies(void); -#endif - -/** - * @ingroup sys_time - * Returns the current time in milliseconds, - * may be the same as sys_jiffies or at least based on it. - * Don't care for wraparound, this is only used for time diffs. - * Not implementing this function means you cannot use some modules (e.g. TCP - * timestamps, internal timeouts for NO_SYS==1). - */ -u32_t sys_now(void); - -/* Critical Region Protection */ -/* These functions must be implemented in the sys_arch.c file. - In some implementations they can provide a more light-weight protection - mechanism than using semaphores. Otherwise semaphores can be used for - implementation */ -#ifndef SYS_ARCH_PROTECT -/** SYS_LIGHTWEIGHT_PROT - * define SYS_LIGHTWEIGHT_PROT in lwipopts.h if you want inter-task protection - * for certain critical regions during buffer allocation, deallocation and memory - * allocation and deallocation. - */ -#if SYS_LIGHTWEIGHT_PROT - -/** - * @ingroup sys_prot - * SYS_ARCH_DECL_PROTECT - * declare a protection variable. This macro will default to defining a variable of - * type sys_prot_t. If a particular port needs a different implementation, then - * this macro may be defined in sys_arch.h. - */ -#define SYS_ARCH_DECL_PROTECT(lev) sys_prot_t lev -/** - * @ingroup sys_prot - * SYS_ARCH_PROTECT - * Perform a "fast" protect. This could be implemented by - * disabling interrupts for an embedded system or by using a semaphore or - * mutex. The implementation should allow calling SYS_ARCH_PROTECT when - * already protected. The old protection level is returned in the variable - * "lev". This macro will default to calling the sys_arch_protect() function - * which should be implemented in sys_arch.c. If a particular port needs a - * different implementation, then this macro may be defined in sys_arch.h - */ -#define SYS_ARCH_PROTECT(lev) lev = sys_arch_protect() -/** - * @ingroup sys_prot - * SYS_ARCH_UNPROTECT - * Perform a "fast" set of the protection level to "lev". This could be - * implemented by setting the interrupt level to "lev" within the MACRO or by - * using a semaphore or mutex. This macro will default to calling the - * sys_arch_unprotect() function which should be implemented in - * sys_arch.c. If a particular port needs a different implementation, then - * this macro may be defined in sys_arch.h - */ -#define SYS_ARCH_UNPROTECT(lev) sys_arch_unprotect(lev) -sys_prot_t sys_arch_protect(void); -void sys_arch_unprotect(sys_prot_t pval); - -#else - -#define SYS_ARCH_DECL_PROTECT(lev) -#define SYS_ARCH_PROTECT(lev) -#define SYS_ARCH_UNPROTECT(lev) - -#endif /* SYS_LIGHTWEIGHT_PROT */ - -#endif /* SYS_ARCH_PROTECT */ - -/* - * Macros to set/get and increase/decrease variables in a thread-safe way. - * Use these for accessing variable that are used from more than one thread. - */ - -#ifndef SYS_ARCH_INC -#define SYS_ARCH_INC(var, val) do { \ - SYS_ARCH_DECL_PROTECT(old_level); \ - SYS_ARCH_PROTECT(old_level); \ - var += val; \ - SYS_ARCH_UNPROTECT(old_level); \ - } while(0) -#endif /* SYS_ARCH_INC */ - -#ifndef SYS_ARCH_DEC -#define SYS_ARCH_DEC(var, val) do { \ - SYS_ARCH_DECL_PROTECT(old_level); \ - SYS_ARCH_PROTECT(old_level); \ - var -= val; \ - SYS_ARCH_UNPROTECT(old_level); \ - } while(0) -#endif /* SYS_ARCH_DEC */ - -#ifndef SYS_ARCH_GET -#define SYS_ARCH_GET(var, ret) do { \ - SYS_ARCH_DECL_PROTECT(old_level); \ - SYS_ARCH_PROTECT(old_level); \ - ret = var; \ - SYS_ARCH_UNPROTECT(old_level); \ - } while(0) -#endif /* SYS_ARCH_GET */ - -#ifndef SYS_ARCH_SET -#define SYS_ARCH_SET(var, val) do { \ - SYS_ARCH_DECL_PROTECT(old_level); \ - SYS_ARCH_PROTECT(old_level); \ - var = val; \ - SYS_ARCH_UNPROTECT(old_level); \ - } while(0) -#endif /* SYS_ARCH_SET */ - -#ifndef SYS_ARCH_LOCKED -#define SYS_ARCH_LOCKED(code) do { \ - SYS_ARCH_DECL_PROTECT(old_level); \ - SYS_ARCH_PROTECT(old_level); \ - code; \ - SYS_ARCH_UNPROTECT(old_level); \ - } while(0) -#endif /* SYS_ARCH_LOCKED */ - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_SYS_H */ +/** + * @file + * OS abstraction layer + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + */ + +#ifndef LWIP_HDR_SYS_H +#define LWIP_HDR_SYS_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if NO_SYS + +/* For a totally minimal and standalone system, we provide null + definitions of the sys_ functions. */ +typedef u8_t sys_sem_t; +typedef u8_t sys_mutex_t; +typedef u8_t sys_mbox_t; + +#define sys_sem_new(s, c) ERR_OK +#define sys_sem_signal(s) +#define sys_sem_wait(s) +#define sys_arch_sem_wait(s,t) +#define sys_sem_free(s) +#define sys_sem_valid(s) 0 +#define sys_sem_valid_val(s) 0 +#define sys_sem_set_invalid(s) +#define sys_sem_set_invalid_val(s) +#define sys_mutex_new(mu) ERR_OK +#define sys_mutex_lock(mu) +#define sys_mutex_unlock(mu) +#define sys_mutex_free(mu) +#define sys_mutex_valid(mu) 0 +#define sys_mutex_set_invalid(mu) +#define sys_mbox_new(m, s) ERR_OK +#define sys_mbox_fetch(m,d) +#define sys_mbox_tryfetch(m,d) +#define sys_mbox_post(m,d) +#define sys_mbox_trypost(m,d) +#define sys_mbox_free(m) +#define sys_mbox_valid(m) +#define sys_mbox_valid_val(m) +#define sys_mbox_set_invalid(m) +#define sys_mbox_set_invalid_val(m) + +#define sys_thread_new(n,t,a,s,p) + +#define sys_msleep(t) + +#else /* NO_SYS */ + +/** Return code for timeouts from sys_arch_mbox_fetch and sys_arch_sem_wait */ +#define SYS_ARCH_TIMEOUT 0xffffffffUL + +/** sys_mbox_tryfetch() returns SYS_MBOX_EMPTY if appropriate. + * For now we use the same magic value, but we allow this to change in future. + */ +#define SYS_MBOX_EMPTY SYS_ARCH_TIMEOUT + +#include "lwip/err.h" +#include "arch/sys_arch.h" + +/** Function prototype for thread functions */ +typedef void (*lwip_thread_fn)(void *arg); + +/* Function prototypes for functions to be implemented by platform ports + (in sys_arch.c) */ + +/* Mutex functions: */ + +/** Define LWIP_COMPAT_MUTEX if the port has no mutexes and binary semaphores + should be used instead */ +#ifndef LWIP_COMPAT_MUTEX +#define LWIP_COMPAT_MUTEX 0 +#endif + +#if LWIP_COMPAT_MUTEX +/* for old ports that don't have mutexes: define them to binary semaphores */ +#define sys_mutex_t sys_sem_t +#define sys_mutex_new(mutex) sys_sem_new(mutex, 1) +#define sys_mutex_lock(mutex) sys_sem_wait(mutex) +#define sys_mutex_unlock(mutex) sys_sem_signal(mutex) +#define sys_mutex_free(mutex) sys_sem_free(mutex) +#define sys_mutex_valid(mutex) sys_sem_valid(mutex) +#define sys_mutex_set_invalid(mutex) sys_sem_set_invalid(mutex) + +#else /* LWIP_COMPAT_MUTEX */ + +/** + * @ingroup sys_mutex + * Create a new mutex. + * Note that mutexes are expected to not be taken recursively by the lwIP code, + * so both implementation types (recursive or non-recursive) should work. + * The mutex is allocated to the memory that 'mutex' + * points to (which can be both a pointer or the actual OS structure). + * If the mutex has been created, ERR_OK should be returned. Returning any + * other error will provide a hint what went wrong, but except for assertions, + * no real error handling is implemented. + * + * @param mutex pointer to the mutex to create + * @return ERR_OK if successful, another err_t otherwise + */ +err_t sys_mutex_new(sys_mutex_t *mutex); +/** + * @ingroup sys_mutex + * Blocks the thread until the mutex can be grabbed. + * @param mutex the mutex to lock + */ +void sys_mutex_lock(sys_mutex_t *mutex); +/** + * @ingroup sys_mutex + * Releases the mutex previously locked through 'sys_mutex_lock()'. + * @param mutex the mutex to unlock + */ +void sys_mutex_unlock(sys_mutex_t *mutex); +/** + * @ingroup sys_mutex + * Deallocates a mutex. + * @param mutex the mutex to delete + */ +void sys_mutex_free(sys_mutex_t *mutex); +#ifndef sys_mutex_valid +/** + * @ingroup sys_mutex + * Returns 1 if the mutes is valid, 0 if it is not valid. + * When using pointers, a simple way is to check the pointer for != NULL. + * When directly using OS structures, implementing this may be more complex. + * This may also be a define, in which case the function is not prototyped. + */ +int sys_mutex_valid(sys_mutex_t *mutex); +#endif +#ifndef sys_mutex_set_invalid +/** + * @ingroup sys_mutex + * Invalidate a mutex so that sys_mutex_valid() returns 0. + * ATTENTION: This does NOT mean that the mutex shall be deallocated: + * sys_mutex_free() is always called before calling this function! + * This may also be a define, in which case the function is not prototyped. + */ +void sys_mutex_set_invalid(sys_mutex_t *mutex); +#endif +#endif /* LWIP_COMPAT_MUTEX */ + +/* Semaphore functions: */ + +/** + * @ingroup sys_sem + * Create a new semaphore + * Creates a new semaphore. The semaphore is allocated to the memory that 'sem' + * points to (which can be both a pointer or the actual OS structure). + * The "count" argument specifies the initial state of the semaphore (which is + * either 0 or 1). + * If the semaphore has been created, ERR_OK should be returned. Returning any + * other error will provide a hint what went wrong, but except for assertions, + * no real error handling is implemented. + * + * @param sem pointer to the semaphore to create + * @param count initial count of the semaphore + * @return ERR_OK if successful, another err_t otherwise + */ +err_t sys_sem_new(sys_sem_t *sem, u8_t count); +/** + * @ingroup sys_sem + * Signals a semaphore + * @param sem the semaphore to signal + */ +void sys_sem_signal(sys_sem_t *sem); +/** + * @ingroup sys_sem + * Blocks the thread while waiting for the semaphore to be signaled. If the + * "timeout" argument is non-zero, the thread should only be blocked for the + * specified time (measured in milliseconds). If the "timeout" argument is zero, + * the thread should be blocked until the semaphore is signalled. + * + * The return value is SYS_ARCH_TIMEOUT if the semaphore wasn't signaled within + * the specified time or any other value if it was signaled (with or without + * waiting). + * Notice that lwIP implements a function with a similar name, + * sys_sem_wait(), that uses the sys_arch_sem_wait() function. + * + * @param sem the semaphore to wait for + * @param timeout timeout in milliseconds to wait (0 = wait forever) + * @return SYS_ARCH_TIMEOUT on timeout, any other value on success + */ +u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout); +/** + * @ingroup sys_sem + * Deallocates a semaphore. + * @param sem semaphore to delete + */ +void sys_sem_free(sys_sem_t *sem); +/** Wait for a semaphore - forever/no timeout */ +#define sys_sem_wait(sem) sys_arch_sem_wait(sem, 0) +#ifndef sys_sem_valid +/** + * @ingroup sys_sem + * Returns 1 if the semaphore is valid, 0 if it is not valid. + * When using pointers, a simple way is to check the pointer for != NULL. + * When directly using OS structures, implementing this may be more complex. + * This may also be a define, in which case the function is not prototyped. + */ +int sys_sem_valid(sys_sem_t *sem); +#endif +#ifndef sys_sem_set_invalid +/** + * @ingroup sys_sem + * Invalidate a semaphore so that sys_sem_valid() returns 0. + * ATTENTION: This does NOT mean that the semaphore shall be deallocated: + * sys_sem_free() is always called before calling this function! + * This may also be a define, in which case the function is not prototyped. + */ +void sys_sem_set_invalid(sys_sem_t *sem); +#endif +#ifndef sys_sem_valid_val +/** + * Same as sys_sem_valid() but taking a value, not a pointer + */ +#define sys_sem_valid_val(sem) sys_sem_valid(&(sem)) +#endif +#ifndef sys_sem_set_invalid_val +/** + * Same as sys_sem_set_invalid() but taking a value, not a pointer + */ +#define sys_sem_set_invalid_val(sem) sys_sem_set_invalid(&(sem)) +#endif + +#ifndef sys_msleep +/** + * @ingroup sys_misc + * Sleep for specified number of ms + */ +void sys_msleep(u32_t ms); /* only has a (close to) 1 ms resolution. */ +#endif + +/* Mailbox functions. */ + +/** + * @ingroup sys_mbox + * Creates an empty mailbox for maximum "size" elements. Elements stored + * in mailboxes are pointers. You have to define macros "_MBOX_SIZE" + * in your lwipopts.h, or ignore this parameter in your implementation + * and use a default size. + * If the mailbox has been created, ERR_OK should be returned. Returning any + * other error will provide a hint what went wrong, but except for assertions, + * no real error handling is implemented. + * + * @param mbox pointer to the mbox to create + * @param size (minimum) number of messages in this mbox + * @return ERR_OK if successful, another err_t otherwise + */ +err_t sys_mbox_new(sys_mbox_t *mbox, int size); +/** + * @ingroup sys_mbox + * Post a message to an mbox - may not fail + * -> blocks if full, only to be used from tasks NOT from ISR! + * + * @param mbox mbox to posts the message + * @param msg message to post (ATTENTION: can be NULL) + */ +void sys_mbox_post(sys_mbox_t *mbox, void *msg); +/** + * @ingroup sys_mbox + * Try to post a message to an mbox - may fail if full. + * Can be used from ISR (if the sys arch layer allows this). + * Returns ERR_MEM if it is full, else, ERR_OK if the "msg" is posted. + * + * @param mbox mbox to posts the message + * @param msg message to post (ATTENTION: can be NULL) + */ +err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg); +/** + * @ingroup sys_mbox + * Try to post a message to an mbox - may fail if full. + * To be be used from ISR. + * Returns ERR_MEM if it is full, else, ERR_OK if the "msg" is posted. + * + * @param mbox mbox to posts the message + * @param msg message to post (ATTENTION: can be NULL) + */ +err_t sys_mbox_trypost_fromisr(sys_mbox_t *mbox, void *msg); +/** + * @ingroup sys_mbox + * Blocks the thread until a message arrives in the mailbox, but does + * not block the thread longer than "timeout" milliseconds (similar to + * the sys_arch_sem_wait() function). If "timeout" is 0, the thread should + * be blocked until a message arrives. The "msg" argument is a result + * parameter that is set by the function (i.e., by doing "*msg = + * ptr"). The "msg" parameter maybe NULL to indicate that the message + * should be dropped. + * The return values are the same as for the sys_arch_sem_wait() function: + * SYS_ARCH_TIMEOUT if there was a timeout, any other value if a messages + * is received. + * + * Note that a function with a similar name, sys_mbox_fetch(), is + * implemented by lwIP. + * + * @param mbox mbox to get a message from + * @param msg pointer where the message is stored + * @param timeout maximum time (in milliseconds) to wait for a message (0 = wait forever) + * @return SYS_ARCH_TIMEOUT on timeout, any other value if a message has been received + */ +u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout); +/* Allow port to override with a macro, e.g. special timeout for sys_arch_mbox_fetch() */ +#ifndef sys_arch_mbox_tryfetch +/** + * @ingroup sys_mbox + * This is similar to sys_arch_mbox_fetch, however if a message is not + * present in the mailbox, it immediately returns with the code + * SYS_MBOX_EMPTY. On success 0 is returned. + * To allow for efficient implementations, this can be defined as a + * function-like macro in sys_arch.h instead of a normal function. For + * example, a naive implementation could be: + * \#define sys_arch_mbox_tryfetch(mbox,msg) sys_arch_mbox_fetch(mbox,msg,1) + * although this would introduce unnecessary delays. + * + * @param mbox mbox to get a message from + * @param msg pointer where the message is stored + * @return 0 (milliseconds) if a message has been received + * or SYS_MBOX_EMPTY if the mailbox is empty + */ +u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg); +#endif +/** + * For now, we map straight to sys_arch implementation. + */ +#define sys_mbox_tryfetch(mbox, msg) sys_arch_mbox_tryfetch(mbox, msg) +/** + * @ingroup sys_mbox + * Deallocates a mailbox. If there are messages still present in the + * mailbox when the mailbox is deallocated, it is an indication of a + * programming error in lwIP and the developer should be notified. + * + * @param mbox mbox to delete + */ +void sys_mbox_free(sys_mbox_t *mbox); +#define sys_mbox_fetch(mbox, msg) sys_arch_mbox_fetch(mbox, msg, 0) +#ifndef sys_mbox_valid +/** + * @ingroup sys_mbox + * Returns 1 if the mailbox is valid, 0 if it is not valid. + * When using pointers, a simple way is to check the pointer for != NULL. + * When directly using OS structures, implementing this may be more complex. + * This may also be a define, in which case the function is not prototyped. + */ +int sys_mbox_valid(sys_mbox_t *mbox); +#endif +#ifndef sys_mbox_set_invalid +/** + * @ingroup sys_mbox + * Invalidate a mailbox so that sys_mbox_valid() returns 0. + * ATTENTION: This does NOT mean that the mailbox shall be deallocated: + * sys_mbox_free() is always called before calling this function! + * This may also be a define, in which case the function is not prototyped. + */ +void sys_mbox_set_invalid(sys_mbox_t *mbox); +#endif +#ifndef sys_mbox_valid_val +/** + * Same as sys_mbox_valid() but taking a value, not a pointer + */ +#define sys_mbox_valid_val(mbox) sys_mbox_valid(&(mbox)) +#endif +#ifndef sys_mbox_set_invalid_val +/** + * Same as sys_mbox_set_invalid() but taking a value, not a pointer + */ +#define sys_mbox_set_invalid_val(mbox) sys_mbox_set_invalid(&(mbox)) +#endif + + +/** + * @ingroup sys_misc + * The only thread function: + * Starts a new thread named "name" with priority "prio" that will begin its + * execution in the function "thread()". The "arg" argument will be passed as an + * argument to the thread() function. The stack size to used for this thread is + * the "stacksize" parameter. The id of the new thread is returned. Both the id + * and the priority are system dependent. + * ATTENTION: although this function returns a value, it MUST NOT FAIL (ports have to assert this!) + * + * @param name human-readable name for the thread (used for debugging purposes) + * @param thread thread-function + * @param arg parameter passed to 'thread' + * @param stacksize stack size in bytes for the new thread (may be ignored by ports) + * @param prio priority of the new thread (may be ignored by ports) */ +sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio); + +#endif /* NO_SYS */ + +/** + * @ingroup sys_misc + * sys_init() must be called before anything else. + * Initialize the sys_arch layer. + */ +void sys_init(void); + +#ifndef sys_jiffies +/** + * Ticks/jiffies since power up. + */ +u32_t sys_jiffies(void); +#endif + +/** + * @ingroup sys_time + * Returns the current time in milliseconds, + * may be the same as sys_jiffies or at least based on it. + * Don't care for wraparound, this is only used for time diffs. + * Not implementing this function means you cannot use some modules (e.g. TCP + * timestamps, internal timeouts for NO_SYS==1). + */ +u32_t sys_now(void); + +/* Critical Region Protection */ +/* These functions must be implemented in the sys_arch.c file. + In some implementations they can provide a more light-weight protection + mechanism than using semaphores. Otherwise semaphores can be used for + implementation */ +#ifndef SYS_ARCH_PROTECT +/** SYS_LIGHTWEIGHT_PROT + * define SYS_LIGHTWEIGHT_PROT in lwipopts.h if you want inter-task protection + * for certain critical regions during buffer allocation, deallocation and memory + * allocation and deallocation. + */ +#if SYS_LIGHTWEIGHT_PROT + +/** + * @ingroup sys_prot + * SYS_ARCH_DECL_PROTECT + * declare a protection variable. This macro will default to defining a variable of + * type sys_prot_t. If a particular port needs a different implementation, then + * this macro may be defined in sys_arch.h. + */ +#define SYS_ARCH_DECL_PROTECT(lev) sys_prot_t lev +/** + * @ingroup sys_prot + * SYS_ARCH_PROTECT + * Perform a "fast" protect. This could be implemented by + * disabling interrupts for an embedded system or by using a semaphore or + * mutex. The implementation should allow calling SYS_ARCH_PROTECT when + * already protected. The old protection level is returned in the variable + * "lev". This macro will default to calling the sys_arch_protect() function + * which should be implemented in sys_arch.c. If a particular port needs a + * different implementation, then this macro may be defined in sys_arch.h + */ +#define SYS_ARCH_PROTECT(lev) lev = sys_arch_protect() +/** + * @ingroup sys_prot + * SYS_ARCH_UNPROTECT + * Perform a "fast" set of the protection level to "lev". This could be + * implemented by setting the interrupt level to "lev" within the MACRO or by + * using a semaphore or mutex. This macro will default to calling the + * sys_arch_unprotect() function which should be implemented in + * sys_arch.c. If a particular port needs a different implementation, then + * this macro may be defined in sys_arch.h + */ +#define SYS_ARCH_UNPROTECT(lev) sys_arch_unprotect(lev) +sys_prot_t sys_arch_protect(void); +void sys_arch_unprotect(sys_prot_t pval); + +#else + +#define SYS_ARCH_DECL_PROTECT(lev) +#define SYS_ARCH_PROTECT(lev) +#define SYS_ARCH_UNPROTECT(lev) + +#endif /* SYS_LIGHTWEIGHT_PROT */ + +#endif /* SYS_ARCH_PROTECT */ + +/* + * Macros to set/get and increase/decrease variables in a thread-safe way. + * Use these for accessing variable that are used from more than one thread. + */ + +#ifndef SYS_ARCH_INC +#define SYS_ARCH_INC(var, val) do { \ + SYS_ARCH_DECL_PROTECT(old_level); \ + SYS_ARCH_PROTECT(old_level); \ + var += val; \ + SYS_ARCH_UNPROTECT(old_level); \ + } while(0) +#endif /* SYS_ARCH_INC */ + +#ifndef SYS_ARCH_DEC +#define SYS_ARCH_DEC(var, val) do { \ + SYS_ARCH_DECL_PROTECT(old_level); \ + SYS_ARCH_PROTECT(old_level); \ + var -= val; \ + SYS_ARCH_UNPROTECT(old_level); \ + } while(0) +#endif /* SYS_ARCH_DEC */ + +#ifndef SYS_ARCH_GET +#define SYS_ARCH_GET(var, ret) do { \ + SYS_ARCH_DECL_PROTECT(old_level); \ + SYS_ARCH_PROTECT(old_level); \ + ret = var; \ + SYS_ARCH_UNPROTECT(old_level); \ + } while(0) +#endif /* SYS_ARCH_GET */ + +#ifndef SYS_ARCH_SET +#define SYS_ARCH_SET(var, val) do { \ + SYS_ARCH_DECL_PROTECT(old_level); \ + SYS_ARCH_PROTECT(old_level); \ + var = val; \ + SYS_ARCH_UNPROTECT(old_level); \ + } while(0) +#endif /* SYS_ARCH_SET */ + +#ifndef SYS_ARCH_LOCKED +#define SYS_ARCH_LOCKED(code) do { \ + SYS_ARCH_DECL_PROTECT(old_level); \ + SYS_ARCH_PROTECT(old_level); \ + code; \ + SYS_ARCH_UNPROTECT(old_level); \ + } while(0) +#endif /* SYS_ARCH_LOCKED */ + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_SYS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcp.h index 8c9ba98c..daf75994 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcp.h @@ -1,500 +1,500 @@ -/** - * @file - * TCP API (to be used from TCPIP thread)\n - * See also @ref tcp_raw - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_TCP_H -#define LWIP_HDR_TCP_H - -#include "lwip/opt.h" - -#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/tcpbase.h" -#include "lwip/mem.h" -#include "lwip/pbuf.h" -#include "lwip/ip.h" -#include "lwip/icmp.h" -#include "lwip/err.h" -#include "lwip/ip6.h" -#include "lwip/ip6_addr.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct tcp_pcb; -struct tcp_pcb_listen; - -/** Function prototype for tcp accept callback functions. Called when a new - * connection can be accepted on a listening pcb. - * - * @param arg Additional argument to pass to the callback function (@see tcp_arg()) - * @param newpcb The new connection pcb - * @param err An error code if there has been an error accepting. - * Only return ERR_ABRT if you have called tcp_abort from within the - * callback function! - */ -typedef err_t (*tcp_accept_fn)(void *arg, struct tcp_pcb *newpcb, err_t err); - -/** Function prototype for tcp receive callback functions. Called when data has - * been received. - * - * @param arg Additional argument to pass to the callback function (@see tcp_arg()) - * @param tpcb The connection pcb which received data - * @param p The received data (or NULL when the connection has been closed!) - * @param err An error code if there has been an error receiving - * Only return ERR_ABRT if you have called tcp_abort from within the - * callback function! - */ -typedef err_t (*tcp_recv_fn)(void *arg, struct tcp_pcb *tpcb, - struct pbuf *p, err_t err); - -/** Function prototype for tcp sent callback functions. Called when sent data has - * been acknowledged by the remote side. Use it to free corresponding resources. - * This also means that the pcb has now space available to send new data. - * - * @param arg Additional argument to pass to the callback function (@see tcp_arg()) - * @param tpcb The connection pcb for which data has been acknowledged - * @param len The amount of bytes acknowledged - * @return ERR_OK: try to send some data by calling tcp_output - * Only return ERR_ABRT if you have called tcp_abort from within the - * callback function! - */ -typedef err_t (*tcp_sent_fn)(void *arg, struct tcp_pcb *tpcb, - u16_t len); - -/** Function prototype for tcp poll callback functions. Called periodically as - * specified by @see tcp_poll. - * - * @param arg Additional argument to pass to the callback function (@see tcp_arg()) - * @param tpcb tcp pcb - * @return ERR_OK: try to send some data by calling tcp_output - * Only return ERR_ABRT if you have called tcp_abort from within the - * callback function! - */ -typedef err_t (*tcp_poll_fn)(void *arg, struct tcp_pcb *tpcb); - -/** Function prototype for tcp error callback functions. Called when the pcb - * receives a RST or is unexpectedly closed for any other reason. - * - * @note The corresponding pcb is already freed when this callback is called! - * - * @param arg Additional argument to pass to the callback function (@see tcp_arg()) - * @param err Error code to indicate why the pcb has been closed - * ERR_ABRT: aborted through tcp_abort or by a TCP timer - * ERR_RST: the connection was reset by the remote host - */ -typedef void (*tcp_err_fn)(void *arg, err_t err); - -/** Function prototype for tcp connected callback functions. Called when a pcb - * is connected to the remote side after initiating a connection attempt by - * calling tcp_connect(). - * - * @param arg Additional argument to pass to the callback function (@see tcp_arg()) - * @param tpcb The connection pcb which is connected - * @param err An unused error code, always ERR_OK currently ;-) @todo! - * Only return ERR_ABRT if you have called tcp_abort from within the - * callback function! - * - * @note When a connection attempt fails, the error callback is currently called! - */ -typedef err_t (*tcp_connected_fn)(void *arg, struct tcp_pcb *tpcb, err_t err); - -#if LWIP_WND_SCALE -#define RCV_WND_SCALE(pcb, wnd) (((wnd) >> (pcb)->rcv_scale)) -#define SND_WND_SCALE(pcb, wnd) (((wnd) << (pcb)->snd_scale)) -#define TCPWND16(x) ((u16_t)LWIP_MIN((x), 0xFFFF)) -#define TCP_WND_MAX(pcb) ((tcpwnd_size_t)(((pcb)->flags & TF_WND_SCALE) ? TCP_WND : TCPWND16(TCP_WND))) -#else -#define RCV_WND_SCALE(pcb, wnd) (wnd) -#define SND_WND_SCALE(pcb, wnd) (wnd) -#define TCPWND16(x) (x) -#define TCP_WND_MAX(pcb) TCP_WND -#endif -/* Increments a tcpwnd_size_t and holds at max value rather than rollover */ -#define TCP_WND_INC(wnd, inc) do { \ - if ((tcpwnd_size_t)(wnd + inc) >= wnd) { \ - wnd = (tcpwnd_size_t)(wnd + inc); \ - } else { \ - wnd = (tcpwnd_size_t)-1; \ - } \ - } while(0) - -#if LWIP_TCP_SACK_OUT -/** SACK ranges to include in ACK packets. - * SACK entry is invalid if left==right. */ -struct tcp_sack_range { - /** Left edge of the SACK: the first acknowledged sequence number. */ - u32_t left; - /** Right edge of the SACK: the last acknowledged sequence number +1 (so first NOT acknowledged). */ - u32_t right; -}; -#endif /* LWIP_TCP_SACK_OUT */ - -/** Function prototype for deallocation of arguments. Called *just before* the - * pcb is freed, so don't expect to be able to do anything with this pcb! - * - * @param id ext arg id (allocated via @ref tcp_ext_arg_alloc_id) - * @param data pointer to the data (set via @ref tcp_ext_arg_set before) - */ -typedef void (*tcp_extarg_callback_pcb_destroyed_fn)(u8_t id, void *data); - -/** Function prototype to transition arguments from a listening pcb to an accepted pcb - * - * @param id ext arg id (allocated via @ref tcp_ext_arg_alloc_id) - * @param lpcb the listening pcb accepting a connection - * @param cpcb the newly allocated connection pcb - * @return ERR_OK if OK, any error if connection should be dropped - */ -typedef err_t (*tcp_extarg_callback_passive_open_fn)(u8_t id, struct tcp_pcb_listen *lpcb, struct tcp_pcb *cpcb); - -/** A table of callback functions that is invoked for ext arguments */ -struct tcp_ext_arg_callbacks { - /** @ref tcp_extarg_callback_pcb_destroyed_fn */ - tcp_extarg_callback_pcb_destroyed_fn destroy; - /** @ref tcp_extarg_callback_passive_open_fn */ - tcp_extarg_callback_passive_open_fn passive_open; -}; - -#define LWIP_TCP_PCB_NUM_EXT_ARG_ID_INVALID 0xFF - -#if LWIP_TCP_PCB_NUM_EXT_ARGS -/* This is the structure for ext args in tcp pcbs (used as array) */ -struct tcp_pcb_ext_args { - const struct tcp_ext_arg_callbacks *callbacks; - void *data; -}; -/* This is a helper define to prevent zero size arrays if disabled */ -#define TCP_PCB_EXTARGS struct tcp_pcb_ext_args ext_args[LWIP_TCP_PCB_NUM_EXT_ARGS]; -#else -#define TCP_PCB_EXTARGS -#endif - -typedef u16_t tcpflags_t; -#define TCP_ALLFLAGS 0xffffU - -/** - * members common to struct tcp_pcb and struct tcp_listen_pcb - */ -#define TCP_PCB_COMMON(type) \ - type *next; /* for the linked list */ \ - void *callback_arg; \ - TCP_PCB_EXTARGS \ - enum tcp_state state; /* TCP state */ \ - u8_t prio; \ - /* ports are in host byte order */ \ - u16_t local_port - - -/** the TCP protocol control block for listening pcbs */ -struct tcp_pcb_listen { -/** Common members of all PCB types */ - IP_PCB; -/** Protocol specific PCB members */ - TCP_PCB_COMMON(struct tcp_pcb_listen); - -#if LWIP_CALLBACK_API - /* Function to call when a listener has been connected. */ - tcp_accept_fn accept; -#endif /* LWIP_CALLBACK_API */ - -#if TCP_LISTEN_BACKLOG - u8_t backlog; - u8_t accepts_pending; -#endif /* TCP_LISTEN_BACKLOG */ -}; - - -/** the TCP protocol control block */ -struct tcp_pcb { -/** common PCB members */ - IP_PCB; -/** protocol specific PCB members */ - TCP_PCB_COMMON(struct tcp_pcb); - - /* ports are in host byte order */ - u16_t remote_port; - - tcpflags_t flags; -#define TF_ACK_DELAY 0x01U /* Delayed ACK. */ -#define TF_ACK_NOW 0x02U /* Immediate ACK. */ -#define TF_INFR 0x04U /* In fast recovery. */ -#define TF_CLOSEPEND 0x08U /* If this is set, tcp_close failed to enqueue the FIN (retried in tcp_tmr) */ -#define TF_RXCLOSED 0x10U /* rx closed by tcp_shutdown */ -#define TF_FIN 0x20U /* Connection was closed locally (FIN segment enqueued). */ -#define TF_NODELAY 0x40U /* Disable Nagle algorithm */ -#define TF_NAGLEMEMERR 0x80U /* nagle enabled, memerr, try to output to prevent delayed ACK to happen */ -#if LWIP_WND_SCALE -#define TF_WND_SCALE 0x0100U /* Window Scale option enabled */ -#endif -#if TCP_LISTEN_BACKLOG -#define TF_BACKLOGPEND 0x0200U /* If this is set, a connection pcb has increased the backlog on its listener */ -#endif -#if LWIP_TCP_TIMESTAMPS -#define TF_TIMESTAMP 0x0400U /* Timestamp option enabled */ -#endif -#define TF_RTO 0x0800U /* RTO timer has fired, in-flight data moved to unsent and being retransmitted */ -#if LWIP_TCP_SACK_OUT -#define TF_SACK 0x1000U /* Selective ACKs enabled */ -#endif - - /* the rest of the fields are in host byte order - as we have to do some math with them */ - - /* Timers */ - u8_t polltmr, pollinterval; - u8_t last_timer; - u32_t tmr; - - /* receiver variables */ - u32_t rcv_nxt; /* next seqno expected */ - tcpwnd_size_t rcv_wnd; /* receiver window available */ - tcpwnd_size_t rcv_ann_wnd; /* receiver window to announce */ - u32_t rcv_ann_right_edge; /* announced right edge of window */ - -#if LWIP_TCP_SACK_OUT - /* SACK ranges to include in ACK packets (entry is invalid if left==right) */ - struct tcp_sack_range rcv_sacks[LWIP_TCP_MAX_SACK_NUM]; -#define LWIP_TCP_SACK_VALID(pcb, idx) ((pcb)->rcv_sacks[idx].left != (pcb)->rcv_sacks[idx].right) -#endif /* LWIP_TCP_SACK_OUT */ - - /* Retransmission timer. */ - s16_t rtime; - - u16_t mss; /* maximum segment size */ - - /* RTT (round trip time) estimation variables */ - u32_t rttest; /* RTT estimate in 500ms ticks */ - u32_t rtseq; /* sequence number being timed */ - s16_t sa, sv; /* @see "Congestion Avoidance and Control" by Van Jacobson and Karels */ - - s16_t rto; /* retransmission time-out (in ticks of TCP_SLOW_INTERVAL) */ - u8_t nrtx; /* number of retransmissions */ - - /* fast retransmit/recovery */ - u8_t dupacks; - u32_t lastack; /* Highest acknowledged seqno. */ - - /* congestion avoidance/control variables */ - tcpwnd_size_t cwnd; - tcpwnd_size_t ssthresh; - - /* first byte following last rto byte */ - u32_t rto_end; - - /* sender variables */ - u32_t snd_nxt; /* next new seqno to be sent */ - u32_t snd_wl1, snd_wl2; /* Sequence and acknowledgement numbers of last - window update. */ - u32_t snd_lbb; /* Sequence number of next byte to be buffered. */ - tcpwnd_size_t snd_wnd; /* sender window */ - tcpwnd_size_t snd_wnd_max; /* the maximum sender window announced by the remote host */ - - tcpwnd_size_t snd_buf; /* Available buffer space for sending (in bytes). */ -#define TCP_SNDQUEUELEN_OVERFLOW (0xffffU-3) - u16_t snd_queuelen; /* Number of pbufs currently in the send buffer. */ - -#if TCP_OVERSIZE - /* Extra bytes available at the end of the last pbuf in unsent. */ - u16_t unsent_oversize; -#endif /* TCP_OVERSIZE */ - - tcpwnd_size_t bytes_acked; - - /* These are ordered by sequence number: */ - struct tcp_seg *unsent; /* Unsent (queued) segments. */ - struct tcp_seg *unacked; /* Sent but unacknowledged segments. */ -#if TCP_QUEUE_OOSEQ - struct tcp_seg *ooseq; /* Received out of sequence segments. */ -#endif /* TCP_QUEUE_OOSEQ */ - - struct pbuf *refused_data; /* Data previously received but not yet taken by upper layer */ - -#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG - struct tcp_pcb_listen* listener; -#endif /* LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG */ - -#if LWIP_CALLBACK_API - /* Function to be called when more send buffer space is available. */ - tcp_sent_fn sent; - /* Function to be called when (in-sequence) data has arrived. */ - tcp_recv_fn recv; - /* Function to be called when a connection has been set up. */ - tcp_connected_fn connected; - /* Function which is called periodically. */ - tcp_poll_fn poll; - /* Function to be called whenever a fatal error occurs. */ - tcp_err_fn errf; -#endif /* LWIP_CALLBACK_API */ - -#if LWIP_TCP_TIMESTAMPS - u32_t ts_lastacksent; - u32_t ts_recent; -#endif /* LWIP_TCP_TIMESTAMPS */ - - /* idle time before KEEPALIVE is sent */ - u32_t keep_idle; -#if LWIP_TCP_KEEPALIVE - u32_t keep_intvl; - u32_t keep_cnt; -#endif /* LWIP_TCP_KEEPALIVE */ - - /* Persist timer counter */ - u8_t persist_cnt; - /* Persist timer back-off */ - u8_t persist_backoff; - /* Number of persist probes */ - u8_t persist_probe; - - /* KEEPALIVE counter */ - u8_t keep_cnt_sent; - -#if LWIP_WND_SCALE - u8_t snd_scale; - u8_t rcv_scale; -#endif -}; - -#if LWIP_EVENT_API - -enum lwip_event { - LWIP_EVENT_ACCEPT, - LWIP_EVENT_SENT, - LWIP_EVENT_RECV, - LWIP_EVENT_CONNECTED, - LWIP_EVENT_POLL, - LWIP_EVENT_ERR -}; - -err_t lwip_tcp_event(void *arg, struct tcp_pcb *pcb, - enum lwip_event, - struct pbuf *p, - u16_t size, - err_t err); - -#endif /* LWIP_EVENT_API */ - -/* Application program's interface: */ -struct tcp_pcb * tcp_new (void); -struct tcp_pcb * tcp_new_ip_type (u8_t type); - -void tcp_arg (struct tcp_pcb *pcb, void *arg); -#if LWIP_CALLBACK_API -void tcp_recv (struct tcp_pcb *pcb, tcp_recv_fn recv); -void tcp_sent (struct tcp_pcb *pcb, tcp_sent_fn sent); -void tcp_err (struct tcp_pcb *pcb, tcp_err_fn err); -void tcp_accept (struct tcp_pcb *pcb, tcp_accept_fn accept); -#endif /* LWIP_CALLBACK_API */ -void tcp_poll (struct tcp_pcb *pcb, tcp_poll_fn poll, u8_t interval); - -#define tcp_set_flags(pcb, set_flags) do { (pcb)->flags = (tcpflags_t)((pcb)->flags | (set_flags)); } while(0) -#define tcp_clear_flags(pcb, clr_flags) do { (pcb)->flags = (tcpflags_t)((pcb)->flags & (tcpflags_t)(~(clr_flags) & TCP_ALLFLAGS)); } while(0) -#define tcp_is_flag_set(pcb, flag) (((pcb)->flags & (flag)) != 0) - -#if LWIP_TCP_TIMESTAMPS -#define tcp_mss(pcb) (((pcb)->flags & TF_TIMESTAMP) ? ((pcb)->mss - 12) : (pcb)->mss) -#else /* LWIP_TCP_TIMESTAMPS */ -/** @ingroup tcp_raw */ -#define tcp_mss(pcb) ((pcb)->mss) -#endif /* LWIP_TCP_TIMESTAMPS */ -/** @ingroup tcp_raw */ -#define tcp_sndbuf(pcb) (TCPWND16((pcb)->snd_buf)) -/** @ingroup tcp_raw */ -#define tcp_sndqueuelen(pcb) ((pcb)->snd_queuelen) -/** @ingroup tcp_raw */ -#define tcp_nagle_disable(pcb) tcp_set_flags(pcb, TF_NODELAY) -/** @ingroup tcp_raw */ -#define tcp_nagle_enable(pcb) tcp_clear_flags(pcb, TF_NODELAY) -/** @ingroup tcp_raw */ -#define tcp_nagle_disabled(pcb) tcp_is_flag_set(pcb, TF_NODELAY) - -#if TCP_LISTEN_BACKLOG -#define tcp_backlog_set(pcb, new_backlog) do { \ - LWIP_ASSERT("pcb->state == LISTEN (called for wrong pcb?)", (pcb)->state == LISTEN); \ - ((struct tcp_pcb_listen *)(pcb))->backlog = ((new_backlog) ? (new_backlog) : 1); } while(0) -void tcp_backlog_delayed(struct tcp_pcb* pcb); -void tcp_backlog_accepted(struct tcp_pcb* pcb); -#else /* TCP_LISTEN_BACKLOG */ -#define tcp_backlog_set(pcb, new_backlog) -#define tcp_backlog_delayed(pcb) -#define tcp_backlog_accepted(pcb) -#endif /* TCP_LISTEN_BACKLOG */ -#define tcp_accepted(pcb) do { LWIP_UNUSED_ARG(pcb); } while(0) /* compatibility define, not needed any more */ - -void tcp_recved (struct tcp_pcb *pcb, u16_t len); -err_t tcp_bind (struct tcp_pcb *pcb, const ip_addr_t *ipaddr, - u16_t port); -void tcp_bind_netif(struct tcp_pcb *pcb, const struct netif *netif); -err_t tcp_connect (struct tcp_pcb *pcb, const ip_addr_t *ipaddr, - u16_t port, tcp_connected_fn connected); - -struct tcp_pcb * tcp_listen_with_backlog_and_err(struct tcp_pcb *pcb, u8_t backlog, err_t *err); -struct tcp_pcb * tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog); -/** @ingroup tcp_raw */ -#define tcp_listen(pcb) tcp_listen_with_backlog(pcb, TCP_DEFAULT_LISTEN_BACKLOG) - -void tcp_abort (struct tcp_pcb *pcb); -err_t tcp_close (struct tcp_pcb *pcb); -err_t tcp_shutdown(struct tcp_pcb *pcb, int shut_rx, int shut_tx); - -err_t tcp_write (struct tcp_pcb *pcb, const void *dataptr, u16_t len, - u8_t apiflags); - -void tcp_setprio (struct tcp_pcb *pcb, u8_t prio); - -err_t tcp_output (struct tcp_pcb *pcb); - -err_t tcp_tcp_get_tcp_addrinfo(struct tcp_pcb *pcb, int local, ip_addr_t *addr, u16_t *port); - -#define tcp_dbg_get_tcp_state(pcb) ((pcb)->state) - -/* for compatibility with older implementation */ -#define tcp_new_ip6() tcp_new_ip_type(IPADDR_TYPE_V6) - -#if LWIP_TCP_PCB_NUM_EXT_ARGS -u8_t tcp_ext_arg_alloc_id(void); -void tcp_ext_arg_set_callbacks(struct tcp_pcb *pcb, uint8_t id, const struct tcp_ext_arg_callbacks * const callbacks); -void tcp_ext_arg_set(struct tcp_pcb *pcb, uint8_t id, void *arg); -void *tcp_ext_arg_get(const struct tcp_pcb *pcb, uint8_t id); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_TCP */ - -#endif /* LWIP_HDR_TCP_H */ +/** + * @file + * TCP API (to be used from TCPIP thread)\n + * See also @ref tcp_raw + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_TCP_H +#define LWIP_HDR_TCP_H + +#include "lwip/opt.h" + +#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/tcpbase.h" +#include "lwip/mem.h" +#include "lwip/pbuf.h" +#include "lwip/ip.h" +#include "lwip/icmp.h" +#include "lwip/err.h" +#include "lwip/ip6.h" +#include "lwip/ip6_addr.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct tcp_pcb; +struct tcp_pcb_listen; + +/** Function prototype for tcp accept callback functions. Called when a new + * connection can be accepted on a listening pcb. + * + * @param arg Additional argument to pass to the callback function (@see tcp_arg()) + * @param newpcb The new connection pcb + * @param err An error code if there has been an error accepting. + * Only return ERR_ABRT if you have called tcp_abort from within the + * callback function! + */ +typedef err_t (*tcp_accept_fn)(void *arg, struct tcp_pcb *newpcb, err_t err); + +/** Function prototype for tcp receive callback functions. Called when data has + * been received. + * + * @param arg Additional argument to pass to the callback function (@see tcp_arg()) + * @param tpcb The connection pcb which received data + * @param p The received data (or NULL when the connection has been closed!) + * @param err An error code if there has been an error receiving + * Only return ERR_ABRT if you have called tcp_abort from within the + * callback function! + */ +typedef err_t (*tcp_recv_fn)(void *arg, struct tcp_pcb *tpcb, + struct pbuf *p, err_t err); + +/** Function prototype for tcp sent callback functions. Called when sent data has + * been acknowledged by the remote side. Use it to free corresponding resources. + * This also means that the pcb has now space available to send new data. + * + * @param arg Additional argument to pass to the callback function (@see tcp_arg()) + * @param tpcb The connection pcb for which data has been acknowledged + * @param len The amount of bytes acknowledged + * @return ERR_OK: try to send some data by calling tcp_output + * Only return ERR_ABRT if you have called tcp_abort from within the + * callback function! + */ +typedef err_t (*tcp_sent_fn)(void *arg, struct tcp_pcb *tpcb, + u16_t len); + +/** Function prototype for tcp poll callback functions. Called periodically as + * specified by @see tcp_poll. + * + * @param arg Additional argument to pass to the callback function (@see tcp_arg()) + * @param tpcb tcp pcb + * @return ERR_OK: try to send some data by calling tcp_output + * Only return ERR_ABRT if you have called tcp_abort from within the + * callback function! + */ +typedef err_t (*tcp_poll_fn)(void *arg, struct tcp_pcb *tpcb); + +/** Function prototype for tcp error callback functions. Called when the pcb + * receives a RST or is unexpectedly closed for any other reason. + * + * @note The corresponding pcb is already freed when this callback is called! + * + * @param arg Additional argument to pass to the callback function (@see tcp_arg()) + * @param err Error code to indicate why the pcb has been closed + * ERR_ABRT: aborted through tcp_abort or by a TCP timer + * ERR_RST: the connection was reset by the remote host + */ +typedef void (*tcp_err_fn)(void *arg, err_t err); + +/** Function prototype for tcp connected callback functions. Called when a pcb + * is connected to the remote side after initiating a connection attempt by + * calling tcp_connect(). + * + * @param arg Additional argument to pass to the callback function (@see tcp_arg()) + * @param tpcb The connection pcb which is connected + * @param err An unused error code, always ERR_OK currently ;-) @todo! + * Only return ERR_ABRT if you have called tcp_abort from within the + * callback function! + * + * @note When a connection attempt fails, the error callback is currently called! + */ +typedef err_t (*tcp_connected_fn)(void *arg, struct tcp_pcb *tpcb, err_t err); + +#if LWIP_WND_SCALE +#define RCV_WND_SCALE(pcb, wnd) (((wnd) >> (pcb)->rcv_scale)) +#define SND_WND_SCALE(pcb, wnd) (((wnd) << (pcb)->snd_scale)) +#define TCPWND16(x) ((u16_t)LWIP_MIN((x), 0xFFFF)) +#define TCP_WND_MAX(pcb) ((tcpwnd_size_t)(((pcb)->flags & TF_WND_SCALE) ? TCP_WND : TCPWND16(TCP_WND))) +#else +#define RCV_WND_SCALE(pcb, wnd) (wnd) +#define SND_WND_SCALE(pcb, wnd) (wnd) +#define TCPWND16(x) (x) +#define TCP_WND_MAX(pcb) TCP_WND +#endif +/* Increments a tcpwnd_size_t and holds at max value rather than rollover */ +#define TCP_WND_INC(wnd, inc) do { \ + if ((tcpwnd_size_t)(wnd + inc) >= wnd) { \ + wnd = (tcpwnd_size_t)(wnd + inc); \ + } else { \ + wnd = (tcpwnd_size_t)-1; \ + } \ + } while(0) + +#if LWIP_TCP_SACK_OUT +/** SACK ranges to include in ACK packets. + * SACK entry is invalid if left==right. */ +struct tcp_sack_range { + /** Left edge of the SACK: the first acknowledged sequence number. */ + u32_t left; + /** Right edge of the SACK: the last acknowledged sequence number +1 (so first NOT acknowledged). */ + u32_t right; +}; +#endif /* LWIP_TCP_SACK_OUT */ + +/** Function prototype for deallocation of arguments. Called *just before* the + * pcb is freed, so don't expect to be able to do anything with this pcb! + * + * @param id ext arg id (allocated via @ref tcp_ext_arg_alloc_id) + * @param data pointer to the data (set via @ref tcp_ext_arg_set before) + */ +typedef void (*tcp_extarg_callback_pcb_destroyed_fn)(u8_t id, void *data); + +/** Function prototype to transition arguments from a listening pcb to an accepted pcb + * + * @param id ext arg id (allocated via @ref tcp_ext_arg_alloc_id) + * @param lpcb the listening pcb accepting a connection + * @param cpcb the newly allocated connection pcb + * @return ERR_OK if OK, any error if connection should be dropped + */ +typedef err_t (*tcp_extarg_callback_passive_open_fn)(u8_t id, struct tcp_pcb_listen *lpcb, struct tcp_pcb *cpcb); + +/** A table of callback functions that is invoked for ext arguments */ +struct tcp_ext_arg_callbacks { + /** @ref tcp_extarg_callback_pcb_destroyed_fn */ + tcp_extarg_callback_pcb_destroyed_fn destroy; + /** @ref tcp_extarg_callback_passive_open_fn */ + tcp_extarg_callback_passive_open_fn passive_open; +}; + +#define LWIP_TCP_PCB_NUM_EXT_ARG_ID_INVALID 0xFF + +#if LWIP_TCP_PCB_NUM_EXT_ARGS +/* This is the structure for ext args in tcp pcbs (used as array) */ +struct tcp_pcb_ext_args { + const struct tcp_ext_arg_callbacks *callbacks; + void *data; +}; +/* This is a helper define to prevent zero size arrays if disabled */ +#define TCP_PCB_EXTARGS struct tcp_pcb_ext_args ext_args[LWIP_TCP_PCB_NUM_EXT_ARGS]; +#else +#define TCP_PCB_EXTARGS +#endif + +typedef u16_t tcpflags_t; +#define TCP_ALLFLAGS 0xffffU + +/** + * members common to struct tcp_pcb and struct tcp_listen_pcb + */ +#define TCP_PCB_COMMON(type) \ + type *next; /* for the linked list */ \ + void *callback_arg; \ + TCP_PCB_EXTARGS \ + enum tcp_state state; /* TCP state */ \ + u8_t prio; \ + /* ports are in host byte order */ \ + u16_t local_port + + +/** the TCP protocol control block for listening pcbs */ +struct tcp_pcb_listen { +/** Common members of all PCB types */ + IP_PCB; +/** Protocol specific PCB members */ + TCP_PCB_COMMON(struct tcp_pcb_listen); + +#if LWIP_CALLBACK_API + /* Function to call when a listener has been connected. */ + tcp_accept_fn accept; +#endif /* LWIP_CALLBACK_API */ + +#if TCP_LISTEN_BACKLOG + u8_t backlog; + u8_t accepts_pending; +#endif /* TCP_LISTEN_BACKLOG */ +}; + + +/** the TCP protocol control block */ +struct tcp_pcb { +/** common PCB members */ + IP_PCB; +/** protocol specific PCB members */ + TCP_PCB_COMMON(struct tcp_pcb); + + /* ports are in host byte order */ + u16_t remote_port; + + tcpflags_t flags; +#define TF_ACK_DELAY 0x01U /* Delayed ACK. */ +#define TF_ACK_NOW 0x02U /* Immediate ACK. */ +#define TF_INFR 0x04U /* In fast recovery. */ +#define TF_CLOSEPEND 0x08U /* If this is set, tcp_close failed to enqueue the FIN (retried in tcp_tmr) */ +#define TF_RXCLOSED 0x10U /* rx closed by tcp_shutdown */ +#define TF_FIN 0x20U /* Connection was closed locally (FIN segment enqueued). */ +#define TF_NODELAY 0x40U /* Disable Nagle algorithm */ +#define TF_NAGLEMEMERR 0x80U /* nagle enabled, memerr, try to output to prevent delayed ACK to happen */ +#if LWIP_WND_SCALE +#define TF_WND_SCALE 0x0100U /* Window Scale option enabled */ +#endif +#if TCP_LISTEN_BACKLOG +#define TF_BACKLOGPEND 0x0200U /* If this is set, a connection pcb has increased the backlog on its listener */ +#endif +#if LWIP_TCP_TIMESTAMPS +#define TF_TIMESTAMP 0x0400U /* Timestamp option enabled */ +#endif +#define TF_RTO 0x0800U /* RTO timer has fired, in-flight data moved to unsent and being retransmitted */ +#if LWIP_TCP_SACK_OUT +#define TF_SACK 0x1000U /* Selective ACKs enabled */ +#endif + + /* the rest of the fields are in host byte order + as we have to do some math with them */ + + /* Timers */ + u8_t polltmr, pollinterval; + u8_t last_timer; + u32_t tmr; + + /* receiver variables */ + u32_t rcv_nxt; /* next seqno expected */ + tcpwnd_size_t rcv_wnd; /* receiver window available */ + tcpwnd_size_t rcv_ann_wnd; /* receiver window to announce */ + u32_t rcv_ann_right_edge; /* announced right edge of window */ + +#if LWIP_TCP_SACK_OUT + /* SACK ranges to include in ACK packets (entry is invalid if left==right) */ + struct tcp_sack_range rcv_sacks[LWIP_TCP_MAX_SACK_NUM]; +#define LWIP_TCP_SACK_VALID(pcb, idx) ((pcb)->rcv_sacks[idx].left != (pcb)->rcv_sacks[idx].right) +#endif /* LWIP_TCP_SACK_OUT */ + + /* Retransmission timer. */ + s16_t rtime; + + u16_t mss; /* maximum segment size */ + + /* RTT (round trip time) estimation variables */ + u32_t rttest; /* RTT estimate in 500ms ticks */ + u32_t rtseq; /* sequence number being timed */ + s16_t sa, sv; /* @see "Congestion Avoidance and Control" by Van Jacobson and Karels */ + + s16_t rto; /* retransmission time-out (in ticks of TCP_SLOW_INTERVAL) */ + u8_t nrtx; /* number of retransmissions */ + + /* fast retransmit/recovery */ + u8_t dupacks; + u32_t lastack; /* Highest acknowledged seqno. */ + + /* congestion avoidance/control variables */ + tcpwnd_size_t cwnd; + tcpwnd_size_t ssthresh; + + /* first byte following last rto byte */ + u32_t rto_end; + + /* sender variables */ + u32_t snd_nxt; /* next new seqno to be sent */ + u32_t snd_wl1, snd_wl2; /* Sequence and acknowledgement numbers of last + window update. */ + u32_t snd_lbb; /* Sequence number of next byte to be buffered. */ + tcpwnd_size_t snd_wnd; /* sender window */ + tcpwnd_size_t snd_wnd_max; /* the maximum sender window announced by the remote host */ + + tcpwnd_size_t snd_buf; /* Available buffer space for sending (in bytes). */ +#define TCP_SNDQUEUELEN_OVERFLOW (0xffffU-3) + u16_t snd_queuelen; /* Number of pbufs currently in the send buffer. */ + +#if TCP_OVERSIZE + /* Extra bytes available at the end of the last pbuf in unsent. */ + u16_t unsent_oversize; +#endif /* TCP_OVERSIZE */ + + tcpwnd_size_t bytes_acked; + + /* These are ordered by sequence number: */ + struct tcp_seg *unsent; /* Unsent (queued) segments. */ + struct tcp_seg *unacked; /* Sent but unacknowledged segments. */ +#if TCP_QUEUE_OOSEQ + struct tcp_seg *ooseq; /* Received out of sequence segments. */ +#endif /* TCP_QUEUE_OOSEQ */ + + struct pbuf *refused_data; /* Data previously received but not yet taken by upper layer */ + +#if LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG + struct tcp_pcb_listen* listener; +#endif /* LWIP_CALLBACK_API || TCP_LISTEN_BACKLOG */ + +#if LWIP_CALLBACK_API + /* Function to be called when more send buffer space is available. */ + tcp_sent_fn sent; + /* Function to be called when (in-sequence) data has arrived. */ + tcp_recv_fn recv; + /* Function to be called when a connection has been set up. */ + tcp_connected_fn connected; + /* Function which is called periodically. */ + tcp_poll_fn poll; + /* Function to be called whenever a fatal error occurs. */ + tcp_err_fn errf; +#endif /* LWIP_CALLBACK_API */ + +#if LWIP_TCP_TIMESTAMPS + u32_t ts_lastacksent; + u32_t ts_recent; +#endif /* LWIP_TCP_TIMESTAMPS */ + + /* idle time before KEEPALIVE is sent */ + u32_t keep_idle; +#if LWIP_TCP_KEEPALIVE + u32_t keep_intvl; + u32_t keep_cnt; +#endif /* LWIP_TCP_KEEPALIVE */ + + /* Persist timer counter */ + u8_t persist_cnt; + /* Persist timer back-off */ + u8_t persist_backoff; + /* Number of persist probes */ + u8_t persist_probe; + + /* KEEPALIVE counter */ + u8_t keep_cnt_sent; + +#if LWIP_WND_SCALE + u8_t snd_scale; + u8_t rcv_scale; +#endif +}; + +#if LWIP_EVENT_API + +enum lwip_event { + LWIP_EVENT_ACCEPT, + LWIP_EVENT_SENT, + LWIP_EVENT_RECV, + LWIP_EVENT_CONNECTED, + LWIP_EVENT_POLL, + LWIP_EVENT_ERR +}; + +err_t lwip_tcp_event(void *arg, struct tcp_pcb *pcb, + enum lwip_event, + struct pbuf *p, + u16_t size, + err_t err); + +#endif /* LWIP_EVENT_API */ + +/* Application program's interface: */ +struct tcp_pcb * tcp_new (void); +struct tcp_pcb * tcp_new_ip_type (u8_t type); + +void tcp_arg (struct tcp_pcb *pcb, void *arg); +#if LWIP_CALLBACK_API +void tcp_recv (struct tcp_pcb *pcb, tcp_recv_fn recv); +void tcp_sent (struct tcp_pcb *pcb, tcp_sent_fn sent); +void tcp_err (struct tcp_pcb *pcb, tcp_err_fn err); +void tcp_accept (struct tcp_pcb *pcb, tcp_accept_fn accept); +#endif /* LWIP_CALLBACK_API */ +void tcp_poll (struct tcp_pcb *pcb, tcp_poll_fn poll, u8_t interval); + +#define tcp_set_flags(pcb, set_flags) do { (pcb)->flags = (tcpflags_t)((pcb)->flags | (set_flags)); } while(0) +#define tcp_clear_flags(pcb, clr_flags) do { (pcb)->flags = (tcpflags_t)((pcb)->flags & (tcpflags_t)(~(clr_flags) & TCP_ALLFLAGS)); } while(0) +#define tcp_is_flag_set(pcb, flag) (((pcb)->flags & (flag)) != 0) + +#if LWIP_TCP_TIMESTAMPS +#define tcp_mss(pcb) (((pcb)->flags & TF_TIMESTAMP) ? ((pcb)->mss - 12) : (pcb)->mss) +#else /* LWIP_TCP_TIMESTAMPS */ +/** @ingroup tcp_raw */ +#define tcp_mss(pcb) ((pcb)->mss) +#endif /* LWIP_TCP_TIMESTAMPS */ +/** @ingroup tcp_raw */ +#define tcp_sndbuf(pcb) (TCPWND16((pcb)->snd_buf)) +/** @ingroup tcp_raw */ +#define tcp_sndqueuelen(pcb) ((pcb)->snd_queuelen) +/** @ingroup tcp_raw */ +#define tcp_nagle_disable(pcb) tcp_set_flags(pcb, TF_NODELAY) +/** @ingroup tcp_raw */ +#define tcp_nagle_enable(pcb) tcp_clear_flags(pcb, TF_NODELAY) +/** @ingroup tcp_raw */ +#define tcp_nagle_disabled(pcb) tcp_is_flag_set(pcb, TF_NODELAY) + +#if TCP_LISTEN_BACKLOG +#define tcp_backlog_set(pcb, new_backlog) do { \ + LWIP_ASSERT("pcb->state == LISTEN (called for wrong pcb?)", (pcb)->state == LISTEN); \ + ((struct tcp_pcb_listen *)(pcb))->backlog = ((new_backlog) ? (new_backlog) : 1); } while(0) +void tcp_backlog_delayed(struct tcp_pcb* pcb); +void tcp_backlog_accepted(struct tcp_pcb* pcb); +#else /* TCP_LISTEN_BACKLOG */ +#define tcp_backlog_set(pcb, new_backlog) +#define tcp_backlog_delayed(pcb) +#define tcp_backlog_accepted(pcb) +#endif /* TCP_LISTEN_BACKLOG */ +#define tcp_accepted(pcb) do { LWIP_UNUSED_ARG(pcb); } while(0) /* compatibility define, not needed any more */ + +void tcp_recved (struct tcp_pcb *pcb, u16_t len); +err_t tcp_bind (struct tcp_pcb *pcb, const ip_addr_t *ipaddr, + u16_t port); +void tcp_bind_netif(struct tcp_pcb *pcb, const struct netif *netif); +err_t tcp_connect (struct tcp_pcb *pcb, const ip_addr_t *ipaddr, + u16_t port, tcp_connected_fn connected); + +struct tcp_pcb * tcp_listen_with_backlog_and_err(struct tcp_pcb *pcb, u8_t backlog, err_t *err); +struct tcp_pcb * tcp_listen_with_backlog(struct tcp_pcb *pcb, u8_t backlog); +/** @ingroup tcp_raw */ +#define tcp_listen(pcb) tcp_listen_with_backlog(pcb, TCP_DEFAULT_LISTEN_BACKLOG) + +void tcp_abort (struct tcp_pcb *pcb); +err_t tcp_close (struct tcp_pcb *pcb); +err_t tcp_shutdown(struct tcp_pcb *pcb, int shut_rx, int shut_tx); + +err_t tcp_write (struct tcp_pcb *pcb, const void *dataptr, u16_t len, + u8_t apiflags); + +void tcp_setprio (struct tcp_pcb *pcb, u8_t prio); + +err_t tcp_output (struct tcp_pcb *pcb); + +err_t tcp_tcp_get_tcp_addrinfo(struct tcp_pcb *pcb, int local, ip_addr_t *addr, u16_t *port); + +#define tcp_dbg_get_tcp_state(pcb) ((pcb)->state) + +/* for compatibility with older implementation */ +#define tcp_new_ip6() tcp_new_ip_type(IPADDR_TYPE_V6) + +#if LWIP_TCP_PCB_NUM_EXT_ARGS +u8_t tcp_ext_arg_alloc_id(void); +void tcp_ext_arg_set_callbacks(struct tcp_pcb *pcb, uint8_t id, const struct tcp_ext_arg_callbacks * const callbacks); +void tcp_ext_arg_set(struct tcp_pcb *pcb, uint8_t id, void *arg); +void *tcp_ext_arg_get(const struct tcp_pcb *pcb, uint8_t id); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_TCP */ + +#endif /* LWIP_HDR_TCP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpbase.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpbase.h index 6614b807..00230746 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpbase.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpbase.h @@ -1,88 +1,88 @@ -/** - * @file - * Base TCP API definitions shared by TCP and ALTCP\n - * See also @ref tcp_raw - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_TCPBASE_H -#define LWIP_HDR_TCPBASE_H - -#include "lwip/opt.h" - -#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ - -#ifdef __cplusplus -extern "C" { -#endif - - -#if LWIP_WND_SCALE -typedef u32_t tcpwnd_size_t; -#else -typedef u16_t tcpwnd_size_t; -#endif - -enum tcp_state { - CLOSED = 0, - LISTEN = 1, - SYN_SENT = 2, - SYN_RCVD = 3, - ESTABLISHED = 4, - FIN_WAIT_1 = 5, - FIN_WAIT_2 = 6, - CLOSE_WAIT = 7, - CLOSING = 8, - LAST_ACK = 9, - TIME_WAIT = 10 -}; -/* ATTENTION: this depends on state number ordering! */ -#define TCP_STATE_IS_CLOSING(state) ((state) >= FIN_WAIT_1) - -/* Flags for "apiflags" parameter in tcp_write */ -#define TCP_WRITE_FLAG_COPY 0x01 -#define TCP_WRITE_FLAG_MORE 0x02 - -#define TCP_PRIO_MIN 1 -#define TCP_PRIO_NORMAL 64 -#define TCP_PRIO_MAX 127 - -const char* tcp_debug_state_str(enum tcp_state s); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_TCP */ - -#endif /* LWIP_HDR_TCPBASE_H */ +/** + * @file + * Base TCP API definitions shared by TCP and ALTCP\n + * See also @ref tcp_raw + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_TCPBASE_H +#define LWIP_HDR_TCPBASE_H + +#include "lwip/opt.h" + +#if LWIP_TCP /* don't build if not configured for use in lwipopts.h */ + +#ifdef __cplusplus +extern "C" { +#endif + + +#if LWIP_WND_SCALE +typedef u32_t tcpwnd_size_t; +#else +typedef u16_t tcpwnd_size_t; +#endif + +enum tcp_state { + CLOSED = 0, + LISTEN = 1, + SYN_SENT = 2, + SYN_RCVD = 3, + ESTABLISHED = 4, + FIN_WAIT_1 = 5, + FIN_WAIT_2 = 6, + CLOSE_WAIT = 7, + CLOSING = 8, + LAST_ACK = 9, + TIME_WAIT = 10 +}; +/* ATTENTION: this depends on state number ordering! */ +#define TCP_STATE_IS_CLOSING(state) ((state) >= FIN_WAIT_1) + +/* Flags for "apiflags" parameter in tcp_write */ +#define TCP_WRITE_FLAG_COPY 0x01 +#define TCP_WRITE_FLAG_MORE 0x02 + +#define TCP_PRIO_MIN 1 +#define TCP_PRIO_NORMAL 64 +#define TCP_PRIO_MAX 127 + +const char* tcp_debug_state_str(enum tcp_state s); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_TCP */ + +#endif /* LWIP_HDR_TCPBASE_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpip.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpip.h index 271cad5f..5bd8b920 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpip.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/tcpip.h @@ -1,115 +1,115 @@ -/** - * @file - * Functions to sync with TCPIP thread - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_TCPIP_H -#define LWIP_HDR_TCPIP_H - -#include "lwip/opt.h" - -#if !NO_SYS /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/err.h" -#include "lwip/timeouts.h" -#include "lwip/netif.h" - -#include "sys_arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_TCPIP_CORE_LOCKING -/** The global semaphore to lock the stack. */ -extern sys_mutex_t lock_tcpip_core; -#if !defined LOCK_TCPIP_CORE || defined __DOXYGEN__ -/** Lock lwIP core mutex (needs @ref LWIP_TCPIP_CORE_LOCKING 1) */ -#define LOCK_TCPIP_CORE() sys_mutex_lock(&lock_tcpip_core) -/** Unlock lwIP core mutex (needs @ref LWIP_TCPIP_CORE_LOCKING 1) */ -#define UNLOCK_TCPIP_CORE() sys_mutex_unlock(&lock_tcpip_core) -#endif /* LOCK_TCPIP_CORE */ -#else /* LWIP_TCPIP_CORE_LOCKING */ -#define LOCK_TCPIP_CORE() -#define UNLOCK_TCPIP_CORE() -#endif /* LWIP_TCPIP_CORE_LOCKING */ - -struct pbuf; -struct netif; - -/** Function prototype for the init_done function passed to tcpip_init */ -typedef void (*tcpip_init_done_fn)(void *arg); -/** Function prototype for functions passed to tcpip_callback() */ -typedef void (*tcpip_callback_fn)(void *ctx); - -/* Forward declarations */ -struct tcpip_callback_msg; - -void tcpip_init(tcpip_init_done_fn tcpip_init_done, void *arg); - -err_t tcpip_inpkt(struct pbuf *p, struct netif *inp, netif_input_fn input_fn); -err_t tcpip_input(struct pbuf *p, struct netif *inp); - -err_t tcpip_try_callback(tcpip_callback_fn function, void *ctx); -err_t tcpip_callback(tcpip_callback_fn function, void *ctx); -/** @ingroup lwip_os - * @deprecated use tcpip_try_callback() or tcpip_callback() instead - */ -#define tcpip_callback_with_block(function, ctx, block) ((block != 0)? tcpip_callback(function, ctx) : tcpip_try_callback(function, ctx)) - -struct tcpip_callback_msg* tcpip_callbackmsg_new(tcpip_callback_fn function, void *ctx); -void tcpip_callbackmsg_delete(struct tcpip_callback_msg* msg); -err_t tcpip_callbackmsg_trycallback(struct tcpip_callback_msg* msg); -err_t tcpip_callbackmsg_trycallback_fromisr(struct tcpip_callback_msg* msg); - -/* free pbufs or heap memory from another context without blocking */ -err_t pbuf_free_callback(struct pbuf *p); -err_t mem_free_callback(void *m); - -#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS -err_t tcpip_timeout(u32_t msecs, sys_timeout_handler h, void *arg); -err_t tcpip_untimeout(sys_timeout_handler h, void *arg); -#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ - -#ifdef TCPIP_THREAD_TEST -int tcpip_thread_poll_one(void); -#endif - -#ifdef __cplusplus -} -#endif - -#endif /* !NO_SYS */ - -#endif /* LWIP_HDR_TCPIP_H */ +/** + * @file + * Functions to sync with TCPIP thread + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_TCPIP_H +#define LWIP_HDR_TCPIP_H + +#include "lwip/opt.h" + +#if !NO_SYS /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/err.h" +#include "lwip/timeouts.h" +#include "lwip/netif.h" + +#include "sys_arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_TCPIP_CORE_LOCKING +/** The global semaphore to lock the stack. */ +extern sys_mutex_t lock_tcpip_core; +#if !defined LOCK_TCPIP_CORE || defined __DOXYGEN__ +/** Lock lwIP core mutex (needs @ref LWIP_TCPIP_CORE_LOCKING 1) */ +#define LOCK_TCPIP_CORE() sys_mutex_lock(&lock_tcpip_core) +/** Unlock lwIP core mutex (needs @ref LWIP_TCPIP_CORE_LOCKING 1) */ +#define UNLOCK_TCPIP_CORE() sys_mutex_unlock(&lock_tcpip_core) +#endif /* LOCK_TCPIP_CORE */ +#else /* LWIP_TCPIP_CORE_LOCKING */ +#define LOCK_TCPIP_CORE() +#define UNLOCK_TCPIP_CORE() +#endif /* LWIP_TCPIP_CORE_LOCKING */ + +struct pbuf; +struct netif; + +/** Function prototype for the init_done function passed to tcpip_init */ +typedef void (*tcpip_init_done_fn)(void *arg); +/** Function prototype for functions passed to tcpip_callback() */ +typedef void (*tcpip_callback_fn)(void *ctx); + +/* Forward declarations */ +struct tcpip_callback_msg; + +void tcpip_init(tcpip_init_done_fn tcpip_init_done, void *arg); + +err_t tcpip_inpkt(struct pbuf *p, struct netif *inp, netif_input_fn input_fn); +err_t tcpip_input(struct pbuf *p, struct netif *inp); + +err_t tcpip_try_callback(tcpip_callback_fn function, void *ctx); +err_t tcpip_callback(tcpip_callback_fn function, void *ctx); +/** @ingroup lwip_os + * @deprecated use tcpip_try_callback() or tcpip_callback() instead + */ +#define tcpip_callback_with_block(function, ctx, block) ((block != 0)? tcpip_callback(function, ctx) : tcpip_try_callback(function, ctx)) + +struct tcpip_callback_msg* tcpip_callbackmsg_new(tcpip_callback_fn function, void *ctx); +void tcpip_callbackmsg_delete(struct tcpip_callback_msg* msg); +err_t tcpip_callbackmsg_trycallback(struct tcpip_callback_msg* msg); +err_t tcpip_callbackmsg_trycallback_fromisr(struct tcpip_callback_msg* msg); + +/* free pbufs or heap memory from another context without blocking */ +err_t pbuf_free_callback(struct pbuf *p); +err_t mem_free_callback(void *m); + +#if LWIP_TCPIP_TIMEOUT && LWIP_TIMERS +err_t tcpip_timeout(u32_t msecs, sys_timeout_handler h, void *arg); +err_t tcpip_untimeout(sys_timeout_handler h, void *arg); +#endif /* LWIP_TCPIP_TIMEOUT && LWIP_TIMERS */ + +#ifdef TCPIP_THREAD_TEST +int tcpip_thread_poll_one(void); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* !NO_SYS */ + +#endif /* LWIP_HDR_TCPIP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/timeouts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/timeouts.h index 3ab3c0ea..b601f9eb 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/timeouts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/timeouts.h @@ -1,128 +1,128 @@ -/** - * @file - * Timer implementations - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_TIMEOUTS_H -#define LWIP_HDR_TIMEOUTS_H - -#include "lwip/opt.h" -#include "lwip/err.h" -#if !NO_SYS -#include "lwip/sys.h" -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -#ifndef LWIP_DEBUG_TIMERNAMES -#ifdef LWIP_DEBUG -#define LWIP_DEBUG_TIMERNAMES SYS_DEBUG -#else /* LWIP_DEBUG */ -#define LWIP_DEBUG_TIMERNAMES 0 -#endif /* LWIP_DEBUG*/ -#endif - -/** Returned by sys_timeouts_sleeptime() to indicate there is no timer, so we - * can sleep forever. - */ -#define SYS_TIMEOUTS_SLEEPTIME_INFINITE 0xFFFFFFFF - -/** Function prototype for a stack-internal timer function that has to be - * called at a defined interval */ -typedef void (* lwip_cyclic_timer_handler)(void); - -/** This struct contains information about a stack-internal timer function - that has to be called at a defined interval */ -struct lwip_cyclic_timer { - u32_t interval_ms; - lwip_cyclic_timer_handler handler; -#if LWIP_DEBUG_TIMERNAMES - const char* handler_name; -#endif /* LWIP_DEBUG_TIMERNAMES */ -}; - -/** This array contains all stack-internal cyclic timers. To get the number of - * timers, use lwip_num_cyclic_timers */ -extern const struct lwip_cyclic_timer lwip_cyclic_timers[]; -/** Array size of lwip_cyclic_timers[] */ -extern const int lwip_num_cyclic_timers; - -#if LWIP_TIMERS - -/** Function prototype for a timeout callback function. Register such a function - * using sys_timeout(). - * - * @param arg Additional argument to pass to the function - set up by sys_timeout() - */ -typedef void (* sys_timeout_handler)(void *arg); - -struct sys_timeo { - struct sys_timeo *next; - u32_t time; - sys_timeout_handler h; - void *arg; -#if LWIP_DEBUG_TIMERNAMES - const char* handler_name; -#endif /* LWIP_DEBUG_TIMERNAMES */ -}; - -void sys_timeouts_init(void); - -#if LWIP_DEBUG_TIMERNAMES -void sys_timeout_debug(u32_t msecs, sys_timeout_handler handler, void *arg, const char* handler_name); -#define sys_timeout(msecs, handler, arg) sys_timeout_debug(msecs, handler, arg, #handler) -#else /* LWIP_DEBUG_TIMERNAMES */ -void sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg); -#endif /* LWIP_DEBUG_TIMERNAMES */ - -void sys_untimeout(sys_timeout_handler handler, void *arg); -void sys_restart_timeouts(void); -void sys_check_timeouts(void); -u32_t sys_timeouts_sleeptime(void); - -#if LWIP_TESTMODE -struct sys_timeo** sys_timeouts_get_next_timeout(void); -void lwip_cyclic_timer(void *arg); -#endif - -#endif /* LWIP_TIMERS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_TIMEOUTS_H */ +/** + * @file + * Timer implementations + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_TIMEOUTS_H +#define LWIP_HDR_TIMEOUTS_H + +#include "lwip/opt.h" +#include "lwip/err.h" +#if !NO_SYS +#include "lwip/sys.h" +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef LWIP_DEBUG_TIMERNAMES +#ifdef LWIP_DEBUG +#define LWIP_DEBUG_TIMERNAMES SYS_DEBUG +#else /* LWIP_DEBUG */ +#define LWIP_DEBUG_TIMERNAMES 0 +#endif /* LWIP_DEBUG*/ +#endif + +/** Returned by sys_timeouts_sleeptime() to indicate there is no timer, so we + * can sleep forever. + */ +#define SYS_TIMEOUTS_SLEEPTIME_INFINITE 0xFFFFFFFF + +/** Function prototype for a stack-internal timer function that has to be + * called at a defined interval */ +typedef void (* lwip_cyclic_timer_handler)(void); + +/** This struct contains information about a stack-internal timer function + that has to be called at a defined interval */ +struct lwip_cyclic_timer { + u32_t interval_ms; + lwip_cyclic_timer_handler handler; +#if LWIP_DEBUG_TIMERNAMES + const char* handler_name; +#endif /* LWIP_DEBUG_TIMERNAMES */ +}; + +/** This array contains all stack-internal cyclic timers. To get the number of + * timers, use lwip_num_cyclic_timers */ +extern const struct lwip_cyclic_timer lwip_cyclic_timers[]; +/** Array size of lwip_cyclic_timers[] */ +extern const int lwip_num_cyclic_timers; + +#if LWIP_TIMERS + +/** Function prototype for a timeout callback function. Register such a function + * using sys_timeout(). + * + * @param arg Additional argument to pass to the function - set up by sys_timeout() + */ +typedef void (* sys_timeout_handler)(void *arg); + +struct sys_timeo { + struct sys_timeo *next; + u32_t time; + sys_timeout_handler h; + void *arg; +#if LWIP_DEBUG_TIMERNAMES + const char* handler_name; +#endif /* LWIP_DEBUG_TIMERNAMES */ +}; + +void sys_timeouts_init(void); + +#if LWIP_DEBUG_TIMERNAMES +void sys_timeout_debug(u32_t msecs, sys_timeout_handler handler, void *arg, const char* handler_name); +#define sys_timeout(msecs, handler, arg) sys_timeout_debug(msecs, handler, arg, #handler) +#else /* LWIP_DEBUG_TIMERNAMES */ +void sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg); +#endif /* LWIP_DEBUG_TIMERNAMES */ + +void sys_untimeout(sys_timeout_handler handler, void *arg); +void sys_restart_timeouts(void); +void sys_check_timeouts(void); +u32_t sys_timeouts_sleeptime(void); + +#if LWIP_TESTMODE +struct sys_timeo** sys_timeouts_get_next_timeout(void); +void lwip_cyclic_timer(void *arg); +#endif + +#endif /* LWIP_TIMERS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_TIMEOUTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/udp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/udp.h index 3794af43..b1c78e58 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/udp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/lwip/udp.h @@ -1,195 +1,195 @@ -/** - * @file - * UDP API (to be used from TCPIP thread)\n - * See also @ref udp_raw - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_UDP_H -#define LWIP_HDR_UDP_H - -#include "lwip/opt.h" - -#if LWIP_UDP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/netif.h" -#include "lwip/ip_addr.h" -#include "lwip/ip.h" -#include "lwip/ip6_addr.h" -#include "lwip/prot/udp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define UDP_FLAGS_NOCHKSUM 0x01U -#define UDP_FLAGS_UDPLITE 0x02U -#define UDP_FLAGS_CONNECTED 0x04U -#define UDP_FLAGS_MULTICAST_LOOP 0x08U - -struct udp_pcb; - -/** Function prototype for udp pcb receive callback functions - * addr and port are in same byte order as in the pcb - * The callback is responsible for freeing the pbuf - * if it's not used any more. - * - * ATTENTION: Be aware that 'addr' might point into the pbuf 'p' so freeing this pbuf - * can make 'addr' invalid, too. - * - * @param arg user supplied argument (udp_pcb.recv_arg) - * @param pcb the udp_pcb which received data - * @param p the packet buffer that was received - * @param addr the remote IP address from which the packet was received - * @param port the remote port from which the packet was received - */ -typedef void (*udp_recv_fn)(void *arg, struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *addr, u16_t port); - -/** the UDP protocol control block */ -struct udp_pcb { -/** Common members of all PCB types */ - IP_PCB; - -/* Protocol specific PCB members */ - - struct udp_pcb *next; - - u8_t flags; - /** ports are in host byte order */ - u16_t local_port, remote_port; - -#if LWIP_MULTICAST_TX_OPTIONS -#if LWIP_IPV4 - /** outgoing network interface for multicast packets, by IPv4 address (if not 'any') */ - ip4_addr_t mcast_ip4; -#endif /* LWIP_IPV4 */ - /** outgoing network interface for multicast packets, by interface index (if nonzero) */ - u8_t mcast_ifindex; - /** TTL for outgoing multicast packets */ - u8_t mcast_ttl; -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - -#if LWIP_UDPLITE - /** used for UDP_LITE only */ - u16_t chksum_len_rx, chksum_len_tx; -#endif /* LWIP_UDPLITE */ - - /** receive callback function */ - udp_recv_fn recv; - /** user-supplied argument for the recv callback */ - void *recv_arg; -}; -/* udp_pcbs export for external reference (e.g. SNMP agent) */ -extern struct udp_pcb *udp_pcbs; - -/* The following functions is the application layer interface to the - UDP code. */ -struct udp_pcb * udp_new (void); -struct udp_pcb * udp_new_ip_type(u8_t type); -void udp_remove (struct udp_pcb *pcb); -err_t udp_bind (struct udp_pcb *pcb, const ip_addr_t *ipaddr, - u16_t port); -void udp_bind_netif (struct udp_pcb *pcb, const struct netif* netif); -err_t udp_connect (struct udp_pcb *pcb, const ip_addr_t *ipaddr, - u16_t port); -void udp_disconnect (struct udp_pcb *pcb); -void udp_recv (struct udp_pcb *pcb, udp_recv_fn recv, - void *recv_arg); -err_t udp_sendto_if (struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port, - struct netif *netif); -err_t udp_sendto_if_src(struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port, - struct netif *netif, const ip_addr_t *src_ip); -err_t udp_sendto (struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port); -err_t udp_send (struct udp_pcb *pcb, struct pbuf *p); - -#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP -err_t udp_sendto_if_chksum(struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port, - struct netif *netif, u8_t have_chksum, - u16_t chksum); -err_t udp_sendto_chksum(struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port, - u8_t have_chksum, u16_t chksum); -err_t udp_send_chksum(struct udp_pcb *pcb, struct pbuf *p, - u8_t have_chksum, u16_t chksum); -err_t udp_sendto_if_src_chksum(struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif, - u8_t have_chksum, u16_t chksum, const ip_addr_t *src_ip); -#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ - -#define udp_flags(pcb) ((pcb)->flags) -#define udp_setflags(pcb, f) ((pcb)->flags = (f)) - -#define udp_set_flags(pcb, set_flags) do { (pcb)->flags = (u8_t)((pcb)->flags | (set_flags)); } while(0) -#define udp_clear_flags(pcb, clr_flags) do { (pcb)->flags = (u8_t)((pcb)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) -#define udp_is_flag_set(pcb, flag) (((pcb)->flags & (flag)) != 0) - -/* The following functions are the lower layer interface to UDP. */ -void udp_input (struct pbuf *p, struct netif *inp); - -void udp_init (void); - -/* for compatibility with older implementation */ -#define udp_new_ip6() udp_new_ip_type(IPADDR_TYPE_V6) - -#if LWIP_MULTICAST_TX_OPTIONS -#if LWIP_IPV4 -#define udp_set_multicast_netif_addr(pcb, ip4addr) ip4_addr_copy((pcb)->mcast_ip4, *(ip4addr)) -#define udp_get_multicast_netif_addr(pcb) (&(pcb)->mcast_ip4) -#endif /* LWIP_IPV4 */ -#define udp_set_multicast_netif_index(pcb, idx) ((pcb)->mcast_ifindex = (idx)) -#define udp_get_multicast_netif_index(pcb) ((pcb)->mcast_ifindex) -#define udp_set_multicast_ttl(pcb, value) ((pcb)->mcast_ttl = (value)) -#define udp_get_multicast_ttl(pcb) ((pcb)->mcast_ttl) -#endif /* LWIP_MULTICAST_TX_OPTIONS */ - -#if UDP_DEBUG -void udp_debug_print(struct udp_hdr *udphdr); -#else -#define udp_debug_print(udphdr) -#endif - -void udp_netif_ip_addr_changed(const ip_addr_t* old_addr, const ip_addr_t* new_addr); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_UDP */ - -#endif /* LWIP_HDR_UDP_H */ +/** + * @file + * UDP API (to be used from TCPIP thread)\n + * See also @ref udp_raw + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_UDP_H +#define LWIP_HDR_UDP_H + +#include "lwip/opt.h" + +#if LWIP_UDP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/netif.h" +#include "lwip/ip_addr.h" +#include "lwip/ip.h" +#include "lwip/ip6_addr.h" +#include "lwip/prot/udp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define UDP_FLAGS_NOCHKSUM 0x01U +#define UDP_FLAGS_UDPLITE 0x02U +#define UDP_FLAGS_CONNECTED 0x04U +#define UDP_FLAGS_MULTICAST_LOOP 0x08U + +struct udp_pcb; + +/** Function prototype for udp pcb receive callback functions + * addr and port are in same byte order as in the pcb + * The callback is responsible for freeing the pbuf + * if it's not used any more. + * + * ATTENTION: Be aware that 'addr' might point into the pbuf 'p' so freeing this pbuf + * can make 'addr' invalid, too. + * + * @param arg user supplied argument (udp_pcb.recv_arg) + * @param pcb the udp_pcb which received data + * @param p the packet buffer that was received + * @param addr the remote IP address from which the packet was received + * @param port the remote port from which the packet was received + */ +typedef void (*udp_recv_fn)(void *arg, struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *addr, u16_t port); + +/** the UDP protocol control block */ +struct udp_pcb { +/** Common members of all PCB types */ + IP_PCB; + +/* Protocol specific PCB members */ + + struct udp_pcb *next; + + u8_t flags; + /** ports are in host byte order */ + u16_t local_port, remote_port; + +#if LWIP_MULTICAST_TX_OPTIONS +#if LWIP_IPV4 + /** outgoing network interface for multicast packets, by IPv4 address (if not 'any') */ + ip4_addr_t mcast_ip4; +#endif /* LWIP_IPV4 */ + /** outgoing network interface for multicast packets, by interface index (if nonzero) */ + u8_t mcast_ifindex; + /** TTL for outgoing multicast packets */ + u8_t mcast_ttl; +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + +#if LWIP_UDPLITE + /** used for UDP_LITE only */ + u16_t chksum_len_rx, chksum_len_tx; +#endif /* LWIP_UDPLITE */ + + /** receive callback function */ + udp_recv_fn recv; + /** user-supplied argument for the recv callback */ + void *recv_arg; +}; +/* udp_pcbs export for external reference (e.g. SNMP agent) */ +extern struct udp_pcb *udp_pcbs; + +/* The following functions is the application layer interface to the + UDP code. */ +struct udp_pcb * udp_new (void); +struct udp_pcb * udp_new_ip_type(u8_t type); +void udp_remove (struct udp_pcb *pcb); +err_t udp_bind (struct udp_pcb *pcb, const ip_addr_t *ipaddr, + u16_t port); +void udp_bind_netif (struct udp_pcb *pcb, const struct netif* netif); +err_t udp_connect (struct udp_pcb *pcb, const ip_addr_t *ipaddr, + u16_t port); +void udp_disconnect (struct udp_pcb *pcb); +void udp_recv (struct udp_pcb *pcb, udp_recv_fn recv, + void *recv_arg); +err_t udp_sendto_if (struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port, + struct netif *netif); +err_t udp_sendto_if_src(struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port, + struct netif *netif, const ip_addr_t *src_ip); +err_t udp_sendto (struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port); +err_t udp_send (struct udp_pcb *pcb, struct pbuf *p); + +#if LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP +err_t udp_sendto_if_chksum(struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port, + struct netif *netif, u8_t have_chksum, + u16_t chksum); +err_t udp_sendto_chksum(struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port, + u8_t have_chksum, u16_t chksum); +err_t udp_send_chksum(struct udp_pcb *pcb, struct pbuf *p, + u8_t have_chksum, u16_t chksum); +err_t udp_sendto_if_src_chksum(struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *dst_ip, u16_t dst_port, struct netif *netif, + u8_t have_chksum, u16_t chksum, const ip_addr_t *src_ip); +#endif /* LWIP_CHECKSUM_ON_COPY && CHECKSUM_GEN_UDP */ + +#define udp_flags(pcb) ((pcb)->flags) +#define udp_setflags(pcb, f) ((pcb)->flags = (f)) + +#define udp_set_flags(pcb, set_flags) do { (pcb)->flags = (u8_t)((pcb)->flags | (set_flags)); } while(0) +#define udp_clear_flags(pcb, clr_flags) do { (pcb)->flags = (u8_t)((pcb)->flags & (u8_t)(~(clr_flags) & 0xff)); } while(0) +#define udp_is_flag_set(pcb, flag) (((pcb)->flags & (flag)) != 0) + +/* The following functions are the lower layer interface to UDP. */ +void udp_input (struct pbuf *p, struct netif *inp); + +void udp_init (void); + +/* for compatibility with older implementation */ +#define udp_new_ip6() udp_new_ip_type(IPADDR_TYPE_V6) + +#if LWIP_MULTICAST_TX_OPTIONS +#if LWIP_IPV4 +#define udp_set_multicast_netif_addr(pcb, ip4addr) ip4_addr_copy((pcb)->mcast_ip4, *(ip4addr)) +#define udp_get_multicast_netif_addr(pcb) (&(pcb)->mcast_ip4) +#endif /* LWIP_IPV4 */ +#define udp_set_multicast_netif_index(pcb, idx) ((pcb)->mcast_ifindex = (idx)) +#define udp_get_multicast_netif_index(pcb) ((pcb)->mcast_ifindex) +#define udp_set_multicast_ttl(pcb, value) ((pcb)->mcast_ttl = (value)) +#define udp_get_multicast_ttl(pcb) ((pcb)->mcast_ttl) +#endif /* LWIP_MULTICAST_TX_OPTIONS */ + +#if UDP_DEBUG +void udp_debug_print(struct udp_hdr *udphdr); +#else +#define udp_debug_print(udphdr) +#endif + +void udp_netif_ip_addr_changed(const ip_addr_t* old_addr, const ip_addr_t* new_addr); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_UDP */ + +#endif /* LWIP_HDR_UDP_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif.h index 927c6190..f4f8cf14 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif.h @@ -1,127 +1,127 @@ -/** - * @file - * lwIP netif implementing an IEEE 802.1D MAC Bridge - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_NETIF_BRIDGEIF_H -#define LWIP_HDR_NETIF_BRIDGEIF_H - -#include "netif/bridgeif_opts.h" - -#include "lwip/err.h" -#include "lwip/prot/ethernet.h" - -#ifdef __cplusplus -extern "C" { -#endif - -struct netif; - -#if (BRIDGEIF_MAX_PORTS < 0) || (BRIDGEIF_MAX_PORTS >= 64) -#error BRIDGEIF_MAX_PORTS must be [1..63] -#elif BRIDGEIF_MAX_PORTS < 8 -typedef u8_t bridgeif_portmask_t; -#elif BRIDGEIF_MAX_PORTS < 16 -typedef u16_t bridgeif_portmask_t; -#elif BRIDGEIF_MAX_PORTS < 32 -typedef u32_t bridgeif_portmask_t; -#elif BRIDGEIF_MAX_PORTS < 64 -typedef u64_t bridgeif_portmask_t; -#endif - -#define BR_FLOOD ((bridgeif_portmask_t)-1) - -/** @ingroup bridgeif - * Initialisation data for @ref bridgeif_init. - * An instance of this type must be passed as parameter 'state' to @ref netif_add - * when the bridge is added. - */ -typedef struct bridgeif_initdata_s { - /** MAC address of the bridge (cannot use the netif's addresses) */ - struct eth_addr ethaddr; - /** Maximum number of ports in the bridge (ports are stored in an array, this - influences memory allocated for netif->state of the bridge netif). */ - u8_t max_ports; - /** Maximum number of dynamic/learning entries in the bridge's forwarding database. - In the default implementation, this controls memory consumption only. */ - u16_t max_fdb_dynamic_entries; - /** Maximum number of static forwarding entries. Influences memory consumption! */ - u16_t max_fdb_static_entries; -} bridgeif_initdata_t; - -/** @ingroup bridgeif - * Use this for constant initialization of a bridgeif_initdat_t - * (ethaddr must be passed as ETH_ADDR()) - */ -#define BRIDGEIF_INITDATA1(max_ports, max_fdb_dynamic_entries, max_fdb_static_entries, ethaddr) {ethaddr, max_ports, max_fdb_dynamic_entries, max_fdb_static_entries} -/** @ingroup bridgeif - * Use this for constant initialization of a bridgeif_initdat_t - * (each byte of ethaddr must be passed) - */ -#define BRIDGEIF_INITDATA2(max_ports, max_fdb_dynamic_entries, max_fdb_static_entries, e0, e1, e2, e3, e4, e5) {{e0, e1, e2, e3, e4, e5}, max_ports, max_fdb_dynamic_entries, max_fdb_static_entries} - -err_t bridgeif_init(struct netif *netif); -err_t bridgeif_add_port(struct netif *bridgeif, struct netif *portif); -err_t bridgeif_fdb_add(struct netif *bridgeif, const struct eth_addr *addr, bridgeif_portmask_t ports); -err_t bridgeif_fdb_remove(struct netif *bridgeif, const struct eth_addr *addr); - -/* FDB interface, can be replaced by own implementation */ -void bridgeif_fdb_update_src(void *fdb_ptr, struct eth_addr *src_addr, u8_t port_idx); -bridgeif_portmask_t bridgeif_fdb_get_dst_ports(void *fdb_ptr, struct eth_addr *dst_addr); -void* bridgeif_fdb_init(u16_t max_fdb_entries); - -#if BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT -#ifndef BRIDGEIF_DECL_PROTECT -/* define bridgeif protection to sys_arch_protect... */ -#include "lwip/sys.h" -#define BRIDGEIF_DECL_PROTECT(lev) SYS_ARCH_DECL_PROTECT(lev) -#define BRIDGEIF_READ_PROTECT(lev) SYS_ARCH_PROTECT(lev) -#define BRIDGEIF_READ_UNPROTECT(lev) SYS_ARCH_UNPROTECT(lev) -#define BRIDGEIF_WRITE_PROTECT(lev) -#define BRIDGEIF_WRITE_UNPROTECT(lev) -#endif -#else /* BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT */ -#include "lwip/tcpip.h" -#define BRIDGEIF_DECL_PROTECT(lev) -#define BRIDGEIF_READ_PROTECT(lev) -#define BRIDGEIF_READ_UNPROTECT(lev) -#define BRIDGEIF_WRITE_PROTECT(lev) -#define BRIDGEIF_WRITE_UNPROTECT(lev) -#endif /* BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_NETIF_BRIDGEIF_H */ +/** + * @file + * lwIP netif implementing an IEEE 802.1D MAC Bridge + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_NETIF_BRIDGEIF_H +#define LWIP_HDR_NETIF_BRIDGEIF_H + +#include "netif/bridgeif_opts.h" + +#include "lwip/err.h" +#include "lwip/prot/ethernet.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct netif; + +#if (BRIDGEIF_MAX_PORTS < 0) || (BRIDGEIF_MAX_PORTS >= 64) +#error BRIDGEIF_MAX_PORTS must be [1..63] +#elif BRIDGEIF_MAX_PORTS < 8 +typedef u8_t bridgeif_portmask_t; +#elif BRIDGEIF_MAX_PORTS < 16 +typedef u16_t bridgeif_portmask_t; +#elif BRIDGEIF_MAX_PORTS < 32 +typedef u32_t bridgeif_portmask_t; +#elif BRIDGEIF_MAX_PORTS < 64 +typedef u64_t bridgeif_portmask_t; +#endif + +#define BR_FLOOD ((bridgeif_portmask_t)-1) + +/** @ingroup bridgeif + * Initialisation data for @ref bridgeif_init. + * An instance of this type must be passed as parameter 'state' to @ref netif_add + * when the bridge is added. + */ +typedef struct bridgeif_initdata_s { + /** MAC address of the bridge (cannot use the netif's addresses) */ + struct eth_addr ethaddr; + /** Maximum number of ports in the bridge (ports are stored in an array, this + influences memory allocated for netif->state of the bridge netif). */ + u8_t max_ports; + /** Maximum number of dynamic/learning entries in the bridge's forwarding database. + In the default implementation, this controls memory consumption only. */ + u16_t max_fdb_dynamic_entries; + /** Maximum number of static forwarding entries. Influences memory consumption! */ + u16_t max_fdb_static_entries; +} bridgeif_initdata_t; + +/** @ingroup bridgeif + * Use this for constant initialization of a bridgeif_initdat_t + * (ethaddr must be passed as ETH_ADDR()) + */ +#define BRIDGEIF_INITDATA1(max_ports, max_fdb_dynamic_entries, max_fdb_static_entries, ethaddr) {ethaddr, max_ports, max_fdb_dynamic_entries, max_fdb_static_entries} +/** @ingroup bridgeif + * Use this for constant initialization of a bridgeif_initdat_t + * (each byte of ethaddr must be passed) + */ +#define BRIDGEIF_INITDATA2(max_ports, max_fdb_dynamic_entries, max_fdb_static_entries, e0, e1, e2, e3, e4, e5) {{e0, e1, e2, e3, e4, e5}, max_ports, max_fdb_dynamic_entries, max_fdb_static_entries} + +err_t bridgeif_init(struct netif *netif); +err_t bridgeif_add_port(struct netif *bridgeif, struct netif *portif); +err_t bridgeif_fdb_add(struct netif *bridgeif, const struct eth_addr *addr, bridgeif_portmask_t ports); +err_t bridgeif_fdb_remove(struct netif *bridgeif, const struct eth_addr *addr); + +/* FDB interface, can be replaced by own implementation */ +void bridgeif_fdb_update_src(void *fdb_ptr, struct eth_addr *src_addr, u8_t port_idx); +bridgeif_portmask_t bridgeif_fdb_get_dst_ports(void *fdb_ptr, struct eth_addr *dst_addr); +void* bridgeif_fdb_init(u16_t max_fdb_entries); + +#if BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT +#ifndef BRIDGEIF_DECL_PROTECT +/* define bridgeif protection to sys_arch_protect... */ +#include "lwip/sys.h" +#define BRIDGEIF_DECL_PROTECT(lev) SYS_ARCH_DECL_PROTECT(lev) +#define BRIDGEIF_READ_PROTECT(lev) SYS_ARCH_PROTECT(lev) +#define BRIDGEIF_READ_UNPROTECT(lev) SYS_ARCH_UNPROTECT(lev) +#define BRIDGEIF_WRITE_PROTECT(lev) +#define BRIDGEIF_WRITE_UNPROTECT(lev) +#endif +#else /* BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT */ +#include "lwip/tcpip.h" +#define BRIDGEIF_DECL_PROTECT(lev) +#define BRIDGEIF_READ_PROTECT(lev) +#define BRIDGEIF_READ_UNPROTECT(lev) +#define BRIDGEIF_WRITE_PROTECT(lev) +#define BRIDGEIF_WRITE_UNPROTECT(lev) +#endif /* BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_NETIF_BRIDGEIF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif_opts.h index 5866410e..b85c3017 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/bridgeif_opts.h @@ -1,90 +1,90 @@ -/** - * @file - * lwIP netif implementing an IEEE 802.1D MAC Bridge - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#ifndef LWIP_HDR_NETIF_BRIDGEIF_OPTS_H -#define LWIP_HDR_NETIF_BRIDGEIF_OPTS_H - -#include "lwip/opt.h" - -/** - * @defgroup bridgeif_opts Options - * @ingroup bridgeif - * @{ - */ - -/** BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT==1: set port netif's 'input' function - * to call directly into bridgeif code and on top of that, directly call into - * the selected forwarding port's 'linkoutput' function. - * This means that the bridgeif input/output path is protected from concurrent access - * but as well, *all* bridge port netif's drivers must correctly handle concurrent access! - * == 0: get into tcpip_thread for every input packet (no multithreading) - * ATTENTION: as ==0 relies on tcpip.h, the default depends on NO_SYS setting - */ -#ifndef BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT -#define BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT NO_SYS -#endif - -/** BRIDGEIF_MAX_PORTS: this is used to create a typedef used for forwarding - * bit-fields: the number of bits required is this + 1 (for the internal/cpu port) - * (63 is the maximum, resulting in an u64_t for the bit mask) - * ATTENTION: this controls the maximum number of the implementation only! - * The max. number of ports per bridge must still be passed via netif_add parameter! - */ -#ifndef BRIDGEIF_MAX_PORTS -#define BRIDGEIF_MAX_PORTS 7 -#endif - -/** BRIDGEIF_DEBUG: Enable generic debugging in bridgeif.c. */ -#ifndef BRIDGEIF_DEBUG -#define BRIDGEIF_DEBUG LWIP_DBG_OFF -#endif - -/** BRIDGEIF_DEBUG: Enable FDB debugging in bridgeif.c. */ -#ifndef BRIDGEIF_FDB_DEBUG -#define BRIDGEIF_FDB_DEBUG LWIP_DBG_OFF -#endif - -/** BRIDGEIF_DEBUG: Enable forwarding debugging in bridgeif.c. */ -#ifndef BRIDGEIF_FW_DEBUG -#define BRIDGEIF_FW_DEBUG LWIP_DBG_OFF -#endif - -/** - * @} - */ - -#endif /* LWIP_HDR_NETIF_BRIDGEIF_OPTS_H */ +/** + * @file + * lwIP netif implementing an IEEE 802.1D MAC Bridge + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#ifndef LWIP_HDR_NETIF_BRIDGEIF_OPTS_H +#define LWIP_HDR_NETIF_BRIDGEIF_OPTS_H + +#include "lwip/opt.h" + +/** + * @defgroup bridgeif_opts Options + * @ingroup bridgeif + * @{ + */ + +/** BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT==1: set port netif's 'input' function + * to call directly into bridgeif code and on top of that, directly call into + * the selected forwarding port's 'linkoutput' function. + * This means that the bridgeif input/output path is protected from concurrent access + * but as well, *all* bridge port netif's drivers must correctly handle concurrent access! + * == 0: get into tcpip_thread for every input packet (no multithreading) + * ATTENTION: as ==0 relies on tcpip.h, the default depends on NO_SYS setting + */ +#ifndef BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT +#define BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT NO_SYS +#endif + +/** BRIDGEIF_MAX_PORTS: this is used to create a typedef used for forwarding + * bit-fields: the number of bits required is this + 1 (for the internal/cpu port) + * (63 is the maximum, resulting in an u64_t for the bit mask) + * ATTENTION: this controls the maximum number of the implementation only! + * The max. number of ports per bridge must still be passed via netif_add parameter! + */ +#ifndef BRIDGEIF_MAX_PORTS +#define BRIDGEIF_MAX_PORTS 7 +#endif + +/** BRIDGEIF_DEBUG: Enable generic debugging in bridgeif.c. */ +#ifndef BRIDGEIF_DEBUG +#define BRIDGEIF_DEBUG LWIP_DBG_OFF +#endif + +/** BRIDGEIF_DEBUG: Enable FDB debugging in bridgeif.c. */ +#ifndef BRIDGEIF_FDB_DEBUG +#define BRIDGEIF_FDB_DEBUG LWIP_DBG_OFF +#endif + +/** BRIDGEIF_DEBUG: Enable forwarding debugging in bridgeif.c. */ +#ifndef BRIDGEIF_FW_DEBUG +#define BRIDGEIF_FW_DEBUG LWIP_DBG_OFF +#endif + +/** + * @} + */ + +#endif /* LWIP_HDR_NETIF_BRIDGEIF_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/etharp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/etharp.h index c00de049..b536fd28 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/etharp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/etharp.h @@ -1,3 +1,3 @@ -/* ARP has been moved to core/ipv4, provide this #include for compatibility only */ -#include "lwip/etharp.h" -#include "netif/ethernet.h" +/* ARP has been moved to core/ipv4, provide this #include for compatibility only */ +#include "lwip/etharp.h" +#include "netif/ethernet.h" diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ethernet.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ethernet.h index 6e94e16a..49649cbf 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ethernet.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ethernet.h @@ -1,77 +1,77 @@ -/** - * @file - * Ethernet input function - handles INCOMING ethernet level traffic - * To be used in most low-level netif implementations - */ - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * Copyright (c) 2003-2004 Leon Woestenberg - * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - -#ifndef LWIP_HDR_NETIF_ETHERNET_H -#define LWIP_HDR_NETIF_ETHERNET_H - -#include "lwip/opt.h" - -#include "lwip/pbuf.h" -#include "lwip/netif.h" -#include "lwip/prot/ethernet.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#if LWIP_ARP || LWIP_ETHERNET - -/** Define this to 1 and define LWIP_ARP_FILTER_NETIF_FN(pbuf, netif, type) - * to a filter function that returns the correct netif when using multiple - * netifs on one hardware interface where the netif's low-level receive - * routine cannot decide for the correct netif (e.g. when mapping multiple - * IP addresses to one hardware interface). - */ -#ifndef LWIP_ARP_FILTER_NETIF -#define LWIP_ARP_FILTER_NETIF 0 -#endif - -err_t ethernet_input(struct pbuf *p, struct netif *netif); -err_t ethernet_output(struct netif* netif, struct pbuf* p, const struct eth_addr* src, const struct eth_addr* dst, u16_t eth_type); - -extern const struct eth_addr ethbroadcast, ethzero; - -#endif /* LWIP_ARP || LWIP_ETHERNET */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_NETIF_ETHERNET_H */ +/** + * @file + * Ethernet input function - handles INCOMING ethernet level traffic + * To be used in most low-level netif implementations + */ + +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * Copyright (c) 2003-2004 Leon Woestenberg + * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ + +#ifndef LWIP_HDR_NETIF_ETHERNET_H +#define LWIP_HDR_NETIF_ETHERNET_H + +#include "lwip/opt.h" + +#include "lwip/pbuf.h" +#include "lwip/netif.h" +#include "lwip/prot/ethernet.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#if LWIP_ARP || LWIP_ETHERNET + +/** Define this to 1 and define LWIP_ARP_FILTER_NETIF_FN(pbuf, netif, type) + * to a filter function that returns the correct netif when using multiple + * netifs on one hardware interface where the netif's low-level receive + * routine cannot decide for the correct netif (e.g. when mapping multiple + * IP addresses to one hardware interface). + */ +#ifndef LWIP_ARP_FILTER_NETIF +#define LWIP_ARP_FILTER_NETIF 0 +#endif + +err_t ethernet_input(struct pbuf *p, struct netif *netif); +err_t ethernet_output(struct netif* netif, struct pbuf* p, const struct eth_addr* src, const struct eth_addr* dst, u16_t eth_type); + +extern const struct eth_addr ethbroadcast, ethzero; + +#endif /* LWIP_ARP || LWIP_ETHERNET */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_NETIF_ETHERNET_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ieee802154.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ieee802154.h index 0a11a2b2..54e019fd 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ieee802154.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ieee802154.h @@ -1,112 +1,112 @@ -/** - * @file - * Definitions for IEEE 802.15.4 MAC frames - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ -#ifndef LWIP_HDR_NETIF_IEEE802154_H -#define LWIP_HDR_NETIF_IEEE802154_H - -#include "lwip/opt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -/** General MAC frame format - * This shows the full featured header, mainly for documentation. - * Some fields are omitted or shortened to achieve frame compression. - */ -struct ieee_802154_hdr { - /** See IEEE_802154_FC_* defines */ - PACK_STRUCT_FIELD(u16_t frame_control); - /** Sequence number is omitted if IEEE_802154_FC_SEQNO_SUPPR is set in frame_control */ - PACK_STRUCT_FLD_8(u8_t sequence_number); - /** Destination PAN ID is omitted if Destination Addressing Mode is 0 */ - PACK_STRUCT_FIELD(u16_t destination_pan_id); - /** Destination Address is omitted if Destination Addressing Mode is 0 */ - PACK_STRUCT_FLD_8(u8_t destination_address[8]); - /** Source PAN ID is omitted if Source Addressing Mode is 0 - or if IEEE_802154_FC_PANID_COMPR is set in frame control*/ - PACK_STRUCT_FIELD(u16_t source_pan_id); - /** Source Address is omitted if Source Addressing Mode is 0 */ - PACK_STRUCT_FLD_8(u8_t source_address[8]); - /* The rest is variable */ -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/* Addressing modes (2 bits) */ -#define IEEE_802154_ADDR_MODE_NO_ADDR 0x00 /* PAN ID and address fields are not present */ -#define IEEE_802154_ADDR_MODE_RESERVED 0x01 /* Reserved */ -#define IEEE_802154_ADDR_MODE_SHORT 0x02 /* Address field contains a short address (16 bit) */ -#define IEEE_802154_ADDR_MODE_EXT 0x03 /* Address field contains an extended address (64 bit) */ - -/* IEEE 802.15.4 Frame Control definitions (2 bytes; see IEEE 802.15.4-2015 ch. 7.2.1) */ -#define IEEE_802154_FC_FT_MASK 0x0007 /* bits 0..2: Frame Type */ -#define IEEE_802154_FC_FT_BEACON 0x00 -#define IEEE_802154_FC_FT_DATA 0x01 -#define IEEE_802154_FC_FT_ACK 0x02 -#define IEEE_802154_FC_FT_MAC_CMD 0x03 -#define IEEE_802154_FC_FT_RESERVED 0x04 -#define IEEE_802154_FC_FT_MULTIPURPOSE 0x05 -#define IEEE_802154_FC_FT_FRAG 0x06 -#define IEEE_802154_FC_FT_EXT 0x07 -#define IEEE_802154_FC_SEC_EN 0x0008 /* bit 3: Security Enabled */ -#define IEEE_802154_FC_FRAME_PEND 0x0010 /* bit 4: Frame Pending */ -#define IEEE_802154_FC_ACK_REQ 0x0020 /* bit 5: AR (ACK required) */ -#define IEEE_802154_FC_PANID_COMPR 0x0040 /* bit 6: PAN ID Compression (src and dst are equal, src PAN ID omitted) */ -#define IEEE_802154_FC_RESERVED 0x0080 -#define IEEE_802154_FC_SEQNO_SUPPR 0x0100 /* bit 8: Sequence Number Suppression */ -#define IEEE_802154_FC_IE_PRESENT 0x0200 /* bit 9: IE Present */ -#define IEEE_802154_FC_DST_ADDR_MODE_MASK 0x0c00 /* bits 10..11: Destination Addressing Mode */ -#define IEEE_802154_FC_DST_ADDR_MODE_NO_ADDR (IEEE_802154_ADDR_MODE_NO_ADDR << 10) -#define IEEE_802154_FC_DST_ADDR_MODE_SHORT (IEEE_802154_ADDR_MODE_SHORT << 10) -#define IEEE_802154_FC_DST_ADDR_MODE_EXT (IEEE_802154_ADDR_MODE_EXT << 10) -#define IEEE_802154_FC_FRAME_VERSION_MASK 0x3000 /* bits 12..13: Frame Version */ -#define IEEE_802154_FC_FRAME_VERSION_GET(x) (((x) & IEEE_802154_FC_FRAME_VERSION_MASK) >> 12) -#define IEEE_802154_FC_SRC_ADDR_MODE_MASK 0xc000 /* bits 14..15: Source Addressing Mode */ -#define IEEE_802154_FC_SRC_ADDR_MODE_SHORT (IEEE_802154_ADDR_MODE_SHORT << 14) -#define IEEE_802154_FC_SRC_ADDR_MODE_EXT (IEEE_802154_ADDR_MODE_EXT << 14) - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_NETIF_IEEE802154_H */ +/** + * @file + * Definitions for IEEE 802.15.4 MAC frames + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ +#ifndef LWIP_HDR_NETIF_IEEE802154_H +#define LWIP_HDR_NETIF_IEEE802154_H + +#include "lwip/opt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +/** General MAC frame format + * This shows the full featured header, mainly for documentation. + * Some fields are omitted or shortened to achieve frame compression. + */ +struct ieee_802154_hdr { + /** See IEEE_802154_FC_* defines */ + PACK_STRUCT_FIELD(u16_t frame_control); + /** Sequence number is omitted if IEEE_802154_FC_SEQNO_SUPPR is set in frame_control */ + PACK_STRUCT_FLD_8(u8_t sequence_number); + /** Destination PAN ID is omitted if Destination Addressing Mode is 0 */ + PACK_STRUCT_FIELD(u16_t destination_pan_id); + /** Destination Address is omitted if Destination Addressing Mode is 0 */ + PACK_STRUCT_FLD_8(u8_t destination_address[8]); + /** Source PAN ID is omitted if Source Addressing Mode is 0 + or if IEEE_802154_FC_PANID_COMPR is set in frame control*/ + PACK_STRUCT_FIELD(u16_t source_pan_id); + /** Source Address is omitted if Source Addressing Mode is 0 */ + PACK_STRUCT_FLD_8(u8_t source_address[8]); + /* The rest is variable */ +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/* Addressing modes (2 bits) */ +#define IEEE_802154_ADDR_MODE_NO_ADDR 0x00 /* PAN ID and address fields are not present */ +#define IEEE_802154_ADDR_MODE_RESERVED 0x01 /* Reserved */ +#define IEEE_802154_ADDR_MODE_SHORT 0x02 /* Address field contains a short address (16 bit) */ +#define IEEE_802154_ADDR_MODE_EXT 0x03 /* Address field contains an extended address (64 bit) */ + +/* IEEE 802.15.4 Frame Control definitions (2 bytes; see IEEE 802.15.4-2015 ch. 7.2.1) */ +#define IEEE_802154_FC_FT_MASK 0x0007 /* bits 0..2: Frame Type */ +#define IEEE_802154_FC_FT_BEACON 0x00 +#define IEEE_802154_FC_FT_DATA 0x01 +#define IEEE_802154_FC_FT_ACK 0x02 +#define IEEE_802154_FC_FT_MAC_CMD 0x03 +#define IEEE_802154_FC_FT_RESERVED 0x04 +#define IEEE_802154_FC_FT_MULTIPURPOSE 0x05 +#define IEEE_802154_FC_FT_FRAG 0x06 +#define IEEE_802154_FC_FT_EXT 0x07 +#define IEEE_802154_FC_SEC_EN 0x0008 /* bit 3: Security Enabled */ +#define IEEE_802154_FC_FRAME_PEND 0x0010 /* bit 4: Frame Pending */ +#define IEEE_802154_FC_ACK_REQ 0x0020 /* bit 5: AR (ACK required) */ +#define IEEE_802154_FC_PANID_COMPR 0x0040 /* bit 6: PAN ID Compression (src and dst are equal, src PAN ID omitted) */ +#define IEEE_802154_FC_RESERVED 0x0080 +#define IEEE_802154_FC_SEQNO_SUPPR 0x0100 /* bit 8: Sequence Number Suppression */ +#define IEEE_802154_FC_IE_PRESENT 0x0200 /* bit 9: IE Present */ +#define IEEE_802154_FC_DST_ADDR_MODE_MASK 0x0c00 /* bits 10..11: Destination Addressing Mode */ +#define IEEE_802154_FC_DST_ADDR_MODE_NO_ADDR (IEEE_802154_ADDR_MODE_NO_ADDR << 10) +#define IEEE_802154_FC_DST_ADDR_MODE_SHORT (IEEE_802154_ADDR_MODE_SHORT << 10) +#define IEEE_802154_FC_DST_ADDR_MODE_EXT (IEEE_802154_ADDR_MODE_EXT << 10) +#define IEEE_802154_FC_FRAME_VERSION_MASK 0x3000 /* bits 12..13: Frame Version */ +#define IEEE_802154_FC_FRAME_VERSION_GET(x) (((x) & IEEE_802154_FC_FRAME_VERSION_MASK) >> 12) +#define IEEE_802154_FC_SRC_ADDR_MODE_MASK 0xc000 /* bits 14..15: Source Addressing Mode */ +#define IEEE_802154_FC_SRC_ADDR_MODE_SHORT (IEEE_802154_ADDR_MODE_SHORT << 14) +#define IEEE_802154_FC_SRC_ADDR_MODE_EXT (IEEE_802154_ADDR_MODE_EXT << 14) + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_NETIF_IEEE802154_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6.h index b84b838c..ecff24ba 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6.h @@ -1,89 +1,89 @@ -/** - * @file - * - * 6LowPAN output for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. - */ - -/* - * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#ifndef LWIP_HDR_LOWPAN6_H -#define LWIP_HDR_LOWPAN6_H - -#include "netif/lowpan6_opts.h" - -#if LWIP_IPV6 - -#include "netif/lowpan6_common.h" -#include "lwip/pbuf.h" -#include "lwip/ip.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** 1 second period for reassembly */ -#define LOWPAN6_TMR_INTERVAL 1000 - -void lowpan6_tmr(void); - -err_t lowpan6_set_context(u8_t idx, const ip6_addr_t * context); -err_t lowpan6_set_short_addr(u8_t addr_high, u8_t addr_low); - -#if LWIP_IPV4 -err_t lowpan4_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr); -#endif /* LWIP_IPV4 */ -err_t lowpan6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr); -err_t lowpan6_input(struct pbuf * p, struct netif *netif); -err_t lowpan6_if_init(struct netif *netif); - -/* pan_id in network byte order. */ -err_t lowpan6_set_pan_id(u16_t pan_id); - -u16_t lowpan6_calc_crc(const void *buf, u16_t len); - -#if !NO_SYS -err_t tcpip_6lowpan_input(struct pbuf *p, struct netif *inp); -#endif /* !NO_SYS */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 */ - -#endif /* LWIP_HDR_LOWPAN6_H */ +/** + * @file + * + * 6LowPAN output for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. + */ + +/* + * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#ifndef LWIP_HDR_LOWPAN6_H +#define LWIP_HDR_LOWPAN6_H + +#include "netif/lowpan6_opts.h" + +#if LWIP_IPV6 + +#include "netif/lowpan6_common.h" +#include "lwip/pbuf.h" +#include "lwip/ip.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** 1 second period for reassembly */ +#define LOWPAN6_TMR_INTERVAL 1000 + +void lowpan6_tmr(void); + +err_t lowpan6_set_context(u8_t idx, const ip6_addr_t * context); +err_t lowpan6_set_short_addr(u8_t addr_high, u8_t addr_low); + +#if LWIP_IPV4 +err_t lowpan4_output(struct netif *netif, struct pbuf *q, const ip4_addr_t *ipaddr); +#endif /* LWIP_IPV4 */ +err_t lowpan6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr); +err_t lowpan6_input(struct pbuf * p, struct netif *netif); +err_t lowpan6_if_init(struct netif *netif); + +/* pan_id in network byte order. */ +err_t lowpan6_set_pan_id(u16_t pan_id); + +u16_t lowpan6_calc_crc(const void *buf, u16_t len); + +#if !NO_SYS +err_t tcpip_6lowpan_input(struct pbuf *p, struct netif *inp); +#endif /* !NO_SYS */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 */ + +#endif /* LWIP_HDR_LOWPAN6_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_ble.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_ble.h index 46a5f2e6..01896a7f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_ble.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_ble.h @@ -1,78 +1,78 @@ -/** - * @file - * 6LowPAN over BLE for IPv6 (RFC7668). - */ - -/* - * Copyright (c) 2017 Benjamin Aigner - * Copyright (c) 2015 Inico Technologies Ltd. , Author: Ivan Delamer - * - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Benjamin Aigner - * - * Based on the original 6lowpan implementation of lwIP ( @see 6lowpan.c) - */ - -#ifndef LWIP_HDR_LOWPAN6_BLE_H -#define LWIP_HDR_LOWPAN6_BLE_H - -#include "netif/lowpan6_opts.h" - -#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ - -#include "netif/lowpan6_common.h" -#include "lwip/pbuf.h" -#include "lwip/ip.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -err_t rfc7668_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr); -err_t rfc7668_input(struct pbuf * p, struct netif *netif); -err_t rfc7668_set_local_addr_eui64(struct netif *netif, const u8_t *local_addr, size_t local_addr_len); -err_t rfc7668_set_local_addr_mac48(struct netif *netif, const u8_t *local_addr, size_t local_addr_len, int is_public_addr); -err_t rfc7668_set_peer_addr_eui64(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len); -err_t rfc7668_set_peer_addr_mac48(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len, int is_public_addr); -err_t rfc7668_set_context(u8_t index, const ip6_addr_t * context); -err_t rfc7668_if_init(struct netif *netif); - -#if !NO_SYS -err_t tcpip_rfc7668_input(struct pbuf *p, struct netif *inp); -#endif - -void ble_addr_to_eui64(uint8_t *dst, const uint8_t *src, int public_addr); -void eui64_to_ble_addr(uint8_t *dst, const uint8_t *src); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 */ - -#endif /* LWIP_HDR_LOWPAN6_BLE_H */ +/** + * @file + * 6LowPAN over BLE for IPv6 (RFC7668). + */ + +/* + * Copyright (c) 2017 Benjamin Aigner + * Copyright (c) 2015 Inico Technologies Ltd. , Author: Ivan Delamer + * + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Benjamin Aigner + * + * Based on the original 6lowpan implementation of lwIP ( @see 6lowpan.c) + */ + +#ifndef LWIP_HDR_LOWPAN6_BLE_H +#define LWIP_HDR_LOWPAN6_BLE_H + +#include "netif/lowpan6_opts.h" + +#if LWIP_IPV6 /* don't build if not configured for use in lwipopts.h */ + +#include "netif/lowpan6_common.h" +#include "lwip/pbuf.h" +#include "lwip/ip.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +err_t rfc7668_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr); +err_t rfc7668_input(struct pbuf * p, struct netif *netif); +err_t rfc7668_set_local_addr_eui64(struct netif *netif, const u8_t *local_addr, size_t local_addr_len); +err_t rfc7668_set_local_addr_mac48(struct netif *netif, const u8_t *local_addr, size_t local_addr_len, int is_public_addr); +err_t rfc7668_set_peer_addr_eui64(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len); +err_t rfc7668_set_peer_addr_mac48(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len, int is_public_addr); +err_t rfc7668_set_context(u8_t index, const ip6_addr_t * context); +err_t rfc7668_if_init(struct netif *netif); + +#if !NO_SYS +err_t tcpip_rfc7668_input(struct pbuf *p, struct netif *inp); +#endif + +void ble_addr_to_eui64(uint8_t *dst, const uint8_t *src, int public_addr); +void eui64_to_ble_addr(uint8_t *dst, const uint8_t *src); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 */ + +#endif /* LWIP_HDR_LOWPAN6_BLE_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_common.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_common.h index d80eef97..0dc13ab5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_common.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_common.h @@ -1,82 +1,82 @@ -/** - * @file - * - * Common 6LowPAN routines for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. - */ - -/* - * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#ifndef LWIP_HDR_LOWPAN6_COMMON_H -#define LWIP_HDR_LOWPAN6_COMMON_H - -#include "netif/lowpan6_opts.h" - -#if LWIP_IPV6 /* don't build if IPv6 is disabled in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/ip.h" -#include "lwip/ip6_addr.h" -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** Helper define for a link layer address, which can be encoded as 0, 2 or 8 bytes */ -struct lowpan6_link_addr { - /* encoded length of the address */ - u8_t addr_len; - /* address bytes */ - u8_t addr[8]; -}; - -s8_t lowpan6_get_address_mode(const ip6_addr_t *ip6addr, const struct lowpan6_link_addr *mac_addr); - -#if LWIP_6LOWPAN_IPHC -err_t lowpan6_compress_headers(struct netif *netif, u8_t *inbuf, size_t inbuf_size, u8_t *outbuf, size_t outbuf_size, - u8_t *lowpan6_header_len_out, u8_t *hidden_header_len_out, ip6_addr_t *lowpan6_contexts, - const struct lowpan6_link_addr *src, const struct lowpan6_link_addr *dst); -struct pbuf *lowpan6_decompress(struct pbuf *p, u16_t datagram_size, ip6_addr_t *lowpan6_contexts, - struct lowpan6_link_addr *src, struct lowpan6_link_addr *dest); -#endif /* LWIP_6LOWPAN_IPHC */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 */ - -#endif /* LWIP_HDR_LOWPAN6_COMMON_H */ +/** + * @file + * + * Common 6LowPAN routines for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. + */ + +/* + * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#ifndef LWIP_HDR_LOWPAN6_COMMON_H +#define LWIP_HDR_LOWPAN6_COMMON_H + +#include "netif/lowpan6_opts.h" + +#if LWIP_IPV6 /* don't build if IPv6 is disabled in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/ip.h" +#include "lwip/ip6_addr.h" +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** Helper define for a link layer address, which can be encoded as 0, 2 or 8 bytes */ +struct lowpan6_link_addr { + /* encoded length of the address */ + u8_t addr_len; + /* address bytes */ + u8_t addr[8]; +}; + +s8_t lowpan6_get_address_mode(const ip6_addr_t *ip6addr, const struct lowpan6_link_addr *mac_addr); + +#if LWIP_6LOWPAN_IPHC +err_t lowpan6_compress_headers(struct netif *netif, u8_t *inbuf, size_t inbuf_size, u8_t *outbuf, size_t outbuf_size, + u8_t *lowpan6_header_len_out, u8_t *hidden_header_len_out, ip6_addr_t *lowpan6_contexts, + const struct lowpan6_link_addr *src, const struct lowpan6_link_addr *dst); +struct pbuf *lowpan6_decompress(struct pbuf *p, u16_t datagram_size, ip6_addr_t *lowpan6_contexts, + struct lowpan6_link_addr *src, struct lowpan6_link_addr *dest); +#endif /* LWIP_6LOWPAN_IPHC */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 */ + +#endif /* LWIP_HDR_LOWPAN6_COMMON_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_opts.h index 5303c15b..17d46cdc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/lowpan6_opts.h @@ -1,122 +1,122 @@ -/** - * @file - * 6LowPAN options list - */ - -/* - * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -#ifndef LWIP_HDR_LOWPAN6_OPTS_H -#define LWIP_HDR_LOWPAN6_OPTS_H - -#include "lwip/opt.h" - -/** LWIP_6LOWPAN_NUM_CONTEXTS: define the number of compression - * contexts per netif type - */ -#ifndef LWIP_6LOWPAN_NUM_CONTEXTS -#define LWIP_6LOWPAN_NUM_CONTEXTS 10 -#endif - -/** LWIP_6LOWPAN_INFER_SHORT_ADDRESS: set this to 0 to disable creating - * short addresses for matching addresses (debug only) - */ -#ifndef LWIP_6LOWPAN_INFER_SHORT_ADDRESS -#define LWIP_6LOWPAN_INFER_SHORT_ADDRESS 1 -#endif - -/** LWIP_6LOWPAN_IPHC: set this to 0 to disable IP header compression as per - * RFC 6282 (which is mandatory for BLE) - */ -#ifndef LWIP_6LOWPAN_IPHC -#define LWIP_6LOWPAN_IPHC 1 -#endif - -/** Set this to 1 if your IEEE 802.15.4 interface can calculate and check the - * CRC in hardware. This means TX packets get 2 zero bytes added on transmission - * which are to be filled with the CRC. - */ -#ifndef LWIP_6LOWPAN_802154_HW_CRC -#define LWIP_6LOWPAN_802154_HW_CRC 0 -#endif - -/** If LWIP_6LOWPAN_802154_HW_CRC==0, this can override the default slow - * implementation of the CRC used for 6LoWPAN over IEEE 802.15.4 (which uses - * a shift register). - */ -#ifndef LWIP_6LOWPAN_CALC_CRC -#define LWIP_6LOWPAN_CALC_CRC(buf, len) lowpan6_calc_crc(buf, len) -#endif - -/** Debug level for 6LoWPAN in general */ -#ifndef LWIP_LOWPAN6_DEBUG -#define LWIP_LOWPAN6_DEBUG LWIP_DBG_OFF -#endif - -/** Debug level for 6LoWPAN over IEEE 802.15.4 */ -#ifndef LWIP_LOWPAN6_802154_DEBUG -#define LWIP_LOWPAN6_802154_DEBUG LWIP_DBG_OFF -#endif - -/** LWIP_LOWPAN6_IP_COMPRESSED_DEBUG: enable compressed IP frame - * output debugging - */ -#ifndef LWIP_LOWPAN6_IP_COMPRESSED_DEBUG -#define LWIP_LOWPAN6_IP_COMPRESSED_DEBUG LWIP_DBG_OFF -#endif - -/** LWIP_LOWPAN6_DECOMPRESSION_DEBUG: enable decompression debug output - */ -#ifndef LWIP_LOWPAN6_DECOMPRESSION_DEBUG -#define LWIP_LOWPAN6_DECOMPRESSION_DEBUG LWIP_DBG_OFF -#endif - -/** LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG: enable decompressed IP frame - * output debugging */ -#ifndef LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG -#define LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG LWIP_DBG_OFF -#endif - -/** LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS: - * Currently, the linux kernel driver for 6lowpan sets/clears a bit in - * the address, depending on the BD address (either public or not). - * Might not be RFC7668 conform, so you may select to do that (=1) or - * not (=0) */ -#ifndef LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS -#define LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS 1 -#endif - - -#endif /* LWIP_HDR_LOWPAN6_OPTS_H */ +/** + * @file + * 6LowPAN options list + */ + +/* + * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +#ifndef LWIP_HDR_LOWPAN6_OPTS_H +#define LWIP_HDR_LOWPAN6_OPTS_H + +#include "lwip/opt.h" + +/** LWIP_6LOWPAN_NUM_CONTEXTS: define the number of compression + * contexts per netif type + */ +#ifndef LWIP_6LOWPAN_NUM_CONTEXTS +#define LWIP_6LOWPAN_NUM_CONTEXTS 10 +#endif + +/** LWIP_6LOWPAN_INFER_SHORT_ADDRESS: set this to 0 to disable creating + * short addresses for matching addresses (debug only) + */ +#ifndef LWIP_6LOWPAN_INFER_SHORT_ADDRESS +#define LWIP_6LOWPAN_INFER_SHORT_ADDRESS 1 +#endif + +/** LWIP_6LOWPAN_IPHC: set this to 0 to disable IP header compression as per + * RFC 6282 (which is mandatory for BLE) + */ +#ifndef LWIP_6LOWPAN_IPHC +#define LWIP_6LOWPAN_IPHC 1 +#endif + +/** Set this to 1 if your IEEE 802.15.4 interface can calculate and check the + * CRC in hardware. This means TX packets get 2 zero bytes added on transmission + * which are to be filled with the CRC. + */ +#ifndef LWIP_6LOWPAN_802154_HW_CRC +#define LWIP_6LOWPAN_802154_HW_CRC 0 +#endif + +/** If LWIP_6LOWPAN_802154_HW_CRC==0, this can override the default slow + * implementation of the CRC used for 6LoWPAN over IEEE 802.15.4 (which uses + * a shift register). + */ +#ifndef LWIP_6LOWPAN_CALC_CRC +#define LWIP_6LOWPAN_CALC_CRC(buf, len) lowpan6_calc_crc(buf, len) +#endif + +/** Debug level for 6LoWPAN in general */ +#ifndef LWIP_LOWPAN6_DEBUG +#define LWIP_LOWPAN6_DEBUG LWIP_DBG_OFF +#endif + +/** Debug level for 6LoWPAN over IEEE 802.15.4 */ +#ifndef LWIP_LOWPAN6_802154_DEBUG +#define LWIP_LOWPAN6_802154_DEBUG LWIP_DBG_OFF +#endif + +/** LWIP_LOWPAN6_IP_COMPRESSED_DEBUG: enable compressed IP frame + * output debugging + */ +#ifndef LWIP_LOWPAN6_IP_COMPRESSED_DEBUG +#define LWIP_LOWPAN6_IP_COMPRESSED_DEBUG LWIP_DBG_OFF +#endif + +/** LWIP_LOWPAN6_DECOMPRESSION_DEBUG: enable decompression debug output + */ +#ifndef LWIP_LOWPAN6_DECOMPRESSION_DEBUG +#define LWIP_LOWPAN6_DECOMPRESSION_DEBUG LWIP_DBG_OFF +#endif + +/** LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG: enable decompressed IP frame + * output debugging */ +#ifndef LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG +#define LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG LWIP_DBG_OFF +#endif + +/** LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS: + * Currently, the linux kernel driver for 6lowpan sets/clears a bit in + * the address, depending on the BD address (either public or not). + * Might not be RFC7668 conform, so you may select to do that (=1) or + * not (=0) */ +#ifndef LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS +#define LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS 1 +#endif + + +#endif /* LWIP_HDR_LOWPAN6_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ccp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ccp.h index c35336f9..b2285228 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ccp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ccp.h @@ -1,164 +1,164 @@ -/* - * ccp.h - Definitions for PPP Compression Control Protocol. - * - * Copyright (c) 1994-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: ccp.h,v 1.12 2004/11/04 10:02:26 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && CCP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef CCP_H -#define CCP_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * CCP codes. - */ - -#define CCP_CONFREQ 1 -#define CCP_CONFACK 2 -#define CCP_TERMREQ 5 -#define CCP_TERMACK 6 -#define CCP_RESETREQ 14 -#define CCP_RESETACK 15 - -/* - * Max # bytes for a CCP option - */ - -#define CCP_MAX_OPTION_LENGTH 32 - -/* - * Parts of a CCP packet. - */ - -#define CCP_CODE(dp) ((dp)[0]) -#define CCP_ID(dp) ((dp)[1]) -#define CCP_LENGTH(dp) (((dp)[2] << 8) + (dp)[3]) -#define CCP_HDRLEN 4 - -#define CCP_OPT_CODE(dp) ((dp)[0]) -#define CCP_OPT_LENGTH(dp) ((dp)[1]) -#define CCP_OPT_MINLEN 2 - -#if BSDCOMPRESS_SUPPORT -/* - * Definitions for BSD-Compress. - */ - -#define CI_BSD_COMPRESS 21 /* config. option for BSD-Compress */ -#define CILEN_BSD_COMPRESS 3 /* length of config. option */ - -/* Macros for handling the 3rd byte of the BSD-Compress config option. */ -#define BSD_NBITS(x) ((x) & 0x1F) /* number of bits requested */ -#define BSD_VERSION(x) ((x) >> 5) /* version of option format */ -#define BSD_CURRENT_VERSION 1 /* current version number */ -#define BSD_MAKE_OPT(v, n) (((v) << 5) | (n)) - -#define BSD_MIN_BITS 9 /* smallest code size supported */ -#define BSD_MAX_BITS 15 /* largest code size supported */ -#endif /* BSDCOMPRESS_SUPPORT */ - -#if DEFLATE_SUPPORT -/* - * Definitions for Deflate. - */ - -#define CI_DEFLATE 26 /* config option for Deflate */ -#define CI_DEFLATE_DRAFT 24 /* value used in original draft RFC */ -#define CILEN_DEFLATE 4 /* length of its config option */ - -#define DEFLATE_MIN_SIZE 9 -#define DEFLATE_MAX_SIZE 15 -#define DEFLATE_METHOD_VAL 8 -#define DEFLATE_SIZE(x) (((x) >> 4) + 8) -#define DEFLATE_METHOD(x) ((x) & 0x0F) -#define DEFLATE_MAKE_OPT(w) ((((w) - 8) << 4) + DEFLATE_METHOD_VAL) -#define DEFLATE_CHK_SEQUENCE 0 -#endif /* DEFLATE_SUPPORT */ - -#if MPPE_SUPPORT -/* - * Definitions for MPPE. - */ - -#define CI_MPPE 18 /* config option for MPPE */ -#define CILEN_MPPE 6 /* length of config option */ -#endif /* MPPE_SUPPORT */ - -#if PREDICTOR_SUPPORT -/* - * Definitions for other, as yet unsupported, compression methods. - */ - -#define CI_PREDICTOR_1 1 /* config option for Predictor-1 */ -#define CILEN_PREDICTOR_1 2 /* length of its config option */ -#define CI_PREDICTOR_2 2 /* config option for Predictor-2 */ -#define CILEN_PREDICTOR_2 2 /* length of its config option */ -#endif /* PREDICTOR_SUPPORT */ - -typedef struct ccp_options { -#if DEFLATE_SUPPORT - unsigned int deflate :1; /* do Deflate? */ - unsigned int deflate_correct :1; /* use correct code for deflate? */ - unsigned int deflate_draft :1; /* use draft RFC code for deflate? */ -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - unsigned int bsd_compress :1; /* do BSD Compress? */ -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - unsigned int predictor_1 :1; /* do Predictor-1? */ - unsigned int predictor_2 :1; /* do Predictor-2? */ -#endif /* PREDICTOR_SUPPORT */ - -#if MPPE_SUPPORT - u8_t mppe; /* MPPE bitfield */ -#endif /* MPPE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - u_short bsd_bits; /* # bits/code for BSD Compress */ -#endif /* BSDCOMPRESS_SUPPORT */ -#if DEFLATE_SUPPORT - u_short deflate_size; /* lg(window size) for Deflate */ -#endif /* DEFLATE_SUPPORT */ - u8_t method; /* code for chosen compression method */ -} ccp_options; - -extern const struct protent ccp_protent; - -void ccp_resetrequest(ppp_pcb *pcb); /* Issue a reset-request. */ - -#ifdef __cplusplus -} -#endif - -#endif /* CCP_H */ -#endif /* PPP_SUPPORT && CCP_SUPPORT */ +/* + * ccp.h - Definitions for PPP Compression Control Protocol. + * + * Copyright (c) 1994-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: ccp.h,v 1.12 2004/11/04 10:02:26 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && CCP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef CCP_H +#define CCP_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * CCP codes. + */ + +#define CCP_CONFREQ 1 +#define CCP_CONFACK 2 +#define CCP_TERMREQ 5 +#define CCP_TERMACK 6 +#define CCP_RESETREQ 14 +#define CCP_RESETACK 15 + +/* + * Max # bytes for a CCP option + */ + +#define CCP_MAX_OPTION_LENGTH 32 + +/* + * Parts of a CCP packet. + */ + +#define CCP_CODE(dp) ((dp)[0]) +#define CCP_ID(dp) ((dp)[1]) +#define CCP_LENGTH(dp) (((dp)[2] << 8) + (dp)[3]) +#define CCP_HDRLEN 4 + +#define CCP_OPT_CODE(dp) ((dp)[0]) +#define CCP_OPT_LENGTH(dp) ((dp)[1]) +#define CCP_OPT_MINLEN 2 + +#if BSDCOMPRESS_SUPPORT +/* + * Definitions for BSD-Compress. + */ + +#define CI_BSD_COMPRESS 21 /* config. option for BSD-Compress */ +#define CILEN_BSD_COMPRESS 3 /* length of config. option */ + +/* Macros for handling the 3rd byte of the BSD-Compress config option. */ +#define BSD_NBITS(x) ((x) & 0x1F) /* number of bits requested */ +#define BSD_VERSION(x) ((x) >> 5) /* version of option format */ +#define BSD_CURRENT_VERSION 1 /* current version number */ +#define BSD_MAKE_OPT(v, n) (((v) << 5) | (n)) + +#define BSD_MIN_BITS 9 /* smallest code size supported */ +#define BSD_MAX_BITS 15 /* largest code size supported */ +#endif /* BSDCOMPRESS_SUPPORT */ + +#if DEFLATE_SUPPORT +/* + * Definitions for Deflate. + */ + +#define CI_DEFLATE 26 /* config option for Deflate */ +#define CI_DEFLATE_DRAFT 24 /* value used in original draft RFC */ +#define CILEN_DEFLATE 4 /* length of its config option */ + +#define DEFLATE_MIN_SIZE 9 +#define DEFLATE_MAX_SIZE 15 +#define DEFLATE_METHOD_VAL 8 +#define DEFLATE_SIZE(x) (((x) >> 4) + 8) +#define DEFLATE_METHOD(x) ((x) & 0x0F) +#define DEFLATE_MAKE_OPT(w) ((((w) - 8) << 4) + DEFLATE_METHOD_VAL) +#define DEFLATE_CHK_SEQUENCE 0 +#endif /* DEFLATE_SUPPORT */ + +#if MPPE_SUPPORT +/* + * Definitions for MPPE. + */ + +#define CI_MPPE 18 /* config option for MPPE */ +#define CILEN_MPPE 6 /* length of config option */ +#endif /* MPPE_SUPPORT */ + +#if PREDICTOR_SUPPORT +/* + * Definitions for other, as yet unsupported, compression methods. + */ + +#define CI_PREDICTOR_1 1 /* config option for Predictor-1 */ +#define CILEN_PREDICTOR_1 2 /* length of its config option */ +#define CI_PREDICTOR_2 2 /* config option for Predictor-2 */ +#define CILEN_PREDICTOR_2 2 /* length of its config option */ +#endif /* PREDICTOR_SUPPORT */ + +typedef struct ccp_options { +#if DEFLATE_SUPPORT + unsigned int deflate :1; /* do Deflate? */ + unsigned int deflate_correct :1; /* use correct code for deflate? */ + unsigned int deflate_draft :1; /* use draft RFC code for deflate? */ +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + unsigned int bsd_compress :1; /* do BSD Compress? */ +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + unsigned int predictor_1 :1; /* do Predictor-1? */ + unsigned int predictor_2 :1; /* do Predictor-2? */ +#endif /* PREDICTOR_SUPPORT */ + +#if MPPE_SUPPORT + u8_t mppe; /* MPPE bitfield */ +#endif /* MPPE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + u_short bsd_bits; /* # bits/code for BSD Compress */ +#endif /* BSDCOMPRESS_SUPPORT */ +#if DEFLATE_SUPPORT + u_short deflate_size; /* lg(window size) for Deflate */ +#endif /* DEFLATE_SUPPORT */ + u8_t method; /* code for chosen compression method */ +} ccp_options; + +extern const struct protent ccp_protent; + +void ccp_resetrequest(ppp_pcb *pcb); /* Issue a reset-request. */ + +#ifdef __cplusplus +} +#endif + +#endif /* CCP_H */ +#endif /* PPP_SUPPORT && CCP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-md5.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-md5.h index 1f58dfe7..eb0269fe 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-md5.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-md5.h @@ -1,36 +1,36 @@ -/* - * chap-md5.h - New CHAP/MD5 implementation. - * - * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -extern const struct chap_digest_type md5_digest; - -#endif /* PPP_SUPPORT && CHAP_SUPPORT */ +/* + * chap-md5.h - New CHAP/MD5 implementation. + * + * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +extern const struct chap_digest_type md5_digest; + +#endif /* PPP_SUPPORT && CHAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-new.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-new.h index dadd9c2f..2d8cd9ca 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-new.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap-new.h @@ -1,200 +1,200 @@ -/* - * chap-new.c - New CHAP implementation. - * - * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef CHAP_H -#define CHAP_H - -#include "ppp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * CHAP packets begin with a standard header with code, id, len (2 bytes). - */ -#define CHAP_HDRLEN 4 - -/* - * Values for the code field. - */ -#define CHAP_CHALLENGE 1 -#define CHAP_RESPONSE 2 -#define CHAP_SUCCESS 3 -#define CHAP_FAILURE 4 - -/* - * CHAP digest codes. - */ -#define CHAP_MD5 5 -#if MSCHAP_SUPPORT -#define CHAP_MICROSOFT 0x80 -#define CHAP_MICROSOFT_V2 0x81 -#endif /* MSCHAP_SUPPORT */ - -/* - * Semi-arbitrary limits on challenge and response fields. - */ -#define MAX_CHALLENGE_LEN 64 -#define MAX_RESPONSE_LEN 64 - -/* - * These limits apply to challenge and response packets we send. - * The +4 is the +1 that we actually need rounded up. - */ -#define CHAL_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_CHALLENGE_LEN + MAXNAMELEN) -#define RESP_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_RESPONSE_LEN + MAXNAMELEN) - -/* bitmask of supported algorithms */ -#if MSCHAP_SUPPORT -#define MDTYPE_MICROSOFT_V2 0x1 -#define MDTYPE_MICROSOFT 0x2 -#endif /* MSCHAP_SUPPORT */ -#define MDTYPE_MD5 0x4 -#define MDTYPE_NONE 0 - -#if MSCHAP_SUPPORT -/* Return the digest alg. ID for the most preferred digest type. */ -#define CHAP_DIGEST(mdtype) \ - ((mdtype) & MDTYPE_MD5)? CHAP_MD5: \ - ((mdtype) & MDTYPE_MICROSOFT_V2)? CHAP_MICROSOFT_V2: \ - ((mdtype) & MDTYPE_MICROSOFT)? CHAP_MICROSOFT: \ - 0 -#else /* !MSCHAP_SUPPORT */ -#define CHAP_DIGEST(mdtype) \ - ((mdtype) & MDTYPE_MD5)? CHAP_MD5: \ - 0 -#endif /* MSCHAP_SUPPORT */ - -/* Return the bit flag (lsb set) for our most preferred digest type. */ -#define CHAP_MDTYPE(mdtype) ((mdtype) ^ ((mdtype) - 1)) & (mdtype) - -/* Return the bit flag for a given digest algorithm ID. */ -#if MSCHAP_SUPPORT -#define CHAP_MDTYPE_D(digest) \ - ((digest) == CHAP_MICROSOFT_V2)? MDTYPE_MICROSOFT_V2: \ - ((digest) == CHAP_MICROSOFT)? MDTYPE_MICROSOFT: \ - ((digest) == CHAP_MD5)? MDTYPE_MD5: \ - 0 -#else /* !MSCHAP_SUPPORT */ -#define CHAP_MDTYPE_D(digest) \ - ((digest) == CHAP_MD5)? MDTYPE_MD5: \ - 0 -#endif /* MSCHAP_SUPPORT */ - -/* Can we do the requested digest? */ -#if MSCHAP_SUPPORT -#define CHAP_CANDIGEST(mdtype, digest) \ - ((digest) == CHAP_MICROSOFT_V2)? (mdtype) & MDTYPE_MICROSOFT_V2: \ - ((digest) == CHAP_MICROSOFT)? (mdtype) & MDTYPE_MICROSOFT: \ - ((digest) == CHAP_MD5)? (mdtype) & MDTYPE_MD5: \ - 0 -#else /* !MSCHAP_SUPPORT */ -#define CHAP_CANDIGEST(mdtype, digest) \ - ((digest) == CHAP_MD5)? (mdtype) & MDTYPE_MD5: \ - 0 -#endif /* MSCHAP_SUPPORT */ - -/* - * The code for each digest type has to supply one of these. - */ -struct chap_digest_type { - int code; - -#if PPP_SERVER - /* - * Note: challenge and response arguments below are formatted as - * a length byte followed by the actual challenge/response data. - */ - void (*generate_challenge)(ppp_pcb *pcb, unsigned char *challenge); - int (*verify_response)(ppp_pcb *pcb, int id, const char *name, - const unsigned char *secret, int secret_len, - const unsigned char *challenge, const unsigned char *response, - char *message, int message_space); -#endif /* PPP_SERVER */ - void (*make_response)(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, - const unsigned char *challenge, const char *secret, int secret_len, - unsigned char *priv); - int (*check_success)(ppp_pcb *pcb, unsigned char *pkt, int len, unsigned char *priv); - void (*handle_failure)(ppp_pcb *pcb, unsigned char *pkt, int len); -}; - -/* - * Each interface is described by chap structure. - */ -#if CHAP_SUPPORT -typedef struct chap_client_state { - u8_t flags; - const char *name; - const struct chap_digest_type *digest; - unsigned char priv[64]; /* private area for digest's use */ -} chap_client_state; - -#if PPP_SERVER -typedef struct chap_server_state { - u8_t flags; - u8_t id; - const char *name; - const struct chap_digest_type *digest; - int challenge_xmits; - int challenge_pktlen; - unsigned char challenge[CHAL_MAX_PKTLEN]; -} chap_server_state; -#endif /* PPP_SERVER */ -#endif /* CHAP_SUPPORT */ - -#if 0 /* UNUSED */ -/* Hook for a plugin to validate CHAP challenge */ -extern int (*chap_verify_hook)(char *name, char *ourname, int id, - const struct chap_digest_type *digest, - unsigned char *challenge, unsigned char *response, - char *message, int message_space); -#endif /* UNUSED */ - -#if PPP_SERVER -/* Called by authentication code to start authenticating the peer. */ -extern void chap_auth_peer(ppp_pcb *pcb, const char *our_name, int digest_code); -#endif /* PPP_SERVER */ - -/* Called by auth. code to start authenticating us to the peer. */ -extern void chap_auth_with_peer(ppp_pcb *pcb, const char *our_name, int digest_code); - -/* Represents the CHAP protocol to the main pppd code */ -extern const struct protent chap_protent; - -#ifdef __cplusplus -} -#endif - -#endif /* CHAP_H */ -#endif /* PPP_SUPPORT && CHAP_SUPPORT */ +/* + * chap-new.c - New CHAP implementation. + * + * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef CHAP_H +#define CHAP_H + +#include "ppp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * CHAP packets begin with a standard header with code, id, len (2 bytes). + */ +#define CHAP_HDRLEN 4 + +/* + * Values for the code field. + */ +#define CHAP_CHALLENGE 1 +#define CHAP_RESPONSE 2 +#define CHAP_SUCCESS 3 +#define CHAP_FAILURE 4 + +/* + * CHAP digest codes. + */ +#define CHAP_MD5 5 +#if MSCHAP_SUPPORT +#define CHAP_MICROSOFT 0x80 +#define CHAP_MICROSOFT_V2 0x81 +#endif /* MSCHAP_SUPPORT */ + +/* + * Semi-arbitrary limits on challenge and response fields. + */ +#define MAX_CHALLENGE_LEN 64 +#define MAX_RESPONSE_LEN 64 + +/* + * These limits apply to challenge and response packets we send. + * The +4 is the +1 that we actually need rounded up. + */ +#define CHAL_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_CHALLENGE_LEN + MAXNAMELEN) +#define RESP_MAX_PKTLEN (PPP_HDRLEN + CHAP_HDRLEN + 4 + MAX_RESPONSE_LEN + MAXNAMELEN) + +/* bitmask of supported algorithms */ +#if MSCHAP_SUPPORT +#define MDTYPE_MICROSOFT_V2 0x1 +#define MDTYPE_MICROSOFT 0x2 +#endif /* MSCHAP_SUPPORT */ +#define MDTYPE_MD5 0x4 +#define MDTYPE_NONE 0 + +#if MSCHAP_SUPPORT +/* Return the digest alg. ID for the most preferred digest type. */ +#define CHAP_DIGEST(mdtype) \ + ((mdtype) & MDTYPE_MD5)? CHAP_MD5: \ + ((mdtype) & MDTYPE_MICROSOFT_V2)? CHAP_MICROSOFT_V2: \ + ((mdtype) & MDTYPE_MICROSOFT)? CHAP_MICROSOFT: \ + 0 +#else /* !MSCHAP_SUPPORT */ +#define CHAP_DIGEST(mdtype) \ + ((mdtype) & MDTYPE_MD5)? CHAP_MD5: \ + 0 +#endif /* MSCHAP_SUPPORT */ + +/* Return the bit flag (lsb set) for our most preferred digest type. */ +#define CHAP_MDTYPE(mdtype) ((mdtype) ^ ((mdtype) - 1)) & (mdtype) + +/* Return the bit flag for a given digest algorithm ID. */ +#if MSCHAP_SUPPORT +#define CHAP_MDTYPE_D(digest) \ + ((digest) == CHAP_MICROSOFT_V2)? MDTYPE_MICROSOFT_V2: \ + ((digest) == CHAP_MICROSOFT)? MDTYPE_MICROSOFT: \ + ((digest) == CHAP_MD5)? MDTYPE_MD5: \ + 0 +#else /* !MSCHAP_SUPPORT */ +#define CHAP_MDTYPE_D(digest) \ + ((digest) == CHAP_MD5)? MDTYPE_MD5: \ + 0 +#endif /* MSCHAP_SUPPORT */ + +/* Can we do the requested digest? */ +#if MSCHAP_SUPPORT +#define CHAP_CANDIGEST(mdtype, digest) \ + ((digest) == CHAP_MICROSOFT_V2)? (mdtype) & MDTYPE_MICROSOFT_V2: \ + ((digest) == CHAP_MICROSOFT)? (mdtype) & MDTYPE_MICROSOFT: \ + ((digest) == CHAP_MD5)? (mdtype) & MDTYPE_MD5: \ + 0 +#else /* !MSCHAP_SUPPORT */ +#define CHAP_CANDIGEST(mdtype, digest) \ + ((digest) == CHAP_MD5)? (mdtype) & MDTYPE_MD5: \ + 0 +#endif /* MSCHAP_SUPPORT */ + +/* + * The code for each digest type has to supply one of these. + */ +struct chap_digest_type { + int code; + +#if PPP_SERVER + /* + * Note: challenge and response arguments below are formatted as + * a length byte followed by the actual challenge/response data. + */ + void (*generate_challenge)(ppp_pcb *pcb, unsigned char *challenge); + int (*verify_response)(ppp_pcb *pcb, int id, const char *name, + const unsigned char *secret, int secret_len, + const unsigned char *challenge, const unsigned char *response, + char *message, int message_space); +#endif /* PPP_SERVER */ + void (*make_response)(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, + const unsigned char *challenge, const char *secret, int secret_len, + unsigned char *priv); + int (*check_success)(ppp_pcb *pcb, unsigned char *pkt, int len, unsigned char *priv); + void (*handle_failure)(ppp_pcb *pcb, unsigned char *pkt, int len); +}; + +/* + * Each interface is described by chap structure. + */ +#if CHAP_SUPPORT +typedef struct chap_client_state { + u8_t flags; + const char *name; + const struct chap_digest_type *digest; + unsigned char priv[64]; /* private area for digest's use */ +} chap_client_state; + +#if PPP_SERVER +typedef struct chap_server_state { + u8_t flags; + u8_t id; + const char *name; + const struct chap_digest_type *digest; + int challenge_xmits; + int challenge_pktlen; + unsigned char challenge[CHAL_MAX_PKTLEN]; +} chap_server_state; +#endif /* PPP_SERVER */ +#endif /* CHAP_SUPPORT */ + +#if 0 /* UNUSED */ +/* Hook for a plugin to validate CHAP challenge */ +extern int (*chap_verify_hook)(char *name, char *ourname, int id, + const struct chap_digest_type *digest, + unsigned char *challenge, unsigned char *response, + char *message, int message_space); +#endif /* UNUSED */ + +#if PPP_SERVER +/* Called by authentication code to start authenticating the peer. */ +extern void chap_auth_peer(ppp_pcb *pcb, const char *our_name, int digest_code); +#endif /* PPP_SERVER */ + +/* Called by auth. code to start authenticating us to the peer. */ +extern void chap_auth_with_peer(ppp_pcb *pcb, const char *our_name, int digest_code); + +/* Represents the CHAP protocol to the main pppd code */ +extern const struct protent chap_protent; + +#ifdef __cplusplus +} +#endif + +#endif /* CHAP_H */ +#endif /* PPP_SUPPORT && CHAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap_ms.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap_ms.h index ed52b404..07952911 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap_ms.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/chap_ms.h @@ -1,44 +1,44 @@ -/* - * chap_ms.h - Challenge Handshake Authentication Protocol definitions. - * - * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: chap_ms.h,v 1.13 2004/11/15 22:13:26 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && MSCHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef CHAPMS_INCLUDE -#define CHAPMS_INCLUDE - -extern const struct chap_digest_type chapms_digest; -extern const struct chap_digest_type chapms2_digest; - -#endif /* CHAPMS_INCLUDE */ - -#endif /* PPP_SUPPORT && MSCHAP_SUPPORT */ +/* + * chap_ms.h - Challenge Handshake Authentication Protocol definitions. + * + * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: chap_ms.h,v 1.13 2004/11/15 22:13:26 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && MSCHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef CHAPMS_INCLUDE +#define CHAPMS_INCLUDE + +extern const struct chap_digest_type chapms_digest; +extern const struct chap_digest_type chapms2_digest; + +#endif /* CHAPMS_INCLUDE */ + +#endif /* PPP_SUPPORT && MSCHAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eap.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eap.h index 61efdafe..3ee9aaf8 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eap.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eap.h @@ -1,169 +1,169 @@ -/* - * eap.h - Extensible Authentication Protocol for PPP (RFC 2284) - * - * Copyright (c) 2001 by Sun Microsystems, Inc. - * All rights reserved. - * - * Non-exclusive rights to redistribute, modify, translate, and use - * this software in source and binary forms, in whole or in part, is - * hereby granted, provided that the above copyright notice is - * duplicated in any source form, and that neither the name of the - * copyright holder nor the author is used to endorse or promote - * products derived from this software. - * - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. - * - * Original version by James Carlson - * - * $Id: eap.h,v 1.2 2003/06/11 23:56:26 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && EAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef PPP_EAP_H -#define PPP_EAP_H - -#include "ppp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Packet header = Code, id, length. - */ -#define EAP_HEADERLEN 4 - - -/* EAP message codes. */ -#define EAP_REQUEST 1 -#define EAP_RESPONSE 2 -#define EAP_SUCCESS 3 -#define EAP_FAILURE 4 - -/* EAP types */ -#define EAPT_IDENTITY 1 -#define EAPT_NOTIFICATION 2 -#define EAPT_NAK 3 /* (response only) */ -#define EAPT_MD5CHAP 4 -#define EAPT_OTP 5 /* One-Time Password; RFC 1938 */ -#define EAPT_TOKEN 6 /* Generic Token Card */ -/* 7 and 8 are unassigned. */ -#define EAPT_RSA 9 /* RSA Public Key Authentication */ -#define EAPT_DSS 10 /* DSS Unilateral */ -#define EAPT_KEA 11 /* KEA */ -#define EAPT_KEA_VALIDATE 12 /* KEA-VALIDATE */ -#define EAPT_TLS 13 /* EAP-TLS */ -#define EAPT_DEFENDER 14 /* Defender Token (AXENT) */ -#define EAPT_W2K 15 /* Windows 2000 EAP */ -#define EAPT_ARCOT 16 /* Arcot Systems */ -#define EAPT_CISCOWIRELESS 17 /* Cisco Wireless */ -#define EAPT_NOKIACARD 18 /* Nokia IP smart card */ -#define EAPT_SRP 19 /* Secure Remote Password */ -/* 20 is deprecated */ - -/* EAP SRP-SHA1 Subtypes */ -#define EAPSRP_CHALLENGE 1 /* Request 1 - Challenge */ -#define EAPSRP_CKEY 1 /* Response 1 - Client Key */ -#define EAPSRP_SKEY 2 /* Request 2 - Server Key */ -#define EAPSRP_CVALIDATOR 2 /* Response 2 - Client Validator */ -#define EAPSRP_SVALIDATOR 3 /* Request 3 - Server Validator */ -#define EAPSRP_ACK 3 /* Response 3 - final ack */ -#define EAPSRP_LWRECHALLENGE 4 /* Req/resp 4 - Lightweight rechal */ - -#define SRPVAL_EBIT 0x00000001 /* Use shared key for ECP */ - -#define SRP_PSEUDO_ID "pseudo_" -#define SRP_PSEUDO_LEN 7 - -#define MD5_SIGNATURE_SIZE 16 -#define EAP_MIN_CHALLENGE_LENGTH 17 -#define EAP_MAX_CHALLENGE_LENGTH 24 -#define EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH 3 /* 2^3-1 = 7, 17+7 = 24 */ - -#define EAP_STATES \ - "Initial", "Pending", "Closed", "Listen", "Identify", \ - "SRP1", "SRP2", "SRP3", "MD5Chall", "Open", "SRP4", "BadAuth" - -#define eap_client_active(pcb) ((pcb)->eap.es_client.ea_state == eapListen) -#if PPP_SERVER -#define eap_server_active(pcb) \ - ((pcb)->eap.es_server.ea_state >= eapIdentify && \ - (pcb)->eap.es_server.ea_state <= eapMD5Chall) -#endif /* PPP_SERVER */ - -/* - * Complete EAP state for one PPP session. - */ -enum eap_state_code { - eapInitial = 0, /* No EAP authentication yet requested */ - eapPending, /* Waiting for LCP (no timer) */ - eapClosed, /* Authentication not in use */ - eapListen, /* Client ready (and timer running) */ - eapIdentify, /* EAP Identify sent */ - eapSRP1, /* Sent EAP SRP-SHA1 Subtype 1 */ - eapSRP2, /* Sent EAP SRP-SHA1 Subtype 2 */ - eapSRP3, /* Sent EAP SRP-SHA1 Subtype 3 */ - eapMD5Chall, /* Sent MD5-Challenge */ - eapOpen, /* Completed authentication */ - eapSRP4, /* Sent EAP SRP-SHA1 Subtype 4 */ - eapBadAuth /* Failed authentication */ -}; - -struct eap_auth { - const char *ea_name; /* Our name */ - char ea_peer[MAXNAMELEN +1]; /* Peer's name */ - void *ea_session; /* Authentication library linkage */ - u_char *ea_skey; /* Shared encryption key */ - u_short ea_namelen; /* Length of our name */ - u_short ea_peerlen; /* Length of peer's name */ - enum eap_state_code ea_state; - u_char ea_id; /* Current id */ - u_char ea_requests; /* Number of Requests sent/received */ - u_char ea_responses; /* Number of Responses */ - u_char ea_type; /* One of EAPT_* */ - u32_t ea_keyflags; /* SRP shared key usage flags */ -}; - -#ifndef EAP_MAX_CHALLENGE_LENGTH -#define EAP_MAX_CHALLENGE_LENGTH 24 -#endif -typedef struct eap_state { - struct eap_auth es_client; /* Client (authenticatee) data */ -#if PPP_SERVER - struct eap_auth es_server; /* Server (authenticator) data */ -#endif /* PPP_SERVER */ - int es_savedtime; /* Saved timeout */ - int es_rechallenge; /* EAP rechallenge interval */ - int es_lwrechallenge; /* SRP lightweight rechallenge inter */ - u8_t es_usepseudo; /* Use SRP Pseudonym if offered one */ - int es_usedpseudo; /* Set if we already sent PN */ - int es_challen; /* Length of challenge string */ - u_char es_challenge[EAP_MAX_CHALLENGE_LENGTH]; -} eap_state; - -/* - * Timeouts. - */ -#if 0 /* moved to ppp_opts.h */ -#define EAP_DEFTIMEOUT 3 /* Timeout (seconds) for rexmit */ -#define EAP_DEFTRANSMITS 10 /* max # times to transmit */ -#define EAP_DEFREQTIME 20 /* Time to wait for peer request */ -#define EAP_DEFALLOWREQ 20 /* max # times to accept requests */ -#endif /* moved to ppp_opts.h */ - -void eap_authwithpeer(ppp_pcb *pcb, const char *localname); -void eap_authpeer(ppp_pcb *pcb, const char *localname); - -extern const struct protent eap_protent; - -#ifdef __cplusplus -} -#endif - -#endif /* PPP_EAP_H */ - -#endif /* PPP_SUPPORT && EAP_SUPPORT */ +/* + * eap.h - Extensible Authentication Protocol for PPP (RFC 2284) + * + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + * + * Non-exclusive rights to redistribute, modify, translate, and use + * this software in source and binary forms, in whole or in part, is + * hereby granted, provided that the above copyright notice is + * duplicated in any source form, and that neither the name of the + * copyright holder nor the author is used to endorse or promote + * products derived from this software. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Original version by James Carlson + * + * $Id: eap.h,v 1.2 2003/06/11 23:56:26 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && EAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef PPP_EAP_H +#define PPP_EAP_H + +#include "ppp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Packet header = Code, id, length. + */ +#define EAP_HEADERLEN 4 + + +/* EAP message codes. */ +#define EAP_REQUEST 1 +#define EAP_RESPONSE 2 +#define EAP_SUCCESS 3 +#define EAP_FAILURE 4 + +/* EAP types */ +#define EAPT_IDENTITY 1 +#define EAPT_NOTIFICATION 2 +#define EAPT_NAK 3 /* (response only) */ +#define EAPT_MD5CHAP 4 +#define EAPT_OTP 5 /* One-Time Password; RFC 1938 */ +#define EAPT_TOKEN 6 /* Generic Token Card */ +/* 7 and 8 are unassigned. */ +#define EAPT_RSA 9 /* RSA Public Key Authentication */ +#define EAPT_DSS 10 /* DSS Unilateral */ +#define EAPT_KEA 11 /* KEA */ +#define EAPT_KEA_VALIDATE 12 /* KEA-VALIDATE */ +#define EAPT_TLS 13 /* EAP-TLS */ +#define EAPT_DEFENDER 14 /* Defender Token (AXENT) */ +#define EAPT_W2K 15 /* Windows 2000 EAP */ +#define EAPT_ARCOT 16 /* Arcot Systems */ +#define EAPT_CISCOWIRELESS 17 /* Cisco Wireless */ +#define EAPT_NOKIACARD 18 /* Nokia IP smart card */ +#define EAPT_SRP 19 /* Secure Remote Password */ +/* 20 is deprecated */ + +/* EAP SRP-SHA1 Subtypes */ +#define EAPSRP_CHALLENGE 1 /* Request 1 - Challenge */ +#define EAPSRP_CKEY 1 /* Response 1 - Client Key */ +#define EAPSRP_SKEY 2 /* Request 2 - Server Key */ +#define EAPSRP_CVALIDATOR 2 /* Response 2 - Client Validator */ +#define EAPSRP_SVALIDATOR 3 /* Request 3 - Server Validator */ +#define EAPSRP_ACK 3 /* Response 3 - final ack */ +#define EAPSRP_LWRECHALLENGE 4 /* Req/resp 4 - Lightweight rechal */ + +#define SRPVAL_EBIT 0x00000001 /* Use shared key for ECP */ + +#define SRP_PSEUDO_ID "pseudo_" +#define SRP_PSEUDO_LEN 7 + +#define MD5_SIGNATURE_SIZE 16 +#define EAP_MIN_CHALLENGE_LENGTH 17 +#define EAP_MAX_CHALLENGE_LENGTH 24 +#define EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH 3 /* 2^3-1 = 7, 17+7 = 24 */ + +#define EAP_STATES \ + "Initial", "Pending", "Closed", "Listen", "Identify", \ + "SRP1", "SRP2", "SRP3", "MD5Chall", "Open", "SRP4", "BadAuth" + +#define eap_client_active(pcb) ((pcb)->eap.es_client.ea_state == eapListen) +#if PPP_SERVER +#define eap_server_active(pcb) \ + ((pcb)->eap.es_server.ea_state >= eapIdentify && \ + (pcb)->eap.es_server.ea_state <= eapMD5Chall) +#endif /* PPP_SERVER */ + +/* + * Complete EAP state for one PPP session. + */ +enum eap_state_code { + eapInitial = 0, /* No EAP authentication yet requested */ + eapPending, /* Waiting for LCP (no timer) */ + eapClosed, /* Authentication not in use */ + eapListen, /* Client ready (and timer running) */ + eapIdentify, /* EAP Identify sent */ + eapSRP1, /* Sent EAP SRP-SHA1 Subtype 1 */ + eapSRP2, /* Sent EAP SRP-SHA1 Subtype 2 */ + eapSRP3, /* Sent EAP SRP-SHA1 Subtype 3 */ + eapMD5Chall, /* Sent MD5-Challenge */ + eapOpen, /* Completed authentication */ + eapSRP4, /* Sent EAP SRP-SHA1 Subtype 4 */ + eapBadAuth /* Failed authentication */ +}; + +struct eap_auth { + const char *ea_name; /* Our name */ + char ea_peer[MAXNAMELEN +1]; /* Peer's name */ + void *ea_session; /* Authentication library linkage */ + u_char *ea_skey; /* Shared encryption key */ + u_short ea_namelen; /* Length of our name */ + u_short ea_peerlen; /* Length of peer's name */ + enum eap_state_code ea_state; + u_char ea_id; /* Current id */ + u_char ea_requests; /* Number of Requests sent/received */ + u_char ea_responses; /* Number of Responses */ + u_char ea_type; /* One of EAPT_* */ + u32_t ea_keyflags; /* SRP shared key usage flags */ +}; + +#ifndef EAP_MAX_CHALLENGE_LENGTH +#define EAP_MAX_CHALLENGE_LENGTH 24 +#endif +typedef struct eap_state { + struct eap_auth es_client; /* Client (authenticatee) data */ +#if PPP_SERVER + struct eap_auth es_server; /* Server (authenticator) data */ +#endif /* PPP_SERVER */ + int es_savedtime; /* Saved timeout */ + int es_rechallenge; /* EAP rechallenge interval */ + int es_lwrechallenge; /* SRP lightweight rechallenge inter */ + u8_t es_usepseudo; /* Use SRP Pseudonym if offered one */ + int es_usedpseudo; /* Set if we already sent PN */ + int es_challen; /* Length of challenge string */ + u_char es_challenge[EAP_MAX_CHALLENGE_LENGTH]; +} eap_state; + +/* + * Timeouts. + */ +#if 0 /* moved to ppp_opts.h */ +#define EAP_DEFTIMEOUT 3 /* Timeout (seconds) for rexmit */ +#define EAP_DEFTRANSMITS 10 /* max # times to transmit */ +#define EAP_DEFREQTIME 20 /* Time to wait for peer request */ +#define EAP_DEFALLOWREQ 20 /* max # times to accept requests */ +#endif /* moved to ppp_opts.h */ + +void eap_authwithpeer(ppp_pcb *pcb, const char *localname); +void eap_authpeer(ppp_pcb *pcb, const char *localname); + +extern const struct protent eap_protent; + +#ifdef __cplusplus +} +#endif + +#endif /* PPP_EAP_H */ + +#endif /* PPP_SUPPORT && EAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ecp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ecp.h index 8be18726..d8808c3a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ecp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ecp.h @@ -1,62 +1,62 @@ -/* - * ecp.h - Definitions for PPP Encryption Control Protocol. - * - * Copyright (c) 2002 Google, Inc. - * 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: ecp.h,v 1.2 2003/01/10 07:12:36 fcusack Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && ECP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef ECP_H -#define ECP_H - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct ecp_options { - bool required; /* Is ECP required? */ - unsigned enctype; /* Encryption type */ -} ecp_options; - -extern fsm ecp_fsm[]; -extern ecp_options ecp_wantoptions[]; -extern ecp_options ecp_gotoptions[]; -extern ecp_options ecp_allowoptions[]; -extern ecp_options ecp_hisoptions[]; - -extern const struct protent ecp_protent; - -#ifdef __cplusplus -} -#endif - -#endif /* ECP_H */ -#endif /* PPP_SUPPORT && ECP_SUPPORT */ +/* + * ecp.h - Definitions for PPP Encryption Control Protocol. + * + * Copyright (c) 2002 Google, Inc. + * 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: ecp.h,v 1.2 2003/01/10 07:12:36 fcusack Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && ECP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef ECP_H +#define ECP_H + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct ecp_options { + bool required; /* Is ECP required? */ + unsigned enctype; /* Encryption type */ +} ecp_options; + +extern fsm ecp_fsm[]; +extern ecp_options ecp_wantoptions[]; +extern ecp_options ecp_gotoptions[]; +extern ecp_options ecp_allowoptions[]; +extern ecp_options ecp_hisoptions[]; + +extern const struct protent ecp_protent; + +#ifdef __cplusplus +} +#endif + +#endif /* ECP_H */ +#endif /* PPP_SUPPORT && ECP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eui64.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eui64.h index ad199ead..5adeb482 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eui64.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/eui64.h @@ -1,102 +1,102 @@ -/* - * eui64.h - EUI64 routines for IPv6CP. - * - * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Tommi Komulainen - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: eui64.h,v 1.6 2002/12/04 23:03:32 paulus Exp $ -*/ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef EUI64_H -#define EUI64_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * @todo: - * - * Maybe this should be done by processing struct in6_addr directly... - */ -typedef union -{ - u8_t e8[8]; - u16_t e16[4]; - u32_t e32[2]; -} eui64_t; - -#define eui64_iszero(e) (((e).e32[0] | (e).e32[1]) == 0) -#define eui64_equals(e, o) (((e).e32[0] == (o).e32[0]) && \ - ((e).e32[1] == (o).e32[1])) -#define eui64_zero(e) (e).e32[0] = (e).e32[1] = 0; - -#define eui64_copy(s, d) memcpy(&(d), &(s), sizeof(eui64_t)) - -#define eui64_magic(e) do { \ - (e).e32[0] = magic(); \ - (e).e32[1] = magic(); \ - (e).e8[0] &= ~2; \ - } while (0) -#define eui64_magic_nz(x) do { \ - eui64_magic(x); \ - } while (eui64_iszero(x)) -#define eui64_magic_ne(x, y) do { \ - eui64_magic(x); \ - } while (eui64_equals(x, y)) - -#define eui64_get(ll, cp) do { \ - eui64_copy((*cp), (ll)); \ - (cp) += sizeof(eui64_t); \ - } while (0) - -#define eui64_put(ll, cp) do { \ - eui64_copy((ll), (*cp)); \ - (cp) += sizeof(eui64_t); \ - } while (0) - -#define eui64_set32(e, l) do { \ - (e).e32[0] = 0; \ - (e).e32[1] = lwip_htonl(l); \ - } while (0) -#define eui64_setlo32(e, l) eui64_set32(e, l) - -char *eui64_ntoa(eui64_t); /* Returns ascii representation of id */ - -#ifdef __cplusplus -} -#endif - -#endif /* EUI64_H */ -#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ +/* + * eui64.h - EUI64 routines for IPv6CP. + * + * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Tommi Komulainen + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: eui64.h,v 1.6 2002/12/04 23:03:32 paulus Exp $ +*/ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef EUI64_H +#define EUI64_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * @todo: + * + * Maybe this should be done by processing struct in6_addr directly... + */ +typedef union +{ + u8_t e8[8]; + u16_t e16[4]; + u32_t e32[2]; +} eui64_t; + +#define eui64_iszero(e) (((e).e32[0] | (e).e32[1]) == 0) +#define eui64_equals(e, o) (((e).e32[0] == (o).e32[0]) && \ + ((e).e32[1] == (o).e32[1])) +#define eui64_zero(e) (e).e32[0] = (e).e32[1] = 0; + +#define eui64_copy(s, d) memcpy(&(d), &(s), sizeof(eui64_t)) + +#define eui64_magic(e) do { \ + (e).e32[0] = magic(); \ + (e).e32[1] = magic(); \ + (e).e8[0] &= ~2; \ + } while (0) +#define eui64_magic_nz(x) do { \ + eui64_magic(x); \ + } while (eui64_iszero(x)) +#define eui64_magic_ne(x, y) do { \ + eui64_magic(x); \ + } while (eui64_equals(x, y)) + +#define eui64_get(ll, cp) do { \ + eui64_copy((*cp), (ll)); \ + (cp) += sizeof(eui64_t); \ + } while (0) + +#define eui64_put(ll, cp) do { \ + eui64_copy((ll), (*cp)); \ + (cp) += sizeof(eui64_t); \ + } while (0) + +#define eui64_set32(e, l) do { \ + (e).e32[0] = 0; \ + (e).e32[1] = lwip_htonl(l); \ + } while (0) +#define eui64_setlo32(e, l) eui64_set32(e, l) + +char *eui64_ntoa(eui64_t); /* Returns ascii representation of id */ + +#ifdef __cplusplus +} +#endif + +#endif /* EUI64_H */ +#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/fsm.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/fsm.h index e91536d4..8dec700e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/fsm.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/fsm.h @@ -1,182 +1,182 @@ -/* - * fsm.h - {Link, IP} Control Protocol Finite State Machine definitions. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: fsm.h,v 1.10 2004/11/13 02:28:15 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef FSM_H -#define FSM_H - -#include "ppp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Packet header = Code, id, length. - */ -#define HEADERLEN 4 - - -/* - * CP (LCP, IPCP, etc.) codes. - */ -#define CONFREQ 1 /* Configuration Request */ -#define CONFACK 2 /* Configuration Ack */ -#define CONFNAK 3 /* Configuration Nak */ -#define CONFREJ 4 /* Configuration Reject */ -#define TERMREQ 5 /* Termination Request */ -#define TERMACK 6 /* Termination Ack */ -#define CODEREJ 7 /* Code Reject */ - - -/* - * Each FSM is described by an fsm structure and fsm callbacks. - */ -typedef struct fsm { - ppp_pcb *pcb; /* PPP Interface */ - const struct fsm_callbacks *callbacks; /* Callback routines */ - const char *term_reason; /* Reason for closing protocol */ - u8_t seen_ack; /* Have received valid Ack/Nak/Rej to Req */ - /* -- This is our only flag, we might use u_int :1 if we have more flags */ - u16_t protocol; /* Data Link Layer Protocol field value */ - u8_t state; /* State */ - u8_t flags; /* Contains option bits */ - u8_t id; /* Current id */ - u8_t reqid; /* Current request id */ - u8_t retransmits; /* Number of retransmissions left */ - u8_t nakloops; /* Number of nak loops since last ack */ - u8_t rnakloops; /* Number of naks received */ - u8_t maxnakloops; /* Maximum number of nak loops tolerated - (necessary because IPCP require a custom large max nak loops value) */ - u8_t term_reason_len; /* Length of term_reason */ -} fsm; - - -typedef struct fsm_callbacks { - void (*resetci) /* Reset our Configuration Information */ - (fsm *); - int (*cilen) /* Length of our Configuration Information */ - (fsm *); - void (*addci) /* Add our Configuration Information */ - (fsm *, u_char *, int *); - int (*ackci) /* ACK our Configuration Information */ - (fsm *, u_char *, int); - int (*nakci) /* NAK our Configuration Information */ - (fsm *, u_char *, int, int); - int (*rejci) /* Reject our Configuration Information */ - (fsm *, u_char *, int); - int (*reqci) /* Request peer's Configuration Information */ - (fsm *, u_char *, int *, int); - void (*up) /* Called when fsm reaches PPP_FSM_OPENED state */ - (fsm *); - void (*down) /* Called when fsm leaves PPP_FSM_OPENED state */ - (fsm *); - void (*starting) /* Called when we want the lower layer */ - (fsm *); - void (*finished) /* Called when we don't want the lower layer */ - (fsm *); - void (*protreject) /* Called when Protocol-Reject received */ - (int); - void (*retransmit) /* Retransmission is necessary */ - (fsm *); - int (*extcode) /* Called when unknown code received */ - (fsm *, int, int, u_char *, int); - const char *proto_name; /* String name for protocol (for messages) */ -} fsm_callbacks; - - -/* - * Link states. - */ -#define PPP_FSM_INITIAL 0 /* Down, hasn't been opened */ -#define PPP_FSM_STARTING 1 /* Down, been opened */ -#define PPP_FSM_CLOSED 2 /* Up, hasn't been opened */ -#define PPP_FSM_STOPPED 3 /* Open, waiting for down event */ -#define PPP_FSM_CLOSING 4 /* Terminating the connection, not open */ -#define PPP_FSM_STOPPING 5 /* Terminating, but open */ -#define PPP_FSM_REQSENT 6 /* We've sent a Config Request */ -#define PPP_FSM_ACKRCVD 7 /* We've received a Config Ack */ -#define PPP_FSM_ACKSENT 8 /* We've sent a Config Ack */ -#define PPP_FSM_OPENED 9 /* Connection available */ - - -/* - * Flags - indicate options controlling FSM operation - */ -#define OPT_PASSIVE 1 /* Don't die if we don't get a response */ -#define OPT_RESTART 2 /* Treat 2nd OPEN as DOWN, UP */ -#define OPT_SILENT 4 /* Wait for peer to speak first */ - - -/* - * Timeouts. - */ -#if 0 /* moved to ppp_opts.h */ -#define DEFTIMEOUT 3 /* Timeout time in seconds */ -#define DEFMAXTERMREQS 2 /* Maximum Terminate-Request transmissions */ -#define DEFMAXCONFREQS 10 /* Maximum Configure-Request transmissions */ -#define DEFMAXNAKLOOPS 5 /* Maximum number of nak loops */ -#endif /* moved to ppp_opts.h */ - - -/* - * Prototypes - */ -void fsm_init(fsm *f); -void fsm_lowerup(fsm *f); -void fsm_lowerdown(fsm *f); -void fsm_open(fsm *f); -void fsm_close(fsm *f, const char *reason); -void fsm_input(fsm *f, u_char *inpacket, int l); -void fsm_protreject(fsm *f); -void fsm_sdata(fsm *f, u_char code, u_char id, const u_char *data, int datalen); - -#ifdef __cplusplus -} -#endif - -#endif /* FSM_H */ -#endif /* PPP_SUPPORT */ +/* + * fsm.h - {Link, IP} Control Protocol Finite State Machine definitions. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: fsm.h,v 1.10 2004/11/13 02:28:15 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef FSM_H +#define FSM_H + +#include "ppp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Packet header = Code, id, length. + */ +#define HEADERLEN 4 + + +/* + * CP (LCP, IPCP, etc.) codes. + */ +#define CONFREQ 1 /* Configuration Request */ +#define CONFACK 2 /* Configuration Ack */ +#define CONFNAK 3 /* Configuration Nak */ +#define CONFREJ 4 /* Configuration Reject */ +#define TERMREQ 5 /* Termination Request */ +#define TERMACK 6 /* Termination Ack */ +#define CODEREJ 7 /* Code Reject */ + + +/* + * Each FSM is described by an fsm structure and fsm callbacks. + */ +typedef struct fsm { + ppp_pcb *pcb; /* PPP Interface */ + const struct fsm_callbacks *callbacks; /* Callback routines */ + const char *term_reason; /* Reason for closing protocol */ + u8_t seen_ack; /* Have received valid Ack/Nak/Rej to Req */ + /* -- This is our only flag, we might use u_int :1 if we have more flags */ + u16_t protocol; /* Data Link Layer Protocol field value */ + u8_t state; /* State */ + u8_t flags; /* Contains option bits */ + u8_t id; /* Current id */ + u8_t reqid; /* Current request id */ + u8_t retransmits; /* Number of retransmissions left */ + u8_t nakloops; /* Number of nak loops since last ack */ + u8_t rnakloops; /* Number of naks received */ + u8_t maxnakloops; /* Maximum number of nak loops tolerated + (necessary because IPCP require a custom large max nak loops value) */ + u8_t term_reason_len; /* Length of term_reason */ +} fsm; + + +typedef struct fsm_callbacks { + void (*resetci) /* Reset our Configuration Information */ + (fsm *); + int (*cilen) /* Length of our Configuration Information */ + (fsm *); + void (*addci) /* Add our Configuration Information */ + (fsm *, u_char *, int *); + int (*ackci) /* ACK our Configuration Information */ + (fsm *, u_char *, int); + int (*nakci) /* NAK our Configuration Information */ + (fsm *, u_char *, int, int); + int (*rejci) /* Reject our Configuration Information */ + (fsm *, u_char *, int); + int (*reqci) /* Request peer's Configuration Information */ + (fsm *, u_char *, int *, int); + void (*up) /* Called when fsm reaches PPP_FSM_OPENED state */ + (fsm *); + void (*down) /* Called when fsm leaves PPP_FSM_OPENED state */ + (fsm *); + void (*starting) /* Called when we want the lower layer */ + (fsm *); + void (*finished) /* Called when we don't want the lower layer */ + (fsm *); + void (*protreject) /* Called when Protocol-Reject received */ + (int); + void (*retransmit) /* Retransmission is necessary */ + (fsm *); + int (*extcode) /* Called when unknown code received */ + (fsm *, int, int, u_char *, int); + const char *proto_name; /* String name for protocol (for messages) */ +} fsm_callbacks; + + +/* + * Link states. + */ +#define PPP_FSM_INITIAL 0 /* Down, hasn't been opened */ +#define PPP_FSM_STARTING 1 /* Down, been opened */ +#define PPP_FSM_CLOSED 2 /* Up, hasn't been opened */ +#define PPP_FSM_STOPPED 3 /* Open, waiting for down event */ +#define PPP_FSM_CLOSING 4 /* Terminating the connection, not open */ +#define PPP_FSM_STOPPING 5 /* Terminating, but open */ +#define PPP_FSM_REQSENT 6 /* We've sent a Config Request */ +#define PPP_FSM_ACKRCVD 7 /* We've received a Config Ack */ +#define PPP_FSM_ACKSENT 8 /* We've sent a Config Ack */ +#define PPP_FSM_OPENED 9 /* Connection available */ + + +/* + * Flags - indicate options controlling FSM operation + */ +#define OPT_PASSIVE 1 /* Don't die if we don't get a response */ +#define OPT_RESTART 2 /* Treat 2nd OPEN as DOWN, UP */ +#define OPT_SILENT 4 /* Wait for peer to speak first */ + + +/* + * Timeouts. + */ +#if 0 /* moved to ppp_opts.h */ +#define DEFTIMEOUT 3 /* Timeout time in seconds */ +#define DEFMAXTERMREQS 2 /* Maximum Terminate-Request transmissions */ +#define DEFMAXCONFREQS 10 /* Maximum Configure-Request transmissions */ +#define DEFMAXNAKLOOPS 5 /* Maximum number of nak loops */ +#endif /* moved to ppp_opts.h */ + + +/* + * Prototypes + */ +void fsm_init(fsm *f); +void fsm_lowerup(fsm *f); +void fsm_lowerdown(fsm *f); +void fsm_open(fsm *f); +void fsm_close(fsm *f, const char *reason); +void fsm_input(fsm *f, u_char *inpacket, int l); +void fsm_protreject(fsm *f); +void fsm_sdata(fsm *f, u_char code, u_char id, const u_char *data, int datalen); + +#ifdef __cplusplus +} +#endif + +#endif /* FSM_H */ +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipcp.h index 1735158c..32fdd1c6 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipcp.h @@ -1,134 +1,134 @@ -/* - * ipcp.h - IP Control Protocol definitions. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: ipcp.h,v 1.14 2002/12/04 23:03:32 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPP_IPV4_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef IPCP_H -#define IPCP_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Options. - */ -#define CI_ADDRS 1 /* IP Addresses */ -#if VJ_SUPPORT -#define CI_COMPRESSTYPE 2 /* Compression Type */ -#endif /* VJ_SUPPORT */ -#define CI_ADDR 3 - -#if LWIP_DNS -#define CI_MS_DNS1 129 /* Primary DNS value */ -#define CI_MS_DNS2 131 /* Secondary DNS value */ -#endif /* LWIP_DNS */ -#if 0 /* UNUSED - WINS */ -#define CI_MS_WINS1 130 /* Primary WINS value */ -#define CI_MS_WINS2 132 /* Secondary WINS value */ -#endif /* UNUSED - WINS */ - -#if VJ_SUPPORT -#define MAX_STATES 16 /* from slcompress.h */ - -#define IPCP_VJMODE_OLD 1 /* "old" mode (option # = 0x0037) */ -#define IPCP_VJMODE_RFC1172 2 /* "old-rfc"mode (option # = 0x002d) */ -#define IPCP_VJMODE_RFC1332 3 /* "new-rfc"mode (option # = 0x002d, */ - /* maxslot and slot number compression) */ - -#define IPCP_VJ_COMP 0x002d /* current value for VJ compression option*/ -#define IPCP_VJ_COMP_OLD 0x0037 /* "old" (i.e, broken) value for VJ */ - /* compression option*/ -#endif /* VJ_SUPPORT */ - -typedef struct ipcp_options { - unsigned int neg_addr :1; /* Negotiate IP Address? */ - unsigned int old_addrs :1; /* Use old (IP-Addresses) option? */ - unsigned int req_addr :1; /* Ask peer to send IP address? */ -#if 0 /* UNUSED */ - unsigned int default_route :1; /* Assign default route through interface? */ - unsigned int replace_default_route :1; /* Replace default route through interface? */ -#endif /* UNUSED */ -#if 0 /* UNUSED - PROXY ARP */ - unsigned int proxy_arp :1; /* Make proxy ARP entry for peer? */ -#endif /* UNUSED - PROXY ARP */ -#if VJ_SUPPORT - unsigned int neg_vj :1; /* Van Jacobson Compression? */ - unsigned int old_vj :1; /* use old (short) form of VJ option? */ - unsigned int cflag :1; -#endif /* VJ_SUPPORT */ - unsigned int accept_local :1; /* accept peer's value for ouraddr */ - unsigned int accept_remote :1; /* accept peer's value for hisaddr */ -#if LWIP_DNS - unsigned int req_dns1 :1; /* Ask peer to send primary DNS address? */ - unsigned int req_dns2 :1; /* Ask peer to send secondary DNS address? */ -#endif /* LWIP_DNS */ - - u32_t ouraddr, hisaddr; /* Addresses in NETWORK BYTE ORDER */ -#if LWIP_DNS - u32_t dnsaddr[2]; /* Primary and secondary MS DNS entries */ -#endif /* LWIP_DNS */ -#if 0 /* UNUSED - WINS */ - u32_t winsaddr[2]; /* Primary and secondary MS WINS entries */ -#endif /* UNUSED - WINS */ - -#if VJ_SUPPORT - u16_t vj_protocol; /* protocol value to use in VJ option */ - u8_t maxslotindex; /* values for RFC1332 VJ compression neg. */ -#endif /* VJ_SUPPORT */ -} ipcp_options; - -#if 0 /* UNUSED, already defined by lwIP */ -char *ip_ntoa (u32_t); -#endif /* UNUSED, already defined by lwIP */ - -extern const struct protent ipcp_protent; - -#ifdef __cplusplus -} -#endif - -#endif /* IPCP_H */ -#endif /* PPP_SUPPORT && PPP_IPV4_SUPPORT */ +/* + * ipcp.h - IP Control Protocol definitions. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: ipcp.h,v 1.14 2002/12/04 23:03:32 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPP_IPV4_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef IPCP_H +#define IPCP_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Options. + */ +#define CI_ADDRS 1 /* IP Addresses */ +#if VJ_SUPPORT +#define CI_COMPRESSTYPE 2 /* Compression Type */ +#endif /* VJ_SUPPORT */ +#define CI_ADDR 3 + +#if LWIP_DNS +#define CI_MS_DNS1 129 /* Primary DNS value */ +#define CI_MS_DNS2 131 /* Secondary DNS value */ +#endif /* LWIP_DNS */ +#if 0 /* UNUSED - WINS */ +#define CI_MS_WINS1 130 /* Primary WINS value */ +#define CI_MS_WINS2 132 /* Secondary WINS value */ +#endif /* UNUSED - WINS */ + +#if VJ_SUPPORT +#define MAX_STATES 16 /* from slcompress.h */ + +#define IPCP_VJMODE_OLD 1 /* "old" mode (option # = 0x0037) */ +#define IPCP_VJMODE_RFC1172 2 /* "old-rfc"mode (option # = 0x002d) */ +#define IPCP_VJMODE_RFC1332 3 /* "new-rfc"mode (option # = 0x002d, */ + /* maxslot and slot number compression) */ + +#define IPCP_VJ_COMP 0x002d /* current value for VJ compression option*/ +#define IPCP_VJ_COMP_OLD 0x0037 /* "old" (i.e, broken) value for VJ */ + /* compression option*/ +#endif /* VJ_SUPPORT */ + +typedef struct ipcp_options { + unsigned int neg_addr :1; /* Negotiate IP Address? */ + unsigned int old_addrs :1; /* Use old (IP-Addresses) option? */ + unsigned int req_addr :1; /* Ask peer to send IP address? */ +#if 0 /* UNUSED */ + unsigned int default_route :1; /* Assign default route through interface? */ + unsigned int replace_default_route :1; /* Replace default route through interface? */ +#endif /* UNUSED */ +#if 0 /* UNUSED - PROXY ARP */ + unsigned int proxy_arp :1; /* Make proxy ARP entry for peer? */ +#endif /* UNUSED - PROXY ARP */ +#if VJ_SUPPORT + unsigned int neg_vj :1; /* Van Jacobson Compression? */ + unsigned int old_vj :1; /* use old (short) form of VJ option? */ + unsigned int cflag :1; +#endif /* VJ_SUPPORT */ + unsigned int accept_local :1; /* accept peer's value for ouraddr */ + unsigned int accept_remote :1; /* accept peer's value for hisaddr */ +#if LWIP_DNS + unsigned int req_dns1 :1; /* Ask peer to send primary DNS address? */ + unsigned int req_dns2 :1; /* Ask peer to send secondary DNS address? */ +#endif /* LWIP_DNS */ + + u32_t ouraddr, hisaddr; /* Addresses in NETWORK BYTE ORDER */ +#if LWIP_DNS + u32_t dnsaddr[2]; /* Primary and secondary MS DNS entries */ +#endif /* LWIP_DNS */ +#if 0 /* UNUSED - WINS */ + u32_t winsaddr[2]; /* Primary and secondary MS WINS entries */ +#endif /* UNUSED - WINS */ + +#if VJ_SUPPORT + u16_t vj_protocol; /* protocol value to use in VJ option */ + u8_t maxslotindex; /* values for RFC1332 VJ compression neg. */ +#endif /* VJ_SUPPORT */ +} ipcp_options; + +#if 0 /* UNUSED, already defined by lwIP */ +char *ip_ntoa (u32_t); +#endif /* UNUSED, already defined by lwIP */ + +extern const struct protent ipcp_protent; + +#ifdef __cplusplus +} +#endif + +#endif /* IPCP_H */ +#endif /* PPP_SUPPORT && PPP_IPV4_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipv6cp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipv6cp.h index 48b07153..90999738 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipv6cp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ipv6cp.h @@ -1,191 +1,191 @@ -/* - * ipv6cp.h - PPP IPV6 Control Protocol. - * - * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Tommi Komulainen - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - */ - -/* Original version, based on RFC2023 : - - Copyright (c) 1995, 1996, 1997 Francis.Dupont@inria.fr, INRIA Rocquencourt, - Alain.Durand@imag.fr, IMAG, - Jean-Luc.Richier@imag.fr, IMAG-LSR. - - Copyright (c) 1998, 1999 Francis.Dupont@inria.fr, GIE DYADE, - Alain.Durand@imag.fr, IMAG, - Jean-Luc.Richier@imag.fr, IMAG-LSR. - - Ce travail a été fait au sein du GIE DYADE (Groupement d'Intérêt - Économique ayant pour membres BULL S.A. et l'INRIA). - - Ce logiciel informatique est disponible aux conditions - usuelles dans la recherche, c'est-à-dire qu'il peut - être utilisé, copié, modifié, distribué à l'unique - condition que ce texte soit conservé afin que - l'origine de ce logiciel soit reconnue. - - Le nom de l'Institut National de Recherche en Informatique - et en Automatique (INRIA), de l'IMAG, ou d'une personne morale - ou physique ayant participé à l'élaboration de ce logiciel ne peut - être utilisé sans son accord préalable explicite. - - Ce logiciel est fourni tel quel sans aucune garantie, - support ou responsabilité d'aucune sorte. - Ce logiciel est dérivé de sources d'origine - "University of California at Berkeley" et - "Digital Equipment Corporation" couvertes par des copyrights. - - L'Institut d'Informatique et de Mathématiques Appliquées de Grenoble (IMAG) - est une fédération d'unités mixtes de recherche du CNRS, de l'Institut National - Polytechnique de Grenoble et de l'Université Joseph Fourier regroupant - sept laboratoires dont le laboratoire Logiciels, Systèmes, Réseaux (LSR). - - This work has been done in the context of GIE DYADE (joint R & D venture - between BULL S.A. and INRIA). - - This software is available with usual "research" terms - with the aim of retain credits of the software. - Permission to use, copy, modify and distribute this software for any - purpose and without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies, - and the name of INRIA, IMAG, or any contributor not be used in advertising - or publicity pertaining to this material without the prior explicit - permission. The software is provided "as is" without any - warranties, support or liabilities of any kind. - This software is derived from source code from - "University of California at Berkeley" and - "Digital Equipment Corporation" protected by copyrights. - - Grenoble's Institute of Computer Science and Applied Mathematics (IMAG) - is a federation of seven research units funded by the CNRS, National - Polytechnic Institute of Grenoble and University Joseph Fourier. - The research unit in Software, Systems, Networks (LSR) is member of IMAG. -*/ - -/* - * Derived from : - * - * - * ipcp.h - IP Control Protocol definitions. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: ipv6cp.h,v 1.7 2002/12/04 23:03:32 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef IPV6CP_H -#define IPV6CP_H - -#include "eui64.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Options. - */ -#define CI_IFACEID 1 /* Interface Identifier */ -#ifdef IPV6CP_COMP -#define CI_COMPRESSTYPE 2 /* Compression Type */ -#endif /* IPV6CP_COMP */ - -/* No compression types yet defined. - *#define IPV6CP_COMP 0x004f - */ -typedef struct ipv6cp_options { - unsigned int neg_ifaceid :1; /* Negotiate interface identifier? */ - unsigned int req_ifaceid :1; /* Ask peer to send interface identifier? */ - unsigned int accept_local :1; /* accept peer's value for iface id? */ - unsigned int opt_local :1; /* ourtoken set by option */ - unsigned int opt_remote :1; /* histoken set by option */ - unsigned int use_ip :1; /* use IP as interface identifier */ -#if 0 - unsigned int use_persistent :1; /* use uniquely persistent value for address */ -#endif -#ifdef IPV6CP_COMP - unsigned int neg_vj :1; /* Van Jacobson Compression? */ -#endif /* IPV6CP_COMP */ - -#ifdef IPV6CP_COMP - u_short vj_protocol; /* protocol value to use in VJ option */ -#endif /* IPV6CP_COMP */ - eui64_t ourid, hisid; /* Interface identifiers */ -} ipv6cp_options; - -extern const struct protent ipv6cp_protent; - -#ifdef __cplusplus -} -#endif - -#endif /* IPV6CP_H */ -#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ +/* + * ipv6cp.h - PPP IPV6 Control Protocol. + * + * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Tommi Komulainen + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +/* Original version, based on RFC2023 : + + Copyright (c) 1995, 1996, 1997 Francis.Dupont@inria.fr, INRIA Rocquencourt, + Alain.Durand@imag.fr, IMAG, + Jean-Luc.Richier@imag.fr, IMAG-LSR. + + Copyright (c) 1998, 1999 Francis.Dupont@inria.fr, GIE DYADE, + Alain.Durand@imag.fr, IMAG, + Jean-Luc.Richier@imag.fr, IMAG-LSR. + + Ce travail a été fait au sein du GIE DYADE (Groupement d'Intérêt + Économique ayant pour membres BULL S.A. et l'INRIA). + + Ce logiciel informatique est disponible aux conditions + usuelles dans la recherche, c'est-à-dire qu'il peut + être utilisé, copié, modifié, distribué à l'unique + condition que ce texte soit conservé afin que + l'origine de ce logiciel soit reconnue. + + Le nom de l'Institut National de Recherche en Informatique + et en Automatique (INRIA), de l'IMAG, ou d'une personne morale + ou physique ayant participé à l'élaboration de ce logiciel ne peut + être utilisé sans son accord préalable explicite. + + Ce logiciel est fourni tel quel sans aucune garantie, + support ou responsabilité d'aucune sorte. + Ce logiciel est dérivé de sources d'origine + "University of California at Berkeley" et + "Digital Equipment Corporation" couvertes par des copyrights. + + L'Institut d'Informatique et de Mathématiques Appliquées de Grenoble (IMAG) + est une fédération d'unités mixtes de recherche du CNRS, de l'Institut National + Polytechnique de Grenoble et de l'Université Joseph Fourier regroupant + sept laboratoires dont le laboratoire Logiciels, Systèmes, Réseaux (LSR). + + This work has been done in the context of GIE DYADE (joint R & D venture + between BULL S.A. and INRIA). + + This software is available with usual "research" terms + with the aim of retain credits of the software. + Permission to use, copy, modify and distribute this software for any + purpose and without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies, + and the name of INRIA, IMAG, or any contributor not be used in advertising + or publicity pertaining to this material without the prior explicit + permission. The software is provided "as is" without any + warranties, support or liabilities of any kind. + This software is derived from source code from + "University of California at Berkeley" and + "Digital Equipment Corporation" protected by copyrights. + + Grenoble's Institute of Computer Science and Applied Mathematics (IMAG) + is a federation of seven research units funded by the CNRS, National + Polytechnic Institute of Grenoble and University Joseph Fourier. + The research unit in Software, Systems, Networks (LSR) is member of IMAG. +*/ + +/* + * Derived from : + * + * + * ipcp.h - IP Control Protocol definitions. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: ipv6cp.h,v 1.7 2002/12/04 23:03:32 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef IPV6CP_H +#define IPV6CP_H + +#include "eui64.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Options. + */ +#define CI_IFACEID 1 /* Interface Identifier */ +#ifdef IPV6CP_COMP +#define CI_COMPRESSTYPE 2 /* Compression Type */ +#endif /* IPV6CP_COMP */ + +/* No compression types yet defined. + *#define IPV6CP_COMP 0x004f + */ +typedef struct ipv6cp_options { + unsigned int neg_ifaceid :1; /* Negotiate interface identifier? */ + unsigned int req_ifaceid :1; /* Ask peer to send interface identifier? */ + unsigned int accept_local :1; /* accept peer's value for iface id? */ + unsigned int opt_local :1; /* ourtoken set by option */ + unsigned int opt_remote :1; /* histoken set by option */ + unsigned int use_ip :1; /* use IP as interface identifier */ +#if 0 + unsigned int use_persistent :1; /* use uniquely persistent value for address */ +#endif +#ifdef IPV6CP_COMP + unsigned int neg_vj :1; /* Van Jacobson Compression? */ +#endif /* IPV6CP_COMP */ + +#ifdef IPV6CP_COMP + u_short vj_protocol; /* protocol value to use in VJ option */ +#endif /* IPV6CP_COMP */ + eui64_t ourid, hisid; /* Interface identifiers */ +} ipv6cp_options; + +extern const struct protent ipv6cp_protent; + +#ifdef __cplusplus +} +#endif + +#endif /* IPV6CP_H */ +#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/lcp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/lcp.h index 37d05482..18ad1cb2 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/lcp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/lcp.h @@ -1,179 +1,179 @@ -/* - * lcp.h - Link Control Protocol definitions. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: lcp.h,v 1.20 2004/11/14 22:53:42 carlsonj Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef LCP_H -#define LCP_H - -#include "ppp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Options. - */ -#define CI_VENDOR 0 /* Vendor Specific */ -#define CI_MRU 1 /* Maximum Receive Unit */ -#define CI_ASYNCMAP 2 /* Async Control Character Map */ -#define CI_AUTHTYPE 3 /* Authentication Type */ -#define CI_QUALITY 4 /* Quality Protocol */ -#define CI_MAGICNUMBER 5 /* Magic Number */ -#define CI_PCOMPRESSION 7 /* Protocol Field Compression */ -#define CI_ACCOMPRESSION 8 /* Address/Control Field Compression */ -#define CI_FCSALTERN 9 /* FCS-Alternatives */ -#define CI_SDP 10 /* Self-Describing-Pad */ -#define CI_NUMBERED 11 /* Numbered-Mode */ -#define CI_CALLBACK 13 /* callback */ -#define CI_MRRU 17 /* max reconstructed receive unit; multilink */ -#define CI_SSNHF 18 /* short sequence numbers for multilink */ -#define CI_EPDISC 19 /* endpoint discriminator */ -#define CI_MPPLUS 22 /* Multi-Link-Plus-Procedure */ -#define CI_LDISC 23 /* Link-Discriminator */ -#define CI_LCPAUTH 24 /* LCP Authentication */ -#define CI_COBS 25 /* Consistent Overhead Byte Stuffing */ -#define CI_PREFELIS 26 /* Prefix Elision */ -#define CI_MPHDRFMT 27 /* MP Header Format */ -#define CI_I18N 28 /* Internationalization */ -#define CI_SDL 29 /* Simple Data Link */ - -/* - * LCP-specific packet types (code numbers). - */ -#define PROTREJ 8 /* Protocol Reject */ -#define ECHOREQ 9 /* Echo Request */ -#define ECHOREP 10 /* Echo Reply */ -#define DISCREQ 11 /* Discard Request */ -#define IDENTIF 12 /* Identification */ -#define TIMEREM 13 /* Time Remaining */ - -/* Value used as data for CI_CALLBACK option */ -#define CBCP_OPT 6 /* Use callback control protocol */ - -#if 0 /* moved to ppp_opts.h */ -#define DEFMRU 1500 /* Try for this */ -#define MINMRU 128 /* No MRUs below this */ -#define MAXMRU 16384 /* Normally limit MRU to this */ -#endif /* moved to ppp_opts.h */ - -/* An endpoint discriminator, used with multilink. */ -#define MAX_ENDP_LEN 20 /* maximum length of discriminator value */ -struct epdisc { - unsigned char class_; /* -- The word "class" is reserved in C++. */ - unsigned char length; - unsigned char value[MAX_ENDP_LEN]; -}; - -/* - * The state of options is described by an lcp_options structure. - */ -typedef struct lcp_options { - unsigned int passive :1; /* Don't die if we don't get a response */ - unsigned int silent :1; /* Wait for the other end to start first */ -#if 0 /* UNUSED */ - unsigned int restart :1; /* Restart vs. exit after close */ -#endif /* UNUSED */ - unsigned int neg_mru :1; /* Negotiate the MRU? */ - unsigned int neg_asyncmap :1; /* Negotiate the async map? */ -#if PAP_SUPPORT - unsigned int neg_upap :1; /* Ask for UPAP authentication? */ -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - unsigned int neg_chap :1; /* Ask for CHAP authentication? */ -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - unsigned int neg_eap :1; /* Ask for EAP authentication? */ -#endif /* EAP_SUPPORT */ - unsigned int neg_magicnumber :1; /* Ask for magic number? */ - unsigned int neg_pcompression :1; /* HDLC Protocol Field Compression? */ - unsigned int neg_accompression :1; /* HDLC Address/Control Field Compression? */ -#if LQR_SUPPORT - unsigned int neg_lqr :1; /* Negotiate use of Link Quality Reports */ -#endif /* LQR_SUPPORT */ - unsigned int neg_cbcp :1; /* Negotiate use of CBCP */ -#ifdef HAVE_MULTILINK - unsigned int neg_mrru :1; /* negotiate multilink MRRU */ -#endif /* HAVE_MULTILINK */ - unsigned int neg_ssnhf :1; /* negotiate short sequence numbers */ - unsigned int neg_endpoint :1; /* negotiate endpoint discriminator */ - - u16_t mru; /* Value of MRU */ -#ifdef HAVE_MULTILINK - u16_t mrru; /* Value of MRRU, and multilink enable */ -#endif /* MULTILINK */ -#if CHAP_SUPPORT - u8_t chap_mdtype; /* which MD types (hashing algorithm) */ -#endif /* CHAP_SUPPORT */ - u32_t asyncmap; /* Value of async map */ - u32_t magicnumber; - u8_t numloops; /* Number of loops during magic number neg. */ -#if LQR_SUPPORT - u32_t lqr_period; /* Reporting period for LQR 1/100ths second */ -#endif /* LQR_SUPPORT */ - struct epdisc endpoint; /* endpoint discriminator */ -} lcp_options; - -void lcp_open(ppp_pcb *pcb); -void lcp_close(ppp_pcb *pcb, const char *reason); -void lcp_lowerup(ppp_pcb *pcb); -void lcp_lowerdown(ppp_pcb *pcb); -void lcp_sprotrej(ppp_pcb *pcb, u_char *p, int len); /* send protocol reject */ - -extern const struct protent lcp_protent; - -#if 0 /* moved to ppp_opts.h */ -/* Default number of times we receive our magic number from the peer - before deciding the link is looped-back. */ -#define DEFLOOPBACKFAIL 10 -#endif /* moved to ppp_opts.h */ - -#ifdef __cplusplus -} -#endif - -#endif /* LCP_H */ -#endif /* PPP_SUPPORT */ +/* + * lcp.h - Link Control Protocol definitions. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: lcp.h,v 1.20 2004/11/14 22:53:42 carlsonj Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef LCP_H +#define LCP_H + +#include "ppp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Options. + */ +#define CI_VENDOR 0 /* Vendor Specific */ +#define CI_MRU 1 /* Maximum Receive Unit */ +#define CI_ASYNCMAP 2 /* Async Control Character Map */ +#define CI_AUTHTYPE 3 /* Authentication Type */ +#define CI_QUALITY 4 /* Quality Protocol */ +#define CI_MAGICNUMBER 5 /* Magic Number */ +#define CI_PCOMPRESSION 7 /* Protocol Field Compression */ +#define CI_ACCOMPRESSION 8 /* Address/Control Field Compression */ +#define CI_FCSALTERN 9 /* FCS-Alternatives */ +#define CI_SDP 10 /* Self-Describing-Pad */ +#define CI_NUMBERED 11 /* Numbered-Mode */ +#define CI_CALLBACK 13 /* callback */ +#define CI_MRRU 17 /* max reconstructed receive unit; multilink */ +#define CI_SSNHF 18 /* short sequence numbers for multilink */ +#define CI_EPDISC 19 /* endpoint discriminator */ +#define CI_MPPLUS 22 /* Multi-Link-Plus-Procedure */ +#define CI_LDISC 23 /* Link-Discriminator */ +#define CI_LCPAUTH 24 /* LCP Authentication */ +#define CI_COBS 25 /* Consistent Overhead Byte Stuffing */ +#define CI_PREFELIS 26 /* Prefix Elision */ +#define CI_MPHDRFMT 27 /* MP Header Format */ +#define CI_I18N 28 /* Internationalization */ +#define CI_SDL 29 /* Simple Data Link */ + +/* + * LCP-specific packet types (code numbers). + */ +#define PROTREJ 8 /* Protocol Reject */ +#define ECHOREQ 9 /* Echo Request */ +#define ECHOREP 10 /* Echo Reply */ +#define DISCREQ 11 /* Discard Request */ +#define IDENTIF 12 /* Identification */ +#define TIMEREM 13 /* Time Remaining */ + +/* Value used as data for CI_CALLBACK option */ +#define CBCP_OPT 6 /* Use callback control protocol */ + +#if 0 /* moved to ppp_opts.h */ +#define DEFMRU 1500 /* Try for this */ +#define MINMRU 128 /* No MRUs below this */ +#define MAXMRU 16384 /* Normally limit MRU to this */ +#endif /* moved to ppp_opts.h */ + +/* An endpoint discriminator, used with multilink. */ +#define MAX_ENDP_LEN 20 /* maximum length of discriminator value */ +struct epdisc { + unsigned char class_; /* -- The word "class" is reserved in C++. */ + unsigned char length; + unsigned char value[MAX_ENDP_LEN]; +}; + +/* + * The state of options is described by an lcp_options structure. + */ +typedef struct lcp_options { + unsigned int passive :1; /* Don't die if we don't get a response */ + unsigned int silent :1; /* Wait for the other end to start first */ +#if 0 /* UNUSED */ + unsigned int restart :1; /* Restart vs. exit after close */ +#endif /* UNUSED */ + unsigned int neg_mru :1; /* Negotiate the MRU? */ + unsigned int neg_asyncmap :1; /* Negotiate the async map? */ +#if PAP_SUPPORT + unsigned int neg_upap :1; /* Ask for UPAP authentication? */ +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + unsigned int neg_chap :1; /* Ask for CHAP authentication? */ +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + unsigned int neg_eap :1; /* Ask for EAP authentication? */ +#endif /* EAP_SUPPORT */ + unsigned int neg_magicnumber :1; /* Ask for magic number? */ + unsigned int neg_pcompression :1; /* HDLC Protocol Field Compression? */ + unsigned int neg_accompression :1; /* HDLC Address/Control Field Compression? */ +#if LQR_SUPPORT + unsigned int neg_lqr :1; /* Negotiate use of Link Quality Reports */ +#endif /* LQR_SUPPORT */ + unsigned int neg_cbcp :1; /* Negotiate use of CBCP */ +#ifdef HAVE_MULTILINK + unsigned int neg_mrru :1; /* negotiate multilink MRRU */ +#endif /* HAVE_MULTILINK */ + unsigned int neg_ssnhf :1; /* negotiate short sequence numbers */ + unsigned int neg_endpoint :1; /* negotiate endpoint discriminator */ + + u16_t mru; /* Value of MRU */ +#ifdef HAVE_MULTILINK + u16_t mrru; /* Value of MRRU, and multilink enable */ +#endif /* MULTILINK */ +#if CHAP_SUPPORT + u8_t chap_mdtype; /* which MD types (hashing algorithm) */ +#endif /* CHAP_SUPPORT */ + u32_t asyncmap; /* Value of async map */ + u32_t magicnumber; + u8_t numloops; /* Number of loops during magic number neg. */ +#if LQR_SUPPORT + u32_t lqr_period; /* Reporting period for LQR 1/100ths second */ +#endif /* LQR_SUPPORT */ + struct epdisc endpoint; /* endpoint discriminator */ +} lcp_options; + +void lcp_open(ppp_pcb *pcb); +void lcp_close(ppp_pcb *pcb, const char *reason); +void lcp_lowerup(ppp_pcb *pcb); +void lcp_lowerdown(ppp_pcb *pcb); +void lcp_sprotrej(ppp_pcb *pcb, u_char *p, int len); /* send protocol reject */ + +extern const struct protent lcp_protent; + +#if 0 /* moved to ppp_opts.h */ +/* Default number of times we receive our magic number from the peer + before deciding the link is looped-back. */ +#define DEFLOOPBACKFAIL 10 +#endif /* moved to ppp_opts.h */ + +#ifdef __cplusplus +} +#endif + +#endif /* LCP_H */ +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/magic.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/magic.h index ffbd073f..a165e18f 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/magic.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/magic.h @@ -1,130 +1,130 @@ -/* - * magic.h - PPP Magic Number definitions. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: magic.h,v 1.5 2003/06/11 23:56:26 paulus Exp $ - */ -/***************************************************************************** -* randm.h - Random number generator header file. -* -* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. -* Copyright (c) 1998 Global Election Systems Inc. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY -* -* 03-01-01 Marc Boucher -* Ported to lwIP. -* 98-05-29 Guy Lancaster , Global Election Systems Inc. -* Extracted from avos. -*****************************************************************************/ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef MAGIC_H -#define MAGIC_H - -#ifdef __cplusplus -extern "C" { -#endif - -/*********************** -*** PUBLIC FUNCTIONS *** -***********************/ - -/* - * Initialize the random number generator. - */ -void magic_init(void); - -/* - * Randomize our random seed value. To be called for truely random events - * such as user operations and network traffic. - */ -void magic_randomize(void); - -/* - * Return a new random number. - */ -u32_t magic(void); /* Returns the next magic number */ - -/* - * Fill buffer with random bytes - * - * Use the random pool to generate random data. This degrades to pseudo - * random when used faster than randomness is supplied using magic_churnrand(). - * Thus it's important to make sure that the results of this are not - * published directly because one could predict the next result to at - * least some degree. Also, it's important to get a good seed before - * the first use. - */ -void magic_random_bytes(unsigned char *buf, u32_t buf_len); - -/* - * Return a new random number between 0 and (2^pow)-1 included. - */ -u32_t magic_pow(u8_t pow); - -#ifdef __cplusplus -} -#endif - -#endif /* MAGIC_H */ - -#endif /* PPP_SUPPORT */ +/* + * magic.h - PPP Magic Number definitions. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: magic.h,v 1.5 2003/06/11 23:56:26 paulus Exp $ + */ +/***************************************************************************** +* randm.h - Random number generator header file. +* +* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. +* Copyright (c) 1998 Global Election Systems Inc. +* +* The authors hereby grant permission to use, copy, modify, distribute, +* and license this software and its documentation for any purpose, provided +* that existing copyright notices are retained in all copies and that this +* notice and the following disclaimer are included verbatim in any +* distributions. No written agreement, license, or royalty fee is required +* for any of the authorized uses. +* +* THIS SOFTWARE IS PROVIDED BY THE 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 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. +* +****************************************************************************** +* REVISION HISTORY +* +* 03-01-01 Marc Boucher +* Ported to lwIP. +* 98-05-29 Guy Lancaster , Global Election Systems Inc. +* Extracted from avos. +*****************************************************************************/ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef MAGIC_H +#define MAGIC_H + +#ifdef __cplusplus +extern "C" { +#endif + +/*********************** +*** PUBLIC FUNCTIONS *** +***********************/ + +/* + * Initialize the random number generator. + */ +void magic_init(void); + +/* + * Randomize our random seed value. To be called for truely random events + * such as user operations and network traffic. + */ +void magic_randomize(void); + +/* + * Return a new random number. + */ +u32_t magic(void); /* Returns the next magic number */ + +/* + * Fill buffer with random bytes + * + * Use the random pool to generate random data. This degrades to pseudo + * random when used faster than randomness is supplied using magic_churnrand(). + * Thus it's important to make sure that the results of this are not + * published directly because one could predict the next result to at + * least some degree. Also, it's important to get a good seed before + * the first use. + */ +void magic_random_bytes(unsigned char *buf, u32_t buf_len); + +/* + * Return a new random number between 0 and (2^pow)-1 included. + */ +u32_t magic_pow(u8_t pow); + +#ifdef __cplusplus +} +#endif + +#endif /* MAGIC_H */ + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/mppe.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/mppe.h index 4f504fb0..5de11284 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/mppe.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/mppe.h @@ -1,181 +1,181 @@ -/* - * mppe.h - Definitions for MPPE - * - * Copyright (c) 2008 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && MPPE_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef MPPE_H -#define MPPE_H - -#include "netif/ppp/pppcrypt.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define MPPE_PAD 4 /* MPPE growth per frame */ -#define MPPE_MAX_KEY_LEN 16 /* largest key length (128-bit) */ - -/* option bits for ccp_options.mppe */ -#define MPPE_OPT_40 0x01 /* 40 bit */ -#define MPPE_OPT_128 0x02 /* 128 bit */ -#define MPPE_OPT_STATEFUL 0x04 /* stateful mode */ -/* unsupported opts */ -#define MPPE_OPT_56 0x08 /* 56 bit */ -#define MPPE_OPT_MPPC 0x10 /* MPPC compression */ -#define MPPE_OPT_D 0x20 /* Unknown */ -#define MPPE_OPT_UNSUPPORTED (MPPE_OPT_56|MPPE_OPT_MPPC|MPPE_OPT_D) -#define MPPE_OPT_UNKNOWN 0x40 /* Bits !defined in RFC 3078 were set */ - -/* - * This is not nice ... the alternative is a bitfield struct though. - * And unfortunately, we cannot share the same bits for the option - * names above since C and H are the same bit. We could do a u_int32 - * but then we have to do a lwip_htonl() all the time and/or we still need - * to know which octet is which. - */ -#define MPPE_C_BIT 0x01 /* MPPC */ -#define MPPE_D_BIT 0x10 /* Obsolete, usage unknown */ -#define MPPE_L_BIT 0x20 /* 40-bit */ -#define MPPE_S_BIT 0x40 /* 128-bit */ -#define MPPE_M_BIT 0x80 /* 56-bit, not supported */ -#define MPPE_H_BIT 0x01 /* Stateless (in a different byte) */ - -/* Does not include H bit; used for least significant octet only. */ -#define MPPE_ALL_BITS (MPPE_D_BIT|MPPE_L_BIT|MPPE_S_BIT|MPPE_M_BIT|MPPE_H_BIT) - -/* Build a CI from mppe opts (see RFC 3078) */ -#define MPPE_OPTS_TO_CI(opts, ci) \ - do { \ - u_char *ptr = ci; /* u_char[4] */ \ - \ - /* H bit */ \ - if (opts & MPPE_OPT_STATEFUL) \ - *ptr++ = 0x0; \ - else \ - *ptr++ = MPPE_H_BIT; \ - *ptr++ = 0; \ - *ptr++ = 0; \ - \ - /* S,L bits */ \ - *ptr = 0; \ - if (opts & MPPE_OPT_128) \ - *ptr |= MPPE_S_BIT; \ - if (opts & MPPE_OPT_40) \ - *ptr |= MPPE_L_BIT; \ - /* M,D,C bits not supported */ \ - } while (/* CONSTCOND */ 0) - -/* The reverse of the above */ -#define MPPE_CI_TO_OPTS(ci, opts) \ - do { \ - const u_char *ptr = ci; /* u_char[4] */ \ - \ - opts = 0; \ - \ - /* H bit */ \ - if (!(ptr[0] & MPPE_H_BIT)) \ - opts |= MPPE_OPT_STATEFUL; \ - \ - /* S,L bits */ \ - if (ptr[3] & MPPE_S_BIT) \ - opts |= MPPE_OPT_128; \ - if (ptr[3] & MPPE_L_BIT) \ - opts |= MPPE_OPT_40; \ - \ - /* M,D,C bits */ \ - if (ptr[3] & MPPE_M_BIT) \ - opts |= MPPE_OPT_56; \ - if (ptr[3] & MPPE_D_BIT) \ - opts |= MPPE_OPT_D; \ - if (ptr[3] & MPPE_C_BIT) \ - opts |= MPPE_OPT_MPPC; \ - \ - /* Other bits */ \ - if (ptr[0] & ~MPPE_H_BIT) \ - opts |= MPPE_OPT_UNKNOWN; \ - if (ptr[1] || ptr[2]) \ - opts |= MPPE_OPT_UNKNOWN; \ - if (ptr[3] & ~MPPE_ALL_BITS) \ - opts |= MPPE_OPT_UNKNOWN; \ - } while (/* CONSTCOND */ 0) - -/* Shared MPPE padding between MSCHAP and MPPE */ -#define SHA1_PAD_SIZE 40 - -static const u8_t mppe_sha1_pad1[SHA1_PAD_SIZE] = { - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, - 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 -}; -static const u8_t mppe_sha1_pad2[SHA1_PAD_SIZE] = { - 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, - 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, - 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, - 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2 -}; - -/* - * State for an MPPE (de)compressor. - */ -typedef struct ppp_mppe_state { - lwip_arc4_context arc4; - u8_t master_key[MPPE_MAX_KEY_LEN]; - u8_t session_key[MPPE_MAX_KEY_LEN]; - u8_t keylen; /* key length in bytes */ - /* NB: 128-bit == 16, 40-bit == 8! - * If we want to support 56-bit, the unit has to change to bits - */ - u8_t bits; /* MPPE control bits */ - u16_t ccount; /* 12-bit coherency count (seqno) */ - u16_t sanity_errors; /* take down LCP if too many */ - unsigned int stateful :1; /* stateful mode flag */ - unsigned int discard :1; /* stateful mode packet loss flag */ -} ppp_mppe_state; - -void mppe_set_key(ppp_pcb *pcb, ppp_mppe_state *state, u8_t *key); -void mppe_init(ppp_pcb *pcb, ppp_mppe_state *state, u8_t options); -void mppe_comp_reset(ppp_pcb *pcb, ppp_mppe_state *state); -err_t mppe_compress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb, u16_t protocol); -void mppe_decomp_reset(ppp_pcb *pcb, ppp_mppe_state *state); -err_t mppe_decompress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb); - -#ifdef __cplusplus -} -#endif - -#endif /* MPPE_H */ -#endif /* PPP_SUPPORT && MPPE_SUPPORT */ +/* + * mppe.h - Definitions for MPPE + * + * Copyright (c) 2008 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && MPPE_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef MPPE_H +#define MPPE_H + +#include "netif/ppp/pppcrypt.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MPPE_PAD 4 /* MPPE growth per frame */ +#define MPPE_MAX_KEY_LEN 16 /* largest key length (128-bit) */ + +/* option bits for ccp_options.mppe */ +#define MPPE_OPT_40 0x01 /* 40 bit */ +#define MPPE_OPT_128 0x02 /* 128 bit */ +#define MPPE_OPT_STATEFUL 0x04 /* stateful mode */ +/* unsupported opts */ +#define MPPE_OPT_56 0x08 /* 56 bit */ +#define MPPE_OPT_MPPC 0x10 /* MPPC compression */ +#define MPPE_OPT_D 0x20 /* Unknown */ +#define MPPE_OPT_UNSUPPORTED (MPPE_OPT_56|MPPE_OPT_MPPC|MPPE_OPT_D) +#define MPPE_OPT_UNKNOWN 0x40 /* Bits !defined in RFC 3078 were set */ + +/* + * This is not nice ... the alternative is a bitfield struct though. + * And unfortunately, we cannot share the same bits for the option + * names above since C and H are the same bit. We could do a u_int32 + * but then we have to do a lwip_htonl() all the time and/or we still need + * to know which octet is which. + */ +#define MPPE_C_BIT 0x01 /* MPPC */ +#define MPPE_D_BIT 0x10 /* Obsolete, usage unknown */ +#define MPPE_L_BIT 0x20 /* 40-bit */ +#define MPPE_S_BIT 0x40 /* 128-bit */ +#define MPPE_M_BIT 0x80 /* 56-bit, not supported */ +#define MPPE_H_BIT 0x01 /* Stateless (in a different byte) */ + +/* Does not include H bit; used for least significant octet only. */ +#define MPPE_ALL_BITS (MPPE_D_BIT|MPPE_L_BIT|MPPE_S_BIT|MPPE_M_BIT|MPPE_H_BIT) + +/* Build a CI from mppe opts (see RFC 3078) */ +#define MPPE_OPTS_TO_CI(opts, ci) \ + do { \ + u_char *ptr = ci; /* u_char[4] */ \ + \ + /* H bit */ \ + if (opts & MPPE_OPT_STATEFUL) \ + *ptr++ = 0x0; \ + else \ + *ptr++ = MPPE_H_BIT; \ + *ptr++ = 0; \ + *ptr++ = 0; \ + \ + /* S,L bits */ \ + *ptr = 0; \ + if (opts & MPPE_OPT_128) \ + *ptr |= MPPE_S_BIT; \ + if (opts & MPPE_OPT_40) \ + *ptr |= MPPE_L_BIT; \ + /* M,D,C bits not supported */ \ + } while (/* CONSTCOND */ 0) + +/* The reverse of the above */ +#define MPPE_CI_TO_OPTS(ci, opts) \ + do { \ + const u_char *ptr = ci; /* u_char[4] */ \ + \ + opts = 0; \ + \ + /* H bit */ \ + if (!(ptr[0] & MPPE_H_BIT)) \ + opts |= MPPE_OPT_STATEFUL; \ + \ + /* S,L bits */ \ + if (ptr[3] & MPPE_S_BIT) \ + opts |= MPPE_OPT_128; \ + if (ptr[3] & MPPE_L_BIT) \ + opts |= MPPE_OPT_40; \ + \ + /* M,D,C bits */ \ + if (ptr[3] & MPPE_M_BIT) \ + opts |= MPPE_OPT_56; \ + if (ptr[3] & MPPE_D_BIT) \ + opts |= MPPE_OPT_D; \ + if (ptr[3] & MPPE_C_BIT) \ + opts |= MPPE_OPT_MPPC; \ + \ + /* Other bits */ \ + if (ptr[0] & ~MPPE_H_BIT) \ + opts |= MPPE_OPT_UNKNOWN; \ + if (ptr[1] || ptr[2]) \ + opts |= MPPE_OPT_UNKNOWN; \ + if (ptr[3] & ~MPPE_ALL_BITS) \ + opts |= MPPE_OPT_UNKNOWN; \ + } while (/* CONSTCOND */ 0) + +/* Shared MPPE padding between MSCHAP and MPPE */ +#define SHA1_PAD_SIZE 40 + +static const u8_t mppe_sha1_pad1[SHA1_PAD_SIZE] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 +}; +static const u8_t mppe_sha1_pad2[SHA1_PAD_SIZE] = { + 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, + 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, + 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, + 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2, 0xf2 +}; + +/* + * State for an MPPE (de)compressor. + */ +typedef struct ppp_mppe_state { + lwip_arc4_context arc4; + u8_t master_key[MPPE_MAX_KEY_LEN]; + u8_t session_key[MPPE_MAX_KEY_LEN]; + u8_t keylen; /* key length in bytes */ + /* NB: 128-bit == 16, 40-bit == 8! + * If we want to support 56-bit, the unit has to change to bits + */ + u8_t bits; /* MPPE control bits */ + u16_t ccount; /* 12-bit coherency count (seqno) */ + u16_t sanity_errors; /* take down LCP if too many */ + unsigned int stateful :1; /* stateful mode flag */ + unsigned int discard :1; /* stateful mode packet loss flag */ +} ppp_mppe_state; + +void mppe_set_key(ppp_pcb *pcb, ppp_mppe_state *state, u8_t *key); +void mppe_init(ppp_pcb *pcb, ppp_mppe_state *state, u8_t options); +void mppe_comp_reset(ppp_pcb *pcb, ppp_mppe_state *state); +err_t mppe_compress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb, u16_t protocol); +void mppe_decomp_reset(ppp_pcb *pcb, ppp_mppe_state *state); +err_t mppe_decompress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb); + +#ifdef __cplusplus +} +#endif + +#endif /* MPPE_H */ +#endif /* PPP_SUPPORT && MPPE_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/arc4.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/arc4.h index 863626d4..4af724cd 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/arc4.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/arc4.h @@ -1,81 +1,81 @@ -/** - * \file arc4.h - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "netif/ppp/ppp_opts.h" -#if LWIP_INCLUDED_POLARSSL_ARC4 - -#ifndef LWIP_INCLUDED_POLARSSL_ARC4_H -#define LWIP_INCLUDED_POLARSSL_ARC4_H - -/** - * \brief ARC4 context structure - */ -typedef struct -{ - int x; /*!< permutation index */ - int y; /*!< permutation index */ - unsigned char m[256]; /*!< permutation table */ -} -arc4_context; - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * \brief ARC4 key schedule - * - * \param ctx ARC4 context to be initialized - * \param key the secret key - * \param keylen length of the key - */ -void arc4_setup( arc4_context *ctx, unsigned char *key, int keylen ); - -/** - * \brief ARC4 cipher function - * - * \param ctx ARC4 context - * \param buf buffer to be processed - * \param buflen amount of data in buf - */ -void arc4_crypt( arc4_context *ctx, unsigned char *buf, int buflen ); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_INCLUDED_POLARSSL_ARC4_H */ - -#endif /* LWIP_INCLUDED_POLARSSL_ARC4 */ +/** + * \file arc4.h + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "netif/ppp/ppp_opts.h" +#if LWIP_INCLUDED_POLARSSL_ARC4 + +#ifndef LWIP_INCLUDED_POLARSSL_ARC4_H +#define LWIP_INCLUDED_POLARSSL_ARC4_H + +/** + * \brief ARC4 context structure + */ +typedef struct +{ + int x; /*!< permutation index */ + int y; /*!< permutation index */ + unsigned char m[256]; /*!< permutation table */ +} +arc4_context; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief ARC4 key schedule + * + * \param ctx ARC4 context to be initialized + * \param key the secret key + * \param keylen length of the key + */ +void arc4_setup( arc4_context *ctx, unsigned char *key, int keylen ); + +/** + * \brief ARC4 cipher function + * + * \param ctx ARC4 context + * \param buf buffer to be processed + * \param buflen amount of data in buf + */ +void arc4_crypt( arc4_context *ctx, unsigned char *buf, int buflen ); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_INCLUDED_POLARSSL_ARC4_H */ + +#endif /* LWIP_INCLUDED_POLARSSL_ARC4 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/des.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/des.h index ad2f0a29..e893890e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/des.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/des.h @@ -1,92 +1,92 @@ -/** - * \file des.h - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "netif/ppp/ppp_opts.h" -#if LWIP_INCLUDED_POLARSSL_DES - -#ifndef LWIP_INCLUDED_POLARSSL_DES_H -#define LWIP_INCLUDED_POLARSSL_DES_H - -#define DES_ENCRYPT 1 -#define DES_DECRYPT 0 - -/** - * \brief DES context structure - */ -typedef struct -{ - int mode; /*!< encrypt/decrypt */ - unsigned long sk[32]; /*!< DES subkeys */ -} -des_context; - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * \brief DES key schedule (56-bit, encryption) - * - * \param ctx DES context to be initialized - * \param key 8-byte secret key - */ -void des_setkey_enc( des_context *ctx, unsigned char key[8] ); - -/** - * \brief DES key schedule (56-bit, decryption) - * - * \param ctx DES context to be initialized - * \param key 8-byte secret key - */ -void des_setkey_dec( des_context *ctx, unsigned char key[8] ); - -/** - * \brief DES-ECB block encryption/decryption - * - * \param ctx DES context - * \param input 64-bit input block - * \param output 64-bit output block - */ -void des_crypt_ecb( des_context *ctx, - const unsigned char input[8], - unsigned char output[8] ); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_INCLUDED_POLARSSL_DES_H */ - -#endif /* LWIP_INCLUDED_POLARSSL_DES */ +/** + * \file des.h + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "netif/ppp/ppp_opts.h" +#if LWIP_INCLUDED_POLARSSL_DES + +#ifndef LWIP_INCLUDED_POLARSSL_DES_H +#define LWIP_INCLUDED_POLARSSL_DES_H + +#define DES_ENCRYPT 1 +#define DES_DECRYPT 0 + +/** + * \brief DES context structure + */ +typedef struct +{ + int mode; /*!< encrypt/decrypt */ + unsigned long sk[32]; /*!< DES subkeys */ +} +des_context; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief DES key schedule (56-bit, encryption) + * + * \param ctx DES context to be initialized + * \param key 8-byte secret key + */ +void des_setkey_enc( des_context *ctx, unsigned char key[8] ); + +/** + * \brief DES key schedule (56-bit, decryption) + * + * \param ctx DES context to be initialized + * \param key 8-byte secret key + */ +void des_setkey_dec( des_context *ctx, unsigned char key[8] ); + +/** + * \brief DES-ECB block encryption/decryption + * + * \param ctx DES context + * \param input 64-bit input block + * \param output 64-bit output block + */ +void des_crypt_ecb( des_context *ctx, + const unsigned char input[8], + unsigned char output[8] ); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_INCLUDED_POLARSSL_DES_H */ + +#endif /* LWIP_INCLUDED_POLARSSL_DES */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md4.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md4.h index 2262995b..57044568 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md4.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md4.h @@ -1,97 +1,97 @@ -/** - * \file md4.h - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "netif/ppp/ppp_opts.h" -#if LWIP_INCLUDED_POLARSSL_MD4 - -#ifndef LWIP_INCLUDED_POLARSSL_MD4_H -#define LWIP_INCLUDED_POLARSSL_MD4_H - -/** - * \brief MD4 context structure - */ -typedef struct -{ - unsigned long total[2]; /*!< number of bytes processed */ - unsigned long state[4]; /*!< intermediate digest state */ - unsigned char buffer[64]; /*!< data block being processed */ -} -md4_context; - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * \brief MD4 context setup - * - * \param ctx context to be initialized - */ -void md4_starts( md4_context *ctx ); - -/** - * \brief MD4 process buffer - * - * \param ctx MD4 context - * \param input buffer holding the data - * \param ilen length of the input data - */ -void md4_update( md4_context *ctx, const unsigned char *input, int ilen ); - -/** - * \brief MD4 final digest - * - * \param ctx MD4 context - * \param output MD4 checksum result - */ -void md4_finish( md4_context *ctx, unsigned char output[16] ); - -/** - * \brief Output = MD4( input buffer ) - * - * \param input buffer holding the data - * \param ilen length of the input data - * \param output MD4 checksum result - */ -void md4( unsigned char *input, int ilen, unsigned char output[16] ); - - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_INCLUDED_POLARSSL_MD4_H */ - -#endif /* LWIP_INCLUDED_POLARSSL_MD4 */ +/** + * \file md4.h + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "netif/ppp/ppp_opts.h" +#if LWIP_INCLUDED_POLARSSL_MD4 + +#ifndef LWIP_INCLUDED_POLARSSL_MD4_H +#define LWIP_INCLUDED_POLARSSL_MD4_H + +/** + * \brief MD4 context structure + */ +typedef struct +{ + unsigned long total[2]; /*!< number of bytes processed */ + unsigned long state[4]; /*!< intermediate digest state */ + unsigned char buffer[64]; /*!< data block being processed */ +} +md4_context; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief MD4 context setup + * + * \param ctx context to be initialized + */ +void md4_starts( md4_context *ctx ); + +/** + * \brief MD4 process buffer + * + * \param ctx MD4 context + * \param input buffer holding the data + * \param ilen length of the input data + */ +void md4_update( md4_context *ctx, const unsigned char *input, int ilen ); + +/** + * \brief MD4 final digest + * + * \param ctx MD4 context + * \param output MD4 checksum result + */ +void md4_finish( md4_context *ctx, unsigned char output[16] ); + +/** + * \brief Output = MD4( input buffer ) + * + * \param input buffer holding the data + * \param ilen length of the input data + * \param output MD4 checksum result + */ +void md4( unsigned char *input, int ilen, unsigned char output[16] ); + + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_INCLUDED_POLARSSL_MD4_H */ + +#endif /* LWIP_INCLUDED_POLARSSL_MD4 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md5.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md5.h index 3059e1d0..12440118 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md5.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/md5.h @@ -1,96 +1,96 @@ -/** - * \file md5.h - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "netif/ppp/ppp_opts.h" -#if LWIP_INCLUDED_POLARSSL_MD5 - -#ifndef LWIP_INCLUDED_POLARSSL_MD5_H -#define LWIP_INCLUDED_POLARSSL_MD5_H - -/** - * \brief MD5 context structure - */ -typedef struct -{ - unsigned long total[2]; /*!< number of bytes processed */ - unsigned long state[4]; /*!< intermediate digest state */ - unsigned char buffer[64]; /*!< data block being processed */ -} -md5_context; - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * \brief MD5 context setup - * - * \param ctx context to be initialized - */ -void md5_starts( md5_context *ctx ); - -/** - * \brief MD5 process buffer - * - * \param ctx MD5 context - * \param input buffer holding the data - * \param ilen length of the input data - */ -void md5_update( md5_context *ctx, const unsigned char *input, int ilen ); - -/** - * \brief MD5 final digest - * - * \param ctx MD5 context - * \param output MD5 checksum result - */ -void md5_finish( md5_context *ctx, unsigned char output[16] ); - -/** - * \brief Output = MD5( input buffer ) - * - * \param input buffer holding the data - * \param ilen length of the input data - * \param output MD5 checksum result - */ -void md5( unsigned char *input, int ilen, unsigned char output[16] ); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_INCLUDED_POLARSSL_MD5_H */ - -#endif /* LWIP_INCLUDED_POLARSSL_MD5 */ +/** + * \file md5.h + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "netif/ppp/ppp_opts.h" +#if LWIP_INCLUDED_POLARSSL_MD5 + +#ifndef LWIP_INCLUDED_POLARSSL_MD5_H +#define LWIP_INCLUDED_POLARSSL_MD5_H + +/** + * \brief MD5 context structure + */ +typedef struct +{ + unsigned long total[2]; /*!< number of bytes processed */ + unsigned long state[4]; /*!< intermediate digest state */ + unsigned char buffer[64]; /*!< data block being processed */ +} +md5_context; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief MD5 context setup + * + * \param ctx context to be initialized + */ +void md5_starts( md5_context *ctx ); + +/** + * \brief MD5 process buffer + * + * \param ctx MD5 context + * \param input buffer holding the data + * \param ilen length of the input data + */ +void md5_update( md5_context *ctx, const unsigned char *input, int ilen ); + +/** + * \brief MD5 final digest + * + * \param ctx MD5 context + * \param output MD5 checksum result + */ +void md5_finish( md5_context *ctx, unsigned char output[16] ); + +/** + * \brief Output = MD5( input buffer ) + * + * \param input buffer holding the data + * \param ilen length of the input data + * \param output MD5 checksum result + */ +void md5( unsigned char *input, int ilen, unsigned char output[16] ); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_INCLUDED_POLARSSL_MD5_H */ + +#endif /* LWIP_INCLUDED_POLARSSL_MD5 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/sha1.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/sha1.h index 6d2a76ee..a4c53e07 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/sha1.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/polarssl/sha1.h @@ -1,96 +1,96 @@ -/** - * \file sha1.h - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "netif/ppp/ppp_opts.h" -#if LWIP_INCLUDED_POLARSSL_SHA1 - -#ifndef LWIP_INCLUDED_POLARSSL_SHA1_H -#define LWIP_INCLUDED_POLARSSL_SHA1_H - -/** - * \brief SHA-1 context structure - */ -typedef struct -{ - unsigned long total[2]; /*!< number of bytes processed */ - unsigned long state[5]; /*!< intermediate digest state */ - unsigned char buffer[64]; /*!< data block being processed */ -} -sha1_context; - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * \brief SHA-1 context setup - * - * \param ctx context to be initialized - */ -void sha1_starts( sha1_context *ctx ); - -/** - * \brief SHA-1 process buffer - * - * \param ctx SHA-1 context - * \param input buffer holding the data - * \param ilen length of the input data - */ -void sha1_update( sha1_context *ctx, const unsigned char *input, int ilen ); - -/** - * \brief SHA-1 final digest - * - * \param ctx SHA-1 context - * \param output SHA-1 checksum result - */ -void sha1_finish( sha1_context *ctx, unsigned char output[20] ); - -/** - * \brief Output = SHA-1( input buffer ) - * - * \param input buffer holding the data - * \param ilen length of the input data - * \param output SHA-1 checksum result - */ -void sha1( unsigned char *input, int ilen, unsigned char output[20] ); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_INCLUDED_POLARSSL_SHA1_H */ - -#endif /* LWIP_INCLUDED_POLARSSL_SHA1 */ +/** + * \file sha1.h + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "netif/ppp/ppp_opts.h" +#if LWIP_INCLUDED_POLARSSL_SHA1 + +#ifndef LWIP_INCLUDED_POLARSSL_SHA1_H +#define LWIP_INCLUDED_POLARSSL_SHA1_H + +/** + * \brief SHA-1 context structure + */ +typedef struct +{ + unsigned long total[2]; /*!< number of bytes processed */ + unsigned long state[5]; /*!< intermediate digest state */ + unsigned char buffer[64]; /*!< data block being processed */ +} +sha1_context; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * \brief SHA-1 context setup + * + * \param ctx context to be initialized + */ +void sha1_starts( sha1_context *ctx ); + +/** + * \brief SHA-1 process buffer + * + * \param ctx SHA-1 context + * \param input buffer holding the data + * \param ilen length of the input data + */ +void sha1_update( sha1_context *ctx, const unsigned char *input, int ilen ); + +/** + * \brief SHA-1 final digest + * + * \param ctx SHA-1 context + * \param output SHA-1 checksum result + */ +void sha1_finish( sha1_context *ctx, unsigned char output[20] ); + +/** + * \brief Output = SHA-1( input buffer ) + * + * \param input buffer holding the data + * \param ilen length of the input data + * \param output SHA-1 checksum result + */ +void sha1( unsigned char *input, int ilen, unsigned char output[20] ); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_INCLUDED_POLARSSL_SHA1_H */ + +#endif /* LWIP_INCLUDED_POLARSSL_SHA1 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp.h index 3595b7bf..3d73c365 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp.h @@ -1,698 +1,698 @@ -/***************************************************************************** -* ppp.h - Network Point to Point Protocol header file. -* -* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. -* portions Copyright (c) 1997 Global Election Systems Inc. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY -* -* 03-01-01 Marc Boucher -* Ported to lwIP. -* 97-11-05 Guy Lancaster , Global Election Systems Inc. -* Original derived from BSD codes. -*****************************************************************************/ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef PPP_H -#define PPP_H - -#include "lwip/def.h" -#include "lwip/stats.h" -#include "lwip/mem.h" -#include "lwip/netif.h" -#include "lwip/sys.h" -#include "lwip/timeouts.h" -#if PPP_IPV6_SUPPORT -#include "lwip/ip6_addr.h" -#endif /* PPP_IPV6_SUPPORT */ - -#ifdef __cplusplus -extern "C" { -#endif - -/* Disable non-working or rarely used PPP feature, so rarely that we don't want to bloat ppp_opts.h with them */ -#ifndef PPP_OPTIONS -#define PPP_OPTIONS 0 -#endif - -#ifndef PPP_NOTIFY -#define PPP_NOTIFY 0 -#endif - -#ifndef PPP_REMOTENAME -#define PPP_REMOTENAME 0 -#endif - -#ifndef PPP_IDLETIMELIMIT -#define PPP_IDLETIMELIMIT 0 -#endif - -#ifndef PPP_LCP_ADAPTIVE -#define PPP_LCP_ADAPTIVE 0 -#endif - -#ifndef PPP_MAXCONNECT -#define PPP_MAXCONNECT 0 -#endif - -#ifndef PPP_ALLOWED_ADDRS -#define PPP_ALLOWED_ADDRS 0 -#endif - -#ifndef PPP_PROTOCOLNAME -#define PPP_PROTOCOLNAME 0 -#endif - -#ifndef PPP_STATS_SUPPORT -#define PPP_STATS_SUPPORT 0 -#endif - -#ifndef DEFLATE_SUPPORT -#define DEFLATE_SUPPORT 0 -#endif - -#ifndef BSDCOMPRESS_SUPPORT -#define BSDCOMPRESS_SUPPORT 0 -#endif - -#ifndef PREDICTOR_SUPPORT -#define PREDICTOR_SUPPORT 0 -#endif - -/************************* -*** PUBLIC DEFINITIONS *** -*************************/ - -/* - * The basic PPP frame. - */ -#define PPP_HDRLEN 4 /* octets for standard ppp header */ -#define PPP_FCSLEN 2 /* octets for FCS */ - -/* - * Values for phase. - */ -#define PPP_PHASE_DEAD 0 -#define PPP_PHASE_MASTER 1 -#define PPP_PHASE_HOLDOFF 2 -#define PPP_PHASE_INITIALIZE 3 -#define PPP_PHASE_SERIALCONN 4 -#define PPP_PHASE_DORMANT 5 -#define PPP_PHASE_ESTABLISH 6 -#define PPP_PHASE_AUTHENTICATE 7 -#define PPP_PHASE_CALLBACK 8 -#define PPP_PHASE_NETWORK 9 -#define PPP_PHASE_RUNNING 10 -#define PPP_PHASE_TERMINATE 11 -#define PPP_PHASE_DISCONNECT 12 - -/* Error codes. */ -#define PPPERR_NONE 0 /* No error. */ -#define PPPERR_PARAM 1 /* Invalid parameter. */ -#define PPPERR_OPEN 2 /* Unable to open PPP session. */ -#define PPPERR_DEVICE 3 /* Invalid I/O device for PPP. */ -#define PPPERR_ALLOC 4 /* Unable to allocate resources. */ -#define PPPERR_USER 5 /* User interrupt. */ -#define PPPERR_CONNECT 6 /* Connection lost. */ -#define PPPERR_AUTHFAIL 7 /* Failed authentication challenge. */ -#define PPPERR_PROTOCOL 8 /* Failed to meet protocol. */ -#define PPPERR_PEERDEAD 9 /* Connection timeout */ -#define PPPERR_IDLETIMEOUT 10 /* Idle Timeout */ -#define PPPERR_CONNECTTIME 11 /* Max connect time reached */ -#define PPPERR_LOOPBACK 12 /* Loopback detected */ - -/* Whether auth support is enabled at all */ -#define PPP_AUTH_SUPPORT (PAP_SUPPORT || CHAP_SUPPORT || EAP_SUPPORT) - -/************************ -*** PUBLIC DATA TYPES *** -************************/ - -/* - * Other headers require ppp_pcb definition for prototypes, but ppp_pcb - * require some structure definition from other headers as well, we are - * fixing the dependency loop here by declaring the ppp_pcb type then - * by including headers containing necessary struct definition for ppp_pcb - */ -typedef struct ppp_pcb_s ppp_pcb; - -/* Type definitions for BSD code. */ -#ifndef __u_char_defined -typedef unsigned long u_long; -typedef unsigned int u_int; -typedef unsigned short u_short; -typedef unsigned char u_char; -#endif - -#include "fsm.h" -#include "lcp.h" -#if CCP_SUPPORT -#include "ccp.h" -#endif /* CCP_SUPPORT */ -#if MPPE_SUPPORT -#include "mppe.h" -#endif /* MPPE_SUPPORT */ -#if PPP_IPV4_SUPPORT -#include "ipcp.h" -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT -#include "ipv6cp.h" -#endif /* PPP_IPV6_SUPPORT */ -#if PAP_SUPPORT -#include "upap.h" -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT -#include "chap-new.h" -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT -#include "eap.h" -#endif /* EAP_SUPPORT */ -#if VJ_SUPPORT -#include "vj.h" -#endif /* VJ_SUPPORT */ - -/* Link status callback function prototype */ -typedef void (*ppp_link_status_cb_fn)(ppp_pcb *pcb, int err_code, void *ctx); - -/* - * PPP configuration. - */ -typedef struct ppp_settings_s { - -#if PPP_SERVER && PPP_AUTH_SUPPORT - unsigned int auth_required :1; /* Peer is required to authenticate */ - unsigned int null_login :1; /* Username of "" and a password of "" are acceptable */ -#endif /* PPP_SERVER && PPP_AUTH_SUPPORT */ -#if PPP_REMOTENAME - unsigned int explicit_remote :1; /* remote_name specified with remotename opt */ -#endif /* PPP_REMOTENAME */ -#if PAP_SUPPORT - unsigned int refuse_pap :1; /* Don't proceed auth. with PAP */ -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - unsigned int refuse_chap :1; /* Don't proceed auth. with CHAP */ -#endif /* CHAP_SUPPORT */ -#if MSCHAP_SUPPORT - unsigned int refuse_mschap :1; /* Don't proceed auth. with MS-CHAP */ - unsigned int refuse_mschap_v2 :1; /* Don't proceed auth. with MS-CHAPv2 */ -#endif /* MSCHAP_SUPPORT */ -#if EAP_SUPPORT - unsigned int refuse_eap :1; /* Don't proceed auth. with EAP */ -#endif /* EAP_SUPPORT */ -#if LWIP_DNS - unsigned int usepeerdns :1; /* Ask peer for DNS adds */ -#endif /* LWIP_DNS */ - unsigned int persist :1; /* Persist mode, always try to open the connection */ -#if PRINTPKT_SUPPORT - unsigned int hide_password :1; /* Hide password in dumped packets */ -#endif /* PRINTPKT_SUPPORT */ - unsigned int noremoteip :1; /* Let him have no IP address */ - unsigned int lax_recv :1; /* accept control chars in asyncmap */ - unsigned int noendpoint :1; /* don't send/accept endpoint discriminator */ -#if PPP_LCP_ADAPTIVE - unsigned int lcp_echo_adaptive :1; /* request echo only if the link was idle */ -#endif /* PPP_LCP_ADAPTIVE */ -#if MPPE_SUPPORT - unsigned int require_mppe :1; /* Require MPPE (Microsoft Point to Point Encryption) */ - unsigned int refuse_mppe_40 :1; /* Allow MPPE 40-bit mode? */ - unsigned int refuse_mppe_128 :1; /* Allow MPPE 128-bit mode? */ - unsigned int refuse_mppe_stateful :1; /* Allow MPPE stateful mode? */ -#endif /* MPPE_SUPPORT */ - - u16_t listen_time; /* time to listen first (ms), waiting for peer to send LCP packet */ - -#if PPP_IDLETIMELIMIT - u16_t idle_time_limit; /* Disconnect if idle for this many seconds */ -#endif /* PPP_IDLETIMELIMIT */ -#if PPP_MAXCONNECT - u32_t maxconnect; /* Maximum connect time (seconds) */ -#endif /* PPP_MAXCONNECT */ - -#if PPP_AUTH_SUPPORT - /* auth data */ - const char *user; /* Username for PAP */ - const char *passwd; /* Password for PAP, secret for CHAP */ -#if PPP_REMOTENAME - char remote_name[MAXNAMELEN + 1]; /* Peer's name for authentication */ -#endif /* PPP_REMOTENAME */ - -#if PAP_SUPPORT - u8_t pap_timeout_time; /* Timeout (seconds) for auth-req retrans. */ - u8_t pap_max_transmits; /* Number of auth-reqs sent */ -#if PPP_SERVER - u8_t pap_req_timeout; /* Time to wait for auth-req from peer */ -#endif /* PPP_SERVER */ -#endif /* PAP_SUPPPORT */ - -#if CHAP_SUPPORT - u8_t chap_timeout_time; /* Timeout (seconds) for retransmitting req */ - u8_t chap_max_transmits; /* max # times to send challenge */ -#if PPP_SERVER - u8_t chap_rechallenge_time; /* Time to wait for auth-req from peer */ -#endif /* PPP_SERVER */ -#endif /* CHAP_SUPPPORT */ - -#if EAP_SUPPORT - u8_t eap_req_time; /* Time to wait (for retransmit/fail) */ - u8_t eap_allow_req; /* Max Requests allowed */ -#if PPP_SERVER - u8_t eap_timeout_time; /* Time to wait (for retransmit/fail) */ - u8_t eap_max_transmits; /* Max Requests allowed */ -#endif /* PPP_SERVER */ -#endif /* EAP_SUPPORT */ - -#endif /* PPP_AUTH_SUPPORT */ - - u8_t fsm_timeout_time; /* Timeout time in seconds */ - u8_t fsm_max_conf_req_transmits; /* Maximum Configure-Request transmissions */ - u8_t fsm_max_term_transmits; /* Maximum Terminate-Request transmissions */ - u8_t fsm_max_nak_loops; /* Maximum number of nak loops tolerated */ - - u8_t lcp_loopbackfail; /* Number of times we receive our magic number from the peer - before deciding the link is looped-back. */ - u8_t lcp_echo_interval; /* Interval between LCP echo-requests */ - u8_t lcp_echo_fails; /* Tolerance to unanswered echo-requests */ - -} ppp_settings; - -#if PPP_SERVER -struct ppp_addrs { -#if PPP_IPV4_SUPPORT - ip4_addr_t our_ipaddr, his_ipaddr, netmask; -#if LWIP_DNS - ip4_addr_t dns1, dns2; -#endif /* LWIP_DNS */ -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT - ip6_addr_t our6_ipaddr, his6_ipaddr; -#endif /* PPP_IPV6_SUPPORT */ -}; -#endif /* PPP_SERVER */ - -/* - * PPP interface control block. - */ -struct ppp_pcb_s { - ppp_settings settings; - const struct link_callbacks *link_cb; - void *link_ctx_cb; - void (*link_status_cb)(ppp_pcb *pcb, int err_code, void *ctx); /* Status change callback */ -#if PPP_NOTIFY_PHASE - void (*notify_phase_cb)(ppp_pcb *pcb, u8_t phase, void *ctx); /* Notify phase callback */ -#endif /* PPP_NOTIFY_PHASE */ - void *ctx_cb; /* Callbacks optional pointer */ - struct netif *netif; /* PPP interface */ - u8_t phase; /* where the link is at */ - u8_t err_code; /* Code indicating why interface is down. */ - - /* flags */ -#if PPP_IPV4_SUPPORT - unsigned int ask_for_local :1; /* request our address from peer */ - unsigned int ipcp_is_open :1; /* haven't called np_finished() */ - unsigned int ipcp_is_up :1; /* have called ipcp_up() */ - unsigned int if4_up :1; /* True when the IPv4 interface is up. */ -#if 0 /* UNUSED - PROXY ARP */ - unsigned int proxy_arp_set :1; /* Have created proxy arp entry */ -#endif /* UNUSED - PROXY ARP */ -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT - unsigned int ipv6cp_is_up :1; /* have called ip6cp_up() */ - unsigned int if6_up :1; /* True when the IPv6 interface is up. */ -#endif /* PPP_IPV6_SUPPORT */ - unsigned int lcp_echo_timer_running :1; /* set if a timer is running */ -#if VJ_SUPPORT - unsigned int vj_enabled :1; /* Flag indicating VJ compression enabled. */ -#endif /* VJ_SUPPORT */ -#if CCP_SUPPORT - unsigned int ccp_all_rejected :1; /* we rejected all peer's options */ -#endif /* CCP_SUPPORT */ -#if MPPE_SUPPORT - unsigned int mppe_keys_set :1; /* Have the MPPE keys been set? */ -#endif /* MPPE_SUPPORT */ - -#if PPP_AUTH_SUPPORT - /* auth data */ -#if PPP_SERVER && defined(HAVE_MULTILINK) - char peer_authname[MAXNAMELEN + 1]; /* The name by which the peer authenticated itself to us. */ -#endif /* PPP_SERVER && defined(HAVE_MULTILINK) */ - u16_t auth_pending; /* Records which authentication operations haven't completed yet. */ - u16_t auth_done; /* Records which authentication operations have been completed. */ - -#if PAP_SUPPORT - upap_state upap; /* PAP data */ -#endif /* PAP_SUPPORT */ - -#if CHAP_SUPPORT - chap_client_state chap_client; /* CHAP client data */ -#if PPP_SERVER - chap_server_state chap_server; /* CHAP server data */ -#endif /* PPP_SERVER */ -#endif /* CHAP_SUPPORT */ - -#if EAP_SUPPORT - eap_state eap; /* EAP data */ -#endif /* EAP_SUPPORT */ -#endif /* PPP_AUTH_SUPPORT */ - - fsm lcp_fsm; /* LCP fsm structure */ - lcp_options lcp_wantoptions; /* Options that we want to request */ - lcp_options lcp_gotoptions; /* Options that peer ack'd */ - lcp_options lcp_allowoptions; /* Options we allow peer to request */ - lcp_options lcp_hisoptions; /* Options that we ack'd */ - u16_t peer_mru; /* currently negotiated peer MRU */ - u8_t lcp_echos_pending; /* Number of outstanding echo msgs */ - u8_t lcp_echo_number; /* ID number of next echo frame */ - - u8_t num_np_open; /* Number of network protocols which we have opened. */ - u8_t num_np_up; /* Number of network protocols which have come up. */ - -#if VJ_SUPPORT - struct vjcompress vj_comp; /* Van Jacobson compression header. */ -#endif /* VJ_SUPPORT */ - -#if CCP_SUPPORT - fsm ccp_fsm; /* CCP fsm structure */ - ccp_options ccp_wantoptions; /* what to request the peer to use */ - ccp_options ccp_gotoptions; /* what the peer agreed to do */ - ccp_options ccp_allowoptions; /* what we'll agree to do */ - ccp_options ccp_hisoptions; /* what we agreed to do */ - u8_t ccp_localstate; /* Local state (mainly for handling reset-reqs and reset-acks). */ - u8_t ccp_receive_method; /* Method chosen on receive path */ - u8_t ccp_transmit_method; /* Method chosen on transmit path */ -#if MPPE_SUPPORT - ppp_mppe_state mppe_comp; /* MPPE "compressor" structure */ - ppp_mppe_state mppe_decomp; /* MPPE "decompressor" structure */ -#endif /* MPPE_SUPPORT */ -#endif /* CCP_SUPPORT */ - -#if PPP_IPV4_SUPPORT - fsm ipcp_fsm; /* IPCP fsm structure */ - ipcp_options ipcp_wantoptions; /* Options that we want to request */ - ipcp_options ipcp_gotoptions; /* Options that peer ack'd */ - ipcp_options ipcp_allowoptions; /* Options we allow peer to request */ - ipcp_options ipcp_hisoptions; /* Options that we ack'd */ -#endif /* PPP_IPV4_SUPPORT */ - -#if PPP_IPV6_SUPPORT - fsm ipv6cp_fsm; /* IPV6CP fsm structure */ - ipv6cp_options ipv6cp_wantoptions; /* Options that we want to request */ - ipv6cp_options ipv6cp_gotoptions; /* Options that peer ack'd */ - ipv6cp_options ipv6cp_allowoptions; /* Options we allow peer to request */ - ipv6cp_options ipv6cp_hisoptions; /* Options that we ack'd */ -#endif /* PPP_IPV6_SUPPORT */ -}; - -/************************ - *** PUBLIC FUNCTIONS *** - ************************/ - -/* - * WARNING: For multi-threads environment, all ppp_set_* functions most - * only be called while the PPP is in the dead phase (i.e. disconnected). - */ - -#if PPP_AUTH_SUPPORT -/* - * Set PPP authentication. - * - * Warning: Using PPPAUTHTYPE_ANY might have security consequences. - * RFC 1994 says: - * - * In practice, within or associated with each PPP server, there is a - * database which associates "user" names with authentication - * information ("secrets"). It is not anticipated that a particular - * named user would be authenticated by multiple methods. This would - * make the user vulnerable to attacks which negotiate the least secure - * method from among a set (such as PAP rather than CHAP). If the same - * secret was used, PAP would reveal the secret to be used later with - * CHAP. - * - * Instead, for each user name there should be an indication of exactly - * one method used to authenticate that user name. If a user needs to - * make use of different authentication methods under different - * circumstances, then distinct user names SHOULD be employed, each of - * which identifies exactly one authentication method. - * - * Default is none auth type, unset (NULL) user and passwd. - */ -#define PPPAUTHTYPE_NONE 0x00 -#define PPPAUTHTYPE_PAP 0x01 -#define PPPAUTHTYPE_CHAP 0x02 -#define PPPAUTHTYPE_MSCHAP 0x04 -#define PPPAUTHTYPE_MSCHAP_V2 0x08 -#define PPPAUTHTYPE_EAP 0x10 -#define PPPAUTHTYPE_ANY 0xff -void ppp_set_auth(ppp_pcb *pcb, u8_t authtype, const char *user, const char *passwd); - -/* - * If set, peer is required to authenticate. This is mostly necessary for PPP server support. - * - * Default is false. - */ -#define ppp_set_auth_required(ppp, boolval) (ppp->settings.auth_required = boolval) -#endif /* PPP_AUTH_SUPPORT */ - -#if PPP_IPV4_SUPPORT -/* - * Set PPP interface "our" and "his" IPv4 addresses. This is mostly necessary for PPP server - * support but it can also be used on a PPP link where each side choose its own IP address. - * - * Default is unset (0.0.0.0). - */ -#define ppp_set_ipcp_ouraddr(ppp, addr) do { ppp->ipcp_wantoptions.ouraddr = ip4_addr_get_u32(addr); \ - ppp->ask_for_local = ppp->ipcp_wantoptions.ouraddr != 0; } while(0) -#define ppp_set_ipcp_hisaddr(ppp, addr) (ppp->ipcp_wantoptions.hisaddr = ip4_addr_get_u32(addr)) -#if LWIP_DNS -/* - * Set DNS server addresses that are sent if the peer asks for them. This is mostly necessary - * for PPP server support. - * - * Default is unset (0.0.0.0). - */ -#define ppp_set_ipcp_dnsaddr(ppp, index, addr) (ppp->ipcp_allowoptions.dnsaddr[index] = ip4_addr_get_u32(addr)) - -/* - * If set, we ask the peer for up to 2 DNS server addresses. Received DNS server addresses are - * registered using the dns_setserver() function. - * - * Default is false. - */ -#define ppp_set_usepeerdns(ppp, boolval) (ppp->settings.usepeerdns = boolval) -#endif /* LWIP_DNS */ -#endif /* PPP_IPV4_SUPPORT */ - -#if MPPE_SUPPORT -/* Disable MPPE (Microsoft Point to Point Encryption). This parameter is exclusive. */ -#define PPP_MPPE_DISABLE 0x00 -/* Require the use of MPPE (Microsoft Point to Point Encryption). */ -#define PPP_MPPE_ENABLE 0x01 -/* Allow MPPE to use stateful mode. Stateless mode is still attempted first. */ -#define PPP_MPPE_ALLOW_STATEFUL 0x02 -/* Refuse the use of MPPE with 40-bit encryption. Conflict with PPP_MPPE_REFUSE_128. */ -#define PPP_MPPE_REFUSE_40 0x04 -/* Refuse the use of MPPE with 128-bit encryption. Conflict with PPP_MPPE_REFUSE_40. */ -#define PPP_MPPE_REFUSE_128 0x08 -/* - * Set MPPE configuration - * - * Default is disabled. - */ -void ppp_set_mppe(ppp_pcb *pcb, u8_t flags); -#endif /* MPPE_SUPPORT */ - -/* - * Wait for up to intval milliseconds for a valid PPP packet from the peer. - * At the end of this time, or when a valid PPP packet is received from the - * peer, we commence negotiation by sending our first LCP packet. - * - * Default is 0. - */ -#define ppp_set_listen_time(ppp, intval) (ppp->settings.listen_time = intval) - -/* - * If set, we will attempt to initiate a connection but if no reply is received from - * the peer, we will then just wait passively for a valid LCP packet from the peer. - * - * Default is false. - */ -#define ppp_set_passive(ppp, boolval) (ppp->lcp_wantoptions.passive = boolval) - -/* - * If set, we will not transmit LCP packets to initiate a connection until a valid - * LCP packet is received from the peer. This is what we usually call the server mode. - * - * Default is false. - */ -#define ppp_set_silent(ppp, boolval) (ppp->lcp_wantoptions.silent = boolval) - -/* - * If set, enable protocol field compression negotiation in both the receive and - * the transmit direction. - * - * Default is true. - */ -#define ppp_set_neg_pcomp(ppp, boolval) (ppp->lcp_wantoptions.neg_pcompression = \ - ppp->lcp_allowoptions.neg_pcompression = boolval) - -/* - * If set, enable Address/Control compression in both the receive and the transmit - * direction. - * - * Default is true. - */ -#define ppp_set_neg_accomp(ppp, boolval) (ppp->lcp_wantoptions.neg_accompression = \ - ppp->lcp_allowoptions.neg_accompression = boolval) - -/* - * If set, enable asyncmap negotiation. Otherwise forcing all control characters to - * be escaped for both the transmit and the receive direction. - * - * Default is true. - */ -#define ppp_set_neg_asyncmap(ppp, boolval) (ppp->lcp_wantoptions.neg_asyncmap = \ - ppp->lcp_allowoptions.neg_asyncmap = boolval) - -/* - * This option sets the Async-Control-Character-Map (ACCM) for this end of the link. - * The ACCM is a set of 32 bits, one for each of the ASCII control characters with - * values from 0 to 31, where a 1 bit indicates that the corresponding control - * character should not be used in PPP packets sent to this system. The map is - * an unsigned 32 bits integer where the least significant bit (00000001) represents - * character 0 and the most significant bit (80000000) represents character 31. - * We will then ask the peer to send these characters as a 2-byte escape sequence. - * - * Default is 0. - */ -#define ppp_set_asyncmap(ppp, intval) (ppp->lcp_wantoptions.asyncmap = intval) - -/* - * Set a PPP interface as the default network interface - * (used to output all packets for which no specific route is found). - */ -#define ppp_set_default(ppp) netif_set_default(ppp->netif) - -#if PPP_NOTIFY_PHASE -/* - * Set a PPP notify phase callback. - * - * This can be used for example to set a LED pattern depending on the - * current phase of the PPP session. - */ -typedef void (*ppp_notify_phase_cb_fn)(ppp_pcb *pcb, u8_t phase, void *ctx); -void ppp_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb); -#endif /* PPP_NOTIFY_PHASE */ - -/* - * Initiate a PPP connection. - * - * This can only be called if PPP is in the dead phase. - * - * Holdoff is the time to wait (in seconds) before initiating - * the connection. - * - * If this port connects to a modem, the modem connection must be - * established before calling this. - */ -err_t ppp_connect(ppp_pcb *pcb, u16_t holdoff); - -#if PPP_SERVER -/* - * Listen for an incoming PPP connection. - * - * This can only be called if PPP is in the dead phase. - * - * If this port connects to a modem, the modem connection must be - * established before calling this. - */ -err_t ppp_listen(ppp_pcb *pcb); -#endif /* PPP_SERVER */ - -/* - * Initiate the end of a PPP connection. - * Any outstanding packets in the queues are dropped. - * - * Setting nocarrier to 1 close the PPP connection without initiating the - * shutdown procedure. Always using nocarrier = 0 is still recommended, - * this is going to take a little longer time if your link is down, but - * is a safer choice for the PPP state machine. - * - * Return 0 on success, an error code on failure. - */ -err_t ppp_close(ppp_pcb *pcb, u8_t nocarrier); - -/* - * Release the control block. - * - * This can only be called if PPP is in the dead phase. - * - * You must use ppp_close() before if you wish to terminate - * an established PPP session. - * - * Return 0 on success, an error code on failure. - */ -err_t ppp_free(ppp_pcb *pcb); - -/* - * PPP IOCTL commands. - * - * Get the up status - 0 for down, non-zero for up. The argument must - * point to an int. - */ -#define PPPCTLG_UPSTATUS 0 - -/* - * Get the PPP error code. The argument must point to an int. - * Returns a PPPERR_* value. - */ -#define PPPCTLG_ERRCODE 1 - -/* - * Get the fd associated with a PPP over serial - */ -#define PPPCTLG_FD 2 - -/* - * Get and set parameters for the given connection. - * Return 0 on success, an error code on failure. - */ -err_t ppp_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg); - -/* Get the PPP netif interface */ -#define ppp_netif(ppp) (ppp->netif) - -/* Set an lwIP-style status-callback for the selected PPP device */ -#define ppp_set_netif_statuscallback(ppp, status_cb) \ - netif_set_status_callback(ppp->netif, status_cb); - -/* Set an lwIP-style link-callback for the selected PPP device */ -#define ppp_set_netif_linkcallback(ppp, link_cb) \ - netif_set_link_callback(ppp->netif, link_cb); - -#ifdef __cplusplus -} -#endif - -#endif /* PPP_H */ - -#endif /* PPP_SUPPORT */ +/***************************************************************************** +* ppp.h - Network Point to Point Protocol header file. +* +* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. +* portions Copyright (c) 1997 Global Election Systems Inc. +* +* The authors hereby grant permission to use, copy, modify, distribute, +* and license this software and its documentation for any purpose, provided +* that existing copyright notices are retained in all copies and that this +* notice and the following disclaimer are included verbatim in any +* distributions. No written agreement, license, or royalty fee is required +* for any of the authorized uses. +* +* THIS SOFTWARE IS PROVIDED BY THE 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 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. +* +****************************************************************************** +* REVISION HISTORY +* +* 03-01-01 Marc Boucher +* Ported to lwIP. +* 97-11-05 Guy Lancaster , Global Election Systems Inc. +* Original derived from BSD codes. +*****************************************************************************/ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef PPP_H +#define PPP_H + +#include "lwip/def.h" +#include "lwip/stats.h" +#include "lwip/mem.h" +#include "lwip/netif.h" +#include "lwip/sys.h" +#include "lwip/timeouts.h" +#if PPP_IPV6_SUPPORT +#include "lwip/ip6_addr.h" +#endif /* PPP_IPV6_SUPPORT */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* Disable non-working or rarely used PPP feature, so rarely that we don't want to bloat ppp_opts.h with them */ +#ifndef PPP_OPTIONS +#define PPP_OPTIONS 0 +#endif + +#ifndef PPP_NOTIFY +#define PPP_NOTIFY 0 +#endif + +#ifndef PPP_REMOTENAME +#define PPP_REMOTENAME 0 +#endif + +#ifndef PPP_IDLETIMELIMIT +#define PPP_IDLETIMELIMIT 0 +#endif + +#ifndef PPP_LCP_ADAPTIVE +#define PPP_LCP_ADAPTIVE 0 +#endif + +#ifndef PPP_MAXCONNECT +#define PPP_MAXCONNECT 0 +#endif + +#ifndef PPP_ALLOWED_ADDRS +#define PPP_ALLOWED_ADDRS 0 +#endif + +#ifndef PPP_PROTOCOLNAME +#define PPP_PROTOCOLNAME 0 +#endif + +#ifndef PPP_STATS_SUPPORT +#define PPP_STATS_SUPPORT 0 +#endif + +#ifndef DEFLATE_SUPPORT +#define DEFLATE_SUPPORT 0 +#endif + +#ifndef BSDCOMPRESS_SUPPORT +#define BSDCOMPRESS_SUPPORT 0 +#endif + +#ifndef PREDICTOR_SUPPORT +#define PREDICTOR_SUPPORT 0 +#endif + +/************************* +*** PUBLIC DEFINITIONS *** +*************************/ + +/* + * The basic PPP frame. + */ +#define PPP_HDRLEN 4 /* octets for standard ppp header */ +#define PPP_FCSLEN 2 /* octets for FCS */ + +/* + * Values for phase. + */ +#define PPP_PHASE_DEAD 0 +#define PPP_PHASE_MASTER 1 +#define PPP_PHASE_HOLDOFF 2 +#define PPP_PHASE_INITIALIZE 3 +#define PPP_PHASE_SERIALCONN 4 +#define PPP_PHASE_DORMANT 5 +#define PPP_PHASE_ESTABLISH 6 +#define PPP_PHASE_AUTHENTICATE 7 +#define PPP_PHASE_CALLBACK 8 +#define PPP_PHASE_NETWORK 9 +#define PPP_PHASE_RUNNING 10 +#define PPP_PHASE_TERMINATE 11 +#define PPP_PHASE_DISCONNECT 12 + +/* Error codes. */ +#define PPPERR_NONE 0 /* No error. */ +#define PPPERR_PARAM 1 /* Invalid parameter. */ +#define PPPERR_OPEN 2 /* Unable to open PPP session. */ +#define PPPERR_DEVICE 3 /* Invalid I/O device for PPP. */ +#define PPPERR_ALLOC 4 /* Unable to allocate resources. */ +#define PPPERR_USER 5 /* User interrupt. */ +#define PPPERR_CONNECT 6 /* Connection lost. */ +#define PPPERR_AUTHFAIL 7 /* Failed authentication challenge. */ +#define PPPERR_PROTOCOL 8 /* Failed to meet protocol. */ +#define PPPERR_PEERDEAD 9 /* Connection timeout */ +#define PPPERR_IDLETIMEOUT 10 /* Idle Timeout */ +#define PPPERR_CONNECTTIME 11 /* Max connect time reached */ +#define PPPERR_LOOPBACK 12 /* Loopback detected */ + +/* Whether auth support is enabled at all */ +#define PPP_AUTH_SUPPORT (PAP_SUPPORT || CHAP_SUPPORT || EAP_SUPPORT) + +/************************ +*** PUBLIC DATA TYPES *** +************************/ + +/* + * Other headers require ppp_pcb definition for prototypes, but ppp_pcb + * require some structure definition from other headers as well, we are + * fixing the dependency loop here by declaring the ppp_pcb type then + * by including headers containing necessary struct definition for ppp_pcb + */ +typedef struct ppp_pcb_s ppp_pcb; + +/* Type definitions for BSD code. */ +#ifndef __u_char_defined +typedef unsigned long u_long; +typedef unsigned int u_int; +typedef unsigned short u_short; +typedef unsigned char u_char; +#endif + +#include "fsm.h" +#include "lcp.h" +#if CCP_SUPPORT +#include "ccp.h" +#endif /* CCP_SUPPORT */ +#if MPPE_SUPPORT +#include "mppe.h" +#endif /* MPPE_SUPPORT */ +#if PPP_IPV4_SUPPORT +#include "ipcp.h" +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT +#include "ipv6cp.h" +#endif /* PPP_IPV6_SUPPORT */ +#if PAP_SUPPORT +#include "upap.h" +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT +#include "chap-new.h" +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT +#include "eap.h" +#endif /* EAP_SUPPORT */ +#if VJ_SUPPORT +#include "vj.h" +#endif /* VJ_SUPPORT */ + +/* Link status callback function prototype */ +typedef void (*ppp_link_status_cb_fn)(ppp_pcb *pcb, int err_code, void *ctx); + +/* + * PPP configuration. + */ +typedef struct ppp_settings_s { + +#if PPP_SERVER && PPP_AUTH_SUPPORT + unsigned int auth_required :1; /* Peer is required to authenticate */ + unsigned int null_login :1; /* Username of "" and a password of "" are acceptable */ +#endif /* PPP_SERVER && PPP_AUTH_SUPPORT */ +#if PPP_REMOTENAME + unsigned int explicit_remote :1; /* remote_name specified with remotename opt */ +#endif /* PPP_REMOTENAME */ +#if PAP_SUPPORT + unsigned int refuse_pap :1; /* Don't proceed auth. with PAP */ +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + unsigned int refuse_chap :1; /* Don't proceed auth. with CHAP */ +#endif /* CHAP_SUPPORT */ +#if MSCHAP_SUPPORT + unsigned int refuse_mschap :1; /* Don't proceed auth. with MS-CHAP */ + unsigned int refuse_mschap_v2 :1; /* Don't proceed auth. with MS-CHAPv2 */ +#endif /* MSCHAP_SUPPORT */ +#if EAP_SUPPORT + unsigned int refuse_eap :1; /* Don't proceed auth. with EAP */ +#endif /* EAP_SUPPORT */ +#if LWIP_DNS + unsigned int usepeerdns :1; /* Ask peer for DNS adds */ +#endif /* LWIP_DNS */ + unsigned int persist :1; /* Persist mode, always try to open the connection */ +#if PRINTPKT_SUPPORT + unsigned int hide_password :1; /* Hide password in dumped packets */ +#endif /* PRINTPKT_SUPPORT */ + unsigned int noremoteip :1; /* Let him have no IP address */ + unsigned int lax_recv :1; /* accept control chars in asyncmap */ + unsigned int noendpoint :1; /* don't send/accept endpoint discriminator */ +#if PPP_LCP_ADAPTIVE + unsigned int lcp_echo_adaptive :1; /* request echo only if the link was idle */ +#endif /* PPP_LCP_ADAPTIVE */ +#if MPPE_SUPPORT + unsigned int require_mppe :1; /* Require MPPE (Microsoft Point to Point Encryption) */ + unsigned int refuse_mppe_40 :1; /* Allow MPPE 40-bit mode? */ + unsigned int refuse_mppe_128 :1; /* Allow MPPE 128-bit mode? */ + unsigned int refuse_mppe_stateful :1; /* Allow MPPE stateful mode? */ +#endif /* MPPE_SUPPORT */ + + u16_t listen_time; /* time to listen first (ms), waiting for peer to send LCP packet */ + +#if PPP_IDLETIMELIMIT + u16_t idle_time_limit; /* Disconnect if idle for this many seconds */ +#endif /* PPP_IDLETIMELIMIT */ +#if PPP_MAXCONNECT + u32_t maxconnect; /* Maximum connect time (seconds) */ +#endif /* PPP_MAXCONNECT */ + +#if PPP_AUTH_SUPPORT + /* auth data */ + const char *user; /* Username for PAP */ + const char *passwd; /* Password for PAP, secret for CHAP */ +#if PPP_REMOTENAME + char remote_name[MAXNAMELEN + 1]; /* Peer's name for authentication */ +#endif /* PPP_REMOTENAME */ + +#if PAP_SUPPORT + u8_t pap_timeout_time; /* Timeout (seconds) for auth-req retrans. */ + u8_t pap_max_transmits; /* Number of auth-reqs sent */ +#if PPP_SERVER + u8_t pap_req_timeout; /* Time to wait for auth-req from peer */ +#endif /* PPP_SERVER */ +#endif /* PAP_SUPPPORT */ + +#if CHAP_SUPPORT + u8_t chap_timeout_time; /* Timeout (seconds) for retransmitting req */ + u8_t chap_max_transmits; /* max # times to send challenge */ +#if PPP_SERVER + u8_t chap_rechallenge_time; /* Time to wait for auth-req from peer */ +#endif /* PPP_SERVER */ +#endif /* CHAP_SUPPPORT */ + +#if EAP_SUPPORT + u8_t eap_req_time; /* Time to wait (for retransmit/fail) */ + u8_t eap_allow_req; /* Max Requests allowed */ +#if PPP_SERVER + u8_t eap_timeout_time; /* Time to wait (for retransmit/fail) */ + u8_t eap_max_transmits; /* Max Requests allowed */ +#endif /* PPP_SERVER */ +#endif /* EAP_SUPPORT */ + +#endif /* PPP_AUTH_SUPPORT */ + + u8_t fsm_timeout_time; /* Timeout time in seconds */ + u8_t fsm_max_conf_req_transmits; /* Maximum Configure-Request transmissions */ + u8_t fsm_max_term_transmits; /* Maximum Terminate-Request transmissions */ + u8_t fsm_max_nak_loops; /* Maximum number of nak loops tolerated */ + + u8_t lcp_loopbackfail; /* Number of times we receive our magic number from the peer + before deciding the link is looped-back. */ + u8_t lcp_echo_interval; /* Interval between LCP echo-requests */ + u8_t lcp_echo_fails; /* Tolerance to unanswered echo-requests */ + +} ppp_settings; + +#if PPP_SERVER +struct ppp_addrs { +#if PPP_IPV4_SUPPORT + ip4_addr_t our_ipaddr, his_ipaddr, netmask; +#if LWIP_DNS + ip4_addr_t dns1, dns2; +#endif /* LWIP_DNS */ +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT + ip6_addr_t our6_ipaddr, his6_ipaddr; +#endif /* PPP_IPV6_SUPPORT */ +}; +#endif /* PPP_SERVER */ + +/* + * PPP interface control block. + */ +struct ppp_pcb_s { + ppp_settings settings; + const struct link_callbacks *link_cb; + void *link_ctx_cb; + void (*link_status_cb)(ppp_pcb *pcb, int err_code, void *ctx); /* Status change callback */ +#if PPP_NOTIFY_PHASE + void (*notify_phase_cb)(ppp_pcb *pcb, u8_t phase, void *ctx); /* Notify phase callback */ +#endif /* PPP_NOTIFY_PHASE */ + void *ctx_cb; /* Callbacks optional pointer */ + struct netif *netif; /* PPP interface */ + u8_t phase; /* where the link is at */ + u8_t err_code; /* Code indicating why interface is down. */ + + /* flags */ +#if PPP_IPV4_SUPPORT + unsigned int ask_for_local :1; /* request our address from peer */ + unsigned int ipcp_is_open :1; /* haven't called np_finished() */ + unsigned int ipcp_is_up :1; /* have called ipcp_up() */ + unsigned int if4_up :1; /* True when the IPv4 interface is up. */ +#if 0 /* UNUSED - PROXY ARP */ + unsigned int proxy_arp_set :1; /* Have created proxy arp entry */ +#endif /* UNUSED - PROXY ARP */ +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT + unsigned int ipv6cp_is_up :1; /* have called ip6cp_up() */ + unsigned int if6_up :1; /* True when the IPv6 interface is up. */ +#endif /* PPP_IPV6_SUPPORT */ + unsigned int lcp_echo_timer_running :1; /* set if a timer is running */ +#if VJ_SUPPORT + unsigned int vj_enabled :1; /* Flag indicating VJ compression enabled. */ +#endif /* VJ_SUPPORT */ +#if CCP_SUPPORT + unsigned int ccp_all_rejected :1; /* we rejected all peer's options */ +#endif /* CCP_SUPPORT */ +#if MPPE_SUPPORT + unsigned int mppe_keys_set :1; /* Have the MPPE keys been set? */ +#endif /* MPPE_SUPPORT */ + +#if PPP_AUTH_SUPPORT + /* auth data */ +#if PPP_SERVER && defined(HAVE_MULTILINK) + char peer_authname[MAXNAMELEN + 1]; /* The name by which the peer authenticated itself to us. */ +#endif /* PPP_SERVER && defined(HAVE_MULTILINK) */ + u16_t auth_pending; /* Records which authentication operations haven't completed yet. */ + u16_t auth_done; /* Records which authentication operations have been completed. */ + +#if PAP_SUPPORT + upap_state upap; /* PAP data */ +#endif /* PAP_SUPPORT */ + +#if CHAP_SUPPORT + chap_client_state chap_client; /* CHAP client data */ +#if PPP_SERVER + chap_server_state chap_server; /* CHAP server data */ +#endif /* PPP_SERVER */ +#endif /* CHAP_SUPPORT */ + +#if EAP_SUPPORT + eap_state eap; /* EAP data */ +#endif /* EAP_SUPPORT */ +#endif /* PPP_AUTH_SUPPORT */ + + fsm lcp_fsm; /* LCP fsm structure */ + lcp_options lcp_wantoptions; /* Options that we want to request */ + lcp_options lcp_gotoptions; /* Options that peer ack'd */ + lcp_options lcp_allowoptions; /* Options we allow peer to request */ + lcp_options lcp_hisoptions; /* Options that we ack'd */ + u16_t peer_mru; /* currently negotiated peer MRU */ + u8_t lcp_echos_pending; /* Number of outstanding echo msgs */ + u8_t lcp_echo_number; /* ID number of next echo frame */ + + u8_t num_np_open; /* Number of network protocols which we have opened. */ + u8_t num_np_up; /* Number of network protocols which have come up. */ + +#if VJ_SUPPORT + struct vjcompress vj_comp; /* Van Jacobson compression header. */ +#endif /* VJ_SUPPORT */ + +#if CCP_SUPPORT + fsm ccp_fsm; /* CCP fsm structure */ + ccp_options ccp_wantoptions; /* what to request the peer to use */ + ccp_options ccp_gotoptions; /* what the peer agreed to do */ + ccp_options ccp_allowoptions; /* what we'll agree to do */ + ccp_options ccp_hisoptions; /* what we agreed to do */ + u8_t ccp_localstate; /* Local state (mainly for handling reset-reqs and reset-acks). */ + u8_t ccp_receive_method; /* Method chosen on receive path */ + u8_t ccp_transmit_method; /* Method chosen on transmit path */ +#if MPPE_SUPPORT + ppp_mppe_state mppe_comp; /* MPPE "compressor" structure */ + ppp_mppe_state mppe_decomp; /* MPPE "decompressor" structure */ +#endif /* MPPE_SUPPORT */ +#endif /* CCP_SUPPORT */ + +#if PPP_IPV4_SUPPORT + fsm ipcp_fsm; /* IPCP fsm structure */ + ipcp_options ipcp_wantoptions; /* Options that we want to request */ + ipcp_options ipcp_gotoptions; /* Options that peer ack'd */ + ipcp_options ipcp_allowoptions; /* Options we allow peer to request */ + ipcp_options ipcp_hisoptions; /* Options that we ack'd */ +#endif /* PPP_IPV4_SUPPORT */ + +#if PPP_IPV6_SUPPORT + fsm ipv6cp_fsm; /* IPV6CP fsm structure */ + ipv6cp_options ipv6cp_wantoptions; /* Options that we want to request */ + ipv6cp_options ipv6cp_gotoptions; /* Options that peer ack'd */ + ipv6cp_options ipv6cp_allowoptions; /* Options we allow peer to request */ + ipv6cp_options ipv6cp_hisoptions; /* Options that we ack'd */ +#endif /* PPP_IPV6_SUPPORT */ +}; + +/************************ + *** PUBLIC FUNCTIONS *** + ************************/ + +/* + * WARNING: For multi-threads environment, all ppp_set_* functions most + * only be called while the PPP is in the dead phase (i.e. disconnected). + */ + +#if PPP_AUTH_SUPPORT +/* + * Set PPP authentication. + * + * Warning: Using PPPAUTHTYPE_ANY might have security consequences. + * RFC 1994 says: + * + * In practice, within or associated with each PPP server, there is a + * database which associates "user" names with authentication + * information ("secrets"). It is not anticipated that a particular + * named user would be authenticated by multiple methods. This would + * make the user vulnerable to attacks which negotiate the least secure + * method from among a set (such as PAP rather than CHAP). If the same + * secret was used, PAP would reveal the secret to be used later with + * CHAP. + * + * Instead, for each user name there should be an indication of exactly + * one method used to authenticate that user name. If a user needs to + * make use of different authentication methods under different + * circumstances, then distinct user names SHOULD be employed, each of + * which identifies exactly one authentication method. + * + * Default is none auth type, unset (NULL) user and passwd. + */ +#define PPPAUTHTYPE_NONE 0x00 +#define PPPAUTHTYPE_PAP 0x01 +#define PPPAUTHTYPE_CHAP 0x02 +#define PPPAUTHTYPE_MSCHAP 0x04 +#define PPPAUTHTYPE_MSCHAP_V2 0x08 +#define PPPAUTHTYPE_EAP 0x10 +#define PPPAUTHTYPE_ANY 0xff +void ppp_set_auth(ppp_pcb *pcb, u8_t authtype, const char *user, const char *passwd); + +/* + * If set, peer is required to authenticate. This is mostly necessary for PPP server support. + * + * Default is false. + */ +#define ppp_set_auth_required(ppp, boolval) (ppp->settings.auth_required = boolval) +#endif /* PPP_AUTH_SUPPORT */ + +#if PPP_IPV4_SUPPORT +/* + * Set PPP interface "our" and "his" IPv4 addresses. This is mostly necessary for PPP server + * support but it can also be used on a PPP link where each side choose its own IP address. + * + * Default is unset (0.0.0.0). + */ +#define ppp_set_ipcp_ouraddr(ppp, addr) do { ppp->ipcp_wantoptions.ouraddr = ip4_addr_get_u32(addr); \ + ppp->ask_for_local = ppp->ipcp_wantoptions.ouraddr != 0; } while(0) +#define ppp_set_ipcp_hisaddr(ppp, addr) (ppp->ipcp_wantoptions.hisaddr = ip4_addr_get_u32(addr)) +#if LWIP_DNS +/* + * Set DNS server addresses that are sent if the peer asks for them. This is mostly necessary + * for PPP server support. + * + * Default is unset (0.0.0.0). + */ +#define ppp_set_ipcp_dnsaddr(ppp, index, addr) (ppp->ipcp_allowoptions.dnsaddr[index] = ip4_addr_get_u32(addr)) + +/* + * If set, we ask the peer for up to 2 DNS server addresses. Received DNS server addresses are + * registered using the dns_setserver() function. + * + * Default is false. + */ +#define ppp_set_usepeerdns(ppp, boolval) (ppp->settings.usepeerdns = boolval) +#endif /* LWIP_DNS */ +#endif /* PPP_IPV4_SUPPORT */ + +#if MPPE_SUPPORT +/* Disable MPPE (Microsoft Point to Point Encryption). This parameter is exclusive. */ +#define PPP_MPPE_DISABLE 0x00 +/* Require the use of MPPE (Microsoft Point to Point Encryption). */ +#define PPP_MPPE_ENABLE 0x01 +/* Allow MPPE to use stateful mode. Stateless mode is still attempted first. */ +#define PPP_MPPE_ALLOW_STATEFUL 0x02 +/* Refuse the use of MPPE with 40-bit encryption. Conflict with PPP_MPPE_REFUSE_128. */ +#define PPP_MPPE_REFUSE_40 0x04 +/* Refuse the use of MPPE with 128-bit encryption. Conflict with PPP_MPPE_REFUSE_40. */ +#define PPP_MPPE_REFUSE_128 0x08 +/* + * Set MPPE configuration + * + * Default is disabled. + */ +void ppp_set_mppe(ppp_pcb *pcb, u8_t flags); +#endif /* MPPE_SUPPORT */ + +/* + * Wait for up to intval milliseconds for a valid PPP packet from the peer. + * At the end of this time, or when a valid PPP packet is received from the + * peer, we commence negotiation by sending our first LCP packet. + * + * Default is 0. + */ +#define ppp_set_listen_time(ppp, intval) (ppp->settings.listen_time = intval) + +/* + * If set, we will attempt to initiate a connection but if no reply is received from + * the peer, we will then just wait passively for a valid LCP packet from the peer. + * + * Default is false. + */ +#define ppp_set_passive(ppp, boolval) (ppp->lcp_wantoptions.passive = boolval) + +/* + * If set, we will not transmit LCP packets to initiate a connection until a valid + * LCP packet is received from the peer. This is what we usually call the server mode. + * + * Default is false. + */ +#define ppp_set_silent(ppp, boolval) (ppp->lcp_wantoptions.silent = boolval) + +/* + * If set, enable protocol field compression negotiation in both the receive and + * the transmit direction. + * + * Default is true. + */ +#define ppp_set_neg_pcomp(ppp, boolval) (ppp->lcp_wantoptions.neg_pcompression = \ + ppp->lcp_allowoptions.neg_pcompression = boolval) + +/* + * If set, enable Address/Control compression in both the receive and the transmit + * direction. + * + * Default is true. + */ +#define ppp_set_neg_accomp(ppp, boolval) (ppp->lcp_wantoptions.neg_accompression = \ + ppp->lcp_allowoptions.neg_accompression = boolval) + +/* + * If set, enable asyncmap negotiation. Otherwise forcing all control characters to + * be escaped for both the transmit and the receive direction. + * + * Default is true. + */ +#define ppp_set_neg_asyncmap(ppp, boolval) (ppp->lcp_wantoptions.neg_asyncmap = \ + ppp->lcp_allowoptions.neg_asyncmap = boolval) + +/* + * This option sets the Async-Control-Character-Map (ACCM) for this end of the link. + * The ACCM is a set of 32 bits, one for each of the ASCII control characters with + * values from 0 to 31, where a 1 bit indicates that the corresponding control + * character should not be used in PPP packets sent to this system. The map is + * an unsigned 32 bits integer where the least significant bit (00000001) represents + * character 0 and the most significant bit (80000000) represents character 31. + * We will then ask the peer to send these characters as a 2-byte escape sequence. + * + * Default is 0. + */ +#define ppp_set_asyncmap(ppp, intval) (ppp->lcp_wantoptions.asyncmap = intval) + +/* + * Set a PPP interface as the default network interface + * (used to output all packets for which no specific route is found). + */ +#define ppp_set_default(ppp) netif_set_default(ppp->netif) + +#if PPP_NOTIFY_PHASE +/* + * Set a PPP notify phase callback. + * + * This can be used for example to set a LED pattern depending on the + * current phase of the PPP session. + */ +typedef void (*ppp_notify_phase_cb_fn)(ppp_pcb *pcb, u8_t phase, void *ctx); +void ppp_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb); +#endif /* PPP_NOTIFY_PHASE */ + +/* + * Initiate a PPP connection. + * + * This can only be called if PPP is in the dead phase. + * + * Holdoff is the time to wait (in seconds) before initiating + * the connection. + * + * If this port connects to a modem, the modem connection must be + * established before calling this. + */ +err_t ppp_connect(ppp_pcb *pcb, u16_t holdoff); + +#if PPP_SERVER +/* + * Listen for an incoming PPP connection. + * + * This can only be called if PPP is in the dead phase. + * + * If this port connects to a modem, the modem connection must be + * established before calling this. + */ +err_t ppp_listen(ppp_pcb *pcb); +#endif /* PPP_SERVER */ + +/* + * Initiate the end of a PPP connection. + * Any outstanding packets in the queues are dropped. + * + * Setting nocarrier to 1 close the PPP connection without initiating the + * shutdown procedure. Always using nocarrier = 0 is still recommended, + * this is going to take a little longer time if your link is down, but + * is a safer choice for the PPP state machine. + * + * Return 0 on success, an error code on failure. + */ +err_t ppp_close(ppp_pcb *pcb, u8_t nocarrier); + +/* + * Release the control block. + * + * This can only be called if PPP is in the dead phase. + * + * You must use ppp_close() before if you wish to terminate + * an established PPP session. + * + * Return 0 on success, an error code on failure. + */ +err_t ppp_free(ppp_pcb *pcb); + +/* + * PPP IOCTL commands. + * + * Get the up status - 0 for down, non-zero for up. The argument must + * point to an int. + */ +#define PPPCTLG_UPSTATUS 0 + +/* + * Get the PPP error code. The argument must point to an int. + * Returns a PPPERR_* value. + */ +#define PPPCTLG_ERRCODE 1 + +/* + * Get the fd associated with a PPP over serial + */ +#define PPPCTLG_FD 2 + +/* + * Get and set parameters for the given connection. + * Return 0 on success, an error code on failure. + */ +err_t ppp_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg); + +/* Get the PPP netif interface */ +#define ppp_netif(ppp) (ppp->netif) + +/* Set an lwIP-style status-callback for the selected PPP device */ +#define ppp_set_netif_statuscallback(ppp, status_cb) \ + netif_set_status_callback(ppp->netif, status_cb); + +/* Set an lwIP-style link-callback for the selected PPP device */ +#define ppp_set_netif_linkcallback(ppp, link_cb) \ + netif_set_link_callback(ppp->netif, link_cb); + +#ifdef __cplusplus +} +#endif + +#endif /* PPP_H */ + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_impl.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_impl.h index 280ff007..40843d5a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_impl.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_impl.h @@ -1,722 +1,722 @@ -/***************************************************************************** -* ppp.h - Network Point to Point Protocol header file. -* -* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. -* portions Copyright (c) 1997 Global Election Systems Inc. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY -* -* 03-01-01 Marc Boucher -* Ported to lwIP. -* 97-11-05 Guy Lancaster , Global Election Systems Inc. -* Original derived from BSD codes. -*****************************************************************************/ -#ifndef LWIP_HDR_PPP_IMPL_H -#define LWIP_HDR_PPP_IMPL_H - -#include "netif/ppp/ppp_opts.h" - -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifdef PPP_INCLUDE_SETTINGS_HEADER -#include "ppp_settings.h" -#endif - -#include /* formats */ -#include -#include -#include /* strtol() */ - -#include "lwip/netif.h" -#include "lwip/def.h" -#include "lwip/timeouts.h" - -#include "ppp.h" -#include "pppdebug.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Memory used for control packets. - * - * PPP_CTRL_PBUF_MAX_SIZE is the amount of memory we allocate when we - * cannot figure out how much we are going to use before filling the buffer. - */ -#if PPP_USE_PBUF_RAM -#define PPP_CTRL_PBUF_TYPE PBUF_RAM -#define PPP_CTRL_PBUF_MAX_SIZE 512 -#else /* PPP_USE_PBUF_RAM */ -#define PPP_CTRL_PBUF_TYPE PBUF_POOL -#define PPP_CTRL_PBUF_MAX_SIZE PBUF_POOL_BUFSIZE -#endif /* PPP_USE_PBUF_RAM */ - -/* - * The basic PPP frame. - */ -#define PPP_ADDRESS(p) (((u_char *)(p))[0]) -#define PPP_CONTROL(p) (((u_char *)(p))[1]) -#define PPP_PROTOCOL(p) ((((u_char *)(p))[2] << 8) + ((u_char *)(p))[3]) - -/* - * Significant octet values. - */ -#define PPP_ALLSTATIONS 0xff /* All-Stations broadcast address */ -#define PPP_UI 0x03 /* Unnumbered Information */ -#define PPP_FLAG 0x7e /* Flag Sequence */ -#define PPP_ESCAPE 0x7d /* Asynchronous Control Escape */ -#define PPP_TRANS 0x20 /* Asynchronous transparency modifier */ - -/* - * Protocol field values. - */ -#define PPP_IP 0x21 /* Internet Protocol */ -#if 0 /* UNUSED */ -#define PPP_AT 0x29 /* AppleTalk Protocol */ -#define PPP_IPX 0x2b /* IPX protocol */ -#endif /* UNUSED */ -#if VJ_SUPPORT -#define PPP_VJC_COMP 0x2d /* VJ compressed TCP */ -#define PPP_VJC_UNCOMP 0x2f /* VJ uncompressed TCP */ -#endif /* VJ_SUPPORT */ -#if PPP_IPV6_SUPPORT -#define PPP_IPV6 0x57 /* Internet Protocol Version 6 */ -#endif /* PPP_IPV6_SUPPORT */ -#if CCP_SUPPORT -#define PPP_COMP 0xfd /* compressed packet */ -#endif /* CCP_SUPPORT */ -#define PPP_IPCP 0x8021 /* IP Control Protocol */ -#if 0 /* UNUSED */ -#define PPP_ATCP 0x8029 /* AppleTalk Control Protocol */ -#define PPP_IPXCP 0x802b /* IPX Control Protocol */ -#endif /* UNUSED */ -#if PPP_IPV6_SUPPORT -#define PPP_IPV6CP 0x8057 /* IPv6 Control Protocol */ -#endif /* PPP_IPV6_SUPPORT */ -#if CCP_SUPPORT -#define PPP_CCP 0x80fd /* Compression Control Protocol */ -#endif /* CCP_SUPPORT */ -#if ECP_SUPPORT -#define PPP_ECP 0x8053 /* Encryption Control Protocol */ -#endif /* ECP_SUPPORT */ -#define PPP_LCP 0xc021 /* Link Control Protocol */ -#if PAP_SUPPORT -#define PPP_PAP 0xc023 /* Password Authentication Protocol */ -#endif /* PAP_SUPPORT */ -#if LQR_SUPPORT -#define PPP_LQR 0xc025 /* Link Quality Report protocol */ -#endif /* LQR_SUPPORT */ -#if CHAP_SUPPORT -#define PPP_CHAP 0xc223 /* Cryptographic Handshake Auth. Protocol */ -#endif /* CHAP_SUPPORT */ -#if CBCP_SUPPORT -#define PPP_CBCP 0xc029 /* Callback Control Protocol */ -#endif /* CBCP_SUPPORT */ -#if EAP_SUPPORT -#define PPP_EAP 0xc227 /* Extensible Authentication Protocol */ -#endif /* EAP_SUPPORT */ - -/* - * The following struct gives the addresses of procedures to call - * for a particular lower link level protocol. - */ -struct link_callbacks { - /* Start a connection (e.g. Initiate discovery phase) */ - void (*connect) (ppp_pcb *pcb, void *ctx); -#if PPP_SERVER - /* Listen for an incoming connection (Passive mode) */ - void (*listen) (ppp_pcb *pcb, void *ctx); -#endif /* PPP_SERVER */ - /* End a connection (i.e. initiate disconnect phase) */ - void (*disconnect) (ppp_pcb *pcb, void *ctx); - /* Free lower protocol control block */ - err_t (*free) (ppp_pcb *pcb, void *ctx); - /* Write a pbuf to a ppp link, only used from PPP functions to send PPP packets. */ - err_t (*write)(ppp_pcb *pcb, void *ctx, struct pbuf *p); - /* Send a packet from lwIP core (IPv4 or IPv6) */ - err_t (*netif_output)(ppp_pcb *pcb, void *ctx, struct pbuf *p, u_short protocol); - /* configure the transmit-side characteristics of the PPP interface */ - void (*send_config)(ppp_pcb *pcb, void *ctx, u32_t accm, int pcomp, int accomp); - /* confire the receive-side characteristics of the PPP interface */ - void (*recv_config)(ppp_pcb *pcb, void *ctx, u32_t accm, int pcomp, int accomp); -}; - -/* - * What to do with network protocol (NP) packets. - */ -enum NPmode { - NPMODE_PASS, /* pass the packet through */ - NPMODE_DROP, /* silently drop the packet */ - NPMODE_ERROR, /* return an error */ - NPMODE_QUEUE /* save it up for later. */ -}; - -/* - * Statistics. - */ -#if PPP_STATS_SUPPORT -struct pppstat { - unsigned int ppp_ibytes; /* bytes received */ - unsigned int ppp_ipackets; /* packets received */ - unsigned int ppp_ierrors; /* receive errors */ - unsigned int ppp_obytes; /* bytes sent */ - unsigned int ppp_opackets; /* packets sent */ - unsigned int ppp_oerrors; /* transmit errors */ -}; - -#if VJ_SUPPORT -struct vjstat { - unsigned int vjs_packets; /* outbound packets */ - unsigned int vjs_compressed; /* outbound compressed packets */ - unsigned int vjs_searches; /* searches for connection state */ - unsigned int vjs_misses; /* times couldn't find conn. state */ - unsigned int vjs_uncompressedin; /* inbound uncompressed packets */ - unsigned int vjs_compressedin; /* inbound compressed packets */ - unsigned int vjs_errorin; /* inbound unknown type packets */ - unsigned int vjs_tossed; /* inbound packets tossed because of error */ -}; -#endif /* VJ_SUPPORT */ - -struct ppp_stats { - struct pppstat p; /* basic PPP statistics */ -#if VJ_SUPPORT - struct vjstat vj; /* VJ header compression statistics */ -#endif /* VJ_SUPPORT */ -}; - -#if CCP_SUPPORT -struct compstat { - unsigned int unc_bytes; /* total uncompressed bytes */ - unsigned int unc_packets; /* total uncompressed packets */ - unsigned int comp_bytes; /* compressed bytes */ - unsigned int comp_packets; /* compressed packets */ - unsigned int inc_bytes; /* incompressible bytes */ - unsigned int inc_packets; /* incompressible packets */ - unsigned int ratio; /* recent compression ratio << 8 */ -}; - -struct ppp_comp_stats { - struct compstat c; /* packet compression statistics */ - struct compstat d; /* packet decompression statistics */ -}; -#endif /* CCP_SUPPORT */ - -#endif /* PPP_STATS_SUPPORT */ - -#if PPP_IDLETIMELIMIT -/* - * The following structure records the time in seconds since - * the last NP packet was sent or received. - */ -struct ppp_idle { - time_t xmit_idle; /* time since last NP packet sent */ - time_t recv_idle; /* time since last NP packet received */ -}; -#endif /* PPP_IDLETIMELIMIT */ - -/* values for epdisc.class */ -#define EPD_NULL 0 /* null discriminator, no data */ -#define EPD_LOCAL 1 -#define EPD_IP 2 -#define EPD_MAC 3 -#define EPD_MAGIC 4 -#define EPD_PHONENUM 5 - -/* - * Global variables. - */ -#ifdef HAVE_MULTILINK -extern u8_t multilink; /* enable multilink operation */ -extern u8_t doing_multilink; -extern u8_t multilink_master; -extern u8_t bundle_eof; -extern u8_t bundle_terminating; -#endif - -#ifdef MAXOCTETS -extern unsigned int maxoctets; /* Maximum octetes per session (in bytes) */ -extern int maxoctets_dir; /* Direction : - 0 - in+out (default) - 1 - in - 2 - out - 3 - max(in,out) */ -extern int maxoctets_timeout; /* Timeout for check of octets limit */ -#define PPP_OCTETS_DIRECTION_SUM 0 -#define PPP_OCTETS_DIRECTION_IN 1 -#define PPP_OCTETS_DIRECTION_OUT 2 -#define PPP_OCTETS_DIRECTION_MAXOVERAL 3 -/* same as previos, but little different on RADIUS side */ -#define PPP_OCTETS_DIRECTION_MAXSESSION 4 -#endif - -/* Data input may be used by CCP and ECP, remove this entry - * from struct protent to save some flash - */ -#define PPP_DATAINPUT 0 - -/* - * The following struct gives the addresses of procedures to call - * for a particular protocol. - */ -struct protent { - u_short protocol; /* PPP protocol number */ - /* Initialization procedure */ - void (*init) (ppp_pcb *pcb); - /* Process a received packet */ - void (*input) (ppp_pcb *pcb, u_char *pkt, int len); - /* Process a received protocol-reject */ - void (*protrej) (ppp_pcb *pcb); - /* Lower layer has come up */ - void (*lowerup) (ppp_pcb *pcb); - /* Lower layer has gone down */ - void (*lowerdown) (ppp_pcb *pcb); - /* Open the protocol */ - void (*open) (ppp_pcb *pcb); - /* Close the protocol */ - void (*close) (ppp_pcb *pcb, const char *reason); -#if PRINTPKT_SUPPORT - /* Print a packet in readable form */ - int (*printpkt) (const u_char *pkt, int len, - void (*printer) (void *, const char *, ...), - void *arg); -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - /* Process a received data packet */ - void (*datainput) (ppp_pcb *pcb, u_char *pkt, int len); -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - const char *name; /* Text name of protocol */ - const char *data_name; /* Text name of corresponding data protocol */ -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - option_t *options; /* List of command-line options */ - /* Check requested options, assign defaults */ - void (*check_options) (void); -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - /* Configure interface for demand-dial */ - int (*demand_conf) (int unit); - /* Say whether to bring up link for this pkt */ - int (*active_pkt) (u_char *pkt, int len); -#endif /* DEMAND_SUPPORT */ -}; - -/* Table of pointers to supported protocols */ -extern const struct protent* const protocols[]; - - -/* Values for auth_pending, auth_done */ -#if PAP_SUPPORT -#define PAP_WITHPEER 0x1 -#define PAP_PEER 0x2 -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT -#define CHAP_WITHPEER 0x4 -#define CHAP_PEER 0x8 -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT -#define EAP_WITHPEER 0x10 -#define EAP_PEER 0x20 -#endif /* EAP_SUPPORT */ - -/* Values for auth_done only */ -#if CHAP_SUPPORT -#define CHAP_MD5_WITHPEER 0x40 -#define CHAP_MD5_PEER 0x80 -#if MSCHAP_SUPPORT -#define CHAP_MS_SHIFT 8 /* LSB position for MS auths */ -#define CHAP_MS_WITHPEER 0x100 -#define CHAP_MS_PEER 0x200 -#define CHAP_MS2_WITHPEER 0x400 -#define CHAP_MS2_PEER 0x800 -#endif /* MSCHAP_SUPPORT */ -#endif /* CHAP_SUPPORT */ - -/* Supported CHAP protocols */ -#if CHAP_SUPPORT - -#if MSCHAP_SUPPORT -#define CHAP_MDTYPE_SUPPORTED (MDTYPE_MICROSOFT_V2 | MDTYPE_MICROSOFT | MDTYPE_MD5) -#else /* MSCHAP_SUPPORT */ -#define CHAP_MDTYPE_SUPPORTED (MDTYPE_MD5) -#endif /* MSCHAP_SUPPORT */ - -#else /* CHAP_SUPPORT */ -#define CHAP_MDTYPE_SUPPORTED (MDTYPE_NONE) -#endif /* CHAP_SUPPORT */ - -#if PPP_STATS_SUPPORT -/* - * PPP statistics structure - */ -struct pppd_stats { - unsigned int bytes_in; - unsigned int bytes_out; - unsigned int pkts_in; - unsigned int pkts_out; -}; -#endif /* PPP_STATS_SUPPORT */ - - -/* - * PPP private functions - */ - - -/* - * Functions called from lwIP core. - */ - -/* initialize the PPP subsystem */ -int ppp_init(void); - -/* - * Functions called from PPP link protocols. - */ - -/* Create a new PPP control block */ -ppp_pcb *ppp_new(struct netif *pppif, const struct link_callbacks *callbacks, void *link_ctx_cb, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb); - -/* Initiate LCP open request */ -void ppp_start(ppp_pcb *pcb); - -/* Called when link failed to setup */ -void ppp_link_failed(ppp_pcb *pcb); - -/* Called when link is normally down (i.e. it was asked to end) */ -void ppp_link_end(ppp_pcb *pcb); - -/* function called to process input packet */ -void ppp_input(ppp_pcb *pcb, struct pbuf *pb); - - -/* - * Functions called by PPP protocols. - */ - -/* function called by all PPP subsystems to send packets */ -err_t ppp_write(ppp_pcb *pcb, struct pbuf *p); - -/* functions called by auth.c link_terminated() */ -void ppp_link_terminated(ppp_pcb *pcb); - -void new_phase(ppp_pcb *pcb, int p); - -int ppp_send_config(ppp_pcb *pcb, int mtu, u32_t accm, int pcomp, int accomp); -int ppp_recv_config(ppp_pcb *pcb, int mru, u32_t accm, int pcomp, int accomp); - -#if PPP_IPV4_SUPPORT -int sifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr, u32_t netmask); -int cifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr); -#if 0 /* UNUSED - PROXY ARP */ -int sifproxyarp(ppp_pcb *pcb, u32_t his_adr); -int cifproxyarp(ppp_pcb *pcb, u32_t his_adr); -#endif /* UNUSED - PROXY ARP */ -#if LWIP_DNS -int sdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2); -int cdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2); -#endif /* LWIP_DNS */ -#if VJ_SUPPORT -int sifvjcomp(ppp_pcb *pcb, int vjcomp, int cidcomp, int maxcid); -#endif /* VJ_SUPPORT */ -int sifup(ppp_pcb *pcb); -int sifdown (ppp_pcb *pcb); -u32_t get_mask(u32_t addr); -#endif /* PPP_IPV4_SUPPORT */ - -#if PPP_IPV6_SUPPORT -int sif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64); -int cif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64); -int sif6up(ppp_pcb *pcb); -int sif6down (ppp_pcb *pcb); -#endif /* PPP_IPV6_SUPPORT */ - -#if DEMAND_SUPPORT -int sifnpmode(ppp_pcb *pcb, int proto, enum NPmode mode); -#endif /* DEMAND_SUPPORt */ - -void netif_set_mtu(ppp_pcb *pcb, int mtu); -int netif_get_mtu(ppp_pcb *pcb); - -#if CCP_SUPPORT -#if 0 /* unused */ -int ccp_test(ppp_pcb *pcb, u_char *opt_ptr, int opt_len, int for_transmit); -#endif /* unused */ -void ccp_set(ppp_pcb *pcb, u8_t isopen, u8_t isup, u8_t receive_method, u8_t transmit_method); -void ccp_reset_comp(ppp_pcb *pcb); -void ccp_reset_decomp(ppp_pcb *pcb); -#if 0 /* unused */ -int ccp_fatal_error(ppp_pcb *pcb); -#endif /* unused */ -#endif /* CCP_SUPPORT */ - -#if PPP_IDLETIMELIMIT -int get_idle_time(ppp_pcb *pcb, struct ppp_idle *ip); -#endif /* PPP_IDLETIMELIMIT */ - -#if DEMAND_SUPPORT -int get_loop_output(void); -#endif /* DEMAND_SUPPORT */ - -/* Optional protocol names list, to make our messages a little more informative. */ -#if PPP_PROTOCOLNAME -const char * protocol_name(int proto); -#endif /* PPP_PROTOCOLNAME */ - -/* Optional stats support, to get some statistics on the PPP interface */ -#if PPP_STATS_SUPPORT -void print_link_stats(void); /* Print stats, if available */ -void reset_link_stats(int u); /* Reset (init) stats when link goes up */ -void update_link_stats(int u); /* Get stats at link termination */ -#endif /* PPP_STATS_SUPPORT */ - - - -/* - * Inline versions of get/put char/short/long. - * Pointer is advanced; we assume that both arguments - * are lvalues and will already be in registers. - * cp MUST be u_char *. - */ -#define GETCHAR(c, cp) { \ - (c) = *(cp)++; \ -} -#define PUTCHAR(c, cp) { \ - *(cp)++ = (u_char) (c); \ -} -#define GETSHORT(s, cp) { \ - (s) = *(cp)++ << 8; \ - (s) |= *(cp)++; \ -} -#define PUTSHORT(s, cp) { \ - *(cp)++ = (u_char) ((s) >> 8); \ - *(cp)++ = (u_char) (s); \ -} -#define GETLONG(l, cp) { \ - (l) = *(cp)++ << 8; \ - (l) |= *(cp)++; (l) <<= 8; \ - (l) |= *(cp)++; (l) <<= 8; \ - (l) |= *(cp)++; \ -} -#define PUTLONG(l, cp) { \ - *(cp)++ = (u_char) ((l) >> 24); \ - *(cp)++ = (u_char) ((l) >> 16); \ - *(cp)++ = (u_char) ((l) >> 8); \ - *(cp)++ = (u_char) (l); \ -} - -#define INCPTR(n, cp) ((cp) += (n)) -#define DECPTR(n, cp) ((cp) -= (n)) - -/* - * System dependent definitions for user-level 4.3BSD UNIX implementation. - */ -#define TIMEOUT(f, a, t) do { sys_untimeout((f), (a)); sys_timeout((t)*1000, (f), (a)); } while(0) -#define TIMEOUTMS(f, a, t) do { sys_untimeout((f), (a)); sys_timeout((t), (f), (a)); } while(0) -#define UNTIMEOUT(f, a) sys_untimeout((f), (a)) - -#define BZERO(s, n) memset(s, 0, n) -#define BCMP(s1, s2, l) memcmp(s1, s2, l) - -#define PRINTMSG(m, l) { ppp_info("Remote message: %0.*v", l, m); } - -/* - * MAKEHEADER - Add Header fields to a packet. - */ -#define MAKEHEADER(p, t) { \ - PUTCHAR(PPP_ALLSTATIONS, p); \ - PUTCHAR(PPP_UI, p); \ - PUTSHORT(t, p); } - -/* Procedures exported from auth.c */ -void link_required(ppp_pcb *pcb); /* we are starting to use the link */ -void link_terminated(ppp_pcb *pcb); /* we are finished with the link */ -void link_down(ppp_pcb *pcb); /* the LCP layer has left the Opened state */ -void upper_layers_down(ppp_pcb *pcb); /* take all NCPs down */ -void link_established(ppp_pcb *pcb); /* the link is up; authenticate now */ -void start_networks(ppp_pcb *pcb); /* start all the network control protos */ -void continue_networks(ppp_pcb *pcb); /* start network [ip, etc] control protos */ -#if PPP_AUTH_SUPPORT -#if PPP_SERVER -int auth_check_passwd(ppp_pcb *pcb, char *auser, int userlen, char *apasswd, int passwdlen, const char **msg, int *msglen); - /* check the user name and passwd against configuration */ -void auth_peer_fail(ppp_pcb *pcb, int protocol); - /* peer failed to authenticate itself */ -void auth_peer_success(ppp_pcb *pcb, int protocol, int prot_flavor, const char *name, int namelen); - /* peer successfully authenticated itself */ -#endif /* PPP_SERVER */ -void auth_withpeer_fail(ppp_pcb *pcb, int protocol); - /* we failed to authenticate ourselves */ -void auth_withpeer_success(ppp_pcb *pcb, int protocol, int prot_flavor); - /* we successfully authenticated ourselves */ -#endif /* PPP_AUTH_SUPPORT */ -void np_up(ppp_pcb *pcb, int proto); /* a network protocol has come up */ -void np_down(ppp_pcb *pcb, int proto); /* a network protocol has gone down */ -void np_finished(ppp_pcb *pcb, int proto); /* a network protocol no longer needs link */ -#if PPP_AUTH_SUPPORT -int get_secret(ppp_pcb *pcb, const char *client, const char *server, char *secret, int *secret_len, int am_server); - /* get "secret" for chap */ -#endif /* PPP_AUTH_SUPPORT */ - -/* Procedures exported from ipcp.c */ -/* int parse_dotted_ip (char *, u32_t *); */ - -/* Procedures exported from demand.c */ -#if DEMAND_SUPPORT -void demand_conf (void); /* config interface(s) for demand-dial */ -void demand_block (void); /* set all NPs to queue up packets */ -void demand_unblock (void); /* set all NPs to pass packets */ -void demand_discard (void); /* set all NPs to discard packets */ -void demand_rexmit (int, u32_t); /* retransmit saved frames for an NP*/ -int loop_chars (unsigned char *, int); /* process chars from loopback */ -int loop_frame (unsigned char *, int); /* should we bring link up? */ -#endif /* DEMAND_SUPPORT */ - -/* Procedures exported from multilink.c */ -#ifdef HAVE_MULTILINK -void mp_check_options (void); /* Check multilink-related options */ -int mp_join_bundle (void); /* join our link to an appropriate bundle */ -void mp_exit_bundle (void); /* have disconnected our link from bundle */ -void mp_bundle_terminated (void); -char *epdisc_to_str (struct epdisc *); /* string from endpoint discrim. */ -int str_to_epdisc (struct epdisc *, char *); /* endpt disc. from str */ -#else -#define mp_bundle_terminated() /* nothing */ -#define mp_exit_bundle() /* nothing */ -#define doing_multilink 0 -#define multilink_master 0 -#endif - -/* Procedures exported from utils.c. */ -void ppp_print_string(const u_char *p, int len, void (*printer) (void *, const char *, ...), void *arg); /* Format a string for output */ -int ppp_slprintf(char *buf, int buflen, const char *fmt, ...); /* sprintf++ */ -int ppp_vslprintf(char *buf, int buflen, const char *fmt, va_list args); /* vsprintf++ */ -size_t ppp_strlcpy(char *dest, const char *src, size_t len); /* safe strcpy */ -size_t ppp_strlcat(char *dest, const char *src, size_t len); /* safe strncpy */ -void ppp_dbglog(const char *fmt, ...); /* log a debug message */ -void ppp_info(const char *fmt, ...); /* log an informational message */ -void ppp_notice(const char *fmt, ...); /* log a notice-level message */ -void ppp_warn(const char *fmt, ...); /* log a warning message */ -void ppp_error(const char *fmt, ...); /* log an error message */ -void ppp_fatal(const char *fmt, ...); /* log an error message and die(1) */ -#if PRINTPKT_SUPPORT -void ppp_dump_packet(ppp_pcb *pcb, const char *tag, unsigned char *p, int len); - /* dump packet to debug log if interesting */ -#endif /* PRINTPKT_SUPPORT */ - -/* - * Number of necessary timers analysis. - * - * PPP use at least one timer per each of its protocol, but not all protocols are - * active at the same time, thus the number of necessary timeouts is actually - * lower than enabled protocols. Here is the actual necessary timeouts based - * on code analysis. - * - * Note that many features analysed here are not working at all and are only - * there for a comprehensive analysis of necessary timers in order to prevent - * having to redo that each time we add a feature. - * - * Timer list - * - * | holdoff timeout - * | low level protocol timeout (PPPoE or PPPoL2P) - * | LCP delayed UP - * | LCP retransmit (FSM) - * | LCP Echo timer - * .| PAP or CHAP or EAP authentication - * . | ECP retransmit (FSM) - * . | CCP retransmit (FSM) when MPPE is enabled - * . | CCP retransmit (FSM) when MPPE is NOT enabled - * . | IPCP retransmit (FSM) - * . .| IP6CP retransmit (FSM) - * . . | Idle time limit - * . . | Max connect time - * . . | Max octets - * . . | CCP RACK timeout - * . . . - * PPP_PHASE_DEAD - * PPP_PHASE_HOLDOFF - * | . . . - * PPP_PHASE_INITIALIZE - * | . . . - * PPP_PHASE_ESTABLISH - * | . . . - * |. . . - * | . . - * PPP_PHASE_AUTHENTICATE - * | . . - * || . . - * PPP_PHASE_NETWORK - * | || . . - * | ||| . - * PPP_PHASE_RUNNING - * | .||||| - * | . |||| - * PPP_PHASE_TERMINATE - * | . |||| - * PPP_PHASE_NETWORK - * |. . - * PPP_PHASE_ESTABLISH - * PPP_PHASE_DISCONNECT - * PPP_PHASE_DEAD - * - * Alright, PPP basic retransmission and LCP Echo consume one timer. - * 1 - * - * If authentication is enabled one timer is necessary during authentication. - * 1 + PPP_AUTH_SUPPORT - * - * If ECP is enabled one timer is necessary before IPCP and/or IP6CP, one more - * is necessary if CCP is enabled (only with MPPE support but we don't care much - * up to this detail level). - * 1 + ECP_SUPPORT + CCP_SUPPORT - * - * If CCP is enabled it might consume a timer during IPCP or IP6CP, thus - * we might use IPCP, IP6CP and CCP timers simultaneously. - * 1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT - * - * When entering running phase, IPCP or IP6CP is still running. If idle time limit - * is enabled one more timer is necessary. Same for max connect time and max - * octets features. Furthermore CCP RACK might be used past this point. - * 1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT -1 + PPP_IDLETIMELIMIT + PPP_MAXCONNECT + MAXOCTETS + CCP_SUPPORT - * - * IPv4 or IPv6 must be enabled, therefore we don't need to take care the authentication - * and the CCP + ECP case, thus reducing overall complexity. - * 1 + LWIP_MAX(PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT, PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT -1 + PPP_IDLETIMELIMIT + PPP_MAXCONNECT + MAXOCTETS + CCP_SUPPORT) - * - * We don't support PPP_IDLETIMELIMIT + PPP_MAXCONNECT + MAXOCTETS features - * and adding those defines to ppp_opts.h just for having the value always - * defined to 0 isn't worth it. - * 1 + LWIP_MAX(PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT, PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT -1 + CCP_SUPPORT) - * - * Thus, the following is enough for now. - * 1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT - */ - -#ifdef __cplusplus -} -#endif - -#endif /* PPP_SUPPORT */ -#endif /* LWIP_HDR_PPP_IMPL_H */ +/***************************************************************************** +* ppp.h - Network Point to Point Protocol header file. +* +* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. +* portions Copyright (c) 1997 Global Election Systems Inc. +* +* The authors hereby grant permission to use, copy, modify, distribute, +* and license this software and its documentation for any purpose, provided +* that existing copyright notices are retained in all copies and that this +* notice and the following disclaimer are included verbatim in any +* distributions. No written agreement, license, or royalty fee is required +* for any of the authorized uses. +* +* THIS SOFTWARE IS PROVIDED BY THE 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 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. +* +****************************************************************************** +* REVISION HISTORY +* +* 03-01-01 Marc Boucher +* Ported to lwIP. +* 97-11-05 Guy Lancaster , Global Election Systems Inc. +* Original derived from BSD codes. +*****************************************************************************/ +#ifndef LWIP_HDR_PPP_IMPL_H +#define LWIP_HDR_PPP_IMPL_H + +#include "netif/ppp/ppp_opts.h" + +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifdef PPP_INCLUDE_SETTINGS_HEADER +#include "ppp_settings.h" +#endif + +#include /* formats */ +#include +#include +#include /* strtol() */ + +#include "lwip/netif.h" +#include "lwip/def.h" +#include "lwip/timeouts.h" + +#include "ppp.h" +#include "pppdebug.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Memory used for control packets. + * + * PPP_CTRL_PBUF_MAX_SIZE is the amount of memory we allocate when we + * cannot figure out how much we are going to use before filling the buffer. + */ +#if PPP_USE_PBUF_RAM +#define PPP_CTRL_PBUF_TYPE PBUF_RAM +#define PPP_CTRL_PBUF_MAX_SIZE 512 +#else /* PPP_USE_PBUF_RAM */ +#define PPP_CTRL_PBUF_TYPE PBUF_POOL +#define PPP_CTRL_PBUF_MAX_SIZE PBUF_POOL_BUFSIZE +#endif /* PPP_USE_PBUF_RAM */ + +/* + * The basic PPP frame. + */ +#define PPP_ADDRESS(p) (((u_char *)(p))[0]) +#define PPP_CONTROL(p) (((u_char *)(p))[1]) +#define PPP_PROTOCOL(p) ((((u_char *)(p))[2] << 8) + ((u_char *)(p))[3]) + +/* + * Significant octet values. + */ +#define PPP_ALLSTATIONS 0xff /* All-Stations broadcast address */ +#define PPP_UI 0x03 /* Unnumbered Information */ +#define PPP_FLAG 0x7e /* Flag Sequence */ +#define PPP_ESCAPE 0x7d /* Asynchronous Control Escape */ +#define PPP_TRANS 0x20 /* Asynchronous transparency modifier */ + +/* + * Protocol field values. + */ +#define PPP_IP 0x21 /* Internet Protocol */ +#if 0 /* UNUSED */ +#define PPP_AT 0x29 /* AppleTalk Protocol */ +#define PPP_IPX 0x2b /* IPX protocol */ +#endif /* UNUSED */ +#if VJ_SUPPORT +#define PPP_VJC_COMP 0x2d /* VJ compressed TCP */ +#define PPP_VJC_UNCOMP 0x2f /* VJ uncompressed TCP */ +#endif /* VJ_SUPPORT */ +#if PPP_IPV6_SUPPORT +#define PPP_IPV6 0x57 /* Internet Protocol Version 6 */ +#endif /* PPP_IPV6_SUPPORT */ +#if CCP_SUPPORT +#define PPP_COMP 0xfd /* compressed packet */ +#endif /* CCP_SUPPORT */ +#define PPP_IPCP 0x8021 /* IP Control Protocol */ +#if 0 /* UNUSED */ +#define PPP_ATCP 0x8029 /* AppleTalk Control Protocol */ +#define PPP_IPXCP 0x802b /* IPX Control Protocol */ +#endif /* UNUSED */ +#if PPP_IPV6_SUPPORT +#define PPP_IPV6CP 0x8057 /* IPv6 Control Protocol */ +#endif /* PPP_IPV6_SUPPORT */ +#if CCP_SUPPORT +#define PPP_CCP 0x80fd /* Compression Control Protocol */ +#endif /* CCP_SUPPORT */ +#if ECP_SUPPORT +#define PPP_ECP 0x8053 /* Encryption Control Protocol */ +#endif /* ECP_SUPPORT */ +#define PPP_LCP 0xc021 /* Link Control Protocol */ +#if PAP_SUPPORT +#define PPP_PAP 0xc023 /* Password Authentication Protocol */ +#endif /* PAP_SUPPORT */ +#if LQR_SUPPORT +#define PPP_LQR 0xc025 /* Link Quality Report protocol */ +#endif /* LQR_SUPPORT */ +#if CHAP_SUPPORT +#define PPP_CHAP 0xc223 /* Cryptographic Handshake Auth. Protocol */ +#endif /* CHAP_SUPPORT */ +#if CBCP_SUPPORT +#define PPP_CBCP 0xc029 /* Callback Control Protocol */ +#endif /* CBCP_SUPPORT */ +#if EAP_SUPPORT +#define PPP_EAP 0xc227 /* Extensible Authentication Protocol */ +#endif /* EAP_SUPPORT */ + +/* + * The following struct gives the addresses of procedures to call + * for a particular lower link level protocol. + */ +struct link_callbacks { + /* Start a connection (e.g. Initiate discovery phase) */ + void (*connect) (ppp_pcb *pcb, void *ctx); +#if PPP_SERVER + /* Listen for an incoming connection (Passive mode) */ + void (*listen) (ppp_pcb *pcb, void *ctx); +#endif /* PPP_SERVER */ + /* End a connection (i.e. initiate disconnect phase) */ + void (*disconnect) (ppp_pcb *pcb, void *ctx); + /* Free lower protocol control block */ + err_t (*free) (ppp_pcb *pcb, void *ctx); + /* Write a pbuf to a ppp link, only used from PPP functions to send PPP packets. */ + err_t (*write)(ppp_pcb *pcb, void *ctx, struct pbuf *p); + /* Send a packet from lwIP core (IPv4 or IPv6) */ + err_t (*netif_output)(ppp_pcb *pcb, void *ctx, struct pbuf *p, u_short protocol); + /* configure the transmit-side characteristics of the PPP interface */ + void (*send_config)(ppp_pcb *pcb, void *ctx, u32_t accm, int pcomp, int accomp); + /* confire the receive-side characteristics of the PPP interface */ + void (*recv_config)(ppp_pcb *pcb, void *ctx, u32_t accm, int pcomp, int accomp); +}; + +/* + * What to do with network protocol (NP) packets. + */ +enum NPmode { + NPMODE_PASS, /* pass the packet through */ + NPMODE_DROP, /* silently drop the packet */ + NPMODE_ERROR, /* return an error */ + NPMODE_QUEUE /* save it up for later. */ +}; + +/* + * Statistics. + */ +#if PPP_STATS_SUPPORT +struct pppstat { + unsigned int ppp_ibytes; /* bytes received */ + unsigned int ppp_ipackets; /* packets received */ + unsigned int ppp_ierrors; /* receive errors */ + unsigned int ppp_obytes; /* bytes sent */ + unsigned int ppp_opackets; /* packets sent */ + unsigned int ppp_oerrors; /* transmit errors */ +}; + +#if VJ_SUPPORT +struct vjstat { + unsigned int vjs_packets; /* outbound packets */ + unsigned int vjs_compressed; /* outbound compressed packets */ + unsigned int vjs_searches; /* searches for connection state */ + unsigned int vjs_misses; /* times couldn't find conn. state */ + unsigned int vjs_uncompressedin; /* inbound uncompressed packets */ + unsigned int vjs_compressedin; /* inbound compressed packets */ + unsigned int vjs_errorin; /* inbound unknown type packets */ + unsigned int vjs_tossed; /* inbound packets tossed because of error */ +}; +#endif /* VJ_SUPPORT */ + +struct ppp_stats { + struct pppstat p; /* basic PPP statistics */ +#if VJ_SUPPORT + struct vjstat vj; /* VJ header compression statistics */ +#endif /* VJ_SUPPORT */ +}; + +#if CCP_SUPPORT +struct compstat { + unsigned int unc_bytes; /* total uncompressed bytes */ + unsigned int unc_packets; /* total uncompressed packets */ + unsigned int comp_bytes; /* compressed bytes */ + unsigned int comp_packets; /* compressed packets */ + unsigned int inc_bytes; /* incompressible bytes */ + unsigned int inc_packets; /* incompressible packets */ + unsigned int ratio; /* recent compression ratio << 8 */ +}; + +struct ppp_comp_stats { + struct compstat c; /* packet compression statistics */ + struct compstat d; /* packet decompression statistics */ +}; +#endif /* CCP_SUPPORT */ + +#endif /* PPP_STATS_SUPPORT */ + +#if PPP_IDLETIMELIMIT +/* + * The following structure records the time in seconds since + * the last NP packet was sent or received. + */ +struct ppp_idle { + time_t xmit_idle; /* time since last NP packet sent */ + time_t recv_idle; /* time since last NP packet received */ +}; +#endif /* PPP_IDLETIMELIMIT */ + +/* values for epdisc.class */ +#define EPD_NULL 0 /* null discriminator, no data */ +#define EPD_LOCAL 1 +#define EPD_IP 2 +#define EPD_MAC 3 +#define EPD_MAGIC 4 +#define EPD_PHONENUM 5 + +/* + * Global variables. + */ +#ifdef HAVE_MULTILINK +extern u8_t multilink; /* enable multilink operation */ +extern u8_t doing_multilink; +extern u8_t multilink_master; +extern u8_t bundle_eof; +extern u8_t bundle_terminating; +#endif + +#ifdef MAXOCTETS +extern unsigned int maxoctets; /* Maximum octetes per session (in bytes) */ +extern int maxoctets_dir; /* Direction : + 0 - in+out (default) + 1 - in + 2 - out + 3 - max(in,out) */ +extern int maxoctets_timeout; /* Timeout for check of octets limit */ +#define PPP_OCTETS_DIRECTION_SUM 0 +#define PPP_OCTETS_DIRECTION_IN 1 +#define PPP_OCTETS_DIRECTION_OUT 2 +#define PPP_OCTETS_DIRECTION_MAXOVERAL 3 +/* same as previos, but little different on RADIUS side */ +#define PPP_OCTETS_DIRECTION_MAXSESSION 4 +#endif + +/* Data input may be used by CCP and ECP, remove this entry + * from struct protent to save some flash + */ +#define PPP_DATAINPUT 0 + +/* + * The following struct gives the addresses of procedures to call + * for a particular protocol. + */ +struct protent { + u_short protocol; /* PPP protocol number */ + /* Initialization procedure */ + void (*init) (ppp_pcb *pcb); + /* Process a received packet */ + void (*input) (ppp_pcb *pcb, u_char *pkt, int len); + /* Process a received protocol-reject */ + void (*protrej) (ppp_pcb *pcb); + /* Lower layer has come up */ + void (*lowerup) (ppp_pcb *pcb); + /* Lower layer has gone down */ + void (*lowerdown) (ppp_pcb *pcb); + /* Open the protocol */ + void (*open) (ppp_pcb *pcb); + /* Close the protocol */ + void (*close) (ppp_pcb *pcb, const char *reason); +#if PRINTPKT_SUPPORT + /* Print a packet in readable form */ + int (*printpkt) (const u_char *pkt, int len, + void (*printer) (void *, const char *, ...), + void *arg); +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + /* Process a received data packet */ + void (*datainput) (ppp_pcb *pcb, u_char *pkt, int len); +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + const char *name; /* Text name of protocol */ + const char *data_name; /* Text name of corresponding data protocol */ +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + option_t *options; /* List of command-line options */ + /* Check requested options, assign defaults */ + void (*check_options) (void); +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + /* Configure interface for demand-dial */ + int (*demand_conf) (int unit); + /* Say whether to bring up link for this pkt */ + int (*active_pkt) (u_char *pkt, int len); +#endif /* DEMAND_SUPPORT */ +}; + +/* Table of pointers to supported protocols */ +extern const struct protent* const protocols[]; + + +/* Values for auth_pending, auth_done */ +#if PAP_SUPPORT +#define PAP_WITHPEER 0x1 +#define PAP_PEER 0x2 +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT +#define CHAP_WITHPEER 0x4 +#define CHAP_PEER 0x8 +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT +#define EAP_WITHPEER 0x10 +#define EAP_PEER 0x20 +#endif /* EAP_SUPPORT */ + +/* Values for auth_done only */ +#if CHAP_SUPPORT +#define CHAP_MD5_WITHPEER 0x40 +#define CHAP_MD5_PEER 0x80 +#if MSCHAP_SUPPORT +#define CHAP_MS_SHIFT 8 /* LSB position for MS auths */ +#define CHAP_MS_WITHPEER 0x100 +#define CHAP_MS_PEER 0x200 +#define CHAP_MS2_WITHPEER 0x400 +#define CHAP_MS2_PEER 0x800 +#endif /* MSCHAP_SUPPORT */ +#endif /* CHAP_SUPPORT */ + +/* Supported CHAP protocols */ +#if CHAP_SUPPORT + +#if MSCHAP_SUPPORT +#define CHAP_MDTYPE_SUPPORTED (MDTYPE_MICROSOFT_V2 | MDTYPE_MICROSOFT | MDTYPE_MD5) +#else /* MSCHAP_SUPPORT */ +#define CHAP_MDTYPE_SUPPORTED (MDTYPE_MD5) +#endif /* MSCHAP_SUPPORT */ + +#else /* CHAP_SUPPORT */ +#define CHAP_MDTYPE_SUPPORTED (MDTYPE_NONE) +#endif /* CHAP_SUPPORT */ + +#if PPP_STATS_SUPPORT +/* + * PPP statistics structure + */ +struct pppd_stats { + unsigned int bytes_in; + unsigned int bytes_out; + unsigned int pkts_in; + unsigned int pkts_out; +}; +#endif /* PPP_STATS_SUPPORT */ + + +/* + * PPP private functions + */ + + +/* + * Functions called from lwIP core. + */ + +/* initialize the PPP subsystem */ +int ppp_init(void); + +/* + * Functions called from PPP link protocols. + */ + +/* Create a new PPP control block */ +ppp_pcb *ppp_new(struct netif *pppif, const struct link_callbacks *callbacks, void *link_ctx_cb, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb); + +/* Initiate LCP open request */ +void ppp_start(ppp_pcb *pcb); + +/* Called when link failed to setup */ +void ppp_link_failed(ppp_pcb *pcb); + +/* Called when link is normally down (i.e. it was asked to end) */ +void ppp_link_end(ppp_pcb *pcb); + +/* function called to process input packet */ +void ppp_input(ppp_pcb *pcb, struct pbuf *pb); + + +/* + * Functions called by PPP protocols. + */ + +/* function called by all PPP subsystems to send packets */ +err_t ppp_write(ppp_pcb *pcb, struct pbuf *p); + +/* functions called by auth.c link_terminated() */ +void ppp_link_terminated(ppp_pcb *pcb); + +void new_phase(ppp_pcb *pcb, int p); + +int ppp_send_config(ppp_pcb *pcb, int mtu, u32_t accm, int pcomp, int accomp); +int ppp_recv_config(ppp_pcb *pcb, int mru, u32_t accm, int pcomp, int accomp); + +#if PPP_IPV4_SUPPORT +int sifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr, u32_t netmask); +int cifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr); +#if 0 /* UNUSED - PROXY ARP */ +int sifproxyarp(ppp_pcb *pcb, u32_t his_adr); +int cifproxyarp(ppp_pcb *pcb, u32_t his_adr); +#endif /* UNUSED - PROXY ARP */ +#if LWIP_DNS +int sdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2); +int cdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2); +#endif /* LWIP_DNS */ +#if VJ_SUPPORT +int sifvjcomp(ppp_pcb *pcb, int vjcomp, int cidcomp, int maxcid); +#endif /* VJ_SUPPORT */ +int sifup(ppp_pcb *pcb); +int sifdown (ppp_pcb *pcb); +u32_t get_mask(u32_t addr); +#endif /* PPP_IPV4_SUPPORT */ + +#if PPP_IPV6_SUPPORT +int sif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64); +int cif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64); +int sif6up(ppp_pcb *pcb); +int sif6down (ppp_pcb *pcb); +#endif /* PPP_IPV6_SUPPORT */ + +#if DEMAND_SUPPORT +int sifnpmode(ppp_pcb *pcb, int proto, enum NPmode mode); +#endif /* DEMAND_SUPPORt */ + +void netif_set_mtu(ppp_pcb *pcb, int mtu); +int netif_get_mtu(ppp_pcb *pcb); + +#if CCP_SUPPORT +#if 0 /* unused */ +int ccp_test(ppp_pcb *pcb, u_char *opt_ptr, int opt_len, int for_transmit); +#endif /* unused */ +void ccp_set(ppp_pcb *pcb, u8_t isopen, u8_t isup, u8_t receive_method, u8_t transmit_method); +void ccp_reset_comp(ppp_pcb *pcb); +void ccp_reset_decomp(ppp_pcb *pcb); +#if 0 /* unused */ +int ccp_fatal_error(ppp_pcb *pcb); +#endif /* unused */ +#endif /* CCP_SUPPORT */ + +#if PPP_IDLETIMELIMIT +int get_idle_time(ppp_pcb *pcb, struct ppp_idle *ip); +#endif /* PPP_IDLETIMELIMIT */ + +#if DEMAND_SUPPORT +int get_loop_output(void); +#endif /* DEMAND_SUPPORT */ + +/* Optional protocol names list, to make our messages a little more informative. */ +#if PPP_PROTOCOLNAME +const char * protocol_name(int proto); +#endif /* PPP_PROTOCOLNAME */ + +/* Optional stats support, to get some statistics on the PPP interface */ +#if PPP_STATS_SUPPORT +void print_link_stats(void); /* Print stats, if available */ +void reset_link_stats(int u); /* Reset (init) stats when link goes up */ +void update_link_stats(int u); /* Get stats at link termination */ +#endif /* PPP_STATS_SUPPORT */ + + + +/* + * Inline versions of get/put char/short/long. + * Pointer is advanced; we assume that both arguments + * are lvalues and will already be in registers. + * cp MUST be u_char *. + */ +#define GETCHAR(c, cp) { \ + (c) = *(cp)++; \ +} +#define PUTCHAR(c, cp) { \ + *(cp)++ = (u_char) (c); \ +} +#define GETSHORT(s, cp) { \ + (s) = *(cp)++ << 8; \ + (s) |= *(cp)++; \ +} +#define PUTSHORT(s, cp) { \ + *(cp)++ = (u_char) ((s) >> 8); \ + *(cp)++ = (u_char) (s); \ +} +#define GETLONG(l, cp) { \ + (l) = *(cp)++ << 8; \ + (l) |= *(cp)++; (l) <<= 8; \ + (l) |= *(cp)++; (l) <<= 8; \ + (l) |= *(cp)++; \ +} +#define PUTLONG(l, cp) { \ + *(cp)++ = (u_char) ((l) >> 24); \ + *(cp)++ = (u_char) ((l) >> 16); \ + *(cp)++ = (u_char) ((l) >> 8); \ + *(cp)++ = (u_char) (l); \ +} + +#define INCPTR(n, cp) ((cp) += (n)) +#define DECPTR(n, cp) ((cp) -= (n)) + +/* + * System dependent definitions for user-level 4.3BSD UNIX implementation. + */ +#define TIMEOUT(f, a, t) do { sys_untimeout((f), (a)); sys_timeout((t)*1000, (f), (a)); } while(0) +#define TIMEOUTMS(f, a, t) do { sys_untimeout((f), (a)); sys_timeout((t), (f), (a)); } while(0) +#define UNTIMEOUT(f, a) sys_untimeout((f), (a)) + +#define BZERO(s, n) memset(s, 0, n) +#define BCMP(s1, s2, l) memcmp(s1, s2, l) + +#define PRINTMSG(m, l) { ppp_info("Remote message: %0.*v", l, m); } + +/* + * MAKEHEADER - Add Header fields to a packet. + */ +#define MAKEHEADER(p, t) { \ + PUTCHAR(PPP_ALLSTATIONS, p); \ + PUTCHAR(PPP_UI, p); \ + PUTSHORT(t, p); } + +/* Procedures exported from auth.c */ +void link_required(ppp_pcb *pcb); /* we are starting to use the link */ +void link_terminated(ppp_pcb *pcb); /* we are finished with the link */ +void link_down(ppp_pcb *pcb); /* the LCP layer has left the Opened state */ +void upper_layers_down(ppp_pcb *pcb); /* take all NCPs down */ +void link_established(ppp_pcb *pcb); /* the link is up; authenticate now */ +void start_networks(ppp_pcb *pcb); /* start all the network control protos */ +void continue_networks(ppp_pcb *pcb); /* start network [ip, etc] control protos */ +#if PPP_AUTH_SUPPORT +#if PPP_SERVER +int auth_check_passwd(ppp_pcb *pcb, char *auser, int userlen, char *apasswd, int passwdlen, const char **msg, int *msglen); + /* check the user name and passwd against configuration */ +void auth_peer_fail(ppp_pcb *pcb, int protocol); + /* peer failed to authenticate itself */ +void auth_peer_success(ppp_pcb *pcb, int protocol, int prot_flavor, const char *name, int namelen); + /* peer successfully authenticated itself */ +#endif /* PPP_SERVER */ +void auth_withpeer_fail(ppp_pcb *pcb, int protocol); + /* we failed to authenticate ourselves */ +void auth_withpeer_success(ppp_pcb *pcb, int protocol, int prot_flavor); + /* we successfully authenticated ourselves */ +#endif /* PPP_AUTH_SUPPORT */ +void np_up(ppp_pcb *pcb, int proto); /* a network protocol has come up */ +void np_down(ppp_pcb *pcb, int proto); /* a network protocol has gone down */ +void np_finished(ppp_pcb *pcb, int proto); /* a network protocol no longer needs link */ +#if PPP_AUTH_SUPPORT +int get_secret(ppp_pcb *pcb, const char *client, const char *server, char *secret, int *secret_len, int am_server); + /* get "secret" for chap */ +#endif /* PPP_AUTH_SUPPORT */ + +/* Procedures exported from ipcp.c */ +/* int parse_dotted_ip (char *, u32_t *); */ + +/* Procedures exported from demand.c */ +#if DEMAND_SUPPORT +void demand_conf (void); /* config interface(s) for demand-dial */ +void demand_block (void); /* set all NPs to queue up packets */ +void demand_unblock (void); /* set all NPs to pass packets */ +void demand_discard (void); /* set all NPs to discard packets */ +void demand_rexmit (int, u32_t); /* retransmit saved frames for an NP*/ +int loop_chars (unsigned char *, int); /* process chars from loopback */ +int loop_frame (unsigned char *, int); /* should we bring link up? */ +#endif /* DEMAND_SUPPORT */ + +/* Procedures exported from multilink.c */ +#ifdef HAVE_MULTILINK +void mp_check_options (void); /* Check multilink-related options */ +int mp_join_bundle (void); /* join our link to an appropriate bundle */ +void mp_exit_bundle (void); /* have disconnected our link from bundle */ +void mp_bundle_terminated (void); +char *epdisc_to_str (struct epdisc *); /* string from endpoint discrim. */ +int str_to_epdisc (struct epdisc *, char *); /* endpt disc. from str */ +#else +#define mp_bundle_terminated() /* nothing */ +#define mp_exit_bundle() /* nothing */ +#define doing_multilink 0 +#define multilink_master 0 +#endif + +/* Procedures exported from utils.c. */ +void ppp_print_string(const u_char *p, int len, void (*printer) (void *, const char *, ...), void *arg); /* Format a string for output */ +int ppp_slprintf(char *buf, int buflen, const char *fmt, ...); /* sprintf++ */ +int ppp_vslprintf(char *buf, int buflen, const char *fmt, va_list args); /* vsprintf++ */ +size_t ppp_strlcpy(char *dest, const char *src, size_t len); /* safe strcpy */ +size_t ppp_strlcat(char *dest, const char *src, size_t len); /* safe strncpy */ +void ppp_dbglog(const char *fmt, ...); /* log a debug message */ +void ppp_info(const char *fmt, ...); /* log an informational message */ +void ppp_notice(const char *fmt, ...); /* log a notice-level message */ +void ppp_warn(const char *fmt, ...); /* log a warning message */ +void ppp_error(const char *fmt, ...); /* log an error message */ +void ppp_fatal(const char *fmt, ...); /* log an error message and die(1) */ +#if PRINTPKT_SUPPORT +void ppp_dump_packet(ppp_pcb *pcb, const char *tag, unsigned char *p, int len); + /* dump packet to debug log if interesting */ +#endif /* PRINTPKT_SUPPORT */ + +/* + * Number of necessary timers analysis. + * + * PPP use at least one timer per each of its protocol, but not all protocols are + * active at the same time, thus the number of necessary timeouts is actually + * lower than enabled protocols. Here is the actual necessary timeouts based + * on code analysis. + * + * Note that many features analysed here are not working at all and are only + * there for a comprehensive analysis of necessary timers in order to prevent + * having to redo that each time we add a feature. + * + * Timer list + * + * | holdoff timeout + * | low level protocol timeout (PPPoE or PPPoL2P) + * | LCP delayed UP + * | LCP retransmit (FSM) + * | LCP Echo timer + * .| PAP or CHAP or EAP authentication + * . | ECP retransmit (FSM) + * . | CCP retransmit (FSM) when MPPE is enabled + * . | CCP retransmit (FSM) when MPPE is NOT enabled + * . | IPCP retransmit (FSM) + * . .| IP6CP retransmit (FSM) + * . . | Idle time limit + * . . | Max connect time + * . . | Max octets + * . . | CCP RACK timeout + * . . . + * PPP_PHASE_DEAD + * PPP_PHASE_HOLDOFF + * | . . . + * PPP_PHASE_INITIALIZE + * | . . . + * PPP_PHASE_ESTABLISH + * | . . . + * |. . . + * | . . + * PPP_PHASE_AUTHENTICATE + * | . . + * || . . + * PPP_PHASE_NETWORK + * | || . . + * | ||| . + * PPP_PHASE_RUNNING + * | .||||| + * | . |||| + * PPP_PHASE_TERMINATE + * | . |||| + * PPP_PHASE_NETWORK + * |. . + * PPP_PHASE_ESTABLISH + * PPP_PHASE_DISCONNECT + * PPP_PHASE_DEAD + * + * Alright, PPP basic retransmission and LCP Echo consume one timer. + * 1 + * + * If authentication is enabled one timer is necessary during authentication. + * 1 + PPP_AUTH_SUPPORT + * + * If ECP is enabled one timer is necessary before IPCP and/or IP6CP, one more + * is necessary if CCP is enabled (only with MPPE support but we don't care much + * up to this detail level). + * 1 + ECP_SUPPORT + CCP_SUPPORT + * + * If CCP is enabled it might consume a timer during IPCP or IP6CP, thus + * we might use IPCP, IP6CP and CCP timers simultaneously. + * 1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT + * + * When entering running phase, IPCP or IP6CP is still running. If idle time limit + * is enabled one more timer is necessary. Same for max connect time and max + * octets features. Furthermore CCP RACK might be used past this point. + * 1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT -1 + PPP_IDLETIMELIMIT + PPP_MAXCONNECT + MAXOCTETS + CCP_SUPPORT + * + * IPv4 or IPv6 must be enabled, therefore we don't need to take care the authentication + * and the CCP + ECP case, thus reducing overall complexity. + * 1 + LWIP_MAX(PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT, PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT -1 + PPP_IDLETIMELIMIT + PPP_MAXCONNECT + MAXOCTETS + CCP_SUPPORT) + * + * We don't support PPP_IDLETIMELIMIT + PPP_MAXCONNECT + MAXOCTETS features + * and adding those defines to ppp_opts.h just for having the value always + * defined to 0 isn't worth it. + * 1 + LWIP_MAX(PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT, PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT -1 + CCP_SUPPORT) + * + * Thus, the following is enough for now. + * 1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT + */ + +#ifdef __cplusplus +} +#endif + +#endif /* PPP_SUPPORT */ +#endif /* LWIP_HDR_PPP_IMPL_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_opts.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_opts.h index 502a2ccc..6702bec6 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_opts.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/ppp_opts.h @@ -1,610 +1,610 @@ -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#ifndef LWIP_PPP_OPTS_H -#define LWIP_PPP_OPTS_H - -#include "lwip/opt.h" - -/** - * PPP_SUPPORT==1: Enable PPP. - */ -#ifndef PPP_SUPPORT -#define PPP_SUPPORT 0 -#endif - -/** - * PPPOE_SUPPORT==1: Enable PPP Over Ethernet - */ -#ifndef PPPOE_SUPPORT -#define PPPOE_SUPPORT 0 -#endif - -/** - * PPPOL2TP_SUPPORT==1: Enable PPP Over L2TP - */ -#ifndef PPPOL2TP_SUPPORT -#define PPPOL2TP_SUPPORT 0 -#endif - -/** - * PPPOL2TP_AUTH_SUPPORT==1: Enable PPP Over L2TP Auth (enable MD5 support) - */ -#ifndef PPPOL2TP_AUTH_SUPPORT -#define PPPOL2TP_AUTH_SUPPORT PPPOL2TP_SUPPORT -#endif - -/** - * PPPOS_SUPPORT==1: Enable PPP Over Serial - */ -#ifndef PPPOS_SUPPORT -#define PPPOS_SUPPORT PPP_SUPPORT -#endif - -/** - * LWIP_PPP_API==1: Enable PPP API (in pppapi.c) - */ -#ifndef LWIP_PPP_API -#define LWIP_PPP_API (PPP_SUPPORT && (NO_SYS == 0)) -#endif - -#if PPP_SUPPORT - -/** - * MEMP_NUM_PPP_PCB: the number of simultaneously active PPP - * connections (requires the PPP_SUPPORT option) - */ -#ifndef MEMP_NUM_PPP_PCB -#define MEMP_NUM_PPP_PCB 1 -#endif - -/** - * PPP_NUM_TIMEOUTS_PER_PCB: the number of sys_timeouts running in parallel per - * ppp_pcb. See the detailed explanation at the end of ppp_impl.h about simultaneous - * timers analysis. - */ -#ifndef PPP_NUM_TIMEOUTS_PER_PCB -#define PPP_NUM_TIMEOUTS_PER_PCB (1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT) -#endif - -/* The number of sys_timeouts required for the PPP module */ -#define PPP_NUM_TIMEOUTS (PPP_SUPPORT * PPP_NUM_TIMEOUTS_PER_PCB * MEMP_NUM_PPP_PCB) - -/** - * MEMP_NUM_PPPOS_INTERFACES: the number of concurrently active PPPoS - * interfaces (only used with PPPOS_SUPPORT==1) - */ -#ifndef MEMP_NUM_PPPOS_INTERFACES -#define MEMP_NUM_PPPOS_INTERFACES MEMP_NUM_PPP_PCB -#endif - -/** - * MEMP_NUM_PPPOE_INTERFACES: the number of concurrently active PPPoE - * interfaces (only used with PPPOE_SUPPORT==1) - */ -#ifndef MEMP_NUM_PPPOE_INTERFACES -#define MEMP_NUM_PPPOE_INTERFACES 1 -#endif - -/** - * MEMP_NUM_PPPOL2TP_INTERFACES: the number of concurrently active PPPoL2TP - * interfaces (only used with PPPOL2TP_SUPPORT==1) - */ -#ifndef MEMP_NUM_PPPOL2TP_INTERFACES -#define MEMP_NUM_PPPOL2TP_INTERFACES 1 -#endif - -/** - * MEMP_NUM_PPP_API_MSG: Number of concurrent PPP API messages (in pppapi.c) - */ -#ifndef MEMP_NUM_PPP_API_MSG -#define MEMP_NUM_PPP_API_MSG 5 -#endif - -/** - * PPP_DEBUG: Enable debugging for PPP. - */ -#ifndef PPP_DEBUG -#define PPP_DEBUG LWIP_DBG_OFF -#endif - -/** - * PPP_INPROC_IRQ_SAFE==1 call pppos_input() using tcpip_callback(). - * - * Please read the "PPPoS input path" chapter in the PPP documentation about this option. - */ -#ifndef PPP_INPROC_IRQ_SAFE -#define PPP_INPROC_IRQ_SAFE 0 -#endif - -/** - * PRINTPKT_SUPPORT==1: Enable PPP print packet support - * - * Mandatory for debugging, it displays exchanged packet content in debug trace. - */ -#ifndef PRINTPKT_SUPPORT -#define PRINTPKT_SUPPORT 0 -#endif - -/** - * PPP_IPV4_SUPPORT==1: Enable PPP IPv4 support - */ -#ifndef PPP_IPV4_SUPPORT -#define PPP_IPV4_SUPPORT (LWIP_IPV4) -#endif - -/** - * PPP_IPV6_SUPPORT==1: Enable PPP IPv6 support - */ -#ifndef PPP_IPV6_SUPPORT -#define PPP_IPV6_SUPPORT (LWIP_IPV6) -#endif - -/** - * PPP_NOTIFY_PHASE==1: Support PPP notify phase support - * - * PPP notify phase support allows you to set a callback which is - * called on change of the internal PPP state machine. - * - * This can be used for example to set a LED pattern depending on the - * current phase of the PPP session. - */ -#ifndef PPP_NOTIFY_PHASE -#define PPP_NOTIFY_PHASE 0 -#endif - -/** - * pbuf_type PPP is using for LCP, PAP, CHAP, EAP, CCP, IPCP and IP6CP packets. - * - * Memory allocated must be single buffered for PPP to works, it requires pbuf - * that are not going to be chained when allocated. This requires setting - * PBUF_POOL_BUFSIZE to at least 512 bytes, which is quite huge for small systems. - * - * Setting PPP_USE_PBUF_RAM to 1 makes PPP use memory from heap where continuous - * buffers are required, allowing you to use a smaller PBUF_POOL_BUFSIZE. - */ -#ifndef PPP_USE_PBUF_RAM -#define PPP_USE_PBUF_RAM 0 -#endif - -/** - * PPP_FCS_TABLE: Keep a 256*2 byte table to speed up FCS calculation for PPPoS - */ -#ifndef PPP_FCS_TABLE -#define PPP_FCS_TABLE 1 -#endif - -/** - * PAP_SUPPORT==1: Support PAP. - */ -#ifndef PAP_SUPPORT -#define PAP_SUPPORT 0 -#endif - -/** - * CHAP_SUPPORT==1: Support CHAP. - */ -#ifndef CHAP_SUPPORT -#define CHAP_SUPPORT 0 -#endif - -/** - * MSCHAP_SUPPORT==1: Support MSCHAP. - */ -#ifndef MSCHAP_SUPPORT -#define MSCHAP_SUPPORT 0 -#endif -#if MSCHAP_SUPPORT -/* MSCHAP requires CHAP support */ -#undef CHAP_SUPPORT -#define CHAP_SUPPORT 1 -#endif /* MSCHAP_SUPPORT */ - -/** - * EAP_SUPPORT==1: Support EAP. - */ -#ifndef EAP_SUPPORT -#define EAP_SUPPORT 0 -#endif - -/** - * CCP_SUPPORT==1: Support CCP. - */ -#ifndef CCP_SUPPORT -#define CCP_SUPPORT 0 -#endif - -/** - * MPPE_SUPPORT==1: Support MPPE. - */ -#ifndef MPPE_SUPPORT -#define MPPE_SUPPORT 0 -#endif -#if MPPE_SUPPORT -/* MPPE requires CCP support */ -#undef CCP_SUPPORT -#define CCP_SUPPORT 1 -/* MPPE requires MSCHAP support */ -#undef MSCHAP_SUPPORT -#define MSCHAP_SUPPORT 1 -/* MSCHAP requires CHAP support */ -#undef CHAP_SUPPORT -#define CHAP_SUPPORT 1 -#endif /* MPPE_SUPPORT */ - -/** - * CBCP_SUPPORT==1: Support CBCP. CURRENTLY NOT SUPPORTED! DO NOT SET! - */ -#ifndef CBCP_SUPPORT -#define CBCP_SUPPORT 0 -#endif - -/** - * ECP_SUPPORT==1: Support ECP. CURRENTLY NOT SUPPORTED! DO NOT SET! - */ -#ifndef ECP_SUPPORT -#define ECP_SUPPORT 0 -#endif - -/** - * DEMAND_SUPPORT==1: Support dial on demand. CURRENTLY NOT SUPPORTED! DO NOT SET! - */ -#ifndef DEMAND_SUPPORT -#define DEMAND_SUPPORT 0 -#endif - -/** - * LQR_SUPPORT==1: Support Link Quality Report. Do nothing except exchanging some LCP packets. - */ -#ifndef LQR_SUPPORT -#define LQR_SUPPORT 0 -#endif - -/** - * PPP_SERVER==1: Enable PPP server support (waiting for incoming PPP session). - * - * Currently only supported for PPPoS. - */ -#ifndef PPP_SERVER -#define PPP_SERVER 0 -#endif - -#if PPP_SERVER -/* - * PPP_OUR_NAME: Our name for authentication purposes - */ -#ifndef PPP_OUR_NAME -#define PPP_OUR_NAME "lwIP" -#endif -#endif /* PPP_SERVER */ - -/** - * VJ_SUPPORT==1: Support VJ header compression. - */ -#ifndef VJ_SUPPORT -#define VJ_SUPPORT 1 -#endif -/* VJ compression is only supported for TCP over IPv4 over PPPoS. */ -#if !PPPOS_SUPPORT || !PPP_IPV4_SUPPORT || !LWIP_TCP -#undef VJ_SUPPORT -#define VJ_SUPPORT 0 -#endif /* !PPPOS_SUPPORT */ - -/** - * PPP_MD5_RANDM==1: Use MD5 for better randomness. - * Enabled by default if CHAP, EAP, or L2TP AUTH support is enabled. - */ -#ifndef PPP_MD5_RANDM -#define PPP_MD5_RANDM (CHAP_SUPPORT || EAP_SUPPORT || PPPOL2TP_AUTH_SUPPORT) -#endif - -/** - * PolarSSL embedded library - * - * - * lwIP contains some files fetched from the latest BSD release of - * the PolarSSL project (PolarSSL 0.10.1-bsd) for ciphers and encryption - * methods we need for lwIP PPP support. - * - * The PolarSSL files were cleaned to contain only the necessary struct - * fields and functions needed for lwIP. - * - * The PolarSSL API was not changed at all, so if you are already using - * PolarSSL you can choose to skip the compilation of the included PolarSSL - * library into lwIP. - * - * If you are not using the embedded copy you must include external - * libraries into your arch/cc.h port file. - * - * Beware of the stack requirements which can be a lot larger if you are not - * using our cleaned PolarSSL library. - */ - -/** - * LWIP_USE_EXTERNAL_POLARSSL: Use external PolarSSL library - */ -#ifndef LWIP_USE_EXTERNAL_POLARSSL -#define LWIP_USE_EXTERNAL_POLARSSL 0 -#endif - -/** - * LWIP_USE_EXTERNAL_MBEDTLS: Use external mbed TLS library - */ -#ifndef LWIP_USE_EXTERNAL_MBEDTLS -#define LWIP_USE_EXTERNAL_MBEDTLS 0 -#endif - -/* - * PPP Timeouts - */ - -/** - * FSM_DEFTIMEOUT: Timeout time in seconds - */ -#ifndef FSM_DEFTIMEOUT -#define FSM_DEFTIMEOUT 6 -#endif - -/** - * FSM_DEFMAXTERMREQS: Maximum Terminate-Request transmissions - */ -#ifndef FSM_DEFMAXTERMREQS -#define FSM_DEFMAXTERMREQS 2 -#endif - -/** - * FSM_DEFMAXCONFREQS: Maximum Configure-Request transmissions - */ -#ifndef FSM_DEFMAXCONFREQS -#define FSM_DEFMAXCONFREQS 10 -#endif - -/** - * FSM_DEFMAXNAKLOOPS: Maximum number of nak loops - */ -#ifndef FSM_DEFMAXNAKLOOPS -#define FSM_DEFMAXNAKLOOPS 5 -#endif - -/** - * UPAP_DEFTIMEOUT: Timeout (seconds) for retransmitting req - */ -#ifndef UPAP_DEFTIMEOUT -#define UPAP_DEFTIMEOUT 6 -#endif - -/** - * UPAP_DEFTRANSMITS: Maximum number of auth-reqs to send - */ -#ifndef UPAP_DEFTRANSMITS -#define UPAP_DEFTRANSMITS 10 -#endif - -#if PPP_SERVER -/** - * UPAP_DEFREQTIME: Time to wait for auth-req from peer - */ -#ifndef UPAP_DEFREQTIME -#define UPAP_DEFREQTIME 30 -#endif -#endif /* PPP_SERVER */ - -/** - * CHAP_DEFTIMEOUT: Timeout (seconds) for retransmitting req - */ -#ifndef CHAP_DEFTIMEOUT -#define CHAP_DEFTIMEOUT 6 -#endif - -/** - * CHAP_DEFTRANSMITS: max # times to send challenge - */ -#ifndef CHAP_DEFTRANSMITS -#define CHAP_DEFTRANSMITS 10 -#endif - -#if PPP_SERVER -/** - * CHAP_DEFRECHALLENGETIME: If this option is > 0, rechallenge the peer every n seconds - */ -#ifndef CHAP_DEFRECHALLENGETIME -#define CHAP_DEFRECHALLENGETIME 0 -#endif -#endif /* PPP_SERVER */ - -/** - * EAP_DEFREQTIME: Time to wait for peer request - */ -#ifndef EAP_DEFREQTIME -#define EAP_DEFREQTIME 6 -#endif - -/** - * EAP_DEFALLOWREQ: max # times to accept requests - */ -#ifndef EAP_DEFALLOWREQ -#define EAP_DEFALLOWREQ 10 -#endif - -#if PPP_SERVER -/** - * EAP_DEFTIMEOUT: Timeout (seconds) for rexmit - */ -#ifndef EAP_DEFTIMEOUT -#define EAP_DEFTIMEOUT 6 -#endif - -/** - * EAP_DEFTRANSMITS: max # times to transmit - */ -#ifndef EAP_DEFTRANSMITS -#define EAP_DEFTRANSMITS 10 -#endif -#endif /* PPP_SERVER */ - -/** - * LCP_DEFLOOPBACKFAIL: Default number of times we receive our magic number from the peer - * before deciding the link is looped-back. - */ -#ifndef LCP_DEFLOOPBACKFAIL -#define LCP_DEFLOOPBACKFAIL 10 -#endif - -/** - * LCP_ECHOINTERVAL: Interval in seconds between keepalive echo requests, 0 to disable. - */ -#ifndef LCP_ECHOINTERVAL -#define LCP_ECHOINTERVAL 0 -#endif - -/** - * LCP_MAXECHOFAILS: Number of unanswered echo requests before failure. - */ -#ifndef LCP_MAXECHOFAILS -#define LCP_MAXECHOFAILS 3 -#endif - -/** - * PPP_MAXIDLEFLAG: Max Xmit idle time (in ms) before resend flag char. - */ -#ifndef PPP_MAXIDLEFLAG -#define PPP_MAXIDLEFLAG 100 -#endif - -/** - * PPP Packet sizes - */ - -/** - * PPP_MRU: Default MRU - */ -#ifndef PPP_MRU -#define PPP_MRU 1500 -#endif - -/** - * PPP_DEFMRU: Default MRU to try - */ -#ifndef PPP_DEFMRU -#define PPP_DEFMRU 1500 -#endif - -/** - * PPP_MAXMRU: Normally limit MRU to this (pppd default = 16384) - */ -#ifndef PPP_MAXMRU -#define PPP_MAXMRU 1500 -#endif - -/** - * PPP_MINMRU: No MRUs below this - */ -#ifndef PPP_MINMRU -#define PPP_MINMRU 128 -#endif - -/** - * PPPOL2TP_DEFMRU: Default MTU and MRU for L2TP - * Default = 1500 - PPPoE(6) - PPP Protocol(2) - IPv4 header(20) - UDP Header(8) - * - L2TP Header(6) - HDLC Header(2) - PPP Protocol(2) - MPPE Header(2) - PPP Protocol(2) - */ -#if PPPOL2TP_SUPPORT -#ifndef PPPOL2TP_DEFMRU -#define PPPOL2TP_DEFMRU 1450 -#endif -#endif /* PPPOL2TP_SUPPORT */ - -/** - * MAXNAMELEN: max length of hostname or name for auth - */ -#ifndef MAXNAMELEN -#define MAXNAMELEN 256 -#endif - -/** - * MAXSECRETLEN: max length of password or secret - */ -#ifndef MAXSECRETLEN -#define MAXSECRETLEN 256 -#endif - -/* ------------------------------------------------------------------------- */ - -/* - * Build triggers for embedded PolarSSL - */ -#if !LWIP_USE_EXTERNAL_POLARSSL && !LWIP_USE_EXTERNAL_MBEDTLS - -/* CHAP, EAP, L2TP AUTH and MD5 Random require MD5 support */ -#if CHAP_SUPPORT || EAP_SUPPORT || PPPOL2TP_AUTH_SUPPORT || PPP_MD5_RANDM -#define LWIP_INCLUDED_POLARSSL_MD5 1 -#endif /* CHAP_SUPPORT || EAP_SUPPORT || PPPOL2TP_AUTH_SUPPORT || PPP_MD5_RANDM */ - -#if MSCHAP_SUPPORT - -/* MSCHAP require MD4 support */ -#define LWIP_INCLUDED_POLARSSL_MD4 1 -/* MSCHAP require SHA1 support */ -#define LWIP_INCLUDED_POLARSSL_SHA1 1 -/* MSCHAP require DES support */ -#define LWIP_INCLUDED_POLARSSL_DES 1 - -/* MS-CHAP support is required for MPPE */ -#if MPPE_SUPPORT -/* MPPE require ARC4 support */ -#define LWIP_INCLUDED_POLARSSL_ARC4 1 -#endif /* MPPE_SUPPORT */ - -#endif /* MSCHAP_SUPPORT */ - -#endif /* !LWIP_USE_EXTERNAL_POLARSSL && !LWIP_USE_EXTERNAL_MBEDTLS */ - -/* Default value if unset */ -#ifndef LWIP_INCLUDED_POLARSSL_MD4 -#define LWIP_INCLUDED_POLARSSL_MD4 0 -#endif /* LWIP_INCLUDED_POLARSSL_MD4 */ -#ifndef LWIP_INCLUDED_POLARSSL_MD5 -#define LWIP_INCLUDED_POLARSSL_MD5 0 -#endif /* LWIP_INCLUDED_POLARSSL_MD5 */ -#ifndef LWIP_INCLUDED_POLARSSL_SHA1 -#define LWIP_INCLUDED_POLARSSL_SHA1 0 -#endif /* LWIP_INCLUDED_POLARSSL_SHA1 */ -#ifndef LWIP_INCLUDED_POLARSSL_DES -#define LWIP_INCLUDED_POLARSSL_DES 0 -#endif /* LWIP_INCLUDED_POLARSSL_DES */ -#ifndef LWIP_INCLUDED_POLARSSL_ARC4 -#define LWIP_INCLUDED_POLARSSL_ARC4 0 -#endif /* LWIP_INCLUDED_POLARSSL_ARC4 */ - -#endif /* PPP_SUPPORT */ - -/* Default value if unset */ -#ifndef PPP_NUM_TIMEOUTS -#define PPP_NUM_TIMEOUTS 0 -#endif /* PPP_NUM_TIMEOUTS */ - -#endif /* LWIP_PPP_OPTS_H */ +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#ifndef LWIP_PPP_OPTS_H +#define LWIP_PPP_OPTS_H + +#include "lwip/opt.h" + +/** + * PPP_SUPPORT==1: Enable PPP. + */ +#ifndef PPP_SUPPORT +#define PPP_SUPPORT 0 +#endif + +/** + * PPPOE_SUPPORT==1: Enable PPP Over Ethernet + */ +#ifndef PPPOE_SUPPORT +#define PPPOE_SUPPORT 0 +#endif + +/** + * PPPOL2TP_SUPPORT==1: Enable PPP Over L2TP + */ +#ifndef PPPOL2TP_SUPPORT +#define PPPOL2TP_SUPPORT 0 +#endif + +/** + * PPPOL2TP_AUTH_SUPPORT==1: Enable PPP Over L2TP Auth (enable MD5 support) + */ +#ifndef PPPOL2TP_AUTH_SUPPORT +#define PPPOL2TP_AUTH_SUPPORT PPPOL2TP_SUPPORT +#endif + +/** + * PPPOS_SUPPORT==1: Enable PPP Over Serial + */ +#ifndef PPPOS_SUPPORT +#define PPPOS_SUPPORT PPP_SUPPORT +#endif + +/** + * LWIP_PPP_API==1: Enable PPP API (in pppapi.c) + */ +#ifndef LWIP_PPP_API +#define LWIP_PPP_API (PPP_SUPPORT && (NO_SYS == 0)) +#endif + +#if PPP_SUPPORT + +/** + * MEMP_NUM_PPP_PCB: the number of simultaneously active PPP + * connections (requires the PPP_SUPPORT option) + */ +#ifndef MEMP_NUM_PPP_PCB +#define MEMP_NUM_PPP_PCB 1 +#endif + +/** + * PPP_NUM_TIMEOUTS_PER_PCB: the number of sys_timeouts running in parallel per + * ppp_pcb. See the detailed explanation at the end of ppp_impl.h about simultaneous + * timers analysis. + */ +#ifndef PPP_NUM_TIMEOUTS_PER_PCB +#define PPP_NUM_TIMEOUTS_PER_PCB (1 + PPP_IPV4_SUPPORT + PPP_IPV6_SUPPORT + CCP_SUPPORT) +#endif + +/* The number of sys_timeouts required for the PPP module */ +#define PPP_NUM_TIMEOUTS (PPP_SUPPORT * PPP_NUM_TIMEOUTS_PER_PCB * MEMP_NUM_PPP_PCB) + +/** + * MEMP_NUM_PPPOS_INTERFACES: the number of concurrently active PPPoS + * interfaces (only used with PPPOS_SUPPORT==1) + */ +#ifndef MEMP_NUM_PPPOS_INTERFACES +#define MEMP_NUM_PPPOS_INTERFACES MEMP_NUM_PPP_PCB +#endif + +/** + * MEMP_NUM_PPPOE_INTERFACES: the number of concurrently active PPPoE + * interfaces (only used with PPPOE_SUPPORT==1) + */ +#ifndef MEMP_NUM_PPPOE_INTERFACES +#define MEMP_NUM_PPPOE_INTERFACES 1 +#endif + +/** + * MEMP_NUM_PPPOL2TP_INTERFACES: the number of concurrently active PPPoL2TP + * interfaces (only used with PPPOL2TP_SUPPORT==1) + */ +#ifndef MEMP_NUM_PPPOL2TP_INTERFACES +#define MEMP_NUM_PPPOL2TP_INTERFACES 1 +#endif + +/** + * MEMP_NUM_PPP_API_MSG: Number of concurrent PPP API messages (in pppapi.c) + */ +#ifndef MEMP_NUM_PPP_API_MSG +#define MEMP_NUM_PPP_API_MSG 5 +#endif + +/** + * PPP_DEBUG: Enable debugging for PPP. + */ +#ifndef PPP_DEBUG +#define PPP_DEBUG LWIP_DBG_OFF +#endif + +/** + * PPP_INPROC_IRQ_SAFE==1 call pppos_input() using tcpip_callback(). + * + * Please read the "PPPoS input path" chapter in the PPP documentation about this option. + */ +#ifndef PPP_INPROC_IRQ_SAFE +#define PPP_INPROC_IRQ_SAFE 0 +#endif + +/** + * PRINTPKT_SUPPORT==1: Enable PPP print packet support + * + * Mandatory for debugging, it displays exchanged packet content in debug trace. + */ +#ifndef PRINTPKT_SUPPORT +#define PRINTPKT_SUPPORT 0 +#endif + +/** + * PPP_IPV4_SUPPORT==1: Enable PPP IPv4 support + */ +#ifndef PPP_IPV4_SUPPORT +#define PPP_IPV4_SUPPORT (LWIP_IPV4) +#endif + +/** + * PPP_IPV6_SUPPORT==1: Enable PPP IPv6 support + */ +#ifndef PPP_IPV6_SUPPORT +#define PPP_IPV6_SUPPORT (LWIP_IPV6) +#endif + +/** + * PPP_NOTIFY_PHASE==1: Support PPP notify phase support + * + * PPP notify phase support allows you to set a callback which is + * called on change of the internal PPP state machine. + * + * This can be used for example to set a LED pattern depending on the + * current phase of the PPP session. + */ +#ifndef PPP_NOTIFY_PHASE +#define PPP_NOTIFY_PHASE 0 +#endif + +/** + * pbuf_type PPP is using for LCP, PAP, CHAP, EAP, CCP, IPCP and IP6CP packets. + * + * Memory allocated must be single buffered for PPP to works, it requires pbuf + * that are not going to be chained when allocated. This requires setting + * PBUF_POOL_BUFSIZE to at least 512 bytes, which is quite huge for small systems. + * + * Setting PPP_USE_PBUF_RAM to 1 makes PPP use memory from heap where continuous + * buffers are required, allowing you to use a smaller PBUF_POOL_BUFSIZE. + */ +#ifndef PPP_USE_PBUF_RAM +#define PPP_USE_PBUF_RAM 0 +#endif + +/** + * PPP_FCS_TABLE: Keep a 256*2 byte table to speed up FCS calculation for PPPoS + */ +#ifndef PPP_FCS_TABLE +#define PPP_FCS_TABLE 1 +#endif + +/** + * PAP_SUPPORT==1: Support PAP. + */ +#ifndef PAP_SUPPORT +#define PAP_SUPPORT 0 +#endif + +/** + * CHAP_SUPPORT==1: Support CHAP. + */ +#ifndef CHAP_SUPPORT +#define CHAP_SUPPORT 0 +#endif + +/** + * MSCHAP_SUPPORT==1: Support MSCHAP. + */ +#ifndef MSCHAP_SUPPORT +#define MSCHAP_SUPPORT 0 +#endif +#if MSCHAP_SUPPORT +/* MSCHAP requires CHAP support */ +#undef CHAP_SUPPORT +#define CHAP_SUPPORT 1 +#endif /* MSCHAP_SUPPORT */ + +/** + * EAP_SUPPORT==1: Support EAP. + */ +#ifndef EAP_SUPPORT +#define EAP_SUPPORT 0 +#endif + +/** + * CCP_SUPPORT==1: Support CCP. + */ +#ifndef CCP_SUPPORT +#define CCP_SUPPORT 0 +#endif + +/** + * MPPE_SUPPORT==1: Support MPPE. + */ +#ifndef MPPE_SUPPORT +#define MPPE_SUPPORT 0 +#endif +#if MPPE_SUPPORT +/* MPPE requires CCP support */ +#undef CCP_SUPPORT +#define CCP_SUPPORT 1 +/* MPPE requires MSCHAP support */ +#undef MSCHAP_SUPPORT +#define MSCHAP_SUPPORT 1 +/* MSCHAP requires CHAP support */ +#undef CHAP_SUPPORT +#define CHAP_SUPPORT 1 +#endif /* MPPE_SUPPORT */ + +/** + * CBCP_SUPPORT==1: Support CBCP. CURRENTLY NOT SUPPORTED! DO NOT SET! + */ +#ifndef CBCP_SUPPORT +#define CBCP_SUPPORT 0 +#endif + +/** + * ECP_SUPPORT==1: Support ECP. CURRENTLY NOT SUPPORTED! DO NOT SET! + */ +#ifndef ECP_SUPPORT +#define ECP_SUPPORT 0 +#endif + +/** + * DEMAND_SUPPORT==1: Support dial on demand. CURRENTLY NOT SUPPORTED! DO NOT SET! + */ +#ifndef DEMAND_SUPPORT +#define DEMAND_SUPPORT 0 +#endif + +/** + * LQR_SUPPORT==1: Support Link Quality Report. Do nothing except exchanging some LCP packets. + */ +#ifndef LQR_SUPPORT +#define LQR_SUPPORT 0 +#endif + +/** + * PPP_SERVER==1: Enable PPP server support (waiting for incoming PPP session). + * + * Currently only supported for PPPoS. + */ +#ifndef PPP_SERVER +#define PPP_SERVER 0 +#endif + +#if PPP_SERVER +/* + * PPP_OUR_NAME: Our name for authentication purposes + */ +#ifndef PPP_OUR_NAME +#define PPP_OUR_NAME "lwIP" +#endif +#endif /* PPP_SERVER */ + +/** + * VJ_SUPPORT==1: Support VJ header compression. + */ +#ifndef VJ_SUPPORT +#define VJ_SUPPORT 1 +#endif +/* VJ compression is only supported for TCP over IPv4 over PPPoS. */ +#if !PPPOS_SUPPORT || !PPP_IPV4_SUPPORT || !LWIP_TCP +#undef VJ_SUPPORT +#define VJ_SUPPORT 0 +#endif /* !PPPOS_SUPPORT */ + +/** + * PPP_MD5_RANDM==1: Use MD5 for better randomness. + * Enabled by default if CHAP, EAP, or L2TP AUTH support is enabled. + */ +#ifndef PPP_MD5_RANDM +#define PPP_MD5_RANDM (CHAP_SUPPORT || EAP_SUPPORT || PPPOL2TP_AUTH_SUPPORT) +#endif + +/** + * PolarSSL embedded library + * + * + * lwIP contains some files fetched from the latest BSD release of + * the PolarSSL project (PolarSSL 0.10.1-bsd) for ciphers and encryption + * methods we need for lwIP PPP support. + * + * The PolarSSL files were cleaned to contain only the necessary struct + * fields and functions needed for lwIP. + * + * The PolarSSL API was not changed at all, so if you are already using + * PolarSSL you can choose to skip the compilation of the included PolarSSL + * library into lwIP. + * + * If you are not using the embedded copy you must include external + * libraries into your arch/cc.h port file. + * + * Beware of the stack requirements which can be a lot larger if you are not + * using our cleaned PolarSSL library. + */ + +/** + * LWIP_USE_EXTERNAL_POLARSSL: Use external PolarSSL library + */ +#ifndef LWIP_USE_EXTERNAL_POLARSSL +#define LWIP_USE_EXTERNAL_POLARSSL 0 +#endif + +/** + * LWIP_USE_EXTERNAL_MBEDTLS: Use external mbed TLS library + */ +#ifndef LWIP_USE_EXTERNAL_MBEDTLS +#define LWIP_USE_EXTERNAL_MBEDTLS 0 +#endif + +/* + * PPP Timeouts + */ + +/** + * FSM_DEFTIMEOUT: Timeout time in seconds + */ +#ifndef FSM_DEFTIMEOUT +#define FSM_DEFTIMEOUT 6 +#endif + +/** + * FSM_DEFMAXTERMREQS: Maximum Terminate-Request transmissions + */ +#ifndef FSM_DEFMAXTERMREQS +#define FSM_DEFMAXTERMREQS 2 +#endif + +/** + * FSM_DEFMAXCONFREQS: Maximum Configure-Request transmissions + */ +#ifndef FSM_DEFMAXCONFREQS +#define FSM_DEFMAXCONFREQS 10 +#endif + +/** + * FSM_DEFMAXNAKLOOPS: Maximum number of nak loops + */ +#ifndef FSM_DEFMAXNAKLOOPS +#define FSM_DEFMAXNAKLOOPS 5 +#endif + +/** + * UPAP_DEFTIMEOUT: Timeout (seconds) for retransmitting req + */ +#ifndef UPAP_DEFTIMEOUT +#define UPAP_DEFTIMEOUT 6 +#endif + +/** + * UPAP_DEFTRANSMITS: Maximum number of auth-reqs to send + */ +#ifndef UPAP_DEFTRANSMITS +#define UPAP_DEFTRANSMITS 10 +#endif + +#if PPP_SERVER +/** + * UPAP_DEFREQTIME: Time to wait for auth-req from peer + */ +#ifndef UPAP_DEFREQTIME +#define UPAP_DEFREQTIME 30 +#endif +#endif /* PPP_SERVER */ + +/** + * CHAP_DEFTIMEOUT: Timeout (seconds) for retransmitting req + */ +#ifndef CHAP_DEFTIMEOUT +#define CHAP_DEFTIMEOUT 6 +#endif + +/** + * CHAP_DEFTRANSMITS: max # times to send challenge + */ +#ifndef CHAP_DEFTRANSMITS +#define CHAP_DEFTRANSMITS 10 +#endif + +#if PPP_SERVER +/** + * CHAP_DEFRECHALLENGETIME: If this option is > 0, rechallenge the peer every n seconds + */ +#ifndef CHAP_DEFRECHALLENGETIME +#define CHAP_DEFRECHALLENGETIME 0 +#endif +#endif /* PPP_SERVER */ + +/** + * EAP_DEFREQTIME: Time to wait for peer request + */ +#ifndef EAP_DEFREQTIME +#define EAP_DEFREQTIME 6 +#endif + +/** + * EAP_DEFALLOWREQ: max # times to accept requests + */ +#ifndef EAP_DEFALLOWREQ +#define EAP_DEFALLOWREQ 10 +#endif + +#if PPP_SERVER +/** + * EAP_DEFTIMEOUT: Timeout (seconds) for rexmit + */ +#ifndef EAP_DEFTIMEOUT +#define EAP_DEFTIMEOUT 6 +#endif + +/** + * EAP_DEFTRANSMITS: max # times to transmit + */ +#ifndef EAP_DEFTRANSMITS +#define EAP_DEFTRANSMITS 10 +#endif +#endif /* PPP_SERVER */ + +/** + * LCP_DEFLOOPBACKFAIL: Default number of times we receive our magic number from the peer + * before deciding the link is looped-back. + */ +#ifndef LCP_DEFLOOPBACKFAIL +#define LCP_DEFLOOPBACKFAIL 10 +#endif + +/** + * LCP_ECHOINTERVAL: Interval in seconds between keepalive echo requests, 0 to disable. + */ +#ifndef LCP_ECHOINTERVAL +#define LCP_ECHOINTERVAL 0 +#endif + +/** + * LCP_MAXECHOFAILS: Number of unanswered echo requests before failure. + */ +#ifndef LCP_MAXECHOFAILS +#define LCP_MAXECHOFAILS 3 +#endif + +/** + * PPP_MAXIDLEFLAG: Max Xmit idle time (in ms) before resend flag char. + */ +#ifndef PPP_MAXIDLEFLAG +#define PPP_MAXIDLEFLAG 100 +#endif + +/** + * PPP Packet sizes + */ + +/** + * PPP_MRU: Default MRU + */ +#ifndef PPP_MRU +#define PPP_MRU 1500 +#endif + +/** + * PPP_DEFMRU: Default MRU to try + */ +#ifndef PPP_DEFMRU +#define PPP_DEFMRU 1500 +#endif + +/** + * PPP_MAXMRU: Normally limit MRU to this (pppd default = 16384) + */ +#ifndef PPP_MAXMRU +#define PPP_MAXMRU 1500 +#endif + +/** + * PPP_MINMRU: No MRUs below this + */ +#ifndef PPP_MINMRU +#define PPP_MINMRU 128 +#endif + +/** + * PPPOL2TP_DEFMRU: Default MTU and MRU for L2TP + * Default = 1500 - PPPoE(6) - PPP Protocol(2) - IPv4 header(20) - UDP Header(8) + * - L2TP Header(6) - HDLC Header(2) - PPP Protocol(2) - MPPE Header(2) - PPP Protocol(2) + */ +#if PPPOL2TP_SUPPORT +#ifndef PPPOL2TP_DEFMRU +#define PPPOL2TP_DEFMRU 1450 +#endif +#endif /* PPPOL2TP_SUPPORT */ + +/** + * MAXNAMELEN: max length of hostname or name for auth + */ +#ifndef MAXNAMELEN +#define MAXNAMELEN 256 +#endif + +/** + * MAXSECRETLEN: max length of password or secret + */ +#ifndef MAXSECRETLEN +#define MAXSECRETLEN 256 +#endif + +/* ------------------------------------------------------------------------- */ + +/* + * Build triggers for embedded PolarSSL + */ +#if !LWIP_USE_EXTERNAL_POLARSSL && !LWIP_USE_EXTERNAL_MBEDTLS + +/* CHAP, EAP, L2TP AUTH and MD5 Random require MD5 support */ +#if CHAP_SUPPORT || EAP_SUPPORT || PPPOL2TP_AUTH_SUPPORT || PPP_MD5_RANDM +#define LWIP_INCLUDED_POLARSSL_MD5 1 +#endif /* CHAP_SUPPORT || EAP_SUPPORT || PPPOL2TP_AUTH_SUPPORT || PPP_MD5_RANDM */ + +#if MSCHAP_SUPPORT + +/* MSCHAP require MD4 support */ +#define LWIP_INCLUDED_POLARSSL_MD4 1 +/* MSCHAP require SHA1 support */ +#define LWIP_INCLUDED_POLARSSL_SHA1 1 +/* MSCHAP require DES support */ +#define LWIP_INCLUDED_POLARSSL_DES 1 + +/* MS-CHAP support is required for MPPE */ +#if MPPE_SUPPORT +/* MPPE require ARC4 support */ +#define LWIP_INCLUDED_POLARSSL_ARC4 1 +#endif /* MPPE_SUPPORT */ + +#endif /* MSCHAP_SUPPORT */ + +#endif /* !LWIP_USE_EXTERNAL_POLARSSL && !LWIP_USE_EXTERNAL_MBEDTLS */ + +/* Default value if unset */ +#ifndef LWIP_INCLUDED_POLARSSL_MD4 +#define LWIP_INCLUDED_POLARSSL_MD4 0 +#endif /* LWIP_INCLUDED_POLARSSL_MD4 */ +#ifndef LWIP_INCLUDED_POLARSSL_MD5 +#define LWIP_INCLUDED_POLARSSL_MD5 0 +#endif /* LWIP_INCLUDED_POLARSSL_MD5 */ +#ifndef LWIP_INCLUDED_POLARSSL_SHA1 +#define LWIP_INCLUDED_POLARSSL_SHA1 0 +#endif /* LWIP_INCLUDED_POLARSSL_SHA1 */ +#ifndef LWIP_INCLUDED_POLARSSL_DES +#define LWIP_INCLUDED_POLARSSL_DES 0 +#endif /* LWIP_INCLUDED_POLARSSL_DES */ +#ifndef LWIP_INCLUDED_POLARSSL_ARC4 +#define LWIP_INCLUDED_POLARSSL_ARC4 0 +#endif /* LWIP_INCLUDED_POLARSSL_ARC4 */ + +#endif /* PPP_SUPPORT */ + +/* Default value if unset */ +#ifndef PPP_NUM_TIMEOUTS +#define PPP_NUM_TIMEOUTS 0 +#endif /* PPP_NUM_TIMEOUTS */ + +#endif /* LWIP_PPP_OPTS_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppapi.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppapi.h index 70c262a8..913d93f7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppapi.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppapi.h @@ -1,137 +1,137 @@ -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#ifndef LWIP_PPPAPI_H -#define LWIP_PPPAPI_H - -#include "netif/ppp/ppp_opts.h" - -#if LWIP_PPP_API /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/sys.h" -#include "lwip/netif.h" -#include "lwip/priv/tcpip_priv.h" -#include "netif/ppp/ppp.h" -#if PPPOS_SUPPORT -#include "netif/ppp/pppos.h" -#endif /* PPPOS_SUPPORT */ - -#ifdef __cplusplus -extern "C" { -#endif - -struct pppapi_msg_msg { - ppp_pcb *ppp; - union { -#if PPP_NOTIFY_PHASE - struct { - ppp_notify_phase_cb_fn notify_phase_cb; - } setnotifyphasecb; -#endif /* PPP_NOTIFY_PHASE */ -#if PPPOS_SUPPORT - struct { - struct netif *pppif; - pppos_output_cb_fn output_cb; - ppp_link_status_cb_fn link_status_cb; - void *ctx_cb; - } serialcreate; -#endif /* PPPOS_SUPPORT */ -#if PPPOE_SUPPORT - struct { - struct netif *pppif; - struct netif *ethif; - const char *service_name; - const char *concentrator_name; - ppp_link_status_cb_fn link_status_cb; - void *ctx_cb; - } ethernetcreate; -#endif /* PPPOE_SUPPORT */ -#if PPPOL2TP_SUPPORT - struct { - struct netif *pppif; - struct netif *netif; - API_MSG_M_DEF_C(ip_addr_t, ipaddr); - u16_t port; -#if PPPOL2TP_AUTH_SUPPORT - const u8_t *secret; - u8_t secret_len; -#endif /* PPPOL2TP_AUTH_SUPPORT */ - ppp_link_status_cb_fn link_status_cb; - void *ctx_cb; - } l2tpcreate; -#endif /* PPPOL2TP_SUPPORT */ - struct { - u16_t holdoff; - } connect; - struct { - u8_t nocarrier; - } close; - struct { - u8_t cmd; - void *arg; - } ioctl; - } msg; -}; - -struct pppapi_msg { - struct tcpip_api_call_data call; - struct pppapi_msg_msg msg; -}; - -/* API for application */ -err_t pppapi_set_default(ppp_pcb *pcb); -#if PPP_NOTIFY_PHASE -err_t pppapi_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb); -#endif /* PPP_NOTIFY_PHASE */ -#if PPPOS_SUPPORT -ppp_pcb *pppapi_pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, ppp_link_status_cb_fn link_status_cb, void *ctx_cb); -#endif /* PPPOS_SUPPORT */ -#if PPPOE_SUPPORT -ppp_pcb *pppapi_pppoe_create(struct netif *pppif, struct netif *ethif, const char *service_name, - const char *concentrator_name, ppp_link_status_cb_fn link_status_cb, - void *ctx_cb); -#endif /* PPPOE_SUPPORT */ -#if PPPOL2TP_SUPPORT -ppp_pcb *pppapi_pppol2tp_create(struct netif *pppif, struct netif *netif, ip_addr_t *ipaddr, u16_t port, - const u8_t *secret, u8_t secret_len, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb); -#endif /* PPPOL2TP_SUPPORT */ -err_t pppapi_connect(ppp_pcb *pcb, u16_t holdoff); -#if PPP_SERVER -err_t pppapi_listen(ppp_pcb *pcb); -#endif /* PPP_SERVER */ -err_t pppapi_close(ppp_pcb *pcb, u8_t nocarrier); -err_t pppapi_free(ppp_pcb *pcb); -err_t pppapi_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_PPP_API */ - -#endif /* LWIP_PPPAPI_H */ +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#ifndef LWIP_PPPAPI_H +#define LWIP_PPPAPI_H + +#include "netif/ppp/ppp_opts.h" + +#if LWIP_PPP_API /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/sys.h" +#include "lwip/netif.h" +#include "lwip/priv/tcpip_priv.h" +#include "netif/ppp/ppp.h" +#if PPPOS_SUPPORT +#include "netif/ppp/pppos.h" +#endif /* PPPOS_SUPPORT */ + +#ifdef __cplusplus +extern "C" { +#endif + +struct pppapi_msg_msg { + ppp_pcb *ppp; + union { +#if PPP_NOTIFY_PHASE + struct { + ppp_notify_phase_cb_fn notify_phase_cb; + } setnotifyphasecb; +#endif /* PPP_NOTIFY_PHASE */ +#if PPPOS_SUPPORT + struct { + struct netif *pppif; + pppos_output_cb_fn output_cb; + ppp_link_status_cb_fn link_status_cb; + void *ctx_cb; + } serialcreate; +#endif /* PPPOS_SUPPORT */ +#if PPPOE_SUPPORT + struct { + struct netif *pppif; + struct netif *ethif; + const char *service_name; + const char *concentrator_name; + ppp_link_status_cb_fn link_status_cb; + void *ctx_cb; + } ethernetcreate; +#endif /* PPPOE_SUPPORT */ +#if PPPOL2TP_SUPPORT + struct { + struct netif *pppif; + struct netif *netif; + API_MSG_M_DEF_C(ip_addr_t, ipaddr); + u16_t port; +#if PPPOL2TP_AUTH_SUPPORT + const u8_t *secret; + u8_t secret_len; +#endif /* PPPOL2TP_AUTH_SUPPORT */ + ppp_link_status_cb_fn link_status_cb; + void *ctx_cb; + } l2tpcreate; +#endif /* PPPOL2TP_SUPPORT */ + struct { + u16_t holdoff; + } connect; + struct { + u8_t nocarrier; + } close; + struct { + u8_t cmd; + void *arg; + } ioctl; + } msg; +}; + +struct pppapi_msg { + struct tcpip_api_call_data call; + struct pppapi_msg_msg msg; +}; + +/* API for application */ +err_t pppapi_set_default(ppp_pcb *pcb); +#if PPP_NOTIFY_PHASE +err_t pppapi_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb); +#endif /* PPP_NOTIFY_PHASE */ +#if PPPOS_SUPPORT +ppp_pcb *pppapi_pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, ppp_link_status_cb_fn link_status_cb, void *ctx_cb); +#endif /* PPPOS_SUPPORT */ +#if PPPOE_SUPPORT +ppp_pcb *pppapi_pppoe_create(struct netif *pppif, struct netif *ethif, const char *service_name, + const char *concentrator_name, ppp_link_status_cb_fn link_status_cb, + void *ctx_cb); +#endif /* PPPOE_SUPPORT */ +#if PPPOL2TP_SUPPORT +ppp_pcb *pppapi_pppol2tp_create(struct netif *pppif, struct netif *netif, ip_addr_t *ipaddr, u16_t port, + const u8_t *secret, u8_t secret_len, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb); +#endif /* PPPOL2TP_SUPPORT */ +err_t pppapi_connect(ppp_pcb *pcb, u16_t holdoff); +#if PPP_SERVER +err_t pppapi_listen(ppp_pcb *pcb); +#endif /* PPP_SERVER */ +err_t pppapi_close(ppp_pcb *pcb, u8_t nocarrier); +err_t pppapi_free(ppp_pcb *pcb); +err_t pppapi_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_PPP_API */ + +#endif /* LWIP_PPPAPI_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppcrypt.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppcrypt.h index 968e5328..c0230bbc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppcrypt.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppcrypt.h @@ -1,144 +1,144 @@ -/* - * pppcrypt.c - PPP/DES linkage for MS-CHAP and EAP SRP-SHA1 - * - * Extracted from chap_ms.c by James Carlson. - * - * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -/* This header file is included in all PPP modules needing hashes and/or ciphers */ - -#ifndef PPPCRYPT_H -#define PPPCRYPT_H - -/* - * If included PolarSSL copy is not used, user is expected to include - * external libraries in arch/cc.h (which is included by lwip/arch.h). - */ -#include "lwip/arch.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Map hashes and ciphers functions to PolarSSL - */ -#if !LWIP_USE_EXTERNAL_MBEDTLS - -#include "netif/ppp/polarssl/md4.h" -#define lwip_md4_context md4_context -#define lwip_md4_init(context) -#define lwip_md4_starts md4_starts -#define lwip_md4_update md4_update -#define lwip_md4_finish md4_finish -#define lwip_md4_free(context) - -#include "netif/ppp/polarssl/md5.h" -#define lwip_md5_context md5_context -#define lwip_md5_init(context) -#define lwip_md5_starts md5_starts -#define lwip_md5_update md5_update -#define lwip_md5_finish md5_finish -#define lwip_md5_free(context) - -#include "netif/ppp/polarssl/sha1.h" -#define lwip_sha1_context sha1_context -#define lwip_sha1_init(context) -#define lwip_sha1_starts sha1_starts -#define lwip_sha1_update sha1_update -#define lwip_sha1_finish sha1_finish -#define lwip_sha1_free(context) - -#include "netif/ppp/polarssl/des.h" -#define lwip_des_context des_context -#define lwip_des_init(context) -#define lwip_des_setkey_enc des_setkey_enc -#define lwip_des_crypt_ecb des_crypt_ecb -#define lwip_des_free(context) - -#include "netif/ppp/polarssl/arc4.h" -#define lwip_arc4_context arc4_context -#define lwip_arc4_init(context) -#define lwip_arc4_setup arc4_setup -#define lwip_arc4_crypt arc4_crypt -#define lwip_arc4_free(context) - -#endif /* !LWIP_USE_EXTERNAL_MBEDTLS */ - -/* - * Map hashes and ciphers functions to mbed TLS - */ -#if LWIP_USE_EXTERNAL_MBEDTLS - -#define lwip_md4_context mbedtls_md4_context -#define lwip_md4_init mbedtls_md4_init -#define lwip_md4_starts mbedtls_md4_starts -#define lwip_md4_update mbedtls_md4_update -#define lwip_md4_finish mbedtls_md4_finish -#define lwip_md4_free mbedtls_md4_free - -#define lwip_md5_context mbedtls_md5_context -#define lwip_md5_init mbedtls_md5_init -#define lwip_md5_starts mbedtls_md5_starts -#define lwip_md5_update mbedtls_md5_update -#define lwip_md5_finish mbedtls_md5_finish -#define lwip_md5_free mbedtls_md5_free - -#define lwip_sha1_context mbedtls_sha1_context -#define lwip_sha1_init mbedtls_sha1_init -#define lwip_sha1_starts mbedtls_sha1_starts -#define lwip_sha1_update mbedtls_sha1_update -#define lwip_sha1_finish mbedtls_sha1_finish -#define lwip_sha1_free mbedtls_sha1_free - -#define lwip_des_context mbedtls_des_context -#define lwip_des_init mbedtls_des_init -#define lwip_des_setkey_enc mbedtls_des_setkey_enc -#define lwip_des_crypt_ecb mbedtls_des_crypt_ecb -#define lwip_des_free mbedtls_des_free - -#define lwip_arc4_context mbedtls_arc4_context -#define lwip_arc4_init mbedtls_arc4_init -#define lwip_arc4_setup mbedtls_arc4_setup -#define lwip_arc4_crypt(context, buffer, length) mbedtls_arc4_crypt(context, length, buffer, buffer) -#define lwip_arc4_free mbedtls_arc4_free - -#endif /* LWIP_USE_EXTERNAL_MBEDTLS */ - -void pppcrypt_56_to_64_bit_key(u_char *key, u_char *des_key); - -#ifdef __cplusplus -} -#endif - -#endif /* PPPCRYPT_H */ - -#endif /* PPP_SUPPORT */ +/* + * pppcrypt.c - PPP/DES linkage for MS-CHAP and EAP SRP-SHA1 + * + * Extracted from chap_ms.c by James Carlson. + * + * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +/* This header file is included in all PPP modules needing hashes and/or ciphers */ + +#ifndef PPPCRYPT_H +#define PPPCRYPT_H + +/* + * If included PolarSSL copy is not used, user is expected to include + * external libraries in arch/cc.h (which is included by lwip/arch.h). + */ +#include "lwip/arch.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Map hashes and ciphers functions to PolarSSL + */ +#if !LWIP_USE_EXTERNAL_MBEDTLS + +#include "netif/ppp/polarssl/md4.h" +#define lwip_md4_context md4_context +#define lwip_md4_init(context) +#define lwip_md4_starts md4_starts +#define lwip_md4_update md4_update +#define lwip_md4_finish md4_finish +#define lwip_md4_free(context) + +#include "netif/ppp/polarssl/md5.h" +#define lwip_md5_context md5_context +#define lwip_md5_init(context) +#define lwip_md5_starts md5_starts +#define lwip_md5_update md5_update +#define lwip_md5_finish md5_finish +#define lwip_md5_free(context) + +#include "netif/ppp/polarssl/sha1.h" +#define lwip_sha1_context sha1_context +#define lwip_sha1_init(context) +#define lwip_sha1_starts sha1_starts +#define lwip_sha1_update sha1_update +#define lwip_sha1_finish sha1_finish +#define lwip_sha1_free(context) + +#include "netif/ppp/polarssl/des.h" +#define lwip_des_context des_context +#define lwip_des_init(context) +#define lwip_des_setkey_enc des_setkey_enc +#define lwip_des_crypt_ecb des_crypt_ecb +#define lwip_des_free(context) + +#include "netif/ppp/polarssl/arc4.h" +#define lwip_arc4_context arc4_context +#define lwip_arc4_init(context) +#define lwip_arc4_setup arc4_setup +#define lwip_arc4_crypt arc4_crypt +#define lwip_arc4_free(context) + +#endif /* !LWIP_USE_EXTERNAL_MBEDTLS */ + +/* + * Map hashes and ciphers functions to mbed TLS + */ +#if LWIP_USE_EXTERNAL_MBEDTLS + +#define lwip_md4_context mbedtls_md4_context +#define lwip_md4_init mbedtls_md4_init +#define lwip_md4_starts mbedtls_md4_starts +#define lwip_md4_update mbedtls_md4_update +#define lwip_md4_finish mbedtls_md4_finish +#define lwip_md4_free mbedtls_md4_free + +#define lwip_md5_context mbedtls_md5_context +#define lwip_md5_init mbedtls_md5_init +#define lwip_md5_starts mbedtls_md5_starts +#define lwip_md5_update mbedtls_md5_update +#define lwip_md5_finish mbedtls_md5_finish +#define lwip_md5_free mbedtls_md5_free + +#define lwip_sha1_context mbedtls_sha1_context +#define lwip_sha1_init mbedtls_sha1_init +#define lwip_sha1_starts mbedtls_sha1_starts +#define lwip_sha1_update mbedtls_sha1_update +#define lwip_sha1_finish mbedtls_sha1_finish +#define lwip_sha1_free mbedtls_sha1_free + +#define lwip_des_context mbedtls_des_context +#define lwip_des_init mbedtls_des_init +#define lwip_des_setkey_enc mbedtls_des_setkey_enc +#define lwip_des_crypt_ecb mbedtls_des_crypt_ecb +#define lwip_des_free mbedtls_des_free + +#define lwip_arc4_context mbedtls_arc4_context +#define lwip_arc4_init mbedtls_arc4_init +#define lwip_arc4_setup mbedtls_arc4_setup +#define lwip_arc4_crypt(context, buffer, length) mbedtls_arc4_crypt(context, length, buffer, buffer) +#define lwip_arc4_free mbedtls_arc4_free + +#endif /* LWIP_USE_EXTERNAL_MBEDTLS */ + +void pppcrypt_56_to_64_bit_key(u_char *key, u_char *des_key); + +#ifdef __cplusplus +} +#endif + +#endif /* PPPCRYPT_H */ + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppdebug.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppdebug.h index 391b7c61..36ee4f9b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppdebug.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppdebug.h @@ -1,88 +1,88 @@ -/***************************************************************************** -* pppdebug.h - System debugging utilities. -* -* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. -* portions Copyright (c) 1998 Global Election Systems Inc. -* portions Copyright (c) 2001 by Cognizant Pty Ltd. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY (please don't use tabs!) -* -* 03-01-01 Marc Boucher -* Ported to lwIP. -* 98-07-29 Guy Lancaster , Global Election Systems Inc. -* Original. -* -***************************************************************************** -*/ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef PPPDEBUG_H -#define PPPDEBUG_H - -#ifdef __cplusplus -extern "C" { -#endif - -/* Trace levels. */ -#define LOG_CRITICAL (PPP_DEBUG | LWIP_DBG_LEVEL_SEVERE) -#define LOG_ERR (PPP_DEBUG | LWIP_DBG_LEVEL_SEVERE) -#define LOG_NOTICE (PPP_DEBUG | LWIP_DBG_LEVEL_WARNING) -#define LOG_WARNING (PPP_DEBUG | LWIP_DBG_LEVEL_WARNING) -#define LOG_INFO (PPP_DEBUG) -#define LOG_DETAIL (PPP_DEBUG) -#define LOG_DEBUG (PPP_DEBUG) - -#if PPP_DEBUG - -#define MAINDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define SYSDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define FSMDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define LCPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define IPCPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define IPV6CPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define UPAPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define CHAPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) -#define PPPDEBUG(a, b) LWIP_DEBUGF(a, b) - -#else /* PPP_DEBUG */ - -#define MAINDEBUG(a) -#define SYSDEBUG(a) -#define FSMDEBUG(a) -#define LCPDEBUG(a) -#define IPCPDEBUG(a) -#define IPV6CPDEBUG(a) -#define UPAPDEBUG(a) -#define CHAPDEBUG(a) -#define PPPDEBUG(a, b) - -#endif /* PPP_DEBUG */ - -#ifdef __cplusplus -} -#endif - -#endif /* PPPDEBUG_H */ - -#endif /* PPP_SUPPORT */ +/***************************************************************************** +* pppdebug.h - System debugging utilities. +* +* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. +* portions Copyright (c) 1998 Global Election Systems Inc. +* portions Copyright (c) 2001 by Cognizant Pty Ltd. +* +* The authors hereby grant permission to use, copy, modify, distribute, +* and license this software and its documentation for any purpose, provided +* that existing copyright notices are retained in all copies and that this +* notice and the following disclaimer are included verbatim in any +* distributions. No written agreement, license, or royalty fee is required +* for any of the authorized uses. +* +* THIS SOFTWARE IS PROVIDED BY THE 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 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. +* +****************************************************************************** +* REVISION HISTORY (please don't use tabs!) +* +* 03-01-01 Marc Boucher +* Ported to lwIP. +* 98-07-29 Guy Lancaster , Global Election Systems Inc. +* Original. +* +***************************************************************************** +*/ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef PPPDEBUG_H +#define PPPDEBUG_H + +#ifdef __cplusplus +extern "C" { +#endif + +/* Trace levels. */ +#define LOG_CRITICAL (PPP_DEBUG | LWIP_DBG_LEVEL_SEVERE) +#define LOG_ERR (PPP_DEBUG | LWIP_DBG_LEVEL_SEVERE) +#define LOG_NOTICE (PPP_DEBUG | LWIP_DBG_LEVEL_WARNING) +#define LOG_WARNING (PPP_DEBUG | LWIP_DBG_LEVEL_WARNING) +#define LOG_INFO (PPP_DEBUG) +#define LOG_DETAIL (PPP_DEBUG) +#define LOG_DEBUG (PPP_DEBUG) + +#if PPP_DEBUG + +#define MAINDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define SYSDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define FSMDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define LCPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define IPCPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define IPV6CPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define UPAPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define CHAPDEBUG(a) LWIP_DEBUGF(LWIP_DBG_LEVEL_WARNING, a) +#define PPPDEBUG(a, b) LWIP_DEBUGF(a, b) + +#else /* PPP_DEBUG */ + +#define MAINDEBUG(a) +#define SYSDEBUG(a) +#define FSMDEBUG(a) +#define LCPDEBUG(a) +#define IPCPDEBUG(a) +#define IPV6CPDEBUG(a) +#define UPAPDEBUG(a) +#define CHAPDEBUG(a) +#define PPPDEBUG(a, b) + +#endif /* PPP_DEBUG */ + +#ifdef __cplusplus +} +#endif + +#endif /* PPPDEBUG_H */ + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppoe.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppoe.h index 93acd4c9..08ab7ab5 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppoe.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppoe.h @@ -1,187 +1,187 @@ -/***************************************************************************** -* pppoe.h - PPP Over Ethernet implementation for lwIP. -* -* Copyright (c) 2006 by Marc Boucher, Services Informatiques (MBSI) inc. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY -* -* 06-01-01 Marc Boucher -* Ported to lwIP. -*****************************************************************************/ - - - -/* based on NetBSD: if_pppoe.c,v 1.64 2006/01/31 23:50:15 martin Exp */ - -/*- - * Copyright (c) 2002 The NetBSD Foundation, Inc. - * All rights reserved. - * - * This code is derived from software contributed to The NetBSD Foundation - * by Martin Husemann . - * - * 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. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the NetBSD - * Foundation, Inc. and its contributors. - * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPPOE_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef PPP_OE_H -#define PPP_OE_H - -#include "ppp.h" -#include "lwip/etharp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct pppoehdr { - PACK_STRUCT_FLD_8(u8_t vertype); - PACK_STRUCT_FLD_8(u8_t code); - PACK_STRUCT_FIELD(u16_t session); - PACK_STRUCT_FIELD(u16_t plen); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct pppoetag { - PACK_STRUCT_FIELD(u16_t tag); - PACK_STRUCT_FIELD(u16_t len); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - - -#define PPPOE_STATE_INITIAL 0 -#define PPPOE_STATE_PADI_SENT 1 -#define PPPOE_STATE_PADR_SENT 2 -#define PPPOE_STATE_SESSION 3 -/* passive */ -#define PPPOE_STATE_PADO_SENT 1 - -#define PPPOE_HEADERLEN sizeof(struct pppoehdr) -#define PPPOE_VERTYPE 0x11 /* VER=1, TYPE = 1 */ - -#define PPPOE_TAG_EOL 0x0000 /* end of list */ -#define PPPOE_TAG_SNAME 0x0101 /* service name */ -#define PPPOE_TAG_ACNAME 0x0102 /* access concentrator name */ -#define PPPOE_TAG_HUNIQUE 0x0103 /* host unique */ -#define PPPOE_TAG_ACCOOKIE 0x0104 /* AC cookie */ -#define PPPOE_TAG_VENDOR 0x0105 /* vendor specific */ -#define PPPOE_TAG_RELAYSID 0x0110 /* relay session id */ -#define PPPOE_TAG_SNAME_ERR 0x0201 /* service name error */ -#define PPPOE_TAG_ACSYS_ERR 0x0202 /* AC system error */ -#define PPPOE_TAG_GENERIC_ERR 0x0203 /* gerneric error */ - -#define PPPOE_CODE_PADI 0x09 /* Active Discovery Initiation */ -#define PPPOE_CODE_PADO 0x07 /* Active Discovery Offer */ -#define PPPOE_CODE_PADR 0x19 /* Active Discovery Request */ -#define PPPOE_CODE_PADS 0x65 /* Active Discovery Session confirmation */ -#define PPPOE_CODE_PADT 0xA7 /* Active Discovery Terminate */ - -#ifndef PPPOE_MAX_AC_COOKIE_LEN -#define PPPOE_MAX_AC_COOKIE_LEN 64 -#endif - -struct pppoe_softc { - struct pppoe_softc *next; - struct netif *sc_ethif; /* ethernet interface we are using */ - ppp_pcb *pcb; /* PPP PCB */ - - struct eth_addr sc_dest; /* hardware address of concentrator */ - u16_t sc_session; /* PPPoE session id */ - u8_t sc_state; /* discovery phase or session connected */ - -#ifdef PPPOE_TODO - u8_t *sc_service_name; /* if != NULL: requested name of service */ - u8_t *sc_concentrator_name; /* if != NULL: requested concentrator id */ -#endif /* PPPOE_TODO */ - u8_t sc_ac_cookie[PPPOE_MAX_AC_COOKIE_LEN]; /* content of AC cookie we must echo back */ - u8_t sc_ac_cookie_len; /* length of cookie data */ -#ifdef PPPOE_SERVER - u8_t *sc_hunique; /* content of host unique we must echo back */ - u8_t sc_hunique_len; /* length of host unique */ -#endif - u8_t sc_padi_retried; /* number of PADI retries already done */ - u8_t sc_padr_retried; /* number of PADR retries already done */ -}; - - -#define pppoe_init() /* compatibility define, no initialization needed */ - -ppp_pcb *pppoe_create(struct netif *pppif, - struct netif *ethif, - const char *service_name, const char *concentrator_name, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb); - -/* - * Functions called from lwIP - * DO NOT CALL FROM lwIP USER APPLICATION. - */ -void pppoe_disc_input(struct netif *netif, struct pbuf *p); -void pppoe_data_input(struct netif *netif, struct pbuf *p); - -#ifdef __cplusplus -} -#endif - -#endif /* PPP_OE_H */ - -#endif /* PPP_SUPPORT && PPPOE_SUPPORT */ +/***************************************************************************** +* pppoe.h - PPP Over Ethernet implementation for lwIP. +* +* Copyright (c) 2006 by Marc Boucher, Services Informatiques (MBSI) inc. +* +* The authors hereby grant permission to use, copy, modify, distribute, +* and license this software and its documentation for any purpose, provided +* that existing copyright notices are retained in all copies and that this +* notice and the following disclaimer are included verbatim in any +* distributions. No written agreement, license, or royalty fee is required +* for any of the authorized uses. +* +* THIS SOFTWARE IS PROVIDED BY THE 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 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. +* +****************************************************************************** +* REVISION HISTORY +* +* 06-01-01 Marc Boucher +* Ported to lwIP. +*****************************************************************************/ + + + +/* based on NetBSD: if_pppoe.c,v 1.64 2006/01/31 23:50:15 martin Exp */ + +/*- + * Copyright (c) 2002 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Martin Husemann . + * + * 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPPOE_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef PPP_OE_H +#define PPP_OE_H + +#include "ppp.h" +#include "lwip/etharp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct pppoehdr { + PACK_STRUCT_FLD_8(u8_t vertype); + PACK_STRUCT_FLD_8(u8_t code); + PACK_STRUCT_FIELD(u16_t session); + PACK_STRUCT_FIELD(u16_t plen); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct pppoetag { + PACK_STRUCT_FIELD(u16_t tag); + PACK_STRUCT_FIELD(u16_t len); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + + +#define PPPOE_STATE_INITIAL 0 +#define PPPOE_STATE_PADI_SENT 1 +#define PPPOE_STATE_PADR_SENT 2 +#define PPPOE_STATE_SESSION 3 +/* passive */ +#define PPPOE_STATE_PADO_SENT 1 + +#define PPPOE_HEADERLEN sizeof(struct pppoehdr) +#define PPPOE_VERTYPE 0x11 /* VER=1, TYPE = 1 */ + +#define PPPOE_TAG_EOL 0x0000 /* end of list */ +#define PPPOE_TAG_SNAME 0x0101 /* service name */ +#define PPPOE_TAG_ACNAME 0x0102 /* access concentrator name */ +#define PPPOE_TAG_HUNIQUE 0x0103 /* host unique */ +#define PPPOE_TAG_ACCOOKIE 0x0104 /* AC cookie */ +#define PPPOE_TAG_VENDOR 0x0105 /* vendor specific */ +#define PPPOE_TAG_RELAYSID 0x0110 /* relay session id */ +#define PPPOE_TAG_SNAME_ERR 0x0201 /* service name error */ +#define PPPOE_TAG_ACSYS_ERR 0x0202 /* AC system error */ +#define PPPOE_TAG_GENERIC_ERR 0x0203 /* gerneric error */ + +#define PPPOE_CODE_PADI 0x09 /* Active Discovery Initiation */ +#define PPPOE_CODE_PADO 0x07 /* Active Discovery Offer */ +#define PPPOE_CODE_PADR 0x19 /* Active Discovery Request */ +#define PPPOE_CODE_PADS 0x65 /* Active Discovery Session confirmation */ +#define PPPOE_CODE_PADT 0xA7 /* Active Discovery Terminate */ + +#ifndef PPPOE_MAX_AC_COOKIE_LEN +#define PPPOE_MAX_AC_COOKIE_LEN 64 +#endif + +struct pppoe_softc { + struct pppoe_softc *next; + struct netif *sc_ethif; /* ethernet interface we are using */ + ppp_pcb *pcb; /* PPP PCB */ + + struct eth_addr sc_dest; /* hardware address of concentrator */ + u16_t sc_session; /* PPPoE session id */ + u8_t sc_state; /* discovery phase or session connected */ + +#ifdef PPPOE_TODO + u8_t *sc_service_name; /* if != NULL: requested name of service */ + u8_t *sc_concentrator_name; /* if != NULL: requested concentrator id */ +#endif /* PPPOE_TODO */ + u8_t sc_ac_cookie[PPPOE_MAX_AC_COOKIE_LEN]; /* content of AC cookie we must echo back */ + u8_t sc_ac_cookie_len; /* length of cookie data */ +#ifdef PPPOE_SERVER + u8_t *sc_hunique; /* content of host unique we must echo back */ + u8_t sc_hunique_len; /* length of host unique */ +#endif + u8_t sc_padi_retried; /* number of PADI retries already done */ + u8_t sc_padr_retried; /* number of PADR retries already done */ +}; + + +#define pppoe_init() /* compatibility define, no initialization needed */ + +ppp_pcb *pppoe_create(struct netif *pppif, + struct netif *ethif, + const char *service_name, const char *concentrator_name, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb); + +/* + * Functions called from lwIP + * DO NOT CALL FROM lwIP USER APPLICATION. + */ +void pppoe_disc_input(struct netif *netif, struct pbuf *p); +void pppoe_data_input(struct netif *netif, struct pbuf *p); + +#ifdef __cplusplus +} +#endif + +#endif /* PPP_OE_H */ + +#endif /* PPP_SUPPORT && PPPOE_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppol2tp.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppol2tp.h index e09d6e1f..1221ca15 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppol2tp.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppol2tp.h @@ -1,209 +1,209 @@ -/** - * @file - * Network Point to Point Protocol over Layer 2 Tunneling Protocol header file. - * - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPPOL2TP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef PPPOL2TP_H -#define PPPOL2TP_H - -#include "ppp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* Timeout */ -#define PPPOL2TP_CONTROL_TIMEOUT (5*1000) /* base for quick timeout calculation */ -#define PPPOL2TP_SLOW_RETRY (60*1000) /* persistent retry interval */ - -#define PPPOL2TP_MAXSCCRQ 4 /* retry SCCRQ four times (quickly) */ -#define PPPOL2TP_MAXICRQ 4 /* retry IRCQ four times */ -#define PPPOL2TP_MAXICCN 4 /* retry ICCN four times */ - -/* L2TP header flags */ -#define PPPOL2TP_HEADERFLAG_CONTROL 0x8000 -#define PPPOL2TP_HEADERFLAG_LENGTH 0x4000 -#define PPPOL2TP_HEADERFLAG_SEQUENCE 0x0800 -#define PPPOL2TP_HEADERFLAG_OFFSET 0x0200 -#define PPPOL2TP_HEADERFLAG_PRIORITY 0x0100 -#define PPPOL2TP_HEADERFLAG_VERSION 0x0002 - -/* Mandatory bits for control: Control, Length, Sequence, Version 2 */ -#define PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY (PPPOL2TP_HEADERFLAG_CONTROL|PPPOL2TP_HEADERFLAG_LENGTH|PPPOL2TP_HEADERFLAG_SEQUENCE|PPPOL2TP_HEADERFLAG_VERSION) -/* Forbidden bits for control: Offset, Priority */ -#define PPPOL2TP_HEADERFLAG_CONTROL_FORBIDDEN (PPPOL2TP_HEADERFLAG_OFFSET|PPPOL2TP_HEADERFLAG_PRIORITY) - -/* Mandatory bits for data: Version 2 */ -#define PPPOL2TP_HEADERFLAG_DATA_MANDATORY (PPPOL2TP_HEADERFLAG_VERSION) - -/* AVP (Attribute Value Pair) header */ -#define PPPOL2TP_AVPHEADERFLAG_MANDATORY 0x8000 -#define PPPOL2TP_AVPHEADERFLAG_HIDDEN 0x4000 -#define PPPOL2TP_AVPHEADERFLAG_LENGTHMASK 0x03ff - -/* -- AVP - Message type */ -#define PPPOL2TP_AVPTYPE_MESSAGE 0 /* Message type */ - -/* Control Connection Management */ -#define PPPOL2TP_MESSAGETYPE_SCCRQ 1 /* Start Control Connection Request */ -#define PPPOL2TP_MESSAGETYPE_SCCRP 2 /* Start Control Connection Reply */ -#define PPPOL2TP_MESSAGETYPE_SCCCN 3 /* Start Control Connection Connected */ -#define PPPOL2TP_MESSAGETYPE_STOPCCN 4 /* Stop Control Connection Notification */ -#define PPPOL2TP_MESSAGETYPE_HELLO 6 /* Hello */ -/* Call Management */ -#define PPPOL2TP_MESSAGETYPE_OCRQ 7 /* Outgoing Call Request */ -#define PPPOL2TP_MESSAGETYPE_OCRP 8 /* Outgoing Call Reply */ -#define PPPOL2TP_MESSAGETYPE_OCCN 9 /* Outgoing Call Connected */ -#define PPPOL2TP_MESSAGETYPE_ICRQ 10 /* Incoming Call Request */ -#define PPPOL2TP_MESSAGETYPE_ICRP 11 /* Incoming Call Reply */ -#define PPPOL2TP_MESSAGETYPE_ICCN 12 /* Incoming Call Connected */ -#define PPPOL2TP_MESSAGETYPE_CDN 14 /* Call Disconnect Notify */ -/* Error reporting */ -#define PPPOL2TP_MESSAGETYPE_WEN 15 /* WAN Error Notify */ -/* PPP Session Control */ -#define PPPOL2TP_MESSAGETYPE_SLI 16 /* Set Link Info */ - -/* -- AVP - Result code */ -#define PPPOL2TP_AVPTYPE_RESULTCODE 1 /* Result code */ -#define PPPOL2TP_RESULTCODE 1 /* General request to clear control connection */ - -/* -- AVP - Protocol version (!= L2TP Header version) */ -#define PPPOL2TP_AVPTYPE_VERSION 2 -#define PPPOL2TP_VERSION 0x0100 /* L2TP Protocol version 1, revision 0 */ - -/* -- AVP - Framing capabilities */ -#define PPPOL2TP_AVPTYPE_FRAMINGCAPABILITIES 3 /* Bearer capabilities */ -#define PPPOL2TP_FRAMINGCAPABILITIES 0x00000003 /* Async + Sync framing */ - -/* -- AVP - Bearer capabilities */ -#define PPPOL2TP_AVPTYPE_BEARERCAPABILITIES 4 /* Bearer capabilities */ -#define PPPOL2TP_BEARERCAPABILITIES 0x00000003 /* Analog + Digital Access */ - -/* -- AVP - Tie breaker */ -#define PPPOL2TP_AVPTYPE_TIEBREAKER 5 - -/* -- AVP - Host name */ -#define PPPOL2TP_AVPTYPE_HOSTNAME 7 /* Host name */ -#define PPPOL2TP_HOSTNAME "lwIP" /* FIXME: make it configurable */ - -/* -- AVP - Vendor name */ -#define PPPOL2TP_AVPTYPE_VENDORNAME 8 /* Vendor name */ -#define PPPOL2TP_VENDORNAME "lwIP" /* FIXME: make it configurable */ - -/* -- AVP - Assign tunnel ID */ -#define PPPOL2TP_AVPTYPE_TUNNELID 9 /* Assign Tunnel ID */ - -/* -- AVP - Receive window size */ -#define PPPOL2TP_AVPTYPE_RECEIVEWINDOWSIZE 10 /* Receive window size */ -#define PPPOL2TP_RECEIVEWINDOWSIZE 8 /* FIXME: make it configurable */ - -/* -- AVP - Challenge */ -#define PPPOL2TP_AVPTYPE_CHALLENGE 11 /* Challenge */ - -/* -- AVP - Cause code */ -#define PPPOL2TP_AVPTYPE_CAUSECODE 12 /* Cause code*/ - -/* -- AVP - Challenge response */ -#define PPPOL2TP_AVPTYPE_CHALLENGERESPONSE 13 /* Challenge response */ -#define PPPOL2TP_AVPTYPE_CHALLENGERESPONSE_SIZE 16 - -/* -- AVP - Assign session ID */ -#define PPPOL2TP_AVPTYPE_SESSIONID 14 /* Assign Session ID */ - -/* -- AVP - Call serial number */ -#define PPPOL2TP_AVPTYPE_CALLSERIALNUMBER 15 /* Call Serial Number */ - -/* -- AVP - Framing type */ -#define PPPOL2TP_AVPTYPE_FRAMINGTYPE 19 /* Framing Type */ -#define PPPOL2TP_FRAMINGTYPE 0x00000001 /* Sync framing */ - -/* -- AVP - TX Connect Speed */ -#define PPPOL2TP_AVPTYPE_TXCONNECTSPEED 24 /* TX Connect Speed */ -#define PPPOL2TP_TXCONNECTSPEED 100000000 /* Connect speed: 100 Mbits/s */ - -/* L2TP Session state */ -#define PPPOL2TP_STATE_INITIAL 0 -#define PPPOL2TP_STATE_SCCRQ_SENT 1 -#define PPPOL2TP_STATE_ICRQ_SENT 2 -#define PPPOL2TP_STATE_ICCN_SENT 3 -#define PPPOL2TP_STATE_DATA 4 - -#define PPPOL2TP_OUTPUT_DATA_HEADER_LEN 6 /* Our data header len */ - -/* - * PPPoL2TP interface control block. - */ -typedef struct pppol2tp_pcb_s pppol2tp_pcb; -struct pppol2tp_pcb_s { - ppp_pcb *ppp; /* PPP PCB */ - u8_t phase; /* L2TP phase */ - struct udp_pcb *udp; /* UDP L2TP Socket */ - struct netif *netif; /* Output interface, used as a default route */ - ip_addr_t remote_ip; /* LNS IP Address */ - u16_t remote_port; /* LNS port */ -#if PPPOL2TP_AUTH_SUPPORT - const u8_t *secret; /* Secret string */ - u8_t secret_len; /* Secret string length */ - u8_t secret_rv[16]; /* Random vector */ - u8_t challenge_hash[16]; /* Challenge response */ - u8_t send_challenge; /* Boolean whether the next sent packet should contains a challenge response */ -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - u16_t tunnel_port; /* Tunnel port */ - u16_t our_ns; /* NS to peer */ - u16_t peer_nr; /* NR from peer */ - u16_t peer_ns; /* Expected NS from peer */ - u16_t source_tunnel_id; /* Tunnel ID assigned by peer */ - u16_t remote_tunnel_id; /* Tunnel ID assigned to peer */ - u16_t source_session_id; /* Session ID assigned by peer */ - u16_t remote_session_id; /* Session ID assigned to peer */ - - u8_t sccrq_retried; /* number of SCCRQ retries already done */ - u8_t icrq_retried; /* number of ICRQ retries already done */ - u8_t iccn_retried; /* number of ICCN retries already done */ -}; - - -/* Create a new L2TP session. */ -ppp_pcb *pppol2tp_create(struct netif *pppif, - struct netif *netif, const ip_addr_t *ipaddr, u16_t port, - const u8_t *secret, u8_t secret_len, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb); - -#ifdef __cplusplus -} -#endif - -#endif /* PPPOL2TP_H */ -#endif /* PPP_SUPPORT && PPPOL2TP_SUPPORT */ +/** + * @file + * Network Point to Point Protocol over Layer 2 Tunneling Protocol header file. + * + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPPOL2TP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef PPPOL2TP_H +#define PPPOL2TP_H + +#include "ppp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* Timeout */ +#define PPPOL2TP_CONTROL_TIMEOUT (5*1000) /* base for quick timeout calculation */ +#define PPPOL2TP_SLOW_RETRY (60*1000) /* persistent retry interval */ + +#define PPPOL2TP_MAXSCCRQ 4 /* retry SCCRQ four times (quickly) */ +#define PPPOL2TP_MAXICRQ 4 /* retry IRCQ four times */ +#define PPPOL2TP_MAXICCN 4 /* retry ICCN four times */ + +/* L2TP header flags */ +#define PPPOL2TP_HEADERFLAG_CONTROL 0x8000 +#define PPPOL2TP_HEADERFLAG_LENGTH 0x4000 +#define PPPOL2TP_HEADERFLAG_SEQUENCE 0x0800 +#define PPPOL2TP_HEADERFLAG_OFFSET 0x0200 +#define PPPOL2TP_HEADERFLAG_PRIORITY 0x0100 +#define PPPOL2TP_HEADERFLAG_VERSION 0x0002 + +/* Mandatory bits for control: Control, Length, Sequence, Version 2 */ +#define PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY (PPPOL2TP_HEADERFLAG_CONTROL|PPPOL2TP_HEADERFLAG_LENGTH|PPPOL2TP_HEADERFLAG_SEQUENCE|PPPOL2TP_HEADERFLAG_VERSION) +/* Forbidden bits for control: Offset, Priority */ +#define PPPOL2TP_HEADERFLAG_CONTROL_FORBIDDEN (PPPOL2TP_HEADERFLAG_OFFSET|PPPOL2TP_HEADERFLAG_PRIORITY) + +/* Mandatory bits for data: Version 2 */ +#define PPPOL2TP_HEADERFLAG_DATA_MANDATORY (PPPOL2TP_HEADERFLAG_VERSION) + +/* AVP (Attribute Value Pair) header */ +#define PPPOL2TP_AVPHEADERFLAG_MANDATORY 0x8000 +#define PPPOL2TP_AVPHEADERFLAG_HIDDEN 0x4000 +#define PPPOL2TP_AVPHEADERFLAG_LENGTHMASK 0x03ff + +/* -- AVP - Message type */ +#define PPPOL2TP_AVPTYPE_MESSAGE 0 /* Message type */ + +/* Control Connection Management */ +#define PPPOL2TP_MESSAGETYPE_SCCRQ 1 /* Start Control Connection Request */ +#define PPPOL2TP_MESSAGETYPE_SCCRP 2 /* Start Control Connection Reply */ +#define PPPOL2TP_MESSAGETYPE_SCCCN 3 /* Start Control Connection Connected */ +#define PPPOL2TP_MESSAGETYPE_STOPCCN 4 /* Stop Control Connection Notification */ +#define PPPOL2TP_MESSAGETYPE_HELLO 6 /* Hello */ +/* Call Management */ +#define PPPOL2TP_MESSAGETYPE_OCRQ 7 /* Outgoing Call Request */ +#define PPPOL2TP_MESSAGETYPE_OCRP 8 /* Outgoing Call Reply */ +#define PPPOL2TP_MESSAGETYPE_OCCN 9 /* Outgoing Call Connected */ +#define PPPOL2TP_MESSAGETYPE_ICRQ 10 /* Incoming Call Request */ +#define PPPOL2TP_MESSAGETYPE_ICRP 11 /* Incoming Call Reply */ +#define PPPOL2TP_MESSAGETYPE_ICCN 12 /* Incoming Call Connected */ +#define PPPOL2TP_MESSAGETYPE_CDN 14 /* Call Disconnect Notify */ +/* Error reporting */ +#define PPPOL2TP_MESSAGETYPE_WEN 15 /* WAN Error Notify */ +/* PPP Session Control */ +#define PPPOL2TP_MESSAGETYPE_SLI 16 /* Set Link Info */ + +/* -- AVP - Result code */ +#define PPPOL2TP_AVPTYPE_RESULTCODE 1 /* Result code */ +#define PPPOL2TP_RESULTCODE 1 /* General request to clear control connection */ + +/* -- AVP - Protocol version (!= L2TP Header version) */ +#define PPPOL2TP_AVPTYPE_VERSION 2 +#define PPPOL2TP_VERSION 0x0100 /* L2TP Protocol version 1, revision 0 */ + +/* -- AVP - Framing capabilities */ +#define PPPOL2TP_AVPTYPE_FRAMINGCAPABILITIES 3 /* Bearer capabilities */ +#define PPPOL2TP_FRAMINGCAPABILITIES 0x00000003 /* Async + Sync framing */ + +/* -- AVP - Bearer capabilities */ +#define PPPOL2TP_AVPTYPE_BEARERCAPABILITIES 4 /* Bearer capabilities */ +#define PPPOL2TP_BEARERCAPABILITIES 0x00000003 /* Analog + Digital Access */ + +/* -- AVP - Tie breaker */ +#define PPPOL2TP_AVPTYPE_TIEBREAKER 5 + +/* -- AVP - Host name */ +#define PPPOL2TP_AVPTYPE_HOSTNAME 7 /* Host name */ +#define PPPOL2TP_HOSTNAME "lwIP" /* FIXME: make it configurable */ + +/* -- AVP - Vendor name */ +#define PPPOL2TP_AVPTYPE_VENDORNAME 8 /* Vendor name */ +#define PPPOL2TP_VENDORNAME "lwIP" /* FIXME: make it configurable */ + +/* -- AVP - Assign tunnel ID */ +#define PPPOL2TP_AVPTYPE_TUNNELID 9 /* Assign Tunnel ID */ + +/* -- AVP - Receive window size */ +#define PPPOL2TP_AVPTYPE_RECEIVEWINDOWSIZE 10 /* Receive window size */ +#define PPPOL2TP_RECEIVEWINDOWSIZE 8 /* FIXME: make it configurable */ + +/* -- AVP - Challenge */ +#define PPPOL2TP_AVPTYPE_CHALLENGE 11 /* Challenge */ + +/* -- AVP - Cause code */ +#define PPPOL2TP_AVPTYPE_CAUSECODE 12 /* Cause code*/ + +/* -- AVP - Challenge response */ +#define PPPOL2TP_AVPTYPE_CHALLENGERESPONSE 13 /* Challenge response */ +#define PPPOL2TP_AVPTYPE_CHALLENGERESPONSE_SIZE 16 + +/* -- AVP - Assign session ID */ +#define PPPOL2TP_AVPTYPE_SESSIONID 14 /* Assign Session ID */ + +/* -- AVP - Call serial number */ +#define PPPOL2TP_AVPTYPE_CALLSERIALNUMBER 15 /* Call Serial Number */ + +/* -- AVP - Framing type */ +#define PPPOL2TP_AVPTYPE_FRAMINGTYPE 19 /* Framing Type */ +#define PPPOL2TP_FRAMINGTYPE 0x00000001 /* Sync framing */ + +/* -- AVP - TX Connect Speed */ +#define PPPOL2TP_AVPTYPE_TXCONNECTSPEED 24 /* TX Connect Speed */ +#define PPPOL2TP_TXCONNECTSPEED 100000000 /* Connect speed: 100 Mbits/s */ + +/* L2TP Session state */ +#define PPPOL2TP_STATE_INITIAL 0 +#define PPPOL2TP_STATE_SCCRQ_SENT 1 +#define PPPOL2TP_STATE_ICRQ_SENT 2 +#define PPPOL2TP_STATE_ICCN_SENT 3 +#define PPPOL2TP_STATE_DATA 4 + +#define PPPOL2TP_OUTPUT_DATA_HEADER_LEN 6 /* Our data header len */ + +/* + * PPPoL2TP interface control block. + */ +typedef struct pppol2tp_pcb_s pppol2tp_pcb; +struct pppol2tp_pcb_s { + ppp_pcb *ppp; /* PPP PCB */ + u8_t phase; /* L2TP phase */ + struct udp_pcb *udp; /* UDP L2TP Socket */ + struct netif *netif; /* Output interface, used as a default route */ + ip_addr_t remote_ip; /* LNS IP Address */ + u16_t remote_port; /* LNS port */ +#if PPPOL2TP_AUTH_SUPPORT + const u8_t *secret; /* Secret string */ + u8_t secret_len; /* Secret string length */ + u8_t secret_rv[16]; /* Random vector */ + u8_t challenge_hash[16]; /* Challenge response */ + u8_t send_challenge; /* Boolean whether the next sent packet should contains a challenge response */ +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + u16_t tunnel_port; /* Tunnel port */ + u16_t our_ns; /* NS to peer */ + u16_t peer_nr; /* NR from peer */ + u16_t peer_ns; /* Expected NS from peer */ + u16_t source_tunnel_id; /* Tunnel ID assigned by peer */ + u16_t remote_tunnel_id; /* Tunnel ID assigned to peer */ + u16_t source_session_id; /* Session ID assigned by peer */ + u16_t remote_session_id; /* Session ID assigned to peer */ + + u8_t sccrq_retried; /* number of SCCRQ retries already done */ + u8_t icrq_retried; /* number of ICRQ retries already done */ + u8_t iccn_retried; /* number of ICCN retries already done */ +}; + + +/* Create a new L2TP session. */ +ppp_pcb *pppol2tp_create(struct netif *pppif, + struct netif *netif, const ip_addr_t *ipaddr, u16_t port, + const u8_t *secret, u8_t secret_len, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb); + +#ifdef __cplusplus +} +#endif + +#endif /* PPPOL2TP_H */ +#endif /* PPP_SUPPORT && PPPOL2TP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppos.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppos.h index acaedd78..380a965c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppos.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/pppos.h @@ -1,126 +1,126 @@ -/** - * @file - * Network Point to Point Protocol over Serial header file. - * - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPPOS_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef PPPOS_H -#define PPPOS_H - -#include "lwip/sys.h" - -#include "ppp.h" -#include "vj.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* PPP packet parser states. Current state indicates operation yet to be - * completed. */ -enum { - PDIDLE = 0, /* Idle state - waiting. */ - PDSTART, /* Process start flag. */ - PDADDRESS, /* Process address field. */ - PDCONTROL, /* Process control field. */ - PDPROTOCOL1, /* Process protocol field 1. */ - PDPROTOCOL2, /* Process protocol field 2. */ - PDDATA /* Process data byte. */ -}; - -/* PPPoS serial output callback function prototype */ -typedef u32_t (*pppos_output_cb_fn)(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx); - -/* - * Extended asyncmap - allows any character to be escaped. - */ -typedef u8_t ext_accm[32]; - -/* - * PPPoS interface control block. - */ -typedef struct pppos_pcb_s pppos_pcb; -struct pppos_pcb_s { - /* -- below are data that will NOT be cleared between two sessions */ - ppp_pcb *ppp; /* PPP PCB */ - pppos_output_cb_fn output_cb; /* PPP serial output callback */ - - /* -- below are data that will be cleared between two sessions - * - * last_xmit must be the first member of cleared members, because it is - * used to know which part must not be cleared. - */ - u32_t last_xmit; /* Time of last transmission. */ - ext_accm out_accm; /* Async-Ctl-Char-Map for output. */ - - /* flags */ - unsigned int open :1; /* Set if PPPoS is open */ - unsigned int pcomp :1; /* Does peer accept protocol compression? */ - unsigned int accomp :1; /* Does peer accept addr/ctl compression? */ - - /* PPPoS rx */ - ext_accm in_accm; /* Async-Ctl-Char-Map for input. */ - struct pbuf *in_head, *in_tail; /* The input packet. */ - u16_t in_protocol; /* The input protocol code. */ - u16_t in_fcs; /* Input Frame Check Sequence value. */ - u8_t in_state; /* The input process state. */ - u8_t in_escaped; /* Escape next character. */ -}; - -/* Create a new PPPoS session. */ -ppp_pcb *pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb); - -#if !NO_SYS && !PPP_INPROC_IRQ_SAFE -/* Pass received raw characters to PPPoS to be decoded through lwIP TCPIP thread. */ -err_t pppos_input_tcpip(ppp_pcb *ppp, u8_t *s, int l); -#endif /* !NO_SYS && !PPP_INPROC_IRQ_SAFE */ - -/* PPP over Serial: this is the input function to be called for received data. */ -void pppos_input(ppp_pcb *ppp, u8_t* data, int len); - - -/* - * Functions called from lwIP - * DO NOT CALL FROM lwIP USER APPLICATION. - */ -#if !NO_SYS && !PPP_INPROC_IRQ_SAFE -err_t pppos_input_sys(struct pbuf *p, struct netif *inp); -#endif /* !NO_SYS && !PPP_INPROC_IRQ_SAFE */ - -#ifdef __cplusplus -} -#endif - -#endif /* PPPOS_H */ -#endif /* PPP_SUPPORT && PPPOL2TP_SUPPORT */ +/** + * @file + * Network Point to Point Protocol over Serial header file. + * + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPPOS_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef PPPOS_H +#define PPPOS_H + +#include "lwip/sys.h" + +#include "ppp.h" +#include "vj.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* PPP packet parser states. Current state indicates operation yet to be + * completed. */ +enum { + PDIDLE = 0, /* Idle state - waiting. */ + PDSTART, /* Process start flag. */ + PDADDRESS, /* Process address field. */ + PDCONTROL, /* Process control field. */ + PDPROTOCOL1, /* Process protocol field 1. */ + PDPROTOCOL2, /* Process protocol field 2. */ + PDDATA /* Process data byte. */ +}; + +/* PPPoS serial output callback function prototype */ +typedef u32_t (*pppos_output_cb_fn)(ppp_pcb *pcb, u8_t *data, u32_t len, void *ctx); + +/* + * Extended asyncmap - allows any character to be escaped. + */ +typedef u8_t ext_accm[32]; + +/* + * PPPoS interface control block. + */ +typedef struct pppos_pcb_s pppos_pcb; +struct pppos_pcb_s { + /* -- below are data that will NOT be cleared between two sessions */ + ppp_pcb *ppp; /* PPP PCB */ + pppos_output_cb_fn output_cb; /* PPP serial output callback */ + + /* -- below are data that will be cleared between two sessions + * + * last_xmit must be the first member of cleared members, because it is + * used to know which part must not be cleared. + */ + u32_t last_xmit; /* Time of last transmission. */ + ext_accm out_accm; /* Async-Ctl-Char-Map for output. */ + + /* flags */ + unsigned int open :1; /* Set if PPPoS is open */ + unsigned int pcomp :1; /* Does peer accept protocol compression? */ + unsigned int accomp :1; /* Does peer accept addr/ctl compression? */ + + /* PPPoS rx */ + ext_accm in_accm; /* Async-Ctl-Char-Map for input. */ + struct pbuf *in_head, *in_tail; /* The input packet. */ + u16_t in_protocol; /* The input protocol code. */ + u16_t in_fcs; /* Input Frame Check Sequence value. */ + u8_t in_state; /* The input process state. */ + u8_t in_escaped; /* Escape next character. */ +}; + +/* Create a new PPPoS session. */ +ppp_pcb *pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb); + +#if !NO_SYS && !PPP_INPROC_IRQ_SAFE +/* Pass received raw characters to PPPoS to be decoded through lwIP TCPIP thread. */ +err_t pppos_input_tcpip(ppp_pcb *ppp, u8_t *s, int l); +#endif /* !NO_SYS && !PPP_INPROC_IRQ_SAFE */ + +/* PPP over Serial: this is the input function to be called for received data. */ +void pppos_input(ppp_pcb *ppp, u8_t* data, int len); + + +/* + * Functions called from lwIP + * DO NOT CALL FROM lwIP USER APPLICATION. + */ +#if !NO_SYS && !PPP_INPROC_IRQ_SAFE +err_t pppos_input_sys(struct pbuf *p, struct netif *inp); +#endif /* !NO_SYS && !PPP_INPROC_IRQ_SAFE */ + +#ifdef __cplusplus +} +#endif + +#endif /* PPPOS_H */ +#endif /* PPP_SUPPORT && PPPOL2TP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/upap.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/upap.h index 8d90e35f..540d9814 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/upap.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/upap.h @@ -1,131 +1,131 @@ -/* - * upap.h - User/Password Authentication Protocol definitions. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: upap.h,v 1.8 2002/12/04 23:03:33 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef UPAP_H -#define UPAP_H - -#include "ppp.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/* - * Packet header = Code, id, length. - */ -#define UPAP_HEADERLEN 4 - - -/* - * UPAP codes. - */ -#define UPAP_AUTHREQ 1 /* Authenticate-Request */ -#define UPAP_AUTHACK 2 /* Authenticate-Ack */ -#define UPAP_AUTHNAK 3 /* Authenticate-Nak */ - - -/* - * Client states. - */ -#define UPAPCS_INITIAL 0 /* Connection down */ -#define UPAPCS_CLOSED 1 /* Connection up, haven't requested auth */ -#define UPAPCS_PENDING 2 /* Connection down, have requested auth */ -#define UPAPCS_AUTHREQ 3 /* We've sent an Authenticate-Request */ -#define UPAPCS_OPEN 4 /* We've received an Ack */ -#define UPAPCS_BADAUTH 5 /* We've received a Nak */ - -/* - * Server states. - */ -#define UPAPSS_INITIAL 0 /* Connection down */ -#define UPAPSS_CLOSED 1 /* Connection up, haven't requested auth */ -#define UPAPSS_PENDING 2 /* Connection down, have requested auth */ -#define UPAPSS_LISTEN 3 /* Listening for an Authenticate */ -#define UPAPSS_OPEN 4 /* We've sent an Ack */ -#define UPAPSS_BADAUTH 5 /* We've sent a Nak */ - - -/* - * Timeouts. - */ -#if 0 /* moved to ppp_opts.h */ -#define UPAP_DEFTIMEOUT 3 /* Timeout (seconds) for retransmitting req */ -#define UPAP_DEFREQTIME 30 /* Time to wait for auth-req from peer */ -#endif /* moved to ppp_opts.h */ - -/* - * Each interface is described by upap structure. - */ -#if PAP_SUPPORT -typedef struct upap_state { - const char *us_user; /* User */ - u8_t us_userlen; /* User length */ - const char *us_passwd; /* Password */ - u8_t us_passwdlen; /* Password length */ - u8_t us_clientstate; /* Client state */ -#if PPP_SERVER - u8_t us_serverstate; /* Server state */ -#endif /* PPP_SERVER */ - u8_t us_id; /* Current id */ - u8_t us_transmits; /* Number of auth-reqs sent */ -} upap_state; -#endif /* PAP_SUPPORT */ - - -void upap_authwithpeer(ppp_pcb *pcb, const char *user, const char *password); -#if PPP_SERVER -void upap_authpeer(ppp_pcb *pcb); -#endif /* PPP_SERVER */ - -extern const struct protent pap_protent; - -#ifdef __cplusplus -} -#endif - -#endif /* UPAP_H */ -#endif /* PPP_SUPPORT && PAP_SUPPORT */ +/* + * upap.h - User/Password Authentication Protocol definitions. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: upap.h,v 1.8 2002/12/04 23:03:33 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef UPAP_H +#define UPAP_H + +#include "ppp.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * Packet header = Code, id, length. + */ +#define UPAP_HEADERLEN 4 + + +/* + * UPAP codes. + */ +#define UPAP_AUTHREQ 1 /* Authenticate-Request */ +#define UPAP_AUTHACK 2 /* Authenticate-Ack */ +#define UPAP_AUTHNAK 3 /* Authenticate-Nak */ + + +/* + * Client states. + */ +#define UPAPCS_INITIAL 0 /* Connection down */ +#define UPAPCS_CLOSED 1 /* Connection up, haven't requested auth */ +#define UPAPCS_PENDING 2 /* Connection down, have requested auth */ +#define UPAPCS_AUTHREQ 3 /* We've sent an Authenticate-Request */ +#define UPAPCS_OPEN 4 /* We've received an Ack */ +#define UPAPCS_BADAUTH 5 /* We've received a Nak */ + +/* + * Server states. + */ +#define UPAPSS_INITIAL 0 /* Connection down */ +#define UPAPSS_CLOSED 1 /* Connection up, haven't requested auth */ +#define UPAPSS_PENDING 2 /* Connection down, have requested auth */ +#define UPAPSS_LISTEN 3 /* Listening for an Authenticate */ +#define UPAPSS_OPEN 4 /* We've sent an Ack */ +#define UPAPSS_BADAUTH 5 /* We've sent a Nak */ + + +/* + * Timeouts. + */ +#if 0 /* moved to ppp_opts.h */ +#define UPAP_DEFTIMEOUT 3 /* Timeout (seconds) for retransmitting req */ +#define UPAP_DEFREQTIME 30 /* Time to wait for auth-req from peer */ +#endif /* moved to ppp_opts.h */ + +/* + * Each interface is described by upap structure. + */ +#if PAP_SUPPORT +typedef struct upap_state { + const char *us_user; /* User */ + u8_t us_userlen; /* User length */ + const char *us_passwd; /* Password */ + u8_t us_passwdlen; /* Password length */ + u8_t us_clientstate; /* Client state */ +#if PPP_SERVER + u8_t us_serverstate; /* Server state */ +#endif /* PPP_SERVER */ + u8_t us_id; /* Current id */ + u8_t us_transmits; /* Number of auth-reqs sent */ +} upap_state; +#endif /* PAP_SUPPORT */ + + +void upap_authwithpeer(ppp_pcb *pcb, const char *user, const char *password); +#if PPP_SERVER +void upap_authpeer(ppp_pcb *pcb); +#endif /* PPP_SERVER */ + +extern const struct protent pap_protent; + +#ifdef __cplusplus +} +#endif + +#endif /* UPAP_H */ +#endif /* PPP_SUPPORT && PAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/vj.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/vj.h index 1d91f259..77d9976c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/vj.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/ppp/vj.h @@ -1,169 +1,169 @@ -/* - * Definitions for tcp compression routines. - * - * $Id: vj.h,v 1.7 2010/02/22 17:52:09 goldsimon Exp $ - * - * Copyright (c) 1989 Regents of the University of California. - * All rights reserved. - * - * Redistribution and use in source and binary forms are permitted - * provided that the above copyright notice and this paragraph are - * duplicated in all such forms and that any documentation, - * advertising materials, and other materials related to such - * distribution and use acknowledge that the software was developed - * by the University of California, Berkeley. The name of the - * University may not be used to endorse or promote products derived - * from this software without specific prior written permission. - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. - * - * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: - * - Initial distribution. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && VJ_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#ifndef VJ_H -#define VJ_H - -#include "lwip/ip.h" -#include "lwip/priv/tcp_priv.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define MAX_SLOTS 16 /* must be > 2 and < 256 */ -#define MAX_HDR 128 - -/* - * Compressed packet format: - * - * The first octet contains the packet type (top 3 bits), TCP - * 'push' bit, and flags that indicate which of the 4 TCP sequence - * numbers have changed (bottom 5 bits). The next octet is a - * conversation number that associates a saved IP/TCP header with - * the compressed packet. The next two octets are the TCP checksum - * from the original datagram. The next 0 to 15 octets are - * sequence number changes, one change per bit set in the header - * (there may be no changes and there are two special cases where - * the receiver implicitly knows what changed -- see below). - * - * There are 5 numbers which can change (they are always inserted - * in the following order): TCP urgent pointer, window, - * acknowlegement, sequence number and IP ID. (The urgent pointer - * is different from the others in that its value is sent, not the - * change in value.) Since typical use of SLIP links is biased - * toward small packets (see comments on MTU/MSS below), changes - * use a variable length coding with one octet for numbers in the - * range 1 - 255 and 3 octets (0, MSB, LSB) for numbers in the - * range 256 - 65535 or 0. (If the change in sequence number or - * ack is more than 65535, an uncompressed packet is sent.) - */ - -/* - * Packet types (must not conflict with IP protocol version) - * - * The top nibble of the first octet is the packet type. There are - * three possible types: IP (not proto TCP or tcp with one of the - * control flags set); uncompressed TCP (a normal IP/TCP packet but - * with the 8-bit protocol field replaced by an 8-bit connection id -- - * this type of packet syncs the sender & receiver); and compressed - * TCP (described above). - * - * LSB of 4-bit field is TCP "PUSH" bit (a worthless anachronism) and - * is logically part of the 4-bit "changes" field that follows. Top - * three bits are actual packet type. For backward compatibility - * and in the interest of conserving bits, numbers are chosen so the - * IP protocol version number (4) which normally appears in this nibble - * means "IP packet". - */ - -/* packet types */ -#define TYPE_IP 0x40 -#define TYPE_UNCOMPRESSED_TCP 0x70 -#define TYPE_COMPRESSED_TCP 0x80 -#define TYPE_ERROR 0x00 - -/* Bits in first octet of compressed packet */ -#define NEW_C 0x40 /* flag bits for what changed in a packet */ -#define NEW_I 0x20 -#define NEW_S 0x08 -#define NEW_A 0x04 -#define NEW_W 0x02 -#define NEW_U 0x01 - -/* reserved, special-case values of above */ -#define SPECIAL_I (NEW_S|NEW_W|NEW_U) /* echoed interactive traffic */ -#define SPECIAL_D (NEW_S|NEW_A|NEW_W|NEW_U) /* unidirectional data */ -#define SPECIALS_MASK (NEW_S|NEW_A|NEW_W|NEW_U) - -#define TCP_PUSH_BIT 0x10 - - -/* - * "state" data for each active tcp conversation on the wire. This is - * basically a copy of the entire IP/TCP header from the last packet - * we saw from the conversation together with a small identifier - * the transmit & receive ends of the line use to locate saved header. - */ -struct cstate { - struct cstate *cs_next; /* next most recently used state (xmit only) */ - u16_t cs_hlen; /* size of hdr (receive only) */ - u8_t cs_id; /* connection # associated with this state */ - u8_t cs_filler; - union { - char csu_hdr[MAX_HDR]; - struct ip_hdr csu_ip; /* ip/tcp hdr from most recent packet */ - } vjcs_u; -}; -#define cs_ip vjcs_u.csu_ip -#define cs_hdr vjcs_u.csu_hdr - - -struct vjstat { - u32_t vjs_packets; /* outbound packets */ - u32_t vjs_compressed; /* outbound compressed packets */ - u32_t vjs_searches; /* searches for connection state */ - u32_t vjs_misses; /* times couldn't find conn. state */ - u32_t vjs_uncompressedin; /* inbound uncompressed packets */ - u32_t vjs_compressedin; /* inbound compressed packets */ - u32_t vjs_errorin; /* inbound unknown type packets */ - u32_t vjs_tossed; /* inbound packets tossed because of error */ -}; - -/* - * all the state data for one serial line (we need one of these per line). - */ -struct vjcompress { - struct cstate *last_cs; /* most recently used tstate */ - u8_t last_recv; /* last rcvd conn. id */ - u8_t last_xmit; /* last sent conn. id */ - u16_t flags; - u8_t maxSlotIndex; - u8_t compressSlot; /* Flag indicating OK to compress slot ID. */ -#if LINK_STATS - struct vjstat stats; -#endif - struct cstate tstate[MAX_SLOTS]; /* xmit connection states */ - struct cstate rstate[MAX_SLOTS]; /* receive connection states */ -}; - -/* flag values */ -#define VJF_TOSS 1U /* tossing rcvd frames because of input err */ - -extern void vj_compress_init (struct vjcompress *comp); -extern u8_t vj_compress_tcp (struct vjcompress *comp, struct pbuf **pb); -extern void vj_uncompress_err (struct vjcompress *comp); -extern int vj_uncompress_uncomp(struct pbuf *nb, struct vjcompress *comp); -extern int vj_uncompress_tcp (struct pbuf **nb, struct vjcompress *comp); - -#ifdef __cplusplus -} -#endif - -#endif /* VJ_H */ - -#endif /* PPP_SUPPORT && VJ_SUPPORT */ +/* + * Definitions for tcp compression routines. + * + * $Id: vj.h,v 1.7 2010/02/22 17:52:09 goldsimon Exp $ + * + * Copyright (c) 1989 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: + * - Initial distribution. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && VJ_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#ifndef VJ_H +#define VJ_H + +#include "lwip/ip.h" +#include "lwip/priv/tcp_priv.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define MAX_SLOTS 16 /* must be > 2 and < 256 */ +#define MAX_HDR 128 + +/* + * Compressed packet format: + * + * The first octet contains the packet type (top 3 bits), TCP + * 'push' bit, and flags that indicate which of the 4 TCP sequence + * numbers have changed (bottom 5 bits). The next octet is a + * conversation number that associates a saved IP/TCP header with + * the compressed packet. The next two octets are the TCP checksum + * from the original datagram. The next 0 to 15 octets are + * sequence number changes, one change per bit set in the header + * (there may be no changes and there are two special cases where + * the receiver implicitly knows what changed -- see below). + * + * There are 5 numbers which can change (they are always inserted + * in the following order): TCP urgent pointer, window, + * acknowlegement, sequence number and IP ID. (The urgent pointer + * is different from the others in that its value is sent, not the + * change in value.) Since typical use of SLIP links is biased + * toward small packets (see comments on MTU/MSS below), changes + * use a variable length coding with one octet for numbers in the + * range 1 - 255 and 3 octets (0, MSB, LSB) for numbers in the + * range 256 - 65535 or 0. (If the change in sequence number or + * ack is more than 65535, an uncompressed packet is sent.) + */ + +/* + * Packet types (must not conflict with IP protocol version) + * + * The top nibble of the first octet is the packet type. There are + * three possible types: IP (not proto TCP or tcp with one of the + * control flags set); uncompressed TCP (a normal IP/TCP packet but + * with the 8-bit protocol field replaced by an 8-bit connection id -- + * this type of packet syncs the sender & receiver); and compressed + * TCP (described above). + * + * LSB of 4-bit field is TCP "PUSH" bit (a worthless anachronism) and + * is logically part of the 4-bit "changes" field that follows. Top + * three bits are actual packet type. For backward compatibility + * and in the interest of conserving bits, numbers are chosen so the + * IP protocol version number (4) which normally appears in this nibble + * means "IP packet". + */ + +/* packet types */ +#define TYPE_IP 0x40 +#define TYPE_UNCOMPRESSED_TCP 0x70 +#define TYPE_COMPRESSED_TCP 0x80 +#define TYPE_ERROR 0x00 + +/* Bits in first octet of compressed packet */ +#define NEW_C 0x40 /* flag bits for what changed in a packet */ +#define NEW_I 0x20 +#define NEW_S 0x08 +#define NEW_A 0x04 +#define NEW_W 0x02 +#define NEW_U 0x01 + +/* reserved, special-case values of above */ +#define SPECIAL_I (NEW_S|NEW_W|NEW_U) /* echoed interactive traffic */ +#define SPECIAL_D (NEW_S|NEW_A|NEW_W|NEW_U) /* unidirectional data */ +#define SPECIALS_MASK (NEW_S|NEW_A|NEW_W|NEW_U) + +#define TCP_PUSH_BIT 0x10 + + +/* + * "state" data for each active tcp conversation on the wire. This is + * basically a copy of the entire IP/TCP header from the last packet + * we saw from the conversation together with a small identifier + * the transmit & receive ends of the line use to locate saved header. + */ +struct cstate { + struct cstate *cs_next; /* next most recently used state (xmit only) */ + u16_t cs_hlen; /* size of hdr (receive only) */ + u8_t cs_id; /* connection # associated with this state */ + u8_t cs_filler; + union { + char csu_hdr[MAX_HDR]; + struct ip_hdr csu_ip; /* ip/tcp hdr from most recent packet */ + } vjcs_u; +}; +#define cs_ip vjcs_u.csu_ip +#define cs_hdr vjcs_u.csu_hdr + + +struct vjstat { + u32_t vjs_packets; /* outbound packets */ + u32_t vjs_compressed; /* outbound compressed packets */ + u32_t vjs_searches; /* searches for connection state */ + u32_t vjs_misses; /* times couldn't find conn. state */ + u32_t vjs_uncompressedin; /* inbound uncompressed packets */ + u32_t vjs_compressedin; /* inbound compressed packets */ + u32_t vjs_errorin; /* inbound unknown type packets */ + u32_t vjs_tossed; /* inbound packets tossed because of error */ +}; + +/* + * all the state data for one serial line (we need one of these per line). + */ +struct vjcompress { + struct cstate *last_cs; /* most recently used tstate */ + u8_t last_recv; /* last rcvd conn. id */ + u8_t last_xmit; /* last sent conn. id */ + u16_t flags; + u8_t maxSlotIndex; + u8_t compressSlot; /* Flag indicating OK to compress slot ID. */ +#if LINK_STATS + struct vjstat stats; +#endif + struct cstate tstate[MAX_SLOTS]; /* xmit connection states */ + struct cstate rstate[MAX_SLOTS]; /* receive connection states */ +}; + +/* flag values */ +#define VJF_TOSS 1U /* tossing rcvd frames because of input err */ + +extern void vj_compress_init (struct vjcompress *comp); +extern u8_t vj_compress_tcp (struct vjcompress *comp, struct pbuf **pb); +extern void vj_uncompress_err (struct vjcompress *comp); +extern int vj_uncompress_uncomp(struct pbuf *nb, struct vjcompress *comp); +extern int vj_uncompress_tcp (struct pbuf **nb, struct vjcompress *comp); + +#ifdef __cplusplus +} +#endif + +#endif /* VJ_H */ + +#endif /* PPP_SUPPORT && VJ_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/slipif.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/slipif.h index 4e68c941..65ba31f8 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/slipif.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/slipif.h @@ -1,87 +1,87 @@ -/** - * @file - * - * SLIP netif API - */ - -/* - * Copyright (c) 2001, Swedish Institute of Computer Science. - * 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 Institute 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 INSTITUTE 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 INSTITUTE 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ -#ifndef LWIP_HDR_NETIF_SLIPIF_H -#define LWIP_HDR_NETIF_SLIPIF_H - -#include "lwip/opt.h" -#include "lwip/netif.h" - -/** Set this to 1 to start a thread that blocks reading on the serial line - * (using sio_read()). - */ -#ifndef SLIP_USE_RX_THREAD -#define SLIP_USE_RX_THREAD !NO_SYS -#endif - -/** Set this to 1 to enable functions to pass in RX bytes from ISR context. - * If enabled, slipif_received_byte[s]() process incoming bytes and put assembled - * packets on a queue, which is fed into lwIP from slipif_poll(). - * If disabled, slipif_poll() polls the serial line (using sio_tryread()). - */ -#ifndef SLIP_RX_FROM_ISR -#define SLIP_RX_FROM_ISR 0 -#endif - -/** Set this to 1 (default for SLIP_RX_FROM_ISR) to queue incoming packets - * received by slipif_received_byte[s]() as long as PBUF_POOL pbufs are available. - * If disabled, packets will be dropped if more than one packet is received. - */ -#ifndef SLIP_RX_QUEUE -#define SLIP_RX_QUEUE SLIP_RX_FROM_ISR -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -err_t slipif_init(struct netif * netif); -void slipif_poll(struct netif *netif); -#if SLIP_RX_FROM_ISR -void slipif_process_rxqueue(struct netif *netif); -void slipif_received_byte(struct netif *netif, u8_t data); -void slipif_received_bytes(struct netif *netif, u8_t *data, u8_t len); -#endif /* SLIP_RX_FROM_ISR */ - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_HDR_NETIF_SLIPIF_H */ - +/** + * @file + * + * SLIP netif API + */ + +/* + * Copyright (c) 2001, Swedish Institute of Computer Science. + * 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 Institute 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 INSTITUTE 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 INSTITUTE 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Adam Dunkels + * + */ +#ifndef LWIP_HDR_NETIF_SLIPIF_H +#define LWIP_HDR_NETIF_SLIPIF_H + +#include "lwip/opt.h" +#include "lwip/netif.h" + +/** Set this to 1 to start a thread that blocks reading on the serial line + * (using sio_read()). + */ +#ifndef SLIP_USE_RX_THREAD +#define SLIP_USE_RX_THREAD !NO_SYS +#endif + +/** Set this to 1 to enable functions to pass in RX bytes from ISR context. + * If enabled, slipif_received_byte[s]() process incoming bytes and put assembled + * packets on a queue, which is fed into lwIP from slipif_poll(). + * If disabled, slipif_poll() polls the serial line (using sio_tryread()). + */ +#ifndef SLIP_RX_FROM_ISR +#define SLIP_RX_FROM_ISR 0 +#endif + +/** Set this to 1 (default for SLIP_RX_FROM_ISR) to queue incoming packets + * received by slipif_received_byte[s]() as long as PBUF_POOL pbufs are available. + * If disabled, packets will be dropped if more than one packet is received. + */ +#ifndef SLIP_RX_QUEUE +#define SLIP_RX_QUEUE SLIP_RX_FROM_ISR +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +err_t slipif_init(struct netif * netif); +void slipif_poll(struct netif *netif); +#if SLIP_RX_FROM_ISR +void slipif_process_rxqueue(struct netif *netif); +void slipif_received_byte(struct netif *netif, u8_t data); +void slipif_received_bytes(struct netif *netif, u8_t *data, u8_t len); +#endif /* SLIP_RX_FROM_ISR */ + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_HDR_NETIF_SLIPIF_H */ + diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/zepif.h b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/zepif.h index 059c8b0a..2a801b4c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/zepif.h +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/include/netif/zepif.h @@ -1,81 +1,81 @@ -/** - * @file - * - * A netif implementing the ZigBee Eencapsulation Protocol (ZEP). - * This is used to tunnel 6LowPAN over UDP. - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#ifndef LWIP_HDR_ZEPIF_H -#define LWIP_HDR_ZEPIF_H - -#include "lwip/opt.h" -#include "netif/lowpan6.h" - -#if LWIP_IPV6 && LWIP_UDP /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/netif.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#define ZEPIF_DEFAULT_UDP_PORT 17754 - -/** Pass this struct as 'state' to netif_add to control the behaviour - * of this netif. If NULL is passed, default behaviour is chosen */ -struct zepif_init { - /** The UDP port used to ZEP frames from (0 = default) */ - u16_t zep_src_udp_port; - /** The UDP port used to ZEP frames to (0 = default) */ - u16_t zep_dst_udp_port; - /** The IP address to sed ZEP frames from (NULL = ANY) */ - const ip_addr_t *zep_src_ip_addr; - /** The IP address to sed ZEP frames to (NULL = BROADCAST) */ - const ip_addr_t *zep_dst_ip_addr; - /** If != NULL, the udp pcb is bound to this netif */ - const struct netif *zep_netif; - /** MAC address of the 6LowPAN device */ - u8_t addr[6]; -}; - -err_t zepif_init(struct netif *netif); - -#ifdef __cplusplus -} -#endif - -#endif /* LWIP_IPV6 && LWIP_UDP */ - -#endif /* LWIP_HDR_ZEPIF_H */ +/** + * @file + * + * A netif implementing the ZigBee Eencapsulation Protocol (ZEP). + * This is used to tunnel 6LowPAN over UDP. + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#ifndef LWIP_HDR_ZEPIF_H +#define LWIP_HDR_ZEPIF_H + +#include "lwip/opt.h" +#include "netif/lowpan6.h" + +#if LWIP_IPV6 && LWIP_UDP /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/netif.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZEPIF_DEFAULT_UDP_PORT 17754 + +/** Pass this struct as 'state' to netif_add to control the behaviour + * of this netif. If NULL is passed, default behaviour is chosen */ +struct zepif_init { + /** The UDP port used to ZEP frames from (0 = default) */ + u16_t zep_src_udp_port; + /** The UDP port used to ZEP frames to (0 = default) */ + u16_t zep_dst_udp_port; + /** The IP address to sed ZEP frames from (NULL = ANY) */ + const ip_addr_t *zep_src_ip_addr; + /** The IP address to sed ZEP frames to (NULL = BROADCAST) */ + const ip_addr_t *zep_dst_ip_addr; + /** If != NULL, the udp pcb is bound to this netif */ + const struct netif *zep_netif; + /** MAC address of the 6LowPAN device */ + u8_t addr[6]; +}; + +err_t zepif_init(struct netif *netif); + +#ifdef __cplusplus +} +#endif + +#endif /* LWIP_IPV6 && LWIP_UDP */ + +#endif /* LWIP_HDR_ZEPIF_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/FILES b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/FILES index 1c193c08..1ffd6f2d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/FILES +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/FILES @@ -1,23 +1,23 @@ -This directory contains generic network interface device drivers that -do not contain any hardware or architecture specific code. The files -are: - -ethernet.c - Shared code for Ethernet based interfaces. - -lowpan6.c - A 6LoWPAN implementation as a netif. - -lowpan6_ble.c - A 6LoWPAN over Bluetooth Low Energy (BLE) implementation as netif, - according to RFC-7668. - -slipif.c - A generic implementation of the SLIP (Serial Line IP) - protocol. It requires a sio (serial I/O) module to work. - -ppp/ Point-to-Point Protocol stack - The lwIP PPP support is based from pppd (http://ppp.samba.org) with - huge changes to match code size and memory requirements for embedded - devices. Please read /doc/ppp.txt and ppp/PPPD_FOLLOWUP for a detailed - explanation. +This directory contains generic network interface device drivers that +do not contain any hardware or architecture specific code. The files +are: + +ethernet.c + Shared code for Ethernet based interfaces. + +lowpan6.c + A 6LoWPAN implementation as a netif. + +lowpan6_ble.c + A 6LoWPAN over Bluetooth Low Energy (BLE) implementation as netif, + according to RFC-7668. + +slipif.c + A generic implementation of the SLIP (Serial Line IP) + protocol. It requires a sio (serial I/O) module to work. + +ppp/ Point-to-Point Protocol stack + The lwIP PPP support is based from pppd (http://ppp.samba.org) with + huge changes to match code size and memory requirements for embedded + devices. Please read /doc/ppp.txt and ppp/PPPD_FOLLOWUP for a detailed + explanation. diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif.c index 1cdda12b..8a97bce3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif.c @@ -1,563 +1,563 @@ -/** - * @file - * lwIP netif implementing an IEEE 802.1D MAC Bridge - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -/** - * @defgroup bridgeif IEEE 802.1D bridge - * @ingroup netifs - * This file implements an IEEE 802.1D bridge by using a multilayer netif approach - * (one hardware-independent netif for the bridge that uses hardware netifs for its ports). - * On transmit, the bridge selects the outgoing port(s). - * On receive, the port netif calls into the bridge (via its netif->input function) and - * the bridge selects the port(s) (and/or its netif->input function) to pass the received pbuf to. - * - * Usage: - * - add the port netifs just like you would when using them as dedicated netif without a bridge - * - only NETIF_FLAG_ETHARP/NETIF_FLAG_ETHERNET netifs are supported as bridge ports - * - add the bridge port netifs without IPv4 addresses (i.e. pass 'NULL, NULL, NULL') - * - don't add IPv6 addresses to the port netifs! - * - set up the bridge configuration in a global variable of type 'bridgeif_initdata_t' that contains - * - the MAC address of the bridge - * - some configuration options controlling the memory consumption (maximum number of ports - * and FDB entries) - * - e.g. for a bridge MAC address 00-01-02-03-04-05, 2 bridge ports, 1024 FDB entries + 16 static MAC entries: - * bridgeif_initdata_t mybridge_initdata = BRIDGEIF_INITDATA1(2, 1024, 16, ETH_ADDR(0, 1, 2, 3, 4, 5)); - * - add the bridge netif (with IPv4 config): - * struct netif bridge_netif; - * netif_add(&bridge_netif, &my_ip, &my_netmask, &my_gw, &mybridge_initdata, bridgeif_init, tcpip_input); - * NOTE: the passed 'input' function depends on BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT setting, - * which controls where the forwarding is done (netif low level input context vs. tcpip_thread) - * - set up all ports netifs and the bridge netif - * - * - When adding a port netif, NETIF_FLAG_ETHARP flag will be removed from a port - * to prevent ETHARP working on that port netif (we only want one IP per bridge not per port). - * - When adding a port netif, its input function is changed to call into the bridge. - * - * - * @todo: - * - compact static FDB entries (instead of walking the whole array) - * - add FDB query/read access - * - add FDB change callback (when learning or dropping auto-learned entries) - * - prefill FDB with MAC classes that should never be forwarded - * - multicast snooping? (and only forward group addresses to interested ports) - * - support removing ports - * - check SNMP integration - * - VLAN handling / trunk ports - * - priority handling? (although that largely depends on TX queue limitations and lwIP doesn't provide tx-done handling) - */ - -#include "netif/bridgeif.h" -#include "lwip/netif.h" -#include "lwip/sys.h" -#include "lwip/etharp.h" -#include "lwip/ethip6.h" -#include "lwip/snmp.h" -#include "lwip/timeouts.h" -#include - -#if LWIP_NUM_NETIF_CLIENT_DATA - -/* Define those to better describe your network interface. */ -#define IFNAME0 'b' -#define IFNAME1 'r' - -struct bridgeif_private_s; -typedef struct bridgeif_port_private_s { - struct bridgeif_private_s *bridge; - struct netif *port_netif; - u8_t port_num; -} bridgeif_port_t; - -typedef struct bridgeif_fdb_static_entry_s { - u8_t used; - bridgeif_portmask_t dst_ports; - struct eth_addr addr; -} bridgeif_fdb_static_entry_t; - -typedef struct bridgeif_private_s { - struct netif *netif; - struct eth_addr ethaddr; - u8_t max_ports; - u8_t num_ports; - bridgeif_port_t *ports; - u16_t max_fdbs_entries; - bridgeif_fdb_static_entry_t *fdbs; - u16_t max_fdbd_entries; - void *fdbd; -} bridgeif_private_t; - -/* netif data index to get the bridge on input */ -u8_t bridgeif_netif_client_id = 0xff; - -/** - * @ingroup bridgeif - * Add a static entry to the forwarding database. - * A static entry marks where frames to a specific eth address (unicast or group address) are - * forwarded. - * bits [0..(BRIDGEIF_MAX_PORTS-1)]: hw ports - * bit [BRIDGEIF_MAX_PORTS]: cpu port - * 0: drop - */ -err_t -bridgeif_fdb_add(struct netif *bridgeif, const struct eth_addr *addr, bridgeif_portmask_t ports) -{ - int i; - bridgeif_private_t *br; - BRIDGEIF_DECL_PROTECT(lev); - LWIP_ASSERT("invalid netif", bridgeif != NULL); - br = (bridgeif_private_t *)bridgeif->state; - LWIP_ASSERT("invalid state", br != NULL); - - BRIDGEIF_READ_PROTECT(lev); - for (i = 0; i < br->max_fdbs_entries; i++) { - if (!br->fdbs[i].used) { - BRIDGEIF_WRITE_PROTECT(lev); - if (!br->fdbs[i].used) { - br->fdbs[i].used = 1; - br->fdbs[i].dst_ports = ports; - memcpy(&br->fdbs[i].addr, addr, sizeof(struct eth_addr)); - BRIDGEIF_WRITE_UNPROTECT(lev); - BRIDGEIF_READ_UNPROTECT(lev); - return ERR_OK; - } - BRIDGEIF_WRITE_UNPROTECT(lev); - } - } - BRIDGEIF_READ_UNPROTECT(lev); - return ERR_MEM; -} - -/** - * @ingroup bridgeif - * Remove a static entry from the forwarding database - */ -err_t -bridgeif_fdb_remove(struct netif *bridgeif, const struct eth_addr *addr) -{ - int i; - bridgeif_private_t *br; - BRIDGEIF_DECL_PROTECT(lev); - LWIP_ASSERT("invalid netif", bridgeif != NULL); - br = (bridgeif_private_t *)bridgeif->state; - LWIP_ASSERT("invalid state", br != NULL); - - BRIDGEIF_READ_PROTECT(lev); - for (i = 0; i < br->max_fdbs_entries; i++) { - if (br->fdbs[i].used && !memcmp(&br->fdbs[i].addr, addr, sizeof(struct eth_addr))) { - BRIDGEIF_WRITE_PROTECT(lev); - if (br->fdbs[i].used && !memcmp(&br->fdbs[i].addr, addr, sizeof(struct eth_addr))) { - memset(&br->fdbs[i], 0, sizeof(bridgeif_fdb_static_entry_t)); - BRIDGEIF_WRITE_UNPROTECT(lev); - BRIDGEIF_READ_UNPROTECT(lev); - return ERR_OK; - } - BRIDGEIF_WRITE_UNPROTECT(lev); - } - } - BRIDGEIF_READ_UNPROTECT(lev); - return ERR_VAL; -} - -/** Get the forwarding port(s) (as bit mask) for the specified destination mac address */ -static bridgeif_portmask_t -bridgeif_find_dst_ports(bridgeif_private_t *br, struct eth_addr *dst_addr) -{ - int i; - BRIDGEIF_DECL_PROTECT(lev); - BRIDGEIF_READ_PROTECT(lev); - /* first check for static entries */ - for (i = 0; i < br->max_fdbs_entries; i++) { - if (br->fdbs[i].used) { - if (!memcmp(&br->fdbs[i].addr, dst_addr, sizeof(struct eth_addr))) { - bridgeif_portmask_t ret = br->fdbs[i].dst_ports; - BRIDGEIF_READ_UNPROTECT(lev); - return ret; - } - } - } - if (dst_addr->addr[0] & 1) { - /* no match found: flood remaining group address */ - BRIDGEIF_READ_UNPROTECT(lev); - return BR_FLOOD; - } - BRIDGEIF_READ_UNPROTECT(lev); - /* no match found: check dynamic fdb for port or fall back to flooding */ - return bridgeif_fdb_get_dst_ports(br->fdbd, dst_addr); -} - -/** Helper function to see if a destination mac belongs to the bridge - * (bridge netif or one of the port netifs), in which case the frame - * is sent to the cpu only. - */ -static int -bridgeif_is_local_mac(bridgeif_private_t *br, struct eth_addr *addr) -{ - int i; - BRIDGEIF_DECL_PROTECT(lev); - if (!memcmp(br->netif->hwaddr, addr, sizeof(struct eth_addr))) { - return 1; - } - BRIDGEIF_READ_PROTECT(lev); - for (i = 0; i < br->num_ports; i++) { - struct netif *portif = br->ports[i].port_netif; - if (portif != NULL) { - if (!memcmp(portif->hwaddr, addr, sizeof(struct eth_addr))) { - BRIDGEIF_READ_UNPROTECT(lev); - return 1; - } - } - } - BRIDGEIF_READ_UNPROTECT(lev); - return 0; -} - -/* Output helper function */ -static err_t -bridgeif_send_to_port(bridgeif_private_t *br, struct pbuf *p, u8_t dstport_idx) -{ - if (dstport_idx < BRIDGEIF_MAX_PORTS) { - /* possibly an external port */ - if (dstport_idx < br->max_ports) { - struct netif *portif = br->ports[dstport_idx].port_netif; - if ((portif != NULL) && (portif->linkoutput != NULL)) { - /* prevent sending out to rx port */ - if (netif_get_index(portif) != p->if_idx) { - if (netif_is_link_up(portif)) { - LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> flood(%p:%d) -> %d\n", (void *)p, p->if_idx, netif_get_index(portif))); - return portif->linkoutput(portif, p); - } - } - } - } - } else { - LWIP_ASSERT("invalid port index", dstport_idx == BRIDGEIF_MAX_PORTS); - } - return ERR_OK; -} - -/** Helper function to pass a pbuf to all ports marked in 'dstports' - */ -static err_t -bridgeif_send_to_ports(bridgeif_private_t *br, struct pbuf *p, bridgeif_portmask_t dstports) -{ - err_t err, ret_err = ERR_OK; - u8_t i; - bridgeif_portmask_t mask = 1; - BRIDGEIF_DECL_PROTECT(lev); - BRIDGEIF_READ_PROTECT(lev); - for (i = 0; i < BRIDGEIF_MAX_PORTS; i++, mask = (bridgeif_portmask_t)(mask << 1)) { - if (dstports & mask) { - err = bridgeif_send_to_port(br, p, i); - if (err != ERR_OK) { - ret_err = err; - } - } - } - BRIDGEIF_READ_UNPROTECT(lev); - return ret_err; -} - -/** Output function of the application port of the bridge (the one with an ip address). - * The forwarding port(s) where this pbuf is sent on is/are automatically selected - * from the FDB. - */ -static err_t -bridgeif_output(struct netif *netif, struct pbuf *p) -{ - err_t err; - bridgeif_private_t *br = (bridgeif_private_t *)netif->state; - struct eth_addr *dst = (struct eth_addr *)(p->payload); - - bridgeif_portmask_t dstports = bridgeif_find_dst_ports(br, dst); - err = bridgeif_send_to_ports(br, p, dstports); - - MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len); - if (((u8_t *)p->payload)[0] & 1) { - /* broadcast or multicast packet*/ - MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts); - } else { - /* unicast packet */ - MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); - } - /* increase ifoutdiscards or ifouterrors on error */ - - LINK_STATS_INC(link.xmit); - - return err; -} - -/** The actual bridge input function. Port netif's input is changed to call - * here. This function decides where the frame is forwarded. - */ -static err_t -bridgeif_input(struct pbuf *p, struct netif *netif) -{ - u8_t rx_idx; - bridgeif_portmask_t dstports; - struct eth_addr *src, *dst; - bridgeif_private_t *br; - bridgeif_port_t *port; - if (p == NULL || netif == NULL) { - return ERR_VAL; - } - port = (bridgeif_port_t *)netif_get_client_data(netif, bridgeif_netif_client_id); - LWIP_ASSERT("port data not set", port != NULL); - if (port == NULL || port->bridge == NULL) { - return ERR_VAL; - } - br = (bridgeif_private_t *)port->bridge; - rx_idx = netif_get_index(netif); - /* store receive index in pbuf */ - p->if_idx = rx_idx; - - dst = (struct eth_addr *)p->payload; - src = (struct eth_addr *)(((u8_t *)p->payload) + sizeof(struct eth_addr)); - - if ((src->addr[0] & 1) == 0) { - /* update src for all non-group addresses */ - bridgeif_fdb_update_src(br->fdbd, src, port->port_num); - } - - if (dst->addr[0] & 1) { - /* group address -> flood + cpu? */ - dstports = bridgeif_find_dst_ports(br, dst); - bridgeif_send_to_ports(br, p, dstports); - if (dstports & (1 << BRIDGEIF_MAX_PORTS)) { - /* we pass the reference to ->input or have to free it */ - LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> input(%p)\n", (void *)p)); - if (br->netif->input(p, br->netif) != ERR_OK) { - pbuf_free(p); - } - } else { - /* all references done */ - pbuf_free(p); - } - /* always return ERR_OK here to prevent the caller freeing the pbuf */ - return ERR_OK; - } else { - /* is this for one of the local ports? */ - if (bridgeif_is_local_mac(br, dst)) { - /* yes, send to cpu port only */ - LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> input(%p)\n", (void *)p)); - return br->netif->input(p, br->netif); - } - - /* get dst port */ - dstports = bridgeif_find_dst_ports(br, dst); - bridgeif_send_to_ports(br, p, dstports); - /* no need to send to cpu, flooding is for external ports only */ - /* by this, we consumed the pbuf */ - pbuf_free(p); - /* always return ERR_OK here to prevent the caller freeing the pbuf */ - return ERR_OK; - } -} - -#if !BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT -/** Input function for port netifs used to synchronize into tcpip_thread. - */ -static err_t -bridgeif_tcpip_input(struct pbuf *p, struct netif *netif) -{ - return tcpip_inpkt(p, netif, bridgeif_input); -} -#endif /* BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT */ - -/** - * @ingroup bridgeif - * Initialization function passed to netif_add(). - * - * ATTENTION: A pointer to a @ref bridgeif_initdata_t must be passed as 'state' - * to @ref netif_add when adding the bridge. I supplies MAC address - * and controls memory allocation (number of ports, FDB size). - * - * @param netif the lwip network interface structure for this ethernetif - * @return ERR_OK if the loopif is initialized - * ERR_MEM if private data couldn't be allocated - * any other err_t on error - */ -err_t -bridgeif_init(struct netif *netif) -{ - bridgeif_initdata_t *init_data; - bridgeif_private_t *br; - size_t alloc_len_sizet; - mem_size_t alloc_len; - - LWIP_ASSERT("netif != NULL", (netif != NULL)); - LWIP_ASSERT("bridgeif needs an input callback", (netif->input != NULL)); -#if !BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT - if (netif->input == tcpip_input) { - LWIP_DEBUGF(BRIDGEIF_DEBUG | LWIP_DBG_ON, ("bridgeif does not need tcpip_input, use netif_input/ethernet_input instead")); - } -#endif - - if (bridgeif_netif_client_id == 0xFF) { - bridgeif_netif_client_id = netif_alloc_client_data_id(); - } - - init_data = (bridgeif_initdata_t *)netif->state; - LWIP_ASSERT("init_data != NULL", (init_data != NULL)); - LWIP_ASSERT("init_data->max_ports <= BRIDGEIF_MAX_PORTS", - init_data->max_ports <= BRIDGEIF_MAX_PORTS); - - alloc_len_sizet = sizeof(bridgeif_private_t) + (init_data->max_ports * sizeof(bridgeif_port_t) + (init_data->max_fdb_static_entries * sizeof(bridgeif_fdb_static_entry_t))); - alloc_len = (mem_size_t)alloc_len_sizet; - LWIP_ASSERT("alloc_len == alloc_len_sizet", alloc_len == alloc_len_sizet); - LWIP_DEBUGF(BRIDGEIF_DEBUG, ("bridgeif_init: allocating %d bytes for private data\n", (int)alloc_len)); - br = (bridgeif_private_t *)mem_calloc(1, alloc_len); - if (br == NULL) { - LWIP_DEBUGF(NETIF_DEBUG, ("bridgeif_init: out of memory\n")); - return ERR_MEM; - } - memcpy(&br->ethaddr, &init_data->ethaddr, sizeof(br->ethaddr)); - br->netif = netif; - - br->max_ports = init_data->max_ports; - br->ports = (bridgeif_port_t *)(br + 1); - - br->max_fdbs_entries = init_data->max_fdb_static_entries; - br->fdbs = (bridgeif_fdb_static_entry_t *)(((u8_t *)(br + 1)) + (init_data->max_ports * sizeof(bridgeif_port_t))); - - br->max_fdbd_entries = init_data->max_fdb_dynamic_entries; - br->fdbd = bridgeif_fdb_init(init_data->max_fdb_dynamic_entries); - if (br->fdbd == NULL) { - LWIP_DEBUGF(NETIF_DEBUG, ("bridgeif_init: out of memory in fdb_init\n")); - mem_free(br); - return ERR_MEM; - } - -#if LWIP_NETIF_HOSTNAME - /* Initialize interface hostname */ - netif->hostname = "lwip"; -#endif /* LWIP_NETIF_HOSTNAME */ - - /* - * Initialize the snmp variables and counters inside the struct netif. - * The last argument should be replaced with your link speed, in units - * of bits per second. - */ - MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, 0); - - netif->state = br; - netif->name[0] = IFNAME0; - netif->name[1] = IFNAME1; - /* We directly use etharp_output() here to save a function call. - * You can instead declare your own function an call etharp_output() - * from it if you have to do some checks before sending (e.g. if link - * is available...) */ -#if LWIP_IPV4 - netif->output = etharp_output; -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 - netif->output_ip6 = ethip6_output; -#endif /* LWIP_IPV6 */ - netif->linkoutput = bridgeif_output; - - /* set MAC hardware address length */ - netif->hwaddr_len = ETH_HWADDR_LEN; - - /* set MAC hardware address */ - memcpy(netif->hwaddr, &br->ethaddr, ETH_HWADDR_LEN); - - /* maximum transfer unit */ - netif->mtu = 1500; - - /* device capabilities */ - /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */ - netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP | NETIF_FLAG_MLD6 | NETIF_FLAG_LINK_UP; - -#if LWIP_IPV6 && LWIP_IPV6_MLD - /* - * For hardware/netifs that implement MAC filtering. - * All-nodes link-local is handled by default, so we must let the hardware know - * to allow multicast packets in. - * Should set mld_mac_filter previously. */ - if (netif->mld_mac_filter != NULL) { - ip6_addr_t ip6_allnodes_ll; - ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll); - netif->mld_mac_filter(netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER); - } -#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ - - return ERR_OK; -} - -/** - * @ingroup bridgeif - * Add a port to the bridge - */ -err_t -bridgeif_add_port(struct netif *bridgeif, struct netif *portif) -{ - bridgeif_private_t *br; - bridgeif_port_t *port; - - LWIP_ASSERT("bridgeif != NULL", bridgeif != NULL); - LWIP_ASSERT("bridgeif->state != NULL", bridgeif->state != NULL); - LWIP_ASSERT("portif != NULL", portif != NULL); - - if (!(portif->flags & NETIF_FLAG_ETHARP) || !(portif->flags & NETIF_FLAG_ETHERNET)) { - /* can only add ETHERNET/ETHARP interfaces */ - return ERR_VAL; - } - - br = (bridgeif_private_t *)bridgeif->state; - - if (br->num_ports >= br->max_ports) { - return ERR_VAL; - } - port = &br->ports[br->num_ports]; - port->port_netif = portif; - port->port_num = br->num_ports; - port->bridge = br; - br->num_ports++; - - /* let the port call us on input */ -#if BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT - portif->input = bridgeif_input; -#else - portif->input = bridgeif_tcpip_input; -#endif - /* store pointer to bridge in netif */ - netif_set_client_data(portif, bridgeif_netif_client_id, port); - /* remove ETHARP flag to prevent sending report events on netif-up */ - netif_clear_flags(portif, NETIF_FLAG_ETHARP); - - return ERR_OK; -} - -#endif /* LWIP_NUM_NETIF_CLIENT_DATA */ +/** + * @file + * lwIP netif implementing an IEEE 802.1D MAC Bridge + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +/** + * @defgroup bridgeif IEEE 802.1D bridge + * @ingroup netifs + * This file implements an IEEE 802.1D bridge by using a multilayer netif approach + * (one hardware-independent netif for the bridge that uses hardware netifs for its ports). + * On transmit, the bridge selects the outgoing port(s). + * On receive, the port netif calls into the bridge (via its netif->input function) and + * the bridge selects the port(s) (and/or its netif->input function) to pass the received pbuf to. + * + * Usage: + * - add the port netifs just like you would when using them as dedicated netif without a bridge + * - only NETIF_FLAG_ETHARP/NETIF_FLAG_ETHERNET netifs are supported as bridge ports + * - add the bridge port netifs without IPv4 addresses (i.e. pass 'NULL, NULL, NULL') + * - don't add IPv6 addresses to the port netifs! + * - set up the bridge configuration in a global variable of type 'bridgeif_initdata_t' that contains + * - the MAC address of the bridge + * - some configuration options controlling the memory consumption (maximum number of ports + * and FDB entries) + * - e.g. for a bridge MAC address 00-01-02-03-04-05, 2 bridge ports, 1024 FDB entries + 16 static MAC entries: + * bridgeif_initdata_t mybridge_initdata = BRIDGEIF_INITDATA1(2, 1024, 16, ETH_ADDR(0, 1, 2, 3, 4, 5)); + * - add the bridge netif (with IPv4 config): + * struct netif bridge_netif; + * netif_add(&bridge_netif, &my_ip, &my_netmask, &my_gw, &mybridge_initdata, bridgeif_init, tcpip_input); + * NOTE: the passed 'input' function depends on BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT setting, + * which controls where the forwarding is done (netif low level input context vs. tcpip_thread) + * - set up all ports netifs and the bridge netif + * + * - When adding a port netif, NETIF_FLAG_ETHARP flag will be removed from a port + * to prevent ETHARP working on that port netif (we only want one IP per bridge not per port). + * - When adding a port netif, its input function is changed to call into the bridge. + * + * + * @todo: + * - compact static FDB entries (instead of walking the whole array) + * - add FDB query/read access + * - add FDB change callback (when learning or dropping auto-learned entries) + * - prefill FDB with MAC classes that should never be forwarded + * - multicast snooping? (and only forward group addresses to interested ports) + * - support removing ports + * - check SNMP integration + * - VLAN handling / trunk ports + * - priority handling? (although that largely depends on TX queue limitations and lwIP doesn't provide tx-done handling) + */ + +#include "netif/bridgeif.h" +#include "lwip/netif.h" +#include "lwip/sys.h" +#include "lwip/etharp.h" +#include "lwip/ethip6.h" +#include "lwip/snmp.h" +#include "lwip/timeouts.h" +#include + +#if LWIP_NUM_NETIF_CLIENT_DATA + +/* Define those to better describe your network interface. */ +#define IFNAME0 'b' +#define IFNAME1 'r' + +struct bridgeif_private_s; +typedef struct bridgeif_port_private_s { + struct bridgeif_private_s *bridge; + struct netif *port_netif; + u8_t port_num; +} bridgeif_port_t; + +typedef struct bridgeif_fdb_static_entry_s { + u8_t used; + bridgeif_portmask_t dst_ports; + struct eth_addr addr; +} bridgeif_fdb_static_entry_t; + +typedef struct bridgeif_private_s { + struct netif *netif; + struct eth_addr ethaddr; + u8_t max_ports; + u8_t num_ports; + bridgeif_port_t *ports; + u16_t max_fdbs_entries; + bridgeif_fdb_static_entry_t *fdbs; + u16_t max_fdbd_entries; + void *fdbd; +} bridgeif_private_t; + +/* netif data index to get the bridge on input */ +u8_t bridgeif_netif_client_id = 0xff; + +/** + * @ingroup bridgeif + * Add a static entry to the forwarding database. + * A static entry marks where frames to a specific eth address (unicast or group address) are + * forwarded. + * bits [0..(BRIDGEIF_MAX_PORTS-1)]: hw ports + * bit [BRIDGEIF_MAX_PORTS]: cpu port + * 0: drop + */ +err_t +bridgeif_fdb_add(struct netif *bridgeif, const struct eth_addr *addr, bridgeif_portmask_t ports) +{ + int i; + bridgeif_private_t *br; + BRIDGEIF_DECL_PROTECT(lev); + LWIP_ASSERT("invalid netif", bridgeif != NULL); + br = (bridgeif_private_t *)bridgeif->state; + LWIP_ASSERT("invalid state", br != NULL); + + BRIDGEIF_READ_PROTECT(lev); + for (i = 0; i < br->max_fdbs_entries; i++) { + if (!br->fdbs[i].used) { + BRIDGEIF_WRITE_PROTECT(lev); + if (!br->fdbs[i].used) { + br->fdbs[i].used = 1; + br->fdbs[i].dst_ports = ports; + memcpy(&br->fdbs[i].addr, addr, sizeof(struct eth_addr)); + BRIDGEIF_WRITE_UNPROTECT(lev); + BRIDGEIF_READ_UNPROTECT(lev); + return ERR_OK; + } + BRIDGEIF_WRITE_UNPROTECT(lev); + } + } + BRIDGEIF_READ_UNPROTECT(lev); + return ERR_MEM; +} + +/** + * @ingroup bridgeif + * Remove a static entry from the forwarding database + */ +err_t +bridgeif_fdb_remove(struct netif *bridgeif, const struct eth_addr *addr) +{ + int i; + bridgeif_private_t *br; + BRIDGEIF_DECL_PROTECT(lev); + LWIP_ASSERT("invalid netif", bridgeif != NULL); + br = (bridgeif_private_t *)bridgeif->state; + LWIP_ASSERT("invalid state", br != NULL); + + BRIDGEIF_READ_PROTECT(lev); + for (i = 0; i < br->max_fdbs_entries; i++) { + if (br->fdbs[i].used && !memcmp(&br->fdbs[i].addr, addr, sizeof(struct eth_addr))) { + BRIDGEIF_WRITE_PROTECT(lev); + if (br->fdbs[i].used && !memcmp(&br->fdbs[i].addr, addr, sizeof(struct eth_addr))) { + memset(&br->fdbs[i], 0, sizeof(bridgeif_fdb_static_entry_t)); + BRIDGEIF_WRITE_UNPROTECT(lev); + BRIDGEIF_READ_UNPROTECT(lev); + return ERR_OK; + } + BRIDGEIF_WRITE_UNPROTECT(lev); + } + } + BRIDGEIF_READ_UNPROTECT(lev); + return ERR_VAL; +} + +/** Get the forwarding port(s) (as bit mask) for the specified destination mac address */ +static bridgeif_portmask_t +bridgeif_find_dst_ports(bridgeif_private_t *br, struct eth_addr *dst_addr) +{ + int i; + BRIDGEIF_DECL_PROTECT(lev); + BRIDGEIF_READ_PROTECT(lev); + /* first check for static entries */ + for (i = 0; i < br->max_fdbs_entries; i++) { + if (br->fdbs[i].used) { + if (!memcmp(&br->fdbs[i].addr, dst_addr, sizeof(struct eth_addr))) { + bridgeif_portmask_t ret = br->fdbs[i].dst_ports; + BRIDGEIF_READ_UNPROTECT(lev); + return ret; + } + } + } + if (dst_addr->addr[0] & 1) { + /* no match found: flood remaining group address */ + BRIDGEIF_READ_UNPROTECT(lev); + return BR_FLOOD; + } + BRIDGEIF_READ_UNPROTECT(lev); + /* no match found: check dynamic fdb for port or fall back to flooding */ + return bridgeif_fdb_get_dst_ports(br->fdbd, dst_addr); +} + +/** Helper function to see if a destination mac belongs to the bridge + * (bridge netif or one of the port netifs), in which case the frame + * is sent to the cpu only. + */ +static int +bridgeif_is_local_mac(bridgeif_private_t *br, struct eth_addr *addr) +{ + int i; + BRIDGEIF_DECL_PROTECT(lev); + if (!memcmp(br->netif->hwaddr, addr, sizeof(struct eth_addr))) { + return 1; + } + BRIDGEIF_READ_PROTECT(lev); + for (i = 0; i < br->num_ports; i++) { + struct netif *portif = br->ports[i].port_netif; + if (portif != NULL) { + if (!memcmp(portif->hwaddr, addr, sizeof(struct eth_addr))) { + BRIDGEIF_READ_UNPROTECT(lev); + return 1; + } + } + } + BRIDGEIF_READ_UNPROTECT(lev); + return 0; +} + +/* Output helper function */ +static err_t +bridgeif_send_to_port(bridgeif_private_t *br, struct pbuf *p, u8_t dstport_idx) +{ + if (dstport_idx < BRIDGEIF_MAX_PORTS) { + /* possibly an external port */ + if (dstport_idx < br->max_ports) { + struct netif *portif = br->ports[dstport_idx].port_netif; + if ((portif != NULL) && (portif->linkoutput != NULL)) { + /* prevent sending out to rx port */ + if (netif_get_index(portif) != p->if_idx) { + if (netif_is_link_up(portif)) { + LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> flood(%p:%d) -> %d\n", (void *)p, p->if_idx, netif_get_index(portif))); + return portif->linkoutput(portif, p); + } + } + } + } + } else { + LWIP_ASSERT("invalid port index", dstport_idx == BRIDGEIF_MAX_PORTS); + } + return ERR_OK; +} + +/** Helper function to pass a pbuf to all ports marked in 'dstports' + */ +static err_t +bridgeif_send_to_ports(bridgeif_private_t *br, struct pbuf *p, bridgeif_portmask_t dstports) +{ + err_t err, ret_err = ERR_OK; + u8_t i; + bridgeif_portmask_t mask = 1; + BRIDGEIF_DECL_PROTECT(lev); + BRIDGEIF_READ_PROTECT(lev); + for (i = 0; i < BRIDGEIF_MAX_PORTS; i++, mask = (bridgeif_portmask_t)(mask << 1)) { + if (dstports & mask) { + err = bridgeif_send_to_port(br, p, i); + if (err != ERR_OK) { + ret_err = err; + } + } + } + BRIDGEIF_READ_UNPROTECT(lev); + return ret_err; +} + +/** Output function of the application port of the bridge (the one with an ip address). + * The forwarding port(s) where this pbuf is sent on is/are automatically selected + * from the FDB. + */ +static err_t +bridgeif_output(struct netif *netif, struct pbuf *p) +{ + err_t err; + bridgeif_private_t *br = (bridgeif_private_t *)netif->state; + struct eth_addr *dst = (struct eth_addr *)(p->payload); + + bridgeif_portmask_t dstports = bridgeif_find_dst_ports(br, dst); + err = bridgeif_send_to_ports(br, p, dstports); + + MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p->tot_len); + if (((u8_t *)p->payload)[0] & 1) { + /* broadcast or multicast packet*/ + MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts); + } else { + /* unicast packet */ + MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); + } + /* increase ifoutdiscards or ifouterrors on error */ + + LINK_STATS_INC(link.xmit); + + return err; +} + +/** The actual bridge input function. Port netif's input is changed to call + * here. This function decides where the frame is forwarded. + */ +static err_t +bridgeif_input(struct pbuf *p, struct netif *netif) +{ + u8_t rx_idx; + bridgeif_portmask_t dstports; + struct eth_addr *src, *dst; + bridgeif_private_t *br; + bridgeif_port_t *port; + if (p == NULL || netif == NULL) { + return ERR_VAL; + } + port = (bridgeif_port_t *)netif_get_client_data(netif, bridgeif_netif_client_id); + LWIP_ASSERT("port data not set", port != NULL); + if (port == NULL || port->bridge == NULL) { + return ERR_VAL; + } + br = (bridgeif_private_t *)port->bridge; + rx_idx = netif_get_index(netif); + /* store receive index in pbuf */ + p->if_idx = rx_idx; + + dst = (struct eth_addr *)p->payload; + src = (struct eth_addr *)(((u8_t *)p->payload) + sizeof(struct eth_addr)); + + if ((src->addr[0] & 1) == 0) { + /* update src for all non-group addresses */ + bridgeif_fdb_update_src(br->fdbd, src, port->port_num); + } + + if (dst->addr[0] & 1) { + /* group address -> flood + cpu? */ + dstports = bridgeif_find_dst_ports(br, dst); + bridgeif_send_to_ports(br, p, dstports); + if (dstports & (1 << BRIDGEIF_MAX_PORTS)) { + /* we pass the reference to ->input or have to free it */ + LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> input(%p)\n", (void *)p)); + if (br->netif->input(p, br->netif) != ERR_OK) { + pbuf_free(p); + } + } else { + /* all references done */ + pbuf_free(p); + } + /* always return ERR_OK here to prevent the caller freeing the pbuf */ + return ERR_OK; + } else { + /* is this for one of the local ports? */ + if (bridgeif_is_local_mac(br, dst)) { + /* yes, send to cpu port only */ + LWIP_DEBUGF(BRIDGEIF_FW_DEBUG, ("br -> input(%p)\n", (void *)p)); + return br->netif->input(p, br->netif); + } + + /* get dst port */ + dstports = bridgeif_find_dst_ports(br, dst); + bridgeif_send_to_ports(br, p, dstports); + /* no need to send to cpu, flooding is for external ports only */ + /* by this, we consumed the pbuf */ + pbuf_free(p); + /* always return ERR_OK here to prevent the caller freeing the pbuf */ + return ERR_OK; + } +} + +#if !BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT +/** Input function for port netifs used to synchronize into tcpip_thread. + */ +static err_t +bridgeif_tcpip_input(struct pbuf *p, struct netif *netif) +{ + return tcpip_inpkt(p, netif, bridgeif_input); +} +#endif /* BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT */ + +/** + * @ingroup bridgeif + * Initialization function passed to netif_add(). + * + * ATTENTION: A pointer to a @ref bridgeif_initdata_t must be passed as 'state' + * to @ref netif_add when adding the bridge. I supplies MAC address + * and controls memory allocation (number of ports, FDB size). + * + * @param netif the lwip network interface structure for this ethernetif + * @return ERR_OK if the loopif is initialized + * ERR_MEM if private data couldn't be allocated + * any other err_t on error + */ +err_t +bridgeif_init(struct netif *netif) +{ + bridgeif_initdata_t *init_data; + bridgeif_private_t *br; + size_t alloc_len_sizet; + mem_size_t alloc_len; + + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("bridgeif needs an input callback", (netif->input != NULL)); +#if !BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT + if (netif->input == tcpip_input) { + LWIP_DEBUGF(BRIDGEIF_DEBUG | LWIP_DBG_ON, ("bridgeif does not need tcpip_input, use netif_input/ethernet_input instead")); + } +#endif + + if (bridgeif_netif_client_id == 0xFF) { + bridgeif_netif_client_id = netif_alloc_client_data_id(); + } + + init_data = (bridgeif_initdata_t *)netif->state; + LWIP_ASSERT("init_data != NULL", (init_data != NULL)); + LWIP_ASSERT("init_data->max_ports <= BRIDGEIF_MAX_PORTS", + init_data->max_ports <= BRIDGEIF_MAX_PORTS); + + alloc_len_sizet = sizeof(bridgeif_private_t) + (init_data->max_ports * sizeof(bridgeif_port_t) + (init_data->max_fdb_static_entries * sizeof(bridgeif_fdb_static_entry_t))); + alloc_len = (mem_size_t)alloc_len_sizet; + LWIP_ASSERT("alloc_len == alloc_len_sizet", alloc_len == alloc_len_sizet); + LWIP_DEBUGF(BRIDGEIF_DEBUG, ("bridgeif_init: allocating %d bytes for private data\n", (int)alloc_len)); + br = (bridgeif_private_t *)mem_calloc(1, alloc_len); + if (br == NULL) { + LWIP_DEBUGF(NETIF_DEBUG, ("bridgeif_init: out of memory\n")); + return ERR_MEM; + } + memcpy(&br->ethaddr, &init_data->ethaddr, sizeof(br->ethaddr)); + br->netif = netif; + + br->max_ports = init_data->max_ports; + br->ports = (bridgeif_port_t *)(br + 1); + + br->max_fdbs_entries = init_data->max_fdb_static_entries; + br->fdbs = (bridgeif_fdb_static_entry_t *)(((u8_t *)(br + 1)) + (init_data->max_ports * sizeof(bridgeif_port_t))); + + br->max_fdbd_entries = init_data->max_fdb_dynamic_entries; + br->fdbd = bridgeif_fdb_init(init_data->max_fdb_dynamic_entries); + if (br->fdbd == NULL) { + LWIP_DEBUGF(NETIF_DEBUG, ("bridgeif_init: out of memory in fdb_init\n")); + mem_free(br); + return ERR_MEM; + } + +#if LWIP_NETIF_HOSTNAME + /* Initialize interface hostname */ + netif->hostname = "lwip"; +#endif /* LWIP_NETIF_HOSTNAME */ + + /* + * Initialize the snmp variables and counters inside the struct netif. + * The last argument should be replaced with your link speed, in units + * of bits per second. + */ + MIB2_INIT_NETIF(netif, snmp_ifType_ethernet_csmacd, 0); + + netif->state = br; + netif->name[0] = IFNAME0; + netif->name[1] = IFNAME1; + /* We directly use etharp_output() here to save a function call. + * You can instead declare your own function an call etharp_output() + * from it if you have to do some checks before sending (e.g. if link + * is available...) */ +#if LWIP_IPV4 + netif->output = etharp_output; +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 + netif->output_ip6 = ethip6_output; +#endif /* LWIP_IPV6 */ + netif->linkoutput = bridgeif_output; + + /* set MAC hardware address length */ + netif->hwaddr_len = ETH_HWADDR_LEN; + + /* set MAC hardware address */ + memcpy(netif->hwaddr, &br->ethaddr, ETH_HWADDR_LEN); + + /* maximum transfer unit */ + netif->mtu = 1500; + + /* device capabilities */ + /* don't set NETIF_FLAG_ETHARP if this device is not an ethernet one */ + netif->flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_ETHERNET | NETIF_FLAG_IGMP | NETIF_FLAG_MLD6 | NETIF_FLAG_LINK_UP; + +#if LWIP_IPV6 && LWIP_IPV6_MLD + /* + * For hardware/netifs that implement MAC filtering. + * All-nodes link-local is handled by default, so we must let the hardware know + * to allow multicast packets in. + * Should set mld_mac_filter previously. */ + if (netif->mld_mac_filter != NULL) { + ip6_addr_t ip6_allnodes_ll; + ip6_addr_set_allnodes_linklocal(&ip6_allnodes_ll); + netif->mld_mac_filter(netif, &ip6_allnodes_ll, NETIF_ADD_MAC_FILTER); + } +#endif /* LWIP_IPV6 && LWIP_IPV6_MLD */ + + return ERR_OK; +} + +/** + * @ingroup bridgeif + * Add a port to the bridge + */ +err_t +bridgeif_add_port(struct netif *bridgeif, struct netif *portif) +{ + bridgeif_private_t *br; + bridgeif_port_t *port; + + LWIP_ASSERT("bridgeif != NULL", bridgeif != NULL); + LWIP_ASSERT("bridgeif->state != NULL", bridgeif->state != NULL); + LWIP_ASSERT("portif != NULL", portif != NULL); + + if (!(portif->flags & NETIF_FLAG_ETHARP) || !(portif->flags & NETIF_FLAG_ETHERNET)) { + /* can only add ETHERNET/ETHARP interfaces */ + return ERR_VAL; + } + + br = (bridgeif_private_t *)bridgeif->state; + + if (br->num_ports >= br->max_ports) { + return ERR_VAL; + } + port = &br->ports[br->num_ports]; + port->port_netif = portif; + port->port_num = br->num_ports; + port->bridge = br; + br->num_ports++; + + /* let the port call us on input */ +#if BRIDGEIF_PORT_NETIFS_OUTPUT_DIRECT + portif->input = bridgeif_input; +#else + portif->input = bridgeif_tcpip_input; +#endif + /* store pointer to bridge in netif */ + netif_set_client_data(portif, bridgeif_netif_client_id, port); + /* remove ETHARP flag to prevent sending report events on netif-up */ + netif_clear_flags(portif, NETIF_FLAG_ETHARP); + + return ERR_OK; +} + +#endif /* LWIP_NUM_NETIF_CLIENT_DATA */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif_fdb.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif_fdb.c index fb4b0946..6739fc24 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif_fdb.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/bridgeif_fdb.c @@ -1,212 +1,212 @@ -/** - * @file - * lwIP netif implementing an FDB for IEEE 802.1D MAC Bridge - */ - -/* - * Copyright (c) 2017 Simon Goldschmidt. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -/** - * @defgroup bridgeif_fdb FDB example code - * @ingroup bridgeif - * This file implements an example for an FDB (Forwarding DataBase) - */ - -#include "netif/bridgeif.h" -#include "lwip/sys.h" -#include "lwip/mem.h" -#include "lwip/timeouts.h" -#include - -#define BRIDGEIF_AGE_TIMER_MS 1000 - -#define BR_FDB_TIMEOUT_SEC (60*5) /* 5 minutes FDB timeout */ - -typedef struct bridgeif_dfdb_entry_s { - u8_t used; - u8_t port; - u32_t ts; - struct eth_addr addr; -} bridgeif_dfdb_entry_t; - -typedef struct bridgeif_dfdb_s { - u16_t max_fdb_entries; - bridgeif_dfdb_entry_t *fdb; -} bridgeif_dfdb_t; - -/** - * @ingroup bridgeif_fdb - * A real simple and slow implementation of an auto-learning forwarding database that - * remembers known src mac addresses to know which port to send frames destined for that - * mac address. - * - * ATTENTION: This is meant as an example only, in real-world use, you should - * provide a better implementation :-) - */ -void -bridgeif_fdb_update_src(void *fdb_ptr, struct eth_addr *src_addr, u8_t port_idx) -{ - int i; - bridgeif_dfdb_t *fdb = (bridgeif_dfdb_t *)fdb_ptr; - BRIDGEIF_DECL_PROTECT(lev); - BRIDGEIF_READ_PROTECT(lev); - for (i = 0; i < fdb->max_fdb_entries; i++) { - bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; - if (e->used && e->ts) { - if (!memcmp(&e->addr, src_addr, sizeof(struct eth_addr))) { - LWIP_DEBUGF(BRIDGEIF_FDB_DEBUG, ("br: update src %02x:%02x:%02x:%02x:%02x:%02x (from %d) @ idx %d\n", - src_addr->addr[0], src_addr->addr[1], src_addr->addr[2], src_addr->addr[3], src_addr->addr[4], src_addr->addr[5], - port_idx, i)); - BRIDGEIF_WRITE_PROTECT(lev); - e->ts = BR_FDB_TIMEOUT_SEC; - e->port = port_idx; - BRIDGEIF_WRITE_UNPROTECT(lev); - BRIDGEIF_READ_UNPROTECT(lev); - return; - } - } - } - /* not found, allocate new entry from free */ - for (i = 0; i < fdb->max_fdb_entries; i++) { - bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; - if (!e->used || !e->ts) { - BRIDGEIF_WRITE_PROTECT(lev); - /* check again when protected */ - if (!e->used || !e->ts) { - LWIP_DEBUGF(BRIDGEIF_FDB_DEBUG, ("br: create src %02x:%02x:%02x:%02x:%02x:%02x (from %d) @ idx %d\n", - src_addr->addr[0], src_addr->addr[1], src_addr->addr[2], src_addr->addr[3], src_addr->addr[4], src_addr->addr[5], - port_idx, i)); - memcpy(&e->addr, src_addr, sizeof(struct eth_addr)); - e->ts = BR_FDB_TIMEOUT_SEC; - e->port = port_idx; - e->used = 1; - BRIDGEIF_WRITE_UNPROTECT(lev); - BRIDGEIF_READ_UNPROTECT(lev); - return; - } - BRIDGEIF_WRITE_UNPROTECT(lev); - } - } - BRIDGEIF_READ_UNPROTECT(lev); - /* not found, no free entry -> flood */ -} - -/** - * @ingroup bridgeif_fdb - * Walk our list of auto-learnt fdb entries and return a port to forward or BR_FLOOD if unknown - */ -bridgeif_portmask_t -bridgeif_fdb_get_dst_ports(void *fdb_ptr, struct eth_addr *dst_addr) -{ - int i; - bridgeif_dfdb_t *fdb = (bridgeif_dfdb_t *)fdb_ptr; - BRIDGEIF_DECL_PROTECT(lev); - BRIDGEIF_READ_PROTECT(lev); - for (i = 0; i < fdb->max_fdb_entries; i++) { - bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; - if (e->used && e->ts) { - if (!memcmp(&e->addr, dst_addr, sizeof(struct eth_addr))) { - bridgeif_portmask_t ret = (bridgeif_portmask_t)(1 << e->port); - BRIDGEIF_READ_UNPROTECT(lev); - return ret; - } - } - } - BRIDGEIF_READ_UNPROTECT(lev); - return BR_FLOOD; -} - -/** - * @ingroup bridgeif_fdb - * Aging implementation of our simple fdb - */ -static void -bridgeif_fdb_age_one_second(void *fdb_ptr) -{ - int i; - bridgeif_dfdb_t *fdb; - BRIDGEIF_DECL_PROTECT(lev); - - fdb = (bridgeif_dfdb_t *)fdb_ptr; - BRIDGEIF_READ_PROTECT(lev); - - for (i = 0; i < fdb->max_fdb_entries; i++) { - bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; - if (e->used && e->ts) { - BRIDGEIF_WRITE_PROTECT(lev); - /* check again when protected */ - if (e->used && e->ts) { - if (--e->ts == 0) { - e->used = 0; - } - } - BRIDGEIF_WRITE_UNPROTECT(lev); - } - } - BRIDGEIF_READ_UNPROTECT(lev); -} - -/** Timer callback for fdb aging, called once per second */ -static void -bridgeif_age_tmr(void *arg) -{ - bridgeif_dfdb_t *fdb = (bridgeif_dfdb_t *)arg; - - LWIP_ASSERT("invalid arg", arg != NULL); - - bridgeif_fdb_age_one_second(fdb); - sys_timeout(BRIDGEIF_AGE_TIMER_MS, bridgeif_age_tmr, arg); -} - -/** - * @ingroup bridgeif_fdb - * Init our simple fdb list - */ -void * -bridgeif_fdb_init(u16_t max_fdb_entries) -{ - bridgeif_dfdb_t *fdb; - size_t alloc_len_sizet = sizeof(bridgeif_dfdb_t) + (max_fdb_entries * sizeof(bridgeif_dfdb_entry_t)); - mem_size_t alloc_len = (mem_size_t)alloc_len_sizet; - LWIP_ASSERT("alloc_len == alloc_len_sizet", alloc_len == alloc_len_sizet); - LWIP_DEBUGF(BRIDGEIF_DEBUG, ("bridgeif_fdb_init: allocating %d bytes for private FDB data\n", (int)alloc_len)); - fdb = (bridgeif_dfdb_t *)mem_calloc(1, alloc_len); - if (fdb == NULL) { - return NULL; - } - fdb->max_fdb_entries = max_fdb_entries; - fdb->fdb = (bridgeif_dfdb_entry_t *)(fdb + 1); - - sys_timeout(BRIDGEIF_AGE_TIMER_MS, bridgeif_age_tmr, fdb); - - return fdb; -} +/** + * @file + * lwIP netif implementing an FDB for IEEE 802.1D MAC Bridge + */ + +/* + * Copyright (c) 2017 Simon Goldschmidt. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +/** + * @defgroup bridgeif_fdb FDB example code + * @ingroup bridgeif + * This file implements an example for an FDB (Forwarding DataBase) + */ + +#include "netif/bridgeif.h" +#include "lwip/sys.h" +#include "lwip/mem.h" +#include "lwip/timeouts.h" +#include + +#define BRIDGEIF_AGE_TIMER_MS 1000 + +#define BR_FDB_TIMEOUT_SEC (60*5) /* 5 minutes FDB timeout */ + +typedef struct bridgeif_dfdb_entry_s { + u8_t used; + u8_t port; + u32_t ts; + struct eth_addr addr; +} bridgeif_dfdb_entry_t; + +typedef struct bridgeif_dfdb_s { + u16_t max_fdb_entries; + bridgeif_dfdb_entry_t *fdb; +} bridgeif_dfdb_t; + +/** + * @ingroup bridgeif_fdb + * A real simple and slow implementation of an auto-learning forwarding database that + * remembers known src mac addresses to know which port to send frames destined for that + * mac address. + * + * ATTENTION: This is meant as an example only, in real-world use, you should + * provide a better implementation :-) + */ +void +bridgeif_fdb_update_src(void *fdb_ptr, struct eth_addr *src_addr, u8_t port_idx) +{ + int i; + bridgeif_dfdb_t *fdb = (bridgeif_dfdb_t *)fdb_ptr; + BRIDGEIF_DECL_PROTECT(lev); + BRIDGEIF_READ_PROTECT(lev); + for (i = 0; i < fdb->max_fdb_entries; i++) { + bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; + if (e->used && e->ts) { + if (!memcmp(&e->addr, src_addr, sizeof(struct eth_addr))) { + LWIP_DEBUGF(BRIDGEIF_FDB_DEBUG, ("br: update src %02x:%02x:%02x:%02x:%02x:%02x (from %d) @ idx %d\n", + src_addr->addr[0], src_addr->addr[1], src_addr->addr[2], src_addr->addr[3], src_addr->addr[4], src_addr->addr[5], + port_idx, i)); + BRIDGEIF_WRITE_PROTECT(lev); + e->ts = BR_FDB_TIMEOUT_SEC; + e->port = port_idx; + BRIDGEIF_WRITE_UNPROTECT(lev); + BRIDGEIF_READ_UNPROTECT(lev); + return; + } + } + } + /* not found, allocate new entry from free */ + for (i = 0; i < fdb->max_fdb_entries; i++) { + bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; + if (!e->used || !e->ts) { + BRIDGEIF_WRITE_PROTECT(lev); + /* check again when protected */ + if (!e->used || !e->ts) { + LWIP_DEBUGF(BRIDGEIF_FDB_DEBUG, ("br: create src %02x:%02x:%02x:%02x:%02x:%02x (from %d) @ idx %d\n", + src_addr->addr[0], src_addr->addr[1], src_addr->addr[2], src_addr->addr[3], src_addr->addr[4], src_addr->addr[5], + port_idx, i)); + memcpy(&e->addr, src_addr, sizeof(struct eth_addr)); + e->ts = BR_FDB_TIMEOUT_SEC; + e->port = port_idx; + e->used = 1; + BRIDGEIF_WRITE_UNPROTECT(lev); + BRIDGEIF_READ_UNPROTECT(lev); + return; + } + BRIDGEIF_WRITE_UNPROTECT(lev); + } + } + BRIDGEIF_READ_UNPROTECT(lev); + /* not found, no free entry -> flood */ +} + +/** + * @ingroup bridgeif_fdb + * Walk our list of auto-learnt fdb entries and return a port to forward or BR_FLOOD if unknown + */ +bridgeif_portmask_t +bridgeif_fdb_get_dst_ports(void *fdb_ptr, struct eth_addr *dst_addr) +{ + int i; + bridgeif_dfdb_t *fdb = (bridgeif_dfdb_t *)fdb_ptr; + BRIDGEIF_DECL_PROTECT(lev); + BRIDGEIF_READ_PROTECT(lev); + for (i = 0; i < fdb->max_fdb_entries; i++) { + bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; + if (e->used && e->ts) { + if (!memcmp(&e->addr, dst_addr, sizeof(struct eth_addr))) { + bridgeif_portmask_t ret = (bridgeif_portmask_t)(1 << e->port); + BRIDGEIF_READ_UNPROTECT(lev); + return ret; + } + } + } + BRIDGEIF_READ_UNPROTECT(lev); + return BR_FLOOD; +} + +/** + * @ingroup bridgeif_fdb + * Aging implementation of our simple fdb + */ +static void +bridgeif_fdb_age_one_second(void *fdb_ptr) +{ + int i; + bridgeif_dfdb_t *fdb; + BRIDGEIF_DECL_PROTECT(lev); + + fdb = (bridgeif_dfdb_t *)fdb_ptr; + BRIDGEIF_READ_PROTECT(lev); + + for (i = 0; i < fdb->max_fdb_entries; i++) { + bridgeif_dfdb_entry_t *e = &fdb->fdb[i]; + if (e->used && e->ts) { + BRIDGEIF_WRITE_PROTECT(lev); + /* check again when protected */ + if (e->used && e->ts) { + if (--e->ts == 0) { + e->used = 0; + } + } + BRIDGEIF_WRITE_UNPROTECT(lev); + } + } + BRIDGEIF_READ_UNPROTECT(lev); +} + +/** Timer callback for fdb aging, called once per second */ +static void +bridgeif_age_tmr(void *arg) +{ + bridgeif_dfdb_t *fdb = (bridgeif_dfdb_t *)arg; + + LWIP_ASSERT("invalid arg", arg != NULL); + + bridgeif_fdb_age_one_second(fdb); + sys_timeout(BRIDGEIF_AGE_TIMER_MS, bridgeif_age_tmr, arg); +} + +/** + * @ingroup bridgeif_fdb + * Init our simple fdb list + */ +void * +bridgeif_fdb_init(u16_t max_fdb_entries) +{ + bridgeif_dfdb_t *fdb; + size_t alloc_len_sizet = sizeof(bridgeif_dfdb_t) + (max_fdb_entries * sizeof(bridgeif_dfdb_entry_t)); + mem_size_t alloc_len = (mem_size_t)alloc_len_sizet; + LWIP_ASSERT("alloc_len == alloc_len_sizet", alloc_len == alloc_len_sizet); + LWIP_DEBUGF(BRIDGEIF_DEBUG, ("bridgeif_fdb_init: allocating %d bytes for private FDB data\n", (int)alloc_len)); + fdb = (bridgeif_dfdb_t *)mem_calloc(1, alloc_len); + if (fdb == NULL) { + return NULL; + } + fdb->max_fdb_entries = max_fdb_entries; + fdb->fdb = (bridgeif_dfdb_entry_t *)(fdb + 1); + + sys_timeout(BRIDGEIF_AGE_TIMER_MS, bridgeif_age_tmr, fdb); + + return fdb; +} diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ethernet.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ethernet.c index 3c9eb02d..dd171e28 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ethernet.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ethernet.c @@ -1,321 +1,321 @@ -/** - * @file - * Ethernet common functions - * - * @defgroup ethernet Ethernet - * @ingroup callbackstyle_api - */ - -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * Copyright (c) 2003-2004 Leon Woestenberg - * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "lwip/opt.h" - -#if LWIP_ARP || LWIP_ETHERNET - -#include "netif/ethernet.h" -#include "lwip/def.h" -#include "lwip/stats.h" -#include "lwip/etharp.h" -#include "lwip/ip.h" -#include "lwip/snmp.h" - -#include - -#include "netif/ppp/ppp_opts.h" -#if PPPOE_SUPPORT -#include "netif/ppp/pppoe.h" -#endif /* PPPOE_SUPPORT */ - -#ifdef LWIP_HOOK_FILENAME -#include LWIP_HOOK_FILENAME -#endif - -const struct eth_addr ethbroadcast = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}; -const struct eth_addr ethzero = {{0, 0, 0, 0, 0, 0}}; - -/** - * @ingroup lwip_nosys - * Process received ethernet frames. Using this function instead of directly - * calling ip_input and passing ARP frames through etharp in ethernetif_input, - * the ARP cache is protected from concurrent access.\n - * Don't call directly, pass to netif_add() and call netif->input(). - * - * @param p the received packet, p->payload pointing to the ethernet header - * @param netif the network interface on which the packet was received - * - * @see LWIP_HOOK_UNKNOWN_ETH_PROTOCOL - * @see ETHARP_SUPPORT_VLAN - * @see LWIP_HOOK_VLAN_CHECK - */ -err_t -ethernet_input(struct pbuf *p, struct netif *netif) -{ - struct eth_hdr *ethhdr; - u16_t type; -#if LWIP_ARP || ETHARP_SUPPORT_VLAN || LWIP_IPV6 - u16_t next_hdr_offset = SIZEOF_ETH_HDR; -#endif /* LWIP_ARP || ETHARP_SUPPORT_VLAN */ - - LWIP_ASSERT_CORE_LOCKED(); - - if (p->len <= SIZEOF_ETH_HDR) { - /* a packet with only an ethernet header (or less) is not valid for us */ - ETHARP_STATS_INC(etharp.proterr); - ETHARP_STATS_INC(etharp.drop); - MIB2_STATS_NETIF_INC(netif, ifinerrors); - goto free_and_return; - } - - if (p->if_idx == NETIF_NO_INDEX) { - p->if_idx = netif_get_index(netif); - } - - /* points to packet payload, which starts with an Ethernet header */ - ethhdr = (struct eth_hdr *)p->payload; - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, - ("ethernet_input: dest:%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F", src:%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F", type:%"X16_F"\n", - (unsigned char)ethhdr->dest.addr[0], (unsigned char)ethhdr->dest.addr[1], (unsigned char)ethhdr->dest.addr[2], - (unsigned char)ethhdr->dest.addr[3], (unsigned char)ethhdr->dest.addr[4], (unsigned char)ethhdr->dest.addr[5], - (unsigned char)ethhdr->src.addr[0], (unsigned char)ethhdr->src.addr[1], (unsigned char)ethhdr->src.addr[2], - (unsigned char)ethhdr->src.addr[3], (unsigned char)ethhdr->src.addr[4], (unsigned char)ethhdr->src.addr[5], - lwip_htons(ethhdr->type))); - - type = ethhdr->type; -#if ETHARP_SUPPORT_VLAN - if (type == PP_HTONS(ETHTYPE_VLAN)) { - struct eth_vlan_hdr *vlan = (struct eth_vlan_hdr *)(((char *)ethhdr) + SIZEOF_ETH_HDR); - next_hdr_offset = SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR; - if (p->len <= SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR) { - /* a packet with only an ethernet/vlan header (or less) is not valid for us */ - ETHARP_STATS_INC(etharp.proterr); - ETHARP_STATS_INC(etharp.drop); - MIB2_STATS_NETIF_INC(netif, ifinerrors); - goto free_and_return; - } -#if defined(LWIP_HOOK_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK_FN) /* if not, allow all VLANs */ -#ifdef LWIP_HOOK_VLAN_CHECK - if (!LWIP_HOOK_VLAN_CHECK(netif, ethhdr, vlan)) { -#elif defined(ETHARP_VLAN_CHECK_FN) - if (!ETHARP_VLAN_CHECK_FN(ethhdr, vlan)) { -#elif defined(ETHARP_VLAN_CHECK) - if (VLAN_ID(vlan) != ETHARP_VLAN_CHECK) { -#endif - /* silently ignore this packet: not for our VLAN */ - pbuf_free(p); - return ERR_OK; - } -#endif /* defined(LWIP_HOOK_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK_FN) */ - type = vlan->tpid; - } -#endif /* ETHARP_SUPPORT_VLAN */ - -#if LWIP_ARP_FILTER_NETIF - netif = LWIP_ARP_FILTER_NETIF_FN(p, netif, lwip_htons(type)); -#endif /* LWIP_ARP_FILTER_NETIF*/ - - if (ethhdr->dest.addr[0] & 1) { - /* this might be a multicast or broadcast packet */ - if (ethhdr->dest.addr[0] == LL_IP4_MULTICAST_ADDR_0) { -#if LWIP_IPV4 - if ((ethhdr->dest.addr[1] == LL_IP4_MULTICAST_ADDR_1) && - (ethhdr->dest.addr[2] == LL_IP4_MULTICAST_ADDR_2)) { - /* mark the pbuf as link-layer multicast */ - p->flags |= PBUF_FLAG_LLMCAST; - } -#endif /* LWIP_IPV4 */ - } -#if LWIP_IPV6 - else if ((ethhdr->dest.addr[0] == LL_IP6_MULTICAST_ADDR_0) && - (ethhdr->dest.addr[1] == LL_IP6_MULTICAST_ADDR_1)) { - /* mark the pbuf as link-layer multicast */ - p->flags |= PBUF_FLAG_LLMCAST; - } -#endif /* LWIP_IPV6 */ - else if (eth_addr_cmp(ðhdr->dest, ðbroadcast)) { - /* mark the pbuf as link-layer broadcast */ - p->flags |= PBUF_FLAG_LLBCAST; - } - } - - switch (type) { -#if LWIP_IPV4 && LWIP_ARP - /* IP packet? */ - case PP_HTONS(ETHTYPE_IP): - if (!(netif->flags & NETIF_FLAG_ETHARP)) { - goto free_and_return; - } - /* skip Ethernet header (min. size checked above) */ - if (pbuf_remove_header(p, next_hdr_offset)) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, - ("ethernet_input: IPv4 packet dropped, too short (%"U16_F"/%"U16_F")\n", - p->tot_len, next_hdr_offset)); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("Can't move over header in packet")); - goto free_and_return; - } else { - /* pass to IP layer */ - ip4_input(p, netif); - } - break; - - case PP_HTONS(ETHTYPE_ARP): - if (!(netif->flags & NETIF_FLAG_ETHARP)) { - goto free_and_return; - } - /* skip Ethernet header (min. size checked above) */ - if (pbuf_remove_header(p, next_hdr_offset)) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, - ("ethernet_input: ARP response packet dropped, too short (%"U16_F"/%"U16_F")\n", - p->tot_len, next_hdr_offset)); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("Can't move over header in packet")); - ETHARP_STATS_INC(etharp.lenerr); - ETHARP_STATS_INC(etharp.drop); - goto free_and_return; - } else { - /* pass p to ARP module */ - etharp_input(p, netif); - } - break; -#endif /* LWIP_IPV4 && LWIP_ARP */ -#if PPPOE_SUPPORT - case PP_HTONS(ETHTYPE_PPPOEDISC): /* PPP Over Ethernet Discovery Stage */ - pppoe_disc_input(netif, p); - break; - - case PP_HTONS(ETHTYPE_PPPOE): /* PPP Over Ethernet Session Stage */ - pppoe_data_input(netif, p); - break; -#endif /* PPPOE_SUPPORT */ - -#if LWIP_IPV6 - case PP_HTONS(ETHTYPE_IPV6): /* IPv6 */ - /* skip Ethernet header */ - if ((p->len < next_hdr_offset) || pbuf_remove_header(p, next_hdr_offset)) { - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, - ("ethernet_input: IPv6 packet dropped, too short (%"U16_F"/%"U16_F")\n", - p->tot_len, next_hdr_offset)); - goto free_and_return; - } else { - /* pass to IPv6 layer */ - ip6_input(p, netif); - } - break; -#endif /* LWIP_IPV6 */ - - default: -#ifdef LWIP_HOOK_UNKNOWN_ETH_PROTOCOL - if (LWIP_HOOK_UNKNOWN_ETH_PROTOCOL(p, netif) == ERR_OK) { - break; - } -#endif - ETHARP_STATS_INC(etharp.proterr); - ETHARP_STATS_INC(etharp.drop); - MIB2_STATS_NETIF_INC(netif, ifinunknownprotos); - goto free_and_return; - } - - /* This means the pbuf is freed or consumed, - so the caller doesn't have to free it again */ - return ERR_OK; - -free_and_return: - pbuf_free(p); - return ERR_OK; -} - -/** - * @ingroup ethernet - * Send an ethernet packet on the network using netif->linkoutput(). - * The ethernet header is filled in before sending. - * - * @see LWIP_HOOK_VLAN_SET - * - * @param netif the lwIP network interface on which to send the packet - * @param p the packet to send. pbuf layer must be @ref PBUF_LINK. - * @param src the source MAC address to be copied into the ethernet header - * @param dst the destination MAC address to be copied into the ethernet header - * @param eth_type ethernet type (@ref lwip_ieee_eth_type) - * @return ERR_OK if the packet was sent, any other err_t on failure - */ -err_t -ethernet_output(struct netif * netif, struct pbuf * p, - const struct eth_addr * src, const struct eth_addr * dst, - u16_t eth_type) { - struct eth_hdr *ethhdr; - u16_t eth_type_be = lwip_htons(eth_type); - -#if ETHARP_SUPPORT_VLAN && defined(LWIP_HOOK_VLAN_SET) - s32_t vlan_prio_vid = LWIP_HOOK_VLAN_SET(netif, p, src, dst, eth_type); - if (vlan_prio_vid >= 0) { - struct eth_vlan_hdr *vlanhdr; - - LWIP_ASSERT("prio_vid must be <= 0xFFFF", vlan_prio_vid <= 0xFFFF); - - if (pbuf_add_header(p, SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR) != 0) { - goto pbuf_header_failed; - } - vlanhdr = (struct eth_vlan_hdr *)(((u8_t *)p->payload) + SIZEOF_ETH_HDR); - vlanhdr->tpid = eth_type_be; - vlanhdr->prio_vid = lwip_htons((u16_t)vlan_prio_vid); - - eth_type_be = PP_HTONS(ETHTYPE_VLAN); - } else -#endif /* ETHARP_SUPPORT_VLAN && defined(LWIP_HOOK_VLAN_SET) */ - { - if (pbuf_add_header(p, SIZEOF_ETH_HDR) != 0) { - goto pbuf_header_failed; - } - } - - LWIP_ASSERT_CORE_LOCKED(); - - ethhdr = (struct eth_hdr *)p->payload; - ethhdr->type = eth_type_be; - SMEMCPY(ðhdr->dest, dst, ETH_HWADDR_LEN); - SMEMCPY(ðhdr->src, src, ETH_HWADDR_LEN); - - LWIP_ASSERT("netif->hwaddr_len must be 6 for ethernet_output!", - (netif->hwaddr_len == ETH_HWADDR_LEN)); - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, - ("ethernet_output: sending packet %p\n", (void *)p)); - - /* send the packet */ - return netif->linkoutput(netif, p); - -pbuf_header_failed: - LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, - ("ethernet_output: could not allocate room for header.\n")); - LINK_STATS_INC(link.lenerr); - return ERR_BUF; -} - -#endif /* LWIP_ARP || LWIP_ETHERNET */ +/** + * @file + * Ethernet common functions + * + * @defgroup ethernet Ethernet + * @ingroup callbackstyle_api + */ + +/* + * Copyright (c) 2001-2003 Swedish Institute of Computer Science. + * Copyright (c) 2003-2004 Leon Woestenberg + * Copyright (c) 2003-2004 Axon Digital Design B.V., The Netherlands. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "lwip/opt.h" + +#if LWIP_ARP || LWIP_ETHERNET + +#include "netif/ethernet.h" +#include "lwip/def.h" +#include "lwip/stats.h" +#include "lwip/etharp.h" +#include "lwip/ip.h" +#include "lwip/snmp.h" + +#include + +#include "netif/ppp/ppp_opts.h" +#if PPPOE_SUPPORT +#include "netif/ppp/pppoe.h" +#endif /* PPPOE_SUPPORT */ + +#ifdef LWIP_HOOK_FILENAME +#include LWIP_HOOK_FILENAME +#endif + +const struct eth_addr ethbroadcast = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}}; +const struct eth_addr ethzero = {{0, 0, 0, 0, 0, 0}}; + +/** + * @ingroup lwip_nosys + * Process received ethernet frames. Using this function instead of directly + * calling ip_input and passing ARP frames through etharp in ethernetif_input, + * the ARP cache is protected from concurrent access.\n + * Don't call directly, pass to netif_add() and call netif->input(). + * + * @param p the received packet, p->payload pointing to the ethernet header + * @param netif the network interface on which the packet was received + * + * @see LWIP_HOOK_UNKNOWN_ETH_PROTOCOL + * @see ETHARP_SUPPORT_VLAN + * @see LWIP_HOOK_VLAN_CHECK + */ +err_t +ethernet_input(struct pbuf *p, struct netif *netif) +{ + struct eth_hdr *ethhdr; + u16_t type; +#if LWIP_ARP || ETHARP_SUPPORT_VLAN || LWIP_IPV6 + u16_t next_hdr_offset = SIZEOF_ETH_HDR; +#endif /* LWIP_ARP || ETHARP_SUPPORT_VLAN */ + + LWIP_ASSERT_CORE_LOCKED(); + + if (p->len <= SIZEOF_ETH_HDR) { + /* a packet with only an ethernet header (or less) is not valid for us */ + ETHARP_STATS_INC(etharp.proterr); + ETHARP_STATS_INC(etharp.drop); + MIB2_STATS_NETIF_INC(netif, ifinerrors); + goto free_and_return; + } + + if (p->if_idx == NETIF_NO_INDEX) { + p->if_idx = netif_get_index(netif); + } + + /* points to packet payload, which starts with an Ethernet header */ + ethhdr = (struct eth_hdr *)p->payload; + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, + ("ethernet_input: dest:%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F", src:%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F":%"X8_F", type:%"X16_F"\n", + (unsigned char)ethhdr->dest.addr[0], (unsigned char)ethhdr->dest.addr[1], (unsigned char)ethhdr->dest.addr[2], + (unsigned char)ethhdr->dest.addr[3], (unsigned char)ethhdr->dest.addr[4], (unsigned char)ethhdr->dest.addr[5], + (unsigned char)ethhdr->src.addr[0], (unsigned char)ethhdr->src.addr[1], (unsigned char)ethhdr->src.addr[2], + (unsigned char)ethhdr->src.addr[3], (unsigned char)ethhdr->src.addr[4], (unsigned char)ethhdr->src.addr[5], + lwip_htons(ethhdr->type))); + + type = ethhdr->type; +#if ETHARP_SUPPORT_VLAN + if (type == PP_HTONS(ETHTYPE_VLAN)) { + struct eth_vlan_hdr *vlan = (struct eth_vlan_hdr *)(((char *)ethhdr) + SIZEOF_ETH_HDR); + next_hdr_offset = SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR; + if (p->len <= SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR) { + /* a packet with only an ethernet/vlan header (or less) is not valid for us */ + ETHARP_STATS_INC(etharp.proterr); + ETHARP_STATS_INC(etharp.drop); + MIB2_STATS_NETIF_INC(netif, ifinerrors); + goto free_and_return; + } +#if defined(LWIP_HOOK_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK_FN) /* if not, allow all VLANs */ +#ifdef LWIP_HOOK_VLAN_CHECK + if (!LWIP_HOOK_VLAN_CHECK(netif, ethhdr, vlan)) { +#elif defined(ETHARP_VLAN_CHECK_FN) + if (!ETHARP_VLAN_CHECK_FN(ethhdr, vlan)) { +#elif defined(ETHARP_VLAN_CHECK) + if (VLAN_ID(vlan) != ETHARP_VLAN_CHECK) { +#endif + /* silently ignore this packet: not for our VLAN */ + pbuf_free(p); + return ERR_OK; + } +#endif /* defined(LWIP_HOOK_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK) || defined(ETHARP_VLAN_CHECK_FN) */ + type = vlan->tpid; + } +#endif /* ETHARP_SUPPORT_VLAN */ + +#if LWIP_ARP_FILTER_NETIF + netif = LWIP_ARP_FILTER_NETIF_FN(p, netif, lwip_htons(type)); +#endif /* LWIP_ARP_FILTER_NETIF*/ + + if (ethhdr->dest.addr[0] & 1) { + /* this might be a multicast or broadcast packet */ + if (ethhdr->dest.addr[0] == LL_IP4_MULTICAST_ADDR_0) { +#if LWIP_IPV4 + if ((ethhdr->dest.addr[1] == LL_IP4_MULTICAST_ADDR_1) && + (ethhdr->dest.addr[2] == LL_IP4_MULTICAST_ADDR_2)) { + /* mark the pbuf as link-layer multicast */ + p->flags |= PBUF_FLAG_LLMCAST; + } +#endif /* LWIP_IPV4 */ + } +#if LWIP_IPV6 + else if ((ethhdr->dest.addr[0] == LL_IP6_MULTICAST_ADDR_0) && + (ethhdr->dest.addr[1] == LL_IP6_MULTICAST_ADDR_1)) { + /* mark the pbuf as link-layer multicast */ + p->flags |= PBUF_FLAG_LLMCAST; + } +#endif /* LWIP_IPV6 */ + else if (eth_addr_cmp(ðhdr->dest, ðbroadcast)) { + /* mark the pbuf as link-layer broadcast */ + p->flags |= PBUF_FLAG_LLBCAST; + } + } + + switch (type) { +#if LWIP_IPV4 && LWIP_ARP + /* IP packet? */ + case PP_HTONS(ETHTYPE_IP): + if (!(netif->flags & NETIF_FLAG_ETHARP)) { + goto free_and_return; + } + /* skip Ethernet header (min. size checked above) */ + if (pbuf_remove_header(p, next_hdr_offset)) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, + ("ethernet_input: IPv4 packet dropped, too short (%"U16_F"/%"U16_F")\n", + p->tot_len, next_hdr_offset)); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("Can't move over header in packet")); + goto free_and_return; + } else { + /* pass to IP layer */ + ip4_input(p, netif); + } + break; + + case PP_HTONS(ETHTYPE_ARP): + if (!(netif->flags & NETIF_FLAG_ETHARP)) { + goto free_and_return; + } + /* skip Ethernet header (min. size checked above) */ + if (pbuf_remove_header(p, next_hdr_offset)) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, + ("ethernet_input: ARP response packet dropped, too short (%"U16_F"/%"U16_F")\n", + p->tot_len, next_hdr_offset)); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, ("Can't move over header in packet")); + ETHARP_STATS_INC(etharp.lenerr); + ETHARP_STATS_INC(etharp.drop); + goto free_and_return; + } else { + /* pass p to ARP module */ + etharp_input(p, netif); + } + break; +#endif /* LWIP_IPV4 && LWIP_ARP */ +#if PPPOE_SUPPORT + case PP_HTONS(ETHTYPE_PPPOEDISC): /* PPP Over Ethernet Discovery Stage */ + pppoe_disc_input(netif, p); + break; + + case PP_HTONS(ETHTYPE_PPPOE): /* PPP Over Ethernet Session Stage */ + pppoe_data_input(netif, p); + break; +#endif /* PPPOE_SUPPORT */ + +#if LWIP_IPV6 + case PP_HTONS(ETHTYPE_IPV6): /* IPv6 */ + /* skip Ethernet header */ + if ((p->len < next_hdr_offset) || pbuf_remove_header(p, next_hdr_offset)) { + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_WARNING, + ("ethernet_input: IPv6 packet dropped, too short (%"U16_F"/%"U16_F")\n", + p->tot_len, next_hdr_offset)); + goto free_and_return; + } else { + /* pass to IPv6 layer */ + ip6_input(p, netif); + } + break; +#endif /* LWIP_IPV6 */ + + default: +#ifdef LWIP_HOOK_UNKNOWN_ETH_PROTOCOL + if (LWIP_HOOK_UNKNOWN_ETH_PROTOCOL(p, netif) == ERR_OK) { + break; + } +#endif + ETHARP_STATS_INC(etharp.proterr); + ETHARP_STATS_INC(etharp.drop); + MIB2_STATS_NETIF_INC(netif, ifinunknownprotos); + goto free_and_return; + } + + /* This means the pbuf is freed or consumed, + so the caller doesn't have to free it again */ + return ERR_OK; + +free_and_return: + pbuf_free(p); + return ERR_OK; +} + +/** + * @ingroup ethernet + * Send an ethernet packet on the network using netif->linkoutput(). + * The ethernet header is filled in before sending. + * + * @see LWIP_HOOK_VLAN_SET + * + * @param netif the lwIP network interface on which to send the packet + * @param p the packet to send. pbuf layer must be @ref PBUF_LINK. + * @param src the source MAC address to be copied into the ethernet header + * @param dst the destination MAC address to be copied into the ethernet header + * @param eth_type ethernet type (@ref lwip_ieee_eth_type) + * @return ERR_OK if the packet was sent, any other err_t on failure + */ +err_t +ethernet_output(struct netif * netif, struct pbuf * p, + const struct eth_addr * src, const struct eth_addr * dst, + u16_t eth_type) { + struct eth_hdr *ethhdr; + u16_t eth_type_be = lwip_htons(eth_type); + +#if ETHARP_SUPPORT_VLAN && defined(LWIP_HOOK_VLAN_SET) + s32_t vlan_prio_vid = LWIP_HOOK_VLAN_SET(netif, p, src, dst, eth_type); + if (vlan_prio_vid >= 0) { + struct eth_vlan_hdr *vlanhdr; + + LWIP_ASSERT("prio_vid must be <= 0xFFFF", vlan_prio_vid <= 0xFFFF); + + if (pbuf_add_header(p, SIZEOF_ETH_HDR + SIZEOF_VLAN_HDR) != 0) { + goto pbuf_header_failed; + } + vlanhdr = (struct eth_vlan_hdr *)(((u8_t *)p->payload) + SIZEOF_ETH_HDR); + vlanhdr->tpid = eth_type_be; + vlanhdr->prio_vid = lwip_htons((u16_t)vlan_prio_vid); + + eth_type_be = PP_HTONS(ETHTYPE_VLAN); + } else +#endif /* ETHARP_SUPPORT_VLAN && defined(LWIP_HOOK_VLAN_SET) */ + { + if (pbuf_add_header(p, SIZEOF_ETH_HDR) != 0) { + goto pbuf_header_failed; + } + } + + LWIP_ASSERT_CORE_LOCKED(); + + ethhdr = (struct eth_hdr *)p->payload; + ethhdr->type = eth_type_be; + SMEMCPY(ðhdr->dest, dst, ETH_HWADDR_LEN); + SMEMCPY(ðhdr->src, src, ETH_HWADDR_LEN); + + LWIP_ASSERT("netif->hwaddr_len must be 6 for ethernet_output!", + (netif->hwaddr_len == ETH_HWADDR_LEN)); + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE, + ("ethernet_output: sending packet %p\n", (void *)p)); + + /* send the packet */ + return netif->linkoutput(netif, p); + +pbuf_header_failed: + LWIP_DEBUGF(ETHARP_DEBUG | LWIP_DBG_TRACE | LWIP_DBG_LEVEL_SERIOUS, + ("ethernet_output: could not allocate room for header.\n")); + LINK_STATS_INC(link.lenerr); + return ERR_BUF; +} + +#endif /* LWIP_ARP || LWIP_ETHERNET */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6.c index 6c26f660..7f0d2767 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6.c @@ -1,920 +1,920 @@ -/** - * @file - * - * 6LowPAN output for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. - * - * This implementation aims to conform to IEEE 802.15.4(-2015), RFC 4944 and RFC 6282. - * @todo: RFC 6775. - */ - -/* - * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -/** - * @defgroup sixlowpan 6LoWPAN (RFC4944) - * @ingroup netifs - * 6LowPAN netif implementation - */ - -#include "netif/lowpan6.h" - -#if LWIP_IPV6 - -#include "lwip/ip.h" -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/nd6.h" -#include "lwip/mem.h" -#include "lwip/udp.h" -#include "lwip/tcpip.h" -#include "lwip/snmp.h" -#include "netif/ieee802154.h" - -#include - -#if LWIP_6LOWPAN_802154_HW_CRC -#define LWIP_6LOWPAN_DO_CALC_CRC(buf, len) 0 -#else -#define LWIP_6LOWPAN_DO_CALC_CRC(buf, len) LWIP_6LOWPAN_CALC_CRC(buf, len) -#endif - -/** This is a helper struct for reassembly of fragments - * (IEEE 802.15.4 limits to 127 bytes) - */ -struct lowpan6_reass_helper { - struct lowpan6_reass_helper *next_packet; - struct pbuf *reass; - struct pbuf *frags; - u8_t timer; - struct lowpan6_link_addr sender_addr; - u16_t datagram_size; - u16_t datagram_tag; -}; - -/** This struct keeps track of per-netif state */ -struct lowpan6_ieee802154_data { - /** fragment reassembly list */ - struct lowpan6_reass_helper *reass_list; -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 - /** address context for compression */ - ip6_addr_t lowpan6_context[LWIP_6LOWPAN_NUM_CONTEXTS]; -#endif - /** Datagram Tag for fragmentation */ - u16_t tx_datagram_tag; - /** local PAN ID for IEEE 802.15.4 header */ - u16_t ieee_802154_pan_id; - /** Sequence Number for IEEE 802.15.4 transmission */ - u8_t tx_frame_seq_num; -}; - -/* Maximum frame size is 127 bytes minus CRC size */ -#define LOWPAN6_MAX_PAYLOAD (127 - 2) - -/** Currently, this state is global, since there's only one 6LoWPAN netif */ -static struct lowpan6_ieee802154_data lowpan6_data; - -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 -#define LWIP_6LOWPAN_CONTEXTS(netif) lowpan6_data.lowpan6_context -#else -#define LWIP_6LOWPAN_CONTEXTS(netif) NULL -#endif - -static const struct lowpan6_link_addr ieee_802154_broadcast = {2, {0xff, 0xff}}; - -#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS -static struct lowpan6_link_addr short_mac_addr = {2, {0, 0}}; -#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ - -/* IEEE 802.15.4 specific functions: */ - -/** Write the IEEE 802.15.4 header that encapsulates the 6LoWPAN frame. - * Src and dst PAN IDs are filled with the ID set by @ref lowpan6_set_pan_id. - * - * Since the length is variable: - * @returns the header length - */ -static u8_t -lowpan6_write_iee802154_header(struct ieee_802154_hdr *hdr, const struct lowpan6_link_addr *src, - const struct lowpan6_link_addr *dst) -{ - u8_t ieee_header_len; - u8_t *buffer; - u8_t i; - u16_t fc; - - fc = IEEE_802154_FC_FT_DATA; /* send data packet (2003 frame version) */ - fc |= IEEE_802154_FC_PANID_COMPR; /* set PAN ID compression, for now src and dst PANs are equal */ - if (dst != &ieee_802154_broadcast) { - fc |= IEEE_802154_FC_ACK_REQ; /* data packet, no broadcast: ack required. */ - } - if (dst->addr_len == 2) { - fc |= IEEE_802154_FC_DST_ADDR_MODE_SHORT; - } else { - LWIP_ASSERT("invalid dst address length", dst->addr_len == 8); - fc |= IEEE_802154_FC_DST_ADDR_MODE_EXT; - } - if (src->addr_len == 2) { - fc |= IEEE_802154_FC_SRC_ADDR_MODE_SHORT; - } else { - LWIP_ASSERT("invalid src address length", src->addr_len == 8); - fc |= IEEE_802154_FC_SRC_ADDR_MODE_EXT; - } - hdr->frame_control = fc; - hdr->sequence_number = lowpan6_data.tx_frame_seq_num++; - hdr->destination_pan_id = lowpan6_data.ieee_802154_pan_id; /* pan id */ - - buffer = (u8_t *)hdr; - ieee_header_len = 5; - i = dst->addr_len; - /* reverse memcpy of dst addr */ - while (i-- > 0) { - buffer[ieee_header_len++] = dst->addr[i]; - } - /* Source PAN ID skipped due to PAN ID Compression */ - i = src->addr_len; - /* reverse memcpy of src addr */ - while (i-- > 0) { - buffer[ieee_header_len++] = src->addr[i]; - } - return ieee_header_len; -} - -/** Parse the IEEE 802.15.4 header from a pbuf. - * If successful, the header is hidden from the pbuf. - * - * PAN IDs and seuqence number are not checked - * - * @param p input pbuf, p->payload pointing at the IEEE 802.15.4 header - * @param src pointer to source address filled from the header - * @param dest pointer to destination address filled from the header - * @returns ERR_OK if successful - */ -static err_t -lowpan6_parse_iee802154_header(struct pbuf *p, struct lowpan6_link_addr *src, - struct lowpan6_link_addr *dest) -{ - u8_t *puc; - s8_t i; - u16_t frame_control, addr_mode; - u16_t datagram_offset; - - /* Parse IEEE 802.15.4 header */ - puc = (u8_t *)p->payload; - frame_control = puc[0] | (puc[1] << 8); - datagram_offset = 2; - if (frame_control & IEEE_802154_FC_SEQNO_SUPPR) { - if (IEEE_802154_FC_FRAME_VERSION_GET(frame_control) <= 1) { - /* sequence number suppressed, this is not valid for versions 0/1 */ - return ERR_VAL; - } - } else { - datagram_offset++; - } - datagram_offset += 2; /* Skip destination PAN ID */ - addr_mode = frame_control & IEEE_802154_FC_DST_ADDR_MODE_MASK; - if (addr_mode == IEEE_802154_FC_DST_ADDR_MODE_EXT) { - /* extended address (64 bit) */ - dest->addr_len = 8; - /* reverse memcpy: */ - for (i = 0; i < 8; i++) { - dest->addr[i] = puc[datagram_offset + 7 - i]; - } - datagram_offset += 8; - } else if (addr_mode == IEEE_802154_FC_DST_ADDR_MODE_SHORT) { - /* short address (16 bit) */ - dest->addr_len = 2; - /* reverse memcpy: */ - dest->addr[0] = puc[datagram_offset + 1]; - dest->addr[1] = puc[datagram_offset]; - datagram_offset += 2; - } else { - /* unsupported address mode (do we need "no address"?) */ - return ERR_VAL; - } - - if (!(frame_control & IEEE_802154_FC_PANID_COMPR)) { - /* No PAN ID compression, skip source PAN ID */ - datagram_offset += 2; - } - - addr_mode = frame_control & IEEE_802154_FC_SRC_ADDR_MODE_MASK; - if (addr_mode == IEEE_802154_FC_SRC_ADDR_MODE_EXT) { - /* extended address (64 bit) */ - src->addr_len = 8; - /* reverse memcpy: */ - for (i = 0; i < 8; i++) { - src->addr[i] = puc[datagram_offset + 7 - i]; - } - datagram_offset += 8; - } else if (addr_mode == IEEE_802154_FC_DST_ADDR_MODE_SHORT) { - /* short address (16 bit) */ - src->addr_len = 2; - src->addr[0] = puc[datagram_offset + 1]; - src->addr[1] = puc[datagram_offset]; - datagram_offset += 2; - } else { - /* unsupported address mode (do we need "no address"?) */ - return ERR_VAL; - } - - /* hide IEEE802.15.4 header. */ - if (pbuf_remove_header(p, datagram_offset)) { - return ERR_VAL; - } - return ERR_OK; -} - -/** Calculate the 16-bit CRC as required by IEEE 802.15.4 */ -u16_t -lowpan6_calc_crc(const void* buf, u16_t len) -{ -#define CCITT_POLY_16 0x8408U - u16_t i; - u8_t b; - u16_t crc = 0; - const u8_t* p = (const u8_t*)buf; - - for (i = 0; i < len; i++) { - u8_t data = *p; - for (b = 0U; b < 8U; b++) { - if (((data ^ crc) & 1) != 0) { - crc = (u16_t)((crc >> 1) ^ CCITT_POLY_16); - } else { - crc = (u16_t)(crc >> 1); - } - data = (u8_t)(data >> 1); - } - p++; - } - return crc; -} - -/* Fragmentation specific functions: */ - -static void -free_reass_datagram(struct lowpan6_reass_helper *lrh) -{ - if (lrh->reass) { - pbuf_free(lrh->reass); - } - if (lrh->frags) { - pbuf_free(lrh->frags); - } - mem_free(lrh); -} - -/** - * Removes a datagram from the reassembly queue. - **/ -static void -dequeue_datagram(struct lowpan6_reass_helper *lrh, struct lowpan6_reass_helper *prev) -{ - if (lowpan6_data.reass_list == lrh) { - lowpan6_data.reass_list = lowpan6_data.reass_list->next_packet; - } else { - /* it wasn't the first, so it must have a valid 'prev' */ - LWIP_ASSERT("sanity check linked list", prev != NULL); - prev->next_packet = lrh->next_packet; - } -} - -/** - * Periodic timer for 6LowPAN functions: - * - * - Remove incomplete/old packets - */ -void -lowpan6_tmr(void) -{ - struct lowpan6_reass_helper *lrh, *lrh_next, *lrh_prev = NULL; - - lrh = lowpan6_data.reass_list; - while (lrh != NULL) { - lrh_next = lrh->next_packet; - if ((--lrh->timer) == 0) { - dequeue_datagram(lrh, lrh_prev); - free_reass_datagram(lrh); - } else { - lrh_prev = lrh; - } - lrh = lrh_next; - } -} - -/* - * Encapsulates data into IEEE 802.15.4 frames. - * Fragments an IPv6 datagram into 6LowPAN units, which fit into IEEE 802.15.4 frames. - * If configured, will compress IPv6 and or UDP headers. - * */ -static err_t -lowpan6_frag(struct netif *netif, struct pbuf *p, const struct lowpan6_link_addr *src, const struct lowpan6_link_addr *dst) -{ - struct pbuf *p_frag; - u16_t frag_len, remaining_len, max_data_len; - u8_t *buffer; - u8_t ieee_header_len; - u8_t lowpan6_header_len; - u8_t hidden_header_len; - u16_t crc; - u16_t datagram_offset; - err_t err = ERR_IF; - - LWIP_ASSERT("lowpan6_frag: netif->linkoutput not set", netif->linkoutput != NULL); - - /* We'll use a dedicated pbuf for building 6LowPAN fragments. */ - p_frag = pbuf_alloc(PBUF_RAW, 127, PBUF_RAM); - if (p_frag == NULL) { - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - return ERR_MEM; - } - LWIP_ASSERT("this needs a pbuf in one piece", p_frag->len == p_frag->tot_len); - - /* Write IEEE 802.15.4 header. */ - buffer = (u8_t *)p_frag->payload; - ieee_header_len = lowpan6_write_iee802154_header((struct ieee_802154_hdr *)buffer, src, dst); - LWIP_ASSERT("ieee_header_len < p_frag->len", ieee_header_len < p_frag->len); - -#if LWIP_6LOWPAN_IPHC - /* Perform 6LowPAN IPv6 header compression according to RFC 6282 */ - /* do the header compression (this does NOT copy any non-compressed data) */ - err = lowpan6_compress_headers(netif, (u8_t *)p->payload, p->len, - &buffer[ieee_header_len], p_frag->len - ieee_header_len, &lowpan6_header_len, - &hidden_header_len, LWIP_6LOWPAN_CONTEXTS(netif), src, dst); - if (err != ERR_OK) { - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - pbuf_free(p_frag); - return err; - } - pbuf_remove_header(p, hidden_header_len); - -#else /* LWIP_6LOWPAN_IPHC */ - /* Send uncompressed IPv6 header with appropriate dispatch byte. */ - lowpan6_header_len = 1; - buffer[ieee_header_len] = 0x41; /* IPv6 dispatch */ -#endif /* LWIP_6LOWPAN_IPHC */ - - /* Calculate remaining packet length */ - remaining_len = p->tot_len; - - if (remaining_len > 0x7FF) { - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - /* datagram_size must fit into 11 bit */ - pbuf_free(p_frag); - return ERR_VAL; - } - - /* Fragment, or 1 packet? */ - max_data_len = LOWPAN6_MAX_PAYLOAD - ieee_header_len - lowpan6_header_len; - if (remaining_len > max_data_len) { - u16_t data_len; - /* We must move the 6LowPAN header to make room for the FRAG header. */ - memmove(&buffer[ieee_header_len + 4], &buffer[ieee_header_len], lowpan6_header_len); - - /* Now we need to fragment the packet. FRAG1 header first */ - buffer[ieee_header_len] = 0xc0 | (((p->tot_len + hidden_header_len) >> 8) & 0x7); - buffer[ieee_header_len + 1] = (p->tot_len + hidden_header_len) & 0xff; - - lowpan6_data.tx_datagram_tag++; - buffer[ieee_header_len + 2] = (lowpan6_data.tx_datagram_tag >> 8) & 0xff; - buffer[ieee_header_len + 3] = lowpan6_data.tx_datagram_tag & 0xff; - - /* Fragment follows. */ - data_len = (max_data_len - 4) & 0xf8; - frag_len = data_len + lowpan6_header_len; - - pbuf_copy_partial(p, buffer + ieee_header_len + lowpan6_header_len + 4, frag_len - lowpan6_header_len, 0); - remaining_len -= frag_len - lowpan6_header_len; - /* datagram offset holds the offset before compression */ - datagram_offset = frag_len - lowpan6_header_len + hidden_header_len; - LWIP_ASSERT("datagram offset must be a multiple of 8", (datagram_offset & 7) == 0); - - /* Calculate frame length */ - p_frag->len = p_frag->tot_len = ieee_header_len + 4 + frag_len + 2; /* add 2 bytes for crc*/ - - /* 2 bytes CRC */ - crc = LWIP_6LOWPAN_DO_CALC_CRC(p_frag->payload, p_frag->len - 2); - pbuf_take_at(p_frag, &crc, 2, p_frag->len - 2); - - /* send the packet */ - MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); - LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG | LWIP_DBG_TRACE, ("lowpan6_send: sending packet %p\n", (void *)p)); - err = netif->linkoutput(netif, p_frag); - - while ((remaining_len > 0) && (err == ERR_OK)) { - struct ieee_802154_hdr *hdr = (struct ieee_802154_hdr *)buffer; - /* new frame, new seq num for ACK */ - hdr->sequence_number = lowpan6_data.tx_frame_seq_num++; - - buffer[ieee_header_len] |= 0x20; /* Change FRAG1 to FRAGN */ - - LWIP_ASSERT("datagram offset must be a multiple of 8", (datagram_offset & 7) == 0); - buffer[ieee_header_len + 4] = (u8_t)(datagram_offset >> 3); /* datagram offset in FRAGN header (datagram_offset is max. 11 bit) */ - - frag_len = (127 - ieee_header_len - 5 - 2) & 0xf8; - if (frag_len > remaining_len) { - frag_len = remaining_len; - } - - pbuf_copy_partial(p, buffer + ieee_header_len + 5, frag_len, p->tot_len - remaining_len); - remaining_len -= frag_len; - datagram_offset += frag_len; - - /* Calculate frame length */ - p_frag->len = p_frag->tot_len = frag_len + 5 + ieee_header_len + 2; - - /* 2 bytes CRC */ - crc = LWIP_6LOWPAN_DO_CALC_CRC(p_frag->payload, p_frag->len - 2); - pbuf_take_at(p_frag, &crc, 2, p_frag->len - 2); - - /* send the packet */ - MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); - LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG | LWIP_DBG_TRACE, ("lowpan6_send: sending packet %p\n", (void *)p)); - err = netif->linkoutput(netif, p_frag); - } - } else { - /* It fits in one frame. */ - frag_len = remaining_len; - - /* Copy IPv6 packet */ - pbuf_copy_partial(p, buffer + ieee_header_len + lowpan6_header_len, frag_len, 0); - remaining_len = 0; - - /* Calculate frame length */ - p_frag->len = p_frag->tot_len = frag_len + lowpan6_header_len + ieee_header_len + 2; - LWIP_ASSERT("", p_frag->len <= 127); - - /* 2 bytes CRC */ - crc = LWIP_6LOWPAN_DO_CALC_CRC(p_frag->payload, p_frag->len - 2); - pbuf_take_at(p_frag, &crc, 2, p_frag->len - 2); - - /* send the packet */ - MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); - LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG | LWIP_DBG_TRACE, ("lowpan6_send: sending packet %p\n", (void *)p)); - err = netif->linkoutput(netif, p_frag); - } - - pbuf_free(p_frag); - - return err; -} - -/** - * @ingroup sixlowpan - * Set context - */ -err_t -lowpan6_set_context(u8_t idx, const ip6_addr_t *context) -{ -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 - if (idx >= LWIP_6LOWPAN_NUM_CONTEXTS) { - return ERR_ARG; - } - - IP6_ADDR_ZONECHECK(context); - - ip6_addr_set(&lowpan6_data.lowpan6_context[idx], context); - - return ERR_OK; -#else - LWIP_UNUSED_ARG(idx); - LWIP_UNUSED_ARG(context); - return ERR_ARG; -#endif -} - -#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS -/** - * @ingroup sixlowpan - * Set short address - */ -err_t -lowpan6_set_short_addr(u8_t addr_high, u8_t addr_low) -{ - short_mac_addr.addr[0] = addr_high; - short_mac_addr.addr[1] = addr_low; - - return ERR_OK; -} -#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ - -/* Create IEEE 802.15.4 address from netif address */ -static err_t -lowpan6_hwaddr_to_addr(struct netif *netif, struct lowpan6_link_addr *addr) -{ - addr->addr_len = 8; - if (netif->hwaddr_len == 8) { - LWIP_ERROR("NETIF_MAX_HWADDR_LEN >= 8 required", sizeof(netif->hwaddr) >= 8, return ERR_VAL;); - SMEMCPY(addr->addr, netif->hwaddr, 8); - } else if (netif->hwaddr_len == 6) { - /* Copy from MAC-48 */ - SMEMCPY(addr->addr, netif->hwaddr, 3); - addr->addr[3] = addr->addr[4] = 0xff; - SMEMCPY(&addr->addr[5], &netif->hwaddr[3], 3); - } else { - /* Invalid address length, don't know how to convert this */ - return ERR_VAL; - } - return ERR_OK; -} - -/** - * @ingroup sixlowpan - * Resolve and fill-in IEEE 802.15.4 address header for outgoing IPv6 packet. - * - * Perform Header Compression and fragment if necessary. - * - * @param netif The lwIP network interface which the IP packet will be sent on. - * @param q The pbuf(s) containing the IP packet to be sent. - * @param ip6addr The IP address of the packet destination. - * - * @return err_t - */ -err_t -lowpan6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr) -{ - err_t result; - const u8_t *hwaddr; - struct lowpan6_link_addr src, dest; -#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS - ip6_addr_t ip6_src; - struct ip6_hdr *ip6_hdr; -#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ - -#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS - /* Check if we can compress source address (use aligned copy) */ - ip6_hdr = (struct ip6_hdr *)q->payload; - ip6_addr_copy_from_packed(ip6_src, ip6_hdr->src); - ip6_addr_assign_zone(&ip6_src, IP6_UNICAST, netif); - if (lowpan6_get_address_mode(&ip6_src, &short_mac_addr) == 3) { - src.addr_len = 2; - src.addr[0] = short_mac_addr.addr[0]; - src.addr[1] = short_mac_addr.addr[1]; - } else -#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ - { - result = lowpan6_hwaddr_to_addr(netif, &src); - if (result != ERR_OK) { - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - return result; - } - } - - /* multicast destination IP address? */ - if (ip6_addr_ismulticast(ip6addr)) { - MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts); - /* We need to send to the broadcast address.*/ - return lowpan6_frag(netif, q, &src, &ieee_802154_broadcast); - } - - /* We have a unicast destination IP address */ - /* @todo anycast? */ - -#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS - if (src.addr_len == 2) { - /* If source address was compressable to short_mac_addr, and dest has same subnet and - * is also compressable to 2-bytes, assume we can infer dest as a short address too. */ - dest.addr_len = 2; - dest.addr[0] = ((u8_t *)q->payload)[38]; - dest.addr[1] = ((u8_t *)q->payload)[39]; - if ((src.addr_len == 2) && (ip6_addr_netcmp_zoneless(&ip6_hdr->src, &ip6_hdr->dest)) && - (lowpan6_get_address_mode(ip6addr, &dest) == 3)) { - MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); - return lowpan6_frag(netif, q, &src, &dest); - } - } -#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ - - /* Ask ND6 what to do with the packet. */ - result = nd6_get_next_hop_addr_or_queue(netif, q, ip6addr, &hwaddr); - if (result != ERR_OK) { - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - return result; - } - - /* If no hardware address is returned, nd6 has queued the packet for later. */ - if (hwaddr == NULL) { - return ERR_OK; - } - - /* Send out the packet using the returned hardware address. */ - dest.addr_len = netif->hwaddr_len; - /* XXX: Inferring the length of the source address from the destination address - * is not correct for IEEE 802.15.4, but currently we don't get this information - * from the neighbor cache */ - SMEMCPY(dest.addr, hwaddr, netif->hwaddr_len); - MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); - return lowpan6_frag(netif, q, &src, &dest); -} -/** - * @ingroup sixlowpan - * NETIF input function: don't free the input pbuf when returning != ERR_OK! - */ -err_t -lowpan6_input(struct pbuf *p, struct netif *netif) -{ - u8_t *puc, b; - s8_t i; - struct lowpan6_link_addr src, dest; - u16_t datagram_size = 0; - u16_t datagram_offset, datagram_tag; - struct lowpan6_reass_helper *lrh, *lrh_next, *lrh_prev = NULL; - - if (p == NULL) { - return ERR_OK; - } - - MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len); - - if (p->len != p->tot_len) { - /* for now, this needs a pbuf in one piece */ - goto lowpan6_input_discard; - } - - if (lowpan6_parse_iee802154_header(p, &src, &dest) != ERR_OK) { - goto lowpan6_input_discard; - } - - /* Check dispatch. */ - puc = (u8_t *)p->payload; - - b = *puc; - if ((b & 0xf8) == 0xc0) { - /* FRAG1 dispatch. add this packet to reassembly list. */ - datagram_size = ((u16_t)(puc[0] & 0x07) << 8) | (u16_t)puc[1]; - datagram_tag = ((u16_t)puc[2] << 8) | (u16_t)puc[3]; - - /* check for duplicate */ - lrh = lowpan6_data.reass_list; - while (lrh != NULL) { - uint8_t discard = 0; - lrh_next = lrh->next_packet; - if ((lrh->sender_addr.addr_len == src.addr_len) && - (memcmp(lrh->sender_addr.addr, src.addr, src.addr_len) == 0)) { - /* address match with packet in reassembly. */ - if ((datagram_tag == lrh->datagram_tag) && (datagram_size == lrh->datagram_size)) { - /* duplicate fragment. */ - goto lowpan6_input_discard; - } else { - /* We are receiving the start of a new datagram. Discard old one (incomplete). */ - discard = 1; - } - } - if (discard) { - dequeue_datagram(lrh, lrh_prev); - free_reass_datagram(lrh); - } else { - lrh_prev = lrh; - } - /* Check next datagram in queue. */ - lrh = lrh_next; - } - - pbuf_remove_header(p, 4); /* hide frag1 dispatch */ - - lrh = (struct lowpan6_reass_helper *) mem_malloc(sizeof(struct lowpan6_reass_helper)); - if (lrh == NULL) { - goto lowpan6_input_discard; - } - - lrh->sender_addr.addr_len = src.addr_len; - for (i = 0; i < src.addr_len; i++) { - lrh->sender_addr.addr[i] = src.addr[i]; - } - lrh->datagram_size = datagram_size; - lrh->datagram_tag = datagram_tag; - lrh->frags = NULL; - if (*(u8_t *)p->payload == 0x41) { - /* This is a complete IPv6 packet, just skip dispatch byte. */ - pbuf_remove_header(p, 1); /* hide dispatch byte. */ - lrh->reass = p; - } else if ((*(u8_t *)p->payload & 0xe0 ) == 0x60) { - lrh->reass = lowpan6_decompress(p, datagram_size, LWIP_6LOWPAN_CONTEXTS(netif), &src, &dest); - if (lrh->reass == NULL) { - /* decompression failed */ - mem_free(lrh); - goto lowpan6_input_discard; - } - } - /* TODO: handle the case where we already have FRAGN received */ - lrh->next_packet = lowpan6_data.reass_list; - lrh->timer = 2; - lowpan6_data.reass_list = lrh; - - return ERR_OK; - } else if ((b & 0xf8) == 0xe0) { - /* FRAGN dispatch, find packet being reassembled. */ - datagram_size = ((u16_t)(puc[0] & 0x07) << 8) | (u16_t)puc[1]; - datagram_tag = ((u16_t)puc[2] << 8) | (u16_t)puc[3]; - datagram_offset = (u16_t)puc[4] << 3; - pbuf_remove_header(p, 4); /* hide frag1 dispatch but keep datagram offset for reassembly */ - - for (lrh = lowpan6_data.reass_list; lrh != NULL; lrh_prev = lrh, lrh = lrh->next_packet) { - if ((lrh->sender_addr.addr_len == src.addr_len) && - (memcmp(lrh->sender_addr.addr, src.addr, src.addr_len) == 0) && - (datagram_tag == lrh->datagram_tag) && - (datagram_size == lrh->datagram_size)) { - break; - } - } - if (lrh == NULL) { - /* rogue fragment */ - goto lowpan6_input_discard; - } - /* Insert new pbuf into list of fragments. Each fragment is a pbuf, - this only works for unchained pbufs. */ - LWIP_ASSERT("p->next == NULL", p->next == NULL); - if (lrh->reass != NULL) { - /* FRAG1 already received, check this offset against first len */ - if (datagram_offset < lrh->reass->len) { - /* fragment overlap, discard old fragments */ - dequeue_datagram(lrh, lrh_prev); - free_reass_datagram(lrh); - goto lowpan6_input_discard; - } - } - if (lrh->frags == NULL) { - /* first FRAGN */ - lrh->frags = p; - } else { - /* find the correct place to insert */ - struct pbuf *q, *last; - u16_t new_frag_len = p->len - 1; /* p->len includes datagram_offset byte */ - for (q = lrh->frags, last = NULL; q != NULL; last = q, q = q->next) { - u16_t q_datagram_offset = ((u8_t *)q->payload)[0] << 3; - u16_t q_frag_len = q->len - 1; - if (datagram_offset < q_datagram_offset) { - if (datagram_offset + new_frag_len > q_datagram_offset) { - /* overlap, discard old fragments */ - dequeue_datagram(lrh, lrh_prev); - free_reass_datagram(lrh); - goto lowpan6_input_discard; - } - /* insert here */ - break; - } else if (datagram_offset == q_datagram_offset) { - if (q_frag_len != new_frag_len) { - /* fragment mismatch, discard old fragments */ - dequeue_datagram(lrh, lrh_prev); - free_reass_datagram(lrh); - goto lowpan6_input_discard; - } - /* duplicate, ignore */ - pbuf_free(p); - return ERR_OK; - } - } - /* insert fragment */ - if (last == NULL) { - lrh->frags = p; - } else { - last->next = p; - p->next = q; - } - } - /* check if all fragments were received */ - if (lrh->reass) { - u16_t offset = lrh->reass->len; - struct pbuf *q; - for (q = lrh->frags; q != NULL; q = q->next) { - u16_t q_datagram_offset = ((u8_t *)q->payload)[0] << 3; - if (q_datagram_offset != offset) { - /* not complete, wait for more fragments */ - return ERR_OK; - } - offset += q->len - 1; - } - if (offset == datagram_size) { - /* all fragments received, combine pbufs */ - u16_t datagram_left = datagram_size - lrh->reass->len; - for (q = lrh->frags; q != NULL; q = q->next) { - /* hide datagram_offset byte now */ - pbuf_remove_header(q, 1); - q->tot_len = datagram_left; - datagram_left -= q->len; - } - LWIP_ASSERT("datagram_left == 0", datagram_left == 0); - q = lrh->reass; - q->tot_len = datagram_size; - q->next = lrh->frags; - lrh->frags = NULL; - lrh->reass = NULL; - dequeue_datagram(lrh, lrh_prev); - mem_free(lrh); - - /* @todo: distinguish unicast/multicast */ - MIB2_STATS_NETIF_INC(netif, ifinucastpkts); - return ip6_input(q, netif); - } - } - /* pbuf enqueued, waiting for more fragments */ - return ERR_OK; - } else { - if (b == 0x41) { - /* This is a complete IPv6 packet, just skip dispatch byte. */ - pbuf_remove_header(p, 1); /* hide dispatch byte. */ - } else if ((b & 0xe0 ) == 0x60) { - /* IPv6 headers are compressed using IPHC. */ - p = lowpan6_decompress(p, datagram_size, LWIP_6LOWPAN_CONTEXTS(netif), &src, &dest); - if (p == NULL) { - MIB2_STATS_NETIF_INC(netif, ifindiscards); - return ERR_OK; - } - } else { - goto lowpan6_input_discard; - } - - /* @todo: distinguish unicast/multicast */ - MIB2_STATS_NETIF_INC(netif, ifinucastpkts); - - return ip6_input(p, netif); - } -lowpan6_input_discard: - MIB2_STATS_NETIF_INC(netif, ifindiscards); - pbuf_free(p); - /* always return ERR_OK here to prevent the caller freeing the pbuf */ - return ERR_OK; -} - -/** - * @ingroup sixlowpan - */ -err_t -lowpan6_if_init(struct netif *netif) -{ - netif->name[0] = 'L'; - netif->name[1] = '6'; - netif->output_ip6 = lowpan6_output; - - MIB2_INIT_NETIF(netif, snmp_ifType_other, 0); - - /* maximum transfer unit */ - netif->mtu = 1280; - - /* broadcast capability */ - netif->flags = NETIF_FLAG_BROADCAST /* | NETIF_FLAG_LOWPAN6 */; - - return ERR_OK; -} - -/** - * @ingroup sixlowpan - * Set PAN ID - */ -err_t -lowpan6_set_pan_id(u16_t pan_id) -{ - lowpan6_data.ieee_802154_pan_id = pan_id; - - return ERR_OK; -} - -#if !NO_SYS -/** - * @ingroup sixlowpan - * Pass a received packet to tcpip_thread for input processing - * - * @param p the received packet, p->payload pointing to the - * IEEE 802.15.4 header. - * @param inp the network interface on which the packet was received - */ -err_t -tcpip_6lowpan_input(struct pbuf *p, struct netif *inp) -{ - return tcpip_inpkt(p, inp, lowpan6_input); -} -#endif /* !NO_SYS */ - -#endif /* LWIP_IPV6 */ +/** + * @file + * + * 6LowPAN output for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. + * + * This implementation aims to conform to IEEE 802.15.4(-2015), RFC 4944 and RFC 6282. + * @todo: RFC 6775. + */ + +/* + * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +/** + * @defgroup sixlowpan 6LoWPAN (RFC4944) + * @ingroup netifs + * 6LowPAN netif implementation + */ + +#include "netif/lowpan6.h" + +#if LWIP_IPV6 + +#include "lwip/ip.h" +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/nd6.h" +#include "lwip/mem.h" +#include "lwip/udp.h" +#include "lwip/tcpip.h" +#include "lwip/snmp.h" +#include "netif/ieee802154.h" + +#include + +#if LWIP_6LOWPAN_802154_HW_CRC +#define LWIP_6LOWPAN_DO_CALC_CRC(buf, len) 0 +#else +#define LWIP_6LOWPAN_DO_CALC_CRC(buf, len) LWIP_6LOWPAN_CALC_CRC(buf, len) +#endif + +/** This is a helper struct for reassembly of fragments + * (IEEE 802.15.4 limits to 127 bytes) + */ +struct lowpan6_reass_helper { + struct lowpan6_reass_helper *next_packet; + struct pbuf *reass; + struct pbuf *frags; + u8_t timer; + struct lowpan6_link_addr sender_addr; + u16_t datagram_size; + u16_t datagram_tag; +}; + +/** This struct keeps track of per-netif state */ +struct lowpan6_ieee802154_data { + /** fragment reassembly list */ + struct lowpan6_reass_helper *reass_list; +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 + /** address context for compression */ + ip6_addr_t lowpan6_context[LWIP_6LOWPAN_NUM_CONTEXTS]; +#endif + /** Datagram Tag for fragmentation */ + u16_t tx_datagram_tag; + /** local PAN ID for IEEE 802.15.4 header */ + u16_t ieee_802154_pan_id; + /** Sequence Number for IEEE 802.15.4 transmission */ + u8_t tx_frame_seq_num; +}; + +/* Maximum frame size is 127 bytes minus CRC size */ +#define LOWPAN6_MAX_PAYLOAD (127 - 2) + +/** Currently, this state is global, since there's only one 6LoWPAN netif */ +static struct lowpan6_ieee802154_data lowpan6_data; + +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 +#define LWIP_6LOWPAN_CONTEXTS(netif) lowpan6_data.lowpan6_context +#else +#define LWIP_6LOWPAN_CONTEXTS(netif) NULL +#endif + +static const struct lowpan6_link_addr ieee_802154_broadcast = {2, {0xff, 0xff}}; + +#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS +static struct lowpan6_link_addr short_mac_addr = {2, {0, 0}}; +#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ + +/* IEEE 802.15.4 specific functions: */ + +/** Write the IEEE 802.15.4 header that encapsulates the 6LoWPAN frame. + * Src and dst PAN IDs are filled with the ID set by @ref lowpan6_set_pan_id. + * + * Since the length is variable: + * @returns the header length + */ +static u8_t +lowpan6_write_iee802154_header(struct ieee_802154_hdr *hdr, const struct lowpan6_link_addr *src, + const struct lowpan6_link_addr *dst) +{ + u8_t ieee_header_len; + u8_t *buffer; + u8_t i; + u16_t fc; + + fc = IEEE_802154_FC_FT_DATA; /* send data packet (2003 frame version) */ + fc |= IEEE_802154_FC_PANID_COMPR; /* set PAN ID compression, for now src and dst PANs are equal */ + if (dst != &ieee_802154_broadcast) { + fc |= IEEE_802154_FC_ACK_REQ; /* data packet, no broadcast: ack required. */ + } + if (dst->addr_len == 2) { + fc |= IEEE_802154_FC_DST_ADDR_MODE_SHORT; + } else { + LWIP_ASSERT("invalid dst address length", dst->addr_len == 8); + fc |= IEEE_802154_FC_DST_ADDR_MODE_EXT; + } + if (src->addr_len == 2) { + fc |= IEEE_802154_FC_SRC_ADDR_MODE_SHORT; + } else { + LWIP_ASSERT("invalid src address length", src->addr_len == 8); + fc |= IEEE_802154_FC_SRC_ADDR_MODE_EXT; + } + hdr->frame_control = fc; + hdr->sequence_number = lowpan6_data.tx_frame_seq_num++; + hdr->destination_pan_id = lowpan6_data.ieee_802154_pan_id; /* pan id */ + + buffer = (u8_t *)hdr; + ieee_header_len = 5; + i = dst->addr_len; + /* reverse memcpy of dst addr */ + while (i-- > 0) { + buffer[ieee_header_len++] = dst->addr[i]; + } + /* Source PAN ID skipped due to PAN ID Compression */ + i = src->addr_len; + /* reverse memcpy of src addr */ + while (i-- > 0) { + buffer[ieee_header_len++] = src->addr[i]; + } + return ieee_header_len; +} + +/** Parse the IEEE 802.15.4 header from a pbuf. + * If successful, the header is hidden from the pbuf. + * + * PAN IDs and seuqence number are not checked + * + * @param p input pbuf, p->payload pointing at the IEEE 802.15.4 header + * @param src pointer to source address filled from the header + * @param dest pointer to destination address filled from the header + * @returns ERR_OK if successful + */ +static err_t +lowpan6_parse_iee802154_header(struct pbuf *p, struct lowpan6_link_addr *src, + struct lowpan6_link_addr *dest) +{ + u8_t *puc; + s8_t i; + u16_t frame_control, addr_mode; + u16_t datagram_offset; + + /* Parse IEEE 802.15.4 header */ + puc = (u8_t *)p->payload; + frame_control = puc[0] | (puc[1] << 8); + datagram_offset = 2; + if (frame_control & IEEE_802154_FC_SEQNO_SUPPR) { + if (IEEE_802154_FC_FRAME_VERSION_GET(frame_control) <= 1) { + /* sequence number suppressed, this is not valid for versions 0/1 */ + return ERR_VAL; + } + } else { + datagram_offset++; + } + datagram_offset += 2; /* Skip destination PAN ID */ + addr_mode = frame_control & IEEE_802154_FC_DST_ADDR_MODE_MASK; + if (addr_mode == IEEE_802154_FC_DST_ADDR_MODE_EXT) { + /* extended address (64 bit) */ + dest->addr_len = 8; + /* reverse memcpy: */ + for (i = 0; i < 8; i++) { + dest->addr[i] = puc[datagram_offset + 7 - i]; + } + datagram_offset += 8; + } else if (addr_mode == IEEE_802154_FC_DST_ADDR_MODE_SHORT) { + /* short address (16 bit) */ + dest->addr_len = 2; + /* reverse memcpy: */ + dest->addr[0] = puc[datagram_offset + 1]; + dest->addr[1] = puc[datagram_offset]; + datagram_offset += 2; + } else { + /* unsupported address mode (do we need "no address"?) */ + return ERR_VAL; + } + + if (!(frame_control & IEEE_802154_FC_PANID_COMPR)) { + /* No PAN ID compression, skip source PAN ID */ + datagram_offset += 2; + } + + addr_mode = frame_control & IEEE_802154_FC_SRC_ADDR_MODE_MASK; + if (addr_mode == IEEE_802154_FC_SRC_ADDR_MODE_EXT) { + /* extended address (64 bit) */ + src->addr_len = 8; + /* reverse memcpy: */ + for (i = 0; i < 8; i++) { + src->addr[i] = puc[datagram_offset + 7 - i]; + } + datagram_offset += 8; + } else if (addr_mode == IEEE_802154_FC_DST_ADDR_MODE_SHORT) { + /* short address (16 bit) */ + src->addr_len = 2; + src->addr[0] = puc[datagram_offset + 1]; + src->addr[1] = puc[datagram_offset]; + datagram_offset += 2; + } else { + /* unsupported address mode (do we need "no address"?) */ + return ERR_VAL; + } + + /* hide IEEE802.15.4 header. */ + if (pbuf_remove_header(p, datagram_offset)) { + return ERR_VAL; + } + return ERR_OK; +} + +/** Calculate the 16-bit CRC as required by IEEE 802.15.4 */ +u16_t +lowpan6_calc_crc(const void* buf, u16_t len) +{ +#define CCITT_POLY_16 0x8408U + u16_t i; + u8_t b; + u16_t crc = 0; + const u8_t* p = (const u8_t*)buf; + + for (i = 0; i < len; i++) { + u8_t data = *p; + for (b = 0U; b < 8U; b++) { + if (((data ^ crc) & 1) != 0) { + crc = (u16_t)((crc >> 1) ^ CCITT_POLY_16); + } else { + crc = (u16_t)(crc >> 1); + } + data = (u8_t)(data >> 1); + } + p++; + } + return crc; +} + +/* Fragmentation specific functions: */ + +static void +free_reass_datagram(struct lowpan6_reass_helper *lrh) +{ + if (lrh->reass) { + pbuf_free(lrh->reass); + } + if (lrh->frags) { + pbuf_free(lrh->frags); + } + mem_free(lrh); +} + +/** + * Removes a datagram from the reassembly queue. + **/ +static void +dequeue_datagram(struct lowpan6_reass_helper *lrh, struct lowpan6_reass_helper *prev) +{ + if (lowpan6_data.reass_list == lrh) { + lowpan6_data.reass_list = lowpan6_data.reass_list->next_packet; + } else { + /* it wasn't the first, so it must have a valid 'prev' */ + LWIP_ASSERT("sanity check linked list", prev != NULL); + prev->next_packet = lrh->next_packet; + } +} + +/** + * Periodic timer for 6LowPAN functions: + * + * - Remove incomplete/old packets + */ +void +lowpan6_tmr(void) +{ + struct lowpan6_reass_helper *lrh, *lrh_next, *lrh_prev = NULL; + + lrh = lowpan6_data.reass_list; + while (lrh != NULL) { + lrh_next = lrh->next_packet; + if ((--lrh->timer) == 0) { + dequeue_datagram(lrh, lrh_prev); + free_reass_datagram(lrh); + } else { + lrh_prev = lrh; + } + lrh = lrh_next; + } +} + +/* + * Encapsulates data into IEEE 802.15.4 frames. + * Fragments an IPv6 datagram into 6LowPAN units, which fit into IEEE 802.15.4 frames. + * If configured, will compress IPv6 and or UDP headers. + * */ +static err_t +lowpan6_frag(struct netif *netif, struct pbuf *p, const struct lowpan6_link_addr *src, const struct lowpan6_link_addr *dst) +{ + struct pbuf *p_frag; + u16_t frag_len, remaining_len, max_data_len; + u8_t *buffer; + u8_t ieee_header_len; + u8_t lowpan6_header_len; + u8_t hidden_header_len; + u16_t crc; + u16_t datagram_offset; + err_t err = ERR_IF; + + LWIP_ASSERT("lowpan6_frag: netif->linkoutput not set", netif->linkoutput != NULL); + + /* We'll use a dedicated pbuf for building 6LowPAN fragments. */ + p_frag = pbuf_alloc(PBUF_RAW, 127, PBUF_RAM); + if (p_frag == NULL) { + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + return ERR_MEM; + } + LWIP_ASSERT("this needs a pbuf in one piece", p_frag->len == p_frag->tot_len); + + /* Write IEEE 802.15.4 header. */ + buffer = (u8_t *)p_frag->payload; + ieee_header_len = lowpan6_write_iee802154_header((struct ieee_802154_hdr *)buffer, src, dst); + LWIP_ASSERT("ieee_header_len < p_frag->len", ieee_header_len < p_frag->len); + +#if LWIP_6LOWPAN_IPHC + /* Perform 6LowPAN IPv6 header compression according to RFC 6282 */ + /* do the header compression (this does NOT copy any non-compressed data) */ + err = lowpan6_compress_headers(netif, (u8_t *)p->payload, p->len, + &buffer[ieee_header_len], p_frag->len - ieee_header_len, &lowpan6_header_len, + &hidden_header_len, LWIP_6LOWPAN_CONTEXTS(netif), src, dst); + if (err != ERR_OK) { + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + pbuf_free(p_frag); + return err; + } + pbuf_remove_header(p, hidden_header_len); + +#else /* LWIP_6LOWPAN_IPHC */ + /* Send uncompressed IPv6 header with appropriate dispatch byte. */ + lowpan6_header_len = 1; + buffer[ieee_header_len] = 0x41; /* IPv6 dispatch */ +#endif /* LWIP_6LOWPAN_IPHC */ + + /* Calculate remaining packet length */ + remaining_len = p->tot_len; + + if (remaining_len > 0x7FF) { + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + /* datagram_size must fit into 11 bit */ + pbuf_free(p_frag); + return ERR_VAL; + } + + /* Fragment, or 1 packet? */ + max_data_len = LOWPAN6_MAX_PAYLOAD - ieee_header_len - lowpan6_header_len; + if (remaining_len > max_data_len) { + u16_t data_len; + /* We must move the 6LowPAN header to make room for the FRAG header. */ + memmove(&buffer[ieee_header_len + 4], &buffer[ieee_header_len], lowpan6_header_len); + + /* Now we need to fragment the packet. FRAG1 header first */ + buffer[ieee_header_len] = 0xc0 | (((p->tot_len + hidden_header_len) >> 8) & 0x7); + buffer[ieee_header_len + 1] = (p->tot_len + hidden_header_len) & 0xff; + + lowpan6_data.tx_datagram_tag++; + buffer[ieee_header_len + 2] = (lowpan6_data.tx_datagram_tag >> 8) & 0xff; + buffer[ieee_header_len + 3] = lowpan6_data.tx_datagram_tag & 0xff; + + /* Fragment follows. */ + data_len = (max_data_len - 4) & 0xf8; + frag_len = data_len + lowpan6_header_len; + + pbuf_copy_partial(p, buffer + ieee_header_len + lowpan6_header_len + 4, frag_len - lowpan6_header_len, 0); + remaining_len -= frag_len - lowpan6_header_len; + /* datagram offset holds the offset before compression */ + datagram_offset = frag_len - lowpan6_header_len + hidden_header_len; + LWIP_ASSERT("datagram offset must be a multiple of 8", (datagram_offset & 7) == 0); + + /* Calculate frame length */ + p_frag->len = p_frag->tot_len = ieee_header_len + 4 + frag_len + 2; /* add 2 bytes for crc*/ + + /* 2 bytes CRC */ + crc = LWIP_6LOWPAN_DO_CALC_CRC(p_frag->payload, p_frag->len - 2); + pbuf_take_at(p_frag, &crc, 2, p_frag->len - 2); + + /* send the packet */ + MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); + LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG | LWIP_DBG_TRACE, ("lowpan6_send: sending packet %p\n", (void *)p)); + err = netif->linkoutput(netif, p_frag); + + while ((remaining_len > 0) && (err == ERR_OK)) { + struct ieee_802154_hdr *hdr = (struct ieee_802154_hdr *)buffer; + /* new frame, new seq num for ACK */ + hdr->sequence_number = lowpan6_data.tx_frame_seq_num++; + + buffer[ieee_header_len] |= 0x20; /* Change FRAG1 to FRAGN */ + + LWIP_ASSERT("datagram offset must be a multiple of 8", (datagram_offset & 7) == 0); + buffer[ieee_header_len + 4] = (u8_t)(datagram_offset >> 3); /* datagram offset in FRAGN header (datagram_offset is max. 11 bit) */ + + frag_len = (127 - ieee_header_len - 5 - 2) & 0xf8; + if (frag_len > remaining_len) { + frag_len = remaining_len; + } + + pbuf_copy_partial(p, buffer + ieee_header_len + 5, frag_len, p->tot_len - remaining_len); + remaining_len -= frag_len; + datagram_offset += frag_len; + + /* Calculate frame length */ + p_frag->len = p_frag->tot_len = frag_len + 5 + ieee_header_len + 2; + + /* 2 bytes CRC */ + crc = LWIP_6LOWPAN_DO_CALC_CRC(p_frag->payload, p_frag->len - 2); + pbuf_take_at(p_frag, &crc, 2, p_frag->len - 2); + + /* send the packet */ + MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); + LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG | LWIP_DBG_TRACE, ("lowpan6_send: sending packet %p\n", (void *)p)); + err = netif->linkoutput(netif, p_frag); + } + } else { + /* It fits in one frame. */ + frag_len = remaining_len; + + /* Copy IPv6 packet */ + pbuf_copy_partial(p, buffer + ieee_header_len + lowpan6_header_len, frag_len, 0); + remaining_len = 0; + + /* Calculate frame length */ + p_frag->len = p_frag->tot_len = frag_len + lowpan6_header_len + ieee_header_len + 2; + LWIP_ASSERT("", p_frag->len <= 127); + + /* 2 bytes CRC */ + crc = LWIP_6LOWPAN_DO_CALC_CRC(p_frag->payload, p_frag->len - 2); + pbuf_take_at(p_frag, &crc, 2, p_frag->len - 2); + + /* send the packet */ + MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); + LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG | LWIP_DBG_TRACE, ("lowpan6_send: sending packet %p\n", (void *)p)); + err = netif->linkoutput(netif, p_frag); + } + + pbuf_free(p_frag); + + return err; +} + +/** + * @ingroup sixlowpan + * Set context + */ +err_t +lowpan6_set_context(u8_t idx, const ip6_addr_t *context) +{ +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 + if (idx >= LWIP_6LOWPAN_NUM_CONTEXTS) { + return ERR_ARG; + } + + IP6_ADDR_ZONECHECK(context); + + ip6_addr_set(&lowpan6_data.lowpan6_context[idx], context); + + return ERR_OK; +#else + LWIP_UNUSED_ARG(idx); + LWIP_UNUSED_ARG(context); + return ERR_ARG; +#endif +} + +#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS +/** + * @ingroup sixlowpan + * Set short address + */ +err_t +lowpan6_set_short_addr(u8_t addr_high, u8_t addr_low) +{ + short_mac_addr.addr[0] = addr_high; + short_mac_addr.addr[1] = addr_low; + + return ERR_OK; +} +#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ + +/* Create IEEE 802.15.4 address from netif address */ +static err_t +lowpan6_hwaddr_to_addr(struct netif *netif, struct lowpan6_link_addr *addr) +{ + addr->addr_len = 8; + if (netif->hwaddr_len == 8) { + LWIP_ERROR("NETIF_MAX_HWADDR_LEN >= 8 required", sizeof(netif->hwaddr) >= 8, return ERR_VAL;); + SMEMCPY(addr->addr, netif->hwaddr, 8); + } else if (netif->hwaddr_len == 6) { + /* Copy from MAC-48 */ + SMEMCPY(addr->addr, netif->hwaddr, 3); + addr->addr[3] = addr->addr[4] = 0xff; + SMEMCPY(&addr->addr[5], &netif->hwaddr[3], 3); + } else { + /* Invalid address length, don't know how to convert this */ + return ERR_VAL; + } + return ERR_OK; +} + +/** + * @ingroup sixlowpan + * Resolve and fill-in IEEE 802.15.4 address header for outgoing IPv6 packet. + * + * Perform Header Compression and fragment if necessary. + * + * @param netif The lwIP network interface which the IP packet will be sent on. + * @param q The pbuf(s) containing the IP packet to be sent. + * @param ip6addr The IP address of the packet destination. + * + * @return err_t + */ +err_t +lowpan6_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr) +{ + err_t result; + const u8_t *hwaddr; + struct lowpan6_link_addr src, dest; +#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS + ip6_addr_t ip6_src; + struct ip6_hdr *ip6_hdr; +#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ + +#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS + /* Check if we can compress source address (use aligned copy) */ + ip6_hdr = (struct ip6_hdr *)q->payload; + ip6_addr_copy_from_packed(ip6_src, ip6_hdr->src); + ip6_addr_assign_zone(&ip6_src, IP6_UNICAST, netif); + if (lowpan6_get_address_mode(&ip6_src, &short_mac_addr) == 3) { + src.addr_len = 2; + src.addr[0] = short_mac_addr.addr[0]; + src.addr[1] = short_mac_addr.addr[1]; + } else +#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ + { + result = lowpan6_hwaddr_to_addr(netif, &src); + if (result != ERR_OK) { + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + return result; + } + } + + /* multicast destination IP address? */ + if (ip6_addr_ismulticast(ip6addr)) { + MIB2_STATS_NETIF_INC(netif, ifoutnucastpkts); + /* We need to send to the broadcast address.*/ + return lowpan6_frag(netif, q, &src, &ieee_802154_broadcast); + } + + /* We have a unicast destination IP address */ + /* @todo anycast? */ + +#if LWIP_6LOWPAN_INFER_SHORT_ADDRESS + if (src.addr_len == 2) { + /* If source address was compressable to short_mac_addr, and dest has same subnet and + * is also compressable to 2-bytes, assume we can infer dest as a short address too. */ + dest.addr_len = 2; + dest.addr[0] = ((u8_t *)q->payload)[38]; + dest.addr[1] = ((u8_t *)q->payload)[39]; + if ((src.addr_len == 2) && (ip6_addr_netcmp_zoneless(&ip6_hdr->src, &ip6_hdr->dest)) && + (lowpan6_get_address_mode(ip6addr, &dest) == 3)) { + MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); + return lowpan6_frag(netif, q, &src, &dest); + } + } +#endif /* LWIP_6LOWPAN_INFER_SHORT_ADDRESS */ + + /* Ask ND6 what to do with the packet. */ + result = nd6_get_next_hop_addr_or_queue(netif, q, ip6addr, &hwaddr); + if (result != ERR_OK) { + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + return result; + } + + /* If no hardware address is returned, nd6 has queued the packet for later. */ + if (hwaddr == NULL) { + return ERR_OK; + } + + /* Send out the packet using the returned hardware address. */ + dest.addr_len = netif->hwaddr_len; + /* XXX: Inferring the length of the source address from the destination address + * is not correct for IEEE 802.15.4, but currently we don't get this information + * from the neighbor cache */ + SMEMCPY(dest.addr, hwaddr, netif->hwaddr_len); + MIB2_STATS_NETIF_INC(netif, ifoutucastpkts); + return lowpan6_frag(netif, q, &src, &dest); +} +/** + * @ingroup sixlowpan + * NETIF input function: don't free the input pbuf when returning != ERR_OK! + */ +err_t +lowpan6_input(struct pbuf *p, struct netif *netif) +{ + u8_t *puc, b; + s8_t i; + struct lowpan6_link_addr src, dest; + u16_t datagram_size = 0; + u16_t datagram_offset, datagram_tag; + struct lowpan6_reass_helper *lrh, *lrh_next, *lrh_prev = NULL; + + if (p == NULL) { + return ERR_OK; + } + + MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len); + + if (p->len != p->tot_len) { + /* for now, this needs a pbuf in one piece */ + goto lowpan6_input_discard; + } + + if (lowpan6_parse_iee802154_header(p, &src, &dest) != ERR_OK) { + goto lowpan6_input_discard; + } + + /* Check dispatch. */ + puc = (u8_t *)p->payload; + + b = *puc; + if ((b & 0xf8) == 0xc0) { + /* FRAG1 dispatch. add this packet to reassembly list. */ + datagram_size = ((u16_t)(puc[0] & 0x07) << 8) | (u16_t)puc[1]; + datagram_tag = ((u16_t)puc[2] << 8) | (u16_t)puc[3]; + + /* check for duplicate */ + lrh = lowpan6_data.reass_list; + while (lrh != NULL) { + uint8_t discard = 0; + lrh_next = lrh->next_packet; + if ((lrh->sender_addr.addr_len == src.addr_len) && + (memcmp(lrh->sender_addr.addr, src.addr, src.addr_len) == 0)) { + /* address match with packet in reassembly. */ + if ((datagram_tag == lrh->datagram_tag) && (datagram_size == lrh->datagram_size)) { + /* duplicate fragment. */ + goto lowpan6_input_discard; + } else { + /* We are receiving the start of a new datagram. Discard old one (incomplete). */ + discard = 1; + } + } + if (discard) { + dequeue_datagram(lrh, lrh_prev); + free_reass_datagram(lrh); + } else { + lrh_prev = lrh; + } + /* Check next datagram in queue. */ + lrh = lrh_next; + } + + pbuf_remove_header(p, 4); /* hide frag1 dispatch */ + + lrh = (struct lowpan6_reass_helper *) mem_malloc(sizeof(struct lowpan6_reass_helper)); + if (lrh == NULL) { + goto lowpan6_input_discard; + } + + lrh->sender_addr.addr_len = src.addr_len; + for (i = 0; i < src.addr_len; i++) { + lrh->sender_addr.addr[i] = src.addr[i]; + } + lrh->datagram_size = datagram_size; + lrh->datagram_tag = datagram_tag; + lrh->frags = NULL; + if (*(u8_t *)p->payload == 0x41) { + /* This is a complete IPv6 packet, just skip dispatch byte. */ + pbuf_remove_header(p, 1); /* hide dispatch byte. */ + lrh->reass = p; + } else if ((*(u8_t *)p->payload & 0xe0 ) == 0x60) { + lrh->reass = lowpan6_decompress(p, datagram_size, LWIP_6LOWPAN_CONTEXTS(netif), &src, &dest); + if (lrh->reass == NULL) { + /* decompression failed */ + mem_free(lrh); + goto lowpan6_input_discard; + } + } + /* TODO: handle the case where we already have FRAGN received */ + lrh->next_packet = lowpan6_data.reass_list; + lrh->timer = 2; + lowpan6_data.reass_list = lrh; + + return ERR_OK; + } else if ((b & 0xf8) == 0xe0) { + /* FRAGN dispatch, find packet being reassembled. */ + datagram_size = ((u16_t)(puc[0] & 0x07) << 8) | (u16_t)puc[1]; + datagram_tag = ((u16_t)puc[2] << 8) | (u16_t)puc[3]; + datagram_offset = (u16_t)puc[4] << 3; + pbuf_remove_header(p, 4); /* hide frag1 dispatch but keep datagram offset for reassembly */ + + for (lrh = lowpan6_data.reass_list; lrh != NULL; lrh_prev = lrh, lrh = lrh->next_packet) { + if ((lrh->sender_addr.addr_len == src.addr_len) && + (memcmp(lrh->sender_addr.addr, src.addr, src.addr_len) == 0) && + (datagram_tag == lrh->datagram_tag) && + (datagram_size == lrh->datagram_size)) { + break; + } + } + if (lrh == NULL) { + /* rogue fragment */ + goto lowpan6_input_discard; + } + /* Insert new pbuf into list of fragments. Each fragment is a pbuf, + this only works for unchained pbufs. */ + LWIP_ASSERT("p->next == NULL", p->next == NULL); + if (lrh->reass != NULL) { + /* FRAG1 already received, check this offset against first len */ + if (datagram_offset < lrh->reass->len) { + /* fragment overlap, discard old fragments */ + dequeue_datagram(lrh, lrh_prev); + free_reass_datagram(lrh); + goto lowpan6_input_discard; + } + } + if (lrh->frags == NULL) { + /* first FRAGN */ + lrh->frags = p; + } else { + /* find the correct place to insert */ + struct pbuf *q, *last; + u16_t new_frag_len = p->len - 1; /* p->len includes datagram_offset byte */ + for (q = lrh->frags, last = NULL; q != NULL; last = q, q = q->next) { + u16_t q_datagram_offset = ((u8_t *)q->payload)[0] << 3; + u16_t q_frag_len = q->len - 1; + if (datagram_offset < q_datagram_offset) { + if (datagram_offset + new_frag_len > q_datagram_offset) { + /* overlap, discard old fragments */ + dequeue_datagram(lrh, lrh_prev); + free_reass_datagram(lrh); + goto lowpan6_input_discard; + } + /* insert here */ + break; + } else if (datagram_offset == q_datagram_offset) { + if (q_frag_len != new_frag_len) { + /* fragment mismatch, discard old fragments */ + dequeue_datagram(lrh, lrh_prev); + free_reass_datagram(lrh); + goto lowpan6_input_discard; + } + /* duplicate, ignore */ + pbuf_free(p); + return ERR_OK; + } + } + /* insert fragment */ + if (last == NULL) { + lrh->frags = p; + } else { + last->next = p; + p->next = q; + } + } + /* check if all fragments were received */ + if (lrh->reass) { + u16_t offset = lrh->reass->len; + struct pbuf *q; + for (q = lrh->frags; q != NULL; q = q->next) { + u16_t q_datagram_offset = ((u8_t *)q->payload)[0] << 3; + if (q_datagram_offset != offset) { + /* not complete, wait for more fragments */ + return ERR_OK; + } + offset += q->len - 1; + } + if (offset == datagram_size) { + /* all fragments received, combine pbufs */ + u16_t datagram_left = datagram_size - lrh->reass->len; + for (q = lrh->frags; q != NULL; q = q->next) { + /* hide datagram_offset byte now */ + pbuf_remove_header(q, 1); + q->tot_len = datagram_left; + datagram_left -= q->len; + } + LWIP_ASSERT("datagram_left == 0", datagram_left == 0); + q = lrh->reass; + q->tot_len = datagram_size; + q->next = lrh->frags; + lrh->frags = NULL; + lrh->reass = NULL; + dequeue_datagram(lrh, lrh_prev); + mem_free(lrh); + + /* @todo: distinguish unicast/multicast */ + MIB2_STATS_NETIF_INC(netif, ifinucastpkts); + return ip6_input(q, netif); + } + } + /* pbuf enqueued, waiting for more fragments */ + return ERR_OK; + } else { + if (b == 0x41) { + /* This is a complete IPv6 packet, just skip dispatch byte. */ + pbuf_remove_header(p, 1); /* hide dispatch byte. */ + } else if ((b & 0xe0 ) == 0x60) { + /* IPv6 headers are compressed using IPHC. */ + p = lowpan6_decompress(p, datagram_size, LWIP_6LOWPAN_CONTEXTS(netif), &src, &dest); + if (p == NULL) { + MIB2_STATS_NETIF_INC(netif, ifindiscards); + return ERR_OK; + } + } else { + goto lowpan6_input_discard; + } + + /* @todo: distinguish unicast/multicast */ + MIB2_STATS_NETIF_INC(netif, ifinucastpkts); + + return ip6_input(p, netif); + } +lowpan6_input_discard: + MIB2_STATS_NETIF_INC(netif, ifindiscards); + pbuf_free(p); + /* always return ERR_OK here to prevent the caller freeing the pbuf */ + return ERR_OK; +} + +/** + * @ingroup sixlowpan + */ +err_t +lowpan6_if_init(struct netif *netif) +{ + netif->name[0] = 'L'; + netif->name[1] = '6'; + netif->output_ip6 = lowpan6_output; + + MIB2_INIT_NETIF(netif, snmp_ifType_other, 0); + + /* maximum transfer unit */ + netif->mtu = 1280; + + /* broadcast capability */ + netif->flags = NETIF_FLAG_BROADCAST /* | NETIF_FLAG_LOWPAN6 */; + + return ERR_OK; +} + +/** + * @ingroup sixlowpan + * Set PAN ID + */ +err_t +lowpan6_set_pan_id(u16_t pan_id) +{ + lowpan6_data.ieee_802154_pan_id = pan_id; + + return ERR_OK; +} + +#if !NO_SYS +/** + * @ingroup sixlowpan + * Pass a received packet to tcpip_thread for input processing + * + * @param p the received packet, p->payload pointing to the + * IEEE 802.15.4 header. + * @param inp the network interface on which the packet was received + */ +err_t +tcpip_6lowpan_input(struct pbuf *p, struct netif *inp) +{ + return tcpip_inpkt(p, inp, lowpan6_input); +} +#endif /* !NO_SYS */ + +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_ble.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_ble.c index 37bd4cea..d89816d3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_ble.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_ble.c @@ -1,447 +1,447 @@ -/** - * @file - * 6LowPAN over BLE output for IPv6 (RFC7668). -*/ - -/* - * Copyright (c) 2017 Benjamin Aigner - * Copyright (c) 2015 Inico Technologies Ltd. , Author: Ivan Delamer - * - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * Author: Benjamin Aigner - * - * Based on the original 6lowpan implementation of lwIP ( @see 6lowpan.c) - */ - - -/** - * @defgroup rfc7668if 6LoWPAN over BLE (RFC7668) - * @ingroup netifs - * This file implements a RFC7668 implementation for 6LoWPAN over - * Bluetooth Low Energy. The specification is very similar to 6LoWPAN, - * so most of the code is re-used. - * Compared to 6LoWPAN, much functionality is already implemented in - * lower BLE layers (fragmenting, session management,...). - * - * Usage: - * - add this netif - * - don't add IPv4 addresses (no IPv4 support in RFC7668), pass 'NULL','NULL','NULL' - * - use the BLE to EUI64 conversation util to create an IPv6 link-local address from the BLE MAC (@ref ble_addr_to_eui64) - * - input function: @ref rfc7668_input - * - set the link output function, which transmits output data to an established L2CAP channel - * - If data arrives (HCI event "L2CAP_DATA_PACKET"): - * - allocate a @ref PBUF_RAW buffer - * - let the pbuf struct point to the incoming data or copy it to the buffer - * - call netif->input - * - * @todo: - * - further testing - * - support compression contexts - * - support multiple addresses - * - support multicast - * - support neighbor discovery - */ - - -#include "netif/lowpan6_ble.h" - -#if LWIP_IPV6 - -#include "lwip/ip.h" -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/nd6.h" -#include "lwip/mem.h" -#include "lwip/udp.h" -#include "lwip/tcpip.h" -#include "lwip/snmp.h" - -#include - -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 -/** context memory, containing IPv6 addresses */ -static ip6_addr_t rfc7668_context[LWIP_6LOWPAN_NUM_CONTEXTS]; -#else -#define rfc7668_context NULL -#endif - -static struct lowpan6_link_addr rfc7668_local_addr; -static struct lowpan6_link_addr rfc7668_peer_addr; - -/** - * @ingroup rfc7668if - * convert BT address to EUI64 addr - * - * This method converts a Bluetooth MAC address to an EUI64 address, - * which is used within IPv6 communication - * - * @param dst IPv6 destination space - * @param src BLE MAC address source - * @param public_addr If the LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS - * option is set, bit 0x02 will be set if param=0 (no public addr); cleared otherwise - * - * @see LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS - */ -void -ble_addr_to_eui64(uint8_t *dst, const uint8_t *src, int public_addr) -{ - /* according to RFC7668 ch 3.2.2. */ - memcpy(dst, src, 3); - dst[3] = 0xFF; - dst[4] = 0xFE; - memcpy(&dst[5], &src[3], 3); -#if LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS - if(public_addr) { - dst[0] &= ~0x02; - } else { - dst[0] |= 0x02; - } -#else - LWIP_UNUSED_ARG(public_addr); -#endif -} - -/** - * @ingroup rfc7668if - * convert EUI64 address to Bluetooth MAC addr - * - * This method converts an EUI64 address to a Bluetooth MAC address, - * - * @param dst BLE MAC address destination - * @param src IPv6 source - * - */ -void -eui64_to_ble_addr(uint8_t *dst, const uint8_t *src) -{ - /* according to RFC7668 ch 3.2.2. */ - memcpy(dst,src,3); - memcpy(&dst[3],&src[5],3); -} - -/** Set an address used for stateful compression. - * This expects an address of 6 or 8 bytes. - */ -static err_t -rfc7668_set_addr(struct lowpan6_link_addr *addr, const u8_t *in_addr, size_t in_addr_len, int is_mac_48, int is_public_addr) -{ - if ((in_addr == NULL) || (addr == NULL)) { - return ERR_VAL; - } - if (is_mac_48) { - if (in_addr_len != 6) { - return ERR_VAL; - } - addr->addr_len = 8; - ble_addr_to_eui64(addr->addr, in_addr, is_public_addr); - } else { - if (in_addr_len != 8) { - return ERR_VAL; - } - addr->addr_len = 8; - memcpy(addr->addr, in_addr, 8); - } - return ERR_OK; -} - - -/** Set the local address used for stateful compression. - * This expects an address of 8 bytes. - */ -err_t -rfc7668_set_local_addr_eui64(struct netif *netif, const u8_t *local_addr, size_t local_addr_len) -{ - /* netif not used for now, the address is stored globally... */ - LWIP_UNUSED_ARG(netif); - return rfc7668_set_addr(&rfc7668_local_addr, local_addr, local_addr_len, 0, 0); -} - -/** Set the local address used for stateful compression. - * This expects an address of 6 bytes. - */ -err_t -rfc7668_set_local_addr_mac48(struct netif *netif, const u8_t *local_addr, size_t local_addr_len, int is_public_addr) -{ - /* netif not used for now, the address is stored globally... */ - LWIP_UNUSED_ARG(netif); - return rfc7668_set_addr(&rfc7668_local_addr, local_addr, local_addr_len, 1, is_public_addr); -} - -/** Set the peer address used for stateful compression. - * This expects an address of 8 bytes. - */ -err_t -rfc7668_set_peer_addr_eui64(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len) -{ - /* netif not used for now, the address is stored globally... */ - LWIP_UNUSED_ARG(netif); - return rfc7668_set_addr(&rfc7668_peer_addr, peer_addr, peer_addr_len, 0, 0); -} - -/** Set the peer address used for stateful compression. - * This expects an address of 6 bytes. - */ -err_t -rfc7668_set_peer_addr_mac48(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len, int is_public_addr) -{ - /* netif not used for now, the address is stored globally... */ - LWIP_UNUSED_ARG(netif); - return rfc7668_set_addr(&rfc7668_peer_addr, peer_addr, peer_addr_len, 1, is_public_addr); -} - -/** Encapsulate IPv6 frames for BLE transmission - * - * This method implements the IPv6 header compression: - * *) According to RFC6282 - * *) See Figure 2, contains base format of bit positions - * *) Fragmentation not necessary (done at L2CAP layer of BLE) - * @note Currently the pbuf allocation uses 256 bytes. If longer packets are used (possible due to MTU=1480Bytes), increase it here! - * - * @param p Pbuf struct, containing the payload data - * @param netif Output network interface. Should be of RFC7668 type - * - * @return Same as netif->output. - */ -static err_t -rfc7668_compress(struct netif *netif, struct pbuf *p) -{ - struct pbuf *p_frag; - u16_t remaining_len; - u8_t *buffer; - u8_t lowpan6_header_len; - u8_t hidden_header_len; - err_t err; - - LWIP_ASSERT("lowpan6_frag: netif->linkoutput not set", netif->linkoutput != NULL); - -#if LWIP_6LOWPAN_IPHC - - /* We'll use a dedicated pbuf for building BLE fragments. - * We'll over-allocate it by the bytes saved for header compression. - */ - p_frag = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM); - if (p_frag == NULL) { - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - return ERR_MEM; - } - LWIP_ASSERT("this needs a pbuf in one piece", p_frag->len == p_frag->tot_len); - - /* Write IP6 header (with IPHC). */ - buffer = (u8_t*)p_frag->payload; - - err = lowpan6_compress_headers(netif, (u8_t *)p->payload, p->len, buffer, p_frag->len, - &lowpan6_header_len, &hidden_header_len, rfc7668_context, &rfc7668_local_addr, &rfc7668_peer_addr); - if (err != ERR_OK) { - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - pbuf_free(p_frag); - return err; - } - pbuf_remove_header(p, hidden_header_len); - - /* Calculate remaining packet length */ - remaining_len = p->tot_len; - - /* Copy IPv6 packet */ - pbuf_copy_partial(p, buffer + lowpan6_header_len, remaining_len, 0); - - /* Calculate frame length */ - p_frag->len = p_frag->tot_len = remaining_len + lowpan6_header_len; - - /* send the packet */ - MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); - LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG|LWIP_DBG_TRACE, ("rfc7668_output: sending packet %p\n", (void *)p)); - err = netif->linkoutput(netif, p_frag); - - pbuf_free(p_frag); - - return err; -#else /* LWIP_6LOWPAN_IPHC */ - /* 6LoWPAN over BLE requires IPHC! */ - return ERR_IF; -#endif/* LWIP_6LOWPAN_IPHC */ -} - -/** - * @ingroup rfc7668if - * Set context id IPv6 address - * - * Store one IPv6 address to a given context id. - * - * @param idx Context id - * @param context IPv6 addr for this context - * - * @return ERR_OK (if everything is fine), ERR_ARG (if the context id is out of range), ERR_VAL (if contexts disabled) - */ -err_t -rfc7668_set_context(u8_t idx, const ip6_addr_t *context) -{ -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 - /* check if the ID is possible */ - if (idx >= LWIP_6LOWPAN_NUM_CONTEXTS) { - return ERR_ARG; - } - /* copy IPv6 address to context storage */ - ip6_addr_set(&rfc7668_context[idx], context); - return ERR_OK; -#else - LWIP_UNUSED_ARG(idx); - LWIP_UNUSED_ARG(context); - return ERR_VAL; -#endif -} - -/** - * @ingroup rfc7668if - * Compress outgoing IPv6 packet and pass it on to netif->linkoutput - * - * @param netif The lwIP network interface which the IP packet will be sent on. - * @param q The pbuf(s) containing the IP packet to be sent. - * @param ip6addr The IP address of the packet destination. - * - * @return See rfc7668_compress - */ -err_t -rfc7668_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr) -{ - /* dst ip6addr is not used here, we only have one peer */ - LWIP_UNUSED_ARG(ip6addr); - - return rfc7668_compress(netif, q); -} - -/** - * @ingroup rfc7668if - * Process a received raw payload from an L2CAP channel - * - * @param p the received packet, p->payload pointing to the - * IPv6 header (maybe compressed) - * @param netif the network interface on which the packet was received - * - * @return ERR_OK if everything was fine - */ -err_t -rfc7668_input(struct pbuf * p, struct netif *netif) -{ - u8_t * puc; - - MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len); - - /* Load first header byte */ - puc = (u8_t*)p->payload; - - /* no IP header compression */ - if (*puc == 0x41) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Completed packet, removing dispatch: 0x%2x \n", *puc)); - /* This is a complete IPv6 packet, just skip header byte. */ - pbuf_remove_header(p, 1); - /* IPHC header compression */ - } else if ((*puc & 0xe0 )== 0x60) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Completed packet, decompress dispatch: 0x%2x \n", *puc)); - /* IPv6 headers are compressed using IPHC. */ - p = lowpan6_decompress(p, 0, rfc7668_context, &rfc7668_peer_addr, &rfc7668_local_addr); - /* if no pbuf is returned, handle as discarded packet */ - if (p == NULL) { - MIB2_STATS_NETIF_INC(netif, ifindiscards); - return ERR_OK; - } - /* invalid header byte, discard */ - } else { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Completed packet, discarding: 0x%2x \n", *puc)); - MIB2_STATS_NETIF_INC(netif, ifindiscards); - pbuf_free(p); - return ERR_OK; - } - /* @todo: distinguish unicast/multicast */ - MIB2_STATS_NETIF_INC(netif, ifinucastpkts); - -#if LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG - { - u16_t i; - LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("IPv6 payload:\n")); - for (i = 0; i < p->len; i++) { - if ((i%4)==0) { - LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("\n")); - } - LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("%2X ", *((uint8_t *)p->payload+i))); - } - LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("\np->len: %d\n", p->len)); - } -#endif - /* pass data to ip6_input */ - return ip6_input(p, netif); -} - -/** - * @ingroup rfc7668if - * Initialize the netif - * - * No flags are used (broadcast not possible, not ethernet, ...) - * The shortname for this netif is "BT" - * - * @param netif the network interface to be initialized as RFC7668 netif - * - * @return ERR_OK if everything went fine - */ -err_t -rfc7668_if_init(struct netif *netif) -{ - netif->name[0] = 'b'; - netif->name[1] = 't'; - /* local function as IPv6 output */ - netif->output_ip6 = rfc7668_output; - - MIB2_INIT_NETIF(netif, snmp_ifType_other, 0); - - /* maximum transfer unit, set according to RFC7668 ch2.4 */ - netif->mtu = 1280; - - /* no flags set (no broadcast, ethernet,...)*/ - netif->flags = 0; - - /* everything fine */ - return ERR_OK; -} - -#if !NO_SYS -/** - * Pass a received packet to tcpip_thread for input processing - * - * @param p the received packet, p->payload pointing to the - * IEEE 802.15.4 header. - * @param inp the network interface on which the packet was received - * - * @return see @ref tcpip_inpkt, same return values - */ -err_t -tcpip_rfc7668_input(struct pbuf *p, struct netif *inp) -{ - /* send data to upper layer, return the result */ - return tcpip_inpkt(p, inp, rfc7668_input); -} -#endif /* !NO_SYS */ - -#endif /* LWIP_IPV6 */ +/** + * @file + * 6LowPAN over BLE output for IPv6 (RFC7668). +*/ + +/* + * Copyright (c) 2017 Benjamin Aigner + * Copyright (c) 2015 Inico Technologies Ltd. , Author: Ivan Delamer + * + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * Author: Benjamin Aigner + * + * Based on the original 6lowpan implementation of lwIP ( @see 6lowpan.c) + */ + + +/** + * @defgroup rfc7668if 6LoWPAN over BLE (RFC7668) + * @ingroup netifs + * This file implements a RFC7668 implementation for 6LoWPAN over + * Bluetooth Low Energy. The specification is very similar to 6LoWPAN, + * so most of the code is re-used. + * Compared to 6LoWPAN, much functionality is already implemented in + * lower BLE layers (fragmenting, session management,...). + * + * Usage: + * - add this netif + * - don't add IPv4 addresses (no IPv4 support in RFC7668), pass 'NULL','NULL','NULL' + * - use the BLE to EUI64 conversation util to create an IPv6 link-local address from the BLE MAC (@ref ble_addr_to_eui64) + * - input function: @ref rfc7668_input + * - set the link output function, which transmits output data to an established L2CAP channel + * - If data arrives (HCI event "L2CAP_DATA_PACKET"): + * - allocate a @ref PBUF_RAW buffer + * - let the pbuf struct point to the incoming data or copy it to the buffer + * - call netif->input + * + * @todo: + * - further testing + * - support compression contexts + * - support multiple addresses + * - support multicast + * - support neighbor discovery + */ + + +#include "netif/lowpan6_ble.h" + +#if LWIP_IPV6 + +#include "lwip/ip.h" +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/nd6.h" +#include "lwip/mem.h" +#include "lwip/udp.h" +#include "lwip/tcpip.h" +#include "lwip/snmp.h" + +#include + +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 +/** context memory, containing IPv6 addresses */ +static ip6_addr_t rfc7668_context[LWIP_6LOWPAN_NUM_CONTEXTS]; +#else +#define rfc7668_context NULL +#endif + +static struct lowpan6_link_addr rfc7668_local_addr; +static struct lowpan6_link_addr rfc7668_peer_addr; + +/** + * @ingroup rfc7668if + * convert BT address to EUI64 addr + * + * This method converts a Bluetooth MAC address to an EUI64 address, + * which is used within IPv6 communication + * + * @param dst IPv6 destination space + * @param src BLE MAC address source + * @param public_addr If the LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS + * option is set, bit 0x02 will be set if param=0 (no public addr); cleared otherwise + * + * @see LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS + */ +void +ble_addr_to_eui64(uint8_t *dst, const uint8_t *src, int public_addr) +{ + /* according to RFC7668 ch 3.2.2. */ + memcpy(dst, src, 3); + dst[3] = 0xFF; + dst[4] = 0xFE; + memcpy(&dst[5], &src[3], 3); +#if LWIP_RFC7668_LINUX_WORKAROUND_PUBLIC_ADDRESS + if(public_addr) { + dst[0] &= ~0x02; + } else { + dst[0] |= 0x02; + } +#else + LWIP_UNUSED_ARG(public_addr); +#endif +} + +/** + * @ingroup rfc7668if + * convert EUI64 address to Bluetooth MAC addr + * + * This method converts an EUI64 address to a Bluetooth MAC address, + * + * @param dst BLE MAC address destination + * @param src IPv6 source + * + */ +void +eui64_to_ble_addr(uint8_t *dst, const uint8_t *src) +{ + /* according to RFC7668 ch 3.2.2. */ + memcpy(dst,src,3); + memcpy(&dst[3],&src[5],3); +} + +/** Set an address used for stateful compression. + * This expects an address of 6 or 8 bytes. + */ +static err_t +rfc7668_set_addr(struct lowpan6_link_addr *addr, const u8_t *in_addr, size_t in_addr_len, int is_mac_48, int is_public_addr) +{ + if ((in_addr == NULL) || (addr == NULL)) { + return ERR_VAL; + } + if (is_mac_48) { + if (in_addr_len != 6) { + return ERR_VAL; + } + addr->addr_len = 8; + ble_addr_to_eui64(addr->addr, in_addr, is_public_addr); + } else { + if (in_addr_len != 8) { + return ERR_VAL; + } + addr->addr_len = 8; + memcpy(addr->addr, in_addr, 8); + } + return ERR_OK; +} + + +/** Set the local address used for stateful compression. + * This expects an address of 8 bytes. + */ +err_t +rfc7668_set_local_addr_eui64(struct netif *netif, const u8_t *local_addr, size_t local_addr_len) +{ + /* netif not used for now, the address is stored globally... */ + LWIP_UNUSED_ARG(netif); + return rfc7668_set_addr(&rfc7668_local_addr, local_addr, local_addr_len, 0, 0); +} + +/** Set the local address used for stateful compression. + * This expects an address of 6 bytes. + */ +err_t +rfc7668_set_local_addr_mac48(struct netif *netif, const u8_t *local_addr, size_t local_addr_len, int is_public_addr) +{ + /* netif not used for now, the address is stored globally... */ + LWIP_UNUSED_ARG(netif); + return rfc7668_set_addr(&rfc7668_local_addr, local_addr, local_addr_len, 1, is_public_addr); +} + +/** Set the peer address used for stateful compression. + * This expects an address of 8 bytes. + */ +err_t +rfc7668_set_peer_addr_eui64(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len) +{ + /* netif not used for now, the address is stored globally... */ + LWIP_UNUSED_ARG(netif); + return rfc7668_set_addr(&rfc7668_peer_addr, peer_addr, peer_addr_len, 0, 0); +} + +/** Set the peer address used for stateful compression. + * This expects an address of 6 bytes. + */ +err_t +rfc7668_set_peer_addr_mac48(struct netif *netif, const u8_t *peer_addr, size_t peer_addr_len, int is_public_addr) +{ + /* netif not used for now, the address is stored globally... */ + LWIP_UNUSED_ARG(netif); + return rfc7668_set_addr(&rfc7668_peer_addr, peer_addr, peer_addr_len, 1, is_public_addr); +} + +/** Encapsulate IPv6 frames for BLE transmission + * + * This method implements the IPv6 header compression: + * *) According to RFC6282 + * *) See Figure 2, contains base format of bit positions + * *) Fragmentation not necessary (done at L2CAP layer of BLE) + * @note Currently the pbuf allocation uses 256 bytes. If longer packets are used (possible due to MTU=1480Bytes), increase it here! + * + * @param p Pbuf struct, containing the payload data + * @param netif Output network interface. Should be of RFC7668 type + * + * @return Same as netif->output. + */ +static err_t +rfc7668_compress(struct netif *netif, struct pbuf *p) +{ + struct pbuf *p_frag; + u16_t remaining_len; + u8_t *buffer; + u8_t lowpan6_header_len; + u8_t hidden_header_len; + err_t err; + + LWIP_ASSERT("lowpan6_frag: netif->linkoutput not set", netif->linkoutput != NULL); + +#if LWIP_6LOWPAN_IPHC + + /* We'll use a dedicated pbuf for building BLE fragments. + * We'll over-allocate it by the bytes saved for header compression. + */ + p_frag = pbuf_alloc(PBUF_RAW, p->tot_len, PBUF_RAM); + if (p_frag == NULL) { + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + return ERR_MEM; + } + LWIP_ASSERT("this needs a pbuf in one piece", p_frag->len == p_frag->tot_len); + + /* Write IP6 header (with IPHC). */ + buffer = (u8_t*)p_frag->payload; + + err = lowpan6_compress_headers(netif, (u8_t *)p->payload, p->len, buffer, p_frag->len, + &lowpan6_header_len, &hidden_header_len, rfc7668_context, &rfc7668_local_addr, &rfc7668_peer_addr); + if (err != ERR_OK) { + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + pbuf_free(p_frag); + return err; + } + pbuf_remove_header(p, hidden_header_len); + + /* Calculate remaining packet length */ + remaining_len = p->tot_len; + + /* Copy IPv6 packet */ + pbuf_copy_partial(p, buffer + lowpan6_header_len, remaining_len, 0); + + /* Calculate frame length */ + p_frag->len = p_frag->tot_len = remaining_len + lowpan6_header_len; + + /* send the packet */ + MIB2_STATS_NETIF_ADD(netif, ifoutoctets, p_frag->tot_len); + LWIP_DEBUGF(LWIP_LOWPAN6_DEBUG|LWIP_DBG_TRACE, ("rfc7668_output: sending packet %p\n", (void *)p)); + err = netif->linkoutput(netif, p_frag); + + pbuf_free(p_frag); + + return err; +#else /* LWIP_6LOWPAN_IPHC */ + /* 6LoWPAN over BLE requires IPHC! */ + return ERR_IF; +#endif/* LWIP_6LOWPAN_IPHC */ +} + +/** + * @ingroup rfc7668if + * Set context id IPv6 address + * + * Store one IPv6 address to a given context id. + * + * @param idx Context id + * @param context IPv6 addr for this context + * + * @return ERR_OK (if everything is fine), ERR_ARG (if the context id is out of range), ERR_VAL (if contexts disabled) + */ +err_t +rfc7668_set_context(u8_t idx, const ip6_addr_t *context) +{ +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 + /* check if the ID is possible */ + if (idx >= LWIP_6LOWPAN_NUM_CONTEXTS) { + return ERR_ARG; + } + /* copy IPv6 address to context storage */ + ip6_addr_set(&rfc7668_context[idx], context); + return ERR_OK; +#else + LWIP_UNUSED_ARG(idx); + LWIP_UNUSED_ARG(context); + return ERR_VAL; +#endif +} + +/** + * @ingroup rfc7668if + * Compress outgoing IPv6 packet and pass it on to netif->linkoutput + * + * @param netif The lwIP network interface which the IP packet will be sent on. + * @param q The pbuf(s) containing the IP packet to be sent. + * @param ip6addr The IP address of the packet destination. + * + * @return See rfc7668_compress + */ +err_t +rfc7668_output(struct netif *netif, struct pbuf *q, const ip6_addr_t *ip6addr) +{ + /* dst ip6addr is not used here, we only have one peer */ + LWIP_UNUSED_ARG(ip6addr); + + return rfc7668_compress(netif, q); +} + +/** + * @ingroup rfc7668if + * Process a received raw payload from an L2CAP channel + * + * @param p the received packet, p->payload pointing to the + * IPv6 header (maybe compressed) + * @param netif the network interface on which the packet was received + * + * @return ERR_OK if everything was fine + */ +err_t +rfc7668_input(struct pbuf * p, struct netif *netif) +{ + u8_t * puc; + + MIB2_STATS_NETIF_ADD(netif, ifinoctets, p->tot_len); + + /* Load first header byte */ + puc = (u8_t*)p->payload; + + /* no IP header compression */ + if (*puc == 0x41) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Completed packet, removing dispatch: 0x%2x \n", *puc)); + /* This is a complete IPv6 packet, just skip header byte. */ + pbuf_remove_header(p, 1); + /* IPHC header compression */ + } else if ((*puc & 0xe0 )== 0x60) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Completed packet, decompress dispatch: 0x%2x \n", *puc)); + /* IPv6 headers are compressed using IPHC. */ + p = lowpan6_decompress(p, 0, rfc7668_context, &rfc7668_peer_addr, &rfc7668_local_addr); + /* if no pbuf is returned, handle as discarded packet */ + if (p == NULL) { + MIB2_STATS_NETIF_INC(netif, ifindiscards); + return ERR_OK; + } + /* invalid header byte, discard */ + } else { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Completed packet, discarding: 0x%2x \n", *puc)); + MIB2_STATS_NETIF_INC(netif, ifindiscards); + pbuf_free(p); + return ERR_OK; + } + /* @todo: distinguish unicast/multicast */ + MIB2_STATS_NETIF_INC(netif, ifinucastpkts); + +#if LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG + { + u16_t i; + LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("IPv6 payload:\n")); + for (i = 0; i < p->len; i++) { + if ((i%4)==0) { + LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("\n")); + } + LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("%2X ", *((uint8_t *)p->payload+i))); + } + LWIP_DEBUGF(LWIP_RFC7668_IP_UNCOMPRESSED_DEBUG, ("\np->len: %d\n", p->len)); + } +#endif + /* pass data to ip6_input */ + return ip6_input(p, netif); +} + +/** + * @ingroup rfc7668if + * Initialize the netif + * + * No flags are used (broadcast not possible, not ethernet, ...) + * The shortname for this netif is "BT" + * + * @param netif the network interface to be initialized as RFC7668 netif + * + * @return ERR_OK if everything went fine + */ +err_t +rfc7668_if_init(struct netif *netif) +{ + netif->name[0] = 'b'; + netif->name[1] = 't'; + /* local function as IPv6 output */ + netif->output_ip6 = rfc7668_output; + + MIB2_INIT_NETIF(netif, snmp_ifType_other, 0); + + /* maximum transfer unit, set according to RFC7668 ch2.4 */ + netif->mtu = 1280; + + /* no flags set (no broadcast, ethernet,...)*/ + netif->flags = 0; + + /* everything fine */ + return ERR_OK; +} + +#if !NO_SYS +/** + * Pass a received packet to tcpip_thread for input processing + * + * @param p the received packet, p->payload pointing to the + * IEEE 802.15.4 header. + * @param inp the network interface on which the packet was received + * + * @return see @ref tcpip_inpkt, same return values + */ +err_t +tcpip_rfc7668_input(struct pbuf *p, struct netif *inp) +{ + /* send data to upper layer, return the result */ + return tcpip_inpkt(p, inp, rfc7668_input); +} +#endif /* !NO_SYS */ + +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_common.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_common.c index 4aba4a31..baea206a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_common.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/lowpan6_common.c @@ -1,841 +1,841 @@ -/** - * @file - * - * Common 6LowPAN routines for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. - * - * This implementation aims to conform to IEEE 802.15.4(-2015), RFC 4944 and RFC 6282. - * @todo: RFC 6775. - */ - -/* - * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Ivan Delamer - * - * - * Please coordinate changes and requests with Ivan Delamer - * - */ - -/** - * @defgroup sixlowpan 6LoWPAN (RFC4944) - * @ingroup netifs - * 6LowPAN netif implementation - */ - -#include "netif/lowpan6_common.h" - -#if LWIP_IPV6 - -#include "lwip/ip.h" -#include "lwip/pbuf.h" -#include "lwip/ip_addr.h" -#include "lwip/netif.h" -#include "lwip/udp.h" - -#include - -/* Determine compression mode for unicast address. */ -s8_t -lowpan6_get_address_mode(const ip6_addr_t *ip6addr, const struct lowpan6_link_addr *mac_addr) -{ - if (mac_addr->addr_len == 2) { - if ((ip6addr->addr[2] == (u32_t)PP_HTONL(0x000000ff)) && - ((ip6addr->addr[3] & PP_HTONL(0xffff0000)) == PP_NTOHL(0xfe000000))) { - if ((ip6addr->addr[3] & PP_HTONL(0x0000ffff)) == lwip_ntohl((mac_addr->addr[0] << 8) | mac_addr->addr[1])) { - return 3; - } - } - } else if (mac_addr->addr_len == 8) { - if ((ip6addr->addr[2] == lwip_ntohl(((mac_addr->addr[0] ^ 2) << 24) | (mac_addr->addr[1] << 16) | mac_addr->addr[2] << 8 | mac_addr->addr[3])) && - (ip6addr->addr[3] == lwip_ntohl((mac_addr->addr[4] << 24) | (mac_addr->addr[5] << 16) | mac_addr->addr[6] << 8 | mac_addr->addr[7]))) { - return 3; - } - } - - if ((ip6addr->addr[2] == PP_HTONL(0x000000ffUL)) && - ((ip6addr->addr[3] & PP_HTONL(0xffff0000)) == PP_NTOHL(0xfe000000UL))) { - return 2; - } - - return 1; -} - -#if LWIP_6LOWPAN_IPHC - -/* Determine compression mode for multicast address. */ -static s8_t -lowpan6_get_address_mode_mc(const ip6_addr_t *ip6addr) -{ - if ((ip6addr->addr[0] == PP_HTONL(0xff020000)) && - (ip6addr->addr[1] == 0) && - (ip6addr->addr[2] == 0) && - ((ip6addr->addr[3] & PP_HTONL(0xffffff00)) == 0)) { - return 3; - } else if (((ip6addr->addr[0] & PP_HTONL(0xff00ffff)) == PP_HTONL(0xff000000)) && - (ip6addr->addr[1] == 0)) { - if ((ip6addr->addr[2] == 0) && - ((ip6addr->addr[3] & PP_HTONL(0xff000000)) == 0)) { - return 2; - } else if ((ip6addr->addr[2] & PP_HTONL(0xffffff00)) == 0) { - return 1; - } - } - - return 0; -} - -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 -static s8_t -lowpan6_context_lookup(const ip6_addr_t *lowpan6_contexts, const ip6_addr_t *ip6addr) -{ - s8_t i; - - for (i = 0; i < LWIP_6LOWPAN_NUM_CONTEXTS; i++) { - if (ip6_addr_netcmp(&lowpan6_contexts[i], ip6addr)) { - return i; - } - } - return -1; -} -#endif /* LWIP_6LOWPAN_NUM_CONTEXTS > 0 */ - -/* - * Compress IPv6 and/or UDP headers. - * */ -err_t -lowpan6_compress_headers(struct netif *netif, u8_t *inbuf, size_t inbuf_size, u8_t *outbuf, size_t outbuf_size, - u8_t *lowpan6_header_len_out, u8_t *hidden_header_len_out, ip6_addr_t *lowpan6_contexts, - const struct lowpan6_link_addr *src, const struct lowpan6_link_addr *dst) -{ - u8_t *buffer, *inptr; - u8_t lowpan6_header_len; - u8_t hidden_header_len = 0; - s8_t i; - struct ip6_hdr *ip6hdr; - ip_addr_t ip6src, ip6dst; - - LWIP_ASSERT("netif != NULL", netif != NULL); - LWIP_ASSERT("inbuf != NULL", inbuf != NULL); - LWIP_ASSERT("outbuf != NULL", outbuf != NULL); - LWIP_ASSERT("lowpan6_header_len_out != NULL", lowpan6_header_len_out != NULL); - LWIP_ASSERT("hidden_header_len_out != NULL", hidden_header_len_out != NULL); - - /* Perform 6LowPAN IPv6 header compression according to RFC 6282 */ - buffer = outbuf; - inptr = inbuf; - - if (inbuf_size < IP6_HLEN) { - /* input buffer too short */ - return ERR_VAL; - } - if (outbuf_size < IP6_HLEN) { - /* output buffer too short for worst case */ - return ERR_MEM; - } - - /* Point to ip6 header and align copies of src/dest addresses. */ - ip6hdr = (struct ip6_hdr *)inptr; - ip_addr_copy_from_ip6_packed(ip6dst, ip6hdr->dest); - ip6_addr_assign_zone(ip_2_ip6(&ip6dst), IP6_UNKNOWN, netif); - ip_addr_copy_from_ip6_packed(ip6src, ip6hdr->src); - ip6_addr_assign_zone(ip_2_ip6(&ip6src), IP6_UNKNOWN, netif); - - /* Basic length of 6LowPAN header, set dispatch and clear fields. */ - lowpan6_header_len = 2; - buffer[0] = 0x60; - buffer[1] = 0; - - /* Determine whether there will be a Context Identifier Extension byte or not. - * If so, set it already. */ -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 - buffer[2] = 0; - - i = lowpan6_context_lookup(lowpan6_contexts, ip_2_ip6(&ip6src)); - if (i >= 0) { - /* Stateful source address compression. */ - buffer[1] |= 0x40; - buffer[2] |= (i & 0x0f) << 4; - } - - i = lowpan6_context_lookup(lowpan6_contexts, ip_2_ip6(&ip6dst)); - if (i >= 0) { - /* Stateful destination address compression. */ - buffer[1] |= 0x04; - buffer[2] |= i & 0x0f; - } - - if (buffer[2] != 0x00) { - /* Context identifier extension byte is appended. */ - buffer[1] |= 0x80; - lowpan6_header_len++; - } -#else /* LWIP_6LOWPAN_NUM_CONTEXTS > 0 */ - LWIP_UNUSED_ARG(lowpan6_contexts); -#endif /* LWIP_6LOWPAN_NUM_CONTEXTS > 0 */ - - /* Determine TF field: Traffic Class, Flow Label */ - if (IP6H_FL(ip6hdr) == 0) { - /* Flow label is elided. */ - buffer[0] |= 0x10; - if (IP6H_TC(ip6hdr) == 0) { - /* Traffic class (ECN+DSCP) elided too. */ - buffer[0] |= 0x08; - } else { - /* Traffic class (ECN+DSCP) appended. */ - buffer[lowpan6_header_len++] = IP6H_TC(ip6hdr); - } - } else { - if (((IP6H_TC(ip6hdr) & 0x3f) == 0)) { - /* DSCP portion of Traffic Class is elided, ECN and FL are appended (3 bytes) */ - buffer[0] |= 0x08; - - buffer[lowpan6_header_len] = IP6H_TC(ip6hdr) & 0xc0; - buffer[lowpan6_header_len++] |= (IP6H_FL(ip6hdr) >> 16) & 0x0f; - buffer[lowpan6_header_len++] = (IP6H_FL(ip6hdr) >> 8) & 0xff; - buffer[lowpan6_header_len++] = IP6H_FL(ip6hdr) & 0xff; - } else { - /* Traffic class and flow label are appended (4 bytes) */ - buffer[lowpan6_header_len++] = IP6H_TC(ip6hdr); - buffer[lowpan6_header_len++] = (IP6H_FL(ip6hdr) >> 16) & 0x0f; - buffer[lowpan6_header_len++] = (IP6H_FL(ip6hdr) >> 8) & 0xff; - buffer[lowpan6_header_len++] = IP6H_FL(ip6hdr) & 0xff; - } - } - - /* Compress NH? - * Only if UDP for now. @todo support other NH compression. */ - if (IP6H_NEXTH(ip6hdr) == IP6_NEXTH_UDP) { - buffer[0] |= 0x04; - } else { - /* append nexth. */ - buffer[lowpan6_header_len++] = IP6H_NEXTH(ip6hdr); - } - - /* Compress hop limit? */ - if (IP6H_HOPLIM(ip6hdr) == 255) { - buffer[0] |= 0x03; - } else if (IP6H_HOPLIM(ip6hdr) == 64) { - buffer[0] |= 0x02; - } else if (IP6H_HOPLIM(ip6hdr) == 1) { - buffer[0] |= 0x01; - } else { - /* append hop limit */ - buffer[lowpan6_header_len++] = IP6H_HOPLIM(ip6hdr); - } - - /* Compress source address */ - if (((buffer[1] & 0x40) != 0) || - (ip6_addr_islinklocal(ip_2_ip6(&ip6src)))) { - /* Context-based or link-local source address compression. */ - i = lowpan6_get_address_mode(ip_2_ip6(&ip6src), src); - buffer[1] |= (i & 0x03) << 4; - if (i == 1) { - MEMCPY(buffer + lowpan6_header_len, inptr + 16, 8); - lowpan6_header_len += 8; - } else if (i == 2) { - MEMCPY(buffer + lowpan6_header_len, inptr + 22, 2); - lowpan6_header_len += 2; - } - } else if (ip6_addr_isany(ip_2_ip6(&ip6src))) { - /* Special case: mark SAC and leave SAM=0 */ - buffer[1] |= 0x40; - } else { - /* Append full address. */ - MEMCPY(buffer + lowpan6_header_len, inptr + 8, 16); - lowpan6_header_len += 16; - } - - /* Compress destination address */ - if (ip6_addr_ismulticast(ip_2_ip6(&ip6dst))) { - /* @todo support stateful multicast address compression */ - - buffer[1] |= 0x08; - - i = lowpan6_get_address_mode_mc(ip_2_ip6(&ip6dst)); - buffer[1] |= i & 0x03; - if (i == 0) { - MEMCPY(buffer + lowpan6_header_len, inptr + 24, 16); - lowpan6_header_len += 16; - } else if (i == 1) { - buffer[lowpan6_header_len++] = inptr[25]; - MEMCPY(buffer + lowpan6_header_len, inptr + 35, 5); - lowpan6_header_len += 5; - } else if (i == 2) { - buffer[lowpan6_header_len++] = inptr[25]; - MEMCPY(buffer + lowpan6_header_len, inptr + 37, 3); - lowpan6_header_len += 3; - } else if (i == 3) { - buffer[lowpan6_header_len++] = (inptr)[39]; - } - } else if (((buffer[1] & 0x04) != 0) || - (ip6_addr_islinklocal(ip_2_ip6(&ip6dst)))) { - /* Context-based or link-local destination address compression. */ - i = lowpan6_get_address_mode(ip_2_ip6(&ip6dst), dst); - buffer[1] |= i & 0x03; - if (i == 1) { - MEMCPY(buffer + lowpan6_header_len, inptr + 32, 8); - lowpan6_header_len += 8; - } else if (i == 2) { - MEMCPY(buffer + lowpan6_header_len, inptr + 38, 2); - lowpan6_header_len += 2; - } - } else { - /* Append full address. */ - MEMCPY(buffer + lowpan6_header_len, inptr + 24, 16); - lowpan6_header_len += 16; - } - - /* Move to payload. */ - inptr += IP6_HLEN; - hidden_header_len += IP6_HLEN; - -#if LWIP_UDP - /* Compress UDP header? */ - if (IP6H_NEXTH(ip6hdr) == IP6_NEXTH_UDP) { - /* @todo support optional checksum compression */ - - if (inbuf_size < IP6_HLEN + UDP_HLEN) { - /* input buffer too short */ - return ERR_VAL; - } - if (outbuf_size < (size_t)(hidden_header_len + 7)) { - /* output buffer too short for worst case */ - return ERR_MEM; - } - - buffer[lowpan6_header_len] = 0xf0; - - /* determine port compression mode. */ - if ((inptr[0] == 0xf0) && ((inptr[1] & 0xf0) == 0xb0) && - (inptr[2] == 0xf0) && ((inptr[3] & 0xf0) == 0xb0)) { - /* Compress source and dest ports. */ - buffer[lowpan6_header_len++] |= 0x03; - buffer[lowpan6_header_len++] = ((inptr[1] & 0x0f) << 4) | (inptr[3] & 0x0f); - } else if (inptr[0] == 0xf0) { - /* Compress source port. */ - buffer[lowpan6_header_len++] |= 0x02; - buffer[lowpan6_header_len++] = inptr[1]; - buffer[lowpan6_header_len++] = inptr[2]; - buffer[lowpan6_header_len++] = inptr[3]; - } else if (inptr[2] == 0xf0) { - /* Compress dest port. */ - buffer[lowpan6_header_len++] |= 0x01; - buffer[lowpan6_header_len++] = inptr[0]; - buffer[lowpan6_header_len++] = inptr[1]; - buffer[lowpan6_header_len++] = inptr[3]; - } else { - /* append full ports. */ - lowpan6_header_len++; - buffer[lowpan6_header_len++] = inptr[0]; - buffer[lowpan6_header_len++] = inptr[1]; - buffer[lowpan6_header_len++] = inptr[2]; - buffer[lowpan6_header_len++] = inptr[3]; - } - - /* elide length and copy checksum */ - buffer[lowpan6_header_len++] = inptr[6]; - buffer[lowpan6_header_len++] = inptr[7]; - - hidden_header_len += UDP_HLEN; - } -#endif /* LWIP_UDP */ - - *lowpan6_header_len_out = lowpan6_header_len; - *hidden_header_len_out = hidden_header_len; - - return ERR_OK; -} - -/** Decompress IPv6 and UDP headers compressed according to RFC 6282 - * - * @param lowpan6_buffer compressed headers, first byte is the dispatch byte - * @param lowpan6_bufsize size of lowpan6_buffer (may include data after headers) - * @param decomp_buffer buffer where the decompressed headers are stored - * @param decomp_bufsize size of decomp_buffer - * @param hdr_size_comp returns the size of the compressed headers (skip to get to data) - * @param hdr_size_decomp returns the size of the decompressed headers (IPv6 + UDP) - * @param datagram_size datagram size from fragments or 0 if unfragmented - * @param compressed_size compressed datagram size (for unfragmented rx) - * @param lowpan6_contexts context addresses - * @param src source address of the outer layer, used for address compression - * @param dest destination address of the outer layer, used for address compression - * @return ERR_OK if decompression succeeded, an error otherwise - */ -static err_t -lowpan6_decompress_hdr(u8_t *lowpan6_buffer, size_t lowpan6_bufsize, - u8_t *decomp_buffer, size_t decomp_bufsize, - u16_t *hdr_size_comp, u16_t *hdr_size_decomp, - u16_t datagram_size, u16_t compressed_size, - ip6_addr_t *lowpan6_contexts, - struct lowpan6_link_addr *src, struct lowpan6_link_addr *dest) -{ - u16_t lowpan6_offset; - struct ip6_hdr *ip6hdr; - s8_t i; - u32_t header_temp; - u16_t ip6_offset = IP6_HLEN; - - LWIP_ASSERT("lowpan6_buffer != NULL", lowpan6_buffer != NULL); - LWIP_ASSERT("decomp_buffer != NULL", decomp_buffer != NULL); - LWIP_ASSERT("src != NULL", src != NULL); - LWIP_ASSERT("dest != NULL", dest != NULL); - LWIP_ASSERT("hdr_size_comp != NULL", hdr_size_comp != NULL); - LWIP_ASSERT("dehdr_size_decompst != NULL", hdr_size_decomp != NULL); - - ip6hdr = (struct ip6_hdr *)decomp_buffer; - if (decomp_bufsize < IP6_HLEN) { - return ERR_MEM; - } - - /* output the full compressed packet, if set in @see lowpan6_opts.h */ -#if LWIP_LOWPAN6_IP_COMPRESSED_DEBUG - { - u16_t j; - LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("lowpan6_decompress_hdr: IP6 payload (compressed): \n")); - for (j = 0; j < lowpan6_bufsize; j++) { - if ((j % 4) == 0) { - LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("\n")); - } - LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("%2X ", lowpan6_buffer[j])); - } - LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("\np->len: %d", lowpan6_bufsize)); - } -#endif - - /* offset for inline IP headers (RFC 6282 ch3)*/ - lowpan6_offset = 2; - /* if CID is set (context identifier), the context byte - * follows immediately after the header, so other IPHC fields are @+3 */ - if (lowpan6_buffer[1] & 0x80) { - lowpan6_offset++; - } - - /* Set IPv6 version, traffic class and flow label. (RFC6282, ch 3.1.1.)*/ - if ((lowpan6_buffer[0] & 0x18) == 0x00) { - header_temp = ((lowpan6_buffer[lowpan6_offset+1] & 0x0f) << 16) | \ - (lowpan6_buffer[lowpan6_offset + 2] << 8) | lowpan6_buffer[lowpan6_offset+3]; - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 00, ECN: 0x%2x, Flowlabel+DSCP: 0x%8X\n", \ - lowpan6_buffer[lowpan6_offset],header_temp)); - IP6H_VTCFL_SET(ip6hdr, 6, lowpan6_buffer[lowpan6_offset], header_temp); - /* increase offset, processed 4 bytes here: - * TF=00: ECN + DSCP + 4-bit Pad + Flow Label (4 bytes)*/ - lowpan6_offset += 4; - } else if ((lowpan6_buffer[0] & 0x18) == 0x08) { - header_temp = ((lowpan6_buffer[lowpan6_offset] & 0x0f) << 16) | (lowpan6_buffer[lowpan6_offset + 1] << 8) | lowpan6_buffer[lowpan6_offset+2]; - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 01, ECN: 0x%2x, Flowlabel: 0x%2X, DSCP ignored\n", \ - lowpan6_buffer[lowpan6_offset] & 0xc0,header_temp)); - IP6H_VTCFL_SET(ip6hdr, 6, lowpan6_buffer[lowpan6_offset] & 0xc0, header_temp); - /* increase offset, processed 3 bytes here: - * TF=01: ECN + 2-bit Pad + Flow Label (3 bytes), DSCP is elided.*/ - lowpan6_offset += 3; - } else if ((lowpan6_buffer[0] & 0x18) == 0x10) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 10, DCSP+ECN: 0x%2x, Flowlabel ignored\n", lowpan6_buffer[lowpan6_offset])); - IP6H_VTCFL_SET(ip6hdr, 6, lowpan6_buffer[lowpan6_offset],0); - /* increase offset, processed 1 byte here: - * ECN + DSCP (1 byte), Flow Label is elided.*/ - lowpan6_offset += 1; - } else if ((lowpan6_buffer[0] & 0x18) == 0x18) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 11, DCSP/ECN & Flowlabel ignored\n")); - /* don't increase offset, no bytes processed here */ - IP6H_VTCFL_SET(ip6hdr, 6, 0, 0); - } - - /* Set Next Header (NH) */ - if ((lowpan6_buffer[0] & 0x04) == 0x00) { - /* 0: full next header byte carried inline (increase offset)*/ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NH: 0x%2X\n", lowpan6_buffer[lowpan6_offset+1])); - IP6H_NEXTH_SET(ip6hdr, lowpan6_buffer[lowpan6_offset++]); - } else { - /* 1: NH compression, LOWPAN_NHC (RFC6282, ch 4.1) */ - /* We should fill this later with NHC decoding */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NH: skipped, later done with NHC\n")); - IP6H_NEXTH_SET(ip6hdr, 0); - } - - /* Set Hop Limit, either carried inline or 3 different hops (1,64,255) */ - if ((lowpan6_buffer[0] & 0x03) == 0x00) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: full value: %d\n", lowpan6_buffer[lowpan6_offset+1])); - IP6H_HOPLIM_SET(ip6hdr, lowpan6_buffer[lowpan6_offset++]); - } else if ((lowpan6_buffer[0] & 0x03) == 0x01) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: compressed: 1\n")); - IP6H_HOPLIM_SET(ip6hdr, 1); - } else if ((lowpan6_buffer[0] & 0x03) == 0x02) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: compressed: 64\n")); - IP6H_HOPLIM_SET(ip6hdr, 64); - } else if ((lowpan6_buffer[0] & 0x03) == 0x03) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: compressed: 255\n")); - IP6H_HOPLIM_SET(ip6hdr, 255); - } - - /* Source address decoding. */ - if ((lowpan6_buffer[1] & 0x40) == 0x00) { - /* Source address compression (SAC) = 0 -> stateless compression */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAC == 0, no context byte\n")); - /* Stateless compression */ - if ((lowpan6_buffer[1] & 0x30) == 0x00) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 00, no src compression, fetching 128bits inline\n")); - /* copy full address, increase offset by 16 Bytes */ - MEMCPY(&ip6hdr->src.addr[0], lowpan6_buffer + lowpan6_offset, 16); - lowpan6_offset += 16; - } else if ((lowpan6_buffer[1] & 0x30) == 0x10) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 01, src compression, 64bits inline\n")); - /* set 64 bits to link local */ - ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL); - ip6hdr->src.addr[1] = 0; - /* copy 8 Bytes, increase offset */ - MEMCPY(&ip6hdr->src.addr[2], lowpan6_buffer + lowpan6_offset, 8); - lowpan6_offset += 8; - } else if ((lowpan6_buffer[1] & 0x30) == 0x20) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 10, src compression, 16bits inline\n")); - /* set 96 bits to link local */ - ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL); - ip6hdr->src.addr[1] = 0; - ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); - /* extract remaining 16bits from inline bytes, increase offset */ - ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | - lowpan6_buffer[lowpan6_offset + 1]); - lowpan6_offset += 2; - } else if ((lowpan6_buffer[1] & 0x30) == 0x30) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 11, src compression, 0bits inline, using other headers\n")); - /* no information avalaible, using other layers, see RFC6282 ch 3.2.2 */ - ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL); - ip6hdr->src.addr[1] = 0; - if (src->addr_len == 2) { - ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); - ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]); - } else if (src->addr_len == 8) { - ip6hdr->src.addr[2] = lwip_htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) | - (src->addr[2] << 8) | src->addr[3]); - ip6hdr->src.addr[3] = lwip_htonl((src->addr[4] << 24) | (src->addr[5] << 16) | - (src->addr[6] << 8) | src->addr[7]); - } else { - /* invalid source address length */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Invalid source address length\n")); - return ERR_VAL; - } - } - } else { - /* Source address compression (SAC) = 1 -> stateful/context-based compression */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAC == 1, additional context byte\n")); - if ((lowpan6_buffer[1] & 0x30) == 0x00) { - /* SAM=00, address=> :: (ANY) */ - ip6hdr->src.addr[0] = 0; - ip6hdr->src.addr[1] = 0; - ip6hdr->src.addr[2] = 0; - ip6hdr->src.addr[3] = 0; - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 00, context compression, ANY (::)\n")); - } else { - /* Set prefix from context info */ - if (lowpan6_buffer[1] & 0x80) { - i = (lowpan6_buffer[2] >> 4) & 0x0f; - } else { - i = 0; - } - if (i >= LWIP_6LOWPAN_NUM_CONTEXTS) { - /* Error */ - return ERR_VAL; - } -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 - ip6hdr->src.addr[0] = lowpan6_contexts[i].addr[0]; - ip6hdr->src.addr[1] = lowpan6_contexts[i].addr[1]; - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == xx, context compression found @%d: %8X, %8X\n", (int)i, ip6hdr->src.addr[0], ip6hdr->src.addr[1])); -#else - LWIP_UNUSED_ARG(lowpan6_contexts); -#endif - } - - /* determine further address bits */ - if ((lowpan6_buffer[1] & 0x30) == 0x10) { - /* SAM=01, load additional 64bits */ - MEMCPY(&ip6hdr->src.addr[2], lowpan6_buffer + lowpan6_offset, 8); - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 01, context compression, 64bits inline\n")); - lowpan6_offset += 8; - } else if ((lowpan6_buffer[1] & 0x30) == 0x20) { - /* SAM=01, load additional 16bits */ - ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); - ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset + 1]); - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 10, context compression, 16bits inline\n")); - lowpan6_offset += 2; - } else if ((lowpan6_buffer[1] & 0x30) == 0x30) { - /* SAM=11, address is fully elided, load from other layers */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 11, context compression, 0bits inline, using other headers\n")); - if (src->addr_len == 2) { - ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); - ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]); - } else if (src->addr_len == 8) { - ip6hdr->src.addr[2] = lwip_htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) | (src->addr[2] << 8) | src->addr[3]); - ip6hdr->src.addr[3] = lwip_htonl((src->addr[4] << 24) | (src->addr[5] << 16) | (src->addr[6] << 8) | src->addr[7]); - } else { - /* invalid source address length */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Invalid source address length\n")); - return ERR_VAL; - } - } - } - - /* Destination address decoding. */ - if (lowpan6_buffer[1] & 0x08) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("M=1: multicast\n")); - /* Multicast destination */ - if (lowpan6_buffer[1] & 0x04) { - LWIP_DEBUGF(LWIP_DBG_ON,("DAC == 1, context multicast: unsupported!!!\n")); - /* @todo support stateful multicast addressing */ - return ERR_VAL; - } - - if ((lowpan6_buffer[1] & 0x03) == 0x00) { - /* DAM = 00, copy full address (128bits) */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 00, no dst compression, fetching 128bits inline\n")); - MEMCPY(&ip6hdr->dest.addr[0], lowpan6_buffer + lowpan6_offset, 16); - lowpan6_offset += 16; - } else if ((lowpan6_buffer[1] & 0x03) == 0x01) { - /* DAM = 01, copy 4 bytes (32bits) */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 01, dst address form (48bits): ffXX::00XX:XXXX:XXXX\n")); - ip6hdr->dest.addr[0] = lwip_htonl(0xff000000UL | (lowpan6_buffer[lowpan6_offset++] << 16)); - ip6hdr->dest.addr[1] = 0; - ip6hdr->dest.addr[2] = lwip_htonl(lowpan6_buffer[lowpan6_offset++]); - ip6hdr->dest.addr[3] = lwip_htonl((lowpan6_buffer[lowpan6_offset] << 24) | (lowpan6_buffer[lowpan6_offset + 1] << 16) | (lowpan6_buffer[lowpan6_offset + 2] << 8) | lowpan6_buffer[lowpan6_offset + 3]); - lowpan6_offset += 4; - } else if ((lowpan6_buffer[1] & 0x03) == 0x02) { - /* DAM = 10, copy 3 bytes (24bits) */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 10, dst address form (32bits): ffXX::00XX:XXXX\n")); - ip6hdr->dest.addr[0] = lwip_htonl(0xff000000UL | (lowpan6_buffer[lowpan6_offset++] << 16)); - ip6hdr->dest.addr[1] = 0; - ip6hdr->dest.addr[2] = 0; - ip6hdr->dest.addr[3] = lwip_htonl((lowpan6_buffer[lowpan6_offset] << 16) | (lowpan6_buffer[lowpan6_offset + 1] << 8) | lowpan6_buffer[lowpan6_offset + 2]); - lowpan6_offset += 3; - } else if ((lowpan6_buffer[1] & 0x03) == 0x03) { - /* DAM = 11, copy 1 byte (8bits) */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 11, dst address form (8bits): ff02::00XX\n")); - ip6hdr->dest.addr[0] = PP_HTONL(0xff020000UL); - ip6hdr->dest.addr[1] = 0; - ip6hdr->dest.addr[2] = 0; - ip6hdr->dest.addr[3] = lwip_htonl(lowpan6_buffer[lowpan6_offset++]); - } - - } else { - /* no Multicast (M=0) */ - if (lowpan6_buffer[1] & 0x04) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAC == 1, stateful compression\n")); - /* Stateful destination compression */ - /* Set prefix from context info */ - if (lowpan6_buffer[1] & 0x80) { - i = lowpan6_buffer[2] & 0x0f; - } else { - i = 0; - } - if (i >= LWIP_6LOWPAN_NUM_CONTEXTS) { - /* Error */ - return ERR_VAL; - } -#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 - ip6hdr->dest.addr[0] = lowpan6_contexts[i].addr[0]; - ip6hdr->dest.addr[1] = lowpan6_contexts[i].addr[1]; -#endif - } else { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAC == 0, stateless compression, setting link local prefix\n")); - /* Link local address compression */ - ip6hdr->dest.addr[0] = PP_HTONL(0xfe800000UL); - ip6hdr->dest.addr[1] = 0; - } - - /* M=0, DAC=0, determining destination address length via DAM=xx */ - if ((lowpan6_buffer[1] & 0x03) == 0x00) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 00, no dst compression, fetching 128bits inline")); - /* DAM=00, copy full address */ - MEMCPY(&ip6hdr->dest.addr[0], lowpan6_buffer + lowpan6_offset, 16); - lowpan6_offset += 16; - } else if ((lowpan6_buffer[1] & 0x03) == 0x01) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 01, dst compression, 64bits inline\n")); - /* DAM=01, copy 64 inline bits, increase offset */ - MEMCPY(&ip6hdr->dest.addr[2], lowpan6_buffer + lowpan6_offset, 8); - lowpan6_offset += 8; - } else if ((lowpan6_buffer[1] & 0x03) == 0x02) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 01, dst compression, 16bits inline\n")); - /* DAM=10, copy 16 inline bits, increase offset */ - ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL); - ip6hdr->dest.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset + 1]); - lowpan6_offset += 2; - } else if ((lowpan6_buffer[1] & 0x03) == 0x03) { - /* DAM=11, no bits available, use other headers (not done here) */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG,("DAM == 01, dst compression, 0bits inline, using other headers\n")); - if (dest->addr_len == 2) { - ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL); - ip6hdr->dest.addr[3] = lwip_htonl(0xfe000000UL | (dest->addr[0] << 8) | dest->addr[1]); - } else if (dest->addr_len == 8) { - ip6hdr->dest.addr[2] = lwip_htonl(((dest->addr[0] ^ 2) << 24) | (dest->addr[1] << 16) | dest->addr[2] << 8 | dest->addr[3]); - ip6hdr->dest.addr[3] = lwip_htonl((dest->addr[4] << 24) | (dest->addr[5] << 16) | dest->addr[6] << 8 | dest->addr[7]); - } else { - /* invalid destination address length */ - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Invalid destination address length\n")); - return ERR_VAL; - } - } - } - - - /* Next Header Compression (NHC) decoding? */ - if (lowpan6_buffer[0] & 0x04) { - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NHC decoding\n")); -#if LWIP_UDP - if ((lowpan6_buffer[lowpan6_offset] & 0xf8) == 0xf0) { - /* NHC: UDP */ - struct udp_hdr *udphdr; - LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NHC: UDP\n")); - - /* UDP compression */ - IP6H_NEXTH_SET(ip6hdr, IP6_NEXTH_UDP); - udphdr = (struct udp_hdr *)((u8_t *)decomp_buffer + ip6_offset); - if (decomp_bufsize < IP6_HLEN + UDP_HLEN) { - return ERR_MEM; - } - - /* Checksum decompression */ - if (lowpan6_buffer[lowpan6_offset] & 0x04) { - /* @todo support checksum decompress */ - LWIP_DEBUGF(LWIP_DBG_ON, ("NHC: UDP chechsum decompression UNSUPPORTED\n")); - return ERR_VAL; - } - - /* Decompress ports, according to RFC4944 */ - i = lowpan6_buffer[lowpan6_offset++] & 0x03; - if (i == 0) { - udphdr->src = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); - udphdr->dest = lwip_htons(lowpan6_buffer[lowpan6_offset + 2] << 8 | lowpan6_buffer[lowpan6_offset + 3]); - lowpan6_offset += 4; - } else if (i == 0x01) { - udphdr->src = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); - udphdr->dest = lwip_htons(0xf000 | lowpan6_buffer[lowpan6_offset + 2]); - lowpan6_offset += 3; - } else if (i == 0x02) { - udphdr->src = lwip_htons(0xf000 | lowpan6_buffer[lowpan6_offset]); - udphdr->dest = lwip_htons(lowpan6_buffer[lowpan6_offset + 1] << 8 | lowpan6_buffer[lowpan6_offset + 2]); - lowpan6_offset += 3; - } else if (i == 0x03) { - udphdr->src = lwip_htons(0xf0b0 | ((lowpan6_buffer[lowpan6_offset] >> 4) & 0x0f)); - udphdr->dest = lwip_htons(0xf0b0 | (lowpan6_buffer[lowpan6_offset] & 0x0f)); - lowpan6_offset += 1; - } - - udphdr->chksum = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); - lowpan6_offset += 2; - ip6_offset += UDP_HLEN; - if (datagram_size == 0) { - datagram_size = compressed_size - lowpan6_offset + ip6_offset; - } - udphdr->len = lwip_htons(datagram_size - IP6_HLEN); - - } else -#endif /* LWIP_UDP */ - { - LWIP_DEBUGF(LWIP_DBG_ON,("NHC: unsupported protocol!\n")); - /* @todo support NHC other than UDP */ - return ERR_VAL; - } - } - if (datagram_size == 0) { - datagram_size = compressed_size - lowpan6_offset + ip6_offset; - } - /* Infer IPv6 payload length for header */ - IP6H_PLEN_SET(ip6hdr, datagram_size - IP6_HLEN); - - if (lowpan6_offset > lowpan6_bufsize) { - /* input buffer overflow */ - return ERR_VAL; - } - *hdr_size_comp = lowpan6_offset; - *hdr_size_decomp = ip6_offset; - - return ERR_OK; -} - -struct pbuf * -lowpan6_decompress(struct pbuf *p, u16_t datagram_size, ip6_addr_t *lowpan6_contexts, - struct lowpan6_link_addr *src, struct lowpan6_link_addr *dest) -{ - struct pbuf *q; - u16_t lowpan6_offset, ip6_offset; - err_t err; - -#if LWIP_UDP -#define UDP_HLEN_ALLOC UDP_HLEN -#else -#define UDP_HLEN_ALLOC 0 -#endif - - /* Allocate a buffer for decompression. This buffer will be too big and will be - trimmed once the final size is known. */ - q = pbuf_alloc(PBUF_IP, p->len + IP6_HLEN + UDP_HLEN_ALLOC, PBUF_POOL); - if (q == NULL) { - pbuf_free(p); - return NULL; - } - if (q->len < IP6_HLEN + UDP_HLEN_ALLOC) { - /* The headers need to fit into the first pbuf */ - pbuf_free(p); - pbuf_free(q); - return NULL; - } - - /* Decompress the IPv6 (and possibly UDP) header(s) into the new pbuf */ - err = lowpan6_decompress_hdr((u8_t *)p->payload, p->len, (u8_t *)q->payload, q->len, - &lowpan6_offset, &ip6_offset, datagram_size, p->tot_len, lowpan6_contexts, src, dest); - if (err != ERR_OK) { - pbuf_free(p); - pbuf_free(q); - return NULL; - } - - /* Now we copy leftover contents from p to q, so we have all L2 and L3 headers - (and L4?) in a single pbuf: */ - - /* Hide the compressed headers in p */ - pbuf_remove_header(p, lowpan6_offset); - /* Temporarily hide the headers in q... */ - pbuf_remove_header(q, ip6_offset); - /* ... copy the rest of p into q... */ - pbuf_copy(q, p); - /* ... and reveal the headers again... */ - pbuf_add_header_force(q, ip6_offset); - /* ... trim the pbuf to its correct size... */ - pbuf_realloc(q, ip6_offset + p->len); - /* ... and cat possibly remaining (data-only) pbufs */ - if (p->next != NULL) { - pbuf_cat(q, p->next); - } - /* the original (first) pbuf can now be freed */ - p->next = NULL; - pbuf_free(p); - - /* all done */ - return q; -} - -#endif /* LWIP_6LOWPAN_IPHC */ -#endif /* LWIP_IPV6 */ +/** + * @file + * + * Common 6LowPAN routines for IPv6. Uses ND tables for link-layer addressing. Fragments packets to 6LowPAN units. + * + * This implementation aims to conform to IEEE 802.15.4(-2015), RFC 4944 and RFC 6282. + * @todo: RFC 6775. + */ + +/* + * Copyright (c) 2015 Inico Technologies 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Ivan Delamer + * + * + * Please coordinate changes and requests with Ivan Delamer + * + */ + +/** + * @defgroup sixlowpan 6LoWPAN (RFC4944) + * @ingroup netifs + * 6LowPAN netif implementation + */ + +#include "netif/lowpan6_common.h" + +#if LWIP_IPV6 + +#include "lwip/ip.h" +#include "lwip/pbuf.h" +#include "lwip/ip_addr.h" +#include "lwip/netif.h" +#include "lwip/udp.h" + +#include + +/* Determine compression mode for unicast address. */ +s8_t +lowpan6_get_address_mode(const ip6_addr_t *ip6addr, const struct lowpan6_link_addr *mac_addr) +{ + if (mac_addr->addr_len == 2) { + if ((ip6addr->addr[2] == (u32_t)PP_HTONL(0x000000ff)) && + ((ip6addr->addr[3] & PP_HTONL(0xffff0000)) == PP_NTOHL(0xfe000000))) { + if ((ip6addr->addr[3] & PP_HTONL(0x0000ffff)) == lwip_ntohl((mac_addr->addr[0] << 8) | mac_addr->addr[1])) { + return 3; + } + } + } else if (mac_addr->addr_len == 8) { + if ((ip6addr->addr[2] == lwip_ntohl(((mac_addr->addr[0] ^ 2) << 24) | (mac_addr->addr[1] << 16) | mac_addr->addr[2] << 8 | mac_addr->addr[3])) && + (ip6addr->addr[3] == lwip_ntohl((mac_addr->addr[4] << 24) | (mac_addr->addr[5] << 16) | mac_addr->addr[6] << 8 | mac_addr->addr[7]))) { + return 3; + } + } + + if ((ip6addr->addr[2] == PP_HTONL(0x000000ffUL)) && + ((ip6addr->addr[3] & PP_HTONL(0xffff0000)) == PP_NTOHL(0xfe000000UL))) { + return 2; + } + + return 1; +} + +#if LWIP_6LOWPAN_IPHC + +/* Determine compression mode for multicast address. */ +static s8_t +lowpan6_get_address_mode_mc(const ip6_addr_t *ip6addr) +{ + if ((ip6addr->addr[0] == PP_HTONL(0xff020000)) && + (ip6addr->addr[1] == 0) && + (ip6addr->addr[2] == 0) && + ((ip6addr->addr[3] & PP_HTONL(0xffffff00)) == 0)) { + return 3; + } else if (((ip6addr->addr[0] & PP_HTONL(0xff00ffff)) == PP_HTONL(0xff000000)) && + (ip6addr->addr[1] == 0)) { + if ((ip6addr->addr[2] == 0) && + ((ip6addr->addr[3] & PP_HTONL(0xff000000)) == 0)) { + return 2; + } else if ((ip6addr->addr[2] & PP_HTONL(0xffffff00)) == 0) { + return 1; + } + } + + return 0; +} + +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 +static s8_t +lowpan6_context_lookup(const ip6_addr_t *lowpan6_contexts, const ip6_addr_t *ip6addr) +{ + s8_t i; + + for (i = 0; i < LWIP_6LOWPAN_NUM_CONTEXTS; i++) { + if (ip6_addr_netcmp(&lowpan6_contexts[i], ip6addr)) { + return i; + } + } + return -1; +} +#endif /* LWIP_6LOWPAN_NUM_CONTEXTS > 0 */ + +/* + * Compress IPv6 and/or UDP headers. + * */ +err_t +lowpan6_compress_headers(struct netif *netif, u8_t *inbuf, size_t inbuf_size, u8_t *outbuf, size_t outbuf_size, + u8_t *lowpan6_header_len_out, u8_t *hidden_header_len_out, ip6_addr_t *lowpan6_contexts, + const struct lowpan6_link_addr *src, const struct lowpan6_link_addr *dst) +{ + u8_t *buffer, *inptr; + u8_t lowpan6_header_len; + u8_t hidden_header_len = 0; + s8_t i; + struct ip6_hdr *ip6hdr; + ip_addr_t ip6src, ip6dst; + + LWIP_ASSERT("netif != NULL", netif != NULL); + LWIP_ASSERT("inbuf != NULL", inbuf != NULL); + LWIP_ASSERT("outbuf != NULL", outbuf != NULL); + LWIP_ASSERT("lowpan6_header_len_out != NULL", lowpan6_header_len_out != NULL); + LWIP_ASSERT("hidden_header_len_out != NULL", hidden_header_len_out != NULL); + + /* Perform 6LowPAN IPv6 header compression according to RFC 6282 */ + buffer = outbuf; + inptr = inbuf; + + if (inbuf_size < IP6_HLEN) { + /* input buffer too short */ + return ERR_VAL; + } + if (outbuf_size < IP6_HLEN) { + /* output buffer too short for worst case */ + return ERR_MEM; + } + + /* Point to ip6 header and align copies of src/dest addresses. */ + ip6hdr = (struct ip6_hdr *)inptr; + ip_addr_copy_from_ip6_packed(ip6dst, ip6hdr->dest); + ip6_addr_assign_zone(ip_2_ip6(&ip6dst), IP6_UNKNOWN, netif); + ip_addr_copy_from_ip6_packed(ip6src, ip6hdr->src); + ip6_addr_assign_zone(ip_2_ip6(&ip6src), IP6_UNKNOWN, netif); + + /* Basic length of 6LowPAN header, set dispatch and clear fields. */ + lowpan6_header_len = 2; + buffer[0] = 0x60; + buffer[1] = 0; + + /* Determine whether there will be a Context Identifier Extension byte or not. + * If so, set it already. */ +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 + buffer[2] = 0; + + i = lowpan6_context_lookup(lowpan6_contexts, ip_2_ip6(&ip6src)); + if (i >= 0) { + /* Stateful source address compression. */ + buffer[1] |= 0x40; + buffer[2] |= (i & 0x0f) << 4; + } + + i = lowpan6_context_lookup(lowpan6_contexts, ip_2_ip6(&ip6dst)); + if (i >= 0) { + /* Stateful destination address compression. */ + buffer[1] |= 0x04; + buffer[2] |= i & 0x0f; + } + + if (buffer[2] != 0x00) { + /* Context identifier extension byte is appended. */ + buffer[1] |= 0x80; + lowpan6_header_len++; + } +#else /* LWIP_6LOWPAN_NUM_CONTEXTS > 0 */ + LWIP_UNUSED_ARG(lowpan6_contexts); +#endif /* LWIP_6LOWPAN_NUM_CONTEXTS > 0 */ + + /* Determine TF field: Traffic Class, Flow Label */ + if (IP6H_FL(ip6hdr) == 0) { + /* Flow label is elided. */ + buffer[0] |= 0x10; + if (IP6H_TC(ip6hdr) == 0) { + /* Traffic class (ECN+DSCP) elided too. */ + buffer[0] |= 0x08; + } else { + /* Traffic class (ECN+DSCP) appended. */ + buffer[lowpan6_header_len++] = IP6H_TC(ip6hdr); + } + } else { + if (((IP6H_TC(ip6hdr) & 0x3f) == 0)) { + /* DSCP portion of Traffic Class is elided, ECN and FL are appended (3 bytes) */ + buffer[0] |= 0x08; + + buffer[lowpan6_header_len] = IP6H_TC(ip6hdr) & 0xc0; + buffer[lowpan6_header_len++] |= (IP6H_FL(ip6hdr) >> 16) & 0x0f; + buffer[lowpan6_header_len++] = (IP6H_FL(ip6hdr) >> 8) & 0xff; + buffer[lowpan6_header_len++] = IP6H_FL(ip6hdr) & 0xff; + } else { + /* Traffic class and flow label are appended (4 bytes) */ + buffer[lowpan6_header_len++] = IP6H_TC(ip6hdr); + buffer[lowpan6_header_len++] = (IP6H_FL(ip6hdr) >> 16) & 0x0f; + buffer[lowpan6_header_len++] = (IP6H_FL(ip6hdr) >> 8) & 0xff; + buffer[lowpan6_header_len++] = IP6H_FL(ip6hdr) & 0xff; + } + } + + /* Compress NH? + * Only if UDP for now. @todo support other NH compression. */ + if (IP6H_NEXTH(ip6hdr) == IP6_NEXTH_UDP) { + buffer[0] |= 0x04; + } else { + /* append nexth. */ + buffer[lowpan6_header_len++] = IP6H_NEXTH(ip6hdr); + } + + /* Compress hop limit? */ + if (IP6H_HOPLIM(ip6hdr) == 255) { + buffer[0] |= 0x03; + } else if (IP6H_HOPLIM(ip6hdr) == 64) { + buffer[0] |= 0x02; + } else if (IP6H_HOPLIM(ip6hdr) == 1) { + buffer[0] |= 0x01; + } else { + /* append hop limit */ + buffer[lowpan6_header_len++] = IP6H_HOPLIM(ip6hdr); + } + + /* Compress source address */ + if (((buffer[1] & 0x40) != 0) || + (ip6_addr_islinklocal(ip_2_ip6(&ip6src)))) { + /* Context-based or link-local source address compression. */ + i = lowpan6_get_address_mode(ip_2_ip6(&ip6src), src); + buffer[1] |= (i & 0x03) << 4; + if (i == 1) { + MEMCPY(buffer + lowpan6_header_len, inptr + 16, 8); + lowpan6_header_len += 8; + } else if (i == 2) { + MEMCPY(buffer + lowpan6_header_len, inptr + 22, 2); + lowpan6_header_len += 2; + } + } else if (ip6_addr_isany(ip_2_ip6(&ip6src))) { + /* Special case: mark SAC and leave SAM=0 */ + buffer[1] |= 0x40; + } else { + /* Append full address. */ + MEMCPY(buffer + lowpan6_header_len, inptr + 8, 16); + lowpan6_header_len += 16; + } + + /* Compress destination address */ + if (ip6_addr_ismulticast(ip_2_ip6(&ip6dst))) { + /* @todo support stateful multicast address compression */ + + buffer[1] |= 0x08; + + i = lowpan6_get_address_mode_mc(ip_2_ip6(&ip6dst)); + buffer[1] |= i & 0x03; + if (i == 0) { + MEMCPY(buffer + lowpan6_header_len, inptr + 24, 16); + lowpan6_header_len += 16; + } else if (i == 1) { + buffer[lowpan6_header_len++] = inptr[25]; + MEMCPY(buffer + lowpan6_header_len, inptr + 35, 5); + lowpan6_header_len += 5; + } else if (i == 2) { + buffer[lowpan6_header_len++] = inptr[25]; + MEMCPY(buffer + lowpan6_header_len, inptr + 37, 3); + lowpan6_header_len += 3; + } else if (i == 3) { + buffer[lowpan6_header_len++] = (inptr)[39]; + } + } else if (((buffer[1] & 0x04) != 0) || + (ip6_addr_islinklocal(ip_2_ip6(&ip6dst)))) { + /* Context-based or link-local destination address compression. */ + i = lowpan6_get_address_mode(ip_2_ip6(&ip6dst), dst); + buffer[1] |= i & 0x03; + if (i == 1) { + MEMCPY(buffer + lowpan6_header_len, inptr + 32, 8); + lowpan6_header_len += 8; + } else if (i == 2) { + MEMCPY(buffer + lowpan6_header_len, inptr + 38, 2); + lowpan6_header_len += 2; + } + } else { + /* Append full address. */ + MEMCPY(buffer + lowpan6_header_len, inptr + 24, 16); + lowpan6_header_len += 16; + } + + /* Move to payload. */ + inptr += IP6_HLEN; + hidden_header_len += IP6_HLEN; + +#if LWIP_UDP + /* Compress UDP header? */ + if (IP6H_NEXTH(ip6hdr) == IP6_NEXTH_UDP) { + /* @todo support optional checksum compression */ + + if (inbuf_size < IP6_HLEN + UDP_HLEN) { + /* input buffer too short */ + return ERR_VAL; + } + if (outbuf_size < (size_t)(hidden_header_len + 7)) { + /* output buffer too short for worst case */ + return ERR_MEM; + } + + buffer[lowpan6_header_len] = 0xf0; + + /* determine port compression mode. */ + if ((inptr[0] == 0xf0) && ((inptr[1] & 0xf0) == 0xb0) && + (inptr[2] == 0xf0) && ((inptr[3] & 0xf0) == 0xb0)) { + /* Compress source and dest ports. */ + buffer[lowpan6_header_len++] |= 0x03; + buffer[lowpan6_header_len++] = ((inptr[1] & 0x0f) << 4) | (inptr[3] & 0x0f); + } else if (inptr[0] == 0xf0) { + /* Compress source port. */ + buffer[lowpan6_header_len++] |= 0x02; + buffer[lowpan6_header_len++] = inptr[1]; + buffer[lowpan6_header_len++] = inptr[2]; + buffer[lowpan6_header_len++] = inptr[3]; + } else if (inptr[2] == 0xf0) { + /* Compress dest port. */ + buffer[lowpan6_header_len++] |= 0x01; + buffer[lowpan6_header_len++] = inptr[0]; + buffer[lowpan6_header_len++] = inptr[1]; + buffer[lowpan6_header_len++] = inptr[3]; + } else { + /* append full ports. */ + lowpan6_header_len++; + buffer[lowpan6_header_len++] = inptr[0]; + buffer[lowpan6_header_len++] = inptr[1]; + buffer[lowpan6_header_len++] = inptr[2]; + buffer[lowpan6_header_len++] = inptr[3]; + } + + /* elide length and copy checksum */ + buffer[lowpan6_header_len++] = inptr[6]; + buffer[lowpan6_header_len++] = inptr[7]; + + hidden_header_len += UDP_HLEN; + } +#endif /* LWIP_UDP */ + + *lowpan6_header_len_out = lowpan6_header_len; + *hidden_header_len_out = hidden_header_len; + + return ERR_OK; +} + +/** Decompress IPv6 and UDP headers compressed according to RFC 6282 + * + * @param lowpan6_buffer compressed headers, first byte is the dispatch byte + * @param lowpan6_bufsize size of lowpan6_buffer (may include data after headers) + * @param decomp_buffer buffer where the decompressed headers are stored + * @param decomp_bufsize size of decomp_buffer + * @param hdr_size_comp returns the size of the compressed headers (skip to get to data) + * @param hdr_size_decomp returns the size of the decompressed headers (IPv6 + UDP) + * @param datagram_size datagram size from fragments or 0 if unfragmented + * @param compressed_size compressed datagram size (for unfragmented rx) + * @param lowpan6_contexts context addresses + * @param src source address of the outer layer, used for address compression + * @param dest destination address of the outer layer, used for address compression + * @return ERR_OK if decompression succeeded, an error otherwise + */ +static err_t +lowpan6_decompress_hdr(u8_t *lowpan6_buffer, size_t lowpan6_bufsize, + u8_t *decomp_buffer, size_t decomp_bufsize, + u16_t *hdr_size_comp, u16_t *hdr_size_decomp, + u16_t datagram_size, u16_t compressed_size, + ip6_addr_t *lowpan6_contexts, + struct lowpan6_link_addr *src, struct lowpan6_link_addr *dest) +{ + u16_t lowpan6_offset; + struct ip6_hdr *ip6hdr; + s8_t i; + u32_t header_temp; + u16_t ip6_offset = IP6_HLEN; + + LWIP_ASSERT("lowpan6_buffer != NULL", lowpan6_buffer != NULL); + LWIP_ASSERT("decomp_buffer != NULL", decomp_buffer != NULL); + LWIP_ASSERT("src != NULL", src != NULL); + LWIP_ASSERT("dest != NULL", dest != NULL); + LWIP_ASSERT("hdr_size_comp != NULL", hdr_size_comp != NULL); + LWIP_ASSERT("dehdr_size_decompst != NULL", hdr_size_decomp != NULL); + + ip6hdr = (struct ip6_hdr *)decomp_buffer; + if (decomp_bufsize < IP6_HLEN) { + return ERR_MEM; + } + + /* output the full compressed packet, if set in @see lowpan6_opts.h */ +#if LWIP_LOWPAN6_IP_COMPRESSED_DEBUG + { + u16_t j; + LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("lowpan6_decompress_hdr: IP6 payload (compressed): \n")); + for (j = 0; j < lowpan6_bufsize; j++) { + if ((j % 4) == 0) { + LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("\n")); + } + LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("%2X ", lowpan6_buffer[j])); + } + LWIP_DEBUGF(LWIP_LOWPAN6_IP_COMPRESSED_DEBUG, ("\np->len: %d", lowpan6_bufsize)); + } +#endif + + /* offset for inline IP headers (RFC 6282 ch3)*/ + lowpan6_offset = 2; + /* if CID is set (context identifier), the context byte + * follows immediately after the header, so other IPHC fields are @+3 */ + if (lowpan6_buffer[1] & 0x80) { + lowpan6_offset++; + } + + /* Set IPv6 version, traffic class and flow label. (RFC6282, ch 3.1.1.)*/ + if ((lowpan6_buffer[0] & 0x18) == 0x00) { + header_temp = ((lowpan6_buffer[lowpan6_offset+1] & 0x0f) << 16) | \ + (lowpan6_buffer[lowpan6_offset + 2] << 8) | lowpan6_buffer[lowpan6_offset+3]; + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 00, ECN: 0x%2x, Flowlabel+DSCP: 0x%8X\n", \ + lowpan6_buffer[lowpan6_offset],header_temp)); + IP6H_VTCFL_SET(ip6hdr, 6, lowpan6_buffer[lowpan6_offset], header_temp); + /* increase offset, processed 4 bytes here: + * TF=00: ECN + DSCP + 4-bit Pad + Flow Label (4 bytes)*/ + lowpan6_offset += 4; + } else if ((lowpan6_buffer[0] & 0x18) == 0x08) { + header_temp = ((lowpan6_buffer[lowpan6_offset] & 0x0f) << 16) | (lowpan6_buffer[lowpan6_offset + 1] << 8) | lowpan6_buffer[lowpan6_offset+2]; + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 01, ECN: 0x%2x, Flowlabel: 0x%2X, DSCP ignored\n", \ + lowpan6_buffer[lowpan6_offset] & 0xc0,header_temp)); + IP6H_VTCFL_SET(ip6hdr, 6, lowpan6_buffer[lowpan6_offset] & 0xc0, header_temp); + /* increase offset, processed 3 bytes here: + * TF=01: ECN + 2-bit Pad + Flow Label (3 bytes), DSCP is elided.*/ + lowpan6_offset += 3; + } else if ((lowpan6_buffer[0] & 0x18) == 0x10) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 10, DCSP+ECN: 0x%2x, Flowlabel ignored\n", lowpan6_buffer[lowpan6_offset])); + IP6H_VTCFL_SET(ip6hdr, 6, lowpan6_buffer[lowpan6_offset],0); + /* increase offset, processed 1 byte here: + * ECN + DSCP (1 byte), Flow Label is elided.*/ + lowpan6_offset += 1; + } else if ((lowpan6_buffer[0] & 0x18) == 0x18) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("TF: 11, DCSP/ECN & Flowlabel ignored\n")); + /* don't increase offset, no bytes processed here */ + IP6H_VTCFL_SET(ip6hdr, 6, 0, 0); + } + + /* Set Next Header (NH) */ + if ((lowpan6_buffer[0] & 0x04) == 0x00) { + /* 0: full next header byte carried inline (increase offset)*/ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NH: 0x%2X\n", lowpan6_buffer[lowpan6_offset+1])); + IP6H_NEXTH_SET(ip6hdr, lowpan6_buffer[lowpan6_offset++]); + } else { + /* 1: NH compression, LOWPAN_NHC (RFC6282, ch 4.1) */ + /* We should fill this later with NHC decoding */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NH: skipped, later done with NHC\n")); + IP6H_NEXTH_SET(ip6hdr, 0); + } + + /* Set Hop Limit, either carried inline or 3 different hops (1,64,255) */ + if ((lowpan6_buffer[0] & 0x03) == 0x00) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: full value: %d\n", lowpan6_buffer[lowpan6_offset+1])); + IP6H_HOPLIM_SET(ip6hdr, lowpan6_buffer[lowpan6_offset++]); + } else if ((lowpan6_buffer[0] & 0x03) == 0x01) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: compressed: 1\n")); + IP6H_HOPLIM_SET(ip6hdr, 1); + } else if ((lowpan6_buffer[0] & 0x03) == 0x02) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: compressed: 64\n")); + IP6H_HOPLIM_SET(ip6hdr, 64); + } else if ((lowpan6_buffer[0] & 0x03) == 0x03) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Hops: compressed: 255\n")); + IP6H_HOPLIM_SET(ip6hdr, 255); + } + + /* Source address decoding. */ + if ((lowpan6_buffer[1] & 0x40) == 0x00) { + /* Source address compression (SAC) = 0 -> stateless compression */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAC == 0, no context byte\n")); + /* Stateless compression */ + if ((lowpan6_buffer[1] & 0x30) == 0x00) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 00, no src compression, fetching 128bits inline\n")); + /* copy full address, increase offset by 16 Bytes */ + MEMCPY(&ip6hdr->src.addr[0], lowpan6_buffer + lowpan6_offset, 16); + lowpan6_offset += 16; + } else if ((lowpan6_buffer[1] & 0x30) == 0x10) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 01, src compression, 64bits inline\n")); + /* set 64 bits to link local */ + ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL); + ip6hdr->src.addr[1] = 0; + /* copy 8 Bytes, increase offset */ + MEMCPY(&ip6hdr->src.addr[2], lowpan6_buffer + lowpan6_offset, 8); + lowpan6_offset += 8; + } else if ((lowpan6_buffer[1] & 0x30) == 0x20) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 10, src compression, 16bits inline\n")); + /* set 96 bits to link local */ + ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL); + ip6hdr->src.addr[1] = 0; + ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); + /* extract remaining 16bits from inline bytes, increase offset */ + ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | + lowpan6_buffer[lowpan6_offset + 1]); + lowpan6_offset += 2; + } else if ((lowpan6_buffer[1] & 0x30) == 0x30) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 11, src compression, 0bits inline, using other headers\n")); + /* no information avalaible, using other layers, see RFC6282 ch 3.2.2 */ + ip6hdr->src.addr[0] = PP_HTONL(0xfe800000UL); + ip6hdr->src.addr[1] = 0; + if (src->addr_len == 2) { + ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); + ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]); + } else if (src->addr_len == 8) { + ip6hdr->src.addr[2] = lwip_htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) | + (src->addr[2] << 8) | src->addr[3]); + ip6hdr->src.addr[3] = lwip_htonl((src->addr[4] << 24) | (src->addr[5] << 16) | + (src->addr[6] << 8) | src->addr[7]); + } else { + /* invalid source address length */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Invalid source address length\n")); + return ERR_VAL; + } + } + } else { + /* Source address compression (SAC) = 1 -> stateful/context-based compression */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAC == 1, additional context byte\n")); + if ((lowpan6_buffer[1] & 0x30) == 0x00) { + /* SAM=00, address=> :: (ANY) */ + ip6hdr->src.addr[0] = 0; + ip6hdr->src.addr[1] = 0; + ip6hdr->src.addr[2] = 0; + ip6hdr->src.addr[3] = 0; + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 00, context compression, ANY (::)\n")); + } else { + /* Set prefix from context info */ + if (lowpan6_buffer[1] & 0x80) { + i = (lowpan6_buffer[2] >> 4) & 0x0f; + } else { + i = 0; + } + if (i >= LWIP_6LOWPAN_NUM_CONTEXTS) { + /* Error */ + return ERR_VAL; + } +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 + ip6hdr->src.addr[0] = lowpan6_contexts[i].addr[0]; + ip6hdr->src.addr[1] = lowpan6_contexts[i].addr[1]; + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == xx, context compression found @%d: %8X, %8X\n", (int)i, ip6hdr->src.addr[0], ip6hdr->src.addr[1])); +#else + LWIP_UNUSED_ARG(lowpan6_contexts); +#endif + } + + /* determine further address bits */ + if ((lowpan6_buffer[1] & 0x30) == 0x10) { + /* SAM=01, load additional 64bits */ + MEMCPY(&ip6hdr->src.addr[2], lowpan6_buffer + lowpan6_offset, 8); + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 01, context compression, 64bits inline\n")); + lowpan6_offset += 8; + } else if ((lowpan6_buffer[1] & 0x30) == 0x20) { + /* SAM=01, load additional 16bits */ + ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); + ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset + 1]); + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 10, context compression, 16bits inline\n")); + lowpan6_offset += 2; + } else if ((lowpan6_buffer[1] & 0x30) == 0x30) { + /* SAM=11, address is fully elided, load from other layers */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("SAM == 11, context compression, 0bits inline, using other headers\n")); + if (src->addr_len == 2) { + ip6hdr->src.addr[2] = PP_HTONL(0x000000ffUL); + ip6hdr->src.addr[3] = lwip_htonl(0xfe000000UL | (src->addr[0] << 8) | src->addr[1]); + } else if (src->addr_len == 8) { + ip6hdr->src.addr[2] = lwip_htonl(((src->addr[0] ^ 2) << 24) | (src->addr[1] << 16) | (src->addr[2] << 8) | src->addr[3]); + ip6hdr->src.addr[3] = lwip_htonl((src->addr[4] << 24) | (src->addr[5] << 16) | (src->addr[6] << 8) | src->addr[7]); + } else { + /* invalid source address length */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Invalid source address length\n")); + return ERR_VAL; + } + } + } + + /* Destination address decoding. */ + if (lowpan6_buffer[1] & 0x08) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("M=1: multicast\n")); + /* Multicast destination */ + if (lowpan6_buffer[1] & 0x04) { + LWIP_DEBUGF(LWIP_DBG_ON,("DAC == 1, context multicast: unsupported!!!\n")); + /* @todo support stateful multicast addressing */ + return ERR_VAL; + } + + if ((lowpan6_buffer[1] & 0x03) == 0x00) { + /* DAM = 00, copy full address (128bits) */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 00, no dst compression, fetching 128bits inline\n")); + MEMCPY(&ip6hdr->dest.addr[0], lowpan6_buffer + lowpan6_offset, 16); + lowpan6_offset += 16; + } else if ((lowpan6_buffer[1] & 0x03) == 0x01) { + /* DAM = 01, copy 4 bytes (32bits) */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 01, dst address form (48bits): ffXX::00XX:XXXX:XXXX\n")); + ip6hdr->dest.addr[0] = lwip_htonl(0xff000000UL | (lowpan6_buffer[lowpan6_offset++] << 16)); + ip6hdr->dest.addr[1] = 0; + ip6hdr->dest.addr[2] = lwip_htonl(lowpan6_buffer[lowpan6_offset++]); + ip6hdr->dest.addr[3] = lwip_htonl((lowpan6_buffer[lowpan6_offset] << 24) | (lowpan6_buffer[lowpan6_offset + 1] << 16) | (lowpan6_buffer[lowpan6_offset + 2] << 8) | lowpan6_buffer[lowpan6_offset + 3]); + lowpan6_offset += 4; + } else if ((lowpan6_buffer[1] & 0x03) == 0x02) { + /* DAM = 10, copy 3 bytes (24bits) */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 10, dst address form (32bits): ffXX::00XX:XXXX\n")); + ip6hdr->dest.addr[0] = lwip_htonl(0xff000000UL | (lowpan6_buffer[lowpan6_offset++] << 16)); + ip6hdr->dest.addr[1] = 0; + ip6hdr->dest.addr[2] = 0; + ip6hdr->dest.addr[3] = lwip_htonl((lowpan6_buffer[lowpan6_offset] << 16) | (lowpan6_buffer[lowpan6_offset + 1] << 8) | lowpan6_buffer[lowpan6_offset + 2]); + lowpan6_offset += 3; + } else if ((lowpan6_buffer[1] & 0x03) == 0x03) { + /* DAM = 11, copy 1 byte (8bits) */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 11, dst address form (8bits): ff02::00XX\n")); + ip6hdr->dest.addr[0] = PP_HTONL(0xff020000UL); + ip6hdr->dest.addr[1] = 0; + ip6hdr->dest.addr[2] = 0; + ip6hdr->dest.addr[3] = lwip_htonl(lowpan6_buffer[lowpan6_offset++]); + } + + } else { + /* no Multicast (M=0) */ + if (lowpan6_buffer[1] & 0x04) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAC == 1, stateful compression\n")); + /* Stateful destination compression */ + /* Set prefix from context info */ + if (lowpan6_buffer[1] & 0x80) { + i = lowpan6_buffer[2] & 0x0f; + } else { + i = 0; + } + if (i >= LWIP_6LOWPAN_NUM_CONTEXTS) { + /* Error */ + return ERR_VAL; + } +#if LWIP_6LOWPAN_NUM_CONTEXTS > 0 + ip6hdr->dest.addr[0] = lowpan6_contexts[i].addr[0]; + ip6hdr->dest.addr[1] = lowpan6_contexts[i].addr[1]; +#endif + } else { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAC == 0, stateless compression, setting link local prefix\n")); + /* Link local address compression */ + ip6hdr->dest.addr[0] = PP_HTONL(0xfe800000UL); + ip6hdr->dest.addr[1] = 0; + } + + /* M=0, DAC=0, determining destination address length via DAM=xx */ + if ((lowpan6_buffer[1] & 0x03) == 0x00) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 00, no dst compression, fetching 128bits inline")); + /* DAM=00, copy full address */ + MEMCPY(&ip6hdr->dest.addr[0], lowpan6_buffer + lowpan6_offset, 16); + lowpan6_offset += 16; + } else if ((lowpan6_buffer[1] & 0x03) == 0x01) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 01, dst compression, 64bits inline\n")); + /* DAM=01, copy 64 inline bits, increase offset */ + MEMCPY(&ip6hdr->dest.addr[2], lowpan6_buffer + lowpan6_offset, 8); + lowpan6_offset += 8; + } else if ((lowpan6_buffer[1] & 0x03) == 0x02) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("DAM == 01, dst compression, 16bits inline\n")); + /* DAM=10, copy 16 inline bits, increase offset */ + ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL); + ip6hdr->dest.addr[3] = lwip_htonl(0xfe000000UL | (lowpan6_buffer[lowpan6_offset] << 8) | lowpan6_buffer[lowpan6_offset + 1]); + lowpan6_offset += 2; + } else if ((lowpan6_buffer[1] & 0x03) == 0x03) { + /* DAM=11, no bits available, use other headers (not done here) */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG,("DAM == 01, dst compression, 0bits inline, using other headers\n")); + if (dest->addr_len == 2) { + ip6hdr->dest.addr[2] = PP_HTONL(0x000000ffUL); + ip6hdr->dest.addr[3] = lwip_htonl(0xfe000000UL | (dest->addr[0] << 8) | dest->addr[1]); + } else if (dest->addr_len == 8) { + ip6hdr->dest.addr[2] = lwip_htonl(((dest->addr[0] ^ 2) << 24) | (dest->addr[1] << 16) | dest->addr[2] << 8 | dest->addr[3]); + ip6hdr->dest.addr[3] = lwip_htonl((dest->addr[4] << 24) | (dest->addr[5] << 16) | dest->addr[6] << 8 | dest->addr[7]); + } else { + /* invalid destination address length */ + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("Invalid destination address length\n")); + return ERR_VAL; + } + } + } + + + /* Next Header Compression (NHC) decoding? */ + if (lowpan6_buffer[0] & 0x04) { + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NHC decoding\n")); +#if LWIP_UDP + if ((lowpan6_buffer[lowpan6_offset] & 0xf8) == 0xf0) { + /* NHC: UDP */ + struct udp_hdr *udphdr; + LWIP_DEBUGF(LWIP_LOWPAN6_DECOMPRESSION_DEBUG, ("NHC: UDP\n")); + + /* UDP compression */ + IP6H_NEXTH_SET(ip6hdr, IP6_NEXTH_UDP); + udphdr = (struct udp_hdr *)((u8_t *)decomp_buffer + ip6_offset); + if (decomp_bufsize < IP6_HLEN + UDP_HLEN) { + return ERR_MEM; + } + + /* Checksum decompression */ + if (lowpan6_buffer[lowpan6_offset] & 0x04) { + /* @todo support checksum decompress */ + LWIP_DEBUGF(LWIP_DBG_ON, ("NHC: UDP chechsum decompression UNSUPPORTED\n")); + return ERR_VAL; + } + + /* Decompress ports, according to RFC4944 */ + i = lowpan6_buffer[lowpan6_offset++] & 0x03; + if (i == 0) { + udphdr->src = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); + udphdr->dest = lwip_htons(lowpan6_buffer[lowpan6_offset + 2] << 8 | lowpan6_buffer[lowpan6_offset + 3]); + lowpan6_offset += 4; + } else if (i == 0x01) { + udphdr->src = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); + udphdr->dest = lwip_htons(0xf000 | lowpan6_buffer[lowpan6_offset + 2]); + lowpan6_offset += 3; + } else if (i == 0x02) { + udphdr->src = lwip_htons(0xf000 | lowpan6_buffer[lowpan6_offset]); + udphdr->dest = lwip_htons(lowpan6_buffer[lowpan6_offset + 1] << 8 | lowpan6_buffer[lowpan6_offset + 2]); + lowpan6_offset += 3; + } else if (i == 0x03) { + udphdr->src = lwip_htons(0xf0b0 | ((lowpan6_buffer[lowpan6_offset] >> 4) & 0x0f)); + udphdr->dest = lwip_htons(0xf0b0 | (lowpan6_buffer[lowpan6_offset] & 0x0f)); + lowpan6_offset += 1; + } + + udphdr->chksum = lwip_htons(lowpan6_buffer[lowpan6_offset] << 8 | lowpan6_buffer[lowpan6_offset + 1]); + lowpan6_offset += 2; + ip6_offset += UDP_HLEN; + if (datagram_size == 0) { + datagram_size = compressed_size - lowpan6_offset + ip6_offset; + } + udphdr->len = lwip_htons(datagram_size - IP6_HLEN); + + } else +#endif /* LWIP_UDP */ + { + LWIP_DEBUGF(LWIP_DBG_ON,("NHC: unsupported protocol!\n")); + /* @todo support NHC other than UDP */ + return ERR_VAL; + } + } + if (datagram_size == 0) { + datagram_size = compressed_size - lowpan6_offset + ip6_offset; + } + /* Infer IPv6 payload length for header */ + IP6H_PLEN_SET(ip6hdr, datagram_size - IP6_HLEN); + + if (lowpan6_offset > lowpan6_bufsize) { + /* input buffer overflow */ + return ERR_VAL; + } + *hdr_size_comp = lowpan6_offset; + *hdr_size_decomp = ip6_offset; + + return ERR_OK; +} + +struct pbuf * +lowpan6_decompress(struct pbuf *p, u16_t datagram_size, ip6_addr_t *lowpan6_contexts, + struct lowpan6_link_addr *src, struct lowpan6_link_addr *dest) +{ + struct pbuf *q; + u16_t lowpan6_offset, ip6_offset; + err_t err; + +#if LWIP_UDP +#define UDP_HLEN_ALLOC UDP_HLEN +#else +#define UDP_HLEN_ALLOC 0 +#endif + + /* Allocate a buffer for decompression. This buffer will be too big and will be + trimmed once the final size is known. */ + q = pbuf_alloc(PBUF_IP, p->len + IP6_HLEN + UDP_HLEN_ALLOC, PBUF_POOL); + if (q == NULL) { + pbuf_free(p); + return NULL; + } + if (q->len < IP6_HLEN + UDP_HLEN_ALLOC) { + /* The headers need to fit into the first pbuf */ + pbuf_free(p); + pbuf_free(q); + return NULL; + } + + /* Decompress the IPv6 (and possibly UDP) header(s) into the new pbuf */ + err = lowpan6_decompress_hdr((u8_t *)p->payload, p->len, (u8_t *)q->payload, q->len, + &lowpan6_offset, &ip6_offset, datagram_size, p->tot_len, lowpan6_contexts, src, dest); + if (err != ERR_OK) { + pbuf_free(p); + pbuf_free(q); + return NULL; + } + + /* Now we copy leftover contents from p to q, so we have all L2 and L3 headers + (and L4?) in a single pbuf: */ + + /* Hide the compressed headers in p */ + pbuf_remove_header(p, lowpan6_offset); + /* Temporarily hide the headers in q... */ + pbuf_remove_header(q, ip6_offset); + /* ... copy the rest of p into q... */ + pbuf_copy(q, p); + /* ... and reveal the headers again... */ + pbuf_add_header_force(q, ip6_offset); + /* ... trim the pbuf to its correct size... */ + pbuf_realloc(q, ip6_offset + p->len); + /* ... and cat possibly remaining (data-only) pbufs */ + if (p->next != NULL) { + pbuf_cat(q, p->next); + } + /* the original (first) pbuf can now be freed */ + p->next = NULL; + pbuf_free(p); + + /* all done */ + return q; +} + +#endif /* LWIP_6LOWPAN_IPHC */ +#endif /* LWIP_IPV6 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/PPPD_FOLLOWUP b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/PPPD_FOLLOWUP index e131de2d..c231982a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/PPPD_FOLLOWUP +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/PPPD_FOLLOWUP @@ -1,473 +1,473 @@ -The lwIP PPP support is based from pppd 2.4.5 (http://ppp.samba.org) with -huge changes to match code size and memory requirements for embedded devices. - -Anyway, pppd has a mature codebase for years and the average commit count -is getting low on their Git repository, meaning that we can follow what -is happening on their side and merge what is relevant for lwIP. - -So, here is the pppd follow up, so that we don't get away too far from pppd. - - -== Patch fetched from from pppd Debian packages == - -This has nothing to do with pppd, but we merged some good patch from -Debian and this is a good place to be. - -- LCP adaptive echo, so that we don't send LCP echo request if we - are receiving data from peer, can be enabled by setting PPP_LCP_ADAPTIVE - to true. - -- IPCP no/replace default route option, were added in the early stage of - the ppp port, but it wasn't really helpful and was disabled when adding - the new API ppp_set_default() call, which gives the lwIP user control over - which one is the default interface, it was actually a requirement if you - are doing PPP over PPP (i.e. PPPoL2TP, VPN link, over PPPoE, ADSL link). - -- using rp-pppoe pppd exits with EXIT_OK after receiving a timeout waiting - for PADO due to no modem attached, bug reported to pppd bug tracker, fixed - in Debian but not in the latest (at the time when the port were started) - pppd release. - - -== Commits on pppd == - -2010-03-06 - Document +ipv6 and ipv6cp-accept-local - e7537958aee79b3f653c601e903cb31d78fb7dcc - -Don't care. - - -2010-03-06 - Install pppol2tp plugins with sane permissions - 406215672cfadc03017341fe03802d1c7294b903 - -Don't care. - - -2010-03-07 - pppd: Terminate correctly if lcp_lowerup delayed calling - fsm_lowerup - 3eb9e810cfa515543655659b72dde30c54fea0a5 - -Merged 2012-05-17. - - -2010-03-07 - rp_pppoe: Copy acName and pppd_pppoe_service after option parsing - cab58617fd9d328029fffabc788020264b4fa91f - -Don't care, is a patch for pppd/plugins/rp-pppoe/plugin.c which is not part -of the port. - - -2010-08-23 - set and reset options to control environment variables - for scripts. - 2b6310fd24dba8e0fca8999916a162f0a1842a84 - -We can't fork processes in embedded, therefore all the pppd process run -feature is disabled in the port, so we don't care about the new -"environment variables" pppd feature. - - -2010-08-23 - Nit: use _exit when exec fails and restrict values to 0-255 - per POSIX. - 2b4ea140432eeba5a007c0d4e6236bd0e0c12ba4 - -Again, we are not running as a heavy process, so all exit() or _exit() calls -were removed. - - -2010-08-23 - Fix quote handling in configuration files to be more like shell - quoting. - 3089132cdf5b58dbdfc2daf08ec5c08eb47f8aca - -We are not parsing config file, all the filesystem I/O stuff were disabled -in our port. - - -2010-08-24 - rp-pppoe: allow MTU to be increased up to 1500 - fd1dcdf758418f040da3ed801ab001b5e46854e7 - -Only concern changes on RP-PPPoE plugin, which we don't use. - - -2010-09-11 - chat: Allow TIMEOUT value to come from environment variable - ae80bf833e48a6202f44a935a68083ae52ad3824 - -See 2b6310fd24dba8e0fca8999916a162f0a1842a84. - - -2011-03-05 - pppdump: Fix printfs with insufficient arguments - 7b8db569642c83ba3283745034f2e2c95e459423 - -pppdump is a ppp tool outside pppd source tree. - - -2012-05-06 - pppd: Don't unconditionally disable VJ compression under Linux - d8a66adf98a0e525cf38031b42098d539da6eeb6 - -Patch for sys-linux.c, which we don't use. - - -2012-05-20 - Remove old version of Linux if_pppol2tp.h - c41092dd4c49267f232f6cba3d31c6c68bfdf68d - -Not in the port. - - -2012-05-20 - pppd: Make MSCHAP-v2 cope better with packet loss - 08ef47ca532294eb428238c831616748940e24a2 - -This is an interesting patch. However it consumes much more memory for -MSCHAP and I am not sure if the benefit worth it. The PPP client can -always start the authentication again if it failed for whatever reason. - - -2012-05-20 - scripts: Make poff ignore extra arguments to pppd - 18f515f32c9f5723a9c2c912601e04335106534b - -Again, we are not running scripts. - - -2012-05-20 - rp-pppoe plugin: Print leading zeros in MAC address - f5dda0cfc220c4b52e26144096d729e27b30f0f7 - -Again, we are not using the RP-PPPoE plugin. - - -2012-05-20 - pppd: Notify IPv6 up/down as we do for IPv4 - 845cda8fa18939cf56e60b073f63a7efa65336fc - -This is just a patch that adds plugins hooks for IPv6, the plugin interface -was disabled because we don't have .so plugins in embedded. - - -2012-05-20 - pppd: Enable IPV6 by default and fix some warnings - 0b6118239615e98959f7e0b4e746bdd197533248 - -Change on Makefile for IPv6, warnings were already cleared during port. - - -2012-05-20 - contrib: Fix pppgetpass.gtk compilation - 80a8e2ce257ca12cce723519a0f20ea1d663b14a - -Change on Makefile, don't care. - - -2012-05-20 - pppd: Don't crash if crypt() returns NULL - 04c4348108d847e034dd91066cc6843f60d71731 - -We are using the PolarSSL DES implementation that does not return NULL. - - -2012-05-20 - pppd: Eliminate some warnings - c44ae5e6a7338c96eb463881fe709b2dfaffe568 - -Again, we are handling compilation warnings on our own. - - -2012-05-20 - rp-pppoe plugin: Import some fixes from rp-pppoe-3.10 - 1817d83e51a411044e730ba89ebdb0480e1c8cd4 - -Once more, we are not using the RP-PPPoE plugin. - - -2013-01-23 - pppd: Clarify circumstances where DNS1/DNS2 environment variables are set - cf2f5c9538b9400ade23446a194729b0a4113b3a - -Documentation only. - - -2013-02-03 - ppp: ignore unrecognised radiusclient configuration directives - 7f736dde0da3c19855997d9e67370e351e15e923 - -Radius plugin, not in the port. - - -2013-02-03 - pppd: Take out unused %r conversion completely - 356d8d558d844412119aa18c8e5a113bc6459c7b - -Merged 2014-04-15. - - -2013-02-03 - pppd: Arrange to use logwtmp from libutil on Linux - 9617a7eb137f4fee62799a677a9ecf8d834db3f5 - -Patch for sys-linux.c, which we don't use. - - -2013-02-03 - pppdump: Eliminate some compiler warnings - 3e3acf1ba2b3046c072a42c19164788a9e419bd1 - -pppdump is a ppp tool outside pppd source tree. - - -2013-02-03 - chat: Correct spelling errors in the man page - 8dea1b969d266ccbf6f3a8c5474eb6dcd8838e3b - -Documentation only. - - -2013-02-03 - pppd: Fix spelling errors in man page - 9e05a25d76b3f83096c661678010320df673df6b - -Documentation only. - - -2013-02-03 - plugins/passprompt: Fix potential out-of-bounds array reference - 8edb889b753056a691a3e4b217a110a35f9fdedb - -Plugin patch, we do not have plugins. - - -2013-02-03 - chat: Fix *roff errors in the man page - a7c3489eeaf44e83ce592143c7c8a5b5c29f4c48 - -Documentation only. - - -2013-03-02 - pppd: Fix man page description of case when remote IP address isn't known - 224841f4799f4f1e2e71bc490c54448d66740f4f - -Documentation only. - - -2013-03-02 - pppd: Add master_detach option - 398ed2585640d198c53e736ee5bbd67f7ce8168e - -Option for multilink support, we do not support multilink and this option -is about detaching from the terminal, which is out of the embedded scope. - - -2013-03-11 - pppd: Default exit status to EXIT_CONNECT_FAILED during connection phase - 225361d64ae737afdc8cb57579a2f33525461bc9 - -Commented out in our port, and already fixed by a previously applied Debian patch. - - -2013-03-11 - pppstats: Fix undefined macro in man page - d16a3985eade5280b8e171f5dd0670a91cba0d39 - -Documentation only. - - -2013-05-11 - plugins/radius: Handle bindaddr keyword in radiusclient.conf - d883b2dbafeed3ebd9d7a56ab1469373bd001a3b - -Radius plugin, not in the port. - - -2013-06-09 - pppoatm: Remove explicit loading of pppoatm kernel module - 52cd43a84bea524033b918b603698104f221bbb7 - -PPPoATM plugin, not in the port. - - -2013-06-09 - pppd: Fix segfault in update_db_entry() - 37476164f15a45015310b9d4b197c2d7db1f7f8f - -We do not use the samba db. - - -2013-06-09 - chat: Fix some text that was intended to be literal - cd9683676618adcee8add2c3cfa3382341b5a1f6 - -Documentation only. - - -2013-06-09 - README.pppoe: Minor semantic fix - b5b8898af6fd3d44e873cfc66810ace5f1f47e17 - -Documentation only. - - -2013-06-10 - radius: Handle additional attributes - 2f581cd986a56f2ec4a95abad4f8297a1b10d7e2 - -Radius plugin, not in the port. - - -2013-06-10 - chat, pppd: Use \e instead of \\ in man pages - 8d6942415d22f6ca4377340ca26e345c3f5fa5db - -Documentation only. - - -2014-01-02 - pppd: Don't crash if NULL pointer passed to vslprintf for %q or %v - 906814431bddeb2061825fa1ebad1a967b6d87a9 - -Merged 2014-04-15. - - -2014-01-02 - pppd: Accept IPCP ConfAck packets containing MS-WINS options - a243f217f1c6ac1aa7793806bc88590d077f490a - -Merged 2014-04-15. - - -2014-01-02 - config: Update Solaris compiler options and enable CHAPMS and IPV6 - 99c46caaed01b7edba87962aa52b77fad61bfd7b - -Solaris port, don't care. - - -2014-01-02 - Update README and patchlevel for 2.4.6 release - 4043750fca36e7e0eb90d702e048ad1da4929418 - -Just release stuff. - - -2014-02-18 - pppd: Add option "stop-bits" to set number of serial port stop bits. - ad993a20ee485f0d0e2ac4105221641b200da6e2 - -Low level serial port, not in the port. - - -2014-03-09 - pppd: Separate IPv6 handling for sifup/sifdown - b04d2dc6df5c6b5650fea44250d58757ee3dac4a - -Reimplemented. - - -2014-03-09 - pppol2tp: Connect up/down events to notifiers and add IPv6 ones - fafbe50251efc7d6b4a8be652d085316e112b34f - -Not in the port. - - -2014-03-09 - pppd: Add declarations to eliminate compile warnings - 50967962addebe15c7a7e63116ff46a0441dc464 - -We are handling compilation warnings on our own - - -2014-03-09 - pppd: Eliminate some unnecessary ifdefs - de8da14d845ee6db9236ccfddabf1d8ebf045ddb - -We mostly did that previously. Anyway, merged 2014-12-24. - - -2014-08-01 - radius: Fix realms-config-file option - 880a81be7c8e0fe8567227bc17a1bff3ea035943 - -Radius plugin, not in the port. - - -2014-08-01 - pppd: Eliminate potential integer overflow in option parsing - 7658e8257183f062dc01f87969c140707c7e52cb - -pppd config file parser, not in the port. - - -2014-08-01 - pppd: Eliminate memory leak with multiple instances of a string option - b94b7fbbaa0589aa6ec5fdc733aeb9ff294d2656 - -pppd config file parser, not in the port. - - -2014-08-01 - pppd: Fix a stack variable overflow in MSCHAP-v2 - 36733a891fb56594fcee580f667b33a64b990981 - -This fixes a bug introduced in 08ef47ca ("pppd: Make MSCHAP-v2 cope better with packet loss"). - -We didn't merge 08ef47ca ;-) - - -2014-08-01 - winbind plugin: Add -DMPPE=1 to eliminate compiler warnings - 2b05e22c62095e97dd0a97e4b5588402c2185071 - -Linux plugin, not in the port. - - -2014-08-09 - Update README and patchlevel for 2.4.7 release - 6e8eaa7a78b31cdab2edf140a9c8afdb02ffaca5 - -Just release stuff. - - -2014-08-10 - abort on errors in subdir builds - 5e90783d11a59268e05f4cfb29ce2343b13e8ab2 - -Linux Makefile, not in the port. - - -2014-06-03 - pppd: add support for defaultroute-metric option - 35e5a569c988b1ff865b02a24d9a727a00db4da9 - -Only necessary for Linux, lwIP does not support route metrics. - - -2014-12-13 - scripts: Avoid killing wrong pppd - 67811a647d399db5d188a242827760615a0f86b5 - -pppd helper script, not in the port. - - -2014-12-20 - pppd: Fix sign-extension when displaying bytes in octal - 5e8c3cb256a7e86e3572a82a75d51c6850efdbdc - -Merged 2016-07-02. - - -2015-03-01 - Suppress false error message on PPPoE disconnect - 219aac3b53d0827549377f1bfe22853ee52d4405 - -PPPoE plugin, not in the port. - - -2015-03-01 - Send PADT on PPPoE disconnect - cd2c14f998c57bbe6a01dc5854f2763c0d7f31fb - -PPPoE plugin, not in the port. And our PPPoE implementation already does -that: pppoe_disconnect() calls pppoe_send_padt(). - - -2015-08-14 - pppd: ipxcp: Prevent buffer overrun on remote router name - fe149de624f96629a7f46732055d8f718c74b856 - -We never ported IPX support. lwIP does not support IPX. - - -2015-03-25 - pppd: Fix ccp_options.mppe type - 234edab99a6bb250cc9ecd384cca27b0c8b475ce - -We found that while working on MPPE support in lwIP, that's our patch ;-) - - -2015-03-24 - pppd: Fix ccp_cilen calculated size if both deflate_correct and deflate_draft are enabled - 094cb8ae4c61db225e67fedadb4964f846dd0c27 - -We found that while working on MPPE support in lwIP, that's our patch ;-) - - -2015-08-14 - Merge branch 'master' of https://github.com/ncopa/ppp - 3a5c9a8fbc8970375cd881151d44e4b6fe249c6a - -Merge commit, we don't care. - - -2015-08-14 - Merge branch 'master' of git://github.com/vapier/ppp - 912e4fc6665aca188dced7ea7fdc663ce5a2dd24 - -Merge commit, we don't care. - - -2015-08-14 - Merge branch 'bug_fix' of git://github.com/radaiming/ppp - dfd33d7f526ecd7b39dd1bba8101260d02af5ebb - -Merge commit, we don't care. - - -2015-08-14 - Merge branch 'master' of git://github.com/pprindeville/ppp - aa4a985f6114d08cf4e47634fb6325da71016473 - -Merge commit, we don't care. - - -2015-08-14 - Merge branch 'no-error-on-already-closed' of git://github.com/farnz/ppp - 6edf252483b30dbcdcc5059f01831455365d5b6e - -Merge commit, we don't care. - - -2015-08-14 - Merge branch 'send-padt-on-disconnect' of git://github.com/farnz/ppp - 84684243d651f55f6df69d2a6707b52fbbe62bb9 - -Merge commit, we don't care. +The lwIP PPP support is based from pppd 2.4.5 (http://ppp.samba.org) with +huge changes to match code size and memory requirements for embedded devices. + +Anyway, pppd has a mature codebase for years and the average commit count +is getting low on their Git repository, meaning that we can follow what +is happening on their side and merge what is relevant for lwIP. + +So, here is the pppd follow up, so that we don't get away too far from pppd. + + +== Patch fetched from from pppd Debian packages == + +This has nothing to do with pppd, but we merged some good patch from +Debian and this is a good place to be. + +- LCP adaptive echo, so that we don't send LCP echo request if we + are receiving data from peer, can be enabled by setting PPP_LCP_ADAPTIVE + to true. + +- IPCP no/replace default route option, were added in the early stage of + the ppp port, but it wasn't really helpful and was disabled when adding + the new API ppp_set_default() call, which gives the lwIP user control over + which one is the default interface, it was actually a requirement if you + are doing PPP over PPP (i.e. PPPoL2TP, VPN link, over PPPoE, ADSL link). + +- using rp-pppoe pppd exits with EXIT_OK after receiving a timeout waiting + for PADO due to no modem attached, bug reported to pppd bug tracker, fixed + in Debian but not in the latest (at the time when the port were started) + pppd release. + + +== Commits on pppd == + +2010-03-06 - Document +ipv6 and ipv6cp-accept-local + e7537958aee79b3f653c601e903cb31d78fb7dcc + +Don't care. + + +2010-03-06 - Install pppol2tp plugins with sane permissions + 406215672cfadc03017341fe03802d1c7294b903 + +Don't care. + + +2010-03-07 - pppd: Terminate correctly if lcp_lowerup delayed calling + fsm_lowerup + 3eb9e810cfa515543655659b72dde30c54fea0a5 + +Merged 2012-05-17. + + +2010-03-07 - rp_pppoe: Copy acName and pppd_pppoe_service after option parsing + cab58617fd9d328029fffabc788020264b4fa91f + +Don't care, is a patch for pppd/plugins/rp-pppoe/plugin.c which is not part +of the port. + + +2010-08-23 - set and reset options to control environment variables + for scripts. + 2b6310fd24dba8e0fca8999916a162f0a1842a84 + +We can't fork processes in embedded, therefore all the pppd process run +feature is disabled in the port, so we don't care about the new +"environment variables" pppd feature. + + +2010-08-23 - Nit: use _exit when exec fails and restrict values to 0-255 + per POSIX. + 2b4ea140432eeba5a007c0d4e6236bd0e0c12ba4 + +Again, we are not running as a heavy process, so all exit() or _exit() calls +were removed. + + +2010-08-23 - Fix quote handling in configuration files to be more like shell + quoting. + 3089132cdf5b58dbdfc2daf08ec5c08eb47f8aca + +We are not parsing config file, all the filesystem I/O stuff were disabled +in our port. + + +2010-08-24 - rp-pppoe: allow MTU to be increased up to 1500 + fd1dcdf758418f040da3ed801ab001b5e46854e7 + +Only concern changes on RP-PPPoE plugin, which we don't use. + + +2010-09-11 - chat: Allow TIMEOUT value to come from environment variable + ae80bf833e48a6202f44a935a68083ae52ad3824 + +See 2b6310fd24dba8e0fca8999916a162f0a1842a84. + + +2011-03-05 - pppdump: Fix printfs with insufficient arguments + 7b8db569642c83ba3283745034f2e2c95e459423 + +pppdump is a ppp tool outside pppd source tree. + + +2012-05-06 - pppd: Don't unconditionally disable VJ compression under Linux + d8a66adf98a0e525cf38031b42098d539da6eeb6 + +Patch for sys-linux.c, which we don't use. + + +2012-05-20 - Remove old version of Linux if_pppol2tp.h + c41092dd4c49267f232f6cba3d31c6c68bfdf68d + +Not in the port. + + +2012-05-20 - pppd: Make MSCHAP-v2 cope better with packet loss + 08ef47ca532294eb428238c831616748940e24a2 + +This is an interesting patch. However it consumes much more memory for +MSCHAP and I am not sure if the benefit worth it. The PPP client can +always start the authentication again if it failed for whatever reason. + + +2012-05-20 - scripts: Make poff ignore extra arguments to pppd + 18f515f32c9f5723a9c2c912601e04335106534b + +Again, we are not running scripts. + + +2012-05-20 - rp-pppoe plugin: Print leading zeros in MAC address + f5dda0cfc220c4b52e26144096d729e27b30f0f7 + +Again, we are not using the RP-PPPoE plugin. + + +2012-05-20 - pppd: Notify IPv6 up/down as we do for IPv4 + 845cda8fa18939cf56e60b073f63a7efa65336fc + +This is just a patch that adds plugins hooks for IPv6, the plugin interface +was disabled because we don't have .so plugins in embedded. + + +2012-05-20 - pppd: Enable IPV6 by default and fix some warnings + 0b6118239615e98959f7e0b4e746bdd197533248 + +Change on Makefile for IPv6, warnings were already cleared during port. + + +2012-05-20 - contrib: Fix pppgetpass.gtk compilation + 80a8e2ce257ca12cce723519a0f20ea1d663b14a + +Change on Makefile, don't care. + + +2012-05-20 - pppd: Don't crash if crypt() returns NULL + 04c4348108d847e034dd91066cc6843f60d71731 + +We are using the PolarSSL DES implementation that does not return NULL. + + +2012-05-20 - pppd: Eliminate some warnings + c44ae5e6a7338c96eb463881fe709b2dfaffe568 + +Again, we are handling compilation warnings on our own. + + +2012-05-20 - rp-pppoe plugin: Import some fixes from rp-pppoe-3.10 + 1817d83e51a411044e730ba89ebdb0480e1c8cd4 + +Once more, we are not using the RP-PPPoE plugin. + + +2013-01-23 - pppd: Clarify circumstances where DNS1/DNS2 environment variables are set + cf2f5c9538b9400ade23446a194729b0a4113b3a + +Documentation only. + + +2013-02-03 - ppp: ignore unrecognised radiusclient configuration directives + 7f736dde0da3c19855997d9e67370e351e15e923 + +Radius plugin, not in the port. + + +2013-02-03 - pppd: Take out unused %r conversion completely + 356d8d558d844412119aa18c8e5a113bc6459c7b + +Merged 2014-04-15. + + +2013-02-03 - pppd: Arrange to use logwtmp from libutil on Linux + 9617a7eb137f4fee62799a677a9ecf8d834db3f5 + +Patch for sys-linux.c, which we don't use. + + +2013-02-03 - pppdump: Eliminate some compiler warnings + 3e3acf1ba2b3046c072a42c19164788a9e419bd1 + +pppdump is a ppp tool outside pppd source tree. + + +2013-02-03 - chat: Correct spelling errors in the man page + 8dea1b969d266ccbf6f3a8c5474eb6dcd8838e3b + +Documentation only. + + +2013-02-03 - pppd: Fix spelling errors in man page + 9e05a25d76b3f83096c661678010320df673df6b + +Documentation only. + + +2013-02-03 - plugins/passprompt: Fix potential out-of-bounds array reference + 8edb889b753056a691a3e4b217a110a35f9fdedb + +Plugin patch, we do not have plugins. + + +2013-02-03 - chat: Fix *roff errors in the man page + a7c3489eeaf44e83ce592143c7c8a5b5c29f4c48 + +Documentation only. + + +2013-03-02 - pppd: Fix man page description of case when remote IP address isn't known + 224841f4799f4f1e2e71bc490c54448d66740f4f + +Documentation only. + + +2013-03-02 - pppd: Add master_detach option + 398ed2585640d198c53e736ee5bbd67f7ce8168e + +Option for multilink support, we do not support multilink and this option +is about detaching from the terminal, which is out of the embedded scope. + + +2013-03-11 - pppd: Default exit status to EXIT_CONNECT_FAILED during connection phase + 225361d64ae737afdc8cb57579a2f33525461bc9 + +Commented out in our port, and already fixed by a previously applied Debian patch. + + +2013-03-11 - pppstats: Fix undefined macro in man page + d16a3985eade5280b8e171f5dd0670a91cba0d39 + +Documentation only. + + +2013-05-11 - plugins/radius: Handle bindaddr keyword in radiusclient.conf + d883b2dbafeed3ebd9d7a56ab1469373bd001a3b + +Radius plugin, not in the port. + + +2013-06-09 - pppoatm: Remove explicit loading of pppoatm kernel module + 52cd43a84bea524033b918b603698104f221bbb7 + +PPPoATM plugin, not in the port. + + +2013-06-09 - pppd: Fix segfault in update_db_entry() + 37476164f15a45015310b9d4b197c2d7db1f7f8f + +We do not use the samba db. + + +2013-06-09 - chat: Fix some text that was intended to be literal + cd9683676618adcee8add2c3cfa3382341b5a1f6 + +Documentation only. + + +2013-06-09 - README.pppoe: Minor semantic fix + b5b8898af6fd3d44e873cfc66810ace5f1f47e17 + +Documentation only. + + +2013-06-10 - radius: Handle additional attributes + 2f581cd986a56f2ec4a95abad4f8297a1b10d7e2 + +Radius plugin, not in the port. + + +2013-06-10 - chat, pppd: Use \e instead of \\ in man pages + 8d6942415d22f6ca4377340ca26e345c3f5fa5db + +Documentation only. + + +2014-01-02 - pppd: Don't crash if NULL pointer passed to vslprintf for %q or %v + 906814431bddeb2061825fa1ebad1a967b6d87a9 + +Merged 2014-04-15. + + +2014-01-02 - pppd: Accept IPCP ConfAck packets containing MS-WINS options + a243f217f1c6ac1aa7793806bc88590d077f490a + +Merged 2014-04-15. + + +2014-01-02 - config: Update Solaris compiler options and enable CHAPMS and IPV6 + 99c46caaed01b7edba87962aa52b77fad61bfd7b + +Solaris port, don't care. + + +2014-01-02 - Update README and patchlevel for 2.4.6 release + 4043750fca36e7e0eb90d702e048ad1da4929418 + +Just release stuff. + + +2014-02-18 - pppd: Add option "stop-bits" to set number of serial port stop bits. + ad993a20ee485f0d0e2ac4105221641b200da6e2 + +Low level serial port, not in the port. + + +2014-03-09 - pppd: Separate IPv6 handling for sifup/sifdown + b04d2dc6df5c6b5650fea44250d58757ee3dac4a + +Reimplemented. + + +2014-03-09 - pppol2tp: Connect up/down events to notifiers and add IPv6 ones + fafbe50251efc7d6b4a8be652d085316e112b34f + +Not in the port. + + +2014-03-09 - pppd: Add declarations to eliminate compile warnings + 50967962addebe15c7a7e63116ff46a0441dc464 + +We are handling compilation warnings on our own + + +2014-03-09 - pppd: Eliminate some unnecessary ifdefs + de8da14d845ee6db9236ccfddabf1d8ebf045ddb + +We mostly did that previously. Anyway, merged 2014-12-24. + + +2014-08-01 - radius: Fix realms-config-file option + 880a81be7c8e0fe8567227bc17a1bff3ea035943 + +Radius plugin, not in the port. + + +2014-08-01 - pppd: Eliminate potential integer overflow in option parsing + 7658e8257183f062dc01f87969c140707c7e52cb + +pppd config file parser, not in the port. + + +2014-08-01 - pppd: Eliminate memory leak with multiple instances of a string option + b94b7fbbaa0589aa6ec5fdc733aeb9ff294d2656 + +pppd config file parser, not in the port. + + +2014-08-01 - pppd: Fix a stack variable overflow in MSCHAP-v2 + 36733a891fb56594fcee580f667b33a64b990981 + +This fixes a bug introduced in 08ef47ca ("pppd: Make MSCHAP-v2 cope better with packet loss"). + +We didn't merge 08ef47ca ;-) + + +2014-08-01 - winbind plugin: Add -DMPPE=1 to eliminate compiler warnings + 2b05e22c62095e97dd0a97e4b5588402c2185071 + +Linux plugin, not in the port. + + +2014-08-09 - Update README and patchlevel for 2.4.7 release + 6e8eaa7a78b31cdab2edf140a9c8afdb02ffaca5 + +Just release stuff. + + +2014-08-10 - abort on errors in subdir builds + 5e90783d11a59268e05f4cfb29ce2343b13e8ab2 + +Linux Makefile, not in the port. + + +2014-06-03 - pppd: add support for defaultroute-metric option + 35e5a569c988b1ff865b02a24d9a727a00db4da9 + +Only necessary for Linux, lwIP does not support route metrics. + + +2014-12-13 - scripts: Avoid killing wrong pppd + 67811a647d399db5d188a242827760615a0f86b5 + +pppd helper script, not in the port. + + +2014-12-20 - pppd: Fix sign-extension when displaying bytes in octal + 5e8c3cb256a7e86e3572a82a75d51c6850efdbdc + +Merged 2016-07-02. + + +2015-03-01 - Suppress false error message on PPPoE disconnect + 219aac3b53d0827549377f1bfe22853ee52d4405 + +PPPoE plugin, not in the port. + + +2015-03-01 - Send PADT on PPPoE disconnect + cd2c14f998c57bbe6a01dc5854f2763c0d7f31fb + +PPPoE plugin, not in the port. And our PPPoE implementation already does +that: pppoe_disconnect() calls pppoe_send_padt(). + + +2015-08-14 - pppd: ipxcp: Prevent buffer overrun on remote router name + fe149de624f96629a7f46732055d8f718c74b856 + +We never ported IPX support. lwIP does not support IPX. + + +2015-03-25 - pppd: Fix ccp_options.mppe type + 234edab99a6bb250cc9ecd384cca27b0c8b475ce + +We found that while working on MPPE support in lwIP, that's our patch ;-) + + +2015-03-24 - pppd: Fix ccp_cilen calculated size if both deflate_correct and deflate_draft are enabled + 094cb8ae4c61db225e67fedadb4964f846dd0c27 + +We found that while working on MPPE support in lwIP, that's our patch ;-) + + +2015-08-14 - Merge branch 'master' of https://github.com/ncopa/ppp + 3a5c9a8fbc8970375cd881151d44e4b6fe249c6a + +Merge commit, we don't care. + + +2015-08-14 - Merge branch 'master' of git://github.com/vapier/ppp + 912e4fc6665aca188dced7ea7fdc663ce5a2dd24 + +Merge commit, we don't care. + + +2015-08-14 - Merge branch 'bug_fix' of git://github.com/radaiming/ppp + dfd33d7f526ecd7b39dd1bba8101260d02af5ebb + +Merge commit, we don't care. + + +2015-08-14 - Merge branch 'master' of git://github.com/pprindeville/ppp + aa4a985f6114d08cf4e47634fb6325da71016473 + +Merge commit, we don't care. + + +2015-08-14 - Merge branch 'no-error-on-already-closed' of git://github.com/farnz/ppp + 6edf252483b30dbcdcc5059f01831455365d5b6e + +Merge commit, we don't care. + + +2015-08-14 - Merge branch 'send-padt-on-disconnect' of git://github.com/farnz/ppp + 84684243d651f55f6df69d2a6707b52fbbe62bb9 + +Merge commit, we don't care. diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/auth.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/auth.c index fee01ae1..c8673ad0 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/auth.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/auth.c @@ -1,2510 +1,2510 @@ -/* - * auth.c - PPP authentication and phase control. - * - * Copyright (c) 1993-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * Derived from main.c, which is: - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#if 0 /* UNUSED */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#if defined(_PATH_LASTLOG) && defined(__linux__) -#include -#endif - -#include -#include -#include - -#ifdef HAS_SHADOW -#include -#ifndef PW_PPP -#define PW_PPP PW_LOGIN -#endif -#endif - -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/lcp.h" -#if CCP_SUPPORT -#include "netif/ppp/ccp.h" -#endif /* CCP_SUPPORT */ -#if ECP_SUPPORT -#include "netif/ppp/ecp.h" -#endif /* ECP_SUPPORT */ -#include "netif/ppp/ipcp.h" -#if PAP_SUPPORT -#include "netif/ppp/upap.h" -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT -#include "netif/ppp/chap-new.h" -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT -#include "netif/ppp/eap.h" -#endif /* EAP_SUPPORT */ -#if CBCP_SUPPORT -#include "netif/ppp/cbcp.h" -#endif - -#if 0 /* UNUSED */ -#include "session.h" -#endif /* UNUSED */ - -#if 0 /* UNUSED */ -/* Bits in scan_authfile return value */ -#define NONWILD_SERVER 1 -#define NONWILD_CLIENT 2 - -#define ISWILD(word) (word[0] == '*' && word[1] == 0) -#endif /* UNUSED */ - -#if 0 /* UNUSED */ -/* List of addresses which the peer may use. */ -static struct permitted_ip *addresses[NUM_PPP]; - -/* Wordlist giving addresses which the peer may use - without authenticating itself. */ -static struct wordlist *noauth_addrs; - -/* Remote telephone number, if available */ -char remote_number[MAXNAMELEN]; - -/* Wordlist giving remote telephone numbers which may connect. */ -static struct wordlist *permitted_numbers; - -/* Extra options to apply, from the secrets file entry for the peer. */ -static struct wordlist *extra_options; -#endif /* UNUSED */ - -#if 0 /* UNUSED */ -/* Set if we require authentication only because we have a default route. */ -static bool default_auth; - -/* Hook to enable a plugin to control the idle time limit */ -int (*idle_time_hook) (struct ppp_idle *) = NULL; - -/* Hook for a plugin to say whether we can possibly authenticate any peer */ -int (*pap_check_hook) (void) = NULL; - -/* Hook for a plugin to check the PAP user and password */ -int (*pap_auth_hook) (char *user, char *passwd, char **msgp, - struct wordlist **paddrs, - struct wordlist **popts) = NULL; - -/* Hook for a plugin to know about the PAP user logout */ -void (*pap_logout_hook) (void) = NULL; - -/* Hook for a plugin to get the PAP password for authenticating us */ -int (*pap_passwd_hook) (char *user, char *passwd) = NULL; - -/* Hook for a plugin to say if we can possibly authenticate a peer using CHAP */ -int (*chap_check_hook) (void) = NULL; - -/* Hook for a plugin to get the CHAP password for authenticating us */ -int (*chap_passwd_hook) (char *user, char *passwd) = NULL; - -/* Hook for a plugin to say whether it is OK if the peer - refuses to authenticate. */ -int (*null_auth_hook) (struct wordlist **paddrs, - struct wordlist **popts) = NULL; - -int (*allowed_address_hook) (u32_t addr) = NULL; -#endif /* UNUSED */ - -#ifdef HAVE_MULTILINK -/* Hook for plugin to hear when an interface joins a multilink bundle */ -void (*multilink_join_hook) (void) = NULL; -#endif - -#if PPP_NOTIFY -/* A notifier for when the peer has authenticated itself, - and we are proceeding to the network phase. */ -struct notifier *auth_up_notifier = NULL; - -/* A notifier for when the link goes down. */ -struct notifier *link_down_notifier = NULL; -#endif /* PPP_NOTIFY */ - -/* - * Option variables. - */ -#if 0 /* MOVED TO ppp_settings */ -bool uselogin = 0; /* Use /etc/passwd for checking PAP */ -bool session_mgmt = 0; /* Do session management (login records) */ -bool cryptpap = 0; /* Passwords in pap-secrets are encrypted */ -bool refuse_pap = 0; /* Don't wanna auth. ourselves with PAP */ -bool refuse_chap = 0; /* Don't wanna auth. ourselves with CHAP */ -bool refuse_eap = 0; /* Don't wanna auth. ourselves with EAP */ -#if MSCHAP_SUPPORT -bool refuse_mschap = 0; /* Don't wanna auth. ourselves with MS-CHAP */ -bool refuse_mschap_v2 = 0; /* Don't wanna auth. ourselves with MS-CHAPv2 */ -#else /* MSCHAP_SUPPORT */ -bool refuse_mschap = 1; /* Don't wanna auth. ourselves with MS-CHAP */ -bool refuse_mschap_v2 = 1; /* Don't wanna auth. ourselves with MS-CHAPv2 */ -#endif /* MSCHAP_SUPPORT */ -bool usehostname = 0; /* Use hostname for our_name */ -bool auth_required = 0; /* Always require authentication from peer */ -bool allow_any_ip = 0; /* Allow peer to use any IP address */ -bool explicit_remote = 0; /* User specified explicit remote name */ -bool explicit_user = 0; /* Set if "user" option supplied */ -bool explicit_passwd = 0; /* Set if "password" option supplied */ -char remote_name[MAXNAMELEN]; /* Peer's name for authentication */ -static char *uafname; /* name of most recent +ua file */ - -extern char *crypt (const char *, const char *); -#endif /* UNUSED */ -/* Prototypes for procedures local to this file. */ - -static void network_phase(ppp_pcb *pcb); -#if PPP_IDLETIMELIMIT -static void check_idle(void *arg); -#endif /* PPP_IDLETIMELIMIT */ -#if PPP_MAXCONNECT -static void connect_time_expired(void *arg); -#endif /* PPP_MAXCONNECT */ -#if 0 /* UNUSED */ -static int null_login (int); -/* static int get_pap_passwd (char *); */ -static int have_pap_secret (int *); -static int have_chap_secret (char *, char *, int, int *); -static int have_srp_secret (char *client, char *server, int need_ip, - int *lacks_ipp); -static int ip_addr_check (u32_t, struct permitted_ip *); -static int scan_authfile (FILE *, char *, char *, char *, - struct wordlist **, struct wordlist **, - char *, int); -static void free_wordlist (struct wordlist *); -static void set_allowed_addrs (int, struct wordlist *, struct wordlist *); -static int some_ip_ok (struct wordlist *); -static int setupapfile (char **); -static int privgroup (char **); -static int set_noauth_addr (char **); -static int set_permitted_number (char **); -static void check_access (FILE *, char *); -static int wordlist_count (struct wordlist *); -#endif /* UNUSED */ - -#ifdef MAXOCTETS -static void check_maxoctets (void *); -#endif - -#if PPP_OPTIONS -/* - * Authentication-related options. - */ -option_t auth_options[] = { - { "auth", o_bool, &auth_required, - "Require authentication from peer", OPT_PRIO | 1 }, - { "noauth", o_bool, &auth_required, - "Don't require peer to authenticate", OPT_PRIOSUB | OPT_PRIV, - &allow_any_ip }, - { "require-pap", o_bool, &lcp_wantoptions[0].neg_upap, - "Require PAP authentication from peer", - OPT_PRIOSUB | 1, &auth_required }, - { "+pap", o_bool, &lcp_wantoptions[0].neg_upap, - "Require PAP authentication from peer", - OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required }, - { "require-chap", o_bool, &auth_required, - "Require CHAP authentication from peer", - OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5, - &lcp_wantoptions[0].chap_mdtype }, - { "+chap", o_bool, &auth_required, - "Require CHAP authentication from peer", - OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5, - &lcp_wantoptions[0].chap_mdtype }, -#if MSCHAP_SUPPORT - { "require-mschap", o_bool, &auth_required, - "Require MS-CHAP authentication from peer", - OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT, - &lcp_wantoptions[0].chap_mdtype }, - { "+mschap", o_bool, &auth_required, - "Require MS-CHAP authentication from peer", - OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT, - &lcp_wantoptions[0].chap_mdtype }, - { "require-mschap-v2", o_bool, &auth_required, - "Require MS-CHAPv2 authentication from peer", - OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2, - &lcp_wantoptions[0].chap_mdtype }, - { "+mschap-v2", o_bool, &auth_required, - "Require MS-CHAPv2 authentication from peer", - OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2, - &lcp_wantoptions[0].chap_mdtype }, -#endif /* MSCHAP_SUPPORT */ -#if 0 - { "refuse-pap", o_bool, &refuse_pap, - "Don't agree to auth to peer with PAP", 1 }, - { "-pap", o_bool, &refuse_pap, - "Don't allow PAP authentication with peer", OPT_ALIAS | 1 }, - { "refuse-chap", o_bool, &refuse_chap, - "Don't agree to auth to peer with CHAP", - OPT_A2CLRB | MDTYPE_MD5, - &lcp_allowoptions[0].chap_mdtype }, - { "-chap", o_bool, &refuse_chap, - "Don't allow CHAP authentication with peer", - OPT_ALIAS | OPT_A2CLRB | MDTYPE_MD5, - &lcp_allowoptions[0].chap_mdtype }, -#endif -#if MSCHAP_SUPPORT -#if 0 - { "refuse-mschap", o_bool, &refuse_mschap, - "Don't agree to auth to peer with MS-CHAP", - OPT_A2CLRB | MDTYPE_MICROSOFT, - &lcp_allowoptions[0].chap_mdtype }, - { "-mschap", o_bool, &refuse_mschap, - "Don't allow MS-CHAP authentication with peer", - OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT, - &lcp_allowoptions[0].chap_mdtype }, - { "refuse-mschap-v2", o_bool, &refuse_mschap_v2, - "Don't agree to auth to peer with MS-CHAPv2", - OPT_A2CLRB | MDTYPE_MICROSOFT_V2, - &lcp_allowoptions[0].chap_mdtype }, - { "-mschap-v2", o_bool, &refuse_mschap_v2, - "Don't allow MS-CHAPv2 authentication with peer", - OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT_V2, - &lcp_allowoptions[0].chap_mdtype }, -#endif -#endif /* MSCHAP_SUPPORT*/ -#if EAP_SUPPORT - { "require-eap", o_bool, &lcp_wantoptions[0].neg_eap, - "Require EAP authentication from peer", OPT_PRIOSUB | 1, - &auth_required }, -#if 0 - { "refuse-eap", o_bool, &refuse_eap, - "Don't agree to authenticate to peer with EAP", 1 }, -#endif -#endif /* EAP_SUPPORT */ - { "name", o_string, our_name, - "Set local name for authentication", - OPT_PRIO | OPT_PRIV | OPT_STATIC, NULL, MAXNAMELEN }, - - { "+ua", o_special, (void *)setupapfile, - "Get PAP user and password from file", - OPT_PRIO | OPT_A2STRVAL, &uafname }, - -#if 0 - { "user", o_string, user, - "Set name for auth with peer", OPT_PRIO | OPT_STATIC, - &explicit_user, MAXNAMELEN }, - - { "password", o_string, passwd, - "Password for authenticating us to the peer", - OPT_PRIO | OPT_STATIC | OPT_HIDE, - &explicit_passwd, MAXSECRETLEN }, -#endif - - { "usehostname", o_bool, &usehostname, - "Must use hostname for authentication", 1 }, - - { "remotename", o_string, remote_name, - "Set remote name for authentication", OPT_PRIO | OPT_STATIC, - &explicit_remote, MAXNAMELEN }, - - { "login", o_bool, &uselogin, - "Use system password database for PAP", OPT_A2COPY | 1 , - &session_mgmt }, - { "enable-session", o_bool, &session_mgmt, - "Enable session accounting for remote peers", OPT_PRIV | 1 }, - - { "papcrypt", o_bool, &cryptpap, - "PAP passwords are encrypted", 1 }, - - { "privgroup", o_special, (void *)privgroup, - "Allow group members to use privileged options", OPT_PRIV | OPT_A2LIST }, - - { "allow-ip", o_special, (void *)set_noauth_addr, - "Set IP address(es) which can be used without authentication", - OPT_PRIV | OPT_A2LIST }, - - { "remotenumber", o_string, remote_number, - "Set remote telephone number for authentication", OPT_PRIO | OPT_STATIC, - NULL, MAXNAMELEN }, - - { "allow-number", o_special, (void *)set_permitted_number, - "Set telephone number(s) which are allowed to connect", - OPT_PRIV | OPT_A2LIST }, - - { NULL } -}; -#endif /* PPP_OPTIONS */ - -#if 0 /* UNUSED */ -/* - * setupapfile - specifies UPAP info for authenticating with peer. - */ -static int -setupapfile(argv) - char **argv; -{ - FILE *ufile; - int l; - uid_t euid; - char u[MAXNAMELEN], p[MAXSECRETLEN]; - char *fname; - - lcp_allowoptions[0].neg_upap = 1; - - /* open user info file */ - fname = strdup(*argv); - if (fname == NULL) - novm("+ua file name"); - euid = geteuid(); - if (seteuid(getuid()) == -1) { - option_error("unable to reset uid before opening %s: %m", fname); - return 0; - } - ufile = fopen(fname, "r"); - if (seteuid(euid) == -1) - fatal("unable to regain privileges: %m"); - if (ufile == NULL) { - option_error("unable to open user login data file %s", fname); - return 0; - } - check_access(ufile, fname); - uafname = fname; - - /* get username */ - if (fgets(u, MAXNAMELEN - 1, ufile) == NULL - || fgets(p, MAXSECRETLEN - 1, ufile) == NULL) { - fclose(ufile); - option_error("unable to read user login data file %s", fname); - return 0; - } - fclose(ufile); - - /* get rid of newlines */ - l = strlen(u); - if (l > 0 && u[l-1] == '\n') - u[l-1] = 0; - l = strlen(p); - if (l > 0 && p[l-1] == '\n') - p[l-1] = 0; - - if (override_value("user", option_priority, fname)) { - strlcpy(ppp_settings.user, u, sizeof(ppp_settings.user)); - explicit_user = 1; - } - if (override_value("passwd", option_priority, fname)) { - strlcpy(ppp_settings.passwd, p, sizeof(ppp_settings.passwd)); - explicit_passwd = 1; - } - - return (1); -} - -/* - * privgroup - allow members of the group to have privileged access. - */ -static int -privgroup(argv) - char **argv; -{ - struct group *g; - int i; - - g = getgrnam(*argv); - if (g == 0) { - option_error("group %s is unknown", *argv); - return 0; - } - for (i = 0; i < ngroups; ++i) { - if (groups[i] == g->gr_gid) { - privileged = 1; - break; - } - } - return 1; -} - - -/* - * set_noauth_addr - set address(es) that can be used without authentication. - * Equivalent to specifying an entry like `"" * "" addr' in pap-secrets. - */ -static int -set_noauth_addr(argv) - char **argv; -{ - char *addr = *argv; - int l = strlen(addr) + 1; - struct wordlist *wp; - - wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l); - if (wp == NULL) - novm("allow-ip argument"); - wp->word = (char *) (wp + 1); - wp->next = noauth_addrs; - MEMCPY(wp->word, addr, l); - noauth_addrs = wp; - return 1; -} - - -/* - * set_permitted_number - set remote telephone number(s) that may connect. - */ -static int -set_permitted_number(argv) - char **argv; -{ - char *number = *argv; - int l = strlen(number) + 1; - struct wordlist *wp; - - wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l); - if (wp == NULL) - novm("allow-number argument"); - wp->word = (char *) (wp + 1); - wp->next = permitted_numbers; - MEMCPY(wp->word, number, l); - permitted_numbers = wp; - return 1; -} -#endif - -/* - * An Open on LCP has requested a change from Dead to Establish phase. - */ -void link_required(ppp_pcb *pcb) { - LWIP_UNUSED_ARG(pcb); -} - -#if 0 -/* - * Bring the link up to the point of being able to do ppp. - */ -void start_link(unit) - int unit; -{ - ppp_pcb *pcb = &ppp_pcb_list[unit]; - char *msg; - - status = EXIT_NEGOTIATION_FAILED; - new_phase(pcb, PPP_PHASE_SERIALCONN); - - hungup = 0; - devfd = the_channel->connect(); - msg = "Connect script failed"; - if (devfd < 0) - goto fail; - - /* set up the serial device as a ppp interface */ - /* - * N.B. we used to do tdb_writelock/tdb_writeunlock around this - * (from establish_ppp to set_ifunit). However, we won't be - * doing the set_ifunit in multilink mode, which is the only time - * we need the atomicity that the tdb_writelock/tdb_writeunlock - * gives us. Thus we don't need the tdb_writelock/tdb_writeunlock. - */ - fd_ppp = the_channel->establish_ppp(devfd); - msg = "ppp establishment failed"; - if (fd_ppp < 0) { - status = EXIT_FATAL_ERROR; - goto disconnect; - } - - if (!demand && ifunit >= 0) - set_ifunit(1); - - /* - * Start opening the connection and wait for - * incoming events (reply, timeout, etc.). - */ - if (ifunit >= 0) - ppp_notice("Connect: %s <--> %s", ifname, ppp_devnam); - else - ppp_notice("Starting negotiation on %s", ppp_devnam); - add_fd(fd_ppp); - - new_phase(pcb, PPP_PHASE_ESTABLISH); - - lcp_lowerup(pcb); - return; - - disconnect: - new_phase(pcb, PPP_PHASE_DISCONNECT); - if (the_channel->disconnect) - the_channel->disconnect(); - - fail: - new_phase(pcb, PPP_PHASE_DEAD); - if (the_channel->cleanup) - (*the_channel->cleanup)(); -} -#endif - -/* - * LCP has terminated the link; go to the Dead phase and take the - * physical layer down. - */ -void link_terminated(ppp_pcb *pcb) { - if (pcb->phase == PPP_PHASE_DEAD -#ifdef HAVE_MULTILINK - || pcb->phase == PPP_PHASE_MASTER -#endif /* HAVE_MULTILINK */ - ) - return; - new_phase(pcb, PPP_PHASE_DISCONNECT); - -#if 0 /* UNUSED */ - if (pap_logout_hook) { - pap_logout_hook(); - } - session_end(devnam); -#endif /* UNUSED */ - - if (!doing_multilink) { - ppp_notice("Connection terminated."); -#if PPP_STATS_SUPPORT - print_link_stats(); -#endif /* PPP_STATS_SUPPORT */ - } else - ppp_notice("Link terminated."); - - lcp_lowerdown(pcb); - - ppp_link_terminated(pcb); -#if 0 - /* - * Delete pid files before disestablishing ppp. Otherwise it - * can happen that another pppd gets the same unit and then - * we delete its pid file. - */ - if (!doing_multilink && !demand) - remove_pidfiles(); - - /* - * If we may want to bring the link up again, transfer - * the ppp unit back to the loopback. Set the - * real serial device back to its normal mode of operation. - */ - if (fd_ppp >= 0) { - remove_fd(fd_ppp); - clean_check(); - the_channel->disestablish_ppp(devfd); - if (doing_multilink) - mp_exit_bundle(); - fd_ppp = -1; - } - if (!hungup) - lcp_lowerdown(pcb); - if (!doing_multilink && !demand) - script_unsetenv("IFNAME"); - - /* - * Run disconnector script, if requested. - * XXX we may not be able to do this if the line has hung up! - */ - if (devfd >= 0 && the_channel->disconnect) { - the_channel->disconnect(); - devfd = -1; - } - if (the_channel->cleanup) - (*the_channel->cleanup)(); - - if (doing_multilink && multilink_master) { - if (!bundle_terminating) - new_phase(pcb, PPP_PHASE_MASTER); - else - mp_bundle_terminated(); - } else - new_phase(pcb, PPP_PHASE_DEAD); -#endif -} - -/* - * LCP has gone down; it will either die or try to re-establish. - */ -void link_down(ppp_pcb *pcb) { -#if PPP_NOTIFY - notify(link_down_notifier, 0); -#endif /* PPP_NOTIFY */ - - if (!doing_multilink) { - upper_layers_down(pcb); - if (pcb->phase != PPP_PHASE_DEAD -#ifdef HAVE_MULTILINK - && pcb->phase != PPP_PHASE_MASTER -#endif /* HAVE_MULTILINK */ - ) - new_phase(pcb, PPP_PHASE_ESTABLISH); - } - /* XXX if doing_multilink, should do something to stop - network-layer traffic on the link */ -} - -void upper_layers_down(ppp_pcb *pcb) { - int i; - const struct protent *protp; - - for (i = 0; (protp = protocols[i]) != NULL; ++i) { - if (protp->protocol != PPP_LCP && protp->lowerdown != NULL) - (*protp->lowerdown)(pcb); - if (protp->protocol < 0xC000 && protp->close != NULL) - (*protp->close)(pcb, "LCP down"); - } - pcb->num_np_open = 0; - pcb->num_np_up = 0; -} - -/* - * The link is established. - * Proceed to the Dead, Authenticate or Network phase as appropriate. - */ -void link_established(ppp_pcb *pcb) { -#if PPP_AUTH_SUPPORT - int auth; -#if PPP_SERVER -#if PAP_SUPPORT - lcp_options *wo = &pcb->lcp_wantoptions; -#endif /* PAP_SUPPORT */ - lcp_options *go = &pcb->lcp_gotoptions; -#endif /* PPP_SERVER */ - lcp_options *ho = &pcb->lcp_hisoptions; -#endif /* PPP_AUTH_SUPPORT */ - int i; - const struct protent *protp; - - /* - * Tell higher-level protocols that LCP is up. - */ - if (!doing_multilink) { - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (protp->protocol != PPP_LCP - && protp->lowerup != NULL) - (*protp->lowerup)(pcb); - } - -#if PPP_AUTH_SUPPORT -#if PPP_SERVER -#if PPP_ALLOWED_ADDRS - if (!auth_required && noauth_addrs != NULL) - set_allowed_addrs(unit, NULL, NULL); -#endif /* PPP_ALLOWED_ADDRS */ - - if (pcb->settings.auth_required && !(0 -#if PAP_SUPPORT - || go->neg_upap -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - || go->neg_chap -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - || go->neg_eap -#endif /* EAP_SUPPORT */ - )) { - -#if PPP_ALLOWED_ADDRS - /* - * We wanted the peer to authenticate itself, and it refused: - * if we have some address(es) it can use without auth, fine, - * otherwise treat it as though it authenticated with PAP using - * a username of "" and a password of "". If that's not OK, - * boot it out. - */ - if (noauth_addrs != NULL) { - set_allowed_addrs(unit, NULL, NULL); - } else -#endif /* PPP_ALLOWED_ADDRS */ - if (!pcb->settings.null_login -#if PAP_SUPPORT - || !wo->neg_upap -#endif /* PAP_SUPPORT */ - ) { - ppp_warn("peer refused to authenticate: terminating link"); -#if 0 /* UNUSED */ - status = EXIT_PEER_AUTH_FAILED; -#endif /* UNUSED */ - pcb->err_code = PPPERR_AUTHFAIL; - lcp_close(pcb, "peer refused to authenticate"); - return; - } - } -#endif /* PPP_SERVER */ - - new_phase(pcb, PPP_PHASE_AUTHENTICATE); - auth = 0; -#if PPP_SERVER -#if EAP_SUPPORT - if (go->neg_eap) { - eap_authpeer(pcb, PPP_OUR_NAME); - auth |= EAP_PEER; - } else -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT - if (go->neg_chap) { - chap_auth_peer(pcb, PPP_OUR_NAME, CHAP_DIGEST(go->chap_mdtype)); - auth |= CHAP_PEER; - } else -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - if (go->neg_upap) { - upap_authpeer(pcb); - auth |= PAP_PEER; - } else -#endif /* PAP_SUPPORT */ - {} -#endif /* PPP_SERVER */ - -#if EAP_SUPPORT - if (ho->neg_eap) { - eap_authwithpeer(pcb, pcb->settings.user); - auth |= EAP_WITHPEER; - } else -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT - if (ho->neg_chap) { - chap_auth_with_peer(pcb, pcb->settings.user, CHAP_DIGEST(ho->chap_mdtype)); - auth |= CHAP_WITHPEER; - } else -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - if (ho->neg_upap) { - upap_authwithpeer(pcb, pcb->settings.user, pcb->settings.passwd); - auth |= PAP_WITHPEER; - } else -#endif /* PAP_SUPPORT */ - {} - - pcb->auth_pending = auth; - pcb->auth_done = 0; - - if (!auth) -#endif /* PPP_AUTH_SUPPORT */ - network_phase(pcb); -} - -/* - * Proceed to the network phase. - */ -static void network_phase(ppp_pcb *pcb) { -#if CBCP_SUPPORT - ppp_pcb *pcb = &ppp_pcb_list[unit]; -#endif -#if 0 /* UNUSED */ - lcp_options *go = &lcp_gotoptions[unit]; -#endif /* UNUSED */ - -#if 0 /* UNUSED */ - /* Log calling number. */ - if (*remote_number) - ppp_notice("peer from calling number %q authorized", remote_number); -#endif /* UNUSED */ - -#if PPP_NOTIFY - /* - * If the peer had to authenticate, notify it now. - */ - if (0 -#if CHAP_SUPPORT - || go->neg_chap -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - || go->neg_upap -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - || go->neg_eap -#endif /* EAP_SUPPORT */ - ) { - notify(auth_up_notifier, 0); - } -#endif /* PPP_NOTIFY */ - -#if CBCP_SUPPORT - /* - * If we negotiated callback, do it now. - */ - if (go->neg_cbcp) { - new_phase(pcb, PPP_PHASE_CALLBACK); - (*cbcp_protent.open)(pcb); - return; - } -#endif - -#if PPP_OPTIONS - /* - * Process extra options from the secrets file - */ - if (extra_options) { - options_from_list(extra_options, 1); - free_wordlist(extra_options); - extra_options = 0; - } -#endif /* PPP_OPTIONS */ - start_networks(pcb); -} - -void start_networks(ppp_pcb *pcb) { -#if CCP_SUPPORT || ECP_SUPPORT - int i; - const struct protent *protp; -#endif /* CCP_SUPPORT || ECP_SUPPORT */ - - new_phase(pcb, PPP_PHASE_NETWORK); - -#ifdef HAVE_MULTILINK - if (multilink) { - if (mp_join_bundle()) { - if (multilink_join_hook) - (*multilink_join_hook)(); - if (updetach && !nodetach) - detach(); - return; - } - } -#endif /* HAVE_MULTILINK */ - -#ifdef PPP_FILTER - if (!demand) - set_filters(&pass_filter, &active_filter); -#endif -#if CCP_SUPPORT || ECP_SUPPORT - /* Start CCP and ECP */ - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if ( - (0 -#if ECP_SUPPORT - || protp->protocol == PPP_ECP -#endif /* ECP_SUPPORT */ -#if CCP_SUPPORT - || protp->protocol == PPP_CCP -#endif /* CCP_SUPPORT */ - ) - && protp->open != NULL) - (*protp->open)(pcb); -#endif /* CCP_SUPPORT || ECP_SUPPORT */ - - /* - * Bring up other network protocols iff encryption is not required. - */ - if (1 -#if ECP_SUPPORT - && !ecp_gotoptions[unit].required -#endif /* ECP_SUPPORT */ -#if MPPE_SUPPORT - && !pcb->ccp_gotoptions.mppe -#endif /* MPPE_SUPPORT */ - ) - continue_networks(pcb); -} - -void continue_networks(ppp_pcb *pcb) { - int i; - const struct protent *protp; - - /* - * Start the "real" network protocols. - */ - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (protp->protocol < 0xC000 -#if CCP_SUPPORT - && protp->protocol != PPP_CCP -#endif /* CCP_SUPPORT */ -#if ECP_SUPPORT - && protp->protocol != PPP_ECP -#endif /* ECP_SUPPORT */ - && protp->open != NULL) { - (*protp->open)(pcb); - ++pcb->num_np_open; - } - - if (pcb->num_np_open == 0) - /* nothing to do */ - lcp_close(pcb, "No network protocols running"); -} - -#if PPP_AUTH_SUPPORT -#if PPP_SERVER -/* - * auth_check_passwd - Check the user name and passwd against configuration. - * - * returns: - * 0: Authentication failed. - * 1: Authentication succeeded. - * In either case, msg points to an appropriate message and msglen to the message len. - */ -int auth_check_passwd(ppp_pcb *pcb, char *auser, int userlen, char *apasswd, int passwdlen, const char **msg, int *msglen) { - int secretuserlen; - int secretpasswdlen; - - if (pcb->settings.user && pcb->settings.passwd) { - secretuserlen = (int)strlen(pcb->settings.user); - secretpasswdlen = (int)strlen(pcb->settings.passwd); - if (secretuserlen == userlen - && secretpasswdlen == passwdlen - && !memcmp(auser, pcb->settings.user, userlen) - && !memcmp(apasswd, pcb->settings.passwd, passwdlen) ) { - *msg = "Login ok"; - *msglen = sizeof("Login ok")-1; - return 1; - } - } - - *msg = "Login incorrect"; - *msglen = sizeof("Login incorrect")-1; - return 0; -} - -/* - * The peer has failed to authenticate himself using `protocol'. - */ -void auth_peer_fail(ppp_pcb *pcb, int protocol) { - LWIP_UNUSED_ARG(protocol); - /* - * Authentication failure: take the link down - */ -#if 0 /* UNUSED */ - status = EXIT_PEER_AUTH_FAILED; -#endif /* UNUSED */ - pcb->err_code = PPPERR_AUTHFAIL; - lcp_close(pcb, "Authentication failed"); -} - -/* - * The peer has been successfully authenticated using `protocol'. - */ -void auth_peer_success(ppp_pcb *pcb, int protocol, int prot_flavor, const char *name, int namelen) { - int bit; -#ifndef HAVE_MULTILINK - LWIP_UNUSED_ARG(name); - LWIP_UNUSED_ARG(namelen); -#endif /* HAVE_MULTILINK */ - - switch (protocol) { -#if CHAP_SUPPORT - case PPP_CHAP: - bit = CHAP_PEER; - switch (prot_flavor) { - case CHAP_MD5: - bit |= CHAP_MD5_PEER; - break; -#if MSCHAP_SUPPORT - case CHAP_MICROSOFT: - bit |= CHAP_MS_PEER; - break; - case CHAP_MICROSOFT_V2: - bit |= CHAP_MS2_PEER; - break; -#endif /* MSCHAP_SUPPORT */ - default: - break; - } - break; -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - case PPP_PAP: - bit = PAP_PEER; - break; -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - case PPP_EAP: - bit = EAP_PEER; - break; -#endif /* EAP_SUPPORT */ - default: - ppp_warn("auth_peer_success: unknown protocol %x", protocol); - return; - } - -#ifdef HAVE_MULTILINK - /* - * Save the authenticated name of the peer for later. - */ - if (namelen > (int)sizeof(pcb->peer_authname) - 1) - namelen = (int)sizeof(pcb->peer_authname) - 1; - MEMCPY(pcb->peer_authname, name, namelen); - pcb->peer_authname[namelen] = 0; -#endif /* HAVE_MULTILINK */ -#if 0 /* UNUSED */ - script_setenv("PEERNAME", , 0); -#endif /* UNUSED */ - - /* Save the authentication method for later. */ - pcb->auth_done |= bit; - - /* - * If there is no more authentication still to be done, - * proceed to the network (or callback) phase. - */ - if ((pcb->auth_pending &= ~bit) == 0) - network_phase(pcb); -} -#endif /* PPP_SERVER */ - -/* - * We have failed to authenticate ourselves to the peer using `protocol'. - */ -void auth_withpeer_fail(ppp_pcb *pcb, int protocol) { - LWIP_UNUSED_ARG(protocol); - /* - * We've failed to authenticate ourselves to our peer. - * - * Some servers keep sending CHAP challenges, but there - * is no point in persisting without any way to get updated - * authentication secrets. - * - * He'll probably take the link down, and there's not much - * we can do except wait for that. - */ - pcb->err_code = PPPERR_AUTHFAIL; - lcp_close(pcb, "Failed to authenticate ourselves to peer"); -} - -/* - * We have successfully authenticated ourselves with the peer using `protocol'. - */ -void auth_withpeer_success(ppp_pcb *pcb, int protocol, int prot_flavor) { - int bit; - const char *prot = ""; - - switch (protocol) { -#if CHAP_SUPPORT - case PPP_CHAP: - bit = CHAP_WITHPEER; - prot = "CHAP"; - switch (prot_flavor) { - case CHAP_MD5: - bit |= CHAP_MD5_WITHPEER; - break; -#if MSCHAP_SUPPORT - case CHAP_MICROSOFT: - bit |= CHAP_MS_WITHPEER; - break; - case CHAP_MICROSOFT_V2: - bit |= CHAP_MS2_WITHPEER; - break; -#endif /* MSCHAP_SUPPORT */ - default: - break; - } - break; -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - case PPP_PAP: - bit = PAP_WITHPEER; - prot = "PAP"; - break; -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - case PPP_EAP: - bit = EAP_WITHPEER; - prot = "EAP"; - break; -#endif /* EAP_SUPPORT */ - default: - ppp_warn("auth_withpeer_success: unknown protocol %x", protocol); - bit = 0; - /* no break */ - } - - ppp_notice("%s authentication succeeded", prot); - - /* Save the authentication method for later. */ - pcb->auth_done |= bit; - - /* - * If there is no more authentication still being done, - * proceed to the network (or callback) phase. - */ - if ((pcb->auth_pending &= ~bit) == 0) - network_phase(pcb); -} -#endif /* PPP_AUTH_SUPPORT */ - - -/* - * np_up - a network protocol has come up. - */ -void np_up(ppp_pcb *pcb, int proto) { -#if PPP_IDLETIMELIMIT - int tlim; -#endif /* PPP_IDLETIMELIMIT */ - LWIP_UNUSED_ARG(proto); - - if (pcb->num_np_up == 0) { - /* - * At this point we consider that the link has come up successfully. - */ - new_phase(pcb, PPP_PHASE_RUNNING); - -#if PPP_IDLETIMELIMIT -#if 0 /* UNUSED */ - if (idle_time_hook != 0) - tlim = (*idle_time_hook)(NULL); - else -#endif /* UNUSED */ - tlim = pcb->settings.idle_time_limit; - if (tlim > 0) - TIMEOUT(check_idle, (void*)pcb, tlim); -#endif /* PPP_IDLETIMELIMIT */ - -#if PPP_MAXCONNECT - /* - * Set a timeout to close the connection once the maximum - * connect time has expired. - */ - if (pcb->settings.maxconnect > 0) - TIMEOUT(connect_time_expired, (void*)pcb, pcb->settings.maxconnect); -#endif /* PPP_MAXCONNECT */ - -#ifdef MAXOCTETS - if (maxoctets > 0) - TIMEOUT(check_maxoctets, NULL, maxoctets_timeout); -#endif - -#if 0 /* Unused */ - /* - * Detach now, if the updetach option was given. - */ - if (updetach && !nodetach) - detach(); -#endif /* Unused */ - } - ++pcb->num_np_up; -} - -/* - * np_down - a network protocol has gone down. - */ -void np_down(ppp_pcb *pcb, int proto) { - LWIP_UNUSED_ARG(proto); - if (--pcb->num_np_up == 0) { -#if PPP_IDLETIMELIMIT - UNTIMEOUT(check_idle, (void*)pcb); -#endif /* PPP_IDLETIMELIMIT */ -#if PPP_MAXCONNECT - UNTIMEOUT(connect_time_expired, NULL); -#endif /* PPP_MAXCONNECT */ -#ifdef MAXOCTETS - UNTIMEOUT(check_maxoctets, NULL); -#endif - new_phase(pcb, PPP_PHASE_NETWORK); - } -} - -/* - * np_finished - a network protocol has finished using the link. - */ -void np_finished(ppp_pcb *pcb, int proto) { - LWIP_UNUSED_ARG(proto); - if (--pcb->num_np_open <= 0) { - /* no further use for the link: shut up shop. */ - lcp_close(pcb, "No network protocols running"); - } -} - -#ifdef MAXOCTETS -static void -check_maxoctets(arg) - void *arg; -{ -#if PPP_STATS_SUPPORT - unsigned int used; - - update_link_stats(ifunit); - link_stats_valid=0; - - switch(maxoctets_dir) { - case PPP_OCTETS_DIRECTION_IN: - used = link_stats.bytes_in; - break; - case PPP_OCTETS_DIRECTION_OUT: - used = link_stats.bytes_out; - break; - case PPP_OCTETS_DIRECTION_MAXOVERAL: - case PPP_OCTETS_DIRECTION_MAXSESSION: - used = (link_stats.bytes_in > link_stats.bytes_out) ? link_stats.bytes_in : link_stats.bytes_out; - break; - default: - used = link_stats.bytes_in+link_stats.bytes_out; - break; - } - if (used > maxoctets) { - ppp_notice("Traffic limit reached. Limit: %u Used: %u", maxoctets, used); - status = EXIT_TRAFFIC_LIMIT; - lcp_close(pcb, "Traffic limit"); -#if 0 /* UNUSED */ - need_holdoff = 0; -#endif /* UNUSED */ - } else { - TIMEOUT(check_maxoctets, NULL, maxoctets_timeout); - } -#endif /* PPP_STATS_SUPPORT */ -} -#endif /* MAXOCTETS */ - -#if PPP_IDLETIMELIMIT -/* - * check_idle - check whether the link has been idle for long - * enough that we can shut it down. - */ -static void check_idle(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - struct ppp_idle idle; - time_t itime; - int tlim; - - if (!get_idle_time(pcb, &idle)) - return; -#if 0 /* UNUSED */ - if (idle_time_hook != 0) { - tlim = idle_time_hook(&idle); - } else { -#endif /* UNUSED */ - itime = LWIP_MIN(idle.xmit_idle, idle.recv_idle); - tlim = pcb->settings.idle_time_limit - itime; -#if 0 /* UNUSED */ - } -#endif /* UNUSED */ - if (tlim <= 0) { - /* link is idle: shut it down. */ - ppp_notice("Terminating connection due to lack of activity."); - pcb->err_code = PPPERR_IDLETIMEOUT; - lcp_close(pcb, "Link inactive"); -#if 0 /* UNUSED */ - need_holdoff = 0; -#endif /* UNUSED */ - } else { - TIMEOUT(check_idle, (void*)pcb, tlim); - } -} -#endif /* PPP_IDLETIMELIMIT */ - -#if PPP_MAXCONNECT -/* - * connect_time_expired - log a message and close the connection. - */ -static void connect_time_expired(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - ppp_info("Connect time expired"); - pcb->err_code = PPPERR_CONNECTTIME; - lcp_close(pcb, "Connect time expired"); /* Close connection */ -} -#endif /* PPP_MAXCONNECT */ - -#if PPP_OPTIONS -/* - * auth_check_options - called to check authentication options. - */ -void -auth_check_options() -{ - lcp_options *wo = &lcp_wantoptions[0]; - int can_auth; - int lacks_ip; - - /* Default our_name to hostname, and user to our_name */ - if (our_name[0] == 0 || usehostname) - strlcpy(our_name, hostname, sizeof(our_name)); - /* If a blank username was explicitly given as an option, trust - the user and don't use our_name */ - if (ppp_settings.user[0] == 0 && !explicit_user) - strlcpy(ppp_settings.user, our_name, sizeof(ppp_settings.user)); - - /* - * If we have a default route, require the peer to authenticate - * unless the noauth option was given or the real user is root. - */ - if (!auth_required && !allow_any_ip && have_route_to(0) && !privileged) { - auth_required = 1; - default_auth = 1; - } - -#if CHAP_SUPPORT - /* If we selected any CHAP flavors, we should probably negotiate it. :-) */ - if (wo->chap_mdtype) - wo->neg_chap = 1; -#endif /* CHAP_SUPPORT */ - - /* If authentication is required, ask peer for CHAP, PAP, or EAP. */ - if (auth_required) { - allow_any_ip = 0; - if (1 -#if CHAP_SUPPORT - && !wo->neg_chap -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - && !wo->neg_upap -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - && !wo->neg_eap -#endif /* EAP_SUPPORT */ - ) { -#if CHAP_SUPPORT - wo->neg_chap = CHAP_MDTYPE_SUPPORTED != MDTYPE_NONE; - wo->chap_mdtype = CHAP_MDTYPE_SUPPORTED; -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - wo->neg_upap = 1; -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - wo->neg_eap = 1; -#endif /* EAP_SUPPORT */ - } - } else { -#if CHAP_SUPPORT - wo->neg_chap = 0; - wo->chap_mdtype = MDTYPE_NONE; -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - wo->neg_upap = 0; -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - wo->neg_eap = 0; -#endif /* EAP_SUPPORT */ - } - - /* - * Check whether we have appropriate secrets to use - * to authenticate the peer. Note that EAP can authenticate by way - * of a CHAP-like exchanges as well as SRP. - */ - lacks_ip = 0; -#if PAP_SUPPORT - can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip)); -#else - can_auth = 0; -#endif /* PAP_SUPPORT */ - if (!can_auth && (0 -#if CHAP_SUPPORT - || wo->neg_chap -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - || wo->neg_eap -#endif /* EAP_SUPPORT */ - )) { -#if CHAP_SUPPORT - can_auth = have_chap_secret((explicit_remote? remote_name: NULL), - our_name, 1, &lacks_ip); -#else - can_auth = 0; -#endif - } - if (!can_auth -#if EAP_SUPPORT - && wo->neg_eap -#endif /* EAP_SUPPORT */ - ) { - can_auth = have_srp_secret((explicit_remote? remote_name: NULL), - our_name, 1, &lacks_ip); - } - - if (auth_required && !can_auth && noauth_addrs == NULL) { - if (default_auth) { - option_error( -"By default the remote system is required to authenticate itself"); - option_error( -"(because this system has a default route to the internet)"); - } else if (explicit_remote) - option_error( -"The remote system (%s) is required to authenticate itself", - remote_name); - else - option_error( -"The remote system is required to authenticate itself"); - option_error( -"but I couldn't find any suitable secret (password) for it to use to do so."); - if (lacks_ip) - option_error( -"(None of the available passwords would let it use an IP address.)"); - - exit(1); - } - - /* - * Early check for remote number authorization. - */ - if (!auth_number()) { - ppp_warn("calling number %q is not authorized", remote_number); - exit(EXIT_CNID_AUTH_FAILED); - } -} -#endif /* PPP_OPTIONS */ - -#if 0 /* UNUSED */ -/* - * auth_reset - called when LCP is starting negotiations to recheck - * authentication options, i.e. whether we have appropriate secrets - * to use for authenticating ourselves and/or the peer. - */ -void -auth_reset(unit) - int unit; -{ - lcp_options *go = &lcp_gotoptions[unit]; - lcp_options *ao = &lcp_allowoptions[unit]; - int hadchap; - - hadchap = -1; - ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL)); - ao->neg_chap = (!refuse_chap || !refuse_mschap || !refuse_mschap_v2) - && (passwd[0] != 0 || - (hadchap = have_chap_secret(user, (explicit_remote? remote_name: - NULL), 0, NULL))); - ao->neg_eap = !refuse_eap && ( - passwd[0] != 0 || - (hadchap == 1 || (hadchap == -1 && have_chap_secret(user, - (explicit_remote? remote_name: NULL), 0, NULL))) || - have_srp_secret(user, (explicit_remote? remote_name: NULL), 0, NULL)); - - hadchap = -1; - if (go->neg_upap && !uselogin && !have_pap_secret(NULL)) - go->neg_upap = 0; - if (go->neg_chap) { - if (!(hadchap = have_chap_secret((explicit_remote? remote_name: NULL), - our_name, 1, NULL))) - go->neg_chap = 0; - } - if (go->neg_eap && - (hadchap == 0 || (hadchap == -1 && - !have_chap_secret((explicit_remote? remote_name: NULL), our_name, - 1, NULL))) && - !have_srp_secret((explicit_remote? remote_name: NULL), our_name, 1, - NULL)) - go->neg_eap = 0; -} - -/* - * check_passwd - Check the user name and passwd against the PAP secrets - * file. If requested, also check against the system password database, - * and login the user if OK. - * - * returns: - * UPAP_AUTHNAK: Authentication failed. - * UPAP_AUTHACK: Authentication succeeded. - * In either case, msg points to an appropriate message. - */ -int -check_passwd(unit, auser, userlen, apasswd, passwdlen, msg) - int unit; - char *auser; - int userlen; - char *apasswd; - int passwdlen; - char **msg; -{ - return UPAP_AUTHNAK; - int ret; - char *filename; - FILE *f; - struct wordlist *addrs = NULL, *opts = NULL; - char passwd[256], user[256]; - char secret[MAXWORDLEN]; - static int attempts = 0; - - /* - * Make copies of apasswd and auser, then null-terminate them. - * If there are unprintable characters in the password, make - * them visible. - */ - slprintf(ppp_settings.passwd, sizeof(ppp_settings.passwd), "%.*v", passwdlen, apasswd); - slprintf(ppp_settings.user, sizeof(ppp_settings.user), "%.*v", userlen, auser); - *msg = ""; - - /* - * Check if a plugin wants to handle this. - */ - if (pap_auth_hook) { - ret = (*pap_auth_hook)(ppp_settings.user, ppp_settings.passwd, msg, &addrs, &opts); - if (ret >= 0) { - /* note: set_allowed_addrs() saves opts (but not addrs): - don't free it! */ - if (ret) - set_allowed_addrs(unit, addrs, opts); - else if (opts != 0) - free_wordlist(opts); - if (addrs != 0) - free_wordlist(addrs); - BZERO(ppp_settings.passwd, sizeof(ppp_settings.passwd)); - return ret? UPAP_AUTHACK: UPAP_AUTHNAK; - } - } - - /* - * Open the file of pap secrets and scan for a suitable secret - * for authenticating this user. - */ - filename = _PATH_UPAPFILE; - addrs = opts = NULL; - ret = UPAP_AUTHNAK; - f = fopen(filename, "r"); - if (f == NULL) { - ppp_error("Can't open PAP password file %s: %m", filename); - - } else { - check_access(f, filename); - if (scan_authfile(f, ppp_settings.user, our_name, secret, &addrs, &opts, filename, 0) < 0) { - ppp_warn("no PAP secret found for %s", user); - } else { - /* - * If the secret is "@login", it means to check - * the password against the login database. - */ - int login_secret = strcmp(secret, "@login") == 0; - ret = UPAP_AUTHACK; - if (uselogin || login_secret) { - /* login option or secret is @login */ - if (session_full(ppp_settings.user, ppp_settings.passwd, devnam, msg) == 0) { - ret = UPAP_AUTHNAK; - } - } else if (session_mgmt) { - if (session_check(ppp_settings.user, NULL, devnam, NULL) == 0) { - ppp_warn("Peer %q failed PAP Session verification", user); - ret = UPAP_AUTHNAK; - } - } - if (secret[0] != 0 && !login_secret) { - /* password given in pap-secrets - must match */ - if ((cryptpap || strcmp(ppp_settings.passwd, secret) != 0) - && strcmp(crypt(ppp_settings.passwd, secret), secret) != 0) - ret = UPAP_AUTHNAK; - } - } - fclose(f); - } - - if (ret == UPAP_AUTHNAK) { - if (**msg == 0) - *msg = "Login incorrect"; - /* - * XXX can we ever get here more than once?? - * Frustrate passwd stealer programs. - * Allow 10 tries, but start backing off after 3 (stolen from login). - * On 10'th, drop the connection. - */ - if (attempts++ >= 10) { - ppp_warn("%d LOGIN FAILURES ON %s, %s", attempts, devnam, user); - lcp_close(pcb, "login failed"); - } - if (attempts > 3) - sleep((u_int) (attempts - 3) * 5); - if (opts != NULL) - free_wordlist(opts); - - } else { - attempts = 0; /* Reset count */ - if (**msg == 0) - *msg = "Login ok"; - set_allowed_addrs(unit, addrs, opts); - } - - if (addrs != NULL) - free_wordlist(addrs); - BZERO(ppp_settings.passwd, sizeof(ppp_settings.passwd)); - BZERO(secret, sizeof(secret)); - - return ret; -} - -/* - * null_login - Check if a username of "" and a password of "" are - * acceptable, and iff so, set the list of acceptable IP addresses - * and return 1. - */ -static int -null_login(unit) - int unit; -{ - char *filename; - FILE *f; - int i, ret; - struct wordlist *addrs, *opts; - char secret[MAXWORDLEN]; - - /* - * Check if a plugin wants to handle this. - */ - ret = -1; - if (null_auth_hook) - ret = (*null_auth_hook)(&addrs, &opts); - - /* - * Open the file of pap secrets and scan for a suitable secret. - */ - if (ret <= 0) { - filename = _PATH_UPAPFILE; - addrs = NULL; - f = fopen(filename, "r"); - if (f == NULL) - return 0; - check_access(f, filename); - - i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename, 0); - ret = i >= 0 && secret[0] == 0; - BZERO(secret, sizeof(secret)); - fclose(f); - } - - if (ret) - set_allowed_addrs(unit, addrs, opts); - else if (opts != 0) - free_wordlist(opts); - if (addrs != 0) - free_wordlist(addrs); - - return ret; -} - -/* - * get_pap_passwd - get a password for authenticating ourselves with - * our peer using PAP. Returns 1 on success, 0 if no suitable password - * could be found. - * Assumes passwd points to MAXSECRETLEN bytes of space (if non-null). - */ -static int -get_pap_passwd(passwd) - char *passwd; -{ - char *filename; - FILE *f; - int ret; - char secret[MAXWORDLEN]; - - /* - * Check whether a plugin wants to supply this. - */ - if (pap_passwd_hook) { - ret = (*pap_passwd_hook)(ppp_settings,user, ppp_settings.passwd); - if (ret >= 0) - return ret; - } - - filename = _PATH_UPAPFILE; - f = fopen(filename, "r"); - if (f == NULL) - return 0; - check_access(f, filename); - ret = scan_authfile(f, user, - (remote_name[0]? remote_name: NULL), - secret, NULL, NULL, filename, 0); - fclose(f); - if (ret < 0) - return 0; - if (passwd != NULL) - strlcpy(passwd, secret, MAXSECRETLEN); - BZERO(secret, sizeof(secret)); - return 1; -} - -/* - * have_pap_secret - check whether we have a PAP file with any - * secrets that we could possibly use for authenticating the peer. - */ -static int -have_pap_secret(lacks_ipp) - int *lacks_ipp; -{ - FILE *f; - int ret; - char *filename; - struct wordlist *addrs; - - /* let the plugin decide, if there is one */ - if (pap_check_hook) { - ret = (*pap_check_hook)(); - if (ret >= 0) - return ret; - } - - filename = _PATH_UPAPFILE; - f = fopen(filename, "r"); - if (f == NULL) - return 0; - - ret = scan_authfile(f, (explicit_remote? remote_name: NULL), our_name, - NULL, &addrs, NULL, filename, 0); - fclose(f); - if (ret >= 0 && !some_ip_ok(addrs)) { - if (lacks_ipp != 0) - *lacks_ipp = 1; - ret = -1; - } - if (addrs != 0) - free_wordlist(addrs); - - return ret >= 0; -} - -/* - * have_chap_secret - check whether we have a CHAP file with a - * secret that we could possibly use for authenticating `client' - * on `server'. Either can be the null string, meaning we don't - * know the identity yet. - */ -static int -have_chap_secret(client, server, need_ip, lacks_ipp) - char *client; - char *server; - int need_ip; - int *lacks_ipp; -{ - FILE *f; - int ret; - char *filename; - struct wordlist *addrs; - - if (chap_check_hook) { - ret = (*chap_check_hook)(); - if (ret >= 0) { - return ret; - } - } - - filename = _PATH_CHAPFILE; - f = fopen(filename, "r"); - if (f == NULL) - return 0; - - if (client != NULL && client[0] == 0) - client = NULL; - else if (server != NULL && server[0] == 0) - server = NULL; - - ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0); - fclose(f); - if (ret >= 0 && need_ip && !some_ip_ok(addrs)) { - if (lacks_ipp != 0) - *lacks_ipp = 1; - ret = -1; - } - if (addrs != 0) - free_wordlist(addrs); - - return ret >= 0; -} - -/* - * have_srp_secret - check whether we have a SRP file with a - * secret that we could possibly use for authenticating `client' - * on `server'. Either can be the null string, meaning we don't - * know the identity yet. - */ -static int -have_srp_secret(client, server, need_ip, lacks_ipp) - char *client; - char *server; - int need_ip; - int *lacks_ipp; -{ - FILE *f; - int ret; - char *filename; - struct wordlist *addrs; - - filename = _PATH_SRPFILE; - f = fopen(filename, "r"); - if (f == NULL) - return 0; - - if (client != NULL && client[0] == 0) - client = NULL; - else if (server != NULL && server[0] == 0) - server = NULL; - - ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0); - fclose(f); - if (ret >= 0 && need_ip && !some_ip_ok(addrs)) { - if (lacks_ipp != 0) - *lacks_ipp = 1; - ret = -1; - } - if (addrs != 0) - free_wordlist(addrs); - - return ret >= 0; -} -#endif /* UNUSED */ - -#if PPP_AUTH_SUPPORT -/* - * get_secret - open the CHAP secret file and return the secret - * for authenticating the given client on the given server. - * (We could be either client or server). - */ -int get_secret(ppp_pcb *pcb, const char *client, const char *server, char *secret, int *secret_len, int am_server) { - int len; - LWIP_UNUSED_ARG(server); - LWIP_UNUSED_ARG(am_server); - - if (!client || !client[0] || !pcb->settings.user || !pcb->settings.passwd || strcmp(client, pcb->settings.user)) { - return 0; - } - - len = (int)strlen(pcb->settings.passwd); - if (len > MAXSECRETLEN) { - ppp_error("Secret for %s on %s is too long", client, server); - len = MAXSECRETLEN; - } - - MEMCPY(secret, pcb->settings.passwd, len); - *secret_len = len; - return 1; - -#if 0 /* UNUSED */ - FILE *f; - int ret, len; - char *filename; - struct wordlist *addrs, *opts; - char secbuf[MAXWORDLEN]; - struct wordlist *addrs; - addrs = NULL; - - if (!am_server && ppp_settings.passwd[0] != 0) { - strlcpy(secbuf, ppp_settings.passwd, sizeof(secbuf)); - } else if (!am_server && chap_passwd_hook) { - if ( (*chap_passwd_hook)(client, secbuf) < 0) { - ppp_error("Unable to obtain CHAP password for %s on %s from plugin", - client, server); - return 0; - } - } else { - filename = _PATH_CHAPFILE; - addrs = NULL; - secbuf[0] = 0; - - f = fopen(filename, "r"); - if (f == NULL) { - ppp_error("Can't open chap secret file %s: %m", filename); - return 0; - } - check_access(f, filename); - - ret = scan_authfile(f, client, server, secbuf, &addrs, &opts, filename, 0); - fclose(f); - if (ret < 0) - return 0; - - if (am_server) - set_allowed_addrs(unit, addrs, opts); - else if (opts != 0) - free_wordlist(opts); - if (addrs != 0) - free_wordlist(addrs); - } - - len = strlen(secbuf); - if (len > MAXSECRETLEN) { - ppp_error("Secret for %s on %s is too long", client, server); - len = MAXSECRETLEN; - } - MEMCPY(secret, secbuf, len); - BZERO(secbuf, sizeof(secbuf)); - *secret_len = len; - - return 1; -#endif /* UNUSED */ -} -#endif /* PPP_AUTH_SUPPORT */ - - -#if 0 /* UNUSED */ -/* - * get_srp_secret - open the SRP secret file and return the secret - * for authenticating the given client on the given server. - * (We could be either client or server). - */ -int -get_srp_secret(unit, client, server, secret, am_server) - int unit; - char *client; - char *server; - char *secret; - int am_server; -{ - FILE *fp; - int ret; - char *filename; - struct wordlist *addrs, *opts; - - if (!am_server && ppp_settings.passwd[0] != '\0') { - strlcpy(secret, ppp_settings.passwd, MAXWORDLEN); - } else { - filename = _PATH_SRPFILE; - addrs = NULL; - - fp = fopen(filename, "r"); - if (fp == NULL) { - ppp_error("Can't open srp secret file %s: %m", filename); - return 0; - } - check_access(fp, filename); - - secret[0] = '\0'; - ret = scan_authfile(fp, client, server, secret, &addrs, &opts, - filename, am_server); - fclose(fp); - if (ret < 0) - return 0; - - if (am_server) - set_allowed_addrs(unit, addrs, opts); - else if (opts != NULL) - free_wordlist(opts); - if (addrs != NULL) - free_wordlist(addrs); - } - - return 1; -} - -/* - * set_allowed_addrs() - set the list of allowed addresses. - * Also looks for `--' indicating options to apply for this peer - * and leaves the following words in extra_options. - */ -static void -set_allowed_addrs(unit, addrs, opts) - int unit; - struct wordlist *addrs; - struct wordlist *opts; -{ - int n; - struct wordlist *ap, **plink; - struct permitted_ip *ip; - char *ptr_word, *ptr_mask; - struct hostent *hp; - struct netent *np; - u32_t a, mask, ah, offset; - struct ipcp_options *wo = &ipcp_wantoptions[unit]; - u32_t suggested_ip = 0; - - if (addresses[unit] != NULL) - free(addresses[unit]); - addresses[unit] = NULL; - if (extra_options != NULL) - free_wordlist(extra_options); - extra_options = opts; - - /* - * Count the number of IP addresses given. - */ - n = wordlist_count(addrs) + wordlist_count(noauth_addrs); - if (n == 0) - return; - ip = (struct permitted_ip *) malloc((n + 1) * sizeof(struct permitted_ip)); - if (ip == 0) - return; - - /* temporarily append the noauth_addrs list to addrs */ - for (plink = &addrs; *plink != NULL; plink = &(*plink)->next) - ; - *plink = noauth_addrs; - - n = 0; - for (ap = addrs; ap != NULL; ap = ap->next) { - /* "-" means no addresses authorized, "*" means any address allowed */ - ptr_word = ap->word; - if (strcmp(ptr_word, "-") == 0) - break; - if (strcmp(ptr_word, "*") == 0) { - ip[n].permit = 1; - ip[n].base = ip[n].mask = 0; - ++n; - break; - } - - ip[n].permit = 1; - if (*ptr_word == '!') { - ip[n].permit = 0; - ++ptr_word; - } - - mask = ~ (u32_t) 0; - offset = 0; - ptr_mask = strchr (ptr_word, '/'); - if (ptr_mask != NULL) { - int bit_count; - char *endp; - - bit_count = (int) strtol (ptr_mask+1, &endp, 10); - if (bit_count <= 0 || bit_count > 32) { - ppp_warn("invalid address length %v in auth. address list", - ptr_mask+1); - continue; - } - bit_count = 32 - bit_count; /* # bits in host part */ - if (*endp == '+') { - offset = ifunit + 1; - ++endp; - } - if (*endp != 0) { - ppp_warn("invalid address length syntax: %v", ptr_mask+1); - continue; - } - *ptr_mask = '\0'; - mask <<= bit_count; - } - - hp = gethostbyname(ptr_word); - if (hp != NULL && hp->h_addrtype == AF_INET) { - a = *(u32_t *)hp->h_addr; - } else { - np = getnetbyname (ptr_word); - if (np != NULL && np->n_addrtype == AF_INET) { - a = lwip_htonl ((u32_t)np->n_net); - if (ptr_mask == NULL) { - /* calculate appropriate mask for net */ - ah = lwip_ntohl(a); - if (IN_CLASSA(ah)) - mask = IN_CLASSA_NET; - else if (IN_CLASSB(ah)) - mask = IN_CLASSB_NET; - else if (IN_CLASSC(ah)) - mask = IN_CLASSC_NET; - } - } else { - a = inet_addr (ptr_word); - } - } - - if (ptr_mask != NULL) - *ptr_mask = '/'; - - if (a == (u32_t)-1L) { - ppp_warn("unknown host %s in auth. address list", ap->word); - continue; - } - if (offset != 0) { - if (offset >= ~mask) { - ppp_warn("interface unit %d too large for subnet %v", - ifunit, ptr_word); - continue; - } - a = lwip_htonl((lwip_ntohl(a) & mask) + offset); - mask = ~(u32_t)0; - } - ip[n].mask = lwip_htonl(mask); - ip[n].base = a & ip[n].mask; - ++n; - if (~mask == 0 && suggested_ip == 0) - suggested_ip = a; - } - *plink = NULL; - - ip[n].permit = 0; /* make the last entry forbid all addresses */ - ip[n].base = 0; /* to terminate the list */ - ip[n].mask = 0; - - addresses[unit] = ip; - - /* - * If the address given for the peer isn't authorized, or if - * the user hasn't given one, AND there is an authorized address - * which is a single host, then use that if we find one. - */ - if (suggested_ip != 0 - && (wo->hisaddr == 0 || !auth_ip_addr(unit, wo->hisaddr))) { - wo->hisaddr = suggested_ip; - /* - * Do we insist on this address? No, if there are other - * addresses authorized than the suggested one. - */ - if (n > 1) - wo->accept_remote = 1; - } -} - -/* - * auth_ip_addr - check whether the peer is authorized to use - * a given IP address. Returns 1 if authorized, 0 otherwise. - */ -int -auth_ip_addr(unit, addr) - int unit; - u32_t addr; -{ - int ok; - - /* don't allow loopback or multicast address */ - if (bad_ip_adrs(addr)) - return 0; - - if (allowed_address_hook) { - ok = allowed_address_hook(addr); - if (ok >= 0) return ok; - } - - if (addresses[unit] != NULL) { - ok = ip_addr_check(addr, addresses[unit]); - if (ok >= 0) - return ok; - } - - if (auth_required) - return 0; /* no addresses authorized */ - return allow_any_ip || privileged || !have_route_to(addr); -} - -static int -ip_addr_check(addr, addrs) - u32_t addr; - struct permitted_ip *addrs; -{ - for (; ; ++addrs) - if ((addr & addrs->mask) == addrs->base) - return addrs->permit; -} - -/* - * bad_ip_adrs - return 1 if the IP address is one we don't want - * to use, such as an address in the loopback net or a multicast address. - * addr is in network byte order. - */ -int -bad_ip_adrs(addr) - u32_t addr; -{ - addr = lwip_ntohl(addr); - return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET - || IN_MULTICAST(addr) || IN_BADCLASS(addr); -} - -/* - * some_ip_ok - check a wordlist to see if it authorizes any - * IP address(es). - */ -static int -some_ip_ok(addrs) - struct wordlist *addrs; -{ - for (; addrs != 0; addrs = addrs->next) { - if (addrs->word[0] == '-') - break; - if (addrs->word[0] != '!') - return 1; /* some IP address is allowed */ - } - return 0; -} - -/* - * auth_number - check whether the remote number is allowed to connect. - * Returns 1 if authorized, 0 otherwise. - */ -int -auth_number() -{ - struct wordlist *wp = permitted_numbers; - int l; - - /* Allow all if no authorization list. */ - if (!wp) - return 1; - - /* Allow if we have a match in the authorization list. */ - while (wp) { - /* trailing '*' wildcard */ - l = strlen(wp->word); - if ((wp->word)[l - 1] == '*') - l--; - if (!strncasecmp(wp->word, remote_number, l)) - return 1; - wp = wp->next; - } - - return 0; -} - -/* - * check_access - complain if a secret file has too-liberal permissions. - */ -static void -check_access(f, filename) - FILE *f; - char *filename; -{ - struct stat sbuf; - - if (fstat(fileno(f), &sbuf) < 0) { - ppp_warn("cannot stat secret file %s: %m", filename); - } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) { - ppp_warn("Warning - secret file %s has world and/or group access", - filename); - } -} - -/* - * scan_authfile - Scan an authorization file for a secret suitable - * for authenticating `client' on `server'. The return value is -1 - * if no secret is found, otherwise >= 0. The return value has - * NONWILD_CLIENT set if the secret didn't have "*" for the client, and - * NONWILD_SERVER set if the secret didn't have "*" for the server. - * Any following words on the line up to a "--" (i.e. address authorization - * info) are placed in a wordlist and returned in *addrs. Any - * following words (extra options) are placed in a wordlist and - * returned in *opts. - * We assume secret is NULL or points to MAXWORDLEN bytes of space. - * Flags are non-zero if we need two colons in the secret in order to - * match. - */ -static int -scan_authfile(f, client, server, secret, addrs, opts, filename, flags) - FILE *f; - char *client; - char *server; - char *secret; - struct wordlist **addrs; - struct wordlist **opts; - char *filename; - int flags; -{ - int newline, xxx; - int got_flag, best_flag; - FILE *sf; - struct wordlist *ap, *addr_list, *alist, **app; - char word[MAXWORDLEN]; - char atfile[MAXWORDLEN]; - char lsecret[MAXWORDLEN]; - char *cp; - - if (addrs != NULL) - *addrs = NULL; - if (opts != NULL) - *opts = NULL; - addr_list = NULL; - if (!getword(f, word, &newline, filename)) - return -1; /* file is empty??? */ - newline = 1; - best_flag = -1; - for (;;) { - /* - * Skip until we find a word at the start of a line. - */ - while (!newline && getword(f, word, &newline, filename)) - ; - if (!newline) - break; /* got to end of file */ - - /* - * Got a client - check if it's a match or a wildcard. - */ - got_flag = 0; - if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) { - newline = 0; - continue; - } - if (!ISWILD(word)) - got_flag = NONWILD_CLIENT; - - /* - * Now get a server and check if it matches. - */ - if (!getword(f, word, &newline, filename)) - break; - if (newline) - continue; - if (!ISWILD(word)) { - if (server != NULL && strcmp(word, server) != 0) - continue; - got_flag |= NONWILD_SERVER; - } - - /* - * Got some sort of a match - see if it's better than what - * we have already. - */ - if (got_flag <= best_flag) - continue; - - /* - * Get the secret. - */ - if (!getword(f, word, &newline, filename)) - break; - if (newline) - continue; - - /* - * SRP-SHA1 authenticator should never be reading secrets from - * a file. (Authenticatee may, though.) - */ - if (flags && ((cp = strchr(word, ':')) == NULL || - strchr(cp + 1, ':') == NULL)) - continue; - - if (secret != NULL) { - /* - * Special syntax: @/pathname means read secret from file. - */ - if (word[0] == '@' && word[1] == '/') { - strlcpy(atfile, word+1, sizeof(atfile)); - if ((sf = fopen(atfile, "r")) == NULL) { - ppp_warn("can't open indirect secret file %s", atfile); - continue; - } - check_access(sf, atfile); - if (!getword(sf, word, &xxx, atfile)) { - ppp_warn("no secret in indirect secret file %s", atfile); - fclose(sf); - continue; - } - fclose(sf); - } - strlcpy(lsecret, word, sizeof(lsecret)); - } - - /* - * Now read address authorization info and make a wordlist. - */ - app = &alist; - for (;;) { - if (!getword(f, word, &newline, filename) || newline) - break; - ap = (struct wordlist *) - malloc(sizeof(struct wordlist) + strlen(word) + 1); - if (ap == NULL) - novm("authorized addresses"); - ap->word = (char *) (ap + 1); - strcpy(ap->word, word); - *app = ap; - app = &ap->next; - } - *app = NULL; - - /* - * This is the best so far; remember it. - */ - best_flag = got_flag; - if (addr_list) - free_wordlist(addr_list); - addr_list = alist; - if (secret != NULL) - strlcpy(secret, lsecret, MAXWORDLEN); - - if (!newline) - break; - } - - /* scan for a -- word indicating the start of options */ - for (app = &addr_list; (ap = *app) != NULL; app = &ap->next) - if (strcmp(ap->word, "--") == 0) - break; - /* ap = start of options */ - if (ap != NULL) { - ap = ap->next; /* first option */ - free(*app); /* free the "--" word */ - *app = NULL; /* terminate addr list */ - } - if (opts != NULL) - *opts = ap; - else if (ap != NULL) - free_wordlist(ap); - if (addrs != NULL) - *addrs = addr_list; - else if (addr_list != NULL) - free_wordlist(addr_list); - - return best_flag; -} - -/* - * wordlist_count - return the number of items in a wordlist - */ -static int -wordlist_count(wp) - struct wordlist *wp; -{ - int n; - - for (n = 0; wp != NULL; wp = wp->next) - ++n; - return n; -} - -/* - * free_wordlist - release memory allocated for a wordlist. - */ -static void -free_wordlist(wp) - struct wordlist *wp; -{ - struct wordlist *next; - - while (wp != NULL) { - next = wp->next; - free(wp); - wp = next; - } -} -#endif /* UNUSED */ - -#endif /* PPP_SUPPORT */ +/* + * auth.c - PPP authentication and phase control. + * + * Copyright (c) 1993-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Derived from main.c, which is: + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#if 0 /* UNUSED */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#if defined(_PATH_LASTLOG) && defined(__linux__) +#include +#endif + +#include +#include +#include + +#ifdef HAS_SHADOW +#include +#ifndef PW_PPP +#define PW_PPP PW_LOGIN +#endif +#endif + +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/lcp.h" +#if CCP_SUPPORT +#include "netif/ppp/ccp.h" +#endif /* CCP_SUPPORT */ +#if ECP_SUPPORT +#include "netif/ppp/ecp.h" +#endif /* ECP_SUPPORT */ +#include "netif/ppp/ipcp.h" +#if PAP_SUPPORT +#include "netif/ppp/upap.h" +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT +#include "netif/ppp/chap-new.h" +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT +#include "netif/ppp/eap.h" +#endif /* EAP_SUPPORT */ +#if CBCP_SUPPORT +#include "netif/ppp/cbcp.h" +#endif + +#if 0 /* UNUSED */ +#include "session.h" +#endif /* UNUSED */ + +#if 0 /* UNUSED */ +/* Bits in scan_authfile return value */ +#define NONWILD_SERVER 1 +#define NONWILD_CLIENT 2 + +#define ISWILD(word) (word[0] == '*' && word[1] == 0) +#endif /* UNUSED */ + +#if 0 /* UNUSED */ +/* List of addresses which the peer may use. */ +static struct permitted_ip *addresses[NUM_PPP]; + +/* Wordlist giving addresses which the peer may use + without authenticating itself. */ +static struct wordlist *noauth_addrs; + +/* Remote telephone number, if available */ +char remote_number[MAXNAMELEN]; + +/* Wordlist giving remote telephone numbers which may connect. */ +static struct wordlist *permitted_numbers; + +/* Extra options to apply, from the secrets file entry for the peer. */ +static struct wordlist *extra_options; +#endif /* UNUSED */ + +#if 0 /* UNUSED */ +/* Set if we require authentication only because we have a default route. */ +static bool default_auth; + +/* Hook to enable a plugin to control the idle time limit */ +int (*idle_time_hook) (struct ppp_idle *) = NULL; + +/* Hook for a plugin to say whether we can possibly authenticate any peer */ +int (*pap_check_hook) (void) = NULL; + +/* Hook for a plugin to check the PAP user and password */ +int (*pap_auth_hook) (char *user, char *passwd, char **msgp, + struct wordlist **paddrs, + struct wordlist **popts) = NULL; + +/* Hook for a plugin to know about the PAP user logout */ +void (*pap_logout_hook) (void) = NULL; + +/* Hook for a plugin to get the PAP password for authenticating us */ +int (*pap_passwd_hook) (char *user, char *passwd) = NULL; + +/* Hook for a plugin to say if we can possibly authenticate a peer using CHAP */ +int (*chap_check_hook) (void) = NULL; + +/* Hook for a plugin to get the CHAP password for authenticating us */ +int (*chap_passwd_hook) (char *user, char *passwd) = NULL; + +/* Hook for a plugin to say whether it is OK if the peer + refuses to authenticate. */ +int (*null_auth_hook) (struct wordlist **paddrs, + struct wordlist **popts) = NULL; + +int (*allowed_address_hook) (u32_t addr) = NULL; +#endif /* UNUSED */ + +#ifdef HAVE_MULTILINK +/* Hook for plugin to hear when an interface joins a multilink bundle */ +void (*multilink_join_hook) (void) = NULL; +#endif + +#if PPP_NOTIFY +/* A notifier for when the peer has authenticated itself, + and we are proceeding to the network phase. */ +struct notifier *auth_up_notifier = NULL; + +/* A notifier for when the link goes down. */ +struct notifier *link_down_notifier = NULL; +#endif /* PPP_NOTIFY */ + +/* + * Option variables. + */ +#if 0 /* MOVED TO ppp_settings */ +bool uselogin = 0; /* Use /etc/passwd for checking PAP */ +bool session_mgmt = 0; /* Do session management (login records) */ +bool cryptpap = 0; /* Passwords in pap-secrets are encrypted */ +bool refuse_pap = 0; /* Don't wanna auth. ourselves with PAP */ +bool refuse_chap = 0; /* Don't wanna auth. ourselves with CHAP */ +bool refuse_eap = 0; /* Don't wanna auth. ourselves with EAP */ +#if MSCHAP_SUPPORT +bool refuse_mschap = 0; /* Don't wanna auth. ourselves with MS-CHAP */ +bool refuse_mschap_v2 = 0; /* Don't wanna auth. ourselves with MS-CHAPv2 */ +#else /* MSCHAP_SUPPORT */ +bool refuse_mschap = 1; /* Don't wanna auth. ourselves with MS-CHAP */ +bool refuse_mschap_v2 = 1; /* Don't wanna auth. ourselves with MS-CHAPv2 */ +#endif /* MSCHAP_SUPPORT */ +bool usehostname = 0; /* Use hostname for our_name */ +bool auth_required = 0; /* Always require authentication from peer */ +bool allow_any_ip = 0; /* Allow peer to use any IP address */ +bool explicit_remote = 0; /* User specified explicit remote name */ +bool explicit_user = 0; /* Set if "user" option supplied */ +bool explicit_passwd = 0; /* Set if "password" option supplied */ +char remote_name[MAXNAMELEN]; /* Peer's name for authentication */ +static char *uafname; /* name of most recent +ua file */ + +extern char *crypt (const char *, const char *); +#endif /* UNUSED */ +/* Prototypes for procedures local to this file. */ + +static void network_phase(ppp_pcb *pcb); +#if PPP_IDLETIMELIMIT +static void check_idle(void *arg); +#endif /* PPP_IDLETIMELIMIT */ +#if PPP_MAXCONNECT +static void connect_time_expired(void *arg); +#endif /* PPP_MAXCONNECT */ +#if 0 /* UNUSED */ +static int null_login (int); +/* static int get_pap_passwd (char *); */ +static int have_pap_secret (int *); +static int have_chap_secret (char *, char *, int, int *); +static int have_srp_secret (char *client, char *server, int need_ip, + int *lacks_ipp); +static int ip_addr_check (u32_t, struct permitted_ip *); +static int scan_authfile (FILE *, char *, char *, char *, + struct wordlist **, struct wordlist **, + char *, int); +static void free_wordlist (struct wordlist *); +static void set_allowed_addrs (int, struct wordlist *, struct wordlist *); +static int some_ip_ok (struct wordlist *); +static int setupapfile (char **); +static int privgroup (char **); +static int set_noauth_addr (char **); +static int set_permitted_number (char **); +static void check_access (FILE *, char *); +static int wordlist_count (struct wordlist *); +#endif /* UNUSED */ + +#ifdef MAXOCTETS +static void check_maxoctets (void *); +#endif + +#if PPP_OPTIONS +/* + * Authentication-related options. + */ +option_t auth_options[] = { + { "auth", o_bool, &auth_required, + "Require authentication from peer", OPT_PRIO | 1 }, + { "noauth", o_bool, &auth_required, + "Don't require peer to authenticate", OPT_PRIOSUB | OPT_PRIV, + &allow_any_ip }, + { "require-pap", o_bool, &lcp_wantoptions[0].neg_upap, + "Require PAP authentication from peer", + OPT_PRIOSUB | 1, &auth_required }, + { "+pap", o_bool, &lcp_wantoptions[0].neg_upap, + "Require PAP authentication from peer", + OPT_ALIAS | OPT_PRIOSUB | 1, &auth_required }, + { "require-chap", o_bool, &auth_required, + "Require CHAP authentication from peer", + OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5, + &lcp_wantoptions[0].chap_mdtype }, + { "+chap", o_bool, &auth_required, + "Require CHAP authentication from peer", + OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MD5, + &lcp_wantoptions[0].chap_mdtype }, +#if MSCHAP_SUPPORT + { "require-mschap", o_bool, &auth_required, + "Require MS-CHAP authentication from peer", + OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT, + &lcp_wantoptions[0].chap_mdtype }, + { "+mschap", o_bool, &auth_required, + "Require MS-CHAP authentication from peer", + OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT, + &lcp_wantoptions[0].chap_mdtype }, + { "require-mschap-v2", o_bool, &auth_required, + "Require MS-CHAPv2 authentication from peer", + OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2, + &lcp_wantoptions[0].chap_mdtype }, + { "+mschap-v2", o_bool, &auth_required, + "Require MS-CHAPv2 authentication from peer", + OPT_ALIAS | OPT_PRIOSUB | OPT_A2OR | MDTYPE_MICROSOFT_V2, + &lcp_wantoptions[0].chap_mdtype }, +#endif /* MSCHAP_SUPPORT */ +#if 0 + { "refuse-pap", o_bool, &refuse_pap, + "Don't agree to auth to peer with PAP", 1 }, + { "-pap", o_bool, &refuse_pap, + "Don't allow PAP authentication with peer", OPT_ALIAS | 1 }, + { "refuse-chap", o_bool, &refuse_chap, + "Don't agree to auth to peer with CHAP", + OPT_A2CLRB | MDTYPE_MD5, + &lcp_allowoptions[0].chap_mdtype }, + { "-chap", o_bool, &refuse_chap, + "Don't allow CHAP authentication with peer", + OPT_ALIAS | OPT_A2CLRB | MDTYPE_MD5, + &lcp_allowoptions[0].chap_mdtype }, +#endif +#if MSCHAP_SUPPORT +#if 0 + { "refuse-mschap", o_bool, &refuse_mschap, + "Don't agree to auth to peer with MS-CHAP", + OPT_A2CLRB | MDTYPE_MICROSOFT, + &lcp_allowoptions[0].chap_mdtype }, + { "-mschap", o_bool, &refuse_mschap, + "Don't allow MS-CHAP authentication with peer", + OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT, + &lcp_allowoptions[0].chap_mdtype }, + { "refuse-mschap-v2", o_bool, &refuse_mschap_v2, + "Don't agree to auth to peer with MS-CHAPv2", + OPT_A2CLRB | MDTYPE_MICROSOFT_V2, + &lcp_allowoptions[0].chap_mdtype }, + { "-mschap-v2", o_bool, &refuse_mschap_v2, + "Don't allow MS-CHAPv2 authentication with peer", + OPT_ALIAS | OPT_A2CLRB | MDTYPE_MICROSOFT_V2, + &lcp_allowoptions[0].chap_mdtype }, +#endif +#endif /* MSCHAP_SUPPORT*/ +#if EAP_SUPPORT + { "require-eap", o_bool, &lcp_wantoptions[0].neg_eap, + "Require EAP authentication from peer", OPT_PRIOSUB | 1, + &auth_required }, +#if 0 + { "refuse-eap", o_bool, &refuse_eap, + "Don't agree to authenticate to peer with EAP", 1 }, +#endif +#endif /* EAP_SUPPORT */ + { "name", o_string, our_name, + "Set local name for authentication", + OPT_PRIO | OPT_PRIV | OPT_STATIC, NULL, MAXNAMELEN }, + + { "+ua", o_special, (void *)setupapfile, + "Get PAP user and password from file", + OPT_PRIO | OPT_A2STRVAL, &uafname }, + +#if 0 + { "user", o_string, user, + "Set name for auth with peer", OPT_PRIO | OPT_STATIC, + &explicit_user, MAXNAMELEN }, + + { "password", o_string, passwd, + "Password for authenticating us to the peer", + OPT_PRIO | OPT_STATIC | OPT_HIDE, + &explicit_passwd, MAXSECRETLEN }, +#endif + + { "usehostname", o_bool, &usehostname, + "Must use hostname for authentication", 1 }, + + { "remotename", o_string, remote_name, + "Set remote name for authentication", OPT_PRIO | OPT_STATIC, + &explicit_remote, MAXNAMELEN }, + + { "login", o_bool, &uselogin, + "Use system password database for PAP", OPT_A2COPY | 1 , + &session_mgmt }, + { "enable-session", o_bool, &session_mgmt, + "Enable session accounting for remote peers", OPT_PRIV | 1 }, + + { "papcrypt", o_bool, &cryptpap, + "PAP passwords are encrypted", 1 }, + + { "privgroup", o_special, (void *)privgroup, + "Allow group members to use privileged options", OPT_PRIV | OPT_A2LIST }, + + { "allow-ip", o_special, (void *)set_noauth_addr, + "Set IP address(es) which can be used without authentication", + OPT_PRIV | OPT_A2LIST }, + + { "remotenumber", o_string, remote_number, + "Set remote telephone number for authentication", OPT_PRIO | OPT_STATIC, + NULL, MAXNAMELEN }, + + { "allow-number", o_special, (void *)set_permitted_number, + "Set telephone number(s) which are allowed to connect", + OPT_PRIV | OPT_A2LIST }, + + { NULL } +}; +#endif /* PPP_OPTIONS */ + +#if 0 /* UNUSED */ +/* + * setupapfile - specifies UPAP info for authenticating with peer. + */ +static int +setupapfile(argv) + char **argv; +{ + FILE *ufile; + int l; + uid_t euid; + char u[MAXNAMELEN], p[MAXSECRETLEN]; + char *fname; + + lcp_allowoptions[0].neg_upap = 1; + + /* open user info file */ + fname = strdup(*argv); + if (fname == NULL) + novm("+ua file name"); + euid = geteuid(); + if (seteuid(getuid()) == -1) { + option_error("unable to reset uid before opening %s: %m", fname); + return 0; + } + ufile = fopen(fname, "r"); + if (seteuid(euid) == -1) + fatal("unable to regain privileges: %m"); + if (ufile == NULL) { + option_error("unable to open user login data file %s", fname); + return 0; + } + check_access(ufile, fname); + uafname = fname; + + /* get username */ + if (fgets(u, MAXNAMELEN - 1, ufile) == NULL + || fgets(p, MAXSECRETLEN - 1, ufile) == NULL) { + fclose(ufile); + option_error("unable to read user login data file %s", fname); + return 0; + } + fclose(ufile); + + /* get rid of newlines */ + l = strlen(u); + if (l > 0 && u[l-1] == '\n') + u[l-1] = 0; + l = strlen(p); + if (l > 0 && p[l-1] == '\n') + p[l-1] = 0; + + if (override_value("user", option_priority, fname)) { + strlcpy(ppp_settings.user, u, sizeof(ppp_settings.user)); + explicit_user = 1; + } + if (override_value("passwd", option_priority, fname)) { + strlcpy(ppp_settings.passwd, p, sizeof(ppp_settings.passwd)); + explicit_passwd = 1; + } + + return (1); +} + +/* + * privgroup - allow members of the group to have privileged access. + */ +static int +privgroup(argv) + char **argv; +{ + struct group *g; + int i; + + g = getgrnam(*argv); + if (g == 0) { + option_error("group %s is unknown", *argv); + return 0; + } + for (i = 0; i < ngroups; ++i) { + if (groups[i] == g->gr_gid) { + privileged = 1; + break; + } + } + return 1; +} + + +/* + * set_noauth_addr - set address(es) that can be used without authentication. + * Equivalent to specifying an entry like `"" * "" addr' in pap-secrets. + */ +static int +set_noauth_addr(argv) + char **argv; +{ + char *addr = *argv; + int l = strlen(addr) + 1; + struct wordlist *wp; + + wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l); + if (wp == NULL) + novm("allow-ip argument"); + wp->word = (char *) (wp + 1); + wp->next = noauth_addrs; + MEMCPY(wp->word, addr, l); + noauth_addrs = wp; + return 1; +} + + +/* + * set_permitted_number - set remote telephone number(s) that may connect. + */ +static int +set_permitted_number(argv) + char **argv; +{ + char *number = *argv; + int l = strlen(number) + 1; + struct wordlist *wp; + + wp = (struct wordlist *) malloc(sizeof(struct wordlist) + l); + if (wp == NULL) + novm("allow-number argument"); + wp->word = (char *) (wp + 1); + wp->next = permitted_numbers; + MEMCPY(wp->word, number, l); + permitted_numbers = wp; + return 1; +} +#endif + +/* + * An Open on LCP has requested a change from Dead to Establish phase. + */ +void link_required(ppp_pcb *pcb) { + LWIP_UNUSED_ARG(pcb); +} + +#if 0 +/* + * Bring the link up to the point of being able to do ppp. + */ +void start_link(unit) + int unit; +{ + ppp_pcb *pcb = &ppp_pcb_list[unit]; + char *msg; + + status = EXIT_NEGOTIATION_FAILED; + new_phase(pcb, PPP_PHASE_SERIALCONN); + + hungup = 0; + devfd = the_channel->connect(); + msg = "Connect script failed"; + if (devfd < 0) + goto fail; + + /* set up the serial device as a ppp interface */ + /* + * N.B. we used to do tdb_writelock/tdb_writeunlock around this + * (from establish_ppp to set_ifunit). However, we won't be + * doing the set_ifunit in multilink mode, which is the only time + * we need the atomicity that the tdb_writelock/tdb_writeunlock + * gives us. Thus we don't need the tdb_writelock/tdb_writeunlock. + */ + fd_ppp = the_channel->establish_ppp(devfd); + msg = "ppp establishment failed"; + if (fd_ppp < 0) { + status = EXIT_FATAL_ERROR; + goto disconnect; + } + + if (!demand && ifunit >= 0) + set_ifunit(1); + + /* + * Start opening the connection and wait for + * incoming events (reply, timeout, etc.). + */ + if (ifunit >= 0) + ppp_notice("Connect: %s <--> %s", ifname, ppp_devnam); + else + ppp_notice("Starting negotiation on %s", ppp_devnam); + add_fd(fd_ppp); + + new_phase(pcb, PPP_PHASE_ESTABLISH); + + lcp_lowerup(pcb); + return; + + disconnect: + new_phase(pcb, PPP_PHASE_DISCONNECT); + if (the_channel->disconnect) + the_channel->disconnect(); + + fail: + new_phase(pcb, PPP_PHASE_DEAD); + if (the_channel->cleanup) + (*the_channel->cleanup)(); +} +#endif + +/* + * LCP has terminated the link; go to the Dead phase and take the + * physical layer down. + */ +void link_terminated(ppp_pcb *pcb) { + if (pcb->phase == PPP_PHASE_DEAD +#ifdef HAVE_MULTILINK + || pcb->phase == PPP_PHASE_MASTER +#endif /* HAVE_MULTILINK */ + ) + return; + new_phase(pcb, PPP_PHASE_DISCONNECT); + +#if 0 /* UNUSED */ + if (pap_logout_hook) { + pap_logout_hook(); + } + session_end(devnam); +#endif /* UNUSED */ + + if (!doing_multilink) { + ppp_notice("Connection terminated."); +#if PPP_STATS_SUPPORT + print_link_stats(); +#endif /* PPP_STATS_SUPPORT */ + } else + ppp_notice("Link terminated."); + + lcp_lowerdown(pcb); + + ppp_link_terminated(pcb); +#if 0 + /* + * Delete pid files before disestablishing ppp. Otherwise it + * can happen that another pppd gets the same unit and then + * we delete its pid file. + */ + if (!doing_multilink && !demand) + remove_pidfiles(); + + /* + * If we may want to bring the link up again, transfer + * the ppp unit back to the loopback. Set the + * real serial device back to its normal mode of operation. + */ + if (fd_ppp >= 0) { + remove_fd(fd_ppp); + clean_check(); + the_channel->disestablish_ppp(devfd); + if (doing_multilink) + mp_exit_bundle(); + fd_ppp = -1; + } + if (!hungup) + lcp_lowerdown(pcb); + if (!doing_multilink && !demand) + script_unsetenv("IFNAME"); + + /* + * Run disconnector script, if requested. + * XXX we may not be able to do this if the line has hung up! + */ + if (devfd >= 0 && the_channel->disconnect) { + the_channel->disconnect(); + devfd = -1; + } + if (the_channel->cleanup) + (*the_channel->cleanup)(); + + if (doing_multilink && multilink_master) { + if (!bundle_terminating) + new_phase(pcb, PPP_PHASE_MASTER); + else + mp_bundle_terminated(); + } else + new_phase(pcb, PPP_PHASE_DEAD); +#endif +} + +/* + * LCP has gone down; it will either die or try to re-establish. + */ +void link_down(ppp_pcb *pcb) { +#if PPP_NOTIFY + notify(link_down_notifier, 0); +#endif /* PPP_NOTIFY */ + + if (!doing_multilink) { + upper_layers_down(pcb); + if (pcb->phase != PPP_PHASE_DEAD +#ifdef HAVE_MULTILINK + && pcb->phase != PPP_PHASE_MASTER +#endif /* HAVE_MULTILINK */ + ) + new_phase(pcb, PPP_PHASE_ESTABLISH); + } + /* XXX if doing_multilink, should do something to stop + network-layer traffic on the link */ +} + +void upper_layers_down(ppp_pcb *pcb) { + int i; + const struct protent *protp; + + for (i = 0; (protp = protocols[i]) != NULL; ++i) { + if (protp->protocol != PPP_LCP && protp->lowerdown != NULL) + (*protp->lowerdown)(pcb); + if (protp->protocol < 0xC000 && protp->close != NULL) + (*protp->close)(pcb, "LCP down"); + } + pcb->num_np_open = 0; + pcb->num_np_up = 0; +} + +/* + * The link is established. + * Proceed to the Dead, Authenticate or Network phase as appropriate. + */ +void link_established(ppp_pcb *pcb) { +#if PPP_AUTH_SUPPORT + int auth; +#if PPP_SERVER +#if PAP_SUPPORT + lcp_options *wo = &pcb->lcp_wantoptions; +#endif /* PAP_SUPPORT */ + lcp_options *go = &pcb->lcp_gotoptions; +#endif /* PPP_SERVER */ + lcp_options *ho = &pcb->lcp_hisoptions; +#endif /* PPP_AUTH_SUPPORT */ + int i; + const struct protent *protp; + + /* + * Tell higher-level protocols that LCP is up. + */ + if (!doing_multilink) { + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (protp->protocol != PPP_LCP + && protp->lowerup != NULL) + (*protp->lowerup)(pcb); + } + +#if PPP_AUTH_SUPPORT +#if PPP_SERVER +#if PPP_ALLOWED_ADDRS + if (!auth_required && noauth_addrs != NULL) + set_allowed_addrs(unit, NULL, NULL); +#endif /* PPP_ALLOWED_ADDRS */ + + if (pcb->settings.auth_required && !(0 +#if PAP_SUPPORT + || go->neg_upap +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + || go->neg_chap +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + || go->neg_eap +#endif /* EAP_SUPPORT */ + )) { + +#if PPP_ALLOWED_ADDRS + /* + * We wanted the peer to authenticate itself, and it refused: + * if we have some address(es) it can use without auth, fine, + * otherwise treat it as though it authenticated with PAP using + * a username of "" and a password of "". If that's not OK, + * boot it out. + */ + if (noauth_addrs != NULL) { + set_allowed_addrs(unit, NULL, NULL); + } else +#endif /* PPP_ALLOWED_ADDRS */ + if (!pcb->settings.null_login +#if PAP_SUPPORT + || !wo->neg_upap +#endif /* PAP_SUPPORT */ + ) { + ppp_warn("peer refused to authenticate: terminating link"); +#if 0 /* UNUSED */ + status = EXIT_PEER_AUTH_FAILED; +#endif /* UNUSED */ + pcb->err_code = PPPERR_AUTHFAIL; + lcp_close(pcb, "peer refused to authenticate"); + return; + } + } +#endif /* PPP_SERVER */ + + new_phase(pcb, PPP_PHASE_AUTHENTICATE); + auth = 0; +#if PPP_SERVER +#if EAP_SUPPORT + if (go->neg_eap) { + eap_authpeer(pcb, PPP_OUR_NAME); + auth |= EAP_PEER; + } else +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT + if (go->neg_chap) { + chap_auth_peer(pcb, PPP_OUR_NAME, CHAP_DIGEST(go->chap_mdtype)); + auth |= CHAP_PEER; + } else +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + if (go->neg_upap) { + upap_authpeer(pcb); + auth |= PAP_PEER; + } else +#endif /* PAP_SUPPORT */ + {} +#endif /* PPP_SERVER */ + +#if EAP_SUPPORT + if (ho->neg_eap) { + eap_authwithpeer(pcb, pcb->settings.user); + auth |= EAP_WITHPEER; + } else +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT + if (ho->neg_chap) { + chap_auth_with_peer(pcb, pcb->settings.user, CHAP_DIGEST(ho->chap_mdtype)); + auth |= CHAP_WITHPEER; + } else +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + if (ho->neg_upap) { + upap_authwithpeer(pcb, pcb->settings.user, pcb->settings.passwd); + auth |= PAP_WITHPEER; + } else +#endif /* PAP_SUPPORT */ + {} + + pcb->auth_pending = auth; + pcb->auth_done = 0; + + if (!auth) +#endif /* PPP_AUTH_SUPPORT */ + network_phase(pcb); +} + +/* + * Proceed to the network phase. + */ +static void network_phase(ppp_pcb *pcb) { +#if CBCP_SUPPORT + ppp_pcb *pcb = &ppp_pcb_list[unit]; +#endif +#if 0 /* UNUSED */ + lcp_options *go = &lcp_gotoptions[unit]; +#endif /* UNUSED */ + +#if 0 /* UNUSED */ + /* Log calling number. */ + if (*remote_number) + ppp_notice("peer from calling number %q authorized", remote_number); +#endif /* UNUSED */ + +#if PPP_NOTIFY + /* + * If the peer had to authenticate, notify it now. + */ + if (0 +#if CHAP_SUPPORT + || go->neg_chap +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + || go->neg_upap +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + || go->neg_eap +#endif /* EAP_SUPPORT */ + ) { + notify(auth_up_notifier, 0); + } +#endif /* PPP_NOTIFY */ + +#if CBCP_SUPPORT + /* + * If we negotiated callback, do it now. + */ + if (go->neg_cbcp) { + new_phase(pcb, PPP_PHASE_CALLBACK); + (*cbcp_protent.open)(pcb); + return; + } +#endif + +#if PPP_OPTIONS + /* + * Process extra options from the secrets file + */ + if (extra_options) { + options_from_list(extra_options, 1); + free_wordlist(extra_options); + extra_options = 0; + } +#endif /* PPP_OPTIONS */ + start_networks(pcb); +} + +void start_networks(ppp_pcb *pcb) { +#if CCP_SUPPORT || ECP_SUPPORT + int i; + const struct protent *protp; +#endif /* CCP_SUPPORT || ECP_SUPPORT */ + + new_phase(pcb, PPP_PHASE_NETWORK); + +#ifdef HAVE_MULTILINK + if (multilink) { + if (mp_join_bundle()) { + if (multilink_join_hook) + (*multilink_join_hook)(); + if (updetach && !nodetach) + detach(); + return; + } + } +#endif /* HAVE_MULTILINK */ + +#ifdef PPP_FILTER + if (!demand) + set_filters(&pass_filter, &active_filter); +#endif +#if CCP_SUPPORT || ECP_SUPPORT + /* Start CCP and ECP */ + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if ( + (0 +#if ECP_SUPPORT + || protp->protocol == PPP_ECP +#endif /* ECP_SUPPORT */ +#if CCP_SUPPORT + || protp->protocol == PPP_CCP +#endif /* CCP_SUPPORT */ + ) + && protp->open != NULL) + (*protp->open)(pcb); +#endif /* CCP_SUPPORT || ECP_SUPPORT */ + + /* + * Bring up other network protocols iff encryption is not required. + */ + if (1 +#if ECP_SUPPORT + && !ecp_gotoptions[unit].required +#endif /* ECP_SUPPORT */ +#if MPPE_SUPPORT + && !pcb->ccp_gotoptions.mppe +#endif /* MPPE_SUPPORT */ + ) + continue_networks(pcb); +} + +void continue_networks(ppp_pcb *pcb) { + int i; + const struct protent *protp; + + /* + * Start the "real" network protocols. + */ + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (protp->protocol < 0xC000 +#if CCP_SUPPORT + && protp->protocol != PPP_CCP +#endif /* CCP_SUPPORT */ +#if ECP_SUPPORT + && protp->protocol != PPP_ECP +#endif /* ECP_SUPPORT */ + && protp->open != NULL) { + (*protp->open)(pcb); + ++pcb->num_np_open; + } + + if (pcb->num_np_open == 0) + /* nothing to do */ + lcp_close(pcb, "No network protocols running"); +} + +#if PPP_AUTH_SUPPORT +#if PPP_SERVER +/* + * auth_check_passwd - Check the user name and passwd against configuration. + * + * returns: + * 0: Authentication failed. + * 1: Authentication succeeded. + * In either case, msg points to an appropriate message and msglen to the message len. + */ +int auth_check_passwd(ppp_pcb *pcb, char *auser, int userlen, char *apasswd, int passwdlen, const char **msg, int *msglen) { + int secretuserlen; + int secretpasswdlen; + + if (pcb->settings.user && pcb->settings.passwd) { + secretuserlen = (int)strlen(pcb->settings.user); + secretpasswdlen = (int)strlen(pcb->settings.passwd); + if (secretuserlen == userlen + && secretpasswdlen == passwdlen + && !memcmp(auser, pcb->settings.user, userlen) + && !memcmp(apasswd, pcb->settings.passwd, passwdlen) ) { + *msg = "Login ok"; + *msglen = sizeof("Login ok")-1; + return 1; + } + } + + *msg = "Login incorrect"; + *msglen = sizeof("Login incorrect")-1; + return 0; +} + +/* + * The peer has failed to authenticate himself using `protocol'. + */ +void auth_peer_fail(ppp_pcb *pcb, int protocol) { + LWIP_UNUSED_ARG(protocol); + /* + * Authentication failure: take the link down + */ +#if 0 /* UNUSED */ + status = EXIT_PEER_AUTH_FAILED; +#endif /* UNUSED */ + pcb->err_code = PPPERR_AUTHFAIL; + lcp_close(pcb, "Authentication failed"); +} + +/* + * The peer has been successfully authenticated using `protocol'. + */ +void auth_peer_success(ppp_pcb *pcb, int protocol, int prot_flavor, const char *name, int namelen) { + int bit; +#ifndef HAVE_MULTILINK + LWIP_UNUSED_ARG(name); + LWIP_UNUSED_ARG(namelen); +#endif /* HAVE_MULTILINK */ + + switch (protocol) { +#if CHAP_SUPPORT + case PPP_CHAP: + bit = CHAP_PEER; + switch (prot_flavor) { + case CHAP_MD5: + bit |= CHAP_MD5_PEER; + break; +#if MSCHAP_SUPPORT + case CHAP_MICROSOFT: + bit |= CHAP_MS_PEER; + break; + case CHAP_MICROSOFT_V2: + bit |= CHAP_MS2_PEER; + break; +#endif /* MSCHAP_SUPPORT */ + default: + break; + } + break; +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + case PPP_PAP: + bit = PAP_PEER; + break; +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + case PPP_EAP: + bit = EAP_PEER; + break; +#endif /* EAP_SUPPORT */ + default: + ppp_warn("auth_peer_success: unknown protocol %x", protocol); + return; + } + +#ifdef HAVE_MULTILINK + /* + * Save the authenticated name of the peer for later. + */ + if (namelen > (int)sizeof(pcb->peer_authname) - 1) + namelen = (int)sizeof(pcb->peer_authname) - 1; + MEMCPY(pcb->peer_authname, name, namelen); + pcb->peer_authname[namelen] = 0; +#endif /* HAVE_MULTILINK */ +#if 0 /* UNUSED */ + script_setenv("PEERNAME", , 0); +#endif /* UNUSED */ + + /* Save the authentication method for later. */ + pcb->auth_done |= bit; + + /* + * If there is no more authentication still to be done, + * proceed to the network (or callback) phase. + */ + if ((pcb->auth_pending &= ~bit) == 0) + network_phase(pcb); +} +#endif /* PPP_SERVER */ + +/* + * We have failed to authenticate ourselves to the peer using `protocol'. + */ +void auth_withpeer_fail(ppp_pcb *pcb, int protocol) { + LWIP_UNUSED_ARG(protocol); + /* + * We've failed to authenticate ourselves to our peer. + * + * Some servers keep sending CHAP challenges, but there + * is no point in persisting without any way to get updated + * authentication secrets. + * + * He'll probably take the link down, and there's not much + * we can do except wait for that. + */ + pcb->err_code = PPPERR_AUTHFAIL; + lcp_close(pcb, "Failed to authenticate ourselves to peer"); +} + +/* + * We have successfully authenticated ourselves with the peer using `protocol'. + */ +void auth_withpeer_success(ppp_pcb *pcb, int protocol, int prot_flavor) { + int bit; + const char *prot = ""; + + switch (protocol) { +#if CHAP_SUPPORT + case PPP_CHAP: + bit = CHAP_WITHPEER; + prot = "CHAP"; + switch (prot_flavor) { + case CHAP_MD5: + bit |= CHAP_MD5_WITHPEER; + break; +#if MSCHAP_SUPPORT + case CHAP_MICROSOFT: + bit |= CHAP_MS_WITHPEER; + break; + case CHAP_MICROSOFT_V2: + bit |= CHAP_MS2_WITHPEER; + break; +#endif /* MSCHAP_SUPPORT */ + default: + break; + } + break; +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + case PPP_PAP: + bit = PAP_WITHPEER; + prot = "PAP"; + break; +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + case PPP_EAP: + bit = EAP_WITHPEER; + prot = "EAP"; + break; +#endif /* EAP_SUPPORT */ + default: + ppp_warn("auth_withpeer_success: unknown protocol %x", protocol); + bit = 0; + /* no break */ + } + + ppp_notice("%s authentication succeeded", prot); + + /* Save the authentication method for later. */ + pcb->auth_done |= bit; + + /* + * If there is no more authentication still being done, + * proceed to the network (or callback) phase. + */ + if ((pcb->auth_pending &= ~bit) == 0) + network_phase(pcb); +} +#endif /* PPP_AUTH_SUPPORT */ + + +/* + * np_up - a network protocol has come up. + */ +void np_up(ppp_pcb *pcb, int proto) { +#if PPP_IDLETIMELIMIT + int tlim; +#endif /* PPP_IDLETIMELIMIT */ + LWIP_UNUSED_ARG(proto); + + if (pcb->num_np_up == 0) { + /* + * At this point we consider that the link has come up successfully. + */ + new_phase(pcb, PPP_PHASE_RUNNING); + +#if PPP_IDLETIMELIMIT +#if 0 /* UNUSED */ + if (idle_time_hook != 0) + tlim = (*idle_time_hook)(NULL); + else +#endif /* UNUSED */ + tlim = pcb->settings.idle_time_limit; + if (tlim > 0) + TIMEOUT(check_idle, (void*)pcb, tlim); +#endif /* PPP_IDLETIMELIMIT */ + +#if PPP_MAXCONNECT + /* + * Set a timeout to close the connection once the maximum + * connect time has expired. + */ + if (pcb->settings.maxconnect > 0) + TIMEOUT(connect_time_expired, (void*)pcb, pcb->settings.maxconnect); +#endif /* PPP_MAXCONNECT */ + +#ifdef MAXOCTETS + if (maxoctets > 0) + TIMEOUT(check_maxoctets, NULL, maxoctets_timeout); +#endif + +#if 0 /* Unused */ + /* + * Detach now, if the updetach option was given. + */ + if (updetach && !nodetach) + detach(); +#endif /* Unused */ + } + ++pcb->num_np_up; +} + +/* + * np_down - a network protocol has gone down. + */ +void np_down(ppp_pcb *pcb, int proto) { + LWIP_UNUSED_ARG(proto); + if (--pcb->num_np_up == 0) { +#if PPP_IDLETIMELIMIT + UNTIMEOUT(check_idle, (void*)pcb); +#endif /* PPP_IDLETIMELIMIT */ +#if PPP_MAXCONNECT + UNTIMEOUT(connect_time_expired, NULL); +#endif /* PPP_MAXCONNECT */ +#ifdef MAXOCTETS + UNTIMEOUT(check_maxoctets, NULL); +#endif + new_phase(pcb, PPP_PHASE_NETWORK); + } +} + +/* + * np_finished - a network protocol has finished using the link. + */ +void np_finished(ppp_pcb *pcb, int proto) { + LWIP_UNUSED_ARG(proto); + if (--pcb->num_np_open <= 0) { + /* no further use for the link: shut up shop. */ + lcp_close(pcb, "No network protocols running"); + } +} + +#ifdef MAXOCTETS +static void +check_maxoctets(arg) + void *arg; +{ +#if PPP_STATS_SUPPORT + unsigned int used; + + update_link_stats(ifunit); + link_stats_valid=0; + + switch(maxoctets_dir) { + case PPP_OCTETS_DIRECTION_IN: + used = link_stats.bytes_in; + break; + case PPP_OCTETS_DIRECTION_OUT: + used = link_stats.bytes_out; + break; + case PPP_OCTETS_DIRECTION_MAXOVERAL: + case PPP_OCTETS_DIRECTION_MAXSESSION: + used = (link_stats.bytes_in > link_stats.bytes_out) ? link_stats.bytes_in : link_stats.bytes_out; + break; + default: + used = link_stats.bytes_in+link_stats.bytes_out; + break; + } + if (used > maxoctets) { + ppp_notice("Traffic limit reached. Limit: %u Used: %u", maxoctets, used); + status = EXIT_TRAFFIC_LIMIT; + lcp_close(pcb, "Traffic limit"); +#if 0 /* UNUSED */ + need_holdoff = 0; +#endif /* UNUSED */ + } else { + TIMEOUT(check_maxoctets, NULL, maxoctets_timeout); + } +#endif /* PPP_STATS_SUPPORT */ +} +#endif /* MAXOCTETS */ + +#if PPP_IDLETIMELIMIT +/* + * check_idle - check whether the link has been idle for long + * enough that we can shut it down. + */ +static void check_idle(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + struct ppp_idle idle; + time_t itime; + int tlim; + + if (!get_idle_time(pcb, &idle)) + return; +#if 0 /* UNUSED */ + if (idle_time_hook != 0) { + tlim = idle_time_hook(&idle); + } else { +#endif /* UNUSED */ + itime = LWIP_MIN(idle.xmit_idle, idle.recv_idle); + tlim = pcb->settings.idle_time_limit - itime; +#if 0 /* UNUSED */ + } +#endif /* UNUSED */ + if (tlim <= 0) { + /* link is idle: shut it down. */ + ppp_notice("Terminating connection due to lack of activity."); + pcb->err_code = PPPERR_IDLETIMEOUT; + lcp_close(pcb, "Link inactive"); +#if 0 /* UNUSED */ + need_holdoff = 0; +#endif /* UNUSED */ + } else { + TIMEOUT(check_idle, (void*)pcb, tlim); + } +} +#endif /* PPP_IDLETIMELIMIT */ + +#if PPP_MAXCONNECT +/* + * connect_time_expired - log a message and close the connection. + */ +static void connect_time_expired(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + ppp_info("Connect time expired"); + pcb->err_code = PPPERR_CONNECTTIME; + lcp_close(pcb, "Connect time expired"); /* Close connection */ +} +#endif /* PPP_MAXCONNECT */ + +#if PPP_OPTIONS +/* + * auth_check_options - called to check authentication options. + */ +void +auth_check_options() +{ + lcp_options *wo = &lcp_wantoptions[0]; + int can_auth; + int lacks_ip; + + /* Default our_name to hostname, and user to our_name */ + if (our_name[0] == 0 || usehostname) + strlcpy(our_name, hostname, sizeof(our_name)); + /* If a blank username was explicitly given as an option, trust + the user and don't use our_name */ + if (ppp_settings.user[0] == 0 && !explicit_user) + strlcpy(ppp_settings.user, our_name, sizeof(ppp_settings.user)); + + /* + * If we have a default route, require the peer to authenticate + * unless the noauth option was given or the real user is root. + */ + if (!auth_required && !allow_any_ip && have_route_to(0) && !privileged) { + auth_required = 1; + default_auth = 1; + } + +#if CHAP_SUPPORT + /* If we selected any CHAP flavors, we should probably negotiate it. :-) */ + if (wo->chap_mdtype) + wo->neg_chap = 1; +#endif /* CHAP_SUPPORT */ + + /* If authentication is required, ask peer for CHAP, PAP, or EAP. */ + if (auth_required) { + allow_any_ip = 0; + if (1 +#if CHAP_SUPPORT + && !wo->neg_chap +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + && !wo->neg_upap +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + && !wo->neg_eap +#endif /* EAP_SUPPORT */ + ) { +#if CHAP_SUPPORT + wo->neg_chap = CHAP_MDTYPE_SUPPORTED != MDTYPE_NONE; + wo->chap_mdtype = CHAP_MDTYPE_SUPPORTED; +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + wo->neg_upap = 1; +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + wo->neg_eap = 1; +#endif /* EAP_SUPPORT */ + } + } else { +#if CHAP_SUPPORT + wo->neg_chap = 0; + wo->chap_mdtype = MDTYPE_NONE; +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + wo->neg_upap = 0; +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + wo->neg_eap = 0; +#endif /* EAP_SUPPORT */ + } + + /* + * Check whether we have appropriate secrets to use + * to authenticate the peer. Note that EAP can authenticate by way + * of a CHAP-like exchanges as well as SRP. + */ + lacks_ip = 0; +#if PAP_SUPPORT + can_auth = wo->neg_upap && (uselogin || have_pap_secret(&lacks_ip)); +#else + can_auth = 0; +#endif /* PAP_SUPPORT */ + if (!can_auth && (0 +#if CHAP_SUPPORT + || wo->neg_chap +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + || wo->neg_eap +#endif /* EAP_SUPPORT */ + )) { +#if CHAP_SUPPORT + can_auth = have_chap_secret((explicit_remote? remote_name: NULL), + our_name, 1, &lacks_ip); +#else + can_auth = 0; +#endif + } + if (!can_auth +#if EAP_SUPPORT + && wo->neg_eap +#endif /* EAP_SUPPORT */ + ) { + can_auth = have_srp_secret((explicit_remote? remote_name: NULL), + our_name, 1, &lacks_ip); + } + + if (auth_required && !can_auth && noauth_addrs == NULL) { + if (default_auth) { + option_error( +"By default the remote system is required to authenticate itself"); + option_error( +"(because this system has a default route to the internet)"); + } else if (explicit_remote) + option_error( +"The remote system (%s) is required to authenticate itself", + remote_name); + else + option_error( +"The remote system is required to authenticate itself"); + option_error( +"but I couldn't find any suitable secret (password) for it to use to do so."); + if (lacks_ip) + option_error( +"(None of the available passwords would let it use an IP address.)"); + + exit(1); + } + + /* + * Early check for remote number authorization. + */ + if (!auth_number()) { + ppp_warn("calling number %q is not authorized", remote_number); + exit(EXIT_CNID_AUTH_FAILED); + } +} +#endif /* PPP_OPTIONS */ + +#if 0 /* UNUSED */ +/* + * auth_reset - called when LCP is starting negotiations to recheck + * authentication options, i.e. whether we have appropriate secrets + * to use for authenticating ourselves and/or the peer. + */ +void +auth_reset(unit) + int unit; +{ + lcp_options *go = &lcp_gotoptions[unit]; + lcp_options *ao = &lcp_allowoptions[unit]; + int hadchap; + + hadchap = -1; + ao->neg_upap = !refuse_pap && (passwd[0] != 0 || get_pap_passwd(NULL)); + ao->neg_chap = (!refuse_chap || !refuse_mschap || !refuse_mschap_v2) + && (passwd[0] != 0 || + (hadchap = have_chap_secret(user, (explicit_remote? remote_name: + NULL), 0, NULL))); + ao->neg_eap = !refuse_eap && ( + passwd[0] != 0 || + (hadchap == 1 || (hadchap == -1 && have_chap_secret(user, + (explicit_remote? remote_name: NULL), 0, NULL))) || + have_srp_secret(user, (explicit_remote? remote_name: NULL), 0, NULL)); + + hadchap = -1; + if (go->neg_upap && !uselogin && !have_pap_secret(NULL)) + go->neg_upap = 0; + if (go->neg_chap) { + if (!(hadchap = have_chap_secret((explicit_remote? remote_name: NULL), + our_name, 1, NULL))) + go->neg_chap = 0; + } + if (go->neg_eap && + (hadchap == 0 || (hadchap == -1 && + !have_chap_secret((explicit_remote? remote_name: NULL), our_name, + 1, NULL))) && + !have_srp_secret((explicit_remote? remote_name: NULL), our_name, 1, + NULL)) + go->neg_eap = 0; +} + +/* + * check_passwd - Check the user name and passwd against the PAP secrets + * file. If requested, also check against the system password database, + * and login the user if OK. + * + * returns: + * UPAP_AUTHNAK: Authentication failed. + * UPAP_AUTHACK: Authentication succeeded. + * In either case, msg points to an appropriate message. + */ +int +check_passwd(unit, auser, userlen, apasswd, passwdlen, msg) + int unit; + char *auser; + int userlen; + char *apasswd; + int passwdlen; + char **msg; +{ + return UPAP_AUTHNAK; + int ret; + char *filename; + FILE *f; + struct wordlist *addrs = NULL, *opts = NULL; + char passwd[256], user[256]; + char secret[MAXWORDLEN]; + static int attempts = 0; + + /* + * Make copies of apasswd and auser, then null-terminate them. + * If there are unprintable characters in the password, make + * them visible. + */ + slprintf(ppp_settings.passwd, sizeof(ppp_settings.passwd), "%.*v", passwdlen, apasswd); + slprintf(ppp_settings.user, sizeof(ppp_settings.user), "%.*v", userlen, auser); + *msg = ""; + + /* + * Check if a plugin wants to handle this. + */ + if (pap_auth_hook) { + ret = (*pap_auth_hook)(ppp_settings.user, ppp_settings.passwd, msg, &addrs, &opts); + if (ret >= 0) { + /* note: set_allowed_addrs() saves opts (but not addrs): + don't free it! */ + if (ret) + set_allowed_addrs(unit, addrs, opts); + else if (opts != 0) + free_wordlist(opts); + if (addrs != 0) + free_wordlist(addrs); + BZERO(ppp_settings.passwd, sizeof(ppp_settings.passwd)); + return ret? UPAP_AUTHACK: UPAP_AUTHNAK; + } + } + + /* + * Open the file of pap secrets and scan for a suitable secret + * for authenticating this user. + */ + filename = _PATH_UPAPFILE; + addrs = opts = NULL; + ret = UPAP_AUTHNAK; + f = fopen(filename, "r"); + if (f == NULL) { + ppp_error("Can't open PAP password file %s: %m", filename); + + } else { + check_access(f, filename); + if (scan_authfile(f, ppp_settings.user, our_name, secret, &addrs, &opts, filename, 0) < 0) { + ppp_warn("no PAP secret found for %s", user); + } else { + /* + * If the secret is "@login", it means to check + * the password against the login database. + */ + int login_secret = strcmp(secret, "@login") == 0; + ret = UPAP_AUTHACK; + if (uselogin || login_secret) { + /* login option or secret is @login */ + if (session_full(ppp_settings.user, ppp_settings.passwd, devnam, msg) == 0) { + ret = UPAP_AUTHNAK; + } + } else if (session_mgmt) { + if (session_check(ppp_settings.user, NULL, devnam, NULL) == 0) { + ppp_warn("Peer %q failed PAP Session verification", user); + ret = UPAP_AUTHNAK; + } + } + if (secret[0] != 0 && !login_secret) { + /* password given in pap-secrets - must match */ + if ((cryptpap || strcmp(ppp_settings.passwd, secret) != 0) + && strcmp(crypt(ppp_settings.passwd, secret), secret) != 0) + ret = UPAP_AUTHNAK; + } + } + fclose(f); + } + + if (ret == UPAP_AUTHNAK) { + if (**msg == 0) + *msg = "Login incorrect"; + /* + * XXX can we ever get here more than once?? + * Frustrate passwd stealer programs. + * Allow 10 tries, but start backing off after 3 (stolen from login). + * On 10'th, drop the connection. + */ + if (attempts++ >= 10) { + ppp_warn("%d LOGIN FAILURES ON %s, %s", attempts, devnam, user); + lcp_close(pcb, "login failed"); + } + if (attempts > 3) + sleep((u_int) (attempts - 3) * 5); + if (opts != NULL) + free_wordlist(opts); + + } else { + attempts = 0; /* Reset count */ + if (**msg == 0) + *msg = "Login ok"; + set_allowed_addrs(unit, addrs, opts); + } + + if (addrs != NULL) + free_wordlist(addrs); + BZERO(ppp_settings.passwd, sizeof(ppp_settings.passwd)); + BZERO(secret, sizeof(secret)); + + return ret; +} + +/* + * null_login - Check if a username of "" and a password of "" are + * acceptable, and iff so, set the list of acceptable IP addresses + * and return 1. + */ +static int +null_login(unit) + int unit; +{ + char *filename; + FILE *f; + int i, ret; + struct wordlist *addrs, *opts; + char secret[MAXWORDLEN]; + + /* + * Check if a plugin wants to handle this. + */ + ret = -1; + if (null_auth_hook) + ret = (*null_auth_hook)(&addrs, &opts); + + /* + * Open the file of pap secrets and scan for a suitable secret. + */ + if (ret <= 0) { + filename = _PATH_UPAPFILE; + addrs = NULL; + f = fopen(filename, "r"); + if (f == NULL) + return 0; + check_access(f, filename); + + i = scan_authfile(f, "", our_name, secret, &addrs, &opts, filename, 0); + ret = i >= 0 && secret[0] == 0; + BZERO(secret, sizeof(secret)); + fclose(f); + } + + if (ret) + set_allowed_addrs(unit, addrs, opts); + else if (opts != 0) + free_wordlist(opts); + if (addrs != 0) + free_wordlist(addrs); + + return ret; +} + +/* + * get_pap_passwd - get a password for authenticating ourselves with + * our peer using PAP. Returns 1 on success, 0 if no suitable password + * could be found. + * Assumes passwd points to MAXSECRETLEN bytes of space (if non-null). + */ +static int +get_pap_passwd(passwd) + char *passwd; +{ + char *filename; + FILE *f; + int ret; + char secret[MAXWORDLEN]; + + /* + * Check whether a plugin wants to supply this. + */ + if (pap_passwd_hook) { + ret = (*pap_passwd_hook)(ppp_settings,user, ppp_settings.passwd); + if (ret >= 0) + return ret; + } + + filename = _PATH_UPAPFILE; + f = fopen(filename, "r"); + if (f == NULL) + return 0; + check_access(f, filename); + ret = scan_authfile(f, user, + (remote_name[0]? remote_name: NULL), + secret, NULL, NULL, filename, 0); + fclose(f); + if (ret < 0) + return 0; + if (passwd != NULL) + strlcpy(passwd, secret, MAXSECRETLEN); + BZERO(secret, sizeof(secret)); + return 1; +} + +/* + * have_pap_secret - check whether we have a PAP file with any + * secrets that we could possibly use for authenticating the peer. + */ +static int +have_pap_secret(lacks_ipp) + int *lacks_ipp; +{ + FILE *f; + int ret; + char *filename; + struct wordlist *addrs; + + /* let the plugin decide, if there is one */ + if (pap_check_hook) { + ret = (*pap_check_hook)(); + if (ret >= 0) + return ret; + } + + filename = _PATH_UPAPFILE; + f = fopen(filename, "r"); + if (f == NULL) + return 0; + + ret = scan_authfile(f, (explicit_remote? remote_name: NULL), our_name, + NULL, &addrs, NULL, filename, 0); + fclose(f); + if (ret >= 0 && !some_ip_ok(addrs)) { + if (lacks_ipp != 0) + *lacks_ipp = 1; + ret = -1; + } + if (addrs != 0) + free_wordlist(addrs); + + return ret >= 0; +} + +/* + * have_chap_secret - check whether we have a CHAP file with a + * secret that we could possibly use for authenticating `client' + * on `server'. Either can be the null string, meaning we don't + * know the identity yet. + */ +static int +have_chap_secret(client, server, need_ip, lacks_ipp) + char *client; + char *server; + int need_ip; + int *lacks_ipp; +{ + FILE *f; + int ret; + char *filename; + struct wordlist *addrs; + + if (chap_check_hook) { + ret = (*chap_check_hook)(); + if (ret >= 0) { + return ret; + } + } + + filename = _PATH_CHAPFILE; + f = fopen(filename, "r"); + if (f == NULL) + return 0; + + if (client != NULL && client[0] == 0) + client = NULL; + else if (server != NULL && server[0] == 0) + server = NULL; + + ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0); + fclose(f); + if (ret >= 0 && need_ip && !some_ip_ok(addrs)) { + if (lacks_ipp != 0) + *lacks_ipp = 1; + ret = -1; + } + if (addrs != 0) + free_wordlist(addrs); + + return ret >= 0; +} + +/* + * have_srp_secret - check whether we have a SRP file with a + * secret that we could possibly use for authenticating `client' + * on `server'. Either can be the null string, meaning we don't + * know the identity yet. + */ +static int +have_srp_secret(client, server, need_ip, lacks_ipp) + char *client; + char *server; + int need_ip; + int *lacks_ipp; +{ + FILE *f; + int ret; + char *filename; + struct wordlist *addrs; + + filename = _PATH_SRPFILE; + f = fopen(filename, "r"); + if (f == NULL) + return 0; + + if (client != NULL && client[0] == 0) + client = NULL; + else if (server != NULL && server[0] == 0) + server = NULL; + + ret = scan_authfile(f, client, server, NULL, &addrs, NULL, filename, 0); + fclose(f); + if (ret >= 0 && need_ip && !some_ip_ok(addrs)) { + if (lacks_ipp != 0) + *lacks_ipp = 1; + ret = -1; + } + if (addrs != 0) + free_wordlist(addrs); + + return ret >= 0; +} +#endif /* UNUSED */ + +#if PPP_AUTH_SUPPORT +/* + * get_secret - open the CHAP secret file and return the secret + * for authenticating the given client on the given server. + * (We could be either client or server). + */ +int get_secret(ppp_pcb *pcb, const char *client, const char *server, char *secret, int *secret_len, int am_server) { + int len; + LWIP_UNUSED_ARG(server); + LWIP_UNUSED_ARG(am_server); + + if (!client || !client[0] || !pcb->settings.user || !pcb->settings.passwd || strcmp(client, pcb->settings.user)) { + return 0; + } + + len = (int)strlen(pcb->settings.passwd); + if (len > MAXSECRETLEN) { + ppp_error("Secret for %s on %s is too long", client, server); + len = MAXSECRETLEN; + } + + MEMCPY(secret, pcb->settings.passwd, len); + *secret_len = len; + return 1; + +#if 0 /* UNUSED */ + FILE *f; + int ret, len; + char *filename; + struct wordlist *addrs, *opts; + char secbuf[MAXWORDLEN]; + struct wordlist *addrs; + addrs = NULL; + + if (!am_server && ppp_settings.passwd[0] != 0) { + strlcpy(secbuf, ppp_settings.passwd, sizeof(secbuf)); + } else if (!am_server && chap_passwd_hook) { + if ( (*chap_passwd_hook)(client, secbuf) < 0) { + ppp_error("Unable to obtain CHAP password for %s on %s from plugin", + client, server); + return 0; + } + } else { + filename = _PATH_CHAPFILE; + addrs = NULL; + secbuf[0] = 0; + + f = fopen(filename, "r"); + if (f == NULL) { + ppp_error("Can't open chap secret file %s: %m", filename); + return 0; + } + check_access(f, filename); + + ret = scan_authfile(f, client, server, secbuf, &addrs, &opts, filename, 0); + fclose(f); + if (ret < 0) + return 0; + + if (am_server) + set_allowed_addrs(unit, addrs, opts); + else if (opts != 0) + free_wordlist(opts); + if (addrs != 0) + free_wordlist(addrs); + } + + len = strlen(secbuf); + if (len > MAXSECRETLEN) { + ppp_error("Secret for %s on %s is too long", client, server); + len = MAXSECRETLEN; + } + MEMCPY(secret, secbuf, len); + BZERO(secbuf, sizeof(secbuf)); + *secret_len = len; + + return 1; +#endif /* UNUSED */ +} +#endif /* PPP_AUTH_SUPPORT */ + + +#if 0 /* UNUSED */ +/* + * get_srp_secret - open the SRP secret file and return the secret + * for authenticating the given client on the given server. + * (We could be either client or server). + */ +int +get_srp_secret(unit, client, server, secret, am_server) + int unit; + char *client; + char *server; + char *secret; + int am_server; +{ + FILE *fp; + int ret; + char *filename; + struct wordlist *addrs, *opts; + + if (!am_server && ppp_settings.passwd[0] != '\0') { + strlcpy(secret, ppp_settings.passwd, MAXWORDLEN); + } else { + filename = _PATH_SRPFILE; + addrs = NULL; + + fp = fopen(filename, "r"); + if (fp == NULL) { + ppp_error("Can't open srp secret file %s: %m", filename); + return 0; + } + check_access(fp, filename); + + secret[0] = '\0'; + ret = scan_authfile(fp, client, server, secret, &addrs, &opts, + filename, am_server); + fclose(fp); + if (ret < 0) + return 0; + + if (am_server) + set_allowed_addrs(unit, addrs, opts); + else if (opts != NULL) + free_wordlist(opts); + if (addrs != NULL) + free_wordlist(addrs); + } + + return 1; +} + +/* + * set_allowed_addrs() - set the list of allowed addresses. + * Also looks for `--' indicating options to apply for this peer + * and leaves the following words in extra_options. + */ +static void +set_allowed_addrs(unit, addrs, opts) + int unit; + struct wordlist *addrs; + struct wordlist *opts; +{ + int n; + struct wordlist *ap, **plink; + struct permitted_ip *ip; + char *ptr_word, *ptr_mask; + struct hostent *hp; + struct netent *np; + u32_t a, mask, ah, offset; + struct ipcp_options *wo = &ipcp_wantoptions[unit]; + u32_t suggested_ip = 0; + + if (addresses[unit] != NULL) + free(addresses[unit]); + addresses[unit] = NULL; + if (extra_options != NULL) + free_wordlist(extra_options); + extra_options = opts; + + /* + * Count the number of IP addresses given. + */ + n = wordlist_count(addrs) + wordlist_count(noauth_addrs); + if (n == 0) + return; + ip = (struct permitted_ip *) malloc((n + 1) * sizeof(struct permitted_ip)); + if (ip == 0) + return; + + /* temporarily append the noauth_addrs list to addrs */ + for (plink = &addrs; *plink != NULL; plink = &(*plink)->next) + ; + *plink = noauth_addrs; + + n = 0; + for (ap = addrs; ap != NULL; ap = ap->next) { + /* "-" means no addresses authorized, "*" means any address allowed */ + ptr_word = ap->word; + if (strcmp(ptr_word, "-") == 0) + break; + if (strcmp(ptr_word, "*") == 0) { + ip[n].permit = 1; + ip[n].base = ip[n].mask = 0; + ++n; + break; + } + + ip[n].permit = 1; + if (*ptr_word == '!') { + ip[n].permit = 0; + ++ptr_word; + } + + mask = ~ (u32_t) 0; + offset = 0; + ptr_mask = strchr (ptr_word, '/'); + if (ptr_mask != NULL) { + int bit_count; + char *endp; + + bit_count = (int) strtol (ptr_mask+1, &endp, 10); + if (bit_count <= 0 || bit_count > 32) { + ppp_warn("invalid address length %v in auth. address list", + ptr_mask+1); + continue; + } + bit_count = 32 - bit_count; /* # bits in host part */ + if (*endp == '+') { + offset = ifunit + 1; + ++endp; + } + if (*endp != 0) { + ppp_warn("invalid address length syntax: %v", ptr_mask+1); + continue; + } + *ptr_mask = '\0'; + mask <<= bit_count; + } + + hp = gethostbyname(ptr_word); + if (hp != NULL && hp->h_addrtype == AF_INET) { + a = *(u32_t *)hp->h_addr; + } else { + np = getnetbyname (ptr_word); + if (np != NULL && np->n_addrtype == AF_INET) { + a = lwip_htonl ((u32_t)np->n_net); + if (ptr_mask == NULL) { + /* calculate appropriate mask for net */ + ah = lwip_ntohl(a); + if (IN_CLASSA(ah)) + mask = IN_CLASSA_NET; + else if (IN_CLASSB(ah)) + mask = IN_CLASSB_NET; + else if (IN_CLASSC(ah)) + mask = IN_CLASSC_NET; + } + } else { + a = inet_addr (ptr_word); + } + } + + if (ptr_mask != NULL) + *ptr_mask = '/'; + + if (a == (u32_t)-1L) { + ppp_warn("unknown host %s in auth. address list", ap->word); + continue; + } + if (offset != 0) { + if (offset >= ~mask) { + ppp_warn("interface unit %d too large for subnet %v", + ifunit, ptr_word); + continue; + } + a = lwip_htonl((lwip_ntohl(a) & mask) + offset); + mask = ~(u32_t)0; + } + ip[n].mask = lwip_htonl(mask); + ip[n].base = a & ip[n].mask; + ++n; + if (~mask == 0 && suggested_ip == 0) + suggested_ip = a; + } + *plink = NULL; + + ip[n].permit = 0; /* make the last entry forbid all addresses */ + ip[n].base = 0; /* to terminate the list */ + ip[n].mask = 0; + + addresses[unit] = ip; + + /* + * If the address given for the peer isn't authorized, or if + * the user hasn't given one, AND there is an authorized address + * which is a single host, then use that if we find one. + */ + if (suggested_ip != 0 + && (wo->hisaddr == 0 || !auth_ip_addr(unit, wo->hisaddr))) { + wo->hisaddr = suggested_ip; + /* + * Do we insist on this address? No, if there are other + * addresses authorized than the suggested one. + */ + if (n > 1) + wo->accept_remote = 1; + } +} + +/* + * auth_ip_addr - check whether the peer is authorized to use + * a given IP address. Returns 1 if authorized, 0 otherwise. + */ +int +auth_ip_addr(unit, addr) + int unit; + u32_t addr; +{ + int ok; + + /* don't allow loopback or multicast address */ + if (bad_ip_adrs(addr)) + return 0; + + if (allowed_address_hook) { + ok = allowed_address_hook(addr); + if (ok >= 0) return ok; + } + + if (addresses[unit] != NULL) { + ok = ip_addr_check(addr, addresses[unit]); + if (ok >= 0) + return ok; + } + + if (auth_required) + return 0; /* no addresses authorized */ + return allow_any_ip || privileged || !have_route_to(addr); +} + +static int +ip_addr_check(addr, addrs) + u32_t addr; + struct permitted_ip *addrs; +{ + for (; ; ++addrs) + if ((addr & addrs->mask) == addrs->base) + return addrs->permit; +} + +/* + * bad_ip_adrs - return 1 if the IP address is one we don't want + * to use, such as an address in the loopback net or a multicast address. + * addr is in network byte order. + */ +int +bad_ip_adrs(addr) + u32_t addr; +{ + addr = lwip_ntohl(addr); + return (addr >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET + || IN_MULTICAST(addr) || IN_BADCLASS(addr); +} + +/* + * some_ip_ok - check a wordlist to see if it authorizes any + * IP address(es). + */ +static int +some_ip_ok(addrs) + struct wordlist *addrs; +{ + for (; addrs != 0; addrs = addrs->next) { + if (addrs->word[0] == '-') + break; + if (addrs->word[0] != '!') + return 1; /* some IP address is allowed */ + } + return 0; +} + +/* + * auth_number - check whether the remote number is allowed to connect. + * Returns 1 if authorized, 0 otherwise. + */ +int +auth_number() +{ + struct wordlist *wp = permitted_numbers; + int l; + + /* Allow all if no authorization list. */ + if (!wp) + return 1; + + /* Allow if we have a match in the authorization list. */ + while (wp) { + /* trailing '*' wildcard */ + l = strlen(wp->word); + if ((wp->word)[l - 1] == '*') + l--; + if (!strncasecmp(wp->word, remote_number, l)) + return 1; + wp = wp->next; + } + + return 0; +} + +/* + * check_access - complain if a secret file has too-liberal permissions. + */ +static void +check_access(f, filename) + FILE *f; + char *filename; +{ + struct stat sbuf; + + if (fstat(fileno(f), &sbuf) < 0) { + ppp_warn("cannot stat secret file %s: %m", filename); + } else if ((sbuf.st_mode & (S_IRWXG | S_IRWXO)) != 0) { + ppp_warn("Warning - secret file %s has world and/or group access", + filename); + } +} + +/* + * scan_authfile - Scan an authorization file for a secret suitable + * for authenticating `client' on `server'. The return value is -1 + * if no secret is found, otherwise >= 0. The return value has + * NONWILD_CLIENT set if the secret didn't have "*" for the client, and + * NONWILD_SERVER set if the secret didn't have "*" for the server. + * Any following words on the line up to a "--" (i.e. address authorization + * info) are placed in a wordlist and returned in *addrs. Any + * following words (extra options) are placed in a wordlist and + * returned in *opts. + * We assume secret is NULL or points to MAXWORDLEN bytes of space. + * Flags are non-zero if we need two colons in the secret in order to + * match. + */ +static int +scan_authfile(f, client, server, secret, addrs, opts, filename, flags) + FILE *f; + char *client; + char *server; + char *secret; + struct wordlist **addrs; + struct wordlist **opts; + char *filename; + int flags; +{ + int newline, xxx; + int got_flag, best_flag; + FILE *sf; + struct wordlist *ap, *addr_list, *alist, **app; + char word[MAXWORDLEN]; + char atfile[MAXWORDLEN]; + char lsecret[MAXWORDLEN]; + char *cp; + + if (addrs != NULL) + *addrs = NULL; + if (opts != NULL) + *opts = NULL; + addr_list = NULL; + if (!getword(f, word, &newline, filename)) + return -1; /* file is empty??? */ + newline = 1; + best_flag = -1; + for (;;) { + /* + * Skip until we find a word at the start of a line. + */ + while (!newline && getword(f, word, &newline, filename)) + ; + if (!newline) + break; /* got to end of file */ + + /* + * Got a client - check if it's a match or a wildcard. + */ + got_flag = 0; + if (client != NULL && strcmp(word, client) != 0 && !ISWILD(word)) { + newline = 0; + continue; + } + if (!ISWILD(word)) + got_flag = NONWILD_CLIENT; + + /* + * Now get a server and check if it matches. + */ + if (!getword(f, word, &newline, filename)) + break; + if (newline) + continue; + if (!ISWILD(word)) { + if (server != NULL && strcmp(word, server) != 0) + continue; + got_flag |= NONWILD_SERVER; + } + + /* + * Got some sort of a match - see if it's better than what + * we have already. + */ + if (got_flag <= best_flag) + continue; + + /* + * Get the secret. + */ + if (!getword(f, word, &newline, filename)) + break; + if (newline) + continue; + + /* + * SRP-SHA1 authenticator should never be reading secrets from + * a file. (Authenticatee may, though.) + */ + if (flags && ((cp = strchr(word, ':')) == NULL || + strchr(cp + 1, ':') == NULL)) + continue; + + if (secret != NULL) { + /* + * Special syntax: @/pathname means read secret from file. + */ + if (word[0] == '@' && word[1] == '/') { + strlcpy(atfile, word+1, sizeof(atfile)); + if ((sf = fopen(atfile, "r")) == NULL) { + ppp_warn("can't open indirect secret file %s", atfile); + continue; + } + check_access(sf, atfile); + if (!getword(sf, word, &xxx, atfile)) { + ppp_warn("no secret in indirect secret file %s", atfile); + fclose(sf); + continue; + } + fclose(sf); + } + strlcpy(lsecret, word, sizeof(lsecret)); + } + + /* + * Now read address authorization info and make a wordlist. + */ + app = &alist; + for (;;) { + if (!getword(f, word, &newline, filename) || newline) + break; + ap = (struct wordlist *) + malloc(sizeof(struct wordlist) + strlen(word) + 1); + if (ap == NULL) + novm("authorized addresses"); + ap->word = (char *) (ap + 1); + strcpy(ap->word, word); + *app = ap; + app = &ap->next; + } + *app = NULL; + + /* + * This is the best so far; remember it. + */ + best_flag = got_flag; + if (addr_list) + free_wordlist(addr_list); + addr_list = alist; + if (secret != NULL) + strlcpy(secret, lsecret, MAXWORDLEN); + + if (!newline) + break; + } + + /* scan for a -- word indicating the start of options */ + for (app = &addr_list; (ap = *app) != NULL; app = &ap->next) + if (strcmp(ap->word, "--") == 0) + break; + /* ap = start of options */ + if (ap != NULL) { + ap = ap->next; /* first option */ + free(*app); /* free the "--" word */ + *app = NULL; /* terminate addr list */ + } + if (opts != NULL) + *opts = ap; + else if (ap != NULL) + free_wordlist(ap); + if (addrs != NULL) + *addrs = addr_list; + else if (addr_list != NULL) + free_wordlist(addr_list); + + return best_flag; +} + +/* + * wordlist_count - return the number of items in a wordlist + */ +static int +wordlist_count(wp) + struct wordlist *wp; +{ + int n; + + for (n = 0; wp != NULL; wp = wp->next) + ++n; + return n; +} + +/* + * free_wordlist - release memory allocated for a wordlist. + */ +static void +free_wordlist(wp) + struct wordlist *wp; +{ + struct wordlist *next; + + while (wp != NULL) { + next = wp->next; + free(wp); + wp = next; + } +} +#endif /* UNUSED */ + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ccp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ccp.c index b354a3fe..f8519ebe 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ccp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ccp.c @@ -1,1740 +1,1740 @@ -/* - * ccp.c - PPP Compression Control Protocol. - * - * Copyright (c) 1994-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && CCP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include -#include - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/ccp.h" - -#if MPPE_SUPPORT -#include "netif/ppp/lcp.h" /* lcp_close(), lcp_fsm */ -#include "netif/ppp/mppe.h" /* mppe_init() */ -#endif /* MPPE_SUPPORT */ - -/* - * Unfortunately there is a bug in zlib which means that using a - * size of 8 (window size = 256) for Deflate compression will cause - * buffer overruns and kernel crashes in the deflate module. - * Until this is fixed we only accept sizes in the range 9 .. 15. - * Thanks to James Carlson for pointing this out. - */ -#define DEFLATE_MIN_WORKS 9 - -/* - * Command-line options. - */ -#if PPP_OPTIONS -static int setbsdcomp (char **); -static int setdeflate (char **); -static char bsd_value[8]; -static char deflate_value[8]; - -/* - * Option variables. - */ -#if MPPE_SUPPORT -bool refuse_mppe_stateful = 1; /* Allow stateful mode? */ -#endif /* MPPE_SUPPORT */ - -static option_t ccp_option_list[] = { - { "noccp", o_bool, &ccp_protent.enabled_flag, - "Disable CCP negotiation" }, - { "-ccp", o_bool, &ccp_protent.enabled_flag, - "Disable CCP negotiation", OPT_ALIAS }, - - { "bsdcomp", o_special, (void *)setbsdcomp, - "Request BSD-Compress packet compression", - OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, bsd_value }, - { "nobsdcomp", o_bool, &ccp_wantoptions[0].bsd_compress, - "don't allow BSD-Compress", OPT_PRIOSUB | OPT_A2CLR, - &ccp_allowoptions[0].bsd_compress }, - { "-bsdcomp", o_bool, &ccp_wantoptions[0].bsd_compress, - "don't allow BSD-Compress", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, - &ccp_allowoptions[0].bsd_compress }, - - { "deflate", o_special, (void *)setdeflate, - "request Deflate compression", - OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, deflate_value }, - { "nodeflate", o_bool, &ccp_wantoptions[0].deflate, - "don't allow Deflate compression", OPT_PRIOSUB | OPT_A2CLR, - &ccp_allowoptions[0].deflate }, - { "-deflate", o_bool, &ccp_wantoptions[0].deflate, - "don't allow Deflate compression", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, - &ccp_allowoptions[0].deflate }, - - { "nodeflatedraft", o_bool, &ccp_wantoptions[0].deflate_draft, - "don't use draft deflate #", OPT_A2COPY, - &ccp_allowoptions[0].deflate_draft }, - - { "predictor1", o_bool, &ccp_wantoptions[0].predictor_1, - "request Predictor-1", OPT_PRIO | 1 }, - { "nopredictor1", o_bool, &ccp_wantoptions[0].predictor_1, - "don't allow Predictor-1", OPT_PRIOSUB | OPT_A2CLR, - &ccp_allowoptions[0].predictor_1 }, - { "-predictor1", o_bool, &ccp_wantoptions[0].predictor_1, - "don't allow Predictor-1", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, - &ccp_allowoptions[0].predictor_1 }, - -#if MPPE_SUPPORT - /* MPPE options are symmetrical ... we only set wantoptions here */ - { "require-mppe", o_bool, &ccp_wantoptions[0].mppe, - "require MPPE encryption", - OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 }, - { "+mppe", o_bool, &ccp_wantoptions[0].mppe, - "require MPPE encryption", - OPT_ALIAS | OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 }, - { "nomppe", o_bool, &ccp_wantoptions[0].mppe, - "don't allow MPPE encryption", OPT_PRIO }, - { "-mppe", o_bool, &ccp_wantoptions[0].mppe, - "don't allow MPPE encryption", OPT_ALIAS | OPT_PRIO }, - - /* We use ccp_allowoptions[0].mppe as a junk var ... it is reset later */ - { "require-mppe-40", o_bool, &ccp_allowoptions[0].mppe, - "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40, - &ccp_wantoptions[0].mppe }, - { "+mppe-40", o_bool, &ccp_allowoptions[0].mppe, - "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40, - &ccp_wantoptions[0].mppe }, - { "nomppe-40", o_bool, &ccp_allowoptions[0].mppe, - "don't allow MPPE 40-bit encryption", - OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40, &ccp_wantoptions[0].mppe }, - { "-mppe-40", o_bool, &ccp_allowoptions[0].mppe, - "don't allow MPPE 40-bit encryption", - OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40, - &ccp_wantoptions[0].mppe }, - - { "require-mppe-128", o_bool, &ccp_allowoptions[0].mppe, - "require MPPE 128-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_128, - &ccp_wantoptions[0].mppe }, - { "+mppe-128", o_bool, &ccp_allowoptions[0].mppe, - "require MPPE 128-bit encryption", - OPT_ALIAS | OPT_PRIO | OPT_A2OR | MPPE_OPT_128, - &ccp_wantoptions[0].mppe }, - { "nomppe-128", o_bool, &ccp_allowoptions[0].mppe, - "don't allow MPPE 128-bit encryption", - OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128, &ccp_wantoptions[0].mppe }, - { "-mppe-128", o_bool, &ccp_allowoptions[0].mppe, - "don't allow MPPE 128-bit encryption", - OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128, - &ccp_wantoptions[0].mppe }, - - /* strange one; we always request stateless, but will we allow stateful? */ - { "mppe-stateful", o_bool, &refuse_mppe_stateful, - "allow MPPE stateful mode", OPT_PRIO }, - { "nomppe-stateful", o_bool, &refuse_mppe_stateful, - "disallow MPPE stateful mode", OPT_PRIO | 1 }, -#endif /* MPPE_SUPPORT */ - - { NULL } -}; -#endif /* PPP_OPTIONS */ - -/* - * Protocol entry points from main code. - */ -static void ccp_init(ppp_pcb *pcb); -static void ccp_open(ppp_pcb *pcb); -static void ccp_close(ppp_pcb *pcb, const char *reason); -static void ccp_lowerup(ppp_pcb *pcb); -static void ccp_lowerdown(ppp_pcb *pcb); -static void ccp_input(ppp_pcb *pcb, u_char *pkt, int len); -static void ccp_protrej(ppp_pcb *pcb); -#if PRINTPKT_SUPPORT -static int ccp_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg); -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT -static void ccp_datainput(ppp_pcb *pcb, u_char *pkt, int len); -#endif /* PPP_DATAINPUT */ - -const struct protent ccp_protent = { - PPP_CCP, - ccp_init, - ccp_input, - ccp_protrej, - ccp_lowerup, - ccp_lowerdown, - ccp_open, - ccp_close, -#if PRINTPKT_SUPPORT - ccp_printpkt, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - ccp_datainput, -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "CCP", - "Compressed", -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - ccp_option_list, - NULL, -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - NULL, - NULL -#endif /* DEMAND_SUPPORT */ -}; - -/* - * Callbacks for fsm code. - */ -static void ccp_resetci (fsm *); -static int ccp_cilen (fsm *); -static void ccp_addci (fsm *, u_char *, int *); -static int ccp_ackci (fsm *, u_char *, int); -static int ccp_nakci (fsm *, u_char *, int, int); -static int ccp_rejci (fsm *, u_char *, int); -static int ccp_reqci (fsm *, u_char *, int *, int); -static void ccp_up (fsm *); -static void ccp_down (fsm *); -static int ccp_extcode (fsm *, int, int, u_char *, int); -static void ccp_rack_timeout (void *); -static const char *method_name (ccp_options *, ccp_options *); - -static const fsm_callbacks ccp_callbacks = { - ccp_resetci, - ccp_cilen, - ccp_addci, - ccp_ackci, - ccp_nakci, - ccp_rejci, - ccp_reqci, - ccp_up, - ccp_down, - NULL, - NULL, - NULL, - NULL, - ccp_extcode, - "CCP" -}; - -/* - * Do we want / did we get any compression? - */ -static int ccp_anycompress(ccp_options *opt) { - return (0 -#if DEFLATE_SUPPORT - || (opt)->deflate -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - || (opt)->bsd_compress -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - || (opt)->predictor_1 || (opt)->predictor_2 -#endif /* PREDICTOR_SUPPORT */ -#if MPPE_SUPPORT - || (opt)->mppe -#endif /* MPPE_SUPPORT */ - ); -} - -/* - * Local state (mainly for handling reset-reqs and reset-acks). - */ -#define RACK_PENDING 1 /* waiting for reset-ack */ -#define RREQ_REPEAT 2 /* send another reset-req if no reset-ack */ - -#define RACKTIMEOUT 1 /* second */ - -#if PPP_OPTIONS -/* - * Option parsing - */ -static int -setbsdcomp(argv) - char **argv; -{ - int rbits, abits; - char *str, *endp; - - str = *argv; - abits = rbits = strtol(str, &endp, 0); - if (endp != str && *endp == ',') { - str = endp + 1; - abits = strtol(str, &endp, 0); - } - if (*endp != 0 || endp == str) { - option_error("invalid parameter '%s' for bsdcomp option", *argv); - return 0; - } - if ((rbits != 0 && (rbits < BSD_MIN_BITS || rbits > BSD_MAX_BITS)) - || (abits != 0 && (abits < BSD_MIN_BITS || abits > BSD_MAX_BITS))) { - option_error("bsdcomp option values must be 0 or %d .. %d", - BSD_MIN_BITS, BSD_MAX_BITS); - return 0; - } - if (rbits > 0) { - ccp_wantoptions[0].bsd_compress = 1; - ccp_wantoptions[0].bsd_bits = rbits; - } else - ccp_wantoptions[0].bsd_compress = 0; - if (abits > 0) { - ccp_allowoptions[0].bsd_compress = 1; - ccp_allowoptions[0].bsd_bits = abits; - } else - ccp_allowoptions[0].bsd_compress = 0; - ppp_slprintf(bsd_value, sizeof(bsd_value), - rbits == abits? "%d": "%d,%d", rbits, abits); - - return 1; -} - -static int -setdeflate(argv) - char **argv; -{ - int rbits, abits; - char *str, *endp; - - str = *argv; - abits = rbits = strtol(str, &endp, 0); - if (endp != str && *endp == ',') { - str = endp + 1; - abits = strtol(str, &endp, 0); - } - if (*endp != 0 || endp == str) { - option_error("invalid parameter '%s' for deflate option", *argv); - return 0; - } - if ((rbits != 0 && (rbits < DEFLATE_MIN_SIZE || rbits > DEFLATE_MAX_SIZE)) - || (abits != 0 && (abits < DEFLATE_MIN_SIZE - || abits > DEFLATE_MAX_SIZE))) { - option_error("deflate option values must be 0 or %d .. %d", - DEFLATE_MIN_SIZE, DEFLATE_MAX_SIZE); - return 0; - } - if (rbits == DEFLATE_MIN_SIZE || abits == DEFLATE_MIN_SIZE) { - if (rbits == DEFLATE_MIN_SIZE) - rbits = DEFLATE_MIN_WORKS; - if (abits == DEFLATE_MIN_SIZE) - abits = DEFLATE_MIN_WORKS; - warn("deflate option value of %d changed to %d to avoid zlib bug", - DEFLATE_MIN_SIZE, DEFLATE_MIN_WORKS); - } - if (rbits > 0) { - ccp_wantoptions[0].deflate = 1; - ccp_wantoptions[0].deflate_size = rbits; - } else - ccp_wantoptions[0].deflate = 0; - if (abits > 0) { - ccp_allowoptions[0].deflate = 1; - ccp_allowoptions[0].deflate_size = abits; - } else - ccp_allowoptions[0].deflate = 0; - ppp_slprintf(deflate_value, sizeof(deflate_value), - rbits == abits? "%d": "%d,%d", rbits, abits); - - return 1; -} -#endif /* PPP_OPTIONS */ - -/* - * ccp_init - initialize CCP. - */ -static void ccp_init(ppp_pcb *pcb) { - fsm *f = &pcb->ccp_fsm; - - f->pcb = pcb; - f->protocol = PPP_CCP; - f->callbacks = &ccp_callbacks; - fsm_init(f); - -#if 0 /* Not necessary, everything is cleared in ppp_new() */ - memset(wo, 0, sizeof(*wo)); - memset(go, 0, sizeof(*go)); - memset(ao, 0, sizeof(*ao)); - memset(ho, 0, sizeof(*ho)); -#endif /* 0 */ - -#if DEFLATE_SUPPORT - wo->deflate = 1; - wo->deflate_size = DEFLATE_MAX_SIZE; - wo->deflate_correct = 1; - wo->deflate_draft = 1; - ao->deflate = 1; - ao->deflate_size = DEFLATE_MAX_SIZE; - ao->deflate_correct = 1; - ao->deflate_draft = 1; -#endif /* DEFLATE_SUPPORT */ - -#if BSDCOMPRESS_SUPPORT - wo->bsd_compress = 1; - wo->bsd_bits = BSD_MAX_BITS; - ao->bsd_compress = 1; - ao->bsd_bits = BSD_MAX_BITS; -#endif /* BSDCOMPRESS_SUPPORT */ - -#if PREDICTOR_SUPPORT - ao->predictor_1 = 1; -#endif /* PREDICTOR_SUPPORT */ -} - -/* - * ccp_open - CCP is allowed to come up. - */ -static void ccp_open(ppp_pcb *pcb) { - fsm *f = &pcb->ccp_fsm; - ccp_options *go = &pcb->ccp_gotoptions; - - if (f->state != PPP_FSM_OPENED) - ccp_set(pcb, 1, 0, 0, 0); - - /* - * Find out which compressors the kernel supports before - * deciding whether to open in silent mode. - */ - ccp_resetci(f); - if (!ccp_anycompress(go)) - f->flags |= OPT_SILENT; - - fsm_open(f); -} - -/* - * ccp_close - Terminate CCP. - */ -static void ccp_close(ppp_pcb *pcb, const char *reason) { - fsm *f = &pcb->ccp_fsm; - ccp_set(pcb, 0, 0, 0, 0); - fsm_close(f, reason); -} - -/* - * ccp_lowerup - we may now transmit CCP packets. - */ -static void ccp_lowerup(ppp_pcb *pcb) { - fsm *f = &pcb->ccp_fsm; - fsm_lowerup(f); -} - -/* - * ccp_lowerdown - we may not transmit CCP packets. - */ -static void ccp_lowerdown(ppp_pcb *pcb) { - fsm *f = &pcb->ccp_fsm; - fsm_lowerdown(f); -} - -/* - * ccp_input - process a received CCP packet. - */ -static void ccp_input(ppp_pcb *pcb, u_char *p, int len) { - fsm *f = &pcb->ccp_fsm; - ccp_options *go = &pcb->ccp_gotoptions; - int oldstate; - - /* - * Check for a terminate-request so we can print a message. - */ - oldstate = f->state; - fsm_input(f, p, len); - if (oldstate == PPP_FSM_OPENED && p[0] == TERMREQ && f->state != PPP_FSM_OPENED) { - ppp_notice("Compression disabled by peer."); -#if MPPE_SUPPORT - if (go->mppe) { - ppp_error("MPPE disabled, closing LCP"); - lcp_close(pcb, "MPPE disabled by peer"); - } -#endif /* MPPE_SUPPORT */ - } - - /* - * If we get a terminate-ack and we're not asking for compression, - * close CCP. - */ - if (oldstate == PPP_FSM_REQSENT && p[0] == TERMACK - && !ccp_anycompress(go)) - ccp_close(pcb, "No compression negotiated"); -} - -/* - * Handle a CCP-specific code. - */ -static int ccp_extcode(fsm *f, int code, int id, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - LWIP_UNUSED_ARG(p); - LWIP_UNUSED_ARG(len); - - switch (code) { - case CCP_RESETREQ: - if (f->state != PPP_FSM_OPENED) - break; - ccp_reset_comp(pcb); - /* send a reset-ack, which the transmitter will see and - reset its compression state. */ - fsm_sdata(f, CCP_RESETACK, id, NULL, 0); - break; - - case CCP_RESETACK: - if ((pcb->ccp_localstate & RACK_PENDING) && id == f->reqid) { - pcb->ccp_localstate &= ~(RACK_PENDING | RREQ_REPEAT); - UNTIMEOUT(ccp_rack_timeout, f); - ccp_reset_decomp(pcb); - } - break; - - default: - return 0; - } - - return 1; -} - -/* - * ccp_protrej - peer doesn't talk CCP. - */ -static void ccp_protrej(ppp_pcb *pcb) { - fsm *f = &pcb->ccp_fsm; -#if MPPE_SUPPORT - ccp_options *go = &pcb->ccp_gotoptions; -#endif /* MPPE_SUPPORT */ - - ccp_set(pcb, 0, 0, 0, 0); - fsm_lowerdown(f); - -#if MPPE_SUPPORT - if (go->mppe) { - ppp_error("MPPE required but peer negotiation failed"); - lcp_close(pcb, "MPPE required but peer negotiation failed"); - } -#endif /* MPPE_SUPPORT */ - -} - -/* - * ccp_resetci - initialize at start of negotiation. - */ -static void ccp_resetci(fsm *f) { - ppp_pcb *pcb = f->pcb; - ccp_options *go = &pcb->ccp_gotoptions; - ccp_options *wo = &pcb->ccp_wantoptions; -#if MPPE_SUPPORT - ccp_options *ao = &pcb->ccp_allowoptions; -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT - u_char opt_buf[CCP_MAX_OPTION_LENGTH]; -#endif /* DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT */ -#if DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT - int res; -#endif /* DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT */ - -#if MPPE_SUPPORT - if (pcb->settings.require_mppe) { - wo->mppe = ao->mppe = - (pcb->settings.refuse_mppe_40 ? 0 : MPPE_OPT_40) - | (pcb->settings.refuse_mppe_128 ? 0 : MPPE_OPT_128); - } -#endif /* MPPE_SUPPORT */ - - *go = *wo; - pcb->ccp_all_rejected = 0; - -#if MPPE_SUPPORT - if (go->mppe) { - int auth_mschap_bits = pcb->auth_done; - int numbits; - - /* - * Start with a basic sanity check: mschap[v2] auth must be in - * exactly one direction. RFC 3079 says that the keys are - * 'derived from the credentials of the peer that initiated the call', - * however the PPP protocol doesn't have such a concept, and pppd - * cannot get this info externally. Instead we do the best we can. - * NB: If MPPE is required, all other compression opts are invalid. - * So, we return right away if we can't do it. - */ - - /* Leave only the mschap auth bits set */ - auth_mschap_bits &= (CHAP_MS_WITHPEER | CHAP_MS_PEER | - CHAP_MS2_WITHPEER | CHAP_MS2_PEER); - /* Count the mschap auths */ - auth_mschap_bits >>= CHAP_MS_SHIFT; - numbits = 0; - do { - numbits += auth_mschap_bits & 1; - auth_mschap_bits >>= 1; - } while (auth_mschap_bits); - if (numbits > 1) { - ppp_error("MPPE required, but auth done in both directions."); - lcp_close(pcb, "MPPE required but not available"); - return; - } - if (!numbits) { - ppp_error("MPPE required, but MS-CHAP[v2] auth not performed."); - lcp_close(pcb, "MPPE required but not available"); - return; - } - - /* A plugin (eg radius) may not have obtained key material. */ - if (!pcb->mppe_keys_set) { - ppp_error("MPPE required, but keys are not available. " - "Possible plugin problem?"); - lcp_close(pcb, "MPPE required but not available"); - return; - } - - /* LM auth not supported for MPPE */ - if (pcb->auth_done & (CHAP_MS_WITHPEER | CHAP_MS_PEER)) { - /* This might be noise */ - if (go->mppe & MPPE_OPT_40) { - ppp_notice("Disabling 40-bit MPPE; MS-CHAP LM not supported"); - go->mppe &= ~MPPE_OPT_40; - wo->mppe &= ~MPPE_OPT_40; - } - } - - /* Last check: can we actually negotiate something? */ - if (!(go->mppe & (MPPE_OPT_40 | MPPE_OPT_128))) { - /* Could be misconfig, could be 40-bit disabled above. */ - ppp_error("MPPE required, but both 40-bit and 128-bit disabled."); - lcp_close(pcb, "MPPE required but not available"); - return; - } - - /* sync options */ - ao->mppe = go->mppe; - /* MPPE is not compatible with other compression types */ -#if BSDCOMPRESS_SUPPORT - ao->bsd_compress = go->bsd_compress = 0; -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - ao->predictor_1 = go->predictor_1 = 0; - ao->predictor_2 = go->predictor_2 = 0; -#endif /* PREDICTOR_SUPPORT */ -#if DEFLATE_SUPPORT - ao->deflate = go->deflate = 0; -#endif /* DEFLATE_SUPPORT */ - } -#endif /* MPPE_SUPPORT */ - - /* - * Check whether the kernel knows about the various - * compression methods we might request. - */ -#if BSDCOMPRESS_SUPPORT - /* FIXME: we don't need to test if BSD compress is available - * if BSDCOMPRESS_SUPPORT is set, it is. - */ - if (go->bsd_compress) { - opt_buf[0] = CI_BSD_COMPRESS; - opt_buf[1] = CILEN_BSD_COMPRESS; - for (;;) { - if (go->bsd_bits < BSD_MIN_BITS) { - go->bsd_compress = 0; - break; - } - opt_buf[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits); - res = ccp_test(pcb, opt_buf, CILEN_BSD_COMPRESS, 0); - if (res > 0) { - break; - } else if (res < 0) { - go->bsd_compress = 0; - break; - } - go->bsd_bits--; - } - } -#endif /* BSDCOMPRESS_SUPPORT */ -#if DEFLATE_SUPPORT - /* FIXME: we don't need to test if deflate is available - * if DEFLATE_SUPPORT is set, it is. - */ - if (go->deflate) { - if (go->deflate_correct) { - opt_buf[0] = CI_DEFLATE; - opt_buf[1] = CILEN_DEFLATE; - opt_buf[3] = DEFLATE_CHK_SEQUENCE; - for (;;) { - if (go->deflate_size < DEFLATE_MIN_WORKS) { - go->deflate_correct = 0; - break; - } - opt_buf[2] = DEFLATE_MAKE_OPT(go->deflate_size); - res = ccp_test(pcb, opt_buf, CILEN_DEFLATE, 0); - if (res > 0) { - break; - } else if (res < 0) { - go->deflate_correct = 0; - break; - } - go->deflate_size--; - } - } - if (go->deflate_draft) { - opt_buf[0] = CI_DEFLATE_DRAFT; - opt_buf[1] = CILEN_DEFLATE; - opt_buf[3] = DEFLATE_CHK_SEQUENCE; - for (;;) { - if (go->deflate_size < DEFLATE_MIN_WORKS) { - go->deflate_draft = 0; - break; - } - opt_buf[2] = DEFLATE_MAKE_OPT(go->deflate_size); - res = ccp_test(pcb, opt_buf, CILEN_DEFLATE, 0); - if (res > 0) { - break; - } else if (res < 0) { - go->deflate_draft = 0; - break; - } - go->deflate_size--; - } - } - if (!go->deflate_correct && !go->deflate_draft) - go->deflate = 0; - } -#endif /* DEFLATE_SUPPORT */ -#if PREDICTOR_SUPPORT - /* FIXME: we don't need to test if predictor is available, - * if PREDICTOR_SUPPORT is set, it is. - */ - if (go->predictor_1) { - opt_buf[0] = CI_PREDICTOR_1; - opt_buf[1] = CILEN_PREDICTOR_1; - if (ccp_test(pcb, opt_buf, CILEN_PREDICTOR_1, 0) <= 0) - go->predictor_1 = 0; - } - if (go->predictor_2) { - opt_buf[0] = CI_PREDICTOR_2; - opt_buf[1] = CILEN_PREDICTOR_2; - if (ccp_test(pcb, opt_buf, CILEN_PREDICTOR_2, 0) <= 0) - go->predictor_2 = 0; - } -#endif /* PREDICTOR_SUPPORT */ -} - -/* - * ccp_cilen - Return total length of our configuration info. - */ -static int ccp_cilen(fsm *f) { - ppp_pcb *pcb = f->pcb; - ccp_options *go = &pcb->ccp_gotoptions; - - return 0 -#if BSDCOMPRESS_SUPPORT - + (go->bsd_compress? CILEN_BSD_COMPRESS: 0) -#endif /* BSDCOMPRESS_SUPPORT */ -#if DEFLATE_SUPPORT - + (go->deflate && go->deflate_correct? CILEN_DEFLATE: 0) - + (go->deflate && go->deflate_draft? CILEN_DEFLATE: 0) -#endif /* DEFLATE_SUPPORT */ -#if PREDICTOR_SUPPORT - + (go->predictor_1? CILEN_PREDICTOR_1: 0) - + (go->predictor_2? CILEN_PREDICTOR_2: 0) -#endif /* PREDICTOR_SUPPORT */ -#if MPPE_SUPPORT - + (go->mppe? CILEN_MPPE: 0) -#endif /* MPPE_SUPPORT */ - ; -} - -/* - * ccp_addci - put our requests in a packet. - */ -static void ccp_addci(fsm *f, u_char *p, int *lenp) { - ppp_pcb *pcb = f->pcb; - ccp_options *go = &pcb->ccp_gotoptions; - u_char *p0 = p; - - /* - * Add the compression types that we can receive, in decreasing - * preference order. - */ -#if MPPE_SUPPORT - if (go->mppe) { - p[0] = CI_MPPE; - p[1] = CILEN_MPPE; - MPPE_OPTS_TO_CI(go->mppe, &p[2]); - mppe_init(pcb, &pcb->mppe_decomp, go->mppe); - p += CILEN_MPPE; - } -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT - if (go->deflate) { - if (go->deflate_correct) { - p[0] = CI_DEFLATE; - p[1] = CILEN_DEFLATE; - p[2] = DEFLATE_MAKE_OPT(go->deflate_size); - p[3] = DEFLATE_CHK_SEQUENCE; - p += CILEN_DEFLATE; - } - if (go->deflate_draft) { - p[0] = CI_DEFLATE_DRAFT; - p[1] = CILEN_DEFLATE; - p[2] = p[2 - CILEN_DEFLATE]; - p[3] = DEFLATE_CHK_SEQUENCE; - p += CILEN_DEFLATE; - } - } -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - if (go->bsd_compress) { - p[0] = CI_BSD_COMPRESS; - p[1] = CILEN_BSD_COMPRESS; - p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits); - p += CILEN_BSD_COMPRESS; - } -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - /* XXX Should Predictor 2 be preferable to Predictor 1? */ - if (go->predictor_1) { - p[0] = CI_PREDICTOR_1; - p[1] = CILEN_PREDICTOR_1; - p += CILEN_PREDICTOR_1; - } - if (go->predictor_2) { - p[0] = CI_PREDICTOR_2; - p[1] = CILEN_PREDICTOR_2; - p += CILEN_PREDICTOR_2; - } -#endif /* PREDICTOR_SUPPORT */ - - go->method = (p > p0)? p0[0]: 0; - - *lenp = p - p0; -} - -/* - * ccp_ackci - process a received configure-ack, and return - * 1 iff the packet was OK. - */ -static int ccp_ackci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - ccp_options *go = &pcb->ccp_gotoptions; -#if BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT - u_char *p0 = p; -#endif /* BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT */ - -#if MPPE_SUPPORT - if (go->mppe) { - u_char opt_buf[CILEN_MPPE]; - - opt_buf[0] = CI_MPPE; - opt_buf[1] = CILEN_MPPE; - MPPE_OPTS_TO_CI(go->mppe, &opt_buf[2]); - if (len < CILEN_MPPE || memcmp(opt_buf, p, CILEN_MPPE)) - return 0; - p += CILEN_MPPE; - len -= CILEN_MPPE; - /* XXX Cope with first/fast ack */ - if (len == 0) - return 1; - } -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT - if (go->deflate) { - if (len < CILEN_DEFLATE - || p[0] != (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT) - || p[1] != CILEN_DEFLATE - || p[2] != DEFLATE_MAKE_OPT(go->deflate_size) - || p[3] != DEFLATE_CHK_SEQUENCE) - return 0; - p += CILEN_DEFLATE; - len -= CILEN_DEFLATE; - /* XXX Cope with first/fast ack */ - if (len == 0) - return 1; - if (go->deflate_correct && go->deflate_draft) { - if (len < CILEN_DEFLATE - || p[0] != CI_DEFLATE_DRAFT - || p[1] != CILEN_DEFLATE - || p[2] != DEFLATE_MAKE_OPT(go->deflate_size) - || p[3] != DEFLATE_CHK_SEQUENCE) - return 0; - p += CILEN_DEFLATE; - len -= CILEN_DEFLATE; - } - } -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - if (go->bsd_compress) { - if (len < CILEN_BSD_COMPRESS - || p[0] != CI_BSD_COMPRESS || p[1] != CILEN_BSD_COMPRESS - || p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits)) - return 0; - p += CILEN_BSD_COMPRESS; - len -= CILEN_BSD_COMPRESS; - /* XXX Cope with first/fast ack */ - if (p == p0 && len == 0) - return 1; - } -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - if (go->predictor_1) { - if (len < CILEN_PREDICTOR_1 - || p[0] != CI_PREDICTOR_1 || p[1] != CILEN_PREDICTOR_1) - return 0; - p += CILEN_PREDICTOR_1; - len -= CILEN_PREDICTOR_1; - /* XXX Cope with first/fast ack */ - if (p == p0 && len == 0) - return 1; - } - if (go->predictor_2) { - if (len < CILEN_PREDICTOR_2 - || p[0] != CI_PREDICTOR_2 || p[1] != CILEN_PREDICTOR_2) - return 0; - p += CILEN_PREDICTOR_2; - len -= CILEN_PREDICTOR_2; - /* XXX Cope with first/fast ack */ - if (p == p0 && len == 0) - return 1; - } -#endif /* PREDICTOR_SUPPORT */ - - if (len != 0) - return 0; - return 1; -} - -/* - * ccp_nakci - process received configure-nak. - * Returns 1 iff the nak was OK. - */ -static int ccp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { - ppp_pcb *pcb = f->pcb; - ccp_options *go = &pcb->ccp_gotoptions; - ccp_options no; /* options we've seen already */ - ccp_options try_; /* options to ask for next time */ - LWIP_UNUSED_ARG(treat_as_reject); -#if !MPPE_SUPPORT && !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT - LWIP_UNUSED_ARG(p); - LWIP_UNUSED_ARG(len); -#endif /* !MPPE_SUPPORT && !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT */ - - memset(&no, 0, sizeof(no)); - try_ = *go; - -#if MPPE_SUPPORT - if (go->mppe && len >= CILEN_MPPE - && p[0] == CI_MPPE && p[1] == CILEN_MPPE) { - no.mppe = 1; - /* - * Peer wants us to use a different strength or other setting. - * Fail if we aren't willing to use his suggestion. - */ - MPPE_CI_TO_OPTS(&p[2], try_.mppe); - if ((try_.mppe & MPPE_OPT_STATEFUL) && pcb->settings.refuse_mppe_stateful) { - ppp_error("Refusing MPPE stateful mode offered by peer"); - try_.mppe = 0; - } else if (((go->mppe | MPPE_OPT_STATEFUL) & try_.mppe) != try_.mppe) { - /* Peer must have set options we didn't request (suggest) */ - try_.mppe = 0; - } - - if (!try_.mppe) { - ppp_error("MPPE required but peer negotiation failed"); - lcp_close(pcb, "MPPE required but peer negotiation failed"); - } - } -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT - if (go->deflate && len >= CILEN_DEFLATE - && p[0] == (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT) - && p[1] == CILEN_DEFLATE) { - no.deflate = 1; - /* - * Peer wants us to use a different code size or something. - * Stop asking for Deflate if we don't understand his suggestion. - */ - if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL - || DEFLATE_SIZE(p[2]) < DEFLATE_MIN_WORKS - || p[3] != DEFLATE_CHK_SEQUENCE) - try_.deflate = 0; - else if (DEFLATE_SIZE(p[2]) < go->deflate_size) - try_.deflate_size = DEFLATE_SIZE(p[2]); - p += CILEN_DEFLATE; - len -= CILEN_DEFLATE; - if (go->deflate_correct && go->deflate_draft - && len >= CILEN_DEFLATE && p[0] == CI_DEFLATE_DRAFT - && p[1] == CILEN_DEFLATE) { - p += CILEN_DEFLATE; - len -= CILEN_DEFLATE; - } - } -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - if (go->bsd_compress && len >= CILEN_BSD_COMPRESS - && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) { - no.bsd_compress = 1; - /* - * Peer wants us to use a different number of bits - * or a different version. - */ - if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION) - try_.bsd_compress = 0; - else if (BSD_NBITS(p[2]) < go->bsd_bits) - try_.bsd_bits = BSD_NBITS(p[2]); - p += CILEN_BSD_COMPRESS; - len -= CILEN_BSD_COMPRESS; - } -#endif /* BSDCOMPRESS_SUPPORT */ - - /* - * Predictor-1 and 2 have no options, so they can't be Naked. - * - * There may be remaining options but we ignore them. - */ - - if (f->state != PPP_FSM_OPENED) - *go = try_; - return 1; -} - -/* - * ccp_rejci - reject some of our suggested compression methods. - */ -static int ccp_rejci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - ccp_options *go = &pcb->ccp_gotoptions; - ccp_options try_; /* options to request next time */ - - try_ = *go; - - /* - * Cope with empty configure-rejects by ceasing to send - * configure-requests. - */ - if (len == 0 && pcb->ccp_all_rejected) - return -1; - -#if MPPE_SUPPORT - if (go->mppe && len >= CILEN_MPPE - && p[0] == CI_MPPE && p[1] == CILEN_MPPE) { - ppp_error("MPPE required but peer refused"); - lcp_close(pcb, "MPPE required but peer refused"); - p += CILEN_MPPE; - len -= CILEN_MPPE; - } -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT - if (go->deflate_correct && len >= CILEN_DEFLATE - && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) { - if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size) - || p[3] != DEFLATE_CHK_SEQUENCE) - return 0; /* Rej is bad */ - try_.deflate_correct = 0; - p += CILEN_DEFLATE; - len -= CILEN_DEFLATE; - } - if (go->deflate_draft && len >= CILEN_DEFLATE - && p[0] == CI_DEFLATE_DRAFT && p[1] == CILEN_DEFLATE) { - if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size) - || p[3] != DEFLATE_CHK_SEQUENCE) - return 0; /* Rej is bad */ - try_.deflate_draft = 0; - p += CILEN_DEFLATE; - len -= CILEN_DEFLATE; - } - if (!try_.deflate_correct && !try_.deflate_draft) - try_.deflate = 0; -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - if (go->bsd_compress && len >= CILEN_BSD_COMPRESS - && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) { - if (p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits)) - return 0; - try_.bsd_compress = 0; - p += CILEN_BSD_COMPRESS; - len -= CILEN_BSD_COMPRESS; - } -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - if (go->predictor_1 && len >= CILEN_PREDICTOR_1 - && p[0] == CI_PREDICTOR_1 && p[1] == CILEN_PREDICTOR_1) { - try_.predictor_1 = 0; - p += CILEN_PREDICTOR_1; - len -= CILEN_PREDICTOR_1; - } - if (go->predictor_2 && len >= CILEN_PREDICTOR_2 - && p[0] == CI_PREDICTOR_2 && p[1] == CILEN_PREDICTOR_2) { - try_.predictor_2 = 0; - p += CILEN_PREDICTOR_2; - len -= CILEN_PREDICTOR_2; - } -#endif /* PREDICTOR_SUPPORT */ - - if (len != 0) - return 0; - - if (f->state != PPP_FSM_OPENED) - *go = try_; - - return 1; -} - -/* - * ccp_reqci - processed a received configure-request. - * Returns CONFACK, CONFNAK or CONFREJ and the packet modified - * appropriately. - */ -static int ccp_reqci(fsm *f, u_char *p, int *lenp, int dont_nak) { - ppp_pcb *pcb = f->pcb; - ccp_options *ho = &pcb->ccp_hisoptions; - ccp_options *ao = &pcb->ccp_allowoptions; - int ret, newret; -#if DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT - int res; - int nb; -#endif /* DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT */ - u_char *p0, *retp; - int len, clen, type; -#if MPPE_SUPPORT - u8_t rej_for_ci_mppe = 1; /* Are we rejecting based on a bad/missing */ - /* CI_MPPE, or due to other options? */ -#endif /* MPPE_SUPPORT */ - - ret = CONFACK; - retp = p0 = p; - len = *lenp; - - memset(ho, 0, sizeof(ccp_options)); - ho->method = (len > 0)? p[0]: 0; - - while (len > 0) { - newret = CONFACK; - if (len < 2 || p[1] < 2 || p[1] > len) { - /* length is bad */ - clen = len; - newret = CONFREJ; - - } else { - type = p[0]; - clen = p[1]; - - switch (type) { -#if MPPE_SUPPORT - case CI_MPPE: - if (!ao->mppe || clen != CILEN_MPPE) { - newret = CONFREJ; - break; - } - MPPE_CI_TO_OPTS(&p[2], ho->mppe); - - /* Nak if anything unsupported or unknown are set. */ - if (ho->mppe & MPPE_OPT_UNSUPPORTED) { - newret = CONFNAK; - ho->mppe &= ~MPPE_OPT_UNSUPPORTED; - } - if (ho->mppe & MPPE_OPT_UNKNOWN) { - newret = CONFNAK; - ho->mppe &= ~MPPE_OPT_UNKNOWN; - } - - /* Check state opt */ - if (ho->mppe & MPPE_OPT_STATEFUL) { - /* - * We can Nak and request stateless, but it's a - * lot easier to just assume the peer will request - * it if he can do it; stateful mode is bad over - * the Internet -- which is where we expect MPPE. - */ - if (pcb->settings.refuse_mppe_stateful) { - ppp_error("Refusing MPPE stateful mode offered by peer"); - newret = CONFREJ; - break; - } - } - - /* Find out which of {S,L} are set. */ - if ((ho->mppe & MPPE_OPT_128) - && (ho->mppe & MPPE_OPT_40)) { - /* Both are set, negotiate the strongest. */ - newret = CONFNAK; - if (ao->mppe & MPPE_OPT_128) - ho->mppe &= ~MPPE_OPT_40; - else if (ao->mppe & MPPE_OPT_40) - ho->mppe &= ~MPPE_OPT_128; - else { - newret = CONFREJ; - break; - } - } else if (ho->mppe & MPPE_OPT_128) { - if (!(ao->mppe & MPPE_OPT_128)) { - newret = CONFREJ; - break; - } - } else if (ho->mppe & MPPE_OPT_40) { - if (!(ao->mppe & MPPE_OPT_40)) { - newret = CONFREJ; - break; - } - } else { - /* Neither are set. */ - /* We cannot accept this. */ - newret = CONFNAK; - /* Give the peer our idea of what can be used, - so it can choose and confirm */ - ho->mppe = ao->mppe; - } - - /* rebuild the opts */ - MPPE_OPTS_TO_CI(ho->mppe, &p[2]); - if (newret == CONFACK) { - int mtu; - - mppe_init(pcb, &pcb->mppe_comp, ho->mppe); - /* - * We need to decrease the interface MTU by MPPE_PAD - * because MPPE frames **grow**. The kernel [must] - * allocate MPPE_PAD extra bytes in xmit buffers. - */ - mtu = netif_get_mtu(pcb); - if (mtu) - netif_set_mtu(pcb, mtu - MPPE_PAD); - else - newret = CONFREJ; - } - - /* - * We have accepted MPPE or are willing to negotiate - * MPPE parameters. A CONFREJ is due to subsequent - * (non-MPPE) processing. - */ - rej_for_ci_mppe = 0; - break; -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT - case CI_DEFLATE: - case CI_DEFLATE_DRAFT: - if (!ao->deflate || clen != CILEN_DEFLATE - || (!ao->deflate_correct && type == CI_DEFLATE) - || (!ao->deflate_draft && type == CI_DEFLATE_DRAFT)) { - newret = CONFREJ; - break; - } - - ho->deflate = 1; - ho->deflate_size = nb = DEFLATE_SIZE(p[2]); - if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL - || p[3] != DEFLATE_CHK_SEQUENCE - || nb > ao->deflate_size || nb < DEFLATE_MIN_WORKS) { - newret = CONFNAK; - if (!dont_nak) { - p[2] = DEFLATE_MAKE_OPT(ao->deflate_size); - p[3] = DEFLATE_CHK_SEQUENCE; - /* fall through to test this #bits below */ - } else - break; - } - - /* - * Check whether we can do Deflate with the window - * size they want. If the window is too big, reduce - * it until the kernel can cope and nak with that. - * We only check this for the first option. - */ - if (p == p0) { - for (;;) { - res = ccp_test(pcb, p, CILEN_DEFLATE, 1); - if (res > 0) - break; /* it's OK now */ - if (res < 0 || nb == DEFLATE_MIN_WORKS || dont_nak) { - newret = CONFREJ; - p[2] = DEFLATE_MAKE_OPT(ho->deflate_size); - break; - } - newret = CONFNAK; - --nb; - p[2] = DEFLATE_MAKE_OPT(nb); - } - } - break; -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - case CI_BSD_COMPRESS: - if (!ao->bsd_compress || clen != CILEN_BSD_COMPRESS) { - newret = CONFREJ; - break; - } - - ho->bsd_compress = 1; - ho->bsd_bits = nb = BSD_NBITS(p[2]); - if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION - || nb > ao->bsd_bits || nb < BSD_MIN_BITS) { - newret = CONFNAK; - if (!dont_nak) { - p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, ao->bsd_bits); - /* fall through to test this #bits below */ - } else - break; - } - - /* - * Check whether we can do BSD-Compress with the code - * size they want. If the code size is too big, reduce - * it until the kernel can cope and nak with that. - * We only check this for the first option. - */ - if (p == p0) { - for (;;) { - res = ccp_test(pcb, p, CILEN_BSD_COMPRESS, 1); - if (res > 0) - break; - if (res < 0 || nb == BSD_MIN_BITS || dont_nak) { - newret = CONFREJ; - p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, - ho->bsd_bits); - break; - } - newret = CONFNAK; - --nb; - p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb); - } - } - break; -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - case CI_PREDICTOR_1: - if (!ao->predictor_1 || clen != CILEN_PREDICTOR_1) { - newret = CONFREJ; - break; - } - - ho->predictor_1 = 1; - if (p == p0 - && ccp_test(pcb, p, CILEN_PREDICTOR_1, 1) <= 0) { - newret = CONFREJ; - } - break; - - case CI_PREDICTOR_2: - if (!ao->predictor_2 || clen != CILEN_PREDICTOR_2) { - newret = CONFREJ; - break; - } - - ho->predictor_2 = 1; - if (p == p0 - && ccp_test(pcb, p, CILEN_PREDICTOR_2, 1) <= 0) { - newret = CONFREJ; - } - break; -#endif /* PREDICTOR_SUPPORT */ - - default: - newret = CONFREJ; - } - } - - if (newret == CONFNAK && dont_nak) - newret = CONFREJ; - if (!(newret == CONFACK || (newret == CONFNAK && ret == CONFREJ))) { - /* we're returning this option */ - if (newret == CONFREJ && ret == CONFNAK) - retp = p0; - ret = newret; - if (p != retp) - MEMCPY(retp, p, clen); - retp += clen; - } - - p += clen; - len -= clen; - } - - if (ret != CONFACK) { - if (ret == CONFREJ && *lenp == retp - p0) - pcb->ccp_all_rejected = 1; - else - *lenp = retp - p0; - } -#if MPPE_SUPPORT - if (ret == CONFREJ && ao->mppe && rej_for_ci_mppe) { - ppp_error("MPPE required but peer negotiation failed"); - lcp_close(pcb, "MPPE required but peer negotiation failed"); - } -#endif /* MPPE_SUPPORT */ - return ret; -} - -/* - * Make a string name for a compression method (or 2). - */ -static const char *method_name(ccp_options *opt, ccp_options *opt2) { - static char result[64]; -#if !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT - LWIP_UNUSED_ARG(opt2); -#endif /* !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT */ - - if (!ccp_anycompress(opt)) - return "(none)"; - switch (opt->method) { -#if MPPE_SUPPORT - case CI_MPPE: - { - char *p = result; - char *q = result + sizeof(result); /* 1 past result */ - - ppp_slprintf(p, q - p, "MPPE "); - p += 5; - if (opt->mppe & MPPE_OPT_128) { - ppp_slprintf(p, q - p, "128-bit "); - p += 8; - } - if (opt->mppe & MPPE_OPT_40) { - ppp_slprintf(p, q - p, "40-bit "); - p += 7; - } - if (opt->mppe & MPPE_OPT_STATEFUL) - ppp_slprintf(p, q - p, "stateful"); - else - ppp_slprintf(p, q - p, "stateless"); - - break; - } -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT - case CI_DEFLATE: - case CI_DEFLATE_DRAFT: - if (opt2 != NULL && opt2->deflate_size != opt->deflate_size) - ppp_slprintf(result, sizeof(result), "Deflate%s (%d/%d)", - (opt->method == CI_DEFLATE_DRAFT? "(old#)": ""), - opt->deflate_size, opt2->deflate_size); - else - ppp_slprintf(result, sizeof(result), "Deflate%s (%d)", - (opt->method == CI_DEFLATE_DRAFT? "(old#)": ""), - opt->deflate_size); - break; -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - case CI_BSD_COMPRESS: - if (opt2 != NULL && opt2->bsd_bits != opt->bsd_bits) - ppp_slprintf(result, sizeof(result), "BSD-Compress (%d/%d)", - opt->bsd_bits, opt2->bsd_bits); - else - ppp_slprintf(result, sizeof(result), "BSD-Compress (%d)", - opt->bsd_bits); - break; -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - case CI_PREDICTOR_1: - return "Predictor 1"; - case CI_PREDICTOR_2: - return "Predictor 2"; -#endif /* PREDICTOR_SUPPORT */ - default: - ppp_slprintf(result, sizeof(result), "Method %d", opt->method); - } - return result; -} - -/* - * CCP has come up - inform the kernel driver and log a message. - */ -static void ccp_up(fsm *f) { - ppp_pcb *pcb = f->pcb; - ccp_options *go = &pcb->ccp_gotoptions; - ccp_options *ho = &pcb->ccp_hisoptions; - char method1[64]; - - ccp_set(pcb, 1, 1, go->method, ho->method); - if (ccp_anycompress(go)) { - if (ccp_anycompress(ho)) { - if (go->method == ho->method) { - ppp_notice("%s compression enabled", method_name(go, ho)); - } else { - ppp_strlcpy(method1, method_name(go, NULL), sizeof(method1)); - ppp_notice("%s / %s compression enabled", - method1, method_name(ho, NULL)); - } - } else - ppp_notice("%s receive compression enabled", method_name(go, NULL)); - } else if (ccp_anycompress(ho)) - ppp_notice("%s transmit compression enabled", method_name(ho, NULL)); -#if MPPE_SUPPORT - if (go->mppe) { - continue_networks(pcb); /* Bring up IP et al */ - } -#endif /* MPPE_SUPPORT */ -} - -/* - * CCP has gone down - inform the kernel driver. - */ -static void ccp_down(fsm *f) { - ppp_pcb *pcb = f->pcb; -#if MPPE_SUPPORT - ccp_options *go = &pcb->ccp_gotoptions; -#endif /* MPPE_SUPPORT */ - - if (pcb->ccp_localstate & RACK_PENDING) - UNTIMEOUT(ccp_rack_timeout, f); - pcb->ccp_localstate = 0; - ccp_set(pcb, 1, 0, 0, 0); -#if MPPE_SUPPORT - if (go->mppe) { - go->mppe = 0; - if (pcb->lcp_fsm.state == PPP_FSM_OPENED) { - /* If LCP is not already going down, make sure it does. */ - ppp_error("MPPE disabled"); - lcp_close(pcb, "MPPE disabled"); - } - } -#endif /* MPPE_SUPPORT */ -} - -#if PRINTPKT_SUPPORT -/* - * Print the contents of a CCP packet. - */ -static const char* const ccp_codenames[] = { - "ConfReq", "ConfAck", "ConfNak", "ConfRej", - "TermReq", "TermAck", "CodeRej", - NULL, NULL, NULL, NULL, NULL, NULL, - "ResetReq", "ResetAck", -}; - -static int ccp_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg) { - const u_char *p0, *optend; - int code, id, len; - int optlen; - - p0 = p; - if (plen < HEADERLEN) - return 0; - code = p[0]; - id = p[1]; - len = (p[2] << 8) + p[3]; - if (len < HEADERLEN || len > plen) - return 0; - - if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(ccp_codenames) && ccp_codenames[code-1] != NULL) - printer(arg, " %s", ccp_codenames[code-1]); - else - printer(arg, " code=0x%x", code); - printer(arg, " id=0x%x", id); - len -= HEADERLEN; - p += HEADERLEN; - - switch (code) { - case CONFREQ: - case CONFACK: - case CONFNAK: - case CONFREJ: - /* print list of possible compression methods */ - while (len >= 2) { - code = p[0]; - optlen = p[1]; - if (optlen < 2 || optlen > len) - break; - printer(arg, " <"); - len -= optlen; - optend = p + optlen; - switch (code) { -#if MPPE_SUPPORT - case CI_MPPE: - if (optlen >= CILEN_MPPE) { - u_char mppe_opts; - - MPPE_CI_TO_OPTS(&p[2], mppe_opts); - printer(arg, "mppe %s %s %s %s %s %s%s", - (p[2] & MPPE_H_BIT)? "+H": "-H", - (p[5] & MPPE_M_BIT)? "+M": "-M", - (p[5] & MPPE_S_BIT)? "+S": "-S", - (p[5] & MPPE_L_BIT)? "+L": "-L", - (p[5] & MPPE_D_BIT)? "+D": "-D", - (p[5] & MPPE_C_BIT)? "+C": "-C", - (mppe_opts & MPPE_OPT_UNKNOWN)? " +U": ""); - if (mppe_opts & MPPE_OPT_UNKNOWN) - printer(arg, " (%.2x %.2x %.2x %.2x)", - p[2], p[3], p[4], p[5]); - p += CILEN_MPPE; - } - break; -#endif /* MPPE_SUPPORT */ -#if DEFLATE_SUPPORT - case CI_DEFLATE: - case CI_DEFLATE_DRAFT: - if (optlen >= CILEN_DEFLATE) { - printer(arg, "deflate%s %d", - (code == CI_DEFLATE_DRAFT? "(old#)": ""), - DEFLATE_SIZE(p[2])); - if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL) - printer(arg, " method %d", DEFLATE_METHOD(p[2])); - if (p[3] != DEFLATE_CHK_SEQUENCE) - printer(arg, " check %d", p[3]); - p += CILEN_DEFLATE; - } - break; -#endif /* DEFLATE_SUPPORT */ -#if BSDCOMPRESS_SUPPORT - case CI_BSD_COMPRESS: - if (optlen >= CILEN_BSD_COMPRESS) { - printer(arg, "bsd v%d %d", BSD_VERSION(p[2]), - BSD_NBITS(p[2])); - p += CILEN_BSD_COMPRESS; - } - break; -#endif /* BSDCOMPRESS_SUPPORT */ -#if PREDICTOR_SUPPORT - case CI_PREDICTOR_1: - if (optlen >= CILEN_PREDICTOR_1) { - printer(arg, "predictor 1"); - p += CILEN_PREDICTOR_1; - } - break; - case CI_PREDICTOR_2: - if (optlen >= CILEN_PREDICTOR_2) { - printer(arg, "predictor 2"); - p += CILEN_PREDICTOR_2; - } - break; -#endif /* PREDICTOR_SUPPORT */ - default: - break; - } - while (p < optend) - printer(arg, " %.2x", *p++); - printer(arg, ">"); - } - break; - - case TERMACK: - case TERMREQ: - if (len > 0 && *p >= ' ' && *p < 0x7f) { - ppp_print_string(p, len, printer, arg); - p += len; - len = 0; - } - break; - default: - break; - } - - /* dump out the rest of the packet in hex */ - while (--len >= 0) - printer(arg, " %.2x", *p++); - - return p - p0; -} -#endif /* PRINTPKT_SUPPORT */ - -#if PPP_DATAINPUT -/* - * We have received a packet that the decompressor failed to - * decompress. Here we would expect to issue a reset-request, but - * Motorola has a patent on resetting the compressor as a result of - * detecting an error in the decompressed data after decompression. - * (See US patent 5,130,993; international patent publication number - * WO 91/10289; Australian patent 73296/91.) - * - * So we ask the kernel whether the error was detected after - * decompression; if it was, we take CCP down, thus disabling - * compression :-(, otherwise we issue the reset-request. - */ -static void ccp_datainput(ppp_pcb *pcb, u_char *pkt, int len) { - fsm *f; -#if MPPE_SUPPORT - ccp_options *go = &pcb->ccp_gotoptions; -#endif /* MPPE_SUPPORT */ - LWIP_UNUSED_ARG(pkt); - LWIP_UNUSED_ARG(len); - - f = &pcb->ccp_fsm; - if (f->state == PPP_FSM_OPENED) { - if (ccp_fatal_error(pcb)) { - /* - * Disable compression by taking CCP down. - */ - ppp_error("Lost compression sync: disabling compression"); - ccp_close(pcb, "Lost compression sync"); -#if MPPE_SUPPORT - /* - * If we were doing MPPE, we must also take the link down. - */ - if (go->mppe) { - ppp_error("Too many MPPE errors, closing LCP"); - lcp_close(pcb, "Too many MPPE errors"); - } -#endif /* MPPE_SUPPORT */ - } else { - /* - * Send a reset-request to reset the peer's compressor. - * We don't do that if we are still waiting for an - * acknowledgement to a previous reset-request. - */ - if (!(pcb->ccp_localstate & RACK_PENDING)) { - fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0); - TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT); - pcb->ccp_localstate |= RACK_PENDING; - } else - pcb->ccp_localstate |= RREQ_REPEAT; - } - } -} -#endif /* PPP_DATAINPUT */ - -/* - * We have received a packet that the decompressor failed to - * decompress. Issue a reset-request. - */ -void ccp_resetrequest(ppp_pcb *pcb) { - fsm *f = &pcb->ccp_fsm; - - if (f->state != PPP_FSM_OPENED) - return; - - /* - * Send a reset-request to reset the peer's compressor. - * We don't do that if we are still waiting for an - * acknowledgement to a previous reset-request. - */ - if (!(pcb->ccp_localstate & RACK_PENDING)) { - fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0); - TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT); - pcb->ccp_localstate |= RACK_PENDING; - } else - pcb->ccp_localstate |= RREQ_REPEAT; -} - -/* - * Timeout waiting for reset-ack. - */ -static void ccp_rack_timeout(void *arg) { - fsm *f = (fsm*)arg; - ppp_pcb *pcb = f->pcb; - - if (f->state == PPP_FSM_OPENED && (pcb->ccp_localstate & RREQ_REPEAT)) { - fsm_sdata(f, CCP_RESETREQ, f->reqid, NULL, 0); - TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT); - pcb->ccp_localstate &= ~RREQ_REPEAT; - } else - pcb->ccp_localstate &= ~RACK_PENDING; -} - -#endif /* PPP_SUPPORT && CCP_SUPPORT */ +/* + * ccp.c - PPP Compression Control Protocol. + * + * Copyright (c) 1994-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && CCP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include +#include + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/ccp.h" + +#if MPPE_SUPPORT +#include "netif/ppp/lcp.h" /* lcp_close(), lcp_fsm */ +#include "netif/ppp/mppe.h" /* mppe_init() */ +#endif /* MPPE_SUPPORT */ + +/* + * Unfortunately there is a bug in zlib which means that using a + * size of 8 (window size = 256) for Deflate compression will cause + * buffer overruns and kernel crashes in the deflate module. + * Until this is fixed we only accept sizes in the range 9 .. 15. + * Thanks to James Carlson for pointing this out. + */ +#define DEFLATE_MIN_WORKS 9 + +/* + * Command-line options. + */ +#if PPP_OPTIONS +static int setbsdcomp (char **); +static int setdeflate (char **); +static char bsd_value[8]; +static char deflate_value[8]; + +/* + * Option variables. + */ +#if MPPE_SUPPORT +bool refuse_mppe_stateful = 1; /* Allow stateful mode? */ +#endif /* MPPE_SUPPORT */ + +static option_t ccp_option_list[] = { + { "noccp", o_bool, &ccp_protent.enabled_flag, + "Disable CCP negotiation" }, + { "-ccp", o_bool, &ccp_protent.enabled_flag, + "Disable CCP negotiation", OPT_ALIAS }, + + { "bsdcomp", o_special, (void *)setbsdcomp, + "Request BSD-Compress packet compression", + OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, bsd_value }, + { "nobsdcomp", o_bool, &ccp_wantoptions[0].bsd_compress, + "don't allow BSD-Compress", OPT_PRIOSUB | OPT_A2CLR, + &ccp_allowoptions[0].bsd_compress }, + { "-bsdcomp", o_bool, &ccp_wantoptions[0].bsd_compress, + "don't allow BSD-Compress", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, + &ccp_allowoptions[0].bsd_compress }, + + { "deflate", o_special, (void *)setdeflate, + "request Deflate compression", + OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, deflate_value }, + { "nodeflate", o_bool, &ccp_wantoptions[0].deflate, + "don't allow Deflate compression", OPT_PRIOSUB | OPT_A2CLR, + &ccp_allowoptions[0].deflate }, + { "-deflate", o_bool, &ccp_wantoptions[0].deflate, + "don't allow Deflate compression", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, + &ccp_allowoptions[0].deflate }, + + { "nodeflatedraft", o_bool, &ccp_wantoptions[0].deflate_draft, + "don't use draft deflate #", OPT_A2COPY, + &ccp_allowoptions[0].deflate_draft }, + + { "predictor1", o_bool, &ccp_wantoptions[0].predictor_1, + "request Predictor-1", OPT_PRIO | 1 }, + { "nopredictor1", o_bool, &ccp_wantoptions[0].predictor_1, + "don't allow Predictor-1", OPT_PRIOSUB | OPT_A2CLR, + &ccp_allowoptions[0].predictor_1 }, + { "-predictor1", o_bool, &ccp_wantoptions[0].predictor_1, + "don't allow Predictor-1", OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, + &ccp_allowoptions[0].predictor_1 }, + +#if MPPE_SUPPORT + /* MPPE options are symmetrical ... we only set wantoptions here */ + { "require-mppe", o_bool, &ccp_wantoptions[0].mppe, + "require MPPE encryption", + OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 }, + { "+mppe", o_bool, &ccp_wantoptions[0].mppe, + "require MPPE encryption", + OPT_ALIAS | OPT_PRIO | MPPE_OPT_40 | MPPE_OPT_128 }, + { "nomppe", o_bool, &ccp_wantoptions[0].mppe, + "don't allow MPPE encryption", OPT_PRIO }, + { "-mppe", o_bool, &ccp_wantoptions[0].mppe, + "don't allow MPPE encryption", OPT_ALIAS | OPT_PRIO }, + + /* We use ccp_allowoptions[0].mppe as a junk var ... it is reset later */ + { "require-mppe-40", o_bool, &ccp_allowoptions[0].mppe, + "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40, + &ccp_wantoptions[0].mppe }, + { "+mppe-40", o_bool, &ccp_allowoptions[0].mppe, + "require MPPE 40-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_40, + &ccp_wantoptions[0].mppe }, + { "nomppe-40", o_bool, &ccp_allowoptions[0].mppe, + "don't allow MPPE 40-bit encryption", + OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40, &ccp_wantoptions[0].mppe }, + { "-mppe-40", o_bool, &ccp_allowoptions[0].mppe, + "don't allow MPPE 40-bit encryption", + OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_40, + &ccp_wantoptions[0].mppe }, + + { "require-mppe-128", o_bool, &ccp_allowoptions[0].mppe, + "require MPPE 128-bit encryption", OPT_PRIO | OPT_A2OR | MPPE_OPT_128, + &ccp_wantoptions[0].mppe }, + { "+mppe-128", o_bool, &ccp_allowoptions[0].mppe, + "require MPPE 128-bit encryption", + OPT_ALIAS | OPT_PRIO | OPT_A2OR | MPPE_OPT_128, + &ccp_wantoptions[0].mppe }, + { "nomppe-128", o_bool, &ccp_allowoptions[0].mppe, + "don't allow MPPE 128-bit encryption", + OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128, &ccp_wantoptions[0].mppe }, + { "-mppe-128", o_bool, &ccp_allowoptions[0].mppe, + "don't allow MPPE 128-bit encryption", + OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLRB | MPPE_OPT_128, + &ccp_wantoptions[0].mppe }, + + /* strange one; we always request stateless, but will we allow stateful? */ + { "mppe-stateful", o_bool, &refuse_mppe_stateful, + "allow MPPE stateful mode", OPT_PRIO }, + { "nomppe-stateful", o_bool, &refuse_mppe_stateful, + "disallow MPPE stateful mode", OPT_PRIO | 1 }, +#endif /* MPPE_SUPPORT */ + + { NULL } +}; +#endif /* PPP_OPTIONS */ + +/* + * Protocol entry points from main code. + */ +static void ccp_init(ppp_pcb *pcb); +static void ccp_open(ppp_pcb *pcb); +static void ccp_close(ppp_pcb *pcb, const char *reason); +static void ccp_lowerup(ppp_pcb *pcb); +static void ccp_lowerdown(ppp_pcb *pcb); +static void ccp_input(ppp_pcb *pcb, u_char *pkt, int len); +static void ccp_protrej(ppp_pcb *pcb); +#if PRINTPKT_SUPPORT +static int ccp_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg); +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT +static void ccp_datainput(ppp_pcb *pcb, u_char *pkt, int len); +#endif /* PPP_DATAINPUT */ + +const struct protent ccp_protent = { + PPP_CCP, + ccp_init, + ccp_input, + ccp_protrej, + ccp_lowerup, + ccp_lowerdown, + ccp_open, + ccp_close, +#if PRINTPKT_SUPPORT + ccp_printpkt, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + ccp_datainput, +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "CCP", + "Compressed", +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + ccp_option_list, + NULL, +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + NULL, + NULL +#endif /* DEMAND_SUPPORT */ +}; + +/* + * Callbacks for fsm code. + */ +static void ccp_resetci (fsm *); +static int ccp_cilen (fsm *); +static void ccp_addci (fsm *, u_char *, int *); +static int ccp_ackci (fsm *, u_char *, int); +static int ccp_nakci (fsm *, u_char *, int, int); +static int ccp_rejci (fsm *, u_char *, int); +static int ccp_reqci (fsm *, u_char *, int *, int); +static void ccp_up (fsm *); +static void ccp_down (fsm *); +static int ccp_extcode (fsm *, int, int, u_char *, int); +static void ccp_rack_timeout (void *); +static const char *method_name (ccp_options *, ccp_options *); + +static const fsm_callbacks ccp_callbacks = { + ccp_resetci, + ccp_cilen, + ccp_addci, + ccp_ackci, + ccp_nakci, + ccp_rejci, + ccp_reqci, + ccp_up, + ccp_down, + NULL, + NULL, + NULL, + NULL, + ccp_extcode, + "CCP" +}; + +/* + * Do we want / did we get any compression? + */ +static int ccp_anycompress(ccp_options *opt) { + return (0 +#if DEFLATE_SUPPORT + || (opt)->deflate +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + || (opt)->bsd_compress +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + || (opt)->predictor_1 || (opt)->predictor_2 +#endif /* PREDICTOR_SUPPORT */ +#if MPPE_SUPPORT + || (opt)->mppe +#endif /* MPPE_SUPPORT */ + ); +} + +/* + * Local state (mainly for handling reset-reqs and reset-acks). + */ +#define RACK_PENDING 1 /* waiting for reset-ack */ +#define RREQ_REPEAT 2 /* send another reset-req if no reset-ack */ + +#define RACKTIMEOUT 1 /* second */ + +#if PPP_OPTIONS +/* + * Option parsing + */ +static int +setbsdcomp(argv) + char **argv; +{ + int rbits, abits; + char *str, *endp; + + str = *argv; + abits = rbits = strtol(str, &endp, 0); + if (endp != str && *endp == ',') { + str = endp + 1; + abits = strtol(str, &endp, 0); + } + if (*endp != 0 || endp == str) { + option_error("invalid parameter '%s' for bsdcomp option", *argv); + return 0; + } + if ((rbits != 0 && (rbits < BSD_MIN_BITS || rbits > BSD_MAX_BITS)) + || (abits != 0 && (abits < BSD_MIN_BITS || abits > BSD_MAX_BITS))) { + option_error("bsdcomp option values must be 0 or %d .. %d", + BSD_MIN_BITS, BSD_MAX_BITS); + return 0; + } + if (rbits > 0) { + ccp_wantoptions[0].bsd_compress = 1; + ccp_wantoptions[0].bsd_bits = rbits; + } else + ccp_wantoptions[0].bsd_compress = 0; + if (abits > 0) { + ccp_allowoptions[0].bsd_compress = 1; + ccp_allowoptions[0].bsd_bits = abits; + } else + ccp_allowoptions[0].bsd_compress = 0; + ppp_slprintf(bsd_value, sizeof(bsd_value), + rbits == abits? "%d": "%d,%d", rbits, abits); + + return 1; +} + +static int +setdeflate(argv) + char **argv; +{ + int rbits, abits; + char *str, *endp; + + str = *argv; + abits = rbits = strtol(str, &endp, 0); + if (endp != str && *endp == ',') { + str = endp + 1; + abits = strtol(str, &endp, 0); + } + if (*endp != 0 || endp == str) { + option_error("invalid parameter '%s' for deflate option", *argv); + return 0; + } + if ((rbits != 0 && (rbits < DEFLATE_MIN_SIZE || rbits > DEFLATE_MAX_SIZE)) + || (abits != 0 && (abits < DEFLATE_MIN_SIZE + || abits > DEFLATE_MAX_SIZE))) { + option_error("deflate option values must be 0 or %d .. %d", + DEFLATE_MIN_SIZE, DEFLATE_MAX_SIZE); + return 0; + } + if (rbits == DEFLATE_MIN_SIZE || abits == DEFLATE_MIN_SIZE) { + if (rbits == DEFLATE_MIN_SIZE) + rbits = DEFLATE_MIN_WORKS; + if (abits == DEFLATE_MIN_SIZE) + abits = DEFLATE_MIN_WORKS; + warn("deflate option value of %d changed to %d to avoid zlib bug", + DEFLATE_MIN_SIZE, DEFLATE_MIN_WORKS); + } + if (rbits > 0) { + ccp_wantoptions[0].deflate = 1; + ccp_wantoptions[0].deflate_size = rbits; + } else + ccp_wantoptions[0].deflate = 0; + if (abits > 0) { + ccp_allowoptions[0].deflate = 1; + ccp_allowoptions[0].deflate_size = abits; + } else + ccp_allowoptions[0].deflate = 0; + ppp_slprintf(deflate_value, sizeof(deflate_value), + rbits == abits? "%d": "%d,%d", rbits, abits); + + return 1; +} +#endif /* PPP_OPTIONS */ + +/* + * ccp_init - initialize CCP. + */ +static void ccp_init(ppp_pcb *pcb) { + fsm *f = &pcb->ccp_fsm; + + f->pcb = pcb; + f->protocol = PPP_CCP; + f->callbacks = &ccp_callbacks; + fsm_init(f); + +#if 0 /* Not necessary, everything is cleared in ppp_new() */ + memset(wo, 0, sizeof(*wo)); + memset(go, 0, sizeof(*go)); + memset(ao, 0, sizeof(*ao)); + memset(ho, 0, sizeof(*ho)); +#endif /* 0 */ + +#if DEFLATE_SUPPORT + wo->deflate = 1; + wo->deflate_size = DEFLATE_MAX_SIZE; + wo->deflate_correct = 1; + wo->deflate_draft = 1; + ao->deflate = 1; + ao->deflate_size = DEFLATE_MAX_SIZE; + ao->deflate_correct = 1; + ao->deflate_draft = 1; +#endif /* DEFLATE_SUPPORT */ + +#if BSDCOMPRESS_SUPPORT + wo->bsd_compress = 1; + wo->bsd_bits = BSD_MAX_BITS; + ao->bsd_compress = 1; + ao->bsd_bits = BSD_MAX_BITS; +#endif /* BSDCOMPRESS_SUPPORT */ + +#if PREDICTOR_SUPPORT + ao->predictor_1 = 1; +#endif /* PREDICTOR_SUPPORT */ +} + +/* + * ccp_open - CCP is allowed to come up. + */ +static void ccp_open(ppp_pcb *pcb) { + fsm *f = &pcb->ccp_fsm; + ccp_options *go = &pcb->ccp_gotoptions; + + if (f->state != PPP_FSM_OPENED) + ccp_set(pcb, 1, 0, 0, 0); + + /* + * Find out which compressors the kernel supports before + * deciding whether to open in silent mode. + */ + ccp_resetci(f); + if (!ccp_anycompress(go)) + f->flags |= OPT_SILENT; + + fsm_open(f); +} + +/* + * ccp_close - Terminate CCP. + */ +static void ccp_close(ppp_pcb *pcb, const char *reason) { + fsm *f = &pcb->ccp_fsm; + ccp_set(pcb, 0, 0, 0, 0); + fsm_close(f, reason); +} + +/* + * ccp_lowerup - we may now transmit CCP packets. + */ +static void ccp_lowerup(ppp_pcb *pcb) { + fsm *f = &pcb->ccp_fsm; + fsm_lowerup(f); +} + +/* + * ccp_lowerdown - we may not transmit CCP packets. + */ +static void ccp_lowerdown(ppp_pcb *pcb) { + fsm *f = &pcb->ccp_fsm; + fsm_lowerdown(f); +} + +/* + * ccp_input - process a received CCP packet. + */ +static void ccp_input(ppp_pcb *pcb, u_char *p, int len) { + fsm *f = &pcb->ccp_fsm; + ccp_options *go = &pcb->ccp_gotoptions; + int oldstate; + + /* + * Check for a terminate-request so we can print a message. + */ + oldstate = f->state; + fsm_input(f, p, len); + if (oldstate == PPP_FSM_OPENED && p[0] == TERMREQ && f->state != PPP_FSM_OPENED) { + ppp_notice("Compression disabled by peer."); +#if MPPE_SUPPORT + if (go->mppe) { + ppp_error("MPPE disabled, closing LCP"); + lcp_close(pcb, "MPPE disabled by peer"); + } +#endif /* MPPE_SUPPORT */ + } + + /* + * If we get a terminate-ack and we're not asking for compression, + * close CCP. + */ + if (oldstate == PPP_FSM_REQSENT && p[0] == TERMACK + && !ccp_anycompress(go)) + ccp_close(pcb, "No compression negotiated"); +} + +/* + * Handle a CCP-specific code. + */ +static int ccp_extcode(fsm *f, int code, int id, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + LWIP_UNUSED_ARG(p); + LWIP_UNUSED_ARG(len); + + switch (code) { + case CCP_RESETREQ: + if (f->state != PPP_FSM_OPENED) + break; + ccp_reset_comp(pcb); + /* send a reset-ack, which the transmitter will see and + reset its compression state. */ + fsm_sdata(f, CCP_RESETACK, id, NULL, 0); + break; + + case CCP_RESETACK: + if ((pcb->ccp_localstate & RACK_PENDING) && id == f->reqid) { + pcb->ccp_localstate &= ~(RACK_PENDING | RREQ_REPEAT); + UNTIMEOUT(ccp_rack_timeout, f); + ccp_reset_decomp(pcb); + } + break; + + default: + return 0; + } + + return 1; +} + +/* + * ccp_protrej - peer doesn't talk CCP. + */ +static void ccp_protrej(ppp_pcb *pcb) { + fsm *f = &pcb->ccp_fsm; +#if MPPE_SUPPORT + ccp_options *go = &pcb->ccp_gotoptions; +#endif /* MPPE_SUPPORT */ + + ccp_set(pcb, 0, 0, 0, 0); + fsm_lowerdown(f); + +#if MPPE_SUPPORT + if (go->mppe) { + ppp_error("MPPE required but peer negotiation failed"); + lcp_close(pcb, "MPPE required but peer negotiation failed"); + } +#endif /* MPPE_SUPPORT */ + +} + +/* + * ccp_resetci - initialize at start of negotiation. + */ +static void ccp_resetci(fsm *f) { + ppp_pcb *pcb = f->pcb; + ccp_options *go = &pcb->ccp_gotoptions; + ccp_options *wo = &pcb->ccp_wantoptions; +#if MPPE_SUPPORT + ccp_options *ao = &pcb->ccp_allowoptions; +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT + u_char opt_buf[CCP_MAX_OPTION_LENGTH]; +#endif /* DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT */ +#if DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT + int res; +#endif /* DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT */ + +#if MPPE_SUPPORT + if (pcb->settings.require_mppe) { + wo->mppe = ao->mppe = + (pcb->settings.refuse_mppe_40 ? 0 : MPPE_OPT_40) + | (pcb->settings.refuse_mppe_128 ? 0 : MPPE_OPT_128); + } +#endif /* MPPE_SUPPORT */ + + *go = *wo; + pcb->ccp_all_rejected = 0; + +#if MPPE_SUPPORT + if (go->mppe) { + int auth_mschap_bits = pcb->auth_done; + int numbits; + + /* + * Start with a basic sanity check: mschap[v2] auth must be in + * exactly one direction. RFC 3079 says that the keys are + * 'derived from the credentials of the peer that initiated the call', + * however the PPP protocol doesn't have such a concept, and pppd + * cannot get this info externally. Instead we do the best we can. + * NB: If MPPE is required, all other compression opts are invalid. + * So, we return right away if we can't do it. + */ + + /* Leave only the mschap auth bits set */ + auth_mschap_bits &= (CHAP_MS_WITHPEER | CHAP_MS_PEER | + CHAP_MS2_WITHPEER | CHAP_MS2_PEER); + /* Count the mschap auths */ + auth_mschap_bits >>= CHAP_MS_SHIFT; + numbits = 0; + do { + numbits += auth_mschap_bits & 1; + auth_mschap_bits >>= 1; + } while (auth_mschap_bits); + if (numbits > 1) { + ppp_error("MPPE required, but auth done in both directions."); + lcp_close(pcb, "MPPE required but not available"); + return; + } + if (!numbits) { + ppp_error("MPPE required, but MS-CHAP[v2] auth not performed."); + lcp_close(pcb, "MPPE required but not available"); + return; + } + + /* A plugin (eg radius) may not have obtained key material. */ + if (!pcb->mppe_keys_set) { + ppp_error("MPPE required, but keys are not available. " + "Possible plugin problem?"); + lcp_close(pcb, "MPPE required but not available"); + return; + } + + /* LM auth not supported for MPPE */ + if (pcb->auth_done & (CHAP_MS_WITHPEER | CHAP_MS_PEER)) { + /* This might be noise */ + if (go->mppe & MPPE_OPT_40) { + ppp_notice("Disabling 40-bit MPPE; MS-CHAP LM not supported"); + go->mppe &= ~MPPE_OPT_40; + wo->mppe &= ~MPPE_OPT_40; + } + } + + /* Last check: can we actually negotiate something? */ + if (!(go->mppe & (MPPE_OPT_40 | MPPE_OPT_128))) { + /* Could be misconfig, could be 40-bit disabled above. */ + ppp_error("MPPE required, but both 40-bit and 128-bit disabled."); + lcp_close(pcb, "MPPE required but not available"); + return; + } + + /* sync options */ + ao->mppe = go->mppe; + /* MPPE is not compatible with other compression types */ +#if BSDCOMPRESS_SUPPORT + ao->bsd_compress = go->bsd_compress = 0; +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + ao->predictor_1 = go->predictor_1 = 0; + ao->predictor_2 = go->predictor_2 = 0; +#endif /* PREDICTOR_SUPPORT */ +#if DEFLATE_SUPPORT + ao->deflate = go->deflate = 0; +#endif /* DEFLATE_SUPPORT */ + } +#endif /* MPPE_SUPPORT */ + + /* + * Check whether the kernel knows about the various + * compression methods we might request. + */ +#if BSDCOMPRESS_SUPPORT + /* FIXME: we don't need to test if BSD compress is available + * if BSDCOMPRESS_SUPPORT is set, it is. + */ + if (go->bsd_compress) { + opt_buf[0] = CI_BSD_COMPRESS; + opt_buf[1] = CILEN_BSD_COMPRESS; + for (;;) { + if (go->bsd_bits < BSD_MIN_BITS) { + go->bsd_compress = 0; + break; + } + opt_buf[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits); + res = ccp_test(pcb, opt_buf, CILEN_BSD_COMPRESS, 0); + if (res > 0) { + break; + } else if (res < 0) { + go->bsd_compress = 0; + break; + } + go->bsd_bits--; + } + } +#endif /* BSDCOMPRESS_SUPPORT */ +#if DEFLATE_SUPPORT + /* FIXME: we don't need to test if deflate is available + * if DEFLATE_SUPPORT is set, it is. + */ + if (go->deflate) { + if (go->deflate_correct) { + opt_buf[0] = CI_DEFLATE; + opt_buf[1] = CILEN_DEFLATE; + opt_buf[3] = DEFLATE_CHK_SEQUENCE; + for (;;) { + if (go->deflate_size < DEFLATE_MIN_WORKS) { + go->deflate_correct = 0; + break; + } + opt_buf[2] = DEFLATE_MAKE_OPT(go->deflate_size); + res = ccp_test(pcb, opt_buf, CILEN_DEFLATE, 0); + if (res > 0) { + break; + } else if (res < 0) { + go->deflate_correct = 0; + break; + } + go->deflate_size--; + } + } + if (go->deflate_draft) { + opt_buf[0] = CI_DEFLATE_DRAFT; + opt_buf[1] = CILEN_DEFLATE; + opt_buf[3] = DEFLATE_CHK_SEQUENCE; + for (;;) { + if (go->deflate_size < DEFLATE_MIN_WORKS) { + go->deflate_draft = 0; + break; + } + opt_buf[2] = DEFLATE_MAKE_OPT(go->deflate_size); + res = ccp_test(pcb, opt_buf, CILEN_DEFLATE, 0); + if (res > 0) { + break; + } else if (res < 0) { + go->deflate_draft = 0; + break; + } + go->deflate_size--; + } + } + if (!go->deflate_correct && !go->deflate_draft) + go->deflate = 0; + } +#endif /* DEFLATE_SUPPORT */ +#if PREDICTOR_SUPPORT + /* FIXME: we don't need to test if predictor is available, + * if PREDICTOR_SUPPORT is set, it is. + */ + if (go->predictor_1) { + opt_buf[0] = CI_PREDICTOR_1; + opt_buf[1] = CILEN_PREDICTOR_1; + if (ccp_test(pcb, opt_buf, CILEN_PREDICTOR_1, 0) <= 0) + go->predictor_1 = 0; + } + if (go->predictor_2) { + opt_buf[0] = CI_PREDICTOR_2; + opt_buf[1] = CILEN_PREDICTOR_2; + if (ccp_test(pcb, opt_buf, CILEN_PREDICTOR_2, 0) <= 0) + go->predictor_2 = 0; + } +#endif /* PREDICTOR_SUPPORT */ +} + +/* + * ccp_cilen - Return total length of our configuration info. + */ +static int ccp_cilen(fsm *f) { + ppp_pcb *pcb = f->pcb; + ccp_options *go = &pcb->ccp_gotoptions; + + return 0 +#if BSDCOMPRESS_SUPPORT + + (go->bsd_compress? CILEN_BSD_COMPRESS: 0) +#endif /* BSDCOMPRESS_SUPPORT */ +#if DEFLATE_SUPPORT + + (go->deflate && go->deflate_correct? CILEN_DEFLATE: 0) + + (go->deflate && go->deflate_draft? CILEN_DEFLATE: 0) +#endif /* DEFLATE_SUPPORT */ +#if PREDICTOR_SUPPORT + + (go->predictor_1? CILEN_PREDICTOR_1: 0) + + (go->predictor_2? CILEN_PREDICTOR_2: 0) +#endif /* PREDICTOR_SUPPORT */ +#if MPPE_SUPPORT + + (go->mppe? CILEN_MPPE: 0) +#endif /* MPPE_SUPPORT */ + ; +} + +/* + * ccp_addci - put our requests in a packet. + */ +static void ccp_addci(fsm *f, u_char *p, int *lenp) { + ppp_pcb *pcb = f->pcb; + ccp_options *go = &pcb->ccp_gotoptions; + u_char *p0 = p; + + /* + * Add the compression types that we can receive, in decreasing + * preference order. + */ +#if MPPE_SUPPORT + if (go->mppe) { + p[0] = CI_MPPE; + p[1] = CILEN_MPPE; + MPPE_OPTS_TO_CI(go->mppe, &p[2]); + mppe_init(pcb, &pcb->mppe_decomp, go->mppe); + p += CILEN_MPPE; + } +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT + if (go->deflate) { + if (go->deflate_correct) { + p[0] = CI_DEFLATE; + p[1] = CILEN_DEFLATE; + p[2] = DEFLATE_MAKE_OPT(go->deflate_size); + p[3] = DEFLATE_CHK_SEQUENCE; + p += CILEN_DEFLATE; + } + if (go->deflate_draft) { + p[0] = CI_DEFLATE_DRAFT; + p[1] = CILEN_DEFLATE; + p[2] = p[2 - CILEN_DEFLATE]; + p[3] = DEFLATE_CHK_SEQUENCE; + p += CILEN_DEFLATE; + } + } +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + if (go->bsd_compress) { + p[0] = CI_BSD_COMPRESS; + p[1] = CILEN_BSD_COMPRESS; + p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits); + p += CILEN_BSD_COMPRESS; + } +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + /* XXX Should Predictor 2 be preferable to Predictor 1? */ + if (go->predictor_1) { + p[0] = CI_PREDICTOR_1; + p[1] = CILEN_PREDICTOR_1; + p += CILEN_PREDICTOR_1; + } + if (go->predictor_2) { + p[0] = CI_PREDICTOR_2; + p[1] = CILEN_PREDICTOR_2; + p += CILEN_PREDICTOR_2; + } +#endif /* PREDICTOR_SUPPORT */ + + go->method = (p > p0)? p0[0]: 0; + + *lenp = p - p0; +} + +/* + * ccp_ackci - process a received configure-ack, and return + * 1 iff the packet was OK. + */ +static int ccp_ackci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + ccp_options *go = &pcb->ccp_gotoptions; +#if BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT + u_char *p0 = p; +#endif /* BSDCOMPRESS_SUPPORT || PREDICTOR_SUPPORT */ + +#if MPPE_SUPPORT + if (go->mppe) { + u_char opt_buf[CILEN_MPPE]; + + opt_buf[0] = CI_MPPE; + opt_buf[1] = CILEN_MPPE; + MPPE_OPTS_TO_CI(go->mppe, &opt_buf[2]); + if (len < CILEN_MPPE || memcmp(opt_buf, p, CILEN_MPPE)) + return 0; + p += CILEN_MPPE; + len -= CILEN_MPPE; + /* XXX Cope with first/fast ack */ + if (len == 0) + return 1; + } +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT + if (go->deflate) { + if (len < CILEN_DEFLATE + || p[0] != (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT) + || p[1] != CILEN_DEFLATE + || p[2] != DEFLATE_MAKE_OPT(go->deflate_size) + || p[3] != DEFLATE_CHK_SEQUENCE) + return 0; + p += CILEN_DEFLATE; + len -= CILEN_DEFLATE; + /* XXX Cope with first/fast ack */ + if (len == 0) + return 1; + if (go->deflate_correct && go->deflate_draft) { + if (len < CILEN_DEFLATE + || p[0] != CI_DEFLATE_DRAFT + || p[1] != CILEN_DEFLATE + || p[2] != DEFLATE_MAKE_OPT(go->deflate_size) + || p[3] != DEFLATE_CHK_SEQUENCE) + return 0; + p += CILEN_DEFLATE; + len -= CILEN_DEFLATE; + } + } +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + if (go->bsd_compress) { + if (len < CILEN_BSD_COMPRESS + || p[0] != CI_BSD_COMPRESS || p[1] != CILEN_BSD_COMPRESS + || p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits)) + return 0; + p += CILEN_BSD_COMPRESS; + len -= CILEN_BSD_COMPRESS; + /* XXX Cope with first/fast ack */ + if (p == p0 && len == 0) + return 1; + } +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + if (go->predictor_1) { + if (len < CILEN_PREDICTOR_1 + || p[0] != CI_PREDICTOR_1 || p[1] != CILEN_PREDICTOR_1) + return 0; + p += CILEN_PREDICTOR_1; + len -= CILEN_PREDICTOR_1; + /* XXX Cope with first/fast ack */ + if (p == p0 && len == 0) + return 1; + } + if (go->predictor_2) { + if (len < CILEN_PREDICTOR_2 + || p[0] != CI_PREDICTOR_2 || p[1] != CILEN_PREDICTOR_2) + return 0; + p += CILEN_PREDICTOR_2; + len -= CILEN_PREDICTOR_2; + /* XXX Cope with first/fast ack */ + if (p == p0 && len == 0) + return 1; + } +#endif /* PREDICTOR_SUPPORT */ + + if (len != 0) + return 0; + return 1; +} + +/* + * ccp_nakci - process received configure-nak. + * Returns 1 iff the nak was OK. + */ +static int ccp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { + ppp_pcb *pcb = f->pcb; + ccp_options *go = &pcb->ccp_gotoptions; + ccp_options no; /* options we've seen already */ + ccp_options try_; /* options to ask for next time */ + LWIP_UNUSED_ARG(treat_as_reject); +#if !MPPE_SUPPORT && !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT + LWIP_UNUSED_ARG(p); + LWIP_UNUSED_ARG(len); +#endif /* !MPPE_SUPPORT && !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT */ + + memset(&no, 0, sizeof(no)); + try_ = *go; + +#if MPPE_SUPPORT + if (go->mppe && len >= CILEN_MPPE + && p[0] == CI_MPPE && p[1] == CILEN_MPPE) { + no.mppe = 1; + /* + * Peer wants us to use a different strength or other setting. + * Fail if we aren't willing to use his suggestion. + */ + MPPE_CI_TO_OPTS(&p[2], try_.mppe); + if ((try_.mppe & MPPE_OPT_STATEFUL) && pcb->settings.refuse_mppe_stateful) { + ppp_error("Refusing MPPE stateful mode offered by peer"); + try_.mppe = 0; + } else if (((go->mppe | MPPE_OPT_STATEFUL) & try_.mppe) != try_.mppe) { + /* Peer must have set options we didn't request (suggest) */ + try_.mppe = 0; + } + + if (!try_.mppe) { + ppp_error("MPPE required but peer negotiation failed"); + lcp_close(pcb, "MPPE required but peer negotiation failed"); + } + } +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT + if (go->deflate && len >= CILEN_DEFLATE + && p[0] == (go->deflate_correct? CI_DEFLATE: CI_DEFLATE_DRAFT) + && p[1] == CILEN_DEFLATE) { + no.deflate = 1; + /* + * Peer wants us to use a different code size or something. + * Stop asking for Deflate if we don't understand his suggestion. + */ + if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL + || DEFLATE_SIZE(p[2]) < DEFLATE_MIN_WORKS + || p[3] != DEFLATE_CHK_SEQUENCE) + try_.deflate = 0; + else if (DEFLATE_SIZE(p[2]) < go->deflate_size) + try_.deflate_size = DEFLATE_SIZE(p[2]); + p += CILEN_DEFLATE; + len -= CILEN_DEFLATE; + if (go->deflate_correct && go->deflate_draft + && len >= CILEN_DEFLATE && p[0] == CI_DEFLATE_DRAFT + && p[1] == CILEN_DEFLATE) { + p += CILEN_DEFLATE; + len -= CILEN_DEFLATE; + } + } +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + if (go->bsd_compress && len >= CILEN_BSD_COMPRESS + && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) { + no.bsd_compress = 1; + /* + * Peer wants us to use a different number of bits + * or a different version. + */ + if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION) + try_.bsd_compress = 0; + else if (BSD_NBITS(p[2]) < go->bsd_bits) + try_.bsd_bits = BSD_NBITS(p[2]); + p += CILEN_BSD_COMPRESS; + len -= CILEN_BSD_COMPRESS; + } +#endif /* BSDCOMPRESS_SUPPORT */ + + /* + * Predictor-1 and 2 have no options, so they can't be Naked. + * + * There may be remaining options but we ignore them. + */ + + if (f->state != PPP_FSM_OPENED) + *go = try_; + return 1; +} + +/* + * ccp_rejci - reject some of our suggested compression methods. + */ +static int ccp_rejci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + ccp_options *go = &pcb->ccp_gotoptions; + ccp_options try_; /* options to request next time */ + + try_ = *go; + + /* + * Cope with empty configure-rejects by ceasing to send + * configure-requests. + */ + if (len == 0 && pcb->ccp_all_rejected) + return -1; + +#if MPPE_SUPPORT + if (go->mppe && len >= CILEN_MPPE + && p[0] == CI_MPPE && p[1] == CILEN_MPPE) { + ppp_error("MPPE required but peer refused"); + lcp_close(pcb, "MPPE required but peer refused"); + p += CILEN_MPPE; + len -= CILEN_MPPE; + } +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT + if (go->deflate_correct && len >= CILEN_DEFLATE + && p[0] == CI_DEFLATE && p[1] == CILEN_DEFLATE) { + if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size) + || p[3] != DEFLATE_CHK_SEQUENCE) + return 0; /* Rej is bad */ + try_.deflate_correct = 0; + p += CILEN_DEFLATE; + len -= CILEN_DEFLATE; + } + if (go->deflate_draft && len >= CILEN_DEFLATE + && p[0] == CI_DEFLATE_DRAFT && p[1] == CILEN_DEFLATE) { + if (p[2] != DEFLATE_MAKE_OPT(go->deflate_size) + || p[3] != DEFLATE_CHK_SEQUENCE) + return 0; /* Rej is bad */ + try_.deflate_draft = 0; + p += CILEN_DEFLATE; + len -= CILEN_DEFLATE; + } + if (!try_.deflate_correct && !try_.deflate_draft) + try_.deflate = 0; +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + if (go->bsd_compress && len >= CILEN_BSD_COMPRESS + && p[0] == CI_BSD_COMPRESS && p[1] == CILEN_BSD_COMPRESS) { + if (p[2] != BSD_MAKE_OPT(BSD_CURRENT_VERSION, go->bsd_bits)) + return 0; + try_.bsd_compress = 0; + p += CILEN_BSD_COMPRESS; + len -= CILEN_BSD_COMPRESS; + } +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + if (go->predictor_1 && len >= CILEN_PREDICTOR_1 + && p[0] == CI_PREDICTOR_1 && p[1] == CILEN_PREDICTOR_1) { + try_.predictor_1 = 0; + p += CILEN_PREDICTOR_1; + len -= CILEN_PREDICTOR_1; + } + if (go->predictor_2 && len >= CILEN_PREDICTOR_2 + && p[0] == CI_PREDICTOR_2 && p[1] == CILEN_PREDICTOR_2) { + try_.predictor_2 = 0; + p += CILEN_PREDICTOR_2; + len -= CILEN_PREDICTOR_2; + } +#endif /* PREDICTOR_SUPPORT */ + + if (len != 0) + return 0; + + if (f->state != PPP_FSM_OPENED) + *go = try_; + + return 1; +} + +/* + * ccp_reqci - processed a received configure-request. + * Returns CONFACK, CONFNAK or CONFREJ and the packet modified + * appropriately. + */ +static int ccp_reqci(fsm *f, u_char *p, int *lenp, int dont_nak) { + ppp_pcb *pcb = f->pcb; + ccp_options *ho = &pcb->ccp_hisoptions; + ccp_options *ao = &pcb->ccp_allowoptions; + int ret, newret; +#if DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT + int res; + int nb; +#endif /* DEFLATE_SUPPORT || BSDCOMPRESS_SUPPORT */ + u_char *p0, *retp; + int len, clen, type; +#if MPPE_SUPPORT + u8_t rej_for_ci_mppe = 1; /* Are we rejecting based on a bad/missing */ + /* CI_MPPE, or due to other options? */ +#endif /* MPPE_SUPPORT */ + + ret = CONFACK; + retp = p0 = p; + len = *lenp; + + memset(ho, 0, sizeof(ccp_options)); + ho->method = (len > 0)? p[0]: 0; + + while (len > 0) { + newret = CONFACK; + if (len < 2 || p[1] < 2 || p[1] > len) { + /* length is bad */ + clen = len; + newret = CONFREJ; + + } else { + type = p[0]; + clen = p[1]; + + switch (type) { +#if MPPE_SUPPORT + case CI_MPPE: + if (!ao->mppe || clen != CILEN_MPPE) { + newret = CONFREJ; + break; + } + MPPE_CI_TO_OPTS(&p[2], ho->mppe); + + /* Nak if anything unsupported or unknown are set. */ + if (ho->mppe & MPPE_OPT_UNSUPPORTED) { + newret = CONFNAK; + ho->mppe &= ~MPPE_OPT_UNSUPPORTED; + } + if (ho->mppe & MPPE_OPT_UNKNOWN) { + newret = CONFNAK; + ho->mppe &= ~MPPE_OPT_UNKNOWN; + } + + /* Check state opt */ + if (ho->mppe & MPPE_OPT_STATEFUL) { + /* + * We can Nak and request stateless, but it's a + * lot easier to just assume the peer will request + * it if he can do it; stateful mode is bad over + * the Internet -- which is where we expect MPPE. + */ + if (pcb->settings.refuse_mppe_stateful) { + ppp_error("Refusing MPPE stateful mode offered by peer"); + newret = CONFREJ; + break; + } + } + + /* Find out which of {S,L} are set. */ + if ((ho->mppe & MPPE_OPT_128) + && (ho->mppe & MPPE_OPT_40)) { + /* Both are set, negotiate the strongest. */ + newret = CONFNAK; + if (ao->mppe & MPPE_OPT_128) + ho->mppe &= ~MPPE_OPT_40; + else if (ao->mppe & MPPE_OPT_40) + ho->mppe &= ~MPPE_OPT_128; + else { + newret = CONFREJ; + break; + } + } else if (ho->mppe & MPPE_OPT_128) { + if (!(ao->mppe & MPPE_OPT_128)) { + newret = CONFREJ; + break; + } + } else if (ho->mppe & MPPE_OPT_40) { + if (!(ao->mppe & MPPE_OPT_40)) { + newret = CONFREJ; + break; + } + } else { + /* Neither are set. */ + /* We cannot accept this. */ + newret = CONFNAK; + /* Give the peer our idea of what can be used, + so it can choose and confirm */ + ho->mppe = ao->mppe; + } + + /* rebuild the opts */ + MPPE_OPTS_TO_CI(ho->mppe, &p[2]); + if (newret == CONFACK) { + int mtu; + + mppe_init(pcb, &pcb->mppe_comp, ho->mppe); + /* + * We need to decrease the interface MTU by MPPE_PAD + * because MPPE frames **grow**. The kernel [must] + * allocate MPPE_PAD extra bytes in xmit buffers. + */ + mtu = netif_get_mtu(pcb); + if (mtu) + netif_set_mtu(pcb, mtu - MPPE_PAD); + else + newret = CONFREJ; + } + + /* + * We have accepted MPPE or are willing to negotiate + * MPPE parameters. A CONFREJ is due to subsequent + * (non-MPPE) processing. + */ + rej_for_ci_mppe = 0; + break; +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT + case CI_DEFLATE: + case CI_DEFLATE_DRAFT: + if (!ao->deflate || clen != CILEN_DEFLATE + || (!ao->deflate_correct && type == CI_DEFLATE) + || (!ao->deflate_draft && type == CI_DEFLATE_DRAFT)) { + newret = CONFREJ; + break; + } + + ho->deflate = 1; + ho->deflate_size = nb = DEFLATE_SIZE(p[2]); + if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL + || p[3] != DEFLATE_CHK_SEQUENCE + || nb > ao->deflate_size || nb < DEFLATE_MIN_WORKS) { + newret = CONFNAK; + if (!dont_nak) { + p[2] = DEFLATE_MAKE_OPT(ao->deflate_size); + p[3] = DEFLATE_CHK_SEQUENCE; + /* fall through to test this #bits below */ + } else + break; + } + + /* + * Check whether we can do Deflate with the window + * size they want. If the window is too big, reduce + * it until the kernel can cope and nak with that. + * We only check this for the first option. + */ + if (p == p0) { + for (;;) { + res = ccp_test(pcb, p, CILEN_DEFLATE, 1); + if (res > 0) + break; /* it's OK now */ + if (res < 0 || nb == DEFLATE_MIN_WORKS || dont_nak) { + newret = CONFREJ; + p[2] = DEFLATE_MAKE_OPT(ho->deflate_size); + break; + } + newret = CONFNAK; + --nb; + p[2] = DEFLATE_MAKE_OPT(nb); + } + } + break; +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + case CI_BSD_COMPRESS: + if (!ao->bsd_compress || clen != CILEN_BSD_COMPRESS) { + newret = CONFREJ; + break; + } + + ho->bsd_compress = 1; + ho->bsd_bits = nb = BSD_NBITS(p[2]); + if (BSD_VERSION(p[2]) != BSD_CURRENT_VERSION + || nb > ao->bsd_bits || nb < BSD_MIN_BITS) { + newret = CONFNAK; + if (!dont_nak) { + p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, ao->bsd_bits); + /* fall through to test this #bits below */ + } else + break; + } + + /* + * Check whether we can do BSD-Compress with the code + * size they want. If the code size is too big, reduce + * it until the kernel can cope and nak with that. + * We only check this for the first option. + */ + if (p == p0) { + for (;;) { + res = ccp_test(pcb, p, CILEN_BSD_COMPRESS, 1); + if (res > 0) + break; + if (res < 0 || nb == BSD_MIN_BITS || dont_nak) { + newret = CONFREJ; + p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, + ho->bsd_bits); + break; + } + newret = CONFNAK; + --nb; + p[2] = BSD_MAKE_OPT(BSD_CURRENT_VERSION, nb); + } + } + break; +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + case CI_PREDICTOR_1: + if (!ao->predictor_1 || clen != CILEN_PREDICTOR_1) { + newret = CONFREJ; + break; + } + + ho->predictor_1 = 1; + if (p == p0 + && ccp_test(pcb, p, CILEN_PREDICTOR_1, 1) <= 0) { + newret = CONFREJ; + } + break; + + case CI_PREDICTOR_2: + if (!ao->predictor_2 || clen != CILEN_PREDICTOR_2) { + newret = CONFREJ; + break; + } + + ho->predictor_2 = 1; + if (p == p0 + && ccp_test(pcb, p, CILEN_PREDICTOR_2, 1) <= 0) { + newret = CONFREJ; + } + break; +#endif /* PREDICTOR_SUPPORT */ + + default: + newret = CONFREJ; + } + } + + if (newret == CONFNAK && dont_nak) + newret = CONFREJ; + if (!(newret == CONFACK || (newret == CONFNAK && ret == CONFREJ))) { + /* we're returning this option */ + if (newret == CONFREJ && ret == CONFNAK) + retp = p0; + ret = newret; + if (p != retp) + MEMCPY(retp, p, clen); + retp += clen; + } + + p += clen; + len -= clen; + } + + if (ret != CONFACK) { + if (ret == CONFREJ && *lenp == retp - p0) + pcb->ccp_all_rejected = 1; + else + *lenp = retp - p0; + } +#if MPPE_SUPPORT + if (ret == CONFREJ && ao->mppe && rej_for_ci_mppe) { + ppp_error("MPPE required but peer negotiation failed"); + lcp_close(pcb, "MPPE required but peer negotiation failed"); + } +#endif /* MPPE_SUPPORT */ + return ret; +} + +/* + * Make a string name for a compression method (or 2). + */ +static const char *method_name(ccp_options *opt, ccp_options *opt2) { + static char result[64]; +#if !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT + LWIP_UNUSED_ARG(opt2); +#endif /* !DEFLATE_SUPPORT && !BSDCOMPRESS_SUPPORT */ + + if (!ccp_anycompress(opt)) + return "(none)"; + switch (opt->method) { +#if MPPE_SUPPORT + case CI_MPPE: + { + char *p = result; + char *q = result + sizeof(result); /* 1 past result */ + + ppp_slprintf(p, q - p, "MPPE "); + p += 5; + if (opt->mppe & MPPE_OPT_128) { + ppp_slprintf(p, q - p, "128-bit "); + p += 8; + } + if (opt->mppe & MPPE_OPT_40) { + ppp_slprintf(p, q - p, "40-bit "); + p += 7; + } + if (opt->mppe & MPPE_OPT_STATEFUL) + ppp_slprintf(p, q - p, "stateful"); + else + ppp_slprintf(p, q - p, "stateless"); + + break; + } +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT + case CI_DEFLATE: + case CI_DEFLATE_DRAFT: + if (opt2 != NULL && opt2->deflate_size != opt->deflate_size) + ppp_slprintf(result, sizeof(result), "Deflate%s (%d/%d)", + (opt->method == CI_DEFLATE_DRAFT? "(old#)": ""), + opt->deflate_size, opt2->deflate_size); + else + ppp_slprintf(result, sizeof(result), "Deflate%s (%d)", + (opt->method == CI_DEFLATE_DRAFT? "(old#)": ""), + opt->deflate_size); + break; +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + case CI_BSD_COMPRESS: + if (opt2 != NULL && opt2->bsd_bits != opt->bsd_bits) + ppp_slprintf(result, sizeof(result), "BSD-Compress (%d/%d)", + opt->bsd_bits, opt2->bsd_bits); + else + ppp_slprintf(result, sizeof(result), "BSD-Compress (%d)", + opt->bsd_bits); + break; +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + case CI_PREDICTOR_1: + return "Predictor 1"; + case CI_PREDICTOR_2: + return "Predictor 2"; +#endif /* PREDICTOR_SUPPORT */ + default: + ppp_slprintf(result, sizeof(result), "Method %d", opt->method); + } + return result; +} + +/* + * CCP has come up - inform the kernel driver and log a message. + */ +static void ccp_up(fsm *f) { + ppp_pcb *pcb = f->pcb; + ccp_options *go = &pcb->ccp_gotoptions; + ccp_options *ho = &pcb->ccp_hisoptions; + char method1[64]; + + ccp_set(pcb, 1, 1, go->method, ho->method); + if (ccp_anycompress(go)) { + if (ccp_anycompress(ho)) { + if (go->method == ho->method) { + ppp_notice("%s compression enabled", method_name(go, ho)); + } else { + ppp_strlcpy(method1, method_name(go, NULL), sizeof(method1)); + ppp_notice("%s / %s compression enabled", + method1, method_name(ho, NULL)); + } + } else + ppp_notice("%s receive compression enabled", method_name(go, NULL)); + } else if (ccp_anycompress(ho)) + ppp_notice("%s transmit compression enabled", method_name(ho, NULL)); +#if MPPE_SUPPORT + if (go->mppe) { + continue_networks(pcb); /* Bring up IP et al */ + } +#endif /* MPPE_SUPPORT */ +} + +/* + * CCP has gone down - inform the kernel driver. + */ +static void ccp_down(fsm *f) { + ppp_pcb *pcb = f->pcb; +#if MPPE_SUPPORT + ccp_options *go = &pcb->ccp_gotoptions; +#endif /* MPPE_SUPPORT */ + + if (pcb->ccp_localstate & RACK_PENDING) + UNTIMEOUT(ccp_rack_timeout, f); + pcb->ccp_localstate = 0; + ccp_set(pcb, 1, 0, 0, 0); +#if MPPE_SUPPORT + if (go->mppe) { + go->mppe = 0; + if (pcb->lcp_fsm.state == PPP_FSM_OPENED) { + /* If LCP is not already going down, make sure it does. */ + ppp_error("MPPE disabled"); + lcp_close(pcb, "MPPE disabled"); + } + } +#endif /* MPPE_SUPPORT */ +} + +#if PRINTPKT_SUPPORT +/* + * Print the contents of a CCP packet. + */ +static const char* const ccp_codenames[] = { + "ConfReq", "ConfAck", "ConfNak", "ConfRej", + "TermReq", "TermAck", "CodeRej", + NULL, NULL, NULL, NULL, NULL, NULL, + "ResetReq", "ResetAck", +}; + +static int ccp_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg) { + const u_char *p0, *optend; + int code, id, len; + int optlen; + + p0 = p; + if (plen < HEADERLEN) + return 0; + code = p[0]; + id = p[1]; + len = (p[2] << 8) + p[3]; + if (len < HEADERLEN || len > plen) + return 0; + + if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(ccp_codenames) && ccp_codenames[code-1] != NULL) + printer(arg, " %s", ccp_codenames[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= HEADERLEN; + p += HEADERLEN; + + switch (code) { + case CONFREQ: + case CONFACK: + case CONFNAK: + case CONFREJ: + /* print list of possible compression methods */ + while (len >= 2) { + code = p[0]; + optlen = p[1]; + if (optlen < 2 || optlen > len) + break; + printer(arg, " <"); + len -= optlen; + optend = p + optlen; + switch (code) { +#if MPPE_SUPPORT + case CI_MPPE: + if (optlen >= CILEN_MPPE) { + u_char mppe_opts; + + MPPE_CI_TO_OPTS(&p[2], mppe_opts); + printer(arg, "mppe %s %s %s %s %s %s%s", + (p[2] & MPPE_H_BIT)? "+H": "-H", + (p[5] & MPPE_M_BIT)? "+M": "-M", + (p[5] & MPPE_S_BIT)? "+S": "-S", + (p[5] & MPPE_L_BIT)? "+L": "-L", + (p[5] & MPPE_D_BIT)? "+D": "-D", + (p[5] & MPPE_C_BIT)? "+C": "-C", + (mppe_opts & MPPE_OPT_UNKNOWN)? " +U": ""); + if (mppe_opts & MPPE_OPT_UNKNOWN) + printer(arg, " (%.2x %.2x %.2x %.2x)", + p[2], p[3], p[4], p[5]); + p += CILEN_MPPE; + } + break; +#endif /* MPPE_SUPPORT */ +#if DEFLATE_SUPPORT + case CI_DEFLATE: + case CI_DEFLATE_DRAFT: + if (optlen >= CILEN_DEFLATE) { + printer(arg, "deflate%s %d", + (code == CI_DEFLATE_DRAFT? "(old#)": ""), + DEFLATE_SIZE(p[2])); + if (DEFLATE_METHOD(p[2]) != DEFLATE_METHOD_VAL) + printer(arg, " method %d", DEFLATE_METHOD(p[2])); + if (p[3] != DEFLATE_CHK_SEQUENCE) + printer(arg, " check %d", p[3]); + p += CILEN_DEFLATE; + } + break; +#endif /* DEFLATE_SUPPORT */ +#if BSDCOMPRESS_SUPPORT + case CI_BSD_COMPRESS: + if (optlen >= CILEN_BSD_COMPRESS) { + printer(arg, "bsd v%d %d", BSD_VERSION(p[2]), + BSD_NBITS(p[2])); + p += CILEN_BSD_COMPRESS; + } + break; +#endif /* BSDCOMPRESS_SUPPORT */ +#if PREDICTOR_SUPPORT + case CI_PREDICTOR_1: + if (optlen >= CILEN_PREDICTOR_1) { + printer(arg, "predictor 1"); + p += CILEN_PREDICTOR_1; + } + break; + case CI_PREDICTOR_2: + if (optlen >= CILEN_PREDICTOR_2) { + printer(arg, "predictor 2"); + p += CILEN_PREDICTOR_2; + } + break; +#endif /* PREDICTOR_SUPPORT */ + default: + break; + } + while (p < optend) + printer(arg, " %.2x", *p++); + printer(arg, ">"); + } + break; + + case TERMACK: + case TERMREQ: + if (len > 0 && *p >= ' ' && *p < 0x7f) { + ppp_print_string(p, len, printer, arg); + p += len; + len = 0; + } + break; + default: + break; + } + + /* dump out the rest of the packet in hex */ + while (--len >= 0) + printer(arg, " %.2x", *p++); + + return p - p0; +} +#endif /* PRINTPKT_SUPPORT */ + +#if PPP_DATAINPUT +/* + * We have received a packet that the decompressor failed to + * decompress. Here we would expect to issue a reset-request, but + * Motorola has a patent on resetting the compressor as a result of + * detecting an error in the decompressed data after decompression. + * (See US patent 5,130,993; international patent publication number + * WO 91/10289; Australian patent 73296/91.) + * + * So we ask the kernel whether the error was detected after + * decompression; if it was, we take CCP down, thus disabling + * compression :-(, otherwise we issue the reset-request. + */ +static void ccp_datainput(ppp_pcb *pcb, u_char *pkt, int len) { + fsm *f; +#if MPPE_SUPPORT + ccp_options *go = &pcb->ccp_gotoptions; +#endif /* MPPE_SUPPORT */ + LWIP_UNUSED_ARG(pkt); + LWIP_UNUSED_ARG(len); + + f = &pcb->ccp_fsm; + if (f->state == PPP_FSM_OPENED) { + if (ccp_fatal_error(pcb)) { + /* + * Disable compression by taking CCP down. + */ + ppp_error("Lost compression sync: disabling compression"); + ccp_close(pcb, "Lost compression sync"); +#if MPPE_SUPPORT + /* + * If we were doing MPPE, we must also take the link down. + */ + if (go->mppe) { + ppp_error("Too many MPPE errors, closing LCP"); + lcp_close(pcb, "Too many MPPE errors"); + } +#endif /* MPPE_SUPPORT */ + } else { + /* + * Send a reset-request to reset the peer's compressor. + * We don't do that if we are still waiting for an + * acknowledgement to a previous reset-request. + */ + if (!(pcb->ccp_localstate & RACK_PENDING)) { + fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0); + TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT); + pcb->ccp_localstate |= RACK_PENDING; + } else + pcb->ccp_localstate |= RREQ_REPEAT; + } + } +} +#endif /* PPP_DATAINPUT */ + +/* + * We have received a packet that the decompressor failed to + * decompress. Issue a reset-request. + */ +void ccp_resetrequest(ppp_pcb *pcb) { + fsm *f = &pcb->ccp_fsm; + + if (f->state != PPP_FSM_OPENED) + return; + + /* + * Send a reset-request to reset the peer's compressor. + * We don't do that if we are still waiting for an + * acknowledgement to a previous reset-request. + */ + if (!(pcb->ccp_localstate & RACK_PENDING)) { + fsm_sdata(f, CCP_RESETREQ, f->reqid = ++f->id, NULL, 0); + TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT); + pcb->ccp_localstate |= RACK_PENDING; + } else + pcb->ccp_localstate |= RREQ_REPEAT; +} + +/* + * Timeout waiting for reset-ack. + */ +static void ccp_rack_timeout(void *arg) { + fsm *f = (fsm*)arg; + ppp_pcb *pcb = f->pcb; + + if (f->state == PPP_FSM_OPENED && (pcb->ccp_localstate & RREQ_REPEAT)) { + fsm_sdata(f, CCP_RESETREQ, f->reqid, NULL, 0); + TIMEOUT(ccp_rack_timeout, f, RACKTIMEOUT); + pcb->ccp_localstate &= ~RREQ_REPEAT; + } else + pcb->ccp_localstate &= ~RACK_PENDING; +} + +#endif /* PPP_SUPPORT && CCP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-md5.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-md5.c index 5a78944f..88f069f0 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-md5.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-md5.c @@ -1,126 +1,126 @@ -/* - * chap-md5.c - New CHAP/MD5 implementation. - * - * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#if 0 /* UNUSED */ -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/chap-new.h" -#include "netif/ppp/chap-md5.h" -#include "netif/ppp/magic.h" -#include "netif/ppp/pppcrypt.h" - -#define MD5_HASH_SIZE 16 -#define MD5_MIN_CHALLENGE 17 -#define MD5_MAX_CHALLENGE 24 -#define MD5_MIN_MAX_POWER_OF_TWO_CHALLENGE 3 /* 2^3-1 = 7, 17+7 = 24 */ - -#if PPP_SERVER -static void chap_md5_generate_challenge(ppp_pcb *pcb, unsigned char *cp) { - int clen; - LWIP_UNUSED_ARG(pcb); - - clen = MD5_MIN_CHALLENGE + magic_pow(MD5_MIN_MAX_POWER_OF_TWO_CHALLENGE); - *cp++ = clen; - magic_random_bytes(cp, clen); -} - -static int chap_md5_verify_response(ppp_pcb *pcb, int id, const char *name, - const unsigned char *secret, int secret_len, - const unsigned char *challenge, const unsigned char *response, - char *message, int message_space) { - lwip_md5_context ctx; - unsigned char idbyte = id; - unsigned char hash[MD5_HASH_SIZE]; - int challenge_len, response_len; - LWIP_UNUSED_ARG(name); - LWIP_UNUSED_ARG(pcb); - - challenge_len = *challenge++; - response_len = *response++; - if (response_len == MD5_HASH_SIZE) { - /* Generate hash of ID, secret, challenge */ - lwip_md5_init(&ctx); - lwip_md5_starts(&ctx); - lwip_md5_update(&ctx, &idbyte, 1); - lwip_md5_update(&ctx, secret, secret_len); - lwip_md5_update(&ctx, challenge, challenge_len); - lwip_md5_finish(&ctx, hash); - lwip_md5_free(&ctx); - - /* Test if our hash matches the peer's response */ - if (memcmp(hash, response, MD5_HASH_SIZE) == 0) { - ppp_slprintf(message, message_space, "Access granted"); - return 1; - } - } - ppp_slprintf(message, message_space, "Access denied"); - return 0; -} -#endif /* PPP_SERVER */ - -static void chap_md5_make_response(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, - const unsigned char *challenge, const char *secret, int secret_len, - unsigned char *private_) { - lwip_md5_context ctx; - unsigned char idbyte = id; - int challenge_len = *challenge++; - LWIP_UNUSED_ARG(our_name); - LWIP_UNUSED_ARG(private_); - LWIP_UNUSED_ARG(pcb); - - lwip_md5_init(&ctx); - lwip_md5_starts(&ctx); - lwip_md5_update(&ctx, &idbyte, 1); - lwip_md5_update(&ctx, (const u_char *)secret, secret_len); - lwip_md5_update(&ctx, challenge, challenge_len); - lwip_md5_finish(&ctx, &response[1]); - lwip_md5_free(&ctx); - response[0] = MD5_HASH_SIZE; -} - -const struct chap_digest_type md5_digest = { - CHAP_MD5, /* code */ -#if PPP_SERVER - chap_md5_generate_challenge, - chap_md5_verify_response, -#endif /* PPP_SERVER */ - chap_md5_make_response, - NULL, /* check_success */ - NULL, /* handle_failure */ -}; - -#endif /* PPP_SUPPORT && CHAP_SUPPORT */ +/* + * chap-md5.c - New CHAP/MD5 implementation. + * + * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#if 0 /* UNUSED */ +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/chap-new.h" +#include "netif/ppp/chap-md5.h" +#include "netif/ppp/magic.h" +#include "netif/ppp/pppcrypt.h" + +#define MD5_HASH_SIZE 16 +#define MD5_MIN_CHALLENGE 17 +#define MD5_MAX_CHALLENGE 24 +#define MD5_MIN_MAX_POWER_OF_TWO_CHALLENGE 3 /* 2^3-1 = 7, 17+7 = 24 */ + +#if PPP_SERVER +static void chap_md5_generate_challenge(ppp_pcb *pcb, unsigned char *cp) { + int clen; + LWIP_UNUSED_ARG(pcb); + + clen = MD5_MIN_CHALLENGE + magic_pow(MD5_MIN_MAX_POWER_OF_TWO_CHALLENGE); + *cp++ = clen; + magic_random_bytes(cp, clen); +} + +static int chap_md5_verify_response(ppp_pcb *pcb, int id, const char *name, + const unsigned char *secret, int secret_len, + const unsigned char *challenge, const unsigned char *response, + char *message, int message_space) { + lwip_md5_context ctx; + unsigned char idbyte = id; + unsigned char hash[MD5_HASH_SIZE]; + int challenge_len, response_len; + LWIP_UNUSED_ARG(name); + LWIP_UNUSED_ARG(pcb); + + challenge_len = *challenge++; + response_len = *response++; + if (response_len == MD5_HASH_SIZE) { + /* Generate hash of ID, secret, challenge */ + lwip_md5_init(&ctx); + lwip_md5_starts(&ctx); + lwip_md5_update(&ctx, &idbyte, 1); + lwip_md5_update(&ctx, secret, secret_len); + lwip_md5_update(&ctx, challenge, challenge_len); + lwip_md5_finish(&ctx, hash); + lwip_md5_free(&ctx); + + /* Test if our hash matches the peer's response */ + if (memcmp(hash, response, MD5_HASH_SIZE) == 0) { + ppp_slprintf(message, message_space, "Access granted"); + return 1; + } + } + ppp_slprintf(message, message_space, "Access denied"); + return 0; +} +#endif /* PPP_SERVER */ + +static void chap_md5_make_response(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, + const unsigned char *challenge, const char *secret, int secret_len, + unsigned char *private_) { + lwip_md5_context ctx; + unsigned char idbyte = id; + int challenge_len = *challenge++; + LWIP_UNUSED_ARG(our_name); + LWIP_UNUSED_ARG(private_); + LWIP_UNUSED_ARG(pcb); + + lwip_md5_init(&ctx); + lwip_md5_starts(&ctx); + lwip_md5_update(&ctx, &idbyte, 1); + lwip_md5_update(&ctx, (const u_char *)secret, secret_len); + lwip_md5_update(&ctx, challenge, challenge_len); + lwip_md5_finish(&ctx, &response[1]); + lwip_md5_free(&ctx); + response[0] = MD5_HASH_SIZE; +} + +const struct chap_digest_type md5_digest = { + CHAP_MD5, /* code */ +#if PPP_SERVER + chap_md5_generate_challenge, + chap_md5_verify_response, +#endif /* PPP_SERVER */ + chap_md5_make_response, + NULL, /* check_success */ + NULL, /* handle_failure */ +}; + +#endif /* PPP_SUPPORT && CHAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-new.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-new.c index 486d7e10..485122d2 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-new.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap-new.c @@ -1,677 +1,677 @@ -/* - * chap-new.c - New CHAP implementation. - * - * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#if 0 /* UNUSED */ -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#if 0 /* UNUSED */ -#include "session.h" -#endif /* UNUSED */ - -#include "netif/ppp/chap-new.h" -#include "netif/ppp/chap-md5.h" -#if MSCHAP_SUPPORT -#include "netif/ppp/chap_ms.h" -#endif -#include "netif/ppp/magic.h" - -#if 0 /* UNUSED */ -/* Hook for a plugin to validate CHAP challenge */ -int (*chap_verify_hook)(const char *name, const char *ourname, int id, - const struct chap_digest_type *digest, - const unsigned char *challenge, const unsigned char *response, - char *message, int message_space) = NULL; -#endif /* UNUSED */ - -#if PPP_OPTIONS -/* - * Command-line options. - */ -static option_t chap_option_list[] = { - { "chap-restart", o_int, &chap_timeout_time, - "Set timeout for CHAP", OPT_PRIO }, - { "chap-max-challenge", o_int, &pcb->settings.chap_max_transmits, - "Set max #xmits for challenge", OPT_PRIO }, - { "chap-interval", o_int, &pcb->settings.chap_rechallenge_time, - "Set interval for rechallenge", OPT_PRIO }, - { NULL } -}; -#endif /* PPP_OPTIONS */ - - -/* Values for flags in chap_client_state and chap_server_state */ -#define LOWERUP 1 -#define AUTH_STARTED 2 -#define AUTH_DONE 4 -#define AUTH_FAILED 8 -#define TIMEOUT_PENDING 0x10 -#define CHALLENGE_VALID 0x20 - -/* - * Prototypes. - */ -static void chap_init(ppp_pcb *pcb); -static void chap_lowerup(ppp_pcb *pcb); -static void chap_lowerdown(ppp_pcb *pcb); -#if PPP_SERVER -static void chap_timeout(void *arg); -static void chap_generate_challenge(ppp_pcb *pcb); -static void chap_handle_response(ppp_pcb *pcb, int code, - unsigned char *pkt, int len); -static int chap_verify_response(ppp_pcb *pcb, const char *name, const char *ourname, int id, - const struct chap_digest_type *digest, - const unsigned char *challenge, const unsigned char *response, - char *message, int message_space); -#endif /* PPP_SERVER */ -static void chap_respond(ppp_pcb *pcb, int id, - unsigned char *pkt, int len); -static void chap_handle_status(ppp_pcb *pcb, int code, int id, - unsigned char *pkt, int len); -static void chap_protrej(ppp_pcb *pcb); -static void chap_input(ppp_pcb *pcb, unsigned char *pkt, int pktlen); -#if PRINTPKT_SUPPORT -static int chap_print_pkt(const unsigned char *p, int plen, - void (*printer) (void *, const char *, ...), void *arg); -#endif /* PRINTPKT_SUPPORT */ - -/* List of digest types that we know about */ -static const struct chap_digest_type* const chap_digests[] = { - &md5_digest, -#if MSCHAP_SUPPORT - &chapms_digest, - &chapms2_digest, -#endif /* MSCHAP_SUPPORT */ - NULL -}; - -/* - * chap_init - reset to initial state. - */ -static void chap_init(ppp_pcb *pcb) { - LWIP_UNUSED_ARG(pcb); - -#if 0 /* Not necessary, everything is cleared in ppp_new() */ - memset(&pcb->chap_client, 0, sizeof(chap_client_state)); -#if PPP_SERVER - memset(&pcb->chap_server, 0, sizeof(chap_server_state)); -#endif /* PPP_SERVER */ -#endif /* 0 */ -} - -/* - * chap_lowerup - we can start doing stuff now. - */ -static void chap_lowerup(ppp_pcb *pcb) { - - pcb->chap_client.flags |= LOWERUP; -#if PPP_SERVER - pcb->chap_server.flags |= LOWERUP; - if (pcb->chap_server.flags & AUTH_STARTED) - chap_timeout(pcb); -#endif /* PPP_SERVER */ -} - -static void chap_lowerdown(ppp_pcb *pcb) { - - pcb->chap_client.flags = 0; -#if PPP_SERVER - if (pcb->chap_server.flags & TIMEOUT_PENDING) - UNTIMEOUT(chap_timeout, pcb); - pcb->chap_server.flags = 0; -#endif /* PPP_SERVER */ -} - -#if PPP_SERVER -/* - * chap_auth_peer - Start authenticating the peer. - * If the lower layer is already up, we start sending challenges, - * otherwise we wait for the lower layer to come up. - */ -void chap_auth_peer(ppp_pcb *pcb, const char *our_name, int digest_code) { - const struct chap_digest_type *dp; - int i; - - if (pcb->chap_server.flags & AUTH_STARTED) { - ppp_error("CHAP: peer authentication already started!"); - return; - } - for (i = 0; (dp = chap_digests[i]) != NULL; ++i) - if (dp->code == digest_code) - break; - if (dp == NULL) - ppp_fatal("CHAP digest 0x%x requested but not available", - digest_code); - - pcb->chap_server.digest = dp; - pcb->chap_server.name = our_name; - /* Start with a random ID value */ - pcb->chap_server.id = magic(); - pcb->chap_server.flags |= AUTH_STARTED; - if (pcb->chap_server.flags & LOWERUP) - chap_timeout(pcb); -} -#endif /* PPP_SERVER */ - -/* - * chap_auth_with_peer - Prepare to authenticate ourselves to the peer. - * There isn't much to do until we receive a challenge. - */ -void chap_auth_with_peer(ppp_pcb *pcb, const char *our_name, int digest_code) { - const struct chap_digest_type *dp; - int i; - - if(NULL == our_name) - return; - - if (pcb->chap_client.flags & AUTH_STARTED) { - ppp_error("CHAP: authentication with peer already started!"); - return; - } - for (i = 0; (dp = chap_digests[i]) != NULL; ++i) - if (dp->code == digest_code) - break; - - if (dp == NULL) - ppp_fatal("CHAP digest 0x%x requested but not available", - digest_code); - - pcb->chap_client.digest = dp; - pcb->chap_client.name = our_name; - pcb->chap_client.flags |= AUTH_STARTED; -} - -#if PPP_SERVER -/* - * chap_timeout - It's time to send another challenge to the peer. - * This could be either a retransmission of a previous challenge, - * or a new challenge to start re-authentication. - */ -static void chap_timeout(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - struct pbuf *p; - - pcb->chap_server.flags &= ~TIMEOUT_PENDING; - if ((pcb->chap_server.flags & CHALLENGE_VALID) == 0) { - pcb->chap_server.challenge_xmits = 0; - chap_generate_challenge(pcb); - pcb->chap_server.flags |= CHALLENGE_VALID; - } else if (pcb->chap_server.challenge_xmits >= pcb->settings.chap_max_transmits) { - pcb->chap_server.flags &= ~CHALLENGE_VALID; - pcb->chap_server.flags |= AUTH_DONE | AUTH_FAILED; - auth_peer_fail(pcb, PPP_CHAP); - return; - } - - p = pbuf_alloc(PBUF_RAW, (u16_t)(pcb->chap_server.challenge_pktlen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - MEMCPY(p->payload, pcb->chap_server.challenge, pcb->chap_server.challenge_pktlen); - ppp_write(pcb, p); - ++pcb->chap_server.challenge_xmits; - pcb->chap_server.flags |= TIMEOUT_PENDING; - TIMEOUT(chap_timeout, arg, pcb->settings.chap_timeout_time); -} - -/* - * chap_generate_challenge - generate a challenge string and format - * the challenge packet in pcb->chap_server.challenge_pkt. - */ -static void chap_generate_challenge(ppp_pcb *pcb) { - int clen = 1, nlen, len; - unsigned char *p; - - p = pcb->chap_server.challenge; - MAKEHEADER(p, PPP_CHAP); - p += CHAP_HDRLEN; - pcb->chap_server.digest->generate_challenge(pcb, p); - clen = *p; - nlen = strlen(pcb->chap_server.name); - memcpy(p + 1 + clen, pcb->chap_server.name, nlen); - - len = CHAP_HDRLEN + 1 + clen + nlen; - pcb->chap_server.challenge_pktlen = PPP_HDRLEN + len; - - p = pcb->chap_server.challenge + PPP_HDRLEN; - p[0] = CHAP_CHALLENGE; - p[1] = ++pcb->chap_server.id; - p[2] = len >> 8; - p[3] = len; -} - -/* - * chap_handle_response - check the response to our challenge. - */ -static void chap_handle_response(ppp_pcb *pcb, int id, - unsigned char *pkt, int len) { - int response_len, ok, mlen; - const unsigned char *response; - unsigned char *outp; - struct pbuf *p; - const char *name = NULL; /* initialized to shut gcc up */ -#if 0 /* UNUSED */ - int (*verifier)(const char *, const char *, int, const struct chap_digest_type *, - const unsigned char *, const unsigned char *, char *, int); -#endif /* UNUSED */ - char rname[MAXNAMELEN+1]; - char message[256]; - - if ((pcb->chap_server.flags & LOWERUP) == 0) - return; - if (id != pcb->chap_server.challenge[PPP_HDRLEN+1] || len < 2) - return; - if (pcb->chap_server.flags & CHALLENGE_VALID) { - response = pkt; - GETCHAR(response_len, pkt); - len -= response_len + 1; /* length of name */ - name = (char *)pkt + response_len; - if (len < 0) - return; - - if (pcb->chap_server.flags & TIMEOUT_PENDING) { - pcb->chap_server.flags &= ~TIMEOUT_PENDING; - UNTIMEOUT(chap_timeout, pcb); - } -#if PPP_REMOTENAME - if (pcb->settings.explicit_remote) { - name = pcb->remote_name; - } else -#endif /* PPP_REMOTENAME */ - { - /* Null terminate and clean remote name. */ - ppp_slprintf(rname, sizeof(rname), "%.*v", len, name); - name = rname; - } - -#if 0 /* UNUSED */ - if (chap_verify_hook) - verifier = chap_verify_hook; - else - verifier = chap_verify_response; - ok = (*verifier)(name, pcb->chap_server.name, id, pcb->chap_server.digest, - pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN, - response, pcb->chap_server.message, sizeof(pcb->chap_server.message)); -#endif /* UNUSED */ - ok = chap_verify_response(pcb, name, pcb->chap_server.name, id, pcb->chap_server.digest, - pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN, - response, message, sizeof(message)); -#if 0 /* UNUSED */ - if (!ok || !auth_number()) { -#endif /* UNUSED */ - if (!ok) { - pcb->chap_server.flags |= AUTH_FAILED; - ppp_warn("Peer %q failed CHAP authentication", name); - } - } else if ((pcb->chap_server.flags & AUTH_DONE) == 0) - return; - - /* send the response */ - mlen = strlen(message); - len = CHAP_HDRLEN + mlen; - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +len), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (unsigned char *)p->payload; - MAKEHEADER(outp, PPP_CHAP); - - outp[0] = (pcb->chap_server.flags & AUTH_FAILED)? CHAP_FAILURE: CHAP_SUCCESS; - outp[1] = id; - outp[2] = len >> 8; - outp[3] = len; - if (mlen > 0) - memcpy(outp + CHAP_HDRLEN, message, mlen); - ppp_write(pcb, p); - - if (pcb->chap_server.flags & CHALLENGE_VALID) { - pcb->chap_server.flags &= ~CHALLENGE_VALID; - if (!(pcb->chap_server.flags & AUTH_DONE) && !(pcb->chap_server.flags & AUTH_FAILED)) { - -#if 0 /* UNUSED */ - /* - * Auth is OK, so now we need to check session restrictions - * to ensure everything is OK, but only if we used a - * plugin, and only if we're configured to check. This - * allows us to do PAM checks on PPP servers that - * authenticate against ActiveDirectory, and use AD for - * account info (like when using Winbind integrated with - * PAM). - */ - if (session_mgmt && - session_check(name, NULL, devnam, NULL) == 0) { - pcb->chap_server.flags |= AUTH_FAILED; - ppp_warn("Peer %q failed CHAP Session verification", name); - } -#endif /* UNUSED */ - - } - if (pcb->chap_server.flags & AUTH_FAILED) { - auth_peer_fail(pcb, PPP_CHAP); - } else { - if ((pcb->chap_server.flags & AUTH_DONE) == 0) - auth_peer_success(pcb, PPP_CHAP, - pcb->chap_server.digest->code, - name, strlen(name)); - if (pcb->settings.chap_rechallenge_time) { - pcb->chap_server.flags |= TIMEOUT_PENDING; - TIMEOUT(chap_timeout, pcb, - pcb->settings.chap_rechallenge_time); - } - } - pcb->chap_server.flags |= AUTH_DONE; - } -} - -/* - * chap_verify_response - check whether the peer's response matches - * what we think it should be. Returns 1 if it does (authentication - * succeeded), or 0 if it doesn't. - */ -static int chap_verify_response(ppp_pcb *pcb, const char *name, const char *ourname, int id, - const struct chap_digest_type *digest, - const unsigned char *challenge, const unsigned char *response, - char *message, int message_space) { - int ok; - unsigned char secret[MAXSECRETLEN]; - int secret_len; - - /* Get the secret that the peer is supposed to know */ - if (!get_secret(pcb, name, ourname, (char *)secret, &secret_len, 1)) { - ppp_error("No CHAP secret found for authenticating %q", name); - return 0; - } - ok = digest->verify_response(pcb, id, name, secret, secret_len, challenge, - response, message, message_space); - memset(secret, 0, sizeof(secret)); - - return ok; -} -#endif /* PPP_SERVER */ - -/* - * chap_respond - Generate and send a response to a challenge. - */ -static void chap_respond(ppp_pcb *pcb, int id, - unsigned char *pkt, int len) { - int clen, nlen; - int secret_len; - struct pbuf *p; - u_char *outp; - char rname[MAXNAMELEN+1]; - char secret[MAXSECRETLEN+1]; - - p = pbuf_alloc(PBUF_RAW, (u16_t)(RESP_MAX_PKTLEN), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - if ((pcb->chap_client.flags & (LOWERUP | AUTH_STARTED)) != (LOWERUP | AUTH_STARTED)) - return; /* not ready */ - if (len < 2 || len < pkt[0] + 1) - return; /* too short */ - clen = pkt[0]; - nlen = len - (clen + 1); - - /* Null terminate and clean remote name. */ - ppp_slprintf(rname, sizeof(rname), "%.*v", nlen, pkt + clen + 1); - -#if PPP_REMOTENAME - /* Microsoft doesn't send their name back in the PPP packet */ - if (pcb->settings.explicit_remote || (pcb->settings.remote_name[0] != 0 && rname[0] == 0)) - strlcpy(rname, pcb->settings.remote_name, sizeof(rname)); -#endif /* PPP_REMOTENAME */ - - /* get secret for authenticating ourselves with the specified host */ - if (!get_secret(pcb, pcb->chap_client.name, rname, secret, &secret_len, 0)) { - secret_len = 0; /* assume null secret if can't find one */ - ppp_warn("No CHAP secret found for authenticating us to %q", rname); - } - - outp = (u_char*)p->payload; - MAKEHEADER(outp, PPP_CHAP); - outp += CHAP_HDRLEN; - - pcb->chap_client.digest->make_response(pcb, outp, id, pcb->chap_client.name, pkt, - secret, secret_len, pcb->chap_client.priv); - memset(secret, 0, secret_len); - - clen = *outp; - nlen = strlen(pcb->chap_client.name); - memcpy(outp + clen + 1, pcb->chap_client.name, nlen); - - outp = (u_char*)p->payload + PPP_HDRLEN; - len = CHAP_HDRLEN + clen + 1 + nlen; - outp[0] = CHAP_RESPONSE; - outp[1] = id; - outp[2] = len >> 8; - outp[3] = len; - - pbuf_realloc(p, PPP_HDRLEN + len); - ppp_write(pcb, p); -} - -static void chap_handle_status(ppp_pcb *pcb, int code, int id, - unsigned char *pkt, int len) { - const char *msg = NULL; - LWIP_UNUSED_ARG(id); - - if ((pcb->chap_client.flags & (AUTH_DONE|AUTH_STARTED|LOWERUP)) - != (AUTH_STARTED|LOWERUP)) - return; - pcb->chap_client.flags |= AUTH_DONE; - - if (code == CHAP_SUCCESS) { - /* used for MS-CHAP v2 mutual auth, yuck */ - if (pcb->chap_client.digest->check_success != NULL) { - if (!(*pcb->chap_client.digest->check_success)(pcb, pkt, len, pcb->chap_client.priv)) - code = CHAP_FAILURE; - } else - msg = "CHAP authentication succeeded"; - } else { - if (pcb->chap_client.digest->handle_failure != NULL) - (*pcb->chap_client.digest->handle_failure)(pcb, pkt, len); - else - msg = "CHAP authentication failed"; - } - if (msg) { - if (len > 0) - ppp_info("%s: %.*v", msg, len, pkt); - else - ppp_info("%s", msg); - } - if (code == CHAP_SUCCESS) - auth_withpeer_success(pcb, PPP_CHAP, pcb->chap_client.digest->code); - else { - pcb->chap_client.flags |= AUTH_FAILED; - ppp_error("CHAP authentication failed"); - auth_withpeer_fail(pcb, PPP_CHAP); - } -} - -static void chap_input(ppp_pcb *pcb, unsigned char *pkt, int pktlen) { - unsigned char code, id; - int len; - - if (pktlen < CHAP_HDRLEN) - return; - GETCHAR(code, pkt); - GETCHAR(id, pkt); - GETSHORT(len, pkt); - if (len < CHAP_HDRLEN || len > pktlen) - return; - len -= CHAP_HDRLEN; - - switch (code) { - case CHAP_CHALLENGE: - chap_respond(pcb, id, pkt, len); - break; -#if PPP_SERVER - case CHAP_RESPONSE: - chap_handle_response(pcb, id, pkt, len); - break; -#endif /* PPP_SERVER */ - case CHAP_FAILURE: - case CHAP_SUCCESS: - chap_handle_status(pcb, code, id, pkt, len); - break; - default: - break; - } -} - -static void chap_protrej(ppp_pcb *pcb) { - -#if PPP_SERVER - if (pcb->chap_server.flags & TIMEOUT_PENDING) { - pcb->chap_server.flags &= ~TIMEOUT_PENDING; - UNTIMEOUT(chap_timeout, pcb); - } - if (pcb->chap_server.flags & AUTH_STARTED) { - pcb->chap_server.flags = 0; - auth_peer_fail(pcb, PPP_CHAP); - } -#endif /* PPP_SERVER */ - if ((pcb->chap_client.flags & (AUTH_STARTED|AUTH_DONE)) == AUTH_STARTED) { - pcb->chap_client.flags &= ~AUTH_STARTED; - ppp_error("CHAP authentication failed due to protocol-reject"); - auth_withpeer_fail(pcb, PPP_CHAP); - } -} - -#if PRINTPKT_SUPPORT -/* - * chap_print_pkt - print the contents of a CHAP packet. - */ -static const char* const chap_code_names[] = { - "Challenge", "Response", "Success", "Failure" -}; - -static int chap_print_pkt(const unsigned char *p, int plen, - void (*printer) (void *, const char *, ...), void *arg) { - int code, id, len; - int clen, nlen; - unsigned char x; - - if (plen < CHAP_HDRLEN) - return 0; - GETCHAR(code, p); - GETCHAR(id, p); - GETSHORT(len, p); - if (len < CHAP_HDRLEN || len > plen) - return 0; - - if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(chap_code_names)) - printer(arg, " %s", chap_code_names[code-1]); - else - printer(arg, " code=0x%x", code); - printer(arg, " id=0x%x", id); - len -= CHAP_HDRLEN; - switch (code) { - case CHAP_CHALLENGE: - case CHAP_RESPONSE: - if (len < 1) - break; - clen = p[0]; - if (len < clen + 1) - break; - ++p; - nlen = len - clen - 1; - printer(arg, " <"); - for (; clen > 0; --clen) { - GETCHAR(x, p); - printer(arg, "%.2x", x); - } - printer(arg, ">, name = "); - ppp_print_string(p, nlen, printer, arg); - break; - case CHAP_FAILURE: - case CHAP_SUCCESS: - printer(arg, " "); - ppp_print_string(p, len, printer, arg); - break; - default: - for (clen = len; clen > 0; --clen) { - GETCHAR(x, p); - printer(arg, " %.2x", x); - } - /* no break */ - } - - return len + CHAP_HDRLEN; -} -#endif /* PRINTPKT_SUPPORT */ - -const struct protent chap_protent = { - PPP_CHAP, - chap_init, - chap_input, - chap_protrej, - chap_lowerup, - chap_lowerdown, - NULL, /* open */ - NULL, /* close */ -#if PRINTPKT_SUPPORT - chap_print_pkt, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - NULL, /* datainput */ -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "CHAP", /* name */ - NULL, /* data_name */ -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - chap_option_list, - NULL, /* check_options */ -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - NULL, - NULL -#endif /* DEMAND_SUPPORT */ -}; - -#endif /* PPP_SUPPORT && CHAP_SUPPORT */ +/* + * chap-new.c - New CHAP implementation. + * + * Copyright (c) 2003 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && CHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#if 0 /* UNUSED */ +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#if 0 /* UNUSED */ +#include "session.h" +#endif /* UNUSED */ + +#include "netif/ppp/chap-new.h" +#include "netif/ppp/chap-md5.h" +#if MSCHAP_SUPPORT +#include "netif/ppp/chap_ms.h" +#endif +#include "netif/ppp/magic.h" + +#if 0 /* UNUSED */ +/* Hook for a plugin to validate CHAP challenge */ +int (*chap_verify_hook)(const char *name, const char *ourname, int id, + const struct chap_digest_type *digest, + const unsigned char *challenge, const unsigned char *response, + char *message, int message_space) = NULL; +#endif /* UNUSED */ + +#if PPP_OPTIONS +/* + * Command-line options. + */ +static option_t chap_option_list[] = { + { "chap-restart", o_int, &chap_timeout_time, + "Set timeout for CHAP", OPT_PRIO }, + { "chap-max-challenge", o_int, &pcb->settings.chap_max_transmits, + "Set max #xmits for challenge", OPT_PRIO }, + { "chap-interval", o_int, &pcb->settings.chap_rechallenge_time, + "Set interval for rechallenge", OPT_PRIO }, + { NULL } +}; +#endif /* PPP_OPTIONS */ + + +/* Values for flags in chap_client_state and chap_server_state */ +#define LOWERUP 1 +#define AUTH_STARTED 2 +#define AUTH_DONE 4 +#define AUTH_FAILED 8 +#define TIMEOUT_PENDING 0x10 +#define CHALLENGE_VALID 0x20 + +/* + * Prototypes. + */ +static void chap_init(ppp_pcb *pcb); +static void chap_lowerup(ppp_pcb *pcb); +static void chap_lowerdown(ppp_pcb *pcb); +#if PPP_SERVER +static void chap_timeout(void *arg); +static void chap_generate_challenge(ppp_pcb *pcb); +static void chap_handle_response(ppp_pcb *pcb, int code, + unsigned char *pkt, int len); +static int chap_verify_response(ppp_pcb *pcb, const char *name, const char *ourname, int id, + const struct chap_digest_type *digest, + const unsigned char *challenge, const unsigned char *response, + char *message, int message_space); +#endif /* PPP_SERVER */ +static void chap_respond(ppp_pcb *pcb, int id, + unsigned char *pkt, int len); +static void chap_handle_status(ppp_pcb *pcb, int code, int id, + unsigned char *pkt, int len); +static void chap_protrej(ppp_pcb *pcb); +static void chap_input(ppp_pcb *pcb, unsigned char *pkt, int pktlen); +#if PRINTPKT_SUPPORT +static int chap_print_pkt(const unsigned char *p, int plen, + void (*printer) (void *, const char *, ...), void *arg); +#endif /* PRINTPKT_SUPPORT */ + +/* List of digest types that we know about */ +static const struct chap_digest_type* const chap_digests[] = { + &md5_digest, +#if MSCHAP_SUPPORT + &chapms_digest, + &chapms2_digest, +#endif /* MSCHAP_SUPPORT */ + NULL +}; + +/* + * chap_init - reset to initial state. + */ +static void chap_init(ppp_pcb *pcb) { + LWIP_UNUSED_ARG(pcb); + +#if 0 /* Not necessary, everything is cleared in ppp_new() */ + memset(&pcb->chap_client, 0, sizeof(chap_client_state)); +#if PPP_SERVER + memset(&pcb->chap_server, 0, sizeof(chap_server_state)); +#endif /* PPP_SERVER */ +#endif /* 0 */ +} + +/* + * chap_lowerup - we can start doing stuff now. + */ +static void chap_lowerup(ppp_pcb *pcb) { + + pcb->chap_client.flags |= LOWERUP; +#if PPP_SERVER + pcb->chap_server.flags |= LOWERUP; + if (pcb->chap_server.flags & AUTH_STARTED) + chap_timeout(pcb); +#endif /* PPP_SERVER */ +} + +static void chap_lowerdown(ppp_pcb *pcb) { + + pcb->chap_client.flags = 0; +#if PPP_SERVER + if (pcb->chap_server.flags & TIMEOUT_PENDING) + UNTIMEOUT(chap_timeout, pcb); + pcb->chap_server.flags = 0; +#endif /* PPP_SERVER */ +} + +#if PPP_SERVER +/* + * chap_auth_peer - Start authenticating the peer. + * If the lower layer is already up, we start sending challenges, + * otherwise we wait for the lower layer to come up. + */ +void chap_auth_peer(ppp_pcb *pcb, const char *our_name, int digest_code) { + const struct chap_digest_type *dp; + int i; + + if (pcb->chap_server.flags & AUTH_STARTED) { + ppp_error("CHAP: peer authentication already started!"); + return; + } + for (i = 0; (dp = chap_digests[i]) != NULL; ++i) + if (dp->code == digest_code) + break; + if (dp == NULL) + ppp_fatal("CHAP digest 0x%x requested but not available", + digest_code); + + pcb->chap_server.digest = dp; + pcb->chap_server.name = our_name; + /* Start with a random ID value */ + pcb->chap_server.id = magic(); + pcb->chap_server.flags |= AUTH_STARTED; + if (pcb->chap_server.flags & LOWERUP) + chap_timeout(pcb); +} +#endif /* PPP_SERVER */ + +/* + * chap_auth_with_peer - Prepare to authenticate ourselves to the peer. + * There isn't much to do until we receive a challenge. + */ +void chap_auth_with_peer(ppp_pcb *pcb, const char *our_name, int digest_code) { + const struct chap_digest_type *dp; + int i; + + if(NULL == our_name) + return; + + if (pcb->chap_client.flags & AUTH_STARTED) { + ppp_error("CHAP: authentication with peer already started!"); + return; + } + for (i = 0; (dp = chap_digests[i]) != NULL; ++i) + if (dp->code == digest_code) + break; + + if (dp == NULL) + ppp_fatal("CHAP digest 0x%x requested but not available", + digest_code); + + pcb->chap_client.digest = dp; + pcb->chap_client.name = our_name; + pcb->chap_client.flags |= AUTH_STARTED; +} + +#if PPP_SERVER +/* + * chap_timeout - It's time to send another challenge to the peer. + * This could be either a retransmission of a previous challenge, + * or a new challenge to start re-authentication. + */ +static void chap_timeout(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + struct pbuf *p; + + pcb->chap_server.flags &= ~TIMEOUT_PENDING; + if ((pcb->chap_server.flags & CHALLENGE_VALID) == 0) { + pcb->chap_server.challenge_xmits = 0; + chap_generate_challenge(pcb); + pcb->chap_server.flags |= CHALLENGE_VALID; + } else if (pcb->chap_server.challenge_xmits >= pcb->settings.chap_max_transmits) { + pcb->chap_server.flags &= ~CHALLENGE_VALID; + pcb->chap_server.flags |= AUTH_DONE | AUTH_FAILED; + auth_peer_fail(pcb, PPP_CHAP); + return; + } + + p = pbuf_alloc(PBUF_RAW, (u16_t)(pcb->chap_server.challenge_pktlen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + MEMCPY(p->payload, pcb->chap_server.challenge, pcb->chap_server.challenge_pktlen); + ppp_write(pcb, p); + ++pcb->chap_server.challenge_xmits; + pcb->chap_server.flags |= TIMEOUT_PENDING; + TIMEOUT(chap_timeout, arg, pcb->settings.chap_timeout_time); +} + +/* + * chap_generate_challenge - generate a challenge string and format + * the challenge packet in pcb->chap_server.challenge_pkt. + */ +static void chap_generate_challenge(ppp_pcb *pcb) { + int clen = 1, nlen, len; + unsigned char *p; + + p = pcb->chap_server.challenge; + MAKEHEADER(p, PPP_CHAP); + p += CHAP_HDRLEN; + pcb->chap_server.digest->generate_challenge(pcb, p); + clen = *p; + nlen = strlen(pcb->chap_server.name); + memcpy(p + 1 + clen, pcb->chap_server.name, nlen); + + len = CHAP_HDRLEN + 1 + clen + nlen; + pcb->chap_server.challenge_pktlen = PPP_HDRLEN + len; + + p = pcb->chap_server.challenge + PPP_HDRLEN; + p[0] = CHAP_CHALLENGE; + p[1] = ++pcb->chap_server.id; + p[2] = len >> 8; + p[3] = len; +} + +/* + * chap_handle_response - check the response to our challenge. + */ +static void chap_handle_response(ppp_pcb *pcb, int id, + unsigned char *pkt, int len) { + int response_len, ok, mlen; + const unsigned char *response; + unsigned char *outp; + struct pbuf *p; + const char *name = NULL; /* initialized to shut gcc up */ +#if 0 /* UNUSED */ + int (*verifier)(const char *, const char *, int, const struct chap_digest_type *, + const unsigned char *, const unsigned char *, char *, int); +#endif /* UNUSED */ + char rname[MAXNAMELEN+1]; + char message[256]; + + if ((pcb->chap_server.flags & LOWERUP) == 0) + return; + if (id != pcb->chap_server.challenge[PPP_HDRLEN+1] || len < 2) + return; + if (pcb->chap_server.flags & CHALLENGE_VALID) { + response = pkt; + GETCHAR(response_len, pkt); + len -= response_len + 1; /* length of name */ + name = (char *)pkt + response_len; + if (len < 0) + return; + + if (pcb->chap_server.flags & TIMEOUT_PENDING) { + pcb->chap_server.flags &= ~TIMEOUT_PENDING; + UNTIMEOUT(chap_timeout, pcb); + } +#if PPP_REMOTENAME + if (pcb->settings.explicit_remote) { + name = pcb->remote_name; + } else +#endif /* PPP_REMOTENAME */ + { + /* Null terminate and clean remote name. */ + ppp_slprintf(rname, sizeof(rname), "%.*v", len, name); + name = rname; + } + +#if 0 /* UNUSED */ + if (chap_verify_hook) + verifier = chap_verify_hook; + else + verifier = chap_verify_response; + ok = (*verifier)(name, pcb->chap_server.name, id, pcb->chap_server.digest, + pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN, + response, pcb->chap_server.message, sizeof(pcb->chap_server.message)); +#endif /* UNUSED */ + ok = chap_verify_response(pcb, name, pcb->chap_server.name, id, pcb->chap_server.digest, + pcb->chap_server.challenge + PPP_HDRLEN + CHAP_HDRLEN, + response, message, sizeof(message)); +#if 0 /* UNUSED */ + if (!ok || !auth_number()) { +#endif /* UNUSED */ + if (!ok) { + pcb->chap_server.flags |= AUTH_FAILED; + ppp_warn("Peer %q failed CHAP authentication", name); + } + } else if ((pcb->chap_server.flags & AUTH_DONE) == 0) + return; + + /* send the response */ + mlen = strlen(message); + len = CHAP_HDRLEN + mlen; + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +len), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (unsigned char *)p->payload; + MAKEHEADER(outp, PPP_CHAP); + + outp[0] = (pcb->chap_server.flags & AUTH_FAILED)? CHAP_FAILURE: CHAP_SUCCESS; + outp[1] = id; + outp[2] = len >> 8; + outp[3] = len; + if (mlen > 0) + memcpy(outp + CHAP_HDRLEN, message, mlen); + ppp_write(pcb, p); + + if (pcb->chap_server.flags & CHALLENGE_VALID) { + pcb->chap_server.flags &= ~CHALLENGE_VALID; + if (!(pcb->chap_server.flags & AUTH_DONE) && !(pcb->chap_server.flags & AUTH_FAILED)) { + +#if 0 /* UNUSED */ + /* + * Auth is OK, so now we need to check session restrictions + * to ensure everything is OK, but only if we used a + * plugin, and only if we're configured to check. This + * allows us to do PAM checks on PPP servers that + * authenticate against ActiveDirectory, and use AD for + * account info (like when using Winbind integrated with + * PAM). + */ + if (session_mgmt && + session_check(name, NULL, devnam, NULL) == 0) { + pcb->chap_server.flags |= AUTH_FAILED; + ppp_warn("Peer %q failed CHAP Session verification", name); + } +#endif /* UNUSED */ + + } + if (pcb->chap_server.flags & AUTH_FAILED) { + auth_peer_fail(pcb, PPP_CHAP); + } else { + if ((pcb->chap_server.flags & AUTH_DONE) == 0) + auth_peer_success(pcb, PPP_CHAP, + pcb->chap_server.digest->code, + name, strlen(name)); + if (pcb->settings.chap_rechallenge_time) { + pcb->chap_server.flags |= TIMEOUT_PENDING; + TIMEOUT(chap_timeout, pcb, + pcb->settings.chap_rechallenge_time); + } + } + pcb->chap_server.flags |= AUTH_DONE; + } +} + +/* + * chap_verify_response - check whether the peer's response matches + * what we think it should be. Returns 1 if it does (authentication + * succeeded), or 0 if it doesn't. + */ +static int chap_verify_response(ppp_pcb *pcb, const char *name, const char *ourname, int id, + const struct chap_digest_type *digest, + const unsigned char *challenge, const unsigned char *response, + char *message, int message_space) { + int ok; + unsigned char secret[MAXSECRETLEN]; + int secret_len; + + /* Get the secret that the peer is supposed to know */ + if (!get_secret(pcb, name, ourname, (char *)secret, &secret_len, 1)) { + ppp_error("No CHAP secret found for authenticating %q", name); + return 0; + } + ok = digest->verify_response(pcb, id, name, secret, secret_len, challenge, + response, message, message_space); + memset(secret, 0, sizeof(secret)); + + return ok; +} +#endif /* PPP_SERVER */ + +/* + * chap_respond - Generate and send a response to a challenge. + */ +static void chap_respond(ppp_pcb *pcb, int id, + unsigned char *pkt, int len) { + int clen, nlen; + int secret_len; + struct pbuf *p; + u_char *outp; + char rname[MAXNAMELEN+1]; + char secret[MAXSECRETLEN+1]; + + p = pbuf_alloc(PBUF_RAW, (u16_t)(RESP_MAX_PKTLEN), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + if ((pcb->chap_client.flags & (LOWERUP | AUTH_STARTED)) != (LOWERUP | AUTH_STARTED)) + return; /* not ready */ + if (len < 2 || len < pkt[0] + 1) + return; /* too short */ + clen = pkt[0]; + nlen = len - (clen + 1); + + /* Null terminate and clean remote name. */ + ppp_slprintf(rname, sizeof(rname), "%.*v", nlen, pkt + clen + 1); + +#if PPP_REMOTENAME + /* Microsoft doesn't send their name back in the PPP packet */ + if (pcb->settings.explicit_remote || (pcb->settings.remote_name[0] != 0 && rname[0] == 0)) + strlcpy(rname, pcb->settings.remote_name, sizeof(rname)); +#endif /* PPP_REMOTENAME */ + + /* get secret for authenticating ourselves with the specified host */ + if (!get_secret(pcb, pcb->chap_client.name, rname, secret, &secret_len, 0)) { + secret_len = 0; /* assume null secret if can't find one */ + ppp_warn("No CHAP secret found for authenticating us to %q", rname); + } + + outp = (u_char*)p->payload; + MAKEHEADER(outp, PPP_CHAP); + outp += CHAP_HDRLEN; + + pcb->chap_client.digest->make_response(pcb, outp, id, pcb->chap_client.name, pkt, + secret, secret_len, pcb->chap_client.priv); + memset(secret, 0, secret_len); + + clen = *outp; + nlen = strlen(pcb->chap_client.name); + memcpy(outp + clen + 1, pcb->chap_client.name, nlen); + + outp = (u_char*)p->payload + PPP_HDRLEN; + len = CHAP_HDRLEN + clen + 1 + nlen; + outp[0] = CHAP_RESPONSE; + outp[1] = id; + outp[2] = len >> 8; + outp[3] = len; + + pbuf_realloc(p, PPP_HDRLEN + len); + ppp_write(pcb, p); +} + +static void chap_handle_status(ppp_pcb *pcb, int code, int id, + unsigned char *pkt, int len) { + const char *msg = NULL; + LWIP_UNUSED_ARG(id); + + if ((pcb->chap_client.flags & (AUTH_DONE|AUTH_STARTED|LOWERUP)) + != (AUTH_STARTED|LOWERUP)) + return; + pcb->chap_client.flags |= AUTH_DONE; + + if (code == CHAP_SUCCESS) { + /* used for MS-CHAP v2 mutual auth, yuck */ + if (pcb->chap_client.digest->check_success != NULL) { + if (!(*pcb->chap_client.digest->check_success)(pcb, pkt, len, pcb->chap_client.priv)) + code = CHAP_FAILURE; + } else + msg = "CHAP authentication succeeded"; + } else { + if (pcb->chap_client.digest->handle_failure != NULL) + (*pcb->chap_client.digest->handle_failure)(pcb, pkt, len); + else + msg = "CHAP authentication failed"; + } + if (msg) { + if (len > 0) + ppp_info("%s: %.*v", msg, len, pkt); + else + ppp_info("%s", msg); + } + if (code == CHAP_SUCCESS) + auth_withpeer_success(pcb, PPP_CHAP, pcb->chap_client.digest->code); + else { + pcb->chap_client.flags |= AUTH_FAILED; + ppp_error("CHAP authentication failed"); + auth_withpeer_fail(pcb, PPP_CHAP); + } +} + +static void chap_input(ppp_pcb *pcb, unsigned char *pkt, int pktlen) { + unsigned char code, id; + int len; + + if (pktlen < CHAP_HDRLEN) + return; + GETCHAR(code, pkt); + GETCHAR(id, pkt); + GETSHORT(len, pkt); + if (len < CHAP_HDRLEN || len > pktlen) + return; + len -= CHAP_HDRLEN; + + switch (code) { + case CHAP_CHALLENGE: + chap_respond(pcb, id, pkt, len); + break; +#if PPP_SERVER + case CHAP_RESPONSE: + chap_handle_response(pcb, id, pkt, len); + break; +#endif /* PPP_SERVER */ + case CHAP_FAILURE: + case CHAP_SUCCESS: + chap_handle_status(pcb, code, id, pkt, len); + break; + default: + break; + } +} + +static void chap_protrej(ppp_pcb *pcb) { + +#if PPP_SERVER + if (pcb->chap_server.flags & TIMEOUT_PENDING) { + pcb->chap_server.flags &= ~TIMEOUT_PENDING; + UNTIMEOUT(chap_timeout, pcb); + } + if (pcb->chap_server.flags & AUTH_STARTED) { + pcb->chap_server.flags = 0; + auth_peer_fail(pcb, PPP_CHAP); + } +#endif /* PPP_SERVER */ + if ((pcb->chap_client.flags & (AUTH_STARTED|AUTH_DONE)) == AUTH_STARTED) { + pcb->chap_client.flags &= ~AUTH_STARTED; + ppp_error("CHAP authentication failed due to protocol-reject"); + auth_withpeer_fail(pcb, PPP_CHAP); + } +} + +#if PRINTPKT_SUPPORT +/* + * chap_print_pkt - print the contents of a CHAP packet. + */ +static const char* const chap_code_names[] = { + "Challenge", "Response", "Success", "Failure" +}; + +static int chap_print_pkt(const unsigned char *p, int plen, + void (*printer) (void *, const char *, ...), void *arg) { + int code, id, len; + int clen, nlen; + unsigned char x; + + if (plen < CHAP_HDRLEN) + return 0; + GETCHAR(code, p); + GETCHAR(id, p); + GETSHORT(len, p); + if (len < CHAP_HDRLEN || len > plen) + return 0; + + if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(chap_code_names)) + printer(arg, " %s", chap_code_names[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= CHAP_HDRLEN; + switch (code) { + case CHAP_CHALLENGE: + case CHAP_RESPONSE: + if (len < 1) + break; + clen = p[0]; + if (len < clen + 1) + break; + ++p; + nlen = len - clen - 1; + printer(arg, " <"); + for (; clen > 0; --clen) { + GETCHAR(x, p); + printer(arg, "%.2x", x); + } + printer(arg, ">, name = "); + ppp_print_string(p, nlen, printer, arg); + break; + case CHAP_FAILURE: + case CHAP_SUCCESS: + printer(arg, " "); + ppp_print_string(p, len, printer, arg); + break; + default: + for (clen = len; clen > 0; --clen) { + GETCHAR(x, p); + printer(arg, " %.2x", x); + } + /* no break */ + } + + return len + CHAP_HDRLEN; +} +#endif /* PRINTPKT_SUPPORT */ + +const struct protent chap_protent = { + PPP_CHAP, + chap_init, + chap_input, + chap_protrej, + chap_lowerup, + chap_lowerdown, + NULL, /* open */ + NULL, /* close */ +#if PRINTPKT_SUPPORT + chap_print_pkt, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + NULL, /* datainput */ +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "CHAP", /* name */ + NULL, /* data_name */ +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + chap_option_list, + NULL, /* check_options */ +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + NULL, + NULL +#endif /* DEMAND_SUPPORT */ +}; + +#endif /* PPP_SUPPORT && CHAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap_ms.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap_ms.c index c1533e01..5a989c9b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap_ms.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/chap_ms.c @@ -1,962 +1,962 @@ -/* - * chap_ms.c - Microsoft MS-CHAP compatible implementation. - * - * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -/* - * Modifications by Lauri Pesonen / lpesonen@clinet.fi, april 1997 - * - * Implemented LANManager type password response to MS-CHAP challenges. - * Now pppd provides both NT style and LANMan style blocks, and the - * prefered is set by option "ms-lanman". Default is to use NT. - * The hash text (StdText) was taken from Win95 RASAPI32.DLL. - * - * You should also use DOMAIN\\USERNAME as described in README.MSCHAP80 - */ - -/* - * Modifications by Frank Cusack, frank@google.com, March 2002. - * - * Implemented MS-CHAPv2 functionality, heavily based on sample - * implementation in RFC 2759. Implemented MPPE functionality, - * heavily based on sample implementation in RFC 3079. - * - * Copyright (c) 2002 Google, Inc. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && MSCHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#if 0 /* UNUSED */ -#include -#include -#include -#include -#include -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/chap-new.h" -#include "netif/ppp/chap_ms.h" -#include "netif/ppp/pppcrypt.h" -#include "netif/ppp/magic.h" -#if MPPE_SUPPORT -#include "netif/ppp/mppe.h" /* For mppe_sha1_pad*, mppe_set_key() */ -#endif /* MPPE_SUPPORT */ - -#define SHA1_SIGNATURE_SIZE 20 -#define MD4_SIGNATURE_SIZE 16 /* 16 bytes in a MD4 message digest */ -#define MAX_NT_PASSWORD 256 /* Max (Unicode) chars in an NT pass */ - -#define MS_CHAP_RESPONSE_LEN 49 /* Response length for MS-CHAP */ -#define MS_CHAP2_RESPONSE_LEN 49 /* Response length for MS-CHAPv2 */ -#define MS_AUTH_RESPONSE_LENGTH 40 /* MS-CHAPv2 authenticator response, */ - /* as ASCII */ - -/* Error codes for MS-CHAP failure messages. */ -#define MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS 646 -#define MS_CHAP_ERROR_ACCT_DISABLED 647 -#define MS_CHAP_ERROR_PASSWD_EXPIRED 648 -#define MS_CHAP_ERROR_NO_DIALIN_PERMISSION 649 -#define MS_CHAP_ERROR_AUTHENTICATION_FAILURE 691 -#define MS_CHAP_ERROR_CHANGING_PASSWORD 709 - -/* - * Offsets within the response field for MS-CHAP - */ -#define MS_CHAP_LANMANRESP 0 -#define MS_CHAP_LANMANRESP_LEN 24 -#define MS_CHAP_NTRESP 24 -#define MS_CHAP_NTRESP_LEN 24 -#define MS_CHAP_USENT 48 - -/* - * Offsets within the response field for MS-CHAP2 - */ -#define MS_CHAP2_PEER_CHALLENGE 0 -#define MS_CHAP2_PEER_CHAL_LEN 16 -#define MS_CHAP2_RESERVED_LEN 8 -#define MS_CHAP2_NTRESP 24 -#define MS_CHAP2_NTRESP_LEN 24 -#define MS_CHAP2_FLAGS 48 - -#if MPPE_SUPPORT -#if 0 /* UNUSED */ -/* These values are the RADIUS attribute values--see RFC 2548. */ -#define MPPE_ENC_POL_ENC_ALLOWED 1 -#define MPPE_ENC_POL_ENC_REQUIRED 2 -#define MPPE_ENC_TYPES_RC4_40 2 -#define MPPE_ENC_TYPES_RC4_128 4 - -/* used by plugins (using above values) */ -extern void set_mppe_enc_types(int, int); -#endif /* UNUSED */ -#endif /* MPPE_SUPPORT */ - -/* Are we the authenticator or authenticatee? For MS-CHAPv2 key derivation. */ -#define MS_CHAP2_AUTHENTICATEE 0 -#define MS_CHAP2_AUTHENTICATOR 1 - -static void ascii2unicode (const char[], int, u_char[]); -static void NTPasswordHash (u_char *, int, u_char[MD4_SIGNATURE_SIZE]); -static void ChallengeResponse (const u_char *, const u_char *, u_char[24]); -static void ChallengeHash (const u_char[16], const u_char *, const char *, u_char[8]); -static void ChapMS_NT (const u_char *, const char *, int, u_char[24]); -static void ChapMS2_NT (const u_char *, const u_char[16], const char *, const char *, int, - u_char[24]); -static void GenerateAuthenticatorResponsePlain - (const char*, int, u_char[24], const u_char[16], const u_char *, - const char *, u_char[41]); -#ifdef MSLANMAN -static void ChapMS_LANMan (u_char *, char *, int, u_char *); -#endif - -static void GenerateAuthenticatorResponse(const u_char PasswordHashHash[MD4_SIGNATURE_SIZE], - u_char NTResponse[24], const u_char PeerChallenge[16], - const u_char *rchallenge, const char *username, - u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1]); - -#if MPPE_SUPPORT -static void Set_Start_Key (ppp_pcb *pcb, const u_char *, const char *, int); -static void SetMasterKeys (ppp_pcb *pcb, const char *, int, u_char[24], int); -#endif /* MPPE_SUPPORT */ - -static void ChapMS (ppp_pcb *pcb, const u_char *, const char *, int, u_char *); -static void ChapMS2 (ppp_pcb *pcb, const u_char *, const u_char *, const char *, const char *, int, - u_char *, u_char[MS_AUTH_RESPONSE_LENGTH+1], int); - -#ifdef MSLANMAN -bool ms_lanman = 0; /* Use LanMan password instead of NT */ - /* Has meaning only with MS-CHAP challenges */ -#endif - -#if MPPE_SUPPORT -#ifdef DEBUGMPPEKEY -/* For MPPE debug */ -/* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */ -static char *mschap_challenge = NULL; -/* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */ -static char *mschap2_peer_challenge = NULL; -#endif - -#include "netif/ppp/fsm.h" /* Need to poke MPPE options */ -#include "netif/ppp/ccp.h" -#endif /* MPPE_SUPPORT */ - -#if PPP_OPTIONS -/* - * Command-line options. - */ -static option_t chapms_option_list[] = { -#ifdef MSLANMAN - { "ms-lanman", o_bool, &ms_lanman, - "Use LanMan passwd when using MS-CHAP", 1 }, -#endif -#ifdef DEBUGMPPEKEY - { "mschap-challenge", o_string, &mschap_challenge, - "specify CHAP challenge" }, - { "mschap2-peer-challenge", o_string, &mschap2_peer_challenge, - "specify CHAP peer challenge" }, -#endif - { NULL } -}; -#endif /* PPP_OPTIONS */ - -#if PPP_SERVER -/* - * chapms_generate_challenge - generate a challenge for MS-CHAP. - * For MS-CHAP the challenge length is fixed at 8 bytes. - * The length goes in challenge[0] and the actual challenge starts - * at challenge[1]. - */ -static void chapms_generate_challenge(ppp_pcb *pcb, unsigned char *challenge) { - LWIP_UNUSED_ARG(pcb); - - *challenge++ = 8; -#ifdef DEBUGMPPEKEY - if (mschap_challenge && strlen(mschap_challenge) == 8) - memcpy(challenge, mschap_challenge, 8); - else -#endif - magic_random_bytes(challenge, 8); -} - -static void chapms2_generate_challenge(ppp_pcb *pcb, unsigned char *challenge) { - LWIP_UNUSED_ARG(pcb); - - *challenge++ = 16; -#ifdef DEBUGMPPEKEY - if (mschap_challenge && strlen(mschap_challenge) == 16) - memcpy(challenge, mschap_challenge, 16); - else -#endif - magic_random_bytes(challenge, 16); -} - -static int chapms_verify_response(ppp_pcb *pcb, int id, const char *name, - const unsigned char *secret, int secret_len, - const unsigned char *challenge, const unsigned char *response, - char *message, int message_space) { - unsigned char md[MS_CHAP_RESPONSE_LEN]; - int diff; - int challenge_len, response_len; - LWIP_UNUSED_ARG(id); - LWIP_UNUSED_ARG(name); - - challenge_len = *challenge++; /* skip length, is 8 */ - response_len = *response++; - if (response_len != MS_CHAP_RESPONSE_LEN) - goto bad; - -#ifndef MSLANMAN - if (!response[MS_CHAP_USENT]) { - /* Should really propagate this into the error packet. */ - ppp_notice("Peer request for LANMAN auth not supported"); - goto bad; - } -#endif - - /* Generate the expected response. */ - ChapMS(pcb, (const u_char *)challenge, (const char *)secret, secret_len, md); - -#ifdef MSLANMAN - /* Determine which part of response to verify against */ - if (!response[MS_CHAP_USENT]) - diff = memcmp(&response[MS_CHAP_LANMANRESP], - &md[MS_CHAP_LANMANRESP], MS_CHAP_LANMANRESP_LEN); - else -#endif - diff = memcmp(&response[MS_CHAP_NTRESP], &md[MS_CHAP_NTRESP], - MS_CHAP_NTRESP_LEN); - - if (diff == 0) { - ppp_slprintf(message, message_space, "Access granted"); - return 1; - } - - bad: - /* See comments below for MS-CHAP V2 */ - ppp_slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0", - challenge_len, challenge); - return 0; -} - -static int chapms2_verify_response(ppp_pcb *pcb, int id, const char *name, - const unsigned char *secret, int secret_len, - const unsigned char *challenge, const unsigned char *response, - char *message, int message_space) { - unsigned char md[MS_CHAP2_RESPONSE_LEN]; - char saresponse[MS_AUTH_RESPONSE_LENGTH+1]; - int challenge_len, response_len; - LWIP_UNUSED_ARG(id); - - challenge_len = *challenge++; /* skip length, is 16 */ - response_len = *response++; - if (response_len != MS_CHAP2_RESPONSE_LEN) - goto bad; /* not even the right length */ - - /* Generate the expected response and our mutual auth. */ - ChapMS2(pcb, (const u_char*)challenge, (const u_char*)&response[MS_CHAP2_PEER_CHALLENGE], name, - (const char *)secret, secret_len, md, - (unsigned char *)saresponse, MS_CHAP2_AUTHENTICATOR); - - /* compare MDs and send the appropriate status */ - /* - * Per RFC 2759, success message must be formatted as - * "S= M=" - * where - * is the Authenticator Response (mutual auth) - * is a text message - * - * However, some versions of Windows (win98 tested) do not know - * about the M= part (required per RFC 2759) and flag - * it as an error (reported incorrectly as an encryption error - * to the user). Since the RFC requires it, and it can be - * useful information, we supply it if the peer is a conforming - * system. Luckily (?), win98 sets the Flags field to 0x04 - * (contrary to RFC requirements) so we can use that to - * distinguish between conforming and non-conforming systems. - * - * Special thanks to Alex Swiridov for - * help debugging this. - */ - if (memcmp(&md[MS_CHAP2_NTRESP], &response[MS_CHAP2_NTRESP], - MS_CHAP2_NTRESP_LEN) == 0) { - if (response[MS_CHAP2_FLAGS]) - ppp_slprintf(message, message_space, "S=%s", saresponse); - else - ppp_slprintf(message, message_space, "S=%s M=%s", - saresponse, "Access granted"); - return 1; - } - - bad: - /* - * Failure message must be formatted as - * "E=e R=r C=c V=v M=m" - * where - * e = error code (we use 691, ERROR_AUTHENTICATION_FAILURE) - * r = retry (we use 1, ok to retry) - * c = challenge to use for next response, we reuse previous - * v = Change Password version supported, we use 0 - * m = text message - * - * The M=m part is only for MS-CHAPv2. Neither win2k nor - * win98 (others untested) display the message to the user anyway. - * They also both ignore the E=e code. - * - * Note that it's safe to reuse the same challenge as we don't - * actually accept another response based on the error message - * (and no clients try to resend a response anyway). - * - * Basically, this whole bit is useless code, even the small - * implementation here is only because of overspecification. - */ - ppp_slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0 M=%s", - challenge_len, challenge, "Access denied"); - return 0; -} -#endif /* PPP_SERVER */ - -static void chapms_make_response(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, - const unsigned char *challenge, const char *secret, int secret_len, - unsigned char *private_) { - LWIP_UNUSED_ARG(id); - LWIP_UNUSED_ARG(our_name); - LWIP_UNUSED_ARG(private_); - challenge++; /* skip length, should be 8 */ - *response++ = MS_CHAP_RESPONSE_LEN; - ChapMS(pcb, challenge, secret, secret_len, response); -} - -static void chapms2_make_response(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, - const unsigned char *challenge, const char *secret, int secret_len, - unsigned char *private_) { - LWIP_UNUSED_ARG(id); - challenge++; /* skip length, should be 16 */ - *response++ = MS_CHAP2_RESPONSE_LEN; - ChapMS2(pcb, challenge, -#ifdef DEBUGMPPEKEY - mschap2_peer_challenge, -#else - NULL, -#endif - our_name, secret, secret_len, response, private_, - MS_CHAP2_AUTHENTICATEE); -} - -static int chapms2_check_success(ppp_pcb *pcb, unsigned char *msg, int len, unsigned char *private_) { - LWIP_UNUSED_ARG(pcb); - - if ((len < MS_AUTH_RESPONSE_LENGTH + 2) || - strncmp((char *)msg, "S=", 2) != 0) { - /* Packet does not start with "S=" */ - ppp_error("MS-CHAPv2 Success packet is badly formed."); - return 0; - } - msg += 2; - len -= 2; - if (len < MS_AUTH_RESPONSE_LENGTH - || memcmp(msg, private_, MS_AUTH_RESPONSE_LENGTH)) { - /* Authenticator Response did not match expected. */ - ppp_error("MS-CHAPv2 mutual authentication failed."); - return 0; - } - /* Authenticator Response matches. */ - msg += MS_AUTH_RESPONSE_LENGTH; /* Eat it */ - len -= MS_AUTH_RESPONSE_LENGTH; - if ((len >= 3) && !strncmp((char *)msg, " M=", 3)) { - msg += 3; /* Eat the delimiter */ - } else if (len) { - /* Packet has extra text which does not begin " M=" */ - ppp_error("MS-CHAPv2 Success packet is badly formed."); - return 0; - } - return 1; -} - -static void chapms_handle_failure(ppp_pcb *pcb, unsigned char *inp, int len) { - int err; - const char *p; - char msg[64]; - LWIP_UNUSED_ARG(pcb); - - /* We want a null-terminated string for strxxx(). */ - len = LWIP_MIN(len, 63); - MEMCPY(msg, inp, len); - msg[len] = 0; - p = msg; - - /* - * Deal with MS-CHAP formatted failure messages; just print the - * M= part (if any). For MS-CHAP we're not really supposed - * to use M=, but it shouldn't hurt. See - * chapms[2]_verify_response. - */ - if (!strncmp(p, "E=", 2)) - err = strtol(p+2, NULL, 10); /* Remember the error code. */ - else - goto print_msg; /* Message is badly formatted. */ - - if (len && ((p = strstr(p, " M=")) != NULL)) { - /* M= field found. */ - p += 3; - } else { - /* No M=; use the error code. */ - switch (err) { - case MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS: - p = "E=646 Restricted logon hours"; - break; - - case MS_CHAP_ERROR_ACCT_DISABLED: - p = "E=647 Account disabled"; - break; - - case MS_CHAP_ERROR_PASSWD_EXPIRED: - p = "E=648 Password expired"; - break; - - case MS_CHAP_ERROR_NO_DIALIN_PERMISSION: - p = "E=649 No dialin permission"; - break; - - case MS_CHAP_ERROR_AUTHENTICATION_FAILURE: - p = "E=691 Authentication failure"; - break; - - case MS_CHAP_ERROR_CHANGING_PASSWORD: - /* Should never see this, we don't support Change Password. */ - p = "E=709 Error changing password"; - break; - - default: - ppp_error("Unknown MS-CHAP authentication failure: %.*v", - len, inp); - return; - } - } -print_msg: - if (p != NULL) - ppp_error("MS-CHAP authentication failed: %v", p); -} - -static void ChallengeResponse(const u_char *challenge, - const u_char PasswordHash[MD4_SIGNATURE_SIZE], - u_char response[24]) { - u_char ZPasswordHash[21]; - lwip_des_context des; - u_char des_key[8]; - - BZERO(ZPasswordHash, sizeof(ZPasswordHash)); - MEMCPY(ZPasswordHash, PasswordHash, MD4_SIGNATURE_SIZE); - -#if 0 - dbglog("ChallengeResponse - ZPasswordHash %.*B", - sizeof(ZPasswordHash), ZPasswordHash); -#endif - - pppcrypt_56_to_64_bit_key(ZPasswordHash + 0, des_key); - lwip_des_init(&des); - lwip_des_setkey_enc(&des, des_key); - lwip_des_crypt_ecb(&des, challenge, response +0); - lwip_des_free(&des); - - pppcrypt_56_to_64_bit_key(ZPasswordHash + 7, des_key); - lwip_des_init(&des); - lwip_des_setkey_enc(&des, des_key); - lwip_des_crypt_ecb(&des, challenge, response +8); - lwip_des_free(&des); - - pppcrypt_56_to_64_bit_key(ZPasswordHash + 14, des_key); - lwip_des_init(&des); - lwip_des_setkey_enc(&des, des_key); - lwip_des_crypt_ecb(&des, challenge, response +16); - lwip_des_free(&des); - -#if 0 - dbglog("ChallengeResponse - response %.24B", response); -#endif -} - -static void ChallengeHash(const u_char PeerChallenge[16], const u_char *rchallenge, - const char *username, u_char Challenge[8]) { - lwip_sha1_context sha1Context; - u_char sha1Hash[SHA1_SIGNATURE_SIZE]; - const char *user; - - /* remove domain from "domain\username" */ - if ((user = strrchr(username, '\\')) != NULL) - ++user; - else - user = username; - - lwip_sha1_init(&sha1Context); - lwip_sha1_starts(&sha1Context); - lwip_sha1_update(&sha1Context, PeerChallenge, 16); - lwip_sha1_update(&sha1Context, rchallenge, 16); - lwip_sha1_update(&sha1Context, (const unsigned char*)user, strlen(user)); - lwip_sha1_finish(&sha1Context, sha1Hash); - lwip_sha1_free(&sha1Context); - - MEMCPY(Challenge, sha1Hash, 8); -} - -/* - * Convert the ASCII version of the password to Unicode. - * This implicitly supports 8-bit ISO8859/1 characters. - * This gives us the little-endian representation, which - * is assumed by all M$ CHAP RFCs. (Unicode byte ordering - * is machine-dependent.) - */ -static void ascii2unicode(const char ascii[], int ascii_len, u_char unicode[]) { - int i; - - BZERO(unicode, ascii_len * 2); - for (i = 0; i < ascii_len; i++) - unicode[i * 2] = (u_char) ascii[i]; -} - -static void NTPasswordHash(u_char *secret, int secret_len, u_char hash[MD4_SIGNATURE_SIZE]) { - lwip_md4_context md4Context; - - lwip_md4_init(&md4Context); - lwip_md4_starts(&md4Context); - lwip_md4_update(&md4Context, secret, secret_len); - lwip_md4_finish(&md4Context, hash); - lwip_md4_free(&md4Context); -} - -static void ChapMS_NT(const u_char *rchallenge, const char *secret, int secret_len, - u_char NTResponse[24]) { - u_char unicodePassword[MAX_NT_PASSWORD * 2]; - u_char PasswordHash[MD4_SIGNATURE_SIZE]; - - /* Hash the Unicode version of the secret (== password). */ - ascii2unicode(secret, secret_len, unicodePassword); - NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); - - ChallengeResponse(rchallenge, PasswordHash, NTResponse); -} - -static void ChapMS2_NT(const u_char *rchallenge, const u_char PeerChallenge[16], const char *username, - const char *secret, int secret_len, u_char NTResponse[24]) { - u_char unicodePassword[MAX_NT_PASSWORD * 2]; - u_char PasswordHash[MD4_SIGNATURE_SIZE]; - u_char Challenge[8]; - - ChallengeHash(PeerChallenge, rchallenge, username, Challenge); - - /* Hash the Unicode version of the secret (== password). */ - ascii2unicode(secret, secret_len, unicodePassword); - NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); - - ChallengeResponse(Challenge, PasswordHash, NTResponse); -} - -#ifdef MSLANMAN -static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */ - -static void ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len, - unsigned char *response) { - int i; - u_char UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */ - u_char PasswordHash[MD4_SIGNATURE_SIZE]; - lwip_des_context des; - u_char des_key[8]; - - /* LANMan password is case insensitive */ - BZERO(UcasePassword, sizeof(UcasePassword)); - for (i = 0; i < secret_len; i++) - UcasePassword[i] = (u_char)toupper(secret[i]); - - pppcrypt_56_to_64_bit_key(UcasePassword +0, des_key); - lwip_des_init(&des); - lwip_des_setkey_enc(&des, des_key); - lwip_des_crypt_ecb(&des, StdText, PasswordHash +0); - lwip_des_free(&des); - - pppcrypt_56_to_64_bit_key(UcasePassword +7, des_key); - lwip_des_init(&des); - lwip_des_setkey_enc(&des, des_key); - lwip_des_crypt_ecb(&des, StdText, PasswordHash +8); - lwip_des_free(&des); - - ChallengeResponse(rchallenge, PasswordHash, &response[MS_CHAP_LANMANRESP]); -} -#endif - - -static void GenerateAuthenticatorResponse(const u_char PasswordHashHash[MD4_SIGNATURE_SIZE], - u_char NTResponse[24], const u_char PeerChallenge[16], - const u_char *rchallenge, const char *username, - u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1]) { - /* - * "Magic" constants used in response generation, from RFC 2759. - */ - static const u_char Magic1[39] = /* "Magic server to client signing constant" */ - { 0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76, - 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65, - 0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67, - 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74 }; - static const u_char Magic2[41] = /* "Pad to make it do more than one iteration" */ - { 0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, - 0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F, - 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E, - 0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, - 0x6E }; - - int i; - lwip_sha1_context sha1Context; - u_char Digest[SHA1_SIGNATURE_SIZE]; - u_char Challenge[8]; - - lwip_sha1_init(&sha1Context); - lwip_sha1_starts(&sha1Context); - lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); - lwip_sha1_update(&sha1Context, NTResponse, 24); - lwip_sha1_update(&sha1Context, Magic1, sizeof(Magic1)); - lwip_sha1_finish(&sha1Context, Digest); - lwip_sha1_free(&sha1Context); - - ChallengeHash(PeerChallenge, rchallenge, username, Challenge); - - lwip_sha1_init(&sha1Context); - lwip_sha1_starts(&sha1Context); - lwip_sha1_update(&sha1Context, Digest, sizeof(Digest)); - lwip_sha1_update(&sha1Context, Challenge, sizeof(Challenge)); - lwip_sha1_update(&sha1Context, Magic2, sizeof(Magic2)); - lwip_sha1_finish(&sha1Context, Digest); - lwip_sha1_free(&sha1Context); - - /* Convert to ASCII hex string. */ - for (i = 0; i < LWIP_MAX((MS_AUTH_RESPONSE_LENGTH / 2), (int)sizeof(Digest)); i++) - sprintf((char *)&authResponse[i * 2], "%02X", Digest[i]); -} - - -static void GenerateAuthenticatorResponsePlain( - const char *secret, int secret_len, - u_char NTResponse[24], const u_char PeerChallenge[16], - const u_char *rchallenge, const char *username, - u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1]) { - u_char unicodePassword[MAX_NT_PASSWORD * 2]; - u_char PasswordHash[MD4_SIGNATURE_SIZE]; - u_char PasswordHashHash[MD4_SIGNATURE_SIZE]; - - /* Hash (x2) the Unicode version of the secret (== password). */ - ascii2unicode(secret, secret_len, unicodePassword); - NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); - NTPasswordHash(PasswordHash, sizeof(PasswordHash), - PasswordHashHash); - - GenerateAuthenticatorResponse(PasswordHashHash, NTResponse, PeerChallenge, - rchallenge, username, authResponse); -} - - -#if MPPE_SUPPORT -/* - * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079) - */ -static void Set_Start_Key(ppp_pcb *pcb, const u_char *rchallenge, const char *secret, int secret_len) { - u_char unicodePassword[MAX_NT_PASSWORD * 2]; - u_char PasswordHash[MD4_SIGNATURE_SIZE]; - u_char PasswordHashHash[MD4_SIGNATURE_SIZE]; - lwip_sha1_context sha1Context; - u_char Digest[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */ - - /* Hash (x2) the Unicode version of the secret (== password). */ - ascii2unicode(secret, secret_len, unicodePassword); - NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); - NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash); - - lwip_sha1_init(&sha1Context); - lwip_sha1_starts(&sha1Context); - lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); - lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); - lwip_sha1_update(&sha1Context, rchallenge, 8); - lwip_sha1_finish(&sha1Context, Digest); - lwip_sha1_free(&sha1Context); - - /* Same key in both directions. */ - mppe_set_key(pcb, &pcb->mppe_comp, Digest); - mppe_set_key(pcb, &pcb->mppe_decomp, Digest); - - pcb->mppe_keys_set = 1; -} - -/* - * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079) - */ -static void SetMasterKeys(ppp_pcb *pcb, const char *secret, int secret_len, u_char NTResponse[24], int IsServer) { - u_char unicodePassword[MAX_NT_PASSWORD * 2]; - u_char PasswordHash[MD4_SIGNATURE_SIZE]; - u_char PasswordHashHash[MD4_SIGNATURE_SIZE]; - lwip_sha1_context sha1Context; - u_char MasterKey[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */ - u_char Digest[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */ - const u_char *s; - - /* "This is the MPPE Master Key" */ - static const u_char Magic1[27] = - { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, - 0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d, - 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 }; - /* "On the client side, this is the send key; " - "on the server side, it is the receive key." */ - static const u_char Magic2[84] = - { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, - 0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20, - 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, - 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79, - 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, - 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65, - 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, - 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20, - 0x6b, 0x65, 0x79, 0x2e }; - /* "On the client side, this is the receive key; " - "on the server side, it is the send key." */ - static const u_char Magic3[84] = - { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, - 0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20, - 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, - 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20, - 0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, - 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, - 0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, - 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, - 0x6b, 0x65, 0x79, 0x2e }; - - /* Hash (x2) the Unicode version of the secret (== password). */ - ascii2unicode(secret, secret_len, unicodePassword); - NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); - NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash); - - lwip_sha1_init(&sha1Context); - lwip_sha1_starts(&sha1Context); - lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); - lwip_sha1_update(&sha1Context, NTResponse, 24); - lwip_sha1_update(&sha1Context, Magic1, sizeof(Magic1)); - lwip_sha1_finish(&sha1Context, MasterKey); - lwip_sha1_free(&sha1Context); - - /* - * generate send key - */ - if (IsServer) - s = Magic3; - else - s = Magic2; - lwip_sha1_init(&sha1Context); - lwip_sha1_starts(&sha1Context); - lwip_sha1_update(&sha1Context, MasterKey, 16); - lwip_sha1_update(&sha1Context, mppe_sha1_pad1, SHA1_PAD_SIZE); - lwip_sha1_update(&sha1Context, s, 84); - lwip_sha1_update(&sha1Context, mppe_sha1_pad2, SHA1_PAD_SIZE); - lwip_sha1_finish(&sha1Context, Digest); - lwip_sha1_free(&sha1Context); - - mppe_set_key(pcb, &pcb->mppe_comp, Digest); - - /* - * generate recv key - */ - if (IsServer) - s = Magic2; - else - s = Magic3; - lwip_sha1_init(&sha1Context); - lwip_sha1_starts(&sha1Context); - lwip_sha1_update(&sha1Context, MasterKey, 16); - lwip_sha1_update(&sha1Context, mppe_sha1_pad1, SHA1_PAD_SIZE); - lwip_sha1_update(&sha1Context, s, 84); - lwip_sha1_update(&sha1Context, mppe_sha1_pad2, SHA1_PAD_SIZE); - lwip_sha1_finish(&sha1Context, Digest); - lwip_sha1_free(&sha1Context); - - mppe_set_key(pcb, &pcb->mppe_decomp, Digest); - - pcb->mppe_keys_set = 1; -} - -#endif /* MPPE_SUPPORT */ - - -static void ChapMS(ppp_pcb *pcb, const u_char *rchallenge, const char *secret, int secret_len, - unsigned char *response) { -#if !MPPE_SUPPORT - LWIP_UNUSED_ARG(pcb); -#endif /* !MPPE_SUPPORT */ - BZERO(response, MS_CHAP_RESPONSE_LEN); - - ChapMS_NT(rchallenge, secret, secret_len, &response[MS_CHAP_NTRESP]); - -#ifdef MSLANMAN - ChapMS_LANMan(rchallenge, secret, secret_len, - &response[MS_CHAP_LANMANRESP]); - - /* preferred method is set by option */ - response[MS_CHAP_USENT] = !ms_lanman; -#else - response[MS_CHAP_USENT] = 1; -#endif - -#if MPPE_SUPPORT - Set_Start_Key(pcb, rchallenge, secret, secret_len); -#endif /* MPPE_SUPPORT */ -} - - -/* - * If PeerChallenge is NULL, one is generated and the PeerChallenge - * field of response is filled in. Call this way when generating a response. - * If PeerChallenge is supplied, it is copied into the PeerChallenge field. - * Call this way when verifying a response (or debugging). - * Do not call with PeerChallenge = response. - * - * The PeerChallenge field of response is then used for calculation of the - * Authenticator Response. - */ -static void ChapMS2(ppp_pcb *pcb, const u_char *rchallenge, const u_char *PeerChallenge, - const char *user, const char *secret, int secret_len, unsigned char *response, - u_char authResponse[], int authenticator) { - /* ARGSUSED */ - LWIP_UNUSED_ARG(authenticator); -#if !MPPE_SUPPORT - LWIP_UNUSED_ARG(pcb); -#endif /* !MPPE_SUPPORT */ - - BZERO(response, MS_CHAP2_RESPONSE_LEN); - - /* Generate the Peer-Challenge if requested, or copy it if supplied. */ - if (!PeerChallenge) - magic_random_bytes(&response[MS_CHAP2_PEER_CHALLENGE], MS_CHAP2_PEER_CHAL_LEN); - else - MEMCPY(&response[MS_CHAP2_PEER_CHALLENGE], PeerChallenge, - MS_CHAP2_PEER_CHAL_LEN); - - /* Generate the NT-Response */ - ChapMS2_NT(rchallenge, &response[MS_CHAP2_PEER_CHALLENGE], user, - secret, secret_len, &response[MS_CHAP2_NTRESP]); - - /* Generate the Authenticator Response. */ - GenerateAuthenticatorResponsePlain(secret, secret_len, - &response[MS_CHAP2_NTRESP], - &response[MS_CHAP2_PEER_CHALLENGE], - rchallenge, user, authResponse); - -#if MPPE_SUPPORT - SetMasterKeys(pcb, secret, secret_len, - &response[MS_CHAP2_NTRESP], authenticator); -#endif /* MPPE_SUPPORT */ -} - -#if 0 /* UNUSED */ -#if MPPE_SUPPORT -/* - * Set MPPE options from plugins. - */ -void set_mppe_enc_types(int policy, int types) { - /* Early exit for unknown policies. */ - if (policy != MPPE_ENC_POL_ENC_ALLOWED || - policy != MPPE_ENC_POL_ENC_REQUIRED) - return; - - /* Don't modify MPPE if it's optional and wasn't already configured. */ - if (policy == MPPE_ENC_POL_ENC_ALLOWED && !ccp_wantoptions[0].mppe) - return; - - /* - * Disable undesirable encryption types. Note that we don't ENABLE - * any encryption types, to avoid overriding manual configuration. - */ - switch(types) { - case MPPE_ENC_TYPES_RC4_40: - ccp_wantoptions[0].mppe &= ~MPPE_OPT_128; /* disable 128-bit */ - break; - case MPPE_ENC_TYPES_RC4_128: - ccp_wantoptions[0].mppe &= ~MPPE_OPT_40; /* disable 40-bit */ - break; - default: - break; - } -} -#endif /* MPPE_SUPPORT */ -#endif /* UNUSED */ - -const struct chap_digest_type chapms_digest = { - CHAP_MICROSOFT, /* code */ -#if PPP_SERVER - chapms_generate_challenge, - chapms_verify_response, -#endif /* PPP_SERVER */ - chapms_make_response, - NULL, /* check_success */ - chapms_handle_failure, -}; - -const struct chap_digest_type chapms2_digest = { - CHAP_MICROSOFT_V2, /* code */ -#if PPP_SERVER - chapms2_generate_challenge, - chapms2_verify_response, -#endif /* PPP_SERVER */ - chapms2_make_response, - chapms2_check_success, - chapms_handle_failure, -}; - -#endif /* PPP_SUPPORT && MSCHAP_SUPPORT */ +/* + * chap_ms.c - Microsoft MS-CHAP compatible implementation. + * + * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +/* + * Modifications by Lauri Pesonen / lpesonen@clinet.fi, april 1997 + * + * Implemented LANManager type password response to MS-CHAP challenges. + * Now pppd provides both NT style and LANMan style blocks, and the + * prefered is set by option "ms-lanman". Default is to use NT. + * The hash text (StdText) was taken from Win95 RASAPI32.DLL. + * + * You should also use DOMAIN\\USERNAME as described in README.MSCHAP80 + */ + +/* + * Modifications by Frank Cusack, frank@google.com, March 2002. + * + * Implemented MS-CHAPv2 functionality, heavily based on sample + * implementation in RFC 2759. Implemented MPPE functionality, + * heavily based on sample implementation in RFC 3079. + * + * Copyright (c) 2002 Google, Inc. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && MSCHAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#if 0 /* UNUSED */ +#include +#include +#include +#include +#include +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/chap-new.h" +#include "netif/ppp/chap_ms.h" +#include "netif/ppp/pppcrypt.h" +#include "netif/ppp/magic.h" +#if MPPE_SUPPORT +#include "netif/ppp/mppe.h" /* For mppe_sha1_pad*, mppe_set_key() */ +#endif /* MPPE_SUPPORT */ + +#define SHA1_SIGNATURE_SIZE 20 +#define MD4_SIGNATURE_SIZE 16 /* 16 bytes in a MD4 message digest */ +#define MAX_NT_PASSWORD 256 /* Max (Unicode) chars in an NT pass */ + +#define MS_CHAP_RESPONSE_LEN 49 /* Response length for MS-CHAP */ +#define MS_CHAP2_RESPONSE_LEN 49 /* Response length for MS-CHAPv2 */ +#define MS_AUTH_RESPONSE_LENGTH 40 /* MS-CHAPv2 authenticator response, */ + /* as ASCII */ + +/* Error codes for MS-CHAP failure messages. */ +#define MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS 646 +#define MS_CHAP_ERROR_ACCT_DISABLED 647 +#define MS_CHAP_ERROR_PASSWD_EXPIRED 648 +#define MS_CHAP_ERROR_NO_DIALIN_PERMISSION 649 +#define MS_CHAP_ERROR_AUTHENTICATION_FAILURE 691 +#define MS_CHAP_ERROR_CHANGING_PASSWORD 709 + +/* + * Offsets within the response field for MS-CHAP + */ +#define MS_CHAP_LANMANRESP 0 +#define MS_CHAP_LANMANRESP_LEN 24 +#define MS_CHAP_NTRESP 24 +#define MS_CHAP_NTRESP_LEN 24 +#define MS_CHAP_USENT 48 + +/* + * Offsets within the response field for MS-CHAP2 + */ +#define MS_CHAP2_PEER_CHALLENGE 0 +#define MS_CHAP2_PEER_CHAL_LEN 16 +#define MS_CHAP2_RESERVED_LEN 8 +#define MS_CHAP2_NTRESP 24 +#define MS_CHAP2_NTRESP_LEN 24 +#define MS_CHAP2_FLAGS 48 + +#if MPPE_SUPPORT +#if 0 /* UNUSED */ +/* These values are the RADIUS attribute values--see RFC 2548. */ +#define MPPE_ENC_POL_ENC_ALLOWED 1 +#define MPPE_ENC_POL_ENC_REQUIRED 2 +#define MPPE_ENC_TYPES_RC4_40 2 +#define MPPE_ENC_TYPES_RC4_128 4 + +/* used by plugins (using above values) */ +extern void set_mppe_enc_types(int, int); +#endif /* UNUSED */ +#endif /* MPPE_SUPPORT */ + +/* Are we the authenticator or authenticatee? For MS-CHAPv2 key derivation. */ +#define MS_CHAP2_AUTHENTICATEE 0 +#define MS_CHAP2_AUTHENTICATOR 1 + +static void ascii2unicode (const char[], int, u_char[]); +static void NTPasswordHash (u_char *, int, u_char[MD4_SIGNATURE_SIZE]); +static void ChallengeResponse (const u_char *, const u_char *, u_char[24]); +static void ChallengeHash (const u_char[16], const u_char *, const char *, u_char[8]); +static void ChapMS_NT (const u_char *, const char *, int, u_char[24]); +static void ChapMS2_NT (const u_char *, const u_char[16], const char *, const char *, int, + u_char[24]); +static void GenerateAuthenticatorResponsePlain + (const char*, int, u_char[24], const u_char[16], const u_char *, + const char *, u_char[41]); +#ifdef MSLANMAN +static void ChapMS_LANMan (u_char *, char *, int, u_char *); +#endif + +static void GenerateAuthenticatorResponse(const u_char PasswordHashHash[MD4_SIGNATURE_SIZE], + u_char NTResponse[24], const u_char PeerChallenge[16], + const u_char *rchallenge, const char *username, + u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1]); + +#if MPPE_SUPPORT +static void Set_Start_Key (ppp_pcb *pcb, const u_char *, const char *, int); +static void SetMasterKeys (ppp_pcb *pcb, const char *, int, u_char[24], int); +#endif /* MPPE_SUPPORT */ + +static void ChapMS (ppp_pcb *pcb, const u_char *, const char *, int, u_char *); +static void ChapMS2 (ppp_pcb *pcb, const u_char *, const u_char *, const char *, const char *, int, + u_char *, u_char[MS_AUTH_RESPONSE_LENGTH+1], int); + +#ifdef MSLANMAN +bool ms_lanman = 0; /* Use LanMan password instead of NT */ + /* Has meaning only with MS-CHAP challenges */ +#endif + +#if MPPE_SUPPORT +#ifdef DEBUGMPPEKEY +/* For MPPE debug */ +/* Use "[]|}{?/><,`!2&&(" (sans quotes) for RFC 3079 MS-CHAPv2 test value */ +static char *mschap_challenge = NULL; +/* Use "!@\#$%^&*()_+:3|~" (sans quotes, backslash is to escape #) for ... */ +static char *mschap2_peer_challenge = NULL; +#endif + +#include "netif/ppp/fsm.h" /* Need to poke MPPE options */ +#include "netif/ppp/ccp.h" +#endif /* MPPE_SUPPORT */ + +#if PPP_OPTIONS +/* + * Command-line options. + */ +static option_t chapms_option_list[] = { +#ifdef MSLANMAN + { "ms-lanman", o_bool, &ms_lanman, + "Use LanMan passwd when using MS-CHAP", 1 }, +#endif +#ifdef DEBUGMPPEKEY + { "mschap-challenge", o_string, &mschap_challenge, + "specify CHAP challenge" }, + { "mschap2-peer-challenge", o_string, &mschap2_peer_challenge, + "specify CHAP peer challenge" }, +#endif + { NULL } +}; +#endif /* PPP_OPTIONS */ + +#if PPP_SERVER +/* + * chapms_generate_challenge - generate a challenge for MS-CHAP. + * For MS-CHAP the challenge length is fixed at 8 bytes. + * The length goes in challenge[0] and the actual challenge starts + * at challenge[1]. + */ +static void chapms_generate_challenge(ppp_pcb *pcb, unsigned char *challenge) { + LWIP_UNUSED_ARG(pcb); + + *challenge++ = 8; +#ifdef DEBUGMPPEKEY + if (mschap_challenge && strlen(mschap_challenge) == 8) + memcpy(challenge, mschap_challenge, 8); + else +#endif + magic_random_bytes(challenge, 8); +} + +static void chapms2_generate_challenge(ppp_pcb *pcb, unsigned char *challenge) { + LWIP_UNUSED_ARG(pcb); + + *challenge++ = 16; +#ifdef DEBUGMPPEKEY + if (mschap_challenge && strlen(mschap_challenge) == 16) + memcpy(challenge, mschap_challenge, 16); + else +#endif + magic_random_bytes(challenge, 16); +} + +static int chapms_verify_response(ppp_pcb *pcb, int id, const char *name, + const unsigned char *secret, int secret_len, + const unsigned char *challenge, const unsigned char *response, + char *message, int message_space) { + unsigned char md[MS_CHAP_RESPONSE_LEN]; + int diff; + int challenge_len, response_len; + LWIP_UNUSED_ARG(id); + LWIP_UNUSED_ARG(name); + + challenge_len = *challenge++; /* skip length, is 8 */ + response_len = *response++; + if (response_len != MS_CHAP_RESPONSE_LEN) + goto bad; + +#ifndef MSLANMAN + if (!response[MS_CHAP_USENT]) { + /* Should really propagate this into the error packet. */ + ppp_notice("Peer request for LANMAN auth not supported"); + goto bad; + } +#endif + + /* Generate the expected response. */ + ChapMS(pcb, (const u_char *)challenge, (const char *)secret, secret_len, md); + +#ifdef MSLANMAN + /* Determine which part of response to verify against */ + if (!response[MS_CHAP_USENT]) + diff = memcmp(&response[MS_CHAP_LANMANRESP], + &md[MS_CHAP_LANMANRESP], MS_CHAP_LANMANRESP_LEN); + else +#endif + diff = memcmp(&response[MS_CHAP_NTRESP], &md[MS_CHAP_NTRESP], + MS_CHAP_NTRESP_LEN); + + if (diff == 0) { + ppp_slprintf(message, message_space, "Access granted"); + return 1; + } + + bad: + /* See comments below for MS-CHAP V2 */ + ppp_slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0", + challenge_len, challenge); + return 0; +} + +static int chapms2_verify_response(ppp_pcb *pcb, int id, const char *name, + const unsigned char *secret, int secret_len, + const unsigned char *challenge, const unsigned char *response, + char *message, int message_space) { + unsigned char md[MS_CHAP2_RESPONSE_LEN]; + char saresponse[MS_AUTH_RESPONSE_LENGTH+1]; + int challenge_len, response_len; + LWIP_UNUSED_ARG(id); + + challenge_len = *challenge++; /* skip length, is 16 */ + response_len = *response++; + if (response_len != MS_CHAP2_RESPONSE_LEN) + goto bad; /* not even the right length */ + + /* Generate the expected response and our mutual auth. */ + ChapMS2(pcb, (const u_char*)challenge, (const u_char*)&response[MS_CHAP2_PEER_CHALLENGE], name, + (const char *)secret, secret_len, md, + (unsigned char *)saresponse, MS_CHAP2_AUTHENTICATOR); + + /* compare MDs and send the appropriate status */ + /* + * Per RFC 2759, success message must be formatted as + * "S= M=" + * where + * is the Authenticator Response (mutual auth) + * is a text message + * + * However, some versions of Windows (win98 tested) do not know + * about the M= part (required per RFC 2759) and flag + * it as an error (reported incorrectly as an encryption error + * to the user). Since the RFC requires it, and it can be + * useful information, we supply it if the peer is a conforming + * system. Luckily (?), win98 sets the Flags field to 0x04 + * (contrary to RFC requirements) so we can use that to + * distinguish between conforming and non-conforming systems. + * + * Special thanks to Alex Swiridov for + * help debugging this. + */ + if (memcmp(&md[MS_CHAP2_NTRESP], &response[MS_CHAP2_NTRESP], + MS_CHAP2_NTRESP_LEN) == 0) { + if (response[MS_CHAP2_FLAGS]) + ppp_slprintf(message, message_space, "S=%s", saresponse); + else + ppp_slprintf(message, message_space, "S=%s M=%s", + saresponse, "Access granted"); + return 1; + } + + bad: + /* + * Failure message must be formatted as + * "E=e R=r C=c V=v M=m" + * where + * e = error code (we use 691, ERROR_AUTHENTICATION_FAILURE) + * r = retry (we use 1, ok to retry) + * c = challenge to use for next response, we reuse previous + * v = Change Password version supported, we use 0 + * m = text message + * + * The M=m part is only for MS-CHAPv2. Neither win2k nor + * win98 (others untested) display the message to the user anyway. + * They also both ignore the E=e code. + * + * Note that it's safe to reuse the same challenge as we don't + * actually accept another response based on the error message + * (and no clients try to resend a response anyway). + * + * Basically, this whole bit is useless code, even the small + * implementation here is only because of overspecification. + */ + ppp_slprintf(message, message_space, "E=691 R=1 C=%0.*B V=0 M=%s", + challenge_len, challenge, "Access denied"); + return 0; +} +#endif /* PPP_SERVER */ + +static void chapms_make_response(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, + const unsigned char *challenge, const char *secret, int secret_len, + unsigned char *private_) { + LWIP_UNUSED_ARG(id); + LWIP_UNUSED_ARG(our_name); + LWIP_UNUSED_ARG(private_); + challenge++; /* skip length, should be 8 */ + *response++ = MS_CHAP_RESPONSE_LEN; + ChapMS(pcb, challenge, secret, secret_len, response); +} + +static void chapms2_make_response(ppp_pcb *pcb, unsigned char *response, int id, const char *our_name, + const unsigned char *challenge, const char *secret, int secret_len, + unsigned char *private_) { + LWIP_UNUSED_ARG(id); + challenge++; /* skip length, should be 16 */ + *response++ = MS_CHAP2_RESPONSE_LEN; + ChapMS2(pcb, challenge, +#ifdef DEBUGMPPEKEY + mschap2_peer_challenge, +#else + NULL, +#endif + our_name, secret, secret_len, response, private_, + MS_CHAP2_AUTHENTICATEE); +} + +static int chapms2_check_success(ppp_pcb *pcb, unsigned char *msg, int len, unsigned char *private_) { + LWIP_UNUSED_ARG(pcb); + + if ((len < MS_AUTH_RESPONSE_LENGTH + 2) || + strncmp((char *)msg, "S=", 2) != 0) { + /* Packet does not start with "S=" */ + ppp_error("MS-CHAPv2 Success packet is badly formed."); + return 0; + } + msg += 2; + len -= 2; + if (len < MS_AUTH_RESPONSE_LENGTH + || memcmp(msg, private_, MS_AUTH_RESPONSE_LENGTH)) { + /* Authenticator Response did not match expected. */ + ppp_error("MS-CHAPv2 mutual authentication failed."); + return 0; + } + /* Authenticator Response matches. */ + msg += MS_AUTH_RESPONSE_LENGTH; /* Eat it */ + len -= MS_AUTH_RESPONSE_LENGTH; + if ((len >= 3) && !strncmp((char *)msg, " M=", 3)) { + msg += 3; /* Eat the delimiter */ + } else if (len) { + /* Packet has extra text which does not begin " M=" */ + ppp_error("MS-CHAPv2 Success packet is badly formed."); + return 0; + } + return 1; +} + +static void chapms_handle_failure(ppp_pcb *pcb, unsigned char *inp, int len) { + int err; + const char *p; + char msg[64]; + LWIP_UNUSED_ARG(pcb); + + /* We want a null-terminated string for strxxx(). */ + len = LWIP_MIN(len, 63); + MEMCPY(msg, inp, len); + msg[len] = 0; + p = msg; + + /* + * Deal with MS-CHAP formatted failure messages; just print the + * M= part (if any). For MS-CHAP we're not really supposed + * to use M=, but it shouldn't hurt. See + * chapms[2]_verify_response. + */ + if (!strncmp(p, "E=", 2)) + err = strtol(p+2, NULL, 10); /* Remember the error code. */ + else + goto print_msg; /* Message is badly formatted. */ + + if (len && ((p = strstr(p, " M=")) != NULL)) { + /* M= field found. */ + p += 3; + } else { + /* No M=; use the error code. */ + switch (err) { + case MS_CHAP_ERROR_RESTRICTED_LOGON_HOURS: + p = "E=646 Restricted logon hours"; + break; + + case MS_CHAP_ERROR_ACCT_DISABLED: + p = "E=647 Account disabled"; + break; + + case MS_CHAP_ERROR_PASSWD_EXPIRED: + p = "E=648 Password expired"; + break; + + case MS_CHAP_ERROR_NO_DIALIN_PERMISSION: + p = "E=649 No dialin permission"; + break; + + case MS_CHAP_ERROR_AUTHENTICATION_FAILURE: + p = "E=691 Authentication failure"; + break; + + case MS_CHAP_ERROR_CHANGING_PASSWORD: + /* Should never see this, we don't support Change Password. */ + p = "E=709 Error changing password"; + break; + + default: + ppp_error("Unknown MS-CHAP authentication failure: %.*v", + len, inp); + return; + } + } +print_msg: + if (p != NULL) + ppp_error("MS-CHAP authentication failed: %v", p); +} + +static void ChallengeResponse(const u_char *challenge, + const u_char PasswordHash[MD4_SIGNATURE_SIZE], + u_char response[24]) { + u_char ZPasswordHash[21]; + lwip_des_context des; + u_char des_key[8]; + + BZERO(ZPasswordHash, sizeof(ZPasswordHash)); + MEMCPY(ZPasswordHash, PasswordHash, MD4_SIGNATURE_SIZE); + +#if 0 + dbglog("ChallengeResponse - ZPasswordHash %.*B", + sizeof(ZPasswordHash), ZPasswordHash); +#endif + + pppcrypt_56_to_64_bit_key(ZPasswordHash + 0, des_key); + lwip_des_init(&des); + lwip_des_setkey_enc(&des, des_key); + lwip_des_crypt_ecb(&des, challenge, response +0); + lwip_des_free(&des); + + pppcrypt_56_to_64_bit_key(ZPasswordHash + 7, des_key); + lwip_des_init(&des); + lwip_des_setkey_enc(&des, des_key); + lwip_des_crypt_ecb(&des, challenge, response +8); + lwip_des_free(&des); + + pppcrypt_56_to_64_bit_key(ZPasswordHash + 14, des_key); + lwip_des_init(&des); + lwip_des_setkey_enc(&des, des_key); + lwip_des_crypt_ecb(&des, challenge, response +16); + lwip_des_free(&des); + +#if 0 + dbglog("ChallengeResponse - response %.24B", response); +#endif +} + +static void ChallengeHash(const u_char PeerChallenge[16], const u_char *rchallenge, + const char *username, u_char Challenge[8]) { + lwip_sha1_context sha1Context; + u_char sha1Hash[SHA1_SIGNATURE_SIZE]; + const char *user; + + /* remove domain from "domain\username" */ + if ((user = strrchr(username, '\\')) != NULL) + ++user; + else + user = username; + + lwip_sha1_init(&sha1Context); + lwip_sha1_starts(&sha1Context); + lwip_sha1_update(&sha1Context, PeerChallenge, 16); + lwip_sha1_update(&sha1Context, rchallenge, 16); + lwip_sha1_update(&sha1Context, (const unsigned char*)user, strlen(user)); + lwip_sha1_finish(&sha1Context, sha1Hash); + lwip_sha1_free(&sha1Context); + + MEMCPY(Challenge, sha1Hash, 8); +} + +/* + * Convert the ASCII version of the password to Unicode. + * This implicitly supports 8-bit ISO8859/1 characters. + * This gives us the little-endian representation, which + * is assumed by all M$ CHAP RFCs. (Unicode byte ordering + * is machine-dependent.) + */ +static void ascii2unicode(const char ascii[], int ascii_len, u_char unicode[]) { + int i; + + BZERO(unicode, ascii_len * 2); + for (i = 0; i < ascii_len; i++) + unicode[i * 2] = (u_char) ascii[i]; +} + +static void NTPasswordHash(u_char *secret, int secret_len, u_char hash[MD4_SIGNATURE_SIZE]) { + lwip_md4_context md4Context; + + lwip_md4_init(&md4Context); + lwip_md4_starts(&md4Context); + lwip_md4_update(&md4Context, secret, secret_len); + lwip_md4_finish(&md4Context, hash); + lwip_md4_free(&md4Context); +} + +static void ChapMS_NT(const u_char *rchallenge, const char *secret, int secret_len, + u_char NTResponse[24]) { + u_char unicodePassword[MAX_NT_PASSWORD * 2]; + u_char PasswordHash[MD4_SIGNATURE_SIZE]; + + /* Hash the Unicode version of the secret (== password). */ + ascii2unicode(secret, secret_len, unicodePassword); + NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); + + ChallengeResponse(rchallenge, PasswordHash, NTResponse); +} + +static void ChapMS2_NT(const u_char *rchallenge, const u_char PeerChallenge[16], const char *username, + const char *secret, int secret_len, u_char NTResponse[24]) { + u_char unicodePassword[MAX_NT_PASSWORD * 2]; + u_char PasswordHash[MD4_SIGNATURE_SIZE]; + u_char Challenge[8]; + + ChallengeHash(PeerChallenge, rchallenge, username, Challenge); + + /* Hash the Unicode version of the secret (== password). */ + ascii2unicode(secret, secret_len, unicodePassword); + NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); + + ChallengeResponse(Challenge, PasswordHash, NTResponse); +} + +#ifdef MSLANMAN +static u_char *StdText = (u_char *)"KGS!@#$%"; /* key from rasapi32.dll */ + +static void ChapMS_LANMan(u_char *rchallenge, char *secret, int secret_len, + unsigned char *response) { + int i; + u_char UcasePassword[MAX_NT_PASSWORD]; /* max is actually 14 */ + u_char PasswordHash[MD4_SIGNATURE_SIZE]; + lwip_des_context des; + u_char des_key[8]; + + /* LANMan password is case insensitive */ + BZERO(UcasePassword, sizeof(UcasePassword)); + for (i = 0; i < secret_len; i++) + UcasePassword[i] = (u_char)toupper(secret[i]); + + pppcrypt_56_to_64_bit_key(UcasePassword +0, des_key); + lwip_des_init(&des); + lwip_des_setkey_enc(&des, des_key); + lwip_des_crypt_ecb(&des, StdText, PasswordHash +0); + lwip_des_free(&des); + + pppcrypt_56_to_64_bit_key(UcasePassword +7, des_key); + lwip_des_init(&des); + lwip_des_setkey_enc(&des, des_key); + lwip_des_crypt_ecb(&des, StdText, PasswordHash +8); + lwip_des_free(&des); + + ChallengeResponse(rchallenge, PasswordHash, &response[MS_CHAP_LANMANRESP]); +} +#endif + + +static void GenerateAuthenticatorResponse(const u_char PasswordHashHash[MD4_SIGNATURE_SIZE], + u_char NTResponse[24], const u_char PeerChallenge[16], + const u_char *rchallenge, const char *username, + u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1]) { + /* + * "Magic" constants used in response generation, from RFC 2759. + */ + static const u_char Magic1[39] = /* "Magic server to client signing constant" */ + { 0x4D, 0x61, 0x67, 0x69, 0x63, 0x20, 0x73, 0x65, 0x72, 0x76, + 0x65, 0x72, 0x20, 0x74, 0x6F, 0x20, 0x63, 0x6C, 0x69, 0x65, + 0x6E, 0x74, 0x20, 0x73, 0x69, 0x67, 0x6E, 0x69, 0x6E, 0x67, + 0x20, 0x63, 0x6F, 0x6E, 0x73, 0x74, 0x61, 0x6E, 0x74 }; + static const u_char Magic2[41] = /* "Pad to make it do more than one iteration" */ + { 0x50, 0x61, 0x64, 0x20, 0x74, 0x6F, 0x20, 0x6D, 0x61, 0x6B, + 0x65, 0x20, 0x69, 0x74, 0x20, 0x64, 0x6F, 0x20, 0x6D, 0x6F, + 0x72, 0x65, 0x20, 0x74, 0x68, 0x61, 0x6E, 0x20, 0x6F, 0x6E, + 0x65, 0x20, 0x69, 0x74, 0x65, 0x72, 0x61, 0x74, 0x69, 0x6F, + 0x6E }; + + int i; + lwip_sha1_context sha1Context; + u_char Digest[SHA1_SIGNATURE_SIZE]; + u_char Challenge[8]; + + lwip_sha1_init(&sha1Context); + lwip_sha1_starts(&sha1Context); + lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); + lwip_sha1_update(&sha1Context, NTResponse, 24); + lwip_sha1_update(&sha1Context, Magic1, sizeof(Magic1)); + lwip_sha1_finish(&sha1Context, Digest); + lwip_sha1_free(&sha1Context); + + ChallengeHash(PeerChallenge, rchallenge, username, Challenge); + + lwip_sha1_init(&sha1Context); + lwip_sha1_starts(&sha1Context); + lwip_sha1_update(&sha1Context, Digest, sizeof(Digest)); + lwip_sha1_update(&sha1Context, Challenge, sizeof(Challenge)); + lwip_sha1_update(&sha1Context, Magic2, sizeof(Magic2)); + lwip_sha1_finish(&sha1Context, Digest); + lwip_sha1_free(&sha1Context); + + /* Convert to ASCII hex string. */ + for (i = 0; i < LWIP_MAX((MS_AUTH_RESPONSE_LENGTH / 2), (int)sizeof(Digest)); i++) + sprintf((char *)&authResponse[i * 2], "%02X", Digest[i]); +} + + +static void GenerateAuthenticatorResponsePlain( + const char *secret, int secret_len, + u_char NTResponse[24], const u_char PeerChallenge[16], + const u_char *rchallenge, const char *username, + u_char authResponse[MS_AUTH_RESPONSE_LENGTH+1]) { + u_char unicodePassword[MAX_NT_PASSWORD * 2]; + u_char PasswordHash[MD4_SIGNATURE_SIZE]; + u_char PasswordHashHash[MD4_SIGNATURE_SIZE]; + + /* Hash (x2) the Unicode version of the secret (== password). */ + ascii2unicode(secret, secret_len, unicodePassword); + NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); + NTPasswordHash(PasswordHash, sizeof(PasswordHash), + PasswordHashHash); + + GenerateAuthenticatorResponse(PasswordHashHash, NTResponse, PeerChallenge, + rchallenge, username, authResponse); +} + + +#if MPPE_SUPPORT +/* + * Set mppe_xxxx_key from MS-CHAP credentials. (see RFC 3079) + */ +static void Set_Start_Key(ppp_pcb *pcb, const u_char *rchallenge, const char *secret, int secret_len) { + u_char unicodePassword[MAX_NT_PASSWORD * 2]; + u_char PasswordHash[MD4_SIGNATURE_SIZE]; + u_char PasswordHashHash[MD4_SIGNATURE_SIZE]; + lwip_sha1_context sha1Context; + u_char Digest[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */ + + /* Hash (x2) the Unicode version of the secret (== password). */ + ascii2unicode(secret, secret_len, unicodePassword); + NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); + NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash); + + lwip_sha1_init(&sha1Context); + lwip_sha1_starts(&sha1Context); + lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); + lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); + lwip_sha1_update(&sha1Context, rchallenge, 8); + lwip_sha1_finish(&sha1Context, Digest); + lwip_sha1_free(&sha1Context); + + /* Same key in both directions. */ + mppe_set_key(pcb, &pcb->mppe_comp, Digest); + mppe_set_key(pcb, &pcb->mppe_decomp, Digest); + + pcb->mppe_keys_set = 1; +} + +/* + * Set mppe_xxxx_key from MS-CHAPv2 credentials. (see RFC 3079) + */ +static void SetMasterKeys(ppp_pcb *pcb, const char *secret, int secret_len, u_char NTResponse[24], int IsServer) { + u_char unicodePassword[MAX_NT_PASSWORD * 2]; + u_char PasswordHash[MD4_SIGNATURE_SIZE]; + u_char PasswordHashHash[MD4_SIGNATURE_SIZE]; + lwip_sha1_context sha1Context; + u_char MasterKey[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */ + u_char Digest[SHA1_SIGNATURE_SIZE]; /* >= MPPE_MAX_KEY_LEN */ + const u_char *s; + + /* "This is the MPPE Master Key" */ + static const u_char Magic1[27] = + { 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, + 0x68, 0x65, 0x20, 0x4d, 0x50, 0x50, 0x45, 0x20, 0x4d, + 0x61, 0x73, 0x74, 0x65, 0x72, 0x20, 0x4b, 0x65, 0x79 }; + /* "On the client side, this is the send key; " + "on the server side, it is the receive key." */ + static const u_char Magic2[84] = + { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, 0x6b, 0x65, 0x79, + 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, + 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, 0x69, 0x64, 0x65, + 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20, + 0x6b, 0x65, 0x79, 0x2e }; + /* "On the client side, this is the receive key; " + "on the server side, it is the send key." */ + static const u_char Magic3[84] = + { 0x4f, 0x6e, 0x20, 0x74, 0x68, 0x65, 0x20, 0x63, 0x6c, 0x69, + 0x65, 0x6e, 0x74, 0x20, 0x73, 0x69, 0x64, 0x65, 0x2c, 0x20, + 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x72, 0x65, 0x63, 0x65, 0x69, 0x76, 0x65, 0x20, + 0x6b, 0x65, 0x79, 0x3b, 0x20, 0x6f, 0x6e, 0x20, 0x74, 0x68, + 0x65, 0x20, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x20, 0x73, + 0x69, 0x64, 0x65, 0x2c, 0x20, 0x69, 0x74, 0x20, 0x69, 0x73, + 0x20, 0x74, 0x68, 0x65, 0x20, 0x73, 0x65, 0x6e, 0x64, 0x20, + 0x6b, 0x65, 0x79, 0x2e }; + + /* Hash (x2) the Unicode version of the secret (== password). */ + ascii2unicode(secret, secret_len, unicodePassword); + NTPasswordHash(unicodePassword, secret_len * 2, PasswordHash); + NTPasswordHash(PasswordHash, sizeof(PasswordHash), PasswordHashHash); + + lwip_sha1_init(&sha1Context); + lwip_sha1_starts(&sha1Context); + lwip_sha1_update(&sha1Context, PasswordHashHash, MD4_SIGNATURE_SIZE); + lwip_sha1_update(&sha1Context, NTResponse, 24); + lwip_sha1_update(&sha1Context, Magic1, sizeof(Magic1)); + lwip_sha1_finish(&sha1Context, MasterKey); + lwip_sha1_free(&sha1Context); + + /* + * generate send key + */ + if (IsServer) + s = Magic3; + else + s = Magic2; + lwip_sha1_init(&sha1Context); + lwip_sha1_starts(&sha1Context); + lwip_sha1_update(&sha1Context, MasterKey, 16); + lwip_sha1_update(&sha1Context, mppe_sha1_pad1, SHA1_PAD_SIZE); + lwip_sha1_update(&sha1Context, s, 84); + lwip_sha1_update(&sha1Context, mppe_sha1_pad2, SHA1_PAD_SIZE); + lwip_sha1_finish(&sha1Context, Digest); + lwip_sha1_free(&sha1Context); + + mppe_set_key(pcb, &pcb->mppe_comp, Digest); + + /* + * generate recv key + */ + if (IsServer) + s = Magic2; + else + s = Magic3; + lwip_sha1_init(&sha1Context); + lwip_sha1_starts(&sha1Context); + lwip_sha1_update(&sha1Context, MasterKey, 16); + lwip_sha1_update(&sha1Context, mppe_sha1_pad1, SHA1_PAD_SIZE); + lwip_sha1_update(&sha1Context, s, 84); + lwip_sha1_update(&sha1Context, mppe_sha1_pad2, SHA1_PAD_SIZE); + lwip_sha1_finish(&sha1Context, Digest); + lwip_sha1_free(&sha1Context); + + mppe_set_key(pcb, &pcb->mppe_decomp, Digest); + + pcb->mppe_keys_set = 1; +} + +#endif /* MPPE_SUPPORT */ + + +static void ChapMS(ppp_pcb *pcb, const u_char *rchallenge, const char *secret, int secret_len, + unsigned char *response) { +#if !MPPE_SUPPORT + LWIP_UNUSED_ARG(pcb); +#endif /* !MPPE_SUPPORT */ + BZERO(response, MS_CHAP_RESPONSE_LEN); + + ChapMS_NT(rchallenge, secret, secret_len, &response[MS_CHAP_NTRESP]); + +#ifdef MSLANMAN + ChapMS_LANMan(rchallenge, secret, secret_len, + &response[MS_CHAP_LANMANRESP]); + + /* preferred method is set by option */ + response[MS_CHAP_USENT] = !ms_lanman; +#else + response[MS_CHAP_USENT] = 1; +#endif + +#if MPPE_SUPPORT + Set_Start_Key(pcb, rchallenge, secret, secret_len); +#endif /* MPPE_SUPPORT */ +} + + +/* + * If PeerChallenge is NULL, one is generated and the PeerChallenge + * field of response is filled in. Call this way when generating a response. + * If PeerChallenge is supplied, it is copied into the PeerChallenge field. + * Call this way when verifying a response (or debugging). + * Do not call with PeerChallenge = response. + * + * The PeerChallenge field of response is then used for calculation of the + * Authenticator Response. + */ +static void ChapMS2(ppp_pcb *pcb, const u_char *rchallenge, const u_char *PeerChallenge, + const char *user, const char *secret, int secret_len, unsigned char *response, + u_char authResponse[], int authenticator) { + /* ARGSUSED */ + LWIP_UNUSED_ARG(authenticator); +#if !MPPE_SUPPORT + LWIP_UNUSED_ARG(pcb); +#endif /* !MPPE_SUPPORT */ + + BZERO(response, MS_CHAP2_RESPONSE_LEN); + + /* Generate the Peer-Challenge if requested, or copy it if supplied. */ + if (!PeerChallenge) + magic_random_bytes(&response[MS_CHAP2_PEER_CHALLENGE], MS_CHAP2_PEER_CHAL_LEN); + else + MEMCPY(&response[MS_CHAP2_PEER_CHALLENGE], PeerChallenge, + MS_CHAP2_PEER_CHAL_LEN); + + /* Generate the NT-Response */ + ChapMS2_NT(rchallenge, &response[MS_CHAP2_PEER_CHALLENGE], user, + secret, secret_len, &response[MS_CHAP2_NTRESP]); + + /* Generate the Authenticator Response. */ + GenerateAuthenticatorResponsePlain(secret, secret_len, + &response[MS_CHAP2_NTRESP], + &response[MS_CHAP2_PEER_CHALLENGE], + rchallenge, user, authResponse); + +#if MPPE_SUPPORT + SetMasterKeys(pcb, secret, secret_len, + &response[MS_CHAP2_NTRESP], authenticator); +#endif /* MPPE_SUPPORT */ +} + +#if 0 /* UNUSED */ +#if MPPE_SUPPORT +/* + * Set MPPE options from plugins. + */ +void set_mppe_enc_types(int policy, int types) { + /* Early exit for unknown policies. */ + if (policy != MPPE_ENC_POL_ENC_ALLOWED || + policy != MPPE_ENC_POL_ENC_REQUIRED) + return; + + /* Don't modify MPPE if it's optional and wasn't already configured. */ + if (policy == MPPE_ENC_POL_ENC_ALLOWED && !ccp_wantoptions[0].mppe) + return; + + /* + * Disable undesirable encryption types. Note that we don't ENABLE + * any encryption types, to avoid overriding manual configuration. + */ + switch(types) { + case MPPE_ENC_TYPES_RC4_40: + ccp_wantoptions[0].mppe &= ~MPPE_OPT_128; /* disable 128-bit */ + break; + case MPPE_ENC_TYPES_RC4_128: + ccp_wantoptions[0].mppe &= ~MPPE_OPT_40; /* disable 40-bit */ + break; + default: + break; + } +} +#endif /* MPPE_SUPPORT */ +#endif /* UNUSED */ + +const struct chap_digest_type chapms_digest = { + CHAP_MICROSOFT, /* code */ +#if PPP_SERVER + chapms_generate_challenge, + chapms_verify_response, +#endif /* PPP_SERVER */ + chapms_make_response, + NULL, /* check_success */ + chapms_handle_failure, +}; + +const struct chap_digest_type chapms2_digest = { + CHAP_MICROSOFT_V2, /* code */ +#if PPP_SERVER + chapms2_generate_challenge, + chapms2_verify_response, +#endif /* PPP_SERVER */ + chapms2_make_response, + chapms2_check_success, + chapms_handle_failure, +}; + +#endif /* PPP_SUPPORT && MSCHAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/demand.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/demand.c index 0bd3598e..26c6c30d 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/demand.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/demand.c @@ -1,465 +1,465 @@ -/* - * demand.c - Support routines for demand-dialling. - * - * Copyright (c) 1996-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && DEMAND_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifdef PPP_FILTER -#include -#endif - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/ipcp.h" -#include "netif/ppp/lcp.h" - -char *frame; -int framelen; -int framemax; -int escape_flag; -int flush_flag; -int fcs; - -struct packet { - int length; - struct packet *next; - unsigned char data[1]; -}; - -struct packet *pend_q; -struct packet *pend_qtail; - -static int active_packet (unsigned char *, int); - -/* - * demand_conf - configure the interface for doing dial-on-demand. - */ -void -demand_conf() -{ - int i; - const struct protent *protp; - -/* framemax = lcp_allowoptions[0].mru; - if (framemax < PPP_MRU) */ - framemax = PPP_MRU; - framemax += PPP_HDRLEN + PPP_FCSLEN; - frame = malloc(framemax); - if (frame == NULL) - novm("demand frame"); - framelen = 0; - pend_q = NULL; - escape_flag = 0; - flush_flag = 0; - fcs = PPP_INITFCS; - - netif_set_mtu(pcb, LWIP_MIN(lcp_allowoptions[0].mru, PPP_MRU)); - if (ppp_send_config(pcb, PPP_MRU, (u32_t) 0, 0, 0) < 0 - || ppp_recv_config(pcb, PPP_MRU, (u32_t) 0, 0, 0) < 0) - fatal("Couldn't set up demand-dialled PPP interface: %m"); - -#ifdef PPP_FILTER - set_filters(&pass_filter, &active_filter); -#endif - - /* - * Call the demand_conf procedure for each protocol that's got one. - */ - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (protp->demand_conf != NULL) - ((*protp->demand_conf)(pcb)); -/* FIXME: find a way to die() here */ -#if 0 - if (!((*protp->demand_conf)(pcb))) - die(1); -#endif -} - - -/* - * demand_block - set each network protocol to block further packets. - */ -void -demand_block() -{ - int i; - const struct protent *protp; - - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (protp->demand_conf != NULL) - sifnpmode(pcb, protp->protocol & ~0x8000, NPMODE_QUEUE); - get_loop_output(); -} - -/* - * demand_discard - set each network protocol to discard packets - * with an error. - */ -void -demand_discard() -{ - struct packet *pkt, *nextpkt; - int i; - const struct protent *protp; - - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (protp->demand_conf != NULL) - sifnpmode(pcb, protp->protocol & ~0x8000, NPMODE_ERROR); - get_loop_output(); - - /* discard all saved packets */ - for (pkt = pend_q; pkt != NULL; pkt = nextpkt) { - nextpkt = pkt->next; - free(pkt); - } - pend_q = NULL; - framelen = 0; - flush_flag = 0; - escape_flag = 0; - fcs = PPP_INITFCS; -} - -/* - * demand_unblock - set each enabled network protocol to pass packets. - */ -void -demand_unblock() -{ - int i; - const struct protent *protp; - - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (protp->demand_conf != NULL) - sifnpmode(pcb, protp->protocol & ~0x8000, NPMODE_PASS); -} - -/* - * FCS lookup table as calculated by genfcstab. - */ -static u_short fcstab[256] = { - 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, - 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, - 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, - 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, - 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, - 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, - 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, - 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, - 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, - 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, - 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, - 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, - 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, - 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, - 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, - 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, - 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, - 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, - 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, - 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, - 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, - 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, - 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, - 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, - 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, - 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, - 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, - 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, - 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, - 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, - 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, - 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 -}; - -/* - * loop_chars - process characters received from the loopback. - * Calls loop_frame when a complete frame has been accumulated. - * Return value is 1 if we need to bring up the link, 0 otherwise. - */ -int -loop_chars(p, n) - unsigned char *p; - int n; -{ - int c, rv; - - rv = 0; - -/* check for synchronous connection... */ - - if ( (p[0] == 0xFF) && (p[1] == 0x03) ) { - rv = loop_frame(p,n); - return rv; - } - - for (; n > 0; --n) { - c = *p++; - if (c == PPP_FLAG) { - if (!escape_flag && !flush_flag - && framelen > 2 && fcs == PPP_GOODFCS) { - framelen -= 2; - if (loop_frame((unsigned char *)frame, framelen)) - rv = 1; - } - framelen = 0; - flush_flag = 0; - escape_flag = 0; - fcs = PPP_INITFCS; - continue; - } - if (flush_flag) - continue; - if (escape_flag) { - c ^= PPP_TRANS; - escape_flag = 0; - } else if (c == PPP_ESCAPE) { - escape_flag = 1; - continue; - } - if (framelen >= framemax) { - flush_flag = 1; - continue; - } - frame[framelen++] = c; - fcs = PPP_FCS(fcs, c); - } - return rv; -} - -/* - * loop_frame - given a frame obtained from the loopback, - * decide whether to bring up the link or not, and, if we want - * to transmit this frame later, put it on the pending queue. - * Return value is 1 if we need to bring up the link, 0 otherwise. - * We assume that the kernel driver has already applied the - * pass_filter, so we won't get packets it rejected. - * We apply the active_filter to see if we want this packet to - * bring up the link. - */ -int -loop_frame(frame, len) - unsigned char *frame; - int len; -{ - struct packet *pkt; - - /* dbglog("from loop: %P", frame, len); */ - if (len < PPP_HDRLEN) - return 0; - if ((PPP_PROTOCOL(frame) & 0x8000) != 0) - return 0; /* shouldn't get any of these anyway */ - if (!active_packet(frame, len)) - return 0; - - pkt = (struct packet *) malloc(sizeof(struct packet) + len); - if (pkt != NULL) { - pkt->length = len; - pkt->next = NULL; - memcpy(pkt->data, frame, len); - if (pend_q == NULL) - pend_q = pkt; - else - pend_qtail->next = pkt; - pend_qtail = pkt; - } - return 1; -} - -/* - * demand_rexmit - Resend all those frames which we got via the - * loopback, now that the real serial link is up. - */ -void -demand_rexmit(proto, newip) - int proto; - u32_t newip; -{ - struct packet *pkt, *prev, *nextpkt; - unsigned short checksum; - unsigned short pkt_checksum = 0; - unsigned iphdr; - struct timeval tv; - char cv = 0; - char ipstr[16]; - - prev = NULL; - pkt = pend_q; - pend_q = NULL; - tv.tv_sec = 1; - tv.tv_usec = 0; - select(0,NULL,NULL,NULL,&tv); /* Sleep for 1 Seconds */ - for (; pkt != NULL; pkt = nextpkt) { - nextpkt = pkt->next; - if (PPP_PROTOCOL(pkt->data) == proto) { - if ( (proto == PPP_IP) && newip ) { - /* Get old checksum */ - - iphdr = (pkt->data[4] & 15) << 2; - checksum = *((unsigned short *) (pkt->data+14)); - if (checksum == 0xFFFF) { - checksum = 0; - } - - - if (pkt->data[13] == 17) { - pkt_checksum = *((unsigned short *) (pkt->data+10+iphdr)); - if (pkt_checksum) { - cv = 1; - if (pkt_checksum == 0xFFFF) { - pkt_checksum = 0; - } - } - else { - cv = 0; - } - } - - if (pkt->data[13] == 6) { - pkt_checksum = *((unsigned short *) (pkt->data+20+iphdr)); - cv = 1; - if (pkt_checksum == 0xFFFF) { - pkt_checksum = 0; - } - } - - /* Delete old Source-IP-Address */ - checksum -= *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; - checksum -= *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; - - pkt_checksum -= *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; - pkt_checksum -= *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; - - /* Change Source-IP-Address */ - * ((u32_t *) (pkt->data + 16)) = newip; - - /* Add new Source-IP-Address */ - checksum += *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; - checksum += *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; - - pkt_checksum += *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; - pkt_checksum += *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; - - /* Write new checksum */ - if (!checksum) { - checksum = 0xFFFF; - } - *((unsigned short *) (pkt->data+14)) = checksum; - if (pkt->data[13] == 6) { - *((unsigned short *) (pkt->data+20+iphdr)) = pkt_checksum; - } - if (cv && (pkt->data[13] == 17) ) { - *((unsigned short *) (pkt->data+10+iphdr)) = pkt_checksum; - } - - /* Log Packet */ - strcpy(ipstr,inet_ntoa(*( (struct in_addr *) (pkt->data+16)))); - if (pkt->data[13] == 1) { - syslog(LOG_INFO,"Open ICMP %s -> %s\n", - ipstr, - inet_ntoa(*( (struct in_addr *) (pkt->data+20)))); - } else { - syslog(LOG_INFO,"Open %s %s:%d -> %s:%d\n", - pkt->data[13] == 6 ? "TCP" : "UDP", - ipstr, - ntohs(*( (short *) (pkt->data+iphdr+4))), - inet_ntoa(*( (struct in_addr *) (pkt->data+20))), - ntohs(*( (short *) (pkt->data+iphdr+6)))); - } - } - output(pcb, pkt->data, pkt->length); - free(pkt); - } else { - if (prev == NULL) - pend_q = pkt; - else - prev->next = pkt; - prev = pkt; - } - } - pend_qtail = prev; - if (prev != NULL) - prev->next = NULL; -} - -/* - * Scan a packet to decide whether it is an "active" packet, - * that is, whether it is worth bringing up the link for. - */ -static int -active_packet(p, len) - unsigned char *p; - int len; -{ - int proto, i; - const struct protent *protp; - - if (len < PPP_HDRLEN) - return 0; - proto = PPP_PROTOCOL(p); -#ifdef PPP_FILTER - p[0] = 1; /* outbound packet indicator */ - if ((pass_filter.bf_len != 0 - && bpf_filter(pass_filter.bf_insns, p, len, len) == 0) - || (active_filter.bf_len != 0 - && bpf_filter(active_filter.bf_insns, p, len, len) == 0)) { - p[0] = 0xff; - return 0; - } - p[0] = 0xff; -#endif - for (i = 0; (protp = protocols[i]) != NULL; ++i) { - if (protp->protocol < 0xC000 && (protp->protocol & ~0x8000) == proto) { - if (protp->active_pkt == NULL) - return 1; - return (*protp->active_pkt)(p, len); - } - } - return 0; /* not a supported protocol !!?? */ -} - -#endif /* PPP_SUPPORT && DEMAND_SUPPORT */ +/* + * demand.c - Support routines for demand-dialling. + * + * Copyright (c) 1996-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && DEMAND_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef PPP_FILTER +#include +#endif + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/ipcp.h" +#include "netif/ppp/lcp.h" + +char *frame; +int framelen; +int framemax; +int escape_flag; +int flush_flag; +int fcs; + +struct packet { + int length; + struct packet *next; + unsigned char data[1]; +}; + +struct packet *pend_q; +struct packet *pend_qtail; + +static int active_packet (unsigned char *, int); + +/* + * demand_conf - configure the interface for doing dial-on-demand. + */ +void +demand_conf() +{ + int i; + const struct protent *protp; + +/* framemax = lcp_allowoptions[0].mru; + if (framemax < PPP_MRU) */ + framemax = PPP_MRU; + framemax += PPP_HDRLEN + PPP_FCSLEN; + frame = malloc(framemax); + if (frame == NULL) + novm("demand frame"); + framelen = 0; + pend_q = NULL; + escape_flag = 0; + flush_flag = 0; + fcs = PPP_INITFCS; + + netif_set_mtu(pcb, LWIP_MIN(lcp_allowoptions[0].mru, PPP_MRU)); + if (ppp_send_config(pcb, PPP_MRU, (u32_t) 0, 0, 0) < 0 + || ppp_recv_config(pcb, PPP_MRU, (u32_t) 0, 0, 0) < 0) + fatal("Couldn't set up demand-dialled PPP interface: %m"); + +#ifdef PPP_FILTER + set_filters(&pass_filter, &active_filter); +#endif + + /* + * Call the demand_conf procedure for each protocol that's got one. + */ + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (protp->demand_conf != NULL) + ((*protp->demand_conf)(pcb)); +/* FIXME: find a way to die() here */ +#if 0 + if (!((*protp->demand_conf)(pcb))) + die(1); +#endif +} + + +/* + * demand_block - set each network protocol to block further packets. + */ +void +demand_block() +{ + int i; + const struct protent *protp; + + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (protp->demand_conf != NULL) + sifnpmode(pcb, protp->protocol & ~0x8000, NPMODE_QUEUE); + get_loop_output(); +} + +/* + * demand_discard - set each network protocol to discard packets + * with an error. + */ +void +demand_discard() +{ + struct packet *pkt, *nextpkt; + int i; + const struct protent *protp; + + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (protp->demand_conf != NULL) + sifnpmode(pcb, protp->protocol & ~0x8000, NPMODE_ERROR); + get_loop_output(); + + /* discard all saved packets */ + for (pkt = pend_q; pkt != NULL; pkt = nextpkt) { + nextpkt = pkt->next; + free(pkt); + } + pend_q = NULL; + framelen = 0; + flush_flag = 0; + escape_flag = 0; + fcs = PPP_INITFCS; +} + +/* + * demand_unblock - set each enabled network protocol to pass packets. + */ +void +demand_unblock() +{ + int i; + const struct protent *protp; + + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (protp->demand_conf != NULL) + sifnpmode(pcb, protp->protocol & ~0x8000, NPMODE_PASS); +} + +/* + * FCS lookup table as calculated by genfcstab. + */ +static u_short fcstab[256] = { + 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, + 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, + 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, + 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, + 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, + 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, + 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, + 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, + 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, + 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, + 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, + 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, + 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, + 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, + 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, + 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, + 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, + 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, + 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, + 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, + 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, + 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, + 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, + 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, + 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, + 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, + 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, + 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, + 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, + 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, + 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, + 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 +}; + +/* + * loop_chars - process characters received from the loopback. + * Calls loop_frame when a complete frame has been accumulated. + * Return value is 1 if we need to bring up the link, 0 otherwise. + */ +int +loop_chars(p, n) + unsigned char *p; + int n; +{ + int c, rv; + + rv = 0; + +/* check for synchronous connection... */ + + if ( (p[0] == 0xFF) && (p[1] == 0x03) ) { + rv = loop_frame(p,n); + return rv; + } + + for (; n > 0; --n) { + c = *p++; + if (c == PPP_FLAG) { + if (!escape_flag && !flush_flag + && framelen > 2 && fcs == PPP_GOODFCS) { + framelen -= 2; + if (loop_frame((unsigned char *)frame, framelen)) + rv = 1; + } + framelen = 0; + flush_flag = 0; + escape_flag = 0; + fcs = PPP_INITFCS; + continue; + } + if (flush_flag) + continue; + if (escape_flag) { + c ^= PPP_TRANS; + escape_flag = 0; + } else if (c == PPP_ESCAPE) { + escape_flag = 1; + continue; + } + if (framelen >= framemax) { + flush_flag = 1; + continue; + } + frame[framelen++] = c; + fcs = PPP_FCS(fcs, c); + } + return rv; +} + +/* + * loop_frame - given a frame obtained from the loopback, + * decide whether to bring up the link or not, and, if we want + * to transmit this frame later, put it on the pending queue. + * Return value is 1 if we need to bring up the link, 0 otherwise. + * We assume that the kernel driver has already applied the + * pass_filter, so we won't get packets it rejected. + * We apply the active_filter to see if we want this packet to + * bring up the link. + */ +int +loop_frame(frame, len) + unsigned char *frame; + int len; +{ + struct packet *pkt; + + /* dbglog("from loop: %P", frame, len); */ + if (len < PPP_HDRLEN) + return 0; + if ((PPP_PROTOCOL(frame) & 0x8000) != 0) + return 0; /* shouldn't get any of these anyway */ + if (!active_packet(frame, len)) + return 0; + + pkt = (struct packet *) malloc(sizeof(struct packet) + len); + if (pkt != NULL) { + pkt->length = len; + pkt->next = NULL; + memcpy(pkt->data, frame, len); + if (pend_q == NULL) + pend_q = pkt; + else + pend_qtail->next = pkt; + pend_qtail = pkt; + } + return 1; +} + +/* + * demand_rexmit - Resend all those frames which we got via the + * loopback, now that the real serial link is up. + */ +void +demand_rexmit(proto, newip) + int proto; + u32_t newip; +{ + struct packet *pkt, *prev, *nextpkt; + unsigned short checksum; + unsigned short pkt_checksum = 0; + unsigned iphdr; + struct timeval tv; + char cv = 0; + char ipstr[16]; + + prev = NULL; + pkt = pend_q; + pend_q = NULL; + tv.tv_sec = 1; + tv.tv_usec = 0; + select(0,NULL,NULL,NULL,&tv); /* Sleep for 1 Seconds */ + for (; pkt != NULL; pkt = nextpkt) { + nextpkt = pkt->next; + if (PPP_PROTOCOL(pkt->data) == proto) { + if ( (proto == PPP_IP) && newip ) { + /* Get old checksum */ + + iphdr = (pkt->data[4] & 15) << 2; + checksum = *((unsigned short *) (pkt->data+14)); + if (checksum == 0xFFFF) { + checksum = 0; + } + + + if (pkt->data[13] == 17) { + pkt_checksum = *((unsigned short *) (pkt->data+10+iphdr)); + if (pkt_checksum) { + cv = 1; + if (pkt_checksum == 0xFFFF) { + pkt_checksum = 0; + } + } + else { + cv = 0; + } + } + + if (pkt->data[13] == 6) { + pkt_checksum = *((unsigned short *) (pkt->data+20+iphdr)); + cv = 1; + if (pkt_checksum == 0xFFFF) { + pkt_checksum = 0; + } + } + + /* Delete old Source-IP-Address */ + checksum -= *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; + checksum -= *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; + + pkt_checksum -= *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; + pkt_checksum -= *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; + + /* Change Source-IP-Address */ + * ((u32_t *) (pkt->data + 16)) = newip; + + /* Add new Source-IP-Address */ + checksum += *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; + checksum += *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; + + pkt_checksum += *((unsigned short *) (pkt->data+16)) ^ 0xFFFF; + pkt_checksum += *((unsigned short *) (pkt->data+18)) ^ 0xFFFF; + + /* Write new checksum */ + if (!checksum) { + checksum = 0xFFFF; + } + *((unsigned short *) (pkt->data+14)) = checksum; + if (pkt->data[13] == 6) { + *((unsigned short *) (pkt->data+20+iphdr)) = pkt_checksum; + } + if (cv && (pkt->data[13] == 17) ) { + *((unsigned short *) (pkt->data+10+iphdr)) = pkt_checksum; + } + + /* Log Packet */ + strcpy(ipstr,inet_ntoa(*( (struct in_addr *) (pkt->data+16)))); + if (pkt->data[13] == 1) { + syslog(LOG_INFO,"Open ICMP %s -> %s\n", + ipstr, + inet_ntoa(*( (struct in_addr *) (pkt->data+20)))); + } else { + syslog(LOG_INFO,"Open %s %s:%d -> %s:%d\n", + pkt->data[13] == 6 ? "TCP" : "UDP", + ipstr, + ntohs(*( (short *) (pkt->data+iphdr+4))), + inet_ntoa(*( (struct in_addr *) (pkt->data+20))), + ntohs(*( (short *) (pkt->data+iphdr+6)))); + } + } + output(pcb, pkt->data, pkt->length); + free(pkt); + } else { + if (prev == NULL) + pend_q = pkt; + else + prev->next = pkt; + prev = pkt; + } + } + pend_qtail = prev; + if (prev != NULL) + prev->next = NULL; +} + +/* + * Scan a packet to decide whether it is an "active" packet, + * that is, whether it is worth bringing up the link for. + */ +static int +active_packet(p, len) + unsigned char *p; + int len; +{ + int proto, i; + const struct protent *protp; + + if (len < PPP_HDRLEN) + return 0; + proto = PPP_PROTOCOL(p); +#ifdef PPP_FILTER + p[0] = 1; /* outbound packet indicator */ + if ((pass_filter.bf_len != 0 + && bpf_filter(pass_filter.bf_insns, p, len, len) == 0) + || (active_filter.bf_len != 0 + && bpf_filter(active_filter.bf_insns, p, len, len) == 0)) { + p[0] = 0xff; + return 0; + } + p[0] = 0xff; +#endif + for (i = 0; (protp = protocols[i]) != NULL; ++i) { + if (protp->protocol < 0xC000 && (protp->protocol & ~0x8000) == proto) { + if (protp->active_pkt == NULL) + return 1; + return (*protp->active_pkt)(p, len); + } + } + return 0; /* not a supported protocol !!?? */ +} + +#endif /* PPP_SUPPORT && DEMAND_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eap.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eap.c index 5000e26b..8fb56368 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eap.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eap.c @@ -1,2423 +1,2423 @@ -/* - * eap.c - Extensible Authentication Protocol for PPP (RFC 2284) - * - * Copyright (c) 2001 by Sun Microsystems, Inc. - * All rights reserved. - * - * Non-exclusive rights to redistribute, modify, translate, and use - * this software in source and binary forms, in whole or in part, is - * hereby granted, provided that the above copyright notice is - * duplicated in any source form, and that neither the name of the - * copyright holder nor the author is used to endorse or promote - * products derived from this software. - * - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. - * - * Original version by James Carlson - * - * This implementation of EAP supports MD5-Challenge and SRP-SHA1 - * authentication styles. Note that support of MD5-Challenge is a - * requirement of RFC 2284, and that it's essentially just a - * reimplementation of regular RFC 1994 CHAP using EAP messages. - * - * As an authenticator ("server"), there are multiple phases for each - * style. In the first phase of each style, the unauthenticated peer - * name is queried using the EAP Identity request type. If the - * "remotename" option is used, then this phase is skipped, because - * the peer's name is presumed to be known. - * - * For MD5-Challenge, there are two phases, and the second phase - * consists of sending the challenge itself and handling the - * associated response. - * - * For SRP-SHA1, there are four phases. The second sends 's', 'N', - * and 'g'. The reply contains 'A'. The third sends 'B', and the - * reply contains 'M1'. The forth sends the 'M2' value. - * - * As an authenticatee ("client"), there's just a single phase -- - * responding to the queries generated by the peer. EAP is an - * authenticator-driven protocol. - * - * Based on draft-ietf-pppext-eap-srp-03.txt. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && EAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/eap.h" -#include "netif/ppp/magic.h" -#include "netif/ppp/pppcrypt.h" - -#ifdef USE_SRP -#include -#include -#include -#endif /* USE_SRP */ - -#ifndef SHA_DIGESTSIZE -#define SHA_DIGESTSIZE 20 -#endif - -#ifdef USE_SRP -static char *pn_secret = NULL; /* Pseudonym generating secret */ -#endif - -#if PPP_OPTIONS -/* - * Command-line options. - */ -static option_t eap_option_list[] = { - { "eap-restart", o_int, &eap_states[0].es_server.ea_timeout, - "Set retransmit timeout for EAP Requests (server)" }, - { "eap-max-sreq", o_int, &eap_states[0].es_server.ea_maxrequests, - "Set max number of EAP Requests sent (server)" }, - { "eap-timeout", o_int, &eap_states[0].es_client.ea_timeout, - "Set time limit for peer EAP authentication" }, - { "eap-max-rreq", o_int, &eap_states[0].es_client.ea_maxrequests, - "Set max number of EAP Requests allows (client)" }, - { "eap-interval", o_int, &eap_states[0].es_rechallenge, - "Set interval for EAP rechallenge" }, -#ifdef USE_SRP - { "srp-interval", o_int, &eap_states[0].es_lwrechallenge, - "Set interval for SRP lightweight rechallenge" }, - { "srp-pn-secret", o_string, &pn_secret, - "Long term pseudonym generation secret" }, - { "srp-use-pseudonym", o_bool, &eap_states[0].es_usepseudo, - "Use pseudonym if offered one by server", 1 }, -#endif - { NULL } -}; -#endif /* PPP_OPTIONS */ - -/* - * Protocol entry points. - */ -static void eap_init(ppp_pcb *pcb); -static void eap_input(ppp_pcb *pcb, u_char *inp, int inlen); -static void eap_protrej(ppp_pcb *pcb); -static void eap_lowerup(ppp_pcb *pcb); -static void eap_lowerdown(ppp_pcb *pcb); -#if PRINTPKT_SUPPORT -static int eap_printpkt(const u_char *inp, int inlen, - void (*)(void *arg, const char *fmt, ...), void *arg); -#endif /* PRINTPKT_SUPPORT */ - -const struct protent eap_protent = { - PPP_EAP, /* protocol number */ - eap_init, /* initialization procedure */ - eap_input, /* process a received packet */ - eap_protrej, /* process a received protocol-reject */ - eap_lowerup, /* lower layer has gone up */ - eap_lowerdown, /* lower layer has gone down */ - NULL, /* open the protocol */ - NULL, /* close the protocol */ -#if PRINTPKT_SUPPORT - eap_printpkt, /* print a packet in readable form */ -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - NULL, /* process a received data packet */ -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "EAP", /* text name of protocol */ - NULL, /* text name of corresponding data protocol */ -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - eap_option_list, /* list of command-line options */ - NULL, /* check requested options; assign defaults */ -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - NULL, /* configure interface for demand-dial */ - NULL /* say whether to bring up link for this pkt */ -#endif /* DEMAND_SUPPORT */ -}; - -#ifdef USE_SRP -/* - * A well-known 2048 bit modulus. - */ -static const u_char wkmodulus[] = { - 0xAC, 0x6B, 0xDB, 0x41, 0x32, 0x4A, 0x9A, 0x9B, - 0xF1, 0x66, 0xDE, 0x5E, 0x13, 0x89, 0x58, 0x2F, - 0xAF, 0x72, 0xB6, 0x65, 0x19, 0x87, 0xEE, 0x07, - 0xFC, 0x31, 0x92, 0x94, 0x3D, 0xB5, 0x60, 0x50, - 0xA3, 0x73, 0x29, 0xCB, 0xB4, 0xA0, 0x99, 0xED, - 0x81, 0x93, 0xE0, 0x75, 0x77, 0x67, 0xA1, 0x3D, - 0xD5, 0x23, 0x12, 0xAB, 0x4B, 0x03, 0x31, 0x0D, - 0xCD, 0x7F, 0x48, 0xA9, 0xDA, 0x04, 0xFD, 0x50, - 0xE8, 0x08, 0x39, 0x69, 0xED, 0xB7, 0x67, 0xB0, - 0xCF, 0x60, 0x95, 0x17, 0x9A, 0x16, 0x3A, 0xB3, - 0x66, 0x1A, 0x05, 0xFB, 0xD5, 0xFA, 0xAA, 0xE8, - 0x29, 0x18, 0xA9, 0x96, 0x2F, 0x0B, 0x93, 0xB8, - 0x55, 0xF9, 0x79, 0x93, 0xEC, 0x97, 0x5E, 0xEA, - 0xA8, 0x0D, 0x74, 0x0A, 0xDB, 0xF4, 0xFF, 0x74, - 0x73, 0x59, 0xD0, 0x41, 0xD5, 0xC3, 0x3E, 0xA7, - 0x1D, 0x28, 0x1E, 0x44, 0x6B, 0x14, 0x77, 0x3B, - 0xCA, 0x97, 0xB4, 0x3A, 0x23, 0xFB, 0x80, 0x16, - 0x76, 0xBD, 0x20, 0x7A, 0x43, 0x6C, 0x64, 0x81, - 0xF1, 0xD2, 0xB9, 0x07, 0x87, 0x17, 0x46, 0x1A, - 0x5B, 0x9D, 0x32, 0xE6, 0x88, 0xF8, 0x77, 0x48, - 0x54, 0x45, 0x23, 0xB5, 0x24, 0xB0, 0xD5, 0x7D, - 0x5E, 0xA7, 0x7A, 0x27, 0x75, 0xD2, 0xEC, 0xFA, - 0x03, 0x2C, 0xFB, 0xDB, 0xF5, 0x2F, 0xB3, 0x78, - 0x61, 0x60, 0x27, 0x90, 0x04, 0xE5, 0x7A, 0xE6, - 0xAF, 0x87, 0x4E, 0x73, 0x03, 0xCE, 0x53, 0x29, - 0x9C, 0xCC, 0x04, 0x1C, 0x7B, 0xC3, 0x08, 0xD8, - 0x2A, 0x56, 0x98, 0xF3, 0xA8, 0xD0, 0xC3, 0x82, - 0x71, 0xAE, 0x35, 0xF8, 0xE9, 0xDB, 0xFB, 0xB6, - 0x94, 0xB5, 0xC8, 0x03, 0xD8, 0x9F, 0x7A, 0xE4, - 0x35, 0xDE, 0x23, 0x6D, 0x52, 0x5F, 0x54, 0x75, - 0x9B, 0x65, 0xE3, 0x72, 0xFC, 0xD6, 0x8E, 0xF2, - 0x0F, 0xA7, 0x11, 0x1F, 0x9E, 0x4A, 0xFF, 0x73 -}; -#endif - -#if PPP_SERVER -/* Local forward declarations. */ -static void eap_server_timeout(void *arg); -#endif /* PPP_SERVER */ - -/* - * Convert EAP state code to printable string for debug. - */ -static const char * eap_state_name(enum eap_state_code esc) -{ - static const char *state_names[] = { EAP_STATES }; - - return (state_names[(int)esc]); -} - -/* - * eap_init - Initialize state for an EAP user. This is currently - * called once by main() during start-up. - */ -static void eap_init(ppp_pcb *pcb) { - - BZERO(&pcb->eap, sizeof(eap_state)); -#if PPP_SERVER - pcb->eap.es_server.ea_id = magic(); -#endif /* PPP_SERVER */ -} - -/* - * eap_client_timeout - Give up waiting for the peer to send any - * Request messages. - */ -static void eap_client_timeout(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - - if (!eap_client_active(pcb)) - return; - - ppp_error("EAP: timeout waiting for Request from peer"); - auth_withpeer_fail(pcb, PPP_EAP); - pcb->eap.es_client.ea_state = eapBadAuth; -} - -/* - * eap_authwithpeer - Authenticate to our peer (behave as client). - * - * Start client state and wait for requests. This is called only - * after eap_lowerup. - */ -void eap_authwithpeer(ppp_pcb *pcb, const char *localname) { - - if(NULL == localname) - return; - - /* Save the peer name we're given */ - pcb->eap.es_client.ea_name = localname; - pcb->eap.es_client.ea_namelen = strlen(localname); - - pcb->eap.es_client.ea_state = eapListen; - - /* - * Start a timer so that if the other end just goes - * silent, we don't sit here waiting forever. - */ - if (pcb->settings.eap_req_time > 0) - TIMEOUT(eap_client_timeout, pcb, - pcb->settings.eap_req_time); -} - -#if PPP_SERVER -/* - * Format a standard EAP Failure message and send it to the peer. - * (Server operation) - */ -static void eap_send_failure(ppp_pcb *pcb) { - struct pbuf *p; - u_char *outp; - - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + EAP_HEADERLEN), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_FAILURE, outp); - pcb->eap.es_server.ea_id++; - PUTCHAR(pcb->eap.es_server.ea_id, outp); - PUTSHORT(EAP_HEADERLEN, outp); - - ppp_write(pcb, p); - - pcb->eap.es_server.ea_state = eapBadAuth; - auth_peer_fail(pcb, PPP_EAP); -} - -/* - * Format a standard EAP Success message and send it to the peer. - * (Server operation) - */ -static void eap_send_success(ppp_pcb *pcb) { - struct pbuf *p; - u_char *outp; - - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + EAP_HEADERLEN), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_SUCCESS, outp); - pcb->eap.es_server.ea_id++; - PUTCHAR(pcb->eap.es_server.ea_id, outp); - PUTSHORT(EAP_HEADERLEN, outp); - - ppp_write(pcb, p); - - auth_peer_success(pcb, PPP_EAP, 0, - pcb->eap.es_server.ea_peer, pcb->eap.es_server.ea_peerlen); -} -#endif /* PPP_SERVER */ - -#ifdef USE_SRP -/* - * Set DES key according to pseudonym-generating secret and current - * date. - */ -static bool -pncrypt_setkey(int timeoffs) -{ - struct tm *tp; - char tbuf[9]; - SHA1_CTX ctxt; - u_char dig[SHA_DIGESTSIZE]; - time_t reftime; - - if (pn_secret == NULL) - return (0); - reftime = time(NULL) + timeoffs; - tp = localtime(&reftime); - SHA1Init(&ctxt); - SHA1Update(&ctxt, pn_secret, strlen(pn_secret)); - strftime(tbuf, sizeof (tbuf), "%Y%m%d", tp); - SHA1Update(&ctxt, tbuf, strlen(tbuf)); - SHA1Final(dig, &ctxt); - /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ - return (DesSetkey(dig)); -} - -static char base64[] = -"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - -struct b64state { - u32_t bs_bits; - int bs_offs; -}; - -static int -b64enc(bs, inp, inlen, outp) -struct b64state *bs; -u_char *inp; -int inlen; -u_char *outp; -{ - int outlen = 0; - - while (inlen > 0) { - bs->bs_bits = (bs->bs_bits << 8) | *inp++; - inlen--; - bs->bs_offs += 8; - if (bs->bs_offs >= 24) { - *outp++ = base64[(bs->bs_bits >> 18) & 0x3F]; - *outp++ = base64[(bs->bs_bits >> 12) & 0x3F]; - *outp++ = base64[(bs->bs_bits >> 6) & 0x3F]; - *outp++ = base64[bs->bs_bits & 0x3F]; - outlen += 4; - bs->bs_offs = 0; - bs->bs_bits = 0; - } - } - return (outlen); -} - -static int -b64flush(bs, outp) -struct b64state *bs; -u_char *outp; -{ - int outlen = 0; - - if (bs->bs_offs == 8) { - *outp++ = base64[(bs->bs_bits >> 2) & 0x3F]; - *outp++ = base64[(bs->bs_bits << 4) & 0x3F]; - outlen = 2; - } else if (bs->bs_offs == 16) { - *outp++ = base64[(bs->bs_bits >> 10) & 0x3F]; - *outp++ = base64[(bs->bs_bits >> 4) & 0x3F]; - *outp++ = base64[(bs->bs_bits << 2) & 0x3F]; - outlen = 3; - } - bs->bs_offs = 0; - bs->bs_bits = 0; - return (outlen); -} - -static int -b64dec(bs, inp, inlen, outp) -struct b64state *bs; -u_char *inp; -int inlen; -u_char *outp; -{ - int outlen = 0; - char *cp; - - while (inlen > 0) { - if ((cp = strchr(base64, *inp++)) == NULL) - break; - bs->bs_bits = (bs->bs_bits << 6) | (cp - base64); - inlen--; - bs->bs_offs += 6; - if (bs->bs_offs >= 8) { - *outp++ = bs->bs_bits >> (bs->bs_offs - 8); - outlen++; - bs->bs_offs -= 8; - } - } - return (outlen); -} -#endif /* USE_SRP */ - -#if PPP_SERVER -/* - * Assume that current waiting server state is complete and figure - * next state to use based on available authentication data. 'status' - * indicates if there was an error in handling the last query. It is - * 0 for success and non-zero for failure. - */ -static void eap_figure_next_state(ppp_pcb *pcb, int status) { -#ifdef USE_SRP - unsigned char secbuf[MAXSECRETLEN], clear[8], *sp, *dp; - struct t_pw tpw; - struct t_confent *tce, mytce; - char *cp, *cp2; - struct t_server *ts; - int id, i, plen, toffs; - u_char vals[2]; - struct b64state bs; -#endif /* USE_SRP */ - - pcb->settings.eap_timeout_time = pcb->eap.es_savedtime; - switch (pcb->eap.es_server.ea_state) { - case eapBadAuth: - return; - - case eapIdentify: -#ifdef USE_SRP - /* Discard any previous session. */ - ts = (struct t_server *)pcb->eap.es_server.ea_session; - if (ts != NULL) { - t_serverclose(ts); - pcb->eap.es_server.ea_session = NULL; - pcb->eap.es_server.ea_skey = NULL; - } -#endif /* USE_SRP */ - if (status != 0) { - pcb->eap.es_server.ea_state = eapBadAuth; - break; - } -#ifdef USE_SRP - /* If we've got a pseudonym, try to decode to real name. */ - if (pcb->eap.es_server.ea_peerlen > SRP_PSEUDO_LEN && - strncmp(pcb->eap.es_server.ea_peer, SRP_PSEUDO_ID, - SRP_PSEUDO_LEN) == 0 && - (pcb->eap.es_server.ea_peerlen - SRP_PSEUDO_LEN) * 3 / 4 < - sizeof (secbuf)) { - BZERO(&bs, sizeof (bs)); - plen = b64dec(&bs, - pcb->eap.es_server.ea_peer + SRP_PSEUDO_LEN, - pcb->eap.es_server.ea_peerlen - SRP_PSEUDO_LEN, - secbuf); - toffs = 0; - for (i = 0; i < 5; i++) { - pncrypt_setkey(toffs); - toffs -= 86400; - /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ - if (!DesDecrypt(secbuf, clear)) { - ppp_dbglog("no DES here; cannot decode " - "pseudonym"); - return; - } - id = *(unsigned char *)clear; - if (id + 1 <= plen && id + 9 > plen) - break; - } - if (plen % 8 == 0 && i < 5) { - /* - * Note that this is always shorter than the - * original stored string, so there's no need - * to realloc. - */ - if ((i = plen = *(unsigned char *)clear) > 7) - i = 7; - pcb->eap.es_server.ea_peerlen = plen; - dp = (unsigned char *)pcb->eap.es_server.ea_peer; - MEMCPY(dp, clear + 1, i); - plen -= i; - dp += i; - sp = secbuf + 8; - while (plen > 0) { - /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ - (void) DesDecrypt(sp, dp); - sp += 8; - dp += 8; - plen -= 8; - } - pcb->eap.es_server.ea_peer[ - pcb->eap.es_server.ea_peerlen] = '\0'; - ppp_dbglog("decoded pseudonym to \"%.*q\"", - pcb->eap.es_server.ea_peerlen, - pcb->eap.es_server.ea_peer); - } else { - ppp_dbglog("failed to decode real name"); - /* Stay in eapIdentfy state; requery */ - break; - } - } - /* Look up user in secrets database. */ - if (get_srp_secret(pcb->eap.es_unit, pcb->eap.es_server.ea_peer, - pcb->eap.es_server.ea_name, (char *)secbuf, 1) != 0) { - /* Set up default in case SRP entry is bad */ - pcb->eap.es_server.ea_state = eapMD5Chall; - /* Get t_confent based on index in srp-secrets */ - id = strtol((char *)secbuf, &cp, 10); - if (*cp++ != ':' || id < 0) - break; - if (id == 0) { - mytce.index = 0; - mytce.modulus.data = (u_char *)wkmodulus; - mytce.modulus.len = sizeof (wkmodulus); - mytce.generator.data = (u_char *)"\002"; - mytce.generator.len = 1; - tce = &mytce; - } else if ((tce = gettcid(id)) != NULL) { - /* - * Client will have to verify this modulus/ - * generator combination, and that will take - * a while. Lengthen the timeout here. - */ - if (pcb->settings.eap_timeout_time > 0 && - pcb->settings.eap_timeout_time < 30) - pcb->settings.eap_timeout_time = 30; - } else { - break; - } - if ((cp2 = strchr(cp, ':')) == NULL) - break; - *cp2++ = '\0'; - tpw.pebuf.name = pcb->eap.es_server.ea_peer; - tpw.pebuf.password.len = t_fromb64((char *)tpw.pwbuf, - cp); - tpw.pebuf.password.data = tpw.pwbuf; - tpw.pebuf.salt.len = t_fromb64((char *)tpw.saltbuf, - cp2); - tpw.pebuf.salt.data = tpw.saltbuf; - if ((ts = t_serveropenraw(&tpw.pebuf, tce)) == NULL) - break; - pcb->eap.es_server.ea_session = (void *)ts; - pcb->eap.es_server.ea_state = eapSRP1; - vals[0] = pcb->eap.es_server.ea_id + 1; - vals[1] = EAPT_SRP; - t_serveraddexdata(ts, vals, 2); - /* Generate B; must call before t_servergetkey() */ - t_servergenexp(ts); - break; - } -#endif /* USE_SRP */ - pcb->eap.es_server.ea_state = eapMD5Chall; - break; - - case eapSRP1: -#ifdef USE_SRP - ts = (struct t_server *)pcb->eap.es_server.ea_session; - if (ts != NULL && status != 0) { - t_serverclose(ts); - pcb->eap.es_server.ea_session = NULL; - pcb->eap.es_server.ea_skey = NULL; - } -#endif /* USE_SRP */ - if (status == 1) { - pcb->eap.es_server.ea_state = eapMD5Chall; - } else if (status != 0 || pcb->eap.es_server.ea_session == NULL) { - pcb->eap.es_server.ea_state = eapBadAuth; - } else { - pcb->eap.es_server.ea_state = eapSRP2; - } - break; - - case eapSRP2: -#ifdef USE_SRP - ts = (struct t_server *)pcb->eap.es_server.ea_session; - if (ts != NULL && status != 0) { - t_serverclose(ts); - pcb->eap.es_server.ea_session = NULL; - pcb->eap.es_server.ea_skey = NULL; - } -#endif /* USE_SRP */ - if (status != 0 || pcb->eap.es_server.ea_session == NULL) { - pcb->eap.es_server.ea_state = eapBadAuth; - } else { - pcb->eap.es_server.ea_state = eapSRP3; - } - break; - - case eapSRP3: - case eapSRP4: -#ifdef USE_SRP - ts = (struct t_server *)pcb->eap.es_server.ea_session; - if (ts != NULL && status != 0) { - t_serverclose(ts); - pcb->eap.es_server.ea_session = NULL; - pcb->eap.es_server.ea_skey = NULL; - } -#endif /* USE_SRP */ - if (status != 0 || pcb->eap.es_server.ea_session == NULL) { - pcb->eap.es_server.ea_state = eapBadAuth; - } else { - pcb->eap.es_server.ea_state = eapOpen; - } - break; - - case eapMD5Chall: - if (status != 0) { - pcb->eap.es_server.ea_state = eapBadAuth; - } else { - pcb->eap.es_server.ea_state = eapOpen; - } - break; - - default: - pcb->eap.es_server.ea_state = eapBadAuth; - break; - } - if (pcb->eap.es_server.ea_state == eapBadAuth) - eap_send_failure(pcb); -} - -/* - * Format an EAP Request message and send it to the peer. Message - * type depends on current state. (Server operation) - */ -static void eap_send_request(ppp_pcb *pcb) { - struct pbuf *p; - u_char *outp; - u_char *lenloc; - int outlen; - int len; - const char *str; -#ifdef USE_SRP - struct t_server *ts; - u_char clear[8], cipher[8], dig[SHA_DIGESTSIZE], *optr, *cp; - int i, j; - struct b64state b64; - SHA1_CTX ctxt; -#endif /* USE_SRP */ - - /* Handle both initial auth and restart */ - if (pcb->eap.es_server.ea_state < eapIdentify && - pcb->eap.es_server.ea_state != eapInitial) { - pcb->eap.es_server.ea_state = eapIdentify; -#if PPP_REMOTENAME - if (pcb->settings.explicit_remote && pcb->remote_name) { - /* - * If we already know the peer's - * unauthenticated name, then there's no - * reason to ask. Go to next state instead. - */ - int len = (int)strlen(pcb->remote_name); - if (len > MAXNAMELEN) { - len = MAXNAMELEN; - } - MEMCPY(pcb->eap.es_server.ea_peer, pcb->remote_name, len); - pcb->eap.es_server.ea_peer[len] = '\0'; - pcb->eap.es_server.ea_peerlen = len; - eap_figure_next_state(pcb, 0); - } -#endif /* PPP_REMOTENAME */ - } - - if (pcb->settings.eap_max_transmits > 0 && - pcb->eap.es_server.ea_requests >= pcb->settings.eap_max_transmits) { - if (pcb->eap.es_server.ea_responses > 0) - ppp_error("EAP: too many Requests sent"); - else - ppp_error("EAP: no response to Requests"); - eap_send_failure(pcb); - return; - } - - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_CTRL_PBUF_MAX_SIZE), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_REQUEST, outp); - PUTCHAR(pcb->eap.es_server.ea_id, outp); - lenloc = outp; - INCPTR(2, outp); - - switch (pcb->eap.es_server.ea_state) { - case eapIdentify: - PUTCHAR(EAPT_IDENTITY, outp); - str = "Name"; - len = strlen(str); - MEMCPY(outp, str, len); - INCPTR(len, outp); - break; - - case eapMD5Chall: - PUTCHAR(EAPT_MD5CHAP, outp); - /* - * pick a random challenge length between - * EAP_MIN_CHALLENGE_LENGTH and EAP_MAX_CHALLENGE_LENGTH - */ - pcb->eap.es_challen = EAP_MIN_CHALLENGE_LENGTH + - magic_pow(EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH); - PUTCHAR(pcb->eap.es_challen, outp); - magic_random_bytes(pcb->eap.es_challenge, pcb->eap.es_challen); - MEMCPY(outp, pcb->eap.es_challenge, pcb->eap.es_challen); - INCPTR(pcb->eap.es_challen, outp); - MEMCPY(outp, pcb->eap.es_server.ea_name, pcb->eap.es_server.ea_namelen); - INCPTR(pcb->eap.es_server.ea_namelen, outp); - break; - -#ifdef USE_SRP - case eapSRP1: - PUTCHAR(EAPT_SRP, outp); - PUTCHAR(EAPSRP_CHALLENGE, outp); - - PUTCHAR(pcb->eap.es_server.ea_namelen, outp); - MEMCPY(outp, pcb->eap.es_server.ea_name, pcb->eap.es_server.ea_namelen); - INCPTR(pcb->eap.es_server.ea_namelen, outp); - - ts = (struct t_server *)pcb->eap.es_server.ea_session; - assert(ts != NULL); - PUTCHAR(ts->s.len, outp); - MEMCPY(outp, ts->s.data, ts->s.len); - INCPTR(ts->s.len, outp); - - if (ts->g.len == 1 && ts->g.data[0] == 2) { - PUTCHAR(0, outp); - } else { - PUTCHAR(ts->g.len, outp); - MEMCPY(outp, ts->g.data, ts->g.len); - INCPTR(ts->g.len, outp); - } - - if (ts->n.len != sizeof (wkmodulus) || - BCMP(ts->n.data, wkmodulus, sizeof (wkmodulus)) != 0) { - MEMCPY(outp, ts->n.data, ts->n.len); - INCPTR(ts->n.len, outp); - } - break; - - case eapSRP2: - PUTCHAR(EAPT_SRP, outp); - PUTCHAR(EAPSRP_SKEY, outp); - - ts = (struct t_server *)pcb->eap.es_server.ea_session; - assert(ts != NULL); - MEMCPY(outp, ts->B.data, ts->B.len); - INCPTR(ts->B.len, outp); - break; - - case eapSRP3: - PUTCHAR(EAPT_SRP, outp); - PUTCHAR(EAPSRP_SVALIDATOR, outp); - PUTLONG(SRPVAL_EBIT, outp); - ts = (struct t_server *)pcb->eap.es_server.ea_session; - assert(ts != NULL); - MEMCPY(outp, t_serverresponse(ts), SHA_DIGESTSIZE); - INCPTR(SHA_DIGESTSIZE, outp); - - if (pncrypt_setkey(0)) { - /* Generate pseudonym */ - optr = outp; - cp = (unsigned char *)pcb->eap.es_server.ea_peer; - if ((j = i = pcb->eap.es_server.ea_peerlen) > 7) - j = 7; - clear[0] = i; - MEMCPY(clear + 1, cp, j); - i -= j; - cp += j; - /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ - if (!DesEncrypt(clear, cipher)) { - ppp_dbglog("no DES here; not generating pseudonym"); - break; - } - BZERO(&b64, sizeof (b64)); - outp++; /* space for pseudonym length */ - outp += b64enc(&b64, cipher, 8, outp); - while (i >= 8) { - /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ - (void) DesEncrypt(cp, cipher); - outp += b64enc(&b64, cipher, 8, outp); - cp += 8; - i -= 8; - } - if (i > 0) { - MEMCPY(clear, cp, i); - cp += i; - magic_random_bytes(cp, 8-i); - /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ - (void) DesEncrypt(clear, cipher); - outp += b64enc(&b64, cipher, 8, outp); - } - outp += b64flush(&b64, outp); - - /* Set length and pad out to next 20 octet boundary */ - i = outp - optr - 1; - *optr = i; - i %= SHA_DIGESTSIZE; - if (i != 0) { - magic_random_bytes(outp, SHA_DIGESTSIZE-i); - INCPTR(SHA_DIGESTSIZE-i, outp); - } - - /* Obscure the pseudonym with SHA1 hash */ - SHA1Init(&ctxt); - SHA1Update(&ctxt, &pcb->eap.es_server.ea_id, 1); - SHA1Update(&ctxt, pcb->eap.es_server.ea_skey, - SESSION_KEY_LEN); - SHA1Update(&ctxt, pcb->eap.es_server.ea_peer, - pcb->eap.es_server.ea_peerlen); - while (optr < outp) { - SHA1Final(dig, &ctxt); - cp = dig; - while (cp < dig + SHA_DIGESTSIZE) - *optr++ ^= *cp++; - SHA1Init(&ctxt); - SHA1Update(&ctxt, &pcb->eap.es_server.ea_id, 1); - SHA1Update(&ctxt, pcb->eap.es_server.ea_skey, - SESSION_KEY_LEN); - SHA1Update(&ctxt, optr - SHA_DIGESTSIZE, - SHA_DIGESTSIZE); - } - } - break; - - case eapSRP4: - PUTCHAR(EAPT_SRP, outp); - PUTCHAR(EAPSRP_LWRECHALLENGE, outp); - pcb->eap.es_challen = EAP_MIN_CHALLENGE_LENGTH + - magic_pow(EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH); - magic_random_bytes(pcb->eap.es_challenge, pcb->eap.es_challen); - MEMCPY(outp, pcb->eap.es_challenge, pcb->eap.es_challen); - INCPTR(pcb->eap.es_challen, outp); - break; -#endif /* USE_SRP */ - - default: - return; - } - - outlen = (outp - (unsigned char*)p->payload) - PPP_HDRLEN; - PUTSHORT(outlen, lenloc); - - pbuf_realloc(p, outlen + PPP_HDRLEN); - ppp_write(pcb, p); - - pcb->eap.es_server.ea_requests++; - - if (pcb->settings.eap_timeout_time > 0) - TIMEOUT(eap_server_timeout, pcb, pcb->settings.eap_timeout_time); -} - -/* - * eap_authpeer - Authenticate our peer (behave as server). - * - * Start server state and send first request. This is called only - * after eap_lowerup. - */ -void eap_authpeer(ppp_pcb *pcb, const char *localname) { - - /* Save the name we're given. */ - pcb->eap.es_server.ea_name = localname; - pcb->eap.es_server.ea_namelen = strlen(localname); - - pcb->eap.es_savedtime = pcb->settings.eap_timeout_time; - - /* Lower layer up yet? */ - if (pcb->eap.es_server.ea_state == eapInitial || - pcb->eap.es_server.ea_state == eapPending) { - pcb->eap.es_server.ea_state = eapPending; - return; - } - - pcb->eap.es_server.ea_state = eapPending; - - /* ID number not updated here intentionally; hashed into M1 */ - eap_send_request(pcb); -} - -/* - * eap_server_timeout - Retransmission timer for sending Requests - * expired. - */ -static void eap_server_timeout(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - - if (!eap_server_active(pcb)) - return; - - /* EAP ID number must not change on timeout. */ - eap_send_request(pcb); -} - -/* - * When it's time to send rechallenge the peer, this timeout is - * called. Once the rechallenge is successful, the response handler - * will restart the timer. If it fails, then the link is dropped. - */ -static void eap_rechallenge(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - - if (pcb->eap.es_server.ea_state != eapOpen && - pcb->eap.es_server.ea_state != eapSRP4) - return; - - pcb->eap.es_server.ea_requests = 0; - pcb->eap.es_server.ea_state = eapIdentify; - eap_figure_next_state(pcb, 0); - pcb->eap.es_server.ea_id++; - eap_send_request(pcb); -} - -static void srp_lwrechallenge(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - - if (pcb->eap.es_server.ea_state != eapOpen || - pcb->eap.es_server.ea_type != EAPT_SRP) - return; - - pcb->eap.es_server.ea_requests = 0; - pcb->eap.es_server.ea_state = eapSRP4; - pcb->eap.es_server.ea_id++; - eap_send_request(pcb); -} -#endif /* PPP_SERVER */ - -/* - * eap_lowerup - The lower layer is now up. - * - * This is called before either eap_authpeer or eap_authwithpeer. See - * link_established() in auth.c. All that's necessary here is to - * return to closed state so that those two routines will do the right - * thing. - */ -static void eap_lowerup(ppp_pcb *pcb) { - pcb->eap.es_client.ea_state = eapClosed; -#if PPP_SERVER - pcb->eap.es_server.ea_state = eapClosed; -#endif /* PPP_SERVER */ -} - -/* - * eap_lowerdown - The lower layer is now down. - * - * Cancel all timeouts and return to initial state. - */ -static void eap_lowerdown(ppp_pcb *pcb) { - - if (eap_client_active(pcb) && pcb->settings.eap_req_time > 0) { - UNTIMEOUT(eap_client_timeout, pcb); - } -#if PPP_SERVER - if (eap_server_active(pcb)) { - if (pcb->settings.eap_timeout_time > 0) { - UNTIMEOUT(eap_server_timeout, pcb); - } - } else { - if ((pcb->eap.es_server.ea_state == eapOpen || - pcb->eap.es_server.ea_state == eapSRP4) && - pcb->eap.es_rechallenge > 0) { - UNTIMEOUT(eap_rechallenge, (void *)pcb); - } - if (pcb->eap.es_server.ea_state == eapOpen && - pcb->eap.es_lwrechallenge > 0) { - UNTIMEOUT(srp_lwrechallenge, (void *)pcb); - } - } - - pcb->eap.es_client.ea_state = pcb->eap.es_server.ea_state = eapInitial; - pcb->eap.es_client.ea_requests = pcb->eap.es_server.ea_requests = 0; -#endif /* PPP_SERVER */ -} - -/* - * eap_protrej - Peer doesn't speak this protocol. - * - * This shouldn't happen. If it does, it represents authentication - * failure. - */ -static void eap_protrej(ppp_pcb *pcb) { - - if (eap_client_active(pcb)) { - ppp_error("EAP authentication failed due to Protocol-Reject"); - auth_withpeer_fail(pcb, PPP_EAP); - } -#if PPP_SERVER - if (eap_server_active(pcb)) { - ppp_error("EAP authentication of peer failed on Protocol-Reject"); - auth_peer_fail(pcb, PPP_EAP); - } -#endif /* PPP_SERVER */ - eap_lowerdown(pcb); -} - -/* - * Format and send a regular EAP Response message. - */ -static void eap_send_response(ppp_pcb *pcb, u_char id, u_char typenum, const u_char *str, int lenstr) { - struct pbuf *p; - u_char *outp; - int msglen; - - msglen = EAP_HEADERLEN + sizeof (u_char) + lenstr; - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_RESPONSE, outp); - PUTCHAR(id, outp); - pcb->eap.es_client.ea_id = id; - PUTSHORT(msglen, outp); - PUTCHAR(typenum, outp); - if (lenstr > 0) { - MEMCPY(outp, str, lenstr); - } - - ppp_write(pcb, p); -} - -/* - * Format and send an MD5-Challenge EAP Response message. - */ -static void eap_chap_response(ppp_pcb *pcb, u_char id, u_char *hash, const char *name, int namelen) { - struct pbuf *p; - u_char *outp; - int msglen; - - msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + MD5_SIGNATURE_SIZE + - namelen; - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_RESPONSE, outp); - PUTCHAR(id, outp); - pcb->eap.es_client.ea_id = id; - PUTSHORT(msglen, outp); - PUTCHAR(EAPT_MD5CHAP, outp); - PUTCHAR(MD5_SIGNATURE_SIZE, outp); - MEMCPY(outp, hash, MD5_SIGNATURE_SIZE); - INCPTR(MD5_SIGNATURE_SIZE, outp); - if (namelen > 0) { - MEMCPY(outp, name, namelen); - } - - ppp_write(pcb, p); -} - -#ifdef USE_SRP -/* - * Format and send a SRP EAP Response message. - */ -static void -eap_srp_response(esp, id, subtypenum, str, lenstr) -eap_state *esp; -u_char id; -u_char subtypenum; -u_char *str; -int lenstr; -{ - ppp_pcb *pcb = &ppp_pcb_list[pcb->eap.es_unit]; - struct pbuf *p; - u_char *outp; - int msglen; - - msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + lenstr; - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_RESPONSE, outp); - PUTCHAR(id, outp); - pcb->eap.es_client.ea_id = id; - PUTSHORT(msglen, outp); - PUTCHAR(EAPT_SRP, outp); - PUTCHAR(subtypenum, outp); - if (lenstr > 0) { - MEMCPY(outp, str, lenstr); - } - - ppp_write(pcb, p); -} - -/* - * Format and send a SRP EAP Client Validator Response message. - */ -static void -eap_srpval_response(esp, id, flags, str) -eap_state *esp; -u_char id; -u32_t flags; -u_char *str; -{ - ppp_pcb *pcb = &ppp_pcb_list[pcb->eap.es_unit]; - struct pbuf *p; - u_char *outp; - int msglen; - - msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + sizeof (u32_t) + - SHA_DIGESTSIZE; - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_RESPONSE, outp); - PUTCHAR(id, outp); - pcb->eap.es_client.ea_id = id; - PUTSHORT(msglen, outp); - PUTCHAR(EAPT_SRP, outp); - PUTCHAR(EAPSRP_CVALIDATOR, outp); - PUTLONG(flags, outp); - MEMCPY(outp, str, SHA_DIGESTSIZE); - - ppp_write(pcb, p); -} -#endif /* USE_SRP */ - -static void eap_send_nak(ppp_pcb *pcb, u_char id, u_char type) { - struct pbuf *p; - u_char *outp; - int msglen; - - msglen = EAP_HEADERLEN + 2 * sizeof (u_char); - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - - MAKEHEADER(outp, PPP_EAP); - - PUTCHAR(EAP_RESPONSE, outp); - PUTCHAR(id, outp); - pcb->eap.es_client.ea_id = id; - PUTSHORT(msglen, outp); - PUTCHAR(EAPT_NAK, outp); - PUTCHAR(type, outp); - - ppp_write(pcb, p); -} - -#ifdef USE_SRP -static char * -name_of_pn_file() -{ - char *user, *path, *file; - struct passwd *pw; - size_t pl; - static bool pnlogged = 0; - - pw = getpwuid(getuid()); - if (pw == NULL || (user = pw->pw_dir) == NULL || user[0] == 0) { - errno = EINVAL; - return (NULL); - } - file = _PATH_PSEUDONYM; - pl = strlen(user) + strlen(file) + 2; - path = malloc(pl); - if (path == NULL) - return (NULL); - (void) slprintf(path, pl, "%s/%s", user, file); - if (!pnlogged) { - ppp_dbglog("pseudonym file: %s", path); - pnlogged = 1; - } - return (path); -} - -static int -open_pn_file(modebits) -mode_t modebits; -{ - char *path; - int fd, err; - - if ((path = name_of_pn_file()) == NULL) - return (-1); - fd = open(path, modebits, S_IRUSR | S_IWUSR); - err = errno; - free(path); - errno = err; - return (fd); -} - -static void -remove_pn_file() -{ - char *path; - - if ((path = name_of_pn_file()) != NULL) { - (void) unlink(path); - (void) free(path); - } -} - -static void -write_pseudonym(esp, inp, len, id) -eap_state *esp; -u_char *inp; -int len, id; -{ - u_char val; - u_char *datp, *digp; - SHA1_CTX ctxt; - u_char dig[SHA_DIGESTSIZE]; - int dsize, fd, olen = len; - - /* - * Do the decoding by working backwards. This eliminates the need - * to save the decoded output in a separate buffer. - */ - val = id; - while (len > 0) { - if ((dsize = len % SHA_DIGESTSIZE) == 0) - dsize = SHA_DIGESTSIZE; - len -= dsize; - datp = inp + len; - SHA1Init(&ctxt); - SHA1Update(&ctxt, &val, 1); - SHA1Update(&ctxt, pcb->eap.es_client.ea_skey, SESSION_KEY_LEN); - if (len > 0) { - SHA1Update(&ctxt, datp, SHA_DIGESTSIZE); - } else { - SHA1Update(&ctxt, pcb->eap.es_client.ea_name, - pcb->eap.es_client.ea_namelen); - } - SHA1Final(dig, &ctxt); - for (digp = dig; digp < dig + SHA_DIGESTSIZE; digp++) - *datp++ ^= *digp; - } - - /* Now check that the result is sane */ - if (olen <= 0 || *inp + 1 > olen) { - ppp_dbglog("EAP: decoded pseudonym is unusable <%.*B>", olen, inp); - return; - } - - /* Save it away */ - fd = open_pn_file(O_WRONLY | O_CREAT | O_TRUNC); - if (fd < 0) { - ppp_dbglog("EAP: error saving pseudonym: %m"); - return; - } - len = write(fd, inp + 1, *inp); - if (close(fd) != -1 && len == *inp) { - ppp_dbglog("EAP: saved pseudonym"); - pcb->eap.es_usedpseudo = 0; - } else { - ppp_dbglog("EAP: failed to save pseudonym"); - remove_pn_file(); - } -} -#endif /* USE_SRP */ - -/* - * eap_request - Receive EAP Request message (client mode). - */ -static void eap_request(ppp_pcb *pcb, u_char *inp, int id, int len) { - u_char typenum; - u_char vallen; - int secret_len; - char secret[MAXSECRETLEN]; - char rhostname[MAXNAMELEN]; - lwip_md5_context mdContext; - u_char hash[MD5_SIGNATURE_SIZE]; -#ifdef USE_SRP - struct t_client *tc; - struct t_num sval, gval, Nval, *Ap, Bval; - u_char vals[2]; - SHA1_CTX ctxt; - u_char dig[SHA_DIGESTSIZE]; - int fd; -#endif /* USE_SRP */ - - /* - * Note: we update es_client.ea_id *only if* a Response - * message is being generated. Otherwise, we leave it the - * same for duplicate detection purposes. - */ - - pcb->eap.es_client.ea_requests++; - if (pcb->settings.eap_allow_req != 0 && - pcb->eap.es_client.ea_requests > pcb->settings.eap_allow_req) { - ppp_info("EAP: received too many Request messages"); - if (pcb->settings.eap_req_time > 0) { - UNTIMEOUT(eap_client_timeout, pcb); - } - auth_withpeer_fail(pcb, PPP_EAP); - return; - } - - if (len <= 0) { - ppp_error("EAP: empty Request message discarded"); - return; - } - - GETCHAR(typenum, inp); - len--; - - switch (typenum) { - case EAPT_IDENTITY: - if (len > 0) - ppp_info("EAP: Identity prompt \"%.*q\"", len, inp); -#ifdef USE_SRP - if (pcb->eap.es_usepseudo && - (pcb->eap.es_usedpseudo == 0 || - (pcb->eap.es_usedpseudo == 1 && - id == pcb->eap.es_client.ea_id))) { - pcb->eap.es_usedpseudo = 1; - /* Try to get a pseudonym */ - if ((fd = open_pn_file(O_RDONLY)) >= 0) { - strcpy(rhostname, SRP_PSEUDO_ID); - len = read(fd, rhostname + SRP_PSEUDO_LEN, - sizeof (rhostname) - SRP_PSEUDO_LEN); - /* XXX NAI unsupported */ - if (len > 0) { - eap_send_response(pcb, id, typenum, - rhostname, len + SRP_PSEUDO_LEN); - } - (void) close(fd); - if (len > 0) - break; - } - } - /* Stop using pseudonym now. */ - if (pcb->eap.es_usepseudo && pcb->eap.es_usedpseudo != 2) { - remove_pn_file(); - pcb->eap.es_usedpseudo = 2; - } -#endif /* USE_SRP */ - eap_send_response(pcb, id, typenum, (const u_char*)pcb->eap.es_client.ea_name, - pcb->eap.es_client.ea_namelen); - break; - - case EAPT_NOTIFICATION: - if (len > 0) - ppp_info("EAP: Notification \"%.*q\"", len, inp); - eap_send_response(pcb, id, typenum, NULL, 0); - break; - - case EAPT_NAK: - /* - * Avoid the temptation to send Response Nak in reply - * to Request Nak here. It can only lead to trouble. - */ - ppp_warn("EAP: unexpected Nak in Request; ignored"); - /* Return because we're waiting for something real. */ - return; - - case EAPT_MD5CHAP: - if (len < 1) { - ppp_error("EAP: received MD5-Challenge with no data"); - /* Bogus request; wait for something real. */ - return; - } - GETCHAR(vallen, inp); - len--; - if (vallen < 8 || vallen > len) { - ppp_error("EAP: MD5-Challenge with bad length %d (8..%d)", - vallen, len); - /* Try something better. */ - eap_send_nak(pcb, id, EAPT_SRP); - break; - } - - /* Not so likely to happen. */ - if (vallen >= len + sizeof (rhostname)) { - ppp_dbglog("EAP: trimming really long peer name down"); - MEMCPY(rhostname, inp + vallen, sizeof (rhostname) - 1); - rhostname[sizeof (rhostname) - 1] = '\0'; - } else { - MEMCPY(rhostname, inp + vallen, len - vallen); - rhostname[len - vallen] = '\0'; - } - -#if PPP_REMOTENAME - /* In case the remote doesn't give us his name. */ - if (pcb->settings.explicit_remote || - (pcb->settings.remote_name[0] != '\0' && vallen == len)) - strlcpy(rhostname, pcb->settings.remote_name, sizeof (rhostname)); -#endif /* PPP_REMOTENAME */ - - /* - * Get the secret for authenticating ourselves with - * the specified host. - */ - if (!get_secret(pcb, pcb->eap.es_client.ea_name, - rhostname, secret, &secret_len, 0)) { - ppp_dbglog("EAP: no MD5 secret for auth to %q", rhostname); - eap_send_nak(pcb, id, EAPT_SRP); - break; - } - lwip_md5_init(&mdContext); - lwip_md5_starts(&mdContext); - typenum = id; - lwip_md5_update(&mdContext, &typenum, 1); - lwip_md5_update(&mdContext, (u_char *)secret, secret_len); - BZERO(secret, sizeof (secret)); - lwip_md5_update(&mdContext, inp, vallen); - lwip_md5_finish(&mdContext, hash); - lwip_md5_free(&mdContext); - eap_chap_response(pcb, id, hash, pcb->eap.es_client.ea_name, - pcb->eap.es_client.ea_namelen); - break; - -#ifdef USE_SRP - case EAPT_SRP: - if (len < 1) { - ppp_error("EAP: received empty SRP Request"); - /* Bogus request; wait for something real. */ - return; - } - - /* Get subtype */ - GETCHAR(vallen, inp); - len--; - switch (vallen) { - case EAPSRP_CHALLENGE: - tc = NULL; - if (pcb->eap.es_client.ea_session != NULL) { - tc = (struct t_client *)pcb->eap.es_client. - ea_session; - /* - * If this is a new challenge, then start - * over with a new client session context. - * Otherwise, just resend last response. - */ - if (id != pcb->eap.es_client.ea_id) { - t_clientclose(tc); - pcb->eap.es_client.ea_session = NULL; - tc = NULL; - } - } - /* No session key just yet */ - pcb->eap.es_client.ea_skey = NULL; - if (tc == NULL) { - int rhostnamelen; - - GETCHAR(vallen, inp); - len--; - if (vallen >= len) { - ppp_error("EAP: badly-formed SRP Challenge" - " (name)"); - /* Ignore badly-formed messages */ - return; - } - MEMCPY(rhostname, inp, vallen); - rhostname[vallen] = '\0'; - INCPTR(vallen, inp); - len -= vallen; - - /* - * In case the remote doesn't give us his name, - * use configured name. - */ - if (explicit_remote || - (remote_name[0] != '\0' && vallen == 0)) { - strlcpy(rhostname, remote_name, - sizeof (rhostname)); - } - - rhostnamelen = (int)strlen(rhostname); - if (rhostnamelen > MAXNAMELEN) { - rhostnamelen = MAXNAMELEN; - } - MEMCPY(pcb->eap.es_client.ea_peer, rhostname, rhostnamelen); - pcb->eap.es_client.ea_peer[rhostnamelen] = '\0'; - pcb->eap.es_client.ea_peerlen = rhostnamelen; - - GETCHAR(vallen, inp); - len--; - if (vallen >= len) { - ppp_error("EAP: badly-formed SRP Challenge" - " (s)"); - /* Ignore badly-formed messages */ - return; - } - sval.data = inp; - sval.len = vallen; - INCPTR(vallen, inp); - len -= vallen; - - GETCHAR(vallen, inp); - len--; - if (vallen > len) { - ppp_error("EAP: badly-formed SRP Challenge" - " (g)"); - /* Ignore badly-formed messages */ - return; - } - /* If no generator present, then use value 2 */ - if (vallen == 0) { - gval.data = (u_char *)"\002"; - gval.len = 1; - } else { - gval.data = inp; - gval.len = vallen; - } - INCPTR(vallen, inp); - len -= vallen; - - /* - * If no modulus present, then use well-known - * value. - */ - if (len == 0) { - Nval.data = (u_char *)wkmodulus; - Nval.len = sizeof (wkmodulus); - } else { - Nval.data = inp; - Nval.len = len; - } - tc = t_clientopen(pcb->eap.es_client.ea_name, - &Nval, &gval, &sval); - if (tc == NULL) { - eap_send_nak(pcb, id, EAPT_MD5CHAP); - break; - } - pcb->eap.es_client.ea_session = (void *)tc; - - /* Add Challenge ID & type to verifier */ - vals[0] = id; - vals[1] = EAPT_SRP; - t_clientaddexdata(tc, vals, 2); - } - Ap = t_clientgenexp(tc); - eap_srp_response(esp, id, EAPSRP_CKEY, Ap->data, - Ap->len); - break; - - case EAPSRP_SKEY: - tc = (struct t_client *)pcb->eap.es_client.ea_session; - if (tc == NULL) { - ppp_warn("EAP: peer sent Subtype 2 without 1"); - eap_send_nak(pcb, id, EAPT_MD5CHAP); - break; - } - if (pcb->eap.es_client.ea_skey != NULL) { - /* - * ID number should not change here. Warn - * if it does (but otherwise ignore). - */ - if (id != pcb->eap.es_client.ea_id) { - ppp_warn("EAP: ID changed from %d to %d " - "in SRP Subtype 2 rexmit", - pcb->eap.es_client.ea_id, id); - } - } else { - if (get_srp_secret(pcb->eap.es_unit, - pcb->eap.es_client.ea_name, - pcb->eap.es_client.ea_peer, secret, 0) == 0) { - /* - * Can't work with this peer because - * the secret is missing. Just give - * up. - */ - eap_send_nak(pcb, id, EAPT_MD5CHAP); - break; - } - Bval.data = inp; - Bval.len = len; - t_clientpasswd(tc, secret); - BZERO(secret, sizeof (secret)); - pcb->eap.es_client.ea_skey = - t_clientgetkey(tc, &Bval); - if (pcb->eap.es_client.ea_skey == NULL) { - /* Server is rogue; stop now */ - ppp_error("EAP: SRP server is rogue"); - goto client_failure; - } - } - eap_srpval_response(esp, id, SRPVAL_EBIT, - t_clientresponse(tc)); - break; - - case EAPSRP_SVALIDATOR: - tc = (struct t_client *)pcb->eap.es_client.ea_session; - if (tc == NULL || pcb->eap.es_client.ea_skey == NULL) { - ppp_warn("EAP: peer sent Subtype 3 without 1/2"); - eap_send_nak(pcb, id, EAPT_MD5CHAP); - break; - } - /* - * If we're already open, then this ought to be a - * duplicate. Otherwise, check that the server is - * who we think it is. - */ - if (pcb->eap.es_client.ea_state == eapOpen) { - if (id != pcb->eap.es_client.ea_id) { - ppp_warn("EAP: ID changed from %d to %d " - "in SRP Subtype 3 rexmit", - pcb->eap.es_client.ea_id, id); - } - } else { - len -= sizeof (u32_t) + SHA_DIGESTSIZE; - if (len < 0 || t_clientverify(tc, inp + - sizeof (u32_t)) != 0) { - ppp_error("EAP: SRP server verification " - "failed"); - goto client_failure; - } - GETLONG(pcb->eap.es_client.ea_keyflags, inp); - /* Save pseudonym if user wants it. */ - if (len > 0 && pcb->eap.es_usepseudo) { - INCPTR(SHA_DIGESTSIZE, inp); - write_pseudonym(esp, inp, len, id); - } - } - /* - * We've verified our peer. We're now mostly done, - * except for waiting on the regular EAP Success - * message. - */ - eap_srp_response(esp, id, EAPSRP_ACK, NULL, 0); - break; - - case EAPSRP_LWRECHALLENGE: - if (len < 4) { - ppp_warn("EAP: malformed Lightweight rechallenge"); - return; - } - SHA1Init(&ctxt); - vals[0] = id; - SHA1Update(&ctxt, vals, 1); - SHA1Update(&ctxt, pcb->eap.es_client.ea_skey, - SESSION_KEY_LEN); - SHA1Update(&ctxt, inp, len); - SHA1Update(&ctxt, pcb->eap.es_client.ea_name, - pcb->eap.es_client.ea_namelen); - SHA1Final(dig, &ctxt); - eap_srp_response(esp, id, EAPSRP_LWRECHALLENGE, dig, - SHA_DIGESTSIZE); - break; - - default: - ppp_error("EAP: unknown SRP Subtype %d", vallen); - eap_send_nak(pcb, id, EAPT_MD5CHAP); - break; - } - break; -#endif /* USE_SRP */ - - default: - ppp_info("EAP: unknown authentication type %d; Naking", typenum); - eap_send_nak(pcb, id, EAPT_SRP); - break; - } - - if (pcb->settings.eap_req_time > 0) { - UNTIMEOUT(eap_client_timeout, pcb); - TIMEOUT(eap_client_timeout, pcb, - pcb->settings.eap_req_time); - } - return; - -#ifdef USE_SRP -client_failure: - pcb->eap.es_client.ea_state = eapBadAuth; - if (pcb->settings.eap_req_time > 0) { - UNTIMEOUT(eap_client_timeout, (void *)esp); - } - pcb->eap.es_client.ea_session = NULL; - t_clientclose(tc); - auth_withpeer_fail(pcb, PPP_EAP); -#endif /* USE_SRP */ -} - -#if PPP_SERVER -/* - * eap_response - Receive EAP Response message (server mode). - */ -static void eap_response(ppp_pcb *pcb, u_char *inp, int id, int len) { - u_char typenum; - u_char vallen; - int secret_len; - char secret[MAXSECRETLEN]; - char rhostname[MAXNAMELEN]; - lwip_md5_context mdContext; - u_char hash[MD5_SIGNATURE_SIZE]; -#ifdef USE_SRP - struct t_server *ts; - struct t_num A; - SHA1_CTX ctxt; - u_char dig[SHA_DIGESTSIZE]; -#endif /* USE_SRP */ - - if (pcb->eap.es_server.ea_id != id) { - ppp_dbglog("EAP: discarding Response %d; expected ID %d", id, - pcb->eap.es_server.ea_id); - return; - } - - pcb->eap.es_server.ea_responses++; - - if (len <= 0) { - ppp_error("EAP: empty Response message discarded"); - return; - } - - GETCHAR(typenum, inp); - len--; - - switch (typenum) { - case EAPT_IDENTITY: - if (pcb->eap.es_server.ea_state != eapIdentify) { - ppp_dbglog("EAP discarding unwanted Identify \"%.q\"", len, - inp); - break; - } - ppp_info("EAP: unauthenticated peer name \"%.*q\"", len, inp); - if (len > MAXNAMELEN) { - len = MAXNAMELEN; - } - MEMCPY(pcb->eap.es_server.ea_peer, inp, len); - pcb->eap.es_server.ea_peer[len] = '\0'; - pcb->eap.es_server.ea_peerlen = len; - eap_figure_next_state(pcb, 0); - break; - - case EAPT_NOTIFICATION: - ppp_dbglog("EAP unexpected Notification; response discarded"); - break; - - case EAPT_NAK: - if (len < 1) { - ppp_info("EAP: Nak Response with no suggested protocol"); - eap_figure_next_state(pcb, 1); - break; - } - - GETCHAR(vallen, inp); - len--; - - if ( -#if PPP_REMOTENAME - !pcb->explicit_remote && -#endif /* PPP_REMOTENAME */ - pcb->eap.es_server.ea_state == eapIdentify){ - /* Peer cannot Nak Identify Request */ - eap_figure_next_state(pcb, 1); - break; - } - - switch (vallen) { - case EAPT_SRP: - /* Run through SRP validator selection again. */ - pcb->eap.es_server.ea_state = eapIdentify; - eap_figure_next_state(pcb, 0); - break; - - case EAPT_MD5CHAP: - pcb->eap.es_server.ea_state = eapMD5Chall; - break; - - default: - ppp_dbglog("EAP: peer requesting unknown Type %d", vallen); - switch (pcb->eap.es_server.ea_state) { - case eapSRP1: - case eapSRP2: - case eapSRP3: - pcb->eap.es_server.ea_state = eapMD5Chall; - break; - case eapMD5Chall: - case eapSRP4: - pcb->eap.es_server.ea_state = eapIdentify; - eap_figure_next_state(pcb, 0); - break; - default: - break; - } - break; - } - break; - - case EAPT_MD5CHAP: - if (pcb->eap.es_server.ea_state != eapMD5Chall) { - ppp_error("EAP: unexpected MD5-Response"); - eap_figure_next_state(pcb, 1); - break; - } - if (len < 1) { - ppp_error("EAP: received MD5-Response with no data"); - eap_figure_next_state(pcb, 1); - break; - } - GETCHAR(vallen, inp); - len--; - if (vallen != 16 || vallen > len) { - ppp_error("EAP: MD5-Response with bad length %d", vallen); - eap_figure_next_state(pcb, 1); - break; - } - - /* Not so likely to happen. */ - if (vallen >= len + sizeof (rhostname)) { - ppp_dbglog("EAP: trimming really long peer name down"); - MEMCPY(rhostname, inp + vallen, sizeof (rhostname) - 1); - rhostname[sizeof (rhostname) - 1] = '\0'; - } else { - MEMCPY(rhostname, inp + vallen, len - vallen); - rhostname[len - vallen] = '\0'; - } - -#if PPP_REMOTENAME - /* In case the remote doesn't give us his name. */ - if (explicit_remote || - (remote_name[0] != '\0' && vallen == len)) - strlcpy(rhostname, remote_name, sizeof (rhostname)); -#endif /* PPP_REMOTENAME */ - - /* - * Get the secret for authenticating the specified - * host. - */ - if (!get_secret(pcb, rhostname, - pcb->eap.es_server.ea_name, secret, &secret_len, 1)) { - ppp_dbglog("EAP: no MD5 secret for auth of %q", rhostname); - eap_send_failure(pcb); - break; - } - lwip_md5_init(&mdContext); - lwip_md5_starts(&mdContext); - lwip_md5_update(&mdContext, &pcb->eap.es_server.ea_id, 1); - lwip_md5_update(&mdContext, (u_char *)secret, secret_len); - BZERO(secret, sizeof (secret)); - lwip_md5_update(&mdContext, pcb->eap.es_challenge, pcb->eap.es_challen); - lwip_md5_finish(&mdContext, hash); - lwip_md5_free(&mdContext); - if (BCMP(hash, inp, MD5_SIGNATURE_SIZE) != 0) { - eap_send_failure(pcb); - break; - } - pcb->eap.es_server.ea_type = EAPT_MD5CHAP; - eap_send_success(pcb); - eap_figure_next_state(pcb, 0); - if (pcb->eap.es_rechallenge != 0) - TIMEOUT(eap_rechallenge, pcb, pcb->eap.es_rechallenge); - break; - -#ifdef USE_SRP - case EAPT_SRP: - if (len < 1) { - ppp_error("EAP: empty SRP Response"); - eap_figure_next_state(pcb, 1); - break; - } - GETCHAR(typenum, inp); - len--; - switch (typenum) { - case EAPSRP_CKEY: - if (pcb->eap.es_server.ea_state != eapSRP1) { - ppp_error("EAP: unexpected SRP Subtype 1 Response"); - eap_figure_next_state(pcb, 1); - break; - } - A.data = inp; - A.len = len; - ts = (struct t_server *)pcb->eap.es_server.ea_session; - assert(ts != NULL); - pcb->eap.es_server.ea_skey = t_servergetkey(ts, &A); - if (pcb->eap.es_server.ea_skey == NULL) { - /* Client's A value is bogus; terminate now */ - ppp_error("EAP: bogus A value from client"); - eap_send_failure(pcb); - } else { - eap_figure_next_state(pcb, 0); - } - break; - - case EAPSRP_CVALIDATOR: - if (pcb->eap.es_server.ea_state != eapSRP2) { - ppp_error("EAP: unexpected SRP Subtype 2 Response"); - eap_figure_next_state(pcb, 1); - break; - } - if (len < sizeof (u32_t) + SHA_DIGESTSIZE) { - ppp_error("EAP: M1 length %d < %d", len, - sizeof (u32_t) + SHA_DIGESTSIZE); - eap_figure_next_state(pcb, 1); - break; - } - GETLONG(pcb->eap.es_server.ea_keyflags, inp); - ts = (struct t_server *)pcb->eap.es_server.ea_session; - assert(ts != NULL); - if (t_serververify(ts, inp)) { - ppp_info("EAP: unable to validate client identity"); - eap_send_failure(pcb); - break; - } - eap_figure_next_state(pcb, 0); - break; - - case EAPSRP_ACK: - if (pcb->eap.es_server.ea_state != eapSRP3) { - ppp_error("EAP: unexpected SRP Subtype 3 Response"); - eap_send_failure(esp); - break; - } - pcb->eap.es_server.ea_type = EAPT_SRP; - eap_send_success(pcb, esp); - eap_figure_next_state(pcb, 0); - if (pcb->eap.es_rechallenge != 0) - TIMEOUT(eap_rechallenge, pcb, - pcb->eap.es_rechallenge); - if (pcb->eap.es_lwrechallenge != 0) - TIMEOUT(srp_lwrechallenge, pcb, - pcb->eap.es_lwrechallenge); - break; - - case EAPSRP_LWRECHALLENGE: - if (pcb->eap.es_server.ea_state != eapSRP4) { - ppp_info("EAP: unexpected SRP Subtype 4 Response"); - return; - } - if (len != SHA_DIGESTSIZE) { - ppp_error("EAP: bad Lightweight rechallenge " - "response"); - return; - } - SHA1Init(&ctxt); - vallen = id; - SHA1Update(&ctxt, &vallen, 1); - SHA1Update(&ctxt, pcb->eap.es_server.ea_skey, - SESSION_KEY_LEN); - SHA1Update(&ctxt, pcb->eap.es_challenge, pcb->eap.es_challen); - SHA1Update(&ctxt, pcb->eap.es_server.ea_peer, - pcb->eap.es_server.ea_peerlen); - SHA1Final(dig, &ctxt); - if (BCMP(dig, inp, SHA_DIGESTSIZE) != 0) { - ppp_error("EAP: failed Lightweight rechallenge"); - eap_send_failure(pcb); - break; - } - pcb->eap.es_server.ea_state = eapOpen; - if (pcb->eap.es_lwrechallenge != 0) - TIMEOUT(srp_lwrechallenge, esp, - pcb->eap.es_lwrechallenge); - break; - } - break; -#endif /* USE_SRP */ - - default: - /* This can't happen. */ - ppp_error("EAP: unknown Response type %d; ignored", typenum); - return; - } - - if (pcb->settings.eap_timeout_time > 0) { - UNTIMEOUT(eap_server_timeout, pcb); - } - - if (pcb->eap.es_server.ea_state != eapBadAuth && - pcb->eap.es_server.ea_state != eapOpen) { - pcb->eap.es_server.ea_id++; - eap_send_request(pcb); - } -} -#endif /* PPP_SERVER */ - -/* - * eap_success - Receive EAP Success message (client mode). - */ -static void eap_success(ppp_pcb *pcb, u_char *inp, int id, int len) { - LWIP_UNUSED_ARG(id); - - if (pcb->eap.es_client.ea_state != eapOpen && !eap_client_active(pcb)) { - ppp_dbglog("EAP unexpected success message in state %s (%d)", - eap_state_name(pcb->eap.es_client.ea_state), - pcb->eap.es_client.ea_state); - return; - } - - if (pcb->settings.eap_req_time > 0) { - UNTIMEOUT(eap_client_timeout, pcb); - } - - if (len > 0) { - /* This is odd. The spec doesn't allow for this. */ - PRINTMSG(inp, len); - } - - pcb->eap.es_client.ea_state = eapOpen; - auth_withpeer_success(pcb, PPP_EAP, 0); -} - -/* - * eap_failure - Receive EAP Failure message (client mode). - */ -static void eap_failure(ppp_pcb *pcb, u_char *inp, int id, int len) { - LWIP_UNUSED_ARG(id); - - if (!eap_client_active(pcb)) { - ppp_dbglog("EAP unexpected failure message in state %s (%d)", - eap_state_name(pcb->eap.es_client.ea_state), - pcb->eap.es_client.ea_state); - } - - if (pcb->settings.eap_req_time > 0) { - UNTIMEOUT(eap_client_timeout, pcb); - } - - if (len > 0) { - /* This is odd. The spec doesn't allow for this. */ - PRINTMSG(inp, len); - } - - pcb->eap.es_client.ea_state = eapBadAuth; - - ppp_error("EAP: peer reports authentication failure"); - auth_withpeer_fail(pcb, PPP_EAP); -} - -/* - * eap_input - Handle received EAP message. - */ -static void eap_input(ppp_pcb *pcb, u_char *inp, int inlen) { - u_char code, id; - int len; - - /* - * Parse header (code, id and length). If packet too short, - * drop it. - */ - if (inlen < EAP_HEADERLEN) { - ppp_error("EAP: packet too short: %d < %d", inlen, EAP_HEADERLEN); - return; - } - GETCHAR(code, inp); - GETCHAR(id, inp); - GETSHORT(len, inp); - if (len < EAP_HEADERLEN || len > inlen) { - ppp_error("EAP: packet has illegal length field %d (%d..%d)", len, - EAP_HEADERLEN, inlen); - return; - } - len -= EAP_HEADERLEN; - - /* Dispatch based on message code */ - switch (code) { - case EAP_REQUEST: - eap_request(pcb, inp, id, len); - break; - -#if PPP_SERVER - case EAP_RESPONSE: - eap_response(pcb, inp, id, len); - break; -#endif /* PPP_SERVER */ - - case EAP_SUCCESS: - eap_success(pcb, inp, id, len); - break; - - case EAP_FAILURE: - eap_failure(pcb, inp, id, len); - break; - - default: /* XXX Need code reject */ - /* Note: it's not legal to send EAP Nak here. */ - ppp_warn("EAP: unknown code %d received", code); - break; - } -} - -#if PRINTPKT_SUPPORT -/* - * eap_printpkt - print the contents of an EAP packet. - */ -static const char* const eap_codenames[] = { - "Request", "Response", "Success", "Failure" -}; - -static const char* const eap_typenames[] = { - "Identity", "Notification", "Nak", "MD5-Challenge", - "OTP", "Generic-Token", NULL, NULL, - "RSA", "DSS", "KEA", "KEA-Validate", - "TLS", "Defender", "Windows 2000", "Arcot", - "Cisco", "Nokia", "SRP" -}; - -static int eap_printpkt(const u_char *inp, int inlen, void (*printer) (void *, const char *, ...), void *arg) { - int code, id, len, rtype, vallen; - const u_char *pstart; - u32_t uval; - - if (inlen < EAP_HEADERLEN) - return (0); - pstart = inp; - GETCHAR(code, inp); - GETCHAR(id, inp); - GETSHORT(len, inp); - if (len < EAP_HEADERLEN || len > inlen) - return (0); - - if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(eap_codenames)) - printer(arg, " %s", eap_codenames[code-1]); - else - printer(arg, " code=0x%x", code); - printer(arg, " id=0x%x", id); - len -= EAP_HEADERLEN; - switch (code) { - case EAP_REQUEST: - if (len < 1) { - printer(arg, " "); - break; - } - GETCHAR(rtype, inp); - len--; - if (rtype >= 1 && rtype <= (int)LWIP_ARRAYSIZE(eap_typenames)) - printer(arg, " %s", eap_typenames[rtype-1]); - else - printer(arg, " type=0x%x", rtype); - switch (rtype) { - case EAPT_IDENTITY: - case EAPT_NOTIFICATION: - if (len > 0) { - printer(arg, " "); - INCPTR(len, inp); - len = 0; - } else { - printer(arg, " "); - } - break; - - case EAPT_MD5CHAP: - if (len <= 0) - break; - GETCHAR(vallen, inp); - len--; - if (vallen > len) - goto truncated; - printer(arg, " ", vallen, inp); - INCPTR(vallen, inp); - len -= vallen; - if (len > 0) { - printer(arg, " "); - INCPTR(len, inp); - len = 0; - } else { - printer(arg, " "); - } - break; - - case EAPT_SRP: - if (len < 3) - goto truncated; - GETCHAR(vallen, inp); - len--; - printer(arg, "-%d", vallen); - switch (vallen) { - case EAPSRP_CHALLENGE: - GETCHAR(vallen, inp); - len--; - if (vallen >= len) - goto truncated; - if (vallen > 0) { - printer(arg, " "); - } else { - printer(arg, " "); - } - INCPTR(vallen, inp); - len -= vallen; - GETCHAR(vallen, inp); - len--; - if (vallen >= len) - goto truncated; - printer(arg, " ", vallen, inp); - INCPTR(vallen, inp); - len -= vallen; - GETCHAR(vallen, inp); - len--; - if (vallen > len) - goto truncated; - if (vallen == 0) { - printer(arg, " "); - } else { - printer(arg, " ", vallen, inp); - } - INCPTR(vallen, inp); - len -= vallen; - if (len == 0) { - printer(arg, " "); - } else { - printer(arg, " ", len, inp); - INCPTR(len, inp); - len = 0; - } - break; - - case EAPSRP_SKEY: - printer(arg, " ", len, inp); - INCPTR(len, inp); - len = 0; - break; - - case EAPSRP_SVALIDATOR: - if (len < (int)sizeof (u32_t)) - break; - GETLONG(uval, inp); - len -= sizeof (u32_t); - if (uval & SRPVAL_EBIT) { - printer(arg, " E"); - uval &= ~SRPVAL_EBIT; - } - if (uval != 0) { - printer(arg, " f<%X>", uval); - } - if ((vallen = len) > SHA_DIGESTSIZE) - vallen = SHA_DIGESTSIZE; - printer(arg, " ", len, inp, - len < SHA_DIGESTSIZE ? "?" : ""); - INCPTR(vallen, inp); - len -= vallen; - if (len > 0) { - printer(arg, " ", len, inp); - INCPTR(len, inp); - len = 0; - } - break; - - case EAPSRP_LWRECHALLENGE: - printer(arg, " ", len, inp); - INCPTR(len, inp); - len = 0; - break; - default: - break; - } - break; - default: - break; - } - break; - - case EAP_RESPONSE: - if (len < 1) - break; - GETCHAR(rtype, inp); - len--; - if (rtype >= 1 && rtype <= (int)LWIP_ARRAYSIZE(eap_typenames)) - printer(arg, " %s", eap_typenames[rtype-1]); - else - printer(arg, " type=0x%x", rtype); - switch (rtype) { - case EAPT_IDENTITY: - if (len > 0) { - printer(arg, " "); - INCPTR(len, inp); - len = 0; - } - break; - - case EAPT_NAK: - if (len <= 0) { - printer(arg, " "); - break; - } - GETCHAR(rtype, inp); - len--; - printer(arg, " = 1 && rtype < (int)LWIP_ARRAYSIZE(eap_typenames)) - printer(arg, " (%s)", eap_typenames[rtype-1]); - printer(arg, ">"); - break; - - case EAPT_MD5CHAP: - if (len <= 0) { - printer(arg, " "); - break; - } - GETCHAR(vallen, inp); - len--; - if (vallen > len) - goto truncated; - printer(arg, " ", vallen, inp); - INCPTR(vallen, inp); - len -= vallen; - if (len > 0) { - printer(arg, " "); - INCPTR(len, inp); - len = 0; - } else { - printer(arg, " "); - } - break; - - case EAPT_SRP: - if (len < 1) - goto truncated; - GETCHAR(vallen, inp); - len--; - printer(arg, "-%d", vallen); - switch (vallen) { - case EAPSRP_CKEY: - printer(arg, " ", len, inp); - INCPTR(len, inp); - len = 0; - break; - - case EAPSRP_CVALIDATOR: - if (len < (int)sizeof (u32_t)) - break; - GETLONG(uval, inp); - len -= sizeof (u32_t); - if (uval & SRPVAL_EBIT) { - printer(arg, " E"); - uval &= ~SRPVAL_EBIT; - } - if (uval != 0) { - printer(arg, " f<%X>", uval); - } - printer(arg, " ", len, inp, - len == SHA_DIGESTSIZE ? "" : "?"); - INCPTR(len, inp); - len = 0; - break; - - case EAPSRP_ACK: - break; - - case EAPSRP_LWRECHALLENGE: - printer(arg, " ", len, inp, - len == SHA_DIGESTSIZE ? "" : "?"); - if ((vallen = len) > SHA_DIGESTSIZE) - vallen = SHA_DIGESTSIZE; - INCPTR(vallen, inp); - len -= vallen; - break; - default: - break; - } - break; - default: - break; - } - break; - - case EAP_SUCCESS: /* No payload expected for these! */ - case EAP_FAILURE: - default: - break; - - truncated: - printer(arg, " "); - break; - } - - if (len > 8) - printer(arg, "%8B...", inp); - else if (len > 0) - printer(arg, "%.*B", len, inp); - INCPTR(len, inp); - - return (inp - pstart); -} -#endif /* PRINTPKT_SUPPORT */ - -#endif /* PPP_SUPPORT && EAP_SUPPORT */ +/* + * eap.c - Extensible Authentication Protocol for PPP (RFC 2284) + * + * Copyright (c) 2001 by Sun Microsystems, Inc. + * All rights reserved. + * + * Non-exclusive rights to redistribute, modify, translate, and use + * this software in source and binary forms, in whole or in part, is + * hereby granted, provided that the above copyright notice is + * duplicated in any source form, and that neither the name of the + * copyright holder nor the author is used to endorse or promote + * products derived from this software. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Original version by James Carlson + * + * This implementation of EAP supports MD5-Challenge and SRP-SHA1 + * authentication styles. Note that support of MD5-Challenge is a + * requirement of RFC 2284, and that it's essentially just a + * reimplementation of regular RFC 1994 CHAP using EAP messages. + * + * As an authenticator ("server"), there are multiple phases for each + * style. In the first phase of each style, the unauthenticated peer + * name is queried using the EAP Identity request type. If the + * "remotename" option is used, then this phase is skipped, because + * the peer's name is presumed to be known. + * + * For MD5-Challenge, there are two phases, and the second phase + * consists of sending the challenge itself and handling the + * associated response. + * + * For SRP-SHA1, there are four phases. The second sends 's', 'N', + * and 'g'. The reply contains 'A'. The third sends 'B', and the + * reply contains 'M1'. The forth sends the 'M2' value. + * + * As an authenticatee ("client"), there's just a single phase -- + * responding to the queries generated by the peer. EAP is an + * authenticator-driven protocol. + * + * Based on draft-ietf-pppext-eap-srp-03.txt. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && EAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/eap.h" +#include "netif/ppp/magic.h" +#include "netif/ppp/pppcrypt.h" + +#ifdef USE_SRP +#include +#include +#include +#endif /* USE_SRP */ + +#ifndef SHA_DIGESTSIZE +#define SHA_DIGESTSIZE 20 +#endif + +#ifdef USE_SRP +static char *pn_secret = NULL; /* Pseudonym generating secret */ +#endif + +#if PPP_OPTIONS +/* + * Command-line options. + */ +static option_t eap_option_list[] = { + { "eap-restart", o_int, &eap_states[0].es_server.ea_timeout, + "Set retransmit timeout for EAP Requests (server)" }, + { "eap-max-sreq", o_int, &eap_states[0].es_server.ea_maxrequests, + "Set max number of EAP Requests sent (server)" }, + { "eap-timeout", o_int, &eap_states[0].es_client.ea_timeout, + "Set time limit for peer EAP authentication" }, + { "eap-max-rreq", o_int, &eap_states[0].es_client.ea_maxrequests, + "Set max number of EAP Requests allows (client)" }, + { "eap-interval", o_int, &eap_states[0].es_rechallenge, + "Set interval for EAP rechallenge" }, +#ifdef USE_SRP + { "srp-interval", o_int, &eap_states[0].es_lwrechallenge, + "Set interval for SRP lightweight rechallenge" }, + { "srp-pn-secret", o_string, &pn_secret, + "Long term pseudonym generation secret" }, + { "srp-use-pseudonym", o_bool, &eap_states[0].es_usepseudo, + "Use pseudonym if offered one by server", 1 }, +#endif + { NULL } +}; +#endif /* PPP_OPTIONS */ + +/* + * Protocol entry points. + */ +static void eap_init(ppp_pcb *pcb); +static void eap_input(ppp_pcb *pcb, u_char *inp, int inlen); +static void eap_protrej(ppp_pcb *pcb); +static void eap_lowerup(ppp_pcb *pcb); +static void eap_lowerdown(ppp_pcb *pcb); +#if PRINTPKT_SUPPORT +static int eap_printpkt(const u_char *inp, int inlen, + void (*)(void *arg, const char *fmt, ...), void *arg); +#endif /* PRINTPKT_SUPPORT */ + +const struct protent eap_protent = { + PPP_EAP, /* protocol number */ + eap_init, /* initialization procedure */ + eap_input, /* process a received packet */ + eap_protrej, /* process a received protocol-reject */ + eap_lowerup, /* lower layer has gone up */ + eap_lowerdown, /* lower layer has gone down */ + NULL, /* open the protocol */ + NULL, /* close the protocol */ +#if PRINTPKT_SUPPORT + eap_printpkt, /* print a packet in readable form */ +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + NULL, /* process a received data packet */ +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "EAP", /* text name of protocol */ + NULL, /* text name of corresponding data protocol */ +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + eap_option_list, /* list of command-line options */ + NULL, /* check requested options; assign defaults */ +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + NULL, /* configure interface for demand-dial */ + NULL /* say whether to bring up link for this pkt */ +#endif /* DEMAND_SUPPORT */ +}; + +#ifdef USE_SRP +/* + * A well-known 2048 bit modulus. + */ +static const u_char wkmodulus[] = { + 0xAC, 0x6B, 0xDB, 0x41, 0x32, 0x4A, 0x9A, 0x9B, + 0xF1, 0x66, 0xDE, 0x5E, 0x13, 0x89, 0x58, 0x2F, + 0xAF, 0x72, 0xB6, 0x65, 0x19, 0x87, 0xEE, 0x07, + 0xFC, 0x31, 0x92, 0x94, 0x3D, 0xB5, 0x60, 0x50, + 0xA3, 0x73, 0x29, 0xCB, 0xB4, 0xA0, 0x99, 0xED, + 0x81, 0x93, 0xE0, 0x75, 0x77, 0x67, 0xA1, 0x3D, + 0xD5, 0x23, 0x12, 0xAB, 0x4B, 0x03, 0x31, 0x0D, + 0xCD, 0x7F, 0x48, 0xA9, 0xDA, 0x04, 0xFD, 0x50, + 0xE8, 0x08, 0x39, 0x69, 0xED, 0xB7, 0x67, 0xB0, + 0xCF, 0x60, 0x95, 0x17, 0x9A, 0x16, 0x3A, 0xB3, + 0x66, 0x1A, 0x05, 0xFB, 0xD5, 0xFA, 0xAA, 0xE8, + 0x29, 0x18, 0xA9, 0x96, 0x2F, 0x0B, 0x93, 0xB8, + 0x55, 0xF9, 0x79, 0x93, 0xEC, 0x97, 0x5E, 0xEA, + 0xA8, 0x0D, 0x74, 0x0A, 0xDB, 0xF4, 0xFF, 0x74, + 0x73, 0x59, 0xD0, 0x41, 0xD5, 0xC3, 0x3E, 0xA7, + 0x1D, 0x28, 0x1E, 0x44, 0x6B, 0x14, 0x77, 0x3B, + 0xCA, 0x97, 0xB4, 0x3A, 0x23, 0xFB, 0x80, 0x16, + 0x76, 0xBD, 0x20, 0x7A, 0x43, 0x6C, 0x64, 0x81, + 0xF1, 0xD2, 0xB9, 0x07, 0x87, 0x17, 0x46, 0x1A, + 0x5B, 0x9D, 0x32, 0xE6, 0x88, 0xF8, 0x77, 0x48, + 0x54, 0x45, 0x23, 0xB5, 0x24, 0xB0, 0xD5, 0x7D, + 0x5E, 0xA7, 0x7A, 0x27, 0x75, 0xD2, 0xEC, 0xFA, + 0x03, 0x2C, 0xFB, 0xDB, 0xF5, 0x2F, 0xB3, 0x78, + 0x61, 0x60, 0x27, 0x90, 0x04, 0xE5, 0x7A, 0xE6, + 0xAF, 0x87, 0x4E, 0x73, 0x03, 0xCE, 0x53, 0x29, + 0x9C, 0xCC, 0x04, 0x1C, 0x7B, 0xC3, 0x08, 0xD8, + 0x2A, 0x56, 0x98, 0xF3, 0xA8, 0xD0, 0xC3, 0x82, + 0x71, 0xAE, 0x35, 0xF8, 0xE9, 0xDB, 0xFB, 0xB6, + 0x94, 0xB5, 0xC8, 0x03, 0xD8, 0x9F, 0x7A, 0xE4, + 0x35, 0xDE, 0x23, 0x6D, 0x52, 0x5F, 0x54, 0x75, + 0x9B, 0x65, 0xE3, 0x72, 0xFC, 0xD6, 0x8E, 0xF2, + 0x0F, 0xA7, 0x11, 0x1F, 0x9E, 0x4A, 0xFF, 0x73 +}; +#endif + +#if PPP_SERVER +/* Local forward declarations. */ +static void eap_server_timeout(void *arg); +#endif /* PPP_SERVER */ + +/* + * Convert EAP state code to printable string for debug. + */ +static const char * eap_state_name(enum eap_state_code esc) +{ + static const char *state_names[] = { EAP_STATES }; + + return (state_names[(int)esc]); +} + +/* + * eap_init - Initialize state for an EAP user. This is currently + * called once by main() during start-up. + */ +static void eap_init(ppp_pcb *pcb) { + + BZERO(&pcb->eap, sizeof(eap_state)); +#if PPP_SERVER + pcb->eap.es_server.ea_id = magic(); +#endif /* PPP_SERVER */ +} + +/* + * eap_client_timeout - Give up waiting for the peer to send any + * Request messages. + */ +static void eap_client_timeout(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + + if (!eap_client_active(pcb)) + return; + + ppp_error("EAP: timeout waiting for Request from peer"); + auth_withpeer_fail(pcb, PPP_EAP); + pcb->eap.es_client.ea_state = eapBadAuth; +} + +/* + * eap_authwithpeer - Authenticate to our peer (behave as client). + * + * Start client state and wait for requests. This is called only + * after eap_lowerup. + */ +void eap_authwithpeer(ppp_pcb *pcb, const char *localname) { + + if(NULL == localname) + return; + + /* Save the peer name we're given */ + pcb->eap.es_client.ea_name = localname; + pcb->eap.es_client.ea_namelen = strlen(localname); + + pcb->eap.es_client.ea_state = eapListen; + + /* + * Start a timer so that if the other end just goes + * silent, we don't sit here waiting forever. + */ + if (pcb->settings.eap_req_time > 0) + TIMEOUT(eap_client_timeout, pcb, + pcb->settings.eap_req_time); +} + +#if PPP_SERVER +/* + * Format a standard EAP Failure message and send it to the peer. + * (Server operation) + */ +static void eap_send_failure(ppp_pcb *pcb) { + struct pbuf *p; + u_char *outp; + + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + EAP_HEADERLEN), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_FAILURE, outp); + pcb->eap.es_server.ea_id++; + PUTCHAR(pcb->eap.es_server.ea_id, outp); + PUTSHORT(EAP_HEADERLEN, outp); + + ppp_write(pcb, p); + + pcb->eap.es_server.ea_state = eapBadAuth; + auth_peer_fail(pcb, PPP_EAP); +} + +/* + * Format a standard EAP Success message and send it to the peer. + * (Server operation) + */ +static void eap_send_success(ppp_pcb *pcb) { + struct pbuf *p; + u_char *outp; + + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + EAP_HEADERLEN), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_SUCCESS, outp); + pcb->eap.es_server.ea_id++; + PUTCHAR(pcb->eap.es_server.ea_id, outp); + PUTSHORT(EAP_HEADERLEN, outp); + + ppp_write(pcb, p); + + auth_peer_success(pcb, PPP_EAP, 0, + pcb->eap.es_server.ea_peer, pcb->eap.es_server.ea_peerlen); +} +#endif /* PPP_SERVER */ + +#ifdef USE_SRP +/* + * Set DES key according to pseudonym-generating secret and current + * date. + */ +static bool +pncrypt_setkey(int timeoffs) +{ + struct tm *tp; + char tbuf[9]; + SHA1_CTX ctxt; + u_char dig[SHA_DIGESTSIZE]; + time_t reftime; + + if (pn_secret == NULL) + return (0); + reftime = time(NULL) + timeoffs; + tp = localtime(&reftime); + SHA1Init(&ctxt); + SHA1Update(&ctxt, pn_secret, strlen(pn_secret)); + strftime(tbuf, sizeof (tbuf), "%Y%m%d", tp); + SHA1Update(&ctxt, tbuf, strlen(tbuf)); + SHA1Final(dig, &ctxt); + /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ + return (DesSetkey(dig)); +} + +static char base64[] = +"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +struct b64state { + u32_t bs_bits; + int bs_offs; +}; + +static int +b64enc(bs, inp, inlen, outp) +struct b64state *bs; +u_char *inp; +int inlen; +u_char *outp; +{ + int outlen = 0; + + while (inlen > 0) { + bs->bs_bits = (bs->bs_bits << 8) | *inp++; + inlen--; + bs->bs_offs += 8; + if (bs->bs_offs >= 24) { + *outp++ = base64[(bs->bs_bits >> 18) & 0x3F]; + *outp++ = base64[(bs->bs_bits >> 12) & 0x3F]; + *outp++ = base64[(bs->bs_bits >> 6) & 0x3F]; + *outp++ = base64[bs->bs_bits & 0x3F]; + outlen += 4; + bs->bs_offs = 0; + bs->bs_bits = 0; + } + } + return (outlen); +} + +static int +b64flush(bs, outp) +struct b64state *bs; +u_char *outp; +{ + int outlen = 0; + + if (bs->bs_offs == 8) { + *outp++ = base64[(bs->bs_bits >> 2) & 0x3F]; + *outp++ = base64[(bs->bs_bits << 4) & 0x3F]; + outlen = 2; + } else if (bs->bs_offs == 16) { + *outp++ = base64[(bs->bs_bits >> 10) & 0x3F]; + *outp++ = base64[(bs->bs_bits >> 4) & 0x3F]; + *outp++ = base64[(bs->bs_bits << 2) & 0x3F]; + outlen = 3; + } + bs->bs_offs = 0; + bs->bs_bits = 0; + return (outlen); +} + +static int +b64dec(bs, inp, inlen, outp) +struct b64state *bs; +u_char *inp; +int inlen; +u_char *outp; +{ + int outlen = 0; + char *cp; + + while (inlen > 0) { + if ((cp = strchr(base64, *inp++)) == NULL) + break; + bs->bs_bits = (bs->bs_bits << 6) | (cp - base64); + inlen--; + bs->bs_offs += 6; + if (bs->bs_offs >= 8) { + *outp++ = bs->bs_bits >> (bs->bs_offs - 8); + outlen++; + bs->bs_offs -= 8; + } + } + return (outlen); +} +#endif /* USE_SRP */ + +#if PPP_SERVER +/* + * Assume that current waiting server state is complete and figure + * next state to use based on available authentication data. 'status' + * indicates if there was an error in handling the last query. It is + * 0 for success and non-zero for failure. + */ +static void eap_figure_next_state(ppp_pcb *pcb, int status) { +#ifdef USE_SRP + unsigned char secbuf[MAXSECRETLEN], clear[8], *sp, *dp; + struct t_pw tpw; + struct t_confent *tce, mytce; + char *cp, *cp2; + struct t_server *ts; + int id, i, plen, toffs; + u_char vals[2]; + struct b64state bs; +#endif /* USE_SRP */ + + pcb->settings.eap_timeout_time = pcb->eap.es_savedtime; + switch (pcb->eap.es_server.ea_state) { + case eapBadAuth: + return; + + case eapIdentify: +#ifdef USE_SRP + /* Discard any previous session. */ + ts = (struct t_server *)pcb->eap.es_server.ea_session; + if (ts != NULL) { + t_serverclose(ts); + pcb->eap.es_server.ea_session = NULL; + pcb->eap.es_server.ea_skey = NULL; + } +#endif /* USE_SRP */ + if (status != 0) { + pcb->eap.es_server.ea_state = eapBadAuth; + break; + } +#ifdef USE_SRP + /* If we've got a pseudonym, try to decode to real name. */ + if (pcb->eap.es_server.ea_peerlen > SRP_PSEUDO_LEN && + strncmp(pcb->eap.es_server.ea_peer, SRP_PSEUDO_ID, + SRP_PSEUDO_LEN) == 0 && + (pcb->eap.es_server.ea_peerlen - SRP_PSEUDO_LEN) * 3 / 4 < + sizeof (secbuf)) { + BZERO(&bs, sizeof (bs)); + plen = b64dec(&bs, + pcb->eap.es_server.ea_peer + SRP_PSEUDO_LEN, + pcb->eap.es_server.ea_peerlen - SRP_PSEUDO_LEN, + secbuf); + toffs = 0; + for (i = 0; i < 5; i++) { + pncrypt_setkey(toffs); + toffs -= 86400; + /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ + if (!DesDecrypt(secbuf, clear)) { + ppp_dbglog("no DES here; cannot decode " + "pseudonym"); + return; + } + id = *(unsigned char *)clear; + if (id + 1 <= plen && id + 9 > plen) + break; + } + if (plen % 8 == 0 && i < 5) { + /* + * Note that this is always shorter than the + * original stored string, so there's no need + * to realloc. + */ + if ((i = plen = *(unsigned char *)clear) > 7) + i = 7; + pcb->eap.es_server.ea_peerlen = plen; + dp = (unsigned char *)pcb->eap.es_server.ea_peer; + MEMCPY(dp, clear + 1, i); + plen -= i; + dp += i; + sp = secbuf + 8; + while (plen > 0) { + /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ + (void) DesDecrypt(sp, dp); + sp += 8; + dp += 8; + plen -= 8; + } + pcb->eap.es_server.ea_peer[ + pcb->eap.es_server.ea_peerlen] = '\0'; + ppp_dbglog("decoded pseudonym to \"%.*q\"", + pcb->eap.es_server.ea_peerlen, + pcb->eap.es_server.ea_peer); + } else { + ppp_dbglog("failed to decode real name"); + /* Stay in eapIdentfy state; requery */ + break; + } + } + /* Look up user in secrets database. */ + if (get_srp_secret(pcb->eap.es_unit, pcb->eap.es_server.ea_peer, + pcb->eap.es_server.ea_name, (char *)secbuf, 1) != 0) { + /* Set up default in case SRP entry is bad */ + pcb->eap.es_server.ea_state = eapMD5Chall; + /* Get t_confent based on index in srp-secrets */ + id = strtol((char *)secbuf, &cp, 10); + if (*cp++ != ':' || id < 0) + break; + if (id == 0) { + mytce.index = 0; + mytce.modulus.data = (u_char *)wkmodulus; + mytce.modulus.len = sizeof (wkmodulus); + mytce.generator.data = (u_char *)"\002"; + mytce.generator.len = 1; + tce = &mytce; + } else if ((tce = gettcid(id)) != NULL) { + /* + * Client will have to verify this modulus/ + * generator combination, and that will take + * a while. Lengthen the timeout here. + */ + if (pcb->settings.eap_timeout_time > 0 && + pcb->settings.eap_timeout_time < 30) + pcb->settings.eap_timeout_time = 30; + } else { + break; + } + if ((cp2 = strchr(cp, ':')) == NULL) + break; + *cp2++ = '\0'; + tpw.pebuf.name = pcb->eap.es_server.ea_peer; + tpw.pebuf.password.len = t_fromb64((char *)tpw.pwbuf, + cp); + tpw.pebuf.password.data = tpw.pwbuf; + tpw.pebuf.salt.len = t_fromb64((char *)tpw.saltbuf, + cp2); + tpw.pebuf.salt.data = tpw.saltbuf; + if ((ts = t_serveropenraw(&tpw.pebuf, tce)) == NULL) + break; + pcb->eap.es_server.ea_session = (void *)ts; + pcb->eap.es_server.ea_state = eapSRP1; + vals[0] = pcb->eap.es_server.ea_id + 1; + vals[1] = EAPT_SRP; + t_serveraddexdata(ts, vals, 2); + /* Generate B; must call before t_servergetkey() */ + t_servergenexp(ts); + break; + } +#endif /* USE_SRP */ + pcb->eap.es_server.ea_state = eapMD5Chall; + break; + + case eapSRP1: +#ifdef USE_SRP + ts = (struct t_server *)pcb->eap.es_server.ea_session; + if (ts != NULL && status != 0) { + t_serverclose(ts); + pcb->eap.es_server.ea_session = NULL; + pcb->eap.es_server.ea_skey = NULL; + } +#endif /* USE_SRP */ + if (status == 1) { + pcb->eap.es_server.ea_state = eapMD5Chall; + } else if (status != 0 || pcb->eap.es_server.ea_session == NULL) { + pcb->eap.es_server.ea_state = eapBadAuth; + } else { + pcb->eap.es_server.ea_state = eapSRP2; + } + break; + + case eapSRP2: +#ifdef USE_SRP + ts = (struct t_server *)pcb->eap.es_server.ea_session; + if (ts != NULL && status != 0) { + t_serverclose(ts); + pcb->eap.es_server.ea_session = NULL; + pcb->eap.es_server.ea_skey = NULL; + } +#endif /* USE_SRP */ + if (status != 0 || pcb->eap.es_server.ea_session == NULL) { + pcb->eap.es_server.ea_state = eapBadAuth; + } else { + pcb->eap.es_server.ea_state = eapSRP3; + } + break; + + case eapSRP3: + case eapSRP4: +#ifdef USE_SRP + ts = (struct t_server *)pcb->eap.es_server.ea_session; + if (ts != NULL && status != 0) { + t_serverclose(ts); + pcb->eap.es_server.ea_session = NULL; + pcb->eap.es_server.ea_skey = NULL; + } +#endif /* USE_SRP */ + if (status != 0 || pcb->eap.es_server.ea_session == NULL) { + pcb->eap.es_server.ea_state = eapBadAuth; + } else { + pcb->eap.es_server.ea_state = eapOpen; + } + break; + + case eapMD5Chall: + if (status != 0) { + pcb->eap.es_server.ea_state = eapBadAuth; + } else { + pcb->eap.es_server.ea_state = eapOpen; + } + break; + + default: + pcb->eap.es_server.ea_state = eapBadAuth; + break; + } + if (pcb->eap.es_server.ea_state == eapBadAuth) + eap_send_failure(pcb); +} + +/* + * Format an EAP Request message and send it to the peer. Message + * type depends on current state. (Server operation) + */ +static void eap_send_request(ppp_pcb *pcb) { + struct pbuf *p; + u_char *outp; + u_char *lenloc; + int outlen; + int len; + const char *str; +#ifdef USE_SRP + struct t_server *ts; + u_char clear[8], cipher[8], dig[SHA_DIGESTSIZE], *optr, *cp; + int i, j; + struct b64state b64; + SHA1_CTX ctxt; +#endif /* USE_SRP */ + + /* Handle both initial auth and restart */ + if (pcb->eap.es_server.ea_state < eapIdentify && + pcb->eap.es_server.ea_state != eapInitial) { + pcb->eap.es_server.ea_state = eapIdentify; +#if PPP_REMOTENAME + if (pcb->settings.explicit_remote && pcb->remote_name) { + /* + * If we already know the peer's + * unauthenticated name, then there's no + * reason to ask. Go to next state instead. + */ + int len = (int)strlen(pcb->remote_name); + if (len > MAXNAMELEN) { + len = MAXNAMELEN; + } + MEMCPY(pcb->eap.es_server.ea_peer, pcb->remote_name, len); + pcb->eap.es_server.ea_peer[len] = '\0'; + pcb->eap.es_server.ea_peerlen = len; + eap_figure_next_state(pcb, 0); + } +#endif /* PPP_REMOTENAME */ + } + + if (pcb->settings.eap_max_transmits > 0 && + pcb->eap.es_server.ea_requests >= pcb->settings.eap_max_transmits) { + if (pcb->eap.es_server.ea_responses > 0) + ppp_error("EAP: too many Requests sent"); + else + ppp_error("EAP: no response to Requests"); + eap_send_failure(pcb); + return; + } + + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_CTRL_PBUF_MAX_SIZE), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_REQUEST, outp); + PUTCHAR(pcb->eap.es_server.ea_id, outp); + lenloc = outp; + INCPTR(2, outp); + + switch (pcb->eap.es_server.ea_state) { + case eapIdentify: + PUTCHAR(EAPT_IDENTITY, outp); + str = "Name"; + len = strlen(str); + MEMCPY(outp, str, len); + INCPTR(len, outp); + break; + + case eapMD5Chall: + PUTCHAR(EAPT_MD5CHAP, outp); + /* + * pick a random challenge length between + * EAP_MIN_CHALLENGE_LENGTH and EAP_MAX_CHALLENGE_LENGTH + */ + pcb->eap.es_challen = EAP_MIN_CHALLENGE_LENGTH + + magic_pow(EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH); + PUTCHAR(pcb->eap.es_challen, outp); + magic_random_bytes(pcb->eap.es_challenge, pcb->eap.es_challen); + MEMCPY(outp, pcb->eap.es_challenge, pcb->eap.es_challen); + INCPTR(pcb->eap.es_challen, outp); + MEMCPY(outp, pcb->eap.es_server.ea_name, pcb->eap.es_server.ea_namelen); + INCPTR(pcb->eap.es_server.ea_namelen, outp); + break; + +#ifdef USE_SRP + case eapSRP1: + PUTCHAR(EAPT_SRP, outp); + PUTCHAR(EAPSRP_CHALLENGE, outp); + + PUTCHAR(pcb->eap.es_server.ea_namelen, outp); + MEMCPY(outp, pcb->eap.es_server.ea_name, pcb->eap.es_server.ea_namelen); + INCPTR(pcb->eap.es_server.ea_namelen, outp); + + ts = (struct t_server *)pcb->eap.es_server.ea_session; + assert(ts != NULL); + PUTCHAR(ts->s.len, outp); + MEMCPY(outp, ts->s.data, ts->s.len); + INCPTR(ts->s.len, outp); + + if (ts->g.len == 1 && ts->g.data[0] == 2) { + PUTCHAR(0, outp); + } else { + PUTCHAR(ts->g.len, outp); + MEMCPY(outp, ts->g.data, ts->g.len); + INCPTR(ts->g.len, outp); + } + + if (ts->n.len != sizeof (wkmodulus) || + BCMP(ts->n.data, wkmodulus, sizeof (wkmodulus)) != 0) { + MEMCPY(outp, ts->n.data, ts->n.len); + INCPTR(ts->n.len, outp); + } + break; + + case eapSRP2: + PUTCHAR(EAPT_SRP, outp); + PUTCHAR(EAPSRP_SKEY, outp); + + ts = (struct t_server *)pcb->eap.es_server.ea_session; + assert(ts != NULL); + MEMCPY(outp, ts->B.data, ts->B.len); + INCPTR(ts->B.len, outp); + break; + + case eapSRP3: + PUTCHAR(EAPT_SRP, outp); + PUTCHAR(EAPSRP_SVALIDATOR, outp); + PUTLONG(SRPVAL_EBIT, outp); + ts = (struct t_server *)pcb->eap.es_server.ea_session; + assert(ts != NULL); + MEMCPY(outp, t_serverresponse(ts), SHA_DIGESTSIZE); + INCPTR(SHA_DIGESTSIZE, outp); + + if (pncrypt_setkey(0)) { + /* Generate pseudonym */ + optr = outp; + cp = (unsigned char *)pcb->eap.es_server.ea_peer; + if ((j = i = pcb->eap.es_server.ea_peerlen) > 7) + j = 7; + clear[0] = i; + MEMCPY(clear + 1, cp, j); + i -= j; + cp += j; + /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ + if (!DesEncrypt(clear, cipher)) { + ppp_dbglog("no DES here; not generating pseudonym"); + break; + } + BZERO(&b64, sizeof (b64)); + outp++; /* space for pseudonym length */ + outp += b64enc(&b64, cipher, 8, outp); + while (i >= 8) { + /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ + (void) DesEncrypt(cp, cipher); + outp += b64enc(&b64, cipher, 8, outp); + cp += 8; + i -= 8; + } + if (i > 0) { + MEMCPY(clear, cp, i); + cp += i; + magic_random_bytes(cp, 8-i); + /* FIXME: if we want to do SRP, we need to find a way to pass the PolarSSL des_context instead of using static memory */ + (void) DesEncrypt(clear, cipher); + outp += b64enc(&b64, cipher, 8, outp); + } + outp += b64flush(&b64, outp); + + /* Set length and pad out to next 20 octet boundary */ + i = outp - optr - 1; + *optr = i; + i %= SHA_DIGESTSIZE; + if (i != 0) { + magic_random_bytes(outp, SHA_DIGESTSIZE-i); + INCPTR(SHA_DIGESTSIZE-i, outp); + } + + /* Obscure the pseudonym with SHA1 hash */ + SHA1Init(&ctxt); + SHA1Update(&ctxt, &pcb->eap.es_server.ea_id, 1); + SHA1Update(&ctxt, pcb->eap.es_server.ea_skey, + SESSION_KEY_LEN); + SHA1Update(&ctxt, pcb->eap.es_server.ea_peer, + pcb->eap.es_server.ea_peerlen); + while (optr < outp) { + SHA1Final(dig, &ctxt); + cp = dig; + while (cp < dig + SHA_DIGESTSIZE) + *optr++ ^= *cp++; + SHA1Init(&ctxt); + SHA1Update(&ctxt, &pcb->eap.es_server.ea_id, 1); + SHA1Update(&ctxt, pcb->eap.es_server.ea_skey, + SESSION_KEY_LEN); + SHA1Update(&ctxt, optr - SHA_DIGESTSIZE, + SHA_DIGESTSIZE); + } + } + break; + + case eapSRP4: + PUTCHAR(EAPT_SRP, outp); + PUTCHAR(EAPSRP_LWRECHALLENGE, outp); + pcb->eap.es_challen = EAP_MIN_CHALLENGE_LENGTH + + magic_pow(EAP_MIN_MAX_POWER_OF_TWO_CHALLENGE_LENGTH); + magic_random_bytes(pcb->eap.es_challenge, pcb->eap.es_challen); + MEMCPY(outp, pcb->eap.es_challenge, pcb->eap.es_challen); + INCPTR(pcb->eap.es_challen, outp); + break; +#endif /* USE_SRP */ + + default: + return; + } + + outlen = (outp - (unsigned char*)p->payload) - PPP_HDRLEN; + PUTSHORT(outlen, lenloc); + + pbuf_realloc(p, outlen + PPP_HDRLEN); + ppp_write(pcb, p); + + pcb->eap.es_server.ea_requests++; + + if (pcb->settings.eap_timeout_time > 0) + TIMEOUT(eap_server_timeout, pcb, pcb->settings.eap_timeout_time); +} + +/* + * eap_authpeer - Authenticate our peer (behave as server). + * + * Start server state and send first request. This is called only + * after eap_lowerup. + */ +void eap_authpeer(ppp_pcb *pcb, const char *localname) { + + /* Save the name we're given. */ + pcb->eap.es_server.ea_name = localname; + pcb->eap.es_server.ea_namelen = strlen(localname); + + pcb->eap.es_savedtime = pcb->settings.eap_timeout_time; + + /* Lower layer up yet? */ + if (pcb->eap.es_server.ea_state == eapInitial || + pcb->eap.es_server.ea_state == eapPending) { + pcb->eap.es_server.ea_state = eapPending; + return; + } + + pcb->eap.es_server.ea_state = eapPending; + + /* ID number not updated here intentionally; hashed into M1 */ + eap_send_request(pcb); +} + +/* + * eap_server_timeout - Retransmission timer for sending Requests + * expired. + */ +static void eap_server_timeout(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + + if (!eap_server_active(pcb)) + return; + + /* EAP ID number must not change on timeout. */ + eap_send_request(pcb); +} + +/* + * When it's time to send rechallenge the peer, this timeout is + * called. Once the rechallenge is successful, the response handler + * will restart the timer. If it fails, then the link is dropped. + */ +static void eap_rechallenge(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + + if (pcb->eap.es_server.ea_state != eapOpen && + pcb->eap.es_server.ea_state != eapSRP4) + return; + + pcb->eap.es_server.ea_requests = 0; + pcb->eap.es_server.ea_state = eapIdentify; + eap_figure_next_state(pcb, 0); + pcb->eap.es_server.ea_id++; + eap_send_request(pcb); +} + +static void srp_lwrechallenge(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + + if (pcb->eap.es_server.ea_state != eapOpen || + pcb->eap.es_server.ea_type != EAPT_SRP) + return; + + pcb->eap.es_server.ea_requests = 0; + pcb->eap.es_server.ea_state = eapSRP4; + pcb->eap.es_server.ea_id++; + eap_send_request(pcb); +} +#endif /* PPP_SERVER */ + +/* + * eap_lowerup - The lower layer is now up. + * + * This is called before either eap_authpeer or eap_authwithpeer. See + * link_established() in auth.c. All that's necessary here is to + * return to closed state so that those two routines will do the right + * thing. + */ +static void eap_lowerup(ppp_pcb *pcb) { + pcb->eap.es_client.ea_state = eapClosed; +#if PPP_SERVER + pcb->eap.es_server.ea_state = eapClosed; +#endif /* PPP_SERVER */ +} + +/* + * eap_lowerdown - The lower layer is now down. + * + * Cancel all timeouts and return to initial state. + */ +static void eap_lowerdown(ppp_pcb *pcb) { + + if (eap_client_active(pcb) && pcb->settings.eap_req_time > 0) { + UNTIMEOUT(eap_client_timeout, pcb); + } +#if PPP_SERVER + if (eap_server_active(pcb)) { + if (pcb->settings.eap_timeout_time > 0) { + UNTIMEOUT(eap_server_timeout, pcb); + } + } else { + if ((pcb->eap.es_server.ea_state == eapOpen || + pcb->eap.es_server.ea_state == eapSRP4) && + pcb->eap.es_rechallenge > 0) { + UNTIMEOUT(eap_rechallenge, (void *)pcb); + } + if (pcb->eap.es_server.ea_state == eapOpen && + pcb->eap.es_lwrechallenge > 0) { + UNTIMEOUT(srp_lwrechallenge, (void *)pcb); + } + } + + pcb->eap.es_client.ea_state = pcb->eap.es_server.ea_state = eapInitial; + pcb->eap.es_client.ea_requests = pcb->eap.es_server.ea_requests = 0; +#endif /* PPP_SERVER */ +} + +/* + * eap_protrej - Peer doesn't speak this protocol. + * + * This shouldn't happen. If it does, it represents authentication + * failure. + */ +static void eap_protrej(ppp_pcb *pcb) { + + if (eap_client_active(pcb)) { + ppp_error("EAP authentication failed due to Protocol-Reject"); + auth_withpeer_fail(pcb, PPP_EAP); + } +#if PPP_SERVER + if (eap_server_active(pcb)) { + ppp_error("EAP authentication of peer failed on Protocol-Reject"); + auth_peer_fail(pcb, PPP_EAP); + } +#endif /* PPP_SERVER */ + eap_lowerdown(pcb); +} + +/* + * Format and send a regular EAP Response message. + */ +static void eap_send_response(ppp_pcb *pcb, u_char id, u_char typenum, const u_char *str, int lenstr) { + struct pbuf *p; + u_char *outp; + int msglen; + + msglen = EAP_HEADERLEN + sizeof (u_char) + lenstr; + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_RESPONSE, outp); + PUTCHAR(id, outp); + pcb->eap.es_client.ea_id = id; + PUTSHORT(msglen, outp); + PUTCHAR(typenum, outp); + if (lenstr > 0) { + MEMCPY(outp, str, lenstr); + } + + ppp_write(pcb, p); +} + +/* + * Format and send an MD5-Challenge EAP Response message. + */ +static void eap_chap_response(ppp_pcb *pcb, u_char id, u_char *hash, const char *name, int namelen) { + struct pbuf *p; + u_char *outp; + int msglen; + + msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + MD5_SIGNATURE_SIZE + + namelen; + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_RESPONSE, outp); + PUTCHAR(id, outp); + pcb->eap.es_client.ea_id = id; + PUTSHORT(msglen, outp); + PUTCHAR(EAPT_MD5CHAP, outp); + PUTCHAR(MD5_SIGNATURE_SIZE, outp); + MEMCPY(outp, hash, MD5_SIGNATURE_SIZE); + INCPTR(MD5_SIGNATURE_SIZE, outp); + if (namelen > 0) { + MEMCPY(outp, name, namelen); + } + + ppp_write(pcb, p); +} + +#ifdef USE_SRP +/* + * Format and send a SRP EAP Response message. + */ +static void +eap_srp_response(esp, id, subtypenum, str, lenstr) +eap_state *esp; +u_char id; +u_char subtypenum; +u_char *str; +int lenstr; +{ + ppp_pcb *pcb = &ppp_pcb_list[pcb->eap.es_unit]; + struct pbuf *p; + u_char *outp; + int msglen; + + msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + lenstr; + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_RESPONSE, outp); + PUTCHAR(id, outp); + pcb->eap.es_client.ea_id = id; + PUTSHORT(msglen, outp); + PUTCHAR(EAPT_SRP, outp); + PUTCHAR(subtypenum, outp); + if (lenstr > 0) { + MEMCPY(outp, str, lenstr); + } + + ppp_write(pcb, p); +} + +/* + * Format and send a SRP EAP Client Validator Response message. + */ +static void +eap_srpval_response(esp, id, flags, str) +eap_state *esp; +u_char id; +u32_t flags; +u_char *str; +{ + ppp_pcb *pcb = &ppp_pcb_list[pcb->eap.es_unit]; + struct pbuf *p; + u_char *outp; + int msglen; + + msglen = EAP_HEADERLEN + 2 * sizeof (u_char) + sizeof (u32_t) + + SHA_DIGESTSIZE; + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_RESPONSE, outp); + PUTCHAR(id, outp); + pcb->eap.es_client.ea_id = id; + PUTSHORT(msglen, outp); + PUTCHAR(EAPT_SRP, outp); + PUTCHAR(EAPSRP_CVALIDATOR, outp); + PUTLONG(flags, outp); + MEMCPY(outp, str, SHA_DIGESTSIZE); + + ppp_write(pcb, p); +} +#endif /* USE_SRP */ + +static void eap_send_nak(ppp_pcb *pcb, u_char id, u_char type) { + struct pbuf *p; + u_char *outp; + int msglen; + + msglen = EAP_HEADERLEN + 2 * sizeof (u_char); + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN + msglen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + + MAKEHEADER(outp, PPP_EAP); + + PUTCHAR(EAP_RESPONSE, outp); + PUTCHAR(id, outp); + pcb->eap.es_client.ea_id = id; + PUTSHORT(msglen, outp); + PUTCHAR(EAPT_NAK, outp); + PUTCHAR(type, outp); + + ppp_write(pcb, p); +} + +#ifdef USE_SRP +static char * +name_of_pn_file() +{ + char *user, *path, *file; + struct passwd *pw; + size_t pl; + static bool pnlogged = 0; + + pw = getpwuid(getuid()); + if (pw == NULL || (user = pw->pw_dir) == NULL || user[0] == 0) { + errno = EINVAL; + return (NULL); + } + file = _PATH_PSEUDONYM; + pl = strlen(user) + strlen(file) + 2; + path = malloc(pl); + if (path == NULL) + return (NULL); + (void) slprintf(path, pl, "%s/%s", user, file); + if (!pnlogged) { + ppp_dbglog("pseudonym file: %s", path); + pnlogged = 1; + } + return (path); +} + +static int +open_pn_file(modebits) +mode_t modebits; +{ + char *path; + int fd, err; + + if ((path = name_of_pn_file()) == NULL) + return (-1); + fd = open(path, modebits, S_IRUSR | S_IWUSR); + err = errno; + free(path); + errno = err; + return (fd); +} + +static void +remove_pn_file() +{ + char *path; + + if ((path = name_of_pn_file()) != NULL) { + (void) unlink(path); + (void) free(path); + } +} + +static void +write_pseudonym(esp, inp, len, id) +eap_state *esp; +u_char *inp; +int len, id; +{ + u_char val; + u_char *datp, *digp; + SHA1_CTX ctxt; + u_char dig[SHA_DIGESTSIZE]; + int dsize, fd, olen = len; + + /* + * Do the decoding by working backwards. This eliminates the need + * to save the decoded output in a separate buffer. + */ + val = id; + while (len > 0) { + if ((dsize = len % SHA_DIGESTSIZE) == 0) + dsize = SHA_DIGESTSIZE; + len -= dsize; + datp = inp + len; + SHA1Init(&ctxt); + SHA1Update(&ctxt, &val, 1); + SHA1Update(&ctxt, pcb->eap.es_client.ea_skey, SESSION_KEY_LEN); + if (len > 0) { + SHA1Update(&ctxt, datp, SHA_DIGESTSIZE); + } else { + SHA1Update(&ctxt, pcb->eap.es_client.ea_name, + pcb->eap.es_client.ea_namelen); + } + SHA1Final(dig, &ctxt); + for (digp = dig; digp < dig + SHA_DIGESTSIZE; digp++) + *datp++ ^= *digp; + } + + /* Now check that the result is sane */ + if (olen <= 0 || *inp + 1 > olen) { + ppp_dbglog("EAP: decoded pseudonym is unusable <%.*B>", olen, inp); + return; + } + + /* Save it away */ + fd = open_pn_file(O_WRONLY | O_CREAT | O_TRUNC); + if (fd < 0) { + ppp_dbglog("EAP: error saving pseudonym: %m"); + return; + } + len = write(fd, inp + 1, *inp); + if (close(fd) != -1 && len == *inp) { + ppp_dbglog("EAP: saved pseudonym"); + pcb->eap.es_usedpseudo = 0; + } else { + ppp_dbglog("EAP: failed to save pseudonym"); + remove_pn_file(); + } +} +#endif /* USE_SRP */ + +/* + * eap_request - Receive EAP Request message (client mode). + */ +static void eap_request(ppp_pcb *pcb, u_char *inp, int id, int len) { + u_char typenum; + u_char vallen; + int secret_len; + char secret[MAXSECRETLEN]; + char rhostname[MAXNAMELEN]; + lwip_md5_context mdContext; + u_char hash[MD5_SIGNATURE_SIZE]; +#ifdef USE_SRP + struct t_client *tc; + struct t_num sval, gval, Nval, *Ap, Bval; + u_char vals[2]; + SHA1_CTX ctxt; + u_char dig[SHA_DIGESTSIZE]; + int fd; +#endif /* USE_SRP */ + + /* + * Note: we update es_client.ea_id *only if* a Response + * message is being generated. Otherwise, we leave it the + * same for duplicate detection purposes. + */ + + pcb->eap.es_client.ea_requests++; + if (pcb->settings.eap_allow_req != 0 && + pcb->eap.es_client.ea_requests > pcb->settings.eap_allow_req) { + ppp_info("EAP: received too many Request messages"); + if (pcb->settings.eap_req_time > 0) { + UNTIMEOUT(eap_client_timeout, pcb); + } + auth_withpeer_fail(pcb, PPP_EAP); + return; + } + + if (len <= 0) { + ppp_error("EAP: empty Request message discarded"); + return; + } + + GETCHAR(typenum, inp); + len--; + + switch (typenum) { + case EAPT_IDENTITY: + if (len > 0) + ppp_info("EAP: Identity prompt \"%.*q\"", len, inp); +#ifdef USE_SRP + if (pcb->eap.es_usepseudo && + (pcb->eap.es_usedpseudo == 0 || + (pcb->eap.es_usedpseudo == 1 && + id == pcb->eap.es_client.ea_id))) { + pcb->eap.es_usedpseudo = 1; + /* Try to get a pseudonym */ + if ((fd = open_pn_file(O_RDONLY)) >= 0) { + strcpy(rhostname, SRP_PSEUDO_ID); + len = read(fd, rhostname + SRP_PSEUDO_LEN, + sizeof (rhostname) - SRP_PSEUDO_LEN); + /* XXX NAI unsupported */ + if (len > 0) { + eap_send_response(pcb, id, typenum, + rhostname, len + SRP_PSEUDO_LEN); + } + (void) close(fd); + if (len > 0) + break; + } + } + /* Stop using pseudonym now. */ + if (pcb->eap.es_usepseudo && pcb->eap.es_usedpseudo != 2) { + remove_pn_file(); + pcb->eap.es_usedpseudo = 2; + } +#endif /* USE_SRP */ + eap_send_response(pcb, id, typenum, (const u_char*)pcb->eap.es_client.ea_name, + pcb->eap.es_client.ea_namelen); + break; + + case EAPT_NOTIFICATION: + if (len > 0) + ppp_info("EAP: Notification \"%.*q\"", len, inp); + eap_send_response(pcb, id, typenum, NULL, 0); + break; + + case EAPT_NAK: + /* + * Avoid the temptation to send Response Nak in reply + * to Request Nak here. It can only lead to trouble. + */ + ppp_warn("EAP: unexpected Nak in Request; ignored"); + /* Return because we're waiting for something real. */ + return; + + case EAPT_MD5CHAP: + if (len < 1) { + ppp_error("EAP: received MD5-Challenge with no data"); + /* Bogus request; wait for something real. */ + return; + } + GETCHAR(vallen, inp); + len--; + if (vallen < 8 || vallen > len) { + ppp_error("EAP: MD5-Challenge with bad length %d (8..%d)", + vallen, len); + /* Try something better. */ + eap_send_nak(pcb, id, EAPT_SRP); + break; + } + + /* Not so likely to happen. */ + if (vallen >= len + sizeof (rhostname)) { + ppp_dbglog("EAP: trimming really long peer name down"); + MEMCPY(rhostname, inp + vallen, sizeof (rhostname) - 1); + rhostname[sizeof (rhostname) - 1] = '\0'; + } else { + MEMCPY(rhostname, inp + vallen, len - vallen); + rhostname[len - vallen] = '\0'; + } + +#if PPP_REMOTENAME + /* In case the remote doesn't give us his name. */ + if (pcb->settings.explicit_remote || + (pcb->settings.remote_name[0] != '\0' && vallen == len)) + strlcpy(rhostname, pcb->settings.remote_name, sizeof (rhostname)); +#endif /* PPP_REMOTENAME */ + + /* + * Get the secret for authenticating ourselves with + * the specified host. + */ + if (!get_secret(pcb, pcb->eap.es_client.ea_name, + rhostname, secret, &secret_len, 0)) { + ppp_dbglog("EAP: no MD5 secret for auth to %q", rhostname); + eap_send_nak(pcb, id, EAPT_SRP); + break; + } + lwip_md5_init(&mdContext); + lwip_md5_starts(&mdContext); + typenum = id; + lwip_md5_update(&mdContext, &typenum, 1); + lwip_md5_update(&mdContext, (u_char *)secret, secret_len); + BZERO(secret, sizeof (secret)); + lwip_md5_update(&mdContext, inp, vallen); + lwip_md5_finish(&mdContext, hash); + lwip_md5_free(&mdContext); + eap_chap_response(pcb, id, hash, pcb->eap.es_client.ea_name, + pcb->eap.es_client.ea_namelen); + break; + +#ifdef USE_SRP + case EAPT_SRP: + if (len < 1) { + ppp_error("EAP: received empty SRP Request"); + /* Bogus request; wait for something real. */ + return; + } + + /* Get subtype */ + GETCHAR(vallen, inp); + len--; + switch (vallen) { + case EAPSRP_CHALLENGE: + tc = NULL; + if (pcb->eap.es_client.ea_session != NULL) { + tc = (struct t_client *)pcb->eap.es_client. + ea_session; + /* + * If this is a new challenge, then start + * over with a new client session context. + * Otherwise, just resend last response. + */ + if (id != pcb->eap.es_client.ea_id) { + t_clientclose(tc); + pcb->eap.es_client.ea_session = NULL; + tc = NULL; + } + } + /* No session key just yet */ + pcb->eap.es_client.ea_skey = NULL; + if (tc == NULL) { + int rhostnamelen; + + GETCHAR(vallen, inp); + len--; + if (vallen >= len) { + ppp_error("EAP: badly-formed SRP Challenge" + " (name)"); + /* Ignore badly-formed messages */ + return; + } + MEMCPY(rhostname, inp, vallen); + rhostname[vallen] = '\0'; + INCPTR(vallen, inp); + len -= vallen; + + /* + * In case the remote doesn't give us his name, + * use configured name. + */ + if (explicit_remote || + (remote_name[0] != '\0' && vallen == 0)) { + strlcpy(rhostname, remote_name, + sizeof (rhostname)); + } + + rhostnamelen = (int)strlen(rhostname); + if (rhostnamelen > MAXNAMELEN) { + rhostnamelen = MAXNAMELEN; + } + MEMCPY(pcb->eap.es_client.ea_peer, rhostname, rhostnamelen); + pcb->eap.es_client.ea_peer[rhostnamelen] = '\0'; + pcb->eap.es_client.ea_peerlen = rhostnamelen; + + GETCHAR(vallen, inp); + len--; + if (vallen >= len) { + ppp_error("EAP: badly-formed SRP Challenge" + " (s)"); + /* Ignore badly-formed messages */ + return; + } + sval.data = inp; + sval.len = vallen; + INCPTR(vallen, inp); + len -= vallen; + + GETCHAR(vallen, inp); + len--; + if (vallen > len) { + ppp_error("EAP: badly-formed SRP Challenge" + " (g)"); + /* Ignore badly-formed messages */ + return; + } + /* If no generator present, then use value 2 */ + if (vallen == 0) { + gval.data = (u_char *)"\002"; + gval.len = 1; + } else { + gval.data = inp; + gval.len = vallen; + } + INCPTR(vallen, inp); + len -= vallen; + + /* + * If no modulus present, then use well-known + * value. + */ + if (len == 0) { + Nval.data = (u_char *)wkmodulus; + Nval.len = sizeof (wkmodulus); + } else { + Nval.data = inp; + Nval.len = len; + } + tc = t_clientopen(pcb->eap.es_client.ea_name, + &Nval, &gval, &sval); + if (tc == NULL) { + eap_send_nak(pcb, id, EAPT_MD5CHAP); + break; + } + pcb->eap.es_client.ea_session = (void *)tc; + + /* Add Challenge ID & type to verifier */ + vals[0] = id; + vals[1] = EAPT_SRP; + t_clientaddexdata(tc, vals, 2); + } + Ap = t_clientgenexp(tc); + eap_srp_response(esp, id, EAPSRP_CKEY, Ap->data, + Ap->len); + break; + + case EAPSRP_SKEY: + tc = (struct t_client *)pcb->eap.es_client.ea_session; + if (tc == NULL) { + ppp_warn("EAP: peer sent Subtype 2 without 1"); + eap_send_nak(pcb, id, EAPT_MD5CHAP); + break; + } + if (pcb->eap.es_client.ea_skey != NULL) { + /* + * ID number should not change here. Warn + * if it does (but otherwise ignore). + */ + if (id != pcb->eap.es_client.ea_id) { + ppp_warn("EAP: ID changed from %d to %d " + "in SRP Subtype 2 rexmit", + pcb->eap.es_client.ea_id, id); + } + } else { + if (get_srp_secret(pcb->eap.es_unit, + pcb->eap.es_client.ea_name, + pcb->eap.es_client.ea_peer, secret, 0) == 0) { + /* + * Can't work with this peer because + * the secret is missing. Just give + * up. + */ + eap_send_nak(pcb, id, EAPT_MD5CHAP); + break; + } + Bval.data = inp; + Bval.len = len; + t_clientpasswd(tc, secret); + BZERO(secret, sizeof (secret)); + pcb->eap.es_client.ea_skey = + t_clientgetkey(tc, &Bval); + if (pcb->eap.es_client.ea_skey == NULL) { + /* Server is rogue; stop now */ + ppp_error("EAP: SRP server is rogue"); + goto client_failure; + } + } + eap_srpval_response(esp, id, SRPVAL_EBIT, + t_clientresponse(tc)); + break; + + case EAPSRP_SVALIDATOR: + tc = (struct t_client *)pcb->eap.es_client.ea_session; + if (tc == NULL || pcb->eap.es_client.ea_skey == NULL) { + ppp_warn("EAP: peer sent Subtype 3 without 1/2"); + eap_send_nak(pcb, id, EAPT_MD5CHAP); + break; + } + /* + * If we're already open, then this ought to be a + * duplicate. Otherwise, check that the server is + * who we think it is. + */ + if (pcb->eap.es_client.ea_state == eapOpen) { + if (id != pcb->eap.es_client.ea_id) { + ppp_warn("EAP: ID changed from %d to %d " + "in SRP Subtype 3 rexmit", + pcb->eap.es_client.ea_id, id); + } + } else { + len -= sizeof (u32_t) + SHA_DIGESTSIZE; + if (len < 0 || t_clientverify(tc, inp + + sizeof (u32_t)) != 0) { + ppp_error("EAP: SRP server verification " + "failed"); + goto client_failure; + } + GETLONG(pcb->eap.es_client.ea_keyflags, inp); + /* Save pseudonym if user wants it. */ + if (len > 0 && pcb->eap.es_usepseudo) { + INCPTR(SHA_DIGESTSIZE, inp); + write_pseudonym(esp, inp, len, id); + } + } + /* + * We've verified our peer. We're now mostly done, + * except for waiting on the regular EAP Success + * message. + */ + eap_srp_response(esp, id, EAPSRP_ACK, NULL, 0); + break; + + case EAPSRP_LWRECHALLENGE: + if (len < 4) { + ppp_warn("EAP: malformed Lightweight rechallenge"); + return; + } + SHA1Init(&ctxt); + vals[0] = id; + SHA1Update(&ctxt, vals, 1); + SHA1Update(&ctxt, pcb->eap.es_client.ea_skey, + SESSION_KEY_LEN); + SHA1Update(&ctxt, inp, len); + SHA1Update(&ctxt, pcb->eap.es_client.ea_name, + pcb->eap.es_client.ea_namelen); + SHA1Final(dig, &ctxt); + eap_srp_response(esp, id, EAPSRP_LWRECHALLENGE, dig, + SHA_DIGESTSIZE); + break; + + default: + ppp_error("EAP: unknown SRP Subtype %d", vallen); + eap_send_nak(pcb, id, EAPT_MD5CHAP); + break; + } + break; +#endif /* USE_SRP */ + + default: + ppp_info("EAP: unknown authentication type %d; Naking", typenum); + eap_send_nak(pcb, id, EAPT_SRP); + break; + } + + if (pcb->settings.eap_req_time > 0) { + UNTIMEOUT(eap_client_timeout, pcb); + TIMEOUT(eap_client_timeout, pcb, + pcb->settings.eap_req_time); + } + return; + +#ifdef USE_SRP +client_failure: + pcb->eap.es_client.ea_state = eapBadAuth; + if (pcb->settings.eap_req_time > 0) { + UNTIMEOUT(eap_client_timeout, (void *)esp); + } + pcb->eap.es_client.ea_session = NULL; + t_clientclose(tc); + auth_withpeer_fail(pcb, PPP_EAP); +#endif /* USE_SRP */ +} + +#if PPP_SERVER +/* + * eap_response - Receive EAP Response message (server mode). + */ +static void eap_response(ppp_pcb *pcb, u_char *inp, int id, int len) { + u_char typenum; + u_char vallen; + int secret_len; + char secret[MAXSECRETLEN]; + char rhostname[MAXNAMELEN]; + lwip_md5_context mdContext; + u_char hash[MD5_SIGNATURE_SIZE]; +#ifdef USE_SRP + struct t_server *ts; + struct t_num A; + SHA1_CTX ctxt; + u_char dig[SHA_DIGESTSIZE]; +#endif /* USE_SRP */ + + if (pcb->eap.es_server.ea_id != id) { + ppp_dbglog("EAP: discarding Response %d; expected ID %d", id, + pcb->eap.es_server.ea_id); + return; + } + + pcb->eap.es_server.ea_responses++; + + if (len <= 0) { + ppp_error("EAP: empty Response message discarded"); + return; + } + + GETCHAR(typenum, inp); + len--; + + switch (typenum) { + case EAPT_IDENTITY: + if (pcb->eap.es_server.ea_state != eapIdentify) { + ppp_dbglog("EAP discarding unwanted Identify \"%.q\"", len, + inp); + break; + } + ppp_info("EAP: unauthenticated peer name \"%.*q\"", len, inp); + if (len > MAXNAMELEN) { + len = MAXNAMELEN; + } + MEMCPY(pcb->eap.es_server.ea_peer, inp, len); + pcb->eap.es_server.ea_peer[len] = '\0'; + pcb->eap.es_server.ea_peerlen = len; + eap_figure_next_state(pcb, 0); + break; + + case EAPT_NOTIFICATION: + ppp_dbglog("EAP unexpected Notification; response discarded"); + break; + + case EAPT_NAK: + if (len < 1) { + ppp_info("EAP: Nak Response with no suggested protocol"); + eap_figure_next_state(pcb, 1); + break; + } + + GETCHAR(vallen, inp); + len--; + + if ( +#if PPP_REMOTENAME + !pcb->explicit_remote && +#endif /* PPP_REMOTENAME */ + pcb->eap.es_server.ea_state == eapIdentify){ + /* Peer cannot Nak Identify Request */ + eap_figure_next_state(pcb, 1); + break; + } + + switch (vallen) { + case EAPT_SRP: + /* Run through SRP validator selection again. */ + pcb->eap.es_server.ea_state = eapIdentify; + eap_figure_next_state(pcb, 0); + break; + + case EAPT_MD5CHAP: + pcb->eap.es_server.ea_state = eapMD5Chall; + break; + + default: + ppp_dbglog("EAP: peer requesting unknown Type %d", vallen); + switch (pcb->eap.es_server.ea_state) { + case eapSRP1: + case eapSRP2: + case eapSRP3: + pcb->eap.es_server.ea_state = eapMD5Chall; + break; + case eapMD5Chall: + case eapSRP4: + pcb->eap.es_server.ea_state = eapIdentify; + eap_figure_next_state(pcb, 0); + break; + default: + break; + } + break; + } + break; + + case EAPT_MD5CHAP: + if (pcb->eap.es_server.ea_state != eapMD5Chall) { + ppp_error("EAP: unexpected MD5-Response"); + eap_figure_next_state(pcb, 1); + break; + } + if (len < 1) { + ppp_error("EAP: received MD5-Response with no data"); + eap_figure_next_state(pcb, 1); + break; + } + GETCHAR(vallen, inp); + len--; + if (vallen != 16 || vallen > len) { + ppp_error("EAP: MD5-Response with bad length %d", vallen); + eap_figure_next_state(pcb, 1); + break; + } + + /* Not so likely to happen. */ + if (vallen >= len + sizeof (rhostname)) { + ppp_dbglog("EAP: trimming really long peer name down"); + MEMCPY(rhostname, inp + vallen, sizeof (rhostname) - 1); + rhostname[sizeof (rhostname) - 1] = '\0'; + } else { + MEMCPY(rhostname, inp + vallen, len - vallen); + rhostname[len - vallen] = '\0'; + } + +#if PPP_REMOTENAME + /* In case the remote doesn't give us his name. */ + if (explicit_remote || + (remote_name[0] != '\0' && vallen == len)) + strlcpy(rhostname, remote_name, sizeof (rhostname)); +#endif /* PPP_REMOTENAME */ + + /* + * Get the secret for authenticating the specified + * host. + */ + if (!get_secret(pcb, rhostname, + pcb->eap.es_server.ea_name, secret, &secret_len, 1)) { + ppp_dbglog("EAP: no MD5 secret for auth of %q", rhostname); + eap_send_failure(pcb); + break; + } + lwip_md5_init(&mdContext); + lwip_md5_starts(&mdContext); + lwip_md5_update(&mdContext, &pcb->eap.es_server.ea_id, 1); + lwip_md5_update(&mdContext, (u_char *)secret, secret_len); + BZERO(secret, sizeof (secret)); + lwip_md5_update(&mdContext, pcb->eap.es_challenge, pcb->eap.es_challen); + lwip_md5_finish(&mdContext, hash); + lwip_md5_free(&mdContext); + if (BCMP(hash, inp, MD5_SIGNATURE_SIZE) != 0) { + eap_send_failure(pcb); + break; + } + pcb->eap.es_server.ea_type = EAPT_MD5CHAP; + eap_send_success(pcb); + eap_figure_next_state(pcb, 0); + if (pcb->eap.es_rechallenge != 0) + TIMEOUT(eap_rechallenge, pcb, pcb->eap.es_rechallenge); + break; + +#ifdef USE_SRP + case EAPT_SRP: + if (len < 1) { + ppp_error("EAP: empty SRP Response"); + eap_figure_next_state(pcb, 1); + break; + } + GETCHAR(typenum, inp); + len--; + switch (typenum) { + case EAPSRP_CKEY: + if (pcb->eap.es_server.ea_state != eapSRP1) { + ppp_error("EAP: unexpected SRP Subtype 1 Response"); + eap_figure_next_state(pcb, 1); + break; + } + A.data = inp; + A.len = len; + ts = (struct t_server *)pcb->eap.es_server.ea_session; + assert(ts != NULL); + pcb->eap.es_server.ea_skey = t_servergetkey(ts, &A); + if (pcb->eap.es_server.ea_skey == NULL) { + /* Client's A value is bogus; terminate now */ + ppp_error("EAP: bogus A value from client"); + eap_send_failure(pcb); + } else { + eap_figure_next_state(pcb, 0); + } + break; + + case EAPSRP_CVALIDATOR: + if (pcb->eap.es_server.ea_state != eapSRP2) { + ppp_error("EAP: unexpected SRP Subtype 2 Response"); + eap_figure_next_state(pcb, 1); + break; + } + if (len < sizeof (u32_t) + SHA_DIGESTSIZE) { + ppp_error("EAP: M1 length %d < %d", len, + sizeof (u32_t) + SHA_DIGESTSIZE); + eap_figure_next_state(pcb, 1); + break; + } + GETLONG(pcb->eap.es_server.ea_keyflags, inp); + ts = (struct t_server *)pcb->eap.es_server.ea_session; + assert(ts != NULL); + if (t_serververify(ts, inp)) { + ppp_info("EAP: unable to validate client identity"); + eap_send_failure(pcb); + break; + } + eap_figure_next_state(pcb, 0); + break; + + case EAPSRP_ACK: + if (pcb->eap.es_server.ea_state != eapSRP3) { + ppp_error("EAP: unexpected SRP Subtype 3 Response"); + eap_send_failure(esp); + break; + } + pcb->eap.es_server.ea_type = EAPT_SRP; + eap_send_success(pcb, esp); + eap_figure_next_state(pcb, 0); + if (pcb->eap.es_rechallenge != 0) + TIMEOUT(eap_rechallenge, pcb, + pcb->eap.es_rechallenge); + if (pcb->eap.es_lwrechallenge != 0) + TIMEOUT(srp_lwrechallenge, pcb, + pcb->eap.es_lwrechallenge); + break; + + case EAPSRP_LWRECHALLENGE: + if (pcb->eap.es_server.ea_state != eapSRP4) { + ppp_info("EAP: unexpected SRP Subtype 4 Response"); + return; + } + if (len != SHA_DIGESTSIZE) { + ppp_error("EAP: bad Lightweight rechallenge " + "response"); + return; + } + SHA1Init(&ctxt); + vallen = id; + SHA1Update(&ctxt, &vallen, 1); + SHA1Update(&ctxt, pcb->eap.es_server.ea_skey, + SESSION_KEY_LEN); + SHA1Update(&ctxt, pcb->eap.es_challenge, pcb->eap.es_challen); + SHA1Update(&ctxt, pcb->eap.es_server.ea_peer, + pcb->eap.es_server.ea_peerlen); + SHA1Final(dig, &ctxt); + if (BCMP(dig, inp, SHA_DIGESTSIZE) != 0) { + ppp_error("EAP: failed Lightweight rechallenge"); + eap_send_failure(pcb); + break; + } + pcb->eap.es_server.ea_state = eapOpen; + if (pcb->eap.es_lwrechallenge != 0) + TIMEOUT(srp_lwrechallenge, esp, + pcb->eap.es_lwrechallenge); + break; + } + break; +#endif /* USE_SRP */ + + default: + /* This can't happen. */ + ppp_error("EAP: unknown Response type %d; ignored", typenum); + return; + } + + if (pcb->settings.eap_timeout_time > 0) { + UNTIMEOUT(eap_server_timeout, pcb); + } + + if (pcb->eap.es_server.ea_state != eapBadAuth && + pcb->eap.es_server.ea_state != eapOpen) { + pcb->eap.es_server.ea_id++; + eap_send_request(pcb); + } +} +#endif /* PPP_SERVER */ + +/* + * eap_success - Receive EAP Success message (client mode). + */ +static void eap_success(ppp_pcb *pcb, u_char *inp, int id, int len) { + LWIP_UNUSED_ARG(id); + + if (pcb->eap.es_client.ea_state != eapOpen && !eap_client_active(pcb)) { + ppp_dbglog("EAP unexpected success message in state %s (%d)", + eap_state_name(pcb->eap.es_client.ea_state), + pcb->eap.es_client.ea_state); + return; + } + + if (pcb->settings.eap_req_time > 0) { + UNTIMEOUT(eap_client_timeout, pcb); + } + + if (len > 0) { + /* This is odd. The spec doesn't allow for this. */ + PRINTMSG(inp, len); + } + + pcb->eap.es_client.ea_state = eapOpen; + auth_withpeer_success(pcb, PPP_EAP, 0); +} + +/* + * eap_failure - Receive EAP Failure message (client mode). + */ +static void eap_failure(ppp_pcb *pcb, u_char *inp, int id, int len) { + LWIP_UNUSED_ARG(id); + + if (!eap_client_active(pcb)) { + ppp_dbglog("EAP unexpected failure message in state %s (%d)", + eap_state_name(pcb->eap.es_client.ea_state), + pcb->eap.es_client.ea_state); + } + + if (pcb->settings.eap_req_time > 0) { + UNTIMEOUT(eap_client_timeout, pcb); + } + + if (len > 0) { + /* This is odd. The spec doesn't allow for this. */ + PRINTMSG(inp, len); + } + + pcb->eap.es_client.ea_state = eapBadAuth; + + ppp_error("EAP: peer reports authentication failure"); + auth_withpeer_fail(pcb, PPP_EAP); +} + +/* + * eap_input - Handle received EAP message. + */ +static void eap_input(ppp_pcb *pcb, u_char *inp, int inlen) { + u_char code, id; + int len; + + /* + * Parse header (code, id and length). If packet too short, + * drop it. + */ + if (inlen < EAP_HEADERLEN) { + ppp_error("EAP: packet too short: %d < %d", inlen, EAP_HEADERLEN); + return; + } + GETCHAR(code, inp); + GETCHAR(id, inp); + GETSHORT(len, inp); + if (len < EAP_HEADERLEN || len > inlen) { + ppp_error("EAP: packet has illegal length field %d (%d..%d)", len, + EAP_HEADERLEN, inlen); + return; + } + len -= EAP_HEADERLEN; + + /* Dispatch based on message code */ + switch (code) { + case EAP_REQUEST: + eap_request(pcb, inp, id, len); + break; + +#if PPP_SERVER + case EAP_RESPONSE: + eap_response(pcb, inp, id, len); + break; +#endif /* PPP_SERVER */ + + case EAP_SUCCESS: + eap_success(pcb, inp, id, len); + break; + + case EAP_FAILURE: + eap_failure(pcb, inp, id, len); + break; + + default: /* XXX Need code reject */ + /* Note: it's not legal to send EAP Nak here. */ + ppp_warn("EAP: unknown code %d received", code); + break; + } +} + +#if PRINTPKT_SUPPORT +/* + * eap_printpkt - print the contents of an EAP packet. + */ +static const char* const eap_codenames[] = { + "Request", "Response", "Success", "Failure" +}; + +static const char* const eap_typenames[] = { + "Identity", "Notification", "Nak", "MD5-Challenge", + "OTP", "Generic-Token", NULL, NULL, + "RSA", "DSS", "KEA", "KEA-Validate", + "TLS", "Defender", "Windows 2000", "Arcot", + "Cisco", "Nokia", "SRP" +}; + +static int eap_printpkt(const u_char *inp, int inlen, void (*printer) (void *, const char *, ...), void *arg) { + int code, id, len, rtype, vallen; + const u_char *pstart; + u32_t uval; + + if (inlen < EAP_HEADERLEN) + return (0); + pstart = inp; + GETCHAR(code, inp); + GETCHAR(id, inp); + GETSHORT(len, inp); + if (len < EAP_HEADERLEN || len > inlen) + return (0); + + if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(eap_codenames)) + printer(arg, " %s", eap_codenames[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= EAP_HEADERLEN; + switch (code) { + case EAP_REQUEST: + if (len < 1) { + printer(arg, " "); + break; + } + GETCHAR(rtype, inp); + len--; + if (rtype >= 1 && rtype <= (int)LWIP_ARRAYSIZE(eap_typenames)) + printer(arg, " %s", eap_typenames[rtype-1]); + else + printer(arg, " type=0x%x", rtype); + switch (rtype) { + case EAPT_IDENTITY: + case EAPT_NOTIFICATION: + if (len > 0) { + printer(arg, " "); + INCPTR(len, inp); + len = 0; + } else { + printer(arg, " "); + } + break; + + case EAPT_MD5CHAP: + if (len <= 0) + break; + GETCHAR(vallen, inp); + len--; + if (vallen > len) + goto truncated; + printer(arg, " ", vallen, inp); + INCPTR(vallen, inp); + len -= vallen; + if (len > 0) { + printer(arg, " "); + INCPTR(len, inp); + len = 0; + } else { + printer(arg, " "); + } + break; + + case EAPT_SRP: + if (len < 3) + goto truncated; + GETCHAR(vallen, inp); + len--; + printer(arg, "-%d", vallen); + switch (vallen) { + case EAPSRP_CHALLENGE: + GETCHAR(vallen, inp); + len--; + if (vallen >= len) + goto truncated; + if (vallen > 0) { + printer(arg, " "); + } else { + printer(arg, " "); + } + INCPTR(vallen, inp); + len -= vallen; + GETCHAR(vallen, inp); + len--; + if (vallen >= len) + goto truncated; + printer(arg, " ", vallen, inp); + INCPTR(vallen, inp); + len -= vallen; + GETCHAR(vallen, inp); + len--; + if (vallen > len) + goto truncated; + if (vallen == 0) { + printer(arg, " "); + } else { + printer(arg, " ", vallen, inp); + } + INCPTR(vallen, inp); + len -= vallen; + if (len == 0) { + printer(arg, " "); + } else { + printer(arg, " ", len, inp); + INCPTR(len, inp); + len = 0; + } + break; + + case EAPSRP_SKEY: + printer(arg, " ", len, inp); + INCPTR(len, inp); + len = 0; + break; + + case EAPSRP_SVALIDATOR: + if (len < (int)sizeof (u32_t)) + break; + GETLONG(uval, inp); + len -= sizeof (u32_t); + if (uval & SRPVAL_EBIT) { + printer(arg, " E"); + uval &= ~SRPVAL_EBIT; + } + if (uval != 0) { + printer(arg, " f<%X>", uval); + } + if ((vallen = len) > SHA_DIGESTSIZE) + vallen = SHA_DIGESTSIZE; + printer(arg, " ", len, inp, + len < SHA_DIGESTSIZE ? "?" : ""); + INCPTR(vallen, inp); + len -= vallen; + if (len > 0) { + printer(arg, " ", len, inp); + INCPTR(len, inp); + len = 0; + } + break; + + case EAPSRP_LWRECHALLENGE: + printer(arg, " ", len, inp); + INCPTR(len, inp); + len = 0; + break; + default: + break; + } + break; + default: + break; + } + break; + + case EAP_RESPONSE: + if (len < 1) + break; + GETCHAR(rtype, inp); + len--; + if (rtype >= 1 && rtype <= (int)LWIP_ARRAYSIZE(eap_typenames)) + printer(arg, " %s", eap_typenames[rtype-1]); + else + printer(arg, " type=0x%x", rtype); + switch (rtype) { + case EAPT_IDENTITY: + if (len > 0) { + printer(arg, " "); + INCPTR(len, inp); + len = 0; + } + break; + + case EAPT_NAK: + if (len <= 0) { + printer(arg, " "); + break; + } + GETCHAR(rtype, inp); + len--; + printer(arg, " = 1 && rtype < (int)LWIP_ARRAYSIZE(eap_typenames)) + printer(arg, " (%s)", eap_typenames[rtype-1]); + printer(arg, ">"); + break; + + case EAPT_MD5CHAP: + if (len <= 0) { + printer(arg, " "); + break; + } + GETCHAR(vallen, inp); + len--; + if (vallen > len) + goto truncated; + printer(arg, " ", vallen, inp); + INCPTR(vallen, inp); + len -= vallen; + if (len > 0) { + printer(arg, " "); + INCPTR(len, inp); + len = 0; + } else { + printer(arg, " "); + } + break; + + case EAPT_SRP: + if (len < 1) + goto truncated; + GETCHAR(vallen, inp); + len--; + printer(arg, "-%d", vallen); + switch (vallen) { + case EAPSRP_CKEY: + printer(arg, " ", len, inp); + INCPTR(len, inp); + len = 0; + break; + + case EAPSRP_CVALIDATOR: + if (len < (int)sizeof (u32_t)) + break; + GETLONG(uval, inp); + len -= sizeof (u32_t); + if (uval & SRPVAL_EBIT) { + printer(arg, " E"); + uval &= ~SRPVAL_EBIT; + } + if (uval != 0) { + printer(arg, " f<%X>", uval); + } + printer(arg, " ", len, inp, + len == SHA_DIGESTSIZE ? "" : "?"); + INCPTR(len, inp); + len = 0; + break; + + case EAPSRP_ACK: + break; + + case EAPSRP_LWRECHALLENGE: + printer(arg, " ", len, inp, + len == SHA_DIGESTSIZE ? "" : "?"); + if ((vallen = len) > SHA_DIGESTSIZE) + vallen = SHA_DIGESTSIZE; + INCPTR(vallen, inp); + len -= vallen; + break; + default: + break; + } + break; + default: + break; + } + break; + + case EAP_SUCCESS: /* No payload expected for these! */ + case EAP_FAILURE: + default: + break; + + truncated: + printer(arg, " "); + break; + } + + if (len > 8) + printer(arg, "%8B...", inp); + else if (len > 0) + printer(arg, "%.*B", len, inp); + INCPTR(len, inp); + + return (inp - pstart); +} +#endif /* PRINTPKT_SUPPORT */ + +#endif /* PPP_SUPPORT && EAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ecp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ecp.c index a22eda8b..4d84f609 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ecp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ecp.c @@ -1,191 +1,191 @@ -/* - * ecp.c - PPP Encryption Control Protocol. - * - * Copyright (c) 2002 Google, Inc. - * 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * Derived from ccp.c, which is: - * - * Copyright (c) 1994-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && ECP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/ecp.h" - -#if PPP_OPTIONS -static option_t ecp_option_list[] = { - { "noecp", o_bool, &ecp_protent.enabled_flag, - "Disable ECP negotiation" }, - { "-ecp", o_bool, &ecp_protent.enabled_flag, - "Disable ECP negotiation", OPT_ALIAS }, - - { NULL } -}; -#endif /* PPP_OPTIONS */ - -/* - * Protocol entry points from main code. - */ -static void ecp_init (int unit); -/* -static void ecp_open (int unit); -static void ecp_close (int unit, char *); -static void ecp_lowerup (int unit); -static void ecp_lowerdown (int); -static void ecp_input (int unit, u_char *pkt, int len); -static void ecp_protrej (int unit); -*/ -#if PRINTPKT_SUPPORT -static int ecp_printpkt (const u_char *pkt, int len, - void (*printer) (void *, char *, ...), - void *arg); -#endif /* PRINTPKT_SUPPORT */ -/* -static void ecp_datainput (int unit, u_char *pkt, int len); -*/ - -const struct protent ecp_protent = { - PPP_ECP, - ecp_init, - NULL, /* ecp_input, */ - NULL, /* ecp_protrej, */ - NULL, /* ecp_lowerup, */ - NULL, /* ecp_lowerdown, */ - NULL, /* ecp_open, */ - NULL, /* ecp_close, */ -#if PRINTPKT_SUPPORT - ecp_printpkt, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - NULL, /* ecp_datainput, */ -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "ECP", - "Encrypted", -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - ecp_option_list, - NULL, -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - NULL, - NULL -#endif /* DEMAND_SUPPORT */ -}; - -fsm ecp_fsm[NUM_PPP]; -ecp_options ecp_wantoptions[NUM_PPP]; /* what to request the peer to use */ -ecp_options ecp_gotoptions[NUM_PPP]; /* what the peer agreed to do */ -ecp_options ecp_allowoptions[NUM_PPP]; /* what we'll agree to do */ -ecp_options ecp_hisoptions[NUM_PPP]; /* what we agreed to do */ - -static const fsm_callbacks ecp_callbacks = { - NULL, /* ecp_resetci, */ - NULL, /* ecp_cilen, */ - NULL, /* ecp_addci, */ - NULL, /* ecp_ackci, */ - NULL, /* ecp_nakci, */ - NULL, /* ecp_rejci, */ - NULL, /* ecp_reqci, */ - NULL, /* ecp_up, */ - NULL, /* ecp_down, */ - NULL, - NULL, - NULL, - NULL, - NULL, /* ecp_extcode, */ - "ECP" -}; - -/* - * ecp_init - initialize ECP. - */ -static void -ecp_init(unit) - int unit; -{ - fsm *f = &ecp_fsm[unit]; - - f->unit = unit; - f->protocol = PPP_ECP; - f->callbacks = &ecp_callbacks; - fsm_init(f); - -#if 0 /* Not necessary, everything is cleared in ppp_new() */ - memset(&ecp_wantoptions[unit], 0, sizeof(ecp_options)); - memset(&ecp_gotoptions[unit], 0, sizeof(ecp_options)); - memset(&ecp_allowoptions[unit], 0, sizeof(ecp_options)); - memset(&ecp_hisoptions[unit], 0, sizeof(ecp_options)); -#endif /* 0 */ - -} - - -#if PRINTPKT_SUPPORT -static int -ecp_printpkt(p, plen, printer, arg) - const u_char *p; - int plen; - void (*printer) (void *, char *, ...); - void *arg; -{ - return 0; -} -#endif /* PRINTPKT_SUPPORT */ - -#endif /* PPP_SUPPORT && ECP_SUPPORT */ +/* + * ecp.c - PPP Encryption Control Protocol. + * + * Copyright (c) 2002 Google, Inc. + * 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Derived from ccp.c, which is: + * + * Copyright (c) 1994-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && ECP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/ecp.h" + +#if PPP_OPTIONS +static option_t ecp_option_list[] = { + { "noecp", o_bool, &ecp_protent.enabled_flag, + "Disable ECP negotiation" }, + { "-ecp", o_bool, &ecp_protent.enabled_flag, + "Disable ECP negotiation", OPT_ALIAS }, + + { NULL } +}; +#endif /* PPP_OPTIONS */ + +/* + * Protocol entry points from main code. + */ +static void ecp_init (int unit); +/* +static void ecp_open (int unit); +static void ecp_close (int unit, char *); +static void ecp_lowerup (int unit); +static void ecp_lowerdown (int); +static void ecp_input (int unit, u_char *pkt, int len); +static void ecp_protrej (int unit); +*/ +#if PRINTPKT_SUPPORT +static int ecp_printpkt (const u_char *pkt, int len, + void (*printer) (void *, char *, ...), + void *arg); +#endif /* PRINTPKT_SUPPORT */ +/* +static void ecp_datainput (int unit, u_char *pkt, int len); +*/ + +const struct protent ecp_protent = { + PPP_ECP, + ecp_init, + NULL, /* ecp_input, */ + NULL, /* ecp_protrej, */ + NULL, /* ecp_lowerup, */ + NULL, /* ecp_lowerdown, */ + NULL, /* ecp_open, */ + NULL, /* ecp_close, */ +#if PRINTPKT_SUPPORT + ecp_printpkt, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + NULL, /* ecp_datainput, */ +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "ECP", + "Encrypted", +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + ecp_option_list, + NULL, +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + NULL, + NULL +#endif /* DEMAND_SUPPORT */ +}; + +fsm ecp_fsm[NUM_PPP]; +ecp_options ecp_wantoptions[NUM_PPP]; /* what to request the peer to use */ +ecp_options ecp_gotoptions[NUM_PPP]; /* what the peer agreed to do */ +ecp_options ecp_allowoptions[NUM_PPP]; /* what we'll agree to do */ +ecp_options ecp_hisoptions[NUM_PPP]; /* what we agreed to do */ + +static const fsm_callbacks ecp_callbacks = { + NULL, /* ecp_resetci, */ + NULL, /* ecp_cilen, */ + NULL, /* ecp_addci, */ + NULL, /* ecp_ackci, */ + NULL, /* ecp_nakci, */ + NULL, /* ecp_rejci, */ + NULL, /* ecp_reqci, */ + NULL, /* ecp_up, */ + NULL, /* ecp_down, */ + NULL, + NULL, + NULL, + NULL, + NULL, /* ecp_extcode, */ + "ECP" +}; + +/* + * ecp_init - initialize ECP. + */ +static void +ecp_init(unit) + int unit; +{ + fsm *f = &ecp_fsm[unit]; + + f->unit = unit; + f->protocol = PPP_ECP; + f->callbacks = &ecp_callbacks; + fsm_init(f); + +#if 0 /* Not necessary, everything is cleared in ppp_new() */ + memset(&ecp_wantoptions[unit], 0, sizeof(ecp_options)); + memset(&ecp_gotoptions[unit], 0, sizeof(ecp_options)); + memset(&ecp_allowoptions[unit], 0, sizeof(ecp_options)); + memset(&ecp_hisoptions[unit], 0, sizeof(ecp_options)); +#endif /* 0 */ + +} + + +#if PRINTPKT_SUPPORT +static int +ecp_printpkt(p, plen, printer, arg) + const u_char *p; + int plen; + void (*printer) (void *, char *, ...); + void *arg; +{ + return 0; +} +#endif /* PRINTPKT_SUPPORT */ + +#endif /* PPP_SUPPORT && ECP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eui64.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eui64.c index 15af8555..01493bc1 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eui64.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/eui64.c @@ -1,56 +1,56 @@ -/* - * eui64.c - EUI64 routines for IPv6CP. - * - * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Tommi Komulainen - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: eui64.c,v 1.6 2002/12/04 23:03:32 paulus Exp $ - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/eui64.h" - -/* - * eui64_ntoa - Make an ascii representation of an interface identifier - */ -char *eui64_ntoa(eui64_t e) { - static char buf[20]; - - sprintf(buf, "%02x%02x:%02x%02x:%02x%02x:%02x%02x", - e.e8[0], e.e8[1], e.e8[2], e.e8[3], - e.e8[4], e.e8[5], e.e8[6], e.e8[7]); - return buf; -} - -#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ +/* + * eui64.c - EUI64 routines for IPv6CP. + * + * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Tommi Komulainen + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: eui64.c,v 1.6 2002/12/04 23:03:32 paulus Exp $ + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/eui64.h" + +/* + * eui64_ntoa - Make an ascii representation of an interface identifier + */ +char *eui64_ntoa(eui64_t e) { + static char buf[20]; + + sprintf(buf, "%02x%02x:%02x%02x:%02x%02x:%02x%02x", + e.e8[0], e.e8[1], e.e8[2], e.e8[3], + e.e8[4], e.e8[5], e.e8[6], e.e8[7]); + return buf; +} + +#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/fsm.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/fsm.c index 9d32e7c2..b1f08aff 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/fsm.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/fsm.c @@ -1,799 +1,799 @@ -/* - * fsm.c - {Link, IP} Control Protocol Finite State Machine. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -/* - * @todo: - * Randomize fsm id on link/init. - * Deal with variable outgoing MTU. - */ - -#if 0 /* UNUSED */ -#include -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" - -static void fsm_timeout (void *); -static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len); -static void fsm_rconfack(fsm *f, int id, u_char *inp, int len); -static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len); -static void fsm_rtermreq(fsm *f, int id, u_char *p, int len); -static void fsm_rtermack(fsm *f); -static void fsm_rcoderej(fsm *f, u_char *inp, int len); -static void fsm_sconfreq(fsm *f, int retransmit); - -#define PROTO_NAME(f) ((f)->callbacks->proto_name) - -/* - * fsm_init - Initialize fsm. - * - * Initialize fsm state. - */ -void fsm_init(fsm *f) { - ppp_pcb *pcb = f->pcb; - f->state = PPP_FSM_INITIAL; - f->flags = 0; - f->id = 0; /* XXX Start with random id? */ - f->maxnakloops = pcb->settings.fsm_max_nak_loops; - f->term_reason_len = 0; -} - - -/* - * fsm_lowerup - The lower layer is up. - */ -void fsm_lowerup(fsm *f) { - switch( f->state ){ - case PPP_FSM_INITIAL: - f->state = PPP_FSM_CLOSED; - break; - - case PPP_FSM_STARTING: - if( f->flags & OPT_SILENT ) - f->state = PPP_FSM_STOPPED; - else { - /* Send an initial configure-request */ - fsm_sconfreq(f, 0); - f->state = PPP_FSM_REQSENT; - } - break; - - default: - FSMDEBUG(("%s: Up event in state %d!", PROTO_NAME(f), f->state)); - /* no break */ - } -} - - -/* - * fsm_lowerdown - The lower layer is down. - * - * Cancel all timeouts and inform upper layers. - */ -void fsm_lowerdown(fsm *f) { - switch( f->state ){ - case PPP_FSM_CLOSED: - f->state = PPP_FSM_INITIAL; - break; - - case PPP_FSM_STOPPED: - f->state = PPP_FSM_STARTING; - if( f->callbacks->starting ) - (*f->callbacks->starting)(f); - break; - - case PPP_FSM_CLOSING: - f->state = PPP_FSM_INITIAL; - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - break; - - case PPP_FSM_STOPPING: - case PPP_FSM_REQSENT: - case PPP_FSM_ACKRCVD: - case PPP_FSM_ACKSENT: - f->state = PPP_FSM_STARTING; - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - break; - - case PPP_FSM_OPENED: - if( f->callbacks->down ) - (*f->callbacks->down)(f); - f->state = PPP_FSM_STARTING; - break; - - default: - FSMDEBUG(("%s: Down event in state %d!", PROTO_NAME(f), f->state)); - /* no break */ - } -} - - -/* - * fsm_open - Link is allowed to come up. - */ -void fsm_open(fsm *f) { - switch( f->state ){ - case PPP_FSM_INITIAL: - f->state = PPP_FSM_STARTING; - if( f->callbacks->starting ) - (*f->callbacks->starting)(f); - break; - - case PPP_FSM_CLOSED: - if( f->flags & OPT_SILENT ) - f->state = PPP_FSM_STOPPED; - else { - /* Send an initial configure-request */ - fsm_sconfreq(f, 0); - f->state = PPP_FSM_REQSENT; - } - break; - - case PPP_FSM_CLOSING: - f->state = PPP_FSM_STOPPING; - /* fall through */ - /* no break */ - case PPP_FSM_STOPPED: - case PPP_FSM_OPENED: - if( f->flags & OPT_RESTART ){ - fsm_lowerdown(f); - fsm_lowerup(f); - } - break; - default: - break; - } -} - -/* - * terminate_layer - Start process of shutting down the FSM - * - * Cancel any timeout running, notify upper layers we're done, and - * send a terminate-request message as configured. - */ -static void terminate_layer(fsm *f, int nextstate) { - ppp_pcb *pcb = f->pcb; - - if( f->state != PPP_FSM_OPENED ) - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - else if( f->callbacks->down ) - (*f->callbacks->down)(f); /* Inform upper layers we're down */ - - /* Init restart counter and send Terminate-Request */ - f->retransmits = pcb->settings.fsm_max_term_transmits; - fsm_sdata(f, TERMREQ, f->reqid = ++f->id, - (const u_char *) f->term_reason, f->term_reason_len); - - if (f->retransmits == 0) { - /* - * User asked for no terminate requests at all; just close it. - * We've already fired off one Terminate-Request just to be nice - * to the peer, but we're not going to wait for a reply. - */ - f->state = nextstate == PPP_FSM_CLOSING ? PPP_FSM_CLOSED : PPP_FSM_STOPPED; - if( f->callbacks->finished ) - (*f->callbacks->finished)(f); - return; - } - - TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); - --f->retransmits; - - f->state = nextstate; -} - -/* - * fsm_close - Start closing connection. - * - * Cancel timeouts and either initiate close or possibly go directly to - * the PPP_FSM_CLOSED state. - */ -void fsm_close(fsm *f, const char *reason) { - f->term_reason = reason; - f->term_reason_len = (reason == NULL? 0: (u8_t)LWIP_MIN(strlen(reason), 0xFF) ); - switch( f->state ){ - case PPP_FSM_STARTING: - f->state = PPP_FSM_INITIAL; - break; - case PPP_FSM_STOPPED: - f->state = PPP_FSM_CLOSED; - break; - case PPP_FSM_STOPPING: - f->state = PPP_FSM_CLOSING; - break; - - case PPP_FSM_REQSENT: - case PPP_FSM_ACKRCVD: - case PPP_FSM_ACKSENT: - case PPP_FSM_OPENED: - terminate_layer(f, PPP_FSM_CLOSING); - break; - default: - break; - } -} - - -/* - * fsm_timeout - Timeout expired. - */ -static void fsm_timeout(void *arg) { - fsm *f = (fsm *) arg; - ppp_pcb *pcb = f->pcb; - - switch (f->state) { - case PPP_FSM_CLOSING: - case PPP_FSM_STOPPING: - if( f->retransmits <= 0 ){ - /* - * We've waited for an ack long enough. Peer probably heard us. - */ - f->state = (f->state == PPP_FSM_CLOSING)? PPP_FSM_CLOSED: PPP_FSM_STOPPED; - if( f->callbacks->finished ) - (*f->callbacks->finished)(f); - } else { - /* Send Terminate-Request */ - fsm_sdata(f, TERMREQ, f->reqid = ++f->id, - (const u_char *) f->term_reason, f->term_reason_len); - TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); - --f->retransmits; - } - break; - - case PPP_FSM_REQSENT: - case PPP_FSM_ACKRCVD: - case PPP_FSM_ACKSENT: - if (f->retransmits <= 0) { - ppp_warn("%s: timeout sending Config-Requests", PROTO_NAME(f)); - f->state = PPP_FSM_STOPPED; - if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished ) - (*f->callbacks->finished)(f); - - } else { - /* Retransmit the configure-request */ - if (f->callbacks->retransmit) - (*f->callbacks->retransmit)(f); - fsm_sconfreq(f, 1); /* Re-send Configure-Request */ - if( f->state == PPP_FSM_ACKRCVD ) - f->state = PPP_FSM_REQSENT; - } - break; - - default: - FSMDEBUG(("%s: Timeout event in state %d!", PROTO_NAME(f), f->state)); - /* no break */ - } -} - - -/* - * fsm_input - Input packet. - */ -void fsm_input(fsm *f, u_char *inpacket, int l) { - u_char *inp; - u_char code, id; - int len; - - /* - * Parse header (code, id and length). - * If packet too short, drop it. - */ - inp = inpacket; - if (l < HEADERLEN) { - FSMDEBUG(("fsm_input(%x): Rcvd short header.", f->protocol)); - return; - } - GETCHAR(code, inp); - GETCHAR(id, inp); - GETSHORT(len, inp); - if (len < HEADERLEN) { - FSMDEBUG(("fsm_input(%x): Rcvd illegal length.", f->protocol)); - return; - } - if (len > l) { - FSMDEBUG(("fsm_input(%x): Rcvd short packet.", f->protocol)); - return; - } - len -= HEADERLEN; /* subtract header length */ - - if( f->state == PPP_FSM_INITIAL || f->state == PPP_FSM_STARTING ){ - FSMDEBUG(("fsm_input(%x): Rcvd packet in state %d.", - f->protocol, f->state)); - return; - } - - /* - * Action depends on code. - */ - switch (code) { - case CONFREQ: - fsm_rconfreq(f, id, inp, len); - break; - - case CONFACK: - fsm_rconfack(f, id, inp, len); - break; - - case CONFNAK: - case CONFREJ: - fsm_rconfnakrej(f, code, id, inp, len); - break; - - case TERMREQ: - fsm_rtermreq(f, id, inp, len); - break; - - case TERMACK: - fsm_rtermack(f); - break; - - case CODEREJ: - fsm_rcoderej(f, inp, len); - break; - - default: - if( !f->callbacks->extcode - || !(*f->callbacks->extcode)(f, code, id, inp, len) ) - fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN); - break; - } -} - - -/* - * fsm_rconfreq - Receive Configure-Request. - */ -static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len) { - int code, reject_if_disagree; - - switch( f->state ){ - case PPP_FSM_CLOSED: - /* Go away, we're closed */ - fsm_sdata(f, TERMACK, id, NULL, 0); - return; - case PPP_FSM_CLOSING: - case PPP_FSM_STOPPING: - return; - - case PPP_FSM_OPENED: - /* Go down and restart negotiation */ - if( f->callbacks->down ) - (*f->callbacks->down)(f); /* Inform upper layers */ - fsm_sconfreq(f, 0); /* Send initial Configure-Request */ - f->state = PPP_FSM_REQSENT; - break; - - case PPP_FSM_STOPPED: - /* Negotiation started by our peer */ - fsm_sconfreq(f, 0); /* Send initial Configure-Request */ - f->state = PPP_FSM_REQSENT; - break; - default: - break; - } - - /* - * Pass the requested configuration options - * to protocol-specific code for checking. - */ - if (f->callbacks->reqci){ /* Check CI */ - reject_if_disagree = (f->nakloops >= f->maxnakloops); - code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree); - } else if (len) - code = CONFREJ; /* Reject all CI */ - else - code = CONFACK; - - /* send the Ack, Nak or Rej to the peer */ - fsm_sdata(f, code, id, inp, len); - - if (code == CONFACK) { - if (f->state == PPP_FSM_ACKRCVD) { - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - f->state = PPP_FSM_OPENED; - if (f->callbacks->up) - (*f->callbacks->up)(f); /* Inform upper layers */ - } else - f->state = PPP_FSM_ACKSENT; - f->nakloops = 0; - - } else { - /* we sent CONFACK or CONFREJ */ - if (f->state != PPP_FSM_ACKRCVD) - f->state = PPP_FSM_REQSENT; - if( code == CONFNAK ) - ++f->nakloops; - } -} - - -/* - * fsm_rconfack - Receive Configure-Ack. - */ -static void fsm_rconfack(fsm *f, int id, u_char *inp, int len) { - ppp_pcb *pcb = f->pcb; - - if (id != f->reqid || f->seen_ack) /* Expected id? */ - return; /* Nope, toss... */ - if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len): - (len == 0)) ){ - /* Ack is bad - ignore it */ - ppp_error("Received bad configure-ack: %P", inp, len); - return; - } - f->seen_ack = 1; - f->rnakloops = 0; - - switch (f->state) { - case PPP_FSM_CLOSED: - case PPP_FSM_STOPPED: - fsm_sdata(f, TERMACK, id, NULL, 0); - break; - - case PPP_FSM_REQSENT: - f->state = PPP_FSM_ACKRCVD; - f->retransmits = pcb->settings.fsm_max_conf_req_transmits; - break; - - case PPP_FSM_ACKRCVD: - /* Huh? an extra valid Ack? oh well... */ - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - fsm_sconfreq(f, 0); - f->state = PPP_FSM_REQSENT; - break; - - case PPP_FSM_ACKSENT: - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - f->state = PPP_FSM_OPENED; - f->retransmits = pcb->settings.fsm_max_conf_req_transmits; - if (f->callbacks->up) - (*f->callbacks->up)(f); /* Inform upper layers */ - break; - - case PPP_FSM_OPENED: - /* Go down and restart negotiation */ - if (f->callbacks->down) - (*f->callbacks->down)(f); /* Inform upper layers */ - fsm_sconfreq(f, 0); /* Send initial Configure-Request */ - f->state = PPP_FSM_REQSENT; - break; - default: - break; - } -} - - -/* - * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject. - */ -static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len) { - int ret; - int treat_as_reject; - - if (id != f->reqid || f->seen_ack) /* Expected id? */ - return; /* Nope, toss... */ - - if (code == CONFNAK) { - ++f->rnakloops; - treat_as_reject = (f->rnakloops >= f->maxnakloops); - if (f->callbacks->nakci == NULL - || !(ret = f->callbacks->nakci(f, inp, len, treat_as_reject))) { - ppp_error("Received bad configure-nak: %P", inp, len); - return; - } - } else { - f->rnakloops = 0; - if (f->callbacks->rejci == NULL - || !(ret = f->callbacks->rejci(f, inp, len))) { - ppp_error("Received bad configure-rej: %P", inp, len); - return; - } - } - - f->seen_ack = 1; - - switch (f->state) { - case PPP_FSM_CLOSED: - case PPP_FSM_STOPPED: - fsm_sdata(f, TERMACK, id, NULL, 0); - break; - - case PPP_FSM_REQSENT: - case PPP_FSM_ACKSENT: - /* They didn't agree to what we wanted - try another request */ - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - if (ret < 0) - f->state = PPP_FSM_STOPPED; /* kludge for stopping CCP */ - else - fsm_sconfreq(f, 0); /* Send Configure-Request */ - break; - - case PPP_FSM_ACKRCVD: - /* Got a Nak/reject when we had already had an Ack?? oh well... */ - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - fsm_sconfreq(f, 0); - f->state = PPP_FSM_REQSENT; - break; - - case PPP_FSM_OPENED: - /* Go down and restart negotiation */ - if (f->callbacks->down) - (*f->callbacks->down)(f); /* Inform upper layers */ - fsm_sconfreq(f, 0); /* Send initial Configure-Request */ - f->state = PPP_FSM_REQSENT; - break; - default: - break; - } -} - - -/* - * fsm_rtermreq - Receive Terminate-Req. - */ -static void fsm_rtermreq(fsm *f, int id, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - - switch (f->state) { - case PPP_FSM_ACKRCVD: - case PPP_FSM_ACKSENT: - f->state = PPP_FSM_REQSENT; /* Start over but keep trying */ - break; - - case PPP_FSM_OPENED: - if (len > 0) { - ppp_info("%s terminated by peer (%0.*v)", PROTO_NAME(f), len, p); - } else - ppp_info("%s terminated by peer", PROTO_NAME(f)); - f->retransmits = 0; - f->state = PPP_FSM_STOPPING; - if (f->callbacks->down) - (*f->callbacks->down)(f); /* Inform upper layers */ - TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); - break; - default: - break; - } - - fsm_sdata(f, TERMACK, id, NULL, 0); -} - - -/* - * fsm_rtermack - Receive Terminate-Ack. - */ -static void fsm_rtermack(fsm *f) { - switch (f->state) { - case PPP_FSM_CLOSING: - UNTIMEOUT(fsm_timeout, f); - f->state = PPP_FSM_CLOSED; - if( f->callbacks->finished ) - (*f->callbacks->finished)(f); - break; - case PPP_FSM_STOPPING: - UNTIMEOUT(fsm_timeout, f); - f->state = PPP_FSM_STOPPED; - if( f->callbacks->finished ) - (*f->callbacks->finished)(f); - break; - - case PPP_FSM_ACKRCVD: - f->state = PPP_FSM_REQSENT; - break; - - case PPP_FSM_OPENED: - if (f->callbacks->down) - (*f->callbacks->down)(f); /* Inform upper layers */ - fsm_sconfreq(f, 0); - f->state = PPP_FSM_REQSENT; - break; - default: - break; - } -} - - -/* - * fsm_rcoderej - Receive an Code-Reject. - */ -static void fsm_rcoderej(fsm *f, u_char *inp, int len) { - u_char code, id; - - if (len < HEADERLEN) { - FSMDEBUG(("fsm_rcoderej: Rcvd short Code-Reject packet!")); - return; - } - GETCHAR(code, inp); - GETCHAR(id, inp); - ppp_warn("%s: Rcvd Code-Reject for code %d, id %d", PROTO_NAME(f), code, id); - - if( f->state == PPP_FSM_ACKRCVD ) - f->state = PPP_FSM_REQSENT; -} - - -/* - * fsm_protreject - Peer doesn't speak this protocol. - * - * Treat this as a catastrophic error (RXJ-). - */ -void fsm_protreject(fsm *f) { - switch( f->state ){ - case PPP_FSM_CLOSING: - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - /* fall through */ - /* no break */ - case PPP_FSM_CLOSED: - f->state = PPP_FSM_CLOSED; - if( f->callbacks->finished ) - (*f->callbacks->finished)(f); - break; - - case PPP_FSM_STOPPING: - case PPP_FSM_REQSENT: - case PPP_FSM_ACKRCVD: - case PPP_FSM_ACKSENT: - UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ - /* fall through */ - /* no break */ - case PPP_FSM_STOPPED: - f->state = PPP_FSM_STOPPED; - if( f->callbacks->finished ) - (*f->callbacks->finished)(f); - break; - - case PPP_FSM_OPENED: - terminate_layer(f, PPP_FSM_STOPPING); - break; - - default: - FSMDEBUG(("%s: Protocol-reject event in state %d!", - PROTO_NAME(f), f->state)); - /* no break */ - } -} - - -/* - * fsm_sconfreq - Send a Configure-Request. - */ -static void fsm_sconfreq(fsm *f, int retransmit) { - ppp_pcb *pcb = f->pcb; - struct pbuf *p; - u_char *outp; - int cilen; - - if( f->state != PPP_FSM_REQSENT && f->state != PPP_FSM_ACKRCVD && f->state != PPP_FSM_ACKSENT ){ - /* Not currently negotiating - reset options */ - if( f->callbacks->resetci ) - (*f->callbacks->resetci)(f); - f->nakloops = 0; - f->rnakloops = 0; - } - - if( !retransmit ){ - /* New request - reset retransmission counter, use new ID */ - f->retransmits = pcb->settings.fsm_max_conf_req_transmits; - f->reqid = ++f->id; - } - - f->seen_ack = 0; - - /* - * Make up the request packet - */ - if( f->callbacks->cilen && f->callbacks->addci ){ - cilen = (*f->callbacks->cilen)(f); - if( cilen > pcb->peer_mru - HEADERLEN ) - cilen = pcb->peer_mru - HEADERLEN; - } else - cilen = 0; - - p = pbuf_alloc(PBUF_RAW, (u16_t)(cilen + HEADERLEN + PPP_HDRLEN), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - /* send the request to our peer */ - outp = (u_char*)p->payload; - MAKEHEADER(outp, f->protocol); - PUTCHAR(CONFREQ, outp); - PUTCHAR(f->reqid, outp); - PUTSHORT(cilen + HEADERLEN, outp); - if (cilen != 0) { - (*f->callbacks->addci)(f, outp, &cilen); - LWIP_ASSERT("cilen == p->len - HEADERLEN - PPP_HDRLEN", cilen == p->len - HEADERLEN - PPP_HDRLEN); - } - - ppp_write(pcb, p); - - /* start the retransmit timer */ - --f->retransmits; - TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); -} - - -/* - * fsm_sdata - Send some data. - * - * Used for all packets sent to our peer by this module. - */ -void fsm_sdata(fsm *f, u_char code, u_char id, const u_char *data, int datalen) { - ppp_pcb *pcb = f->pcb; - struct pbuf *p; - u_char *outp; - int outlen; - - /* Adjust length to be smaller than MTU */ - if (datalen > pcb->peer_mru - HEADERLEN) - datalen = pcb->peer_mru - HEADERLEN; - outlen = datalen + HEADERLEN; - - p = pbuf_alloc(PBUF_RAW, (u16_t)(outlen + PPP_HDRLEN), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - if (datalen) /* && data != outp + PPP_HDRLEN + HEADERLEN) -- was only for fsm_sconfreq() */ - MEMCPY(outp + PPP_HDRLEN + HEADERLEN, data, datalen); - MAKEHEADER(outp, f->protocol); - PUTCHAR(code, outp); - PUTCHAR(id, outp); - PUTSHORT(outlen, outp); - ppp_write(pcb, p); -} - -#endif /* PPP_SUPPORT */ +/* + * fsm.c - {Link, IP} Control Protocol Finite State Machine. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +/* + * @todo: + * Randomize fsm id on link/init. + * Deal with variable outgoing MTU. + */ + +#if 0 /* UNUSED */ +#include +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" + +static void fsm_timeout (void *); +static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len); +static void fsm_rconfack(fsm *f, int id, u_char *inp, int len); +static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len); +static void fsm_rtermreq(fsm *f, int id, u_char *p, int len); +static void fsm_rtermack(fsm *f); +static void fsm_rcoderej(fsm *f, u_char *inp, int len); +static void fsm_sconfreq(fsm *f, int retransmit); + +#define PROTO_NAME(f) ((f)->callbacks->proto_name) + +/* + * fsm_init - Initialize fsm. + * + * Initialize fsm state. + */ +void fsm_init(fsm *f) { + ppp_pcb *pcb = f->pcb; + f->state = PPP_FSM_INITIAL; + f->flags = 0; + f->id = 0; /* XXX Start with random id? */ + f->maxnakloops = pcb->settings.fsm_max_nak_loops; + f->term_reason_len = 0; +} + + +/* + * fsm_lowerup - The lower layer is up. + */ +void fsm_lowerup(fsm *f) { + switch( f->state ){ + case PPP_FSM_INITIAL: + f->state = PPP_FSM_CLOSED; + break; + + case PPP_FSM_STARTING: + if( f->flags & OPT_SILENT ) + f->state = PPP_FSM_STOPPED; + else { + /* Send an initial configure-request */ + fsm_sconfreq(f, 0); + f->state = PPP_FSM_REQSENT; + } + break; + + default: + FSMDEBUG(("%s: Up event in state %d!", PROTO_NAME(f), f->state)); + /* no break */ + } +} + + +/* + * fsm_lowerdown - The lower layer is down. + * + * Cancel all timeouts and inform upper layers. + */ +void fsm_lowerdown(fsm *f) { + switch( f->state ){ + case PPP_FSM_CLOSED: + f->state = PPP_FSM_INITIAL; + break; + + case PPP_FSM_STOPPED: + f->state = PPP_FSM_STARTING; + if( f->callbacks->starting ) + (*f->callbacks->starting)(f); + break; + + case PPP_FSM_CLOSING: + f->state = PPP_FSM_INITIAL; + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + break; + + case PPP_FSM_STOPPING: + case PPP_FSM_REQSENT: + case PPP_FSM_ACKRCVD: + case PPP_FSM_ACKSENT: + f->state = PPP_FSM_STARTING; + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + break; + + case PPP_FSM_OPENED: + if( f->callbacks->down ) + (*f->callbacks->down)(f); + f->state = PPP_FSM_STARTING; + break; + + default: + FSMDEBUG(("%s: Down event in state %d!", PROTO_NAME(f), f->state)); + /* no break */ + } +} + + +/* + * fsm_open - Link is allowed to come up. + */ +void fsm_open(fsm *f) { + switch( f->state ){ + case PPP_FSM_INITIAL: + f->state = PPP_FSM_STARTING; + if( f->callbacks->starting ) + (*f->callbacks->starting)(f); + break; + + case PPP_FSM_CLOSED: + if( f->flags & OPT_SILENT ) + f->state = PPP_FSM_STOPPED; + else { + /* Send an initial configure-request */ + fsm_sconfreq(f, 0); + f->state = PPP_FSM_REQSENT; + } + break; + + case PPP_FSM_CLOSING: + f->state = PPP_FSM_STOPPING; + /* fall through */ + /* no break */ + case PPP_FSM_STOPPED: + case PPP_FSM_OPENED: + if( f->flags & OPT_RESTART ){ + fsm_lowerdown(f); + fsm_lowerup(f); + } + break; + default: + break; + } +} + +/* + * terminate_layer - Start process of shutting down the FSM + * + * Cancel any timeout running, notify upper layers we're done, and + * send a terminate-request message as configured. + */ +static void terminate_layer(fsm *f, int nextstate) { + ppp_pcb *pcb = f->pcb; + + if( f->state != PPP_FSM_OPENED ) + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + else if( f->callbacks->down ) + (*f->callbacks->down)(f); /* Inform upper layers we're down */ + + /* Init restart counter and send Terminate-Request */ + f->retransmits = pcb->settings.fsm_max_term_transmits; + fsm_sdata(f, TERMREQ, f->reqid = ++f->id, + (const u_char *) f->term_reason, f->term_reason_len); + + if (f->retransmits == 0) { + /* + * User asked for no terminate requests at all; just close it. + * We've already fired off one Terminate-Request just to be nice + * to the peer, but we're not going to wait for a reply. + */ + f->state = nextstate == PPP_FSM_CLOSING ? PPP_FSM_CLOSED : PPP_FSM_STOPPED; + if( f->callbacks->finished ) + (*f->callbacks->finished)(f); + return; + } + + TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); + --f->retransmits; + + f->state = nextstate; +} + +/* + * fsm_close - Start closing connection. + * + * Cancel timeouts and either initiate close or possibly go directly to + * the PPP_FSM_CLOSED state. + */ +void fsm_close(fsm *f, const char *reason) { + f->term_reason = reason; + f->term_reason_len = (reason == NULL? 0: (u8_t)LWIP_MIN(strlen(reason), 0xFF) ); + switch( f->state ){ + case PPP_FSM_STARTING: + f->state = PPP_FSM_INITIAL; + break; + case PPP_FSM_STOPPED: + f->state = PPP_FSM_CLOSED; + break; + case PPP_FSM_STOPPING: + f->state = PPP_FSM_CLOSING; + break; + + case PPP_FSM_REQSENT: + case PPP_FSM_ACKRCVD: + case PPP_FSM_ACKSENT: + case PPP_FSM_OPENED: + terminate_layer(f, PPP_FSM_CLOSING); + break; + default: + break; + } +} + + +/* + * fsm_timeout - Timeout expired. + */ +static void fsm_timeout(void *arg) { + fsm *f = (fsm *) arg; + ppp_pcb *pcb = f->pcb; + + switch (f->state) { + case PPP_FSM_CLOSING: + case PPP_FSM_STOPPING: + if( f->retransmits <= 0 ){ + /* + * We've waited for an ack long enough. Peer probably heard us. + */ + f->state = (f->state == PPP_FSM_CLOSING)? PPP_FSM_CLOSED: PPP_FSM_STOPPED; + if( f->callbacks->finished ) + (*f->callbacks->finished)(f); + } else { + /* Send Terminate-Request */ + fsm_sdata(f, TERMREQ, f->reqid = ++f->id, + (const u_char *) f->term_reason, f->term_reason_len); + TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); + --f->retransmits; + } + break; + + case PPP_FSM_REQSENT: + case PPP_FSM_ACKRCVD: + case PPP_FSM_ACKSENT: + if (f->retransmits <= 0) { + ppp_warn("%s: timeout sending Config-Requests", PROTO_NAME(f)); + f->state = PPP_FSM_STOPPED; + if( (f->flags & OPT_PASSIVE) == 0 && f->callbacks->finished ) + (*f->callbacks->finished)(f); + + } else { + /* Retransmit the configure-request */ + if (f->callbacks->retransmit) + (*f->callbacks->retransmit)(f); + fsm_sconfreq(f, 1); /* Re-send Configure-Request */ + if( f->state == PPP_FSM_ACKRCVD ) + f->state = PPP_FSM_REQSENT; + } + break; + + default: + FSMDEBUG(("%s: Timeout event in state %d!", PROTO_NAME(f), f->state)); + /* no break */ + } +} + + +/* + * fsm_input - Input packet. + */ +void fsm_input(fsm *f, u_char *inpacket, int l) { + u_char *inp; + u_char code, id; + int len; + + /* + * Parse header (code, id and length). + * If packet too short, drop it. + */ + inp = inpacket; + if (l < HEADERLEN) { + FSMDEBUG(("fsm_input(%x): Rcvd short header.", f->protocol)); + return; + } + GETCHAR(code, inp); + GETCHAR(id, inp); + GETSHORT(len, inp); + if (len < HEADERLEN) { + FSMDEBUG(("fsm_input(%x): Rcvd illegal length.", f->protocol)); + return; + } + if (len > l) { + FSMDEBUG(("fsm_input(%x): Rcvd short packet.", f->protocol)); + return; + } + len -= HEADERLEN; /* subtract header length */ + + if( f->state == PPP_FSM_INITIAL || f->state == PPP_FSM_STARTING ){ + FSMDEBUG(("fsm_input(%x): Rcvd packet in state %d.", + f->protocol, f->state)); + return; + } + + /* + * Action depends on code. + */ + switch (code) { + case CONFREQ: + fsm_rconfreq(f, id, inp, len); + break; + + case CONFACK: + fsm_rconfack(f, id, inp, len); + break; + + case CONFNAK: + case CONFREJ: + fsm_rconfnakrej(f, code, id, inp, len); + break; + + case TERMREQ: + fsm_rtermreq(f, id, inp, len); + break; + + case TERMACK: + fsm_rtermack(f); + break; + + case CODEREJ: + fsm_rcoderej(f, inp, len); + break; + + default: + if( !f->callbacks->extcode + || !(*f->callbacks->extcode)(f, code, id, inp, len) ) + fsm_sdata(f, CODEREJ, ++f->id, inpacket, len + HEADERLEN); + break; + } +} + + +/* + * fsm_rconfreq - Receive Configure-Request. + */ +static void fsm_rconfreq(fsm *f, u_char id, u_char *inp, int len) { + int code, reject_if_disagree; + + switch( f->state ){ + case PPP_FSM_CLOSED: + /* Go away, we're closed */ + fsm_sdata(f, TERMACK, id, NULL, 0); + return; + case PPP_FSM_CLOSING: + case PPP_FSM_STOPPING: + return; + + case PPP_FSM_OPENED: + /* Go down and restart negotiation */ + if( f->callbacks->down ) + (*f->callbacks->down)(f); /* Inform upper layers */ + fsm_sconfreq(f, 0); /* Send initial Configure-Request */ + f->state = PPP_FSM_REQSENT; + break; + + case PPP_FSM_STOPPED: + /* Negotiation started by our peer */ + fsm_sconfreq(f, 0); /* Send initial Configure-Request */ + f->state = PPP_FSM_REQSENT; + break; + default: + break; + } + + /* + * Pass the requested configuration options + * to protocol-specific code for checking. + */ + if (f->callbacks->reqci){ /* Check CI */ + reject_if_disagree = (f->nakloops >= f->maxnakloops); + code = (*f->callbacks->reqci)(f, inp, &len, reject_if_disagree); + } else if (len) + code = CONFREJ; /* Reject all CI */ + else + code = CONFACK; + + /* send the Ack, Nak or Rej to the peer */ + fsm_sdata(f, code, id, inp, len); + + if (code == CONFACK) { + if (f->state == PPP_FSM_ACKRCVD) { + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + f->state = PPP_FSM_OPENED; + if (f->callbacks->up) + (*f->callbacks->up)(f); /* Inform upper layers */ + } else + f->state = PPP_FSM_ACKSENT; + f->nakloops = 0; + + } else { + /* we sent CONFACK or CONFREJ */ + if (f->state != PPP_FSM_ACKRCVD) + f->state = PPP_FSM_REQSENT; + if( code == CONFNAK ) + ++f->nakloops; + } +} + + +/* + * fsm_rconfack - Receive Configure-Ack. + */ +static void fsm_rconfack(fsm *f, int id, u_char *inp, int len) { + ppp_pcb *pcb = f->pcb; + + if (id != f->reqid || f->seen_ack) /* Expected id? */ + return; /* Nope, toss... */ + if( !(f->callbacks->ackci? (*f->callbacks->ackci)(f, inp, len): + (len == 0)) ){ + /* Ack is bad - ignore it */ + ppp_error("Received bad configure-ack: %P", inp, len); + return; + } + f->seen_ack = 1; + f->rnakloops = 0; + + switch (f->state) { + case PPP_FSM_CLOSED: + case PPP_FSM_STOPPED: + fsm_sdata(f, TERMACK, id, NULL, 0); + break; + + case PPP_FSM_REQSENT: + f->state = PPP_FSM_ACKRCVD; + f->retransmits = pcb->settings.fsm_max_conf_req_transmits; + break; + + case PPP_FSM_ACKRCVD: + /* Huh? an extra valid Ack? oh well... */ + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + fsm_sconfreq(f, 0); + f->state = PPP_FSM_REQSENT; + break; + + case PPP_FSM_ACKSENT: + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + f->state = PPP_FSM_OPENED; + f->retransmits = pcb->settings.fsm_max_conf_req_transmits; + if (f->callbacks->up) + (*f->callbacks->up)(f); /* Inform upper layers */ + break; + + case PPP_FSM_OPENED: + /* Go down and restart negotiation */ + if (f->callbacks->down) + (*f->callbacks->down)(f); /* Inform upper layers */ + fsm_sconfreq(f, 0); /* Send initial Configure-Request */ + f->state = PPP_FSM_REQSENT; + break; + default: + break; + } +} + + +/* + * fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject. + */ +static void fsm_rconfnakrej(fsm *f, int code, int id, u_char *inp, int len) { + int ret; + int treat_as_reject; + + if (id != f->reqid || f->seen_ack) /* Expected id? */ + return; /* Nope, toss... */ + + if (code == CONFNAK) { + ++f->rnakloops; + treat_as_reject = (f->rnakloops >= f->maxnakloops); + if (f->callbacks->nakci == NULL + || !(ret = f->callbacks->nakci(f, inp, len, treat_as_reject))) { + ppp_error("Received bad configure-nak: %P", inp, len); + return; + } + } else { + f->rnakloops = 0; + if (f->callbacks->rejci == NULL + || !(ret = f->callbacks->rejci(f, inp, len))) { + ppp_error("Received bad configure-rej: %P", inp, len); + return; + } + } + + f->seen_ack = 1; + + switch (f->state) { + case PPP_FSM_CLOSED: + case PPP_FSM_STOPPED: + fsm_sdata(f, TERMACK, id, NULL, 0); + break; + + case PPP_FSM_REQSENT: + case PPP_FSM_ACKSENT: + /* They didn't agree to what we wanted - try another request */ + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + if (ret < 0) + f->state = PPP_FSM_STOPPED; /* kludge for stopping CCP */ + else + fsm_sconfreq(f, 0); /* Send Configure-Request */ + break; + + case PPP_FSM_ACKRCVD: + /* Got a Nak/reject when we had already had an Ack?? oh well... */ + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + fsm_sconfreq(f, 0); + f->state = PPP_FSM_REQSENT; + break; + + case PPP_FSM_OPENED: + /* Go down and restart negotiation */ + if (f->callbacks->down) + (*f->callbacks->down)(f); /* Inform upper layers */ + fsm_sconfreq(f, 0); /* Send initial Configure-Request */ + f->state = PPP_FSM_REQSENT; + break; + default: + break; + } +} + + +/* + * fsm_rtermreq - Receive Terminate-Req. + */ +static void fsm_rtermreq(fsm *f, int id, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + + switch (f->state) { + case PPP_FSM_ACKRCVD: + case PPP_FSM_ACKSENT: + f->state = PPP_FSM_REQSENT; /* Start over but keep trying */ + break; + + case PPP_FSM_OPENED: + if (len > 0) { + ppp_info("%s terminated by peer (%0.*v)", PROTO_NAME(f), len, p); + } else + ppp_info("%s terminated by peer", PROTO_NAME(f)); + f->retransmits = 0; + f->state = PPP_FSM_STOPPING; + if (f->callbacks->down) + (*f->callbacks->down)(f); /* Inform upper layers */ + TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); + break; + default: + break; + } + + fsm_sdata(f, TERMACK, id, NULL, 0); +} + + +/* + * fsm_rtermack - Receive Terminate-Ack. + */ +static void fsm_rtermack(fsm *f) { + switch (f->state) { + case PPP_FSM_CLOSING: + UNTIMEOUT(fsm_timeout, f); + f->state = PPP_FSM_CLOSED; + if( f->callbacks->finished ) + (*f->callbacks->finished)(f); + break; + case PPP_FSM_STOPPING: + UNTIMEOUT(fsm_timeout, f); + f->state = PPP_FSM_STOPPED; + if( f->callbacks->finished ) + (*f->callbacks->finished)(f); + break; + + case PPP_FSM_ACKRCVD: + f->state = PPP_FSM_REQSENT; + break; + + case PPP_FSM_OPENED: + if (f->callbacks->down) + (*f->callbacks->down)(f); /* Inform upper layers */ + fsm_sconfreq(f, 0); + f->state = PPP_FSM_REQSENT; + break; + default: + break; + } +} + + +/* + * fsm_rcoderej - Receive an Code-Reject. + */ +static void fsm_rcoderej(fsm *f, u_char *inp, int len) { + u_char code, id; + + if (len < HEADERLEN) { + FSMDEBUG(("fsm_rcoderej: Rcvd short Code-Reject packet!")); + return; + } + GETCHAR(code, inp); + GETCHAR(id, inp); + ppp_warn("%s: Rcvd Code-Reject for code %d, id %d", PROTO_NAME(f), code, id); + + if( f->state == PPP_FSM_ACKRCVD ) + f->state = PPP_FSM_REQSENT; +} + + +/* + * fsm_protreject - Peer doesn't speak this protocol. + * + * Treat this as a catastrophic error (RXJ-). + */ +void fsm_protreject(fsm *f) { + switch( f->state ){ + case PPP_FSM_CLOSING: + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + /* fall through */ + /* no break */ + case PPP_FSM_CLOSED: + f->state = PPP_FSM_CLOSED; + if( f->callbacks->finished ) + (*f->callbacks->finished)(f); + break; + + case PPP_FSM_STOPPING: + case PPP_FSM_REQSENT: + case PPP_FSM_ACKRCVD: + case PPP_FSM_ACKSENT: + UNTIMEOUT(fsm_timeout, f); /* Cancel timeout */ + /* fall through */ + /* no break */ + case PPP_FSM_STOPPED: + f->state = PPP_FSM_STOPPED; + if( f->callbacks->finished ) + (*f->callbacks->finished)(f); + break; + + case PPP_FSM_OPENED: + terminate_layer(f, PPP_FSM_STOPPING); + break; + + default: + FSMDEBUG(("%s: Protocol-reject event in state %d!", + PROTO_NAME(f), f->state)); + /* no break */ + } +} + + +/* + * fsm_sconfreq - Send a Configure-Request. + */ +static void fsm_sconfreq(fsm *f, int retransmit) { + ppp_pcb *pcb = f->pcb; + struct pbuf *p; + u_char *outp; + int cilen; + + if( f->state != PPP_FSM_REQSENT && f->state != PPP_FSM_ACKRCVD && f->state != PPP_FSM_ACKSENT ){ + /* Not currently negotiating - reset options */ + if( f->callbacks->resetci ) + (*f->callbacks->resetci)(f); + f->nakloops = 0; + f->rnakloops = 0; + } + + if( !retransmit ){ + /* New request - reset retransmission counter, use new ID */ + f->retransmits = pcb->settings.fsm_max_conf_req_transmits; + f->reqid = ++f->id; + } + + f->seen_ack = 0; + + /* + * Make up the request packet + */ + if( f->callbacks->cilen && f->callbacks->addci ){ + cilen = (*f->callbacks->cilen)(f); + if( cilen > pcb->peer_mru - HEADERLEN ) + cilen = pcb->peer_mru - HEADERLEN; + } else + cilen = 0; + + p = pbuf_alloc(PBUF_RAW, (u16_t)(cilen + HEADERLEN + PPP_HDRLEN), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + /* send the request to our peer */ + outp = (u_char*)p->payload; + MAKEHEADER(outp, f->protocol); + PUTCHAR(CONFREQ, outp); + PUTCHAR(f->reqid, outp); + PUTSHORT(cilen + HEADERLEN, outp); + if (cilen != 0) { + (*f->callbacks->addci)(f, outp, &cilen); + LWIP_ASSERT("cilen == p->len - HEADERLEN - PPP_HDRLEN", cilen == p->len - HEADERLEN - PPP_HDRLEN); + } + + ppp_write(pcb, p); + + /* start the retransmit timer */ + --f->retransmits; + TIMEOUT(fsm_timeout, f, pcb->settings.fsm_timeout_time); +} + + +/* + * fsm_sdata - Send some data. + * + * Used for all packets sent to our peer by this module. + */ +void fsm_sdata(fsm *f, u_char code, u_char id, const u_char *data, int datalen) { + ppp_pcb *pcb = f->pcb; + struct pbuf *p; + u_char *outp; + int outlen; + + /* Adjust length to be smaller than MTU */ + if (datalen > pcb->peer_mru - HEADERLEN) + datalen = pcb->peer_mru - HEADERLEN; + outlen = datalen + HEADERLEN; + + p = pbuf_alloc(PBUF_RAW, (u16_t)(outlen + PPP_HDRLEN), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + if (datalen) /* && data != outp + PPP_HDRLEN + HEADERLEN) -- was only for fsm_sconfreq() */ + MEMCPY(outp + PPP_HDRLEN + HEADERLEN, data, datalen); + MAKEHEADER(outp, f->protocol); + PUTCHAR(code, outp); + PUTCHAR(id, outp); + PUTSHORT(outlen, outp); + ppp_write(pcb, p); +} + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipcp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipcp.c index 3fba3205..b7c766eb 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipcp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipcp.c @@ -1,2418 +1,2418 @@ -/* - * ipcp.c - PPP IP Control Protocol. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPP_IPV4_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -/* - * @todo: - */ - -#if 0 /* UNUSED */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/ipcp.h" - -#if 0 /* UNUSED */ -/* global vars */ -u32_t netmask = 0; /* IP netmask to set on interface */ -#endif /* UNUSED */ - -#if 0 /* UNUSED */ -bool disable_defaultip = 0; /* Don't use hostname for default IP adrs */ -#endif /* UNUSED */ - -#if 0 /* moved to ppp_settings */ -bool noremoteip = 0; /* Let him have no IP address */ -#endif /* moved to ppp_setting */ - -#if 0 /* UNUSED */ -/* Hook for a plugin to know when IP protocol has come up */ -void (*ip_up_hook) (void) = NULL; - -/* Hook for a plugin to know when IP protocol has come down */ -void (*ip_down_hook) (void) = NULL; - -/* Hook for a plugin to choose the remote IP address */ -void (*ip_choose_hook) (u32_t *) = NULL; -#endif /* UNUSED */ - -#if PPP_NOTIFY -/* Notifiers for when IPCP goes up and down */ -struct notifier *ip_up_notifier = NULL; -struct notifier *ip_down_notifier = NULL; -#endif /* PPP_NOTIFY */ - -/* local vars */ -#if 0 /* moved to ppp_pcb */ -static int default_route_set[NUM_PPP]; /* Have set up a default route */ -static int proxy_arp_set[NUM_PPP]; /* Have created proxy arp entry */ -static int ipcp_is_up; /* have called np_up() */ -static int ipcp_is_open; /* haven't called np_finished() */ -static bool ask_for_local; /* request our address from peer */ -#endif /* moved to ppp_pcb */ -#if 0 /* UNUSED */ -static char vj_value[8]; /* string form of vj option value */ -static char netmask_str[20]; /* string form of netmask value */ -#endif /* UNUSED */ - -/* - * Callbacks for fsm code. (CI = Configuration Information) - */ -static void ipcp_resetci(fsm *f); /* Reset our CI */ -static int ipcp_cilen(fsm *f); /* Return length of our CI */ -static void ipcp_addci(fsm *f, u_char *ucp, int *lenp); /* Add our CI */ -static int ipcp_ackci(fsm *f, u_char *p, int len); /* Peer ack'd our CI */ -static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject);/* Peer nak'd our CI */ -static int ipcp_rejci(fsm *f, u_char *p, int len); /* Peer rej'd our CI */ -static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree); /* Rcv CI */ -static void ipcp_up(fsm *f); /* We're UP */ -static void ipcp_down(fsm *f); /* We're DOWN */ -static void ipcp_finished(fsm *f); /* Don't need lower layer */ - -static const fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */ - ipcp_resetci, /* Reset our Configuration Information */ - ipcp_cilen, /* Length of our Configuration Information */ - ipcp_addci, /* Add our Configuration Information */ - ipcp_ackci, /* ACK our Configuration Information */ - ipcp_nakci, /* NAK our Configuration Information */ - ipcp_rejci, /* Reject our Configuration Information */ - ipcp_reqci, /* Request peer's Configuration Information */ - ipcp_up, /* Called when fsm reaches OPENED state */ - ipcp_down, /* Called when fsm leaves OPENED state */ - NULL, /* Called when we want the lower layer up */ - ipcp_finished, /* Called when we want the lower layer down */ - NULL, /* Called when Protocol-Reject received */ - NULL, /* Retransmission is necessary */ - NULL, /* Called to handle protocol-specific codes */ - "IPCP" /* String name of protocol */ -}; - -/* - * Command-line options. - */ -#if PPP_OPTIONS -static int setvjslots (char **); -static int setdnsaddr (char **); -static int setwinsaddr (char **); -static int setnetmask (char **); -int setipaddr (char *, char **, int); - -static void printipaddr (option_t *, void (*)(void *, char *,...),void *); - -static option_t ipcp_option_list[] = { - { "noip", o_bool, &ipcp_protent.enabled_flag, - "Disable IP and IPCP" }, - { "-ip", o_bool, &ipcp_protent.enabled_flag, - "Disable IP and IPCP", OPT_ALIAS }, - - { "novj", o_bool, &ipcp_wantoptions[0].neg_vj, - "Disable VJ compression", OPT_A2CLR, &ipcp_allowoptions[0].neg_vj }, - { "-vj", o_bool, &ipcp_wantoptions[0].neg_vj, - "Disable VJ compression", OPT_ALIAS | OPT_A2CLR, - &ipcp_allowoptions[0].neg_vj }, - - { "novjccomp", o_bool, &ipcp_wantoptions[0].cflag, - "Disable VJ connection-ID compression", OPT_A2CLR, - &ipcp_allowoptions[0].cflag }, - { "-vjccomp", o_bool, &ipcp_wantoptions[0].cflag, - "Disable VJ connection-ID compression", OPT_ALIAS | OPT_A2CLR, - &ipcp_allowoptions[0].cflag }, - - { "vj-max-slots", o_special, (void *)setvjslots, - "Set maximum VJ header slots", - OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, vj_value }, - - { "ipcp-accept-local", o_bool, &ipcp_wantoptions[0].accept_local, - "Accept peer's address for us", 1 }, - { "ipcp-accept-remote", o_bool, &ipcp_wantoptions[0].accept_remote, - "Accept peer's address for it", 1 }, - - { "ipparam", o_string, &ipparam, - "Set ip script parameter", OPT_PRIO }, - - { "noipdefault", o_bool, &disable_defaultip, - "Don't use name for default IP adrs", 1 }, - - { "ms-dns", 1, (void *)setdnsaddr, - "DNS address for the peer's use" }, - { "ms-wins", 1, (void *)setwinsaddr, - "Nameserver for SMB over TCP/IP for peer" }, - - { "ipcp-restart", o_int, &ipcp_fsm[0].timeouttime, - "Set timeout for IPCP", OPT_PRIO }, - { "ipcp-max-terminate", o_int, &ipcp_fsm[0].maxtermtransmits, - "Set max #xmits for term-reqs", OPT_PRIO }, - { "ipcp-max-configure", o_int, &ipcp_fsm[0].maxconfreqtransmits, - "Set max #xmits for conf-reqs", OPT_PRIO }, - { "ipcp-max-failure", o_int, &ipcp_fsm[0].maxnakloops, - "Set max #conf-naks for IPCP", OPT_PRIO }, - - { "defaultroute", o_bool, &ipcp_wantoptions[0].default_route, - "Add default route", OPT_ENABLE|1, &ipcp_allowoptions[0].default_route }, - { "nodefaultroute", o_bool, &ipcp_allowoptions[0].default_route, - "disable defaultroute option", OPT_A2CLR, - &ipcp_wantoptions[0].default_route }, - { "-defaultroute", o_bool, &ipcp_allowoptions[0].default_route, - "disable defaultroute option", OPT_ALIAS | OPT_A2CLR, - &ipcp_wantoptions[0].default_route }, - - { "replacedefaultroute", o_bool, - &ipcp_wantoptions[0].replace_default_route, - "Replace default route", 1 - }, - { "noreplacedefaultroute", o_bool, - &ipcp_allowoptions[0].replace_default_route, - "Never replace default route", OPT_A2COPY, - &ipcp_wantoptions[0].replace_default_route }, - { "proxyarp", o_bool, &ipcp_wantoptions[0].proxy_arp, - "Add proxy ARP entry", OPT_ENABLE|1, &ipcp_allowoptions[0].proxy_arp }, - { "noproxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp, - "disable proxyarp option", OPT_A2CLR, - &ipcp_wantoptions[0].proxy_arp }, - { "-proxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp, - "disable proxyarp option", OPT_ALIAS | OPT_A2CLR, - &ipcp_wantoptions[0].proxy_arp }, - - { "usepeerdns", o_bool, &usepeerdns, - "Ask peer for DNS address(es)", 1 }, - - { "netmask", o_special, (void *)setnetmask, - "set netmask", OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, netmask_str }, - - { "ipcp-no-addresses", o_bool, &ipcp_wantoptions[0].old_addrs, - "Disable old-style IP-Addresses usage", OPT_A2CLR, - &ipcp_allowoptions[0].old_addrs }, - { "ipcp-no-address", o_bool, &ipcp_wantoptions[0].neg_addr, - "Disable IP-Address usage", OPT_A2CLR, - &ipcp_allowoptions[0].neg_addr }, - - { "noremoteip", o_bool, &noremoteip, - "Allow peer to have no IP address", 1 }, - - { "nosendip", o_bool, &ipcp_wantoptions[0].neg_addr, - "Don't send our IP address to peer", OPT_A2CLR, - &ipcp_wantoptions[0].old_addrs}, - - { "IP addresses", o_wild, (void *) &setipaddr, - "set local and remote IP addresses", - OPT_NOARG | OPT_A2PRINTER, (void *) &printipaddr }, - - { NULL } -}; -#endif /* PPP_OPTIONS */ - -/* - * Protocol entry points from main code. - */ -static void ipcp_init(ppp_pcb *pcb); -static void ipcp_open(ppp_pcb *pcb); -static void ipcp_close(ppp_pcb *pcb, const char *reason); -static void ipcp_lowerup(ppp_pcb *pcb); -static void ipcp_lowerdown(ppp_pcb *pcb); -static void ipcp_input(ppp_pcb *pcb, u_char *p, int len); -static void ipcp_protrej(ppp_pcb *pcb); -#if PRINTPKT_SUPPORT -static int ipcp_printpkt(const u_char *p, int plen, - void (*printer) (void *, const char *, ...), void *arg); -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS -static void ip_check_options (void); -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT -static int ip_demand_conf (int); -static int ip_active_pkt (u_char *, int); -#endif /* DEMAND_SUPPORT */ -#if 0 /* UNUSED */ -static void create_resolv (u32_t, u32_t); -#endif /* UNUSED */ - -const struct protent ipcp_protent = { - PPP_IPCP, - ipcp_init, - ipcp_input, - ipcp_protrej, - ipcp_lowerup, - ipcp_lowerdown, - ipcp_open, - ipcp_close, -#if PRINTPKT_SUPPORT - ipcp_printpkt, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - NULL, -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "IPCP", - "IP", -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - ipcp_option_list, - ip_check_options, -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - ip_demand_conf, - ip_active_pkt -#endif /* DEMAND_SUPPORT */ -}; - -static void ipcp_clear_addrs(ppp_pcb *pcb, u32_t ouraddr, u32_t hisaddr, u8_t replacedefaultroute); - -/* - * Lengths of configuration options. - */ -#define CILEN_VOID 2 -#define CILEN_COMPRESS 4 /* min length for compression protocol opt. */ -#define CILEN_VJ 6 /* length for RFC1332 Van-Jacobson opt. */ -#define CILEN_ADDR 6 /* new-style single address option */ -#define CILEN_ADDRS 10 /* old-style dual address option */ - - -#define CODENAME(x) ((x) == CONFACK ? "ACK" : \ - (x) == CONFNAK ? "NAK" : "REJ") - -#if 0 /* UNUSED, already defined by lwIP */ -/* - * Make a string representation of a network IP address. - */ -char * -ip_ntoa(ipaddr) -u32_t ipaddr; -{ - static char b[64]; - - slprintf(b, sizeof(b), "%I", ipaddr); - return b; -} -#endif /* UNUSED, already defined by lwIP */ - -/* - * Option parsing. - */ -#if PPP_OPTIONS -/* - * setvjslots - set maximum number of connection slots for VJ compression - */ -static int -setvjslots(argv) - char **argv; -{ - int value; - - if (!int_option(*argv, &value)) - return 0; - - if (value < 2 || value > 16) { - option_error("vj-max-slots value must be between 2 and 16"); - return 0; - } - ipcp_wantoptions [0].maxslotindex = - ipcp_allowoptions[0].maxslotindex = value - 1; - slprintf(vj_value, sizeof(vj_value), "%d", value); - return 1; -} - -/* - * setdnsaddr - set the dns address(es) - */ -static int -setdnsaddr(argv) - char **argv; -{ - u32_t dns; - struct hostent *hp; - - dns = inet_addr(*argv); - if (dns == (u32_t) -1) { - if ((hp = gethostbyname(*argv)) == NULL) { - option_error("invalid address parameter '%s' for ms-dns option", - *argv); - return 0; - } - dns = *(u32_t *)hp->h_addr; - } - - /* We take the last 2 values given, the 2nd-last as the primary - and the last as the secondary. If only one is given it - becomes both primary and secondary. */ - if (ipcp_allowoptions[0].dnsaddr[1] == 0) - ipcp_allowoptions[0].dnsaddr[0] = dns; - else - ipcp_allowoptions[0].dnsaddr[0] = ipcp_allowoptions[0].dnsaddr[1]; - - /* always set the secondary address value. */ - ipcp_allowoptions[0].dnsaddr[1] = dns; - - return (1); -} - -/* - * setwinsaddr - set the wins address(es) - * This is primrarly used with the Samba package under UNIX or for pointing - * the caller to the existing WINS server on a Windows NT platform. - */ -static int -setwinsaddr(argv) - char **argv; -{ - u32_t wins; - struct hostent *hp; - - wins = inet_addr(*argv); - if (wins == (u32_t) -1) { - if ((hp = gethostbyname(*argv)) == NULL) { - option_error("invalid address parameter '%s' for ms-wins option", - *argv); - return 0; - } - wins = *(u32_t *)hp->h_addr; - } - - /* We take the last 2 values given, the 2nd-last as the primary - and the last as the secondary. If only one is given it - becomes both primary and secondary. */ - if (ipcp_allowoptions[0].winsaddr[1] == 0) - ipcp_allowoptions[0].winsaddr[0] = wins; - else - ipcp_allowoptions[0].winsaddr[0] = ipcp_allowoptions[0].winsaddr[1]; - - /* always set the secondary address value. */ - ipcp_allowoptions[0].winsaddr[1] = wins; - - return (1); -} - -/* - * setipaddr - Set the IP address - * If doit is 0, the call is to check whether this option is - * potentially an IP address specification. - * Not static so that plugins can call it to set the addresses - */ -int -setipaddr(arg, argv, doit) - char *arg; - char **argv; - int doit; -{ - struct hostent *hp; - char *colon; - u32_t local, remote; - ipcp_options *wo = &ipcp_wantoptions[0]; - static int prio_local = 0, prio_remote = 0; - - /* - * IP address pair separated by ":". - */ - if ((colon = strchr(arg, ':')) == NULL) - return 0; - if (!doit) - return 1; - - /* - * If colon first character, then no local addr. - */ - if (colon != arg && option_priority >= prio_local) { - *colon = '\0'; - if ((local = inet_addr(arg)) == (u32_t) -1) { - if ((hp = gethostbyname(arg)) == NULL) { - option_error("unknown host: %s", arg); - return 0; - } - local = *(u32_t *)hp->h_addr; - } - if (bad_ip_adrs(local)) { - option_error("bad local IP address %s", ip_ntoa(local)); - return 0; - } - if (local != 0) - wo->ouraddr = local; - *colon = ':'; - prio_local = option_priority; - } - - /* - * If colon last character, then no remote addr. - */ - if (*++colon != '\0' && option_priority >= prio_remote) { - if ((remote = inet_addr(colon)) == (u32_t) -1) { - if ((hp = gethostbyname(colon)) == NULL) { - option_error("unknown host: %s", colon); - return 0; - } - remote = *(u32_t *)hp->h_addr; - if (remote_name[0] == 0) - strlcpy(remote_name, colon, sizeof(remote_name)); - } - if (bad_ip_adrs(remote)) { - option_error("bad remote IP address %s", ip_ntoa(remote)); - return 0; - } - if (remote != 0) - wo->hisaddr = remote; - prio_remote = option_priority; - } - - return 1; -} - -static void -printipaddr(opt, printer, arg) - option_t *opt; - void (*printer) (void *, char *, ...); - void *arg; -{ - ipcp_options *wo = &ipcp_wantoptions[0]; - - if (wo->ouraddr != 0) - printer(arg, "%I", wo->ouraddr); - printer(arg, ":"); - if (wo->hisaddr != 0) - printer(arg, "%I", wo->hisaddr); -} - -/* - * setnetmask - set the netmask to be used on the interface. - */ -static int -setnetmask(argv) - char **argv; -{ - u32_t mask; - int n; - char *p; - - /* - * Unfortunately, if we use inet_addr, we can't tell whether - * a result of all 1s is an error or a valid 255.255.255.255. - */ - p = *argv; - n = parse_dotted_ip(p, &mask); - - mask = lwip_htonl(mask); - - if (n == 0 || p[n] != 0 || (netmask & ~mask) != 0) { - option_error("invalid netmask value '%s'", *argv); - return 0; - } - - netmask = mask; - slprintf(netmask_str, sizeof(netmask_str), "%I", mask); - - return (1); -} - -int -parse_dotted_ip(p, vp) - char *p; - u32_t *vp; -{ - int n; - u32_t v, b; - char *endp, *p0 = p; - - v = 0; - for (n = 3;; --n) { - b = strtoul(p, &endp, 0); - if (endp == p) - return 0; - if (b > 255) { - if (n < 3) - return 0; - /* accept e.g. 0xffffff00 */ - *vp = b; - return endp - p0; - } - v |= b << (n * 8); - p = endp; - if (n == 0) - break; - if (*p != '.') - return 0; - ++p; - } - *vp = v; - return p - p0; -} -#endif /* PPP_OPTIONS */ - -/* - * ipcp_init - Initialize IPCP. - */ -static void ipcp_init(ppp_pcb *pcb) { - fsm *f = &pcb->ipcp_fsm; - - ipcp_options *wo = &pcb->ipcp_wantoptions; - ipcp_options *ao = &pcb->ipcp_allowoptions; - - f->pcb = pcb; - f->protocol = PPP_IPCP; - f->callbacks = &ipcp_callbacks; - fsm_init(f); - - /* - * Some 3G modems use repeated IPCP NAKs as a way of stalling - * until they can contact a server on the network, so we increase - * the default number of NAKs we accept before we start treating - * them as rejects. - */ - f->maxnakloops = 100; - -#if 0 /* Not necessary, everything is cleared in ppp_new() */ - memset(wo, 0, sizeof(*wo)); - memset(ao, 0, sizeof(*ao)); -#endif /* 0 */ - - wo->neg_addr = wo->old_addrs = 1; -#if VJ_SUPPORT - wo->neg_vj = 1; - wo->vj_protocol = IPCP_VJ_COMP; - wo->maxslotindex = MAX_STATES - 1; /* really max index */ - wo->cflag = 1; -#endif /* VJ_SUPPORT */ - -#if 0 /* UNUSED */ - /* wanting default route by default */ - wo->default_route = 1; -#endif /* UNUSED */ - - ao->neg_addr = ao->old_addrs = 1; -#if VJ_SUPPORT - /* max slots and slot-id compression are currently hardwired in */ - /* ppp_if.c to 16 and 1, this needs to be changed (among other */ - /* things) gmc */ - - ao->neg_vj = 1; - ao->maxslotindex = MAX_STATES - 1; - ao->cflag = 1; -#endif /* #if VJ_SUPPORT */ - -#if 0 /* UNUSED */ - /* - * XXX These control whether the user may use the proxyarp - * and defaultroute options. - */ - ao->proxy_arp = 1; - ao->default_route = 1; -#endif /* UNUSED */ -} - - -/* - * ipcp_open - IPCP is allowed to come up. - */ -static void ipcp_open(ppp_pcb *pcb) { - fsm *f = &pcb->ipcp_fsm; - fsm_open(f); - pcb->ipcp_is_open = 1; -} - - -/* - * ipcp_close - Take IPCP down. - */ -static void ipcp_close(ppp_pcb *pcb, const char *reason) { - fsm *f = &pcb->ipcp_fsm; - fsm_close(f, reason); -} - - -/* - * ipcp_lowerup - The lower layer is up. - */ -static void ipcp_lowerup(ppp_pcb *pcb) { - fsm *f = &pcb->ipcp_fsm; - fsm_lowerup(f); -} - - -/* - * ipcp_lowerdown - The lower layer is down. - */ -static void ipcp_lowerdown(ppp_pcb *pcb) { - fsm *f = &pcb->ipcp_fsm; - fsm_lowerdown(f); -} - - -/* - * ipcp_input - Input IPCP packet. - */ -static void ipcp_input(ppp_pcb *pcb, u_char *p, int len) { - fsm *f = &pcb->ipcp_fsm; - fsm_input(f, p, len); -} - - -/* - * ipcp_protrej - A Protocol-Reject was received for IPCP. - * - * Pretend the lower layer went down, so we shut up. - */ -static void ipcp_protrej(ppp_pcb *pcb) { - fsm *f = &pcb->ipcp_fsm; - fsm_lowerdown(f); -} - - -/* - * ipcp_resetci - Reset our CI. - * Called by fsm_sconfreq, Send Configure Request. - */ -static void ipcp_resetci(fsm *f) { - ppp_pcb *pcb = f->pcb; - ipcp_options *wo = &pcb->ipcp_wantoptions; - ipcp_options *go = &pcb->ipcp_gotoptions; - ipcp_options *ao = &pcb->ipcp_allowoptions; - - wo->req_addr = (wo->neg_addr || wo->old_addrs) && - (ao->neg_addr || ao->old_addrs); - if (wo->ouraddr == 0) - wo->accept_local = 1; - if (wo->hisaddr == 0) - wo->accept_remote = 1; -#if LWIP_DNS - wo->req_dns1 = wo->req_dns2 = pcb->settings.usepeerdns; /* Request DNS addresses from the peer */ -#endif /* LWIP_DNS */ - *go = *wo; - if (!pcb->ask_for_local) - go->ouraddr = 0; -#if 0 /* UNUSED */ - if (ip_choose_hook) { - ip_choose_hook(&wo->hisaddr); - if (wo->hisaddr) { - wo->accept_remote = 0; - } - } -#endif /* UNUSED */ - BZERO(&pcb->ipcp_hisoptions, sizeof(ipcp_options)); -} - - -/* - * ipcp_cilen - Return length of our CI. - * Called by fsm_sconfreq, Send Configure Request. - */ -static int ipcp_cilen(fsm *f) { - ppp_pcb *pcb = f->pcb; - ipcp_options *go = &pcb->ipcp_gotoptions; -#if VJ_SUPPORT - ipcp_options *wo = &pcb->ipcp_wantoptions; -#endif /* VJ_SUPPORT */ - ipcp_options *ho = &pcb->ipcp_hisoptions; - -#define LENCIADDRS(neg) (neg ? CILEN_ADDRS : 0) -#if VJ_SUPPORT -#define LENCIVJ(neg, old) (neg ? (old? CILEN_COMPRESS : CILEN_VJ) : 0) -#endif /* VJ_SUPPORT */ -#define LENCIADDR(neg) (neg ? CILEN_ADDR : 0) -#if LWIP_DNS -#define LENCIDNS(neg) LENCIADDR(neg) -#endif /* LWIP_DNS */ -#if 0 /* UNUSED - WINS */ -#define LENCIWINS(neg) LENCIADDR(neg) -#endif /* UNUSED - WINS */ - - /* - * First see if we want to change our options to the old - * forms because we have received old forms from the peer. - */ - if (go->neg_addr && go->old_addrs && !ho->neg_addr && ho->old_addrs) - go->neg_addr = 0; - -#if VJ_SUPPORT - if (wo->neg_vj && !go->neg_vj && !go->old_vj) { - /* try an older style of VJ negotiation */ - /* use the old style only if the peer did */ - if (ho->neg_vj && ho->old_vj) { - go->neg_vj = 1; - go->old_vj = 1; - go->vj_protocol = ho->vj_protocol; - } - } -#endif /* VJ_SUPPORT */ - - return (LENCIADDRS(!go->neg_addr && go->old_addrs) + -#if VJ_SUPPORT - LENCIVJ(go->neg_vj, go->old_vj) + -#endif /* VJ_SUPPORT */ - LENCIADDR(go->neg_addr) + -#if LWIP_DNS - LENCIDNS(go->req_dns1) + - LENCIDNS(go->req_dns2) + -#endif /* LWIP_DNS */ -#if 0 /* UNUSED - WINS */ - LENCIWINS(go->winsaddr[0]) + - LENCIWINS(go->winsaddr[1]) + -#endif /* UNUSED - WINS */ - 0); -} - - -/* - * ipcp_addci - Add our desired CIs to a packet. - * Called by fsm_sconfreq, Send Configure Request. - */ -static void ipcp_addci(fsm *f, u_char *ucp, int *lenp) { - ppp_pcb *pcb = f->pcb; - ipcp_options *go = &pcb->ipcp_gotoptions; - int len = *lenp; - -#define ADDCIADDRS(opt, neg, val1, val2) \ - if (neg) { \ - if (len >= CILEN_ADDRS) { \ - u32_t l; \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_ADDRS, ucp); \ - l = lwip_ntohl(val1); \ - PUTLONG(l, ucp); \ - l = lwip_ntohl(val2); \ - PUTLONG(l, ucp); \ - len -= CILEN_ADDRS; \ - } else \ - go->old_addrs = 0; \ - } - -#if VJ_SUPPORT -#define ADDCIVJ(opt, neg, val, old, maxslotindex, cflag) \ - if (neg) { \ - int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \ - if (len >= vjlen) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(vjlen, ucp); \ - PUTSHORT(val, ucp); \ - if (!old) { \ - PUTCHAR(maxslotindex, ucp); \ - PUTCHAR(cflag, ucp); \ - } \ - len -= vjlen; \ - } else \ - neg = 0; \ - } -#endif /* VJ_SUPPORT */ - -#define ADDCIADDR(opt, neg, val) \ - if (neg) { \ - if (len >= CILEN_ADDR) { \ - u32_t l; \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_ADDR, ucp); \ - l = lwip_ntohl(val); \ - PUTLONG(l, ucp); \ - len -= CILEN_ADDR; \ - } else \ - neg = 0; \ - } - -#if LWIP_DNS -#define ADDCIDNS(opt, neg, addr) \ - if (neg) { \ - if (len >= CILEN_ADDR) { \ - u32_t l; \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_ADDR, ucp); \ - l = lwip_ntohl(addr); \ - PUTLONG(l, ucp); \ - len -= CILEN_ADDR; \ - } else \ - neg = 0; \ - } -#endif /* LWIP_DNS */ - -#if 0 /* UNUSED - WINS */ -#define ADDCIWINS(opt, addr) \ - if (addr) { \ - if (len >= CILEN_ADDR) { \ - u32_t l; \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_ADDR, ucp); \ - l = lwip_ntohl(addr); \ - PUTLONG(l, ucp); \ - len -= CILEN_ADDR; \ - } else \ - addr = 0; \ - } -#endif /* UNUSED - WINS */ - - ADDCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, go->ouraddr, - go->hisaddr); - -#if VJ_SUPPORT - ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj, - go->maxslotindex, go->cflag); -#endif /* VJ_SUPPORT */ - - ADDCIADDR(CI_ADDR, go->neg_addr, go->ouraddr); - -#if LWIP_DNS - ADDCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]); - - ADDCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]); -#endif /* LWIP_DNS */ - -#if 0 /* UNUSED - WINS */ - ADDCIWINS(CI_MS_WINS1, go->winsaddr[0]); - - ADDCIWINS(CI_MS_WINS2, go->winsaddr[1]); -#endif /* UNUSED - WINS */ - - *lenp -= len; -} - - -/* - * ipcp_ackci - Ack our CIs. - * Called by fsm_rconfack, Receive Configure ACK. - * - * Returns: - * 0 - Ack was bad. - * 1 - Ack was good. - */ -static int ipcp_ackci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - ipcp_options *go = &pcb->ipcp_gotoptions; - u_short cilen, citype; - u32_t cilong; -#if VJ_SUPPORT - u_short cishort; - u_char cimaxslotindex, cicflag; -#endif /* VJ_SUPPORT */ - - /* - * CIs must be in exactly the same order that we sent... - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ - -#define ACKCIADDRS(opt, neg, val1, val2) \ - if (neg) { \ - u32_t l; \ - if ((len -= CILEN_ADDRS) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_ADDRS || \ - citype != opt) \ - goto bad; \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - if (val1 != cilong) \ - goto bad; \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - if (val2 != cilong) \ - goto bad; \ - } - -#if VJ_SUPPORT -#define ACKCIVJ(opt, neg, val, old, maxslotindex, cflag) \ - if (neg) { \ - int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \ - if ((len -= vjlen) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != vjlen || \ - citype != opt) \ - goto bad; \ - GETSHORT(cishort, p); \ - if (cishort != val) \ - goto bad; \ - if (!old) { \ - GETCHAR(cimaxslotindex, p); \ - if (cimaxslotindex != maxslotindex) \ - goto bad; \ - GETCHAR(cicflag, p); \ - if (cicflag != cflag) \ - goto bad; \ - } \ - } -#endif /* VJ_SUPPORT */ - -#define ACKCIADDR(opt, neg, val) \ - if (neg) { \ - u32_t l; \ - if ((len -= CILEN_ADDR) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_ADDR || \ - citype != opt) \ - goto bad; \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - if (val != cilong) \ - goto bad; \ - } - -#if LWIP_DNS -#define ACKCIDNS(opt, neg, addr) \ - if (neg) { \ - u32_t l; \ - if ((len -= CILEN_ADDR) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_ADDR || citype != opt) \ - goto bad; \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - if (addr != cilong) \ - goto bad; \ - } -#endif /* LWIP_DNS */ - -#if 0 /* UNUSED - WINS */ -#define ACKCIWINS(opt, addr) \ - if (addr) { \ - u32_t l; \ - if ((len -= CILEN_ADDR) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_ADDR || citype != opt) \ - goto bad; \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - if (addr != cilong) \ - goto bad; \ - } -#endif /* UNUSED - WINS */ - - ACKCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, go->ouraddr, - go->hisaddr); - -#if VJ_SUPPORT - ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj, - go->maxslotindex, go->cflag); -#endif /* VJ_SUPPORT */ - - ACKCIADDR(CI_ADDR, go->neg_addr, go->ouraddr); - -#if LWIP_DNS - ACKCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]); - - ACKCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]); -#endif /* LWIP_DNS */ - -#if 0 /* UNUSED - WINS */ - ACKCIWINS(CI_MS_WINS1, go->winsaddr[0]); - - ACKCIWINS(CI_MS_WINS2, go->winsaddr[1]); -#endif /* UNUSED - WINS */ - - /* - * If there are any remaining CIs, then this packet is bad. - */ - if (len != 0) - goto bad; - return (1); - -bad: - IPCPDEBUG(("ipcp_ackci: received bad Ack!")); - return (0); -} - -/* - * ipcp_nakci - Peer has sent a NAK for some of our CIs. - * This should not modify any state if the Nak is bad - * or if IPCP is in the OPENED state. - * Calback from fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject. - * - * Returns: - * 0 - Nak was bad. - * 1 - Nak was good. - */ -static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { - ppp_pcb *pcb = f->pcb; - ipcp_options *go = &pcb->ipcp_gotoptions; - u_char citype, cilen, *next; -#if VJ_SUPPORT - u_char cimaxslotindex, cicflag; - u_short cishort; -#endif /* VJ_SUPPORT */ - u32_t ciaddr1, ciaddr2, l; -#if LWIP_DNS - u32_t cidnsaddr; -#endif /* LWIP_DNS */ - ipcp_options no; /* options we've seen Naks for */ - ipcp_options try_; /* options to request next time */ - - BZERO(&no, sizeof(no)); - try_ = *go; - - /* - * Any Nak'd CIs must be in exactly the same order that we sent. - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ -#define NAKCIADDRS(opt, neg, code) \ - if ((neg) && \ - (cilen = p[1]) == CILEN_ADDRS && \ - len >= cilen && \ - p[0] == opt) { \ - len -= cilen; \ - INCPTR(2, p); \ - GETLONG(l, p); \ - ciaddr1 = lwip_htonl(l); \ - GETLONG(l, p); \ - ciaddr2 = lwip_htonl(l); \ - no.old_addrs = 1; \ - code \ - } - -#if VJ_SUPPORT -#define NAKCIVJ(opt, neg, code) \ - if (go->neg && \ - ((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && \ - len >= cilen && \ - p[0] == opt) { \ - len -= cilen; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - no.neg = 1; \ - code \ - } -#endif /* VJ_SUPPORT */ - -#define NAKCIADDR(opt, neg, code) \ - if (go->neg && \ - (cilen = p[1]) == CILEN_ADDR && \ - len >= cilen && \ - p[0] == opt) { \ - len -= cilen; \ - INCPTR(2, p); \ - GETLONG(l, p); \ - ciaddr1 = lwip_htonl(l); \ - no.neg = 1; \ - code \ - } - -#if LWIP_DNS -#define NAKCIDNS(opt, neg, code) \ - if (go->neg && \ - ((cilen = p[1]) == CILEN_ADDR) && \ - len >= cilen && \ - p[0] == opt) { \ - len -= cilen; \ - INCPTR(2, p); \ - GETLONG(l, p); \ - cidnsaddr = lwip_htonl(l); \ - no.neg = 1; \ - code \ - } -#endif /* LWIP_DNS */ - - /* - * Accept the peer's idea of {our,his} address, if different - * from our idea, only if the accept_{local,remote} flag is set. - */ - NAKCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, - if (treat_as_reject) { - try_.old_addrs = 0; - } else { - if (go->accept_local && ciaddr1) { - /* take his idea of our address */ - try_.ouraddr = ciaddr1; - } - if (go->accept_remote && ciaddr2) { - /* take his idea of his address */ - try_.hisaddr = ciaddr2; - } - } - ); - -#if VJ_SUPPORT - /* - * Accept the peer's value of maxslotindex provided that it - * is less than what we asked for. Turn off slot-ID compression - * if the peer wants. Send old-style compress-type option if - * the peer wants. - */ - NAKCIVJ(CI_COMPRESSTYPE, neg_vj, - if (treat_as_reject) { - try_.neg_vj = 0; - } else if (cilen == CILEN_VJ) { - GETCHAR(cimaxslotindex, p); - GETCHAR(cicflag, p); - if (cishort == IPCP_VJ_COMP) { - try_.old_vj = 0; - if (cimaxslotindex < go->maxslotindex) - try_.maxslotindex = cimaxslotindex; - if (!cicflag) - try_.cflag = 0; - } else { - try_.neg_vj = 0; - } - } else { - if (cishort == IPCP_VJ_COMP || cishort == IPCP_VJ_COMP_OLD) { - try_.old_vj = 1; - try_.vj_protocol = cishort; - } else { - try_.neg_vj = 0; - } - } - ); -#endif /* VJ_SUPPORT */ - - NAKCIADDR(CI_ADDR, neg_addr, - if (treat_as_reject) { - try_.neg_addr = 0; - try_.old_addrs = 0; - } else if (go->accept_local && ciaddr1) { - /* take his idea of our address */ - try_.ouraddr = ciaddr1; - } - ); - -#if LWIP_DNS - NAKCIDNS(CI_MS_DNS1, req_dns1, - if (treat_as_reject) { - try_.req_dns1 = 0; - } else { - try_.dnsaddr[0] = cidnsaddr; - } - ); - - NAKCIDNS(CI_MS_DNS2, req_dns2, - if (treat_as_reject) { - try_.req_dns2 = 0; - } else { - try_.dnsaddr[1] = cidnsaddr; - } - ); -#endif /* #if LWIP_DNS */ - - /* - * There may be remaining CIs, if the peer is requesting negotiation - * on an option that we didn't include in our request packet. - * If they want to negotiate about IP addresses, we comply. - * If they want us to ask for compression, we refuse. - * If they want us to ask for ms-dns, we do that, since some - * peers get huffy if we don't. - */ - while (len >= CILEN_VOID) { - GETCHAR(citype, p); - GETCHAR(cilen, p); - if ( cilen < CILEN_VOID || (len -= cilen) < 0 ) - goto bad; - next = p + cilen - 2; - - switch (citype) { -#if VJ_SUPPORT - case CI_COMPRESSTYPE: - if (go->neg_vj || no.neg_vj || - (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) - goto bad; - no.neg_vj = 1; - break; -#endif /* VJ_SUPPORT */ - case CI_ADDRS: - if ((!go->neg_addr && go->old_addrs) || no.old_addrs - || cilen != CILEN_ADDRS) - goto bad; - try_.neg_addr = 0; - GETLONG(l, p); - ciaddr1 = lwip_htonl(l); - if (ciaddr1 && go->accept_local) - try_.ouraddr = ciaddr1; - GETLONG(l, p); - ciaddr2 = lwip_htonl(l); - if (ciaddr2 && go->accept_remote) - try_.hisaddr = ciaddr2; - no.old_addrs = 1; - break; - case CI_ADDR: - if (go->neg_addr || no.neg_addr || cilen != CILEN_ADDR) - goto bad; - try_.old_addrs = 0; - GETLONG(l, p); - ciaddr1 = lwip_htonl(l); - if (ciaddr1 && go->accept_local) - try_.ouraddr = ciaddr1; - if (try_.ouraddr != 0) - try_.neg_addr = 1; - no.neg_addr = 1; - break; -#if LWIP_DNS - case CI_MS_DNS1: - if (go->req_dns1 || no.req_dns1 || cilen != CILEN_ADDR) - goto bad; - GETLONG(l, p); - try_.dnsaddr[0] = lwip_htonl(l); - try_.req_dns1 = 1; - no.req_dns1 = 1; - break; - case CI_MS_DNS2: - if (go->req_dns2 || no.req_dns2 || cilen != CILEN_ADDR) - goto bad; - GETLONG(l, p); - try_.dnsaddr[1] = lwip_htonl(l); - try_.req_dns2 = 1; - no.req_dns2 = 1; - break; -#endif /* LWIP_DNS */ -#if 0 /* UNUSED - WINS */ - case CI_MS_WINS1: - case CI_MS_WINS2: - if (cilen != CILEN_ADDR) - goto bad; - GETLONG(l, p); - ciaddr1 = lwip_htonl(l); - if (ciaddr1) - try_.winsaddr[citype == CI_MS_WINS2] = ciaddr1; - break; -#endif /* UNUSED - WINS */ - default: - break; - } - p = next; - } - - /* - * OK, the Nak is good. Now we can update state. - * If there are any remaining options, we ignore them. - */ - if (f->state != PPP_FSM_OPENED) - *go = try_; - - return 1; - -bad: - IPCPDEBUG(("ipcp_nakci: received bad Nak!")); - return 0; -} - - -/* - * ipcp_rejci - Reject some of our CIs. - * Callback from fsm_rconfnakrej. - */ -static int ipcp_rejci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - ipcp_options *go = &pcb->ipcp_gotoptions; - u_char cilen; -#if VJ_SUPPORT - u_char cimaxslotindex, ciflag; - u_short cishort; -#endif /* VJ_SUPPORT */ - u32_t cilong; - ipcp_options try_; /* options to request next time */ - - try_ = *go; - /* - * Any Rejected CIs must be in exactly the same order that we sent. - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ -#define REJCIADDRS(opt, neg, val1, val2) \ - if ((neg) && \ - (cilen = p[1]) == CILEN_ADDRS && \ - len >= cilen && \ - p[0] == opt) { \ - u32_t l; \ - len -= cilen; \ - INCPTR(2, p); \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - /* Check rejected value. */ \ - if (cilong != val1) \ - goto bad; \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - /* Check rejected value. */ \ - if (cilong != val2) \ - goto bad; \ - try_.old_addrs = 0; \ - } - -#if VJ_SUPPORT -#define REJCIVJ(opt, neg, val, old, maxslot, cflag) \ - if (go->neg && \ - p[1] == (old? CILEN_COMPRESS : CILEN_VJ) && \ - len >= p[1] && \ - p[0] == opt) { \ - len -= p[1]; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - /* Check rejected value. */ \ - if (cishort != val) \ - goto bad; \ - if (!old) { \ - GETCHAR(cimaxslotindex, p); \ - if (cimaxslotindex != maxslot) \ - goto bad; \ - GETCHAR(ciflag, p); \ - if (ciflag != cflag) \ - goto bad; \ - } \ - try_.neg = 0; \ - } -#endif /* VJ_SUPPORT */ - -#define REJCIADDR(opt, neg, val) \ - if (go->neg && \ - (cilen = p[1]) == CILEN_ADDR && \ - len >= cilen && \ - p[0] == opt) { \ - u32_t l; \ - len -= cilen; \ - INCPTR(2, p); \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - /* Check rejected value. */ \ - if (cilong != val) \ - goto bad; \ - try_.neg = 0; \ - } - -#if LWIP_DNS -#define REJCIDNS(opt, neg, dnsaddr) \ - if (go->neg && \ - ((cilen = p[1]) == CILEN_ADDR) && \ - len >= cilen && \ - p[0] == opt) { \ - u32_t l; \ - len -= cilen; \ - INCPTR(2, p); \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - /* Check rejected value. */ \ - if (cilong != dnsaddr) \ - goto bad; \ - try_.neg = 0; \ - } -#endif /* LWIP_DNS */ - -#if 0 /* UNUSED - WINS */ -#define REJCIWINS(opt, addr) \ - if (addr && \ - ((cilen = p[1]) == CILEN_ADDR) && \ - len >= cilen && \ - p[0] == opt) { \ - u32_t l; \ - len -= cilen; \ - INCPTR(2, p); \ - GETLONG(l, p); \ - cilong = lwip_htonl(l); \ - /* Check rejected value. */ \ - if (cilong != addr) \ - goto bad; \ - try_.winsaddr[opt == CI_MS_WINS2] = 0; \ - } -#endif /* UNUSED - WINS */ - - REJCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, - go->ouraddr, go->hisaddr); - -#if VJ_SUPPORT - REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol, go->old_vj, - go->maxslotindex, go->cflag); -#endif /* VJ_SUPPORT */ - - REJCIADDR(CI_ADDR, neg_addr, go->ouraddr); - -#if LWIP_DNS - REJCIDNS(CI_MS_DNS1, req_dns1, go->dnsaddr[0]); - - REJCIDNS(CI_MS_DNS2, req_dns2, go->dnsaddr[1]); -#endif /* LWIP_DNS */ - -#if 0 /* UNUSED - WINS */ - REJCIWINS(CI_MS_WINS1, go->winsaddr[0]); - - REJCIWINS(CI_MS_WINS2, go->winsaddr[1]); -#endif /* UNUSED - WINS */ - - /* - * If there are any remaining CIs, then this packet is bad. - */ - if (len != 0) - goto bad; - /* - * Now we can update state. - */ - if (f->state != PPP_FSM_OPENED) - *go = try_; - return 1; - -bad: - IPCPDEBUG(("ipcp_rejci: received bad Reject!")); - return 0; -} - - -/* - * ipcp_reqci - Check the peer's requested CIs and send appropriate response. - * Callback from fsm_rconfreq, Receive Configure Request - * - * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified - * appropriately. If reject_if_disagree is non-zero, doesn't return - * CONFNAK; returns CONFREJ if it can't return CONFACK. - * - * inp = Requested CIs - * len = Length of requested CIs - */ -static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) { - ppp_pcb *pcb = f->pcb; - ipcp_options *wo = &pcb->ipcp_wantoptions; - ipcp_options *ho = &pcb->ipcp_hisoptions; - ipcp_options *ao = &pcb->ipcp_allowoptions; - u_char *cip, *next; /* Pointer to current and next CIs */ - u_short cilen, citype; /* Parsed len, type */ -#if VJ_SUPPORT - u_short cishort; /* Parsed short value */ -#endif /* VJ_SUPPORT */ - u32_t tl, ciaddr1, ciaddr2;/* Parsed address values */ - int rc = CONFACK; /* Final packet return code */ - int orc; /* Individual option return code */ - u_char *p; /* Pointer to next char to parse */ - u_char *ucp = inp; /* Pointer to current output char */ - int l = *len; /* Length left */ -#if VJ_SUPPORT - u_char maxslotindex, cflag; -#endif /* VJ_SUPPORT */ -#if LWIP_DNS - int d; -#endif /* LWIP_DNS */ - - /* - * Reset all his options. - */ - BZERO(ho, sizeof(*ho)); - - /* - * Process all his options. - */ - next = inp; - while (l) { - orc = CONFACK; /* Assume success */ - cip = p = next; /* Remember begining of CI */ - if (l < 2 || /* Not enough data for CI header or */ - p[1] < 2 || /* CI length too small or */ - p[1] > l) { /* CI length too big? */ - IPCPDEBUG(("ipcp_reqci: bad CI length!")); - orc = CONFREJ; /* Reject bad CI */ - cilen = l; /* Reject till end of packet */ - l = 0; /* Don't loop again */ - goto endswitch; - } - GETCHAR(citype, p); /* Parse CI type */ - GETCHAR(cilen, p); /* Parse CI length */ - l -= cilen; /* Adjust remaining length */ - next += cilen; /* Step to next CI */ - - switch (citype) { /* Check CI type */ - case CI_ADDRS: - if (!ao->old_addrs || ho->neg_addr || - cilen != CILEN_ADDRS) { /* Check CI length */ - orc = CONFREJ; /* Reject CI */ - break; - } - - /* - * If he has no address, or if we both have his address but - * disagree about it, then NAK it with our idea. - * In particular, if we don't know his address, but he does, - * then accept it. - */ - GETLONG(tl, p); /* Parse source address (his) */ - ciaddr1 = lwip_htonl(tl); - if (ciaddr1 != wo->hisaddr - && (ciaddr1 == 0 || !wo->accept_remote)) { - orc = CONFNAK; - if (!reject_if_disagree) { - DECPTR(sizeof(u32_t), p); - tl = lwip_ntohl(wo->hisaddr); - PUTLONG(tl, p); - } - } else if (ciaddr1 == 0 && wo->hisaddr == 0) { - /* - * If neither we nor he knows his address, reject the option. - */ - orc = CONFREJ; - wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */ - break; - } - - /* - * If he doesn't know our address, or if we both have our address - * but disagree about it, then NAK it with our idea. - */ - GETLONG(tl, p); /* Parse desination address (ours) */ - ciaddr2 = lwip_htonl(tl); - if (ciaddr2 != wo->ouraddr) { - if (ciaddr2 == 0 || !wo->accept_local) { - orc = CONFNAK; - if (!reject_if_disagree) { - DECPTR(sizeof(u32_t), p); - tl = lwip_ntohl(wo->ouraddr); - PUTLONG(tl, p); - } - } else { - wo->ouraddr = ciaddr2; /* accept peer's idea */ - } - } - - ho->old_addrs = 1; - ho->hisaddr = ciaddr1; - ho->ouraddr = ciaddr2; - break; - - case CI_ADDR: - if (!ao->neg_addr || ho->old_addrs || - cilen != CILEN_ADDR) { /* Check CI length */ - orc = CONFREJ; /* Reject CI */ - break; - } - - /* - * If he has no address, or if we both have his address but - * disagree about it, then NAK it with our idea. - * In particular, if we don't know his address, but he does, - * then accept it. - */ - GETLONG(tl, p); /* Parse source address (his) */ - ciaddr1 = lwip_htonl(tl); - if (ciaddr1 != wo->hisaddr - && (ciaddr1 == 0 || !wo->accept_remote)) { - orc = CONFNAK; - if (!reject_if_disagree) { - DECPTR(sizeof(u32_t), p); - tl = lwip_ntohl(wo->hisaddr); - PUTLONG(tl, p); - } - } else if (ciaddr1 == 0 && wo->hisaddr == 0) { - /* - * Don't ACK an address of 0.0.0.0 - reject it instead. - */ - orc = CONFREJ; - wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */ - break; - } - - ho->neg_addr = 1; - ho->hisaddr = ciaddr1; - break; - -#if LWIP_DNS - case CI_MS_DNS1: - case CI_MS_DNS2: - /* Microsoft primary or secondary DNS request */ - d = citype == CI_MS_DNS2; - - /* If we do not have a DNS address then we cannot send it */ - if (ao->dnsaddr[d] == 0 || - cilen != CILEN_ADDR) { /* Check CI length */ - orc = CONFREJ; /* Reject CI */ - break; - } - GETLONG(tl, p); - if (lwip_htonl(tl) != ao->dnsaddr[d]) { - DECPTR(sizeof(u32_t), p); - tl = lwip_ntohl(ao->dnsaddr[d]); - PUTLONG(tl, p); - orc = CONFNAK; - } - break; -#endif /* LWIP_DNS */ - -#if 0 /* UNUSED - WINS */ - case CI_MS_WINS1: - case CI_MS_WINS2: - /* Microsoft primary or secondary WINS request */ - d = citype == CI_MS_WINS2; - - /* If we do not have a DNS address then we cannot send it */ - if (ao->winsaddr[d] == 0 || - cilen != CILEN_ADDR) { /* Check CI length */ - orc = CONFREJ; /* Reject CI */ - break; - } - GETLONG(tl, p); - if (lwip_htonl(tl) != ao->winsaddr[d]) { - DECPTR(sizeof(u32_t), p); - tl = lwip_ntohl(ao->winsaddr[d]); - PUTLONG(tl, p); - orc = CONFNAK; - } - break; -#endif /* UNUSED - WINS */ - -#if VJ_SUPPORT - case CI_COMPRESSTYPE: - if (!ao->neg_vj || - (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) { - orc = CONFREJ; - break; - } - GETSHORT(cishort, p); - - if (!(cishort == IPCP_VJ_COMP || - (cishort == IPCP_VJ_COMP_OLD && cilen == CILEN_COMPRESS))) { - orc = CONFREJ; - break; - } - - ho->neg_vj = 1; - ho->vj_protocol = cishort; - if (cilen == CILEN_VJ) { - GETCHAR(maxslotindex, p); - if (maxslotindex > ao->maxslotindex) { - orc = CONFNAK; - if (!reject_if_disagree){ - DECPTR(1, p); - PUTCHAR(ao->maxslotindex, p); - } - } - GETCHAR(cflag, p); - if (cflag && !ao->cflag) { - orc = CONFNAK; - if (!reject_if_disagree){ - DECPTR(1, p); - PUTCHAR(wo->cflag, p); - } - } - ho->maxslotindex = maxslotindex; - ho->cflag = cflag; - } else { - ho->old_vj = 1; - ho->maxslotindex = MAX_STATES - 1; - ho->cflag = 1; - } - break; -#endif /* VJ_SUPPORT */ - - default: - orc = CONFREJ; - break; - } -endswitch: - if (orc == CONFACK && /* Good CI */ - rc != CONFACK) /* but prior CI wasnt? */ - continue; /* Don't send this one */ - - if (orc == CONFNAK) { /* Nak this CI? */ - if (reject_if_disagree) /* Getting fed up with sending NAKs? */ - orc = CONFREJ; /* Get tough if so */ - else { - if (rc == CONFREJ) /* Rejecting prior CI? */ - continue; /* Don't send this one */ - if (rc == CONFACK) { /* Ack'd all prior CIs? */ - rc = CONFNAK; /* Not anymore... */ - ucp = inp; /* Backup */ - } - } - } - - if (orc == CONFREJ && /* Reject this CI */ - rc != CONFREJ) { /* but no prior ones? */ - rc = CONFREJ; - ucp = inp; /* Backup */ - } - - /* Need to move CI? */ - if (ucp != cip) - MEMCPY(ucp, cip, cilen); /* Move it */ - - /* Update output pointer */ - INCPTR(cilen, ucp); - } - - /* - * If we aren't rejecting this packet, and we want to negotiate - * their address, and they didn't send their address, then we - * send a NAK with a CI_ADDR option appended. We assume the - * input buffer is long enough that we can append the extra - * option safely. - */ - if (rc != CONFREJ && !ho->neg_addr && !ho->old_addrs && - wo->req_addr && !reject_if_disagree && !pcb->settings.noremoteip) { - if (rc == CONFACK) { - rc = CONFNAK; - ucp = inp; /* reset pointer */ - wo->req_addr = 0; /* don't ask again */ - } - PUTCHAR(CI_ADDR, ucp); - PUTCHAR(CILEN_ADDR, ucp); - tl = lwip_ntohl(wo->hisaddr); - PUTLONG(tl, ucp); - } - - *len = ucp - inp; /* Compute output length */ - IPCPDEBUG(("ipcp: returning Configure-%s", CODENAME(rc))); - return (rc); /* Return final code */ -} - - -#if 0 /* UNUSED */ -/* - * ip_check_options - check that any IP-related options are OK, - * and assign appropriate defaults. - */ -static void -ip_check_options() -{ - struct hostent *hp; - u32_t local; - ipcp_options *wo = &ipcp_wantoptions[0]; - - /* - * Default our local IP address based on our hostname. - * If local IP address already given, don't bother. - */ - if (wo->ouraddr == 0 && !disable_defaultip) { - /* - * Look up our hostname (possibly with domain name appended) - * and take the first IP address as our local IP address. - * If there isn't an IP address for our hostname, too bad. - */ - wo->accept_local = 1; /* don't insist on this default value */ - if ((hp = gethostbyname(hostname)) != NULL) { - local = *(u32_t *)hp->h_addr; - if (local != 0 && !bad_ip_adrs(local)) - wo->ouraddr = local; - } - } - ask_for_local = wo->ouraddr != 0 || !disable_defaultip; -} -#endif /* UNUSED */ - -#if DEMAND_SUPPORT -/* - * ip_demand_conf - configure the interface as though - * IPCP were up, for use with dial-on-demand. - */ -static int -ip_demand_conf(u) - int u; -{ - ppp_pcb *pcb = &ppp_pcb_list[u]; - ipcp_options *wo = &ipcp_wantoptions[u]; - - if (wo->hisaddr == 0 && !pcb->settings.noremoteip) { - /* make up an arbitrary address for the peer */ - wo->hisaddr = lwip_htonl(0x0a707070 + ifunit); - wo->accept_remote = 1; - } - if (wo->ouraddr == 0) { - /* make up an arbitrary address for us */ - wo->ouraddr = lwip_htonl(0x0a404040 + ifunit); - wo->accept_local = 1; - ask_for_local = 0; /* don't tell the peer this address */ - } - if (!sifaddr(pcb, wo->ouraddr, wo->hisaddr, get_mask(wo->ouraddr))) - return 0; - if (!sifup(pcb)) - return 0; - if (!sifnpmode(pcb, PPP_IP, NPMODE_QUEUE)) - return 0; -#if 0 /* UNUSED */ - if (wo->default_route) - if (sifdefaultroute(pcb, wo->ouraddr, wo->hisaddr, - wo->replace_default_route)) - default_route_set[u] = 1; -#endif /* UNUSED */ -#if 0 /* UNUSED - PROXY ARP */ - if (wo->proxy_arp) - if (sifproxyarp(pcb, wo->hisaddr)) - proxy_arp_set[u] = 1; -#endif /* UNUSED - PROXY ARP */ - - ppp_notice("local IP address %I", wo->ouraddr); - if (wo->hisaddr) - ppp_notice("remote IP address %I", wo->hisaddr); - - return 1; -} -#endif /* DEMAND_SUPPORT */ - -/* - * ipcp_up - IPCP has come UP. - * - * Configure the IP network interface appropriately and bring it up. - */ -static void ipcp_up(fsm *f) { - ppp_pcb *pcb = f->pcb; - u32_t mask; - ipcp_options *ho = &pcb->ipcp_hisoptions; - ipcp_options *go = &pcb->ipcp_gotoptions; - ipcp_options *wo = &pcb->ipcp_wantoptions; - - IPCPDEBUG(("ipcp: up")); - - /* - * We must have a non-zero IP address for both ends of the link. - */ - if (!ho->neg_addr && !ho->old_addrs) - ho->hisaddr = wo->hisaddr; - - if (!(go->neg_addr || go->old_addrs) && (wo->neg_addr || wo->old_addrs) - && wo->ouraddr != 0) { - ppp_error("Peer refused to agree to our IP address"); - ipcp_close(f->pcb, "Refused our IP address"); - return; - } - if (go->ouraddr == 0) { - ppp_error("Could not determine local IP address"); - ipcp_close(f->pcb, "Could not determine local IP address"); - return; - } - if (ho->hisaddr == 0 && !pcb->settings.noremoteip) { - ho->hisaddr = lwip_htonl(0x0a404040); - ppp_warn("Could not determine remote IP address: defaulting to %I", - ho->hisaddr); - } -#if 0 /* UNUSED */ - script_setenv("IPLOCAL", ip_ntoa(go->ouraddr), 0); - if (ho->hisaddr != 0) - script_setenv("IPREMOTE", ip_ntoa(ho->hisaddr), 1); -#endif /* UNUSED */ - -#if LWIP_DNS - if (!go->req_dns1) - go->dnsaddr[0] = 0; - if (!go->req_dns2) - go->dnsaddr[1] = 0; -#if 0 /* UNUSED */ - if (go->dnsaddr[0]) - script_setenv("DNS1", ip_ntoa(go->dnsaddr[0]), 0); - if (go->dnsaddr[1]) - script_setenv("DNS2", ip_ntoa(go->dnsaddr[1]), 0); -#endif /* UNUSED */ - if (pcb->settings.usepeerdns && (go->dnsaddr[0] || go->dnsaddr[1])) { - sdns(pcb, go->dnsaddr[0], go->dnsaddr[1]); -#if 0 /* UNUSED */ - script_setenv("USEPEERDNS", "1", 0); - create_resolv(go->dnsaddr[0], go->dnsaddr[1]); -#endif /* UNUSED */ - } -#endif /* LWIP_DNS */ - - /* - * Check that the peer is allowed to use the IP address it wants. - */ - if (ho->hisaddr != 0) { - u32_t addr = lwip_ntohl(ho->hisaddr); - if ((addr >> IP_CLASSA_NSHIFT) == IP_LOOPBACKNET - || IP_MULTICAST(addr) || IP_BADCLASS(addr) - /* - * For now, consider that PPP in server mode with peer required - * to authenticate must provide the peer IP address, reject any - * IP address wanted by peer different than the one we wanted. - */ -#if PPP_SERVER && PPP_AUTH_SUPPORT - || (pcb->settings.auth_required && wo->hisaddr != ho->hisaddr) -#endif /* PPP_SERVER && PPP_AUTH_SUPPORT */ - ) { - ppp_error("Peer is not authorized to use remote address %I", ho->hisaddr); - ipcp_close(pcb, "Unauthorized remote IP address"); - return; - } - } -#if 0 /* Unused */ - /* Upstream checking code */ - if (ho->hisaddr != 0 && !auth_ip_addr(f->unit, ho->hisaddr)) { - ppp_error("Peer is not authorized to use remote address %I", ho->hisaddr); - ipcp_close(f->unit, "Unauthorized remote IP address"); - return; - } -#endif /* Unused */ - -#if VJ_SUPPORT - /* set tcp compression */ - sifvjcomp(pcb, ho->neg_vj, ho->cflag, ho->maxslotindex); -#endif /* VJ_SUPPORT */ - -#if DEMAND_SUPPORT - /* - * If we are doing dial-on-demand, the interface is already - * configured, so we put out any saved-up packets, then set the - * interface to pass IP packets. - */ - if (demand) { - if (go->ouraddr != wo->ouraddr || ho->hisaddr != wo->hisaddr) { - ipcp_clear_addrs(f->unit, wo->ouraddr, wo->hisaddr, - wo->replace_default_route); - if (go->ouraddr != wo->ouraddr) { - ppp_warn("Local IP address changed to %I", go->ouraddr); - script_setenv("OLDIPLOCAL", ip_ntoa(wo->ouraddr), 0); - wo->ouraddr = go->ouraddr; - } else - script_unsetenv("OLDIPLOCAL"); - if (ho->hisaddr != wo->hisaddr && wo->hisaddr != 0) { - ppp_warn("Remote IP address changed to %I", ho->hisaddr); - script_setenv("OLDIPREMOTE", ip_ntoa(wo->hisaddr), 0); - wo->hisaddr = ho->hisaddr; - } else - script_unsetenv("OLDIPREMOTE"); - - /* Set the interface to the new addresses */ - mask = get_mask(go->ouraddr); - if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { -#if PPP_DEBUG - ppp_warn("Interface configuration failed"); -#endif /* PPP_DEBUG */ - ipcp_close(f->unit, "Interface configuration failed"); - return; - } - - /* assign a default route through the interface if required */ - if (ipcp_wantoptions[f->unit].default_route) - if (sifdefaultroute(pcb, go->ouraddr, ho->hisaddr, - wo->replace_default_route)) - default_route_set[f->unit] = 1; - -#if 0 /* UNUSED - PROXY ARP */ - /* Make a proxy ARP entry if requested. */ - if (ho->hisaddr != 0 && ipcp_wantoptions[f->unit].proxy_arp) - if (sifproxyarp(pcb, ho->hisaddr)) - proxy_arp_set[f->unit] = 1; -#endif /* UNUSED - PROXY ARP */ - - } - demand_rexmit(PPP_IP,go->ouraddr); - sifnpmode(pcb, PPP_IP, NPMODE_PASS); - - } else -#endif /* DEMAND_SUPPORT */ - { - /* - * Set IP addresses and (if specified) netmask. - */ - mask = get_mask(go->ouraddr); - -#if !(defined(SVR4) && (defined(SNI) || defined(__USLC__))) - if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { -#if PPP_DEBUG - ppp_warn("Interface configuration failed"); -#endif /* PPP_DEBUG */ - ipcp_close(f->pcb, "Interface configuration failed"); - return; - } -#endif - - /* bring the interface up for IP */ - if (!sifup(pcb)) { -#if PPP_DEBUG - ppp_warn("Interface failed to come up"); -#endif /* PPP_DEBUG */ - ipcp_close(f->pcb, "Interface configuration failed"); - return; - } - -#if (defined(SVR4) && (defined(SNI) || defined(__USLC__))) - if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { -#if PPP_DEBUG - ppp_warn("Interface configuration failed"); -#endif /* PPP_DEBUG */ - ipcp_close(f->unit, "Interface configuration failed"); - return; - } -#endif -#if DEMAND_SUPPORT - sifnpmode(pcb, PPP_IP, NPMODE_PASS); -#endif /* DEMAND_SUPPORT */ - -#if 0 /* UNUSED */ - /* assign a default route through the interface if required */ - if (wo->default_route) - if (sifdefaultroute(pcb, go->ouraddr, ho->hisaddr, - wo->replace_default_route)) - pcb->default_route_set = 1; -#endif /* UNUSED */ - -#if 0 /* UNUSED - PROXY ARP */ - /* Make a proxy ARP entry if requested. */ - if (ho->hisaddr != 0 && wo->proxy_arp) - if (sifproxyarp(pcb, ho->hisaddr)) - pcb->proxy_arp_set = 1; -#endif /* UNUSED - PROXY ARP */ - - wo->ouraddr = go->ouraddr; - - ppp_notice("local IP address %I", go->ouraddr); - if (ho->hisaddr != 0) - ppp_notice("remote IP address %I", ho->hisaddr); -#if LWIP_DNS - if (go->dnsaddr[0]) - ppp_notice("primary DNS address %I", go->dnsaddr[0]); - if (go->dnsaddr[1]) - ppp_notice("secondary DNS address %I", go->dnsaddr[1]); -#endif /* LWIP_DNS */ - } - -#if PPP_STATS_SUPPORT - reset_link_stats(f->unit); -#endif /* PPP_STATS_SUPPORT */ - - np_up(pcb, PPP_IP); - pcb->ipcp_is_up = 1; - -#if PPP_NOTIFY - notify(ip_up_notifier, 0); -#endif /* PPP_NOTIFY */ -#if 0 /* UNUSED */ - if (ip_up_hook) - ip_up_hook(); -#endif /* UNUSED */ -} - - -/* - * ipcp_down - IPCP has gone DOWN. - * - * Take the IP network interface down, clear its addresses - * and delete routes through it. - */ -static void ipcp_down(fsm *f) { - ppp_pcb *pcb = f->pcb; - ipcp_options *ho = &pcb->ipcp_hisoptions; - ipcp_options *go = &pcb->ipcp_gotoptions; - - IPCPDEBUG(("ipcp: down")); -#if PPP_STATS_SUPPORT - /* XXX a bit IPv4-centric here, we only need to get the stats - * before the interface is marked down. */ - /* XXX more correct: we must get the stats before running the notifiers, - * at least for the radius plugin */ - update_link_stats(f->unit); -#endif /* PPP_STATS_SUPPORT */ -#if PPP_NOTIFY - notify(ip_down_notifier, 0); -#endif /* PPP_NOTIFY */ -#if 0 /* UNUSED */ - if (ip_down_hook) - ip_down_hook(); -#endif /* UNUSED */ - if (pcb->ipcp_is_up) { - pcb->ipcp_is_up = 0; - np_down(pcb, PPP_IP); - } -#if VJ_SUPPORT - sifvjcomp(pcb, 0, 0, 0); -#endif /* VJ_SUPPORT */ - -#if PPP_STATS_SUPPORT - print_link_stats(); /* _after_ running the notifiers and ip_down_hook(), - * because print_link_stats() sets link_stats_valid - * to 0 (zero) */ -#endif /* PPP_STATS_SUPPORT */ - -#if DEMAND_SUPPORT - /* - * If we are doing dial-on-demand, set the interface - * to queue up outgoing packets (for now). - */ - if (demand) { - sifnpmode(pcb, PPP_IP, NPMODE_QUEUE); - } else -#endif /* DEMAND_SUPPORT */ - { -#if DEMAND_SUPPORT - sifnpmode(pcb, PPP_IP, NPMODE_DROP); -#endif /* DEMAND_SUPPORT */ - sifdown(pcb); - ipcp_clear_addrs(pcb, go->ouraddr, - ho->hisaddr, 0); -#if LWIP_DNS - cdns(pcb, go->dnsaddr[0], go->dnsaddr[1]); -#endif /* LWIP_DNS */ - } -} - - -/* - * ipcp_clear_addrs() - clear the interface addresses, routes, - * proxy arp entries, etc. - */ -static void ipcp_clear_addrs(ppp_pcb *pcb, u32_t ouraddr, u32_t hisaddr, u8_t replacedefaultroute) { - LWIP_UNUSED_ARG(replacedefaultroute); - -#if 0 /* UNUSED - PROXY ARP */ - if (pcb->proxy_arp_set) { - cifproxyarp(pcb, hisaddr); - pcb->proxy_arp_set = 0; - } -#endif /* UNUSED - PROXY ARP */ -#if 0 /* UNUSED */ - /* If replacedefaultroute, sifdefaultroute will be called soon - * with replacedefaultroute set and that will overwrite the current - * default route. This is the case only when doing demand, otherwise - * during demand, this cifdefaultroute would restore the old default - * route which is not what we want in this case. In the non-demand - * case, we'll delete the default route and restore the old if there - * is one saved by an sifdefaultroute with replacedefaultroute. - */ - if (!replacedefaultroute && pcb->default_route_set) { - cifdefaultroute(pcb, ouraddr, hisaddr); - pcb->default_route_set = 0; - } -#endif /* UNUSED */ - cifaddr(pcb, ouraddr, hisaddr); -} - - -/* - * ipcp_finished - possibly shut down the lower layers. - */ -static void ipcp_finished(fsm *f) { - ppp_pcb *pcb = f->pcb; - if (pcb->ipcp_is_open) { - pcb->ipcp_is_open = 0; - np_finished(pcb, PPP_IP); - } -} - - -#if 0 /* UNUSED */ -/* - * create_resolv - create the replacement resolv.conf file - */ -static void -create_resolv(peerdns1, peerdns2) - u32_t peerdns1, peerdns2; -{ - -} -#endif /* UNUSED */ - -#if PRINTPKT_SUPPORT -/* - * ipcp_printpkt - print the contents of an IPCP packet. - */ -static const char* const ipcp_codenames[] = { - "ConfReq", "ConfAck", "ConfNak", "ConfRej", - "TermReq", "TermAck", "CodeRej" -}; - -static int ipcp_printpkt(const u_char *p, int plen, - void (*printer) (void *, const char *, ...), void *arg) { - int code, id, len, olen; - const u_char *pstart, *optend; -#if VJ_SUPPORT - u_short cishort; -#endif /* VJ_SUPPORT */ - u32_t cilong; - - if (plen < HEADERLEN) - return 0; - pstart = p; - GETCHAR(code, p); - GETCHAR(id, p); - GETSHORT(len, p); - if (len < HEADERLEN || len > plen) - return 0; - - if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(ipcp_codenames)) - printer(arg, " %s", ipcp_codenames[code-1]); - else - printer(arg, " code=0x%x", code); - printer(arg, " id=0x%x", id); - len -= HEADERLEN; - switch (code) { - case CONFREQ: - case CONFACK: - case CONFNAK: - case CONFREJ: - /* print option list */ - while (len >= 2) { - GETCHAR(code, p); - GETCHAR(olen, p); - p -= 2; - if (olen < 2 || olen > len) { - break; - } - printer(arg, " <"); - len -= olen; - optend = p + olen; - switch (code) { - case CI_ADDRS: - if (olen == CILEN_ADDRS) { - p += 2; - GETLONG(cilong, p); - printer(arg, "addrs %I", lwip_htonl(cilong)); - GETLONG(cilong, p); - printer(arg, " %I", lwip_htonl(cilong)); - } - break; -#if VJ_SUPPORT - case CI_COMPRESSTYPE: - if (olen >= CILEN_COMPRESS) { - p += 2; - GETSHORT(cishort, p); - printer(arg, "compress "); - switch (cishort) { - case IPCP_VJ_COMP: - printer(arg, "VJ"); - break; - case IPCP_VJ_COMP_OLD: - printer(arg, "old-VJ"); - break; - default: - printer(arg, "0x%x", cishort); - } - } - break; -#endif /* VJ_SUPPORT */ - case CI_ADDR: - if (olen == CILEN_ADDR) { - p += 2; - GETLONG(cilong, p); - printer(arg, "addr %I", lwip_htonl(cilong)); - } - break; -#if LWIP_DNS - case CI_MS_DNS1: - case CI_MS_DNS2: - p += 2; - GETLONG(cilong, p); - printer(arg, "ms-dns%d %I", (code == CI_MS_DNS1? 1: 2), - htonl(cilong)); - break; -#endif /* LWIP_DNS */ -#if 0 /* UNUSED - WINS */ - case CI_MS_WINS1: - case CI_MS_WINS2: - p += 2; - GETLONG(cilong, p); - printer(arg, "ms-wins %I", lwip_htonl(cilong)); - break; -#endif /* UNUSED - WINS */ - default: - break; - } - while (p < optend) { - GETCHAR(code, p); - printer(arg, " %.2x", code); - } - printer(arg, ">"); - } - break; - - case TERMACK: - case TERMREQ: - if (len > 0 && *p >= ' ' && *p < 0x7f) { - printer(arg, " "); - ppp_print_string(p, len, printer, arg); - p += len; - len = 0; - } - break; - default: - break; - } - - /* print the rest of the bytes in the packet */ - for (; len > 0; --len) { - GETCHAR(code, p); - printer(arg, " %.2x", code); - } - - return p - pstart; -} -#endif /* PRINTPKT_SUPPORT */ - -#if DEMAND_SUPPORT -/* - * ip_active_pkt - see if this IP packet is worth bringing the link up for. - * We don't bring the link up for IP fragments or for TCP FIN packets - * with no data. - */ -#define IP_HDRLEN 20 /* bytes */ -#define IP_OFFMASK 0x1fff -#ifndef IPPROTO_TCP -#define IPPROTO_TCP 6 -#endif -#define TCP_HDRLEN 20 -#define TH_FIN 0x01 - -/* - * We use these macros because the IP header may be at an odd address, - * and some compilers might use word loads to get th_off or ip_hl. - */ - -#define net_short(x) (((x)[0] << 8) + (x)[1]) -#define get_iphl(x) (((unsigned char *)(x))[0] & 0xF) -#define get_ipoff(x) net_short((unsigned char *)(x) + 6) -#define get_ipproto(x) (((unsigned char *)(x))[9]) -#define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4) -#define get_tcpflags(x) (((unsigned char *)(x))[13]) - -static int -ip_active_pkt(pkt, len) - u_char *pkt; - int len; -{ - u_char *tcp; - int hlen; - - len -= PPP_HDRLEN; - pkt += PPP_HDRLEN; - if (len < IP_HDRLEN) - return 0; - if ((get_ipoff(pkt) & IP_OFFMASK) != 0) - return 0; - if (get_ipproto(pkt) != IPPROTO_TCP) - return 1; - hlen = get_iphl(pkt) * 4; - if (len < hlen + TCP_HDRLEN) - return 0; - tcp = pkt + hlen; - if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == hlen + get_tcpoff(tcp) * 4) - return 0; - return 1; -} -#endif /* DEMAND_SUPPORT */ - -#endif /* PPP_SUPPORT && PPP_IPV4_SUPPORT */ +/* + * ipcp.c - PPP IP Control Protocol. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPP_IPV4_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +/* + * @todo: + */ + +#if 0 /* UNUSED */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/ipcp.h" + +#if 0 /* UNUSED */ +/* global vars */ +u32_t netmask = 0; /* IP netmask to set on interface */ +#endif /* UNUSED */ + +#if 0 /* UNUSED */ +bool disable_defaultip = 0; /* Don't use hostname for default IP adrs */ +#endif /* UNUSED */ + +#if 0 /* moved to ppp_settings */ +bool noremoteip = 0; /* Let him have no IP address */ +#endif /* moved to ppp_setting */ + +#if 0 /* UNUSED */ +/* Hook for a plugin to know when IP protocol has come up */ +void (*ip_up_hook) (void) = NULL; + +/* Hook for a plugin to know when IP protocol has come down */ +void (*ip_down_hook) (void) = NULL; + +/* Hook for a plugin to choose the remote IP address */ +void (*ip_choose_hook) (u32_t *) = NULL; +#endif /* UNUSED */ + +#if PPP_NOTIFY +/* Notifiers for when IPCP goes up and down */ +struct notifier *ip_up_notifier = NULL; +struct notifier *ip_down_notifier = NULL; +#endif /* PPP_NOTIFY */ + +/* local vars */ +#if 0 /* moved to ppp_pcb */ +static int default_route_set[NUM_PPP]; /* Have set up a default route */ +static int proxy_arp_set[NUM_PPP]; /* Have created proxy arp entry */ +static int ipcp_is_up; /* have called np_up() */ +static int ipcp_is_open; /* haven't called np_finished() */ +static bool ask_for_local; /* request our address from peer */ +#endif /* moved to ppp_pcb */ +#if 0 /* UNUSED */ +static char vj_value[8]; /* string form of vj option value */ +static char netmask_str[20]; /* string form of netmask value */ +#endif /* UNUSED */ + +/* + * Callbacks for fsm code. (CI = Configuration Information) + */ +static void ipcp_resetci(fsm *f); /* Reset our CI */ +static int ipcp_cilen(fsm *f); /* Return length of our CI */ +static void ipcp_addci(fsm *f, u_char *ucp, int *lenp); /* Add our CI */ +static int ipcp_ackci(fsm *f, u_char *p, int len); /* Peer ack'd our CI */ +static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject);/* Peer nak'd our CI */ +static int ipcp_rejci(fsm *f, u_char *p, int len); /* Peer rej'd our CI */ +static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree); /* Rcv CI */ +static void ipcp_up(fsm *f); /* We're UP */ +static void ipcp_down(fsm *f); /* We're DOWN */ +static void ipcp_finished(fsm *f); /* Don't need lower layer */ + +static const fsm_callbacks ipcp_callbacks = { /* IPCP callback routines */ + ipcp_resetci, /* Reset our Configuration Information */ + ipcp_cilen, /* Length of our Configuration Information */ + ipcp_addci, /* Add our Configuration Information */ + ipcp_ackci, /* ACK our Configuration Information */ + ipcp_nakci, /* NAK our Configuration Information */ + ipcp_rejci, /* Reject our Configuration Information */ + ipcp_reqci, /* Request peer's Configuration Information */ + ipcp_up, /* Called when fsm reaches OPENED state */ + ipcp_down, /* Called when fsm leaves OPENED state */ + NULL, /* Called when we want the lower layer up */ + ipcp_finished, /* Called when we want the lower layer down */ + NULL, /* Called when Protocol-Reject received */ + NULL, /* Retransmission is necessary */ + NULL, /* Called to handle protocol-specific codes */ + "IPCP" /* String name of protocol */ +}; + +/* + * Command-line options. + */ +#if PPP_OPTIONS +static int setvjslots (char **); +static int setdnsaddr (char **); +static int setwinsaddr (char **); +static int setnetmask (char **); +int setipaddr (char *, char **, int); + +static void printipaddr (option_t *, void (*)(void *, char *,...),void *); + +static option_t ipcp_option_list[] = { + { "noip", o_bool, &ipcp_protent.enabled_flag, + "Disable IP and IPCP" }, + { "-ip", o_bool, &ipcp_protent.enabled_flag, + "Disable IP and IPCP", OPT_ALIAS }, + + { "novj", o_bool, &ipcp_wantoptions[0].neg_vj, + "Disable VJ compression", OPT_A2CLR, &ipcp_allowoptions[0].neg_vj }, + { "-vj", o_bool, &ipcp_wantoptions[0].neg_vj, + "Disable VJ compression", OPT_ALIAS | OPT_A2CLR, + &ipcp_allowoptions[0].neg_vj }, + + { "novjccomp", o_bool, &ipcp_wantoptions[0].cflag, + "Disable VJ connection-ID compression", OPT_A2CLR, + &ipcp_allowoptions[0].cflag }, + { "-vjccomp", o_bool, &ipcp_wantoptions[0].cflag, + "Disable VJ connection-ID compression", OPT_ALIAS | OPT_A2CLR, + &ipcp_allowoptions[0].cflag }, + + { "vj-max-slots", o_special, (void *)setvjslots, + "Set maximum VJ header slots", + OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, vj_value }, + + { "ipcp-accept-local", o_bool, &ipcp_wantoptions[0].accept_local, + "Accept peer's address for us", 1 }, + { "ipcp-accept-remote", o_bool, &ipcp_wantoptions[0].accept_remote, + "Accept peer's address for it", 1 }, + + { "ipparam", o_string, &ipparam, + "Set ip script parameter", OPT_PRIO }, + + { "noipdefault", o_bool, &disable_defaultip, + "Don't use name for default IP adrs", 1 }, + + { "ms-dns", 1, (void *)setdnsaddr, + "DNS address for the peer's use" }, + { "ms-wins", 1, (void *)setwinsaddr, + "Nameserver for SMB over TCP/IP for peer" }, + + { "ipcp-restart", o_int, &ipcp_fsm[0].timeouttime, + "Set timeout for IPCP", OPT_PRIO }, + { "ipcp-max-terminate", o_int, &ipcp_fsm[0].maxtermtransmits, + "Set max #xmits for term-reqs", OPT_PRIO }, + { "ipcp-max-configure", o_int, &ipcp_fsm[0].maxconfreqtransmits, + "Set max #xmits for conf-reqs", OPT_PRIO }, + { "ipcp-max-failure", o_int, &ipcp_fsm[0].maxnakloops, + "Set max #conf-naks for IPCP", OPT_PRIO }, + + { "defaultroute", o_bool, &ipcp_wantoptions[0].default_route, + "Add default route", OPT_ENABLE|1, &ipcp_allowoptions[0].default_route }, + { "nodefaultroute", o_bool, &ipcp_allowoptions[0].default_route, + "disable defaultroute option", OPT_A2CLR, + &ipcp_wantoptions[0].default_route }, + { "-defaultroute", o_bool, &ipcp_allowoptions[0].default_route, + "disable defaultroute option", OPT_ALIAS | OPT_A2CLR, + &ipcp_wantoptions[0].default_route }, + + { "replacedefaultroute", o_bool, + &ipcp_wantoptions[0].replace_default_route, + "Replace default route", 1 + }, + { "noreplacedefaultroute", o_bool, + &ipcp_allowoptions[0].replace_default_route, + "Never replace default route", OPT_A2COPY, + &ipcp_wantoptions[0].replace_default_route }, + { "proxyarp", o_bool, &ipcp_wantoptions[0].proxy_arp, + "Add proxy ARP entry", OPT_ENABLE|1, &ipcp_allowoptions[0].proxy_arp }, + { "noproxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp, + "disable proxyarp option", OPT_A2CLR, + &ipcp_wantoptions[0].proxy_arp }, + { "-proxyarp", o_bool, &ipcp_allowoptions[0].proxy_arp, + "disable proxyarp option", OPT_ALIAS | OPT_A2CLR, + &ipcp_wantoptions[0].proxy_arp }, + + { "usepeerdns", o_bool, &usepeerdns, + "Ask peer for DNS address(es)", 1 }, + + { "netmask", o_special, (void *)setnetmask, + "set netmask", OPT_PRIO | OPT_A2STRVAL | OPT_STATIC, netmask_str }, + + { "ipcp-no-addresses", o_bool, &ipcp_wantoptions[0].old_addrs, + "Disable old-style IP-Addresses usage", OPT_A2CLR, + &ipcp_allowoptions[0].old_addrs }, + { "ipcp-no-address", o_bool, &ipcp_wantoptions[0].neg_addr, + "Disable IP-Address usage", OPT_A2CLR, + &ipcp_allowoptions[0].neg_addr }, + + { "noremoteip", o_bool, &noremoteip, + "Allow peer to have no IP address", 1 }, + + { "nosendip", o_bool, &ipcp_wantoptions[0].neg_addr, + "Don't send our IP address to peer", OPT_A2CLR, + &ipcp_wantoptions[0].old_addrs}, + + { "IP addresses", o_wild, (void *) &setipaddr, + "set local and remote IP addresses", + OPT_NOARG | OPT_A2PRINTER, (void *) &printipaddr }, + + { NULL } +}; +#endif /* PPP_OPTIONS */ + +/* + * Protocol entry points from main code. + */ +static void ipcp_init(ppp_pcb *pcb); +static void ipcp_open(ppp_pcb *pcb); +static void ipcp_close(ppp_pcb *pcb, const char *reason); +static void ipcp_lowerup(ppp_pcb *pcb); +static void ipcp_lowerdown(ppp_pcb *pcb); +static void ipcp_input(ppp_pcb *pcb, u_char *p, int len); +static void ipcp_protrej(ppp_pcb *pcb); +#if PRINTPKT_SUPPORT +static int ipcp_printpkt(const u_char *p, int plen, + void (*printer) (void *, const char *, ...), void *arg); +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS +static void ip_check_options (void); +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT +static int ip_demand_conf (int); +static int ip_active_pkt (u_char *, int); +#endif /* DEMAND_SUPPORT */ +#if 0 /* UNUSED */ +static void create_resolv (u32_t, u32_t); +#endif /* UNUSED */ + +const struct protent ipcp_protent = { + PPP_IPCP, + ipcp_init, + ipcp_input, + ipcp_protrej, + ipcp_lowerup, + ipcp_lowerdown, + ipcp_open, + ipcp_close, +#if PRINTPKT_SUPPORT + ipcp_printpkt, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + NULL, +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "IPCP", + "IP", +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + ipcp_option_list, + ip_check_options, +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + ip_demand_conf, + ip_active_pkt +#endif /* DEMAND_SUPPORT */ +}; + +static void ipcp_clear_addrs(ppp_pcb *pcb, u32_t ouraddr, u32_t hisaddr, u8_t replacedefaultroute); + +/* + * Lengths of configuration options. + */ +#define CILEN_VOID 2 +#define CILEN_COMPRESS 4 /* min length for compression protocol opt. */ +#define CILEN_VJ 6 /* length for RFC1332 Van-Jacobson opt. */ +#define CILEN_ADDR 6 /* new-style single address option */ +#define CILEN_ADDRS 10 /* old-style dual address option */ + + +#define CODENAME(x) ((x) == CONFACK ? "ACK" : \ + (x) == CONFNAK ? "NAK" : "REJ") + +#if 0 /* UNUSED, already defined by lwIP */ +/* + * Make a string representation of a network IP address. + */ +char * +ip_ntoa(ipaddr) +u32_t ipaddr; +{ + static char b[64]; + + slprintf(b, sizeof(b), "%I", ipaddr); + return b; +} +#endif /* UNUSED, already defined by lwIP */ + +/* + * Option parsing. + */ +#if PPP_OPTIONS +/* + * setvjslots - set maximum number of connection slots for VJ compression + */ +static int +setvjslots(argv) + char **argv; +{ + int value; + + if (!int_option(*argv, &value)) + return 0; + + if (value < 2 || value > 16) { + option_error("vj-max-slots value must be between 2 and 16"); + return 0; + } + ipcp_wantoptions [0].maxslotindex = + ipcp_allowoptions[0].maxslotindex = value - 1; + slprintf(vj_value, sizeof(vj_value), "%d", value); + return 1; +} + +/* + * setdnsaddr - set the dns address(es) + */ +static int +setdnsaddr(argv) + char **argv; +{ + u32_t dns; + struct hostent *hp; + + dns = inet_addr(*argv); + if (dns == (u32_t) -1) { + if ((hp = gethostbyname(*argv)) == NULL) { + option_error("invalid address parameter '%s' for ms-dns option", + *argv); + return 0; + } + dns = *(u32_t *)hp->h_addr; + } + + /* We take the last 2 values given, the 2nd-last as the primary + and the last as the secondary. If only one is given it + becomes both primary and secondary. */ + if (ipcp_allowoptions[0].dnsaddr[1] == 0) + ipcp_allowoptions[0].dnsaddr[0] = dns; + else + ipcp_allowoptions[0].dnsaddr[0] = ipcp_allowoptions[0].dnsaddr[1]; + + /* always set the secondary address value. */ + ipcp_allowoptions[0].dnsaddr[1] = dns; + + return (1); +} + +/* + * setwinsaddr - set the wins address(es) + * This is primrarly used with the Samba package under UNIX or for pointing + * the caller to the existing WINS server on a Windows NT platform. + */ +static int +setwinsaddr(argv) + char **argv; +{ + u32_t wins; + struct hostent *hp; + + wins = inet_addr(*argv); + if (wins == (u32_t) -1) { + if ((hp = gethostbyname(*argv)) == NULL) { + option_error("invalid address parameter '%s' for ms-wins option", + *argv); + return 0; + } + wins = *(u32_t *)hp->h_addr; + } + + /* We take the last 2 values given, the 2nd-last as the primary + and the last as the secondary. If only one is given it + becomes both primary and secondary. */ + if (ipcp_allowoptions[0].winsaddr[1] == 0) + ipcp_allowoptions[0].winsaddr[0] = wins; + else + ipcp_allowoptions[0].winsaddr[0] = ipcp_allowoptions[0].winsaddr[1]; + + /* always set the secondary address value. */ + ipcp_allowoptions[0].winsaddr[1] = wins; + + return (1); +} + +/* + * setipaddr - Set the IP address + * If doit is 0, the call is to check whether this option is + * potentially an IP address specification. + * Not static so that plugins can call it to set the addresses + */ +int +setipaddr(arg, argv, doit) + char *arg; + char **argv; + int doit; +{ + struct hostent *hp; + char *colon; + u32_t local, remote; + ipcp_options *wo = &ipcp_wantoptions[0]; + static int prio_local = 0, prio_remote = 0; + + /* + * IP address pair separated by ":". + */ + if ((colon = strchr(arg, ':')) == NULL) + return 0; + if (!doit) + return 1; + + /* + * If colon first character, then no local addr. + */ + if (colon != arg && option_priority >= prio_local) { + *colon = '\0'; + if ((local = inet_addr(arg)) == (u32_t) -1) { + if ((hp = gethostbyname(arg)) == NULL) { + option_error("unknown host: %s", arg); + return 0; + } + local = *(u32_t *)hp->h_addr; + } + if (bad_ip_adrs(local)) { + option_error("bad local IP address %s", ip_ntoa(local)); + return 0; + } + if (local != 0) + wo->ouraddr = local; + *colon = ':'; + prio_local = option_priority; + } + + /* + * If colon last character, then no remote addr. + */ + if (*++colon != '\0' && option_priority >= prio_remote) { + if ((remote = inet_addr(colon)) == (u32_t) -1) { + if ((hp = gethostbyname(colon)) == NULL) { + option_error("unknown host: %s", colon); + return 0; + } + remote = *(u32_t *)hp->h_addr; + if (remote_name[0] == 0) + strlcpy(remote_name, colon, sizeof(remote_name)); + } + if (bad_ip_adrs(remote)) { + option_error("bad remote IP address %s", ip_ntoa(remote)); + return 0; + } + if (remote != 0) + wo->hisaddr = remote; + prio_remote = option_priority; + } + + return 1; +} + +static void +printipaddr(opt, printer, arg) + option_t *opt; + void (*printer) (void *, char *, ...); + void *arg; +{ + ipcp_options *wo = &ipcp_wantoptions[0]; + + if (wo->ouraddr != 0) + printer(arg, "%I", wo->ouraddr); + printer(arg, ":"); + if (wo->hisaddr != 0) + printer(arg, "%I", wo->hisaddr); +} + +/* + * setnetmask - set the netmask to be used on the interface. + */ +static int +setnetmask(argv) + char **argv; +{ + u32_t mask; + int n; + char *p; + + /* + * Unfortunately, if we use inet_addr, we can't tell whether + * a result of all 1s is an error or a valid 255.255.255.255. + */ + p = *argv; + n = parse_dotted_ip(p, &mask); + + mask = lwip_htonl(mask); + + if (n == 0 || p[n] != 0 || (netmask & ~mask) != 0) { + option_error("invalid netmask value '%s'", *argv); + return 0; + } + + netmask = mask; + slprintf(netmask_str, sizeof(netmask_str), "%I", mask); + + return (1); +} + +int +parse_dotted_ip(p, vp) + char *p; + u32_t *vp; +{ + int n; + u32_t v, b; + char *endp, *p0 = p; + + v = 0; + for (n = 3;; --n) { + b = strtoul(p, &endp, 0); + if (endp == p) + return 0; + if (b > 255) { + if (n < 3) + return 0; + /* accept e.g. 0xffffff00 */ + *vp = b; + return endp - p0; + } + v |= b << (n * 8); + p = endp; + if (n == 0) + break; + if (*p != '.') + return 0; + ++p; + } + *vp = v; + return p - p0; +} +#endif /* PPP_OPTIONS */ + +/* + * ipcp_init - Initialize IPCP. + */ +static void ipcp_init(ppp_pcb *pcb) { + fsm *f = &pcb->ipcp_fsm; + + ipcp_options *wo = &pcb->ipcp_wantoptions; + ipcp_options *ao = &pcb->ipcp_allowoptions; + + f->pcb = pcb; + f->protocol = PPP_IPCP; + f->callbacks = &ipcp_callbacks; + fsm_init(f); + + /* + * Some 3G modems use repeated IPCP NAKs as a way of stalling + * until they can contact a server on the network, so we increase + * the default number of NAKs we accept before we start treating + * them as rejects. + */ + f->maxnakloops = 100; + +#if 0 /* Not necessary, everything is cleared in ppp_new() */ + memset(wo, 0, sizeof(*wo)); + memset(ao, 0, sizeof(*ao)); +#endif /* 0 */ + + wo->neg_addr = wo->old_addrs = 1; +#if VJ_SUPPORT + wo->neg_vj = 1; + wo->vj_protocol = IPCP_VJ_COMP; + wo->maxslotindex = MAX_STATES - 1; /* really max index */ + wo->cflag = 1; +#endif /* VJ_SUPPORT */ + +#if 0 /* UNUSED */ + /* wanting default route by default */ + wo->default_route = 1; +#endif /* UNUSED */ + + ao->neg_addr = ao->old_addrs = 1; +#if VJ_SUPPORT + /* max slots and slot-id compression are currently hardwired in */ + /* ppp_if.c to 16 and 1, this needs to be changed (among other */ + /* things) gmc */ + + ao->neg_vj = 1; + ao->maxslotindex = MAX_STATES - 1; + ao->cflag = 1; +#endif /* #if VJ_SUPPORT */ + +#if 0 /* UNUSED */ + /* + * XXX These control whether the user may use the proxyarp + * and defaultroute options. + */ + ao->proxy_arp = 1; + ao->default_route = 1; +#endif /* UNUSED */ +} + + +/* + * ipcp_open - IPCP is allowed to come up. + */ +static void ipcp_open(ppp_pcb *pcb) { + fsm *f = &pcb->ipcp_fsm; + fsm_open(f); + pcb->ipcp_is_open = 1; +} + + +/* + * ipcp_close - Take IPCP down. + */ +static void ipcp_close(ppp_pcb *pcb, const char *reason) { + fsm *f = &pcb->ipcp_fsm; + fsm_close(f, reason); +} + + +/* + * ipcp_lowerup - The lower layer is up. + */ +static void ipcp_lowerup(ppp_pcb *pcb) { + fsm *f = &pcb->ipcp_fsm; + fsm_lowerup(f); +} + + +/* + * ipcp_lowerdown - The lower layer is down. + */ +static void ipcp_lowerdown(ppp_pcb *pcb) { + fsm *f = &pcb->ipcp_fsm; + fsm_lowerdown(f); +} + + +/* + * ipcp_input - Input IPCP packet. + */ +static void ipcp_input(ppp_pcb *pcb, u_char *p, int len) { + fsm *f = &pcb->ipcp_fsm; + fsm_input(f, p, len); +} + + +/* + * ipcp_protrej - A Protocol-Reject was received for IPCP. + * + * Pretend the lower layer went down, so we shut up. + */ +static void ipcp_protrej(ppp_pcb *pcb) { + fsm *f = &pcb->ipcp_fsm; + fsm_lowerdown(f); +} + + +/* + * ipcp_resetci - Reset our CI. + * Called by fsm_sconfreq, Send Configure Request. + */ +static void ipcp_resetci(fsm *f) { + ppp_pcb *pcb = f->pcb; + ipcp_options *wo = &pcb->ipcp_wantoptions; + ipcp_options *go = &pcb->ipcp_gotoptions; + ipcp_options *ao = &pcb->ipcp_allowoptions; + + wo->req_addr = (wo->neg_addr || wo->old_addrs) && + (ao->neg_addr || ao->old_addrs); + if (wo->ouraddr == 0) + wo->accept_local = 1; + if (wo->hisaddr == 0) + wo->accept_remote = 1; +#if LWIP_DNS + wo->req_dns1 = wo->req_dns2 = pcb->settings.usepeerdns; /* Request DNS addresses from the peer */ +#endif /* LWIP_DNS */ + *go = *wo; + if (!pcb->ask_for_local) + go->ouraddr = 0; +#if 0 /* UNUSED */ + if (ip_choose_hook) { + ip_choose_hook(&wo->hisaddr); + if (wo->hisaddr) { + wo->accept_remote = 0; + } + } +#endif /* UNUSED */ + BZERO(&pcb->ipcp_hisoptions, sizeof(ipcp_options)); +} + + +/* + * ipcp_cilen - Return length of our CI. + * Called by fsm_sconfreq, Send Configure Request. + */ +static int ipcp_cilen(fsm *f) { + ppp_pcb *pcb = f->pcb; + ipcp_options *go = &pcb->ipcp_gotoptions; +#if VJ_SUPPORT + ipcp_options *wo = &pcb->ipcp_wantoptions; +#endif /* VJ_SUPPORT */ + ipcp_options *ho = &pcb->ipcp_hisoptions; + +#define LENCIADDRS(neg) (neg ? CILEN_ADDRS : 0) +#if VJ_SUPPORT +#define LENCIVJ(neg, old) (neg ? (old? CILEN_COMPRESS : CILEN_VJ) : 0) +#endif /* VJ_SUPPORT */ +#define LENCIADDR(neg) (neg ? CILEN_ADDR : 0) +#if LWIP_DNS +#define LENCIDNS(neg) LENCIADDR(neg) +#endif /* LWIP_DNS */ +#if 0 /* UNUSED - WINS */ +#define LENCIWINS(neg) LENCIADDR(neg) +#endif /* UNUSED - WINS */ + + /* + * First see if we want to change our options to the old + * forms because we have received old forms from the peer. + */ + if (go->neg_addr && go->old_addrs && !ho->neg_addr && ho->old_addrs) + go->neg_addr = 0; + +#if VJ_SUPPORT + if (wo->neg_vj && !go->neg_vj && !go->old_vj) { + /* try an older style of VJ negotiation */ + /* use the old style only if the peer did */ + if (ho->neg_vj && ho->old_vj) { + go->neg_vj = 1; + go->old_vj = 1; + go->vj_protocol = ho->vj_protocol; + } + } +#endif /* VJ_SUPPORT */ + + return (LENCIADDRS(!go->neg_addr && go->old_addrs) + +#if VJ_SUPPORT + LENCIVJ(go->neg_vj, go->old_vj) + +#endif /* VJ_SUPPORT */ + LENCIADDR(go->neg_addr) + +#if LWIP_DNS + LENCIDNS(go->req_dns1) + + LENCIDNS(go->req_dns2) + +#endif /* LWIP_DNS */ +#if 0 /* UNUSED - WINS */ + LENCIWINS(go->winsaddr[0]) + + LENCIWINS(go->winsaddr[1]) + +#endif /* UNUSED - WINS */ + 0); +} + + +/* + * ipcp_addci - Add our desired CIs to a packet. + * Called by fsm_sconfreq, Send Configure Request. + */ +static void ipcp_addci(fsm *f, u_char *ucp, int *lenp) { + ppp_pcb *pcb = f->pcb; + ipcp_options *go = &pcb->ipcp_gotoptions; + int len = *lenp; + +#define ADDCIADDRS(opt, neg, val1, val2) \ + if (neg) { \ + if (len >= CILEN_ADDRS) { \ + u32_t l; \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_ADDRS, ucp); \ + l = lwip_ntohl(val1); \ + PUTLONG(l, ucp); \ + l = lwip_ntohl(val2); \ + PUTLONG(l, ucp); \ + len -= CILEN_ADDRS; \ + } else \ + go->old_addrs = 0; \ + } + +#if VJ_SUPPORT +#define ADDCIVJ(opt, neg, val, old, maxslotindex, cflag) \ + if (neg) { \ + int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \ + if (len >= vjlen) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(vjlen, ucp); \ + PUTSHORT(val, ucp); \ + if (!old) { \ + PUTCHAR(maxslotindex, ucp); \ + PUTCHAR(cflag, ucp); \ + } \ + len -= vjlen; \ + } else \ + neg = 0; \ + } +#endif /* VJ_SUPPORT */ + +#define ADDCIADDR(opt, neg, val) \ + if (neg) { \ + if (len >= CILEN_ADDR) { \ + u32_t l; \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_ADDR, ucp); \ + l = lwip_ntohl(val); \ + PUTLONG(l, ucp); \ + len -= CILEN_ADDR; \ + } else \ + neg = 0; \ + } + +#if LWIP_DNS +#define ADDCIDNS(opt, neg, addr) \ + if (neg) { \ + if (len >= CILEN_ADDR) { \ + u32_t l; \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_ADDR, ucp); \ + l = lwip_ntohl(addr); \ + PUTLONG(l, ucp); \ + len -= CILEN_ADDR; \ + } else \ + neg = 0; \ + } +#endif /* LWIP_DNS */ + +#if 0 /* UNUSED - WINS */ +#define ADDCIWINS(opt, addr) \ + if (addr) { \ + if (len >= CILEN_ADDR) { \ + u32_t l; \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_ADDR, ucp); \ + l = lwip_ntohl(addr); \ + PUTLONG(l, ucp); \ + len -= CILEN_ADDR; \ + } else \ + addr = 0; \ + } +#endif /* UNUSED - WINS */ + + ADDCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, go->ouraddr, + go->hisaddr); + +#if VJ_SUPPORT + ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj, + go->maxslotindex, go->cflag); +#endif /* VJ_SUPPORT */ + + ADDCIADDR(CI_ADDR, go->neg_addr, go->ouraddr); + +#if LWIP_DNS + ADDCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]); + + ADDCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]); +#endif /* LWIP_DNS */ + +#if 0 /* UNUSED - WINS */ + ADDCIWINS(CI_MS_WINS1, go->winsaddr[0]); + + ADDCIWINS(CI_MS_WINS2, go->winsaddr[1]); +#endif /* UNUSED - WINS */ + + *lenp -= len; +} + + +/* + * ipcp_ackci - Ack our CIs. + * Called by fsm_rconfack, Receive Configure ACK. + * + * Returns: + * 0 - Ack was bad. + * 1 - Ack was good. + */ +static int ipcp_ackci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + ipcp_options *go = &pcb->ipcp_gotoptions; + u_short cilen, citype; + u32_t cilong; +#if VJ_SUPPORT + u_short cishort; + u_char cimaxslotindex, cicflag; +#endif /* VJ_SUPPORT */ + + /* + * CIs must be in exactly the same order that we sent... + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ + +#define ACKCIADDRS(opt, neg, val1, val2) \ + if (neg) { \ + u32_t l; \ + if ((len -= CILEN_ADDRS) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_ADDRS || \ + citype != opt) \ + goto bad; \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + if (val1 != cilong) \ + goto bad; \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + if (val2 != cilong) \ + goto bad; \ + } + +#if VJ_SUPPORT +#define ACKCIVJ(opt, neg, val, old, maxslotindex, cflag) \ + if (neg) { \ + int vjlen = old? CILEN_COMPRESS : CILEN_VJ; \ + if ((len -= vjlen) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != vjlen || \ + citype != opt) \ + goto bad; \ + GETSHORT(cishort, p); \ + if (cishort != val) \ + goto bad; \ + if (!old) { \ + GETCHAR(cimaxslotindex, p); \ + if (cimaxslotindex != maxslotindex) \ + goto bad; \ + GETCHAR(cicflag, p); \ + if (cicflag != cflag) \ + goto bad; \ + } \ + } +#endif /* VJ_SUPPORT */ + +#define ACKCIADDR(opt, neg, val) \ + if (neg) { \ + u32_t l; \ + if ((len -= CILEN_ADDR) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_ADDR || \ + citype != opt) \ + goto bad; \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + if (val != cilong) \ + goto bad; \ + } + +#if LWIP_DNS +#define ACKCIDNS(opt, neg, addr) \ + if (neg) { \ + u32_t l; \ + if ((len -= CILEN_ADDR) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_ADDR || citype != opt) \ + goto bad; \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + if (addr != cilong) \ + goto bad; \ + } +#endif /* LWIP_DNS */ + +#if 0 /* UNUSED - WINS */ +#define ACKCIWINS(opt, addr) \ + if (addr) { \ + u32_t l; \ + if ((len -= CILEN_ADDR) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_ADDR || citype != opt) \ + goto bad; \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + if (addr != cilong) \ + goto bad; \ + } +#endif /* UNUSED - WINS */ + + ACKCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, go->ouraddr, + go->hisaddr); + +#if VJ_SUPPORT + ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol, go->old_vj, + go->maxslotindex, go->cflag); +#endif /* VJ_SUPPORT */ + + ACKCIADDR(CI_ADDR, go->neg_addr, go->ouraddr); + +#if LWIP_DNS + ACKCIDNS(CI_MS_DNS1, go->req_dns1, go->dnsaddr[0]); + + ACKCIDNS(CI_MS_DNS2, go->req_dns2, go->dnsaddr[1]); +#endif /* LWIP_DNS */ + +#if 0 /* UNUSED - WINS */ + ACKCIWINS(CI_MS_WINS1, go->winsaddr[0]); + + ACKCIWINS(CI_MS_WINS2, go->winsaddr[1]); +#endif /* UNUSED - WINS */ + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + return (1); + +bad: + IPCPDEBUG(("ipcp_ackci: received bad Ack!")); + return (0); +} + +/* + * ipcp_nakci - Peer has sent a NAK for some of our CIs. + * This should not modify any state if the Nak is bad + * or if IPCP is in the OPENED state. + * Calback from fsm_rconfnakrej - Receive Configure-Nak or Configure-Reject. + * + * Returns: + * 0 - Nak was bad. + * 1 - Nak was good. + */ +static int ipcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { + ppp_pcb *pcb = f->pcb; + ipcp_options *go = &pcb->ipcp_gotoptions; + u_char citype, cilen, *next; +#if VJ_SUPPORT + u_char cimaxslotindex, cicflag; + u_short cishort; +#endif /* VJ_SUPPORT */ + u32_t ciaddr1, ciaddr2, l; +#if LWIP_DNS + u32_t cidnsaddr; +#endif /* LWIP_DNS */ + ipcp_options no; /* options we've seen Naks for */ + ipcp_options try_; /* options to request next time */ + + BZERO(&no, sizeof(no)); + try_ = *go; + + /* + * Any Nak'd CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define NAKCIADDRS(opt, neg, code) \ + if ((neg) && \ + (cilen = p[1]) == CILEN_ADDRS && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETLONG(l, p); \ + ciaddr1 = lwip_htonl(l); \ + GETLONG(l, p); \ + ciaddr2 = lwip_htonl(l); \ + no.old_addrs = 1; \ + code \ + } + +#if VJ_SUPPORT +#define NAKCIVJ(opt, neg, code) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_COMPRESS || cilen == CILEN_VJ) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + no.neg = 1; \ + code \ + } +#endif /* VJ_SUPPORT */ + +#define NAKCIADDR(opt, neg, code) \ + if (go->neg && \ + (cilen = p[1]) == CILEN_ADDR && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETLONG(l, p); \ + ciaddr1 = lwip_htonl(l); \ + no.neg = 1; \ + code \ + } + +#if LWIP_DNS +#define NAKCIDNS(opt, neg, code) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_ADDR) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETLONG(l, p); \ + cidnsaddr = lwip_htonl(l); \ + no.neg = 1; \ + code \ + } +#endif /* LWIP_DNS */ + + /* + * Accept the peer's idea of {our,his} address, if different + * from our idea, only if the accept_{local,remote} flag is set. + */ + NAKCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, + if (treat_as_reject) { + try_.old_addrs = 0; + } else { + if (go->accept_local && ciaddr1) { + /* take his idea of our address */ + try_.ouraddr = ciaddr1; + } + if (go->accept_remote && ciaddr2) { + /* take his idea of his address */ + try_.hisaddr = ciaddr2; + } + } + ); + +#if VJ_SUPPORT + /* + * Accept the peer's value of maxslotindex provided that it + * is less than what we asked for. Turn off slot-ID compression + * if the peer wants. Send old-style compress-type option if + * the peer wants. + */ + NAKCIVJ(CI_COMPRESSTYPE, neg_vj, + if (treat_as_reject) { + try_.neg_vj = 0; + } else if (cilen == CILEN_VJ) { + GETCHAR(cimaxslotindex, p); + GETCHAR(cicflag, p); + if (cishort == IPCP_VJ_COMP) { + try_.old_vj = 0; + if (cimaxslotindex < go->maxslotindex) + try_.maxslotindex = cimaxslotindex; + if (!cicflag) + try_.cflag = 0; + } else { + try_.neg_vj = 0; + } + } else { + if (cishort == IPCP_VJ_COMP || cishort == IPCP_VJ_COMP_OLD) { + try_.old_vj = 1; + try_.vj_protocol = cishort; + } else { + try_.neg_vj = 0; + } + } + ); +#endif /* VJ_SUPPORT */ + + NAKCIADDR(CI_ADDR, neg_addr, + if (treat_as_reject) { + try_.neg_addr = 0; + try_.old_addrs = 0; + } else if (go->accept_local && ciaddr1) { + /* take his idea of our address */ + try_.ouraddr = ciaddr1; + } + ); + +#if LWIP_DNS + NAKCIDNS(CI_MS_DNS1, req_dns1, + if (treat_as_reject) { + try_.req_dns1 = 0; + } else { + try_.dnsaddr[0] = cidnsaddr; + } + ); + + NAKCIDNS(CI_MS_DNS2, req_dns2, + if (treat_as_reject) { + try_.req_dns2 = 0; + } else { + try_.dnsaddr[1] = cidnsaddr; + } + ); +#endif /* #if LWIP_DNS */ + + /* + * There may be remaining CIs, if the peer is requesting negotiation + * on an option that we didn't include in our request packet. + * If they want to negotiate about IP addresses, we comply. + * If they want us to ask for compression, we refuse. + * If they want us to ask for ms-dns, we do that, since some + * peers get huffy if we don't. + */ + while (len >= CILEN_VOID) { + GETCHAR(citype, p); + GETCHAR(cilen, p); + if ( cilen < CILEN_VOID || (len -= cilen) < 0 ) + goto bad; + next = p + cilen - 2; + + switch (citype) { +#if VJ_SUPPORT + case CI_COMPRESSTYPE: + if (go->neg_vj || no.neg_vj || + (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) + goto bad; + no.neg_vj = 1; + break; +#endif /* VJ_SUPPORT */ + case CI_ADDRS: + if ((!go->neg_addr && go->old_addrs) || no.old_addrs + || cilen != CILEN_ADDRS) + goto bad; + try_.neg_addr = 0; + GETLONG(l, p); + ciaddr1 = lwip_htonl(l); + if (ciaddr1 && go->accept_local) + try_.ouraddr = ciaddr1; + GETLONG(l, p); + ciaddr2 = lwip_htonl(l); + if (ciaddr2 && go->accept_remote) + try_.hisaddr = ciaddr2; + no.old_addrs = 1; + break; + case CI_ADDR: + if (go->neg_addr || no.neg_addr || cilen != CILEN_ADDR) + goto bad; + try_.old_addrs = 0; + GETLONG(l, p); + ciaddr1 = lwip_htonl(l); + if (ciaddr1 && go->accept_local) + try_.ouraddr = ciaddr1; + if (try_.ouraddr != 0) + try_.neg_addr = 1; + no.neg_addr = 1; + break; +#if LWIP_DNS + case CI_MS_DNS1: + if (go->req_dns1 || no.req_dns1 || cilen != CILEN_ADDR) + goto bad; + GETLONG(l, p); + try_.dnsaddr[0] = lwip_htonl(l); + try_.req_dns1 = 1; + no.req_dns1 = 1; + break; + case CI_MS_DNS2: + if (go->req_dns2 || no.req_dns2 || cilen != CILEN_ADDR) + goto bad; + GETLONG(l, p); + try_.dnsaddr[1] = lwip_htonl(l); + try_.req_dns2 = 1; + no.req_dns2 = 1; + break; +#endif /* LWIP_DNS */ +#if 0 /* UNUSED - WINS */ + case CI_MS_WINS1: + case CI_MS_WINS2: + if (cilen != CILEN_ADDR) + goto bad; + GETLONG(l, p); + ciaddr1 = lwip_htonl(l); + if (ciaddr1) + try_.winsaddr[citype == CI_MS_WINS2] = ciaddr1; + break; +#endif /* UNUSED - WINS */ + default: + break; + } + p = next; + } + + /* + * OK, the Nak is good. Now we can update state. + * If there are any remaining options, we ignore them. + */ + if (f->state != PPP_FSM_OPENED) + *go = try_; + + return 1; + +bad: + IPCPDEBUG(("ipcp_nakci: received bad Nak!")); + return 0; +} + + +/* + * ipcp_rejci - Reject some of our CIs. + * Callback from fsm_rconfnakrej. + */ +static int ipcp_rejci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + ipcp_options *go = &pcb->ipcp_gotoptions; + u_char cilen; +#if VJ_SUPPORT + u_char cimaxslotindex, ciflag; + u_short cishort; +#endif /* VJ_SUPPORT */ + u32_t cilong; + ipcp_options try_; /* options to request next time */ + + try_ = *go; + /* + * Any Rejected CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define REJCIADDRS(opt, neg, val1, val2) \ + if ((neg) && \ + (cilen = p[1]) == CILEN_ADDRS && \ + len >= cilen && \ + p[0] == opt) { \ + u32_t l; \ + len -= cilen; \ + INCPTR(2, p); \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + /* Check rejected value. */ \ + if (cilong != val1) \ + goto bad; \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + /* Check rejected value. */ \ + if (cilong != val2) \ + goto bad; \ + try_.old_addrs = 0; \ + } + +#if VJ_SUPPORT +#define REJCIVJ(opt, neg, val, old, maxslot, cflag) \ + if (go->neg && \ + p[1] == (old? CILEN_COMPRESS : CILEN_VJ) && \ + len >= p[1] && \ + p[0] == opt) { \ + len -= p[1]; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + /* Check rejected value. */ \ + if (cishort != val) \ + goto bad; \ + if (!old) { \ + GETCHAR(cimaxslotindex, p); \ + if (cimaxslotindex != maxslot) \ + goto bad; \ + GETCHAR(ciflag, p); \ + if (ciflag != cflag) \ + goto bad; \ + } \ + try_.neg = 0; \ + } +#endif /* VJ_SUPPORT */ + +#define REJCIADDR(opt, neg, val) \ + if (go->neg && \ + (cilen = p[1]) == CILEN_ADDR && \ + len >= cilen && \ + p[0] == opt) { \ + u32_t l; \ + len -= cilen; \ + INCPTR(2, p); \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + /* Check rejected value. */ \ + if (cilong != val) \ + goto bad; \ + try_.neg = 0; \ + } + +#if LWIP_DNS +#define REJCIDNS(opt, neg, dnsaddr) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_ADDR) && \ + len >= cilen && \ + p[0] == opt) { \ + u32_t l; \ + len -= cilen; \ + INCPTR(2, p); \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + /* Check rejected value. */ \ + if (cilong != dnsaddr) \ + goto bad; \ + try_.neg = 0; \ + } +#endif /* LWIP_DNS */ + +#if 0 /* UNUSED - WINS */ +#define REJCIWINS(opt, addr) \ + if (addr && \ + ((cilen = p[1]) == CILEN_ADDR) && \ + len >= cilen && \ + p[0] == opt) { \ + u32_t l; \ + len -= cilen; \ + INCPTR(2, p); \ + GETLONG(l, p); \ + cilong = lwip_htonl(l); \ + /* Check rejected value. */ \ + if (cilong != addr) \ + goto bad; \ + try_.winsaddr[opt == CI_MS_WINS2] = 0; \ + } +#endif /* UNUSED - WINS */ + + REJCIADDRS(CI_ADDRS, !go->neg_addr && go->old_addrs, + go->ouraddr, go->hisaddr); + +#if VJ_SUPPORT + REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol, go->old_vj, + go->maxslotindex, go->cflag); +#endif /* VJ_SUPPORT */ + + REJCIADDR(CI_ADDR, neg_addr, go->ouraddr); + +#if LWIP_DNS + REJCIDNS(CI_MS_DNS1, req_dns1, go->dnsaddr[0]); + + REJCIDNS(CI_MS_DNS2, req_dns2, go->dnsaddr[1]); +#endif /* LWIP_DNS */ + +#if 0 /* UNUSED - WINS */ + REJCIWINS(CI_MS_WINS1, go->winsaddr[0]); + + REJCIWINS(CI_MS_WINS2, go->winsaddr[1]); +#endif /* UNUSED - WINS */ + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + /* + * Now we can update state. + */ + if (f->state != PPP_FSM_OPENED) + *go = try_; + return 1; + +bad: + IPCPDEBUG(("ipcp_rejci: received bad Reject!")); + return 0; +} + + +/* + * ipcp_reqci - Check the peer's requested CIs and send appropriate response. + * Callback from fsm_rconfreq, Receive Configure Request + * + * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified + * appropriately. If reject_if_disagree is non-zero, doesn't return + * CONFNAK; returns CONFREJ if it can't return CONFACK. + * + * inp = Requested CIs + * len = Length of requested CIs + */ +static int ipcp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) { + ppp_pcb *pcb = f->pcb; + ipcp_options *wo = &pcb->ipcp_wantoptions; + ipcp_options *ho = &pcb->ipcp_hisoptions; + ipcp_options *ao = &pcb->ipcp_allowoptions; + u_char *cip, *next; /* Pointer to current and next CIs */ + u_short cilen, citype; /* Parsed len, type */ +#if VJ_SUPPORT + u_short cishort; /* Parsed short value */ +#endif /* VJ_SUPPORT */ + u32_t tl, ciaddr1, ciaddr2;/* Parsed address values */ + int rc = CONFACK; /* Final packet return code */ + int orc; /* Individual option return code */ + u_char *p; /* Pointer to next char to parse */ + u_char *ucp = inp; /* Pointer to current output char */ + int l = *len; /* Length left */ +#if VJ_SUPPORT + u_char maxslotindex, cflag; +#endif /* VJ_SUPPORT */ +#if LWIP_DNS + int d; +#endif /* LWIP_DNS */ + + /* + * Reset all his options. + */ + BZERO(ho, sizeof(*ho)); + + /* + * Process all his options. + */ + next = inp; + while (l) { + orc = CONFACK; /* Assume success */ + cip = p = next; /* Remember begining of CI */ + if (l < 2 || /* Not enough data for CI header or */ + p[1] < 2 || /* CI length too small or */ + p[1] > l) { /* CI length too big? */ + IPCPDEBUG(("ipcp_reqci: bad CI length!")); + orc = CONFREJ; /* Reject bad CI */ + cilen = l; /* Reject till end of packet */ + l = 0; /* Don't loop again */ + goto endswitch; + } + GETCHAR(citype, p); /* Parse CI type */ + GETCHAR(cilen, p); /* Parse CI length */ + l -= cilen; /* Adjust remaining length */ + next += cilen; /* Step to next CI */ + + switch (citype) { /* Check CI type */ + case CI_ADDRS: + if (!ao->old_addrs || ho->neg_addr || + cilen != CILEN_ADDRS) { /* Check CI length */ + orc = CONFREJ; /* Reject CI */ + break; + } + + /* + * If he has no address, or if we both have his address but + * disagree about it, then NAK it with our idea. + * In particular, if we don't know his address, but he does, + * then accept it. + */ + GETLONG(tl, p); /* Parse source address (his) */ + ciaddr1 = lwip_htonl(tl); + if (ciaddr1 != wo->hisaddr + && (ciaddr1 == 0 || !wo->accept_remote)) { + orc = CONFNAK; + if (!reject_if_disagree) { + DECPTR(sizeof(u32_t), p); + tl = lwip_ntohl(wo->hisaddr); + PUTLONG(tl, p); + } + } else if (ciaddr1 == 0 && wo->hisaddr == 0) { + /* + * If neither we nor he knows his address, reject the option. + */ + orc = CONFREJ; + wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */ + break; + } + + /* + * If he doesn't know our address, or if we both have our address + * but disagree about it, then NAK it with our idea. + */ + GETLONG(tl, p); /* Parse desination address (ours) */ + ciaddr2 = lwip_htonl(tl); + if (ciaddr2 != wo->ouraddr) { + if (ciaddr2 == 0 || !wo->accept_local) { + orc = CONFNAK; + if (!reject_if_disagree) { + DECPTR(sizeof(u32_t), p); + tl = lwip_ntohl(wo->ouraddr); + PUTLONG(tl, p); + } + } else { + wo->ouraddr = ciaddr2; /* accept peer's idea */ + } + } + + ho->old_addrs = 1; + ho->hisaddr = ciaddr1; + ho->ouraddr = ciaddr2; + break; + + case CI_ADDR: + if (!ao->neg_addr || ho->old_addrs || + cilen != CILEN_ADDR) { /* Check CI length */ + orc = CONFREJ; /* Reject CI */ + break; + } + + /* + * If he has no address, or if we both have his address but + * disagree about it, then NAK it with our idea. + * In particular, if we don't know his address, but he does, + * then accept it. + */ + GETLONG(tl, p); /* Parse source address (his) */ + ciaddr1 = lwip_htonl(tl); + if (ciaddr1 != wo->hisaddr + && (ciaddr1 == 0 || !wo->accept_remote)) { + orc = CONFNAK; + if (!reject_if_disagree) { + DECPTR(sizeof(u32_t), p); + tl = lwip_ntohl(wo->hisaddr); + PUTLONG(tl, p); + } + } else if (ciaddr1 == 0 && wo->hisaddr == 0) { + /* + * Don't ACK an address of 0.0.0.0 - reject it instead. + */ + orc = CONFREJ; + wo->req_addr = 0; /* don't NAK with 0.0.0.0 later */ + break; + } + + ho->neg_addr = 1; + ho->hisaddr = ciaddr1; + break; + +#if LWIP_DNS + case CI_MS_DNS1: + case CI_MS_DNS2: + /* Microsoft primary or secondary DNS request */ + d = citype == CI_MS_DNS2; + + /* If we do not have a DNS address then we cannot send it */ + if (ao->dnsaddr[d] == 0 || + cilen != CILEN_ADDR) { /* Check CI length */ + orc = CONFREJ; /* Reject CI */ + break; + } + GETLONG(tl, p); + if (lwip_htonl(tl) != ao->dnsaddr[d]) { + DECPTR(sizeof(u32_t), p); + tl = lwip_ntohl(ao->dnsaddr[d]); + PUTLONG(tl, p); + orc = CONFNAK; + } + break; +#endif /* LWIP_DNS */ + +#if 0 /* UNUSED - WINS */ + case CI_MS_WINS1: + case CI_MS_WINS2: + /* Microsoft primary or secondary WINS request */ + d = citype == CI_MS_WINS2; + + /* If we do not have a DNS address then we cannot send it */ + if (ao->winsaddr[d] == 0 || + cilen != CILEN_ADDR) { /* Check CI length */ + orc = CONFREJ; /* Reject CI */ + break; + } + GETLONG(tl, p); + if (lwip_htonl(tl) != ao->winsaddr[d]) { + DECPTR(sizeof(u32_t), p); + tl = lwip_ntohl(ao->winsaddr[d]); + PUTLONG(tl, p); + orc = CONFNAK; + } + break; +#endif /* UNUSED - WINS */ + +#if VJ_SUPPORT + case CI_COMPRESSTYPE: + if (!ao->neg_vj || + (cilen != CILEN_VJ && cilen != CILEN_COMPRESS)) { + orc = CONFREJ; + break; + } + GETSHORT(cishort, p); + + if (!(cishort == IPCP_VJ_COMP || + (cishort == IPCP_VJ_COMP_OLD && cilen == CILEN_COMPRESS))) { + orc = CONFREJ; + break; + } + + ho->neg_vj = 1; + ho->vj_protocol = cishort; + if (cilen == CILEN_VJ) { + GETCHAR(maxslotindex, p); + if (maxslotindex > ao->maxslotindex) { + orc = CONFNAK; + if (!reject_if_disagree){ + DECPTR(1, p); + PUTCHAR(ao->maxslotindex, p); + } + } + GETCHAR(cflag, p); + if (cflag && !ao->cflag) { + orc = CONFNAK; + if (!reject_if_disagree){ + DECPTR(1, p); + PUTCHAR(wo->cflag, p); + } + } + ho->maxslotindex = maxslotindex; + ho->cflag = cflag; + } else { + ho->old_vj = 1; + ho->maxslotindex = MAX_STATES - 1; + ho->cflag = 1; + } + break; +#endif /* VJ_SUPPORT */ + + default: + orc = CONFREJ; + break; + } +endswitch: + if (orc == CONFACK && /* Good CI */ + rc != CONFACK) /* but prior CI wasnt? */ + continue; /* Don't send this one */ + + if (orc == CONFNAK) { /* Nak this CI? */ + if (reject_if_disagree) /* Getting fed up with sending NAKs? */ + orc = CONFREJ; /* Get tough if so */ + else { + if (rc == CONFREJ) /* Rejecting prior CI? */ + continue; /* Don't send this one */ + if (rc == CONFACK) { /* Ack'd all prior CIs? */ + rc = CONFNAK; /* Not anymore... */ + ucp = inp; /* Backup */ + } + } + } + + if (orc == CONFREJ && /* Reject this CI */ + rc != CONFREJ) { /* but no prior ones? */ + rc = CONFREJ; + ucp = inp; /* Backup */ + } + + /* Need to move CI? */ + if (ucp != cip) + MEMCPY(ucp, cip, cilen); /* Move it */ + + /* Update output pointer */ + INCPTR(cilen, ucp); + } + + /* + * If we aren't rejecting this packet, and we want to negotiate + * their address, and they didn't send their address, then we + * send a NAK with a CI_ADDR option appended. We assume the + * input buffer is long enough that we can append the extra + * option safely. + */ + if (rc != CONFREJ && !ho->neg_addr && !ho->old_addrs && + wo->req_addr && !reject_if_disagree && !pcb->settings.noremoteip) { + if (rc == CONFACK) { + rc = CONFNAK; + ucp = inp; /* reset pointer */ + wo->req_addr = 0; /* don't ask again */ + } + PUTCHAR(CI_ADDR, ucp); + PUTCHAR(CILEN_ADDR, ucp); + tl = lwip_ntohl(wo->hisaddr); + PUTLONG(tl, ucp); + } + + *len = ucp - inp; /* Compute output length */ + IPCPDEBUG(("ipcp: returning Configure-%s", CODENAME(rc))); + return (rc); /* Return final code */ +} + + +#if 0 /* UNUSED */ +/* + * ip_check_options - check that any IP-related options are OK, + * and assign appropriate defaults. + */ +static void +ip_check_options() +{ + struct hostent *hp; + u32_t local; + ipcp_options *wo = &ipcp_wantoptions[0]; + + /* + * Default our local IP address based on our hostname. + * If local IP address already given, don't bother. + */ + if (wo->ouraddr == 0 && !disable_defaultip) { + /* + * Look up our hostname (possibly with domain name appended) + * and take the first IP address as our local IP address. + * If there isn't an IP address for our hostname, too bad. + */ + wo->accept_local = 1; /* don't insist on this default value */ + if ((hp = gethostbyname(hostname)) != NULL) { + local = *(u32_t *)hp->h_addr; + if (local != 0 && !bad_ip_adrs(local)) + wo->ouraddr = local; + } + } + ask_for_local = wo->ouraddr != 0 || !disable_defaultip; +} +#endif /* UNUSED */ + +#if DEMAND_SUPPORT +/* + * ip_demand_conf - configure the interface as though + * IPCP were up, for use with dial-on-demand. + */ +static int +ip_demand_conf(u) + int u; +{ + ppp_pcb *pcb = &ppp_pcb_list[u]; + ipcp_options *wo = &ipcp_wantoptions[u]; + + if (wo->hisaddr == 0 && !pcb->settings.noremoteip) { + /* make up an arbitrary address for the peer */ + wo->hisaddr = lwip_htonl(0x0a707070 + ifunit); + wo->accept_remote = 1; + } + if (wo->ouraddr == 0) { + /* make up an arbitrary address for us */ + wo->ouraddr = lwip_htonl(0x0a404040 + ifunit); + wo->accept_local = 1; + ask_for_local = 0; /* don't tell the peer this address */ + } + if (!sifaddr(pcb, wo->ouraddr, wo->hisaddr, get_mask(wo->ouraddr))) + return 0; + if (!sifup(pcb)) + return 0; + if (!sifnpmode(pcb, PPP_IP, NPMODE_QUEUE)) + return 0; +#if 0 /* UNUSED */ + if (wo->default_route) + if (sifdefaultroute(pcb, wo->ouraddr, wo->hisaddr, + wo->replace_default_route)) + default_route_set[u] = 1; +#endif /* UNUSED */ +#if 0 /* UNUSED - PROXY ARP */ + if (wo->proxy_arp) + if (sifproxyarp(pcb, wo->hisaddr)) + proxy_arp_set[u] = 1; +#endif /* UNUSED - PROXY ARP */ + + ppp_notice("local IP address %I", wo->ouraddr); + if (wo->hisaddr) + ppp_notice("remote IP address %I", wo->hisaddr); + + return 1; +} +#endif /* DEMAND_SUPPORT */ + +/* + * ipcp_up - IPCP has come UP. + * + * Configure the IP network interface appropriately and bring it up. + */ +static void ipcp_up(fsm *f) { + ppp_pcb *pcb = f->pcb; + u32_t mask; + ipcp_options *ho = &pcb->ipcp_hisoptions; + ipcp_options *go = &pcb->ipcp_gotoptions; + ipcp_options *wo = &pcb->ipcp_wantoptions; + + IPCPDEBUG(("ipcp: up")); + + /* + * We must have a non-zero IP address for both ends of the link. + */ + if (!ho->neg_addr && !ho->old_addrs) + ho->hisaddr = wo->hisaddr; + + if (!(go->neg_addr || go->old_addrs) && (wo->neg_addr || wo->old_addrs) + && wo->ouraddr != 0) { + ppp_error("Peer refused to agree to our IP address"); + ipcp_close(f->pcb, "Refused our IP address"); + return; + } + if (go->ouraddr == 0) { + ppp_error("Could not determine local IP address"); + ipcp_close(f->pcb, "Could not determine local IP address"); + return; + } + if (ho->hisaddr == 0 && !pcb->settings.noremoteip) { + ho->hisaddr = lwip_htonl(0x0a404040); + ppp_warn("Could not determine remote IP address: defaulting to %I", + ho->hisaddr); + } +#if 0 /* UNUSED */ + script_setenv("IPLOCAL", ip_ntoa(go->ouraddr), 0); + if (ho->hisaddr != 0) + script_setenv("IPREMOTE", ip_ntoa(ho->hisaddr), 1); +#endif /* UNUSED */ + +#if LWIP_DNS + if (!go->req_dns1) + go->dnsaddr[0] = 0; + if (!go->req_dns2) + go->dnsaddr[1] = 0; +#if 0 /* UNUSED */ + if (go->dnsaddr[0]) + script_setenv("DNS1", ip_ntoa(go->dnsaddr[0]), 0); + if (go->dnsaddr[1]) + script_setenv("DNS2", ip_ntoa(go->dnsaddr[1]), 0); +#endif /* UNUSED */ + if (pcb->settings.usepeerdns && (go->dnsaddr[0] || go->dnsaddr[1])) { + sdns(pcb, go->dnsaddr[0], go->dnsaddr[1]); +#if 0 /* UNUSED */ + script_setenv("USEPEERDNS", "1", 0); + create_resolv(go->dnsaddr[0], go->dnsaddr[1]); +#endif /* UNUSED */ + } +#endif /* LWIP_DNS */ + + /* + * Check that the peer is allowed to use the IP address it wants. + */ + if (ho->hisaddr != 0) { + u32_t addr = lwip_ntohl(ho->hisaddr); + if ((addr >> IP_CLASSA_NSHIFT) == IP_LOOPBACKNET + || IP_MULTICAST(addr) || IP_BADCLASS(addr) + /* + * For now, consider that PPP in server mode with peer required + * to authenticate must provide the peer IP address, reject any + * IP address wanted by peer different than the one we wanted. + */ +#if PPP_SERVER && PPP_AUTH_SUPPORT + || (pcb->settings.auth_required && wo->hisaddr != ho->hisaddr) +#endif /* PPP_SERVER && PPP_AUTH_SUPPORT */ + ) { + ppp_error("Peer is not authorized to use remote address %I", ho->hisaddr); + ipcp_close(pcb, "Unauthorized remote IP address"); + return; + } + } +#if 0 /* Unused */ + /* Upstream checking code */ + if (ho->hisaddr != 0 && !auth_ip_addr(f->unit, ho->hisaddr)) { + ppp_error("Peer is not authorized to use remote address %I", ho->hisaddr); + ipcp_close(f->unit, "Unauthorized remote IP address"); + return; + } +#endif /* Unused */ + +#if VJ_SUPPORT + /* set tcp compression */ + sifvjcomp(pcb, ho->neg_vj, ho->cflag, ho->maxslotindex); +#endif /* VJ_SUPPORT */ + +#if DEMAND_SUPPORT + /* + * If we are doing dial-on-demand, the interface is already + * configured, so we put out any saved-up packets, then set the + * interface to pass IP packets. + */ + if (demand) { + if (go->ouraddr != wo->ouraddr || ho->hisaddr != wo->hisaddr) { + ipcp_clear_addrs(f->unit, wo->ouraddr, wo->hisaddr, + wo->replace_default_route); + if (go->ouraddr != wo->ouraddr) { + ppp_warn("Local IP address changed to %I", go->ouraddr); + script_setenv("OLDIPLOCAL", ip_ntoa(wo->ouraddr), 0); + wo->ouraddr = go->ouraddr; + } else + script_unsetenv("OLDIPLOCAL"); + if (ho->hisaddr != wo->hisaddr && wo->hisaddr != 0) { + ppp_warn("Remote IP address changed to %I", ho->hisaddr); + script_setenv("OLDIPREMOTE", ip_ntoa(wo->hisaddr), 0); + wo->hisaddr = ho->hisaddr; + } else + script_unsetenv("OLDIPREMOTE"); + + /* Set the interface to the new addresses */ + mask = get_mask(go->ouraddr); + if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { +#if PPP_DEBUG + ppp_warn("Interface configuration failed"); +#endif /* PPP_DEBUG */ + ipcp_close(f->unit, "Interface configuration failed"); + return; + } + + /* assign a default route through the interface if required */ + if (ipcp_wantoptions[f->unit].default_route) + if (sifdefaultroute(pcb, go->ouraddr, ho->hisaddr, + wo->replace_default_route)) + default_route_set[f->unit] = 1; + +#if 0 /* UNUSED - PROXY ARP */ + /* Make a proxy ARP entry if requested. */ + if (ho->hisaddr != 0 && ipcp_wantoptions[f->unit].proxy_arp) + if (sifproxyarp(pcb, ho->hisaddr)) + proxy_arp_set[f->unit] = 1; +#endif /* UNUSED - PROXY ARP */ + + } + demand_rexmit(PPP_IP,go->ouraddr); + sifnpmode(pcb, PPP_IP, NPMODE_PASS); + + } else +#endif /* DEMAND_SUPPORT */ + { + /* + * Set IP addresses and (if specified) netmask. + */ + mask = get_mask(go->ouraddr); + +#if !(defined(SVR4) && (defined(SNI) || defined(__USLC__))) + if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { +#if PPP_DEBUG + ppp_warn("Interface configuration failed"); +#endif /* PPP_DEBUG */ + ipcp_close(f->pcb, "Interface configuration failed"); + return; + } +#endif + + /* bring the interface up for IP */ + if (!sifup(pcb)) { +#if PPP_DEBUG + ppp_warn("Interface failed to come up"); +#endif /* PPP_DEBUG */ + ipcp_close(f->pcb, "Interface configuration failed"); + return; + } + +#if (defined(SVR4) && (defined(SNI) || defined(__USLC__))) + if (!sifaddr(pcb, go->ouraddr, ho->hisaddr, mask)) { +#if PPP_DEBUG + ppp_warn("Interface configuration failed"); +#endif /* PPP_DEBUG */ + ipcp_close(f->unit, "Interface configuration failed"); + return; + } +#endif +#if DEMAND_SUPPORT + sifnpmode(pcb, PPP_IP, NPMODE_PASS); +#endif /* DEMAND_SUPPORT */ + +#if 0 /* UNUSED */ + /* assign a default route through the interface if required */ + if (wo->default_route) + if (sifdefaultroute(pcb, go->ouraddr, ho->hisaddr, + wo->replace_default_route)) + pcb->default_route_set = 1; +#endif /* UNUSED */ + +#if 0 /* UNUSED - PROXY ARP */ + /* Make a proxy ARP entry if requested. */ + if (ho->hisaddr != 0 && wo->proxy_arp) + if (sifproxyarp(pcb, ho->hisaddr)) + pcb->proxy_arp_set = 1; +#endif /* UNUSED - PROXY ARP */ + + wo->ouraddr = go->ouraddr; + + ppp_notice("local IP address %I", go->ouraddr); + if (ho->hisaddr != 0) + ppp_notice("remote IP address %I", ho->hisaddr); +#if LWIP_DNS + if (go->dnsaddr[0]) + ppp_notice("primary DNS address %I", go->dnsaddr[0]); + if (go->dnsaddr[1]) + ppp_notice("secondary DNS address %I", go->dnsaddr[1]); +#endif /* LWIP_DNS */ + } + +#if PPP_STATS_SUPPORT + reset_link_stats(f->unit); +#endif /* PPP_STATS_SUPPORT */ + + np_up(pcb, PPP_IP); + pcb->ipcp_is_up = 1; + +#if PPP_NOTIFY + notify(ip_up_notifier, 0); +#endif /* PPP_NOTIFY */ +#if 0 /* UNUSED */ + if (ip_up_hook) + ip_up_hook(); +#endif /* UNUSED */ +} + + +/* + * ipcp_down - IPCP has gone DOWN. + * + * Take the IP network interface down, clear its addresses + * and delete routes through it. + */ +static void ipcp_down(fsm *f) { + ppp_pcb *pcb = f->pcb; + ipcp_options *ho = &pcb->ipcp_hisoptions; + ipcp_options *go = &pcb->ipcp_gotoptions; + + IPCPDEBUG(("ipcp: down")); +#if PPP_STATS_SUPPORT + /* XXX a bit IPv4-centric here, we only need to get the stats + * before the interface is marked down. */ + /* XXX more correct: we must get the stats before running the notifiers, + * at least for the radius plugin */ + update_link_stats(f->unit); +#endif /* PPP_STATS_SUPPORT */ +#if PPP_NOTIFY + notify(ip_down_notifier, 0); +#endif /* PPP_NOTIFY */ +#if 0 /* UNUSED */ + if (ip_down_hook) + ip_down_hook(); +#endif /* UNUSED */ + if (pcb->ipcp_is_up) { + pcb->ipcp_is_up = 0; + np_down(pcb, PPP_IP); + } +#if VJ_SUPPORT + sifvjcomp(pcb, 0, 0, 0); +#endif /* VJ_SUPPORT */ + +#if PPP_STATS_SUPPORT + print_link_stats(); /* _after_ running the notifiers and ip_down_hook(), + * because print_link_stats() sets link_stats_valid + * to 0 (zero) */ +#endif /* PPP_STATS_SUPPORT */ + +#if DEMAND_SUPPORT + /* + * If we are doing dial-on-demand, set the interface + * to queue up outgoing packets (for now). + */ + if (demand) { + sifnpmode(pcb, PPP_IP, NPMODE_QUEUE); + } else +#endif /* DEMAND_SUPPORT */ + { +#if DEMAND_SUPPORT + sifnpmode(pcb, PPP_IP, NPMODE_DROP); +#endif /* DEMAND_SUPPORT */ + sifdown(pcb); + ipcp_clear_addrs(pcb, go->ouraddr, + ho->hisaddr, 0); +#if LWIP_DNS + cdns(pcb, go->dnsaddr[0], go->dnsaddr[1]); +#endif /* LWIP_DNS */ + } +} + + +/* + * ipcp_clear_addrs() - clear the interface addresses, routes, + * proxy arp entries, etc. + */ +static void ipcp_clear_addrs(ppp_pcb *pcb, u32_t ouraddr, u32_t hisaddr, u8_t replacedefaultroute) { + LWIP_UNUSED_ARG(replacedefaultroute); + +#if 0 /* UNUSED - PROXY ARP */ + if (pcb->proxy_arp_set) { + cifproxyarp(pcb, hisaddr); + pcb->proxy_arp_set = 0; + } +#endif /* UNUSED - PROXY ARP */ +#if 0 /* UNUSED */ + /* If replacedefaultroute, sifdefaultroute will be called soon + * with replacedefaultroute set and that will overwrite the current + * default route. This is the case only when doing demand, otherwise + * during demand, this cifdefaultroute would restore the old default + * route which is not what we want in this case. In the non-demand + * case, we'll delete the default route and restore the old if there + * is one saved by an sifdefaultroute with replacedefaultroute. + */ + if (!replacedefaultroute && pcb->default_route_set) { + cifdefaultroute(pcb, ouraddr, hisaddr); + pcb->default_route_set = 0; + } +#endif /* UNUSED */ + cifaddr(pcb, ouraddr, hisaddr); +} + + +/* + * ipcp_finished - possibly shut down the lower layers. + */ +static void ipcp_finished(fsm *f) { + ppp_pcb *pcb = f->pcb; + if (pcb->ipcp_is_open) { + pcb->ipcp_is_open = 0; + np_finished(pcb, PPP_IP); + } +} + + +#if 0 /* UNUSED */ +/* + * create_resolv - create the replacement resolv.conf file + */ +static void +create_resolv(peerdns1, peerdns2) + u32_t peerdns1, peerdns2; +{ + +} +#endif /* UNUSED */ + +#if PRINTPKT_SUPPORT +/* + * ipcp_printpkt - print the contents of an IPCP packet. + */ +static const char* const ipcp_codenames[] = { + "ConfReq", "ConfAck", "ConfNak", "ConfRej", + "TermReq", "TermAck", "CodeRej" +}; + +static int ipcp_printpkt(const u_char *p, int plen, + void (*printer) (void *, const char *, ...), void *arg) { + int code, id, len, olen; + const u_char *pstart, *optend; +#if VJ_SUPPORT + u_short cishort; +#endif /* VJ_SUPPORT */ + u32_t cilong; + + if (plen < HEADERLEN) + return 0; + pstart = p; + GETCHAR(code, p); + GETCHAR(id, p); + GETSHORT(len, p); + if (len < HEADERLEN || len > plen) + return 0; + + if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(ipcp_codenames)) + printer(arg, " %s", ipcp_codenames[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= HEADERLEN; + switch (code) { + case CONFREQ: + case CONFACK: + case CONFNAK: + case CONFREJ: + /* print option list */ + while (len >= 2) { + GETCHAR(code, p); + GETCHAR(olen, p); + p -= 2; + if (olen < 2 || olen > len) { + break; + } + printer(arg, " <"); + len -= olen; + optend = p + olen; + switch (code) { + case CI_ADDRS: + if (olen == CILEN_ADDRS) { + p += 2; + GETLONG(cilong, p); + printer(arg, "addrs %I", lwip_htonl(cilong)); + GETLONG(cilong, p); + printer(arg, " %I", lwip_htonl(cilong)); + } + break; +#if VJ_SUPPORT + case CI_COMPRESSTYPE: + if (olen >= CILEN_COMPRESS) { + p += 2; + GETSHORT(cishort, p); + printer(arg, "compress "); + switch (cishort) { + case IPCP_VJ_COMP: + printer(arg, "VJ"); + break; + case IPCP_VJ_COMP_OLD: + printer(arg, "old-VJ"); + break; + default: + printer(arg, "0x%x", cishort); + } + } + break; +#endif /* VJ_SUPPORT */ + case CI_ADDR: + if (olen == CILEN_ADDR) { + p += 2; + GETLONG(cilong, p); + printer(arg, "addr %I", lwip_htonl(cilong)); + } + break; +#if LWIP_DNS + case CI_MS_DNS1: + case CI_MS_DNS2: + p += 2; + GETLONG(cilong, p); + printer(arg, "ms-dns%d %I", (code == CI_MS_DNS1? 1: 2), + htonl(cilong)); + break; +#endif /* LWIP_DNS */ +#if 0 /* UNUSED - WINS */ + case CI_MS_WINS1: + case CI_MS_WINS2: + p += 2; + GETLONG(cilong, p); + printer(arg, "ms-wins %I", lwip_htonl(cilong)); + break; +#endif /* UNUSED - WINS */ + default: + break; + } + while (p < optend) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + printer(arg, ">"); + } + break; + + case TERMACK: + case TERMREQ: + if (len > 0 && *p >= ' ' && *p < 0x7f) { + printer(arg, " "); + ppp_print_string(p, len, printer, arg); + p += len; + len = 0; + } + break; + default: + break; + } + + /* print the rest of the bytes in the packet */ + for (; len > 0; --len) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + + return p - pstart; +} +#endif /* PRINTPKT_SUPPORT */ + +#if DEMAND_SUPPORT +/* + * ip_active_pkt - see if this IP packet is worth bringing the link up for. + * We don't bring the link up for IP fragments or for TCP FIN packets + * with no data. + */ +#define IP_HDRLEN 20 /* bytes */ +#define IP_OFFMASK 0x1fff +#ifndef IPPROTO_TCP +#define IPPROTO_TCP 6 +#endif +#define TCP_HDRLEN 20 +#define TH_FIN 0x01 + +/* + * We use these macros because the IP header may be at an odd address, + * and some compilers might use word loads to get th_off or ip_hl. + */ + +#define net_short(x) (((x)[0] << 8) + (x)[1]) +#define get_iphl(x) (((unsigned char *)(x))[0] & 0xF) +#define get_ipoff(x) net_short((unsigned char *)(x) + 6) +#define get_ipproto(x) (((unsigned char *)(x))[9]) +#define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4) +#define get_tcpflags(x) (((unsigned char *)(x))[13]) + +static int +ip_active_pkt(pkt, len) + u_char *pkt; + int len; +{ + u_char *tcp; + int hlen; + + len -= PPP_HDRLEN; + pkt += PPP_HDRLEN; + if (len < IP_HDRLEN) + return 0; + if ((get_ipoff(pkt) & IP_OFFMASK) != 0) + return 0; + if (get_ipproto(pkt) != IPPROTO_TCP) + return 1; + hlen = get_iphl(pkt) * 4; + if (len < hlen + TCP_HDRLEN) + return 0; + tcp = pkt + hlen; + if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == hlen + get_tcpoff(tcp) * 4) + return 0; + return 1; +} +#endif /* DEMAND_SUPPORT */ + +#endif /* PPP_SUPPORT && PPP_IPV4_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipv6cp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipv6cp.c index e7d81c9d..11c18df7 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipv6cp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ipv6cp.c @@ -1,1533 +1,1533 @@ -/* - * ipv6cp.c - PPP IPV6 Control Protocol. - * - * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Tommi Komulainen - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - */ - -/* Original version, based on RFC2023 : - - Copyright (c) 1995, 1996, 1997 Francis.Dupont@inria.fr, INRIA Rocquencourt, - Alain.Durand@imag.fr, IMAG, - Jean-Luc.Richier@imag.fr, IMAG-LSR. - - Copyright (c) 1998, 1999 Francis.Dupont@inria.fr, GIE DYADE, - Alain.Durand@imag.fr, IMAG, - Jean-Luc.Richier@imag.fr, IMAG-LSR. - - Ce travail a été fait au sein du GIE DYADE (Groupement d'Intérêt - Économique ayant pour membres BULL S.A. et l'INRIA). - - Ce logiciel informatique est disponible aux conditions - usuelles dans la recherche, c'est-à-dire qu'il peut - être utilisé, copié, modifié, distribué à l'unique - condition que ce texte soit conservé afin que - l'origine de ce logiciel soit reconnue. - - Le nom de l'Institut National de Recherche en Informatique - et en Automatique (INRIA), de l'IMAG, ou d'une personne morale - ou physique ayant participé à l'élaboration de ce logiciel ne peut - être utilisé sans son accord préalable explicite. - - Ce logiciel est fourni tel quel sans aucune garantie, - support ou responsabilité d'aucune sorte. - Ce logiciel est dérivé de sources d'origine - "University of California at Berkeley" et - "Digital Equipment Corporation" couvertes par des copyrights. - - L'Institut d'Informatique et de Mathématiques Appliquées de Grenoble (IMAG) - est une fédération d'unités mixtes de recherche du CNRS, de l'Institut National - Polytechnique de Grenoble et de l'Université Joseph Fourier regroupant - sept laboratoires dont le laboratoire Logiciels, Systèmes, Réseaux (LSR). - - This work has been done in the context of GIE DYADE (joint R & D venture - between BULL S.A. and INRIA). - - This software is available with usual "research" terms - with the aim of retain credits of the software. - Permission to use, copy, modify and distribute this software for any - purpose and without fee is hereby granted, provided that the above - copyright notice and this permission notice appear in all copies, - and the name of INRIA, IMAG, or any contributor not be used in advertising - or publicity pertaining to this material without the prior explicit - permission. The software is provided "as is" without any - warranties, support or liabilities of any kind. - This software is derived from source code from - "University of California at Berkeley" and - "Digital Equipment Corporation" protected by copyrights. - - Grenoble's Institute of Computer Science and Applied Mathematics (IMAG) - is a federation of seven research units funded by the CNRS, National - Polytechnic Institute of Grenoble and University Joseph Fourier. - The research unit in Software, Systems, Networks (LSR) is member of IMAG. -*/ - -/* - * Derived from : - * - * - * ipcp.c - PPP IP Control Protocol. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - * - * $Id: ipv6cp.c,v 1.21 2005/08/25 23:59:34 paulus Exp $ - */ - -/* - * @todo: - * - * Proxy Neighbour Discovery. - * - * Better defines for selecting the ordering of - * interface up / set address. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#if 0 /* UNUSED */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/fsm.h" -#include "netif/ppp/ipcp.h" -#include "netif/ppp/ipv6cp.h" -#include "netif/ppp/magic.h" - -/* global vars */ -#if 0 /* UNUSED */ -int no_ifaceid_neg = 0; -#endif /* UNUSED */ - -/* - * Callbacks for fsm code. (CI = Configuration Information) - */ -static void ipv6cp_resetci(fsm *f); /* Reset our CI */ -static int ipv6cp_cilen(fsm *f); /* Return length of our CI */ -static void ipv6cp_addci(fsm *f, u_char *ucp, int *lenp); /* Add our CI */ -static int ipv6cp_ackci(fsm *f, u_char *p, int len); /* Peer ack'd our CI */ -static int ipv6cp_nakci(fsm *f, u_char *p, int len, int treat_as_reject); /* Peer nak'd our CI */ -static int ipv6cp_rejci(fsm *f, u_char *p, int len); /* Peer rej'd our CI */ -static int ipv6cp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree); /* Rcv CI */ -static void ipv6cp_up(fsm *f); /* We're UP */ -static void ipv6cp_down(fsm *f); /* We're DOWN */ -static void ipv6cp_finished(fsm *f); /* Don't need lower layer */ - -static const fsm_callbacks ipv6cp_callbacks = { /* IPV6CP callback routines */ - ipv6cp_resetci, /* Reset our Configuration Information */ - ipv6cp_cilen, /* Length of our Configuration Information */ - ipv6cp_addci, /* Add our Configuration Information */ - ipv6cp_ackci, /* ACK our Configuration Information */ - ipv6cp_nakci, /* NAK our Configuration Information */ - ipv6cp_rejci, /* Reject our Configuration Information */ - ipv6cp_reqci, /* Request peer's Configuration Information */ - ipv6cp_up, /* Called when fsm reaches OPENED state */ - ipv6cp_down, /* Called when fsm leaves OPENED state */ - NULL, /* Called when we want the lower layer up */ - ipv6cp_finished, /* Called when we want the lower layer down */ - NULL, /* Called when Protocol-Reject received */ - NULL, /* Retransmission is necessary */ - NULL, /* Called to handle protocol-specific codes */ - "IPV6CP" /* String name of protocol */ -}; - -#if PPP_OPTIONS -/* - * Command-line options. - */ -static int setifaceid(char **arg)); -static void printifaceid(option_t *, - void (*)(void *, char *, ...), void *)); - -static option_t ipv6cp_option_list[] = { - { "ipv6", o_special, (void *)setifaceid, - "Set interface identifiers for IPV6", - OPT_A2PRINTER, (void *)printifaceid }, - - { "+ipv6", o_bool, &ipv6cp_protent.enabled_flag, - "Enable IPv6 and IPv6CP", OPT_PRIO | 1 }, - { "noipv6", o_bool, &ipv6cp_protent.enabled_flag, - "Disable IPv6 and IPv6CP", OPT_PRIOSUB }, - { "-ipv6", o_bool, &ipv6cp_protent.enabled_flag, - "Disable IPv6 and IPv6CP", OPT_PRIOSUB | OPT_ALIAS }, - - { "ipv6cp-accept-local", o_bool, &ipv6cp_allowoptions[0].accept_local, - "Accept peer's interface identifier for us", 1 }, - - { "ipv6cp-use-ipaddr", o_bool, &ipv6cp_allowoptions[0].use_ip, - "Use (default) IPv4 address as interface identifier", 1 }, - - { "ipv6cp-use-persistent", o_bool, &ipv6cp_wantoptions[0].use_persistent, - "Use uniquely-available persistent value for link local address", 1 }, - - { "ipv6cp-restart", o_int, &ipv6cp_fsm[0].timeouttime, - "Set timeout for IPv6CP", OPT_PRIO }, - { "ipv6cp-max-terminate", o_int, &ipv6cp_fsm[0].maxtermtransmits, - "Set max #xmits for term-reqs", OPT_PRIO }, - { "ipv6cp-max-configure", o_int, &ipv6cp_fsm[0].maxconfreqtransmits, - "Set max #xmits for conf-reqs", OPT_PRIO }, - { "ipv6cp-max-failure", o_int, &ipv6cp_fsm[0].maxnakloops, - "Set max #conf-naks for IPv6CP", OPT_PRIO }, - - { NULL } -}; -#endif /* PPP_OPTIONS */ - -/* - * Protocol entry points from main code. - */ -static void ipv6cp_init(ppp_pcb *pcb); -static void ipv6cp_open(ppp_pcb *pcb); -static void ipv6cp_close(ppp_pcb *pcb, const char *reason); -static void ipv6cp_lowerup(ppp_pcb *pcb); -static void ipv6cp_lowerdown(ppp_pcb *pcb); -static void ipv6cp_input(ppp_pcb *pcb, u_char *p, int len); -static void ipv6cp_protrej(ppp_pcb *pcb); -#if PPP_OPTIONS -static void ipv6_check_options(void); -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT -static int ipv6_demand_conf(int u); -#endif /* DEMAND_SUPPORT */ -#if PRINTPKT_SUPPORT -static int ipv6cp_printpkt(const u_char *p, int plen, - void (*printer)(void *, const char *, ...), void *arg); -#endif /* PRINTPKT_SUPPORT */ -#if DEMAND_SUPPORT -static int ipv6_active_pkt(u_char *pkt, int len); -#endif /* DEMAND_SUPPORT */ - -const struct protent ipv6cp_protent = { - PPP_IPV6CP, - ipv6cp_init, - ipv6cp_input, - ipv6cp_protrej, - ipv6cp_lowerup, - ipv6cp_lowerdown, - ipv6cp_open, - ipv6cp_close, -#if PRINTPKT_SUPPORT - ipv6cp_printpkt, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - NULL, -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "IPV6CP", - "IPV6", -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - ipv6cp_option_list, - ipv6_check_options, -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - ipv6_demand_conf, - ipv6_active_pkt -#endif /* DEMAND_SUPPORT */ -}; - -static void ipv6cp_clear_addrs(ppp_pcb *pcb, eui64_t ourid, eui64_t hisid); -#if 0 /* UNUSED */ -static void ipv6cp_script(char *)); -static void ipv6cp_script_done(void *)); -#endif /* UNUSED */ - -/* - * Lengths of configuration options. - */ -#define CILEN_VOID 2 -#define CILEN_COMPRESS 4 /* length for RFC2023 compress opt. */ -#define CILEN_IFACEID 10 /* RFC2472, interface identifier */ - -#define CODENAME(x) ((x) == CONFACK ? "ACK" : \ - (x) == CONFNAK ? "NAK" : "REJ") - -#if 0 /* UNUSED */ -/* - * This state variable is used to ensure that we don't - * run an ipcp-up/down script while one is already running. - */ -static enum script_state { - s_down, - s_up, -} ipv6cp_script_state; -static pid_t ipv6cp_script_pid; -#endif /* UNUSED */ - -static char *llv6_ntoa(eui64_t ifaceid); - -#if PPP_OPTIONS -/* - * setifaceid - set the interface identifiers manually - */ -static int -setifaceid(argv) - char **argv; -{ - char *comma, *arg, c; - ipv6cp_options *wo = &ipv6cp_wantoptions[0]; - struct in6_addr addr; - static int prio_local, prio_remote; - -#define VALIDID(a) ( (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0)) && \ - (((a).s6_addr32[2] != 0) || ((a).s6_addr32[3] != 0)) ) - - arg = *argv; - if ((comma = strchr(arg, ',')) == NULL) - comma = arg + strlen(arg); - - /* - * If comma first character, then no local identifier - */ - if (comma != arg) { - c = *comma; - *comma = '\0'; - - if (inet_pton(AF_INET6, arg, &addr) == 0 || !VALIDID(addr)) { - option_error("Illegal interface identifier (local): %s", arg); - return 0; - } - - if (option_priority >= prio_local) { - eui64_copy(addr.s6_addr32[2], wo->ourid); - wo->opt_local = 1; - prio_local = option_priority; - } - *comma = c; - } - - /* - * If comma last character, the no remote identifier - */ - if (*comma != 0 && *++comma != '\0') { - if (inet_pton(AF_INET6, comma, &addr) == 0 || !VALIDID(addr)) { - option_error("Illegal interface identifier (remote): %s", comma); - return 0; - } - if (option_priority >= prio_remote) { - eui64_copy(addr.s6_addr32[2], wo->hisid); - wo->opt_remote = 1; - prio_remote = option_priority; - } - } - - if (override_value("+ipv6", option_priority, option_source)) - ipv6cp_protent.enabled_flag = 1; - return 1; -} - -static void -printifaceid(opt, printer, arg) - option_t *opt; - void (*printer)(void *, char *, ...)); - void *arg; -{ - ipv6cp_options *wo = &ipv6cp_wantoptions[0]; - - if (wo->opt_local) - printer(arg, "%s", llv6_ntoa(wo->ourid)); - printer(arg, ","); - if (wo->opt_remote) - printer(arg, "%s", llv6_ntoa(wo->hisid)); -} -#endif /* PPP_OPTIONS */ - -/* - * Make a string representation of a network address. - */ -static char * -llv6_ntoa(eui64_t ifaceid) -{ - static char b[26]; - - sprintf(b, "fe80::%02x%02x:%02x%02x:%02x%02x:%02x%02x", - ifaceid.e8[0], ifaceid.e8[1], ifaceid.e8[2], ifaceid.e8[3], - ifaceid.e8[4], ifaceid.e8[5], ifaceid.e8[6], ifaceid.e8[7]); - - return b; -} - - -/* - * ipv6cp_init - Initialize IPV6CP. - */ -static void ipv6cp_init(ppp_pcb *pcb) { - fsm *f = &pcb->ipv6cp_fsm; - ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; - ipv6cp_options *ao = &pcb->ipv6cp_allowoptions; - - f->pcb = pcb; - f->protocol = PPP_IPV6CP; - f->callbacks = &ipv6cp_callbacks; - fsm_init(f); - -#if 0 /* Not necessary, everything is cleared in ppp_new() */ - memset(wo, 0, sizeof(*wo)); - memset(ao, 0, sizeof(*ao)); -#endif /* 0 */ - - wo->accept_local = 1; - wo->neg_ifaceid = 1; - ao->neg_ifaceid = 1; - -#ifdef IPV6CP_COMP - wo->neg_vj = 1; - ao->neg_vj = 1; - wo->vj_protocol = IPV6CP_COMP; -#endif - -} - - -/* - * ipv6cp_open - IPV6CP is allowed to come up. - */ -static void ipv6cp_open(ppp_pcb *pcb) { - fsm_open(&pcb->ipv6cp_fsm); -} - - -/* - * ipv6cp_close - Take IPV6CP down. - */ -static void ipv6cp_close(ppp_pcb *pcb, const char *reason) { - fsm_close(&pcb->ipv6cp_fsm, reason); -} - - -/* - * ipv6cp_lowerup - The lower layer is up. - */ -static void ipv6cp_lowerup(ppp_pcb *pcb) { - fsm_lowerup(&pcb->ipv6cp_fsm); -} - - -/* - * ipv6cp_lowerdown - The lower layer is down. - */ -static void ipv6cp_lowerdown(ppp_pcb *pcb) { - fsm_lowerdown(&pcb->ipv6cp_fsm); -} - - -/* - * ipv6cp_input - Input IPV6CP packet. - */ -static void ipv6cp_input(ppp_pcb *pcb, u_char *p, int len) { - fsm_input(&pcb->ipv6cp_fsm, p, len); -} - - -/* - * ipv6cp_protrej - A Protocol-Reject was received for IPV6CP. - * - * Pretend the lower layer went down, so we shut up. - */ -static void ipv6cp_protrej(ppp_pcb *pcb) { - fsm_lowerdown(&pcb->ipv6cp_fsm); -} - - -/* - * ipv6cp_resetci - Reset our CI. - */ -static void ipv6cp_resetci(fsm *f) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - ipv6cp_options *ao = &pcb->ipv6cp_allowoptions; - - wo->req_ifaceid = wo->neg_ifaceid && ao->neg_ifaceid; - - if (!wo->opt_local) { - eui64_magic_nz(wo->ourid); - } - - *go = *wo; - eui64_zero(go->hisid); /* last proposed interface identifier */ -} - - -/* - * ipv6cp_cilen - Return length of our CI. - */ -static int ipv6cp_cilen(fsm *f) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - -#ifdef IPV6CP_COMP -#define LENCIVJ(neg) (neg ? CILEN_COMPRESS : 0) -#endif /* IPV6CP_COMP */ -#define LENCIIFACEID(neg) (neg ? CILEN_IFACEID : 0) - - return (LENCIIFACEID(go->neg_ifaceid) + -#ifdef IPV6CP_COMP - LENCIVJ(go->neg_vj) + -#endif /* IPV6CP_COMP */ - 0); -} - - -/* - * ipv6cp_addci - Add our desired CIs to a packet. - */ -static void ipv6cp_addci(fsm *f, u_char *ucp, int *lenp) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - int len = *lenp; - -#ifdef IPV6CP_COMP -#define ADDCIVJ(opt, neg, val) \ - if (neg) { \ - int vjlen = CILEN_COMPRESS; \ - if (len >= vjlen) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(vjlen, ucp); \ - PUTSHORT(val, ucp); \ - len -= vjlen; \ - } else \ - neg = 0; \ - } -#endif /* IPV6CP_COMP */ - -#define ADDCIIFACEID(opt, neg, val1) \ - if (neg) { \ - int idlen = CILEN_IFACEID; \ - if (len >= idlen) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(idlen, ucp); \ - eui64_put(val1, ucp); \ - len -= idlen; \ - } else \ - neg = 0; \ - } - - ADDCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid); - -#ifdef IPV6CP_COMP - ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol); -#endif /* IPV6CP_COMP */ - - *lenp -= len; -} - - -/* - * ipv6cp_ackci - Ack our CIs. - * - * Returns: - * 0 - Ack was bad. - * 1 - Ack was good. - */ -static int ipv6cp_ackci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - u_short cilen, citype; -#ifdef IPV6CP_COMP - u_short cishort; -#endif /* IPV6CP_COMP */ - eui64_t ifaceid; - - /* - * CIs must be in exactly the same order that we sent... - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ - -#ifdef IPV6CP_COMP -#define ACKCIVJ(opt, neg, val) \ - if (neg) { \ - int vjlen = CILEN_COMPRESS; \ - if ((len -= vjlen) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != vjlen || \ - citype != opt) \ - goto bad; \ - GETSHORT(cishort, p); \ - if (cishort != val) \ - goto bad; \ - } -#endif /* IPV6CP_COMP */ - -#define ACKCIIFACEID(opt, neg, val1) \ - if (neg) { \ - int idlen = CILEN_IFACEID; \ - if ((len -= idlen) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != idlen || \ - citype != opt) \ - goto bad; \ - eui64_get(ifaceid, p); \ - if (! eui64_equals(val1, ifaceid)) \ - goto bad; \ - } - - ACKCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid); - -#ifdef IPV6CP_COMP - ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol); -#endif /* IPV6CP_COMP */ - - /* - * If there are any remaining CIs, then this packet is bad. - */ - if (len != 0) - goto bad; - return (1); - -bad: - IPV6CPDEBUG(("ipv6cp_ackci: received bad Ack!")); - return (0); -} - -/* - * ipv6cp_nakci - Peer has sent a NAK for some of our CIs. - * This should not modify any state if the Nak is bad - * or if IPV6CP is in the OPENED state. - * - * Returns: - * 0 - Nak was bad. - * 1 - Nak was good. - */ -static int ipv6cp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - u_char citype, cilen, *next; -#ifdef IPV6CP_COMP - u_short cishort; -#endif /* IPV6CP_COMP */ - eui64_t ifaceid; - ipv6cp_options no; /* options we've seen Naks for */ - ipv6cp_options try_; /* options to request next time */ - - BZERO(&no, sizeof(no)); - try_ = *go; - - /* - * Any Nak'd CIs must be in exactly the same order that we sent. - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ -#define NAKCIIFACEID(opt, neg, code) \ - if (go->neg && \ - len >= (cilen = CILEN_IFACEID) && \ - p[1] == cilen && \ - p[0] == opt) { \ - len -= cilen; \ - INCPTR(2, p); \ - eui64_get(ifaceid, p); \ - no.neg = 1; \ - code \ - } - -#ifdef IPV6CP_COMP -#define NAKCIVJ(opt, neg, code) \ - if (go->neg && \ - ((cilen = p[1]) == CILEN_COMPRESS) && \ - len >= cilen && \ - p[0] == opt) { \ - len -= cilen; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - no.neg = 1; \ - code \ - } -#endif /* IPV6CP_COMP */ - - /* - * Accept the peer's idea of {our,his} interface identifier, if different - * from our idea, only if the accept_{local,remote} flag is set. - */ - NAKCIIFACEID(CI_IFACEID, neg_ifaceid, - if (treat_as_reject) { - try_.neg_ifaceid = 0; - } else if (go->accept_local) { - while (eui64_iszero(ifaceid) || - eui64_equals(ifaceid, go->hisid)) /* bad luck */ - eui64_magic(ifaceid); - try_.ourid = ifaceid; - IPV6CPDEBUG(("local LL address %s", llv6_ntoa(ifaceid))); - } - ); - -#ifdef IPV6CP_COMP - NAKCIVJ(CI_COMPRESSTYPE, neg_vj, - { - if (cishort == IPV6CP_COMP && !treat_as_reject) { - try_.vj_protocol = cishort; - } else { - try_.neg_vj = 0; - } - } - ); -#endif /* IPV6CP_COMP */ - - /* - * There may be remaining CIs, if the peer is requesting negotiation - * on an option that we didn't include in our request packet. - * If they want to negotiate about interface identifier, we comply. - * If they want us to ask for compression, we refuse. - */ - while (len >= CILEN_VOID) { - GETCHAR(citype, p); - GETCHAR(cilen, p); - if ( cilen < CILEN_VOID || (len -= cilen) < 0 ) - goto bad; - next = p + cilen - 2; - - switch (citype) { -#ifdef IPV6CP_COMP - case CI_COMPRESSTYPE: - if (go->neg_vj || no.neg_vj || - (cilen != CILEN_COMPRESS)) - goto bad; - no.neg_vj = 1; - break; -#endif /* IPV6CP_COMP */ - case CI_IFACEID: - if (go->neg_ifaceid || no.neg_ifaceid || cilen != CILEN_IFACEID) - goto bad; - try_.neg_ifaceid = 1; - eui64_get(ifaceid, p); - if (go->accept_local) { - while (eui64_iszero(ifaceid) || - eui64_equals(ifaceid, go->hisid)) /* bad luck */ - eui64_magic(ifaceid); - try_.ourid = ifaceid; - } - no.neg_ifaceid = 1; - break; - default: - break; - } - p = next; - } - - /* If there is still anything left, this packet is bad. */ - if (len != 0) - goto bad; - - /* - * OK, the Nak is good. Now we can update state. - */ - if (f->state != PPP_FSM_OPENED) - *go = try_; - - return 1; - -bad: - IPV6CPDEBUG(("ipv6cp_nakci: received bad Nak!")); - return 0; -} - - -/* - * ipv6cp_rejci - Reject some of our CIs. - */ -static int ipv6cp_rejci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - u_char cilen; -#ifdef IPV6CP_COMP - u_short cishort; -#endif /* IPV6CP_COMP */ - eui64_t ifaceid; - ipv6cp_options try_; /* options to request next time */ - - try_ = *go; - /* - * Any Rejected CIs must be in exactly the same order that we sent. - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ -#define REJCIIFACEID(opt, neg, val1) \ - if (go->neg && \ - len >= (cilen = CILEN_IFACEID) && \ - p[1] == cilen && \ - p[0] == opt) { \ - len -= cilen; \ - INCPTR(2, p); \ - eui64_get(ifaceid, p); \ - /* Check rejected value. */ \ - if (! eui64_equals(ifaceid, val1)) \ - goto bad; \ - try_.neg = 0; \ - } - -#ifdef IPV6CP_COMP -#define REJCIVJ(opt, neg, val) \ - if (go->neg && \ - p[1] == CILEN_COMPRESS && \ - len >= p[1] && \ - p[0] == opt) { \ - len -= p[1]; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - /* Check rejected value. */ \ - if (cishort != val) \ - goto bad; \ - try_.neg = 0; \ - } -#endif /* IPV6CP_COMP */ - - REJCIIFACEID(CI_IFACEID, neg_ifaceid, go->ourid); - -#ifdef IPV6CP_COMP - REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol); -#endif /* IPV6CP_COMP */ - - /* - * If there are any remaining CIs, then this packet is bad. - */ - if (len != 0) - goto bad; - /* - * Now we can update state. - */ - if (f->state != PPP_FSM_OPENED) - *go = try_; - return 1; - -bad: - IPV6CPDEBUG(("ipv6cp_rejci: received bad Reject!")); - return 0; -} - - -/* - * ipv6cp_reqci - Check the peer's requested CIs and send appropriate response. - * - * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified - * appropriately. If reject_if_disagree is non-zero, doesn't return - * CONFNAK; returns CONFREJ if it can't return CONFACK. - * - * inp = Requested CIs - * len = Length of requested CIs - * - */ -static int ipv6cp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; - ipv6cp_options *ho = &pcb->ipv6cp_hisoptions; - ipv6cp_options *ao = &pcb->ipv6cp_allowoptions; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - u_char *cip, *next; /* Pointer to current and next CIs */ - u_short cilen, citype; /* Parsed len, type */ -#ifdef IPV6CP_COMP - u_short cishort; /* Parsed short value */ -#endif /* IPV6CP_COMP */ - eui64_t ifaceid; /* Parsed interface identifier */ - int rc = CONFACK; /* Final packet return code */ - int orc; /* Individual option return code */ - u_char *p; /* Pointer to next char to parse */ - u_char *ucp = inp; /* Pointer to current output char */ - int l = *len; /* Length left */ - - /* - * Reset all his options. - */ - BZERO(ho, sizeof(*ho)); - - /* - * Process all his options. - */ - next = inp; - while (l) { - orc = CONFACK; /* Assume success */ - cip = p = next; /* Remember begining of CI */ - if (l < 2 || /* Not enough data for CI header or */ - p[1] < 2 || /* CI length too small or */ - p[1] > l) { /* CI length too big? */ - IPV6CPDEBUG(("ipv6cp_reqci: bad CI length!")); - orc = CONFREJ; /* Reject bad CI */ - cilen = l; /* Reject till end of packet */ - l = 0; /* Don't loop again */ - goto endswitch; - } - GETCHAR(citype, p); /* Parse CI type */ - GETCHAR(cilen, p); /* Parse CI length */ - l -= cilen; /* Adjust remaining length */ - next += cilen; /* Step to next CI */ - - switch (citype) { /* Check CI type */ - case CI_IFACEID: - IPV6CPDEBUG(("ipv6cp: received interface identifier ")); - - if (!ao->neg_ifaceid || - cilen != CILEN_IFACEID) { /* Check CI length */ - orc = CONFREJ; /* Reject CI */ - break; - } - - /* - * If he has no interface identifier, or if we both have same - * identifier then NAK it with new idea. - * In particular, if we don't know his identifier, but he does, - * then accept it. - */ - eui64_get(ifaceid, p); - IPV6CPDEBUG(("(%s)", llv6_ntoa(ifaceid))); - if (eui64_iszero(ifaceid) && eui64_iszero(go->ourid)) { - orc = CONFREJ; /* Reject CI */ - break; - } - if (!eui64_iszero(wo->hisid) && - !eui64_equals(ifaceid, wo->hisid) && - eui64_iszero(go->hisid)) { - - orc = CONFNAK; - ifaceid = wo->hisid; - go->hisid = ifaceid; - DECPTR(sizeof(ifaceid), p); - eui64_put(ifaceid, p); - } else - if (eui64_iszero(ifaceid) || eui64_equals(ifaceid, go->ourid)) { - orc = CONFNAK; - if (eui64_iszero(go->hisid)) /* first time, try option */ - ifaceid = wo->hisid; - while (eui64_iszero(ifaceid) || - eui64_equals(ifaceid, go->ourid)) /* bad luck */ - eui64_magic(ifaceid); - go->hisid = ifaceid; - DECPTR(sizeof(ifaceid), p); - eui64_put(ifaceid, p); - } - - ho->neg_ifaceid = 1; - ho->hisid = ifaceid; - break; - -#ifdef IPV6CP_COMP - case CI_COMPRESSTYPE: - IPV6CPDEBUG(("ipv6cp: received COMPRESSTYPE ")); - if (!ao->neg_vj || - (cilen != CILEN_COMPRESS)) { - orc = CONFREJ; - break; - } - GETSHORT(cishort, p); - IPV6CPDEBUG(("(%d)", cishort)); - - if (!(cishort == IPV6CP_COMP)) { - orc = CONFREJ; - break; - } - - ho->neg_vj = 1; - ho->vj_protocol = cishort; - break; -#endif /* IPV6CP_COMP */ - - default: - orc = CONFREJ; - break; - } - -endswitch: - IPV6CPDEBUG((" (%s)\n", CODENAME(orc))); - - if (orc == CONFACK && /* Good CI */ - rc != CONFACK) /* but prior CI wasnt? */ - continue; /* Don't send this one */ - - if (orc == CONFNAK) { /* Nak this CI? */ - if (reject_if_disagree) /* Getting fed up with sending NAKs? */ - orc = CONFREJ; /* Get tough if so */ - else { - if (rc == CONFREJ) /* Rejecting prior CI? */ - continue; /* Don't send this one */ - if (rc == CONFACK) { /* Ack'd all prior CIs? */ - rc = CONFNAK; /* Not anymore... */ - ucp = inp; /* Backup */ - } - } - } - - if (orc == CONFREJ && /* Reject this CI */ - rc != CONFREJ) { /* but no prior ones? */ - rc = CONFREJ; - ucp = inp; /* Backup */ - } - - /* Need to move CI? */ - if (ucp != cip) - MEMCPY(ucp, cip, cilen); /* Move it */ - - /* Update output pointer */ - INCPTR(cilen, ucp); - } - - /* - * If we aren't rejecting this packet, and we want to negotiate - * their identifier and they didn't send their identifier, then we - * send a NAK with a CI_IFACEID option appended. We assume the - * input buffer is long enough that we can append the extra - * option safely. - */ - if (rc != CONFREJ && !ho->neg_ifaceid && - wo->req_ifaceid && !reject_if_disagree) { - if (rc == CONFACK) { - rc = CONFNAK; - ucp = inp; /* reset pointer */ - wo->req_ifaceid = 0; /* don't ask again */ - } - PUTCHAR(CI_IFACEID, ucp); - PUTCHAR(CILEN_IFACEID, ucp); - eui64_put(wo->hisid, ucp); - } - - *len = ucp - inp; /* Compute output length */ - IPV6CPDEBUG(("ipv6cp: returning Configure-%s", CODENAME(rc))); - return (rc); /* Return final code */ -} - -#if PPP_OPTIONS -/* - * ipv6_check_options - check that any IP-related options are OK, - * and assign appropriate defaults. - */ -static void ipv6_check_options() { - ipv6cp_options *wo = &ipv6cp_wantoptions[0]; - - if (!ipv6cp_protent.enabled_flag) - return; - - /* - * Persistent link-local id is only used when user has not explicitly - * configure/hard-code the id - */ - if ((wo->use_persistent) && (!wo->opt_local) && (!wo->opt_remote)) { - - /* - * On systems where there are no Ethernet interfaces used, there - * may be other ways to obtain a persistent id. Right now, it - * will fall back to using magic [see eui64_magic] below when - * an EUI-48 from MAC address can't be obtained. Other possibilities - * include obtaining EEPROM serial numbers, or some other unique - * yet persistent number. On Sparc platforms, this is possible, - * but too bad there's no standards yet for x86 machines. - */ - if (ether_to_eui64(&wo->ourid)) { - wo->opt_local = 1; - } - } - - if (!wo->opt_local) { /* init interface identifier */ - if (wo->use_ip && eui64_iszero(wo->ourid)) { - eui64_setlo32(wo->ourid, lwip_ntohl(ipcp_wantoptions[0].ouraddr)); - if (!eui64_iszero(wo->ourid)) - wo->opt_local = 1; - } - - while (eui64_iszero(wo->ourid)) - eui64_magic(wo->ourid); - } - - if (!wo->opt_remote) { - if (wo->use_ip && eui64_iszero(wo->hisid)) { - eui64_setlo32(wo->hisid, lwip_ntohl(ipcp_wantoptions[0].hisaddr)); - if (!eui64_iszero(wo->hisid)) - wo->opt_remote = 1; - } - } - - if (demand && (eui64_iszero(wo->ourid) || eui64_iszero(wo->hisid))) { - option_error("local/remote LL address required for demand-dialling\n"); - exit(1); - } -} -#endif /* PPP_OPTIONS */ - -#if DEMAND_SUPPORT -/* - * ipv6_demand_conf - configure the interface as though - * IPV6CP were up, for use with dial-on-demand. - */ -static int ipv6_demand_conf(int u) { - ipv6cp_options *wo = &ipv6cp_wantoptions[u]; - - if (!sif6up(u)) - return 0; - - if (!sif6addr(u, wo->ourid, wo->hisid)) - return 0; - - if (!sifnpmode(u, PPP_IPV6, NPMODE_QUEUE)) - return 0; - - ppp_notice("ipv6_demand_conf"); - ppp_notice("local LL address %s", llv6_ntoa(wo->ourid)); - ppp_notice("remote LL address %s", llv6_ntoa(wo->hisid)); - - return 1; -} -#endif /* DEMAND_SUPPORT */ - - -/* - * ipv6cp_up - IPV6CP has come UP. - * - * Configure the IPv6 network interface appropriately and bring it up. - */ -static void ipv6cp_up(fsm *f) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; - ipv6cp_options *ho = &pcb->ipv6cp_hisoptions; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - - IPV6CPDEBUG(("ipv6cp: up")); - - /* - * We must have a non-zero LL address for both ends of the link. - */ - if (!ho->neg_ifaceid) - ho->hisid = wo->hisid; - -#if 0 /* UNUSED */ - if(!no_ifaceid_neg) { -#endif /* UNUSED */ - if (eui64_iszero(ho->hisid)) { - ppp_error("Could not determine remote LL address"); - ipv6cp_close(f->pcb, "Could not determine remote LL address"); - return; - } - if (eui64_iszero(go->ourid)) { - ppp_error("Could not determine local LL address"); - ipv6cp_close(f->pcb, "Could not determine local LL address"); - return; - } - if (eui64_equals(go->ourid, ho->hisid)) { - ppp_error("local and remote LL addresses are equal"); - ipv6cp_close(f->pcb, "local and remote LL addresses are equal"); - return; - } -#if 0 /* UNUSED */ - } -#endif /* UNUSED */ -#if 0 /* UNUSED */ - script_setenv("LLLOCAL", llv6_ntoa(go->ourid), 0); - script_setenv("LLREMOTE", llv6_ntoa(ho->hisid), 0); -#endif /* UNUSED */ - -#ifdef IPV6CP_COMP - /* set tcp compression */ - sif6comp(f->unit, ho->neg_vj); -#endif - -#if DEMAND_SUPPORT - /* - * If we are doing dial-on-demand, the interface is already - * configured, so we put out any saved-up packets, then set the - * interface to pass IPv6 packets. - */ - if (demand) { - if (! eui64_equals(go->ourid, wo->ourid) || - ! eui64_equals(ho->hisid, wo->hisid)) { - if (! eui64_equals(go->ourid, wo->ourid)) - warn("Local LL address changed to %s", - llv6_ntoa(go->ourid)); - if (! eui64_equals(ho->hisid, wo->hisid)) - warn("Remote LL address changed to %s", - llv6_ntoa(ho->hisid)); - ipv6cp_clear_addrs(f->pcb, go->ourid, ho->hisid); - - /* Set the interface to the new addresses */ - if (!sif6addr(f->pcb, go->ourid, ho->hisid)) { - if (debug) - warn("sif6addr failed"); - ipv6cp_close(f->unit, "Interface configuration failed"); - return; - } - - } - demand_rexmit(PPP_IPV6); - sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS); - - } else -#endif /* DEMAND_SUPPORT */ - { - /* - * Set LL addresses - */ - if (!sif6addr(f->pcb, go->ourid, ho->hisid)) { - PPPDEBUG(LOG_DEBUG, ("sif6addr failed")); - ipv6cp_close(f->pcb, "Interface configuration failed"); - return; - } - - /* bring the interface up for IPv6 */ - if (!sif6up(f->pcb)) { - PPPDEBUG(LOG_DEBUG, ("sif6up failed (IPV6)")); - ipv6cp_close(f->pcb, "Interface configuration failed"); - return; - } -#if DEMAND_SUPPORT - sifnpmode(f->pcb, PPP_IPV6, NPMODE_PASS); -#endif /* DEMAND_SUPPORT */ - - ppp_notice("local LL address %s", llv6_ntoa(go->ourid)); - ppp_notice("remote LL address %s", llv6_ntoa(ho->hisid)); - } - - np_up(f->pcb, PPP_IPV6); - pcb->ipv6cp_is_up = 1; - -#if 0 /* UNUSED */ - /* - * Execute the ipv6-up script, like this: - * /etc/ppp/ipv6-up interface tty speed local-LL remote-LL - */ - if (ipv6cp_script_state == s_down && ipv6cp_script_pid == 0) { - ipv6cp_script_state = s_up; - ipv6cp_script(_PATH_IPV6UP); - } -#endif /* UNUSED */ -} - - -/* - * ipv6cp_down - IPV6CP has gone DOWN. - * - * Take the IPv6 network interface down, clear its addresses - * and delete routes through it. - */ -static void ipv6cp_down(fsm *f) { - ppp_pcb *pcb = f->pcb; - ipv6cp_options *go = &pcb->ipv6cp_gotoptions; - ipv6cp_options *ho = &pcb->ipv6cp_hisoptions; - - IPV6CPDEBUG(("ipv6cp: down")); -#if PPP_STATS_SUPPORT - update_link_stats(f->unit); -#endif /* PPP_STATS_SUPPORT */ - if (pcb->ipv6cp_is_up) { - pcb->ipv6cp_is_up = 0; - np_down(f->pcb, PPP_IPV6); - } -#ifdef IPV6CP_COMP - sif6comp(f->unit, 0); -#endif - -#if DEMAND_SUPPORT - /* - * If we are doing dial-on-demand, set the interface - * to queue up outgoing packets (for now). - */ - if (demand) { - sifnpmode(f->pcb, PPP_IPV6, NPMODE_QUEUE); - } else -#endif /* DEMAND_SUPPORT */ - { -#if DEMAND_SUPPORT - sifnpmode(f->pcb, PPP_IPV6, NPMODE_DROP); -#endif /* DEMAND_SUPPORT */ - ipv6cp_clear_addrs(f->pcb, - go->ourid, - ho->hisid); - sif6down(f->pcb); - } - -#if 0 /* UNUSED */ - /* Execute the ipv6-down script */ - if (ipv6cp_script_state == s_up && ipv6cp_script_pid == 0) { - ipv6cp_script_state = s_down; - ipv6cp_script(_PATH_IPV6DOWN); - } -#endif /* UNUSED */ -} - - -/* - * ipv6cp_clear_addrs() - clear the interface addresses, routes, - * proxy neighbour discovery entries, etc. - */ -static void ipv6cp_clear_addrs(ppp_pcb *pcb, eui64_t ourid, eui64_t hisid) { - cif6addr(pcb, ourid, hisid); -} - - -/* - * ipv6cp_finished - possibly shut down the lower layers. - */ -static void ipv6cp_finished(fsm *f) { - np_finished(f->pcb, PPP_IPV6); -} - - -#if 0 /* UNUSED */ -/* - * ipv6cp_script_done - called when the ipv6-up or ipv6-down script - * has finished. - */ -static void -ipv6cp_script_done(arg) - void *arg; -{ - ipv6cp_script_pid = 0; - switch (ipv6cp_script_state) { - case s_up: - if (ipv6cp_fsm[0].state != PPP_FSM_OPENED) { - ipv6cp_script_state = s_down; - ipv6cp_script(_PATH_IPV6DOWN); - } - break; - case s_down: - if (ipv6cp_fsm[0].state == PPP_FSM_OPENED) { - ipv6cp_script_state = s_up; - ipv6cp_script(_PATH_IPV6UP); - } - break; - } -} - - -/* - * ipv6cp_script - Execute a script with arguments - * interface-name tty-name speed local-LL remote-LL. - */ -static void -ipv6cp_script(script) - char *script; -{ - char strspeed[32], strlocal[32], strremote[32]; - char *argv[8]; - - sprintf(strspeed, "%d", baud_rate); - strcpy(strlocal, llv6_ntoa(ipv6cp_gotoptions[0].ourid)); - strcpy(strremote, llv6_ntoa(ipv6cp_hisoptions[0].hisid)); - - argv[0] = script; - argv[1] = ifname; - argv[2] = devnam; - argv[3] = strspeed; - argv[4] = strlocal; - argv[5] = strremote; - argv[6] = ipparam; - argv[7] = NULL; - - ipv6cp_script_pid = run_program(script, argv, 0, ipv6cp_script_done, - NULL, 0); -} -#endif /* UNUSED */ - -#if PRINTPKT_SUPPORT -/* - * ipv6cp_printpkt - print the contents of an IPV6CP packet. - */ -static const char* const ipv6cp_codenames[] = { - "ConfReq", "ConfAck", "ConfNak", "ConfRej", - "TermReq", "TermAck", "CodeRej" -}; - -static int ipv6cp_printpkt(const u_char *p, int plen, - void (*printer)(void *, const char *, ...), void *arg) { - int code, id, len, olen; - const u_char *pstart, *optend; -#ifdef IPV6CP_COMP - u_short cishort; -#endif /* IPV6CP_COMP */ - eui64_t ifaceid; - - if (plen < HEADERLEN) - return 0; - pstart = p; - GETCHAR(code, p); - GETCHAR(id, p); - GETSHORT(len, p); - if (len < HEADERLEN || len > plen) - return 0; - - if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(ipv6cp_codenames)) - printer(arg, " %s", ipv6cp_codenames[code-1]); - else - printer(arg, " code=0x%x", code); - printer(arg, " id=0x%x", id); - len -= HEADERLEN; - switch (code) { - case CONFREQ: - case CONFACK: - case CONFNAK: - case CONFREJ: - /* print option list */ - while (len >= 2) { - GETCHAR(code, p); - GETCHAR(olen, p); - p -= 2; - if (olen < 2 || olen > len) { - break; - } - printer(arg, " <"); - len -= olen; - optend = p + olen; - switch (code) { -#ifdef IPV6CP_COMP - case CI_COMPRESSTYPE: - if (olen >= CILEN_COMPRESS) { - p += 2; - GETSHORT(cishort, p); - printer(arg, "compress "); - printer(arg, "0x%x", cishort); - } - break; -#endif /* IPV6CP_COMP */ - case CI_IFACEID: - if (olen == CILEN_IFACEID) { - p += 2; - eui64_get(ifaceid, p); - printer(arg, "addr %s", llv6_ntoa(ifaceid)); - } - break; - default: - break; - } - while (p < optend) { - GETCHAR(code, p); - printer(arg, " %.2x", code); - } - printer(arg, ">"); - } - break; - - case TERMACK: - case TERMREQ: - if (len > 0 && *p >= ' ' && *p < 0x7f) { - printer(arg, " "); - ppp_print_string(p, len, printer, arg); - p += len; - len = 0; - } - break; - default: - break; - } - - /* print the rest of the bytes in the packet */ - for (; len > 0; --len) { - GETCHAR(code, p); - printer(arg, " %.2x", code); - } - - return p - pstart; -} -#endif /* PRINTPKT_SUPPORT */ - -#if DEMAND_SUPPORT -/* - * ipv6_active_pkt - see if this IP packet is worth bringing the link up for. - * We don't bring the link up for IP fragments or for TCP FIN packets - * with no data. - */ -#define IP6_HDRLEN 40 /* bytes */ -#define IP6_NHDR_FRAG 44 /* fragment IPv6 header */ -#define TCP_HDRLEN 20 -#define TH_FIN 0x01 - -/* - * We use these macros because the IP header may be at an odd address, - * and some compilers might use word loads to get th_off or ip_hl. - */ - -#define get_ip6nh(x) (((unsigned char *)(x))[6]) -#define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4) -#define get_tcpflags(x) (((unsigned char *)(x))[13]) - -static int ipv6_active_pkt(u_char *pkt, int len) { - u_char *tcp; - - len -= PPP_HDRLEN; - pkt += PPP_HDRLEN; - if (len < IP6_HDRLEN) - return 0; - if (get_ip6nh(pkt) == IP6_NHDR_FRAG) - return 0; - if (get_ip6nh(pkt) != IPPROTO_TCP) - return 1; - if (len < IP6_HDRLEN + TCP_HDRLEN) - return 0; - tcp = pkt + IP6_HDRLEN; - if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == IP6_HDRLEN + get_tcpoff(tcp) * 4) - return 0; - return 1; -} -#endif /* DEMAND_SUPPORT */ - -#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ +/* + * ipv6cp.c - PPP IPV6 Control Protocol. + * + * Copyright (c) 1999 Tommi Komulainen. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Tommi Komulainen + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +/* Original version, based on RFC2023 : + + Copyright (c) 1995, 1996, 1997 Francis.Dupont@inria.fr, INRIA Rocquencourt, + Alain.Durand@imag.fr, IMAG, + Jean-Luc.Richier@imag.fr, IMAG-LSR. + + Copyright (c) 1998, 1999 Francis.Dupont@inria.fr, GIE DYADE, + Alain.Durand@imag.fr, IMAG, + Jean-Luc.Richier@imag.fr, IMAG-LSR. + + Ce travail a été fait au sein du GIE DYADE (Groupement d'Intérêt + Économique ayant pour membres BULL S.A. et l'INRIA). + + Ce logiciel informatique est disponible aux conditions + usuelles dans la recherche, c'est-à-dire qu'il peut + être utilisé, copié, modifié, distribué à l'unique + condition que ce texte soit conservé afin que + l'origine de ce logiciel soit reconnue. + + Le nom de l'Institut National de Recherche en Informatique + et en Automatique (INRIA), de l'IMAG, ou d'une personne morale + ou physique ayant participé à l'élaboration de ce logiciel ne peut + être utilisé sans son accord préalable explicite. + + Ce logiciel est fourni tel quel sans aucune garantie, + support ou responsabilité d'aucune sorte. + Ce logiciel est dérivé de sources d'origine + "University of California at Berkeley" et + "Digital Equipment Corporation" couvertes par des copyrights. + + L'Institut d'Informatique et de Mathématiques Appliquées de Grenoble (IMAG) + est une fédération d'unités mixtes de recherche du CNRS, de l'Institut National + Polytechnique de Grenoble et de l'Université Joseph Fourier regroupant + sept laboratoires dont le laboratoire Logiciels, Systèmes, Réseaux (LSR). + + This work has been done in the context of GIE DYADE (joint R & D venture + between BULL S.A. and INRIA). + + This software is available with usual "research" terms + with the aim of retain credits of the software. + Permission to use, copy, modify and distribute this software for any + purpose and without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies, + and the name of INRIA, IMAG, or any contributor not be used in advertising + or publicity pertaining to this material without the prior explicit + permission. The software is provided "as is" without any + warranties, support or liabilities of any kind. + This software is derived from source code from + "University of California at Berkeley" and + "Digital Equipment Corporation" protected by copyrights. + + Grenoble's Institute of Computer Science and Applied Mathematics (IMAG) + is a federation of seven research units funded by the CNRS, National + Polytechnic Institute of Grenoble and University Joseph Fourier. + The research unit in Software, Systems, Networks (LSR) is member of IMAG. +*/ + +/* + * Derived from : + * + * + * ipcp.c - PPP IP Control Protocol. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * $Id: ipv6cp.c,v 1.21 2005/08/25 23:59:34 paulus Exp $ + */ + +/* + * @todo: + * + * Proxy Neighbour Discovery. + * + * Better defines for selecting the ordering of + * interface up / set address. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPP_IPV6_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#if 0 /* UNUSED */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/fsm.h" +#include "netif/ppp/ipcp.h" +#include "netif/ppp/ipv6cp.h" +#include "netif/ppp/magic.h" + +/* global vars */ +#if 0 /* UNUSED */ +int no_ifaceid_neg = 0; +#endif /* UNUSED */ + +/* + * Callbacks for fsm code. (CI = Configuration Information) + */ +static void ipv6cp_resetci(fsm *f); /* Reset our CI */ +static int ipv6cp_cilen(fsm *f); /* Return length of our CI */ +static void ipv6cp_addci(fsm *f, u_char *ucp, int *lenp); /* Add our CI */ +static int ipv6cp_ackci(fsm *f, u_char *p, int len); /* Peer ack'd our CI */ +static int ipv6cp_nakci(fsm *f, u_char *p, int len, int treat_as_reject); /* Peer nak'd our CI */ +static int ipv6cp_rejci(fsm *f, u_char *p, int len); /* Peer rej'd our CI */ +static int ipv6cp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree); /* Rcv CI */ +static void ipv6cp_up(fsm *f); /* We're UP */ +static void ipv6cp_down(fsm *f); /* We're DOWN */ +static void ipv6cp_finished(fsm *f); /* Don't need lower layer */ + +static const fsm_callbacks ipv6cp_callbacks = { /* IPV6CP callback routines */ + ipv6cp_resetci, /* Reset our Configuration Information */ + ipv6cp_cilen, /* Length of our Configuration Information */ + ipv6cp_addci, /* Add our Configuration Information */ + ipv6cp_ackci, /* ACK our Configuration Information */ + ipv6cp_nakci, /* NAK our Configuration Information */ + ipv6cp_rejci, /* Reject our Configuration Information */ + ipv6cp_reqci, /* Request peer's Configuration Information */ + ipv6cp_up, /* Called when fsm reaches OPENED state */ + ipv6cp_down, /* Called when fsm leaves OPENED state */ + NULL, /* Called when we want the lower layer up */ + ipv6cp_finished, /* Called when we want the lower layer down */ + NULL, /* Called when Protocol-Reject received */ + NULL, /* Retransmission is necessary */ + NULL, /* Called to handle protocol-specific codes */ + "IPV6CP" /* String name of protocol */ +}; + +#if PPP_OPTIONS +/* + * Command-line options. + */ +static int setifaceid(char **arg)); +static void printifaceid(option_t *, + void (*)(void *, char *, ...), void *)); + +static option_t ipv6cp_option_list[] = { + { "ipv6", o_special, (void *)setifaceid, + "Set interface identifiers for IPV6", + OPT_A2PRINTER, (void *)printifaceid }, + + { "+ipv6", o_bool, &ipv6cp_protent.enabled_flag, + "Enable IPv6 and IPv6CP", OPT_PRIO | 1 }, + { "noipv6", o_bool, &ipv6cp_protent.enabled_flag, + "Disable IPv6 and IPv6CP", OPT_PRIOSUB }, + { "-ipv6", o_bool, &ipv6cp_protent.enabled_flag, + "Disable IPv6 and IPv6CP", OPT_PRIOSUB | OPT_ALIAS }, + + { "ipv6cp-accept-local", o_bool, &ipv6cp_allowoptions[0].accept_local, + "Accept peer's interface identifier for us", 1 }, + + { "ipv6cp-use-ipaddr", o_bool, &ipv6cp_allowoptions[0].use_ip, + "Use (default) IPv4 address as interface identifier", 1 }, + + { "ipv6cp-use-persistent", o_bool, &ipv6cp_wantoptions[0].use_persistent, + "Use uniquely-available persistent value for link local address", 1 }, + + { "ipv6cp-restart", o_int, &ipv6cp_fsm[0].timeouttime, + "Set timeout for IPv6CP", OPT_PRIO }, + { "ipv6cp-max-terminate", o_int, &ipv6cp_fsm[0].maxtermtransmits, + "Set max #xmits for term-reqs", OPT_PRIO }, + { "ipv6cp-max-configure", o_int, &ipv6cp_fsm[0].maxconfreqtransmits, + "Set max #xmits for conf-reqs", OPT_PRIO }, + { "ipv6cp-max-failure", o_int, &ipv6cp_fsm[0].maxnakloops, + "Set max #conf-naks for IPv6CP", OPT_PRIO }, + + { NULL } +}; +#endif /* PPP_OPTIONS */ + +/* + * Protocol entry points from main code. + */ +static void ipv6cp_init(ppp_pcb *pcb); +static void ipv6cp_open(ppp_pcb *pcb); +static void ipv6cp_close(ppp_pcb *pcb, const char *reason); +static void ipv6cp_lowerup(ppp_pcb *pcb); +static void ipv6cp_lowerdown(ppp_pcb *pcb); +static void ipv6cp_input(ppp_pcb *pcb, u_char *p, int len); +static void ipv6cp_protrej(ppp_pcb *pcb); +#if PPP_OPTIONS +static void ipv6_check_options(void); +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT +static int ipv6_demand_conf(int u); +#endif /* DEMAND_SUPPORT */ +#if PRINTPKT_SUPPORT +static int ipv6cp_printpkt(const u_char *p, int plen, + void (*printer)(void *, const char *, ...), void *arg); +#endif /* PRINTPKT_SUPPORT */ +#if DEMAND_SUPPORT +static int ipv6_active_pkt(u_char *pkt, int len); +#endif /* DEMAND_SUPPORT */ + +const struct protent ipv6cp_protent = { + PPP_IPV6CP, + ipv6cp_init, + ipv6cp_input, + ipv6cp_protrej, + ipv6cp_lowerup, + ipv6cp_lowerdown, + ipv6cp_open, + ipv6cp_close, +#if PRINTPKT_SUPPORT + ipv6cp_printpkt, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + NULL, +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "IPV6CP", + "IPV6", +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + ipv6cp_option_list, + ipv6_check_options, +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + ipv6_demand_conf, + ipv6_active_pkt +#endif /* DEMAND_SUPPORT */ +}; + +static void ipv6cp_clear_addrs(ppp_pcb *pcb, eui64_t ourid, eui64_t hisid); +#if 0 /* UNUSED */ +static void ipv6cp_script(char *)); +static void ipv6cp_script_done(void *)); +#endif /* UNUSED */ + +/* + * Lengths of configuration options. + */ +#define CILEN_VOID 2 +#define CILEN_COMPRESS 4 /* length for RFC2023 compress opt. */ +#define CILEN_IFACEID 10 /* RFC2472, interface identifier */ + +#define CODENAME(x) ((x) == CONFACK ? "ACK" : \ + (x) == CONFNAK ? "NAK" : "REJ") + +#if 0 /* UNUSED */ +/* + * This state variable is used to ensure that we don't + * run an ipcp-up/down script while one is already running. + */ +static enum script_state { + s_down, + s_up, +} ipv6cp_script_state; +static pid_t ipv6cp_script_pid; +#endif /* UNUSED */ + +static char *llv6_ntoa(eui64_t ifaceid); + +#if PPP_OPTIONS +/* + * setifaceid - set the interface identifiers manually + */ +static int +setifaceid(argv) + char **argv; +{ + char *comma, *arg, c; + ipv6cp_options *wo = &ipv6cp_wantoptions[0]; + struct in6_addr addr; + static int prio_local, prio_remote; + +#define VALIDID(a) ( (((a).s6_addr32[0] == 0) && ((a).s6_addr32[1] == 0)) && \ + (((a).s6_addr32[2] != 0) || ((a).s6_addr32[3] != 0)) ) + + arg = *argv; + if ((comma = strchr(arg, ',')) == NULL) + comma = arg + strlen(arg); + + /* + * If comma first character, then no local identifier + */ + if (comma != arg) { + c = *comma; + *comma = '\0'; + + if (inet_pton(AF_INET6, arg, &addr) == 0 || !VALIDID(addr)) { + option_error("Illegal interface identifier (local): %s", arg); + return 0; + } + + if (option_priority >= prio_local) { + eui64_copy(addr.s6_addr32[2], wo->ourid); + wo->opt_local = 1; + prio_local = option_priority; + } + *comma = c; + } + + /* + * If comma last character, the no remote identifier + */ + if (*comma != 0 && *++comma != '\0') { + if (inet_pton(AF_INET6, comma, &addr) == 0 || !VALIDID(addr)) { + option_error("Illegal interface identifier (remote): %s", comma); + return 0; + } + if (option_priority >= prio_remote) { + eui64_copy(addr.s6_addr32[2], wo->hisid); + wo->opt_remote = 1; + prio_remote = option_priority; + } + } + + if (override_value("+ipv6", option_priority, option_source)) + ipv6cp_protent.enabled_flag = 1; + return 1; +} + +static void +printifaceid(opt, printer, arg) + option_t *opt; + void (*printer)(void *, char *, ...)); + void *arg; +{ + ipv6cp_options *wo = &ipv6cp_wantoptions[0]; + + if (wo->opt_local) + printer(arg, "%s", llv6_ntoa(wo->ourid)); + printer(arg, ","); + if (wo->opt_remote) + printer(arg, "%s", llv6_ntoa(wo->hisid)); +} +#endif /* PPP_OPTIONS */ + +/* + * Make a string representation of a network address. + */ +static char * +llv6_ntoa(eui64_t ifaceid) +{ + static char b[26]; + + sprintf(b, "fe80::%02x%02x:%02x%02x:%02x%02x:%02x%02x", + ifaceid.e8[0], ifaceid.e8[1], ifaceid.e8[2], ifaceid.e8[3], + ifaceid.e8[4], ifaceid.e8[5], ifaceid.e8[6], ifaceid.e8[7]); + + return b; +} + + +/* + * ipv6cp_init - Initialize IPV6CP. + */ +static void ipv6cp_init(ppp_pcb *pcb) { + fsm *f = &pcb->ipv6cp_fsm; + ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; + ipv6cp_options *ao = &pcb->ipv6cp_allowoptions; + + f->pcb = pcb; + f->protocol = PPP_IPV6CP; + f->callbacks = &ipv6cp_callbacks; + fsm_init(f); + +#if 0 /* Not necessary, everything is cleared in ppp_new() */ + memset(wo, 0, sizeof(*wo)); + memset(ao, 0, sizeof(*ao)); +#endif /* 0 */ + + wo->accept_local = 1; + wo->neg_ifaceid = 1; + ao->neg_ifaceid = 1; + +#ifdef IPV6CP_COMP + wo->neg_vj = 1; + ao->neg_vj = 1; + wo->vj_protocol = IPV6CP_COMP; +#endif + +} + + +/* + * ipv6cp_open - IPV6CP is allowed to come up. + */ +static void ipv6cp_open(ppp_pcb *pcb) { + fsm_open(&pcb->ipv6cp_fsm); +} + + +/* + * ipv6cp_close - Take IPV6CP down. + */ +static void ipv6cp_close(ppp_pcb *pcb, const char *reason) { + fsm_close(&pcb->ipv6cp_fsm, reason); +} + + +/* + * ipv6cp_lowerup - The lower layer is up. + */ +static void ipv6cp_lowerup(ppp_pcb *pcb) { + fsm_lowerup(&pcb->ipv6cp_fsm); +} + + +/* + * ipv6cp_lowerdown - The lower layer is down. + */ +static void ipv6cp_lowerdown(ppp_pcb *pcb) { + fsm_lowerdown(&pcb->ipv6cp_fsm); +} + + +/* + * ipv6cp_input - Input IPV6CP packet. + */ +static void ipv6cp_input(ppp_pcb *pcb, u_char *p, int len) { + fsm_input(&pcb->ipv6cp_fsm, p, len); +} + + +/* + * ipv6cp_protrej - A Protocol-Reject was received for IPV6CP. + * + * Pretend the lower layer went down, so we shut up. + */ +static void ipv6cp_protrej(ppp_pcb *pcb) { + fsm_lowerdown(&pcb->ipv6cp_fsm); +} + + +/* + * ipv6cp_resetci - Reset our CI. + */ +static void ipv6cp_resetci(fsm *f) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + ipv6cp_options *ao = &pcb->ipv6cp_allowoptions; + + wo->req_ifaceid = wo->neg_ifaceid && ao->neg_ifaceid; + + if (!wo->opt_local) { + eui64_magic_nz(wo->ourid); + } + + *go = *wo; + eui64_zero(go->hisid); /* last proposed interface identifier */ +} + + +/* + * ipv6cp_cilen - Return length of our CI. + */ +static int ipv6cp_cilen(fsm *f) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + +#ifdef IPV6CP_COMP +#define LENCIVJ(neg) (neg ? CILEN_COMPRESS : 0) +#endif /* IPV6CP_COMP */ +#define LENCIIFACEID(neg) (neg ? CILEN_IFACEID : 0) + + return (LENCIIFACEID(go->neg_ifaceid) + +#ifdef IPV6CP_COMP + LENCIVJ(go->neg_vj) + +#endif /* IPV6CP_COMP */ + 0); +} + + +/* + * ipv6cp_addci - Add our desired CIs to a packet. + */ +static void ipv6cp_addci(fsm *f, u_char *ucp, int *lenp) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + int len = *lenp; + +#ifdef IPV6CP_COMP +#define ADDCIVJ(opt, neg, val) \ + if (neg) { \ + int vjlen = CILEN_COMPRESS; \ + if (len >= vjlen) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(vjlen, ucp); \ + PUTSHORT(val, ucp); \ + len -= vjlen; \ + } else \ + neg = 0; \ + } +#endif /* IPV6CP_COMP */ + +#define ADDCIIFACEID(opt, neg, val1) \ + if (neg) { \ + int idlen = CILEN_IFACEID; \ + if (len >= idlen) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(idlen, ucp); \ + eui64_put(val1, ucp); \ + len -= idlen; \ + } else \ + neg = 0; \ + } + + ADDCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid); + +#ifdef IPV6CP_COMP + ADDCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol); +#endif /* IPV6CP_COMP */ + + *lenp -= len; +} + + +/* + * ipv6cp_ackci - Ack our CIs. + * + * Returns: + * 0 - Ack was bad. + * 1 - Ack was good. + */ +static int ipv6cp_ackci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + u_short cilen, citype; +#ifdef IPV6CP_COMP + u_short cishort; +#endif /* IPV6CP_COMP */ + eui64_t ifaceid; + + /* + * CIs must be in exactly the same order that we sent... + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ + +#ifdef IPV6CP_COMP +#define ACKCIVJ(opt, neg, val) \ + if (neg) { \ + int vjlen = CILEN_COMPRESS; \ + if ((len -= vjlen) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != vjlen || \ + citype != opt) \ + goto bad; \ + GETSHORT(cishort, p); \ + if (cishort != val) \ + goto bad; \ + } +#endif /* IPV6CP_COMP */ + +#define ACKCIIFACEID(opt, neg, val1) \ + if (neg) { \ + int idlen = CILEN_IFACEID; \ + if ((len -= idlen) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != idlen || \ + citype != opt) \ + goto bad; \ + eui64_get(ifaceid, p); \ + if (! eui64_equals(val1, ifaceid)) \ + goto bad; \ + } + + ACKCIIFACEID(CI_IFACEID, go->neg_ifaceid, go->ourid); + +#ifdef IPV6CP_COMP + ACKCIVJ(CI_COMPRESSTYPE, go->neg_vj, go->vj_protocol); +#endif /* IPV6CP_COMP */ + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + return (1); + +bad: + IPV6CPDEBUG(("ipv6cp_ackci: received bad Ack!")); + return (0); +} + +/* + * ipv6cp_nakci - Peer has sent a NAK for some of our CIs. + * This should not modify any state if the Nak is bad + * or if IPV6CP is in the OPENED state. + * + * Returns: + * 0 - Nak was bad. + * 1 - Nak was good. + */ +static int ipv6cp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + u_char citype, cilen, *next; +#ifdef IPV6CP_COMP + u_short cishort; +#endif /* IPV6CP_COMP */ + eui64_t ifaceid; + ipv6cp_options no; /* options we've seen Naks for */ + ipv6cp_options try_; /* options to request next time */ + + BZERO(&no, sizeof(no)); + try_ = *go; + + /* + * Any Nak'd CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define NAKCIIFACEID(opt, neg, code) \ + if (go->neg && \ + len >= (cilen = CILEN_IFACEID) && \ + p[1] == cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + eui64_get(ifaceid, p); \ + no.neg = 1; \ + code \ + } + +#ifdef IPV6CP_COMP +#define NAKCIVJ(opt, neg, code) \ + if (go->neg && \ + ((cilen = p[1]) == CILEN_COMPRESS) && \ + len >= cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + no.neg = 1; \ + code \ + } +#endif /* IPV6CP_COMP */ + + /* + * Accept the peer's idea of {our,his} interface identifier, if different + * from our idea, only if the accept_{local,remote} flag is set. + */ + NAKCIIFACEID(CI_IFACEID, neg_ifaceid, + if (treat_as_reject) { + try_.neg_ifaceid = 0; + } else if (go->accept_local) { + while (eui64_iszero(ifaceid) || + eui64_equals(ifaceid, go->hisid)) /* bad luck */ + eui64_magic(ifaceid); + try_.ourid = ifaceid; + IPV6CPDEBUG(("local LL address %s", llv6_ntoa(ifaceid))); + } + ); + +#ifdef IPV6CP_COMP + NAKCIVJ(CI_COMPRESSTYPE, neg_vj, + { + if (cishort == IPV6CP_COMP && !treat_as_reject) { + try_.vj_protocol = cishort; + } else { + try_.neg_vj = 0; + } + } + ); +#endif /* IPV6CP_COMP */ + + /* + * There may be remaining CIs, if the peer is requesting negotiation + * on an option that we didn't include in our request packet. + * If they want to negotiate about interface identifier, we comply. + * If they want us to ask for compression, we refuse. + */ + while (len >= CILEN_VOID) { + GETCHAR(citype, p); + GETCHAR(cilen, p); + if ( cilen < CILEN_VOID || (len -= cilen) < 0 ) + goto bad; + next = p + cilen - 2; + + switch (citype) { +#ifdef IPV6CP_COMP + case CI_COMPRESSTYPE: + if (go->neg_vj || no.neg_vj || + (cilen != CILEN_COMPRESS)) + goto bad; + no.neg_vj = 1; + break; +#endif /* IPV6CP_COMP */ + case CI_IFACEID: + if (go->neg_ifaceid || no.neg_ifaceid || cilen != CILEN_IFACEID) + goto bad; + try_.neg_ifaceid = 1; + eui64_get(ifaceid, p); + if (go->accept_local) { + while (eui64_iszero(ifaceid) || + eui64_equals(ifaceid, go->hisid)) /* bad luck */ + eui64_magic(ifaceid); + try_.ourid = ifaceid; + } + no.neg_ifaceid = 1; + break; + default: + break; + } + p = next; + } + + /* If there is still anything left, this packet is bad. */ + if (len != 0) + goto bad; + + /* + * OK, the Nak is good. Now we can update state. + */ + if (f->state != PPP_FSM_OPENED) + *go = try_; + + return 1; + +bad: + IPV6CPDEBUG(("ipv6cp_nakci: received bad Nak!")); + return 0; +} + + +/* + * ipv6cp_rejci - Reject some of our CIs. + */ +static int ipv6cp_rejci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + u_char cilen; +#ifdef IPV6CP_COMP + u_short cishort; +#endif /* IPV6CP_COMP */ + eui64_t ifaceid; + ipv6cp_options try_; /* options to request next time */ + + try_ = *go; + /* + * Any Rejected CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define REJCIIFACEID(opt, neg, val1) \ + if (go->neg && \ + len >= (cilen = CILEN_IFACEID) && \ + p[1] == cilen && \ + p[0] == opt) { \ + len -= cilen; \ + INCPTR(2, p); \ + eui64_get(ifaceid, p); \ + /* Check rejected value. */ \ + if (! eui64_equals(ifaceid, val1)) \ + goto bad; \ + try_.neg = 0; \ + } + +#ifdef IPV6CP_COMP +#define REJCIVJ(opt, neg, val) \ + if (go->neg && \ + p[1] == CILEN_COMPRESS && \ + len >= p[1] && \ + p[0] == opt) { \ + len -= p[1]; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + /* Check rejected value. */ \ + if (cishort != val) \ + goto bad; \ + try_.neg = 0; \ + } +#endif /* IPV6CP_COMP */ + + REJCIIFACEID(CI_IFACEID, neg_ifaceid, go->ourid); + +#ifdef IPV6CP_COMP + REJCIVJ(CI_COMPRESSTYPE, neg_vj, go->vj_protocol); +#endif /* IPV6CP_COMP */ + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + /* + * Now we can update state. + */ + if (f->state != PPP_FSM_OPENED) + *go = try_; + return 1; + +bad: + IPV6CPDEBUG(("ipv6cp_rejci: received bad Reject!")); + return 0; +} + + +/* + * ipv6cp_reqci - Check the peer's requested CIs and send appropriate response. + * + * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified + * appropriately. If reject_if_disagree is non-zero, doesn't return + * CONFNAK; returns CONFREJ if it can't return CONFACK. + * + * inp = Requested CIs + * len = Length of requested CIs + * + */ +static int ipv6cp_reqci(fsm *f, u_char *inp, int *len, int reject_if_disagree) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; + ipv6cp_options *ho = &pcb->ipv6cp_hisoptions; + ipv6cp_options *ao = &pcb->ipv6cp_allowoptions; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + u_char *cip, *next; /* Pointer to current and next CIs */ + u_short cilen, citype; /* Parsed len, type */ +#ifdef IPV6CP_COMP + u_short cishort; /* Parsed short value */ +#endif /* IPV6CP_COMP */ + eui64_t ifaceid; /* Parsed interface identifier */ + int rc = CONFACK; /* Final packet return code */ + int orc; /* Individual option return code */ + u_char *p; /* Pointer to next char to parse */ + u_char *ucp = inp; /* Pointer to current output char */ + int l = *len; /* Length left */ + + /* + * Reset all his options. + */ + BZERO(ho, sizeof(*ho)); + + /* + * Process all his options. + */ + next = inp; + while (l) { + orc = CONFACK; /* Assume success */ + cip = p = next; /* Remember begining of CI */ + if (l < 2 || /* Not enough data for CI header or */ + p[1] < 2 || /* CI length too small or */ + p[1] > l) { /* CI length too big? */ + IPV6CPDEBUG(("ipv6cp_reqci: bad CI length!")); + orc = CONFREJ; /* Reject bad CI */ + cilen = l; /* Reject till end of packet */ + l = 0; /* Don't loop again */ + goto endswitch; + } + GETCHAR(citype, p); /* Parse CI type */ + GETCHAR(cilen, p); /* Parse CI length */ + l -= cilen; /* Adjust remaining length */ + next += cilen; /* Step to next CI */ + + switch (citype) { /* Check CI type */ + case CI_IFACEID: + IPV6CPDEBUG(("ipv6cp: received interface identifier ")); + + if (!ao->neg_ifaceid || + cilen != CILEN_IFACEID) { /* Check CI length */ + orc = CONFREJ; /* Reject CI */ + break; + } + + /* + * If he has no interface identifier, or if we both have same + * identifier then NAK it with new idea. + * In particular, if we don't know his identifier, but he does, + * then accept it. + */ + eui64_get(ifaceid, p); + IPV6CPDEBUG(("(%s)", llv6_ntoa(ifaceid))); + if (eui64_iszero(ifaceid) && eui64_iszero(go->ourid)) { + orc = CONFREJ; /* Reject CI */ + break; + } + if (!eui64_iszero(wo->hisid) && + !eui64_equals(ifaceid, wo->hisid) && + eui64_iszero(go->hisid)) { + + orc = CONFNAK; + ifaceid = wo->hisid; + go->hisid = ifaceid; + DECPTR(sizeof(ifaceid), p); + eui64_put(ifaceid, p); + } else + if (eui64_iszero(ifaceid) || eui64_equals(ifaceid, go->ourid)) { + orc = CONFNAK; + if (eui64_iszero(go->hisid)) /* first time, try option */ + ifaceid = wo->hisid; + while (eui64_iszero(ifaceid) || + eui64_equals(ifaceid, go->ourid)) /* bad luck */ + eui64_magic(ifaceid); + go->hisid = ifaceid; + DECPTR(sizeof(ifaceid), p); + eui64_put(ifaceid, p); + } + + ho->neg_ifaceid = 1; + ho->hisid = ifaceid; + break; + +#ifdef IPV6CP_COMP + case CI_COMPRESSTYPE: + IPV6CPDEBUG(("ipv6cp: received COMPRESSTYPE ")); + if (!ao->neg_vj || + (cilen != CILEN_COMPRESS)) { + orc = CONFREJ; + break; + } + GETSHORT(cishort, p); + IPV6CPDEBUG(("(%d)", cishort)); + + if (!(cishort == IPV6CP_COMP)) { + orc = CONFREJ; + break; + } + + ho->neg_vj = 1; + ho->vj_protocol = cishort; + break; +#endif /* IPV6CP_COMP */ + + default: + orc = CONFREJ; + break; + } + +endswitch: + IPV6CPDEBUG((" (%s)\n", CODENAME(orc))); + + if (orc == CONFACK && /* Good CI */ + rc != CONFACK) /* but prior CI wasnt? */ + continue; /* Don't send this one */ + + if (orc == CONFNAK) { /* Nak this CI? */ + if (reject_if_disagree) /* Getting fed up with sending NAKs? */ + orc = CONFREJ; /* Get tough if so */ + else { + if (rc == CONFREJ) /* Rejecting prior CI? */ + continue; /* Don't send this one */ + if (rc == CONFACK) { /* Ack'd all prior CIs? */ + rc = CONFNAK; /* Not anymore... */ + ucp = inp; /* Backup */ + } + } + } + + if (orc == CONFREJ && /* Reject this CI */ + rc != CONFREJ) { /* but no prior ones? */ + rc = CONFREJ; + ucp = inp; /* Backup */ + } + + /* Need to move CI? */ + if (ucp != cip) + MEMCPY(ucp, cip, cilen); /* Move it */ + + /* Update output pointer */ + INCPTR(cilen, ucp); + } + + /* + * If we aren't rejecting this packet, and we want to negotiate + * their identifier and they didn't send their identifier, then we + * send a NAK with a CI_IFACEID option appended. We assume the + * input buffer is long enough that we can append the extra + * option safely. + */ + if (rc != CONFREJ && !ho->neg_ifaceid && + wo->req_ifaceid && !reject_if_disagree) { + if (rc == CONFACK) { + rc = CONFNAK; + ucp = inp; /* reset pointer */ + wo->req_ifaceid = 0; /* don't ask again */ + } + PUTCHAR(CI_IFACEID, ucp); + PUTCHAR(CILEN_IFACEID, ucp); + eui64_put(wo->hisid, ucp); + } + + *len = ucp - inp; /* Compute output length */ + IPV6CPDEBUG(("ipv6cp: returning Configure-%s", CODENAME(rc))); + return (rc); /* Return final code */ +} + +#if PPP_OPTIONS +/* + * ipv6_check_options - check that any IP-related options are OK, + * and assign appropriate defaults. + */ +static void ipv6_check_options() { + ipv6cp_options *wo = &ipv6cp_wantoptions[0]; + + if (!ipv6cp_protent.enabled_flag) + return; + + /* + * Persistent link-local id is only used when user has not explicitly + * configure/hard-code the id + */ + if ((wo->use_persistent) && (!wo->opt_local) && (!wo->opt_remote)) { + + /* + * On systems where there are no Ethernet interfaces used, there + * may be other ways to obtain a persistent id. Right now, it + * will fall back to using magic [see eui64_magic] below when + * an EUI-48 from MAC address can't be obtained. Other possibilities + * include obtaining EEPROM serial numbers, or some other unique + * yet persistent number. On Sparc platforms, this is possible, + * but too bad there's no standards yet for x86 machines. + */ + if (ether_to_eui64(&wo->ourid)) { + wo->opt_local = 1; + } + } + + if (!wo->opt_local) { /* init interface identifier */ + if (wo->use_ip && eui64_iszero(wo->ourid)) { + eui64_setlo32(wo->ourid, lwip_ntohl(ipcp_wantoptions[0].ouraddr)); + if (!eui64_iszero(wo->ourid)) + wo->opt_local = 1; + } + + while (eui64_iszero(wo->ourid)) + eui64_magic(wo->ourid); + } + + if (!wo->opt_remote) { + if (wo->use_ip && eui64_iszero(wo->hisid)) { + eui64_setlo32(wo->hisid, lwip_ntohl(ipcp_wantoptions[0].hisaddr)); + if (!eui64_iszero(wo->hisid)) + wo->opt_remote = 1; + } + } + + if (demand && (eui64_iszero(wo->ourid) || eui64_iszero(wo->hisid))) { + option_error("local/remote LL address required for demand-dialling\n"); + exit(1); + } +} +#endif /* PPP_OPTIONS */ + +#if DEMAND_SUPPORT +/* + * ipv6_demand_conf - configure the interface as though + * IPV6CP were up, for use with dial-on-demand. + */ +static int ipv6_demand_conf(int u) { + ipv6cp_options *wo = &ipv6cp_wantoptions[u]; + + if (!sif6up(u)) + return 0; + + if (!sif6addr(u, wo->ourid, wo->hisid)) + return 0; + + if (!sifnpmode(u, PPP_IPV6, NPMODE_QUEUE)) + return 0; + + ppp_notice("ipv6_demand_conf"); + ppp_notice("local LL address %s", llv6_ntoa(wo->ourid)); + ppp_notice("remote LL address %s", llv6_ntoa(wo->hisid)); + + return 1; +} +#endif /* DEMAND_SUPPORT */ + + +/* + * ipv6cp_up - IPV6CP has come UP. + * + * Configure the IPv6 network interface appropriately and bring it up. + */ +static void ipv6cp_up(fsm *f) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *wo = &pcb->ipv6cp_wantoptions; + ipv6cp_options *ho = &pcb->ipv6cp_hisoptions; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + + IPV6CPDEBUG(("ipv6cp: up")); + + /* + * We must have a non-zero LL address for both ends of the link. + */ + if (!ho->neg_ifaceid) + ho->hisid = wo->hisid; + +#if 0 /* UNUSED */ + if(!no_ifaceid_neg) { +#endif /* UNUSED */ + if (eui64_iszero(ho->hisid)) { + ppp_error("Could not determine remote LL address"); + ipv6cp_close(f->pcb, "Could not determine remote LL address"); + return; + } + if (eui64_iszero(go->ourid)) { + ppp_error("Could not determine local LL address"); + ipv6cp_close(f->pcb, "Could not determine local LL address"); + return; + } + if (eui64_equals(go->ourid, ho->hisid)) { + ppp_error("local and remote LL addresses are equal"); + ipv6cp_close(f->pcb, "local and remote LL addresses are equal"); + return; + } +#if 0 /* UNUSED */ + } +#endif /* UNUSED */ +#if 0 /* UNUSED */ + script_setenv("LLLOCAL", llv6_ntoa(go->ourid), 0); + script_setenv("LLREMOTE", llv6_ntoa(ho->hisid), 0); +#endif /* UNUSED */ + +#ifdef IPV6CP_COMP + /* set tcp compression */ + sif6comp(f->unit, ho->neg_vj); +#endif + +#if DEMAND_SUPPORT + /* + * If we are doing dial-on-demand, the interface is already + * configured, so we put out any saved-up packets, then set the + * interface to pass IPv6 packets. + */ + if (demand) { + if (! eui64_equals(go->ourid, wo->ourid) || + ! eui64_equals(ho->hisid, wo->hisid)) { + if (! eui64_equals(go->ourid, wo->ourid)) + warn("Local LL address changed to %s", + llv6_ntoa(go->ourid)); + if (! eui64_equals(ho->hisid, wo->hisid)) + warn("Remote LL address changed to %s", + llv6_ntoa(ho->hisid)); + ipv6cp_clear_addrs(f->pcb, go->ourid, ho->hisid); + + /* Set the interface to the new addresses */ + if (!sif6addr(f->pcb, go->ourid, ho->hisid)) { + if (debug) + warn("sif6addr failed"); + ipv6cp_close(f->unit, "Interface configuration failed"); + return; + } + + } + demand_rexmit(PPP_IPV6); + sifnpmode(f->unit, PPP_IPV6, NPMODE_PASS); + + } else +#endif /* DEMAND_SUPPORT */ + { + /* + * Set LL addresses + */ + if (!sif6addr(f->pcb, go->ourid, ho->hisid)) { + PPPDEBUG(LOG_DEBUG, ("sif6addr failed")); + ipv6cp_close(f->pcb, "Interface configuration failed"); + return; + } + + /* bring the interface up for IPv6 */ + if (!sif6up(f->pcb)) { + PPPDEBUG(LOG_DEBUG, ("sif6up failed (IPV6)")); + ipv6cp_close(f->pcb, "Interface configuration failed"); + return; + } +#if DEMAND_SUPPORT + sifnpmode(f->pcb, PPP_IPV6, NPMODE_PASS); +#endif /* DEMAND_SUPPORT */ + + ppp_notice("local LL address %s", llv6_ntoa(go->ourid)); + ppp_notice("remote LL address %s", llv6_ntoa(ho->hisid)); + } + + np_up(f->pcb, PPP_IPV6); + pcb->ipv6cp_is_up = 1; + +#if 0 /* UNUSED */ + /* + * Execute the ipv6-up script, like this: + * /etc/ppp/ipv6-up interface tty speed local-LL remote-LL + */ + if (ipv6cp_script_state == s_down && ipv6cp_script_pid == 0) { + ipv6cp_script_state = s_up; + ipv6cp_script(_PATH_IPV6UP); + } +#endif /* UNUSED */ +} + + +/* + * ipv6cp_down - IPV6CP has gone DOWN. + * + * Take the IPv6 network interface down, clear its addresses + * and delete routes through it. + */ +static void ipv6cp_down(fsm *f) { + ppp_pcb *pcb = f->pcb; + ipv6cp_options *go = &pcb->ipv6cp_gotoptions; + ipv6cp_options *ho = &pcb->ipv6cp_hisoptions; + + IPV6CPDEBUG(("ipv6cp: down")); +#if PPP_STATS_SUPPORT + update_link_stats(f->unit); +#endif /* PPP_STATS_SUPPORT */ + if (pcb->ipv6cp_is_up) { + pcb->ipv6cp_is_up = 0; + np_down(f->pcb, PPP_IPV6); + } +#ifdef IPV6CP_COMP + sif6comp(f->unit, 0); +#endif + +#if DEMAND_SUPPORT + /* + * If we are doing dial-on-demand, set the interface + * to queue up outgoing packets (for now). + */ + if (demand) { + sifnpmode(f->pcb, PPP_IPV6, NPMODE_QUEUE); + } else +#endif /* DEMAND_SUPPORT */ + { +#if DEMAND_SUPPORT + sifnpmode(f->pcb, PPP_IPV6, NPMODE_DROP); +#endif /* DEMAND_SUPPORT */ + ipv6cp_clear_addrs(f->pcb, + go->ourid, + ho->hisid); + sif6down(f->pcb); + } + +#if 0 /* UNUSED */ + /* Execute the ipv6-down script */ + if (ipv6cp_script_state == s_up && ipv6cp_script_pid == 0) { + ipv6cp_script_state = s_down; + ipv6cp_script(_PATH_IPV6DOWN); + } +#endif /* UNUSED */ +} + + +/* + * ipv6cp_clear_addrs() - clear the interface addresses, routes, + * proxy neighbour discovery entries, etc. + */ +static void ipv6cp_clear_addrs(ppp_pcb *pcb, eui64_t ourid, eui64_t hisid) { + cif6addr(pcb, ourid, hisid); +} + + +/* + * ipv6cp_finished - possibly shut down the lower layers. + */ +static void ipv6cp_finished(fsm *f) { + np_finished(f->pcb, PPP_IPV6); +} + + +#if 0 /* UNUSED */ +/* + * ipv6cp_script_done - called when the ipv6-up or ipv6-down script + * has finished. + */ +static void +ipv6cp_script_done(arg) + void *arg; +{ + ipv6cp_script_pid = 0; + switch (ipv6cp_script_state) { + case s_up: + if (ipv6cp_fsm[0].state != PPP_FSM_OPENED) { + ipv6cp_script_state = s_down; + ipv6cp_script(_PATH_IPV6DOWN); + } + break; + case s_down: + if (ipv6cp_fsm[0].state == PPP_FSM_OPENED) { + ipv6cp_script_state = s_up; + ipv6cp_script(_PATH_IPV6UP); + } + break; + } +} + + +/* + * ipv6cp_script - Execute a script with arguments + * interface-name tty-name speed local-LL remote-LL. + */ +static void +ipv6cp_script(script) + char *script; +{ + char strspeed[32], strlocal[32], strremote[32]; + char *argv[8]; + + sprintf(strspeed, "%d", baud_rate); + strcpy(strlocal, llv6_ntoa(ipv6cp_gotoptions[0].ourid)); + strcpy(strremote, llv6_ntoa(ipv6cp_hisoptions[0].hisid)); + + argv[0] = script; + argv[1] = ifname; + argv[2] = devnam; + argv[3] = strspeed; + argv[4] = strlocal; + argv[5] = strremote; + argv[6] = ipparam; + argv[7] = NULL; + + ipv6cp_script_pid = run_program(script, argv, 0, ipv6cp_script_done, + NULL, 0); +} +#endif /* UNUSED */ + +#if PRINTPKT_SUPPORT +/* + * ipv6cp_printpkt - print the contents of an IPV6CP packet. + */ +static const char* const ipv6cp_codenames[] = { + "ConfReq", "ConfAck", "ConfNak", "ConfRej", + "TermReq", "TermAck", "CodeRej" +}; + +static int ipv6cp_printpkt(const u_char *p, int plen, + void (*printer)(void *, const char *, ...), void *arg) { + int code, id, len, olen; + const u_char *pstart, *optend; +#ifdef IPV6CP_COMP + u_short cishort; +#endif /* IPV6CP_COMP */ + eui64_t ifaceid; + + if (plen < HEADERLEN) + return 0; + pstart = p; + GETCHAR(code, p); + GETCHAR(id, p); + GETSHORT(len, p); + if (len < HEADERLEN || len > plen) + return 0; + + if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(ipv6cp_codenames)) + printer(arg, " %s", ipv6cp_codenames[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= HEADERLEN; + switch (code) { + case CONFREQ: + case CONFACK: + case CONFNAK: + case CONFREJ: + /* print option list */ + while (len >= 2) { + GETCHAR(code, p); + GETCHAR(olen, p); + p -= 2; + if (olen < 2 || olen > len) { + break; + } + printer(arg, " <"); + len -= olen; + optend = p + olen; + switch (code) { +#ifdef IPV6CP_COMP + case CI_COMPRESSTYPE: + if (olen >= CILEN_COMPRESS) { + p += 2; + GETSHORT(cishort, p); + printer(arg, "compress "); + printer(arg, "0x%x", cishort); + } + break; +#endif /* IPV6CP_COMP */ + case CI_IFACEID: + if (olen == CILEN_IFACEID) { + p += 2; + eui64_get(ifaceid, p); + printer(arg, "addr %s", llv6_ntoa(ifaceid)); + } + break; + default: + break; + } + while (p < optend) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + printer(arg, ">"); + } + break; + + case TERMACK: + case TERMREQ: + if (len > 0 && *p >= ' ' && *p < 0x7f) { + printer(arg, " "); + ppp_print_string(p, len, printer, arg); + p += len; + len = 0; + } + break; + default: + break; + } + + /* print the rest of the bytes in the packet */ + for (; len > 0; --len) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + + return p - pstart; +} +#endif /* PRINTPKT_SUPPORT */ + +#if DEMAND_SUPPORT +/* + * ipv6_active_pkt - see if this IP packet is worth bringing the link up for. + * We don't bring the link up for IP fragments or for TCP FIN packets + * with no data. + */ +#define IP6_HDRLEN 40 /* bytes */ +#define IP6_NHDR_FRAG 44 /* fragment IPv6 header */ +#define TCP_HDRLEN 20 +#define TH_FIN 0x01 + +/* + * We use these macros because the IP header may be at an odd address, + * and some compilers might use word loads to get th_off or ip_hl. + */ + +#define get_ip6nh(x) (((unsigned char *)(x))[6]) +#define get_tcpoff(x) (((unsigned char *)(x))[12] >> 4) +#define get_tcpflags(x) (((unsigned char *)(x))[13]) + +static int ipv6_active_pkt(u_char *pkt, int len) { + u_char *tcp; + + len -= PPP_HDRLEN; + pkt += PPP_HDRLEN; + if (len < IP6_HDRLEN) + return 0; + if (get_ip6nh(pkt) == IP6_NHDR_FRAG) + return 0; + if (get_ip6nh(pkt) != IPPROTO_TCP) + return 1; + if (len < IP6_HDRLEN + TCP_HDRLEN) + return 0; + tcp = pkt + IP6_HDRLEN; + if ((get_tcpflags(tcp) & TH_FIN) != 0 && len == IP6_HDRLEN + get_tcpoff(tcp) * 4) + return 0; + return 1; +} +#endif /* DEMAND_SUPPORT */ + +#endif /* PPP_SUPPORT && PPP_IPV6_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/lcp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/lcp.c index 13169181..90ed183b 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/lcp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/lcp.c @@ -1,2790 +1,2790 @@ -/* - * lcp.c - PPP Link Control Protocol. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -/* - * @todo: - */ - -#if 0 /* UNUSED */ -#include -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/lcp.h" -#if CHAP_SUPPORT -#include "netif/ppp/chap-new.h" -#endif /* CHAP_SUPPORT */ -#include "netif/ppp/magic.h" - -/* - * When the link comes up we want to be able to wait for a short while, - * or until seeing some input from the peer, before starting to send - * configure-requests. We do this by delaying the fsm_lowerup call. - */ -/* steal a bit in fsm flags word */ -#define DELAYED_UP 0x80 - -static void lcp_delayed_up(void *arg); - -/* - * LCP-related command-line options. - */ -#if 0 /* UNUSED */ -int lcp_echo_interval = 0; /* Interval between LCP echo-requests */ -int lcp_echo_fails = 0; /* Tolerance to unanswered echo-requests */ -#endif /* UNUSED */ - -#if 0 /* UNUSED */ -/* options */ -static u_int lcp_echo_interval = LCP_ECHOINTERVAL; /* Interval between LCP echo-requests */ -static u_int lcp_echo_fails = LCP_MAXECHOFAILS; /* Tolerance to unanswered echo-requests */ -#endif /* UNUSED */ - -#if 0 /* UNUSED */ -#if PPP_LCP_ADAPTIVE -bool lcp_echo_adaptive = 0; /* request echo only if the link was idle */ -#endif -bool lax_recv = 0; /* accept control chars in asyncmap */ -bool noendpoint = 0; /* don't send/accept endpoint discriminator */ -#endif /* UNUSED */ - -#if PPP_OPTIONS -static int noopt (char **); -#endif /* PPP_OPTIONS */ - -#ifdef HAVE_MULTILINK -static int setendpoint (char **); -static void printendpoint (option_t *, void (*)(void *, char *, ...), - void *); -#endif /* HAVE_MULTILINK */ - -#if PPP_OPTIONS -static option_t lcp_option_list[] = { - /* LCP options */ - { "-all", o_special_noarg, (void *)noopt, - "Don't request/allow any LCP options" }, - - { "noaccomp", o_bool, &lcp_wantoptions[0].neg_accompression, - "Disable address/control compression", - OPT_A2CLR, &lcp_allowoptions[0].neg_accompression }, - { "-ac", o_bool, &lcp_wantoptions[0].neg_accompression, - "Disable address/control compression", - OPT_ALIAS | OPT_A2CLR, &lcp_allowoptions[0].neg_accompression }, - - { "asyncmap", o_uint32, &lcp_wantoptions[0].asyncmap, - "Set asyncmap (for received packets)", - OPT_OR, &lcp_wantoptions[0].neg_asyncmap }, - { "-as", o_uint32, &lcp_wantoptions[0].asyncmap, - "Set asyncmap (for received packets)", - OPT_ALIAS | OPT_OR, &lcp_wantoptions[0].neg_asyncmap }, - { "default-asyncmap", o_uint32, &lcp_wantoptions[0].asyncmap, - "Disable asyncmap negotiation", - OPT_OR | OPT_NOARG | OPT_VAL(~0U) | OPT_A2CLR, - &lcp_allowoptions[0].neg_asyncmap }, - { "-am", o_uint32, &lcp_wantoptions[0].asyncmap, - "Disable asyncmap negotiation", - OPT_ALIAS | OPT_OR | OPT_NOARG | OPT_VAL(~0U) | OPT_A2CLR, - &lcp_allowoptions[0].neg_asyncmap }, - - { "nomagic", o_bool, &lcp_wantoptions[0].neg_magicnumber, - "Disable magic number negotiation (looped-back line detection)", - OPT_A2CLR, &lcp_allowoptions[0].neg_magicnumber }, - { "-mn", o_bool, &lcp_wantoptions[0].neg_magicnumber, - "Disable magic number negotiation (looped-back line detection)", - OPT_ALIAS | OPT_A2CLR, &lcp_allowoptions[0].neg_magicnumber }, - - { "mru", o_int, &lcp_wantoptions[0].mru, - "Set MRU (maximum received packet size) for negotiation", - OPT_PRIO, &lcp_wantoptions[0].neg_mru }, - { "default-mru", o_bool, &lcp_wantoptions[0].neg_mru, - "Disable MRU negotiation (use default 1500)", - OPT_PRIOSUB | OPT_A2CLR, &lcp_allowoptions[0].neg_mru }, - { "-mru", o_bool, &lcp_wantoptions[0].neg_mru, - "Disable MRU negotiation (use default 1500)", - OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, &lcp_allowoptions[0].neg_mru }, - - { "mtu", o_int, &lcp_allowoptions[0].mru, - "Set our MTU", OPT_LIMITS, NULL, MAXMRU, MINMRU }, - - { "nopcomp", o_bool, &lcp_wantoptions[0].neg_pcompression, - "Disable protocol field compression", - OPT_A2CLR, &lcp_allowoptions[0].neg_pcompression }, - { "-pc", o_bool, &lcp_wantoptions[0].neg_pcompression, - "Disable protocol field compression", - OPT_ALIAS | OPT_A2CLR, &lcp_allowoptions[0].neg_pcompression }, - - { "passive", o_bool, &lcp_wantoptions[0].passive, - "Set passive mode", 1 }, - { "-p", o_bool, &lcp_wantoptions[0].passive, - "Set passive mode", OPT_ALIAS | 1 }, - - { "silent", o_bool, &lcp_wantoptions[0].silent, - "Set silent mode", 1 }, - - { "lcp-echo-failure", o_int, &lcp_echo_fails, - "Set number of consecutive echo failures to indicate link failure", - OPT_PRIO }, - { "lcp-echo-interval", o_int, &lcp_echo_interval, - "Set time in seconds between LCP echo requests", OPT_PRIO }, -#if PPP_LCP_ADAPTIVE - { "lcp-echo-adaptive", o_bool, &lcp_echo_adaptive, - "Suppress LCP echo requests if traffic was received", 1 }, -#endif - { "lcp-restart", o_int, &lcp_fsm[0].timeouttime, - "Set time in seconds between LCP retransmissions", OPT_PRIO }, - { "lcp-max-terminate", o_int, &lcp_fsm[0].maxtermtransmits, - "Set maximum number of LCP terminate-request transmissions", OPT_PRIO }, - { "lcp-max-configure", o_int, &lcp_fsm[0].maxconfreqtransmits, - "Set maximum number of LCP configure-request transmissions", OPT_PRIO }, - { "lcp-max-failure", o_int, &lcp_fsm[0].maxnakloops, - "Set limit on number of LCP configure-naks", OPT_PRIO }, - - { "receive-all", o_bool, &lax_recv, - "Accept all received control characters", 1 }, - -#ifdef HAVE_MULTILINK - { "mrru", o_int, &lcp_wantoptions[0].mrru, - "Maximum received packet size for multilink bundle", - OPT_PRIO, &lcp_wantoptions[0].neg_mrru }, - - { "mpshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf, - "Use short sequence numbers in multilink headers", - OPT_PRIO | 1, &lcp_allowoptions[0].neg_ssnhf }, - { "nompshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf, - "Don't use short sequence numbers in multilink headers", - OPT_PRIOSUB | OPT_A2CLR, &lcp_allowoptions[0].neg_ssnhf }, - - { "endpoint", o_special, (void *) setendpoint, - "Endpoint discriminator for multilink", - OPT_PRIO | OPT_A2PRINTER, (void *) printendpoint }, -#endif /* HAVE_MULTILINK */ - - { "noendpoint", o_bool, &noendpoint, - "Don't send or accept multilink endpoint discriminator", 1 }, - - {NULL} -}; -#endif /* PPP_OPTIONS */ - -/* - * Callbacks for fsm code. (CI = Configuration Information) - */ -static void lcp_resetci(fsm *f); /* Reset our CI */ -static int lcp_cilen(fsm *f); /* Return length of our CI */ -static void lcp_addci(fsm *f, u_char *ucp, int *lenp); /* Add our CI to pkt */ -static int lcp_ackci(fsm *f, u_char *p, int len); /* Peer ack'd our CI */ -static int lcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject); /* Peer nak'd our CI */ -static int lcp_rejci(fsm *f, u_char *p, int len); /* Peer rej'd our CI */ -static int lcp_reqci(fsm *f, u_char *inp, int *lenp, int reject_if_disagree); /* Rcv peer CI */ -static void lcp_up(fsm *f); /* We're UP */ -static void lcp_down(fsm *f); /* We're DOWN */ -static void lcp_starting (fsm *); /* We need lower layer up */ -static void lcp_finished (fsm *); /* We need lower layer down */ -static int lcp_extcode(fsm *f, int code, int id, u_char *inp, int len); -static void lcp_rprotrej(fsm *f, u_char *inp, int len); - -/* - * routines to send LCP echos to peer - */ - -static void lcp_echo_lowerup(ppp_pcb *pcb); -static void lcp_echo_lowerdown(ppp_pcb *pcb); -static void LcpEchoTimeout(void *arg); -static void lcp_received_echo_reply(fsm *f, int id, u_char *inp, int len); -static void LcpSendEchoRequest(fsm *f); -static void LcpLinkFailure(fsm *f); -static void LcpEchoCheck(fsm *f); - -static const fsm_callbacks lcp_callbacks = { /* LCP callback routines */ - lcp_resetci, /* Reset our Configuration Information */ - lcp_cilen, /* Length of our Configuration Information */ - lcp_addci, /* Add our Configuration Information */ - lcp_ackci, /* ACK our Configuration Information */ - lcp_nakci, /* NAK our Configuration Information */ - lcp_rejci, /* Reject our Configuration Information */ - lcp_reqci, /* Request peer's Configuration Information */ - lcp_up, /* Called when fsm reaches OPENED state */ - lcp_down, /* Called when fsm leaves OPENED state */ - lcp_starting, /* Called when we want the lower layer up */ - lcp_finished, /* Called when we want the lower layer down */ - NULL, /* Called when Protocol-Reject received */ - NULL, /* Retransmission is necessary */ - lcp_extcode, /* Called to handle LCP-specific codes */ - "LCP" /* String name of protocol */ -}; - -/* - * Protocol entry points. - * Some of these are called directly. - */ - -static void lcp_init(ppp_pcb *pcb); -static void lcp_input(ppp_pcb *pcb, u_char *p, int len); -static void lcp_protrej(ppp_pcb *pcb); -#if PRINTPKT_SUPPORT -static int lcp_printpkt(const u_char *p, int plen, - void (*printer) (void *, const char *, ...), void *arg); -#endif /* PRINTPKT_SUPPORT */ - -const struct protent lcp_protent = { - PPP_LCP, - lcp_init, - lcp_input, - lcp_protrej, - lcp_lowerup, - lcp_lowerdown, - lcp_open, - lcp_close, -#if PRINTPKT_SUPPORT - lcp_printpkt, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - NULL, -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "LCP", - NULL, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - lcp_option_list, - NULL, -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - NULL, - NULL -#endif /* DEMAND_SUPPORT */ -}; - -/* - * Length of each type of configuration option (in octets) - */ -#define CILEN_VOID 2 -#define CILEN_CHAR 3 -#define CILEN_SHORT 4 /* CILEN_VOID + 2 */ -#if CHAP_SUPPORT -#define CILEN_CHAP 5 /* CILEN_VOID + 2 + 1 */ -#endif /* CHAP_SUPPORT */ -#define CILEN_LONG 6 /* CILEN_VOID + 4 */ -#if LQR_SUPPORT -#define CILEN_LQR 8 /* CILEN_VOID + 2 + 4 */ -#endif /* LQR_SUPPORT */ -#define CILEN_CBCP 3 - -#define CODENAME(x) ((x) == CONFACK ? "ACK" : \ - (x) == CONFNAK ? "NAK" : "REJ") - -#if PPP_OPTIONS -/* - * noopt - Disable all options (why?). - */ -static int -noopt(argv) - char **argv; -{ - BZERO((char *) &lcp_wantoptions[0], sizeof (struct lcp_options)); - BZERO((char *) &lcp_allowoptions[0], sizeof (struct lcp_options)); - - return (1); -} -#endif /* PPP_OPTIONS */ - -#ifdef HAVE_MULTILINK -static int -setendpoint(argv) - char **argv; -{ - if (str_to_epdisc(&lcp_wantoptions[0].endpoint, *argv)) { - lcp_wantoptions[0].neg_endpoint = 1; - return 1; - } - option_error("Can't parse '%s' as an endpoint discriminator", *argv); - return 0; -} - -static void -printendpoint(opt, printer, arg) - option_t *opt; - void (*printer) (void *, char *, ...); - void *arg; -{ - printer(arg, "%s", epdisc_to_str(&lcp_wantoptions[0].endpoint)); -} -#endif /* HAVE_MULTILINK */ - -/* - * lcp_init - Initialize LCP. - */ -static void lcp_init(ppp_pcb *pcb) { - fsm *f = &pcb->lcp_fsm; - lcp_options *wo = &pcb->lcp_wantoptions; - lcp_options *ao = &pcb->lcp_allowoptions; - - f->pcb = pcb; - f->protocol = PPP_LCP; - f->callbacks = &lcp_callbacks; - - fsm_init(f); - - BZERO(wo, sizeof(*wo)); - wo->neg_mru = 1; - wo->mru = PPP_DEFMRU; - wo->neg_asyncmap = 1; - wo->neg_magicnumber = 1; - wo->neg_pcompression = 1; - wo->neg_accompression = 1; - - BZERO(ao, sizeof(*ao)); - ao->neg_mru = 1; - ao->mru = PPP_MAXMRU; - ao->neg_asyncmap = 1; -#if CHAP_SUPPORT - ao->neg_chap = 1; - ao->chap_mdtype = CHAP_MDTYPE_SUPPORTED; -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - ao->neg_upap = 1; -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - ao->neg_eap = 1; -#endif /* EAP_SUPPORT */ - ao->neg_magicnumber = 1; - ao->neg_pcompression = 1; - ao->neg_accompression = 1; - ao->neg_endpoint = 1; -} - - -/* - * lcp_open - LCP is allowed to come up. - */ -void lcp_open(ppp_pcb *pcb) { - fsm *f = &pcb->lcp_fsm; - lcp_options *wo = &pcb->lcp_wantoptions; - - f->flags &= ~(OPT_PASSIVE | OPT_SILENT); - if (wo->passive) - f->flags |= OPT_PASSIVE; - if (wo->silent) - f->flags |= OPT_SILENT; - fsm_open(f); -} - - -/* - * lcp_close - Take LCP down. - */ -void lcp_close(ppp_pcb *pcb, const char *reason) { - fsm *f = &pcb->lcp_fsm; - int oldstate; - - if (pcb->phase != PPP_PHASE_DEAD -#ifdef HAVE_MULTILINK - && pcb->phase != PPP_PHASE_MASTER -#endif /* HAVE_MULTILINK */ - ) - new_phase(pcb, PPP_PHASE_TERMINATE); - - if (f->flags & DELAYED_UP) { - UNTIMEOUT(lcp_delayed_up, f); - f->state = PPP_FSM_STOPPED; - } - oldstate = f->state; - - fsm_close(f, reason); - if (oldstate == PPP_FSM_STOPPED && (f->flags & (OPT_PASSIVE|OPT_SILENT|DELAYED_UP))) { - /* - * This action is not strictly according to the FSM in RFC1548, - * but it does mean that the program terminates if you do a - * lcp_close() when a connection hasn't been established - * because we are in passive/silent mode or because we have - * delayed the fsm_lowerup() call and it hasn't happened yet. - */ - f->flags &= ~DELAYED_UP; - lcp_finished(f); - } -} - - -/* - * lcp_lowerup - The lower layer is up. - */ -void lcp_lowerup(ppp_pcb *pcb) { - lcp_options *wo = &pcb->lcp_wantoptions; - fsm *f = &pcb->lcp_fsm; - /* - * Don't use A/C or protocol compression on transmission, - * but accept A/C and protocol compressed packets - * if we are going to ask for A/C and protocol compression. - */ - if (ppp_send_config(pcb, PPP_MRU, 0xffffffff, 0, 0) < 0 - || ppp_recv_config(pcb, PPP_MRU, (pcb->settings.lax_recv? 0: 0xffffffff), - wo->neg_pcompression, wo->neg_accompression) < 0) - return; - pcb->peer_mru = PPP_MRU; - - if (pcb->settings.listen_time != 0) { - f->flags |= DELAYED_UP; - TIMEOUTMS(lcp_delayed_up, f, pcb->settings.listen_time); - } else - fsm_lowerup(f); -} - - -/* - * lcp_lowerdown - The lower layer is down. - */ -void lcp_lowerdown(ppp_pcb *pcb) { - fsm *f = &pcb->lcp_fsm; - - if (f->flags & DELAYED_UP) { - f->flags &= ~DELAYED_UP; - UNTIMEOUT(lcp_delayed_up, f); - } else - fsm_lowerdown(f); -} - - -/* - * lcp_delayed_up - Bring the lower layer up now. - */ -static void lcp_delayed_up(void *arg) { - fsm *f = (fsm*)arg; - - if (f->flags & DELAYED_UP) { - f->flags &= ~DELAYED_UP; - fsm_lowerup(f); - } -} - - -/* - * lcp_input - Input LCP packet. - */ -static void lcp_input(ppp_pcb *pcb, u_char *p, int len) { - fsm *f = &pcb->lcp_fsm; - - if (f->flags & DELAYED_UP) { - f->flags &= ~DELAYED_UP; - UNTIMEOUT(lcp_delayed_up, f); - fsm_lowerup(f); - } - fsm_input(f, p, len); -} - -/* - * lcp_extcode - Handle a LCP-specific code. - */ -static int lcp_extcode(fsm *f, int code, int id, u_char *inp, int len) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - u_char *magp; - - switch( code ){ - case PROTREJ: - lcp_rprotrej(f, inp, len); - break; - - case ECHOREQ: - if (f->state != PPP_FSM_OPENED) - break; - magp = inp; - PUTLONG(go->magicnumber, magp); - fsm_sdata(f, ECHOREP, id, inp, len); - break; - - case ECHOREP: - lcp_received_echo_reply(f, id, inp, len); - break; - - case DISCREQ: - case IDENTIF: - case TIMEREM: - break; - - default: - return 0; - } - return 1; -} - - -/* - * lcp_rprotrej - Receive an Protocol-Reject. - * - * Figure out which protocol is rejected and inform it. - */ -static void lcp_rprotrej(fsm *f, u_char *inp, int len) { - int i; - const struct protent *protp; - u_short prot; -#if PPP_PROTOCOLNAME - const char *pname; -#endif /* PPP_PROTOCOLNAME */ - - if (len < 2) { - LCPDEBUG(("lcp_rprotrej: Rcvd short Protocol-Reject packet!")); - return; - } - - GETSHORT(prot, inp); - - /* - * Protocol-Reject packets received in any state other than the LCP - * OPENED state SHOULD be silently discarded. - */ - if( f->state != PPP_FSM_OPENED ){ - LCPDEBUG(("Protocol-Reject discarded: LCP in state %d", f->state)); - return; - } - -#if PPP_PROTOCOLNAME - pname = protocol_name(prot); -#endif /* PPP_PROTOCOLNAME */ - - /* - * Upcall the proper Protocol-Reject routine. - */ - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (protp->protocol == prot) { -#if PPP_PROTOCOLNAME - if (pname != NULL) - ppp_dbglog("Protocol-Reject for '%s' (0x%x) received", pname, - prot); - else -#endif /* PPP_PROTOCOLNAME */ - ppp_dbglog("Protocol-Reject for 0x%x received", prot); - (*protp->protrej)(f->pcb); - return; - } - -#if PPP_PROTOCOLNAME - if (pname != NULL) - ppp_warn("Protocol-Reject for unsupported protocol '%s' (0x%x)", pname, - prot); - else -#endif /* #if PPP_PROTOCOLNAME */ - ppp_warn("Protocol-Reject for unsupported protocol 0x%x", prot); -} - - -/* - * lcp_protrej - A Protocol-Reject was received. - */ -/*ARGSUSED*/ -static void lcp_protrej(ppp_pcb *pcb) { - /* - * Can't reject LCP! - */ - ppp_error("Received Protocol-Reject for LCP!"); - fsm_protreject(&pcb->lcp_fsm); -} - - -/* - * lcp_sprotrej - Send a Protocol-Reject for some protocol. - */ -void lcp_sprotrej(ppp_pcb *pcb, u_char *p, int len) { - fsm *f = &pcb->lcp_fsm; - /* - * Send back the protocol and the information field of the - * rejected packet. We only get here if LCP is in the OPENED state. - */ -#if 0 - p += 2; - len -= 2; -#endif - - fsm_sdata(f, PROTREJ, ++f->id, - p, len); -} - - -/* - * lcp_resetci - Reset our CI. - */ -static void lcp_resetci(fsm *f) { - ppp_pcb *pcb = f->pcb; - lcp_options *wo = &pcb->lcp_wantoptions; - lcp_options *go = &pcb->lcp_gotoptions; - lcp_options *ao = &pcb->lcp_allowoptions; - -#if PPP_AUTH_SUPPORT - - /* note: default value is true for allow options */ - if (pcb->settings.user && pcb->settings.passwd) { -#if PAP_SUPPORT - if (pcb->settings.refuse_pap) { - ao->neg_upap = 0; - } -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - if (pcb->settings.refuse_chap) { - ao->chap_mdtype &= ~MDTYPE_MD5; - } -#if MSCHAP_SUPPORT - if (pcb->settings.refuse_mschap) { - ao->chap_mdtype &= ~MDTYPE_MICROSOFT; - } - if (pcb->settings.refuse_mschap_v2) { - ao->chap_mdtype &= ~MDTYPE_MICROSOFT_V2; - } -#endif /* MSCHAP_SUPPORT */ - ao->neg_chap = (ao->chap_mdtype != MDTYPE_NONE); -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - if (pcb->settings.refuse_eap) { - ao->neg_eap = 0; - } -#endif /* EAP_SUPPORT */ - -#if PPP_SERVER - /* note: default value is false for wanted options */ - if (pcb->settings.auth_required) { -#if PAP_SUPPORT - if (!pcb->settings.refuse_pap) { - wo->neg_upap = 1; - } -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - if (!pcb->settings.refuse_chap) { - wo->chap_mdtype |= MDTYPE_MD5; - } -#if MSCHAP_SUPPORT - if (!pcb->settings.refuse_mschap) { - wo->chap_mdtype |= MDTYPE_MICROSOFT; - } - if (!pcb->settings.refuse_mschap_v2) { - wo->chap_mdtype |= MDTYPE_MICROSOFT_V2; - } -#endif /* MSCHAP_SUPPORT */ - wo->neg_chap = (wo->chap_mdtype != MDTYPE_NONE); -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - if (!pcb->settings.refuse_eap) { - wo->neg_eap = 1; - } -#endif /* EAP_SUPPORT */ - } -#endif /* PPP_SERVER */ - - } else { -#if PAP_SUPPORT - ao->neg_upap = 0; -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - ao->neg_chap = 0; - ao->chap_mdtype = MDTYPE_NONE; -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - ao->neg_eap = 0; -#endif /* EAP_SUPPORT */ - } - - PPPDEBUG(LOG_DEBUG, ("ppp: auth protocols:")); -#if PAP_SUPPORT - PPPDEBUG(LOG_DEBUG, (" PAP=%d", ao->neg_upap)); -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - PPPDEBUG(LOG_DEBUG, (" CHAP=%d CHAP_MD5=%d", ao->neg_chap, !!(ao->chap_mdtype&MDTYPE_MD5))); -#if MSCHAP_SUPPORT - PPPDEBUG(LOG_DEBUG, (" CHAP_MS=%d CHAP_MS2=%d", !!(ao->chap_mdtype&MDTYPE_MICROSOFT), !!(ao->chap_mdtype&MDTYPE_MICROSOFT_V2))); -#endif /* MSCHAP_SUPPORT */ -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - PPPDEBUG(LOG_DEBUG, (" EAP=%d", ao->neg_eap)); -#endif /* EAP_SUPPORT */ - PPPDEBUG(LOG_DEBUG, ("\n")); - -#endif /* PPP_AUTH_SUPPORT */ - - wo->magicnumber = magic(); - wo->numloops = 0; - *go = *wo; -#ifdef HAVE_MULTILINK - if (!multilink) { - go->neg_mrru = 0; -#endif /* HAVE_MULTILINK */ - go->neg_ssnhf = 0; - go->neg_endpoint = 0; -#ifdef HAVE_MULTILINK - } -#endif /* HAVE_MULTILINK */ - if (pcb->settings.noendpoint) - ao->neg_endpoint = 0; - pcb->peer_mru = PPP_MRU; -#if 0 /* UNUSED */ - auth_reset(pcb); -#endif /* UNUSED */ -} - - -/* - * lcp_cilen - Return length of our CI. - */ -static int lcp_cilen(fsm *f) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - -#define LENCIVOID(neg) ((neg) ? CILEN_VOID : 0) -#if CHAP_SUPPORT -#define LENCICHAP(neg) ((neg) ? CILEN_CHAP : 0) -#endif /* CHAP_SUPPORT */ -#define LENCISHORT(neg) ((neg) ? CILEN_SHORT : 0) -#define LENCILONG(neg) ((neg) ? CILEN_LONG : 0) -#if LQR_SUPPORT -#define LENCILQR(neg) ((neg) ? CILEN_LQR: 0) -#endif /* LQR_SUPPORT */ -#define LENCICBCP(neg) ((neg) ? CILEN_CBCP: 0) - /* - * NB: we only ask for one of CHAP, UPAP, or EAP, even if we will - * accept more than one. We prefer EAP first, then CHAP, then - * PAP. - */ - return (LENCISHORT(go->neg_mru && go->mru != PPP_DEFMRU) + - LENCILONG(go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) + -#if EAP_SUPPORT - LENCISHORT(go->neg_eap) + -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ -#if EAP_SUPPORT - LENCICHAP(!go->neg_eap && go->neg_chap) + -#endif /* EAP_SUPPORT */ -#if !EAP_SUPPORT - LENCICHAP(go->neg_chap) + -#endif /* !EAP_SUPPORT */ -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ -#if EAP_SUPPORT && CHAP_SUPPORT - LENCISHORT(!go->neg_eap && !go->neg_chap && go->neg_upap) + -#endif /* EAP_SUPPORT && CHAP_SUPPORT */ -#if EAP_SUPPORT && !CHAP_SUPPORT - LENCISHORT(!go->neg_eap && go->neg_upap) + -#endif /* EAP_SUPPORT && !CHAP_SUPPORT */ -#if !EAP_SUPPORT && CHAP_SUPPORT - LENCISHORT(!go->neg_chap && go->neg_upap) + -#endif /* !EAP_SUPPORT && CHAP_SUPPORT */ -#if !EAP_SUPPORT && !CHAP_SUPPORT - LENCISHORT(go->neg_upap) + -#endif /* !EAP_SUPPORT && !CHAP_SUPPORT */ -#endif /* PAP_SUPPORT */ -#if LQR_SUPPORT - LENCILQR(go->neg_lqr) + -#endif /* LQR_SUPPORT */ - LENCICBCP(go->neg_cbcp) + - LENCILONG(go->neg_magicnumber) + - LENCIVOID(go->neg_pcompression) + - LENCIVOID(go->neg_accompression) + -#ifdef HAVE_MULTILINK - LENCISHORT(go->neg_mrru) + -#endif /* HAVE_MULTILINK */ - LENCIVOID(go->neg_ssnhf) + - (go->neg_endpoint? CILEN_CHAR + go->endpoint.length: 0)); -} - - -/* - * lcp_addci - Add our desired CIs to a packet. - */ -static void lcp_addci(fsm *f, u_char *ucp, int *lenp) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - u_char *start_ucp = ucp; - -#define ADDCIVOID(opt, neg) \ - if (neg) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_VOID, ucp); \ - } -#define ADDCISHORT(opt, neg, val) \ - if (neg) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_SHORT, ucp); \ - PUTSHORT(val, ucp); \ - } -#if CHAP_SUPPORT -#define ADDCICHAP(opt, neg, val) \ - if (neg) { \ - PUTCHAR((opt), ucp); \ - PUTCHAR(CILEN_CHAP, ucp); \ - PUTSHORT(PPP_CHAP, ucp); \ - PUTCHAR((CHAP_DIGEST(val)), ucp); \ - } -#endif /* CHAP_SUPPORT */ -#define ADDCILONG(opt, neg, val) \ - if (neg) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_LONG, ucp); \ - PUTLONG(val, ucp); \ - } -#if LQR_SUPPORT -#define ADDCILQR(opt, neg, val) \ - if (neg) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_LQR, ucp); \ - PUTSHORT(PPP_LQR, ucp); \ - PUTLONG(val, ucp); \ - } -#endif /* LQR_SUPPORT */ -#define ADDCICHAR(opt, neg, val) \ - if (neg) { \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_CHAR, ucp); \ - PUTCHAR(val, ucp); \ - } -#define ADDCIENDP(opt, neg, class, val, len) \ - if (neg) { \ - int i; \ - PUTCHAR(opt, ucp); \ - PUTCHAR(CILEN_CHAR + len, ucp); \ - PUTCHAR(class, ucp); \ - for (i = 0; i < len; ++i) \ - PUTCHAR(val[i], ucp); \ - } - - ADDCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru); - ADDCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF, - go->asyncmap); -#if EAP_SUPPORT - ADDCISHORT(CI_AUTHTYPE, go->neg_eap, PPP_EAP); -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ -#if EAP_SUPPORT - ADDCICHAP(CI_AUTHTYPE, !go->neg_eap && go->neg_chap, go->chap_mdtype); -#endif /* EAP_SUPPORT */ -#if !EAP_SUPPORT - ADDCICHAP(CI_AUTHTYPE, go->neg_chap, go->chap_mdtype); -#endif /* !EAP_SUPPORT */ -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ -#if EAP_SUPPORT && CHAP_SUPPORT - ADDCISHORT(CI_AUTHTYPE, !go->neg_eap && !go->neg_chap && go->neg_upap, PPP_PAP); -#endif /* EAP_SUPPORT && CHAP_SUPPORT */ -#if EAP_SUPPORT && !CHAP_SUPPORT - ADDCISHORT(CI_AUTHTYPE, !go->neg_eap && go->neg_upap, PPP_PAP); -#endif /* EAP_SUPPORT && !CHAP_SUPPORT */ -#if !EAP_SUPPORT && CHAP_SUPPORT - ADDCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP); -#endif /* !EAP_SUPPORT && CHAP_SUPPORT */ -#if !EAP_SUPPORT && !CHAP_SUPPORT - ADDCISHORT(CI_AUTHTYPE, go->neg_upap, PPP_PAP); -#endif /* !EAP_SUPPORT && !CHAP_SUPPORT */ -#endif /* PAP_SUPPORT */ -#if LQR_SUPPORT - ADDCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period); -#endif /* LQR_SUPPORT */ - ADDCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT); - ADDCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber); - ADDCIVOID(CI_PCOMPRESSION, go->neg_pcompression); - ADDCIVOID(CI_ACCOMPRESSION, go->neg_accompression); -#ifdef HAVE_MULTILINK - ADDCISHORT(CI_MRRU, go->neg_mrru, go->mrru); -#endif - ADDCIVOID(CI_SSNHF, go->neg_ssnhf); - ADDCIENDP(CI_EPDISC, go->neg_endpoint, go->endpoint.class_, - go->endpoint.value, go->endpoint.length); - - if (ucp - start_ucp != *lenp) { - /* this should never happen, because peer_mtu should be 1500 */ - ppp_error("Bug in lcp_addci: wrong length"); - } -} - - -/* - * lcp_ackci - Ack our CIs. - * This should not modify any state if the Ack is bad. - * - * Returns: - * 0 - Ack was bad. - * 1 - Ack was good. - */ -static int lcp_ackci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - u_char cilen, citype, cichar; - u_short cishort; - u32_t cilong; - - /* - * CIs must be in exactly the same order that we sent. - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ -#define ACKCIVOID(opt, neg) \ - if (neg) { \ - if ((len -= CILEN_VOID) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_VOID || \ - citype != opt) \ - goto bad; \ - } -#define ACKCISHORT(opt, neg, val) \ - if (neg) { \ - if ((len -= CILEN_SHORT) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_SHORT || \ - citype != opt) \ - goto bad; \ - GETSHORT(cishort, p); \ - if (cishort != val) \ - goto bad; \ - } -#define ACKCICHAR(opt, neg, val) \ - if (neg) { \ - if ((len -= CILEN_CHAR) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_CHAR || \ - citype != opt) \ - goto bad; \ - GETCHAR(cichar, p); \ - if (cichar != val) \ - goto bad; \ - } -#if CHAP_SUPPORT -#define ACKCICHAP(opt, neg, val) \ - if (neg) { \ - if ((len -= CILEN_CHAP) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_CHAP || \ - citype != (opt)) \ - goto bad; \ - GETSHORT(cishort, p); \ - if (cishort != PPP_CHAP) \ - goto bad; \ - GETCHAR(cichar, p); \ - if (cichar != (CHAP_DIGEST(val))) \ - goto bad; \ - } -#endif /* CHAP_SUPPORT */ -#define ACKCILONG(opt, neg, val) \ - if (neg) { \ - if ((len -= CILEN_LONG) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_LONG || \ - citype != opt) \ - goto bad; \ - GETLONG(cilong, p); \ - if (cilong != val) \ - goto bad; \ - } -#if LQR_SUPPORT -#define ACKCILQR(opt, neg, val) \ - if (neg) { \ - if ((len -= CILEN_LQR) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_LQR || \ - citype != opt) \ - goto bad; \ - GETSHORT(cishort, p); \ - if (cishort != PPP_LQR) \ - goto bad; \ - GETLONG(cilong, p); \ - if (cilong != val) \ - goto bad; \ - } -#endif /* LQR_SUPPORT */ -#define ACKCIENDP(opt, neg, class, val, vlen) \ - if (neg) { \ - int i; \ - if ((len -= CILEN_CHAR + vlen) < 0) \ - goto bad; \ - GETCHAR(citype, p); \ - GETCHAR(cilen, p); \ - if (cilen != CILEN_CHAR + vlen || \ - citype != opt) \ - goto bad; \ - GETCHAR(cichar, p); \ - if (cichar != class) \ - goto bad; \ - for (i = 0; i < vlen; ++i) { \ - GETCHAR(cichar, p); \ - if (cichar != val[i]) \ - goto bad; \ - } \ - } - - ACKCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru); - ACKCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF, - go->asyncmap); -#if EAP_SUPPORT - ACKCISHORT(CI_AUTHTYPE, go->neg_eap, PPP_EAP); -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ -#if EAP_SUPPORT - ACKCICHAP(CI_AUTHTYPE, !go->neg_eap && go->neg_chap, go->chap_mdtype); -#endif /* EAP_SUPPORT */ -#if !EAP_SUPPORT - ACKCICHAP(CI_AUTHTYPE, go->neg_chap, go->chap_mdtype); -#endif /* !EAP_SUPPORT */ -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ -#if EAP_SUPPORT && CHAP_SUPPORT - ACKCISHORT(CI_AUTHTYPE, !go->neg_eap && !go->neg_chap && go->neg_upap, PPP_PAP); -#endif /* EAP_SUPPORT && CHAP_SUPPORT */ -#if EAP_SUPPORT && !CHAP_SUPPORT - ACKCISHORT(CI_AUTHTYPE, !go->neg_eap && go->neg_upap, PPP_PAP); -#endif /* EAP_SUPPORT && !CHAP_SUPPORT */ -#if !EAP_SUPPORT && CHAP_SUPPORT - ACKCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP); -#endif /* !EAP_SUPPORT && CHAP_SUPPORT */ -#if !EAP_SUPPORT && !CHAP_SUPPORT - ACKCISHORT(CI_AUTHTYPE, go->neg_upap, PPP_PAP); -#endif /* !EAP_SUPPORT && !CHAP_SUPPORT */ -#endif /* PAP_SUPPORT */ -#if LQR_SUPPORT - ACKCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period); -#endif /* LQR_SUPPORT */ - ACKCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT); - ACKCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber); - ACKCIVOID(CI_PCOMPRESSION, go->neg_pcompression); - ACKCIVOID(CI_ACCOMPRESSION, go->neg_accompression); -#ifdef HAVE_MULTILINK - ACKCISHORT(CI_MRRU, go->neg_mrru, go->mrru); -#endif /* HAVE_MULTILINK */ - ACKCIVOID(CI_SSNHF, go->neg_ssnhf); - ACKCIENDP(CI_EPDISC, go->neg_endpoint, go->endpoint.class_, - go->endpoint.value, go->endpoint.length); - - /* - * If there are any remaining CIs, then this packet is bad. - */ - if (len != 0) - goto bad; - return (1); -bad: - LCPDEBUG(("lcp_acki: received bad Ack!")); - return (0); -} - - -/* - * lcp_nakci - Peer has sent a NAK for some of our CIs. - * This should not modify any state if the Nak is bad - * or if LCP is in the OPENED state. - * - * Returns: - * 0 - Nak was bad. - * 1 - Nak was good. - */ -static int lcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - lcp_options *wo = &pcb->lcp_wantoptions; - u_char citype, cichar, *next; - u_short cishort; - u32_t cilong; - lcp_options no; /* options we've seen Naks for */ - lcp_options try_; /* options to request next time */ - int looped_back = 0; - int cilen; - - BZERO(&no, sizeof(no)); - try_ = *go; - - /* - * Any Nak'd CIs must be in exactly the same order that we sent. - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ -#define NAKCIVOID(opt, neg) \ - if (go->neg && \ - len >= CILEN_VOID && \ - p[1] == CILEN_VOID && \ - p[0] == opt) { \ - len -= CILEN_VOID; \ - INCPTR(CILEN_VOID, p); \ - no.neg = 1; \ - try_.neg = 0; \ - } -#if CHAP_SUPPORT -#define NAKCICHAP(opt, neg, code) \ - if (go->neg && \ - len >= CILEN_CHAP && \ - p[1] == CILEN_CHAP && \ - p[0] == opt) { \ - len -= CILEN_CHAP; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - GETCHAR(cichar, p); \ - no.neg = 1; \ - code \ - } -#endif /* CHAP_SUPPORT */ -#define NAKCICHAR(opt, neg, code) \ - if (go->neg && \ - len >= CILEN_CHAR && \ - p[1] == CILEN_CHAR && \ - p[0] == opt) { \ - len -= CILEN_CHAR; \ - INCPTR(2, p); \ - GETCHAR(cichar, p); \ - no.neg = 1; \ - code \ - } -#define NAKCISHORT(opt, neg, code) \ - if (go->neg && \ - len >= CILEN_SHORT && \ - p[1] == CILEN_SHORT && \ - p[0] == opt) { \ - len -= CILEN_SHORT; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - no.neg = 1; \ - code \ - } -#define NAKCILONG(opt, neg, code) \ - if (go->neg && \ - len >= CILEN_LONG && \ - p[1] == CILEN_LONG && \ - p[0] == opt) { \ - len -= CILEN_LONG; \ - INCPTR(2, p); \ - GETLONG(cilong, p); \ - no.neg = 1; \ - code \ - } -#if LQR_SUPPORT -#define NAKCILQR(opt, neg, code) \ - if (go->neg && \ - len >= CILEN_LQR && \ - p[1] == CILEN_LQR && \ - p[0] == opt) { \ - len -= CILEN_LQR; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - GETLONG(cilong, p); \ - no.neg = 1; \ - code \ - } -#endif /* LQR_SUPPORT */ -#define NAKCIENDP(opt, neg) \ - if (go->neg && \ - len >= CILEN_CHAR && \ - p[0] == opt && \ - p[1] >= CILEN_CHAR && \ - p[1] <= len) { \ - len -= p[1]; \ - INCPTR(p[1], p); \ - no.neg = 1; \ - try_.neg = 0; \ - } - - /* - * NOTE! There must be no assignments to individual fields of *go in - * the code below. Any such assignment is a BUG! - */ - /* - * We don't care if they want to send us smaller packets than - * we want. Therefore, accept any MRU less than what we asked for, - * but then ignore the new value when setting the MRU in the kernel. - * If they send us a bigger MRU than what we asked, accept it, up to - * the limit of the default MRU we'd get if we didn't negotiate. - */ - if (go->neg_mru && go->mru != PPP_DEFMRU) { - NAKCISHORT(CI_MRU, neg_mru, - if (cishort <= wo->mru || cishort <= PPP_DEFMRU) - try_.mru = cishort; - ); - } - - /* - * Add any characters they want to our (receive-side) asyncmap. - */ - if (go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) { - NAKCILONG(CI_ASYNCMAP, neg_asyncmap, - try_.asyncmap = go->asyncmap | cilong; - ); - } - - /* - * If they've nak'd our authentication-protocol, check whether - * they are proposing a different protocol, or a different - * hash algorithm for CHAP. - */ - if ((0 -#if CHAP_SUPPORT - || go->neg_chap -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - || go->neg_upap -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - || go->neg_eap -#endif /* EAP_SUPPORT */ - ) - && len >= CILEN_SHORT - && p[0] == CI_AUTHTYPE && p[1] >= CILEN_SHORT && p[1] <= len) { - cilen = p[1]; - len -= cilen; -#if CHAP_SUPPORT - no.neg_chap = go->neg_chap; -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - no.neg_upap = go->neg_upap; -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - no.neg_eap = go->neg_eap; -#endif /* EAP_SUPPORT */ - INCPTR(2, p); - GETSHORT(cishort, p); - -#if PAP_SUPPORT - if (cishort == PPP_PAP && cilen == CILEN_SHORT) { -#if EAP_SUPPORT - /* If we were asking for EAP, then we need to stop that. */ - if (go->neg_eap) - try_.neg_eap = 0; - else -#endif /* EAP_SUPPORT */ - -#if CHAP_SUPPORT - /* If we were asking for CHAP, then we need to stop that. */ - if (go->neg_chap) - try_.neg_chap = 0; - else -#endif /* CHAP_SUPPORT */ - - /* - * If we weren't asking for CHAP or EAP, then we were asking for - * PAP, in which case this Nak is bad. - */ - goto bad; - } else -#endif /* PAP_SUPPORT */ - -#if CHAP_SUPPORT - if (cishort == PPP_CHAP && cilen == CILEN_CHAP) { - GETCHAR(cichar, p); -#if EAP_SUPPORT - /* Stop asking for EAP, if we were. */ - if (go->neg_eap) { - try_.neg_eap = 0; - /* Try to set up to use their suggestion, if possible */ - if (CHAP_CANDIGEST(go->chap_mdtype, cichar)) - try_.chap_mdtype = CHAP_MDTYPE_D(cichar); - } else -#endif /* EAP_SUPPORT */ - if (go->neg_chap) { - /* - * We were asking for our preferred algorithm, they must - * want something different. - */ - if (cichar != CHAP_DIGEST(go->chap_mdtype)) { - if (CHAP_CANDIGEST(go->chap_mdtype, cichar)) { - /* Use their suggestion if we support it ... */ - try_.chap_mdtype = CHAP_MDTYPE_D(cichar); - } else { - /* ... otherwise, try our next-preferred algorithm. */ - try_.chap_mdtype &= ~(CHAP_MDTYPE(try_.chap_mdtype)); - if (try_.chap_mdtype == MDTYPE_NONE) /* out of algos */ - try_.neg_chap = 0; - } - } else { - /* - * Whoops, they Nak'd our algorithm of choice - * but then suggested it back to us. - */ - goto bad; - } - } else { - /* - * Stop asking for PAP if we were asking for it. - */ -#if PAP_SUPPORT - try_.neg_upap = 0; -#endif /* PAP_SUPPORT */ - } - - } else -#endif /* CHAP_SUPPORT */ - { - -#if EAP_SUPPORT - /* - * If we were asking for EAP, and they're Conf-Naking EAP, - * well, that's just strange. Nobody should do that. - */ - if (cishort == PPP_EAP && cilen == CILEN_SHORT && go->neg_eap) - ppp_dbglog("Unexpected Conf-Nak for EAP"); - - /* - * We don't recognize what they're suggesting. - * Stop asking for what we were asking for. - */ - if (go->neg_eap) - try_.neg_eap = 0; - else -#endif /* EAP_SUPPORT */ - -#if CHAP_SUPPORT - if (go->neg_chap) - try_.neg_chap = 0; - else -#endif /* CHAP_SUPPORT */ - -#if PAP_SUPPORT - if(1) - try_.neg_upap = 0; - else -#endif /* PAP_SUPPORT */ - {} - - p += cilen - CILEN_SHORT; - } - } - -#if LQR_SUPPORT - /* - * If they can't cope with our link quality protocol, we'll have - * to stop asking for LQR. We haven't got any other protocol. - * If they Nak the reporting period, take their value XXX ? - */ - NAKCILQR(CI_QUALITY, neg_lqr, - if (cishort != PPP_LQR) - try_.neg_lqr = 0; - else - try_.lqr_period = cilong; - ); -#endif /* LQR_SUPPORT */ - - /* - * Only implementing CBCP...not the rest of the callback options - */ - NAKCICHAR(CI_CALLBACK, neg_cbcp, - try_.neg_cbcp = 0; - (void)cichar; /* if CHAP support is not compiled, cichar is set but not used, which makes some compilers complaining */ - ); - - /* - * Check for a looped-back line. - */ - NAKCILONG(CI_MAGICNUMBER, neg_magicnumber, - try_.magicnumber = magic(); - looped_back = 1; - ); - - /* - * Peer shouldn't send Nak for protocol compression or - * address/control compression requests; they should send - * a Reject instead. If they send a Nak, treat it as a Reject. - */ - NAKCIVOID(CI_PCOMPRESSION, neg_pcompression); - NAKCIVOID(CI_ACCOMPRESSION, neg_accompression); - -#ifdef HAVE_MULTILINK - /* - * Nak for MRRU option - accept their value if it is smaller - * than the one we want. - */ - if (go->neg_mrru) { - NAKCISHORT(CI_MRRU, neg_mrru, - if (treat_as_reject) - try_.neg_mrru = 0; - else if (cishort <= wo->mrru) - try_.mrru = cishort; - ); - } -#else /* HAVE_MULTILINK */ - LWIP_UNUSED_ARG(treat_as_reject); -#endif /* HAVE_MULTILINK */ - - /* - * Nak for short sequence numbers shouldn't be sent, treat it - * like a reject. - */ - NAKCIVOID(CI_SSNHF, neg_ssnhf); - - /* - * Nak of the endpoint discriminator option is not permitted, - * treat it like a reject. - */ - NAKCIENDP(CI_EPDISC, neg_endpoint); - - /* - * There may be remaining CIs, if the peer is requesting negotiation - * on an option that we didn't include in our request packet. - * If we see an option that we requested, or one we've already seen - * in this packet, then this packet is bad. - * If we wanted to respond by starting to negotiate on the requested - * option(s), we could, but we don't, because except for the - * authentication type and quality protocol, if we are not negotiating - * an option, it is because we were told not to. - * For the authentication type, the Nak from the peer means - * `let me authenticate myself with you' which is a bit pointless. - * For the quality protocol, the Nak means `ask me to send you quality - * reports', but if we didn't ask for them, we don't want them. - * An option we don't recognize represents the peer asking to - * negotiate some option we don't support, so ignore it. - */ - while (len >= CILEN_VOID) { - GETCHAR(citype, p); - GETCHAR(cilen, p); - if (cilen < CILEN_VOID || (len -= cilen) < 0) - goto bad; - next = p + cilen - 2; - - switch (citype) { - case CI_MRU: - if ((go->neg_mru && go->mru != PPP_DEFMRU) - || no.neg_mru || cilen != CILEN_SHORT) - goto bad; - GETSHORT(cishort, p); - if (cishort < PPP_DEFMRU) { - try_.neg_mru = 1; - try_.mru = cishort; - } - break; - case CI_ASYNCMAP: - if ((go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) - || no.neg_asyncmap || cilen != CILEN_LONG) - goto bad; - break; - case CI_AUTHTYPE: - if (0 -#if CHAP_SUPPORT - || go->neg_chap || no.neg_chap -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - || go->neg_upap || no.neg_upap -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - || go->neg_eap || no.neg_eap -#endif /* EAP_SUPPORT */ - ) - goto bad; - break; - case CI_MAGICNUMBER: - if (go->neg_magicnumber || no.neg_magicnumber || - cilen != CILEN_LONG) - goto bad; - break; - case CI_PCOMPRESSION: - if (go->neg_pcompression || no.neg_pcompression - || cilen != CILEN_VOID) - goto bad; - break; - case CI_ACCOMPRESSION: - if (go->neg_accompression || no.neg_accompression - || cilen != CILEN_VOID) - goto bad; - break; -#if LQR_SUPPORT - case CI_QUALITY: - if (go->neg_lqr || no.neg_lqr || cilen != CILEN_LQR) - goto bad; - break; -#endif /* LQR_SUPPORT */ -#ifdef HAVE_MULTILINK - case CI_MRRU: - if (go->neg_mrru || no.neg_mrru || cilen != CILEN_SHORT) - goto bad; - break; -#endif /* HAVE_MULTILINK */ - case CI_SSNHF: - if (go->neg_ssnhf || no.neg_ssnhf || cilen != CILEN_VOID) - goto bad; - try_.neg_ssnhf = 1; - break; - case CI_EPDISC: - if (go->neg_endpoint || no.neg_endpoint || cilen < CILEN_CHAR) - goto bad; - break; - default: - break; - } - p = next; - } - - /* - * OK, the Nak is good. Now we can update state. - * If there are any options left we ignore them. - */ - if (f->state != PPP_FSM_OPENED) { - if (looped_back) { - if (++try_.numloops >= pcb->settings.lcp_loopbackfail) { - ppp_notice("Serial line is looped back."); - pcb->err_code = PPPERR_LOOPBACK; - lcp_close(f->pcb, "Loopback detected"); - } - } else - try_.numloops = 0; - *go = try_; - } - - return 1; - -bad: - LCPDEBUG(("lcp_nakci: received bad Nak!")); - return 0; -} - - -/* - * lcp_rejci - Peer has Rejected some of our CIs. - * This should not modify any state if the Reject is bad - * or if LCP is in the OPENED state. - * - * Returns: - * 0 - Reject was bad. - * 1 - Reject was good. - */ -static int lcp_rejci(fsm *f, u_char *p, int len) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - u_char cichar; - u_short cishort; - u32_t cilong; - lcp_options try_; /* options to request next time */ - - try_ = *go; - - /* - * Any Rejected CIs must be in exactly the same order that we sent. - * Check packet length and CI length at each step. - * If we find any deviations, then this packet is bad. - */ -#define REJCIVOID(opt, neg) \ - if (go->neg && \ - len >= CILEN_VOID && \ - p[1] == CILEN_VOID && \ - p[0] == opt) { \ - len -= CILEN_VOID; \ - INCPTR(CILEN_VOID, p); \ - try_.neg = 0; \ - } -#define REJCISHORT(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_SHORT && \ - p[1] == CILEN_SHORT && \ - p[0] == opt) { \ - len -= CILEN_SHORT; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - /* Check rejected value. */ \ - if (cishort != val) \ - goto bad; \ - try_.neg = 0; \ - } - -#if CHAP_SUPPORT && EAP_SUPPORT && PAP_SUPPORT -#define REJCICHAP(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_CHAP && \ - p[1] == CILEN_CHAP && \ - p[0] == opt) { \ - len -= CILEN_CHAP; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - GETCHAR(cichar, p); \ - /* Check rejected value. */ \ - if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ - goto bad; \ - try_.neg = 0; \ - try_.neg_eap = try_.neg_upap = 0; \ - } -#endif /* CHAP_SUPPORT && EAP_SUPPORT && PAP_SUPPORT */ - -#if CHAP_SUPPORT && !EAP_SUPPORT && PAP_SUPPORT -#define REJCICHAP(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_CHAP && \ - p[1] == CILEN_CHAP && \ - p[0] == opt) { \ - len -= CILEN_CHAP; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - GETCHAR(cichar, p); \ - /* Check rejected value. */ \ - if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ - goto bad; \ - try_.neg = 0; \ - try_.neg_upap = 0; \ - } -#endif /* CHAP_SUPPORT && !EAP_SUPPORT && PAP_SUPPORT */ - -#if CHAP_SUPPORT && EAP_SUPPORT && !PAP_SUPPORT -#define REJCICHAP(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_CHAP && \ - p[1] == CILEN_CHAP && \ - p[0] == opt) { \ - len -= CILEN_CHAP; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - GETCHAR(cichar, p); \ - /* Check rejected value. */ \ - if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ - goto bad; \ - try_.neg = 0; \ - try_.neg_eap = 0; \ - } -#endif /* CHAP_SUPPORT && EAP_SUPPORT && !PAP_SUPPORT */ - -#if CHAP_SUPPORT && !EAP_SUPPORT && !PAP_SUPPORT -#define REJCICHAP(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_CHAP && \ - p[1] == CILEN_CHAP && \ - p[0] == opt) { \ - len -= CILEN_CHAP; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - GETCHAR(cichar, p); \ - /* Check rejected value. */ \ - if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ - goto bad; \ - try_.neg = 0; \ - } -#endif /* CHAP_SUPPORT && !EAP_SUPPORT && !PAP_SUPPORT */ - -#define REJCILONG(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_LONG && \ - p[1] == CILEN_LONG && \ - p[0] == opt) { \ - len -= CILEN_LONG; \ - INCPTR(2, p); \ - GETLONG(cilong, p); \ - /* Check rejected value. */ \ - if (cilong != val) \ - goto bad; \ - try_.neg = 0; \ - } -#if LQR_SUPPORT -#define REJCILQR(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_LQR && \ - p[1] == CILEN_LQR && \ - p[0] == opt) { \ - len -= CILEN_LQR; \ - INCPTR(2, p); \ - GETSHORT(cishort, p); \ - GETLONG(cilong, p); \ - /* Check rejected value. */ \ - if (cishort != PPP_LQR || cilong != val) \ - goto bad; \ - try_.neg = 0; \ - } -#endif /* LQR_SUPPORT */ -#define REJCICBCP(opt, neg, val) \ - if (go->neg && \ - len >= CILEN_CBCP && \ - p[1] == CILEN_CBCP && \ - p[0] == opt) { \ - len -= CILEN_CBCP; \ - INCPTR(2, p); \ - GETCHAR(cichar, p); \ - /* Check rejected value. */ \ - if (cichar != val) \ - goto bad; \ - try_.neg = 0; \ - } -#define REJCIENDP(opt, neg, class, val, vlen) \ - if (go->neg && \ - len >= CILEN_CHAR + vlen && \ - p[0] == opt && \ - p[1] == CILEN_CHAR + vlen) { \ - int i; \ - len -= CILEN_CHAR + vlen; \ - INCPTR(2, p); \ - GETCHAR(cichar, p); \ - if (cichar != class) \ - goto bad; \ - for (i = 0; i < vlen; ++i) { \ - GETCHAR(cichar, p); \ - if (cichar != val[i]) \ - goto bad; \ - } \ - try_.neg = 0; \ - } - - REJCISHORT(CI_MRU, neg_mru, go->mru); - REJCILONG(CI_ASYNCMAP, neg_asyncmap, go->asyncmap); -#if EAP_SUPPORT - REJCISHORT(CI_AUTHTYPE, neg_eap, PPP_EAP); - if (!go->neg_eap) { -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT - REJCICHAP(CI_AUTHTYPE, neg_chap, go->chap_mdtype); - if (!go->neg_chap) { -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - REJCISHORT(CI_AUTHTYPE, neg_upap, PPP_PAP); -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - } -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - } -#endif /* EAP_SUPPORT */ -#if LQR_SUPPORT - REJCILQR(CI_QUALITY, neg_lqr, go->lqr_period); -#endif /* LQR_SUPPORT */ - REJCICBCP(CI_CALLBACK, neg_cbcp, CBCP_OPT); - REJCILONG(CI_MAGICNUMBER, neg_magicnumber, go->magicnumber); - REJCIVOID(CI_PCOMPRESSION, neg_pcompression); - REJCIVOID(CI_ACCOMPRESSION, neg_accompression); -#ifdef HAVE_MULTILINK - REJCISHORT(CI_MRRU, neg_mrru, go->mrru); -#endif /* HAVE_MULTILINK */ - REJCIVOID(CI_SSNHF, neg_ssnhf); - REJCIENDP(CI_EPDISC, neg_endpoint, go->endpoint.class_, - go->endpoint.value, go->endpoint.length); - - /* - * If there are any remaining CIs, then this packet is bad. - */ - if (len != 0) - goto bad; - /* - * Now we can update state. - */ - if (f->state != PPP_FSM_OPENED) - *go = try_; - return 1; - -bad: - LCPDEBUG(("lcp_rejci: received bad Reject!")); - return 0; -} - - -/* - * lcp_reqci - Check the peer's requested CIs and send appropriate response. - * - * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified - * appropriately. If reject_if_disagree is non-zero, doesn't return - * CONFNAK; returns CONFREJ if it can't return CONFACK. - * - * inp = Requested CIs - * lenp = Length of requested CIs - */ -static int lcp_reqci(fsm *f, u_char *inp, int *lenp, int reject_if_disagree) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - lcp_options *ho = &pcb->lcp_hisoptions; - lcp_options *ao = &pcb->lcp_allowoptions; - u_char *cip, *next; /* Pointer to current and next CIs */ - int cilen, citype, cichar; /* Parsed len, type, char value */ - u_short cishort; /* Parsed short value */ - u32_t cilong; /* Parse long value */ - int rc = CONFACK; /* Final packet return code */ - int orc; /* Individual option return code */ - u_char *p; /* Pointer to next char to parse */ - u_char *rejp; /* Pointer to next char in reject frame */ - struct pbuf *nakp; /* Nak buffer */ - u_char *nakoutp; /* Pointer to next char in Nak frame */ - int l = *lenp; /* Length left */ - - /* - * Reset all his options. - */ - BZERO(ho, sizeof(*ho)); - - /* - * Process all his options. - */ - next = inp; - nakp = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_CTRL_PBUF_MAX_SIZE), PPP_CTRL_PBUF_TYPE); - if(NULL == nakp) - return 0; - if(nakp->tot_len != nakp->len) { - pbuf_free(nakp); - return 0; - } - - nakoutp = (u_char*)nakp->payload; - rejp = inp; - while (l) { - orc = CONFACK; /* Assume success */ - cip = p = next; /* Remember begining of CI */ - if (l < 2 || /* Not enough data for CI header or */ - p[1] < 2 || /* CI length too small or */ - p[1] > l) { /* CI length too big? */ - LCPDEBUG(("lcp_reqci: bad CI length!")); - orc = CONFREJ; /* Reject bad CI */ - cilen = l; /* Reject till end of packet */ - l = 0; /* Don't loop again */ - citype = 0; - goto endswitch; - } - GETCHAR(citype, p); /* Parse CI type */ - GETCHAR(cilen, p); /* Parse CI length */ - l -= cilen; /* Adjust remaining length */ - next += cilen; /* Step to next CI */ - - switch (citype) { /* Check CI type */ - case CI_MRU: - if (!ao->neg_mru || /* Allow option? */ - cilen != CILEN_SHORT) { /* Check CI length */ - orc = CONFREJ; /* Reject CI */ - break; - } - GETSHORT(cishort, p); /* Parse MRU */ - - /* - * He must be able to receive at least our minimum. - * No need to check a maximum. If he sends a large number, - * we'll just ignore it. - */ - if (cishort < PPP_MINMRU) { - orc = CONFNAK; /* Nak CI */ - PUTCHAR(CI_MRU, nakoutp); - PUTCHAR(CILEN_SHORT, nakoutp); - PUTSHORT(PPP_MINMRU, nakoutp); /* Give him a hint */ - break; - } - ho->neg_mru = 1; /* Remember he sent MRU */ - ho->mru = cishort; /* And remember value */ - break; - - case CI_ASYNCMAP: - if (!ao->neg_asyncmap || - cilen != CILEN_LONG) { - orc = CONFREJ; - break; - } - GETLONG(cilong, p); - - /* - * Asyncmap must have set at least the bits - * which are set in lcp_allowoptions[unit].asyncmap. - */ - if ((ao->asyncmap & ~cilong) != 0) { - orc = CONFNAK; - PUTCHAR(CI_ASYNCMAP, nakoutp); - PUTCHAR(CILEN_LONG, nakoutp); - PUTLONG(ao->asyncmap | cilong, nakoutp); - break; - } - ho->neg_asyncmap = 1; - ho->asyncmap = cilong; - break; - - case CI_AUTHTYPE: - if (cilen < CILEN_SHORT || - !(0 -#if PAP_SUPPORT - || ao->neg_upap -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - || ao->neg_chap -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - || ao->neg_eap -#endif /* EAP_SUPPORT */ - )) { - /* - * Reject the option if we're not willing to authenticate. - */ - ppp_dbglog("No auth is possible"); - orc = CONFREJ; - break; - } - GETSHORT(cishort, p); - - /* - * Authtype must be PAP, CHAP, or EAP. - * - * Note: if more than one of ao->neg_upap, ao->neg_chap, and - * ao->neg_eap are set, and the peer sends a Configure-Request - * with two or more authenticate-protocol requests, then we will - * reject the second request. - * Whether we end up doing CHAP, UPAP, or EAP depends then on - * the ordering of the CIs in the peer's Configure-Request. - */ - -#if PAP_SUPPORT - if (cishort == PPP_PAP) { - /* we've already accepted CHAP or EAP */ - if (0 -#if CHAP_SUPPORT - || ho->neg_chap -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - || ho->neg_eap -#endif /* EAP_SUPPORT */ - || cilen != CILEN_SHORT) { - LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE PAP, rejecting...")); - orc = CONFREJ; - break; - } - if (!ao->neg_upap) { /* we don't want to do PAP */ - orc = CONFNAK; /* NAK it and suggest CHAP or EAP */ - PUTCHAR(CI_AUTHTYPE, nakoutp); -#if EAP_SUPPORT - if (ao->neg_eap) { - PUTCHAR(CILEN_SHORT, nakoutp); - PUTSHORT(PPP_EAP, nakoutp); - } else { -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT - PUTCHAR(CILEN_CHAP, nakoutp); - PUTSHORT(PPP_CHAP, nakoutp); - PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - } -#endif /* EAP_SUPPORT */ - break; - } - ho->neg_upap = 1; - break; - } -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - if (cishort == PPP_CHAP) { - /* we've already accepted PAP or EAP */ - if ( -#if PAP_SUPPORT - ho->neg_upap || -#endif /* PAP_SUPPORT */ -#if EAP_SUPPORT - ho->neg_eap || -#endif /* EAP_SUPPORT */ - cilen != CILEN_CHAP) { - LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE CHAP, rejecting...")); - orc = CONFREJ; - break; - } - if (!ao->neg_chap) { /* we don't want to do CHAP */ - orc = CONFNAK; /* NAK it and suggest EAP or PAP */ - PUTCHAR(CI_AUTHTYPE, nakoutp); - PUTCHAR(CILEN_SHORT, nakoutp); -#if EAP_SUPPORT - if (ao->neg_eap) { - PUTSHORT(PPP_EAP, nakoutp); - } else -#endif /* EAP_SUPPORT */ -#if PAP_SUPPORT - if(1) { - PUTSHORT(PPP_PAP, nakoutp); - } - else -#endif /* PAP_SUPPORT */ - {} - break; - } - GETCHAR(cichar, p); /* get digest type */ - if (!(CHAP_CANDIGEST(ao->chap_mdtype, cichar))) { - /* - * We can't/won't do the requested type, - * suggest something else. - */ - orc = CONFNAK; - PUTCHAR(CI_AUTHTYPE, nakoutp); - PUTCHAR(CILEN_CHAP, nakoutp); - PUTSHORT(PPP_CHAP, nakoutp); - PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); - break; - } - ho->chap_mdtype = CHAP_MDTYPE_D(cichar); /* save md type */ - ho->neg_chap = 1; - break; - } -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - if (cishort == PPP_EAP) { - /* we've already accepted CHAP or PAP */ - if ( -#if CHAP_SUPPORT - ho->neg_chap || -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - ho->neg_upap || -#endif /* PAP_SUPPORT */ - cilen != CILEN_SHORT) { - LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE EAP, rejecting...")); - orc = CONFREJ; - break; - } - if (!ao->neg_eap) { /* we don't want to do EAP */ - orc = CONFNAK; /* NAK it and suggest CHAP or PAP */ - PUTCHAR(CI_AUTHTYPE, nakoutp); -#if CHAP_SUPPORT - if (ao->neg_chap) { - PUTCHAR(CILEN_CHAP, nakoutp); - PUTSHORT(PPP_CHAP, nakoutp); - PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); - } else -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - if(1) { - PUTCHAR(CILEN_SHORT, nakoutp); - PUTSHORT(PPP_PAP, nakoutp); - } else -#endif /* PAP_SUPPORT */ - {} - break; - } - ho->neg_eap = 1; - break; - } -#endif /* EAP_SUPPORT */ - - /* - * We don't recognize the protocol they're asking for. - * Nak it with something we're willing to do. - * (At this point we know ao->neg_upap || ao->neg_chap || - * ao->neg_eap.) - */ - orc = CONFNAK; - PUTCHAR(CI_AUTHTYPE, nakoutp); - -#if EAP_SUPPORT - if (ao->neg_eap) { - PUTCHAR(CILEN_SHORT, nakoutp); - PUTSHORT(PPP_EAP, nakoutp); - } else -#endif /* EAP_SUPPORT */ -#if CHAP_SUPPORT - if (ao->neg_chap) { - PUTCHAR(CILEN_CHAP, nakoutp); - PUTSHORT(PPP_CHAP, nakoutp); - PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); - } else -#endif /* CHAP_SUPPORT */ -#if PAP_SUPPORT - if(1) { - PUTCHAR(CILEN_SHORT, nakoutp); - PUTSHORT(PPP_PAP, nakoutp); - } else -#endif /* PAP_SUPPORT */ - {} - break; - -#if LQR_SUPPORT - case CI_QUALITY: - if (!ao->neg_lqr || - cilen != CILEN_LQR) { - orc = CONFREJ; - break; - } - - GETSHORT(cishort, p); - GETLONG(cilong, p); - - /* - * Check the protocol and the reporting period. - * XXX When should we Nak this, and what with? - */ - if (cishort != PPP_LQR) { - orc = CONFNAK; - PUTCHAR(CI_QUALITY, nakoutp); - PUTCHAR(CILEN_LQR, nakoutp); - PUTSHORT(PPP_LQR, nakoutp); - PUTLONG(ao->lqr_period, nakoutp); - break; - } - break; -#endif /* LQR_SUPPORT */ - - case CI_MAGICNUMBER: - if (!(ao->neg_magicnumber || go->neg_magicnumber) || - cilen != CILEN_LONG) { - orc = CONFREJ; - break; - } - GETLONG(cilong, p); - - /* - * He must have a different magic number. - */ - if (go->neg_magicnumber && - cilong == go->magicnumber) { - cilong = magic(); /* Don't put magic() inside macro! */ - orc = CONFNAK; - PUTCHAR(CI_MAGICNUMBER, nakoutp); - PUTCHAR(CILEN_LONG, nakoutp); - PUTLONG(cilong, nakoutp); - break; - } - ho->neg_magicnumber = 1; - ho->magicnumber = cilong; - break; - - - case CI_PCOMPRESSION: - if (!ao->neg_pcompression || - cilen != CILEN_VOID) { - orc = CONFREJ; - break; - } - ho->neg_pcompression = 1; - break; - - case CI_ACCOMPRESSION: - if (!ao->neg_accompression || - cilen != CILEN_VOID) { - orc = CONFREJ; - break; - } - ho->neg_accompression = 1; - break; - -#ifdef HAVE_MULTILINK - case CI_MRRU: - if (!ao->neg_mrru - || !multilink - || cilen != CILEN_SHORT) { - orc = CONFREJ; - break; - } - - GETSHORT(cishort, p); - /* possibly should insist on a minimum/maximum MRRU here */ - ho->neg_mrru = 1; - ho->mrru = cishort; - break; -#endif /* HAVE_MULTILINK */ - - case CI_SSNHF: - if (!ao->neg_ssnhf -#ifdef HAVE_MULTILINK - || !multilink -#endif /* HAVE_MULTILINK */ - || cilen != CILEN_VOID) { - orc = CONFREJ; - break; - } - ho->neg_ssnhf = 1; - break; - - case CI_EPDISC: - if (!ao->neg_endpoint || - cilen < CILEN_CHAR || - cilen > CILEN_CHAR + MAX_ENDP_LEN) { - orc = CONFREJ; - break; - } - GETCHAR(cichar, p); - cilen -= CILEN_CHAR; - ho->neg_endpoint = 1; - ho->endpoint.class_ = cichar; - ho->endpoint.length = cilen; - MEMCPY(ho->endpoint.value, p, cilen); - INCPTR(cilen, p); - break; - - default: - LCPDEBUG(("lcp_reqci: rcvd unknown option %d", citype)); - orc = CONFREJ; - break; - } - -endswitch: - if (orc == CONFACK && /* Good CI */ - rc != CONFACK) /* but prior CI wasnt? */ - continue; /* Don't send this one */ - - if (orc == CONFNAK) { /* Nak this CI? */ - if (reject_if_disagree /* Getting fed up with sending NAKs? */ - && citype != CI_MAGICNUMBER) { - orc = CONFREJ; /* Get tough if so */ - } else { - if (rc == CONFREJ) /* Rejecting prior CI? */ - continue; /* Don't send this one */ - rc = CONFNAK; - } - } - if (orc == CONFREJ) { /* Reject this CI */ - rc = CONFREJ; - if (cip != rejp) /* Need to move rejected CI? */ - MEMCPY(rejp, cip, cilen); /* Move it */ - INCPTR(cilen, rejp); /* Update output pointer */ - } - } - - /* - * If we wanted to send additional NAKs (for unsent CIs), the - * code would go here. The extra NAKs would go at *nakoutp. - * At present there are no cases where we want to ask the - * peer to negotiate an option. - */ - - switch (rc) { - case CONFACK: - *lenp = next - inp; - break; - case CONFNAK: - /* - * Copy the Nak'd options from the nak buffer to the caller's buffer. - */ - *lenp = nakoutp - (u_char*)nakp->payload; - MEMCPY(inp, nakp->payload, *lenp); - break; - case CONFREJ: - *lenp = rejp - inp; - break; - default: - break; - } - - pbuf_free(nakp); - LCPDEBUG(("lcp_reqci: returning CONF%s.", CODENAME(rc))); - return (rc); /* Return final code */ -} - - -/* - * lcp_up - LCP has come UP. - */ -static void lcp_up(fsm *f) { - ppp_pcb *pcb = f->pcb; - lcp_options *wo = &pcb->lcp_wantoptions; - lcp_options *ho = &pcb->lcp_hisoptions; - lcp_options *go = &pcb->lcp_gotoptions; - lcp_options *ao = &pcb->lcp_allowoptions; - int mtu, mru; - - if (!go->neg_magicnumber) - go->magicnumber = 0; - if (!ho->neg_magicnumber) - ho->magicnumber = 0; - - /* - * Set our MTU to the smaller of the MTU we wanted and - * the MRU our peer wanted. If we negotiated an MRU, - * set our MRU to the larger of value we wanted and - * the value we got in the negotiation. - * Note on the MTU: the link MTU can be the MRU the peer wanted, - * the interface MTU is set to the lowest of that, the - * MTU we want to use, and our link MRU. - */ - mtu = ho->neg_mru? ho->mru: PPP_MRU; - mru = go->neg_mru? LWIP_MAX(wo->mru, go->mru): PPP_MRU; -#ifdef HAVE_MULTILINK - if (!(multilink && go->neg_mrru && ho->neg_mrru)) -#endif /* HAVE_MULTILINK */ - netif_set_mtu(pcb, LWIP_MIN(LWIP_MIN(mtu, mru), ao->mru)); - ppp_send_config(pcb, mtu, - (ho->neg_asyncmap? ho->asyncmap: 0xffffffff), - ho->neg_pcompression, ho->neg_accompression); - ppp_recv_config(pcb, mru, - (pcb->settings.lax_recv? 0: go->neg_asyncmap? go->asyncmap: 0xffffffff), - go->neg_pcompression, go->neg_accompression); - - if (ho->neg_mru) - pcb->peer_mru = ho->mru; - - lcp_echo_lowerup(f->pcb); /* Enable echo messages */ - - link_established(pcb); -} - - -/* - * lcp_down - LCP has gone DOWN. - * - * Alert other protocols. - */ -static void lcp_down(fsm *f) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - - lcp_echo_lowerdown(f->pcb); - - link_down(pcb); - - ppp_send_config(pcb, PPP_MRU, 0xffffffff, 0, 0); - ppp_recv_config(pcb, PPP_MRU, - (go->neg_asyncmap? go->asyncmap: 0xffffffff), - go->neg_pcompression, go->neg_accompression); - pcb->peer_mru = PPP_MRU; -} - - -/* - * lcp_starting - LCP needs the lower layer up. - */ -static void lcp_starting(fsm *f) { - ppp_pcb *pcb = f->pcb; - link_required(pcb); -} - - -/* - * lcp_finished - LCP has finished with the lower layer. - */ -static void lcp_finished(fsm *f) { - ppp_pcb *pcb = f->pcb; - link_terminated(pcb); -} - - -#if PRINTPKT_SUPPORT -/* - * lcp_printpkt - print the contents of an LCP packet. - */ -static const char* const lcp_codenames[] = { - "ConfReq", "ConfAck", "ConfNak", "ConfRej", - "TermReq", "TermAck", "CodeRej", "ProtRej", - "EchoReq", "EchoRep", "DiscReq", "Ident", - "TimeRem" -}; - -static int lcp_printpkt(const u_char *p, int plen, - void (*printer) (void *, const char *, ...), void *arg) { - int code, id, len, olen, i; - const u_char *pstart, *optend; - u_short cishort; - u32_t cilong; - - if (plen < HEADERLEN) - return 0; - pstart = p; - GETCHAR(code, p); - GETCHAR(id, p); - GETSHORT(len, p); - if (len < HEADERLEN || len > plen) - return 0; - - if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(lcp_codenames)) - printer(arg, " %s", lcp_codenames[code-1]); - else - printer(arg, " code=0x%x", code); - printer(arg, " id=0x%x", id); - len -= HEADERLEN; - switch (code) { - case CONFREQ: - case CONFACK: - case CONFNAK: - case CONFREJ: - /* print option list */ - while (len >= 2) { - GETCHAR(code, p); - GETCHAR(olen, p); - p -= 2; - if (olen < 2 || olen > len) { - break; - } - printer(arg, " <"); - len -= olen; - optend = p + olen; - switch (code) { - case CI_MRU: - if (olen == CILEN_SHORT) { - p += 2; - GETSHORT(cishort, p); - printer(arg, "mru %d", cishort); - } - break; - case CI_ASYNCMAP: - if (olen == CILEN_LONG) { - p += 2; - GETLONG(cilong, p); - printer(arg, "asyncmap 0x%x", cilong); - } - break; - case CI_AUTHTYPE: - if (olen >= CILEN_SHORT) { - p += 2; - printer(arg, "auth "); - GETSHORT(cishort, p); - switch (cishort) { -#if PAP_SUPPORT - case PPP_PAP: - printer(arg, "pap"); - break; -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - case PPP_CHAP: - printer(arg, "chap"); - if (p < optend) { - switch (*p) { - case CHAP_MD5: - printer(arg, " MD5"); - ++p; - break; -#if MSCHAP_SUPPORT - case CHAP_MICROSOFT: - printer(arg, " MS"); - ++p; - break; - - case CHAP_MICROSOFT_V2: - printer(arg, " MS-v2"); - ++p; - break; -#endif /* MSCHAP_SUPPORT */ - default: - break; - } - } - break; -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - case PPP_EAP: - printer(arg, "eap"); - break; -#endif /* EAP_SUPPORT */ - default: - printer(arg, "0x%x", cishort); - } - } - break; -#if LQR_SUPPORT - case CI_QUALITY: - if (olen >= CILEN_SHORT) { - p += 2; - printer(arg, "quality "); - GETSHORT(cishort, p); - switch (cishort) { - case PPP_LQR: - printer(arg, "lqr"); - break; - default: - printer(arg, "0x%x", cishort); - } - } - break; -#endif /* LQR_SUPPORT */ - case CI_CALLBACK: - if (olen >= CILEN_CHAR) { - p += 2; - printer(arg, "callback "); - GETCHAR(cishort, p); - switch (cishort) { - case CBCP_OPT: - printer(arg, "CBCP"); - break; - default: - printer(arg, "0x%x", cishort); - } - } - break; - case CI_MAGICNUMBER: - if (olen == CILEN_LONG) { - p += 2; - GETLONG(cilong, p); - printer(arg, "magic 0x%x", cilong); - } - break; - case CI_PCOMPRESSION: - if (olen == CILEN_VOID) { - p += 2; - printer(arg, "pcomp"); - } - break; - case CI_ACCOMPRESSION: - if (olen == CILEN_VOID) { - p += 2; - printer(arg, "accomp"); - } - break; - case CI_MRRU: - if (olen == CILEN_SHORT) { - p += 2; - GETSHORT(cishort, p); - printer(arg, "mrru %d", cishort); - } - break; - case CI_SSNHF: - if (olen == CILEN_VOID) { - p += 2; - printer(arg, "ssnhf"); - } - break; - case CI_EPDISC: -#ifdef HAVE_MULTILINK - if (olen >= CILEN_CHAR) { - struct epdisc epd; - p += 2; - GETCHAR(epd.class, p); - epd.length = olen - CILEN_CHAR; - if (epd.length > MAX_ENDP_LEN) - epd.length = MAX_ENDP_LEN; - if (epd.length > 0) { - MEMCPY(epd.value, p, epd.length); - p += epd.length; - } - printer(arg, "endpoint [%s]", epdisc_to_str(&epd)); - } -#else - printer(arg, "endpoint"); -#endif - break; - default: - break; - } - while (p < optend) { - GETCHAR(code, p); - printer(arg, " %.2x", code); - } - printer(arg, ">"); - } - break; - - case TERMACK: - case TERMREQ: - if (len > 0 && *p >= ' ' && *p < 0x7f) { - printer(arg, " "); - ppp_print_string(p, len, printer, arg); - p += len; - len = 0; - } - break; - - case ECHOREQ: - case ECHOREP: - case DISCREQ: - if (len >= 4) { - GETLONG(cilong, p); - printer(arg, " magic=0x%x", cilong); - len -= 4; - } - break; - - case IDENTIF: - case TIMEREM: - if (len >= 4) { - GETLONG(cilong, p); - printer(arg, " magic=0x%x", cilong); - len -= 4; - } - if (code == TIMEREM) { - if (len < 4) - break; - GETLONG(cilong, p); - printer(arg, " seconds=%u", cilong); - len -= 4; - } - if (len > 0) { - printer(arg, " "); - ppp_print_string(p, len, printer, arg); - p += len; - len = 0; - } - break; - default: - break; - } - - /* print the rest of the bytes in the packet */ - for (i = 0; i < len && i < 32; ++i) { - GETCHAR(code, p); - printer(arg, " %.2x", code); - } - if (i < len) { - printer(arg, " ..."); - p += len - i; - } - - return p - pstart; -} -#endif /* PRINTPKT_SUPPORT */ - -/* - * Time to shut down the link because there is nothing out there. - */ - -static void LcpLinkFailure(fsm *f) { - ppp_pcb *pcb = f->pcb; - if (f->state == PPP_FSM_OPENED) { - ppp_info("No response to %d echo-requests", pcb->lcp_echos_pending); - ppp_notice("Serial link appears to be disconnected."); - pcb->err_code = PPPERR_PEERDEAD; - lcp_close(pcb, "Peer not responding"); - } -} - -/* - * Timer expired for the LCP echo requests from this process. - */ - -static void LcpEchoCheck(fsm *f) { - ppp_pcb *pcb = f->pcb; - - LcpSendEchoRequest (f); - if (f->state != PPP_FSM_OPENED) - return; - - /* - * Start the timer for the next interval. - */ - if (pcb->lcp_echo_timer_running) - ppp_warn("assertion lcp_echo_timer_running==0 failed"); - TIMEOUT (LcpEchoTimeout, f, pcb->settings.lcp_echo_interval); - pcb->lcp_echo_timer_running = 1; -} - -/* - * LcpEchoTimeout - Timer expired on the LCP echo - */ - -static void LcpEchoTimeout(void *arg) { - fsm *f = (fsm*)arg; - ppp_pcb *pcb = f->pcb; - if (pcb->lcp_echo_timer_running != 0) { - pcb->lcp_echo_timer_running = 0; - LcpEchoCheck ((fsm *) arg); - } -} - -/* - * LcpEchoReply - LCP has received a reply to the echo - */ - -static void lcp_received_echo_reply(fsm *f, int id, u_char *inp, int len) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - u32_t magic_val; - LWIP_UNUSED_ARG(id); - - /* Check the magic number - don't count replies from ourselves. */ - if (len < 4) { - ppp_dbglog("lcp: received short Echo-Reply, length %d", len); - return; - } - GETLONG(magic_val, inp); - if (go->neg_magicnumber - && magic_val == go->magicnumber) { - ppp_warn("appear to have received our own echo-reply!"); - return; - } - - /* Reset the number of outstanding echo frames */ - pcb->lcp_echos_pending = 0; -} - -/* - * LcpSendEchoRequest - Send an echo request frame to the peer - */ - -static void LcpSendEchoRequest(fsm *f) { - ppp_pcb *pcb = f->pcb; - lcp_options *go = &pcb->lcp_gotoptions; - u32_t lcp_magic; - u_char pkt[4], *pktp; - - /* - * Detect the failure of the peer at this point. - */ - if (pcb->settings.lcp_echo_fails != 0) { - if (pcb->lcp_echos_pending >= pcb->settings.lcp_echo_fails) { - LcpLinkFailure(f); - pcb->lcp_echos_pending = 0; - } - } - -#if PPP_LCP_ADAPTIVE - /* - * If adaptive echos have been enabled, only send the echo request if - * no traffic was received since the last one. - */ - if (pcb->settings.lcp_echo_adaptive) { - static unsigned int last_pkts_in = 0; - -#if PPP_STATS_SUPPORT - update_link_stats(f->unit); - link_stats_valid = 0; -#endif /* PPP_STATS_SUPPORT */ - - if (link_stats.pkts_in != last_pkts_in) { - last_pkts_in = link_stats.pkts_in; - return; - } - } -#endif - - /* - * Make and send the echo request frame. - */ - if (f->state == PPP_FSM_OPENED) { - lcp_magic = go->magicnumber; - pktp = pkt; - PUTLONG(lcp_magic, pktp); - fsm_sdata(f, ECHOREQ, pcb->lcp_echo_number++, pkt, pktp - pkt); - ++pcb->lcp_echos_pending; - } -} - -/* - * lcp_echo_lowerup - Start the timer for the LCP frame - */ - -static void lcp_echo_lowerup(ppp_pcb *pcb) { - fsm *f = &pcb->lcp_fsm; - - /* Clear the parameters for generating echo frames */ - pcb->lcp_echos_pending = 0; - pcb->lcp_echo_number = 0; - pcb->lcp_echo_timer_running = 0; - - /* If a timeout interval is specified then start the timer */ - if (pcb->settings.lcp_echo_interval != 0) - LcpEchoCheck (f); -} - -/* - * lcp_echo_lowerdown - Stop the timer for the LCP frame - */ - -static void lcp_echo_lowerdown(ppp_pcb *pcb) { - fsm *f = &pcb->lcp_fsm; - - if (pcb->lcp_echo_timer_running != 0) { - UNTIMEOUT (LcpEchoTimeout, f); - pcb->lcp_echo_timer_running = 0; - } -} - -#endif /* PPP_SUPPORT */ +/* + * lcp.c - PPP Link Control Protocol. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +/* + * @todo: + */ + +#if 0 /* UNUSED */ +#include +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/lcp.h" +#if CHAP_SUPPORT +#include "netif/ppp/chap-new.h" +#endif /* CHAP_SUPPORT */ +#include "netif/ppp/magic.h" + +/* + * When the link comes up we want to be able to wait for a short while, + * or until seeing some input from the peer, before starting to send + * configure-requests. We do this by delaying the fsm_lowerup call. + */ +/* steal a bit in fsm flags word */ +#define DELAYED_UP 0x80 + +static void lcp_delayed_up(void *arg); + +/* + * LCP-related command-line options. + */ +#if 0 /* UNUSED */ +int lcp_echo_interval = 0; /* Interval between LCP echo-requests */ +int lcp_echo_fails = 0; /* Tolerance to unanswered echo-requests */ +#endif /* UNUSED */ + +#if 0 /* UNUSED */ +/* options */ +static u_int lcp_echo_interval = LCP_ECHOINTERVAL; /* Interval between LCP echo-requests */ +static u_int lcp_echo_fails = LCP_MAXECHOFAILS; /* Tolerance to unanswered echo-requests */ +#endif /* UNUSED */ + +#if 0 /* UNUSED */ +#if PPP_LCP_ADAPTIVE +bool lcp_echo_adaptive = 0; /* request echo only if the link was idle */ +#endif +bool lax_recv = 0; /* accept control chars in asyncmap */ +bool noendpoint = 0; /* don't send/accept endpoint discriminator */ +#endif /* UNUSED */ + +#if PPP_OPTIONS +static int noopt (char **); +#endif /* PPP_OPTIONS */ + +#ifdef HAVE_MULTILINK +static int setendpoint (char **); +static void printendpoint (option_t *, void (*)(void *, char *, ...), + void *); +#endif /* HAVE_MULTILINK */ + +#if PPP_OPTIONS +static option_t lcp_option_list[] = { + /* LCP options */ + { "-all", o_special_noarg, (void *)noopt, + "Don't request/allow any LCP options" }, + + { "noaccomp", o_bool, &lcp_wantoptions[0].neg_accompression, + "Disable address/control compression", + OPT_A2CLR, &lcp_allowoptions[0].neg_accompression }, + { "-ac", o_bool, &lcp_wantoptions[0].neg_accompression, + "Disable address/control compression", + OPT_ALIAS | OPT_A2CLR, &lcp_allowoptions[0].neg_accompression }, + + { "asyncmap", o_uint32, &lcp_wantoptions[0].asyncmap, + "Set asyncmap (for received packets)", + OPT_OR, &lcp_wantoptions[0].neg_asyncmap }, + { "-as", o_uint32, &lcp_wantoptions[0].asyncmap, + "Set asyncmap (for received packets)", + OPT_ALIAS | OPT_OR, &lcp_wantoptions[0].neg_asyncmap }, + { "default-asyncmap", o_uint32, &lcp_wantoptions[0].asyncmap, + "Disable asyncmap negotiation", + OPT_OR | OPT_NOARG | OPT_VAL(~0U) | OPT_A2CLR, + &lcp_allowoptions[0].neg_asyncmap }, + { "-am", o_uint32, &lcp_wantoptions[0].asyncmap, + "Disable asyncmap negotiation", + OPT_ALIAS | OPT_OR | OPT_NOARG | OPT_VAL(~0U) | OPT_A2CLR, + &lcp_allowoptions[0].neg_asyncmap }, + + { "nomagic", o_bool, &lcp_wantoptions[0].neg_magicnumber, + "Disable magic number negotiation (looped-back line detection)", + OPT_A2CLR, &lcp_allowoptions[0].neg_magicnumber }, + { "-mn", o_bool, &lcp_wantoptions[0].neg_magicnumber, + "Disable magic number negotiation (looped-back line detection)", + OPT_ALIAS | OPT_A2CLR, &lcp_allowoptions[0].neg_magicnumber }, + + { "mru", o_int, &lcp_wantoptions[0].mru, + "Set MRU (maximum received packet size) for negotiation", + OPT_PRIO, &lcp_wantoptions[0].neg_mru }, + { "default-mru", o_bool, &lcp_wantoptions[0].neg_mru, + "Disable MRU negotiation (use default 1500)", + OPT_PRIOSUB | OPT_A2CLR, &lcp_allowoptions[0].neg_mru }, + { "-mru", o_bool, &lcp_wantoptions[0].neg_mru, + "Disable MRU negotiation (use default 1500)", + OPT_ALIAS | OPT_PRIOSUB | OPT_A2CLR, &lcp_allowoptions[0].neg_mru }, + + { "mtu", o_int, &lcp_allowoptions[0].mru, + "Set our MTU", OPT_LIMITS, NULL, MAXMRU, MINMRU }, + + { "nopcomp", o_bool, &lcp_wantoptions[0].neg_pcompression, + "Disable protocol field compression", + OPT_A2CLR, &lcp_allowoptions[0].neg_pcompression }, + { "-pc", o_bool, &lcp_wantoptions[0].neg_pcompression, + "Disable protocol field compression", + OPT_ALIAS | OPT_A2CLR, &lcp_allowoptions[0].neg_pcompression }, + + { "passive", o_bool, &lcp_wantoptions[0].passive, + "Set passive mode", 1 }, + { "-p", o_bool, &lcp_wantoptions[0].passive, + "Set passive mode", OPT_ALIAS | 1 }, + + { "silent", o_bool, &lcp_wantoptions[0].silent, + "Set silent mode", 1 }, + + { "lcp-echo-failure", o_int, &lcp_echo_fails, + "Set number of consecutive echo failures to indicate link failure", + OPT_PRIO }, + { "lcp-echo-interval", o_int, &lcp_echo_interval, + "Set time in seconds between LCP echo requests", OPT_PRIO }, +#if PPP_LCP_ADAPTIVE + { "lcp-echo-adaptive", o_bool, &lcp_echo_adaptive, + "Suppress LCP echo requests if traffic was received", 1 }, +#endif + { "lcp-restart", o_int, &lcp_fsm[0].timeouttime, + "Set time in seconds between LCP retransmissions", OPT_PRIO }, + { "lcp-max-terminate", o_int, &lcp_fsm[0].maxtermtransmits, + "Set maximum number of LCP terminate-request transmissions", OPT_PRIO }, + { "lcp-max-configure", o_int, &lcp_fsm[0].maxconfreqtransmits, + "Set maximum number of LCP configure-request transmissions", OPT_PRIO }, + { "lcp-max-failure", o_int, &lcp_fsm[0].maxnakloops, + "Set limit on number of LCP configure-naks", OPT_PRIO }, + + { "receive-all", o_bool, &lax_recv, + "Accept all received control characters", 1 }, + +#ifdef HAVE_MULTILINK + { "mrru", o_int, &lcp_wantoptions[0].mrru, + "Maximum received packet size for multilink bundle", + OPT_PRIO, &lcp_wantoptions[0].neg_mrru }, + + { "mpshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf, + "Use short sequence numbers in multilink headers", + OPT_PRIO | 1, &lcp_allowoptions[0].neg_ssnhf }, + { "nompshortseq", o_bool, &lcp_wantoptions[0].neg_ssnhf, + "Don't use short sequence numbers in multilink headers", + OPT_PRIOSUB | OPT_A2CLR, &lcp_allowoptions[0].neg_ssnhf }, + + { "endpoint", o_special, (void *) setendpoint, + "Endpoint discriminator for multilink", + OPT_PRIO | OPT_A2PRINTER, (void *) printendpoint }, +#endif /* HAVE_MULTILINK */ + + { "noendpoint", o_bool, &noendpoint, + "Don't send or accept multilink endpoint discriminator", 1 }, + + {NULL} +}; +#endif /* PPP_OPTIONS */ + +/* + * Callbacks for fsm code. (CI = Configuration Information) + */ +static void lcp_resetci(fsm *f); /* Reset our CI */ +static int lcp_cilen(fsm *f); /* Return length of our CI */ +static void lcp_addci(fsm *f, u_char *ucp, int *lenp); /* Add our CI to pkt */ +static int lcp_ackci(fsm *f, u_char *p, int len); /* Peer ack'd our CI */ +static int lcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject); /* Peer nak'd our CI */ +static int lcp_rejci(fsm *f, u_char *p, int len); /* Peer rej'd our CI */ +static int lcp_reqci(fsm *f, u_char *inp, int *lenp, int reject_if_disagree); /* Rcv peer CI */ +static void lcp_up(fsm *f); /* We're UP */ +static void lcp_down(fsm *f); /* We're DOWN */ +static void lcp_starting (fsm *); /* We need lower layer up */ +static void lcp_finished (fsm *); /* We need lower layer down */ +static int lcp_extcode(fsm *f, int code, int id, u_char *inp, int len); +static void lcp_rprotrej(fsm *f, u_char *inp, int len); + +/* + * routines to send LCP echos to peer + */ + +static void lcp_echo_lowerup(ppp_pcb *pcb); +static void lcp_echo_lowerdown(ppp_pcb *pcb); +static void LcpEchoTimeout(void *arg); +static void lcp_received_echo_reply(fsm *f, int id, u_char *inp, int len); +static void LcpSendEchoRequest(fsm *f); +static void LcpLinkFailure(fsm *f); +static void LcpEchoCheck(fsm *f); + +static const fsm_callbacks lcp_callbacks = { /* LCP callback routines */ + lcp_resetci, /* Reset our Configuration Information */ + lcp_cilen, /* Length of our Configuration Information */ + lcp_addci, /* Add our Configuration Information */ + lcp_ackci, /* ACK our Configuration Information */ + lcp_nakci, /* NAK our Configuration Information */ + lcp_rejci, /* Reject our Configuration Information */ + lcp_reqci, /* Request peer's Configuration Information */ + lcp_up, /* Called when fsm reaches OPENED state */ + lcp_down, /* Called when fsm leaves OPENED state */ + lcp_starting, /* Called when we want the lower layer up */ + lcp_finished, /* Called when we want the lower layer down */ + NULL, /* Called when Protocol-Reject received */ + NULL, /* Retransmission is necessary */ + lcp_extcode, /* Called to handle LCP-specific codes */ + "LCP" /* String name of protocol */ +}; + +/* + * Protocol entry points. + * Some of these are called directly. + */ + +static void lcp_init(ppp_pcb *pcb); +static void lcp_input(ppp_pcb *pcb, u_char *p, int len); +static void lcp_protrej(ppp_pcb *pcb); +#if PRINTPKT_SUPPORT +static int lcp_printpkt(const u_char *p, int plen, + void (*printer) (void *, const char *, ...), void *arg); +#endif /* PRINTPKT_SUPPORT */ + +const struct protent lcp_protent = { + PPP_LCP, + lcp_init, + lcp_input, + lcp_protrej, + lcp_lowerup, + lcp_lowerdown, + lcp_open, + lcp_close, +#if PRINTPKT_SUPPORT + lcp_printpkt, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + NULL, +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "LCP", + NULL, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + lcp_option_list, + NULL, +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + NULL, + NULL +#endif /* DEMAND_SUPPORT */ +}; + +/* + * Length of each type of configuration option (in octets) + */ +#define CILEN_VOID 2 +#define CILEN_CHAR 3 +#define CILEN_SHORT 4 /* CILEN_VOID + 2 */ +#if CHAP_SUPPORT +#define CILEN_CHAP 5 /* CILEN_VOID + 2 + 1 */ +#endif /* CHAP_SUPPORT */ +#define CILEN_LONG 6 /* CILEN_VOID + 4 */ +#if LQR_SUPPORT +#define CILEN_LQR 8 /* CILEN_VOID + 2 + 4 */ +#endif /* LQR_SUPPORT */ +#define CILEN_CBCP 3 + +#define CODENAME(x) ((x) == CONFACK ? "ACK" : \ + (x) == CONFNAK ? "NAK" : "REJ") + +#if PPP_OPTIONS +/* + * noopt - Disable all options (why?). + */ +static int +noopt(argv) + char **argv; +{ + BZERO((char *) &lcp_wantoptions[0], sizeof (struct lcp_options)); + BZERO((char *) &lcp_allowoptions[0], sizeof (struct lcp_options)); + + return (1); +} +#endif /* PPP_OPTIONS */ + +#ifdef HAVE_MULTILINK +static int +setendpoint(argv) + char **argv; +{ + if (str_to_epdisc(&lcp_wantoptions[0].endpoint, *argv)) { + lcp_wantoptions[0].neg_endpoint = 1; + return 1; + } + option_error("Can't parse '%s' as an endpoint discriminator", *argv); + return 0; +} + +static void +printendpoint(opt, printer, arg) + option_t *opt; + void (*printer) (void *, char *, ...); + void *arg; +{ + printer(arg, "%s", epdisc_to_str(&lcp_wantoptions[0].endpoint)); +} +#endif /* HAVE_MULTILINK */ + +/* + * lcp_init - Initialize LCP. + */ +static void lcp_init(ppp_pcb *pcb) { + fsm *f = &pcb->lcp_fsm; + lcp_options *wo = &pcb->lcp_wantoptions; + lcp_options *ao = &pcb->lcp_allowoptions; + + f->pcb = pcb; + f->protocol = PPP_LCP; + f->callbacks = &lcp_callbacks; + + fsm_init(f); + + BZERO(wo, sizeof(*wo)); + wo->neg_mru = 1; + wo->mru = PPP_DEFMRU; + wo->neg_asyncmap = 1; + wo->neg_magicnumber = 1; + wo->neg_pcompression = 1; + wo->neg_accompression = 1; + + BZERO(ao, sizeof(*ao)); + ao->neg_mru = 1; + ao->mru = PPP_MAXMRU; + ao->neg_asyncmap = 1; +#if CHAP_SUPPORT + ao->neg_chap = 1; + ao->chap_mdtype = CHAP_MDTYPE_SUPPORTED; +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + ao->neg_upap = 1; +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + ao->neg_eap = 1; +#endif /* EAP_SUPPORT */ + ao->neg_magicnumber = 1; + ao->neg_pcompression = 1; + ao->neg_accompression = 1; + ao->neg_endpoint = 1; +} + + +/* + * lcp_open - LCP is allowed to come up. + */ +void lcp_open(ppp_pcb *pcb) { + fsm *f = &pcb->lcp_fsm; + lcp_options *wo = &pcb->lcp_wantoptions; + + f->flags &= ~(OPT_PASSIVE | OPT_SILENT); + if (wo->passive) + f->flags |= OPT_PASSIVE; + if (wo->silent) + f->flags |= OPT_SILENT; + fsm_open(f); +} + + +/* + * lcp_close - Take LCP down. + */ +void lcp_close(ppp_pcb *pcb, const char *reason) { + fsm *f = &pcb->lcp_fsm; + int oldstate; + + if (pcb->phase != PPP_PHASE_DEAD +#ifdef HAVE_MULTILINK + && pcb->phase != PPP_PHASE_MASTER +#endif /* HAVE_MULTILINK */ + ) + new_phase(pcb, PPP_PHASE_TERMINATE); + + if (f->flags & DELAYED_UP) { + UNTIMEOUT(lcp_delayed_up, f); + f->state = PPP_FSM_STOPPED; + } + oldstate = f->state; + + fsm_close(f, reason); + if (oldstate == PPP_FSM_STOPPED && (f->flags & (OPT_PASSIVE|OPT_SILENT|DELAYED_UP))) { + /* + * This action is not strictly according to the FSM in RFC1548, + * but it does mean that the program terminates if you do a + * lcp_close() when a connection hasn't been established + * because we are in passive/silent mode or because we have + * delayed the fsm_lowerup() call and it hasn't happened yet. + */ + f->flags &= ~DELAYED_UP; + lcp_finished(f); + } +} + + +/* + * lcp_lowerup - The lower layer is up. + */ +void lcp_lowerup(ppp_pcb *pcb) { + lcp_options *wo = &pcb->lcp_wantoptions; + fsm *f = &pcb->lcp_fsm; + /* + * Don't use A/C or protocol compression on transmission, + * but accept A/C and protocol compressed packets + * if we are going to ask for A/C and protocol compression. + */ + if (ppp_send_config(pcb, PPP_MRU, 0xffffffff, 0, 0) < 0 + || ppp_recv_config(pcb, PPP_MRU, (pcb->settings.lax_recv? 0: 0xffffffff), + wo->neg_pcompression, wo->neg_accompression) < 0) + return; + pcb->peer_mru = PPP_MRU; + + if (pcb->settings.listen_time != 0) { + f->flags |= DELAYED_UP; + TIMEOUTMS(lcp_delayed_up, f, pcb->settings.listen_time); + } else + fsm_lowerup(f); +} + + +/* + * lcp_lowerdown - The lower layer is down. + */ +void lcp_lowerdown(ppp_pcb *pcb) { + fsm *f = &pcb->lcp_fsm; + + if (f->flags & DELAYED_UP) { + f->flags &= ~DELAYED_UP; + UNTIMEOUT(lcp_delayed_up, f); + } else + fsm_lowerdown(f); +} + + +/* + * lcp_delayed_up - Bring the lower layer up now. + */ +static void lcp_delayed_up(void *arg) { + fsm *f = (fsm*)arg; + + if (f->flags & DELAYED_UP) { + f->flags &= ~DELAYED_UP; + fsm_lowerup(f); + } +} + + +/* + * lcp_input - Input LCP packet. + */ +static void lcp_input(ppp_pcb *pcb, u_char *p, int len) { + fsm *f = &pcb->lcp_fsm; + + if (f->flags & DELAYED_UP) { + f->flags &= ~DELAYED_UP; + UNTIMEOUT(lcp_delayed_up, f); + fsm_lowerup(f); + } + fsm_input(f, p, len); +} + +/* + * lcp_extcode - Handle a LCP-specific code. + */ +static int lcp_extcode(fsm *f, int code, int id, u_char *inp, int len) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + u_char *magp; + + switch( code ){ + case PROTREJ: + lcp_rprotrej(f, inp, len); + break; + + case ECHOREQ: + if (f->state != PPP_FSM_OPENED) + break; + magp = inp; + PUTLONG(go->magicnumber, magp); + fsm_sdata(f, ECHOREP, id, inp, len); + break; + + case ECHOREP: + lcp_received_echo_reply(f, id, inp, len); + break; + + case DISCREQ: + case IDENTIF: + case TIMEREM: + break; + + default: + return 0; + } + return 1; +} + + +/* + * lcp_rprotrej - Receive an Protocol-Reject. + * + * Figure out which protocol is rejected and inform it. + */ +static void lcp_rprotrej(fsm *f, u_char *inp, int len) { + int i; + const struct protent *protp; + u_short prot; +#if PPP_PROTOCOLNAME + const char *pname; +#endif /* PPP_PROTOCOLNAME */ + + if (len < 2) { + LCPDEBUG(("lcp_rprotrej: Rcvd short Protocol-Reject packet!")); + return; + } + + GETSHORT(prot, inp); + + /* + * Protocol-Reject packets received in any state other than the LCP + * OPENED state SHOULD be silently discarded. + */ + if( f->state != PPP_FSM_OPENED ){ + LCPDEBUG(("Protocol-Reject discarded: LCP in state %d", f->state)); + return; + } + +#if PPP_PROTOCOLNAME + pname = protocol_name(prot); +#endif /* PPP_PROTOCOLNAME */ + + /* + * Upcall the proper Protocol-Reject routine. + */ + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (protp->protocol == prot) { +#if PPP_PROTOCOLNAME + if (pname != NULL) + ppp_dbglog("Protocol-Reject for '%s' (0x%x) received", pname, + prot); + else +#endif /* PPP_PROTOCOLNAME */ + ppp_dbglog("Protocol-Reject for 0x%x received", prot); + (*protp->protrej)(f->pcb); + return; + } + +#if PPP_PROTOCOLNAME + if (pname != NULL) + ppp_warn("Protocol-Reject for unsupported protocol '%s' (0x%x)", pname, + prot); + else +#endif /* #if PPP_PROTOCOLNAME */ + ppp_warn("Protocol-Reject for unsupported protocol 0x%x", prot); +} + + +/* + * lcp_protrej - A Protocol-Reject was received. + */ +/*ARGSUSED*/ +static void lcp_protrej(ppp_pcb *pcb) { + /* + * Can't reject LCP! + */ + ppp_error("Received Protocol-Reject for LCP!"); + fsm_protreject(&pcb->lcp_fsm); +} + + +/* + * lcp_sprotrej - Send a Protocol-Reject for some protocol. + */ +void lcp_sprotrej(ppp_pcb *pcb, u_char *p, int len) { + fsm *f = &pcb->lcp_fsm; + /* + * Send back the protocol and the information field of the + * rejected packet. We only get here if LCP is in the OPENED state. + */ +#if 0 + p += 2; + len -= 2; +#endif + + fsm_sdata(f, PROTREJ, ++f->id, + p, len); +} + + +/* + * lcp_resetci - Reset our CI. + */ +static void lcp_resetci(fsm *f) { + ppp_pcb *pcb = f->pcb; + lcp_options *wo = &pcb->lcp_wantoptions; + lcp_options *go = &pcb->lcp_gotoptions; + lcp_options *ao = &pcb->lcp_allowoptions; + +#if PPP_AUTH_SUPPORT + + /* note: default value is true for allow options */ + if (pcb->settings.user && pcb->settings.passwd) { +#if PAP_SUPPORT + if (pcb->settings.refuse_pap) { + ao->neg_upap = 0; + } +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + if (pcb->settings.refuse_chap) { + ao->chap_mdtype &= ~MDTYPE_MD5; + } +#if MSCHAP_SUPPORT + if (pcb->settings.refuse_mschap) { + ao->chap_mdtype &= ~MDTYPE_MICROSOFT; + } + if (pcb->settings.refuse_mschap_v2) { + ao->chap_mdtype &= ~MDTYPE_MICROSOFT_V2; + } +#endif /* MSCHAP_SUPPORT */ + ao->neg_chap = (ao->chap_mdtype != MDTYPE_NONE); +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + if (pcb->settings.refuse_eap) { + ao->neg_eap = 0; + } +#endif /* EAP_SUPPORT */ + +#if PPP_SERVER + /* note: default value is false for wanted options */ + if (pcb->settings.auth_required) { +#if PAP_SUPPORT + if (!pcb->settings.refuse_pap) { + wo->neg_upap = 1; + } +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + if (!pcb->settings.refuse_chap) { + wo->chap_mdtype |= MDTYPE_MD5; + } +#if MSCHAP_SUPPORT + if (!pcb->settings.refuse_mschap) { + wo->chap_mdtype |= MDTYPE_MICROSOFT; + } + if (!pcb->settings.refuse_mschap_v2) { + wo->chap_mdtype |= MDTYPE_MICROSOFT_V2; + } +#endif /* MSCHAP_SUPPORT */ + wo->neg_chap = (wo->chap_mdtype != MDTYPE_NONE); +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + if (!pcb->settings.refuse_eap) { + wo->neg_eap = 1; + } +#endif /* EAP_SUPPORT */ + } +#endif /* PPP_SERVER */ + + } else { +#if PAP_SUPPORT + ao->neg_upap = 0; +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + ao->neg_chap = 0; + ao->chap_mdtype = MDTYPE_NONE; +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + ao->neg_eap = 0; +#endif /* EAP_SUPPORT */ + } + + PPPDEBUG(LOG_DEBUG, ("ppp: auth protocols:")); +#if PAP_SUPPORT + PPPDEBUG(LOG_DEBUG, (" PAP=%d", ao->neg_upap)); +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + PPPDEBUG(LOG_DEBUG, (" CHAP=%d CHAP_MD5=%d", ao->neg_chap, !!(ao->chap_mdtype&MDTYPE_MD5))); +#if MSCHAP_SUPPORT + PPPDEBUG(LOG_DEBUG, (" CHAP_MS=%d CHAP_MS2=%d", !!(ao->chap_mdtype&MDTYPE_MICROSOFT), !!(ao->chap_mdtype&MDTYPE_MICROSOFT_V2))); +#endif /* MSCHAP_SUPPORT */ +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + PPPDEBUG(LOG_DEBUG, (" EAP=%d", ao->neg_eap)); +#endif /* EAP_SUPPORT */ + PPPDEBUG(LOG_DEBUG, ("\n")); + +#endif /* PPP_AUTH_SUPPORT */ + + wo->magicnumber = magic(); + wo->numloops = 0; + *go = *wo; +#ifdef HAVE_MULTILINK + if (!multilink) { + go->neg_mrru = 0; +#endif /* HAVE_MULTILINK */ + go->neg_ssnhf = 0; + go->neg_endpoint = 0; +#ifdef HAVE_MULTILINK + } +#endif /* HAVE_MULTILINK */ + if (pcb->settings.noendpoint) + ao->neg_endpoint = 0; + pcb->peer_mru = PPP_MRU; +#if 0 /* UNUSED */ + auth_reset(pcb); +#endif /* UNUSED */ +} + + +/* + * lcp_cilen - Return length of our CI. + */ +static int lcp_cilen(fsm *f) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + +#define LENCIVOID(neg) ((neg) ? CILEN_VOID : 0) +#if CHAP_SUPPORT +#define LENCICHAP(neg) ((neg) ? CILEN_CHAP : 0) +#endif /* CHAP_SUPPORT */ +#define LENCISHORT(neg) ((neg) ? CILEN_SHORT : 0) +#define LENCILONG(neg) ((neg) ? CILEN_LONG : 0) +#if LQR_SUPPORT +#define LENCILQR(neg) ((neg) ? CILEN_LQR: 0) +#endif /* LQR_SUPPORT */ +#define LENCICBCP(neg) ((neg) ? CILEN_CBCP: 0) + /* + * NB: we only ask for one of CHAP, UPAP, or EAP, even if we will + * accept more than one. We prefer EAP first, then CHAP, then + * PAP. + */ + return (LENCISHORT(go->neg_mru && go->mru != PPP_DEFMRU) + + LENCILONG(go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) + +#if EAP_SUPPORT + LENCISHORT(go->neg_eap) + +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ +#if EAP_SUPPORT + LENCICHAP(!go->neg_eap && go->neg_chap) + +#endif /* EAP_SUPPORT */ +#if !EAP_SUPPORT + LENCICHAP(go->neg_chap) + +#endif /* !EAP_SUPPORT */ +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ +#if EAP_SUPPORT && CHAP_SUPPORT + LENCISHORT(!go->neg_eap && !go->neg_chap && go->neg_upap) + +#endif /* EAP_SUPPORT && CHAP_SUPPORT */ +#if EAP_SUPPORT && !CHAP_SUPPORT + LENCISHORT(!go->neg_eap && go->neg_upap) + +#endif /* EAP_SUPPORT && !CHAP_SUPPORT */ +#if !EAP_SUPPORT && CHAP_SUPPORT + LENCISHORT(!go->neg_chap && go->neg_upap) + +#endif /* !EAP_SUPPORT && CHAP_SUPPORT */ +#if !EAP_SUPPORT && !CHAP_SUPPORT + LENCISHORT(go->neg_upap) + +#endif /* !EAP_SUPPORT && !CHAP_SUPPORT */ +#endif /* PAP_SUPPORT */ +#if LQR_SUPPORT + LENCILQR(go->neg_lqr) + +#endif /* LQR_SUPPORT */ + LENCICBCP(go->neg_cbcp) + + LENCILONG(go->neg_magicnumber) + + LENCIVOID(go->neg_pcompression) + + LENCIVOID(go->neg_accompression) + +#ifdef HAVE_MULTILINK + LENCISHORT(go->neg_mrru) + +#endif /* HAVE_MULTILINK */ + LENCIVOID(go->neg_ssnhf) + + (go->neg_endpoint? CILEN_CHAR + go->endpoint.length: 0)); +} + + +/* + * lcp_addci - Add our desired CIs to a packet. + */ +static void lcp_addci(fsm *f, u_char *ucp, int *lenp) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + u_char *start_ucp = ucp; + +#define ADDCIVOID(opt, neg) \ + if (neg) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_VOID, ucp); \ + } +#define ADDCISHORT(opt, neg, val) \ + if (neg) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_SHORT, ucp); \ + PUTSHORT(val, ucp); \ + } +#if CHAP_SUPPORT +#define ADDCICHAP(opt, neg, val) \ + if (neg) { \ + PUTCHAR((opt), ucp); \ + PUTCHAR(CILEN_CHAP, ucp); \ + PUTSHORT(PPP_CHAP, ucp); \ + PUTCHAR((CHAP_DIGEST(val)), ucp); \ + } +#endif /* CHAP_SUPPORT */ +#define ADDCILONG(opt, neg, val) \ + if (neg) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_LONG, ucp); \ + PUTLONG(val, ucp); \ + } +#if LQR_SUPPORT +#define ADDCILQR(opt, neg, val) \ + if (neg) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_LQR, ucp); \ + PUTSHORT(PPP_LQR, ucp); \ + PUTLONG(val, ucp); \ + } +#endif /* LQR_SUPPORT */ +#define ADDCICHAR(opt, neg, val) \ + if (neg) { \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_CHAR, ucp); \ + PUTCHAR(val, ucp); \ + } +#define ADDCIENDP(opt, neg, class, val, len) \ + if (neg) { \ + int i; \ + PUTCHAR(opt, ucp); \ + PUTCHAR(CILEN_CHAR + len, ucp); \ + PUTCHAR(class, ucp); \ + for (i = 0; i < len; ++i) \ + PUTCHAR(val[i], ucp); \ + } + + ADDCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru); + ADDCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF, + go->asyncmap); +#if EAP_SUPPORT + ADDCISHORT(CI_AUTHTYPE, go->neg_eap, PPP_EAP); +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ +#if EAP_SUPPORT + ADDCICHAP(CI_AUTHTYPE, !go->neg_eap && go->neg_chap, go->chap_mdtype); +#endif /* EAP_SUPPORT */ +#if !EAP_SUPPORT + ADDCICHAP(CI_AUTHTYPE, go->neg_chap, go->chap_mdtype); +#endif /* !EAP_SUPPORT */ +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ +#if EAP_SUPPORT && CHAP_SUPPORT + ADDCISHORT(CI_AUTHTYPE, !go->neg_eap && !go->neg_chap && go->neg_upap, PPP_PAP); +#endif /* EAP_SUPPORT && CHAP_SUPPORT */ +#if EAP_SUPPORT && !CHAP_SUPPORT + ADDCISHORT(CI_AUTHTYPE, !go->neg_eap && go->neg_upap, PPP_PAP); +#endif /* EAP_SUPPORT && !CHAP_SUPPORT */ +#if !EAP_SUPPORT && CHAP_SUPPORT + ADDCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP); +#endif /* !EAP_SUPPORT && CHAP_SUPPORT */ +#if !EAP_SUPPORT && !CHAP_SUPPORT + ADDCISHORT(CI_AUTHTYPE, go->neg_upap, PPP_PAP); +#endif /* !EAP_SUPPORT && !CHAP_SUPPORT */ +#endif /* PAP_SUPPORT */ +#if LQR_SUPPORT + ADDCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period); +#endif /* LQR_SUPPORT */ + ADDCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT); + ADDCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber); + ADDCIVOID(CI_PCOMPRESSION, go->neg_pcompression); + ADDCIVOID(CI_ACCOMPRESSION, go->neg_accompression); +#ifdef HAVE_MULTILINK + ADDCISHORT(CI_MRRU, go->neg_mrru, go->mrru); +#endif + ADDCIVOID(CI_SSNHF, go->neg_ssnhf); + ADDCIENDP(CI_EPDISC, go->neg_endpoint, go->endpoint.class_, + go->endpoint.value, go->endpoint.length); + + if (ucp - start_ucp != *lenp) { + /* this should never happen, because peer_mtu should be 1500 */ + ppp_error("Bug in lcp_addci: wrong length"); + } +} + + +/* + * lcp_ackci - Ack our CIs. + * This should not modify any state if the Ack is bad. + * + * Returns: + * 0 - Ack was bad. + * 1 - Ack was good. + */ +static int lcp_ackci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + u_char cilen, citype, cichar; + u_short cishort; + u32_t cilong; + + /* + * CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define ACKCIVOID(opt, neg) \ + if (neg) { \ + if ((len -= CILEN_VOID) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_VOID || \ + citype != opt) \ + goto bad; \ + } +#define ACKCISHORT(opt, neg, val) \ + if (neg) { \ + if ((len -= CILEN_SHORT) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_SHORT || \ + citype != opt) \ + goto bad; \ + GETSHORT(cishort, p); \ + if (cishort != val) \ + goto bad; \ + } +#define ACKCICHAR(opt, neg, val) \ + if (neg) { \ + if ((len -= CILEN_CHAR) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_CHAR || \ + citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (cichar != val) \ + goto bad; \ + } +#if CHAP_SUPPORT +#define ACKCICHAP(opt, neg, val) \ + if (neg) { \ + if ((len -= CILEN_CHAP) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_CHAP || \ + citype != (opt)) \ + goto bad; \ + GETSHORT(cishort, p); \ + if (cishort != PPP_CHAP) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (cichar != (CHAP_DIGEST(val))) \ + goto bad; \ + } +#endif /* CHAP_SUPPORT */ +#define ACKCILONG(opt, neg, val) \ + if (neg) { \ + if ((len -= CILEN_LONG) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_LONG || \ + citype != opt) \ + goto bad; \ + GETLONG(cilong, p); \ + if (cilong != val) \ + goto bad; \ + } +#if LQR_SUPPORT +#define ACKCILQR(opt, neg, val) \ + if (neg) { \ + if ((len -= CILEN_LQR) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_LQR || \ + citype != opt) \ + goto bad; \ + GETSHORT(cishort, p); \ + if (cishort != PPP_LQR) \ + goto bad; \ + GETLONG(cilong, p); \ + if (cilong != val) \ + goto bad; \ + } +#endif /* LQR_SUPPORT */ +#define ACKCIENDP(opt, neg, class, val, vlen) \ + if (neg) { \ + int i; \ + if ((len -= CILEN_CHAR + vlen) < 0) \ + goto bad; \ + GETCHAR(citype, p); \ + GETCHAR(cilen, p); \ + if (cilen != CILEN_CHAR + vlen || \ + citype != opt) \ + goto bad; \ + GETCHAR(cichar, p); \ + if (cichar != class) \ + goto bad; \ + for (i = 0; i < vlen; ++i) { \ + GETCHAR(cichar, p); \ + if (cichar != val[i]) \ + goto bad; \ + } \ + } + + ACKCISHORT(CI_MRU, go->neg_mru && go->mru != PPP_DEFMRU, go->mru); + ACKCILONG(CI_ASYNCMAP, go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF, + go->asyncmap); +#if EAP_SUPPORT + ACKCISHORT(CI_AUTHTYPE, go->neg_eap, PPP_EAP); +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ +#if EAP_SUPPORT + ACKCICHAP(CI_AUTHTYPE, !go->neg_eap && go->neg_chap, go->chap_mdtype); +#endif /* EAP_SUPPORT */ +#if !EAP_SUPPORT + ACKCICHAP(CI_AUTHTYPE, go->neg_chap, go->chap_mdtype); +#endif /* !EAP_SUPPORT */ +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT /* cannot be improved, embedding a directive within macro arguments is not portable */ +#if EAP_SUPPORT && CHAP_SUPPORT + ACKCISHORT(CI_AUTHTYPE, !go->neg_eap && !go->neg_chap && go->neg_upap, PPP_PAP); +#endif /* EAP_SUPPORT && CHAP_SUPPORT */ +#if EAP_SUPPORT && !CHAP_SUPPORT + ACKCISHORT(CI_AUTHTYPE, !go->neg_eap && go->neg_upap, PPP_PAP); +#endif /* EAP_SUPPORT && !CHAP_SUPPORT */ +#if !EAP_SUPPORT && CHAP_SUPPORT + ACKCISHORT(CI_AUTHTYPE, !go->neg_chap && go->neg_upap, PPP_PAP); +#endif /* !EAP_SUPPORT && CHAP_SUPPORT */ +#if !EAP_SUPPORT && !CHAP_SUPPORT + ACKCISHORT(CI_AUTHTYPE, go->neg_upap, PPP_PAP); +#endif /* !EAP_SUPPORT && !CHAP_SUPPORT */ +#endif /* PAP_SUPPORT */ +#if LQR_SUPPORT + ACKCILQR(CI_QUALITY, go->neg_lqr, go->lqr_period); +#endif /* LQR_SUPPORT */ + ACKCICHAR(CI_CALLBACK, go->neg_cbcp, CBCP_OPT); + ACKCILONG(CI_MAGICNUMBER, go->neg_magicnumber, go->magicnumber); + ACKCIVOID(CI_PCOMPRESSION, go->neg_pcompression); + ACKCIVOID(CI_ACCOMPRESSION, go->neg_accompression); +#ifdef HAVE_MULTILINK + ACKCISHORT(CI_MRRU, go->neg_mrru, go->mrru); +#endif /* HAVE_MULTILINK */ + ACKCIVOID(CI_SSNHF, go->neg_ssnhf); + ACKCIENDP(CI_EPDISC, go->neg_endpoint, go->endpoint.class_, + go->endpoint.value, go->endpoint.length); + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + return (1); +bad: + LCPDEBUG(("lcp_acki: received bad Ack!")); + return (0); +} + + +/* + * lcp_nakci - Peer has sent a NAK for some of our CIs. + * This should not modify any state if the Nak is bad + * or if LCP is in the OPENED state. + * + * Returns: + * 0 - Nak was bad. + * 1 - Nak was good. + */ +static int lcp_nakci(fsm *f, u_char *p, int len, int treat_as_reject) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + lcp_options *wo = &pcb->lcp_wantoptions; + u_char citype, cichar, *next; + u_short cishort; + u32_t cilong; + lcp_options no; /* options we've seen Naks for */ + lcp_options try_; /* options to request next time */ + int looped_back = 0; + int cilen; + + BZERO(&no, sizeof(no)); + try_ = *go; + + /* + * Any Nak'd CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define NAKCIVOID(opt, neg) \ + if (go->neg && \ + len >= CILEN_VOID && \ + p[1] == CILEN_VOID && \ + p[0] == opt) { \ + len -= CILEN_VOID; \ + INCPTR(CILEN_VOID, p); \ + no.neg = 1; \ + try_.neg = 0; \ + } +#if CHAP_SUPPORT +#define NAKCICHAP(opt, neg, code) \ + if (go->neg && \ + len >= CILEN_CHAP && \ + p[1] == CILEN_CHAP && \ + p[0] == opt) { \ + len -= CILEN_CHAP; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + GETCHAR(cichar, p); \ + no.neg = 1; \ + code \ + } +#endif /* CHAP_SUPPORT */ +#define NAKCICHAR(opt, neg, code) \ + if (go->neg && \ + len >= CILEN_CHAR && \ + p[1] == CILEN_CHAR && \ + p[0] == opt) { \ + len -= CILEN_CHAR; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + no.neg = 1; \ + code \ + } +#define NAKCISHORT(opt, neg, code) \ + if (go->neg && \ + len >= CILEN_SHORT && \ + p[1] == CILEN_SHORT && \ + p[0] == opt) { \ + len -= CILEN_SHORT; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + no.neg = 1; \ + code \ + } +#define NAKCILONG(opt, neg, code) \ + if (go->neg && \ + len >= CILEN_LONG && \ + p[1] == CILEN_LONG && \ + p[0] == opt) { \ + len -= CILEN_LONG; \ + INCPTR(2, p); \ + GETLONG(cilong, p); \ + no.neg = 1; \ + code \ + } +#if LQR_SUPPORT +#define NAKCILQR(opt, neg, code) \ + if (go->neg && \ + len >= CILEN_LQR && \ + p[1] == CILEN_LQR && \ + p[0] == opt) { \ + len -= CILEN_LQR; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + GETLONG(cilong, p); \ + no.neg = 1; \ + code \ + } +#endif /* LQR_SUPPORT */ +#define NAKCIENDP(opt, neg) \ + if (go->neg && \ + len >= CILEN_CHAR && \ + p[0] == opt && \ + p[1] >= CILEN_CHAR && \ + p[1] <= len) { \ + len -= p[1]; \ + INCPTR(p[1], p); \ + no.neg = 1; \ + try_.neg = 0; \ + } + + /* + * NOTE! There must be no assignments to individual fields of *go in + * the code below. Any such assignment is a BUG! + */ + /* + * We don't care if they want to send us smaller packets than + * we want. Therefore, accept any MRU less than what we asked for, + * but then ignore the new value when setting the MRU in the kernel. + * If they send us a bigger MRU than what we asked, accept it, up to + * the limit of the default MRU we'd get if we didn't negotiate. + */ + if (go->neg_mru && go->mru != PPP_DEFMRU) { + NAKCISHORT(CI_MRU, neg_mru, + if (cishort <= wo->mru || cishort <= PPP_DEFMRU) + try_.mru = cishort; + ); + } + + /* + * Add any characters they want to our (receive-side) asyncmap. + */ + if (go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) { + NAKCILONG(CI_ASYNCMAP, neg_asyncmap, + try_.asyncmap = go->asyncmap | cilong; + ); + } + + /* + * If they've nak'd our authentication-protocol, check whether + * they are proposing a different protocol, or a different + * hash algorithm for CHAP. + */ + if ((0 +#if CHAP_SUPPORT + || go->neg_chap +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + || go->neg_upap +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + || go->neg_eap +#endif /* EAP_SUPPORT */ + ) + && len >= CILEN_SHORT + && p[0] == CI_AUTHTYPE && p[1] >= CILEN_SHORT && p[1] <= len) { + cilen = p[1]; + len -= cilen; +#if CHAP_SUPPORT + no.neg_chap = go->neg_chap; +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + no.neg_upap = go->neg_upap; +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + no.neg_eap = go->neg_eap; +#endif /* EAP_SUPPORT */ + INCPTR(2, p); + GETSHORT(cishort, p); + +#if PAP_SUPPORT + if (cishort == PPP_PAP && cilen == CILEN_SHORT) { +#if EAP_SUPPORT + /* If we were asking for EAP, then we need to stop that. */ + if (go->neg_eap) + try_.neg_eap = 0; + else +#endif /* EAP_SUPPORT */ + +#if CHAP_SUPPORT + /* If we were asking for CHAP, then we need to stop that. */ + if (go->neg_chap) + try_.neg_chap = 0; + else +#endif /* CHAP_SUPPORT */ + + /* + * If we weren't asking for CHAP or EAP, then we were asking for + * PAP, in which case this Nak is bad. + */ + goto bad; + } else +#endif /* PAP_SUPPORT */ + +#if CHAP_SUPPORT + if (cishort == PPP_CHAP && cilen == CILEN_CHAP) { + GETCHAR(cichar, p); +#if EAP_SUPPORT + /* Stop asking for EAP, if we were. */ + if (go->neg_eap) { + try_.neg_eap = 0; + /* Try to set up to use their suggestion, if possible */ + if (CHAP_CANDIGEST(go->chap_mdtype, cichar)) + try_.chap_mdtype = CHAP_MDTYPE_D(cichar); + } else +#endif /* EAP_SUPPORT */ + if (go->neg_chap) { + /* + * We were asking for our preferred algorithm, they must + * want something different. + */ + if (cichar != CHAP_DIGEST(go->chap_mdtype)) { + if (CHAP_CANDIGEST(go->chap_mdtype, cichar)) { + /* Use their suggestion if we support it ... */ + try_.chap_mdtype = CHAP_MDTYPE_D(cichar); + } else { + /* ... otherwise, try our next-preferred algorithm. */ + try_.chap_mdtype &= ~(CHAP_MDTYPE(try_.chap_mdtype)); + if (try_.chap_mdtype == MDTYPE_NONE) /* out of algos */ + try_.neg_chap = 0; + } + } else { + /* + * Whoops, they Nak'd our algorithm of choice + * but then suggested it back to us. + */ + goto bad; + } + } else { + /* + * Stop asking for PAP if we were asking for it. + */ +#if PAP_SUPPORT + try_.neg_upap = 0; +#endif /* PAP_SUPPORT */ + } + + } else +#endif /* CHAP_SUPPORT */ + { + +#if EAP_SUPPORT + /* + * If we were asking for EAP, and they're Conf-Naking EAP, + * well, that's just strange. Nobody should do that. + */ + if (cishort == PPP_EAP && cilen == CILEN_SHORT && go->neg_eap) + ppp_dbglog("Unexpected Conf-Nak for EAP"); + + /* + * We don't recognize what they're suggesting. + * Stop asking for what we were asking for. + */ + if (go->neg_eap) + try_.neg_eap = 0; + else +#endif /* EAP_SUPPORT */ + +#if CHAP_SUPPORT + if (go->neg_chap) + try_.neg_chap = 0; + else +#endif /* CHAP_SUPPORT */ + +#if PAP_SUPPORT + if(1) + try_.neg_upap = 0; + else +#endif /* PAP_SUPPORT */ + {} + + p += cilen - CILEN_SHORT; + } + } + +#if LQR_SUPPORT + /* + * If they can't cope with our link quality protocol, we'll have + * to stop asking for LQR. We haven't got any other protocol. + * If they Nak the reporting period, take their value XXX ? + */ + NAKCILQR(CI_QUALITY, neg_lqr, + if (cishort != PPP_LQR) + try_.neg_lqr = 0; + else + try_.lqr_period = cilong; + ); +#endif /* LQR_SUPPORT */ + + /* + * Only implementing CBCP...not the rest of the callback options + */ + NAKCICHAR(CI_CALLBACK, neg_cbcp, + try_.neg_cbcp = 0; + (void)cichar; /* if CHAP support is not compiled, cichar is set but not used, which makes some compilers complaining */ + ); + + /* + * Check for a looped-back line. + */ + NAKCILONG(CI_MAGICNUMBER, neg_magicnumber, + try_.magicnumber = magic(); + looped_back = 1; + ); + + /* + * Peer shouldn't send Nak for protocol compression or + * address/control compression requests; they should send + * a Reject instead. If they send a Nak, treat it as a Reject. + */ + NAKCIVOID(CI_PCOMPRESSION, neg_pcompression); + NAKCIVOID(CI_ACCOMPRESSION, neg_accompression); + +#ifdef HAVE_MULTILINK + /* + * Nak for MRRU option - accept their value if it is smaller + * than the one we want. + */ + if (go->neg_mrru) { + NAKCISHORT(CI_MRRU, neg_mrru, + if (treat_as_reject) + try_.neg_mrru = 0; + else if (cishort <= wo->mrru) + try_.mrru = cishort; + ); + } +#else /* HAVE_MULTILINK */ + LWIP_UNUSED_ARG(treat_as_reject); +#endif /* HAVE_MULTILINK */ + + /* + * Nak for short sequence numbers shouldn't be sent, treat it + * like a reject. + */ + NAKCIVOID(CI_SSNHF, neg_ssnhf); + + /* + * Nak of the endpoint discriminator option is not permitted, + * treat it like a reject. + */ + NAKCIENDP(CI_EPDISC, neg_endpoint); + + /* + * There may be remaining CIs, if the peer is requesting negotiation + * on an option that we didn't include in our request packet. + * If we see an option that we requested, or one we've already seen + * in this packet, then this packet is bad. + * If we wanted to respond by starting to negotiate on the requested + * option(s), we could, but we don't, because except for the + * authentication type and quality protocol, if we are not negotiating + * an option, it is because we were told not to. + * For the authentication type, the Nak from the peer means + * `let me authenticate myself with you' which is a bit pointless. + * For the quality protocol, the Nak means `ask me to send you quality + * reports', but if we didn't ask for them, we don't want them. + * An option we don't recognize represents the peer asking to + * negotiate some option we don't support, so ignore it. + */ + while (len >= CILEN_VOID) { + GETCHAR(citype, p); + GETCHAR(cilen, p); + if (cilen < CILEN_VOID || (len -= cilen) < 0) + goto bad; + next = p + cilen - 2; + + switch (citype) { + case CI_MRU: + if ((go->neg_mru && go->mru != PPP_DEFMRU) + || no.neg_mru || cilen != CILEN_SHORT) + goto bad; + GETSHORT(cishort, p); + if (cishort < PPP_DEFMRU) { + try_.neg_mru = 1; + try_.mru = cishort; + } + break; + case CI_ASYNCMAP: + if ((go->neg_asyncmap && go->asyncmap != 0xFFFFFFFF) + || no.neg_asyncmap || cilen != CILEN_LONG) + goto bad; + break; + case CI_AUTHTYPE: + if (0 +#if CHAP_SUPPORT + || go->neg_chap || no.neg_chap +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + || go->neg_upap || no.neg_upap +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + || go->neg_eap || no.neg_eap +#endif /* EAP_SUPPORT */ + ) + goto bad; + break; + case CI_MAGICNUMBER: + if (go->neg_magicnumber || no.neg_magicnumber || + cilen != CILEN_LONG) + goto bad; + break; + case CI_PCOMPRESSION: + if (go->neg_pcompression || no.neg_pcompression + || cilen != CILEN_VOID) + goto bad; + break; + case CI_ACCOMPRESSION: + if (go->neg_accompression || no.neg_accompression + || cilen != CILEN_VOID) + goto bad; + break; +#if LQR_SUPPORT + case CI_QUALITY: + if (go->neg_lqr || no.neg_lqr || cilen != CILEN_LQR) + goto bad; + break; +#endif /* LQR_SUPPORT */ +#ifdef HAVE_MULTILINK + case CI_MRRU: + if (go->neg_mrru || no.neg_mrru || cilen != CILEN_SHORT) + goto bad; + break; +#endif /* HAVE_MULTILINK */ + case CI_SSNHF: + if (go->neg_ssnhf || no.neg_ssnhf || cilen != CILEN_VOID) + goto bad; + try_.neg_ssnhf = 1; + break; + case CI_EPDISC: + if (go->neg_endpoint || no.neg_endpoint || cilen < CILEN_CHAR) + goto bad; + break; + default: + break; + } + p = next; + } + + /* + * OK, the Nak is good. Now we can update state. + * If there are any options left we ignore them. + */ + if (f->state != PPP_FSM_OPENED) { + if (looped_back) { + if (++try_.numloops >= pcb->settings.lcp_loopbackfail) { + ppp_notice("Serial line is looped back."); + pcb->err_code = PPPERR_LOOPBACK; + lcp_close(f->pcb, "Loopback detected"); + } + } else + try_.numloops = 0; + *go = try_; + } + + return 1; + +bad: + LCPDEBUG(("lcp_nakci: received bad Nak!")); + return 0; +} + + +/* + * lcp_rejci - Peer has Rejected some of our CIs. + * This should not modify any state if the Reject is bad + * or if LCP is in the OPENED state. + * + * Returns: + * 0 - Reject was bad. + * 1 - Reject was good. + */ +static int lcp_rejci(fsm *f, u_char *p, int len) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + u_char cichar; + u_short cishort; + u32_t cilong; + lcp_options try_; /* options to request next time */ + + try_ = *go; + + /* + * Any Rejected CIs must be in exactly the same order that we sent. + * Check packet length and CI length at each step. + * If we find any deviations, then this packet is bad. + */ +#define REJCIVOID(opt, neg) \ + if (go->neg && \ + len >= CILEN_VOID && \ + p[1] == CILEN_VOID && \ + p[0] == opt) { \ + len -= CILEN_VOID; \ + INCPTR(CILEN_VOID, p); \ + try_.neg = 0; \ + } +#define REJCISHORT(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_SHORT && \ + p[1] == CILEN_SHORT && \ + p[0] == opt) { \ + len -= CILEN_SHORT; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + /* Check rejected value. */ \ + if (cishort != val) \ + goto bad; \ + try_.neg = 0; \ + } + +#if CHAP_SUPPORT && EAP_SUPPORT && PAP_SUPPORT +#define REJCICHAP(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_CHAP && \ + p[1] == CILEN_CHAP && \ + p[0] == opt) { \ + len -= CILEN_CHAP; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ + goto bad; \ + try_.neg = 0; \ + try_.neg_eap = try_.neg_upap = 0; \ + } +#endif /* CHAP_SUPPORT && EAP_SUPPORT && PAP_SUPPORT */ + +#if CHAP_SUPPORT && !EAP_SUPPORT && PAP_SUPPORT +#define REJCICHAP(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_CHAP && \ + p[1] == CILEN_CHAP && \ + p[0] == opt) { \ + len -= CILEN_CHAP; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ + goto bad; \ + try_.neg = 0; \ + try_.neg_upap = 0; \ + } +#endif /* CHAP_SUPPORT && !EAP_SUPPORT && PAP_SUPPORT */ + +#if CHAP_SUPPORT && EAP_SUPPORT && !PAP_SUPPORT +#define REJCICHAP(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_CHAP && \ + p[1] == CILEN_CHAP && \ + p[0] == opt) { \ + len -= CILEN_CHAP; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ + goto bad; \ + try_.neg = 0; \ + try_.neg_eap = 0; \ + } +#endif /* CHAP_SUPPORT && EAP_SUPPORT && !PAP_SUPPORT */ + +#if CHAP_SUPPORT && !EAP_SUPPORT && !PAP_SUPPORT +#define REJCICHAP(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_CHAP && \ + p[1] == CILEN_CHAP && \ + p[0] == opt) { \ + len -= CILEN_CHAP; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if ((cishort != PPP_CHAP) || (cichar != (CHAP_DIGEST(val)))) \ + goto bad; \ + try_.neg = 0; \ + } +#endif /* CHAP_SUPPORT && !EAP_SUPPORT && !PAP_SUPPORT */ + +#define REJCILONG(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_LONG && \ + p[1] == CILEN_LONG && \ + p[0] == opt) { \ + len -= CILEN_LONG; \ + INCPTR(2, p); \ + GETLONG(cilong, p); \ + /* Check rejected value. */ \ + if (cilong != val) \ + goto bad; \ + try_.neg = 0; \ + } +#if LQR_SUPPORT +#define REJCILQR(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_LQR && \ + p[1] == CILEN_LQR && \ + p[0] == opt) { \ + len -= CILEN_LQR; \ + INCPTR(2, p); \ + GETSHORT(cishort, p); \ + GETLONG(cilong, p); \ + /* Check rejected value. */ \ + if (cishort != PPP_LQR || cilong != val) \ + goto bad; \ + try_.neg = 0; \ + } +#endif /* LQR_SUPPORT */ +#define REJCICBCP(opt, neg, val) \ + if (go->neg && \ + len >= CILEN_CBCP && \ + p[1] == CILEN_CBCP && \ + p[0] == opt) { \ + len -= CILEN_CBCP; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + /* Check rejected value. */ \ + if (cichar != val) \ + goto bad; \ + try_.neg = 0; \ + } +#define REJCIENDP(opt, neg, class, val, vlen) \ + if (go->neg && \ + len >= CILEN_CHAR + vlen && \ + p[0] == opt && \ + p[1] == CILEN_CHAR + vlen) { \ + int i; \ + len -= CILEN_CHAR + vlen; \ + INCPTR(2, p); \ + GETCHAR(cichar, p); \ + if (cichar != class) \ + goto bad; \ + for (i = 0; i < vlen; ++i) { \ + GETCHAR(cichar, p); \ + if (cichar != val[i]) \ + goto bad; \ + } \ + try_.neg = 0; \ + } + + REJCISHORT(CI_MRU, neg_mru, go->mru); + REJCILONG(CI_ASYNCMAP, neg_asyncmap, go->asyncmap); +#if EAP_SUPPORT + REJCISHORT(CI_AUTHTYPE, neg_eap, PPP_EAP); + if (!go->neg_eap) { +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT + REJCICHAP(CI_AUTHTYPE, neg_chap, go->chap_mdtype); + if (!go->neg_chap) { +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + REJCISHORT(CI_AUTHTYPE, neg_upap, PPP_PAP); +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + } +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + } +#endif /* EAP_SUPPORT */ +#if LQR_SUPPORT + REJCILQR(CI_QUALITY, neg_lqr, go->lqr_period); +#endif /* LQR_SUPPORT */ + REJCICBCP(CI_CALLBACK, neg_cbcp, CBCP_OPT); + REJCILONG(CI_MAGICNUMBER, neg_magicnumber, go->magicnumber); + REJCIVOID(CI_PCOMPRESSION, neg_pcompression); + REJCIVOID(CI_ACCOMPRESSION, neg_accompression); +#ifdef HAVE_MULTILINK + REJCISHORT(CI_MRRU, neg_mrru, go->mrru); +#endif /* HAVE_MULTILINK */ + REJCIVOID(CI_SSNHF, neg_ssnhf); + REJCIENDP(CI_EPDISC, neg_endpoint, go->endpoint.class_, + go->endpoint.value, go->endpoint.length); + + /* + * If there are any remaining CIs, then this packet is bad. + */ + if (len != 0) + goto bad; + /* + * Now we can update state. + */ + if (f->state != PPP_FSM_OPENED) + *go = try_; + return 1; + +bad: + LCPDEBUG(("lcp_rejci: received bad Reject!")); + return 0; +} + + +/* + * lcp_reqci - Check the peer's requested CIs and send appropriate response. + * + * Returns: CONFACK, CONFNAK or CONFREJ and input packet modified + * appropriately. If reject_if_disagree is non-zero, doesn't return + * CONFNAK; returns CONFREJ if it can't return CONFACK. + * + * inp = Requested CIs + * lenp = Length of requested CIs + */ +static int lcp_reqci(fsm *f, u_char *inp, int *lenp, int reject_if_disagree) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + lcp_options *ho = &pcb->lcp_hisoptions; + lcp_options *ao = &pcb->lcp_allowoptions; + u_char *cip, *next; /* Pointer to current and next CIs */ + int cilen, citype, cichar; /* Parsed len, type, char value */ + u_short cishort; /* Parsed short value */ + u32_t cilong; /* Parse long value */ + int rc = CONFACK; /* Final packet return code */ + int orc; /* Individual option return code */ + u_char *p; /* Pointer to next char to parse */ + u_char *rejp; /* Pointer to next char in reject frame */ + struct pbuf *nakp; /* Nak buffer */ + u_char *nakoutp; /* Pointer to next char in Nak frame */ + int l = *lenp; /* Length left */ + + /* + * Reset all his options. + */ + BZERO(ho, sizeof(*ho)); + + /* + * Process all his options. + */ + next = inp; + nakp = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_CTRL_PBUF_MAX_SIZE), PPP_CTRL_PBUF_TYPE); + if(NULL == nakp) + return 0; + if(nakp->tot_len != nakp->len) { + pbuf_free(nakp); + return 0; + } + + nakoutp = (u_char*)nakp->payload; + rejp = inp; + while (l) { + orc = CONFACK; /* Assume success */ + cip = p = next; /* Remember begining of CI */ + if (l < 2 || /* Not enough data for CI header or */ + p[1] < 2 || /* CI length too small or */ + p[1] > l) { /* CI length too big? */ + LCPDEBUG(("lcp_reqci: bad CI length!")); + orc = CONFREJ; /* Reject bad CI */ + cilen = l; /* Reject till end of packet */ + l = 0; /* Don't loop again */ + citype = 0; + goto endswitch; + } + GETCHAR(citype, p); /* Parse CI type */ + GETCHAR(cilen, p); /* Parse CI length */ + l -= cilen; /* Adjust remaining length */ + next += cilen; /* Step to next CI */ + + switch (citype) { /* Check CI type */ + case CI_MRU: + if (!ao->neg_mru || /* Allow option? */ + cilen != CILEN_SHORT) { /* Check CI length */ + orc = CONFREJ; /* Reject CI */ + break; + } + GETSHORT(cishort, p); /* Parse MRU */ + + /* + * He must be able to receive at least our minimum. + * No need to check a maximum. If he sends a large number, + * we'll just ignore it. + */ + if (cishort < PPP_MINMRU) { + orc = CONFNAK; /* Nak CI */ + PUTCHAR(CI_MRU, nakoutp); + PUTCHAR(CILEN_SHORT, nakoutp); + PUTSHORT(PPP_MINMRU, nakoutp); /* Give him a hint */ + break; + } + ho->neg_mru = 1; /* Remember he sent MRU */ + ho->mru = cishort; /* And remember value */ + break; + + case CI_ASYNCMAP: + if (!ao->neg_asyncmap || + cilen != CILEN_LONG) { + orc = CONFREJ; + break; + } + GETLONG(cilong, p); + + /* + * Asyncmap must have set at least the bits + * which are set in lcp_allowoptions[unit].asyncmap. + */ + if ((ao->asyncmap & ~cilong) != 0) { + orc = CONFNAK; + PUTCHAR(CI_ASYNCMAP, nakoutp); + PUTCHAR(CILEN_LONG, nakoutp); + PUTLONG(ao->asyncmap | cilong, nakoutp); + break; + } + ho->neg_asyncmap = 1; + ho->asyncmap = cilong; + break; + + case CI_AUTHTYPE: + if (cilen < CILEN_SHORT || + !(0 +#if PAP_SUPPORT + || ao->neg_upap +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + || ao->neg_chap +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + || ao->neg_eap +#endif /* EAP_SUPPORT */ + )) { + /* + * Reject the option if we're not willing to authenticate. + */ + ppp_dbglog("No auth is possible"); + orc = CONFREJ; + break; + } + GETSHORT(cishort, p); + + /* + * Authtype must be PAP, CHAP, or EAP. + * + * Note: if more than one of ao->neg_upap, ao->neg_chap, and + * ao->neg_eap are set, and the peer sends a Configure-Request + * with two or more authenticate-protocol requests, then we will + * reject the second request. + * Whether we end up doing CHAP, UPAP, or EAP depends then on + * the ordering of the CIs in the peer's Configure-Request. + */ + +#if PAP_SUPPORT + if (cishort == PPP_PAP) { + /* we've already accepted CHAP or EAP */ + if (0 +#if CHAP_SUPPORT + || ho->neg_chap +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + || ho->neg_eap +#endif /* EAP_SUPPORT */ + || cilen != CILEN_SHORT) { + LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE PAP, rejecting...")); + orc = CONFREJ; + break; + } + if (!ao->neg_upap) { /* we don't want to do PAP */ + orc = CONFNAK; /* NAK it and suggest CHAP or EAP */ + PUTCHAR(CI_AUTHTYPE, nakoutp); +#if EAP_SUPPORT + if (ao->neg_eap) { + PUTCHAR(CILEN_SHORT, nakoutp); + PUTSHORT(PPP_EAP, nakoutp); + } else { +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT + PUTCHAR(CILEN_CHAP, nakoutp); + PUTSHORT(PPP_CHAP, nakoutp); + PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + } +#endif /* EAP_SUPPORT */ + break; + } + ho->neg_upap = 1; + break; + } +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + if (cishort == PPP_CHAP) { + /* we've already accepted PAP or EAP */ + if ( +#if PAP_SUPPORT + ho->neg_upap || +#endif /* PAP_SUPPORT */ +#if EAP_SUPPORT + ho->neg_eap || +#endif /* EAP_SUPPORT */ + cilen != CILEN_CHAP) { + LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE CHAP, rejecting...")); + orc = CONFREJ; + break; + } + if (!ao->neg_chap) { /* we don't want to do CHAP */ + orc = CONFNAK; /* NAK it and suggest EAP or PAP */ + PUTCHAR(CI_AUTHTYPE, nakoutp); + PUTCHAR(CILEN_SHORT, nakoutp); +#if EAP_SUPPORT + if (ao->neg_eap) { + PUTSHORT(PPP_EAP, nakoutp); + } else +#endif /* EAP_SUPPORT */ +#if PAP_SUPPORT + if(1) { + PUTSHORT(PPP_PAP, nakoutp); + } + else +#endif /* PAP_SUPPORT */ + {} + break; + } + GETCHAR(cichar, p); /* get digest type */ + if (!(CHAP_CANDIGEST(ao->chap_mdtype, cichar))) { + /* + * We can't/won't do the requested type, + * suggest something else. + */ + orc = CONFNAK; + PUTCHAR(CI_AUTHTYPE, nakoutp); + PUTCHAR(CILEN_CHAP, nakoutp); + PUTSHORT(PPP_CHAP, nakoutp); + PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); + break; + } + ho->chap_mdtype = CHAP_MDTYPE_D(cichar); /* save md type */ + ho->neg_chap = 1; + break; + } +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + if (cishort == PPP_EAP) { + /* we've already accepted CHAP or PAP */ + if ( +#if CHAP_SUPPORT + ho->neg_chap || +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + ho->neg_upap || +#endif /* PAP_SUPPORT */ + cilen != CILEN_SHORT) { + LCPDEBUG(("lcp_reqci: rcvd AUTHTYPE EAP, rejecting...")); + orc = CONFREJ; + break; + } + if (!ao->neg_eap) { /* we don't want to do EAP */ + orc = CONFNAK; /* NAK it and suggest CHAP or PAP */ + PUTCHAR(CI_AUTHTYPE, nakoutp); +#if CHAP_SUPPORT + if (ao->neg_chap) { + PUTCHAR(CILEN_CHAP, nakoutp); + PUTSHORT(PPP_CHAP, nakoutp); + PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); + } else +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + if(1) { + PUTCHAR(CILEN_SHORT, nakoutp); + PUTSHORT(PPP_PAP, nakoutp); + } else +#endif /* PAP_SUPPORT */ + {} + break; + } + ho->neg_eap = 1; + break; + } +#endif /* EAP_SUPPORT */ + + /* + * We don't recognize the protocol they're asking for. + * Nak it with something we're willing to do. + * (At this point we know ao->neg_upap || ao->neg_chap || + * ao->neg_eap.) + */ + orc = CONFNAK; + PUTCHAR(CI_AUTHTYPE, nakoutp); + +#if EAP_SUPPORT + if (ao->neg_eap) { + PUTCHAR(CILEN_SHORT, nakoutp); + PUTSHORT(PPP_EAP, nakoutp); + } else +#endif /* EAP_SUPPORT */ +#if CHAP_SUPPORT + if (ao->neg_chap) { + PUTCHAR(CILEN_CHAP, nakoutp); + PUTSHORT(PPP_CHAP, nakoutp); + PUTCHAR(CHAP_DIGEST(ao->chap_mdtype), nakoutp); + } else +#endif /* CHAP_SUPPORT */ +#if PAP_SUPPORT + if(1) { + PUTCHAR(CILEN_SHORT, nakoutp); + PUTSHORT(PPP_PAP, nakoutp); + } else +#endif /* PAP_SUPPORT */ + {} + break; + +#if LQR_SUPPORT + case CI_QUALITY: + if (!ao->neg_lqr || + cilen != CILEN_LQR) { + orc = CONFREJ; + break; + } + + GETSHORT(cishort, p); + GETLONG(cilong, p); + + /* + * Check the protocol and the reporting period. + * XXX When should we Nak this, and what with? + */ + if (cishort != PPP_LQR) { + orc = CONFNAK; + PUTCHAR(CI_QUALITY, nakoutp); + PUTCHAR(CILEN_LQR, nakoutp); + PUTSHORT(PPP_LQR, nakoutp); + PUTLONG(ao->lqr_period, nakoutp); + break; + } + break; +#endif /* LQR_SUPPORT */ + + case CI_MAGICNUMBER: + if (!(ao->neg_magicnumber || go->neg_magicnumber) || + cilen != CILEN_LONG) { + orc = CONFREJ; + break; + } + GETLONG(cilong, p); + + /* + * He must have a different magic number. + */ + if (go->neg_magicnumber && + cilong == go->magicnumber) { + cilong = magic(); /* Don't put magic() inside macro! */ + orc = CONFNAK; + PUTCHAR(CI_MAGICNUMBER, nakoutp); + PUTCHAR(CILEN_LONG, nakoutp); + PUTLONG(cilong, nakoutp); + break; + } + ho->neg_magicnumber = 1; + ho->magicnumber = cilong; + break; + + + case CI_PCOMPRESSION: + if (!ao->neg_pcompression || + cilen != CILEN_VOID) { + orc = CONFREJ; + break; + } + ho->neg_pcompression = 1; + break; + + case CI_ACCOMPRESSION: + if (!ao->neg_accompression || + cilen != CILEN_VOID) { + orc = CONFREJ; + break; + } + ho->neg_accompression = 1; + break; + +#ifdef HAVE_MULTILINK + case CI_MRRU: + if (!ao->neg_mrru + || !multilink + || cilen != CILEN_SHORT) { + orc = CONFREJ; + break; + } + + GETSHORT(cishort, p); + /* possibly should insist on a minimum/maximum MRRU here */ + ho->neg_mrru = 1; + ho->mrru = cishort; + break; +#endif /* HAVE_MULTILINK */ + + case CI_SSNHF: + if (!ao->neg_ssnhf +#ifdef HAVE_MULTILINK + || !multilink +#endif /* HAVE_MULTILINK */ + || cilen != CILEN_VOID) { + orc = CONFREJ; + break; + } + ho->neg_ssnhf = 1; + break; + + case CI_EPDISC: + if (!ao->neg_endpoint || + cilen < CILEN_CHAR || + cilen > CILEN_CHAR + MAX_ENDP_LEN) { + orc = CONFREJ; + break; + } + GETCHAR(cichar, p); + cilen -= CILEN_CHAR; + ho->neg_endpoint = 1; + ho->endpoint.class_ = cichar; + ho->endpoint.length = cilen; + MEMCPY(ho->endpoint.value, p, cilen); + INCPTR(cilen, p); + break; + + default: + LCPDEBUG(("lcp_reqci: rcvd unknown option %d", citype)); + orc = CONFREJ; + break; + } + +endswitch: + if (orc == CONFACK && /* Good CI */ + rc != CONFACK) /* but prior CI wasnt? */ + continue; /* Don't send this one */ + + if (orc == CONFNAK) { /* Nak this CI? */ + if (reject_if_disagree /* Getting fed up with sending NAKs? */ + && citype != CI_MAGICNUMBER) { + orc = CONFREJ; /* Get tough if so */ + } else { + if (rc == CONFREJ) /* Rejecting prior CI? */ + continue; /* Don't send this one */ + rc = CONFNAK; + } + } + if (orc == CONFREJ) { /* Reject this CI */ + rc = CONFREJ; + if (cip != rejp) /* Need to move rejected CI? */ + MEMCPY(rejp, cip, cilen); /* Move it */ + INCPTR(cilen, rejp); /* Update output pointer */ + } + } + + /* + * If we wanted to send additional NAKs (for unsent CIs), the + * code would go here. The extra NAKs would go at *nakoutp. + * At present there are no cases where we want to ask the + * peer to negotiate an option. + */ + + switch (rc) { + case CONFACK: + *lenp = next - inp; + break; + case CONFNAK: + /* + * Copy the Nak'd options from the nak buffer to the caller's buffer. + */ + *lenp = nakoutp - (u_char*)nakp->payload; + MEMCPY(inp, nakp->payload, *lenp); + break; + case CONFREJ: + *lenp = rejp - inp; + break; + default: + break; + } + + pbuf_free(nakp); + LCPDEBUG(("lcp_reqci: returning CONF%s.", CODENAME(rc))); + return (rc); /* Return final code */ +} + + +/* + * lcp_up - LCP has come UP. + */ +static void lcp_up(fsm *f) { + ppp_pcb *pcb = f->pcb; + lcp_options *wo = &pcb->lcp_wantoptions; + lcp_options *ho = &pcb->lcp_hisoptions; + lcp_options *go = &pcb->lcp_gotoptions; + lcp_options *ao = &pcb->lcp_allowoptions; + int mtu, mru; + + if (!go->neg_magicnumber) + go->magicnumber = 0; + if (!ho->neg_magicnumber) + ho->magicnumber = 0; + + /* + * Set our MTU to the smaller of the MTU we wanted and + * the MRU our peer wanted. If we negotiated an MRU, + * set our MRU to the larger of value we wanted and + * the value we got in the negotiation. + * Note on the MTU: the link MTU can be the MRU the peer wanted, + * the interface MTU is set to the lowest of that, the + * MTU we want to use, and our link MRU. + */ + mtu = ho->neg_mru? ho->mru: PPP_MRU; + mru = go->neg_mru? LWIP_MAX(wo->mru, go->mru): PPP_MRU; +#ifdef HAVE_MULTILINK + if (!(multilink && go->neg_mrru && ho->neg_mrru)) +#endif /* HAVE_MULTILINK */ + netif_set_mtu(pcb, LWIP_MIN(LWIP_MIN(mtu, mru), ao->mru)); + ppp_send_config(pcb, mtu, + (ho->neg_asyncmap? ho->asyncmap: 0xffffffff), + ho->neg_pcompression, ho->neg_accompression); + ppp_recv_config(pcb, mru, + (pcb->settings.lax_recv? 0: go->neg_asyncmap? go->asyncmap: 0xffffffff), + go->neg_pcompression, go->neg_accompression); + + if (ho->neg_mru) + pcb->peer_mru = ho->mru; + + lcp_echo_lowerup(f->pcb); /* Enable echo messages */ + + link_established(pcb); +} + + +/* + * lcp_down - LCP has gone DOWN. + * + * Alert other protocols. + */ +static void lcp_down(fsm *f) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + + lcp_echo_lowerdown(f->pcb); + + link_down(pcb); + + ppp_send_config(pcb, PPP_MRU, 0xffffffff, 0, 0); + ppp_recv_config(pcb, PPP_MRU, + (go->neg_asyncmap? go->asyncmap: 0xffffffff), + go->neg_pcompression, go->neg_accompression); + pcb->peer_mru = PPP_MRU; +} + + +/* + * lcp_starting - LCP needs the lower layer up. + */ +static void lcp_starting(fsm *f) { + ppp_pcb *pcb = f->pcb; + link_required(pcb); +} + + +/* + * lcp_finished - LCP has finished with the lower layer. + */ +static void lcp_finished(fsm *f) { + ppp_pcb *pcb = f->pcb; + link_terminated(pcb); +} + + +#if PRINTPKT_SUPPORT +/* + * lcp_printpkt - print the contents of an LCP packet. + */ +static const char* const lcp_codenames[] = { + "ConfReq", "ConfAck", "ConfNak", "ConfRej", + "TermReq", "TermAck", "CodeRej", "ProtRej", + "EchoReq", "EchoRep", "DiscReq", "Ident", + "TimeRem" +}; + +static int lcp_printpkt(const u_char *p, int plen, + void (*printer) (void *, const char *, ...), void *arg) { + int code, id, len, olen, i; + const u_char *pstart, *optend; + u_short cishort; + u32_t cilong; + + if (plen < HEADERLEN) + return 0; + pstart = p; + GETCHAR(code, p); + GETCHAR(id, p); + GETSHORT(len, p); + if (len < HEADERLEN || len > plen) + return 0; + + if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(lcp_codenames)) + printer(arg, " %s", lcp_codenames[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= HEADERLEN; + switch (code) { + case CONFREQ: + case CONFACK: + case CONFNAK: + case CONFREJ: + /* print option list */ + while (len >= 2) { + GETCHAR(code, p); + GETCHAR(olen, p); + p -= 2; + if (olen < 2 || olen > len) { + break; + } + printer(arg, " <"); + len -= olen; + optend = p + olen; + switch (code) { + case CI_MRU: + if (olen == CILEN_SHORT) { + p += 2; + GETSHORT(cishort, p); + printer(arg, "mru %d", cishort); + } + break; + case CI_ASYNCMAP: + if (olen == CILEN_LONG) { + p += 2; + GETLONG(cilong, p); + printer(arg, "asyncmap 0x%x", cilong); + } + break; + case CI_AUTHTYPE: + if (olen >= CILEN_SHORT) { + p += 2; + printer(arg, "auth "); + GETSHORT(cishort, p); + switch (cishort) { +#if PAP_SUPPORT + case PPP_PAP: + printer(arg, "pap"); + break; +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + case PPP_CHAP: + printer(arg, "chap"); + if (p < optend) { + switch (*p) { + case CHAP_MD5: + printer(arg, " MD5"); + ++p; + break; +#if MSCHAP_SUPPORT + case CHAP_MICROSOFT: + printer(arg, " MS"); + ++p; + break; + + case CHAP_MICROSOFT_V2: + printer(arg, " MS-v2"); + ++p; + break; +#endif /* MSCHAP_SUPPORT */ + default: + break; + } + } + break; +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + case PPP_EAP: + printer(arg, "eap"); + break; +#endif /* EAP_SUPPORT */ + default: + printer(arg, "0x%x", cishort); + } + } + break; +#if LQR_SUPPORT + case CI_QUALITY: + if (olen >= CILEN_SHORT) { + p += 2; + printer(arg, "quality "); + GETSHORT(cishort, p); + switch (cishort) { + case PPP_LQR: + printer(arg, "lqr"); + break; + default: + printer(arg, "0x%x", cishort); + } + } + break; +#endif /* LQR_SUPPORT */ + case CI_CALLBACK: + if (olen >= CILEN_CHAR) { + p += 2; + printer(arg, "callback "); + GETCHAR(cishort, p); + switch (cishort) { + case CBCP_OPT: + printer(arg, "CBCP"); + break; + default: + printer(arg, "0x%x", cishort); + } + } + break; + case CI_MAGICNUMBER: + if (olen == CILEN_LONG) { + p += 2; + GETLONG(cilong, p); + printer(arg, "magic 0x%x", cilong); + } + break; + case CI_PCOMPRESSION: + if (olen == CILEN_VOID) { + p += 2; + printer(arg, "pcomp"); + } + break; + case CI_ACCOMPRESSION: + if (olen == CILEN_VOID) { + p += 2; + printer(arg, "accomp"); + } + break; + case CI_MRRU: + if (olen == CILEN_SHORT) { + p += 2; + GETSHORT(cishort, p); + printer(arg, "mrru %d", cishort); + } + break; + case CI_SSNHF: + if (olen == CILEN_VOID) { + p += 2; + printer(arg, "ssnhf"); + } + break; + case CI_EPDISC: +#ifdef HAVE_MULTILINK + if (olen >= CILEN_CHAR) { + struct epdisc epd; + p += 2; + GETCHAR(epd.class, p); + epd.length = olen - CILEN_CHAR; + if (epd.length > MAX_ENDP_LEN) + epd.length = MAX_ENDP_LEN; + if (epd.length > 0) { + MEMCPY(epd.value, p, epd.length); + p += epd.length; + } + printer(arg, "endpoint [%s]", epdisc_to_str(&epd)); + } +#else + printer(arg, "endpoint"); +#endif + break; + default: + break; + } + while (p < optend) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + printer(arg, ">"); + } + break; + + case TERMACK: + case TERMREQ: + if (len > 0 && *p >= ' ' && *p < 0x7f) { + printer(arg, " "); + ppp_print_string(p, len, printer, arg); + p += len; + len = 0; + } + break; + + case ECHOREQ: + case ECHOREP: + case DISCREQ: + if (len >= 4) { + GETLONG(cilong, p); + printer(arg, " magic=0x%x", cilong); + len -= 4; + } + break; + + case IDENTIF: + case TIMEREM: + if (len >= 4) { + GETLONG(cilong, p); + printer(arg, " magic=0x%x", cilong); + len -= 4; + } + if (code == TIMEREM) { + if (len < 4) + break; + GETLONG(cilong, p); + printer(arg, " seconds=%u", cilong); + len -= 4; + } + if (len > 0) { + printer(arg, " "); + ppp_print_string(p, len, printer, arg); + p += len; + len = 0; + } + break; + default: + break; + } + + /* print the rest of the bytes in the packet */ + for (i = 0; i < len && i < 32; ++i) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + if (i < len) { + printer(arg, " ..."); + p += len - i; + } + + return p - pstart; +} +#endif /* PRINTPKT_SUPPORT */ + +/* + * Time to shut down the link because there is nothing out there. + */ + +static void LcpLinkFailure(fsm *f) { + ppp_pcb *pcb = f->pcb; + if (f->state == PPP_FSM_OPENED) { + ppp_info("No response to %d echo-requests", pcb->lcp_echos_pending); + ppp_notice("Serial link appears to be disconnected."); + pcb->err_code = PPPERR_PEERDEAD; + lcp_close(pcb, "Peer not responding"); + } +} + +/* + * Timer expired for the LCP echo requests from this process. + */ + +static void LcpEchoCheck(fsm *f) { + ppp_pcb *pcb = f->pcb; + + LcpSendEchoRequest (f); + if (f->state != PPP_FSM_OPENED) + return; + + /* + * Start the timer for the next interval. + */ + if (pcb->lcp_echo_timer_running) + ppp_warn("assertion lcp_echo_timer_running==0 failed"); + TIMEOUT (LcpEchoTimeout, f, pcb->settings.lcp_echo_interval); + pcb->lcp_echo_timer_running = 1; +} + +/* + * LcpEchoTimeout - Timer expired on the LCP echo + */ + +static void LcpEchoTimeout(void *arg) { + fsm *f = (fsm*)arg; + ppp_pcb *pcb = f->pcb; + if (pcb->lcp_echo_timer_running != 0) { + pcb->lcp_echo_timer_running = 0; + LcpEchoCheck ((fsm *) arg); + } +} + +/* + * LcpEchoReply - LCP has received a reply to the echo + */ + +static void lcp_received_echo_reply(fsm *f, int id, u_char *inp, int len) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + u32_t magic_val; + LWIP_UNUSED_ARG(id); + + /* Check the magic number - don't count replies from ourselves. */ + if (len < 4) { + ppp_dbglog("lcp: received short Echo-Reply, length %d", len); + return; + } + GETLONG(magic_val, inp); + if (go->neg_magicnumber + && magic_val == go->magicnumber) { + ppp_warn("appear to have received our own echo-reply!"); + return; + } + + /* Reset the number of outstanding echo frames */ + pcb->lcp_echos_pending = 0; +} + +/* + * LcpSendEchoRequest - Send an echo request frame to the peer + */ + +static void LcpSendEchoRequest(fsm *f) { + ppp_pcb *pcb = f->pcb; + lcp_options *go = &pcb->lcp_gotoptions; + u32_t lcp_magic; + u_char pkt[4], *pktp; + + /* + * Detect the failure of the peer at this point. + */ + if (pcb->settings.lcp_echo_fails != 0) { + if (pcb->lcp_echos_pending >= pcb->settings.lcp_echo_fails) { + LcpLinkFailure(f); + pcb->lcp_echos_pending = 0; + } + } + +#if PPP_LCP_ADAPTIVE + /* + * If adaptive echos have been enabled, only send the echo request if + * no traffic was received since the last one. + */ + if (pcb->settings.lcp_echo_adaptive) { + static unsigned int last_pkts_in = 0; + +#if PPP_STATS_SUPPORT + update_link_stats(f->unit); + link_stats_valid = 0; +#endif /* PPP_STATS_SUPPORT */ + + if (link_stats.pkts_in != last_pkts_in) { + last_pkts_in = link_stats.pkts_in; + return; + } + } +#endif + + /* + * Make and send the echo request frame. + */ + if (f->state == PPP_FSM_OPENED) { + lcp_magic = go->magicnumber; + pktp = pkt; + PUTLONG(lcp_magic, pktp); + fsm_sdata(f, ECHOREQ, pcb->lcp_echo_number++, pkt, pktp - pkt); + ++pcb->lcp_echos_pending; + } +} + +/* + * lcp_echo_lowerup - Start the timer for the LCP frame + */ + +static void lcp_echo_lowerup(ppp_pcb *pcb) { + fsm *f = &pcb->lcp_fsm; + + /* Clear the parameters for generating echo frames */ + pcb->lcp_echos_pending = 0; + pcb->lcp_echo_number = 0; + pcb->lcp_echo_timer_running = 0; + + /* If a timeout interval is specified then start the timer */ + if (pcb->settings.lcp_echo_interval != 0) + LcpEchoCheck (f); +} + +/* + * lcp_echo_lowerdown - Stop the timer for the LCP frame + */ + +static void lcp_echo_lowerdown(ppp_pcb *pcb) { + fsm *f = &pcb->lcp_fsm; + + if (pcb->lcp_echo_timer_running != 0) { + UNTIMEOUT (LcpEchoTimeout, f); + pcb->lcp_echo_timer_running = 0; + } +} + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/magic.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/magic.c index 32cfa260..d0d87c5e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/magic.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/magic.c @@ -1,294 +1,294 @@ -/* - * magic.c - PPP Magic Number routines. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ -/***************************************************************************** -* randm.c - Random number generator program file. -* -* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. -* Copyright (c) 1998 by Global Election Systems Inc. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY -* -* 03-01-01 Marc Boucher -* Ported to lwIP. -* 98-06-03 Guy Lancaster , Global Election Systems Inc. -* Extracted from avos. -*****************************************************************************/ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/magic.h" - -#if PPP_MD5_RANDM /* Using MD5 for better randomness if enabled */ - -#include "netif/ppp/pppcrypt.h" - -#define MD5_HASH_SIZE 16 -static char magic_randpool[MD5_HASH_SIZE]; /* Pool of randomness. */ -static long magic_randcount; /* Pseudo-random incrementer */ -static u32_t magic_randomseed; /* Seed used for random number generation. */ - -/* - * Churn the randomness pool on a random event. Call this early and often - * on random and semi-random system events to build randomness in time for - * usage. For randomly timed events, pass a null pointer and a zero length - * and this will use the system timer and other sources to add randomness. - * If new random data is available, pass a pointer to that and it will be - * included. - * - * Ref: Applied Cryptography 2nd Ed. by Bruce Schneier p. 427 - */ -static void magic_churnrand(char *rand_data, u32_t rand_len) { - lwip_md5_context md5_ctx; - - /* LWIP_DEBUGF(LOG_INFO, ("magic_churnrand: %u@%P\n", rand_len, rand_data)); */ - lwip_md5_init(&md5_ctx); - lwip_md5_starts(&md5_ctx); - lwip_md5_update(&md5_ctx, (u_char *)magic_randpool, sizeof(magic_randpool)); - if (rand_data) { - lwip_md5_update(&md5_ctx, (u_char *)rand_data, rand_len); - } else { - struct { - /* INCLUDE fields for any system sources of randomness */ - u32_t jiffies; -#ifdef LWIP_RAND - u32_t rand; -#endif /* LWIP_RAND */ - } sys_data; - magic_randomseed += sys_jiffies(); - sys_data.jiffies = magic_randomseed; -#ifdef LWIP_RAND - sys_data.rand = LWIP_RAND(); -#endif /* LWIP_RAND */ - /* Load sys_data fields here. */ - lwip_md5_update(&md5_ctx, (u_char *)&sys_data, sizeof(sys_data)); - } - lwip_md5_finish(&md5_ctx, (u_char *)magic_randpool); - lwip_md5_free(&md5_ctx); -/* LWIP_DEBUGF(LOG_INFO, ("magic_churnrand: -> 0\n")); */ -} - -/* - * Initialize the random number generator. - */ -void magic_init(void) { - magic_churnrand(NULL, 0); -} - -/* - * Randomize our random seed value. - */ -void magic_randomize(void) { - magic_churnrand(NULL, 0); -} - -/* - * magic_random_bytes - Fill a buffer with random bytes. - * - * Use the random pool to generate random data. This degrades to pseudo - * random when used faster than randomness is supplied using magic_churnrand(). - * Note: It's important that there be sufficient randomness in magic_randpool - * before this is called for otherwise the range of the result may be - * narrow enough to make a search feasible. - * - * Ref: Applied Cryptography 2nd Ed. by Bruce Schneier p. 427 - * - * XXX Why does he not just call magic_churnrand() for each block? Probably - * so that you don't ever publish the seed which could possibly help - * predict future values. - * XXX Why don't we preserve md5 between blocks and just update it with - * magic_randcount each time? Probably there is a weakness but I wish that - * it was documented. - */ -void magic_random_bytes(unsigned char *buf, u32_t buf_len) { - lwip_md5_context md5_ctx; - u_char tmp[MD5_HASH_SIZE]; - u32_t n; - - while (buf_len > 0) { - lwip_md5_init(&md5_ctx); - lwip_md5_starts(&md5_ctx); - lwip_md5_update(&md5_ctx, (u_char *)magic_randpool, sizeof(magic_randpool)); - lwip_md5_update(&md5_ctx, (u_char *)&magic_randcount, sizeof(magic_randcount)); - lwip_md5_finish(&md5_ctx, tmp); - lwip_md5_free(&md5_ctx); - magic_randcount++; - n = LWIP_MIN(buf_len, MD5_HASH_SIZE); - MEMCPY(buf, tmp, n); - buf += n; - buf_len -= n; - } -} - -/* - * Return a new random number. - */ -u32_t magic(void) { - u32_t new_rand; - - magic_random_bytes((unsigned char *)&new_rand, sizeof(new_rand)); - - return new_rand; -} - -#else /* PPP_MD5_RANDM */ - -/*****************************/ -/*** LOCAL DATA STRUCTURES ***/ -/*****************************/ -#ifndef LWIP_RAND -static int magic_randomized; /* Set when truely randomized. */ -#endif /* LWIP_RAND */ -static u32_t magic_randomseed; /* Seed used for random number generation. */ - - -/***********************************/ -/*** PUBLIC FUNCTION DEFINITIONS ***/ -/***********************************/ - -/* - * Initialize the random number generator. - * - * Here we attempt to compute a random number seed but even if - * it isn't random, we'll randomize it later. - * - * The current method uses the fields from the real time clock, - * the idle process counter, the millisecond counter, and the - * hardware timer tick counter. When this is invoked - * in startup(), then the idle counter and timer values may - * repeat after each boot and the real time clock may not be - * operational. Thus we call it again on the first random - * event. - */ -void magic_init(void) { - magic_randomseed += sys_jiffies(); -#ifndef LWIP_RAND - /* Initialize the Borland random number generator. */ - srand((unsigned)magic_randomseed); -#endif /* LWIP_RAND */ -} - -/* - * magic_init - Initialize the magic number generator. - * - * Randomize our random seed value. Here we use the fact that - * this function is called at *truely random* times by the polling - * and network functions. Here we only get 16 bits of new random - * value but we use the previous value to randomize the other 16 - * bits. - */ -void magic_randomize(void) { -#ifndef LWIP_RAND - if (!magic_randomized) { - magic_randomized = !0; - magic_init(); - /* The initialization function also updates the seed. */ - } else { -#endif /* LWIP_RAND */ - magic_randomseed += sys_jiffies(); -#ifndef LWIP_RAND - } -#endif /* LWIP_RAND */ -} - -/* - * Return a new random number. - * - * Here we use the Borland rand() function to supply a pseudo random - * number which we make truely random by combining it with our own - * seed which is randomized by truely random events. - * Thus the numbers will be truely random unless there have been no - * operator or network events in which case it will be pseudo random - * seeded by the real time clock. - */ -u32_t magic(void) { -#ifdef LWIP_RAND - return LWIP_RAND() + magic_randomseed; -#else /* LWIP_RAND */ - return ((u32_t)rand() << 16) + (u32_t)rand() + magic_randomseed; -#endif /* LWIP_RAND */ -} - -/* - * magic_random_bytes - Fill a buffer with random bytes. - */ -void magic_random_bytes(unsigned char *buf, u32_t buf_len) { - u32_t new_rand, n; - - while (buf_len > 0) { - new_rand = magic(); - n = LWIP_MIN(buf_len, sizeof(new_rand)); - MEMCPY(buf, &new_rand, n); - buf += n; - buf_len -= n; - } -} -#endif /* PPP_MD5_RANDM */ - -/* - * Return a new random number between 0 and (2^pow)-1 included. - */ -u32_t magic_pow(u8_t pow) { - return magic() & ~(~0UL< +* Ported to lwIP. +* 98-06-03 Guy Lancaster , Global Election Systems Inc. +* Extracted from avos. +*****************************************************************************/ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/magic.h" + +#if PPP_MD5_RANDM /* Using MD5 for better randomness if enabled */ + +#include "netif/ppp/pppcrypt.h" + +#define MD5_HASH_SIZE 16 +static char magic_randpool[MD5_HASH_SIZE]; /* Pool of randomness. */ +static long magic_randcount; /* Pseudo-random incrementer */ +static u32_t magic_randomseed; /* Seed used for random number generation. */ + +/* + * Churn the randomness pool on a random event. Call this early and often + * on random and semi-random system events to build randomness in time for + * usage. For randomly timed events, pass a null pointer and a zero length + * and this will use the system timer and other sources to add randomness. + * If new random data is available, pass a pointer to that and it will be + * included. + * + * Ref: Applied Cryptography 2nd Ed. by Bruce Schneier p. 427 + */ +static void magic_churnrand(char *rand_data, u32_t rand_len) { + lwip_md5_context md5_ctx; + + /* LWIP_DEBUGF(LOG_INFO, ("magic_churnrand: %u@%P\n", rand_len, rand_data)); */ + lwip_md5_init(&md5_ctx); + lwip_md5_starts(&md5_ctx); + lwip_md5_update(&md5_ctx, (u_char *)magic_randpool, sizeof(magic_randpool)); + if (rand_data) { + lwip_md5_update(&md5_ctx, (u_char *)rand_data, rand_len); + } else { + struct { + /* INCLUDE fields for any system sources of randomness */ + u32_t jiffies; +#ifdef LWIP_RAND + u32_t rand; +#endif /* LWIP_RAND */ + } sys_data; + magic_randomseed += sys_jiffies(); + sys_data.jiffies = magic_randomseed; +#ifdef LWIP_RAND + sys_data.rand = LWIP_RAND(); +#endif /* LWIP_RAND */ + /* Load sys_data fields here. */ + lwip_md5_update(&md5_ctx, (u_char *)&sys_data, sizeof(sys_data)); + } + lwip_md5_finish(&md5_ctx, (u_char *)magic_randpool); + lwip_md5_free(&md5_ctx); +/* LWIP_DEBUGF(LOG_INFO, ("magic_churnrand: -> 0\n")); */ +} + +/* + * Initialize the random number generator. + */ +void magic_init(void) { + magic_churnrand(NULL, 0); +} + +/* + * Randomize our random seed value. + */ +void magic_randomize(void) { + magic_churnrand(NULL, 0); +} + +/* + * magic_random_bytes - Fill a buffer with random bytes. + * + * Use the random pool to generate random data. This degrades to pseudo + * random when used faster than randomness is supplied using magic_churnrand(). + * Note: It's important that there be sufficient randomness in magic_randpool + * before this is called for otherwise the range of the result may be + * narrow enough to make a search feasible. + * + * Ref: Applied Cryptography 2nd Ed. by Bruce Schneier p. 427 + * + * XXX Why does he not just call magic_churnrand() for each block? Probably + * so that you don't ever publish the seed which could possibly help + * predict future values. + * XXX Why don't we preserve md5 between blocks and just update it with + * magic_randcount each time? Probably there is a weakness but I wish that + * it was documented. + */ +void magic_random_bytes(unsigned char *buf, u32_t buf_len) { + lwip_md5_context md5_ctx; + u_char tmp[MD5_HASH_SIZE]; + u32_t n; + + while (buf_len > 0) { + lwip_md5_init(&md5_ctx); + lwip_md5_starts(&md5_ctx); + lwip_md5_update(&md5_ctx, (u_char *)magic_randpool, sizeof(magic_randpool)); + lwip_md5_update(&md5_ctx, (u_char *)&magic_randcount, sizeof(magic_randcount)); + lwip_md5_finish(&md5_ctx, tmp); + lwip_md5_free(&md5_ctx); + magic_randcount++; + n = LWIP_MIN(buf_len, MD5_HASH_SIZE); + MEMCPY(buf, tmp, n); + buf += n; + buf_len -= n; + } +} + +/* + * Return a new random number. + */ +u32_t magic(void) { + u32_t new_rand; + + magic_random_bytes((unsigned char *)&new_rand, sizeof(new_rand)); + + return new_rand; +} + +#else /* PPP_MD5_RANDM */ + +/*****************************/ +/*** LOCAL DATA STRUCTURES ***/ +/*****************************/ +#ifndef LWIP_RAND +static int magic_randomized; /* Set when truely randomized. */ +#endif /* LWIP_RAND */ +static u32_t magic_randomseed; /* Seed used for random number generation. */ + + +/***********************************/ +/*** PUBLIC FUNCTION DEFINITIONS ***/ +/***********************************/ + +/* + * Initialize the random number generator. + * + * Here we attempt to compute a random number seed but even if + * it isn't random, we'll randomize it later. + * + * The current method uses the fields from the real time clock, + * the idle process counter, the millisecond counter, and the + * hardware timer tick counter. When this is invoked + * in startup(), then the idle counter and timer values may + * repeat after each boot and the real time clock may not be + * operational. Thus we call it again on the first random + * event. + */ +void magic_init(void) { + magic_randomseed += sys_jiffies(); +#ifndef LWIP_RAND + /* Initialize the Borland random number generator. */ + srand((unsigned)magic_randomseed); +#endif /* LWIP_RAND */ +} + +/* + * magic_init - Initialize the magic number generator. + * + * Randomize our random seed value. Here we use the fact that + * this function is called at *truely random* times by the polling + * and network functions. Here we only get 16 bits of new random + * value but we use the previous value to randomize the other 16 + * bits. + */ +void magic_randomize(void) { +#ifndef LWIP_RAND + if (!magic_randomized) { + magic_randomized = !0; + magic_init(); + /* The initialization function also updates the seed. */ + } else { +#endif /* LWIP_RAND */ + magic_randomseed += sys_jiffies(); +#ifndef LWIP_RAND + } +#endif /* LWIP_RAND */ +} + +/* + * Return a new random number. + * + * Here we use the Borland rand() function to supply a pseudo random + * number which we make truely random by combining it with our own + * seed which is randomized by truely random events. + * Thus the numbers will be truely random unless there have been no + * operator or network events in which case it will be pseudo random + * seeded by the real time clock. + */ +u32_t magic(void) { +#ifdef LWIP_RAND + return LWIP_RAND() + magic_randomseed; +#else /* LWIP_RAND */ + return ((u32_t)rand() << 16) + (u32_t)rand() + magic_randomseed; +#endif /* LWIP_RAND */ +} + +/* + * magic_random_bytes - Fill a buffer with random bytes. + */ +void magic_random_bytes(unsigned char *buf, u32_t buf_len) { + u32_t new_rand, n; + + while (buf_len > 0) { + new_rand = magic(); + n = LWIP_MIN(buf_len, sizeof(new_rand)); + MEMCPY(buf, &new_rand, n); + buf += n; + buf_len -= n; + } +} +#endif /* PPP_MD5_RANDM */ + +/* + * Return a new random number between 0 and (2^pow)-1 included. + */ +u32_t magic_pow(u8_t pow) { + return magic() & ~(~0UL<. - * Copyright (c) 2002,2003,2004 Google, Inc. - * All rights reserved. - * - * License: - * Permission to use, copy, modify, and distribute this software and its - * documentation is hereby granted, provided that the above copyright - * notice appears in all copies. This software is provided without any - * warranty, express or implied. - * - * Changelog: - * 08/12/05 - Matt Domsch - * Only need extra skb padding on transmit, not receive. - * 06/18/04 - Matt Domsch , Oleg Makarenko - * Use Linux kernel 2.6 arc4 and sha1 routines rather than - * providing our own. - * 2/15/04 - TS: added #include and testing for Kernel - * version before using - * MOD_DEC_USAGE_COUNT/MOD_INC_USAGE_COUNT which are - * deprecated in 2.6 - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && MPPE_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include - -#include "lwip/err.h" - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/ccp.h" -#include "netif/ppp/mppe.h" -#include "netif/ppp/pppdebug.h" -#include "netif/ppp/pppcrypt.h" - -#define SHA1_SIGNATURE_SIZE 20 - -/* ppp_mppe_state.bits definitions */ -#define MPPE_BIT_A 0x80 /* Encryption table were (re)inititalized */ -#define MPPE_BIT_B 0x40 /* MPPC only (not implemented) */ -#define MPPE_BIT_C 0x20 /* MPPC only (not implemented) */ -#define MPPE_BIT_D 0x10 /* This is an encrypted frame */ - -#define MPPE_BIT_FLUSHED MPPE_BIT_A -#define MPPE_BIT_ENCRYPTED MPPE_BIT_D - -#define MPPE_BITS(p) ((p)[0] & 0xf0) -#define MPPE_CCOUNT(p) ((((p)[0] & 0x0f) << 8) + (p)[1]) -#define MPPE_CCOUNT_SPACE 0x1000 /* The size of the ccount space */ - -#define MPPE_OVHD 2 /* MPPE overhead/packet */ -#define SANITY_MAX 1600 /* Max bogon factor we will tolerate */ - -/* - * Perform the MPPE rekey algorithm, from RFC 3078, sec. 7.3. - * Well, not what's written there, but rather what they meant. - */ -static void mppe_rekey(ppp_mppe_state * state, int initial_key) -{ - lwip_sha1_context sha1_ctx; - u8_t sha1_digest[SHA1_SIGNATURE_SIZE]; - - /* - * Key Derivation, from RFC 3078, RFC 3079. - * Equivalent to Get_Key() for MS-CHAP as described in RFC 3079. - */ - lwip_sha1_init(&sha1_ctx); - lwip_sha1_starts(&sha1_ctx); - lwip_sha1_update(&sha1_ctx, state->master_key, state->keylen); - lwip_sha1_update(&sha1_ctx, mppe_sha1_pad1, SHA1_PAD_SIZE); - lwip_sha1_update(&sha1_ctx, state->session_key, state->keylen); - lwip_sha1_update(&sha1_ctx, mppe_sha1_pad2, SHA1_PAD_SIZE); - lwip_sha1_finish(&sha1_ctx, sha1_digest); - lwip_sha1_free(&sha1_ctx); - MEMCPY(state->session_key, sha1_digest, state->keylen); - - if (!initial_key) { - lwip_arc4_init(&state->arc4); - lwip_arc4_setup(&state->arc4, sha1_digest, state->keylen); - lwip_arc4_crypt(&state->arc4, state->session_key, state->keylen); - lwip_arc4_free(&state->arc4); - } - if (state->keylen == 8) { - /* See RFC 3078 */ - state->session_key[0] = 0xd1; - state->session_key[1] = 0x26; - state->session_key[2] = 0x9e; - } - lwip_arc4_init(&state->arc4); - lwip_arc4_setup(&state->arc4, state->session_key, state->keylen); -} - -/* - * Set key, used by MSCHAP before mppe_init() is actually called by CCP so we - * don't have to keep multiple copies of keys. - */ -void mppe_set_key(ppp_pcb *pcb, ppp_mppe_state *state, u8_t *key) { - LWIP_UNUSED_ARG(pcb); - MEMCPY(state->master_key, key, MPPE_MAX_KEY_LEN); -} - -/* - * Initialize (de)compressor state. - */ -void -mppe_init(ppp_pcb *pcb, ppp_mppe_state *state, u8_t options) -{ -#if PPP_DEBUG - const u8_t *debugstr = (const u8_t*)"mppe_comp_init"; - if (&pcb->mppe_decomp == state) { - debugstr = (const u8_t*)"mppe_decomp_init"; - } -#endif /* PPP_DEBUG */ - - /* Save keys. */ - MEMCPY(state->session_key, state->master_key, sizeof(state->master_key)); - - if (options & MPPE_OPT_128) - state->keylen = 16; - else if (options & MPPE_OPT_40) - state->keylen = 8; - else { - PPPDEBUG(LOG_DEBUG, ("%s[%d]: unknown key length\n", debugstr, - pcb->netif->num)); - lcp_close(pcb, "MPPE required but peer negotiation failed"); - return; - } - if (options & MPPE_OPT_STATEFUL) - state->stateful = 1; - - /* Generate the initial session key. */ - mppe_rekey(state, 1); - -#if PPP_DEBUG - { - int i; - char mkey[sizeof(state->master_key) * 2 + 1]; - char skey[sizeof(state->session_key) * 2 + 1]; - - PPPDEBUG(LOG_DEBUG, ("%s[%d]: initialized with %d-bit %s mode\n", - debugstr, pcb->netif->num, (state->keylen == 16) ? 128 : 40, - (state->stateful) ? "stateful" : "stateless")); - - for (i = 0; i < (int)sizeof(state->master_key); i++) - sprintf(mkey + i * 2, "%02x", state->master_key[i]); - for (i = 0; i < (int)sizeof(state->session_key); i++) - sprintf(skey + i * 2, "%02x", state->session_key[i]); - PPPDEBUG(LOG_DEBUG, - ("%s[%d]: keys: master: %s initial session: %s\n", - debugstr, pcb->netif->num, mkey, skey)); - } -#endif /* PPP_DEBUG */ - - /* - * Initialize the coherency count. The initial value is not specified - * in RFC 3078, but we can make a reasonable assumption that it will - * start at 0. Setting it to the max here makes the comp/decomp code - * do the right thing (determined through experiment). - */ - state->ccount = MPPE_CCOUNT_SPACE - 1; - - /* - * Note that even though we have initialized the key table, we don't - * set the FLUSHED bit. This is contrary to RFC 3078, sec. 3.1. - */ - state->bits = MPPE_BIT_ENCRYPTED; -} - -/* - * We received a CCP Reset-Request (actually, we are sending a Reset-Ack), - * tell the compressor to rekey. Note that we MUST NOT rekey for - * every CCP Reset-Request; we only rekey on the next xmit packet. - * We might get multiple CCP Reset-Requests if our CCP Reset-Ack is lost. - * So, rekeying for every CCP Reset-Request is broken as the peer will not - * know how many times we've rekeyed. (If we rekey and THEN get another - * CCP Reset-Request, we must rekey again.) - */ -void mppe_comp_reset(ppp_pcb *pcb, ppp_mppe_state *state) -{ - LWIP_UNUSED_ARG(pcb); - state->bits |= MPPE_BIT_FLUSHED; -} - -/* - * Compress (encrypt) a packet. - * It's strange to call this a compressor, since the output is always - * MPPE_OVHD + 2 bytes larger than the input. - */ -err_t -mppe_compress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb, u16_t protocol) -{ - struct pbuf *n, *np; - u8_t *pl; - err_t err; - - LWIP_UNUSED_ARG(pcb); - - /* TCP stack requires that we don't change the packet payload, therefore we copy - * the whole packet before encryption. - */ - np = pbuf_alloc(PBUF_RAW, MPPE_OVHD + sizeof(protocol) + (*pb)->tot_len, PBUF_RAM); - if (!np) { - return ERR_MEM; - } - - /* Hide MPPE header + protocol */ - pbuf_remove_header(np, MPPE_OVHD + sizeof(protocol)); - - if ((err = pbuf_copy(np, *pb)) != ERR_OK) { - pbuf_free(np); - return err; - } - - /* Reveal MPPE header + protocol */ - pbuf_add_header(np, MPPE_OVHD + sizeof(protocol)); - - *pb = np; - pl = (u8_t*)np->payload; - - state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE; - PPPDEBUG(LOG_DEBUG, ("mppe_compress[%d]: ccount %d\n", pcb->netif->num, state->ccount)); - /* FIXME: use PUT* macros */ - pl[0] = state->ccount>>8; - pl[1] = state->ccount; - - if (!state->stateful || /* stateless mode */ - ((state->ccount & 0xff) == 0xff) || /* "flag" packet */ - (state->bits & MPPE_BIT_FLUSHED)) { /* CCP Reset-Request */ - /* We must rekey */ - if (state->stateful) { - PPPDEBUG(LOG_DEBUG, ("mppe_compress[%d]: rekeying\n", pcb->netif->num)); - } - mppe_rekey(state, 0); - state->bits |= MPPE_BIT_FLUSHED; - } - pl[0] |= state->bits; - state->bits &= ~MPPE_BIT_FLUSHED; /* reset for next xmit */ - pl += MPPE_OVHD; - - /* Add protocol */ - /* FIXME: add PFC support */ - pl[0] = protocol >> 8; - pl[1] = protocol; - - /* Hide MPPE header */ - pbuf_remove_header(np, MPPE_OVHD); - - /* Encrypt packet */ - for (n = np; n != NULL; n = n->next) { - lwip_arc4_crypt(&state->arc4, (u8_t*)n->payload, n->len); - if (n->tot_len == n->len) { - break; - } - } - - /* Reveal MPPE header */ - pbuf_add_header(np, MPPE_OVHD); - - return ERR_OK; -} - -/* - * We received a CCP Reset-Ack. Just ignore it. - */ -void mppe_decomp_reset(ppp_pcb *pcb, ppp_mppe_state *state) -{ - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(state); - return; -} - -/* - * Decompress (decrypt) an MPPE packet. - */ -err_t -mppe_decompress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb) -{ - struct pbuf *n0 = *pb, *n; - u8_t *pl; - u16_t ccount; - u8_t flushed; - - /* MPPE Header */ - if (n0->len < MPPE_OVHD) { - PPPDEBUG(LOG_DEBUG, - ("mppe_decompress[%d]: short pkt (%d)\n", - pcb->netif->num, n0->len)); - state->sanity_errors += 100; - goto sanity_error; - } - - pl = (u8_t*)n0->payload; - flushed = MPPE_BITS(pl) & MPPE_BIT_FLUSHED; - ccount = MPPE_CCOUNT(pl); - PPPDEBUG(LOG_DEBUG, ("mppe_decompress[%d]: ccount %d\n", - pcb->netif->num, ccount)); - - /* sanity checks -- terminate with extreme prejudice */ - if (!(MPPE_BITS(pl) & MPPE_BIT_ENCRYPTED)) { - PPPDEBUG(LOG_DEBUG, - ("mppe_decompress[%d]: ENCRYPTED bit not set!\n", - pcb->netif->num)); - state->sanity_errors += 100; - goto sanity_error; - } - if (!state->stateful && !flushed) { - PPPDEBUG(LOG_DEBUG, ("mppe_decompress[%d]: FLUSHED bit not set in " - "stateless mode!\n", pcb->netif->num)); - state->sanity_errors += 100; - goto sanity_error; - } - if (state->stateful && ((ccount & 0xff) == 0xff) && !flushed) { - PPPDEBUG(LOG_DEBUG, ("mppe_decompress[%d]: FLUSHED bit not set on " - "flag packet!\n", pcb->netif->num)); - state->sanity_errors += 100; - goto sanity_error; - } - - /* - * Check the coherency count. - */ - - if (!state->stateful) { - /* Discard late packet */ - if ((ccount - state->ccount) % MPPE_CCOUNT_SPACE > MPPE_CCOUNT_SPACE / 2) { - state->sanity_errors++; - goto sanity_error; - } - - /* RFC 3078, sec 8.1. Rekey for every packet. */ - while (state->ccount != ccount) { - mppe_rekey(state, 0); - state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE; - } - } else { - /* RFC 3078, sec 8.2. */ - if (!state->discard) { - /* normal state */ - state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE; - if (ccount != state->ccount) { - /* - * (ccount > state->ccount) - * Packet loss detected, enter the discard state. - * Signal the peer to rekey (by sending a CCP Reset-Request). - */ - state->discard = 1; - ccp_resetrequest(pcb); - return ERR_BUF; - } - } else { - /* discard state */ - if (!flushed) { - /* ccp.c will be silent (no additional CCP Reset-Requests). */ - return ERR_BUF; - } else { - /* Rekey for every missed "flag" packet. */ - while ((ccount & ~0xff) != - (state->ccount & ~0xff)) { - mppe_rekey(state, 0); - state->ccount = - (state->ccount + - 256) % MPPE_CCOUNT_SPACE; - } - - /* reset */ - state->discard = 0; - state->ccount = ccount; - /* - * Another problem with RFC 3078 here. It implies that the - * peer need not send a Reset-Ack packet. But RFC 1962 - * requires it. Hopefully, M$ does send a Reset-Ack; even - * though it isn't required for MPPE synchronization, it is - * required to reset CCP state. - */ - } - } - if (flushed) - mppe_rekey(state, 0); - } - - /* Hide MPPE header */ - pbuf_remove_header(n0, MPPE_OVHD); - - /* Decrypt the packet. */ - for (n = n0; n != NULL; n = n->next) { - lwip_arc4_crypt(&state->arc4, (u8_t*)n->payload, n->len); - if (n->tot_len == n->len) { - break; - } - } - - /* good packet credit */ - state->sanity_errors >>= 1; - - return ERR_OK; - -sanity_error: - if (state->sanity_errors >= SANITY_MAX) { - /* - * Take LCP down if the peer is sending too many bogons. - * We don't want to do this for a single or just a few - * instances since it could just be due to packet corruption. - */ - lcp_close(pcb, "Too many MPPE errors"); - } - return ERR_BUF; -} - -#endif /* PPP_SUPPORT && MPPE_SUPPORT */ +/* + * mppe.c - interface MPPE to the PPP code. + * + * By Frank Cusack . + * Copyright (c) 2002,2003,2004 Google, Inc. + * All rights reserved. + * + * License: + * Permission to use, copy, modify, and distribute this software and its + * documentation is hereby granted, provided that the above copyright + * notice appears in all copies. This software is provided without any + * warranty, express or implied. + * + * Changelog: + * 08/12/05 - Matt Domsch + * Only need extra skb padding on transmit, not receive. + * 06/18/04 - Matt Domsch , Oleg Makarenko + * Use Linux kernel 2.6 arc4 and sha1 routines rather than + * providing our own. + * 2/15/04 - TS: added #include and testing for Kernel + * version before using + * MOD_DEC_USAGE_COUNT/MOD_INC_USAGE_COUNT which are + * deprecated in 2.6 + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && MPPE_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include + +#include "lwip/err.h" + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/ccp.h" +#include "netif/ppp/mppe.h" +#include "netif/ppp/pppdebug.h" +#include "netif/ppp/pppcrypt.h" + +#define SHA1_SIGNATURE_SIZE 20 + +/* ppp_mppe_state.bits definitions */ +#define MPPE_BIT_A 0x80 /* Encryption table were (re)inititalized */ +#define MPPE_BIT_B 0x40 /* MPPC only (not implemented) */ +#define MPPE_BIT_C 0x20 /* MPPC only (not implemented) */ +#define MPPE_BIT_D 0x10 /* This is an encrypted frame */ + +#define MPPE_BIT_FLUSHED MPPE_BIT_A +#define MPPE_BIT_ENCRYPTED MPPE_BIT_D + +#define MPPE_BITS(p) ((p)[0] & 0xf0) +#define MPPE_CCOUNT(p) ((((p)[0] & 0x0f) << 8) + (p)[1]) +#define MPPE_CCOUNT_SPACE 0x1000 /* The size of the ccount space */ + +#define MPPE_OVHD 2 /* MPPE overhead/packet */ +#define SANITY_MAX 1600 /* Max bogon factor we will tolerate */ + +/* + * Perform the MPPE rekey algorithm, from RFC 3078, sec. 7.3. + * Well, not what's written there, but rather what they meant. + */ +static void mppe_rekey(ppp_mppe_state * state, int initial_key) +{ + lwip_sha1_context sha1_ctx; + u8_t sha1_digest[SHA1_SIGNATURE_SIZE]; + + /* + * Key Derivation, from RFC 3078, RFC 3079. + * Equivalent to Get_Key() for MS-CHAP as described in RFC 3079. + */ + lwip_sha1_init(&sha1_ctx); + lwip_sha1_starts(&sha1_ctx); + lwip_sha1_update(&sha1_ctx, state->master_key, state->keylen); + lwip_sha1_update(&sha1_ctx, mppe_sha1_pad1, SHA1_PAD_SIZE); + lwip_sha1_update(&sha1_ctx, state->session_key, state->keylen); + lwip_sha1_update(&sha1_ctx, mppe_sha1_pad2, SHA1_PAD_SIZE); + lwip_sha1_finish(&sha1_ctx, sha1_digest); + lwip_sha1_free(&sha1_ctx); + MEMCPY(state->session_key, sha1_digest, state->keylen); + + if (!initial_key) { + lwip_arc4_init(&state->arc4); + lwip_arc4_setup(&state->arc4, sha1_digest, state->keylen); + lwip_arc4_crypt(&state->arc4, state->session_key, state->keylen); + lwip_arc4_free(&state->arc4); + } + if (state->keylen == 8) { + /* See RFC 3078 */ + state->session_key[0] = 0xd1; + state->session_key[1] = 0x26; + state->session_key[2] = 0x9e; + } + lwip_arc4_init(&state->arc4); + lwip_arc4_setup(&state->arc4, state->session_key, state->keylen); +} + +/* + * Set key, used by MSCHAP before mppe_init() is actually called by CCP so we + * don't have to keep multiple copies of keys. + */ +void mppe_set_key(ppp_pcb *pcb, ppp_mppe_state *state, u8_t *key) { + LWIP_UNUSED_ARG(pcb); + MEMCPY(state->master_key, key, MPPE_MAX_KEY_LEN); +} + +/* + * Initialize (de)compressor state. + */ +void +mppe_init(ppp_pcb *pcb, ppp_mppe_state *state, u8_t options) +{ +#if PPP_DEBUG + const u8_t *debugstr = (const u8_t*)"mppe_comp_init"; + if (&pcb->mppe_decomp == state) { + debugstr = (const u8_t*)"mppe_decomp_init"; + } +#endif /* PPP_DEBUG */ + + /* Save keys. */ + MEMCPY(state->session_key, state->master_key, sizeof(state->master_key)); + + if (options & MPPE_OPT_128) + state->keylen = 16; + else if (options & MPPE_OPT_40) + state->keylen = 8; + else { + PPPDEBUG(LOG_DEBUG, ("%s[%d]: unknown key length\n", debugstr, + pcb->netif->num)); + lcp_close(pcb, "MPPE required but peer negotiation failed"); + return; + } + if (options & MPPE_OPT_STATEFUL) + state->stateful = 1; + + /* Generate the initial session key. */ + mppe_rekey(state, 1); + +#if PPP_DEBUG + { + int i; + char mkey[sizeof(state->master_key) * 2 + 1]; + char skey[sizeof(state->session_key) * 2 + 1]; + + PPPDEBUG(LOG_DEBUG, ("%s[%d]: initialized with %d-bit %s mode\n", + debugstr, pcb->netif->num, (state->keylen == 16) ? 128 : 40, + (state->stateful) ? "stateful" : "stateless")); + + for (i = 0; i < (int)sizeof(state->master_key); i++) + sprintf(mkey + i * 2, "%02x", state->master_key[i]); + for (i = 0; i < (int)sizeof(state->session_key); i++) + sprintf(skey + i * 2, "%02x", state->session_key[i]); + PPPDEBUG(LOG_DEBUG, + ("%s[%d]: keys: master: %s initial session: %s\n", + debugstr, pcb->netif->num, mkey, skey)); + } +#endif /* PPP_DEBUG */ + + /* + * Initialize the coherency count. The initial value is not specified + * in RFC 3078, but we can make a reasonable assumption that it will + * start at 0. Setting it to the max here makes the comp/decomp code + * do the right thing (determined through experiment). + */ + state->ccount = MPPE_CCOUNT_SPACE - 1; + + /* + * Note that even though we have initialized the key table, we don't + * set the FLUSHED bit. This is contrary to RFC 3078, sec. 3.1. + */ + state->bits = MPPE_BIT_ENCRYPTED; +} + +/* + * We received a CCP Reset-Request (actually, we are sending a Reset-Ack), + * tell the compressor to rekey. Note that we MUST NOT rekey for + * every CCP Reset-Request; we only rekey on the next xmit packet. + * We might get multiple CCP Reset-Requests if our CCP Reset-Ack is lost. + * So, rekeying for every CCP Reset-Request is broken as the peer will not + * know how many times we've rekeyed. (If we rekey and THEN get another + * CCP Reset-Request, we must rekey again.) + */ +void mppe_comp_reset(ppp_pcb *pcb, ppp_mppe_state *state) +{ + LWIP_UNUSED_ARG(pcb); + state->bits |= MPPE_BIT_FLUSHED; +} + +/* + * Compress (encrypt) a packet. + * It's strange to call this a compressor, since the output is always + * MPPE_OVHD + 2 bytes larger than the input. + */ +err_t +mppe_compress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb, u16_t protocol) +{ + struct pbuf *n, *np; + u8_t *pl; + err_t err; + + LWIP_UNUSED_ARG(pcb); + + /* TCP stack requires that we don't change the packet payload, therefore we copy + * the whole packet before encryption. + */ + np = pbuf_alloc(PBUF_RAW, MPPE_OVHD + sizeof(protocol) + (*pb)->tot_len, PBUF_RAM); + if (!np) { + return ERR_MEM; + } + + /* Hide MPPE header + protocol */ + pbuf_remove_header(np, MPPE_OVHD + sizeof(protocol)); + + if ((err = pbuf_copy(np, *pb)) != ERR_OK) { + pbuf_free(np); + return err; + } + + /* Reveal MPPE header + protocol */ + pbuf_add_header(np, MPPE_OVHD + sizeof(protocol)); + + *pb = np; + pl = (u8_t*)np->payload; + + state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE; + PPPDEBUG(LOG_DEBUG, ("mppe_compress[%d]: ccount %d\n", pcb->netif->num, state->ccount)); + /* FIXME: use PUT* macros */ + pl[0] = state->ccount>>8; + pl[1] = state->ccount; + + if (!state->stateful || /* stateless mode */ + ((state->ccount & 0xff) == 0xff) || /* "flag" packet */ + (state->bits & MPPE_BIT_FLUSHED)) { /* CCP Reset-Request */ + /* We must rekey */ + if (state->stateful) { + PPPDEBUG(LOG_DEBUG, ("mppe_compress[%d]: rekeying\n", pcb->netif->num)); + } + mppe_rekey(state, 0); + state->bits |= MPPE_BIT_FLUSHED; + } + pl[0] |= state->bits; + state->bits &= ~MPPE_BIT_FLUSHED; /* reset for next xmit */ + pl += MPPE_OVHD; + + /* Add protocol */ + /* FIXME: add PFC support */ + pl[0] = protocol >> 8; + pl[1] = protocol; + + /* Hide MPPE header */ + pbuf_remove_header(np, MPPE_OVHD); + + /* Encrypt packet */ + for (n = np; n != NULL; n = n->next) { + lwip_arc4_crypt(&state->arc4, (u8_t*)n->payload, n->len); + if (n->tot_len == n->len) { + break; + } + } + + /* Reveal MPPE header */ + pbuf_add_header(np, MPPE_OVHD); + + return ERR_OK; +} + +/* + * We received a CCP Reset-Ack. Just ignore it. + */ +void mppe_decomp_reset(ppp_pcb *pcb, ppp_mppe_state *state) +{ + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(state); + return; +} + +/* + * Decompress (decrypt) an MPPE packet. + */ +err_t +mppe_decompress(ppp_pcb *pcb, ppp_mppe_state *state, struct pbuf **pb) +{ + struct pbuf *n0 = *pb, *n; + u8_t *pl; + u16_t ccount; + u8_t flushed; + + /* MPPE Header */ + if (n0->len < MPPE_OVHD) { + PPPDEBUG(LOG_DEBUG, + ("mppe_decompress[%d]: short pkt (%d)\n", + pcb->netif->num, n0->len)); + state->sanity_errors += 100; + goto sanity_error; + } + + pl = (u8_t*)n0->payload; + flushed = MPPE_BITS(pl) & MPPE_BIT_FLUSHED; + ccount = MPPE_CCOUNT(pl); + PPPDEBUG(LOG_DEBUG, ("mppe_decompress[%d]: ccount %d\n", + pcb->netif->num, ccount)); + + /* sanity checks -- terminate with extreme prejudice */ + if (!(MPPE_BITS(pl) & MPPE_BIT_ENCRYPTED)) { + PPPDEBUG(LOG_DEBUG, + ("mppe_decompress[%d]: ENCRYPTED bit not set!\n", + pcb->netif->num)); + state->sanity_errors += 100; + goto sanity_error; + } + if (!state->stateful && !flushed) { + PPPDEBUG(LOG_DEBUG, ("mppe_decompress[%d]: FLUSHED bit not set in " + "stateless mode!\n", pcb->netif->num)); + state->sanity_errors += 100; + goto sanity_error; + } + if (state->stateful && ((ccount & 0xff) == 0xff) && !flushed) { + PPPDEBUG(LOG_DEBUG, ("mppe_decompress[%d]: FLUSHED bit not set on " + "flag packet!\n", pcb->netif->num)); + state->sanity_errors += 100; + goto sanity_error; + } + + /* + * Check the coherency count. + */ + + if (!state->stateful) { + /* Discard late packet */ + if ((ccount - state->ccount) % MPPE_CCOUNT_SPACE > MPPE_CCOUNT_SPACE / 2) { + state->sanity_errors++; + goto sanity_error; + } + + /* RFC 3078, sec 8.1. Rekey for every packet. */ + while (state->ccount != ccount) { + mppe_rekey(state, 0); + state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE; + } + } else { + /* RFC 3078, sec 8.2. */ + if (!state->discard) { + /* normal state */ + state->ccount = (state->ccount + 1) % MPPE_CCOUNT_SPACE; + if (ccount != state->ccount) { + /* + * (ccount > state->ccount) + * Packet loss detected, enter the discard state. + * Signal the peer to rekey (by sending a CCP Reset-Request). + */ + state->discard = 1; + ccp_resetrequest(pcb); + return ERR_BUF; + } + } else { + /* discard state */ + if (!flushed) { + /* ccp.c will be silent (no additional CCP Reset-Requests). */ + return ERR_BUF; + } else { + /* Rekey for every missed "flag" packet. */ + while ((ccount & ~0xff) != + (state->ccount & ~0xff)) { + mppe_rekey(state, 0); + state->ccount = + (state->ccount + + 256) % MPPE_CCOUNT_SPACE; + } + + /* reset */ + state->discard = 0; + state->ccount = ccount; + /* + * Another problem with RFC 3078 here. It implies that the + * peer need not send a Reset-Ack packet. But RFC 1962 + * requires it. Hopefully, M$ does send a Reset-Ack; even + * though it isn't required for MPPE synchronization, it is + * required to reset CCP state. + */ + } + } + if (flushed) + mppe_rekey(state, 0); + } + + /* Hide MPPE header */ + pbuf_remove_header(n0, MPPE_OVHD); + + /* Decrypt the packet. */ + for (n = n0; n != NULL; n = n->next) { + lwip_arc4_crypt(&state->arc4, (u8_t*)n->payload, n->len); + if (n->tot_len == n->len) { + break; + } + } + + /* good packet credit */ + state->sanity_errors >>= 1; + + return ERR_OK; + +sanity_error: + if (state->sanity_errors >= SANITY_MAX) { + /* + * Take LCP down if the peer is sending too many bogons. + * We don't want to do this for a single or just a few + * instances since it could just be due to packet corruption. + */ + lcp_close(pcb, "Too many MPPE errors"); + } + return ERR_BUF; +} + +#endif /* PPP_SUPPORT && MPPE_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/multilink.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/multilink.c index 9153deaa..62014e8c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/multilink.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/multilink.c @@ -1,609 +1,609 @@ -/* - * multilink.c - support routines for multilink. - * - * Copyright (c) 2000-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && defined(HAVE_MULTILINK) /* don't build if not configured for use in lwipopts.h */ - -/* Multilink support - * - * Multilink uses Samba TDB (Trivial Database Library), which - * we cannot port, because it needs a filesystem. - * - * We have to choose between doing a memory-shared TDB-clone, - * or dropping multilink support at all. - */ - -#include -#include -#include -#include -#include -#include -#include -#include - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/lcp.h" -#include "netif/ppp/tdb.h" - -bool endpoint_specified; /* user gave explicit endpoint discriminator */ -char *bundle_id; /* identifier for our bundle */ -char *blinks_id; /* key for the list of links */ -bool doing_multilink; /* multilink was enabled and agreed to */ -bool multilink_master; /* we own the multilink bundle */ - -extern TDB_CONTEXT *pppdb; -extern char db_key[]; - -static void make_bundle_links (int append); -static void remove_bundle_link (void); -static void iterate_bundle_links (void (*func) (char *)); - -static int get_default_epdisc (struct epdisc *); -static int parse_num (char *str, const char *key, int *valp); -static int owns_unit (TDB_DATA pid, int unit); - -#define set_ip_epdisc(ep, addr) do { \ - ep->length = 4; \ - ep->value[0] = addr >> 24; \ - ep->value[1] = addr >> 16; \ - ep->value[2] = addr >> 8; \ - ep->value[3] = addr; \ -} while (0) - -#define LOCAL_IP_ADDR(addr) \ - (((addr) & 0xff000000) == 0x0a000000 /* 10.x.x.x */ \ - || ((addr) & 0xfff00000) == 0xac100000 /* 172.16.x.x */ \ - || ((addr) & 0xffff0000) == 0xc0a80000) /* 192.168.x.x */ - -#define process_exists(n) (kill((n), 0) == 0 || errno != ESRCH) - -void -mp_check_options() -{ - lcp_options *wo = &lcp_wantoptions[0]; - lcp_options *ao = &lcp_allowoptions[0]; - - doing_multilink = 0; - if (!multilink) - return; - /* if we're doing multilink, we have to negotiate MRRU */ - if (!wo->neg_mrru) { - /* mrru not specified, default to mru */ - wo->mrru = wo->mru; - wo->neg_mrru = 1; - } - ao->mrru = ao->mru; - ao->neg_mrru = 1; - - if (!wo->neg_endpoint && !noendpoint) { - /* get a default endpoint value */ - wo->neg_endpoint = get_default_epdisc(&wo->endpoint); - } -} - -/* - * Make a new bundle or join us to an existing bundle - * if we are doing multilink. - */ -int -mp_join_bundle() -{ - lcp_options *go = &lcp_gotoptions[0]; - lcp_options *ho = &lcp_hisoptions[0]; - lcp_options *ao = &lcp_allowoptions[0]; - int unit, pppd_pid; - int l, mtu; - char *p; - TDB_DATA key, pid, rec; - - if (doing_multilink) { - /* have previously joined a bundle */ - if (!go->neg_mrru || !ho->neg_mrru) { - notice("oops, didn't get multilink on renegotiation"); - lcp_close(pcb, "multilink required"); - return 0; - } - /* XXX should check the peer_authname and ho->endpoint - are the same as previously */ - return 0; - } - - if (!go->neg_mrru || !ho->neg_mrru) { - /* not doing multilink */ - if (go->neg_mrru) - notice("oops, multilink negotiated only for receive"); - mtu = ho->neg_mru? ho->mru: PPP_MRU; - if (mtu > ao->mru) - mtu = ao->mru; - if (demand) { - /* already have a bundle */ - cfg_bundle(0, 0, 0, 0); - netif_set_mtu(pcb, mtu); - return 0; - } - make_new_bundle(0, 0, 0, 0); - set_ifunit(1); - netif_set_mtu(pcb, mtu); - return 0; - } - - doing_multilink = 1; - - /* - * Find the appropriate bundle or join a new one. - * First we make up a name for the bundle. - * The length estimate is worst-case assuming every - * character has to be quoted. - */ - l = 4 * strlen(peer_authname) + 10; - if (ho->neg_endpoint) - l += 3 * ho->endpoint.length + 8; - if (bundle_name) - l += 3 * strlen(bundle_name) + 2; - bundle_id = malloc(l); - if (bundle_id == 0) - novm("bundle identifier"); - - p = bundle_id; - p += slprintf(p, l-1, "BUNDLE=\"%q\"", peer_authname); - if (ho->neg_endpoint || bundle_name) - *p++ = '/'; - if (ho->neg_endpoint) - p += slprintf(p, bundle_id+l-p, "%s", - epdisc_to_str(&ho->endpoint)); - if (bundle_name) - p += slprintf(p, bundle_id+l-p, "/%v", bundle_name); - - /* Make the key for the list of links belonging to the bundle */ - l = p - bundle_id; - blinks_id = malloc(l + 7); - if (blinks_id == NULL) - novm("bundle links key"); - slprintf(blinks_id, l + 7, "BUNDLE_LINKS=%s", bundle_id + 7); - - /* - * For demand mode, we only need to configure the bundle - * and attach the link. - */ - mtu = LWIP_MIN(ho->mrru, ao->mru); - if (demand) { - cfg_bundle(go->mrru, ho->mrru, go->neg_ssnhf, ho->neg_ssnhf); - netif_set_mtu(pcb, mtu); - script_setenv("BUNDLE", bundle_id + 7, 1); - return 0; - } - - /* - * Check if the bundle ID is already in the database. - */ - unit = -1; - lock_db(); - key.dptr = bundle_id; - key.dsize = p - bundle_id; - pid = tdb_fetch(pppdb, key); - if (pid.dptr != NULL) { - /* bundle ID exists, see if the pppd record exists */ - rec = tdb_fetch(pppdb, pid); - if (rec.dptr != NULL && rec.dsize > 0) { - /* make sure the string is null-terminated */ - rec.dptr[rec.dsize-1] = 0; - /* parse the interface number */ - parse_num(rec.dptr, "IFNAME=ppp", &unit); - /* check the pid value */ - if (!parse_num(rec.dptr, "PPPD_PID=", &pppd_pid) - || !process_exists(pppd_pid) - || !owns_unit(pid, unit)) - unit = -1; - free(rec.dptr); - } - free(pid.dptr); - } - - if (unit >= 0) { - /* attach to existing unit */ - if (bundle_attach(unit)) { - set_ifunit(0); - script_setenv("BUNDLE", bundle_id + 7, 0); - make_bundle_links(1); - unlock_db(); - info("Link attached to %s", ifname); - return 1; - } - /* attach failed because bundle doesn't exist */ - } - - /* we have to make a new bundle */ - make_new_bundle(go->mrru, ho->mrru, go->neg_ssnhf, ho->neg_ssnhf); - set_ifunit(1); - netif_set_mtu(pcb, mtu); - script_setenv("BUNDLE", bundle_id + 7, 1); - make_bundle_links(pcb); - unlock_db(); - info("New bundle %s created", ifname); - multilink_master = 1; - return 0; -} - -void mp_exit_bundle() -{ - lock_db(); - remove_bundle_link(); - unlock_db(); -} - -static void sendhup(char *str) -{ - int pid; - - if (parse_num(str, "PPPD_PID=", &pid) && pid != getpid()) { - if (debug) - dbglog("sending SIGHUP to process %d", pid); - kill(pid, SIGHUP); - } -} - -void mp_bundle_terminated() -{ - TDB_DATA key; - - bundle_terminating = 1; - upper_layers_down(pcb); - notice("Connection terminated."); -#if PPP_STATS_SUPPORT - print_link_stats(); -#endif /* PPP_STATS_SUPPORT */ - if (!demand) { - remove_pidfiles(); - script_unsetenv("IFNAME"); - } - - lock_db(); - destroy_bundle(); - iterate_bundle_links(sendhup); - key.dptr = blinks_id; - key.dsize = strlen(blinks_id); - tdb_delete(pppdb, key); - unlock_db(); - - new_phase(PPP_PHASE_DEAD); - - doing_multilink = 0; - multilink_master = 0; -} - -static void make_bundle_links(int append) -{ - TDB_DATA key, rec; - char *p; - char entry[32]; - int l; - - key.dptr = blinks_id; - key.dsize = strlen(blinks_id); - slprintf(entry, sizeof(entry), "%s;", db_key); - p = entry; - if (append) { - rec = tdb_fetch(pppdb, key); - if (rec.dptr != NULL && rec.dsize > 0) { - rec.dptr[rec.dsize-1] = 0; - if (strstr(rec.dptr, db_key) != NULL) { - /* already in there? strange */ - warn("link entry already exists in tdb"); - return; - } - l = rec.dsize + strlen(entry); - p = malloc(l); - if (p == NULL) - novm("bundle link list"); - slprintf(p, l, "%s%s", rec.dptr, entry); - } else { - warn("bundle link list not found"); - } - if (rec.dptr != NULL) - free(rec.dptr); - } - rec.dptr = p; - rec.dsize = strlen(p) + 1; - if (tdb_store(pppdb, key, rec, TDB_REPLACE)) - error("couldn't %s bundle link list", - append? "update": "create"); - if (p != entry) - free(p); -} - -static void remove_bundle_link() -{ - TDB_DATA key, rec; - char entry[32]; - char *p, *q; - int l; - - key.dptr = blinks_id; - key.dsize = strlen(blinks_id); - slprintf(entry, sizeof(entry), "%s;", db_key); - - rec = tdb_fetch(pppdb, key); - if (rec.dptr == NULL || rec.dsize <= 0) { - if (rec.dptr != NULL) - free(rec.dptr); - return; - } - rec.dptr[rec.dsize-1] = 0; - p = strstr(rec.dptr, entry); - if (p != NULL) { - q = p + strlen(entry); - l = strlen(q) + 1; - memmove(p, q, l); - rec.dsize = p - rec.dptr + l; - if (tdb_store(pppdb, key, rec, TDB_REPLACE)) - error("couldn't update bundle link list (removal)"); - } - free(rec.dptr); -} - -static void iterate_bundle_links(void (*func)(char *)) -{ - TDB_DATA key, rec, pp; - char *p, *q; - - key.dptr = blinks_id; - key.dsize = strlen(blinks_id); - rec = tdb_fetch(pppdb, key); - if (rec.dptr == NULL || rec.dsize <= 0) { - error("bundle link list not found (iterating list)"); - if (rec.dptr != NULL) - free(rec.dptr); - return; - } - p = rec.dptr; - p[rec.dsize-1] = 0; - while ((q = strchr(p, ';')) != NULL) { - *q = 0; - key.dptr = p; - key.dsize = q - p; - pp = tdb_fetch(pppdb, key); - if (pp.dptr != NULL && pp.dsize > 0) { - pp.dptr[pp.dsize-1] = 0; - func(pp.dptr); - } - if (pp.dptr != NULL) - free(pp.dptr); - p = q + 1; - } - free(rec.dptr); -} - -static int -parse_num(str, key, valp) - char *str; - const char *key; - int *valp; -{ - char *p, *endp; - int i; - - p = strstr(str, key); - if (p != 0) { - p += strlen(key); - i = strtol(p, &endp, 10); - if (endp != p && (*endp == 0 || *endp == ';')) { - *valp = i; - return 1; - } - } - return 0; -} - -/* - * Check whether the pppd identified by `key' still owns ppp unit `unit'. - */ -static int -owns_unit(key, unit) - TDB_DATA key; - int unit; -{ - char ifkey[32]; - TDB_DATA kd, vd; - int ret = 0; - - slprintf(ifkey, sizeof(ifkey), "IFNAME=ppp%d", unit); - kd.dptr = ifkey; - kd.dsize = strlen(ifkey); - vd = tdb_fetch(pppdb, kd); - if (vd.dptr != NULL) { - ret = vd.dsize == key.dsize - && memcmp(vd.dptr, key.dptr, vd.dsize) == 0; - free(vd.dptr); - } - return ret; -} - -static int -get_default_epdisc(ep) - struct epdisc *ep; -{ - char *p; - struct hostent *hp; - u32_t addr; - - /* First try for an ethernet MAC address */ - p = get_first_ethernet(); - if (p != 0 && get_if_hwaddr(ep->value, p) >= 0) { - ep->class = EPD_MAC; - ep->length = 6; - return 1; - } - - /* see if our hostname corresponds to a reasonable IP address */ - hp = gethostbyname(hostname); - if (hp != NULL) { - addr = *(u32_t *)hp->h_addr; - if (!bad_ip_adrs(addr)) { - addr = lwip_ntohl(addr); - if (!LOCAL_IP_ADDR(addr)) { - ep->class = EPD_IP; - set_ip_epdisc(ep, addr); - return 1; - } - } - } - - return 0; -} - -/* - * epdisc_to_str - make a printable string from an endpoint discriminator. - */ - -static char *endp_class_names[] = { - "null", "local", "IP", "MAC", "magic", "phone" -}; - -char * -epdisc_to_str(ep) - struct epdisc *ep; -{ - static char str[MAX_ENDP_LEN*3+8]; - u_char *p = ep->value; - int i, mask = 0; - char *q, c, c2; - - if (ep->class == EPD_NULL && ep->length == 0) - return "null"; - if (ep->class == EPD_IP && ep->length == 4) { - u32_t addr; - - GETLONG(addr, p); - slprintf(str, sizeof(str), "IP:%I", lwip_htonl(addr)); - return str; - } - - c = ':'; - c2 = '.'; - if (ep->class == EPD_MAC && ep->length == 6) - c2 = ':'; - else if (ep->class == EPD_MAGIC && (ep->length % 4) == 0) - mask = 3; - q = str; - if (ep->class <= EPD_PHONENUM) - q += slprintf(q, sizeof(str)-1, "%s", - endp_class_names[ep->class]); - else - q += slprintf(q, sizeof(str)-1, "%d", ep->class); - c = ':'; - for (i = 0; i < ep->length && i < MAX_ENDP_LEN; ++i) { - if ((i & mask) == 0) { - *q++ = c; - c = c2; - } - q += slprintf(q, str + sizeof(str) - q, "%.2x", ep->value[i]); - } - return str; -} - -static int hexc_val(int c) -{ - if (c >= 'a') - return c - 'a' + 10; - if (c >= 'A') - return c - 'A' + 10; - return c - '0'; -} - -int -str_to_epdisc(ep, str) - struct epdisc *ep; - char *str; -{ - int i, l; - char *p, *endp; - - for (i = EPD_NULL; i <= EPD_PHONENUM; ++i) { - int sl = strlen(endp_class_names[i]); - if (strncasecmp(str, endp_class_names[i], sl) == 0) { - str += sl; - break; - } - } - if (i > EPD_PHONENUM) { - /* not a class name, try a decimal class number */ - i = strtol(str, &endp, 10); - if (endp == str) - return 0; /* can't parse class number */ - str = endp; - } - ep->class = i; - if (*str == 0) { - ep->length = 0; - return 1; - } - if (*str != ':' && *str != '.') - return 0; - ++str; - - if (i == EPD_IP) { - u32_t addr; - i = parse_dotted_ip(str, &addr); - if (i == 0 || str[i] != 0) - return 0; - set_ip_epdisc(ep, addr); - return 1; - } - if (i == EPD_MAC && get_if_hwaddr(ep->value, str) >= 0) { - ep->length = 6; - return 1; - } - - p = str; - for (l = 0; l < MAX_ENDP_LEN; ++l) { - if (*str == 0) - break; - if (p <= str) - for (p = str; isxdigit(*p); ++p) - ; - i = p - str; - if (i == 0) - return 0; - ep->value[l] = hexc_val(*str++); - if ((i & 1) == 0) - ep->value[l] = (ep->value[l] << 4) + hexc_val(*str++); - if (*str == ':' || *str == '.') - ++str; - } - if (*str != 0 || (ep->class == EPD_MAC && l != 6)) - return 0; - ep->length = l; - return 1; -} - -#endif /* PPP_SUPPORT && HAVE_MULTILINK */ +/* + * multilink.c - support routines for multilink. + * + * Copyright (c) 2000-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && defined(HAVE_MULTILINK) /* don't build if not configured for use in lwipopts.h */ + +/* Multilink support + * + * Multilink uses Samba TDB (Trivial Database Library), which + * we cannot port, because it needs a filesystem. + * + * We have to choose between doing a memory-shared TDB-clone, + * or dropping multilink support at all. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/lcp.h" +#include "netif/ppp/tdb.h" + +bool endpoint_specified; /* user gave explicit endpoint discriminator */ +char *bundle_id; /* identifier for our bundle */ +char *blinks_id; /* key for the list of links */ +bool doing_multilink; /* multilink was enabled and agreed to */ +bool multilink_master; /* we own the multilink bundle */ + +extern TDB_CONTEXT *pppdb; +extern char db_key[]; + +static void make_bundle_links (int append); +static void remove_bundle_link (void); +static void iterate_bundle_links (void (*func) (char *)); + +static int get_default_epdisc (struct epdisc *); +static int parse_num (char *str, const char *key, int *valp); +static int owns_unit (TDB_DATA pid, int unit); + +#define set_ip_epdisc(ep, addr) do { \ + ep->length = 4; \ + ep->value[0] = addr >> 24; \ + ep->value[1] = addr >> 16; \ + ep->value[2] = addr >> 8; \ + ep->value[3] = addr; \ +} while (0) + +#define LOCAL_IP_ADDR(addr) \ + (((addr) & 0xff000000) == 0x0a000000 /* 10.x.x.x */ \ + || ((addr) & 0xfff00000) == 0xac100000 /* 172.16.x.x */ \ + || ((addr) & 0xffff0000) == 0xc0a80000) /* 192.168.x.x */ + +#define process_exists(n) (kill((n), 0) == 0 || errno != ESRCH) + +void +mp_check_options() +{ + lcp_options *wo = &lcp_wantoptions[0]; + lcp_options *ao = &lcp_allowoptions[0]; + + doing_multilink = 0; + if (!multilink) + return; + /* if we're doing multilink, we have to negotiate MRRU */ + if (!wo->neg_mrru) { + /* mrru not specified, default to mru */ + wo->mrru = wo->mru; + wo->neg_mrru = 1; + } + ao->mrru = ao->mru; + ao->neg_mrru = 1; + + if (!wo->neg_endpoint && !noendpoint) { + /* get a default endpoint value */ + wo->neg_endpoint = get_default_epdisc(&wo->endpoint); + } +} + +/* + * Make a new bundle or join us to an existing bundle + * if we are doing multilink. + */ +int +mp_join_bundle() +{ + lcp_options *go = &lcp_gotoptions[0]; + lcp_options *ho = &lcp_hisoptions[0]; + lcp_options *ao = &lcp_allowoptions[0]; + int unit, pppd_pid; + int l, mtu; + char *p; + TDB_DATA key, pid, rec; + + if (doing_multilink) { + /* have previously joined a bundle */ + if (!go->neg_mrru || !ho->neg_mrru) { + notice("oops, didn't get multilink on renegotiation"); + lcp_close(pcb, "multilink required"); + return 0; + } + /* XXX should check the peer_authname and ho->endpoint + are the same as previously */ + return 0; + } + + if (!go->neg_mrru || !ho->neg_mrru) { + /* not doing multilink */ + if (go->neg_mrru) + notice("oops, multilink negotiated only for receive"); + mtu = ho->neg_mru? ho->mru: PPP_MRU; + if (mtu > ao->mru) + mtu = ao->mru; + if (demand) { + /* already have a bundle */ + cfg_bundle(0, 0, 0, 0); + netif_set_mtu(pcb, mtu); + return 0; + } + make_new_bundle(0, 0, 0, 0); + set_ifunit(1); + netif_set_mtu(pcb, mtu); + return 0; + } + + doing_multilink = 1; + + /* + * Find the appropriate bundle or join a new one. + * First we make up a name for the bundle. + * The length estimate is worst-case assuming every + * character has to be quoted. + */ + l = 4 * strlen(peer_authname) + 10; + if (ho->neg_endpoint) + l += 3 * ho->endpoint.length + 8; + if (bundle_name) + l += 3 * strlen(bundle_name) + 2; + bundle_id = malloc(l); + if (bundle_id == 0) + novm("bundle identifier"); + + p = bundle_id; + p += slprintf(p, l-1, "BUNDLE=\"%q\"", peer_authname); + if (ho->neg_endpoint || bundle_name) + *p++ = '/'; + if (ho->neg_endpoint) + p += slprintf(p, bundle_id+l-p, "%s", + epdisc_to_str(&ho->endpoint)); + if (bundle_name) + p += slprintf(p, bundle_id+l-p, "/%v", bundle_name); + + /* Make the key for the list of links belonging to the bundle */ + l = p - bundle_id; + blinks_id = malloc(l + 7); + if (blinks_id == NULL) + novm("bundle links key"); + slprintf(blinks_id, l + 7, "BUNDLE_LINKS=%s", bundle_id + 7); + + /* + * For demand mode, we only need to configure the bundle + * and attach the link. + */ + mtu = LWIP_MIN(ho->mrru, ao->mru); + if (demand) { + cfg_bundle(go->mrru, ho->mrru, go->neg_ssnhf, ho->neg_ssnhf); + netif_set_mtu(pcb, mtu); + script_setenv("BUNDLE", bundle_id + 7, 1); + return 0; + } + + /* + * Check if the bundle ID is already in the database. + */ + unit = -1; + lock_db(); + key.dptr = bundle_id; + key.dsize = p - bundle_id; + pid = tdb_fetch(pppdb, key); + if (pid.dptr != NULL) { + /* bundle ID exists, see if the pppd record exists */ + rec = tdb_fetch(pppdb, pid); + if (rec.dptr != NULL && rec.dsize > 0) { + /* make sure the string is null-terminated */ + rec.dptr[rec.dsize-1] = 0; + /* parse the interface number */ + parse_num(rec.dptr, "IFNAME=ppp", &unit); + /* check the pid value */ + if (!parse_num(rec.dptr, "PPPD_PID=", &pppd_pid) + || !process_exists(pppd_pid) + || !owns_unit(pid, unit)) + unit = -1; + free(rec.dptr); + } + free(pid.dptr); + } + + if (unit >= 0) { + /* attach to existing unit */ + if (bundle_attach(unit)) { + set_ifunit(0); + script_setenv("BUNDLE", bundle_id + 7, 0); + make_bundle_links(1); + unlock_db(); + info("Link attached to %s", ifname); + return 1; + } + /* attach failed because bundle doesn't exist */ + } + + /* we have to make a new bundle */ + make_new_bundle(go->mrru, ho->mrru, go->neg_ssnhf, ho->neg_ssnhf); + set_ifunit(1); + netif_set_mtu(pcb, mtu); + script_setenv("BUNDLE", bundle_id + 7, 1); + make_bundle_links(pcb); + unlock_db(); + info("New bundle %s created", ifname); + multilink_master = 1; + return 0; +} + +void mp_exit_bundle() +{ + lock_db(); + remove_bundle_link(); + unlock_db(); +} + +static void sendhup(char *str) +{ + int pid; + + if (parse_num(str, "PPPD_PID=", &pid) && pid != getpid()) { + if (debug) + dbglog("sending SIGHUP to process %d", pid); + kill(pid, SIGHUP); + } +} + +void mp_bundle_terminated() +{ + TDB_DATA key; + + bundle_terminating = 1; + upper_layers_down(pcb); + notice("Connection terminated."); +#if PPP_STATS_SUPPORT + print_link_stats(); +#endif /* PPP_STATS_SUPPORT */ + if (!demand) { + remove_pidfiles(); + script_unsetenv("IFNAME"); + } + + lock_db(); + destroy_bundle(); + iterate_bundle_links(sendhup); + key.dptr = blinks_id; + key.dsize = strlen(blinks_id); + tdb_delete(pppdb, key); + unlock_db(); + + new_phase(PPP_PHASE_DEAD); + + doing_multilink = 0; + multilink_master = 0; +} + +static void make_bundle_links(int append) +{ + TDB_DATA key, rec; + char *p; + char entry[32]; + int l; + + key.dptr = blinks_id; + key.dsize = strlen(blinks_id); + slprintf(entry, sizeof(entry), "%s;", db_key); + p = entry; + if (append) { + rec = tdb_fetch(pppdb, key); + if (rec.dptr != NULL && rec.dsize > 0) { + rec.dptr[rec.dsize-1] = 0; + if (strstr(rec.dptr, db_key) != NULL) { + /* already in there? strange */ + warn("link entry already exists in tdb"); + return; + } + l = rec.dsize + strlen(entry); + p = malloc(l); + if (p == NULL) + novm("bundle link list"); + slprintf(p, l, "%s%s", rec.dptr, entry); + } else { + warn("bundle link list not found"); + } + if (rec.dptr != NULL) + free(rec.dptr); + } + rec.dptr = p; + rec.dsize = strlen(p) + 1; + if (tdb_store(pppdb, key, rec, TDB_REPLACE)) + error("couldn't %s bundle link list", + append? "update": "create"); + if (p != entry) + free(p); +} + +static void remove_bundle_link() +{ + TDB_DATA key, rec; + char entry[32]; + char *p, *q; + int l; + + key.dptr = blinks_id; + key.dsize = strlen(blinks_id); + slprintf(entry, sizeof(entry), "%s;", db_key); + + rec = tdb_fetch(pppdb, key); + if (rec.dptr == NULL || rec.dsize <= 0) { + if (rec.dptr != NULL) + free(rec.dptr); + return; + } + rec.dptr[rec.dsize-1] = 0; + p = strstr(rec.dptr, entry); + if (p != NULL) { + q = p + strlen(entry); + l = strlen(q) + 1; + memmove(p, q, l); + rec.dsize = p - rec.dptr + l; + if (tdb_store(pppdb, key, rec, TDB_REPLACE)) + error("couldn't update bundle link list (removal)"); + } + free(rec.dptr); +} + +static void iterate_bundle_links(void (*func)(char *)) +{ + TDB_DATA key, rec, pp; + char *p, *q; + + key.dptr = blinks_id; + key.dsize = strlen(blinks_id); + rec = tdb_fetch(pppdb, key); + if (rec.dptr == NULL || rec.dsize <= 0) { + error("bundle link list not found (iterating list)"); + if (rec.dptr != NULL) + free(rec.dptr); + return; + } + p = rec.dptr; + p[rec.dsize-1] = 0; + while ((q = strchr(p, ';')) != NULL) { + *q = 0; + key.dptr = p; + key.dsize = q - p; + pp = tdb_fetch(pppdb, key); + if (pp.dptr != NULL && pp.dsize > 0) { + pp.dptr[pp.dsize-1] = 0; + func(pp.dptr); + } + if (pp.dptr != NULL) + free(pp.dptr); + p = q + 1; + } + free(rec.dptr); +} + +static int +parse_num(str, key, valp) + char *str; + const char *key; + int *valp; +{ + char *p, *endp; + int i; + + p = strstr(str, key); + if (p != 0) { + p += strlen(key); + i = strtol(p, &endp, 10); + if (endp != p && (*endp == 0 || *endp == ';')) { + *valp = i; + return 1; + } + } + return 0; +} + +/* + * Check whether the pppd identified by `key' still owns ppp unit `unit'. + */ +static int +owns_unit(key, unit) + TDB_DATA key; + int unit; +{ + char ifkey[32]; + TDB_DATA kd, vd; + int ret = 0; + + slprintf(ifkey, sizeof(ifkey), "IFNAME=ppp%d", unit); + kd.dptr = ifkey; + kd.dsize = strlen(ifkey); + vd = tdb_fetch(pppdb, kd); + if (vd.dptr != NULL) { + ret = vd.dsize == key.dsize + && memcmp(vd.dptr, key.dptr, vd.dsize) == 0; + free(vd.dptr); + } + return ret; +} + +static int +get_default_epdisc(ep) + struct epdisc *ep; +{ + char *p; + struct hostent *hp; + u32_t addr; + + /* First try for an ethernet MAC address */ + p = get_first_ethernet(); + if (p != 0 && get_if_hwaddr(ep->value, p) >= 0) { + ep->class = EPD_MAC; + ep->length = 6; + return 1; + } + + /* see if our hostname corresponds to a reasonable IP address */ + hp = gethostbyname(hostname); + if (hp != NULL) { + addr = *(u32_t *)hp->h_addr; + if (!bad_ip_adrs(addr)) { + addr = lwip_ntohl(addr); + if (!LOCAL_IP_ADDR(addr)) { + ep->class = EPD_IP; + set_ip_epdisc(ep, addr); + return 1; + } + } + } + + return 0; +} + +/* + * epdisc_to_str - make a printable string from an endpoint discriminator. + */ + +static char *endp_class_names[] = { + "null", "local", "IP", "MAC", "magic", "phone" +}; + +char * +epdisc_to_str(ep) + struct epdisc *ep; +{ + static char str[MAX_ENDP_LEN*3+8]; + u_char *p = ep->value; + int i, mask = 0; + char *q, c, c2; + + if (ep->class == EPD_NULL && ep->length == 0) + return "null"; + if (ep->class == EPD_IP && ep->length == 4) { + u32_t addr; + + GETLONG(addr, p); + slprintf(str, sizeof(str), "IP:%I", lwip_htonl(addr)); + return str; + } + + c = ':'; + c2 = '.'; + if (ep->class == EPD_MAC && ep->length == 6) + c2 = ':'; + else if (ep->class == EPD_MAGIC && (ep->length % 4) == 0) + mask = 3; + q = str; + if (ep->class <= EPD_PHONENUM) + q += slprintf(q, sizeof(str)-1, "%s", + endp_class_names[ep->class]); + else + q += slprintf(q, sizeof(str)-1, "%d", ep->class); + c = ':'; + for (i = 0; i < ep->length && i < MAX_ENDP_LEN; ++i) { + if ((i & mask) == 0) { + *q++ = c; + c = c2; + } + q += slprintf(q, str + sizeof(str) - q, "%.2x", ep->value[i]); + } + return str; +} + +static int hexc_val(int c) +{ + if (c >= 'a') + return c - 'a' + 10; + if (c >= 'A') + return c - 'A' + 10; + return c - '0'; +} + +int +str_to_epdisc(ep, str) + struct epdisc *ep; + char *str; +{ + int i, l; + char *p, *endp; + + for (i = EPD_NULL; i <= EPD_PHONENUM; ++i) { + int sl = strlen(endp_class_names[i]); + if (strncasecmp(str, endp_class_names[i], sl) == 0) { + str += sl; + break; + } + } + if (i > EPD_PHONENUM) { + /* not a class name, try a decimal class number */ + i = strtol(str, &endp, 10); + if (endp == str) + return 0; /* can't parse class number */ + str = endp; + } + ep->class = i; + if (*str == 0) { + ep->length = 0; + return 1; + } + if (*str != ':' && *str != '.') + return 0; + ++str; + + if (i == EPD_IP) { + u32_t addr; + i = parse_dotted_ip(str, &addr); + if (i == 0 || str[i] != 0) + return 0; + set_ip_epdisc(ep, addr); + return 1; + } + if (i == EPD_MAC && get_if_hwaddr(ep->value, str) >= 0) { + ep->length = 6; + return 1; + } + + p = str; + for (l = 0; l < MAX_ENDP_LEN; ++l) { + if (*str == 0) + break; + if (p <= str) + for (p = str; isxdigit(*p); ++p) + ; + i = p - str; + if (i == 0) + return 0; + ep->value[l] = hexc_val(*str++); + if ((i & 1) == 0) + ep->value[l] = (ep->value[l] << 4) + hexc_val(*str++); + if (*str == ':' || *str == '.') + ++str; + } + if (*str != 0 || (ep->class == EPD_MAC && l != 6)) + return 0; + ep->length = l; + return 1; +} + +#endif /* PPP_SUPPORT && HAVE_MULTILINK */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/README b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/README index d4bfc7e6..3fdf159e 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/README +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/README @@ -1,22 +1,22 @@ -About PolarSSL files into lwIP PPP support ------------------------------------------- - -This folder contains some files fetched from the latest BSD release of -the PolarSSL project (PolarSSL 0.10.1-bsd) for ciphers and encryption -methods we need for lwIP PPP support. - -The PolarSSL files were cleaned to contain only the necessary struct -fields and functions needed for lwIP. - -The PolarSSL API was not changed at all, so if you are already using -PolarSSL you can choose to skip the compilation of the included PolarSSL -library into lwIP. - -If you are not using the embedded copy you must include external -libraries into your arch/cc.h port file. - -Beware of the stack requirements which can be a lot larger if you are not -using our cleaned PolarSSL library. - - -PolarSSL project website: http://polarssl.org/ +About PolarSSL files into lwIP PPP support +------------------------------------------ + +This folder contains some files fetched from the latest BSD release of +the PolarSSL project (PolarSSL 0.10.1-bsd) for ciphers and encryption +methods we need for lwIP PPP support. + +The PolarSSL files were cleaned to contain only the necessary struct +fields and functions needed for lwIP. + +The PolarSSL API was not changed at all, so if you are already using +PolarSSL you can choose to skip the compilation of the included PolarSSL +library into lwIP. + +If you are not using the embedded copy you must include external +libraries into your arch/cc.h port file. + +Beware of the stack requirements which can be a lot larger if you are not +using our cleaned PolarSSL library. + + +PolarSSL project website: http://polarssl.org/ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/arc4.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/arc4.c index ea8936f0..6e17ec42 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/arc4.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/arc4.c @@ -1,101 +1,101 @@ -/* - * An implementation of the ARCFOUR algorithm - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * The ARCFOUR algorithm was publicly disclosed on 94/09. - * - * http://groups.google.com/group/sci.crypt/msg/10a300c9d21afca0 - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_ARC4 - -#include "netif/ppp/polarssl/arc4.h" -/* - * ARC4 key schedule - */ -void arc4_setup( arc4_context *ctx, unsigned char *key, int keylen ) -{ - int i, j, k, a; - unsigned char *m; - - ctx->x = 0; - ctx->y = 0; - m = ctx->m; - - for( i = 0; i < 256; i++ ) - m[i] = (unsigned char) i; - - j = k = 0; - - for( i = 0; i < 256; i++, k++ ) - { - if( k >= keylen ) k = 0; - - a = m[i]; - j = ( j + a + key[k] ) & 0xFF; - m[i] = m[j]; - m[j] = (unsigned char) a; - } -} - -/* - * ARC4 cipher function - */ -void arc4_crypt( arc4_context *ctx, unsigned char *buf, int buflen ) -{ - int i, x, y, a, b; - unsigned char *m; - - x = ctx->x; - y = ctx->y; - m = ctx->m; - - for( i = 0; i < buflen; i++ ) - { - x = ( x + 1 ) & 0xFF; a = m[x]; - y = ( y + a ) & 0xFF; b = m[y]; - - m[x] = (unsigned char) b; - m[y] = (unsigned char) a; - - buf[i] = (unsigned char) - ( buf[i] ^ m[(unsigned char)( a + b )] ); - } - - ctx->x = x; - ctx->y = y; -} - -#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_DES */ +/* + * An implementation of the ARCFOUR algorithm + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * The ARCFOUR algorithm was publicly disclosed on 94/09. + * + * http://groups.google.com/group/sci.crypt/msg/10a300c9d21afca0 + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_ARC4 + +#include "netif/ppp/polarssl/arc4.h" +/* + * ARC4 key schedule + */ +void arc4_setup( arc4_context *ctx, unsigned char *key, int keylen ) +{ + int i, j, k, a; + unsigned char *m; + + ctx->x = 0; + ctx->y = 0; + m = ctx->m; + + for( i = 0; i < 256; i++ ) + m[i] = (unsigned char) i; + + j = k = 0; + + for( i = 0; i < 256; i++, k++ ) + { + if( k >= keylen ) k = 0; + + a = m[i]; + j = ( j + a + key[k] ) & 0xFF; + m[i] = m[j]; + m[j] = (unsigned char) a; + } +} + +/* + * ARC4 cipher function + */ +void arc4_crypt( arc4_context *ctx, unsigned char *buf, int buflen ) +{ + int i, x, y, a, b; + unsigned char *m; + + x = ctx->x; + y = ctx->y; + m = ctx->m; + + for( i = 0; i < buflen; i++ ) + { + x = ( x + 1 ) & 0xFF; a = m[x]; + y = ( y + a ) & 0xFF; b = m[y]; + + m[x] = (unsigned char) b; + m[y] = (unsigned char) a; + + buf[i] = (unsigned char) + ( buf[i] ^ m[(unsigned char)( a + b )] ); + } + + ctx->x = x; + ctx->y = y; +} + +#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_DES */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/des.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/des.c index d5cbb33b..9a89d007 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/des.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/des.c @@ -1,422 +1,422 @@ -/* - * FIPS-46-3 compliant Triple-DES implementation - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * DES, on which TDES is based, was originally designed by Horst Feistel - * at IBM in 1974, and was adopted as a standard by NIST (formerly NBS). - * - * http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_DES - -#include "netif/ppp/polarssl/des.h" - -/* - * 32-bit integer manipulation macros (big endian) - */ -#ifndef GET_ULONG_BE -#define GET_ULONG_BE(n,b,i) \ -{ \ - (n) = ( (unsigned long) (b)[(i) ] << 24 ) \ - | ( (unsigned long) (b)[(i) + 1] << 16 ) \ - | ( (unsigned long) (b)[(i) + 2] << 8 ) \ - | ( (unsigned long) (b)[(i) + 3] ); \ -} -#endif - -#ifndef PUT_ULONG_BE -#define PUT_ULONG_BE(n,b,i) \ -{ \ - (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ - (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ - (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ - (b)[(i) + 3] = (unsigned char) ( (n) ); \ -} -#endif - -/* - * Expanded DES S-boxes - */ -static const unsigned long SB1[64] = -{ - 0x01010400, 0x00000000, 0x00010000, 0x01010404, - 0x01010004, 0x00010404, 0x00000004, 0x00010000, - 0x00000400, 0x01010400, 0x01010404, 0x00000400, - 0x01000404, 0x01010004, 0x01000000, 0x00000004, - 0x00000404, 0x01000400, 0x01000400, 0x00010400, - 0x00010400, 0x01010000, 0x01010000, 0x01000404, - 0x00010004, 0x01000004, 0x01000004, 0x00010004, - 0x00000000, 0x00000404, 0x00010404, 0x01000000, - 0x00010000, 0x01010404, 0x00000004, 0x01010000, - 0x01010400, 0x01000000, 0x01000000, 0x00000400, - 0x01010004, 0x00010000, 0x00010400, 0x01000004, - 0x00000400, 0x00000004, 0x01000404, 0x00010404, - 0x01010404, 0x00010004, 0x01010000, 0x01000404, - 0x01000004, 0x00000404, 0x00010404, 0x01010400, - 0x00000404, 0x01000400, 0x01000400, 0x00000000, - 0x00010004, 0x00010400, 0x00000000, 0x01010004 -}; - -static const unsigned long SB2[64] = -{ - 0x80108020, 0x80008000, 0x00008000, 0x00108020, - 0x00100000, 0x00000020, 0x80100020, 0x80008020, - 0x80000020, 0x80108020, 0x80108000, 0x80000000, - 0x80008000, 0x00100000, 0x00000020, 0x80100020, - 0x00108000, 0x00100020, 0x80008020, 0x00000000, - 0x80000000, 0x00008000, 0x00108020, 0x80100000, - 0x00100020, 0x80000020, 0x00000000, 0x00108000, - 0x00008020, 0x80108000, 0x80100000, 0x00008020, - 0x00000000, 0x00108020, 0x80100020, 0x00100000, - 0x80008020, 0x80100000, 0x80108000, 0x00008000, - 0x80100000, 0x80008000, 0x00000020, 0x80108020, - 0x00108020, 0x00000020, 0x00008000, 0x80000000, - 0x00008020, 0x80108000, 0x00100000, 0x80000020, - 0x00100020, 0x80008020, 0x80000020, 0x00100020, - 0x00108000, 0x00000000, 0x80008000, 0x00008020, - 0x80000000, 0x80100020, 0x80108020, 0x00108000 -}; - -static const unsigned long SB3[64] = -{ - 0x00000208, 0x08020200, 0x00000000, 0x08020008, - 0x08000200, 0x00000000, 0x00020208, 0x08000200, - 0x00020008, 0x08000008, 0x08000008, 0x00020000, - 0x08020208, 0x00020008, 0x08020000, 0x00000208, - 0x08000000, 0x00000008, 0x08020200, 0x00000200, - 0x00020200, 0x08020000, 0x08020008, 0x00020208, - 0x08000208, 0x00020200, 0x00020000, 0x08000208, - 0x00000008, 0x08020208, 0x00000200, 0x08000000, - 0x08020200, 0x08000000, 0x00020008, 0x00000208, - 0x00020000, 0x08020200, 0x08000200, 0x00000000, - 0x00000200, 0x00020008, 0x08020208, 0x08000200, - 0x08000008, 0x00000200, 0x00000000, 0x08020008, - 0x08000208, 0x00020000, 0x08000000, 0x08020208, - 0x00000008, 0x00020208, 0x00020200, 0x08000008, - 0x08020000, 0x08000208, 0x00000208, 0x08020000, - 0x00020208, 0x00000008, 0x08020008, 0x00020200 -}; - -static const unsigned long SB4[64] = -{ - 0x00802001, 0x00002081, 0x00002081, 0x00000080, - 0x00802080, 0x00800081, 0x00800001, 0x00002001, - 0x00000000, 0x00802000, 0x00802000, 0x00802081, - 0x00000081, 0x00000000, 0x00800080, 0x00800001, - 0x00000001, 0x00002000, 0x00800000, 0x00802001, - 0x00000080, 0x00800000, 0x00002001, 0x00002080, - 0x00800081, 0x00000001, 0x00002080, 0x00800080, - 0x00002000, 0x00802080, 0x00802081, 0x00000081, - 0x00800080, 0x00800001, 0x00802000, 0x00802081, - 0x00000081, 0x00000000, 0x00000000, 0x00802000, - 0x00002080, 0x00800080, 0x00800081, 0x00000001, - 0x00802001, 0x00002081, 0x00002081, 0x00000080, - 0x00802081, 0x00000081, 0x00000001, 0x00002000, - 0x00800001, 0x00002001, 0x00802080, 0x00800081, - 0x00002001, 0x00002080, 0x00800000, 0x00802001, - 0x00000080, 0x00800000, 0x00002000, 0x00802080 -}; - -static const unsigned long SB5[64] = -{ - 0x00000100, 0x02080100, 0x02080000, 0x42000100, - 0x00080000, 0x00000100, 0x40000000, 0x02080000, - 0x40080100, 0x00080000, 0x02000100, 0x40080100, - 0x42000100, 0x42080000, 0x00080100, 0x40000000, - 0x02000000, 0x40080000, 0x40080000, 0x00000000, - 0x40000100, 0x42080100, 0x42080100, 0x02000100, - 0x42080000, 0x40000100, 0x00000000, 0x42000000, - 0x02080100, 0x02000000, 0x42000000, 0x00080100, - 0x00080000, 0x42000100, 0x00000100, 0x02000000, - 0x40000000, 0x02080000, 0x42000100, 0x40080100, - 0x02000100, 0x40000000, 0x42080000, 0x02080100, - 0x40080100, 0x00000100, 0x02000000, 0x42080000, - 0x42080100, 0x00080100, 0x42000000, 0x42080100, - 0x02080000, 0x00000000, 0x40080000, 0x42000000, - 0x00080100, 0x02000100, 0x40000100, 0x00080000, - 0x00000000, 0x40080000, 0x02080100, 0x40000100 -}; - -static const unsigned long SB6[64] = -{ - 0x20000010, 0x20400000, 0x00004000, 0x20404010, - 0x20400000, 0x00000010, 0x20404010, 0x00400000, - 0x20004000, 0x00404010, 0x00400000, 0x20000010, - 0x00400010, 0x20004000, 0x20000000, 0x00004010, - 0x00000000, 0x00400010, 0x20004010, 0x00004000, - 0x00404000, 0x20004010, 0x00000010, 0x20400010, - 0x20400010, 0x00000000, 0x00404010, 0x20404000, - 0x00004010, 0x00404000, 0x20404000, 0x20000000, - 0x20004000, 0x00000010, 0x20400010, 0x00404000, - 0x20404010, 0x00400000, 0x00004010, 0x20000010, - 0x00400000, 0x20004000, 0x20000000, 0x00004010, - 0x20000010, 0x20404010, 0x00404000, 0x20400000, - 0x00404010, 0x20404000, 0x00000000, 0x20400010, - 0x00000010, 0x00004000, 0x20400000, 0x00404010, - 0x00004000, 0x00400010, 0x20004010, 0x00000000, - 0x20404000, 0x20000000, 0x00400010, 0x20004010 -}; - -static const unsigned long SB7[64] = -{ - 0x00200000, 0x04200002, 0x04000802, 0x00000000, - 0x00000800, 0x04000802, 0x00200802, 0x04200800, - 0x04200802, 0x00200000, 0x00000000, 0x04000002, - 0x00000002, 0x04000000, 0x04200002, 0x00000802, - 0x04000800, 0x00200802, 0x00200002, 0x04000800, - 0x04000002, 0x04200000, 0x04200800, 0x00200002, - 0x04200000, 0x00000800, 0x00000802, 0x04200802, - 0x00200800, 0x00000002, 0x04000000, 0x00200800, - 0x04000000, 0x00200800, 0x00200000, 0x04000802, - 0x04000802, 0x04200002, 0x04200002, 0x00000002, - 0x00200002, 0x04000000, 0x04000800, 0x00200000, - 0x04200800, 0x00000802, 0x00200802, 0x04200800, - 0x00000802, 0x04000002, 0x04200802, 0x04200000, - 0x00200800, 0x00000000, 0x00000002, 0x04200802, - 0x00000000, 0x00200802, 0x04200000, 0x00000800, - 0x04000002, 0x04000800, 0x00000800, 0x00200002 -}; - -static const unsigned long SB8[64] = -{ - 0x10001040, 0x00001000, 0x00040000, 0x10041040, - 0x10000000, 0x10001040, 0x00000040, 0x10000000, - 0x00040040, 0x10040000, 0x10041040, 0x00041000, - 0x10041000, 0x00041040, 0x00001000, 0x00000040, - 0x10040000, 0x10000040, 0x10001000, 0x00001040, - 0x00041000, 0x00040040, 0x10040040, 0x10041000, - 0x00001040, 0x00000000, 0x00000000, 0x10040040, - 0x10000040, 0x10001000, 0x00041040, 0x00040000, - 0x00041040, 0x00040000, 0x10041000, 0x00001000, - 0x00000040, 0x10040040, 0x00001000, 0x00041040, - 0x10001000, 0x00000040, 0x10000040, 0x10040000, - 0x10040040, 0x10000000, 0x00040000, 0x10001040, - 0x00000000, 0x10041040, 0x00040040, 0x10000040, - 0x10040000, 0x10001000, 0x10001040, 0x00000000, - 0x10041040, 0x00041000, 0x00041000, 0x00001040, - 0x00001040, 0x00040040, 0x10000000, 0x10041000 -}; - -/* - * PC1: left and right halves bit-swap - */ -static const unsigned long LHs[16] = -{ - 0x00000000, 0x00000001, 0x00000100, 0x00000101, - 0x00010000, 0x00010001, 0x00010100, 0x00010101, - 0x01000000, 0x01000001, 0x01000100, 0x01000101, - 0x01010000, 0x01010001, 0x01010100, 0x01010101 -}; - -static const unsigned long RHs[16] = -{ - 0x00000000, 0x01000000, 0x00010000, 0x01010000, - 0x00000100, 0x01000100, 0x00010100, 0x01010100, - 0x00000001, 0x01000001, 0x00010001, 0x01010001, - 0x00000101, 0x01000101, 0x00010101, 0x01010101, -}; - -/* - * Initial Permutation macro - */ -#define DES_IP(X,Y) \ -{ \ - T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \ - T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \ - T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \ - T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \ - Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF; \ - T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \ - X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF; \ -} - -/* - * Final Permutation macro - */ -#define DES_FP(X,Y) \ -{ \ - X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF; \ - T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \ - Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF; \ - T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \ - T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \ - T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \ - T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \ -} - -/* - * DES round macro - */ -#define DES_ROUND(X,Y) \ -{ \ - T = *SK++ ^ X; \ - Y ^= SB8[ (T ) & 0x3F ] ^ \ - SB6[ (T >> 8) & 0x3F ] ^ \ - SB4[ (T >> 16) & 0x3F ] ^ \ - SB2[ (T >> 24) & 0x3F ]; \ - \ - T = *SK++ ^ ((X << 28) | (X >> 4)); \ - Y ^= SB7[ (T ) & 0x3F ] ^ \ - SB5[ (T >> 8) & 0x3F ] ^ \ - SB3[ (T >> 16) & 0x3F ] ^ \ - SB1[ (T >> 24) & 0x3F ]; \ -} - -#define SWAP(a,b) { unsigned long t = a; a = b; b = t; t = 0; } - -static void des_setkey( unsigned long SK[32], unsigned char key[8] ) -{ - int i; - unsigned long X, Y, T; - - GET_ULONG_BE( X, key, 0 ); - GET_ULONG_BE( Y, key, 4 ); - - /* - * Permuted Choice 1 - */ - T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4); - T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T ); - - X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2) - | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] ) - | (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6) - | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4); - - Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2) - | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] ) - | (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6) - | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4); - - X &= 0x0FFFFFFF; - Y &= 0x0FFFFFFF; - - /* - * calculate subkeys - */ - for( i = 0; i < 16; i++ ) - { - if( i < 2 || i == 8 || i == 15 ) - { - X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF; - Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF; - } - else - { - X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF; - Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF; - } - - *SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000) - | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000) - | ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000) - | ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000) - | ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000) - | ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000) - | ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400) - | ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100) - | ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010) - | ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004) - | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001); - - *SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000) - | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000) - | ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000) - | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000) - | ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000) - | ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000) - | ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000) - | ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400) - | ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100) - | ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011) - | ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002); - } -} - -/* - * DES key schedule (56-bit, encryption) - */ -void des_setkey_enc( des_context *ctx, unsigned char key[8] ) -{ - des_setkey( ctx->sk, key ); -} - -/* - * DES key schedule (56-bit, decryption) - */ -void des_setkey_dec( des_context *ctx, unsigned char key[8] ) -{ - int i; - - des_setkey( ctx->sk, key ); - - for( i = 0; i < 16; i += 2 ) - { - SWAP( ctx->sk[i ], ctx->sk[30 - i] ); - SWAP( ctx->sk[i + 1], ctx->sk[31 - i] ); - } -} - -/* - * DES-ECB block encryption/decryption - */ -void des_crypt_ecb( des_context *ctx, - const unsigned char input[8], - unsigned char output[8] ) -{ - int i; - unsigned long X, Y, T, *SK; - - SK = ctx->sk; - - GET_ULONG_BE( X, input, 0 ); - GET_ULONG_BE( Y, input, 4 ); - - DES_IP( X, Y ); - - for( i = 0; i < 8; i++ ) - { - DES_ROUND( Y, X ); - DES_ROUND( X, Y ); - } - - DES_FP( Y, X ); - - PUT_ULONG_BE( Y, output, 0 ); - PUT_ULONG_BE( X, output, 4 ); -} - -#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_DES */ +/* + * FIPS-46-3 compliant Triple-DES implementation + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * DES, on which TDES is based, was originally designed by Horst Feistel + * at IBM in 1974, and was adopted as a standard by NIST (formerly NBS). + * + * http://csrc.nist.gov/publications/fips/fips46-3/fips46-3.pdf + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_DES + +#include "netif/ppp/polarssl/des.h" + +/* + * 32-bit integer manipulation macros (big endian) + */ +#ifndef GET_ULONG_BE +#define GET_ULONG_BE(n,b,i) \ +{ \ + (n) = ( (unsigned long) (b)[(i) ] << 24 ) \ + | ( (unsigned long) (b)[(i) + 1] << 16 ) \ + | ( (unsigned long) (b)[(i) + 2] << 8 ) \ + | ( (unsigned long) (b)[(i) + 3] ); \ +} +#endif + +#ifndef PUT_ULONG_BE +#define PUT_ULONG_BE(n,b,i) \ +{ \ + (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ + (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ + (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ + (b)[(i) + 3] = (unsigned char) ( (n) ); \ +} +#endif + +/* + * Expanded DES S-boxes + */ +static const unsigned long SB1[64] = +{ + 0x01010400, 0x00000000, 0x00010000, 0x01010404, + 0x01010004, 0x00010404, 0x00000004, 0x00010000, + 0x00000400, 0x01010400, 0x01010404, 0x00000400, + 0x01000404, 0x01010004, 0x01000000, 0x00000004, + 0x00000404, 0x01000400, 0x01000400, 0x00010400, + 0x00010400, 0x01010000, 0x01010000, 0x01000404, + 0x00010004, 0x01000004, 0x01000004, 0x00010004, + 0x00000000, 0x00000404, 0x00010404, 0x01000000, + 0x00010000, 0x01010404, 0x00000004, 0x01010000, + 0x01010400, 0x01000000, 0x01000000, 0x00000400, + 0x01010004, 0x00010000, 0x00010400, 0x01000004, + 0x00000400, 0x00000004, 0x01000404, 0x00010404, + 0x01010404, 0x00010004, 0x01010000, 0x01000404, + 0x01000004, 0x00000404, 0x00010404, 0x01010400, + 0x00000404, 0x01000400, 0x01000400, 0x00000000, + 0x00010004, 0x00010400, 0x00000000, 0x01010004 +}; + +static const unsigned long SB2[64] = +{ + 0x80108020, 0x80008000, 0x00008000, 0x00108020, + 0x00100000, 0x00000020, 0x80100020, 0x80008020, + 0x80000020, 0x80108020, 0x80108000, 0x80000000, + 0x80008000, 0x00100000, 0x00000020, 0x80100020, + 0x00108000, 0x00100020, 0x80008020, 0x00000000, + 0x80000000, 0x00008000, 0x00108020, 0x80100000, + 0x00100020, 0x80000020, 0x00000000, 0x00108000, + 0x00008020, 0x80108000, 0x80100000, 0x00008020, + 0x00000000, 0x00108020, 0x80100020, 0x00100000, + 0x80008020, 0x80100000, 0x80108000, 0x00008000, + 0x80100000, 0x80008000, 0x00000020, 0x80108020, + 0x00108020, 0x00000020, 0x00008000, 0x80000000, + 0x00008020, 0x80108000, 0x00100000, 0x80000020, + 0x00100020, 0x80008020, 0x80000020, 0x00100020, + 0x00108000, 0x00000000, 0x80008000, 0x00008020, + 0x80000000, 0x80100020, 0x80108020, 0x00108000 +}; + +static const unsigned long SB3[64] = +{ + 0x00000208, 0x08020200, 0x00000000, 0x08020008, + 0x08000200, 0x00000000, 0x00020208, 0x08000200, + 0x00020008, 0x08000008, 0x08000008, 0x00020000, + 0x08020208, 0x00020008, 0x08020000, 0x00000208, + 0x08000000, 0x00000008, 0x08020200, 0x00000200, + 0x00020200, 0x08020000, 0x08020008, 0x00020208, + 0x08000208, 0x00020200, 0x00020000, 0x08000208, + 0x00000008, 0x08020208, 0x00000200, 0x08000000, + 0x08020200, 0x08000000, 0x00020008, 0x00000208, + 0x00020000, 0x08020200, 0x08000200, 0x00000000, + 0x00000200, 0x00020008, 0x08020208, 0x08000200, + 0x08000008, 0x00000200, 0x00000000, 0x08020008, + 0x08000208, 0x00020000, 0x08000000, 0x08020208, + 0x00000008, 0x00020208, 0x00020200, 0x08000008, + 0x08020000, 0x08000208, 0x00000208, 0x08020000, + 0x00020208, 0x00000008, 0x08020008, 0x00020200 +}; + +static const unsigned long SB4[64] = +{ + 0x00802001, 0x00002081, 0x00002081, 0x00000080, + 0x00802080, 0x00800081, 0x00800001, 0x00002001, + 0x00000000, 0x00802000, 0x00802000, 0x00802081, + 0x00000081, 0x00000000, 0x00800080, 0x00800001, + 0x00000001, 0x00002000, 0x00800000, 0x00802001, + 0x00000080, 0x00800000, 0x00002001, 0x00002080, + 0x00800081, 0x00000001, 0x00002080, 0x00800080, + 0x00002000, 0x00802080, 0x00802081, 0x00000081, + 0x00800080, 0x00800001, 0x00802000, 0x00802081, + 0x00000081, 0x00000000, 0x00000000, 0x00802000, + 0x00002080, 0x00800080, 0x00800081, 0x00000001, + 0x00802001, 0x00002081, 0x00002081, 0x00000080, + 0x00802081, 0x00000081, 0x00000001, 0x00002000, + 0x00800001, 0x00002001, 0x00802080, 0x00800081, + 0x00002001, 0x00002080, 0x00800000, 0x00802001, + 0x00000080, 0x00800000, 0x00002000, 0x00802080 +}; + +static const unsigned long SB5[64] = +{ + 0x00000100, 0x02080100, 0x02080000, 0x42000100, + 0x00080000, 0x00000100, 0x40000000, 0x02080000, + 0x40080100, 0x00080000, 0x02000100, 0x40080100, + 0x42000100, 0x42080000, 0x00080100, 0x40000000, + 0x02000000, 0x40080000, 0x40080000, 0x00000000, + 0x40000100, 0x42080100, 0x42080100, 0x02000100, + 0x42080000, 0x40000100, 0x00000000, 0x42000000, + 0x02080100, 0x02000000, 0x42000000, 0x00080100, + 0x00080000, 0x42000100, 0x00000100, 0x02000000, + 0x40000000, 0x02080000, 0x42000100, 0x40080100, + 0x02000100, 0x40000000, 0x42080000, 0x02080100, + 0x40080100, 0x00000100, 0x02000000, 0x42080000, + 0x42080100, 0x00080100, 0x42000000, 0x42080100, + 0x02080000, 0x00000000, 0x40080000, 0x42000000, + 0x00080100, 0x02000100, 0x40000100, 0x00080000, + 0x00000000, 0x40080000, 0x02080100, 0x40000100 +}; + +static const unsigned long SB6[64] = +{ + 0x20000010, 0x20400000, 0x00004000, 0x20404010, + 0x20400000, 0x00000010, 0x20404010, 0x00400000, + 0x20004000, 0x00404010, 0x00400000, 0x20000010, + 0x00400010, 0x20004000, 0x20000000, 0x00004010, + 0x00000000, 0x00400010, 0x20004010, 0x00004000, + 0x00404000, 0x20004010, 0x00000010, 0x20400010, + 0x20400010, 0x00000000, 0x00404010, 0x20404000, + 0x00004010, 0x00404000, 0x20404000, 0x20000000, + 0x20004000, 0x00000010, 0x20400010, 0x00404000, + 0x20404010, 0x00400000, 0x00004010, 0x20000010, + 0x00400000, 0x20004000, 0x20000000, 0x00004010, + 0x20000010, 0x20404010, 0x00404000, 0x20400000, + 0x00404010, 0x20404000, 0x00000000, 0x20400010, + 0x00000010, 0x00004000, 0x20400000, 0x00404010, + 0x00004000, 0x00400010, 0x20004010, 0x00000000, + 0x20404000, 0x20000000, 0x00400010, 0x20004010 +}; + +static const unsigned long SB7[64] = +{ + 0x00200000, 0x04200002, 0x04000802, 0x00000000, + 0x00000800, 0x04000802, 0x00200802, 0x04200800, + 0x04200802, 0x00200000, 0x00000000, 0x04000002, + 0x00000002, 0x04000000, 0x04200002, 0x00000802, + 0x04000800, 0x00200802, 0x00200002, 0x04000800, + 0x04000002, 0x04200000, 0x04200800, 0x00200002, + 0x04200000, 0x00000800, 0x00000802, 0x04200802, + 0x00200800, 0x00000002, 0x04000000, 0x00200800, + 0x04000000, 0x00200800, 0x00200000, 0x04000802, + 0x04000802, 0x04200002, 0x04200002, 0x00000002, + 0x00200002, 0x04000000, 0x04000800, 0x00200000, + 0x04200800, 0x00000802, 0x00200802, 0x04200800, + 0x00000802, 0x04000002, 0x04200802, 0x04200000, + 0x00200800, 0x00000000, 0x00000002, 0x04200802, + 0x00000000, 0x00200802, 0x04200000, 0x00000800, + 0x04000002, 0x04000800, 0x00000800, 0x00200002 +}; + +static const unsigned long SB8[64] = +{ + 0x10001040, 0x00001000, 0x00040000, 0x10041040, + 0x10000000, 0x10001040, 0x00000040, 0x10000000, + 0x00040040, 0x10040000, 0x10041040, 0x00041000, + 0x10041000, 0x00041040, 0x00001000, 0x00000040, + 0x10040000, 0x10000040, 0x10001000, 0x00001040, + 0x00041000, 0x00040040, 0x10040040, 0x10041000, + 0x00001040, 0x00000000, 0x00000000, 0x10040040, + 0x10000040, 0x10001000, 0x00041040, 0x00040000, + 0x00041040, 0x00040000, 0x10041000, 0x00001000, + 0x00000040, 0x10040040, 0x00001000, 0x00041040, + 0x10001000, 0x00000040, 0x10000040, 0x10040000, + 0x10040040, 0x10000000, 0x00040000, 0x10001040, + 0x00000000, 0x10041040, 0x00040040, 0x10000040, + 0x10040000, 0x10001000, 0x10001040, 0x00000000, + 0x10041040, 0x00041000, 0x00041000, 0x00001040, + 0x00001040, 0x00040040, 0x10000000, 0x10041000 +}; + +/* + * PC1: left and right halves bit-swap + */ +static const unsigned long LHs[16] = +{ + 0x00000000, 0x00000001, 0x00000100, 0x00000101, + 0x00010000, 0x00010001, 0x00010100, 0x00010101, + 0x01000000, 0x01000001, 0x01000100, 0x01000101, + 0x01010000, 0x01010001, 0x01010100, 0x01010101 +}; + +static const unsigned long RHs[16] = +{ + 0x00000000, 0x01000000, 0x00010000, 0x01010000, + 0x00000100, 0x01000100, 0x00010100, 0x01010100, + 0x00000001, 0x01000001, 0x00010001, 0x01010001, + 0x00000101, 0x01000101, 0x00010101, 0x01010101, +}; + +/* + * Initial Permutation macro + */ +#define DES_IP(X,Y) \ +{ \ + T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \ + T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \ + T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \ + T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \ + Y = ((Y << 1) | (Y >> 31)) & 0xFFFFFFFF; \ + T = (X ^ Y) & 0xAAAAAAAA; Y ^= T; X ^= T; \ + X = ((X << 1) | (X >> 31)) & 0xFFFFFFFF; \ +} + +/* + * Final Permutation macro + */ +#define DES_FP(X,Y) \ +{ \ + X = ((X << 31) | (X >> 1)) & 0xFFFFFFFF; \ + T = (X ^ Y) & 0xAAAAAAAA; X ^= T; Y ^= T; \ + Y = ((Y << 31) | (Y >> 1)) & 0xFFFFFFFF; \ + T = ((Y >> 8) ^ X) & 0x00FF00FF; X ^= T; Y ^= (T << 8); \ + T = ((Y >> 2) ^ X) & 0x33333333; X ^= T; Y ^= (T << 2); \ + T = ((X >> 16) ^ Y) & 0x0000FFFF; Y ^= T; X ^= (T << 16); \ + T = ((X >> 4) ^ Y) & 0x0F0F0F0F; Y ^= T; X ^= (T << 4); \ +} + +/* + * DES round macro + */ +#define DES_ROUND(X,Y) \ +{ \ + T = *SK++ ^ X; \ + Y ^= SB8[ (T ) & 0x3F ] ^ \ + SB6[ (T >> 8) & 0x3F ] ^ \ + SB4[ (T >> 16) & 0x3F ] ^ \ + SB2[ (T >> 24) & 0x3F ]; \ + \ + T = *SK++ ^ ((X << 28) | (X >> 4)); \ + Y ^= SB7[ (T ) & 0x3F ] ^ \ + SB5[ (T >> 8) & 0x3F ] ^ \ + SB3[ (T >> 16) & 0x3F ] ^ \ + SB1[ (T >> 24) & 0x3F ]; \ +} + +#define SWAP(a,b) { unsigned long t = a; a = b; b = t; t = 0; } + +static void des_setkey( unsigned long SK[32], unsigned char key[8] ) +{ + int i; + unsigned long X, Y, T; + + GET_ULONG_BE( X, key, 0 ); + GET_ULONG_BE( Y, key, 4 ); + + /* + * Permuted Choice 1 + */ + T = ((Y >> 4) ^ X) & 0x0F0F0F0F; X ^= T; Y ^= (T << 4); + T = ((Y ) ^ X) & 0x10101010; X ^= T; Y ^= (T ); + + X = (LHs[ (X ) & 0xF] << 3) | (LHs[ (X >> 8) & 0xF ] << 2) + | (LHs[ (X >> 16) & 0xF] << 1) | (LHs[ (X >> 24) & 0xF ] ) + | (LHs[ (X >> 5) & 0xF] << 7) | (LHs[ (X >> 13) & 0xF ] << 6) + | (LHs[ (X >> 21) & 0xF] << 5) | (LHs[ (X >> 29) & 0xF ] << 4); + + Y = (RHs[ (Y >> 1) & 0xF] << 3) | (RHs[ (Y >> 9) & 0xF ] << 2) + | (RHs[ (Y >> 17) & 0xF] << 1) | (RHs[ (Y >> 25) & 0xF ] ) + | (RHs[ (Y >> 4) & 0xF] << 7) | (RHs[ (Y >> 12) & 0xF ] << 6) + | (RHs[ (Y >> 20) & 0xF] << 5) | (RHs[ (Y >> 28) & 0xF ] << 4); + + X &= 0x0FFFFFFF; + Y &= 0x0FFFFFFF; + + /* + * calculate subkeys + */ + for( i = 0; i < 16; i++ ) + { + if( i < 2 || i == 8 || i == 15 ) + { + X = ((X << 1) | (X >> 27)) & 0x0FFFFFFF; + Y = ((Y << 1) | (Y >> 27)) & 0x0FFFFFFF; + } + else + { + X = ((X << 2) | (X >> 26)) & 0x0FFFFFFF; + Y = ((Y << 2) | (Y >> 26)) & 0x0FFFFFFF; + } + + *SK++ = ((X << 4) & 0x24000000) | ((X << 28) & 0x10000000) + | ((X << 14) & 0x08000000) | ((X << 18) & 0x02080000) + | ((X << 6) & 0x01000000) | ((X << 9) & 0x00200000) + | ((X >> 1) & 0x00100000) | ((X << 10) & 0x00040000) + | ((X << 2) & 0x00020000) | ((X >> 10) & 0x00010000) + | ((Y >> 13) & 0x00002000) | ((Y >> 4) & 0x00001000) + | ((Y << 6) & 0x00000800) | ((Y >> 1) & 0x00000400) + | ((Y >> 14) & 0x00000200) | ((Y ) & 0x00000100) + | ((Y >> 5) & 0x00000020) | ((Y >> 10) & 0x00000010) + | ((Y >> 3) & 0x00000008) | ((Y >> 18) & 0x00000004) + | ((Y >> 26) & 0x00000002) | ((Y >> 24) & 0x00000001); + + *SK++ = ((X << 15) & 0x20000000) | ((X << 17) & 0x10000000) + | ((X << 10) & 0x08000000) | ((X << 22) & 0x04000000) + | ((X >> 2) & 0x02000000) | ((X << 1) & 0x01000000) + | ((X << 16) & 0x00200000) | ((X << 11) & 0x00100000) + | ((X << 3) & 0x00080000) | ((X >> 6) & 0x00040000) + | ((X << 15) & 0x00020000) | ((X >> 4) & 0x00010000) + | ((Y >> 2) & 0x00002000) | ((Y << 8) & 0x00001000) + | ((Y >> 14) & 0x00000808) | ((Y >> 9) & 0x00000400) + | ((Y ) & 0x00000200) | ((Y << 7) & 0x00000100) + | ((Y >> 7) & 0x00000020) | ((Y >> 3) & 0x00000011) + | ((Y << 2) & 0x00000004) | ((Y >> 21) & 0x00000002); + } +} + +/* + * DES key schedule (56-bit, encryption) + */ +void des_setkey_enc( des_context *ctx, unsigned char key[8] ) +{ + des_setkey( ctx->sk, key ); +} + +/* + * DES key schedule (56-bit, decryption) + */ +void des_setkey_dec( des_context *ctx, unsigned char key[8] ) +{ + int i; + + des_setkey( ctx->sk, key ); + + for( i = 0; i < 16; i += 2 ) + { + SWAP( ctx->sk[i ], ctx->sk[30 - i] ); + SWAP( ctx->sk[i + 1], ctx->sk[31 - i] ); + } +} + +/* + * DES-ECB block encryption/decryption + */ +void des_crypt_ecb( des_context *ctx, + const unsigned char input[8], + unsigned char output[8] ) +{ + int i; + unsigned long X, Y, T, *SK; + + SK = ctx->sk; + + GET_ULONG_BE( X, input, 0 ); + GET_ULONG_BE( Y, input, 4 ); + + DES_IP( X, Y ); + + for( i = 0; i < 8; i++ ) + { + DES_ROUND( Y, X ); + DES_ROUND( X, Y ); + } + + DES_FP( Y, X ); + + PUT_ULONG_BE( Y, output, 0 ); + PUT_ULONG_BE( X, output, 4 ); +} + +#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_DES */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md4.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md4.c index 2bb63865..b1701a07 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md4.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md4.c @@ -1,281 +1,281 @@ -/* - * RFC 1186/1320 compliant MD4 implementation - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * The MD4 algorithm was designed by Ron Rivest in 1990. - * - * http://www.ietf.org/rfc/rfc1186.txt - * http://www.ietf.org/rfc/rfc1320.txt - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD4 - -#include "netif/ppp/polarssl/md4.h" - -#include - -/* - * 32-bit integer manipulation macros (little endian) - */ -#ifndef GET_ULONG_LE -#define GET_ULONG_LE(n,b,i) \ -{ \ - (n) = ( (unsigned long) (b)[(i) ] ) \ - | ( (unsigned long) (b)[(i) + 1] << 8 ) \ - | ( (unsigned long) (b)[(i) + 2] << 16 ) \ - | ( (unsigned long) (b)[(i) + 3] << 24 ); \ -} -#endif - -#ifndef PUT_ULONG_LE -#define PUT_ULONG_LE(n,b,i) \ -{ \ - (b)[(i) ] = (unsigned char) ( (n) ); \ - (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \ - (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \ - (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \ -} -#endif - -/* - * MD4 context setup - */ -void md4_starts( md4_context *ctx ) -{ - ctx->total[0] = 0; - ctx->total[1] = 0; - - ctx->state[0] = 0x67452301; - ctx->state[1] = 0xEFCDAB89; - ctx->state[2] = 0x98BADCFE; - ctx->state[3] = 0x10325476; -} - -static void md4_process( md4_context *ctx, const unsigned char data[64] ) -{ - unsigned long X[16], A, B, C, D; - - GET_ULONG_LE( X[ 0], data, 0 ); - GET_ULONG_LE( X[ 1], data, 4 ); - GET_ULONG_LE( X[ 2], data, 8 ); - GET_ULONG_LE( X[ 3], data, 12 ); - GET_ULONG_LE( X[ 4], data, 16 ); - GET_ULONG_LE( X[ 5], data, 20 ); - GET_ULONG_LE( X[ 6], data, 24 ); - GET_ULONG_LE( X[ 7], data, 28 ); - GET_ULONG_LE( X[ 8], data, 32 ); - GET_ULONG_LE( X[ 9], data, 36 ); - GET_ULONG_LE( X[10], data, 40 ); - GET_ULONG_LE( X[11], data, 44 ); - GET_ULONG_LE( X[12], data, 48 ); - GET_ULONG_LE( X[13], data, 52 ); - GET_ULONG_LE( X[14], data, 56 ); - GET_ULONG_LE( X[15], data, 60 ); - -#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) - - A = ctx->state[0]; - B = ctx->state[1]; - C = ctx->state[2]; - D = ctx->state[3]; - -#define F(x, y, z) ((x & y) | ((~x) & z)) -#define P(a,b,c,d,x,s) { a += F(b,c,d) + x; a = S(a,s); } - - P( A, B, C, D, X[ 0], 3 ); - P( D, A, B, C, X[ 1], 7 ); - P( C, D, A, B, X[ 2], 11 ); - P( B, C, D, A, X[ 3], 19 ); - P( A, B, C, D, X[ 4], 3 ); - P( D, A, B, C, X[ 5], 7 ); - P( C, D, A, B, X[ 6], 11 ); - P( B, C, D, A, X[ 7], 19 ); - P( A, B, C, D, X[ 8], 3 ); - P( D, A, B, C, X[ 9], 7 ); - P( C, D, A, B, X[10], 11 ); - P( B, C, D, A, X[11], 19 ); - P( A, B, C, D, X[12], 3 ); - P( D, A, B, C, X[13], 7 ); - P( C, D, A, B, X[14], 11 ); - P( B, C, D, A, X[15], 19 ); - -#undef P -#undef F - -#define F(x,y,z) ((x & y) | (x & z) | (y & z)) -#define P(a,b,c,d,x,s) { a += F(b,c,d) + x + 0x5A827999; a = S(a,s); } - - P( A, B, C, D, X[ 0], 3 ); - P( D, A, B, C, X[ 4], 5 ); - P( C, D, A, B, X[ 8], 9 ); - P( B, C, D, A, X[12], 13 ); - P( A, B, C, D, X[ 1], 3 ); - P( D, A, B, C, X[ 5], 5 ); - P( C, D, A, B, X[ 9], 9 ); - P( B, C, D, A, X[13], 13 ); - P( A, B, C, D, X[ 2], 3 ); - P( D, A, B, C, X[ 6], 5 ); - P( C, D, A, B, X[10], 9 ); - P( B, C, D, A, X[14], 13 ); - P( A, B, C, D, X[ 3], 3 ); - P( D, A, B, C, X[ 7], 5 ); - P( C, D, A, B, X[11], 9 ); - P( B, C, D, A, X[15], 13 ); - -#undef P -#undef F - -#define F(x,y,z) (x ^ y ^ z) -#define P(a,b,c,d,x,s) { a += F(b,c,d) + x + 0x6ED9EBA1; a = S(a,s); } - - P( A, B, C, D, X[ 0], 3 ); - P( D, A, B, C, X[ 8], 9 ); - P( C, D, A, B, X[ 4], 11 ); - P( B, C, D, A, X[12], 15 ); - P( A, B, C, D, X[ 2], 3 ); - P( D, A, B, C, X[10], 9 ); - P( C, D, A, B, X[ 6], 11 ); - P( B, C, D, A, X[14], 15 ); - P( A, B, C, D, X[ 1], 3 ); - P( D, A, B, C, X[ 9], 9 ); - P( C, D, A, B, X[ 5], 11 ); - P( B, C, D, A, X[13], 15 ); - P( A, B, C, D, X[ 3], 3 ); - P( D, A, B, C, X[11], 9 ); - P( C, D, A, B, X[ 7], 11 ); - P( B, C, D, A, X[15], 15 ); - -#undef F -#undef P - - ctx->state[0] += A; - ctx->state[1] += B; - ctx->state[2] += C; - ctx->state[3] += D; -} - -/* - * MD4 process buffer - */ -void md4_update( md4_context *ctx, const unsigned char *input, int ilen ) -{ - int fill; - unsigned long left; - - if( ilen <= 0 ) - return; - - left = ctx->total[0] & 0x3F; - fill = 64 - left; - - ctx->total[0] += ilen; - ctx->total[0] &= 0xFFFFFFFF; - - if( ctx->total[0] < (unsigned long) ilen ) - ctx->total[1]++; - - if( left && ilen >= fill ) - { - MEMCPY( (void *) (ctx->buffer + left), - input, fill ); - md4_process( ctx, ctx->buffer ); - input += fill; - ilen -= fill; - left = 0; - } - - while( ilen >= 64 ) - { - md4_process( ctx, input ); - input += 64; - ilen -= 64; - } - - if( ilen > 0 ) - { - MEMCPY( (void *) (ctx->buffer + left), - input, ilen ); - } -} - -static const unsigned char md4_padding[64] = -{ - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - -/* - * MD4 final digest - */ -void md4_finish( md4_context *ctx, unsigned char output[16] ) -{ - unsigned long last, padn; - unsigned long high, low; - unsigned char msglen[8]; - - high = ( ctx->total[0] >> 29 ) - | ( ctx->total[1] << 3 ); - low = ( ctx->total[0] << 3 ); - - PUT_ULONG_LE( low, msglen, 0 ); - PUT_ULONG_LE( high, msglen, 4 ); - - last = ctx->total[0] & 0x3F; - padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); - - md4_update( ctx, md4_padding, padn ); - md4_update( ctx, msglen, 8 ); - - PUT_ULONG_LE( ctx->state[0], output, 0 ); - PUT_ULONG_LE( ctx->state[1], output, 4 ); - PUT_ULONG_LE( ctx->state[2], output, 8 ); - PUT_ULONG_LE( ctx->state[3], output, 12 ); -} - -/* - * output = MD4( input buffer ) - */ -void md4( unsigned char *input, int ilen, unsigned char output[16] ) -{ - md4_context ctx; - - md4_starts( &ctx ); - md4_update( &ctx, input, ilen ); - md4_finish( &ctx, output ); -} - -#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD4 */ +/* + * RFC 1186/1320 compliant MD4 implementation + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * The MD4 algorithm was designed by Ron Rivest in 1990. + * + * http://www.ietf.org/rfc/rfc1186.txt + * http://www.ietf.org/rfc/rfc1320.txt + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD4 + +#include "netif/ppp/polarssl/md4.h" + +#include + +/* + * 32-bit integer manipulation macros (little endian) + */ +#ifndef GET_ULONG_LE +#define GET_ULONG_LE(n,b,i) \ +{ \ + (n) = ( (unsigned long) (b)[(i) ] ) \ + | ( (unsigned long) (b)[(i) + 1] << 8 ) \ + | ( (unsigned long) (b)[(i) + 2] << 16 ) \ + | ( (unsigned long) (b)[(i) + 3] << 24 ); \ +} +#endif + +#ifndef PUT_ULONG_LE +#define PUT_ULONG_LE(n,b,i) \ +{ \ + (b)[(i) ] = (unsigned char) ( (n) ); \ + (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \ + (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \ + (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \ +} +#endif + +/* + * MD4 context setup + */ +void md4_starts( md4_context *ctx ) +{ + ctx->total[0] = 0; + ctx->total[1] = 0; + + ctx->state[0] = 0x67452301; + ctx->state[1] = 0xEFCDAB89; + ctx->state[2] = 0x98BADCFE; + ctx->state[3] = 0x10325476; +} + +static void md4_process( md4_context *ctx, const unsigned char data[64] ) +{ + unsigned long X[16], A, B, C, D; + + GET_ULONG_LE( X[ 0], data, 0 ); + GET_ULONG_LE( X[ 1], data, 4 ); + GET_ULONG_LE( X[ 2], data, 8 ); + GET_ULONG_LE( X[ 3], data, 12 ); + GET_ULONG_LE( X[ 4], data, 16 ); + GET_ULONG_LE( X[ 5], data, 20 ); + GET_ULONG_LE( X[ 6], data, 24 ); + GET_ULONG_LE( X[ 7], data, 28 ); + GET_ULONG_LE( X[ 8], data, 32 ); + GET_ULONG_LE( X[ 9], data, 36 ); + GET_ULONG_LE( X[10], data, 40 ); + GET_ULONG_LE( X[11], data, 44 ); + GET_ULONG_LE( X[12], data, 48 ); + GET_ULONG_LE( X[13], data, 52 ); + GET_ULONG_LE( X[14], data, 56 ); + GET_ULONG_LE( X[15], data, 60 ); + +#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) + + A = ctx->state[0]; + B = ctx->state[1]; + C = ctx->state[2]; + D = ctx->state[3]; + +#define F(x, y, z) ((x & y) | ((~x) & z)) +#define P(a,b,c,d,x,s) { a += F(b,c,d) + x; a = S(a,s); } + + P( A, B, C, D, X[ 0], 3 ); + P( D, A, B, C, X[ 1], 7 ); + P( C, D, A, B, X[ 2], 11 ); + P( B, C, D, A, X[ 3], 19 ); + P( A, B, C, D, X[ 4], 3 ); + P( D, A, B, C, X[ 5], 7 ); + P( C, D, A, B, X[ 6], 11 ); + P( B, C, D, A, X[ 7], 19 ); + P( A, B, C, D, X[ 8], 3 ); + P( D, A, B, C, X[ 9], 7 ); + P( C, D, A, B, X[10], 11 ); + P( B, C, D, A, X[11], 19 ); + P( A, B, C, D, X[12], 3 ); + P( D, A, B, C, X[13], 7 ); + P( C, D, A, B, X[14], 11 ); + P( B, C, D, A, X[15], 19 ); + +#undef P +#undef F + +#define F(x,y,z) ((x & y) | (x & z) | (y & z)) +#define P(a,b,c,d,x,s) { a += F(b,c,d) + x + 0x5A827999; a = S(a,s); } + + P( A, B, C, D, X[ 0], 3 ); + P( D, A, B, C, X[ 4], 5 ); + P( C, D, A, B, X[ 8], 9 ); + P( B, C, D, A, X[12], 13 ); + P( A, B, C, D, X[ 1], 3 ); + P( D, A, B, C, X[ 5], 5 ); + P( C, D, A, B, X[ 9], 9 ); + P( B, C, D, A, X[13], 13 ); + P( A, B, C, D, X[ 2], 3 ); + P( D, A, B, C, X[ 6], 5 ); + P( C, D, A, B, X[10], 9 ); + P( B, C, D, A, X[14], 13 ); + P( A, B, C, D, X[ 3], 3 ); + P( D, A, B, C, X[ 7], 5 ); + P( C, D, A, B, X[11], 9 ); + P( B, C, D, A, X[15], 13 ); + +#undef P +#undef F + +#define F(x,y,z) (x ^ y ^ z) +#define P(a,b,c,d,x,s) { a += F(b,c,d) + x + 0x6ED9EBA1; a = S(a,s); } + + P( A, B, C, D, X[ 0], 3 ); + P( D, A, B, C, X[ 8], 9 ); + P( C, D, A, B, X[ 4], 11 ); + P( B, C, D, A, X[12], 15 ); + P( A, B, C, D, X[ 2], 3 ); + P( D, A, B, C, X[10], 9 ); + P( C, D, A, B, X[ 6], 11 ); + P( B, C, D, A, X[14], 15 ); + P( A, B, C, D, X[ 1], 3 ); + P( D, A, B, C, X[ 9], 9 ); + P( C, D, A, B, X[ 5], 11 ); + P( B, C, D, A, X[13], 15 ); + P( A, B, C, D, X[ 3], 3 ); + P( D, A, B, C, X[11], 9 ); + P( C, D, A, B, X[ 7], 11 ); + P( B, C, D, A, X[15], 15 ); + +#undef F +#undef P + + ctx->state[0] += A; + ctx->state[1] += B; + ctx->state[2] += C; + ctx->state[3] += D; +} + +/* + * MD4 process buffer + */ +void md4_update( md4_context *ctx, const unsigned char *input, int ilen ) +{ + int fill; + unsigned long left; + + if( ilen <= 0 ) + return; + + left = ctx->total[0] & 0x3F; + fill = 64 - left; + + ctx->total[0] += ilen; + ctx->total[0] &= 0xFFFFFFFF; + + if( ctx->total[0] < (unsigned long) ilen ) + ctx->total[1]++; + + if( left && ilen >= fill ) + { + MEMCPY( (void *) (ctx->buffer + left), + input, fill ); + md4_process( ctx, ctx->buffer ); + input += fill; + ilen -= fill; + left = 0; + } + + while( ilen >= 64 ) + { + md4_process( ctx, input ); + input += 64; + ilen -= 64; + } + + if( ilen > 0 ) + { + MEMCPY( (void *) (ctx->buffer + left), + input, ilen ); + } +} + +static const unsigned char md4_padding[64] = +{ + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* + * MD4 final digest + */ +void md4_finish( md4_context *ctx, unsigned char output[16] ) +{ + unsigned long last, padn; + unsigned long high, low; + unsigned char msglen[8]; + + high = ( ctx->total[0] >> 29 ) + | ( ctx->total[1] << 3 ); + low = ( ctx->total[0] << 3 ); + + PUT_ULONG_LE( low, msglen, 0 ); + PUT_ULONG_LE( high, msglen, 4 ); + + last = ctx->total[0] & 0x3F; + padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); + + md4_update( ctx, md4_padding, padn ); + md4_update( ctx, msglen, 8 ); + + PUT_ULONG_LE( ctx->state[0], output, 0 ); + PUT_ULONG_LE( ctx->state[1], output, 4 ); + PUT_ULONG_LE( ctx->state[2], output, 8 ); + PUT_ULONG_LE( ctx->state[3], output, 12 ); +} + +/* + * output = MD4( input buffer ) + */ +void md4( unsigned char *input, int ilen, unsigned char output[16] ) +{ + md4_context ctx; + + md4_starts( &ctx ); + md4_update( &ctx, input, ilen ); + md4_finish( &ctx, output ); +} + +#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD4 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md5.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md5.c index f8e48e28..1ec4d81a 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md5.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/md5.c @@ -1,300 +1,300 @@ -/* - * RFC 1321 compliant MD5 implementation - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * The MD5 algorithm was designed by Ron Rivest in 1991. - * - * http://www.ietf.org/rfc/rfc1321.txt - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD5 - -#include "netif/ppp/polarssl/md5.h" - -#include - -/* - * 32-bit integer manipulation macros (little endian) - */ -#ifndef GET_ULONG_LE -#define GET_ULONG_LE(n,b,i) \ -{ \ - (n) = ( (unsigned long) (b)[(i) ] ) \ - | ( (unsigned long) (b)[(i) + 1] << 8 ) \ - | ( (unsigned long) (b)[(i) + 2] << 16 ) \ - | ( (unsigned long) (b)[(i) + 3] << 24 ); \ -} -#endif - -#ifndef PUT_ULONG_LE -#define PUT_ULONG_LE(n,b,i) \ -{ \ - (b)[(i) ] = (unsigned char) ( (n) ); \ - (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \ - (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \ - (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \ -} -#endif - -/* - * MD5 context setup - */ -void md5_starts( md5_context *ctx ) -{ - ctx->total[0] = 0; - ctx->total[1] = 0; - - ctx->state[0] = 0x67452301; - ctx->state[1] = 0xEFCDAB89; - ctx->state[2] = 0x98BADCFE; - ctx->state[3] = 0x10325476; -} - -static void md5_process( md5_context *ctx, const unsigned char data[64] ) -{ - unsigned long X[16], A, B, C, D; - - GET_ULONG_LE( X[ 0], data, 0 ); - GET_ULONG_LE( X[ 1], data, 4 ); - GET_ULONG_LE( X[ 2], data, 8 ); - GET_ULONG_LE( X[ 3], data, 12 ); - GET_ULONG_LE( X[ 4], data, 16 ); - GET_ULONG_LE( X[ 5], data, 20 ); - GET_ULONG_LE( X[ 6], data, 24 ); - GET_ULONG_LE( X[ 7], data, 28 ); - GET_ULONG_LE( X[ 8], data, 32 ); - GET_ULONG_LE( X[ 9], data, 36 ); - GET_ULONG_LE( X[10], data, 40 ); - GET_ULONG_LE( X[11], data, 44 ); - GET_ULONG_LE( X[12], data, 48 ); - GET_ULONG_LE( X[13], data, 52 ); - GET_ULONG_LE( X[14], data, 56 ); - GET_ULONG_LE( X[15], data, 60 ); - -#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) - -#define P(a,b,c,d,k,s,t) \ -{ \ - a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \ -} - - A = ctx->state[0]; - B = ctx->state[1]; - C = ctx->state[2]; - D = ctx->state[3]; - -#define F(x,y,z) (z ^ (x & (y ^ z))) - - P( A, B, C, D, 0, 7, 0xD76AA478 ); - P( D, A, B, C, 1, 12, 0xE8C7B756 ); - P( C, D, A, B, 2, 17, 0x242070DB ); - P( B, C, D, A, 3, 22, 0xC1BDCEEE ); - P( A, B, C, D, 4, 7, 0xF57C0FAF ); - P( D, A, B, C, 5, 12, 0x4787C62A ); - P( C, D, A, B, 6, 17, 0xA8304613 ); - P( B, C, D, A, 7, 22, 0xFD469501 ); - P( A, B, C, D, 8, 7, 0x698098D8 ); - P( D, A, B, C, 9, 12, 0x8B44F7AF ); - P( C, D, A, B, 10, 17, 0xFFFF5BB1 ); - P( B, C, D, A, 11, 22, 0x895CD7BE ); - P( A, B, C, D, 12, 7, 0x6B901122 ); - P( D, A, B, C, 13, 12, 0xFD987193 ); - P( C, D, A, B, 14, 17, 0xA679438E ); - P( B, C, D, A, 15, 22, 0x49B40821 ); - -#undef F - -#define F(x,y,z) (y ^ (z & (x ^ y))) - - P( A, B, C, D, 1, 5, 0xF61E2562 ); - P( D, A, B, C, 6, 9, 0xC040B340 ); - P( C, D, A, B, 11, 14, 0x265E5A51 ); - P( B, C, D, A, 0, 20, 0xE9B6C7AA ); - P( A, B, C, D, 5, 5, 0xD62F105D ); - P( D, A, B, C, 10, 9, 0x02441453 ); - P( C, D, A, B, 15, 14, 0xD8A1E681 ); - P( B, C, D, A, 4, 20, 0xE7D3FBC8 ); - P( A, B, C, D, 9, 5, 0x21E1CDE6 ); - P( D, A, B, C, 14, 9, 0xC33707D6 ); - P( C, D, A, B, 3, 14, 0xF4D50D87 ); - P( B, C, D, A, 8, 20, 0x455A14ED ); - P( A, B, C, D, 13, 5, 0xA9E3E905 ); - P( D, A, B, C, 2, 9, 0xFCEFA3F8 ); - P( C, D, A, B, 7, 14, 0x676F02D9 ); - P( B, C, D, A, 12, 20, 0x8D2A4C8A ); - -#undef F - -#define F(x,y,z) (x ^ y ^ z) - - P( A, B, C, D, 5, 4, 0xFFFA3942 ); - P( D, A, B, C, 8, 11, 0x8771F681 ); - P( C, D, A, B, 11, 16, 0x6D9D6122 ); - P( B, C, D, A, 14, 23, 0xFDE5380C ); - P( A, B, C, D, 1, 4, 0xA4BEEA44 ); - P( D, A, B, C, 4, 11, 0x4BDECFA9 ); - P( C, D, A, B, 7, 16, 0xF6BB4B60 ); - P( B, C, D, A, 10, 23, 0xBEBFBC70 ); - P( A, B, C, D, 13, 4, 0x289B7EC6 ); - P( D, A, B, C, 0, 11, 0xEAA127FA ); - P( C, D, A, B, 3, 16, 0xD4EF3085 ); - P( B, C, D, A, 6, 23, 0x04881D05 ); - P( A, B, C, D, 9, 4, 0xD9D4D039 ); - P( D, A, B, C, 12, 11, 0xE6DB99E5 ); - P( C, D, A, B, 15, 16, 0x1FA27CF8 ); - P( B, C, D, A, 2, 23, 0xC4AC5665 ); - -#undef F - -#define F(x,y,z) (y ^ (x | ~z)) - - P( A, B, C, D, 0, 6, 0xF4292244 ); - P( D, A, B, C, 7, 10, 0x432AFF97 ); - P( C, D, A, B, 14, 15, 0xAB9423A7 ); - P( B, C, D, A, 5, 21, 0xFC93A039 ); - P( A, B, C, D, 12, 6, 0x655B59C3 ); - P( D, A, B, C, 3, 10, 0x8F0CCC92 ); - P( C, D, A, B, 10, 15, 0xFFEFF47D ); - P( B, C, D, A, 1, 21, 0x85845DD1 ); - P( A, B, C, D, 8, 6, 0x6FA87E4F ); - P( D, A, B, C, 15, 10, 0xFE2CE6E0 ); - P( C, D, A, B, 6, 15, 0xA3014314 ); - P( B, C, D, A, 13, 21, 0x4E0811A1 ); - P( A, B, C, D, 4, 6, 0xF7537E82 ); - P( D, A, B, C, 11, 10, 0xBD3AF235 ); - P( C, D, A, B, 2, 15, 0x2AD7D2BB ); - P( B, C, D, A, 9, 21, 0xEB86D391 ); - -#undef F - - ctx->state[0] += A; - ctx->state[1] += B; - ctx->state[2] += C; - ctx->state[3] += D; -} - -/* - * MD5 process buffer - */ -void md5_update( md5_context *ctx, const unsigned char *input, int ilen ) -{ - int fill; - unsigned long left; - - if( ilen <= 0 ) - return; - - left = ctx->total[0] & 0x3F; - fill = 64 - left; - - ctx->total[0] += ilen; - ctx->total[0] &= 0xFFFFFFFF; - - if( ctx->total[0] < (unsigned long) ilen ) - ctx->total[1]++; - - if( left && ilen >= fill ) - { - MEMCPY( (void *) (ctx->buffer + left), - input, fill ); - md5_process( ctx, ctx->buffer ); - input += fill; - ilen -= fill; - left = 0; - } - - while( ilen >= 64 ) - { - md5_process( ctx, input ); - input += 64; - ilen -= 64; - } - - if( ilen > 0 ) - { - MEMCPY( (void *) (ctx->buffer + left), - input, ilen ); - } -} - -static const unsigned char md5_padding[64] = -{ - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - -/* - * MD5 final digest - */ -void md5_finish( md5_context *ctx, unsigned char output[16] ) -{ - unsigned long last, padn; - unsigned long high, low; - unsigned char msglen[8]; - - high = ( ctx->total[0] >> 29 ) - | ( ctx->total[1] << 3 ); - low = ( ctx->total[0] << 3 ); - - PUT_ULONG_LE( low, msglen, 0 ); - PUT_ULONG_LE( high, msglen, 4 ); - - last = ctx->total[0] & 0x3F; - padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); - - md5_update( ctx, md5_padding, padn ); - md5_update( ctx, msglen, 8 ); - - PUT_ULONG_LE( ctx->state[0], output, 0 ); - PUT_ULONG_LE( ctx->state[1], output, 4 ); - PUT_ULONG_LE( ctx->state[2], output, 8 ); - PUT_ULONG_LE( ctx->state[3], output, 12 ); -} - -/* - * output = MD5( input buffer ) - */ -void md5( unsigned char *input, int ilen, unsigned char output[16] ) -{ - md5_context ctx; - - md5_starts( &ctx ); - md5_update( &ctx, input, ilen ); - md5_finish( &ctx, output ); -} - -#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD5 */ +/* + * RFC 1321 compliant MD5 implementation + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * The MD5 algorithm was designed by Ron Rivest in 1991. + * + * http://www.ietf.org/rfc/rfc1321.txt + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD5 + +#include "netif/ppp/polarssl/md5.h" + +#include + +/* + * 32-bit integer manipulation macros (little endian) + */ +#ifndef GET_ULONG_LE +#define GET_ULONG_LE(n,b,i) \ +{ \ + (n) = ( (unsigned long) (b)[(i) ] ) \ + | ( (unsigned long) (b)[(i) + 1] << 8 ) \ + | ( (unsigned long) (b)[(i) + 2] << 16 ) \ + | ( (unsigned long) (b)[(i) + 3] << 24 ); \ +} +#endif + +#ifndef PUT_ULONG_LE +#define PUT_ULONG_LE(n,b,i) \ +{ \ + (b)[(i) ] = (unsigned char) ( (n) ); \ + (b)[(i) + 1] = (unsigned char) ( (n) >> 8 ); \ + (b)[(i) + 2] = (unsigned char) ( (n) >> 16 ); \ + (b)[(i) + 3] = (unsigned char) ( (n) >> 24 ); \ +} +#endif + +/* + * MD5 context setup + */ +void md5_starts( md5_context *ctx ) +{ + ctx->total[0] = 0; + ctx->total[1] = 0; + + ctx->state[0] = 0x67452301; + ctx->state[1] = 0xEFCDAB89; + ctx->state[2] = 0x98BADCFE; + ctx->state[3] = 0x10325476; +} + +static void md5_process( md5_context *ctx, const unsigned char data[64] ) +{ + unsigned long X[16], A, B, C, D; + + GET_ULONG_LE( X[ 0], data, 0 ); + GET_ULONG_LE( X[ 1], data, 4 ); + GET_ULONG_LE( X[ 2], data, 8 ); + GET_ULONG_LE( X[ 3], data, 12 ); + GET_ULONG_LE( X[ 4], data, 16 ); + GET_ULONG_LE( X[ 5], data, 20 ); + GET_ULONG_LE( X[ 6], data, 24 ); + GET_ULONG_LE( X[ 7], data, 28 ); + GET_ULONG_LE( X[ 8], data, 32 ); + GET_ULONG_LE( X[ 9], data, 36 ); + GET_ULONG_LE( X[10], data, 40 ); + GET_ULONG_LE( X[11], data, 44 ); + GET_ULONG_LE( X[12], data, 48 ); + GET_ULONG_LE( X[13], data, 52 ); + GET_ULONG_LE( X[14], data, 56 ); + GET_ULONG_LE( X[15], data, 60 ); + +#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) + +#define P(a,b,c,d,k,s,t) \ +{ \ + a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \ +} + + A = ctx->state[0]; + B = ctx->state[1]; + C = ctx->state[2]; + D = ctx->state[3]; + +#define F(x,y,z) (z ^ (x & (y ^ z))) + + P( A, B, C, D, 0, 7, 0xD76AA478 ); + P( D, A, B, C, 1, 12, 0xE8C7B756 ); + P( C, D, A, B, 2, 17, 0x242070DB ); + P( B, C, D, A, 3, 22, 0xC1BDCEEE ); + P( A, B, C, D, 4, 7, 0xF57C0FAF ); + P( D, A, B, C, 5, 12, 0x4787C62A ); + P( C, D, A, B, 6, 17, 0xA8304613 ); + P( B, C, D, A, 7, 22, 0xFD469501 ); + P( A, B, C, D, 8, 7, 0x698098D8 ); + P( D, A, B, C, 9, 12, 0x8B44F7AF ); + P( C, D, A, B, 10, 17, 0xFFFF5BB1 ); + P( B, C, D, A, 11, 22, 0x895CD7BE ); + P( A, B, C, D, 12, 7, 0x6B901122 ); + P( D, A, B, C, 13, 12, 0xFD987193 ); + P( C, D, A, B, 14, 17, 0xA679438E ); + P( B, C, D, A, 15, 22, 0x49B40821 ); + +#undef F + +#define F(x,y,z) (y ^ (z & (x ^ y))) + + P( A, B, C, D, 1, 5, 0xF61E2562 ); + P( D, A, B, C, 6, 9, 0xC040B340 ); + P( C, D, A, B, 11, 14, 0x265E5A51 ); + P( B, C, D, A, 0, 20, 0xE9B6C7AA ); + P( A, B, C, D, 5, 5, 0xD62F105D ); + P( D, A, B, C, 10, 9, 0x02441453 ); + P( C, D, A, B, 15, 14, 0xD8A1E681 ); + P( B, C, D, A, 4, 20, 0xE7D3FBC8 ); + P( A, B, C, D, 9, 5, 0x21E1CDE6 ); + P( D, A, B, C, 14, 9, 0xC33707D6 ); + P( C, D, A, B, 3, 14, 0xF4D50D87 ); + P( B, C, D, A, 8, 20, 0x455A14ED ); + P( A, B, C, D, 13, 5, 0xA9E3E905 ); + P( D, A, B, C, 2, 9, 0xFCEFA3F8 ); + P( C, D, A, B, 7, 14, 0x676F02D9 ); + P( B, C, D, A, 12, 20, 0x8D2A4C8A ); + +#undef F + +#define F(x,y,z) (x ^ y ^ z) + + P( A, B, C, D, 5, 4, 0xFFFA3942 ); + P( D, A, B, C, 8, 11, 0x8771F681 ); + P( C, D, A, B, 11, 16, 0x6D9D6122 ); + P( B, C, D, A, 14, 23, 0xFDE5380C ); + P( A, B, C, D, 1, 4, 0xA4BEEA44 ); + P( D, A, B, C, 4, 11, 0x4BDECFA9 ); + P( C, D, A, B, 7, 16, 0xF6BB4B60 ); + P( B, C, D, A, 10, 23, 0xBEBFBC70 ); + P( A, B, C, D, 13, 4, 0x289B7EC6 ); + P( D, A, B, C, 0, 11, 0xEAA127FA ); + P( C, D, A, B, 3, 16, 0xD4EF3085 ); + P( B, C, D, A, 6, 23, 0x04881D05 ); + P( A, B, C, D, 9, 4, 0xD9D4D039 ); + P( D, A, B, C, 12, 11, 0xE6DB99E5 ); + P( C, D, A, B, 15, 16, 0x1FA27CF8 ); + P( B, C, D, A, 2, 23, 0xC4AC5665 ); + +#undef F + +#define F(x,y,z) (y ^ (x | ~z)) + + P( A, B, C, D, 0, 6, 0xF4292244 ); + P( D, A, B, C, 7, 10, 0x432AFF97 ); + P( C, D, A, B, 14, 15, 0xAB9423A7 ); + P( B, C, D, A, 5, 21, 0xFC93A039 ); + P( A, B, C, D, 12, 6, 0x655B59C3 ); + P( D, A, B, C, 3, 10, 0x8F0CCC92 ); + P( C, D, A, B, 10, 15, 0xFFEFF47D ); + P( B, C, D, A, 1, 21, 0x85845DD1 ); + P( A, B, C, D, 8, 6, 0x6FA87E4F ); + P( D, A, B, C, 15, 10, 0xFE2CE6E0 ); + P( C, D, A, B, 6, 15, 0xA3014314 ); + P( B, C, D, A, 13, 21, 0x4E0811A1 ); + P( A, B, C, D, 4, 6, 0xF7537E82 ); + P( D, A, B, C, 11, 10, 0xBD3AF235 ); + P( C, D, A, B, 2, 15, 0x2AD7D2BB ); + P( B, C, D, A, 9, 21, 0xEB86D391 ); + +#undef F + + ctx->state[0] += A; + ctx->state[1] += B; + ctx->state[2] += C; + ctx->state[3] += D; +} + +/* + * MD5 process buffer + */ +void md5_update( md5_context *ctx, const unsigned char *input, int ilen ) +{ + int fill; + unsigned long left; + + if( ilen <= 0 ) + return; + + left = ctx->total[0] & 0x3F; + fill = 64 - left; + + ctx->total[0] += ilen; + ctx->total[0] &= 0xFFFFFFFF; + + if( ctx->total[0] < (unsigned long) ilen ) + ctx->total[1]++; + + if( left && ilen >= fill ) + { + MEMCPY( (void *) (ctx->buffer + left), + input, fill ); + md5_process( ctx, ctx->buffer ); + input += fill; + ilen -= fill; + left = 0; + } + + while( ilen >= 64 ) + { + md5_process( ctx, input ); + input += 64; + ilen -= 64; + } + + if( ilen > 0 ) + { + MEMCPY( (void *) (ctx->buffer + left), + input, ilen ); + } +} + +static const unsigned char md5_padding[64] = +{ + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* + * MD5 final digest + */ +void md5_finish( md5_context *ctx, unsigned char output[16] ) +{ + unsigned long last, padn; + unsigned long high, low; + unsigned char msglen[8]; + + high = ( ctx->total[0] >> 29 ) + | ( ctx->total[1] << 3 ); + low = ( ctx->total[0] << 3 ); + + PUT_ULONG_LE( low, msglen, 0 ); + PUT_ULONG_LE( high, msglen, 4 ); + + last = ctx->total[0] & 0x3F; + padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); + + md5_update( ctx, md5_padding, padn ); + md5_update( ctx, msglen, 8 ); + + PUT_ULONG_LE( ctx->state[0], output, 0 ); + PUT_ULONG_LE( ctx->state[1], output, 4 ); + PUT_ULONG_LE( ctx->state[2], output, 8 ); + PUT_ULONG_LE( ctx->state[3], output, 12 ); +} + +/* + * output = MD5( input buffer ) + */ +void md5( unsigned char *input, int ilen, unsigned char output[16] ) +{ + md5_context ctx; + + md5_starts( &ctx ); + md5_update( &ctx, input, ilen ); + md5_finish( &ctx, output ); +} + +#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_MD5 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/sha1.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/sha1.c index 7cc24598..c2192eac 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/sha1.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/polarssl/sha1.c @@ -1,335 +1,335 @@ -/* - * FIPS-180-1 compliant SHA-1 implementation - * - * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine - * - * Copyright (C) 2009 Paul Bakker - * - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * * 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. - * * Neither the names of PolarSSL or XySSL nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT - * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, - * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED - * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ -/* - * The SHA-1 standard was published by NIST in 1993. - * - * http://www.itl.nist.gov/fipspubs/fip180-1.htm - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_SHA1 - -#include "netif/ppp/polarssl/sha1.h" - -#include - -/* - * 32-bit integer manipulation macros (big endian) - */ -#ifndef GET_ULONG_BE -#define GET_ULONG_BE(n,b,i) \ -{ \ - (n) = ( (unsigned long) (b)[(i) ] << 24 ) \ - | ( (unsigned long) (b)[(i) + 1] << 16 ) \ - | ( (unsigned long) (b)[(i) + 2] << 8 ) \ - | ( (unsigned long) (b)[(i) + 3] ); \ -} -#endif - -#ifndef PUT_ULONG_BE -#define PUT_ULONG_BE(n,b,i) \ -{ \ - (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ - (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ - (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ - (b)[(i) + 3] = (unsigned char) ( (n) ); \ -} -#endif - -/* - * SHA-1 context setup - */ -void sha1_starts( sha1_context *ctx ) -{ - ctx->total[0] = 0; - ctx->total[1] = 0; - - ctx->state[0] = 0x67452301; - ctx->state[1] = 0xEFCDAB89; - ctx->state[2] = 0x98BADCFE; - ctx->state[3] = 0x10325476; - ctx->state[4] = 0xC3D2E1F0; -} - -static void sha1_process( sha1_context *ctx, const unsigned char data[64] ) -{ - unsigned long temp, W[16], A, B, C, D, E; - - GET_ULONG_BE( W[ 0], data, 0 ); - GET_ULONG_BE( W[ 1], data, 4 ); - GET_ULONG_BE( W[ 2], data, 8 ); - GET_ULONG_BE( W[ 3], data, 12 ); - GET_ULONG_BE( W[ 4], data, 16 ); - GET_ULONG_BE( W[ 5], data, 20 ); - GET_ULONG_BE( W[ 6], data, 24 ); - GET_ULONG_BE( W[ 7], data, 28 ); - GET_ULONG_BE( W[ 8], data, 32 ); - GET_ULONG_BE( W[ 9], data, 36 ); - GET_ULONG_BE( W[10], data, 40 ); - GET_ULONG_BE( W[11], data, 44 ); - GET_ULONG_BE( W[12], data, 48 ); - GET_ULONG_BE( W[13], data, 52 ); - GET_ULONG_BE( W[14], data, 56 ); - GET_ULONG_BE( W[15], data, 60 ); - -#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) - -#define R(t) \ -( \ - temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \ - W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \ - ( W[t & 0x0F] = S(temp,1) ) \ -) - -#define P(a,b,c,d,e,x) \ -{ \ - e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \ -} - - A = ctx->state[0]; - B = ctx->state[1]; - C = ctx->state[2]; - D = ctx->state[3]; - E = ctx->state[4]; - -#define F(x,y,z) (z ^ (x & (y ^ z))) -#define K 0x5A827999 - - P( A, B, C, D, E, W[0] ); - P( E, A, B, C, D, W[1] ); - P( D, E, A, B, C, W[2] ); - P( C, D, E, A, B, W[3] ); - P( B, C, D, E, A, W[4] ); - P( A, B, C, D, E, W[5] ); - P( E, A, B, C, D, W[6] ); - P( D, E, A, B, C, W[7] ); - P( C, D, E, A, B, W[8] ); - P( B, C, D, E, A, W[9] ); - P( A, B, C, D, E, W[10] ); - P( E, A, B, C, D, W[11] ); - P( D, E, A, B, C, W[12] ); - P( C, D, E, A, B, W[13] ); - P( B, C, D, E, A, W[14] ); - P( A, B, C, D, E, W[15] ); - P( E, A, B, C, D, R(16) ); - P( D, E, A, B, C, R(17) ); - P( C, D, E, A, B, R(18) ); - P( B, C, D, E, A, R(19) ); - -#undef K -#undef F - -#define F(x,y,z) (x ^ y ^ z) -#define K 0x6ED9EBA1 - - P( A, B, C, D, E, R(20) ); - P( E, A, B, C, D, R(21) ); - P( D, E, A, B, C, R(22) ); - P( C, D, E, A, B, R(23) ); - P( B, C, D, E, A, R(24) ); - P( A, B, C, D, E, R(25) ); - P( E, A, B, C, D, R(26) ); - P( D, E, A, B, C, R(27) ); - P( C, D, E, A, B, R(28) ); - P( B, C, D, E, A, R(29) ); - P( A, B, C, D, E, R(30) ); - P( E, A, B, C, D, R(31) ); - P( D, E, A, B, C, R(32) ); - P( C, D, E, A, B, R(33) ); - P( B, C, D, E, A, R(34) ); - P( A, B, C, D, E, R(35) ); - P( E, A, B, C, D, R(36) ); - P( D, E, A, B, C, R(37) ); - P( C, D, E, A, B, R(38) ); - P( B, C, D, E, A, R(39) ); - -#undef K -#undef F - -#define F(x,y,z) ((x & y) | (z & (x | y))) -#define K 0x8F1BBCDC - - P( A, B, C, D, E, R(40) ); - P( E, A, B, C, D, R(41) ); - P( D, E, A, B, C, R(42) ); - P( C, D, E, A, B, R(43) ); - P( B, C, D, E, A, R(44) ); - P( A, B, C, D, E, R(45) ); - P( E, A, B, C, D, R(46) ); - P( D, E, A, B, C, R(47) ); - P( C, D, E, A, B, R(48) ); - P( B, C, D, E, A, R(49) ); - P( A, B, C, D, E, R(50) ); - P( E, A, B, C, D, R(51) ); - P( D, E, A, B, C, R(52) ); - P( C, D, E, A, B, R(53) ); - P( B, C, D, E, A, R(54) ); - P( A, B, C, D, E, R(55) ); - P( E, A, B, C, D, R(56) ); - P( D, E, A, B, C, R(57) ); - P( C, D, E, A, B, R(58) ); - P( B, C, D, E, A, R(59) ); - -#undef K -#undef F - -#define F(x,y,z) (x ^ y ^ z) -#define K 0xCA62C1D6 - - P( A, B, C, D, E, R(60) ); - P( E, A, B, C, D, R(61) ); - P( D, E, A, B, C, R(62) ); - P( C, D, E, A, B, R(63) ); - P( B, C, D, E, A, R(64) ); - P( A, B, C, D, E, R(65) ); - P( E, A, B, C, D, R(66) ); - P( D, E, A, B, C, R(67) ); - P( C, D, E, A, B, R(68) ); - P( B, C, D, E, A, R(69) ); - P( A, B, C, D, E, R(70) ); - P( E, A, B, C, D, R(71) ); - P( D, E, A, B, C, R(72) ); - P( C, D, E, A, B, R(73) ); - P( B, C, D, E, A, R(74) ); - P( A, B, C, D, E, R(75) ); - P( E, A, B, C, D, R(76) ); - P( D, E, A, B, C, R(77) ); - P( C, D, E, A, B, R(78) ); - P( B, C, D, E, A, R(79) ); - -#undef K -#undef F - - ctx->state[0] += A; - ctx->state[1] += B; - ctx->state[2] += C; - ctx->state[3] += D; - ctx->state[4] += E; -} - -/* - * SHA-1 process buffer - */ -void sha1_update( sha1_context *ctx, const unsigned char *input, int ilen ) -{ - int fill; - unsigned long left; - - if( ilen <= 0 ) - return; - - left = ctx->total[0] & 0x3F; - fill = 64 - left; - - ctx->total[0] += ilen; - ctx->total[0] &= 0xFFFFFFFF; - - if( ctx->total[0] < (unsigned long) ilen ) - ctx->total[1]++; - - if( left && ilen >= fill ) - { - MEMCPY( (void *) (ctx->buffer + left), - input, fill ); - sha1_process( ctx, ctx->buffer ); - input += fill; - ilen -= fill; - left = 0; - } - - while( ilen >= 64 ) - { - sha1_process( ctx, input ); - input += 64; - ilen -= 64; - } - - if( ilen > 0 ) - { - MEMCPY( (void *) (ctx->buffer + left), - input, ilen ); - } -} - -static const unsigned char sha1_padding[64] = -{ - 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; - -/* - * SHA-1 final digest - */ -void sha1_finish( sha1_context *ctx, unsigned char output[20] ) -{ - unsigned long last, padn; - unsigned long high, low; - unsigned char msglen[8]; - - high = ( ctx->total[0] >> 29 ) - | ( ctx->total[1] << 3 ); - low = ( ctx->total[0] << 3 ); - - PUT_ULONG_BE( high, msglen, 0 ); - PUT_ULONG_BE( low, msglen, 4 ); - - last = ctx->total[0] & 0x3F; - padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); - - sha1_update( ctx, sha1_padding, padn ); - sha1_update( ctx, msglen, 8 ); - - PUT_ULONG_BE( ctx->state[0], output, 0 ); - PUT_ULONG_BE( ctx->state[1], output, 4 ); - PUT_ULONG_BE( ctx->state[2], output, 8 ); - PUT_ULONG_BE( ctx->state[3], output, 12 ); - PUT_ULONG_BE( ctx->state[4], output, 16 ); -} - -/* - * output = SHA-1( input buffer ) - */ -void sha1( unsigned char *input, int ilen, unsigned char output[20] ) -{ - sha1_context ctx; - - sha1_starts( &ctx ); - sha1_update( &ctx, input, ilen ); - sha1_finish( &ctx, output ); -} - -#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_SHA1 */ +/* + * FIPS-180-1 compliant SHA-1 implementation + * + * Based on XySSL: Copyright (C) 2006-2008 Christophe Devine + * + * Copyright (C) 2009 Paul Bakker + * + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * 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. + * * Neither the names of PolarSSL or XySSL nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED + * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +/* + * The SHA-1 standard was published by NIST in 1993. + * + * http://www.itl.nist.gov/fipspubs/fip180-1.htm + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_SHA1 + +#include "netif/ppp/polarssl/sha1.h" + +#include + +/* + * 32-bit integer manipulation macros (big endian) + */ +#ifndef GET_ULONG_BE +#define GET_ULONG_BE(n,b,i) \ +{ \ + (n) = ( (unsigned long) (b)[(i) ] << 24 ) \ + | ( (unsigned long) (b)[(i) + 1] << 16 ) \ + | ( (unsigned long) (b)[(i) + 2] << 8 ) \ + | ( (unsigned long) (b)[(i) + 3] ); \ +} +#endif + +#ifndef PUT_ULONG_BE +#define PUT_ULONG_BE(n,b,i) \ +{ \ + (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \ + (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \ + (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \ + (b)[(i) + 3] = (unsigned char) ( (n) ); \ +} +#endif + +/* + * SHA-1 context setup + */ +void sha1_starts( sha1_context *ctx ) +{ + ctx->total[0] = 0; + ctx->total[1] = 0; + + ctx->state[0] = 0x67452301; + ctx->state[1] = 0xEFCDAB89; + ctx->state[2] = 0x98BADCFE; + ctx->state[3] = 0x10325476; + ctx->state[4] = 0xC3D2E1F0; +} + +static void sha1_process( sha1_context *ctx, const unsigned char data[64] ) +{ + unsigned long temp, W[16], A, B, C, D, E; + + GET_ULONG_BE( W[ 0], data, 0 ); + GET_ULONG_BE( W[ 1], data, 4 ); + GET_ULONG_BE( W[ 2], data, 8 ); + GET_ULONG_BE( W[ 3], data, 12 ); + GET_ULONG_BE( W[ 4], data, 16 ); + GET_ULONG_BE( W[ 5], data, 20 ); + GET_ULONG_BE( W[ 6], data, 24 ); + GET_ULONG_BE( W[ 7], data, 28 ); + GET_ULONG_BE( W[ 8], data, 32 ); + GET_ULONG_BE( W[ 9], data, 36 ); + GET_ULONG_BE( W[10], data, 40 ); + GET_ULONG_BE( W[11], data, 44 ); + GET_ULONG_BE( W[12], data, 48 ); + GET_ULONG_BE( W[13], data, 52 ); + GET_ULONG_BE( W[14], data, 56 ); + GET_ULONG_BE( W[15], data, 60 ); + +#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n))) + +#define R(t) \ +( \ + temp = W[(t - 3) & 0x0F] ^ W[(t - 8) & 0x0F] ^ \ + W[(t - 14) & 0x0F] ^ W[ t & 0x0F], \ + ( W[t & 0x0F] = S(temp,1) ) \ +) + +#define P(a,b,c,d,e,x) \ +{ \ + e += S(a,5) + F(b,c,d) + K + x; b = S(b,30); \ +} + + A = ctx->state[0]; + B = ctx->state[1]; + C = ctx->state[2]; + D = ctx->state[3]; + E = ctx->state[4]; + +#define F(x,y,z) (z ^ (x & (y ^ z))) +#define K 0x5A827999 + + P( A, B, C, D, E, W[0] ); + P( E, A, B, C, D, W[1] ); + P( D, E, A, B, C, W[2] ); + P( C, D, E, A, B, W[3] ); + P( B, C, D, E, A, W[4] ); + P( A, B, C, D, E, W[5] ); + P( E, A, B, C, D, W[6] ); + P( D, E, A, B, C, W[7] ); + P( C, D, E, A, B, W[8] ); + P( B, C, D, E, A, W[9] ); + P( A, B, C, D, E, W[10] ); + P( E, A, B, C, D, W[11] ); + P( D, E, A, B, C, W[12] ); + P( C, D, E, A, B, W[13] ); + P( B, C, D, E, A, W[14] ); + P( A, B, C, D, E, W[15] ); + P( E, A, B, C, D, R(16) ); + P( D, E, A, B, C, R(17) ); + P( C, D, E, A, B, R(18) ); + P( B, C, D, E, A, R(19) ); + +#undef K +#undef F + +#define F(x,y,z) (x ^ y ^ z) +#define K 0x6ED9EBA1 + + P( A, B, C, D, E, R(20) ); + P( E, A, B, C, D, R(21) ); + P( D, E, A, B, C, R(22) ); + P( C, D, E, A, B, R(23) ); + P( B, C, D, E, A, R(24) ); + P( A, B, C, D, E, R(25) ); + P( E, A, B, C, D, R(26) ); + P( D, E, A, B, C, R(27) ); + P( C, D, E, A, B, R(28) ); + P( B, C, D, E, A, R(29) ); + P( A, B, C, D, E, R(30) ); + P( E, A, B, C, D, R(31) ); + P( D, E, A, B, C, R(32) ); + P( C, D, E, A, B, R(33) ); + P( B, C, D, E, A, R(34) ); + P( A, B, C, D, E, R(35) ); + P( E, A, B, C, D, R(36) ); + P( D, E, A, B, C, R(37) ); + P( C, D, E, A, B, R(38) ); + P( B, C, D, E, A, R(39) ); + +#undef K +#undef F + +#define F(x,y,z) ((x & y) | (z & (x | y))) +#define K 0x8F1BBCDC + + P( A, B, C, D, E, R(40) ); + P( E, A, B, C, D, R(41) ); + P( D, E, A, B, C, R(42) ); + P( C, D, E, A, B, R(43) ); + P( B, C, D, E, A, R(44) ); + P( A, B, C, D, E, R(45) ); + P( E, A, B, C, D, R(46) ); + P( D, E, A, B, C, R(47) ); + P( C, D, E, A, B, R(48) ); + P( B, C, D, E, A, R(49) ); + P( A, B, C, D, E, R(50) ); + P( E, A, B, C, D, R(51) ); + P( D, E, A, B, C, R(52) ); + P( C, D, E, A, B, R(53) ); + P( B, C, D, E, A, R(54) ); + P( A, B, C, D, E, R(55) ); + P( E, A, B, C, D, R(56) ); + P( D, E, A, B, C, R(57) ); + P( C, D, E, A, B, R(58) ); + P( B, C, D, E, A, R(59) ); + +#undef K +#undef F + +#define F(x,y,z) (x ^ y ^ z) +#define K 0xCA62C1D6 + + P( A, B, C, D, E, R(60) ); + P( E, A, B, C, D, R(61) ); + P( D, E, A, B, C, R(62) ); + P( C, D, E, A, B, R(63) ); + P( B, C, D, E, A, R(64) ); + P( A, B, C, D, E, R(65) ); + P( E, A, B, C, D, R(66) ); + P( D, E, A, B, C, R(67) ); + P( C, D, E, A, B, R(68) ); + P( B, C, D, E, A, R(69) ); + P( A, B, C, D, E, R(70) ); + P( E, A, B, C, D, R(71) ); + P( D, E, A, B, C, R(72) ); + P( C, D, E, A, B, R(73) ); + P( B, C, D, E, A, R(74) ); + P( A, B, C, D, E, R(75) ); + P( E, A, B, C, D, R(76) ); + P( D, E, A, B, C, R(77) ); + P( C, D, E, A, B, R(78) ); + P( B, C, D, E, A, R(79) ); + +#undef K +#undef F + + ctx->state[0] += A; + ctx->state[1] += B; + ctx->state[2] += C; + ctx->state[3] += D; + ctx->state[4] += E; +} + +/* + * SHA-1 process buffer + */ +void sha1_update( sha1_context *ctx, const unsigned char *input, int ilen ) +{ + int fill; + unsigned long left; + + if( ilen <= 0 ) + return; + + left = ctx->total[0] & 0x3F; + fill = 64 - left; + + ctx->total[0] += ilen; + ctx->total[0] &= 0xFFFFFFFF; + + if( ctx->total[0] < (unsigned long) ilen ) + ctx->total[1]++; + + if( left && ilen >= fill ) + { + MEMCPY( (void *) (ctx->buffer + left), + input, fill ); + sha1_process( ctx, ctx->buffer ); + input += fill; + ilen -= fill; + left = 0; + } + + while( ilen >= 64 ) + { + sha1_process( ctx, input ); + input += 64; + ilen -= 64; + } + + if( ilen > 0 ) + { + MEMCPY( (void *) (ctx->buffer + left), + input, ilen ); + } +} + +static const unsigned char sha1_padding[64] = +{ + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* + * SHA-1 final digest + */ +void sha1_finish( sha1_context *ctx, unsigned char output[20] ) +{ + unsigned long last, padn; + unsigned long high, low; + unsigned char msglen[8]; + + high = ( ctx->total[0] >> 29 ) + | ( ctx->total[1] << 3 ); + low = ( ctx->total[0] << 3 ); + + PUT_ULONG_BE( high, msglen, 0 ); + PUT_ULONG_BE( low, msglen, 4 ); + + last = ctx->total[0] & 0x3F; + padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last ); + + sha1_update( ctx, sha1_padding, padn ); + sha1_update( ctx, msglen, 8 ); + + PUT_ULONG_BE( ctx->state[0], output, 0 ); + PUT_ULONG_BE( ctx->state[1], output, 4 ); + PUT_ULONG_BE( ctx->state[2], output, 8 ); + PUT_ULONG_BE( ctx->state[3], output, 12 ); + PUT_ULONG_BE( ctx->state[4], output, 16 ); +} + +/* + * output = SHA-1( input buffer ) + */ +void sha1( unsigned char *input, int ilen, unsigned char output[20] ) +{ + sha1_context ctx; + + sha1_starts( &ctx ); + sha1_update( &ctx, input, ilen ); + sha1_finish( &ctx, output ); +} + +#endif /* PPP_SUPPORT && LWIP_INCLUDED_POLARSSL_SHA1 */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ppp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ppp.c index 98d7b9e9..a9c18e30 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ppp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/ppp.c @@ -1,1628 +1,1628 @@ -/***************************************************************************** -* ppp.c - Network Point to Point Protocol program file. -* -* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. -* portions Copyright (c) 1997 by Global Election Systems Inc. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY -* -* 03-01-01 Marc Boucher -* Ported to lwIP. -* 97-11-05 Guy Lancaster , Global Election Systems Inc. -* Original. -*****************************************************************************/ - -/* - * ppp_defs.h - PPP definitions. - * - * if_pppvar.h - private structures and declarations for PPP. - * - * Copyright (c) 1994 The Australian National University. - * All rights reserved. - * - * Permission to use, copy, modify, and distribute this software and its - * documentation is hereby granted, provided that the above copyright - * notice appears in all copies. This software is provided without any - * warranty, express or implied. The Australian National University - * makes no representations about the suitability of this software for - * any purpose. - * - * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY - * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES - * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF - * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY - * OF SUCH DAMAGE. - * - * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, - * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS - * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO - * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, - * OR MODIFICATIONS. - */ - -/* - * if_ppp.h - Point-to-Point Protocol definitions. - * - * Copyright (c) 1989 Carnegie Mellon University. - * All rights reserved. - * - * Redistribution and use in source and binary forms are permitted - * provided that the above copyright notice and this paragraph are - * duplicated in all such forms and that any documentation, - * advertising materials, and other materials related to such - * distribution and use acknowledge that the software was developed - * by Carnegie Mellon University. The name of the - * University may not be used to endorse or promote products derived - * from this software without specific prior written permission. - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. - */ - -/** - * @defgroup ppp PPP - * @ingroup netifs - * @verbinclude "ppp.txt" - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/pbuf.h" -#include "lwip/stats.h" -#include "lwip/sys.h" -#include "lwip/tcpip.h" -#include "lwip/api.h" -#include "lwip/snmp.h" -#include "lwip/ip4.h" /* for ip4_input() */ -#if PPP_IPV6_SUPPORT -#include "lwip/ip6.h" /* for ip6_input() */ -#endif /* PPP_IPV6_SUPPORT */ -#include "lwip/dns.h" - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/pppos.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/lcp.h" -#include "netif/ppp/magic.h" - -#if PAP_SUPPORT -#include "netif/ppp/upap.h" -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT -#include "netif/ppp/chap-new.h" -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT -#include "netif/ppp/eap.h" -#endif /* EAP_SUPPORT */ -#if CCP_SUPPORT -#include "netif/ppp/ccp.h" -#endif /* CCP_SUPPORT */ -#if MPPE_SUPPORT -#include "netif/ppp/mppe.h" -#endif /* MPPE_SUPPORT */ -#if ECP_SUPPORT -#include "netif/ppp/ecp.h" -#endif /* EAP_SUPPORT */ -#if VJ_SUPPORT -#include "netif/ppp/vj.h" -#endif /* VJ_SUPPORT */ -#if PPP_IPV4_SUPPORT -#include "netif/ppp/ipcp.h" -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT -#include "netif/ppp/ipv6cp.h" -#endif /* PPP_IPV6_SUPPORT */ - -/*************************/ -/*** LOCAL DEFINITIONS ***/ -/*************************/ - -/* Memory pools */ -#if PPPOS_SUPPORT -LWIP_MEMPOOL_PROTOTYPE(PPPOS_PCB); -#endif -#if PPPOE_SUPPORT -LWIP_MEMPOOL_PROTOTYPE(PPPOE_IF); -#endif -#if PPPOL2TP_SUPPORT -LWIP_MEMPOOL_PROTOTYPE(PPPOL2TP_PCB); -#endif -#if LWIP_PPP_API && LWIP_MPU_COMPATIBLE -LWIP_MEMPOOL_PROTOTYPE(PPPAPI_MSG); -#endif -LWIP_MEMPOOL_DECLARE(PPP_PCB, MEMP_NUM_PPP_PCB, sizeof(ppp_pcb), "PPP_PCB") - -/* FIXME: add stats per PPP session */ -#if PPP_STATS_SUPPORT -static struct timeval start_time; /* Time when link was started. */ -static struct pppd_stats old_link_stats; -struct pppd_stats link_stats; -unsigned link_connect_time; -int link_stats_valid; -#endif /* PPP_STATS_SUPPORT */ - -/* - * PPP Data Link Layer "protocol" table. - * One entry per supported protocol. - * The last entry must be NULL. - */ -const struct protent* const protocols[] = { - &lcp_protent, -#if PAP_SUPPORT - &pap_protent, -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - &chap_protent, -#endif /* CHAP_SUPPORT */ -#if CBCP_SUPPORT - &cbcp_protent, -#endif /* CBCP_SUPPORT */ -#if PPP_IPV4_SUPPORT - &ipcp_protent, -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT - &ipv6cp_protent, -#endif /* PPP_IPV6_SUPPORT */ -#if CCP_SUPPORT - &ccp_protent, -#endif /* CCP_SUPPORT */ -#if ECP_SUPPORT - &ecp_protent, -#endif /* ECP_SUPPORT */ -#ifdef AT_CHANGE - &atcp_protent, -#endif /* AT_CHANGE */ -#if EAP_SUPPORT - &eap_protent, -#endif /* EAP_SUPPORT */ - NULL -}; - -/* Prototypes for procedures local to this file. */ -static void ppp_do_connect(void *arg); -static err_t ppp_netif_init_cb(struct netif *netif); -#if PPP_IPV4_SUPPORT -static err_t ppp_netif_output_ip4(struct netif *netif, struct pbuf *pb, const ip4_addr_t *ipaddr); -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT -static err_t ppp_netif_output_ip6(struct netif *netif, struct pbuf *pb, const ip6_addr_t *ipaddr); -#endif /* PPP_IPV6_SUPPORT */ -static err_t ppp_netif_output(struct netif *netif, struct pbuf *pb, u16_t protocol); - -/***********************************/ -/*** PUBLIC FUNCTION DEFINITIONS ***/ -/***********************************/ -#if PPP_AUTH_SUPPORT -void ppp_set_auth(ppp_pcb *pcb, u8_t authtype, const char *user, const char *passwd) { - LWIP_ASSERT_CORE_LOCKED(); -#if PAP_SUPPORT - pcb->settings.refuse_pap = !(authtype & PPPAUTHTYPE_PAP); -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - pcb->settings.refuse_chap = !(authtype & PPPAUTHTYPE_CHAP); -#if MSCHAP_SUPPORT - pcb->settings.refuse_mschap = !(authtype & PPPAUTHTYPE_MSCHAP); - pcb->settings.refuse_mschap_v2 = !(authtype & PPPAUTHTYPE_MSCHAP_V2); -#endif /* MSCHAP_SUPPORT */ -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - pcb->settings.refuse_eap = !(authtype & PPPAUTHTYPE_EAP); -#endif /* EAP_SUPPORT */ - pcb->settings.user = user; - pcb->settings.passwd = passwd; -} -#endif /* PPP_AUTH_SUPPORT */ - -#if MPPE_SUPPORT -/* Set MPPE configuration */ -void ppp_set_mppe(ppp_pcb *pcb, u8_t flags) { - if (flags == PPP_MPPE_DISABLE) { - pcb->settings.require_mppe = 0; - return; - } - - pcb->settings.require_mppe = 1; - pcb->settings.refuse_mppe_stateful = !(flags & PPP_MPPE_ALLOW_STATEFUL); - pcb->settings.refuse_mppe_40 = !!(flags & PPP_MPPE_REFUSE_40); - pcb->settings.refuse_mppe_128 = !!(flags & PPP_MPPE_REFUSE_128); -} -#endif /* MPPE_SUPPORT */ - -#if PPP_NOTIFY_PHASE -void ppp_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb) { - pcb->notify_phase_cb = notify_phase_cb; - notify_phase_cb(pcb, pcb->phase, pcb->ctx_cb); -} -#endif /* PPP_NOTIFY_PHASE */ - -/* - * Initiate a PPP connection. - * - * This can only be called if PPP is in the dead phase. - * - * Holdoff is the time to wait (in seconds) before initiating - * the connection. - * - * If this port connects to a modem, the modem connection must be - * established before calling this. - */ -err_t ppp_connect(ppp_pcb *pcb, u16_t holdoff) { - LWIP_ASSERT_CORE_LOCKED(); - if (pcb->phase != PPP_PHASE_DEAD) { - return ERR_ALREADY; - } - - PPPDEBUG(LOG_DEBUG, ("ppp_connect[%d]: holdoff=%d\n", pcb->netif->num, holdoff)); - - magic_randomize(); - - if (holdoff == 0) { - ppp_do_connect(pcb); - return ERR_OK; - } - - new_phase(pcb, PPP_PHASE_HOLDOFF); - sys_timeout((u32_t)(holdoff*1000), ppp_do_connect, pcb); - return ERR_OK; -} - -#if PPP_SERVER -/* - * Listen for an incoming PPP connection. - * - * This can only be called if PPP is in the dead phase. - * - * If this port connects to a modem, the modem connection must be - * established before calling this. - */ -err_t ppp_listen(ppp_pcb *pcb) { - LWIP_ASSERT_CORE_LOCKED(); - if (pcb->phase != PPP_PHASE_DEAD) { - return ERR_ALREADY; - } - - PPPDEBUG(LOG_DEBUG, ("ppp_listen[%d]\n", pcb->netif->num)); - - magic_randomize(); - - if (pcb->link_cb->listen) { - new_phase(pcb, PPP_PHASE_INITIALIZE); - pcb->link_cb->listen(pcb, pcb->link_ctx_cb); - return ERR_OK; - } - return ERR_IF; -} -#endif /* PPP_SERVER */ - -/* - * Initiate the end of a PPP connection. - * Any outstanding packets in the queues are dropped. - * - * Setting nocarrier to 1 close the PPP connection without initiating the - * shutdown procedure. Always using nocarrier = 0 is still recommended, - * this is going to take a little longer time if your link is down, but - * is a safer choice for the PPP state machine. - * - * Return 0 on success, an error code on failure. - */ -err_t -ppp_close(ppp_pcb *pcb, u8_t nocarrier) -{ - LWIP_ASSERT_CORE_LOCKED(); - - pcb->err_code = PPPERR_USER; - - /* holdoff phase, cancel the reconnection */ - if (pcb->phase == PPP_PHASE_HOLDOFF) { - sys_untimeout(ppp_do_connect, pcb); - new_phase(pcb, PPP_PHASE_DEAD); - } - - /* dead phase, nothing to do, call the status callback to be consistent */ - if (pcb->phase == PPP_PHASE_DEAD) { - pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); - return ERR_OK; - } - - /* Already terminating, nothing to do */ - if (pcb->phase >= PPP_PHASE_TERMINATE) { - return ERR_INPROGRESS; - } - - /* LCP not open, close link protocol */ - if (pcb->phase < PPP_PHASE_ESTABLISH) { - new_phase(pcb, PPP_PHASE_DISCONNECT); - ppp_link_terminated(pcb); - return ERR_OK; - } - - /* - * Only accept carrier lost signal on the stable running phase in order - * to prevent changing the PPP phase FSM in transition phases. - * - * Always using nocarrier = 0 is still recommended, this is going to - * take a little longer time, but is a safer choice from FSM point of view. - */ - if (nocarrier && pcb->phase == PPP_PHASE_RUNNING) { - PPPDEBUG(LOG_DEBUG, ("ppp_close[%d]: carrier lost -> lcp_lowerdown\n", pcb->netif->num)); - lcp_lowerdown(pcb); - /* forced link termination, this will force link protocol to disconnect. */ - link_terminated(pcb); - return ERR_OK; - } - - /* Disconnect */ - PPPDEBUG(LOG_DEBUG, ("ppp_close[%d]: kill_link -> lcp_close\n", pcb->netif->num)); - /* LCP soft close request. */ - lcp_close(pcb, "User request"); - return ERR_OK; -} - -/* - * Release the control block. - * - * This can only be called if PPP is in the dead phase. - * - * You must use ppp_close() before if you wish to terminate - * an established PPP session. - * - * Return 0 on success, an error code on failure. - */ -err_t ppp_free(ppp_pcb *pcb) { - err_t err; - LWIP_ASSERT_CORE_LOCKED(); - if (pcb->phase != PPP_PHASE_DEAD) { - return ERR_CONN; - } - - PPPDEBUG(LOG_DEBUG, ("ppp_free[%d]\n", pcb->netif->num)); - - netif_remove(pcb->netif); - - err = pcb->link_cb->free(pcb, pcb->link_ctx_cb); - - LWIP_MEMPOOL_FREE(PPP_PCB, pcb); - return err; -} - -/* Get and set parameters for the given connection. - * Return 0 on success, an error code on failure. */ -err_t -ppp_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg) -{ - LWIP_ASSERT_CORE_LOCKED(); - if (pcb == NULL) { - return ERR_VAL; - } - - switch(cmd) { - case PPPCTLG_UPSTATUS: /* Get the PPP up status. */ - if (!arg) { - goto fail; - } - *(int *)arg = (int)(0 -#if PPP_IPV4_SUPPORT - || pcb->if4_up -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT - || pcb->if6_up -#endif /* PPP_IPV6_SUPPORT */ - ); - return ERR_OK; - - case PPPCTLG_ERRCODE: /* Get the PPP error code. */ - if (!arg) { - goto fail; - } - *(int *)arg = (int)(pcb->err_code); - return ERR_OK; - - default: - goto fail; - } - -fail: - return ERR_VAL; -} - - -/**********************************/ -/*** LOCAL FUNCTION DEFINITIONS ***/ -/**********************************/ - -static void ppp_do_connect(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - - LWIP_ASSERT("pcb->phase == PPP_PHASE_DEAD || pcb->phase == PPP_PHASE_HOLDOFF", pcb->phase == PPP_PHASE_DEAD || pcb->phase == PPP_PHASE_HOLDOFF); - - new_phase(pcb, PPP_PHASE_INITIALIZE); - pcb->link_cb->connect(pcb, pcb->link_ctx_cb); -} - -/* - * ppp_netif_init_cb - netif init callback - */ -static err_t ppp_netif_init_cb(struct netif *netif) { - netif->name[0] = 'p'; - netif->name[1] = 'p'; -#if PPP_IPV4_SUPPORT - netif->output = ppp_netif_output_ip4; -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT - netif->output_ip6 = ppp_netif_output_ip6; -#endif /* PPP_IPV6_SUPPORT */ - netif->flags = NETIF_FLAG_UP; -#if LWIP_NETIF_HOSTNAME - /* @todo: Initialize interface hostname */ - /* netif_set_hostname(netif, "lwip"); */ -#endif /* LWIP_NETIF_HOSTNAME */ - return ERR_OK; -} - -#if PPP_IPV4_SUPPORT -/* - * Send an IPv4 packet on the given connection. - */ -static err_t ppp_netif_output_ip4(struct netif *netif, struct pbuf *pb, const ip4_addr_t *ipaddr) { - LWIP_UNUSED_ARG(ipaddr); - return ppp_netif_output(netif, pb, PPP_IP); -} -#endif /* PPP_IPV4_SUPPORT */ - -#if PPP_IPV6_SUPPORT -/* - * Send an IPv6 packet on the given connection. - */ -static err_t ppp_netif_output_ip6(struct netif *netif, struct pbuf *pb, const ip6_addr_t *ipaddr) { - LWIP_UNUSED_ARG(ipaddr); - return ppp_netif_output(netif, pb, PPP_IPV6); -} -#endif /* PPP_IPV6_SUPPORT */ - -static err_t ppp_netif_output(struct netif *netif, struct pbuf *pb, u16_t protocol) { - ppp_pcb *pcb = (ppp_pcb*)netif->state; - err_t err; - struct pbuf *fpb = NULL; - - /* Check that the link is up. */ - if (0 -#if PPP_IPV4_SUPPORT - || (protocol == PPP_IP && !pcb->if4_up) -#endif /* PPP_IPV4_SUPPORT */ -#if PPP_IPV6_SUPPORT - || (protocol == PPP_IPV6 && !pcb->if6_up) -#endif /* PPP_IPV6_SUPPORT */ - ) { - PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: link not up\n", pcb->netif->num)); - goto err_rte_drop; - } - -#if MPPE_SUPPORT - /* If MPPE is required, refuse any IP packet until we are able to crypt them. */ - if (pcb->settings.require_mppe && pcb->ccp_transmit_method != CI_MPPE) { - PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: MPPE required, not up\n", pcb->netif->num)); - goto err_rte_drop; - } -#endif /* MPPE_SUPPORT */ - -#if VJ_SUPPORT - /* - * Attempt Van Jacobson header compression if VJ is configured and - * this is an IP packet. - */ - if (protocol == PPP_IP && pcb->vj_enabled) { - switch (vj_compress_tcp(&pcb->vj_comp, &pb)) { - case TYPE_IP: - /* No change... - protocol = PPP_IP; */ - break; - case TYPE_COMPRESSED_TCP: - /* vj_compress_tcp() returns a new allocated pbuf, indicate we should free - * our duplicated pbuf later */ - fpb = pb; - protocol = PPP_VJC_COMP; - break; - case TYPE_UNCOMPRESSED_TCP: - /* vj_compress_tcp() returns a new allocated pbuf, indicate we should free - * our duplicated pbuf later */ - fpb = pb; - protocol = PPP_VJC_UNCOMP; - break; - default: - PPPDEBUG(LOG_WARNING, ("ppp_netif_output[%d]: bad IP packet\n", pcb->netif->num)); - LINK_STATS_INC(link.proterr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(pcb->netif, ifoutdiscards); - return ERR_VAL; - } - } -#endif /* VJ_SUPPORT */ - -#if CCP_SUPPORT - switch (pcb->ccp_transmit_method) { - case 0: - break; /* Don't compress */ -#if MPPE_SUPPORT - case CI_MPPE: - if ((err = mppe_compress(pcb, &pcb->mppe_comp, &pb, protocol)) != ERR_OK) { - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); - goto err; - } - /* if VJ compressor returned a new allocated pbuf, free it */ - if (fpb) { - pbuf_free(fpb); - } - /* mppe_compress() returns a new allocated pbuf, indicate we should free - * our duplicated pbuf later */ - fpb = pb; - protocol = PPP_COMP; - break; -#endif /* MPPE_SUPPORT */ - default: - PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: bad CCP transmit method\n", pcb->netif->num)); - goto err_rte_drop; /* Cannot really happen, we only negotiate what we are able to do */ - } -#endif /* CCP_SUPPORT */ - - err = pcb->link_cb->netif_output(pcb, pcb->link_ctx_cb, pb, protocol); - goto err; - -err_rte_drop: - err = ERR_RTE; - LINK_STATS_INC(link.rterr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(netif, ifoutdiscards); -err: - if (fpb) { - pbuf_free(fpb); - } - return err; -} - -/************************************/ -/*** PRIVATE FUNCTION DEFINITIONS ***/ -/************************************/ - -/* Initialize the PPP subsystem. */ -int ppp_init(void) -{ -#if PPPOS_SUPPORT - LWIP_MEMPOOL_INIT(PPPOS_PCB); -#endif -#if PPPOE_SUPPORT - LWIP_MEMPOOL_INIT(PPPOE_IF); -#endif -#if PPPOL2TP_SUPPORT - LWIP_MEMPOOL_INIT(PPPOL2TP_PCB); -#endif -#if LWIP_PPP_API && LWIP_MPU_COMPATIBLE - LWIP_MEMPOOL_INIT(PPPAPI_MSG); -#endif - - LWIP_MEMPOOL_INIT(PPP_PCB); - - /* - * Initialize magic number generator now so that protocols may - * use magic numbers in initialization. - */ - magic_init(); - - return 0; -} - -/* - * Create a new PPP control block. - * - * This initializes the PPP control block but does not - * attempt to negotiate the LCP session. - * - * Return a new PPP connection control block pointer - * on success or a null pointer on failure. - */ -ppp_pcb *ppp_new(struct netif *pppif, const struct link_callbacks *callbacks, void *link_ctx_cb, ppp_link_status_cb_fn link_status_cb, void *ctx_cb) { - ppp_pcb *pcb; - const struct protent *protp; - int i; - - /* PPP is single-threaded: without a callback, - * there is no way to know when the link is up. */ - if (link_status_cb == NULL) { - return NULL; - } - - pcb = (ppp_pcb*)LWIP_MEMPOOL_ALLOC(PPP_PCB); - if (pcb == NULL) { - return NULL; - } - - memset(pcb, 0, sizeof(ppp_pcb)); - - /* default configuration */ -#if PAP_SUPPORT - pcb->settings.pap_timeout_time = UPAP_DEFTIMEOUT; - pcb->settings.pap_max_transmits = UPAP_DEFTRANSMITS; -#if PPP_SERVER - pcb->settings.pap_req_timeout = UPAP_DEFREQTIME; -#endif /* PPP_SERVER */ -#endif /* PAP_SUPPORT */ - -#if CHAP_SUPPORT - pcb->settings.chap_timeout_time = CHAP_DEFTIMEOUT; - pcb->settings.chap_max_transmits = CHAP_DEFTRANSMITS; -#if PPP_SERVER - pcb->settings.chap_rechallenge_time = CHAP_DEFRECHALLENGETIME; -#endif /* PPP_SERVER */ -#endif /* CHAP_SUPPPORT */ - -#if EAP_SUPPORT - pcb->settings.eap_req_time = EAP_DEFREQTIME; - pcb->settings.eap_allow_req = EAP_DEFALLOWREQ; -#if PPP_SERVER - pcb->settings.eap_timeout_time = EAP_DEFTIMEOUT; - pcb->settings.eap_max_transmits = EAP_DEFTRANSMITS; -#endif /* PPP_SERVER */ -#endif /* EAP_SUPPORT */ - - pcb->settings.lcp_loopbackfail = LCP_DEFLOOPBACKFAIL; - pcb->settings.lcp_echo_interval = LCP_ECHOINTERVAL; - pcb->settings.lcp_echo_fails = LCP_MAXECHOFAILS; - - pcb->settings.fsm_timeout_time = FSM_DEFTIMEOUT; - pcb->settings.fsm_max_conf_req_transmits = FSM_DEFMAXCONFREQS; - pcb->settings.fsm_max_term_transmits = FSM_DEFMAXTERMREQS; - pcb->settings.fsm_max_nak_loops = FSM_DEFMAXNAKLOOPS; - - pcb->netif = pppif; - MIB2_INIT_NETIF(pppif, snmp_ifType_ppp, 0); - if (!netif_add(pcb->netif, -#if LWIP_IPV4 - IP4_ADDR_ANY4, IP4_ADDR_BROADCAST, IP4_ADDR_ANY4, -#endif /* LWIP_IPV4 */ - (void *)pcb, ppp_netif_init_cb, NULL)) { - LWIP_MEMPOOL_FREE(PPP_PCB, pcb); - PPPDEBUG(LOG_ERR, ("ppp_new: netif_add failed\n")); - return NULL; - } - - pcb->link_cb = callbacks; - pcb->link_ctx_cb = link_ctx_cb; - pcb->link_status_cb = link_status_cb; - pcb->ctx_cb = ctx_cb; - - /* - * Initialize each protocol. - */ - for (i = 0; (protp = protocols[i]) != NULL; ++i) { - (*protp->init)(pcb); - } - - new_phase(pcb, PPP_PHASE_DEAD); - return pcb; -} - -/** Initiate LCP open request */ -void ppp_start(ppp_pcb *pcb) { - PPPDEBUG(LOG_DEBUG, ("ppp_start[%d]\n", pcb->netif->num)); - - /* Clean data not taken care by anything else, mostly shared data. */ -#if PPP_STATS_SUPPORT - link_stats_valid = 0; -#endif /* PPP_STATS_SUPPORT */ -#if MPPE_SUPPORT - pcb->mppe_keys_set = 0; - memset(&pcb->mppe_comp, 0, sizeof(pcb->mppe_comp)); - memset(&pcb->mppe_decomp, 0, sizeof(pcb->mppe_decomp)); -#endif /* MPPE_SUPPORT */ -#if VJ_SUPPORT - vj_compress_init(&pcb->vj_comp); -#endif /* VJ_SUPPORT */ - - /* Start protocol */ - new_phase(pcb, PPP_PHASE_ESTABLISH); - lcp_open(pcb); - lcp_lowerup(pcb); - PPPDEBUG(LOG_DEBUG, ("ppp_start[%d]: finished\n", pcb->netif->num)); -} - -/** Called when link failed to setup */ -void ppp_link_failed(ppp_pcb *pcb) { - PPPDEBUG(LOG_DEBUG, ("ppp_link_failed[%d]\n", pcb->netif->num)); - new_phase(pcb, PPP_PHASE_DEAD); - pcb->err_code = PPPERR_OPEN; - pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); -} - -/** Called when link is normally down (i.e. it was asked to end) */ -void ppp_link_end(ppp_pcb *pcb) { - PPPDEBUG(LOG_DEBUG, ("ppp_link_end[%d]\n", pcb->netif->num)); - new_phase(pcb, PPP_PHASE_DEAD); - if (pcb->err_code == PPPERR_NONE) { - pcb->err_code = PPPERR_CONNECT; - } - pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); -} - -/* - * Pass the processed input packet to the appropriate handler. - * This function and all handlers run in the context of the tcpip_thread - */ -void ppp_input(ppp_pcb *pcb, struct pbuf *pb) { - u16_t protocol; -#if PPP_DEBUG && PPP_PROTOCOLNAME - const char *pname; -#endif /* PPP_DEBUG && PPP_PROTOCOLNAME */ - - magic_randomize(); - - if (pb->len < 2) { - PPPDEBUG(LOG_ERR, ("ppp_input[%d]: packet too short\n", pcb->netif->num)); - goto drop; - } - protocol = (((u8_t *)pb->payload)[0] << 8) | ((u8_t*)pb->payload)[1]; - -#if PRINTPKT_SUPPORT - ppp_dump_packet(pcb, "rcvd", (unsigned char *)pb->payload, pb->len); -#endif /* PRINTPKT_SUPPORT */ - - pbuf_remove_header(pb, sizeof(protocol)); - - LINK_STATS_INC(link.recv); - MIB2_STATS_NETIF_INC(pcb->netif, ifinucastpkts); - MIB2_STATS_NETIF_ADD(pcb->netif, ifinoctets, pb->tot_len); - - /* - * Toss all non-LCP packets unless LCP is OPEN. - */ - if (protocol != PPP_LCP && pcb->lcp_fsm.state != PPP_FSM_OPENED) { - ppp_dbglog("Discarded non-LCP packet when LCP not open"); - goto drop; - } - - /* - * Until we get past the authentication phase, toss all packets - * except LCP, LQR and authentication packets. - */ - if (pcb->phase <= PPP_PHASE_AUTHENTICATE - && !(protocol == PPP_LCP -#if LQR_SUPPORT - || protocol == PPP_LQR -#endif /* LQR_SUPPORT */ -#if PAP_SUPPORT - || protocol == PPP_PAP -#endif /* PAP_SUPPORT */ -#if CHAP_SUPPORT - || protocol == PPP_CHAP -#endif /* CHAP_SUPPORT */ -#if EAP_SUPPORT - || protocol == PPP_EAP -#endif /* EAP_SUPPORT */ - )) { - ppp_dbglog("discarding proto 0x%x in phase %d", protocol, pcb->phase); - goto drop; - } - -#if CCP_SUPPORT -#if MPPE_SUPPORT - /* - * MPPE is required and unencrypted data has arrived (this - * should never happen!). We should probably drop the link if - * the protocol is in the range of what should be encrypted. - * At the least, we drop this packet. - */ - if (pcb->settings.require_mppe && protocol != PPP_COMP && protocol < 0x8000) { - PPPDEBUG(LOG_ERR, ("ppp_input[%d]: MPPE required, received unencrypted data!\n", pcb->netif->num)); - goto drop; - } -#endif /* MPPE_SUPPORT */ - - if (protocol == PPP_COMP) { - u8_t *pl; - - switch (pcb->ccp_receive_method) { -#if MPPE_SUPPORT - case CI_MPPE: - if (mppe_decompress(pcb, &pcb->mppe_decomp, &pb) != ERR_OK) { - goto drop; - } - break; -#endif /* MPPE_SUPPORT */ - default: - PPPDEBUG(LOG_ERR, ("ppp_input[%d]: bad CCP receive method\n", pcb->netif->num)); - goto drop; /* Cannot really happen, we only negotiate what we are able to do */ - } - - /* Assume no PFC */ - if (pb->len < 2) { - goto drop; - } - - /* Extract and hide protocol (do PFC decompression if necessary) */ - pl = (u8_t*)pb->payload; - if (pl[0] & 0x01) { - protocol = pl[0]; - pbuf_remove_header(pb, 1); - } else { - protocol = (pl[0] << 8) | pl[1]; - pbuf_remove_header(pb, 2); - } - } -#endif /* CCP_SUPPORT */ - - switch(protocol) { - -#if PPP_IPV4_SUPPORT - case PPP_IP: /* Internet Protocol */ - PPPDEBUG(LOG_INFO, ("ppp_input[%d]: ip in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); - ip4_input(pb, pcb->netif); - return; -#endif /* PPP_IPV4_SUPPORT */ - -#if PPP_IPV6_SUPPORT - case PPP_IPV6: /* Internet Protocol Version 6 */ - PPPDEBUG(LOG_INFO, ("ppp_input[%d]: ip6 in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); - ip6_input(pb, pcb->netif); - return; -#endif /* PPP_IPV6_SUPPORT */ - -#if VJ_SUPPORT - case PPP_VJC_COMP: /* VJ compressed TCP */ - /* - * Clip off the VJ header and prepend the rebuilt TCP/IP header and - * pass the result to IP. - */ - PPPDEBUG(LOG_INFO, ("ppp_input[%d]: vj_comp in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); - if (pcb->vj_enabled && vj_uncompress_tcp(&pb, &pcb->vj_comp) >= 0) { - ip4_input(pb, pcb->netif); - return; - } - /* Something's wrong so drop it. */ - PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping VJ compressed\n", pcb->netif->num)); - break; - - case PPP_VJC_UNCOMP: /* VJ uncompressed TCP */ - /* - * Process the TCP/IP header for VJ header compression and then pass - * the packet to IP. - */ - PPPDEBUG(LOG_INFO, ("ppp_input[%d]: vj_un in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); - if (pcb->vj_enabled && vj_uncompress_uncomp(pb, &pcb->vj_comp) >= 0) { - ip4_input(pb, pcb->netif); - return; - } - /* Something's wrong so drop it. */ - PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping VJ uncompressed\n", pcb->netif->num)); - break; -#endif /* VJ_SUPPORT */ - - default: { - int i; - const struct protent *protp; - - /* - * Upcall the proper protocol input routine. - */ - for (i = 0; (protp = protocols[i]) != NULL; ++i) { - if (protp->protocol == protocol) { - pb = pbuf_coalesce(pb, PBUF_RAW); - (*protp->input)(pcb, (u8_t*)pb->payload, pb->len); - goto out; - } -#if 0 /* UNUSED - * - * This is actually a (hacked?) way for the Linux kernel to pass a data - * packet to pppd. pppd in normal condition only do signaling - * (LCP, PAP, CHAP, IPCP, ...) and does not handle any data packet at all. - * - * We don't even need this interface, which is only there because of PPP - * interface limitation between Linux kernel and pppd. For MPPE, which uses - * CCP to negotiate although it is not really a (de)compressor, we added - * ccp_resetrequest() in CCP and MPPE input data flow is calling either - * ccp_resetrequest() or lcp_close() if the issue is, respectively, non-fatal - * or fatal, this is what ccp_datainput() really do. - */ - if (protocol == (protp->protocol & ~0x8000) - && protp->datainput != NULL) { - (*protp->datainput)(pcb, pb->payload, pb->len); - goto out; - } -#endif /* UNUSED */ - } - -#if PPP_DEBUG -#if PPP_PROTOCOLNAME - pname = protocol_name(protocol); - if (pname != NULL) { - ppp_warn("Unsupported protocol '%s' (0x%x) received", pname, protocol); - } else -#endif /* PPP_PROTOCOLNAME */ - ppp_warn("Unsupported protocol 0x%x received", protocol); -#endif /* PPP_DEBUG */ - if (pbuf_add_header(pb, sizeof(protocol))) { - PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping (pbuf_add_header failed)\n", pcb->netif->num)); - goto drop; - } - lcp_sprotrej(pcb, (u8_t*)pb->payload, pb->len); - } - break; - } - -drop: - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(pcb->netif, ifindiscards); - -out: - pbuf_free(pb); -} - -/* - * Write a pbuf to a ppp link, only used from PPP functions - * to send PPP packets. - * - * IPv4 and IPv6 packets from lwIP are sent, respectively, - * with ppp_netif_output_ip4() and ppp_netif_output_ip6() - * functions (which are callbacks of the netif PPP interface). - */ -err_t ppp_write(ppp_pcb *pcb, struct pbuf *p) { -#if PRINTPKT_SUPPORT - ppp_dump_packet(pcb, "sent", (unsigned char *)p->payload+2, p->len-2); -#endif /* PRINTPKT_SUPPORT */ - return pcb->link_cb->write(pcb, pcb->link_ctx_cb, p); -} - -void ppp_link_terminated(ppp_pcb *pcb) { - PPPDEBUG(LOG_DEBUG, ("ppp_link_terminated[%d]\n", pcb->netif->num)); - pcb->link_cb->disconnect(pcb, pcb->link_ctx_cb); - PPPDEBUG(LOG_DEBUG, ("ppp_link_terminated[%d]: finished.\n", pcb->netif->num)); -} - - -/************************************************************************ - * Functions called by various PPP subsystems to configure - * the PPP interface or change the PPP phase. - */ - -/* - * new_phase - signal the start of a new phase of pppd's operation. - */ -void new_phase(ppp_pcb *pcb, int p) { - pcb->phase = p; - PPPDEBUG(LOG_DEBUG, ("ppp phase changed[%d]: phase=%d\n", pcb->netif->num, pcb->phase)); -#if PPP_NOTIFY_PHASE - if (pcb->notify_phase_cb != NULL) { - pcb->notify_phase_cb(pcb, p, pcb->ctx_cb); - } -#endif /* PPP_NOTIFY_PHASE */ -} - -/* - * ppp_send_config - configure the transmit-side characteristics of - * the ppp interface. - */ -int ppp_send_config(ppp_pcb *pcb, int mtu, u32_t accm, int pcomp, int accomp) { - LWIP_UNUSED_ARG(mtu); - /* pcb->mtu = mtu; -- set correctly with netif_set_mtu */ - - if (pcb->link_cb->send_config) { - pcb->link_cb->send_config(pcb, pcb->link_ctx_cb, accm, pcomp, accomp); - } - - PPPDEBUG(LOG_INFO, ("ppp_send_config[%d]\n", pcb->netif->num) ); - return 0; -} - -/* - * ppp_recv_config - configure the receive-side characteristics of - * the ppp interface. - */ -int ppp_recv_config(ppp_pcb *pcb, int mru, u32_t accm, int pcomp, int accomp) { - LWIP_UNUSED_ARG(mru); - - if (pcb->link_cb->recv_config) { - pcb->link_cb->recv_config(pcb, pcb->link_ctx_cb, accm, pcomp, accomp); - } - - PPPDEBUG(LOG_INFO, ("ppp_recv_config[%d]\n", pcb->netif->num)); - return 0; -} - -#if PPP_IPV4_SUPPORT -/* - * sifaddr - Config the interface IP addresses and netmask. - */ -int sifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr, u32_t netmask) { - ip4_addr_t ip, nm, gw; - - ip4_addr_set_u32(&ip, our_adr); - ip4_addr_set_u32(&nm, netmask); - ip4_addr_set_u32(&gw, his_adr); - netif_set_addr(pcb->netif, &ip, &nm, &gw); - return 1; -} - -/******************************************************************** - * - * cifaddr - Clear the interface IP addresses, and delete routes - * through the interface if possible. - */ -int cifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr) { - LWIP_UNUSED_ARG(our_adr); - LWIP_UNUSED_ARG(his_adr); - - netif_set_addr(pcb->netif, IP4_ADDR_ANY4, IP4_ADDR_BROADCAST, IP4_ADDR_ANY4); - return 1; -} - -#if 0 /* UNUSED - PROXY ARP */ -/******************************************************************** - * - * sifproxyarp - Make a proxy ARP entry for the peer. - */ - -int sifproxyarp(ppp_pcb *pcb, u32_t his_adr) { - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(his_adr); - return 0; -} - -/******************************************************************** - * - * cifproxyarp - Delete the proxy ARP entry for the peer. - */ - -int cifproxyarp(ppp_pcb *pcb, u32_t his_adr) { - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(his_adr); - return 0; -} -#endif /* UNUSED - PROXY ARP */ - -#if LWIP_DNS -/* - * sdns - Config the DNS servers - */ -int sdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2) { - ip_addr_t ns; - LWIP_UNUSED_ARG(pcb); - - ip_addr_set_ip4_u32_val(ns, ns1); - dns_setserver(0, &ns); - ip_addr_set_ip4_u32_val(ns, ns2); - dns_setserver(1, &ns); - return 1; -} - -/******************************************************************** - * - * cdns - Clear the DNS servers - */ -int cdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2) { - const ip_addr_t *nsa; - ip_addr_t nsb; - LWIP_UNUSED_ARG(pcb); - - nsa = dns_getserver(0); - ip_addr_set_ip4_u32_val(nsb, ns1); - if (ip_addr_cmp(nsa, &nsb)) { - dns_setserver(0, IP_ADDR_ANY); - } - nsa = dns_getserver(1); - ip_addr_set_ip4_u32_val(nsb, ns2); - if (ip_addr_cmp(nsa, &nsb)) { - dns_setserver(1, IP_ADDR_ANY); - } - return 1; -} -#endif /* LWIP_DNS */ - -#if VJ_SUPPORT -/******************************************************************** - * - * sifvjcomp - config tcp header compression - */ -int sifvjcomp(ppp_pcb *pcb, int vjcomp, int cidcomp, int maxcid) { - pcb->vj_enabled = vjcomp; - pcb->vj_comp.compressSlot = cidcomp; - pcb->vj_comp.maxSlotIndex = maxcid; - PPPDEBUG(LOG_INFO, ("sifvjcomp[%d]: VJ compress enable=%d slot=%d max slot=%d\n", - pcb->netif->num, vjcomp, cidcomp, maxcid)); - return 0; -} -#endif /* VJ_SUPPORT */ - -/* - * sifup - Config the interface up and enable IP packets to pass. - */ -int sifup(ppp_pcb *pcb) { - pcb->if4_up = 1; - pcb->err_code = PPPERR_NONE; - netif_set_link_up(pcb->netif); - - PPPDEBUG(LOG_DEBUG, ("sifup[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); - pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); - return 1; -} - -/******************************************************************** - * - * sifdown - Disable the indicated protocol and config the interface - * down if there are no remaining protocols. - */ -int sifdown(ppp_pcb *pcb) { - - pcb->if4_up = 0; - - if (1 -#if PPP_IPV6_SUPPORT - /* set the interface down if IPv6 is down as well */ - && !pcb->if6_up -#endif /* PPP_IPV6_SUPPORT */ - ) { - /* make sure the netif link callback is called */ - netif_set_link_down(pcb->netif); - } - PPPDEBUG(LOG_DEBUG, ("sifdown[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); - return 1; -} - -/******************************************************************** - * - * Return user specified netmask, modified by any mask we might determine - * for address `addr' (in network byte order). - * Here we scan through the system's list of interfaces, looking for - * any non-point-to-point interfaces which might appear to be on the same - * network as `addr'. If we find any, we OR in their netmask to the - * user-specified netmask. - */ -u32_t get_mask(u32_t addr) { -#if 0 - u32_t mask, nmask; - - addr = lwip_htonl(addr); - if (IP_CLASSA(addr)) { /* determine network mask for address class */ - nmask = IP_CLASSA_NET; - } else if (IP_CLASSB(addr)) { - nmask = IP_CLASSB_NET; - } else { - nmask = IP_CLASSC_NET; - } - - /* class D nets are disallowed by bad_ip_adrs */ - mask = PP_HTONL(0xffffff00UL) | lwip_htonl(nmask); - - /* XXX - * Scan through the system's network interfaces. - * Get each netmask and OR them into our mask. - */ - /* return mask; */ - return mask; -#endif /* 0 */ - LWIP_UNUSED_ARG(addr); - return IPADDR_BROADCAST; -} -#endif /* PPP_IPV4_SUPPORT */ - -#if PPP_IPV6_SUPPORT -#define IN6_LLADDR_FROM_EUI64(ip6, eui64) do { \ - ip6.addr[0] = PP_HTONL(0xfe800000); \ - ip6.addr[1] = 0; \ - eui64_copy(eui64, ip6.addr[2]); \ - } while (0) - -/******************************************************************** - * - * sif6addr - Config the interface with an IPv6 link-local address - */ -int sif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64) { - ip6_addr_t ip6; - LWIP_UNUSED_ARG(his_eui64); - - IN6_LLADDR_FROM_EUI64(ip6, our_eui64); - netif_ip6_addr_set(pcb->netif, 0, &ip6); - netif_ip6_addr_set_state(pcb->netif, 0, IP6_ADDR_PREFERRED); - /* FIXME: should we add an IPv6 static neighbor using his_eui64 ? */ - return 1; -} - -/******************************************************************** - * - * cif6addr - Remove IPv6 address from interface - */ -int cif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64) { - LWIP_UNUSED_ARG(our_eui64); - LWIP_UNUSED_ARG(his_eui64); - - netif_ip6_addr_set_state(pcb->netif, 0, IP6_ADDR_INVALID); - netif_ip6_addr_set(pcb->netif, 0, IP6_ADDR_ANY6); - return 1; -} - -/* - * sif6up - Config the interface up and enable IPv6 packets to pass. - */ -int sif6up(ppp_pcb *pcb) { - - pcb->if6_up = 1; - pcb->err_code = PPPERR_NONE; - netif_set_link_up(pcb->netif); - - PPPDEBUG(LOG_DEBUG, ("sif6up[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); - pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); - return 1; -} - -/******************************************************************** - * - * sif6down - Disable the indicated protocol and config the interface - * down if there are no remaining protocols. - */ -int sif6down(ppp_pcb *pcb) { - - pcb->if6_up = 0; - - if (1 -#if PPP_IPV4_SUPPORT - /* set the interface down if IPv4 is down as well */ - && !pcb->if4_up -#endif /* PPP_IPV4_SUPPORT */ - ) { - /* make sure the netif link callback is called */ - netif_set_link_down(pcb->netif); - } - PPPDEBUG(LOG_DEBUG, ("sif6down[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); - return 1; -} -#endif /* PPP_IPV6_SUPPORT */ - -#if DEMAND_SUPPORT -/* - * sifnpmode - Set the mode for handling packets for a given NP. - */ -int sifnpmode(ppp_pcb *pcb, int proto, enum NPmode mode) { - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(proto); - LWIP_UNUSED_ARG(mode); - return 0; -} -#endif /* DEMAND_SUPPORT */ - -/* - * netif_set_mtu - set the MTU on the PPP network interface. - */ -void netif_set_mtu(ppp_pcb *pcb, int mtu) { - - pcb->netif->mtu = mtu; - PPPDEBUG(LOG_INFO, ("netif_set_mtu[%d]: mtu=%d\n", pcb->netif->num, mtu)); -} - -/* - * netif_get_mtu - get PPP interface MTU - */ -int netif_get_mtu(ppp_pcb *pcb) { - - return pcb->netif->mtu; -} - -#if CCP_SUPPORT -#if 0 /* unused */ -/* - * ccp_test - whether a given compression method is acceptable for use. - */ -int -ccp_test(ppp_pcb *pcb, u_char *opt_ptr, int opt_len, int for_transmit) -{ - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(opt_ptr); - LWIP_UNUSED_ARG(opt_len); - LWIP_UNUSED_ARG(for_transmit); - return -1; -} -#endif /* unused */ - -/* - * ccp_set - inform about the current state of CCP. - */ -void -ccp_set(ppp_pcb *pcb, u8_t isopen, u8_t isup, u8_t receive_method, u8_t transmit_method) -{ - LWIP_UNUSED_ARG(isopen); - LWIP_UNUSED_ARG(isup); - pcb->ccp_receive_method = receive_method; - pcb->ccp_transmit_method = transmit_method; - PPPDEBUG(LOG_DEBUG, ("ccp_set[%d]: is_open=%d, is_up=%d, receive_method=%u, transmit_method=%u\n", - pcb->netif->num, isopen, isup, receive_method, transmit_method)); -} - -void -ccp_reset_comp(ppp_pcb *pcb) -{ - switch (pcb->ccp_transmit_method) { -#if MPPE_SUPPORT - case CI_MPPE: - mppe_comp_reset(pcb, &pcb->mppe_comp); - break; -#endif /* MPPE_SUPPORT */ - default: - break; - } -} - -void -ccp_reset_decomp(ppp_pcb *pcb) -{ - switch (pcb->ccp_receive_method) { -#if MPPE_SUPPORT - case CI_MPPE: - mppe_decomp_reset(pcb, &pcb->mppe_decomp); - break; -#endif /* MPPE_SUPPORT */ - default: - break; - } -} - -#if 0 /* unused */ -/* - * ccp_fatal_error - returns 1 if decompression was disabled as a - * result of an error detected after decompression of a packet, - * 0 otherwise. This is necessary because of patent nonsense. - */ -int -ccp_fatal_error(ppp_pcb *pcb) -{ - LWIP_UNUSED_ARG(pcb); - return 1; -} -#endif /* unused */ -#endif /* CCP_SUPPORT */ - -#if PPP_IDLETIMELIMIT -/******************************************************************** - * - * get_idle_time - return how long the link has been idle. - */ -int get_idle_time(ppp_pcb *pcb, struct ppp_idle *ip) { - /* FIXME: add idle time support and make it optional */ - LWIP_UNUSED_ARG(pcb); - LWIP_UNUSED_ARG(ip); - return 1; -} -#endif /* PPP_IDLETIMELIMIT */ - -#if DEMAND_SUPPORT -/******************************************************************** - * - * get_loop_output - get outgoing packets from the ppp device, - * and detect when we want to bring the real link up. - * Return value is 1 if we need to bring up the link, 0 otherwise. - */ -int get_loop_output(void) { - return 0; -} -#endif /* DEMAND_SUPPORT */ - -#if PPP_PROTOCOLNAME -/* List of protocol names, to make our messages a little more informative. */ -struct protocol_list { - u_short proto; - const char *name; -} const protocol_list[] = { - { 0x21, "IP" }, - { 0x23, "OSI Network Layer" }, - { 0x25, "Xerox NS IDP" }, - { 0x27, "DECnet Phase IV" }, - { 0x29, "Appletalk" }, - { 0x2b, "Novell IPX" }, - { 0x2d, "VJ compressed TCP/IP" }, - { 0x2f, "VJ uncompressed TCP/IP" }, - { 0x31, "Bridging PDU" }, - { 0x33, "Stream Protocol ST-II" }, - { 0x35, "Banyan Vines" }, - { 0x39, "AppleTalk EDDP" }, - { 0x3b, "AppleTalk SmartBuffered" }, - { 0x3d, "Multi-Link" }, - { 0x3f, "NETBIOS Framing" }, - { 0x41, "Cisco Systems" }, - { 0x43, "Ascom Timeplex" }, - { 0x45, "Fujitsu Link Backup and Load Balancing (LBLB)" }, - { 0x47, "DCA Remote Lan" }, - { 0x49, "Serial Data Transport Protocol (PPP-SDTP)" }, - { 0x4b, "SNA over 802.2" }, - { 0x4d, "SNA" }, - { 0x4f, "IP6 Header Compression" }, - { 0x51, "KNX Bridging Data" }, - { 0x53, "Encryption" }, - { 0x55, "Individual Link Encryption" }, - { 0x57, "IPv6" }, - { 0x59, "PPP Muxing" }, - { 0x5b, "Vendor-Specific Network Protocol" }, - { 0x61, "RTP IPHC Full Header" }, - { 0x63, "RTP IPHC Compressed TCP" }, - { 0x65, "RTP IPHC Compressed non-TCP" }, - { 0x67, "RTP IPHC Compressed UDP 8" }, - { 0x69, "RTP IPHC Compressed RTP 8" }, - { 0x6f, "Stampede Bridging" }, - { 0x73, "MP+" }, - { 0xc1, "NTCITS IPI" }, - { 0xfb, "single-link compression" }, - { 0xfd, "Compressed Datagram" }, - { 0x0201, "802.1d Hello Packets" }, - { 0x0203, "IBM Source Routing BPDU" }, - { 0x0205, "DEC LANBridge100 Spanning Tree" }, - { 0x0207, "Cisco Discovery Protocol" }, - { 0x0209, "Netcs Twin Routing" }, - { 0x020b, "STP - Scheduled Transfer Protocol" }, - { 0x020d, "EDP - Extreme Discovery Protocol" }, - { 0x0211, "Optical Supervisory Channel Protocol" }, - { 0x0213, "Optical Supervisory Channel Protocol" }, - { 0x0231, "Luxcom" }, - { 0x0233, "Sigma Network Systems" }, - { 0x0235, "Apple Client Server Protocol" }, - { 0x0281, "MPLS Unicast" }, - { 0x0283, "MPLS Multicast" }, - { 0x0285, "IEEE p1284.4 standard - data packets" }, - { 0x0287, "ETSI TETRA Network Protocol Type 1" }, - { 0x0289, "Multichannel Flow Treatment Protocol" }, - { 0x2063, "RTP IPHC Compressed TCP No Delta" }, - { 0x2065, "RTP IPHC Context State" }, - { 0x2067, "RTP IPHC Compressed UDP 16" }, - { 0x2069, "RTP IPHC Compressed RTP 16" }, - { 0x4001, "Cray Communications Control Protocol" }, - { 0x4003, "CDPD Mobile Network Registration Protocol" }, - { 0x4005, "Expand accelerator protocol" }, - { 0x4007, "ODSICP NCP" }, - { 0x4009, "DOCSIS DLL" }, - { 0x400B, "Cetacean Network Detection Protocol" }, - { 0x4021, "Stacker LZS" }, - { 0x4023, "RefTek Protocol" }, - { 0x4025, "Fibre Channel" }, - { 0x4027, "EMIT Protocols" }, - { 0x405b, "Vendor-Specific Protocol (VSP)" }, - { 0x8021, "Internet Protocol Control Protocol" }, - { 0x8023, "OSI Network Layer Control Protocol" }, - { 0x8025, "Xerox NS IDP Control Protocol" }, - { 0x8027, "DECnet Phase IV Control Protocol" }, - { 0x8029, "Appletalk Control Protocol" }, - { 0x802b, "Novell IPX Control Protocol" }, - { 0x8031, "Bridging NCP" }, - { 0x8033, "Stream Protocol Control Protocol" }, - { 0x8035, "Banyan Vines Control Protocol" }, - { 0x803d, "Multi-Link Control Protocol" }, - { 0x803f, "NETBIOS Framing Control Protocol" }, - { 0x8041, "Cisco Systems Control Protocol" }, - { 0x8043, "Ascom Timeplex" }, - { 0x8045, "Fujitsu LBLB Control Protocol" }, - { 0x8047, "DCA Remote Lan Network Control Protocol (RLNCP)" }, - { 0x8049, "Serial Data Control Protocol (PPP-SDCP)" }, - { 0x804b, "SNA over 802.2 Control Protocol" }, - { 0x804d, "SNA Control Protocol" }, - { 0x804f, "IP6 Header Compression Control Protocol" }, - { 0x8051, "KNX Bridging Control Protocol" }, - { 0x8053, "Encryption Control Protocol" }, - { 0x8055, "Individual Link Encryption Control Protocol" }, - { 0x8057, "IPv6 Control Protocol" }, - { 0x8059, "PPP Muxing Control Protocol" }, - { 0x805b, "Vendor-Specific Network Control Protocol (VSNCP)" }, - { 0x806f, "Stampede Bridging Control Protocol" }, - { 0x8073, "MP+ Control Protocol" }, - { 0x80c1, "NTCITS IPI Control Protocol" }, - { 0x80fb, "Single Link Compression Control Protocol" }, - { 0x80fd, "Compression Control Protocol" }, - { 0x8207, "Cisco Discovery Protocol Control" }, - { 0x8209, "Netcs Twin Routing" }, - { 0x820b, "STP - Control Protocol" }, - { 0x820d, "EDPCP - Extreme Discovery Protocol Ctrl Prtcl" }, - { 0x8235, "Apple Client Server Protocol Control" }, - { 0x8281, "MPLSCP" }, - { 0x8285, "IEEE p1284.4 standard - Protocol Control" }, - { 0x8287, "ETSI TETRA TNP1 Control Protocol" }, - { 0x8289, "Multichannel Flow Treatment Protocol" }, - { 0xc021, "Link Control Protocol" }, - { 0xc023, "Password Authentication Protocol" }, - { 0xc025, "Link Quality Report" }, - { 0xc027, "Shiva Password Authentication Protocol" }, - { 0xc029, "CallBack Control Protocol (CBCP)" }, - { 0xc02b, "BACP Bandwidth Allocation Control Protocol" }, - { 0xc02d, "BAP" }, - { 0xc05b, "Vendor-Specific Authentication Protocol (VSAP)" }, - { 0xc081, "Container Control Protocol" }, - { 0xc223, "Challenge Handshake Authentication Protocol" }, - { 0xc225, "RSA Authentication Protocol" }, - { 0xc227, "Extensible Authentication Protocol" }, - { 0xc229, "Mitsubishi Security Info Exch Ptcl (SIEP)" }, - { 0xc26f, "Stampede Bridging Authorization Protocol" }, - { 0xc281, "Proprietary Authentication Protocol" }, - { 0xc283, "Proprietary Authentication Protocol" }, - { 0xc481, "Proprietary Node ID Authentication Protocol" }, - { 0, NULL }, -}; - -/* - * protocol_name - find a name for a PPP protocol. - */ -const char * protocol_name(int proto) { - const struct protocol_list *lp; - - for (lp = protocol_list; lp->proto != 0; ++lp) { - if (proto == lp->proto) { - return lp->name; - } - } - return NULL; -} -#endif /* PPP_PROTOCOLNAME */ - -#if PPP_STATS_SUPPORT - -/* ---- Note on PPP Stats support ---- - * - * The one willing link stats support should add the get_ppp_stats() - * to fetch statistics from lwIP. - */ - -/* - * reset_link_stats - "reset" stats when link goes up. - */ -void reset_link_stats(int u) { - if (!get_ppp_stats(u, &old_link_stats)) { - return; - } - gettimeofday(&start_time, NULL); -} - -/* - * update_link_stats - get stats at link termination. - */ -void update_link_stats(int u) { - struct timeval now; - char numbuf[32]; - - if (!get_ppp_stats(u, &link_stats) || gettimeofday(&now, NULL) < 0) { - return; - } - link_connect_time = now.tv_sec - start_time.tv_sec; - link_stats_valid = 1; - - link_stats.bytes_in -= old_link_stats.bytes_in; - link_stats.bytes_out -= old_link_stats.bytes_out; - link_stats.pkts_in -= old_link_stats.pkts_in; - link_stats.pkts_out -= old_link_stats.pkts_out; -} - -void print_link_stats() { - /* - * Print connect time and statistics. - */ - if (link_stats_valid) { - int t = (link_connect_time + 5) / 6; /* 1/10ths of minutes */ - info("Connect time %d.%d minutes.", t/10, t%10); - info("Sent %u bytes, received %u bytes.", link_stats.bytes_out, link_stats.bytes_in); - link_stats_valid = 0; - } -} -#endif /* PPP_STATS_SUPPORT */ - -#endif /* PPP_SUPPORT */ +/***************************************************************************** +* ppp.c - Network Point to Point Protocol program file. +* +* Copyright (c) 2003 by Marc Boucher, Services Informatiques (MBSI) inc. +* portions Copyright (c) 1997 by Global Election Systems Inc. +* +* The authors hereby grant permission to use, copy, modify, distribute, +* and license this software and its documentation for any purpose, provided +* that existing copyright notices are retained in all copies and that this +* notice and the following disclaimer are included verbatim in any +* distributions. No written agreement, license, or royalty fee is required +* for any of the authorized uses. +* +* THIS SOFTWARE IS PROVIDED BY THE 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 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. +* +****************************************************************************** +* REVISION HISTORY +* +* 03-01-01 Marc Boucher +* Ported to lwIP. +* 97-11-05 Guy Lancaster , Global Election Systems Inc. +* Original. +*****************************************************************************/ + +/* + * ppp_defs.h - PPP definitions. + * + * if_pppvar.h - private structures and declarations for PPP. + * + * Copyright (c) 1994 The Australian National University. + * All rights reserved. + * + * Permission to use, copy, modify, and distribute this software and its + * documentation is hereby granted, provided that the above copyright + * notice appears in all copies. This software is provided without any + * warranty, express or implied. The Australian National University + * makes no representations about the suitability of this software for + * any purpose. + * + * IN NO EVENT SHALL THE AUSTRALIAN NATIONAL UNIVERSITY BE LIABLE TO ANY + * PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES + * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF + * THE AUSTRALIAN NATIONAL UNIVERSITY HAVE BEEN ADVISED OF THE POSSIBILITY + * OF SUCH DAMAGE. + * + * THE AUSTRALIAN NATIONAL UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, + * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS + * ON AN "AS IS" BASIS, AND THE AUSTRALIAN NATIONAL UNIVERSITY HAS NO + * OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, + * OR MODIFICATIONS. + */ + +/* + * if_ppp.h - Point-to-Point Protocol definitions. + * + * Copyright (c) 1989 Carnegie Mellon University. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by Carnegie Mellon University. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. + */ + +/** + * @defgroup ppp PPP + * @ingroup netifs + * @verbinclude "ppp.txt" + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/pbuf.h" +#include "lwip/stats.h" +#include "lwip/sys.h" +#include "lwip/tcpip.h" +#include "lwip/api.h" +#include "lwip/snmp.h" +#include "lwip/ip4.h" /* for ip4_input() */ +#if PPP_IPV6_SUPPORT +#include "lwip/ip6.h" /* for ip6_input() */ +#endif /* PPP_IPV6_SUPPORT */ +#include "lwip/dns.h" + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/pppos.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/lcp.h" +#include "netif/ppp/magic.h" + +#if PAP_SUPPORT +#include "netif/ppp/upap.h" +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT +#include "netif/ppp/chap-new.h" +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT +#include "netif/ppp/eap.h" +#endif /* EAP_SUPPORT */ +#if CCP_SUPPORT +#include "netif/ppp/ccp.h" +#endif /* CCP_SUPPORT */ +#if MPPE_SUPPORT +#include "netif/ppp/mppe.h" +#endif /* MPPE_SUPPORT */ +#if ECP_SUPPORT +#include "netif/ppp/ecp.h" +#endif /* EAP_SUPPORT */ +#if VJ_SUPPORT +#include "netif/ppp/vj.h" +#endif /* VJ_SUPPORT */ +#if PPP_IPV4_SUPPORT +#include "netif/ppp/ipcp.h" +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT +#include "netif/ppp/ipv6cp.h" +#endif /* PPP_IPV6_SUPPORT */ + +/*************************/ +/*** LOCAL DEFINITIONS ***/ +/*************************/ + +/* Memory pools */ +#if PPPOS_SUPPORT +LWIP_MEMPOOL_PROTOTYPE(PPPOS_PCB); +#endif +#if PPPOE_SUPPORT +LWIP_MEMPOOL_PROTOTYPE(PPPOE_IF); +#endif +#if PPPOL2TP_SUPPORT +LWIP_MEMPOOL_PROTOTYPE(PPPOL2TP_PCB); +#endif +#if LWIP_PPP_API && LWIP_MPU_COMPATIBLE +LWIP_MEMPOOL_PROTOTYPE(PPPAPI_MSG); +#endif +LWIP_MEMPOOL_DECLARE(PPP_PCB, MEMP_NUM_PPP_PCB, sizeof(ppp_pcb), "PPP_PCB") + +/* FIXME: add stats per PPP session */ +#if PPP_STATS_SUPPORT +static struct timeval start_time; /* Time when link was started. */ +static struct pppd_stats old_link_stats; +struct pppd_stats link_stats; +unsigned link_connect_time; +int link_stats_valid; +#endif /* PPP_STATS_SUPPORT */ + +/* + * PPP Data Link Layer "protocol" table. + * One entry per supported protocol. + * The last entry must be NULL. + */ +const struct protent* const protocols[] = { + &lcp_protent, +#if PAP_SUPPORT + &pap_protent, +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + &chap_protent, +#endif /* CHAP_SUPPORT */ +#if CBCP_SUPPORT + &cbcp_protent, +#endif /* CBCP_SUPPORT */ +#if PPP_IPV4_SUPPORT + &ipcp_protent, +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT + &ipv6cp_protent, +#endif /* PPP_IPV6_SUPPORT */ +#if CCP_SUPPORT + &ccp_protent, +#endif /* CCP_SUPPORT */ +#if ECP_SUPPORT + &ecp_protent, +#endif /* ECP_SUPPORT */ +#ifdef AT_CHANGE + &atcp_protent, +#endif /* AT_CHANGE */ +#if EAP_SUPPORT + &eap_protent, +#endif /* EAP_SUPPORT */ + NULL +}; + +/* Prototypes for procedures local to this file. */ +static void ppp_do_connect(void *arg); +static err_t ppp_netif_init_cb(struct netif *netif); +#if PPP_IPV4_SUPPORT +static err_t ppp_netif_output_ip4(struct netif *netif, struct pbuf *pb, const ip4_addr_t *ipaddr); +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT +static err_t ppp_netif_output_ip6(struct netif *netif, struct pbuf *pb, const ip6_addr_t *ipaddr); +#endif /* PPP_IPV6_SUPPORT */ +static err_t ppp_netif_output(struct netif *netif, struct pbuf *pb, u16_t protocol); + +/***********************************/ +/*** PUBLIC FUNCTION DEFINITIONS ***/ +/***********************************/ +#if PPP_AUTH_SUPPORT +void ppp_set_auth(ppp_pcb *pcb, u8_t authtype, const char *user, const char *passwd) { + LWIP_ASSERT_CORE_LOCKED(); +#if PAP_SUPPORT + pcb->settings.refuse_pap = !(authtype & PPPAUTHTYPE_PAP); +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + pcb->settings.refuse_chap = !(authtype & PPPAUTHTYPE_CHAP); +#if MSCHAP_SUPPORT + pcb->settings.refuse_mschap = !(authtype & PPPAUTHTYPE_MSCHAP); + pcb->settings.refuse_mschap_v2 = !(authtype & PPPAUTHTYPE_MSCHAP_V2); +#endif /* MSCHAP_SUPPORT */ +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + pcb->settings.refuse_eap = !(authtype & PPPAUTHTYPE_EAP); +#endif /* EAP_SUPPORT */ + pcb->settings.user = user; + pcb->settings.passwd = passwd; +} +#endif /* PPP_AUTH_SUPPORT */ + +#if MPPE_SUPPORT +/* Set MPPE configuration */ +void ppp_set_mppe(ppp_pcb *pcb, u8_t flags) { + if (flags == PPP_MPPE_DISABLE) { + pcb->settings.require_mppe = 0; + return; + } + + pcb->settings.require_mppe = 1; + pcb->settings.refuse_mppe_stateful = !(flags & PPP_MPPE_ALLOW_STATEFUL); + pcb->settings.refuse_mppe_40 = !!(flags & PPP_MPPE_REFUSE_40); + pcb->settings.refuse_mppe_128 = !!(flags & PPP_MPPE_REFUSE_128); +} +#endif /* MPPE_SUPPORT */ + +#if PPP_NOTIFY_PHASE +void ppp_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb) { + pcb->notify_phase_cb = notify_phase_cb; + notify_phase_cb(pcb, pcb->phase, pcb->ctx_cb); +} +#endif /* PPP_NOTIFY_PHASE */ + +/* + * Initiate a PPP connection. + * + * This can only be called if PPP is in the dead phase. + * + * Holdoff is the time to wait (in seconds) before initiating + * the connection. + * + * If this port connects to a modem, the modem connection must be + * established before calling this. + */ +err_t ppp_connect(ppp_pcb *pcb, u16_t holdoff) { + LWIP_ASSERT_CORE_LOCKED(); + if (pcb->phase != PPP_PHASE_DEAD) { + return ERR_ALREADY; + } + + PPPDEBUG(LOG_DEBUG, ("ppp_connect[%d]: holdoff=%d\n", pcb->netif->num, holdoff)); + + magic_randomize(); + + if (holdoff == 0) { + ppp_do_connect(pcb); + return ERR_OK; + } + + new_phase(pcb, PPP_PHASE_HOLDOFF); + sys_timeout((u32_t)(holdoff*1000), ppp_do_connect, pcb); + return ERR_OK; +} + +#if PPP_SERVER +/* + * Listen for an incoming PPP connection. + * + * This can only be called if PPP is in the dead phase. + * + * If this port connects to a modem, the modem connection must be + * established before calling this. + */ +err_t ppp_listen(ppp_pcb *pcb) { + LWIP_ASSERT_CORE_LOCKED(); + if (pcb->phase != PPP_PHASE_DEAD) { + return ERR_ALREADY; + } + + PPPDEBUG(LOG_DEBUG, ("ppp_listen[%d]\n", pcb->netif->num)); + + magic_randomize(); + + if (pcb->link_cb->listen) { + new_phase(pcb, PPP_PHASE_INITIALIZE); + pcb->link_cb->listen(pcb, pcb->link_ctx_cb); + return ERR_OK; + } + return ERR_IF; +} +#endif /* PPP_SERVER */ + +/* + * Initiate the end of a PPP connection. + * Any outstanding packets in the queues are dropped. + * + * Setting nocarrier to 1 close the PPP connection without initiating the + * shutdown procedure. Always using nocarrier = 0 is still recommended, + * this is going to take a little longer time if your link is down, but + * is a safer choice for the PPP state machine. + * + * Return 0 on success, an error code on failure. + */ +err_t +ppp_close(ppp_pcb *pcb, u8_t nocarrier) +{ + LWIP_ASSERT_CORE_LOCKED(); + + pcb->err_code = PPPERR_USER; + + /* holdoff phase, cancel the reconnection */ + if (pcb->phase == PPP_PHASE_HOLDOFF) { + sys_untimeout(ppp_do_connect, pcb); + new_phase(pcb, PPP_PHASE_DEAD); + } + + /* dead phase, nothing to do, call the status callback to be consistent */ + if (pcb->phase == PPP_PHASE_DEAD) { + pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); + return ERR_OK; + } + + /* Already terminating, nothing to do */ + if (pcb->phase >= PPP_PHASE_TERMINATE) { + return ERR_INPROGRESS; + } + + /* LCP not open, close link protocol */ + if (pcb->phase < PPP_PHASE_ESTABLISH) { + new_phase(pcb, PPP_PHASE_DISCONNECT); + ppp_link_terminated(pcb); + return ERR_OK; + } + + /* + * Only accept carrier lost signal on the stable running phase in order + * to prevent changing the PPP phase FSM in transition phases. + * + * Always using nocarrier = 0 is still recommended, this is going to + * take a little longer time, but is a safer choice from FSM point of view. + */ + if (nocarrier && pcb->phase == PPP_PHASE_RUNNING) { + PPPDEBUG(LOG_DEBUG, ("ppp_close[%d]: carrier lost -> lcp_lowerdown\n", pcb->netif->num)); + lcp_lowerdown(pcb); + /* forced link termination, this will force link protocol to disconnect. */ + link_terminated(pcb); + return ERR_OK; + } + + /* Disconnect */ + PPPDEBUG(LOG_DEBUG, ("ppp_close[%d]: kill_link -> lcp_close\n", pcb->netif->num)); + /* LCP soft close request. */ + lcp_close(pcb, "User request"); + return ERR_OK; +} + +/* + * Release the control block. + * + * This can only be called if PPP is in the dead phase. + * + * You must use ppp_close() before if you wish to terminate + * an established PPP session. + * + * Return 0 on success, an error code on failure. + */ +err_t ppp_free(ppp_pcb *pcb) { + err_t err; + LWIP_ASSERT_CORE_LOCKED(); + if (pcb->phase != PPP_PHASE_DEAD) { + return ERR_CONN; + } + + PPPDEBUG(LOG_DEBUG, ("ppp_free[%d]\n", pcb->netif->num)); + + netif_remove(pcb->netif); + + err = pcb->link_cb->free(pcb, pcb->link_ctx_cb); + + LWIP_MEMPOOL_FREE(PPP_PCB, pcb); + return err; +} + +/* Get and set parameters for the given connection. + * Return 0 on success, an error code on failure. */ +err_t +ppp_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg) +{ + LWIP_ASSERT_CORE_LOCKED(); + if (pcb == NULL) { + return ERR_VAL; + } + + switch(cmd) { + case PPPCTLG_UPSTATUS: /* Get the PPP up status. */ + if (!arg) { + goto fail; + } + *(int *)arg = (int)(0 +#if PPP_IPV4_SUPPORT + || pcb->if4_up +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT + || pcb->if6_up +#endif /* PPP_IPV6_SUPPORT */ + ); + return ERR_OK; + + case PPPCTLG_ERRCODE: /* Get the PPP error code. */ + if (!arg) { + goto fail; + } + *(int *)arg = (int)(pcb->err_code); + return ERR_OK; + + default: + goto fail; + } + +fail: + return ERR_VAL; +} + + +/**********************************/ +/*** LOCAL FUNCTION DEFINITIONS ***/ +/**********************************/ + +static void ppp_do_connect(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + + LWIP_ASSERT("pcb->phase == PPP_PHASE_DEAD || pcb->phase == PPP_PHASE_HOLDOFF", pcb->phase == PPP_PHASE_DEAD || pcb->phase == PPP_PHASE_HOLDOFF); + + new_phase(pcb, PPP_PHASE_INITIALIZE); + pcb->link_cb->connect(pcb, pcb->link_ctx_cb); +} + +/* + * ppp_netif_init_cb - netif init callback + */ +static err_t ppp_netif_init_cb(struct netif *netif) { + netif->name[0] = 'p'; + netif->name[1] = 'p'; +#if PPP_IPV4_SUPPORT + netif->output = ppp_netif_output_ip4; +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT + netif->output_ip6 = ppp_netif_output_ip6; +#endif /* PPP_IPV6_SUPPORT */ + netif->flags = NETIF_FLAG_UP; +#if LWIP_NETIF_HOSTNAME + /* @todo: Initialize interface hostname */ + /* netif_set_hostname(netif, "lwip"); */ +#endif /* LWIP_NETIF_HOSTNAME */ + return ERR_OK; +} + +#if PPP_IPV4_SUPPORT +/* + * Send an IPv4 packet on the given connection. + */ +static err_t ppp_netif_output_ip4(struct netif *netif, struct pbuf *pb, const ip4_addr_t *ipaddr) { + LWIP_UNUSED_ARG(ipaddr); + return ppp_netif_output(netif, pb, PPP_IP); +} +#endif /* PPP_IPV4_SUPPORT */ + +#if PPP_IPV6_SUPPORT +/* + * Send an IPv6 packet on the given connection. + */ +static err_t ppp_netif_output_ip6(struct netif *netif, struct pbuf *pb, const ip6_addr_t *ipaddr) { + LWIP_UNUSED_ARG(ipaddr); + return ppp_netif_output(netif, pb, PPP_IPV6); +} +#endif /* PPP_IPV6_SUPPORT */ + +static err_t ppp_netif_output(struct netif *netif, struct pbuf *pb, u16_t protocol) { + ppp_pcb *pcb = (ppp_pcb*)netif->state; + err_t err; + struct pbuf *fpb = NULL; + + /* Check that the link is up. */ + if (0 +#if PPP_IPV4_SUPPORT + || (protocol == PPP_IP && !pcb->if4_up) +#endif /* PPP_IPV4_SUPPORT */ +#if PPP_IPV6_SUPPORT + || (protocol == PPP_IPV6 && !pcb->if6_up) +#endif /* PPP_IPV6_SUPPORT */ + ) { + PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: link not up\n", pcb->netif->num)); + goto err_rte_drop; + } + +#if MPPE_SUPPORT + /* If MPPE is required, refuse any IP packet until we are able to crypt them. */ + if (pcb->settings.require_mppe && pcb->ccp_transmit_method != CI_MPPE) { + PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: MPPE required, not up\n", pcb->netif->num)); + goto err_rte_drop; + } +#endif /* MPPE_SUPPORT */ + +#if VJ_SUPPORT + /* + * Attempt Van Jacobson header compression if VJ is configured and + * this is an IP packet. + */ + if (protocol == PPP_IP && pcb->vj_enabled) { + switch (vj_compress_tcp(&pcb->vj_comp, &pb)) { + case TYPE_IP: + /* No change... + protocol = PPP_IP; */ + break; + case TYPE_COMPRESSED_TCP: + /* vj_compress_tcp() returns a new allocated pbuf, indicate we should free + * our duplicated pbuf later */ + fpb = pb; + protocol = PPP_VJC_COMP; + break; + case TYPE_UNCOMPRESSED_TCP: + /* vj_compress_tcp() returns a new allocated pbuf, indicate we should free + * our duplicated pbuf later */ + fpb = pb; + protocol = PPP_VJC_UNCOMP; + break; + default: + PPPDEBUG(LOG_WARNING, ("ppp_netif_output[%d]: bad IP packet\n", pcb->netif->num)); + LINK_STATS_INC(link.proterr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(pcb->netif, ifoutdiscards); + return ERR_VAL; + } + } +#endif /* VJ_SUPPORT */ + +#if CCP_SUPPORT + switch (pcb->ccp_transmit_method) { + case 0: + break; /* Don't compress */ +#if MPPE_SUPPORT + case CI_MPPE: + if ((err = mppe_compress(pcb, &pcb->mppe_comp, &pb, protocol)) != ERR_OK) { + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); + goto err; + } + /* if VJ compressor returned a new allocated pbuf, free it */ + if (fpb) { + pbuf_free(fpb); + } + /* mppe_compress() returns a new allocated pbuf, indicate we should free + * our duplicated pbuf later */ + fpb = pb; + protocol = PPP_COMP; + break; +#endif /* MPPE_SUPPORT */ + default: + PPPDEBUG(LOG_ERR, ("ppp_netif_output[%d]: bad CCP transmit method\n", pcb->netif->num)); + goto err_rte_drop; /* Cannot really happen, we only negotiate what we are able to do */ + } +#endif /* CCP_SUPPORT */ + + err = pcb->link_cb->netif_output(pcb, pcb->link_ctx_cb, pb, protocol); + goto err; + +err_rte_drop: + err = ERR_RTE; + LINK_STATS_INC(link.rterr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(netif, ifoutdiscards); +err: + if (fpb) { + pbuf_free(fpb); + } + return err; +} + +/************************************/ +/*** PRIVATE FUNCTION DEFINITIONS ***/ +/************************************/ + +/* Initialize the PPP subsystem. */ +int ppp_init(void) +{ +#if PPPOS_SUPPORT + LWIP_MEMPOOL_INIT(PPPOS_PCB); +#endif +#if PPPOE_SUPPORT + LWIP_MEMPOOL_INIT(PPPOE_IF); +#endif +#if PPPOL2TP_SUPPORT + LWIP_MEMPOOL_INIT(PPPOL2TP_PCB); +#endif +#if LWIP_PPP_API && LWIP_MPU_COMPATIBLE + LWIP_MEMPOOL_INIT(PPPAPI_MSG); +#endif + + LWIP_MEMPOOL_INIT(PPP_PCB); + + /* + * Initialize magic number generator now so that protocols may + * use magic numbers in initialization. + */ + magic_init(); + + return 0; +} + +/* + * Create a new PPP control block. + * + * This initializes the PPP control block but does not + * attempt to negotiate the LCP session. + * + * Return a new PPP connection control block pointer + * on success or a null pointer on failure. + */ +ppp_pcb *ppp_new(struct netif *pppif, const struct link_callbacks *callbacks, void *link_ctx_cb, ppp_link_status_cb_fn link_status_cb, void *ctx_cb) { + ppp_pcb *pcb; + const struct protent *protp; + int i; + + /* PPP is single-threaded: without a callback, + * there is no way to know when the link is up. */ + if (link_status_cb == NULL) { + return NULL; + } + + pcb = (ppp_pcb*)LWIP_MEMPOOL_ALLOC(PPP_PCB); + if (pcb == NULL) { + return NULL; + } + + memset(pcb, 0, sizeof(ppp_pcb)); + + /* default configuration */ +#if PAP_SUPPORT + pcb->settings.pap_timeout_time = UPAP_DEFTIMEOUT; + pcb->settings.pap_max_transmits = UPAP_DEFTRANSMITS; +#if PPP_SERVER + pcb->settings.pap_req_timeout = UPAP_DEFREQTIME; +#endif /* PPP_SERVER */ +#endif /* PAP_SUPPORT */ + +#if CHAP_SUPPORT + pcb->settings.chap_timeout_time = CHAP_DEFTIMEOUT; + pcb->settings.chap_max_transmits = CHAP_DEFTRANSMITS; +#if PPP_SERVER + pcb->settings.chap_rechallenge_time = CHAP_DEFRECHALLENGETIME; +#endif /* PPP_SERVER */ +#endif /* CHAP_SUPPPORT */ + +#if EAP_SUPPORT + pcb->settings.eap_req_time = EAP_DEFREQTIME; + pcb->settings.eap_allow_req = EAP_DEFALLOWREQ; +#if PPP_SERVER + pcb->settings.eap_timeout_time = EAP_DEFTIMEOUT; + pcb->settings.eap_max_transmits = EAP_DEFTRANSMITS; +#endif /* PPP_SERVER */ +#endif /* EAP_SUPPORT */ + + pcb->settings.lcp_loopbackfail = LCP_DEFLOOPBACKFAIL; + pcb->settings.lcp_echo_interval = LCP_ECHOINTERVAL; + pcb->settings.lcp_echo_fails = LCP_MAXECHOFAILS; + + pcb->settings.fsm_timeout_time = FSM_DEFTIMEOUT; + pcb->settings.fsm_max_conf_req_transmits = FSM_DEFMAXCONFREQS; + pcb->settings.fsm_max_term_transmits = FSM_DEFMAXTERMREQS; + pcb->settings.fsm_max_nak_loops = FSM_DEFMAXNAKLOOPS; + + pcb->netif = pppif; + MIB2_INIT_NETIF(pppif, snmp_ifType_ppp, 0); + if (!netif_add(pcb->netif, +#if LWIP_IPV4 + IP4_ADDR_ANY4, IP4_ADDR_BROADCAST, IP4_ADDR_ANY4, +#endif /* LWIP_IPV4 */ + (void *)pcb, ppp_netif_init_cb, NULL)) { + LWIP_MEMPOOL_FREE(PPP_PCB, pcb); + PPPDEBUG(LOG_ERR, ("ppp_new: netif_add failed\n")); + return NULL; + } + + pcb->link_cb = callbacks; + pcb->link_ctx_cb = link_ctx_cb; + pcb->link_status_cb = link_status_cb; + pcb->ctx_cb = ctx_cb; + + /* + * Initialize each protocol. + */ + for (i = 0; (protp = protocols[i]) != NULL; ++i) { + (*protp->init)(pcb); + } + + new_phase(pcb, PPP_PHASE_DEAD); + return pcb; +} + +/** Initiate LCP open request */ +void ppp_start(ppp_pcb *pcb) { + PPPDEBUG(LOG_DEBUG, ("ppp_start[%d]\n", pcb->netif->num)); + + /* Clean data not taken care by anything else, mostly shared data. */ +#if PPP_STATS_SUPPORT + link_stats_valid = 0; +#endif /* PPP_STATS_SUPPORT */ +#if MPPE_SUPPORT + pcb->mppe_keys_set = 0; + memset(&pcb->mppe_comp, 0, sizeof(pcb->mppe_comp)); + memset(&pcb->mppe_decomp, 0, sizeof(pcb->mppe_decomp)); +#endif /* MPPE_SUPPORT */ +#if VJ_SUPPORT + vj_compress_init(&pcb->vj_comp); +#endif /* VJ_SUPPORT */ + + /* Start protocol */ + new_phase(pcb, PPP_PHASE_ESTABLISH); + lcp_open(pcb); + lcp_lowerup(pcb); + PPPDEBUG(LOG_DEBUG, ("ppp_start[%d]: finished\n", pcb->netif->num)); +} + +/** Called when link failed to setup */ +void ppp_link_failed(ppp_pcb *pcb) { + PPPDEBUG(LOG_DEBUG, ("ppp_link_failed[%d]\n", pcb->netif->num)); + new_phase(pcb, PPP_PHASE_DEAD); + pcb->err_code = PPPERR_OPEN; + pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); +} + +/** Called when link is normally down (i.e. it was asked to end) */ +void ppp_link_end(ppp_pcb *pcb) { + PPPDEBUG(LOG_DEBUG, ("ppp_link_end[%d]\n", pcb->netif->num)); + new_phase(pcb, PPP_PHASE_DEAD); + if (pcb->err_code == PPPERR_NONE) { + pcb->err_code = PPPERR_CONNECT; + } + pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); +} + +/* + * Pass the processed input packet to the appropriate handler. + * This function and all handlers run in the context of the tcpip_thread + */ +void ppp_input(ppp_pcb *pcb, struct pbuf *pb) { + u16_t protocol; +#if PPP_DEBUG && PPP_PROTOCOLNAME + const char *pname; +#endif /* PPP_DEBUG && PPP_PROTOCOLNAME */ + + magic_randomize(); + + if (pb->len < 2) { + PPPDEBUG(LOG_ERR, ("ppp_input[%d]: packet too short\n", pcb->netif->num)); + goto drop; + } + protocol = (((u8_t *)pb->payload)[0] << 8) | ((u8_t*)pb->payload)[1]; + +#if PRINTPKT_SUPPORT + ppp_dump_packet(pcb, "rcvd", (unsigned char *)pb->payload, pb->len); +#endif /* PRINTPKT_SUPPORT */ + + pbuf_remove_header(pb, sizeof(protocol)); + + LINK_STATS_INC(link.recv); + MIB2_STATS_NETIF_INC(pcb->netif, ifinucastpkts); + MIB2_STATS_NETIF_ADD(pcb->netif, ifinoctets, pb->tot_len); + + /* + * Toss all non-LCP packets unless LCP is OPEN. + */ + if (protocol != PPP_LCP && pcb->lcp_fsm.state != PPP_FSM_OPENED) { + ppp_dbglog("Discarded non-LCP packet when LCP not open"); + goto drop; + } + + /* + * Until we get past the authentication phase, toss all packets + * except LCP, LQR and authentication packets. + */ + if (pcb->phase <= PPP_PHASE_AUTHENTICATE + && !(protocol == PPP_LCP +#if LQR_SUPPORT + || protocol == PPP_LQR +#endif /* LQR_SUPPORT */ +#if PAP_SUPPORT + || protocol == PPP_PAP +#endif /* PAP_SUPPORT */ +#if CHAP_SUPPORT + || protocol == PPP_CHAP +#endif /* CHAP_SUPPORT */ +#if EAP_SUPPORT + || protocol == PPP_EAP +#endif /* EAP_SUPPORT */ + )) { + ppp_dbglog("discarding proto 0x%x in phase %d", protocol, pcb->phase); + goto drop; + } + +#if CCP_SUPPORT +#if MPPE_SUPPORT + /* + * MPPE is required and unencrypted data has arrived (this + * should never happen!). We should probably drop the link if + * the protocol is in the range of what should be encrypted. + * At the least, we drop this packet. + */ + if (pcb->settings.require_mppe && protocol != PPP_COMP && protocol < 0x8000) { + PPPDEBUG(LOG_ERR, ("ppp_input[%d]: MPPE required, received unencrypted data!\n", pcb->netif->num)); + goto drop; + } +#endif /* MPPE_SUPPORT */ + + if (protocol == PPP_COMP) { + u8_t *pl; + + switch (pcb->ccp_receive_method) { +#if MPPE_SUPPORT + case CI_MPPE: + if (mppe_decompress(pcb, &pcb->mppe_decomp, &pb) != ERR_OK) { + goto drop; + } + break; +#endif /* MPPE_SUPPORT */ + default: + PPPDEBUG(LOG_ERR, ("ppp_input[%d]: bad CCP receive method\n", pcb->netif->num)); + goto drop; /* Cannot really happen, we only negotiate what we are able to do */ + } + + /* Assume no PFC */ + if (pb->len < 2) { + goto drop; + } + + /* Extract and hide protocol (do PFC decompression if necessary) */ + pl = (u8_t*)pb->payload; + if (pl[0] & 0x01) { + protocol = pl[0]; + pbuf_remove_header(pb, 1); + } else { + protocol = (pl[0] << 8) | pl[1]; + pbuf_remove_header(pb, 2); + } + } +#endif /* CCP_SUPPORT */ + + switch(protocol) { + +#if PPP_IPV4_SUPPORT + case PPP_IP: /* Internet Protocol */ + PPPDEBUG(LOG_INFO, ("ppp_input[%d]: ip in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); + ip4_input(pb, pcb->netif); + return; +#endif /* PPP_IPV4_SUPPORT */ + +#if PPP_IPV6_SUPPORT + case PPP_IPV6: /* Internet Protocol Version 6 */ + PPPDEBUG(LOG_INFO, ("ppp_input[%d]: ip6 in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); + ip6_input(pb, pcb->netif); + return; +#endif /* PPP_IPV6_SUPPORT */ + +#if VJ_SUPPORT + case PPP_VJC_COMP: /* VJ compressed TCP */ + /* + * Clip off the VJ header and prepend the rebuilt TCP/IP header and + * pass the result to IP. + */ + PPPDEBUG(LOG_INFO, ("ppp_input[%d]: vj_comp in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); + if (pcb->vj_enabled && vj_uncompress_tcp(&pb, &pcb->vj_comp) >= 0) { + ip4_input(pb, pcb->netif); + return; + } + /* Something's wrong so drop it. */ + PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping VJ compressed\n", pcb->netif->num)); + break; + + case PPP_VJC_UNCOMP: /* VJ uncompressed TCP */ + /* + * Process the TCP/IP header for VJ header compression and then pass + * the packet to IP. + */ + PPPDEBUG(LOG_INFO, ("ppp_input[%d]: vj_un in pbuf len=%d\n", pcb->netif->num, pb->tot_len)); + if (pcb->vj_enabled && vj_uncompress_uncomp(pb, &pcb->vj_comp) >= 0) { + ip4_input(pb, pcb->netif); + return; + } + /* Something's wrong so drop it. */ + PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping VJ uncompressed\n", pcb->netif->num)); + break; +#endif /* VJ_SUPPORT */ + + default: { + int i; + const struct protent *protp; + + /* + * Upcall the proper protocol input routine. + */ + for (i = 0; (protp = protocols[i]) != NULL; ++i) { + if (protp->protocol == protocol) { + pb = pbuf_coalesce(pb, PBUF_RAW); + (*protp->input)(pcb, (u8_t*)pb->payload, pb->len); + goto out; + } +#if 0 /* UNUSED + * + * This is actually a (hacked?) way for the Linux kernel to pass a data + * packet to pppd. pppd in normal condition only do signaling + * (LCP, PAP, CHAP, IPCP, ...) and does not handle any data packet at all. + * + * We don't even need this interface, which is only there because of PPP + * interface limitation between Linux kernel and pppd. For MPPE, which uses + * CCP to negotiate although it is not really a (de)compressor, we added + * ccp_resetrequest() in CCP and MPPE input data flow is calling either + * ccp_resetrequest() or lcp_close() if the issue is, respectively, non-fatal + * or fatal, this is what ccp_datainput() really do. + */ + if (protocol == (protp->protocol & ~0x8000) + && protp->datainput != NULL) { + (*protp->datainput)(pcb, pb->payload, pb->len); + goto out; + } +#endif /* UNUSED */ + } + +#if PPP_DEBUG +#if PPP_PROTOCOLNAME + pname = protocol_name(protocol); + if (pname != NULL) { + ppp_warn("Unsupported protocol '%s' (0x%x) received", pname, protocol); + } else +#endif /* PPP_PROTOCOLNAME */ + ppp_warn("Unsupported protocol 0x%x received", protocol); +#endif /* PPP_DEBUG */ + if (pbuf_add_header(pb, sizeof(protocol))) { + PPPDEBUG(LOG_WARNING, ("ppp_input[%d]: Dropping (pbuf_add_header failed)\n", pcb->netif->num)); + goto drop; + } + lcp_sprotrej(pcb, (u8_t*)pb->payload, pb->len); + } + break; + } + +drop: + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(pcb->netif, ifindiscards); + +out: + pbuf_free(pb); +} + +/* + * Write a pbuf to a ppp link, only used from PPP functions + * to send PPP packets. + * + * IPv4 and IPv6 packets from lwIP are sent, respectively, + * with ppp_netif_output_ip4() and ppp_netif_output_ip6() + * functions (which are callbacks of the netif PPP interface). + */ +err_t ppp_write(ppp_pcb *pcb, struct pbuf *p) { +#if PRINTPKT_SUPPORT + ppp_dump_packet(pcb, "sent", (unsigned char *)p->payload+2, p->len-2); +#endif /* PRINTPKT_SUPPORT */ + return pcb->link_cb->write(pcb, pcb->link_ctx_cb, p); +} + +void ppp_link_terminated(ppp_pcb *pcb) { + PPPDEBUG(LOG_DEBUG, ("ppp_link_terminated[%d]\n", pcb->netif->num)); + pcb->link_cb->disconnect(pcb, pcb->link_ctx_cb); + PPPDEBUG(LOG_DEBUG, ("ppp_link_terminated[%d]: finished.\n", pcb->netif->num)); +} + + +/************************************************************************ + * Functions called by various PPP subsystems to configure + * the PPP interface or change the PPP phase. + */ + +/* + * new_phase - signal the start of a new phase of pppd's operation. + */ +void new_phase(ppp_pcb *pcb, int p) { + pcb->phase = p; + PPPDEBUG(LOG_DEBUG, ("ppp phase changed[%d]: phase=%d\n", pcb->netif->num, pcb->phase)); +#if PPP_NOTIFY_PHASE + if (pcb->notify_phase_cb != NULL) { + pcb->notify_phase_cb(pcb, p, pcb->ctx_cb); + } +#endif /* PPP_NOTIFY_PHASE */ +} + +/* + * ppp_send_config - configure the transmit-side characteristics of + * the ppp interface. + */ +int ppp_send_config(ppp_pcb *pcb, int mtu, u32_t accm, int pcomp, int accomp) { + LWIP_UNUSED_ARG(mtu); + /* pcb->mtu = mtu; -- set correctly with netif_set_mtu */ + + if (pcb->link_cb->send_config) { + pcb->link_cb->send_config(pcb, pcb->link_ctx_cb, accm, pcomp, accomp); + } + + PPPDEBUG(LOG_INFO, ("ppp_send_config[%d]\n", pcb->netif->num) ); + return 0; +} + +/* + * ppp_recv_config - configure the receive-side characteristics of + * the ppp interface. + */ +int ppp_recv_config(ppp_pcb *pcb, int mru, u32_t accm, int pcomp, int accomp) { + LWIP_UNUSED_ARG(mru); + + if (pcb->link_cb->recv_config) { + pcb->link_cb->recv_config(pcb, pcb->link_ctx_cb, accm, pcomp, accomp); + } + + PPPDEBUG(LOG_INFO, ("ppp_recv_config[%d]\n", pcb->netif->num)); + return 0; +} + +#if PPP_IPV4_SUPPORT +/* + * sifaddr - Config the interface IP addresses and netmask. + */ +int sifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr, u32_t netmask) { + ip4_addr_t ip, nm, gw; + + ip4_addr_set_u32(&ip, our_adr); + ip4_addr_set_u32(&nm, netmask); + ip4_addr_set_u32(&gw, his_adr); + netif_set_addr(pcb->netif, &ip, &nm, &gw); + return 1; +} + +/******************************************************************** + * + * cifaddr - Clear the interface IP addresses, and delete routes + * through the interface if possible. + */ +int cifaddr(ppp_pcb *pcb, u32_t our_adr, u32_t his_adr) { + LWIP_UNUSED_ARG(our_adr); + LWIP_UNUSED_ARG(his_adr); + + netif_set_addr(pcb->netif, IP4_ADDR_ANY4, IP4_ADDR_BROADCAST, IP4_ADDR_ANY4); + return 1; +} + +#if 0 /* UNUSED - PROXY ARP */ +/******************************************************************** + * + * sifproxyarp - Make a proxy ARP entry for the peer. + */ + +int sifproxyarp(ppp_pcb *pcb, u32_t his_adr) { + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(his_adr); + return 0; +} + +/******************************************************************** + * + * cifproxyarp - Delete the proxy ARP entry for the peer. + */ + +int cifproxyarp(ppp_pcb *pcb, u32_t his_adr) { + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(his_adr); + return 0; +} +#endif /* UNUSED - PROXY ARP */ + +#if LWIP_DNS +/* + * sdns - Config the DNS servers + */ +int sdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2) { + ip_addr_t ns; + LWIP_UNUSED_ARG(pcb); + + ip_addr_set_ip4_u32_val(ns, ns1); + dns_setserver(0, &ns); + ip_addr_set_ip4_u32_val(ns, ns2); + dns_setserver(1, &ns); + return 1; +} + +/******************************************************************** + * + * cdns - Clear the DNS servers + */ +int cdns(ppp_pcb *pcb, u32_t ns1, u32_t ns2) { + const ip_addr_t *nsa; + ip_addr_t nsb; + LWIP_UNUSED_ARG(pcb); + + nsa = dns_getserver(0); + ip_addr_set_ip4_u32_val(nsb, ns1); + if (ip_addr_cmp(nsa, &nsb)) { + dns_setserver(0, IP_ADDR_ANY); + } + nsa = dns_getserver(1); + ip_addr_set_ip4_u32_val(nsb, ns2); + if (ip_addr_cmp(nsa, &nsb)) { + dns_setserver(1, IP_ADDR_ANY); + } + return 1; +} +#endif /* LWIP_DNS */ + +#if VJ_SUPPORT +/******************************************************************** + * + * sifvjcomp - config tcp header compression + */ +int sifvjcomp(ppp_pcb *pcb, int vjcomp, int cidcomp, int maxcid) { + pcb->vj_enabled = vjcomp; + pcb->vj_comp.compressSlot = cidcomp; + pcb->vj_comp.maxSlotIndex = maxcid; + PPPDEBUG(LOG_INFO, ("sifvjcomp[%d]: VJ compress enable=%d slot=%d max slot=%d\n", + pcb->netif->num, vjcomp, cidcomp, maxcid)); + return 0; +} +#endif /* VJ_SUPPORT */ + +/* + * sifup - Config the interface up and enable IP packets to pass. + */ +int sifup(ppp_pcb *pcb) { + pcb->if4_up = 1; + pcb->err_code = PPPERR_NONE; + netif_set_link_up(pcb->netif); + + PPPDEBUG(LOG_DEBUG, ("sifup[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); + pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); + return 1; +} + +/******************************************************************** + * + * sifdown - Disable the indicated protocol and config the interface + * down if there are no remaining protocols. + */ +int sifdown(ppp_pcb *pcb) { + + pcb->if4_up = 0; + + if (1 +#if PPP_IPV6_SUPPORT + /* set the interface down if IPv6 is down as well */ + && !pcb->if6_up +#endif /* PPP_IPV6_SUPPORT */ + ) { + /* make sure the netif link callback is called */ + netif_set_link_down(pcb->netif); + } + PPPDEBUG(LOG_DEBUG, ("sifdown[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); + return 1; +} + +/******************************************************************** + * + * Return user specified netmask, modified by any mask we might determine + * for address `addr' (in network byte order). + * Here we scan through the system's list of interfaces, looking for + * any non-point-to-point interfaces which might appear to be on the same + * network as `addr'. If we find any, we OR in their netmask to the + * user-specified netmask. + */ +u32_t get_mask(u32_t addr) { +#if 0 + u32_t mask, nmask; + + addr = lwip_htonl(addr); + if (IP_CLASSA(addr)) { /* determine network mask for address class */ + nmask = IP_CLASSA_NET; + } else if (IP_CLASSB(addr)) { + nmask = IP_CLASSB_NET; + } else { + nmask = IP_CLASSC_NET; + } + + /* class D nets are disallowed by bad_ip_adrs */ + mask = PP_HTONL(0xffffff00UL) | lwip_htonl(nmask); + + /* XXX + * Scan through the system's network interfaces. + * Get each netmask and OR them into our mask. + */ + /* return mask; */ + return mask; +#endif /* 0 */ + LWIP_UNUSED_ARG(addr); + return IPADDR_BROADCAST; +} +#endif /* PPP_IPV4_SUPPORT */ + +#if PPP_IPV6_SUPPORT +#define IN6_LLADDR_FROM_EUI64(ip6, eui64) do { \ + ip6.addr[0] = PP_HTONL(0xfe800000); \ + ip6.addr[1] = 0; \ + eui64_copy(eui64, ip6.addr[2]); \ + } while (0) + +/******************************************************************** + * + * sif6addr - Config the interface with an IPv6 link-local address + */ +int sif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64) { + ip6_addr_t ip6; + LWIP_UNUSED_ARG(his_eui64); + + IN6_LLADDR_FROM_EUI64(ip6, our_eui64); + netif_ip6_addr_set(pcb->netif, 0, &ip6); + netif_ip6_addr_set_state(pcb->netif, 0, IP6_ADDR_PREFERRED); + /* FIXME: should we add an IPv6 static neighbor using his_eui64 ? */ + return 1; +} + +/******************************************************************** + * + * cif6addr - Remove IPv6 address from interface + */ +int cif6addr(ppp_pcb *pcb, eui64_t our_eui64, eui64_t his_eui64) { + LWIP_UNUSED_ARG(our_eui64); + LWIP_UNUSED_ARG(his_eui64); + + netif_ip6_addr_set_state(pcb->netif, 0, IP6_ADDR_INVALID); + netif_ip6_addr_set(pcb->netif, 0, IP6_ADDR_ANY6); + return 1; +} + +/* + * sif6up - Config the interface up and enable IPv6 packets to pass. + */ +int sif6up(ppp_pcb *pcb) { + + pcb->if6_up = 1; + pcb->err_code = PPPERR_NONE; + netif_set_link_up(pcb->netif); + + PPPDEBUG(LOG_DEBUG, ("sif6up[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); + pcb->link_status_cb(pcb, pcb->err_code, pcb->ctx_cb); + return 1; +} + +/******************************************************************** + * + * sif6down - Disable the indicated protocol and config the interface + * down if there are no remaining protocols. + */ +int sif6down(ppp_pcb *pcb) { + + pcb->if6_up = 0; + + if (1 +#if PPP_IPV4_SUPPORT + /* set the interface down if IPv4 is down as well */ + && !pcb->if4_up +#endif /* PPP_IPV4_SUPPORT */ + ) { + /* make sure the netif link callback is called */ + netif_set_link_down(pcb->netif); + } + PPPDEBUG(LOG_DEBUG, ("sif6down[%d]: err_code=%d\n", pcb->netif->num, pcb->err_code)); + return 1; +} +#endif /* PPP_IPV6_SUPPORT */ + +#if DEMAND_SUPPORT +/* + * sifnpmode - Set the mode for handling packets for a given NP. + */ +int sifnpmode(ppp_pcb *pcb, int proto, enum NPmode mode) { + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(proto); + LWIP_UNUSED_ARG(mode); + return 0; +} +#endif /* DEMAND_SUPPORT */ + +/* + * netif_set_mtu - set the MTU on the PPP network interface. + */ +void netif_set_mtu(ppp_pcb *pcb, int mtu) { + + pcb->netif->mtu = mtu; + PPPDEBUG(LOG_INFO, ("netif_set_mtu[%d]: mtu=%d\n", pcb->netif->num, mtu)); +} + +/* + * netif_get_mtu - get PPP interface MTU + */ +int netif_get_mtu(ppp_pcb *pcb) { + + return pcb->netif->mtu; +} + +#if CCP_SUPPORT +#if 0 /* unused */ +/* + * ccp_test - whether a given compression method is acceptable for use. + */ +int +ccp_test(ppp_pcb *pcb, u_char *opt_ptr, int opt_len, int for_transmit) +{ + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(opt_ptr); + LWIP_UNUSED_ARG(opt_len); + LWIP_UNUSED_ARG(for_transmit); + return -1; +} +#endif /* unused */ + +/* + * ccp_set - inform about the current state of CCP. + */ +void +ccp_set(ppp_pcb *pcb, u8_t isopen, u8_t isup, u8_t receive_method, u8_t transmit_method) +{ + LWIP_UNUSED_ARG(isopen); + LWIP_UNUSED_ARG(isup); + pcb->ccp_receive_method = receive_method; + pcb->ccp_transmit_method = transmit_method; + PPPDEBUG(LOG_DEBUG, ("ccp_set[%d]: is_open=%d, is_up=%d, receive_method=%u, transmit_method=%u\n", + pcb->netif->num, isopen, isup, receive_method, transmit_method)); +} + +void +ccp_reset_comp(ppp_pcb *pcb) +{ + switch (pcb->ccp_transmit_method) { +#if MPPE_SUPPORT + case CI_MPPE: + mppe_comp_reset(pcb, &pcb->mppe_comp); + break; +#endif /* MPPE_SUPPORT */ + default: + break; + } +} + +void +ccp_reset_decomp(ppp_pcb *pcb) +{ + switch (pcb->ccp_receive_method) { +#if MPPE_SUPPORT + case CI_MPPE: + mppe_decomp_reset(pcb, &pcb->mppe_decomp); + break; +#endif /* MPPE_SUPPORT */ + default: + break; + } +} + +#if 0 /* unused */ +/* + * ccp_fatal_error - returns 1 if decompression was disabled as a + * result of an error detected after decompression of a packet, + * 0 otherwise. This is necessary because of patent nonsense. + */ +int +ccp_fatal_error(ppp_pcb *pcb) +{ + LWIP_UNUSED_ARG(pcb); + return 1; +} +#endif /* unused */ +#endif /* CCP_SUPPORT */ + +#if PPP_IDLETIMELIMIT +/******************************************************************** + * + * get_idle_time - return how long the link has been idle. + */ +int get_idle_time(ppp_pcb *pcb, struct ppp_idle *ip) { + /* FIXME: add idle time support and make it optional */ + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(ip); + return 1; +} +#endif /* PPP_IDLETIMELIMIT */ + +#if DEMAND_SUPPORT +/******************************************************************** + * + * get_loop_output - get outgoing packets from the ppp device, + * and detect when we want to bring the real link up. + * Return value is 1 if we need to bring up the link, 0 otherwise. + */ +int get_loop_output(void) { + return 0; +} +#endif /* DEMAND_SUPPORT */ + +#if PPP_PROTOCOLNAME +/* List of protocol names, to make our messages a little more informative. */ +struct protocol_list { + u_short proto; + const char *name; +} const protocol_list[] = { + { 0x21, "IP" }, + { 0x23, "OSI Network Layer" }, + { 0x25, "Xerox NS IDP" }, + { 0x27, "DECnet Phase IV" }, + { 0x29, "Appletalk" }, + { 0x2b, "Novell IPX" }, + { 0x2d, "VJ compressed TCP/IP" }, + { 0x2f, "VJ uncompressed TCP/IP" }, + { 0x31, "Bridging PDU" }, + { 0x33, "Stream Protocol ST-II" }, + { 0x35, "Banyan Vines" }, + { 0x39, "AppleTalk EDDP" }, + { 0x3b, "AppleTalk SmartBuffered" }, + { 0x3d, "Multi-Link" }, + { 0x3f, "NETBIOS Framing" }, + { 0x41, "Cisco Systems" }, + { 0x43, "Ascom Timeplex" }, + { 0x45, "Fujitsu Link Backup and Load Balancing (LBLB)" }, + { 0x47, "DCA Remote Lan" }, + { 0x49, "Serial Data Transport Protocol (PPP-SDTP)" }, + { 0x4b, "SNA over 802.2" }, + { 0x4d, "SNA" }, + { 0x4f, "IP6 Header Compression" }, + { 0x51, "KNX Bridging Data" }, + { 0x53, "Encryption" }, + { 0x55, "Individual Link Encryption" }, + { 0x57, "IPv6" }, + { 0x59, "PPP Muxing" }, + { 0x5b, "Vendor-Specific Network Protocol" }, + { 0x61, "RTP IPHC Full Header" }, + { 0x63, "RTP IPHC Compressed TCP" }, + { 0x65, "RTP IPHC Compressed non-TCP" }, + { 0x67, "RTP IPHC Compressed UDP 8" }, + { 0x69, "RTP IPHC Compressed RTP 8" }, + { 0x6f, "Stampede Bridging" }, + { 0x73, "MP+" }, + { 0xc1, "NTCITS IPI" }, + { 0xfb, "single-link compression" }, + { 0xfd, "Compressed Datagram" }, + { 0x0201, "802.1d Hello Packets" }, + { 0x0203, "IBM Source Routing BPDU" }, + { 0x0205, "DEC LANBridge100 Spanning Tree" }, + { 0x0207, "Cisco Discovery Protocol" }, + { 0x0209, "Netcs Twin Routing" }, + { 0x020b, "STP - Scheduled Transfer Protocol" }, + { 0x020d, "EDP - Extreme Discovery Protocol" }, + { 0x0211, "Optical Supervisory Channel Protocol" }, + { 0x0213, "Optical Supervisory Channel Protocol" }, + { 0x0231, "Luxcom" }, + { 0x0233, "Sigma Network Systems" }, + { 0x0235, "Apple Client Server Protocol" }, + { 0x0281, "MPLS Unicast" }, + { 0x0283, "MPLS Multicast" }, + { 0x0285, "IEEE p1284.4 standard - data packets" }, + { 0x0287, "ETSI TETRA Network Protocol Type 1" }, + { 0x0289, "Multichannel Flow Treatment Protocol" }, + { 0x2063, "RTP IPHC Compressed TCP No Delta" }, + { 0x2065, "RTP IPHC Context State" }, + { 0x2067, "RTP IPHC Compressed UDP 16" }, + { 0x2069, "RTP IPHC Compressed RTP 16" }, + { 0x4001, "Cray Communications Control Protocol" }, + { 0x4003, "CDPD Mobile Network Registration Protocol" }, + { 0x4005, "Expand accelerator protocol" }, + { 0x4007, "ODSICP NCP" }, + { 0x4009, "DOCSIS DLL" }, + { 0x400B, "Cetacean Network Detection Protocol" }, + { 0x4021, "Stacker LZS" }, + { 0x4023, "RefTek Protocol" }, + { 0x4025, "Fibre Channel" }, + { 0x4027, "EMIT Protocols" }, + { 0x405b, "Vendor-Specific Protocol (VSP)" }, + { 0x8021, "Internet Protocol Control Protocol" }, + { 0x8023, "OSI Network Layer Control Protocol" }, + { 0x8025, "Xerox NS IDP Control Protocol" }, + { 0x8027, "DECnet Phase IV Control Protocol" }, + { 0x8029, "Appletalk Control Protocol" }, + { 0x802b, "Novell IPX Control Protocol" }, + { 0x8031, "Bridging NCP" }, + { 0x8033, "Stream Protocol Control Protocol" }, + { 0x8035, "Banyan Vines Control Protocol" }, + { 0x803d, "Multi-Link Control Protocol" }, + { 0x803f, "NETBIOS Framing Control Protocol" }, + { 0x8041, "Cisco Systems Control Protocol" }, + { 0x8043, "Ascom Timeplex" }, + { 0x8045, "Fujitsu LBLB Control Protocol" }, + { 0x8047, "DCA Remote Lan Network Control Protocol (RLNCP)" }, + { 0x8049, "Serial Data Control Protocol (PPP-SDCP)" }, + { 0x804b, "SNA over 802.2 Control Protocol" }, + { 0x804d, "SNA Control Protocol" }, + { 0x804f, "IP6 Header Compression Control Protocol" }, + { 0x8051, "KNX Bridging Control Protocol" }, + { 0x8053, "Encryption Control Protocol" }, + { 0x8055, "Individual Link Encryption Control Protocol" }, + { 0x8057, "IPv6 Control Protocol" }, + { 0x8059, "PPP Muxing Control Protocol" }, + { 0x805b, "Vendor-Specific Network Control Protocol (VSNCP)" }, + { 0x806f, "Stampede Bridging Control Protocol" }, + { 0x8073, "MP+ Control Protocol" }, + { 0x80c1, "NTCITS IPI Control Protocol" }, + { 0x80fb, "Single Link Compression Control Protocol" }, + { 0x80fd, "Compression Control Protocol" }, + { 0x8207, "Cisco Discovery Protocol Control" }, + { 0x8209, "Netcs Twin Routing" }, + { 0x820b, "STP - Control Protocol" }, + { 0x820d, "EDPCP - Extreme Discovery Protocol Ctrl Prtcl" }, + { 0x8235, "Apple Client Server Protocol Control" }, + { 0x8281, "MPLSCP" }, + { 0x8285, "IEEE p1284.4 standard - Protocol Control" }, + { 0x8287, "ETSI TETRA TNP1 Control Protocol" }, + { 0x8289, "Multichannel Flow Treatment Protocol" }, + { 0xc021, "Link Control Protocol" }, + { 0xc023, "Password Authentication Protocol" }, + { 0xc025, "Link Quality Report" }, + { 0xc027, "Shiva Password Authentication Protocol" }, + { 0xc029, "CallBack Control Protocol (CBCP)" }, + { 0xc02b, "BACP Bandwidth Allocation Control Protocol" }, + { 0xc02d, "BAP" }, + { 0xc05b, "Vendor-Specific Authentication Protocol (VSAP)" }, + { 0xc081, "Container Control Protocol" }, + { 0xc223, "Challenge Handshake Authentication Protocol" }, + { 0xc225, "RSA Authentication Protocol" }, + { 0xc227, "Extensible Authentication Protocol" }, + { 0xc229, "Mitsubishi Security Info Exch Ptcl (SIEP)" }, + { 0xc26f, "Stampede Bridging Authorization Protocol" }, + { 0xc281, "Proprietary Authentication Protocol" }, + { 0xc283, "Proprietary Authentication Protocol" }, + { 0xc481, "Proprietary Node ID Authentication Protocol" }, + { 0, NULL }, +}; + +/* + * protocol_name - find a name for a PPP protocol. + */ +const char * protocol_name(int proto) { + const struct protocol_list *lp; + + for (lp = protocol_list; lp->proto != 0; ++lp) { + if (proto == lp->proto) { + return lp->name; + } + } + return NULL; +} +#endif /* PPP_PROTOCOLNAME */ + +#if PPP_STATS_SUPPORT + +/* ---- Note on PPP Stats support ---- + * + * The one willing link stats support should add the get_ppp_stats() + * to fetch statistics from lwIP. + */ + +/* + * reset_link_stats - "reset" stats when link goes up. + */ +void reset_link_stats(int u) { + if (!get_ppp_stats(u, &old_link_stats)) { + return; + } + gettimeofday(&start_time, NULL); +} + +/* + * update_link_stats - get stats at link termination. + */ +void update_link_stats(int u) { + struct timeval now; + char numbuf[32]; + + if (!get_ppp_stats(u, &link_stats) || gettimeofday(&now, NULL) < 0) { + return; + } + link_connect_time = now.tv_sec - start_time.tv_sec; + link_stats_valid = 1; + + link_stats.bytes_in -= old_link_stats.bytes_in; + link_stats.bytes_out -= old_link_stats.bytes_out; + link_stats.pkts_in -= old_link_stats.pkts_in; + link_stats.pkts_out -= old_link_stats.pkts_out; +} + +void print_link_stats() { + /* + * Print connect time and statistics. + */ + if (link_stats_valid) { + int t = (link_connect_time + 5) / 6; /* 1/10ths of minutes */ + info("Connect time %d.%d minutes.", t/10, t%10); + info("Sent %u bytes, received %u bytes.", link_stats.bytes_out, link_stats.bytes_in); + link_stats_valid = 0; + } +} +#endif /* PPP_STATS_SUPPORT */ + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppapi.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppapi.c index 5d19f002..947f7ba8 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppapi.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppapi.c @@ -1,427 +1,427 @@ -/** - * @file - * Point To Point Protocol Sequential API module - * - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "netif/ppp/ppp_opts.h" - -#if LWIP_PPP_API /* don't build if not configured for use in lwipopts.h */ - -#include "netif/ppp/pppapi.h" -#include "lwip/priv/tcpip_priv.h" -#include "netif/ppp/pppoe.h" -#include "netif/ppp/pppol2tp.h" -#include "netif/ppp/pppos.h" - -#if LWIP_MPU_COMPATIBLE -LWIP_MEMPOOL_DECLARE(PPPAPI_MSG, MEMP_NUM_PPP_API_MSG, sizeof(struct pppapi_msg), "PPPAPI_MSG") -#endif - -#define PPPAPI_VAR_REF(name) API_VAR_REF(name) -#define PPPAPI_VAR_DECLARE(name) API_VAR_DECLARE(struct pppapi_msg, name) -#define PPPAPI_VAR_ALLOC(name) API_VAR_ALLOC_POOL(struct pppapi_msg, PPPAPI_MSG, name, ERR_MEM) -#define PPPAPI_VAR_ALLOC_RETURN_NULL(name) API_VAR_ALLOC_POOL(struct pppapi_msg, PPPAPI_MSG, name, NULL) -#define PPPAPI_VAR_FREE(name) API_VAR_FREE_POOL(PPPAPI_MSG, name) - -/** - * Call ppp_set_default() inside the tcpip_thread context. - */ -static err_t -pppapi_do_ppp_set_default(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - ppp_set_default(msg->msg.ppp); - return ERR_OK; -} - -/** - * Call ppp_set_default() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -err_t -pppapi_set_default(ppp_pcb *pcb) -{ - err_t err; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = pcb; - err = tcpip_api_call(pppapi_do_ppp_set_default, &PPPAPI_VAR_REF(msg).call); - PPPAPI_VAR_FREE(msg); - return err; -} - - -#if PPP_NOTIFY_PHASE -/** - * Call ppp_set_notify_phase_callback() inside the tcpip_thread context. - */ -static err_t -pppapi_do_ppp_set_notify_phase_callback(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - ppp_set_notify_phase_callback(msg->msg.ppp, msg->msg.msg.setnotifyphasecb.notify_phase_cb); - return ERR_OK; -} - -/** - * Call ppp_set_notify_phase_callback() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -err_t -pppapi_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb) -{ - err_t err; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = pcb; - PPPAPI_VAR_REF(msg).msg.msg.setnotifyphasecb.notify_phase_cb = notify_phase_cb; - err = tcpip_api_call(pppapi_do_ppp_set_notify_phase_callback, &PPPAPI_VAR_REF(msg).call); - PPPAPI_VAR_FREE(msg); - return err; -} -#endif /* PPP_NOTIFY_PHASE */ - - -#if PPPOS_SUPPORT -/** - * Call pppos_create() inside the tcpip_thread context. - */ -static err_t -pppapi_do_pppos_create(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - msg->msg.ppp = pppos_create(msg->msg.msg.serialcreate.pppif, msg->msg.msg.serialcreate.output_cb, - msg->msg.msg.serialcreate.link_status_cb, msg->msg.msg.serialcreate.ctx_cb); - return ERR_OK; -} - -/** - * Call pppos_create() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -ppp_pcb* -pppapi_pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb) -{ - ppp_pcb* result; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC_RETURN_NULL(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = NULL; - PPPAPI_VAR_REF(msg).msg.msg.serialcreate.pppif = pppif; - PPPAPI_VAR_REF(msg).msg.msg.serialcreate.output_cb = output_cb; - PPPAPI_VAR_REF(msg).msg.msg.serialcreate.link_status_cb = link_status_cb; - PPPAPI_VAR_REF(msg).msg.msg.serialcreate.ctx_cb = ctx_cb; - tcpip_api_call(pppapi_do_pppos_create, &PPPAPI_VAR_REF(msg).call); - result = PPPAPI_VAR_REF(msg).msg.ppp; - PPPAPI_VAR_FREE(msg); - return result; -} -#endif /* PPPOS_SUPPORT */ - - -#if PPPOE_SUPPORT -/** - * Call pppoe_create() inside the tcpip_thread context. - */ -static err_t -pppapi_do_pppoe_create(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - msg->msg.ppp = pppoe_create(msg->msg.msg.ethernetcreate.pppif, msg->msg.msg.ethernetcreate.ethif, - msg->msg.msg.ethernetcreate.service_name, msg->msg.msg.ethernetcreate.concentrator_name, - msg->msg.msg.ethernetcreate.link_status_cb, msg->msg.msg.ethernetcreate.ctx_cb); - return ERR_OK; -} - -/** - * Call pppoe_create() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -ppp_pcb* -pppapi_pppoe_create(struct netif *pppif, struct netif *ethif, const char *service_name, - const char *concentrator_name, ppp_link_status_cb_fn link_status_cb, - void *ctx_cb) -{ - ppp_pcb* result; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC_RETURN_NULL(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = NULL; - PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.pppif = pppif; - PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.ethif = ethif; - PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.service_name = service_name; - PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.concentrator_name = concentrator_name; - PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.link_status_cb = link_status_cb; - PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.ctx_cb = ctx_cb; - tcpip_api_call(pppapi_do_pppoe_create, &PPPAPI_VAR_REF(msg).call); - result = PPPAPI_VAR_REF(msg).msg.ppp; - PPPAPI_VAR_FREE(msg); - return result; -} -#endif /* PPPOE_SUPPORT */ - - -#if PPPOL2TP_SUPPORT -/** - * Call pppol2tp_create() inside the tcpip_thread context. - */ -static err_t -pppapi_do_pppol2tp_create(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - msg->msg.ppp = pppol2tp_create(msg->msg.msg.l2tpcreate.pppif, - msg->msg.msg.l2tpcreate.netif, API_EXPR_REF(msg->msg.msg.l2tpcreate.ipaddr), msg->msg.msg.l2tpcreate.port, -#if PPPOL2TP_AUTH_SUPPORT - msg->msg.msg.l2tpcreate.secret, - msg->msg.msg.l2tpcreate.secret_len, -#else /* PPPOL2TP_AUTH_SUPPORT */ - NULL, - 0, -#endif /* PPPOL2TP_AUTH_SUPPORT */ - msg->msg.msg.l2tpcreate.link_status_cb, msg->msg.msg.l2tpcreate.ctx_cb); - return ERR_OK; -} - -/** - * Call pppol2tp_create() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -ppp_pcb* -pppapi_pppol2tp_create(struct netif *pppif, struct netif *netif, ip_addr_t *ipaddr, u16_t port, - const u8_t *secret, u8_t secret_len, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb) -{ - ppp_pcb* result; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC_RETURN_NULL(msg); -#if !PPPOL2TP_AUTH_SUPPORT - LWIP_UNUSED_ARG(secret); - LWIP_UNUSED_ARG(secret_len); -#endif /* !PPPOL2TP_AUTH_SUPPORT */ - - PPPAPI_VAR_REF(msg).msg.ppp = NULL; - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.pppif = pppif; - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.netif = netif; - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.ipaddr = PPPAPI_VAR_REF(ipaddr); - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.port = port; -#if PPPOL2TP_AUTH_SUPPORT - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.secret = secret; - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.secret_len = secret_len; -#endif /* PPPOL2TP_AUTH_SUPPORT */ - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.link_status_cb = link_status_cb; - PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.ctx_cb = ctx_cb; - tcpip_api_call(pppapi_do_pppol2tp_create, &PPPAPI_VAR_REF(msg).call); - result = PPPAPI_VAR_REF(msg).msg.ppp; - PPPAPI_VAR_FREE(msg); - return result; -} -#endif /* PPPOL2TP_SUPPORT */ - - -/** - * Call ppp_connect() inside the tcpip_thread context. - */ -static err_t -pppapi_do_ppp_connect(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - return ppp_connect(msg->msg.ppp, msg->msg.msg.connect.holdoff); -} - -/** - * Call ppp_connect() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -err_t -pppapi_connect(ppp_pcb *pcb, u16_t holdoff) -{ - err_t err; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = pcb; - PPPAPI_VAR_REF(msg).msg.msg.connect.holdoff = holdoff; - err = tcpip_api_call(pppapi_do_ppp_connect, &PPPAPI_VAR_REF(msg).call); - PPPAPI_VAR_FREE(msg); - return err; -} - - -#if PPP_SERVER -/** - * Call ppp_listen() inside the tcpip_thread context. - */ -static err_t -pppapi_do_ppp_listen(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - return ppp_listen(msg->msg.ppp); -} - -/** - * Call ppp_listen() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -err_t -pppapi_listen(ppp_pcb *pcb) -{ - err_t err; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = pcb; - err = tcpip_api_call(pppapi_do_ppp_listen, &PPPAPI_VAR_REF(msg).call); - PPPAPI_VAR_FREE(msg); - return err; -} -#endif /* PPP_SERVER */ - - -/** - * Call ppp_close() inside the tcpip_thread context. - */ -static err_t -pppapi_do_ppp_close(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - return ppp_close(msg->msg.ppp, msg->msg.msg.close.nocarrier); -} - -/** - * Call ppp_close() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -err_t -pppapi_close(ppp_pcb *pcb, u8_t nocarrier) -{ - err_t err; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = pcb; - PPPAPI_VAR_REF(msg).msg.msg.close.nocarrier = nocarrier; - err = tcpip_api_call(pppapi_do_ppp_close, &PPPAPI_VAR_REF(msg).call); - PPPAPI_VAR_FREE(msg); - return err; -} - - -/** - * Call ppp_free() inside the tcpip_thread context. - */ -static err_t -pppapi_do_ppp_free(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - return ppp_free(msg->msg.ppp); -} - -/** - * Call ppp_free() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -err_t -pppapi_free(ppp_pcb *pcb) -{ - err_t err; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = pcb; - err = tcpip_api_call(pppapi_do_ppp_free, &PPPAPI_VAR_REF(msg).call); - PPPAPI_VAR_FREE(msg); - return err; -} - - -/** - * Call ppp_ioctl() inside the tcpip_thread context. - */ -static err_t -pppapi_do_ppp_ioctl(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 pppapi_msg */ - struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; - - return ppp_ioctl(msg->msg.ppp, msg->msg.msg.ioctl.cmd, msg->msg.msg.ioctl.arg); -} - -/** - * Call ppp_ioctl() in a thread-safe way by running that function inside the - * tcpip_thread context. - */ -err_t -pppapi_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg) -{ - err_t err; - PPPAPI_VAR_DECLARE(msg); - PPPAPI_VAR_ALLOC(msg); - - PPPAPI_VAR_REF(msg).msg.ppp = pcb; - PPPAPI_VAR_REF(msg).msg.msg.ioctl.cmd = cmd; - PPPAPI_VAR_REF(msg).msg.msg.ioctl.arg = arg; - err = tcpip_api_call(pppapi_do_ppp_ioctl, &PPPAPI_VAR_REF(msg).call); - PPPAPI_VAR_FREE(msg); - return err; -} - -#endif /* LWIP_PPP_API */ +/** + * @file + * Point To Point Protocol Sequential API module + * + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "netif/ppp/ppp_opts.h" + +#if LWIP_PPP_API /* don't build if not configured for use in lwipopts.h */ + +#include "netif/ppp/pppapi.h" +#include "lwip/priv/tcpip_priv.h" +#include "netif/ppp/pppoe.h" +#include "netif/ppp/pppol2tp.h" +#include "netif/ppp/pppos.h" + +#if LWIP_MPU_COMPATIBLE +LWIP_MEMPOOL_DECLARE(PPPAPI_MSG, MEMP_NUM_PPP_API_MSG, sizeof(struct pppapi_msg), "PPPAPI_MSG") +#endif + +#define PPPAPI_VAR_REF(name) API_VAR_REF(name) +#define PPPAPI_VAR_DECLARE(name) API_VAR_DECLARE(struct pppapi_msg, name) +#define PPPAPI_VAR_ALLOC(name) API_VAR_ALLOC_POOL(struct pppapi_msg, PPPAPI_MSG, name, ERR_MEM) +#define PPPAPI_VAR_ALLOC_RETURN_NULL(name) API_VAR_ALLOC_POOL(struct pppapi_msg, PPPAPI_MSG, name, NULL) +#define PPPAPI_VAR_FREE(name) API_VAR_FREE_POOL(PPPAPI_MSG, name) + +/** + * Call ppp_set_default() inside the tcpip_thread context. + */ +static err_t +pppapi_do_ppp_set_default(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + ppp_set_default(msg->msg.ppp); + return ERR_OK; +} + +/** + * Call ppp_set_default() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +err_t +pppapi_set_default(ppp_pcb *pcb) +{ + err_t err; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = pcb; + err = tcpip_api_call(pppapi_do_ppp_set_default, &PPPAPI_VAR_REF(msg).call); + PPPAPI_VAR_FREE(msg); + return err; +} + + +#if PPP_NOTIFY_PHASE +/** + * Call ppp_set_notify_phase_callback() inside the tcpip_thread context. + */ +static err_t +pppapi_do_ppp_set_notify_phase_callback(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + ppp_set_notify_phase_callback(msg->msg.ppp, msg->msg.msg.setnotifyphasecb.notify_phase_cb); + return ERR_OK; +} + +/** + * Call ppp_set_notify_phase_callback() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +err_t +pppapi_set_notify_phase_callback(ppp_pcb *pcb, ppp_notify_phase_cb_fn notify_phase_cb) +{ + err_t err; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = pcb; + PPPAPI_VAR_REF(msg).msg.msg.setnotifyphasecb.notify_phase_cb = notify_phase_cb; + err = tcpip_api_call(pppapi_do_ppp_set_notify_phase_callback, &PPPAPI_VAR_REF(msg).call); + PPPAPI_VAR_FREE(msg); + return err; +} +#endif /* PPP_NOTIFY_PHASE */ + + +#if PPPOS_SUPPORT +/** + * Call pppos_create() inside the tcpip_thread context. + */ +static err_t +pppapi_do_pppos_create(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + msg->msg.ppp = pppos_create(msg->msg.msg.serialcreate.pppif, msg->msg.msg.serialcreate.output_cb, + msg->msg.msg.serialcreate.link_status_cb, msg->msg.msg.serialcreate.ctx_cb); + return ERR_OK; +} + +/** + * Call pppos_create() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +ppp_pcb* +pppapi_pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb) +{ + ppp_pcb* result; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC_RETURN_NULL(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = NULL; + PPPAPI_VAR_REF(msg).msg.msg.serialcreate.pppif = pppif; + PPPAPI_VAR_REF(msg).msg.msg.serialcreate.output_cb = output_cb; + PPPAPI_VAR_REF(msg).msg.msg.serialcreate.link_status_cb = link_status_cb; + PPPAPI_VAR_REF(msg).msg.msg.serialcreate.ctx_cb = ctx_cb; + tcpip_api_call(pppapi_do_pppos_create, &PPPAPI_VAR_REF(msg).call); + result = PPPAPI_VAR_REF(msg).msg.ppp; + PPPAPI_VAR_FREE(msg); + return result; +} +#endif /* PPPOS_SUPPORT */ + + +#if PPPOE_SUPPORT +/** + * Call pppoe_create() inside the tcpip_thread context. + */ +static err_t +pppapi_do_pppoe_create(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + msg->msg.ppp = pppoe_create(msg->msg.msg.ethernetcreate.pppif, msg->msg.msg.ethernetcreate.ethif, + msg->msg.msg.ethernetcreate.service_name, msg->msg.msg.ethernetcreate.concentrator_name, + msg->msg.msg.ethernetcreate.link_status_cb, msg->msg.msg.ethernetcreate.ctx_cb); + return ERR_OK; +} + +/** + * Call pppoe_create() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +ppp_pcb* +pppapi_pppoe_create(struct netif *pppif, struct netif *ethif, const char *service_name, + const char *concentrator_name, ppp_link_status_cb_fn link_status_cb, + void *ctx_cb) +{ + ppp_pcb* result; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC_RETURN_NULL(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = NULL; + PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.pppif = pppif; + PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.ethif = ethif; + PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.service_name = service_name; + PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.concentrator_name = concentrator_name; + PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.link_status_cb = link_status_cb; + PPPAPI_VAR_REF(msg).msg.msg.ethernetcreate.ctx_cb = ctx_cb; + tcpip_api_call(pppapi_do_pppoe_create, &PPPAPI_VAR_REF(msg).call); + result = PPPAPI_VAR_REF(msg).msg.ppp; + PPPAPI_VAR_FREE(msg); + return result; +} +#endif /* PPPOE_SUPPORT */ + + +#if PPPOL2TP_SUPPORT +/** + * Call pppol2tp_create() inside the tcpip_thread context. + */ +static err_t +pppapi_do_pppol2tp_create(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + msg->msg.ppp = pppol2tp_create(msg->msg.msg.l2tpcreate.pppif, + msg->msg.msg.l2tpcreate.netif, API_EXPR_REF(msg->msg.msg.l2tpcreate.ipaddr), msg->msg.msg.l2tpcreate.port, +#if PPPOL2TP_AUTH_SUPPORT + msg->msg.msg.l2tpcreate.secret, + msg->msg.msg.l2tpcreate.secret_len, +#else /* PPPOL2TP_AUTH_SUPPORT */ + NULL, + 0, +#endif /* PPPOL2TP_AUTH_SUPPORT */ + msg->msg.msg.l2tpcreate.link_status_cb, msg->msg.msg.l2tpcreate.ctx_cb); + return ERR_OK; +} + +/** + * Call pppol2tp_create() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +ppp_pcb* +pppapi_pppol2tp_create(struct netif *pppif, struct netif *netif, ip_addr_t *ipaddr, u16_t port, + const u8_t *secret, u8_t secret_len, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb) +{ + ppp_pcb* result; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC_RETURN_NULL(msg); +#if !PPPOL2TP_AUTH_SUPPORT + LWIP_UNUSED_ARG(secret); + LWIP_UNUSED_ARG(secret_len); +#endif /* !PPPOL2TP_AUTH_SUPPORT */ + + PPPAPI_VAR_REF(msg).msg.ppp = NULL; + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.pppif = pppif; + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.netif = netif; + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.ipaddr = PPPAPI_VAR_REF(ipaddr); + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.port = port; +#if PPPOL2TP_AUTH_SUPPORT + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.secret = secret; + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.secret_len = secret_len; +#endif /* PPPOL2TP_AUTH_SUPPORT */ + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.link_status_cb = link_status_cb; + PPPAPI_VAR_REF(msg).msg.msg.l2tpcreate.ctx_cb = ctx_cb; + tcpip_api_call(pppapi_do_pppol2tp_create, &PPPAPI_VAR_REF(msg).call); + result = PPPAPI_VAR_REF(msg).msg.ppp; + PPPAPI_VAR_FREE(msg); + return result; +} +#endif /* PPPOL2TP_SUPPORT */ + + +/** + * Call ppp_connect() inside the tcpip_thread context. + */ +static err_t +pppapi_do_ppp_connect(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + return ppp_connect(msg->msg.ppp, msg->msg.msg.connect.holdoff); +} + +/** + * Call ppp_connect() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +err_t +pppapi_connect(ppp_pcb *pcb, u16_t holdoff) +{ + err_t err; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = pcb; + PPPAPI_VAR_REF(msg).msg.msg.connect.holdoff = holdoff; + err = tcpip_api_call(pppapi_do_ppp_connect, &PPPAPI_VAR_REF(msg).call); + PPPAPI_VAR_FREE(msg); + return err; +} + + +#if PPP_SERVER +/** + * Call ppp_listen() inside the tcpip_thread context. + */ +static err_t +pppapi_do_ppp_listen(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + return ppp_listen(msg->msg.ppp); +} + +/** + * Call ppp_listen() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +err_t +pppapi_listen(ppp_pcb *pcb) +{ + err_t err; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = pcb; + err = tcpip_api_call(pppapi_do_ppp_listen, &PPPAPI_VAR_REF(msg).call); + PPPAPI_VAR_FREE(msg); + return err; +} +#endif /* PPP_SERVER */ + + +/** + * Call ppp_close() inside the tcpip_thread context. + */ +static err_t +pppapi_do_ppp_close(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + return ppp_close(msg->msg.ppp, msg->msg.msg.close.nocarrier); +} + +/** + * Call ppp_close() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +err_t +pppapi_close(ppp_pcb *pcb, u8_t nocarrier) +{ + err_t err; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = pcb; + PPPAPI_VAR_REF(msg).msg.msg.close.nocarrier = nocarrier; + err = tcpip_api_call(pppapi_do_ppp_close, &PPPAPI_VAR_REF(msg).call); + PPPAPI_VAR_FREE(msg); + return err; +} + + +/** + * Call ppp_free() inside the tcpip_thread context. + */ +static err_t +pppapi_do_ppp_free(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + return ppp_free(msg->msg.ppp); +} + +/** + * Call ppp_free() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +err_t +pppapi_free(ppp_pcb *pcb) +{ + err_t err; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = pcb; + err = tcpip_api_call(pppapi_do_ppp_free, &PPPAPI_VAR_REF(msg).call); + PPPAPI_VAR_FREE(msg); + return err; +} + + +/** + * Call ppp_ioctl() inside the tcpip_thread context. + */ +static err_t +pppapi_do_ppp_ioctl(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 pppapi_msg */ + struct pppapi_msg *msg = (struct pppapi_msg *)(void*)m; + + return ppp_ioctl(msg->msg.ppp, msg->msg.msg.ioctl.cmd, msg->msg.msg.ioctl.arg); +} + +/** + * Call ppp_ioctl() in a thread-safe way by running that function inside the + * tcpip_thread context. + */ +err_t +pppapi_ioctl(ppp_pcb *pcb, u8_t cmd, void *arg) +{ + err_t err; + PPPAPI_VAR_DECLARE(msg); + PPPAPI_VAR_ALLOC(msg); + + PPPAPI_VAR_REF(msg).msg.ppp = pcb; + PPPAPI_VAR_REF(msg).msg.msg.ioctl.cmd = cmd; + PPPAPI_VAR_REF(msg).msg.msg.ioctl.arg = arg; + err = tcpip_api_call(pppapi_do_ppp_ioctl, &PPPAPI_VAR_REF(msg).call); + PPPAPI_VAR_FREE(msg); + return err; +} + +#endif /* LWIP_PPP_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppcrypt.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppcrypt.c index f2f36aad..82d78c13 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppcrypt.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppcrypt.c @@ -1,66 +1,66 @@ -/* - * pppcrypt.c - PPP/DES linkage for MS-CHAP and EAP SRP-SHA1 - * - * Extracted from chap_ms.c by James Carlson. - * - * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && MSCHAP_SUPPORT /* don't build if not necessary */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/pppcrypt.h" - - -static u_char pppcrypt_get_7bits(u_char *input, int startBit) { - unsigned int word; - - word = (unsigned)input[startBit / 8] << 8; - word |= (unsigned)input[startBit / 8 + 1]; - - word >>= 15 - (startBit % 8 + 7); - - return word & 0xFE; -} - -/* IN 56 bit DES key missing parity bits - * OUT 64 bit DES key with parity bits added - */ -void pppcrypt_56_to_64_bit_key(u_char *key, u_char * des_key) { - des_key[0] = pppcrypt_get_7bits(key, 0); - des_key[1] = pppcrypt_get_7bits(key, 7); - des_key[2] = pppcrypt_get_7bits(key, 14); - des_key[3] = pppcrypt_get_7bits(key, 21); - des_key[4] = pppcrypt_get_7bits(key, 28); - des_key[5] = pppcrypt_get_7bits(key, 35); - des_key[6] = pppcrypt_get_7bits(key, 42); - des_key[7] = pppcrypt_get_7bits(key, 49); -} - -#endif /* PPP_SUPPORT && MSCHAP_SUPPORT */ +/* + * pppcrypt.c - PPP/DES linkage for MS-CHAP and EAP SRP-SHA1 + * + * Extracted from chap_ms.c by James Carlson. + * + * Copyright (c) 1995 Eric Rosenquist. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && MSCHAP_SUPPORT /* don't build if not necessary */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/pppcrypt.h" + + +static u_char pppcrypt_get_7bits(u_char *input, int startBit) { + unsigned int word; + + word = (unsigned)input[startBit / 8] << 8; + word |= (unsigned)input[startBit / 8 + 1]; + + word >>= 15 - (startBit % 8 + 7); + + return word & 0xFE; +} + +/* IN 56 bit DES key missing parity bits + * OUT 64 bit DES key with parity bits added + */ +void pppcrypt_56_to_64_bit_key(u_char *key, u_char * des_key) { + des_key[0] = pppcrypt_get_7bits(key, 0); + des_key[1] = pppcrypt_get_7bits(key, 7); + des_key[2] = pppcrypt_get_7bits(key, 14); + des_key[3] = pppcrypt_get_7bits(key, 21); + des_key[4] = pppcrypt_get_7bits(key, 28); + des_key[5] = pppcrypt_get_7bits(key, 35); + des_key[6] = pppcrypt_get_7bits(key, 42); + des_key[7] = pppcrypt_get_7bits(key, 49); +} + +#endif /* PPP_SUPPORT && MSCHAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppoe.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppoe.c index 33b96279..8ed2d638 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppoe.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppoe.c @@ -1,1201 +1,1201 @@ -/***************************************************************************** -* pppoe.c - PPP Over Ethernet implementation for lwIP. -* -* Copyright (c) 2006 by Marc Boucher, Services Informatiques (MBSI) inc. -* -* The authors hereby grant permission to use, copy, modify, distribute, -* and license this software and its documentation for any purpose, provided -* that existing copyright notices are retained in all copies and that this -* notice and the following disclaimer are included verbatim in any -* distributions. No written agreement, license, or royalty fee is required -* for any of the authorized uses. -* -* THIS SOFTWARE IS PROVIDED BY THE 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 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. -* -****************************************************************************** -* REVISION HISTORY -* -* 06-01-01 Marc Boucher -* Ported to lwIP. -*****************************************************************************/ - - - -/* based on NetBSD: if_pppoe.c,v 1.64 2006/01/31 23:50:15 martin Exp */ - -/*- - * Copyright (c) 2002 The NetBSD Foundation, Inc. - * All rights reserved. - * - * This code is derived from software contributed to The NetBSD Foundation - * by Martin Husemann . - * - * 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. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the NetBSD - * Foundation, Inc. and its contributors. - * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPPOE_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#if 0 /* UNUSED */ -#include -#include -#endif /* UNUSED */ - -#include "lwip/timeouts.h" -#include "lwip/memp.h" -#include "lwip/stats.h" -#include "lwip/snmp.h" - -#include "netif/ethernet.h" -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/lcp.h" -#include "netif/ppp/ipcp.h" -#include "netif/ppp/pppoe.h" - -/* Memory pool */ -LWIP_MEMPOOL_DECLARE(PPPOE_IF, MEMP_NUM_PPPOE_INTERFACES, sizeof(struct pppoe_softc), "PPPOE_IF") - -/* Add a 16 bit unsigned value to a buffer pointed to by PTR */ -#define PPPOE_ADD_16(PTR, VAL) \ - *(PTR)++ = (u8_t)((VAL) / 256); \ - *(PTR)++ = (u8_t)((VAL) % 256) - -/* Add a complete PPPoE header to the buffer pointed to by PTR */ -#define PPPOE_ADD_HEADER(PTR, CODE, SESS, LEN) \ - *(PTR)++ = PPPOE_VERTYPE; \ - *(PTR)++ = (CODE); \ - PPPOE_ADD_16(PTR, SESS); \ - PPPOE_ADD_16(PTR, LEN) - -#define PPPOE_DISC_TIMEOUT (5*1000) /* base for quick timeout calculation */ -#define PPPOE_SLOW_RETRY (60*1000) /* persistent retry interval */ -#define PPPOE_DISC_MAXPADI 4 /* retry PADI four times (quickly) */ -#define PPPOE_DISC_MAXPADR 2 /* retry PADR twice */ - -#ifdef PPPOE_SERVER -#error "PPPOE_SERVER is not yet supported under lwIP!" -/* from if_spppsubr.c */ -#define IFF_PASSIVE IFF_LINK0 /* wait passively for connection */ -#endif - -#define PPPOE_ERRORSTRING_LEN 64 - - -/* callbacks called from PPP core */ -static err_t pppoe_write(ppp_pcb *ppp, void *ctx, struct pbuf *p); -static err_t pppoe_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol); -static void pppoe_connect(ppp_pcb *ppp, void *ctx); -static void pppoe_disconnect(ppp_pcb *ppp, void *ctx); -static err_t pppoe_destroy(ppp_pcb *ppp, void *ctx); - -/* management routines */ -static void pppoe_abort_connect(struct pppoe_softc *); -#if 0 /* UNUSED */ -static void pppoe_clear_softc(struct pppoe_softc *, const char *); -#endif /* UNUSED */ - -/* internal timeout handling */ -static void pppoe_timeout(void *); - -/* sending actual protocol controll packets */ -static err_t pppoe_send_padi(struct pppoe_softc *); -static err_t pppoe_send_padr(struct pppoe_softc *); -#ifdef PPPOE_SERVER -static err_t pppoe_send_pado(struct pppoe_softc *); -static err_t pppoe_send_pads(struct pppoe_softc *); -#endif -static err_t pppoe_send_padt(struct netif *, u_int, const u8_t *); - -/* internal helper functions */ -static err_t pppoe_xmit(struct pppoe_softc *sc, struct pbuf *pb); -static struct pppoe_softc* pppoe_find_softc_by_session(u_int session, struct netif *rcvif); -static struct pppoe_softc* pppoe_find_softc_by_hunique(u8_t *token, size_t len, struct netif *rcvif); - -/** linked list of created pppoe interfaces */ -static struct pppoe_softc *pppoe_softc_list; - -/* Callbacks structure for PPP core */ -static const struct link_callbacks pppoe_callbacks = { - pppoe_connect, -#if PPP_SERVER - NULL, -#endif /* PPP_SERVER */ - pppoe_disconnect, - pppoe_destroy, - pppoe_write, - pppoe_netif_output, - NULL, - NULL -}; - -/* - * Create a new PPP Over Ethernet (PPPoE) connection. - * - * Return 0 on success, an error code on failure. - */ -ppp_pcb *pppoe_create(struct netif *pppif, - struct netif *ethif, - const char *service_name, const char *concentrator_name, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb) -{ - ppp_pcb *ppp; - struct pppoe_softc *sc; - LWIP_UNUSED_ARG(service_name); - LWIP_UNUSED_ARG(concentrator_name); - LWIP_ASSERT_CORE_LOCKED(); - - sc = (struct pppoe_softc *)LWIP_MEMPOOL_ALLOC(PPPOE_IF); - if (sc == NULL) { - return NULL; - } - - ppp = ppp_new(pppif, &pppoe_callbacks, sc, link_status_cb, ctx_cb); - if (ppp == NULL) { - LWIP_MEMPOOL_FREE(PPPOE_IF, sc); - return NULL; - } - - memset(sc, 0, sizeof(struct pppoe_softc)); - sc->pcb = ppp; - sc->sc_ethif = ethif; - /* put the new interface at the head of the list */ - sc->next = pppoe_softc_list; - pppoe_softc_list = sc; - return ppp; -} - -/* Called by PPP core */ -static err_t pppoe_write(ppp_pcb *ppp, void *ctx, struct pbuf *p) { - struct pppoe_softc *sc = (struct pppoe_softc *)ctx; - struct pbuf *ph; /* Ethernet + PPPoE header */ - err_t ret; -#if MIB2_STATS - u16_t tot_len; -#else /* MIB2_STATS */ - LWIP_UNUSED_ARG(ppp); -#endif /* MIB2_STATS */ - - /* skip address & flags */ - pbuf_remove_header(p, 2); - - ph = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN), PBUF_RAM); - if(!ph) { - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.proterr); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - pbuf_free(p); - return ERR_MEM; - } - - pbuf_remove_header(ph, PPPOE_HEADERLEN); /* hide PPPoE header */ - pbuf_cat(ph, p); -#if MIB2_STATS - tot_len = ph->tot_len; -#endif /* MIB2_STATS */ - - ret = pppoe_xmit(sc, ph); - if (ret != ERR_OK) { - LINK_STATS_INC(link.err); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - return ret; - } - - MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, (u16_t)tot_len); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); - LINK_STATS_INC(link.xmit); - return ERR_OK; -} - -/* Called by PPP core */ -static err_t pppoe_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol) { - struct pppoe_softc *sc = (struct pppoe_softc *)ctx; - struct pbuf *pb; - u8_t *pl; - err_t err; -#if MIB2_STATS - u16_t tot_len; -#else /* MIB2_STATS */ - LWIP_UNUSED_ARG(ppp); -#endif /* MIB2_STATS */ - - /* @todo: try to use pbuf_header() here! */ - pb = pbuf_alloc(PBUF_LINK, PPPOE_HEADERLEN + sizeof(protocol), PBUF_RAM); - if(!pb) { - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.proterr); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - return ERR_MEM; - } - - pbuf_remove_header(pb, PPPOE_HEADERLEN); - - pl = (u8_t*)pb->payload; - PUTSHORT(protocol, pl); - - pbuf_chain(pb, p); -#if MIB2_STATS - tot_len = pb->tot_len; -#endif /* MIB2_STATS */ - - if( (err = pppoe_xmit(sc, pb)) != ERR_OK) { - LINK_STATS_INC(link.err); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - return err; - } - - MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, tot_len); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); - LINK_STATS_INC(link.xmit); - return ERR_OK; -} - -static err_t -pppoe_destroy(ppp_pcb *ppp, void *ctx) -{ - struct pppoe_softc *sc = (struct pppoe_softc *)ctx; - struct pppoe_softc **copp, *freep; - LWIP_UNUSED_ARG(ppp); - - sys_untimeout(pppoe_timeout, sc); - - /* remove interface from list */ - for (copp = &pppoe_softc_list; (freep = *copp); copp = &freep->next) { - if (freep == sc) { - *copp = freep->next; - break; - } - } - -#ifdef PPPOE_TODO - if (sc->sc_concentrator_name) { - mem_free(sc->sc_concentrator_name); - } - if (sc->sc_service_name) { - mem_free(sc->sc_service_name); - } -#endif /* PPPOE_TODO */ - LWIP_MEMPOOL_FREE(PPPOE_IF, sc); - - return ERR_OK; -} - -/* - * Find the interface handling the specified session. - * Note: O(number of sessions open), this is a client-side only, mean - * and lean implementation, so number of open sessions typically should - * be 1. - */ -static struct pppoe_softc* pppoe_find_softc_by_session(u_int session, struct netif *rcvif) { - struct pppoe_softc *sc; - - for (sc = pppoe_softc_list; sc != NULL; sc = sc->next) { - if (sc->sc_state == PPPOE_STATE_SESSION - && sc->sc_session == session - && sc->sc_ethif == rcvif) { - return sc; - } - } - return NULL; -} - -/* Check host unique token passed and return appropriate softc pointer, - * or NULL if token is bogus. */ -static struct pppoe_softc* pppoe_find_softc_by_hunique(u8_t *token, size_t len, struct netif *rcvif) { - struct pppoe_softc *sc, *t; - - if (len != sizeof sc) { - return NULL; - } - MEMCPY(&t, token, len); - - for (sc = pppoe_softc_list; sc != NULL; sc = sc->next) { - if (sc == t) { - break; - } - } - - if (sc == NULL) { - PPPDEBUG(LOG_DEBUG, ("pppoe: alien host unique tag, no session found\n")); - return NULL; - } - - /* should be safe to access *sc now */ - if (sc->sc_state < PPPOE_STATE_PADI_SENT || sc->sc_state >= PPPOE_STATE_SESSION) { - PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": host unique tag found, but it belongs to a connection in state %d\n", - sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, sc->sc_state)); - return NULL; - } - if (sc->sc_ethif != rcvif) { - PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": wrong interface, not accepting host unique\n", - sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - return NULL; - } - return sc; -} - -/* analyze and handle a single received packet while not in session state */ -void -pppoe_disc_input(struct netif *netif, struct pbuf *pb) -{ - u16_t tag, len, off; - u16_t session, plen; - struct pppoe_softc *sc; -#if PPP_DEBUG - const char *err_msg = NULL; -#endif /* PPP_DEBUG */ - u8_t *ac_cookie; - u16_t ac_cookie_len; -#ifdef PPPOE_SERVER - u8_t *hunique; - size_t hunique_len; -#endif - struct pppoehdr *ph; - struct pppoetag pt; - int err; - struct eth_hdr *ethhdr; - - /* don't do anything if there is not a single PPPoE instance */ - if (pppoe_softc_list == NULL) { - pbuf_free(pb); - return; - } - - pb = pbuf_coalesce(pb, PBUF_RAW); - - ethhdr = (struct eth_hdr *)pb->payload; - - ac_cookie = NULL; - ac_cookie_len = 0; -#ifdef PPPOE_SERVER - hunique = NULL; - hunique_len = 0; -#endif - session = 0; - off = sizeof(struct eth_hdr) + sizeof(struct pppoehdr); - if (pb->len < off) { - PPPDEBUG(LOG_DEBUG, ("pppoe: packet too short: %d\n", pb->len)); - goto done; - } - - ph = (struct pppoehdr *) (ethhdr + 1); - if (ph->vertype != PPPOE_VERTYPE) { - PPPDEBUG(LOG_DEBUG, ("pppoe: unknown version/type packet: 0x%x\n", ph->vertype)); - goto done; - } - session = lwip_ntohs(ph->session); - plen = lwip_ntohs(ph->plen); - - if (plen > (pb->len - off)) { - PPPDEBUG(LOG_DEBUG, ("pppoe: packet content does not fit: data available = %d, packet size = %u\n", - pb->len - off, plen)); - goto done; - } - if(pb->tot_len == pb->len) { - u16_t framelen = off + plen; - if (framelen < pb->len) { - /* ignore trailing garbage */ - pb->tot_len = pb->len = framelen; - } - } - tag = 0; - len = 0; - sc = NULL; - while (off + sizeof(pt) <= pb->len) { - MEMCPY(&pt, (u8_t*)pb->payload + off, sizeof(pt)); - tag = lwip_ntohs(pt.tag); - len = lwip_ntohs(pt.len); - if (off + sizeof(pt) + len > pb->len) { - PPPDEBUG(LOG_DEBUG, ("pppoe: tag 0x%x len 0x%x is too long\n", tag, len)); - goto done; - } - switch (tag) { - case PPPOE_TAG_EOL: - goto breakbreak; - case PPPOE_TAG_SNAME: - break; /* ignored */ - case PPPOE_TAG_ACNAME: - break; /* ignored */ - case PPPOE_TAG_HUNIQUE: - if (sc != NULL) { - break; - } -#ifdef PPPOE_SERVER - hunique = (u8_t*)pb->payload + off + sizeof(pt); - hunique_len = len; -#endif - sc = pppoe_find_softc_by_hunique((u8_t*)pb->payload + off + sizeof(pt), len, netif); - break; - case PPPOE_TAG_ACCOOKIE: - if (ac_cookie == NULL) { - if (len > PPPOE_MAX_AC_COOKIE_LEN) { - PPPDEBUG(LOG_DEBUG, ("pppoe: AC cookie is too long: len = %d, max = %d\n", len, PPPOE_MAX_AC_COOKIE_LEN)); - goto done; - } - ac_cookie = (u8_t*)pb->payload + off + sizeof(pt); - ac_cookie_len = len; - } - break; -#if PPP_DEBUG - case PPPOE_TAG_SNAME_ERR: - err_msg = "SERVICE NAME ERROR"; - break; - case PPPOE_TAG_ACSYS_ERR: - err_msg = "AC SYSTEM ERROR"; - break; - case PPPOE_TAG_GENERIC_ERR: - err_msg = "GENERIC ERROR"; - break; -#endif /* PPP_DEBUG */ - default: - break; - } -#if PPP_DEBUG - if (err_msg != NULL) { - char error_tmp[PPPOE_ERRORSTRING_LEN]; - u16_t error_len = LWIP_MIN(len, sizeof(error_tmp)-1); - strncpy(error_tmp, (char*)pb->payload + off + sizeof(pt), error_len); - error_tmp[error_len] = '\0'; - if (sc) { - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": %s: %s\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err_msg, error_tmp)); - } else { - PPPDEBUG(LOG_DEBUG, ("pppoe: %s: %s\n", err_msg, error_tmp)); - } - } -#endif /* PPP_DEBUG */ - off += sizeof(pt) + len; - } - -breakbreak:; - switch (ph->code) { - case PPPOE_CODE_PADI: -#ifdef PPPOE_SERVER - /* - * got service name, concentrator name, and/or host unique. - * ignore if we have no interfaces with IFF_PASSIVE|IFF_UP. - */ - if (LIST_EMPTY(&pppoe_softc_list)) { - goto done; - } - LIST_FOREACH(sc, &pppoe_softc_list, sc_list) { - if (!(sc->sc_sppp.pp_if.if_flags & IFF_UP)) { - continue; - } - if (!(sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE)) { - continue; - } - if (sc->sc_state == PPPOE_STATE_INITIAL) { - break; - } - } - if (sc == NULL) { - /* PPPDEBUG(LOG_DEBUG, ("pppoe: free passive interface is not found\n")); */ - goto done; - } - if (hunique) { - if (sc->sc_hunique) { - mem_free(sc->sc_hunique); - } - sc->sc_hunique = mem_malloc(hunique_len); - if (sc->sc_hunique == NULL) { - goto done; - } - sc->sc_hunique_len = hunique_len; - MEMCPY(sc->sc_hunique, hunique, hunique_len); - } - MEMCPY(&sc->sc_dest, eh->ether_shost, sizeof sc->sc_dest); - sc->sc_state = PPPOE_STATE_PADO_SENT; - pppoe_send_pado(sc); - break; -#endif /* PPPOE_SERVER */ - case PPPOE_CODE_PADR: -#ifdef PPPOE_SERVER - /* - * get sc from ac_cookie if IFF_PASSIVE - */ - if (ac_cookie == NULL) { - /* be quiet if there is not a single pppoe instance */ - PPPDEBUG(LOG_DEBUG, ("pppoe: received PADR but not includes ac_cookie\n")); - goto done; - } - sc = pppoe_find_softc_by_hunique(ac_cookie, ac_cookie_len, netif); - if (sc == NULL) { - /* be quiet if there is not a single pppoe instance */ - if (!LIST_EMPTY(&pppoe_softc_list)) { - PPPDEBUG(LOG_DEBUG, ("pppoe: received PADR but could not find request for it\n")); - } - goto done; - } - if (sc->sc_state != PPPOE_STATE_PADO_SENT) { - PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": received unexpected PADR\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - goto done; - } - if (hunique) { - if (sc->sc_hunique) { - mem_free(sc->sc_hunique); - } - sc->sc_hunique = mem_malloc(hunique_len); - if (sc->sc_hunique == NULL) { - goto done; - } - sc->sc_hunique_len = hunique_len; - MEMCPY(sc->sc_hunique, hunique, hunique_len); - } - pppoe_send_pads(sc); - sc->sc_state = PPPOE_STATE_SESSION; - ppp_start(sc->pcb); /* notify upper layers */ - break; -#else - /* ignore, we are no access concentrator */ - goto done; -#endif /* PPPOE_SERVER */ - case PPPOE_CODE_PADO: - if (sc == NULL) { - /* be quiet if there is not a single pppoe instance */ - if (pppoe_softc_list != NULL) { - PPPDEBUG(LOG_DEBUG, ("pppoe: received PADO but could not find request for it\n")); - } - goto done; - } - if (sc->sc_state != PPPOE_STATE_PADI_SENT) { - PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": received unexpected PADO\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - goto done; - } - if (ac_cookie) { - sc->sc_ac_cookie_len = ac_cookie_len; - MEMCPY(sc->sc_ac_cookie, ac_cookie, ac_cookie_len); - } - MEMCPY(&sc->sc_dest, ethhdr->src.addr, sizeof(sc->sc_dest.addr)); - sys_untimeout(pppoe_timeout, sc); - sc->sc_padr_retried = 0; - sc->sc_state = PPPOE_STATE_PADR_SENT; - if ((err = pppoe_send_padr(sc)) != 0) { - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADR, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried), pppoe_timeout, sc); - break; - case PPPOE_CODE_PADS: - if (sc == NULL) { - goto done; - } - sc->sc_session = session; - sys_untimeout(pppoe_timeout, sc); - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": session 0x%x connected\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, session)); - sc->sc_state = PPPOE_STATE_SESSION; - ppp_start(sc->pcb); /* notify upper layers */ - break; - case PPPOE_CODE_PADT: - /* Don't disconnect here, we let the LCP Echo/Reply find the fact - * that PPP session is down. Asking the PPP stack to end the session - * require strict checking about the PPP phase to prevent endless - * disconnection loops. - */ -#if 0 /* UNUSED */ - if (sc == NULL) { /* PADT frames are rarely sent with a hunique tag, this is actually almost always true */ - goto done; - } - pppoe_clear_softc(sc, "received PADT"); -#endif /* UNUSED */ - break; - default: - if(sc) { - PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": unknown code (0x%"X16_F") session = 0x%"X16_F"\n", - sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, - (u16_t)ph->code, session)); - } else { - PPPDEBUG(LOG_DEBUG, ("pppoe: unknown code (0x%"X16_F") session = 0x%"X16_F"\n", (u16_t)ph->code, session)); - } - break; - } - -done: - pbuf_free(pb); - return; -} - -void -pppoe_data_input(struct netif *netif, struct pbuf *pb) -{ - u16_t session, plen; - struct pppoe_softc *sc; - struct pppoehdr *ph; -#ifdef PPPOE_TERM_UNKNOWN_SESSIONS - u8_t shost[ETHER_ADDR_LEN]; -#endif - -#ifdef PPPOE_TERM_UNKNOWN_SESSIONS - MEMCPY(shost, ((struct eth_hdr *)pb->payload)->src.addr, sizeof(shost)); -#endif - if (pbuf_remove_header(pb, sizeof(struct eth_hdr)) != 0) { - /* bail out */ - PPPDEBUG(LOG_ERR, ("pppoe_data_input: pbuf_remove_header failed\n")); - LINK_STATS_INC(link.lenerr); - goto drop; - } - - if (pb->len < sizeof(*ph)) { - PPPDEBUG(LOG_DEBUG, ("pppoe_data_input: could not get PPPoE header\n")); - goto drop; - } - ph = (struct pppoehdr *)pb->payload; - - if (ph->vertype != PPPOE_VERTYPE) { - PPPDEBUG(LOG_DEBUG, ("pppoe (data): unknown version/type packet: 0x%x\n", ph->vertype)); - goto drop; - } - if (ph->code != 0) { - goto drop; - } - - session = lwip_ntohs(ph->session); - sc = pppoe_find_softc_by_session(session, netif); - if (sc == NULL) { -#ifdef PPPOE_TERM_UNKNOWN_SESSIONS - PPPDEBUG(LOG_DEBUG, ("pppoe: input for unknown session 0x%x, sending PADT\n", session)); - pppoe_send_padt(netif, session, shost); -#endif - goto drop; - } - - plen = lwip_ntohs(ph->plen); - - if (pbuf_remove_header(pb, PPPOE_HEADERLEN) != 0) { - /* bail out */ - PPPDEBUG(LOG_ERR, ("pppoe_data_input: pbuf_remove_header PPPOE_HEADERLEN failed\n")); - LINK_STATS_INC(link.lenerr); - goto drop; - } - - PPPDEBUG(LOG_DEBUG, ("pppoe_data_input: %c%c%"U16_F": pkthdr.len=%d, pppoe.len=%d\n", - sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, - pb->len, plen)); - - if (pb->tot_len < plen) { - goto drop; - } - - /* Dispatch the packet thereby consuming it. */ - ppp_input(sc->pcb, pb); - return; - -drop: - pbuf_free(pb); -} - -static err_t -pppoe_output(struct pppoe_softc *sc, struct pbuf *pb) -{ - struct eth_hdr *ethhdr; - u16_t etype; - err_t res; - - /* make room for Ethernet header - should not fail */ - if (pbuf_add_header(pb, sizeof(struct eth_hdr)) != 0) { - /* bail out */ - PPPDEBUG(LOG_ERR, ("pppoe: %c%c%"U16_F": pppoe_output: could not allocate room for Ethernet header\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - LINK_STATS_INC(link.lenerr); - pbuf_free(pb); - return ERR_BUF; - } - ethhdr = (struct eth_hdr *)pb->payload; - etype = sc->sc_state == PPPOE_STATE_SESSION ? ETHTYPE_PPPOE : ETHTYPE_PPPOEDISC; - ethhdr->type = lwip_htons(etype); - MEMCPY(ðhdr->dest.addr, &sc->sc_dest.addr, sizeof(ethhdr->dest.addr)); - MEMCPY(ðhdr->src.addr, &sc->sc_ethif->hwaddr, sizeof(ethhdr->src.addr)); - - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F" (%x) state=%d, session=0x%x output -> %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F", len=%d\n", - sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, etype, - sc->sc_state, sc->sc_session, - sc->sc_dest.addr[0], sc->sc_dest.addr[1], sc->sc_dest.addr[2], sc->sc_dest.addr[3], sc->sc_dest.addr[4], sc->sc_dest.addr[5], - pb->tot_len)); - - res = sc->sc_ethif->linkoutput(sc->sc_ethif, pb); - - pbuf_free(pb); - - return res; -} - -static err_t -pppoe_send_padi(struct pppoe_softc *sc) -{ - struct pbuf *pb; - u8_t *p; - int len; -#ifdef PPPOE_TODO - int l1 = 0, l2 = 0; /* XXX: gcc */ -#endif /* PPPOE_TODO */ - - /* calculate length of frame (excluding ethernet header + pppoe header) */ - len = 2 + 2 + 2 + 2 + sizeof sc; /* service name tag is required, host unique is send too */ -#ifdef PPPOE_TODO - if (sc->sc_service_name != NULL) { - l1 = (int)strlen(sc->sc_service_name); - len += l1; - } - if (sc->sc_concentrator_name != NULL) { - l2 = (int)strlen(sc->sc_concentrator_name); - len += 2 + 2 + l2; - } -#endif /* PPPOE_TODO */ - LWIP_ASSERT("sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff", - sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff); - - /* allocate a buffer */ - pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); - if (!pb) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - p = (u8_t*)pb->payload; - /* fill in pkt */ - PPPOE_ADD_HEADER(p, PPPOE_CODE_PADI, 0, (u16_t)len); - PPPOE_ADD_16(p, PPPOE_TAG_SNAME); -#ifdef PPPOE_TODO - if (sc->sc_service_name != NULL) { - PPPOE_ADD_16(p, l1); - MEMCPY(p, sc->sc_service_name, l1); - p += l1; - } else -#endif /* PPPOE_TODO */ - { - PPPOE_ADD_16(p, 0); - } -#ifdef PPPOE_TODO - if (sc->sc_concentrator_name != NULL) { - PPPOE_ADD_16(p, PPPOE_TAG_ACNAME); - PPPOE_ADD_16(p, l2); - MEMCPY(p, sc->sc_concentrator_name, l2); - p += l2; - } -#endif /* PPPOE_TODO */ - PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); - PPPOE_ADD_16(p, sizeof(sc)); - MEMCPY(p, &sc, sizeof sc); - - /* send pkt */ - return pppoe_output(sc, pb); -} - -static void -pppoe_timeout(void *arg) -{ - u32_t retry_wait; - int err; - struct pppoe_softc *sc = (struct pppoe_softc*)arg; - - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": timeout\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - - switch (sc->sc_state) { - case PPPOE_STATE_PADI_SENT: - /* - * We have two basic ways of retrying: - * - Quick retry mode: try a few times in short sequence - * - Slow retry mode: we already had a connection successfully - * established and will try infinitely (without user - * intervention) - * We only enter slow retry mode if IFF_LINK1 (aka autodial) - * is not set. - */ - if (sc->sc_padi_retried < 0xff) { - sc->sc_padi_retried++; - } - if (!sc->pcb->settings.persist && sc->sc_padi_retried >= PPPOE_DISC_MAXPADI) { -#if 0 - if ((sc->sc_sppp.pp_if.if_flags & IFF_LINK1) == 0) { - /* slow retry mode */ - retry_wait = PPPOE_SLOW_RETRY; - } else -#endif - { - pppoe_abort_connect(sc); - return; - } - } - /* initialize for quick retry mode */ - retry_wait = LWIP_MIN(PPPOE_DISC_TIMEOUT * sc->sc_padi_retried, PPPOE_SLOW_RETRY); - if ((err = pppoe_send_padi(sc)) != 0) { - sc->sc_padi_retried--; - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to transmit PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_timeout(retry_wait, pppoe_timeout, sc); - break; - - case PPPOE_STATE_PADR_SENT: - sc->sc_padr_retried++; - if (sc->sc_padr_retried >= PPPOE_DISC_MAXPADR) { - MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest)); - sc->sc_state = PPPOE_STATE_PADI_SENT; - sc->sc_padr_retried = 0; - if ((err = pppoe_send_padi(sc)) != 0) { - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padi_retried), pppoe_timeout, sc); - return; - } - if ((err = pppoe_send_padr(sc)) != 0) { - sc->sc_padr_retried--; - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADR, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried), pppoe_timeout, sc); - break; - default: - return; /* all done, work in peace */ - } -} - -/* Start a connection (i.e. initiate discovery phase) */ -static void -pppoe_connect(ppp_pcb *ppp, void *ctx) -{ - err_t err; - struct pppoe_softc *sc = (struct pppoe_softc *)ctx; - lcp_options *lcp_wo; - lcp_options *lcp_ao; -#if PPP_IPV4_SUPPORT && VJ_SUPPORT - ipcp_options *ipcp_wo; - ipcp_options *ipcp_ao; -#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ - - sc->sc_session = 0; - sc->sc_ac_cookie_len = 0; - sc->sc_padi_retried = 0; - sc->sc_padr_retried = 0; - /* changed to real address later */ - MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest)); -#ifdef PPPOE_SERVER - /* wait PADI if IFF_PASSIVE */ - if ((sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE)) { - return 0; - } -#endif - - lcp_wo = &ppp->lcp_wantoptions; - lcp_wo->mru = sc->sc_ethif->mtu-PPPOE_HEADERLEN-2; /* two byte PPP protocol discriminator, then IP data */ - lcp_wo->neg_asyncmap = 0; - lcp_wo->neg_pcompression = 0; - lcp_wo->neg_accompression = 0; - lcp_wo->passive = 0; - lcp_wo->silent = 0; - - lcp_ao = &ppp->lcp_allowoptions; - lcp_ao->mru = sc->sc_ethif->mtu-PPPOE_HEADERLEN-2; /* two byte PPP protocol discriminator, then IP data */ - lcp_ao->neg_asyncmap = 0; - lcp_ao->neg_pcompression = 0; - lcp_ao->neg_accompression = 0; - -#if PPP_IPV4_SUPPORT && VJ_SUPPORT - ipcp_wo = &ppp->ipcp_wantoptions; - ipcp_wo->neg_vj = 0; - ipcp_wo->old_vj = 0; - - ipcp_ao = &ppp->ipcp_allowoptions; - ipcp_ao->neg_vj = 0; - ipcp_ao->old_vj = 0; -#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ - - /* save state, in case we fail to send PADI */ - sc->sc_state = PPPOE_STATE_PADI_SENT; - if ((err = pppoe_send_padi(sc)) != 0) { - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); - } - sys_timeout(PPPOE_DISC_TIMEOUT, pppoe_timeout, sc); -} - -/* disconnect */ -static void -pppoe_disconnect(ppp_pcb *ppp, void *ctx) -{ - struct pppoe_softc *sc = (struct pppoe_softc *)ctx; - - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": disconnecting\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - if (sc->sc_state == PPPOE_STATE_SESSION) { - pppoe_send_padt(sc->sc_ethif, sc->sc_session, (const u8_t *)&sc->sc_dest); - } - - /* stop any timer, disconnect can be called while initiating is in progress */ - sys_untimeout(pppoe_timeout, sc); - sc->sc_state = PPPOE_STATE_INITIAL; -#ifdef PPPOE_SERVER - if (sc->sc_hunique) { - mem_free(sc->sc_hunique); - sc->sc_hunique = NULL; /* probably not necessary, if state is initial we shouldn't have to access hunique anyway */ - } - sc->sc_hunique_len = 0; /* probably not necessary, if state is initial we shouldn't have to access hunique anyway */ -#endif - ppp_link_end(ppp); /* notify upper layers */ - return; -} - -/* Connection attempt aborted */ -static void -pppoe_abort_connect(struct pppoe_softc *sc) -{ - PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": could not establish connection\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - sc->sc_state = PPPOE_STATE_INITIAL; - ppp_link_failed(sc->pcb); /* notify upper layers */ -} - -/* Send a PADR packet */ -static err_t -pppoe_send_padr(struct pppoe_softc *sc) -{ - struct pbuf *pb; - u8_t *p; - size_t len; -#ifdef PPPOE_TODO - size_t l1 = 0; /* XXX: gcc */ -#endif /* PPPOE_TODO */ - - len = 2 + 2 + 2 + 2 + sizeof(sc); /* service name, host unique */ -#ifdef PPPOE_TODO - if (sc->sc_service_name != NULL) { /* service name tag maybe empty */ - l1 = strlen(sc->sc_service_name); - len += l1; - } -#endif /* PPPOE_TODO */ - if (sc->sc_ac_cookie_len > 0) { - len += 2 + 2 + sc->sc_ac_cookie_len; /* AC cookie */ - } - LWIP_ASSERT("sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff", - sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff); - pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); - if (!pb) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - p = (u8_t*)pb->payload; - PPPOE_ADD_HEADER(p, PPPOE_CODE_PADR, 0, len); - PPPOE_ADD_16(p, PPPOE_TAG_SNAME); -#ifdef PPPOE_TODO - if (sc->sc_service_name != NULL) { - PPPOE_ADD_16(p, l1); - MEMCPY(p, sc->sc_service_name, l1); - p += l1; - } else -#endif /* PPPOE_TODO */ - { - PPPOE_ADD_16(p, 0); - } - if (sc->sc_ac_cookie_len > 0) { - PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE); - PPPOE_ADD_16(p, sc->sc_ac_cookie_len); - MEMCPY(p, sc->sc_ac_cookie, sc->sc_ac_cookie_len); - p += sc->sc_ac_cookie_len; - } - PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); - PPPOE_ADD_16(p, sizeof(sc)); - MEMCPY(p, &sc, sizeof sc); - - return pppoe_output(sc, pb); -} - -/* send a PADT packet */ -static err_t -pppoe_send_padt(struct netif *outgoing_if, u_int session, const u8_t *dest) -{ - struct pbuf *pb; - struct eth_hdr *ethhdr; - err_t res; - u8_t *p; - - pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN), PBUF_RAM); - if (!pb) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - if (pbuf_add_header(pb, sizeof(struct eth_hdr))) { - PPPDEBUG(LOG_ERR, ("pppoe: pppoe_send_padt: could not allocate room for PPPoE header\n")); - LINK_STATS_INC(link.lenerr); - pbuf_free(pb); - return ERR_BUF; - } - ethhdr = (struct eth_hdr *)pb->payload; - ethhdr->type = PP_HTONS(ETHTYPE_PPPOEDISC); - MEMCPY(ðhdr->dest.addr, dest, sizeof(ethhdr->dest.addr)); - MEMCPY(ðhdr->src.addr, &outgoing_if->hwaddr, sizeof(ethhdr->src.addr)); - - p = (u8_t*)(ethhdr + 1); - PPPOE_ADD_HEADER(p, PPPOE_CODE_PADT, session, 0); - - res = outgoing_if->linkoutput(outgoing_if, pb); - - pbuf_free(pb); - - return res; -} - -#ifdef PPPOE_SERVER -static err_t -pppoe_send_pado(struct pppoe_softc *sc) -{ - struct pbuf *pb; - u8_t *p; - size_t len; - - /* calc length */ - len = 0; - /* include ac_cookie */ - len += 2 + 2 + sizeof(sc); - /* include hunique */ - len += 2 + 2 + sc->sc_hunique_len; - pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); - if (!pb) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - p = (u8_t*)pb->payload; - PPPOE_ADD_HEADER(p, PPPOE_CODE_PADO, 0, len); - PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE); - PPPOE_ADD_16(p, sizeof(sc)); - MEMCPY(p, &sc, sizeof(sc)); - p += sizeof(sc); - PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); - PPPOE_ADD_16(p, sc->sc_hunique_len); - MEMCPY(p, sc->sc_hunique, sc->sc_hunique_len); - return pppoe_output(sc, pb); -} - -static err_t -pppoe_send_pads(struct pppoe_softc *sc) -{ - struct pbuf *pb; - u8_t *p; - size_t len, l1 = 0; /* XXX: gcc */ - - sc->sc_session = mono_time.tv_sec % 0xff + 1; - /* calc length */ - len = 0; - /* include hunique */ - len += 2 + 2 + 2 + 2 + sc->sc_hunique_len; /* service name, host unique*/ - if (sc->sc_service_name != NULL) { /* service name tag maybe empty */ - l1 = strlen(sc->sc_service_name); - len += l1; - } - pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); - if (!pb) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - p = (u8_t*)pb->payload; - PPPOE_ADD_HEADER(p, PPPOE_CODE_PADS, sc->sc_session, len); - PPPOE_ADD_16(p, PPPOE_TAG_SNAME); - if (sc->sc_service_name != NULL) { - PPPOE_ADD_16(p, l1); - MEMCPY(p, sc->sc_service_name, l1); - p += l1; - } else { - PPPOE_ADD_16(p, 0); - } - PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); - PPPOE_ADD_16(p, sc->sc_hunique_len); - MEMCPY(p, sc->sc_hunique, sc->sc_hunique_len); - return pppoe_output(sc, pb); -} -#endif - -static err_t -pppoe_xmit(struct pppoe_softc *sc, struct pbuf *pb) -{ - u8_t *p; - size_t len; - - len = pb->tot_len; - - /* make room for PPPoE header - should not fail */ - if (pbuf_add_header(pb, PPPOE_HEADERLEN) != 0) { - /* bail out */ - PPPDEBUG(LOG_ERR, ("pppoe: %c%c%"U16_F": pppoe_xmit: could not allocate room for PPPoE header\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - LINK_STATS_INC(link.lenerr); - pbuf_free(pb); - return ERR_BUF; - } - - p = (u8_t*)pb->payload; - PPPOE_ADD_HEADER(p, 0, sc->sc_session, len); - - return pppoe_output(sc, pb); -} - -#if 0 /*def PFIL_HOOKS*/ -static int -pppoe_ifattach_hook(void *arg, struct pbuf **mp, struct netif *ifp, int dir) -{ - struct pppoe_softc *sc; - int s; - - if (mp != (struct pbuf **)PFIL_IFNET_DETACH) { - return 0; - } - - LIST_FOREACH(sc, &pppoe_softc_list, sc_list) { - if (sc->sc_ethif != ifp) { - continue; - } - if (sc->sc_sppp.pp_if.if_flags & IFF_UP) { - sc->sc_sppp.pp_if.if_flags &= ~(IFF_UP|IFF_RUNNING); - PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": ethernet interface detached, going down\n", - sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); - } - sc->sc_ethif = NULL; - pppoe_clear_softc(sc, "ethernet interface detached"); - } - - return 0; -} -#endif - -#if 0 /* UNUSED */ -static void -pppoe_clear_softc(struct pppoe_softc *sc, const char *message) -{ - LWIP_UNUSED_ARG(message); - - /* stop timer */ - sys_untimeout(pppoe_timeout, sc); - PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": session 0x%x terminated, %s\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, sc->sc_session, message)); - sc->sc_state = PPPOE_STATE_INITIAL; - ppp_link_end(sc->pcb); /* notify upper layers - /!\ dangerous /!\ - see pppoe_disc_input() */ -} -#endif /* UNUSED */ -#endif /* PPP_SUPPORT && PPPOE_SUPPORT */ +/***************************************************************************** +* pppoe.c - PPP Over Ethernet implementation for lwIP. +* +* Copyright (c) 2006 by Marc Boucher, Services Informatiques (MBSI) inc. +* +* The authors hereby grant permission to use, copy, modify, distribute, +* and license this software and its documentation for any purpose, provided +* that existing copyright notices are retained in all copies and that this +* notice and the following disclaimer are included verbatim in any +* distributions. No written agreement, license, or royalty fee is required +* for any of the authorized uses. +* +* THIS SOFTWARE IS PROVIDED BY THE 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 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. +* +****************************************************************************** +* REVISION HISTORY +* +* 06-01-01 Marc Boucher +* Ported to lwIP. +*****************************************************************************/ + + + +/* based on NetBSD: if_pppoe.c,v 1.64 2006/01/31 23:50:15 martin Exp */ + +/*- + * Copyright (c) 2002 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Martin Husemann . + * + * 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. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the NetBSD + * Foundation, Inc. and its contributors. + * 4. Neither the name of The NetBSD Foundation 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPPOE_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#if 0 /* UNUSED */ +#include +#include +#endif /* UNUSED */ + +#include "lwip/timeouts.h" +#include "lwip/memp.h" +#include "lwip/stats.h" +#include "lwip/snmp.h" + +#include "netif/ethernet.h" +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/lcp.h" +#include "netif/ppp/ipcp.h" +#include "netif/ppp/pppoe.h" + +/* Memory pool */ +LWIP_MEMPOOL_DECLARE(PPPOE_IF, MEMP_NUM_PPPOE_INTERFACES, sizeof(struct pppoe_softc), "PPPOE_IF") + +/* Add a 16 bit unsigned value to a buffer pointed to by PTR */ +#define PPPOE_ADD_16(PTR, VAL) \ + *(PTR)++ = (u8_t)((VAL) / 256); \ + *(PTR)++ = (u8_t)((VAL) % 256) + +/* Add a complete PPPoE header to the buffer pointed to by PTR */ +#define PPPOE_ADD_HEADER(PTR, CODE, SESS, LEN) \ + *(PTR)++ = PPPOE_VERTYPE; \ + *(PTR)++ = (CODE); \ + PPPOE_ADD_16(PTR, SESS); \ + PPPOE_ADD_16(PTR, LEN) + +#define PPPOE_DISC_TIMEOUT (5*1000) /* base for quick timeout calculation */ +#define PPPOE_SLOW_RETRY (60*1000) /* persistent retry interval */ +#define PPPOE_DISC_MAXPADI 4 /* retry PADI four times (quickly) */ +#define PPPOE_DISC_MAXPADR 2 /* retry PADR twice */ + +#ifdef PPPOE_SERVER +#error "PPPOE_SERVER is not yet supported under lwIP!" +/* from if_spppsubr.c */ +#define IFF_PASSIVE IFF_LINK0 /* wait passively for connection */ +#endif + +#define PPPOE_ERRORSTRING_LEN 64 + + +/* callbacks called from PPP core */ +static err_t pppoe_write(ppp_pcb *ppp, void *ctx, struct pbuf *p); +static err_t pppoe_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol); +static void pppoe_connect(ppp_pcb *ppp, void *ctx); +static void pppoe_disconnect(ppp_pcb *ppp, void *ctx); +static err_t pppoe_destroy(ppp_pcb *ppp, void *ctx); + +/* management routines */ +static void pppoe_abort_connect(struct pppoe_softc *); +#if 0 /* UNUSED */ +static void pppoe_clear_softc(struct pppoe_softc *, const char *); +#endif /* UNUSED */ + +/* internal timeout handling */ +static void pppoe_timeout(void *); + +/* sending actual protocol controll packets */ +static err_t pppoe_send_padi(struct pppoe_softc *); +static err_t pppoe_send_padr(struct pppoe_softc *); +#ifdef PPPOE_SERVER +static err_t pppoe_send_pado(struct pppoe_softc *); +static err_t pppoe_send_pads(struct pppoe_softc *); +#endif +static err_t pppoe_send_padt(struct netif *, u_int, const u8_t *); + +/* internal helper functions */ +static err_t pppoe_xmit(struct pppoe_softc *sc, struct pbuf *pb); +static struct pppoe_softc* pppoe_find_softc_by_session(u_int session, struct netif *rcvif); +static struct pppoe_softc* pppoe_find_softc_by_hunique(u8_t *token, size_t len, struct netif *rcvif); + +/** linked list of created pppoe interfaces */ +static struct pppoe_softc *pppoe_softc_list; + +/* Callbacks structure for PPP core */ +static const struct link_callbacks pppoe_callbacks = { + pppoe_connect, +#if PPP_SERVER + NULL, +#endif /* PPP_SERVER */ + pppoe_disconnect, + pppoe_destroy, + pppoe_write, + pppoe_netif_output, + NULL, + NULL +}; + +/* + * Create a new PPP Over Ethernet (PPPoE) connection. + * + * Return 0 on success, an error code on failure. + */ +ppp_pcb *pppoe_create(struct netif *pppif, + struct netif *ethif, + const char *service_name, const char *concentrator_name, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb) +{ + ppp_pcb *ppp; + struct pppoe_softc *sc; + LWIP_UNUSED_ARG(service_name); + LWIP_UNUSED_ARG(concentrator_name); + LWIP_ASSERT_CORE_LOCKED(); + + sc = (struct pppoe_softc *)LWIP_MEMPOOL_ALLOC(PPPOE_IF); + if (sc == NULL) { + return NULL; + } + + ppp = ppp_new(pppif, &pppoe_callbacks, sc, link_status_cb, ctx_cb); + if (ppp == NULL) { + LWIP_MEMPOOL_FREE(PPPOE_IF, sc); + return NULL; + } + + memset(sc, 0, sizeof(struct pppoe_softc)); + sc->pcb = ppp; + sc->sc_ethif = ethif; + /* put the new interface at the head of the list */ + sc->next = pppoe_softc_list; + pppoe_softc_list = sc; + return ppp; +} + +/* Called by PPP core */ +static err_t pppoe_write(ppp_pcb *ppp, void *ctx, struct pbuf *p) { + struct pppoe_softc *sc = (struct pppoe_softc *)ctx; + struct pbuf *ph; /* Ethernet + PPPoE header */ + err_t ret; +#if MIB2_STATS + u16_t tot_len; +#else /* MIB2_STATS */ + LWIP_UNUSED_ARG(ppp); +#endif /* MIB2_STATS */ + + /* skip address & flags */ + pbuf_remove_header(p, 2); + + ph = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN), PBUF_RAM); + if(!ph) { + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.proterr); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + pbuf_free(p); + return ERR_MEM; + } + + pbuf_remove_header(ph, PPPOE_HEADERLEN); /* hide PPPoE header */ + pbuf_cat(ph, p); +#if MIB2_STATS + tot_len = ph->tot_len; +#endif /* MIB2_STATS */ + + ret = pppoe_xmit(sc, ph); + if (ret != ERR_OK) { + LINK_STATS_INC(link.err); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + return ret; + } + + MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, (u16_t)tot_len); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); + LINK_STATS_INC(link.xmit); + return ERR_OK; +} + +/* Called by PPP core */ +static err_t pppoe_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol) { + struct pppoe_softc *sc = (struct pppoe_softc *)ctx; + struct pbuf *pb; + u8_t *pl; + err_t err; +#if MIB2_STATS + u16_t tot_len; +#else /* MIB2_STATS */ + LWIP_UNUSED_ARG(ppp); +#endif /* MIB2_STATS */ + + /* @todo: try to use pbuf_header() here! */ + pb = pbuf_alloc(PBUF_LINK, PPPOE_HEADERLEN + sizeof(protocol), PBUF_RAM); + if(!pb) { + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.proterr); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + return ERR_MEM; + } + + pbuf_remove_header(pb, PPPOE_HEADERLEN); + + pl = (u8_t*)pb->payload; + PUTSHORT(protocol, pl); + + pbuf_chain(pb, p); +#if MIB2_STATS + tot_len = pb->tot_len; +#endif /* MIB2_STATS */ + + if( (err = pppoe_xmit(sc, pb)) != ERR_OK) { + LINK_STATS_INC(link.err); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + return err; + } + + MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, tot_len); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); + LINK_STATS_INC(link.xmit); + return ERR_OK; +} + +static err_t +pppoe_destroy(ppp_pcb *ppp, void *ctx) +{ + struct pppoe_softc *sc = (struct pppoe_softc *)ctx; + struct pppoe_softc **copp, *freep; + LWIP_UNUSED_ARG(ppp); + + sys_untimeout(pppoe_timeout, sc); + + /* remove interface from list */ + for (copp = &pppoe_softc_list; (freep = *copp); copp = &freep->next) { + if (freep == sc) { + *copp = freep->next; + break; + } + } + +#ifdef PPPOE_TODO + if (sc->sc_concentrator_name) { + mem_free(sc->sc_concentrator_name); + } + if (sc->sc_service_name) { + mem_free(sc->sc_service_name); + } +#endif /* PPPOE_TODO */ + LWIP_MEMPOOL_FREE(PPPOE_IF, sc); + + return ERR_OK; +} + +/* + * Find the interface handling the specified session. + * Note: O(number of sessions open), this is a client-side only, mean + * and lean implementation, so number of open sessions typically should + * be 1. + */ +static struct pppoe_softc* pppoe_find_softc_by_session(u_int session, struct netif *rcvif) { + struct pppoe_softc *sc; + + for (sc = pppoe_softc_list; sc != NULL; sc = sc->next) { + if (sc->sc_state == PPPOE_STATE_SESSION + && sc->sc_session == session + && sc->sc_ethif == rcvif) { + return sc; + } + } + return NULL; +} + +/* Check host unique token passed and return appropriate softc pointer, + * or NULL if token is bogus. */ +static struct pppoe_softc* pppoe_find_softc_by_hunique(u8_t *token, size_t len, struct netif *rcvif) { + struct pppoe_softc *sc, *t; + + if (len != sizeof sc) { + return NULL; + } + MEMCPY(&t, token, len); + + for (sc = pppoe_softc_list; sc != NULL; sc = sc->next) { + if (sc == t) { + break; + } + } + + if (sc == NULL) { + PPPDEBUG(LOG_DEBUG, ("pppoe: alien host unique tag, no session found\n")); + return NULL; + } + + /* should be safe to access *sc now */ + if (sc->sc_state < PPPOE_STATE_PADI_SENT || sc->sc_state >= PPPOE_STATE_SESSION) { + PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": host unique tag found, but it belongs to a connection in state %d\n", + sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, sc->sc_state)); + return NULL; + } + if (sc->sc_ethif != rcvif) { + PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": wrong interface, not accepting host unique\n", + sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + return NULL; + } + return sc; +} + +/* analyze and handle a single received packet while not in session state */ +void +pppoe_disc_input(struct netif *netif, struct pbuf *pb) +{ + u16_t tag, len, off; + u16_t session, plen; + struct pppoe_softc *sc; +#if PPP_DEBUG + const char *err_msg = NULL; +#endif /* PPP_DEBUG */ + u8_t *ac_cookie; + u16_t ac_cookie_len; +#ifdef PPPOE_SERVER + u8_t *hunique; + size_t hunique_len; +#endif + struct pppoehdr *ph; + struct pppoetag pt; + int err; + struct eth_hdr *ethhdr; + + /* don't do anything if there is not a single PPPoE instance */ + if (pppoe_softc_list == NULL) { + pbuf_free(pb); + return; + } + + pb = pbuf_coalesce(pb, PBUF_RAW); + + ethhdr = (struct eth_hdr *)pb->payload; + + ac_cookie = NULL; + ac_cookie_len = 0; +#ifdef PPPOE_SERVER + hunique = NULL; + hunique_len = 0; +#endif + session = 0; + off = sizeof(struct eth_hdr) + sizeof(struct pppoehdr); + if (pb->len < off) { + PPPDEBUG(LOG_DEBUG, ("pppoe: packet too short: %d\n", pb->len)); + goto done; + } + + ph = (struct pppoehdr *) (ethhdr + 1); + if (ph->vertype != PPPOE_VERTYPE) { + PPPDEBUG(LOG_DEBUG, ("pppoe: unknown version/type packet: 0x%x\n", ph->vertype)); + goto done; + } + session = lwip_ntohs(ph->session); + plen = lwip_ntohs(ph->plen); + + if (plen > (pb->len - off)) { + PPPDEBUG(LOG_DEBUG, ("pppoe: packet content does not fit: data available = %d, packet size = %u\n", + pb->len - off, plen)); + goto done; + } + if(pb->tot_len == pb->len) { + u16_t framelen = off + plen; + if (framelen < pb->len) { + /* ignore trailing garbage */ + pb->tot_len = pb->len = framelen; + } + } + tag = 0; + len = 0; + sc = NULL; + while (off + sizeof(pt) <= pb->len) { + MEMCPY(&pt, (u8_t*)pb->payload + off, sizeof(pt)); + tag = lwip_ntohs(pt.tag); + len = lwip_ntohs(pt.len); + if (off + sizeof(pt) + len > pb->len) { + PPPDEBUG(LOG_DEBUG, ("pppoe: tag 0x%x len 0x%x is too long\n", tag, len)); + goto done; + } + switch (tag) { + case PPPOE_TAG_EOL: + goto breakbreak; + case PPPOE_TAG_SNAME: + break; /* ignored */ + case PPPOE_TAG_ACNAME: + break; /* ignored */ + case PPPOE_TAG_HUNIQUE: + if (sc != NULL) { + break; + } +#ifdef PPPOE_SERVER + hunique = (u8_t*)pb->payload + off + sizeof(pt); + hunique_len = len; +#endif + sc = pppoe_find_softc_by_hunique((u8_t*)pb->payload + off + sizeof(pt), len, netif); + break; + case PPPOE_TAG_ACCOOKIE: + if (ac_cookie == NULL) { + if (len > PPPOE_MAX_AC_COOKIE_LEN) { + PPPDEBUG(LOG_DEBUG, ("pppoe: AC cookie is too long: len = %d, max = %d\n", len, PPPOE_MAX_AC_COOKIE_LEN)); + goto done; + } + ac_cookie = (u8_t*)pb->payload + off + sizeof(pt); + ac_cookie_len = len; + } + break; +#if PPP_DEBUG + case PPPOE_TAG_SNAME_ERR: + err_msg = "SERVICE NAME ERROR"; + break; + case PPPOE_TAG_ACSYS_ERR: + err_msg = "AC SYSTEM ERROR"; + break; + case PPPOE_TAG_GENERIC_ERR: + err_msg = "GENERIC ERROR"; + break; +#endif /* PPP_DEBUG */ + default: + break; + } +#if PPP_DEBUG + if (err_msg != NULL) { + char error_tmp[PPPOE_ERRORSTRING_LEN]; + u16_t error_len = LWIP_MIN(len, sizeof(error_tmp)-1); + strncpy(error_tmp, (char*)pb->payload + off + sizeof(pt), error_len); + error_tmp[error_len] = '\0'; + if (sc) { + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": %s: %s\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err_msg, error_tmp)); + } else { + PPPDEBUG(LOG_DEBUG, ("pppoe: %s: %s\n", err_msg, error_tmp)); + } + } +#endif /* PPP_DEBUG */ + off += sizeof(pt) + len; + } + +breakbreak:; + switch (ph->code) { + case PPPOE_CODE_PADI: +#ifdef PPPOE_SERVER + /* + * got service name, concentrator name, and/or host unique. + * ignore if we have no interfaces with IFF_PASSIVE|IFF_UP. + */ + if (LIST_EMPTY(&pppoe_softc_list)) { + goto done; + } + LIST_FOREACH(sc, &pppoe_softc_list, sc_list) { + if (!(sc->sc_sppp.pp_if.if_flags & IFF_UP)) { + continue; + } + if (!(sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE)) { + continue; + } + if (sc->sc_state == PPPOE_STATE_INITIAL) { + break; + } + } + if (sc == NULL) { + /* PPPDEBUG(LOG_DEBUG, ("pppoe: free passive interface is not found\n")); */ + goto done; + } + if (hunique) { + if (sc->sc_hunique) { + mem_free(sc->sc_hunique); + } + sc->sc_hunique = mem_malloc(hunique_len); + if (sc->sc_hunique == NULL) { + goto done; + } + sc->sc_hunique_len = hunique_len; + MEMCPY(sc->sc_hunique, hunique, hunique_len); + } + MEMCPY(&sc->sc_dest, eh->ether_shost, sizeof sc->sc_dest); + sc->sc_state = PPPOE_STATE_PADO_SENT; + pppoe_send_pado(sc); + break; +#endif /* PPPOE_SERVER */ + case PPPOE_CODE_PADR: +#ifdef PPPOE_SERVER + /* + * get sc from ac_cookie if IFF_PASSIVE + */ + if (ac_cookie == NULL) { + /* be quiet if there is not a single pppoe instance */ + PPPDEBUG(LOG_DEBUG, ("pppoe: received PADR but not includes ac_cookie\n")); + goto done; + } + sc = pppoe_find_softc_by_hunique(ac_cookie, ac_cookie_len, netif); + if (sc == NULL) { + /* be quiet if there is not a single pppoe instance */ + if (!LIST_EMPTY(&pppoe_softc_list)) { + PPPDEBUG(LOG_DEBUG, ("pppoe: received PADR but could not find request for it\n")); + } + goto done; + } + if (sc->sc_state != PPPOE_STATE_PADO_SENT) { + PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": received unexpected PADR\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + goto done; + } + if (hunique) { + if (sc->sc_hunique) { + mem_free(sc->sc_hunique); + } + sc->sc_hunique = mem_malloc(hunique_len); + if (sc->sc_hunique == NULL) { + goto done; + } + sc->sc_hunique_len = hunique_len; + MEMCPY(sc->sc_hunique, hunique, hunique_len); + } + pppoe_send_pads(sc); + sc->sc_state = PPPOE_STATE_SESSION; + ppp_start(sc->pcb); /* notify upper layers */ + break; +#else + /* ignore, we are no access concentrator */ + goto done; +#endif /* PPPOE_SERVER */ + case PPPOE_CODE_PADO: + if (sc == NULL) { + /* be quiet if there is not a single pppoe instance */ + if (pppoe_softc_list != NULL) { + PPPDEBUG(LOG_DEBUG, ("pppoe: received PADO but could not find request for it\n")); + } + goto done; + } + if (sc->sc_state != PPPOE_STATE_PADI_SENT) { + PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": received unexpected PADO\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + goto done; + } + if (ac_cookie) { + sc->sc_ac_cookie_len = ac_cookie_len; + MEMCPY(sc->sc_ac_cookie, ac_cookie, ac_cookie_len); + } + MEMCPY(&sc->sc_dest, ethhdr->src.addr, sizeof(sc->sc_dest.addr)); + sys_untimeout(pppoe_timeout, sc); + sc->sc_padr_retried = 0; + sc->sc_state = PPPOE_STATE_PADR_SENT; + if ((err = pppoe_send_padr(sc)) != 0) { + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADR, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried), pppoe_timeout, sc); + break; + case PPPOE_CODE_PADS: + if (sc == NULL) { + goto done; + } + sc->sc_session = session; + sys_untimeout(pppoe_timeout, sc); + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": session 0x%x connected\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, session)); + sc->sc_state = PPPOE_STATE_SESSION; + ppp_start(sc->pcb); /* notify upper layers */ + break; + case PPPOE_CODE_PADT: + /* Don't disconnect here, we let the LCP Echo/Reply find the fact + * that PPP session is down. Asking the PPP stack to end the session + * require strict checking about the PPP phase to prevent endless + * disconnection loops. + */ +#if 0 /* UNUSED */ + if (sc == NULL) { /* PADT frames are rarely sent with a hunique tag, this is actually almost always true */ + goto done; + } + pppoe_clear_softc(sc, "received PADT"); +#endif /* UNUSED */ + break; + default: + if(sc) { + PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": unknown code (0x%"X16_F") session = 0x%"X16_F"\n", + sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, + (u16_t)ph->code, session)); + } else { + PPPDEBUG(LOG_DEBUG, ("pppoe: unknown code (0x%"X16_F") session = 0x%"X16_F"\n", (u16_t)ph->code, session)); + } + break; + } + +done: + pbuf_free(pb); + return; +} + +void +pppoe_data_input(struct netif *netif, struct pbuf *pb) +{ + u16_t session, plen; + struct pppoe_softc *sc; + struct pppoehdr *ph; +#ifdef PPPOE_TERM_UNKNOWN_SESSIONS + u8_t shost[ETHER_ADDR_LEN]; +#endif + +#ifdef PPPOE_TERM_UNKNOWN_SESSIONS + MEMCPY(shost, ((struct eth_hdr *)pb->payload)->src.addr, sizeof(shost)); +#endif + if (pbuf_remove_header(pb, sizeof(struct eth_hdr)) != 0) { + /* bail out */ + PPPDEBUG(LOG_ERR, ("pppoe_data_input: pbuf_remove_header failed\n")); + LINK_STATS_INC(link.lenerr); + goto drop; + } + + if (pb->len < sizeof(*ph)) { + PPPDEBUG(LOG_DEBUG, ("pppoe_data_input: could not get PPPoE header\n")); + goto drop; + } + ph = (struct pppoehdr *)pb->payload; + + if (ph->vertype != PPPOE_VERTYPE) { + PPPDEBUG(LOG_DEBUG, ("pppoe (data): unknown version/type packet: 0x%x\n", ph->vertype)); + goto drop; + } + if (ph->code != 0) { + goto drop; + } + + session = lwip_ntohs(ph->session); + sc = pppoe_find_softc_by_session(session, netif); + if (sc == NULL) { +#ifdef PPPOE_TERM_UNKNOWN_SESSIONS + PPPDEBUG(LOG_DEBUG, ("pppoe: input for unknown session 0x%x, sending PADT\n", session)); + pppoe_send_padt(netif, session, shost); +#endif + goto drop; + } + + plen = lwip_ntohs(ph->plen); + + if (pbuf_remove_header(pb, PPPOE_HEADERLEN) != 0) { + /* bail out */ + PPPDEBUG(LOG_ERR, ("pppoe_data_input: pbuf_remove_header PPPOE_HEADERLEN failed\n")); + LINK_STATS_INC(link.lenerr); + goto drop; + } + + PPPDEBUG(LOG_DEBUG, ("pppoe_data_input: %c%c%"U16_F": pkthdr.len=%d, pppoe.len=%d\n", + sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, + pb->len, plen)); + + if (pb->tot_len < plen) { + goto drop; + } + + /* Dispatch the packet thereby consuming it. */ + ppp_input(sc->pcb, pb); + return; + +drop: + pbuf_free(pb); +} + +static err_t +pppoe_output(struct pppoe_softc *sc, struct pbuf *pb) +{ + struct eth_hdr *ethhdr; + u16_t etype; + err_t res; + + /* make room for Ethernet header - should not fail */ + if (pbuf_add_header(pb, sizeof(struct eth_hdr)) != 0) { + /* bail out */ + PPPDEBUG(LOG_ERR, ("pppoe: %c%c%"U16_F": pppoe_output: could not allocate room for Ethernet header\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + LINK_STATS_INC(link.lenerr); + pbuf_free(pb); + return ERR_BUF; + } + ethhdr = (struct eth_hdr *)pb->payload; + etype = sc->sc_state == PPPOE_STATE_SESSION ? ETHTYPE_PPPOE : ETHTYPE_PPPOEDISC; + ethhdr->type = lwip_htons(etype); + MEMCPY(ðhdr->dest.addr, &sc->sc_dest.addr, sizeof(ethhdr->dest.addr)); + MEMCPY(ðhdr->src.addr, &sc->sc_ethif->hwaddr, sizeof(ethhdr->src.addr)); + + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F" (%x) state=%d, session=0x%x output -> %02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F":%02"X16_F", len=%d\n", + sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, etype, + sc->sc_state, sc->sc_session, + sc->sc_dest.addr[0], sc->sc_dest.addr[1], sc->sc_dest.addr[2], sc->sc_dest.addr[3], sc->sc_dest.addr[4], sc->sc_dest.addr[5], + pb->tot_len)); + + res = sc->sc_ethif->linkoutput(sc->sc_ethif, pb); + + pbuf_free(pb); + + return res; +} + +static err_t +pppoe_send_padi(struct pppoe_softc *sc) +{ + struct pbuf *pb; + u8_t *p; + int len; +#ifdef PPPOE_TODO + int l1 = 0, l2 = 0; /* XXX: gcc */ +#endif /* PPPOE_TODO */ + + /* calculate length of frame (excluding ethernet header + pppoe header) */ + len = 2 + 2 + 2 + 2 + sizeof sc; /* service name tag is required, host unique is send too */ +#ifdef PPPOE_TODO + if (sc->sc_service_name != NULL) { + l1 = (int)strlen(sc->sc_service_name); + len += l1; + } + if (sc->sc_concentrator_name != NULL) { + l2 = (int)strlen(sc->sc_concentrator_name); + len += 2 + 2 + l2; + } +#endif /* PPPOE_TODO */ + LWIP_ASSERT("sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff", + sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff); + + /* allocate a buffer */ + pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); + if (!pb) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + p = (u8_t*)pb->payload; + /* fill in pkt */ + PPPOE_ADD_HEADER(p, PPPOE_CODE_PADI, 0, (u16_t)len); + PPPOE_ADD_16(p, PPPOE_TAG_SNAME); +#ifdef PPPOE_TODO + if (sc->sc_service_name != NULL) { + PPPOE_ADD_16(p, l1); + MEMCPY(p, sc->sc_service_name, l1); + p += l1; + } else +#endif /* PPPOE_TODO */ + { + PPPOE_ADD_16(p, 0); + } +#ifdef PPPOE_TODO + if (sc->sc_concentrator_name != NULL) { + PPPOE_ADD_16(p, PPPOE_TAG_ACNAME); + PPPOE_ADD_16(p, l2); + MEMCPY(p, sc->sc_concentrator_name, l2); + p += l2; + } +#endif /* PPPOE_TODO */ + PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); + PPPOE_ADD_16(p, sizeof(sc)); + MEMCPY(p, &sc, sizeof sc); + + /* send pkt */ + return pppoe_output(sc, pb); +} + +static void +pppoe_timeout(void *arg) +{ + u32_t retry_wait; + int err; + struct pppoe_softc *sc = (struct pppoe_softc*)arg; + + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": timeout\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + + switch (sc->sc_state) { + case PPPOE_STATE_PADI_SENT: + /* + * We have two basic ways of retrying: + * - Quick retry mode: try a few times in short sequence + * - Slow retry mode: we already had a connection successfully + * established and will try infinitely (without user + * intervention) + * We only enter slow retry mode if IFF_LINK1 (aka autodial) + * is not set. + */ + if (sc->sc_padi_retried < 0xff) { + sc->sc_padi_retried++; + } + if (!sc->pcb->settings.persist && sc->sc_padi_retried >= PPPOE_DISC_MAXPADI) { +#if 0 + if ((sc->sc_sppp.pp_if.if_flags & IFF_LINK1) == 0) { + /* slow retry mode */ + retry_wait = PPPOE_SLOW_RETRY; + } else +#endif + { + pppoe_abort_connect(sc); + return; + } + } + /* initialize for quick retry mode */ + retry_wait = LWIP_MIN(PPPOE_DISC_TIMEOUT * sc->sc_padi_retried, PPPOE_SLOW_RETRY); + if ((err = pppoe_send_padi(sc)) != 0) { + sc->sc_padi_retried--; + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to transmit PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_timeout(retry_wait, pppoe_timeout, sc); + break; + + case PPPOE_STATE_PADR_SENT: + sc->sc_padr_retried++; + if (sc->sc_padr_retried >= PPPOE_DISC_MAXPADR) { + MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest)); + sc->sc_state = PPPOE_STATE_PADI_SENT; + sc->sc_padr_retried = 0; + if ((err = pppoe_send_padi(sc)) != 0) { + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padi_retried), pppoe_timeout, sc); + return; + } + if ((err = pppoe_send_padr(sc)) != 0) { + sc->sc_padr_retried--; + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADR, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_timeout(PPPOE_DISC_TIMEOUT * (1 + sc->sc_padr_retried), pppoe_timeout, sc); + break; + default: + return; /* all done, work in peace */ + } +} + +/* Start a connection (i.e. initiate discovery phase) */ +static void +pppoe_connect(ppp_pcb *ppp, void *ctx) +{ + err_t err; + struct pppoe_softc *sc = (struct pppoe_softc *)ctx; + lcp_options *lcp_wo; + lcp_options *lcp_ao; +#if PPP_IPV4_SUPPORT && VJ_SUPPORT + ipcp_options *ipcp_wo; + ipcp_options *ipcp_ao; +#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ + + sc->sc_session = 0; + sc->sc_ac_cookie_len = 0; + sc->sc_padi_retried = 0; + sc->sc_padr_retried = 0; + /* changed to real address later */ + MEMCPY(&sc->sc_dest, ethbroadcast.addr, sizeof(sc->sc_dest)); +#ifdef PPPOE_SERVER + /* wait PADI if IFF_PASSIVE */ + if ((sc->sc_sppp.pp_if.if_flags & IFF_PASSIVE)) { + return 0; + } +#endif + + lcp_wo = &ppp->lcp_wantoptions; + lcp_wo->mru = sc->sc_ethif->mtu-PPPOE_HEADERLEN-2; /* two byte PPP protocol discriminator, then IP data */ + lcp_wo->neg_asyncmap = 0; + lcp_wo->neg_pcompression = 0; + lcp_wo->neg_accompression = 0; + lcp_wo->passive = 0; + lcp_wo->silent = 0; + + lcp_ao = &ppp->lcp_allowoptions; + lcp_ao->mru = sc->sc_ethif->mtu-PPPOE_HEADERLEN-2; /* two byte PPP protocol discriminator, then IP data */ + lcp_ao->neg_asyncmap = 0; + lcp_ao->neg_pcompression = 0; + lcp_ao->neg_accompression = 0; + +#if PPP_IPV4_SUPPORT && VJ_SUPPORT + ipcp_wo = &ppp->ipcp_wantoptions; + ipcp_wo->neg_vj = 0; + ipcp_wo->old_vj = 0; + + ipcp_ao = &ppp->ipcp_allowoptions; + ipcp_ao->neg_vj = 0; + ipcp_ao->old_vj = 0; +#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ + + /* save state, in case we fail to send PADI */ + sc->sc_state = PPPOE_STATE_PADI_SENT; + if ((err = pppoe_send_padi(sc)) != 0) { + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": failed to send PADI, error=%d\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, err)); + } + sys_timeout(PPPOE_DISC_TIMEOUT, pppoe_timeout, sc); +} + +/* disconnect */ +static void +pppoe_disconnect(ppp_pcb *ppp, void *ctx) +{ + struct pppoe_softc *sc = (struct pppoe_softc *)ctx; + + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": disconnecting\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + if (sc->sc_state == PPPOE_STATE_SESSION) { + pppoe_send_padt(sc->sc_ethif, sc->sc_session, (const u8_t *)&sc->sc_dest); + } + + /* stop any timer, disconnect can be called while initiating is in progress */ + sys_untimeout(pppoe_timeout, sc); + sc->sc_state = PPPOE_STATE_INITIAL; +#ifdef PPPOE_SERVER + if (sc->sc_hunique) { + mem_free(sc->sc_hunique); + sc->sc_hunique = NULL; /* probably not necessary, if state is initial we shouldn't have to access hunique anyway */ + } + sc->sc_hunique_len = 0; /* probably not necessary, if state is initial we shouldn't have to access hunique anyway */ +#endif + ppp_link_end(ppp); /* notify upper layers */ + return; +} + +/* Connection attempt aborted */ +static void +pppoe_abort_connect(struct pppoe_softc *sc) +{ + PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": could not establish connection\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + sc->sc_state = PPPOE_STATE_INITIAL; + ppp_link_failed(sc->pcb); /* notify upper layers */ +} + +/* Send a PADR packet */ +static err_t +pppoe_send_padr(struct pppoe_softc *sc) +{ + struct pbuf *pb; + u8_t *p; + size_t len; +#ifdef PPPOE_TODO + size_t l1 = 0; /* XXX: gcc */ +#endif /* PPPOE_TODO */ + + len = 2 + 2 + 2 + 2 + sizeof(sc); /* service name, host unique */ +#ifdef PPPOE_TODO + if (sc->sc_service_name != NULL) { /* service name tag maybe empty */ + l1 = strlen(sc->sc_service_name); + len += l1; + } +#endif /* PPPOE_TODO */ + if (sc->sc_ac_cookie_len > 0) { + len += 2 + 2 + sc->sc_ac_cookie_len; /* AC cookie */ + } + LWIP_ASSERT("sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff", + sizeof(struct eth_hdr) + PPPOE_HEADERLEN + len <= 0xffff); + pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); + if (!pb) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + p = (u8_t*)pb->payload; + PPPOE_ADD_HEADER(p, PPPOE_CODE_PADR, 0, len); + PPPOE_ADD_16(p, PPPOE_TAG_SNAME); +#ifdef PPPOE_TODO + if (sc->sc_service_name != NULL) { + PPPOE_ADD_16(p, l1); + MEMCPY(p, sc->sc_service_name, l1); + p += l1; + } else +#endif /* PPPOE_TODO */ + { + PPPOE_ADD_16(p, 0); + } + if (sc->sc_ac_cookie_len > 0) { + PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE); + PPPOE_ADD_16(p, sc->sc_ac_cookie_len); + MEMCPY(p, sc->sc_ac_cookie, sc->sc_ac_cookie_len); + p += sc->sc_ac_cookie_len; + } + PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); + PPPOE_ADD_16(p, sizeof(sc)); + MEMCPY(p, &sc, sizeof sc); + + return pppoe_output(sc, pb); +} + +/* send a PADT packet */ +static err_t +pppoe_send_padt(struct netif *outgoing_if, u_int session, const u8_t *dest) +{ + struct pbuf *pb; + struct eth_hdr *ethhdr; + err_t res; + u8_t *p; + + pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN), PBUF_RAM); + if (!pb) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + if (pbuf_add_header(pb, sizeof(struct eth_hdr))) { + PPPDEBUG(LOG_ERR, ("pppoe: pppoe_send_padt: could not allocate room for PPPoE header\n")); + LINK_STATS_INC(link.lenerr); + pbuf_free(pb); + return ERR_BUF; + } + ethhdr = (struct eth_hdr *)pb->payload; + ethhdr->type = PP_HTONS(ETHTYPE_PPPOEDISC); + MEMCPY(ðhdr->dest.addr, dest, sizeof(ethhdr->dest.addr)); + MEMCPY(ðhdr->src.addr, &outgoing_if->hwaddr, sizeof(ethhdr->src.addr)); + + p = (u8_t*)(ethhdr + 1); + PPPOE_ADD_HEADER(p, PPPOE_CODE_PADT, session, 0); + + res = outgoing_if->linkoutput(outgoing_if, pb); + + pbuf_free(pb); + + return res; +} + +#ifdef PPPOE_SERVER +static err_t +pppoe_send_pado(struct pppoe_softc *sc) +{ + struct pbuf *pb; + u8_t *p; + size_t len; + + /* calc length */ + len = 0; + /* include ac_cookie */ + len += 2 + 2 + sizeof(sc); + /* include hunique */ + len += 2 + 2 + sc->sc_hunique_len; + pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); + if (!pb) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + p = (u8_t*)pb->payload; + PPPOE_ADD_HEADER(p, PPPOE_CODE_PADO, 0, len); + PPPOE_ADD_16(p, PPPOE_TAG_ACCOOKIE); + PPPOE_ADD_16(p, sizeof(sc)); + MEMCPY(p, &sc, sizeof(sc)); + p += sizeof(sc); + PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); + PPPOE_ADD_16(p, sc->sc_hunique_len); + MEMCPY(p, sc->sc_hunique, sc->sc_hunique_len); + return pppoe_output(sc, pb); +} + +static err_t +pppoe_send_pads(struct pppoe_softc *sc) +{ + struct pbuf *pb; + u8_t *p; + size_t len, l1 = 0; /* XXX: gcc */ + + sc->sc_session = mono_time.tv_sec % 0xff + 1; + /* calc length */ + len = 0; + /* include hunique */ + len += 2 + 2 + 2 + 2 + sc->sc_hunique_len; /* service name, host unique*/ + if (sc->sc_service_name != NULL) { /* service name tag maybe empty */ + l1 = strlen(sc->sc_service_name); + len += l1; + } + pb = pbuf_alloc(PBUF_LINK, (u16_t)(PPPOE_HEADERLEN + len), PBUF_RAM); + if (!pb) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + p = (u8_t*)pb->payload; + PPPOE_ADD_HEADER(p, PPPOE_CODE_PADS, sc->sc_session, len); + PPPOE_ADD_16(p, PPPOE_TAG_SNAME); + if (sc->sc_service_name != NULL) { + PPPOE_ADD_16(p, l1); + MEMCPY(p, sc->sc_service_name, l1); + p += l1; + } else { + PPPOE_ADD_16(p, 0); + } + PPPOE_ADD_16(p, PPPOE_TAG_HUNIQUE); + PPPOE_ADD_16(p, sc->sc_hunique_len); + MEMCPY(p, sc->sc_hunique, sc->sc_hunique_len); + return pppoe_output(sc, pb); +} +#endif + +static err_t +pppoe_xmit(struct pppoe_softc *sc, struct pbuf *pb) +{ + u8_t *p; + size_t len; + + len = pb->tot_len; + + /* make room for PPPoE header - should not fail */ + if (pbuf_add_header(pb, PPPOE_HEADERLEN) != 0) { + /* bail out */ + PPPDEBUG(LOG_ERR, ("pppoe: %c%c%"U16_F": pppoe_xmit: could not allocate room for PPPoE header\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + LINK_STATS_INC(link.lenerr); + pbuf_free(pb); + return ERR_BUF; + } + + p = (u8_t*)pb->payload; + PPPOE_ADD_HEADER(p, 0, sc->sc_session, len); + + return pppoe_output(sc, pb); +} + +#if 0 /*def PFIL_HOOKS*/ +static int +pppoe_ifattach_hook(void *arg, struct pbuf **mp, struct netif *ifp, int dir) +{ + struct pppoe_softc *sc; + int s; + + if (mp != (struct pbuf **)PFIL_IFNET_DETACH) { + return 0; + } + + LIST_FOREACH(sc, &pppoe_softc_list, sc_list) { + if (sc->sc_ethif != ifp) { + continue; + } + if (sc->sc_sppp.pp_if.if_flags & IFF_UP) { + sc->sc_sppp.pp_if.if_flags &= ~(IFF_UP|IFF_RUNNING); + PPPDEBUG(LOG_DEBUG, ("%c%c%"U16_F": ethernet interface detached, going down\n", + sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num)); + } + sc->sc_ethif = NULL; + pppoe_clear_softc(sc, "ethernet interface detached"); + } + + return 0; +} +#endif + +#if 0 /* UNUSED */ +static void +pppoe_clear_softc(struct pppoe_softc *sc, const char *message) +{ + LWIP_UNUSED_ARG(message); + + /* stop timer */ + sys_untimeout(pppoe_timeout, sc); + PPPDEBUG(LOG_DEBUG, ("pppoe: %c%c%"U16_F": session 0x%x terminated, %s\n", sc->sc_ethif->name[0], sc->sc_ethif->name[1], sc->sc_ethif->num, sc->sc_session, message)); + sc->sc_state = PPPOE_STATE_INITIAL; + ppp_link_end(sc->pcb); /* notify upper layers - /!\ dangerous /!\ - see pppoe_disc_input() */ +} +#endif /* UNUSED */ +#endif /* PPP_SUPPORT && PPPOE_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppol2tp.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppol2tp.c index af366d4e..4c4557fc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppol2tp.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppol2tp.c @@ -1,1159 +1,1159 @@ -/** - * @file - * Network Point to Point Protocol over Layer 2 Tunneling Protocol program file. - * - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -/* - * L2TP Support status: - * - * Supported: - * - L2TPv2 (PPP over L2TP, a.k.a. UDP tunnels) - * - LAC - * - * Not supported: - * - LNS (require PPP server support) - * - L2TPv3 ethernet pseudowires - * - L2TPv3 VLAN pseudowire - * - L2TPv3 PPP pseudowires - * - L2TPv3 IP encapsulation - * - L2TPv3 IP pseudowire - * - L2TP tunnel switching - http://tools.ietf.org/html/draft-ietf-l2tpext-tunnel-switching-08 - * - Multiple tunnels per UDP socket, as well as multiple sessions per tunnel - * - Hidden AVPs - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPPOL2TP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include "lwip/err.h" -#include "lwip/memp.h" -#include "lwip/netif.h" -#include "lwip/udp.h" -#include "lwip/snmp.h" - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/lcp.h" -#include "netif/ppp/ipcp.h" -#include "netif/ppp/pppol2tp.h" -#include "netif/ppp/pppcrypt.h" -#include "netif/ppp/magic.h" - -/* Memory pool */ -LWIP_MEMPOOL_DECLARE(PPPOL2TP_PCB, MEMP_NUM_PPPOL2TP_INTERFACES, sizeof(pppol2tp_pcb), "PPPOL2TP_PCB") - -/* callbacks called from PPP core */ -static err_t pppol2tp_write(ppp_pcb *ppp, void *ctx, struct pbuf *p); -static err_t pppol2tp_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol); -static err_t pppol2tp_destroy(ppp_pcb *ppp, void *ctx); /* Destroy a L2TP control block */ -static void pppol2tp_connect(ppp_pcb *ppp, void *ctx); /* Be a LAC, connect to a LNS. */ -static void pppol2tp_disconnect(ppp_pcb *ppp, void *ctx); /* Disconnect */ - - /* Prototypes for procedures local to this file. */ -static void pppol2tp_input(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); -static void pppol2tp_dispatch_control_packet(pppol2tp_pcb *l2tp, u16_t port, struct pbuf *p, u16_t ns, u16_t nr); -static void pppol2tp_timeout(void *arg); -static void pppol2tp_abort_connect(pppol2tp_pcb *l2tp); -static err_t pppol2tp_send_sccrq(pppol2tp_pcb *l2tp); -static err_t pppol2tp_send_scccn(pppol2tp_pcb *l2tp, u16_t ns); -static err_t pppol2tp_send_icrq(pppol2tp_pcb *l2tp, u16_t ns); -static err_t pppol2tp_send_iccn(pppol2tp_pcb *l2tp, u16_t ns); -static err_t pppol2tp_send_zlb(pppol2tp_pcb *l2tp, u16_t ns, u16_t nr); -static err_t pppol2tp_send_stopccn(pppol2tp_pcb *l2tp, u16_t ns); -static err_t pppol2tp_xmit(pppol2tp_pcb *l2tp, struct pbuf *pb); -static err_t pppol2tp_udp_send(pppol2tp_pcb *l2tp, struct pbuf *pb); - -/* Callbacks structure for PPP core */ -static const struct link_callbacks pppol2tp_callbacks = { - pppol2tp_connect, -#if PPP_SERVER - NULL, -#endif /* PPP_SERVER */ - pppol2tp_disconnect, - pppol2tp_destroy, - pppol2tp_write, - pppol2tp_netif_output, - NULL, - NULL -}; - - -/* Create a new L2TP session. */ -ppp_pcb *pppol2tp_create(struct netif *pppif, - struct netif *netif, const ip_addr_t *ipaddr, u16_t port, - const u8_t *secret, u8_t secret_len, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb) { - ppp_pcb *ppp; - pppol2tp_pcb *l2tp; - struct udp_pcb *udp; -#if !PPPOL2TP_AUTH_SUPPORT - LWIP_UNUSED_ARG(secret); - LWIP_UNUSED_ARG(secret_len); -#endif /* !PPPOL2TP_AUTH_SUPPORT */ - - if (ipaddr == NULL) { - goto ipaddr_check_failed; - } - - l2tp = (pppol2tp_pcb *)LWIP_MEMPOOL_ALLOC(PPPOL2TP_PCB); - if (l2tp == NULL) { - goto memp_malloc_l2tp_failed; - } - - udp = udp_new_ip_type(IP_GET_TYPE(ipaddr)); - if (udp == NULL) { - goto udp_new_failed; - } - udp_recv(udp, pppol2tp_input, l2tp); - - ppp = ppp_new(pppif, &pppol2tp_callbacks, l2tp, link_status_cb, ctx_cb); - if (ppp == NULL) { - goto ppp_new_failed; - } - - memset(l2tp, 0, sizeof(pppol2tp_pcb)); - l2tp->phase = PPPOL2TP_STATE_INITIAL; - l2tp->ppp = ppp; - l2tp->udp = udp; - l2tp->netif = netif; - ip_addr_copy(l2tp->remote_ip, *ipaddr); - l2tp->remote_port = port; -#if PPPOL2TP_AUTH_SUPPORT - l2tp->secret = secret; - l2tp->secret_len = secret_len; -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - return ppp; - -ppp_new_failed: - udp_remove(udp); -udp_new_failed: - LWIP_MEMPOOL_FREE(PPPOL2TP_PCB, l2tp); -memp_malloc_l2tp_failed: -ipaddr_check_failed: - return NULL; -} - -/* Called by PPP core */ -static err_t pppol2tp_write(ppp_pcb *ppp, void *ctx, struct pbuf *p) { - pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; - struct pbuf *ph; /* UDP + L2TP header */ - err_t ret; -#if MIB2_STATS - u16_t tot_len; -#else /* MIB2_STATS */ - LWIP_UNUSED_ARG(ppp); -#endif /* MIB2_STATS */ - - ph = pbuf_alloc(PBUF_TRANSPORT, (u16_t)(PPPOL2TP_OUTPUT_DATA_HEADER_LEN), PBUF_RAM); - if(!ph) { - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.proterr); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - pbuf_free(p); - return ERR_MEM; - } - - pbuf_remove_header(ph, PPPOL2TP_OUTPUT_DATA_HEADER_LEN); /* hide L2TP header */ - pbuf_cat(ph, p); -#if MIB2_STATS - tot_len = ph->tot_len; -#endif /* MIB2_STATS */ - - ret = pppol2tp_xmit(l2tp, ph); - if (ret != ERR_OK) { - LINK_STATS_INC(link.err); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - return ret; - } - - MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, (u16_t)tot_len); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); - LINK_STATS_INC(link.xmit); - return ERR_OK; -} - -/* Called by PPP core */ -static err_t pppol2tp_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol) { - pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; - struct pbuf *pb; - u8_t *pl; - err_t err; -#if MIB2_STATS - u16_t tot_len; -#else /* MIB2_STATS */ - LWIP_UNUSED_ARG(ppp); -#endif /* MIB2_STATS */ - - /* @todo: try to use pbuf_header() here! */ - pb = pbuf_alloc(PBUF_TRANSPORT, PPPOL2TP_OUTPUT_DATA_HEADER_LEN + sizeof(protocol), PBUF_RAM); - if(!pb) { - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.proterr); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - return ERR_MEM; - } - - pbuf_remove_header(pb, PPPOL2TP_OUTPUT_DATA_HEADER_LEN); - - pl = (u8_t*)pb->payload; - PUTSHORT(protocol, pl); - - pbuf_chain(pb, p); -#if MIB2_STATS - tot_len = pb->tot_len; -#endif /* MIB2_STATS */ - - if( (err = pppol2tp_xmit(l2tp, pb)) != ERR_OK) { - LINK_STATS_INC(link.err); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - return err; - } - - MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, tot_len); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); - LINK_STATS_INC(link.xmit); - return ERR_OK; -} - -/* Destroy a L2TP control block */ -static err_t pppol2tp_destroy(ppp_pcb *ppp, void *ctx) { - pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; - LWIP_UNUSED_ARG(ppp); - - sys_untimeout(pppol2tp_timeout, l2tp); - udp_remove(l2tp->udp); - LWIP_MEMPOOL_FREE(PPPOL2TP_PCB, l2tp); - return ERR_OK; -} - -/* Be a LAC, connect to a LNS. */ -static void pppol2tp_connect(ppp_pcb *ppp, void *ctx) { - err_t err; - pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; - lcp_options *lcp_wo; - lcp_options *lcp_ao; -#if PPP_IPV4_SUPPORT && VJ_SUPPORT - ipcp_options *ipcp_wo; - ipcp_options *ipcp_ao; -#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ - - l2tp->tunnel_port = l2tp->remote_port; - l2tp->our_ns = 0; - l2tp->peer_nr = 0; - l2tp->peer_ns = 0; - l2tp->source_tunnel_id = 0; - l2tp->remote_tunnel_id = 0; - l2tp->source_session_id = 0; - l2tp->remote_session_id = 0; - /* l2tp->*_retried are cleared when used */ - - lcp_wo = &ppp->lcp_wantoptions; - lcp_wo->mru = PPPOL2TP_DEFMRU; - lcp_wo->neg_asyncmap = 0; - lcp_wo->neg_pcompression = 0; - lcp_wo->neg_accompression = 0; - lcp_wo->passive = 0; - lcp_wo->silent = 0; - - lcp_ao = &ppp->lcp_allowoptions; - lcp_ao->mru = PPPOL2TP_DEFMRU; - lcp_ao->neg_asyncmap = 0; - lcp_ao->neg_pcompression = 0; - lcp_ao->neg_accompression = 0; - -#if PPP_IPV4_SUPPORT && VJ_SUPPORT - ipcp_wo = &ppp->ipcp_wantoptions; - ipcp_wo->neg_vj = 0; - ipcp_wo->old_vj = 0; - - ipcp_ao = &ppp->ipcp_allowoptions; - ipcp_ao->neg_vj = 0; - ipcp_ao->old_vj = 0; -#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ - - /* Listen to a random source port, we need to do that instead of using udp_connect() - * because the L2TP LNS might answer with its own random source port (!= 1701) - */ -#if LWIP_IPV6 - if (IP_IS_V6_VAL(l2tp->udp->local_ip)) { - udp_bind(l2tp->udp, IP6_ADDR_ANY, 0); - } else -#endif /* LWIP_IPV6 */ - udp_bind(l2tp->udp, IP_ADDR_ANY, 0); - -#if PPPOL2TP_AUTH_SUPPORT - /* Generate random vector */ - if (l2tp->secret != NULL) { - magic_random_bytes(l2tp->secret_rv, sizeof(l2tp->secret_rv)); - } -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - do { - l2tp->remote_tunnel_id = magic(); - } while(l2tp->remote_tunnel_id == 0); - /* save state, in case we fail to send SCCRQ */ - l2tp->sccrq_retried = 0; - l2tp->phase = PPPOL2TP_STATE_SCCRQ_SENT; - if ((err = pppol2tp_send_sccrq(l2tp)) != 0) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCRQ, error=%d\n", err)); - } - sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); -} - -/* Disconnect */ -static void pppol2tp_disconnect(ppp_pcb *ppp, void *ctx) { - pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; - - l2tp->our_ns++; - pppol2tp_send_stopccn(l2tp, l2tp->our_ns); - - /* stop any timer, disconnect can be called while initiating is in progress */ - sys_untimeout(pppol2tp_timeout, l2tp); - l2tp->phase = PPPOL2TP_STATE_INITIAL; - ppp_link_end(ppp); /* notify upper layers */ -} - -/* UDP Callback for incoming IPv4 L2TP frames */ -static void pppol2tp_input(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) { - pppol2tp_pcb *l2tp = (pppol2tp_pcb*)arg; - u16_t hflags, hlen, len=0, tunnel_id=0, session_id=0, ns=0, nr=0, offset=0; - u8_t *inp; - LWIP_UNUSED_ARG(pcb); - - /* we can't unbound a UDP pcb, thus we can still receive UDP frames after the link is closed */ - if (l2tp->phase < PPPOL2TP_STATE_SCCRQ_SENT) { - goto free_and_return; - } - - if (!ip_addr_cmp(&l2tp->remote_ip, addr)) { - goto free_and_return; - } - - /* discard packet if port mismatch, but only if we received a SCCRP */ - if (l2tp->phase > PPPOL2TP_STATE_SCCRQ_SENT && l2tp->tunnel_port != port) { - goto free_and_return; - } - - /* printf("-----------\nL2TP INPUT, %d\n", p->len); */ - - /* L2TP header */ - if (p->len < sizeof(hflags) + sizeof(tunnel_id) + sizeof(session_id) ) { - goto packet_too_short; - } - - inp = (u8_t*)p->payload; - GETSHORT(hflags, inp); - - if (hflags & PPPOL2TP_HEADERFLAG_CONTROL) { - /* check mandatory flags for a control packet */ - if ( (hflags & PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY) != PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY ) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: mandatory header flags for control packet not set\n")); - goto free_and_return; - } - /* check forbidden flags for a control packet */ - if (hflags & PPPOL2TP_HEADERFLAG_CONTROL_FORBIDDEN) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: forbidden header flags for control packet found\n")); - goto free_and_return; - } - } else { - /* check mandatory flags for a data packet */ - if ( (hflags & PPPOL2TP_HEADERFLAG_DATA_MANDATORY) != PPPOL2TP_HEADERFLAG_DATA_MANDATORY) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: mandatory header flags for data packet not set\n")); - goto free_and_return; - } - } - - /* Expected header size */ - hlen = sizeof(hflags) + sizeof(tunnel_id) + sizeof(session_id); - if (hflags & PPPOL2TP_HEADERFLAG_LENGTH) { - hlen += sizeof(len); - } - if (hflags & PPPOL2TP_HEADERFLAG_SEQUENCE) { - hlen += sizeof(ns) + sizeof(nr); - } - if (hflags & PPPOL2TP_HEADERFLAG_OFFSET) { - hlen += sizeof(offset); - } - if (p->len < hlen) { - goto packet_too_short; - } - - if (hflags & PPPOL2TP_HEADERFLAG_LENGTH) { - GETSHORT(len, inp); - if (p->len < len || len < hlen) { - goto packet_too_short; - } - } - GETSHORT(tunnel_id, inp); - GETSHORT(session_id, inp); - if (hflags & PPPOL2TP_HEADERFLAG_SEQUENCE) { - GETSHORT(ns, inp); - GETSHORT(nr, inp); - } - if (hflags & PPPOL2TP_HEADERFLAG_OFFSET) { - GETSHORT(offset, inp) - if (offset > 4096) { /* don't be fooled with large offset which might overflow hlen */ - PPPDEBUG(LOG_DEBUG, ("pppol2tp: strange packet received, offset=%d\n", offset)); - goto free_and_return; - } - hlen += offset; - if (p->len < hlen) { - goto packet_too_short; - } - INCPTR(offset, inp); - } - - /* printf("HLEN = %d\n", hlen); */ - - /* skip L2TP header */ - if (pbuf_remove_header(p, hlen) != 0) { - goto free_and_return; - } - - /* printf("LEN=%d, TUNNEL_ID=%d, SESSION_ID=%d, NS=%d, NR=%d, OFFSET=%d\n", len, tunnel_id, session_id, ns, nr, offset); */ - PPPDEBUG(LOG_DEBUG, ("pppol2tp: input packet, len=%"U16_F", tunnel=%"U16_F", session=%"U16_F", ns=%"U16_F", nr=%"U16_F"\n", - len, tunnel_id, session_id, ns, nr)); - - /* Control packet */ - if (hflags & PPPOL2TP_HEADERFLAG_CONTROL) { - pppol2tp_dispatch_control_packet(l2tp, port, p, ns, nr); - goto free_and_return; - } - - /* Data packet */ - if(l2tp->phase != PPPOL2TP_STATE_DATA) { - goto free_and_return; - } - if(tunnel_id != l2tp->remote_tunnel_id) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: tunnel ID mismatch, assigned=%d, received=%d\n", l2tp->remote_tunnel_id, tunnel_id)); - goto free_and_return; - } - if(session_id != l2tp->remote_session_id) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: session ID mismatch, assigned=%d, received=%d\n", l2tp->remote_session_id, session_id)); - goto free_and_return; - } - /* - * skip address & flags if necessary - * - * RFC 2661 does not specify whether the PPP frame in the L2TP payload should - * have a HDLC header or not. We handle both cases for compatibility. - */ - if (p->len >= 2) { - GETSHORT(hflags, inp); - if (hflags == 0xff03) { - pbuf_remove_header(p, 2); - } - } - /* Dispatch the packet thereby consuming it. */ - ppp_input(l2tp->ppp, p); - return; - -packet_too_short: - PPPDEBUG(LOG_DEBUG, ("pppol2tp: packet too short: %d\n", p->len)); -free_and_return: - pbuf_free(p); -} - -/* L2TP Control packet entry point */ -static void pppol2tp_dispatch_control_packet(pppol2tp_pcb *l2tp, u16_t port, struct pbuf *p, u16_t ns, u16_t nr) { - u8_t *inp; - u16_t avplen, avpflags, vendorid, attributetype, messagetype=0; - err_t err; -#if PPPOL2TP_AUTH_SUPPORT - lwip_md5_context md5_ctx; - u8_t md5_hash[16]; - u8_t challenge_id = 0; -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - /* printf("L2TP CTRL INPUT, ns=%d, nr=%d, len=%d\n", ns, nr, p->len); */ - - /* Drop unexpected packet */ - if (ns != l2tp->peer_ns) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: drop unexpected packet: received NS=%d, expected NS=%d\n", ns, l2tp->peer_ns)); - /* - * In order to ensure that all messages are acknowledged properly - * (particularly in the case of a lost ZLB ACK message), receipt - * of duplicate messages MUST be acknowledged. - * - * In this very special case we Ack a packet we previously received. - * Therefore our NS is the NR we just received. And our NR is the - * NS we just received plus one. - */ - if ((s16_t)(ns - l2tp->peer_ns) < 0) { - pppol2tp_send_zlb(l2tp, nr, ns+1); - } - return; - } - - l2tp->peer_nr = nr; - - /* Handle the special case of the ICCN acknowledge */ - if (l2tp->phase == PPPOL2TP_STATE_ICCN_SENT && (s16_t)(l2tp->peer_nr - l2tp->our_ns) > 0) { - l2tp->phase = PPPOL2TP_STATE_DATA; - sys_untimeout(pppol2tp_timeout, l2tp); - ppp_start(l2tp->ppp); /* notify upper layers */ - } - - /* ZLB packets */ - if (p->tot_len == 0) { - return; - } - /* A ZLB packet does not consume a NS slot thus we don't record the NS value for ZLB packets */ - l2tp->peer_ns = ns+1; - - p = pbuf_coalesce(p, PBUF_RAW); - inp = (u8_t*)p->payload; - /* Decode AVPs */ - while (p->len > 0) { - if (p->len < sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype) ) { - goto packet_too_short; - } - GETSHORT(avpflags, inp); - avplen = avpflags & PPPOL2TP_AVPHEADERFLAG_LENGTHMASK; - /* printf("AVPLEN = %d\n", avplen); */ - if (p->len < avplen || avplen < sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype)) { - goto packet_too_short; - } - GETSHORT(vendorid, inp); - GETSHORT(attributetype, inp); - avplen -= sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype); - - /* Message type must be the first AVP */ - if (messagetype == 0) { - if (attributetype != 0 || vendorid != 0 || avplen != sizeof(messagetype) ) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: message type must be the first AVP\n")); - return; - } - GETSHORT(messagetype, inp); - /* printf("Message type = %d\n", messagetype); */ - switch(messagetype) { - /* Start Control Connection Reply */ - case PPPOL2TP_MESSAGETYPE_SCCRP: - /* Only accept SCCRP packet if we sent a SCCRQ */ - if (l2tp->phase != PPPOL2TP_STATE_SCCRQ_SENT) { - goto send_zlb; - } - break; - /* Incoming Call Reply */ - case PPPOL2TP_MESSAGETYPE_ICRP: - /* Only accept ICRP packet if we sent a IRCQ */ - if (l2tp->phase != PPPOL2TP_STATE_ICRQ_SENT) { - goto send_zlb; - } - break; - /* Stop Control Connection Notification */ - case PPPOL2TP_MESSAGETYPE_STOPCCN: - pppol2tp_send_zlb(l2tp, l2tp->our_ns+1, l2tp->peer_ns); /* Ack the StopCCN before we switch to down state */ - if (l2tp->phase < PPPOL2TP_STATE_DATA) { - pppol2tp_abort_connect(l2tp); - } else if (l2tp->phase == PPPOL2TP_STATE_DATA) { - /* Don't disconnect here, we let the LCP Echo/Reply find the fact - * that PPP session is down. Asking the PPP stack to end the session - * require strict checking about the PPP phase to prevent endless - * disconnection loops. - */ - } - return; - default: - break; - } - goto nextavp; - } - - /* Skip proprietary L2TP extensions */ - if (vendorid != 0) { - goto skipavp; - } - - switch (messagetype) { - /* Start Control Connection Reply */ - case PPPOL2TP_MESSAGETYPE_SCCRP: - switch (attributetype) { - case PPPOL2TP_AVPTYPE_TUNNELID: - if (avplen != sizeof(l2tp->source_tunnel_id) ) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: AVP Assign tunnel ID length check failed\n")); - return; - } - GETSHORT(l2tp->source_tunnel_id, inp); - PPPDEBUG(LOG_DEBUG, ("pppol2tp: Assigned tunnel ID %"U16_F"\n", l2tp->source_tunnel_id)); - goto nextavp; -#if PPPOL2TP_AUTH_SUPPORT - case PPPOL2TP_AVPTYPE_CHALLENGE: - if (avplen == 0) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: Challenge length check failed\n")); - return; - } - if (l2tp->secret == NULL) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: Received challenge from peer and no secret key available\n")); - pppol2tp_abort_connect(l2tp); - return; - } - /* Generate hash of ID, secret, challenge */ - lwip_md5_init(&md5_ctx); - lwip_md5_starts(&md5_ctx); - challenge_id = PPPOL2TP_MESSAGETYPE_SCCCN; - lwip_md5_update(&md5_ctx, &challenge_id, 1); - lwip_md5_update(&md5_ctx, l2tp->secret, l2tp->secret_len); - lwip_md5_update(&md5_ctx, inp, avplen); - lwip_md5_finish(&md5_ctx, l2tp->challenge_hash); - lwip_md5_free(&md5_ctx); - l2tp->send_challenge = 1; - goto skipavp; - case PPPOL2TP_AVPTYPE_CHALLENGERESPONSE: - if (avplen != PPPOL2TP_AVPTYPE_CHALLENGERESPONSE_SIZE) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: AVP Challenge Response length check failed\n")); - return; - } - /* Generate hash of ID, secret, challenge */ - lwip_md5_init(&md5_ctx); - lwip_md5_starts(&md5_ctx); - challenge_id = PPPOL2TP_MESSAGETYPE_SCCRP; - lwip_md5_update(&md5_ctx, &challenge_id, 1); - lwip_md5_update(&md5_ctx, l2tp->secret, l2tp->secret_len); - lwip_md5_update(&md5_ctx, l2tp->secret_rv, sizeof(l2tp->secret_rv)); - lwip_md5_finish(&md5_ctx, md5_hash); - lwip_md5_free(&md5_ctx); - if ( memcmp(inp, md5_hash, sizeof(md5_hash)) ) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: Received challenge response from peer and secret key do not match\n")); - pppol2tp_abort_connect(l2tp); - return; - } - goto skipavp; -#endif /* PPPOL2TP_AUTH_SUPPORT */ - default: - break; - } - break; - /* Incoming Call Reply */ - case PPPOL2TP_MESSAGETYPE_ICRP: - switch (attributetype) { - case PPPOL2TP_AVPTYPE_SESSIONID: - if (avplen != sizeof(l2tp->source_session_id) ) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: AVP Assign session ID length check failed\n")); - return; - } - GETSHORT(l2tp->source_session_id, inp); - PPPDEBUG(LOG_DEBUG, ("pppol2tp: Assigned session ID %"U16_F"\n", l2tp->source_session_id)); - goto nextavp; - default: - break; - } - break; - default: - break; - } - -skipavp: - INCPTR(avplen, inp); -nextavp: - /* printf("AVP Found, vendor=%d, attribute=%d, len=%d\n", vendorid, attributetype, avplen); */ - /* next AVP */ - if (pbuf_remove_header(p, avplen + sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype)) != 0) { - return; - } - } - - switch(messagetype) { - /* Start Control Connection Reply */ - case PPPOL2TP_MESSAGETYPE_SCCRP: - do { - l2tp->remote_session_id = magic(); - } while(l2tp->remote_session_id == 0); - l2tp->tunnel_port = port; /* LNS server might have chosen its own local port */ - l2tp->icrq_retried = 0; - l2tp->phase = PPPOL2TP_STATE_ICRQ_SENT; - l2tp->our_ns++; - if ((err = pppol2tp_send_scccn(l2tp, l2tp->our_ns)) != 0) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCCN, error=%d\n", err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - l2tp->our_ns++; - if ((err = pppol2tp_send_icrq(l2tp, l2tp->our_ns)) != 0) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICRQ, error=%d\n", err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_untimeout(pppol2tp_timeout, l2tp); - sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); - break; - /* Incoming Call Reply */ - case PPPOL2TP_MESSAGETYPE_ICRP: - l2tp->iccn_retried = 0; - l2tp->phase = PPPOL2TP_STATE_ICCN_SENT; - l2tp->our_ns++; - if ((err = pppol2tp_send_iccn(l2tp, l2tp->our_ns)) != 0) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICCN, error=%d\n", err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_untimeout(pppol2tp_timeout, l2tp); - sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); - break; - /* Unhandled packet, send ZLB ACK */ - default: - goto send_zlb; - } - return; - -send_zlb: - pppol2tp_send_zlb(l2tp, l2tp->our_ns+1, l2tp->peer_ns); - return; -packet_too_short: - PPPDEBUG(LOG_DEBUG, ("pppol2tp: packet too short: %d\n", p->len)); -} - -/* L2TP Timeout handler */ -static void pppol2tp_timeout(void *arg) { - pppol2tp_pcb *l2tp = (pppol2tp_pcb*)arg; - err_t err; - u32_t retry_wait; - - PPPDEBUG(LOG_DEBUG, ("pppol2tp: timeout\n")); - - switch (l2tp->phase) { - case PPPOL2TP_STATE_SCCRQ_SENT: - /* backoff wait */ - if (l2tp->sccrq_retried < 0xff) { - l2tp->sccrq_retried++; - } - if (!l2tp->ppp->settings.persist && l2tp->sccrq_retried >= PPPOL2TP_MAXSCCRQ) { - pppol2tp_abort_connect(l2tp); - return; - } - retry_wait = LWIP_MIN(PPPOL2TP_CONTROL_TIMEOUT * l2tp->sccrq_retried, PPPOL2TP_SLOW_RETRY); - PPPDEBUG(LOG_DEBUG, ("pppol2tp: sccrq_retried=%d\n", l2tp->sccrq_retried)); - if ((err = pppol2tp_send_sccrq(l2tp)) != 0) { - l2tp->sccrq_retried--; - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCRQ, error=%d\n", err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_timeout(retry_wait, pppol2tp_timeout, l2tp); - break; - - case PPPOL2TP_STATE_ICRQ_SENT: - l2tp->icrq_retried++; - if (l2tp->icrq_retried >= PPPOL2TP_MAXICRQ) { - pppol2tp_abort_connect(l2tp); - return; - } - PPPDEBUG(LOG_DEBUG, ("pppol2tp: icrq_retried=%d\n", l2tp->icrq_retried)); - if ((s16_t)(l2tp->peer_nr - l2tp->our_ns) < 0) { /* the SCCCN was not acknowledged */ - if ((err = pppol2tp_send_scccn(l2tp, l2tp->our_ns -1)) != 0) { - l2tp->icrq_retried--; - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCCN, error=%d\n", err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); - break; - } - } - if ((err = pppol2tp_send_icrq(l2tp, l2tp->our_ns)) != 0) { - l2tp->icrq_retried--; - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICRQ, error=%d\n", err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); - break; - - case PPPOL2TP_STATE_ICCN_SENT: - l2tp->iccn_retried++; - if (l2tp->iccn_retried >= PPPOL2TP_MAXICCN) { - pppol2tp_abort_connect(l2tp); - return; - } - PPPDEBUG(LOG_DEBUG, ("pppol2tp: iccn_retried=%d\n", l2tp->iccn_retried)); - if ((err = pppol2tp_send_iccn(l2tp, l2tp->our_ns)) != 0) { - l2tp->iccn_retried--; - PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICCN, error=%d\n", err)); - LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ - } - sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); - break; - - default: - return; /* all done, work in peace */ - } -} - -/* Connection attempt aborted */ -static void pppol2tp_abort_connect(pppol2tp_pcb *l2tp) { - PPPDEBUG(LOG_DEBUG, ("pppol2tp: could not establish connection\n")); - l2tp->phase = PPPOL2TP_STATE_INITIAL; - ppp_link_failed(l2tp->ppp); /* notify upper layers */ -} - -/* Initiate a new tunnel */ -static err_t pppol2tp_send_sccrq(pppol2tp_pcb *l2tp) { - struct pbuf *pb; - u8_t *p; - u16_t len; - - /* calculate UDP packet length */ - len = 12 +8 +8 +10 +10 +6+sizeof(PPPOL2TP_HOSTNAME)-1 +6+sizeof(PPPOL2TP_VENDORNAME)-1 +8 +8; -#if PPPOL2TP_AUTH_SUPPORT - if (l2tp->secret != NULL) { - len += 6 + sizeof(l2tp->secret_rv); - } -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - /* allocate a buffer */ - pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); - if (pb == NULL) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - p = (u8_t*)pb->payload; - /* fill in pkt */ - /* L2TP control header */ - PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); - PUTSHORT(len, p); /* Length */ - PUTSHORT(0, p); /* Tunnel Id */ - PUTSHORT(0, p); /* Session Id */ - PUTSHORT(0, p); /* NS Sequence number - to peer */ - PUTSHORT(0, p); /* NR Sequence number - expected for peer */ - - /* AVP - Message type */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ - PUTSHORT(PPPOL2TP_MESSAGETYPE_SCCRQ, p); /* Attribute value: Message type: SCCRQ */ - - /* AVP - L2TP Version */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_VERSION, p); /* Attribute type: Version */ - PUTSHORT(PPPOL2TP_VERSION, p); /* Attribute value: L2TP Version */ - - /* AVP - Framing capabilities */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_FRAMINGCAPABILITIES, p); /* Attribute type: Framing capabilities */ - PUTLONG(PPPOL2TP_FRAMINGCAPABILITIES, p); /* Attribute value: Framing capabilities */ - - /* AVP - Bearer capabilities */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_BEARERCAPABILITIES, p); /* Attribute type: Bearer capabilities */ - PUTLONG(PPPOL2TP_BEARERCAPABILITIES, p); /* Attribute value: Bearer capabilities */ - - /* AVP - Host name */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 6+sizeof(PPPOL2TP_HOSTNAME)-1, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_HOSTNAME, p); /* Attribute type: Hostname */ - MEMCPY(p, PPPOL2TP_HOSTNAME, sizeof(PPPOL2TP_HOSTNAME)-1); /* Attribute value: Hostname */ - INCPTR(sizeof(PPPOL2TP_HOSTNAME)-1, p); - - /* AVP - Vendor name */ - PUTSHORT(6+sizeof(PPPOL2TP_VENDORNAME)-1, p); /* len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_VENDORNAME, p); /* Attribute type: Vendor name */ - MEMCPY(p, PPPOL2TP_VENDORNAME, sizeof(PPPOL2TP_VENDORNAME)-1); /* Attribute value: Vendor name */ - INCPTR(sizeof(PPPOL2TP_VENDORNAME)-1, p); - - /* AVP - Assign tunnel ID */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_TUNNELID, p); /* Attribute type: Tunnel ID */ - PUTSHORT(l2tp->remote_tunnel_id, p); /* Attribute value: Tunnel ID */ - - /* AVP - Receive window size */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_RECEIVEWINDOWSIZE, p); /* Attribute type: Receive window size */ - PUTSHORT(PPPOL2TP_RECEIVEWINDOWSIZE, p); /* Attribute value: Receive window size */ - -#if PPPOL2TP_AUTH_SUPPORT - /* AVP - Challenge */ - if (l2tp->secret != NULL) { - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 6 + sizeof(l2tp->secret_rv), p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_CHALLENGE, p); /* Attribute type: Challenge */ - MEMCPY(p, l2tp->secret_rv, sizeof(l2tp->secret_rv)); /* Attribute value: Random vector */ - INCPTR(sizeof(l2tp->secret_rv), p); - } -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - return pppol2tp_udp_send(l2tp, pb); -} - -/* Complete tunnel establishment */ -static err_t pppol2tp_send_scccn(pppol2tp_pcb *l2tp, u16_t ns) { - struct pbuf *pb; - u8_t *p; - u16_t len; - - /* calculate UDP packet length */ - len = 12 +8; -#if PPPOL2TP_AUTH_SUPPORT - if (l2tp->send_challenge) { - len += 6 + sizeof(l2tp->challenge_hash); - } -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - /* allocate a buffer */ - pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); - if (pb == NULL) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - p = (u8_t*)pb->payload; - /* fill in pkt */ - /* L2TP control header */ - PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); - PUTSHORT(len, p); /* Length */ - PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ - PUTSHORT(0, p); /* Session Id */ - PUTSHORT(ns, p); /* NS Sequence number - to peer */ - PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ - - /* AVP - Message type */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ - PUTSHORT(PPPOL2TP_MESSAGETYPE_SCCCN, p); /* Attribute value: Message type: SCCCN */ - -#if PPPOL2TP_AUTH_SUPPORT - /* AVP - Challenge response */ - if (l2tp->send_challenge) { - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 6 + sizeof(l2tp->challenge_hash), p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_CHALLENGERESPONSE, p); /* Attribute type: Challenge response */ - MEMCPY(p, l2tp->challenge_hash, sizeof(l2tp->challenge_hash)); /* Attribute value: Computed challenge */ - INCPTR(sizeof(l2tp->challenge_hash), p); - } -#endif /* PPPOL2TP_AUTH_SUPPORT */ - - return pppol2tp_udp_send(l2tp, pb); -} - -/* Initiate a new session */ -static err_t pppol2tp_send_icrq(pppol2tp_pcb *l2tp, u16_t ns) { - struct pbuf *pb; - u8_t *p; - u16_t len; - u32_t serialnumber; - - /* calculate UDP packet length */ - len = 12 +8 +8 +10; - - /* allocate a buffer */ - pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); - if (pb == NULL) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - p = (u8_t*)pb->payload; - /* fill in pkt */ - /* L2TP control header */ - PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); - PUTSHORT(len, p); /* Length */ - PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ - PUTSHORT(0, p); /* Session Id */ - PUTSHORT(ns, p); /* NS Sequence number - to peer */ - PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ - - /* AVP - Message type */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ - PUTSHORT(PPPOL2TP_MESSAGETYPE_ICRQ, p); /* Attribute value: Message type: ICRQ */ - - /* AVP - Assign session ID */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_SESSIONID, p); /* Attribute type: Session ID */ - PUTSHORT(l2tp->remote_session_id, p); /* Attribute value: Session ID */ - - /* AVP - Call Serial Number */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_CALLSERIALNUMBER, p); /* Attribute type: Serial number */ - serialnumber = magic(); - PUTLONG(serialnumber, p); /* Attribute value: Serial number */ - - return pppol2tp_udp_send(l2tp, pb); -} - -/* Complete tunnel establishment */ -static err_t pppol2tp_send_iccn(pppol2tp_pcb *l2tp, u16_t ns) { - struct pbuf *pb; - u8_t *p; - u16_t len; - - /* calculate UDP packet length */ - len = 12 +8 +10 +10; - - /* allocate a buffer */ - pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); - if (pb == NULL) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - p = (u8_t*)pb->payload; - /* fill in pkt */ - /* L2TP control header */ - PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); - PUTSHORT(len, p); /* Length */ - PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ - PUTSHORT(l2tp->source_session_id, p); /* Session Id */ - PUTSHORT(ns, p); /* NS Sequence number - to peer */ - PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ - - /* AVP - Message type */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ - PUTSHORT(PPPOL2TP_MESSAGETYPE_ICCN, p); /* Attribute value: Message type: ICCN */ - - /* AVP - Framing type */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_FRAMINGTYPE, p); /* Attribute type: Framing type */ - PUTLONG(PPPOL2TP_FRAMINGTYPE, p); /* Attribute value: Framing type */ - - /* AVP - TX Connect speed */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_TXCONNECTSPEED, p); /* Attribute type: TX Connect speed */ - PUTLONG(PPPOL2TP_TXCONNECTSPEED, p); /* Attribute value: TX Connect speed */ - - return pppol2tp_udp_send(l2tp, pb); -} - -/* Send a ZLB ACK packet */ -static err_t pppol2tp_send_zlb(pppol2tp_pcb *l2tp, u16_t ns, u16_t nr) { - struct pbuf *pb; - u8_t *p; - u16_t len; - - /* calculate UDP packet length */ - len = 12; - - /* allocate a buffer */ - pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); - if (pb == NULL) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - p = (u8_t*)pb->payload; - /* fill in pkt */ - /* L2TP control header */ - PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); - PUTSHORT(len, p); /* Length */ - PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ - PUTSHORT(0, p); /* Session Id */ - PUTSHORT(ns, p); /* NS Sequence number - to peer */ - PUTSHORT(nr, p); /* NR Sequence number - expected for peer */ - - return pppol2tp_udp_send(l2tp, pb); -} - -/* Send a StopCCN packet */ -static err_t pppol2tp_send_stopccn(pppol2tp_pcb *l2tp, u16_t ns) { - struct pbuf *pb; - u8_t *p; - u16_t len; - - /* calculate UDP packet length */ - len = 12 +8 +8 +8; - - /* allocate a buffer */ - pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); - if (pb == NULL) { - return ERR_MEM; - } - LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); - - p = (u8_t*)pb->payload; - /* fill in pkt */ - /* L2TP control header */ - PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); - PUTSHORT(len, p); /* Length */ - PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ - PUTSHORT(0, p); /* Session Id */ - PUTSHORT(ns, p); /* NS Sequence number - to peer */ - PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ - - /* AVP - Message type */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ - PUTSHORT(PPPOL2TP_MESSAGETYPE_STOPCCN, p); /* Attribute value: Message type: StopCCN */ - - /* AVP - Assign tunnel ID */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_TUNNELID, p); /* Attribute type: Tunnel ID */ - PUTSHORT(l2tp->remote_tunnel_id, p); /* Attribute value: Tunnel ID */ - - /* AVP - Result code */ - PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ - PUTSHORT(0, p); /* Vendor ID */ - PUTSHORT(PPPOL2TP_AVPTYPE_RESULTCODE, p); /* Attribute type: Result code */ - PUTSHORT(PPPOL2TP_RESULTCODE, p); /* Attribute value: Result code */ - - return pppol2tp_udp_send(l2tp, pb); -} - -static err_t pppol2tp_xmit(pppol2tp_pcb *l2tp, struct pbuf *pb) { - u8_t *p; - - /* make room for L2TP header - should not fail */ - if (pbuf_add_header(pb, PPPOL2TP_OUTPUT_DATA_HEADER_LEN) != 0) { - /* bail out */ - PPPDEBUG(LOG_ERR, ("pppol2tp: pppol2tp_pcb: could not allocate room for L2TP header\n")); - LINK_STATS_INC(link.lenerr); - pbuf_free(pb); - return ERR_BUF; - } - - p = (u8_t*)pb->payload; - PUTSHORT(PPPOL2TP_HEADERFLAG_DATA_MANDATORY, p); - PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ - PUTSHORT(l2tp->source_session_id, p); /* Session Id */ - - return pppol2tp_udp_send(l2tp, pb); -} - -static err_t pppol2tp_udp_send(pppol2tp_pcb *l2tp, struct pbuf *pb) { - err_t err; - if (l2tp->netif) { - err = udp_sendto_if(l2tp->udp, pb, &l2tp->remote_ip, l2tp->tunnel_port, l2tp->netif); - } else { - err = udp_sendto(l2tp->udp, pb, &l2tp->remote_ip, l2tp->tunnel_port); - } - pbuf_free(pb); - return err; -} - -#endif /* PPP_SUPPORT && PPPOL2TP_SUPPORT */ +/** + * @file + * Network Point to Point Protocol over Layer 2 Tunneling Protocol program file. + * + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +/* + * L2TP Support status: + * + * Supported: + * - L2TPv2 (PPP over L2TP, a.k.a. UDP tunnels) + * - LAC + * + * Not supported: + * - LNS (require PPP server support) + * - L2TPv3 ethernet pseudowires + * - L2TPv3 VLAN pseudowire + * - L2TPv3 PPP pseudowires + * - L2TPv3 IP encapsulation + * - L2TPv3 IP pseudowire + * - L2TP tunnel switching - http://tools.ietf.org/html/draft-ietf-l2tpext-tunnel-switching-08 + * - Multiple tunnels per UDP socket, as well as multiple sessions per tunnel + * - Hidden AVPs + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPPOL2TP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include "lwip/err.h" +#include "lwip/memp.h" +#include "lwip/netif.h" +#include "lwip/udp.h" +#include "lwip/snmp.h" + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/lcp.h" +#include "netif/ppp/ipcp.h" +#include "netif/ppp/pppol2tp.h" +#include "netif/ppp/pppcrypt.h" +#include "netif/ppp/magic.h" + +/* Memory pool */ +LWIP_MEMPOOL_DECLARE(PPPOL2TP_PCB, MEMP_NUM_PPPOL2TP_INTERFACES, sizeof(pppol2tp_pcb), "PPPOL2TP_PCB") + +/* callbacks called from PPP core */ +static err_t pppol2tp_write(ppp_pcb *ppp, void *ctx, struct pbuf *p); +static err_t pppol2tp_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol); +static err_t pppol2tp_destroy(ppp_pcb *ppp, void *ctx); /* Destroy a L2TP control block */ +static void pppol2tp_connect(ppp_pcb *ppp, void *ctx); /* Be a LAC, connect to a LNS. */ +static void pppol2tp_disconnect(ppp_pcb *ppp, void *ctx); /* Disconnect */ + + /* Prototypes for procedures local to this file. */ +static void pppol2tp_input(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port); +static void pppol2tp_dispatch_control_packet(pppol2tp_pcb *l2tp, u16_t port, struct pbuf *p, u16_t ns, u16_t nr); +static void pppol2tp_timeout(void *arg); +static void pppol2tp_abort_connect(pppol2tp_pcb *l2tp); +static err_t pppol2tp_send_sccrq(pppol2tp_pcb *l2tp); +static err_t pppol2tp_send_scccn(pppol2tp_pcb *l2tp, u16_t ns); +static err_t pppol2tp_send_icrq(pppol2tp_pcb *l2tp, u16_t ns); +static err_t pppol2tp_send_iccn(pppol2tp_pcb *l2tp, u16_t ns); +static err_t pppol2tp_send_zlb(pppol2tp_pcb *l2tp, u16_t ns, u16_t nr); +static err_t pppol2tp_send_stopccn(pppol2tp_pcb *l2tp, u16_t ns); +static err_t pppol2tp_xmit(pppol2tp_pcb *l2tp, struct pbuf *pb); +static err_t pppol2tp_udp_send(pppol2tp_pcb *l2tp, struct pbuf *pb); + +/* Callbacks structure for PPP core */ +static const struct link_callbacks pppol2tp_callbacks = { + pppol2tp_connect, +#if PPP_SERVER + NULL, +#endif /* PPP_SERVER */ + pppol2tp_disconnect, + pppol2tp_destroy, + pppol2tp_write, + pppol2tp_netif_output, + NULL, + NULL +}; + + +/* Create a new L2TP session. */ +ppp_pcb *pppol2tp_create(struct netif *pppif, + struct netif *netif, const ip_addr_t *ipaddr, u16_t port, + const u8_t *secret, u8_t secret_len, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb) { + ppp_pcb *ppp; + pppol2tp_pcb *l2tp; + struct udp_pcb *udp; +#if !PPPOL2TP_AUTH_SUPPORT + LWIP_UNUSED_ARG(secret); + LWIP_UNUSED_ARG(secret_len); +#endif /* !PPPOL2TP_AUTH_SUPPORT */ + + if (ipaddr == NULL) { + goto ipaddr_check_failed; + } + + l2tp = (pppol2tp_pcb *)LWIP_MEMPOOL_ALLOC(PPPOL2TP_PCB); + if (l2tp == NULL) { + goto memp_malloc_l2tp_failed; + } + + udp = udp_new_ip_type(IP_GET_TYPE(ipaddr)); + if (udp == NULL) { + goto udp_new_failed; + } + udp_recv(udp, pppol2tp_input, l2tp); + + ppp = ppp_new(pppif, &pppol2tp_callbacks, l2tp, link_status_cb, ctx_cb); + if (ppp == NULL) { + goto ppp_new_failed; + } + + memset(l2tp, 0, sizeof(pppol2tp_pcb)); + l2tp->phase = PPPOL2TP_STATE_INITIAL; + l2tp->ppp = ppp; + l2tp->udp = udp; + l2tp->netif = netif; + ip_addr_copy(l2tp->remote_ip, *ipaddr); + l2tp->remote_port = port; +#if PPPOL2TP_AUTH_SUPPORT + l2tp->secret = secret; + l2tp->secret_len = secret_len; +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + return ppp; + +ppp_new_failed: + udp_remove(udp); +udp_new_failed: + LWIP_MEMPOOL_FREE(PPPOL2TP_PCB, l2tp); +memp_malloc_l2tp_failed: +ipaddr_check_failed: + return NULL; +} + +/* Called by PPP core */ +static err_t pppol2tp_write(ppp_pcb *ppp, void *ctx, struct pbuf *p) { + pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; + struct pbuf *ph; /* UDP + L2TP header */ + err_t ret; +#if MIB2_STATS + u16_t tot_len; +#else /* MIB2_STATS */ + LWIP_UNUSED_ARG(ppp); +#endif /* MIB2_STATS */ + + ph = pbuf_alloc(PBUF_TRANSPORT, (u16_t)(PPPOL2TP_OUTPUT_DATA_HEADER_LEN), PBUF_RAM); + if(!ph) { + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.proterr); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + pbuf_free(p); + return ERR_MEM; + } + + pbuf_remove_header(ph, PPPOL2TP_OUTPUT_DATA_HEADER_LEN); /* hide L2TP header */ + pbuf_cat(ph, p); +#if MIB2_STATS + tot_len = ph->tot_len; +#endif /* MIB2_STATS */ + + ret = pppol2tp_xmit(l2tp, ph); + if (ret != ERR_OK) { + LINK_STATS_INC(link.err); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + return ret; + } + + MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, (u16_t)tot_len); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); + LINK_STATS_INC(link.xmit); + return ERR_OK; +} + +/* Called by PPP core */ +static err_t pppol2tp_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *p, u_short protocol) { + pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; + struct pbuf *pb; + u8_t *pl; + err_t err; +#if MIB2_STATS + u16_t tot_len; +#else /* MIB2_STATS */ + LWIP_UNUSED_ARG(ppp); +#endif /* MIB2_STATS */ + + /* @todo: try to use pbuf_header() here! */ + pb = pbuf_alloc(PBUF_TRANSPORT, PPPOL2TP_OUTPUT_DATA_HEADER_LEN + sizeof(protocol), PBUF_RAM); + if(!pb) { + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.proterr); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + return ERR_MEM; + } + + pbuf_remove_header(pb, PPPOL2TP_OUTPUT_DATA_HEADER_LEN); + + pl = (u8_t*)pb->payload; + PUTSHORT(protocol, pl); + + pbuf_chain(pb, p); +#if MIB2_STATS + tot_len = pb->tot_len; +#endif /* MIB2_STATS */ + + if( (err = pppol2tp_xmit(l2tp, pb)) != ERR_OK) { + LINK_STATS_INC(link.err); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + return err; + } + + MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, tot_len); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); + LINK_STATS_INC(link.xmit); + return ERR_OK; +} + +/* Destroy a L2TP control block */ +static err_t pppol2tp_destroy(ppp_pcb *ppp, void *ctx) { + pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; + LWIP_UNUSED_ARG(ppp); + + sys_untimeout(pppol2tp_timeout, l2tp); + udp_remove(l2tp->udp); + LWIP_MEMPOOL_FREE(PPPOL2TP_PCB, l2tp); + return ERR_OK; +} + +/* Be a LAC, connect to a LNS. */ +static void pppol2tp_connect(ppp_pcb *ppp, void *ctx) { + err_t err; + pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; + lcp_options *lcp_wo; + lcp_options *lcp_ao; +#if PPP_IPV4_SUPPORT && VJ_SUPPORT + ipcp_options *ipcp_wo; + ipcp_options *ipcp_ao; +#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ + + l2tp->tunnel_port = l2tp->remote_port; + l2tp->our_ns = 0; + l2tp->peer_nr = 0; + l2tp->peer_ns = 0; + l2tp->source_tunnel_id = 0; + l2tp->remote_tunnel_id = 0; + l2tp->source_session_id = 0; + l2tp->remote_session_id = 0; + /* l2tp->*_retried are cleared when used */ + + lcp_wo = &ppp->lcp_wantoptions; + lcp_wo->mru = PPPOL2TP_DEFMRU; + lcp_wo->neg_asyncmap = 0; + lcp_wo->neg_pcompression = 0; + lcp_wo->neg_accompression = 0; + lcp_wo->passive = 0; + lcp_wo->silent = 0; + + lcp_ao = &ppp->lcp_allowoptions; + lcp_ao->mru = PPPOL2TP_DEFMRU; + lcp_ao->neg_asyncmap = 0; + lcp_ao->neg_pcompression = 0; + lcp_ao->neg_accompression = 0; + +#if PPP_IPV4_SUPPORT && VJ_SUPPORT + ipcp_wo = &ppp->ipcp_wantoptions; + ipcp_wo->neg_vj = 0; + ipcp_wo->old_vj = 0; + + ipcp_ao = &ppp->ipcp_allowoptions; + ipcp_ao->neg_vj = 0; + ipcp_ao->old_vj = 0; +#endif /* PPP_IPV4_SUPPORT && VJ_SUPPORT */ + + /* Listen to a random source port, we need to do that instead of using udp_connect() + * because the L2TP LNS might answer with its own random source port (!= 1701) + */ +#if LWIP_IPV6 + if (IP_IS_V6_VAL(l2tp->udp->local_ip)) { + udp_bind(l2tp->udp, IP6_ADDR_ANY, 0); + } else +#endif /* LWIP_IPV6 */ + udp_bind(l2tp->udp, IP_ADDR_ANY, 0); + +#if PPPOL2TP_AUTH_SUPPORT + /* Generate random vector */ + if (l2tp->secret != NULL) { + magic_random_bytes(l2tp->secret_rv, sizeof(l2tp->secret_rv)); + } +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + do { + l2tp->remote_tunnel_id = magic(); + } while(l2tp->remote_tunnel_id == 0); + /* save state, in case we fail to send SCCRQ */ + l2tp->sccrq_retried = 0; + l2tp->phase = PPPOL2TP_STATE_SCCRQ_SENT; + if ((err = pppol2tp_send_sccrq(l2tp)) != 0) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCRQ, error=%d\n", err)); + } + sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); +} + +/* Disconnect */ +static void pppol2tp_disconnect(ppp_pcb *ppp, void *ctx) { + pppol2tp_pcb *l2tp = (pppol2tp_pcb *)ctx; + + l2tp->our_ns++; + pppol2tp_send_stopccn(l2tp, l2tp->our_ns); + + /* stop any timer, disconnect can be called while initiating is in progress */ + sys_untimeout(pppol2tp_timeout, l2tp); + l2tp->phase = PPPOL2TP_STATE_INITIAL; + ppp_link_end(ppp); /* notify upper layers */ +} + +/* UDP Callback for incoming IPv4 L2TP frames */ +static void pppol2tp_input(void *arg, struct udp_pcb *pcb, struct pbuf *p, const ip_addr_t *addr, u16_t port) { + pppol2tp_pcb *l2tp = (pppol2tp_pcb*)arg; + u16_t hflags, hlen, len=0, tunnel_id=0, session_id=0, ns=0, nr=0, offset=0; + u8_t *inp; + LWIP_UNUSED_ARG(pcb); + + /* we can't unbound a UDP pcb, thus we can still receive UDP frames after the link is closed */ + if (l2tp->phase < PPPOL2TP_STATE_SCCRQ_SENT) { + goto free_and_return; + } + + if (!ip_addr_cmp(&l2tp->remote_ip, addr)) { + goto free_and_return; + } + + /* discard packet if port mismatch, but only if we received a SCCRP */ + if (l2tp->phase > PPPOL2TP_STATE_SCCRQ_SENT && l2tp->tunnel_port != port) { + goto free_and_return; + } + + /* printf("-----------\nL2TP INPUT, %d\n", p->len); */ + + /* L2TP header */ + if (p->len < sizeof(hflags) + sizeof(tunnel_id) + sizeof(session_id) ) { + goto packet_too_short; + } + + inp = (u8_t*)p->payload; + GETSHORT(hflags, inp); + + if (hflags & PPPOL2TP_HEADERFLAG_CONTROL) { + /* check mandatory flags for a control packet */ + if ( (hflags & PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY) != PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY ) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: mandatory header flags for control packet not set\n")); + goto free_and_return; + } + /* check forbidden flags for a control packet */ + if (hflags & PPPOL2TP_HEADERFLAG_CONTROL_FORBIDDEN) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: forbidden header flags for control packet found\n")); + goto free_and_return; + } + } else { + /* check mandatory flags for a data packet */ + if ( (hflags & PPPOL2TP_HEADERFLAG_DATA_MANDATORY) != PPPOL2TP_HEADERFLAG_DATA_MANDATORY) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: mandatory header flags for data packet not set\n")); + goto free_and_return; + } + } + + /* Expected header size */ + hlen = sizeof(hflags) + sizeof(tunnel_id) + sizeof(session_id); + if (hflags & PPPOL2TP_HEADERFLAG_LENGTH) { + hlen += sizeof(len); + } + if (hflags & PPPOL2TP_HEADERFLAG_SEQUENCE) { + hlen += sizeof(ns) + sizeof(nr); + } + if (hflags & PPPOL2TP_HEADERFLAG_OFFSET) { + hlen += sizeof(offset); + } + if (p->len < hlen) { + goto packet_too_short; + } + + if (hflags & PPPOL2TP_HEADERFLAG_LENGTH) { + GETSHORT(len, inp); + if (p->len < len || len < hlen) { + goto packet_too_short; + } + } + GETSHORT(tunnel_id, inp); + GETSHORT(session_id, inp); + if (hflags & PPPOL2TP_HEADERFLAG_SEQUENCE) { + GETSHORT(ns, inp); + GETSHORT(nr, inp); + } + if (hflags & PPPOL2TP_HEADERFLAG_OFFSET) { + GETSHORT(offset, inp) + if (offset > 4096) { /* don't be fooled with large offset which might overflow hlen */ + PPPDEBUG(LOG_DEBUG, ("pppol2tp: strange packet received, offset=%d\n", offset)); + goto free_and_return; + } + hlen += offset; + if (p->len < hlen) { + goto packet_too_short; + } + INCPTR(offset, inp); + } + + /* printf("HLEN = %d\n", hlen); */ + + /* skip L2TP header */ + if (pbuf_remove_header(p, hlen) != 0) { + goto free_and_return; + } + + /* printf("LEN=%d, TUNNEL_ID=%d, SESSION_ID=%d, NS=%d, NR=%d, OFFSET=%d\n", len, tunnel_id, session_id, ns, nr, offset); */ + PPPDEBUG(LOG_DEBUG, ("pppol2tp: input packet, len=%"U16_F", tunnel=%"U16_F", session=%"U16_F", ns=%"U16_F", nr=%"U16_F"\n", + len, tunnel_id, session_id, ns, nr)); + + /* Control packet */ + if (hflags & PPPOL2TP_HEADERFLAG_CONTROL) { + pppol2tp_dispatch_control_packet(l2tp, port, p, ns, nr); + goto free_and_return; + } + + /* Data packet */ + if(l2tp->phase != PPPOL2TP_STATE_DATA) { + goto free_and_return; + } + if(tunnel_id != l2tp->remote_tunnel_id) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: tunnel ID mismatch, assigned=%d, received=%d\n", l2tp->remote_tunnel_id, tunnel_id)); + goto free_and_return; + } + if(session_id != l2tp->remote_session_id) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: session ID mismatch, assigned=%d, received=%d\n", l2tp->remote_session_id, session_id)); + goto free_and_return; + } + /* + * skip address & flags if necessary + * + * RFC 2661 does not specify whether the PPP frame in the L2TP payload should + * have a HDLC header or not. We handle both cases for compatibility. + */ + if (p->len >= 2) { + GETSHORT(hflags, inp); + if (hflags == 0xff03) { + pbuf_remove_header(p, 2); + } + } + /* Dispatch the packet thereby consuming it. */ + ppp_input(l2tp->ppp, p); + return; + +packet_too_short: + PPPDEBUG(LOG_DEBUG, ("pppol2tp: packet too short: %d\n", p->len)); +free_and_return: + pbuf_free(p); +} + +/* L2TP Control packet entry point */ +static void pppol2tp_dispatch_control_packet(pppol2tp_pcb *l2tp, u16_t port, struct pbuf *p, u16_t ns, u16_t nr) { + u8_t *inp; + u16_t avplen, avpflags, vendorid, attributetype, messagetype=0; + err_t err; +#if PPPOL2TP_AUTH_SUPPORT + lwip_md5_context md5_ctx; + u8_t md5_hash[16]; + u8_t challenge_id = 0; +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + /* printf("L2TP CTRL INPUT, ns=%d, nr=%d, len=%d\n", ns, nr, p->len); */ + + /* Drop unexpected packet */ + if (ns != l2tp->peer_ns) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: drop unexpected packet: received NS=%d, expected NS=%d\n", ns, l2tp->peer_ns)); + /* + * In order to ensure that all messages are acknowledged properly + * (particularly in the case of a lost ZLB ACK message), receipt + * of duplicate messages MUST be acknowledged. + * + * In this very special case we Ack a packet we previously received. + * Therefore our NS is the NR we just received. And our NR is the + * NS we just received plus one. + */ + if ((s16_t)(ns - l2tp->peer_ns) < 0) { + pppol2tp_send_zlb(l2tp, nr, ns+1); + } + return; + } + + l2tp->peer_nr = nr; + + /* Handle the special case of the ICCN acknowledge */ + if (l2tp->phase == PPPOL2TP_STATE_ICCN_SENT && (s16_t)(l2tp->peer_nr - l2tp->our_ns) > 0) { + l2tp->phase = PPPOL2TP_STATE_DATA; + sys_untimeout(pppol2tp_timeout, l2tp); + ppp_start(l2tp->ppp); /* notify upper layers */ + } + + /* ZLB packets */ + if (p->tot_len == 0) { + return; + } + /* A ZLB packet does not consume a NS slot thus we don't record the NS value for ZLB packets */ + l2tp->peer_ns = ns+1; + + p = pbuf_coalesce(p, PBUF_RAW); + inp = (u8_t*)p->payload; + /* Decode AVPs */ + while (p->len > 0) { + if (p->len < sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype) ) { + goto packet_too_short; + } + GETSHORT(avpflags, inp); + avplen = avpflags & PPPOL2TP_AVPHEADERFLAG_LENGTHMASK; + /* printf("AVPLEN = %d\n", avplen); */ + if (p->len < avplen || avplen < sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype)) { + goto packet_too_short; + } + GETSHORT(vendorid, inp); + GETSHORT(attributetype, inp); + avplen -= sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype); + + /* Message type must be the first AVP */ + if (messagetype == 0) { + if (attributetype != 0 || vendorid != 0 || avplen != sizeof(messagetype) ) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: message type must be the first AVP\n")); + return; + } + GETSHORT(messagetype, inp); + /* printf("Message type = %d\n", messagetype); */ + switch(messagetype) { + /* Start Control Connection Reply */ + case PPPOL2TP_MESSAGETYPE_SCCRP: + /* Only accept SCCRP packet if we sent a SCCRQ */ + if (l2tp->phase != PPPOL2TP_STATE_SCCRQ_SENT) { + goto send_zlb; + } + break; + /* Incoming Call Reply */ + case PPPOL2TP_MESSAGETYPE_ICRP: + /* Only accept ICRP packet if we sent a IRCQ */ + if (l2tp->phase != PPPOL2TP_STATE_ICRQ_SENT) { + goto send_zlb; + } + break; + /* Stop Control Connection Notification */ + case PPPOL2TP_MESSAGETYPE_STOPCCN: + pppol2tp_send_zlb(l2tp, l2tp->our_ns+1, l2tp->peer_ns); /* Ack the StopCCN before we switch to down state */ + if (l2tp->phase < PPPOL2TP_STATE_DATA) { + pppol2tp_abort_connect(l2tp); + } else if (l2tp->phase == PPPOL2TP_STATE_DATA) { + /* Don't disconnect here, we let the LCP Echo/Reply find the fact + * that PPP session is down. Asking the PPP stack to end the session + * require strict checking about the PPP phase to prevent endless + * disconnection loops. + */ + } + return; + default: + break; + } + goto nextavp; + } + + /* Skip proprietary L2TP extensions */ + if (vendorid != 0) { + goto skipavp; + } + + switch (messagetype) { + /* Start Control Connection Reply */ + case PPPOL2TP_MESSAGETYPE_SCCRP: + switch (attributetype) { + case PPPOL2TP_AVPTYPE_TUNNELID: + if (avplen != sizeof(l2tp->source_tunnel_id) ) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: AVP Assign tunnel ID length check failed\n")); + return; + } + GETSHORT(l2tp->source_tunnel_id, inp); + PPPDEBUG(LOG_DEBUG, ("pppol2tp: Assigned tunnel ID %"U16_F"\n", l2tp->source_tunnel_id)); + goto nextavp; +#if PPPOL2TP_AUTH_SUPPORT + case PPPOL2TP_AVPTYPE_CHALLENGE: + if (avplen == 0) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: Challenge length check failed\n")); + return; + } + if (l2tp->secret == NULL) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: Received challenge from peer and no secret key available\n")); + pppol2tp_abort_connect(l2tp); + return; + } + /* Generate hash of ID, secret, challenge */ + lwip_md5_init(&md5_ctx); + lwip_md5_starts(&md5_ctx); + challenge_id = PPPOL2TP_MESSAGETYPE_SCCCN; + lwip_md5_update(&md5_ctx, &challenge_id, 1); + lwip_md5_update(&md5_ctx, l2tp->secret, l2tp->secret_len); + lwip_md5_update(&md5_ctx, inp, avplen); + lwip_md5_finish(&md5_ctx, l2tp->challenge_hash); + lwip_md5_free(&md5_ctx); + l2tp->send_challenge = 1; + goto skipavp; + case PPPOL2TP_AVPTYPE_CHALLENGERESPONSE: + if (avplen != PPPOL2TP_AVPTYPE_CHALLENGERESPONSE_SIZE) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: AVP Challenge Response length check failed\n")); + return; + } + /* Generate hash of ID, secret, challenge */ + lwip_md5_init(&md5_ctx); + lwip_md5_starts(&md5_ctx); + challenge_id = PPPOL2TP_MESSAGETYPE_SCCRP; + lwip_md5_update(&md5_ctx, &challenge_id, 1); + lwip_md5_update(&md5_ctx, l2tp->secret, l2tp->secret_len); + lwip_md5_update(&md5_ctx, l2tp->secret_rv, sizeof(l2tp->secret_rv)); + lwip_md5_finish(&md5_ctx, md5_hash); + lwip_md5_free(&md5_ctx); + if ( memcmp(inp, md5_hash, sizeof(md5_hash)) ) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: Received challenge response from peer and secret key do not match\n")); + pppol2tp_abort_connect(l2tp); + return; + } + goto skipavp; +#endif /* PPPOL2TP_AUTH_SUPPORT */ + default: + break; + } + break; + /* Incoming Call Reply */ + case PPPOL2TP_MESSAGETYPE_ICRP: + switch (attributetype) { + case PPPOL2TP_AVPTYPE_SESSIONID: + if (avplen != sizeof(l2tp->source_session_id) ) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: AVP Assign session ID length check failed\n")); + return; + } + GETSHORT(l2tp->source_session_id, inp); + PPPDEBUG(LOG_DEBUG, ("pppol2tp: Assigned session ID %"U16_F"\n", l2tp->source_session_id)); + goto nextavp; + default: + break; + } + break; + default: + break; + } + +skipavp: + INCPTR(avplen, inp); +nextavp: + /* printf("AVP Found, vendor=%d, attribute=%d, len=%d\n", vendorid, attributetype, avplen); */ + /* next AVP */ + if (pbuf_remove_header(p, avplen + sizeof(avpflags) + sizeof(vendorid) + sizeof(attributetype)) != 0) { + return; + } + } + + switch(messagetype) { + /* Start Control Connection Reply */ + case PPPOL2TP_MESSAGETYPE_SCCRP: + do { + l2tp->remote_session_id = magic(); + } while(l2tp->remote_session_id == 0); + l2tp->tunnel_port = port; /* LNS server might have chosen its own local port */ + l2tp->icrq_retried = 0; + l2tp->phase = PPPOL2TP_STATE_ICRQ_SENT; + l2tp->our_ns++; + if ((err = pppol2tp_send_scccn(l2tp, l2tp->our_ns)) != 0) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCCN, error=%d\n", err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + l2tp->our_ns++; + if ((err = pppol2tp_send_icrq(l2tp, l2tp->our_ns)) != 0) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICRQ, error=%d\n", err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_untimeout(pppol2tp_timeout, l2tp); + sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); + break; + /* Incoming Call Reply */ + case PPPOL2TP_MESSAGETYPE_ICRP: + l2tp->iccn_retried = 0; + l2tp->phase = PPPOL2TP_STATE_ICCN_SENT; + l2tp->our_ns++; + if ((err = pppol2tp_send_iccn(l2tp, l2tp->our_ns)) != 0) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICCN, error=%d\n", err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_untimeout(pppol2tp_timeout, l2tp); + sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); + break; + /* Unhandled packet, send ZLB ACK */ + default: + goto send_zlb; + } + return; + +send_zlb: + pppol2tp_send_zlb(l2tp, l2tp->our_ns+1, l2tp->peer_ns); + return; +packet_too_short: + PPPDEBUG(LOG_DEBUG, ("pppol2tp: packet too short: %d\n", p->len)); +} + +/* L2TP Timeout handler */ +static void pppol2tp_timeout(void *arg) { + pppol2tp_pcb *l2tp = (pppol2tp_pcb*)arg; + err_t err; + u32_t retry_wait; + + PPPDEBUG(LOG_DEBUG, ("pppol2tp: timeout\n")); + + switch (l2tp->phase) { + case PPPOL2TP_STATE_SCCRQ_SENT: + /* backoff wait */ + if (l2tp->sccrq_retried < 0xff) { + l2tp->sccrq_retried++; + } + if (!l2tp->ppp->settings.persist && l2tp->sccrq_retried >= PPPOL2TP_MAXSCCRQ) { + pppol2tp_abort_connect(l2tp); + return; + } + retry_wait = LWIP_MIN(PPPOL2TP_CONTROL_TIMEOUT * l2tp->sccrq_retried, PPPOL2TP_SLOW_RETRY); + PPPDEBUG(LOG_DEBUG, ("pppol2tp: sccrq_retried=%d\n", l2tp->sccrq_retried)); + if ((err = pppol2tp_send_sccrq(l2tp)) != 0) { + l2tp->sccrq_retried--; + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCRQ, error=%d\n", err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_timeout(retry_wait, pppol2tp_timeout, l2tp); + break; + + case PPPOL2TP_STATE_ICRQ_SENT: + l2tp->icrq_retried++; + if (l2tp->icrq_retried >= PPPOL2TP_MAXICRQ) { + pppol2tp_abort_connect(l2tp); + return; + } + PPPDEBUG(LOG_DEBUG, ("pppol2tp: icrq_retried=%d\n", l2tp->icrq_retried)); + if ((s16_t)(l2tp->peer_nr - l2tp->our_ns) < 0) { /* the SCCCN was not acknowledged */ + if ((err = pppol2tp_send_scccn(l2tp, l2tp->our_ns -1)) != 0) { + l2tp->icrq_retried--; + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send SCCCN, error=%d\n", err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); + break; + } + } + if ((err = pppol2tp_send_icrq(l2tp, l2tp->our_ns)) != 0) { + l2tp->icrq_retried--; + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICRQ, error=%d\n", err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); + break; + + case PPPOL2TP_STATE_ICCN_SENT: + l2tp->iccn_retried++; + if (l2tp->iccn_retried >= PPPOL2TP_MAXICCN) { + pppol2tp_abort_connect(l2tp); + return; + } + PPPDEBUG(LOG_DEBUG, ("pppol2tp: iccn_retried=%d\n", l2tp->iccn_retried)); + if ((err = pppol2tp_send_iccn(l2tp, l2tp->our_ns)) != 0) { + l2tp->iccn_retried--; + PPPDEBUG(LOG_DEBUG, ("pppol2tp: failed to send ICCN, error=%d\n", err)); + LWIP_UNUSED_ARG(err); /* if PPPDEBUG is disabled */ + } + sys_timeout(PPPOL2TP_CONTROL_TIMEOUT, pppol2tp_timeout, l2tp); + break; + + default: + return; /* all done, work in peace */ + } +} + +/* Connection attempt aborted */ +static void pppol2tp_abort_connect(pppol2tp_pcb *l2tp) { + PPPDEBUG(LOG_DEBUG, ("pppol2tp: could not establish connection\n")); + l2tp->phase = PPPOL2TP_STATE_INITIAL; + ppp_link_failed(l2tp->ppp); /* notify upper layers */ +} + +/* Initiate a new tunnel */ +static err_t pppol2tp_send_sccrq(pppol2tp_pcb *l2tp) { + struct pbuf *pb; + u8_t *p; + u16_t len; + + /* calculate UDP packet length */ + len = 12 +8 +8 +10 +10 +6+sizeof(PPPOL2TP_HOSTNAME)-1 +6+sizeof(PPPOL2TP_VENDORNAME)-1 +8 +8; +#if PPPOL2TP_AUTH_SUPPORT + if (l2tp->secret != NULL) { + len += 6 + sizeof(l2tp->secret_rv); + } +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + /* allocate a buffer */ + pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); + if (pb == NULL) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + p = (u8_t*)pb->payload; + /* fill in pkt */ + /* L2TP control header */ + PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); + PUTSHORT(len, p); /* Length */ + PUTSHORT(0, p); /* Tunnel Id */ + PUTSHORT(0, p); /* Session Id */ + PUTSHORT(0, p); /* NS Sequence number - to peer */ + PUTSHORT(0, p); /* NR Sequence number - expected for peer */ + + /* AVP - Message type */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ + PUTSHORT(PPPOL2TP_MESSAGETYPE_SCCRQ, p); /* Attribute value: Message type: SCCRQ */ + + /* AVP - L2TP Version */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_VERSION, p); /* Attribute type: Version */ + PUTSHORT(PPPOL2TP_VERSION, p); /* Attribute value: L2TP Version */ + + /* AVP - Framing capabilities */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_FRAMINGCAPABILITIES, p); /* Attribute type: Framing capabilities */ + PUTLONG(PPPOL2TP_FRAMINGCAPABILITIES, p); /* Attribute value: Framing capabilities */ + + /* AVP - Bearer capabilities */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_BEARERCAPABILITIES, p); /* Attribute type: Bearer capabilities */ + PUTLONG(PPPOL2TP_BEARERCAPABILITIES, p); /* Attribute value: Bearer capabilities */ + + /* AVP - Host name */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 6+sizeof(PPPOL2TP_HOSTNAME)-1, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_HOSTNAME, p); /* Attribute type: Hostname */ + MEMCPY(p, PPPOL2TP_HOSTNAME, sizeof(PPPOL2TP_HOSTNAME)-1); /* Attribute value: Hostname */ + INCPTR(sizeof(PPPOL2TP_HOSTNAME)-1, p); + + /* AVP - Vendor name */ + PUTSHORT(6+sizeof(PPPOL2TP_VENDORNAME)-1, p); /* len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_VENDORNAME, p); /* Attribute type: Vendor name */ + MEMCPY(p, PPPOL2TP_VENDORNAME, sizeof(PPPOL2TP_VENDORNAME)-1); /* Attribute value: Vendor name */ + INCPTR(sizeof(PPPOL2TP_VENDORNAME)-1, p); + + /* AVP - Assign tunnel ID */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_TUNNELID, p); /* Attribute type: Tunnel ID */ + PUTSHORT(l2tp->remote_tunnel_id, p); /* Attribute value: Tunnel ID */ + + /* AVP - Receive window size */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_RECEIVEWINDOWSIZE, p); /* Attribute type: Receive window size */ + PUTSHORT(PPPOL2TP_RECEIVEWINDOWSIZE, p); /* Attribute value: Receive window size */ + +#if PPPOL2TP_AUTH_SUPPORT + /* AVP - Challenge */ + if (l2tp->secret != NULL) { + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 6 + sizeof(l2tp->secret_rv), p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_CHALLENGE, p); /* Attribute type: Challenge */ + MEMCPY(p, l2tp->secret_rv, sizeof(l2tp->secret_rv)); /* Attribute value: Random vector */ + INCPTR(sizeof(l2tp->secret_rv), p); + } +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + return pppol2tp_udp_send(l2tp, pb); +} + +/* Complete tunnel establishment */ +static err_t pppol2tp_send_scccn(pppol2tp_pcb *l2tp, u16_t ns) { + struct pbuf *pb; + u8_t *p; + u16_t len; + + /* calculate UDP packet length */ + len = 12 +8; +#if PPPOL2TP_AUTH_SUPPORT + if (l2tp->send_challenge) { + len += 6 + sizeof(l2tp->challenge_hash); + } +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + /* allocate a buffer */ + pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); + if (pb == NULL) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + p = (u8_t*)pb->payload; + /* fill in pkt */ + /* L2TP control header */ + PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); + PUTSHORT(len, p); /* Length */ + PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ + PUTSHORT(0, p); /* Session Id */ + PUTSHORT(ns, p); /* NS Sequence number - to peer */ + PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ + + /* AVP - Message type */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ + PUTSHORT(PPPOL2TP_MESSAGETYPE_SCCCN, p); /* Attribute value: Message type: SCCCN */ + +#if PPPOL2TP_AUTH_SUPPORT + /* AVP - Challenge response */ + if (l2tp->send_challenge) { + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 6 + sizeof(l2tp->challenge_hash), p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_CHALLENGERESPONSE, p); /* Attribute type: Challenge response */ + MEMCPY(p, l2tp->challenge_hash, sizeof(l2tp->challenge_hash)); /* Attribute value: Computed challenge */ + INCPTR(sizeof(l2tp->challenge_hash), p); + } +#endif /* PPPOL2TP_AUTH_SUPPORT */ + + return pppol2tp_udp_send(l2tp, pb); +} + +/* Initiate a new session */ +static err_t pppol2tp_send_icrq(pppol2tp_pcb *l2tp, u16_t ns) { + struct pbuf *pb; + u8_t *p; + u16_t len; + u32_t serialnumber; + + /* calculate UDP packet length */ + len = 12 +8 +8 +10; + + /* allocate a buffer */ + pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); + if (pb == NULL) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + p = (u8_t*)pb->payload; + /* fill in pkt */ + /* L2TP control header */ + PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); + PUTSHORT(len, p); /* Length */ + PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ + PUTSHORT(0, p); /* Session Id */ + PUTSHORT(ns, p); /* NS Sequence number - to peer */ + PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ + + /* AVP - Message type */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ + PUTSHORT(PPPOL2TP_MESSAGETYPE_ICRQ, p); /* Attribute value: Message type: ICRQ */ + + /* AVP - Assign session ID */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_SESSIONID, p); /* Attribute type: Session ID */ + PUTSHORT(l2tp->remote_session_id, p); /* Attribute value: Session ID */ + + /* AVP - Call Serial Number */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_CALLSERIALNUMBER, p); /* Attribute type: Serial number */ + serialnumber = magic(); + PUTLONG(serialnumber, p); /* Attribute value: Serial number */ + + return pppol2tp_udp_send(l2tp, pb); +} + +/* Complete tunnel establishment */ +static err_t pppol2tp_send_iccn(pppol2tp_pcb *l2tp, u16_t ns) { + struct pbuf *pb; + u8_t *p; + u16_t len; + + /* calculate UDP packet length */ + len = 12 +8 +10 +10; + + /* allocate a buffer */ + pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); + if (pb == NULL) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + p = (u8_t*)pb->payload; + /* fill in pkt */ + /* L2TP control header */ + PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); + PUTSHORT(len, p); /* Length */ + PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ + PUTSHORT(l2tp->source_session_id, p); /* Session Id */ + PUTSHORT(ns, p); /* NS Sequence number - to peer */ + PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ + + /* AVP - Message type */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ + PUTSHORT(PPPOL2TP_MESSAGETYPE_ICCN, p); /* Attribute value: Message type: ICCN */ + + /* AVP - Framing type */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_FRAMINGTYPE, p); /* Attribute type: Framing type */ + PUTLONG(PPPOL2TP_FRAMINGTYPE, p); /* Attribute value: Framing type */ + + /* AVP - TX Connect speed */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 10, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_TXCONNECTSPEED, p); /* Attribute type: TX Connect speed */ + PUTLONG(PPPOL2TP_TXCONNECTSPEED, p); /* Attribute value: TX Connect speed */ + + return pppol2tp_udp_send(l2tp, pb); +} + +/* Send a ZLB ACK packet */ +static err_t pppol2tp_send_zlb(pppol2tp_pcb *l2tp, u16_t ns, u16_t nr) { + struct pbuf *pb; + u8_t *p; + u16_t len; + + /* calculate UDP packet length */ + len = 12; + + /* allocate a buffer */ + pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); + if (pb == NULL) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + p = (u8_t*)pb->payload; + /* fill in pkt */ + /* L2TP control header */ + PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); + PUTSHORT(len, p); /* Length */ + PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ + PUTSHORT(0, p); /* Session Id */ + PUTSHORT(ns, p); /* NS Sequence number - to peer */ + PUTSHORT(nr, p); /* NR Sequence number - expected for peer */ + + return pppol2tp_udp_send(l2tp, pb); +} + +/* Send a StopCCN packet */ +static err_t pppol2tp_send_stopccn(pppol2tp_pcb *l2tp, u16_t ns) { + struct pbuf *pb; + u8_t *p; + u16_t len; + + /* calculate UDP packet length */ + len = 12 +8 +8 +8; + + /* allocate a buffer */ + pb = pbuf_alloc(PBUF_TRANSPORT, len, PBUF_RAM); + if (pb == NULL) { + return ERR_MEM; + } + LWIP_ASSERT("pb->tot_len == pb->len", pb->tot_len == pb->len); + + p = (u8_t*)pb->payload; + /* fill in pkt */ + /* L2TP control header */ + PUTSHORT(PPPOL2TP_HEADERFLAG_CONTROL_MANDATORY, p); + PUTSHORT(len, p); /* Length */ + PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ + PUTSHORT(0, p); /* Session Id */ + PUTSHORT(ns, p); /* NS Sequence number - to peer */ + PUTSHORT(l2tp->peer_ns, p); /* NR Sequence number - expected for peer */ + + /* AVP - Message type */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_MESSAGE, p); /* Attribute type: Message Type */ + PUTSHORT(PPPOL2TP_MESSAGETYPE_STOPCCN, p); /* Attribute value: Message type: StopCCN */ + + /* AVP - Assign tunnel ID */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_TUNNELID, p); /* Attribute type: Tunnel ID */ + PUTSHORT(l2tp->remote_tunnel_id, p); /* Attribute value: Tunnel ID */ + + /* AVP - Result code */ + PUTSHORT(PPPOL2TP_AVPHEADERFLAG_MANDATORY + 8, p); /* Mandatory flag + len field */ + PUTSHORT(0, p); /* Vendor ID */ + PUTSHORT(PPPOL2TP_AVPTYPE_RESULTCODE, p); /* Attribute type: Result code */ + PUTSHORT(PPPOL2TP_RESULTCODE, p); /* Attribute value: Result code */ + + return pppol2tp_udp_send(l2tp, pb); +} + +static err_t pppol2tp_xmit(pppol2tp_pcb *l2tp, struct pbuf *pb) { + u8_t *p; + + /* make room for L2TP header - should not fail */ + if (pbuf_add_header(pb, PPPOL2TP_OUTPUT_DATA_HEADER_LEN) != 0) { + /* bail out */ + PPPDEBUG(LOG_ERR, ("pppol2tp: pppol2tp_pcb: could not allocate room for L2TP header\n")); + LINK_STATS_INC(link.lenerr); + pbuf_free(pb); + return ERR_BUF; + } + + p = (u8_t*)pb->payload; + PUTSHORT(PPPOL2TP_HEADERFLAG_DATA_MANDATORY, p); + PUTSHORT(l2tp->source_tunnel_id, p); /* Tunnel Id */ + PUTSHORT(l2tp->source_session_id, p); /* Session Id */ + + return pppol2tp_udp_send(l2tp, pb); +} + +static err_t pppol2tp_udp_send(pppol2tp_pcb *l2tp, struct pbuf *pb) { + err_t err; + if (l2tp->netif) { + err = udp_sendto_if(l2tp->udp, pb, &l2tp->remote_ip, l2tp->tunnel_port, l2tp->netif); + } else { + err = udp_sendto(l2tp->udp, pb, &l2tp->remote_ip, l2tp->tunnel_port); + } + pbuf_free(pb); + return err; +} + +#endif /* PPP_SUPPORT && PPPOL2TP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppos.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppos.c index d10dd8e4..dff02554 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppos.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/pppos.c @@ -1,895 +1,895 @@ -/** - * @file - * Network Point to Point Protocol over Serial file. - * - */ - -/* - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PPPOS_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include - -#include "lwip/arch.h" -#include "lwip/err.h" -#include "lwip/pbuf.h" -#include "lwip/sys.h" -#include "lwip/memp.h" -#include "lwip/netif.h" -#include "lwip/snmp.h" -#include "lwip/priv/tcpip_priv.h" -#include "lwip/api.h" -#include "lwip/ip4.h" /* for ip4_input() */ - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/pppos.h" -#include "netif/ppp/vj.h" - -/* Memory pool */ -LWIP_MEMPOOL_DECLARE(PPPOS_PCB, MEMP_NUM_PPPOS_INTERFACES, sizeof(pppos_pcb), "PPPOS_PCB") - -/* callbacks called from PPP core */ -static err_t pppos_write(ppp_pcb *ppp, void *ctx, struct pbuf *p); -static err_t pppos_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *pb, u16_t protocol); -static void pppos_connect(ppp_pcb *ppp, void *ctx); -#if PPP_SERVER -static void pppos_listen(ppp_pcb *ppp, void *ctx); -#endif /* PPP_SERVER */ -static void pppos_disconnect(ppp_pcb *ppp, void *ctx); -static err_t pppos_destroy(ppp_pcb *ppp, void *ctx); -static void pppos_send_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp); -static void pppos_recv_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp); - -/* Prototypes for procedures local to this file. */ -#if PPP_INPROC_IRQ_SAFE -static void pppos_input_callback(void *arg); -#endif /* PPP_INPROC_IRQ_SAFE */ -static void pppos_input_free_current_packet(pppos_pcb *pppos); -static void pppos_input_drop(pppos_pcb *pppos); -static err_t pppos_output_append(pppos_pcb *pppos, err_t err, struct pbuf *nb, u8_t c, u8_t accm, u16_t *fcs); -static err_t pppos_output_last(pppos_pcb *pppos, err_t err, struct pbuf *nb, u16_t *fcs); - -/* Callbacks structure for PPP core */ -static const struct link_callbacks pppos_callbacks = { - pppos_connect, -#if PPP_SERVER - pppos_listen, -#endif /* PPP_SERVER */ - pppos_disconnect, - pppos_destroy, - pppos_write, - pppos_netif_output, - pppos_send_config, - pppos_recv_config -}; - -/* PPP's Asynchronous-Control-Character-Map. The mask array is used - * to select the specific bit for a character. */ -#define ESCAPE_P(accm, c) ((accm)[(c) >> 3] & 1 << (c & 0x07)) - -#if PPP_FCS_TABLE -/* - * FCS lookup table as calculated by genfcstab. - */ -static const u16_t fcstab[256] = { - 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, - 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, - 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, - 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, - 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, - 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, - 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, - 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, - 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, - 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, - 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, - 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, - 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, - 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, - 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, - 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, - 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, - 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, - 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, - 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, - 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, - 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, - 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, - 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, - 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, - 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, - 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, - 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, - 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, - 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, - 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, - 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 -}; -#define PPP_FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff]) -#else /* PPP_FCS_TABLE */ -/* The HDLC polynomial: X**0 + X**5 + X**12 + X**16 (0x8408) */ -#define PPP_FCS_POLYNOMIAL 0x8408 -static u16_t -ppp_get_fcs(u8_t byte) -{ - unsigned int octet; - int bit; - octet = byte; - for (bit = 8; bit-- > 0; ) { - octet = (octet & 0x01) ? ((octet >> 1) ^ PPP_FCS_POLYNOMIAL) : (octet >> 1); - } - return octet & 0xffff; -} -#define PPP_FCS(fcs, c) (((fcs) >> 8) ^ ppp_get_fcs(((fcs) ^ (c)) & 0xff)) -#endif /* PPP_FCS_TABLE */ - -/* - * Values for FCS calculations. - */ -#define PPP_INITFCS 0xffff /* Initial FCS value */ -#define PPP_GOODFCS 0xf0b8 /* Good final FCS value */ - -#if PPP_INPROC_IRQ_SAFE -#define PPPOS_DECL_PROTECT(lev) SYS_ARCH_DECL_PROTECT(lev) -#define PPPOS_PROTECT(lev) SYS_ARCH_PROTECT(lev) -#define PPPOS_UNPROTECT(lev) SYS_ARCH_UNPROTECT(lev) -#else -#define PPPOS_DECL_PROTECT(lev) -#define PPPOS_PROTECT(lev) -#define PPPOS_UNPROTECT(lev) -#endif /* PPP_INPROC_IRQ_SAFE */ - - -/* - * Create a new PPP connection using the given serial I/O device. - * - * Return 0 on success, an error code on failure. - */ -ppp_pcb *pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, - ppp_link_status_cb_fn link_status_cb, void *ctx_cb) -{ - pppos_pcb *pppos; - ppp_pcb *ppp; - LWIP_ASSERT_CORE_LOCKED(); - - pppos = (pppos_pcb *)LWIP_MEMPOOL_ALLOC(PPPOS_PCB); - if (pppos == NULL) { - return NULL; - } - - ppp = ppp_new(pppif, &pppos_callbacks, pppos, link_status_cb, ctx_cb); - if (ppp == NULL) { - LWIP_MEMPOOL_FREE(PPPOS_PCB, pppos); - return NULL; - } - - memset(pppos, 0, sizeof(pppos_pcb)); - pppos->ppp = ppp; - pppos->output_cb = output_cb; - return ppp; -} - -/* Called by PPP core */ -static err_t -pppos_write(ppp_pcb *ppp, void *ctx, struct pbuf *p) -{ - pppos_pcb *pppos = (pppos_pcb *)ctx; - u8_t *s; - struct pbuf *nb; - u16_t n; - u16_t fcs_out; - err_t err; - LWIP_UNUSED_ARG(ppp); - - /* Grab an output buffer. Using PBUF_POOL here for tx is ok since the pbuf - gets freed by 'pppos_output_last' before this function returns and thus - cannot starve rx. */ - nb = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL); - if (nb == NULL) { - PPPDEBUG(LOG_WARNING, ("pppos_write[%d]: alloc fail\n", ppp->netif->num)); - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - pbuf_free(p); - return ERR_MEM; - } - - /* Set nb->tot_len to actual payload length */ - nb->tot_len = p->len; - - /* If the link has been idle, we'll send a fresh flag character to - * flush any noise. */ - err = ERR_OK; - if ((sys_now() - pppos->last_xmit) >= PPP_MAXIDLEFLAG) { - err = pppos_output_append(pppos, err, nb, PPP_FLAG, 0, NULL); - } - - /* Load output buffer. */ - fcs_out = PPP_INITFCS; - s = (u8_t*)p->payload; - n = p->len; - while (n-- > 0) { - err = pppos_output_append(pppos, err, nb, *s++, 1, &fcs_out); - } - - err = pppos_output_last(pppos, err, nb, &fcs_out); - if (err == ERR_OK) { - PPPDEBUG(LOG_INFO, ("pppos_write[%d]: len=%d\n", ppp->netif->num, p->len)); - } else { - PPPDEBUG(LOG_WARNING, ("pppos_write[%d]: output failed len=%d\n", ppp->netif->num, p->len)); - } - pbuf_free(p); - return err; -} - -/* Called by PPP core */ -static err_t -pppos_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *pb, u16_t protocol) -{ - pppos_pcb *pppos = (pppos_pcb *)ctx; - struct pbuf *nb, *p; - u16_t fcs_out; - err_t err; - LWIP_UNUSED_ARG(ppp); - - /* Grab an output buffer. Using PBUF_POOL here for tx is ok since the pbuf - gets freed by 'pppos_output_last' before this function returns and thus - cannot starve rx. */ - nb = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL); - if (nb == NULL) { - PPPDEBUG(LOG_WARNING, ("pppos_netif_output[%d]: alloc fail\n", ppp->netif->num)); - LINK_STATS_INC(link.memerr); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - return ERR_MEM; - } - - /* Set nb->tot_len to actual payload length */ - nb->tot_len = pb->tot_len; - - /* If the link has been idle, we'll send a fresh flag character to - * flush any noise. */ - err = ERR_OK; - if ((sys_now() - pppos->last_xmit) >= PPP_MAXIDLEFLAG) { - err = pppos_output_append(pppos, err, nb, PPP_FLAG, 0, NULL); - } - - fcs_out = PPP_INITFCS; - if (!pppos->accomp) { - err = pppos_output_append(pppos, err, nb, PPP_ALLSTATIONS, 1, &fcs_out); - err = pppos_output_append(pppos, err, nb, PPP_UI, 1, &fcs_out); - } - if (!pppos->pcomp || protocol > 0xFF) { - err = pppos_output_append(pppos, err, nb, (protocol >> 8) & 0xFF, 1, &fcs_out); - } - err = pppos_output_append(pppos, err, nb, protocol & 0xFF, 1, &fcs_out); - - /* Load packet. */ - for(p = pb; p; p = p->next) { - u16_t n = p->len; - u8_t *s = (u8_t*)p->payload; - - while (n-- > 0) { - err = pppos_output_append(pppos, err, nb, *s++, 1, &fcs_out); - } - } - - err = pppos_output_last(pppos, err, nb, &fcs_out); - if (err == ERR_OK) { - PPPDEBUG(LOG_INFO, ("pppos_netif_output[%d]: proto=0x%"X16_F", len = %d\n", ppp->netif->num, protocol, pb->tot_len)); - } else { - PPPDEBUG(LOG_WARNING, ("pppos_netif_output[%d]: output failed proto=0x%"X16_F", len = %d\n", ppp->netif->num, protocol, pb->tot_len)); - } - return err; -} - -static void -pppos_connect(ppp_pcb *ppp, void *ctx) -{ - pppos_pcb *pppos = (pppos_pcb *)ctx; - PPPOS_DECL_PROTECT(lev); - -#if PPP_INPROC_IRQ_SAFE - /* input pbuf left over from last session? */ - pppos_input_free_current_packet(pppos); -#endif /* PPP_INPROC_IRQ_SAFE */ - - /* reset PPPoS control block to its initial state */ - memset(&pppos->last_xmit, 0, sizeof(pppos_pcb) - offsetof(pppos_pcb, last_xmit)); - - /* - * Default the in and out accm so that escape and flag characters - * are always escaped. - */ - pppos->in_accm[15] = 0x60; /* no need to protect since RX is not running */ - pppos->out_accm[15] = 0x60; - PPPOS_PROTECT(lev); - pppos->open = 1; - PPPOS_UNPROTECT(lev); - - /* - * Start the connection and handle incoming events (packet or timeout). - */ - PPPDEBUG(LOG_INFO, ("pppos_connect: unit %d: connecting\n", ppp->netif->num)); - ppp_start(ppp); /* notify upper layers */ -} - -#if PPP_SERVER -static void -pppos_listen(ppp_pcb *ppp, void *ctx) -{ - pppos_pcb *pppos = (pppos_pcb *)ctx; - PPPOS_DECL_PROTECT(lev); - -#if PPP_INPROC_IRQ_SAFE - /* input pbuf left over from last session? */ - pppos_input_free_current_packet(pppos); -#endif /* PPP_INPROC_IRQ_SAFE */ - - /* reset PPPoS control block to its initial state */ - memset(&pppos->last_xmit, 0, sizeof(pppos_pcb) - offsetof(pppos_pcb, last_xmit)); - - /* - * Default the in and out accm so that escape and flag characters - * are always escaped. - */ - pppos->in_accm[15] = 0x60; /* no need to protect since RX is not running */ - pppos->out_accm[15] = 0x60; - PPPOS_PROTECT(lev); - pppos->open = 1; - PPPOS_UNPROTECT(lev); - - /* - * Wait for something to happen. - */ - PPPDEBUG(LOG_INFO, ("pppos_listen: unit %d: listening\n", ppp->netif->num)); - ppp_start(ppp); /* notify upper layers */ -} -#endif /* PPP_SERVER */ - -static void -pppos_disconnect(ppp_pcb *ppp, void *ctx) -{ - pppos_pcb *pppos = (pppos_pcb *)ctx; - PPPOS_DECL_PROTECT(lev); - - PPPOS_PROTECT(lev); - pppos->open = 0; - PPPOS_UNPROTECT(lev); - - /* If PPP_INPROC_IRQ_SAFE is used we cannot call - * pppos_input_free_current_packet() here because - * rx IRQ might still call pppos_input(). - */ -#if !PPP_INPROC_IRQ_SAFE - /* input pbuf left ? */ - pppos_input_free_current_packet(pppos); -#endif /* !PPP_INPROC_IRQ_SAFE */ - - ppp_link_end(ppp); /* notify upper layers */ -} - -static err_t -pppos_destroy(ppp_pcb *ppp, void *ctx) -{ - pppos_pcb *pppos = (pppos_pcb *)ctx; - LWIP_UNUSED_ARG(ppp); - -#if PPP_INPROC_IRQ_SAFE - /* input pbuf left ? */ - pppos_input_free_current_packet(pppos); -#endif /* PPP_INPROC_IRQ_SAFE */ - - LWIP_MEMPOOL_FREE(PPPOS_PCB, pppos); - return ERR_OK; -} - -#if !NO_SYS && !PPP_INPROC_IRQ_SAFE -/** Pass received raw characters to PPPoS to be decoded through lwIP TCPIP thread. - * - * This is one of the only functions that may be called outside of the TCPIP thread! - * - * @param ppp PPP descriptor index, returned by pppos_create() - * @param s received data - * @param l length of received data - */ -err_t -pppos_input_tcpip(ppp_pcb *ppp, u8_t *s, int l) -{ - struct pbuf *p; - err_t err; - - p = pbuf_alloc(PBUF_RAW, l, PBUF_POOL); - if (!p) { - return ERR_MEM; - } - pbuf_take(p, s, l); - - err = tcpip_inpkt(p, ppp_netif(ppp), pppos_input_sys); - if (err != ERR_OK) { - pbuf_free(p); - } - return err; -} - -/* called from TCPIP thread */ -err_t pppos_input_sys(struct pbuf *p, struct netif *inp) { - ppp_pcb *ppp = (ppp_pcb*)inp->state; - struct pbuf *n; - LWIP_ASSERT_CORE_LOCKED(); - - for (n = p; n; n = n->next) { - pppos_input(ppp, (u8_t*)n->payload, n->len); - } - pbuf_free(p); - return ERR_OK; -} -#endif /* !NO_SYS && !PPP_INPROC_IRQ_SAFE */ - -/** PPPoS input helper struct, must be packed since it is stored - * to pbuf->payload, which might be unaligned. */ -#if PPP_INPROC_IRQ_SAFE -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct pppos_input_header { - PACK_STRUCT_FIELD(ppp_pcb *ppp); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif -#endif /* PPP_INPROC_IRQ_SAFE */ - -/** Pass received raw characters to PPPoS to be decoded. - * - * @param ppp PPP descriptor index, returned by pppos_create() - * @param s received data - * @param l length of received data - */ -void -pppos_input(ppp_pcb *ppp, u8_t *s, int l) -{ - pppos_pcb *pppos = (pppos_pcb *)ppp->link_ctx_cb; - struct pbuf *next_pbuf; - u8_t cur_char; - u8_t escaped; - PPPOS_DECL_PROTECT(lev); -#if !PPP_INPROC_IRQ_SAFE - LWIP_ASSERT_CORE_LOCKED(); -#endif - - PPPDEBUG(LOG_DEBUG, ("pppos_input[%d]: got %d bytes\n", ppp->netif->num, l)); - while (l-- > 0) { - cur_char = *s++; - - PPPOS_PROTECT(lev); - /* ppp_input can disconnect the interface, we need to abort to prevent a memory - * leak if there are remaining bytes because pppos_connect and pppos_listen - * functions expect input buffer to be free. Furthermore there are no real - * reason to continue reading bytes if we are disconnected. - */ - if (!pppos->open) { - PPPOS_UNPROTECT(lev); - return; - } - escaped = ESCAPE_P(pppos->in_accm, cur_char); - PPPOS_UNPROTECT(lev); - /* Handle special characters. */ - if (escaped) { - /* Check for escape sequences. */ - /* XXX Note that this does not handle an escaped 0x5d character which - * would appear as an escape character. Since this is an ASCII ']' - * and there is no reason that I know of to escape it, I won't complicate - * the code to handle this case. GLL */ - if (cur_char == PPP_ESCAPE) { - pppos->in_escaped = 1; - /* Check for the flag character. */ - } else if (cur_char == PPP_FLAG) { - /* If this is just an extra flag character, ignore it. */ - if (pppos->in_state <= PDADDRESS) { - /* ignore it */; - /* If we haven't received the packet header, drop what has come in. */ - } else if (pppos->in_state < PDDATA) { - PPPDEBUG(LOG_WARNING, - ("pppos_input[%d]: Dropping incomplete packet %d\n", - ppp->netif->num, pppos->in_state)); - LINK_STATS_INC(link.lenerr); - pppos_input_drop(pppos); - /* If the fcs is invalid, drop the packet. */ - } else if (pppos->in_fcs != PPP_GOODFCS) { - PPPDEBUG(LOG_INFO, - ("pppos_input[%d]: Dropping bad fcs 0x%"X16_F" proto=0x%"X16_F"\n", - ppp->netif->num, pppos->in_fcs, pppos->in_protocol)); - /* Note: If you get lots of these, check for UART frame errors or try different baud rate */ - LINK_STATS_INC(link.chkerr); - pppos_input_drop(pppos); - /* Otherwise it's a good packet so pass it on. */ - } else { - struct pbuf *inp; - /* Trim off the checksum. */ - if(pppos->in_tail->len > 2) { - pppos->in_tail->len -= 2; - - pppos->in_tail->tot_len = pppos->in_tail->len; - if (pppos->in_tail != pppos->in_head) { - pbuf_cat(pppos->in_head, pppos->in_tail); - } - } else { - pppos->in_tail->tot_len = pppos->in_tail->len; - if (pppos->in_tail != pppos->in_head) { - pbuf_cat(pppos->in_head, pppos->in_tail); - } - - pbuf_realloc(pppos->in_head, pppos->in_head->tot_len - 2); - } - - /* Dispatch the packet thereby consuming it. */ - inp = pppos->in_head; - /* Packet consumed, release our references. */ - pppos->in_head = NULL; - pppos->in_tail = NULL; -#if IP_FORWARD || LWIP_IPV6_FORWARD - /* hide the room for Ethernet forwarding header */ - pbuf_remove_header(inp, PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN); -#endif /* IP_FORWARD || LWIP_IPV6_FORWARD */ -#if PPP_INPROC_IRQ_SAFE - if(tcpip_try_callback(pppos_input_callback, inp) != ERR_OK) { - PPPDEBUG(LOG_ERR, ("pppos_input[%d]: tcpip_callback() failed, dropping packet\n", ppp->netif->num)); - pbuf_free(inp); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(ppp->netif, ifindiscards); - } -#else /* PPP_INPROC_IRQ_SAFE */ - ppp_input(ppp, inp); -#endif /* PPP_INPROC_IRQ_SAFE */ - } - - /* Prepare for a new packet. */ - pppos->in_fcs = PPP_INITFCS; - pppos->in_state = PDADDRESS; - pppos->in_escaped = 0; - /* Other characters are usually control characters that may have - * been inserted by the physical layer so here we just drop them. */ - } else { - PPPDEBUG(LOG_WARNING, - ("pppos_input[%d]: Dropping ACCM char <%d>\n", ppp->netif->num, cur_char)); - } - /* Process other characters. */ - } else { - /* Unencode escaped characters. */ - if (pppos->in_escaped) { - pppos->in_escaped = 0; - cur_char ^= PPP_TRANS; - } - - /* Process character relative to current state. */ - switch(pppos->in_state) { - case PDIDLE: /* Idle state - waiting. */ - /* Drop the character if it's not 0xff - * we would have processed a flag character above. */ - if (cur_char != PPP_ALLSTATIONS) { - break; - } - /* no break */ - /* Fall through */ - - case PDSTART: /* Process start flag. */ - /* Prepare for a new packet. */ - pppos->in_fcs = PPP_INITFCS; - /* no break */ - /* Fall through */ - - case PDADDRESS: /* Process address field. */ - if (cur_char == PPP_ALLSTATIONS) { - pppos->in_state = PDCONTROL; - break; - } - /* no break */ - - /* Else assume compressed address and control fields so - * fall through to get the protocol... */ - /* Fall through */ - case PDCONTROL: /* Process control field. */ - /* If we don't get a valid control code, restart. */ - if (cur_char == PPP_UI) { - pppos->in_state = PDPROTOCOL1; - break; - } - /* no break */ - -#if 0 - else { - PPPDEBUG(LOG_WARNING, - ("pppos_input[%d]: Invalid control <%d>\n", ppp->netif->num, cur_char)); - pppos->in_state = PDSTART; - } -#endif - /* Fall through */ - - case PDPROTOCOL1: /* Process protocol field 1. */ - /* If the lower bit is set, this is the end of the protocol - * field. */ - if (cur_char & 1) { - pppos->in_protocol = cur_char; - pppos->in_state = PDDATA; - } else { - pppos->in_protocol = (u16_t)cur_char << 8; - pppos->in_state = PDPROTOCOL2; - } - break; - case PDPROTOCOL2: /* Process protocol field 2. */ - pppos->in_protocol |= cur_char; - pppos->in_state = PDDATA; - break; - case PDDATA: /* Process data byte. */ - /* Make space to receive processed data. */ - if (pppos->in_tail == NULL || pppos->in_tail->len == PBUF_POOL_BUFSIZE) { - u16_t pbuf_alloc_len; - if (pppos->in_tail != NULL) { - pppos->in_tail->tot_len = pppos->in_tail->len; - if (pppos->in_tail != pppos->in_head) { - pbuf_cat(pppos->in_head, pppos->in_tail); - /* give up the in_tail reference now */ - pppos->in_tail = NULL; - } - } - /* If we haven't started a packet, we need a packet header. */ - pbuf_alloc_len = 0; -#if IP_FORWARD || LWIP_IPV6_FORWARD - /* If IP forwarding is enabled we are reserving PBUF_LINK_ENCAPSULATION_HLEN - * + PBUF_LINK_HLEN bytes so the packet is being allocated with enough header - * space to be forwarded (to Ethernet for example). - */ - if (pppos->in_head == NULL) { - pbuf_alloc_len = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN; - } -#endif /* IP_FORWARD || LWIP_IPV6_FORWARD */ - next_pbuf = pbuf_alloc(PBUF_RAW, pbuf_alloc_len, PBUF_POOL); - if (next_pbuf == NULL) { - /* No free buffers. Drop the input packet and let the - * higher layers deal with it. Continue processing - * the received pbuf chain in case a new packet starts. */ - PPPDEBUG(LOG_ERR, ("pppos_input[%d]: NO FREE PBUFS!\n", ppp->netif->num)); - LINK_STATS_INC(link.memerr); - pppos_input_drop(pppos); - pppos->in_state = PDSTART; /* Wait for flag sequence. */ - break; - } - if (pppos->in_head == NULL) { - u8_t *payload = ((u8_t*)next_pbuf->payload) + pbuf_alloc_len; -#if PPP_INPROC_IRQ_SAFE - ((struct pppos_input_header*)payload)->ppp = ppp; - payload += sizeof(struct pppos_input_header); - next_pbuf->len += sizeof(struct pppos_input_header); -#endif /* PPP_INPROC_IRQ_SAFE */ - next_pbuf->len += sizeof(pppos->in_protocol); - *(payload++) = pppos->in_protocol >> 8; - *(payload) = pppos->in_protocol & 0xFF; - pppos->in_head = next_pbuf; - } - pppos->in_tail = next_pbuf; - } - /* Load character into buffer. */ - ((u8_t*)pppos->in_tail->payload)[pppos->in_tail->len++] = cur_char; - break; - default: - break; - } - - /* update the frame check sequence number. */ - pppos->in_fcs = PPP_FCS(pppos->in_fcs, cur_char); - } - } /* while (l-- > 0), all bytes processed */ -} - -#if PPP_INPROC_IRQ_SAFE -/* PPPoS input callback using one input pointer - */ -static void pppos_input_callback(void *arg) { - struct pbuf *pb = (struct pbuf*)arg; - ppp_pcb *ppp; - - ppp = ((struct pppos_input_header*)pb->payload)->ppp; - if(pbuf_remove_header(pb, sizeof(struct pppos_input_header))) { - LWIP_ASSERT("pbuf_remove_header failed\n", 0); - goto drop; - } - - /* Dispatch the packet thereby consuming it. */ - ppp_input(ppp, pb); - return; - -drop: - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(ppp->netif, ifindiscards); - pbuf_free(pb); -} -#endif /* PPP_INPROC_IRQ_SAFE */ - -static void -pppos_send_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp) -{ - int i; - pppos_pcb *pppos = (pppos_pcb *)ctx; - LWIP_UNUSED_ARG(ppp); - - pppos->pcomp = pcomp; - pppos->accomp = accomp; - - /* Load the ACCM bits for the 32 control codes. */ - for (i = 0; i < 32/8; i++) { - pppos->out_accm[i] = (u8_t)((accm >> (8 * i)) & 0xFF); - } - - PPPDEBUG(LOG_INFO, ("pppos_send_config[%d]: out_accm=%X %X %X %X\n", - pppos->ppp->netif->num, - pppos->out_accm[0], pppos->out_accm[1], pppos->out_accm[2], pppos->out_accm[3])); -} - -static void -pppos_recv_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp) -{ - int i; - pppos_pcb *pppos = (pppos_pcb *)ctx; - PPPOS_DECL_PROTECT(lev); - LWIP_UNUSED_ARG(ppp); - LWIP_UNUSED_ARG(pcomp); - LWIP_UNUSED_ARG(accomp); - - /* Load the ACCM bits for the 32 control codes. */ - PPPOS_PROTECT(lev); - for (i = 0; i < 32 / 8; i++) { - pppos->in_accm[i] = (u8_t)(accm >> (i * 8)); - } - PPPOS_UNPROTECT(lev); - - PPPDEBUG(LOG_INFO, ("pppos_recv_config[%d]: in_accm=%X %X %X %X\n", - pppos->ppp->netif->num, - pppos->in_accm[0], pppos->in_accm[1], pppos->in_accm[2], pppos->in_accm[3])); -} - -/* - * Drop the input packet. - */ -static void -pppos_input_free_current_packet(pppos_pcb *pppos) -{ - if (pppos->in_head != NULL) { - if (pppos->in_tail && (pppos->in_tail != pppos->in_head)) { - pbuf_free(pppos->in_tail); - } - pbuf_free(pppos->in_head); - pppos->in_head = NULL; - } - pppos->in_tail = NULL; -} - -/* - * Drop the input packet and increase error counters. - */ -static void -pppos_input_drop(pppos_pcb *pppos) -{ - if (pppos->in_head != NULL) { -#if 0 - PPPDEBUG(LOG_INFO, ("pppos_input_drop: %d:%.*H\n", pppos->in_head->len, min(60, pppos->in_head->len * 2), pppos->in_head->payload)); -#endif - PPPDEBUG(LOG_INFO, ("pppos_input_drop: pbuf len=%d, addr %p\n", pppos->in_head->len, (void*)pppos->in_head)); - } - pppos_input_free_current_packet(pppos); -#if VJ_SUPPORT - vj_uncompress_err(&pppos->ppp->vj_comp); -#endif /* VJ_SUPPORT */ - - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(pppos->ppp->netif, ifindiscards); -} - -/* - * pppos_output_append - append given character to end of given pbuf. - * If out_accm is not 0 and the character needs to be escaped, do so. - * If pbuf is full, send the pbuf and reuse it. - * Return the current pbuf. - */ -static err_t -pppos_output_append(pppos_pcb *pppos, err_t err, struct pbuf *nb, u8_t c, u8_t accm, u16_t *fcs) -{ - if (err != ERR_OK) { - return err; - } - - /* Make sure there is room for the character and an escape code. - * Sure we don't quite fill the buffer if the character doesn't - * get escaped but is one character worth complicating this? */ - if ((PBUF_POOL_BUFSIZE - nb->len) < 2) { - u32_t l = pppos->output_cb(pppos->ppp, (u8_t*)nb->payload, nb->len, pppos->ppp->ctx_cb); - if (l != nb->len) { - return ERR_IF; - } - nb->len = 0; - } - - /* Update FCS before checking for special characters. */ - if (fcs) { - *fcs = PPP_FCS(*fcs, c); - } - - /* Copy to output buffer escaping special characters. */ - if (accm && ESCAPE_P(pppos->out_accm, c)) { - *((u8_t*)nb->payload + nb->len++) = PPP_ESCAPE; - *((u8_t*)nb->payload + nb->len++) = c ^ PPP_TRANS; - } else { - *((u8_t*)nb->payload + nb->len++) = c; - } - - return ERR_OK; -} - -static err_t -pppos_output_last(pppos_pcb *pppos, err_t err, struct pbuf *nb, u16_t *fcs) -{ - ppp_pcb *ppp = pppos->ppp; - - /* Add FCS and trailing flag. */ - err = pppos_output_append(pppos, err, nb, ~(*fcs) & 0xFF, 1, NULL); - err = pppos_output_append(pppos, err, nb, (~(*fcs) >> 8) & 0xFF, 1, NULL); - err = pppos_output_append(pppos, err, nb, PPP_FLAG, 0, NULL); - - if (err != ERR_OK) { - goto failed; - } - - /* Send remaining buffer if not empty */ - if (nb->len > 0) { - u32_t l = pppos->output_cb(ppp, (u8_t*)nb->payload, nb->len, ppp->ctx_cb); - if (l != nb->len) { - err = ERR_IF; - goto failed; - } - } - - pppos->last_xmit = sys_now(); - MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, nb->tot_len); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); - LINK_STATS_INC(link.xmit); - pbuf_free(nb); - return ERR_OK; - -failed: - pppos->last_xmit = 0; /* prepend PPP_FLAG to next packet */ - LINK_STATS_INC(link.err); - LINK_STATS_INC(link.drop); - MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); - pbuf_free(nb); - return err; -} - -#endif /* PPP_SUPPORT && PPPOS_SUPPORT */ +/** + * @file + * Network Point to Point Protocol over Serial file. + * + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PPPOS_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include + +#include "lwip/arch.h" +#include "lwip/err.h" +#include "lwip/pbuf.h" +#include "lwip/sys.h" +#include "lwip/memp.h" +#include "lwip/netif.h" +#include "lwip/snmp.h" +#include "lwip/priv/tcpip_priv.h" +#include "lwip/api.h" +#include "lwip/ip4.h" /* for ip4_input() */ + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/pppos.h" +#include "netif/ppp/vj.h" + +/* Memory pool */ +LWIP_MEMPOOL_DECLARE(PPPOS_PCB, MEMP_NUM_PPPOS_INTERFACES, sizeof(pppos_pcb), "PPPOS_PCB") + +/* callbacks called from PPP core */ +static err_t pppos_write(ppp_pcb *ppp, void *ctx, struct pbuf *p); +static err_t pppos_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *pb, u16_t protocol); +static void pppos_connect(ppp_pcb *ppp, void *ctx); +#if PPP_SERVER +static void pppos_listen(ppp_pcb *ppp, void *ctx); +#endif /* PPP_SERVER */ +static void pppos_disconnect(ppp_pcb *ppp, void *ctx); +static err_t pppos_destroy(ppp_pcb *ppp, void *ctx); +static void pppos_send_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp); +static void pppos_recv_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp); + +/* Prototypes for procedures local to this file. */ +#if PPP_INPROC_IRQ_SAFE +static void pppos_input_callback(void *arg); +#endif /* PPP_INPROC_IRQ_SAFE */ +static void pppos_input_free_current_packet(pppos_pcb *pppos); +static void pppos_input_drop(pppos_pcb *pppos); +static err_t pppos_output_append(pppos_pcb *pppos, err_t err, struct pbuf *nb, u8_t c, u8_t accm, u16_t *fcs); +static err_t pppos_output_last(pppos_pcb *pppos, err_t err, struct pbuf *nb, u16_t *fcs); + +/* Callbacks structure for PPP core */ +static const struct link_callbacks pppos_callbacks = { + pppos_connect, +#if PPP_SERVER + pppos_listen, +#endif /* PPP_SERVER */ + pppos_disconnect, + pppos_destroy, + pppos_write, + pppos_netif_output, + pppos_send_config, + pppos_recv_config +}; + +/* PPP's Asynchronous-Control-Character-Map. The mask array is used + * to select the specific bit for a character. */ +#define ESCAPE_P(accm, c) ((accm)[(c) >> 3] & 1 << (c & 0x07)) + +#if PPP_FCS_TABLE +/* + * FCS lookup table as calculated by genfcstab. + */ +static const u16_t fcstab[256] = { + 0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, + 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, + 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, + 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, + 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, + 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, + 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, + 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, + 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, + 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, + 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, + 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, + 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, + 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, + 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, + 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, + 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, + 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, + 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, + 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, + 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, + 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, + 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, + 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, + 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, + 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, + 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, + 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, + 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, + 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, + 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, + 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78 +}; +#define PPP_FCS(fcs, c) (((fcs) >> 8) ^ fcstab[((fcs) ^ (c)) & 0xff]) +#else /* PPP_FCS_TABLE */ +/* The HDLC polynomial: X**0 + X**5 + X**12 + X**16 (0x8408) */ +#define PPP_FCS_POLYNOMIAL 0x8408 +static u16_t +ppp_get_fcs(u8_t byte) +{ + unsigned int octet; + int bit; + octet = byte; + for (bit = 8; bit-- > 0; ) { + octet = (octet & 0x01) ? ((octet >> 1) ^ PPP_FCS_POLYNOMIAL) : (octet >> 1); + } + return octet & 0xffff; +} +#define PPP_FCS(fcs, c) (((fcs) >> 8) ^ ppp_get_fcs(((fcs) ^ (c)) & 0xff)) +#endif /* PPP_FCS_TABLE */ + +/* + * Values for FCS calculations. + */ +#define PPP_INITFCS 0xffff /* Initial FCS value */ +#define PPP_GOODFCS 0xf0b8 /* Good final FCS value */ + +#if PPP_INPROC_IRQ_SAFE +#define PPPOS_DECL_PROTECT(lev) SYS_ARCH_DECL_PROTECT(lev) +#define PPPOS_PROTECT(lev) SYS_ARCH_PROTECT(lev) +#define PPPOS_UNPROTECT(lev) SYS_ARCH_UNPROTECT(lev) +#else +#define PPPOS_DECL_PROTECT(lev) +#define PPPOS_PROTECT(lev) +#define PPPOS_UNPROTECT(lev) +#endif /* PPP_INPROC_IRQ_SAFE */ + + +/* + * Create a new PPP connection using the given serial I/O device. + * + * Return 0 on success, an error code on failure. + */ +ppp_pcb *pppos_create(struct netif *pppif, pppos_output_cb_fn output_cb, + ppp_link_status_cb_fn link_status_cb, void *ctx_cb) +{ + pppos_pcb *pppos; + ppp_pcb *ppp; + LWIP_ASSERT_CORE_LOCKED(); + + pppos = (pppos_pcb *)LWIP_MEMPOOL_ALLOC(PPPOS_PCB); + if (pppos == NULL) { + return NULL; + } + + ppp = ppp_new(pppif, &pppos_callbacks, pppos, link_status_cb, ctx_cb); + if (ppp == NULL) { + LWIP_MEMPOOL_FREE(PPPOS_PCB, pppos); + return NULL; + } + + memset(pppos, 0, sizeof(pppos_pcb)); + pppos->ppp = ppp; + pppos->output_cb = output_cb; + return ppp; +} + +/* Called by PPP core */ +static err_t +pppos_write(ppp_pcb *ppp, void *ctx, struct pbuf *p) +{ + pppos_pcb *pppos = (pppos_pcb *)ctx; + u8_t *s; + struct pbuf *nb; + u16_t n; + u16_t fcs_out; + err_t err; + LWIP_UNUSED_ARG(ppp); + + /* Grab an output buffer. Using PBUF_POOL here for tx is ok since the pbuf + gets freed by 'pppos_output_last' before this function returns and thus + cannot starve rx. */ + nb = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL); + if (nb == NULL) { + PPPDEBUG(LOG_WARNING, ("pppos_write[%d]: alloc fail\n", ppp->netif->num)); + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + pbuf_free(p); + return ERR_MEM; + } + + /* Set nb->tot_len to actual payload length */ + nb->tot_len = p->len; + + /* If the link has been idle, we'll send a fresh flag character to + * flush any noise. */ + err = ERR_OK; + if ((sys_now() - pppos->last_xmit) >= PPP_MAXIDLEFLAG) { + err = pppos_output_append(pppos, err, nb, PPP_FLAG, 0, NULL); + } + + /* Load output buffer. */ + fcs_out = PPP_INITFCS; + s = (u8_t*)p->payload; + n = p->len; + while (n-- > 0) { + err = pppos_output_append(pppos, err, nb, *s++, 1, &fcs_out); + } + + err = pppos_output_last(pppos, err, nb, &fcs_out); + if (err == ERR_OK) { + PPPDEBUG(LOG_INFO, ("pppos_write[%d]: len=%d\n", ppp->netif->num, p->len)); + } else { + PPPDEBUG(LOG_WARNING, ("pppos_write[%d]: output failed len=%d\n", ppp->netif->num, p->len)); + } + pbuf_free(p); + return err; +} + +/* Called by PPP core */ +static err_t +pppos_netif_output(ppp_pcb *ppp, void *ctx, struct pbuf *pb, u16_t protocol) +{ + pppos_pcb *pppos = (pppos_pcb *)ctx; + struct pbuf *nb, *p; + u16_t fcs_out; + err_t err; + LWIP_UNUSED_ARG(ppp); + + /* Grab an output buffer. Using PBUF_POOL here for tx is ok since the pbuf + gets freed by 'pppos_output_last' before this function returns and thus + cannot starve rx. */ + nb = pbuf_alloc(PBUF_RAW, 0, PBUF_POOL); + if (nb == NULL) { + PPPDEBUG(LOG_WARNING, ("pppos_netif_output[%d]: alloc fail\n", ppp->netif->num)); + LINK_STATS_INC(link.memerr); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + return ERR_MEM; + } + + /* Set nb->tot_len to actual payload length */ + nb->tot_len = pb->tot_len; + + /* If the link has been idle, we'll send a fresh flag character to + * flush any noise. */ + err = ERR_OK; + if ((sys_now() - pppos->last_xmit) >= PPP_MAXIDLEFLAG) { + err = pppos_output_append(pppos, err, nb, PPP_FLAG, 0, NULL); + } + + fcs_out = PPP_INITFCS; + if (!pppos->accomp) { + err = pppos_output_append(pppos, err, nb, PPP_ALLSTATIONS, 1, &fcs_out); + err = pppos_output_append(pppos, err, nb, PPP_UI, 1, &fcs_out); + } + if (!pppos->pcomp || protocol > 0xFF) { + err = pppos_output_append(pppos, err, nb, (protocol >> 8) & 0xFF, 1, &fcs_out); + } + err = pppos_output_append(pppos, err, nb, protocol & 0xFF, 1, &fcs_out); + + /* Load packet. */ + for(p = pb; p; p = p->next) { + u16_t n = p->len; + u8_t *s = (u8_t*)p->payload; + + while (n-- > 0) { + err = pppos_output_append(pppos, err, nb, *s++, 1, &fcs_out); + } + } + + err = pppos_output_last(pppos, err, nb, &fcs_out); + if (err == ERR_OK) { + PPPDEBUG(LOG_INFO, ("pppos_netif_output[%d]: proto=0x%"X16_F", len = %d\n", ppp->netif->num, protocol, pb->tot_len)); + } else { + PPPDEBUG(LOG_WARNING, ("pppos_netif_output[%d]: output failed proto=0x%"X16_F", len = %d\n", ppp->netif->num, protocol, pb->tot_len)); + } + return err; +} + +static void +pppos_connect(ppp_pcb *ppp, void *ctx) +{ + pppos_pcb *pppos = (pppos_pcb *)ctx; + PPPOS_DECL_PROTECT(lev); + +#if PPP_INPROC_IRQ_SAFE + /* input pbuf left over from last session? */ + pppos_input_free_current_packet(pppos); +#endif /* PPP_INPROC_IRQ_SAFE */ + + /* reset PPPoS control block to its initial state */ + memset(&pppos->last_xmit, 0, sizeof(pppos_pcb) - offsetof(pppos_pcb, last_xmit)); + + /* + * Default the in and out accm so that escape and flag characters + * are always escaped. + */ + pppos->in_accm[15] = 0x60; /* no need to protect since RX is not running */ + pppos->out_accm[15] = 0x60; + PPPOS_PROTECT(lev); + pppos->open = 1; + PPPOS_UNPROTECT(lev); + + /* + * Start the connection and handle incoming events (packet or timeout). + */ + PPPDEBUG(LOG_INFO, ("pppos_connect: unit %d: connecting\n", ppp->netif->num)); + ppp_start(ppp); /* notify upper layers */ +} + +#if PPP_SERVER +static void +pppos_listen(ppp_pcb *ppp, void *ctx) +{ + pppos_pcb *pppos = (pppos_pcb *)ctx; + PPPOS_DECL_PROTECT(lev); + +#if PPP_INPROC_IRQ_SAFE + /* input pbuf left over from last session? */ + pppos_input_free_current_packet(pppos); +#endif /* PPP_INPROC_IRQ_SAFE */ + + /* reset PPPoS control block to its initial state */ + memset(&pppos->last_xmit, 0, sizeof(pppos_pcb) - offsetof(pppos_pcb, last_xmit)); + + /* + * Default the in and out accm so that escape and flag characters + * are always escaped. + */ + pppos->in_accm[15] = 0x60; /* no need to protect since RX is not running */ + pppos->out_accm[15] = 0x60; + PPPOS_PROTECT(lev); + pppos->open = 1; + PPPOS_UNPROTECT(lev); + + /* + * Wait for something to happen. + */ + PPPDEBUG(LOG_INFO, ("pppos_listen: unit %d: listening\n", ppp->netif->num)); + ppp_start(ppp); /* notify upper layers */ +} +#endif /* PPP_SERVER */ + +static void +pppos_disconnect(ppp_pcb *ppp, void *ctx) +{ + pppos_pcb *pppos = (pppos_pcb *)ctx; + PPPOS_DECL_PROTECT(lev); + + PPPOS_PROTECT(lev); + pppos->open = 0; + PPPOS_UNPROTECT(lev); + + /* If PPP_INPROC_IRQ_SAFE is used we cannot call + * pppos_input_free_current_packet() here because + * rx IRQ might still call pppos_input(). + */ +#if !PPP_INPROC_IRQ_SAFE + /* input pbuf left ? */ + pppos_input_free_current_packet(pppos); +#endif /* !PPP_INPROC_IRQ_SAFE */ + + ppp_link_end(ppp); /* notify upper layers */ +} + +static err_t +pppos_destroy(ppp_pcb *ppp, void *ctx) +{ + pppos_pcb *pppos = (pppos_pcb *)ctx; + LWIP_UNUSED_ARG(ppp); + +#if PPP_INPROC_IRQ_SAFE + /* input pbuf left ? */ + pppos_input_free_current_packet(pppos); +#endif /* PPP_INPROC_IRQ_SAFE */ + + LWIP_MEMPOOL_FREE(PPPOS_PCB, pppos); + return ERR_OK; +} + +#if !NO_SYS && !PPP_INPROC_IRQ_SAFE +/** Pass received raw characters to PPPoS to be decoded through lwIP TCPIP thread. + * + * This is one of the only functions that may be called outside of the TCPIP thread! + * + * @param ppp PPP descriptor index, returned by pppos_create() + * @param s received data + * @param l length of received data + */ +err_t +pppos_input_tcpip(ppp_pcb *ppp, u8_t *s, int l) +{ + struct pbuf *p; + err_t err; + + p = pbuf_alloc(PBUF_RAW, l, PBUF_POOL); + if (!p) { + return ERR_MEM; + } + pbuf_take(p, s, l); + + err = tcpip_inpkt(p, ppp_netif(ppp), pppos_input_sys); + if (err != ERR_OK) { + pbuf_free(p); + } + return err; +} + +/* called from TCPIP thread */ +err_t pppos_input_sys(struct pbuf *p, struct netif *inp) { + ppp_pcb *ppp = (ppp_pcb*)inp->state; + struct pbuf *n; + LWIP_ASSERT_CORE_LOCKED(); + + for (n = p; n; n = n->next) { + pppos_input(ppp, (u8_t*)n->payload, n->len); + } + pbuf_free(p); + return ERR_OK; +} +#endif /* !NO_SYS && !PPP_INPROC_IRQ_SAFE */ + +/** PPPoS input helper struct, must be packed since it is stored + * to pbuf->payload, which might be unaligned. */ +#if PPP_INPROC_IRQ_SAFE +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct pppos_input_header { + PACK_STRUCT_FIELD(ppp_pcb *ppp); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif +#endif /* PPP_INPROC_IRQ_SAFE */ + +/** Pass received raw characters to PPPoS to be decoded. + * + * @param ppp PPP descriptor index, returned by pppos_create() + * @param s received data + * @param l length of received data + */ +void +pppos_input(ppp_pcb *ppp, u8_t *s, int l) +{ + pppos_pcb *pppos = (pppos_pcb *)ppp->link_ctx_cb; + struct pbuf *next_pbuf; + u8_t cur_char; + u8_t escaped; + PPPOS_DECL_PROTECT(lev); +#if !PPP_INPROC_IRQ_SAFE + LWIP_ASSERT_CORE_LOCKED(); +#endif + + PPPDEBUG(LOG_DEBUG, ("pppos_input[%d]: got %d bytes\n", ppp->netif->num, l)); + while (l-- > 0) { + cur_char = *s++; + + PPPOS_PROTECT(lev); + /* ppp_input can disconnect the interface, we need to abort to prevent a memory + * leak if there are remaining bytes because pppos_connect and pppos_listen + * functions expect input buffer to be free. Furthermore there are no real + * reason to continue reading bytes if we are disconnected. + */ + if (!pppos->open) { + PPPOS_UNPROTECT(lev); + return; + } + escaped = ESCAPE_P(pppos->in_accm, cur_char); + PPPOS_UNPROTECT(lev); + /* Handle special characters. */ + if (escaped) { + /* Check for escape sequences. */ + /* XXX Note that this does not handle an escaped 0x5d character which + * would appear as an escape character. Since this is an ASCII ']' + * and there is no reason that I know of to escape it, I won't complicate + * the code to handle this case. GLL */ + if (cur_char == PPP_ESCAPE) { + pppos->in_escaped = 1; + /* Check for the flag character. */ + } else if (cur_char == PPP_FLAG) { + /* If this is just an extra flag character, ignore it. */ + if (pppos->in_state <= PDADDRESS) { + /* ignore it */; + /* If we haven't received the packet header, drop what has come in. */ + } else if (pppos->in_state < PDDATA) { + PPPDEBUG(LOG_WARNING, + ("pppos_input[%d]: Dropping incomplete packet %d\n", + ppp->netif->num, pppos->in_state)); + LINK_STATS_INC(link.lenerr); + pppos_input_drop(pppos); + /* If the fcs is invalid, drop the packet. */ + } else if (pppos->in_fcs != PPP_GOODFCS) { + PPPDEBUG(LOG_INFO, + ("pppos_input[%d]: Dropping bad fcs 0x%"X16_F" proto=0x%"X16_F"\n", + ppp->netif->num, pppos->in_fcs, pppos->in_protocol)); + /* Note: If you get lots of these, check for UART frame errors or try different baud rate */ + LINK_STATS_INC(link.chkerr); + pppos_input_drop(pppos); + /* Otherwise it's a good packet so pass it on. */ + } else { + struct pbuf *inp; + /* Trim off the checksum. */ + if(pppos->in_tail->len > 2) { + pppos->in_tail->len -= 2; + + pppos->in_tail->tot_len = pppos->in_tail->len; + if (pppos->in_tail != pppos->in_head) { + pbuf_cat(pppos->in_head, pppos->in_tail); + } + } else { + pppos->in_tail->tot_len = pppos->in_tail->len; + if (pppos->in_tail != pppos->in_head) { + pbuf_cat(pppos->in_head, pppos->in_tail); + } + + pbuf_realloc(pppos->in_head, pppos->in_head->tot_len - 2); + } + + /* Dispatch the packet thereby consuming it. */ + inp = pppos->in_head; + /* Packet consumed, release our references. */ + pppos->in_head = NULL; + pppos->in_tail = NULL; +#if IP_FORWARD || LWIP_IPV6_FORWARD + /* hide the room for Ethernet forwarding header */ + pbuf_remove_header(inp, PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN); +#endif /* IP_FORWARD || LWIP_IPV6_FORWARD */ +#if PPP_INPROC_IRQ_SAFE + if(tcpip_try_callback(pppos_input_callback, inp) != ERR_OK) { + PPPDEBUG(LOG_ERR, ("pppos_input[%d]: tcpip_callback() failed, dropping packet\n", ppp->netif->num)); + pbuf_free(inp); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(ppp->netif, ifindiscards); + } +#else /* PPP_INPROC_IRQ_SAFE */ + ppp_input(ppp, inp); +#endif /* PPP_INPROC_IRQ_SAFE */ + } + + /* Prepare for a new packet. */ + pppos->in_fcs = PPP_INITFCS; + pppos->in_state = PDADDRESS; + pppos->in_escaped = 0; + /* Other characters are usually control characters that may have + * been inserted by the physical layer so here we just drop them. */ + } else { + PPPDEBUG(LOG_WARNING, + ("pppos_input[%d]: Dropping ACCM char <%d>\n", ppp->netif->num, cur_char)); + } + /* Process other characters. */ + } else { + /* Unencode escaped characters. */ + if (pppos->in_escaped) { + pppos->in_escaped = 0; + cur_char ^= PPP_TRANS; + } + + /* Process character relative to current state. */ + switch(pppos->in_state) { + case PDIDLE: /* Idle state - waiting. */ + /* Drop the character if it's not 0xff + * we would have processed a flag character above. */ + if (cur_char != PPP_ALLSTATIONS) { + break; + } + /* no break */ + /* Fall through */ + + case PDSTART: /* Process start flag. */ + /* Prepare for a new packet. */ + pppos->in_fcs = PPP_INITFCS; + /* no break */ + /* Fall through */ + + case PDADDRESS: /* Process address field. */ + if (cur_char == PPP_ALLSTATIONS) { + pppos->in_state = PDCONTROL; + break; + } + /* no break */ + + /* Else assume compressed address and control fields so + * fall through to get the protocol... */ + /* Fall through */ + case PDCONTROL: /* Process control field. */ + /* If we don't get a valid control code, restart. */ + if (cur_char == PPP_UI) { + pppos->in_state = PDPROTOCOL1; + break; + } + /* no break */ + +#if 0 + else { + PPPDEBUG(LOG_WARNING, + ("pppos_input[%d]: Invalid control <%d>\n", ppp->netif->num, cur_char)); + pppos->in_state = PDSTART; + } +#endif + /* Fall through */ + + case PDPROTOCOL1: /* Process protocol field 1. */ + /* If the lower bit is set, this is the end of the protocol + * field. */ + if (cur_char & 1) { + pppos->in_protocol = cur_char; + pppos->in_state = PDDATA; + } else { + pppos->in_protocol = (u16_t)cur_char << 8; + pppos->in_state = PDPROTOCOL2; + } + break; + case PDPROTOCOL2: /* Process protocol field 2. */ + pppos->in_protocol |= cur_char; + pppos->in_state = PDDATA; + break; + case PDDATA: /* Process data byte. */ + /* Make space to receive processed data. */ + if (pppos->in_tail == NULL || pppos->in_tail->len == PBUF_POOL_BUFSIZE) { + u16_t pbuf_alloc_len; + if (pppos->in_tail != NULL) { + pppos->in_tail->tot_len = pppos->in_tail->len; + if (pppos->in_tail != pppos->in_head) { + pbuf_cat(pppos->in_head, pppos->in_tail); + /* give up the in_tail reference now */ + pppos->in_tail = NULL; + } + } + /* If we haven't started a packet, we need a packet header. */ + pbuf_alloc_len = 0; +#if IP_FORWARD || LWIP_IPV6_FORWARD + /* If IP forwarding is enabled we are reserving PBUF_LINK_ENCAPSULATION_HLEN + * + PBUF_LINK_HLEN bytes so the packet is being allocated with enough header + * space to be forwarded (to Ethernet for example). + */ + if (pppos->in_head == NULL) { + pbuf_alloc_len = PBUF_LINK_ENCAPSULATION_HLEN + PBUF_LINK_HLEN; + } +#endif /* IP_FORWARD || LWIP_IPV6_FORWARD */ + next_pbuf = pbuf_alloc(PBUF_RAW, pbuf_alloc_len, PBUF_POOL); + if (next_pbuf == NULL) { + /* No free buffers. Drop the input packet and let the + * higher layers deal with it. Continue processing + * the received pbuf chain in case a new packet starts. */ + PPPDEBUG(LOG_ERR, ("pppos_input[%d]: NO FREE PBUFS!\n", ppp->netif->num)); + LINK_STATS_INC(link.memerr); + pppos_input_drop(pppos); + pppos->in_state = PDSTART; /* Wait for flag sequence. */ + break; + } + if (pppos->in_head == NULL) { + u8_t *payload = ((u8_t*)next_pbuf->payload) + pbuf_alloc_len; +#if PPP_INPROC_IRQ_SAFE + ((struct pppos_input_header*)payload)->ppp = ppp; + payload += sizeof(struct pppos_input_header); + next_pbuf->len += sizeof(struct pppos_input_header); +#endif /* PPP_INPROC_IRQ_SAFE */ + next_pbuf->len += sizeof(pppos->in_protocol); + *(payload++) = pppos->in_protocol >> 8; + *(payload) = pppos->in_protocol & 0xFF; + pppos->in_head = next_pbuf; + } + pppos->in_tail = next_pbuf; + } + /* Load character into buffer. */ + ((u8_t*)pppos->in_tail->payload)[pppos->in_tail->len++] = cur_char; + break; + default: + break; + } + + /* update the frame check sequence number. */ + pppos->in_fcs = PPP_FCS(pppos->in_fcs, cur_char); + } + } /* while (l-- > 0), all bytes processed */ +} + +#if PPP_INPROC_IRQ_SAFE +/* PPPoS input callback using one input pointer + */ +static void pppos_input_callback(void *arg) { + struct pbuf *pb = (struct pbuf*)arg; + ppp_pcb *ppp; + + ppp = ((struct pppos_input_header*)pb->payload)->ppp; + if(pbuf_remove_header(pb, sizeof(struct pppos_input_header))) { + LWIP_ASSERT("pbuf_remove_header failed\n", 0); + goto drop; + } + + /* Dispatch the packet thereby consuming it. */ + ppp_input(ppp, pb); + return; + +drop: + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(ppp->netif, ifindiscards); + pbuf_free(pb); +} +#endif /* PPP_INPROC_IRQ_SAFE */ + +static void +pppos_send_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp) +{ + int i; + pppos_pcb *pppos = (pppos_pcb *)ctx; + LWIP_UNUSED_ARG(ppp); + + pppos->pcomp = pcomp; + pppos->accomp = accomp; + + /* Load the ACCM bits for the 32 control codes. */ + for (i = 0; i < 32/8; i++) { + pppos->out_accm[i] = (u8_t)((accm >> (8 * i)) & 0xFF); + } + + PPPDEBUG(LOG_INFO, ("pppos_send_config[%d]: out_accm=%X %X %X %X\n", + pppos->ppp->netif->num, + pppos->out_accm[0], pppos->out_accm[1], pppos->out_accm[2], pppos->out_accm[3])); +} + +static void +pppos_recv_config(ppp_pcb *ppp, void *ctx, u32_t accm, int pcomp, int accomp) +{ + int i; + pppos_pcb *pppos = (pppos_pcb *)ctx; + PPPOS_DECL_PROTECT(lev); + LWIP_UNUSED_ARG(ppp); + LWIP_UNUSED_ARG(pcomp); + LWIP_UNUSED_ARG(accomp); + + /* Load the ACCM bits for the 32 control codes. */ + PPPOS_PROTECT(lev); + for (i = 0; i < 32 / 8; i++) { + pppos->in_accm[i] = (u8_t)(accm >> (i * 8)); + } + PPPOS_UNPROTECT(lev); + + PPPDEBUG(LOG_INFO, ("pppos_recv_config[%d]: in_accm=%X %X %X %X\n", + pppos->ppp->netif->num, + pppos->in_accm[0], pppos->in_accm[1], pppos->in_accm[2], pppos->in_accm[3])); +} + +/* + * Drop the input packet. + */ +static void +pppos_input_free_current_packet(pppos_pcb *pppos) +{ + if (pppos->in_head != NULL) { + if (pppos->in_tail && (pppos->in_tail != pppos->in_head)) { + pbuf_free(pppos->in_tail); + } + pbuf_free(pppos->in_head); + pppos->in_head = NULL; + } + pppos->in_tail = NULL; +} + +/* + * Drop the input packet and increase error counters. + */ +static void +pppos_input_drop(pppos_pcb *pppos) +{ + if (pppos->in_head != NULL) { +#if 0 + PPPDEBUG(LOG_INFO, ("pppos_input_drop: %d:%.*H\n", pppos->in_head->len, min(60, pppos->in_head->len * 2), pppos->in_head->payload)); +#endif + PPPDEBUG(LOG_INFO, ("pppos_input_drop: pbuf len=%d, addr %p\n", pppos->in_head->len, (void*)pppos->in_head)); + } + pppos_input_free_current_packet(pppos); +#if VJ_SUPPORT + vj_uncompress_err(&pppos->ppp->vj_comp); +#endif /* VJ_SUPPORT */ + + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(pppos->ppp->netif, ifindiscards); +} + +/* + * pppos_output_append - append given character to end of given pbuf. + * If out_accm is not 0 and the character needs to be escaped, do so. + * If pbuf is full, send the pbuf and reuse it. + * Return the current pbuf. + */ +static err_t +pppos_output_append(pppos_pcb *pppos, err_t err, struct pbuf *nb, u8_t c, u8_t accm, u16_t *fcs) +{ + if (err != ERR_OK) { + return err; + } + + /* Make sure there is room for the character and an escape code. + * Sure we don't quite fill the buffer if the character doesn't + * get escaped but is one character worth complicating this? */ + if ((PBUF_POOL_BUFSIZE - nb->len) < 2) { + u32_t l = pppos->output_cb(pppos->ppp, (u8_t*)nb->payload, nb->len, pppos->ppp->ctx_cb); + if (l != nb->len) { + return ERR_IF; + } + nb->len = 0; + } + + /* Update FCS before checking for special characters. */ + if (fcs) { + *fcs = PPP_FCS(*fcs, c); + } + + /* Copy to output buffer escaping special characters. */ + if (accm && ESCAPE_P(pppos->out_accm, c)) { + *((u8_t*)nb->payload + nb->len++) = PPP_ESCAPE; + *((u8_t*)nb->payload + nb->len++) = c ^ PPP_TRANS; + } else { + *((u8_t*)nb->payload + nb->len++) = c; + } + + return ERR_OK; +} + +static err_t +pppos_output_last(pppos_pcb *pppos, err_t err, struct pbuf *nb, u16_t *fcs) +{ + ppp_pcb *ppp = pppos->ppp; + + /* Add FCS and trailing flag. */ + err = pppos_output_append(pppos, err, nb, ~(*fcs) & 0xFF, 1, NULL); + err = pppos_output_append(pppos, err, nb, (~(*fcs) >> 8) & 0xFF, 1, NULL); + err = pppos_output_append(pppos, err, nb, PPP_FLAG, 0, NULL); + + if (err != ERR_OK) { + goto failed; + } + + /* Send remaining buffer if not empty */ + if (nb->len > 0) { + u32_t l = pppos->output_cb(ppp, (u8_t*)nb->payload, nb->len, ppp->ctx_cb); + if (l != nb->len) { + err = ERR_IF; + goto failed; + } + } + + pppos->last_xmit = sys_now(); + MIB2_STATS_NETIF_ADD(ppp->netif, ifoutoctets, nb->tot_len); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutucastpkts); + LINK_STATS_INC(link.xmit); + pbuf_free(nb); + return ERR_OK; + +failed: + pppos->last_xmit = 0; /* prepend PPP_FLAG to next packet */ + LINK_STATS_INC(link.err); + LINK_STATS_INC(link.drop); + MIB2_STATS_NETIF_INC(ppp->netif, ifoutdiscards); + pbuf_free(nb); + return err; +} + +#endif /* PPP_SUPPORT && PPPOS_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/upap.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/upap.c index 709c2d65..3b2399dc 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/upap.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/upap.c @@ -1,677 +1,677 @@ -/* - * upap.c - User/Password Authentication Protocol. - * - * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to - * endorse or promote products derived from this software without - * prior written permission. For permission or any legal - * details, please contact - * Office of Technology Transfer - * Carnegie Mellon University - * 5000 Forbes Avenue - * Pittsburgh, PA 15213-3890 - * (412) 268-4387, fax: (412) 268-7395 - * tech-transfer@andrew.cmu.edu - * - * 4. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Computing Services - * at Carnegie Mellon University (http://www.cmu.edu/computing/)." - * - * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE - * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && PAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -/* - * @todo: - */ - -#if 0 /* UNUSED */ -#include -#include -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/upap.h" - -#if PPP_OPTIONS -/* - * Command-line options. - */ -static option_t pap_option_list[] = { - { "hide-password", o_bool, &hide_password, - "Don't output passwords to log", OPT_PRIO | 1 }, - { "show-password", o_bool, &hide_password, - "Show password string in debug log messages", OPT_PRIOSUB | 0 }, - - { "pap-restart", o_int, &upap[0].us_timeouttime, - "Set retransmit timeout for PAP", OPT_PRIO }, - { "pap-max-authreq", o_int, &upap[0].us_maxtransmits, - "Set max number of transmissions for auth-reqs", OPT_PRIO }, - { "pap-timeout", o_int, &upap[0].us_reqtimeout, - "Set time limit for peer PAP authentication", OPT_PRIO }, - - { NULL } -}; -#endif /* PPP_OPTIONS */ - -/* - * Protocol entry points. - */ -static void upap_init(ppp_pcb *pcb); -static void upap_lowerup(ppp_pcb *pcb); -static void upap_lowerdown(ppp_pcb *pcb); -static void upap_input(ppp_pcb *pcb, u_char *inpacket, int l); -static void upap_protrej(ppp_pcb *pcb); -#if PRINTPKT_SUPPORT -static int upap_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg); -#endif /* PRINTPKT_SUPPORT */ - -const struct protent pap_protent = { - PPP_PAP, - upap_init, - upap_input, - upap_protrej, - upap_lowerup, - upap_lowerdown, - NULL, - NULL, -#if PRINTPKT_SUPPORT - upap_printpkt, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_DATAINPUT - NULL, -#endif /* PPP_DATAINPUT */ -#if PRINTPKT_SUPPORT - "PAP", - NULL, -#endif /* PRINTPKT_SUPPORT */ -#if PPP_OPTIONS - pap_option_list, - NULL, -#endif /* PPP_OPTIONS */ -#if DEMAND_SUPPORT - NULL, - NULL -#endif /* DEMAND_SUPPORT */ -}; - -static void upap_timeout(void *arg); -#if PPP_SERVER -static void upap_reqtimeout(void *arg); -static void upap_rauthreq(ppp_pcb *pcb, u_char *inp, int id, int len); -#endif /* PPP_SERVER */ -static void upap_rauthack(ppp_pcb *pcb, u_char *inp, int id, int len); -static void upap_rauthnak(ppp_pcb *pcb, u_char *inp, int id, int len); -static void upap_sauthreq(ppp_pcb *pcb); -#if PPP_SERVER -static void upap_sresp(ppp_pcb *pcb, u_char code, u_char id, const char *msg, int msglen); -#endif /* PPP_SERVER */ - - -/* - * upap_init - Initialize a UPAP unit. - */ -static void upap_init(ppp_pcb *pcb) { - pcb->upap.us_user = NULL; - pcb->upap.us_userlen = 0; - pcb->upap.us_passwd = NULL; - pcb->upap.us_passwdlen = 0; - pcb->upap.us_clientstate = UPAPCS_INITIAL; -#if PPP_SERVER - pcb->upap.us_serverstate = UPAPSS_INITIAL; -#endif /* PPP_SERVER */ - pcb->upap.us_id = 0; -} - - -/* - * upap_authwithpeer - Authenticate us with our peer (start client). - * - * Set new state and send authenticate's. - */ -void upap_authwithpeer(ppp_pcb *pcb, const char *user, const char *password) { - - if(!user || !password) - return; - - /* Save the username and password we're given */ - pcb->upap.us_user = user; - pcb->upap.us_userlen = (u8_t)LWIP_MIN(strlen(user), 0xff); - pcb->upap.us_passwd = password; - pcb->upap.us_passwdlen = (u8_t)LWIP_MIN(strlen(password), 0xff); - pcb->upap.us_transmits = 0; - - /* Lower layer up yet? */ - if (pcb->upap.us_clientstate == UPAPCS_INITIAL || - pcb->upap.us_clientstate == UPAPCS_PENDING) { - pcb->upap.us_clientstate = UPAPCS_PENDING; - return; - } - - upap_sauthreq(pcb); /* Start protocol */ -} - -#if PPP_SERVER -/* - * upap_authpeer - Authenticate our peer (start server). - * - * Set new state. - */ -void upap_authpeer(ppp_pcb *pcb) { - - /* Lower layer up yet? */ - if (pcb->upap.us_serverstate == UPAPSS_INITIAL || - pcb->upap.us_serverstate == UPAPSS_PENDING) { - pcb->upap.us_serverstate = UPAPSS_PENDING; - return; - } - - pcb->upap.us_serverstate = UPAPSS_LISTEN; - if (pcb->settings.pap_req_timeout > 0) - TIMEOUT(upap_reqtimeout, pcb, pcb->settings.pap_req_timeout); -} -#endif /* PPP_SERVER */ - -/* - * upap_timeout - Retransmission timer for sending auth-reqs expired. - */ -static void upap_timeout(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - - if (pcb->upap.us_clientstate != UPAPCS_AUTHREQ) - return; - - if (pcb->upap.us_transmits >= pcb->settings.pap_max_transmits) { - /* give up in disgust */ - ppp_error("No response to PAP authenticate-requests"); - pcb->upap.us_clientstate = UPAPCS_BADAUTH; - auth_withpeer_fail(pcb, PPP_PAP); - return; - } - - upap_sauthreq(pcb); /* Send Authenticate-Request */ -} - - -#if PPP_SERVER -/* - * upap_reqtimeout - Give up waiting for the peer to send an auth-req. - */ -static void upap_reqtimeout(void *arg) { - ppp_pcb *pcb = (ppp_pcb*)arg; - - if (pcb->upap.us_serverstate != UPAPSS_LISTEN) - return; /* huh?? */ - - auth_peer_fail(pcb, PPP_PAP); - pcb->upap.us_serverstate = UPAPSS_BADAUTH; -} -#endif /* PPP_SERVER */ - - -/* - * upap_lowerup - The lower layer is up. - * - * Start authenticating if pending. - */ -static void upap_lowerup(ppp_pcb *pcb) { - - if (pcb->upap.us_clientstate == UPAPCS_INITIAL) - pcb->upap.us_clientstate = UPAPCS_CLOSED; - else if (pcb->upap.us_clientstate == UPAPCS_PENDING) { - upap_sauthreq(pcb); /* send an auth-request */ - } - -#if PPP_SERVER - if (pcb->upap.us_serverstate == UPAPSS_INITIAL) - pcb->upap.us_serverstate = UPAPSS_CLOSED; - else if (pcb->upap.us_serverstate == UPAPSS_PENDING) { - pcb->upap.us_serverstate = UPAPSS_LISTEN; - if (pcb->settings.pap_req_timeout > 0) - TIMEOUT(upap_reqtimeout, pcb, pcb->settings.pap_req_timeout); - } -#endif /* PPP_SERVER */ -} - - -/* - * upap_lowerdown - The lower layer is down. - * - * Cancel all timeouts. - */ -static void upap_lowerdown(ppp_pcb *pcb) { - - if (pcb->upap.us_clientstate == UPAPCS_AUTHREQ) /* Timeout pending? */ - UNTIMEOUT(upap_timeout, pcb); /* Cancel timeout */ -#if PPP_SERVER - if (pcb->upap.us_serverstate == UPAPSS_LISTEN && pcb->settings.pap_req_timeout > 0) - UNTIMEOUT(upap_reqtimeout, pcb); -#endif /* PPP_SERVER */ - - pcb->upap.us_clientstate = UPAPCS_INITIAL; -#if PPP_SERVER - pcb->upap.us_serverstate = UPAPSS_INITIAL; -#endif /* PPP_SERVER */ -} - - -/* - * upap_protrej - Peer doesn't speak this protocol. - * - * This shouldn't happen. In any case, pretend lower layer went down. - */ -static void upap_protrej(ppp_pcb *pcb) { - - if (pcb->upap.us_clientstate == UPAPCS_AUTHREQ) { - ppp_error("PAP authentication failed due to protocol-reject"); - auth_withpeer_fail(pcb, PPP_PAP); - } -#if PPP_SERVER - if (pcb->upap.us_serverstate == UPAPSS_LISTEN) { - ppp_error("PAP authentication of peer failed (protocol-reject)"); - auth_peer_fail(pcb, PPP_PAP); - } -#endif /* PPP_SERVER */ - upap_lowerdown(pcb); -} - - -/* - * upap_input - Input UPAP packet. - */ -static void upap_input(ppp_pcb *pcb, u_char *inpacket, int l) { - u_char *inp; - u_char code, id; - int len; - - /* - * Parse header (code, id and length). - * If packet too short, drop it. - */ - inp = inpacket; - if (l < UPAP_HEADERLEN) { - UPAPDEBUG(("pap_input: rcvd short header.")); - return; - } - GETCHAR(code, inp); - GETCHAR(id, inp); - GETSHORT(len, inp); - if (len < UPAP_HEADERLEN) { - UPAPDEBUG(("pap_input: rcvd illegal length.")); - return; - } - if (len > l) { - UPAPDEBUG(("pap_input: rcvd short packet.")); - return; - } - len -= UPAP_HEADERLEN; - - /* - * Action depends on code. - */ - switch (code) { - case UPAP_AUTHREQ: -#if PPP_SERVER - upap_rauthreq(pcb, inp, id, len); -#endif /* PPP_SERVER */ - break; - - case UPAP_AUTHACK: - upap_rauthack(pcb, inp, id, len); - break; - - case UPAP_AUTHNAK: - upap_rauthnak(pcb, inp, id, len); - break; - - default: /* XXX Need code reject */ - break; - } -} - -#if PPP_SERVER -/* - * upap_rauth - Receive Authenticate. - */ -static void upap_rauthreq(ppp_pcb *pcb, u_char *inp, int id, int len) { - u_char ruserlen, rpasswdlen; - char *ruser; - char *rpasswd; - char rhostname[256]; - int retcode; - const char *msg; - int msglen; - - if (pcb->upap.us_serverstate < UPAPSS_LISTEN) - return; - - /* - * If we receive a duplicate authenticate-request, we are - * supposed to return the same status as for the first request. - */ - if (pcb->upap.us_serverstate == UPAPSS_OPEN) { - upap_sresp(pcb, UPAP_AUTHACK, id, "", 0); /* return auth-ack */ - return; - } - if (pcb->upap.us_serverstate == UPAPSS_BADAUTH) { - upap_sresp(pcb, UPAP_AUTHNAK, id, "", 0); /* return auth-nak */ - return; - } - - /* - * Parse user/passwd. - */ - if (len < 1) { - UPAPDEBUG(("pap_rauth: rcvd short packet.")); - return; - } - GETCHAR(ruserlen, inp); - len -= sizeof (u_char) + ruserlen + sizeof (u_char); - if (len < 0) { - UPAPDEBUG(("pap_rauth: rcvd short packet.")); - return; - } - ruser = (char *) inp; - INCPTR(ruserlen, inp); - GETCHAR(rpasswdlen, inp); - if (len < rpasswdlen) { - UPAPDEBUG(("pap_rauth: rcvd short packet.")); - return; - } - - rpasswd = (char *) inp; - - /* - * Check the username and password given. - */ - retcode = UPAP_AUTHNAK; - if (auth_check_passwd(pcb, ruser, ruserlen, rpasswd, rpasswdlen, &msg, &msglen)) { - retcode = UPAP_AUTHACK; - } - BZERO(rpasswd, rpasswdlen); - -#if 0 /* UNUSED */ - /* - * Check remote number authorization. A plugin may have filled in - * the remote number or added an allowed number, and rather than - * return an authenticate failure, is leaving it for us to verify. - */ - if (retcode == UPAP_AUTHACK) { - if (!auth_number()) { - /* We do not want to leak info about the pap result. */ - retcode = UPAP_AUTHNAK; /* XXX exit value will be "wrong" */ - warn("calling number %q is not authorized", remote_number); - } - } - - msglen = strlen(msg); - if (msglen > 255) - msglen = 255; -#endif /* UNUSED */ - - upap_sresp(pcb, retcode, id, msg, msglen); - - /* Null terminate and clean remote name. */ - ppp_slprintf(rhostname, sizeof(rhostname), "%.*v", ruserlen, ruser); - - if (retcode == UPAP_AUTHACK) { - pcb->upap.us_serverstate = UPAPSS_OPEN; - ppp_notice("PAP peer authentication succeeded for %q", rhostname); - auth_peer_success(pcb, PPP_PAP, 0, ruser, ruserlen); - } else { - pcb->upap.us_serverstate = UPAPSS_BADAUTH; - ppp_warn("PAP peer authentication failed for %q", rhostname); - auth_peer_fail(pcb, PPP_PAP); - } - - if (pcb->settings.pap_req_timeout > 0) - UNTIMEOUT(upap_reqtimeout, pcb); -} -#endif /* PPP_SERVER */ - -/* - * upap_rauthack - Receive Authenticate-Ack. - */ -static void upap_rauthack(ppp_pcb *pcb, u_char *inp, int id, int len) { - u_char msglen; - char *msg; - LWIP_UNUSED_ARG(id); - - if (pcb->upap.us_clientstate != UPAPCS_AUTHREQ) /* XXX */ - return; - - /* - * Parse message. - */ - if (len < 1) { - UPAPDEBUG(("pap_rauthack: ignoring missing msg-length.")); - } else { - GETCHAR(msglen, inp); - if (msglen > 0) { - len -= sizeof (u_char); - if (len < msglen) { - UPAPDEBUG(("pap_rauthack: rcvd short packet.")); - return; - } - msg = (char *) inp; - PRINTMSG(msg, msglen); - } - } - - pcb->upap.us_clientstate = UPAPCS_OPEN; - - auth_withpeer_success(pcb, PPP_PAP, 0); -} - - -/* - * upap_rauthnak - Receive Authenticate-Nak. - */ -static void upap_rauthnak(ppp_pcb *pcb, u_char *inp, int id, int len) { - u_char msglen; - char *msg; - LWIP_UNUSED_ARG(id); - - if (pcb->upap.us_clientstate != UPAPCS_AUTHREQ) /* XXX */ - return; - - /* - * Parse message. - */ - if (len < 1) { - UPAPDEBUG(("pap_rauthnak: ignoring missing msg-length.")); - } else { - GETCHAR(msglen, inp); - if (msglen > 0) { - len -= sizeof (u_char); - if (len < msglen) { - UPAPDEBUG(("pap_rauthnak: rcvd short packet.")); - return; - } - msg = (char *) inp; - PRINTMSG(msg, msglen); - } - } - - pcb->upap.us_clientstate = UPAPCS_BADAUTH; - - ppp_error("PAP authentication failed"); - auth_withpeer_fail(pcb, PPP_PAP); -} - - -/* - * upap_sauthreq - Send an Authenticate-Request. - */ -static void upap_sauthreq(ppp_pcb *pcb) { - struct pbuf *p; - u_char *outp; - int outlen; - - outlen = UPAP_HEADERLEN + 2 * sizeof (u_char) + - pcb->upap.us_userlen + pcb->upap.us_passwdlen; - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +outlen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - MAKEHEADER(outp, PPP_PAP); - - PUTCHAR(UPAP_AUTHREQ, outp); - PUTCHAR(++pcb->upap.us_id, outp); - PUTSHORT(outlen, outp); - PUTCHAR(pcb->upap.us_userlen, outp); - MEMCPY(outp, pcb->upap.us_user, pcb->upap.us_userlen); - INCPTR(pcb->upap.us_userlen, outp); - PUTCHAR(pcb->upap.us_passwdlen, outp); - MEMCPY(outp, pcb->upap.us_passwd, pcb->upap.us_passwdlen); - - ppp_write(pcb, p); - - TIMEOUT(upap_timeout, pcb, pcb->settings.pap_timeout_time); - ++pcb->upap.us_transmits; - pcb->upap.us_clientstate = UPAPCS_AUTHREQ; -} - -#if PPP_SERVER -/* - * upap_sresp - Send a response (ack or nak). - */ -static void upap_sresp(ppp_pcb *pcb, u_char code, u_char id, const char *msg, int msglen) { - struct pbuf *p; - u_char *outp; - int outlen; - - outlen = UPAP_HEADERLEN + sizeof (u_char) + msglen; - p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +outlen), PPP_CTRL_PBUF_TYPE); - if(NULL == p) - return; - if(p->tot_len != p->len) { - pbuf_free(p); - return; - } - - outp = (u_char*)p->payload; - MAKEHEADER(outp, PPP_PAP); - - PUTCHAR(code, outp); - PUTCHAR(id, outp); - PUTSHORT(outlen, outp); - PUTCHAR(msglen, outp); - MEMCPY(outp, msg, msglen); - - ppp_write(pcb, p); -} -#endif /* PPP_SERVER */ - -#if PRINTPKT_SUPPORT -/* - * upap_printpkt - print the contents of a PAP packet. - */ -static const char* const upap_codenames[] = { - "AuthReq", "AuthAck", "AuthNak" -}; - -static int upap_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg) { - int code, id, len; - int mlen, ulen, wlen; - const u_char *user, *pwd, *msg; - const u_char *pstart; - - if (plen < UPAP_HEADERLEN) - return 0; - pstart = p; - GETCHAR(code, p); - GETCHAR(id, p); - GETSHORT(len, p); - if (len < UPAP_HEADERLEN || len > plen) - return 0; - - if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(upap_codenames)) - printer(arg, " %s", upap_codenames[code-1]); - else - printer(arg, " code=0x%x", code); - printer(arg, " id=0x%x", id); - len -= UPAP_HEADERLEN; - switch (code) { - case UPAP_AUTHREQ: - if (len < 1) - break; - ulen = p[0]; - if (len < ulen + 2) - break; - wlen = p[ulen + 1]; - if (len < ulen + wlen + 2) - break; - user = (const u_char *) (p + 1); - pwd = (const u_char *) (p + ulen + 2); - p += ulen + wlen + 2; - len -= ulen + wlen + 2; - printer(arg, " user="); - ppp_print_string(user, ulen, printer, arg); - printer(arg, " password="); -/* FIXME: require ppp_pcb struct as printpkt() argument */ -#if 0 - if (!pcb->settings.hide_password) -#endif - ppp_print_string(pwd, wlen, printer, arg); -#if 0 - else - printer(arg, ""); -#endif - break; - case UPAP_AUTHACK: - case UPAP_AUTHNAK: - if (len < 1) - break; - mlen = p[0]; - if (len < mlen + 1) - break; - msg = (const u_char *) (p + 1); - p += mlen + 1; - len -= mlen + 1; - printer(arg, " "); - ppp_print_string(msg, mlen, printer, arg); - break; - default: - break; - } - - /* print the rest of the bytes in the packet */ - for (; len > 0; --len) { - GETCHAR(code, p); - printer(arg, " %.2x", code); - } - - return p - pstart; -} -#endif /* PRINTPKT_SUPPORT */ - -#endif /* PPP_SUPPORT && PAP_SUPPORT */ +/* + * upap.c - User/Password Authentication Protocol. + * + * Copyright (c) 1984-2000 Carnegie Mellon University. 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. The name "Carnegie Mellon University" must not be used to + * endorse or promote products derived from this software without + * prior written permission. For permission or any legal + * details, please contact + * Office of Technology Transfer + * Carnegie Mellon University + * 5000 Forbes Avenue + * Pittsburgh, PA 15213-3890 + * (412) 268-4387, fax: (412) 268-7395 + * tech-transfer@andrew.cmu.edu + * + * 4. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Computing Services + * at Carnegie Mellon University (http://www.cmu.edu/computing/)." + * + * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE + * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && PAP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +/* + * @todo: + */ + +#if 0 /* UNUSED */ +#include +#include +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/upap.h" + +#if PPP_OPTIONS +/* + * Command-line options. + */ +static option_t pap_option_list[] = { + { "hide-password", o_bool, &hide_password, + "Don't output passwords to log", OPT_PRIO | 1 }, + { "show-password", o_bool, &hide_password, + "Show password string in debug log messages", OPT_PRIOSUB | 0 }, + + { "pap-restart", o_int, &upap[0].us_timeouttime, + "Set retransmit timeout for PAP", OPT_PRIO }, + { "pap-max-authreq", o_int, &upap[0].us_maxtransmits, + "Set max number of transmissions for auth-reqs", OPT_PRIO }, + { "pap-timeout", o_int, &upap[0].us_reqtimeout, + "Set time limit for peer PAP authentication", OPT_PRIO }, + + { NULL } +}; +#endif /* PPP_OPTIONS */ + +/* + * Protocol entry points. + */ +static void upap_init(ppp_pcb *pcb); +static void upap_lowerup(ppp_pcb *pcb); +static void upap_lowerdown(ppp_pcb *pcb); +static void upap_input(ppp_pcb *pcb, u_char *inpacket, int l); +static void upap_protrej(ppp_pcb *pcb); +#if PRINTPKT_SUPPORT +static int upap_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg); +#endif /* PRINTPKT_SUPPORT */ + +const struct protent pap_protent = { + PPP_PAP, + upap_init, + upap_input, + upap_protrej, + upap_lowerup, + upap_lowerdown, + NULL, + NULL, +#if PRINTPKT_SUPPORT + upap_printpkt, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_DATAINPUT + NULL, +#endif /* PPP_DATAINPUT */ +#if PRINTPKT_SUPPORT + "PAP", + NULL, +#endif /* PRINTPKT_SUPPORT */ +#if PPP_OPTIONS + pap_option_list, + NULL, +#endif /* PPP_OPTIONS */ +#if DEMAND_SUPPORT + NULL, + NULL +#endif /* DEMAND_SUPPORT */ +}; + +static void upap_timeout(void *arg); +#if PPP_SERVER +static void upap_reqtimeout(void *arg); +static void upap_rauthreq(ppp_pcb *pcb, u_char *inp, int id, int len); +#endif /* PPP_SERVER */ +static void upap_rauthack(ppp_pcb *pcb, u_char *inp, int id, int len); +static void upap_rauthnak(ppp_pcb *pcb, u_char *inp, int id, int len); +static void upap_sauthreq(ppp_pcb *pcb); +#if PPP_SERVER +static void upap_sresp(ppp_pcb *pcb, u_char code, u_char id, const char *msg, int msglen); +#endif /* PPP_SERVER */ + + +/* + * upap_init - Initialize a UPAP unit. + */ +static void upap_init(ppp_pcb *pcb) { + pcb->upap.us_user = NULL; + pcb->upap.us_userlen = 0; + pcb->upap.us_passwd = NULL; + pcb->upap.us_passwdlen = 0; + pcb->upap.us_clientstate = UPAPCS_INITIAL; +#if PPP_SERVER + pcb->upap.us_serverstate = UPAPSS_INITIAL; +#endif /* PPP_SERVER */ + pcb->upap.us_id = 0; +} + + +/* + * upap_authwithpeer - Authenticate us with our peer (start client). + * + * Set new state and send authenticate's. + */ +void upap_authwithpeer(ppp_pcb *pcb, const char *user, const char *password) { + + if(!user || !password) + return; + + /* Save the username and password we're given */ + pcb->upap.us_user = user; + pcb->upap.us_userlen = (u8_t)LWIP_MIN(strlen(user), 0xff); + pcb->upap.us_passwd = password; + pcb->upap.us_passwdlen = (u8_t)LWIP_MIN(strlen(password), 0xff); + pcb->upap.us_transmits = 0; + + /* Lower layer up yet? */ + if (pcb->upap.us_clientstate == UPAPCS_INITIAL || + pcb->upap.us_clientstate == UPAPCS_PENDING) { + pcb->upap.us_clientstate = UPAPCS_PENDING; + return; + } + + upap_sauthreq(pcb); /* Start protocol */ +} + +#if PPP_SERVER +/* + * upap_authpeer - Authenticate our peer (start server). + * + * Set new state. + */ +void upap_authpeer(ppp_pcb *pcb) { + + /* Lower layer up yet? */ + if (pcb->upap.us_serverstate == UPAPSS_INITIAL || + pcb->upap.us_serverstate == UPAPSS_PENDING) { + pcb->upap.us_serverstate = UPAPSS_PENDING; + return; + } + + pcb->upap.us_serverstate = UPAPSS_LISTEN; + if (pcb->settings.pap_req_timeout > 0) + TIMEOUT(upap_reqtimeout, pcb, pcb->settings.pap_req_timeout); +} +#endif /* PPP_SERVER */ + +/* + * upap_timeout - Retransmission timer for sending auth-reqs expired. + */ +static void upap_timeout(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + + if (pcb->upap.us_clientstate != UPAPCS_AUTHREQ) + return; + + if (pcb->upap.us_transmits >= pcb->settings.pap_max_transmits) { + /* give up in disgust */ + ppp_error("No response to PAP authenticate-requests"); + pcb->upap.us_clientstate = UPAPCS_BADAUTH; + auth_withpeer_fail(pcb, PPP_PAP); + return; + } + + upap_sauthreq(pcb); /* Send Authenticate-Request */ +} + + +#if PPP_SERVER +/* + * upap_reqtimeout - Give up waiting for the peer to send an auth-req. + */ +static void upap_reqtimeout(void *arg) { + ppp_pcb *pcb = (ppp_pcb*)arg; + + if (pcb->upap.us_serverstate != UPAPSS_LISTEN) + return; /* huh?? */ + + auth_peer_fail(pcb, PPP_PAP); + pcb->upap.us_serverstate = UPAPSS_BADAUTH; +} +#endif /* PPP_SERVER */ + + +/* + * upap_lowerup - The lower layer is up. + * + * Start authenticating if pending. + */ +static void upap_lowerup(ppp_pcb *pcb) { + + if (pcb->upap.us_clientstate == UPAPCS_INITIAL) + pcb->upap.us_clientstate = UPAPCS_CLOSED; + else if (pcb->upap.us_clientstate == UPAPCS_PENDING) { + upap_sauthreq(pcb); /* send an auth-request */ + } + +#if PPP_SERVER + if (pcb->upap.us_serverstate == UPAPSS_INITIAL) + pcb->upap.us_serverstate = UPAPSS_CLOSED; + else if (pcb->upap.us_serverstate == UPAPSS_PENDING) { + pcb->upap.us_serverstate = UPAPSS_LISTEN; + if (pcb->settings.pap_req_timeout > 0) + TIMEOUT(upap_reqtimeout, pcb, pcb->settings.pap_req_timeout); + } +#endif /* PPP_SERVER */ +} + + +/* + * upap_lowerdown - The lower layer is down. + * + * Cancel all timeouts. + */ +static void upap_lowerdown(ppp_pcb *pcb) { + + if (pcb->upap.us_clientstate == UPAPCS_AUTHREQ) /* Timeout pending? */ + UNTIMEOUT(upap_timeout, pcb); /* Cancel timeout */ +#if PPP_SERVER + if (pcb->upap.us_serverstate == UPAPSS_LISTEN && pcb->settings.pap_req_timeout > 0) + UNTIMEOUT(upap_reqtimeout, pcb); +#endif /* PPP_SERVER */ + + pcb->upap.us_clientstate = UPAPCS_INITIAL; +#if PPP_SERVER + pcb->upap.us_serverstate = UPAPSS_INITIAL; +#endif /* PPP_SERVER */ +} + + +/* + * upap_protrej - Peer doesn't speak this protocol. + * + * This shouldn't happen. In any case, pretend lower layer went down. + */ +static void upap_protrej(ppp_pcb *pcb) { + + if (pcb->upap.us_clientstate == UPAPCS_AUTHREQ) { + ppp_error("PAP authentication failed due to protocol-reject"); + auth_withpeer_fail(pcb, PPP_PAP); + } +#if PPP_SERVER + if (pcb->upap.us_serverstate == UPAPSS_LISTEN) { + ppp_error("PAP authentication of peer failed (protocol-reject)"); + auth_peer_fail(pcb, PPP_PAP); + } +#endif /* PPP_SERVER */ + upap_lowerdown(pcb); +} + + +/* + * upap_input - Input UPAP packet. + */ +static void upap_input(ppp_pcb *pcb, u_char *inpacket, int l) { + u_char *inp; + u_char code, id; + int len; + + /* + * Parse header (code, id and length). + * If packet too short, drop it. + */ + inp = inpacket; + if (l < UPAP_HEADERLEN) { + UPAPDEBUG(("pap_input: rcvd short header.")); + return; + } + GETCHAR(code, inp); + GETCHAR(id, inp); + GETSHORT(len, inp); + if (len < UPAP_HEADERLEN) { + UPAPDEBUG(("pap_input: rcvd illegal length.")); + return; + } + if (len > l) { + UPAPDEBUG(("pap_input: rcvd short packet.")); + return; + } + len -= UPAP_HEADERLEN; + + /* + * Action depends on code. + */ + switch (code) { + case UPAP_AUTHREQ: +#if PPP_SERVER + upap_rauthreq(pcb, inp, id, len); +#endif /* PPP_SERVER */ + break; + + case UPAP_AUTHACK: + upap_rauthack(pcb, inp, id, len); + break; + + case UPAP_AUTHNAK: + upap_rauthnak(pcb, inp, id, len); + break; + + default: /* XXX Need code reject */ + break; + } +} + +#if PPP_SERVER +/* + * upap_rauth - Receive Authenticate. + */ +static void upap_rauthreq(ppp_pcb *pcb, u_char *inp, int id, int len) { + u_char ruserlen, rpasswdlen; + char *ruser; + char *rpasswd; + char rhostname[256]; + int retcode; + const char *msg; + int msglen; + + if (pcb->upap.us_serverstate < UPAPSS_LISTEN) + return; + + /* + * If we receive a duplicate authenticate-request, we are + * supposed to return the same status as for the first request. + */ + if (pcb->upap.us_serverstate == UPAPSS_OPEN) { + upap_sresp(pcb, UPAP_AUTHACK, id, "", 0); /* return auth-ack */ + return; + } + if (pcb->upap.us_serverstate == UPAPSS_BADAUTH) { + upap_sresp(pcb, UPAP_AUTHNAK, id, "", 0); /* return auth-nak */ + return; + } + + /* + * Parse user/passwd. + */ + if (len < 1) { + UPAPDEBUG(("pap_rauth: rcvd short packet.")); + return; + } + GETCHAR(ruserlen, inp); + len -= sizeof (u_char) + ruserlen + sizeof (u_char); + if (len < 0) { + UPAPDEBUG(("pap_rauth: rcvd short packet.")); + return; + } + ruser = (char *) inp; + INCPTR(ruserlen, inp); + GETCHAR(rpasswdlen, inp); + if (len < rpasswdlen) { + UPAPDEBUG(("pap_rauth: rcvd short packet.")); + return; + } + + rpasswd = (char *) inp; + + /* + * Check the username and password given. + */ + retcode = UPAP_AUTHNAK; + if (auth_check_passwd(pcb, ruser, ruserlen, rpasswd, rpasswdlen, &msg, &msglen)) { + retcode = UPAP_AUTHACK; + } + BZERO(rpasswd, rpasswdlen); + +#if 0 /* UNUSED */ + /* + * Check remote number authorization. A plugin may have filled in + * the remote number or added an allowed number, and rather than + * return an authenticate failure, is leaving it for us to verify. + */ + if (retcode == UPAP_AUTHACK) { + if (!auth_number()) { + /* We do not want to leak info about the pap result. */ + retcode = UPAP_AUTHNAK; /* XXX exit value will be "wrong" */ + warn("calling number %q is not authorized", remote_number); + } + } + + msglen = strlen(msg); + if (msglen > 255) + msglen = 255; +#endif /* UNUSED */ + + upap_sresp(pcb, retcode, id, msg, msglen); + + /* Null terminate and clean remote name. */ + ppp_slprintf(rhostname, sizeof(rhostname), "%.*v", ruserlen, ruser); + + if (retcode == UPAP_AUTHACK) { + pcb->upap.us_serverstate = UPAPSS_OPEN; + ppp_notice("PAP peer authentication succeeded for %q", rhostname); + auth_peer_success(pcb, PPP_PAP, 0, ruser, ruserlen); + } else { + pcb->upap.us_serverstate = UPAPSS_BADAUTH; + ppp_warn("PAP peer authentication failed for %q", rhostname); + auth_peer_fail(pcb, PPP_PAP); + } + + if (pcb->settings.pap_req_timeout > 0) + UNTIMEOUT(upap_reqtimeout, pcb); +} +#endif /* PPP_SERVER */ + +/* + * upap_rauthack - Receive Authenticate-Ack. + */ +static void upap_rauthack(ppp_pcb *pcb, u_char *inp, int id, int len) { + u_char msglen; + char *msg; + LWIP_UNUSED_ARG(id); + + if (pcb->upap.us_clientstate != UPAPCS_AUTHREQ) /* XXX */ + return; + + /* + * Parse message. + */ + if (len < 1) { + UPAPDEBUG(("pap_rauthack: ignoring missing msg-length.")); + } else { + GETCHAR(msglen, inp); + if (msglen > 0) { + len -= sizeof (u_char); + if (len < msglen) { + UPAPDEBUG(("pap_rauthack: rcvd short packet.")); + return; + } + msg = (char *) inp; + PRINTMSG(msg, msglen); + } + } + + pcb->upap.us_clientstate = UPAPCS_OPEN; + + auth_withpeer_success(pcb, PPP_PAP, 0); +} + + +/* + * upap_rauthnak - Receive Authenticate-Nak. + */ +static void upap_rauthnak(ppp_pcb *pcb, u_char *inp, int id, int len) { + u_char msglen; + char *msg; + LWIP_UNUSED_ARG(id); + + if (pcb->upap.us_clientstate != UPAPCS_AUTHREQ) /* XXX */ + return; + + /* + * Parse message. + */ + if (len < 1) { + UPAPDEBUG(("pap_rauthnak: ignoring missing msg-length.")); + } else { + GETCHAR(msglen, inp); + if (msglen > 0) { + len -= sizeof (u_char); + if (len < msglen) { + UPAPDEBUG(("pap_rauthnak: rcvd short packet.")); + return; + } + msg = (char *) inp; + PRINTMSG(msg, msglen); + } + } + + pcb->upap.us_clientstate = UPAPCS_BADAUTH; + + ppp_error("PAP authentication failed"); + auth_withpeer_fail(pcb, PPP_PAP); +} + + +/* + * upap_sauthreq - Send an Authenticate-Request. + */ +static void upap_sauthreq(ppp_pcb *pcb) { + struct pbuf *p; + u_char *outp; + int outlen; + + outlen = UPAP_HEADERLEN + 2 * sizeof (u_char) + + pcb->upap.us_userlen + pcb->upap.us_passwdlen; + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +outlen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + MAKEHEADER(outp, PPP_PAP); + + PUTCHAR(UPAP_AUTHREQ, outp); + PUTCHAR(++pcb->upap.us_id, outp); + PUTSHORT(outlen, outp); + PUTCHAR(pcb->upap.us_userlen, outp); + MEMCPY(outp, pcb->upap.us_user, pcb->upap.us_userlen); + INCPTR(pcb->upap.us_userlen, outp); + PUTCHAR(pcb->upap.us_passwdlen, outp); + MEMCPY(outp, pcb->upap.us_passwd, pcb->upap.us_passwdlen); + + ppp_write(pcb, p); + + TIMEOUT(upap_timeout, pcb, pcb->settings.pap_timeout_time); + ++pcb->upap.us_transmits; + pcb->upap.us_clientstate = UPAPCS_AUTHREQ; +} + +#if PPP_SERVER +/* + * upap_sresp - Send a response (ack or nak). + */ +static void upap_sresp(ppp_pcb *pcb, u_char code, u_char id, const char *msg, int msglen) { + struct pbuf *p; + u_char *outp; + int outlen; + + outlen = UPAP_HEADERLEN + sizeof (u_char) + msglen; + p = pbuf_alloc(PBUF_RAW, (u16_t)(PPP_HDRLEN +outlen), PPP_CTRL_PBUF_TYPE); + if(NULL == p) + return; + if(p->tot_len != p->len) { + pbuf_free(p); + return; + } + + outp = (u_char*)p->payload; + MAKEHEADER(outp, PPP_PAP); + + PUTCHAR(code, outp); + PUTCHAR(id, outp); + PUTSHORT(outlen, outp); + PUTCHAR(msglen, outp); + MEMCPY(outp, msg, msglen); + + ppp_write(pcb, p); +} +#endif /* PPP_SERVER */ + +#if PRINTPKT_SUPPORT +/* + * upap_printpkt - print the contents of a PAP packet. + */ +static const char* const upap_codenames[] = { + "AuthReq", "AuthAck", "AuthNak" +}; + +static int upap_printpkt(const u_char *p, int plen, void (*printer) (void *, const char *, ...), void *arg) { + int code, id, len; + int mlen, ulen, wlen; + const u_char *user, *pwd, *msg; + const u_char *pstart; + + if (plen < UPAP_HEADERLEN) + return 0; + pstart = p; + GETCHAR(code, p); + GETCHAR(id, p); + GETSHORT(len, p); + if (len < UPAP_HEADERLEN || len > plen) + return 0; + + if (code >= 1 && code <= (int)LWIP_ARRAYSIZE(upap_codenames)) + printer(arg, " %s", upap_codenames[code-1]); + else + printer(arg, " code=0x%x", code); + printer(arg, " id=0x%x", id); + len -= UPAP_HEADERLEN; + switch (code) { + case UPAP_AUTHREQ: + if (len < 1) + break; + ulen = p[0]; + if (len < ulen + 2) + break; + wlen = p[ulen + 1]; + if (len < ulen + wlen + 2) + break; + user = (const u_char *) (p + 1); + pwd = (const u_char *) (p + ulen + 2); + p += ulen + wlen + 2; + len -= ulen + wlen + 2; + printer(arg, " user="); + ppp_print_string(user, ulen, printer, arg); + printer(arg, " password="); +/* FIXME: require ppp_pcb struct as printpkt() argument */ +#if 0 + if (!pcb->settings.hide_password) +#endif + ppp_print_string(pwd, wlen, printer, arg); +#if 0 + else + printer(arg, ""); +#endif + break; + case UPAP_AUTHACK: + case UPAP_AUTHNAK: + if (len < 1) + break; + mlen = p[0]; + if (len < mlen + 1) + break; + msg = (const u_char *) (p + 1); + p += mlen + 1; + len -= mlen + 1; + printer(arg, " "); + ppp_print_string(msg, mlen, printer, arg); + break; + default: + break; + } + + /* print the rest of the bytes in the packet */ + for (; len > 0; --len) { + GETCHAR(code, p); + printer(arg, " %.2x", code); + } + + return p - pstart; +} +#endif /* PRINTPKT_SUPPORT */ + +#endif /* PPP_SUPPORT && PAP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/utils.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/utils.c index be7a3b03..f1366dae 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/utils.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/utils.c @@ -1,957 +1,957 @@ -/* - * utils.c - various utility functions used in pppd. - * - * Copyright (c) 1999-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to - * endorse or promote products derived from this software without - * prior written permission. - * - * 3. Redistributions of any form whatsoever must retain the following - * acknowledgment: - * "This product includes software developed by Paul Mackerras - * ". - * - * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO - * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY - * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY - * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES - * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN - * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#if 0 /* UNUSED */ -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#ifdef SVR4 -#include -#endif -#endif /* UNUSED */ - -#include "netif/ppp/ppp_impl.h" - -#include "netif/ppp/fsm.h" -#include "netif/ppp/lcp.h" - -#if defined(SUNOS4) -extern char *strerror(); -#endif - -static void ppp_logit(int level, const char *fmt, va_list args); -static void ppp_log_write(int level, char *buf); -#if PRINTPKT_SUPPORT -static void ppp_vslp_printer(void *arg, const char *fmt, ...); -static void ppp_format_packet(const u_char *p, int len, - void (*printer) (void *, const char *, ...), void *arg); - -struct buffer_info { - char *ptr; - int len; -}; -#endif /* PRINTPKT_SUPPORT */ - -/* - * ppp_strlcpy - like strcpy/strncpy, doesn't overflow destination buffer, - * always leaves destination null-terminated (for len > 0). - */ -size_t ppp_strlcpy(char *dest, const char *src, size_t len) { - size_t ret = strlen(src); - - if (len != 0) { - if (ret < len) - strcpy(dest, src); - else { - strncpy(dest, src, len - 1); - dest[len-1] = 0; - } - } - return ret; -} - -/* - * ppp_strlcat - like strcat/strncat, doesn't overflow destination buffer, - * always leaves destination null-terminated (for len > 0). - */ -size_t ppp_strlcat(char *dest, const char *src, size_t len) { - size_t dlen = strlen(dest); - - return dlen + ppp_strlcpy(dest + dlen, src, (len > dlen? len - dlen: 0)); -} - - -/* - * ppp_slprintf - format a message into a buffer. Like sprintf except we - * also specify the length of the output buffer, and we handle - * %m (error message), %v (visible string), - * %q (quoted string), %t (current time) and %I (IP address) formats. - * Doesn't do floating-point formats. - * Returns the number of chars put into buf. - */ -int ppp_slprintf(char *buf, int buflen, const char *fmt, ...) { - va_list args; - int n; - - va_start(args, fmt); - n = ppp_vslprintf(buf, buflen, fmt, args); - va_end(args); - return n; -} - -/* - * ppp_vslprintf - like ppp_slprintf, takes a va_list instead of a list of args. - */ -#define OUTCHAR(c) (buflen > 0? (--buflen, *buf++ = (c)): 0) - -int ppp_vslprintf(char *buf, int buflen, const char *fmt, va_list args) { - int c, i, n; - int width, prec, fillch; - int base, len, neg, quoted; - unsigned long val = 0; - const char *f; - char *str, *buf0; - const unsigned char *p; - char num[32]; -#if 0 /* need port */ - time_t t; -#endif /* need port */ - u32_t ip; - static char hexchars[] = "0123456789abcdef"; -#if PRINTPKT_SUPPORT - struct buffer_info bufinfo; -#endif /* PRINTPKT_SUPPORT */ - - buf0 = buf; - --buflen; - while (buflen > 0) { - for (f = fmt; *f != '%' && *f != 0; ++f) - ; - if (f > fmt) { - len = f - fmt; - if (len > buflen) - len = buflen; - memcpy(buf, fmt, len); - buf += len; - buflen -= len; - fmt = f; - } - if (*fmt == 0) - break; - c = *++fmt; - width = 0; - prec = -1; - fillch = ' '; - if (c == '0') { - fillch = '0'; - c = *++fmt; - } - if (c == '*') { - width = va_arg(args, int); - c = *++fmt; - } else { - while (lwip_isdigit(c)) { - width = width * 10 + c - '0'; - c = *++fmt; - } - } - if (c == '.') { - c = *++fmt; - if (c == '*') { - prec = va_arg(args, int); - c = *++fmt; - } else { - prec = 0; - while (lwip_isdigit(c)) { - prec = prec * 10 + c - '0'; - c = *++fmt; - } - } - } - str = 0; - base = 0; - neg = 0; - ++fmt; - switch (c) { - case 'l': - c = *fmt++; - switch (c) { - case 'd': - val = va_arg(args, long); - if ((long)val < 0) { - neg = 1; - val = (unsigned long)-(long)val; - } - base = 10; - break; - case 'u': - val = va_arg(args, unsigned long); - base = 10; - break; - default: - OUTCHAR('%'); - OUTCHAR('l'); - --fmt; /* so %lz outputs %lz etc. */ - continue; - } - break; - case 'd': - i = va_arg(args, int); - if (i < 0) { - neg = 1; - val = -i; - } else - val = i; - base = 10; - break; - case 'u': - val = va_arg(args, unsigned int); - base = 10; - break; - case 'o': - val = va_arg(args, unsigned int); - base = 8; - break; - case 'x': - case 'X': - val = va_arg(args, unsigned int); - base = 16; - break; -#if 0 /* unused (and wrong on LLP64 systems) */ - case 'p': - val = (unsigned long) va_arg(args, void *); - base = 16; - neg = 2; - break; -#endif /* unused (and wrong on LLP64 systems) */ - case 's': - str = va_arg(args, char *); - break; - case 'c': - num[0] = va_arg(args, int); - num[1] = 0; - str = num; - break; -#if 0 /* do we always have strerror() in embedded ? */ - case 'm': - str = strerror(errno); - break; -#endif /* do we always have strerror() in embedded ? */ - case 'I': - ip = va_arg(args, u32_t); - ip = lwip_ntohl(ip); - ppp_slprintf(num, sizeof(num), "%d.%d.%d.%d", (ip >> 24) & 0xff, - (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff); - str = num; - break; -#if 0 /* need port */ - case 't': - time(&t); - str = ctime(&t); - str += 4; /* chop off the day name */ - str[15] = 0; /* chop off year and newline */ - break; -#endif /* need port */ - case 'v': /* "visible" string */ - case 'q': /* quoted string */ - quoted = c == 'q'; - p = va_arg(args, unsigned char *); - if (p == NULL) - p = (const unsigned char *)""; - if (fillch == '0' && prec >= 0) { - n = prec; - } else { - n = strlen((const char *)p); - if (prec >= 0 && n > prec) - n = prec; - } - while (n > 0 && buflen > 0) { - c = *p++; - --n; - if (!quoted && c >= 0x80) { - OUTCHAR('M'); - OUTCHAR('-'); - c -= 0x80; - } - if (quoted && (c == '"' || c == '\\')) - OUTCHAR('\\'); - if (c < 0x20 || (0x7f <= c && c < 0xa0)) { - if (quoted) { - OUTCHAR('\\'); - switch (c) { - case '\t': OUTCHAR('t'); break; - case '\n': OUTCHAR('n'); break; - case '\b': OUTCHAR('b'); break; - case '\f': OUTCHAR('f'); break; - default: - OUTCHAR('x'); - OUTCHAR(hexchars[c >> 4]); - OUTCHAR(hexchars[c & 0xf]); - } - } else { - if (c == '\t') - OUTCHAR(c); - else { - OUTCHAR('^'); - OUTCHAR(c ^ 0x40); - } - } - } else - OUTCHAR(c); - } - continue; -#if PRINTPKT_SUPPORT - case 'P': /* print PPP packet */ - bufinfo.ptr = buf; - bufinfo.len = buflen + 1; - p = va_arg(args, unsigned char *); - n = va_arg(args, int); - ppp_format_packet(p, n, ppp_vslp_printer, &bufinfo); - buf = bufinfo.ptr; - buflen = bufinfo.len - 1; - continue; -#endif /* PRINTPKT_SUPPORT */ - case 'B': - p = va_arg(args, unsigned char *); - for (n = prec; n > 0; --n) { - c = *p++; - if (fillch == ' ') - OUTCHAR(' '); - OUTCHAR(hexchars[(c >> 4) & 0xf]); - OUTCHAR(hexchars[c & 0xf]); - } - continue; - default: - *buf++ = '%'; - if (c != '%') - --fmt; /* so %z outputs %z etc. */ - --buflen; - continue; - } - if (base != 0) { - str = num + sizeof(num); - *--str = 0; - while (str > num + neg) { - *--str = hexchars[val % base]; - val = val / base; - if (--prec <= 0 && val == 0) - break; - } - switch (neg) { - case 1: - *--str = '-'; - break; - case 2: - *--str = 'x'; - *--str = '0'; - break; - default: - break; - } - len = num + sizeof(num) - 1 - str; - } else { - len = strlen(str); - if (prec >= 0 && len > prec) - len = prec; - } - if (width > 0) { - if (width > buflen) - width = buflen; - if ((n = width - len) > 0) { - buflen -= n; - for (; n > 0; --n) - *buf++ = fillch; - } - } - if (len > buflen) - len = buflen; - memcpy(buf, str, len); - buf += len; - buflen -= len; - } - *buf = 0; - return buf - buf0; -} - -#if PRINTPKT_SUPPORT -/* - * vslp_printer - used in processing a %P format - */ -static void ppp_vslp_printer(void *arg, const char *fmt, ...) { - int n; - va_list pvar; - struct buffer_info *bi; - - va_start(pvar, fmt); - bi = (struct buffer_info *) arg; - n = ppp_vslprintf(bi->ptr, bi->len, fmt, pvar); - va_end(pvar); - - bi->ptr += n; - bi->len -= n; -} -#endif /* PRINTPKT_SUPPORT */ - -#if 0 /* UNUSED */ -/* - * log_packet - format a packet and log it. - */ - -void -log_packet(p, len, prefix, level) - u_char *p; - int len; - char *prefix; - int level; -{ - init_pr_log(prefix, level); - ppp_format_packet(p, len, pr_log, &level); - end_pr_log(); -} -#endif /* UNUSED */ - -#if PRINTPKT_SUPPORT -/* - * ppp_format_packet - make a readable representation of a packet, - * calling `printer(arg, format, ...)' to output it. - */ -static void ppp_format_packet(const u_char *p, int len, - void (*printer) (void *, const char *, ...), void *arg) { - int i, n; - u_short proto; - const struct protent *protp; - - if (len >= 2) { - GETSHORT(proto, p); - len -= 2; - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (proto == protp->protocol) - break; - if (protp != NULL) { - printer(arg, "[%s", protp->name); - n = (*protp->printpkt)(p, len, printer, arg); - printer(arg, "]"); - p += n; - len -= n; - } else { - for (i = 0; (protp = protocols[i]) != NULL; ++i) - if (proto == (protp->protocol & ~0x8000)) - break; - if (protp != 0 && protp->data_name != 0) { - printer(arg, "[%s data]", protp->data_name); - if (len > 8) - printer(arg, "%.8B ...", p); - else - printer(arg, "%.*B", len, p); - len = 0; - } else - printer(arg, "[proto=0x%x]", proto); - } - } - - if (len > 32) - printer(arg, "%.32B ...", p); - else - printer(arg, "%.*B", len, p); -} -#endif /* PRINTPKT_SUPPORT */ - -#if 0 /* UNUSED */ -/* - * init_pr_log, end_pr_log - initialize and finish use of pr_log. - */ - -static char line[256]; /* line to be logged accumulated here */ -static char *linep; /* current pointer within line */ -static int llevel; /* level for logging */ - -void -init_pr_log(prefix, level) - const char *prefix; - int level; -{ - linep = line; - if (prefix != NULL) { - ppp_strlcpy(line, prefix, sizeof(line)); - linep = line + strlen(line); - } - llevel = level; -} - -void -end_pr_log() -{ - if (linep != line) { - *linep = 0; - ppp_log_write(llevel, line); - } -} - -/* - * pr_log - printer routine for outputting to log - */ -void -pr_log (void *arg, const char *fmt, ...) -{ - int l, n; - va_list pvar; - char *p, *eol; - char buf[256]; - - va_start(pvar, fmt); - n = ppp_vslprintf(buf, sizeof(buf), fmt, pvar); - va_end(pvar); - - p = buf; - eol = strchr(buf, '\n'); - if (linep != line) { - l = (eol == NULL)? n: eol - buf; - if (linep + l < line + sizeof(line)) { - if (l > 0) { - memcpy(linep, buf, l); - linep += l; - } - if (eol == NULL) - return; - p = eol + 1; - eol = strchr(p, '\n'); - } - *linep = 0; - ppp_log_write(llevel, line); - linep = line; - } - - while (eol != NULL) { - *eol = 0; - ppp_log_write(llevel, p); - p = eol + 1; - eol = strchr(p, '\n'); - } - - /* assumes sizeof(buf) <= sizeof(line) */ - l = buf + n - p; - if (l > 0) { - memcpy(line, p, n); - linep = line + l; - } -} -#endif /* UNUSED */ - -/* - * ppp_print_string - print a readable representation of a string using - * printer. - */ -void ppp_print_string(const u_char *p, int len, void (*printer) (void *, const char *, ...), void *arg) { - int c; - - printer(arg, "\""); - for (; len > 0; --len) { - c = *p++; - if (' ' <= c && c <= '~') { - if (c == '\\' || c == '"') - printer(arg, "\\"); - printer(arg, "%c", c); - } else { - switch (c) { - case '\n': - printer(arg, "\\n"); - break; - case '\r': - printer(arg, "\\r"); - break; - case '\t': - printer(arg, "\\t"); - break; - default: - printer(arg, "\\%.3o", (u8_t)c); - /* no break */ - } - } - } - printer(arg, "\""); -} - -/* - * ppp_logit - does the hard work for fatal et al. - */ -static void ppp_logit(int level, const char *fmt, va_list args) { - char buf[1024]; - - ppp_vslprintf(buf, sizeof(buf), fmt, args); - ppp_log_write(level, buf); -} - -static void ppp_log_write(int level, char *buf) { - LWIP_UNUSED_ARG(level); /* necessary if PPPDEBUG is defined to an empty function */ - LWIP_UNUSED_ARG(buf); - PPPDEBUG(level, ("%s\n", buf) ); -#if 0 - if (log_to_fd >= 0 && (level != LOG_DEBUG || debug)) { - int n = strlen(buf); - - if (n > 0 && buf[n-1] == '\n') - --n; - if (write(log_to_fd, buf, n) != n - || write(log_to_fd, "\n", 1) != 1) - log_to_fd = -1; - } -#endif -} - -/* - * ppp_fatal - log an error message and die horribly. - */ -void ppp_fatal(const char *fmt, ...) { - va_list pvar; - - va_start(pvar, fmt); - ppp_logit(LOG_ERR, fmt, pvar); - va_end(pvar); - - LWIP_ASSERT("ppp_fatal", 0); /* as promised */ -} - -/* - * ppp_error - log an error message. - */ -void ppp_error(const char *fmt, ...) { - va_list pvar; - - va_start(pvar, fmt); - ppp_logit(LOG_ERR, fmt, pvar); - va_end(pvar); -#if 0 /* UNUSED */ - ++error_count; -#endif /* UNUSED */ -} - -/* - * ppp_warn - log a warning message. - */ -void ppp_warn(const char *fmt, ...) { - va_list pvar; - - va_start(pvar, fmt); - ppp_logit(LOG_WARNING, fmt, pvar); - va_end(pvar); -} - -/* - * ppp_notice - log a notice-level message. - */ -void ppp_notice(const char *fmt, ...) { - va_list pvar; - - va_start(pvar, fmt); - ppp_logit(LOG_NOTICE, fmt, pvar); - va_end(pvar); -} - -/* - * ppp_info - log an informational message. - */ -void ppp_info(const char *fmt, ...) { - va_list pvar; - - va_start(pvar, fmt); - ppp_logit(LOG_INFO, fmt, pvar); - va_end(pvar); -} - -/* - * ppp_dbglog - log a debug message. - */ -void ppp_dbglog(const char *fmt, ...) { - va_list pvar; - - va_start(pvar, fmt); - ppp_logit(LOG_DEBUG, fmt, pvar); - va_end(pvar); -} - -#if PRINTPKT_SUPPORT -/* - * ppp_dump_packet - print out a packet in readable form if it is interesting. - * Assumes len >= PPP_HDRLEN. - */ -void ppp_dump_packet(ppp_pcb *pcb, const char *tag, unsigned char *p, int len) { - int proto; - - /* - * don't print data packets, i.e. IPv4, IPv6, VJ, and compressed packets. - */ - proto = (p[0] << 8) + p[1]; - if (proto < 0xC000 && (proto & ~0x8000) == proto) - return; - - /* - * don't print valid LCP echo request/reply packets if the link is up. - */ - if (proto == PPP_LCP && pcb->phase == PPP_PHASE_RUNNING && len >= 2 + HEADERLEN) { - unsigned char *lcp = p + 2; - int l = (lcp[2] << 8) + lcp[3]; - - if ((lcp[0] == ECHOREQ || lcp[0] == ECHOREP) - && l >= HEADERLEN && l <= len - 2) - return; - } - - ppp_dbglog("%s %P", tag, p, len); -} -#endif /* PRINTPKT_SUPPORT */ - -#if 0 /* Unused */ - -/* - * complete_read - read a full `count' bytes from fd, - * unless end-of-file or an error other than EINTR is encountered. - */ -ssize_t -complete_read(int fd, void *buf, size_t count) -{ - size_t done; - ssize_t nb; - char *ptr = buf; - - for (done = 0; done < count; ) { - nb = read(fd, ptr, count - done); - if (nb < 0) { - if (errno == EINTR) - continue; - return -1; - } - if (nb == 0) - break; - done += nb; - ptr += nb; - } - return done; -} - -/* Procedures for locking the serial device using a lock file. */ -#ifndef LOCK_DIR -#ifdef __linux__ -#define LOCK_DIR "/var/lock" -#else -#ifdef SVR4 -#define LOCK_DIR "/var/spool/locks" -#else -#define LOCK_DIR "/var/spool/lock" -#endif -#endif -#endif /* LOCK_DIR */ - -static char lock_file[MAXPATHLEN]; - -/* - * lock - create a lock file for the named device - */ -int -lock(dev) - char *dev; -{ -#ifdef LOCKLIB - int result; - - result = mklock (dev, (void *) 0); - if (result == 0) { - ppp_strlcpy(lock_file, dev, sizeof(lock_file)); - return 0; - } - - if (result > 0) - ppp_notice("Device %s is locked by pid %d", dev, result); - else - ppp_error("Can't create lock file %s", lock_file); - return -1; - -#else /* LOCKLIB */ - - char lock_buffer[12]; - int fd, pid, n; - -#ifdef SVR4 - struct stat sbuf; - - if (stat(dev, &sbuf) < 0) { - ppp_error("Can't get device number for %s: %m", dev); - return -1; - } - if ((sbuf.st_mode & S_IFMT) != S_IFCHR) { - ppp_error("Can't lock %s: not a character device", dev); - return -1; - } - ppp_slprintf(lock_file, sizeof(lock_file), "%s/LK.%03d.%03d.%03d", - LOCK_DIR, major(sbuf.st_dev), - major(sbuf.st_rdev), minor(sbuf.st_rdev)); -#else - char *p; - char lockdev[MAXPATHLEN]; - - if ((p = strstr(dev, "dev/")) != NULL) { - dev = p + 4; - strncpy(lockdev, dev, MAXPATHLEN-1); - lockdev[MAXPATHLEN-1] = 0; - while ((p = strrchr(lockdev, '/')) != NULL) { - *p = '_'; - } - dev = lockdev; - } else - if ((p = strrchr(dev, '/')) != NULL) - dev = p + 1; - - ppp_slprintf(lock_file, sizeof(lock_file), "%s/LCK..%s", LOCK_DIR, dev); -#endif - - while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) { - if (errno != EEXIST) { - ppp_error("Can't create lock file %s: %m", lock_file); - break; - } - - /* Read the lock file to find out who has the device locked. */ - fd = open(lock_file, O_RDONLY, 0); - if (fd < 0) { - if (errno == ENOENT) /* This is just a timing problem. */ - continue; - ppp_error("Can't open existing lock file %s: %m", lock_file); - break; - } -#ifndef LOCK_BINARY - n = read(fd, lock_buffer, 11); -#else - n = read(fd, &pid, sizeof(pid)); -#endif /* LOCK_BINARY */ - close(fd); - fd = -1; - if (n <= 0) { - ppp_error("Can't read pid from lock file %s", lock_file); - break; - } - - /* See if the process still exists. */ -#ifndef LOCK_BINARY - lock_buffer[n] = 0; - pid = atoi(lock_buffer); -#endif /* LOCK_BINARY */ - if (pid == getpid()) - return 1; /* somebody else locked it for us */ - if (pid == 0 - || (kill(pid, 0) == -1 && errno == ESRCH)) { - if (unlink (lock_file) == 0) { - ppp_notice("Removed stale lock on %s (pid %d)", dev, pid); - continue; - } - ppp_warn("Couldn't remove stale lock on %s", dev); - } else - ppp_notice("Device %s is locked by pid %d", dev, pid); - break; - } - - if (fd < 0) { - lock_file[0] = 0; - return -1; - } - - pid = getpid(); -#ifndef LOCK_BINARY - ppp_slprintf(lock_buffer, sizeof(lock_buffer), "%10d\n", pid); - write (fd, lock_buffer, 11); -#else - write(fd, &pid, sizeof (pid)); -#endif - close(fd); - return 0; - -#endif -} - -/* - * relock - called to update our lockfile when we are about to detach, - * thus changing our pid (we fork, the child carries on, and the parent dies). - * Note that this is called by the parent, with pid equal to the pid - * of the child. This avoids a potential race which would exist if - * we had the child rewrite the lockfile (the parent might die first, - * and another process could think the lock was stale if it checked - * between when the parent died and the child rewrote the lockfile). - */ -int -relock(pid) - int pid; -{ -#ifdef LOCKLIB - /* XXX is there a way to do this? */ - return -1; -#else /* LOCKLIB */ - - int fd; - char lock_buffer[12]; - - if (lock_file[0] == 0) - return -1; - fd = open(lock_file, O_WRONLY, 0); - if (fd < 0) { - ppp_error("Couldn't reopen lock file %s: %m", lock_file); - lock_file[0] = 0; - return -1; - } - -#ifndef LOCK_BINARY - ppp_slprintf(lock_buffer, sizeof(lock_buffer), "%10d\n", pid); - write (fd, lock_buffer, 11); -#else - write(fd, &pid, sizeof(pid)); -#endif /* LOCK_BINARY */ - close(fd); - return 0; - -#endif /* LOCKLIB */ -} - -/* - * unlock - remove our lockfile - */ -void -unlock() -{ - if (lock_file[0]) { -#ifdef LOCKLIB - (void) rmlock(lock_file, (void *) 0); -#else - unlink(lock_file); -#endif - lock_file[0] = 0; - } -} - -#endif /* Unused */ - -#endif /* PPP_SUPPORT */ +/* + * utils.c - various utility functions used in pppd. + * + * Copyright (c) 1999-2002 Paul Mackerras. 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. The name(s) of the authors of this software must not be used to + * endorse or promote products derived from this software without + * prior written permission. + * + * 3. Redistributions of any form whatsoever must retain the following + * acknowledgment: + * "This product includes software developed by Paul Mackerras + * ". + * + * THE AUTHORS OF THIS SOFTWARE DISCLAIM ALL WARRANTIES WITH REGARD TO + * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + * AND FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY + * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN + * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING + * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#if 0 /* UNUSED */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#ifdef SVR4 +#include +#endif +#endif /* UNUSED */ + +#include "netif/ppp/ppp_impl.h" + +#include "netif/ppp/fsm.h" +#include "netif/ppp/lcp.h" + +#if defined(SUNOS4) +extern char *strerror(); +#endif + +static void ppp_logit(int level, const char *fmt, va_list args); +static void ppp_log_write(int level, char *buf); +#if PRINTPKT_SUPPORT +static void ppp_vslp_printer(void *arg, const char *fmt, ...); +static void ppp_format_packet(const u_char *p, int len, + void (*printer) (void *, const char *, ...), void *arg); + +struct buffer_info { + char *ptr; + int len; +}; +#endif /* PRINTPKT_SUPPORT */ + +/* + * ppp_strlcpy - like strcpy/strncpy, doesn't overflow destination buffer, + * always leaves destination null-terminated (for len > 0). + */ +size_t ppp_strlcpy(char *dest, const char *src, size_t len) { + size_t ret = strlen(src); + + if (len != 0) { + if (ret < len) + strcpy(dest, src); + else { + strncpy(dest, src, len - 1); + dest[len-1] = 0; + } + } + return ret; +} + +/* + * ppp_strlcat - like strcat/strncat, doesn't overflow destination buffer, + * always leaves destination null-terminated (for len > 0). + */ +size_t ppp_strlcat(char *dest, const char *src, size_t len) { + size_t dlen = strlen(dest); + + return dlen + ppp_strlcpy(dest + dlen, src, (len > dlen? len - dlen: 0)); +} + + +/* + * ppp_slprintf - format a message into a buffer. Like sprintf except we + * also specify the length of the output buffer, and we handle + * %m (error message), %v (visible string), + * %q (quoted string), %t (current time) and %I (IP address) formats. + * Doesn't do floating-point formats. + * Returns the number of chars put into buf. + */ +int ppp_slprintf(char *buf, int buflen, const char *fmt, ...) { + va_list args; + int n; + + va_start(args, fmt); + n = ppp_vslprintf(buf, buflen, fmt, args); + va_end(args); + return n; +} + +/* + * ppp_vslprintf - like ppp_slprintf, takes a va_list instead of a list of args. + */ +#define OUTCHAR(c) (buflen > 0? (--buflen, *buf++ = (c)): 0) + +int ppp_vslprintf(char *buf, int buflen, const char *fmt, va_list args) { + int c, i, n; + int width, prec, fillch; + int base, len, neg, quoted; + unsigned long val = 0; + const char *f; + char *str, *buf0; + const unsigned char *p; + char num[32]; +#if 0 /* need port */ + time_t t; +#endif /* need port */ + u32_t ip; + static char hexchars[] = "0123456789abcdef"; +#if PRINTPKT_SUPPORT + struct buffer_info bufinfo; +#endif /* PRINTPKT_SUPPORT */ + + buf0 = buf; + --buflen; + while (buflen > 0) { + for (f = fmt; *f != '%' && *f != 0; ++f) + ; + if (f > fmt) { + len = f - fmt; + if (len > buflen) + len = buflen; + memcpy(buf, fmt, len); + buf += len; + buflen -= len; + fmt = f; + } + if (*fmt == 0) + break; + c = *++fmt; + width = 0; + prec = -1; + fillch = ' '; + if (c == '0') { + fillch = '0'; + c = *++fmt; + } + if (c == '*') { + width = va_arg(args, int); + c = *++fmt; + } else { + while (lwip_isdigit(c)) { + width = width * 10 + c - '0'; + c = *++fmt; + } + } + if (c == '.') { + c = *++fmt; + if (c == '*') { + prec = va_arg(args, int); + c = *++fmt; + } else { + prec = 0; + while (lwip_isdigit(c)) { + prec = prec * 10 + c - '0'; + c = *++fmt; + } + } + } + str = 0; + base = 0; + neg = 0; + ++fmt; + switch (c) { + case 'l': + c = *fmt++; + switch (c) { + case 'd': + val = va_arg(args, long); + if ((long)val < 0) { + neg = 1; + val = (unsigned long)-(long)val; + } + base = 10; + break; + case 'u': + val = va_arg(args, unsigned long); + base = 10; + break; + default: + OUTCHAR('%'); + OUTCHAR('l'); + --fmt; /* so %lz outputs %lz etc. */ + continue; + } + break; + case 'd': + i = va_arg(args, int); + if (i < 0) { + neg = 1; + val = -i; + } else + val = i; + base = 10; + break; + case 'u': + val = va_arg(args, unsigned int); + base = 10; + break; + case 'o': + val = va_arg(args, unsigned int); + base = 8; + break; + case 'x': + case 'X': + val = va_arg(args, unsigned int); + base = 16; + break; +#if 0 /* unused (and wrong on LLP64 systems) */ + case 'p': + val = (unsigned long) va_arg(args, void *); + base = 16; + neg = 2; + break; +#endif /* unused (and wrong on LLP64 systems) */ + case 's': + str = va_arg(args, char *); + break; + case 'c': + num[0] = va_arg(args, int); + num[1] = 0; + str = num; + break; +#if 0 /* do we always have strerror() in embedded ? */ + case 'm': + str = strerror(errno); + break; +#endif /* do we always have strerror() in embedded ? */ + case 'I': + ip = va_arg(args, u32_t); + ip = lwip_ntohl(ip); + ppp_slprintf(num, sizeof(num), "%d.%d.%d.%d", (ip >> 24) & 0xff, + (ip >> 16) & 0xff, (ip >> 8) & 0xff, ip & 0xff); + str = num; + break; +#if 0 /* need port */ + case 't': + time(&t); + str = ctime(&t); + str += 4; /* chop off the day name */ + str[15] = 0; /* chop off year and newline */ + break; +#endif /* need port */ + case 'v': /* "visible" string */ + case 'q': /* quoted string */ + quoted = c == 'q'; + p = va_arg(args, unsigned char *); + if (p == NULL) + p = (const unsigned char *)""; + if (fillch == '0' && prec >= 0) { + n = prec; + } else { + n = strlen((const char *)p); + if (prec >= 0 && n > prec) + n = prec; + } + while (n > 0 && buflen > 0) { + c = *p++; + --n; + if (!quoted && c >= 0x80) { + OUTCHAR('M'); + OUTCHAR('-'); + c -= 0x80; + } + if (quoted && (c == '"' || c == '\\')) + OUTCHAR('\\'); + if (c < 0x20 || (0x7f <= c && c < 0xa0)) { + if (quoted) { + OUTCHAR('\\'); + switch (c) { + case '\t': OUTCHAR('t'); break; + case '\n': OUTCHAR('n'); break; + case '\b': OUTCHAR('b'); break; + case '\f': OUTCHAR('f'); break; + default: + OUTCHAR('x'); + OUTCHAR(hexchars[c >> 4]); + OUTCHAR(hexchars[c & 0xf]); + } + } else { + if (c == '\t') + OUTCHAR(c); + else { + OUTCHAR('^'); + OUTCHAR(c ^ 0x40); + } + } + } else + OUTCHAR(c); + } + continue; +#if PRINTPKT_SUPPORT + case 'P': /* print PPP packet */ + bufinfo.ptr = buf; + bufinfo.len = buflen + 1; + p = va_arg(args, unsigned char *); + n = va_arg(args, int); + ppp_format_packet(p, n, ppp_vslp_printer, &bufinfo); + buf = bufinfo.ptr; + buflen = bufinfo.len - 1; + continue; +#endif /* PRINTPKT_SUPPORT */ + case 'B': + p = va_arg(args, unsigned char *); + for (n = prec; n > 0; --n) { + c = *p++; + if (fillch == ' ') + OUTCHAR(' '); + OUTCHAR(hexchars[(c >> 4) & 0xf]); + OUTCHAR(hexchars[c & 0xf]); + } + continue; + default: + *buf++ = '%'; + if (c != '%') + --fmt; /* so %z outputs %z etc. */ + --buflen; + continue; + } + if (base != 0) { + str = num + sizeof(num); + *--str = 0; + while (str > num + neg) { + *--str = hexchars[val % base]; + val = val / base; + if (--prec <= 0 && val == 0) + break; + } + switch (neg) { + case 1: + *--str = '-'; + break; + case 2: + *--str = 'x'; + *--str = '0'; + break; + default: + break; + } + len = num + sizeof(num) - 1 - str; + } else { + len = strlen(str); + if (prec >= 0 && len > prec) + len = prec; + } + if (width > 0) { + if (width > buflen) + width = buflen; + if ((n = width - len) > 0) { + buflen -= n; + for (; n > 0; --n) + *buf++ = fillch; + } + } + if (len > buflen) + len = buflen; + memcpy(buf, str, len); + buf += len; + buflen -= len; + } + *buf = 0; + return buf - buf0; +} + +#if PRINTPKT_SUPPORT +/* + * vslp_printer - used in processing a %P format + */ +static void ppp_vslp_printer(void *arg, const char *fmt, ...) { + int n; + va_list pvar; + struct buffer_info *bi; + + va_start(pvar, fmt); + bi = (struct buffer_info *) arg; + n = ppp_vslprintf(bi->ptr, bi->len, fmt, pvar); + va_end(pvar); + + bi->ptr += n; + bi->len -= n; +} +#endif /* PRINTPKT_SUPPORT */ + +#if 0 /* UNUSED */ +/* + * log_packet - format a packet and log it. + */ + +void +log_packet(p, len, prefix, level) + u_char *p; + int len; + char *prefix; + int level; +{ + init_pr_log(prefix, level); + ppp_format_packet(p, len, pr_log, &level); + end_pr_log(); +} +#endif /* UNUSED */ + +#if PRINTPKT_SUPPORT +/* + * ppp_format_packet - make a readable representation of a packet, + * calling `printer(arg, format, ...)' to output it. + */ +static void ppp_format_packet(const u_char *p, int len, + void (*printer) (void *, const char *, ...), void *arg) { + int i, n; + u_short proto; + const struct protent *protp; + + if (len >= 2) { + GETSHORT(proto, p); + len -= 2; + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (proto == protp->protocol) + break; + if (protp != NULL) { + printer(arg, "[%s", protp->name); + n = (*protp->printpkt)(p, len, printer, arg); + printer(arg, "]"); + p += n; + len -= n; + } else { + for (i = 0; (protp = protocols[i]) != NULL; ++i) + if (proto == (protp->protocol & ~0x8000)) + break; + if (protp != 0 && protp->data_name != 0) { + printer(arg, "[%s data]", protp->data_name); + if (len > 8) + printer(arg, "%.8B ...", p); + else + printer(arg, "%.*B", len, p); + len = 0; + } else + printer(arg, "[proto=0x%x]", proto); + } + } + + if (len > 32) + printer(arg, "%.32B ...", p); + else + printer(arg, "%.*B", len, p); +} +#endif /* PRINTPKT_SUPPORT */ + +#if 0 /* UNUSED */ +/* + * init_pr_log, end_pr_log - initialize and finish use of pr_log. + */ + +static char line[256]; /* line to be logged accumulated here */ +static char *linep; /* current pointer within line */ +static int llevel; /* level for logging */ + +void +init_pr_log(prefix, level) + const char *prefix; + int level; +{ + linep = line; + if (prefix != NULL) { + ppp_strlcpy(line, prefix, sizeof(line)); + linep = line + strlen(line); + } + llevel = level; +} + +void +end_pr_log() +{ + if (linep != line) { + *linep = 0; + ppp_log_write(llevel, line); + } +} + +/* + * pr_log - printer routine for outputting to log + */ +void +pr_log (void *arg, const char *fmt, ...) +{ + int l, n; + va_list pvar; + char *p, *eol; + char buf[256]; + + va_start(pvar, fmt); + n = ppp_vslprintf(buf, sizeof(buf), fmt, pvar); + va_end(pvar); + + p = buf; + eol = strchr(buf, '\n'); + if (linep != line) { + l = (eol == NULL)? n: eol - buf; + if (linep + l < line + sizeof(line)) { + if (l > 0) { + memcpy(linep, buf, l); + linep += l; + } + if (eol == NULL) + return; + p = eol + 1; + eol = strchr(p, '\n'); + } + *linep = 0; + ppp_log_write(llevel, line); + linep = line; + } + + while (eol != NULL) { + *eol = 0; + ppp_log_write(llevel, p); + p = eol + 1; + eol = strchr(p, '\n'); + } + + /* assumes sizeof(buf) <= sizeof(line) */ + l = buf + n - p; + if (l > 0) { + memcpy(line, p, n); + linep = line + l; + } +} +#endif /* UNUSED */ + +/* + * ppp_print_string - print a readable representation of a string using + * printer. + */ +void ppp_print_string(const u_char *p, int len, void (*printer) (void *, const char *, ...), void *arg) { + int c; + + printer(arg, "\""); + for (; len > 0; --len) { + c = *p++; + if (' ' <= c && c <= '~') { + if (c == '\\' || c == '"') + printer(arg, "\\"); + printer(arg, "%c", c); + } else { + switch (c) { + case '\n': + printer(arg, "\\n"); + break; + case '\r': + printer(arg, "\\r"); + break; + case '\t': + printer(arg, "\\t"); + break; + default: + printer(arg, "\\%.3o", (u8_t)c); + /* no break */ + } + } + } + printer(arg, "\""); +} + +/* + * ppp_logit - does the hard work for fatal et al. + */ +static void ppp_logit(int level, const char *fmt, va_list args) { + char buf[1024]; + + ppp_vslprintf(buf, sizeof(buf), fmt, args); + ppp_log_write(level, buf); +} + +static void ppp_log_write(int level, char *buf) { + LWIP_UNUSED_ARG(level); /* necessary if PPPDEBUG is defined to an empty function */ + LWIP_UNUSED_ARG(buf); + PPPDEBUG(level, ("%s\n", buf) ); +#if 0 + if (log_to_fd >= 0 && (level != LOG_DEBUG || debug)) { + int n = strlen(buf); + + if (n > 0 && buf[n-1] == '\n') + --n; + if (write(log_to_fd, buf, n) != n + || write(log_to_fd, "\n", 1) != 1) + log_to_fd = -1; + } +#endif +} + +/* + * ppp_fatal - log an error message and die horribly. + */ +void ppp_fatal(const char *fmt, ...) { + va_list pvar; + + va_start(pvar, fmt); + ppp_logit(LOG_ERR, fmt, pvar); + va_end(pvar); + + LWIP_ASSERT("ppp_fatal", 0); /* as promised */ +} + +/* + * ppp_error - log an error message. + */ +void ppp_error(const char *fmt, ...) { + va_list pvar; + + va_start(pvar, fmt); + ppp_logit(LOG_ERR, fmt, pvar); + va_end(pvar); +#if 0 /* UNUSED */ + ++error_count; +#endif /* UNUSED */ +} + +/* + * ppp_warn - log a warning message. + */ +void ppp_warn(const char *fmt, ...) { + va_list pvar; + + va_start(pvar, fmt); + ppp_logit(LOG_WARNING, fmt, pvar); + va_end(pvar); +} + +/* + * ppp_notice - log a notice-level message. + */ +void ppp_notice(const char *fmt, ...) { + va_list pvar; + + va_start(pvar, fmt); + ppp_logit(LOG_NOTICE, fmt, pvar); + va_end(pvar); +} + +/* + * ppp_info - log an informational message. + */ +void ppp_info(const char *fmt, ...) { + va_list pvar; + + va_start(pvar, fmt); + ppp_logit(LOG_INFO, fmt, pvar); + va_end(pvar); +} + +/* + * ppp_dbglog - log a debug message. + */ +void ppp_dbglog(const char *fmt, ...) { + va_list pvar; + + va_start(pvar, fmt); + ppp_logit(LOG_DEBUG, fmt, pvar); + va_end(pvar); +} + +#if PRINTPKT_SUPPORT +/* + * ppp_dump_packet - print out a packet in readable form if it is interesting. + * Assumes len >= PPP_HDRLEN. + */ +void ppp_dump_packet(ppp_pcb *pcb, const char *tag, unsigned char *p, int len) { + int proto; + + /* + * don't print data packets, i.e. IPv4, IPv6, VJ, and compressed packets. + */ + proto = (p[0] << 8) + p[1]; + if (proto < 0xC000 && (proto & ~0x8000) == proto) + return; + + /* + * don't print valid LCP echo request/reply packets if the link is up. + */ + if (proto == PPP_LCP && pcb->phase == PPP_PHASE_RUNNING && len >= 2 + HEADERLEN) { + unsigned char *lcp = p + 2; + int l = (lcp[2] << 8) + lcp[3]; + + if ((lcp[0] == ECHOREQ || lcp[0] == ECHOREP) + && l >= HEADERLEN && l <= len - 2) + return; + } + + ppp_dbglog("%s %P", tag, p, len); +} +#endif /* PRINTPKT_SUPPORT */ + +#if 0 /* Unused */ + +/* + * complete_read - read a full `count' bytes from fd, + * unless end-of-file or an error other than EINTR is encountered. + */ +ssize_t +complete_read(int fd, void *buf, size_t count) +{ + size_t done; + ssize_t nb; + char *ptr = buf; + + for (done = 0; done < count; ) { + nb = read(fd, ptr, count - done); + if (nb < 0) { + if (errno == EINTR) + continue; + return -1; + } + if (nb == 0) + break; + done += nb; + ptr += nb; + } + return done; +} + +/* Procedures for locking the serial device using a lock file. */ +#ifndef LOCK_DIR +#ifdef __linux__ +#define LOCK_DIR "/var/lock" +#else +#ifdef SVR4 +#define LOCK_DIR "/var/spool/locks" +#else +#define LOCK_DIR "/var/spool/lock" +#endif +#endif +#endif /* LOCK_DIR */ + +static char lock_file[MAXPATHLEN]; + +/* + * lock - create a lock file for the named device + */ +int +lock(dev) + char *dev; +{ +#ifdef LOCKLIB + int result; + + result = mklock (dev, (void *) 0); + if (result == 0) { + ppp_strlcpy(lock_file, dev, sizeof(lock_file)); + return 0; + } + + if (result > 0) + ppp_notice("Device %s is locked by pid %d", dev, result); + else + ppp_error("Can't create lock file %s", lock_file); + return -1; + +#else /* LOCKLIB */ + + char lock_buffer[12]; + int fd, pid, n; + +#ifdef SVR4 + struct stat sbuf; + + if (stat(dev, &sbuf) < 0) { + ppp_error("Can't get device number for %s: %m", dev); + return -1; + } + if ((sbuf.st_mode & S_IFMT) != S_IFCHR) { + ppp_error("Can't lock %s: not a character device", dev); + return -1; + } + ppp_slprintf(lock_file, sizeof(lock_file), "%s/LK.%03d.%03d.%03d", + LOCK_DIR, major(sbuf.st_dev), + major(sbuf.st_rdev), minor(sbuf.st_rdev)); +#else + char *p; + char lockdev[MAXPATHLEN]; + + if ((p = strstr(dev, "dev/")) != NULL) { + dev = p + 4; + strncpy(lockdev, dev, MAXPATHLEN-1); + lockdev[MAXPATHLEN-1] = 0; + while ((p = strrchr(lockdev, '/')) != NULL) { + *p = '_'; + } + dev = lockdev; + } else + if ((p = strrchr(dev, '/')) != NULL) + dev = p + 1; + + ppp_slprintf(lock_file, sizeof(lock_file), "%s/LCK..%s", LOCK_DIR, dev); +#endif + + while ((fd = open(lock_file, O_EXCL | O_CREAT | O_RDWR, 0644)) < 0) { + if (errno != EEXIST) { + ppp_error("Can't create lock file %s: %m", lock_file); + break; + } + + /* Read the lock file to find out who has the device locked. */ + fd = open(lock_file, O_RDONLY, 0); + if (fd < 0) { + if (errno == ENOENT) /* This is just a timing problem. */ + continue; + ppp_error("Can't open existing lock file %s: %m", lock_file); + break; + } +#ifndef LOCK_BINARY + n = read(fd, lock_buffer, 11); +#else + n = read(fd, &pid, sizeof(pid)); +#endif /* LOCK_BINARY */ + close(fd); + fd = -1; + if (n <= 0) { + ppp_error("Can't read pid from lock file %s", lock_file); + break; + } + + /* See if the process still exists. */ +#ifndef LOCK_BINARY + lock_buffer[n] = 0; + pid = atoi(lock_buffer); +#endif /* LOCK_BINARY */ + if (pid == getpid()) + return 1; /* somebody else locked it for us */ + if (pid == 0 + || (kill(pid, 0) == -1 && errno == ESRCH)) { + if (unlink (lock_file) == 0) { + ppp_notice("Removed stale lock on %s (pid %d)", dev, pid); + continue; + } + ppp_warn("Couldn't remove stale lock on %s", dev); + } else + ppp_notice("Device %s is locked by pid %d", dev, pid); + break; + } + + if (fd < 0) { + lock_file[0] = 0; + return -1; + } + + pid = getpid(); +#ifndef LOCK_BINARY + ppp_slprintf(lock_buffer, sizeof(lock_buffer), "%10d\n", pid); + write (fd, lock_buffer, 11); +#else + write(fd, &pid, sizeof (pid)); +#endif + close(fd); + return 0; + +#endif +} + +/* + * relock - called to update our lockfile when we are about to detach, + * thus changing our pid (we fork, the child carries on, and the parent dies). + * Note that this is called by the parent, with pid equal to the pid + * of the child. This avoids a potential race which would exist if + * we had the child rewrite the lockfile (the parent might die first, + * and another process could think the lock was stale if it checked + * between when the parent died and the child rewrote the lockfile). + */ +int +relock(pid) + int pid; +{ +#ifdef LOCKLIB + /* XXX is there a way to do this? */ + return -1; +#else /* LOCKLIB */ + + int fd; + char lock_buffer[12]; + + if (lock_file[0] == 0) + return -1; + fd = open(lock_file, O_WRONLY, 0); + if (fd < 0) { + ppp_error("Couldn't reopen lock file %s: %m", lock_file); + lock_file[0] = 0; + return -1; + } + +#ifndef LOCK_BINARY + ppp_slprintf(lock_buffer, sizeof(lock_buffer), "%10d\n", pid); + write (fd, lock_buffer, 11); +#else + write(fd, &pid, sizeof(pid)); +#endif /* LOCK_BINARY */ + close(fd); + return 0; + +#endif /* LOCKLIB */ +} + +/* + * unlock - remove our lockfile + */ +void +unlock() +{ + if (lock_file[0]) { +#ifdef LOCKLIB + (void) rmlock(lock_file, (void *) 0); +#else + unlink(lock_file); +#endif + lock_file[0] = 0; + } +} + +#endif /* Unused */ + +#endif /* PPP_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/vj.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/vj.c index 8ba94ba4..3fecba69 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/vj.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/ppp/vj.c @@ -1,685 +1,685 @@ -/* - * Routines to compress and uncompess tcp packets (for transmission - * over low speed serial lines. - * - * Copyright (c) 1989 Regents of the University of California. - * All rights reserved. - * - * Redistribution and use in source and binary forms are permitted - * provided that the above copyright notice and this paragraph are - * duplicated in all such forms and that any documentation, - * advertising materials, and other materials related to such - * distribution and use acknowledge that the software was developed - * by the University of California, Berkeley. The name of the - * University may not be used to endorse or promote products derived - * from this software without specific prior written permission. - * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR - * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED - * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. - * - * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: - * Initial distribution. - * - * Modified June 1993 by Paul Mackerras, paulus@cs.anu.edu.au, - * so that the entire packet being decompressed doesn't have - * to be in contiguous memory (just the compressed header). - * - * Modified March 1998 by Guy Lancaster, glanca@gesn.com, - * for a 16 bit processor. - */ - -#include "netif/ppp/ppp_opts.h" -#if PPP_SUPPORT && VJ_SUPPORT /* don't build if not configured for use in lwipopts.h */ - -#include "netif/ppp/ppp_impl.h" -#include "netif/ppp/pppdebug.h" - -#include "netif/ppp/vj.h" - -#include - -#if LINK_STATS -#define INCR(counter) ++comp->stats.counter -#else -#define INCR(counter) -#endif - -void -vj_compress_init(struct vjcompress *comp) -{ - u8_t i; - struct cstate *tstate = comp->tstate; - -#if MAX_SLOTS == 0 - memset((char *)comp, 0, sizeof(*comp)); -#endif - comp->maxSlotIndex = MAX_SLOTS - 1; - comp->compressSlot = 0; /* Disable slot ID compression by default. */ - for (i = MAX_SLOTS - 1; i > 0; --i) { - tstate[i].cs_id = i; - tstate[i].cs_next = &tstate[i - 1]; - } - tstate[0].cs_next = &tstate[MAX_SLOTS - 1]; - tstate[0].cs_id = 0; - comp->last_cs = &tstate[0]; - comp->last_recv = 255; - comp->last_xmit = 255; - comp->flags = VJF_TOSS; -} - - -/* ENCODE encodes a number that is known to be non-zero. ENCODEZ - * checks for zero (since zero has to be encoded in the long, 3 byte - * form). - */ -#define ENCODE(n) { \ - if ((u16_t)(n) >= 256) { \ - *cp++ = 0; \ - cp[1] = (u8_t)(n); \ - cp[0] = (u8_t)((n) >> 8); \ - cp += 2; \ - } else { \ - *cp++ = (u8_t)(n); \ - } \ -} -#define ENCODEZ(n) { \ - if ((u16_t)(n) >= 256 || (u16_t)(n) == 0) { \ - *cp++ = 0; \ - cp[1] = (u8_t)(n); \ - cp[0] = (u8_t)((n) >> 8); \ - cp += 2; \ - } else { \ - *cp++ = (u8_t)(n); \ - } \ -} - -#define DECODEL(f) { \ - if (*cp == 0) {\ - u32_t tmp_ = lwip_ntohl(f) + ((cp[1] << 8) | cp[2]); \ - (f) = lwip_htonl(tmp_); \ - cp += 3; \ - } else { \ - u32_t tmp_ = lwip_ntohl(f) + (u32_t)*cp++; \ - (f) = lwip_htonl(tmp_); \ - } \ -} - -#define DECODES(f) { \ - if (*cp == 0) {\ - u16_t tmp_ = lwip_ntohs(f) + (((u16_t)cp[1] << 8) | cp[2]); \ - (f) = lwip_htons(tmp_); \ - cp += 3; \ - } else { \ - u16_t tmp_ = lwip_ntohs(f) + (u16_t)*cp++; \ - (f) = lwip_htons(tmp_); \ - } \ -} - -#define DECODEU(f) { \ - if (*cp == 0) {\ - (f) = lwip_htons(((u16_t)cp[1] << 8) | cp[2]); \ - cp += 3; \ - } else { \ - (f) = lwip_htons((u16_t)*cp++); \ - } \ -} - -/* Helper structures for unaligned *u32_t and *u16_t accesses */ -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct vj_u32_t { - PACK_STRUCT_FIELD(u32_t v); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct vj_u16_t { - PACK_STRUCT_FIELD(u16_t v); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -/* - * vj_compress_tcp - Attempt to do Van Jacobson header compression on a - * packet. This assumes that nb and comp are not null and that the first - * buffer of the chain contains a valid IP header. - * Return the VJ type code indicating whether or not the packet was - * compressed. - */ -u8_t -vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb) -{ - struct pbuf *np = *pb; - struct ip_hdr *ip = (struct ip_hdr *)np->payload; - struct cstate *cs = comp->last_cs->cs_next; - u16_t ilen = IPH_HL(ip); - u16_t hlen; - struct tcp_hdr *oth; - struct tcp_hdr *th; - u16_t deltaS, deltaA = 0; - u32_t deltaL; - u32_t changes = 0; - u8_t new_seq[16]; - u8_t *cp = new_seq; - - /* - * Check that the packet is IP proto TCP. - */ - if (IPH_PROTO(ip) != IP_PROTO_TCP) { - return (TYPE_IP); - } - - /* - * Bail if this is an IP fragment or if the TCP packet isn't - * `compressible' (i.e., ACK isn't set or some other control bit is - * set). - */ - if ((IPH_OFFSET(ip) & PP_HTONS(0x3fff)) || np->tot_len < 40) { - return (TYPE_IP); - } - th = (struct tcp_hdr *)&((struct vj_u32_t*)ip)[ilen]; - if ((TCPH_FLAGS(th) & (TCP_SYN|TCP_FIN|TCP_RST|TCP_ACK)) != TCP_ACK) { - return (TYPE_IP); - } - - /* Check that the TCP/IP headers are contained in the first buffer. */ - hlen = ilen + TCPH_HDRLEN(th); - hlen <<= 2; - if (np->len < hlen) { - PPPDEBUG(LOG_INFO, ("vj_compress_tcp: header len %d spans buffers\n", hlen)); - return (TYPE_IP); - } - - /* TCP stack requires that we don't change the packet payload, therefore we copy - * the whole packet before compression. */ - np = pbuf_clone(PBUF_RAW, PBUF_RAM, *pb); - if (!np) { - return (TYPE_IP); - } - - *pb = np; - ip = (struct ip_hdr *)np->payload; - - /* - * Packet is compressible -- we're going to send either a - * COMPRESSED_TCP or UNCOMPRESSED_TCP packet. Either way we need - * to locate (or create) the connection state. Special case the - * most recently used connection since it's most likely to be used - * again & we don't have to do any reordering if it's used. - */ - INCR(vjs_packets); - if (!ip4_addr_cmp(&ip->src, &cs->cs_ip.src) - || !ip4_addr_cmp(&ip->dest, &cs->cs_ip.dest) - || (*(struct vj_u32_t*)th).v != (((struct vj_u32_t*)&cs->cs_ip)[IPH_HL(&cs->cs_ip)]).v) { - /* - * Wasn't the first -- search for it. - * - * States are kept in a circularly linked list with - * last_cs pointing to the end of the list. The - * list is kept in lru order by moving a state to the - * head of the list whenever it is referenced. Since - * the list is short and, empirically, the connection - * we want is almost always near the front, we locate - * states via linear search. If we don't find a state - * for the datagram, the oldest state is (re-)used. - */ - struct cstate *lcs; - struct cstate *lastcs = comp->last_cs; - - do { - lcs = cs; cs = cs->cs_next; - INCR(vjs_searches); - if (ip4_addr_cmp(&ip->src, &cs->cs_ip.src) - && ip4_addr_cmp(&ip->dest, &cs->cs_ip.dest) - && (*(struct vj_u32_t*)th).v == (((struct vj_u32_t*)&cs->cs_ip)[IPH_HL(&cs->cs_ip)]).v) { - goto found; - } - } while (cs != lastcs); - - /* - * Didn't find it -- re-use oldest cstate. Send an - * uncompressed packet that tells the other side what - * connection number we're using for this conversation. - * Note that since the state list is circular, the oldest - * state points to the newest and we only need to set - * last_cs to update the lru linkage. - */ - INCR(vjs_misses); - comp->last_cs = lcs; - goto uncompressed; - - found: - /* - * Found it -- move to the front on the connection list. - */ - if (cs == lastcs) { - comp->last_cs = lcs; - } else { - lcs->cs_next = cs->cs_next; - cs->cs_next = lastcs->cs_next; - lastcs->cs_next = cs; - } - } - - oth = (struct tcp_hdr *)&((struct vj_u32_t*)&cs->cs_ip)[ilen]; - deltaS = ilen; - - /* - * Make sure that only what we expect to change changed. The first - * line of the `if' checks the IP protocol version, header length & - * type of service. The 2nd line checks the "Don't fragment" bit. - * The 3rd line checks the time-to-live and protocol (the protocol - * check is unnecessary but costless). The 4th line checks the TCP - * header length. The 5th line checks IP options, if any. The 6th - * line checks TCP options, if any. If any of these things are - * different between the previous & current datagram, we send the - * current datagram `uncompressed'. - */ - if ((((struct vj_u16_t*)ip)[0]).v != (((struct vj_u16_t*)&cs->cs_ip)[0]).v - || (((struct vj_u16_t*)ip)[3]).v != (((struct vj_u16_t*)&cs->cs_ip)[3]).v - || (((struct vj_u16_t*)ip)[4]).v != (((struct vj_u16_t*)&cs->cs_ip)[4]).v - || TCPH_HDRLEN(th) != TCPH_HDRLEN(oth) - || (deltaS > 5 && BCMP(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2)) - || (TCPH_HDRLEN(th) > 5 && BCMP(th + 1, oth + 1, (TCPH_HDRLEN(th) - 5) << 2))) { - goto uncompressed; - } - - /* - * Figure out which of the changing fields changed. The - * receiver expects changes in the order: urgent, window, - * ack, seq (the order minimizes the number of temporaries - * needed in this section of code). - */ - if (TCPH_FLAGS(th) & TCP_URG) { - deltaS = lwip_ntohs(th->urgp); - ENCODEZ(deltaS); - changes |= NEW_U; - } else if (th->urgp != oth->urgp) { - /* argh! URG not set but urp changed -- a sensible - * implementation should never do this but RFC793 - * doesn't prohibit the change so we have to deal - * with it. */ - goto uncompressed; - } - - if ((deltaS = (u16_t)(lwip_ntohs(th->wnd) - lwip_ntohs(oth->wnd))) != 0) { - ENCODE(deltaS); - changes |= NEW_W; - } - - if ((deltaL = lwip_ntohl(th->ackno) - lwip_ntohl(oth->ackno)) != 0) { - if (deltaL > 0xffff) { - goto uncompressed; - } - deltaA = (u16_t)deltaL; - ENCODE(deltaA); - changes |= NEW_A; - } - - if ((deltaL = lwip_ntohl(th->seqno) - lwip_ntohl(oth->seqno)) != 0) { - if (deltaL > 0xffff) { - goto uncompressed; - } - deltaS = (u16_t)deltaL; - ENCODE(deltaS); - changes |= NEW_S; - } - - switch(changes) { - case 0: - /* - * Nothing changed. If this packet contains data and the - * last one didn't, this is probably a data packet following - * an ack (normal on an interactive connection) and we send - * it compressed. Otherwise it's probably a retransmit, - * retransmitted ack or window probe. Send it uncompressed - * in case the other side missed the compressed version. - */ - if (IPH_LEN(ip) != IPH_LEN(&cs->cs_ip) && - lwip_ntohs(IPH_LEN(&cs->cs_ip)) == hlen) { - break; - } - /* no break */ - /* fall through */ - - case SPECIAL_I: - case SPECIAL_D: - /* - * actual changes match one of our special case encodings -- - * send packet uncompressed. - */ - goto uncompressed; - - case NEW_S|NEW_A: - if (deltaS == deltaA && deltaS == lwip_ntohs(IPH_LEN(&cs->cs_ip)) - hlen) { - /* special case for echoed terminal traffic */ - changes = SPECIAL_I; - cp = new_seq; - } - break; - - case NEW_S: - if (deltaS == lwip_ntohs(IPH_LEN(&cs->cs_ip)) - hlen) { - /* special case for data xfer */ - changes = SPECIAL_D; - cp = new_seq; - } - break; - default: - break; - } - - deltaS = (u16_t)(lwip_ntohs(IPH_ID(ip)) - lwip_ntohs(IPH_ID(&cs->cs_ip))); - if (deltaS != 1) { - ENCODEZ(deltaS); - changes |= NEW_I; - } - if (TCPH_FLAGS(th) & TCP_PSH) { - changes |= TCP_PUSH_BIT; - } - /* - * Grab the cksum before we overwrite it below. Then update our - * state with this packet's header. - */ - deltaA = lwip_ntohs(th->chksum); - MEMCPY(&cs->cs_ip, ip, hlen); - - /* - * We want to use the original packet as our compressed packet. - * (cp - new_seq) is the number of bytes we need for compressed - * sequence numbers. In addition we need one byte for the change - * mask, one for the connection id and two for the tcp checksum. - * So, (cp - new_seq) + 4 bytes of header are needed. hlen is how - * many bytes of the original packet to toss so subtract the two to - * get the new packet size. - */ - deltaS = (u16_t)(cp - new_seq); - if (!comp->compressSlot || comp->last_xmit != cs->cs_id) { - comp->last_xmit = cs->cs_id; - hlen -= deltaS + 4; - if (pbuf_remove_header(np, hlen)){ - /* Can we cope with this failing? Just assert for now */ - LWIP_ASSERT("pbuf_remove_header failed\n", 0); - } - cp = (u8_t*)np->payload; - *cp++ = (u8_t)(changes | NEW_C); - *cp++ = cs->cs_id; - } else { - hlen -= deltaS + 3; - if (pbuf_remove_header(np, hlen)) { - /* Can we cope with this failing? Just assert for now */ - LWIP_ASSERT("pbuf_remove_header failed\n", 0); - } - cp = (u8_t*)np->payload; - *cp++ = (u8_t)changes; - } - *cp++ = (u8_t)(deltaA >> 8); - *cp++ = (u8_t)deltaA; - MEMCPY(cp, new_seq, deltaS); - INCR(vjs_compressed); - return (TYPE_COMPRESSED_TCP); - - /* - * Update connection state cs & send uncompressed packet (that is, - * a regular ip/tcp packet but with the 'conversation id' we hope - * to use on future compressed packets in the protocol field). - */ -uncompressed: - MEMCPY(&cs->cs_ip, ip, hlen); - IPH_PROTO_SET(ip, cs->cs_id); - comp->last_xmit = cs->cs_id; - return (TYPE_UNCOMPRESSED_TCP); -} - -/* - * Called when we may have missed a packet. - */ -void -vj_uncompress_err(struct vjcompress *comp) -{ - comp->flags |= VJF_TOSS; - INCR(vjs_errorin); -} - -/* - * "Uncompress" a packet of type TYPE_UNCOMPRESSED_TCP. - * Return 0 on success, -1 on failure. - */ -int -vj_uncompress_uncomp(struct pbuf *nb, struct vjcompress *comp) -{ - u32_t hlen; - struct cstate *cs; - struct ip_hdr *ip; - - ip = (struct ip_hdr *)nb->payload; - hlen = IPH_HL(ip) << 2; - if (IPH_PROTO(ip) >= MAX_SLOTS - || hlen + sizeof(struct tcp_hdr) > nb->len - || (hlen += TCPH_HDRLEN_BYTES((struct tcp_hdr *)&((char *)ip)[hlen])) - > nb->len - || hlen > MAX_HDR) { - PPPDEBUG(LOG_INFO, ("vj_uncompress_uncomp: bad cid=%d, hlen=%d buflen=%d\n", - IPH_PROTO(ip), hlen, nb->len)); - vj_uncompress_err(comp); - return -1; - } - cs = &comp->rstate[comp->last_recv = IPH_PROTO(ip)]; - comp->flags &=~ VJF_TOSS; - IPH_PROTO_SET(ip, IP_PROTO_TCP); - /* copy from/to bigger buffers checked above instead of cs->cs_ip and ip - just to help static code analysis to see this is correct ;-) */ - MEMCPY(&cs->cs_hdr, nb->payload, hlen); - cs->cs_hlen = (u16_t)hlen; - INCR(vjs_uncompressedin); - return 0; -} - -/* - * Uncompress a packet of type TYPE_COMPRESSED_TCP. - * The packet is composed of a buffer chain and the first buffer - * must contain an accurate chain length. - * The first buffer must include the entire compressed TCP/IP header. - * This procedure replaces the compressed header with the uncompressed - * header and returns the length of the VJ header. - */ -int -vj_uncompress_tcp(struct pbuf **nb, struct vjcompress *comp) -{ - u8_t *cp; - struct tcp_hdr *th; - struct cstate *cs; - struct vj_u16_t *bp; - struct pbuf *n0 = *nb; - u32_t tmp; - u32_t vjlen, hlen, changes; - - INCR(vjs_compressedin); - cp = (u8_t*)n0->payload; - changes = *cp++; - if (changes & NEW_C) { - /* - * Make sure the state index is in range, then grab the state. - * If we have a good state index, clear the 'discard' flag. - */ - if (*cp >= MAX_SLOTS) { - PPPDEBUG(LOG_INFO, ("vj_uncompress_tcp: bad cid=%d\n", *cp)); - goto bad; - } - - comp->flags &=~ VJF_TOSS; - comp->last_recv = *cp++; - } else { - /* - * this packet has an implicit state index. If we've - * had a line error since the last time we got an - * explicit state index, we have to toss the packet. - */ - if (comp->flags & VJF_TOSS) { - PPPDEBUG(LOG_INFO, ("vj_uncompress_tcp: tossing\n")); - INCR(vjs_tossed); - return (-1); - } - } - cs = &comp->rstate[comp->last_recv]; - hlen = IPH_HL(&cs->cs_ip) << 2; - th = (struct tcp_hdr *)&((u8_t*)&cs->cs_ip)[hlen]; - th->chksum = lwip_htons((*cp << 8) | cp[1]); - cp += 2; - if (changes & TCP_PUSH_BIT) { - TCPH_SET_FLAG(th, TCP_PSH); - } else { - TCPH_UNSET_FLAG(th, TCP_PSH); - } - - switch (changes & SPECIALS_MASK) { - case SPECIAL_I: - { - u32_t i = lwip_ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen; - /* some compilers can't nest inline assembler.. */ - tmp = lwip_ntohl(th->ackno) + i; - th->ackno = lwip_htonl(tmp); - tmp = lwip_ntohl(th->seqno) + i; - th->seqno = lwip_htonl(tmp); - } - break; - - case SPECIAL_D: - /* some compilers can't nest inline assembler.. */ - tmp = lwip_ntohl(th->seqno) + lwip_ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen; - th->seqno = lwip_htonl(tmp); - break; - - default: - if (changes & NEW_U) { - TCPH_SET_FLAG(th, TCP_URG); - DECODEU(th->urgp); - } else { - TCPH_UNSET_FLAG(th, TCP_URG); - } - if (changes & NEW_W) { - DECODES(th->wnd); - } - if (changes & NEW_A) { - DECODEL(th->ackno); - } - if (changes & NEW_S) { - DECODEL(th->seqno); - } - break; - } - if (changes & NEW_I) { - DECODES(cs->cs_ip._id); - } else { - IPH_ID_SET(&cs->cs_ip, lwip_ntohs(IPH_ID(&cs->cs_ip)) + 1); - IPH_ID_SET(&cs->cs_ip, lwip_htons(IPH_ID(&cs->cs_ip))); - } - - /* - * At this point, cp points to the first byte of data in the - * packet. Fill in the IP total length and update the IP - * header checksum. - */ - vjlen = (u16_t)(cp - (u8_t*)n0->payload); - if (n0->len < vjlen) { - /* - * We must have dropped some characters (crc should detect - * this but the old slip framing won't) - */ - PPPDEBUG(LOG_INFO, ("vj_uncompress_tcp: head buffer %d too short %d\n", - n0->len, vjlen)); - goto bad; - } - -#if BYTE_ORDER == LITTLE_ENDIAN - tmp = n0->tot_len - vjlen + cs->cs_hlen; - IPH_LEN_SET(&cs->cs_ip, lwip_htons((u16_t)tmp)); -#else - IPH_LEN_SET(&cs->cs_ip, lwip_htons(n0->tot_len - vjlen + cs->cs_hlen)); -#endif - - /* recompute the ip header checksum */ - bp = (struct vj_u16_t*) &cs->cs_ip; - IPH_CHKSUM_SET(&cs->cs_ip, 0); - for (tmp = 0; hlen > 0; hlen -= 2) { - tmp += (*bp++).v; - } - tmp = (tmp & 0xffff) + (tmp >> 16); - tmp = (tmp & 0xffff) + (tmp >> 16); - IPH_CHKSUM_SET(&cs->cs_ip, (u16_t)(~tmp)); - - /* Remove the compressed header and prepend the uncompressed header. */ - if (pbuf_remove_header(n0, vjlen)) { - /* Can we cope with this failing? Just assert for now */ - LWIP_ASSERT("pbuf_remove_header failed\n", 0); - goto bad; - } - - if(LWIP_MEM_ALIGN(n0->payload) != n0->payload) { - struct pbuf *np; - -#if IP_FORWARD - /* If IP forwarding is enabled we are using a PBUF_LINK packet type so - * the packet is being allocated with enough header space to be - * forwarded (to Ethernet for example). - */ - np = pbuf_alloc(PBUF_LINK, n0->len + cs->cs_hlen, PBUF_POOL); -#else /* IP_FORWARD */ - np = pbuf_alloc(PBUF_RAW, n0->len + cs->cs_hlen, PBUF_POOL); -#endif /* IP_FORWARD */ - if(!np) { - PPPDEBUG(LOG_WARNING, ("vj_uncompress_tcp: realign failed\n")); - goto bad; - } - - if (pbuf_remove_header(np, cs->cs_hlen)) { - /* Can we cope with this failing? Just assert for now */ - LWIP_ASSERT("pbuf_remove_header failed\n", 0); - goto bad; - } - - pbuf_take(np, n0->payload, n0->len); - - if(n0->next) { - pbuf_chain(np, n0->next); - pbuf_dechain(n0); - } - pbuf_free(n0); - n0 = np; - } - - if (pbuf_add_header(n0, cs->cs_hlen)) { - struct pbuf *np; - - LWIP_ASSERT("vj_uncompress_tcp: cs->cs_hlen <= PBUF_POOL_BUFSIZE", cs->cs_hlen <= PBUF_POOL_BUFSIZE); - np = pbuf_alloc(PBUF_RAW, cs->cs_hlen, PBUF_POOL); - if(!np) { - PPPDEBUG(LOG_WARNING, ("vj_uncompress_tcp: prepend failed\n")); - goto bad; - } - pbuf_cat(np, n0); - n0 = np; - } - LWIP_ASSERT("n0->len >= cs->cs_hlen", n0->len >= cs->cs_hlen); - MEMCPY(n0->payload, &cs->cs_ip, cs->cs_hlen); - - *nb = n0; - - return vjlen; - -bad: - vj_uncompress_err(comp); - return (-1); -} - -#endif /* PPP_SUPPORT && VJ_SUPPORT */ +/* + * Routines to compress and uncompess tcp packets (for transmission + * over low speed serial lines. + * + * Copyright (c) 1989 Regents of the University of California. + * All rights reserved. + * + * Redistribution and use in source and binary forms are permitted + * provided that the above copyright notice and this paragraph are + * duplicated in all such forms and that any documentation, + * advertising materials, and other materials related to such + * distribution and use acknowledge that the software was developed + * by the University of California, Berkeley. The name of the + * University may not be used to endorse or promote products derived + * from this software without specific prior written permission. + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED + * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. + * + * Van Jacobson (van@helios.ee.lbl.gov), Dec 31, 1989: + * Initial distribution. + * + * Modified June 1993 by Paul Mackerras, paulus@cs.anu.edu.au, + * so that the entire packet being decompressed doesn't have + * to be in contiguous memory (just the compressed header). + * + * Modified March 1998 by Guy Lancaster, glanca@gesn.com, + * for a 16 bit processor. + */ + +#include "netif/ppp/ppp_opts.h" +#if PPP_SUPPORT && VJ_SUPPORT /* don't build if not configured for use in lwipopts.h */ + +#include "netif/ppp/ppp_impl.h" +#include "netif/ppp/pppdebug.h" + +#include "netif/ppp/vj.h" + +#include + +#if LINK_STATS +#define INCR(counter) ++comp->stats.counter +#else +#define INCR(counter) +#endif + +void +vj_compress_init(struct vjcompress *comp) +{ + u8_t i; + struct cstate *tstate = comp->tstate; + +#if MAX_SLOTS == 0 + memset((char *)comp, 0, sizeof(*comp)); +#endif + comp->maxSlotIndex = MAX_SLOTS - 1; + comp->compressSlot = 0; /* Disable slot ID compression by default. */ + for (i = MAX_SLOTS - 1; i > 0; --i) { + tstate[i].cs_id = i; + tstate[i].cs_next = &tstate[i - 1]; + } + tstate[0].cs_next = &tstate[MAX_SLOTS - 1]; + tstate[0].cs_id = 0; + comp->last_cs = &tstate[0]; + comp->last_recv = 255; + comp->last_xmit = 255; + comp->flags = VJF_TOSS; +} + + +/* ENCODE encodes a number that is known to be non-zero. ENCODEZ + * checks for zero (since zero has to be encoded in the long, 3 byte + * form). + */ +#define ENCODE(n) { \ + if ((u16_t)(n) >= 256) { \ + *cp++ = 0; \ + cp[1] = (u8_t)(n); \ + cp[0] = (u8_t)((n) >> 8); \ + cp += 2; \ + } else { \ + *cp++ = (u8_t)(n); \ + } \ +} +#define ENCODEZ(n) { \ + if ((u16_t)(n) >= 256 || (u16_t)(n) == 0) { \ + *cp++ = 0; \ + cp[1] = (u8_t)(n); \ + cp[0] = (u8_t)((n) >> 8); \ + cp += 2; \ + } else { \ + *cp++ = (u8_t)(n); \ + } \ +} + +#define DECODEL(f) { \ + if (*cp == 0) {\ + u32_t tmp_ = lwip_ntohl(f) + ((cp[1] << 8) | cp[2]); \ + (f) = lwip_htonl(tmp_); \ + cp += 3; \ + } else { \ + u32_t tmp_ = lwip_ntohl(f) + (u32_t)*cp++; \ + (f) = lwip_htonl(tmp_); \ + } \ +} + +#define DECODES(f) { \ + if (*cp == 0) {\ + u16_t tmp_ = lwip_ntohs(f) + (((u16_t)cp[1] << 8) | cp[2]); \ + (f) = lwip_htons(tmp_); \ + cp += 3; \ + } else { \ + u16_t tmp_ = lwip_ntohs(f) + (u16_t)*cp++; \ + (f) = lwip_htons(tmp_); \ + } \ +} + +#define DECODEU(f) { \ + if (*cp == 0) {\ + (f) = lwip_htons(((u16_t)cp[1] << 8) | cp[2]); \ + cp += 3; \ + } else { \ + (f) = lwip_htons((u16_t)*cp++); \ + } \ +} + +/* Helper structures for unaligned *u32_t and *u16_t accesses */ +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct vj_u32_t { + PACK_STRUCT_FIELD(u32_t v); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct vj_u16_t { + PACK_STRUCT_FIELD(u16_t v); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +/* + * vj_compress_tcp - Attempt to do Van Jacobson header compression on a + * packet. This assumes that nb and comp are not null and that the first + * buffer of the chain contains a valid IP header. + * Return the VJ type code indicating whether or not the packet was + * compressed. + */ +u8_t +vj_compress_tcp(struct vjcompress *comp, struct pbuf **pb) +{ + struct pbuf *np = *pb; + struct ip_hdr *ip = (struct ip_hdr *)np->payload; + struct cstate *cs = comp->last_cs->cs_next; + u16_t ilen = IPH_HL(ip); + u16_t hlen; + struct tcp_hdr *oth; + struct tcp_hdr *th; + u16_t deltaS, deltaA = 0; + u32_t deltaL; + u32_t changes = 0; + u8_t new_seq[16]; + u8_t *cp = new_seq; + + /* + * Check that the packet is IP proto TCP. + */ + if (IPH_PROTO(ip) != IP_PROTO_TCP) { + return (TYPE_IP); + } + + /* + * Bail if this is an IP fragment or if the TCP packet isn't + * `compressible' (i.e., ACK isn't set or some other control bit is + * set). + */ + if ((IPH_OFFSET(ip) & PP_HTONS(0x3fff)) || np->tot_len < 40) { + return (TYPE_IP); + } + th = (struct tcp_hdr *)&((struct vj_u32_t*)ip)[ilen]; + if ((TCPH_FLAGS(th) & (TCP_SYN|TCP_FIN|TCP_RST|TCP_ACK)) != TCP_ACK) { + return (TYPE_IP); + } + + /* Check that the TCP/IP headers are contained in the first buffer. */ + hlen = ilen + TCPH_HDRLEN(th); + hlen <<= 2; + if (np->len < hlen) { + PPPDEBUG(LOG_INFO, ("vj_compress_tcp: header len %d spans buffers\n", hlen)); + return (TYPE_IP); + } + + /* TCP stack requires that we don't change the packet payload, therefore we copy + * the whole packet before compression. */ + np = pbuf_clone(PBUF_RAW, PBUF_RAM, *pb); + if (!np) { + return (TYPE_IP); + } + + *pb = np; + ip = (struct ip_hdr *)np->payload; + + /* + * Packet is compressible -- we're going to send either a + * COMPRESSED_TCP or UNCOMPRESSED_TCP packet. Either way we need + * to locate (or create) the connection state. Special case the + * most recently used connection since it's most likely to be used + * again & we don't have to do any reordering if it's used. + */ + INCR(vjs_packets); + if (!ip4_addr_cmp(&ip->src, &cs->cs_ip.src) + || !ip4_addr_cmp(&ip->dest, &cs->cs_ip.dest) + || (*(struct vj_u32_t*)th).v != (((struct vj_u32_t*)&cs->cs_ip)[IPH_HL(&cs->cs_ip)]).v) { + /* + * Wasn't the first -- search for it. + * + * States are kept in a circularly linked list with + * last_cs pointing to the end of the list. The + * list is kept in lru order by moving a state to the + * head of the list whenever it is referenced. Since + * the list is short and, empirically, the connection + * we want is almost always near the front, we locate + * states via linear search. If we don't find a state + * for the datagram, the oldest state is (re-)used. + */ + struct cstate *lcs; + struct cstate *lastcs = comp->last_cs; + + do { + lcs = cs; cs = cs->cs_next; + INCR(vjs_searches); + if (ip4_addr_cmp(&ip->src, &cs->cs_ip.src) + && ip4_addr_cmp(&ip->dest, &cs->cs_ip.dest) + && (*(struct vj_u32_t*)th).v == (((struct vj_u32_t*)&cs->cs_ip)[IPH_HL(&cs->cs_ip)]).v) { + goto found; + } + } while (cs != lastcs); + + /* + * Didn't find it -- re-use oldest cstate. Send an + * uncompressed packet that tells the other side what + * connection number we're using for this conversation. + * Note that since the state list is circular, the oldest + * state points to the newest and we only need to set + * last_cs to update the lru linkage. + */ + INCR(vjs_misses); + comp->last_cs = lcs; + goto uncompressed; + + found: + /* + * Found it -- move to the front on the connection list. + */ + if (cs == lastcs) { + comp->last_cs = lcs; + } else { + lcs->cs_next = cs->cs_next; + cs->cs_next = lastcs->cs_next; + lastcs->cs_next = cs; + } + } + + oth = (struct tcp_hdr *)&((struct vj_u32_t*)&cs->cs_ip)[ilen]; + deltaS = ilen; + + /* + * Make sure that only what we expect to change changed. The first + * line of the `if' checks the IP protocol version, header length & + * type of service. The 2nd line checks the "Don't fragment" bit. + * The 3rd line checks the time-to-live and protocol (the protocol + * check is unnecessary but costless). The 4th line checks the TCP + * header length. The 5th line checks IP options, if any. The 6th + * line checks TCP options, if any. If any of these things are + * different between the previous & current datagram, we send the + * current datagram `uncompressed'. + */ + if ((((struct vj_u16_t*)ip)[0]).v != (((struct vj_u16_t*)&cs->cs_ip)[0]).v + || (((struct vj_u16_t*)ip)[3]).v != (((struct vj_u16_t*)&cs->cs_ip)[3]).v + || (((struct vj_u16_t*)ip)[4]).v != (((struct vj_u16_t*)&cs->cs_ip)[4]).v + || TCPH_HDRLEN(th) != TCPH_HDRLEN(oth) + || (deltaS > 5 && BCMP(ip + 1, &cs->cs_ip + 1, (deltaS - 5) << 2)) + || (TCPH_HDRLEN(th) > 5 && BCMP(th + 1, oth + 1, (TCPH_HDRLEN(th) - 5) << 2))) { + goto uncompressed; + } + + /* + * Figure out which of the changing fields changed. The + * receiver expects changes in the order: urgent, window, + * ack, seq (the order minimizes the number of temporaries + * needed in this section of code). + */ + if (TCPH_FLAGS(th) & TCP_URG) { + deltaS = lwip_ntohs(th->urgp); + ENCODEZ(deltaS); + changes |= NEW_U; + } else if (th->urgp != oth->urgp) { + /* argh! URG not set but urp changed -- a sensible + * implementation should never do this but RFC793 + * doesn't prohibit the change so we have to deal + * with it. */ + goto uncompressed; + } + + if ((deltaS = (u16_t)(lwip_ntohs(th->wnd) - lwip_ntohs(oth->wnd))) != 0) { + ENCODE(deltaS); + changes |= NEW_W; + } + + if ((deltaL = lwip_ntohl(th->ackno) - lwip_ntohl(oth->ackno)) != 0) { + if (deltaL > 0xffff) { + goto uncompressed; + } + deltaA = (u16_t)deltaL; + ENCODE(deltaA); + changes |= NEW_A; + } + + if ((deltaL = lwip_ntohl(th->seqno) - lwip_ntohl(oth->seqno)) != 0) { + if (deltaL > 0xffff) { + goto uncompressed; + } + deltaS = (u16_t)deltaL; + ENCODE(deltaS); + changes |= NEW_S; + } + + switch(changes) { + case 0: + /* + * Nothing changed. If this packet contains data and the + * last one didn't, this is probably a data packet following + * an ack (normal on an interactive connection) and we send + * it compressed. Otherwise it's probably a retransmit, + * retransmitted ack or window probe. Send it uncompressed + * in case the other side missed the compressed version. + */ + if (IPH_LEN(ip) != IPH_LEN(&cs->cs_ip) && + lwip_ntohs(IPH_LEN(&cs->cs_ip)) == hlen) { + break; + } + /* no break */ + /* fall through */ + + case SPECIAL_I: + case SPECIAL_D: + /* + * actual changes match one of our special case encodings -- + * send packet uncompressed. + */ + goto uncompressed; + + case NEW_S|NEW_A: + if (deltaS == deltaA && deltaS == lwip_ntohs(IPH_LEN(&cs->cs_ip)) - hlen) { + /* special case for echoed terminal traffic */ + changes = SPECIAL_I; + cp = new_seq; + } + break; + + case NEW_S: + if (deltaS == lwip_ntohs(IPH_LEN(&cs->cs_ip)) - hlen) { + /* special case for data xfer */ + changes = SPECIAL_D; + cp = new_seq; + } + break; + default: + break; + } + + deltaS = (u16_t)(lwip_ntohs(IPH_ID(ip)) - lwip_ntohs(IPH_ID(&cs->cs_ip))); + if (deltaS != 1) { + ENCODEZ(deltaS); + changes |= NEW_I; + } + if (TCPH_FLAGS(th) & TCP_PSH) { + changes |= TCP_PUSH_BIT; + } + /* + * Grab the cksum before we overwrite it below. Then update our + * state with this packet's header. + */ + deltaA = lwip_ntohs(th->chksum); + MEMCPY(&cs->cs_ip, ip, hlen); + + /* + * We want to use the original packet as our compressed packet. + * (cp - new_seq) is the number of bytes we need for compressed + * sequence numbers. In addition we need one byte for the change + * mask, one for the connection id and two for the tcp checksum. + * So, (cp - new_seq) + 4 bytes of header are needed. hlen is how + * many bytes of the original packet to toss so subtract the two to + * get the new packet size. + */ + deltaS = (u16_t)(cp - new_seq); + if (!comp->compressSlot || comp->last_xmit != cs->cs_id) { + comp->last_xmit = cs->cs_id; + hlen -= deltaS + 4; + if (pbuf_remove_header(np, hlen)){ + /* Can we cope with this failing? Just assert for now */ + LWIP_ASSERT("pbuf_remove_header failed\n", 0); + } + cp = (u8_t*)np->payload; + *cp++ = (u8_t)(changes | NEW_C); + *cp++ = cs->cs_id; + } else { + hlen -= deltaS + 3; + if (pbuf_remove_header(np, hlen)) { + /* Can we cope with this failing? Just assert for now */ + LWIP_ASSERT("pbuf_remove_header failed\n", 0); + } + cp = (u8_t*)np->payload; + *cp++ = (u8_t)changes; + } + *cp++ = (u8_t)(deltaA >> 8); + *cp++ = (u8_t)deltaA; + MEMCPY(cp, new_seq, deltaS); + INCR(vjs_compressed); + return (TYPE_COMPRESSED_TCP); + + /* + * Update connection state cs & send uncompressed packet (that is, + * a regular ip/tcp packet but with the 'conversation id' we hope + * to use on future compressed packets in the protocol field). + */ +uncompressed: + MEMCPY(&cs->cs_ip, ip, hlen); + IPH_PROTO_SET(ip, cs->cs_id); + comp->last_xmit = cs->cs_id; + return (TYPE_UNCOMPRESSED_TCP); +} + +/* + * Called when we may have missed a packet. + */ +void +vj_uncompress_err(struct vjcompress *comp) +{ + comp->flags |= VJF_TOSS; + INCR(vjs_errorin); +} + +/* + * "Uncompress" a packet of type TYPE_UNCOMPRESSED_TCP. + * Return 0 on success, -1 on failure. + */ +int +vj_uncompress_uncomp(struct pbuf *nb, struct vjcompress *comp) +{ + u32_t hlen; + struct cstate *cs; + struct ip_hdr *ip; + + ip = (struct ip_hdr *)nb->payload; + hlen = IPH_HL(ip) << 2; + if (IPH_PROTO(ip) >= MAX_SLOTS + || hlen + sizeof(struct tcp_hdr) > nb->len + || (hlen += TCPH_HDRLEN_BYTES((struct tcp_hdr *)&((char *)ip)[hlen])) + > nb->len + || hlen > MAX_HDR) { + PPPDEBUG(LOG_INFO, ("vj_uncompress_uncomp: bad cid=%d, hlen=%d buflen=%d\n", + IPH_PROTO(ip), hlen, nb->len)); + vj_uncompress_err(comp); + return -1; + } + cs = &comp->rstate[comp->last_recv = IPH_PROTO(ip)]; + comp->flags &=~ VJF_TOSS; + IPH_PROTO_SET(ip, IP_PROTO_TCP); + /* copy from/to bigger buffers checked above instead of cs->cs_ip and ip + just to help static code analysis to see this is correct ;-) */ + MEMCPY(&cs->cs_hdr, nb->payload, hlen); + cs->cs_hlen = (u16_t)hlen; + INCR(vjs_uncompressedin); + return 0; +} + +/* + * Uncompress a packet of type TYPE_COMPRESSED_TCP. + * The packet is composed of a buffer chain and the first buffer + * must contain an accurate chain length. + * The first buffer must include the entire compressed TCP/IP header. + * This procedure replaces the compressed header with the uncompressed + * header and returns the length of the VJ header. + */ +int +vj_uncompress_tcp(struct pbuf **nb, struct vjcompress *comp) +{ + u8_t *cp; + struct tcp_hdr *th; + struct cstate *cs; + struct vj_u16_t *bp; + struct pbuf *n0 = *nb; + u32_t tmp; + u32_t vjlen, hlen, changes; + + INCR(vjs_compressedin); + cp = (u8_t*)n0->payload; + changes = *cp++; + if (changes & NEW_C) { + /* + * Make sure the state index is in range, then grab the state. + * If we have a good state index, clear the 'discard' flag. + */ + if (*cp >= MAX_SLOTS) { + PPPDEBUG(LOG_INFO, ("vj_uncompress_tcp: bad cid=%d\n", *cp)); + goto bad; + } + + comp->flags &=~ VJF_TOSS; + comp->last_recv = *cp++; + } else { + /* + * this packet has an implicit state index. If we've + * had a line error since the last time we got an + * explicit state index, we have to toss the packet. + */ + if (comp->flags & VJF_TOSS) { + PPPDEBUG(LOG_INFO, ("vj_uncompress_tcp: tossing\n")); + INCR(vjs_tossed); + return (-1); + } + } + cs = &comp->rstate[comp->last_recv]; + hlen = IPH_HL(&cs->cs_ip) << 2; + th = (struct tcp_hdr *)&((u8_t*)&cs->cs_ip)[hlen]; + th->chksum = lwip_htons((*cp << 8) | cp[1]); + cp += 2; + if (changes & TCP_PUSH_BIT) { + TCPH_SET_FLAG(th, TCP_PSH); + } else { + TCPH_UNSET_FLAG(th, TCP_PSH); + } + + switch (changes & SPECIALS_MASK) { + case SPECIAL_I: + { + u32_t i = lwip_ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen; + /* some compilers can't nest inline assembler.. */ + tmp = lwip_ntohl(th->ackno) + i; + th->ackno = lwip_htonl(tmp); + tmp = lwip_ntohl(th->seqno) + i; + th->seqno = lwip_htonl(tmp); + } + break; + + case SPECIAL_D: + /* some compilers can't nest inline assembler.. */ + tmp = lwip_ntohl(th->seqno) + lwip_ntohs(IPH_LEN(&cs->cs_ip)) - cs->cs_hlen; + th->seqno = lwip_htonl(tmp); + break; + + default: + if (changes & NEW_U) { + TCPH_SET_FLAG(th, TCP_URG); + DECODEU(th->urgp); + } else { + TCPH_UNSET_FLAG(th, TCP_URG); + } + if (changes & NEW_W) { + DECODES(th->wnd); + } + if (changes & NEW_A) { + DECODEL(th->ackno); + } + if (changes & NEW_S) { + DECODEL(th->seqno); + } + break; + } + if (changes & NEW_I) { + DECODES(cs->cs_ip._id); + } else { + IPH_ID_SET(&cs->cs_ip, lwip_ntohs(IPH_ID(&cs->cs_ip)) + 1); + IPH_ID_SET(&cs->cs_ip, lwip_htons(IPH_ID(&cs->cs_ip))); + } + + /* + * At this point, cp points to the first byte of data in the + * packet. Fill in the IP total length and update the IP + * header checksum. + */ + vjlen = (u16_t)(cp - (u8_t*)n0->payload); + if (n0->len < vjlen) { + /* + * We must have dropped some characters (crc should detect + * this but the old slip framing won't) + */ + PPPDEBUG(LOG_INFO, ("vj_uncompress_tcp: head buffer %d too short %d\n", + n0->len, vjlen)); + goto bad; + } + +#if BYTE_ORDER == LITTLE_ENDIAN + tmp = n0->tot_len - vjlen + cs->cs_hlen; + IPH_LEN_SET(&cs->cs_ip, lwip_htons((u16_t)tmp)); +#else + IPH_LEN_SET(&cs->cs_ip, lwip_htons(n0->tot_len - vjlen + cs->cs_hlen)); +#endif + + /* recompute the ip header checksum */ + bp = (struct vj_u16_t*) &cs->cs_ip; + IPH_CHKSUM_SET(&cs->cs_ip, 0); + for (tmp = 0; hlen > 0; hlen -= 2) { + tmp += (*bp++).v; + } + tmp = (tmp & 0xffff) + (tmp >> 16); + tmp = (tmp & 0xffff) + (tmp >> 16); + IPH_CHKSUM_SET(&cs->cs_ip, (u16_t)(~tmp)); + + /* Remove the compressed header and prepend the uncompressed header. */ + if (pbuf_remove_header(n0, vjlen)) { + /* Can we cope with this failing? Just assert for now */ + LWIP_ASSERT("pbuf_remove_header failed\n", 0); + goto bad; + } + + if(LWIP_MEM_ALIGN(n0->payload) != n0->payload) { + struct pbuf *np; + +#if IP_FORWARD + /* If IP forwarding is enabled we are using a PBUF_LINK packet type so + * the packet is being allocated with enough header space to be + * forwarded (to Ethernet for example). + */ + np = pbuf_alloc(PBUF_LINK, n0->len + cs->cs_hlen, PBUF_POOL); +#else /* IP_FORWARD */ + np = pbuf_alloc(PBUF_RAW, n0->len + cs->cs_hlen, PBUF_POOL); +#endif /* IP_FORWARD */ + if(!np) { + PPPDEBUG(LOG_WARNING, ("vj_uncompress_tcp: realign failed\n")); + goto bad; + } + + if (pbuf_remove_header(np, cs->cs_hlen)) { + /* Can we cope with this failing? Just assert for now */ + LWIP_ASSERT("pbuf_remove_header failed\n", 0); + goto bad; + } + + pbuf_take(np, n0->payload, n0->len); + + if(n0->next) { + pbuf_chain(np, n0->next); + pbuf_dechain(n0); + } + pbuf_free(n0); + n0 = np; + } + + if (pbuf_add_header(n0, cs->cs_hlen)) { + struct pbuf *np; + + LWIP_ASSERT("vj_uncompress_tcp: cs->cs_hlen <= PBUF_POOL_BUFSIZE", cs->cs_hlen <= PBUF_POOL_BUFSIZE); + np = pbuf_alloc(PBUF_RAW, cs->cs_hlen, PBUF_POOL); + if(!np) { + PPPDEBUG(LOG_WARNING, ("vj_uncompress_tcp: prepend failed\n")); + goto bad; + } + pbuf_cat(np, n0); + n0 = np; + } + LWIP_ASSERT("n0->len >= cs->cs_hlen", n0->len >= cs->cs_hlen); + MEMCPY(n0->payload, &cs->cs_ip, cs->cs_hlen); + + *nb = n0; + + return vjlen; + +bad: + vj_uncompress_err(comp); + return (-1); +} + +#endif /* PPP_SUPPORT && VJ_SUPPORT */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/slipif.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/slipif.c index 037ed9cf..9b175dc3 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/slipif.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/slipif.c @@ -1,558 +1,558 @@ -/** - * @file - * SLIP Interface - * - */ - -/* - * Copyright (c) 2001-2004 Swedish Institute of Computer Science. - * 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 Institute 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 INSTITUTE 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 INSTITUTE 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. - * - * This file is built upon the file: src/arch/rtxc/netif/sioslip.c - * - * Author: Magnus Ivarsson - * Simon Goldschmidt - */ - - -/** - * @defgroup slipif SLIP - * @ingroup netifs - * - * This is an arch independent SLIP netif. The specific serial hooks must be - * provided by another file. They are sio_open, sio_read/sio_tryread and sio_send - * - * Usage: This netif can be used in three ways:\n - * 1) For NO_SYS==0, an RX thread can be used which blocks on sio_read() - * until data is received.\n - * 2) In your main loop, call slipif_poll() to check for new RX bytes, - * completed packets are fed into netif->input().\n - * 3) Call slipif_received_byte[s]() from your serial RX ISR and - * slipif_process_rxqueue() from your main loop. ISR level decodes - * packets and puts completed packets on a queue which is fed into - * the stack from the main loop (needs SYS_LIGHTWEIGHT_PROT for - * pbuf_alloc to work on ISR level!). - * - */ - -#include "netif/slipif.h" -#include "lwip/opt.h" - -#include "lwip/def.h" -#include "lwip/pbuf.h" -#include "lwip/stats.h" -#include "lwip/snmp.h" -#include "lwip/sys.h" -#include "lwip/sio.h" - -#define SLIP_END 0xC0 /* 0300: start and end of every packet */ -#define SLIP_ESC 0xDB /* 0333: escape start (one byte escaped data follows) */ -#define SLIP_ESC_END 0xDC /* 0334: following escape: original byte is 0xC0 (END) */ -#define SLIP_ESC_ESC 0xDD /* 0335: following escape: original byte is 0xDB (ESC) */ - -/** Maximum packet size that is received by this netif */ -#ifndef SLIP_MAX_SIZE -#define SLIP_MAX_SIZE 1500 -#endif - -/** Define this to the interface speed for SNMP - * (sio_fd is the sio_fd_t returned by sio_open). - * The default value of zero means 'unknown'. - */ -#ifndef SLIP_SIO_SPEED -#define SLIP_SIO_SPEED(sio_fd) 0 -#endif - -enum slipif_recv_state { - SLIP_RECV_NORMAL, - SLIP_RECV_ESCAPE -}; - -struct slipif_priv { - sio_fd_t sd; - /* q is the whole pbuf chain for a packet, p is the current pbuf in the chain */ - struct pbuf *p, *q; - u8_t state; - u16_t i, recved; -#if SLIP_RX_FROM_ISR - struct pbuf *rxpackets; -#endif -}; - -/** - * Send a pbuf doing the necessary SLIP encapsulation - * - * Uses the serial layer's sio_send() - * - * @param netif the lwip network interface structure for this slipif - * @param p the pbuf chain packet to send - * @return always returns ERR_OK since the serial layer does not provide return values - */ -static err_t -slipif_output(struct netif *netif, struct pbuf *p) -{ - struct slipif_priv *priv; - struct pbuf *q; - u16_t i; - u8_t c; - - LWIP_ASSERT("netif != NULL", (netif != NULL)); - LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); - LWIP_ASSERT("p != NULL", (p != NULL)); - - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: sending %"U16_F" bytes\n", p->tot_len)); - priv = (struct slipif_priv *)netif->state; - - /* Send pbuf out on the serial I/O device. */ - /* Start with packet delimiter. */ - sio_send(SLIP_END, priv->sd); - - for (q = p; q != NULL; q = q->next) { - for (i = 0; i < q->len; i++) { - c = ((u8_t *)q->payload)[i]; - switch (c) { - case SLIP_END: - /* need to escape this byte (0xC0 -> 0xDB, 0xDC) */ - sio_send(SLIP_ESC, priv->sd); - sio_send(SLIP_ESC_END, priv->sd); - break; - case SLIP_ESC: - /* need to escape this byte (0xDB -> 0xDB, 0xDD) */ - sio_send(SLIP_ESC, priv->sd); - sio_send(SLIP_ESC_ESC, priv->sd); - break; - default: - /* normal byte - no need for escaping */ - sio_send(c, priv->sd); - break; - } - } - } - /* End with packet delimiter. */ - sio_send(SLIP_END, priv->sd); - return ERR_OK; -} - -#if LWIP_IPV4 -/** - * Send a pbuf doing the necessary SLIP encapsulation - * - * Uses the serial layer's sio_send() - * - * @param netif the lwip network interface structure for this slipif - * @param p the pbuf chain packet to send - * @param ipaddr the ip address to send the packet to (not used for slipif) - * @return always returns ERR_OK since the serial layer does not provide return values - */ -static err_t -slipif_output_v4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr) -{ - LWIP_UNUSED_ARG(ipaddr); - return slipif_output(netif, p); -} -#endif /* LWIP_IPV4 */ - -#if LWIP_IPV6 -/** - * Send a pbuf doing the necessary SLIP encapsulation - * - * Uses the serial layer's sio_send() - * - * @param netif the lwip network interface structure for this slipif - * @param p the pbuf chain packet to send - * @param ipaddr the ip address to send the packet to (not used for slipif) - * @return always returns ERR_OK since the serial layer does not provide return values - */ -static err_t -slipif_output_v6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr) -{ - LWIP_UNUSED_ARG(ipaddr); - return slipif_output(netif, p); -} -#endif /* LWIP_IPV6 */ - -/** - * Handle the incoming SLIP stream character by character - * - * @param netif the lwip network interface structure for this slipif - * @param c received character (multiple calls to this function will - * return a complete packet, NULL is returned before - used for polling) - * @return The IP packet when SLIP_END is received - */ -static struct pbuf * -slipif_rxbyte(struct netif *netif, u8_t c) -{ - struct slipif_priv *priv; - struct pbuf *t; - - LWIP_ASSERT("netif != NULL", (netif != NULL)); - LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); - - priv = (struct slipif_priv *)netif->state; - - switch (priv->state) { - case SLIP_RECV_NORMAL: - switch (c) { - case SLIP_END: - if (priv->recved > 0) { - /* Received whole packet. */ - /* Trim the pbuf to the size of the received packet. */ - pbuf_realloc(priv->q, priv->recved); - - LINK_STATS_INC(link.recv); - - LWIP_DEBUGF(SLIP_DEBUG, ("slipif: Got packet (%"U16_F" bytes)\n", priv->recved)); - t = priv->q; - priv->p = priv->q = NULL; - priv->i = priv->recved = 0; - return t; - } - return NULL; - case SLIP_ESC: - priv->state = SLIP_RECV_ESCAPE; - return NULL; - default: - break; - } /* end switch (c) */ - break; - case SLIP_RECV_ESCAPE: - /* un-escape END or ESC bytes, leave other bytes - (although that would be a protocol error) */ - switch (c) { - case SLIP_ESC_END: - c = SLIP_END; - break; - case SLIP_ESC_ESC: - c = SLIP_ESC; - break; - default: - break; - } - priv->state = SLIP_RECV_NORMAL; - break; - default: - break; - } /* end switch (priv->state) */ - - /* byte received, packet not yet completely received */ - if (priv->p == NULL) { - /* allocate a new pbuf */ - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: alloc\n")); - priv->p = pbuf_alloc(PBUF_LINK, (PBUF_POOL_BUFSIZE - PBUF_LINK_HLEN - PBUF_LINK_ENCAPSULATION_HLEN), PBUF_POOL); - - if (priv->p == NULL) { - LINK_STATS_INC(link.drop); - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: no new pbuf! (DROP)\n")); - /* don't process any further since we got no pbuf to receive to */ - return NULL; - } - - if (priv->q != NULL) { - /* 'chain' the pbuf to the existing chain */ - pbuf_cat(priv->q, priv->p); - } else { - /* p is the first pbuf in the chain */ - priv->q = priv->p; - } - } - - /* this automatically drops bytes if > SLIP_MAX_SIZE */ - if ((priv->p != NULL) && (priv->recved <= SLIP_MAX_SIZE)) { - ((u8_t *)priv->p->payload)[priv->i] = c; - priv->recved++; - priv->i++; - if (priv->i >= priv->p->len) { - /* on to the next pbuf */ - priv->i = 0; - if (priv->p->next != NULL && priv->p->next->len > 0) { - /* p is a chain, on to the next in the chain */ - priv->p = priv->p->next; - } else { - /* p is a single pbuf, set it to NULL so next time a new - * pbuf is allocated */ - priv->p = NULL; - } - } - } - return NULL; -} - -/** Like slipif_rxbyte, but passes completed packets to netif->input - * - * @param netif The lwip network interface structure for this slipif - * @param c received character - */ -static void -slipif_rxbyte_input(struct netif *netif, u8_t c) -{ - struct pbuf *p; - p = slipif_rxbyte(netif, c); - if (p != NULL) { - if (netif->input(p, netif) != ERR_OK) { - pbuf_free(p); - } - } -} - -#if SLIP_USE_RX_THREAD -/** - * The SLIP input thread. - * - * Feed the IP layer with incoming packets - * - * @param nf the lwip network interface structure for this slipif - */ -static void -slipif_loop_thread(void *nf) -{ - u8_t c; - struct netif *netif = (struct netif *)nf; - struct slipif_priv *priv = (struct slipif_priv *)netif->state; - - while (1) { - if (sio_read(priv->sd, &c, 1) > 0) { - slipif_rxbyte_input(netif, c); - } - } -} -#endif /* SLIP_USE_RX_THREAD */ - -/** - * @ingroup slipif - * SLIP netif initialization - * - * Call the arch specific sio_open and remember - * the opened device in the state field of the netif. - * - * @param netif the lwip network interface structure for this slipif - * @return ERR_OK if serial line could be opened, - * ERR_MEM if no memory could be allocated, - * ERR_IF is serial line couldn't be opened - * - * @note If netif->state is interpreted as an u8_t serial port number. - * - */ -err_t -slipif_init(struct netif *netif) -{ - struct slipif_priv *priv; - u8_t sio_num; - - LWIP_ASSERT("slipif needs an input callback", netif->input != NULL); - - /* netif->state contains serial port number */ - sio_num = LWIP_PTR_NUMERIC_CAST(u8_t, netif->state); - - LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%"U16_F"\n", (u16_t)sio_num)); - - /* Allocate private data */ - priv = (struct slipif_priv *)mem_malloc(sizeof(struct slipif_priv)); - if (!priv) { - return ERR_MEM; - } - - netif->name[0] = 's'; - netif->name[1] = 'l'; -#if LWIP_IPV4 - netif->output = slipif_output_v4; -#endif /* LWIP_IPV4 */ -#if LWIP_IPV6 - netif->output_ip6 = slipif_output_v6; -#endif /* LWIP_IPV6 */ - netif->mtu = SLIP_MAX_SIZE; - - /* Try to open the serial port. */ - priv->sd = sio_open(sio_num); - if (!priv->sd) { - /* Opening the serial port failed. */ - mem_free(priv); - return ERR_IF; - } - - /* Initialize private data */ - priv->p = NULL; - priv->q = NULL; - priv->state = SLIP_RECV_NORMAL; - priv->i = 0; - priv->recved = 0; -#if SLIP_RX_FROM_ISR - priv->rxpackets = NULL; -#endif - - netif->state = priv; - - /* initialize the snmp variables and counters inside the struct netif */ - MIB2_INIT_NETIF(netif, snmp_ifType_slip, SLIP_SIO_SPEED(priv->sd)); - -#if SLIP_USE_RX_THREAD - /* Create a thread to poll the serial line. */ - sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop_thread, netif, - SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO); -#endif /* SLIP_USE_RX_THREAD */ - return ERR_OK; -} - -/** - * @ingroup slipif - * Polls the serial device and feeds the IP layer with incoming packets. - * - * @param netif The lwip network interface structure for this slipif - */ -void -slipif_poll(struct netif *netif) -{ - u8_t c; - struct slipif_priv *priv; - - LWIP_ASSERT("netif != NULL", (netif != NULL)); - LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); - - priv = (struct slipif_priv *)netif->state; - - while (sio_tryread(priv->sd, &c, 1) > 0) { - slipif_rxbyte_input(netif, c); - } -} - -#if SLIP_RX_FROM_ISR -/** - * @ingroup slipif - * Feeds the IP layer with incoming packets that were receive - * - * @param netif The lwip network interface structure for this slipif - */ -void -slipif_process_rxqueue(struct netif *netif) -{ - struct slipif_priv *priv; - SYS_ARCH_DECL_PROTECT(old_level); - - LWIP_ASSERT("netif != NULL", (netif != NULL)); - LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); - - priv = (struct slipif_priv *)netif->state; - - SYS_ARCH_PROTECT(old_level); - while (priv->rxpackets != NULL) { - struct pbuf *p = priv->rxpackets; -#if SLIP_RX_QUEUE - /* dequeue packet */ - struct pbuf *q = p; - while ((q->len != q->tot_len) && (q->next != NULL)) { - q = q->next; - } - priv->rxpackets = q->next; - q->next = NULL; -#else /* SLIP_RX_QUEUE */ - priv->rxpackets = NULL; -#endif /* SLIP_RX_QUEUE */ - SYS_ARCH_UNPROTECT(old_level); - if (netif->input(p, netif) != ERR_OK) { - pbuf_free(p); - } - SYS_ARCH_PROTECT(old_level); - } - SYS_ARCH_UNPROTECT(old_level); -} - -/** Like slipif_rxbyte, but queues completed packets. - * - * @param netif The lwip network interface structure for this slipif - * @param data Received serial byte - */ -static void -slipif_rxbyte_enqueue(struct netif *netif, u8_t data) -{ - struct pbuf *p; - struct slipif_priv *priv = (struct slipif_priv *)netif->state; - SYS_ARCH_DECL_PROTECT(old_level); - - p = slipif_rxbyte(netif, data); - if (p != NULL) { - SYS_ARCH_PROTECT(old_level); - if (priv->rxpackets != NULL) { -#if SLIP_RX_QUEUE - /* queue multiple pbufs */ - struct pbuf *q = p; - while (q->next != NULL) { - q = q->next; - } - q->next = p; - } else { -#else /* SLIP_RX_QUEUE */ - pbuf_free(priv->rxpackets); - } - { -#endif /* SLIP_RX_QUEUE */ - priv->rxpackets = p; - } - SYS_ARCH_UNPROTECT(old_level); - } -} - -/** - * @ingroup slipif - * Process a received byte, completed packets are put on a queue that is - * fed into IP through slipif_process_rxqueue(). - * - * This function can be called from ISR if SYS_LIGHTWEIGHT_PROT is enabled. - * - * @param netif The lwip network interface structure for this slipif - * @param data received character - */ -void -slipif_received_byte(struct netif *netif, u8_t data) -{ - LWIP_ASSERT("netif != NULL", (netif != NULL)); - LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); - slipif_rxbyte_enqueue(netif, data); -} - -/** - * @ingroup slipif - * Process multiple received byte, completed packets are put on a queue that is - * fed into IP through slipif_process_rxqueue(). - * - * This function can be called from ISR if SYS_LIGHTWEIGHT_PROT is enabled. - * - * @param netif The lwip network interface structure for this slipif - * @param data received character - * @param len Number of received characters - */ -void -slipif_received_bytes(struct netif *netif, u8_t *data, u8_t len) -{ - u8_t i; - u8_t *rxdata = data; - LWIP_ASSERT("netif != NULL", (netif != NULL)); - LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); - - for (i = 0; i < len; i++, rxdata++) { - slipif_rxbyte_enqueue(netif, *rxdata); - } -} -#endif /* SLIP_RX_FROM_ISR */ +/** + * @file + * SLIP Interface + * + */ + +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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 Institute 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 INSTITUTE 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 INSTITUTE 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. + * + * This file is built upon the file: src/arch/rtxc/netif/sioslip.c + * + * Author: Magnus Ivarsson + * Simon Goldschmidt + */ + + +/** + * @defgroup slipif SLIP + * @ingroup netifs + * + * This is an arch independent SLIP netif. The specific serial hooks must be + * provided by another file. They are sio_open, sio_read/sio_tryread and sio_send + * + * Usage: This netif can be used in three ways:\n + * 1) For NO_SYS==0, an RX thread can be used which blocks on sio_read() + * until data is received.\n + * 2) In your main loop, call slipif_poll() to check for new RX bytes, + * completed packets are fed into netif->input().\n + * 3) Call slipif_received_byte[s]() from your serial RX ISR and + * slipif_process_rxqueue() from your main loop. ISR level decodes + * packets and puts completed packets on a queue which is fed into + * the stack from the main loop (needs SYS_LIGHTWEIGHT_PROT for + * pbuf_alloc to work on ISR level!). + * + */ + +#include "netif/slipif.h" +#include "lwip/opt.h" + +#include "lwip/def.h" +#include "lwip/pbuf.h" +#include "lwip/stats.h" +#include "lwip/snmp.h" +#include "lwip/sys.h" +#include "lwip/sio.h" + +#define SLIP_END 0xC0 /* 0300: start and end of every packet */ +#define SLIP_ESC 0xDB /* 0333: escape start (one byte escaped data follows) */ +#define SLIP_ESC_END 0xDC /* 0334: following escape: original byte is 0xC0 (END) */ +#define SLIP_ESC_ESC 0xDD /* 0335: following escape: original byte is 0xDB (ESC) */ + +/** Maximum packet size that is received by this netif */ +#ifndef SLIP_MAX_SIZE +#define SLIP_MAX_SIZE 1500 +#endif + +/** Define this to the interface speed for SNMP + * (sio_fd is the sio_fd_t returned by sio_open). + * The default value of zero means 'unknown'. + */ +#ifndef SLIP_SIO_SPEED +#define SLIP_SIO_SPEED(sio_fd) 0 +#endif + +enum slipif_recv_state { + SLIP_RECV_NORMAL, + SLIP_RECV_ESCAPE +}; + +struct slipif_priv { + sio_fd_t sd; + /* q is the whole pbuf chain for a packet, p is the current pbuf in the chain */ + struct pbuf *p, *q; + u8_t state; + u16_t i, recved; +#if SLIP_RX_FROM_ISR + struct pbuf *rxpackets; +#endif +}; + +/** + * Send a pbuf doing the necessary SLIP encapsulation + * + * Uses the serial layer's sio_send() + * + * @param netif the lwip network interface structure for this slipif + * @param p the pbuf chain packet to send + * @return always returns ERR_OK since the serial layer does not provide return values + */ +static err_t +slipif_output(struct netif *netif, struct pbuf *p) +{ + struct slipif_priv *priv; + struct pbuf *q; + u16_t i; + u8_t c; + + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); + LWIP_ASSERT("p != NULL", (p != NULL)); + + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_output: sending %"U16_F" bytes\n", p->tot_len)); + priv = (struct slipif_priv *)netif->state; + + /* Send pbuf out on the serial I/O device. */ + /* Start with packet delimiter. */ + sio_send(SLIP_END, priv->sd); + + for (q = p; q != NULL; q = q->next) { + for (i = 0; i < q->len; i++) { + c = ((u8_t *)q->payload)[i]; + switch (c) { + case SLIP_END: + /* need to escape this byte (0xC0 -> 0xDB, 0xDC) */ + sio_send(SLIP_ESC, priv->sd); + sio_send(SLIP_ESC_END, priv->sd); + break; + case SLIP_ESC: + /* need to escape this byte (0xDB -> 0xDB, 0xDD) */ + sio_send(SLIP_ESC, priv->sd); + sio_send(SLIP_ESC_ESC, priv->sd); + break; + default: + /* normal byte - no need for escaping */ + sio_send(c, priv->sd); + break; + } + } + } + /* End with packet delimiter. */ + sio_send(SLIP_END, priv->sd); + return ERR_OK; +} + +#if LWIP_IPV4 +/** + * Send a pbuf doing the necessary SLIP encapsulation + * + * Uses the serial layer's sio_send() + * + * @param netif the lwip network interface structure for this slipif + * @param p the pbuf chain packet to send + * @param ipaddr the ip address to send the packet to (not used for slipif) + * @return always returns ERR_OK since the serial layer does not provide return values + */ +static err_t +slipif_output_v4(struct netif *netif, struct pbuf *p, const ip4_addr_t *ipaddr) +{ + LWIP_UNUSED_ARG(ipaddr); + return slipif_output(netif, p); +} +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 +/** + * Send a pbuf doing the necessary SLIP encapsulation + * + * Uses the serial layer's sio_send() + * + * @param netif the lwip network interface structure for this slipif + * @param p the pbuf chain packet to send + * @param ipaddr the ip address to send the packet to (not used for slipif) + * @return always returns ERR_OK since the serial layer does not provide return values + */ +static err_t +slipif_output_v6(struct netif *netif, struct pbuf *p, const ip6_addr_t *ipaddr) +{ + LWIP_UNUSED_ARG(ipaddr); + return slipif_output(netif, p); +} +#endif /* LWIP_IPV6 */ + +/** + * Handle the incoming SLIP stream character by character + * + * @param netif the lwip network interface structure for this slipif + * @param c received character (multiple calls to this function will + * return a complete packet, NULL is returned before - used for polling) + * @return The IP packet when SLIP_END is received + */ +static struct pbuf * +slipif_rxbyte(struct netif *netif, u8_t c) +{ + struct slipif_priv *priv; + struct pbuf *t; + + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); + + priv = (struct slipif_priv *)netif->state; + + switch (priv->state) { + case SLIP_RECV_NORMAL: + switch (c) { + case SLIP_END: + if (priv->recved > 0) { + /* Received whole packet. */ + /* Trim the pbuf to the size of the received packet. */ + pbuf_realloc(priv->q, priv->recved); + + LINK_STATS_INC(link.recv); + + LWIP_DEBUGF(SLIP_DEBUG, ("slipif: Got packet (%"U16_F" bytes)\n", priv->recved)); + t = priv->q; + priv->p = priv->q = NULL; + priv->i = priv->recved = 0; + return t; + } + return NULL; + case SLIP_ESC: + priv->state = SLIP_RECV_ESCAPE; + return NULL; + default: + break; + } /* end switch (c) */ + break; + case SLIP_RECV_ESCAPE: + /* un-escape END or ESC bytes, leave other bytes + (although that would be a protocol error) */ + switch (c) { + case SLIP_ESC_END: + c = SLIP_END; + break; + case SLIP_ESC_ESC: + c = SLIP_ESC; + break; + default: + break; + } + priv->state = SLIP_RECV_NORMAL; + break; + default: + break; + } /* end switch (priv->state) */ + + /* byte received, packet not yet completely received */ + if (priv->p == NULL) { + /* allocate a new pbuf */ + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: alloc\n")); + priv->p = pbuf_alloc(PBUF_LINK, (PBUF_POOL_BUFSIZE - PBUF_LINK_HLEN - PBUF_LINK_ENCAPSULATION_HLEN), PBUF_POOL); + + if (priv->p == NULL) { + LINK_STATS_INC(link.drop); + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_input: no new pbuf! (DROP)\n")); + /* don't process any further since we got no pbuf to receive to */ + return NULL; + } + + if (priv->q != NULL) { + /* 'chain' the pbuf to the existing chain */ + pbuf_cat(priv->q, priv->p); + } else { + /* p is the first pbuf in the chain */ + priv->q = priv->p; + } + } + + /* this automatically drops bytes if > SLIP_MAX_SIZE */ + if ((priv->p != NULL) && (priv->recved <= SLIP_MAX_SIZE)) { + ((u8_t *)priv->p->payload)[priv->i] = c; + priv->recved++; + priv->i++; + if (priv->i >= priv->p->len) { + /* on to the next pbuf */ + priv->i = 0; + if (priv->p->next != NULL && priv->p->next->len > 0) { + /* p is a chain, on to the next in the chain */ + priv->p = priv->p->next; + } else { + /* p is a single pbuf, set it to NULL so next time a new + * pbuf is allocated */ + priv->p = NULL; + } + } + } + return NULL; +} + +/** Like slipif_rxbyte, but passes completed packets to netif->input + * + * @param netif The lwip network interface structure for this slipif + * @param c received character + */ +static void +slipif_rxbyte_input(struct netif *netif, u8_t c) +{ + struct pbuf *p; + p = slipif_rxbyte(netif, c); + if (p != NULL) { + if (netif->input(p, netif) != ERR_OK) { + pbuf_free(p); + } + } +} + +#if SLIP_USE_RX_THREAD +/** + * The SLIP input thread. + * + * Feed the IP layer with incoming packets + * + * @param nf the lwip network interface structure for this slipif + */ +static void +slipif_loop_thread(void *nf) +{ + u8_t c; + struct netif *netif = (struct netif *)nf; + struct slipif_priv *priv = (struct slipif_priv *)netif->state; + + while (1) { + if (sio_read(priv->sd, &c, 1) > 0) { + slipif_rxbyte_input(netif, c); + } + } +} +#endif /* SLIP_USE_RX_THREAD */ + +/** + * @ingroup slipif + * SLIP netif initialization + * + * Call the arch specific sio_open and remember + * the opened device in the state field of the netif. + * + * @param netif the lwip network interface structure for this slipif + * @return ERR_OK if serial line could be opened, + * ERR_MEM if no memory could be allocated, + * ERR_IF is serial line couldn't be opened + * + * @note If netif->state is interpreted as an u8_t serial port number. + * + */ +err_t +slipif_init(struct netif *netif) +{ + struct slipif_priv *priv; + u8_t sio_num; + + LWIP_ASSERT("slipif needs an input callback", netif->input != NULL); + + /* netif->state contains serial port number */ + sio_num = LWIP_PTR_NUMERIC_CAST(u8_t, netif->state); + + LWIP_DEBUGF(SLIP_DEBUG, ("slipif_init: netif->num=%"U16_F"\n", (u16_t)sio_num)); + + /* Allocate private data */ + priv = (struct slipif_priv *)mem_malloc(sizeof(struct slipif_priv)); + if (!priv) { + return ERR_MEM; + } + + netif->name[0] = 's'; + netif->name[1] = 'l'; +#if LWIP_IPV4 + netif->output = slipif_output_v4; +#endif /* LWIP_IPV4 */ +#if LWIP_IPV6 + netif->output_ip6 = slipif_output_v6; +#endif /* LWIP_IPV6 */ + netif->mtu = SLIP_MAX_SIZE; + + /* Try to open the serial port. */ + priv->sd = sio_open(sio_num); + if (!priv->sd) { + /* Opening the serial port failed. */ + mem_free(priv); + return ERR_IF; + } + + /* Initialize private data */ + priv->p = NULL; + priv->q = NULL; + priv->state = SLIP_RECV_NORMAL; + priv->i = 0; + priv->recved = 0; +#if SLIP_RX_FROM_ISR + priv->rxpackets = NULL; +#endif + + netif->state = priv; + + /* initialize the snmp variables and counters inside the struct netif */ + MIB2_INIT_NETIF(netif, snmp_ifType_slip, SLIP_SIO_SPEED(priv->sd)); + +#if SLIP_USE_RX_THREAD + /* Create a thread to poll the serial line. */ + sys_thread_new(SLIPIF_THREAD_NAME, slipif_loop_thread, netif, + SLIPIF_THREAD_STACKSIZE, SLIPIF_THREAD_PRIO); +#endif /* SLIP_USE_RX_THREAD */ + return ERR_OK; +} + +/** + * @ingroup slipif + * Polls the serial device and feeds the IP layer with incoming packets. + * + * @param netif The lwip network interface structure for this slipif + */ +void +slipif_poll(struct netif *netif) +{ + u8_t c; + struct slipif_priv *priv; + + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); + + priv = (struct slipif_priv *)netif->state; + + while (sio_tryread(priv->sd, &c, 1) > 0) { + slipif_rxbyte_input(netif, c); + } +} + +#if SLIP_RX_FROM_ISR +/** + * @ingroup slipif + * Feeds the IP layer with incoming packets that were receive + * + * @param netif The lwip network interface structure for this slipif + */ +void +slipif_process_rxqueue(struct netif *netif) +{ + struct slipif_priv *priv; + SYS_ARCH_DECL_PROTECT(old_level); + + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); + + priv = (struct slipif_priv *)netif->state; + + SYS_ARCH_PROTECT(old_level); + while (priv->rxpackets != NULL) { + struct pbuf *p = priv->rxpackets; +#if SLIP_RX_QUEUE + /* dequeue packet */ + struct pbuf *q = p; + while ((q->len != q->tot_len) && (q->next != NULL)) { + q = q->next; + } + priv->rxpackets = q->next; + q->next = NULL; +#else /* SLIP_RX_QUEUE */ + priv->rxpackets = NULL; +#endif /* SLIP_RX_QUEUE */ + SYS_ARCH_UNPROTECT(old_level); + if (netif->input(p, netif) != ERR_OK) { + pbuf_free(p); + } + SYS_ARCH_PROTECT(old_level); + } + SYS_ARCH_UNPROTECT(old_level); +} + +/** Like slipif_rxbyte, but queues completed packets. + * + * @param netif The lwip network interface structure for this slipif + * @param data Received serial byte + */ +static void +slipif_rxbyte_enqueue(struct netif *netif, u8_t data) +{ + struct pbuf *p; + struct slipif_priv *priv = (struct slipif_priv *)netif->state; + SYS_ARCH_DECL_PROTECT(old_level); + + p = slipif_rxbyte(netif, data); + if (p != NULL) { + SYS_ARCH_PROTECT(old_level); + if (priv->rxpackets != NULL) { +#if SLIP_RX_QUEUE + /* queue multiple pbufs */ + struct pbuf *q = p; + while (q->next != NULL) { + q = q->next; + } + q->next = p; + } else { +#else /* SLIP_RX_QUEUE */ + pbuf_free(priv->rxpackets); + } + { +#endif /* SLIP_RX_QUEUE */ + priv->rxpackets = p; + } + SYS_ARCH_UNPROTECT(old_level); + } +} + +/** + * @ingroup slipif + * Process a received byte, completed packets are put on a queue that is + * fed into IP through slipif_process_rxqueue(). + * + * This function can be called from ISR if SYS_LIGHTWEIGHT_PROT is enabled. + * + * @param netif The lwip network interface structure for this slipif + * @param data received character + */ +void +slipif_received_byte(struct netif *netif, u8_t data) +{ + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); + slipif_rxbyte_enqueue(netif, data); +} + +/** + * @ingroup slipif + * Process multiple received byte, completed packets are put on a queue that is + * fed into IP through slipif_process_rxqueue(). + * + * This function can be called from ISR if SYS_LIGHTWEIGHT_PROT is enabled. + * + * @param netif The lwip network interface structure for this slipif + * @param data received character + * @param len Number of received characters + */ +void +slipif_received_bytes(struct netif *netif, u8_t *data, u8_t len) +{ + u8_t i; + u8_t *rxdata = data; + LWIP_ASSERT("netif != NULL", (netif != NULL)); + LWIP_ASSERT("netif->state != NULL", (netif->state != NULL)); + + for (i = 0; i < len; i++, rxdata++) { + slipif_rxbyte_enqueue(netif, *rxdata); + } +} +#endif /* SLIP_RX_FROM_ISR */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/zepif.c b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/zepif.c index b7c9b9c5..b4033030 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/zepif.c +++ b/Ubiquitous/XiUOS/resources/ethernet/LwIP/netif/zepif.c @@ -1,300 +1,300 @@ -/** - * @file - * - * @defgroup zepif ZEP - ZigBee Encapsulation Protocol - * @ingroup netifs - * A netif implementing the ZigBee Encapsulation Protocol (ZEP). - * This is used to tunnel 6LowPAN over UDP. - * - * Usage (there must be a default netif before!): - * @code{.c} - * netif_add(&zep_netif, NULL, NULL, NULL, NULL, zepif_init, tcpip_6lowpan_input); - * netif_create_ip6_linklocal_address(&zep_netif, 1); - * netif_set_up(&zep_netif); - * netif_set_link_up(&zep_netif); - * @endcode - */ - -/* - * Copyright (c) 2018 Simon Goldschmidt - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Simon Goldschmidt - * - */ - -#include "netif/zepif.h" - -#if LWIP_IPV6 && LWIP_UDP - -#include "netif/lowpan6.h" -#include "lwip/udp.h" -#include "lwip/timeouts.h" -#include - -/** Define this to 1 to loop back TX packets for testing */ -#ifndef ZEPIF_LOOPBACK -#define ZEPIF_LOOPBACK 0 -#endif - -#define ZEP_MAX_DATA_LEN 127 - -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/bpstruct.h" -#endif -PACK_STRUCT_BEGIN -struct zep_hdr { - PACK_STRUCT_FLD_8(u8_t prot_id[2]); - PACK_STRUCT_FLD_8(u8_t prot_version); - PACK_STRUCT_FLD_8(u8_t type); - PACK_STRUCT_FLD_8(u8_t channel_id); - PACK_STRUCT_FIELD(u16_t device_id); - PACK_STRUCT_FLD_8(u8_t crc_mode); - PACK_STRUCT_FLD_8(u8_t unknown_1); - PACK_STRUCT_FIELD(u32_t timestamp[2]); - PACK_STRUCT_FIELD(u32_t seq_num); - PACK_STRUCT_FLD_8(u8_t unknown_2[10]); - PACK_STRUCT_FLD_8(u8_t len); -} PACK_STRUCT_STRUCT; -PACK_STRUCT_END -#ifdef PACK_STRUCT_USE_INCLUDES -# include "arch/epstruct.h" -#endif - -struct zepif_state { - struct zepif_init init; - struct udp_pcb *pcb; - u32_t seqno; -}; - -static u8_t zep_lowpan_timer_running; - -/* Helper function that calls the 6LoWPAN timer and reschedules itself */ -static void -zep_lowpan_timer(void *arg) -{ - lowpan6_tmr(); - if (zep_lowpan_timer_running) { - sys_timeout(LOWPAN6_TMR_INTERVAL, zep_lowpan_timer, arg); - } -} - -/* Pass received pbufs into 6LowPAN netif */ -static void -zepif_udp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, - const ip_addr_t *addr, u16_t port) -{ - err_t err; - struct netif *netif_lowpan6 = (struct netif *)arg; - struct zep_hdr *zep; - - LWIP_ASSERT("arg != NULL", arg != NULL); - LWIP_ASSERT("pcb != NULL", pcb != NULL); - LWIP_UNUSED_ARG(pcb); /* for LWIP_NOASSERT */ - LWIP_UNUSED_ARG(addr); - LWIP_UNUSED_ARG(port); - if (p == NULL) { - return; - } - - /* Parse and hide the ZEP header */ - if (p->len < sizeof(struct zep_hdr)) { - /* need the zep_hdr in one piece */ - goto err_return; - } - zep = (struct zep_hdr *)p->payload; - if (zep->prot_id[0] != 'E') { - goto err_return; - } - if (zep->prot_id[1] != 'X') { - goto err_return; - } - if (zep->prot_version != 2) { - /* we only support this version for now */ - goto err_return; - } - if (zep->type != 1) { - goto err_return; - } - if (zep->crc_mode != 1) { - goto err_return; - } - if (zep->len != p->tot_len - sizeof(struct zep_hdr)) { - goto err_return; - } - /* everything seems to be OK, hide the ZEP header */ - if (pbuf_remove_header(p, sizeof(struct zep_hdr))) { - goto err_return; - } - /* TODO Check CRC? */ - /* remove CRC trailer */ - pbuf_realloc(p, p->tot_len - 2); - - /* Call into 6LoWPAN code. */ - err = netif_lowpan6->input(p, netif_lowpan6); - if (err == ERR_OK) { - return; - } -err_return: - pbuf_free(p); -} - -/* Send 6LoWPAN TX packets as UDP broadcast */ -static err_t -zepif_linkoutput(struct netif *netif, struct pbuf *p) -{ - err_t err; - struct pbuf *q; - struct zep_hdr *zep; - struct zepif_state *state; - - LWIP_ASSERT("invalid netif", netif != NULL); - LWIP_ASSERT("invalid pbuf", p != NULL); - - if (p->tot_len > ZEP_MAX_DATA_LEN) { - return ERR_VAL; - } - LWIP_ASSERT("TODO: support chained pbufs", p->next == NULL); - - state = (struct zepif_state *)netif->state; - LWIP_ASSERT("state->pcb != NULL", state->pcb != NULL); - - q = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct zep_hdr) + p->tot_len, PBUF_RAM); - if (q == NULL) { - return ERR_MEM; - } - zep = (struct zep_hdr *)q->payload; - memset(zep, 0, sizeof(struct zep_hdr)); - zep->prot_id[0] = 'E'; - zep->prot_id[1] = 'X'; - zep->prot_version = 2; - zep->type = 1; /* Data */ - zep->channel_id = 0; /* whatever */ - zep->device_id = lwip_htons(1); /* whatever */ - zep->crc_mode = 1; - zep->unknown_1 = 0xff; - zep->seq_num = lwip_htonl(state->seqno); - state->seqno++; - zep->len = (u8_t)p->tot_len; - - err = pbuf_take_at(q, p->payload, p->tot_len, sizeof(struct zep_hdr)); - if (err == ERR_OK) { -#if ZEPIF_LOOPBACK - zepif_udp_recv(netif, state->pcb, pbuf_clone(PBUF_RAW, PBUF_RAM, q), NULL, 0); -#endif - err = udp_sendto(state->pcb, q, state->init.zep_dst_ip_addr, state->init.zep_dst_udp_port); - } - pbuf_free(q); - - return err; -} - -/** - * @ingroup zepif - * Set up a raw 6LowPAN netif and surround it with input- and output - * functions for ZEP - */ -err_t -zepif_init(struct netif *netif) -{ - err_t err; - struct zepif_init *init_state = (struct zepif_init *)netif->state; - struct zepif_state *state = (struct zepif_state *)mem_malloc(sizeof(struct zepif_state)); - - LWIP_ASSERT("zepif needs an input callback", netif->input != NULL); - - if (state == NULL) { - return ERR_MEM; - } - memset(state, 0, sizeof(struct zepif_state)); - if (init_state != NULL) { - memcpy(&state->init, init_state, sizeof(struct zepif_init)); - } - if (state->init.zep_src_udp_port == 0) { - state->init.zep_src_udp_port = ZEPIF_DEFAULT_UDP_PORT; - } - if (state->init.zep_dst_udp_port == 0) { - state->init.zep_dst_udp_port = ZEPIF_DEFAULT_UDP_PORT; - } -#if LWIP_IPV4 - if (state->init.zep_dst_ip_addr == NULL) { - /* With IPv4 enabled, default to broadcasting packets if no address is set */ - state->init.zep_dst_ip_addr = IP_ADDR_BROADCAST; - } -#endif /* LWIP_IPV4 */ - - netif->state = NULL; - - state->pcb = udp_new_ip_type(IPADDR_TYPE_ANY); - if (state->pcb == NULL) { - err = ERR_MEM; - goto err_ret; - } - err = udp_bind(state->pcb, state->init.zep_src_ip_addr, state->init.zep_src_udp_port); - if (err != ERR_OK) { - goto err_ret; - } - if (state->init.zep_netif != NULL) { - udp_bind_netif(state->pcb, state->init.zep_netif); - } - LWIP_ASSERT("udp_bind(lowpan6_broadcast_pcb) failed", err == ERR_OK); - ip_set_option(state->pcb, SOF_BROADCAST); - udp_recv(state->pcb, zepif_udp_recv, netif); - - err = lowpan6_if_init(netif); - LWIP_ASSERT("lowpan6_if_init set a state", netif->state == NULL); - if (err == ERR_OK) { - netif->state = state; - netif->hwaddr_len = 6; - if (init_state != NULL) { - memcpy(netif->hwaddr, init_state->addr, 6); - } else { - u8_t i; - for (i = 0; i < 6; i++) { - netif->hwaddr[i] = i; - } - netif->hwaddr[0] &= 0xfc; - } - netif->linkoutput = zepif_linkoutput; - - if (!zep_lowpan_timer_running) { - sys_timeout(LOWPAN6_TMR_INTERVAL, zep_lowpan_timer, NULL); - zep_lowpan_timer_running = 1; - } - - return ERR_OK; - } - -err_ret: - if (state->pcb != NULL) { - udp_remove(state->pcb); - } - mem_free(state); - return err; -} - -#endif /* LWIP_IPV6 && LWIP_UDP */ +/** + * @file + * + * @defgroup zepif ZEP - ZigBee Encapsulation Protocol + * @ingroup netifs + * A netif implementing the ZigBee Encapsulation Protocol (ZEP). + * This is used to tunnel 6LowPAN over UDP. + * + * Usage (there must be a default netif before!): + * @code{.c} + * netif_add(&zep_netif, NULL, NULL, NULL, NULL, zepif_init, tcpip_6lowpan_input); + * netif_create_ip6_linklocal_address(&zep_netif, 1); + * netif_set_up(&zep_netif); + * netif_set_link_up(&zep_netif); + * @endcode + */ + +/* + * Copyright (c) 2018 Simon Goldschmidt + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + * Author: Simon Goldschmidt + * + */ + +#include "netif/zepif.h" + +#if LWIP_IPV6 && LWIP_UDP + +#include "netif/lowpan6.h" +#include "lwip/udp.h" +#include "lwip/timeouts.h" +#include + +/** Define this to 1 to loop back TX packets for testing */ +#ifndef ZEPIF_LOOPBACK +#define ZEPIF_LOOPBACK 0 +#endif + +#define ZEP_MAX_DATA_LEN 127 + +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/bpstruct.h" +#endif +PACK_STRUCT_BEGIN +struct zep_hdr { + PACK_STRUCT_FLD_8(u8_t prot_id[2]); + PACK_STRUCT_FLD_8(u8_t prot_version); + PACK_STRUCT_FLD_8(u8_t type); + PACK_STRUCT_FLD_8(u8_t channel_id); + PACK_STRUCT_FIELD(u16_t device_id); + PACK_STRUCT_FLD_8(u8_t crc_mode); + PACK_STRUCT_FLD_8(u8_t unknown_1); + PACK_STRUCT_FIELD(u32_t timestamp[2]); + PACK_STRUCT_FIELD(u32_t seq_num); + PACK_STRUCT_FLD_8(u8_t unknown_2[10]); + PACK_STRUCT_FLD_8(u8_t len); +} PACK_STRUCT_STRUCT; +PACK_STRUCT_END +#ifdef PACK_STRUCT_USE_INCLUDES +# include "arch/epstruct.h" +#endif + +struct zepif_state { + struct zepif_init init; + struct udp_pcb *pcb; + u32_t seqno; +}; + +static u8_t zep_lowpan_timer_running; + +/* Helper function that calls the 6LoWPAN timer and reschedules itself */ +static void +zep_lowpan_timer(void *arg) +{ + lowpan6_tmr(); + if (zep_lowpan_timer_running) { + sys_timeout(LOWPAN6_TMR_INTERVAL, zep_lowpan_timer, arg); + } +} + +/* Pass received pbufs into 6LowPAN netif */ +static void +zepif_udp_recv(void *arg, struct udp_pcb *pcb, struct pbuf *p, + const ip_addr_t *addr, u16_t port) +{ + err_t err; + struct netif *netif_lowpan6 = (struct netif *)arg; + struct zep_hdr *zep; + + LWIP_ASSERT("arg != NULL", arg != NULL); + LWIP_ASSERT("pcb != NULL", pcb != NULL); + LWIP_UNUSED_ARG(pcb); /* for LWIP_NOASSERT */ + LWIP_UNUSED_ARG(addr); + LWIP_UNUSED_ARG(port); + if (p == NULL) { + return; + } + + /* Parse and hide the ZEP header */ + if (p->len < sizeof(struct zep_hdr)) { + /* need the zep_hdr in one piece */ + goto err_return; + } + zep = (struct zep_hdr *)p->payload; + if (zep->prot_id[0] != 'E') { + goto err_return; + } + if (zep->prot_id[1] != 'X') { + goto err_return; + } + if (zep->prot_version != 2) { + /* we only support this version for now */ + goto err_return; + } + if (zep->type != 1) { + goto err_return; + } + if (zep->crc_mode != 1) { + goto err_return; + } + if (zep->len != p->tot_len - sizeof(struct zep_hdr)) { + goto err_return; + } + /* everything seems to be OK, hide the ZEP header */ + if (pbuf_remove_header(p, sizeof(struct zep_hdr))) { + goto err_return; + } + /* TODO Check CRC? */ + /* remove CRC trailer */ + pbuf_realloc(p, p->tot_len - 2); + + /* Call into 6LoWPAN code. */ + err = netif_lowpan6->input(p, netif_lowpan6); + if (err == ERR_OK) { + return; + } +err_return: + pbuf_free(p); +} + +/* Send 6LoWPAN TX packets as UDP broadcast */ +static err_t +zepif_linkoutput(struct netif *netif, struct pbuf *p) +{ + err_t err; + struct pbuf *q; + struct zep_hdr *zep; + struct zepif_state *state; + + LWIP_ASSERT("invalid netif", netif != NULL); + LWIP_ASSERT("invalid pbuf", p != NULL); + + if (p->tot_len > ZEP_MAX_DATA_LEN) { + return ERR_VAL; + } + LWIP_ASSERT("TODO: support chained pbufs", p->next == NULL); + + state = (struct zepif_state *)netif->state; + LWIP_ASSERT("state->pcb != NULL", state->pcb != NULL); + + q = pbuf_alloc(PBUF_TRANSPORT, sizeof(struct zep_hdr) + p->tot_len, PBUF_RAM); + if (q == NULL) { + return ERR_MEM; + } + zep = (struct zep_hdr *)q->payload; + memset(zep, 0, sizeof(struct zep_hdr)); + zep->prot_id[0] = 'E'; + zep->prot_id[1] = 'X'; + zep->prot_version = 2; + zep->type = 1; /* Data */ + zep->channel_id = 0; /* whatever */ + zep->device_id = lwip_htons(1); /* whatever */ + zep->crc_mode = 1; + zep->unknown_1 = 0xff; + zep->seq_num = lwip_htonl(state->seqno); + state->seqno++; + zep->len = (u8_t)p->tot_len; + + err = pbuf_take_at(q, p->payload, p->tot_len, sizeof(struct zep_hdr)); + if (err == ERR_OK) { +#if ZEPIF_LOOPBACK + zepif_udp_recv(netif, state->pcb, pbuf_clone(PBUF_RAW, PBUF_RAM, q), NULL, 0); +#endif + err = udp_sendto(state->pcb, q, state->init.zep_dst_ip_addr, state->init.zep_dst_udp_port); + } + pbuf_free(q); + + return err; +} + +/** + * @ingroup zepif + * Set up a raw 6LowPAN netif and surround it with input- and output + * functions for ZEP + */ +err_t +zepif_init(struct netif *netif) +{ + err_t err; + struct zepif_init *init_state = (struct zepif_init *)netif->state; + struct zepif_state *state = (struct zepif_state *)mem_malloc(sizeof(struct zepif_state)); + + LWIP_ASSERT("zepif needs an input callback", netif->input != NULL); + + if (state == NULL) { + return ERR_MEM; + } + memset(state, 0, sizeof(struct zepif_state)); + if (init_state != NULL) { + memcpy(&state->init, init_state, sizeof(struct zepif_init)); + } + if (state->init.zep_src_udp_port == 0) { + state->init.zep_src_udp_port = ZEPIF_DEFAULT_UDP_PORT; + } + if (state->init.zep_dst_udp_port == 0) { + state->init.zep_dst_udp_port = ZEPIF_DEFAULT_UDP_PORT; + } +#if LWIP_IPV4 + if (state->init.zep_dst_ip_addr == NULL) { + /* With IPv4 enabled, default to broadcasting packets if no address is set */ + state->init.zep_dst_ip_addr = IP_ADDR_BROADCAST; + } +#endif /* LWIP_IPV4 */ + + netif->state = NULL; + + state->pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + if (state->pcb == NULL) { + err = ERR_MEM; + goto err_ret; + } + err = udp_bind(state->pcb, state->init.zep_src_ip_addr, state->init.zep_src_udp_port); + if (err != ERR_OK) { + goto err_ret; + } + if (state->init.zep_netif != NULL) { + udp_bind_netif(state->pcb, state->init.zep_netif); + } + LWIP_ASSERT("udp_bind(lowpan6_broadcast_pcb) failed", err == ERR_OK); + ip_set_option(state->pcb, SOF_BROADCAST); + udp_recv(state->pcb, zepif_udp_recv, netif); + + err = lowpan6_if_init(netif); + LWIP_ASSERT("lowpan6_if_init set a state", netif->state == NULL); + if (err == ERR_OK) { + netif->state = state; + netif->hwaddr_len = 6; + if (init_state != NULL) { + memcpy(netif->hwaddr, init_state->addr, 6); + } else { + u8_t i; + for (i = 0; i < 6; i++) { + netif->hwaddr[i] = i; + } + netif->hwaddr[0] &= 0xfc; + } + netif->linkoutput = zepif_linkoutput; + + if (!zep_lowpan_timer_running) { + sys_timeout(LOWPAN6_TMR_INTERVAL, zep_lowpan_timer, NULL); + zep_lowpan_timer_running = 1; + } + + return ERR_OK; + } + +err_ret: + if (state->pcb != NULL) { + udp_remove(state->pcb); + } + mem_free(state); + return err; +} + +#endif /* LWIP_IPV6 && LWIP_UDP */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/Makefile b/Ubiquitous/XiUOS/resources/ethernet/Makefile index a511fa3f..7173fa1c 100644 --- a/Ubiquitous/XiUOS/resources/ethernet/Makefile +++ b/Ubiquitous/XiUOS/resources/ethernet/Makefile @@ -1,3 +1,3 @@ -SRC_DIR += LwIP +SRC_DIR += LwIP cmd_lwip include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/Makefile b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/Makefile new file mode 100755 index 00000000..20a73337 --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/Makefile @@ -0,0 +1,3 @@ +SRC_FILES := ping.c lwip_ping_demo.c lwip_udp_demo.c lwip_tcp_demo.c tcpecho_raw.c lwip_config_demo.c lwip_dhcp_demo.c + +include $(KERNEL_ROOT)/compiler.mk diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_config_demo.c b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_config_demo.c new file mode 100755 index 00000000..4268d230 --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_config_demo.c @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file lwip_config_demo.c + * @brief Demo for ping function + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.12.15 + */ + + +/******************************************************************************* + * Includes + ******************************************************************************/ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_RAW + +#include "ping.h" + +#include "lwip/timeouts.h" +#include "lwip/init.h" +#include "netif/ethernet.h" + +#include "board.h" +#include "pin_mux.h" +#include "clock_config.h" + +#include +#include +#include "connect_ethernet.h" +#include "lwip_demo.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +/******************************************************************************* + * Code + ******************************************************************************/ + +static void *lwip_config_test(void *param) +{ + ETH_BSP_Config(); + lwip_config_net(lwip_ipaddr, lwip_netmask, lwip_gwaddr); +} + +void lwip_setip_thread(int argc, char *argv[]) +{ + int result = 0; + pthread_t th_id; + pthread_attr_t attr; + + attr.schedparam.sched_priority = 15; + attr.stacksize = 4096; + + if(argc >= 4) + { + lw_print("lw: [%s] ip %s mask %s gw %s\n", __func__, argv[1], argv[2], argv[3]); + sscanf(argv[1], "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]); + sscanf(argv[2], "%d.%d.%d.%d", &lwip_netmask[0], &lwip_netmask[1], &lwip_netmask[2], &lwip_netmask[3]); + sscanf(argv[3], "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1], &lwip_gwaddr[2], &lwip_gwaddr[3]); + } + else if(argc == 2) + { + lw_print("lw: [%s] ipaddr %s\n", __func__, argv[1]); + sscanf(argv[1], "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]); + } + + result = pthread_create(&th_id, &attr, lwip_config_test, NULL); + if (0 == result) { + lw_print("lwip_config_test %d successfully!\n", th_id); + } else { + lw_print("lwip_config_test failed! error code is %d\n", result); + } +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + setip, lwip_setip_thread, SetIp [IP] [Netmask] [Gateway]); + + +void lwip_getip_thread(int argc, char *argv[]) +{ + lw_pr_info("\r\n************************************************\r\n"); + lw_pr_info(" Network Configuration\r\n"); + lw_pr_info("************************************************\r\n"); + lw_pr_info(" IPv4 Address : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_ipaddr)[0], ((u8_t *)&lwip_ipaddr)[1], + ((u8_t *)&lwip_ipaddr)[2], ((u8_t *)&lwip_ipaddr)[3]); + lw_pr_info(" IPv4 Subnet mask : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_netmask)[0], ((u8_t *)&lwip_netmask)[1], + ((u8_t *)&lwip_netmask)[2], ((u8_t *)&lwip_netmask)[3]); + lw_pr_info(" IPv4 Gateway : %u.%u.%u.%u\r\n", ((u8_t *)&lwip_gwaddr)[0], ((u8_t *)&lwip_gwaddr)[1], + ((u8_t *)&lwip_gwaddr)[2], ((u8_t *)&lwip_gwaddr)[3]); + lw_pr_info("************************************************\r\n"); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), + showip, lwip_getip_thread, GetIp [IP] [Netmask] [Gateway]); + +#endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_demo.h b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_demo.h new file mode 100755 index 00000000..c2cf2ebb --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_demo.h @@ -0,0 +1,6 @@ +#ifndef __LWIP_DEMO_H__ +#define __LWIP_DEMO_H__ + +void *eth_input_thread(void *param); + +#endif /* __LWIP_DEMO_H__ */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_dhcp_demo.c b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_dhcp_demo.c new file mode 100755 index 00000000..b4e47d00 --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_dhcp_demo.c @@ -0,0 +1,177 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/******************************************************************************* + * Includes + ******************************************************************************/ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_DHCP + +#include "lwip/timeouts.h" +#include "lwip/ip_addr.h" +#include "lwip/init.h" +#include "lwip/dhcp.h" +#include "lwip/prot/dhcp.h" +#include "netif/ethernet.h" +#include "enet_ethernetif.h" + +#include "board.h" + +#include "pin_mux.h" +#include "clock_config.h" +#include "fsl_gpio.h" +#include "fsl_iomuxc.h" +#include "sys_arch.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +#define LWIP_DHCP_TIME 10000 // 10s + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +/******************************************************************************* + * Code + ******************************************************************************/ + +/*! + * @brief Prints DHCP status of the interface when it has changed from last status. + * + * @param netif network interface structure + */ +int print_dhcp_state(struct netif *netif) +{ + static u8_t dhcp_last_state = DHCP_STATE_OFF; + struct dhcp *dhcp = netif_dhcp_data(netif); + + if (dhcp == NULL) + { + dhcp_last_state = DHCP_STATE_OFF; + } + else if (dhcp_last_state != dhcp->state) + { + dhcp_last_state = dhcp->state; + + lw_pr_info(" DHCP state : "); + switch (dhcp_last_state) + { + case DHCP_STATE_OFF: + lw_pr_info("OFF"); + break; + case DHCP_STATE_REQUESTING: + lw_pr_info("REQUESTING"); + break; + case DHCP_STATE_INIT: + lw_pr_info("INIT"); + break; + case DHCP_STATE_REBOOTING: + lw_pr_info("REBOOTING"); + break; + case DHCP_STATE_REBINDING: + lw_pr_info("REBINDING"); + break; + case DHCP_STATE_RENEWING: + lw_pr_info("RENEWING"); + break; + case DHCP_STATE_SELECTING: + lw_pr_info("SELECTING"); + break; + case DHCP_STATE_INFORMING: + lw_pr_info("INFORMING"); + break; + case DHCP_STATE_CHECKING: + lw_pr_info("CHECKING"); + break; + case DHCP_STATE_BOUND: + lw_pr_info("BOUND"); + break; + case DHCP_STATE_BACKING_OFF: + lw_pr_info("BACKING_OFF"); + break; + default: + lw_pr_info("%u", dhcp_last_state); + assert(0); + break; + } + lw_pr_info("\r\n"); + + if (dhcp_last_state == DHCP_STATE_BOUND) + { + lw_pr_info("\r\n IPv4 Address : %s\r\n", ipaddr_ntoa(&netif->ip_addr)); + lw_pr_info(" IPv4 Subnet mask : %s\r\n", ipaddr_ntoa(&netif->netmask)); + lw_pr_info(" IPv4 Gateway : %s\r\n\r\n", ipaddr_ntoa(&netif->gw)); + return 1; + } + } + return 0; +} + +/*! + * @brief Main function. + */ +void lwip_dhcp_test(void) +{ + u32_t dhcp_time; + static int flag = 0; + char ip_addr[4] = {0, 0, 0, 0}; + + ETH_BSP_Config(); + + lwip_config_net(ip_addr, ip_addr, ip_addr); + is_lwip_test = 1; + + dhcp_start(&gnetif); + + lw_print("\r\n************************************************\r\n"); + lw_print(" DHCP example\r\n"); + lw_print("************************************************\r\n"); + + dhcp_time = sys_now(); + + while ((sys_now() - dhcp_time) < LWIP_DHCP_TIME) + { + /* Poll the driver, get any outstanding frames */ + ethernetif_input(&gnetif); + + /* Handle all system timeouts for all core protocols */ + sys_check_timeouts(); + + /* Print DHCP progress */ + if(print_dhcp_state(&gnetif)) + { + sscanf(ipaddr_ntoa(&gnetif.ip_addr), "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], + &lwip_ipaddr[2], &lwip_ipaddr[3]); + + sscanf(ipaddr_ntoa(&gnetif.netmask), "%d.%d.%d.%d", &lwip_netmask[0], &lwip_netmask[1], + &lwip_netmask[2], &lwip_netmask[3]); + + sscanf(ipaddr_ntoa(&gnetif.gw), "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1], + &lwip_gwaddr[2], &lwip_gwaddr[3]); + + break; + } + } + + is_lwip_test = 0; +} + + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), + getdynip, lwip_dhcp_test, DHCP_Test); + +#endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_ping_demo.c b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_ping_demo.c new file mode 100755 index 00000000..65a159cd --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_ping_demo.c @@ -0,0 +1,122 @@ +/* + * Copyright (c) 2016, Freescale Semiconductor, Inc. + * Copyright 2016-2019 NXP + * All rights reserved. + * + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* + * Copyright (c) 2021 AIIT XUOS Lab + * XiUOS is licensed under Mulan PSL v2. + * You can use this software according to the terms and conditions of the Mulan PSL v2. + * You may obtain a copy of Mulan PSL v2 at: + * http://license.coscl.org.cn/MulanPSL2 + * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, + * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, + * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. + * See the Mulan PSL v2 for more details. + */ + +/** + * @file lwip_ping_demo.c + * @brief Demo for ping function + * @version 1.0 + * @author AIIT XUOS Lab + * @date 2021.12.15 + */ + + +/******************************************************************************* + * Includes + ******************************************************************************/ + +#include "lwip/opt.h" + +#if LWIP_IPV4 && LWIP_RAW + +#include "ping.h" + +#include "lwip/timeouts.h" +#include "lwip/init.h" +#include "netif/ethernet.h" + +#include "board.h" +#include "pin_mux.h" +#include "clock_config.h" + +#include +#include +#include "connect_ethernet.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +char test_ip_addr[] = {192, 168, 250, 253}; +char test_net_mask[] = {255, 255, 255, 0}; +char test_gw_addr[] = {192, 168, 250, 252}; +ip4_addr_t ping_addr; + +/******************************************************************************* + * Code + ******************************************************************************/ + +static void *lwip_ping_test(void *param) +{ + IP4_ADDR(&ping_addr, lwip_gwaddr[0], lwip_gwaddr[1], lwip_gwaddr[2], lwip_gwaddr[3]); + ETH_BSP_Config(); + lwip_config_net(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + ping_init(&ping_addr); +} + +void lwip_ping_thread(int argc, char *argv[]) +{ + int result = 0; + + if(argc >= 4) + { + lw_print("lw: [%s] ip %s mask %s gw %s\n", __func__, argv[1], argv[2], argv[3]); + sscanf(argv[1], "%d.%d.%d.%d", &lwip_ipaddr[0], &lwip_ipaddr[1], &lwip_ipaddr[2], &lwip_ipaddr[3]); + sscanf(argv[2], "%d.%d.%d.%d", &lwip_netmask[0], &lwip_netmask[1], &lwip_netmask[2], &lwip_netmask[3]); + sscanf(argv[3], "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1], &lwip_gwaddr[2], &lwip_gwaddr[3]); + } + else if(argc == 2) + { + lw_print("lw: [%s] gw %s\n", __func__, argv[1]); + if(isdigit(argv[1][0])) + { + if(sscanf(argv[1], "%d.%d.%d.%d", &lwip_gwaddr[0], &lwip_gwaddr[1], &lwip_gwaddr[2], &lwip_gwaddr[3]) == EOF) + { + lw_pr_info("input wrong ip\n"); + return; + } + } + else + { + get_url_ip(argv[1]); + return; + } + } + + lw_print("lw: [%s] argc %d\n", __func__, argc); + + IP4_ADDR(&ping_addr, lwip_gwaddr[0], lwip_gwaddr[1], lwip_gwaddr[2], lwip_gwaddr[3]); + ETH_BSP_Config(); + lwip_config_net(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + ping_init(&ping_addr); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + ping, lwip_ping_thread, ping [IP] 3 times); + +#endif diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_tcp_demo.c b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_tcp_demo.c new file mode 100755 index 00000000..647199d9 --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_tcp_demo.c @@ -0,0 +1,122 @@ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file tcp_echo_socket_demo.c +* @brief One UDP demo based on LwIP +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-29 +*/ +#include +#include +#include "board.h" +#include "sys_arch.h" +#include +#include "lwip/sys.h" +#include "tcpecho_raw.h" + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +char tcp_target[] = {192, 168, 250, 252}; +#define MSG_SIZE 128 +// this is for test in shell, in fact, shell restrict the length of input string, which is less then 128 +char tcp_send_msg[MSG_SIZE] = {0}; + +/******************************************************************************* + * Code + ******************************************************************************/ + +static void lwip_tcp_send_thread(void *arg) +{ + lw_print("lwip_tcp_send_thread start.\n"); + + int fd = -1; + fd = socket(AF_INET, SOCK_STREAM, 0); + if (fd < 0) + { + lw_print("Socket error\n"); + return; + } + + struct sockaddr_in tcp_sock; + tcp_sock.sin_family = AF_INET; + tcp_sock.sin_port = htons(TARGET_PORT_CLIENT); + tcp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(tcp_target[0], tcp_target[1], tcp_target[2], tcp_target[3])); + memset(&(tcp_sock.sin_zero), 0, sizeof(tcp_sock.sin_zero)); + + if (connect(fd, (struct sockaddr *)&tcp_sock, sizeof(struct sockaddr))) + { + lw_print("Unable to connect\n"); + goto __exit; + } + + lw_print("tcp connect success, start to send.\n"); + lw_print("\n\nTarget Port:%d\n\n", tcp_sock.sin_port); + + sendto(fd, tcp_send_msg, strlen(tcp_send_msg), 0, (struct sockaddr*)&tcp_sock, sizeof(struct sockaddr)); + + lw_print("Send tcp msg: %s ", tcp_send_msg); + +__exit: + if (fd >= 0) + closesocket(fd); + + return; +} + +void lwip_tcp_send_run(int argc, char *argv[]) +{ + memset(tcp_send_msg, 0, MSG_SIZE); + if(argc >= 2) + { + strncpy(tcp_send_msg, argv[1], strlen(argv[1])); + } + else + { + strncpy(tcp_send_msg, "hello world", strlen("hello world")); + } + strcat(tcp_send_msg, "\r\n"); + + if(argc >= 3) + { + sscanf(argv[2], "%d.%d.%d.%d", &tcp_target[0], &tcp_target[1], &tcp_target[2], &tcp_target[3]); + } + + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + sys_thread_new("tcp send", lwip_tcp_send_thread, NULL, 4096, 25); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + TCPSend, lwip_tcp_send_run, TCP Send message); + +void lwip_tcp_recv_run(void) +{ + ETH_BSP_Config(); + lwip_config_net(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + tcpecho_raw_init(); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), + TCPRecv, lwip_tcp_recv_run, TCP Recv message); + diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_udp_demo.c b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_udp_demo.c new file mode 100755 index 00000000..37c16b0e --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/lwip_udp_demo.c @@ -0,0 +1,190 @@ +/* +* Copyright (c) 2020 AIIT XUOS Lab +* XiUOS is licensed under Mulan PSL v2. +* You can use this software according to the terms and conditions of the Mulan PSL v2. +* You may obtain a copy of Mulan PSL v2 at: +* http://license.coscl.org.cn/MulanPSL2 +* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, +* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, +* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. +* See the Mulan PSL v2 for more details. +*/ + +/** +* @file tcp_echo_socket_demo.c +* @brief One UDP demo based on LwIP +* @version 1.0 +* @author AIIT XUOS Lab +* @date 2021-05-29 +*/ +#include +#include +#include "board.h" +#include "sys_arch.h" +#include "lwip/udp.h" +#include +#include "lwip/sys.h" + + +/******************************************************************************* + * Definitions + ******************************************************************************/ + +#define UDP_TASK_STACK_SIZE 4096 +#define UDP_TASK_PRIO 15 +#define PBUF_SIZE 27 + +/******************************************************************************* + * Prototypes + ******************************************************************************/ + +/******************************************************************************* + * Variables + ******************************************************************************/ + +static struct udp_pcb *udpecho_raw_pcb; +char udp_target[] = {192, 168, 250, 252}; +char hello_str[] = {"hello world\r\n"}; +char udp_send_msg[] = "\n\nThis one is UDP pkg. Congratulations on you.\n\n"; + +/******************************************************************************* + * Code + ******************************************************************************/ + +static void lwip_udp_send(void *arg) +{ + int cnt = TEST_LWIP_TIMES; + + lw_print("udp_send_demo start.\n"); + + int socket_fd = -1; + socket_fd = socket(AF_INET, SOCK_DGRAM, 0); + if (socket_fd < 0) + { + lw_print("Socket error\n"); + return; + } + + struct sockaddr_in udp_sock; + udp_sock.sin_family = AF_INET; + udp_sock.sin_port = htons(TARGET_PORT_CLIENT); + udp_sock.sin_addr.s_addr = PP_HTONL(LWIP_MAKEU32(udp_target[0],udp_target[1],udp_target[2],udp_target[3])); + memset(&(udp_sock.sin_zero), 0, sizeof(udp_sock.sin_zero)); + + if (connect(socket_fd, (struct sockaddr *)&udp_sock, sizeof(struct sockaddr))) + { + lw_print("Unable to connect\n"); + goto __exit; + } + + lw_print("UDP connect success, start to send.\n"); + lw_print("\n\nTarget Port:%d\n\n", udp_sock.sin_port); + + sendto(socket_fd, udp_send_msg, strlen(udp_send_msg), 0, (struct sockaddr*)&udp_sock, sizeof(struct sockaddr)); + lw_pr_info("Send UDP msg: %s ", udp_send_msg); + +__exit: + if (socket_fd >= 0) + { + closesocket(socket_fd); + } + + return; +} + +void *lwip_udp_send_run(int argc, char *argv[]) +{ + int result = 0; + pthread_t th_id; + pthread_attr_t attr; + + memset(udp_send_msg, 0, sizeof(udp_send_msg)); + + if(argc == 1) + { + lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_target[0], udp_target[1], udp_target[2], udp_target[3]); + strncpy(udp_send_msg, hello_str, strlen(hello_str)); + } + else + { + strncpy(udp_send_msg, argv[1], strlen(argv[1])); + strncat(udp_send_msg, "\r\n", 2); + if(argc == 3) + { + sscanf(argv[2], "%d.%d.%d.%d", &udp_target[0], &udp_target[1], &udp_target[2], &udp_target[3]); + } + } + lw_print("lw: [%s] gw %d.%d.%d.%d\n", __func__, udp_target[0], udp_target[1], udp_target[2], udp_target[3]); + + ETH_BSP_Config(); + lwip_config_tcp(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + sys_thread_new("udp socket send", lwip_udp_send, NULL, 4096, 25); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(3), + UDPSend, lwip_udp_send_run, UDP send echo); + +static void udpecho_raw_recv(void *arg, struct udp_pcb *upcb, struct pbuf *p, + const ip_addr_t *addr, u16_t port) +{ + int udp_len; + err_t err; + struct pbuf* udp_buf; + + LWIP_UNUSED_ARG(arg); + + if (p == NULL) + { + return; + } + udp_len = p->tot_len; + lw_pr_info("Receive data :%dB\r\n", udp_len); + + if(udp_len <= 80) + { + lw_pr_info("%.*s\r\n", udp_len, (char *)(p->payload)); + } + + udp_buf = pbuf_alloc(PBUF_TRANSPORT, PBUF_SIZE, PBUF_RAM); + + memset(udp_buf->payload, 0, PBUF_SIZE); + + err = pbuf_take(udp_buf, "Client receive success!\r\n", 27); + + /* send received packet back to sender */ + udp_sendto(upcb, udp_buf, addr, port); + + /* free the pbuf */ + pbuf_free(p); + pbuf_free(udp_buf); +} + +void udpecho_raw_init(void) +{ + err_t err; + lw_print("udpecho_raw_init\r\n"); + + udpecho_raw_pcb = udp_new_ip_type(IPADDR_TYPE_ANY); + if (udpecho_raw_pcb == NULL) + { + return; + } + + err = udp_bind(udpecho_raw_pcb, IP_ANY_TYPE, LOCAL_PORT_SERVER); + if (err == ERR_OK) + { + udp_recv(udpecho_raw_pcb, udpecho_raw_recv, NULL); + } +} + +void lwip_udp_server(void) +{ + lw_print("lwip_udp_server\r\n"); + ETH_BSP_Config(); + lwip_config_net(lwip_ipaddr, lwip_netmask, lwip_gwaddr); + udpecho_raw_init(); +} + +SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN) | SHELL_CMD_PARAM_NUM(0), + UDPRecv, lwip_udp_server, UDP server echo); + diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/ping.c b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/ping.c new file mode 100755 index 00000000..925f174b --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/ping.c @@ -0,0 +1,544 @@ +/** + * @file + * Ping sender module + * + */ + +/* + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ + +/** + * This is an example of a "ping" sender (with raw API and socket API). + * It can be used as a start point to maintain opened a network connection, or + * like a network "watchdog" for your device. + * + */ + +#include +#include "lwip/opt.h" + +#if LWIP_RAW /* don't build if not configured for use in lwipopts.h */ + +#include "ping.h" + +#include "lwip/mem.h" +#include "lwip/raw.h" +#include "lwip/icmp.h" +#include "lwip/netif.h" +#include "lwip/sys.h" +#include "lwip/timeouts.h" +#include "lwip/inet_chksum.h" +#include "lwip/prot/ip4.h" +#include "lwip/netdb.h" +#include "lwip/prot/ip.h" + +#if PING_USE_SOCKETS +#include "lwip/sockets.h" +#include "lwip/inet.h" +#include +#endif /* PING_USE_SOCKETS */ + + +/** + * PING_DEBUG: Enable debugging for PING. + */ +#ifndef PING_DEBUG +#define PING_DEBUG LWIP_DBG_ON +#endif + +/** ping receive timeout - in milliseconds */ +#ifndef PING_RCV_TIMEO +#define PING_RCV_TIMEO 2000 +#endif + +/** ping delay - in milliseconds */ +#ifndef PING_DELAY +#define PING_DELAY 1000 +#endif + +/** ping identifier - must fit on a u16_t */ +#ifndef PING_ID +#define PING_ID 0xAFAF +#endif + +/** ping additional data size to include in the packet */ +#ifndef PING_DATA_SIZE +#define PING_DATA_SIZE 32 +#endif + +/** ping result action - no default action */ +#ifndef PING_RESULT +#define PING_RESULT(ping_ok) +#endif + +/* ping variables */ +static const ip_addr_t* ping_target; +static u16_t ping_seq_num; +#ifdef LWIP_DEBUG +static u32_t ping_time; +#endif /* LWIP_DEBUG */ +#if !PING_USE_SOCKETS +static struct raw_pcb *ping_pcb; +#endif /* PING_USE_SOCKETS */ + +#define PING_THREAD_STACKSIZE 4096 +#define PING_THREAD_PRIO 15 + + +/** Prepare a echo ICMP request */ +static void +ping_prepare_echo( struct icmp_echo_hdr *iecho, u16_t len) +{ + size_t i; + size_t data_len = len - sizeof(struct icmp_echo_hdr); + + ICMPH_TYPE_SET(iecho, ICMP_ECHO); + ICMPH_CODE_SET(iecho, 0); + iecho->chksum = 0; + iecho->id = PING_ID; + iecho->seqno = lwip_htons(++ping_seq_num); + + /* fill the additional data buffer with some data */ + for(i = 0; i < data_len; i++) { + ((char*)iecho)[sizeof(struct icmp_echo_hdr) + i] = (char)i; + } + + iecho->chksum = inet_chksum(iecho, len); +} + +#if PING_USE_SOCKETS + +/* Ping using the socket ip */ +static err_t +ping_send(int s, const ip_addr_t *addr) +{ + int err; + struct icmp_echo_hdr *iecho; + struct sockaddr_storage to; + size_t ping_size = sizeof(struct icmp_echo_hdr) + PING_DATA_SIZE; + LWIP_ASSERT("ping_size is too big", ping_size <= 0xffff); + +#if LWIP_IPV6 + if(IP_IS_V6(addr) && !ip6_addr_isipv4mappedipv6(ip_2_ip6(addr))) { + /* todo: support ICMP6 echo */ + return ERR_VAL; + } +#endif /* LWIP_IPV6 */ + + iecho = (struct icmp_echo_hdr *)mem_malloc((mem_size_t)ping_size); + if (!iecho) { + return ERR_MEM; + } + + ping_prepare_echo(iecho, (u16_t)ping_size); + +#if LWIP_IPV4 + if(IP_IS_V4(addr)) { + struct sockaddr_in *to4 = (struct sockaddr_in*)&to; + to4->sin_len = sizeof(to4); + to4->sin_family = AF_INET; + inet_addr_from_ip4addr(&to4->sin_addr, ip_2_ip4(addr)); + } +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 + if(IP_IS_V6(addr)) { + struct sockaddr_in6 *to6 = (struct sockaddr_in6*)&to; + to6->sin6_len = sizeof(to6); + to6->sin6_family = AF_INET6; + inet6_addr_from_ip6addr(&to6->sin6_addr, ip_2_ip6(addr)); + } +#endif /* LWIP_IPV6 */ + + err = lwip_sendto(s, iecho, ping_size, 0, (struct sockaddr*)&to, sizeof(to)); + + mem_free(iecho); + + return (err ? ERR_OK : ERR_VAL); +} + +static void +ping_recv(int s) +{ + char buf[64]; + int len; + struct sockaddr_storage from; + int fromlen = sizeof(from); + + while((len = lwip_recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr*)&from, (socklen_t*)&fromlen)) > 0) { + if (len >= (int)(sizeof(struct ip_hdr)+sizeof(struct icmp_echo_hdr))) { + ip_addr_t fromaddr; + memset(&fromaddr, 0, sizeof(fromaddr)); + +#if LWIP_IPV4 + if(from.ss_family == AF_INET) { + struct sockaddr_in *from4 = (struct sockaddr_in*)&from; + inet_addr_to_ip4addr(ip_2_ip4(&fromaddr), &from4->sin_addr); + IP_SET_TYPE_VAL(fromaddr, IPADDR_TYPE_V4); + } +#endif /* LWIP_IPV4 */ + +#if LWIP_IPV6 + if(from.ss_family == AF_INET6) { + struct sockaddr_in6 *from6 = (struct sockaddr_in6*)&from; + inet6_addr_to_ip6addr(ip_2_ip6(&fromaddr), &from6->sin6_addr); + IP_SET_TYPE_VAL(fromaddr, IPADDR_TYPE_V6); + } +#endif /* LWIP_IPV6 */ + + LWIP_DEBUGF( PING_DEBUG, ("ping: recv ")); + ip_addr_debug_print_val(PING_DEBUG, fromaddr); + LWIP_DEBUGF( PING_DEBUG, (" %"U32_F" ms\n", (sys_now() - ping_time))); + + /* todo: support ICMP6 echo */ +#if LWIP_IPV4 + if (IP_IS_V4_VAL(fromaddr)) { + struct ip_hdr *iphdr; + struct icmp_echo_hdr *iecho; + + iphdr = (struct ip_hdr *)buf; + iecho = (struct icmp_echo_hdr *)(buf + (IPH_HL(iphdr) * 4)); + if ((iecho->id == PING_ID) && (iecho->seqno == lwip_htons(ping_seq_num))) { + /* do some ping result processing */ + PING_RESULT((ICMPH_TYPE(iecho) == ICMP_ER)); + return; + } else { + LWIP_DEBUGF( PING_DEBUG, ("ping: drop\n")); + } + } +#endif /* LWIP_IPV4 */ + } + fromlen = sizeof(from); + } + + if (len == 0) { + LWIP_DEBUGF( PING_DEBUG, ("ping: recv - %"U32_F" ms - timeout\n", (sys_now()-ping_time))); + } + + /* do some ping result processing */ + PING_RESULT(0); +} + +static void +ping_thread(void *arg) +{ + int s; + int ret; + int cnt = TEST_LWIP_TIMES; + +#if LWIP_SO_SNDRCVTIMEO_NONSTANDARD + int timeout = PING_RCV_TIMEO; +#else + struct timeval timeout; + timeout.tv_sec = PING_RCV_TIMEO/1000; + timeout.tv_usec = (PING_RCV_TIMEO%1000)*1000; +#endif + LWIP_UNUSED_ARG(arg); + + lw_print("lw: [%s] start...\n", __func__); + +#if LWIP_IPV6 + if(IP_IS_V4(ping_target) || ip6_addr_isipv4mappedipv6(ip_2_ip6(ping_target))) { + s = lwip_socket(AF_INET6, SOCK_RAW, IP_PROTO_ICMP); + } else { + s = lwip_socket(AF_INET6, SOCK_RAW, IP6_NEXTH_ICMP6); + } +#else + s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP); +#endif + if (s < 0) { + lw_print("lw: [%s] ping failed %d!\n", __func__, s); + return; + } + + lw_print("lw: [%s] ping start!\n", __func__); + + ret = lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); + LWIP_ASSERT("setting receive timeout failed", ret != 0); + LWIP_UNUSED_ARG(ret); + + while (cnt --) { + if (ping_send(s, ping_target) == ERR_OK) { + LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); + ip_addr_debug_print(PING_DEBUG, ping_target); + LWIP_DEBUGF( PING_DEBUG, ("\n")); + +#ifdef LWIP_DEBUG + ping_time = sys_now(); +#endif /* LWIP_DEBUG */ + ping_recv(s); + } else { + LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); + ip_addr_debug_print(PING_DEBUG, ping_target); + LWIP_DEBUGF( PING_DEBUG, (" - error\n")); + } + sys_msleep(PING_DELAY); + } + lwip_close(s); +} + +#else /* PING_USE_SOCKETS */ + +/* Ping using the raw ip */ +static u8_t +ping_recv(void *arg, struct raw_pcb *pcb, struct pbuf *p, const ip_addr_t *addr) +{ + struct icmp_echo_hdr *iecho; + LWIP_UNUSED_ARG(arg); + LWIP_UNUSED_ARG(pcb); + LWIP_UNUSED_ARG(addr); + LWIP_ASSERT("p != NULL", p != NULL); + + if ((p->tot_len >= (PBUF_IP_HLEN + sizeof(struct icmp_echo_hdr))) && + pbuf_remove_header(p, PBUF_IP_HLEN) == 0) { + iecho = (struct icmp_echo_hdr *)p->payload; + + if ((iecho->id == PING_ID) && (iecho->seqno == lwip_htons(ping_seq_num))) { + LWIP_DEBUGF( PING_DEBUG, ("ping: recv ")); + ip_addr_debug_print(PING_DEBUG, addr); + LWIP_DEBUGF( PING_DEBUG, (" %"U32_F" ms\n", (sys_now()-ping_time))); + + /* do some ping result processing */ + PING_RESULT(1); + pbuf_free(p); + return 1; /* eat the packet */ + } + /* not eaten, restore original packet */ + /* Changed to the "_force" version because of LPC zerocopy pbufs */ + pbuf_add_header_force(p, PBUF_IP_HLEN); + } + + return 0; /* don't eat the packet */ +} + +static void +ping_send(struct raw_pcb *raw, const ip_addr_t *addr) +{ + struct pbuf *p; + struct icmp_echo_hdr *iecho; + size_t ping_size = sizeof(struct icmp_echo_hdr) + PING_DATA_SIZE; + + LWIP_DEBUGF( PING_DEBUG, ("ping: send ")); + ip_addr_debug_print(PING_DEBUG, addr); + LWIP_DEBUGF( PING_DEBUG, ("\n")); + LWIP_ASSERT("ping_size <= 0xffff", ping_size <= 0xffff); + + p = pbuf_alloc(PBUF_IP, (u16_t)ping_size, PBUF_RAM); + if (!p) { + return; + } + if ((p->len == p->tot_len) && (p->next == NULL)) { + iecho = (struct icmp_echo_hdr *)p->payload; + + ping_prepare_echo(iecho, (u16_t)ping_size); + + raw_sendto(raw, p, addr); +#ifdef LWIP_DEBUG + ping_time = sys_now(); +#endif /* LWIP_DEBUG */ + } + pbuf_free(p); +} + +static void +ping_timeout(void *arg) +{ + static int cnt = TEST_LWIP_TIMES; + struct raw_pcb *pcb = (struct raw_pcb*)arg; + + LWIP_ASSERT("ping_timeout: no pcb given!", pcb != NULL); + + ping_send(pcb, ping_target); + + if(cnt -- > 0) + { + sys_timeout(PING_DELAY, ping_timeout, pcb); + } + else + { + cnt = TEST_LWIP_TIMES; + } +} + +static void +ping_raw_init(void) +{ + ping_pcb = raw_new(IP_PROTO_ICMP); + LWIP_ASSERT("ping_pcb != NULL", ping_pcb != NULL); + + raw_recv(ping_pcb, ping_recv, NULL); + raw_bind(ping_pcb, IP_ADDR_ANY); + sys_timeout(PING_DELAY, ping_timeout, ping_pcb); +} + +void +ping_send_now(void) +{ + LWIP_ASSERT("ping_pcb != NULL", ping_pcb != NULL); + ping_send(ping_pcb, ping_target); +} + +#endif /* PING_USE_SOCKETS */ + +void +ping_init(const ip_addr_t* ping_addr) +{ + sys_thread_t th; + + ping_target = ping_addr; + +#if PING_USE_SOCKETS + th = sys_thread_new("ping_thread", ping_thread, NULL, PING_THREAD_STACKSIZE, PING_THREAD_PRIO); + lw_print("lw: [%s] new thread %d addr %#x\n", __func__, th, (*ping_addr).addr); +#else /* PING_USE_SOCKETS */ + ping_raw_init(); +#endif /* PING_USE_SOCKETS */ +} + +int lwip_ping_send(int s, ip_addr_t *addr, int size) +{ + int err; + struct icmp_echo_hdr *iecho; + struct sockaddr_in to; + int ping_size = sizeof(struct icmp_echo_hdr) + size; + LWIP_ASSERT("ping_size is too big", ping_size <= 0xffff); + + iecho = malloc(ping_size); + if (iecho == NULL) + { + return ERR_MEM; + } + + ping_prepare_echo(iecho, (u16_t) ping_size); + + to.sin_len = sizeof(to); + to.sin_family = AF_INET; +#if LWIP_IPV4 && LWIP_IPV6 + to.sin_addr.s_addr = addr->u_addr.ip4.addr; +#elif LWIP_IPV4 + to.sin_addr.s_addr = addr->addr; +#elif LWIP_IPV6 +#error Not supported IPv6. +#endif + + err = lwip_sendto(s, iecho, ping_size, 0, (struct sockaddr*) &to, sizeof(to)); + free(iecho); + + return (err == ping_size ? ERR_OK : ERR_VAL); +} + +int lwip_ping_recv(int s, int *ttl) +{ + char buf[64]; + int fromlen = sizeof(struct sockaddr_in), len; + struct sockaddr_in from; + struct ip_hdr *iphdr; + struct icmp_echo_hdr *iecho; + + while ((len = lwip_recvfrom(s, buf, sizeof(buf), 0, (struct sockaddr*) &from, (socklen_t*) &fromlen)) > 0) + { + if (len >= (int)(sizeof(struct ip_hdr) + sizeof(struct icmp_echo_hdr))) + { + iphdr = (struct ip_hdr *) buf; + iecho = (struct icmp_echo_hdr *) (buf + (IPH_HL(iphdr) * 4)); + if ((iecho->id == PING_ID) && (iecho->seqno == htons(ping_seq_num))) + { + *ttl = iphdr->_ttl; + return len; + } + } + } + + return len; +} + +int get_url_ip(char* url) +{ +#if LWIP_VERSION_MAJOR >= 2U + struct timeval timeout = { PING_RCV_TIMEO / TICK_PER_SECOND, PING_RCV_TIMEO % TICK_PER_SECOND }; +#else + int timeout = PING_RCV_TIMEO * 1000UL / TICK_PER_SECOND; +#endif + int cnt = TEST_LWIP_TIMES; + + int s, ttl, recv_len; + ip_addr_t target_addr; + struct addrinfo hint, *res = NULL; + struct sockaddr_in *h = NULL; + struct in_addr ina; + + memset(&hint, 0, sizeof(hint)); + /* convert URL to IP */ + if (lwip_getaddrinfo(url, NULL, &hint, &res) != 0) + { + lw_pr_info("ping: unknown host %s\n", url); + return -1; + } + memcpy(&h, &res->ai_addr, sizeof(struct sockaddr_in *)); + memcpy(&ina, &h->sin_addr, sizeof(ina)); + lwip_freeaddrinfo(res); + if (inet_aton(inet_ntoa(ina), &target_addr) == 0) + { + lw_pr_info("ping: unknown host %s\n", url); + return -2; + } + /* new a socket */ + if ((s = lwip_socket(AF_INET, SOCK_RAW, IP_PROTO_ICMP)) < 0) + { + lw_pr_info("ping: create socket failed\n"); + return -3; + } + + lwip_setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)); + + while (cnt --) + { + if (ping_send(s, &target_addr) == ERR_OK) + { +#ifdef LWIP_DEBUG + ping_time = sys_now(); +#endif /* LWIP_DEBUG */ + if ((recv_len = lwip_ping_recv(s, &ttl)) >= 0) + { + lw_pr_info("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n", recv_len, inet_ntoa(ina), cnt, + ttl, sys_now() - ping_time); + } + else + { + lw_pr_info("From %s icmp_seq=%d timeout\n", inet_ntoa(ina), cnt); + } + } + + sys_msleep(PING_DELAY); + } + + lwip_close(s); + return 0; +} + + +#endif /* LWIP_RAW */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/ping.h b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/ping.h new file mode 100755 index 00000000..109bca9c --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/ping.h @@ -0,0 +1,21 @@ +#ifndef LWIP_PING_H +#define LWIP_PING_H + +#include "lwip/ip_addr.h" + +/** + * PING_USE_SOCKETS: Set to 1 to use sockets, otherwise the raw api is used + */ +#ifndef PING_USE_SOCKETS +#define PING_USE_SOCKETS LWIP_SOCKET +#endif + +void ping_init(const ip_addr_t* ping_addr); + +#if !PING_USE_SOCKETS +void ping_send_now(void); +#endif /* !PING_USE_SOCKETS */ + +int get_url_ip(char* url); + +#endif /* LWIP_PING_H */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/tcpecho_raw.c b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/tcpecho_raw.c new file mode 100755 index 00000000..887e8bcd --- /dev/null +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/tcpecho_raw.c @@ -0,0 +1,330 @@ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of and a contribution to the lwIP TCP/IP stack. + * + * Credits go to Adam Dunkels (and the current maintainers) of this software. + * + * Christiaan Simons rewrote this file to get a more stable echo example. + */ + +/** + * @file + * TCP echo server example using raw API. + * + * Echos all bytes sent by connecting client, + * and passively closes when client is done. + * + */ + +#include "lwip/opt.h" +#include "lwip/debug.h" +#include "lwip/stats.h" +#include "lwip/tcp.h" +#include "tcpecho_raw.h" +#include + +#if LWIP_TCP && LWIP_CALLBACK_API + +#define MAX_TESTED_TCP_SEND_SIZE (56000) + +static struct tcp_pcb *tcpecho_raw_pcb; + +enum tcpecho_raw_states +{ + ES_NONE = 0, + ES_ACCEPTED, + ES_RECEIVED, + ES_CLOSING +}; + +struct tcpecho_raw_state +{ + u8_t state; + u8_t retries; + struct tcp_pcb *pcb; + /* pbuf (chain) to recycle */ + struct pbuf *p; +}; + +static void +tcpecho_raw_free(struct tcpecho_raw_state *es) +{ + if (es != NULL) { + if (es->p) { + /* free the buffer chain if present */ + pbuf_free(es->p); + } + + mem_free(es); + } +} + +static void +tcpecho_raw_close(struct tcp_pcb *tpcb, struct tcpecho_raw_state *es) +{ + tcp_arg(tpcb, NULL); + tcp_sent(tpcb, NULL); + tcp_recv(tpcb, NULL); + tcp_err(tpcb, NULL); + tcp_poll(tpcb, NULL, 0); + + tcpecho_raw_free(es); + + tcp_close(tpcb); +} + +static void +tcpecho_raw_error(void *arg, err_t err) +{ + struct tcpecho_raw_state *es; + + LWIP_UNUSED_ARG(err); + + es = (struct tcpecho_raw_state *)arg; + + tcpecho_raw_free(es); +} + +#define SHELL_TCP_LENGTH 80 +char* recved_msg; +int recved_msg_length; +// compute received message length until '\n' +static void record_msg(struct tcp_pcb *tpcb, struct tcpecho_raw_state* es){ + struct pbuf* ptr = es->p; + int plen = ptr->len; + if(es==NULL||ptr==NULL||plen==0){ + if(recved_msg){ + free(recved_msg); + recved_msg = NULL; + } + recved_msg_length = 0; + } + int new_size = plen+1; + char* temp = recved_msg; + if(temp!=NULL){ + new_size += strlen(temp); + } + recved_msg = malloc(new_size); + memset(recved_msg, 0, new_size); + if(temp!=NULL){ + memcpy(recved_msg,temp,strlen(temp)); + } + memcpy(recved_msg+new_size-plen-1, ptr->payload, plen); + free(temp); + recved_msg_length += plen; + if(recved_msg_length>=SHELL_TCP_LENGTH){ + if(recved_msg){ + free(recved_msg); + recved_msg = NULL; + } + } + if(((char*)ptr->payload)[plen-1]=='\n'){ + if(recved_msg_length>MAX_TESTED_TCP_SEND_SIZE){ + KPrintf("Recved_msg_length is larger than %d, which may lead to unexpected exceptions.\n",MAX_TESTED_TCP_SEND_SIZE); + } + if(recved_msg_lengthpayload,"%d\n\0",recved_msg_length); + reply_pbuf->len = strlen(reply_pbuf->payload); + reply_pbuf->tot_len = strlen(reply_pbuf->payload); + reply_pbuf->next = NULL; + + tcp_write(tpcb, reply_pbuf->payload, reply_pbuf->len, 1); + + pbuf_free(reply_pbuf); + free(recved_msg); + recved_msg = NULL; + recved_msg_length = 0; + } + es->p = ptr->next; + if(es->p != NULL) { + /* new reference! */ + pbuf_ref(es->p); + } + pbuf_free(ptr); + tcp_recved(tpcb, plen); +} + +static err_t +tcpecho_raw_poll(void *arg, struct tcp_pcb *tpcb) +{ + err_t ret_err; + struct tcpecho_raw_state *es; + + es = (struct tcpecho_raw_state *)arg; + if (es != NULL) { + if (es->p != NULL) { + /* there is a remaining pbuf (chain) */ + record_msg(tpcb, es); + } else { + /* no remaining pbuf (chain) */ + if(es->state == ES_CLOSING) { + tcpecho_raw_close(tpcb, es); + } + } + ret_err = ERR_OK; + } else { + /* nothing to be done */ + tcp_abort(tpcb); + ret_err = ERR_ABRT; + } + return ret_err; +} + +static err_t +tcpecho_raw_sent(void *arg, struct tcp_pcb *tpcb, u16_t len) +{ + struct tcpecho_raw_state *es; + + LWIP_UNUSED_ARG(len); + + es = (struct tcpecho_raw_state *)arg; + es->retries = 0; + es->p = NULL; + // the sent reply from server never have successors + if(es->state == ES_CLOSING) { + tcpecho_raw_close(tpcb, es); + } + return ERR_OK; +} + +static err_t +tcpecho_raw_recv(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err) +{ + struct tcpecho_raw_state *es; + err_t ret_err; + + LWIP_ASSERT("arg != NULL",arg != NULL); + es = (struct tcpecho_raw_state *)arg; + if (p == NULL) { + /* remote host closed connection */ + es->state = ES_CLOSING; + if(es->p == NULL) { + /* we're done sending, close it */ + tcpecho_raw_close(tpcb, es); + } else { + /* we're not done yet */ + record_msg(tpcb, es); + } + ret_err = ERR_OK; + } else if(err != ERR_OK) { + /* cleanup, for unknown reason */ + if (p != NULL) { + pbuf_free(p); + } + ret_err = err; + } + else if(es->state == ES_ACCEPTED) { + /* first data chunk in p->payload */ + es->state = ES_RECEIVED; + /* store reference to incoming pbuf (chain) */ + es->p = p; + record_msg(tpcb, es); + ret_err = ERR_OK; + } else if (es->state == ES_RECEIVED) { + /* read some more data */ + if(es->p == NULL) { + es->p = p; + record_msg(tpcb, es); + } else { + struct pbuf *ptr; + + /* chain pbufs to the end of what we recv'ed previously */ + ptr = es->p; + pbuf_cat(ptr,p); + } + ret_err = ERR_OK; + } else { + /* unkown es->state, trash data */ + tcp_recved(tpcb, p->tot_len); + pbuf_free(p); + ret_err = ERR_OK; + } + return ret_err; +} + +static err_t +tcpecho_raw_accept(void *arg, struct tcp_pcb *newpcb, err_t err) +{ + err_t ret_err; + struct tcpecho_raw_state *es; + recved_msg = NULL; + recved_msg_length = 0; + + LWIP_UNUSED_ARG(arg); + if ((err != ERR_OK) || (newpcb == NULL)) { + return ERR_VAL; + } + + /* Unless this pcb should have NORMAL priority, set its priority now. + When running out of pcbs, low priority pcbs can be aborted to create + new pcbs of higher priority. */ + tcp_setprio(newpcb, TCP_PRIO_MIN); + + es = (struct tcpecho_raw_state *)mem_malloc(sizeof(struct tcpecho_raw_state)); + if (es != NULL) { + es->state = ES_ACCEPTED; + es->pcb = newpcb; + es->retries = 0; + es->p = NULL; + /* pass newly allocated es to our callbacks */ + tcp_arg(newpcb, es); + tcp_recv(newpcb, tcpecho_raw_recv); + tcp_err(newpcb, tcpecho_raw_error); + tcp_poll(newpcb, tcpecho_raw_poll, 0); + tcp_sent(newpcb, tcpecho_raw_sent); + ret_err = ERR_OK; + } else { + ret_err = ERR_MEM; + } + return ret_err; +} + +void +tcpecho_raw_init(void) +{ + tcpecho_raw_pcb = tcp_new_ip_type(IPADDR_TYPE_ANY); + if (tcpecho_raw_pcb != NULL) { + err_t err; + err = tcp_bind(tcpecho_raw_pcb, IP_ANY_TYPE, LWIP_TEST_TCP_PORT); + if (err == ERR_OK) { + tcpecho_raw_pcb = tcp_listen(tcpecho_raw_pcb); + tcp_accept(tcpecho_raw_pcb, tcpecho_raw_accept); + } else { + /* abort? output diagnostic? */ + } + } else { + /* abort? output diagnostic? */ + } +} + +#endif /* LWIP_TCP && LWIP_CALLBACK_API */ diff --git a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/udp_echo.h b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/tcpecho_raw.h old mode 100644 new mode 100755 similarity index 73% rename from Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/udp_echo.h rename to Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/tcpecho_raw.h index ddf419e0..4b6aca75 --- a/Ubiquitous/XiUOS/resources/ethernet/LwIP/arch/udp_echo.h +++ b/Ubiquitous/XiUOS/resources/ethernet/cmd_lwip/tcpecho_raw.h @@ -1,40 +1,37 @@ -/* - * Copyright (c) 2001-2003 Swedish Institute of Computer Science. - * 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. The name of the author may not be used to endorse or promote products - * derived from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. - * - * This file is part of the lwIP TCP/IP stack. - * - * Author: Adam Dunkels - * - */ - - -#ifndef LWIP_TCPECHO_H -#define LWIP_TCPECHO_H - -void UdpEchoInit(void); - - -#endif /* LWIP_TCPECHO_H */ +/* + * Copyright (c) 2001-2004 Swedish Institute of Computer Science. + * 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. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. + * + * This file is part of the lwIP TCP/IP stack. + * + */ +#ifndef LWIP_TCPECHO_RAW_H +#define LWIP_TCPECHO_RAW_H + +#define LWIP_TEST_TCP_PORT 4840 + +void tcpecho_raw_init(void); + +#endif /* LWIP_TCPECHO_RAW_H */